readability.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/tai/data/miniconda3/envs/pixel/lib/python3.10/site-packages/transformers/deepspeed.py:23: FutureWarning: transformers.deepspeed module is deprecated and will be removed in a future version. Please import deepspeed modules directly from transformers.integrations\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "from datasets import load_dataset, load_from_disk\n",
    "import random\n",
    "from LatentPixel import TGraph\n",
    "from LatentPixel import LatentLlama, BIN_FONT\n",
    "import re\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "import logging\n",
    "import torch\n",
    "loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict]\n",
    "for logger in loggers:\n",
    "    logger.setLevel(logging.WARNING)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Juan Gálvez (Buenos Aires, 14 February 1916 – 3 March 1963 in Olavarría) was an Argentine racing driver, and the brother of driver Oscar Alfredo Gálvez. They started racing together in Turismo Carretera but then took separate ways and competed in different cars. He made his debut in the Avellaneda Automobile Club 1000-Mile race on 14 February 1941 and finished second to Juan Manuel Fangio. His first win came on 22 February 1949 at the I Vuelta de Santa Fe. He won the Turismo Carretera championship nine times, in 1949, 1950, 1951, 1952, 1955, 1956, 1957, 1958 and 1961. His last victory was at the IV Vuelta de Laboulaye (1962) behind the wheel of a Ford. He was killed during an accident at Olavarría race in 1963. In 13 years of motorsport he competed in 153 races, winning more than 50 times. See also\\n\\nAutódromo Juan y Oscar Gálvez\\n\\nRacing drivers from Buenos Aires\\n1916 births\\n1963 deaths\\nRacing drivers killed while racing\\nArgentine racing drivers\\nTurismo Carretera drivers\\nSport deaths in Argentina\\nBurials at La Chacarita Cemetery'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[292]['text']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def randomSplit(sent: str) -> tuple[str, str, str]:\n",
    "    words = sent.split()\n",
    "    if len(words) == 0:\n",
    "        return '', '', ''\n",
    "    bint = min(50, len(words))\n",
    "    eint = min(120, len(words))\n",
    "    idx = random.randint(bint, eint) - 1\n",
    "    sent1 = ' '.join(words[:idx])\n",
    "    sent2 = ' '.join(words[idx:])\n",
    "    return sent1, sent2, words[idx]\n",
    "\n",
    "pat = re.compile('([a-zA-Z]+)')\n",
    "def add_word(words: str | list[str], corpus: set[str]):\n",
    "    global pat\n",
    "    if isinstance(words, str):\n",
    "        words = re.findall(pat, words)\n",
    "\n",
    "    for word in words:\n",
    "        corpus.add(str(word).lower())\n",
    "    return\n",
    "\n",
    "def evaluate_babi(generated: list, vocab: set) -> dict[str, float]:\n",
    "    pat = re.compile('^([a-zA-Z]*)')\n",
    "    correct_paddle = 0\n",
    "    correct_tess = 0\n",
    "    corrects = 0\n",
    "    n_readable = 0\n",
    "    readables = []\n",
    "    cor_samples = []\n",
    "    for idx in tqdm(range(len(generated))):\n",
    "        cor = False\n",
    "        readable = False\n",
    "        pro = generated[idx][0]\n",
    "        t: str = generated[idx][1]\n",
    "        t = t.replace('g', 'q')\n",
    "        g = generated[idx][2]\n",
    "        img: TGraph = g[pro._num_text_patches[0]-1:g._num_text_patches[0]-1]\n",
    "        text = img.ocr(method='paddleocr', square=False, span=True, span_ratio=1.3, scale=3)\n",
    "        raw = text[0].lower().split()\n",
    "        if len(raw) == 0:\n",
    "            raw = ''\n",
    "        else:\n",
    "            raw = raw[0]\n",
    "        m = pat.match(text[0])\n",
    "        if m is not None:\n",
    "            text = m.groups()[0]\n",
    "        else:\n",
    "            text = ''\n",
    "        if raw in vocab:\n",
    "            readable = True\n",
    "        text = text.replace('g', 'q')\n",
    "        if text == t:\n",
    "            correct_paddle += 1\n",
    "            cor = True\n",
    "        text = img.ocr(method='tesseract', square=False, span=True, span_ratio=1.3, scale=3)\n",
    "        raw = text[0].lower().split()\n",
    "        if len(raw) == 0:\n",
    "            raw = ''\n",
    "        else:\n",
    "            raw = raw[0]  \n",
    "        m = pat.match(text[0])\n",
    "        if m is not None:\n",
    "            text = m.groups()[0]\n",
    "        else:\n",
    "            text = ''\n",
    "        if raw in vocab:\n",
    "            readable = True\n",
    "        text = text.replace('g', 'q')\n",
    "        if text == t:\n",
    "            correct_tess += 1\n",
    "            cor = True\n",
    "        if cor:\n",
    "            corrects += 1\n",
    "            cor_samples.append(idx)\n",
    "        if readable:\n",
    "            n_readable += 1\n",
    "            readables.append(idx)\n",
    "    return {\n",
    "        'paddleocr': correct_paddle / len(generated),\n",
    "        'tesseract': correct_tess / len(generated),\n",
    "        'union': corrects / len(generated),\n",
    "        'readability': n_readable / len(generated),\n",
    "        'readables': readables,\n",
    "        'correct_samples': cor_samples\n",
    "    }\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Init model and render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coder path is none, do not load compressor for this model\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of LlamaForPatchCausalInference were not initialized from the model checkpoint at storage/llama_2_backbone/ and are newly initialized: ['embed_tokens.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Yintao's devbox environment\n",
    "'''\n",
    "_ =TGraph.init_render(\n",
    "    dpi=80,\n",
    "    font_file=BIN_FONT,\n",
    "    font_size=8,\n",
    "    pixels_per_patch=8,\n",
    "    rgb=False,\n",
    "    binary=True,\n",
    "    max_seq_length=800,\n",
    "    patch_len=2\n",
    ")\n",
    "model = LatentLlama(\n",
    "    backbone_path='storage/llama_2_backbone/',\n",
    "    num_channels=1,\n",
    "    patch_len=2,\n",
    "    patch_size=8,\n",
    "    binary=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coder path is none, do not load compressor for this model\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of LlamaForPatchCausalInference were not initialized from the model checkpoint at storage/checkpoints/1MModels/dllama_2_b/backbone and are newly initialized: ['embed_tokens.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
     ]
    }
   ],
   "source": [
    "model = LatentLlama(\n",
    "    backbone_path='storage/checkpoints/1MModels/dllama_2_b/backbone',\n",
    "    num_channels=1,\n",
    "    patch_len=2,\n",
    "    patch_size=8,\n",
    "    binary=True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the pretraining dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = load_from_disk('storage/booksAndWiki2/data/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "samples = []\n",
    "for i in range(500):\n",
    "    prompt, _, target = randomSplit(data[i]['text'])\n",
    "    samples.append((prompt, target))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('While the variance at FVIII:C = 0.09 IU/ml is similar between both methods (CV = 7-8%), better precision is found at FVIII:C = 0.01 IU/ml in the investigated method (CV = 5-8% versus 14% in the reference method). At higher concentrations of the other clotting factors, firm clots are formed within uniform clotting times; given the higher response of the calibration curve, uniformity is further enhanced upon converting APTTs to FVIII:Cs. The method comparison reveals that compositional similarity between calibrators and low FVIII:C samples is crucial at lower dilutions, hence falsely elevated FVIII:Cs are found when using calibration standards',\n",
       " 'based')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "samples[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate vocabulary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "corpo = pd.read_csv('storage/unigram_freq.csv')\n",
    "vocab = set()\n",
    "add_word(corpo.word.tolist()[:10000], vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(vocab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run model to generate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 500/500 [00:21<00:00, 23.56it/s]\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "model.cuda()\n",
    "generated = []\n",
    "with torch.no_grad():\n",
    "    for prompt, target in tqdm(samples):\n",
    "        prompt = TGraph.from_text([prompt])\n",
    "        prompt = prompt._spacing_text(3)\n",
    "        prompt.set_device('cuda')\n",
    "        gen = model.autoregressive_generate(prompt, None, 4, binary_method='gray_scale', temperature=1.0)\n",
    "        prompt.set_device('cpu')\n",
    "        gen.set_device('cpu')\n",
    "        generated.append((prompt, target, gen))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 500/500 [00:19<00:00, 25.52it/s]\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "model.cuda()\n",
    "generated2 = []\n",
    "with torch.no_grad():\n",
    "    for prompt, target in tqdm(samples):\n",
    "        prompt = TGraph.from_text([prompt])\n",
    "        prompt = prompt._spacing_text(3)\n",
    "        prompt.set_device('cuda')\n",
    "        gen = model.autoregressive_generate(prompt, None, 4, binary_method='gray_scale', temperature=0.1)\n",
    "        prompt.set_device('cpu')\n",
    "        gen.set_device('cpu')\n",
    "        generated2.append((prompt, target, gen))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 500/500 [00:19<00:00, 25.34it/s]\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "model.cuda()\n",
    "generated1 = []\n",
    "with torch.no_grad():\n",
    "    for prompt, target in tqdm(samples):\n",
    "        prompt = TGraph.from_text([prompt])\n",
    "        prompt = prompt._spacing_text(3)\n",
    "        prompt.set_device('cuda')\n",
    "        gen = model.autoregressive_generate(prompt, None, 4, binary_method='gray_scale', temperature=0.3)\n",
    "        prompt.set_device('cpu')\n",
    "        gen.set_device('cpu')\n",
    "        generated1.append((prompt, target, gen))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 500/500 [00:19<00:00, 25.42it/s]\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "model.cuda()\n",
    "generated3 = []\n",
    "with torch.no_grad():\n",
    "    for prompt, target in tqdm(samples):\n",
    "        prompt = TGraph.from_text([prompt])\n",
    "        prompt = prompt._spacing_text(3)\n",
    "        prompt.set_device('cuda')\n",
    "        gen = model.autoregressive_generate(prompt, None, 4, binary_method='gray_scale', temperature=10.0)\n",
    "        prompt.set_device('cpu')\n",
    "        gen.set_device('cpu')\n",
    "        generated3.append((prompt, target, gen))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save Image Samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx, (p, t, g) in enumerate(generated):\n",
    "    p: TGraph\n",
    "    g: TGraph\n",
    "    folder = f'pretrain_samples/{idx}_target_{t}'\n",
    "    p.to_file(f'{folder}/prompt')\n",
    "    g.to_file(f'{folder}/gen_thresholding_0_5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx, (p, t, g) in enumerate(generated):\n",
    "    p: TGraph\n",
    "    g: TGraph\n",
    "    folder = f'pretrain_samples/{idx}_target_{t}'\n",
    "    g.to_file(f'{folder}/gen_gray_temp_1_0', binary_method='gray_scale')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx, (p, t, g) in enumerate(generated1):\n",
    "    p: TGraph\n",
    "    g: TGraph\n",
    "    folder = f'pretrain_samples/{idx}_target_{t}'\n",
    "    g.to_file(f'{folder}/gen_gray_temp_0_3', binary_method='gray_scale')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx, (p, t, g) in enumerate(generated2):\n",
    "    p: TGraph\n",
    "    g: TGraph\n",
    "    folder = f'pretrain_samples/{idx}_target_{t}'\n",
    "    g.to_file(f'{folder}/gen_gray_temp_0_1', binary_method='gray_scale')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx, (p, t, g) in enumerate(generated3):\n",
    "    p: TGraph\n",
    "    g: TGraph\n",
    "    folder = f'pretrain_samples/{idx}_target_{t}'\n",
    "    g.to_file(f'{folder}/gen_gray_temp_10_0', binary_method='gray_scale')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot the statistics of generated patches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "dists = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = []\n",
    "for p, t, g in generated:\n",
    "    patch = g[p._num_text_patches[0]-1:p._num_text_patches[0]]\n",
    "    patch: TGraph\n",
    "    values.append(patch._value.flatten())\n",
    "values = torch.concat(values).flatten().numpy()\n",
    "dists['temp=1.0'] = values\n",
    "\n",
    "values = []\n",
    "for p, t, g in generated1:\n",
    "    patch = g[p._num_text_patches[0]-1:p._num_text_patches[0]]\n",
    "    patch: TGraph\n",
    "    values.append(patch._value.flatten())\n",
    "values = torch.concat(values).flatten().numpy()\n",
    "dists['temp=0.3'] = values\n",
    "\n",
    "\n",
    "values = []\n",
    "for p, t, g in generated2:\n",
    "    patch = g[p._num_text_patches[0]-1:p._num_text_patches[0]]\n",
    "    patch: TGraph\n",
    "    values.append(patch._value.flatten())\n",
    "values = torch.concat(values).flatten().numpy()\n",
    "dists['temp=0.1'] = values\n",
    "\n",
    "\n",
    "values = []\n",
    "for p, t, g in generated3:\n",
    "    patch = g[p._num_text_patches[0]-1:p._num_text_patches[0]]\n",
    "    patch: TGraph\n",
    "    values.append(patch._value.flatten())\n",
    "values = torch.concat(values).flatten().numpy()\n",
    "dists['temp=10.0'] = values\n",
    "\n",
    "values = []\n",
    "for p, t, g in generated:\n",
    "    patch = g[p._num_text_patches[0]-1:p._num_text_patches[0]]\n",
    "    patch.binary()\n",
    "    patch: TGraph\n",
    "    values.append(patch._value.flatten())\n",
    "values = torch.concat(values).flatten().numpy()\n",
    "dists['binary th=0.5'] = values\n",
    "\n",
    "values = []\n",
    "for p, t, g in generated3:\n",
    "    patch = p[10:11]\n",
    "    patch: TGraph\n",
    "    values.append(patch._value.flatten())\n",
    "values = torch.concat(values).flatten().numpy()\n",
    "dists['gold'] = values\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64000"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnAAAAHWCAYAAAD3vrTNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABpxUlEQVR4nO3de1iUZf4/8PdwEjzAKIdUCBA59E0JyNZILUBSQdnS1DDdxFxJ045uFpqt2moeNit/armFB9hSMfIMIa2CGphWagalgGChhIo6EMppmPv3BzvPOg4gg8wMD75f18VV8zz33POeJ+bTh+c0CiGEABERERHJhoW5AxARERGRYdjAEREREckMGzgiIiIimWEDR0RERCQzbOCIiIiIZIYNHBEREZHMsIEjIiIikhk2cEREREQywwaOiIiISGbYwBERERHJDBs4ahPnzp2DQqHAlClTzB2lXamvr8cHH3yABx54AHZ2dujRowdGjhyJ7Oxsg+Y5f/48lixZgvHjx8Pb2xsWFhZQKBQoKCgwUnKi9od1Rt8vv/yCBQsW4Mknn4S7uzsUCgUUCgXUanWzz7t69SpeffVVeHp6olOnTujduzemTp2K8+fPG5yhqqoKCxYsgJ+fH2xtbeHi4oKnn34av/zyS2vfFrUAGzgiIxFCYMKECZg9ezZqa2vx4osvYsyYMTh06BAee+wx7Nq1q8Vzff/995g/fz6+/PJLCCHg4OBgxOREJBf79u3DO++8g5SUFHTp0gW2tra3fc6VK1fwyCOPYNWqVejbty9ee+01DBw4EBs3bsSAAQNQWFjY4tevqanBsGHD8M4778De3h6vvPIKHn/8cezYsQMPPfQQjh49eidvj5ojiNpAUVGRACBiYmLMHaXd2Lx5swAgBg0aJKqqqqTlx44dEzY2NsLZ2VlUVFS0aK7i4mJx6NAhUV5eLoQQIiQkRAAQ+fn5RslO1B6xzug7ffq0+Pbbb8WNGzeEEEJ4eHgIAKKurq7J5zz//PMCgJg9e7bO8lWrVgkAYsSIES1+/XfffVcAEOPGjRP19fXS8p07dwoA4v7779dZTm2HDRzdsQULFggAjf5s3LhRGpeWliYiIyOFo6OjsLGxEV5eXuL1118X165d05vTw8NDeHh4iD/++EO8+uqrws3NTdja2oqAgACxY8cOIYQQdXV1YvHixcLb21t06tRJeHl5idWrV+vNlZGRIQCIBQsWiOzsbBEeHi7s7e1F165dxfDhw8V3331nlO3y6KOPCgDiwIEDeuueffZZAUBs2LChVXOzgaO7DetMy9yugfvjjz+EnZ2d6NKli94fkPX19dLzz549e9vX0mg0wt3dXQAQhYWFeuubq4F053gIle5YaGgoXnnlFQBAQEAAFixYIP0EBgYCABYtWoSIiAgcPXoUo0aNwssvvwxvb2+89957GDx4MCoqKvTmraurw7Bhw5Camoonn3wSzz77LM6ePYuxY8di//79iI6Oxscff4zQ0FBMmzYNlZWVeOmll5CUlNRozqNHjyI0NBSdOnXCrFmzEBkZif379+PRRx/F4cOH23SbVFdXIzs7G507d8ajjz6qtz4yMhIAcODAgTZ9XaKOinWmbXz77beoqqrC4MGD0a1bN511FhYWGDFiBAAgIyPjtnOdPXsWv/32G3x9fdGnTx+99axzxmVl7gAkf6GhofD09MSqVasQGBiIhQsX6qzPyMjAwoUL8cgjjyA1NRVKpVJat2nTJjz33HNYsGABPvjgA53nlZSU4MEHH0RmZiY6deoEAHj22Wfx2GOPYfz48ejbty9ycnKk+WbPno377rsPy5YtQ3R0tF7OtLQ0rF69Gi+++KK0bNeuXRg9ejSmTp2KM2fOwMKi4W+ac+fOYdOmTQZthylTpsDT0xNAQ2Grr6+Hl5cXrKz0P2Y+Pj4AgLy8PINeg+huxTrT4OY60xpnzpwBAPj6+ja63pDa1JZzUSuYexcgdQzNnZsyevRoAUDk5OQ0+tzAwEDh7Oyss0y7G7+goEBvfJ8+fQQAsX//fr11oaGhwsrKSqjVammZ9tCGt7d3o+diaA9HZmZm6j3HkJ+MjAzp+VlZWQKAGDx4cKPvOS8vTwAQvr6+ja6/HR5CpbsR64xunWnM7Q6hLlmyRAAQb731VqPrP/nkEwFAPP/8882+jhBCfP755wKAmDRpUqPr09PTBQAxfPjw285FhuMeODK6I0eOwNraGl988QW++OILvfW1tbW4fPkyrly5AkdHR2m5UqlE37599cb37t0bRUVFGDBggN46V1dXqNVqlJaWwtXVVWfdo48+Kv3le7PQ0FAcPHgQJ06cQEhIiLRMCGHweyUi82CdobsNGzgyuitXrkCtVmPRokXNjqusrNQprE3dKkN7SLKx9dp1dXV1euvuueeeRufr2bMnAKC8vLzZfIbQZmtqTu3ymw/zEFHr3Y11pjXasjaxzpkXGzgyOgcHB2g0Gly9etWsOS5evNjo8tLSUgC6hfpOz03p27cvLC0tUVhYCLVarXceXH5+PoCmzx0hIsPcjXWmNfz8/AA0fV6aIbWpLeciw7GBozZhaWkJoOGbB24VHByMlJQU5Obmol+/fqaOJvnmm2+g0Wj0Dm9kZmYCAIKCgqRl586du+1f8rfSnmQNALa2thg0aBAOHz6Mw4cPIywsTGfsV199BQAYOnSoge+C6O7FOqNbZ1ojODgYdnZ2yMrKwh9//KFzJapGo0F6ejoA6NWsxvTt2xfu7u7Iy8tDUVGR3pWorHPGxduIUJvo3r07FAoFfvvtN711r732GgAgNjYWJSUleuuvX7+Ob7/91ugZ8/Pz8dFHH+ks27VrFw4ePAhvb2+d231oz00x5Cc0NFRn7hdeeAEAMH/+fFRXV0vLv/vuOyQlJcHZ2Rljx47Vec7vv/+O06dPm/0wC1F7xDqjX2cM1bVrVzz77LO4fv263pW8a9aswblz5zBixAh4eXnprDt79ixOnz6tc9hYoVBgxowZAIA33ngDGo1G5z0fPnwY999/v3TOH7Ut7oGjNtG1a1c8/PDDOHz4MCZNmgRfX19YWlriiSeeQHh4OJYtW4a5c+fCx8cHI0eORJ8+fVBZWYlff/0VBw8exJAhQ5CWlmbUjBEREfjb3/6Gr776CgEBASgoKMD27dtha2uLDRs2NHri8Z2YMGECtm/fjuTkZAQFBeHPf/4zrly5gqSkJNTX1+PTTz+Fvb29znPmzp2LhIQEbNy4Ue/7Hm9+fPr0aQDAm2++Kf0FPW3aNAwZMqRN3wNRe8I6o6+srAyvv/66zmMA+Otf/wqFQgEAiIuLw3333SeNeffdd5GZmYn3338fJ0+exMCBA/HLL79g165dcHFxwdq1a/VeJzw8HL/++iuKiop09gDOnj0be/fuRXJyMh5++GGEh4fjt99+wxdffIHOnTsb5T3Tf5nqclfq+PLz80VUVJTo0aOHUCgUendIP3z4sBg/frzo1auXsLa2Fk5OTiIgIEC89tprencp194hvTHay/EbExMTIwCIoqIiaVljd0jv1q2b6Nq1qxg2bJg4duzYnb71JtXV1Yn3339f9O/fX9ja2gqlUikiIyNFVlZWs/lv3m5auM3tBRp7DlFHwzqjS3trleZ+Grv1yJUrV8TLL78s3N3dhbW1tejZs6d47rnnRHFxcaOvo709yc3vWev69evi7bffFt7e3sLGxkY4OTmJcePGidzc3DZ+t3QzhRC8hpk6tszMTISFhWHBggV6hwyIiNoC6wyZGvdrEhEREckMGzgiIiIimWEDR0RERCQzPAeOiIiISGa4B46IiIhIZtjAEREREckMGzgiIiIimWEDR0RERCQzd/1XaV27dg1qtbpFY52dnXH58mUjJzIe5jcv5jcfQ7JbWVmhe/fuRk70P43VIDlva1PjtjIMt1fLmWtbtbQG3fUNnFqt1vly3qZov1NOrVZDjhfuMr95Mb/5tPfst9ag9p63PeG2Mgy3V8vJYVvxECoRERGRzLCBIyIiIpIZNnBEREREMsMGjoiIiEhm2MARERERyQwbOCIiIiKZuetvI0JE7UN97BPGmzzle+PNTURkBtwDR0RERCQzbOCIiIiIZIYNHBEREZHMsIEjIiIikhk2cEREREQywwaOiIiISGbu6DYiO3fuxObNmzFy5EhMmTIFAFBbW4vExERkZ2ejrq4OAQEBmDZtGpRKpfS8srIyfPrpp8jNzYWtrS1CQkIwceJEWFpaSmNyc3ORmJiI4uJiODo6YuzYsQgNDdV5/bS0NOzZswcqlQoeHh6YOnUqvL297+QtEREREbV7rd4DV1BQgK+//hoeHh46yxMSEvDDDz9g9uzZWLRoEa5du4aVK1dK6zUaDZYuXQq1Wo3Fixdj1qxZyMzMRFJSkjTm0qVLWLZsGfr164cVK1Zg1KhRWLduHU6ePCmNyc7ORmJiIsaNG4fly5fDw8MDS5YsQXl5eWvfEhEREZEstKqBq66uxurVqzF9+nR06dJFWn7jxg0cOHAAMTEx6N+/P7y8vDBz5kycOXMGeXl5AIAff/wR58+fx0svvQRPT08EBQUhOjoa+/btg1qtBgCkp6fDxcUFkydPhpubGyIiIhAcHIyUlBTptfbu3Yvw8HCEhYXBzc0NsbGxsLGxQUZGxp1sDyIiIqJ2r1UNXHx8PIKCgvDAAw/oLC8sLER9fT38/f2lZa6urnBycpIauLy8PLi7u+scUg0MDERVVRWKi4sBAPn5+TpzAEBAQIA0h1qtRmFhoc4YCwsL+Pv7S2OIiIiIOiqDz4HLyspCUVERli5dqrdOpVLByspKZ68cADg4OEClUkljbm7etOu167T/1C67eUxVVRVqa2tRWVkJjUajN49SqURJSUmjuevq6lBXVyc9VigUsLOzk/79drRjWjK2PWJ+82J+8zN39pbWoI6wrU2F28ow3F4tJ4dtZVADV1ZWhk2bNmH+/PmwsbExViaj2LFjB5KTk6XHffr0wfLly+Hs7GzQPD179mzraCbF/ObF/E0rNtrMDcy97Q2tQebOKyfcVobh9mq59rytDGrgCgsLUV5ejjfffFNaptFo8MsvvyAtLQ1vvfUW1Go1rl+/rrMXrry8XNpbplQqUVBQoDOv9sKDm8fcejFCeXk57OzsYGNjA3t7e1hYWEh77LQa27unNWbMGERFRUmPtV315cuXpXPvmqNQKNCzZ0+UlpZCCHHb8e0N85sX85tfS7NbWVkZ/IddS7S0BnWEbW0q3FaG4fZqOXNuq5bWIIMaOH9/f7z33ns6yz7++GP07t0bTz75JJycnGBpaYmffvoJwcHBAICSkhKUlZXB19cXAODr64vt27ejvLxcOkx66tQp2NnZwc3NDQDg4+ODEydO6LzOqVOnpDmsrKzg5eWFnJwcDBw4EEBDI5mTk4OIiIhGs1tbW8Pa2rrRdYb8xxFCyPoXn/nNi/nNx9zZDa1B5s4rJ9xWhuH2arn2vK0MauDs7Ozg7u6us6xTp07o1q2btHzo0KFITExE165d0blzZ2zYsAG+vr5S8xUQEAA3NzesWbMGkyZNgkqlwtatWzFixAipuA0fPhz79u3DZ599hrCwMOTk5ODIkSOIi4uTXjcqKgpr166Fl5cXvL29kZqaipqaGr17xRERERF1NHd0I9/GxMTEQKFQYOXKlVCr1dKNfLUsLCwQFxeH+Ph4zJ8/H506dUJISAiio6OlMS4uLoiLi0NCQgJSU1Ph6OiIGTNmIDAwUBozaNAgVFRUYNu2bVCpVPD09MS8efOaPIRKRERE1FEoRHvdN2gily9f1rkyrCkKhQK9evXC77//3m53pzaH+c2L+W+vPvYJo8wLAPemfN/i7NbW1kY5B64pt9Yguf+umBK3lWG4vVrOnNuqpTWI34VKREREJDNs4IiIiIhkhg0cERERkcywgSMiIiKSGTZwRERERDLDBo6IiIhIZtjAEREREckMGzgiIiIimWEDR0RERCQzbOCIiIiIZIYNHBEREZHMsIEjIiIikhk2cEREREQywwaOiIiISGbYwBERERHJDBs4IiIiIplhA0dEREQkM2zgiIiIiGSGDRwRERGRzLCBIyIiIpIZNnBEREREMsMGjoiIiEhm2MARERERyQwbOCIiIiKZYQNHREREJDNWhgzesWMHjh07hgsXLsDGxga+vr74y1/+gt69e0tjamtrkZiYiOzsbNTV1SEgIADTpk2DUqmUxpSVleHTTz9Fbm4ubG1tERISgokTJ8LS0lIak5ubi8TERBQXF8PR0RFjx45FaGioTp60tDTs2bMHKpUKHh4emDp1Kry9vVu3JYiIiIhkwqAG7ueff8aIESPQt29f1NfXY8uWLVi8eDHef/992NraAgASEhJw/PhxzJ49G507d8b69euxcuVK/OMf/wAAaDQaLF26FEqlEosXL8a1a9ewZs0aWFpaYuLEiQCAS5cuYdmyZRg2bBheeukl5OTkYN26dVAqlQgMDAQAZGdnIzExEbGxsfDx8UFKSgqWLFmCDz/8EA4ODm24iYiIiID62CeMNrflp7uNNjd1TAYdQn3rrbcQGhqKe++9F56enpg1axbKyspQWFgIALhx4wYOHDiAmJgY9O/fH15eXpg5cybOnDmDvLw8AMCPP/6I8+fP46WXXoKnpyeCgoIQHR2Nffv2Qa1WAwDS09Ph4uKCyZMnw83NDREREQgODkZKSoqUZe/evQgPD0dYWBjc3NwQGxsLGxsbZGRktNW2ISIiImqX7ugcuBs3bgAAunbtCgAoLCxEfX09/P39pTGurq5wcnKSGri8vDy4u7vrHFINDAxEVVUViouLAQD5+fk6cwBAQECANIdarUZhYaHOGAsLC/j7+0tjiIiIiDoqgw6h3kyj0WDTpk3w8/ODu7s7AEClUsHKygpdunTRGevg4ACVSiWNubl5067XrtP+89bDoA4ODqiqqkJtbS0qKyuh0Wj05lEqlSgpKWk0b11dHerq6qTHCoUCdnZ20r/fjnZMS8a2R8xvXsxvfubO3tIa1BG2tal0pG1livfQkbaXsclhW7W6gVu/fj2Ki4vxzjvvtGUeo9mxYweSk5Olx3369MHy5cvh7Oxs0Dw9e/Zs62gmxfzmxfxNKzbazA3Mve0NrUHmzisnptpWxvwd7dWrlxFn18XfrZZrz9uqVQ3c+vXrcfz4cSxatAiOjo7ScqVSCbVajevXr+vshSsvL5f2limVShQUFOjMV15eLq3T/lO77OYxdnZ2sLGxgb29PSwsLKQ9dlqN7d3TGjNmDKKioqTH2q768uXL0rl3zVEoFOjZsydKS0shhLjt+PaG+c2L+c2vpdmtrKwM/sOuJVpagzrCtjaVjrStfv/9d6O/RkfaXsZmzm3V0hpkUAMnhMCGDRtw7NgxLFy4EC4uLjrrvby8YGlpiZ9++gnBwcEAgJKSEpSVlcHX1xcA4Ovri+3bt6O8vFw6THrq1CnY2dnBzc0NAODj44MTJ07ozH3q1ClpDisrK3h5eSEnJwcDBw4E0HBINycnBxEREY1mt7a2hrW1dZPvy5BtIOdffOY3L+Y3H3NnN7QGmTuvnHSEbWXK/B1he5lKe95WBjVw69evxzfffIM33ngDdnZ20h6wzp07w8bGBp07d8bQoUORmJiIrl27onPnztiwYQN8fX2l5isgIABubm5Ys2YNJk2aBJVKha1bt2LEiBFScRs+fDj27duHzz77DGFhYcjJycGRI0cQFxcnZYmKisLatWvh5eUFb29vpKamoqamRu9ecURERO2dMW9RAvA2JR2RQQ1ceno6AGDhwoU6y2fOnCk1TjExMVAoFFi5ciXUarV0I18tCwsLxMXFIT4+HvPnz0enTp0QEhKC6OhoaYyLiwvi4uKQkJCA1NRUODo6YsaMGdI94ABg0KBBqKiowLZt26BSqeDp6Yl58+Y1eQiViIiIqKMwqIHbtm3bbcfY2Nhg2rRpOk3brZydnTF37txm5+nXrx9WrFjR7JiIiIgmD5kSERERdVT8LlQiIiIimWEDR0RERCQzbOCIiIiIZIYNHBEREZHMsIEjIiIikhk2cEREREQy0+rvQr0bFY96yKjz80aLRERE1BLcA0dEREQkM2zgiIiIiGSGDRwRERGRzLCBIyIiIpIZNnBEREREMsMGjoiIiEhm2MARERERyQzvA0dERNTB1cc+AQAoNtL8vI+p6XEPHBEREZHMsIEjIiIikhk2cEREREQywwaOiIiISGbYwBERERHJDBs4IiIiIplhA0dEREQkM7wPHBERdQjae52R6Rl72/M+c/rYwBEREVG7xgZRHw+hEhEREckMGzgiIiIimZH9IdS0tDTs2bMHKpUKHh4emDp1Kry9vc0di4iIiMhoZL0HLjs7G4mJiRg3bhyWL18ODw8PLFmyBOXl5eaORkRERGQ0sm7g9u7di/DwcISFhcHNzQ2xsbGwsbFBRkaGuaMRERERGY1sD6Gq1WoUFhZi9OjR0jILCwv4+/sjLy9Pb3xdXR3q6uqkxwqFAnZ2drCyatkmUCgUUPT1u+PczVo2x6jTlwJQ/PdHlv7f57C2toYQwtxJDKZQKFD68iRZb39j//5YGPnz1dLfnZbWBEO1tAYpFA1b2By/6/X/eNWkr9cWbv69NPbvEHVcltbWOo/N+TlsaQ2SbQNXUVEBjUYDpVKps1ypVKKkpERv/I4dO5CcnCw9Hjx4MF555RV079695S/6/z5vbVxqI05OTuaO0Hr8/TErc//uGFqDzJKXv6NEOsxdN5oj60OohhgzZgw2bdok/cTGxur8NXw7VVVVePPNN1FVVWXElMbD/ObF/ObTXrK3tAa1l7xywG1lGG6vlpPDtpLtHjh7e3tYWFhApVLpLFepVHp75YCG3aDWt+wiNYQQAkVFRbI8fAcwv7kxv/m0l+wtrUHtJa8ccFsZhtur5eSwrWS7B87KygpeXl7IycmRlmk0GuTk5MDX19eMyYiIiIiMS7Z74AAgKioKa9euhZeXF7y9vZGamoqamhqEhoaaOxoRERGR0ci6gRs0aBAqKiqwbds2qFQqeHp6Yt68eY0eQr1T1tbWGDdu3B0dhjUn5jcv5jcfuWWXW15z4rYyDLdXy8lhWylEez7AS0RERER6ZHsOHBEREdHdig0cERERkcywgSMiIiKSGTZwRERERDIj66tQ21paWhr27NkDlUoFDw8PTJ06Fd7e3k2OP3LkCJKSknD58mX07NkTkyZNwoMPPmjCxLoMyf+f//wHhw4dQnFxMQDAy8sLzzzzTLPv19gM3f5aWVlZWLVqFR566CG88cYbJkjaOEPzX79+HVu2bMGxY8dQWVkJZ2dnxMTEmOV3yNDsKSkpSE9PR1lZGezt7fHwww9j4sSJsLGxMWHqBj///DN2796NoqIiXLt2Da+//joGDhzY7HNyc3ORmJiI4uJiODo6YuzYsSa9/ZDcP6umJPe6YGpyrkOmJue6B3APnCQ7OxuJiYkYN24cli9fDg8PDyxZsgTl5eWNjj9z5gxWrVqFoUOHYvny5fjTn/6Ef/7zn/jtt99MnLyBofl//vlnDB48GAsWLMDixYvh6OiIxYsX4+rVqyZO3sDQ/FqXLl3Cv//9b/zf//2fiZI2ztD8arUaixcvxuXLlzF79mx8+OGHmD59Onr06GHi5IZn/+abb7B582aMHz8eH3zwAWbMmIEjR45gy5YtJk7eoKamBp6envjrX//aovGXLl3CsmXL0K9fP6xYsQKjRo3CunXrcPLkSeMG/S+5f1ZNSe51wdTkXIdMTe51D2ADJ9m7dy/Cw8MRFhYGNzc3xMbGwsbGBhkZGY2OT01NRWBgIJ544gm4ublhwoQJ8PLyQlpamomTNzA0/8svv4wRI0bA09MTrq6umDFjBoQQ+Omnn0ycvIGh+YGGb95YvXo1nn76abi4uJgwrT5D8x84cACVlZWYM2cO7rvvPri4uOD++++Hp6enaYPD8OxnzpyBn58fhgwZAhcXFwQEBGDw4MEoKCgwcfIGQUFBmDBhwm33ummlp6fDxcUFkydPhpubGyIiIhAcHIyUlBQjJ20g98+qKcm9LpianOuQqcm97gFs4AA0/BVSWFgIf39/aZmFhQX8/f2Rl5fX6HPy8vJ0xgNAQEAA8vPzjZq1Ma3Jf6uamhqo1Wp07drVWDGb1Nr8ycnJsLe3x9ChQ00Rs0mtyf/DDz/Ax8cH69evR2xsLP72t79h+/bt0Gg0pooNoHXZ/fz8UFhYKBWuixcv4sSJEwgKCjJJ5juVn5/f6Ge3pZ+VOyH3z6opyb0umJqc65CpdZS6x3PgAFRUVECj0eh9g4NSqURJSUmjz1GpVHBwcNBZ5uDgAJVKZaSUTWtN/lt9/vnn6NGjh97/2EyhNflPnz6NAwcOYMWKFSZI2LzW5L948SIuX76MIUOGYO7cuSgtLUV8fDzq6+sxfvx4E6Ru0JrsQ4YMQUVFBd5++20AQH19PYYNG4annnrK2HHbRFOf3aqqKtTW1hr1fBa5f1ZNSe51wdTkXIdMraPUPTZwhJ07dyIrKwsLFy4028mYhqiqqsLq1asxffp02NvbmztOqwghYG9vj+nTp8PCwgJeXl64evUqdu/e3e4LZ25uLnbs2IFp06bBx8cHpaWl2LhxI5KTkzFu3Dhzx+vQ5PZZNaWOUBdMTc51yNTaY91jAwfA3t4eFhYWenvPVCpVk9+rqlQq9U52LC8vN8r3sN5Oa/Jr7d69Gzt37sTbb78NDw8P44VshqH5tX81Ll++XFqm/Ua4CRMm4MMPP0TPnj2NGVlHa39/rKysYGHxv7MYXF1doVKpoFarYWVlmo9ma7InJSXhscceQ3h4OADA3d0d1dXV+OSTT/DUU0/pvKf2qKnPrp2dndGbIrl/Vk1J7nXB1ORch0yto9S99l1pTcTKygpeXl7IycmRlmk0GuTk5MDX17fR5/j6+uqdRHzq1Cn4+PgYNWtjWpMfAHbt2oUvv/wS8+bNQ9++fU0RtVGG5u/duzfee+89rFixQvoZMGCAdFWhk5OTKeO3avv7+fmhtLRU51yT33//Hd27dzdp0WxN9pqaGigUCp1l7b1pu5mPj0+jn93mPittRe6fVVOSe10wNTnXIVPrKHVPPlXXyKKiorB//35kZmbi/PnziI+PR01NjXRvqDVr1mDz5s3S+JEjR+LHH3/Enj17cOHCBWzbtg1nz55FRESELPLv3LkTSUlJeOGFF+Di4gKVSgWVSoXq6up2n9/Gxgbu7u46P126dIGtrS3c3d3NUngM3f7Dhw9HZWUlNm3ahJKSEhw/fhw7duzAiBEj2n32AQMG4Ouvv0ZWVhYuXbqEU6dOISkpCQMGDDBLQauursa5c+dw7tw5AA23kDh37hzKysoAAJs3b8aaNWuk8cOHD8elS5fw2Wef4cKFC9i3bx+OHDmCUaNGmSSv3D+rpiT3umBqcq5Dpib3ugfwEKpk0KBBqKiowLZt26BSqeDp6Yl58+ZJu1PLysp0um8/Pz+8/PLL2Lp1K7Zs2YJevXphzpw5cHd3l0X+r7/+Gmq1Gu+//77OPOPGjcPTTz9tyugADM/f3hia38nJCW+99RYSEhIwZ84c9OjRA5GRkRg9enS7zz527FgoFAps3boVV69ehb29PQYMGIBnnnnG5NkB4OzZs1i0aJH0ODExEQAQEhKCWbNm4dq1a1IzBwAuLi6Ii4tDQkICUlNT4ejoiBkzZiAwMNAkeeX+WTUludcFU5NzHTI1udc9AFAI7UkCRERERCQLPIRKREREJDNs4IiIiIhkhg0cERERkcywgSMiIiKSGTZwRERERDLDBo6IiIhIZtjAEREREckMGzgiIiIimWEDR0RERCQzbOCIiIiIZIYNHBEREZHMsIEjIiIikhk2cEREREQywwaOiIiISGbYwBERERHJDBs4IiIiIplhA0dEREQkM2zgiIjI5M6dOweFQoEpU6a0+DmbNm2CQqHApk2bjJarvcvMzIRCocDChQvNHYXMjA0ctYnWFOO7QX19PT744AM88MADsLOzQ48ePTBy5EhkZ2cbNM+hQ4fw7LPPon///nB0dIStrS369OmDJ554Avv37zdSeiIytfZcS9uqnmkb8aZ+1q1bZ6R30LFYmTsAUUclhMCECROQnJwMPz8/vPjii7h69SqSkpLw2GOP4csvv8STTz7ZorkOHDiAAwcO4OGHH8bQoUPRpUsX/Pbbb9i9ezf27NmD+fPn4x//+IeR3xGReY0ZMwbBwcHo1auXuaPcddqynmk9+eSTCAwM1Fv+0EMPtVHqjo0NHJGRbN26FcnJyRg0aBD2798PW1tbAMCMGTMwZMgQxMbGYujQoejWrdtt54qLi2v0kMmFCxfw4IMP4t1338XMmTP5Pzbq0BwcHODg4GDuGHeltqxnWqNHj26XexrlgodQ6Y4tXLgQffr0AQAkJCTo7Aq/+VyVffv2YeTIkXByckKnTp3Qt29fzJkzByqVSm9OT09PeHp6orKyEq+99hruvfde2NnZITAwEDt37gQAqNVqLFmyBD4+PrC1tUXfvn2xZs0avbluPmfkyJEjePzxx+Hg4IBu3bphxIgR+P77742xWfDxxx8DABYvXiwVOwD405/+hOjoaFy+fBnJycktmuvm59/M1dUVgwYNgkajQWFh4Z2HJjKD06dPY/To0ejRowe6dOmCIUOGID09XW9cU+fAaevF9evXMWfOHLi7u6NTp07w9vbG8uXLIYRodK6xY8fCy8sLdnZ2sLe3x+DBg/HZZ581mjE0NBQKhQK1tbV455134Ofnh06dOmHKlCn417/+BYVCgUWLFjX63NLSUlhbW8Pf37/Z7dDSWqp18uRJjBo1CkqlEp07d0ZISIjBhzNbqi3rGbUN7oGjOxYaGgqVSoVVq1YhICAAo0ePltZpd48vWrQICxcuRI8ePRAVFQUXFxecOnUK7733HlJTU3HkyBHY29vrzFtXV4dhw4bh6tWrePLJJ1FbW4stW7Zg7NixSE9Px0cffYSjR48iMjISnTp1whdffIGXXnoJzs7OiI6O1st59OhRLF26FI8//jhmzZqFgoICbN++HYcOHUJ6ejoeffTRNtsm1dXVyM7ORufOnRudNzIyEv/+979x4MABPPfcc61+nUuXLuHo0aPo1KkT/Pz87iQykVkUFRXhkUcegb+/P6ZPn47ff/8dSUlJiIyMxObNmxv9LDemrq4OI0aMQElJCSIjI2FlZYWdO3ciLi4O1dXVWLBggc74F154Af369cNjjz2GXr164cqVK0hNTcWzzz6LM2fONHlKwtixY/Hdd98hMjISo0ePhouLCyZNmoQ33ngD69evx/z582FpaanznA0bNkCtVmP69OnNvoeW1FKt77//HitWrMAjjzyCadOm4bfffsOXX36J8PBwnDx5sk3rgbHq2cmTJ/Hhhx+iuroarq6uCAsLg5ubW5vl7ujYwNEdCw0NhaenJ1atWoXAwEC9Q30ZGRlYuHAhHnnkEaSmpkKpVErrNm3ahOeeew4LFizABx98oPO8kpISPPjgg8jMzESnTp0AAM8++ywee+wxjB8/Hn379kVOTo403+zZs3Hfffdh2bJljRb9tLQ0rF69Gi+++KK0bNeuXRg9ejSmTp2KM2fOwMKiYaf0uXPnDL7SbcqUKfD09AQAnD17FvX19fDy8oKVlf7HzMfHBwCQl5dn0Gt8//332Lt3L9RqNc6fP489e/agvLwcq1evhpOTk0FzEbUHhw4dwuuvv45//vOf0rIXX3wRjzzyCGbMmIHIyEi9P+4aU1JSgoCAAHz99dews7MDACxYsAC+vr744IMPMG/ePFhbW0vjc3Jy0LdvX505amtrERkZiWXLlmHGjBlwdXXVe51ff/0VOTk5ep+3Z599FmvXrsVXX32FqKgoabkQAvHx8ejcuTOeffbZZt/D7WrpzVJSUrBx40adQ5D/+te/MGPGDKxatQofffSRtLy91rNVq1bpPLa0tMS0adPw4YcfNnnUgW4iiNpAUVGRACBiYmL01o0ePVoAEDk5OY0+NzAwUDg7O+ss8/DwEABEQUGB3vg+ffoIAGL//v1660JDQ4WVlZVQq9XSsoyMDAFAeHt7i/r6er3nhISECAAiMzNT7zmG/GRkZEjPz8rKEgDE4MGDG33PeXl5AoDw9fVtdH1TPv74Y53X7Natm0hMTDRoDqL2QFszHBwcREVFhd76mJgYAUBs2rRJWrZx40YBQGzcuFFnrLZe5Ofn680zefJkAUD89NNPLcr15ZdfCgAiISFBZ7m2TuzcubPR5+Xk5AgAIioqSmd5WlqaACCee+65Fr1+c7VUiP/VpsZqS21trbCyshIDBgxo9DntpZ5lZmaK1atXizNnzojr16+LkpISsW3bNtG3b18BQDzzzDMtmuduxz1wZHRHjhyBtbU1vvjiC3zxxRd662tra3H58mVcuXIFjo6O0nKlUqn3FzIA9O7dG0VFRRgwYIDeOldXV6jVapSWlur99fzoo49Ke9huFhoaioMHD+LEiRMICQmRlolGzpsxtxkzZmDGjBmorq5GUVER1q1bh8mTJyMrK4uX3pMsPfjgg42e+B4aGoqEhAScOHECMTExt53HwcEB3t7eesvvvfdeAMC1a9d0lv/2229Yvnw59u/fj99++w1VVVU66y9cuNDo6wwcOLDR5drDsV999RWKi4ul1/3kk08ANHx221JjV2paW1vjnnvu0Xuv7a2ehYSESLUWADp37ozx48cjODgYAQEB2LJlC958800EBASYMWX7xwaOjO7KlStQq9VNnuCrVVlZqdPANXW1mXYXfmPrtevq6ur01t1zzz2NztezZ08AQHl5ebP5DKHN1tSc2uU3H042hK2tLf7v//4Pq1atQk1NDf71r3/h8ccfx7hx41o1H5G5tNXnsqnPkrYm1NfXS8sKCwsxcOBAXLt2DY8++iiGDx8OBwcHWFpa4ty5c0hISEBNTU2zuRozc+ZMHDp0CPHx8Vi0aBFKS0uxe/duBAYGNtn4tVZz7/fm99oWjF3PtO69916MHDkSn3/+OQ4dOsQG7jbYwJHROTg4QKPR4OrVq2bNcfHixUaXl5aWAtBtCO/0nJG+ffvC0tIShYWFUKvVeueN5OfnAwB8fX0Neo3GREZG4l//+hcyMzPZwJHsGPK5bCvvv/8+rly5oncOGQBs2bIFCQkJTT5XoVA0ue6pp57CPffcg/Xr1+Pvf/97iy9eMDY51TNnZ2cAwPXr1+94ro6ODRy1Ce1VV4395RccHIyUlBTk5uaiX79+po4m+eabb6DRaPQOo2ZmZgIAgoKCpGXnzp277R7DW2lPQAYa9pANGjQIhw8fxuHDhxEWFqYz9quvvgIADB061MB3oU97qKexk4uJ2rvjx4/jjz/+0DuM2tjnsq0UFBQAaLii9FYHDx5s9bzW1taYNm0alixZgj179iA+Ph5du3bFpEmTWjxHc7W0teRUz44ePQoA8PLyuuO5OjreB47aRPfu3aFQKPDbb7/prXvttdcAALGxsSgpKdFbf/36dXz77bdGz5ifn69zZRbQcBXqwYMH4e3trXN5vPacEUN+QkNDdeZ+4YUXAADz589HdXW1tPy7775DUlISnJ2d9f4H8vvvv+P06dN6hyqOHTvW6Hs6e/Ys3n33XQDAqFGjDNsgRO1AeXk53nnnHZ1l33//PT7//HM4ODhgzJgxbf6a2sZE2yRq7du3D/Hx8Xc09/PPPw9LS0u8+OKLKCoqwsSJEw26uW1ztbS12ls9a+zemxqNBkuXLsWRI0fg5OSEiIiINnr3HRf/ZKc20bVrVzz88MM4fPgwJk2aBF9fX1haWuKJJ55AeHg4li1bhrlz58LHxwcjR45Enz59UFlZiV9//RUHDx7EkCFDkJaWZtSMERER+Nvf/oavvvoKAQEB0n3gbG1tsWHDhkYvcLgTEyZMwPbt25GcnIygoCD8+c9/xpUrV5CUlIT6+np8+umnerdHmDt3LhISEvQO7QwfPhwuLi4ICgrCvffeC7VajbNnzyItLQ1qtRovvfQShg0b1qb5iUzhscceQ3x8PI4ePYrBgwdL94HTaDT417/+1aJbiBhq5syZ2LhxI8aPH49x48ahd+/eyMnJQVpaGp5++mkkJSW1em53d3eMGjUKu3fvBgCDD582V0sfeOCBVue6U21Zz/70pz+hf//+CAgIgKurK8rLy5GVlYWcnBx07twZn3/+uVH+u3c4prrclTq+/Px8ERUVJXr06CEUCoXe5f6HDx8W48ePF7169RLW1tbCyclJBAQEiNdee0189913OnN5eHgIDw+PRl9Hezl/Y7S3HigqKpKWaS+hX7BggcjOzhbh4eGiW7duomvXrmLYsGHi2LFjd/rWm1RXVyfef/990b9/f2FrayuUSqWIjIwUWVlZzea/9TYJq1atEqNGjRLu7u7Czs5O2NjYiHvvvVeMGzdOpKWlGS0/kbHcfLuMn3/+WTzxxBNCqVQKOzs7MWjQoEZ/r5u7jUhT9WLBggV6t8UQouHWGGFhYUKpVIquXbuKwYMHix07dujUi5s1V3dutXPnTgFAPPTQQy0af6vmamlT+bSa2xZ3qq3q2euvvy4ee+wx0atXL9GpUydhZ2cn/Pz8xKxZs8TZs2eNkr0jUgjRjq4tJjKCzMxMhIWFYcGCBc3eGJOIqC0sXLgQixYtQnx8PP7617+aOw51UDwHjoiIqI388ccfWLduHXr06IFnnnnG3HGoA+M5cERERHcoJSUFx48fx549e3Dx4kW899576Ny5s7ljUQfGBo6IiOgOffHFF0hISMA999yDuXPnSlffExkLz4EjIiIikhmeA0dEREQkM2zgiIiIiGSGDRwRERGRzLCBIyIiIpKZu/4q1GvXrkGtVrdorLOzMy5fvmzkRMbD/ObF/OZjSHYrKyt0797dyIn+hzVIPuScX87Zgbsrf0tr0F3fwKnVatTV1d12nEKhkMbL8cJd5jcv5jef9p6dNUge5JxfztkB5m8KD6ESERERyQwbOCIiIiKZuesPoRIREdHdrT72CeO+QMr3bT4l98ARERERyQwbOCIiIiKZYQNHREREJDNs4IiIiIhkhg0cERERkcywgSMiIiKSGTZwRERERDLDBo6IiIhIZtjAEREREckMGzgiIiIimbmjr9LauXMnNm/ejJEjR2LKlCkAgNraWiQmJiI7Oxt1dXUICAjAtGnToFQqpeeVlZXh008/RW5uLmxtbRESEoKJEyfC0tJSGpObm4vExEQUFxfD0dERY8eORWhoqM7rp6WlYc+ePVCpVPDw8MDUqVPh7e19J2+JiMzEqF9lY4SvsSEiMqdW74ErKCjA119/DQ8PD53lCQkJ+OGHHzB79mwsWrQI165dw8qVK6X1Go0GS5cuhVqtxuLFizFr1ixkZmYiKSlJGnPp0iUsW7YM/fr1w4oVKzBq1CisW7cOJ0+elMZkZ2cjMTER48aNw/Lly+Hh4YElS5agvLy8tW+JiIiISBZa1cBVV1dj9erVmD59Orp06SItv3HjBg4cOICYmBj0798fXl5emDlzJs6cOYO8vDwAwI8//ojz58/jpZdegqenJ4KCghAdHY19+/ZBrVYDANLT0+Hi4oLJkyfDzc0NERERCA4ORkpKivRae/fuRXh4OMLCwuDm5obY2FjY2NggIyPjTrYHERERUbvXqgYuPj4eQUFBeOCBB3SWFxYWor6+Hv7+/tIyV1dXODk5SQ1cXl4e3N3ddQ6pBgYGoqqqCsXFxQCA/Px8nTkAICAgQJpDrVajsLBQZ4yFhQX8/f2lMUREREQdlcHnwGVlZaGoqAhLly7VW6dSqWBlZaWzVw4AHBwcoFKppDE3N2/a9dp12n9ql908pqqqCrW1taisrIRGo9GbR6lUoqSkpNHcdXV1qKurkx4rFArY2dlJ/3472jEtGdseMb95Mb/5mTs7axDzm4ucswPyz6/V1vkNauDKysqwadMmzJ8/HzY2Nm0axNh27NiB5ORk6XGfPn2wfPlyODs7GzRPz5492zqaSTG/eTF/04qNNnMDc2971qAGzG8+cs4OyLv+AG2f36AGrrCwEOXl5XjzzTelZRqNBr/88gvS0tLw1ltvQa1W4/r16zp74crLy6W9ZUqlEgUFBTrzai88uHnMrRcjlJeXw87ODjY2NrC3t4eFhYW0x06rsb17WmPGjEFUVJT0WNsJX758WTr3rjkKhQI9e/ZEaWkphBC3Hd/eML95Mb/5tTS7lZWVwU1VS7AGMb+5yDk7IP/8Wm1dgwxq4Pz9/fHee+/pLPv444/Ru3dvPPnkk3BycoKlpSV++uknBAcHAwBKSkpQVlYGX19fAICvry+2b9+O8vJy6TDpqVOnYGdnBzc3NwCAj48PTpw4ofM6p06dkuawsrKCl5cXcnJyMHDgQAANjWROTg4iIiIazW5tbQ1ra+tG1xnyCyGEkPUvEPObF/Obj7mzswY1YH7zkXN2gPlvZVADZ2dnB3d3d51lnTp1Qrdu3aTlQ4cORWJiIrp27YrOnTtjw4YN8PX1lZqvgIAAuLm5Yc2aNZg0aRJUKhW2bt2KESNGSMVt+PDh2LdvHz777DOEhYUhJycHR44cQVxcnPS6UVFRWLt2Lby8vODt7Y3U1FTU1NTo3SuOiIiIqKO5oxv5NiYmJgYKhQIrV66EWq2WbuSrZWFhgbi4OMTHx2P+/Pno1KkTQkJCEB0dLY1xcXFBXFwcEhISkJqaCkdHR8yYMQOBgYHSmEGDBqGiogLbtm2DSqWCp6cn5s2b1+QhVCIiIqKO4o4buIULF+o8trGxwbRp03Satls5Oztj7ty5zc6rvYlvcyIiIpo8ZEpERETUUfG7UImIiIhkhg0cERERkcywgSMiIiKSGTZwRERERDLDBo6IiIhIZtjAEREREckMGzgiIiIimWEDR0RERCQzbOCIiIiIZIYNHBEREZHMsIEjIiIikhk2cEREREQywwaOiIiISGbYwBERERHJDBs4IiIiIplhA0dEREQkM2zgiIiIiGSGDRwRERGRzLCBIyIiIpIZNnBEREREMsMGjoiIiEhm2MARERERyQwbOCIiIiKZYQNHREREJDNs4IiIiIhkxsqQwTt27MCxY8dw4cIF2NjYwNfXF3/5y1/Qu3dvaUxtbS0SExORnZ2Nuro6BAQEYNq0aVAqldKYsrIyfPrpp8jNzYWtrS1CQkIwceJEWFpaSmNyc3ORmJiI4uJiODo6YuzYsQgNDdXJk5aWhj179kClUsHDwwNTp06Ft7d367YEERERkUwYtAfu559/xogRI7BkyRLMnz8f9fX1WLx4Maqrq6UxCQkJ+OGHHzB79mwsWrQI165dw8qVK6X1Go0GS5cuhVqtxuLFizFr1ixkZmYiKSlJGnPp0iUsW7YM/fr1w4oVKzBq1CisW7cOJ0+elMZkZ2cjMTER48aNw/Lly+Hh4YElS5agvLz8DjYHERERUftnUAP31ltvITQ0FPfeey88PT0xa9YslJWVobCwEABw48YNHDhwADExMejfvz+8vLwwc+ZMnDlzBnl5eQCAH3/8EefPn8dLL70ET09PBAUFITo6Gvv27YNarQYApKenw8XFBZMnT4abmxsiIiIQHByMlJQUKcvevXsRHh6OsLAwuLm5ITY2FjY2NsjIyGirbUNERETULt3ROXA3btwAAHTt2hUAUFhYiPr6evj7+0tjXF1d4eTkJDVweXl5cHd31zmkGhgYiKqqKhQXFwMA8vPzdeYAgICAAGkOtVqNwsJCnTEWFhbw9/eXxhARERF1VAadA3czjUaDTZs2wc/PD+7u7gAAlUoFKysrdOnSRWesg4MDVCqVNObm5k27XrtO+0/tspvHVFVVoba2FpWVldBoNHrzKJVKlJSUNJq3rq4OdXV10mOFQgE7Ozvp329HO6YlY9sj5jcv5jc/c2dnDWJ+c5FzdkD++bXaOn+rG7j169ejuLgY77zzTlvmMZodO3YgOTlZetynTx8sX74czs7OBs3Ts2fPto5mUsxvXszftGKjzdzA3NueNagB85uPnLMD8q4/QNvnb1UDt379ehw/fhyLFi2Co6OjtFypVEKtVuP69es6e+HKy8ulvWVKpRIFBQU682kvPLh5zK0XI5SXl8POzg42Njawt7eHhYWFtMdOq7G9e1pjxoxBVFSU9FjbCV++fFk69645CoUCPXv2RGlpKYQQtx3f3jC/eTG/+bU0u5WVlcFNVUuwBjG/ucg5OyD//FptXYMMauCEENiwYQOOHTuGhQsXwsXFRWe9l5cXLC0t8dNPPyE4OBgAUFJSgrKyMvj6+gIAfH19sX37dpSXl0uHSU+dOgU7Ozu4ubkBAHx8fHDixAmduU+dOiXNYWVlBS8vL+Tk5GDgwIEAGg7p5uTkICIiotHs1tbWsLa2bvJ9GbIN5PwLxPzmxfzmY+7srEENmN985JwdYP5bGXQRw/r163H48GG88sorsLOzg0qlgkqlQm1tLQCgc+fOGDp0KBITE5GTk4PCwkJ89NFH8PX1lZqvgIAAuLm5Yc2aNTh37hxOnjyJrVu3YsSIEVJxGz58OC5duoTPPvsMFy5cwL59+3DkyBGMGjVKyhIVFYX9+/cjMzMT58+fR3x8PGpqavTuFUdERETU0Ri0By49PR0AsHDhQp3lM2fOlBqnmJgYKBQKrFy5Emq1WrqRr5aFhQXi4uIQHx+P+fPno1OnTggJCUF0dLQ0xsXFBXFxcUhISEBqaiocHR0xY8YMBAYGSmMGDRqEiooKbNu2DSqVCp6enpg3b16Th1CJiIiIOgqDGrht27bddoyNjQ2mTZum07TdytnZGXPnzm12Hu1NfJsTERHR5CFTIiIioo6K34VKREREJDNs4IiIiIhkptX3gSMiItMqHvWQUee3/HS3UecnorbDPXBEREREMsMGjoiIiEhm2MARERERyQwbOCIiIiKZYQNHREREJDNs4IiIiIhkhg0cERERkcywgSMiIiKSGTZwRERERDLDBo6IiIhIZvhVWgbg19gQERFRe8A9cEREREQywwaOiIiISGbYwBERERHJDBs4IiIiIplhA0dEREQkM2zgiIiIiGSGDRwRERGRzLCBIyIiIpIZNnBEREREMsMGjoiIiEhm2MARERERyQwbOCIiIiKZkf2X2aelpWHPnj1QqVTw8PDA1KlT4e3tbe5YRB1O8aiHzB2BiIj+S9YNXHZ2NhITExEbGwsfHx+kpKRgyZIl+PDDD+Hg4GDueAarj33CuC+Q8r1x5yezMvrvDxERtRuybuD27t2L8PBwhIWFAQBiY2Nx/PhxZGRkYPTo0eYN1w7JfQ9KsbkD3CG55yciovZDtg2cWq1GYWGhTqNmYWEBf39/5OXl6Y2vq6tDXV2d9FihUMDOzg5WVi3bBAqFAoq+fnecm4jMw9raGkKI245raU0wlBxqkKW1tdHmVigUAFr+36G9kXN+OWcHTJPfwgT/f2/rGiTbBq6iogIajQZKpVJnuVKpRElJid74HTt2IDk5WXo8ePBgvPLKK+jevXvLX/T/fd7auERkZk5OTmZ9fdagBub+73Cn5JxfztkBI+c3wWerrfPfNVehjhkzBps2bZJ+YmNjdf4avp2qqiq8+eabqKqqMmJK42F+82J+82kv2VmDmN9c5JwdYP6myHYPnL29PSwsLKBSqXSWq1Qqvb1yQMOuS+s7ODwghEBRUZEsdz8DzG9uzG8+7SU7axDzm4ucswPM3xTZ7oGzsrKCl5cXcnJypGUajQY5OTnw9fU1YzIiIiIi45LtHjgAiIqKwtq1a+Hl5QVvb2+kpqaipqYGoaGh5o5GREREZDSybuAGDRqEiooKbNu2DSqVCp6enpg3b16jh1DvlLW1NcaNG3dHh0DMifnNi/nNR87Zbyb398H85iPn7ADzN0Uh5HpQmYiIiOguJdtz4IiIiIjuVmzgiIiIiGSGDRwRERGRzLCBIyIiIpIZWV+F2tbS0tKwZ88eqFQqeHh4YOrUqfD29m5y/JEjR5CUlITLly+jZ8+emDRpEh588EETJtZlSP7//Oc/OHToEIqLG75i3cvLC88880yz79fYDN3+WllZWVi1ahUeeughvPHGGyZI2jhD81+/fh1btmzBsWPHUFlZCWdnZ8TExJjld8jQ7CkpKUhPT0dZWRns7e3x8MMPY+LEibCxsTFh6gY///wzdu/ejaKiIly7dg2vv/46Bg4c2OxzcnNzkZiYiOLiYjg6OmLs2LHt4vZDrEHmq0GsP+arP4B8a5BZ648gIYQQWVlZ4plnnhEHDhwQxcXFYt26dWLKlClCpVI1Ov706dMiOjpa7Nq1SxQXF4stW7aICRMmiF9//dXEyRsYmn/VqlUiLS1NFBUVifPnz4u1a9eKmJgYceXKFRMnb2Bofq2LFy+K6dOni7///e9i+fLlJkqrz9D8dXV1Ii4uTrz77rvil19+ERcvXhS5ubmiqKjItMGF4dkPHz4sJk6cKA4fPiwuXrwoTp48KZ5//nmxadMmEydvcPz4cbFlyxZx9OhRMX78eHH06NFmx1+8eFH85S9/EQkJCaK4uFh89dVXIjo6Wpw4ccI0gZvAGmS+GsT6Y776I4S8a5A56w8Pof7X3r17ER4ejrCwMLi5uSE2NhY2NjbIyMhodHxqaioCAwPxxBNPwM3NDRMmTICXlxfS0tJMnLyBoflffvlljBgxAp6ennB1dcWMGTMghMBPP/1k4uQNDM0PNHzzxurVq/H000/DxcXFhGn1GZr/wIEDqKysxJw5c3DffffBxcUF999/Pzw9PU0bHIZnP3PmDPz8/DBkyBC4uLggICAAgwcPRkFBgYmTNwgKCsKECRNu+1evVnp6OlxcXDB58mS4ubkhIiICwcHBSElJMXLS5rEGma8Gsf6Yr/4A8q5B5qw/bOAAqNVqFBYWwt/fX1pmYWEBf39/5OXlNfqcvLw8nfEAEBAQgPz8fKNmbUxr8t+qpqYGarUaXbt2NVbMJrU2f3JyMuzt7TF06FBTxGxSa/L/8MMP8PHxwfr16xEbG4u//e1v2L59OzQajaliA2hddj8/PxQWFkrF8uLFizhx4gSCgoJMkvlO5efnN/rZbelnxRhYg8xXg1h/zFd/gLuvBrVl/eE5cAAqKiqg0Wj0vsFBqVSipKSk0eeoVCo4ODjoLHNwcIBKpTJSyqa1Jv+tPv/8c/To0UPvF8sUWpP/9OnTOHDgAFasWGGChM1rTf6LFy/i8uXLGDJkCObOnYvS0lLEx8ejvr4e48ePN0HqBq3JPmTIEFRUVODtt98GANTX12PYsGF46qmnjB23TTT12a2qqkJtba1ZzuNjDTJfDWL9MV/9Ae6+GtSW9YcNHGHnzp3IysrCwoULzfI/L0NVVVVh9erVmD59Ouzt7c0dp1WEELC3t8f06dNhYWEBLy8vXL16Fbt37zZ5ATVUbm4uduzYgWnTpsHHxwelpaXYuHEjkpOTMW7cOHPHIxmSUw1i/TE/1qAGbOAA2Nvbw8LCQu8vV5VK1eT3qiqVSpSXl+ssKy8vN8r3sN5Oa/Jr7d69Gzt37sTbb78NDw8P44VshqH5tX89Ll++XFom/vuNcBMmTMCHH36Inj17GjOyjtb+/lhZWcHC4n9nMbi6ukKlUkGtVsPKyjQfzdZkT0pKwmOPPYbw8HAAgLu7O6qrq/HJJ5/gqaee0nlP7VFTn107OzuzNQ+sQearQaw/DcxRf4C7rwa1Zf1pv+/ShKysrODl5YWcnBxpmUajQU5ODnx9fRt9jq+vr97JtqdOnYKPj49RszamNfkBYNeuXfjyyy8xb9489O3b1xRRG2Vo/t69e+O9997DihUrpJ8BAwagX79+WLFiBZycnEwZv1Xb38/PD6WlpTrnnPz+++/o3r27SYtna7LX1NRAoVDoLGvPBfNWPj4+jX52m/usGBtrkPlqEOtPA3PUH+Duq0FtWX/k8Y5NICoqCvv370dmZibOnz+P+Ph41NTUSPdmWbNmDTZv3iyNHzlyJH788Ufs2bMHFy5cwLZt23D27FlERETIIv/OnTuRlJSEF154AS4uLlCpVFCpVKiurm73+W1sbODu7q7z06VLF9ja2sLd3d3kBcjQ/AAwfPhwVFZWYtOmTSgpKcHx48exY8cOjBgxot1nHzBgAL7++mtkZWXh0qVLOHXqFJKSkjBgwACzFNHq6mqcO3cO586dAwBcunQJ586dQ1lZGQBg8+bNWLNmjTR++PDhuHTpEj777DNcuHAB+/btw5EjRzBq1CiTZ78Za5D5ahDrj/nqT2vyt6caZM76w0Oo/zVo0CBUVFRg27ZtUKlU8PT0xLx586RduGVlZTodv5+fH15++WVs3boVW7ZsQa9evTBnzhy4u7vLIv/XX38NtVqN999/X2eecePG4emnnzZldACG529vDM3v5OSEt956CwkJCZgzZw569OiByMhIjB49ut1nHzt2LBQKBbZu3YqrV6/C3t4eAwYMwDPPPGPy7ABw9uxZLFq0SHqcmJgIAAgJCcGsWbNw7do1qZgCgIuLC+Li4pCQkIDU1FQ4OjpixowZCAwMNHV0HaxBDcxRg1h/zFd/WpO/PdUgc9YfhdAevCciIiIiWeAhVCIiIiKZYQNHREREJDNs4IiIiIhkhg0cERERkcywgSMiIiKSGTZwRERERDLDBo6IiIhIZtjAEREREckMGzgiIiIimWEDR0RERCQzbOCIiIiIZIYNHBEREZHMsIEjIiIikhk2cEREREQywwaOiIiISGbYwBERERHJDBs4IiIiIplhA0dERNTOnDt3DgqFAlOmTGnxczZt2gSFQoFNmzYZLRe1H2zgqE20pth0dL/88gsWLFiAJ598Eu7u7lAoFFAoFFCr1a2ar76+Hh988AEeeOAB2NnZoUePHhg5ciSys7PbODkREbV3bOCIjGTfvn145513kJKSgi5dusDW1rbVcwkhMGHCBMyePRu1tbV48cUXMWbMGBw6dAiPPfYYdu3a1YbJiYiovWMDR2QkkZGR+Pbbb/HHH3/gl19+wT333NPqubZu3Yrk5GQMGjQIJ0+exD//+U+sX78eGRkZsLS0RGxsLP744482TE9ERO0ZGzi6YwsXLkSfPn0AAAkJCdKhwlvPxdi3bx9GjhwJJycndOrUCX379sWcOXOgUqn05vT09ISnpycqKyvx2muv4d5774WdnR0CAwOxc+dOAIBarcaSJUvg4+MDW1tb9O3bF2vWrNGbKzMzEwqFAgsXLsSRI0fw+OOPw8HBAd26dcOIESPw/fffG2OzwM/PDw8//DDs7OzueK6PP/4YALB48WKdPXl/+tOfEB0djcuXLyM5OfmOX4eIWk4IgVWrVuH++++Hra0tXF1d8eKLL6K8vFyqYTerqanBsmXL4O/vj86dO8Pe3h6PPvootm3bZtDrFhQUYPz48ejevTu6dOmCQYMGISUlpQ3fGcmBlbkDkPyFhoZCpVJh1apVCAgIwOjRo6V1gYGBAIBFixZh4cKF6NGjB6KiouDi4oJTp07hvffeQ2pqKo4cOQJ7e3udeevq6jBs2DBcvXoVTz75JGpra7FlyxaMHTsW6enp+Oijj3D06FFERkaiU6dO+OKLL/DSSy/B2dkZ0dHRejmPHj2KpUuX4vHHH8esWbNQUFCA7du349ChQ0hPT8ejjz5qzM3UatXV1cjOzkbnzp0bzRgZGYl///vfOHDgAJ577jkzJCS6O82aNQsff/wxevfujeeffx42NjbYvXs3jh07hrq6OlhbW0tja2trMWLECBw8eBD33XcfZs2ahRs3biA5ORnR0dE4efIk3n333du+Zn5+Ph555BFcuXIFkZGRCAwMREFBAUaPHo3IyEhjvl1qbwRRGygqKhIARExMjN66AwcOCADikUceEdeuXdNZt3HjRgFAvPrqqzrLPTw8BAARFRUlqqurpeWHDh0SAET37t3FQw89pDPf2bNnhbW1tQgMDNSZKyMjQwAQAMTq1at11u3cuVMAEN7e3qK+vl7n/SxYsMCgn6Kioma3kfY91dXVNTvuVjk5OQKA6N+/f6Prv/vuOwFADBw40KB5iaj1tLXI19dXpw7V1NSIRx99VAAQHh4e0vJ3331XABCRkZE6NeDixYtSbcjKypKWN1VThw0bJgCIDz/8UGe5tpYBEBs3bmzLt0rtFBs4ahPNNXCjR48WAEROTk6jzw0MDBTOzs46y7QFraCgQG98nz59BACxf/9+vXWhoaHCyspKqNVqaZm2gbu1SdMKCQkRAERmZqbecwz5ycjIaGrz6LwnQxu4rKwsAUAMHjy40fV5eXnS/0iIyDT++te/CgAiISFBb90333yj18B5e3sLhUIhfvnlF73x8fHxAoB47rnnpGWN1dTi4mIBQPTp00enxmlpaxkbuLsDD6GS0R05cgTW1tb44osv8MUXX+itr62txeXLl3HlyhU4OjpKy5VKJfr27as3vnfv3igqKsKAAQP01rm6ukKtVqO0tBSurq466x599FFYWOif9hkaGoqDBw/ixIkTCAkJkZYJIQx+r0R0dzhx4gQAYMiQIXrrgoODYWX1v/+9/vHHHygoKICrqyvuu+8+vfFDhw7VmbMlr2lpaam3XlvL6O7ABo6M7sqVK1Cr1Vi0aFGz4yorK3UaOAcHh0bHaQtjY+u16+rq6vTWNXUVaM+ePQEA5eXlzeYzF+37bCqfdrlSqTRVJKK7nvZz11hdsbS01Kll2rG9evVqdC7t8sYu6GrpawL/q2V0d2ADR0bn4OAAjUaDq1evmjXHxYsXG11eWloKQLchPHfunMF3M58yZYreVWdtoW/fvrC0tERhYSHUarXOX/ZAw0nNAODr69vmr01EjdNedHXx4kV4eXnprKuvr8eVK1ekowDa2qKtNbf6/fffdcY1Rbv+drWM7g5s4KhNaHfn19fX660LDg5GSkoKcnNz0a9fP1NHk3zzzTfQaDR6h1EzMzMBAEFBQdKyc+fO3XaP4a1CQ0ON0sDZ2tpi0KBBOHz4MA4fPoywsDCd9V999RWA/x2GISLjCwoKwokTJ/DNN9/oNXDffvutzjeudOvWDX379kVhYSHy8/Ph4+OjMz4jIwMA8OCDD972NYGGWlZfX693GFVby+juwPvAUZvo3r07FAoFfvvtN711r732GgAgNjYWJSUleuuvX7+Ob7/91ugZ8/Pz8dFHH+ks27VrFw4ePAhvb2+dW3Roz4Ez5Cc0NPSOM/722284ffo0bty4obP8hRdeAADMnz8f1dXV0vLvvvsOSUlJcHZ2xtixY+/49YmoZSZPngwAWLJkic7pDbW1tZg3b57e+KlTp0IIgTlz5uj8oVtWVoZ//OMf0pjmuLm5YdiwYSgqKtK756W2ltHdg3vgqE107doVDz/8MA4fPoxJkybB19cXlpaWeOKJJxAeHo5ly5Zh7ty58PHxwciRI9GnTx9UVlbi119/xcGDBzFkyBCkpaUZNWNERAT+9re/4auvvkJAQIB0HzhbW1ts2LCh0Qsc7kRZWRlef/11nccA8Ne//hUKhQIAEBcXp3NS8+TJk3Hw4EFkZGToNIQTJkzA9u3bkZycjKCgIPz5z3/GlStXkJSUhPr6enz66ad699EjIuMJCQnB888/j08++QT9+vXD2LFjYW1tjT179sDBwQG9e/fWqSmvv/46vvrqK+zatQsBAQEYOXIkbty4gS+++AKXLl3CG2+80egFEbdau3YtHnnkEbz66qtIT0+XatmOHTvw5z//GXv27DHm26b2xByXvlLHlJ+fL6KiokSPHj2EQqHQu5z98OHDYvz48aJXr17C2tpaODk5iYCAAPHaa6+J7777TmcuDw8PnUvwb6a9VL4xMTExAoDOPdm0twRZsGCByM7OFuHh4aJbt26ia9euYtiwYeLYsWN3+tYbpb0NQHM/t956RPveGrslSV1dnXj//fdF//79ha2trVAqlSIyMlLn3lFEZDr19fXi/fffF35+fsLGxkb06tVLzJw5U6hUKtG1a1cREBCgM76qqkosWbJE9OvXT9ja2oquXbuKwYMHi82bN+vN3dytmfLz88XYsWOFg4OD6Ny5swgODhZ79+6V7qvJ24jcHRRC8F4J1LFlZmYiLCwMCxYswMKFC80dh4g6uPz8fPj6+mLChAnYsmWLueNQB8Vz4IiIiFqhtLQUGo1GZ9mNGzfw6quvAgDGjBljhlR0t+A5cERERK3w4YcfYsuWLQgNDUWvXr1QWlqK/fv34/z584iMjMT48ePNHZE6MDZwRERErTBs2DD8+OOPSE9Px9WrV2FlZQVfX1+8/PLLePXVV6WLlYiMgefAEREREckMz4EjIiIikhk2cEREREQywwaOiIiISGbYwBERERHJzF1/Feq1a9d0vnS4Oc7Ozrh8+bKRExkP85sX85uPIdmtrKzQvXt3Iyf6H9Yg+ZBzfjlnB+6u/C2tQXd9A6dWq1FXV3fbcdrLwdVqNeR44S7zmxfzm097z84aJA9yzi/n7ADzN4WHUImIiIhkhg0cERERkcywgSMiIiKSmbv+HDgiIiK6u9XHPmHcF0j5vs2n5B44IiIiIplhA0dEREQkM2zgiIiIiGSGDRwRERGRzLCBIyIiIpIZNnBEREREMsMGjoiIiEhm2MARERERyQwbOCIiIiKZuaNvYti5cyc2b96MkSNHYsqUKQCA2tpaJCYmIjs7G3V1dQgICMC0adOgVCql55WVleHTTz9Fbm4ubG1tERISgokTJ8LS0lIak5ubi8TERBQXF8PR0RFjx45FaGiozuunpaVhz549UKlU8PDwwNSpU+Ht7X0nb4mIiIio3Wv1HriCggJ8/fXX8PDw0FmekJCAH374AbNnz8aiRYtw7do1rFy5Ulqv0WiwdOlSqNVqLF68GLNmzUJmZiaSkpKkMZcuXcKyZcvQr18/rFixAqNGjcK6detw8uRJaUx2djYSExMxbtw4LF++HB4eHliyZAnKy8tb+5aIiIiIZKFVDVx1dTVWr16N6dOno0uXLtLyGzdu4MCBA4iJiUH//v3h5eWFmTNn4syZM8jLywMA/Pjjjzh//jxeeukleHp6IigoCNHR0di3bx/UajUAID09HS4uLpg8eTLc3NwQERGB4OBgpKSkSK+1d+9ehIeHIywsDG5uboiNjYWNjQ0yMjLuZHsQERERtXutauDi4+MRFBSEBx54QGd5YWEh6uvr4e/vLy1zdXWFk5OT1MDl5eXB3d1d55BqYGAgqqqqUFxcDADIz8/XmQMAAgICpDnUajUKCwt1xlhYWMDf318aQ0RERNRRGXwOXFZWFoqKirB06VK9dSqVClZWVjp75QDAwcEBKpVKGnNz86Zdr12n/ad22c1jqqqqUFtbi8rKSmg0Gr15lEolSkpKGs1dV1eHuro66bFCoYCdnZ3077ejHdOSse0R85sX85tPe8nOGsT85iLn7ID882u1dX6DGriysjJs2rQJ8+fPh42NTZsGMbYdO3YgOTlZetynTx8sX74czs7OBs3Ts2fPto5mUsxvXsxvPubOzhrUgPnNR87ZAePmLzbazP/T1vkNauAKCwtRXl6ON998U1qm0Wjwyy+/IC0tDW+99RbUajWuX7+usxeuvLxc2lumVCpRUFCgM6/2woObx9x6MUJ5eTns7OxgY2MDe3t7WFhYSHvstBrbu6c1ZswYREVFSY+1nfDly5elc++ao1Ao0LNnT5SWlkIIcdvx7Q3zmxfzm4+h2a2srAxuqlqCNYj5zUXO2QH559dq6xpkUAPn7++P9957T2fZxx9/jN69e+PJJ5+Ek5MTLC0t8dNPPyE4OBgAUFJSgrKyMvj6+gIAfH19sX37dpSXl0uHSU+dOgU7Ozu4ubkBAHx8fHDixAmd1zl16pQ0h5WVFby8vJCTk4OBAwcCaGgkc3JyEBER0Wh2a2trWFtbN7rOkF8IIYSsf4GY37yY33zMnZ01qAHzm4+cswPMfyuDGjg7Ozu4u7vrLOvUqRO6desmLR86dCgSExPRtWtXdO7cGRs2bICvr6/UfAUEBMDNzQ1r1qzBpEmToFKpsHXrVowYMUIqbsOHD8e+ffvw2WefISwsDDk5OThy5Aji4uKk142KisLatWvh5eUFb29vpKamoqamRu9ecUREREQdzR3dyLcxMTExUCgUWLlyJdRqtXQjXy0LCwvExcUhPj4e8+fPR6dOnRASEoLo6GhpjIuLC+Li4pCQkIDU1FQ4OjpixowZCAwMlMYMGjQIFRUV2LZtG1QqFTw9PTFv3rwmD6ESERERdRR33MAtXLhQ57GNjQ2mTZum07TdytnZGXPnzm12Xu1NfJsTERHR5CFTIiIioo6K34VKREREJDNs4IiIiIhkhg0cERERkcywgSMiIiKSGTZwRERERDLDBo6IiIhIZtjAEREREckMGzgiIiIimWEDR0RERCQzbOCIiIiIZIYNHBEREZHMsIEjIiIikhk2cEREREQywwaOiIiISGaszB2AiAgA6mOfMN7kKd8bb24iIjPgHjgiIiIimWEDR0RERCQzbOCIiIiIZIYNHBEREZHMsIEjIiIikhk2cEREREQywwaOiIiISGbYwBERERHJDBs4IiIiIplhA0dEREQkMwZ9ldaOHTtw7NgxXLhwATY2NvD19cVf/vIX9O7dWxpTW1uLxMREZGdno66uDgEBAZg2bRqUSqU0pqysDJ9++ilyc3Nha2uLkJAQTJw4EZaWltKY3NxcJCYmori4GI6Ojhg7dixCQ0N18qSlpWHPnj1QqVTw8PDA1KlT4e3t3botQURERCQTBu2B+/nnnzFixAgsWbIE8+fPR319PRYvXozq6mppTEJCAn744QfMnj0bixYtwrVr17By5UppvUajwdKlS6FWq7F48WLMmjULmZmZSEpKksZcunQJy5YtQ79+/bBixQqMGjUK69atw8mTJ6Ux2dnZSExMxLhx47B8+XJ4eHhgyZIlKC8vv4PNQURERNT+GdTAvfXWWwgNDcW9994LT09PzJo1C2VlZSgsLAQA3LhxAwcOHEBMTAz69+8PLy8vzJw5E2fOnEFeXh4A4Mcff8T58+fx0ksvwdPTE0FBQYiOjsa+ffugVqsBAOnp6XBxccHkyZPh5uaGiIgIBAcHIyUlRcqyd+9ehIeHIywsDG5uboiNjYWNjQ0yMjLaatsQERERtUt3dA7cjRs3AABdu3YFABQWFqK+vh7+/v7SGFdXVzg5OUkNXF5eHtzd3XUOqQYGBqKqqgrFxcUAgPz8fJ05ACAgIECaQ61Wo7CwUGeMhYUF/P39pTFEREREHZVB58DdTKPRYNOmTfDz84O7uzsAQKVSwcrKCl26dNEZ6+DgAJVKJY25uXnTrteu0/5Tu+zmMVVVVaitrUVlZSU0Go3ePEqlEiUlJY3mraurQ11dnfRYoVDAzs5O+vfb0Y5pydj2iPnNi/nNz9zZWYOY31zknB2Qf36tts7f6gZu/fr1KC4uxjvvvNOWeYxmx44dSE5Olh736dMHy5cvh7Ozs0Hz9OzZs62jmRTzmxfzN63YaDM3MPe2Zw1qwPzmI+fsgLzrD9D2+VvVwK1fvx7Hjx/HokWL4OjoKC1XKpVQq9W4fv26zl648vJyaW+ZUqlEQUGBznzaCw9uHnPrxQjl5eWws7ODjY0N7O3tYWFhIe2x02ps757WmDFjEBUVJT3WdsKXL1+Wzr1rjkKhQM+ePVFaWgohxG3HtzfMb17Mb34tzW5lZWVwU9USrEHMby5yzg7IP79WW9cggxo4IQQ2bNiAY8eOYeHChXBxcdFZ7+XlBUtLS/z0008IDg4GAJSUlKCsrAy+vr4AAF9fX2zfvh3l5eXSYdJTp07Bzs4Obm5uAAAfHx+cOHFCZ+5Tp05Jc1hZWcHLyws5OTkYOHAggIZDujk5OYiIiGg0u7W1NaytrZt8X4ZsAzn/AjG/eTG/+Zg7O2tQA+Y3HzlnB5j/VgZdxLB+/XocPnwYr7zyCuzs7KBSqaBSqVBbWwsA6Ny5M4YOHYrExETk5OSgsLAQH330EXx9faXmKyAgAG5ublizZg3OnTuHkydPYuvWrRgxYoRU3IYPH45Lly7hs88+w4ULF7Bv3z4cOXIEo0aNkrJERUVh//79yMzMxPnz5xEfH4+amhq9e8URERERdTQG7YFLT08HACxcuFBn+cyZM6XGKSYmBgqFAitXroRarZZu5KtlYWGBuLg4xMfHY/78+ejUqRNCQkIQHR0tjXFxcUFcXBwSEhKQmpoKR0dHzJgxA4GBgdKYQYMGoaKiAtu2bYNKpYKnpyfmzZvX5CFUIiIioo7CoAZu27Zttx1jY2ODadOm6TRtt3J2dsbcuXObnUd7E9/mRERENHnIlIiIiKij4nehEhEREclMq28jQkREplU86iGjzm/56W6jzk9EbYd74IiIiIhkhg0cERERkcywgSMiIiKSGTZwRERERDLDBo6IiIhIZtjAEREREckMGzgiIiIimWEDR0RERCQzbOCIiIiIZIYNHBEREZHMsIEjIiIikhk2cEREREQywwaOiIiISGbYwBERERHJDBs4IiIiIplhA0dEREQkM1bmDkBE8lA86iFzRyAiov/iHjgiIiIimWEDR0RERCQzPIRK1EHUxz5h7ghERGQi3ANHREREJDPcA0eyIfeT6IvNHYCIiDoMNnDUZngIj4iIyDTYwBnA2HuALD/dbdT55b4Hi4iIiBrIvoFLS0vDnj17oFKp4OHhgalTp8Lb29vcsVqFe7CIiIioJWR9EUN2djYSExMxbtw4LF++HB4eHliyZAnKy8vNHY2IiIjIaGTdwO3duxfh4eEICwuDm5sbYmNjYWNjg4yMDHNHIyIiIjIa2R5CVavVKCwsxOjRo6VlFhYW8Pf3R15ent74uro61NXVSY8VCgXs7OxgZdWyTaBQKKDo63fHuYnIPKytrSGEuO24ltYEQ8mhBllaWxttboVCAaDl/x3aGznnl3N2wDT5LUzw//e2rkGybeAqKiqg0WigVCp1liuVSpSUlOiN37FjB5KTk6XHgwcPxiuvvILu3bu3/EX/3+etjUtEZubk5GTW12cNamDu/w53Ss755ZwdMHJ+E3y22jq/rA+hGmLMmDHYtGmT9BMbG6vz1/DtVFVV4c0330RVVZURUxoP85sX85tPe8nOGsT85iLn7ADzN0W2e+Ds7e1hYWEBlUqls1ylUuntlQMadl1a38HhASEEioqKZLn7GWB+c2N+82kv2VmDmN9c5JwdYP6myHYPnJWVFby8vJCTkyMt02g0yMnJga+vrxmTERERERmXbPfAAUBUVBTWrl0LLy8veHt7IzU1FTU1NQgNDTV3NCIiIiKjkXUDN2jQIFRUVGDbtm1QqVTw9PTEvHnzGj2Eeqesra0xbty4OzoEYk7Mb17Mbz5yzn4zub8P5jcfOWcHmL8pCiHXg8pEREREdynZngNHREREdLdiA0dEREQkM2zgiIiIiGSGDRwRERGRzMj6KtS2lpaWhj179kClUsHDwwNTp06Ft7d3k+OPHDmCpKQkXL58GT179sSkSZPw4IMPmjCxLkPy/+c//8GhQ4dQXFwMAPDy8sIzzzzT7Ps1NkO3v1ZWVhZWrVqFhx56CG+88YYJkjbO0PzXr1/Hli1bcOzYMVRWVsLZ2RkxMTFm+R0yNHtKSgrS09NRVlYGe3t7PPzww5g4cSJsbGxMmLrBzz//jN27d6OoqAjXrl3D66+/joEDBzb7nNzcXCQmJqK4uBiOjo4YO3Zsu7j9EGuQ+WoQ64/56g8g3xpk1vojSAghRFZWlnjmmWfEgQMHRHFxsVi3bp2YMmWKUKlUjY4/ffq0iI6OFrt27RLFxcViy5YtYsKECeLXX381cfIGhuZftWqVSEtLE0VFReL8+fNi7dq1IiYmRly5csXEyRsYml/r4sWLYvr06eLvf/+7WL58uYnS6jM0f11dnYiLixPvvvuu+OWXX8TFixdFbm6uKCoqMm1wYXj2w4cPi4kTJ4rDhw+LixcvipMnT4rnn39ebNq0ycTJGxw/flxs2bJFHD16VIwfP14cPXq02fEXL14Uf/nLX0RCQoIoLi4WX331lYiOjhYnTpwwTeAmsAaZrwax/piv/ggh7xpkzvrDQ6j/tXfvXoSHhyMsLAxubm6IjY2FjY0NMjIyGh2fmpqKwMBAPPHEE3Bzc8OECRPg5eWFtLQ0EydvYGj+l19+GSNGjICnpydcXV0xY8YMCCHw008/mTh5A0PzAw3fvLF69Wo8/fTTcHFxMWFafYbmP3DgACorKzFnzhzcd999cHFxwf333w9PT0/TBofh2c+cOQM/Pz8MGTIELi4uCAgIwODBg1FQUGDi5A2CgoIwYcKE2/7Vq5Weng4XFxdMnjwZbm5uiIiIQHBwMFJSUoyctHmsQearQaw/5qs/gLxrkDnrDxs4AGq1GoWFhfD395eWWVhYwN/fH3l5eY0+Jy8vT2c8AAQEBCA/P9+oWRvTmvy3qqmpgVqtRteuXY0Vs0mtzZ+cnAx7e3sMHTrUFDGb1Jr8P/zwA3x8fLB+/XrExsbib3/7G7Zv3w6NRmOq2ABal93Pzw+FhYVSsbx48SJOnDiBoKAgk2S+U/n5+Y1+dlv6WTEG1iDz1SDWH/PVH+Duq0FtWX94DhyAiooKaDQavW9wUCqVKCkpafQ5KpUKDg4OOsscHBygUqmMlLJprcl/q88//xw9evTQ+8UyhdbkP336NA4cOIAVK1aYIGHzWpP/4sWLuHz5MoYMGYK5c+eitLQU8fHxqK+vx/jx402QukFrsg8ZMgQVFRV4++23AQD19fUYNmwYnnrqKWPHbRNNfXarqqpQW1trlvP4WIPMV4NYf8xXf4C7rwa1Zf1hA0fYuXMnsrKysHDhQrP8z8tQVVVVWL16NaZPnw57e3tzx2kVIQTs7e0xffp0WFhYwMvLC1evXsXu3btNXkANlZubix07dmDatGnw8fFBaWkpNm7ciOTkZIwbN87c8UiG5FSDWH/MjzWoARs4APb29rCwsND7y1WlUjX5vapKpRLl5eU6y8rLy43yPay305r8Wrt378bOnTvx9ttvw8PDw3ghm2Fofu1fj8uXL5eWif9+I9yECRPw4YcfomfPnsaMrKO1vz9WVlawsPjfWQyurq5QqVRQq9WwsjLNR7M12ZOSkvDYY48hPDwcAODu7o7q6mp88skneOqpp3TeU3vU1GfXzs7ObM0Da5D5ahDrTwNz1B/g7qtBbVl/2u+7NCErKyt4eXkhJydHWqbRaJCTkwNfX99Gn+Pr66t3su2pU6fg4+Nj1KyNaU1+ANi1axe+/PJLzJs3D3379jVF1EYZmr9379547733sGLFCulnwIAB6NevH1asWAEnJydTxm/V9vfz80NpaanOOSe///47unfvbtLi2ZrsNTU1UCgUOsvac8G8lY+PT6Of3eY+K8bGGmS+GsT608Ac9Qe4+2pQW9YfebxjE4iKisL+/fuRmZmJ8+fPIz4+HjU1NdK9WdasWYPNmzdL40eOHIkff/wRe/bswYULF7Bt2zacPXsWERERssi/c+dOJCUl4YUXXoCLiwtUKhVUKhWqq6vbfX4bGxu4u7vr/HTp0gW2trZwd3c3eQEyND8ADB8+HJWVldi0aRNKSkpw/Phx7NixAyNGjGj32QcMGICvv/4aWVlZuHTpEk6dOoWkpCQMGDDALEW0uroa586dw7lz5wAAly5dwrlz51BWVgYA2Lx5M9asWSONHz58OC5duoTPPvsMFy5cwL59+3DkyBGMGjXK5NlvxhpkvhrE+mO++tOa/O2pBpmz/vAQ6n8NGjQIFRUV2LZtG1QqFTw9PTFv3jxpF25ZWZlOx+/n54eXX34ZW7duxZYtW9CrVy/MmTMH7u7ussj/9ddfQ61W4/3339eZZ9y4cXj66adNGR2A4fnbG0PzOzk54a233kJCQgLmzJmDHj16IDIyEqNHj2732ceOHQuFQoGtW7fi6tWrsLe3x4ABA/DMM8+YPDsAnD17FosWLZIeJyYmAgBCQkIwa9YsXLt2TSqmAODi4oK4uDgkJCQgNTUVjo6OmDFjBgIDA00dXQdrUANz1CDWH/PVn9bkb081yJz1RyG0B++JiIiISBZ4CJWIiIhIZtjAEREREckMGzgiIiIimWEDR0RERCQzbOCIiIiIZIYNHBEREZHMsIEjIiIikhk2cEREREQywwaOiIiISGbYwBERERHJDBs4IiIiIplhA0dEREQkM/8ff/ds6ciu09IAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('ggplot')\n",
    "\n",
    "fig, axs = plt.subplots(3, 2, sharey=True, tight_layout=True)\n",
    "n_bins = 10\n",
    "\n",
    "# We can set the number of bins with the *bins* keyword argument.\n",
    "axs[0][0].hist(dists['temp=0.1'], bins=n_bins)\n",
    "axs[0][0].title.set_text('temp=0.1')\n",
    "\n",
    "axs[1][0].hist(dists['temp=0.3'], bins=n_bins)\n",
    "axs[1][0].title.set_text('temp=0.3')\n",
    "\n",
    "axs[2][0].hist(dists['temp=1.0'], bins=n_bins)\n",
    "axs[2][0].title.set_text('temp=1.0')\n",
    "\n",
    "axs[0][1].hist(dists['temp=10.0'], bins=n_bins)\n",
    "axs[0][1].title.set_text('temp=10.0')\n",
    "\n",
    "axs[1][1].hist(dists['binary th=0.5'], bins=n_bins)\n",
    "axs[1][1].title.set_text('binary th=0.5')\n",
    "\n",
    "axs[2][1].hist(dists['gold'], bins=n_bins)\n",
    "axs[2][1].title.set_text('gold')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/wAALCADIAQABAREA/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/9oACAEBAAA/APf6x/FH2z+wZfsXn7vNh877PnzPs/mp5+zb827yvMxs+fP3fmxXJyWFoviyyutL0+O7id7ZrR1sHIjt9qLm2vY28uGBVDMYWGXPmDBEq5p6cfGOheC9Gt7RZ7maTRI2kie18sWJjNum1cIzeZ5UkzEOJCzxfKmMxm5od/4y1O4s7WSeSK3kS6Wa7mtJFkjUG2KN+8t4g0vzzBfkVMckSGMhi5uvGEMV9dRXOpSOqandw25soyu63n220AxHuKSo2TzvbYCjLzmvr+seNIJbr+zhqRnD3weGPTVeGJUgnNoY5NuXLlYmYfvPnwpMefLfsNHOrwazfWWoXMl5AtvBcR3LW4jXzXaUSRptGNiiNCASzjf8zNkV5/4MtZdH8Jx/Y9JjttaSyto5poPDM1pcRRboxcEyyArcShcsAB8zJnY+cVoaNceK7XUdWmt7S7mW9uJ1t3vbMQiWX7PZrbzTKDlU2pMXI28hl2K5WMaF1qviiS6lmWDUrSykuJPsiJZJNL5ixQBIJF6CJpftW5yyj5VIlVGUtHoF745vNCvbu5TF3bWkclrb3EAje6uGsYmKOCFCxiZnzg5LHblFQhst7vXoL3Wr61n1l0kt7GC1vLjSHSedVe5ZxhIH2FWb7zQD5do2/Osp7jwzqLXNhDaXk122px26XE63aKJAkjyBGO1EGD5bYBVWAA3qrZFeZ+FrPW9G8ORTaNpPk30WlRxXQi0iXTyrl4QxkDq/2qZUEzK6K20q3yP5qrXSaHdeL9YuLO1uNRu7O1KXRmuRYMJjtNsYwWmt4lD5ebBEW0oCMFgXWTxFZax4p8LeEXk0uxfUpZUubm11GzeS2ikNlOSssecqu8hck5Ulep4Off3HiXR/DjwaMuqxTQ6fI9lBFpiyB7kvL5sTKdwjjiAj8kB8EYCm4ACmvdX3jDRy0VhbzwWv2u+nhP2aaQSyNe3DYlWO2mby9nlMMGIsHbazdUk1rWPFGj6FrNxbi7sTbpfz2Yg01GjmYXNyWabKgIFiEMisSu8uT++PyHU0+DUdNg3am+7RrvVdTivLS5tVWCC0L3UvnSMwz8xVRuJEZSQDbn5j0GiprEnhUKs/kXhll+zSX8Lylbfzm8nzF3K5bydmdzB88tlsirF9C/8AwjkkWtxf2n0+0pY27IJE3gn91vZmUL95MtvAYbW3bDxdtYXK+GLm3itrtLR72Ob7Hb6c9vbzWiyWvn7bZlLxDaJl8ksTKWlYKwcBcuXw8HaG9m02AaZHLNHZwT+GJrmBA8VruKWgcSwZlhnIypHzMSfnUv2GuQ6pceGdB02y0OCH7VLDHeaeZtkNvEsTSNC0iIyiPdGsR+QqysV43Aiv4Gh1hdUvH1i2njmi0+3sxLKXfzfJubxA3mMB5jFPLctgZ3hsAMBXP6XZeLNM0zwxM43eR4f8gi3050mskMlkJAwZ3DzLGsjKu0ZaM/I33asDU/GztqMscuqmGyivLizWTTI4zeiOK0a3SRdhPzl5shSjk7gBGV2J2GiahcQ6neaJqVzPPcRSubOeeEI9zAscDO5KKqHbJPs+UDpjBIY1yd94a1KfwD4nRLjUkFw+rS/2cobdNIZpzFsP3gjAqSi8PhTwGkEg0Ov2+uW2oWkF39rS312O1tRZqlu8v2rfAJGCDaJFUNuLruKKd2WbfYkivtVvNGWw1nxBO8WphpLjUtH8n7MhtblSyAwRAk7gMtvCsUyDna2hqcGpax4IS1vort7gaxBCzIrRSvDFqCqJvkwVJiQSFl2gZLDaMYz9d0bV7bxNpF3513qsmxYpJXtg0ccYvrEj5ANivsWRy+ASVZhtVFVOb0j/AISzQvDttDaWV9ZwyfZ/tEiQP5wddPskVQot5ztyswJ8vho8F1Pyt3nhi48TaleXE2rSR29pC8LIkdu0fns1rCXUCRQyxLI0h5+ct8pKhCr7nk6x/bHm/brH+zP+ff7G/nfd/wCevm7fvc/c6ce9cm2s6/J4z1O0t5buSC21O3gt4Es1MDxNFA1x5soBKlFdnXJTLHAMv3FLa68VjwhpF9qtzdwT3SQC/FlZCSe0TyWJcRmMlpXl8sOuwhFYgKNpkOP4luvFd94T1G0eHUmM+mTx2ccOniRr4M0yEzjA8p/IEDgZjO+RgEcjyhuXWr+KRE1nYWs82r293fSuk1qUgkt9twbVfNIWNsk2oIV9/XdjD4p3+qa1Fo0kmiaj4gv3+0RrcyahpZtpLeIrId0IFnlyXCKcRS4B6J98XPDd54s1S/iS+l8ixS0hlkmNs6O7ie4BQCSKP5mRIfMYquP4EXzAyyeEL/Wr/Wb46jPqUtuqExmW0NvBktxhJLeKRTjooeYAZDNnaW5/TtD1rTNS1DVbXSrRbt7jVJrF4bExz3E5luPLiu5d43QMpR0OFUlUyylU8zQg1vX7O41DUJrrUp9B05La4MuoacttJPATOtwx+VTmP5JMBEYiFVCnfvfY1ODV7rwMn9oRSSXctxBcXtqihylublZJYMJ/rQsO6MgAmQKeCWxWfJMtlb2yaLbazoegyPMzPY6WzSiUCMIqW7RyGKJszE/uly6bsjfmQsbvxowkv9QMkUkV7YwnTYbVTGVljthcNv8AmZkRpJipVhtKNuZ1G1acU3i46V4eOoGe/mv4rO5vUk05AtpIl1aZULt+VtkkrMWJIaIsnlhcCvp/hG6T+wfOkvpNviu+vrnzLSD58faPLmkxEOuyPDcf635SMR7PQLqHWH1GB7O+sYrEbfOhms3kkfn5triVQuRgDKtg889K5fxxqPiWy+2/2L9uWRNPMlglpYrcrcT/ALzzBLkfLsURsnzLuZiAJSPLoe68Y/2RdXqc3Eeqm3tbTytplgN+F3ynyyVXyRtBUHCbpCWLDZX8V3ni7S7O6Swur64vI9PaW0az01JUubgmQyK4wfLWNfLMYLAnOD57AqZHu/Glvbve25kvLma91C2gsJbVY4o4kFy1u7tw2WaOFQ5ZUKSDjcd5x7nxB4rFxqNrptxqV1aQpZus91YCC6WJzch5AiwOxJkjjTmD7oJ2gfvjueG7zxZql/El9L5FilpDLJMbZ0d3E9wCgEkUfzMiQ+YxVcfwIvmBl1NZ1aa60HTNR0i4u10+8dJJryytTNPHbtGzI8cRRiSX8pSNjEK7HAxuXDvtT12OBDp97rk+LTfp7S6UFa+ut8gMV0PIHkxjEIDYhyrsdxxuWR7vxpb273tuZLy5mvdQtoLCW1WOKOJBctbu7cNlmjhUOWVCkg43Hec/T7zWrTxZPqh/tm60gJaRS3VxpRSeaALe5HlIgZiszxD5Y0YLtJUrl3uNqeus4bVL3XNOtJPNltJNN0oTySq1xNtWVfIkMe2EW+Ayo2XcNuYELGRq+max4lMd1rKW9xrEUk1xFYCV4rc2i4eACIiQ+aiRMAJCqrkgHLnQ0K48V3+r+TeSSW+mpbxSieW3CSzAT3AUYKgK8kSwNIDgpnARC+U3NU0PRrmeXVNQsPtMkcWHGx5dyKky7fLGd/y3Ew27Tnf0JAxwfh/w+s9v4Ms7m11K30+Xw5dWF7ZCxaKMSsIfNWQ+WHjLkSNuLLuMalT8x39Bp1/rVx48uIJZ9SfTo3kAVbQwwAAYG7zbcEjP8Uc7lmwwUISEw/E2h6p5PjjUdOsJ5prvzrWSBEw11A9hCqsg48xklXjk4VpwoLECtyC61+58QNatc6lC8lxcRXEQslFva2wEnkzQzNHh5TiAlS8gzI+UG0hM+HTr6f4AHTkOpC/GhND5T22yfesZBh8tkBxkeWPlyVwQSSGq5v1nTNYg0y1kvvLtpbW3s7ZLBPsk9oFjEsskixhY5FzPhA8Y/dxgIQwD7Hg5tduPD1je+IJcX09pCXthGE8pgnzFvlB8xiSWGAq8KB8pZ+TsfDWpQeAfDCPcak4t30mX+zmDboZBNAZd5+8UUBiEbhMseQsYj0PBWq+KrzWZodfSSMG3Z5onglCwzBlG2J/s0abBlx/rZicKVYgMzVyNX0zWPEpjutZS3uNYikmuIrASvFbm0XDwARESHzUSJgBIVVckA5c7E6X2p+AZV1FLtpWcn5bbdJLAs37tpYRtLB4gpliAVmDOgUEhRh2Uusafp0EWnWM9hYmWZom0/SnRZ5gIvKT7JKSbeFiZg2TGC0e/zI/Mybmj6p4okGi6dfvILzUbe0vpJ5IkRoI0jT7VEY8DnzAi5OCPtfyjERrcm0T+wfCmqW3hW38i+a0b7Iu/d++SBYouZCRwI4xzxxk9Sa4fU/D8Wo609/pFjA+kRafbRvdNYPNewHzrozPbuxDLco5DPkNJuOSGcBHueJZ/Ed7puv2KJqU881vqEMtgLH/R47fyphA8MoTMkrkQZUSOcyP8g2/JJe6t4xTTp2tFvpIxLCLieWz8ma3ciXzkiRYpd0astuAwSfIkf94wG9NDw3eeLNUv4kvpfIsUtIZZJjbOju4nuAUAkij+ZkSHzGKrj+BF8wMpoJ1TRPAniF4Vvr3U7S71KWCK8tdplfzZHj2qiJvV8q2VzkuwBGAq8frmh+JLfSbvRn0yeaGOKS4ieCaS8LySadewvl/Kj+ZnSNmAXJknLEkyADY1LW/HEOp63HDHOjJFe/ZoUtJZUwscht2jIttnmMViJDTuDuZdgYhV6ywvr7TfED6Xq97JcpdJC1pcNbeWrTsJ2khTaMBFSAMAxZhu+Z2ytYepp4kbxpJqtvp++1stQtLOF/PkBa3cIJmEQjIdc3DFmEijNvGSD5XzDaY5+Fnhi2vbWcNbWlqJ7eXT2u4wRBtKz2ykPIoYj5V5VwjEYU4x9VsdUjs7O4trO+ix4f1e3gsYrHzoGclGiDRujtEsigMsLt8uxIh0ZWk0vTtfi8UTRWx1LTYLy9kSe6htlJEQudVlGDIjKASYDnHSRf7wzoQ6r4rNlbG9OpQwXNvaXl5cQWAeezaVJzJDDGI23BJI4F2skjqsrFj0Za9nqHjyfTtVvLp7uCexspLmG0GnIpuZ1uLsLF/H8hjSEFUZmIKFZBkl+s0T/kYda+xf8gj93t2/6v7Zvl+0bP8AyFu2/Lv3/wAfmVoaZDrEXm/2tfWN1nHl/ZLN7fb1zndK+e3TGMHrnjj9FtIrfxNJcWFhfaba+UsdwU054pTMZYfluHYOLtmIl/fISI1MhLHzA45uPw5c3ekxW7adJHLFZRHWmbSHb7RcxzWj5lDMv207orol4yxKuQNxYb+w0eS50nwLrNxpWhWkFxAk81pFa6Y9mt64iBVjbH94hLDy8E5bYGBwy4x9H0rXtN8SaVp15YyfY7a9iuxOlw90Nz2d3FKzSGKMAlkjdht/1k7MSTIALGp6Zr0mqazJB5Y0+TxHpsxgNi7Syqv2LdIkgcAIuw5+Q42PyO1P+0/G09xaQLLqsXnxRi9caZGBa3LXVqkqROyEPGkbzFWKsCNzeZJtOzc0vVtX07UITrdxdvZXD3FuXntQojkju47a2IKIOZlk3nOQTyuxARVi50i+uvHWo3lreXdh/wASyzhS4RN0cg8258xdrfIXUFGBwSpK5BVmR+LfR9UttL1K3SLVba3ttQtZo5YbTz55EGr3TMdzxu8u2Mxyj73ZuQ7BtjxDLql/pPiSyubnXPt0tpfxQ6ZBpm+0kTy5BDiYQnLMmxseb987cD7g6zRzq8Gs31lqFzJeQLbwXEdy1uI1812lEkabRjYojQgEs43/ADM2RXH2PhrUoPAPhhHuNScW76TL/ZzBt0MgmgMu8/eKKAxCNwmWPIWMR4ek2/imwQaha6TPFff2fhs2hiWPdb6Ssm1QhAZRHPtUI3zREBG2lD0mh3/jLU7iztZJ5IreRLpZrua0kWSNQbYo37y3iDS/PMF+RUxyRIYyG7TU4dYl8r+yb6xtcZ8z7XZvcbumMbZUx365zkdMc8/4s1TUbTxDpFlbXd9bWNxaXUt29hZLczLseAIyqVY9ZNpwj8OcqPvpX0668c3Nlq1xc28EN3axK9rZ7BtuLg2cRMW48eSszSfMHJZuNyqhD1/7T10RSCC91ybSPNiEupTaUEvosrKXEcHkDcoZbYZ8luJZOflymfpF94p0zw/qkEtnfQ395FdtpqJp5YLfNd3bEtt3rGp325BkcpjkMwDGth9R10Xmo7LjVTq8f2r7Hph08f2fJtD/AGfdceV/EojY/vh8zFfl+6MvSNX8bXMttBG0kge9RGkvrSYbI2guCzOTa24KBkhICgEt8rOodcalzd67F40s9PjvdVnso/KSQxWgjD4ALGR2tjE+erFJo+CVVN6jfn+LvD95qPjK6v0sYHtItPtI5Lo2Bmu4F8y5LvZuCNsyZRuAzcqQGYKj2Lm88XXOvR2NvdX1p593dQzv/ZqPb2cYin+yyJIQN+7ETsMuN+FJizsboPDGp6jrf2rULuH7Jb/JbR2e5ZNk0eRO28AE4kLRY6fuNw4euX0eJ9N8ORnT9GvrbxDFaQR6xerZMhd98YnkywxdTAec6Ool5B6+YFe5YS+KNT1S3s49T1K30lkuWW/n09I7mVV+zbNweMLG+97hRmMbkQnaTiQR6VqPjG7tRq1758LC70+MaYtjtUpNFbfaCxYFyqNJKRgjayNvLgbV59vDerXfh7WbyWO+ivpfBVpbRwx2MSbZCkpkt0URZXlFBQcjze2I9npj6ffWmjWlho15aW72yJEJLqz8xSirjASNogp6dMAcgL0xT8QT6paaTY7J51zKqahd6daeZLGnlsd8UREh5kEa42vhWY9tww/C13401LUGj1cyWduiCWVpLVY3LC7uh5aD5lw0aQ7jvfCgbSTJ5gLa68VjwhpF9qtzdwT3SQC/FlZCSe0TyWJcRmMlpXl8sOuwhFYgKNpkOfZ6h48n07Vby6e7gnsbKS5htBpyKbmdbi7Cxfx/IY0hBVGZiChWQZJeTVNd8XWutRQ2Yne6mu7yJbKe0RbY7ILh7VUmO0t5gjR3wz4IILRfcaPSNX8bXMttBG0kge9RGkvrSYbI2guCzOTa24KBkhICgEt8rOodcdpNfXA0XVIdIk/tDV9OiaEC4UL5lyIVkQPjYvzb0J24Hzdscc2dRvhZE2mseJ7iA3CLeXFxovlz20WyQhoI/sy+YTII1b5JNqknC/eFc3vjSS11O7Wa7RLHTPtVnCbBd99Kstz5avlcgvEkBkjUK4Ljb5XKmn4gk8XXmqwiyjvmvre7vnij+xILe2YWt0loyStgNvDIWyZFDkAmLhG2NQ1vWLy8luLD+1bXQj9nilnTTHFzC2LgyNHDJEXfLfZVJ8tlwzYwQzLTvBq41nSNU0q61nUJ10fUo7db6wEKy3G6No0n/dRmIMV4JKA+UmDy2+SLUfFMl9aQ6RcX15YyXaI15rGnmB1zDcGQMgijPloVt2U7V3MxTzOTt6zUNAsdY02Gx1ZZL5IkZS8jbGctE8Tsdm0ZKSOOAAN2QBgY4PVNMik0PxNA2hX03iWWLVP9LitHBkhfzvJVpsATLsaFViDOQdnyjyyU2NQufEun3ktnLeX01ifs81xqNpp6vLCHFwHSCMI+5Q8duNpWR1WVizHhly7PUPHk+nareXT3cE9jZSXMNoNORTczrcXYWL+P5DGkIKozMQUKyDJL6j6jrovNR2XGqnV4/tX2PTDp4/s+TaH+z7rjyv4lEbH98PmYr8v3Rj22u+Kzod/5txfCRZYRC5065ac537wG+wKqr8qEHyJMfMCQXQr0F7Lrsvw4UW630mrXflwFp2EUyrLMqNIGjjXy9qMWVjGGUKC6ZDLWXoy+L4dUXQkgj03T43u182PdMkMR+zSR+U7RqGK+bPGi7VRQvIfysMRz+IdW8WXui61BJ/Y929zbTW5im8o2xVwhSRLcKrsoQkm4YfM42q2FTpNbsX0/w1PDpEc8atdrNOLdmMhikuBJclMfNuKNKRs+YE/Jztrj7Tw/u8YzatZWNimitqFt9mvbKwzcrGttbeV5MqnH2ZiGjfapABYfdZmjj1G68V32jqiQ6ld3ge0uLy3m08Klpdpd27COA4jEsWPPy3mOMRqTIoO5rGpav4vjsoTZNqUmnm4lVL+S0aO7kUJEU3xLaylRva4H+oTiNDuGR5m5oEninV5L06ndfYbdPL8pre2KO7PaRFtgmTKxpI0jDcCxb5W2hCr5+nR6xb/BfSrOxjvjqb2ltZMs6PbTQb3SKTBCbk8tWba+1sBAx38k4cmma9/atjaXGkSRQafe7IBbb5okha90ycBXKICiDzlUBQFSErzsJNiw1rx9OJYpRJBeO9v5iSWMsqW7m5hWQIfs8SGII0u799KSFBV8Aue00TULiHU7zRNSuZ57iKVzZzzwhHuYFjgZ3JRVQ7ZJ9nygdMYJDGuD8QWviq4h129GlSOmpJqmnsscsruYVhlWD9x5Y2jdApU72BNzIQo80bes8dWMV19gkuLf7RDH5i+XPpD6nbbjtwWgjYOJMA7ZOVUGQHBdc4clpq8XiEztbakrz2WiZtJoheRQ7Lz98pnKHc8asW3Ft3zs/wDCpTH8Ow+K9H0VvscGpWpt9MN59n+xgi5nhsNPWOF9yFsFhMpVCrEqwBBXjqLq98UWl1LZedqUtvbXEkdvepYJLLdyeVA8SSKFVPKLSXCs48oDylBkQ5LV9CvfGkumw6jqE135kdxp0RsWsFTzFlithcO/y7sI0kzDbt2sjbiyjavQeGhM2m6ounSRx6cbgjRndC8Sw+VHgquQTF5vm7RkApt2EJsrQSHUl0a7j1SaO/nZH2jTYmtGZdv3VLSkh85w29cZHTGa4eCwuRpviOPw7bXenJdW7R6dHZac+nRtP5VxhWjkXKOMxE3GUVyIlGNhDEOnaeE1V49BkGgukIit00SaOBbgNcfPJZfK8wCtbBiFIZlVht8vMehJpVzcfDiy097a7Utqds3lxb4nSD7ejBkVcPCgj+ZUzuiUBScoTVfXdG1e28TaRd+dd6rJsWKSV7YNHHGL6xI+QDYr7FkcvgElWYbVRVSvph1fStONpNf+IILQanqRnu4NLEtx5huN0IVBAwaKRGkkLhCN2AGUYSrlhFrtpfanqdrcX0tvLqtiEgmsQj3UckNpFLNJlQw2ruOEEYVkfdkfKupc6RfXXjrUby1vLuw/4llnClwibo5B5tz5i7W+QuoKMDglSVyCrMj+d6roWsLp2oWMGlX0kMf2/wAljbvJI+4awFzIQXfIeHG4nmVSOZMnoNS1vxxDqetxwxzoyRXv2aFLSWVMLHIbdoyLbZ5jFYiQ07g7mXYGIVfQLWHVBp05ubqAX8250Aj3w25IwqAfKzqMZJJBYliNgIVcvWrnWtH8C69fXF/aS6hbWVxPBNa2hhVCsRK5R3kyQwz1weBj1w4tR8YyX1pDaefJHJdolxLqFj5SwuYbgzJtUcwxstuVIY72bZ5zA5Fye61+28QLarc6lM8dxbxW8RslNvdWxEfnTTTLHhJRmchQ8YzGmEO4B+fS68Vya5p+oyQ6k8tvZMb3fp4Vbd2urNrqCEgZlQRJJswrFsHZJKeE2LrV9auLqW4ebWbHQ5riQ29xaaWXulCxQBEMLQu6oz/aiWaPOUT5grKGryav4qj8WWUMbXbaYz2yxPPaS4uIWVPMkmVLU7JdxkGDLCFKqWQLnf0ng5tduPD1je+IJcX09pCXthGE8pgnzFvlB8xiSWGAq8KB8pZ+D8KaLrXh3w/bypp8dldtplqB/Z2mmNmiYw/aHnBLeZdRLvKKV53MQrlnRNi117xRp8N1qN1Fd3tpHetZ21vdW6WbzrJDD9mkJxwWmzGeBg3BZljEZRdjxDYzf2RoMWrLJq9pbXC/2ttszILlRBIoZrdA24GYxNtAO04bouRl313qllAkWh22q2Fqtpv0m0Sy8xLmcvJ+6nyrm3hwINoJh2rIwyuzEcepXvjS00a8v7ea7nuZLjU7eC0SwX9zEi3LW8mNpZnLRwqCfkZXUbSx3m5cxeIh4lsdOmuJ7m381JzqK2MY+ztJb3quIiVZUVGSHbu3MPN2szh8HL8IeFZ7G48ByzLdoljoVwzxSWkSrBPIYNyn92Crne46hj5fJOZN/eeTrH9seb9usf7M/wCff7G/nfd/56+bt+9z9zpx71y+t6j4lh8Q+VZ/bhH/AGhaRpDDYrLA1kzxebM0hHyybjKhAYkIN3lgfvRHY3Hjd9D8M3M0kY1C+eJLuCS3Pl26fZZS0kuFDbzJsYqNgyEjBX5nY1S98UWesxWttNqUwS9soRtsEkimsy0ImneQKAsu4yqQp4QZESj96te2vfGlvomlzXM13c3F9piT3xFgqtYsHt1fy0C583ypJ32Nv3PF8qAZjOXL4h8YyJdpBLfPawag8P2gWfl3Kp9nt3hDRpbzkbxJK7ZiXnAPlcRV0mj6trwj1HVfEVxHZ6XYIlw5jtXXzR9jieQBXQOIlcynvIW+U7dhV9DxRdX1vcWSx3OpWenukpnudMsvtU4lBTy02eXJhCplJbZwUUbhnDZf9o67/bECQ3GqyfvbVbaGXTwsNzassfnTTyeUPKmGZzs3R8xoPLOcPTtr3xpb6Jpc1zNd3NxfaYk98RYKrWLB7dX8tAufN8qSd9jb9zxfKgGYzH4e1DWNK1rUb7UoNVfSrm7mzIdLczTN5FmsEjRRqzDKJNkgKu7IZUbCLc0q818XVhB4jvtZs7wJar5NjpyzW9wTFGZGllWF1QmYyqcOgCqpAAO45+mHV9K042k1/wCIILQanqRnu4NLEtx5huN0IVBAwaKRGkkLhCN2AGUYSug8MTeK7+8uJNdEdlFA8J8iOMfvHa1hMiAkEeUsrSHcGYs3G4BCHPFPhy0+y3Os2ljJLqEVxDeyCIu7zLHLbSSIiZwXZLSNVGByo5GSa5fVNE8VTXNstz5c13ZvbyLcJHLNHuuL60lYDOCyRPbz/LldsRh5yWIua3qPjHT2ezt3vpbS3u3i/tEW/wC/mHlQOmRHazKV3STqSsKj90oLBsh7lje+L5RJqNzNJiO9sYksYbBkjkjljthcP86+bsQySsv3SpRt5YDasnjjUfEtl9t/sX7csiaeZLBLSxW5W4n/AHnmCXI+XYojZPmXczEASkeXVzxXa2kus6XNrGmSajoqW9wskAsXvFFwWhMTGJVY5CrMA+3AyRkbgDl2FtrunX2p31qt9DbtqtiiWE0QleWN4bSKV5JSXZ9i7juRgA0blmccDH8PP4l0/TUJtL6x8/yZGFvpqkvcrYWSxwmPAVISwnViPLCmML5kffQv9OiPwj8K2eqaPPdSQf2V5lqdPe4ePY0Rl3RqrFcRiUHI7lerYOpp1/rVx48uIJZ9SfTo3kAVbQwwAAYG7zbcEjP8Uc7lmwwUISEw7jS52+I+pXCadm4fVbSSKddJlWYwrDbhyl9/q0jAWQNGRlwHQEFxiwmreMfs0TWy31xfN9nN/b3Vn5MNrObmBWihcRfPCUa4DSDztqxq27u2hqh8XWkuqvb6jPOun6Ul5CkVgmLy73XDGFeCfLwsalATJgphwdxfqLDRNO0u6uLmzt/Kmuc+a29m3Zlkl6EnHzzSnj+9joAB53pHiDxpe+E4L63+13l3PpkU9yZrJYUhZmh2tAVRvMLQtNIcCXDIo8tCfJOhod/4y1O4s7WSeSK3kS6Wa7mtJFkjUG2KN+8t4g0vzzBfkVMckSGMhg2Gp6TrHiXUIptSjjv9YiW4u4LGOWeO2W0Uq0KiImQCUrFyrgKGOA2960NCuPFd/q/k3kklvpqW8UonltwkswE9wFGCoCvJEsDSA4KZwEQvlM/SLrxhHa6dPd3OpXEn2fTJ54p7KNQ73Mvl3MbBY1IEKrvABBUsS5ZcAU9L1vxxIt4t9HPHN5SNcILSVzbHzYxKbcm2RG2RtMQu+4LFE27xu36miJr/APwj3jKe2S7/ALUnuJH02W6tlgecizhWGQo3ygkqM5CjIOVTlFj8T6p4lv8AR72Ow0mcQyxXMsKvZq5mthaSqqyI+794bjyyIyoJR1BBKyqtOTSdXfxldpb3epIW8RrcC4ksg0cMLaY6F422BSc5iBJYKVj3KSTv3L4apf8AgeSO8gnmmi1AR3CmHD3FpFeBXZkA+fzLdCSqrh9xCrhgtcvYya3HdRyafpf2a1sYrq2hmstElslWCSWweSRIJNx8wA3JUYO9ouFbkHQt9W8XM04mbVRardyLZz/2UnnT4itzbpJH0Echacu5MWGXBaD7gk8MTa/Yab4c8PuJIXnsrK4WSSNVa2giijFzCUIyTvWNcnDD7XkD90a0PCF/rV/rN8dRn1KW3VCYzLaG3gyW4wklvFIpx0UPMAMhmztLY6W2tabpOtXRs7uS7R9Wl0Xy7cv9nnM1wwLRkHLupBSQ5UqdgClv31zWJPF1nqsVvax/2vNDi6gmmskWMTva3oMasMbIw8cABLbwJdrSEMKy1n1/WfF1nYQ6hqTWlpcW88F5eaYsU8aSW9+kkjJtXB3KEVnRQCE+RxzJsWCavN4z0G81CXUgI7fVLI4tB5b7LhBE8jCP5DJGgfOVUlF2gAlWkLX+n/EW7uhY300Vz5cKt+8aIRN5C+YWVCu1WEgWPO5GaRz+7mZ4qfxF06+ub95LY6lKkvhzVbVYLa28yNpWSMqjEISpfBIywyYlA6sGk1688Y6X9ptbWWe9j/0aaW9S22NEH88SJCEilyqtHAApjlcLKdzYw6yalDqviH4Z20N5BHPfTXtqsiS2cjKUW9j+aWJ0iZhsXL/KgOGICqRjL1my1nwbHZnRxA0km4D7LpyJbwvJd2MQhiRn/dq6+YSnmLucu2QQCtjUdY8SRaSn2W71VozduLed9MkS5nhEaHdIFtJRHiRpFCmFCwVWDYBL9Brvm/2Lo/8AaHn/ANm+an9sfadm7yPJf/XeX8u3zfK37fk27s/u91c3e2SxaX4ixoN3P4oKam4uhYM4kibzjAjyEbJ02GFRDl8HYCg2HbsLceKzo+o3s0kkZjvZoIYorcNL9m+1lTPtK8usAPlqoYNjcfMLhVjvDqmp/DfxVA6315vtLmLT5Lm18q5uUNuPvRBEIbzDIgGxchVODnc1f/TLGKSXQre+0rw1LLEhS208ie3wspklhtmjYqrP9nTb5f8Az1faN3mGnYXvji7R5r2bUraRHhi8lLCJVPm388Mj4KvzHAInGHZRhWYupO6wt14wmuZ83OpRR27wWiBbKPE6vfT27ztmM/OsCxTfLhASGKlDtMYvfEq39y9xHfW9uvl21xqFtpqvcmKOe+VZFURt5jNttiQEZQJmZVQNuFyfUb4G3EmseJ4dPNuGgu4NF33E8vmSCRZo/szeWFURbfkTcGJy+MiT+3NU0/WJ7rUZ75LW2lunv4HssWltZRrI0c0cojy8hCwkqJHP7yT5Bt+STxd4dm8QeKtFVbTTZoIbK8Lvqemm8gVi9ttG3egVyA2DnoG49JFHiWCTX4tMggis9Nyuj2nkqi3BFpHsi6KFhWQtyDktxuRUIbD03WfFUtlMt3PqSWi3EQmuo9Plku4YykuSivZxK43rAuFikKh3JIG0rueGJ9U0vwObm80yd77+0LqW4thHscI95IXdUBfOEYuFUvuwApbIJ5u7uvFel6FfnTIdSgldL2902KDTxN9oeW5uJCJgwzGViaF1UlDuYjbKR5ddI19eyaxeaPq0kH9m2fn3d/cXCx+XNZSKwijdTwq5Mqls5xaZYYlFaGiprEnhUKs/kXhll+zSX8Lylbfzm8nzF3K5bydmdzB88tlsirF9C/8AwjkkWtxf2n0+0pY27IJE3gn91vZmUL95MtvAYbW3bDw40V7rwhfWJgnitXu1uYbWPRWFpJFHJbOxFo2HjXcjgxb90mZXVX3KAPDpsHh6GC48IQSiS7kW28nw9cC0IKJuupbMKzIy4Mahvnbb8rIjsy9p9uOi6DpLxw6lf2ipHFNPLHJJdLH5ZxI8YTzHcsEDAKCC5YgBTXF6dJ4u0bTtD0sR30U1r/Zlq9tDZJNB9lxAs8jS9pA5lQgM2EG7ywP3okuJ9a1DR41ll1m61oXFjNPptxp5hs4ZVu4GkCTrBkopDDcHk+QFvmxmug1NL6/8DJ5yXdxObiB76F7bY7RLcqbiPylzuTyxIoUF964AaTdluf03UNVgsltBFd6RotvcTRx3Oi+HpIHY7IXQC2kSVlQtJc5bbgmNfmGcMWlx4rtri7mubS7sZ7u4Web7HZicPdiys1SLBJHkFhOGfcoBjA81Op6Tw7Z6xF8PPDlrZywWF9Dp9skwvrR5duIgGUoHQhs46njBGPSPxbqOr6ZaaBHb3Uiz3N6ILyWzsxIxjFvM7tHGxJBBTcBlz8oGJPuNX0K48V3+r+TeSSW+mpbxSieW3CSzAT3AUYKgK8kSwNIDgpnARC+Uz7fVfFbWrMDqUk5t1bU1lsAgsJTLEHW0/djzwsbXJH+uyYo+W3YePw9qGsaVrWo32pQaq+lXN3NmQ6W5mmbyLNYJGijVmGUSbJAVd2Qyo2EW5pV5r4urCDxHfazZ3gS1XybHTlmt7gmKMyNLKsLqhMxlU4dAFVSAAdxx7DXfHziVZbeQ3he3MltJBKEjc3MKyIkn2VUEWxpQzb5yAAysQpY9h4gsr5vCP2eaWTUJRcW8l55cOPNgFwjToI1yWTyt67PmZl+U7yeeL/tTxPaaTHa6Vp/2LTILuWJJtP0eaxLDy4nXEDQXDBS8lwCfLAJjHzLnD7lje+L5RJqNzNJiO9sYksYbBkjkjljthcP86+bsQySsv3SpRt5YDap4K1XxVeazNDr6SRg27PNE8EoWGYMo2xP9mjTYMuP9bMThSrEBmanpPhfVLJdW16ytrGPU0u9TmtIVsfInunaWcRJPMXHmQtlWC4XpGd3y8iar4lN5dRi61xtEX7Nt1B9IVbtUIuPMZYvLJdvMWBCDEMIc7MfvWyz4l8dSWdtcBZFKvcruS0dleaO6mQxypBBcEIqpEMB0Jy2JHPzL6ZqcOsS+V/ZN9Y2uM+Z9rs3uN3TGNsqY79c5yOmOcvxRd6vbXFkunm7SBklJe0tRcM9wCnkxOp4ETAybmJQDav7yPPPN6df+Obnwjq17cvPDd2unrLax/Yx59xcGwiYrsKY2rM0hwASz/L8qoVfY1afxLZ/ZC08+6fzZWGn2i3CpOPLENtggEwkeYWkYx5YZ3whgoy9CvfGkumw6jqE135kdxp0RsWsFTzFlithcO/y7sI0kzDbt2sjbiyjaufJ4g8aJMlvF9rku5NMknuIJ7JYhBcLNbLMsDBC0iRJI5QhJAxPWc/Kuhod/4y1O4s7WSeSK3kS6Wa7mtJFkjUG2KN+8t4g0vzzBfkVMckSGMhuo1XVJrjw7cXeiPJI6XHkSPFEWeNUn8u4ZEIO50VZCow24qMBs4PPyajfC3tvL1jxOdPZ5vPvjov8ApaygR+XGIvs3+qKmVi/ln5lA3j7pLG78aMJL/UDJFJFe2MJ02G1UxlZY7YXDb/mZkRpJipVhtKNuZ1G1cdLrxXJrmn6jJDqTy29kxvd+nhVt3a6s2uoISBmVBEkmzCsWwdkkp4TYutX1q4upbh5tZsdDmuJDb3FppZe6ULFAEQwtC7qjP9qJZo85RPmCsoavONXtPEepX1ldazOLnR9PCyS2AGIxPIJ3AEQ/fpGxkEZGS0hHlsAqrYsLrxXe6pb2dvc3Y0uVLkDUb2yEU+wfZtrlDGoEu5rhEVlQFQHKybfn6y/0TTtUure5vLfzZrbHlNvZduJY5egIz88MR5/u46Eg8fbaAnh9vFN7omhwWNwdQhjhmtbFRItoYrXzmhAX5tv71goDAuv3WPyk/tPXTFGJ73XIdI82URalDpQe+lwsRQSQeQdqlmuRnyV4ij5+bL6Gq2OqazZeDjfxz2d+LtZr1rFv+PWX7HPkg/MNokIX5tytkKdwbBz2g1jQfGkuoyPfXlrLFZnUriK1eQOuL4bIolDEKrtb/KmWAIZicuxG1PXWcNql7rmnWknmy2kmm6UJ5JVa4m2rKvkSGPbCLfAZUbLuG3MCFNPn1Tw1B/aN9POmlNquptdW5tPktrUPdTickAuWLIuDnaVkUBS2GOx450Kz1vSrP7RpUF/NDqFns8y3ErJGbqHzcZBwpQHd22g54qnPPq9l4gWxsUu4IIbi3hsrCCxH2KSzxGJXeUJiN0Bn2r5if6uP5Du+eTwtf67c6jGuoPfPutGfUI7qzEMdndZTEVu2xfNj5m+bdLxGh3c5bL/tGWDwZ4k0eLTtSbVGfV3gjfSJpIpC0s8kfzNGYnDArgEkNkDnOKp6xpmoj/hKsXmuD/ioNOvV8mxWTMI+zZaPEJ8zZtbgbiPITcOW317q+8YaOWisLeeC1+1308J+zTSCWRr24bEqx20zeXs8phgxFg7bWbqnpBGl+I9MmilggvrFpXhkinh3IzxSFWBVhzh0PbtkdjXD6TZ3Hh7wb4YtIIL7RbWXT1k1CXS9MEtz9r8uIBXj8qQ/MPNLMUzmNQWGcNct9T8Vvf2Yvo7u31BntAbCC0D2TxMkZuHeba210Y3G1fNXPlR/K2759C51KPRvHWo3F3a6k0FxplmkUlrp09ypZJbksCYkYAgOhwcdRWeb3xRP4ntrPztSggmvbmK78uwTybWERzfZnjlZSCWAjdv9YA+FJj/1b83aah4w0jwv4btrFL6OGDSoR/pFlNuNwpZXimjjtJH8tAsYH+qLKSQ7n5l9QsNE07S7q4ubO38qa5z5rb2bdmWSXoScfPNKeP72OgAHnekeIPGl74Tgvrf7XeXc+mRT3JmslhSFmaHa0BVG8wtC00hwJcMijy0J8k6Gh3/jLU7iztZJ5IreRLpZrua0kWSNQbYo37y3iDS/PMF+RUxyRIYyGDYanpOseJdQim1KOO/1iJbi7gsY5Z47ZbRSrQqIiZAJSsXKuAoY4Db3rQ0K48V3+r+TeSSW+mpbxSieW3CSzAT3AUYKgK8kSwNIDgpnARC+Uz9IuvGEdrp093c6lcSfZ9Mnninso1Dvcy+XcxsFjUgQqu8AEFSxLllwBT0vW/HEi3i30c8c3lI1wgtJXNsfNjEptybZEbZG0xC77gsUTbvG7fqaImv/APCPeMp7ZLv+1J7iR9NlurZYHnIs4VhkKN8oJKjOQoyDlU5RY/E+qeJb/R72Ow0mcQyxXMsKvZq5mthaSqqyI+794bjyyIyoJR1BBKyqtOTSdXfxldpb3epIW8RrcC4ksg0cMLaY6F422BSc5iBJYKVj3KSTv1NaW81HwAYtWsp7xotVijniNmZHnt4dQUb2iVfm3RJvO1cHJIABArL1KfxNpdlCNHgu7XRZriV7ZI4m8+2iCRCOMoLedkRm+0OFMY2L5alo8eXWhY3vi+USajczSYjvbGJLGGwZI5I5Y7YXD/Ovm7EMkrL90qUbeWA2rj6NqnjK3utAtZ7WS0tvs9jH5AspBEUaKMSl0jtmEbhjKoBliC7Eym0ZfQXVPEf9iXU0VzrMuvC3Rriwn03y7W2Yugm8iUW58wopfZhptwGdsve5p0et+J/h5runX0n+mXMVxaW0lzFLE2HiABk3wQ5+Zm5SMDaAOWBJw9etvE2p6fJeGzkkE9vd6tb20tu0jQH7JNAlu0bAqHZZrZvKwQXFz22g14LPxHp+vXd1pujyS3BuLloPtFt8jN5msPH8zY2gs8HzBl4lUZw/Opb3fiq/16Kxg1LXI9IeWAJqE2lxQzFDFdtIWDxYH7xIVy0acbMD5g7j6x4sj0PfO99FcXNpZXeV052eKWXzTNboY4JNip5acvHIw3FWOXVl3JZNXl8AwSE6k127wtclwBcGAzL520RojA+Tv27USTG35Vk4HJ6xodx/ZPi/UfDth50F3FJaxwWiAJdWj6dAsTQgYEmyRflwSArTBQWIFbhvfFE/ie2s/O1KCCa9uYrvy7BPJtYRHN9meOVlIJYCN2/1gD4UmP8A1b17Kx1J/g74ds4Fu/7QhfTFK3dmweFo7mHdujAQlE2n0yq53HO409ZudZ0SOzn0yxni1Iboryee2SdprmS7sU4lYIHWRGYKA0Y2qFxGYtsepYS+KNT1S3s49T1K30lkuWW/n09I7mVV+zbNweMLG+97hRmMbkQnaTiQZ9pr/ja41vSXvLSSziuEs2e3FrMYisiRmbeFt3KOrtKo3Tx7diFlxkv0nhfUNUTRdGn8T3Pl6lqcUUUdqIdu2UQtI275QRIwV2YHCrtCgZBZ6fie51q51O3h0vSJHvtMuJru1aQEwTp9imRCX+VQTNKI/L3bsDdwpyMt013VdV0mO0vdVlsYdQV01LUNNEM8TNa3ayjyzHGNoBh2uyFd8nO/GwSNe+NGi1iZZrtBpdk8lrD9gUtfzRz3SICdvIkjihLKgBO9ShjBw3QeKINSguLLWdHijmv4ElshHKrMm2coA5C84WWOFmOeIxKcE4rn5Rr+gXFjo2ltqRtLK4sLOCNbJZYnsAYVkmeXA2y7vMQgE4QbvLA/erzfh608U6Va2K2FhPa3DRWsZln04yeXmLSI3zkBgu0T7lDL/q2OQUyvSa1qPibT4ZrKK81KQ296Y4rlbBjLcxeTE+5nitZowA8jpgRLu2j5gUffuaX5v/CURfZvP2/2f/xN/N2bvtWIfJ8zZ8nneX5m7Z/D5efl8qti1h1hNRne8vrGWxO7yYYbN45E5+Xc5lYNgZBwq5PPHSuPYabJ4vvJbaw1XTJ7bz/M1GHSbh57xzG2f3rRMrQpn5EJbc6RhVCogkz7bQPsuuapDHo/nXVxLfyNeW2kfZb62WXzXWSO9ZzFI3zqiqCrAOC23Y61seArGe11HVZI7eC30ySK3WGO20iXTI/OBl8w+RIxYttMWZOAwCjnYcU5r3WrjVJ9XWy1LS4J7eytNQeC1M09s8f2p5BCpjbzQJJIE8xUdSrsV6Fljs9V8Sy20R8Q3WuaX/rtj6bpCzPI4uZlKugjnCKsawFTn5t7HfJjI2PB41SC9vba+gntrX7Xfy2qeT8kwa8kYu7kZVsFdq8AqxYF8kRc+G1vSdcuX0zRoLnW7iXUFkln0mUu6fv5bbN7uEZjIW1j8snjplSuFku5/EdxcWk2lJqWrJZ3DTWc2qWP2ZzcGyvFKOuyLEW424DFQCZSN56LseERfS+KtaurhtSntGsrOK1u9Qsvs0kwV7ksCuF5Vnx9xDjb8pBDv0mmQ6xF5v8Aa19Y3WceX9ks3t9vXOd0r57dMYweuePO9G8QeNL7w7pl7b/a7y7uLezluVuLJYIkZ57cL5bqjbkkhaZpGG/ZgHER+StzXLnxLp8vkxXl9NcLaCSyNrp6vDe3ZaQtDMQj+TCP3KqSyHa7ZkYqWXH8QSeLrzVYRZR3zX1vd3zxR/YkFvbMLW6S0ZJWwG3hkLZMihyATFwjbGoa3rF5eS3Fh/atroR+zxSzppji5hbFwZGjhkiLvlvsqk+Wy4ZsYIZly9a1nxVamybSZ9SuLP7PviubzT5Vknm8x9yzxRWbsEUCPGBCWDHDMeV6zw42u3L3dzq8vlwx3d3DbQeWFZ4xcOEkclRj5AoULwVyxLFwE+IKK+/6KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK//Z",
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=256x200>"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.to_PIL()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=256x200>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.to_PIL()[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluate Readability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Results of 0.1M Checkpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [03:58<00:00,  4.19it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'paddleocr': 0.103, 'tesseract': 0.117, 'union': 0.131, 'readability': 0.366, 'readables': [1, 5, 16, 22, 23, 24, 29, 31, 32, 36, 37, 39, 42, 43, 45, 46, 47, 58, 59, 65, 68, 69, 71, 72, 74, 78, 79, 81, 84, 87, 89, 93, 96, 99, 102, 106, 108, 113, 116, 120, 121, 125, 127, 128, 130, 132, 135, 137, 141, 145, 147, 148, 149, 151, 152, 153, 156, 160, 161, 164, 167, 168, 169, 172, 173, 175, 176, 178, 185, 188, 191, 193, 196, 198, 199, 200, 203, 204, 205, 206, 209, 214, 215, 218, 219, 222, 223, 228, 230, 231, 232, 234, 235, 236, 239, 242, 244, 247, 251, 252, 253, 256, 260, 261, 266, 267, 268, 275, 278, 280, 281, 283, 286, 290, 292, 294, 295, 300, 302, 306, 307, 309, 310, 311, 313, 314, 316, 318, 319, 323, 328, 332, 334, 339, 340, 344, 348, 349, 352, 353, 354, 358, 360, 361, 362, 372, 376, 379, 380, 382, 383, 384, 385, 388, 389, 390, 396, 398, 399, 400, 412, 413, 414, 416, 417, 419, 423, 424, 426, 427, 431, 438, 439, 444, 448, 451, 453, 454, 456, 458, 462, 464, 471, 479, 481, 484, 487, 488, 494, 495, 510, 511, 516, 518, 525, 526, 528, 530, 532, 535, 538, 542, 543, 555, 556, 566, 571, 576, 577, 581, 583, 585, 586, 590, 595, 604, 605, 610, 611, 612, 617, 621, 622, 623, 626, 627, 632, 633, 635, 636, 639, 640, 644, 646, 648, 649, 651, 652, 653, 657, 662, 663, 664, 669, 672, 673, 674, 682, 683, 684, 685, 686, 689, 692, 694, 695, 698, 703, 704, 706, 708, 709, 710, 713, 714, 715, 716, 724, 728, 733, 737, 739, 741, 742, 748, 749, 751, 752, 753, 754, 758, 760, 766, 767, 769, 770, 771, 773, 775, 776, 777, 779, 784, 787, 791, 793, 796, 797, 801, 804, 805, 807, 808, 811, 813, 814, 815, 817, 819, 820, 823, 826, 827, 834, 836, 848, 854, 859, 860, 862, 869, 871, 873, 874, 875, 879, 885, 886, 889, 891, 895, 896, 897, 902, 905, 907, 908, 909, 914, 915, 918, 925, 926, 931, 934, 941, 944, 948, 955, 957, 962, 963, 964, 967, 971, 974, 979, 982, 986, 989, 990, 992, 994, 995, 996, 997], 'correct_samples': [5, 37, 45, 59, 69, 72, 73, 74, 81, 107, 127, 128, 130, 135, 160, 168, 175, 178, 185, 188, 196, 199, 209, 214, 222, 231, 236, 252, 256, 260, 261, 267, 278, 280, 283, 302, 311, 312, 318, 320, 323, 332, 339, 340, 354, 372, 378, 384, 389, 396, 399, 416, 438, 444, 448, 453, 454, 481, 485, 487, 511, 512, 517, 528, 532, 555, 566, 590, 605, 611, 612, 622, 623, 626, 635, 639, 640, 648, 649, 652, 657, 663, 669, 672, 673, 686, 689, 703, 714, 715, 724, 737, 739, 741, 748, 758, 769, 770, 774, 776, 777, 779, 796, 814, 830, 834, 835, 850, 859, 861, 862, 871, 873, 879, 889, 895, 896, 897, 902, 915, 918, 934, 955, 964, 968, 970, 971, 982, 986, 989, 995]}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "result = evaluate_babi(generated, vocab)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Results of 1M Checkpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [03:59<00:00,  4.18it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'paddleocr': 0.158, 'tesseract': 0.168, 'union': 0.181, 'readability': 0.397, 'readables': [0, 4, 5, 8, 9, 12, 16, 19, 22, 23, 26, 29, 31, 33, 34, 43, 45, 48, 50, 52, 54, 57, 58, 59, 60, 61, 63, 65, 68, 69, 71, 72, 74, 76, 79, 81, 84, 93, 94, 95, 100, 108, 112, 113, 116, 122, 127, 128, 132, 134, 135, 136, 137, 138, 147, 149, 151, 152, 157, 160, 161, 164, 168, 169, 173, 175, 176, 178, 181, 182, 185, 186, 188, 190, 191, 194, 195, 196, 197, 202, 204, 208, 209, 210, 214, 215, 216, 219, 222, 229, 231, 233, 234, 235, 236, 243, 247, 251, 252, 256, 257, 260, 261, 266, 267, 269, 271, 273, 274, 276, 277, 278, 280, 282, 285, 286, 291, 293, 297, 298, 299, 301, 302, 304, 310, 311, 313, 314, 315, 316, 318, 319, 320, 322, 323, 325, 326, 328, 330, 331, 334, 339, 340, 343, 344, 345, 346, 349, 350, 352, 353, 355, 358, 359, 360, 363, 369, 372, 375, 379, 382, 387, 388, 389, 390, 394, 396, 397, 399, 403, 407, 410, 412, 413, 415, 416, 420, 422, 423, 424, 426, 427, 428, 431, 433, 434, 438, 439, 440, 441, 442, 443, 444, 447, 448, 449, 450, 453, 454, 456, 458, 461, 464, 465, 468, 477, 478, 479, 481, 487, 488, 490, 491, 494, 495, 500, 502, 503, 507, 511, 516, 517, 519, 525, 526, 528, 530, 531, 532, 534, 535, 539, 542, 545, 551, 555, 556, 557, 561, 564, 566, 567, 571, 573, 574, 578, 580, 583, 585, 587, 590, 595, 604, 605, 609, 610, 611, 615, 617, 618, 621, 622, 623, 626, 634, 635, 638, 639, 640, 644, 645, 648, 649, 651, 652, 653, 654, 657, 662, 663, 664, 667, 671, 672, 673, 674, 676, 684, 686, 688, 689, 690, 691, 692, 693, 695, 699, 701, 702, 708, 710, 714, 716, 720, 723, 724, 726, 729, 739, 741, 745, 747, 748, 749, 754, 756, 757, 758, 761, 762, 763, 765, 767, 769, 770, 776, 778, 779, 790, 791, 792, 793, 796, 797, 803, 804, 805, 809, 813, 814, 815, 820, 823, 829, 834, 836, 843, 848, 851, 853, 859, 860, 862, 871, 873, 875, 879, 880, 886, 889, 893, 895, 896, 901, 902, 905, 907, 913, 915, 916, 922, 923, 924, 931, 932, 933, 934, 943, 955, 958, 959, 960, 962, 963, 964, 967, 971, 978, 982, 983, 986, 988, 989, 991, 992, 995, 997], 'correct_samples': [5, 12, 22, 44, 45, 50, 52, 54, 59, 69, 72, 74, 84, 94, 107, 112, 127, 128, 135, 137, 151, 157, 160, 168, 175, 176, 178, 182, 188, 195, 196, 201, 208, 209, 214, 215, 216, 222, 231, 233, 234, 252, 256, 257, 260, 261, 267, 273, 278, 280, 289, 296, 297, 302, 311, 312, 318, 320, 323, 339, 340, 344, 355, 359, 372, 378, 388, 389, 396, 399, 407, 412, 415, 416, 438, 444, 447, 448, 449, 453, 454, 456, 479, 481, 487, 491, 511, 512, 517, 525, 528, 531, 555, 566, 572, 589, 590, 604, 605, 611, 618, 622, 626, 635, 638, 639, 640, 641, 648, 649, 652, 657, 663, 669, 672, 673, 674, 675, 686, 688, 689, 690, 693, 695, 702, 713, 714, 724, 739, 741, 745, 748, 753, 755, 758, 762, 769, 770, 774, 776, 779, 790, 796, 797, 809, 814, 818, 830, 834, 835, 850, 853, 859, 861, 862, 863, 871, 873, 879, 882, 889, 894, 895, 896, 915, 916, 923, 932, 933, 934, 955, 958, 962, 964, 968, 971, 982, 986, 988, 989, 995]}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "result = evaluate_babi(generated, vocab)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Resultsof 1M checkpoint with 0.1 temperature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### 4. Results of 1M checkpoint with 10 temperature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "School\n"
     ]
    },
    {
     "data": {
      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/wAALCADIAQABAREA/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/9oACAEBAAA/APf68v8AC/hnVPDfhDTNUt44La8W0shcWthpvkSPF5kLTmdSzGaZY1kAIVWBeTALOAJNQvNau/FkGqD+2bXSCl3FFdW+lF54YCtlgeU6FlLTJKPmjdiu4hQuHSvbN4rg1a8vpdLkt7u4TzLuSG0Enkkw6WsxhYhtxVRcFVBYO0WNrlcVsSajq629sdP1DxBdQM82Z7nRws7XAEfkwNGYogIGBkLOdgBAHmpWPaR6/JqFtfXy6lNeXmmaE80U2nKYldbv9/n91hHQMXwSCvmMw4RdlxNT8YyW0Qtpb430n2cX63WmfubGdrmBWSHCJ50Oxrjcwd8LGp8xc7mk1rUfE2nwzWUV5qUht70xxXK2DGW5i8mJ9zPFazRgB5HTAiXdtHzAo++x43sprzQ/DQuLSS5EV6r3K3ulnUNv+izLmWCDhjuZRlPlDEEcCsOa+8YaNY2EGn289vaLFJJb/wCjTOjsZpCEeKO2meOER+SVizEyK5TezKSmh4hl1S/0nxJZXNzrn26W0v4odMg0zfaSJ5cghxMITlmTY2PN++duB9wSandeK21C0ktoZIr/AHyQysdPE0VsGu7JdqPgM8RhMjk7gWw5IjKbIrF1e+KLS6lsvO1KW3triSO3vUsEllu5PKgeJJFCqnlFpLhWceUB5SgyIclsvwnP4ll0s+IDPPI17d6ZI9utou26E1tZxzzMcZ2qC5GzaFZG3bh8oP7T8bT3FpAsuqxefFGL1xpkYFrctdWqSpE7IQ8aRvMVYqwI3N5km07NzS9W1fTtQhOt3F29lcPcW5ee1CiOSO7jtrYgog5mWTec5BPK7EBFV9c8JzeIPHV5MyWkMC6ZaxpeTWBlnjbzbksbabcBFKoKndhsEocccx2mo+LLnxpcWF289paSy3EQKW7ukcQD+TJG32UxiQgRsd87ryw2BiFXn7TUPGGkeF/DdtYpfRwwaVCP9IsptxuFLK8U0cdpI/loFjA/1RZSSHc/MvcaRqGqQR3N/wCILn7PajUJrO1h8n5pA92Y4Xf5cjIMarjjaS7M24bMvxrYGXWYbldPkv5/s6rbQy2Ek6mQMxxBPGwNlKSVDTPxxGQf3bYjv7/xc8+ow6a98dTP2xFtXs0W0gjCS/ZpY5mQK8jMLfKmRwPMkyq7Tsj8T3Opa9Z3dxZNrNvpdvcaW8Yj01lnMiXRaciKSIyMFQwvkKRlMDOHU3NAg13Tbq2Znna0u9b1GKS0NqFSCAy3MqzFsbtzOqANkIVkUbd2GNddPc+NtYls9Onh1eTVbaVNRNqyRmyWC3EqmYja6nbKgjBYhyrYG3esdtqvisxRy51KWVEhm1WKawCLaOJ4fNitv3YMyGI3IyplJ2JtbLDfY1PU/GkskCWlnJYyBwJSbZZowsl5biInDHcVgNwJArDBVjkKY3NfWtR8TafDNZRXmpSG3vTHFcrYMZbmLyYn3M8VrNGAHkdMCJd20fMCj79jxPaNeeFbAXcV3L5bxvPHc2K3oY7CP9It4SPNG4g4jyBIEb7qmubtbXxBZrqmpabbz2H2XRIpLe1itGYXkkct40caq+5o42UqTAMOgkRAybcHQv7/AMXPPqMOmvfHUz9sRbV7NFtIIwkv2aWOZkCvIzC3ypkcDzJMqu07Lmo6z4rnIbSNKkBZ5ri1WeIIssAtpAizbmBRzceUdvyNsdehWUJXOo3wsibTWPE9xAbhFvLi40Xy57aLZIQ0Ef2ZfMJkEat8km1SThfvDLbWPGMttpqXL6rDdyS3AnhtNO8twPtMip8zQTw/cVdoaSMD7zSOrhl1NM1XxU/jx7S+SSOxa4nQxGCVohCAxiZHW22B2AjJ3XDD5nG0MQqdhHHqQ1SaSW7tG08piKBbZllVuOWk8whh97gIOo5458/1i1jv9W1qPQ9M1Kw1hLe7SG+WxnilvrhoXABumUKIFJG0M+C6Jt2rGm+nNpQeeWWw0jyvDXmxGe0GhzRws4S8AZrIgPNhnstzAfMUBBXYdnWaXok194KWxk8yzK3r3VkJIz+6jS7M1qpjOCECrEPL+Uhfl+Qjjm7qbxZY6Lp+pxRzw3Ws/wCnaobW3dXt5/JhSOFY/IuWC7EbdlPvJncmQhuS6x4va4sWIu1nkuLASQWumsbY2rmHz5S0ih43DtKm0ksqAExjmVZPt3iyLwDY6hfXU8WrXMVuHt7exd3jOzLE7YJCkjHliYmRcCMAH94dgXWsp4EhuE+3NqDbDM80SNOkRlHmOqLGoLLGWZFMYY4UNHuylYb2Gp67eeHJLqbUp7Gz10ywy3VjHHJLEtq7CWZGiGwiYPGp2pwVIyxR60Nfs7STxVNNq+j3eowPZQJpnkWzytFcB5jIY5F4t3IaD94WjHyqd3yErHLdeMR4f1a+T/j4iu7iG1txFh2g+1kecf3ZO5YR+7VVfONxEpcIufZax4sl06AzvfBRLMscsWnPJNLKBEYYpVkghHlsWmy6pEoCIDKp3FqdpHr8moW19fLqU15eaZoTzRTacpiV1u/3+f3WEdAxfBIK+YzDhF2bFxL4ouLPS4bi3kkksns4dSL2yOtzcfarbM0Q2n5FjWZ9wChfMXo6MI6elXWs+F9Fkn/07UFTVdQt5LW8iS3Mks05Ns6v5a5V32LlQVzdMxIWPaOk1l9X0/QdMi+3Xcjq6RajqFlZiScKI2zJHCFcZaURggI2FduBjcMfwtd+NNS1Bo9XMlnbogllaS1WNywu7oeWg+ZcNGkO473woG0kyeYK9tqvisxRy51KWVEhm1WKawCLaOJ4fNitv3YMyGI3IyplJ2JtbLDfciufEuteIylveX2naJP9okimOnqkoREtAgAlTMbGQ3OPMU7l3YGNjLj3V94p1iDSvt1nfRTS3elTyWUOnkwJDvt5JZWc/MkizeYhXcxCLkx4zKOkudSj0bx1qNxd2upNBcaZZpFJa6dPcqWSW5LAmJGAIDocHHUVn3Gp+K0v7wWMd3cagr3YFhPaBLJIlSQ27pNtXc7sLfcvmtjzZPlXb8mO93r0F7rV9az6y6SW9jBa3lxpDpPOqvcs4wkD7CrN95oB8u0bfnWU7lhqXiqFYf8AQ769860t5UF3HEpysspuMsqxBWMZhWMOqEllLKu2bbTudV8ViKSXOpRSuk02lRQ2AdbtzPN5UVz+7JhQRC2GWMRG99zZU7JNWtvEuseBPFa3c08bGLUbeztbeBTLOglk8ssCn8SKqKFHKsW3FnXYWEWu2l9qep2txfS28uq2ISCaxCPdRyQ2kUs0mVDDau44QRhWR92R8q3PFVovi/T/AAtLp8Vpd2dxei6D3ti1zB5TWk5V5IiVOCWUDJGGK9+Kx9abxV4XNlp+kvI1nDb+ZFJHbSvE8zSOzRNHFbzssCDy1RA0ZCHaHYjKXLc6zpHifXJ4V1W8t5Nbjlmh+ypiSBrHanlNsUN++EaE7vlEalyo3s0lzqfisv8A6XHd2VrGltBfTWFoJnilCzmWS3Qq7SIzfZQCVfCu2QrK+yxoVx4rv9X8m8kkt9NS3ilE8tuElmAnuAowVAV5IlgaQHBTOAiF8ph6BomsnWLWBdR1W28mXWlnvJrFA4D3cLoIy0Yj/eAb921wcyBcYGzpLrU9am8IaHeyx3djPdJC+qNZWhkntQ0JY+XEyuSfN2IQVchWY8Y3Dn7PUPHk+nareXT3cE9jZSXMNoNORTczrcXYWL+P5DGkIKozMQUKyDJL3Gk1288baOLqO+aG31W5eaP7EBb20YguEt2SXjdvRlLcyAOQCYjhG0LTQby48QeJZxe31jBdahGsioSBcQi0txmM/wDLNtwZTInONw+8qNHy/hp/Eul6FZWwtL6yjWKBVMGmq8kk62NmI4pFIGYy3nqzsU2mNVMsYAqTwXY+I9H0OO4VbuALcaXE2ntZ481WtbOGZ3JG7CDeRt27WjbcWHyjQfWvF8unaStnbXb6hbW8EWqrPZtEj3TXFqrYcxkMmz7Vl4gyqPm/uVY8RXXiOxvdOsrfUdSuHdN07WFhsLMznhXa3miwOiq7x7QAXkbduW5oMn9leLPEcF9dXxbUdVj+xrPbbY3zaK/7t1QBsCKRT8xwIlz8zZaTTNSj03xT4gtLq11IPeanE8EiadPJEym1t0z5qoUA3KwJJGMHOKx7fVfFbWrMDqUk5t1bU1lsAgsJTLEHW0/djzwsbXJH+uyYo+W3YfL+2+JLK31OaGTVYpLrVTIkh0uRJriFbW3RJGKW9wqZxypjUs2f9WUaOuottV8RWVzKl1YX1xaxSxzSPLDG0q2pto1IXyiFebz/ADGZVDfKj4HzQhs+wv8Axck+nQ6k98NTH2NGtUs0a0njKRfaZZJlQqkisbjCiRAfLjwrbhvr30HiXUfhxpt9q93fQ35l0yea2sLNXkjCTRmRmQxFjJyZGUKApRVAIDGTQ0CDXdNurZmedrS71vUYpLQ2oVIIDLcyrMWxu3M6oA2QhWRRt3YY09T0zXpNU1mSDyxp8niPTZjAbF2llVfsW6RJA4ARdhz8hxsfkds+w13x84lWW3kN4XtzJbSQShI3NzCsiJJ9lVBFsaUM2+cgAMrEKWNzxRp+ssbsS3N9J5P9kTvd2OnIzyFb2VpQoEbsyxqUdU+YrtXJbc++TUNV8aR6sU06C7nn+0XivaSWSi1RVhnNptm+UkSFYi/zNhjtLRfcbPufEHisXGo2um3GpXVpClm6z3VgILpYnNyHkCLA7EmSONOYPugnaB++PSZv9X+HGdUWd7pv9aIbWQs6JNx5kLpE0ilFHmIETzFLhF+ZRWPZS39hp0EMMN9pGkNLMftOj6RIru4EWwLZyJK1vGcz7hs5aIPkebhtCx1HXZdTtF1+41XTbpvs22003TxPay5jjMnmS+VJs/emVD+8XCop4zvbD0bVPGVvdaBaz2slpbfZ7GPyBZSCIo0UYlLpHbMI3DGVQDLEF2JlNoy9zSrrWfC+iyT/AOnagqarqFvJa3kSW5klmnJtnV/LXKu+xcqCubpmJCx7R2FvcRPot3ZXl9Pe3FhELbUJ7eJ45Hk8lXZkWP5gxV1YCPJBbA5FefrZWt3YC5s9DnsNNe7R7vR20OcQRR+RcLGz2+xftEhlaEv5eQNkYziMSGS5tLMadZWN9o2pCeR7l7a9XTLi4OmWhuJDD5ARG8mfy2QKAFKBFL/6tI26DRn0+0+I2trZ6Vd2qXtvArTLpU0UU1wkly0rNJ5YQnDJ85OGyME1lyeH7xviFqGrSWMCWbarB/psVgTfLtt7bbslz/x7sweN8KcAuD8rM0eXJdeMtb8NeJtP1NbuOeXR7hmt47WRis4A/cwsbVEKNl0IEkzEbSj8FzsSXXibSPFllpNssiaRbvbW1vi1YxSwbUV3cQ2rKjgmQD97Eq7UJQLy5Le+N4/AumajM0n9oXKW4u4oYSJLVPKYs+BBIxlaTYGURMFB2hRtaUxwaj41uNMvr37ROrWOlC6ggTT2BvLhZLkCNjJEjHciRB1VEJLKU8sHDaD6jrovNR2XGqnV4/tX2PTDp4/s+TaH+z7rjyv4lEbH98PmYr8v3Rj22u+Kzod/5txfCRZYRC5065ac537wG+wKqr8qEHyJMfMCQXQr1kBhuPBETeJLO7v43QNcQXdkLmST58rmKOIEjO0j92rAAFlVgwHHx20d54F8LR3en3ebCyS0nt9R8Pz3kCzCKLO63G1y4wQsoBQDzFzlhVi10vxlHqfguXU4I7lLR4Y5Cb6QtEfsUizvMojZWcuWw5cg4RRt3uxseDdLubLxVvhgkjtI7KWK8eXTHtJ5Z98Xlm4lLFLuXCzZlj+XJc5xIM5cr+JbfR9esra0vpGeXV2Wym01WgaBmuXjlViG8yRpTGoQn5kb/VEYkOxq1t4l1jwJ4rW7mnjYxajb2drbwKZZ0EsnllgU/iRVRQo5Vi24s67Cwi120vtT1O1uL6W3l1WxCQTWIR7qOSG0ilmkyoYbV3HCCMKyPuyPlW54Qv8AWr/Wb46jPqUtuqExmW0NvBktxhJLeKRTjooeYAZDNnaWz/7Rlg8GeJNHi07Um1Rn1d4I30iaSKQtLPJH8zRmJwwK4BJDZA5zirHiKXxRJoOqWENvJNcQpfzSObZJYrm3aOf7NCilTvfc0QK7c/uX3ZDp5g9340t7d723Ml5czXuoW0FhLarHFHEguWt3duGyzRwqHLKhSQcbjvNzwnqmo3fiHV7K5u765sbe0tZbR7+yW2mbe84dmUKp6x7RlE4QYU/ffm9I8QeNL3wnBfW/2u8u59MinuTNZLCkLM0O1oCqN5haFppDgS4ZFHloT5JuWWseJJtOg/tO71W1tBLMrXllpkk13uAiMaOj2i5U7pyXWAKNkY3bs7jS9d8XXWtSw3gnS6hu7OJrKC0RrYb4Ld7pXmG4r5Ykd0yyZJADS/cXP8PX3jDTm8N6dJbz21nFaWEAhe2mZGjMUYlMmy2fbIGMqjdNGBsUsu3JfY8bp4km1a4udJ0/z49I09Ly1PnyRl7gyOxVVWNvNbbCqbQyHZPIucSZWO5uvGEMV9dRXOpSOqandw25soyu63n220AxHuKSo2TzvbYCjLzmvp1x4r086hBptpdyXAvdUkhs7qzEds0RkuJIpRKSNztMY1wXX5GJ8vAEpJtZ8TRpqawXesyWapaixubjR2jnlLNP5v3IHKkFUG5oANoUbQXWVpL3U/EqwaNFFca55ksW6dY7NRMxZyATIbRoeRjari3KjBkwWOyTUNV8aR6sU06C7nn+0XivaSWSi1RVhnNptm+UkSFYi/zNhjtLRfcanDca6muaheJNrh02WKygbU30oLd+Sv2tiVi8s7mErRof3IIR87cYlO5oVx4rv9X8m8kkt9NS3ilE8tuElmAnuAowVAV5IlgaQHBTOAiF8oeEL/Wr/Wb46jPqUtuqExmW0NvBktxhJLeKRTjooeYAZDNnaWILrX7nxA1q1zqULyXFxFcRCyUW9rbASeTNDM0eHlOICVLyDMj5QbSEz4dBu7b4AHR4Eu4r06E2YUt0WUytGXaLYE6liUPG85Jzv+apLCLXbS+1PU7W4vpbeXVbEJBNYhHuo5IbSKWaTKhhtXccIIwrI+7I+VZPBWq+KrzWZodfSSMG3Z5onglCwzBlG2J/s0abBlx/rZicKVYgMzZeqLrFtpLWumWV8NX0zUNW1JStm7IFkjvDCyOV8uRiZ4fkUs3zEEfK2Ni5i8RDxLY6dNcT3Nv5qTnUVsYx9naS3vVcREqyoqMkO3duYebtZnD4PL2moeMNI8L+G7axS+jhg0qEf6RZTbjcKWV4po47SR/LQLGB/qiykkO5+ZegaTXbzxto4uo75obfVbl5o/sQFvbRiC4S3ZJeN29GUtzIA5AJiOEaxBYXieMdWub60nm0iTVYnijSM4E32a2VJmH/AC0jDKQCOI3XcQ2N8Of4bm8XRaLa3NwZ4ltpdNto9NXTkiUxyQ2qzswCghUMkpATaEZGDblG1a8ev+LhfwWzyX3mS6e895G+nopt5lntluBb8ZlWKOSQp8rhiR80x+VTT7jXbe51KW7m1yzsLrUHk+32+lB7qXbbWqQZi8uTCsolLMEXDIARESY60LKTxle3cX9oXV9p7XN3FazxW1tC0dqv2FJnkjZkfP8ApAaLczOuGIHzYIseITqmsfDjSL24W+sr8y6bd3cNja75IyJomkAjZHb5OWxgnKDORkGxYX+uv4oWGZ745u50ubV7MLaQWoEnkyxzbBvkbEGV8x8eZJ8q7fkx/FGm6pL4u1J7OS+driLR2tw1n5tshjvyXJZVBOwEOVLg4kc9ANhreo+MdPZ7O3e+ltLe7eL+0Rb/AL+YeVA6ZEdrMpXdJOpKwqP3SgsGyH0PEWmX/iXR/CMdxa2Mtw92k12LnT5J7ZD9knyWhcowXeQBvKkErnnis+TRdd8P3WsT6Vczt9i0SGWGOKzBS6nSW7kW3QHdthXeFEa/OFMYDjHzYerSa/pVxq+sQWMlu8CXUiXBsF2xiM6wyOMpgH5oCW6t5gyT5h3bF5rvii3lsoxPqSwXF7HFPK+mIJ42MFy9xHDH0ZIxHEyMDLk5AafGwyW83i661y0RTPaR3Pkwy3zacnmNbj+0CrOSo2yFVtmwQAjyDKAMUNfVdb8cWzwiKOdI4fOjimNpK32l47iVAZkitpTtMaQv8vk7vMbacY2bmnX+tXHjy4gln1J9OjeQBVtDDAABgbvNtwSM/wAUc7lmwwUISEz9SW9sPG8l6umR3N5JqduttNLpEtyy2bpBE/l3KHbbhT9pYq3XJOAGy0lhf+LrhU8t76S6WKOfUYLmzSFIJlliL29s7IokV0+0oGLSAbYz5i53NH4g1XxegW6sku4dNuriR4jHA32iGMRxLGrIttOwDsLiT5o8gFAzIf3ZkW/8a3Oha/eu/kzWtoZbKO3s233E5sY22okibvLWZnIBBdm+U7QhV7GoXPiXT7yWzlvL6axP2ea41G009XlhDi4DpBGEfcoeO3G0rI6rKxZjwyyaFceK7/V/JvJJLfTUt4pRPLbhJZgJ7gKMFQFeSJYGkBwUzgIhfKHhC/1q/wBZvjqM+pS26oTGZbQ28GS3GEkt4pFOOih5gBkM2dpYgutfufEDWrXOpQvJcXEVxELJRb2tsBJ5M0MzR4eU4gJUvIMyPlBtITPh0G7tvgAdHgS7ivToTZhS3RZTK0ZdotgTqWJQ8bzknO/5qksItdtL7U9Ttbi+lt5dVsQkE1iEe6jkhtIpZpMqGG1dxwgjCsj7sj5Vk8Far4qvNZmh19JIwbdnmieCULDMGUbYn+zRpsGXH+tmJwpViAzMX3hoW3iXxPqmiaJaRasdHjfT7tbWNSbxjd7iHYY3nMe4k8gru4qS71nxJqGvWr6DFOmmSywwE39hJCqN5V20rsrosm0H7KR91WYBAy5YiOzGtaXr+uq7Xa2bXBljvTZG4a5lWxgXMiRhTsyjn92Bvddm6MgLJoeB7vV7y3vJNVk1KQh1WM3cYRehztBtrd88jOUK/d2sTuA5v+1vHMlxaRwNfLJLFGbsz6UDDbXRurVZY0I2mSFI3lwe67iJXIzHqXV74otLqWy87Upbe2uJI7e9SwSWW7k8qB4kkUKqeUWkuFZx5QHlKDIhyWjTT3X4feCoNT06eextYrcapZNatMSgtHUK8ABZ8TGI7dpwQGwNpIr67fa7p2jzL4Zs9VsoY9PeTSrWPTxP5shaXesitnylRBE0aEoRu27HK+SJEu9Xt5Jor6fWdJs/tF01u+k6QJmmY3lxnzFEEm0eWIGVsLv8xmy5zi5/afiBNYnzLfCRZboT276Y0lpb2yrIYZY2RA00jbYMxrKxPmSAKpHyXPA93q95b3kmqyalIQ6rGbuMIvQ52g21u+eRnKFfu7WJ3AcnaTXWj+FUh8P2d9pfm6rfSPDDo88LuhmYxNn7LMFXy2jABjGcABl8tlOhHJ4isNQ1Bo49VgjuLsSiX7FHPNPcCzs1jjkC/u/LYiYO6lEDR4EsY6yaFe+NJdNh1HUJrvzI7jTojYtYKnmLLFbC4d/l3YRpJmG3btZG3FlG1c8XniZtSi1C4/tJbiHR7hJZH0pittdvLa74ITGjF0G35H8uQDlt0wVlXpNL1LXYvAOp6i8V9d6rFFPLbRXkIJlZUyiqiwwuVLDGGjVid2MrtY8nNpXi/TXTTrOxk8+2f7XZTpcNdD7Q9heRFmkeKNATIkTsCuPMnZmJ8wAdJd6jrut69appVxqtho00sMLz/wBniKRGEV28h2zxEhSRajcV25OFOd1U7S98aXkuj27zXdsL9La5u53sFP2XzYLppoVyoChGjhC79zKzrvLg7TseFpdXm1zUzqlvIojt44I7iS2EbT+XdXiBiwUbiY1ifA+UeZlQofnm9QfxLrHhLXLKWTVXuJtEuDewtYLGLe72rtt7YmMebG+ZlJBlOFTDgkM3SeJ9Ihj8K2Fj5ck1tZvGpQ6cLuF1VCo862i2mRMkELGBtcI2AqHHL3upeLdLtdOi0ywksbNLctAkdvO6SP5snDxLbzyRxbBEyxboigkKBiU+TU0efxLpk19bwaZPNDLdzzW8bxqq4+33TzncSuGaJoRHuOCzqR8okZZH1TxRHFGheQSa089tp7SRIjWbefI0chQjLH7K3mbHxj7LtPzyVc0yfxKuo2lxeTzzQXOq3lo9qbRUSC1U3DRSkgbtx8uJQxIUq6/KWO8x/Y7RfGd9LqWj3dzqEl7C+m3cVs5MNuIogwFwMLGgdZy0ZcFgW+VvMAbHafxHqUFnDcpqVw5uLGbUYZrHy0s7hb22YpAwRfMiC+eS26UARqd4zlqfh6+8Yac3hvTpLee2s4rSwgEL20zI0ZijEpk2Wz7ZAxlUbpowNill25LySeIPGiTJbxfa5LuTTJJ7iCeyWIQXCzWyzLAwQtIkSSOUISQMT1nPyr1Hg3W726t/sWszSG/d5XtxLbyxyPCgi3Fy8EIJDSgAqijBA+YqxrLtrd7OXVJrXQZ5/FyS38sV09uyJIhaU26yXBKrLHsMKiMO235eF8slK9vd+Kr/AF6Kxg1LXI9IeWAJqE2lxQzFDFdtIWDxYH7xIVy0acbMD5g707u68V3J0Ce6h1LIe11GaWLTw72TTW14s8aJgAiMBNoYO4LjIlJVD0GhXHiu/wBX8m8kkt9NS3ilE8tuElmAnuAowVAV5IlgaQHBTOAiF8pzcT+JbjR9Bsrm0vo2SXSGayh01VgWBWtnklZgF8uRZRIpQH5UX/VAZkEkniDxokyW8X2uS7k0ySe4gnsliEFws1ssywMELSJEkjlCEkDE9Zz8q6iza3rHws8Tw30c9xeNaXUNspt5VmkBg4BDwQ7m3MwGyMDG0csCTHf6LrXhLRpJdEFor3NxGlzHpFgbaKCJVkPmJCFuCZWcojMEfKBRtXbvEZ1jxY+mQSu98l39kLWKW2nOyXtyJJQI7kyQK0S7Vgy2IAfMkKkKBsz9S1HxLrOh+IrVPt155n9rWgt1sVEP2ZPtCRukigl5vMWOPbuBKknyz/rTuaZqvip/Hj2l8kkdi1xOhiMErRCEBjEyOttsDsBGTuuGHzONoYhUNT1XxVB48S2jSSPTDcQJEBBLJFLCwXzGcpbPhwxkAzNGBtQsu3JfHS68Vya5p+oyQ6k8tvZMb3fp4Vbd2urNrqCEgZlQRJJswrFsHZJKeE2LrV9auLqW4ebWbHQ5riQ29xaaWXulCxQBEMLQu6oz/aiWaPOUT5grKGjvNT8SpqNslnLqskZu7FEVtMXZLZMYfNnlYovlzbmlVlHKqM+Uo/eLjrL4p0XRRa2UmqvH/auom5uHtSswYzlotoS0l3RurPIWEe3dwHUYQ3NRuvE2pHT47uG7Lte6XK9va6e32YwCS3kkmLuA6OJRIuxiWCKCYhzINTxxqPiWy+2/2L9uWRNPMlglpYrcrcT/ALzzBLkfLsURsnzLuZiAJSPLrQ8M21xa+JfFwuJr6RZtQimi8+ALGUNvEMxuEAbBUoeTgRrnkktycGlH/hFrK3sdGu7fxJG+nDU7x7GQJJcLdW5d5TlftJDLI/mKWAAc71D5bQvJ/FFrrM0MaXd1HZpNCupPYo07Qs1g7upVArOqvc7VVcOYVBR2XmPStd8XT32oRwie8SOW4tLX7VaJFiQw2klu86rhkXa07sflPJXYrlIga3rPjHc89rbX1rp8t24QiHM8QWKABCqW9wSpk+1ZbYQdqkSbSu+TwtbarL45fU9Qs5EM9vM8kqW8kcRdrbTM7fMAYAtHIAG5+RgeVOI7a1v7PVtUubXSPP8AEKfb5IpHsJEMhMkrW4kvC6pLD5ZhQQjcVO0/L5Z2F1qfin7PImj3uqz2p3hL7UNKMcyyfZbpiDEIFJjV0tSCIyWZyoLfdG5a3PijULqJvLktbKZI7a4Z4UilgkWKcyzRoWcY8026LkyA7WIDIQ7aGkPqVxFJbXt9J5kDgCVLNo2kVJ5FBZnUIxdEUMEUYyzKdrxkSXMf2eW7u9G02A6lLd20V5K8HlmWMMgdi52+ZsidsEEgEbeSCtSacdS+336XNzHJaxXDrFut2WQqyRuvzYVSFLSL8obI2Zbcr5w9J0240PRfED6dpMC+IZpb27QtCFF0Xnna3DyDAbgjjdlQwztyKsXEmuwTzvDdTz6TLLJ5kzWw+12ahJ9/lRhBvUOluI/lkZtzE7gVNdRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRX/2Q==",
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=256x200>"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idx = 22\n",
    "print(generated[idx][1])\n",
    "generated[idx][2].to_PIL()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=256x200>"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generated[idx][0].to_PIL()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "pro = generated[idx][0]\n",
    "t: str = generated[idx][1]\n",
    "t = t.replace('g', 'q')\n",
    "g = generated[idx][2]\n",
    "img: TGraph = g[pro._num_text_patches[0]-1:g._num_text_patches[0]-1]\n",
    "text = img.ocr(method='paddleocr', square=False, span=True, span_ratio=1.3, scale=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Co']"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'co' in vocab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(generated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=256x200>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generated[0][2].to_PIL(binary_method='gray_scale')[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[1, 1, 1,  ..., 1, 1, 1],\n",
       "          [1, 1, 1,  ..., 1, 1, 1],\n",
       "          [1, 1, 1,  ..., 1, 1, 1],\n",
       "          ...,\n",
       "          [1, 1, 1,  ..., 1, 1, 1],\n",
       "          [1, 1, 1,  ..., 1, 1, 1],\n",
       "          [1, 1, 1,  ..., 1, 1, 1]]]], device='cuda:0')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pt2hfpy310",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}