tutorials/03_eval_performance.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluate performance of `pyctcdecode` on LibriSpeech dev-other"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# download librispeech dev-other corpus, using one of the great existing scripts, for example:\n",
    "#     https://github.com/NVIDIA/NeMo/blob/main/scripts/dataset_processing/get_librispeech_data.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load manifest that holds meta information on all files in dev_other\n",
    "import pandas as pd\n",
    "dev_other_df = pd.read_json(\"/my_dir/dev_other.json\", lines=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare  transcription logits using a pretrained speech model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare offical pre-trained language model for librispeech"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOTE: some of the code to parse the librispeech data is borrowed from the official NeMo tutorial \n",
    "#     https://github.com/NVIDIA/NeMo/blob/main/tutorials/asr/Offline_ASR.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# download pretrained knelm model for librispeech\n",
    "import gzip\n",
    "import os, shutil, wget\n",
    "\n",
    "lm_gzip_path = '3-gram.pruned.1e-7.arpa.gz'\n",
    "if not os.path.exists(lm_gzip_path):\n",
    "    print('Downloading pruned 3-gram model.')\n",
    "    lm_url = 'http://www.openslr.org/resources/11/3-gram.pruned.1e-7.arpa.gz'\n",
    "    lm_gzip_path = wget.download(lm_url)\n",
    "    print('Downloaded the 3-gram language model.')\n",
    "else:\n",
    "    print('Pruned .arpa.gz already exists.')\n",
    "\n",
    "# NOTE: since out nemo vocabulary is all lowercased, we need to convert all librispeech data as well\n",
    "uppercase_lm_path = '3-gram.pruned.1e-7.arpa'\n",
    "if not os.path.exists(uppercase_lm_path):\n",
    "    with gzip.open(lm_gzip_path, 'rb') as f_zipped:\n",
    "        with open(uppercase_lm_path, 'wb') as f_unzipped:\n",
    "            shutil.copyfileobj(f_zipped, f_unzipped)\n",
    "    print('Unzipped the 3-gram language model.')\n",
    "else:\n",
    "    print('Unzipped .arpa already exists.')\n",
    "\n",
    "lm_path = 'lowercase_3-gram.pruned.1e-7.arpa'\n",
    "if not os.path.exists(lm_path):\n",
    "    with open(uppercase_lm_path, 'r') as f_upper:\n",
    "        with open(lm_path, 'w') as f_lower:\n",
    "            for line in f_upper:\n",
    "                f_lower.write(line.lower())\n",
    "print('Converted language model file to lowercase.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2021-04-27 12:26:03--  http://www.openslr.org/resources/11/librispeech-vocab.txt\n",
      "Resolving www.openslr.org (www.openslr.org)... 46.101.158.64\n",
      "Connecting to www.openslr.org (www.openslr.org)|46.101.158.64|:80... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 1737588 (1.7M) [text/plain]\n",
      "Saving to: ‘librispeech-vocab.txt’\n",
      "\n",
      "librispeech-vocab.t 100%[===================>]   1.66M  1.07MB/s    in 1.6s    \n",
      "\n",
      "2021-04-27 12:26:05 (1.07 MB/s) - ‘librispeech-vocab.txt’ saved [1737588/1737588]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# download unigram vocab\n",
    "!wget http://www.openslr.org/resources/11/librispeech-vocab.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare deepspeech decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install ds_ctcdecoder==0.9.3\n",
    "# download and unpack native_client.*.tar.xz  from https://github.com/mozilla/DeepSpeech/releases/tag/v0.9.3\n",
    "\n",
    "# generate a scorer which we can use in the python package\n",
    "# /my/dir/native_client_0.9.3/generate_scorer_package \\\n",
    "#     --alphabet /my/dir/alphabet.txt \\\n",
    "#     --lm /my/dir/lowercase_3-gram.pruned.1e-7.binary \\\n",
    "#     --vocab /my/dir/lowercase_librispeech-vocab.txt \\\n",
    "#     --package /my/dir/lowercase_3-gram.scorer \\\n",
    "#     --default_alpha 0.5 \\\n",
    "#     --default_beta 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prepare logits_list for dev_other like in tutorial tutorials/asr_nemo.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ds_ctcdecoder\n",
    "from pyctcdecode import build_ctcdecoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.special import softmax\n",
    "\n",
    "# we need to do array padding for batch decoding\n",
    "def _pad_array_list(array_list):\n",
    "    \"\"\"Pad a list of arrays to have the same length.\"\"\"\n",
    "    max_val = max(len(arr) for arr in array_list)\n",
    "    pad_vec = np.zeros((1, array_list[0].shape[1]))\n",
    "    pad_vec[0, -1] = 1\n",
    "    return [np.concatenate([arr] + [pad_vec] * (max_val - arr.shape[0])) for arr in array_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prepare ds_decoder\n",
    "ds_alphabet = ds_ctcdecoder.Alphabet(\"ds_decoder_alphabet.txt\")\n",
    "ds_scorer = ds_ctcdecoder.Scorer(\n",
    "    0, 0, scorer_path=\"lowercase_3-gram.scorer\", alphabet=ds_alphabet\n",
    ")\n",
    "prob_list = [softmax(logits, axis=1) for logits in logits_list]\n",
    "seq_lengths = [arr.shape[0] for arr in logits_list]\n",
    "padded_prob_list = _pad_array_list(prob_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>alpha</th>\n",
       "      <th>beta</th>\n",
       "      <th>wer</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.076822</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.6</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.076937</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.6</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.077032</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.7</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.077083</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.8</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.077113</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   alpha  beta       wer\n",
       "4    0.7   3.0  0.076822\n",
       "0    0.6   2.0  0.076937\n",
       "1    0.6   3.0  0.077032\n",
       "3    0.7   2.0  0.077083\n",
       "7    0.8   3.0  0.077113"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_grid = []\n",
    "for a in [0.6, 0.7, 0.8]:\n",
    "    for b in [2.0, 3.0, 4.0]:\n",
    "        decoder.reset_params(alpha=a, beta=b)\n",
    "        with multiprocessing.get_context(\"fork\").Pool(15) as pool:\n",
    "            # use lower beam-with here for fast testing\n",
    "            lm_preds =  decoder.decode_batch(pool, logits_list, beam_width=50)\n",
    "        wer_val = word_error_rate(dev_other_df[\"text\"].tolist(), lm_preds)\n",
    "        data_grid.append((a, b, wer_val))\n",
    "pd.DataFrame(data_grid, columns=[\"alpha\", \"beta\", \"wer\"]).sort_values(by=\"wer\").head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare `pyctcdecode.decoder`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load unigram list\n",
    "with open(\"librispeech-vocab.txt\") as f:\n",
    "    unigram_list = [t.lower() for t in f.read().strip().split(\"\\n\")]\n",
    "    \n",
    "# load kenlm Model\n",
    "import kenlm\n",
    "kenlm_model = kenlm.Model('lowercase_3-gram.pruned.1e-7.arpa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'boil them before they are put into the soup or other dish they may be intended for'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decoder = build_ctcdecoder(\n",
    "    asr_model.decoder.vocabulary,\n",
    "    kenlm_model,\n",
    "    unigram_list,\n",
    ")\n",
    "decoder.decode(logits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# decode all logits (this may take a while)\n",
    "logits_list = [\n",
    "    a.cpu().detach().numpy() \n",
    "    for a in asr_model.transcribe(dev_other_df[\"audio_filepath\"].tolist(), logprobs=True)\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "decoder = build_ctcdecoder(\n",
    "    asr_model.decoder.vocabulary,\n",
    "    kenlm_model,\n",
    "    unigram_list,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import multiprocessing\n",
    "with multiprocessing.get_context(\"fork\").Pool() as pool:\n",
    "    pred_list = decoder.decode_batch(pool, logits_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.07708590580349269"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from nemo.collections.asr.metrics.wer import word_error_rate\n",
    "word_error_rate(dev_other_df[\"text\"].tolist(), pred_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's compare this to greedy decoding\n",
    "def _greedy_decode(logits):\n",
    "    \"\"\"Decode argmax of logits and squash in CTC fashion.\"\"\"\n",
    "    label_dict = {n: c for n, c in enumerate(labels)}\n",
    "    prev_c = None\n",
    "    out = []\n",
    "    for n in logits.argmax(axis=1):\n",
    "        c = label_dict.get(n, \"\")  # if not in labels, then assume it's ctc blank char\n",
    "        if c != prev_c:\n",
    "            out.append(c)\n",
    "        prev_c = c\n",
    "    return \"\".join(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.10084215497225611"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_error_rate(dev_other_df[\"text\"].tolist(), [_greedy_decode(l) for l in logits_list])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we did better by using a language model, but we can improve this further by tuning the decoder parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>alpha</th>\n",
       "      <th>beta</th>\n",
       "      <th>wer</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.076822</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.6</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.076937</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.6</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.077032</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.7</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.077083</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.8</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.077113</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   alpha  beta       wer\n",
       "4    0.7   3.0  0.076822\n",
       "0    0.6   2.0  0.076937\n",
       "1    0.6   3.0  0.077032\n",
       "3    0.7   2.0  0.077083\n",
       "7    0.8   3.0  0.077113"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_grid = []\n",
    "for a in [0.6, 0.7, 0.8]:\n",
    "    for b in [2.0, 3.0, 4.0]:\n",
    "        decoder.reset_params(alpha=a, beta=b)\n",
    "        with multiprocessing.get_context(\"fork\").Pool(15) as pool:\n",
    "            # use lower beam-with here for fast testing\n",
    "            lm_preds =  decoder.decode_batch(pool, logits_list, beam_width=50)\n",
    "        wer_val = word_error_rate(dev_other_df[\"text\"].tolist(), lm_preds)\n",
    "        data_grid.append((a, b, wer_val))\n",
    "pd.DataFrame(data_grid, columns=[\"alpha\", \"beta\", \"wer\"]).sort_values(by=\"wer\").head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compare decoder performance/speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sweep beam_width for custom\n",
    "data = []\n",
    "for beam_width in [1, 5, 10, 50, 100, 150, 200]:\n",
    "    decoder = build_ctcdecoder(\n",
    "        labels,\n",
    "        kenlm_model,\n",
    "        unigrams,\n",
    "        alpha=0.7,\n",
    "        beta=3.0,\n",
    "        score_lm_boundary=True,\n",
    "    )\n",
    "    with multiprocessing.get_context(\"fork\").Pool(15) as pool:\n",
    "        pred_list = decoder.decode_batch(logits_list, pool, beam_width=beam_width)\n",
    "    wer_val = eval_average_wer(text_list, pred_list)\n",
    "    t0 = time.time()\n",
    "    _ = [decoder.decode(l, beam_width=beam_width) for l in logits_list[:500]]\n",
    "    dur = round((time.time() - t0) / 500 * 1000, 1)\n",
    "    data.append((wer_val, dur, beam_width, prune_logp))\n",
    "df_pyctc = pd.DataFrame(data * 100, columns=['wer_val', 'avg_dur_ms', 'beam_width'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sweep beam_width for ds_decoder\n",
    "data = []\n",
    "for beam_width in [1, 5, 10, 25, 50, 100, 150, 200]:\n",
    "    ds_scorer.reset_params(0.7, 2.0)\n",
    "    out = ds_ctcdecoder.ctc_beam_search_decoder_batch(\n",
    "        padded_prob_list,\n",
    "        seq_lengths,\n",
    "        ds_alphabet,\n",
    "        beam_width,\n",
    "        15,\n",
    "        scorer=ds_scorer,\n",
    "    )\n",
    "    pred_list = [e[0][-1] for e in out]\n",
    "    wer_val = eval_average_wer(text_list, pred_list)\n",
    "    t0 = time.time()\n",
    "    _ = [\n",
    "        ds_ctcdecoder.ctc_beam_search_decoder(\n",
    "            softmax(l, axis=-1),\n",
    "            ds_alphabet,\n",
    "            beam_width,\n",
    "            scorer=ds_scorer,\n",
    "        ) \n",
    "        for l in logits_list[:500]\n",
    "    ]\n",
    "    dur = round(time.time() - t0, 1)\n",
    "    dur = round((time.time() - t0) / 500 * 1000, 1)\n",
    "    data.append((wer_val * 100, dur, beam_width))\n",
    "df_other = pd.DataFrame(data, columns=['wer_val', 'avg_dur_ms', 'beam_width'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/georg/venvs/kml/lib/python3.7/site-packages/seaborn/_decorators.py:43: FutureWarning: Pass the following variables as keyword args: x, y. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
      "  FutureWarning\n",
      "/Users/georg/venvs/kml/lib/python3.7/site-packages/seaborn/_decorators.py:43: FutureWarning: Pass the following variables as keyword args: x, y. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
      "  FutureWarning\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEXCAYAAACzhgONAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABKj0lEQVR4nO3deVzU1frA8c93FvZNEDdwTyUVc8syDXNfcEn0urV3je6vUrM0zTTTwtxaLG/dutmmrV5NNMsWLVNRE5fUVDR33EBAkHWYmfP7AxlFdpuBQZ7361Uy3+XMMzPAwznn+32OppRSCCGEEMXQVXYAQgghnJskCiGEECWSRCGEEKJEkiiEEEKUSBKFEEKIEkmiEEIIUSJJFKJSbN++nYEDBwKwaNEiVq1aBUCLFi1ITk4u9fz169fzyiuvODLEMps6dSpLliwp93mPP/44K1eudEBEBe3du5cXX3wRKPi+C1FWhsoOQIgJEyaU+5yePXvSs2dPB0Rz8/nrr7+4cOFCZYchqjBJFKLSTZ06lWbNmvHPf/4TgDfffJN9+/ZhtVp5+umn6d69OytXruR///sfWVlZeHl5MXToUH744Qfee+89fvzxR9599100TUOv1/Pcc89x++2388ADD9C0aVP2799PSkoKQ4YMYfz48QDs2rWLhQsXkpWVhaZpjBs3ju7duwOwfPlyvvjiC6xWK35+fsyYMYOmTZuSkZHBK6+8wq5du9Dr9fTq1YuJEycCsHv3bkaNGsXFixdp1qwZr732Gh4eHgVe54ULF5g6dSoJCQnUq1ePpKQk276jR48SFRXFpUuXsFgsPPDAAwwfPpxnn32Wli1b2t6bL774gu3bt/Pmm28Weh+/+uorli5dik6no2bNmsyYMQM3NzfeeustLl++zPPPP8+9995LZmYmEydO5NixY+Tk5PDKK6/QsWNHTCYTCxcuZMeOHVgsFlq2bMn06dPx8vKiR48etGnThri4OJ555hl69+5t9+8D4cSUEJVg27ZtKjw8XCml1JQpU9QHH3yglFKqefPm6r333lNKKRUXF6c6deqkkpKS1IoVK9Ttt9+uLl++rJRSasWKFSoyMlIppVTPnj3V7t27lVJKbdq0Sb399ttKKaXuv/9+9dhjjymTyaRSU1NV37591YYNG9SlS5dUnz591OnTp5VSSp0/f16FhYWpM2fOqO3bt6sxY8aozMxMW3v9+/dXSik1Z84cNXHiRGU2m1VOTo6677771LZt29SUKVPU8OHDVWZmpjKbzWro0KHqm2++KfSan3jiCfXGG28opZQ6ceKEatu2rVqxYoXKzc1VAwYMUPv371dKKZWWlqb69++vdu/erbZu3aoGDhxoa2P48OFqy5YthdqOiYlRvXr1UklJSbb3p3///spqtRZ4r7Zt26ZuvfVWtWfPHqWUUh999JF68MEHlVJKvf3222ru3LnKarUqpZR67bXX1MyZM5VSSnXv3l0tXry4DJ+suBlJj0I4ndGjRwPQvHlzmjZtyu7du4G8+QsvL69Cx4eHh/PUU0/RrVs3unTpwmOPPWbbN3LkSIxGI0ajkX79+rF582Z0Oh2JiYk8+eSTtuM0TSMuLo4dO3Zw8uRJRo0aZduXmprKpUuXiImJ4fnnn0ev16PX61m2bBkA33zzDb169cLd3R2AZs2aFTnPEhMTw5QpUwBo2LAhd9xxBwAnTpzg1KlTTJs2zXZsdnY2Bw4cYPTo0eTk5LBv3z7c3d1JTk6mc+fOhdretGkTAwYMwN/fH4CIiAiioqKIj48vdGz9+vW57bbbAAgJCWHFihUA/Prrr1y+fJmYmBgAcnNzCQgIsJ3XsWPHQm2J6kEShXA6Ot3VayyUUhgMed+m1w/l5Js4cSLDhw9n8+bNrFy5kvfff982SZx/bn5bOp0Oi8VC06ZNWb58uW3fhQsX8Pf3Z/v27QwZMoTJkycDYLVaSUhIwNfXF4PBgKZptnPOnTuHm5tboefRNA1VRAm167fnn2OxWPDx8SE6Otq27+LFi3h7e6NpGsOHDyc6Ohqj0cjw4cPRNI1FixaxYcMGAHr06FHk8ymlMJvNhbYbjcYiY7JarUybNo1u3boBkJGRQU5Oju3Y4t5/cfOTq56E0/nmm28A+PPPPzl58qTtr9+imM1mevToQWZmJqNHj2bmzJkcPXrU9gty9erVWK1WUlNT+f777+nRowdt27bl5MmT7NixA4CDBw/St29fEhIS6NKlC2vXriUhIQHImxN46KGHAOjcuTPffPMNVqsVk8nE+PHjbW2Uxd13381XX30FwNmzZ9m+fTsAjRs3xtXV1ZYozp07x8CBA9m/fz8AQ4cOZcOGDfzwww9EREQAeRcAREdHEx0dzYQJE+jatSvfffedrSezYsUK/Pz8aNiwIXq9vsiEcb2uXbvy2WefYTKZsFqtzJgxg9dff73Mr0/cvKRHIZzO6dOnuffee9E0jddffx0/P79ijzUYDEybNo1JkybZ/uKfM2cOLi4uQN4QzvDhw8nIyGDMmDG2YZu33nqL+fPnk5OTg1KK+fPnExQURFBQEI899hiPPvoomqbh5eXF4sWL0TSNp556iqioKIYMGYLFYmHAgAH06dPH9pd9aWbOnMnzzz9P//79qVOnDiEhIQC4uLjwzjvvEBUVxQcffIDZbGbChAl06NABgMDAQFq2bInZbKZ27dpFtt2lSxcefvhhHnroIaxWK/7+/rz33nvodDratWvHm2++yZNPPsmDDz5YbHxPPPEE8+bNY+jQoVgsFm699VamTp1aptcmbm6aKqrPKsRN4IEHHuC+++6jX79+lR2KEFWaDD0JIYQokUN7FNHR0bz//vsAhIWF2a74yBcfH8+UKVNIT0/Hx8eHuXPnEhQU5KhwhBBC3ACH9SiysrKIiopi6dKlREdHExsba7vsLt+iRYsIDw8nOjqaPn368MYbbzgqHCGEEDfIYYnCYrFgtVrJysrCbDZjNptxdXUtcIzVaiU9PR3ISyz5lxoKIYRwHg4delq6dCkLFizAzc2NTp068fbbbxe4Dv3UqVOMGjUKvV5Pbm4uX331FQ0bNnRUOEIIIW6Aw3oUhw4dYsWKFfzyyy+2u2Gvr7A5ZcoUZs+ezaZNm5g1axZPPfVUkTcOCSGEqDwOu49i8+bNdO7c2VYCICIigs8//5yxY8cCkJyczLFjx+jVqxcAffv2ZebMmaSkpNjKEJQmJSUDq/XvJ5bZH++gZaMaDL/nlkL7rOlJZK15Fdc7R2No3KHcbQcEeJGUlP63Y3Q0idO+JE77qQoxQtWIU6fTqFHDs9znOSxRhISEsGDBAjIzM3F3d2fDhg2Ehoba9teoUQNXV1diY2Pp2LEjO3fuxNPTs8xJAsBqVXZJFABHz6QV2ZbVYsGcmoghOwPdDT6XvWJ0NInTviRO+6kKMULVibO8HJYounbtyoEDB4iIiMBoNBIaGkpkZCQvvPACPXr0oGfPnixevJiXX36Z7OxsPD09efvttx0VTokC/dw5dja1mL1X5lRkSEwIUU05tIRHZGQkkZGRBbZFRUXZvm7Tpk2BwmyVpaavGzsOJmCxWtHrrpu2uTL5rpBEIYSonqTWE3k9CqtSpKTlUNPPveBO7UrikB6FEMVSSpGSkojJlA12/qMqIUGH1Wq1a5uO4Exx6vUGvLz8cHcv/3xEUSRRAIG+efdvJKZmF04U+SRRCFGs9PRUNE2jdu1gNM2+F1MaDDrMZuf4BVwSZ4lTKUVurolLlxIB7JIspNYT2JJD4qWswjtt931IohCiOFlZ6Xh7+9k9SYjy0zQNFxdX/PwCSU+/ZJc25VMF/H1c0WkaF1OLShQy9CREaaxWC3q9DFA4E6PRBYul9HVIykISBaDX6fD3ceXipeziD5JEIUSJrq26ICqfPT8PSRRXBPq5Fzn0dLUrLYlCiKpu3LjHbV937SprgJeVJIoravq6kZhaRI9Ck/sohLhZ7N69s7JDqJJkUPGKmn7upGWYyMm14GrUFz5AEoUQVcqnn37Ijz9+j06n4/bb78RszgXgscce4r///QSABQvmsH//PgCiouYTHFyfgwf/5K23XicnJxtfXz8mT55GvXpBPPVUJD4+vhw/fpTZs1+lWbMWlfbaKpokiisC/fIukb2Ymk1QzWsuJ5OhJyHKbcu+c2zee84ubWlawb/TurapS5fQuiWes3XrZjZv/o0lS5ai1xuYPv05br/9TgBbkgDo2LETkydPY/HiN4mOXklk5BPMnfsK8+a9QZ06ddi+fSvz5kWxaNE7ADRtegtz5iywy+uqSiRRXBHoe/US2YKJQoaehKhqdu6MpVevvri65v0BGB4+mO+/X1vouLvvvgeAxo2b8Mcfuzl9+iRnz8YzdeoztmMyMjJsX7ds2dqxgTspSRRX5N9LcbHQhPaVEh6SKIQosy6hpf/VX1Y3ciObUtbrHlPkpaIGQ96vQE3TUEphsVipVy+Ijz/+HMhbgC0lJdl2/PWLr1UXMpl9hY+HERejjovXT2jLDXdCVDnt29/Ozz//QE5ONmazme++W0379h3R6/WYzcXfW9CwYSPS0tL444/dAKxdu5qXXnqhosJ2WtKjuELTNAJ9i7hEVoaehKhyunS5myNH4vjnPx/EYjFzxx2dGTZsJHv37uHhh8ewZMnSIs9zcXHh5ZfnsmjRQkwmEx4enkyfPquCo3c+Dl0K1dGSktLtWv990fI/SErLYfY/O9m2KYuZ9CVjcekYgWv7weVuMzDQm8TEy3aL0VEkTvuqbnGeP3+SOnUcs4yxs9RQKo0zxnn956LTaQQEeJW7HRl6ukagnzsXU7MKzkfI3aZCiGpOEsU1avq5k22ykJ6Ve3WjDD0JIao5SRTXyC83XnBCOz9ROFeXUgghKookimsUVW5cCp0JIao7SRTXqFlkj4Irt4ZKj0IIUT1JoriGu6sBL3djEVVkNZmjEEJUW5IorhPo51b47mwZfhJCVGOSKK4T6OdeuNy4DD0JUe1cu3ZFWdx7bzjnzp11UDSVu36GJIrr1PR1Jyk1+7ob+TSp9SRENSNrV1wlJTyuU9PPDYtVkXI5h4Ark9t5Q0+SKIQoq9zDW8iN+80ubeUX7MtnbBGGsXmXEs/ZtSuWDz98H73eQELCeVq2bEVgYG00TePxx58EYM6cWdxxR2datQplzpxZpKQk4+bmxpQpM/j221XA1bUrfvxxHZ9+ugTQuPXWlkyZMp3MzAxmz55BQsIFGjVqgslkAvIKCb7zziJ2796JxWJlwICBjBx5H0op3n33bX777VcMBj2DB0cwYsRoTp06yfz5UVy+nIabmztPPz2JW29txblzZ5k9ewZZWVm0anW1am1mZiavvz6PY8eOYrVaue++B+ndu59d3uviSI/iOoH5VWRTr5mn0HQymS1EFXPgwJ88++xzfP75CnJyTPj5+fHzzz+glCIrK4vY2N+5++57eO21uXTr1oOlS7/m0Ucj+eSTJTz99GQgb+2KxMQE3n77dV5/fTHLln2N1WohJmYzH3zwH5o3D+HTT78iIuIfJCcnAbBmzTcAfPjhZ/z3v5+wadNG/vhjN7/8sp59+/7g00+/5P33P+G779aQlHSRl1+ewT/+MYpPPvmSceOeYfr0KZhMJt54Yz4DBgzi448/JzT0Ntvr+uSTJbRocSsffriMf//7fT799EPOnIl36Hvp0B5FdHQ077//PgBhYWFMmTKlwP6EhASmT59OQkICbm5uLFy4kODgYEeGVKr8m+4SLmXRokGNqzskUQhRZsbmXUr9q7+sbrSGUtu27WjQoBEA/foNYPXqb6hTpy579uziwoXz3HVXV1xcXNizZxcvvRQFQOfOXencuWuBdvbv30to6G3UqlUbgBkzXgbgv/99h5demnPludoTFJT3uys29neOHDnMzp2xAGRlZXL06F+cOHGMHj164+LigouLCx9//DmZmZnEx8fTrVsPAFq3DsXHx4dTp06ye/dOW1x9+vRn7tyXbe3n5GSzdu1qALKzszl+/Jjt+R3BYYkiKyuLqKgo1q1bh4+PD6NHjyYmJoa77rrLdsxzzz1H3759GT16NF988QULFy7kzTffdFRIZeLv44amwcVL10xoy9CTEFWOXn91SWOrVaHX6wkPH8xPP63jwoULPPpo5JXjrv4aVEpx4sRxGjduYtuWv2ZFvpSUFCBvSMxqvZrA8p/PYrHyxBPjbb/8L126hLu7G++99+8C7Zw7dxZvb59C8595a2dYAM02V6ppGjqd7sprsTBjxsu0aBECQHJyEj4+vuV8d8rHYUNPFosFq9VKVlYWZrMZs9lcYNGP5ORkDh06xKhRowAYNmwYTz/9tKPCKTODXoe/t5sMPQlRxe3du4fExASsVivr1q3ljjvuonv3nuzcuYPk5Iu2cf+2bdvx888/AhAbu5358/P+is9fu+LWW1tx4MB+kpIuAvD226+zefNGOnbsxI8/fg/AwYN/Eh9/GoAOHTqyevUqzGYzmZmZPPHEP/nzz/3cdlt7Nm7cgNlsJjs7m2efHUdychJBQcFs3LgBgP3795GcnESTJk3p2LETP/zwHQAbN26wzYG0b387q1b9D4CLFy/y0EOjuXDhvEPfS4f1KLy8vJgwYQL9+/fHzc2NTp060b59e9v+06dPU69ePebMmcP27dupV68eM2bMKNdz3Ei53LKoF+jFpYxcAgO9AcjQabi7Gah55XF5Bd7geRVN4rSv6hRnQoIOg8FxU57lbVuv11GzZiBRUTNJTEzk9tvvYOjQCPR6PaGhbWja9BZbm5MnT2XOnNmsWvU/3NzcmDbtRQwGHXff3Y1HHhnDxx9/xjPPTObZZ8dhtVpp3boNgwcPITs7i9mzZ/LAAyNo2LAR9eoFodfrGD78H5w5E8+jj96HxWJh4MAhdOqUt3TB4cMH+ec/78dqtTJy5BiaNGnMrFmvMG/eHD788H2MRiNz5y7E3d2VyZOnMmvWdFavXknLlq3w8PDEYNARGfk48+e/yoMPjsRisfDUUxNo2LBBke+DTqezy+frsPUoDh06xNSpU1myZAne3t5MmjSJNm3aMHbsWAB27tzJfffdx7vvvkv37t1Zvnw5q1evZunSohcUKYq916PI9+Hag+w7nsQbT+WNVaZ/Og5Dk9tx6/pguduqbusSOJrEaV8363oU+Vc9LV78vm2bUorMzAwef/xRFi16h4CAmpUep6M5/XoUmzdvpnPnzgQEBODi4kJERAS///67bX9gYCCenp50794dgIEDB7J3715HhVMuNf3cSE03Ycq15G3QpISHEFXdwYN/Mnz4YAYPHmr3JHGzc1iiCAkJISYmhszMTJRSbNiwgdDQUNv+Bg0aULt2bTZu3AjAL7/8QqtWrRwVTrnkXyKblHbNhLYkCiGqjPbtOxboTQC0bNma77/fwIgRoyspqqrLYYmia9euhIeHExERweDBgzGbzURGRvLCCy+wfv16ABYvXswHH3zAwIED+fTTT5kzZ46jwimXQN/ryo1rOuSqJyFKJtULnIs9Pw+H3kcRGRlJZGRkgW1RUVG2r5s0aVKuOYmKUtMv716KxPxLZGXoSYgS6XR6LBYzBoOxskMRV+Tmmgpc+vt3yJ3ZRfD1dMFo0F1ziazUehKiJO7uXly+fAklxTMrnVIKkymHS5cS8fLys0ubUuupCJqmUdPXrWCPQoaehCiWl5cvKSmJXLgQj71/VnQ6XYEb25yVM8Wp1xvw9q6Bu7unXdqTRFGMQD/3q+tSyNCTECXSNA1//1oOabu6XWrsjGToqRiBvteuSyHrUQghqi9JFMWo6edGVo6ZjOxcWeFOCFGtSaIoRs1rL5GVoSchRDUmiaIYgVcukc2rIitDT0KI6ksSRTFsPYrULDQZehJCVGOSKIrh4WbA082Qd4msJj0KIUT1JYmiBDVtl8jKHIUQovqSRFGCQL8rl8jK0JMQohqTRFGCQF83klLzexQy9CSEqJ4kUZSgpp87ZovCYpXKmEKI6ksSRQnyL5E1WxVS60kIUV1JoihB/roUuRYlk9lCiGpLEkUJ/H3c0LiSKKRHIYSopiRRlMBo0OHn7YpZehRCiGpMEkUpAv3cMUmiEEJUY5IoShHo60auWYaehBDVlySKUtT0cyfXolAWuY9CCFE9lbrCndlsZteuXRw/fhydTkeTJk3o0KFDRcTmFAL93MhRRnJzMis7FCGEqBQlJorPPvuM9957j9q1a1O/fn0sFgtffPEFKSkpPPbYY4wePfqmr6xa09eds8qINTu9skMRQohKUWyieOqpp2jZsiXLly+ndu3aBfYlJSXxxRdf8OSTT/LOO+84PMjKFOjnzlHlArnSoxBCVE/FJooZM2YUShD5AgICeOqppzh//rzDAnMWvl4uZOOK3pyNUuqm70EJIcT1ip3MLipJmEwmMjIybI/r1KlTYuPR0dGEh4cTHh7OvHnzij3uwIEDtG7duizxVjidpqFz80SHFcw5lR2OEEJUuDJf9bRmzRqGDRvGiBEj+M9//lPq8VlZWURFRbF06VKio6OJjY0lJiamyONmz55Nbm5u+SKvQAZ3TwCUTGgLIaqhYhNFSkpKgcfff/89a9as4dtvv2Xt2rWlNmyxWLBarWRlZWE2mzGbzbi6uhY6bu7cuTz88MPlj7wCuXl5A6BMkiiEENVPsXMUTzzxBAMHDmTMmDFomoafnx/vvvsuBoMBb2/vUhv28vJiwoQJ9O/fHzc3Nzp16kT79u0LHLN+/Xqys7Pp16/f338lDuTh7QOJkH05DU//yo5GCCEqlqaKWWjBbDbz6aefsn79ep555hlatWrF6tWrMZlMhIeHU6NGjRIbPnToEFOnTmXJkiV4e3szadIk2rRpw9ixYwFITEzk//7v//j444/x8vKiRYsWxMXF2f8V2sHvv22j5qYFqB7jaNr5nsoORwghKlSxPQqDwcCjjz7KoEGDWLBgAUopnnvuOQIDA8vU8ObNm+ncuTMBAQEARERE8Pnnn9sSxa+//sqlS5e47777bOcMGTKEzz77DC8vrzI9R1JSOlar40trGIx55cbPn03AJ/Fyuc4NDPQmsZznVAaJ074kTvupCjFC1YhTp9MICCjb79drFZso0tPTiY6OxsXFhZdffpl9+/YxYcIEevTowcMPP4zBUPJN3SEhISxYsIDMzEzc3d3ZsGEDoaGhtv3/+Mc/+Mc//mF73KJFC6Kjo8v9AiqCf00/rEBWmnN/EwghhCMUO5n91FNPkZGRwdmzZ5kyZQodO3Zk2bJluLu7c//995facNeuXQkPDyciIoLBgwdjNpuJjIzkhRdeYP369XZ9EY7m4eMDQE6mJAohRPVTbLcgKSmJyMhIzGYzw4cPB0Cn03HfffcxYMCAMjUeGRlJZGRkgW1RUVFFHuus8xMAms6ACSPmrIzSDxZCiJtMsYmiZ8+ehIeHo5Qq1IMobSL7ZpSrc0XlSKIQQlQ/xSaKp59+mrFjx2IwGHBzc6vImJyS1eCOlpGFVSl0UsZDCFGNFDtHsXz5cry8vEpMEl999ZVDgnJKLh64YiI13VTZkQghRIUqNlGYzWZGjhzJZ599xtmzZ23bz5w5wxdffMGwYcOcuuyGvendPPHQcriYmlXZoQghRIUqduhp9OjRdOvWjffee4/Fixdz+XLeFT8+Pj706dOHRYsWERwcXGGBVjajhxfuWi7nLmXTrPq8bCGEKHnhonr16jFr1ixmzZpFSkoKOp0OX1/fiorNqbh5eZOrmUi8JD0KIUT1UupSqPmq45VO19K7eeKmmUi8JIUBhRDVS5nLjFd3mosHOg3SLqVVdihCCFGhJFGUkeaatyZFelpqJUcihBAVq0yJIjs7m7i4OJRSZGdnOzom5+TiAUBuRjpmi7WSgxFCiIpTaqLYs2cPvXr14vHHH+fChQt069aNXbt2VURsTkVzzUsUbpqJpLRqmiyFENVSqYli/vz5fPzxx/j5+VGnTh3mz59fbL2mm5l2pUfhrpm4eEkShRCi+ig1UWRnZ3PLLbfYHnfr1g2LxeLQoJxRfo/CQy6RFUJUM6UmCoPBQGpqKtqV+kbHjh1zeFDOKL9H4ak3kSh3ZwshqpFS76P417/+xf3338/Fixd55pln2LJlC7Nnz66I2JyLizugEeCu2H9O1qUQQlQfpSaKHj160LRpU7Zs2YLVauWJJ54oMBRVXWiaDlzcaOxtYPmRFP46k8otQdXzLnUhRPVS6tDTtGnTaNiwIWPGjOH+++/nlltuYdy4cRURm9PRXD2p76fDx9OFlRuPVnY4QghRIYrtUcycOZMLFy6wc+dOkpOTbdvNZnO1nqfQcrMI79yQL34+woETybRs5F/ZYQkhhEMVmyiGDx/OkSNHiIuLo2/fvrbter2edu3aVUhwzkZz8QBTJve0DeKH30+x8rdj3Nqwhm2iXwghbkbFJorQ0FBCQ0O56667qFOnTkXG5LQ0Vw+saQkYDToGd2nMx98f4o+/kmjbrGZlhyaEEA5T6mT2uXPnmDVrFpmZmSilsFqtxMfH8+uvv1ZAeE7GxROVk1c99q7Wdfhu20lW/naMNrcEyPKoQoibVqmT2dOnT6ddu3akp6czaNAgvLy86NOnT0XE5nQ0Vw+UKS9RGPQ67u3amPjEdGIPJVRyZEII4TilJgpN04iMjKRTp040adKERYsWERsbWxGxOR3NxQNys1HWvDvTO7WsTVCgJ99sOo7FKoUChRA3p1IThadnXnntBg0acOTIEVxdXatlCQ+4WsYDU96d2TpNY+jdTbiQnEnM/vOVGJkQQjhOqYkiNDSUp59+mjvvvJMPP/yQuXPnotfrKyI2p5NfxkPlZNi2tWtWk8Z1vVm9+QS5ZulVCCFuPqUmiueee46HH36Yxo0bM23aNKxWKwsXLixT49HR0YSHhxMeHs68efMK7d+5cyfDhg1jyJAhPPTQQ5w5c6b8r6AC5fco8ucpIG9obmhYE5LSsvntj7OVFZoQQjhMqYlixIgRtG3bFoB77rmHadOm0aRJk1IbzsrKIioqiqVLlxIdHU1sbCwxMTEFjpk8eTJRUVFER0czaNAgXnnllRt7FRXF1qMouG52q0b+NK/vx7cxJ8jJrZ7DckKIm1epicLNzY3z58s//m6xWLBarWRlZWE2mzGbzbi6utr2m0wmJkyYQEhICAAtWrTg3Llz5X6eilRUjwLyehURYU1IzTCxYVd8ZYQmhBAOU+p9FFlZWfTs2ZM6derg4eFh275mzZoSz/Py8mLChAn0798fNzc3OnXqRPv27W37XVxcGDJkCABWq5XFixfTq1evcgUfEOBVruP/LrNrbU4BXi4WfAK9C+wLDPSm/c541m0/xfBeLfBwMxbYVxVInPYlcdpPVYgRqk6c5VVqonjhhRduqOFDhw6xYsUKfvnlF7y9vZk0aRJLlixh7NixBY4zmUxMnToVs9nM448/Xq7nSEpKx2pVNxTfjVC5eZPVl5OSyUksXGp84J0NmH0ogc+/P8iQro2BvG+cxCKOdTYSp31JnPZTFWKEqhGnTqfd0B/YpSaKTp063VBAmzdvpnPnzgQEBAAQERHB559/XiBRZGRk8H//93/4+fnx7rvvYjQai2vOORhcQdMVmqPI16iODx2aB/LD76fo2SEYL3cnfz1CCFEGpc5R3KiQkBBiYmJspT82bNhAaGhogWMmT55Mw4YNWbRoES4uLo4KxW40TUNz8Sg0R3Gte+9uTI7JwvfbTlZgZEII4Til9ihuVNeuXTlw4AAREREYjUZCQ0OJjIzkhRdeoEePHtStW5f169dzyy23cO+99wJQq1Yt/vvf/zoqJPtw9Si2RwEQFOjFna1qs35nPL1vr3/TjlkKIaqPUhPFa6+9xrPPPntDjUdGRhIZGVlgW1RUlO3ruLi4G2q3MmmuniX2KACGdG3M7wcTWBtzkqcbS2VZIUTVVurQU7WsEluC0oaeAGrV8KBrm7r8uucMCcklHyuEEM6u1B5FcHAwjz76KO3bt7fVfQJ45JFHHBqYs9Jc3FEZKaUeN+iuRmzZd54vf4pjdI/qt8a4EOLmUWqi8PPzA3D68hoV5dpS4yXx93Gje7sg1seepnvbetTx9yj1HCGEcEalJopXX30VyEsUZrOZhg0bOjwop+biWaAoYEnCOzdk096zrNp0jH8Nae3gwIQQwjFKnaM4efIk4eHh3HvvvURERNCrVy+OHj1aEbE5Jc3VAyy5KLOp1GN9PF0YdHcTfj+YwOmE9AqITggh7K/URDF79mzGjh3Ljh072LlzJ//3f//HrFmzKiI2p2QrNX5lTYrSRNxzC+6uBr757ZgjwxJCCIcpNVEkJSUxdOhQ2+Nhw4aRklL6ZO7N6uriRWW7msnLw4V+dzRgz18XOXo21YGRCSGEY5SaKCwWC5cuXbI9Tk5OdmQ8Tk9zybvyq6zzFAC9Owbj7WGUXoUQokoqdTL7/vvvZ+TIkfTv3x+A77//noceesjhgTmr4kqNl8TNxUD4nQ35csNfHDqZQkjDGo4KTwgh7K7UHkVERASzZs0iNzeXnJwcZs6cyZgxYyoiNudUzOJFpenePoga3q6s/O0YSlVcxVshhPi7Su1R/OMf/2DVqlXceeedFRGP07uRHgWA0aBn0F2N+PSHOPYdS6JNUyntIYSoGhy2wt3NSrvBHgVA1zZ1CfRzY+Vvx7BKr0IIUUU4bIW7m5VmcAG9ocxXPV3LoNcxpGtjPvj2ILviEukYUssBEQohhH2VmigmT55cJdaKqEiaS8mlxktyZ8s6fLftFN9sOkb75oHodJqdoxNCCPsqNVEsXLiQVatWVUAoVUdZKsgWR6fTuLdrY95ZtZ+tf56nS2hdO0cnhBD2JXMUN8K17PWeitKhRSANa3sTvfk4ZovVjoEJIYT9yRzFDdBcPVDZN167SdM0hoY14c3lf7Bp7zm6twuyY3RCCGFfpSaKF154oSLiqFI0Fw+saQl/q43QJv7cEuzLmi3H6dK6Di5GvZ2iE0II+yp16KlTp064ublx7Ngx2rZti9FopFOnThURm9PSXD1RWZf/1o1zmqYxLKwJl9JN/LJb1voQQjivUhPFypUref755/nggw+4fPkyTzzxBF9//XVFxOa0dDUbgikTa8rf+wXfokENWjWqwdqtJ8nKMdspOiGEsK9SE8XSpUv56quv8PLyIiAggJUrV/LJJ59URGxOyxCctwiRJX7/325raFhT0rNy+Tn29N9uSwghHKHURKHT6fDy8rI9rlu3Lnp99R5P13kFoPOrh9kOiaJJPR/aNavJut9Pk5Gda4fohBDCvkpNFH5+fhw8eBBNy7sxbPXq1fj6+jo8MGenD26F5VxcmVa6K83Qu5uQnWNm3fZTdohMCCHsq9SrnqZNm8aECRM4deoUXbt2xdXVlXfeeaciYnNqhuDW5O7/Ccv5w7ahqBsVXMuLTi1r81PsaXp1rI+vp9wJL4RwHqUmiqZNmxIdHc2JEyewWCw0btwYo9FYpsajo6N5//33AQgLC2PKlCkF9p89e5bJkyeTlJRE48aNWbhwIZ6enjfwMiqevm4I6PSY4/f/7UQBcG/Xxuw4mMDarScY06u5HSIUQgj7KHXoCUCv19O0aVOaN29e5iSRlZVFVFQUS5cuJTo6mtjYWGJiYgocM2vWLMaMGcO6deto3bp1leqpaEZX9HWaY4n/0y7t1fb3oEtoHX7dfYbktGy7tCmEEPZQpkRxIywWC1arlaysLMxmM2azGVdXV9v+3NxcduzYQd++fYG8BZLWrVvnqHAcQh/cGmvyaayZl+zS3uAujQFYveWEXdoTQgh7cFii8PLyYsKECfTv35+wsDCCgoJo3769bX9KSgpeXl4YDHmjX4GBgVy4cMFR4TjE1ctk7dOrCPB1o1vbIDbvPceFlBsrOiiEEPZW6hzFjTp06BArVqzgl19+wdvbm0mTJrFkyRLGjh0LUORdzflXVpVVQIBX6Qc5kKrZkpMePhguxhHYpV+xxwUGepe5zYcGtmLT3nP8sCOeZ+/rYI8wy6w8cVYmidO+qkKcVSFGqDpxllexiSIkJKTEX9wHDx4sseHNmzfTuXNnAgICgLyhpc8//9yWKPz9/UlPT8disaDX60lMTKRWrfIt5JOUlI7VWrkrxenqtSTj6B4SElLRtMIdtMBAbxITL5erzZ4dgli37RQ92tUjOLBikuGNxFkZJE77qgpxVoUYoWrEqdNpN/QHdrFDT1u3bmXLli2MGDGCiRMnsm3bNnbs2MHzzz/PQw89VGrDISEhxMTEkJmZiVKKDRs2EBoaattvNBrp2LEj3333HQCrVq0iLCys3C+gshmCW6Oy0rAm2e/O6v53NMTNVc+qTcft1qYQQtyoYhNFjRo18Pf3Z//+/URGRuLr64uXlxcPPvggv//+e6kNd+3alfDwcCIiIhg8eDBms5nIyEheeOEF1q9fD8DMmTP5+uuvGTBgALGxsTz99NN2e2EVRX9lnsJsp3kKAC93I31vb8Cuw4kcP5dmt3aFEOJGlGk9imPHjtGkSRMA4uLiyM0tW6mJyMhIIiMjC2yLioqyfR0UFMTSpUvLE6/T0Xn4ofMPxnJmP7QdYLd2e99en593xvPNb8d4ZmRbu7UrhBDlVWqiePrppxk5ciQtWrRAKcVff/3FwoULKyK2KkMf3Jrc/T+jcnPQjK6ln1AG7q4GBtzZkK9/+YvDpy/RvL6fXdoVQojyKjVRBAUFsW7dOnbu3ImmaXTo0AF/f/+KiK3KMAS3JnfvOizn4jA0aGO3dnu0D+KHHadYufEoU+5rX+6rwoQQwh5KvY9i0qRJBAQE0KdPH3r37i1Jogj6Os1Bb7RLNdlruRj1DLqrEYfjU/nzeLJd2xZCiLIqNVG0aNGCNWvWcPbsWS5dumT7T1ylGVzQ122RN09hZ2G31aOmrxsrfjv2t1bUE0KIG1Xq0NP69esLldbQNK3U+yiqG0NwK3K2fYU1PRmdl/16XQa9jsFdGvPhdwfZdTiRDi3Kd6+JEEL8XaUmin379lVEHFVe3mWyX2GJ348uxL73g3RuXZvvtp3km03HadcsEJ1O5iqEEBWn1KEnq9XKf//7Xx544AFGjx7N4sWLMZtlfefr6WoEo7n72n2eAkCv03Hv3Y05ezGD7QeqVj0sIUTVV2qieO2119i2bRsPPfQQjzzyCLt372bevHkVEVuVomka+uDWmM/8ibJa7d5+x5Ba1K/lxarNxzBb7N++EEIUp9Shp02bNrFixQrbOhT33HMPgwcPdnhgVZEhuBXmI1uwJp1EH9jYrm3rNI2hYU1463972bzvHPe0DbJr+0IIUZxSexRKqQKLFbm4uJR58aLq5mo5D/sPPwHc1jSApvV8WLPlBLlmi0OeQwghrldqoggJCWHOnDmcOnWKU6dO8eqrr9K8uSzVWRSduw+6gIZYHJQoNE0jIqwJKZdz+GX3WYc8hxBCXK/URDFz5kzS0tIYNWoUI0aMIDk5mRkzZlREbFWSIbgVlvN/oUxZDmn/1kb+3NqwBmu3niDbJBcVCCEcr9REsWbNGiZPnkxMTAzbtm1jwYIF+Pn5VUBoVZM+uDUoC5Zzhxz2HBFhTbicmcvPsfEOew4hhMhXaqI4cOAA9957L/fffz+ffvpplVuutKLp6zQDg4vD5ikAmgb5clvTANZtP0Vmdtkq+QohxI0qNVG8/PLL/Pbbb0yaNImLFy8yevRoRo0aVRGxVUma3oi+bohd16coytCwJmTmmFn3+ymHPo8QQpSaKEwmE1u3buXHH39k48aNADRr1szhgVVlhuDWqNTzWC8nOuw5GtT25vaQWvy0I560DJPDnkcIIUq9j6Jjx474+vryyCOP8Oabb9K4sX3vD7gZFVj17sqCT45w792NiY1L4O2Vewm7rR7tmgXi5S6XLgsh7KvURPHqq6+yadMmvvjiC2JiYujatStdunSRXkUJdH510Tz9r1wmO8hhz1M3wJP7ezfn++2n+Oi7Q3yqiyOkgR8dWtSiffNAfDxdHPbcQojqQ1PlqF29YcMGFi5cyPHjx52iemxSUjpWq3OW3s7euITc4ztp/OzHXEzKdOhzKaU4eeEyO+MSiT2UwIWULDQNmgf70TEkL2nU8C555b3AQG8SEy87NE57kDjtqyrEWRVihKoRp06nERDgVe7zSu1RbN26lU2bNrFp0yZMJhO9evVizpw5NxRkdaIPbk1u3CZyzh0Fl7oOfS5N02hUx4dGdXyICGvCmcQMYuMS2BmXyGc/Heaznw5zS5AvHVoE0qFFIDV93R0ajxDi5lJqopg/fz69e/fmtddekzuyy8EQ1ArQyDq2B0IcmyiupWkawbW8CK7lxb13N+FcUgaxcYnsPJTAVxv+4qsNf9GojjcdQ2rRoUUgtWt4VFhsQoiqqVxDT87GmYeeADK+mYXR1RWXAVMrOxQAElIy84an4hI5fi4NgPq1vOjQIpDedzbCXe/861xUhe49SJz2VBVihKoRp8OGnsSNMwS3JmfPWoymTDSXyv/LvVYND/rf2ZD+dzYkKTWbnYcTiY1LIHrTcVZtOk7dAA86tKhFxxaB1K/lhaY5f+IQQjieJAoH0ge3ht1rMJ85iLFxh8oOp4AAXzf63F6fPrfXJ+VyDkfOpvHrztOs3XqCb2NOUMvPnQ4hgXRsUYtGdbwlaQhRjUmicCB9raZoLm5Y4vc7XaK4Vg1vV8K7NqFTi0DSMkzsPpI3PPXj76f5ftspAnzc6NAiL2k0CfJBJ0lDiGrFYYli+fLlLFu2zPY4Pj6eIUOG8OKLL9q2/fnnn7z44ovk5uZSt25dFixYgI+Pj6NCqnCa3oB7w1CyHFj3yd58PF3o1jaIbm2DSM/KZc+Ri+yMS2DDrnh+3HEaPy8X2jfPSxrN6/vJ+t1CVAMVMpl95MgRnnzySb788kv8/f1t28eMGcPjjz9Ot27dmDt3Lq6urkycOLHM7Tr7ZDaAy8nNJP3wAZ6j5qPzqVXZ4RSrtIm4rBwzf/x1kdi4RPYdSyLXbMXbw0j75nmX3IY0qIFBX2pFGIfH6SwkTvupCjFC1YjTqSezX3rpJSZOnFggSQBYrVYyMjIAyMrKwtfXtyLCqVAeTW4jCTCf3odLq56VHc4Nc3c1cGerOtzZqg7ZJjP7jiWzMy6BbX9eYOOes3i6GWjbrCYdW9SiZSN/jAbHJw0hRMVweI8iJiaG1157jRUrVhTat2fPHh555BE8PT1xd3fn66+/pkaNGo4Mp8IppTj97ydwqd2QOv9wjstk7Skn18LuuARi9p7l9z/Pk5FtxsPNQKeWdbirTV3ah9TG1aiv7DCFEH+DwxPF+PHj6dOnDwMHDiywPTs7m2HDhvHqq6/Spk0bPvroI7Zu3cr7779f5rarwtBTYKA3p1e8Te7RbXg9tBhN55zXD9ij22y2WDlwIoXYuAR2H04kI9uMq1FPaNMAOrYIpE3TANxc/t7rrwrde5A47akqxAhVI06nHHoymUzs2LGDuXPnFtp3+PBhXF1dadOmDQAjR45k0aJFjgyn0ujrtyb30K9YEo5hqHPz3t1u0Oto0zSANk0DMPdtQdzpS+yMS2RXXAKxhxIwGnS0buxPxxa1uO2Wmni4OWfSFEIU5NCf1Li4OBo1aoSHR+GbzRo2bMj58+c5duwYTZo0Yf369YSGhjoynEpjqHcraBqW+P03daK4lkGvo1Ujf1o18uf+3s05En+J2LhEdh1OZPeRi+h1Gq0a+9OheSDtmkt5dCGcmUMTxenTp6lTp06BbY899hjjx48nNDSUV199laeffhqlFAEBATdtsUHN1RNdraaYT+/HtWNEZYdT4XQ6jRYNatCiQQ1G92rGsbNp7IxLIPZQInuPJvHJujhCGvrRsUUt2jUPxFfKowvhVKTWk4Plj1vmxH6DaddqvB58G82t/GOEjlYZ46v55dFjD+WVEkm4pjx6XqXbWoXKo1eFcWCQOO2pKsQIVSNOp5yjEFcZgltj2hWN+ewBjE06VXY4TuHa8ujDujUhPjEjr6cRl8jnPx/h85+P0DTIhw7N8+pP1fST8uhCVAZJFBVEV6sJuLjnlfOQRFGIpmnUr+VF/Svl0c9ezEsaO+MS+fqXv/j6l79oWMebbu2DuTXYl9r+lV9kUYjqQhJFBdF0egz1WmKO/xOllBTZK0W9mp7Uq9mYQV0aX1MePYFPv8tbWTE40IuOLQLpEFKLoJqelRytEDc3SRQVSB/cGvOJnajU82h+FbeYUVV3bXl0pdfz09bjxB5OZNXm46zaLOXRhXA0SRQVyBDcmhzAHL8fF0kUN6SWvwd9OjWgT6cGpFzOYdfhRHbGJdjKowf6udGxRS3aNqtJ7RoeeHsYJXEI8TdJoqhAOp9ANJ/aeYmide/KDqfKq+HtSs8OwfTsEExaholdRxLZGZfIjztO8/32UwAYDTpqeLsS4OOGv7cr/j5u+PvkPa5xZZu7q/wYCFES+QmpYIbgVuQe3oyy5KLp5SYze/HxdOGetkHcc6U8+uHTl0hKyyY5LZvktByS07I5cDKFS5dzuP6Cag9XQ4EE4u9zJaFcSSw1vF0rpDKuEM5KEkUFMwSHkntgA5YLf+XdsS3szss9r/x5UcwWK5fSc2zJIyktm+TLOaSk5ZCUls3RM6lkZJsLnKMBPl4u1/VK3Ajwufq1t4dRFnQSNy1JFBVMXy8END2W+D8lUVQCg15HTV93avoWf09GjslC8uUrSeRKQkm+kkhOJ2bwx9G89TgKtqvh7321NxJcxwc3Q962/IQiQ1yiqpLv3Aqmubijr90Uc/w+XDsNr+xwRBFcXfTUDfCkbkDRl90qpUjPyi3UK8lPKAdPprDtz/NcXzTA3dVwdXjL25Ua+b0Sbzf8fd2o4eUq63gIpySJohLog1tjil2JNSsNnfvNs/RrdaFpGt4eLnh7uNCwjneRx/j7e/LXiaQieyXJl7M5djaN9KzcQuf5erpcM0dScHjL38cVH08XGeISFU4SRSUwXEkUljMH0N1yZ2WHIxxAr9fZfsEXJyfXkpdALueQnJr3b1JaNilp2Zy9mMG+Y0mYcgsOcel12tWruHyumy/xzvtayrcLe5PvqEqgq9kIXD3JPbQRQ+OOaHr5GKojV2PpQ1wZ2eZCvZH8Hsrh05dIuWzCel1dTzcXva0HUlSvxN/bFaNBVh0UZSe/oSqBptPh2ukf5Gz6mOyf/41bryclWYhCNE3Dy92Il7uRBrWLHuKyWlXeVVyXrxveuvL1yfOXuZxZeIjLx8OIv48bdQO98HTV5yUU36tXdfl6uqDTyRCXyCO/nSqJy633gNVCzpalZP20GPfeT8p9FaLcdDrt6hBXkG+Rx5hyLaRczp94z7nSK8lLJPEJl0lIziIn11LgnPwhrmsvB772/pIAXzc8XA1y13s1IYmiErm06gmaRs7mT68ki6ckWQi7czHqqe3vUWTF3cBAbxIS0sjMMdt6IynXJpTUbP46k0rKoQQs113G5WrU25LHtXMktjvfvV1xMcoQ181AEkUlc2nZA0CShag0mqbh6WbE081I/VpFL2pjtSpSM0wF5kjyksqV+0sS0knLMBU6z9vDWOD+koBr5k78fVzx83KVIa4qQBKFE3Bp2QM0HTmbPibrx7fzkoVBlgMVzkN3ZSiqhrcrTesVfUyuOW+IK8l2OfDVK7kSUrI4eDKFbFPBIS6dplHD2+XKPSWF63H5+7hRs+ouwnnTkEThJFxuvQcgL1nk9ywkWYgqxGjQU6uGB7VqFL+oVGb+VVyXr514z0ssx86mEpuWU3iIy0VPDS9XAnxcCyaUK5PvHm5GNMirtXLln2vnTrRrtud/de3UytX9Vw/UCuzTChxX6JwrX1fhVaVLJYnCiRRMFm/j3nucJAtxU/FwM+Dh5kVwcUNcSnE5w1SgV5JlVsRfSMubfD+aRGoRQ1zOqmACKzpBXZuIrt10beLK/+facwoms/yvi0mQVx4E+rnz5jP3lPt1SKJwMi633pM3wf3bR5IsRLWj0zR8vVzx9XKlSb28qgWBgd4kJl62HZNrtpKSnnNl0j2bbJOFa/+Yz//LXtn+x9WKwUrZvi5wzjUHXt1/9QClCrZRVPseHi5kZOQUfQ7quhiLf968r1XhGK8959rXdV1bhV73NfF6e9zY7xJJFE7IJaQbADm/fUzWj2/h3me8JAshrjAadNTyc6eWX/GFHSvD9QnNGd3ohQOSKJyUS0g3NDSyf/uIrB8W4drlPjTKUTDOxR2dR9HX1QshRHlIonBixpAw0DSyN35I5tfTyneypmEM7Ytrx6FoBlfHBCiEqBYcliiWL1/OsmXLbI/j4+MZMmQIL774om3bsWPHmDlzJqmpqQQGBvL666/j6yt/BV/L2OJudDWCsKZdKNd5lrOHyN27DvOJ3bj3GY/eP8hBEQohbnaaqoBruo4cOcKTTz7Jl19+ib+/P5A3UdSvXz9eeOEFwsLCWLhwIUopJk+eXOZ2k5LSsV5f9N/JVOa4pfnsQXK2fo7x1u62G/uKUxXGV0HitLeqEGdViBGqRpw6nUZAQNFXnJWkQoaeXnrpJSZOnGhLEgB//vknHh4ehIWFAfCvf/2LtLS0igin2jDUuxXDsJcrOwwhRBXn8EQRExNDdnY2/fv3L7D91KlT1KxZkylTpnDgwAGaN2/OjBkzHB2OEEKIcnL40NP48ePp06cPAwcOLLB99erVzJgxg2XLlhEaGsqbb77J+fPnmTt3riPDEUIIUU4O7VGYTCZ27NhR5C//wMBAGjZsSGhoKAADBw5k/Pjx5Wpf5ijsR+K0L4nTfqpCjFA14rzROQqHruQeFxdHo0aN8PAoXPulXbt2JCcnc+jQIQA2bNhAq1atHBmOEEKIG+DQRHH69Gnq1KlTYNtjjz3Gvn37cHNz49///jfTp08nPDyc7du3M3XqVEeGI4QQ4gZUyOWxjiJDT/YjcdqXxGk/VSFGqBpxOuXQkxBCiKpPEoUQQogSSaIQQghRIkkUQgghSiSJQgghRIkkUQghhCiRJAohhBAlkkQhhBCiRJIohBBClEgShRBCiBJV6TWzdTqtskMoE4nTviRO+6oKcVaFGMH547zR+Kp0rSchhBCOJ0NPQgghSiSJQgghRIkkUQghhCiRJAohhBAlkkQhhBCiRJIohBBClEgShRBCiBJJohBCCFEiSRRCCCFKVCUTxZo1axgwYAC9e/fms88+q+xwCkhPT2fgwIHEx8cDEBMTw6BBg+jTpw9vvPFGJUeXZ/HixYSHhxMeHs78+fMB54xz0aJFDBgwgPDwcD766CPAOePMN2/ePKZOnQrAwYMHGTZsGH379uWFF17AbDZXcnTw4IMPEh4ezpAhQxgyZAh//PGHU/4sbdiwgYiICPr168crr7wCON/nvnz5ctv7OGTIEDp06MDs2bOdLs7o6Gjbz/q8efOAG/zeVFXM+fPnVffu3VVKSorKyMhQgwYNUkeOHKnssJRSSu3Zs0cNHDhQtWrVSp0+fVplZWWpbt26qVOnTqnc3Fz16KOPql9//bVSY9yyZYsaOXKkysnJUSaTST344INqzZo1Thfn9u3b1ahRo1Rubq7KyspS3bt3VwcPHnS6OPPFxMSoO+64Q02ZMkUppVR4eLjavXu3Ukqp559/Xn322WeVGJ1SVqtVdenSReXm5tq2OePP0qlTp1TXrl3VuXPnlMlkUqNHj1a//vqr037uSil1+PBh1bt3b3X27FmnijMzM1PdfvvtKikpSeXm5qrhw4erLVu23ND3ZpXrUcTExHDnnXfi5+eHh4cHffv2Zd26dZUdFgBff/01M2fOpFatWgDs3buXhg0bUr9+fQwGA4MGDar0WAMDA5k6dSouLi4YjUaaNm3KiRMnnC7OTp068emnn2IwGEhKSsJisZCWluZ0cQJcunSJN954g3/9618AnDlzhuzsbNq2bQtAREREpcd57NgxNE3jscceY/DgwSxbtswpf5Z++uknBgwYQJ06dTAajbzxxhu4u7s75eee76WXXmLixImcPn3aqeK0WCxYrVaysrIwm82YzWYMBsMNfW9WuUSRkJBAYGCg7XGtWrW4cOFCJUZ0VVRUFB07drQ9dsZYmzVrZvsmOXHiBN999x2apjldnABGo5G33nqL8PBwOnfu7JTvJ8CLL77IxIkT8fHxAQp/7oGBgZUeZ1paGp07d+bf//43H3/8MV9++SVnz551uvfz5MmTWCwW/vnPfzJ48GA+//xzp/3cIe8P1+zsbPr37+90cXp5eTFhwgT69+9PWFgYQUFBGI3GG/rerHKJQhVR7FbTnLO0rzPHeuTIER599FGmTJlCgwYNCu13ljjHjx/P1q1bOXfuHCdOnCi0v7LjXL58OXXr1qVz5862bc74ubdr14758+fj4eGBv78/w4cP56233ip0XGXHabFY2Lp1KwsWLODrr79m3759tvm+a1V2nPm+/PJLHnnkEcD5PvdDhw6xYsUKfvnlFzZv3oxOp2PLli2FjitLjFVuPYratWsTGxtre5yQkGAb6nE2tWvX5uLFi7bHzhLrzp07GT9+PNOmTSM8PJzff//d6eI8evQoJpOJW2+9FXd3d/r06cO6devQ6/W2Y5whzu+++47ExESGDBlCamoqmZmZaJpW4P1MTEys9DhjY2PJzc21JTSlFEFBQU73udesWZPOnTvj7+8PQM+ePZ3ycwcwmUzs2LGDuXPnAs73875582Y6d+5MQEAAkDfMtGTJkhv63qxyPYq77rqLrVu3kpycTFZWFj/++CNhYWGVHVaRbrvtNo4fP27rTn/77beVHuu5c+d48sknWbhwIeHh4U4bZ3x8PNOnT8dkMmEymVi/fj2jRo1yujg/+ugjvv32W6Kjoxk/fjw9evTg1VdfxdXVlZ07dwKwatWqSo/z8uXLzJ8/n5ycHNLT0/nmm29YsGCB0/0sde/enc2bN5OWlobFYmHTpk3069fP6T53gLi4OBo1aoSHhwfgfD9HISEhxMTEkJmZiVKKDRs20KlTpxv63qySPYqJEyfy4IMPkpuby/Dhw2nTpk1lh1UkV1dX5s6dy7hx48jJyaFbt27069evUmNasmQJOTk5tr+CAEaNGuV0cXbr1o0//viDe++9F71eT58+fQgPD8ff39+p4izOwoULmT59OhkZGbRs2ZIHH3ywUuPp3r277f20Wq2MGTOGDh06ON3P0m233cbYsWMZM2YMubm5dOnShdGjR9OkSROn+9xPnz5NnTp1bI+d7ee9a9euHDhwgIiICIxGI6GhoURGRtK7d+9yf2/KCndCCCFKVOWGnoQQQlQsSRRCCCFKJIlCCCFEiSRRCCGEKJEkCiGEECWSRCGqpOXLl9uqnX7xxRe8//77Dnuuw4cPM378eIe1Xx4PPPDADdUP2rhxo92qmU6aNImjR4/apS1RNVS5+yiEgLy7y5s1awbA6NGjHfpc69evp2fPng59DkdKT09n4cKFfP3113Zpb8KECTz77LN89dVXTlNKQziWJApRobZv305UVBQeHh5kZmYyefJk5s2bx7fffmvb//LLL/Ptt9/y9ttvc+bMGRITEzlz5gz+/v688cYb7N27lw0bNrBlyxbc3NxITk4mJSWFF198kR49ejBw4EB+/fVXLl26xLhx49i1axd//vknBoOBd999l9q1a3PhwgVmz57NuXPnyM3NJTw83Fb99XobN27kvffeK7T9rbfe4qeffsJoNFKjRg1effVVatWqxf/+9z+++uorcnNzSU1N5bHHHmPMmDGsXLmSH3/8kezsbM6cOUPdunW57777WLZsGSdOnOCRRx7h0UcfZeXKlaxduxar1cqFCxeoXbs2c+fOpXbt2gWef9euXSxcuJCsrCw0TWPcuHF07969UJyff/45Xbt2xd3dHYDQ0FAefvhhfv31V9LT05k8eTLr1q3j8OHD1KpVi//85z94eHgU+/rq16+Pt7c369evp1evXn/3W0JUBQ4qhS5EkbZt26ZCQkJUfHy87XF4eHiB/fmP33rrLdWzZ091+fJlpZRSjz/+uFq0aJFSSqkpU6aoDz74wHbcrFmzlFJKde/eXc2ZM0cppdTatWtVSEiIOnjwoFJKqSeeeEK9++67SimlHnjgAbV+/XqllFLZ2dnqgQceUGvXri0U7/nz59VDDz1UaPvZs2dV+/btVU5OjlJKqSVLlqiffvpJpaenqxEjRqjk5GSllFK7d+9Wbdu2VUoptWLFCtWhQwd19uxZZbFY1IABA9S4ceOUxWJRBw8eVKGhocpisagVK1aotm3bqmPHjimllFqwYIEaN26cUkqp+++/X33//ffq0qVLqk+fPur06dO2OMPCwtSZM2cKxTp06FC1bds22+PmzZurTz75RCml1HvvvafatWunzp8/rywWixo6dKhavXp1sa8v37Jly9Rzzz1X6LnEzUl6FKLC1a1bl6CgoDId26lTJ7y8vABo2bIlqamppZ7Tp08fAOrXr0/NmjUJCQkBoEGDBrbCfTt27CA1NZVFixYBkJmZyaFDhxgwYECBtn7++Wd69OhR6Dlq165NSEgIQ4cOJSwsjLCwMFvBvf/85z9s3LiREydOcOjQITIzM23nhYaGUrduXQCCg4Pp2rUrOp2O+vXrk5OTQ1ZWFgBdunShcePGAIwYMYIhQ4YUeP49e/aQmJjIk08+adumaRpxcXHUq1evwLHHjx+nYcOGBbb17dvX9p40b97c1lsJDg4mNTW1xNeX/95GR0cX8wmIm40kClHh8ouoQd4vN3VNFZnc3NwCx7q5uRV7bHFcXFxsXxuNxkL7rVYrSim+/PJL23BMcnIyrq6uhY7dsGEDs2fPLrRdp9OxbNky9u3bx9atW5kzZw533HEHY8eOZeTIkYwYMYIOHTrQr18/fvnllyJjAzAYiv4RvLZaqtVqLfAY8spxN23alOXLl9u2XbhwwVZ19VqapmGxWApsu/Z9Keo9Ku71TZ8+3RaTTifXwlQX8kmLSuXv78/Zs2dJSkpCKcXPP/9cpvP0ev0Nr0Pt5eVF27Ztbetwp6WlMXr0aNavX1/guPT0dC5fvlxk7+fQoUMMHDiQpk2b8vjjj/Pwww8TFxfH/v378ff354knnuDuu++2JYnrf1GXZtu2bbYFZb788stCcw9t27bl5MmT7NixA8hbB7lv374kJCQUaqtRo0acPn26XM9f3OvLd/r0aZo0aVKuNkXVJT0KUaluueUWRo0axbBhwwgMDOSee+4p03lhYWG8/PLLN/y8Cxcu5OWXX2bQoEGYTCYGDhzI4MGDCxyzcePGYkswh4SE0L9/f4YNG4aHhwdubm5Mnz6dxo0b87///Y9+/frh7u5OmzZt8Pf35+TJk+WKr3bt2kyePJnExERuueWWQr0af39/3nrrLVvpcKUU8+fPLzKp9evXj02bNnHnnXeW+fmLe335Nm3axP3331+u1ySqLqkeK4STWblyJT/88EORV1rdiPT0dEaMGMGKFStsQ21/x6lTp5g0aZJcHluNyNCTEDc5Ly8vnnnmGd555x27tPfmm2/yyiuvSJKoRqRHIYQQokTSoxBCCFEiSRRCCCFKJIlCCCFEiSRRCCGEKJEkCiGEECWSRCGEEKJE/w/IGQpIsLaOfQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_theme(style=\"darkgrid\")\n",
    "\n",
    "x = df_other[\"avg_dur_ms\"].values\n",
    "y = df_other[\"wer_val\"].values\n",
    "sns.lineplot(x, y, label=\"other\")\n",
    "\n",
    "x = df_pyctc[\"avg_dur_ms\"].values\n",
    "y = df_pyctc[\"wer_val\"].values\n",
    "sns.lineplot(x, y, label=\"pyctcdecode\")\n",
    "\n",
    "plt.xlabel('runtime / sample (ms)')\n",
    "plt.ylabel(\"word error rate (%)\")\n",
    "plt.title(\"librispeech dev-other\")\n",
    "plt.axis([0, 80, 7.5, 8.8])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}