{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-16T01:33:40.641864Z",
     "start_time": "2025-07-16T01:33:35.023421Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/miniconda3/envs/prob/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n",
    "\n",
    "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
    "import torch, numpy as np\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from scipy.stats import pearsonr, entropy\n",
    "from sklearn.metrics.pairwise import rbf_kernel\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2,3,4,5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-16T01:33:49.879531Z",
     "start_time": "2025-07-16T01:33:40.667686Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`torch_dtype` is deprecated! Use `dtype` instead!\n",
      "The following generation flags are not valid and may be ignored: ['output_attentions', 'output_hidden_states']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n",
      "Loading checkpoint shards: 100%|██████████| 4/4 [00:03<00:00,  1.03it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "LlamaForCausalLM(\n",
       "  (model): LlamaModel(\n",
       "    (embed_tokens): Embedding(128256, 4096)\n",
       "    (layers): ModuleList(\n",
       "      (0-31): 32 x LlamaDecoderLayer(\n",
       "        (self_attn): LlamaAttention(\n",
       "          (q_proj): Linear(in_features=4096, out_features=4096, bias=False)\n",
       "          (k_proj): Linear(in_features=4096, out_features=1024, bias=False)\n",
       "          (v_proj): Linear(in_features=4096, out_features=1024, bias=False)\n",
       "          (o_proj): Linear(in_features=4096, out_features=4096, bias=False)\n",
       "        )\n",
       "        (mlp): LlamaMLP(\n",
       "          (gate_proj): Linear(in_features=4096, out_features=14336, bias=False)\n",
       "          (up_proj): Linear(in_features=4096, out_features=14336, bias=False)\n",
       "          (down_proj): Linear(in_features=14336, out_features=4096, bias=False)\n",
       "          (act_fn): SiLU()\n",
       "        )\n",
       "        (input_layernorm): LlamaRMSNorm((4096,), eps=1e-05)\n",
       "        (post_attention_layernorm): LlamaRMSNorm((4096,), eps=1e-05)\n",
       "      )\n",
       "    )\n",
       "    (norm): LlamaRMSNorm((4096,), eps=1e-05)\n",
       "    (rotary_emb): LlamaRotaryEmbedding()\n",
       "  )\n",
       "  (lm_head): Linear(in_features=4096, out_features=128256, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load model\n",
    "\n",
    "torch.mps.empty_cache() if torch.backends.mps.is_available() else None\n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda\")\n",
    "elif torch.backends.mps.is_available():\n",
    "    device = torch.device(\"mps\")\n",
    "else:\n",
    "    device = torch.device(\"cpu\")\n",
    "\n",
    "# model_name = \"Qwen/Qwen3-1.7B\"\n",
    "model_name = \"meta-llama/Llama-3.1-8B-Instruct\"\n",
    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
    "if tokenizer.pad_token is None:\n",
    "        tokenizer.pad_token = tokenizer.eos_token\n",
    "model = AutoModelForCausalLM.from_pretrained(\n",
    "    model_name,\n",
    "    output_hidden_states=True,\n",
    "    output_attentions=True,\n",
    "    torch_dtype=torch.float16,\n",
    "    device_map=\"auto\",\n",
    "    attn_implementation=\"eager\",  # Set this during model initialization\n",
    ")\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-21T03:03:03.367458Z",
     "start_time": "2025-07-21T03:03:03.322758Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "130\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Counter({5: 26, 4: 26, 3: 26, 2: 26, 1: 26})"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load dataset\n",
    "\n",
    "import json\n",
    "\n",
    "class Sample:\n",
    "    def __init__(self, prompt, label):\n",
    "        self.prompt = prompt\n",
    "#         self.response = response\n",
    "        self.label = label  # 1=high, 0=low\n",
    "\n",
    "dataset = []\n",
    "# Load the pre-processed good/bad samples from your new file\n",
    "with open('Meta-Llama-3-8B-Instruct_gpqa_roscoe5dim_probing.json', 'r') as f:\n",
    "    all_data = json.load(f)\n",
    "#     for dim in ['semantic_consistency', 'logicality', 'informativeness', 'fluency', 'factuality']:\n",
    "    for sample in all_data['fluency']:   # You can change the dimension here, from 5 dimensions above\n",
    "        dataset.append(Sample(prompt=sample['eval_prompt'], label=sample['score']))\n",
    "\n",
    "print(len(dataset))\n",
    "labels = np.array([ex.label for ex in dataset])\n",
    "\n",
    "from collections import Counter\n",
    "Counter([sample.label for sample in dataset])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### extract features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-21T03:03:46.101511Z",
     "start_time": "2025-07-21T03:03:46.089639Z"
    }
   },
   "outputs": [],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "def extract_batch_reps(batch: list[Sample]):\n",
    "    \"\"\"Returns dict of arrays: reps[layer]['mean'|'last'|'min'|'max'|'concat'], attn_entropy[layer][head]\"\"\"\n",
    "    inputs = tokenizer(\n",
    "        [ex.prompt for ex in batch],\n",
    "        return_tensors=\"pt\",\n",
    "        padding=True,\n",
    "        truncation=True,\n",
    "    ).to(model.device)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        out = model(\n",
    "            **inputs,\n",
    "            output_hidden_states=True,\n",
    "            output_attentions=True,\n",
    "        )\n",
    "\n",
    "    hidden = out.hidden_states             # tuple of (B, S, H) per layer\n",
    "    attentions = out.attentions            # tuple of (B, heads, S, S) per layer\n",
    "\n",
    "    reps = {}\n",
    "    attn_entropy = {}\n",
    "    \n",
    "    # ignore the first embedding layer in hidden layers\n",
    "    for layer_idx, h in enumerate(hidden[1:]):\n",
    "        # 1) mean-pooled\n",
    "        mean_pooled = h.mean(dim=1).cpu().detach().numpy()       # (B, H)\n",
    "        \n",
    "        # 2) last-token (EOS) pooled\n",
    "        seq_lens = (inputs.attention_mask.sum(dim=1) - 1).cpu()\n",
    "        last_tokens = torch.stack([\n",
    "            h[i, seq_lens[i], :]\n",
    "            for i in range(h.size(0))\n",
    "        ]).cpu().detach().numpy()                                # (B, H)\n",
    "        \n",
    "        # 3) min-pooled\n",
    "        min_pooled = h.min(dim=1)[0].cpu().detach().numpy()     # (B, H)\n",
    "        \n",
    "        # 4) max-pooled\n",
    "        max_pooled = h.max(dim=1)[0].cpu().detach().numpy()     # (B, H)\n",
    "        \n",
    "        # 5) concatenation of min, max, mean\n",
    "        concat_pooled = np.concatenate([min_pooled, max_pooled, mean_pooled], axis=1)  # (B, 3*H)\n",
    "        \n",
    "        reps[layer_idx] = {\n",
    "            \"mean\": mean_pooled, \n",
    "            \"last\": last_tokens,\n",
    "            \"min\": min_pooled,\n",
    "            \"max\": max_pooled,\n",
    "            \"concat\": concat_pooled\n",
    "        }\n",
    "        \n",
    "        # Attention head entropy per example\n",
    "        # average entropy across source tokens for each head\n",
    "        A = attentions[layer_idx]      # (B, heads, S, S)\n",
    "        # compute entropy over S distribution for each head and each example, then mean\n",
    "        # Only compute entropy for non-zero attention weights\n",
    "        mask = A > 0\n",
    "        log_A = torch.where(mask, torch.log(A), torch.zeros_like(A))\n",
    "        ent = - (A * log_A).sum(dim=-1).mean(dim=-1)\n",
    "        # ent = - (A * torch.log(A + 1e-12)).sum(dim=-1).mean(dim=-1)  # (B, heads)\n",
    "        attn_entropy[layer_idx] = ent.cpu().detach().numpy()   # (B, heads)\n",
    "    \n",
    "    return reps, attn_entropy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-21T03:12:28.485074Z",
     "start_time": "2025-07-21T03:05:01.680242Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 130/130 [00:33<00:00,  3.87it/s]\n"
     ]
    }
   ],
   "source": [
    "# Run in batches, cache to disk or memory to avoid recompute\n",
    "all_reps, all_attn = {}, {}\n",
    "batch_size = 1\n",
    "for i in tqdm(range(0, len(dataset), batch_size)):\n",
    "    batch = dataset[i : i + batch_size]\n",
    "    reps, ent = extract_batch_reps(batch)\n",
    "    for l in reps:\n",
    "        if l not in all_reps: \n",
    "            all_reps[l] = {\"mean\": [], \"last\": [], \"min\": [], \"max\": [], \"concat\": []}\n",
    "        for pool_method in [\"mean\", \"last\", \"min\", \"max\", \"concat\"]:\n",
    "            all_reps[l][pool_method].append(reps[l][pool_method])\n",
    "        all_attn.setdefault(l, []).append(ent[l])\n",
    "\n",
    "# Stack per layer/pool\n",
    "for l in all_reps:\n",
    "    all_reps[l][\"mean\"] = np.vstack(all_reps[l][\"mean\"])\n",
    "    all_reps[l][\"last\"] = np.vstack(all_reps[l][\"last\"])\n",
    "    all_reps[l][\"min\"] = np.vstack(all_reps[l][\"min\"])\n",
    "    all_reps[l][\"max\"] = np.vstack(all_reps[l][\"max\"])\n",
    "    all_reps[l][\"concat\"] = np.vstack(all_reps[l][\"concat\"])  # (N, 3*H)\n",
    "    all_attn[l] = np.vstack(all_attn[l])  # shape (N, heads)\n",
    "\n",
    "labels = np.array([ex.label for ex in dataset])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### save all_reps and all_attn first, then load them (optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-16T01:34:32.747081Z",
     "start_time": "2025-07-16T01:34:32.676773Z"
    }
   },
   "outputs": [],
   "source": [
    "# Save all_reps\n",
    "np.savez('gpqa_prob_reps.npz', **{f\"{l}_{k}\": v for l, d in all_reps.items() for k, v in d.items()})\n",
    "\n",
    "# Save all_attn\n",
    "np.savez('gpqa_prob_attn.npz', **{f\"{l}_attn\": v for l, v in all_attn.items()})\n",
    "\n",
    "# Load all_reps\n",
    "loaded_reps = np.load('gpqa_prob_reps.npz')\n",
    "all_reps = {}\n",
    "for key in loaded_reps:\n",
    "    l, kind = key.split('_')\n",
    "    l = int(l)\n",
    "    if l not in all_reps:\n",
    "        all_reps[l] = {}\n",
    "    all_reps[l][kind] = loaded_reps[key]\n",
    "\n",
    "# Load all_attn\n",
    "loaded_attn = np.load('gpqa_prob_attn.npz')\n",
    "all_attn = {int(k.split('_')[0]): loaded_attn[k] for k in loaded_attn}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### layer probing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-18T06:29:48.935067Z",
     "start_time": "2025-07-18T06:21:58.892944Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing 32 layers...\n",
      "Layer 0...\n",
      "Layer 1...\n",
      "Layer 2...\n",
      "Layer 3...\n",
      "Layer 4...\n",
      "Layer 5...\n",
      "Layer 6...\n",
      "Layer 7...\n",
      "Layer 8...\n",
      "Layer 9...\n",
      "Layer 10...\n",
      "Layer 11...\n",
      "Layer 12...\n",
      "Layer 13...\n",
      "Layer 14...\n",
      "Layer 15...\n",
      "Layer 16...\n",
      "Layer 17...\n",
      "Layer 18...\n",
      "Layer 19...\n",
      "Layer 20...\n",
      "Layer 21...\n",
      "Layer 22...\n",
      "Layer 23...\n",
      "Layer 24...\n",
      "Layer 25...\n",
      "Layer 26...\n",
      "Layer 27...\n",
      "Layer 28...\n",
      "Layer 29...\n",
      "Layer 30...\n",
      "Layer 31...\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABdIAAAPeCAYAAAAI5OjmAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XdYU9cbB/BvEsKWoWxFQJy4UBTqHkVxj6p1rzqqrR3SZZerrba1Vatt9Veto+46q7UOXHWLuypuURxsFGSP3N8fMZFAEgIkJMD38zw8kJuTc997z73h5uTc94gEQRBARERERERERERERERqiY0dABERERERERERERGRKWNHOhERERERERERERGRFuxIJyIiIiIiIiIiIiLSgh3pRERERERERERERERasCOdiIiIiIiIiIiIiEgLdqQTEREREREREREREWnBjnQiIiIiIiIiIiIiIi3YkU5EREREREREREREpAU70omIiIiIiIiIiIiItGBHOlElJRKJMHPmTGOHYXBHjhyBSCTCkSNHjBaDun199uxZtG7dGjY2NhCJRLh06RJmzpwJkUhU5vHdv38fIpEIq1atKvN1U+mNGTMGtra2xg6DiIiIdFCc671Vq1ZBJBLh/v37ell3x44d0bFjR73UZSzG3gZ17Zebm4uPP/4Ynp6eEIvF6NevHwDjfd4aM2YMvL29y3y9VHqKz2U//PCDsUMhIg3YkU5UQSgutPP/uLi4oFOnTtizZ4+xwzOI7du3o3v37nBycoK5uTk8PDzw+uuv49ChQ8YOTaucnBwMGjQISUlJWLBgAdasWQMvLy+Dr3f9+vVYuHChwddTUq+//jpEIhE++eQTY4dCanh7e6NXr17GDoOIiMhg8l9PHz9+vNDzgiDA09MTIpFIr/8T58yZgx07duitvvIoNjYWH374IerXrw9ra2vY2NggICAAX3/9NZ49e2bs8LRasWIF5s2bh4EDB2L16tWYOnWqwdf55MkTzJw5E5cuXTL4ukri+vXrEIlEsLS0NPn2q4wU73Xnzp0zdihE5Y6ZsQMgIv2aPXs2fHx8IAgCYmNjsWrVKvTo0QO7du1SueDPyMiAmVn5fAsQBAFvvPEGVq1ahWbNmiE0NBRubm6Ijo7G9u3b8eqrr+LEiRNo3bq1sUMFUHhf3717Fw8ePMCyZcswfvx45fIvvvgC06ZNM1gc69evx9WrV/H++++rLPfy8kJGRgakUqnB1l2UlJQU7Nq1C97e3tiwYQO+/fZbo4zOJyIiIrK0tMT69evRtm1bleX//vsvHj16BAsLC72ub86cORg4cKByJLPCyJEjMWTIEL2vz9ScPXsWPXr0QGpqKkaMGIGAgAAAwLlz5/Dtt9/i6NGj2L9/v5GjlFN3vX7o0CFUr14dCxYsUFluyM9bT548waxZs+Dt7Q1/f3+V55YtWwaZTGaQ9epq7dq1cHNzw9OnT7FlyxaVzzxEROVZ+exFIyKNunfvjhYtWigfjxs3Dq6urtiwYYNKR7qlpWWZxyYIAjIzM2FlZVWqen788UesWrUK77//PubPn6/S4fr5559jzZo1JvUlQcF9HRcXBwBwcHBQWW5mZmaUuBWjRYxp69atyMvLw4oVK9C5c2ccPXoUHTp0MGpM6ujrGCbDS0tLg42NjbHDICKicqhHjx7YvHkzFi1apHJttn79egQEBCAhIaFM4pBIJJBIJGWyLmN59uwZ+vfvD4lEgosXL6J+/foqz3/zzTdYtmyZkaIrTN31elxcXKHresA4n7cAGHVwDCC/Xl6/fj2GDRuGyMhIrFu3zmQ70nm9WD7IZDJkZ2cb/TMrEcDULkQVnoODA6ysrApd8BXM2afI93fnzh2MGTMGDg4OsLe3x9ixY5Genq7y2pUrV6Jz585wcXGBhYUF/Pz8sGTJkkLrVqSC2LdvH1q0aAErKyv873//Q4cOHdC0aVO18darVw8hISEatycjIwNz585F/fr18cMPP6gdtTxy5EgEBgZqrOPYsWMYNGgQatasCQsLC3h6emLq1KnIyMhQKRcTE4OxY8eiRo0asLCwgLu7O/r27auSp/LcuXMICQmBk5MTrKys4OPjgzfeeEOlnvz7esyYMcoO4kGDBkEkEinzPGrKmbl27VoEBgbC2toajo6OaN++vcqonL/++gs9e/aEh4cHLCws4Ovri6+++gp5eXnKMh07dsTu3bvx4MED5S3LityJmnKkHzp0CO3atYONjQ0cHBzQt29fXL9+XaVMcY4bbdatW4cuXbqgU6dOaNCgAdatW6e23I0bN/D666/D2dkZVlZWqFevHj7//HOVMo8fP8a4ceOU+8PHxweTJ09Gdna21v2sLg+ppmMY0P08AIA9e/agQ4cOqFKlCuzs7NCyZUusX78eADBjxgxIpVLEx8cXet3EiRPh4OCAzMzMIvfhvXv3EBISAhsbG3h4eGD27NkQBAGA/AONt7c3+vbtW+h1mZmZsLe3x5tvvlnkOoqiy7m1cuVKiEQiXLx4sdDr58yZA4lEgsePHyuXnTlzBt26dYO9vT2sra3RoUMHnDhxQuV1ijaNiIjAsGHD4OjoWGgUIRERka6GDh2KxMREhIWFKZdlZ2djy5YtGDZsWKHymubk0WUeGpFIhLS0NKxevVp5jTZmzBgAxc+RXtQ1Y0HZ2dmYPn06AgICYG9vDxsbG7Rr1w6HDx8uVHbjxo0ICAhQXss0btwYP/30k/L5nJwczJo1C3Xq1IGlpSWqVauGtm3bquxDdf73v//h8ePHmD9/fqFOdABwdXXFF198YTLbkP86UtG+hw8fxrVr15TtpzgO1OVIL+o6NSkpCR9++CEaN24MW1tb2NnZoXv37rh8+bKyjiNHjqBly5YAgLFjxyrXqzjO1OVIT0tLwwcffABPT09YWFigXr16+OGHH5TXigoikQhTpkzBjh070KhRI1hYWKBhw4bYu3evxjYo6MSJE7h//z6GDBmCIUOG4OjRo3j06FGhcjKZDD/99BMaN24MS0tLODs7o1u3boXSjRR1XGvKRe/t7a08l4CX59O///6Lt956Cy4uLqhRowYA4MGDB3jrrbdQr149WFlZoVq1ahg0aJDac+/Zs2eYOnUqvL29YWFhgRo1amDUqFFISEhAamoqbGxs8N577xV63aNHjyCRSDB37lyd9uOCBQvg5eUFKysrdOjQAVevXlU+V9zr6ZLQ5dwq7meMrKwszJgxA7Vr11Z+Vvj444+RlZWl8lrFcbhu3To0bNgQFhYWxToGiQzJdIZsEpFeJCcnIyEhAYIgIC4uDosXL1beJqmL119/HT4+Ppg7dy4uXLiA5cuXw8XFBd99952yzJIlS9CwYUP06dMHZmZm2LVrF9566y3IZDK8/fbbKvXdvHkTQ4cOxZtvvokJEyagXr16sLW1xYQJE3D16lU0atRIWfbs2bO4deuW1ovl48ePIykpCe+//36JR+hs3rwZ6enpmDx5MqpVq4bw8HAsXrwYjx49wubNm5XlBgwYgGvXruGdd96Bt7c34uLiEBYWhqioKOXjrl27wtnZGdOmTYODgwPu37+Pbdu2aVz3m2++ierVq2POnDl499130bJlS7i6umosP2vWLMycOROtW7fG7NmzYW5ujjNnzuDQoUPo2rUrAPlFoa2tLUJDQ2Fra4tDhw5h+vTpSElJwbx58wDIR+onJyfj0aNHyttOtU1QeeDAAXTv3h21atXCzJkzkZGRgcWLF6NNmza4cOFCoYtzXY4bTZ48eYLDhw9j9erVAOQfXhcsWICff/4Z5ubmynL//fcf2rVrB6lUiokTJ8Lb2xt3797Frl278M033yjrCgwMxLNnzzBx4kTUr18fjx8/xpYtW5Cenq5Sn67UHcOA7ufBqlWr8MYbb6Bhw4b49NNP4eDggIsXL2Lv3r0YNmwYRo4cidmzZ2PTpk2YMmWK8nWKD+wDBgwocvRFXl4eunXrhldeeQXff/899u7dixkzZiA3NxezZ8+GSCTCiBEj8P333yMpKQlVq1ZVvnbXrl1ISUnR+T1CG13OrYEDB+Ltt9/GunXr0KxZM5XXr1u3Dh07dkT16tUByL/M6d69OwICAjBjxgyIxWLlFxjHjh0r9IXZoEGDUKdOHcyZM6fQB0MiIiJdeXt7o1WrVtiwYQO6d+8OQP6leHJyMoYMGYJFixbpbV1r1qzB+PHjERgYiIkTJwIAfH19i12PLteMBaWkpGD58uUYOnQoJkyYgOfPn+P3339HSEgIwsPDlSlDwsLCMHToULz66qvKa7vr16/jxIkTyg7DmTNnYu7cucptSUlJwblz53DhwgV06dJFY9w7d+6ElZUVBg4cWOxtNvY2ODs7Y82aNfjmm2+Qmpqq7CBt0KCB2lh1uU69d+8eduzYgUGDBsHHxwexsbHKgUgRERHw8PBAgwYNMHv2bEyfPh0TJ05Eu3btAEBjWktBENCnTx8cPnwY48aNg7+/P/bt24ePPvoIjx8/LpSS5vjx49i2bRveeustVKlSBYsWLcKAAQMQFRWFatWqFdkm69atg6+vL1q2bIlGjRrB2toaGzZswEcffaRSbty4cVi1ahW6d++O8ePHIzc3F8eOHcPp06eVd1iX5LguyltvvQVnZ2dMnz4daWlpAOSfQ0+ePIkhQ4agRo0auH//PpYsWYKOHTsiIiIC1tbWAIDU1FS0a9cO169fxxtvvIHmzZsjISEBO3fuxKNHj+Dv74/+/ftj06ZNmD9/vsrn1Q0bNkAQBAwfPrzIGP/44w88f/4cb7/9NjIzM/HTTz+hc+fOuHLlClxdXYt1PV1SupxbxfmMIZPJ0KdPHxw/fhwTJ05EgwYNcOXKFSxYsAC3bt0qNE/EoUOH8Oeff2LKlClwcnLiBLpkOgQiqhBWrlwpACj0Y2FhIaxatapQeQDCjBkzlI9nzJghABDeeOMNlXL9+/cXqlWrprIsPT29UH0hISFCrVq1VJZ5eXkJAIS9e/eqLH/27JlgaWkpfPLJJyrL3333XcHGxkZITU3VuJ0//fSTAEDYvn27xjL5HT58WAAgHD58WGv8c+fOFUQikfDgwQNBEATh6dOnAgBh3rx5Guvevn27AEA4e/as1hgK7mtFTJs3b1Ypp2gDhdu3bwtisVjo37+/kJeXp1JWJpNp3Z4333xTsLa2FjIzM5XLevbsKXh5eRUqGxkZKQAQVq5cqVzm7+8vuLi4CImJicplly9fFsRisTBq1KhCMety3Gjyww8/CFZWVkJKSoogCIJw69YttW3cvn17oUqVKso2Usi/L0aNGiWIxWK1baIoV3A/KyjOocjISOUyTcewIOh2Hjx79kyoUqWKEBQUJGRkZGiMu1WrVkJQUJDK89u2bSt07KozevRoAYDwzjvvqNTds2dPwdzcXIiPjxcEQRBu3rwpABCWLFmi8vo+ffoI3t7eKvGo4+XlJfTs2VNrGV3OLUEQhKFDhwoeHh4qx/WFCxdUjkOZTCbUqVNHCAkJKXS8+/j4CF26dFEuU7Tp0KFDtcZHRESkjeJa4OzZs8LPP/8sVKlSRfm/bdCgQUKnTp0EQSj8P1Hd9aYgqL/GUncdYmNjI4wePVpjPPmvTdTR9ZqxQ4cOQocOHZSPc3NzhaysLJXyT58+FVxdXVWu7d577z3Bzs5OyM3N1RhD06ZNi7xOUMfR0VFo2rSpzuWNvQ3q2q9Dhw5Cw4YNC5Ut+BlAl+vUzMzMQm0YGRkpWFhYCLNnz1YuO3v2bKFjS2H06NEq1/w7duwQAAhff/21SrmBAwcKIpFIuHPnjkrM5ubmKssuX74sABAWL15caF0FZWdnC9WqVRM+//xz5bJhw4YVauNDhw4JAIR33323UB2KfaHrcV1wPyt4eXmpnFeK86lt27aFjgN117CnTp0SAAh//PGHctn06dMFAMK2bds0xr1v3z4BgLBnzx6V55s0aaJy7KqjeM+wsrISHj16pFx+5swZAYAwdepU5TJdrqc1yf9ep4mu55aunzHWrFkjiMVi4dixYyrlli5dKgAQTpw4oVwGQBCLxcK1a9e0bgeRMTC1C1EF88svvyAsLAxhYWFYu3YtOnXqhPHjx2sdJZ3fpEmTVB63a9cOiYmJSElJUS7Lnx9aMQK+Q4cOuHfvHpKTk1Ve7+PjUyhVi729Pfr27av8Vh6Qj6jdtGkT+vXrpzVPnSKOKlWq6LQ96uSPPy0tDQkJCWjdujUEQVDeHmdlZQVzc3McOXIET58+VVuPIhfi33//jZycnBLHo8mOHTsgk8kwffp0iMWqb9f5U5Pk357nz58jISEB7dq1Q3p6Om7cuFHs9UZHR+PSpUsYM2aMyqiCJk2aoEuXLvjnn38KvUaX40aTdevWoWfPnso2rVOnDgICAlTSu8THx+Po0aN44403ULNmTZXXK/aFTCbDjh070Lt3b5V5AgqWKy51xzCg23kQFhaG58+fY9q0aYVGleePZ9SoUThz5gzu3r2rXLZu3Tp4enrqnCs+/2h2xe2Q2dnZOHDgAACgbt26CAoKUtmvSUlJ2LNnD4YPH66XyV11ObcA+fYq7kRQWLduHaysrDBgwAAAwKVLl3D79m0MGzYMiYmJSEhIQEJCAtLS0vDqq6/i6NGjhSbSKngcEhERldTrr7+OjIwM/P3333j+/Dn+/vtvtWldTIGu14wFSSQS5d16MpkMSUlJyM3NRYsWLXDhwgVlOQcHB6SlpWlN0+Lg4IBr167h9u3bxYo9JSWlVNf1prANutD1OtXCwkLZhnl5eUhMTIStrS3q1aunsj3F8c8//0AikeDdd99VWf7BBx9AEATs2bNHZXlwcLDKXRFNmjSBnZ0d7t27V+S69uzZg8TERAwdOlS5bOjQobh8+TKuXbumXLZ161aIRCLMmDGjUB2KfVHS47ooEyZMKHRnc/5r2JycHCQmJqJ27dpwcHBQ2e9bt25F06ZN0b9/f41xBwcHw8PDQ+Wa++rVq/jvv/90vgO0X79+KiPKAwMDERQUpPI5TJfr6dLQ9dzS9TPG5s2b0aBBA9SvX195XZ+QkIDOnTsDQKF0TB06dICfn1+pt4NI39iRTlTBBAYGIjg4GMHBwRg+fDh2794NPz8/ZadaUQp2Ujo6OgKASmfyiRMnEBwcrMyd7ezsjM8++wwA1HakqzNq1ChERUXh2LFjAOSpRGJjYzFy5Eit8dnZ2QGQdxiXVFRUlLKT2NbWFs7OzsrOSkX8FhYW+O6777Bnzx64urqiffv2+P777xETE6Osp0OHDhgwYABmzZoFJycn9O3bFytXriyU462k7t69C7FYXOQFxLVr19C/f3/Y29vDzs4Ozs7Oyou0gu2hiwcPHgCAMoVJfg0aNFB2Zuany3GjzvXr13Hx4kW0adMGd+7cUf507NgRf//9t7IjXnHhnj8VUEHx8fFISUnRWqYkNB3DupwHio7xomIaPHgwLCwslBegycnJ+Pvvv3Xu4BaLxahVq5bKsrp16wKASm7HUaNG4cSJE8o23rx5M3Jycoo873Sly7kFAF26dIG7u7tye2UyGTZs2IC+ffsqP0wrPsSOHj0azs7OKj/Lly9HVlaWzu83RERExeXs7Izg4GCsX78e27ZtQ15eXonTj+hLcnIyYmJilD9JSUkAdL9mVGf16tVo0qSJMie4s7Mzdu/erfI/9q233kLdunXRvXt31KhRA2+88UahfMWzZ8/Gs2fPULduXTRu3BgfffQR/vvvvyLXb2dnV6rrelPYBl3oep0qk8mwYMEC1KlTBxYWFnBycoKzszP++++/El3XA/Jrew8Pj0JfWChS0CiuCxUKXtcD8mv7oq7rAXk+cx8fH1hYWCiv6319fWFtba3S0Xr37l14eHioDNopqDTHtTbqrhczMjIwffp0ZQ55xX5/9uyZyn6/e/dukW0oFosxfPhw7NixQzln1Lp162BpaYlBgwbpFGOdOnUKLatbt67Kdb0u19Olpcu5Bej2GeP27du4du1aoet6xWeWuLg4lTp5XU+mih3pRBWcWCxGp06dEB0drdPoCk15xxUjx+/evYtXX30VCQkJmD9/Pnbv3o2wsDBMnToVAAqNEM3/7X5+ISEhcHV1xdq1awHIL7rc3NwQHBysNT7FJERXrlwpclvUycvLQ5cuXbB792588skn2LFjB8LCwpST8+SP//3338etW7cwd+5cWFpa4ssvv0SDBg2UI2tFIhG2bNmCU6dOYcqUKXj8+DHeeOMNBAQEIDU1tUTxFdezZ8/QoUMHXL58GbNnz8auXbsQFhamzP1YsD0MpajjRhNF+0+dOhV16tRR/vz444/IzMzE1q1b9R6rpo7p/JOz5qfuGC7ueVAUR0dH9OrVS3khvGXLFmRlZeklb3l+Q4YMgVQqVa5n7dq1aNGihdovTYqrOOeWRCLBsGHDsHXrVmRmZuLw4cN48uSJyvYqys+bN095l03Bn4J5/jW93xAREZXEsGHDsGfPHixduhTdu3dX3o1YUHGvLUrqvffeg7u7u/LntddeK1V9a9euxZgxY+Dr64vff/8de/fuRVhYGDp37qzyf9vFxQWXLl3Czp07lbm2u3fvjtGjRyvLtG/fHnfv3sWKFSvQqFEjLF++HM2bN8fy5cu1xlC/fn3cunVLpwE/proN+jRnzhyEhoaiffv2WLt2Lfbt24ewsDA0bNjQ5K/rU1JSsGvXLkRGRqpc1/v5+SE9PR3r168v0zlsinNt/8477+Cbb77B66+/jj///BP79+9HWFgYqlWrVqL9PmrUKKSmpmLHjh0QBAHr169Hr169YG9vX+y6NNHlero0dD23AN0+Y8hkMjRu3Fjjdf1bb72lUiev68lUcbJRokogNzcXAPTSubtr1y5kZWVh586dKqMVCt6KVRTFP/5Vq1bhu+++w44dO9TeZldQ27Zt4ejoiA0bNuCzzz4r9oSjV65cwa1bt7B69WqMGjVKuVzTbZ6+vr744IMP8MEHH+D27dvw9/fHjz/+qOwABoBXXnkFr7zyCr755husX78ew4cPx8aNGzF+/PhixaZu3TKZDBEREcqJkgo6cuQIEhMTsW3bNrRv3165PDIyslBZXW+B9PLyAiCfZLOgGzduwMnJSWv6HV0pLio7depU6MIJAL766iusW7cOY8eOVY62zj9bfUHOzs6ws7PTWgZ4OVr+2bNnKh+IC47G0UbX80BxW+zVq1dRu3ZtrXWOGjUKffv2xdmzZ5UTBzVs2FCneGQyGe7du6cc0QEAt27dAgCViXmqVq2Knj17Yt26dRg+fDhOnDiBhQsX6rSOohT33Bo1ahR+/PFH7Nq1C3v27IGzs7NKCh3FvrOzsyvyCzYiIiJD6N+/P958802cPn0amzZt0lgu/7VFfrpeW+h6jfbxxx+rdJIp1qvLNaM6W7ZsQa1atbBt2zaVGNSl2zA3N0fv3r3Ru3dvyGQyvPXWW/jf//6HL7/8UnmNU7VqVYwdOxZjx45Famoq2rdvj5kzZ2q9Ju7duzdOnTqFrVu3qqQDKU/boAtdr1O3bNmCTp064ffff1dZ/uzZMzg5OSkfFye1iZeXFw4cOIDnz5+rjFRWpIBUXPuX1rZt25CZmYklS5aoxArIP1d88cUXOHHiBNq2bQtfX1/s27ev0ASV+el6XDs6OhY697KzsxEdHa1z7Fu2bMHo0aPx448/KpdlZmYWqtfX17fINgTkd6M2a9YM69atQ40aNRAVFYXFixfrHI+6AXC3bt0qNOFmUdfTpVGcc0uXzxi+vr64fPkyXn31Vb2klCQyFo5IJ6rgcnJysH//fpibm2ucQb44FB3X+UcTJCcnY+XKlcWua+TIkXj69CnefPNNpKam6vTtubW1NT755BNcv34dn3zyidpRDWvXrkV4eLjO8QuCgJ9++kmlXHp6OjIzM1WW+fr6okqVKsrULU+fPi20fsVFnj7Su/Tr1w9isRizZ88u9K2/Yr3qtic7Oxu//vprofpsbGx0uiXU3d0d/v7+WL16tcrF49WrV7F//3706NGjJJtTyIkTJ3D//n2MHTsWAwcOLPQzePBg5cgKZ2dntG/fHitWrEBUVJRKPYptF4vF6NevH3bt2oVz584VWp+inKKD9ujRo8rn0tLSsHr1ap1j1/U86Nq1K6pUqYK5c+cWOp4KHjvdu3eHk5MTvvvuO/z777/FHk3y888/q9T9888/QyqV4tVXX1UpN3LkSEREROCjjz6CRCLBkCFDirUeTXQ9txSaNGmCJk2aYPny5di6dSuGDBkCM7OX3+8HBATA19cXP/zwg9ovAePj4/USNxERkSa2trZYsmQJZs6cid69e2ss5+XlBYlEonJtAUDt9Zg6NjY2hTrs1PHz81OmcAwODkZAQAAA3a4Z1VH3v/vMmTM4deqUSrnExESVx2KxGE2aNAHw8pq3YBlbW1vUrl27yGviSZMmwd3dHR988IFyEEB+cXFx+Prrr016G3Sh63WqRCIp1GabN2/G48ePVZYpBrXoctz06NEDeXl5KteKALBgwQKIRCJ07969OJui0dq1a1GrVi1MmjSp0HX9hx9+CFtbW+WI5QEDBkAQBMyaNatQPYrt1/W49vX1LXTu/fbbb8W6I0Tdfl+8eHGhOgYMGIDLly9j+/btGuNWGDlyJPbv34+FCxeiWrVqxdrPO3bsUGnz8PBwnDlzplAdRV1Pl4au55ZCUZ8xXn/9dTx+/BjLli0r9NqMjIxCqUOJTBVHpBNVMHv27FGOLoiLi8P69etx+/ZtTJs2TZlfvDS6du2qHM2h6ABftmwZXFxcivWtPwA0a9YMjRo1Uk480rx5c51e99FHH+HatWv48ccfcfjwYQwcOBBubm6IiYnBjh07EB4ejpMnT6p9bf369eHr64sPP/wQjx8/hp2dHbZu3Voo59+tW7fw6quv4vXXX4efnx/MzMywfft2xMbGKi8KVq9ejV9//RX9+/eHr68vnj9/jmXLlsHOzk4vnc21a9fG559/jq+++grt2rXDa6+9BgsLC5w9exYeHh6YO3cuWrduDUdHR4wePRrvvvsuRCIR1qxZo/ZDU0BAADZt2oTQ0FC0bNkStra2Gj8Uzps3D927d0erVq0wbtw4ZGRkYPHixbC3t8fMmTNLvW2APFegRCJBz5491T7fp08ffP7559i4cSNCQ0OxaNEitG3bFs2bN8fEiRPh4+OD+/fvY/fu3bh06RIA+e2w+/fvR4cOHTBx4kQ0aNAA0dHR2Lx5M44fPw4HBwd07doVNWvWxLhx45QXeitWrICzs3OhTnpNdD0P7OzssGDBAowfPx4tW7bEsGHD4OjoiMuXLyM9PV2l814qlWLIkCH4+eefIZFIijUqy9LSEnv37sXo0aMRFBSEPXv2YPfu3fjss8/g7OysUrZnz56oVq0aNm/ejO7du8PFxUXn9dy5c0fth9lmzZqha9euOp1b+Y0aNQoffvghABT64kAsFmP58uXo3r07GjZsiLFjx6J69ep4/PgxDh8+DDs7O+zatUvn2ImIiEoif+oPTezt7TFo0CAsXrwYIpEIvr6++Pvvvwvl/NUkICAABw4cwPz58+Hh4QEfHx8EBQXpHKMu14zq9OrVC9u2bUP//v3Rs2dPREZGYunSpfDz81P5Env8+PFISkpC586dUaNGDTx48ACLFy+Gv7+/cqCOn58fOnbsiICAAFStWhXnzp3Dli1bVCZDV8fR0RHbt29Hjx494O/vjxEjRii/ILhw4QI2bNiAVq1aaXy9KWyDrnS5Tu3Vqxdmz56NsWPHonXr1rhy5QrWrVtXaC4cX19fODg4YOnSpahSpQpsbGwQFBSkNq9079690alTJ3z++ee4f/8+mjZtiv379+Ovv/7C+++/rzKxaEkpJr0sOKGpgoWFBUJCQrB582YsWrQInTp1wsiRI7Fo0SLcvn0b3bp1g0wmw7Fjx9CpUydMmTJF5+N6/PjxmDRpEgYMGIAuXbrg8uXL2LdvX6FR8dr06tULa9asgb29Pfz8/HDq1CkcOHAA1apVUyn30UcfYcuWLRg0aJAypWdSUhJ27tyJpUuXomnTpsqyw4YNw8cff4zt27dj8uTJkEqlOsdTu3ZttG3bFpMnT0ZWVpayM/7jjz8uVFbb9XRRVqxYUWiuAECeRkrXc0uhqM8YI0eOxJ9//olJkybh8OHDaNOmDfLy8nDjxg38+eef2Ldvn9qJeIlMjkBEFcLKlSsFACo/lpaWgr+/v7BkyRJBJpOplAcgzJgxQ/l4xowZAgAhPj5ebb2RkZHKZTt37hSaNGkiWFpaCt7e3sJ3330nrFixolA5Ly8voWfPnlrj/v777wUAwpw5c4q9zVu2bBG6du0qVK1aVTAzMxPc3d2FwYMHC0eOHFGWOXz4sABAOHz4sHJZRESEEBwcLNja2gpOTk7ChAkThMuXLwsAhJUrVwqCIAgJCQnC22+/LdSvX1+wsbER7O3thaCgIOHPP/9U1nPhwgVh6NChQs2aNQULCwvBxcVF6NWrl3Du3DmVOAvua0VMmzdvVimnaIOCVqxYITRr1kywsLAQHB0dhQ4dOghhYWHK50+cOCG88sorgpWVleDh4SF8/PHHwr59+wptd2pqqjBs2DDBwcFBACB4eXkJgiAIkZGRKtuucODAAaFNmzaClZWVYGdnJ/Tu3VuIiIhQG7Mux01+2dnZQrVq1YR27dqpfV7Bx8dHaNasmfLx1atXhf79+wsODg6CpaWlUK9ePeHLL79Uec2DBw+EUaNGCc7OzoKFhYVQq1Yt4e233xaysrKUZc6fPy8EBQUJ5ubmQs2aNYX58+erjVnbMazreaAo27p1a+W+DAwMFDZs2FCozvDwcAGA0LVrV637Jb/Ro0cLNjY2wt27d4WuXbsK1tbWgqurqzBjxgwhLy9P7WveeustAYCwfv16ndfj5eVV6D1G8TNu3DhBEHQ7t/KLjo4WJBKJULduXY3rvXjxovDaa68J1apVEywsLAQvLy/h9ddfFw4ePKgso+k4JCIiKg7FtcDZs2e1llN3fRAfHy8MGDBAsLa2FhwdHYU333xTuHr1aqH/gequ927cuCG0b99esLKyEgAIo0ePVolH0/VUQUVdM3bo0EHo0KGD8rFMJhPmzJkjeHl5CRYWFkKzZs2Ev//+Wxg9erTyOlEQXl5zu7i4KK+d3nzzTSE6OlpZ5uuvvxYCAwMFBwcHwcrKSqhfv77wzTffCNnZ2TrF/uTJE2Hq1KlC3bp1BUtLS8Ha2loICAgQvvnmGyE5OdlktkFd+3Xo0EFo2LBhoW0q+BlAEIq+Ts3MzBQ++OADwd3dXbCyshLatGkjnDp1qtB2C4Ig/PXXX4Kfn59gZmamcpwV3HZBEITnz58LU6dOFTw8PASpVCrUqVNHmDdvntrPiG+//XahbfHy8lIel+r8+OOPAgCV67OCVq1aJQAQ/vrrL0EQBCE3N1eYN2+eUL9+fcHc3FxwdnYWunfvLpw/f17ldUUd13l5ecInn3wiODk5CdbW1kJISIhw586dQjFrO7+fPn0qjB07VnBychJsbW2FkJAQ4caNG2q3OzExUZgyZYpQvXp1wdzcXKhRo4YwevRoISEhoVC9PXr0EAAIJ0+e1Lhf8lN8Lps3b57w448/Cp6enoKFhYXQrl074fLly2pfo8v1dEHq+g7y/zx8+FDncyu/oj5jZGdnC999953QsGFDZXsGBAQIs2bNUjnPNR2HRKZAJAhlONsDEVEBP/30E6ZOnYr79++rnSGeqDK5fPky/P398ccff6jMcq9vU6dOxe+//46YmBhYW1sbbD1FSUhIgLu7O6ZPn44vv/zSaHEQEREREelb//79ceXKFdy5c8dg6zCl62lT+YxBZEjMkU5ERiMIAn7//Xd06NCBnehEAJYtWwZbW1u89tprBltHZmYm1q5diwEDBhj9AnfVqlXIy8sz6JcGRERERERlLTo6Grt37zb4da6pXE+b0mcMIkNijnQiKnNpaWnYuXMnDh8+jCtXruCvv/4ydkhERrVr1y5ERETgt99+w5QpU5QTSOlTXFwcDhw4gC1btiAxMRHvvfee3tehq0OHDiEiIgLffPMN+vXrB29vb6PFQkRERESkL5GRkThx4gSWL18OqVSKN9980yDrMZXraVP6jEFUFtiRTkRlLj4+HsOGDYODgwM+++wz9OnTx9ghERnVO++8g9jYWPTo0QOzZs0yyDoiIiIwfPhwuLi4YNGiRfD39zfIenQxe/ZsnDx5Em3atMHixYuNFgcRERERkT79+++/GDt2LGrWrInVq1fDzc3NIOsxletpU/qMQVQWmCOdiIiIiIiIiIiIiEgL5kgnIiIiIiIiIiIiItKCHelERERERERERERERFowR3oRZDIZnjx5gipVqkAkEhk7HCIiIiKqIARBwPPnz+Hh4QGxmONbtOE1OREREREZQnGuydmRXoQnT57A09PT2GEQERERUQX18OFD1KhRw9hhmDRekxMRERGRIelyTc6O9CJUqVIFgHxn2tnZldl6c3JysH//fnTt2hVSqbTM1kuq2A7GxzYwDWwH08B2MD62gWmoKO2QkpICT09P5fUmacZr8sqN7WAa2A7GxzYwDWwH08B2ML6K0gbFuSZnR3oRFLeO2tnZlflFu7W1Nezs7Mr1wVjesR2Mj21gGtgOpoHtYHxsA9NQ0dqBqUqKxmvyyo3tYBrYDsbHNjANbAfTwHYwvorWBrpckzMZIxERERERERERERGRFuxIJyIiIiIiIiIiIiLSgh3pRERERERERERERERamFRH+i+//AJvb29YWloiKCgI4eHhGsvm5ORg9uzZ8PX1haWlJZo2bYq9e/eWqk4iIiIiIiIiIiIiooJMpiN906ZNCA0NxYwZM3DhwgU0bdoUISEhiIuLU1v+iy++wP/+9z8sXrwYERERmDRpEvr374+LFy+WuE4iIiIiIiIiIiIiooJMpiN9/vz5mDBhAsaOHQs/Pz8sXboU1tbWWLFihdrya9aswWeffYYePXqgVq1amDx5Mnr06IEff/yxxHUSERERERERERERERVkEh3p2dnZOH/+PIKDg5XLxGIxgoODcerUKbWvycrKgqWlpcoyKysrHD9+vMR1EhEREREREREREREVZGbsAAAgISEBeXl5cHV1VVnu6uqKGzduqH1NSEgI5s+fj/bt28PX1xcHDx7Etm3bkJeXV+I6AXkHfVZWlvJxSkoKAHlO9pycnBJtX0ko1lWW66TC2A7GxzYwDWwH08B2MD62gWmoKO1Q3uMnIiIiIqpMTKIjvSR++uknTJgwAfXr14dIJIKvry/Gjh1b6rQtc+fOxaxZswot379/P6ytrUtVd0mEhYWV+TqpMLaD8bENTAPbwTSwHYyPbWAayns7pKenGzsEIiIiIiLSkUl0pDs5OUEikSA2NlZleWxsLNzc3NS+xtnZGTt27EBmZiYSExPh4eGBadOmoVatWiWuEwA+/fRThIaGKh+npKTA09MTXbt2hZ2dXUk3sdhycnIQFhaGLl26QCqVltl6SRXbwfjYBqaB7WAa2A7GxzYwDRWlHRR3PhIRERERkekziY50c3NzBAQE4ODBg+jXrx8AQCaT4eDBg5gyZYrW11paWqJ69erIycnB1q1b8frrr5eqTgsLC1hYWBRaLpVKjfJBzVjrJVVsB+NjG5gGtoNpYDsYH9vANJT3dijPsRMRERERVTYm0ZEOAKGhoRg9ejRatGiBwMBALFy4EGlpaRg7diwAYNSoUahevTrmzp0LADhz5gweP34Mf39/PH78GDNnzoRMJsPHH3+sc51EREREREREREREREUxmY70wYMHIz4+HtOnT0dMTAz8/f2xd+9e5WShUVFREIvFyvKZmZn44osvcO/ePdja2qJHjx5Ys2YNHBwcdK6TiIiIiIiIiIiIiKgoJtORDgBTpkzRmHblyJEjKo87dOiAiIiIUtVJRERERERERERERFQUcdFFiIiIiIiIiIiIiIgqL3akExERERERERERERFpYVKpXYiI8kvPzoXf9P0AzNAxOBf2UqmxQyIiIiIiIiIiqtxy0yDdbIu+AHJynwJSB2NHVCY4Ip2IiIiIiIiIiIiISAt2pBMRERERERERERERacGOdCIiIiIiIiIiIiIiLdiRTkRERERERERERESkBTvSiYiIiIiIiIiIiIi0YEc6EREREREREREREZEW7EgnIqIylZ6dC+9pu+E9bTfSs3ONHQ4RERERERERUZHYkU5EREREREREREREpAU70omIiIiIiIiIiIiItGBHOhERERERERERERGRFuxIJyIiIiIiIiIiIiLSgh3pREREZDI4GS0RERERERGZInakExERERERERERERFpwY50IiIiIiIiIiIiIiItzIwdABERmbb07Fz4Td8PwAwdg3NhL5UaOyQiIiIiIiIiojLFEelERERERERERERERFqwI52IiIiIiIiIiIiISAt2pBMRERERERERERERacGOdCIiIiIiIiIiIiIiLdiRTkRERERERERERESkBTvSiYiIiIiIiIiIiIi0YEc6ERGRAaRn58J72m54T9uN9OxcY4djUJVpWysLtikREREREZEqdqQTEREREREREREREWnBjnQiIiIiIiIiIiIiIi3YkU5ERERERERUkeSmAetF8p/cNGNHQ0REVCGwI52IiIiIiIiIiIiISAt2pBMRERERERERERERacGOdCIiIqqw0rNz4T1tN7yn7UZ6dq6xwyEqF3755Rd4e3vD0tISQUFBCA8P11h21apVEIlEKj+WlpYqZcaMGVOoTLdu3Qy9GUREREREemVm7ACIiIiIiMg0bNq0CaGhoVi6dCmCgoKwcOFChISE4ObNm3BxcVH7Gjs7O9y8eVP5WCQSFSrTrVs3rFy5UvnYwsJC/8ETERERERkQR6QTUaXBkalERETazZ8/HxMmTMDYsWPh5+eHpUuXwtraGitWrND4GpFIBDc3N+WPq6troTIWFhYqZRwdHQ25GUREREREescR6UREREREhOzsbJw/fx6ffvqpcplYLEZwcDBOnTql8XWpqanw8vKCTCZD8+bNMWfOHDRs2FClzJEjR+Di4gJHR0d07twZX3/9NapVq6axzqysLGRlZSkfp6SkAABycnKQk5NT0k0sNsW6ynKdVBjboQRycyB98WdOTg4glH7fVYp2yE2DdLv8i76c/k8BMxsjB6SqUrRBOcB2MA1sByMr+H/GrPy2Q3GOIXakExFRuZWenQu/6fsAABGzQ2Btzn9rZDjy420/ADN0DM6FvVRa5GvKEs8HKq2EhATk5eUVGlHu6uqKGzduqH1NvXr1sGLFCjRp0gTJycn44Ycf0Lp1a1y7dg01atQAIE/r8tprr8HHxwd3797FZ599hu7du+PUqVOQSCRq6507dy5mzZpVaPn+/fthbW1dyi0tvrCwsDJfJxXGdtCdRMhErxd/79u3D3kiS63li6Mit4Mh95s+VeQ2KE/YDqaB7WAc+d8vDx06ZLLvl7pIT0/XuSw/YRERERERUYm0atUKrVq1Uj5u3bo1GjRogP/973/46quvAABDhgxRPt+4cWM0adIEvr6+OHLkCF599VW19X766acIDQ1VPk5JSYGnpye6du0KOzs7A21NYTk5OQgLC0OXLl0gNbEvzyoTtkMJ5KYB2+V/hoSE6GVkdaVoBwPsN32qFG1QDrAdTAPbwcjyvV927twZUisHo4ZTGoo7H3XBjnQiIiIiIoKTkxMkEgliY2NVlsfGxsLNzU2nOqRSKZo1a4Y7d+5oLFOrVi04OTnhzp07GjvSLSws1E5IKpVKjfJh2VjrJVVsh2IQvdxPUqkUMNPffqvQ7WDA/aZPFboNyhG2g2lgOxhJgffL8twGxYmdk40SERERERHMzc0REBCAgwcPKpfJZDIcPHhQZdS5Nnl5ebhy5Qrc3d01lnn06BESExO1liEiIiIiMjXsSCciIiIiIgBAaGgoli1bhtWrV+P69euYPHky0tLSMHbsWADAqFGjVCYjnT17Nvbv34979+7hwoULGDFiBB48eIDx48cDkE9E+tFHH+H06dO4f/8+Dh48iL59+6J27drytAlEREREpF5uGrBeJP/JTTN2NASmdiEiIiIiohcGDx6M+Ph4TJ8+HTExMfD398fevXuVE5BGRUVBLH45Fufp06eYMGECYmJi4OjoiICAAJw8eRJ+fn4AAIlEgv/++w+rV6/Gs2fP4OHhga5du+Krr75Sm7qFiIiIiMhUsSOdqBxKz86F3/R9AICI2SGwNuepTEREpsuU/2+ZcmzGMmXKFEyZMkXtc0eOHFF5vGDBAixYsEBjXVZWVti3b58+wyMiIiIiMgqmdiEiIiIiIiIiIiIi0sKkOtJ/+eUXeHt7w9LSEkFBQQgPD9dafuHChahXrx6srKzg6emJqVOnIjMzU/n8zJkzIRKJVH7q169v6M0gIiIiIiIiIiIiogrEZO5d3bRpE0JDQ7F06VIEBQVh4cKFCAkJwc2bN+Hi4lKo/Pr16zFt2jSsWLECrVu3xq1btzBmzBiIRCLMnz9fWa5hw4Y4cOCA8rGZmclsMhERERERERERERGVAyYzIn3+/PmYMGECxo4dCz8/PyxduhTW1tZYsWKF2vInT55EmzZtMGzYMHh7e6Nr164YOnRooVHsZmZmcHNzU/44OTmVxeYQERERERERERERUQVhEh3p2dnZOH/+PIKDg5XLxGIxgoODcerUKbWvad26Nc6fP6/sOL937x7++ecf9OjRQ6Xc7du34eHhgVq1amH48OGIiooy3IYQEdKzc+E9bTe8p+1GenauscMhIjV4npoGtgMREREREVH5YRJ5ThISEpCXlwdXV1eV5a6urrhx44ba1wwbNgwJCQlo27YtBEFAbm4uJk2ahM8++0xZJigoCKtWrUK9evUQHR2NWbNmoV27drh69SqqVKmitt6srCxkZWUpH6ekpAAAcnJykJOTU9pN1ZliXWW5TirMVNshJyc33985yBEJRoxGlT5jU60rt9TtYMr7zZSZcjuYcpsaIjZ9vSfpOzZTbtPK9J5UWdpBUUf+36Wry3jvI6Z2fUFERERERJqZREd6SRw5cgRz5szBr7/+iqCgINy5cwfvvfcevvrqK3z55ZcAgO7duyvLN2nSBEFBQfDy8sKff/6JcePGqa137ty5mDVrVqHl+/fvh7W1tWE2RouwsLAyXycVZmrtkJUHKE7fffv2w0Ji1HBU6DO2/HUdOnSo1NtpyvvNlJlyO5hymxoyttK+J+k7NlNu08r0nlRZ2iE/ffx/Nub7SHp6etmtjIiIiIiISsUkOtKdnJwgkUgQGxursjw2NhZubm5qX/Pll19i5MiRGD9+PACgcePGSEtLw8SJE/H5559DLC6ctcbBwQF169bFnTt3NMby6aefIjQ0VPk4JSUFnp6e6Nq1K+zs7EqyeSWSk5ODsLAwdOnSBVKptMzWS6pMtR3Ss3PxcfghAEBISFdYm5vEqQxAv7Hlr6tz586wt7E0mdgqE1NuB1NuU0PEpq/3JH3HZsptWpnekypLOwD6/f9szPcRxZ2PRERERERk+kyix8Hc3BwBAQE4ePAg+vXrBwCQyWQ4ePAgpkyZovY16enphTrLJRL5ECJBUH9LbmpqKu7evYuRI0dqjMXCwgIWFhaFlkulUqN0pBprvaTK1NpBKohe/i2VQio1iVMZgH5jU63LrNRtYMr7zZSZcjuYcpsaMrbSvifpOzZTbtPK9J5UWdpBpV49/H825vuIKV1bEBERERGRdibT4xAaGorRo0ejRYsWCAwMxMKFC5GWloaxY8cCAEaNGoXq1atj7ty5AIDevXtj/vz5aNasmTK1y5dffonevXsrO9Q//PBD9O7dG15eXnjy5AlmzJgBiUSCoUOHGm07iYiIiIiIiIiIiKh8MZmO9MGDByM+Ph7Tp09HTEwM/P39sXfvXuUEpFFRUSoj0L/44guIRCJ88cUXePz4MZydndG7d2988803yjKPHj3C0KFDkZiYCGdnZ7Rt2xanT5+Gs7NzmW8fEREREREREREREZVPJtORDgBTpkzRmMrlyJEjKo/NzMwwY8YMzJgxQ2N9Gzdu1Gd4VMmkZ+fCb/p+AGboGJwLe95+TUREREREREREVCkVnpGTiPQuPTsX3tN2w3vabqRn5xo7HCIiIiIiIiIiIioGdqQTEREREREREREREWnBjnQiogqId0EQERERERGZsNw0YL1I/pObZuxoDKsybStVaOxIJyIiIiIiIiIiIiLSgh3pRERERERERERERERamBk7ACIiIiIiIiKqJHLTgD9t5X+/ngqY2Rg3HiIqf3LTIN1si74AcnKfAlIHY0dElQRHpBMRERERERERERERacGOdCIiohc4SSsRERERERERqcOOdCIiIiIiIiIiIiIiLZgjnYiIiIiIiIiIqCjMzU1UqXFEOhERERERERERERGRFuxIJyIiIiIiIiIiIiLSgh3pRERERERERERERERasCOdiIiIiIiIiIiIiIwjNw1YL5L/5KYZOxqN2JFORERERERERERERKQFO9KJiIiIiIiIiIiIiLRgRzoRERERERERERERkRbsSCciojKVJxOUf4dHJqk8JqKS47lFRERERFRM5SQ3N5kGdqQTEVGZ2Xs1GsHz/1U+HrPyLNp+dwh7r0YbMSqi8o/nFhERERERkWGxI52IiMrE3qvRmLz2AmJTslSWxyRnYvLaC+zwIyohnltERGRwuWmQbjZH37R+HLFJRESVFjvSiYjI4PJkAmbtioC6RBOKZbN2RTAVBVEx8dwiIiIiIiIqG+xIJyIigwuPTEJ0cqbG5wUA0cmZCI9MKrugiCoAnltERERERERlw8zYARARUcUX91xzR19JylVG6dm58Ju+H4AZOgbnwl4qNXZIZAJ4bhEREREREZUNjkgnIiKDc6liqddyRCSn6znz6+E7+OvSY2Tl5hk4IiIiIqp0ctOA9SL5D3PoE1EFxhHpRERkcM1rOsBcIkZ2nkxjmSqWZmjp7ViGURGVf/Xdq0AiFhWZA/1mbCre23gJTrbmGNzSE8OCvFDdwaqMoiQiIiIiIir/OCKdqAzk7+AIj0zipG9U6czbd1NrJzoAPM/MxYebLyMzp2KMmK1M531l2lZTIpMJ+PDPyxr3t+jFz7evNcbU4LpwtbNAQmo2fjl8F+2+O4Txq8/h31vxkKl5PduUiIiIiIhIFTvSiQxs79VoBM//V/l4zMqzaPvdIey9Gm3EqIjKzvaLj7D8eCQA4M32PnC1s1B53t3eEkMCPSERi7Dj0hMM+e004lLKdz7nynTeV6ZtNTULD9zCwRtxMDcTY1r3+oXOLTd7SywZ0RxDAmviveA6OP5JZywd0RxtaleDTAAOXI/F6BXh6PTjESw7eg/P0rMBsE2JqJSY4oGIiIgqKHakExnQ3qvRmLz2AmJTslSWxyRnYvLaC+yUKOfSs3PhPW03vKftRnp2rrHDMUlXHiVj2tYrAIB3OtfGpz38cCC0g/L5VWNb4vgnnfHta02w5o1A2FtJcenhM/T95QSuPk42VtilUpnO+8q0raZm79VoLDp0BwAwt39jTOrgq/bc6tbIXblMKhGjWyN3rBv/Cg6EdsCY1t6oYmGGB4np+Oaf6wiacxBDfzuNSWxTIiIiIiKiQtiRTkZVkTsi82QCZu2KgLqb4RXLZu2K4O3yVGElpGbhzTXnkJUrw6v1XTA1uC4AQCIWKcsE+lRVPm5d2wl/vd0Gvs42iE7OxMClJ7H7v/LVaVeZzvvKtK2m5mbMc4T+eRkA8EYbHwwIqAFA87mlTm0XW8zs0xBnPn8Vc19rDD93O2TlynDqXqLa8mxTIiIiIiKq7NiRTmQg4ZFJiE7WnJ5CABCdnInwyKSyC4qojOTkyfDWugt4kpyJWs42WDDEH2ItnXoK3k422P52G3So64zMHBneXn8BCw/cUpvD2RRVpvO+Mm2rKUlOz8HENeeQnp2H1r7V8FmP+qWqz9rcDEMDa2L3u20xq09DrWXZpkRkFLlpkG42R9+0fkwVQ0REREbFjnQiA4l7rluOZ13LEZUnX/8dgfDIJNhamOG3kS1gZynV+bV2llKsGNMS49v6AAAWHriNdzZcREa26U9CWpnOe523tZznuzcleTIB72y8iAeJ6ajuYIWfhzWHmUQ/l3IikQgO1rqdpzFGbtP07FzU+XI/3jtlVuHuZiMiIiIiItPFjnQiA3GpYqnXclSxVaQ0R3+efYjVpx4AABYM9kdtF9ti1yERi/BFLz98P6AJpBIRdl+JxqD/nUR0coa+w9WrynTeV7Mx16ncj2G3sP5MFNKyyvdxbQrm7buJo7fiYSkV47dRAaiqYxvoStfj8pu/I/DL4TuIf55VdGEiIiIiIqIKgh3pRAYSr8NoTXd7SwT6VC2DaIjKxsWop/hix1UAwNTguuji51qq+l5v6Yn1E15BVRtzXH2cgj4/n8DFqKf6CNUg7sQ/L7JMRTjvk9NzsPTfuzqVjUpKx2fbr+CVOQcxc+c13Ikreh9RYbsuP1Hu8+8HNkVDD3u9ryPQpyrc7S2hLQmTSAQkpGVj3r6baP3tQby74SLO3k+CIJSP9EtEREREREQlxY50Ij2TyQTMD7uFdzdeKrLs9F5+WieDIypP4lIyMWnteWTnydDVzxXvdK6tl3pbelfFX2+3QX23Koh/noXBv53GjouPAUBl0sPwyCSjTYKYmyfDjL+u4ssd15TLNJ3ZbXyrlevz/l58Kvr/egLH7yTC/EVakYJbI3rx8+OgJviiZwN4V7PG86xcrDp5H8Hzj2Lob6fxz5Vo5OTJCtVvKm2qTv5Yzt5/WmaxRTxJwcdb/gMAvNmhFvo09TDIeiRiEWb09gOguU1/GuyPHwc1hb+nA3LyBOy8/ASDlp5C95+OYe3pB0jVcOeBKbcrFfbLL7/A29sblpaWCAoKQnh4uMayq1atgkgkUvmxtFS9u0EQBEyfPh3u7u6wsrJCcHAwbt++bejNICIiIiLSK3akE+lRenYu3l5/AYsOyj8cTmjng1+HNYernYXa8uW5M40ov6zcPExaex6xKVmo42KL+YN1m1xUV55VrbFlcmsEN3BFdq4M72+6hDfXnEPw/H+VZcasPIu23x3C3qvReluvLpLTczBm5VllOpuPQuphyfDmcClw3ttZmgEAtl18jOO3E8o0Rn05djse/X45gXsJafCwt8T2t1tj6YjC2+pmb4klI5pjQIAnxrerhUMfdMQfbwSii58rxCLg1L1EvLXuAtp8ewgLwm4h5sWkpXuvRptEm6pTMLbxay6WSWxP07Ixcc05ZOTkoV0dJ3wcUrrJRYvSrZE7lmhp0z7+1TEgoAZ2vN0Gu6a0xeAWnrCUinEj5jm+2HEVr8w5iOl/XcWt2Jd3Hphyu1JhmzZtQmhoKGbMmIELFy6gadOmCAkJQVxcnMbX2NnZITo6Wvnz4MEDlee///57LFq0CEuXLsWZM2dgY2ODkJAQZGZyDgUiIiIiKj/YkU6kJ0+eZWDgklPYczUGUokI3w9sgs97+qFHE3ccCO2gLLdqbEu82aEWAGDWrohyMYEiUVFm7ozAhahnqGJpht9GtYCthZne1yGfuDQAb3X0BQDsuxaL2BTVHM0xyZmYvPZCmXXQ3YlLRb9fT+D4nQRYm0vw28gAvN2pNro3LnzeX/iyCwY0rwGZAEzZcAEPk9LLJEZ9EAQBq05EYszKs0jJzEWAlyP+mtIWDT3s0a1R4W09/klndGvkrlwmFovQvq4zlo1qgWOfdMaUTrXhZGuOuOdZ+OngbbT57hD6/3ICk9ZeMHqbqrP3ajQmGyG23DwZpmy4gEdPM+BVzRqLhzYrky9gdWlTAGhcwx7fDWyCM58G48tefvBxskFqVi7+OPUAXRccxZDfTuGb3RFG2XdUcvPnz8eECRMwduxY+Pn5YenSpbC2tsaKFSs0vkYkEsHNzU354+r6Mq2XIAhYuHAhvvjiC/Tt2xdNmjTBH3/8gSdPnmDHjh1lsEVERERERPrBjnQiPTj/4Cn6/HwCEdEpqGZjjg0TXsHrLTyVz+fv+Aj0qYr3Xq0DD3tLPH6WgV8O3zFGyER6s+7MA2wIj4JIBCwa2gw+TjYGW5dYLMIHXevBwUqq9nlFsohZuyIMnjri31vx6P/rCUQmpKG6gxW2Tm6Nrg3dlM8XPO/NJGJ8078Rmtawx7P0HEz441y5mFg2O1eGz7ZfxcwX+3RA8xpYPyEIzlVejlguuK3aOnurO1jhw5B6ODntVSwa2gyB3lWRJxNw8eEzteXLsk3VyZMJmLUrAurWbOjYvt1zAyfuJL74kqYFHKz1O7moNsVpU3trKca19cHB0A5YOy4IIQ3ldx6cvpeEZccijbLvqGSys7Nx/vx5BAcHK5eJxWIEBwfj1KlTGl+XmpoKLy8veHp6om/fvrh27WWaq8jISMTExKjUaW9vj6CgIK11EhERERGZGv0PGSSqZLZdeIRpW68gO0+G+m5VsHx0C9RwtNb6GmtzM0zv7YdJay/gt6P38Frz6qjlbFtGERPpz9n7SZi5U95h8lFIPXSq52LwdYZHJuFZRo7G5wUA0cmZCI9MQivfanpfvyAIWHniPr7eHQGZALTwcsTSkQFwslWfwik/S6kES0cGoPfi47gR8xwfbfkPPw9tBpHINNM8JaVlY/La8zgTmQSRCPi0e31MaFdLL/Gam4nRp6kH+jT1wKazUfhk6xWNZQ3dptqERyYhOllz+glDxbb94iMsPx4JAPhxUFPUc6uit7oNRSwWoW0dJ7St44QnzzLww74b2HbxicbyxmxXUi8hIQF5eXkqI8oBwNXVFTdu3FD7mnr16mHFihVo0qQJkpOT8cMPP6B169a4du0aatSogZiYGGUdBetUPKdOVlYWsrJe3smQkpICAMjJyUFOjub/AfqmWFdZrrPcy82B4uvunJwcQCjlvitYnxnbQiem3A76jk2fTDk2mPB7konvN72qLOeCvlWm96TcNEi3O8rr6/8UMCvFQDNTPkb0/f/ZiNtanPdUdqQTlVCeTMC8fTex9N+7AICufq5YMNgfNjqmtAhp6IYOdZ3x7614zNh5DX+8EWiynWlE6kQnZ2Dy2gvIyRPQs7E7JnfwLZP1xj3XLadubIr+c+9m58ow/a+r2Hj2IQBgUEANfN2/ESzMJDrX4W5vhSUjAjD0t9PY/V80GnnYY3LHstl3xXEr9jnGrT6Lh0kZsLUww6Kh/uhc37XoF5aApVS3/ffkWTqAsu1wffhUtxQ8j5/qL7Yrj5Ix7cUXC1NepAoqbzwcrNChnovWjnQFXc9pMk2tWrVCq1atlI9bt26NBg0a4H//+x+++uqrEtc7d+5czJo1q9Dy/fv3w9pa+4AFQwgLCyvzdZZXEiETvV78vW/fPuSJLLWWL059hw4dKnV9lYUpt4O+Y9MnU44tP1N7Tyov+00fKsu5oG+V6T1Jn/WZ8jGi7//PxtzW9HTd066yI52oBFKzcvH+xos4cF0+8daUTrUR2qVusSZXFIlEmNmnIUIWHMWx2wnYezWmXHaWUOWUmZOHSWvOIyE1C/XdqmDeoCZl9kWQSxXd/qHO3XMdCalZGBhQQy8pMZLSsjFp7XmERyZBLAI+69EA49r6lGi7W3pXxcw+DfHFjqv4ft8NNHCvgo5lMJpfVwevx+K9jZeQmpULz6pW+H10S9R1NdyIaF3bdNauCNyNT8OwoJpF3vlTWrdjn2Pt6QfYdO6hTuVn7LyGGzHPMfwVr1KlN0pIzcKba84hK1eGzvVdMLVL3RLXZWy6tuuOi4/h62yLRtXtDRwRFcXJyQkSiQSxsbEqy2NjY+Hm5qbhVaqkUimaNWuGO3fkqesUr4uNjYW7+8vrnNjYWPj7+2us59NPP0VoaKjycUpKCjw9PdG1a1fY2dnpukmllpOTg7CwMHTp0gVSqfq0YlRAbhqwXf5nSEhI6UbiFaivc+fOkFo5lK6+ysKU20HfsemTKccGE35PMvH9pleV5VzQt8r0nqTP+kz5GNH3/2cjbqvizkddsCOdqJgeJqVj/OpzuBn7HOZmYswb2AR9/auXqC4fJxtM6lALiw7dwey/I9ChnjOszcv2tEzPzoXf9H0AgIjZIWW+fip/BEHA59uv4vKjZDhYS/HbyBZletwE+lSFu70lYpIz1eZeBgARgNiULHy9+zrm7buJPk09MKqVNxrXKFlH3c2Y5xj/h3x0dhULMywa2gyd6peu43t4UE1ce5KMDeEP8e6Gi/hrSluD5pfXhSAIWHbsHubuuQFBAIJ8qmLJiABUtTFsbm5d2lQsAlIyc/HrkbtY8u9dvFrfBSNe8UL7Os7F+hJTm5w8GfZfi8Wa0/dx+l6ScrlELNKax1siAtKy87D8eCSWH49EuzpOGPmKFzrXd4GZRPfpaHLyZHhr3QU8Sc5ELScbLBjsXyaTixqKLu0KAIdvxuPwzXg0q+mAUa280L2Ru853KZB+mZubIyAgAAcPHkS/fv0AADKZDAcPHsSUKVN0qiMvLw9XrlxBjx49AAA+Pj5wc3PDwYMHlR3nKSkpOHPmDCZPnqyxHgsLC1hYFE6ZJZVKjdJ5ZKz1lkuil/tJKpUCZqXcbwXqYzvoyJTbQd+x6ZMpx5aPXs6F3DTgzxfpRV9PLV2nVTnZb3pRWc4FfatM70n6rM+UjxF9/3824rYWJ3ZONkqkQf5Ok7P3nyJPJuDMvUT0+fk4bsY+h0sVC/z5ZqsSd6IrTO5YGzUcrRCdnIlFBznxaH7q2oDKXsF2WHkiElsvPIJYBPw8tDlqVivbW+wlYhFm9PYDIO8wz0/04mfBYH/Mfa0xGrjbIStXhs3nH6H3z8fR95cT2HL+ETJz8tTWnX9bwyOTkCcTcPB6LF779QQeJmXAq5o1tr3VutSd6MDLu1Ka13RASmYuJv5xDqlZZTP5qLrtzMrNw4eb/8Ocf+Sd6EMDPbFmXJDBO9EB3dp08dBmWDoiAG1rO0EQgAPX4zBm5Vl0/OEIfjt6F0/TstXWrW5bC4pOzsD8sFto8+0hvL3+Ak7fk991ENLQFWvHBWHxkGbKONTH1hwrx7RE5/ouEImAY7cTMHHNebT//jB+PnQb8c+zCq1TXWyzd11DeGQSbC3M8NuoANhrmFS3vNClXT/oUhe9m3pAKhHhYtQzTN10Ga2/PYRv99zAwyT1t1jq+3+DLsdIZRIaGoply5Zh9erVuH79OiZPnoy0tDSMHTsWADBq1Ch8+umnyvKzZ8/G/v37ce/ePVy4cAEjRozAgwcPMH78eADy97r3338fX3/9NXbu3IkrV65g1KhR8PDwUHbWExERERGVByY19PSXX37BvHnzEBMTg6ZNm2Lx4sUIDAzUWH7hwoVYsmQJoqKi4OTkhIEDB2Lu3LmwtLQscZ1EALD3ajRmvJhAEQDGr7kIe6ureJ6ZA5kANK5uj2WjWsDNvvQ5m6zMJZjZuyHG/3EOy4/dw8CA6qjtYvqTyhmaujZwt7+OGb390K0RU+CUFXXtoPBp9wZoW8fJGGGhWyN3LBnRHDN2XkNsystOSjd7S5VjZEhLT1yIeoo1px7gnysxuPzwGS4/fIavd0fg9RaeGB5UE17V5KNvCm7rmJVnUcXSDM8z5Z3brWpVw6/Dm8NRjx3LFmYSLB0RgF6Lj+N2XCo++PMSlgwP0NsIa3XUbadLFQvYWprhXnwaxCJgei8/jG7tXabzNujapt0aueFufCrWnY7C5vMPEZWUjjn/3MAP+2+hdxMPjGzlBX9PB43b6v6ivpCGbjh5NxFrTj1A2PVYZeepk60FhgV6YkhgTXg4WClfu0RcdGyd6rvgYVI61p55gD/PPsST5Ez8sP8Wfjp4G90auWNUKy+08HKESCRSG5vCgsH+Feb/gK7tGve8Af48+xDrzkQhOjkTS/+9i/8dvYtO9Vww8hUvtK/rDIm48H4r7f8GbcdIZf1fM3jwYMTHx2P69OmIiYmBv78/9u7dq5wsNCoqCmLxy7E4T58+xYQJExATEwNHR0cEBATg5MmT8PPzU5b5+OOPkZaWhokTJ+LZs2do27Yt9u7dq3LNTkRERERk6kymI33Tpk0IDQ3F0qVLERQUhIULFyIkJAQ3b96Ei0vhkX/r16/HtGnTsGLFCrRu3Rq3bt3CmDFjIBKJMH/+/BLVSQTIP1RPXnuh0G3oyRnyWXwDvBywdtwrsDLX323nwX6ueLW+Cw7eiMP0v65h3figSj3xqKY2iEnOxOS1F7BkRPNK28FRljS1g0INRysNz5SNbo3c0aa2ExrP3A8AWDW2JdrVcVZJhSESiRDgVRUBXlXxRa8s/HnuIdadjsLjZxn47eg9/Hb0HjrUdYafux2W/nu30LYqOtHb1XHCijEtIS1Gmg5dudhZYunIAAz532nsuxaLXw7fwTuv1tH7egDNbRr3PAtxz7NgKRXjt5Et0L6us0HWXxRd2hQAfJ1tMb23Hz4MqYtdl5/gj1MPcO1JCrZeeIStFx6hSQ17NPV0wNpTD9S+j0xaewGudhYqHbuBPlUx8hUvhDR0g7lZ4XYuGNvykc3QqYF7odg8q1rj0+4NMDW4Lv65Eo01px/gYtQz7Lr8BLsuP0F9typoVtMBG8Mfajy38mSy4u04E6dLu7pUscSUznUwqYMvDt2Iw5rTD3DsdgIO3YjDoRtx8KxqhRZeVbHj4mO9/W/g/xrNpkyZojGVy5EjR1QeL1iwAAsWLNBan0gkwuzZszF79mx9hUhEREREVOZMJrXL/PnzMWHCBIwdOxZ+fn5YunQprK2tsWLFCrXlT548iTZt2mDYsGHw9vZG165dMXToUISHh5e4TqI8mYBZuyK05nJ98ixTbSdLac3s0xAWZmKcvJuIv/+L1nv95YW2NlAsm7UrotLfem9oRZ0LIgCz/zZ+O+TviAv0qao1n7STrQXe6lgbRz/uhN9Ht0DHes4QiYB/b8VjiZpO9PzuxKVCbMAvt5rXdMTX/RoBAOYfuIUDEbFFvKL4dHl/q2IpRZvaxrnLQKE4bWptbobBLWvi73faYvtbrfFa8+owNxPjv0fJWKOmEx14+T4Sm5IFa6kYI1/xwr732+PPN1uhd1MPre/v+WNp6e2oNTZLqQSvNa+B7W+1wd/vtMWQlp6wlIpxI+Y5NmjpRBehYr7H6dquZhIxujZ0w5pxQTj0QQeMa+sDO0szPEzKwHY1nehAyf438H8NEREREREVl0mMSM/Ozsb58+dV8i2KxWIEBwfj1KlTal/TunVrrF27FuHh4QgMDMS9e/fwzz//YOTIkSWuEwCysrKQlfVyhJpi5tacnBzk5OSUajuLQ7GuslynMeTk5Ob7Owc5IuN+YD0TmYTo5EytZaKTM3HqThyCfKrqXK8u2+lWRYo32/tg0aG7+PrvCLT1dYSthfpTVJ/7Td9tUNr6imoDASVrA33EZsj6TC228tIOJa2rfe2qaF+7Kh4kpWN+2G38c1V7x7Whzvv8+vu74fLDp1gX/hDvb7qELW8Gwdf55aRPqvXlFvv/gy7vb/HPs8ptmzZyt8V3/Rvik651MP/AbWw697jI1/w0uCk61nNWrqt4seneBvVcrPFVnwb4qEttLDh4B2vPPNRYtryfW/qsz9PBAtNC6uC9TrWw6NBdLD9xX2NZxX4LmnNAp4lKM3PykJCqPq9+/vpK0g7FUdGv84iIiIiIKhKT6EhPSEhAXl6eMveigqurK27cuKH2NcOGDUNCQgLatm0LQRCQm5uLSZMm4bPPPitxnQAwd+5czJo1q9Dy/fv3w9q6bCfUA4CwsLAyX2dZysoDFIfhvn37YaG/bCklcj5BBKDoIPYfO4PE67p3Kui6nTVlgJOFBLHPsxD6+wH081Z/e78+95u+26C09enaBvuOFq8N9BGbIesztdgMdS7oIzZ91+WUZdzzPr/mIuB0FQnuPs/FqN+OI7RxHqzMCtd36NChYm9reFzlaVOLZN229diZc0i/W7I2LUkbAIA4qfK0gz7ry9bxPUlb53hJlKQdiiM9Xf2EqkRERKQnuWnAn7byv19PBcxstJcnItLCJDrSS+LIkSOYM2cOfv31VwQFBeHOnTt477338NVXX+HLL78scb2ffvopQkNDlY9TUlLg6emJrl27ws7OTh+h6yQnJwdhYWHo0qULpFJpma23rKVn5+Lj8EMAgJCQrrA2N+4hWS0yCX/cPldkua7tgoo1Qq042+lQNx7j11zE0VgJPhzQBnVdC084p8/9pu82KG19urbBnmhLuPp4Y2BAdVTTcfJHU9tWU47NUOeCPmLTd12mcN7n17pjFvovOY2YlCzsS3HD0mHNIBaLVOrr3Lkz7G10m6Tv4dN0bDz7CH89egggr8jybFPdYitOG5RFbAXjM4V20Gd9uu63mb3qo6FH0ddr156kYObfmgdWKJSkHYpDcecjERERUanp80sDfgFBpJZJdKQ7OTlBIpEgNlb11vrY2Fi4ubmpfc2XX36JkSNHYvz48QCAxo0bIy0tDRMnTsTnn39eojoBwMLCAhYWFoWWS6VSo3RoG2u9ZUUqvMyRKt9W4x6SrWq7wN3eEjHJmWrzpooAuNlbolVtF625cQsqznYGN/RAV78n2B8Ri1m7b2LTxFcKTTyqz/2m7zYobX01qtrCTCxCrpa8tCIRkJCWgx/CbmPRobvo2cQdI17xQvOaDlonaTW1bTXl2BTngqZUICU9F/QRm77rMoXzPj93Ryl+G9UCA5eewuGbCfjl30iEdq1XoD4zrf8b8mQCjt6Kx5rTD3D4ZhyEFxsmFgGaTi22aXFj094GZR1b4fiM3w76rE/X/TaydS2d9ltzbyf879h9g7RDcVTkazwiIiIioorGJCYbNTc3R0BAAA4ePKhcJpPJcPDgQbRq1Urta9LT0yEWq4Yvkchv+RUEoUR1EknEIszo7af2OcXH6Bm9/Qz6oRoApvf2g6VUjPDIJPx16YlB12VKztxLxGtLTmrsRBe9+PlpsD/mDWyCpjXskZ0nw/aLjzFgyUn0XHQcG8KjkJ6dq/b1+SeNC49M4iRyWkjEIkzpXFvtc2V5LpSF/Od9wa0x1rY2qeGAuf0bAwAWHbqDvVejVY7Xs/efqj1+k9KysfTfu+j4w2GMXXUWh27IO9Hb1XHCslEtsHhoM+V5lB/btOyYcmymTN/7je1ARERERJVObhqwXiT/yU0zdjTlkkl0pANAaGgoli1bhtWrV+P69euYPHky0tLSMHbsWADAqFGjVCYO7d27N5YsWYKNGzciMjISYWFh+PLLL9G7d29lh3pRdRKp062ROxYO8S+03M3eEktGNEe3Ru4Gj6GGozXe6VwHAPD17utIyaz4k5FtOhuFEb+fQVJaNhpXt8fc1xrB1U717hBFG/Txr45BLTzx15S2+OvtNhgUUAMWZmJERKfg021XEPTNQczceQ134lKVr917NRrB8/9VPh6z8izafncIe69Gl9k2ljfHbiUAAKQS1Y6ksjwXykq3Ru5YMqI5XDQcc8bY1gEBNfBGGx8AwLsbL6HjvCPK58avuag8fgVBwIWopwjddAmvzD2Ib/fcwMOkDNhbSTG+rQ8Of9gRa8YFoYufK3o28TC57TQUU2xTBVOOzZTpe7+xHYioQpPlS+cWd1T1MREREZWISaR2AYDBgwcjPj4e06dPR0xMDPz9/bF3717lZKFRUVEqI9C/+OILiEQifPHFF3j8+DGcnZ3Ru3dvfPPNNzrXSaRJzaqqE8suH9kMnRq4l+nItPHtfLD1/CPcS0jDgrBbmNG7YZmtuyzl5skw558bWHEiEgDQs4k7fhjYFFbmEvRq4oHGM/cD0NwGTT0d0NTTAZ/3bIAt5x9h7ekHuJ+YjlUn72PVyfto7VsNjTzssOxYZKHb92OSMzF57QV2mKhx5GYc9l6LgUQswsaJr2DAklMAjHMulJVujdzRpraT8phbNbYl2tVxNuq2ftajPk7cicfN2FQk5qpOohiTnIlJay/A09EKD59mKJc3rm6Pka280LuJB6zMC0/OaIrbaSimvK2mHJspK7jfSvuexHYgogrp4Tbg3LsvHx/pAVjXAAJ+AjxfM15cRERE5ZzJdKQDwJQpUzBlyhS1zx05ckTlsZmZGWbMmIEZM2aUuE4iTa5HP1d53NLbscw/VFuYSTCrb0OM/D0cq0/ex6AAT/jpMIFaeZKckYN3NlzE0VvxAIDQLnXxTufayjzn+fd5UW3gYG2O8e1q4Y02Pjh+JwFrTj/AweuxOHk3ESfvJqp9jQD5LfyzdkWgi58bO05eyMzJw8yd1wAAY1p7o4H7y+POGOdCWcq/bYE+VY2+rSKRCE/T1d+Rovhi6OHTDJhLROjjXx0jX/FCU0+HIus1te00JFPeVlOOzZQV539DcetjOxBRufdwG3BsIFBwCEn6Y/nydlvYmU5ERFRCJpPahciUREQnGzsEAEC7Os7o2dgdMgGY/tdVyCpQTu/IhDT0//UEjt6Kh6VUjF+HN8e7r9bROlmoLsRiEdrXdcayUS1w7JPO6OfvobW8ACA6ORPhkUmlWm9FsuzoPdxPTIdLFQu8H1zH2OFUauGRSYh7nlVkuV+GNccPg5rq1IlOREREFZQsDzj/Hgp1ogMvl51/n2leiIiISogd6URqFByRbkxf9GoAa3MJzj14im0XHxs7HL04cScB/X45gXvxaXC3t8SWSa3Ro7H+U6tUd7BCp/ouOpWNe56p9/WXRw+T0vHz4TsAgM97NkAVS6mRI6rcdD0u03P4gZiIiKjSiz8GpD/SUkAA0h/KyxEREVGxsSOdqACZTMD16BRjh6Hkbm+F916Vjwqe+891JGtI81BerDl1H6NWhCM5Iwf+ng746+02aFTd3mDrc6liqddyFd2sXRHIypWhVa1q6NNU+2h+Mjwev0RERKSzjGj9liMiIiIV7EgnKuBBUjrSs/NgbmY6p8fYNj6o7WKLxLRs/Bh209jhlEhOngxf7LiCL/+6hjyZgP7NqmPjxFfgYmfYDsBAn6pwt7eEpoQxIgDu9pYI9Klq0DjKg4PXY3HgeizMxCLM7tuw1Gl2qPR4/BIREZHOrHS8w1PXckRERKTCdHoKiUyEYjR6XRdbI0fykrmZGLP7NgQArD39AFcevczhHh6ZhDwTyp2ePxZFbM/SszF6RTjWno6CSAR80q0+5r/eFJZSicHjkYhFmNHbDwDUdkYKAGb09qv0k8tl5uRh5i75BKPj2vqgjmsVI0dEgPbjV/GYxy8REREBAJzbAdY1oP6qF/Ll1p7yckRERFRs7EgnKiDiibwjvZ6baXUktvZ1Qp+mHpAJwIjfzyiXj1l5Fm2/O4S9V41/i+beq9EInv+v8vGYlWcRNOcAusz/FyfvJsLGXILfRrbA5I6+ZTrauVsjdywZ0RwudhaFnvOqZo2ufm5lFoupWnLkLh4mZcDNzhLvvsoJRk2JpuPXzd4SS0Y0R7dGHFVGREREAMQSIOAnDU++uPYOWCgvR0RERMXGjnSiAhQj0uu7m1ZHOgC09q0GAMjJUx2BHpOciclrLxi1M33v1WhMXnsBsSlZKssTUrMRn5qNajbm2PpWa3TxczVKfN0aueNAaAfl44WDm8LWXIIHienYePahUWIyFQ8S07Dk37sAgC97+cHGwszIEVFBBY/f5SOb4fgnndmJTkREVFHkpgHrRfKf3LSS1+P5GtDil8LLzaoA7bbInzc2Wb5J0uOOqj4mIiIyYexIJyogQtGR7mantzqtzc1w/9ueuP9tT1ibl6yTMk8m4KeDt9U+p+hWn7UrwihpXvJkAmbtioC2NZtJRKjjYtwvJ/Knv+ja0A0fhNQDAHy/7waS0rKNFZZRCYKAGTuvITtXhra1ndCjMUfnm6r8x29Lb0emcyEiIiL1JGrmILKuYRqd6A+3Abv9Xj4+0gPY6S1fTkREZOLYkU6Uz9O0bEQnZwIA6plYjujwyCRlbOoIAKKTMxEemVR2Qb1QVGwAEJuSZZTYtBn5ihcauNvhWXoOvt97w9jhGMX+iFgcuRkPqUSEWZxglIiIiCoyfY36NnVxR1Qfi8yAlAgg5aZRwlF6uA04NhDIeKy6PP2xfDk704mIyMSxI50oH0Val5pVrWFraVrpLeKea++oLm45fYp+lqFTOWPEpo2ZRIyvXkziuvHsQ1yIemrkiMpWRnYeZu+KAABMaFcLvs6mM8EuEZEm1uZmuP1VV/zUKrfEd3kREVVosUdUH7t2lP9+uL2sI3lJlgecfw9Qew/ri2Xn32eaFyIiMmnsSCfKR5HWpYEJ5kd3qaLmFk01zkYm4Vl62aQpiU7OwPz9NzHr7widyuu6DWWphXdVDAyoAQCY/tdVo6TGMZZfDt/B42cZqO5ghSmdaxs7HCIqJX2kESMionIu9T6QHiUfha5QvY/8tzFHfMcfA9IfaSkgAOkP5eWIiIhMFDvSifJRdKT7udsbOZLCAn2qwt3eEkUl3lh7JgpBcw7iw82XcfnhM73HIZMJOH47AW+uOYe23x3GokN3kJyRA23pmkUA3O0tEehTVe/x6MO07vVhZ2mGq49TsP7MA2OHUybuxafit6P3AMgnGGWnGxEREVEFoEjrUjXg5bLqPQGIgKSzQFqUMaICMqL1W46IiMgI2JFOlM/16OcATHNEukQswoze8ol5CvZZi178DA+qiQbudsjKlWHL+Ufo+8sJ9Pn5OP489xCZOepvk8w/Ajs8MknjiOzk9Bz8fjwSwfP/xYjfz2DftVjkyQQE+VTFz8Oa4achzZRxFIwNAGb09jPZyRGdbC3w0YuJR+ftu4mE1Kwyj0HXdtAH5QSjeTJ0rOeMkIauBlsXEREREZUhRVoX53Yvl1m6As5t5X8/2lHWEclZueu3HBERkRFwCCLRC9m5MtyJk3ek+3nYGTka9bo1cseSEc0xY+c1xKa87Ox1s7fEjN5+6NbIHYIg4ELUM6w9/QC7/4vGf4+S8fGW//DN7usYFFADI17xgreTDQBg79VozNh5TVnPmJVn4Z6vLgC4+jgZa049wF+XHyMzRwYAsLUww2vNq2PEK16om29SVqlEpDU2UzYsyAubzj3E1ccp+HbPDfwwqGmZrVuXdtCnPVdjcOx2AszNxJjZmxOMEhEREVUYihHpLu2AGz+8XO75mjxtysNtQL13yz4u53aAdQ35xKJq86SL5M/n/wKAiIjIxLAjneiFO3GpyMkTYGdphuoOVsjQMILb2Lo1ckeb2k5oPHM/AGDV2JZoV8dZOdpbJBIhwMsRAV6O+KJnA/x57hHWnn6Ax88ysPx4JJYfj0T7us5o6G6Hpf/eLXQZG5OciclrL2B0ay9cfpSMi1HPlM/Vc62Cka280K9ZddhaFH77KCo2UyYRi/BV30bo/+tJbDn/CENaeqKFt+FT0ey9Go3Jay9obIclI5rrtTM9LSsXX73IaT+pg6/ySxUiIiIiKudS7wNpDwCRBKgWpPqcZ3/gwlR5Z3pmHGDpUraxiSVAwE/AsQFqnnzxWSFgobwcERGRiWJqFyqW9OxceE/bDe9pu5GenWvscPTq5USjdiY/Qjd/x3SgT1WNHdXVbC0wuaMvjn7cCSvGtECnes4QiYCjt+KxRE0nOiAfHyIAWHXyAS5GPYNUIkKfph7YPKkV9r7fDiNe8VLbiV7c2ExRs5qOGNLSEwDwxY6ryM2TGXR9eTIBs3ZFaGwHAJi1K0KvaV4WHbqN6ORMeFa1wlsdffVWLxEREREZWdy/8t9VWwJSW9XnbLzkedMFGfBoZ9nHBshHxdv5FV5uUQ1ot0X+PBERkQljRzrRC9fzdaRXNBKxCJ3ru2Ll2ED8+2En9G6q2wjnwS09cXLaq1g0tBlaelc1+S8Y9OHjbvXhYC3FjZjnWHPasBOPhkcmITo5U+PzAoDo5EyERybpZX134p7j92ORAICZvRvCUsoRP0REREQVhiKti2tH9c8rOqofbS+LaApLvQekRBRe7jWUnehERFQusCOd6IWIJ/KOdFPNj64vNatZI7iBbpNLtvatBucqFgaOyLRUtTHHxyH1AQDz999CXIrmju7SinuuW926ltNGEARM/+sacmUCghu44FUdjwEiIiIiKidiX4xId+mo/vkaLzqrYw4A2cllEpKKe3/If7t2Vl0ed7TsYymPctMg3WyOvmn9gNw0Y0dDRFQpsSOdCPJOxusxLzrSK+CI9IJcqljqtVxFM6SlJ5p6OuB5Vi7m7rlhsPXoun/P33+K5IycUq1r13/ROHk3ERZmYszo3bBUdRERERGRiUl7AKRFyvOjO7dWX8a+PmBXH5BlA0/+Kdv4BBkQ+aIj3Xu46nPP/gOy9HMHJhERkSGxI50I8vQZz9JzYCYWobaLbdEvKOcCfarC3d4SmhK1iAC421si0Mfwk22aIrFYhK/6NoRIBGy/+Bin7yUaZD1VbaQ65ZD/4/QDvDLnIKZt/Q9XHxd/9FBaVi6+fjHB6NudasOzqnWx6yAiIiITkpsGrBfJfzgylYCXo9GrtgCkVTSXU6RQebjN8DHlF3dM3tFvVgWo3vvl8ip1AQjySVCJiIhMHDvSifAyP7qvs22lyBstEYswo7d8op+C3biKxzN6+5WriUL1rUkNBwwLrAkAmP7XVeToeeLRwzfjMHDJKY0TiYpe/AwN9ER9tyrIyMnDxrMP0WvxcfT/9QS2X3yEzJw8ndb18+E7iHueBa9q1pjYvpb+NoKIiIiITENR+dEVFB3pT/4BcjMMGZGqyFXy316vA2b5BnW4tJP/jj1SdrEQERGVEDvSiVB58qPn162RO5aMaA4XO9Uc6G72llgyojm6NdJtQtKK7KOQeqhqY45bsalYdeK+XuoUBAHLj93DuFVn8TwrF4HeVTFvYBO4amiHua81wZ732mHzpFbo09QDUokIF6OeYeqmy2j97SF8u+cGHialF1pP/g76Nafkk6bO6sMJRomIiIgqpDhFfvQO2ss5NgesawJ56UDMfsPHBQA5qUDUZvnfPmNUn3NuK/+t+CKAiIjIhJkZOwAiUxDxYkR6A3ctt0FWQN0auaNNbSc0nim/iF41tiXa1XGu1CPR83OwNse0bvXx8db/sPDALfRu6gE3+5Lnjc/KzcOXO67iz3OPAACDW3jiq36NYG4mRrdGbhrbQSQSoaV3VbT0roq45w3w59mHWH8mCk+SM7H037v439G76FTPBSNf8UL7us4Ii4jBjJ3XlOuVCYCFmVjnEexEREREVI6kRQGp917kR2+jvaxIJB+VfnOhPL1Ljb6Gj+/hNnkKIltfeXx5+QaBOL8Ykf70MpD9FDB3NHw8REREJcQR6UR4mdrFz93eyJGUvfyd5oE+VdmJXsDAgBpoXtMBadl5+Hp3RInrSUzNwojlZ/DnuUcQi4Dpvfzw7YDGMDeTvw3r2g4uVSwxpXMdHP24E34bGYB2dZwgCMChG3EYu+osAuccwKS1FxCbkqXyuqxcGSavvYC9V6NLvA1EREREZIIUo9GrBgBSHe6wVaR3ebQTkJVuQnudRK6W//YZLe/Iz8/KDbCrB0CQ51EnIqLyQfZyoJ4o/rjK44qMHelU6aVm5eJ+onxURGUbkU5FE4tF+KpfI4hFwN//RePEnYRi13EjJgV9fj6Bs/efooqFGVaMaYk32vpAVPCDRDGYScTo2tANa8YF4fCHHTG+rQ/sLM2QmJqt9XWzdkVozMtOREREROWQrmldFJxaA5YuQM4zw+cmT3sAxB6S/11rlPoyLh3lv5knnYiofHi4Ddjtp3xodrw3sNO77CeyNgJ2pFOldzNGPhrd1c4C1WwtiihNlVFDD3uMauUNQD7xaHau7hOPhkXEYsCvJ/H4WQa8q1lj+9ut0bGei17j83GywRe9/LB4aDOt5QQA0cmZCI9M0uv6iYiIiMiIFB3Qig7pooglQI1+8r8N3ekRuUb+27UTYOOlvoziCwDFFwJERGS6Hm4Djg0EMh6rLk9/LF9ewTvT2ZFOlZ5yolH3yjPRKBXf1C514WRrgbvxafj9eGSR5QVBwK9H7mDimnNIy85Da99q2PF2G9R2MdxdD88ydLs1N+55psFiICIiIqIylPYQSL0LiMSAS1vdX1dDkd5lByDoPkikWAQBuKdI6zJGczlFR/rTi0D2M8PEQkREpSfLA86/B/kwvYJeLDv/foVO88KOdKr0IqKfAwAasCOdtLC3kuKzHvUBAIsO3saTZxkay2bm5GHqpkv4fu9NCAIw8hUvrH4jEA7W5gaN0aWKbhOh6lqOiIiIiEycYhS3o4750RVcOwFSeyAzBkg4bZjYEk4CqXcAM5uXednVsfYAqtQF86QTEZm4+GNA+iMtBQQg/aG8XAXFjnSq9CIUE416sCOdtOvfrDoCvasiIycPX/2tfuLRuJRMDPntNHZcegKJWISv+jbEV/0aQSox/NttoE9VuNtbQlPmdREAd3tLBPpUNXgsRERERFQGFB3prjrmR1eQmAPVe8v/NtRt+PdWyX/XHARIbbWXVaZ3OWKYWIiIqPQyovVbrhxiRzpVankyQZkjnSPSqSgikQiz+zWERCzCnqsxOHozXvlceGQSLj98hr6/nMClh89gbyXFmjcCMfJFbvWyIBGLMKO3fMKPgp3pisczevtBIi75JKdEREREZEKKmx89P8/+8t8Pt8nTsOhTbjoQ9af8b5/RRZd37Sj/zTzpRESmy8pdv+XKIXakU6UWmZCGzBwZrKQSeFezMXY4VA7Ud7PDmNbeAIC3N1xULh+z8iz6/nIC0cmZ8HW2wV9vt0Hr2k5lHl+3Ru5YMqI5XOxUJ851s7fEkhHN0a1Rxf2HRkRERFSppD+Wp04RiQHnYuRHV3APASRWQFok8OyyfmN7tAPISQFsvAGX9kWXZ550yi83DVgvkv/kphk7GiJScG4HWNdA4aF7+Vg4y8tVUOxIp0rt+ou0LvXcqnCULums0Ys0QHky9SN33u5UG95OxvtiplsjdxwIfXl776qxLXH8k87sRCciIiKqSJT50ZsB5vbFf72ZDeDeTf63vtO7KNK6+IyWd/QXxbo6YFtbPvFp/HH9xkJERPohlgABP2kvk5308o6kCogd6VSpMT86FVeeTMD3+25qfF4EYN6+mxo72ctK/i+GAn2q8osiIiIiooqmNGldFBSTgOqzIz39ERBzQP53rVG6v47pXYiITJ/na4DXkMLLrWoATq0BIQ84OQy4/mPZx1YG2JFOlZpiRDrzo5OuwiOTEJ2cqfF5AUB0cibCI5PKLijSG2tzM9z/tifuf9sT1uZmxg6HiIiISDPFxJyKDuiSqN4LEJkBydeAFM2DRYolcg0AQZ7SxbaW7q9TfCGg+IKAiIhMjyAASedUFuW23QX0vQ90OQbUe0++8OKHwPlQ+Z1GFQg70qlSi3jyYkQ6O9JJR3HPNXeil6Qcka6szc1w+6uu+KlVLjv5iYiIKrv0J8Dz2yXPj65g7gC4vSr/++H20sclCEDkavnfukwymp+rIk/6BSA7ufSxEBGR/iWckv//MXuZzlZwbitP+yISA80XAM3myZ+4uQA4MQzIyzJSsPrHjnSqtBJSsxD3PAsiEVDfrYqxw6FywqWKpV7LVUYc9U1ERGRiOLFf+aNIf+LgL+8MLw19pndJPCMf2S6xBmoOKt5rrWsAtr4v8qSfKH0sRESkf4o5MGr0U/+8SAQ0+BBovQ4QS4GoTcDhbhXmC1L2YFClpUjr4l3NBjYWPBVIN4E+VeFub4mY5Eyoy4IuAuBmb4lAn6plHRqZGMUXBpVBZdrWykLfbcpjhIhIz/SR1kWhel8Ak4Cks0DaQ8DGs+R13XsxGt3zNUBagsFKrh2B1Lvy7aveo+RxEBGR/uVmyDvGAcB7OHB/neay3sMAS1fgaH/5e/qBdkDHPfLJpcsxjkinSutlfnSORifdScQizOjtB0DeaZ6f4vGM3n6c3JOIiMqtX375Bd7e3rC0tERQUBDCw8N1et3GjRshEonQr18/leVjxoyBSCRS+enWrZsBIieqRPQx0aiClevL9DCPdpS8nrxM4MFG+d+1xpSsjpLkSecdFUREZePRDiAnBbDx1i2tmNurQJejgKUb8OwKsL8VkHzd0FEaFDvSqdJifnQqqW6N3LFkRHO42FmoLHezt8SSEc3RrZG7kSIjIiIqnU2bNiE0NBQzZszAhQsX0LRpU4SEhCAuLk7r6+7fv48PP/wQ7dq1U/t8t27dEB0drfzZsGGDIcInqhwyooHntwCIABf151yx6SO9y6OdQM4zwNoTcO1UsjpcFHnSz8s7a4iIyHQo0rr4jJLnQ9eFoz/Q9RRgVw9IfwiEtQHijhsqQoNjRzpVGOnZufCethve03YjPTu3yPIRyhHp7Ein4uvWyB0HQjsoH68a2xLHP+nMTnQiIirX5s+fjwkTJmDs2LHw8/PD0qVLYW1tjRUrVmh8TV5eHoYPH45Zs2ahVq1aastYWFjAzc1N+ePo6GioTSCq+GJf5Ed39C99fnQFRa7b+KNAZnzJ6ihJB0tBNp6AbS3mSSciMjXpj4HYA/K/fUYV77W23kCXE0C1V4Dsp8DhLvqZ4NoImBiaKqXMnDzcjZff9ufnob4j3drcDLe/6op//vmHEyKSWvnTtwT6VGU6FyIiKteys7Nx/vx5fPrpp8plYrEYwcHBOHXqlMbXzZ49Gy4uLhg3bhyOHTumtsyRI0fg4uICR0dHdO7cGV9//TWqVaumsc6srCxkZWUpH6ekyAdA5OTkICcnp7ibVmKKdZXlOnWSmwPpiz9zcnIAoZTx6bM+Q8dmZkKx6VMxYhPHHIIEQJ5Te8g0HZvF3VaL6jBzaAbRs4vIjdoOwWes9voKtkPGE5hF74MIQI7nMEDbOVNEbBKn9hCn3kNe9EHInIO1x61DfcVSno6R0pwL6uozpf1WnmIzpfek8rTf2A7lLjbx3VWQCDLInNoiz7ImkJNWvDYQ2wHt90JyZgTET/6GcGwAZM1+gqz2pFLHVlrFuc4zqd7BX375BfPmzUNMTAyaNm2KxYsXIzAwUG3Zjh074t9//y20vEePHti9ezcAeT7G1atXqzwfEhKCvXv36j94Kldux6YiTybA0VoKNztLY4dDREREZHQJCQnIy8uDq6urynJXV1fcuHFD7WuOHz+O33//HZcuXdJYb7du3fDaa6/Bx8cHd+/exWeffYbu3bvj1KlTkEgkal8zd+5czJo1q9Dy/fv3w9raWveN0pOwsLAyX6c2EiETvV78vW/fPuSJSnc9q8/6DBnboUOHTCo2fSpObJ3T/0EVAOeibBDz5J9S16dQN9sPDXARCRd/w5nrqu8DRbVD7eztaAgZEsX1cfzYbQC3Na6nqNg8c+zRHEDK7Z04+qjo1DWmfPzqkz7PBQCQyNKV9Z37Zz7iJP6ASP17cnFiq/DvSfn22+WwxdxvxqqP7VC29QkCOmcsRRUAl1P8EfXPPyV+TxIJY9HELBveufshufgu7l49iuvS4ZAIGXp7Tyqu9PR0ncuaTEe6Ih/j0qVLERQUhIULFyIkJAQ3b96Ei4tLofLbtm1Ddna28nFiYiKaNm2KQYMGqZTr1q0bVq5cqXxsYaGa05gqp+v50rqIRBxFTFReWZub4f63PY0dBlUSvFOJSNXz588xcuRILFu2DE5OThrLDRkyRPl348aN0aRJE/j6+uLIkSN49dVX1b7m008/RWhoqPJxSkoKPD090bVrV9jZlV1avpycHISFhaFLly6QSqVFv6Cs5KYBL+6IDgkJAcxsTKc+A8bWuXNnSK0cTCc2fdI1tswYSHc9hgARmnd7DzDXkCapJNua4gPsWwdX4Qp6dGkDSO3V1leoHQQBZvs/BXIA+2bvoUetHtrXU1RsaQ2Bf36Cg3APPbq0A6RVSldfcZSTY6S054Lo0XZILn6ofNwq6ysIVtWR13Q+hBr9SxVbRX5P4n4zjdjYDmUfmygxHGaHHkGQWKFRj5loJLUr3XuS0At51+dAcm0W6uZsQW2HeIiev/wCttRtWkyKOx91YTKfAvPnYwSApUuXYvfu3VixYgWmTZtWqHzVqlVVHm/cuBHW1taFOtIV+RiJ8lPkR+dEo0RERERyTk5OkEgkiI2NVVkeGxur9nr67t27uH//Pnr37q1cJpPJAABmZma4efMmfH19C72uVq1acHJywp07dzR2pFtYWKgdACOVSo3SoW2s9WokehmLVCoFzEoZmz7rM3BspWoHfcemT7rG9uSkvLhjU0htCg84K3Z9+VVrAtjVhyjlBqRxYYD3UI31qbRD4jkg5TogsYSZz1CgqDYqKjaH2oCND0RpkZA+Cwc8upWuvuIoR8dIic+Fh9uAU0MACKrVZzyB2akhQLstLyefLWFsFfI9ifutNJGxHUyhrtLU93Cd/OWeAyC1rqa2rmK/JzWdCdh6AmcmQhxfOONIqdq0mIoTu0lMNqrIxxgc/DL/mS75GPP7/fffMWTIENjYqH6bosjHWK9ePUyePBmJiYl6jZ3KJ040SkRERKTK3NwcAQEBOHjwoHKZTCbDwYMH0apVq0Ll69evjytXruDSpUvKnz59+qBTp064dOkSPD091a7n0aNHSExMhLs7J+gmKrbYI/LfLh0NU7+is+LhNt1fo5hktEZ/wNxea1GduXaU/447op/6SE6WB5x/DwU7IeVeLDv/vrwcvcT9ZhrYDsaRlwnc3yD/u9YY/dbtMwYwr6rhSdNsU5MYkV6SfIz5hYeH4+rVq/j9999VlpckHyMnNtIuJyc33985yBGpewPTXWbWy+07eTsObWs7lXjCRl1jEwRBmdqlrou11n1cGdpB321quNhyS90O5WdbTTm20rcDlZy+3pP0fbzpkymfC4o68v8uXV2m2w6mrqK0gym+n4aGhmL06NFo0aIFAgMDsXDhQqSlpSnvGh01ahSqV6+OuXPnwtLSEo0aNVJ5vYODAwAol6empmLWrFkYMGAA3NzccPfuXXz88ceoXbu2/JZiIiqeuBej9lw6GKZ+z9eAa3OA6D1AbgZgZqW9fF4W8OBFB4vPaP3F4dIBuLfy5RcHpB/xx4D0R1oKCED6Q3k5xZcZxP1mKtgOxvF4F5DzDLD2BFw76bfu+GNAdoKWAqbXpibRkV5av//+Oxo3blxoYtKS5GPkxEbaZeUBisNm3779sChF3v/LiSJsvS8GIO84H7/mIhzMBbzmLUPTasX/EKtrbImZwPNMM0hEAm6dO4Z7OtyXUZHbQZ91GTK2Q4cOmVRs+q6vvMSmj3ag0ivte5K+jzd9MuVzIT99/F8w5XYoL8p7OxRnYqOyMnjwYMTHx2P69OmIiYmBv78/9u7dqxzwEhUVBbFY95taJRIJ/vvvP6xevRrPnj2Dh4cHunbtiq+++opzFxEVV0asPIUKRIBLe8Osw7E5YF0TSI8CYsKAGn20l3/8N5CdBFh5AG7B2ssWh+KLgqRzQE4qILXVX92VWUa0fstVFrruj/THho2jMku5BVz7RreyPH71S3HXkc8oQKTnxCbl8D3JJDrSi5uPMb+0tDRs3LgRs2fPLnI9uuRj5MRG2qVn5+Lj8EMAgJCQriWebG3ftVisPHW50A05ydkirLwlweIhTRHS0FXta0sbW1hEHHDxEuq62qFPr8K3KedX0dtB33UZMrbOnTvD3qZ0M1SXl2015dj00Q5Ucvp8T+rfu+gyxmDK5wKg//8LptoOpk6f7aDvY6Q4ijOxUVmaMmUKpkyZova5I0eOaH3tqlWrVB5bWVlh3759eoqMqJJTjEZ3aAJYaLoVvpREIvmo9JsL5eldiupIj1wt/+0zEhDr8ZtIW2/AxhtIuw/EnwA8eAeLXljpmFJL13KVhYWzbuUufghkJwK13uCXP/ogCEDcUeDGj/Iv7dSmdFGDx6/+ZEQD0Xvlf/uM0n/95fA9ySQ60vPnY+zXrx+Al/kYNV3EK2zevBlZWVkYMWJEkevRJR8jJzbSTiq8TLsij634h1CeTMA3e25qzGolAvDNnpvo3qR6sdK86Brbrfg0AICfh73O+7YitoOCvVSK+9/21EdY8nj0GJtqXWalbgN9xqbv+spPbKVvByo9U3tP0idTPhdU6q3AbVCe6KMdDHWM6LRuHkNEVByKfOGGvr1d0ZH+eCcgywHEGt6rMmKBJ//I/9ZnWhcFlw5A5H35drMjXT+c2wESGyAvTUMBEWBdQ16O5HJSgevzdCgoAjJj5Dm8/5sO1H4TqPeOfH9S8chygKjNwPUfgacXXi736AUkngGyEqC+U53Hr97dXwcIMsCpNWBXV//1O7eTt1n6Y5SXNjWJyUYBeT7GZcuWYfXq1bh+/TomT55cKB/jp59+Wuh1v//+O/r164dq1aqpLE9NTcVHH32E06dP4/79+zh48CD69u3LfIwmIDwyCdHJmRqfFwBEJ2ciPDLJIOuPeCIf/eXnwYlGiYiIiEiD3DRIN5ujb1o/IFdTpxNRGTJ0fnQFp9aApQuQ/fTlOtW5vw4Q8oBqQYB9A/3HoZxwVEsMVDxRm7R0or8QsFC/dxeUZxmxwMGOQMx+QGz+YmHBwX4i+U/rtUDLX4EqdYCcZOD698BfPsDJEUDSBaiVfwLFuKMmNaGi3umyrdlPgQjFfhsu70SXWAK1JwG9bgAddwGBS18U1jDo0hSOX322qzGPEUF4mdallgG+LAXkbRXw04sH6s4tmEab5mMyHemDBw/GDz/8gOnTp8Pf3x+XLl0qlI8xOlo1J87Nmzdx/PhxjBs3rlB9inyMffr0Qd26dTFu3DgEBATg2LFjzMdoZHHPNXeil6RccV2PkXekN3CvYpD6iYiIiIiI9CozDkiOkP9tqPzoCmIJUL2v/O+H29SXEQQgcpX8b0N1sLh0lP9OPCsfFUylk3ILCH9T/rfnQMCqeoECIqDVKvkdCQQ8vwOEtQaSzgMWTkDwMaDdVvl8APlZ1wDabQG8hwF1Jss7fNvvlH/hJeTKv3DaGwAc6Ag82ikf3QvIz63dfi/rOdID2Omt+Zwrz4ra1tR7wLn3gB2ewKVPgIzHgKUr0OQroO9DIHAJYFdPXtbzNfn+LtgOIinQdrPxj199tquxj5GnF4Dka/IvM2q+brj1aGpTxbll7DYtwCRSuygUNx9jvXr1IAjqcyQxH6PpcqmiW35lXcsVR0pmDh4mZQAA/Nw5Ip2IiIiIiMoBlfzo1bSX1QfP14C7y4CH24EWPxd+/ukl4NkV+ShdryGGicHWG7DxAtIeAAknAfeuhllPZZCXCRx/HchNlXfwttkov9Nmi738eUU++owYY0ZpOhLCgX97AVnxgI0P0GkfYFcHQCDgGqzcb7ltd8GsRnfV0bIiMVCjt/wn6TxwYwHwYJP8HI77Vz5i3aUjcHc5CqWySH8MHBtokp2HJfZwm3yb1G7rAPkdLUlnX37B4NAYqB8KeA0FJBoGwXq+ptIOgtgcIlm2/AsPY9K6rcVsV33WVVKK0eg1+gPmDoZdV4E2Rcd/ALeuJjUSXcFkRqRT5RHg5QgLM82HngiAu70lAn30P4HOjejnAAAPe0s4WJsXUZqIiIiIiMgExJZRWhcF186A1E6e8znhdOHnFZOM1ugLmDsaLg7F9jK9S+mcnwo8uyyfNLP1ennnVP4OKr9p8t83FwF52caJ0VQ8/gc42Eneie7YHOh66kUn+gv59pvg3FZ7R1/VAHnKl76RQIOPAak98Py2/EsqjbPGATj/fsVI8yLLk+eM17atiWfkneju3YBO+4Hul4FaYzR3oivk2+8yr+HyP278qI+oS0aXbdW1XfVZV0nlZQH318v/NsQcGOrkP5dc2ptkJzpgYiPSqXJYeOAWsnJlWsvM6O1XrIlGdRXxJBkA86MTERGRnLW5mV4n3SYiMoiymmhUQWIOVO8tT0vxcBvg2PTlc7Js+XIA8Blj2DhcOgKRfwCxRwy7norswZ/AnRd5pVutAaw9CpepOQi4MlOeUiPqT8BnRJmGaDLurgDCJ8pz/7uHyFOFSPWQEta6BtDsO6DRl8Dlz4Bbi7UUFoD0h0D8sbI73w0l/hiQ/qjockErAN+xJV6NzHcyJJErgce7gJSbL9PAlKUit/VFu54YXPQEtOmPdKvLkMfIk91AdpI83YpbsGHWUU6VakS6t7c3Zs+ejaioKH3FQxXc3/89wa9H7gIA3mjjDVc71W8ZpRIRloxojm6N3A2y/usvRqQ3YFoXIiIiqiB4TU5UwWXGyfPUAoCzgfOj56dIG/Bwmzwn+guimANAVgJg6Wb4dCuKTqLEcE76WxLP7wBnxsv/9vsU8AhRX05iAdR9kWb3xnyV9q4UBAG4+jVwZpy8E91nFNBhl3460fOT2gJOrXQrmxFddBlTp+s2SEqZ1rdKHfkXfwBwY2Hp6iopXbf14Vbg5k/afx5u1e86S+Lei7uOfEaa7MhwYylVR/r777+Pbdu2oVatWujSpQs2btyIrKwsfcVGFcz16BR8tPk/AMDE9rUwvXdDHAh9eWuiWATk5AnwdrIxWAwR0fKJRpkfnYiIiCoKXpMTVXBxR+W/7RsBlmWYA9g9BJBYAWmRQPJV5WJxlOJ2/xGA2MA3udt4A9ae8kkb408adl0VTV4WcHwwkPsccG4LNJmtvXydSfL2fnrx5R0QlYEsDzj7FvDfl/LHfp8Cr6wCxFLDrM9Kx0GDupYzZWW5rfU/kP+OXAVkJpS+vuLSdRu8hwMNP9P+4z1cv+ssroxY+Yh0oOzSupQjpe5Iv3TpEsLDw9GgQQO88847cHd3x5QpU3DhwgV9xUillJ6dC+9pu+E9bTfSs3ONEsPTtGxMXHMOGTl5aFfHCR+HyG+1yZ++JdjPFQCw/oxhRlPl5slwM5Yj0omIiKhi4TU5UQWnyA9e1mkezGzkeYsB4NFfysWimH3yP8qig0Ukkqd3AZgnvbgufgg8vSCfnLbNhqK/9LCoBtR6kV7juhFzTZel3HTg+IAXqW9EQMBiwH+O/LgzFOd2L1J7aFmHhZO8XHln31A+IbFGIvkXZfrYVpf28pz2eZnA7SWlr6+4nNsBVtpStrzY1ldWA02/0f7zyuoijhE97jd1HqyX35lRLRCwb2CYdZRjeplstHnz5li0aBGePHmCGTNmYPny5WjZsiX8/f2xYsUKCJXttiBSkZsnw7sbL+JhUgZqVrXG4qHNYCYpfOi93sITALD9wmODdPjfS0hDdq4MNuYS1Kxqrff6iUpDkaP3/rc9YW3O6SuIiKj4eE1OVEEp8oMrOpTLkiK9y+OdykUiIVc+iaJDo7KJQfEFQmUaJV1aUVuBWz/L/261puiczAr13gcgko9GTb5hqOhMQ1YicChY/iWR2EKeD73eFMOvVywBAn568UBDR2lWEnB/jeFjMaS0KOBAB/mcCmq92PaAhfpJHSISAQ1ejEq//bO8Q70siSXylEBqFXNbizxGBKD5AsOlXFGkdak1xjD1l3N66UjPycnBn3/+iT59+uCDDz5AixYtsHz5cgwYMACfffYZhg/X8bYEqpC+33cTx24nwEoqwW+jAuBgrf4byVd8qqJmVWs8z8rF35f1n+sp4ok8rUsDdzuIDTCRKREREZEx8ZqcqALKTHiZVsWlDPOjK1TvBYjMgOQI1eXemjqMDMDlRTrQxHD5CGJDkuW9/DvuqOrj8iL1njzXNwA0+Bjw6K77a+3qADX6yP++uUD/sRmDujZNvQ+EtQESTv2fvfuOjqpa+zj+nfRCCpCEJBBCKNKLBokICCIQELkgNkClqOirYMu1oVcRRLGLer2iXkVUUJSr2CmCqEhTinSkRVrohkBC6pz3j0MGhhSSzExmkvw+a2XlzJl99tln9kyy55k9zwbfcOi5ABpeU3ltihsM3WabCzmeLbDB6XUQrLB8FGx8pmrmq09fD/MvhYzNEFjfDPoG1rcvE9TAfAwKP6xzhobXmfVmH4LUmc6rtyys+bD3C3Pbp5b9fRW51pKeI4XKsohrRfy9FtL/ML9JED/ENeeo4hwKpK9evdruq6OtW7dmw4YNLFmyhFGjRvH444/zww8/8MUXXzirvVLFfLl2H2//vBOAl65vT4voklOqeHlZGNqpIQAzVjo/vcvmtDOBdBEREZHqQmNykWrscGF+9NYQEFn55/cLN3Ozn2vzc+YipJWhVmMzEGXNMwOfrrLnc/i21Znbi6+ErxpV3nU6Q2Fe9LzjEHEptJ9U/jpsuaY/gOzDzm1fZSuuT+fUh7kXQsZW83nVewlEuSGNStxg6H/WB1Q9voOBqdBrMbR6xNz3x2Pw+9iq9YHOwcWwoCuc2mf+3eqzDFrcV/Ra/7HLuUF0MPPaX3CPuV3Zi+bueMf84MC/LvTfeGa/I9da3HPkotMz1dc+CEd/c6zNxSmcjd5gIPjVdn791YBDgfSLL76Ybdu28eabb7Jv3z5efPFFWrRoYVcmISGBIUP0KUZNtGHfcR6abS4uOubyJlzZ9vwLIVzXsQG+3hb+2JPOxv3Hndoe20KjsQqki4iISPWhMblINebOtC5gBiLT1xbdfyoNfrm2coLMZ+dJL3w8nG3P5+b1nNpnvz9rX+VdpzOsfRiO/W4GwLp8XLEFMyO7Qp2O7ss17Swl9Wn2QchNN3NM91kG4a3d0jzAPjVH1GXmbYsFOkw287VjgW3/gSXXQf4ptzWzzP76FH5MhrwMM393718g2EzhW+y1ukLT0eaM8OMbIW2+a85xrrwMWDfe3G7zpBlML+TotZ77uDW/2wywW/PMD81y0yte97mseZA6w9xOGOm8eqsZhwLpO3fuZO7cuVx33XX4+hb/Bzo4OJhp06Y5chqpgo6ezOGOD1eRk2+lR/NIUno3L9NxEbX86dM6GnDuoqOGYdildhERERGpLjQmF6nGCvOCV/ZCo2DOgl11bwl3np7pueq+ypkt68o86bbrLG72aiVfpyP2zIGtp2erXjIdghtWrB6L5cys9G1vVH6uaWcotU9PM6wQcP7Jfm7TfCx0/dTM3773C/ixt5k73VNteRV+HWLmRI+7BnrOd8+MZr9waHLb6TZV0qK5GydDzmEIbQ7N7nDtuSwWSHoXghMgcxesuM15M+/3f29eR0A0xPRxTp3VkEOB9EOHDrFixYoi+1esWMHvv//uSNVSheUVWBkzczX70k+REBHMq0MuxLscOclvPJ3e5cu1+8nMcc6io4dP5HA0MxcvCzSvF+KUOkVExPm08K5I+WlMLlJN5Rw1cw2De/KjH/7lPHl4DcjaY5ZzNVfmSfek66yok6lmTm0wg+ANBjhWX8NrzBnb2Ydg10cON6/SnbdPMWeqe3KfAjS81gxI+4bB4V/NlCmZzk+D6xDDCmsehNX3AQZcMBa6zALvAPe1qfm9YPGCAwvg73WuPdfJVNhyej2BDi9U7Fsg5eUXDl1nmefa8z/zWwvOsPN983fCTeCl92ElcSiQPmbMGPbs2VNk/759+xgzZowjVUsV9vS3m1m+8xjBft68fXMiYYHl+0PSuUldEiKCOZmTz1d/7HdKmwrTuiREBBPo56KvEImIiMdRYF5qAo3JRaqpQ4X50VtBQFTln/9UmnPLOaJWE3OxQmsuHFnu3Lo96ToroiDXnAmclw51k8y0II7y8jWDkVD5uaadoar36dmiLjPzuAc1MHNwz+/s+uBwWRXkwtKbYfOL5u0Oz0Lia65L21JWtRqZs+LB9Yvm/vEoWHOg3uXm4syVpe7F0OF5c3t1Chxb7Vh92Udg/zfmdsIIx+qq5hwKpG/atImLLrqoyP4LL7yQTZs2FXOEVHef/b6H95emAvDyDR1oVoHZ3xaLhaGdzDxazkrvciY/ephT6hMRERHxFBqTi1RT7s6PHljGtBdlLecIi8V16V086Tor4o9H4egK8A2HLp84b0Zsk9vAJ8QM3qbNdU6dlaWq9+m5wttA76Xm4p2n9sMP3eDgj+5tU16GuXjrXzPB4gOdP4BWD5uvVU9QmJ4odYbrPjA5sgL++hiwwIUvVf61N7/XXBTUmgtLrjf7pKL++tjMkV4n0Xy+SYkcCqT7+/tz8ODBIvvT0tLw8dGsr5pm7Z50HpuzAYB7r2hG8ulc5xVxbWIcft5erN93nPV7HV90dHPaCQBaxiiti4iIiFQvGpOLVFPuzI8O5mKBQQ2AkoJDFjP9R2S3ymlPYXoXZy84GtnNnO1eokq+zvLY982ZPNCXTDNn4jqLX9iZXNObKynXtLNEdoPABqUU8OA+LUlwnDkzPeoyM2D6Y1/4a5Z72nIqDRZcBgcXgk8w9PgWEm52T1tKEpEEkV3M4PCf/3Z+/YZhzgQHaDwC6lzo/HOcj8UCSe9BUEM4uQNWjK74t0dsaV1GOqt11ZZDgfQ+ffowbtw4jh8/E+hMT0/n0UcfpXfv3g43TqqOQyey+b8PV5Gbb6VXy3rce0Uzh+qrE+xH3zanFx1d+ZfD7du033yOttJCoyIiIlLNaEwuUg3lHDuTHz3SDfnRwUzPkHh68coiwfTTtxOnVF4ah8KZ+UdXQP4p59Xr5W0uElgio3Kvs6wy98Cy0ykYmt8LcYOcf44W94LF2wyY/v2H8+t3FS9viEku4U43PHedxS8cLp8Hcdeas5B/HXImP3dlydhqppdJ/8NMOdXrJ89dmLLF6UD3tqmQn+ncuvf8D44sBe8gaDfJuXWXh38dM1+6xQd2fwrb3yp/Henr4e/V5rdZGg11fhurGYcC6S+++CJ79uwhPj6eyy+/nMsvv5yEhAQOHDjASy9VsU8spcJy863c9dFqDmRk0yQymFduaI9XORYXLcmwpDOLjp7IzqtwPadyC9h1xPyjqUC6iIiIVDcak4tUQ4d+BgwIbQmB9dzXjrjB0G02BMba7w9qYO6PG1x5bQlparbDmgtHnZgnfddHcHARYAH/iKL3h7aCBlc773wVZS2wbVoOLYYlN0DuMajT8UyuZGcLjjeDtmDmSq8qjq2C1A/Nbd9z0ru647nrTN4BZgqfC+42b69OgdUPmIt+nvUc4dDP9rfLq7i6Di+D+ZdC5l8Q0gz6LDNTgXiq+gPN9RVyj8HO6c6rtyAH1j5sbrd8AIJK+0ZLJYi45MzaCKvug7/Xlu/4wsem/gDwr+vMllVLDgXS69evz7p163j++edp1aoViYmJvPrqq6xfv564uDhntVE83ISvN/L7X38T4u/DO8M7EhLgnJxsSQl1aBIZTFZuAV+urfiio1sPnsBqQEQtPyJD/J3SNhERERFPoTG5SDXk7rQuZ4sbDP3PrLeQ3/Vr+Meuyg9EWizOT+9yfAv89n/mdtvxMGDHmfsumQ5e/pCxCfZ+6ZzzVdSez+HbVrabPr9eDUeXgXegORvV28915y6c1fvXx5BV8ffllSb3uJkv2poLDQbBwLO+4d7jO/c8d52t8NsiHZ4zb295CX7oDt+2PFNm8ZXwVSPzuVNe5zzfWHwlfF4PFnY3g9J1O0HvX6FWY4cuw+W8vKH5feb2llcc+2DhbH/+G07uNHPst3zQOXU6qkUKxF5lLny65HrIO1G246z5kPqRua1FRsvE4aSJwcHB3H777c5oi1QBBdYz+ZZW7jrGvvRTzFixG4sFXh3agcaRtZx2LnPR0YZM+nYzM1fs5sakhlgqsHjD5tMLjbaMCa3Q8SIiIiKeTmNykWrm0E/m78LAsbudlQLDiOzqvpQY9XqYAd3Cx8cR+afg1+vNlA/1ekLrf4E1+8z9Da+BE3/CxqdhzYMQe6VrA9Yl2fM5/HItUEzu44JT5uxTVwY0IzpBZFc4vMQMIHZ4xnXncpRhwMrRZpAzOB4ueQ+8zgp7RV1W9dK5lMRigVYPmcHcZSPN/jlX1j7zuVOeGfglPd9yj5q/a18EVywyc6NXBY1HwrrH4eR22Pe14ymQco7ChtOpXNpNAl/nxcAcYvGCzu/D9xfCiW2w8v/g0o/OvwBq2jzIPgj+kRDbr1KaWtU5ZfWhTZs2sXv3bnJzc+32/+Mf/3BG9eIh5m5IY/xXG223R077zbb9z94X0LOF879yeG1iA56ft5VNaRn8sfc4HeLCy13Hpv1mIF1pXURERKQ605hcpJrIOXYmH7WnBNKdyScYhlVwQbzCPOlHlkNBtpnmoqJW32fmBg6IgktnmAFW6zllWj0MO/5rBuG2vWnmDK9M1gJYdS/FBtEBsJipHOoPdG2AuMU/zUDt9qnQ5jHPDaJunwq7PzPzRXeZBX61nZ8b29PEDzPTu+QcKeZOA7DA72Ohdgcz331pjAL4bSwlP9+AnEPg5cDrrrL51oJm/webnjXTEzkaSF8/EfLSIbyd583g9q9rpv354TL4aybUuxya3lb6MbtOp3VpdKOZI13Oy6FA+s6dO7n66qtZv349FosF4/TqsIWzfgsKnPS1CXG7uRvSuPOj1SX+OW3ixJnoZwsP8qN/2xi+WLOPmSv+qlAg/ewZ6SIiIiLVjcbkItXMkaWY+dFbQGC0u1vjWUKamTNwT6WZwfSKpr5J/Ri2vw1YzCB6SY+zbwi0mwgr74ANEyDhZnNxv8py+BfI2ltKAQOy9pjlXJkGqP4AM9f0yR2wYxo0H+u6c1XU32th1f3mdodnISLJrc2pNId/KSGIXsgwXy9fNXHO+bL2uv755mwX3G2mvzn8Cxz9DepeXLF6Mv6Ebf8xty96yTO/3RB5KbR/GtY+AqvuNl8H4W2LL5tz7EzaqsYjK62JVZ1DOdLvvfdeEhISOHToEEFBQWzcuJGff/6Zjh07snjxYic1UdytwGow4etNpX0GzsRvNtmlfXGmwkVHv/4jjYxyLjpqtRq2QHqrWAXSRUREpPrRmFykmjn0i/m7cPa1nHF2nvSKpnfJ+BNWnk6F1eZfEN2r9PKNb4GwNpD795mUDpXlVJpzy1WUlze0OB2k3urEXNPOknfidF70HDNPdGFe95qgrH1v8TVz6pf2YynjjGRXP9+cLSgWGg4xtzc7sAj72ofAyIfY/uf/u+FOLR+EmH7mt3aWXA95J4svt+d/5loCtTtA7faV2sSqzKFA+rJly5g4cSIRERF4eXnh5eVF165dmTx5Mvfcc4+z2ihutnLXMdKOZ5d4vwGkHc9m5a5jLjl/x/jaNIuqxam8Auas2VeuY/f8nUVmbgF+Pl40jvDQr5+JiIiIOEBjcpFqpjDXcXVM6+IMhR8wVGTB0cLAUv5J8/FtM/78x3j5wIUvmtvb/g0ntpf/vBUVGOPcco5oPNJMlXJyJ+z7yvXnKyvDML8xcGIbBMWZeaJr0tpoZe37nvPhhqzSf3rOd+45PUnLf5q/98yGzL9KL1ucg4vN2dsWb7jwBac2zeksXtB5OgTGQsYW+O0u83VyrtQZ5m9PS1Hj4RwKpBcUFBASEgJAREQE+/ebKzjHx8ezdetWx1snHuHQiZKD6BUpV14Wi8U2K33mit22ryuXRWF+9Ob1QvDxdujpLiIiIuKRNCYXqWbS15m/6ymQXqzClBJHlpmB8fJYnQLpf5gL6106s+ypGWKTISYZrHlmyoTKEtkNAkoLWlrM4HFkN9e3xScYmv6fub3FgVm9zrbjHXMBWou3mR/av667W1S5IrtBUAPMXAHFKcdzxJl1eZra7aHeFWYe+K2vle9YwwqrTwfim94BYS2d3z5nC4iELh+bQfXUD2Hn+0XLHPvdXE+g0bBKb15V5lBksU2bNvzxh7kISlJSEs8//zy//vorEydOpHFjF64aLZUqKqRsC0mUtVxFDL6wAf4+Xmw5cILVu9PLfNymNC00KiIiItWbxuQi1Y0Boc2r5qzPyhByAQTUM9N4HFlR9uP++tRcMBSg84dmuofyuPBFMyi1539n0u9UBr+ScrKfDnYmTqm8XM0XjDUXJDz8a/kee1f5e93pxViB9s+Y+aFrGi9vSHz19I1zA+DlfI44sy5PVJjyZ/s7kHu87Mft+gj+Xg2+odD2SZc0zSWiLoO2E83t38dA+saiZWKvNBdcljJzKJD+r3/9C6vVXNZ64sSJ7Nq1i27duvHdd9/x2mvl/IRHPFanhDrEhAWU9pkkMWEBdEpw3aIrYUG+XNXOHOjMXLG7zMedWWg0xCXtkqolyM+H1Gf7k/psf4L8HFpruUYJ8vNh21N9eLVzvh43EREPpDG5VGtn5WK2HF7iebmZneXc66qKMz4ri8VyJr1LWfOkn9gBK24zt1uNM2eYl1d4G2hyuo7V/zRnqbrahomQsRG8AswPD84W1AC6zYa4wa5vh+2csRB/evbqlpcr77zFyTsJv15vfishph+0fMC97XGnuMHmcyHwnA+HKvIccWZdnia2L4S2hPwTsOPdsh2TnwV/PGput37MnOldlbQeB9G9oeCU+XrJy7C/P+Fm97SrCnMokJ6cnMzgweaLqGnTpmzZsoUjR45w6NAhevbs6ZQGivt5e1kYP6BVsfcVBtfHD2iFt5dr85AVpnf5Zt1+jmeVbdHRwtQurWLDXNYuEREREXfSmFyqrT2fw7dn3of4LBkAXzUy91cn51ynbV91u05nKkzvcmjx+csW5JzOi34CIrtCu4kVP2/bieBTC479Bn99cv7y+Zkw02L+5GeW71wHfoANT5nbl7wLV/15ptquX8M/drknqFm46Oie2XAytfLPD2a+59/uhIytEFgfOn9gflugJosbDP03nbnd47uKP0ecWZcnsXidmZW+9VWw5p//mM0vwal9EBwPzavgujMWL/MbOAHRcHwTfNXU/v5V9+l/TTlV+C9NXl4ePj4+bNiwwW5/nTp1sNSkhR1qiL5tYnjzpovwOSdYHh0WwJs3XUTfNq7/2uFFDcNpER1CTr6Vz9fsPW/59Kxc9p9eJLWFZqSLiIhINaQxuVRbez6HX641Axhny9pn7q8ub/xLus7cv6vXdTpb4UKsR5aZgfLSrHnATMvgX9fMGezlwDcsA+uZMzzBzJWef6ridZXm1AFYehNgmLPgGw2zS6dhRHZ1X3qN2u0hupc5I3/rq+cv7wo7p0HqR6fzon8MARHuaYenOfs5EXWZY88RZ9blSRJuMtdIyNoNu2eXXvZUGmx+ztxu/yx4uy6dsUsF1oNmp9c3KMiyv+/Ufv2vKacKB9J9fX1p2LAhBQXV9Kt1UkSP5lF2C32+P+piljzcs1KC6FD+RUcL86PH1QkkNMDX5e0TERERqWwak0u1ZC04nfe4uPH+6X2r7qv6aV5qynW6QmgLM69vQba5YF5Jdv8P/vy3uX3JB6cXUnRQ8/vNBRez9sDWKY7Xdy5rASy9EbIPQnhbSPTAFF0tTi+8uOO/5cs17QzpG+H3seZ2u4kQpTRIUg7eAXDBGHN7y0vmtxtKsu4J85skdS+B+Bsqp32uYC0wX6vF0v+a8nLouy+PPfYYjz76KMeOHXNWe8SDbdh3nIKz/sZ0Sqjj8nQu5xp0YX0Cfb3Zdugkv//1d6llN6edAKBltBYarUzKQy4iIlK5NCaXaufwL5BV2jdQDTOIebgSF3x0hZpyna5glye9hMfn5E5Ycau53fJBqH+lc87tE2gubAmwcTJkH3JOvYU2Pg0HF4FPMHT51Dyfp4lJhrBWkH8SdrxTeefNz4Ql15n5nqP7QKtHKu/cUn00u8sMqB/7HQ4vKb7M3+tg53vm9kUvmX9zqir9r3EqhwLp//73v/n555+JjY2lefPmXHTRRXY/Ur2s2Z3u7iYQGuDLgPbmDPjzLTp6Jj+6AukiIiJSfWlMLtXOqbSylTuxw7XtcLWyXmdZy9U0hXnSiwv+FOTCkiGQdxwiOkP7p5177kbDoE5HM+/6uvHOq/fgYtgwwdy++E0Ia+G8up3JYjkn13TZ1jBz2O9jIWMzBMbApR8qL7pUTEAkJAw3t7e8VPR+wzBTQhlWaHgdRF5aue1zNv2vcSqHposOGjTISc2QqmD17tJngFeWYUnxfPr7Xr5dn8YTV7WidrBfseU2n07t0jJGgXQRERGpvjQml2rHN7xs5X6/G45vhBb3mgvBVTWBZUyRWdZyNU1hnvSjK4vet/Zhc0FQv9rQ5RPwcnKqT4sXXPQy/HAZ7HgbLhgL4a0dqzP7ECwdZgbvGo+ChJud01ZXaXQj/PGoOdN17xeuP9/O6bDzffOxv/RjM7WPSEU1vx+2vw17v4IT2+3vS5sLBxaAlx90eNY97XMm/a9xKocC6ePHO/GTV/F4njAjHaB9gzBaxYSyKS2D/63ey23dGhcpk5tvZdshM7VLKwXSRUREpBrTmLyKyM+ET2uZ29efNNM2SFHZh2Dd4+cvZ/EB6ynY+gr8+SrEXWvOkI1Icn0bnSWym5mzu8Sv3FvM+yMrkAPaJxiGlb6mVJUX2tJcNDDnsP3+vV+eyV1+yXQIbuia80d1gwZXm0HkNQ/C5d9VvC7DCktvNmeEhrWCjq87r52u4h0AzcbA+vGw1cXtPb4JfrvL3G7zJNTr7trzSfUX1gJi+8P+b+HPN87st+abs9EBmt8DtYrGm6oc2/+afRS/JocD/2tqIH0PRsok7fgpDmRkU8kp0Ytlt+joyuIXHd11JJO8AoOQAB8a1PbAnHIOUh5yERERkRrs7AXBDv1cfRYIO7ED5neBv1eBz+kPHTj3DYjF/OnyMfT4HqJ7m0HI3Z/C/EtgQVfY83nxj4mnPW5e3nBhMWkFANt1J04xy0lRFsuZ9C6Fdn8GS0eY2y1SoMEA17ahw3PmbPe07yFtfsXr2fQsHJgP3oGn86JXkQ/amt1pBtT/XnNmnzNeW2cfn7YAfrkOCrKg3hXQ+lHH6hYp1PL0orm7Pjyz74/HzA9u/OtC68fc0y5n8/KGxFdP3yjufyr6X1MODgXSvby88Pb2LvFHqo/C2egX1Atxb0NOG9ghliA/b3YezmTFrqILa205cCati6UqLwohIiIich4ak9cwez6Hb1udub34Sviqkbm/Kjv6O8zvDCe3Q3Aj6Ps7dPsfBMbalwtqAN1mQ8NrIbYv9JwP/f6AxiPNgObhX+GXa+DrZrD1Ncg7aR7nqY9b9sHTG+e8NS+8zrjBld6kKsU3zP728lGQfxxqNYX2k11//tBm5qxsMGexViSAfOjnM9/C6PiG4yliKlNAZNFZrI6+ts59rf5yNWRsMvv60hkK9onzRPUw/99Ys8/s23Z6dnr9QeAXXvltcpW4web/lJL+p+p/TZk5NJX1iy/s82Dl5eWxZs0apk+fzoQJExxqmHiWNafzo7ePC2fLgRNubg2EBPgysEMsH6/cw8crd3NJ47p29xe2UWldREREpLrTmLwG2fM5/HItRb6anbXP3F9V3wzvnwtLrjXT39TuAD2+M3O1hjaHer1gthksze/6NT4N+hUNpNVuB5dMg/bPmF/R3/YmZO6CVffCuicg6nLY9yUe97jlpp9ZWPLCF2HN6cUbe3wH0X0UMDyfPZ/DjneLv+/kDtj/TeX0a5vHYdd0SF8PO6dB09vKfmz2Yfh1qPmtikY3mx8IVSV7PocDPxTdX9HXVkl/48BcOPbIr1Xzb5x4pr1fQGZq8fftfA/qX1m9nm9xg+3+p+p/TcU4FEgfOHBgkX3XXnstrVu3ZtasWdx6662OVC8epHBGeoe4MGb9tse9jTltWKd4Pl65h+/XH2D8gFwCfM/M4tiSpkC6iIiI1Awak9cQ1gIzMFxsflMDsMCq+6D+wKr1pnjndFhxGxj5EN3LnIXue9YY/qxrMSK7ln5tgTHQfpKZ+mHXdNjyCpzYBvvmlHCAmx+3jU9DzlEzJ3aTW84E0qMuq1p96A6lvh5Oq6x+9a8DbZ6A1febM8vjbwDfMnyT27DCsuFwaj+EtoCL/2Omq6kqnP036bx9WkX/xolnsj3fSlEdn29nX4v+11SIS3KkX3LJJSxcuNAVVYsb5OZbWbfvOADtG4S7tzFnadsgjLb1w8gtsPK/VfYL9Gw9aAbSWyqQLiIiIjWUxuTVzOFfSlmUEsCArD1muarAMGDjM7B8pBlEb3QjdP/WPoheUT5BZu7mq7ZAu6fP15CKP275mTDTYv7kZ5bv2JM7zdQzAB1eAC+te1QunvZ6aHaXmU4m+wBser5sx2x+AdLmmjnGu34KvrXOf4wnKWsf/NADfh58/p8fenhWn0r15ml/Q6TKcPp/61OnTvHaa69Rv359Z1ctbrI5LYPcfCthgb7E1w1yd3PsDEtqyLjP1/Pxyt0MS4qz7U/PysPby0KzelVsMCIiIiLiBBqTV0On0pxbzp2sBbDqHtj2H/N2y4egw2SwOHmel8ULaiWUrWxlP25rHwFrrrlYamw/cyFFKTtPez14+8GFz8Mvg2HLS9DsDjP3cEkO/2ouagiQ+DqEt62cdjpTWR/bI0vcc16R0nja3xCpMhwKpNeuXdtuIUfDMDhx4gRBQUF89NFHDjdOPENhfvQLG4Z73MKd/2gfy9PfbmbnkUxWnrPoaNPIWgT46msqVVmQnw/bnurDd999R5CfZumIiIgUR2PyGiIwxrnl3CX/FCy90cxNiwUSp0Dze1x3Pk983A4vhd2fARYzN7qHvceqEjyxXxsMMhfePPyLGSTvPL34cjlH4dchYBRA/DBoUkXTb5X1sW1+v7newflkbIWtrzjvvCKl8cS/IVIlOBSZeuWVV+wG7V5eXkRGRpKUlETt2rUdbpx4hjV70gG4MM7z+jTY34eBHWKZsWI3n/5u/7WcljFlyEsnIiIiUsVpTF5DRHYzZ7hm7aP4HMIW8/7IbpXdsrLLOQY//8OcjevlB5d+BA2vc+05z/u4AUFxlfe4GQasPp0Lvckt5kKpUn6e+HqwWOCil2HexbDrA/MDotAW9mUMA5aNNFNKhFwAnaZW3Q9SytoHF75Q9hzpez7zrD6V6ssT/4ZIleBQIH3kyJFOaoacLSs3n1ZPzAd86NErnzBfX7e2p3Ch0Yviw93ajpIMS2rIjBW7WbD5oN3+VrHKjy4iIiLVn8bkNYSXNyS+Cr9cW0IBw5zd7akLh2Xuhh/7QsZm8A2Dy76Eet1df167x81CsQGTVo9U3uP21yw4ugJ8gqHdU5Vzzuqo1H49HZh2x+uhbkdodBOkfgSr/wndv7G/f8vLsP8b8PI/nRe9Ck/+cnYfeGqfSvWk55tUkENJ6KZNm8Znn31WZP9nn33G9OklfI1JqpQjJ3PYfSwLiwXax4W7uznFah0bRvu4cPIL7AfFzetV4UGJVAlBfj6kPtuf1Gf7K/WMiIi4jcbkNUjcYOg2G7wCit4XnGCmlnA3a8GZ7UM/m7f/XgfzO5tB9MD60HtJ5QTRCxU+boGx9vu9/MzfO9+DghzXt6MgG/54xNxu+bBSBjiqpH4NamDujxvsnna1f8ZcQPTQT7Dv6zP7t78Nax42txOnQO32bmmeUzm7Dzy1T6V60vNNKsChQPrkyZOJiIgosj8qKopnnnmm3PW98cYbNGrUiICAAJKSkli5cmWJZXv06IHFYiny079/f1sZwzB44okniImJITAwkF69erFt27Zyt6smK5yN3jSyFqEB7p0ZX5p29cOK7Htw9jrmbtDCECIiIlK9uXNMfrZPPvkEi8XCoEGD7PZrTO5kDa4Gn6Azty/9GHxCIHMX7PrQfe0C2PM5fNvqzO3FV8IXMTD/Eji1H8JaQZ9lEN6m8tsWNxj6bzpzu8d3cNVW8KsDx1bBmodc34atr0LmX+aHCS3/6frz1QTF9es/drk3ABYcBy1Op+9ZdvOZ/atTgAKIuBSa3uGWprmEs/vAE/tUqi8936ScHAqk7969m4SEoqugx8fHs3v37nLVNWvWLFJSUhg/fjyrV6+mffv2JCcnc+jQoWLLf/7556Slpdl+NmzYgLe3N9dddybH3vPPP89rr73G1KlTWbFiBcHBwSQnJ5OdnV2+C63Bzl5o1FPN3ZDGR8v/KrL/8Ikc7vxotYLpIiIiUq25c0xeKDU1lQceeIBu3YrmEtWY3MlObIfcY2duNxgAbR43t/94DPIz3dOuPZ+bX5E/tc9+f85hKDgFoS3NmejBce5pH9h/RT/qMqjV6MyCkH++Bnu+cN25sw/DxtMfbLV/xv7DEHHMuf3qCakYQk9/oGQUFL3vyLLTi+1WI87uA0/sU6m+9HyTcnAokB4VFcW6deuK7P/jjz+oW7duuep6+eWXGT16NKNGjaJVq1ZMnTqVoKAg3nvvvWLL16lTh+joaNvPggULCAoKsgXSDcNgypQp/Otf/2LgwIG0a9eODz74gP379zNnzpxyX2tNVTgj/cKGnrlQVYHVYMLXm4pdGqJw34SvN1FgLWFhIREREZEqzp1jcoCCggJuvPFGJkyYQOPGje3u05jcBY4sK7qv+d0Q3MgMYm9+qdKbhLUAVt1LiYt5AuSdAB8PXMOo/lXQ8gFze/ktcDLVNedZ/yTkZUDtiyDhJtecQzyDteBMCp+SrLrPPg2SiIhUCQ4l9R06dCj33HMPISEhXHbZZQD89NNP3HvvvQwZMqTM9eTm5rJq1SrGjRtn2+fl5UWvXr1YtqyYgWIx3n33XYYMGUJwcDAAu3bt4sCBA/Tq1ctWJiwsjKSkJJYtW1Zi+3JycsjJOZMfLyMjA4C8vDzy8vLKfE2OyMvLt9t29Lz29eWRZylbULnAavDH3nQA2sbUOv0YVKwuZ7et0Ipdx0g7XvJsJgNIO57Nsu2HSEqoU4H25dn9lsqnPqgY579W1Q+eQP3gfuoDz1Bd+sFZ7Xf3mHzixIlERUVx66238ssvv9jdV5XH5OTnUZjYMC8vD3wcPO+59RkVq8/r0K+cPVfObJsflraT8Fl+E8am58iPH1E056sL22Y59BM+WXtLL3RqL/lpP2JElTM3ujP7oaTrbDUB74O/4HVsBdYl11Nw+Y9n8qdXpL5zZWzGZ/tbWID8ds9h5BcA5wRRnfT8cBlnvx6cyZmPnRPqOv/rwYCsPeV/PXjo3ySn11XV2uaKv0meUJ8nt624+tQP7m+bJ/1NKqfyjC0dCqQ/9dRTpKamcsUVV+DjY1ZltVoZPnx4ufIxHjlyhIKCAurVq2e3v169emzZsuW8x69cuZINGzbw7rvv2vYdOHDAVse5dRbeV5zJkyczYcKEIvvnz59PUFDlfP0upwAKu2bRokX4O/itkrPrmzdvfpnr25cJWbk++HsbbFv1CzssFa/L2W0rtOqIBTj/QfN/WcHRzRUPJC5YsKDCx4pzqA/Kx9mv1ULqB8+gfnA/9YFnqOr9kJWV5ZR63DkmX7JkCe+++y5r164t9v6qPCb3NrK56vT2okWLKLAUs8BnBeubN29ehevrcWo+Z68OZKvLCKabV3PqFGxl/9xbWet/d6W1rX7+z3QsQ7m1y79nn0/5Us84sx9Ku85A6630YCN+x35j55fD2Oh/i0P1nS0pexLRRgFp3p1Y+Xsm8F2F63IXZ78enMmZj50z6nLV68FT/yY5u66q1DZX/k1yd32e3LZz61M/uL9tnvY3qbzKMyZ3KJDu5+fHrFmzmDRpEmvXriUwMJC2bdsSHx/vSLXl9u6779K2bVs6derkcF3jxo0jJSXFdjsjI4O4uDj69OlDaGjlfBUxKzefh1YuAqBnz56EBTv25Dm7vuTkPgT5la3bP/ltL6zbRGJ8Xa7q39GhupzdtkJ1dx3jg22/n7dcn25JFZ6RvmDBAnr37o2vr+cutlqdqQ8qxtmvVfWDZ1A/uJ/6wDNUl34onGXtKHeNyU+cOMHNN9/MO++8U+xip47whDE5+ZlwOo1xz5498Q0Md1p9ycnJ4BNc/jryTuAzxz7v/dl1WY7WhUWX0TB/EbGXPwvh7SulbZZDwfDTy+ct1+GSfrQv94x0J/bDea7Tsq8OLL2Wpvlf0ShpJEbsVcVUUvb6ACwHF+Lz8+8YFh8ier/HlSEXVLgut3L268GZnPnYOaEul70ePPFvkivqqkJtc/XfJLfW58ltO6c+9YP72+Zxf5PKqTxjcsciK6c1a9aMZs2aVfj4iIgIvL29OXjwoN3+gwcPEh0dXeqxmZmZfPLJJ0ycONFuf+FxBw8eJCYmxq7ODh06lFifv78//v7+Rfb7+vpW2hs1X8Ny1nl9HD6vfX2++PqWrdv/2Gc+kS6Kr2NrQ0XrcnbbCnVuGkVMWAAHjmcXm5HRAkSHBdC5aRTeXpZiSpSxnZXY/1I89UH5OPu1al+X+sHd1A/upz7wDFW9H5zd9soek+/YsYPU1FQGDBhg22e1WgHw8fFh69atVXpMjuXMeZxy3nPqw6cC9R1dA1ghqCFk7S5aV3Q3aHg9lt2f4rvuEei5ACxlGAM72raYyyGwAZwqKZ2FBYIa4BNzefkXcXNmP5zvOhtdA0fvg61T8PntVui3FoIbVrw+awGse9gs2uxOfOu0rnhd7ubs14MzOfOxc0ZdMZdDUAPI2kfx6wZU8PXgiX+TXFGXs+tzcdtc+jfJnfV5ctuKqU/94Ib6PPlvUjmVp+0OLTZ6zTXX8NxzzxXZ//zzz9sW/SwLPz8/EhMTWbhwoW2f1Wpl4cKFdO7cudRjP/vsM3JycrjpJvsFWxISEoiOjrarMyMjgxUrVpy3TjGt2f03ABc2DHdvQ0rh7WVh/ABzRfRz3yIU3h4/oJVDQXQRERERT+auMXmLFi1Yv349a9eutf384x//4PLLL2ft2rXExcVpTO5sh5eavyOSSi7T4Vkzv/fBhbC/aAoRl/DyhsiuJdx5ehyeOKX8QXR36PAc1LkYcv+GJTeA1YEcrbumQ/o68A2HtuOd1kTxcF7ekPjq6RslvEutKq8HERGx41Ag/eeff+bKK68ssr9fv378/PPP5aorJSWFd955h+nTp7N582buvPNOMjMzGTVqFADDhw+3W/io0LvvvsugQYOoW7eu3X6LxcJ9993HpEmT+Oqrr1i/fj3Dhw8nNjaWQYMGlattNdHxrDx2HDbztXWIC3dvY86jb5sY3rzpIqJC7WctRYcF8OZNF9G3TUwJR4pUX0F+PqQ+25/UZ/s7nNZFREQ8m7vG5AEBAbRp08buJzw8nJCQENq0aYOfn5/G5M525PSir3VLSWlZKwGa32tur3kQrPkll3WWgz/Bnk/Nbb/a9vcFNYBusyFusOvb4QzeftB1FviGwdHl8MdjFasn7ySs+5e53eZf4F+39PJSvcQNNp/35y76W9VeDyIiYseh6MrJkyfx8yu6mrmvr2+5cz7ecMMNHD58mCeeeIIDBw7QoUMH5s6da1uYaPfu3Xh52cf9t27dypIlS5g/f36xdT700ENkZmZy++23k56eTteuXZk7dy4BAZ6zMIqnWrs3HYD4ukHUrVX0a7Wepm+bGLo0jaDtk+Zz4f1RF9OtWaRmoouIiEi15+4x+floTO4khtUM7ALULWVGOkDrR2Hne5CxGXa8A83udF27sg/B0qFm+xJGQOJrMPv0cqg9voPoPlVv5m2tBLjkPfjlGtj8AkR1h/r9y1fH5hfgVBrUagwXjHVNO8WzxQ2Ger2q/utBRERsHAqkt23bllmzZvHEE0/Y7f/kk09o1apVuesbO3YsY8cWP8hYvHhxkX3NmzfHMIrLOWayWCxMnDixSP50Ob/CtC4XNax9npKe4+ygeaeEOgqii4iISI3g7jH52d5///0i+zQmd5KMrWa6Ee9ACG9belm/cGg7AX4fC+uegPhh4Bfm/DYZVlh6sxkwDm0JF79hf3/UZVU3aBg3GC64G/58HZaPMPOlBzUo27FZ+8xAOpipYrw9f2KSuMjZz/+q/HoQERHAwUD6448/zuDBg9mxYwc9e/YEYOHChcycOZPZs2c7pYHiHmt2pwOenR9dRERERDQmrzFsaV0uBq8yLIrV9HYzCJyxFTZNNnOnO9um5+DAfDO43/Uz8AmG/Eznn8ddLnwBjiyFY6vg16FwxY/gVYa30Ov+BQWnILILxF3j+naKVIRPMAwreWKiiIgU5VCO9AEDBjBnzhy2b9/OXXfdxT//+U/27dvHokWLaNq0qbPaKJXMajXOLDQaV3VmpIuIiIjURBqT1xCFgfSIMi7S6uULHU7Pit4yBU6mOrc9h36BdY+b2x3/DeGtnVu/J/D2hy6zwDcUDi8xZ/efz7E1sHO6uX3hS2DRt2RFRESqC4cC6QD9+/fn119/JTMzk507d3L99dfzwAMP0L59e2e0T9xg55FMMrLz8ffxokVMiLubIyIiIiLnoTF5DXBkqfk74tKyH1P/KqjXE6w58Mc457Ul+4g5Q9sogEY3QeNRzqvb04Q0gaT/mtubJsP+eSWXNQxY80/AgPihEHGeXPYiIiJSpTgcSAf4+eefGTFiBLGxsbz00kv07NmT5cuXO6NqcYPC2ejtGoTh6+2Up4iIiIiIuJjG5NVYbjoc32RuR1xS9uMsFrjoJcACf30CR5zwfDCssGw4nNoHoc3h4jer/6zrhtedWbB12c2Qtb/4cvu+gYM/gpc/dJhcee0TERGRSlHhHOkHDhzg/fff59133yUjI4Prr7+enJwc5syZU6FFjcRzrNmTDsCFVWihUREREZGaSGPyGuLICvN3rSYQEFW+POS1O0DjkbBzGqxOgd6/Ohb43vwipH0P3gHQ5VPwrVXxuqqSi1420+v8vRaWDoOeP9jfb82DNQ+Y2y3ug+D4ym6hiIiIuFiFphsPGDCA5s2bs27dOqZMmcL+/ft5/fXXnd02cZPChUYv0kKjIiIiIh5LY/IapCJpXc7WbhJ4B5mB4D0OLEB7eCn88ai5nfgq1G5X8bqqmsIPDnxqwaGfYMNE+/t3vAsn/gT/SGjlxDQ6IiIi4jEqFEj//vvvufXWW5kwYQL9+/fH29vb2e0SN8nMyWfrgQxAM9JFREREPJnG5DVI4UKjkWVcaPRcQbHQ8kFze83DUJBT/jpyjsKvQ8y86PFDoMnoirWlKgttBp3eNrc3TIIDZ81KXz/B/N1uAviFVX7bRERExOUqFEhfsmQJJ06cIDExkaSkJP79739z5MgRZ7dN3OCPvelYDYgNC6BeaIC7myMiIiIiJdCYvIawFsDR06ldIioYSAdo9SAExkDmLviznN9cMAxYPgqy9kBIM+j0VvXPi16SRkOh6e2AAT8PPrM//wRYfMAvwm1NExEREdeqUCD9kksu4Z133iEtLY077riDTz75hNjYWKxWKwsWLODEiRPObqdUksK0LpqNLiIiIuLZNCavITI2QV6GmVIkrE3F6/EJhnZPm9sbJkF2OT502fIK7PvaXESz66fgG1rxdlQHUT1Ob1jt9xv58OsNsOfzym6RiIiIVIIKBdILBQcHc8stt7BkyRLWr1/PP//5T5599lmioqL4xz/+4aw2SiU6E0gPd2s7RERERKRsNCav5grTutTtBF4+jtWVMBzC20Pe8aI5vks8/wpY+7C5nfiKuXhpTWYtgLUPlV5m1X1mOREREalWHAqkn6158+Y8//zz7N27l48//thZ1UolMgyDtXv+BhRIFxEREamKNCavhgoD6Y6kdSnk5Q0XvWRub3sTMraWXj73b3OGtZEPDa+Dpv/neBuqusO/QNbeUgoYZgqcw79UWpNERESkcjgtkF7I29ubQYMG8dVXXzm7anGxvX+f4sjJXHy9LbSO1QI5IiIiIlWVxuTVyOGl5m9nBNIBoq+A2KvM4PiaUmZWF+ZFz/wLajWGTu/U3LzoZzuV5txyIiIiUmU4PZAuVdfq3eZs9FaxYQT4eru5NSIiIiIiNVzOUTjxp7kdcYnz6r3wBbB4w76v4OCPxZfZ+hrs/RK8/My86H6aaAOYC7Y6s5yIiIhUGQqki40tP3pcuFvbISIiIiIiwJHl5u/Q5uBf13n1hrU4k6Zl9T/BOGfRzKO/wdoHze0LX4Q6ic47d1UX2Q2CGgAlzc63QFCcWU5ERESqFQXSxWbNbuVHFxEREREB7BaLtBxe4p7FI484Oa3L2dqOB99Q+HsNpM44s3/fd/DL9WDNg7jBcMFY55+7KvPyhsRXT984N5h++nbiFLOciE8wDDPMH59gd7dGREQcpEC6AJCdV8DG/RkAXNSwtptbIyIiIiLiRns+h29b2W76LBkAXzUy91cm20Kjlzq/7oBIaP2Yuf3bmDP7f70eslLBPxKS3lVe9OLEDYZusyEw1n5/UANzf9xg97RLREREXEqBdAFg4/7j5FsNImr50aB2oLubIyIiIiLiHns+h1+uhVP77Pdn7TP3V1Yw3ZoPR1ea266YkQ4Q3LDwZEXvyzkMBxe55rzVQdxg6L/pzO0e38E/dimILiIiUo0pkC7AWfnRG9bGolknIiIiIlITWQtg1b2AUcydp/etuq9y0rykr4f8TDP9Slir85cvL2sBrHmwlAKWyrvWqurs9C1Rlymdi4iISDWnQLoAZwfSw93aDhERERERtzn8C2TtLaWAAVl7zHKuVpjWpe4lYHHB2zZPulYRERGRKkCBdAFgdeFCo3HKjy4iIiIiNdSpNOeWc4QtP7qL0rp40rWKiIiIVAE+7m6AuF/a8VOkHc/GywLtGoRV6rmD/HxIfbZ/pZ5TRERERKRYgTHOLeeII0vN364KpHvStYqIiFQXPsEwrLgUcVIdaEa6sPZ0Wpfm0aEE++uzFRERERGpoSK7QVADoKQ1gywQFGeWc6XsQ3Byp3m+iCTXnMNTrlVERESkilAgXVizJx1QfnQRERERqeG8vCHx1dM3SggwJ05x/aKShWldwlqBX7hrzlHqtZ6+XRnXKiJl4xNM3nW5fBk8x5zxKiIilU6BdGHN6fzoFzVUfnQRERERqeHiBkO32RAYe84dXtDlE/N+Vzvs4rQuhUq61qAG5v7KuFYRERGRKkKB9Bour8DKur3HAc1IFxEREREBzABy/022m4ZvbcAKXn6Vc37bQqOXuv5c51wrPb6Df+xSEF1ERETkHAqk13Cb0zLIybcSFuhLQl19PUxEREREBLBLaWKNv9Hc2DXd9ee15sGx38xtV89IL3R2+paoy5TORURERKQYCqTXcGtOLzTaIS4cL6+SFhoSEREREam5rPFDzY1930D2Ydee7O+1UJANfrUh9ALXnktERETEE/gEwzDD/PHgdSAUSK/hCvOjK62LiIiIiEgJQltBnUQw8uGvj117Lltal85g0ds1EREREU+hkVkNt2ZPOgAXaqFREREREZGSJYw0f+9837XnOTuQLiIijqkis1xFpGpQIN0DFVgN2/ZvqX/b3Xamoydz+OtoFmCmdimLID8fUp/tT+qz/Qny83FJu0REREREPE6joeDlC3+vgb/Xue48h5eavxVIFxEREfEoCqR7mLkb0uj18k+227d9uIauzy1i7oY0p59r7enZ6E2jahEW6Ov0+kVEREREqg3/ulB/gLntqkVHs/ZB1m4zpUvdTq45h4iIiIhUiALpHmTuhjTu/Gg1BzNy7PYfOJ7NnR+tdnowfXVhfvQyzkYXEREREanRCtO7pH4E1jzn11+Y1iWsLfiGOL9+ERFxjE8wedfl8mXwHKWKEamBFEj3EAVWgwlfb6K4JC6F+yZ8vcmpaV7W7E4HlB9dRERERKRMYvuCfyRkH4K0ec6vX/nRRURERDyWAukeYuWuY6Qdzy7xfgNIO57Nyl3HnHK+AqvBH7aFRsOdUqeIiIiISLXm5QuNbjK3XbHoaGEgPfJS59ctIiIiIg5RIN1DHDpRchC9IuXOZ9uhE2TmFhDs580F9fS1URERERGRMmk8wvy972vIOeq8egty4Ngqc1sz0kVEREQ8jgLpHiIqJMCp5c6nMK1L+7hwvL0sTqlTRERERKTaq90eancAay789Ynz6j222qzTPwJqNXFevSIiItWNctWLmyiQ7iE6JdQhJiyA0kLaMWEBdEqo45TzrSlcaFRpXUREREREyifh9Kz0ndOdV6ctP/qlYNFEFxERERFPo0C6h/D2sjB+QCuAEoPpXZrUddrs8dWFC43GaaFREREREZFyaTQMLD5w7Dc4vsk5dR5Zav5WWheR8vEJhmGG+aOZqSIi4kIKpHuQvm1iePOmi4gK9bfbHxrgA8Dna/axZNsRh89z/FQe2w+dBKCDZqSLiIiIiJRPQBTU729uO2NWumGcNSNdgfQqQwFcERGRGkWBdA/Tt00MP6R0t93+780Xsvrx3lyX2ACrAWM/Xs3uo1kOneOPPekANKwTREQt/9ILi4iIiIhIUYXpXVI/BGu+Y3Vl7YFT+8HiDXUvdrxtIiIiIuJ0CqR7oLPTt1zcqDY+3l48NagN7ePCSc/K4/YPfycrt+KD9cKFRpUfXURERESkgmL7g39dOJUGBxY4Vtfh02ldancAnyCHmyYiIiIizudRgfQ33niDRo0aERAQQFJSEitXriy1fHp6OmPGjCEmJgZ/f38uuOACvvvuO9v9Tz75JBaLxe6nRYsWrr4Mlwjw9eatmxKJqOXPlgMnePCzdRiGUaG61uwxFxq9qKHyo4uIiIiIVIi3H8QPM7cdTe+itC4iIiIiHs9jAumzZs0iJSWF8ePHs3r1atq3b09ycjKHDh0qtnxubi69e/cmNTWV2bNns3XrVt555x3q169vV65169akpaXZfpYsWVIZl+MS0WEBTL3pIny9LXy7Po03f9pR7joMw9CMdBERERERZ2g80vy9dw7k/l3xemyB9EsdbZGIiIiIuIjHBNJffvllRo8ezahRo2jVqhVTp04lKCiI9957r9jy7733HseOHWPOnDl06dKFRo0a0b17d9q3b29XzsfHh+joaNtPREREZVyOy3RsVIcJ/2gDwAvztvLj1uI/aChJ6tEsjp/Kw9/HixbRoa5oooiIiIhIzVD7QghrA9Yc+OvTitWRfwr+XmNua0a6iIiIiMfyiEB6bm4uq1atolevXrZ9Xl5e9OrVi2XLlhV7zFdffUXnzp0ZM2YM9erVo02bNjzzzDMUFBTYldu2bRuxsbE0btyYG2+8kd27d7v0WirDsKSGDO3UEMOAez5ew64jmWU+tnCh0bb1w/Dz8YjuFxERERGpmiyWM7PSd75fsTqO/Q5GPgREQ3C8s1omIlJ1+QTDMMP88Ql2d2tERGx83N0AgCNHjlBQUEC9evXs9terV48tW7YUe8zOnTtZtGgRN954I9999x3bt2/nrrvuIi8vj/HjxwOQlJTE+++/T/PmzUlLS2PChAl069aNDRs2EBISUmy9OTk55OTk2G5nZGQAkJeXR15enjMu97zy8vLttos772P9LmDrgQxW707ntum/MfuOJGr5F9+dZ9e3Zrf5ldP2DUIr7Xoqi/3jlkeepWI55O3rzLP7LZVPfeAZ1A+eQf3gfuoDz1Bd+sFT2//GG2/wwgsvcODAAdq3b8/rr79Op06dii37+eef88wzz7B9+3by8vJo1qwZ//znP7n55pttZUaOHMn06fY5xJOTk5k7d65Lr6PSNLoR1j4MR5dDxlYIbV6+48/Oj26xOL99IiJSMxR+AOFpdYlUIx4RSK8Iq9VKVFQUb7/9Nt7e3iQmJrJv3z5eeOEFWyC9X79+tvLt2rUjKSmJ+Ph4Pv30U2699dZi6508eTITJkwosn/+/PkEBQW55mLOkVMAhV2zaNEi/L2LLzcoEnakebPjcCbD3/iBW5pb8Spm7H12fb9u3gtYsB7eyXfflT/Huic7+zrnzZtf4uNWEQsWLHBeZVIh6gPPoH7wDOoH91MfeIaq3g9ZWVnubkIRhesWTZ06laSkJKZMmUJycjJbt24lKiqqSPk6derw2GOP0aJFC/z8/Pjmm28YNWoUUVFRJCcn28r17duXadOm2W77+/tXyvVUisBoiOkL+781Fx3t8Ez5jj+y1PwdqfzoIiIiIp7MIwLpEREReHt7c/DgQbv9Bw8eJDo6uthjYmJi8PX1xdv7TLS0ZcuWHDhwgNzcXPz8/IocEx4ezgUXXMD27dtLbMu4ceNISUmx3c7IyCAuLo4+ffoQGlo5OcWzcvN5aOUiAHr27ElYcECJZVsmpjPs3d9Y/7cXu4KacfflTUqt78ApM9J+y8DLiQ4tud6q6OzrTE7uQ5Cf40/vvLw8FixYQO/evfH19XW4Pik/9YFnUD94BvWD+6kPPEN16YfCbz56krPXLQKYOnUq3377Le+99x6PPPJIkfI9evSwu33vvfcyffp0lixZYhdI9/f3L3FcXy00HmkG0lM/hHZPgVcZZ3QYhv2MdBERERHxWB4RSPfz8yMxMZGFCxcyaNAgwJxxvnDhQsaOHVvsMV26dGHmzJlYrVa8vMxc33/++ScxMTHFBtEBTp48yY4dO+y+anouf3//YmfI+Pr6VtobNV/jzLRyX1+fUs97ceNInr66LQ/NXsdri3bQtkFtereyT5Fzdn1WA2LCAoirW3xqm6rM/nHzxdfXeU/vyux/KZ76wDOoHzyD+sH91Aeeoar3g6e1vXDdonHjxtn2nW/dorMZhsGiRYvYunUrzz33nN19ixcvJioqitq1a9OzZ08mTZpE3bp1nX4NblN/APjVhqy9cHARxPQu23GZuyD7EHj5Qp1E17ZRRERERBziEYF0gJSUFEaMGEHHjh3p1KkTU6ZMITMz0zYbZvjw4dSvX5/JkycDcOedd/Lvf/+be++9l7vvvptt27bxzDPPcM8999jqfOCBBxgwYADx8fHs37+f8ePH4+3tzdChQ91yja5yfcc4Nu47zvRlf3H/rLXMGdOFplG1Six/YcPwymuciIiIiFQJFVm3COD48ePUr1+fnJwcvL29+c9//kPv3mcCyX379mXw4MEkJCSwY8cOHn30Ufr168eyZcvsvl16Nk9Yt4j8PAo/6sjLywOf0s7rhVfcDXjvmIp1x3sURPQ4f31GHpYDP+MDWMMvpMDqDdYyXlsxdTnEmfW5um2l9kMlt82ZPLlt4Nx+8GQe3g8eu0aIhz9uzua0fqhJj5sLrrVG9ENV+n9fhf8vlOc55DGB9BtuuIHDhw/zxBNPcODAATp06MDcuXNtA/ndu3fbZp4DxMXFMW/ePO6//37atWtH/fr1uffee3n44YdtZfbu3cvQoUM5evQokZGRdO3aleXLlxMZGVnp1+dq/7qqFZsPnGDlrmPc/sHvzBnbhdCA4mc5XRhXu5JbJyIiIiLVVUhICGvXruXkyZMsXLiQlJQUGjdubEv7MmTIEFvZtm3b0q5dO5o0acLixYu54ooriq3TE9Yt8jayuer09qJFiyiwlJ4WMbygMd0B6+7PmX9kAPmW4BLrmzdvHgWWANrlfEoCsCujHhu++65CbSusyxHOrM+VbStLP1Rm25zJk9sGzu0HT+bp/VDI09YIqSqPm7M52g816XFz5bVW536oKv/vq/r/hfKsW+QxgXSAsWPHlpjKZfHixUX2de7cmeXLl5dY3yeffOKspnk8X28v/nPjRfzj9SXsPJLJfZ+s5b/DO+JVzOqjmpEuIiIiIueqyLpFYKZ/adq0KQAdOnRg8+bNTJ48uUj+9EKNGzcmIiKC7du3lxhI94R1i8jPhC/MzZ49e+IbGF56eaMfxrz38DmxheSWJzAaX1difcnJyeATjM+CJyEd4jsOoWHclRVqW2FdDnFmfS5sW5n6oTLb5mR55AKQfJ5ybuHMfvBknv4c8dQ1Qjz8cXM2p/VDTXrcXHCtNaIfqsj/+6r+f6E86xZ5VCBdHBNRy5+3bu7ItVOXsmjLIV754U/+2ae5XRkfbwtt6oe5qYUiIiIi4qkqsm5RcaxWq11alnPt3buXo0ePEhMTU2IZT1i3CMuZ85T5vE1GwdqH8dn9ETS/o9T6MHLg+DoAfKIvg/Jc17l1+Tj4mDizPhe3zaH+d3bbahJn9oMnqyLPEY/rgyryuDmb/iaVgwuvtVr3QxX6f+9Rf5PKqTxt9zp/EalK2jYI49lr2gLw+qLtfL8+jQKrYbs/rnYgvt7Vs9uD/HxIfbY/qc/2J8hPnxGJiIiIlFdKSgrvvPMO06dPZ/Pmzdx5551F1i06ezHSyZMns2DBAnbu3MnmzZt56aWX+PDDD7npppsAOHnyJA8++CDLly8nNTWVhQsXMnDgQJo2bWrOhKpuGt0EFi84vARObC+97LHfwLBCUAPzR0REREQ8mqKN1dDVFzZg474M/rtkF/fOWkuI/5lu3nUki67PLWL8gFb0bVPyLCARERERqXnKu25RZmYmd911F3v37iUwMJAWLVrw0UcfccMNNwDg7e3NunXrmD59Ounp6cTGxtKnTx+eeuqpYmecV3lBsRDdB9Lmwq4PoN3EksseWWb+juhcOW0TEREREYcokF5NPdKvBUu2H2bLgZMczc+1u+/A8Wzu/Gg1b950kYLpIiIiImKnPOsWTZo0iUmTJpVYV2BgIPPmzXNm8zxfwggzkL5zOrR90pyhXpzDS83fEZeW/xw+wTDMOH85EWfxCSbvuly+++47rvSk/MEiVVlN+ltek65VqrXqmeNDsFgs/J2ZV+x9hX+6Jny9yS7ti4iIiIiIOKjBQPANg6zdcOin4ssYBhxdbm5rRrqIiIhUNac/YP0yeI5nLdDqYgqkV1Mrdx3j4ImSF3kygLTj2azcdazyGiUiIiIiUt35BEK8mdqGne8XX+bkdsg5Cl7+UPvCSmuaiIiIiFScAunV1KET2U4tJyIiIiIiZZQw0vy953+Qd7Lo/UdWmL/rdgRvv0prloiIiIhUnALp1VRUSIBTy4mIiIiISBlFXAIhF0B+JuyZXfT+o6cD6UrrIiIiIlJlKJBeTXVKqENMWACWEu63ADFhAXRKqFOZzRIRERERqf4sFmg8wtwuLr3L0ZXmbwXSRUREpLIULvo6zKhRec2dSYH0asrby8L4Aa0AigTTC2+PH9AKb6+SQu0iIiIiIlJhjW4GLOaCoyd32d93fJP5W4F0ERERkSpDgfRqrG+bGN686SKiQv3t9keHBfDmTRfRt02Mm1omIiIiIlLNBcdB9BXm9q4PzrnTgOBGEKjxuIiIiEhVoUB6Nde3TQw/pHS33X5/1MUsebingugiIiIiIq5WuOjozulgWO3v02x0ERERkSpFgfQa4Oz0LZ0S6iidi4iIiIhIZYi7GnxCIHMXHFlqf1/Epe5pk4iIiIhUiALpIiIiIiIiruATBPHXm9upM+3vi9SM9EqnRdZERETEAQqki4iIiIiIuEphepc9n5/Z5x0I4e3c0hwRERERqRgF0kVERERERFwlsgvUagL5J8/sq9UEvRUTERERqVo0ehMREREREXEViwXqXGy/7/gG+KqR/Sx1EREREfFoCqSLiIiIiIi4yp7PYfesovuz9sEv1yqYLiIiIlJFKJAuIiIiIiLiCtYCWHUvYBRz5+l9q+4zy4mIiIiIR1MgXURERERExBUO/wJZe0spYEDWHrOciIiIiHg0H3c3QEREREREpFo6lebcciIiIlJz+ATDsOK+1SbuohnpIiIiIiIirhAY49xyIiIiIuI2CqSLiIiIiIi4QmQ3CGoAWEooYIGgOLOciIiIiHg0BdJFRERERERcwcsbEl89fePcYPrp24lTzHIiIiIi4tEUSBcREREREXGVuMHQbTYExtrvD2pg7o8b7J52iYiIiEi5aLFRERERERERV4obDPV6weww83aP7yC6j2aii4iIiFQhmpEuIiIiIiLiamcHzaMuUxBdREREpIpRIF1EREREREREREREpBQKpIuIiIiIiIhn8gkm77pcvgyeAz7B7m6NiIiI1GAKpHugID8ftj3Vh1c75xPkpzT2IiIiIiIiIiIiIu6kQLqIiIiIiIiIiIiISCkUSBcRERERERERERERKYUC6SIiIiIiIiIiIiIipVAgXURERERERERERESkFAqki4iIiIiIiIiIiIiUQoF0EREREREREREREZFSKJAuIiIiIiIiIiIiIlIKBdJFREREREREREREREqhQLqIiIiIiIiIiIiISCkUSBcRERERERERERERKYUC6SIiIiIiIiIiIiIipVAgXURERERERERERESkFB4VSH/jjTdo1KgRAQEBJCUlsXLlylLLp6enM2bMGGJiYvD39+eCCy7gu+++c6hOERERERERfILJuy6XL4PngE+wu1sjIpXBJxiGGeaPXvciInIOjwmkz5o1i5SUFMaPH8/q1atp3749ycnJHDp0qNjyubm59O7dm9TUVGbPns3WrVt55513qF+/foXrFBERERERERERERE5l8cE0l9++WVGjx7NqFGjaNWqFVOnTiUoKIj33nuv2PLvvfcex44dY86cOXTp0oVGjRrRvXt32rdvX+E6RURERERERERERETO5RGB9NzcXFatWkWvXr1s+7y8vOjVqxfLli0r9pivvvqKzp07M2bMGOrVq0ebNm145plnKCgoqHCdIiIiIiIiIiIiIiLn8nF3AwCOHDlCQUEB9erVs9tfr149tmzZUuwxO3fuZNGiRdx444189913bN++nbvuuou8vDzGjx9foToBcnJyyMnJsd3OyMgAIC8vj7y8vIpeYrkVnssZ58zLy7erN89iOFxnTeHMfpCKUR94BvWDZ1A/uJ/6wDNUl36o6u0XEREREalJPCKQXhFWq5WoqCjefvttvL29SUxMZN++fbzwwguMHz++wvVOnjyZCRMmFNk/f/58goKCHGlyhSxYsMDhOnIKoLCr582bj7+3w1XWOM7oB3GM+sAzqB88g/rB/dQHnqGq90NWVpa7myAiIiIiImXkEYH0iIgIvL29OXjwoN3+gwcPEh0dXewxMTEx+Pr64u19JircsmVLDhw4QG5uboXqBBg3bhwpKSm22xkZGcTFxdGnTx9CQ0MrcnkVkpeXx4IFC+jduze+vr4O1ZWVm89DKxcBkJzchyA/j+j2KsGZ/SAVoz7wDOoHz6B+cD/1gWeoLv1Q+M1HERERERHxfB4RUfXz8yMxMZGFCxcyaNAgwJxxvnDhQsaOHVvsMV26dGHmzJlYrVa8vMxU73/++ScxMTH4+fkBlLtOAH9/f/z9/Yvs9/X1dcsbNWec19ewnFOfR3R7leKu/pcz1AeeQf3gGdQP7qc+8AxVvR+qcttFRERERGoaj1hsFCAlJYV33nmH6dOns3nzZu68804yMzMZNWoUAMOHD2fcuHG28nfeeSfHjh3j3nvv5c8//+Tbb7/lmWeeYcyYMWWuU0RERERE7L3xxhs0atSIgIAAkpKSWLlyZYllP//8czp27Eh4eDjBwcF06NCBDz/80K6MYRg88cQTxMTEEBgYSK9evdi2bZurL0NERERExKk8ZmryDTfcwOHDh3niiSc4cOAAHTp0YO7cubbFQnfv3m2beQ4QFxfHvHnzuP/++2nXrh3169fn3nvv5eGHHy5znSIiIiIicsasWbNISUlh6tSpJCUlMWXKFJKTk9m6dStRUVFFytepU4fHHnuMFi1a4OfnxzfffMOoUaOIiooiOTkZgOeff57XXnuN6dOnk5CQwOOPP05ycjKbNm0iICCgsi9RRESczScYhhnuboWIiMt5TCAdYOzYsSWmXVm8eHGRfZ07d2b58uUVrlNERERERM54+eWXGT16tO0bnFOnTuXbb7/lvffe45FHHilSvkePHna37733XqZPn86SJUtITk7GMAymTJnCv/71LwYOHAjABx98QL169ZgzZw5Dhgxx+TWJiIiIiDiDRwXSRURERETEPXJzc1m1apVdOkUvLy969erFsmXLznu8YRgsWrSIrVu38txzzwGwa9cuDhw4QK9evWzlwsLCSEpKYtmyZSUG0nNycsjJybHdLlyYNS8vj7y8vApdX0UUnssp58zPozArfl5eHhiVdx3n5cy2ueA6ndoPUmHqB/dTH3gG9YNncFo/ePL/Zw9XXV4L5Wm/AukiIiIiIsKRI0coKCgokgaxXr16bNmypcTjjh8/Tv369cnJycHb25v//Oc/9O7dG4ADBw7Y6ji3zsL7ijN58mQmTJhQZP/8+fMJCgoq8zU5y4IFCxyuw9vI5qrT2/PmzaPA4jlpbZzZNldepzP6QRynfnA/9YFnUD94Bkf7wZP/P1cVVf21kJWVVeayCqSLiIiIiEiFhYSEsHbtWk6ePMnChQtJSUmhcePGRdK+lMe4ceNISUmx3c7IyCAuLo4+ffoQGhrqhFaXTV5eHgsWLKB37974+vqe/4DS5GfCF+ZmcnKymVPYUzizbS64Tqf2g1SY+sH91AeeQf3gGZzWD578/9nDVZfXQuE3H8tCgXQRERERESEiIgJvb28OHjxot//gwYNER0eXeJyXlxdNmzYFoEOHDmzevJnJkyfTo0cP23EHDx4kJibGrs4OHTqUWKe/vz/+/v5F9vv6+rrljZpTzms5c7yvry/4eNAbTt9w20KBDrfKhdfprv4Xe+oH91MfeAb1g2dwuB88+f9zFVHVXwvlabuXC9shIiIiIiJVhJ+fH4mJiSxcuNC2z2q1snDhQjp37lzmeqxWqy2/eUJCAtHR0XZ1ZmRksGLFinLVKSIiIiLibpqRLiIiIiIiAKSkpDBixAg6duxIp06dmDJlCpmZmYwaNQqA4cOHU79+fSZPngyYucw7duxIkyZNyMnJ4bvvvuPDDz/kzTffBMBisXDfffcxadIkmjVrRkJCAo8//jixsbEMGjTIXZcpIiIiYvIJtn0rS+R8FEgXEREREREAbrjhBg4fPswTTzzBgQMH6NChA3PnzrUtFrp79268vM58qTUzM5O77rqLvXv3EhgYSIsWLfjoo4+44YYbbGUeeughMjMzuf3220lPT6dr167MnTuXgAAt5iUiIiIiVYcC6SIiIiIiYjN27FjGjh1b7H2LFy+2uz1p0iQmTZpUan0Wi4WJEycyceJEZzVRRERERKTSKUe6iIiIiIiIiIiIiEgpFEgXERERERERERERESmFAukiIiIiIiIiIiIiIqVQIF1EREREREREREREpBQKpIuIiIiIiIiIiIiIlMLH3Q0QERERERGRasInGIYZ7m6FiIiIiNNpRrqIiIiIiIiIiIiISCkUSBcRERERERERERERKYUC6SIiIiIiIiIiIiIipVAgXURERERERERERESkFAqki4iIiIiIiIiIiIiUQoF0EREREREREREREZFSKJAuIiIiIiIiIiIiIlIKBdJFREREREREREREREqhQLqIiIiIiIiIiIiISCkUSBcRERERERERERERKYUC6SIiIiIiIiIiIiIipVAgXURERERERERERESkFAqki4iIiIiIiIiIiIiUQoF0EREREREREREREZFSKJAuIiIiIiIiIiIiIlIKBdJFREREREREREREREqhQLqIiIiIiIiIiIiISCkUSBcRERERERERERERKYUC6SIiIiIiIiIiIiIipVAgXURERERERERERESkFAqki4iIiIiIiIiIiIiUQoF0EREREREREREREZFSKJAuIiIiIiIiIiIiIlIKBdJFREREREREREREREqhQLqIiIiIiIiIiIiISCkUSBcRERERERERERERKYUC6SIiIiIiIiIiIiIipVAgXURERERERERERESkFB4VSH/jjTdo1KgRAQEBJCUlsXLlyhLLvv/++1gsFrufgIAAuzIjR44sUqZv376uvgwRERERERERERERqUZ83N2AQrNmzSIlJYWpU6eSlJTElClTSE5OZuvWrURFRRV7TGhoKFu3brXdtlgsRcr07duXadOm2W77+/s7v/EiIiIiIiIiIiIiUm15zIz0l19+mdGjRzNq1ChatWrF1KlTCQoK4r333ivxGIvFQnR0tO2nXr16Rcr4+/vblaldu7YrL0NEREREREREREREqhmPmJGem5vLqlWrGDdunG2fl5cXvXr1YtmyZSUed/LkSeLj47FarVx00UU888wztG7d2q7M4sWLiYqKonbt2vTs2ZNJkyZRt27dEuvMyckhJyfHdjsjIwOAvLw88vLyKnqJ5VZ4LmecMy8v367ePIvhcJ01hTP7QSpGfeAZ1A+eQf3gfuoDz1Bd+qGqt19EREREpCbxiED6kSNHKCgoKDKjvF69emzZsqXYY5o3b857771Hu3btOH78OC+++CKXXnopGzdupEGDBoCZ1mXw4MEkJCSwY8cOHn30Ufr168eyZcvw9vYutt7JkyczYcKEIvvnz59PUFCQg1dafgsWLHC4jpwCKOzqefPm41/8pUspnNEP4hj1gWdQP3gG9YP7qQ88Q1Xvh6ysLHc3QUREREREysgjAukV0blzZzp37my7femll9KyZUveeustnnrqKQCGDBliu79t27a0a9eOJk2asHjxYq644opi6x03bhwpKSm22xkZGcTFxdGnTx9CQ0NddDVF5eXlsWDBAnr37o2vr69DdWXl5vPQykUAJCf3IcivynZ7pXNmP0jFqA88g/rBM6gf3E994BmqSz8UfvNRREREREQ8n0dEVCMiIvD29ubgwYN2+w8ePEh0dHSZ6vD19eXCCy9k+/btJZZp3LgxERERbN++vcRAur+/f7ELkvr6+rrljZozzutrnFmE1azPI7q9SnFX/8sZ6gPPoH7wDOoH91MfeIaq3g9Vue0iIiIiIjWNRyw26ufnR2JiIgsXLrTts1qtLFy40G7WeWkKCgpYv349MTExJZbZu3cvR48eLbWMiIiIiIiIiIiIiMjZPCKQDpCSksI777zD9OnT2bx5M3feeSeZmZmMGjUKgOHDh9stRjpx4kTmz5/Pzp07Wb16NTfddBN//fUXt912G2AuRPrggw+yfPlyUlNTWbhwIQMHDqRp06YkJye75RpFREREREREREREpOrxmBwfN9xwA4cPH+aJJ57gwIEDdOjQgblz59oWIN29ezdeXmfi/n///TejR4/mwIED1K5dm8TERJYuXUqrVq0A8Pb2Zt26dUyfPp309HRiY2Pp06cPTz31VLGpW0REREREREREREREiuMxgXSAsWPHMnbs2GLvW7x4sd3tV155hVdeeaXEugIDA5k3b54zmyciIiIiIiIiIiIiNZDHpHYREREREREREREREfFECqSLiIiIiIjNG2+8QaNGjQgICCApKYmVK1eWWPadd96hW7du1K5dm9q1a9OrV68i5UeOHInFYrH76du3r6svQ0RERETEqRRIFxERERERAGbNmkVKSgrjx49n9erVtG/fnuTkZA4dOlRs+cWLFzN06FB+/PFHli1bRlxcHH369GHfvn125fr27UtaWprt5+OPP66MyxERERERcRoF0kVEREREBICXX36Z0aNHM2rUKFq1asXUqVMJCgrivffeK7b8jBkzuOuuu+jQoQMtWrTgv//9L1arlYULF9qV8/f3Jzo62vZTu3btyrgcERERERGn8ajFRkVERERExD1yc3NZtWoV48aNs+3z8vKiV69eLFu2rEx1ZGVlkZeXR506dez2L168mKioKGrXrk3Pnj2ZNGkSdevWLbGenJwccnJybLczMjIAyMvLIy8vrzyX5ZDCcznlnPl5+J5dr1F511HVObUfpMLUD+6nPvAM6gfPoH5wv+rSB+VpvwLpIiIiIiLCkSNHKCgooF69enb769Wrx5YtW8pUx8MPP0xsbCy9evWy7evbty+DBw8mISGBHTt28Oijj9KvXz+WLVuGt7d3sfVMnjyZCRMmFNk/f/58goKCynFVzrFgwQKH6/A2srnq9Pa8efMosAQ4XGdN44x+EMepH9xPfeAZ1A+eQf3gflW9D7KysspcVoF0ERERERFx2LPPPssnn3zC4sWLCQg4EyQeMmSIbbtt27a0a9eOJk2asHjxYq644opi6xo3bhwpKSm22xkZGbb866Ghoa67iHPk5eWxYMECevfuja+v7/kPKE1+JnxhbiYnJ4NPsOMNrCGc2g9SYeoH91MfeAb1g2dQP7hfdemDwm8+loUC6SIiIiIiQkREBN7e3hw8eNBu/8GDB4mOji712BdffJFnn32WH374gXbt2pVatnHjxkRERLB9+/YSA+n+/v74+/sX2e/r6+uWN2pOOa/lzPG+vr7gU3XfcLqLu/pf7Kkf3E994BnUD55B/eB+Vb0PytN2LTZaAwT5+ZD6bH9Sn+1PkJ8+OxERERGRovz8/EhMTLRbKLRw4dDOnTuXeNzzzz/PU089xdy5c+nYseN5z7N3716OHj1KTEyMU9pdZfgEwzDD/NFsdBEREZEqR4F0EREREREBICUlhXfeeYfp06ezefNm7rzzTjIzMxk1ahQAw4cPt1uM9LnnnuPxxx/nvffeo1GjRhw4cIADBw5w8uRJAE6ePMmDDz7I8uXLSU1NZeHChQwcOJCmTZua6U1ERERERKoITU8WEREREREAbrjhBg4fPswTTzzBgQMH6NChA3PnzrUtQLp79268vM7MxXnzzTfJzc3l2muvtatn/PjxPPnkk3h7e7Nu3TqmT59Oeno6sbGx9OnTh6eeeqrY1C0iIiIiIp5KgXQREREREbEZO3YsY8eOLfa+xYsX291OTU0tta7AwEDmzZvnpJaJiIiIiLiPUruIiIiIiIiIiIiIiJRCgXQRERERERERERERkVIokC4iIiIiIiIiIiIiUgoF0kVERERERERERERESqFAuoiIiIiIiIiIiIhIKRRIFxEREREREREREREphQLpIiIiIiIiIiIiIiKlUCBdRERERERERERERKQUCqSLiIiIiIiIiIiIiJRCgXQRERERERERERERkVIokC4iIiIiIiIiIiIiUgoF0kVERERERERERERESqFAuoiIiIiIiIiIiIhIKXzc3QBPZxgGABkZGZV63ry8PLKyssjIyMDX17dSzy1nqB/cT33gGdQPnkH94H7qA89QXfqhcHxZON6UkmlMXrOpHzyD+sH91AeeQf3gGdQP7ldd+qA8Y3IF0s/jxIkTAMTFxbm5JSIiIiJSHZ04cYKwsDB3N8OjaUwuIiIiIq5UljG5xdAUmFJZrVb2799PSEgIFoul0s6bkZFBXFwce/bsITQ0tNLOK/bUD+6nPvAM6gfPoH5wP/WBZ6gu/WAYBidOnCA2NhYvL2VcLI3G5DWb+sEzqB/cT33gGdQPnkH94H7VpQ/KMybXjPTz8PLyokGDBm47f2hoaJV+MlYX6gf3Ux94BvWDZ1A/uJ/6wDNUh37QTPSy0ZhcQP3gKdQP7qc+8AzqB8+gfnC/6tAHZR2Ta+qLiIiIiIiIiIiIiEgpFEgXERERERERERERESmFAukeyt/fn/Hjx+Pv7+/uptRo6gf3Ux94BvWDZ1A/uJ/6wDOoH6Sy6LnmGdQPnkH94H7qA8+gfvAM6gf3q4l9oMVGRURERERERERERERKoRnpIiIiIiIiIiIiIiKlUCBdRERERERERERERKQUCqSLiIiIiIiIiIiIiJRCgXQRERERERERERERkVIokO6h3njjDRo1akRAQABJSUmsXLnS3U2qUZ588kksFovdT4sWLdzdrGrt559/ZsCAAcTGxmKxWJgzZ47d/YZh8MQTTxATE0NgYCC9evVi27Zt7mlsNXa+fhg5cmSR10bfvn3d09hqavLkyVx88cWEhIQQFRXFoEGD2Lp1q12Z7OxsxowZQ926dalVqxbXXHMNBw8edFOLq6ey9EOPHj2KvB7+7//+z00trn7efPNN2rVrR2hoKKGhoXTu3Jnvv//edr9eB1IZNCZ3L43JK5/G5J5BY3L305jcM2hM7hk0Lj9DgXQPNGvWLFJSUhg/fjyrV6+mffv2JCcnc+jQIXc3rUZp3bo1aWlptp8lS5a4u0nVWmZmJu3bt+eNN94o9v7nn3+e1157jalTp7JixQqCg4NJTk4mOzu7kltavZ2vHwD69u1r99r4+OOPK7GF1d9PP/3EmDFjWL58OQsWLCAvL48+ffqQmZlpK3P//ffz9ddf89lnn/HTTz+xf/9+Bg8e7MZWVz9l6QeA0aNH270enn/+eTe1uPpp0KABzz77LKtWreL333+nZ8+eDBw4kI0bNwJ6HYjraUzuGTQmr1wak3sGjcndT2Nyz6AxuWfQuPwshnicTp06GWPGjLHdLigoMGJjY43Jkye7sVU1y/jx44327du7uxk1FmB88cUXtttWq9WIjo42XnjhBdu+9PR0w9/f3/j444/d0MKa4dx+MAzDGDFihDFw4EC3tKemOnTokAEYP/30k2EY5nPf19fX+Oyzz2xlNm/ebADGsmXL3NXMau/cfjAMw+jevbtx7733uq9RNVDt2rWN//73v3odSKXQmNz9NCZ3L43JPYPG5J5BY3LPoDG556ip43LNSPcwubm5rFq1il69etn2eXl50atXL5YtW+bGltU827ZtIzY2lsaNG3PjjTeye/dudzepxtq1axcHDhywe12EhYWRlJSk14UbLF68mKioKJo3b86dd97J0aNH3d2kau348eMA1KlTB4BVq1aRl5dn93po0aIFDRs21OvBhc7th0IzZswgIiKCNm3aMG7cOLKystzRvGqvoKCATz75hMzMTDp37qzXgbicxuSeQ2Nyz6ExuWfRmLxyaUzuGTQmd7+aPi73cXcDxN6RI0coKCigXr16dvvr1avHli1b3NSqmicpKYn333+f5s2bk5aWxoQJE+jWrRsbNmwgJCTE3c2rcQ4cOABQ7Oui8D6pHH379mXw4MEkJCSwY8cOHn30Ufr168eyZcvw9vZ2d/OqHavVyn333UeXLl1o06YNYL4e/Pz8CA8Ptyur14PrFNcPAMOGDSM+Pp7Y2FjWrVvHww8/zNatW/n888/d2NrqZf369XTu3Jns7Gxq1arFF198QatWrVi7dq1eB+JSGpN7Bo3JPYvG5J5DY/LKpTG5Z9CY3L00LjcpkC5SjH79+tm227VrR1JSEvHx8Xz66afceuutbmyZiHsNGTLEtt22bVvatWtHkyZNWLx4MVdccYUbW1Y9jRkzhg0bNigfrJuV1A+33367bbtt27bExMRwxRVXsGPHDpo0aVLZzayWmjdvztq1azl+/DizZ89mxIgR/PTTT+5ulohUEo3JRYqnMXnl0pjcM2hM7l4al5uU2sXDRERE4O3tXWR124MHDxIdHe2mVkl4eDgXXHAB27dvd3dTaqTC575eF56ncePGRERE6LXhAmPHjuWbb77hxx9/pEGDBrb90dHR5Obmkp6eblderwfXKKkfipOUlASg14MT+fn50bRpUxITE5k8eTLt27fn1Vdf1etAXE5jcs+kMbl7aUzuuTQmdx2NyT2DxuTup3G5SYF0D+Pn50diYiILFy607bNarSxcuJDOnTu7sWU128mTJ9mxYwcxMTHubkqNlJCQQHR0tN3rIiMjgxUrVuh14WZ79+7l6NGjem04kWEYjB07li+++IJFixaRkJBgd39iYiK+vr52r4etW7eye/duvR6c6Hz9UJy1a9cC6PXgQlarlZycHL0OxOU0JvdMGpO7l8bknktjcufTmNwzaEzuuWrquFypXTxQSkoKI0aMoGPHjnTq1IkpU6aQmZnJqFGj3N20GuOBBx5gwIABxMfHs3//fsaPH4+3tzdDhw51d9OqrZMnT9p9Yrxr1y7Wrl1LnTp1aNiwIffddx+TJk2iWbNmJCQk8PjjjxMbG8ugQYPc1+hqqLR+qFOnDhMmTOCaa64hOjqaHTt28NBDD9G0aVOSk5Pd2OrqZcyYMcycOZMvv/ySkJAQW165sLAwAgMDCQsL49ZbbyUlJYU6deoQGhrK3XffTefOnbnkkkvc3Prq43z9sGPHDmbOnMmVV15J3bp1WbduHffffz+XXXYZ7dq1c3Prq4dx48bRr18/GjZsyIkTJ5g5cyaLFy9m3rx5eh1IpdCY3P00Jq98GpN7Bo3J3U9jcs+gMbln0Lj8LIZ4pNdff91o2LCh4efnZ3Tq1MlYvny5u5tUo9xwww1GTEyM4efnZ9SvX9+44YYbjO3bt7u7WdXajz/+aABFfkaMGGEYhmFYrVbj8ccfN+rVq2f4+/sbV1xxhbF161b3NroaKq0fsrKyjD59+hiRkZGGr6+vER8fb4wePdo4cOCAu5tdrRT3+APGtGnTbGVOnTpl3HXXXUbt2rWNoKAg4+qrrzbS0tLc1+hq6Hz9sHv3buOyyy4z6tSpY/j7+xtNmzY1HnzwQeP48ePubXg1cssttxjx8fGGn5+fERkZaVxxxRXG/PnzbffrdSCVQWNy99KYvPJpTO4ZNCZ3P43JPYPG5J5B4/IzLIZhGK4J0YuIiIiIiIiIiIiIVH3KkS4iIiIiIiIiIiIiUgoF0kVERERERERERERESqFAuoiIiIiIiIiIiIhIKRRIFxEREREREREREREphQLpIiIiIiIiIiIiIiKlUCBdRERERERERERERKQUCqSLiIiIiIiIiIiIiJRCgXQRERERERERERERkVIokC4iIiIiIiIiIiIiUgoF0kVEBICRI0cyaNAgdzdDRERERKTG0phcRMRzKZAuIiIeKTc3191NEBERERGp0TQmFxE5Q4F0ERE5r5dffpm2bdsSHBxMXFwcd911FydPngQgMzOT0NBQZs+ebXfMnDlzCA4O5sSJEwDs2bOH66+/nvDwcOrUqcPAgQNJTU21lS+cffP0008TGxtL8+bNK+36REREREQ8ncbkIiLupUC6iIicl5eXF6+99hobN25k+vTpLFq0iIceegiA4OBghgwZwrRp0+yOmTZtGtdeey0hISHk5eWRnJxMSEgIv/zyC7/++iu1atWib9++drNcFi5cyNatW1mwYAHffPNNpV6jiIiIiIgn05hcRMS9LIZhGO5uhIiIuN/IkSNJT09nzpw55y07e/Zs/u///o8jR44AsHLlSi699FL27NlDTEwMhw4don79+vzwww90796djz76iEmTJrF582YsFgtgfk00PDycOXPm0KdPH0aOHMncuXPZvXs3fn5+rrxUERERERGPpDG5iIjn0ox0ERE5rx9++IErrriC+vXrExISws0338zRo0fJysoCoFOnTrRu3Zrp06cD8NFHHxEfH89ll10GwB9//MH27dsJCQmhVq1a1KpVizp16pCdnc2OHTts52nbtq0G7CIiIiIixdCYXETEvRRIFxGRUqWmpnLVVVfRrl07/ve//7Fq1SreeOMNwH7xodtuu433338fML9COmrUKNtMl5MnT5KYmMjatWvtfv7880+GDRtmqyM4OLjyLkxEREREpIrQmFxExP183N0AERHxbKtWrcJqtfLSSy/h5WV+/vrpp58WKXfTTTfx0EMP8dprr7Fp0yZGjBhhu++iiy5i1qxZREVFERoaWmltFxERERGpDjQmFxFxP81IFxERm+PHjxeZoRIREUFeXh6vv/46O3fu5MMPP2Tq1KlFjq1duzaDBw/mwQcfpE+fPjRo0MB234033khERAQDBw7kl19+YdeuXSxevJh77rmHvXv3VuYlioiIiIh4NI3JRUQ8kwLpIiJis3jxYi688EK7nw8//JCXX36Z5557jjZt2jBjxgwmT55c7PG33norubm53HLLLXb7g4KC+Pnnn2nYsCGDBw+mZcuW3HrrrWRnZ2s2jIiIiIjIWTQmFxHxTBbDMAx3N0JERKqHDz/8kPvvv5/9+/drgSIRERERETfQmFxExDWUI11ERByWlZVFWloazz77LHfccYcG7CIiIiIilUxjchER11JqFxERcdjzzz9PixYtiI6OZty4ce5ujoiIiIhIjaMxuYiIaym1i4iIiIiIiIiIiIhIKTQjXURERERERERERESkFAqki4iIiIiIiIiIiIiUQoF0EREREREREREREZFSKJAuIiIiIiIiIiIiIlIKBdJFREREREREREREREqhQLqIiIiIiIiIiIiISCkUSBcRERERERERERERKYUC6SIiIiIiIiIiIiIipVAgXURERERERERERESkFAqki4iIiIiIiIiIiIiUQoF0EREREREREREREZFSKJAuIiIiIiIiIiIiIlIKBdJFREREREREREREREqhQLqISBX1/vvvY7FYSE1NdVqdqampWCwW3n//fafVWVY9evSgTZs2lX5eEREREZGqaNu2bfTp04ewsDAsFgtz5sxxd5OqrMWLF2OxWJg9e7a7myIiHkyBdBGRs+zYsYM77riDxo0bExAQQGhoKF26dOHVV1/l1KlT7m6e08ycOZMpU6a4uxluYbFYGDt2rLubISIiIlKswskSxf088sgjLjnn0qVLefLJJ0lPT3dJ/RVV0uNw7s/ixYvd3VSbRo0a2bUtKiqKbt268cUXXzj9XCNGjGD9+vU8/fTTfPjhh3Ts2NHp5xDnevLJJ7FYLBw5csTdTRGRCvBxdwNERDzFt99+y3XXXYe/vz/Dhw+nTZs25ObmsmTJEh588EE2btzI22+/7e5mOsXMmTPZsGED9913n93++Ph4Tp06ha+vr3saJiIiIiIATJw4kYSEBLt9rvr23tKlS5kwYQIjR44kPDzcJeeoiA8//NDu9gcffMCCBQuK7G/ZsmVlNuu8OnTowD//+U8A9u/fz1tvvcXgwYN58803+b//+z+nnOPUqVMsW7aMxx57TJNEREQqiQLpIiLArl27GDJkCPHx8SxatIiYmBjbfWPGjGH79u18++23Dp/HMAyys7MJDAwscl92djZ+fn54ebnvy0IWi4WAgAC3nV+KyszMJDg42N3NEBERkUrWr1+/Kj/D2NFxzE033WR3e/ny5SxYsKDIfk9Tv359uzYOHz6cpk2b8sorrzgcSC98z3D48GEAp37woXGnnCs/Px+r1Yqfn5+7myLiEZTaRUQEeP755zl58iTvvvuuXRC9UNOmTbn33nttt/Pz83nqqado0qQJ/v7+NGrUiEcffZScnBy74xo1asRVV13FvHnz6NixI4GBgbz11lu2HHyffPIJ//rXv6hfvz5BQUFkZGQAsGLFCvr27UtYWBhBQUF0796dX3/99bzX8eWXX9K/f39iY2Px9/enSZMmPPXUUxQUFNjK9OjRg2+//Za//vrL9pXTRo0aASXnSF+0aBHdunUjODiY8PBwBg4cyObNm+3KFH5Ncfv27bbZTGFhYYwaNYqsrKzztr3QqlWruPTSSwkMDCQhIYGpU6fa7jt58iTBwcF2fVFo7969eHt7M3ny5DKfqyRleRzHjx+Pr6+v7U3M2W6//XbCw8PJzs627fv+++9tj2FISAj9+/dn48aNdseNHDmSWrVqsWPHDq688kpCQkK48cYbHb4eERERqX7KMrZYt24dI0eOtKUtjI6O5pZbbuHo0aO2Mk8++SQPPvggAAkJCbbxYWpqaqnr51gsFp588km7eiwWC5s2bWLYsGHUrl2brl272u7/6KOPSExMJDAwkDp16jBkyBD27Nnj0GMwYsQIIiIiyMvLK3Jfnz59aN68uV17x44dy4wZM2jevDkBAQEkJiby888/Fzl237593HLLLdSrVw9/f39at27Ne++9V+F2RkdH07JlS3bt2lWuc5T0niElJYX4+HgAHnzwQbvxPMCaNWvo168foaGh1KpViyuuuILly5fb1V2YQuinn37irrvuIioqigYNGgBn1i5at24d3bt3JygoiKZNm9ryh//0008kJSURGBhI8+bN+eGHH+zq/uuvv7jrrrto3rw5gYGB1K1bl+uuu67I2k6Fbfj1119JSUkhMjKS4OBgrr766mLH2N9//z3du3cnJCSE0NBQLr74YmbOnGlXpqLvowoVFBTw6KOPEh0dTXBwMP/4xz/snqflfQ9QEceOHeOBBx6gbdu21KpVi9DQUPr168cff/xhK8d97MIAAQAASURBVFPe90Xp6encd999xMXF4e/vT9OmTXnuueewWq22MoWv9xdffJEpU6bY3utu2rTJoesRqU40I11EBPj6669p3Lgxl156aZnK33bbbUyfPp1rr72Wf/7zn6xYsYLJkyezefPmIvkPt27dytChQ7njjjsYPXq03YD+qaeews/PjwceeICcnBz8/PxYtGgR/fr1IzExkfHjx+Pl5cW0adPo2bMnv/zyC506dSqxXe+//z61atUiJSWFWrVqsWjRIp544gkyMjJ44YUXAHjsscc4fvw4e/fu5ZVXXgGgVq1aJdb5ww8/0K9fPxo3bsyTTz7JqVOneP311+nSpQurV6+2G7QDXH/99SQkJDB58mRWr17Nf//7X6KionjuuefO+7j+/fffXHnllVx//fUMHTqUTz/9lDvvvBM/Pz9uueUWatWqxdVXX82sWbN4+eWX8fb2th378ccfYxiGUwLPZXkcb775ZiZOnMisWbPsvk6bm5vL7Nmzueaaa2yz+z/88ENGjBhBcnIyzz33HFlZWbz55pt07dqVNWvW2D2G+fn5JCcn07VrV1588UWCgoIcvh4RERGpeo4fP14kj3JERARQ9rHFggUL2LlzJ6NGjSI6OtqWqnDjxo0sX74ci8XC4MGD+fPPP/n444955ZVXbOeIjIwsNlh4Ptdddx3NmjXjmWeewTAMAJ5++mkef/xxrr/+em677TYOHz7M66+/zmWXXcaaNWsqPKv65ptv5oMPPmDevHlcddVVtv0HDhxg0aJFjB8/3q78Tz/9xKxZs7jnnnvw9/fnP//5D3379mXlypW2tDkHDx7kkksusQXeIyMj+f7777n11lvJyMgokhqxLPLy8tizZw9169at0DnOfc9w5ZVX0qhRI+6//36GDh3KlVdeaRvPb9y4kW7duhEaGspDDz2Er68vb731Fj169LAFwM921113ERkZyRNPPEFmZqZt/99//81VV13FkCFDuO6663jzzTcZMmQIM2bM4L777uP//u//GDZsGC+88ALXXnste/bsISQkBIDffvuNpUuXMmTIEBo0aEBqaipvvvkmPXr0YNOmTUXGt3fffTe1a9dm/PjxpKamMmXKFMaOHcusWbNsZd5//31uueUWWrduzbhx4wgPD2fNmjXMnTuXYcOGATj0PqrQ008/jcVi4eGHH+bQoUNMmTKFXr16sXbtWgIDA8v1HqCidu7cyZw5c7juuutISEjg4MGDvPXWW3Tv3p1NmzYRGxtbrvdFWVlZdO/enX379nHHHXfQsGFDli5dyrhx40hLSyuydta0adPIzs7m9ttvx9/fnzp16jh0PSLViiEiUsMdP37cAIyBAweWqfzatWsNwLjtttvs9j/wwAMGYCxatMi2Lz4+3gCMuXPn2pX98ccfDcBo3LixkZWVZdtvtVqNZs2aGcnJyYbVarXtz8rKMhISEozevXvb9k2bNs0AjF27dtmVO9cdd9xhBAUFGdnZ2bZ9/fv3N+Lj44uU3bVrlwEY06ZNs+3r0KGDERUVZRw9etS2748//jC8vLyM4cOH2/aNHz/eAIxbbrnFrs6rr77aqFu3bpFznat79+4GYLz00ku2fTk5Obbz5+bmGoZhGPPmzTMA4/vvv7c7vl27dkb37t3Pex7AGDNmTKllyvo4du7c2UhKSrIr9/nnnxuA8eOPPxqGYRgnTpwwwsPDjdGjR9uVO3DggBEWFma3f8SIEQZgPPLII+e9DhEREameCsd4xf0YRvnGFsWNaT7++GMDMH7++WfbvhdeeKHIuNIwih8bFgKM8ePH224XjgWHDh1qVy41NdXw9vY2nn76abv969evN3x8fIrsL82YMWOMs8MYBQUFRoMGDYwbbrjBrtzLL79sWCwWY+fOnXbtBYzff//dtu+vv/4yAgICjKuvvtq279ZbbzViYmKMI0eO2NU5ZMgQIywsrNjH9Gzx8fFGnz59jMOHDxuHDx82/vjjD2PIkCEGYNx9993lOkdJ7xkM40zfvPDCC3b7Bw0aZPj5+Rk7duyw7du/f78REhJiXHbZZbZ9hc+zrl27Gvn5+XZ1FI7LZ86cadu3ZcsWAzC8vLyM5cuX2/YXjs3Pfo4U9xgtW7bMAIwPPvigSBt69epl997n/vvvN7y9vY309HTDMAwjPT3dCAkJMZKSkoxTp07Z1Vt4XHneRxWn8LGuX7++kZGRYdv/6aefGoDx6quv2vaV5T1ASQpfJ4cPHy6xTHZ2tlFQUGC3b9euXYa/v78xceJE276yvi966qmnjODgYOPPP/+0K/fII48Y3t7exu7du23nAIzQ0FDj0KFDpV6HSE2l1C4iUuMVplMpnEFxPt999x0AKSkpdvsLFxQ6N5d6QkICycnJxdY1YsQIu3zpa9euZdu2bQwbNoyjR49y5MgRjhw5QmZmJldccQU///yz3dfvznV2XSdOnODIkSN069aNrKwstmzZUqbrO1taWhpr165l5MiRdjMR2rVrR+/evW2PxdnOzfvYrVs3jh49anucS+Pj48Mdd9xhu+3n58cdd9zBoUOHWLVqFQC9evUiNjaWGTNm2Mpt2LCBdevWOS1fZlkfx+HDh7NixQp27Nhh2zdjxgzi4uLo3r07YM4ES09PZ+jQobb+PHLkCN7e3iQlJfHjjz8WOf+dd97plOsQERGRquuNN95gwYIFdj9QvrHF2WOa7Oxsjhw5wiWXXALA6tWrXdLuc8eCn3/+OVarleuvv96uvdHR0TRr1qzYsVBZeXl5ceONN/LVV19x4sQJ2/4ZM2Zw6aWXFlmstXPnziQmJtpuN2zYkIEDBzJv3jwKCgowDIP//e9/DBgwAMMw7NqbnJzM8ePHy/S4zZ8/n8jISCIjI2nfvj2fffYZN998M88991yFznHue4aSFBQUMH/+fAYNGkTjxo1t+2NiYhg2bBhLliwpMiYfPXq03WzmQrVq1WLIkCG2282bNyc8PJyWLVvazWov3N65c6dt39ltzcvL4+jRozRt2pTw8PBiH7/bb78di8Viu92tWzcKCgr466+/APM5f+LECR555JEis70Lj3P0fVSh4cOH270vvPbaa4mJibF731OW9wCO8Pf3t62bVVBQwNGjR6lVqxbNmze3e/zK+r7os88+o1u3btSuXdvu+darVy8KCgqKpDe65ppriIyMdPg6RKojpXYRkRovNDQUwG7wXZq//voLLy8vmjZtarc/Ojqa8PBw24Cv0LkD+NLu27ZtG2AOlkty/PhxateuXex9Gzdu5F//+heLFi0qMkg+fvx4iXWWpPBazk5HU6hly5bMmzevyKJEDRs2tCtX2Na///7b9liXJDY2tsgCRxdccAFg5uy75JJLbG+Y3nzzTbKysggKCmLGjBkEBARw3XXXlfsai1PWx/GGG27gvvvuY8aMGTzxxBMcP36cb775hvvvv982qC/s0549exZ7rnMfEx8fH1t+ShEREam5OnXqVOxio+UZWxw7dowJEybwySefcOjQIbtyFRkblkVx41vDMGjWrFmx5X19fR063/Dhw3nuuef44osvGD58OFu3bmXVqlV26+wUKq4NF1xwAVlZWRw+fBgvLy/S09N5++23efvtt4s937mPY3GSkpKYNGkSFouFoKAgWrZsaUtfc+jQoXKfo7T3E2c7fPgwWVlZJY7drVYre/bsoXXr1uetu0GDBnbBbYCwsDDi4uKK7ANzrF/o1KlTTJ48mWnTprFv3z5bih8o/nlX2vsHwBawLky/UxxH30cVOvc5YrFYaNq0qV1+97K8B3CE1Wrl1Vdf5T//+Q+7du2yW6epMD0QUOb3Rdu2bWPdunUlBscr+nwTqYkUSBeRGi80NJTY2Fg2bNhQruPKOkgqbfbIufcVzpJ44YUX6NChQ7HHlJTPPD09ne7duxMaGsrEiRNp0qQJAQEBrF69mocffrhMMzCcobgZLYDdANpRw4cP54UXXmDOnDkMHTqUmTNnctVVV9kG8o4oz+NYu3ZtrrrqKtsgevbs2eTk5NjNACks/+GHHxIdHV3kfD4+9v+Kz56BIiIiInKu8owtrr/+epYuXcqDDz5Ihw4dqFWrFlarlb59+5ZpbFjSePfswN65ihvfWiwWvv/++xJnPjuiVatWJCYm8tFHHzF8+HA++ugj/Pz8uP7668tdV+FjctNNN5UYkG3Xrt1564mIiKBXr15OO0dZZqNXVEl1lzSmL8tY/+6772batGncd999dO7cmbCwMCwWC0OGDCn2eeeM9w+OvI8qr7K8B3DEM888w+OPP84tt9zCU089RZ06dfDy8uK+++4r8viV5X2R1Wqld+/ePPTQQ8Wer3DiUiFXPt9EqjoF0kVEgKuuuoq3336bZcuW0blz51LLxsfHY7Va2bZtGy1btrTtP3jwIOnp6cTHx1e4HU2aNAHM4H5Jg++SLF68mKNHj/L5559z2WWX2fbv2rWrSNmyfghQeC1bt24tct+WLVuIiIgoMoPcEfv37y8yw/3PP/8EsFuQs02bNlx44YXMmDGDBg0asHv3bl5//XWntKE8jyOYg9eBAwfy22+/MWPGDC688EK7WT6FfRoVFVXuPhURERE5V1nHFn///TcLFy5kwoQJPPHEE7b9hTN3z1bS2LBw9m56errd/nO/gXm+9hqGQUJCQpGAnbMMHz6clJQU0tLSmDlzJv379y925nFx1/7nn38SFBRkm60bEhJCQUGBy8ZtkZGRLjtHZGQkQUFBJY7dvby8iswod4XZs2czYsQIXnrpJdu+7OzsIs+jsip8zm/YsKHIt4LPLVOR91FnO/c5YhgG27dvL/LhxvneAzhi9uzZXH755bz77rt2+9PT022LARcqy/uiJk2acPLkSb0XEXECTXkTEQEeeughgoODue222zh48GCR+3fs2MGrr74KwJVXXglQZHXzl19+GYD+/ftXuB2JiYk0adKEF198kZMnTxa5//DhwyUeWziT4+yZG7m5ufznP/8pUjY4OLhMX+eNiYmhQ4cOTJ8+3W7gu2HDBubPn297LJwlPz+ft956y3Y7NzeXt956i8jISLt8lgA333wz8+fPZ8qUKdStW5d+/fo5pQ3leRwB+vXrR0REBM899xw//fRTkZkoycnJhIaG8swzz5CXl1fk+NL6VERERORcZR1bFDemgaJjWMA2ieHcQGdoaCgRERFFciiXNC4qzuDBg/H29mbChAlF2mIYBkePHi1zXSUZOnQoFouFe++9l507d5Y4M3jZsmV2Oab37NnDl19+SZ8+ffD29sbb25trrrmG//3vf8V+W9UZ4zZXnsPb25s+ffrw5Zdf2qUiOXjwIDNnzqRr167nTbXoDN7e3kX6+vXXXy/1mwyl6dOnDyEhIUyePJns7Gy7+wrP48j7qLN98MEHdik/Z8+eTVpaWpH3Gud7D+CI4h6/zz77jH379hVb/nzvi66//nqWLVvGvHnzihybnp5Ofn6+09ouUt1pRrqICOan9DNnzuSGG26gZcuWDB8+nDZt2pCbm8vSpUv57LPPGDlyJADt27dnxIgRvP3227Y0ICtXrmT69OkMGjSIyy+/vMLt8PLy4r///S/9+vWjdevWjBo1ivr167Nv3z5+/PFHQkND+frrr4s99tJLL6V27dqMGDGCe+65B4vFwocffljsVyITExOZNWsWKSkpXHzxxdSqVYsBAwYUW+8LL7xAv3796Ny5M7feeiunTp3i9ddfJywsjCeffLLC11qc2NhYnnvuOVJTU7nggguYNWsWa9eu5e233y6SP3PYsGE89NBDfPHFF9x5553lyq/5+++/M2nSpCL7e/ToUa7HEcy8nkOGDOHf//433t7eDB061O7+0NBQ3nzzTW6++WYuuugihgwZQmRkJLt37+bbb7+lS5cu/Pvf/y5z20VERKRmK+vYIjQ0lMsuu4znn3+evLw86tevz/z584v9ll3hhIXHHnuMIUOG4Ovry4ABA2wTTZ599lluu+02OnbsyM8//2z7xmBZNGnShEmTJjFu3DhSU1MZNGgQISEh7Nq1iy+++ILbb7+dBx54wKHHJDIykr59+/LZZ58RHh5e4sSWNm3akJyczD333IO/v7/tA4EJEybYyjz77LP8+OOPJCUlMXr0aFq1asWxY8dYvXo1P/zwA8eOHXOora4+x6RJk1iwYAFdu3blrrvuwsfHh7feeoucnByef/55h9teFldddRUffvghYWFhtGrVimXLlvHDDz/Y5fcuj9DQUF555RVuu+02Lr74YoYNG0bt2rX5448/yMrKYvr06Q69jzpbnTp16Nq1K6NGjeLgwYNMmTKFpk2bMnr0aLty53sPcD4vv/wyQUFBdvu8vLx49NFHueqqq5g4cSKjRo3i0ksvZf369cyYMcNuAdmzne990YMPPshXX33FVVddxciRI0lMTCQzM5P169cze/ZsUlNTi8x0F5ESGCIiYvPnn38ao0ePNho1amT4+fkZISEhRpcuXYzXX3/dyM7OtpXLy8szJkyYYCQkJBi+vr5GXFycMW7cOLsyhmEY8fHxRv/+/Yuc58cffzQA47PPPiu2HWvWrDEGDx5s1K1b1/D39zfi4+ON66+/3li4cKGtzLRp0wzA2LVrl23fr7/+alxyySVGYGCgERsbazz00EPGvHnzDMD48ccfbeVOnjxpDBs2zAgPDzcAIz4+3jAMw9i1a5cBGNOmTbNrzw8//GB06dLFCAwMNEJDQ40BAwYYmzZtsiszfvx4AzAOHz5st7+4dhane/fuRuvWrY3ff//d6Ny5sxEQEGDEx8cb//73v0s85sorrzSA/2fvvsOjqL4Gjn93N70TQgokIaETSmgSem+iiKKCNGmiUhRELLyKiI0fSrWASleaiAhioRN67yWEFgglpBAIIT278/4xJBDSNrCbxvnw5AmZuTNzd+9OsnvmzLnK7t2789z3g4Bcvz7//HNFUYx/HjPs379fAZROnTrletytW7cqnTt3VpydnRUbGxulcuXKysCBA5WDBw9mthkwYIBib29v9GMRQgghROmT8d7pwIEDebYz5r3F1atXlRdeeEFxcXFRnJ2dlZdfflm5fv26AigTJkzIsr/PP/9cqVChgqLVarO8d0tMTFSGDBmiODs7K46OjkrPnj2VqKiobPvI7b1ghj/++ENp0aKFYm9vr9jb2ys1atRQRowYoYSGhhr93IwYMULJLYyxYsUKBVBef/31HNcDyogRI5TFixcrVatWVaytrZX69evn+N4uMjJSGTFihOLj46NYWloqnp6eSvv27ZWff/453z7m9v7/UY6R12eGjPft33zzTbZ1hw8fVjp37qw4ODgodnZ2Stu2bbO9X87rdZbxvtzYx5bx3Ga4deuWMmjQIMXNzU1xcHBQOnfurJw5c0apWLGiMmDAgHz7kPG4Hx6bv/76S2nWrFnmZ5LGjRsry5Yty9LGmM9ROck45rJly5Rx48Yp7u7uiq2trfLMM88oly9fznEbYz4DPCzjPMnpS6fTKYqiKMnJycq7776reHl5Kba2tkrz5s2VPXv2KK1bt1Zat26d437z+1wUHx+vjBs3TqlSpYpiZWWluLm5Kc2aNVOmTJmipKamKoqS92tKCKHSKIoJZ38TQgghCtELL7zAiRMnOH/+fJH249ixY9SrV49ffvmF/v37F2lfhBBCCCGeRGvWrOH5559n+/bttGzZMtt6jUbDiBEj5E5AYTLF6TNAcflcJERpJzXShRBClEgRERH8888/Rf6mFWDOnDk4ODjQo0ePou6KEEIIIcQTac6cOVSqVIkWLVoUdVfEE6K4fAYoTp+LhCjtpEa6EEKIEiUsLIxdu3Yxd+5cLC0teeONN4qsL2vXruX06dP8/PPPjBw5MnOiLiGEEEIIUTiWL1/O8ePH+eeff5g5cyYajaaouyRKueLyGaA4fS4S4kkhgXQhhBAlyrZt2xg0aBC+vr4sWrQIT0/PIuvLW2+9RWRkJF27ds0ySZUQQgghhCgcvXv3xsHBgSFDhjB8+PCi7o54AhSXzwDF6XOREE8KqZEuhBBCCCGEEEIIIYQQQuRBaqQLIYQQQgghhBBCCCGEEHmQQLoQQgghhBBCCCGEEEIIkQcJpAshhBBCCCGEEEIIIYQQeZDJRvNhMBi4fv06jo6OMvu3EEIIIYQwGUVRiI+Pp3z58mi1kt+SF3lPLoQQQgghzKEg78klkJ6P69ev4+PjU9TdEEIIIYQQpdSVK1fw9vYu6m4Ua/KeXAghhBBCmJMx78klkJ4PR0dHQH0ynZycCu24aWlpbNiwgU6dOmFpaVloxxVZyTgUPRmD4kHGoXiQcSh6MgbFQ2kZhzt37uDj45P5flPkTt6TP9lkHIoHGYeiJ2NQPMg4FA8yDkWvtIxBQd6TSyA9Hxm3jjo5ORX6m3Y7OzucnJxK9IuxpJNxKHoyBsWDjEPxIONQ9GQMiofSNg5SqiR/8p78ySbjUDzIOBQ9GYPiQcaheJBxKHqlbQyMeU8uxRiFEEIIIYQQQgghhBBCiDxIIF0IIYQQQgghhBBCCCGEyIME0oUQQgghhBBCCCGEEEKIPEiNdCGEEEKIYkCv15OWllbU3SgR0tLSsLCwIDk5Gb1eX9TdyZWlpSU6na6ou/FEMfV5VFJeayWdlZUVWq3keAkhhBCieJNAuhBCCCFEEVIUhRs3bnD79u2i7kqJoSgKnp6eXLlypdhP1Oni4oKnp2ex72dJZ67zqCS91koyrVaLv78/VlZWRd0VIYQQQohcSSBdCCGEEKIIZQT/3N3dsbOzk2CdEQwGA3fv3sXBwaHYZrEqikJiYiJRUVEAeHl5FXGPSjdznUcl4bVW0hkMBq5fv05ERAS+vr7yO1AIIYQQxZYE0oUQQgghioher88M/pUtW7aou1NiGAwGUlNTsbGxKdbBTVtbWwCioqJwd3eXMi9mYs7zqKS81kq6cuXKcf36ddLT07G0tCzq7gghhBBC5EjeDQohhBBCFJGMWs52dnZF3BNhLhljK/XvzUfOo5Ivo6SL1KEXQgghRHEmgXQhhBBCiCImpQxKLxnbwiPPdcklYyeEEEKIkkAC6UIIIYQQQgghhBBCCCFEHiSQLoQQQghRwukNeoIvBbPsxDKCLwWjN5i/PMLAgQPRaDRoNBqsrKyoUqUKn332Genp6WY/thDmoDco7LlwkzVHr7Hnwk30BqWouySEEEIIIYoRmWxUCCFKIb1Bz47wHUTER+Dl6EVL35botDLJnRCl0aqQVYxaN4qrd65mLvN28mZml5n0qNnDrMfu0qULCxYsICUlhX///ZcRI0ZgaWnJuHHjTH6s1NTUzDrKQpjaupMRTFx7moi45MxlXs42jH+mJs18pfa6EKL00RsU9ofFEhWfjLujDY39XdFppcySEI9Lzq3STTLShRCilFkVsgq/mX60XdSWPqv60HZRW/xm+rEqZFVRd00IYWKrQlbx0oqXsgTRAa7ducZLK14y+3lvbW2Np6cnFStWZNiwYXTo0IG//vqLlJQUxo4dS4UKFbC3tycoKIjg4ODM7W7evEnv3r2pUKECdnZ21KlTh2XLlmXZd5s2bRg5ciSjR4/Gzc2Nzp07oygKn376KX5+fnh4eODt7c3bb7+duc2tW7d49dVXKVOmDHZ2djz99NOcO3cuc/3ChQtxcXFh/fr11KxZEwcHB7p06UJERIRZnydRvK07GcGwxYezBNEBbsQlM2LpETaH3jTbsTNe5yNHjsTZ2Rk3NzfGjx+PoqjZ8CkpKXzwwQf4+PhgbW1NlSpVmDdvHqBOzDlkyBD8/f2xtbWlevXqzJw502x9FUKUHutORtBi8hZ6z9nLqOVH6T1nLy0mb2HdSfl7KMTjkHOr9JOMdCGEKEUygmoKWW9Hzwiqrey50uwZqkKIR6coColpiUa11Rv0vP3f29nOdwAFBQ0aRv03ig7+HYy6I8XO0u6xJ/yztbXl5s2bjBw5ktOnT7N8+XLKly/Pn3/+SZcuXThx4gRVq1YlOTmZhg0b8sEHH+Dk5MQ///xD//79qVy5Mo0bN87c36JFixg2bBi7du0C4I8//mD69OksXboUX19fEhISOHHiRGb7gQMHcu7cOf766y+cnJz44IMP6Nq1K6dPn8bS0hKAxMREpkyZwq+//opWq6Vfv36MHTuWJUuWPNZjF8WHoigkpRlX3khvUJjw16kcziJQAA0wedNFOtTxxtIi//PI1lJX4PNo0aJFDBkyhP3793Pw4EFef/11fH19GTp0KK+++ip79uzh22+/JTAwkLCwMGJiYgAwGAx4e3vz+++/U7ZsWXbv3s3rr7+Ol5cXPXv2LFAfhBBPjoyLhw//3rsRl8ywxYeZ3a8BXWp7FUnfhCjJ5Nx6MkggXQghSgm9Qc+odaPyDKqNXjea7tW7S5kXIYqpxLREHCY5mGRfCgpX46/iPNnZqPZ3x93F3sr+0Y6lKGzevJn169fTu3dvFixYQHh4OOXLlwdg7NixrFu3jgULFvDVV19RoUIFxo4dm7n9W2+9xfr161mxYkWWQHrVqlX5+uuvM3/+559/8PT0pEOHDiQlJeHk5ESTJk0AMgPou3btolmzZgAsWbIEHx8fVq9ezcsvvwxAWloaP/74I5UrVwZg5MiRfPbZZ4/0uEXxlJSmJ+CT9SbZlwJExacS+Nkmo9qf/qwzdlYF+4jl4+PD9OnT0Wg0VK9enRMnTjB9+nRat27NihUr2LhxIx06dACgUqVKmdtZWloyceLEzJ/9/f3Zs2cPK1askEC6ECJHeoPCxLWn87x4OHHtaToGeEopCiEKQM6tJ4eUdhFCiFJiR/iObOUdHqSgcOXOFXaE7yjEXgkhSrO///4bBwcHbGxsePrpp+nVqxcvvfQSer2eatWq4eDgkPm1bds2Lly4AKglKT7//HPq1KmDq6srDg4OrF+/nvDw8Cz7b9iwYZafX375ZZKSkqhSpQqjRo3izz//zJzcNCQkBAsLC4KCgjLbly1blurVqxMSEpK5zM7OLjOIDuDl5UVUVJTJnxshjNWkSZMsWexNmzbl3LlzHDlyBJ1OR+vWrXPd9ocffqBhw4aUK1cOBwcHfv7552znkRBCZNgfFputjNWDFCAiLpn9YbGF1ykhSgE5t54ckpEuhBClRES8cXXXjG0nhCh8dpZ23B1316i22y9vp+vSrvm2+7fPv7Sq2MqoYxdU27ZtmT17NlZWVpQvXx4LCwt+++03dDodhw4dQqfLeveLg4Oabf/NN98wc+ZMZsyYQZ06dbC3t2f06NGkpqZmaW9vnzVD3sfHh9DQUDZs2MC///7LyJEjmTp1Ktu2bTO6zxklXjJoNJrMetSidLC11HH6s85Gtd0fFsvABQfybTd/QEOaVHYz6timYmNjk+f65cuXM3bsWKZOnUrTpk1xdHTkm2++Yd++fSbrgxCidImKzz3Q9yjthBAqObeeHBJIF0KIUsLL0bh6a8a2E0IUPo1GY3R5lU6VO+Ht5M21O9dyLOmkQYO3kzedKncyWzkne3t7qlSpkmVZ/fr10ev1REVF0bJlyxy327VrF927d6dfv36AWuv57NmzBAQE5HtMW1tbunXrRuvWrRk9ejQBAQGcOHGCmjVrkp6ezr59+zJLu9y8eZPQ0FCj9itKD41GY3R5lZZVy+HlbMONuOQcb8fWAO6OVrSsWs6oGumP4uHA9969e6latSqBgYEYDAa2bduWWdrlQRlljIYPH565LOOuDyGEyIm7Y94X6AraTgihMvac+e9kBM0qu1HO0drMPRLmIqVdhBCilGjp2xJvJ2805FxzTYMGHycfWvrmHNgSQpQsOq2OmV1mAmQ77zN+ntFlRqHPiVCtWjX69u3Lq6++yqpVqwgLC2P//v1MmjSJf/75B1Brn2/cuJHdu3cTEhLCG2+8QWRkZL77XrhwIfPmzePkyZNcunSJJUuWYGtrS8WKFalatSrdu3dn6NCh7Ny5k2PHjtGvXz8qVKhA9+7dzf2wRQml02qY0E290PLwX8+Mn9/vUMms9UzDw8MZM2YMoaGhLFu2jO+++45Ro0bh5+fHgAEDGDx4MKtXryYsLIzg4GBWrFgBqOfRwYMHWb9+PWfPnmX8+PEcOJB/dr0Q4snV2N8VZ1vLPNu4O1rT2N+1kHokROnQ2N8Ve6v833OvOxlJq6+3MnndGW4npubbXhQ/EkgXQohS4sGgWm6KIqgmhDCfHjV7sLLnSio4Vciy3NvJm5U9V9KjZo8i6deCBQt49dVXeffdd6levTrPP/88Bw4cwNfXF4CPP/6YBg0a0LlzZ9q0aYOnpyfPP/98vvt1cXFhzpw5tGzZkhYtWrB582bWrl1L2bJlM4/bsGFDnn32WZo2bYqiKPz777/ZyrkI8aAutb2Y3a8Bns5Zs8k8nW34oU992lcva9bjv/rqqyQlJdG4cWNGjBjBqFGjeP311wGYPXs2L730EsOHD6dGjRoMHTqUhIQEAN544w169OhBr169CAoK4ubNm1my04UQ4mE376aQkq7Ps02a3sD120mF1CMhSoeQiDskpuZ8bmnufb3dvgqB3s4kpemZHXyBlpO3MnPTOeKT0wq1r+LxlLjSLj/88APffPMNN27cIDAwkO+++47GjRvnu93y5cvp3bs33bt3Z/Xq1ebvqBBCFIEeNXvwTpN3mLZ3WpbldpZ2/PrCr0UWVBNCmE+Pmj3oXr07O8J3EBEfgZejFy19W5r9otnChQtzXWdpacnEiROZOHFijutdXV3zfT8WHBycbdnzzz/P888/j8Fg4M6dOzg5OaHV3s8LKVOmDL/88kuu+xw4cCADBw7Mtk+pkS661PaiY4An+8NiiYpPxt3Rhsb+rmhQuHPnjlmPbWlpyYwZM5g9e3a2dTY2NkybNo1p06ZlW2dtbc2CBQtYsGBBluWTJk0yW1+FECXbJ2tOkZxmwNfVjtR0Azfu3K/X7OGklpqIvJNC37n7WPFG02wXGIUQ2aXpDby/8jgK0LCiC9dvJ2eZeNTT2YYJ3QLoUtuLdzpUY1NIFFM3hHLmRjzTN51l4e4whrWpTP8mftgakdUuilaJCqT/9ttvjBkzhh9//JGgoCBmzJhB586dCQ0Nxd3dPdftLl26xNixY3Ot0ymEEKWJtYX6JvjZqs8S5B3E+K3j0Rv0tPNvV8Q9E0KYi06ro41fm6LuhhAlmk6roWnlrNnnBoNcZClN9AYl28USc5btEaI4WXcygnWnbmCh1fBjv4ZU93TMdj5Ex6fQ86c9hMcm0mfuXn57vWmJr+X8JJ33T9JjLU7m7LjI6Yg7uNhZ8lP/RpSxs8p1HDQaDR0DPGhfw51/TkQwfeNZLsYk8NW/Z5i7I4yR7arQ6ykfrO/NyyJjWvyUqED6tGnTGDp0KIMGDQLgxx9/5J9//mH+/Pl8+OGHOW6j1+vp27cvEydOZMeOHdy+fbsQeyyEEIXveORxALpU6cLwp4az4tQKTkSdYNmJZQx7algR904IIYQQovCtOxnBxLWns2QJej2QJShEaRaXlMb4NacAeKN1JQLKOwFku3jo6WzD0qFB9PppLxejE+g3dx/LXm+Cq71VoffZFJ6k8/5JeqzFSVhMAjM2nQNg/DMBuDmoF54ePrceptVq6BZYnqdre7LqyDVmbjrHtdtJfLLmFD9tu8io9lWxt9bxxT8hMqbFTIkJpKempnLo0CHGjRuXuUyr1dKhQwf27NmT63afffYZ7u7uDBkyhB07duR7nJSUFFJSUjJ/zriVMy0tjbS0wqtblHGswjymyE7GoejJGBTcsRvHAKjlVov09HQG1B3A2E1jmXdkHq/Ve+2R9injUDzIOBQ9U49BWloaiqJgMBgwGAwm2eeTIKMUS8ZzV5wZDAYURSEtLQ2dLuvtunIui5xKGAnTW3cygmGLD/Pw/QU34pIZtvgws/s1kKCEKNUm/RtCdHwKldzseatd1TzbepexY8lrQfT8aQ+hkfH0n7ePpUOb5DtJaXHzJJ33T9JjLU4MBoUP/zhOarqBllXd6NGgQv4bPcRCp6VnIx+er1eB3w6E892W81y7ncT7fxzPsb2MadErMYH0mJgY9Ho9Hh4eWZZ7eHhw5syZHLfZuXMn8+bN4+jRo0YfZ9KkSTnW89ywYQN2dnYF6rMpbNy4sdCPKbKTcSh6MgbGiU+P52r8VQCuH73Ovyf+xT3dHQuNBYciDjHrj1n42fo98v5lHIoHGYeiZ6oxsLCwwNPTk7t375KammqSfT5J4uPji7oL+UpNTSUpKYnt27eTnp6eZV1iYmIR9UqIJ4feoDBx7elsASYABXUCuIlrT9MxwFNulxel0u4LMSw/cAWAST3qYGOZfw1mPzf7zMz0U9fvMHDBfn4dEoSDdckIIT1J5/2T9FiLm+UHrrAvLBZbSx1fvVAHjebRn18rCy39m/rxUkMfftlzif+tO0NOU/jImBa9kvFb8BHEx8fTv39/5syZg5ubm9HbjRs3jjFjxmT+fOfOHXx8fOjUqRNOTk7m6GqO0tLS2LhxIx07dsTSsmRd+S1NZByKnoxBwWy7vA1Ogp+zHy93ezlz+er01aw6s4oLThcY3nF4gfcr41A8yDgUPVOPQXJyMleuXMHBwQEbG5nQy1iKohAfH4+jo+NjfWgpDMnJydja2tKqVatsY2zuSSyFELA/LDbLbfEPU4CIuGT2h8Xmeyu+ECVNcpqecatOANA3yJegSsa/xqu4O7L4tSB6z9nLkfDbDF54gEWDGpeIyRCfpPP+SXqsxcmNuGQm/RsCwNjO1fFxNU3ira2VjrreLjkG0TPImBatEhNId3NzQ6fTERkZmWV5ZGQknp6e2dpfuHCBS5cu0a1bt8xlGbf+WlhYEBoaSuXKlbNtZ21tjbV19sk0LC0tiyRoUVTHFVnJOBQ9GQPjnIpRax8GegZmeb6GNhzKqjOrWHJyCd90+iZzQtKCknEoHmQcip6pxkCv16PRaNBqtWi1WhP07MmQ8Z4u47krzrRaLRqNJsfXjJzHQphfVHzuAaZHaSdESTJ901ku30zEw8maD56uUeDta3o58evgIPrM2cv+sFiG/nKQuQMaGZXVXpSepPP+SXqsxYWiKIxfc5L4lHQCfVwY2MzPpPuXMS3eivcnjwdYWVnRsGFDNm/enLnMYDCwefNmmjZtmq19jRo1OHHiBEePHs38eu6552jbti1Hjx7Fx8enMLsvhBCF4likWh+9rkfdLMs7VuqIt5M3sUmx/BX6V1F0TQghhBCi0Lk7Gne3j7HthCgpTl6LY+6OMAC+eL4OTjaPdvG2jrczCwc/hZ2Vjp3nYxi+5DCp6cV7fpIn6bw39jGsOnyVK7FSUs4U/jt5g42nI7HQapj8Yh2Tl1cxdkzn7Qzj+NXbJj22yF+JCaQDjBkzhjlz5rBo0SJCQkIYNmwYCQkJDBo0CIBXX301czJSGxsbateuneXLxcUFR0dHateujZVVyZx1Wggh8nI8Up2UJNAjMMtynVbHwMCBAMw7Mq+wuyWEEEIIUSQCfZyxssj9Y68G8HK2obG/a+F1SggzS9MbeH/lcfQGhWfqetExwCP/jfLQsKIr8wY8hbWFli1nohi1/Ajp+uIbTA8o74SlLu/gZmk579OMvKix7WwM7aYGM371SSLvSCbzo7qdmMona9S7wIe3qUwNT9OXgG7s74qXsw35heePX43jue938cavBwm9UfznDSotSlQgvVevXkyZMoVPPvmEevXqcfToUdatW5c5AWl4eDgRERFF3EshhCga6YZ0TkadBNTSLg8bVF+96LjhwgauxF0p1L4JIYQQQhS2NL2Bt5cdzTN7VgEmdAuQCdtEqTJ3RxinI+7gbGvJp91qmWSfTSuXZc6rjbDSafnv5A3e/f0YekMehZyLSGJqOkMXHSRNn3ffRrWvWuLP+30Xb/L64oOZPz/8aDT3vt7vXJ0WVdxI0yv8uvcyrb7eypf/nCY2QSa6L6iv/g0h5m4KlcvZM6JdFbMcQ6fVMKFbAJD7mH7evRY96ldAo4H1pyLpMnM7o5YfISwmwSx9EveVqEA6wMiRI7l8+TIpKSns27ePoKCgzHXBwcEsXLgw120XLlzI6tWrzd9JIYQoAmdvniVFn4K9pT2VylTKtr5SmUq09WuLgsLCowsLv4NCCCGEEIUkXW9g9PKjbAqJxNpCy+j2VfFyzn67vIutJW1ruBdBD4Uwj7CYBGZsOgvAx8/UpJzjo82NlJNW1coxq28DLLQa1hy9zrhVxzEUo2B6cpqe1385xP5LsTjaWDDu6RrZzvuMTPUtZ6JQ8prRsZg7HH6LwQsPkJxmoG31cnzXuz6eDz1WT2cbZvdrwPC2VVj8WhDLhjahYcUypKQbmLMjjJaTtzBtQyhxSWlF9ChKll3nY1hx8CoaDUx+sS7WFuabK6BLbS9m92uQ65j2b+rHtF712DC6FV3reKIosObodTpM28YHK49z7XaS2fr2pCsxk40KIYTI2/HI4/jchraOldAeOZpjm5Gez7H10lYWHF3AR60+QqspcddThRAPCg+HmJjc17u5ga+vWQ4dHR3NJ598wj///ENkZCRlypQhMDCQTz75hObNm5vlmEKYlUEPl3fD3Uhw8ICKzcieC1Y4Bg4cyO3btwucBPTpp5+yevVqjh49apZ+lRQGg8L7K4/zz4kILHUafurfkDbV3XmrfVX2h8USFZ9MGTtLxv5+jKj4VFYdvkbvxub5XSlEYTIYFD784zgp6QZaVnXjpYbeJj9GhwAPZr5Sn7eWHWbFwatYW+iY0C2AA5duERWfjLujWjKlsLO9U9MNDF9ymJ3nY7Cz0rFwUGMaVizDay0rZZ737o42ONla0P37XWw4Hcl/J2/QtY5XofbTFE5ei2PA/P0kpOppXqUss/s1xMZSR9c6Xlke68Pj0LRyWVa+2ZTgs9FM3RDKyWt3+HbLeRbtuczrrSoxqLkfdlZqmFBvUPLcV1HTGxT2hcVyKEZD2bBYmlZxN2v/klL1jFt1AoD+TSrSyM/8ZYG61PaiY4BnnuNQ1cORWX0bcvJaHNM2nmXLmSh+O3iFP49co0+QL8PbVs5Sc724j2tJIIF0IYQoJS4d307o92CbfgI+b5hjmxdsrKk1ypFThBF8KZh2/u0KuZdCCJMJD4fq1SE5jzqXNjYQGmqWYPqLL75IamoqixYtolKlSkRGRrJ582Zu3rxp8mMVRFpaGpaWjzahmniCnf4L1n0Ad67fX+ZUHjr/Dyq0Lrp+iQIzGBT+788TrDpyDZ1Ww/d9GtCmuppxrtNqaFq5bGbbN1pX4fO/TzM7+AIvN/TGQicJBqJk++3gFfaFxWJrqeOrF+qg0ZgnQPZMXS9S9YGMWXGMX/deZtXhqySk6jPXeznbMKFbAF1qF06QOk1v4K1lh9lyJgobSy3zBz5Fw4plgOznPai1rb/dcp5P1pyieWU3nO1KzvuG0Bvx9J+3j/jkdBr7uTLn1UbYWKqZ0Tk91odpNBraVnenTbVyrD91g6kbznIu6i7frA9lwa4whrWpQjkHKyb9d4aIuPvvMQt7TPOy7mQEE9eevtc/Hb+cO2j2/k3fdJbw2ES8nG14v0sNsxwjJ8aMKUDtCs7MH/gUhy7HMnXDWXZfuMnC3ZdYfiCcAc38eLNVZfaF3XzgeVMVp3EtKeSdghBClBLXw45jm553G01yCn08OwEw/8j8QuiVEMJsYmLyDqKDuj6vjPVHdPv2bXbs2MHkyZNp27YtFStWpHHjxowbN47nnnsOUD+ozZ49m6effhpbW1sqVarEypUrs+znypUr9OzZExcXF1xdXenevTuXLl3KXH/gwAE6duyIm5sbzs7OtG7dmsOHD2fZR8ZxnnvuOezt7fnyyy/59NNPqVevHvPnz8fX1xcHBweGDx+OXq/n66+/xtPTE3d3d7788sss+5o2bRp16tTB3t4eHx8fhg8fzt27dzPXL1y4EBcXF9avX0/NmjVxcHCgS5cuMkdPSXf6L1jxatYgOsCdCDS/D8Dy/H9mO/TKlSupU6cOtra2lC1blg4dOvDee++xaNEi1qxZg0ajQaPREBwcDMAHH3xAtWrVsLOzo1KlSowfP560NPWW/IULFzJx4kSOHTuWud3ChQtRFIVPP/0UX19frK2tKV++PG+//bbZHlNRUhSFiWtPsfzAFbQamNGrHp1reebavndjH1ztrQiPTWTt8eu5thOiJIi8k8xX/4YA8G6navi42pn1eC/U96bvvTs5HgyiA9yIS2bY4sOsO2n+v496g8KYFcdYfyoSK52Wn/s3okmlvAOPI9pVoXI5e2LupvDlv6fN3kdTOR91l75z93IrMY16Pi7MG9goM4O8oDQaDV1qe7FudCtm9KpHxbJ2xNxN5fO/T/P28qNZgq1QuGOal3UnIxi2+HCh9u/41dvM3XERgC9fqI2DdfHNSW5Y0ZWlQ5uw9LUg6vu6kJxm4KdtF2k6aTNvFvLzVlpJIF0IIUqJszfPGtXu+ZrPA/BHyB/cTr5tvg4JIQpOUSAhwbivJCNrHyYlGbe/AtQJdXBwwMHBgdWrV5OSkpJru/Hjx/Piiy9y7Ngx+vbtyyuvvEJIiPohPy0tjc6dO+Po6MiOHTvYtWtXZmA6NVWd/Co+Pp4BAwawc+dO9u7dS9WqVenatSvx8fFZjvPpp5/ywgsvcOLECQYPHgzAhQsX+O+//1i3bh3Lli1j3rx5PPPMM1y9epVt27YxefJkPv74Y/bt25e5H61Wy7fffsupU6dYtGgRW7Zs4f33389yrMTERKZMmcKvv/7K9u3bCQ8PZ+zYsUY/d6IQKAqkJhj3lXwH/nsfdcrJbDsCwDb4U7WdMfsrwHkUERFB7969GTx4MCEhIQQHB9OjRw8mTJhAz549My/SRERE0KxZMwAcHR1ZuHAhp0+fZubMmcyZM4fp06cD0KtXL959911q1aqVuV2vXr34448/mD59Oj/99BPnzp1j9erV1KlT5zGf5OJHURT+998ZFu25DMDXLwXSLbB8ntvYWVkwpIU/AD9svVCsaj0LURCKojB+9Unik9MJ9HZmUHN/sx9Tb1DYfCYq5/7c+z5x7WmzTkhqMCh88Mdx1h67joVWw6y+DWhVrVy+21lb6Jj8Yl00Glhx8Cq7zps+6cDULt9MoO/cvcTcTSXAy4lFgxrjaPP4mfQ6rYbn61dg05jWfPVCbXKr8lFYY5oXvUFh4trTefzFNn3/0vQG3l95HIMCzwWWp10ND5Pt25yaVXFj1bBmzB/YiJqejiTnMul2cRjXkqb4XkYRQghhtJuJN4lKiDaqbU23mtRxr8OJqBMsPbGU4U8NN3PvhBBGS0wEBwfT7rNFC+Pa3b0L9vZGNbWwsGDhwoUMHTqUH3/8kQYNGtC6dWteeeUV6tatm9nu5Zdf5rXXXgPg888/Z+PGjXz33XfMmjWL3377DYPBwNy5czNvPV+wYAEuLi4EBwfTqVMn2rXLWn7q559/xsXFhW3bttGqVavM5X369GHQoEFZ2hoMBubPn4+joyMBAQG0bduW0NBQ/v33X7RaLdWrV2fy5Mls3bo1c/L60aNHZ27v5+fHF198wZtvvsmsWbMyl6elpfHjjz9SuXJlAEaOHMlnn31m1PMmCklaInyVdwDVWBoUNHdvwNcVjdvg/66DlXHnUUREBOnp6fTo0YOKFdX9ZwS4bW1tSUlJwdMzazb1xx9/nPl/Pz8/xo4dy/Lly3n//fextbXFwcEBCwuLLNuFh4fj6elJhw4dsLS0xNfXl8aNGxv3eEqQ6ZvO8dP2+xmDxtaG7t+0Ij9uu8D5qLusP3WDp0tgvWQh1p28wYbTkVhoNfzvxbqFUvN4f1hstuzWBylARFwy+8NijSpNUVCKovDJXydZeegqWg1827s+HQKMD3I28nOlf5OK/LLnMuNWnWD96FbYWplv8sjHce12En3m7CPyTgrVPBxY/FqQycvRWOq0+Ls5kFcs1dxjmp+ieM39vP0iZ27EU8bOkgndAkyyz8Ki0WhoV8MDGwsdfebuy7VdUY9rSSMZ6UIIUQocjzxudFuNRsOQ+kMAKe8ihHh0L774ItevX+evv/6iS5cuBAcH06BBAxYuXJjZpmnTplm2adq0aWZG+rFjxzh//jyOjo6ZGe6urq4kJydz4cIFACIjIxk6dChVq1bF2dkZJycn7t69y5UrV7Lst1GjRtn65+fnh6OjY+bPHh4eBAQEoNVqsyyLirqfTbdp0ybat29PhQoVcHR0pH///ty8eZPExMTMNnZ2dplBdAAvL68s+xDCWIGBgbRv3546derw8ssvM2fOHG7dupXnNr/99hvNmzfH09MTBwcHPv74Y8LDw/Pc5uWXXyYpKYlKlSoxdOhQ/vzzT9LT86kFV8LMCj7Pt5vPAfDJswH0DTLywgfgZGPJoGZ+AHy/9TxKAe4qEKI4iEtM45O/TgHwZuvK1PRyKpTjRsXnU16ugO0KQlEUvvgnhMV7w9FoYFrPeo80aej7XWrg5WxDeGwi0zcZd3dvYYu8k0yfOXu5djuJSm72LH4tCFd7K7Mcy+gxvWP6Mc2PoigEhxr3fstUr7kL0XeZee9vy/hnAyjrYG2S/Ra26Lu53z36IHOcq6WRZKQLIUQpcCzyWIHa963bl/c2vsehiEMcu3GMQM9AM/VMCFEgdnZqZrgxjh41Ltt8506oV8+4YxeQjY0NHTt2pGPHjowfP57XXnuNCRMmMHDgwHy3vXv3Lg0bNmTJkiXZ1pUrp96WPWDAAG7evMnMmTOpWLEi1tbWNG3aNLP0Swb7HDLpH55wVKPR5LjMYFBvdb106RLPPvssw4YN48svv8TV1ZWdO3cyZMgQUlNTsbv3/OS0Dwm8FTOWdmpmuDEu74YlL+XbzNB7BVp/I843S+PPI51Ox8aNG9m9ezcbNmzgu+++46OPPspSbuhBe/bsoW/fvkycOJHOnTvj7OzM8uXLmTp1ap7H8fHxITQ0lE2bNrFx40aGDx/ON998w7Zt20rFxLzzdobx9bpQAD7oUoPBLQpe0mJQc3/m7gzj1PU7BIdG07aGu6m7KYTZfPnvaaLjU6hUzp6R7aoU2nHdHW2Mard472VqejlRzcMx/8ZGmrIhlHk7wwD4X486PF+/wiPtx8Hagi9fqM3ghQeZu+Miz9b1oq63i8n6+bhi7qbQZ85eLt9MxMfVliVDg4x+3h+Fsfv+fus5yjla06yKm9n68qDdF2KYuuEshy7nfbE5w/VbSSiK8liT7RoMCuP+OEFquoFW1crxwiO+xooDY8f1bGQ8eoNSKHe0lGSSkS6EEKVAQQPpbnZuPF/jeUCy0oUoVjQatbyKMV+2tsbt09bWuP09xoeNDAEBASQkJGT+vHfv3izr9+7dS82aNQFo0KAB586dw93dnSpVqmT5cnZ2BmDXrl28/fbbdO3alVq1amFtbU2MGSZPBTh06BAGg4GpU6fSpEkTqlWrxvXrMvlgiaTRqOVVjPmq3A6cygM5v/4VNBgcvNR2xuyvgOeRRqOhefPmTJw4kSNHjmBlZcWff/6JlZUVen3Wyft2795NxYoV+eijj2jUqBFVq1bl8uXLWdrktB2opWK6devGt99+S3BwMHv27OHEiRMF6mtxtGTfZT7/W50ocFT7qgxrUzmfLXJWxt6Kfk3ULPbvtpyTi2OixNh1PoYVB68CMPnFuthYFl5pksb+rng52+Ty2/O+A5du0XnGdkYvP8KlmIR8Wufvu83n+GGreufaZ91r0esp38faX7saHjwXWB6DAu+vPE6aPuda0oXtdmIq/ebu40J0Al7ONix9rQlezka+93tExo7puagE+szdR585ezkcblxw+1EcDr9F37l76TNnH4cu38LaQoO9lS7f/k1eH8pLP+5h94VHf8+4dH84+y/FYmel46sXaj9WUL6oGTuuP2y9wNMzt7PuZIT8HcyDBNKFEKIUKEhplwyD66sT8i0+sZiUdONu9xJCCICbN2/Srl07Fi9ezPHjxwkLC+P333/n66+/pnv37pntfv/9d+bPn8/Zs2eZMGEC+/fvZ+TIkQD07dsXNzc3unfvzo4dOwgLCyM4OJi3336bq1fVoEDVqlX59ddfCQkJYd++ffTt2xdbYy8gFFCVKlVIS0vju+++4+LFi/z666/8+OOPZjmWKEa0Ougy+d4PD3/EVH9OajNBbWdi+/bt46uvvuLgwYOEh4ezatUqoqOjqVmzJn5+fhw/fpzQ0FBiYmJIS0ujatWqhIeHs3z5ci5cuMC3337Ln3/+mWWffn5+hIWFcfToUWJiYkhJSWHhwoXMmzePkydPcvHiRRYvXoytrW1mXfaSauWhq3z050kA3mhdidEdqj7W/l5r4Y+VhZbD4bfZc/GmKboohFklpeoZt0q9INa/SUWe8nMt1OPrtJrMmtE5/fbUoJZaerq2J4oCq49ep/20bYxbdZzrt42cMP0hc7ZfZOpGtQTL/3WtwatN/R65/w+a0C2AMnaWnLkRz8/35looSneS0+g/bz9nbsRTztGapUOb4ONa8DsHC8qYMZ3cow4DmlbEUqdh94Wb9Ji1m8ELD3DqepzJ+nHqehxDFh6gx6zd7Dp/E0udhlebVmTH++2Y2jMwz/51DPDA2kLLocu36DNnH33nFjzYfyMumf/9dwaAsZ2q413G/M+9ORkzrt3rlcfJxoKzkXd5c/Fhnvt+F8GhURJQz4EE0oUQooRLN6RzKuoUMXZgsM6nbpuNDbipt+B1rNQRbydvYpNiWRO6phB6KoQwKTc39ZzOywPnvCk5ODgQFBTE9OnTadWqFbVr12b8+PEMHTqU77//PrPdxIkTWb58OXXr1uWXX35h2bJlBASob+Tt7OzYvn07vr6+9OjRg5o1azJkyBCSk5NxclLru86bN49bt27RoEED+vfvz9tvv427u3lKLgQGBjJt2jQmT55M7dq1WbJkCZMmTTLLsUQxE/Ac9PwFnB6qr+tUHuXlRaRVedosh3VycmL79u107dqVatWq8fHHHzN16lSefvpphg4dSvXq1WnUqBHlypVj165dPPfcc7zzzjuMHDmSevXqsXv3bsaPH59lny+++CJdunShbdu2lCtXjmXLluHi4sKcOXNo3rw5devWZdOmTaxdu5ayZUvuhGJrj13n/ZXq3XgDm/nxYZcaj50t6O5kwytP+QDw/Zbzj91HIcxt+qazhMcm4uVsw/tdqhdJH7rU9mJ2vwZ4Omd9P+LpbMPsfg0Y3MKf2f0asnZkC9pWL4feoLBs/xXafBPMp3+dIjre+GSeX/Zc4st/1XlWxnSsxuutHu0OlJyUdbBm/LPq+5OZm89xIdrIMntmkJCSzqAFBzhxLQ5XeyuWvhaEv5txk1ibQn5j2quxLxO712br2Db0auSDTqthy5konvl2JyOWHOZ8VPwjH/t8VDwjlhzmmW93svlMFDqthl6NfNg6tg2fda+Nu5NNvv2b82ojdrzfllfvBft3nVeD/UOMDPYrisLHq09yNyWdej4uDLg3h0ZJl9/zNvOV+uz4oB1vtauCvZWOE9fiGLjgAD1/2sNeubichUaRywt5unPnDs7OzsTFxWV+qCsMaWlp/Pvvv3Tt2rVU1C4sqWQcip6MQf5OR5+m1qxaOFg5ENfnBNqZ38L06dCuHVSpAj//DM2awXffqQE13/u3P47fMp4vdnxBp8qdWN9vfa7HkHEoHmQcip6pxyA5OZmwsDD8/f2xyS8onpPwcMir1MlD53xh0mg0/Pnnnzz//PMm37fBYODOnTs4OTllmTy0OMprjIvqfWZ+fvjhB7755htu3LhBYGAg3333HY0bN861/YwZM5g9ezbh4eG4ubnx0ksvMWnSpCyPt6D7fFhez9Vjn0cZDHq1ZvrdSHDwgIrNMKApMa+1kiyvMdQbFPacj2LDjn10ahlEfIqBkcuOoDco9G7sw1cv1DHZLffXbifR+uutpBsU/hjWjIYVy5hkv6XBw+PQtIq71NEtZA+OQZUatZmwNgQFmDegEe1rehR53/aHxRIVn4y7ow2N/V1zfH0cvBTLlA2h7L0YC4CtpY4Bzfx4s3UlXOysct3fpZt3GbdKvQNleJvKvNe5uslLbSiKwoAFB9h+NprGfq4sf70J2lxe46Z6P/jw46xTwZnXfjnA3ouxONlYsOz1JtQq7/zI+38cxo5pWEwCMzad5a9j11EU0Grg+foVGN2+Gr5l7YzaX/jNRGZsPsvqI9cwKGqVtG51yzO6Q1UqlXPItX/5/U66EpvId1vOsfLQVQz3Ip/P1PXinQ7VqOLukGVfGX27EH2Xbzefx1Kn4Z+3W5q0tn9xYMy43rybwo/bLvDLnsukpKuljlpWdePdTtWp5+OSZV+m/Ltg7GvOHArynlwmGxVCiBLu2A01I6uOex20Ff0gVn1jSuvW0KuXGkjftw98fODeBH4ZBtUfxBc7vmDjhY2Ex4Xj61w0ATchxCPy9S2yQLkonX777TfGjBnDjz/+SFBQEDNmzKBz586EhobmeDfA0qVL+fDDD5k/fz7NmjXj7NmzDBw4EI1Gw7Rp0x5pn0VGqwP/llmXGYpHrdwn1bqTEUxce5qIuGRAxy/nDmau61G/Al8+b7ogOkAFF1t6NKjAioNX+WHreeYPfMpk+y7JchoHL2cbJnQLoEttr3y3F4/v4THgnJqZ3ahimSIPooNaOqJp5fzvcmnk58qyoU3YfeEm36wP5eiV2/y47QJL9l5mSEt/hrTwZ9f5mAcea1aDm/ubJYgOagLAVy/UptP07ey/FMuyA+H0DTJfCaysY6qystCSmm7AwdqCX4cEFVkQHYwfU383e2a+Up9hbSozfeNZ1p+KZNXha/x19Do9n/LhrXZVOHbldrbH6uVsw9vtq3Di2h1WHLhC+r1Id6cAD8Z0qkYNz7yDmTqthiB/V26GKATlEnD1cbXj65cCebN1ZaZvOsfaY9f553gE/52I4IX63ozuUJVT1+NyfL11CvAsdUF0MG5cyzpY89EzAbzWshLfbznP8gPh7DgXw45zMXSo6cG7napx+WaCSf8u5HQ+FNe/M5JWIYQQJVzGRKOBHmq9ODImD6tTB6pXh4YNQa+H33/Ptm2lMpVo69cWBYWFRxcWUo+FEEIUV9OmTWPo0KEMGjSIgIAAfvzxR+zs7Jg/P+eJqXfv3k3z5s3p06cPfn5+dOrUid69e7N///5H3qcQoH6oHrb4cI7BNID2Nd1zzRZ9HMPaVEGrgS1nojh5zXQ1f0uq3MbhRlwywxYfZt3JiCLq2ZMjr3Ph4OVbJW4MNBoNzau48efwZsx9tRE1vZyIT0lnxqZzNPlqM2/mcd4/5VfGrJM+epexY2wntUzO//49w41c+vG4chvT1HvZv2+2rkTgA5m/JUENTyd+6t+Iv0Y2p1W1cqQbFJbuC6fl5K05jmlEXDLjVp1k6b5w0g0KraqVY82I5vz8aqN8g+gFVamcA9/1rs9/o1rSMcADgwJ/HL5K629y7hvAvyciSty5ZWoeTjZ8/nxttrzbhpcbeqPVwKaQSJ6euSPH5+1R/y6UtL8zEkgXQogSLmOi0boedSE9HU6dUlfUrat+79NH/b5sWY7bD6k/BIAFRxdgUCTzTghhGoqimKWsizCf1NRUDh06RIcOHTKXabVaOnTowJ49e3LcplmzZhw6dCgzcH7x4sXM290fdZ9C6A0KE9eeJrcapBrgi39C0BtMX6XU382eZ+uWB2BW8JNdKz2vcchYNnHtabOMg1AZcy6U1DHQaDR0CPDgn7da8H2f+vi72ZGQqs+9PfDZ3+Z/rAOa+VHPx4X4lHQ+Xn3S5JMt5jemAEv2hZfIMQWo6+3CL4Mbs+KNpjzlVyYz0zw3VjoNy14L4pfBjc1+8aCmlxNzXm3E6hHNaVGlLPk9xSX13DI1H1c7vnk5kI1jWvNMHc9c2yn3vj5Zc4pLMQlciU3M9+tSTALj15wqUX9npLSLEEKUcJkZ6Z6BcP48pKSAvT34+6sNevWCsWNh5064fBkqZr1FsUfNHjj/68yl25fYGraV9pXaF/ZDEEIIUQzExMSg1+vx8MhaJsDDw4MzZ87kuE2fPn2IiYmhRYsWKIpCeno6b775Jv/3f//3yPsESElJISXl/iR0d+7cAdS6tGlpaVnapqWloSgKBoMBg4lLsWQEUDL2L8zDYDCgKAppaWnodDr2hcXmmpEK6ofriLhk9pyPIsjf1eT9eaNlRf46dp3/Tt4g5NqtLLV0nyRFPQ7iyRmDzjXL4WipYcCiw7m2KczH+lX3ALrP3sOmkEj+OnKVrg8FDzP+Dj3898gY+Y0plI4xre/tyNttK9F/waE826XqFfQG/SM9l486DrU87XmzlT87z+c+iWZpObdMydfFmt5PefPPiRt5touKT6HNlGCTHLOwxqEgryEJpAshRAkWkxjD9fjrgFojnTX/qStq14aMSdEqVIA2bWDrVli+HD74IMs+bC1t6VOnD7MPzmb+0fkSSBdCCGG04OBgvvrqK2bNmkVQUBDnz59n1KhRfP7554wfP/6R9ztp0iQmTpyYbfmGDRuws7PLsszCwgJPT0/u3r1LamrqIx8zL/Hx8WbZr1ClpqaSlJTE9u3bSU9P51CMBtDlu92GHfu4GWKeLLU6ZbScuKXlk2U76Vf1ybyIUhzG4Un3JI1BcXus7by0rL+q5aM/j5Fw8TD2OcwpunHjxgLvt7g9TnMqrMcq41B4jH3edBoFnRFVmPQK6JX8G5p7HBITE41uK4F0IYQowTLKulQqUwlHa0c4rv6cWdYlQ58+aiB96dJsgXSAwfUHM/vgbP44/QffP/09ZWzLmLvrQogHmPq2YVF8lKSxdXNzQ6fTERkZmWV5ZGQknp4538o7fvx4+vfvz2uvvQZAnTp1SEhI4PXXX+ejjz56pH0CjBs3jjFjxmT+fOfOHXx8fOjUqRNOTllrpyYnJ3PlyhUcHBywsbEp0GPOj6IoxMfH4+joaNa6vE+65ORkbG1tadWqFTY2NpQNi80ysWhuOrUMMluGmk9gHD1+3MfhWB3/a9IKX1e7/DcqZYwdh2oBtenayKcQevTkKQ7nQmEpbo+1fbqB87P2cCE6gYN6XyZ3r525Li0tjY0bN9KxY0csLXOIsOfixLU45v4VAtzJt62Maf4edRwKo2+llbHP26JBTxn1vO0Li6Xf/KIfh4w7H40hgXQhhCjBjt3IY6LRB734IgwfrgbaT55UM9Yf0NCrIXU96nI88jjLTi5j+FPDzd11IQRkvulPTEzE1ta2iHsjzCEjw6WgH/CKgpWVFQ0bNmTz5s2Z9e0NBgObN29m5MiROW6TmJiIVpt12iWdTs1UUhTlkfYJYG1tjbW1dbbllpaW2Z5LvV6PRqNBq9Vm68vjyijnkrF/YR5arRaNRpM5vk2ruOPlbMONuOQc66ZqAE9nG5pWcUdnhglHARr4udGqWjm2n41m7q5wJvWok/9GpczlW8ZNtPjxmhD2hN3mnQ7VntgyOOaScS7kVgqkMM6FwlIczvsHWVrC1y8F8tKPu1l15DovNPCmZdVyD7XJ/jcpJ6E34pm2MZT1pyLzbStjWnDGjkNR9K20MfXzVlzGoSCvH3k3KIQQj0hv0BN8KZhlJ5YRfCkYvSH3yXHMJaM+el2PexnouWWklykDTz+t/j+HSUc1Gg2D6w0GYN6ReWbpqxAiO51Oh4uLC1FRUdy8eZOkpCSSk5Ply4iv1NTUIu9DXl9JSUncvHmTqKgoXFxcMoPLxd2YMWOYM2cOixYtIiQkhGHDhpGQkMCgQYMAePXVVxk3blxm+27dujF79myWL19OWFgYGzduZPz48XTr1i3zMee3TyEeptNqmNAtIMd1GR+jJ3QLMHtw4612VQBYeegKEXFJZj1WcfPnkat8vPpk5s8PP9MZPzeqqN7F+M/xCDpN38a7K44RftP4W+RF3orLuVAYHnysub3eCvuxNqxYhgFN/QD4vz9PkJiaXqDtw2ISGLX8CF1mbmf9qUi0GujRoAKfd6+NhuLzOM2lOI5phuLct+LM1M9bSRwHyUgXQohHsCpkFaPWjeLqnauZy7ydvJnZZSY9avYotH5klHYJ9AiEO3fg0iV1xcMZ6aCWd/nrLzWQ/sUX8NAt6v3q9uP9Te9zOOIwR28cpZ5nPfN2XggBkFneIioqqoh7UnIoikJSUhK2trbFvtyGi4tLniVMiptevXoRHR3NJ598wo0bN6hXrx7r1q3LnCw0PDw8S2b2xx9/jEaj4eOPP+batWuUK1eObt268eWXXxq9TyFy0qW2F7P7NWDE0iPoDffz1DydbZjQLYAutb3M3oen/Fxp7O/K/rBYft5+kQndapn9mMXBP8cjeHfFMRQF+jepSLPKZfns79NZsqIfHIeQiDtM23iWjacj+ePwVdYcvUavp3x4q11VPJ1NW27pSVS5XM5Z/oV5LhSWjPN+4trcX2+FbWzn6mw4dYMrsUlM23CWj5/N+cLGg67dTuLbTedYefhq5u+vZ+p48U7HqlRxdwSgnKNVsXqc5lIcx7Qk9K04M/XzVtLGQaOUpMKNReDOnTs4OzsTFxeXrR6jOaWlpfHvv//StWvXEnErcGkl41D0iuMYrApZxUsrXkJ56OYjzb1rpit7riyUYHqaPg2HSQ6k6lO58PYFKoXcgObN1clFr17NvkFiIri7Q0IC7NkDTZpka9Lz9578fvp33mr8Ft8+/e39YxXDcXgSyTgUPXOOgV6vL9CM8U+ytLQ0tm/fTqtWrYr1uWBpaZlnJnpRvc8sifJ6rpKTkwkLC8Pf39/kNdINBgN37tzBycnpiS3tsnDhQkaPHs3t27fNdozcxjBdb6DG+P9IN0APPz092gUV+m32O85F03/efmwstez8oB1uDtlLDpUmG07dYPiSw6QbFHo18mFSjzpotRr0BoU956PYsGMfnVrmPA5Hr9xm6oZQdpyLAcDKQkv/JhUZ1qZyludNb1DYHxZLVHwy7o42NPZ3LVbZhsXNO78d5c8j1+gU4M6rTXzzHIPSori9RraGRjFowQG0Glj5ZjMSU1JzHIeo+GRmbb3A0n3hpOrV0mDtargzpmM1aldwzrbf4vY4zckcj9VU78ufpHEwJWP+LhR0f0U1DgV5Ty4Z6UIIUQB6g55R60ZlC6IDKCho0DB63Wi6V++OTmve2/jP3jxLqj4VBysH/Fz84PgGdcXDZV0y2NnBCy/A4sXqpKM5BNKH1B/C76d/Z/HxxXzd8WtsLCSLSIjCotPpSkz5j6Km0+lIT0/HxsamWAfSRcmiN+g5HHWY6MRoytmVo4F7g8yL5EXh0qVL+Pv7c+TIEerVq5e5fODAgdy+fZvVq1eb/Jh+fn6MHj2a0aNHZy7r1asXXbt2NfmxjHHtdhLpBjUg29IznaAiCG60qOJGoLczx67GMW9nGB90qVGoxy9M285GM3LpEdINCt3rleere0F0UG+/D/J35WaIkus41PNx4dchQey7eJMpG0I5cOkW83aGsWx/OIOa+/F6y8rsuRiTLevQq5hmHRYHl28msOboNQDealeNGh52eY5BaaHTamhauWxRdyNT2+ruPF+vPKuPXqfnT3tINyiAjl/OHcTL2YZ3O1bjXPRdFu2+RHKaGkBvVrks73aqTsN75Y9yUtwepzkV58danPtWnBnzd6Gg+ysJ4/BkplUIIcQj2hG+I0s5l4cpKFy5c4Ud4TvM3pcH66NrNdrcJxp9UJ8+6vfffoP07DX+OlTqgI+TD7eSb7HmzBpTd1kIIYQoljZd3kTnPzozeP1gPtjxAYPXD6bzH53ZFL6pqLtW5GxtbXF3dy+SY1+MSQDAz9WOoooZajQaRrarCsCvey4Tl1g67xzafSGG1385SKrewNO1PZn6cuAjB0WCKpVlxRtNWTS4MXW9nUlM1fPD1gsETdrEm4sPZ5s480ZcMsMWH2bdyQhTPJRS5cdtFzAo0LpaOep4Z89oFoWneRU3gHtB9Psi4pIZu/I4P227SHKagfq+Lix9LYilQ5vkGUQXQpRMEkgXQhRbeoOebZe3sf3WdrZd3lYkk3k+LCLeuDf4xrZ7HMduqIH0QI9AdUFuE40+qEMHKFsWoqJgy5Zsq3VaHQPrDQRg/tH5puyuEEIIUSxturyJMcFjiEyMzLI8KjGKsdvGsu36NrMde926dbRo0QIXFxfKli3Ls88+y4ULFwDw9/cHoH79+mg0Gtq0acOnn37KokWLWLNmDRqNBo1GQ3BwMABXrlyhZ8+euLi44OrqSvfu3bmUMXcKaib7888/z5QpU/Dy8qJs2bKMGDEis6RUmzZtuHz5Mu+8807mvkEt7eLi4pKl37Nnz6Zy5cpYWVlRvXp1fv311yzrNRoNc+fO5YUXXsDOzo6qVavy119/Ffj5CYu+F0h3syvwtqbUvoY7NTwduZuSzsLdl4q0L+Zw8FIsry06SEq6gfY13Jn5Sn0sdI8XKtBoNLSuVo41I5rzU/+GVHN3yMzUfVhGWHLi2tNZ6uE/6a7fTmLlITWBJ2PiW1E09AaFaRvP5tnGQqth7qsNWTWsGc3uBd2FEKWPBNKFEMXSqpBV+M30o+OSjky7PI2OSzriN9OPVSGrirRfXo7G3XJqbLvHcTxKDZzX9agLimJcRrqlJfTsqf5/6dIcmwyqNwiAjRc2cvn2ZZP1VwghhCgMiqKQmJZo1Fd8SjyT9k/KtWSbgsLMEzOJT4k3an8FnX4qISGBMWPGcPDgQTZv3oxWq+WFF17AYDCwf/9+ADZt2kRERASrVq1i7Nix9OzZky5duhAREUFERATNmjUjLS2Nzp074+joyI4dO9i1axcODg506dKF1NTUzONt3bqVCxcusHXrVhYtWsTChQtZuHAhAKtWrcLb25vPPvssc985+fPPPxk1ahTvvvsuJ0+e5I033mDQoEFs3bo1S7uJEyfSs2dPjh8/TteuXenbty+xsbEFen7C7mWk+5e1L9B2pqbVahjRVg1kzt8Vxt2U7Hf1lVTHr95m0IIDJKbqaVnVjR/6NsDKwnRhAo1GQ+dankx4Lu+JWhXUzN79YQV7jZRmP2+/SJpeLZnQyM+1qLvzRNsfFpvtToqHpRsU7K0ti/0k6EKIxyM10oUQxU5uk3leu3ONl1a8VGiTeeakpW9LvJ28cy3vokGDt5M3LX1bmr0vWTLSr1yBuDiwsIAa+dTu7NMHZs+GVavU77a2WVb7l/GnnX87toRtYdGxRXzS+hNzPQQhhBDC5JLSkwhaGmSy/UUnR9NiRQuj2u7rsw87S+Ozp1988cUsP8+fP59y5cpx+vRpypUrB0DZsmXx9PTMbGNra0tKSkqWZYsXL8ZgMDB37tzMIM6CBQtwcXEhODiYTp06AVCmTBm+//57dDodNWrU4JlnnmHz5s0MHToUV1dXdDodjo6OWfb9sClTpjBw4ECGDx8OwJgxY9i7dy9Tpkyhbdu2me0GDhxI7969Afjqq6/49ttv2b9/P126dDH6+ckIpPu52cENozczi651vJi+8SwXYxJYsvcyb7SuXLQdMoHT1+/Qf95+4lPSaezvys/9G2FjaZ65OmLuphjVLio+72DlkyI6PoVl+8MBeOteaSFRdIx9XcrrV4jSTzLShRDFSn6TeQKMXje6yMq86LQ6xrcan+O6jAnJZnSZYfaJRqMToom4q2aK1Xavfb+sS82aYGWV98bNmoGvL8THw7//5thkSP0hACw4ugCDkvNtuEIIIYR4POfOnaN3795UqlQJJycn/Pz8AAgPDy/Qfo4dO8b58+dxdHTEwcEBBwcHXF1dSU5OziwVA1CrVq0skxp7eXkRFRVVoGOFhITQvHnzLMuaN29OSEhIlmV1Hyg1Z29vj5OTU4GPdT8jvWhLu4A6CdqwNmrwfM6OiySnFX3JwcdxLjKe/vP2EZeURn1fF+YPfApbK/O9f3V3NG4Ce2PblXbzdoaRkm4g0MeF5lWK/+R7pZ28foUQGSQjXQhRrBRkMs82fm0Kr2MPCIlWPyha66xJ0d/PrvF28mZGlxmFki1/PFINnFcuUxlHa0fjyrpk0Gqhd2+YPFkt7/JQNhzACzVewNnamUu3L7E1bCutfFqZsvtCCCGE2dha2LKvzz6j2h6KPMTwzcPzbfdD2x9o5NXIqGMXRLdu3ahYsSJz5syhfPnyGAwGateunaUcizHu3r1Lw4YNWbJkSbZ1GZntAJaWllnWaTQaDAbzXDB/3GMlp+m5djsJAD83eyLzaV8Ynq9fgRmbznHtdhLL94czsLl/UXfpkVyKSaDv3H3cTEildgUnFg5qjIO1eUMDjf1d8XK24UZccg7pMqABPJ1taOwvJUxuJ6by655LALzVtoqUCikG5PUrhMggGelCiGKlOE3mmZPYpFjmHJ4DwB89/2Bt77WZmehbB2wttJIzxyLvlXXxLMBEow/q00f9/s8/cPt2ttW2lrb0rdMXgHlH5j1OV0UxpDfoCb4UzLITywi+FFwsJvIVQghT0Wg02FnaGfXVrHwzPOw8Mv+WZ9sXGtxt3WlavqlR+ytIwOvmzZuEhoby8ccf0759e2rWrMmtW7cy11vdu8NMr8/6O9rKyirbsgYNGnDu3Dnc3d2pUqVKli9nZ2ej+5TTvh9Ws2ZNdu3alWXZrl27CAgIMPo4xrh0U81Gd7KxwNXOMp/WhcNSp+XNe1npP22/SGp6ybtr70psIn3m7CUqPoXqHo78OjgIZ1vzP786rYYJ3dTXSG5nyYRuAei0EjResOsSCal6ang60r6me1F3R5D36zfjZ3n9CvFkkEC6ELnQG/Rsu7yN7be2s+3yNgk0FZLiNJlnTn7Y/wMJaQkEegTStWpXnq32LC181bqpGy5sKLR+ZGSk13W/FzjPCKQbk5Ge0S4gAFJS4M8/c2wyuP5gQK1ZfyvpVo5tRMmTMZFv20Vt6bOqD20XtS0WE/kKIURR0Gl1fNj4Q4BswfSMn9+u/bZZSraVKVOGsmXL8vPPP3P+/Hm2bNnCmDFjMte7u7tja2vLunXriIyMJC4uDgA/Pz+OHz9OaGgoMTExpKWl0bdvX9zc3OjevTs7duwgLCyM4OBg3n77ba5ezf1Ov4f5+fmxfft2rl27RkxMTI5t3nvvPRYuXMjs2bM5d+4c06ZNy5wI1ZTCou+VdSnnUKwycl9u6I27ozURccmsOmz8c1sc3IhLpu/cfVyPS6ZSOXsWvxZEGft8SgKaUJfaXszu1wBP5+zlL3o39qVL7aJ5f1+cxCensXD3JQBGtpNs9OIkt9evp7MNs/s1kNevEE8ICaQLkYOMQFPHJR2ZdnkaHZd0lEBTIcmYzDOvzDAfJ59CmczzYYlpiXy7/1sAPmj+QeYb26erPA3Af+f/K7S+ZMlIT0mB0FB1hbEZ6RrN/az0pUtzbNLAqwGBHoGk6FP4fMfnclGpFMiYyPfh8kkZE/nK7zghxJOoQ8UOTGszDXe7rJmfHnYeTGk9hdblW5vluFqtluXLl3Po0CFq167NO++8wzfffJO53sLCgm+//ZaffvqJ8uXL0717dwCGDh1K9erVadSoEeXKlWPXrl3Y2dmxfft2fH196dGjBzVr1mTIkCEkJyfj5ORkdJ8+++wzLl26ROXKlbOUhHnQ888/z8yZM5kyZQq1atXip59+YsGCBbRp0+axno+HXbxXH72Sm71J9/u4bCx1vN6qEgCzgs+z81w0a45eY8+Fm+gNORV9KBp6g8KeCzcz+3YjLpk+c/cSHpuIr6sdS19rQjlH60LvV5faXuz8oB3LhjZh5iv1eLVJRQB2nI8mXV/yMvxNbfHecOKS0qhUzp6nJTBb7GS8fhcPbsSrVfUsHtyInR+0kyC6EE8QqZEuxEMyAk0PT3aZEWha2XNloZXveBLptDqmd57Oy7+/nON6BaVQJvPMyfwj84lJjKG54sPLKZXh8GEAeiT58ft1uBm1kdTKe7HyLK9O5mkmafo0TkefBiDQIxBCQkCvhzJloEIF43fUuzd8/DFs2QI3boCnZ5bVGo2Ghl4NORZ5jO8Pfg/AtMvT8HbyZmaXmXIelDD5TeSrQcPodaPpXr17kZxfQghRlDpU7EBbn7YcjjpMdGI05ezK0cC9ARo03Llzx3zH7dCB06dPZ1mmKPd/T7/22mu89tprWdaXK1eODRuy3wXn6enJokWLcj3WwoULsy2bMWNGlp+bNGnCsWPHsiwbOHAgAwcOzLJs2LBhDBs2LNdjPfgYMtzOoZRcXjInGi1mgXSAPkG+TN94lvDYJPrN25+53MvZhgndAoo8qLbuZAQT154mIi45c5mFVkO6QaG8sw1LhwblmBVeWHRaDU0rqxNodgrw5J8TEVyJTeKvY9fp0cC7yPpV1JJS9czbeRGA4W2qSJmQYkqn1RDk78rNEIUgf1cZJyGeMJKRLsQD8gs0AYxeN1oycs0sNikWyH6LNYCbnRtdq3Yt7C6Rpk9jyu4p+NyG4EkRWDwVBA0bQsOGVO/ch8M/w65ZyVgFNYXq1SE83Gx9Cb0ZSqo+FUcrRyq6VMw60WhBbv+sVAmaNAGDAVasyLZ6VcgqFhxdkG25ZC+XTAWZyFcIIZ5EOq2Opzyfomulrjzl+ZRcVCxixTmQvv1sNAmp2T8P3IhLZtjiw6w7WTRz+YAaRB+2+HCWIDpA+r1s+TdbV8a7jF1RdC1HtlY6hrRUJ239Yet5DMUoq7+wLT8QTszdVLzL2NK9Xvmi7o4QQogcSCBdiAdIoKno3bh7g29/H0v96/BLxdHsrTeLqUpftteeQafbbvicj2HJ35MKvV8rTq3gctxlqhpcsEhNz7txcjLkUlfUFI7dUDPF6nrURavRFnyi0QflUt5FLiqVPsV9Il8hhBDiQcU1kK43KExcezrHdRnvmiauPV0kZV4y+pbXkWdvu1CsStAA9G9SEScbCy5EJ7Du1I2i7k6RSEnX8/N2NRv9zdaVsdRJqEYIIYoj+e0sxAOMDSCdjDxp5p48uT7/dSgHpsZz+GfoN2g6Qc8PZ8zEJbR8aTTrZ8Rw+Gfo+/Jn3D2X8wcYc1AUhcm7JgPQp06fQjtubjLqo9f1eMSJRh/UsydotbBvH1y4kLlYLiqVPsV9Il8hhBAiw+3EVGITUoHiF0jfHxabLdv7QQoQEZfM/rDYwuvUPfn1DYqub3lxtLFkYHM1K/27LedzLA1U2q06fI2IuGTcHa15qeGTW95GCCGKOwmkC/EAYwNIb617i5o/1GT0utH8e+5fElIT8myvN+gJvhTMshPLCL4ULFm8ufjv3H/sOfo3tvkkfNukw5KtMwunU6iTiJ6IOoGDlQMvB+Rcu70wHY9UA+eBHoHqgozSLo+Ske7hAR06qP9ftixzsWQvlz4u1i7qHQy5KMqJfIUQQogHZWSjezhZY29dvKb1iorPO1Bd0HamVJz7lp9Bzfyws9IREnGHraFRRd2dQpWuNzA7WE1oeb1VJWwspayUEEIUVxJIF+IBzbybYWthm2cbK50VGjSciTnDzH0zeWbpM7h+7Ur7X9ozeedkjkQcwaDcn3F+Vcgq/Gb60XZRW/qs6kPbRW3xm+kn9aUfkpCawLB/cp+06mGLjy8mOiHajD26LyMb/fUGr+Nk41Qox8xLRkZ6oGegWkIm4l4wu3btR9th797q9yVL4F4GkLEXlawtrB/tmMVUab3otSt8F21/aZv5u+nh+Qcyfi6qiXyFEEKIBxXXsi4A7o7GTdKZlm7Iv5EJnY2MZ/Hey0a1NfYxFKYy9lb0b1IRePKy0tcev054bCKu9lb0CfIt6u4IIYTIgwTShbjHoBgY+vdQktKTclyvufdv2YvLuPn+TVa+vJLXG7xOReeKpOpT2RK2hQ83f0iDnxvgNdWLfqv68fZ/b/PSipeylciQyRqz+zT4Uy7HXcbLwdOo9glpiUzaaf5a6Xuu7GH75e1Yai15p+k7Zj9efqISorhx9wYaNNR2r30/G71SJXBweLSdvvACWFvDmTNwTA3St/RtibeTd44Tvj6o36p+fLT5I24n3360YxcjpfWi17/n/qXjrx25nXyb5j7NWfT8Iio4VcjSpqxtWVb2XEmPmj2KqJdCCPH4nqTAW2nz8NjdD6Q/4nsbM2rs74qXs00+75DgvZXHGfPbUcJvJpq1P5diEhi9/AidZ2znwKVbebbVAF7ONjT2dzVrnx7VkJb+WFloORJ+mz0XbhZ1dwqFwaDww1Y1G31IC3/srIrXHRhCCCGykkC6EKhB9DfWvsEvx35Bp9ExtulYvJ2y1qbzdvLODDSVsS3DiwEv8lO3nwgbFUboyFC+e/o7ulXrhr2lPVEJUSw5sYTv9n8nkzUa4UjEEabvnQ7Ahy0+NHq7WQdmER4Xbq5uAfez0fvV7ZftNZGX1PRUs/Qno6xLZdfKOFg5PN5EoxmcneHZZ9X/3yvvotPqmNlFLZ+TW/ZyFdcqJKUn8dXOr6g0sxKTd04mMc28HxbNZVXIqlJ50WvJ8SV0X96dpPQkulbtyob+G3g18FUujbrE1gFbaV2xNQBvNHpDguhCiBLL0tISgMTEkvk3SEBqqvq+SadT74q6eC+QXqkYZqTrtBomdAsAyBZMz/i5no8zCrDqyDXaTQ1m3KoTRMTlnKzzqK7dTuLDP47Tfto2Vh+9jqLA07U9+eTZADR59G1CtwB02vwuAxQNd0cbej/lA6hZ6U+C9aducD7qLo42FvRvWrGouyOEECIfcrlTPPEUReGtf99i7pG5aDVaFvdYzCu1X+F/Hf7H1otb+W/nfzzd4mnaVmqbY8kDjUZDtbLVqFa2GiMbjyRVn8qeK3uYc2gOS04uyf24D0zW2MavjRkfYfGmN+h5/e/X0St6etbqScuKxtVnblS+IUf0h5gYPJF53eeZpW8h0SGsCV0DwHvN3ivQtkduHCGIJibv07Eb98q6ZNRHf5yJRh/Upw/88YcaSJ80CbRaetTswcqeKxm1blSWALO3kzczuszghRovsCZ0DR9t+YjT0af5cPOHzNw3k09af8KQ+kOw1Fk+Xp8Kid6gZ9S6Uble9NKgYfS60XSv3r1ElT35dt+3jFo3ClAvBM1/bn7mmOi0Otr4teHlgJfZdnkbR28cLcKeCiHE49HpdLi4uBAVpdZVtrOzQ6MxTaDQYDCQmppKcnIyWq3kIJmDwWAgOjoaOzs7LCzUj6dh0cW3tAtAl9pezO7XgIlrT2eZ3NPT2YYJ3QLoUtuL41dvM3XDWbadjWbZ/nD+OHyVfkEVGdamMuUcH700XlR8MrO2XmDpvnBS9Wr5mLbVy/Fup+rUruAMQHkXmzz7Vpy93royS/eHs+fiTQ5djqVhxeKZPW8KiqLw/Vb1gsHAZn442ZSM985CCPEkk0C6eKIpisI7699h1sFZaNCwsPtCXqn9CqAGmlpXbE3CqQRaV2xtdADNSmdFa7/WXI+/nmcgPcOTPlnj9/u/5+D1gzhbO6sZ0GevG7XdyMZvMWf/QBYeW8h7zd+jhlsNk/ftm93fAPB8jeepWa6mutDNDbRaMORe9zLJAjbEHSbI5D2C41Fq4Lyux70M9MeZaPRBXbuCkxNcuQK7dkFL9YJGj5o96F69e64XlZ6v8TzdqnVjyYklTAiewKXblxj2zzCm7J7CZ20/45Xar+Q5wWVxsCN8R7ZM9AeVtIteiqIwIXgCn2//HIC3G7/N9C7TcxyHBl4NADgccbhQ+yiEEKbm6amWhssIppuKoigkJSVha2trsuC8yE6r1eLr64tGo0FRlPulXcoVz0A6qMH0jgGe7A+LJSo+GXdHtWRKRrZ3XW8XFg1uzP6wWKZsCGV/WCzzd4WxbH84g5r78Uaryjjb3Q+c6g1KrvsCuJWQyo/bL7Bo9yWS09T3oU0quTK2U3Ua+bkWqG/FWQUXW3rU9+a3g1f4fst5FgxqXKjHz28cTCk4NJpT1+9ga6ljUHN/sxxDCCGEaUkgXTyxFEXhg00fMHOfWr5i7nNz6R/Y32T7N3ayRmPblUZX4q7w8daPAZjcYTKeDp6AcYH0uh516F69O2tC1/Dxlo9Z2XOlSft29c5VFh9fDMAHzT+4vyI19X4QfcUKsLGB554DnQ62bWPj9Z0M2f0hDnd2Md6kPVJlyUjX6+HkSXXF4wbSbWzgxRdhwQJYujQzkA75X1TSaXW8GvgqvWr14udDP/PFji+4cOsCfVf15etdX/Nluy/pWrVrZgBCb9CzI3wHEfEReDl60dK3ZZFmeht7MaskXPTSG/S89d9bzD44G4DP237ORy0/yjX4U9ejLlqNloi7EZnjIYQQJZFGo8HLywt3d3fS0tJMtt+0tDS2b99Oq1atMkvICNOzsrLKzPiPvJNCUpoenVaDTxm7Iu5Z3nRaDU0rl82zTWN/V357vQk7z8cwZX0ox67GMSv4Ar/uvczQlpUY3MKfneeis2WQe93LIG9exY15O8OYtyOM+JR0AOr5uPBe5+o0q1w217/xxvStuBrWpjK/H7rC1tBoTl6Ly8y0N7d1JyNyHQdTZ/IrisJ3W84B0K+JL672VibdvxBCCPOQQLp4Yn2y9ZPMjOPZz8xmcP3BJt1/xmSN1+5cy7FkhAYN3k7etPQ1rpRJaaMoCiP/G8nd1Ls092nO0IZD1RVuburElykpuW9sYwNubnzp/SV/hf7FHyF/cODaAZ6q8JTJ+jd9z3TSDGm0rtiaJt4PlGiZNk393rUrvPwyKAr4+kJ4OCQm8lS3N7ge8hH6mBAu375MRRfT1TpM1adyOvo0AIGegXDxIiQlga0tVK78+Afo3VsNpK9YATNnglXB3tBbW1jzVtBbDKo/iJl7Z/L17q85FnmMZ5c9S3Of5kxqP4noxOgcS8XM7DKzyGp0l5aLXqn6VPr/2Z8Vp1agQcMPXX9g2FPD8tzG3sqeGm41OB19msMRh3nG8ZlC6q0QQpiHTqfLrLNtqv2lp6djY2MjgfRCcjHmLgA+ZWyxsijed7UZS6PR0LJqOVpUcWPj6UimbTzLmRvxTNt4lp+3X+TuvQD5g27EJfPm4sPYWelITFXnVKrp5cS7HavRvqZ7qb5Dws/Nnm6B5Vlz9Do/bD3P7H4NzX7MdScjGLb4cLZPbTfikhm2+DCz+zUwaTB9z8WbHA6/jZWFlqEtK5lsv0IIIcyrdLwzEaKAPt/2OV/s+AKAmV1m8majN01+jLwma8wwo8uMElVz2ZT+PPMnf4X+haXWkp+e/el+2QlfX+jVS/1/YCBpe/cSPHUqaVu3gqOjunzaNPD1pZZ7rcy7CP5vy/+ZrG+xSbH8fPhn4KFs9OhoNdAMMHas+l2jgdbqhI1s24aLjQtNfZoC8N/5/0zWJ4DQmFDSDGk4WTtR0bni/frotWqpGfGPq21b8PCA2FjYuPGRd+Ng5cBHrT4ibFQY7zd7HxsLG3Zd2UWrha14ccWLxW5Cz4yLXrnRoMHHyadYX/S6m3qXbsu6seLUCiy1lix/aXm+QfQMUt5FCCFEcZJZ1qWY1kd/HBqNhk61PPn37ZZ827s+/mXtcgyiA5kB3cRUPf5udnzfpz7/vNWCDgEepTqInmFE2yoArDt1g3OR8WY9lt6gMHHt6RxSn+6Pw8S1p9EbcmrxaL6/N5lqr0Y+uDvZmGy/QgghzEsC6eKJM3nnZD4J/gSAKR2n8HbQ22Y7VsZkjRWcKmRZ7mjlyMqeK4ssA7eoxSXH8dZ/bwHwfvP3qeVe6/7Ky5fVCS8BZsyABg2Iq1wZmjeHMWPU5T//rGaCAxPbTMRSa8mmi5vYfHGzSfo368As7qbepa5HXbpU6XJ/xezZkJwMDRpAmzb3l2f8PzgYgKerPA2YPpB+LFIt61LXo676AcpUE41msLC4fxFj6dLH3p2rrSuTO07m/FvnGdpgaK7tMu7YGL1uNHqD/rGPW1A6rY4ZnWfkuC7jIlhxvuh1M/EmHX7pwIYLG7C3tOefPv/Qs1ZPo7dv4HkvkH5DAulCCCGK3v2JRh2KuCfmo9VqeC6wPJ8/X9uo9p93r82zdcujLQE1zk2lmocjnWt5oCgwK/iCWY+1Pyw2SzmXhylARFwy+8NiTXK8Q5dvsfvCTSy0Gt5oLdnoQghRkkggXTxRpu+ZzoebPwTgy3Zf8m6zd81+zB41e3Bp1CW2DtjK6w1eB9T61k9qEB3goy0fcT3+OlVcq/BRy4+yrvz8c0hLg/btswarAd56C+zt4ehRWLcOAD8Xv8w7Cv5vy/+hKI+XKZKUlsS3+74F1Gz0zIyfpCT4/nv1/++9p2aiZ8jISN+/HxITMwPpmy9uJiU9jxI1BZRRH72uu4knGn1Qnz7q9zVrICHBJLus4FSBPnX65NnmwQk9i0JG2ZaH7x7xdPAs1he9rt65SssFLdl3bR+utq5sfnUzHSt3LNA+JCNdCCFEcVISJho1lZsJqSZtV9qMbFsVgL+OXefyTdO8L81JVHzuQfRHaZefH7aq2egv1K+AdzGfB0AIIURWEkgXT4wf9v/AmA1qRvOE1hP4v5amKwWSH51WRxu/Noxpqh7/YMRBkwZYS5K9V/cy68AsAH569idsLW3vrzx3DhYuVP//+efZNy5bFt68V4bnq68yF3/U8iPsLe3Zf20/q8+sfqz+LTi6gOjEaPxc/LJm9f7yi1rapWJFeOmlrBtVqgTe3uoFgD17qOdZD08HTxLSEtgZvvOx+vOg41FqBnqgZ+C9Bfcy0k0ZSG/cWH08CQmwdq3JdlvcJ/Scd3geAP3q9mPrgK1UcVVvJ/687efFJoiuN+jZdnkb229tZ9vlbZyOOk3z+c0JiQmhgmMFdgzaQZB3UIH3W8+zHgDhceHEJMaYuNdCCCFEwWQE0iuVwtIuD3N3NK6kh7HtSps63s60rlYOvUHhx23my0o39vk1mKC0y8lrcWw5E4VWo06qKoQQomSRQLp4Isw5NIeR/40EYFyLcUxoPSH3xuHhcPiw+nXkCM4XLsCRI/eXhYc/cj+qla2Gm50byenJT2T2Z5o+jaFrh6KgMCBwAO3822VtMHEi6PXqRJ5Nm+a8kzFj1Ekwd+6EHWr2soeDB+80eQdQs90ftTxIuiE9cwLad5u+i4X23nzMej1Mnar+/5131BIoD9JospR30Wg0mSVhTFneJSMjPdAjEO7ehQv3PlCYqrQLqI8lIyvdBOVdMhTnCT3jU+L57dRvAAxtMJQ2fm3oXbs3AJvDTFMu6HGtClmF30w/Oi7pyLTL0+i4pCN1fqxDeFw41cpWY9fgXQSUC3ikfTvbOGdeODgSccSU3RZCCCEKJE1vIDw2ESidNdIf1tjfFS9nm1xmUwIN4OVsQ2N/18LsVrHyVjv1PcrKQ1eJiEsyyzEa+7viaGORb7t3fz/GByuPc/VW4iMfa1awmo3+TN3yVCpXessXCSFEaSWBdFHqLTy6kDf+fgNQg6Nftvsy9wl6wsOhenVo2BAaNsQyKIg2776LZVBQ5jKqV3/kYLpGo6GZTzMAdl3Z9Uj7KMmm7pnKyaiTlLUty5ROU7KuPH36fuD2s89y30n58jBokPr/B7LSxzYbi6utKyExIfx6/NdH6t/vp37n0u1LuNm5Mbj+4Psr1q5Vs+VdXGDIkJw3zijvYqY66ZF3I4lMiESDhtruteHUKXWFpyeUK2eSY2TqrQaR+e8/uHnTJLvMmNAzt4l3i3JCzxWnVpCQlkC1stVo4dsCgA6VOgCw6eImDIqh0Pv0oFUhq3hpxUvZJmnN6NeHzT+kokvFxzpGQ6+GgJR3EUIIUbSu3koi3aBgY6nF8wmYgFGn1TChm3oh/OF3SBk/T+gWgO4Jqo3+sEZ+rgT5u5KmV/hp20WzHGPpvsvEJ+c86WvGM1+7ghMGBX47eIV2U7YxYc1Jou4UrNTL+ah4/jt5A4ARbSUbXQghSiIJpItSQ2/QE3wpmGUnlhF8KRi9Qc+S40sYvGYwCgpvNX6Lbzp+k/cs9zEx6mSSeUlOVts9ohY+aqDuSQukX4i9wMRtEwGY1nkabnZuWRtMmKBOINqjh3rBIi/vvw9arVon/bAa+HO2cWZci3HqroInFLh0jqIoTN41GYC3G7+NneUD9Qqn3Av6DxsGDrlkjmRkpN+rk96xUke0Gi2no08THvfodzFkOB6plnGp4loFeyt785R1yRAQAIGBkJ4Of/xhkl3qtDpmdpkJZK9DnqGoJvScd0Qt6zK43uDM3w9NvJtgb2lPdGI0JyJPFHqfMugNekatG5U5IevDNGiYEDzhsSdpzayTLhOOCiGEKEJhMXcB8Ctr/8RMrNmlthez+zXA0znrhQNPZxtm92tAl9qFf7decfNWO7VW+rL94UTHm7Y85ooDVxi/Rk1Q6VzLI8dx+LFfA/5+qyV/DGtGs8plSdUbWLTnMq2+2cqkf0O4ZWQN+1lbL6Ao0DHAgxqeTiZ9HEIIIQpH/vcvCVECrApZxah1o7JkbJa1LUtsUiwKCm80fIOZXWbmHUQvJM19mwOwK3wXiqIUiz6Zm6IoDPtnGMnpybT3b0//uv2zNjhyBFauVMuKTJyY/w4rVVKzppcsgUmT4PffARjx1Ahm7J1BeFw4Px78kVFNRhndx/UX1nMs8hj2lvaMaDzi/oo9e2DXLrC0VCc7zU3lylChAly7Bnv3UqZdO5p6N2XXlV38d+4/3mj0htF9ycmxyHtlXTLqo2dMNGrKsi4P6tMHjh1T7xJ4/XWT7LJHzR6s7Lky27mq0+hY+uLSIqlFHhIdwp6re/CL0zKE+pkXZqyAwUo9dl7fxfH/FhLY/h3w9S30/u0I35EtE/1BD07S2savzSMfRyYcFUIIURxcjL5XH/0JmGj0QV1qe9ExwJP9YbFExSfj7qiWc3mSM9Ef1LxKWQJ9XDh25Tbzdobx4dM1TLLfNUev8cEqNTllcHN/xj9bE4NCruPQsGIZlg5twu7zMXyzIZQj4bf5aftFluwLZ3ALf15r6Y+TjWWWY+gNCvvDYgmJuMPqo9cAGNm2ikn6L4QQovBJRroo8XIre3Az6SYKCm392jLrmVnFJmDd0Ksh1jprohOjOR97vqi7UyiWnljKxosbsdZZM/uZ2dnH4pNP1O+vvAK1axu30w8/VL//8QecOQOAraVtZv37L3Z8QXxKvNF9zMhGf73h67jaPlCHMiMbvV8/8MojI0ijuV/eZds2wLTlXTIy0uu638tAN2dGOqhjAbB9O1zNPZBbUD1q9uDSqEtsHbCVRc8vwsXGBb3yeNnUj2PekXn43IbQ78GtZef7JZwaNuTbj3dx+GfoP3jGY5V0ehyFNUlrfc/6AJyPPU9cctxj7UsIIYR4VBkTjT4J9dEfptNqaFq5LN3rVaBp5bISRH+ARqPhrXvB51/3XOJ2onEZ4Hn570QEY1YcQ1Ggb5Av45+tiUajMWocmlVxY9WwZswf2IgALyfupqTz7eZztJy8lVnB50lMVcvErDsZQYvJW+g9Zy+f/X0agwJWFlqz1XoXQghhfhJIFyVafmUPAM7FnkNRHn+GdVOxtrCmUflGwJNR3iU2KZZ31qsTgY5vNZ6qZatmbbB3L/z9t1qq5dNPjd9x7drQvbtaDmby5MzFg+oPolrZasQkxjBtzzSjdrXv6j6CLwVjobXInLQUUOui//mn+v93381/Rw9MOArwdFU1kL45bDOp+sd7w58lI11R7gfSzZWR7usLLVuqx/rtN5PuWqfV0cavDa8Gvsrbjd8G4Lv935n0GMZI1afyy7FfcEsEq7R86qA/ZkmnR1VYk7SWtStLRWe1zvrRG0cfa19CCCHEo7ofSJdJGEVW7Wu6U8PTkYRUPQt3X3qsfW05E8nby4+gNyi81NCbz7vXLnDSlUajoV0ND/5+qwWz+jagirsDcUlpfL0ulFZfB/P+ymMMW3yYiLisZUNT0w0MW3yYdScfLwlCCCFE0ShxgfQffvgBPz8/bGxsCAoKYv/+/bm2XbVqFY0aNcLFxQV7e3vq1avHr78+2iSEonjKr+wBwNU7V9kRvsO0B546FUJCHnnz5j5qeZed4TtN1aNi670N7xGdGE2tcrV4r/l72RtkZKMPGADVqhVs5+PUmugsXgyXLwNgobXg87afA+rkptEJ0fnuJiMbvV/dfvg4+9xfMX26Gkju2hVq1cq/PxmB9L17ISmJep718LD34G7q3cca61R9KiHR6ust0CMQrl+HW7dAp4OaNR95v/nq00f9njEJrBm80egNLLQW7AzfWehlRf4++zfRidG42ZUt1OMWRGFO0irlXYQQQhS1JzkjXeRNo9Ewsp2alb5g1yXupuQ8OWh+dp6L4c3Fh0nTK3QLLM/kF+s+Vj1+rVZD1zperB/dimk9A/F1tSPmbgorDl7NI9ULJq49jd5QfJK9hBBCGKdEBdJ/++03xowZw4QJEzh8+DCBgYF07tyZqKioHNu7urry0UcfsWfPHo4fP86gQYMYNGgQ69evL+SeC3MprLIH2Sxdqk7I2KIFLFoEiYkF2jyzTnopzEh/cNLXGXtnMP/ofAB+7vYzVjqrrI23bYONG9X64xkB9YIICoL27dVJMTNKsAAvBbxEA68GxKfGM2nnpDx3cSbmDKvPrAbg/Wbv318RHQ0LFqj/fy+HCwA5qVJFLf+Smgr79qHVaOlSpQsA/5179PIuZ2LOkGZIw9naGV9n3/vZ6NWrg41N3hs/jpdeAgsLtW74vfI5plbesTwvB7wMFH5WesYko89UfaZQj1sQGZO05nTXTUZw3VSTtGYE0g9FHHrsfQkhhBAFlZianpm9W0kC6SIHT9f2olI5e+KS0li893KBt9938Sav/XKA1HQDnWt5MK1noMlK6Oi0Gno08Gbzu615rYV/nm0VICIumf1hsSY5thBCiMJTogLp06ZNY+jQoQwaNIiAgAB+/PFH7OzsmD9/fo7t27RpwwsvvEDNmjWpXLkyo0aNom7duuzcWfqzgJ8UJi97EGFkwL11azUbeNcuGDgQypeHESPg6NGs7cLD1SDkQ18tY+ypfx0Szp/hZuJN445ZAqwKWYXfTD/aLmpLn1V9Mku6dKrUiWY+zbI2VhQYP179/2uvgZ/fox30//5P/T53LkRGAqDVaPmq3VcAzDowi/C43Gtbf7PrGxQUnqv+HDXLPZDdPWuWWs6jYcP7tc/zo9FkL+9igjrpx26oZV3qetRVbzs190SjGRIT1YsVgHbGDJwvXFAnhs14LZuoZvjbQWp5l2Unlhl1B4EpXLtzjXXn1wHQvXr3Qjnmo+pRswd13LOPtbeTNyt7rjTZJK2SkS6EEKIoXYpRE1Nc7CwpY2+VT2vxJNJpNQxvo2alz91xkeQ04+fZORx+i8ELD5CcZqBN9XJ827s+ljrTh0MsdVrqeDsb1TYqPjn/RkIIIYoVi6LugLFSU1M5dOgQ4zJKOQBarZYOHTqwZ8+efLdXFIUtW7YQGhrK5AfqKT8sJSWFlJSUzJ/v3LkDQFpaGmlpaY/xCAom41iFecySqIlXEyo4VuB6/PVcMzYrOFWgiVeT/J/LpCQsPvgglwIK9yk2NqTPmwcWFmh/+QXtggVowsLUwOusWRgaNkQZPBhD8+ZYNGmCJjn7G6QywGEgyQK2PfMH7VsPMvoxF1d/nvmTV1a9kuM4bLy4kRUnVvBCjRcyl2k2bsRixw4Ua2vS338fchmffM+FFi3QNW6Mdv9+9NOmYfjiCwDa+raltW9rtoVvY8LWCfz8zM/ZNr0Wf41fj6vlnsYGjb1/jKQkLL7/Hg2Q/s47KOnG3zqqbdEC3bJlGLZuRf/RR7TxbYNWo+VU9Cku3ryIj5NP/jt5yJGIIwDULlebtLQ0dEePogX0tWphMNfviPBwLGrXznz96ubPp81DTRQbG9JPnlTrqT+GBu4NaOjVkEMRh/jxwI982PzDx9qfMeYfno9BMdDcuzkVHL2N2ubm3Zs4FcHv5FtJtwiJUUv7zOs6j1OnTtGxSUfa+LdBp9WZ7O9EHTc1WH8m5gy3E25jbyXZgDmRv8/FQ2kZh5LefyFMScq6CGN0r1eeGZvOcvVWEsv3hzOwed7Z3wAnr8UxYP5+ElL1NKtclh/7NcTa4vHv5suNu6Nxd4wa204IIUTxUWIC6TExMej1ejw8PLIs9/Dw4EweJQfi4uKoUKECKSkp6HQ6Zs2aRceOHXNtP2nSJCZOnJht+YYNG7Czs3v0B/CINm7cWOjHLGn6le3H5PicL44oKPR17cv6dfmU81EUGsyYgc+pU6Q4OHB49GhSypTJsWmqkxNJJ0+qP9StC1OnUu7ECSpu2IDXvn1oDx2CQ4dQrKzQpOY9waRtOmzavJyUBI882xV3ekXP8NPDc530VUFhxNoRWFywQKfRgaLQ6v33KQNc7NSJk8eOwbFjeR4jr3PBs0MHgvbvx/D992yoW5d0B3WCqq7WXdnGNn459guNUhrhbZM1YLrw2kLSDGkE2AcQezyWf4//C4DfunUExsSQWK4cm2xtUf791+jnwgFoDyh79rBu9WoMVlZUs6vGmYQzTFk9hc5unY3eV4YtF7YAoInS8O+//9Jm926cgQPJyUQWoG8F4XzhAm1yuAj0IE1yMrvWrCGucuXHPl4LyxYc4hAzd88k4HYAFhrz/XkyKAZmhcwCoIGmAbt27sx2kSAni7cuxu9Wwco4mcK22G2kG9LxtfGl7PWytCrTipTQFNaHFrxMmW10NFb3LhDnpPZdZ046xPHTmp+oYV/jcbpd6snf5+KhpI9DYgFLwwlRmoXF3AUkkC7yZqnT8mbryny8+iQ/bb9In6CKWFnknlkeeiOe/vP2EZ+czlN+ZZg7oBE2luYLogM09nfFy9mGG3HJOX460gCezjY09nc1az+EEEKYXokJpD8qR0dHjh49yt27d9m8eTNjxoyhUqVKtMkov/CQcePGMWbMmMyf79y5g4+PD506dcLJyamQeq1mKG3cuJGOHTtiaWlZaMctibrSlQZnGvDmv29yK/lW5nJvJ2+mdpiaJQs6N9pvv0W3bRuKTofuzz9pdK+Uh9Hj8OyzMG4c+uholMWL0c6fj0VoqFH9j7WMpWvXrka1La62Xd7GzWN5l6iJSYvBqbYTrSu2RrN2LRbnzqHY2eE7axa+HrlfSDBqDLp0QVmzBstTp+hy8SKGD9WM5q50ZefKnaw9u5bNymZ+6/pb5ia3km7R74d+AEx6ZlJmCRb0eizGjgXA+sMPebpbN2OfBpWioHz+ObobN3ja1RWlVSuO7jzKp9s/5ZrdtUca69dnvA5A3/Z9ecotEIvr1wFoOGgQVKxY4P0Z5cgRo5o1b9EC6td/7MO1T2/Psu+XEZUYRWqlVJ6r+dxj7zM32y5v48axGzhaOfJZr8+wP3XWqO3ineKL5Fz9ZdUvAPRp0IeOzTs++t+Gh+4yyMkhSy1VRoCNvw1dG5Xs30vmIn+fi4fSMg538riwJcST5uK9jHSpjy7y81JDb77bco6IuGRWHb7KK41zvjvyQvRd+s7dy63ENAJ9XJg/8CnsrMwfAtFpNUzoFsCwxYfRQJZgesbdzxO6BZisPrsQQojCU2IC6W5ubuh0OiLv1UDOEBkZiaenZ67babVaqlRR66jVq1ePkJAQJk2alGsg3draGmtr62zLLS0ti+SDWlEdt6TpWacnJ6JP8MWOL2jr15ZPWn9CS9+Wxk3At3UrfPABAJqpU7Ho0CFbE6PHoXx5eP99dXLK+fPV2t/5OB1zGoPGgLVF9tddSRGdZFxd6+ikaCx1OvjsMwA0b7+NpbdxZTXyHYP/+z/o2xfdt9+ie/dduHcHyVftv+Lvs3/zZ+ifHI06ylMVngJg7t653E29Sx33OnSr0U2tPQ7w999w/jy4uKB7/XV0j3L+tW4Nv/2Gxc6d0L49z1Z/lk+3f8qWS1tQtEr2SVfzEHk3kqjEKDRoCPQKxDL0oloGx8kJy8qV1brs5mBh3J8HSwsLdbLYx2Rpackbjd7g8+2fM+vQLHrX7f3Y+8zNohOLAHil9iu42LuAp6f6ePMo4ZNkAeviDvFxIf8+Tk5PZv0FNfP8xVovZp4Dj/S3IS5OrfufB6s0A26JcCzqmPztyYf8fS4eSvo4lOS+C2Fq90u7OBRxT0RxZ2OpY2jLSnzxTwizgi/wUkNvLB6qdx5+M5G+c/YRczeVAC8nfhnUGEebwvud26W2F7P7NWDi2tOZk+iCmok+oVsAXWobOYeXEEKIYqXETDZqZWVFw4YN2bx5c+Yyg8HA5s2badq0qdH7MRgMWWqgi9Lj/K3zAHSt2pU2fm2MC6Jfvgw9e4JeD6++Cm+/bZrOaDRGZ+mm6tM4FHHINMctIgWa9PWPP9QyLk5O6gUHU+nZEypVgpgYdeLRe2q716Z/YH8Axm0eR/ClYBYdXcTXu74G4P3m798PogNMmaJ+HzYMHB7xg1zGhbpt2wCo71Ufd3t37qbeZVf4rgLt6likWvKmatmqas3qBycaNVcQvSDWrIEzZ8BgyL9tLpPvZnyN8OiGhdaCneE7M+vCm9rt5NusPL0SgCH1h6gLXV3B/l722//+B4cOqa/TexJXraDW2zp2acK5eOuiWfqVmy1hW0hIS6CCYwUaejUstOPKhKNCCCEKm9RIFwXRJ8gXV3srwmMT+ft4RJZ1124n0XvOXm7cSaaquwO/DmmMs13hX7jsUtuLnR+0Y9nQJsx8pR7LhjZh5wftJIguhBAlWIkJpAOMGTOGOXPmsGjRIkJCQhg2bBgJCQkMGqRO1Pjqq69mmYx00qRJbNy4kYsXLxISEsLUqVP59ddf6devX1E9BGFGZ2+q5Rmqla1m3AaJifDCC2rgtWFD+PHHIgtMFjS4Wty09G2Jt1PumeUaNPg4+dCyQjP45BN14ZgxagDTVCws1LsBAL75Bh6oTz+xzUR0Gh2bwzbTdlFbBq4ZSFxKHDqNLmt2+O7d6peVFbz11qP3JSOQvmcPpKSg1WjpUqULAP+d/69Auzp2Qw2kB3oEqguOH1e/16376P0zpc8+g5o1wc0NunaFzz+HTZvg4XIF4eFQvbp6ruXy5dGwFW+WU8uJfLf/O7N0d9mJZSSnJ1OrXC0aV2isLpwzR83WrlIFxo6FBg2gRw9o1w4Au0PH8K7dDIBNFzeZpV+5WX1mNQDdq3fPesHHzE5FnyI5Pe/sdSGEEMJUbiWkcjtRnXzXz63w56USJY+dlQVDWqgTjX6/5Ry7z8ew5ug1/j0RQZ+f93DtdhL+bvYsGRpEWYeiu/NXp9XQtHJZuterQNPKZaWcixBClHAlKpDeq1cvpkyZwieffEK9evU4evQo69aty5yANDw8nIiI+1ejExISGD58OLVq1aJ58+b88ccfLF68mNeMKLchShZFUQoWSFcUeP11tQ50uXKwahXY2pq5l7nbdaVkB9J1Wh0zu8zMcZ3mXiXAGV1moFv+m5q9XKYMjB5t+o4MGABeXnD1KixenLn4cMRh9Io+W3O9oueVla+wKmSVuiAjG71fP3U/j6p6dfDwUMto7N8PkFmDvaCB9ONRauC8rse9wHlGIL1OnUfvnynVrw82NnDrFvz3n3qhpGNHcHFRg/1vvgmLFqlZ3vmUFSE5maG+6pwGS08sJTrBuJJBBTHvyDxAzUbXaDTqBZepU9WV778PugfuZBk2TP0+dy6dfNoAsPFi4U1saFAM/BX6FwDP13j+8Xd47ZpRzcrYuJBuSOdk1MnHP6YQQghhhIz66F7ONoVSw1qUDv2bVsTGUsv56AT6zN3HqOVHGb7kMJdjkyhrb8WS14Jwd7Qp6m4KIYQoRUpUIB1g5MiRXL58mZSUFPbt20dQUFDmuuDgYBYuXJj58xdffMG5c+dISkoiNjaW3bt306tXryLotTC3G3dvcDf1LlqNlkplKuW/wYwZsGSJGjRbsQJ8c56gprDsvrIbRclpTveSo6ZbzRyXezt5s7LnSnpU6QaffqoufP99cHY2fSdsbODdd9X//+9/oNejN+gZtW5UnpuNXjcafegZWL1aXZCxj0el0ah10gGCgwHoVLkTWo2Wk1EnuRJ3xehdZctIzyjtUlwy0ufOVbO59++HmTPhlVfUCVAVRe3rTz/BwIFqhrcR6njUoVH5RqToU5h7eG7+GxTAsRvHOBRxCEutZWa5H5YsUQPMXl5qeacHde+u1k+PjOTlc2om05awLegN2S/KmMO+q/uITIjEydqJ1n6tH20nMTEwaxY0bw7PGTeBa41yNQAp7yKEEKLwSFkX8Sh2n48hOS3n8oI3E1I5fvV24XZICCFEqVfiAulC5CQjG93fxT//iRy3bLlfm3vatPtlOEzNzU0N7OZBsbEm3tGK6MRozsWeM08/Csk3u78B1BIUWwdsZWmPpWwdsJWwUWH0qNlDzUq+eBHc3R+vbEp+3nhDzXg/dw7++IMd4Tu4eudqrs0VFK7cucKNzz9Qg7/PPAMBAY/fj4zX1b1AuqutK0EV1At/686vM2oXKekphMSEABDoGahmfV+991hq1378PubFiNcvNjZqOysreOopdY6BZcvg0iW4fl2tMz52rBrENXJCPY1Gw1uN1dfHrIOzSDfkPgFoQWVko3ev0R03Oze1rvvkyerKd96BhyeatrTMnDC46u+bcLJ2IjYpliM3zFO//WEZZV1edWmD1bGTai35I0dwvnBBvZsmo758eHjWDRMTYfly6NZNvUAwYoRasshINcpKIF0IIUThCou5C0ggXRhPb1CYuPZ0rus1wMS1p9EbSnaykhBCiOJFAumiVDC6rMulS1knFzVnQNfXF0JD1ZIWGV/Dh6vrOnaEQ4fQhJ7Fs5Zap7kk10m/eucqi4+rpVQ+bPEhbfza0LtO7/uTvqakqLW0AcaNuz+xozk4OMCoexnoX31FxJ3r+W7ilgAeK++VXBk71jT9yMhIv1cnHQpe3uVMzBnSDem42Ljg4+RzPxu9YkXzZPQ/6KHXb9q+fQRPnUravn33X8+hobnfzeHlpWahf/MN7NwJO3YYfehetXrhbu/O1TtXM4PJjys5PTnzNZo5yeiaNepjcHFRL8DkZOhQ0GrRbg2mn2UjADZeKJzyLqtDV+NzG2aM+i+zjrxlUBBt3n0Xy6Cg+/Xlq1dXL1KtX6/+XvPwgN694e+/IT1dLb8zdSqsM+4CTg03CaQLIYQoXJKRLgpqf1gsEXG5lw1UgIi4ZPaHxRZep4QQQpR6EkgXpYJRgfSMyUVv3iy8yUV9fdWJCzO+XnxRXR4aqv7s60tzn+YA7Azfad6+mNH0PdNJM6TRumJrmng3yd5gzhy4cgUqVFBrZpvbW2+pwfpjx6h1KDzf5iP2g0VKGjRqdD8A/rhq1lTr7yclwYEDADxdVQ2kb7q4iVR9al5bA3AsUi3rUtejrlrPu7AnGn3w9Vu/PnGVK6tB2YxlBSmJZGRGOoC1hTVvNFQD29/u+7agvc7R6jOruZV8Cx8nHzpW6qjeffC//6krR4wAJ6ecN/T1Ve9SAIYeUjOaNoWZf8LRMzFnOHvzLJ7JFuhS0/JunJys3hHQpQv8+ivcvQt+fvDRR3D6tJq1PmaM+po04i6DatXViVWPRx4nTZ/PsYUQQggTuBitBtIrlZNAujBOVLxxk6Ib204IIYQwhgTSRalwNjafQLqiqJmlR4+qwc0//yyayUUbNwatVi3FcG/ivxa+LYCSO+FobFIsPx36CVCz0bNJTIQvv1T//9FH+QfyTMHVNXOiyDpz/8LbsULmpKcPs0uFtw7e+1U4dqzpLq7kUCe9gVcD3O3diU+NZ/eV/EttZNRHr+teTCcaNaM3G72JhdaCHeE7OHrj6GPvL6Osy8B6A9W7JIKD1bruNjZqSZo8O6Ne/Knz32Fs0tSLXolpiY/dp7xkZOI3rvCUcRvExkLZsupdL7t2qRnqX3yhBs8z5HSXzLJl6jpra3W70FB867TA2dqZFP390kJCCCGEuRgMCpduZmSkOxRxb0RJYewkojLZqBBCCFOSQLooFfLNSJ8+HZYuBQsL+P138PEpxN49wMHhfjbxnj0ANPNRsz9Db4YSkxhTNP16DD/s/4GEtAQCPQLpXLlz9gazZsGNG2o5kiFDCq9jY8aAlRWa3XtYXE7Nbn44mK5Bw4BjUDbBoGbwZtwxYCoZddK3bQNAq9FmPkf/ncu/vMvxKDVwHuhZTCcaNaPyjuV5KeAlAL7b991j7evS7UtsuqhmkQ+qN0hdmJGNPmSIWrc/L507g58futtxDLvoSqo+1ex3kGQE0tv6tTVug+nTISICfvgBmjXL/YLQw3fJ9Oql/j5MSVFr8Pv6otFoqO9VH4BD1w+Z4NEIIcxtwIABbN++vai7IcQjuXEnmeQ0AxZaDd5liiDRRZRIjf1d8XK2ySVVRq2R7uVsQ2N/18LslhBCiFJOAumixEs3pHMh9gKQSyB98+ask4uaqnTHo2raVP1+L5DuautKTTc1a9SYLOXiJDEtkW/3q6U3Pmj+gVp+5EHx8fcnc5wwQZ2UsrB4ecHgwQC0XrKLlT1XUsGpQpYmvg4V+PqEp/rDO++oF1pMKSOQvmsXpKqlXIytk64oSmZGeqBHoDoxZkkOpBdk8tJ73m6sZoovObHksS4yLTiyAID2/u3xL+OvZmJv2AA6Hbz7bv470Ong9dcBGHFIB5i3TnpEfAT7ru0DoFXFVsZt1KpVgcrnZNJo4Nln1f///Xfm4gaeDQCpky5ESREXF0eHDh2oWrUqX331Fdfu3fUmREmQUR/d19UOS518PBXG0Wk1TOgWAJAtmJ7x84RuAei0Zi7lKYQQ4oki71REiXf59mXSDGnYWNjg7eSddeWlS2rGpcEAAwbAyJFF0scsHgqkA5l10kvahKPzj8wnJjEGfxd/Xq71cvYG334LMTFQtSr071/4HXzvPTUIun49PRIrcmnUJbYO2MrSHkvZOmArF/xm4BB+A8qUyQy6m1RAgBoYfqBOeqfKndBqtJyIOsHVO1dz3TQyIZLoxGi0Gi213GtBWBgkJKglOKpWNX1fzS2nsiKHDqnB24wA+5dfZqm73sS7CQ29GpKiT2Hu4bmPdFi9Qc+Co2ogfXD9e2OccXHnlVfA39+4HQ0eDJaWVD4bTb0I2HjRfIH0v0L/AiCoQhDl7MuZ7TiZHgykK2od+AZe9wLpNySQLkRJsHr1aq5du8awYcP47bff8PPz4+mnn2blypWkpclcB6J4uygTjYpH1KW2F7P7NcDTOWuyhqezDbP7NaBLba8i6pkQQojSSgLposTLKOtS1bUqWs0DL+kHJxdt1KhwJhc1RjO1lAuHDqnlFIDmvvcC6SWoTnqaPo0pu6cA8F6z97C4el2d1DDjKzj4fvmMgQPh+vXC72SlStC7t/r/SZPQaXW08WtD7zq9aePXBt3Uqeq6YcPUsjum9mCd9HvlXcralaVxhcYArDu/LtdNM7LRq7pWxc7S7n42ekCA6TPnC8vDZUUaNFAn8pw4UV0/aZJa6/sejUbD20FqVvoPB34g3ZBe4ENuuriJK3eu4GLjwgs1XoBz52DlSnXlBx8YvyMPD+jRA4A3D6oTwUYlRBW4P8ZYHboagOdrPG+W/WfTrh3Y2cHVq3BMfd1lBNKP3jiK3qAvnH4IIR5LuXLlGDNmDMeOHWPfvn1UqVKF/v37U758ed555x3OnTtX1F0UIkdh0RJIF4+uS20vdn7QjmVDmzDzlXosG9qEnR+0kyC6EEIIs5BAuijxIk7to/516BxX7n4Q99AhNeh19Kg68eSqVYUzyaUxKlVSJzxNTVX7yv2M9APXD5CcXjJmll9xagWX4y7jbu/OINf2UL06/D979x0eVYE1cPg3M5n03nujhN6CIAoKShMbYt91cdHVVRdFcBWwgOiugCLi2lgVV921IfKpKKKAoiCd0EtCCSSQ3nsymZnvj5tJCOnJTGYmOe/zzMPk3jt3TuYmYebcc8+Jj6+7jRsHJSXKxs88o6xPSen8QOfVDEBduxaOXzQ4cft25aoAR0fLXqlgau9SM3AUWtfe5WBmTVsXU3/0rjxodPZs6N9fuXphXv2BtXf2v5MA1wDOF52v7RveFqYho38c+EdctC7wyitK1fX117f9tawZYPunI2o8KmDzmc1tjqclRZVF/Jz8MwA3x91s9v03ytkZxo9X7te0d+nt1xtXrStlurLak5VCCPuQnp7Oxo0b2bhxIxqNhilTpnD48GH69evHa6+9Zu3whGggOUd5vxgTIIl00T4atYpRPfy4eUgYo3r4STsXIYQQFiOJdGHfUlL40x3/IOFdeGX+z3VJ3OHD4ccflW1KSmrbFdgElapBe5eevj0JdAukSl9lF8P9jEYjS35Xqs1njZyFc2EJVLRwAqCiQkmUdrb+/WHqVOVnwNTSA5SEKigtZ0IsWLFiqkj//XeoubzelEjfdGYTOn3jl9wfylQS54MCa/qh23N/9JZotfDOO8r9996r1/bIycGJv8Yrw2Lf2N22oaM5ZTm1yff7h96vXBXx0UfKyksS9q1y1VXQty+ulQbuOWSZ9i4bTm2gSl9Fb7/e9PHvA56eLV9Jc0lv+Xa58Ubl33XrANCoNQwJHgJIn3Qh7IFOp+Orr77ihhtuICoqii+//JLHH3+ctLQ0PvroIzZt2sTq1at54YUXrB2qEA0kS2sXIYQQQtgJSaQL+5aTg1bXQtuBqirrJHCbc0kiXaVS1fVJt4P2LutPrudI1hE8HD145LJHrB1Oy2bMUP793//g++/h//4Pvv5aWXbddZatlO/fH/z8lFZDe/cCEB8aT4BrAEWVRU0OmG2yIr0rJtIBxoxRWgCBUvldXdfG5aHhD+GgduC3c79xIONAq3f5yaFP0Bl0DA0eytCQobBihfL34MorYfTotseoUsFDDykx7YVNpzdiNPNJOlPif2rcVGV47//9n3ISyM8PfvsN3a5dbHn1VXS7dtX1mU9MrNdbvl2mTFH+3b0bMjMBGTgqhD0JCQnhgQceICoqit27d7N3714eeughPD09a7cZN24c3t7e1gtSiEZUVRtIzS8HINbfAm32hBBCCCHMSBLpQliDqU/69u211fL2lEhf+rtS2f3Q8Ifwdva2bjAtSUlRBs4C6PXKYMWaXtcA3HabZdvOqNV1Vek17V3UKjWTek4CGm/vUlldyYmcEwAMDhqsJOFNvW27YmsXk5dfVga/HjwIb9RVn4d5hnFr31sBeGNX66rSjUZjbVuX+4feD/n5dVXv7alGN/nTnzC6uDAoCyKOnjdr25MqfRXrT64H4OY+N0NGBrz4orLy1VeVkw1Dh1LYowcMHVrXZ76jSXSA0FDlah6A9UoM8aHK1zJwVAjb99prr5GWlsZbb73FkCFDGt3G29ub5OTkzg1MiBak5pehNxhx0WoI8nSydjhCCCGEEM2SRLqwa/bST7yB4cOVgZFpaZCaCtQNHN2eut3sVa7m9HvK72xN2YqjxpHHL3/c2uG0LCfH+m1nLhk4Cs33ST+ec5xqQzXezt6Ee4bDsWPKCZeAAGXoZVcVEFDXfmfBAmX4ZQ3T0NFPj3xKTlnLx2pv2l4OZx3GSePEHwb+QUmil5TAgAF11dft4eOD6q67gJqq9DOb2r+vS/x69lcKKwsJcgtiZNhIePppKC6GESOUFkSWdkl7F9PA0YT0BAxGg+WfXwjRbjfddBNlZWUNlufl5VFUVNTm/b311ltER0fj7OzMyJEj2b17d5Pbjh07FpVK1eB2/fXX127z5z//ucH6yZMntzku0fVcPGhU1VIrMyGEEEIIK5NEurBrqYWp1g6hfVxdYXBNy46a9i7DQobh7OBMTlmOTQ/3M1WjTx80nVCPUCtHYydMA0e3bavtkz6xx0RUqDiUeYgLRRfqbX4wo6atS9Bg5UPlxYNGu/qHzPvvV1oflZQoQ0hrjAofRXxIPBXVFbyf8H6LuzFVo9/a71Z8cFbaugDMnatcJdARNUNH7zgKOw9817F9XcTU1uWmuJvQ7EuA//xHWfH66x2PuTVuuEH596efoLKSvv59cdI4UVRZRHK+VLEKYcvuuusuPv/88wbLV69ezV01J/9a64svvmDOnDksXLiQhIQEBg8ezKRJk8jKymp0+7Vr15Kenl57O3LkCBqNhttvv73edpMnT6633WeffdamuETXVNsfXQaNCiGEEMIOSCJd2LVzheesHUL7mdq71CTSHTWOXBZ6GQDbUrZZK6pmHc06yrqkdahQ8eSVT1o7HPsxYAD4+kJpqdLTGvB39WdE2AhAGTB5MVN/9EFB3WDQ6KXUali5EjQaWLMGflAq9lUqFY+OeBSAt/e8TbWhusldlOnK+OyIkqC5f+j9SkI6Oxuioura/HTE8OGUDuyDkx6ivv6l2Vhay2g08k3iNwDc3PsmmDVLWfGnP8Hll3d4/60ydKgyeLe0FH79Fa1GW/szKH3ShbBtu3btYty4cQ2Wjx07ll27drVpX8uXL+eBBx5gxowZ9OvXj5UrV+Lq6soHH3zQ6Pa+vr4EBwfX3jZu3Iirq2uDRLqTk1O97Xx8fNoUl+iaztQk0mNl0KgQQggh7IAk0oVdO1dgx4l008DR7XXDJkdHKgMQbbVP+svbXwZgWt9p9PbrbeVo7IhaDVddpdxvRXuXQ5lKBfrgoG4yaPRSgwbVJZJnzoRyZQjZnQPuJMA1gNSiVL458U2TD19zbA1FlUXEeMcwNnw0vPKKsuLJJ0Gr7Xh8KhUuM5Vq+T/vrGRPatuSVI3Zl76PC8UXcNO6MWFXtnKCzc0Nlizp8L5bTa2uq0pvpL2LEMJ2VVZWUl3d8KSeTqejvOZvaGtUVVWxb98+xo8fX7tMrVYzfvx4dtSc+G/JqlWruOuuu3Bzq58Y3bJlC4GBgcTFxfHwww+Tm5vb6rhE15WcUwIorV2EEEIIIWydg7UDEKIjUgotNCCyM5gS6fv3K4lCFxebHjiaUpjCp4c/BWDulXPrr/T3V5Jwhmb6KDs7K9t1V2PHwtdfKwNH5yqv33W9ruP5X59n45mN6PQ6tBotRqOxtiJ9cPBgpTf6xa1duovnn4cvvoAzZ+Cll+DFF3F2cOav8X/lH1v/wb92/4tb+93a6ENNbV3uG3of6i/XwNmzSv/1GTPMFp76j3+k7PG/0TO/mp1r3mXUE1d2aH+mti63REzAcd6zysJnnlGGgHamG26A996D776Df/2rLpEuA0eFsGkjRozg3Xff5Y036g9kXrlyJfGmQcKtkJOTg16vJ+iSeRxBQUGcOHGixcfv3r2bI0eOsGrVqnrLJ0+ezLRp04iJieH06dM8/fTTXHfddezYsQONRtPoviorK6msrKz92tTrXafToatpk9YZTM/Vmc/ZnZh6pEd4OzX7GstxsA1yHKxPjoFtkONgG+Q4WF9XOQZtiV8S6cKuHdKnUe4ALs11VrDVBG5UFAQHQ0aG0u5j9GhGRSjJ9aTcJLJLswlwC7BykHWW71hOtaGaa2Ou5bKwy+qvvHBBSaKrVPDllxAT03AH/v4QGdk5wdoi08DRbduguhocHBgeOhx/V39yynLYcX4HV0VdRUZJBjllOahVavoH9IfMTGUQqloN/fpZ93voTB4eSm/w225TBpDecw/ExfHQ8IdY8vsSfjv3GwczDionGy5yMvckv537DbVKzZ8H3wsza4bdzZqlzCYwFzc3ztw4mgGrtxD56ffwRMd2Z0qkP7XVoAwhjo2t1yO+01x7LTg5KScfjh2rV5FuNBplEJwQNuof//gH48eP5+DBg1x77bUAbN68mT179vDTTz91WhyrVq1i4MCBjBgxot7yi/u0Dxw4kEGDBtGjRw+2bNlSG++lFi9ezKJFixos/+mnn3A159/zVtq4cWOnP2dnMhjhdJGKIh14aqGHpxG1hf/kV+ohs1j5OHoyYTtph1t+TFc/DvZCjoP1yTGwDXIcbIMcB+uz92NQVlbW6m0lkS7s2lbOETcTNl3zIb1vuR/0eqUlwcVVnLaawFWplD7pa9cq7V1Gj8bXxZd+Af04ln2M7anbubnPzdaOEoCcshzeS3gPaKQa3WiEp59W7s+YAbc2XiXc7Q0aBD4+kJ8PCQkwYgRqlZpJPSbxyeFP+OHkD1wVdVVtNXpvv964aF3g0Fbl8T17mjcRbA+mTYMpU2D9enjkEdi0iTDPMG7teytfHP2CN3a/wfs31R88+sF+pYfvpB6TCP/9sNJf3t1debyZec2aC6u3cMWBXErOJOIeG9eu/ZzKO8XR7KP0zFcz4OMflYWvvqqcBOxsbm5KMn39eli3jgF/fxwHtQM5ZTmkFqUS6WWDf0uFEFx55ZXs2LGDV155hdWrV+Pi4sKgQYNYtWoVvXr1avV+/P390Wg0ZGZm1luemZlJcHBws48tLS3l888/54UXXmjxeWJjY/H39+fUqVNNJtLnz5/PnDlzar8uKioiIiKCiRMn4unp2Yrvxjx0Oh0bN25kwoQJaM3RHswG/Xg0k8XrT5BRVHcFQLCnE89O6cOk/kHNPLJjjqYVwe6d+Lhquf3mic1u2x2Ogz2Q42B9cgxsgxwH2yDHwfq6yjEwXfnYGpJIF3YrtyyX3PJccr0h3DNMSaIHBcH11ytJanswapSSSL+o7+iVEVdyLPsYv6f+bjOJ9Dd3v0mZroxhIcMYHzu+/spNm5R2JY6OsHChVeJrlr+/kpCsqGh6m864asHUJ/2bb5TXq6Za77qe1ymJ9FM/sHj8Yg5m1LR1MfVH706DRi+lUsEbb8DPPyu3zz6DP/yBR0c8yhdHv+CTw5+wdPxS/Fz9AKg2VPPRwY+AmiGjD9X0F3/oIeUkhplFXDGZ3T2cGXG6ggsrXiDuX5+0az+mfu8f/O6HqjIbxo+Hm634u3/DDUoi/bvvcJ43j/4B/TmYeZCE9ARJpAthw4YMGcInn7Tv75CJo6Mj8fHxbN68malTpwJgMBjYvHkzM2fObPaxX375JZWVldxzzz0tPs/58+fJzc0lJCSkyW2cnJxwcnJqsFyr1Vrlg5q1ntfSNhxJ59HPD2K8ZHlmUSWPfn6Qd+4ZxuQBTR+njkgtUBL3sQHurX5tu+pxsDdyHKxPjoFtkONgG+Q4WJ+9H4O2xC7DRoXdOpl3EoAwjzBcE2qSjSNH2k8SHer6pO/YoVR2g831SS+tKuWN3UrP1XlXzqvf2uHiavSHH7bNyv/ISEhMVNrnNHVLTOyc2E3tXS4aODqp5yRUqDiYeZC04jQOZSn90AcF1STOu9ug0UvFxsKzNT3D58yBggKuiLiCYSHDqKiu4P2Euor0H07+QHpJOgGuAdyU4wdbtyoneCzYIuXw1CsACPr0W6VlTzt8nfg1487AmL3ZoNHAihXW/Tt2fU07nB07ICdHBo4KYWcqKiooKiqqd2uLOXPm8N577/HRRx9x/PhxHn74YUpLS5lRM2di+vTpzJ8/v8HjVq1axdSpU/Hz86u3vKSkhCeffJKdO3dy9uxZNm/ezM0330zPnj2ZNGlS+79R0WF6g5FF6441SKIDtcsWrTuG3tDYFh2XnKP0R5dBo0IIIYSwF5JIF3YrKTcJUFpgsHOnsnDkSCtG1A7x8aDVKn2wz54FYHTkaAD2pu2lorqZKupO8n7C++SV59HTtyfT+k6rv3LtWti7V2kHYUqo26LISBg2rOlbZ50AGDtW+Xfr1tqkq7+rf23P+Q2nNjSsSO+Og0Yv9fe/Q1yc8nvyzDOoVCoeG/EYAG/teYtqg/JamoaM/mnQn9AuW648dvp0iw7s9LnnL2S7gnduCXz/fZsfn1Waxa6zv/P6hpoFjzwC/fubN8i2ioyEwYOVuQc//CCJdCHsQFlZGTNnziQwMBA3Nzd8fHzq3drizjvvZNmyZSxYsIAhQ4Zw4MABNmzYUDuANCUlhfT09HqPSUxMZNu2bdx///0N9qfRaDh06BA33XQTvXv35v777yc+Pp6tW7c2WnEuOs/u5DzSC5t+r2kE0gsr2J2cZ5Hnl0S6EEIIIeyNJNKF3aqXSN+1S1lob4l0Z2clkQtKn3Qg1ieWILcgqvRV7E3ba8XgQKfX8eqOVwF48oon0ag1dSurq+tXCgcGWiFCOzNoEHh7Q3Ex7N9fu/i6ntcB8H8n/o8TOScAlCGa1dVw7FjdY7srJyd4+23l/jvvwJ493DngTvxd/UktSuWlrS/xzp53WJe4DoCHnccosxJUKnjySYuGNjZuEv8ZqtyveGNFmx//XdJ3PLDXyMAswM8Pnn/enOG13w03KP9+950k0oWwA08++SQ///wz77zzDk5OTrz//vssWrSI0NBQPv744zbvb+bMmZw7d47Kykp27drFyIveX23ZsoUPP/yw3vZxcXEYjUYmTJjQYF8uLi78+OOPZGVlUVVVxdmzZ3n33XdrE/PCerKKW1ew0drt2upMTSI9VhLpQgghhLATkkgXdsuUSB+qCoVz55Sk2WWXWTmqdri4vQugUqm4MrKmvUuKddu7fHbkM1KLUgl2D2b64On1V/7vf3DiBPj6whNPWCdAe6PRwJgxyv2L2ruYEunfJX2H3qjHXetOsFswJCVBVZVS8R8dbYWAbcg118Af/6i0E3r4YZxVWq6OUlrlLNyykEfWP4IBA45qR7TLVyiPufVW6N3bomH5uviyfYpytYDz5i1w5kybHr95z2pe/LnmixdfVH6fbIEpkb5hA4N9+qJWqUkvSSe9OL35xwkhrGLdunW8/fbb3HrrrTg4ODBmzBieffZZXnrppQ73TRddV6BH64Zat3a7tjAajSRnlwAQEyCJdCGEEELYB0mkC7tlSqQPS6npS9yvH3h6WjGidrokkQ620SfdYDSw9PelAMy+fDbODhd9iKqsrBssOm8eeHlZIUI7ZWrvsmVL7aLUwlTUF/05LtGVEPOvGHZtUFqVMHCgMqy0u3v1VeVnbd8+Diz8K2uPr22wSUhuFWHrak5SzJ3bKWH1G3kDG3rUfPHvf7f6caVVpYz5YBO+FVDetxc88IBlAmyPESMgIACKinDbvZ8+/n0A2J+xv4UHCiGsIS8vj9jYWAA8PT3Jy1NacYwePZrffvvNmqEJGzYixhd/d8cm16uAEC9nRsSY/yRvXmkVRRXKe/hoP0mkCyGEEMI+SGZG2CWD0VA7bLRHUpay0N7aupiYEukHD0KpcomrKZG+PXU7RqNlBjy15Luk7ziWfQxPJ0/+Gv/X+iv//W9ISVF6T8+caZX47JZp4OjWraDXs/b4Wu5YcwcGDPU2u1B0gc1f1/T57s5tXS4WFASLFwMQ++oHBBU3/N14Ygc4GGFrbyf0w4Z2SlgTYifwTs3FMMYPPlBONLXCzh/e44HdegCc31wJDg6WCrHt1Oq6oaPS3kUImxcbG0tycjIAffr0YfXq1YBSqe7t7W3FyIQtMxqNuGg1zW6z8MZ+aNTmH4Bt6o8e5u2CcwsxCCGEEELYCkmkC7uUVpxGma4MB7UD3geVynQuv9y6QbVXRASEh4NeD3v2ADA0ZCjODs7klueSmJvY6SEZjUaWbFsCwCPDH8HL+aKK85IS+Mc/lPsLFoCLS6fHZ9eGDFGunCgqQp+wj1kbZmGkYULYiJGBmcp9wwArD5+0JQ8+SNGgPnhWGHn1x/qrAkrgLzV53ucvr2RrytZOCemKiCv4ua8zqZ6gysmBr75q+UFGI8HPLUVjhINX9kR1zTWWD7StbrxR+XfdOoYFKSclJJEuhG2aMWMGBw8qw6rnzZvHW2+9hbOzM7Nnz+ZJC8+KEPbr/W3JpOaX4+qoIdCj/uBXD2cH3rlnGJMHhFjkuc/IoFEhhBBC2CFJpAu7ZGrr0tMrBvXemoGc9lqRDg3auzhqHBkZpnw/21K2dXo421K2seP8Dpw0Tsy6fFb9la+/DtnZ0KMH3Hdfp8dm9zQauOoqAJK//pDzReeb3NSUSD8YaJ2rEmySRsP2p/+EXgV/OALjT9etenQ3uFTDnlD4OYZO6+ft5ODElbFX817N3GBWrmzxMfqv1tD/cAYVGihf8qJlA2yvCRNAq4VTp7iyPACQRLoQtmr27Nk89thjAIwfP54TJ07w6aefsn//fmbNmtXCo0V3lJxTymsblffTz9/Unx3zr+WzBy7n9vhwAHoEuFksiW56fpBEuhBCCCHsiyTShV0yJdKvqQyF4mJlGGN/O67atbE+6Ut+V6rR/zzkzwS7B9etyMuDV15R7r/wgpJkE21X097FZdvOJjfxrIDoQuX+6XDXzojKbjiPvIKParrdvP8NjEyBK8/BrJqX84v+EFEIIR6WSwBcanzseFYNA71apbTtOXKk6Y0rKqiarSS83rzaheFX3NZJUbaRh0dtT/+Be84BcK7wHLlluVYMSghxKZ1Ox7XXXsvJkydrl0VFRTFt2jQGSWsw0Qij0cj8tYeorDZwZU8/bo8PR6NWMaqHH3+fFAfAgdRCMgorLBZDcraSSI+VQaNCCCGEsCOSSBd2yZRIvyqtZkDS8OFKpa+9ujiRXtMT/crImkR6Sucm0g9lHmL9yfWoVWr+fsXf669cuhQKC5We3Xfd1alxdSk1ycmg/UmoDY1vYqpGT/UE/7BenROXnRhDFH88qtyPKoKdH8C2/4BnlbJs2UZIelPZrrNMiJ1Amid836fmv9Xmho6++iou5zM47wFJD9yCg9qGeqNfqqa9i8uGTfT07QnIwFEhbI1Wq+XQoUPWDkPYkS/2pLLzTB7OWjWLbxmESlXXAz3I05n4KB8AfjyaYbEYpCJdCCGEEPZIEunCLpkS6YPOlisL7LU/usnQoeDkBDk5cOoUAKPCleT6ybyTZJVmdVooL//+MgC397u9NnEGQFoa/Otfyv1//lMZRijap6ZPukNxKRNLAlHRcIjXwJpDnhTmzJjIMZ0bn43T5OXjVN38Ns7VynadZWDQQALdAnkjXhkeyscfK/MELnXhAsaXXgLgqQkwZcjtnRZju5gGjm7bxhiPAYC0dxHCFt1zzz2sWrXK2mEIO5BZVME/1x8H4IkJcUT6NbzqbXJ/5WrEDUcsk0g3GIwk59ZUpPu7W+Q5hBBCCCEsQTJhwi6ZEukRJ9KUBfbcHx2UJHp8vHK/pr2Lj4sP/QOUdjXbU7d3ShjJ+cl8fuRzAOZeObf+yn/8AyoqlOp5U3JNtI+DA4weDcBS7RSABsn0wTUV6eFXTkajtuOrLboJtUrNtTHXsjkGckN9oKgIPv+84YZz56IqK2NbBHw91JmJPSZ2frBtERsL/fqBXs/Us8pgYUmkC2F7qqureeeddxg+fDh//etfmTNnTr2bECYLvzlKcUU1g8K9mHFldKPbTB6gJNJ3JeeSV1pl9hjSCsupqjag1agI85Gh9UIIIYSwH5JIF3ZHp9dxJv8MbpXglnRWWWjviXRovk+6Bdu76A16tpzdwmeHP2POj3PQG/VM7DGRoSFD6zY6fRree0+5v3gxqBpWUIs2qmnvMuh4HmvuWEOYZ1i91fG5StuiuHE2XrEsak2InYBRDZ9c4aEseOed2lZNAGzfDp98glEFs66DCT0n4qq1g/73Ne1dLtuvVCbuS99nzWiEEI04cuQIw4YNw8PDg6SkJPbv3197O3DggLXDEzZiw5F0NhzNwEGtYsm0QThoGv8oGOHrSv9QTwxG2HjM/FXpprYuUX5uaNTynlIIIYQQ9sOGG7MK0bjkgmT0Rj2js5xQGSohPBxCQ60dVseZEunb66rPR0eO5t2Edy02cHTt8bXM2jCL80Xn6y2/IvyK+hsuXAjV1TBpUu2gTNFBNYl0fvuNab3XcnPczWxN2Up6cToh7sEMf/VmoErpRy/swvjY8QD8IzaVR52cUCUkwN69cNllYDDArFkAfH2FHwmhucyMm2rFaNvghhtg6VKCtu5HMxhO5Z2isKIQL2cva0cmhKjxyy+/WDsEYeMKy3Q8940yYOSvV8fSL9Sz2e0n9w/maFoRG45kcOdlkWaNRfqjCyGEEMJeSUW6sDumti7X5fkqC+y9P7qJKZF+5AgUFwN1A0f3pu2lXFdu1qdbe3wtt62+rUESHWDRr4tYe3yt8sXhw/Dpp8r9f/7TrDF0a0OHgocHFBTA4cNo1BrGRo/l7oF3M1YVg6q4GLRaiIuzdqSilSK8Iojzi8O5ykjGCKUtEy++CAkJ8MILsHcvBldXXuyfi1ql5obeN1g34Na6/HLw9UWdX8DU/EAADmQcsG5MQggh2mTxD8fJLq4k1t+NR69peYi5qb3L76dyKarQmTWWM9mm/uiSSBdCCCGEfZFEurA7pkT6qAs1P75doa0LKFX1UVFK5eru3QDEeMcQ7B6MzqBjb9pesz2V3qBn1oZZGDE2uc3jGx5Hb9DDM88o7Sluu62uj7vouIv6pLNlS/11hw8r//btqyTThd243X0kiW9CyNaaPuLr1im/N4sWAaAuK+P3D+AW13gC3AKsGGkbODjAFKWX/x/PKRWM0iddCNsybtw4rrnmmiZvonvbfjqHz/ekArB42kCctS3PXukV5EGPADeq9AZ+OWHeofdSkS6EEEIIeyWJdGF3knKTwAh9ThcqC7pKIh0a9ElXqVR1fdLN2N5la8rWRivRTYwYSS1K5eDXK5VEoFqtVNYK8zK1ybk0kX7okPLvwIGdGo7ouGs9BuNS3fw2LtUw1X905wRkLjco1fOjDyl/dxMyJJEuhC0ZMmQIgwcPrr3169ePqqoqEhISGCj/l3Rr5VV65q9VTtD/cWQkI2P9Wv1YU1X6hiPm7ZMuiXQhhBBC2CvpkS7sTlJuEuFF4JlbAhpN16qSHjUKPv+8Xp/0KyOu5KvjX5k1kZ5enN7yRkYIW/K2cv/Pf4Y+fcz2/KLGRX3SMRiUExZQV5Eu/dEb5+8Pzs5QUdH0Ns7OynadLD60dX+Pro6ys1kDkyaBgwMB57KJzZOKdCFszWuvvdbo8ueff56SkpJOjkbYkhWbkziXW0awpzPzrmvbe7nJ/UN465fTbEnMprxKj4tjy5XsLams1nM+vwyAmABJpAshhBDCvkhFurA7SblJjDQVUw8aBK6uVo3HrK6oGfK5c6eSWKWuT/r21O0YjAazPE2IR0iL20w4DUF7joGjozJsVJjfsGHg7g75+XXJc6irSJdEeuMiIyExEfbta/qWmKhs18k8nDxatV2EV4SFIzEzb28YMwaAG5LgRM4JSqtKrRuTEKJF99xzDx988IG1wxBWcuRCIe9vTQbgxakD8HBuW7u4AWGehHm7UK7T82tStlliSs0rw2AEdycHAtydzLJPIYQQQojOIol0YVdKqkq4UHyBkRdqFnSlti4AgweDi4uSWE1SesEPDR6Ki4MLeeV5JOYkmuVpxkSOIcS96WS6ygjLttR82Hr4YaskJLsFrRauVE6U1LZ3qaioPfbS2qUZkZHKiYimbvIza3417V1uPe2IwWjgUOYhKwckLqU36NlydgufHf6MLWe3KHMubIQtx9aV7dixA2dnZ2uHIaxApzfw1JpD6A1Grh8UwoR+QW3eh0qlqm3v8uNR87R3MQ0ajfF3Q6VSmWWfQgghhBCdRVq7CLtyKu8UAKPTHYDqrpdI12ph+HDYulXpk96nD1qNlpHhI9lydgvbUrbRN6Bvh59GZ9Dh4eRBeknDFi8qVEw7bmTQeR24ucHTT3f4+UQzxo6FH3+EX3+FWbPg+HHQ68HXVxlAK4StuOEGeOIJRp3R4VGhtHcZFTHK2lGJGmuPr2XWhln15l+Ee4bz+uTXmdZ3mhUjs+3Yuopp0+q/jkajkfT0dPbu3ctzzz1npaiENb2/NZlj6UV4uWh5/sb+7d7PdQOCWbUtmU3HM6mqNuDo0LE6LOmPLoQQQgh7JhXpwq4k5SbhoIehF2panHS1RDrUDRy9pE86mGfgqNFo5P5v7ycpNwk3rRvB7sH11ke5hfHB3jDlizlzIDCww88pmmHqk/7rr0o7n4sHjUqllrAlvXtD795o9UYmnpY+6bZk7fG13Lb6tgZDpC8UXeC21bex9vhaK0Vm27F1JV5eXvVuvr6+jB07lvXr17NQ2rN1O8k5pazYpFzd9twN/QjwaH8LlWGRPgR4OFFcUc320zlmiQ0kkS6EEEII+yQV6cKuJOUmMSALnKsM4OUFcXHWDsn8TH3Sd+yoXWTORPo/fvsHnx7+FAe1A9/e/S1XR13N1pStpBenE+IRwlWbT6M+8xelIvqJJzr8fKIF8fFK5X9eHhw5IoNGhW274QZYvpwbkuD1DEmk2wK9Qc+sDbMwYmywzogRFSoe3/A4N8fdjEbd8UGBXSW2ruY///mPtUMQNsJgMDLvq0NUVhsY08ufW4eFdWh/arWKif2C+GRXCj8ezWBsXMcKLM7UJNJjZdCoEEIIIeyQVKQLu1Jv0OiIEaDugj/Cpor0Y8egsFBZFDEKFSpO5Z0isySz3btefXQ1C7YsAODtKW9zTcw1aNQaxkaP5e6BdzM2ZBTqF15QNp43TzlZISzr4j7pv/4qg0btnb8/tNSP2NlZ2c4e3XgjANefhGMZh6msrrRyQGJrytYG1d4XM2IktSiVrSlbOzEqhS3H1tXs2bOHXbt2NVi+a9cu9u7da4WIhLV8sTeVXcl5uGg1vHTLQLP0Ib9ugDJX56ejmegNDU+MtYVUpAshhBDCnnXBLKToypJyk7jc9Jm8K7Z1AaWVSmwsGI1Q86HY29mb/oFKf8vtqdube3STdl/Yzb1f3wvA7Mtn80DAJEhIqH979llISVGSfDffbJ7vR7TM1N5ly5b6rV2E/YmMhMREzmz6kmEPwqhHHNn9zTsMexCunumObvcuSEy032GoV16J0cuLgDIYlqrnSNYRa0fU7aUXN5x10ZHtzMmWY+tq/va3v5Gamtpg+YULF/jb3/5mhYiENWQWVfDS+uMAPDGxNxG+rmbZ78hYX7xctOSWVrHnbF6791NcoSO7WDkBGy2JdCGEEELYIUmkC7thNBpJzE1k5IWaBV01kQ6N9kkfHTEaaF97l9TCVG7+/GYqqiu4vtf1vBL3qNIWJz6+/m3ZMuUBOTkweLCSVBeWlZICwTV96n/4ATJrrjjQ6ZSTG3IM7E9kJDHX3EpG7xB2BlZxV/LL7A+F0LE3oL1shP0m0QG0WlSTJwNwQ5L0SbcFIR4hZt3OnGw5tq7m2LFjDBs2rMHyoUOHcuzYMStEJDqb0Wjkua+PUFxRzeBwL2ZcGWO2fWs1asb3DQJgw5GMdu/nbE4ZAP7uTng6a80SmxBCCCFEZ5JEurAbueW5GPML6Guac9SVE+mN9UmPVNp/bEvZ1qZdlVSVcNPnN5FRksHAwIF8dutnaPLyoaKi+QdWVCgJdWE5KSnKCY377lO+Li+vWzdmjHJyIy5Okul26P9O/B+FlUprpuSCZAA2nt7YNQYr1rR3uTER9qXvs3IwYkzkGMI9w1HRePsGFSoiPCMYEzmmkyNTYgv1CG1yvTVj62qcnJzIzGzY+i09PR0HBxmJ1B1sOJLBT8cycVCrWHLrIDRq8w4sv26ActL/x6MZGI3ta+9yJqcEgFipRhdCCCGEnZJEurAbiTmJXJZW80VsLAQEWDUeizJVpO/cCQYDUDdwNCE9gXJdeVOPrMdgNHDP2ns4kHGAQLdA1t29Dg8nD4uELNohJ0dOaHRBa4+v5bbVt1GmK6u3PK88j9tW32b/yfTJkzGoVQzKgrQjO1reXliURq3h9cmvN7vNiskrrDLMU6PWcEX4FY2uMyX+rRVbVzNx4kTmz59PYc1sFYCCggKefvppJkyYYMXIhKXoDUZ2nM7lmwMX2HQsk+e+UVptPTy2B31DPM3+fKN7+ePqqCG9sIKD5wtbfkAjpD+6EEIIIeydJNKF3egW/dFNBg4ENzcoKlKGjgLR3tGEuIegM+jYk7anVbuZv2k+3yR+g5PGiW/u+oYo7yhLRi1Et6c36Jm1YRZGGlbrmZY9vuFx9AZ9Z4dmPn5+VI6IByD692Po9DorBySm9Z3GmjvWoG7kbd0zY55hWt9pVogKzhed5/uT3wPg5+JXb52Hkwdr7lhjtdi6mmXLlpGamkpUVBTjxo1j3LhxxMTEkJGRwauvvmrt8ISZbTiSzuilP3P3ezuZ9fkB/vLxXnJKqgjydGLmNT0t8pzOWg3j+gTWPH/72rvUJtIDJJEuhBBCCPskiXRhN5JykxjZXRLpDg5w2WXK/Zr2LiqVqra9y+8pLfdJ/8/+//Dy9peV+zf/h8vDL7dMrEKIWltTtnK+6HyT640YSS1KZWvK1k6Myvycpt4GwHUnqjmec9zK0QiAG3vfiAHlCqaV16/k9r63A/BN4jdWO3Hz7M/PUl5dzujI0WQ8kcEv9/7CYyMeA8DFwYUbe99olbgupTfo2XJ2C58d/owtZ7fY5YmusLAwDh06xMsvv0y/fv2Ij4/n9ddf5/Dhw0RERFg7PGFGG46k8/D/EkgvbHhFW2ZRJb+cyLLYc5vau2w4kt6u9i5SkS6EEEIIeyeJdGE3ki4eNHp5N0gKN9Ynvaa9S0sDR389+yt//e6vACy4agF3D7zbMjEKIepJL04363a2Sl3TJ/2aZDh0ensLW4vOkF2WDYBapeYvw/7CyhtX4u3szeGsw3x08KNOj2d/+n4+PvgxAK9OfBUHjQNjo8fyysRXCHILIrM0k28Tv+30uC619vhaol+PZtxH4/jD2j8w7qNxRL8ebZctmNzc3HjwwQd56623WLZsGdOnT0erlYGOXYneYGTRumONXPOkUAGL1h1Db2hfD/OWjI0LxNFBzdncMhIzi9v0WKPRSHK2kkiXHulCCCGEsFeSSBd2oyzpKAFlYNA6wJAh1g7H8kx90i9KpI+OHA3A9tTtGIyGRh92Ku8U01ZPQ2fQcUf/O1g4dqHFQxVCKEI8Qsy6nc3q25fcYC+c9FC+4TtrRyOAzBJl0GSAawAatQZfF1+eu+o5AJ775TlKq0o7LRaj0cjfN/4dI0ZmBt3EiEwHSEiAhAQcDx7hWfcpDE2DzV+9YtVhyqZ5BpdeRXKh6ILdzTNYvHgxH3zwQYPlH3zwAUuXLrVCRMISdifnNVqJbmIE0gsr2J2cZ5Hnd3dy4Kpe/kDb27vklFRRXFmNSgWRfq6WCE8IIYQQwuIkkS7sgsFoIPDQGQCqBvYHJycrR9QJTFX3J05AnvKBaHDQYFy1ruRX5HMi50SDhxRUFHDjZzeSV57HiLARfHjzh6hV8msuRGcZEzmGcM/w2kGKl1KhIsIzgjGRYzo5MjNTqci+RmmxFbyldTMbhGVllSrtHILcg2qX/e2yvxHjHUNacRrLdyzvtFjWn1zPz8k/07PYkdcf/xHi4+vdZj78HxLehbcX7MLQu7dVkuldbZ7Bv//9b/r06dNgef/+/Vm5cqUVIhKWkFXcwoDyNm7XHpMHKCeC25pIN7V1CfdxwclBBgwLIYQQwj7ZXYbtrbfeIjo6GmdnZ0aOHMnu3bub3Pa9995jzJgx+Pj44OPjw/jx45vdXtiu1MJUhqVWA+B4xWgrR9NJ/P2hd2/l/s6dAGg1WkaGKcmrbSnb6m1ebajmji/v4ETOCcI9w/n6zq9x0bo0ve+WLvd2dla2E0K0mkat4fXJrwM0SKabvl4xeQUatf0nEVyn3gHAZfuz0VfLwFFryyxVKtKD3OoS6U4OTiwZvwSApb8vJaOkfQMC26LaUM2TG58EYGbsXagrK5vdXl1ZCTk5Fo/rUl1tnkFGRgYhIQ2vdAkICCA93b5bSYk6gR7OZt2uPcb3DUSjVnEio5izOa2/0iU5pwSAGH93S4UmhBBCCGFxdpVI/+KLL5gzZw4LFy4kISGBwYMHM2nSJLKyGh+qs2XLFu6++25++eUXduzYQUREBBMnTuTChQuNbi9s18WDRtWjrrBuMJ2pkfYujfVJNxqNPPbDY2w8sxE3rRvr7l7XfOsIX1/w8VHuP/YY7NvX8JaYCJGRZv+WxEX8/ZUTFs2RExp2Z1rfaay5Yw1hnmH1lod7hrPmjjVM6zvNSpGZV9gNd1PsCMElRlK3fGPtcLo9U2uXiyvSAW7vdzsjw0ZSqitl4S+Wb/X1fsL7HM85jp+LH/cNva9Vj9HpO/9ETFebZxAREcHvvzecn/L7778TGhpqhYiEJYyI8SXEy7mJa56UHukhXs6MiPG1WAzero6MivUDYMPR1p+cO5Mj/dGFEEIIYf8crB1AWyxfvpwHHniAGTNmALBy5Uq+//57PvjgA+bNm9dg+08++aTe1++//z5fffUVmzdvZvr06Z0SszCPU+lHuc/0Xn3kSKvG0qlGjYKPPqqfSI9UEumbTm/is8OfEeIRwsGMg7yz9x1UqPj01k8ZEjyk+f2+/DJkZUFsrHK/O7TKsUWRkcoJi+aqMf395YSGHZrWdxo3x93M1pStpBenE+IRwpjIMV2iEt1E4+LK3oG+jNuXR/GaT2H8bdYOqVszVaQHugbWW65SqVg2cRlj/jOG9/e/z2MjH6N/YH+LxFBUWcTCLUqy/vmxz+Ph4NGqx/2S/AsTL+vc/9u72jyDBx54gMcffxydTsc111wDwObNm3nqqad44oknrBydMBeNWsXCG/vx8P8SGqwzJdcX3tgPjbqpVLt5TB4QzLZTOWw4ksFDV/do1WNMg0ZjJJEuhBBCCDtmN4n0qqoq9u3bx/z582uXqdVqxo8fz46LkozNKSsrQ6fT4evbdJVGZWUllRddhlxUVASATqdDp+u8iinTc3Xmc9qy0t2/46SHEi8XnCIioJNeF6sfh+HD0QLGXbuorqgAjYaMIuWMQlpJGn9Y+4d6my++ZjHXxV7XfLypqTgsW4YKqH7pJYxqdae9nu1h9WNgaSEhyq05NvC9d/njYCFXhl1Ze9+gN2DQNz4kuLVs7TicHz0E9v2M9+bfbSYmS7O1Y2Biqpz2d/FvENvIkJFMjZvK14lf89TGp/j6jq8tEsNLv71EVmkWPX17ct+g+9AdOkILTcQA+PLYl4zTtS3Z29HjcHnI5YR5hHGhuPGrFFWoCPMM4/KQyy16rM217yeffJLc3FweeeQRqqqqAHB2dmbu3LmNFpsI+zV5QAjv3DOMJ748SGllXQ//YC9nFt7Yr7aHuSVN7BfEc98c4UBqAemF5YR4NdFK8CKmHumSSBdCCCGEPbObRHpOTg56vZ6goPqXLAcFBXHiRMOhi42ZO3cuoaGhjB8/vsltFi9ezKJFixos/+mnn3B17fwJ8xs3buz057RFxq1Kj/CzkYGc/uGHTn9+qx0HvZ4pLi5oS0rYtnIlP/pksPTs0iY3zzudx/q89c3ucthrrxFRXk5O//787uQE65vf3lbI74JtkONgG2zlOByPjsEARJzK4sf//pcKPz9rh9RpbOUYmBw7dwyAjNMZrM9v+Hd9onoi61jH+lPrWfzFYgZ7DDbr82dXZfPa8dcAuM3zNjb+uBGv06cZ24rH7ktP4L217xHmHNbyxpfoyHEY7TqaL4q/aHSdESN/9P0jP274sd37b42ysjKz7EelUrF06VKee+45jh8/jouLC7169cLJyQm9Xo9G03WuhhFKMv2LPan8kpjNbfHh3DosnBExvhavRDcJ9HQmPtKHvefy+fFIBn++MqbZ7fUGI+dylZ91SaQLIYQQwp7ZTSK9o5YsWcLnn3/Oli1bcG6mJ/H8+fOZM2dO7ddFRUW1vdU9PT07I1RAqVDauHEjEyZMQNvSUMju4MUCAFyvHceUKVM67Wlt4ThorrgCNm9mtIOGP+X+r8ntVKj4NP9TFt29qMn2Eardu3H49VeMKhVeq1YxZdgwS4VtNrZwDIQcB1tha8chLDOMXa+uYtR5uLaiAmMn/n22Fls7BiYL3l8AxTBh1AQm9ZjU6DbH3I7x5t43WVuylrl3zEWtMt+onPvW3UeVsYoxEWNYdPciVCoV7N/f6sef9DzJA+MfaPX2HT0ORqORpf9VTky7a90p0ZXUrgv3DOfV8a9yS59b2rzftjJd+Wgu7u7uXHbZZQAkJSWxatUqPv74Yxk42gUlZSo/s7fHhzMytvNPYk4eEMzec/lsONpyIj2toJwqvQFHBzWh3i1XrwshhBBC2Cq7SaT7+/uj0WjIzMystzwzM5Pg4OBmH7ts2TKWLFnCpk2bGDRoULPbOjk54dRIv2itVmuVD8zWel5bUlldSf9k5cOC99hJ3e841CTSc3/5jguDmh6Ua8TI+aLz7EzfydjosY1sYIQnnwRANX06WjvrNS+/C7ZBjoNtsJXjMFjnw/shakadN6D734e4XH55/Q26cI9/WzkGJlllyuD1MK+wJuNaOG4hHx/+mIOZB/ni+BdMH2yeeTEJ6Qn877Byonf55OU4OjoqK9qQJP748McsnrAYZ4cWBjBfor3H4cdTP7Lj/A6cHZw5/rfjnMo/ZZV5Bub+GSorK+OLL77ggw8+YMeOHQwfPrxegYjoGooqdFwoKAegT3DnFfpcbFL/YP7x/XF2J+eRW1KJn3vT83ZMg0aj/Vw7rWpeCCGEEMISzFeKZGGOjo7Ex8ezefPm2mUGg4HNmzczatSoJh/38ssv8+KLL7JhwwaGDx/eGaEKMzt3ci8985T7Plc1XmXXpdX8fLvtPdiqzU19chv44gtlaKmrK7z0krmiE0J0VykpaPsN4OE9St93lx17ID6+/i0uDlJSrBxo12cwGsguzQYgyD2oye38Xf15ZswzADzz8zOU68o7/NxGo5EnflL6m/9x4B8ZHnrRe62332758c7OOAaFkFeex5pjazocT2sYjUae++U5AP522d8I9wpnbPRY7h54N2Ojx9rlUOCdO3fyl7/8hZCQEJYvX86OHTv45Zdf2LlzJ0/WnEQXXUdSRjEAwZ7OeLla54RehK8rA8I8MRhh47HMZrdNzlYKYqStixBCCCHsnd0k0gHmzJnDe++9x0cffcTx48d5+OGHKS0tZcaMGQBMnz693jBSU6/IDz74gOjoaDIyMsjIyKCkpKSppxA2KO/XDQCcDXJC5eNj5WisoKbC0yMlE//SljcP8WhkyFR5Ocydq9yfOxdCQ80YoBCiW8rJgYqK5repqFC2ExaVW5aL3qgMHQxwDWh228dGPkakVyTni86zYueKDj/3d0nfseXsFpw0Tvzzmn/Wrdi0Cf7v/5T7H30E+/bV3W69VVk+dCiqEye4/tqHAfj3vn93OJ7W+P7k9+xJ24Or1pWnrnyqU57TUl599VX69+/Pbbfdho+PD7/99huHDx9GpVLh141mFnQ3iZlKIj0u2MOqcVxXM9h0w9GMZrerGzTqbvGYhBBCCCEsya4S6XfeeSfLli1jwYIFDBkyhAMHDrBhw4baAaQpKSn1ekC+8847VFVVcdtttxESElJ7W7ZsmbW+BdEOhl07ADjXt5smf318oG9fAG7I80NF45fEqlAR4RnBmMgxDVe+9ppSFRoeDn//uyWjFUII0ckyS5VqUF8XX7Sa5qtTnR2cWXztYgAWb1tMVmlWu59Xp9fx5Eal2nn25bOJ8o5SVlRUwCOPKPdnzoTp02HYsLrbihXg5KT0UE9K4v5h96NRadiWso2jWUfbHU9rGI1GFvyyAIBHRzxKoFugRZ/P0ubOncvUqVM5d+4cr7zyCoMHm3eIrLBNiTUV6X2snEif1F9pr/n7qRwKy3VNbmdq7RIrFelCCCGEsHN2lUgHmDlzJufOnaOyspJdu3Yx8qI+z1u2bOHDDz+s/frs2bMYjcYGt+eff77zAxft5nXgBADFQ/paORIrqmnvMk91FUCDZLrp6xWTVzS8JD0jAxYrSROWLFFauwghhOgyTMnwILem27pc7K4BdxEfEk9xVTGLtixq9/O+n/A+ibmJ+Lv6M2/0vLoVixfDyZMQEgL/+EfDB4aHw0MPKfefe45Q9xBuirsJsHxV+jeJ37A/Yz/uju78/Qr7P7H84osv8uWXXxITE8PcuXM5cuSItUMSneBEhm1UpPcMdKdnoDs6vZFfTjR9Uq62Ij1AEulCCCGEsG92l0gX3YzBQGSicrmo5vIrrByMFdUk0uNO5rHmjjWEeYbVWx3uGc6aO9Ywre+0ho999lkoKYERI+DuuzsjWiGEEJ0os0SpSG+uP/rF1Co1yyYqV+f9e9+/OZFzos3PWVRZxMItCwF4/urn8XL2UlacOFF38vZf/wIvr8Z3MG8euLjArl3w/ff8Nf6vAHx88GPKdGVtjqc1DEZDbcyzRs7C39XfIs/TmebPn09SUhL//e9/ycjIYOTIkQwePBij0Uh+fr61wxMWYDQaayvSrZ1IB7hugFKVvuFI4+1dKnT62sGo0iNdCCGEEPZOEunCtiUl4VGup9wBAi+/1trRWM8VNScR9uxhWq+bODvrLL/c+wufTvuUX+79heRZyY0n0Q8cgA8+UO6/9hqo5VdeCCG6GlNrl9ZWpAOMjR7LTXE3oTfqmbdpXssPuMSSbUvILssmzi+OB+MfVBYajUqluU4HU6bU9UJvTHAwPPqocn/BAibEjifGO4bCykJWH13d5nhaY+3xtRzKPISnkydzRs2xyHNYy9VXX81HH31ERkYGjzzyCPHx8Vx99dVcccUVLF++3NrhCTPKLKqksFyHRq2iZ6D1e46b2rtsScqirKq6wfqUvDKMRvBwdsDPzbGzwxNCCCGEMCvJqgmbVr5tCwB7Q6FnUDdu7dKnD3h7Q1kZHDqERq1hbPRY7h54N2OjxzZs5wJKQmPOHOXfO++sS8YLIYToUkwV6W3t9710/FI0Kg3fJH7Dr2d/bfXjUgpTeG3nawC8POHlur7sH30Ev/6qVJq/9RaoGp/pUevJJ8HdHfbvR/31Nzww7AEAVu5d2abvozX0Bn1tNfqcy+fg6+Jr9uewBR4eHvz1r39l165d7N+/nxEjRrBkyRJrhyXM6ERGEaBUdzs5NPL+r5P1D/Uk3MeFCp2B35KyG6w/k13XH13V0t8EIYQQQggbJ4l0YdOKt24G4Ei0a91l492RWg2meQDbt7fuMd9+C7/8ogx0W7rUcrEJIbolvUFv1u1E+7WnIh2gj3+f2mryv2/8OwajoVWPe+bnZ6iormBs9Fhu7H2jsjAnp26Y9fPPQ3R0yzvy94fHH1fuL1jAfYPuxUHtwK4LuziYcbBN30tLVh9dzbHsY3g7e/P45Y+bdd+2auDAgaxYsYILFy5YOxRhRrbU1gVApVI1296ltj+6tHURQgghRBcgiXRh0xx27wUgvX+klSOxATV90tmxo+Vtq6rqEhpz5kBUlOXiEkJ0S7srz1Du0Pw25Q7KdsKyaoeNtrJH+sWeH/s8Ho4e7E3by+dHPm9x+71pe/nfof8BsGzCsroK0yefhNxcGDgQZs9ufQBPPKFccXX0KEHrf+WWPrcA5h06Wm2o5vlfnwfg76P+3u1OzGu1WmuHIMzIlEjvE2QbiXSAyTWJ9M3Hs6isrn/yNDmnBIAYf+u3oRFCCCGE6ChJpAvbVVaGd9I5ACriB1s5GBtgas3SmkT6m2/CqVMQFATz51s2LiFEt3TW00DcTBj2oHLbFK0sX3JF3bK4mcp2wsJSUhiaBr3PlkBCQsNbSkqTDw10C2TeaKVH+tObn6aiuqLJbY1GI3//STlJ+6dBfyI+NF5ZsWULfPih0srl3/+GtiRuvb2VZDrA88/z0OC/APC/Q/+jpKqk9ftpxmeHPyMpNwlfF18eG/mYWfYphLWcqEmk97aRinSAoRE+BHo4UVxZzfbTufXW1VakB0hFuhBCCCHsnyTShe1KSEBtMJLmDv5xQ60djfWNHKkkKZKTIaPhpbO1cnLghReU+//8J3jYzgctIUTXEeIRQqo37A9Vbkn+yvIqh7plqd7KdsKCUlJY89xhEt6Fq26dDfHxDW9xcc0m0x+//HHCPcM5V3iON3a90eR265LW8eu5X3F2cOYf1/xDWVhZqQwYBXjwwbqrp9pi1izw84OkJMZuv0Av314UVxXz2eHP2r6vS1Qbqln06yIAnrriKTyc5P9EYb+q9QZOZSsnmPrYUCJdrVbVDh3dcLj+e1RTIj1WWrsIIYQQoguQRLqwXbt2Kf+EQ2//OCsHYwM8PaF/f+V+c1Xpzz8PhYUwZAj8+c+dEJgQojsaEzmGcM9wVCitPTJrrtoPVHImqFAR4RnBmMgxVoqwezBmZ+Nc3cJGFRXKSdYmuGpd+cc4JTH+z63/JKes4bY6vY4nNz4JwOzLZxPpVdNy7eWXITFRuQJq8eJ2fQ94eMDcuQCoX3iRhwbfD5invcvHBz/mdP5pAlwDmDliZv2VKSmNV/C3opJfCGs4m1tKVbUBV0cNET6u1g6nHlN7l43HM6nWK1ciFZbryCmpAiBaEulCCCGE6AJa6G7aOL1ez4cffsjmzZvJysrCYKh/2fbPP/9sluBE92bcuRMVsCsMpvv1tnY4tmHUKDhyREmk33JLw/XHjsHKlcr95ctBo+nc+IQQ3YZGreH1ya9z2+rbUKEiy80IQFAptcn1FZNXoFHL3yFLKqkqwRx1qfcMuocVu1ZwIOMAL/76Iq9f93q99e/ue5ek3CQCXANqW8Fw8qRy5RPAa6+Bj0/7A/jb3+DVVyE5mQcOaZmvcWRf+j72pu1leOjwdu2ySl/Fi7+9CMC80fNwc7wokZeSolTqVzTdygZnZ+UkQaR9zGkxGAycOnWq0ffmV111lZWiEuZkauvSK8gDtVpl5WjqGxHji7erlrzSKvaczWdUDz/O1lSjB3o44e7Uro+dQgghhBA2pV0V6bNmzWLWrFno9XoGDBjA4MGD692EMAfDTqXqelc49PDpYeVobERLfdL//nfQ6+Hmm2HcuM6LSwjRLU3rO401d6whzDOMrJocZWAphHuGs+aONUzrO826AXYDuWW5LW/UChq1hmUTlgHw9t63OZl7snZdYUVh7bDORWMX4enkCUYjPPyw0tpl4kS4666OBeDqWjvTw2Ppa9zds2bo6N72V6V/eOBDzhacJdg9mIeGP1R/ZU5O80l0aLGS35bs3LmTnj170rdvX6666irGjh1bexsn7we6DFscNGqi1aiZ0FcZeLzhSDpwUX90qUYXQgghRBfRrtKAzz//nNWrVzNlyhRzxyOEIi0NzfkL6FWQ3S8KJwcna0dkG0y9Z/fuhaoqcHSsW/fjj/DDD8qQt1desU58QohuZ1rfadwcdzOzsuKBg/TWe5E8K1kq0TtJXkUe0Wba17Wx1zKl1xTWn1zPvE3zeHTko6QXp7MuaR05ZTn08e/DA/EPKBt/8gls3qxUbb/9tjLDo6P++lfl/6/z53k2MYiPgM+OfMark15VkvdtUFldyT9+U9rVzB89H1etbbXBMLeHHnqI4cOH8/333xMSEoLKHMdD2BxTIj3OhvqjX2zygGC+3HeeH49msvDG/pwx9UeXQaNCCCGE6CLaVZHu6OhIz549zR2LEHVq+qMfDYDw0D5WDsaG9O4Nvr5KldyBA3XLq6thzhzl/syZ0KuXVcITQnRPGrUG/5h+AHgUVkgSvRPlleeZdX8vj38ZFSrWnljLuI/G8Ye1f+CzI8rQz1v63IKD2gHy8ur+z3nuOehhpqvGnJ3h2WcB6LFyNUM94yjVlfLJoU/avKtV+1eRWpRKqEcoD8Y/aJ74bNjJkyd56aWX6Nu3L97e3nh5edW7ia4hMbOmIt1GE+lX9vTHzVFDRlEFB88XSEW6EEIIIbqcdiXSn3jiCV5//XWMRqO54xFCcfGgUemPXkelgssvV+5f3N7lvfeU/uh+fkpSQwghOplzqNJH2rm0suWWGcJscstamUgvLGzVZom5iRhp/P3dkm1LWHt8rTIYNDsb+vVTWoqZ0333QXQ0qowMViQrg8ZX7lvZpvecFdUV/HOr0rv9mTHP4OzgbN4YbdDIkSM5deqUtcMQFlRWVU1KXhlguxXpzloN19S2d8kgOacEgBh/d2uGJYQQQghhNu1q7bJt2zZ++eUXfvjhB/r3749Wq623fu3atWYJTnRjNYn0neEwVBLp9V1xBaxfryTSZ82CggJYsEBZt2hRx4a9CSFEO3kFRlKpASc9kJVlNwMa7V1eeSt7pN92mzKM+rbbmmzDojfombVhVrO7+eTth5n2fpbyxcqV9VuMmYOjo/J/2n33Mfqz3/F/2IlDmYfYdWEXl4df3qpd/Hvvv0krTiPSK5L7h97f+EbV1WYM2voeffRRnnjiCTIyMhg4cGCD9+aDBg2yUmTCXJIySzAawd/dCT932215OLl/MOsOpvF/+y9QWFYFQKRv126tJIQQQojuo10V6d7e3txyyy1cffXV+Pv7y+Wjwrz0etizB4BdYVKRXk9KilJ1DrBlCyQkwGOPKcPQoqPhuuusGZ0QohsLdA+qHThKVpZVY+lOzmnLqG6pHbZKpbRjueMOmDYN0tIa3WxrylbOF51vcjcO1UZe+KLm2N5/P4wZ086oW/CnP0GvXqhzcnn7jNIy6N/7Wjd0tExXxuJtiwF4dsyzjc9YKSszfyW9ld16660cP36c++67j8suu4whQ4YwdOjQ2n/b6q233iI6OhpnZ2dGjhzJ7t27m9x27NixqFSqBrfrr7++dhuj0ciCBQsICQnBxcWF8ePHc/LkySb3KRpKzCgCbLeti4lObwAgq7iSSr1yJcm9H+yuHUAqhBBCCGHP2lWR/p///MfccQhR5+hRKC2l2BGOB0givVZKCsTF1bVMyMyE+Pi69WfPQv/+kJgolaBCiE4X6BZIlhtEFKH8fRKdIs1QQKUGHKqBN95Qrlq6lIcH/Pe/sHgxfP01/PILLFumJMMvqk5PL24+0fXEDuifDRU+nji//LJ5v5GLOTjAwoVwzz3csu4UXg/D50c+Z/nE5fi4NH/V1Tt73iGzNJMY7xj+POTPDTfIz4ebboJt2ywTu5UkJyebbV9ffPEFc+bMYeXKlYwcOZIVK1YwadIkEhMTCQwMbLD92rVrqaqqqv06NzeXwYMHc/vtt9cue/nll/nXv/7FRx99RExMDM899xyTJk3i2LFjODt3/dY75nDCxgeNAmw4ks7sLw40WJ5ZVMHD/0vgnXuGMXlASOcHJoQQQghhJu2qSDfJzs5m27ZtbNu2jezsbHPFJLq7mrYue0JBq3UiwjPCygHZiJyclvsOV1Qo2wkhRCczJdIBqUjvRFd/ewi3aijoGwN/+xsMG9bw1qsXvPCCchXTZZcp/dIfeACuvRYu6qsd4tF0gis2Dxb8qtxPfvZvyuBrS7rrLujXD4eiYpYcDqSiuoL/Hvpvsw8pqSph6e9LAXjuqufQauq3NyEtDa6+Wkmie3i03JbG2Rn8/TvyXXSaqKioZm9tsXz5ch544AFmzJhBv379WLlyJa6urnzwwQeNbu/r60twcHDtbePGjbi6utYm0o1GIytWrODZZ5/l5ptvZtCgQXz88cekpaXx9ddfd/Rb7zYSbTyRrjcYWbTuWKMTFkzLFq07ht4gM7aEEEIIYb/aVZFeWlrKo48+yscff4zBoFy+p9FomD59Om+88QaurtIHT3TARf3Re/r2RKPWWDkgIYQQLQl0C2RnTSK9OiOtfW8wRNuUlHDrZqVNS8bMP+PdRO/zWgMHKvM1/vUveOYZpTJ94EB48UV4/HHGRI4h3DOcC0UX6g8cNcJb34NLNfzey4nLZ71gwW+qhkajzP24/Xbu21LEMwOU9i6PjngUVRPf51u73yK7LJuevj350+A/1V958iRMnKhcvRUcDD/+CN7ezZ989ve3qyu8Tp8+zYoVKzh+/DgA/fr1Y9asWfTo0aPV+6iqqmLfvn3Mnz+/dplarWb8+PHsuHjIeTNWrVrFXXfdhZub8gchOTmZjIwMxo8fX7uNl5cXI0eOZMeOHdx1112N7qeyspLKysrar4uKlNYmOp0OnU7X6u+po0zP1ZnP2ZgTNa1devi5WD2WxuxKziO9sOmCDyOQXljBjlNZjIxp+4k4WzkO3Z0cB+uTY2Ab5DjYBjkO1tdVjkFb4m/X59w5c+bw66+/sm7dOq688kpAGUD62GOP8cQTT/DOO++0Z7dCKGoS6bvCpa2LEELYC29nb7LdVYCR8rRz2GbNZBfz7rt4lxlI8gWH2+9s3WM0Gpg9G26+GR58EDZvhiefhM8/R7NqFe8OepZnVz8E1FWRTjwFk09DlRr0zzyNRtNJp0mmTYPBg3E8eJD5Ox140vUY21K2MSaqYW/2osoiXt6utJtZePVCHNQXxZiQAJMnQ3Y29OwJP/0EMTHKOjtKlDfnxx9/5KabbmLIkCG1781///13+vfvz7p165gwYUKr9pOTk4NerycoKKje8qCgIE6cONHi43fv3s2RI0dYtWpV7bKMjIzafVy6T9O6xixevJhFixY1WP7TTz9ZpWhn48aNnf6cJkVVkFfqgAojZ/b/zvlDVgulSftyVEDLxS8/bd1F7vH2V6Vb8ziIOnIcrE+OgW2Q42Ab5DhYn70fg7KyslZv265PQl999RVr1qxh7NixtcumTJmCi4sLd9xxhyTSRfsVFSk90lEGjf5ZEulCCGEXVCoVZT4eQBG6tKYHVgozqazE8Ooy1MDS0fCaZxv7DsfGwsaN8OGHMGcO7NsH8fFcB1ynb/whjga46qHFMO7PnZOAVquVavmbbuLRXfDKCKUqvbFE+r92/Yu88jzi/OK4e8DddSt+/hmmToXiYhg6FH74AS5J6HYF8+bNY/bs2SxZsqTB8rlz57Y6kd5Rq1atYuDAgYwYMaLD+5o/fz5z5syp/bqoqIiIiAgmTpyIp6dnh/ffWjqdjo0bNzJhwgS0Wm3LD7CA30/nwr59RPq6MfXG0VaJoSV+yXl8fHJvi9tNHDOy3RXp1j4OQo6DLZBjYBvkONgGOQ7W11WOgenKx9ZoVyK9rKysQVUJQGBgYJuy+KJxeoOeX8/9ym/5v+F2zo1xseO6T3uTvXvBaCTTz5lMjwqpSBdCCDui8/cGijBkNl1lKszk449Rp6Vz3gO+HObE+47tuAZApYIZM5Rq7Ucfha++avkxplkcnVXJfcMNMGIETrt3M3cbPO21hhWTV+Cl9ardpKCigFd3vArA82Ofr3vP9NVX8Ic/QFUVjBunDFrtxARsZzp+/DirV69usPy+++5jxYoVrd6Pv78/Go2GzEsGBmdmZhIcHNzsY0tLS/n888954YX6rX9Mj8vMzCQkpO6ET2ZmJkOGDGlyf05OTjg5OTVYrtVqrfJBzVrPC3AqW/l81SfEw2Y/pI7qGUiIlzMZhRWN9klXAcFezozqGYhG3UIbqmZY8ziIOnIcrE+OgW2Q42Ab5DhYn70fg7bE3q5ho6NGjWLhwoVUXDT4sLy8nEWLFjFq1Kj27FLUWHt8LdGvRzPhkwksP7ecCZ9MIPr1aNYeX2vt0DqHadBohPKjGecXZ81ohBBCtIE+QBnMqM6WoccWpdfDy0obk1evAF+v4Cb7hrdKSAisWQOvvGKmAM1IpVIGpQKP7FPhm1/JRwc+qrfJip0rKKgooH9Af27vpwy45N//httvV5Lo06bB+vVdNokOEBAQwIEDBxosP3DgAIGBga3ej6OjI/Hx8WzevLl2mcFgYPPmzS2+x//yyy+prKzknnvuqbc8JiaG4ODgevssKipi165d8rmhleoGjdruz7BGrWLhjf0AJWl+MdPXC2/s16EkuhBCCCGEtbWrIv31119n0qRJhIeHM3jwYAAOHjyIs7MzP/74o1kD7E7WHl/Lbatvqz/gC7hQdIHbVt/GmjvWMK3vNCtF10lqEum/BCqVN1KRLoQQ9kMdpFSeOuYWWDeQrm7NGjh1iiovD94bVkx/dzO1KrnmGvPsx9wmToTRo3Heto2nt8IbMe/y6PBHAcgrz+O1na8BNdXoqpp2MAsWKI998EF4+22lN3wX9sADD/Dggw9y5swZrrjiCkDpkb506dJ67VFaY86cOdx7770MHz6cESNGsGLFCkpLS5kxYwYA06dPJywsjMWLF9d73KpVq5g6dSp+fn71lqtUKh5//HH+8Y9/0KtXL2JiYnjuuecIDQ1l6tSp7f+mu5GkTCWR3ifYtqdPTB4Qwjv3DGPRumP1Bo8Gezmz8MZ+TB7QxhZUQgghhBA2pl2J9AEDBnDy5Ek++eST2sFDd999N3/84x9xcXExa4Ddhd6gZ9aGWQ2S6ABGjKhQ8fiGx7k57uau2+bFaISdOwHYGa4MrvN39bdyUDbE3x+cnZXL6pvi7KxsJ4QQVuAYEg6AS34JGAxKj2thXkYj1CQwD915NaVO3xHk1vV6ftejUinJ8XHjeDABXrkyiX/t/hfp+el88dMXFFUWMThoMNPipsJjj8GbbyqPe/ZZpZq9I9X6duK5557Dw8ODV199lfnz5wMQGhrK888/z2OPPdamfd15551kZ2ezYMECMjIyGDJkCBs2bKht65iSkoL6kt/txMREtm3bxk8//dToPp966ilKS0t58MEHKSgoYPTo0WzYsAFnZ+d2fLfdi8FgJCmzBIA4G0+kg5JMn9AvmN3JeWQVVxDo4cyIGF+pRBdCCCFEl9CuRDqAq6srDzzwgDlj6da2pmxFlXKeoU22mDeSU5DK1pStjI0e24mRdaKUFMjMxOCgISFEzyC/3h27VL2riYyExESlN21T/P07r2+tEEJcwjU0CgCNwQj5+XBJZaowgw0b4OBBcHPjlxsGQMJ3BLq1vnWH3Ro7Fq65Bseff+bZ3+BB7yfrrb4+agLqe/4En3+uLPjXv5S+792ESqVi9uzZzJ49m+JipXrZw6P9SdeZM2cyc+bMRtdt2bKlwbK4uDiMxsY6Y9fF98ILLzTony5alpJXRrlOj5ODmmg/N4s9j96gJyErgeyybAJcAxgWOKzdxTsatYpRPbrH339zvm5CCCGEsH2tTqR/++23XHfddWi1Wr799ttmt73ppps6HFh3U5h0mMQ3waW66W3KHeCn6w5DV02k17R1yewRTIX2grR1aUxkpCTKhRA2y987lDxn8K0AsrIkkW4JpnYaDz3EOY2SMO3yFek1dtwcz6iff2ZGAnzXC1Jr5o266OD695fBecDBAT7+GO6+26qxWlNHEujC9pyo6Y/eK8jdYlXdm85tYsnuJWSW1Q2ZDXINYt6IeYyPGm+R5+wK5HUTQgghup9WJ9KnTp1KRkYGgYGBzfYzVKlU6PV6c8TWrYRVOTWbRAclyR5W5dQ5AVlDTSL9eKzyAbC3ryTShRDCngS6BZLlVpNIz8yEvn2tHVLXsm0bbN0Kjo4wZw6Zv88CIMhcPdJtmP5sMkOfUIahOgDffNFwGyNgeP89NN0kiT5s2DA2b96Mj48PQ4cObfYqvoSEhE6MTJhT7aDRIMsMGt10bhNztsxp0F4yqyyLOVvmsHzsckkKN0JeNyGEEKJ7anUi3WAwNHpfmMfQ4KFm3c4u1fRH3x6qnIiRinQhhLAvpkR6n1yUinRhXqZq9HvvhdBQskqV19hsFek2PItj/5GNDG+h4EAF7PerYninRGR9N998M05OTrX3pR1e15SYWQRYZtCo3qBnye4lzc5oWrp7KeMixkm7kovI6yaEEEJ0X+3qkf7xxx9z55131r55N6mqquLzzz9n+vTpZgmuO2ntm6wu+2ZMp4OaaqnvfZQe4JJIF0II+xLoFsgud+W+MTMTSeuZ0cGDsH69MsD1qacAyCxR2gmYrSLdhmdx5JQ2E1M7tusKFi5cWHv/+eeft14gwqJMrV0sMWg0ISuhXluSSxkxklGWQUJWApcFX2b257dX8roJIYQQ3Ze6PQ+aMWMGhYWFDZYXFxczY8aMDgcluqFDh6CiAoOPN7tc8wHo5dfLykEJIYRoiwDXALJqZuFVpqdaN5iuZskS5d/bb4eePQHILK1JpJuzR3pkJAwb1vTNSnM6/N1aVwXf2u26mtjYWHJzcxssLygoIDY21goRCXOo0Ok5m1MKWKYiPbss26zbdRfyugkhhBDdV7sS6UajsdHLR8+fP4+Xl1eHgxLdUE1/9KJBfTCqIdQjFHdHdysHJYQQoi1ctC4UejoCUHkhxcrRdCGnTsHq1cr9efMAqKyupKCiAFCuBOjqpAVe886ePdvojKLKykrOnz9vhYiEOZzKKsFgBG9XLQEe5p+TFOAaYNbtugt53YQQQojuq02tXUyDjFQqFddeey0ODnUP1+v1JCcnM3nyZLMHKbqBmv7oKX2CAWnrIoQQ9qrC1xPIoTozzdqhdB2vvAIGA1x3HQwZAlDbH91B7YCPi48Vg+sc3b4FXhO+/fbb2vs//vhjvYIWvV7P5s2biYmJsUZowgxq27oEeVikB/6wwGEEuQaRVZbVaL9vFSqCXIMYFjjM7M9tz+R1E0IIIbqvNiXSp06dCsCBAweYNGkS7u51FcOOjo5ER0dz6623mjVA0U3UVKQfjHKGKujtK4l0IYSwRzp/XyBHho2aS1oafPihcv/pp2sXmxLpgW6BqFXtusBQdAGm9+YqlYp777233jqtVkt0dDSvvvqqFSIT5pCYYblBo6CceJo3Yh5ztsxpsE5VM+Vi7oi53e4EVUtMr9vsLbMbrJPXTQghhOja2pRINw01io6O5s4778TZ2dkiQXVL/v7g7AwVFU1v4+ysbNfV5OdDUhIAvwZXQIpUpAshhN0KDASScMjOs3YkXcPy5VBVBaNHK7caFumPLuyOwWAAICYmhj179uDfFd8ndmN1g0Y9LfYc46PG8/JVL/Pkb0/WWx7kGsTcEXMZHzXeYs9tz8ZHjecvA/7C+0fer7dcXjchhBCia2tTIt3k0ooXYQaRkZCYCDk5AOiOHkU7fTp5znDss9cZHTlaSaJbaciX2aWk1H6vbN+u/BseTtmp4wzNgcGVXf8ydSGE6IocgkMBcM4rsnIkXUBeHqxcqdyfP7/eqsySmkS6ezdJpHfngoNWSE5OtnYIwgKSMk2JdMtUpJvEetcfSOumdeOHaT/goGnXR8VuQ48yl6CXdy9OFpxEq9ayftp6tBqtlSMTQgghhKW0692RXq/ntddeY/Xq1aSkpFBVVVVvfV6eVKG1S2RkXaK85l/fCkjyg9HDulCPvZQUiItr+GH4/Hk+fUm5a/joYUga33VOHAghRDfhHKr83XYqq4TycnBxsXJEduzNN6G0FAYPVvqjX8RUkd4dBo0CDQsOqqv5fds2rhw9Gq1pZk9XKjhoh9LSUn799ddG35s/9thjVopKtFdBWRWZRZWA5RPpZwrPANDHtw8n809SqislrzKPQNdu8velnfZl7gPgT/3+xIs7X0Rn0JFZlkm4R7iVIxNCCCGEpbQrkb5o0SLef/99nnjiCZ599lmeeeYZzp49y9dff82CBQvMHWP35OVFkasWzzIdpUlHYYy1AzKjnJzmK8oAdWWVsl03/kAshBD2yDMwgkoNOOmB7Gz5O95epaXwr38p9+fNg0sGDdZWpHen1i4XFxzodBSmp8PQoaCV6s/9+/czZcoUysrKKC0txdfXl5ycHFxdXQkMDJREuh0ytXUJ93HB3cmyleHJBcoVDX18+1CpryS5MJmT+Sclkd6MMl0Zx3KOATAiZARRnlGcKjjFmcIzkkgXQgghurB2Taf65JNPeO+993jiiSdwcHDg7rvv5v3332fBggXs3LnT3DF2Wzn+SvWJ4cwpK0cihBBCtE6gexBZbjVfZGZaNRa79t57kJsLPXrAbbc1WC090sXFZs+ezY033kh+fj4uLi7s3LmTc+fOER8fz7Jly6wdnmiHxJpEuqUGjV7MVJEe6xVLL+9eAJzMP2nx57Vnh3IOUW2sJtgtmFC3UGK9lPY4yYXSZkkIIYToytqVSM/IyGDgwIEAuLu7U1hYCMANN9zA999/b77ourmiQF8AHM6lWjkSIYQQonUC3QLrEulZWVaNxW5VVcGrryr3n3oKHBpWo2aVKq9tt+mRLpp14MABnnjiCdRqNRqNhsrKSiIiInj55Zd5+umnrR2eaIe6QaOdnEj3qUmkF0givTkJmQkADAschkqlqu0zb3othRBCCNE1tSuRHh4eTnp6OgA9evTgp59+AmDPnj04OTmZL7puriwwGAD3CzlWjkQIIYRonUC3QDIlkd4x//sfnD8PISHQxIB3qUgXF9NqtajVytv6wMBAUlJSAPDy8iI1VQoy7FFihjKwOS7Y06LPozfoOVt4FrgkkS4V6c0y9UePD4oHqK1IP1MgiXQhhBCiK2tXw71bbrmFzZs3M3LkSB599FHuueceVq1aRUpKCrNnzzZ3jN1WdYjSX88vowij0Yjqkv6oQgghhK0JdAtkT00iXZ+Zgca64dgfvR6WLFHuP/EENFGgUNsjXSrSBTB06FD27NlDr169uPrqq1mwYAE5OTn897//ZcCAAdYOT7SR0WgkKbMEsHxrlwslF6gyVOGkcSLUPbR2+emC01QbqnFQW7Y/uz3S6XUczD4IwPCg4UBdIv104Wn53CaEEEJ0Ye16Z7TE9AEPuPPOO4mMjGTHjh306tWLG2+80WzBdXfG0BgAIvP0FFQU4OPiY+WIhBBCiOb5uviS7a7cLz9/FnfrhmN/1q6FkyfBxwcefLDRTaoN1eSUKVerBbrJMEABL730EsXFSiuQf/7zn0yfPp2HH36YXr16sWrVKitHJ9rqfH45JZXVaDUqYvzdWn5AB5hakUR7RqNRawjzCMPFwYXy6nJSilNqE8SiztHco1TqK/Fx8iHGS/m8FuUZhVqlpriqmNyKXPxd/K0cpRBCCCEswSwlBqNGjWLUqFHm2JW4iC5YqUiPzYczhSmSSBdCCGHzNGoNpd7uQAm69PPWDse+GI2weLFy/9FHwaPxStScshyMGFGhwt9VkjUChg8fXns/MDCQDRs2WDEa0VGmQaM9AtzRatrVibPVLu6PDqBWqenh1YMjuUc4lX9KEumNMLV1GRY0rLby3NnBmTD3MFKLUzlTcEYS6UIIIUQX1epE+rffftvqnd50003tCkbUVx4YiEEF7jrIOncMggdbOyTz8PcHZ2eoqGh6G2dnZTshhBB2p9LfCyjBkJlh7VDsy08/wf794OoKjz3W5GamQaP+rv7SdkEAkJycTHV1Nb169aq3/OTJk2i1WqKjo60TmGiXxMxOHDRa09M7xjumdlkvn14cyT3CyYKTTGSixWOwN5f2RzeJ9YpVEumFZxgRMsIaoQkhhBDCwlr96Wvq1Kmt2k6lUqHX69sbj7iIQaslz9sZ//wKik4chJF3Wzsk84iMhMREyMiAK64AvZ7d7z3PQ3uep5dfT7647QsliR4Zae1IhRBCtIMxIAC4gDpbhmW3iaka/cEHwc+vyc2kP7q41J///Gfuu+++Bon0Xbt28f7777NlyxbrBCba5URG5yXSkwuTAepVnsvA0abpDXr2Z+0HGk+k/3r+19oqfyGEEEJ0Pa2+VtBgMLTqJkl088oP8QZAdyrJuoGYW2QkBAYqQ9UcHdnR14P9oWAYOgSGDZMkuhBC2DFVoJLgdczNt3IkdmTHDvj1V9BqlSGjzcgsrUmku0kiXSj279/PlVde2WD55ZdfzoEDBzo/INEhiRlFgOUHjRqNxgatXUAS6c1Jyk+iRFeCm9aNOJ+4eutM/dIlkS6EEEJ0XR1uulfRXHsO0WHlEcEAqM+es3IkFnCX1A0uAADmAklEQVSm5k1mTAyJBacA6O3b24oBCSGEMAfHEGXGh3N+CRgMVo7GTpiq0adPh/DwZjc1VaTLoFFholKpaoeNXqywsFCKXOxMVbWBM9mlAMQFe1r0ubLKsijRlaBRaYjyjKpd3stbSaSnFqdSpiuzaAz2JiErAYAhgUPQqDX11sV6KycjTO1yhBBCCNH1tCuRrtfrefHFFwkLC8Pd3Z0zNQnR5557jlWrVpk1wO5OH6VUZrumdsE+s6dPK//GxpKUq1Tc9/aTRLoQQtg7l1Dl/y6NwQj5UpXeQEoKJCTU3b74AtatU9Zdf72yvhlSkS4uddVVV7F48eJ6SXO9Xs/ixYsZPXq0FSMTbXUmp4RqgxEPZwdCvZwt+1w1ldMRHhE4ahxrl/u5+OHr7IsRo1RXX8LUH3140PAG60xV/dnl2RRXNTyxJYQQQgj7165E+j//+U8+/PBDXn75ZRwd6950DRgwgPfff99swQlw7KFcMuidUWDdQCzBVJEuiXQhhOhS/L1DyTPlfzIzrRqLzUlJgbg4iI+vu911V936adOU9c0k02sT6dIjXdRYunQpP//8M3FxccyYMYMZM2YQFxfHb7/9xiuvvGLt8EQbJJr6owd5oFKpLPpcpiS5qSXJxaS9S0NGo7HJQaMAHo4eBLooVwrJCQghhBCia2pXIv3jjz/m3Xff5Y9//CMaTd0lbYMHD+bEiRNmC06AW++BAARnl2M0Gq0cjZnVJNKroiNILUoFJJEuhBBdQaBbIFluNV9kZVk1FpuTkwMttcWrqFC2a0JWqfKaSkW6MOnXrx+HDh3ijjvuICsri+LiYqZPn86JEycYMGCAtcMTbWDtQaMmpvYuSfldbE5TByQXJZNXkYeTxon+fv0b3SbGu6ZPurR3EUIIIbokh/Y86MKFC/Ts2bPBcoPBgE6n63BQoo5/f+WywYgCI/mlOfi6B1g5IjOqae1ywd8JSsHXxRc/Vz8rByWEEKKjAt0CyXSHPrlIIt0CTD3SpSJdXCw0NJSXXnrJ2mGIDjJVpFt60CjUVU2bentfrLePUtxyskAq0k0SMpX+6AP9B9ZrhXOxWK9YdqXvqj1JIYQQQoiupV2J9H79+rF161aioqLqLV+zZg1Dhw41S2BC4RQRQ6UGnPSQcWIfvsMnWzsk86mpSE/yUvp5SjW6EEJ0DYFugeyTinSLkR7pAuDQoUMMGDAAtVrNoUOHmt120KBBnRSV6Kja1i4WHjQKdVXTjVakS2uXBppr62Jiei2ltYsQQgjRNbUrkb5gwQLuvfdeLly4gMFgYO3atSQmJvLxxx/z3XffmTvG7k2jIcPPiaisSgqP74eukkjPz68dQHfQtQiAOL84a0YkhBDCTC5u7VKVlkrjdXuiPQxGQ21rl0C3QCtHI6xpyJAhZGRkEBgYyJAhQ1CpVI22AVSpVPWGkArbVVSh40JBOaD0SLekwspCcitygcZ7pMd6xaJCRV5FHrnlufi5yFWjbUmkny443SkxCSGEEKJztatH+s0338y6devYtGkTbm5uLFiwgOPHj7Nu3TomTJhg7hjreeutt4iOjsbZ2ZmRI0eye/fuJrc9evQot956K9HR0ahUKlasWGHR2CwlN0ipSKk4edzKkZhRTTW6MSiIzdk7AXBQO6A3yAc9IYSwd25aN/I9lHP1FWlND80UbZdfnk+1oRqQRHp3l5ycTEBAQO39M2fOkJyc3OB25oxUxtqLpJpq9BAvZ7xctRZ9LlPFdLBbMG5atwbrXbWuhHuEA9LeBSCtJI300nQcVA4MDhjc5HamNjkXSi5QUd3CPAwhhBBC2J02J9Krq6t54YUXiImJYePGjWRlZVFWVsa2bduYOHGiJWKs9cUXXzBnzhwWLlxIQkICgwcPZtKkSWQ1cdl4WVkZsbGxLFmyhODgYIvGZkmlYTV90ZO7UK+9mg91+1zy+en0TwCs2r+K6NejWXt8rTUjE0II0UEqlYpyX+UkcHVGmpWj6VpM1ejezt44OThZORphTbfccgsFBQUAfPTRRwQEBBAVFdXoTdgH06DR3hauRofm27qYmAaOnso/ZfF4bJ2pGr2fXz9cta5Nbufn7IenoydGjJwrOtdZ4QkhhNnpDXr2ZOxh/Zn17MnYI0WPQtRocyLdwcGBl19+merqakvE06zly5fzwAMPMGPGDPr168fKlStxdXXlgw8+aHT7yy67jFdeeYW77roLJyf7/bBZHRUBgGNq10lGHNn5LQDHPavqLb9QdIHbVt8myXQhhLBz1QG+yp3MTOsG0sVIf3Rhcvz4cUpLSwFYtGgRJSUlVo5IdJRVBo02l0g39UmXivTaRPqwoGHNbqdSqaRPuhDC7m06t4lJX03ivh/vY+7Wudz3431M+moSm85tsnZoQlhdu3qkX3vttfz6669ER0ebOZymVVVVsW/fPubPn1+7TK1WM378eHbs2GG256msrKSysrL266IipX+3TqdDp9OZ7XlaYnounU4HsT0A8EzL7dQYLEVv0HNw+1oGAGd86q8zYkSFilkbZjEldgoatcYqMZrUOw7CKuQY2AY5DrbBno6Dwd8fOIUmJ88u4m2tDh8DLy8cnJ1RVTR9yb/R2ZlqLy9o5DkuFF4AINA1sEu9rm1lT78LzelI/EOGDGHGjBmMHj0ao9HIsmXLcHd3b3TbBQsWtPt5ROepGzTaeYn0xvqjm8jA0Tqt6Y9uEusdy4HsA5JIF0LYpU3nNjFnyxyM1J+7klWWxZwtc1g+djnjo8ZbKTohrK9difTrrruOefPmcfjwYeLj43Fzq99X76abbjJLcBfLyclBr9cTFFS/AisoKIgTJ06Y7XkWL17MokWLGiz/6aefcHVt+jI+S9m4cSM5FQbGAQEZxaxfv77TYzC3w8WHuTyzDGiYSAclmX6+6DzLvlzGQI+BnRxd4zZu3GjtELo9OQa2QY6DbbCH45BlVAHgmJPfJf7vulRHjoHLG2/gWFRE/PLleFy4wKH77yevX7/a9VWenpQfOQJHjjR47JbsLQDoi/Rd8nVtK3v4XWhOWVlZux/74YcfsnDhQr777jtUKhU//PADDg4N39qrVCpJpNsBo9HIiQylgKczEunJhUrLyNZUpJ8qOIXBaECtatd4LbuXU57D2aKzqFAxNHBoi9vXVqQXSCJdCGFf9AY9S3YvaZBEh7qix6W7lzIuYpzVix6FsJZ2JdIfeeQRQGm1cimVSoVeb7+9k+bPn8+cOXNqvy4qKiIiIoKJEyfi6enZaXHodDo2btzIhAkTOB8XCAtXElxs4LqxY1FZIaFvTkVHi4jNV+6fbiSRbhI1IIop/ad0TlBNuPg4aLWWHfokGifHwDbIcbAN9nQc9hl+BnbgUlHNlHHjwMXF2iGZhTmPgcMLLwDQ99FH4aJEenN2bNkBF2Bwz8FMmWTd/yOtyZ5+F5pjuvKxPeLi4vj8888B5SrNzZs3ExgoA2jtVWZRJUUV1WjUKnoGNn5lgbmU6cq4UKJc3dLDu0eT20V6ROKodqS8upwLxReI8IywaFy2KiEzAVBOLHg5ebW4vanKXyrShRD2JiErgcyyptsyGjGSUZZBQlYClwVf1omRCWE72pVINxgM5o6jRf7+/mg0GjIv6bWamZlp1kGiTk5OjfZT12q1VvmgptVqiewxhCJH8KyC0jPH8Rl6eafHYU6RbiFEFir3G6tIN4nwjrCZD8fWOv6ijhwD2yDHwTbYw3HwCYqiUgNOetDm50MnnozuDB0+Bvn5UKj8Z6jt1Qtaua+c8hwAQjxCbP5noDPYw+9Cc8wVuzXemwvzMlWjx/i74eRg2Sq/s0VnAfBx8sHHuek34w5qB3p49+B43nGSCpK6byI9S0mkDwtsvj+6ienkxNmis1QbqnFQt+sjtxBCdLrssmyzbidEV9Tm6/N0Oh0ODg4caeRyY0tydHQkPj6ezZs31y4zGAxs3ryZUaNGdWosnc1Z60Kqn/KGOv/YPitH03GjicTBCOUOkNFIwY0KFRGeEYyJHNP5wQkhhDCLQPcgskyd37KyrBqLTTpTU6kYHAxtuNIsq1R5LYPcZdhod/ftt9/W9lj/9ttvm70J22dr/dFNpE/6Rf3Rg1vujw4Q4haCi4ML1YZqzheft2RoQghhVgGuAWbdToiuqM2nx7VaLZGRkVZp3zJnzhzuvfdehg8fzogRI1ixYgWlpaXMmDEDgOnTpxMWFsbixYsBZUDpsWPHau9fuHCBAwcO4O7uTs+ePTs9/o7ICnSnf3ohpUmdewLDEjRnzwFKNbrxklM5KpSeuismr5CeW0IIYccC3QLJdIOIIiSR3phkpT8xMS0nsi6WWapcmRfkJon07m7q1KlkZGQQGBjI1KlTm9zO3tsudhemRHqfoE5IpNf07o71bro/ukkv7+6dSC+qKiIxLxGA+MDWJdLVKjXRntEczzvOmcIzRHtFWzBCIYQwn2GBwwhyDSKrLKvRPukqVAS5BrX6Ch0huqJ2TYx55plnePrpp8nLyzN3PM268847WbZsGQsWLGDIkCEcOHCADRs21A4gTUlJIT09vXb7tLQ0hg4dytChQ0lPT2fZsmUMHTqUv/zlL50atzkUhfkBoD99ysqRmMHp0wD49o9Ho6qfLA/3DGfNHWuY1neaNSITQghhJoFugVKR3hxTRXpsy4msi2WW1CTSpSK92zMYDLU90Q0GQ5M3SaLbhxOdWJHemkGjJrUV6QXdM5F+IOsARoxEeUa1qQJT+qQLIeyRRq1h3oh5zW4zd8RcKXoU3Vq7Gra9+eabnDp1itDQUKKionBzc6u3PiEhwSzBNWbmzJnMnDmz0XVbtmyp93V0dDRGY8OzaPaoMiIUOIPDuVRrh9JxNcmDwIGjMBiVn5W3prxFv4B+jIkcI3+UhRCiCwh0C2R/zdsDQ0Z6+87cd2XtqEg3Go21FemBbjJUUjSvoKAAb29va4chWqFab+BUdgkAfYItP0/ClNxtSyI9pSiFSn0lTpqGs6S6MlNbl7ZWX5peW9NJCyGEsBfjo8azfOxy5m6dS5W+qna5p6Mni65YxPio8VaMTgjra1civbnLR4VlqGJigW24p3WBoQ41ifT8UB+MlUacNE48NPwh1CpJswghRFfh7+pfW5FekZZC67uAdxPtSKQXVxVTUV0BSGsXUd/SpUuJjo7mzjvvBOD222/nq6++IiQkhPXr1zN48GArR2inDHpU57YRlrcD1TlPiL0KLFDwcTa3lKpqA66OGsJ9XMy+/4vpDDpSilKAuqGYzQlwCcDLyYvCykLOFJyhr19fi8Zna2r7owe1rq2Liem1PV1w2uwxie5Lb9CzN3MvB6sOEpgZyIjQEVKEJixiXMQ4HFWOVFFFL+9enCw4yYSoCZJEF4J2JtIXLlxo7jhEC5x7KW9a/TKKrByJGdS0djnv7wQXINo7WpLoQgjRxWg1Wkp8XIEyqtLPSyL9Uu1o7WIaNOqmdcPN0a2FrUV3snLlSj755BMANm7cyKZNm9iwYQOrV6/mySef5KeffrJyhHbo2LewYS4ORWkMBzj3DniGwuSl0O8msz6Vqa1L7yAP1GqVWfd9qdSiVKqN1bg6uBLk2vIJOZVKRU/vnuzL3MfJgpPdKpFeXl3O0ZyjQNsT6RdXpBuNRlQqyx5X0fVtOreJJbuXkFmmXJn25eYvCXINYt6IeZLcFGZ3quAUJdUluDi48MCgB3jqt6c4kXfC2mEJYRM6lL3ct28f//vf//jf//7H/v37zRWTaIR3nyEAeJRVQ36+dYPpCKOxNnlwylvp2Rnj07ZBa0IIIexDpZ83AIaMDOsGYmv0ejinDN5uS0W69EcXTcnIyCAiIgKA7777jjvuuIOJEyfy1FNPsWfPHitHZ4eOfQurp0NRWv3lRenK8mPfmvXpTING4zpj0GhNW5cYr5hWJ3dNA0dP5XeBWU1tcCj7ENXGaoJcgwhzD2vTYyM8I3BQOVBWXVab+BSivTad28ScLXMa/CxllWUxZ8scNp3bZKXIRFdluhpnaOBQBvgNAJSh0zqDzpphCWET2pVIz8rK4pprruGyyy7jscce47HHHiM+Pp5rr72W7Owu0HrEBoUG9yKjpvjMeMaOh9bk5UGRUlV/2FXpBRnjLYl0IYToigz+yqBstbw3qC8tDaqqwMEBwsNb/TBTf3Rp6yIu5ePjQ2qqMkdnw4YNjB+vVCcajUYZNtpWBj1smAs0NmepZtmGecp2ZtKZg0bb0h/dxNQnPakgySIx2aqETGWW07CgYW2uKNeqtUR4Kie3zhTY8Wc3YXV6g54lu5dgbORvkmnZ0t1L0Zvxb5IQF7e1CvcIx0PrQZWhSv6eCUE7E+mPPvooxcXFHD16lLy8PPLy8jhy5AhFRUU89thj5o5RAGGeYST7KPdLEg9bN5iOqGnrQmgoJ8vPA5JIF0KILis4GABtboF147A1pv7oUVGgaX1vU1NFugwaFZeaNm0af/jDH5gwYQK5ublcd911AOzfv5+ePXtaOTo7c257w0r0eoxQdEHZzkxMFel9OjOR7t36RHpvn96AUo3YnZgSScODhrfr8aaTFabXXIj2SMhKaPaqBiNGMsoySMhK6MSoRFdmNBrrDVpWqVTE+cYBSHsXIWhnIn3Dhg28/fbb9O1b1yOvX79+vPXWW/zwww9mC07UcXZwJs3fCYCixENWjqYDLuoJm1ygJBJifVr/Rl4IIYT9cAxWLoV3zi8Gg8HK0diQdvRHB6lIF0177bXXmDlzJv369WPjxo24u7sDkJ6eziOPPGLl6OxMSSvbcLR2uxaUVlaTklcGdFJFekFda5fW6umtnIzJKsuisLLQInHZGp1ex8Hsg0Db+6ObSCJdmEN2Weuu6mvtdkK05FzROXIrctGqtQwMGAhAH98+gCTShYB2Dhs1GAxotdoGy7VaLQb5oGwxBSHecCAT3alEa4fSfqaK9B49SM7fAEiPdCGE6KpcQpTL2jUGo9Lay9/fyhHZCFNFehv6o4P0SBdN02q1/P3vf2+wfPbs2VaIxs619vfLTL+HSZlKNbq/uxN+7k5m2WdTDEYDyYXK358eXj1a/Th3R3dC3UJJK03jZP5Jhge3r0LbnhzNPUqFvgIfJ582tcG5mKnq/3TBaXOGJrqZANcAs24nREtMVzcM9B+Ik0b5f6mfXz8AjuUes1pcQtiKdlWkX3PNNcyaNYu0tLrLHi9cuMDs2bO59tprzRacqK88XLlEXp181rqBdERNFV5VVERtZZ20dhFCiK7J3zuUPOeaL7KyrBqLTWlnIj2rTHkNpSJdXOqjjz7i+++/r/36qaeewtvbmyuuuIJzpsG2onWirgDPUKCpntgq8AxTtjMDUyK9M9q6pJemU6GvQKvWEu7R+vkMUNcn/WRB92jvYkoktac/uokpAW86eSFEewwLHEaQaxCqJv4mqVAR7BrMsMBhnRyZ6Kou7o9uYqpIT8xPxGCU4lnRvbUrkf7mm29SVFREdHQ0PXr0oEePHsTExFBUVMQbb7xh7hhFDUNMNAAu5zOsG0hH1CTSs2o+LHg5eeHj4mPNiIQQQlhIoFsgme41X0givU57W7tIRbpowksvvYSLiwsAO3bs4K233uLll1/G399fqtLbSq2ByUtrvrg0cVXz9eQlynZm0KmDRmvaukR5RuGgbtuFybWJ9G7SJ/3i/sDtFe0ZDUB+ZT75FfnmCEt0Qxq1hnkj5jW6zpRcnztiLhoz/U0SorH5EDFeMThpnCjVlZJanGqt0ISwCe1KpEdERJCQkMD333/P448/zuOPP8769etJSEggPLxt1Q2i9bQ9lEE/XhkF9ttrtqa1yzlf5UdP2roIIUTXFegWSJZbzReZ5ukn3CW0t7WL9EgXTUhNTa0dKvr1119z66238uCDD7J48WK2bt1q5ejsUL+b4I6PwTOk/nLPUGV5v5vM9lSJnZlIL2x7f3STXt7dJ5GuN+jZn7kfgPjg9vVHB3DVuhLqFgpIn3TRMeOjxrPs6mUNqtKDXINYPnY546PGWyky0dVklGZwoeQCapWawYGDa5c7qB1qB08fzzturfCEsAltSqT//PPP9OvXj6KiIlQqFRMmTODRRx/l0Ucf5bLLLqN///7yZt2CvHoOoFoFjjoDZNhhVXplJZw/D8AJzypA2roIIURXVi+RLhXpivJyMLXGa2dFeqBboLmjEnbO3d2d3NxcAH766ScmTJgAgLOzM+Xl5dYMzX71uwkeP0L17f+rW/bITrMm0aEukd4ZrV1MLUba0/PbVJF+quAURqPRrHHZmpMFJynWFeOmdSPOJ65D+zJ91pFEuuioWK9YjNT97rlp3dhw6wZJoguzMlWj9/Xti5vWrd66vr59ATieK4l00b21KZG+YsUKHnjgATw9PRus8/Ly4q9//SvLly83W3CivjDfKFK9ar5ItsNee+fOgdEIbm4cU+UAkkgXQoiuLMgtqDaRrku/YN1gbIWpX7WHB/j6tvph5bpyiquUhJu0dhGXmjBhAn/5y1/4y1/+QlJSElOmTAHg6NGjREdHWzc4e6bWYOw9mSpNzR+yQvNezp5dXEluaRUqFfQK7LyK9PYk0qM9o3FQO1CiKyG9NN3codkUUyJpSOCQNrfAuZTptTa11RGivUx9+/v4KL2qS3WlVOorrRmS6IIa649u0sdP+dk7kXeiU2MSwta0KZF+8OBBJk+e3OT6iRMnsm/fvg4HJRoX4RVBsrdy33jaDqe/m2KOjSW58CwgrV2EEKIr83TyJMdD6dlZkS79FIG6E+GxsdCGAXamti6OGke8nLxa2Fp0N2+99RajRo0iOzubr776Cj8/PwD27dvH3XffbeXo7F+pU81VIHnmLWQxVaNH+7nh4mjZ/sZGo5HTBcp78R7ePdr8eK1GW9vzu6u3d6lNJAW2v62LSQ8v5bWWinTRUXsz9wJwdfjVOOEEKG04hDCn5hLppor0E3knuvyVSUI0p02n2DMzM9FqtU3vzMGB7OzsDgclGhfmEcbPPnDNWSg7eQy3Fh9hYy4arpZcoHwQkYp0IYToulQqFRW+HkAB1VKRrjD9X9jG/uhZpUprnCC3IFRtSMCL7sHb25s333yzwfJFixZZIZqup9QxCJ+yZMgzbzL0REYRAHFBlq9Gz63IpaiqCBUqojyj2rWPXj69OFVwipMFJ7k64mozR2gbjEZjs4mktor1rqlIl0S66ICLfy6HBQ7ja/XXZBoySStNq/0ZE6Kj8iryav9WNTZouZdPLzQqDXkVeWSWZRLsFtzZIQphE9pUkR4WFsaRI0eaXH/o0CFCQkKaXC86xsnBiewgJX1ecdIO+1LVJA+MsbGcya8ZdiQV6UII0aXp/HyUO1kybBRo/6DRmv7o0tZFNKesrIwTJ05w6NChejfRMbUV6fmWqUjv3Yn90cPcw3B2cG7XPkyD5rpyRfrZorPkVeThqHZkgP+ADu/P1NolozSDMl1Zh/cnuqfzJefJKsvCQe3AAL8BeKu9AUgrSbNuYKJLMQ1Z7undE29n7wbrnTROtSdupL2L6M7alEifMmUKzz33HBUVFQ3WlZeXs3DhQm644QazBScaKgkLAMB4xg6rGmpau5RFBFNUqVTgRHtHWzEgIYQQlmYMUhJQmpw8K0diIy66OqstTK1dZNCoaEx2djbXX389Hh4e9O/fn6FDh9a7iY4ps1Rrl8zOGzRq6tHdkerVXt7KwNGTBV03kW6q+h0UMAhHjWOH9+fl5IWvszIPw3QyQ4i2SshU+qP39+uPi4NLbSK9q88rEJ3L1D6ouatxZOCoEG1MpD/77LPk5eXRu3dvXn75Zb755hu++eYbli5dSlxcHHl5eTzzzDOWilUA1ZERADil2uHZ55rkQVqAUgUT5BaEq9bVmhEJIYSwME2QcqWaU26hlSOxER2tSHeTinTR0OOPP05hYSG7du3CxcWFDRs28NFHH9GrVy++/fbbNu/vrbfeIjo6GmdnZ0aOHMnu3bub3b6goIC//e1vhISE4OTkRO/evVm/fn3t+ueffx6VSlXv1qdPnzbHZS0lTjW/d2asSNcbjCTVJNLjOiOR3oFBoya9fJREenJhMjqDzixx2RpTwnJYUMO2Bu1VO3BU2ruIdrq03ZBUpAtLaE1bq9pEep4k0kX31aYe6UFBQWzfvp2HH36Y+fPn1w4YUKlUTJo0ibfeeougIPmAZ0nq2B7AVtwy86CqChw7XinRKYzG2kT6aV/gtLR1EUKI7sAppOYEcFkllJeDi4uVI7Kii/4vbG9FuiTSRWN+/vlnvvnmG4YPH45arSYqKooJEybg6enJ4sWLuf7661u9ry+++II5c+awcuVKRo4cyYoVK5g0aRKJiYkEBja8IqKqqooJEyYQGBjImjVrCAsL49y5c3h7e9fbrn///mzatKn2aweHNn0MsaraivSCVNDrQNP0zKjWSskro0JnwMlBTbSf5ScfmSORHuIWgrvWnRJdCWcLz9Ym1rsSc/ZHN4n1imVv5l5JpIt2ayqRLsNGhbmUVJWQmJ8INN4f3aSPr3ISXFq7iO6sze9go6KiWL9+Pfn5+Zw6dQqj0UivXr3w8fGxRHziEt5RcZQ5gGs1kJICPXtaO6TWycqC0lJQqTjmUgrIoFEhhOgOPAPCqdSAkx7l/4Ko9g256xLy86FIaW1GdHSbHlo7bFR6pItGlJaW1ia5fXx8yM7Opnfv3gwcOJCEhIQ27Wv58uU88MADzJgxA4CVK1fy/fff88EHHzBv3rwG23/wwQfk5eWxfft2tFolwRzdyM+3g4MDwcH2OZiswsEbo4MLqupyKEgBvx4d3mdizaDRXkHuaNSWHyBsjtYuKpWKnt49OZB9gJP5J7tcIj2tJI200jQ0Kg1DAoaYbb+m1/x0wWmz7VN0H9ll2aQUp6BCxZDAIcBFFemlUpEuzONA9gEMRgPh7uHNFm2YEunppekUVBQ02ktdiK6u3aUgPj4+XHbZZeaMRbRCuFcEyT7QPxvl8nB7SaSbKvDCwzlVlgpIIl0IIbqDQPcgMt0gsghJpJvaugQHt7kyXyrSRXPi4uJITEwkOjqawYMH8+9//5vo6GhWrlxJSEhIq/dTVVXFvn37mD9/fu0ytVrN+PHj2bFjR6OP+fbbbxk1ahR/+9vf+OabbwgICOAPf/gDc+fORaPR1G538uRJQkNDcXZ2ZtSoUSxevJjIyMgmY6msrKSysrL266Kak1A6nQ6drvPaiuh0OlCpMHpHospJpDr7FEbPpuNurWNpSrurXoHuFv9+iquKySpXTsZFuEZ06Pl6ePXgQPYBTuSeYELEBHOF2CJTzJZ8rXanKS2M+vr2RYvWbM8V5a78v3em4Eyn/uxaQmccB1Gf6eeyt09vXFQu6HS62kR6VlkWZZVlaNUdv0pGtE1X+10w/ZwNDRza7PfkpHIiwj2C1JJUjmQfYWTwyM4KsVFd7TjYo65yDNoSv/1cUykAiPCKINn7okS6vTAl0nv0ILlAiVtauwghRNcX6BZIlimRnplp7XCsq51tXeCiHulSkS4aMWvWLNLTlaFzCxcuZPLkyXzyySc4Ojry4Ycftno/OTk56PX6Bq0ag4KCOHGi8cu4z5w5w88//8wf//hH1q9fz6lTp3jkkUfQ6XQsXLgQgJEjR/Lhhx8SFxdHeno6ixYtYsyYMRw5cgQPj8b7gy9evJhFixY1WP7TTz/h6tr5M3YydW6EAMe2fUdyYkWH9/dbohpQY8hLZf36lA7vrzmp1UoRi4fKg62btnZoX6aTG9uTttMjreOV+W21ceNGi+37m7JvAPAq8arX47+jigzKSaDU4lS+/f5bHFT2/xHcksehXYwG/EoScdYVUKH1Jtc9DlRtGgdns9aVrQPAt9S39ufSTeWGBg16o57V36/GRyPdAazF5n4X2mlz8WYAHNIdWvz751XpRSqpfL39a3KdczsjvBZ1leNgz+z9GJSVlbV6W/v/X7ybCfcM5/ua/yeNZ85g+QtBzeR0zaWMsbEk5/8OSEW6EEJ0B4FugWSa2v9mZVk1Fqtr56BRqKtID3Rr2KNaiHvuuaf2fnx8POfOnePEiRNERkbi7+9v0ec2GAwEBgby7rvvotFoiI+P58KFC7zyyiu1ifTrrruudvtBgwYxcuRIoqKiWL16Nffff3+j+50/fz5z5syp/bqoqIiIiAgmTpyIp6enRb+ni+l0OjZu3Ih/r8tgbwL9Q13pO2FKh/f7+sltQBk3j72MMT0te4y+PfMt7IQ+gX2Ycm3HYg/KCuK7Td9R5FTElCkdfx1ay3QcJkyYUNtCyNze/+59qILbRt7G1eFXm22/RqORt758i9LqUvpf2Z8e3p1/AsJcOuM4tJXqxHdofnoaVXFdmxOjRyj6iS9h7HODFSMzjw/XfwhVMG3ENK6NvLb2GIS4h3C+5Dx9RvQxa09/0Tq2+LvQXhXVFTy/5nkA7h1/L5EezV91lXk0kyMHj0AQTLmy8/4faExXOg72qqscA9OVj60hiXQ7E+YRRrK3cr/q1AmcrBpNG9RU4RliYjhb8AkgFelCCNEdBLkHcchduW/MzLSfE8CW0M6KdJ1eR155HiCtXUTruLq6MmxY08PCmuLv749GoyHzkqtHMjMzm+xvHhISglarrdfGpW/fvmRkZFBVVYWjo2ODx3h7e9O7d29OnTrVZCxOTk44OTV8p6vVaq3yQU1d0xddU5iCpoPPX6HTczZXqXwaEOZj8e/nXMk5AHp49+jwc/X17wso/XErjZW4O7p3OL62sNTxzy3P5WzRWQAuC73M7M8R6x3L4ZzDpJSm0Cegj1n3bQ3W+j1s4Ni38NUMwFhvsao4HYevZsAdH0O/m6wTmxkUVhZyqkD5Ozk8dHi91zzULZTzJefJqsyyjWPRTdnM70IHHMg9QLWhmgCXAGJ9YlGpmn+33j+gPwCJ+Yk28713heNg7+z9GLQldkmk2xknByfyQryAQqpPn7K7RHpBmB+VKZWoVWoiPCOsHJQQQghLC3ANIKumIr0yPRVn64ZjXe2sSDcNGtWoNPi5+pk7KmGnLq7Wbsny5ctbtZ2joyPx8fFs3ryZqVOnAkrF+ebNm5k5c2ajj7nyyiv59NNPMRgMqNVKK4WkpCRCQkIaTaIDlJSUcPr0af70pz+1+nuwNqNvze9t3pkO7+tUVgkGI/i4agnwsPy7eVNbRXNUQns5eRHoGkhWWRanCk7VDj+0dwlZylDeXj698HLyMvv+Y7xiOJxzmDOFHf/5ETUMetgwl0uT6AojoIIN86DP9aDWNLKN7duftR+AaM9o/F3qX7kS4qbMv0grkYGjomP2Ze4DID4ovsUkOtQNHD1XdI4yXRmu2s5vtyaENUki3Q5VRoQChTicS7V2KK1X09ol1c8BUiDCMwKtxn7PVgkhhGgdJwcnir2cgQqq0rp5Ir2dFemmRHqAWwDqLtLzVXTc/v37W7Vdaz4UX2zOnDnce++9DB8+nBEjRrBixQpKS0uZMWMGANOnTycsLIzFixcD8PDDD/Pmm28ya9YsHn30UU6ePMlLL73EY489VrvPv//979x4441ERUWRlpbGwoUL0Wg03H333W2KzZqMPtHKnfyzYDCAuv2/iycyigGIC/Zo8/Fpj9OFyvvwWK+2z2doTC/vXmSVZZGUn9R1EumZSiI9PtAyLTJMJzHOFEgi3WzObYei5pLIRii6oGwXM6bTwjKnixOclzIl0tNL0zs1JtH1NPdz1hg/F7/aE6qJ+YkMDRxqyfCEsDmSSLdHMTHAcZzyi6CkBNw795LKNisvhzTlTU6SVzUgbV2EEKI7qfT1AirQZ2ZYOxTr0evhnNJeoa0V6ab+6NLWRVzsl19+sch+77zzTrKzs1mwYAEZGRkMGTKEDRs21A4gTUlJqa08B4iIiODHH39k9uzZDBo0iLCwMGbNmsXcuXNrtzl//jx33303ubm5BAQEMHr0aHbu3ElAQIBFvgeL8AwHlQaqK6AkAzxD272rxAylD2efYMv3eq/UV3Kh5AKgtBcxh14+vfg97XdO5p80y/5sQVsTSW1lOokhFelmVNLKAeat3c4GtSqRXiKJdNF+OoOOg9kHARgW1PqWcP18+5FVlsWx3GOSSBfdjiTS7ZB/cCy5LuBXjnKZ+MCB1g6peWfPKv96enLCmA3IoFEhhOhOqgP8gExUWdnWDsV60tJApwOtFsLC2vTQzBIZNCoap9frOXr0KL169cLFxaXeuvLyck6ePMmAAQPqJb5bY+bMmU22ctmyZUuDZaNGjWLnzp1N7u/zzz9v0/PbJI0WvCOUivS85A4l0i+uSLe0s4VnMRgNeDh64OdsntZQvXx6AdT2brZ3xVXFnMg7AbQtkdQWpkT62aKz6A16NHbaasSmuLfy5HJrt7MxZboyjuUeA6QiXVjO8dzjlFf/P3vnHR5Vlf7xz7T0TArJpJOQEDoIoTdFDYKoqKyuu3ZU3HVtK66Crr9Vd9cVd11W14697toVFemwKFWI9BpIAdJ7TyYz8/vjzp0kpE0vyfk8T55MOfecd+bce2fme9/zfRvR+mkZHD7Y6u2GDRjG5jObLedOgaA/IdYH+yCJ2kRLwVHLMnFvxmzrQmoqOdW50s0I52TECAQCgcD7UZgzWTXllR6OxIPIn9fJyaCyTUCxZKT7qBggcB3vv/8+t912W5de5BqNhttuu42PPvrIA5H1USLN318d9Ek/ZhbSh8S4XkjPqZb80VPDei8gZy3p4ZKQfqLqBCZTV/7UvsXPJT9jwsTA0IHoglxzwTIhJAE/pR/NhmYK6oWntVNIntbLBS0FaBOkdj7I3tK9GEwG4oLjiA/p/DrbC+l94TgUeAbZ1iojJsMm+0DZJ/1I+RGXxCUQeDNCSPdBksKSOBVhviMXLvNm2nnCysWOREa6QCAQ9B80sVIGdmBlreQt3B+xs9AotGWkC2sXwbm8+eab/OEPf0DVxcUZtVrNww8/zIoVKzwQWR9FtiastP/7d2V9CyW1zYB7MtJlKxFn+aODZBGjUqiobq6mtNH3VxpZ/NFdZOsCoFKqSA5LBtoubggcRKmCC5b23GbuMp8tNNrbfqkL1KFAQbOhmfKmcneGJuhDyPZBE2Im2LTdiMgRAJysOkmLocXpcQkE3owQ0n2QRG0iOb4opKelkWP+4SE80gUCgaD/EBg/EACl0QQVFR6OxkPYWWgUoKRBKjYqhHTBuRw7dowpU6Z0+/zEiRM5ckRkizmNSPP31wr7v3/Lti6JEYGE+LveZVMW0uVil87AX+XPQK10Xu8LPumykOQqWxcZi0+6KDjqPEqPSf9V56zKUWrgl+/CiPnuj8lJ9Obbr1FpiA6S6kwIn3SBPRhNRvaUmM9/OtvOf7HBsYT5h9Fqau0zNl8CgbUIId0HSdImWaxdTL4gpJutXQwpyZyuOQ2IjHSBQCDoT0SFxVEu2zeXlHg0Fo/hjIx0Ye0iOIf6+npqamq6fb62tpaGhgY3RtTHcdDaxWA0sfqgJHjpQv0xGF1vx3CySvoePijMud+9LfYuPi6kN7Y2crD8IODajHSAtDDpYsbJ6pMuHaffUF8Gu9+Sbl/3AdzyLVz+L1D5g1EPfsGejc8BWgwt7C/dD/R8gSc+WLJ86Yt2QQajgZ+KfmLVqVX8VPQTBqPB0yH5BkYD5PwABz6T/vfwvp2oPEFtSy2B6kCGDRhm0zAKhYLhkcMBYe8i6H+IYqM+SHxovCUj3ZB9wvsn0ZyFVxITgrHUSIA6gNiQWA8HJRAIBAJ3oQvWURJsLpJdXAwjRng6JPcjC+l2ZKRbPNJFRrrgHNLT09m2bRtjxozp8vkff/yR9PR0N0fVh3HA2mX1wUKe/OYwhdVNAGTlVzHjmY08fsUI5o6Kc2aUFlqNreTV5AHOtXYBqeDo2ry1nKjybSH9QOkBWo2t6IJ0JIYkunQsOZFIXiUgcJAdL0NrI8SPg/RLQKGAQTOhLBt2vARb/gmDMz0dpV0cLDtIi7GFyIBIBmm7vwgWFxLH3tK9fS4jfX3eepbtWkZxQ7HlsZigGJZOWkpmsm/OqVs4vBJWL4GadhdWtPEw95kuV2dklUj2QWOjx6JRamwebnjkcHYU7uBIhRDSBf0LkZHug/ir/amNHwCAIjcXvLm4iNFoEdJzIqXdLSU8xWnFjgQCgUDg/cQEx1AiJ4b114x02drFgYx0XbBriuAJfJfrr7+exx57jP3793d6bt++ffzpT3/i+uuv90BkfZSIFOl/UzU0WG9TtfpgIXd9kGUR0WWKqpu464MsS5a6szlbdxa9UU+AKqDLYoWOkB7RNzLSZVuD8THjXf77RL6YkVOVI4pDOkpjFex6Xbo98w+SiC4z7V7J6iV/G+Ru9Uh4jiILnL3tl30xI3193noWb17cQUQHyeZu8ebFrM9b76HIvJzDK+GTmzuK6AA1hdLjh1d22qQ3+6DesBQcFUK6oJ8hhHQfxTRwIEZA1dgEpV5c5KeoCJqaQKXiSFA9IGxdBAKBoL+hC9ZR3J+F9MZGKDQLZTYK6QajgdIG6XNeWLsIzuWBBx5g9OjRjB8/nksvvZQHHniABx54gEsvvZQJEyYwatQoHnjgAU+H2XfwCwJ5VaWVWekGo4knvzlMV7Kp/NiT3xx2ic2L7MWdEpaCUuHcn31DwocAknVMq7HVqX27E4uQpHOtrQtAilaah1p9LWWNZS4fr0+z63VorgHdCBg6r+Nz2jgYd6N0+4dn3R+bE9hdvBvoXeCUL5AV1veNjHSD0cCyXcswdXHGlB97ZtczwublXIwGKRO9p0+a1Us72LyYTCaH60MMHyBZuxyvOC7mRNCvEEK6jxIblcxZrfmON/ukyxl4Awdyqk74owsEAkF/RLZ2ATAU9Y0fezaRmyv912ohMtKmTcsbyzGajACWomICgYxGo2Ht2rU89dRTFBYWsmLFCl577TUKCwt56qmnWLt2LRqN7cu1BT1g8Um37vv3rpyKTpno7TEBhdVN7MpxfiFm2ULE2f7oAAmhCQSqA2kxtpBfm+/0/t2B3qBnX8k+wPX+6AB+Kj+LfYywd3GA5jrJugVg5oOg7ELSmH4/KFRwciOc3ePe+Byk1djK3pK9QO8FIOOCJVuovmLtklWS1SkTvT0mTBQ1FFky9gVm8rZ1zkTvgAlqzkrtzOTX5lPWWIZGqWF01Gi7hk3WJhOoDqTJ0ERuTa5dfQgEvogQ0n2UxNBES8FRrxbSzYVGSU21ZMUMihBCukAgEPQnIgIjKAuRliY3Ffim4OIQ7QuN2mgdUFIvZfAPCByARiUEUUFnNBoNDz/8MHv37qW+vp6Ghgb27t3Lww8/jJ+fn6fD63tEmr/HWimkl9R2L6Lb084WZLFWLnLpTJQKJYPDBwO+a+9yuOIwTYYmwv3DSQ13rod8d8jjCCHdAfa8DY2VEJkGI6/uuk1ECoy5Trq95Z9uC80ZHKs8Rr2+nhBNCEMihvTYVs5I7yvWLvIKPGe16zfUdX/xobt2WcXSxYjRUaMJUAfYNaxSoRT2LoJ+iRDSfZSksCRLwVFL1rc3IseWmkqOeQmsyEgXCASC/oVSoaQxIhSA1sKzHo7GA7T7LLQV2R9d2LoIBF6CjQVHdaHWCRTWtrMFOYnFVSKxrwvpspCUoctwuvVNd8g+6SerTrplvD6Hvgm2vSDdnvEAKFXdt525GFDAse+g+JBbwnMG8n45TjcOVU+vj7aM9NqWWupa6lwem6uxduWdWKF3DtZ+RwyKsty01j6oN2Qh/Wj5UYf6EQh8CSGk+yiJWh/JSJfFg7Q0cqrMQrrISBcIBIJ+R0u0dPXXVGJl1kxfon1Guo0U14tCowKBV2HJSLcukWXSoEhitd2L5AogLiyASYNss33qDZPJRE6NdO6RxVtnIxccza7Kdkn/rsZRf2B7sBQcrfbi32/ezM/vS1m1YUltGefdEZUOI6+Sbv/gO1npthSADNIEEeYfBvSNrPQMXQYxQd2LwgoUxAbF9mp50+9IngbaeKRPlB747kE4+DkYjQ4XGpUZHin5pIuMdEF/QgjpPkqSNolTcka6NwvpZmuXpoHxluXpIiNdIBAI+h+maCl7SFVa7uFIPIAjQrqckR4sMtIFAq/ARmsXlVLBjMEDunxOljwev2IEKqVttk+9UdxQTL2+HpVCxcDQgU7tW0YW0n0xI91gNFgyfyfETHDbuLKQLqxd7MCgh63PS7en3w9qK6yrZj4o/T/4BZR5/wWf9gUgrRU444PNBUf7gE+6Sqni4YkPd/mcwnzGXDJpSa+Z+v0OpQrmPkPXxUbNny1+wVCRDZ/dRtGK6ZytO4tSoeS86PMcGlouOHqk4ggmk/OLZgsE3ogQ0n2URG2ixdrF5M1Cujkj/WyUPwBh/mFEBEb0tIVAIBAI+iDKmFgA/CuqPRyJB3DE2qVeCOkCgVchr6ysK4KWhl6bn65o4LsDRQBoAzrWOYgNC+CVGzOYOyrO6WHKQm1SaJLL6iukh0tC+una0zToe38vvInsqmxq9bUEqYMYGjnUbePKhV/LGsuoaalx27h9gv0fQ/VpycZi3I3WbRM7GoZcCpjgx3+5NDxncKr6FFXNVfir/Bk5YKRV28j2Ln0hIx1Ao5TOV4pzsqsjAyJZPms5mcmZngjL+xkxH6KHd35cGw+/fB8WH4VZj4K/lqzaXACGGZSEnP4JHBDA08LSUCvV1LbUcrauH9o3CvolQkj3URK0CW3WLvn50NrqyXC6pr4eiiUB4ESEERC2LgKBQNBf8Y9LAsCvoRkafEtwcQiTyaGMdHk1l/BIF/TEpk2bPB1C/yEoEgLCpduVuT02NZlMPPrlARr1BiYPimTPY5n8Z9EUnv/VWP6zaAo/LrnIJSI6tFmHuMrWBaQiyJEBkZgw+VyGtewPPE43DrVS7bZxQ/xC0AVJVl2yh73ACowG+GG5dHvavaAJtH7b8/8g/d//X6jy7oLncjb6edHnWX0BTC442hcy0k0mEyv2rwBg4aiFvDXnLcZEjQHg8rTLhYjeExWnoNRsr3LN2/CLN+GWb+H3BySRPUALs5bA/fvYkzIRgPG1FfD+VfDO5ZC/w65hNSqN5aLq0Qrhky7oHwgh3UfxU/lhiNXRrAJFayucOePpkDojZ+BFRHDCIFXWFrYuAoFA0D/RRifSJK/ELS31aCxupaICasxZhykpNm8uMtIF1jB37lzS0tL461//yunTpz0dTt/HSp/0z7PO8sOJMvzUSp5eMBqNWsnUtAFcOTaBqWkDnG7n0h5ZpE0LT3PZGOAmexejAUXejyRUbEeR96MkqtqJobWFn35+k+8Ovg/AOAdtDewhLUyaE+GTbgOHvoSKkxAYAeMX2rZt4gRInQXG1jZrmB4wGA38VPQTq06t4qeinzA4sL/Zij2+1XJGemG97wvp2wu2c7D8IAGqAG4ZeQsTYydy08ibANiUv0lYh/TEzx9I/wdnwqgFMPoaGDSzc0HeoEj2aCQZcPzAWaDyg7wf4a058ME1UPBzW1ujAXJ+gAOfSf+7ORba27sIBP0BIaT7MIkRA8kLM9/xRnuXdkvZLYVGhZAuEAgE/RJdSAwlweY7xf2o4Kj8+RwXB4E2ZNCZsXiki4x0QQ+cPXuWe+65h88++4zU1FTmzJnDJ598QktLi6dD65vIKywru//+XVrbzF++PQzA7zPTSY0OcUdkFk5WS3WKZCsRVyFnIh6vPO6aAQ6vhOdGof7gKibkvYL6g6vguVHS4zay/senmfNeBrftf44DDZIFwYc/v8T6H592ctA9kxourRI4WXXSreP6LEZjW7HQKXeDvx3H0vkPSf+z3ofaom6brc9bz5zP53DbmttY8sMSbltzG3M+n8P6vPV2BG4bJpPJslLClgK4ckZ6X7B2WXFAyka/Zsg1RAZIBZhnJszET+lHfm0+J6p8rx6DWzC0wt6PpNvjbuqxaWVTpeXzIWPuc3BvFmTcAgoVZK+DFbPg4xth+8vSufbdy+Hz26X/3Zx7h0UOA+BIuRDSBf0DIaT7MInaRO8uOCoL6WlpbUK6sHYRCASCfklMeyG9pMSjsbgV+fPZDn90aMtI1wXrnBWRoA8SFRXFAw88wN69e9m5cydDhgzhd7/7HfHx8dx3333s27fP0yH2LawoOPrkN4eobtQzIk7Lopmus1fpDou1S7hrxx4SMQTANQLX4ZXwyc1Qc45AWFMoPW6DmL7+x6dZnP0hxef8+q1UwOLsD90qpouCozZy/HsoOQz+Wpi0yL4+kqdD0hQwNMO2F7pssj5vPYs3L6a4oePF/pKGEhZvXuxyMf1s3VlKGkpQK9QWOxNriAsxZ6T7uLXLnuI97Cneg0ap4daRt1oeD9YEMy1hGoBbLmj4JCc3QG0hBEbC0Et7bJpVIhVZTgtLIyIgAsKTYP6/4Z6fYMx1gAKOfANrHrH63Ds8UspIF9Yugv6CENJ9mCRtkqXgqFcK6SfNWRapqeRUiox0gUAg6M/ognUUy0lk/UlIly8q2+GPbjKZ2jzShbWLwEoyMjJ45JFHuOeee6irq+Ott95i/PjxzJw5k0OHDnk6vL5BpFmc7sbaZf3hYr7dX4hKqeDv14xBo3LvT66qpioqmioAGKR1cUa6q6xdjAZYvQToysrBJP19fTdsfgb+948e/wybnmbZ8Q+knhTn2OmY7z9z/EMMre5ZwSGvEhBCuhWYTLDlH9LtSYsgMNy+fhSKtqz03W9BfXmHpw1GA8t2LcPUxf4mP/bMrmdcavMiC5wjokYQpAmyejvZ2qW0sZQWg++uQnp9/+sAXDX4qk7feTIHSt7o6/OFkN4lWe9J/8/7Faj9e2zarX3QgDRYsAJ++yOoA7rZ2nx8rF7aweZlSMQQFCgobSylrLHMnlcgEPgUQkj3YRK1iW0FR71RSDeLB6ZBg0RGukAgEPRzdME6S0a6qT9au9ghpFc1VVl+FAtrF0Fv6PV6PvvsM+bNm0dycjJr1qzhxRdfpLi4mOzsbJKTk7n22ms9HWbfoAdrl5omPY99dRCAO2YMYlRCWKc2rkYWaOOC42wS5OwhLTwNBQoqmioobyzvfQNrydvWORvyXJprYPPfYNNfe/zL2vkvilXKziK6GZNCQZFKQdaB950Xfw/IGekFdQU0tTa5ZUyf5eRGybNZEwRTfudYX4MvhrixoG+AHS93eCqrJKtTJnp7TJgoaiiyiN2uwB5/dIAI/wgCVJLwWVTfvW2NN3Ow7CBbC7aiUqi4bdRtnZ6flTQLtULNicoT5NXkeSBCL6auFI6vlm73YusCVuxnjZXQ43nJBDVnpXO0mSBNkOUCobB3EfQHhJDuw3TISD/lhRkN5phqk3TUNEuF1lLCUzwYkEAgEAg8RXRQtEVI1xd6YYFsV9GuXoityNnoWn8tAd1mBwkEcO+99xIXF8dvfvMbhgwZws8//8z27du54447CA4OJiUlhWeffZajR8Wya6cgW7tUnQaDvsNTf199lKKaJpIHBPH7zCEeCK5NSJcFW1cSqA4kKTQJcLK9S52VF1xTZkr+vj38lcaOtKqr0pp8BwK2nsiASML8wzBhIrcm1y1j+ixbnpX+j18IwVGO9aVQwPl/kG7vWgGNVZanShusK4JubTt7sAicOtuEdIVCYbF38VWfdDkb/bLUy0gMTez0fJh/GBNjJwLC3qUT+/8rFdJNGA8xI3psWtdSZ7Ff6daH39pz7zntLD7pouCooB+g9nQAAvvx6ox0g8ESU16kVCk6JjjG5VkxAoFAIPBOgv2CqdL6AS00F57Bz9MBuQsHMtJlf3Rh6yLojcOHD/PCCy+wYMEC/P27XtYdFRXFpk2b3BxZHyUkFtSB0NoIVfnSknhgV04FH+yQxNinF4wm0E/lkfAsQrqL/dFl0iPSpUKAlSeYEjfFOZ1auwrngiUwaGaPTaJ/fhP2P9drV9HagdaN6SAKhYK0sDSySrI4VXXKIkAJziF3K+RvA5UfTLvXOX0OvQyih0PpEfjpdYvdS3RQtFWbW9vOVsoay8iryUOBgrG6sTZvHx8cT051jk/6pB+vPM7G0xtRoOD20bd32y4zOZPthdvZkL+hx3b9CpNJKqALVmWj7yvdh9FkJCEkgdjg2K4bWXvuPafd8MjhrMpZJXzSBf0CkZHuwySFJbUVGy0qgsZGj8bTgYICaGkBtZrjgQ2AsHURCASC/k7TAMniwFDkez/07MJggDzzEmQ7MtKL60ShUUHv6PV6kpOTmTJlSrciOoBareaCCy5wY2R9GKUSIlKk22Z7lya9gaWf7wfgVxOTmJbmYPasA5yqcl9GOsDg8MGAk33Sk6eBNr6HBgrQJkjteiFj9E3EGEwoTF35rYPCZCLWYCJjdO9ClLOQbRBOVp9025g+xw/mbPRxN4I2zjl9KpUw80Hp9vaXoaUegAxdBjFB3QuIChTEBsWSoesmi9dB5Gz0IRFDCPO33Q7KlzPS3zjwBgCzk2f3eM66aOBFKFBwoOyAz1rYOJ0zP0HZMenC7qhf9NrcKvsgy7m3ayssoMtz7/ABUsFRYe0i6A8IId2HiQ+NpyoQquXfTLm5ngynI/JS9pQUTtVKmTmpEe75Mi8QCAQC78QQFQmAor8UGz17FvR60GggvidBqGssGenCH13QAxqNhs8//9zTYfQ/ZHuXCklIf3FjNqfK6okO9eeRS4d7MDD3WrtAW8HR7Kps53WqVMHcZ7p50izwzF0mtesFldqPpUNu6LJsqSyuLxlyAyq1+9ZKyXOTU+1lq4q9hbN7JH90hQqm3+/cvkdeLdU5aKyA3W8DoFKqWDppabebmDCxZNISVFbsb/Zgrz+6THyw9B2joM63hPS8mjzW5K4BYNGYRT22jQqMYpxuHAAb8je4PDafQC4yOvIqCND22lzezybETOi+UYdzbzdiesYtnc698sqaM3VnqGmp6TUWgcCXEUK6D+On8iMmNNY77V1OmrMrUlPbCo2Gi4x0gUAg6M8odJIgrCmv9HAkbkL+XE5OBpXtP77ljHRh7SLojauuuoqvvvrK02H0LywFR3M5UljDq/+Tvvv+5cqRhAVpPBZWg76Bwnpp1Y8nhHSjyei8jmNHdf24Nh5++R6MmG91V5kzHmFq2OBOj8cYDCyvqCNzopOsQ6xEtt2RVw8IzmHLP6X/Y65rW/3hLFRqmLlYur3tBdBLhRUvGngRkQGRXW4ycsBIMpMznRtHOxwV0uWMdF/L1H7zwJsYTUYuSLzAKoujiwdeDAifdACa6+DQl9JtK2xdmg3NHCg7APTgjy4zYr50jj13JYjGXOxo/39B39ENIcw/jISQBACOVRzrPX6BwIcRHuk+TqI2kZyIIsYW410FR9sVVxNCukAgEAgA1LFSxlRAZS0YjdIS676MA4VGoa3YqBDSBb2Rnp7On//8Z7Zu3cr48eMJDg7u8Px9993nocj6MOaMdGP5SZZ8vp9Wo4m5I2OZO8pJFhR2klMjfe+ODIgkPCDcLWMODB2In9KPxtZGztaeJUmb5JyOf/5Q+p96Ia3T7mfvD2sYO3MO6tTzrcpEb0+DvoH9jZLI+FDqL4gymogOTSTjh5dQ1RTA7rdguvuOE/kiR15tHq3GVtRK8bPcQvEhOPYdoGgTvJ3NmF/B5meg5gzs/QAm3sGuol1UNFUQog7h2VnPUt1cTauxlT9u/SOHyg9xrOIYQyOHOj2U6uZqiy1SrwJnN/hiRnpBXQHfnPwG6D0bXebi5Iv5x+5/kFWSRXljOQMCB7gyRO/m8FfQUgeRaVZZXB0oPYDeqCcqMIqBoVbUgxgxH4ZdBnnbpMKiITEQMxJemQYVp2DzMpj9ZIdNhkUO42zdWQ6XH7YUhxX0bQxGA7uLd7OvZR+6Yh2T4ie5bOWONyE+sX2cJG0SOeG7pTvelJEuiwdpaeRUSoWthEe6QCAQ9G8C46Uv7kqjCSoqIMpzHsJuwYFCoyCsXQTW8+abbxIeHs6ePXvYs2dPh+cUCoUQ0l2BWUivOnuc/eXVhAaoefLKkR4Oqi3DWfbgdgdqpZq08DSOVBzheNVx5wjpRgPs/Ui6nXEzpuQZnD1Uw3nJM2wW0QHW5a2jXl9PYkgiN874E0qF+UKuIhC+vhu2vwiTFoEm0PHYrSA2OJZAdSCNrY2crj3t1vnyen4wZ6OPvAqi0l0zhtpPsoz5/iH48XnIuIUvTnwBwLzUeUxPmG5puuXsFtbkruGNA2/wjwv+4fRQ9pbsxYSJFG0KUYH2fS+KCzZnpDcUYTQZ2/ZvL+btg2/Tamplctxkzos+z6ptEkISGDFgBIfLD7Pp9CauGXKNi6P0YixFRm8ERQ9+5mbar3pQWNEekM615xZzvmw5/PfX0mqOkVdD/FjLU8Mjh7Mhf4MoONpPWJ+3nmW7llHcIP1e+XTDp8QExbB00lKXruDxBrz/DHsOL730EikpKQQEBDB58mR27drVY/tPP/2UYcOGERAQwOjRo1m1apWbInUPSdp2BUe9SUg3W7sYB6WQW5ULiIx0gUAg6O9Eh8VTLmsUxcUejcUtOJiRbhHSRUa6oBdycnK6/TvlTSsW+xLmBJHAutMoMPLHecOJ0QZ4OKg2z+20sDS3jivbuzit4Gj2BqgtgMBIKSvSQb7MliwQrk6/uqPIOOY6CEuSMi5//sDhcaxFqVBaxHPZ014AlGXDQUnQthQFdRUZN0GwDqrzqc56jw15ku/2gvQFHZotGi1lS6/JXeMST3tHbV0AooOiUSlUtBpbKW0odVZoLqO0odRy4eLO0XfatG3mQEmgW5/fj+1dSo/D6R1SDYGx11u1iTP2MwCGzZMEdJMBVt4LhlbLU6LgaP9hfd56Fm9ebBHRZUoaSli8eXGft1/yKSH9448/ZvHixTz++ONkZWVx3nnnMWfOHEq6KVq2bds2fv3rX3P77bfz888/c9VVV3HVVVdx8OBBN0fuOiRrF/MdbxLSzT/aymK1NBuaUSlUJIU5aZmnQCAQCHwSXbCOEtlxoj8UHHU0I93ska4L1jkrIoFA4CRMYUkYUBKoaOHSZAXXTfSO77knq6RkFtmD212khztZSP/ZXERvzHWg9neoq7yaPPYU70GpUDI/7RxfdZWmrZjl1uehtcWhsWxBtncRPunt+PFfgAmGXAqxo107liYQpt0DwKo9L9BibGFIxBBGDBjRodnQyKHMSpyFCRNvHnjT6WE4Q+BUK9XEBEkX3eUaCd7Me4ffo8XYwtjosTZbgFycLPmk7yzc2X+LWv5szkZPnw2hsb02bzW2srd0LwAZOvvsgzpw6d8hIByK9kureczIPvc5NTk0tjZ2s7HA1zEYDSzbtQxTFyW85cee2fUMBqPB3aG5DZ8S0pcvX86iRYtYuHAhI0aM4NVXXyUoKIi33nqry/bPP/88c+fO5aGHHmL48OH85S9/ISMjgxdffLHL9r5IUlhSW7HRU6fA1FU9ejdTUwNlZQCcCpceSgpLEt5/AoFA0M/RBeso7k9CurMy0oW1i8AKzpw5w8svv8zSpUtZvHhxhz+B8/l0bzFnjJINw/9NC7R+qbyLkbOb3W0VYslIr3KCkF5fBse+l26Pu9Hh7r48IWWjT4ufRmxwF6LTuJsk/9/q07D/Y4fHsxaLkC4y0iWq8qUihgDn/8E9Y064DQLC+VIpiX4L0hd0eSzLHt7fnvqWs3VnnTZ8g76Bw+WHAfv90WXkgqPe7pNe1VTFx8ek42zRmEU2nztTw1JJC0uj1djK/07/zxUhejcGPez7j3TbiiKjAEcrjtLY2kioX6jlXO0QITqY8zfp9uanoVy6gBsdGM2AgAEYTUbnXVQVeB1ZJVmdMtHbY8JEUUMRWSVZbozKvfiMstnS0sKePXt45JFHLI8plUoyMzPZvn17l9ts376904+HOXPm8NVXX3U7TnNzM83NzZb7NTXSVU69Xo9er3fgFdiGPFZvY8YGxZIbbr5TU4O+pAQiu6427jaOHUMDmKKiONIsfdFICUtx6/vnLKydB4HrEHPgHYh58A58fR4i/CPINgvphsJCjD74Oqyeg8ZGNEVSYTt9YiLY+FrrWupo0DcAEOkX6bNz7ip8/ViQcVb8GzZsYP78+aSmpnL06FFGjRpFbm4uJpOJjAwnZJ8JOlBS28RT3x3hBVMMyZQQZ/SODFC9Qc/p2tNAm0jrLmRxJr8mn2ZDM/4qB7LI9/0XjK0QPw5iRzkUV6uxlZUnVwKdLTssaAJg2r2w9jH4cblkleCGYmlCSD+Hrc9L8546CxInuGdM/1COZPyKI4Wr0JjgspRLu2w2JnoMU+Omsr1wO28ffJvHpjzmlOH3l+2n1dRKbHCspWCovcQHx7OHPRTUe7eQ/sGRD2hsbWR45HBmJszsfYMuuDj5Yk7uP8mG/A1ckXaFkyP0co6vgfpSyZZoyByrNrGsetCNd55//tjr4cCncGoTfHM/3PINCoWCYQOGsfXsVo6UH2FM9BjnjCXwKqy1j/IFmyl78RkhvaysDIPBQExMx6ysmJgYjh7tuphBUVFRl+2LzD9su+Lpp5/mySef7PT42rVrCQoKsiNyx1i3bl2Pz5e0lNDoB0UhEFsHWz/4gOrBg90UXdfEbd/OJKAqIoJ1P0nxq2pVPu1P39s8CFyPmAPvQMyDd+Cr81Clr6LWLKSf2Pojx+y0PPEGepuDkNOnuRjQBwWxavt2qwpBtaeoWfqu4qfwY8v6LV6T7ept+OqxINPQ0OCUfh555BH+8Ic/8OSTTxIaGsrnn3+OTqfjhhtuYO7cuU4ZQ9DGkysPU92opy4sEZoPQIV32Cvm1+ZjMBkI1gRbbB7cRXRgNGH+YVQ3V3Oq6pTFK9dmTKY22wIrsy174sezP1LaWEpkQCSzEmd133D8QqnIZcUpOPQljHZ9EUO5flROdY7PFIh0GbVFbcUTZ7opG93MF8HSRZ+L6usJz9sheUB3waIxi9heuJ0vTnzBnWPuRBfkuO2aXQUgu0HOSC+s844Le11R21LLR0ekIsL2ZKPLzE6ezYr9K9h6disN+gaCNO7XaTyGXMvhvF9J1lRWsLt4N+AEf/T2KBRwxXPw8lTI/QGy3oPxtzAicoQkpFcIn/S+SnRQtFPb+SI+I6S7i0ceeaRDFntNTQ1JSUlccsklaLVat8Wh1+tZt24ds2fPRqPp/gSpN+j5zeHfcCrcRGwdzEhIwDSv6w9/d6E8Ip00wzIy0Og0UAQzR81k3gzPxmUP1s6DwHWIOfAOxDx4B74+D63GVpa9dCsAScH+pHn488oerJ0DhfnisTo9nXmX2V4ob8eZHXAE4rXxXGbH9n0dXz8WZOSVj45y5MgR/vMfaam3Wq2msbGRkJAQ/vznP3PllVdy1113OWUcAaw9VMR3BwpRKRWMGzsedn4via9egJzZnBqW6vaLbwqFgvTwdHYX7+ZE1Qn7hfQzu6H0KKgDnSJmy7Yul6dejqYn0ck/BKbcDZv+KgnqIxeA0rXCdlJoEmqFmsbWRorriy1CaL9k2wtgaIakKZAyw23DNrU28Z25aOWCunr44VkYemmXF78nxEwgQ5dBVkkW7x56l4cmPuTw+E4rAAmWjHZv9kj/+NjH1OprSQ1L5eKBF9vdz9CIoSSEJHC27ixbC7YyO3m2E6P0YmqL4MRa6baVFxqNJiNZxZLFhqP2QZ2ISIEL/whr/whr/w/SL7H4pAshve+SocsgJiimW3sXBQpigmKc48fvpfiMkB4VFYVKpaK4uONkFRcXExvbdYGF2NhYm9oD+Pv74+/feSmiRqPxyA+13sbVaDTEhsSSE1HItDOgPn0aPP2DMi8PAOXgweRV/wjA4AGDffqHrqfmX9CGmAPvQMyDd+Cr86BBQ11kMFCPobjQJ1+DTK9zcFqyV1Ckptr1OsubywHQheh8+n1yNb56LMg4K/bg4GBaWqQiiXFxcZw8eZKRI0cC0qpOgXOoadLzf18fBGDRzFTiUoywE6j0jox0uWilu/3RZdIjzEK6I964cpHREVdCQJhD8ZQ1lrHlzBYArh58de8bTFoE2/4NJYfh2CoYfrlD4/eGRqkhWZvMyeqTnKo+1X+F9Ppy2G2ueXb+H2xeweUIG/I3UNtSS1yQjin6Uji7R7KqSLuoU1uFQsGiMYu4a/1dfHr8U+4YfQcRARF2j91iaGF/6X5AstxwFEtGupcK6Q36Bt47JB3fd4y+w6EVGAqFgsyBmbx7+F3W563vP0L63o/AZJAuOEUPsWqTk1UnqWmpIVAdaP8Fzp6Ychcc/BwKsmDVHxg+bxkgFZ7WG/VolL77HU3QNSqliqWTlvLA5gc6PadAOn8vmbQElRss0jyFz6wf8/PzY/z48WzYsMHymNFoZMOGDUydOrXLbaZOndqhPUhLgLtr76skahPbCo7meMEXebm4WloaOVVSPIMifHf5vkAgEAich36A9KPTVNy9zVqfwNFCo3XmQqPBotCooHemTJnCjz9KyQvz5s3jwQcf5KmnnuK2225jypQpHo6u77Ds+6MU1zQzKCqY32emQ6T5+62XWLucrJYKvrnbH11mcLhkL2m3kN5SDwe/kG47ocjoNye/odXUypioMQyOsML6MjBcEtMBtvxDsplxManh0lydrDrp8rG8lp2vgL4B4s6DwZluHfrLbGnFwlXpv0A5/lbpwS3Pdtt+evx0RgwYQWNrI+8fft+hsQ+VH6LZ0EyEf4RTLn7JGekFdQWY3LDv2srnJz6nsrmSxJBELh3UtRe9LWQmS/vKljNbaDG0ONyf12Mytdm62HB+lFc9nBd9nmtEbaUK5r8ASjUc/ZbE01mEakLRG/WWi7uCvkdmciYDQwd2ejwqMIrls5Zbjs++is8I6QCLFy/m9ddf59133+XIkSPcdddd1NfXs3DhQgBuvvnmDsVI77//flavXs0///lPjh49yhNPPMHu3bu55557PPUSXEJSWBI58sXwU15wsjopfRFsTR7ImZozQJsHoEAgEAj6Nyad5JenLC33cCQuRr6wbacPfHG9ENIF1rN8+XImT54MwJNPPsnFF1/Mxx9/TEpKCm+++aaHo/NdDEYTO3Mq2FOm4O1tuXy0Mx+ApxeMJkCjkpa1AzRVQUOFx+KUyamWzjueEtKHREgZkieq7BTSD30FLXUQMchhew+TycQXJyRR/up0K7LRZab8DjRBULgXTm7otbmjyAKqLxQcNRgN7C7ezb6Wfewu3o3BaLC/M6MBcsy+yttflh47/yG3ZqOfqT3DzsKdKFBw1eCrpIKzKj/I2wo7XoUDn0kxtnudCoWCO0ffCcB/jv6Hmhb77bmc6Y8OEBssrbpvaG1wKC5X0GJo4Z2D7wBw++jbUSsdN0YYEz2G6MBo6vR17Cjc4XB/Xk/eNqg4CX4hMNL6c5oz7YO6JXYUTP89AIrvH2JoeBrgensXp56TBDZxovIE+bX5qFDx7MxnCVWEAvDn6X/u8yI6+JC1C8B1111HaWkpf/rTnygqKmLs2LGsXr3aUlA0Pz8fZTsvu2nTpvHRRx/x2GOP8eijj5Kens5XX33FqFGOVX/3NhJDEzkQbr7j6Yz01laLtcuZaD+MJiMB6gBiQ7q30xEIBAJB/0ERI30e+FdUezgSFyN/HjuakR4ihHRB76S228+Cg4N59dVXPRhN32D1wUKe/OYwhdVNgApOHAdgxuAopqQOkBr5BUNILNQVSfYuQZEei9doMpJbnQu0ZTm7GzkjvaShhOrmasL8bbRmsRQZvdFhQXVv6V5ya3IJVAcyN8WGgrvBUVLh0R0vSZnJLs6Qli96yBdBvJX1eetZtmuZxRP30w2fEhMUw9JJS20XTQ6vhNVLoKag7TGlGoxGJ0bcO19lfwXA5LjJxIdI2dwkT5esXVYvaWuojYe5z8CI+QBcOPBCBocPJrsqm/8e/S93jrnTrvGdLXAGqAOIDIikoqmCgroC248/F/JV9leUNJYQExTD/LT5TulTqVBy0cCL+PjYx2zI38D5iec7pV+vRT4/jrxaqulgBSaTyT1COkgXwg5/DeUnGF5Tym7gaMVRlw3n1HOSwGbkC9UXDryQi5Iu4m312xzSH+Jk1UlmJLivzoWn8KmMdIB77rmHvLw8mpub2blzpyX7BmDz5s288847Hdpfe+21HDt2jObmZg4ePMg8Hyxs1htJYUmckjPSc3Pd/iWkA2fOSGK6nx/ZgY0ApISnuL3gkUAgEAi8k4B4aRmgX0MzNDR4OBoXYTK1rRCzMyO9pKEEEBnpAttoaWnhzJkz5Ofnd/gT2Mbqg4Xc9UGWWUTvyNbsMlYfbOdB7CX2LgV1BTQZmtAoNSSEJHgkhhC/EIu9hM32LmUnIH87KJQw9nqHY5GLjF6SfAkhftaJThbkzOT87ZC71eFYekIW0r05I3193noWb17cqbBcSUMJizcvZn3eeus7O7wSPrm5o4gOYGyFT2+RnncDBqPBIqQvSF/QFtupzZ0b1xRKMZtjUyqU3DH6DgDeP/w+DXrbv8sYjAZ+LvkZcG4BSIu9S31BLy3dh96o562Dkgf+wlEL8VP5Oa1v2Rt9U/4mWo2tTuvX62iqkVbsAGTcbPVmZ2rPUNpYilqpZnTUaNfEJqMJkCxegOFn9gFwpNw1GelOPScJbKbF0MK3p74F2lZ8xaik3ysO1UjxIXxOSBd0JlGbyBkttCqBlhYo9GCBEbOtC4MGkVMtZaYLWxeBQCAQyGijEmiSa8+UlHg0FpdRUQG1tdLtlBS7uhAZ6QJbOH78ODNnziQwMJDk5GQGDRrEoEGDSElJYZCdF3P6KwajiSe/OUxPDsNPfnMYg9HcIsI7hHRZiE0JS3GKbYK9pEekA3bYu8jZloNnSxnADlCvr2d17mqgnUhqC9q4Ng/iLf9wKJbeSAlLQYGCquYqKpo8bw90LgajgWW7lmHq4oiQH3tm1zPWWSoYDeZM7x6OrtVLO1ipuIrthdspbihG66flooEX9RKbqVNsc1LmMDB0IFXNVXx6/FObxz9WeYx6fT3BmmCGRgy1/4Wcg6XgaJ33FBz9Pud7ztadJTIg0r7jsQfGx4wnzD+MyuZKsoqznNq3V3Hwc2hthKihkDjR6s12F+8GYHTUaALUAa6Kro3kqTDhdoY16wEpI91ocm6Sp1PPSQK72HR6E1XNVegCdUyLnwZAjNIspNtr7eZjCCG9D5CkTcKggoII85dmT/qktyuuZik0KoR0gUAgEJjRhcRQEmy+01eFdPmzMD4eAuz74SJ7pOuCdc6KStCHWbhwIUqlkm+//ZY9e/aQlZVFVlYWP//8M1lZfVhccAG7ciq6zESXMQGF1U3syjGLnpFmG5VKzwrpnvZHl7EI6bZkpRn0sPc/0m0nFBldk7uGxtZGUrQpjNONs6+T6feDQiXZfJzZ43BM3RGoDrTYinhjYb6skqxOWZ/tMWGiqKGIrBIrzjN52zpnop/TGzVnpXYuRl6xcHnq5fir/G2OTa1Uc/vo2wF459A7NBuabRpfFn3H6cahUqp6aW093paRbjAaeH3/6wDcMvIWAtWBTu1frVRzYdKFAKzP78NZyHbaXrnN1qU9mU8wKFCHv9FIQ2sD+TXOXRXn1HOSwC7kIs1XDr7ScuFezkg/WXWyX1zEEEJ6HyBRmwhAtta8w3rSJ10WD9LS2oT0CCGkCwQCgUBCF6yjWF5l31eFdAcLjUK7jHRh7SKwgr179/Laa69x6aWXMnbsWM4777wOfwLrKantXkTvsp2XWLucrJJWhXpcSA+3Q0g/sQ7qSyAoCobY4GfeDbJ361WDr7LfXjIiBcZcJ93+4VmHY+oJb7Z3KW0odV67uu7FL7va2UllUyUbT28E2q1YsCO2K1KvIDY4lrLGMr468ZVNMbhK4JQz0ovqi5zar72sz19Pbk0uWj8t1w29ziVjyPYuG/I3OD372SsoPgxn90h1BM77tU2bekRID9Civmw5Q1rMWeknVzu1e6eekwQ2U1RfxLaz0gXFqwe3Fb2NVEYSoAqg2dDM6drTngrPbQghvQ8QHxqPAgWnws3LWzwppMvWLqmp5FSKjHSBQCAQdEQXrOs/Gel2Fhptam2iulkqxiqsXQTWMGLECMrKyjwdRp9AF2rdKhJLOzlhxMMZ6bII63Eh3ZyRnl2VjcnUk0FOO+Rsy/N+BWrH/JNPVZ1iX+k+VAoVVw6+0qG+mLkYUMCxVVB00LG+esCbhfTooGjntbP288zFn3vfnvqWVmMrwyOHMzRyqG1j7v8YqiSRSKPSsHDkQgDeOvgWeqPeqi5cWQDSkpFe5/mMdJPJZMlGv3H4jQRrgnvZwj4mx00mWBNMSUMJB8oOuGQMjyKfH4fMhRDrjkeQVjaeqTuDUqFkbPRY18TWHUPnMjxESvY8kvWGtOrISTj1nCSwma+yv8KEiYmxE0nSJlkeVyqUls+y/mDvIoT0PoBGpSE2JLat4Kg3ZKS3t3YRGekCgUAgMNNBSC92bdaZx3AwI720Xsqi0Sg1RARE9NJaIIBnnnmGhx9+mM2bN1NeXk5NTU2HP4H1TBoUSVxYAN3lMSuAuLAAJg2KlB6QM9JrC6HFMwWUTSaTRYQdFObZ792yR3udvo7Ceit8mmuL4Pga6bYNRfS6Q85Gn5k4k6jAKMc6i0qHkVdJt3/4p2N99UBquFlI90JrlwxdBrqg7i3GFCiIDYolQ2dFwczkaRAa10MDBWgTpHYuwmQyWfaRDn7dydPM3vy9rGA4sRZeyIDvl0BtMQvSFzAgYAAF9QV8d+o7q2LIqc6hsrkSf5U/IweMtPOVdI1sE2TVseditpzZwrHKYwSpg7h+uOMFhLvDX+XP+QnnA7Ahb4PLxvEIrc2w77/SbRvPj7K1ydCIobYXXHYCw0bfBMCR1irY9oLT+s3QZRCi6f712HROEtiE0WS0FGlun40uMzh8MNA/Co4KIb2PkBSWRI4XCekNA+MoqZcyDUVGukAgEAhk2gvp+qKzng3GVTgopLf3R7fblkDQr8jMzGTHjh1cfPHF6HQ6IiIiiIiIIDw8nIgIcTHGFlRKBY9fMQLoLKnJ9x+/YgQqpfleUCQEhEm3K3PdEWInypvKqW2pRalQkhKW4pEYZDRKjUXMt+rH9L7/gMkAiZMg2rGii3qjnm9OfQPAgsFOKmo48w/S/0NfQplrxAFvzkhXKVUWD+quMGFiyaQl1vl8K1WQ0F0Gtvl4mrtMauciDpYdJLsqG3+VP/NS53WMbe4zHWPpEJsCLvoTpMwEQwvsfBX+PZaATU9zy5BrAXjjwBtWeQPvKZGy0cdEj8FP5dgKjHOJDY4FoKKpgsbWRqf2bQsmk4kV+1cA8KthvyLMP8yl42UmZwKSlYzVK2F8gWPfQ2OFdAEq7WKbNvWIrUs7hsdLRVGP+vlh2rwMyk86pd+C+oJeaxJYfU4S2MSuol2crTtLiCbEcsy1RwjpAp8jUZtITrj5jqeKjVZWSn9Abrj0BSTMP4yIQPEDTiAQCAQSoX6hlIdKX25bCs54OBoX4aC1i+yPLgqNCqxl06ZNbNq0iY0bN3b4kx8T2MbcUXG8cmMGsWEdbV5iwwJ45cYM5o46J6vWw/YuciZzYkiiVDjRw1h80ntb3m0ywc8fSLczbnJ43C2nt1DRVEFUYBQzE2c63B8AsaNgyKWACX78l3P6PAf5wkNxQzH1+nqXjGEvrcZWthdsB+gyCzQhJIFZSbOs66xgryQMAgRGdnxOGw+/fA9GzLc/WCuQi+RlJmei9dN2fHLEfCkG7TnHtxzb+Q/Crd/CzSshcSLoG2Drc/xyzTLClH7k1eSxNm9trzG4UuDU+mktFiqezErfUbiD/WX78Vf5c9MIx4/t3piRMAN/lT+na09zvPK4y8dzG7Kty9jrQaW2aVN5P5sQM8HZUVlFekQ6KoWKSpWKYlph5X1gdMzD3mQy8eftf0Zv1DM4fDAxQR0tmUI0ISyftbxLkVfgOHKR5nmD5nVZONjqz/4+gG1Ho8BrSdIm8aOsV589C83N4O/mL9KycBATwym9JAKkRnjWp1EgEAgE3oVCoaA5MgyooLXI8x6eTsdggLw86baDGenCH11gLRdccIGnQ+hzzB0Vx+wRsWzPLmHtDzu5ZOZkpg7WtWWitydyEBTuhQrPJLN4iz+6TFp4GgCbT2/mvOjzyNBldJ0dmL8DyrNBEwwjOy8Tt5UvsiXLjivSrkCtdOLP3PP/AMe/l/yxL1gCEcnO6xsp8SgqMIqyxjJyqnMYFTXKqf07wprcNeTX5hPuH86qq1dxsPQg67avY3LGZJ7c+SRn687y7qF3uX307T13ZGiFlfdKqw9GXg2/eBPytknFO0NiJGsVF2eQNrY28n2OJOR3u2JhxHwYdlnPsaVeAIPOl2xeNv6F4KID3FAOL0eEs2LH08yJn4nSv91FB6PB0p8pWMfuot0A9llPGA0o8n4koWI7ijwtpJ7fITaFQkFccBzZVdkU1hW69ZxgMBrIKsmitKGUtw6+BcA1Q65x3GLJCoI0QUyLn8am05tYn7++zfvel6k+A9lmq5qxN1i9mcFoYMuZLWRXZQPSygdP4K/yJzU8lROVJzgSFEps3o+w522IGmL3cf/1ya/ZUbgDf5U/z1/4PAkhCewq2MWKLSvYrd9NZEAkFw+0LXPfF2h/bEUHRXf/mepCqpurWZ+3HjjHFqvdOSmpdioA+TX5NLY2dim29xWEkN5HSNQmUhIMTf4qApoNkJ8P6enuDUIW0tPS2gqNCn90gUAgEJxDa/QAoAJFSamnQ3E+Z85Aayv4+UF8vF1dyBnpMcFCSBd0z/79+xk1ahRKpZL9+/f32HbMGM/8kPZ1VEoFkwdFUn7ExORBkV2L6ACRZrGqwjMZ6SerpCXz3mCnuD5vPe8flrIo95Xu47Y1txETFMPSSUs7ZwnK2ZYjrwb/UIfGLa4v5sezPwJde7c6ROIESJ0FpzbD1ufh8uXO7R/pIkhZYxknq056jZBuNBl548AbANw04iZC/UOZEDOBEr8SLhp4EU2mJh7b+hiv7HuFzORMkrU9XGDY/gIU7YeAcLj075J4NshJqwasZF3eOur0dSSEJDAhtocsXWtiUyhgyBwYPBuOfM31m57iXWMj2S2VbH5tAhdNXgzjb5H8/1cvgRopcaBAraI4KQG1Qsl50efZ9gIOr4TVS1DXFDABIO8VKVt+7jMdMvnjQ+LJrsqmoN59yQrr89azbNcyihs61r6RL6q5g9nJsyUhPW89d4+9223juoy9HwEmSJ4BA6x7H7uah19/9+uuz79uYHjkcE5UnuDo0Iu4cPcX8N2DQDvrnS723+4oayzjHz/9A4Dfjf0dA7UDASnj/nTQaQ7VHyK/Np+skiyP2dm4gq7mtNvPVBeyKmcVLcYWhkQMYcQAyf6uq3NSZHISFUpppdzIKOfWgPAmhLVLHyFJmwQKKIgyZ6F7wif9pNn3qn2hUS/4Qi8QCAQCL0MnWZaoyys8HIgLkD9/k5NBZV+2iCUjXQjpgh4YO3YsZWVlltvjxo1j7Nixnf7GjRvn4Uj7AR62dsmplsb1dEb6+rz1LN68mKrmqg6PlzSUsHjzYks2GwBNNZLvODjF1mXlyZUYTUYydBmuKbh6/kPS/5/fhxrnW2bIMXuTT/qm/E1kV2UTqgnl18N+3en5+WnzmRo3lWZDM09uf7J7b+ryk7B5mXR77tMQ4hnbMrnI6NWDr0apcJIMolTCyKsJ+91OfhU7HYDXA4yYvn8Ilg+HT26yiOgAWQHSb/URjY0EnVjfZZddcnglfHJzh74AaV/85GbpeTNxwZI1TWGde6xd5OP+XBEd4C/b/9LxuHch5yeej1qhJrsqm9zqXLeM6TKMxrYLjVaeH7ubhy7Pv25ieORwAA4b6syPnHOO6GL/7Y5lu5ZR01LD8Mjh3DyiY+FVf4U/lwy8BGg7zvsC3jSnsq3LgvQFUv2mbs5J6c2Sf/3xQ5+4LTZPIIT0PkKiNhGAnHDzyckTQno7T1ghpAsEAoGgOzRxCQAEVNY67JfodTjojw5YinULaxdBT+Tk5BAdHW25ferUKXJycjr9nfJU7Zz+RKT5+66HMtK9wdrFYDSwbNcyTOcKJWB57Jldz7QVYzz0heQxPSAdkiY7NLbJZLJ4X1+d7uRsdJnk6ZA0RSo0uf1Fp3fvbQVHTSYTKw60FYsM9eu8YkChUPCnqX8iUB3IT0U/8fmJz7vqCL65H1qbIPVCOK+zIO8O8mry2FO8B6VCyZWDr3T+AEoVN816mgCVPwf9/dkeEQ8N5Z2a7QmQ6i6Mb2qGVQ9J54yq/J7/KnJg1R/oJEJC22Orl0oWMkgZ6YBbMtJ7Ou5lOhz3LiTMP4zJcdK5ZH2++0Vjp5K7RZp7fy0M7z1b2+bzr5sYFjkMgKPlR7pp0Xn/7YpN+ZtYk7sGlULFk9Oe7NK666q0qwDzypOWuk7P+xreNKdHyo9wpOIIGqWGywZdJs3V6iV0dU4a3KIHIPvIZz3Oqa8jhPQ+QlJYEgBHQswVjD3xo0lYuwgEAoHACgJjpc8spdEE5Z1/aPo08oVsO/3RoS0jXRQbFfREcnKylBVkvt3Tn8DFyNYuVflg0Lt16NqWWkobJZssl2RiW0lWSVaXGakyJkwUNRSRVZJl3qBdtqWiG8scK9ldvJvTtacJUgdxSfIlDvXVLQpFW1b67reg3rmfXanh0j4kry7wNFsLtnK4/DCB6sAei0UmhiZyz9h7AFi+ezklDSUdG2S9C7k/gCYIrnjO4bm2Fzmbclr8NGKDY10yxoDAAVwz5FoAVgzs2qN7j7mGWUZTM9QVwb/HwnOje/7791jJU7pbTFBzVvJhB+KDJSHdHRnpNh/3LubiZMkfe0PeBreM5zLkIsyjrwG/oF6be9s8yMhCepFKQaWyO+mx4/57LrUttfx1x18BuGXkLQwfMLzLdmOixjAobJBUCyH3e4dj9zTeNKfyheqLBl5EeEC4NFfnro4xk97SAsAJmrud076AENL7CHEhcShQcDLcnNnnQWsX06BBnKqURHWRkS4QCASCc4kKi6Ncrj9TUtJjW5/DGUK68EgX2Eh5uwtSp0+f5k9/+hMPPfQQP/zwgwej6keExII6QCqkWH3arUPLGcy6IF2XWcPuorTBupoXpQ2lUHIEzu4GhQrG/MrhsWWR9NJBlxKk6V10spvBF0PcWCmTfsfLTu06LUzyQD5de5oWQ4tT+7YVk8nEiv1SNvq1Q64lIiCix/Y3DL+BUQNGUauv5W87/9b2RE0hrP2TdPuixyAixUUR90yrsZWVJyXriA5F8lzALSNvQaPUsKfmpEU0lylTKcn106AwmRjX3CQ9qNSAOrDnP6XGusHN3x3iQszWLvWuF9JtOu7dwIVJF6JAwcHyg26ztnE6jZVtVifjbrRqE2+bB5kQvxAG+kcCcMTPr+fG3Vwsem7Pc5Q0lpCsTeau8+7qdnOFQmEpIvzVia/siteb8JY5bTY0892p74B2RZp7uLCXrpeSCU5o/Hq5AOjbCCG9j6BRaYgLjSMn3PyAu4V0vV4qcApUxkdQ21ILQEp4invjEAgEAoHXowvWURxsvtPXhHQnWLtYPNKFtYugFw4cOEBKSgo6nY5hw4axd+9eJk6cyL/+9S9WrFjBhRdeyFdffeXpMPs+SmWbSOhme5dTVZ63dQGIDoq2vp2cbTlkLoQ6dp6rballXd46wIW2LjIKBZz/B+n2rhXQWOW0rqMCowjVhGI0GcmryXNav/awu3g3P5f8jJ/Sj1tG3tJre5VSxRPTnkCtULMhf4NlPlj1B2iuhvgMmPxbF0fdPVvPbqW0sZQI/whmJc5y6VixwbFcNfgqAF4P13Z4LsssrKe36Akzmi0RbvoSHivq+e+mL60b/PgaaKy0eKSXNJTQamx1yuvqDpuOezcQFRhFRkwGABvyfTQr/cBnYGgG3Ujp2LECb5uH9gzXpgBwxL+XC0JdfOfdXbSbT45LXtuPT32cAHVAj11cnnY5aoWa/WX7ya7Mtiteb8Fb5nRD3gZqWmqIC45jSvwU6cEefp/I1i5lahWVx1ZBU7VL4/MUQkjvQyRqEzklJwy4W0jPz5d8bgMCOBXQCEBsSCyBmsBeNhQIBAJBf0MXrKNEFtKL+1i2goMZ6a3GVsrNvqoiI13QGw8//DCjR49my5YtzJo1i8svv5zLLruM6upqKisr+c1vfsOyZcs8HWb/QLYzrHCvvaI3+KMDZOgyiAmKQUH31h3h/uFkRI6Cff8xb+R4kdHvc76nydBEWlgaY6LGONxfrwy9DKKHQ3MN/PS607pVKBSWlbwnq086rV97eH2/9LquTr8aXZB1FmNDI4dy2+jbAPjbzr9Rvf+/cPRbUKph/gugtK/4tjOQiw9ennY5GpWV2d0OcNuo21ApVGwNCuSgX1tWegd/dBSgTYDkab13mDwNtPHSNj1x4BN47jyidr2DRqnBYDJ0ttpxMr0d9woUxAbFkqGzThB2BpkDMwEf9knPek/6b4PtlTwP3eGJeZAZljgDgKN+/t206PpYkIsYA/wi/RdMjJ3Y61hRgVGcn3g+AF9k+3bRUWs+U90xp/L7eNXgq9qKNMdngKrr+QwymUiUs9Kzv4XnxsAP/4SWepfG6W6EkN6HSNImkSML6eXlUFPjvsHNti5SodFcQNi6CAQCgaBrOgjpfSkjvaEBioqk23ZmpJc1lGHChFKhJCooyonBCfoiP/30E0899RTTp0/n2WefpaCggN/97ncolUqUSiX33nsvR48e9XSY/QPZJ70y163DeouQrlKqWDppKUC3P/xrWmrYuvsFqQhjSCwMnu3wuLKty9XpV1tqBrgUpRJmPijd3v4yNDuvqJ08hzlVnvNJP1B6gO2F21Er1CwctdCmbe8ccycp2hTKGstYvu3P0oMzHoDYUS6I1DrKGsvYcmYL0M6WwMUkhiZyWeplALweHoosgO8JMPujN5trms1dZt0FBqUK5j5jvnPuPq6Q/qb/HnQjoLka5eaniG2Rxihwsed+++P+XOTzwJJJS1C58ULKxQMln/Ss4izKGsvcNq5TKNwHRftB5QdjrrN6M5VSxeLxi7t8zlPzIDN8wAgAjvpp6PpikKnLY+G1fa+RW5NLdGA0iyd0/dq6QrZv+vbkt+jdXLPEmfR0bMm4ek7P1J5hZ+FOFCjaijS3tsDnt0urJrpEQbo5K/1EZCI0VcGGP8Pz58GOV0Df5LJ43YkQ0vsQidpE6vyhXmvOAndnVnq7pezylz9RaFQgEAgEXdFeSDf1pYz03Fzpf1gYRPTsKdsdsj96VFCUR37wCHyLiooKYmOlwnkhISEEBwcT0W7fi4iIoLa21lPh9S8i5Yx0D1m7hHtWSAfITM5k+azlnbKYY4JiGBc9DqPJyAMnPmB7gD+M/TWo1A6Nd7zyOAfLD6JWqLki7QqH+rKJkVdLKxAaK2DPO07rVhbS5YsjnmDFAckb/bLUy0gISbBpW3+VP09OkzJIvwhUsVOXBjP/4PQYbeGbk9/QamplTNQYBkcMdtu4t4++HQUKNgYHcTwijhqlguN+Ujb8eHUE/PI9GDHf+g5HzJe20cZ1fFwbLz0++0n47Vb4xZsQmUa8XvLZL/zyDvjpDUn8chHyca85x8s9JiiG5bOWk5mc6bKxuyIuJI5RA0ZhwsSm05vcOrbDyEWYh10GQZE2bVrZXAnQljVsxlPzICMXHM3101B/7v4LgALCEjs8cqziGG8ffBuAP075I1o/bRfbdc30hOlEB0ZT2Vzpe/N/DpnJmdyXcV+3z/eUre4Mvsr+CoDJcZOlzwNDK3xxBxz/XqoLM+sR82qZdmjjSR88D4ATIy+Hq1dIn5f1pbB6KbyQAbvfdnthdmfj2LcXgVeRpE0CoCg6kLSaRklIP+889wwuZ6SnpZFTaRbSRUa6QCAQCLogOjia4hDpdnPhaXp2PPQh5AvYTvBH1wVbt5xeIDg3C9ctWbmCzsgJJJXuEdINrS3s2PcWZ+rOADAwJLGXLXrBaIC8bVJxsJAYaZm9HRfzMpMzuTDpQrJKsihtKCU6KJoMXQZGjDy0/h42FG7jvphoXkkaxwTHIrZko89KmkVkgG2ik0Oo1DBzMay8F7Y+D7rhUoFAB943gJTQgQDsPbuNn35+k4zRN6FS91KgrydsnNNjFcfYfHozChTcMfoOu4bMqK/luppaPtaG8uSAcD5XmPCU0afJZOLL7LYVC+4kNSyV2cmzWZu3ltfPu4yhCn9MuSuJ8Qsn8t4NYM+8jpgPwy6j9dQW9v6whrEz56BOPb9tTpVKGH0NjLiKuO9uhsoDFLTWwXcPSvvpBUulLOf2F7CcdNxfkHQBmG3f/zDhD4wYMIIMXYbHEgIuTr6Yg+UH2ZC3gWuHXOv8AYwGFHk/klCxHUWeFtrPgx19kbdNKlS99yPpMSuLjMq0GFp46+BbADwy6RHSwtM6nH89mZgxIHAAuiAdJQ0lHLv+fTIaG9v2t91vw6HPpXPpnZtBpaHV2Mrj2x6n1dTK7OTZlhUG1qJWqrly8JW8ceANvsz+kktSLnHNC3MTeqMkOI+PGc8vh/yS6KBotp7dypsH3+SpnU8xMW6iTRcarMVgNPD1ya8Bc5a/0QBf/w4Ofy2tmLjuQ0jPhPMf6nROSs9fB4WbOVF1Eqb/GUYtgL0fwv/+DjVn4dvfw9bnJCF+9LUdjx0nnZNcjchI70MkaqUv0HkR5mn1dEa6ENIFAoFA0AV+Kj/qwqWf1vrCMx6OxonIn4V2+qNDW0a68EcXWMutt97KggULWLBgAU1NTfz2t7+13L/tttvs6vOll14iJSWFgIAAJk+ezK5du3psX1VVxd13301cXBz+/v4MGTKEVatWOdSnz9E+I91kculQ6398mjnvZfDbgy9ZHrvhk9ms//Fp+zo8vBKeGwXvXi4t2X73cun+4ZV2dadSqpgYO5F5qfOYGDsRlVKFRqnh7/6DmNHQSJNSyd27/8a+0n32xYskHH1z6hvA/SIpAGN+BYEDoL4EPljg8Pu2/sen+fPG+wEo0tdw2/7nmPNehlvn9PUDkjf6nJQ5pISl2D5mSwN8cx+/r6giRunP6aZSXtn7in3xO4F9pfvIqc4hUB3I3JS5bh9/0ZhFAKzOW8PzudL7XtxSxZwv57E+z07/bqUKU/IMzkZOxZQ8o2uBSaUmfuBMAApTpkliVFW+JIK9PAUOfi7VNnPicX+88jh6kx6tn5abR9xsOe49heyTvrNwJ9XNTi52aH7f1B9cxYS8V1B/cJX958v2c/DVXaCvB4XKZsuolSdXUtJQgi5Qx4L0BZ3Ov55mRKRk73Kk8hgMmild8Bk0E+b9HQIjofigdLEH+PDIhxwqP0SoXyiPTn7UrvHkgr/bCrZRVF/klNfgKbad3QbA5amXW+b0rrF3kaJNobSxlOW7l7tk3B2FOyiqL0Lrp+WixFmS+L3/Y6nuxbXvSCI6dHlOGhI+BIATVScwmoyg0sD4W+HeLMmmKjhassH78jfwyjRJnHfyOcnVCCG9D5EUJmWkHwszL93ytJAurF0EAoFA0A0tA8KBPmbt4mChUWjLSI8JEUK6oHduueUWdDodYWFhhIWFceONNxIfH2+5r9PpuPnmm23q8+OPP2bx4sU8/vjjZGVlcd555zFnzhxKuqln0NLSwuzZs8nNzeWzzz7j2LFjvP766yQkJNjdp08SPlASQFobodZ1P9zX//g0i7M/pPicX3ElSlic/aHtwuvhlfDJzVBT0PHxmkLpcWf9gDUa8dv7H/5VUsbkkGQaWhu4a91dHC4/bFd3G09vpLq5Gl2Qjunx050Toy0cXw2N5Z0ft+N9k+e07JzFJO6c05zqHNbmrgWwOxudzU9DZS4hofH83/S/APDu4Xc5VH7Ivv4cRC4yOjt5NiF+IW4f/0xt14kCJQ0lLN682H4x3QriQiQLjcLgcLhvL8z+MwRGQPkJ+Ow2eH4MfHKT0477A6UHABgdNdorVkWlhKUwOHwwraZWi0e+U3Dm+bK7vkwG+PRWq/tqNbby5oE3Abh11K34qRxYxeIihg2Q7F2OlB/p+ERwlOSPDvC/v3M67wde/PlFAB6a8BBRgfbVCkrWJjM+ZjxGk5Gvs7+2O25PU9NSw4Ey6diaFt9WjNVf5c/jUx8H4PMTn/NT0U9OH9tSpDn1cvzX/UkqgqtQwoLXJeuhHhioHYif0o/G1kbO1p1te0ITAFN+C/fvg4sfh4BwKD0qHQf/HuvUc5KrEUJ6H0LOSD8QZL6C6S4h3WSyWLsYUweRK4qNCgQCgaAXTDrJukRZ2oUQ4au0u6hsLyIjXWALb7/9tlV/trB8+XIWLVrEwoULGTFiBK+++ipBQUG89dZbXbZ/6623qKio4KuvvmL69OmkpKRwwQUXcF47e0Fb+/RJVJo2n1cX2bsYWltYdvxDyUHhHLHKZL7/zPEPMeibpe/nvf0ZWmH1EiyeDB17lP6tXiottXaUvB+hMpcATQj/vvQdMnQZ1Opr+c2633Ci8oTN3X114isArky70v0Zl0aD+X3rinbvm6G11zkw6Ju9Yk7fOPAGJkzMSprF0Mihtr8nBT/DdkkA47LlXJB6KZemXIrRZOSJbU9Y7AncRb2+ntW5q4G24oPuxGA0sGzXsi6fM5nn4Zldz2BwxrHVBfHBkm9xQV0B+AXB9Pvh/v0w61HwC5VsRLqJDrD5uJfFvtHRox0J26nInuBOu2BhOe57ObasOO57Pk5p68uKOfg+53vO1J0hwj+CX6T/wp5X5nJkn/SjFV0UPx/zS0i7GJOhmSc3PUCToYnJsZMtWeX2Ih/3X2Z/KWVF+yC7CndhMBlI0aYQH9LRi3xC7AR+OeSXADyx7QmaWp1XxLOyqZKNpzcCsKCsEHatABRw5cuSTUsvqJVqS92WLj/f/YIle7Tf74cLloAmGKryuunNyd9FnITwSO9DxIXEoVQoyQ4znyjkH/SuprwczIWsCgf402JoQaVQWTLkBQKBQCA4F2VMLLAPv4oqT4fiPJyQkV7SIGXoCiFd4AlaWlrYs2cPjzzyiOUxpVJJZmYm27dv73KblStXMnXqVO6++26+/vproqOjuf7661myZAkqlcquPgGam5tpbm623K+pqQFAr9ej17tPlJPHsmZMVUQKyqo8WktPYIqf6PRY9ux/h2JV99meJoWCIhVk/TOJiU3N3bazHhPUnKX11BZpybYDqPa8ixIwjLwajSaM5y54jt9t/B0Hyw9yx9o7eCPzDVK0Kd1u334eCusL2VYgLXe/YtAVbt0fABR5P6I+N2uuA9L7xl8G9NpXVoA/xXHdn+/dMacFdQV8d+o7AG4bfluP72eXx4NBj/qre1CYjBhHXI0h9WLQ63kw40G2FWzjaMVR3t7/NgtHLnRC/Nax6uQqGlsbSQ5NZnTEaLfvI7uLd1Pc0P2KOxMmihqK2FWwiwkxtlULsOacFB0QDUBRfREtLS1SlrgqEKYvRhE1HPVnN/Uwgu3H/f7S/QAMDx/u9ve6O2bFz+LVfa+ytWAr1Q3VBGmCHOrPmcd971g3B0aTkdf3S5ZMNwy7AQ0ar3n/25OuTQfgZNVJ6pvqO2fNX/os375/MTsVzQQo1Dw68VFaW1ut6ru742FW/CxCNCGcrTvL9jPbmRQ7yfEX4mZ+OPMDAFNip3Q5r3ePuZvNpzeTX5vPSz+/xH1juy9Magtfn/iaVmMrwzURDP3pXQBaL30W08hroIs4upqDVG0qRyuOcqz8GDPjZnY9kCoIZjyEInok6s96Wj3pvO8iPWHLsSOE9D6ERqUhNiSWnAjzCT43V7ri6erlVbJgn5BATrO0lDUpLAm1UuxeAoFAIOgavzgpc9OvoRkaGiDIsR84HsdkcmpGuig2KvAEZWVlGAwGYmI6CnsxMTEcPdpFJhlw6tQpNm7cyA033MCqVavIzs7md7/7HXq9nscff9yuPgGefvppnnzyyU6Pr127liAPnC/WrVvXa5sxtSoGASd/Ws/Rs+FOj+F0xQ9WrScuVTk3Q3vvD2s4e6jG7u3VrfXMPSQtr/+xfhBVZv/8K41XUq4qp7CpkFu/u5U7Qu4gUtVz0dB169axsWkjJkwMUg9i/5b97Ge/3bHZQ0LFdocLpcpYO1eunNOVDSsxmAykqdPI35VPPvm9bt/+eEgv+oYRJQdpUQWzQXkxLe3qI2SqM/m85XNe2fcKqlMqolT2WTXYyju17wAwVD+U77//3i1jtmdfi3X+/+u2r6PEzz6Lq57OSa2mVhQoaDI08el3nxKibLO2sXb/tfa4bzQ2kluTC0DRz0Ws2req5w3chMlkIlIZSYWhghe/e5FRfqMc6s+Zx7219DYHh1oOkdOQQwABhOeGsyrPO977czGZTAQqAmk0NfLud++SoE7o8HytsZYXIsKBVn5bUcmJDf/jgJ9tBaS7Oh6GK4bzEz/x8g8vUxZc5sArcD8mk4mNNVJWuOashlUlXc/tbOVsPuRD3jv8HkH5QcSr47tsZ8u4H9R+AMCCQsl14kDCjZwqioZVPe9f7efA0CRlj285soX4/J5jcvY5yV4aGhqsbiuUzj5GkjaJn8MKMCkUKBoaoKQEYlyc1Wa2dSE1lZxKUWhUIBAIBL2jjUqgSQUBBqTPqpQUT4fkGOXlUGe2VktOtrsb4ZEu8DWMRiM6nY4VK1agUqkYP348Z8+e5R//+AePP/643f0+8sgjLF682HK/pqaGpKQkLrnkErRarTNCtwq9Xs+6deuYPXs2Go2mx7bKHadgw0bSB6hInTfP6bHs2V/Mawf39toucvrD6Ef8qtd2itM7UX9+S6/txg1P5bzx9r8e5e63UB3QY4oexrRr7umQ5HNR00Us2rCIU9Wn+I/xP7xx0RvEBcd16kOeh4szL+bl718G4LaJtzFvkPPf595Q5Gkhr/cimq2/eBdT0uQe20Qe/i+c6N3iyOlzmhLBedMvpbSxjCdXShesls5aynjd+B6363Q8lGejfl3yrlXO+zuZY67r0P5S06Wc3XSWHUU7+CHwB167+DWUCte6y56qPkX+d/moFCoevPRBogOjXTpeV+iKdXy64dNe282eOtuujHRrzkkvffkSpY2ljJw6kpEDRloet3b/HTt6OOed1/vxtb1wO2yCxJBErr38WutehJs48fMJ3jvyHlXRVcyb7ti5wpnHvbXH6diZczivmwxck8nEB6s/gAa4adRNLBjjfgsjW/h247fsLNrJgBEDmDe441w8/MPDNNS0MsKo5paqSpTR32O48gOrEkJ7Oh4Glg3k5rU3c9RwlBmZM9D6ue+7g6Pk1eRR9W0VaqWa3172WwLVgV22m8c8Sn4sYV3+OjZqNvLenPccSmg9VH6I4jXF+BuNzKuvx3Dhnxg27T6G9bBNV3MQVhDGms1raAhqYF4v34esPif1cDw4A3nlozUIIb2PkahNZKd6J3XRYYSWVEnLzF0tpHdVaFQI6QKBQCDoAV1IDMUhkFxN3xDSZVuX+HgICLC7G+GRLvAkUVFRqFQqis8pAlxcXExsbGyX28TFxaHRaFC1y5gdPnw4RUWSpYA9fQL4+/vj7+/f6XGNRtOroO0KrBo3ajAAyqpclC6IccKYWwje/2/qlV2LCwqTiRgjTJx0Nyq1FQXntFfAunipmFcPXr2q1Q+hyv0fXPhHiBlhe+D7P5Liy7gZjV/HuHQaHW/OeZNbV99KXk0ed228i7fnvo0uqOtVOXsr9lJQX0CoJpS5qXPRqN2/L5B6Pmh7et8UoI1HPfIK6MW/feKku4k5+iYlyjZP9A6YTISbXDCn//sbquy1fJAyAr1RT4YugykJU3rv34xGo0GjUsH3D4KhGdIuQp1xQ5fC1xPTn+Dqr69mT8keVuau5NohrhVbv839FoCZCTOJ1zqWnWkvk+InERMUQ0lDicUTvT0KFMQExTApfpLdHv+9nZPiQ+IpbSylpKmEsZqxbU/0uv9KqL+9T6ptMGspDEjrtt3hSqlg8Ojo0R45N/fEJYMu4b0j7/FDwQ+YlCbHCnFGD5EKSpu682m2/rjv/Tg195V6frd9bTmzhaOVRwlUB3LzyJu97r0/lxEDRrCzaCcnqk90iHVD/gbWn16PSqHiyZl/Q336JjixBuXxb63y45bp6ngYGzuWweGDya7KZt3pdfxqWO8XI72FXSW7AMjQZaAN7PkCwKNTHmVn0U6OVh7lo+Mfcfvo2+0ed+WuvwOQ2dCIduYSuOBBrD1DtZ+DYVGS9J5Xk9f7sWftZ2oPx4MzsOUYEsVG+xhJWsmXvDTGvHzLHQVHZSE9La1NSI8QQrpAIBAIukcXrKMk2HynuHsfUZ/BCbYuRpORknqzR7rISBd4AD8/P8aPH8+GDRssjxmNRjZs2MDUqVO73Gb69OlkZ2djNLYV8zp+/DhxcXH4+fnZ1afPEmk+/itc8/37jcNvt4nopo4/NhXm+0uG3GCd4ArSD9K5z8g9nPOkQvpLni79P/otvDINPrsdyk9aH3TRASjcC0oNjOlaxIgKjOKNS94gISSB/Np8Fq1dRHlj14Wovz4pWcTMS51HgNr+i5YO0ev7BsxdZtUPfpXaj6VDbpC2PGdOZYvOGqWSLQVbnRSbAoZdDupAKgqz+OyMZB1wZ+z51vXfnqx3IW8raILg8ue6zR5NCEngvnGSd+/y3cstK69cgd6oZ+VJKUP+6vSrXTZOb6iUKpZOWgpIonl75PtLJi1xaaFcueBoYX1hxyes2X8TzFnyBz6BFyfCyvug+kyX48iFRsdEjXFC1M5ldNRodEE66vX17CjcYX9HdaXw/tXtRHTHjntHzyEmk4kV+1cAcN3Q6wgPCO99TA8zfMBwAI6UH7E8VttSy992/A2AhaMWMmzwpTDzQenJ7x+GhgqHxlQoFJaio1+c+MKhvtyNXAdkWvy0XttGBUbx0MSHAHhl3yvk1XRXuLNnGrPe5ftyyZZqQfIc6SKancQExRDqF4rBZCCnupfvRE78THUXQkjvYyRqJc/Z0wPMiw3cUXBUWLsIBAKBwEY6COkl9vmDehVOKDRa2ViJwfwjTXikCzzF4sWLef3113n33Xc5cuQId911F/X19SxcKBUKvPnmmzsUDr3rrruoqKjg/vvv5/jx43z33Xf87W9/4+6777a6zz5DRIr0v6kKGiud2vU7B9/hpb0vATA/JI0YQ8esyBgjLB98A5kzHulq8+4ZMR9++R5oz7FT0cZLjy9cBb/bASOuBExw8DNJWPv6Hqjq3UubrPel/8PmQXD3Rfhig2N545I3iAmK4VT1Ke5cdyfVzdUd2jQaG9l4WhJ+PSmSAr2/byPmW91V5oxHWD74BnTGjo/HGCEjJBkjJh7834NsPWulmN5bbL/6EO7fxwfDL6BRqWRkczPTvl4MH1wDBXutG6OmENb9Sbp90f9BRM+WZr8e9mvGRI2hTl/HUzufwnTuRQMnseX0FiqaKhgQMICZid0UuHMTmcmZLJ+1vNPqipigGJbPWk5mcqZLx48Lkea/oK6LApk97iPvw6INcOdmGDxbEo+z3oV/j4Pvl0Bd23c2k8nEgVJJSB8dPdpVL8VulAolFw+8GID1eevt66ShAt6/CsqOQWg8XPZPpxz3jpxDfir6iX2l+/BT+nHziJ6KNHoPwyKlDOXjlccxGKXPr+V7llPSWEKyNpnfjPmN1HDmYogaCvWlsPYxh8e9PPVy1Eo1RyqOcLSi+7os3oTeoGdXkZSRbo2QDnBl2pVMjZtKs6GZJ7c/afs59uDnrNv4KHVKJYnKICbMe9GhWosKhYL0cKnI7PHK471v4MTPVHcgrF36GElhUkZ6dpiRC8C9GempqeTsFBnpAoFAIOgdXbCO7L4kpDuj0Kg5Sy8iIMKx5ccCgQNcd911lJaW8qc//YmioiLGjh3L6tWrLcVC8/PzUSrbcnGSkpJYs2YNDzzwAGPGjCEhIYH777+fJUuWWN2nt2IwGthdvJt9LfvQFet6t2HwC4aQGKgrlrLSEyKcEsdHRz7in3v+CcC94+7lzsI8DAc2kTVoMqUpU4nWDiRj9E3WZ6Kfy4j5MOwyyNsmxR4SA8nT2rK/dMOkH7KF+2DjU3BiDfz8Puz/GMbfKmUQhraz6TEapL6qT8PPUtEyxvUu9iSGJvLGJW+wcM1Cjlce5851d/LGJW8QpA5id/FuVjWuosXYwpDwIYyItMNixtn09r7ZQOaMR7hwyoNkHXif0pp8y5yalEoe3vIw6/LWcf+m+3kl8xUmxk50OLYa/0D+o5c+cxZFZqAoXAvZ66S/4fPhwkdBN7xjn0YDirwfSajYhurLF6G5RspcnvybXsNRKVU8Me0JfvntL9l0ehNrctcwIHAApQ2lRAdFk6HLcCg722A0kFWSxWv7XwPg8rTL0Sg9b3WRmZzJhUkXklWS5bTXai3dZqTL9Lb/xo+DGz+DvO2w8a+SzcvOVyHrPZh0J0y/n7OGBiqbK1Er1QwLT4ecHxw+FizI5xFHj62Bmfzn6H9Ym7eWibETiQ2OtX4OmqrhgwVQfBCCdXDLNxA1GMO4m/lp3zvs3v8DE8bMZOJ5t9p3/rXzHCJnoy9IX0B0kPtrANhDsjaZAFUATYYm3jss+Xh/dvwzAJ6Y+kTbCiO1P1z5Irx5Cez9EEZfA2kX2T1uREAEFyVdxNq8tXxx4gsenfyoM16OS9lbupfG1kYiAyIZGjnUqmNBoVDwp6l/YsHKBfxU9BOfn/ica4Zc0/UA5/bXUAmfL+KLGOli91VjbkPphHNUekQ6WSVZnKg6Yd0GTvxMdTVCSO9jyBnph4LrpQdcLaQ3N8MZaZmXPmUgZ9ZJt0VGukAgEAh6on1GemtRoe9/IXFCRrrsjy6y0QWe5p577uGee+7p8rnNmzd3emzq1Kns2NHzsvme+vRG1uetZ9muZRQ3SMflpxs+JSYohqWTlvacSRoxyCykn4KEDIfj+Pz45zy962kAFo1exJ2jF8HGMaiAiZPuheFXODwGIP1QHdRLBm/ceXDDJ5C/Ezb+BXJ/gF0rpKzzSYtgxgOQ+yOsXgI17bJgFUpoqbMqjJSwFF6f/Tq3rbmNw+WHuf6762lobaCkoe2Ca2FDIRvyN7g8o9cqrHnfrESl9mPiuM7ets/MfIYWQwv/O/M/7t5wNytmr2CsbqxDsf3nyH+o09cxOHwwF87/CC7Mgc3L4MCncGQlHPkGxvwSLlgi+WMfXgmrl6CuKaBDacxRv7Ba5EiPSOeO0Xfw6r5XWbJlCUbaUvCtOra64dxjFeDbk98yNnqsV+wjKqXKuosfTkbOSO9WSAfr9t/kqXDrt3Bqs3Tcn90DW5+D3W9xYMzlAAwLjMH/hfEdj3ttvGTXYE8mqXl/c0Z/lc2VKFBQr6/n0R8lEdWq/a25Dj68Fgp+hsBIuPlriBrccX9TwmsH9xJz6hO7919bzyF7S/ays2gnaoWa20bdZvt4HmJj/kbLqsvle5ZbHp8aN5UJsecU3E2aJF2s2fUafHO/tCrKLxh7WZC+gLV5a/nu1Hc8OOFB/FWd6694E/Lqo2nx01Ae+dbqYyExNJG7x97Ns7ufZfnu5ZyfeH7neiNdHVtAnlrNnsAAlAolVw6+0imvY0jEEABOVFoppINTP1NdibB26WPIHulZAVXSA64W0nNzJf++4GDy/RoxmowEqAOIDem+eJRAIBAIBOEB4ZSHSF9DWgqssAfwduTPWydkpAt/dIHAs6zPW8/izYs7CHMAJQ0lLN68uGeLANknvdLx7+DfnPyGJ7c/CcDNI27m3nH3QtF+yVJFHQhpFzs8hl0MnCwJazevhMSJ0NoI2/4Ny4fDJzd1+oGOyQif3ir9gLeCwRGDWXHJCgLUAeTW5HYQ0UHy1e11HvoQGpWGf876J1PjptLY2shd6+/iUNkhu/tr0DfwwRFppcCi0YtQKpSSWP6L1+GubeaLMyZpxcGLE+HdK+GTmzvPK8CaR62eV4C0MKloZXsRHaw8trqgu2O1oqmiX+0jXSFnpHdp7WIrCgWkXQh3bIBf/QdiRkFzDftPrgJgdMHRzvtHTaG039iwfwBS+672Nzv6W5+3nof+91Cngq+97m/6RvjPr+D0TggIg5u/gpgRjn02OInXD7wOwBVpV1gulng78vumN+o7Pbe9cHvX79vF/wdhSdLn3canHBp/StwUYoNjqWmpYWP+Rof6cgcWf3RTgM3Hwo3Db2TUgFHU6mv5286/dXyyu2ML+CpUulAxLX4ascHO0fLSIyRrF5uEdB9BCOl9jLjQOJQKJSfCzb6J+fnQ2uq6AdvbulTnAlI2usIBPyWBQCAQ9H2UCiWNkaGAlJHu0xgMkGcu7OOEjPSYYCGkCwSewmA0sGzXsk7CC2B57Jldz1g8XjsRaT4HVOQ6FMfa3LU8tvUxTJi4buh1/GHCH6Tv1/IP5/RM8AtyaAyHSb0Abl8H138iCWutTT23X71UWlJuBenh6QSpe359Pc5DH8Nf5c/zFz3P+Jjx1OnruHPdnRyrOGZXX58e/5Sq5iqStcnMSZnT8cmYEXDdB2Z/7EzJHztnM3RxPFiwcl4NRgPP7n62y+esOra66M+hY7WPI4usNS011OvrndOpQiHVO/jND3DNWxwIDgNgdHNzF43N82LDcY/RIGXLdrm/2daf3ftHazP89wZpxY1fKNz4BcSd5xX725HyI2w5swWlQsntozuvXvFGenrfQCq+2+X75h8Kl/9Lur3zFTizx+4YVEoVV6ZJWdbeXnS0vLGcIxVSQdape/6LrceCbKOlVqjZkL+BdXnrpCd6OLZaga9DQgBYkHaVU14HwODwwQAUNxR3qnni6/j8SmpBR9RKNXEhcRQYzmL090PZ3AKnTzv0w75HZCE9La2t0KjwRxcIBAKBFbRGRwHVKEp93CP9zBnporWfH8TH292NJSNdCOkCgcfIKsnqlG3YHhMmihqKyCrJ6tquQf4eXHHK7hg2n94sWV+YjFw9+GoenfxoW5LKkW+k/8Ods/TaYRQKGDJHypB/ryebGRPUnJW8T61Ytp1VkkVFU0UPvfUyD32QQHUgL138Eneuu5P9pfu5c92dvD3nbVLDrV8J1Wxo5p1D7wBw+6jbu/eJjh8HN34OO141iy/dYf28WntsXfjphVZZLzQbmqls6r6ob3/cR9oTrAlG66elpqWGgroCS3aoU1Aq0Q+fz5Gsv4KpldHNLd00NO8fzw4B2QO7J1qboKGshwYu3t9MQEO5tMomKQGCo2CHVMDZG/Y3ORt9TsockrU9F/j1Fhz6TE2fDaN/CQc+gZX3Shf47KwFctXgq3ht/2vsKNzB2bqzJIQk2NWPq9lRKNnkDQ1OJCpnWw8tuz+2hgILAxW8HqTgbxsfYFKViTB998fW1sAAStUqIgwGZhmdV6Mp1C+UuOA4CusLya7KZnzMeKf17WlERnofJFGbiEkJ9XFR0gOutHc5eVL6n5pKTpVZSBf+6AKBQCCwAoVO8u1Tl3X/w8QnkC8qp6SA0v6vViX10gUFYe0iEHiO0oZSx9o5aO2y7ew2Fm9eTKuplXmD5vH41Mcl6w2A0mNQdgyUGhhyiV39u4x6Ky+I1nUvqLTH4XnoowRrgnkl8xWGRw6noqmCO9beQX6N9fZoX574krLGMuKC47g89XIrBoyyrmMr5tXauapsqqSovqjXv55ETXvG7YvEh/RScNQBjlcep8XUitZgILm3FfANZVBzpve/HkX0drhqf2soogg9RWo1RWoVRc2VXrO/nao6ZbFAWTR6kUvGcAUOn8vnLoOgAVByCLY+b3cciaGJTI6bDMBX2V/Z3Y+rsdi6hAy0boNujq3flJwmpUVPmVLBck1Dj8fWF6FSNvrldfVoGsodfg3t6av2LiIjvQ+SFJbEzrM7qYjVEppb4FohvZ21y6nKHwAhpAsEAoHAOlSx0rJj/8oayR5F5X1V2a3CCYVGoS0jXRQbFQg8R3RQtFXtCuoLMJlMne0MZWuX2kLJZ1cTaPXYPxX9xP2b7kdv1JM5MJOnZjzVMWP4iNnWJXWW5NvrTVh7AdDKdtbOg7Xt+hJaPy0rZq9g4ZqFZFdlc8faO3hn7jsW0bQ79EY9bx18C4CFoxaiUWl6H8yJ82rtXP3flP9jZNTIXtsdKjvEX3b8xWnj9kXiguM4WnHUOT7p57C/bD8Ao5tb6NXU9fJ/SasceqPgZ/j2gd7bKXuXsWza3yJHwOan4cQaqe9LnoLkKR3aeXp/e+PAG5gwcVHSRc5dXeBiHD6XBw+QxPQvFsGWv8OIKyF6iF2xLBi8gJ2FO/kq+yt+O+a33a/I8RAmk8kipE/XTQT+2/tG3Rxb/sCTlce4ZfdTfBEawrxRtzB58786tStTKtkSJH1PWVBbb/0530oGhw9my5ktQkgXeD+JoYkAFAzwJxncI6SnpZFz5j1AWLsIBAKBwDoCY6UC2UqjCSoqINpHf+y2u6jsCMIjXSDwPBm6DGKCYihpKOnW0xXg+azn2Xx6M/eOu9eS5QZAYAT4h0FzNVTmgm64VePuLdnL3RvupsnQxPmJ5/P38/+O+lyxSLZ1GTHfthflDpKngTZeKoLW5fumkJ5PnmZVd73NgwIFMUExZOgyHIvbRwkPCOf1S15n4eqF5Nbkcvua23ln7js9fn58e/JbCusLiQqM4urBV1s3kBPn1do5/UX6L6wSuIZFDGPF/hViH+kB+eJKQb3zhfQDpQcAGI0/oKDH/SPjFrBGtIwdA1v+0cP+ZuaLO+HMTzDjgW5XTVi9vw1egGrVg3DoW1Co4JevmwvudqS3/Q0gNijWJfvb6drTrMqRCrveOeZOp/fvSpxyLh99Lez/BLLXwTf3wa2r7FoBetHAiwj1C6WovoidhTuZlmDd55G7OF55nLLGMgLVgYwbdT18/yfotr5B78dWRvw4rqvN5uNjH/NkxS4+18YTeM6x9W1IMK0KBWOamhkcqLP6M9paLBnpVX1LSBfWLn2QpDBJmDgVaX7glP0ejT1iMnUsNloprF0EAoFAYD1RYXGUycmaJT7sk+7kjHRh7SIQeA6VUsXSSUsB6Qd+e+T7FyZdSIAqgH2l+7hj7R3cseYO9pXuMzdSQGSKdNtKn/RD5Ye4a/1dNLY2MiVuCstnLe+cLVyZC4X7QKGEofPsfXmuQ6mCuc+Y75ybn2q+P3eZdWIa1s3DkklLvC6j0J1EBUbxxiVvkBiSyJm6M9yx9g7KGrtevm8wGnjz4JsA3DLiFgKs8asGp86rs+dU7CO9ExcsrfwrrHO+tcuBMrOQft6t5kccP+6t2t+ihoChGba/CM+NgQ1/gcaqTl1ZtX9MfBjV2j/Cnnek/hes6FJE760/mWGRw9qsuJzIWwffwmAyMD1+ulWrNbwJpxynCoWUea0JhvztsPtNu2IJUAdw2aDLAPgi2/uKjsrZ6BNiJuC36ameRXSw6tj6fcbviQmK4XTtaV4ZeWGH7U202bpcXVdv27FqJenhkpCeXZmNydTDxTEfQwjpfZBErZSRfiSkSXrAVRnpJSVQXw8KBXVxAyy+ViIjXSAQCATWoAvWURJsvlNsnW+uV+IEId1kMomMdIHAS8hMzmT5rOXogjraLMUExfCvWf/i3xf9m1ULVvGrob9CrVSzs2gnN666kbs33M3RiqNtPukVvX8HP1ZxjN+s+w11+joydBk8f+HzXRdaPPKt9D95uvW+1e5mxHz45Xugjev4uDZeetzGTPqe5mH5rOVkJmc6GrHPExMcw5tz3iQ2OJbcmlwWrV3UpZfz2ry15NXkEeYfxi+H/tK2QZw4r86eU7GP9IyrPNKrm6vJrckFYHTGHU497nve396Hu3dJhXDjxkpC4w/PwvPmTPbmug6b9Lh/XPBPMk/8CDtflR688iUYfU2PoXXXn9ZPC8DmM5t5ce+Ltr3eXiiqL7J4evtaNrqMU47T8CTIfFy6vf4JqD5jVywL0hcAsDF/I1VNVXb14Sos/uj1ddKFIoAJt0n7fntsOLZC/EL4vyn/B8C7xVs5dNnTlmNrn78fOX4aAk0m5l7yL5esdksNS0WtUFOrr+2x6KyvIaxd+iBJWikjfW9gtfSAq4R0ORs9KYncRunDOTwgnPCAcNeMJxAIBII+hSykjyjDtzPSnWDtUtNcQ7OhGRAZ6QKBN5CZnMmFSReyq2AX67avY/bU2UyKn2TJmosOiuaPU/7IwlELeXXfq6w8uZItZ7aw5cwWLglM5G6NmtRzCo4ajAaySrIobSglOiia8IBw7lx3J9XN1YyJGsPLmS8TpAnqOiDZ1mW4F9q6tGfEfBh2GeRtkwoChsRIS8XtzHLrbR4Eklj65iVvcuvqW8muyuY3637DG3PeIFgdTFZJFiUNJfw7698A3Dj8xu73sZ4wz2vrqS3s/WENY2fOQZ16vl3zKs9p+2MhQ5dh95w6u7++RHywWUh3ckb6obJDACSFJhEREOH0477X/gZnQtrFcPRb2PgUlB6BjX+FHa/CzMWS+GiuT5GZnMmFCeeTdeB9SmvyidYOJGP0Tah+XA5bn5P6u+yfMO4Gq0Lr7pz08bGPeXrX06zYv4IAVQCLxjinIOi7h96l1djK+JjxZMT4rk2RU47TiXfAgc/gzC747kG47kMUeT+SULEdRZ4WrDgnDR8wnOGRwzlScYRvT33LjSNudPCVOYfG1kayirMAmHbwO+nBS/8Bk+8E47MOHVsXJF3A3JS5rM5dzRNFG3n/nt0cOPRfXj71JdTlMTttPiGjbbzAaiUalYaUsBSyq7I5Xnmc2OBYl4zjboSQ3geRM9J3+ZkrHxcXQ0MDBNnxpaknTp6U/gtbF4FAIBDYgS5Yx6kQ8x1fFdIbGtqy6R3ISC+pl15/iF+IfSKHQCBwOiqligkxEyjxK2FCzIQuf/DHh8Tz5+l/5rZRt/HyvpdZnbOatY1nWJ8Qx+Vl2/lt7WmSQpNYn7eeZbuWdcjIUqLEiJHhkcN5ZfYrBGuCO/UPQG0RnN4p3R52mSteqnNRqmDQTKd1Z8089HcGagfyxiVvsHDNQo5UHOH6766nsbWRkoa2z1YFil4LkvaIUoUpeQZnD9VwXvIMhywAVEoVE2Mn2h+Li/vrK8iiVWljKXqD3roCs1ZgKTQaNbrtQScf9732p1BINixD58HBL2Dz3yQ7rTWPwrYX4fw/wLib4PhqVKuXMLGmnU/86ieguUa6PedvkkBrA12dk64ffj3NhmaW71nOv3/+N/4qf24eebPtr7sd5Y3lfHb8M8B3s9Hb4/BxqlTB/Bfg1RlwfDU8Oxh1YyUTAPJekTK15z7Ta2b11elXc2TnEb7I/oIbht/QuWi4B9hTvIcWYwuxra0M0rfC7D9LIjo45dhaOmkp2wu3c7TiKBd+lkmdvm31xg9nf2R93nqXreBJD08nuyqbE5UnOD/xfJeM4W6EtUsfJC40DqVCSam/AaM2VHowN9f5A7X3R68yC+nC1kUgEAgEVtLe2sXkq9Yu8qqv8HCIiLC7G9kfXRes66WlQCDwRlLCUvj7+X/ns/mfcdGA8zAqFKyklvlfzufOtXfywOYHOi1rNmIE4Prh11usAbrk6LeACRImQFiCC1+FwJdJDU9lxewVBKmDyKvJ6yCiA5gw8diPj7E+b72HIhS4m8iASAJUAZgwUVRf5LR+ZX/0MdFjnNan3ShVMOZayfJl/gugTYTaAvhuMSwfAZ/cBO1FdGgT0UddA1PvdlooC0ct5HdjfwfAP3b/g4+PfuxQf+8ffp8mQxOjBoxiatxUZ4To++iGtfnYN55jY1VTCJ/cDIdX9tjFvEHz8FP6caLyBIfLD7soUNvYmvUaANMbm1DMehSm3+/U/gcEDrD4w7cX0QGqmqtYvHmxyz4b+mLBUSGk90HUSjVxIXGggMYks7eYKwqOyn2mpYmMdIFAIBDYTHshXV9on9ehx3FWoVHhjy4Q9AmGRAzh+ZnP8J+zRUxvbKLV1Mr2wu09bvPSzy9hMBq6byDburjAv1TQtxgcPrjXQqLP7Hqm5/1N0GdQKBSWrPSC+oJeWluHyWTiQKm50Gj7jHRPo9JAxs1wXxZc+ncIigZzDbduyd8OTj4Wfjvmt9w+6nYA/rrzr3x54ku7+qlurua/x/4LSNno3pA17RUYDZC/o5snzcUsVy/tcV7D/MO4OPliAL444QVFR3/+gO1FuwCYlnwxXPCw04cwGA1syN/Q5XMm8/vmqs8Gi5BeKYR0gZeTFCb5pFfFmbPjXOGT3t7apUoI6QKBQCCwjUBNIDVaqaheS+FZD0djJ07wR4e2jHThjy4Q9AFC4xhlUPBqUQlLRvZuGVDUUERWSVbXTzZUQM4P0u1hlzsxSEFfJKski4qmim6fN2HqeX8T9DlkO5+COucI6WfqzlDZXIlaqWZY5DCn9OlU1P4w+Tdw9au9t605K3lPOxGFQsH9Gfdz43DJe/vxbY+z6tQqm/v56OhH1OvrSY9I54KkC5wao0+Tt01acdAtJqvmVS46uipnFY2tjU4M0EYOfEbRt/dz0s8PJTB59j8l2yInk1WS1WOxT1d+NshC+qnqU+iNeqf37wmEkN5HkX3Si6OlIhsuEdKFtYtAIBAIHKQ5Srrgayx23pJjtyIy0gUCwbkolRCRAkCkvtmqTUq7y5w89j2YDBAzCgakOSlAQV+l2/3IznYC3ycuWFqhXljvnIKjcjb6sIhh+Kn8nNKnS2iqsq5dnfOtBRUKBQ9PfJhrh1yLCROP/vioTbYZ9fp6Pjj8AQB3jr4TpULIdhasna9e2k2KnURCSAJ1+jrP2V0dXglf3Mm2QCmpaFTUGMICwlwylCc/G+KD4wnWBNNqbCWvOs/p/XsCcUT2UZK0UkZ6XoR5ip0tpDc2QoF0JdAkio0KBAKBwE6M0VEAqErLPByJnThJSJeLjQohXSDoI0RKq1Simxusah4dFN31E7Kty3Bh6yLonW73IzvbCXwfZ2eky/7oo6O9yNalK6xd4eeilYAKhYLHpjzG/LT5GEwGHtryEFvObLFq20+OfUJNSw0p2hRmJ892SXw+i7Xz1UvNIaVCyVWDrwLgy2z77Hcc4vha+Ow2MBnYFjcUgGkJ01w2nCc/GxQKBYPDBwN9xyddCOl9FDkj/bjWvHTC2UK63J9WS0Ug1LbUApASnuLccQQCgUDQp1HGSF+I/cqrPBuIvTjZ2kUUGxUI+giR0sW1jKYWYoJiUND1Um0FCmKDYsnQZXR+srkWTm6UbsvF1QSCHsjQZdi/vwn6JHJGurOKje4v2w94mT96VyRPA208dHMsgAK0CVI7F6FUKPnztD8zN2UurcZWHtj0ANsLeq6Z0dTaxDuH3gHg9tG3o1KqXBafT9LrvJpZ86gkVptM3Ta5avBVKFDwU9FPnK457dw4e+LkJvj4RjDqMYy4mu3KFgCmx0932ZCe/mywCOl9xCddCOl9FDkjfX+wuSLvqVM9nkRspr2tS3UuALEhsQRqAp03hkAgEAj6PH5x0oVfTWMz1Nd7OBobMZmcZ+0iPNIFgr6F2e5QVZnL0klLATr9gJXvL5m0pGux5MRaMDTDgMGgG+7aeAV9ApVSZf/+JuiTWDLSnVBsVG/Qc7T8KABjosc43J9LUapg7jPmO+eKh+b7c5dJ7VyISqnibzP/xkVJF9FibOG+jfexp3hPt+0/P/E5FU0VxAfHc1nqZS6NzSexZl7VAVB8AD66Ft6aAzldrwSIDY5lWrx0IcVtWel52+A/v5Y+24ddzuEL7qempYZQTSijoka5bFhPfzb0tYKjQkjvo8gZ6T/5mT2OamuhovvCMzYjFxpNSxO2LgKBQCCwG21UAo1q851SH/NsLSuDujqpKFByskNdCY90gaCPYbZ2oTKHzORMls9aji6o44qTmKAYls9aTmZyZtd9WGxdrnBJ8TFB38Tu/U3QJ4kPloT0ovoijCajQ30dqzxGi7GFMP8wBoYOdEZ4rmXEfPjle6CN6/i4Nl56fIR7LLM0Sg3/uOAfTE+YTpOhid+t/x37S/d3aqc36Hn74NsA3DbqNjRKjVvi8zl6nNf34YFDMO1eSVA/vRPevQLenQ9ndnfq6ur0qwH4OvtrWo2tro37zG748FpobYTBmXDNW2wt2gnA5LjJqJXqXjpwDE9+NgyJGAL0HWsX186UwGMkhSWRVAXhRYWYBgxAUV4O338PI0a0NYqKgoF2fgCKQqMCgUAgcAK6kBhKgiG5GiguhpQUT4dkPXI2enw8BAQ41JXISBcI+hhmaxcqcsBkIjM5kwuTLiSrJIvShlKig6LJ0GV0n/2lb5SWpYOwdRHYjM37m6DPEh0UjUqhQm/UU9ZY1klEswXZH31U1CgUvnJxb8R8GHaZlAlcVyx5bCdPc3km+rn4qfx4btZz3LPhHnYW7eS363/Lm5e8yZCIIZbj9HD5YYobiokOjOaq9KvcGp/PYZ7X1lNb2PvDGsbOnIM69fy2eb3krzDlbvjhWdjzLuT8D964GIZcChf9EWIla6ILky4k3D+cksYS3vnhceJRE60dSMbom1CpHSimazR03Of8guGDBdBSB4POh+s+ALW/xerHlf7o7fHUZ0N6uJSRfrbuLPX6eoI1wS4dz9UIIb2PElvRwrEXIbDVAJRLD950U8dGAQFw7Jh9YrospKelkVO5FxAZ6QKBQCCwHV2wrk1ILynxdDi2IQvpDvqjN+gbqGuRrNhERrpA0EcISwKFUso8qy0CbRwqpYqJsROt2/7kJtDXgzYR4oWftcB2bNrfBH0WtVKNLkhHYX0hBXUFjgnppZKQPibKy21dzkWpgkEzPR0FAeoA/n3Rv7lr/V1klWRx6+pbCVQHUt5U3qHd1Pip+Kv8PRSlD6FUYUqewdlDNZyXPKPzxRFtHFz2T5h2H/zv77DvIzj+vfQ38mqY9Sh+0UMYExDDluYqns9dadk05ud/sXTIDWTOeMT2uA6vhNVLoKa9nZICMEHSFPj1f0ETSG1LLftK9wFYLGbcgSc+G8IDwokOjKa0sZQTlScYqxvr1vGdjbB26aOoK6oI7G1lSlOTtCzdHmRrl/YZ6UJIFwgEAoGN6IJ1FMtJCb4mpMsXlR30Ry+pl163v8ofrb/W0agEAoE3oPaDMMlqEbMNok0IWxeBQOAk5IKjhfWFDvUjZ6R7faFRLyZIE8RLF7/EwNCBNLQ2dBLRAVaeXMn6vPUeiK6PEpEMV70Ed++CUb+QHjv0Jbw8mfXvXMSWqqOdNilRwuLsD1n/49O2jXV4JXxy8zkiOoC5XuGE26TsdGBX4S4MJgMp2hQSQhJsfFG+h+yTnl2V7eFIHEcI6QLbMRo7ZOHJQnpqhGMZeQKBQCDof8gZ6YDvCenOKjRq9kfXBet8Z6m0QCDoHdknvcJGId2gh2OrpNvC1kUgEDiIpeBonf0FR6ubq8mtyQWEkO4ogepAGlsbu31egYJndj2DwWhwY1T9gKh0uOYt+O1WGDoPg8nIMkPXF5dM5u/jzxz/EENri3X9Gw1SJrosmndCARuelNoB2wq2Ae7NRvcksr1LXyg4KqxdBLZTVCRls6tUGJMSya3KBYRHukAgEAhsJyY4xiKkG4sKfesKf7t6IY4g/NEFgj5KxCBgs+0Z6bk/QFMVBEfDwCkuCEwgEPQnnJGRfrDsIAADQwcSHhDujLD6LVklWZQ2lnb7vAkTRQ1FZJVkCXsmVxA7Cn79H7I2PUFx/ufdNjMpFBSpIOvDy5kYktx7v3UlXWSid+gRas5C3jZMKTPYWrAV6EdCujkjvS8UHBVCen/nxhvhssvgootgxgwIDe26XX5+mw1MVpb0PyaGsh2bGHm6hcpgJYnaRPfELBAIBII+Q2RgJKUhkm9gc+EZAj0dkC04OSNd+KMLBH0MS8HRU7ZtJ9u6DLvM7QXxBAJB30POSHdESN9fth+QCo0KHKO0oXsR3Z52AvsoVXaXOX5Ou5IDkLPTeQPXFXO69jRn686iVqr7zcUSi5BeeQKTyeTTq3B9RkivqKjg3nvv5ZtvvkGpVPKLX/yC559/npCQkG63WbFiBR999BFZWVnU1tZSWVlJeHi4+4L2BY4ckf6efRZUKpg0SRLVL7wQpk2DwEBJRB86VMpCb09BAboLLiULaFKbUP++wL7CpQKBQCDot6iUKhojQ4EaWovsX3LsdlpbIS9Puu2sjHQhpAsEfQt7rF2MBjjyrXRb2LoIBAInEB/suLWLpdBotI8VGvVCooOindpOYB/RWuu0q+jBcyF2Qu8NK07BT2/03i4kxpKNPk43jiBNkFVx+DqpYakoFUqqmqsoayzz6f3bZ4T0G264gcLCQtatW4der2fhwoXceeedfPTRR91u09DQwNy5c5k7dy6PPGJHtd3+wF/+Arm5sHGjlFm3fbv099RT4OcHU6fCsGGdRfRzCGg1SRnrQkgXCAQCgY20RkUCNSiKiz0divWcOQMGA/j7Q1ycQ13JxUaFtYtA0MeQbQ9tsXY5vQvqSyAgDFLOd01cAoGgXxEX0mbtYk8mqMlkEoVGnUiGLoOYoBhKGkowdeGnrUBBTFAMGboMD0TXf8gYfRMxP/+LEmWbJ3p7FCYTMUbIuOI1qYB4bxgNUn2TmkK69klXgDYekqexbfPvgf5j6wIQoA5gYOhAcmtyOVF5wqeFdJ+wIj1y5AirV6/mjTfeYPLkycyYMYMXXniB//73vxQUdH9V9fe//z1Lly5lyhThLdgt8+bBG29IPq85OfDWW5LdS3w8tLTA//4Hr73m6SgFAoFA0Icx6aQvUqqyCg9HYj2K3FzpRnIyKB37OiVnpOuCdQ5GJRAIvIqIFOl/Y6X0Zw2yrcuQS6374S4QCAS9EBscC0C9vp6alhqbtz9Te4aq5io0Sg3DIoc5O7x+h0qpYumkpYAkmrdHvr9k0hJUwtrLpajUfiwdcgMgiebnYgKWDLkBlbWfxUoVzH3GfOdcYd58f+4y9CYjuwp3ATA9frrtgfswfcUn3Scy0rdv3054eDgTJrQtp8jMzESpVLJz506uvvpqp43V3NxMc3Oz5X5NjfRBo9fr0ev1ThunN+Sx7B4zLAyVvz/Kdq/lXEwBAbSGhYE8RkKCJKLfeCOYTHDiBMr//Q/FF1+g3LCh95hbW9v66iM4PA8ChxFz4B2IefAO+uo8KGKkH3j+VbXozcWsvRX5vTdkZ6MGjIMGYXBwPopqiwAYEDCgz82tq+grx4Kvxy/oBf8QCNZJGeYVOZAQ0XN7k6lNSBe2LgKBwEkEqgOJDIikoqmCwvpCwvzDbNpe9kcfFjkMP5W4wOcMMpMzWT5rOct2LaO4oW1FZkxQDEsmLSEzOdOD0fUfMmc8wnJg2fEPKT7n54dWHcSUSffa1uGI+fDL92D1ko6FR7XxMHcZjJjP3qKfaGhtIDIgkqGRQx1+Db5Eeng66/LWcbzyuKdDcQifENKLiorQ6TpmaanVaiIjIykqKnLqWE8//TRPPvlkp8fXrl1LUJD7vYvWrVtn97Z+LzzP/+2+CyMmHk/9E2Gajh+YLVotjQcPwsGD3XeSkEDYvHnMskJI3/rjj1QX2l/AxJtxZB4EzkHMgXcg5sE76GvzUNxoAEBpNLHmk09oCbPtB54nyN20iaFAnkLB/lWrHOrrVLFUiDD3YC6r8hzrq7/h68dCQ0ODp0MQuJrIVElIr8yBhF6W6Rfuhep80ATB4IvdEp5AIOgfxAXHUdFUQUFdgc1Z5QfLJL1A2Lo4l8zkTC5MupCskixKG0qJDoomQ5chMtHdTOaMR7hwyoNkHXif0pp8tCFxPJX7NWfqzvBc1nM8NuUx2zocMV8qFp63DeqKISQGkqdZiodvL9gOwNT4qSgVPmES4jTaFxz1ZTwqpC9dupRnnnmmxzZHjhxxUzQSjzzyCIsXL7bcr6mpISkpiUsuuQStVuu2OPR6PevWrWP27NloNBq7+7mz9q+cqT1D1HWXMClhkn2d/PyzVc2mz5gB48bZN4aX4qx5ENiPmAPvQMyDd9BX52Hf1n2UBa4iqhEyR4+GUaM8HVK3yHOQZr4/cNYsEufNc6jP+qP1AFxx0RWMjB7pYIT9g75yLMgrHwV9mMhBcHqHdQVHD6+U/qfPBk2ga+MSCAT9iviQeA6VH6Kw3vbENzkjfXS0ENKdjUqpYmLsRE+H0e9Rqf2YOO52y/0n4zO4fe3tfHzsYy4ddCnjY8bb1qFSBYNmdvmUXGi0P/mjy8hC+qnqUxiMBp+9aORRIf3BBx/k1ltv7bFNamoqsbGxlJSUdHi8tbWViooKYmNjnRqTv78//v7+nR7XaDQe+aHm6LhJYUmcqT1DYUOh/f2ordtNNGo1+PCP2Z7w1PwL2hBz4B2IefAO+to8xIXGURIMUY2gqaz0ic8SZX4+AKrBg1E5EG+LoYXKJsk7OTE8sU/Nqzvw9WPBl2MXWIlccLQ3Id1kgiNmIX34fNfGJBAI+h1xwVLB0YK67mvMdYXeoOdo+VEAxkSNcXpcAoE3MiluEgvSF/DFiS94YtsTfDb/M/xVnXVCW6loquBIuZQsPDVuqsP9+RqJIYkEqAJoMjSRX5vPoLBBng7JLjwqpEdHRxMd3Xul1qlTp1JVVcWePXsYP166ErRx40aMRiOTJ092dZg+TaI2EYAzNWc8HIlAIBAIBF2jC9ZRHAIjyoBzLpx7K4ocsyiWmupQP6X1pQCoFCoiAyMdDUsgEHgbkeZzRGUvQnrpMSjPBpUfpF/i+rgEAkG/Ij4kHsDmjPRjlcdoMbYQ7h9OUmiSK0ITCLySxeMXs+XMFnJrcnlt32vcl3Gfw33uKNiBCRNDIoYQHdS7FtrXUClVpIWncaj8ECcqT/iskO4ThjzDhw9n7ty5LFq0iF27drF161buuecefvWrXxEfL30gnD17lmHDhrFr1y7LdkVFRezdu5fs7GwADhw4wN69e6moqPDI6/AESVrpw+509Wn7O4mKgoCAntsEBEjtBAKBQCCwEV2wjpJg8x0fENJVTU0o5DgHOfYFsLheKjAVHRzd73wSBYJ+QaSVGelyNnrqhRDgPjtJgUDQP5Az0gvrbBPS95dKti6jokahUCicHpdA4K2E+Yfxx8l/BODtg29zrOKYw31uK9gGwPT46Q735atYfNKrfNcn3Wd+sX344YcMGzaMiy++mHnz5jFjxgxWrFhheV6v13Ps2LEORZteffVVxo0bx6JFiwA4//zzGTduHCtXrnR7/J7CkpFe60BG+sCBcOwY7NnT4e/zD/5Ixp1w31+nS88PHOikqAUCgUDQn4gJiWkT0ouLPRqLNQTJInp4uPTnAMV10uuNCY5xLCiBQOCdyNYutQWgb+y+nSykjxC2LgKBwPnIGekF9bZZuxwoOwCIQqOC/klmciaZAzNpNbXy+LbHMRgNdvdlMpkshUanJfQ/f3SZ9HBJSM+uzPZwJPbjUWsXW4iMjOSjjz7q9vmUlBRMJlOHx5544gmeeOIJF0fm3SSFOSEjHSSR/ByhfHfFp/wcD9PGjRUiukAgEAjspn1Gur6oAG93jQ4qKpJuOGjrAm0Z6TEhQkgXCPokQZHgr4XmGqjMBd3wzm0qcqDoAChUMORSt4coEAj6PnJGekVTBU2tTQSoe1lxbkYI6YL+ziOTH2Fn4U4OlR/igyMfcMvIW+zq50TVCUoaSwhQBTBON87JUfoOIiNd4PW40iM9p0paojoo3Dd9jQQCgUDgHQRrgqnUSvJ5S6H31/QIdpKtC4iMdIGgz6NQ9G7vcuQb6X/KdAge4J64BAJBv0LrpyVIHQRY75Ne3VxNXk0eIIR0Qf9FF6TjwQkPAvDizy9yuta+JFU5G31C7ASnFC71VWQhPb8mn8bWHlbqeTFCSO/jyB7pBbUFDi1D6QqLkB4hhHSBQCAQ2I9CoaBlQDgApiLbvDs9gTMz0kvqJVFeCOkCQR9G/q5ccarr52UhfbiwdREIBK5BoVC0FRy10iddzkYfGPr/7d15fFT1vf/x90w2yEYI2QlJ2AxBCApKBC+IJZJA68UGr9LiFRRpVVA0rbi0Fal6cSsCllt7f23VqlgVEa2tKFsQFcWGIogYZQ1LFhLIThYm5/fHkIGQhSDJnJPJ6+kjj2TOfGfmM344k8988p3vN04h3UI6KjTA8jIGZmhk1EhVO6r1282/bbIaRlt8cvgTSdLomK67rIskhXUPU2i3UBkytLekhbrI4mike7iowCh52bzkMBzKr8hv1/ved5wZ6QCA9uEId87CtB0tMjmSc/NvpxnpjnqHthc4N/Eqrylv9z94A7CIhhnpx5uZkV6WJx3a4vx50I/cFxOALqdheZe2rpO+4+ipZV3CmY2Ors1ms2n+qPny8/LTZ3mf6Z0975zX7atPViu7IFtS195otEHDOunfHv/W5Ei+HxrpHs7L7qXoQOcvzD//+8/K2p/VLm/UK2ordLTqqCRmpAMALpwtMkqS5FtcYm4gbeDfsCHqBcxIX7lrpRKWJGjtvrWSpD9u/aMSliRo5a6V7REiACsJPfVa0dzSLt+85/weO1IKjnZfTAC6HNeGoxVta6RvL3L+sZ9lXQApLjhOd15ypyTp6S+eVtGJtk/+yS7IVm19raICotS3B/2zAT0HSOq866TTSPdwK3etVGGVc+bc/Kz5uvqlq9vljfr+kv2SpJBuIXzMCwBwwXyjnXt6+JyokSorTY7mLLm50tatrq+AvFMfia6qch7LzT2vu1u5a6Wuf+P6JvuXHC47rOvfuJ5mOuBperYyI33Xu87vg1nWBUDHapiR3pY10g3D0FdFX0mSksOSOzQuoLO4efDNSgpNUlltmRZ+vrDNt/v0yKeSnMu62Gy2jgqv02iYkf7dcRrpsJiGN+q1jtpGx9vjjTrLugAA2lNwrxid8D51oWHpFCvIzZUSE6URI6QRI+RzxRXyrj31ezUjw3k8MbHNzXRHvUNzV8+VoaZrKzYcu2f1PSzzAniShqVdSnIlx8nTxyuLpf3ONVNZ1gVAR3Otkd6GRvqh8kMqqSmRj91HiaGJHR0a0Cl42721YPQCedm89OGBD7U+d32bbndmIx2nNxylkQ5L6eg36mw0CgBoTxGBkSoMOHXBSo30oiKpurr1MdXVznFtsCl3U5OZ6GcyZOhg2UFtyt10PlECsLKgGMnLT6o/KZUePH0855+S4ZCihp5utgNAB3HNSG/DZqMNy7okhSbJ18u3Q+MCOpOkXkmafvF0SdLjnz2u8tryVsfnV+Zrd8lu2W12XRF9hTtCtLwBIc6lXYqri3Ws+pjJ0Zw/GukeqqPfqDMjHQDQniICIlRgxUZ6O8spymnTuLzyc7/JBdBJ2O1SzwTnz2cu77Lr787vSZPdHhKArqehkV5QVaCT9SdbHbujiI1GgZbcMewOxQXFqfBEoZ7NfrbVsZuPbJYkDek1RD38ergjPMvz9/FXbKBzWc/OOCudRrqHausb8O/7Rr1hRnq/nt9/ozUAABpEBlh0Rno72Xt8r+b8c47ufv/uNo2PDmLTQcCjNMw4P7bX+b26TNq7wflz0rXmxASgSwn3D5e33VsOw6GjVUdbHbvj6KlGOhuNAk108+6mR0Y/Ikl689s39a/8f7U41rWsS2+WdTlTZ17ehUa6h2rrG/Dqk+f4uHoLXEu7MCMdANAOIgIiTjfSCwpMjaU9ZR/J1tQVUzXwuYFa9sUy1dbXysfu0+J4m2zqE9xHY+LGuDFKAB2uYTnEY6dmpH/3oeSolcIukiIGmRcXgC7DbrMryj9KknSk8kiL42odtdp1bJckGulASy6PulxTBk6RJC3YvEA1jpomYxz1Dm3Oc85IZ330xlyN9BIa6bCIMXFjFBscK5ta3xH41ndv1cRXJ2r9vvUyjKbrqTfHMAztPe6cTcMa6QCA9nBmI93o5I10wzD04Z4PlfrXVF32/y7T6ztfV71Rr7T+aVp38zq9NuU12U79d6aGy4vTF8vL7mVG6AA6SuipT3Ee3+/8vutd53dmowNwo4YNR49UtNxIzzmWo7r6OoX4hahPUB93hQZ0OpmXZSq8e7j2l+3X818+3+T6Xcd2qbSmVIE+gfxR6izMSIfleNm9tCR9iSS1+EZ9VOwo2W12rd69WuP/Ol4j/m+Elu9YrjpHXav3XXyiWBW1FZKkhJCE9g8eANDlhPmHqSDQ+XNNXst7fFjZyfqTWr5juS7946VKeyVN6/atk5fNS9OGTtO2n2/T6ptW6wd9f6Apg6doxQ0r1Du4d6PbxwbHasUNK5SRlGHSMwDQYULPmJFed0L6bo3zMo10AG7k2nC0suUlXhs2Gh0SNkQ2W+sT84CuLNg3WL+64leSpBe+ekE5xxrvhdSwrEtKdIq87d5uj8/KLgq5SJK0u2S36o16k6M5PzTSPVhGUkaLb9TfuuEtfTrzU30751vNvny2unt317/z/61pK6dpwHMD9OzmZ1Ve03T3YUe9Qyt2rpAkhXYLbfXj6QAAtJWPl4+qejqnpDvyD5sczRlyc9s07LUdr2nA0gGatnKaviz4Uv4+/pqbMld77t6jVzJe0bCoYY3GZyRlaP/c/dowfYOWZyzXhukbtG/uPprogKdq+BTn8X3S7rVSXZXUI06KvsTUsAB0LW2Zkd6w0WhyWLJbYgI6s/Fx43VN/DVyGA49/OnDjTby/eTwJ5JY1qU5ccFx8rX76sTJEzpcYaH3fm1AI93DneuNev/Q/vr9pN/r4L0H9ejVjyoiIEK5pbnK/DBTfZ7to/vX3K/DZc5/1Ct3rVTCkgTd8c87JEnHqo8pYUmCVu5aadrzAwB4jpO9QiVJhlU2G92/X7rzznMOq/aW7t/2jA6UHlC4f7gevfpR5d6Tq8XpixUfEt/i7bzsXhqXME4/GfoTjUsYx3IugCcLiZNsdmcD/Ys/OY8lXSsx2xOAGzXMSM+vzG9xjGuj0XCWogDa4qGUhxTkG6Svi7/WK1+/IkmqqK3Q9qPOT3fQSG/K2+6tfiHOZe862/IufLagC2h4o96aXv699Ouxv9YvR/9SL3/5sn63+XfKKc7RU58+pWc/e1ZX9rlSGw9slKHG66gfLjus69+4no+iAwAuWH1kuKSD8j56zOxQpMOHpfHjpbw87evlpdsmOXS8e/NDi/wln4R++sOV92n6sOnq7tPCQABdl7evFNxbKj0o7c1yHkucZGpIALoe14z0FjYbLa0pVW6589N4rOkMtE1Y9zDdd9l9evjTh7Vs2zKN6zNOH+z/QCeNk4r0j3T9AQuNDQgZoG+OfaPvjn+nH8T9wOxw2owZ6Wikm3c3zRoxS1/P/lrvTn1XY+PHqq6+TlkHspo00SW5jt2z+h456h3uDhcA4EG8o5xv7nxLyiSHib9TCgqcTfS9e3UiPkZXTndofX/p3zHNfx0Mkf7v2v/T7ZfdThMdQPO+fleqOGsj5bdnOY8DgJvEBDhrrbyKPBlG0/f3Dcu6xAfHq4dfD7fGBnRm1w24TilRKap2VGvKu1P0+22/lyQVVBUo7a00rT2w1uQIrce14WhJ55qRTiMdzbLb7Lo28VptnLFRyyYta3WsIUMHyw5qU+4mN0UHAPBE3SJjJUn2ekMqLjYniOJi6ZprpJwcqU8fffjH+5UXfO6bFVZaZDkaANbz9bvSGzdLjtrGx8vynMdppgNwk8iASElStaNax2uON7netawLs9GB82Kz2ZQalypJqq1v/Pu+sKpQmVmZNNPPMjDkVCO9ky3tQiMd59SzW882jcsrb3nnbwAAziUsOEpFDRO6zVgnvbRUSkuTduyQoqOl9evVI7FtG21FB/GRTQDNqHdIq++Xmvlkp+vY6gec4wCgg/l6+Sq8e7gk56z0s20vcq7pTCMdOD+Oeof+9NWfmr2uYSWHJ7c8yUoOZ2iYkX6g7IBqz55sYGE00nFObW0O0EQAAFyIiIAIFQSeuuDuRnpFhTRpkpSdLYWFSWvXSgMGaEzcGAX7tTwl3Sab+gT30Zi4MW4MFkCnceBTqaz5tYidDKnssHMcALhBdKDzffvZ66QbhqGvir6SJCWHt20iAQCnrYVbVVBV0OL1hgzlV+Vra+FWN0ZlbZH+kQryDZLDcGhv6V6zw2kzGuk4pzFxYxQbHCubbM1eTxMBANAeIgMjVRhw6kJBy4VouztxQvrP/5Q+/VQKCZHWrJEGD5YkPb7pcZXVlDV7s4bfi4vTF8vL7uWuaIEOt2zZMiUkJKhbt25KSUnRli1bWhz74osvymazNfrq1q1bozEzZsxoMiY9Pb2jn4Y1nL0u+oWOA4AL1LBO+pGKxo30g+UHVVJTIh+7jy7qeZEZoQGd1tGqo+06riuw2WydcnkXGuk4Jy+7l5akL5GkJs10mggAgPYSERBxupHurhnpNTVSRoa0YYMUFCR98IF0ySWSpAVZCzQ/a74k6aahNyk2OLbRTWODY7XihhXKSMpwT6yAG7z++uvKzMzU/PnztXXrVg0bNkxpaWkqbOWcDA4OVl5enuvrwIEDTcakp6c3GvPaa6915NOwjsDI9h0HABeoYUZ6XmXjpV0alnVJCk2Sr5ev2+MCOrNw//B2HddVuDYc7USNdG+zA0DnkJGUoRU3rNDc1XN1qOyQ63hscKwWpy+miQAAuGARARHa6s5Gel2dNHWqtHq15O8v/eMf0siRkqRHsh7Rgo0LJElPpj6peVfOk6PeoQ17N+j9j9/XxP+YqKv7Xc0fkeFxFi1apFmzZumWW26RJD3//PP6xz/+ob/85S964IEHmr2NzWZTVFRUq/fr5+d3zjEeKX60FBzj3Fi02XXSbc7r40e7OzIAXVTDjPSz10h3bTQazvrowPkaHjFckf6RKqwqdK2JfiabbIr0j9TwiOEmRGddDZ9++bbkW5MjaTtmpKPNMpIytH/ufm2YvkHLM5Zrw/QN2jd3H010AEC7OHNG+sn8Dt7A2uGQbr5ZWrVK8vOT3nlHGjNGhmFo/ob5rib609c8rXlXzpPk/ITWVfFXaWzPsboq/iqa6PA4tbW1ys7OVmpqquuY3W5XamqqNm/e3OLtKioqFB8frz59+mjy5MnauXNnkzFZWVmKiIhQYmKi7rjjDhUXF3fIc7Acu5eU/uSpC2cvk3jqcvoTznEA4AYxgaca6WfNSN9RdKqRzkajwHnzsnvpgZHOCQctreRw/8j7ef9wFmakw+N52b00LmGc2WEAADxQD78eKg7ykuRQ3ZGDHVek1NdLt90m/e1vko+P9NZbUmqqs4meNV+PfvSoJOmZa57RL0b/oqOiACynqKhIDodDkZGNlxmJjIzUN9980+xtEhMT9Ze//EXJyckqLS3VM888o9GjR2vnzp2KjXUuh5Senq6MjAz17dtXe/bs0UMPPaSJEydq8+bN8vJq/g1lTU2NampqXJfLypx7FdTV1amurq49nm6bNDzWBT3mwImyTXlBXh8+JFv56TWJjeAYOa55XMbAic5PyKBF7ZIHXDDyYL72yEG4n3NpiSMVR1z3U+uo1TfHnK/zSSFJ5PgcOBeswWp5uCrmKj015ik9nf20CqtOf7o2wj9CvxzxS10Vc5VlYm0vF5qD+IB4SVJhVaGKK4sV7BvcbrGdj/OJn0Y6AACwBJvNptrQHpKOyVGQ3zEPYhjSXXdJL74o2e3Sa69JP/yhDMPQwxse1mObHpMk/W7C75Q5KrNjYgA8yKhRozRq1CjX5dGjRyspKUl//OMf9eijzj9KTZ061XX90KFDlZycrP79+ysrK0vjx49v9n4XLlyoBQsWNDn+4Ycfyt/fv52fxbmtWbPmAu/BLvX/H/WqyFG3uhJV+4SoODBR2muX9v6zXWLsCi48D2gP5MF8F5KDaqNaklRaW6q3//G2/Gx+OnTykOrq6+Rv89f2j7Zrh21He4Xq0TgXrMFqeZjjM0f7A/ar3ChXkC1ICd4JqtlRo3/u8Nzf9xeSgx62Hio1SvXK6leU4J3QfkGdh6qqqjaPpZEOAAAswxERJumY7EeLLuyOcnOlorPuwzCkxYulV15xXn7pJWnKFBmGoV+v/7X+5+P/kSQtmrBI946698IeH+iEwsLC5OXlpYKCgkbHCwoK2ry+uY+Pjy699FLt3r27xTH9+vVTWFiYdu/e3WIj/cEHH1Rm5uk/ZpWVlalPnz6aMGGCgoPdN1uprq5Oa9as0TXXXCMfH592uMcftcN9dD3tnwd8H+TBfO2VgyVvLlF5XbmSr0xW/5D++lvO36RsaXj0cP1w3A/bMWLPxLlgDeTBfO2Rg9VZq/XxkY8VNihMky6a1M4Rtk3DJx/bgkY6AACwDFtEpKRv5VN8/PvfSW6ulJgoVVe3PMbbWxo7VoZh6Ffrf6WFHy+UJC1OW6y5V8z9/o8NdGK+vr4aMWKE1q1bp+uuu06SVF9fr3Xr1mnOnDltug+Hw6EdO3Zo0qSW3wgdOnRIxcXFio6ObnGMn5+f/Pz8mhz38fEx5c2yWY+LxsiDNZAH811oDmICY5RzPEeFNYUa5DNIO48797ZIjkgmt+eBc8EayIP5LiQHF4VepI+PfKy9ZXtNy+P5PC6NdAAAYL5TM8j7V3eXJPmcqJE++UTq7ryssDApLq5t91VU1HoTXZJOnpRx9Kge+vYPeuKTJyRJS9KX6O6Uu7/vMwA8QmZmpqZPn67LLrtMI0eO1OLFi1VZWalbbrlFknTzzTerd+/eWrjQ+cen3/72t7riiis0YMAAlZSU6Omnn9aBAwd02223SXJuRLpgwQJNmTJFUVFR2rNnj+bNm6cBAwYoLS3NtOcJAF1ZdGC0co7nKK/CueHojqPOpVySw5LNDAtAF+TacLSkc2w4SiMdAACY64wZ5L8+8/h//Mfpn7t1k3Jy2t5Mb4Olny/VE0f/6vw5fanuSrmr3e4b6KxuvPFGHT16VA8//LDy8/N1ySWXaPXq1a4NSHNzc2W3213jjx8/rlmzZik/P189e/bUiBEj9Omnn2rw4MGSJC8vL23fvl0vvfSSSkpKFBMTowkTJujRRx9tdsY5AKDjxQTESJKOVB5RSXWJcstzJUlDwoaYGRaALmhgiLORvvv4bhmGIZvNZnJEraORDgAAzNWWGeTV1c5xZzbSKyqkffukvXsbf339dZse9qUv/yrFSL+f+HvNHjn7Ap4A4FnmzJnT4lIuWVlZjS4/++yzevbZZ1u8r+7du+uDDz5oz/AAABcoJtDZSM+ryNOOIuds9PjgePXw62FmWAC6oH49+snb5q3yunLlV+YrOrDlpf+sgEY6AADoHP73f6UTJ043zAsLL/gul01apjsvv7MdggMAAOgcogOcjaq8ytON9KFhQ80MCUAX5ePlo4QeCdpdslvflXxHIx0AAKBd/PnPTY/17Cn16yf17+/83q+f5HBId9xxzrt78D8e0H/RRAcAAF1Mw4z0I5VHtL1ouyQa6QDMMzBkoHaX7Na3x7/V2NixZofTKhrpAACgc8jIkFJSTjfM+/Z1NtLPtnVrm+7uvy7+r3YOEAAAwPqiAqIkSUerjurEyROSpORwNhoFYI6BPQfq/f3v67vj1t9wlEY6AADoHH71K2n48HMOc9Q75NWGu2vrOAAAAE/Sq1sv+Xn5qcZRo/LacvnafZXYM9HssAB0UQN7Ojcc/a7E+o10u9kBAAAAtKctNXt14hxTBU54O8cBAAB0NTabTVH+Ua7LsUGxsttoDwEwR0MjfU/JHv19z9/1Rf4XctQ7TI6qecxIBwAAndqxE8e0vWC762v9vvU6OUcKq2r5NkX+0pPB9RrlvjABAAAsYe2BtcqrzHNd3lu6V2lvpemBkQ8oNT7VxMgAdEVfF30tm2yqN+r10McPSZIi/SMt+ZpEIx0AAJgrLEwOXx951da1OMTh6yMjNETfHv1a2wu268v8L7W90Nk4P1R2qOkNQqSDIa0/bHSQtXeEBwAAaG9rD6xVZlamDBmNjhdWFSozK1OLxi2yXOMKgOdae2CtfrHxF53mNYlGOgAAMJUjtrdG399LdQX5LY4pDTR06OUk1dbXNnt9QkiChkUOU3Jksi6OuFj3rL5HBRUFTQoySbLJptjgWI2JG9NuzwEAAMDqHPUOPbHliWbrI0OGbLLpyS1P6uo+V8vLzk4yADpWZ3xNopEOAABMtSl3k7Z45UsxrY06KdVLgb6BGhoxVMmRya7G+ZCIIerRrUej0T52H13/xvWyydaoMLPJJklanL7YMsUYAACAO2wt3KqCqoIWrzdkKL8qX1sLt+ryqMvdGBmArqgzvibRSAcAAKbKK8879yBJz6Y9q7tT7m7TZlgZSRlaccMKzV09t9HSL7HBsVqcvlgZSRnfO14AAIDO6GjV0XYdBwAXojO+JtFIBwAApmrrWuWXRF3SpiZ6g4ykDE1OnKxNuZuUV56n6KBojYkbw0x0AADQJYX7h7frOAC4EJ3xNYlGOgAAMNWYuDGKDY7V4bLD7b6muZfdS+MSxrVDlAAAAJ3b8IjhivSPVGFVYYs1V6R/pIZHDDchOgBdTWd8TWr7tC4AAIAO4GX30pL0JZJOr2HegDXNAQAA2oeX3UsPjHxAUss11/0j76fmAuAWnfE1iUY6AAAwXcOa5r2Dezc6HhscqxU3rGBNcwAAgHaQGp+qReMWKcI/otHxSP9ILRq3SKnxqSZFBqAr6myvSSztAgAALIE1zQEAADpeanyqru5ztbYWbtXRqqMK9w/X8Ijh1FwATNGZXpNopAMAAMtgTXMAAICO52X30uVRl5sdBgBI6jyvSSztAgAAAAAAAABAK2ikAwAAAAAAAADQChrpAAAAAAAAAAC0gkY6AAAAAAAAAACtoJEOAAAAAAAAAEAraKQDAAAAAAAAANAKGukAAAAAAAAAALSi0zTSjx07pmnTpik4OFghISGaOXOmKioqWh1/1113KTExUd27d1dcXJzuvvtulZaWujFqAAAAAAAAAEBn12ka6dOmTdPOnTu1Zs0avffee/roo4/0s5/9rMXxR44c0ZEjR/TMM8/oq6++0osvvqjVq1dr5syZbowaAAAAAAAAANDZeZsdQFvs2rVLq1ev1hdffKHLLrtMkvTcc89p0qRJeuaZZxQTE9PkNkOGDNFbb73luty/f389/vjjuummm3Ty5El5e3eKpw4AAAAAAAAAMFmn6CZv3rxZISEhria6JKWmpsput+vzzz/Xj3/84zbdT2lpqYKDg1ttotfU1KimpsZ1uaysTJJUV1enurq67/kMzl/DY7nzMdEUeTAfObAG8mAN5MF85MAaPCUPnT1+AAAAoCvpFI30/Px8RURENDrm7e2t0NBQ5efnt+k+ioqK9Oijj7a6HIwkLVy4UAsWLGhyfNWqVfL392970O3knXfecftjoinyYD5yYA3kwRrIg/nIgTV09jxUVVVJkgzDMDkS62v4f9QwycVd6urqVFVVpbKyMvn4+Lj1sXEaebAG8mA+cmAN5MEayIP5PCUHDfVlW2pyUxvpDzzwgJ588slWx+zateuCH6esrEw//OEPNXjwYD3yyCOtjn3wwQeVmZnpunz48GENHjxYt9122wXHAQAAAJytvLxcPXr0MDsMSysvL5ck9enTx+RIAAAA4InaUpOb2kj/xS9+oRkzZrQ6pl+/foqKilJhYWGj4ydPntSxY8cUFRXV6u3Ly8uVnp6uoKAgvf322+f8C4mfn5/8/PxclwMDA3Xw4EEFBQXJZrO1/oTaUVlZmfr06aODBw8qODjYbY+LxsiD+ciBNZAHayAP5iMH1uApeTAMQ+Xl5c3u94PGYmJiqMm7MPJgDeTBfOTAGsiDNZAH83lKDs6nJje1kR4eHq7w8PBzjhs1apRKSkqUnZ2tESNGSJLWr1+v+vp6paSktHi7srIypaWlyc/PT++++666det23jHa7XbFxsae9+3aS3BwcKf+x+gpyIP5yIE1kAdrIA/mIwfW4Al5YCZ621CTQyIPVkEezEcOrIE8WAN5MJ8n5KCtNbm9g+NoF0lJSUpPT9esWbO0ZcsWffLJJ5ozZ46mTp3q+mvB4cOHNWjQIG3ZskWSs4k+YcIEVVZW6s9//rPKysqUn5+v/Px8ORwOM58OAAAAAAAAAKAT6RSbjUrSq6++qjlz5mj8+PGy2+2aMmWKli5d6rq+rq5OOTk5rk2btm7dqs8//1ySNGDAgEb3tW/fPiUkJLgtdgAAAAAAAABA59VpGumhoaFavnx5i9cnJCQ02l113Lhxbdpt1ar8/Pw0f/78Ruu1w/3Ig/nIgTWQB2sgD+YjB9ZAHuAu/FuzBvJgDeTBfOTAGsiDNZAH83XFHNiMztxtBgAAAAAAAACgg3WKNdIBAAAAAAAAADALjXQAAAAAAAAAAFpBIx0AAAAAAAAAgFbQSLeoZcuWKSEhQd26dVNKSoq2bNlidkhdyiOPPCKbzdboa9CgQWaH5dE++ugjXXvttYqJiZHNZtOqVasaXW8Yhh5++GFFR0ere/fuSk1N1XfffWdOsB7sXHmYMWNGk3MjPT3dnGA91MKFC3X55ZcrKChIERERuu6665STk9NoTHV1tWbPnq1evXopMDBQU6ZMUUFBgUkRe6a25GHcuHFNzofbb7/dpIg9zx/+8AclJycrODhYwcHBGjVqlN5//33X9ZwHcAdqcnNRk7sfNbk1UJObj5rcGqjJrYG6/DQa6Rb0+uuvKzMzU/Pnz9fWrVs1bNgwpaWlqbCw0OzQupSLL75YeXl5rq+PP/7Y7JA8WmVlpYYNG6Zly5Y1e/1TTz2lpUuX6vnnn9fnn3+ugIAApaWlqbq62s2RerZz5UGS0tPTG50br732mhsj9HwbN27U7Nmz9dlnn2nNmjWqq6vThAkTVFlZ6Rpz77336u9//7vefPNNbdy4UUeOHFFGRoaJUXuetuRBkmbNmtXofHjqqadMitjzxMbG6oknnlB2drb+9a9/6Qc/+IEmT56snTt3SuI8QMejJrcGanL3oia3Bmpy81GTWwM1uTVQl5/BgOWMHDnSmD17tuuyw+EwYmJijIULF5oYVdcyf/58Y9iwYWaH0WVJMt5++23X5fr6eiMqKsp4+umnXcdKSkoMPz8/47XXXjMhwq7h7DwYhmFMnz7dmDx5sinxdFWFhYWGJGPjxo2GYTj/7fv4+Bhvvvmma8yuXbsMScbmzZvNCtPjnZ0HwzCMq666ypg7d655QXVBPXv2NP70pz9xHsAtqMnNR01uLmpya6AmtwZqcmugJreOrlqXMyPdYmpra5Wdna3U1FTXMbvdrtTUVG3evNnEyLqe7777TjExMerXr5+mTZum3Nxcs0Pqsvbt26f8/PxG50WPHj2UkpLCeWGCrKwsRUREKDExUXfccYeKi4vNDsmjlZaWSpJCQ0MlSdnZ2aqrq2t0PgwaNEhxcXGcDx3o7Dw0ePXVVxUWFqYhQ4bowQcfVFVVlRnheTyHw6G//e1vqqys1KhRozgP0OGoya2Dmtw6qMmthZrcvajJrYGa3HxdvS73NjsANFZUVCSHw6HIyMhGxyMjI/XNN9+YFFXXk5KSohdffFGJiYnKy8vTggULNGbMGH311VcKCgoyO7wuJz8/X5KaPS8aroN7pKenKyMjQ3379tWePXv00EMPaeLEidq8ebO8vLzMDs/j1NfX65577tGVV16pIUOGSHKeD76+vgoJCWk0lvOh4zSXB0n66U9/qvj4eMXExGj79u26//77lZOTo5UrV5oYrWfZsWOHRo0aperqagUGBurtt9/W4MGDtW3bNs4DdChqcmugJrcWanLroCZ3L2pya6AmNxd1uRONdKAZEydOdP2cnJyslJQUxcfH64033tDMmTNNjAww19SpU10/Dx06VMnJyerfv7+ysrI0fvx4EyPzTLNnz9ZXX33FerAmaykPP/vZz1w/Dx06VNHR0Ro/frz27Nmj/v37uztMj5SYmKht27aptLRUK1as0PTp07Vx40azwwLgJtTkQPOoyd2LmtwaqMnNRV3uxNIuFhMWFiYvL68mu9sWFBQoKirKpKgQEhKiiy66SLt37zY7lC6p4d8+54X19OvXT2FhYZwbHWDOnDl67733tGHDBsXGxrqOR0VFqba2ViUlJY3Gcz50jJby0JyUlBRJ4nxoR76+vhowYIBGjBihhQsXatiwYVqyZAnnATocNbk1UZObi5rcuqjJOw41uTVQk5uPutyJRrrF+Pr6asSIEVq3bp3rWH19vdatW6dRo0aZGFnXVlFRoT179ig6OtrsULqkvn37KioqqtF5UVZWps8//5zzwmSHDh1ScXEx50Y7MgxDc+bM0dtvv63169erb9++ja4fMWKEfHx8Gp0POTk5ys3N5XxoR+fKQ3O2bdsmSZwPHai+vl41NTWcB+hw1OTWRE1uLmpy66Imb3/U5NZATW5dXbUuZ2kXC8rMzNT06dN12WWXaeTIkVq8eLEqKyt1yy23mB1al/HLX/5S1157reLj43XkyBHNnz9fXl5e+slPfmJ2aB6roqKi0V+M9+3bp23btik0NFRxcXG655579Nhjj2ngwIHq27evfvOb3ygmJkbXXXedeUF7oNbyEBoaqgULFmjKlCmKiorSnj17NG/ePA0YMEBpaWkmRu1ZZs+ereXLl+udd95RUFCQa125Hj16qHv37urRo4dmzpypzMxMhYaGKjg4WHfddZdGjRqlK664wuToPce58rBnzx4tX75ckyZNUq9evbR9+3bde++9Gjt2rJKTk02O3jM8+OCDmjhxouLi4lReXq7ly5crKytLH3zwAecB3IKa3HzU5O5HTW4N1OTmoya3Bmpya6AuP4MBS3ruueeMuLg4w9fX1xg5cqTx2WefmR1Sl3LjjTca0dHRhq+vr9G7d2/jxhtvNHbv3m12WB5tw4YNhqQmX9OnTzcMwzDq6+uN3/zmN0ZkZKTh5+dnjB8/3sjJyTE3aA/UWh6qqqqMCRMmGOHh4YaPj48RHx9vzJo1y8jPzzc7bI/S3P9/ScYLL7zgGnPixAnjzjvvNHr27Gn4+/sbP/7xj428vDzzgvZA58pDbm6uMXbsWCM0NNTw8/MzBgwYYNx3331GaWmpuYF7kFtvvdWIj483fH19jfDwcGP8+PHGhx9+6Lqe8wDuQE1uLmpy96MmtwZqcvNRk1sDNbk1UJefZjMMw+iYFj0AAAAAAAAAAJ0fa6QDAAAAAAAAANAKGukAAAAAAAAAALSCRjoAAAAAAAAAAK2gkQ4AAAAAAAAAQCtopAMAAAAAAAAA0Aoa6QAAAAAAAAAAtIJGOgAAAAAAAAAAraCRDgAAAAAAAABAK2ikAwAAAAAAAADQChrpAABJ0owZM3TdddeZHQYAAADQZVGTA4B10UgHAFhSbW2t2SEAAAAAXRo1OQCcRiMdAHBOixYt0tChQxUQEKA+ffrozjvvVEVFhSSpsrJSwcHBWrFiRaPbrFq1SgEBASovL5ckHTx4UDfccINCQkIUGhqqyZMna//+/a7xDbNvHn/8ccXExCgxMdFtzw8AAACwOmpyADAXjXQAwDnZ7XYtXbpUO3fu1EsvvaT169dr3rx5kqSAgABNnTpVL7zwQqPbvPDCC7r++usVFBSkuro6paWlKSgoSJs2bdInn3yiwMBApaenN5rlsm7dOuXk5GjNmjV677333PocAQAAACujJgcAc9kMwzDMDgIAYL4ZM2aopKREq1atOufYFStW6Pbbb1dRUZEkacuWLRo9erQOHjyo6OhoFRYWqnfv3lq7dq2uuuoqvfLKK3rssce0a9cu2Ww2Sc6PiYaEhGjVqlWaMGGCZsyYodWrVys3N1e+vr4d+VQBAAAAS6ImBwDrYkY6AOCc1q5dq/Hjx6t3794KCgrSf//3f6u4uFhVVVWSpJEjR+riiy/WSy+9JEl65ZVXFB8fr7Fjx0qSvvzyS+3evVtBQUEKDAxUYGCgQkNDVV1drT179rgeZ+jQoRTsAAAAQDOoyQHAXDTSAQCt2r9/v370ox8pOTlZb731lrKzs7Vs2TJJjTcfuu222/Tiiy9Kcn6E9JZbbnHNdKmoqNCIESO0bdu2Rl/ffvutfvrTn7ruIyAgwH1PDAAAAOgkqMkBwHzeZgcAALC27Oxs1dfX63e/+53sduffX994440m42666SbNmzdPS5cu1ddff63p06e7rhs+fLhef/11RUREKDg42G2xAwAAAJ6AmhwAzMeMdACAS2lpaZMZKmFhYaqrq9Nzzz2nvXv36uWXX9bzzz/f5LY9e/ZURkaG7rvvPk2YMEGxsbGu66ZNm6awsDBNnjxZmzZt0r59+5SVlaW7775bhw4dcudTBAAAACyNmhwArIlGOgDAJSsrS5deemmjr5dfflmLFi3Sk08+qSFDhujVV1/VwoULm739zJkzVVtbq1tvvbXRcX9/f3300UeKi4tTRkaGkpKSNHPmTFVXVzMbBgAAADgDNTkAWJPNMAzD7CAAAJ7h5Zdf1r333qsjR46wQREAAABgAmpyAOgYrJEOALhgVVVVysvL0xNPPKGf//znFOwAAACAm1GTA0DHYmkXAMAFe+qppzRo0CBFRUXpwQcfNDscAAAAoMuhJgeAjsXSLgAAAAAAAAAAtIIZ6QAAAAAAAAAAtIJGOgAAAAAAAAAAraCRDgAAAAAAAABAK2ikAwAAAAAAAADQChrpAAAAAAAAAAC0gkY6AAAAAAAAAACtoJEOAAAAAAAAAEAraKQDAAAAAAAAANAKGukAAAAAAAAAALTi/wO28ojwEv9qFwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1500x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top performing layer-feature combinations by binary acc:\n",
      "================================================================================\n",
      "Rank Layer  Pool   Feature    Binary Acc   Multi Acc    Spearman r  \n",
      "--------------------------------------------------------------------------------\n",
      "1    16     mean   pca        0.823±0.062 0.362±0.116 0.039\n",
      "2    27     mean   pca        0.823±0.039 0.423±0.100 -0.071\n",
      "3    28     mean   pca        0.815±0.057 0.438±0.108 -0.067\n",
      "4    6      mean   pca        0.815±0.029 0.346±0.054 -0.070\n",
      "5    19     mean   pca        0.815±0.057 0.400±0.099 -0.066\n",
      "Top performing layer-feature combinations by multi-class acc:\n",
      "================================================================================\n",
      "Rank Layer  Pool   Feature    Binary Acc   Multi Acc    Spearman r  \n",
      "--------------------------------------------------------------------------------\n",
      "1    9      mean   attention  0.585±0.071 0.485±0.071 0.271\n",
      "2    9      last   attention  0.585±0.071 0.485±0.071 0.271\n",
      "3    11     mean   attention  0.592±0.062 0.477±0.052 0.266\n",
      "4    11     last   attention  0.592±0.062 0.477±0.052 0.266\n",
      "5    30     mean   attention  0.623±0.075 0.462±0.117 0.020\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import cross_val_score, StratifiedKFold\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import classification_report, accuracy_score\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.impute import SimpleImputer\n",
    "from scipy.stats import spearmanr, pearsonr\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "def safe_entropy(X):\n",
    "    \"\"\"Compute entropy safely, handling NaN and infinite values\"\"\"\n",
    "    # Clip extreme values\n",
    "    X_clipped = np.clip(X, -50, 50)  # Prevent overflow in exp\n",
    "    \n",
    "    # Stable softmax\n",
    "    X_shifted = X_clipped - np.max(X_clipped, axis=1, keepdims=True)\n",
    "    e_x = np.exp(X_shifted)\n",
    "    probs = e_x / (e_x.sum(axis=1, keepdims=True) + 1e-12)\n",
    "    \n",
    "    # Compute entropy\n",
    "    log_probs = np.log(probs + 1e-12)\n",
    "    entropies = -np.sum(probs * log_probs, axis=1)\n",
    "    \n",
    "    # Handle any remaining NaN/inf values\n",
    "    entropies = np.nan_to_num(entropies, nan=0.0, posinf=0.0, neginf=0.0)\n",
    "    \n",
    "    return entropies.reshape(-1, 1)\n",
    "\n",
    "def clean_features(X):\n",
    "    \"\"\"Clean feature matrix by handling NaN and infinite values\"\"\"\n",
    "    # Replace NaN and infinite values\n",
    "    X_clean = np.nan_to_num(X, nan=0.0, posinf=1e6, neginf=-1e6)\n",
    "    \n",
    "    # Remove constant features (they cause issues with scaling)\n",
    "    feature_vars = np.var(X_clean, axis=0)\n",
    "    non_constant_mask = feature_vars > 1e-12\n",
    "    \n",
    "    if np.sum(non_constant_mask) == 0:\n",
    "        # All features are constant, return a single feature of zeros\n",
    "        return np.zeros((X_clean.shape[0], 1))\n",
    "    \n",
    "    X_clean = X_clean[:, non_constant_mask]\n",
    "    \n",
    "    return X_clean\n",
    "\n",
    "def improved_layer_analysis(all_reps, all_attn, labels):\n",
    "    \"\"\"\n",
    "    Better approach for layer selection based on actual classification performance\n",
    "    \"\"\"\n",
    "    results = []\n",
    "    \n",
    "    # Convert labels to classification problem (you can adjust this)\n",
    "    # Option 1: Binary (high vs low quality)\n",
    "    binary_labels = (labels >= 4).astype(int)  # 4,5 = high quality\n",
    "    \n",
    "    # Option 2: Multi-class (keep original 2,3,4,5)\n",
    "    multiclass_labels = labels\n",
    "    \n",
    "    print(f\"Processing {len(all_reps)} layers...\")\n",
    "    \n",
    "    for l in all_reps:\n",
    "        print(f\"Layer {l}...\")\n",
    "        for pool_type in [\"mean\", \"last\"]:\n",
    "            X = all_reps[l][pool_type]\n",
    "            \n",
    "            # Skip if X is empty or has issues\n",
    "            if X.shape[0] == 0 or X.shape[1] == 0:\n",
    "                continue\n",
    "            \n",
    "            # Feature engineering\n",
    "            features = {}\n",
    "            \n",
    "            try:\n",
    "                # 1. Raw representations (select top components)\n",
    "                X_clean = clean_features(X)\n",
    "                if X_clean.shape[1] > 0:\n",
    "                    n_components = min(50, X_clean.shape[1], X_clean.shape[0] - 1)\n",
    "                    if n_components > 0:\n",
    "                        pca = PCA(n_components=n_components)\n",
    "                        X_pca = pca.fit_transform(X_clean)\n",
    "                        features['pca'] = clean_features(X_pca)\n",
    "                \n",
    "                # 2. Statistical features\n",
    "                norms = np.linalg.norm(X, axis=1).reshape(-1, 1)\n",
    "                variances = X.var(axis=1).reshape(-1, 1)\n",
    "                entropies = safe_entropy(X)\n",
    "                \n",
    "                stats_features = np.hstack([norms, variances, entropies])\n",
    "                features['stats'] = clean_features(stats_features)\n",
    "                \n",
    "                # 3. Attention features\n",
    "                if l in all_attn:\n",
    "                    attn_data = all_attn[l]\n",
    "                    attn_mean = attn_data.mean(axis=1).reshape(-1, 1)\n",
    "                    attn_std = attn_data.std(axis=1).reshape(-1, 1)\n",
    "                    attn_max = attn_data.max(axis=1).reshape(-1, 1)\n",
    "                    \n",
    "                    attn_features = np.hstack([attn_mean, attn_std, attn_max])\n",
    "                    features['attention'] = clean_features(attn_features)\n",
    "                \n",
    "            except Exception as e:\n",
    "                print(f\"Error processing layer {l}, pool {pool_type}: {e}\")\n",
    "                continue\n",
    "            \n",
    "            # Test different feature combinations\n",
    "            for feature_name, X_feat in features.items():\n",
    "                if X_feat.shape[1] == 0:\n",
    "                    continue\n",
    "                    \n",
    "                try:\n",
    "                    # Use imputer and scaler pipeline\n",
    "                    imputer = SimpleImputer(strategy='median')\n",
    "                    scaler = StandardScaler()\n",
    "                    \n",
    "                    X_imputed = imputer.fit_transform(X_feat)\n",
    "                    X_scaled = scaler.fit_transform(X_imputed)\n",
    "                    \n",
    "                    # Binary classification\n",
    "                    clf_binary = LogisticRegression(random_state=42, max_iter=1000)\n",
    "                    cv_scores_binary = cross_val_score(\n",
    "                        clf_binary, X_scaled, binary_labels, \n",
    "                        cv=StratifiedKFold(n_splits=5, shuffle=True, random_state=42),\n",
    "                        scoring='accuracy'\n",
    "                    )\n",
    "                    \n",
    "                    # Multi-class classification\n",
    "                    clf_multi = LogisticRegression(random_state=42, max_iter=1000)\n",
    "                    cv_scores_multi = cross_val_score(\n",
    "                        clf_multi, X_scaled, multiclass_labels,\n",
    "                        cv=StratifiedKFold(n_splits=5, shuffle=True, random_state=42),\n",
    "                        scoring='accuracy'\n",
    "                    )\n",
    "                    \n",
    "                    # Correlation analysis\n",
    "                    if X_feat.shape[1] == 1:\n",
    "                        feat_1d = X_imputed.flatten()\n",
    "                        # Check for constant features\n",
    "                        if np.std(feat_1d) > 1e-12:\n",
    "                            corr_pearson, p_pearson = pearsonr(feat_1d, labels)\n",
    "                            corr_spearman, p_spearman = spearmanr(feat_1d, labels)\n",
    "                        else:\n",
    "                            corr_pearson, p_pearson = 0.0, 1.0\n",
    "                            corr_spearman, p_spearman = 0.0, 1.0\n",
    "                    else:\n",
    "                        # For multi-dimensional features, use first PC\n",
    "                        if X_imputed.shape[1] > 1:\n",
    "                            pc1 = PCA(n_components=1).fit_transform(X_imputed).flatten()\n",
    "                            if np.std(pc1) > 1e-12:\n",
    "                                corr_pearson, p_pearson = pearsonr(pc1, labels)\n",
    "                                corr_spearman, p_spearman = spearmanr(pc1, labels)\n",
    "                            else:\n",
    "                                corr_pearson, p_pearson = 0.0, 1.0\n",
    "                                corr_spearman, p_spearman = 0.0, 1.0\n",
    "                        else:\n",
    "                            corr_pearson, p_pearson = 0.0, 1.0\n",
    "                            corr_spearman, p_spearman = 0.0, 1.0\n",
    "                    \n",
    "                    results.append({\n",
    "                        'layer': l,\n",
    "                        'pool_type': pool_type,\n",
    "                        'feature_type': feature_name,\n",
    "                        'binary_acc_mean': cv_scores_binary.mean(),\n",
    "                        'binary_acc_std': cv_scores_binary.std(),\n",
    "                        'multi_acc_mean': cv_scores_multi.mean(),\n",
    "                        'multi_acc_std': cv_scores_multi.std(),\n",
    "                        'pearson_r': corr_pearson,\n",
    "                        'pearson_p': p_pearson,\n",
    "                        'spearman_r': corr_spearman,\n",
    "                        'spearman_p': p_spearman,\n",
    "                        'n_features': X_feat.shape[1]\n",
    "                    })\n",
    "                \n",
    "                except Exception as e:\n",
    "                    print(f\"Error with layer {l}, pool {pool_type}, feature {feature_name}: {e}\")\n",
    "                    continue\n",
    "    \n",
    "    return results\n",
    "\n",
    "def analyze_layer_progression(results):\n",
    "    \"\"\"\n",
    "    Analyze how probing performance changes across layers\n",
    "    \"\"\"\n",
    "    # Group by layer and feature type\n",
    "    layer_analysis = {}\n",
    "    \n",
    "    for result in results:\n",
    "        layer = result['layer']\n",
    "        if layer not in layer_analysis:\n",
    "            layer_analysis[layer] = []\n",
    "        layer_analysis[layer].append(result)\n",
    "    \n",
    "    # Plot layer progression\n",
    "    fig, axes = plt.subplots(2, 2, figsize=(15, 10))\n",
    "    \n",
    "    layers = sorted(layer_analysis.keys())\n",
    "    \n",
    "    # Binary classification accuracy\n",
    "    binary_means = []\n",
    "    binary_stds = []\n",
    "    for layer in layers:\n",
    "        best_result = max(layer_analysis[layer], key=lambda x: x['binary_acc_mean'])\n",
    "        binary_means.append(best_result['binary_acc_mean'])\n",
    "        binary_stds.append(best_result['binary_acc_std'])\n",
    "    \n",
    "    axes[0,0].errorbar(layers, binary_means, yerr=binary_stds, marker='o')\n",
    "    axes[0,0].set_title('Binary Classification Accuracy by Layer')\n",
    "    axes[0,0].set_xlabel('Layer')\n",
    "    axes[0,0].set_ylabel('Accuracy')\n",
    "    axes[0,0].grid(True)\n",
    "    \n",
    "    # Multi-class accuracy\n",
    "    multi_means = []\n",
    "    multi_stds = []\n",
    "    for layer in layers:\n",
    "        best_result = max(layer_analysis[layer], key=lambda x: x['multi_acc_mean'])\n",
    "        multi_means.append(best_result['multi_acc_mean'])\n",
    "        multi_stds.append(best_result['multi_acc_std'])\n",
    "    \n",
    "    axes[0,1].errorbar(layers, multi_means, yerr=multi_stds, marker='o', color='orange')\n",
    "    axes[0,1].set_title('Multi-class Classification Accuracy by Layer')\n",
    "    axes[0,1].set_xlabel('Layer')\n",
    "    axes[0,1].set_ylabel('Accuracy')\n",
    "    axes[0,1].grid(True)\n",
    "    \n",
    "    # Correlation analysis\n",
    "    pearson_corrs = []\n",
    "    spearman_corrs = []\n",
    "    for layer in layers:\n",
    "        best_pearson = max(layer_analysis[layer], key=lambda x: abs(x['pearson_r']))\n",
    "        best_spearman = max(layer_analysis[layer], key=lambda x: abs(x['spearman_r']))\n",
    "        pearson_corrs.append(best_pearson['pearson_r'])\n",
    "        spearman_corrs.append(best_spearman['spearman_r'])\n",
    "    \n",
    "    axes[1,0].plot(layers, pearson_corrs, marker='o', label='Pearson', color='green')\n",
    "    axes[1,0].plot(layers, spearman_corrs, marker='s', label='Spearman', color='red')\n",
    "    axes[1,0].set_title('Correlation by Layer')\n",
    "    axes[1,0].set_xlabel('Layer')\n",
    "    axes[1,0].set_ylabel('Correlation')\n",
    "    axes[1,0].legend()\n",
    "    axes[1,0].grid(True)\n",
    "    \n",
    "    # Feature type comparison\n",
    "    feature_types = ['pca', 'stats', 'attention']\n",
    "    feature_performance = {ft: [] for ft in feature_types}\n",
    "    \n",
    "    for layer in layers:\n",
    "        for ft in feature_types:\n",
    "            ft_results = [r for r in layer_analysis[layer] if r['feature_type'] == ft]\n",
    "            if ft_results:\n",
    "                best_ft = max(ft_results, key=lambda x: x['binary_acc_mean'])\n",
    "                feature_performance[ft].append(best_ft['binary_acc_mean'])\n",
    "            else:\n",
    "                feature_performance[ft].append(0)\n",
    "    \n",
    "    for ft in feature_types:\n",
    "        axes[1,1].plot(layers, feature_performance[ft], marker='o', label=ft)\n",
    "    \n",
    "    axes[1,1].set_title('Feature Type Performance by Layer')\n",
    "    axes[1,1].set_xlabel('Layer')\n",
    "    axes[1,1].set_ylabel('Binary Classification Accuracy')\n",
    "    axes[1,1].legend()\n",
    "    axes[1,1].grid(True)\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "    return layer_analysis\n",
    "\n",
    "def select_best_layers(results, top_k=5):\n",
    "    \"\"\"\n",
    "    Select the best layers based on classification performance\n",
    "    \"\"\"\n",
    "    # Sort by binary classification accuracy (you can change this criterion)\n",
    "    sorted_results = sorted(results, key=lambda x: x['binary_acc_mean'], reverse=True)\n",
    "    print(\"Top performing layer-feature combinations by binary acc:\")\n",
    "    print(\"=\" * 80)\n",
    "    print(f\"{'Rank':<4} {'Layer':<6} {'Pool':<6} {'Feature':<10} {'Binary Acc':<12} {'Multi Acc':<12} {'Spearman r':<12}\")\n",
    "    print(\"-\" * 80)\n",
    "    for i, result in enumerate(sorted_results[:top_k]):\n",
    "        print(f\"{i+1:<4} {result['layer']:<6} {result['pool_type']:<6} {result['feature_type']:<10} \"\n",
    "              f\"{result['binary_acc_mean']:.3f}±{result['binary_acc_std']:.3f} \"\n",
    "              f\"{result['multi_acc_mean']:.3f}±{result['multi_acc_std']:.3f} \"\n",
    "              f\"{result['spearman_r']:.3f}\")\n",
    "\n",
    "\n",
    "    sorted_results = sorted(results, key=lambda x: x['multi_acc_mean'], reverse=True)\n",
    "    print(\"Top performing layer-feature combinations by multi-class acc:\")\n",
    "    print(\"=\" * 80)\n",
    "    print(f\"{'Rank':<4} {'Layer':<6} {'Pool':<6} {'Feature':<10} {'Binary Acc':<12} {'Multi Acc':<12} {'Spearman r':<12}\")\n",
    "    print(\"-\" * 80)\n",
    "    for i, result in enumerate(sorted_results[:top_k]):\n",
    "        print(f\"{i+1:<4} {result['layer']:<6} {result['pool_type']:<6} {result['feature_type']:<10} \"\n",
    "              f\"{result['binary_acc_mean']:.3f}±{result['binary_acc_std']:.3f} \"\n",
    "              f\"{result['multi_acc_mean']:.3f}±{result['multi_acc_std']:.3f} \"\n",
    "              f\"{result['spearman_r']:.3f}\")\n",
    "    \n",
    "    return sorted_results[:top_k]\n",
    "\n",
    "# Example usage:\n",
    "# First, let's diagnose your original data\n",
    "def diagnose_data_issues(all_reps, all_attn, labels):\n",
    "    \"\"\"Diagnose NaN and infinite values in your data\"\"\"\n",
    "    print(\"Data Diagnostics:\")\n",
    "    print(\"=\" * 50)\n",
    "    \n",
    "    # Check labels\n",
    "    print(f\"Labels: {len(labels)} samples\")\n",
    "    print(f\"  NaN values: {np.sum(np.isnan(labels))}\")\n",
    "    print(f\"  Infinite values: {np.sum(np.isinf(labels))}\")\n",
    "    print(f\"  Unique values: {np.unique(labels)}\")\n",
    "    \n",
    "    # Check representations\n",
    "    total_nan_reps = 0\n",
    "    total_inf_reps = 0\n",
    "    \n",
    "    for l in all_reps:\n",
    "        for pool_type in [\"mean\", \"last\"]:\n",
    "            X = all_reps[l][pool_type]\n",
    "            nan_count = np.sum(np.isnan(X))\n",
    "            inf_count = np.sum(np.isinf(X))\n",
    "            \n",
    "            if nan_count > 0 or inf_count > 0:\n",
    "                print(f\"Layer {l}-{pool_type}: {nan_count} NaN, {inf_count} Inf values\")\n",
    "            \n",
    "            total_nan_reps += nan_count\n",
    "            total_inf_reps += inf_count\n",
    "    \n",
    "    print(f\"Total representation issues: {total_nan_reps} NaN, {total_inf_reps} Inf\")\n",
    "    \n",
    "    # Check attention\n",
    "    total_nan_attn = 0\n",
    "    total_inf_attn = 0\n",
    "    \n",
    "    for l in all_attn:\n",
    "        A = all_attn[l]\n",
    "        nan_count = np.sum(np.isnan(A))\n",
    "        inf_count = np.sum(np.isinf(A))\n",
    "        \n",
    "        if nan_count > 0 or inf_count > 0:\n",
    "            print(f\"Attention layer {l}: {nan_count} NaN, {inf_count} Inf values\")\n",
    "        \n",
    "        total_nan_attn += nan_count\n",
    "        total_inf_attn += inf_count\n",
    "    \n",
    "    print(f\"Total attention issues: {total_nan_attn} NaN, {total_inf_attn} Inf\")\n",
    "    \n",
    "    return {\n",
    "        'labels_nan': np.sum(np.isnan(labels)),\n",
    "        'reps_nan': total_nan_reps,\n",
    "        'reps_inf': total_inf_reps,\n",
    "        'attn_nan': total_nan_attn,\n",
    "        'attn_inf': total_inf_attn\n",
    "    }\n",
    "\n",
    "# Run this first to see what's causing the issues:\n",
    "# issues = diagnose_data_issues(all_reps, all_attn, labels)\n",
    "\n",
    "# Then run the improved analysis:\n",
    "results = improved_layer_analysis(all_reps, all_attn, labels)\n",
    "layer_analysis = analyze_layer_progression(results)\n",
    "best_layers = select_best_layers(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### build probing classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-17T10:14:18.960776Z",
     "start_time": "2025-07-17T10:14:18.956059Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_indices(split_samples):\n",
    "    return [prompt2idx[s.prompt] for s in split_samples]\n",
    "\n",
    "def featurize_by_indices(indices, layers, pool=\"mean\", use_attn=False):\n",
    "    \"\"\"Extract features for specific indices with support for multiple pooling strategies:\n",
    "    - 'mean': mean pooling across sequence length\n",
    "    - 'last': last token pooling\n",
    "    - 'min': min pooling across sequence length\n",
    "    - 'max': max pooling across sequence length\n",
    "    - 'concat': concatenation of min, max, and mean pooling (3x dimensionality)\n",
    "    \"\"\"\n",
    "    target_layers = range(len(all_reps)) if layers == 'all' else layers\n",
    "    \n",
    "    # Extract hidden features with the specified pooling strategy\n",
    "    hidden_feats = np.hstack([all_reps[l][pool][indices] for l in target_layers])\n",
    "    \n",
    "    if use_attn:\n",
    "        attn_feats = [all_attn[l][indices] for l in target_layers]  # each: (n_samples, n_heads)\n",
    "        attn_feats = np.hstack(attn_feats)  # shape: (n_samples, n_layers * n_heads)\n",
    "        # return attn_feats\n",
    "        return np.hstack([hidden_feats, attn_feats])\n",
    "    return hidden_feats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-16T01:35:22.965180Z",
     "start_time": "2025-07-16T01:35:22.305157Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.metrics import classification_report, roc_auc_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from scipy.stats import somersd\n",
    "\n",
    "def train_clf(X_train, y_train, clf=\"lr\"):\n",
    "    if clf == 'lr':\n",
    "        pipe = Pipeline([\n",
    "            (\"scaler\", StandardScaler()),\n",
    "            (\"clf\", LogisticRegression(\n",
    "                max_iter=2000,\n",
    "                class_weight=\"balanced\",\n",
    "                # multi_class=\"multinomial\",\n",
    "                solver=\"lbfgs\"  # supports multinomial\n",
    "            ))\n",
    "        ])\n",
    "        param_grid = {\n",
    "            \"clf__C\": [0.001, 0.01, 0.1, 1],\n",
    "            \"clf__penalty\": [\"l2\"],\n",
    "        }\n",
    "\n",
    "    elif clf == 'rf':\n",
    "        pipe = Pipeline([\n",
    "            (\"scaler\", StandardScaler()),\n",
    "            (\"clf\", RandomForestClassifier(class_weight=\"balanced\", random_state=42))\n",
    "        ])\n",
    "        param_grid = {\n",
    "            \"clf__n_estimators\": [100, 300, 500],\n",
    "            \"clf__max_depth\": [None, 10, 20],\n",
    "            \"clf__min_samples_leaf\": [1, 2, 5],\n",
    "        }\n",
    "\n",
    "    elif clf == 'mlp':\n",
    "        pipe = Pipeline([\n",
    "            (\"scaler\", StandardScaler()),\n",
    "            (\"clf\", MLPClassifier(\n",
    "                hidden_layer_sizes=(256, 128),\n",
    "                activation=\"relu\",\n",
    "                alpha=1e-4,\n",
    "                learning_rate_init=1e-3,\n",
    "                max_iter=1000,\n",
    "                early_stopping=True,\n",
    "                random_state=42\n",
    "            ))\n",
    "        ])\n",
    "        param_grid = {\n",
    "            \"clf__alpha\": [1e-4, 1e-3, 1e-2],\n",
    "            \"clf__learning_rate_init\": [1e-4, 1e-3, 1e-2],\n",
    "            \"clf__hidden_layer_sizes\": [(200, 100), (100,), (200, 100, 50)],\n",
    "        }\n",
    "    elif clf == 'linear_svm':\n",
    "        pipe = Pipeline([\n",
    "            (\"scaler\", StandardScaler()),\n",
    "            (\"clf\", SVC(\n",
    "                kernel=\"linear\",\n",
    "                class_weight=\"balanced\",\n",
    "                random_state=42,\n",
    "                probability=True  # Enable probability estimates for ROC-AUC\n",
    "            ))\n",
    "        ])\n",
    "        param_grid = {\n",
    "            \"clf__C\": [0.001, 0.01, 0.1, 1, 10, 100],\n",
    "        }\n",
    "\n",
    "    elif clf == 'nonlinear_svm':\n",
    "        pipe = Pipeline([\n",
    "            (\"scaler\", StandardScaler()),\n",
    "            (\"clf\", SVC(\n",
    "                kernel=\"rbf\",\n",
    "                class_weight=\"balanced\",\n",
    "                random_state=42,\n",
    "                probability=True  # Enable probability estimates for ROC-AUC\n",
    "            ))\n",
    "        ])\n",
    "        param_grid = {\n",
    "            \"clf__C\": [0.001, 0.01, 0.1, 1, 10, 100],\n",
    "            \"clf__gamma\": [\"scale\", \"auto\", 0.001, 0.01, 0.1, 1],\n",
    "        }\n",
    "\n",
    "    search = GridSearchCV(\n",
    "        pipe,\n",
    "        param_grid,\n",
    "        cv=5,\n",
    "        scoring=\"f1_macro\",\n",
    "        n_jobs=-1,\n",
    "        verbose=1,\n",
    "    )\n",
    "    search.fit(X_train, y_train)\n",
    "    print(f\"{clf.upper()} best params:\", search.best_params_)\n",
    "    return search\n",
    "\n",
    "def test_clf(X_test, y_test, search):\n",
    "    y_pred = search.predict(X_test)\n",
    "    y_prob = search.predict_proba(X_test)\n",
    "    print(classification_report(y_test, y_pred, digits=4))\n",
    "#     print(somersd([(sample-1)/4 for sample in y_test], [(sample-1)/4 for sample in y_pred]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "from datetime import datetime\n",
    "\n",
    "def save_model_pickle(search, base_model, dimension, classification, layers, pool=\"mean\", use_attn=False, clf_name=\"lr\", clf_path=\"model.pkl\"):\n",
    "    \"\"\"\n",
    "    Save the trained GridSearchCV pipeline + metadata in a single pickle file.\n",
    "    \"\"\"\n",
    "    metadata = {\n",
    "        \"llm\": base_model,\n",
    "        \"dimension\": dimension,\n",
    "        \"classification\": classification,   # binary or multi\n",
    "        \"layers\": layers,\n",
    "        \"pool\": pool,\n",
    "        \"use_attn\": use_attn,\n",
    "        \"clf_name\": clf_name,\n",
    "        \"best_params\": search.best_params_,\n",
    "        \"best_score\": search.best_score_,\n",
    "        \"timestamp\": datetime.now().isoformat()\n",
    "    }\n",
    "\n",
    "    package = {\n",
    "        \"model\": search,\n",
    "        \"metadata\": metadata\n",
    "    }\n",
    "\n",
    "    with open(clf_path, \"wb\") as f:\n",
    "        pickle.dump(package, f)\n",
    "    print(f\"Model + metadata saved to {clf_path}\")\n",
    "\n",
    "\n",
    "def load_model_pickle(clf_path=\"model.pkl\"):\n",
    "    \"\"\"\n",
    "    Load back the model and metadata from pickle.\n",
    "    \"\"\"\n",
    "    with open(clf_path, \"rb\") as f:\n",
    "        package = pickle.load(f)\n",
    "    clf = package[\"model\"]\n",
    "    metadata = package[\"metadata\"]\n",
    "    print(\"Loaded metadata:\", metadata)\n",
    "    return clf, metadata\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### build the classification dataset (multiclass or binary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-16T01:35:28.505799Z",
     "start_time": "2025-07-16T01:35:28.484026Z"
    }
   },
   "outputs": [],
   "source": [
    "# multiclass classification dataset (score=1-5)\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "clf_dataset = []\n",
    "\n",
    "clf_dataset = dataset\n",
    "train, test = train_test_split(clf_dataset, test_size=0.20, stratify=[s.label for s in clf_dataset], random_state=731)\n",
    "# Map from prompt to index in dataset\n",
    "prompt2idx = {s.prompt: i for i, s in enumerate(clf_dataset)}\n",
    "\n",
    "train_indices = get_indices(train)\n",
    "test_indices  = get_indices(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# binay classification dataset (score=0/1)\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "clf_dataset = []\n",
    "\n",
    "with open('Meta-Llama-3-8B-Instruct_gpqa_roscoe5dim_probing.json', 'r') as f:\n",
    "    # for dim in ['semantic_consistency', 'logicality', 'informativeness', 'fluency', 'factuality']:\n",
    "    for sample in json.load(f)['factuality']:       # You can change the dimension here, from 5 dimensions above\n",
    "        clf_dataset.append(Sample(prompt=sample['eval_prompt'], label=1 if sample['score']>3 else 0))\n",
    "\n",
    "train, test = train_test_split(clf_dataset, test_size=0.20, stratify=[s.label for s in clf_dataset], random_state=731)\n",
    "# Map from prompt to index in dataset\n",
    "prompt2idx = {s.prompt: i for i, s in enumerate(clf_dataset)}\n",
    "\n",
    "train_indices = get_indices(train)\n",
    "test_indices  = get_indices(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### find the layer and pooling for best performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current layer:  35\n",
      "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
      "LINEAR_SVM best params: {'clf__C': 0.001}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9048    0.6786    0.7755        28\n",
      "           1     0.6400    0.8889    0.7442        18\n",
      "\n",
      "    accuracy                         0.7609        46\n",
      "   macro avg     0.7724    0.7837    0.7598        46\n",
      "weighted avg     0.8012    0.7609    0.7633        46\n",
      "\n",
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n",
      "LR best params: {'clf__C': 0.001, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9444    0.6071    0.7391        28\n",
      "           1     0.6071    0.9444    0.7391        18\n",
      "\n",
      "    accuracy                         0.7391        46\n",
      "   macro avg     0.7758    0.7758    0.7391        46\n",
      "weighted avg     0.8125    0.7391    0.7391        46\n",
      "\n",
      "Current layer:  36\n",
      "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
      "LINEAR_SVM best params: {'clf__C': 0.001}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9048    0.6786    0.7755        28\n",
      "           1     0.6400    0.8889    0.7442        18\n",
      "\n",
      "    accuracy                         0.7609        46\n",
      "   macro avg     0.7724    0.7837    0.7598        46\n",
      "weighted avg     0.8012    0.7609    0.7633        46\n",
      "\n",
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n",
      "LR best params: {'clf__C': 0.001, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9444    0.6071    0.7391        28\n",
      "           1     0.6071    0.9444    0.7391        18\n",
      "\n",
      "    accuracy                         0.7391        46\n",
      "   macro avg     0.7758    0.7758    0.7391        46\n",
      "weighted avg     0.8125    0.7391    0.7391        46\n",
      "\n",
      "Current layer:  34\n",
      "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
      "LINEAR_SVM best params: {'clf__C': 0.001}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9524    0.7143    0.8163        28\n",
      "           1     0.6800    0.9444    0.7907        18\n",
      "\n",
      "    accuracy                         0.8043        46\n",
      "   macro avg     0.8162    0.8294    0.8035        46\n",
      "weighted avg     0.8458    0.8043    0.8063        46\n",
      "\n",
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n",
      "LR best params: {'clf__C': 0.001, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9444    0.6071    0.7391        28\n",
      "           1     0.6071    0.9444    0.7391        18\n",
      "\n",
      "    accuracy                         0.7391        46\n",
      "   macro avg     0.7758    0.7758    0.7391        46\n",
      "weighted avg     0.8125    0.7391    0.7391        46\n",
      "\n",
      "Current layer:  33\n",
      "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
      "LINEAR_SVM best params: {'clf__C': 0.001}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9524    0.7143    0.8163        28\n",
      "           1     0.6800    0.9444    0.7907        18\n",
      "\n",
      "    accuracy                         0.8043        46\n",
      "   macro avg     0.8162    0.8294    0.8035        46\n",
      "weighted avg     0.8458    0.8043    0.8063        46\n",
      "\n",
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n",
      "LR best params: {'clf__C': 0.001, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9500    0.6786    0.7917        28\n",
      "           1     0.6538    0.9444    0.7727        18\n",
      "\n",
      "    accuracy                         0.7826        46\n",
      "   macro avg     0.8019    0.8115    0.7822        46\n",
      "weighted avg     0.8341    0.7826    0.7843        46\n",
      "\n",
      "Current layer:  38\n",
      "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
      "LINEAR_SVM best params: {'clf__C': 0.1}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9091    0.7143    0.8000        28\n",
      "           1     0.6667    0.8889    0.7619        18\n",
      "\n",
      "    accuracy                         0.7826        46\n",
      "   macro avg     0.7879    0.8016    0.7810        46\n",
      "weighted avg     0.8142    0.7826    0.7851        46\n",
      "\n",
      "Fitting 5 folds for each of 4 candidates, totalling 20 fits\n",
      "LR best params: {'clf__C': 0.001, 'clf__penalty': 'l2'}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9500    0.6786    0.7917        28\n",
      "           1     0.6538    0.9444    0.7727        18\n",
      "\n",
      "    accuracy                         0.7826        46\n",
      "   macro avg     0.8019    0.8115    0.7822        46\n",
      "weighted avg     0.8341    0.7826    0.7843        46\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for layer in [35,36,34,33,38]:\n",
    "    print(\"Current layer: \", layer)\n",
    "    X_train = featurize_by_indices(train_indices, layers=[layer], pool=\"last\", use_attn=False)\n",
    "    y_train = np.array([s.label for s in train])\n",
    "\n",
    "    X_test = featurize_by_indices(test_indices, layers=[layer], pool=\"last\", use_attn=False)\n",
    "    y_test = np.array([s.label for s in test])\n",
    "\n",
    "    cur_search = train_clf(X_train, y_train, \"linear_svm\")\n",
    "    test_clf(X_test, y_test, cur_search)\n",
    "\n",
    "    cur_search = train_clf(X_train, y_train, \"lr\")\n",
    "    test_clf(X_test, y_test, cur_search)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 6 candidates, totalling 30 fits\n",
      "LINEAR_SVM best params: {'clf__C': 0.001}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.8235    0.7368    0.7778        19\n",
      "           1     0.6429    0.7500    0.6923        12\n",
      "\n",
      "    accuracy                         0.7419        31\n",
      "   macro avg     0.7332    0.7434    0.7350        31\n",
      "weighted avg     0.7536    0.7419    0.7447        31\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X_train = featurize_by_indices(train_indices, layers=[11], pool=\"mean\", use_attn=False)\n",
    "y_train = np.array([s.label for s in train])\n",
    "\n",
    "X_test = featurize_by_indices(test_indices, layers=[11], pool=\"mean\", use_attn=False)\n",
    "y_test = np.array([s.label for s in test])\n",
    "\n",
    "cur_search = train_clf(X_train, y_train, \"linear_svm\")\n",
    "test_clf(X_test, y_test, cur_search)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### save the best classifier for future use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model + metadata saved to gpqa_multi_clfs/logicality.pkl\n",
      "Loaded metadata: {'llm': 'Qwen/Qwen3-1.7B', 'dimension': 'logicality', 'classification': 'multi', 'layers': [13], 'pool': 'mean', 'use_attn': False, 'clf_name': 'linear_svm', 'best_params': {'clf__C': 0.001}, 'best_score': np.float64(0.4177216117216117), 'timestamp': '2025-09-04T19:47:44.265667'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'llm': 'Qwen/Qwen3-1.7B',\n",
       " 'dimension': 'logicality',\n",
       " 'classification': 'multi',\n",
       " 'layers': [13],\n",
       " 'pool': 'mean',\n",
       " 'use_attn': False,\n",
       " 'clf_name': 'linear_svm',\n",
       " 'best_params': {'clf__C': 0.001},\n",
       " 'best_score': np.float64(0.4177216117216117),\n",
       " 'timestamp': '2025-09-04T19:47:44.265667'}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "save_model_pickle(cur_search, \"Qwen/Qwen3-1.7B\", \"logicality\", \"multi\", layers=[13], pool=\"mean\", use_attn=False, clf_name=\"linear_svm\", clf_path=\"gpqa_multi_clfs/logicality.pkl\")\n",
    "clf, metadata = load_model_pickle(\"gpqa_multi_clfs/logicality.pkl\")\n",
    "metadata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model + metadata saved to gpqa_binary_clfs/logicality.pkl\n",
      "Loaded metadata: {'llm': 'Qwen/Qwen3-1.7B', 'dimension': 'logicality', 'classification': 'binary', 'layers': [11], 'pool': 'mean', 'use_attn': False, 'clf_name': 'linear_svm', 'best_params': {'clf__C': 0.001}, 'best_score': np.float64(0.6436371100164203), 'timestamp': '2025-09-04T19:48:57.279164'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'llm': 'Qwen/Qwen3-1.7B',\n",
       " 'dimension': 'logicality',\n",
       " 'classification': 'binary',\n",
       " 'layers': [11],\n",
       " 'pool': 'mean',\n",
       " 'use_attn': False,\n",
       " 'clf_name': 'linear_svm',\n",
       " 'best_params': {'clf__C': 0.001},\n",
       " 'best_score': np.float64(0.6436371100164203),\n",
       " 'timestamp': '2025-09-04T19:48:57.279164'}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "save_model_pickle(cur_search, \"Qwen/Qwen3-1.7B\", \"logicality\", \"binary\", layers=[11], pool=\"mean\", use_attn=False, clf_name=\"linear_svm\", clf_path=\"gpqa_binary_clfs/logicality.pkl\")\n",
    "clf, metadata = load_model_pickle(\"gpqa_binary_clfs/logicality.pkl\")\n",
    "metadata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Roberta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training RoBERTa classifier...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='10' max='10' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [10/10 00:43, Epoch 10/10]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Epoch</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>No log</td>\n",
       "      <td>0.702219</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>No log</td>\n",
       "      <td>0.701864</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>No log</td>\n",
       "      <td>0.701277</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>No log</td>\n",
       "      <td>0.700388</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>0.702800</td>\n",
       "      <td>0.699213</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>0.702800</td>\n",
       "      <td>0.697731</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>0.702800</td>\n",
       "      <td>0.696081</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>0.702800</td>\n",
       "      <td>0.694137</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>0.702800</td>\n",
       "      <td>0.692039</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>0.701000</td>\n",
       "      <td>0.689749</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "Trainer.tokenizer is now deprecated. You should use `Trainer.processing_class = processing_class` instead.\n",
      "Trainer.tokenizer is now deprecated. You should use Trainer.processing_class instead.\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RoBERTa Direct Classification Results for semantic_consistency:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.5909    1.0000    0.7429        13\n",
      "           1     0.0000    0.0000    0.0000         9\n",
      "\n",
      "    accuracy                         0.5909        22\n",
      "   macro avg     0.2955    0.5000    0.3714        22\n",
      "weighted avg     0.3492    0.5909    0.4390        22\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training RoBERTa classifier...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='20' max='20' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [20/20 00:47, Epoch 10/10]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Epoch</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>No log</td>\n",
       "      <td>0.702523</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>No log</td>\n",
       "      <td>0.700828</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.705000</td>\n",
       "      <td>0.698002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.705000</td>\n",
       "      <td>0.694777</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>0.702400</td>\n",
       "      <td>0.691889</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>0.702400</td>\n",
       "      <td>0.688644</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>0.702400</td>\n",
       "      <td>0.684922</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>0.680400</td>\n",
       "      <td>0.680222</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>0.680400</td>\n",
       "      <td>0.674023</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>0.655200</td>\n",
       "      <td>0.668230</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "Trainer.tokenizer is now deprecated. You should use `Trainer.processing_class = processing_class` instead.\n",
      "Trainer.tokenizer is now deprecated. You should use Trainer.processing_class instead.\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RoBERTa Direct Classification Results for logicality:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.6129    1.0000    0.7600        19\n",
      "           1     0.0000    0.0000    0.0000        12\n",
      "\n",
      "    accuracy                         0.6129        31\n",
      "   macro avg     0.3065    0.5000    0.3800        31\n",
      "weighted avg     0.3757    0.6129    0.4658        31\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training RoBERTa classifier...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='50' max='50' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [50/50 01:57, Epoch 10/10]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Epoch</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.702800</td>\n",
       "      <td>0.699707</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.694800</td>\n",
       "      <td>0.691611</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.688200</td>\n",
       "      <td>0.680952</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.677200</td>\n",
       "      <td>0.675175</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>0.669000</td>\n",
       "      <td>0.675187</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>0.685000</td>\n",
       "      <td>0.676663</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>0.675900</td>\n",
       "      <td>0.673752</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>0.670500</td>\n",
       "      <td>0.674983</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>0.672900</td>\n",
       "      <td>0.673659</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>0.674100</td>\n",
       "      <td>0.672213</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "Trainer.tokenizer is now deprecated. You should use `Trainer.processing_class = processing_class` instead.\n",
      "Trainer.tokenizer is now deprecated. You should use Trainer.processing_class instead.\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RoBERTa Direct Classification Results for informativeness:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.5986    1.0000    0.7489        85\n",
      "           1     0.0000    0.0000    0.0000        57\n",
      "\n",
      "    accuracy                         0.5986       142\n",
      "   macro avg     0.2993    0.5000    0.3744       142\n",
      "weighted avg     0.3583    0.5986    0.4483       142\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training RoBERTa classifier...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='10' max='10' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [10/10 00:42, Epoch 10/10]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Epoch</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>No log</td>\n",
       "      <td>0.709023</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>No log</td>\n",
       "      <td>0.708581</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>No log</td>\n",
       "      <td>0.707658</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>No log</td>\n",
       "      <td>0.706273</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>0.703500</td>\n",
       "      <td>0.704412</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>0.703500</td>\n",
       "      <td>0.702131</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>0.703500</td>\n",
       "      <td>0.699542</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>0.703500</td>\n",
       "      <td>0.696563</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>0.703500</td>\n",
       "      <td>0.693134</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>0.694800</td>\n",
       "      <td>0.689434</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "Trainer.tokenizer is now deprecated. You should use `Trainer.processing_class = processing_class` instead.\n",
      "Trainer.tokenizer is now deprecated. You should use Trainer.processing_class instead.\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RoBERTa Direct Classification Results for fluency:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.6154    1.0000    0.7619        16\n",
      "           1     0.0000    0.0000    0.0000        10\n",
      "\n",
      "    accuracy                         0.6154        26\n",
      "   macro avg     0.3077    0.5000    0.3810        26\n",
      "weighted avg     0.3787    0.6154    0.4689        26\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training RoBERTa classifier...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='20' max='20' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [20/20 00:59, Epoch 10/10]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Epoch</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>No log</td>\n",
       "      <td>0.706770</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>No log</td>\n",
       "      <td>0.704455</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.713200</td>\n",
       "      <td>0.700649</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.713200</td>\n",
       "      <td>0.695382</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>0.693400</td>\n",
       "      <td>0.688856</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>0.693400</td>\n",
       "      <td>0.681007</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>0.693400</td>\n",
       "      <td>0.671891</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>0.681400</td>\n",
       "      <td>0.663197</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>0.681400</td>\n",
       "      <td>0.655801</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>0.680500</td>\n",
       "      <td>0.650921</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n",
      "Trainer.tokenizer is now deprecated. You should use `Trainer.processing_class = processing_class` instead.\n",
      "Trainer.tokenizer is now deprecated. You should use Trainer.processing_class instead.\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:71: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RoBERTa Direct Classification Results for factuality:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.6087    1.0000    0.7568        28\n",
      "           1     0.0000    0.0000    0.0000        18\n",
      "\n",
      "    accuracy                         0.6087        46\n",
      "   macro avg     0.3043    0.5000    0.3784        46\n",
      "weighted avg     0.3705    0.6087    0.4606        46\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "/home/zhangyong203/rtx8000_conda/envs/telora/lib/python3.10/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "from transformers import (\n",
    "    AutoTokenizer, \n",
    "    AutoModelForSequenceClassification, \n",
    "    TrainingArguments, \n",
    "    Trainer,\n",
    "    AutoModelForCausalLM\n",
    ")\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import classification_report, accuracy_score\n",
    "import json\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "# Device setup\n",
    "torch.mps.empty_cache() if torch.backends.mps.is_available() else None\n",
    "\n",
    "class ClassificationDataset(Dataset):\n",
    "    def __init__(self, texts, labels, tokenizer, max_length=512):\n",
    "        self.texts = texts\n",
    "        self.labels = labels\n",
    "        self.tokenizer = tokenizer\n",
    "        self.max_length = max_length\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.texts)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        text = str(self.texts[idx])\n",
    "        label = self.labels[idx]\n",
    "\n",
    "        encoding = self.tokenizer(\n",
    "            text,\n",
    "            truncation=True,\n",
    "            padding='max_length',\n",
    "            max_length=self.max_length,\n",
    "            return_tensors='pt'\n",
    "        )\n",
    "\n",
    "        return {\n",
    "            'input_ids': encoding['input_ids'].flatten(),\n",
    "            'attention_mask': encoding['attention_mask'].flatten(),\n",
    "            'labels': torch.tensor(label, dtype=torch.long)\n",
    "        }\n",
    "\n",
    "def train_roberta_classifier(train_texts, train_labels, val_texts, val_labels, num_labels, dim):\n",
    "    \"\"\"\n",
    "    Train RoBERTa as a direct classifier for your task\n",
    "    \"\"\"\n",
    "    # Initialize model and tokenizer\n",
    "    model_name = \"roberta-base\"\n",
    "    tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
    "    model = AutoModelForSequenceClassification.from_pretrained(\n",
    "        model_name, \n",
    "        num_labels=num_labels\n",
    "    )\n",
    "    \n",
    "    # Create datasets\n",
    "    train_dataset = ClassificationDataset(train_texts, train_labels, tokenizer)\n",
    "    val_dataset = ClassificationDataset(val_texts, val_labels, tokenizer)\n",
    "    \n",
    "    # Training arguments\n",
    "    training_args = TrainingArguments(\n",
    "        output_dir=f'checkpoints/roberta_classifier/{dim}',\n",
    "        num_train_epochs=10,\n",
    "        per_device_train_batch_size=16,\n",
    "        per_device_eval_batch_size=16,\n",
    "        warmup_steps=100,\n",
    "        weight_decay=0.01,\n",
    "        logging_dir='./logs',\n",
    "        logging_steps=5,\n",
    "        eval_strategy=\"epoch\",\n",
    "        save_strategy=\"epoch\",\n",
    "        load_best_model_at_end=True,\n",
    "        save_total_limit=2,\n",
    "        metric_for_best_model=\"eval_loss\",\n",
    "        greater_is_better=False,\n",
    "        report_to=None\n",
    "    )\n",
    "    \n",
    "    # Initialize trainer\n",
    "    trainer = Trainer(\n",
    "        model=model,\n",
    "        args=training_args,\n",
    "        train_dataset=train_dataset,\n",
    "        eval_dataset=val_dataset,\n",
    "    )\n",
    "    \n",
    "    # Train the model\n",
    "    print(\"Training RoBERTa classifier...\")\n",
    "    trainer.train()\n",
    "    trainer.tokenizer = tokenizer\n",
    "    \n",
    "    return trainer\n",
    "\n",
    "def evaluate_roberta_classifier(trainer, test_texts, test_labels, tokenizer, dim):\n",
    "    \"\"\"\n",
    "    Evaluate the trained RoBERTa classifier\n",
    "    \"\"\"\n",
    "    test_dataset = ClassificationDataset(test_texts, test_labels, tokenizer)\n",
    "    \n",
    "    # Get predictions\n",
    "    predictions = trainer.predict(test_dataset)\n",
    "    pred_labels = np.argmax(predictions.predictions, axis=1)\n",
    "    \n",
    "    # Calculate metrics\n",
    "    accuracy = accuracy_score(test_labels, pred_labels)\n",
    "    \n",
    "    print(f\"RoBERTa Direct Classification Results for {dim}:\")\n",
    "    # print(f\"Accuracy: {accuracy:.4f}\")\n",
    "    print(classification_report(test_labels, pred_labels, digits=4))\n",
    "\n",
    "\n",
    "# Simplified version if you want to quickly test RoBERTa\n",
    "def quick_roberta_baseline(dim):\n",
    "    \"\"\"\n",
    "    Quick version to test RoBERTa on your exact data\n",
    "    \"\"\"\n",
    "    # Load your data\n",
    "    clf_dataset = []\n",
    "    with open('Meta-Llama-3-8B-Instruct_gpqa_roscoe5dim_probing.json', 'r') as f:\n",
    "        for sample in json.load(f)[dim]:\n",
    "            clf_dataset.append({\n",
    "                'text': sample['eval_prompt'], \n",
    "                'label': 1 if sample['score']>3 else 0  # binary class\n",
    "                # 'label': sample['score'] - 1  # Convert to 0-indexed\n",
    "            })\n",
    "    \n",
    "    # Split data\n",
    "    train_test_split_data = train_test_split(\n",
    "        [item['text'] for item in clf_dataset],\n",
    "        [item['label'] for item in clf_dataset],\n",
    "        test_size=0.20,\n",
    "        stratify=[item['label'] for item in clf_dataset],\n",
    "        random_state=42\n",
    "    )\n",
    "    \n",
    "    train_texts, test_texts, train_labels, test_labels = train_test_split_data\n",
    "    \n",
    "    # Further split for validation\n",
    "    train_texts, val_texts, train_labels, val_labels = train_test_split(\n",
    "        train_texts, train_labels, test_size=0.2, stratify=train_labels, random_state=42\n",
    "    )\n",
    "    \n",
    "    num_labels = len(set(train_labels))\n",
    "    \n",
    "    # Train and evaluate\n",
    "    trainer = train_roberta_classifier(train_texts, train_labels, val_texts, val_labels, num_labels, dim)\n",
    "    results = evaluate_roberta_classifier(trainer, test_texts, test_labels, trainer.tokenizer, dim)\n",
    "    \n",
    "    return results\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    for dim in ['semantic_consistency', 'logicality', 'informativeness', 'fluency', 'factuality']:\n",
    "        quick_roberta_baseline(dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "prob",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.18"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}