notebooks/239-image-bind/239-image-bind-quantize.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4ad832c5-71db-456f-9702-fb8f3b489e46",
   "metadata": {},
   "source": [
    "# Post-Training Quantization of ImageBind model with NNCF\n",
    "\n",
    "The goal of this tutorial is to demonstrate how to speed up the model by applying 8-bit post-training quantization from [NNCF](https://github.com/openvinotoolkit/nncf/) (Neural Network Compression Framework) and infer quantized model via OpenVINO™ Toolkit. \n",
    "\n",
    "The optimization process contains the following steps:\n",
    "1. Quantize converted OpenVINO model from [notebook](239-image-bind-convert.ipynb) with NNCF.\n",
    "2. Compare probability matrices between converted and quantized models on input data examples.\n",
    "3. Compare model size of converted and quantized models.\n",
    "4. Compare performance of converted and quantized models.\n",
    "\n",
    "> **NOTE**: you should run [239-image-bind-convert](239-image-bind-convert.ipynb) notebook first to generate OpenVINO IR models that are used for quantization.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57ec0370",
   "metadata": {},
   "source": [
    "### Table of content:\n",
    "- [Prerequisites](#Prerequisites-Uparrow)\n",
    "- [Create and initialize quantization](#Create-and-initialize-quantization-Uparrow)\n",
    "    - [Prepare datasets](#Prepare-datasets-Uparrow)\n",
    "- [Compare results for the OpenVINO FP16 model and the quantized model](#Compare-results-for-the-OpenVINO-FP16-model-and-the-quantized-model-Uparrow)\n",
    "    - [Select inference device](#Select-inference-device-Uparrow)\n",
    "        - [Compare File Size](#Compare-File-Size-Uparrow)\n",
    "        - [Compare inference time of the FP16 IR and quantized models](#Compare-inference-time-of-the-FP16-IR-and-quantized-models-Uparrow)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5487fe23-6122-47ca-9c29-3beb7802b292",
   "metadata": {},
   "source": [
    "## Prerequisites [$\\Uparrow$](#Table-of-content:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "13473357",
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install -q datasets librosa soundfile \"openvino>=2023.1.0\" \"nncf\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e1a60d45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/ltalamanova/openvino_notebooks/notebooks/239-image-bind/ImageBind\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "repo_dir = Path(\"ImageBind\")\n",
    "\n",
    "if not repo_dir.exists():\n",
    "    raise RuntimeError('This notebook should be run after 239-image-bind-convert notebook')\n",
    "\n",
    "%cd {repo_dir}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "488397fd",
   "metadata": {},
   "source": [
    "## Create and initialize quantization [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "[NNCF](https://github.com/openvinotoolkit/nncf/) enables post-training quantization by adding the quantization layers into the model graph and then using a subset of the training dataset to initialize the parameters of these additional quantization layers. The framework is designed so that modifications to your original training code are minor. Quantization is the simplest scenario and requires a few modifications.\n",
    "\n",
    "The optimization process contains the following steps:\n",
    "1. Create a Dataset for quantization.\n",
    "2. Run `nncf.quantize` for getting a quantized model.\n",
    "3. Serialize the `INT8` model using `openvino.save_model` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "810e2dd7",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "from imagebind.models.imagebind_model import ModalityType\n",
    "\n",
    "modalities = [ModalityType.TEXT, ModalityType.VISION, ModalityType.AUDIO]\n",
    "fp_model_paths = {modality: Path(f\"image-bind-{modality}\") / f\"image-bind-{modality}.xml\" for modality in modalities}\n",
    "int8_model_paths = {modality: Path(f\"image-bind-{modality}\") / f\"image-bind-{modality}_int8.xml\" for modality in modalities}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f261e6a4",
   "metadata": {},
   "source": [
    "### Prepare datasets [$\\Uparrow$](#Table-of-content:)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65d8d559",
   "metadata": {},
   "source": [
    "The [Conceptual Captions](https://ai.google.com/research/ConceptualCaptions/) dataset consisting of ~3.3M images annotated with captions. Dataset is used to quantize image and text models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "40d71747",
   "metadata": {},
   "outputs": [],
   "source": [
    "import imagebind.data as data\n",
    "import os\n",
    "import requests\n",
    "import tempfile\n",
    "\n",
    "from requests.packages.urllib3.exceptions import InsecureRequestWarning\n",
    "requests.packages.urllib3.disable_warnings(InsecureRequestWarning)\n",
    "\n",
    "def check_text_data(data):\n",
    "    \"\"\"\n",
    "    Check if the given data is text-based.\n",
    "    \"\"\"\n",
    "    if isinstance(data, str):\n",
    "        return True\n",
    "    if isinstance(data, list):\n",
    "        return all(isinstance(x, str) for x in data)\n",
    "    return False\n",
    "\n",
    "def collate_fn(examples, image_column=\"image_url\", text_column=\"caption\"):\n",
    "    \"\"\"\n",
    "    Collates examples into a batch for processing.\n",
    "    Preprocesses each example by loading and transforming image and text data.\n",
    "    Checks if the text data in the example is valid by calling the `check_text_data` function.\n",
    "    Downloads the image specified by the URL in the image_column of the example dictionary.\n",
    "    Constructs and returns a dictionary representing the collated batch with the following keys:\n",
    "       - \"pixel_values\": The pixel values of the preprocessed example.\n",
    "       - \"input_ids\": The transformed text data of the preprocessed example.\n",
    "    \"\"\"\n",
    "    assert len(examples) == 1\n",
    "    example = examples[0]\n",
    "    if not check_text_data(example[text_column]):\n",
    "        raise ValueError(\"Text data is not valid\")\n",
    "\n",
    "    url = example[image_column]\n",
    "    with tempfile.TemporaryDirectory() as tempdir:\n",
    "        f_name = os.path.join(tempdir, 'image.jpg')\n",
    "        try:\n",
    "            response = requests.get(url, verify=False, timeout=20)\n",
    "            with open(f_name, \"wb\") as file:\n",
    "                file.write(response.content)\n",
    "            pixel_values = data.load_and_transform_vision_data([f_name], \"cpu\")\n",
    "        except Exception:\n",
    "            print(f\"Can't load image from url: {url}\")\n",
    "            return None\n",
    "\n",
    "    text = data.load_and_transform_text([example[text_column]], \"cpu\")\n",
    "\n",
    "    return {\n",
    "        \"pixel_values\": pixel_values,\n",
    "        \"input_ids\": text\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "befc2204",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datasets import load_dataset\n",
    "import itertools\n",
    "import torch\n",
    "\n",
    "def collect_vision_text_data(dataloader, init_steps):\n",
    "    \"\"\"\n",
    "    This function collects vision and text data from a dataloader for a specified number of initialization steps.\n",
    "    It iterates over the dataloader, fetching batches and storing the relevant vision and text data.\n",
    "    Returns a tuple containing the collected vision_data and text_data lists.\n",
    "    \"\"\"\n",
    "    text_data = []\n",
    "    vision_data = []\n",
    "    print(f\"Fetching {init_steps} for the initialization...\")\n",
    "    counter = 0\n",
    "    for batch in dataloader:\n",
    "        if counter == init_steps:\n",
    "            break\n",
    "        with torch.no_grad():\n",
    "            if batch:\n",
    "                counter += 1\n",
    "                text_data.append(batch[\"input_ids\"].to(\"cpu\"))\n",
    "                vision_data.append(batch[\"pixel_values\"].to(\"cpu\"))\n",
    "    return vision_data, text_data\n",
    "\n",
    "def prepare_vision_text_dataset(opt_init_steps=300):\n",
    "    \"\"\"\n",
    "    Prepares a vision-text dataset for quantization by collecting vision and text data.\n",
    "    \"\"\"\n",
    "    dataset = load_dataset(\"conceptual_captions\", streaming=True)\n",
    "    train_dataset = dataset[\"train\"].shuffle(seed=0)\n",
    "    dataloader = torch.utils.data.DataLoader(train_dataset, collate_fn=collate_fn, batch_size=1)\n",
    "    vision_data, text_data = collect_vision_text_data(dataloader, opt_init_steps)\n",
    "    return vision_data, text_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c0f6587",
   "metadata": {},
   "source": [
    "The [`ESC-50`](https://github.com/karolpiczak/ESC-50) dataset is used to quantize the audio modality of the ImageBind model.\n",
    "Dataset is a labeled collection of 2000 environmental audio recordings suitable for benchmarking methods of environmental sound classification.\n",
    "The dataset consists of 5-second-long recordings organized into 50 semantic classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2a2d4357",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torchaudio\n",
    "\n",
    "def collect_audio_data(dataloader, init_steps=300):\n",
    "    \"\"\"\n",
    "    This function collects audio data from a dataloader for a specified number of initialization steps.\n",
    "    It iterates over the dataloader, fetching batches and storing them in a list.\n",
    "    \"\"\"\n",
    "    audio_data = []\n",
    "    for _, batch in zip(range(init_steps), itertools.islice(dataloader, 0, init_steps)):\n",
    "        with torch.no_grad():\n",
    "            audio_data.append(batch)\n",
    "    return audio_data\n",
    "\n",
    "def prepare_audio_dataset():\n",
    "    \"\"\"\n",
    "    Prepares an \"ashraq/50\" audio dataset for quantization by collecting audio data.\n",
    "    Collects audio data from the dataloader by calling the `collect_audio_data` function.\n",
    "    Returns a list containing the collected calibration audio data batches.\n",
    "    \"\"\"\n",
    "    audio_dataset = load_dataset(\"ashraq/50\", \"clean\", streaming=True)\n",
    "    train_dataset = audio_dataset[\"train\"].shuffle(seed=42, buffer_size=1000)\n",
    "\n",
    "    def collate_fn(examples):\n",
    "        assert len(examples) == 1\n",
    "        with tempfile.TemporaryDirectory() as tempdir:\n",
    "            f_name = os.path.join(tempdir, 'audio.wav')\n",
    "            audio_data = torch.from_numpy(examples[0]['audio']['array'].astype(np.float32)).unsqueeze(0)\n",
    "            torchaudio.save(f_name, audio_data, examples[0]['audio']['sampling_rate'])\n",
    "            return data.load_and_transform_audio_data([f_name], \"cpu\")\n",
    "\n",
    "    dataloader = torch.utils.data.DataLoader(train_dataset, collate_fn=collate_fn, batch_size=1)\n",
    "    calibration_data = collect_audio_data(dataloader)\n",
    "    return calibration_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "768c5f5f",
   "metadata": {},
   "source": [
    "Create a quantized model from the pre-trained `FP16` model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4137cd4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "vision_data, text_data = prepare_vision_text_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d6e9780",
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "import nncf\n",
    "import openvino as ov\n",
    "\n",
    "nncf.set_log_level(logging.ERROR)\n",
    "\n",
    "core = ov.Core()\n",
    "\n",
    "def quantize_openvino_model(modality, calibration_data):\n",
    "    model_path = fp_model_paths[modality]\n",
    "    if not os.path.exists(model_path):\n",
    "        raise RuntimeError(f\"Model: {model_path} not found. \\\n",
    "                             First run 239-image-bind-convert notebook to convert model to OpenVINO IR.\")\n",
    "\n",
    "    model = core.read_model(model_path)\n",
    "    quantized_model = nncf.quantize(\n",
    "        model=model,\n",
    "        calibration_dataset=calibration_data,\n",
    "        model_type=nncf.ModelType.TRANSFORMER,\n",
    "        # remove ignored_scope for nncf>=2.6.0 (PR with fix https://github.com/openvinotoolkit/nncf/pull/1953)\n",
    "        ignored_scope=nncf.IgnoredScope(types=[\"ReduceL2\"])\n",
    "    )\n",
    "    ov.save_model(quantized_model, int8_model_paths[modality])\n",
    "    return quantized_model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e56bc39",
   "metadata": {},
   "source": [
    "Quantize ImageBind model for vision modality.\n",
    "\n",
    "> **NOTE**: Quantization is time and memory consuming operation. Running quantization code below may take a long time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3213f8b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Statistics collection: 100%|██████████| 300/300 [00:58<00:00,  5.16it/s]\n",
      "Statistics collection: 100%|██████████| 300/300 [02:56<00:00,  1.70it/s]\n",
      "Applying Fast Bias correction: 100%|██████████| 128/128 [03:17<00:00,  1.54s/it]\n"
     ]
    }
   ],
   "source": [
    "if len(vision_data) == 0:\n",
    "    raise RuntimeError(\n",
    "        'Calibration dataset is empty. Please check internet connection and try to download images manually from the URLs above.'\n",
    "    )\n",
    "\n",
    "vision_dataset = nncf.Dataset(vision_data)\n",
    "vision_quantized_model = quantize_openvino_model(modality=ModalityType.VISION, calibration_data=vision_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9db7cc5e",
   "metadata": {},
   "source": [
    "Quantize ImageBind model for text modality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7d5eba00",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Statistics collection: 100%|██████████| 300/300 [00:12<00:00, 24.32it/s]\n",
      "Statistics collection: 100%|██████████| 300/300 [00:52<00:00,  5.67it/s]\n",
      "Applying Fast Bias correction: 100%|██████████| 120/120 [01:35<00:00,  1.26it/s]\n"
     ]
    }
   ],
   "source": [
    "text_dataset = nncf.Dataset(text_data)\n",
    "text_quantized_model = quantize_openvino_model(modality=ModalityType.TEXT, calibration_data=text_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a27983fe",
   "metadata": {},
   "source": [
    "Quantize ImageBind model for audio modality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "95540877",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Statistics collection: 100%|██████████| 300/300 [00:57<00:00,  5.19it/s]\n",
      "Statistics collection: 100%|██████████| 300/300 [01:45<00:00,  2.84it/s]\n",
      "Applying Fast Bias correction: 100%|██████████| 48/48 [00:27<00:00,  1.74it/s]\n"
     ]
    }
   ],
   "source": [
    "audio_calibration_data = prepare_audio_dataset()\n",
    "audio_dataset = nncf.Dataset(audio_calibration_data)\n",
    "audio_quantized_model = quantize_openvino_model(modality=ModalityType.AUDIO, calibration_data=audio_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8af6d642",
   "metadata": {},
   "source": [
    "NNCF also supports quantization-aware training, and other algorithms than quantization.\n",
    "See the [NNCF documentation](https://github.com/openvinotoolkit/nncf/#documentation) in the NNCF repository for more information."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0508c15",
   "metadata": {},
   "source": [
    "## Compare results for the OpenVINO FP16 model and the quantized model [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "Compare the probability matrices for `FP16` and `INT8` models.\n",
    "More details about probability matrix can be found in [notebook](239-image-bind-convert.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "06d49203",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prepare inputs\n",
    "from imagebind.models.imagebind_model import ModalityType\n",
    "\n",
    "text_list = [\"A car\", \"A bird\", \"A dog\"]\n",
    "image_paths = [\".assets/dog_image.jpg\", \".assets/car_image.jpg\", \".assets/bird_image.jpg\"]\n",
    "audio_paths = [\".assets/dog_audio.wav\", \".assets/bird_audio.wav\", \".assets/car_audio.wav\"]\n",
    "\n",
    "inputs = {\n",
    "    ModalityType.TEXT: data.load_and_transform_text(text_list, \"cpu\"),\n",
    "    ModalityType.VISION: data.load_and_transform_vision_data(image_paths, \"cpu\"),\n",
    "    ModalityType.AUDIO: data.load_and_transform_audio_data(audio_paths, \"cpu\"),\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfab93b3-f01f-4fc7-ac64-2ffc68c070a9",
   "metadata": {},
   "source": [
    "### Select inference device [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "select device from dropdown list for running inference using OpenVINO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "059788af-9ec0-4808-aa60-dac04216f4a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import ipywidgets as widgets\n",
    "\n",
    "device = widgets.Dropdown(\n",
    "    options=core.available_devices + [\"AUTO\"],\n",
    "    value='AUTO',\n",
    "    description='Device:',\n",
    "    disabled=False,\n",
    ")\n",
    "\n",
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1de57780",
   "metadata": {},
   "source": [
    "Get embeddings of original models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "82e8b0d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "embeddings = {}\n",
    "for modality in modalities:\n",
    "    ov_model = core.compile_model(fp_model_paths[modality], device.value)\n",
    "    embeddings[modality] = ov_model(inputs[modality])[ov_model.output(0)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dcf3317",
   "metadata": {},
   "source": [
    "Get embeddings of quantized models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "995c089a",
   "metadata": {},
   "outputs": [],
   "source": [
    "quantized_embeddings = {}\n",
    "for modality in modalities:\n",
    "    model = compile_model(int8_model_paths[modality], device.value)\n",
    "    quantized_embeddings[modality] = model(inputs[modality])[model.output(0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7668461c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from scipy.special import softmax\n",
    "\n",
    "def visualize_prob_matrices(fp_matrix, int_matrix, x_label, y_label):\n",
    "    fig, ax = plt.subplots(1, 2)\n",
    "    for i, matrix in enumerate([fp_matrix, int_matrix]):\n",
    "        ax[i].matshow(matrix, cmap='winter')\n",
    "\n",
    "        for (k, j), z in np.ndenumerate(matrix):\n",
    "            ax[i].title.set_text('FP16 probs' if i == 0 else 'INT8 probs')\n",
    "            ax[i].text(j, k, '{:0.3f}'.format(z), ha='center', va='center')\n",
    "            ax[i].set_xticks(range(len(x_label)), x_label)\n",
    "            ax[i].set_yticks(range(len(y_label)), y_label)\n",
    "    fig.tight_layout()\n",
    "\n",
    "image_list = [img.split('/')[-1] for img in image_paths]\n",
    "audio_list = [audio.split('/')[-1] for audio in audio_paths]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ca8620d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fp_text_vision_scores = softmax(embeddings[ModalityType.VISION] @ embeddings[ModalityType.TEXT].T, axis=-1)\n",
    "int_text_vision_scores = softmax(quantized_embeddings[ModalityType.VISION] @ quantized_embeddings[ModalityType.TEXT].T, axis=-1)\n",
    "\n",
    "visualize_prob_matrices(fp_text_vision_scores, int_text_vision_scores, text_list, image_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5519db85",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAD/CAYAAAB8dJvAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABDEElEQVR4nO3dd3gU5drH8e+SYHqhBgKR0AzgQYLUCAIeQBCkWAAVDWAUBIP0Jl1AFISANBU8FAUB9YAFpamgQmgCHmlRigRFir6YUCQJybx/TLLJhnRSyO7vc117yczc88zzZDO399RYDMMwEBEREZFir0RRd0BERERE8ocKOxERERE7ocJORERExE6osBMRERGxEyrsREREROyECjsRERERO6HCTkRERMROqLATERERsRMq7ERERETshAo7ETuxbNkyLBYL+/btK+quiIjkK4vFQnh4eFF3o1hQYSfFQkrRktFn9OjR1rjAwECbZeXLl+f+++9n3bp1Nu3t2bOHAQMG0KBBA0qWLInFYsly++fPn6dfv35UqlQJV1dXAgMDCQsLK5CxiohjyujgbNKkSVgsFvz8/Lh27dpN6wQGBvLwww8D0Lt370zzZNpP7969reuvXbuWpk2b4uvrS5kyZWjZsiUbNmwo8LFKwXEu6g6I5MYrr7xC1apVbeb961//spkODg5m2LBhAJw9e5a3336bRx99lEWLFvHCCy8A8MUXX7BkyRLuueceqlWrxs8//5zpNs+cOUOzZs0AeOGFF6hUqRJnz55lz549+Tk0EZFMXbhwgUWLFllzW0b69etHmzZtrNOnTp1iwoQJ9O3bl/vvv986v3r16gDMmzePl156iY4dO/Laa69x/fp1li1bxsMPP8zHH3/Mo48+WnADkgKjwk6KlYceeoiGDRtmGVOpUiWefvpp63RoaCg1atQgIiLCWtj179+fUaNG4ebmRnh4eJaFXb9+/XB2dmbv3r2UKVMmfwaSA0lJScTHx+Pq6lpo2xSR21NwcDAzZ85kwIABuLm5ZRgTEhJCSEiIdXrfvn1MmDCBkJAQm5yYYt68eTRq1IjPPvvMetXi2WefpVKlSixfvrxAC7urV6/i4eFRYO07Ml2KFbtXoUIFateuzalTp6zz/Pz8Mk2OaR07dowvv/ySESNGUKZMGa5fv05CQkKOt51yGeXYsWN0794db29vypQpw6BBg7h+/bpNbMo9JCtXruTuu+/GxcWFjRs3AnDgwAEeeughvL298fT0pHXr1uzatSvDbV67do1+/fpRpkwZvL29CQ0N5dKlSzYx+/bto127dpQtWxY3NzeqVq3Ks88+m+NxiUjhmjBhAufPn2fRokX51mZsbCzly5e3uRUlJcdklx9//fVXLBYLb7zxBhEREVSpUgU3NzdatmzJoUOHbGJ79+6Np6cnJ06coEOHDnh5edGzZ0/ALPCGDRtGQEAALi4uBAUF8cYbb2AYRobbXblyJUFBQbi6utKgQQO+/fZbm+WXL19m8ODBBAYG4uLiQvny5Wnbti379+/Py4+oWNIZOylWYmJi+PPPP23mlS1bNst1EhISOHPmTJ7Otm3duhUwC8HWrVvz9ddf4+TkRNu2bVm0aBGBgYE5aqd79+4EBgYyffp0du3axZtvvsmlS5dYsWKFTdzXX3/N2rVrCQ8Pp2zZsgQGBnL48GHuv/9+vL29GTlyJCVLluTtt9+mVatWbN++nSZNmti0ER4ejq+vL5MmTSIqKopFixZx+vRptm3bhsVi4cKFCzz44IOUK1eO0aNH4+vry6+//sp///vfXP98RKRw3H///fz73/9mxowZ9O/fP0cHptlp1aoVH330EfPmzaNTp05cv36defPmERMTw6BBg3LUxooVK7h8+TIvvvgi169fZ+7cufz73//mp59+ws/Pzxp348YN2rVrR/PmzXnjjTdwd3fHMAw6d+7MN998Q1hYGMHBwWzatIkRI0bw+++/ExERYbOt7du3s2bNGl566SVcXFxYuHAh7du3Z8+ePdZbcl544QU++ugjwsPDqVOnDn/99Rfff/89R48e5d57773ln1mxYIgUA0uXLjWADD9pValSxXjwwQeNixcvGhcvXjR+/PFH44knnjAAY+DAgRm2/eKLL97UToqXXnrJAIwyZcoY7du3N9asWWPMnDnT8PT0NKpXr25cvXo1y35PnDjRAIzOnTvbzB8wYIABGD/++KN1HmCUKFHCOHz4sE1s165djTvuuMM4ceKEdd7Zs2cNLy8vo0WLFjf9jBo0aGDEx8db58+YMcMAjE8++cQwDMNYt26dARh79+7Nsu8iUrhS9uG0+2ZKDrl48aKxfft2AzBmz55tXV6lShWjY8eOGba3d+9eAzCWLl2a4fLz588brVu3tsmnZcuWNXbu3JltX0+dOmUAhpubm/Hbb79Z5+/evdsAjCFDhljn9erVywCM0aNH27Sxfv16AzCmTp1qM//xxx83LBaLcfz4ceu8lP7t27fPOu/06dOGq6ur8cgjj1jn+fj4GC+++GK2/bdnuhQrxcqCBQvYsmWLzSe9zZs3U65cOcqVK0e9evX48MMPeeaZZ3j99ddzvb0rV64A5uXcDRs20L17d4YPH87ixYs5ceIEq1atylE7L774os30wIEDAfMhjrRatmxJnTp1rNOJiYls3ryZrl27Uq1aNev8ihUr8tRTT/H9998TGxtr00bfvn0pWbKkdbp///44Oztbt+Xr6wvA559/nqvLyiJStFq0aMEDDzzAjBkz+Oeff265PXd3d4KCgujVqxcffvgh//nPf6hYsSKPPvoox48fz1EbXbt2pVKlStbpxo0b06RJk5tyG5i5KK0vvvgCJycnXnrpJZv5w4YNwzAMvvzyS5v5ISEhNGjQwDp955130qVLFzZt2kRiYiJg5rfdu3dz9uzZHPXfHqmwk2KlcePGtGnTxuaTXpMmTdiyZQtbt25l586d/Pnnn6xYsSJPly5S1unevTslSqTuLt26dcPZ2ZmdO3fmqJ2aNWvaTFevXp0SJUrw66+/2sxP/8TvxYsXuXbtGkFBQTe1Wbt2bZKSkjhz5kyW2/L09KRixYrWbbVs2ZLHHnuMyZMnU7ZsWbp06cLSpUuJi4vL0VhEpOhMmjSJc+fO8dZbb91yW926dSM6Opply5bx+OOP06dPH7Zt20Z8fDxjx47NURvp8w3AXXfddVNuc3Z2pnLlyjbzTp8+jb+/P15eXjbza9eubV2ek21du3aNixcvAjBjxgwOHTpEQEAAjRs3ZtKkSZw8eTJHY7EXKuzE7pQtW5Y2bdrQunVrQkJCrGeo8sLf3x/A5l4RACcnJ8qUKXPTQwk5ldl78/LjvpmcbPujjz4iMjKS8PBwfv/9d5599lkaNGhgPUMpIrenFi1a0KpVq1s+a3fy5Ek2btxI586dbeaXLl2a5s2bs2PHjlvtqg0XFxebg+OC0r17d06ePMm8efPw9/dn5syZ3H333Ted/bNnKuxEspBy2v/333+3mR8fH8+ff/5JuXLlctTOL7/8YjN9/PhxkpKSsn34oly5cri7uxMVFXXTsmPHjlGiRAkCAgKy3NaVK1f4448/btpW06ZNmTZtGvv27WPlypUcPnyY1atX52g8IlJ0Us7avf3223lu4/z58wDWS5hpJSQkcOPGjRy1kz7fAPz88885erCsSpUqnD17lsuXL9vMP3bsmHV5Trbl7u5uk4srVqzIgAEDWL9+PadOnaJMmTJMmzYtJ8OxCyrsRLLQqlUrypcvz8qVK21eT7Js2TISExNp27ZtjtpZsGCBzfS8efMA8718WXFycuLBBx/kk08+sbm0cf78eVatWkXz5s3x9va2Weedd96xuXdu0aJF3Lhxw7qtS5cu3fQqgeDgYABdjhUpBlq2bEmrVq14/fXXb3ptUk7VqFGDEiVKsGbNGpt88Ntvv/Hdd99Rv379HLWzfv16mwPfPXv2sHv37mxzG0CHDh1ITExk/vz5NvMjIiKwWCw3tREZGWnz2pIzZ87wySef8OCDD+Lk5ERiYiIxMTE265QvXx5/f3+Hym163Yk4pNOnT/Pee+8BWP98z9SpUwHzKPGZZ54BzMsHM2fOpFevXrRo0YJnnnmG6Oho5s6dy/3335/jF3ieOnWKzp070759eyIjI3n//fd56qmnqFevXrbrTp06lS1bttC8eXMGDBiAs7Mzb7/9NnFxccyYMeOm+Pj4eFq3bk337t2Jiopi4cKFNG/e3HrJZfny5SxcuJBHHnmE6tWrc/nyZRYvXoy3tzcdOnTI0XhEpGhNnDiRBx54IM/rlytXjmeffZYlS5bQunVrHn30US5fvszChQv5559/GDNmTI7aqVGjBs2bN6d///7ExcUxZ84cypQpw8iRI7Ndt1OnTjzwwAOMHTuWX3/9lXr16rF582Y++eQTBg8ebP0LGSn+9a9/0a5dO5vXnQBMnjwZMN9hV7lyZR5//HHq1auHp6cnW7duZe/evcyaNSuXP6FirIifyhXJkYxeA5CRrB79T+ubb77J9PUpLVu2vCn+gw8+MOrVq2e4uLgYfn5+Rnh4uBEbG5vtdlJeVXDkyBHj8ccfN7y8vIxSpUoZ4eHhxj///GMTC2T6mP7+/fuNdu3aGZ6enoa7u7vxwAMP3PRKgpSf0fbt242+ffsapUqVMjw9PY2ePXsaf/31l01bTz75pHHnnXcaLi4uRvny5Y2HH37Y5jUCIlL4snvdSXotW7Y0gDy/7iQhIcGYN2+eERwcbHh6ehqenp7GAw88YHz99dfZ9jXldSczZ840Zs2aZQQEBBguLi7G/fffb/MaJ8MwX3fi4eGRYTuXL182hgwZYvj7+xslS5Y0atasacycOdNISkqyiUvJj++//75Rs2ZNw8XFxahfv77xzTffWGPi4uKMESNGGPXq1TO8vLwMDw8Po169esbChQuzHY89sRhGJq93FpFbNmnSJCZPnszFixezfZGyiEhx8euvv1K1alVmzpzJ8OHDi7o7kobusRMRERGxEyrsREREROyECjsRERERO6F77ERERETshM7YiYiIiNgJFXYiIiIidkKFnYiIiIidUGEnkg8CAwOZM2dOljEWi4X169fnuu3evXvTtWvXPPWrKOTkZyEixYfyW6rikN9U2EmORUZG4uTkRMeOHYu6KwWuIMb6xx9/5OjvJxYlR/qORdJzlN9/5Tf7/n5V2EmOvfvuuwwcOJBvv/2Ws2fPFvr24+PjC21bBTHWChUq4OLikunyhISEfNnOrSjq71ikKBX1739h5TjlN/vObyrsJEeuXLnCmjVr6N+/Px07dmTZsmXZrhMXF8eoUaMICAjAxcWFGjVq8O677wKQmJhIWFgYVatWxc3NjaCgIObOnWuzfsop+mnTpuHv709QUFBBDO0meRkrmH+A+sknn8TDw4NKlSqxYMECm+VpL1X8+uuvWCwW1qxZQ8uWLXF1dWXlypUkJiYydOhQfH19rX9Iu7DeSJSXcV+4cIFOnTrh5uZG1apVWbly5U0x0dHRdOnSBU9PT7y9venevTvnz5+3iZk6dSrly5fHy8uL5557jtGjRxMcHJxPIxPJnqPkOOU3B8hvRfmHaqX4ePfdd42GDRsahmEYn332mVG9evWb/khzet27dzcCAgKM//73v8aJEyeMrVu3GqtXrzYMwzDi4+ONCRMmGHv37jVOnjxpvP/++4a7u7uxZs0a6/q9evUyPD09jWeeecY4dOiQcejQoYIbYBp5GWuVKlUMLy8vY/r06UZUVJTx5ptvGk5OTsbmzZutMYCxbt06wzBS/4B2YGCg8fHHHxsnT540zp49a7z++utGqVKljI8//tg4cuSIERYWZnh5eRldunQpqOFa5WXcDz30kFGvXj0jMjLS2Ldvn3HfffcZbm5uRkREhGEYhpGYmGgEBwcbzZs3N/bt22fs2rXLaNCggdGyZUtrG++//77h6upq/Oc//zGioqKMyZMnG97e3ka9evUKaKQiN3OUHKf8Zv/5TYWd5Mh9991nzJkzxzAMw0hISDDKli1rfPPNN5nGR0VFGYCxZcuWHG/jxRdfNB577DHrdK9evQw/Pz8jLi4uz/3Oi9yO1TDMxNe+fXubeT169DAeeugh63RGiS9lOykqVqxozJgxwzqdkJBgVK5cuVASX16/4z179ljnHT161ACsiW/z5s2Gk5OTER0dbY05fPiwzXpNmjQxXnzxRZu2mzVrpsJOCpWj5DjlN/vPb7oUK9mKiopiz549PPnkkwA4OzvTo0cP6yWHjBw8eBAnJydatmyZacyCBQto0KAB5cqVw9PTk3feeYfo6GibmLp163LHHXfkz0ByIC9jTRESEnLT9NGjR7Ncp2HDhtZ/x8TE8Mcff9CkSRPrPGdnZ5uYgpKXcR89ehRnZ2caNGhgnVerVi18fX1tYgICAggICLDOq1OnDr6+vtafTVRUFI0bN7ZpO/20SEFylByn/OYY+c25QFsXu/Duu+9y48YN/P39rfMMw8DFxYX58+fj4+Nz0zpubm5Ztrl69WqGDx/OrFmzCAkJwcvLi5kzZ7J7926bOA8Pj/wZRA7lZay3orDHl5nCHrfI7cRRcpzym2PkN52xkyzduHGDFStWMGvWLA4ePGj9/Pjjj/j7+/PBBx9kuF7dunVJSkpi+/btGS7fsWMH9913HwMGDKB+/frUqFGDEydOFORQspXXsabYtWvXTdO1a9fO8fZ9fHyoWLGiTeK/ceMGP/zwQ+4Gkkt5HXetWrVu6l9UVBR///23dbp27dqcOXOGM2fOWOcdOXKEv//+mzp16gAQFBTE3r17bdpOPy1SUBwlxym/OVB+K7CLvGIX1q1bZ9xxxx3G33//fdOykSNHWm9GzUjv3r2NgIAAY926dcbJkyeNb775xnrj8Ny5cw1vb29j48aNRlRUlDFu3Libbijt1atXodx7keJWxlqlShXD29vbeP31142oqChj/vz5hpOTk7Fx40ZrDBncg3LgwAGbdl577TWjdOnSxrp164yjR48azz//fIHfXHwr427fvr1Rv359Y9euXca+ffuM5s2b29xcnJSUZAQHBxv333+/8cMPPxi7d+/O8OZiNzc3Y9myZcbPP/9sTJkyxfD29jaCg4Pze6giN3GUHKf85jj5TYWdZOnhhx82OnTokOGy3bt3G4Dx448/Zrj8n3/+MYYMGWJUrFjRuOOOO4waNWoY//nPfwzDMIzr168bvXv3Nnx8fAxfX1+jf//+xujRo4u0sLuVsVapUsWYPHmy0a1bN8Pd3d2oUKGCMXfuXJuYnCS+hIQEY9CgQYa3t7fh6+trDB061AgNDS3Qn8OtjPuPP/4wOnbsaLi4uBh33nmnsWLFCqNKlSrWxGcYhnH69Gmjc+fOhoeHh+Hl5WV069bNOHfunE07r7zyilG2bFnD09PTePbZZ42XXnrJaNq0ab6NUSQzjpLjlN9uZq/5zWIYhfQSGRGRHGrbti0VKlTgvffeK+quiIjkq4LOb3p4QkSK1LVr13jrrbdo164dTk5OfPDBB2zdupUtW7YUdddERG5JUeQ3nbETkSL1zz//0KlTJw4cOMD169cJCgpi3LhxPProo0XdNRGRW1IU+U2FnYiIiIid0OtOREREROyECjsRERERO6HCTkRERMROqLATERERsRMq7KTAxcXFMWnSJOLi4oq6K4XGEccMjjtucWyO+HuvMd++9FSsFLjY2Fh8fHyIiYnB29u7qLtTKBxxzOC44xbH5oi/9xrz7TtmnbETERERsRMq7ERERETshP6kmINISkri7NmzeHl5YbFYCnXbsbGxNv91BI44ZijacRuGweXLl/H396dECR2zOhrluMKlMReu3OQ33WPnIH777TcCAgKKuhsiBe7MmTNUrly5qLshhUw5ThxBTvKbztg5CC8vr+R/nQFu35s+JZ/ETC/qHhS+2DgIiEjzuy6ORDnOwThajstFflNh5yBSL014o6TnALxdiroHRaawL8PJ7UE5zsE4aI7LSX7TjSgiIiIidkKFnYiIiIidUGEnIiIiYidU2ImIiIjYCRV2IiIiInZChZ2IiIiInVBhJyIiImInVNiJiIiI2AkVdiIiIiJ2QoWdiIiIiJ1QYSciIiJiJ1TYiYiIiNgJFXYiIiIidkKFnYiIiIidUGEnIiIiYidU2ImIiIjYCRV2IiIiInZChZ2IiIiInVBhJyIiImInVNiJiIiI2AkVdiIiIiJ2QoWdiIiIiJ3It8KuVatWDB48OL+ay9KkSZMIDg4ulG0VhN69e9O1a9ei7kYuLAACAVegCbAnm/gPgVrJ8XWBL9ItN4AJQEXADWgD/JIu5v+AnoA34AuEAVfy2P+8crBxf3saOn0A/rPAMhnWH8t+nW2/wr1vg8tUqPEmLDt4c8yCPRA4B1ynQpMlsOd32+XXb8CLG6DMDPB8FR5bC+cL+7vOmvJbzhW//AYOt68DDjdmB8pvxfKM3fDhw/nqq6+Kuht5NnfuXJYtW1bU3cihNcBQYCKwH6gHtAMuZBK/E3gSc4c9AHRN/hxKEzMDeBN4C9gNeCS3eT1NTE/gMLAF+Bz4Fuh768PJMQcc99V4qOcHCzrkLP7UJei4Ch4IhIP9YHBTeO5T2HQ8NWbNIRi6GSa2hP39zPbbvQ8XrqbGDNkIn/0MH3aD7b3h7GV4dG1+jqxYUX4rbA64rzvimB0ov1kMwzDyo6FWrVoRHBzMnDlz8qM5yWexsbH4+PgAMZhHSznVBGgEzE+eTgICgIHA6AziewBXMXfaFE2BYMwd3gD8gWHA8OTlMYAfsAx4AjgK1AH2Ag2TYzYCHYDfktcvaMV83MaknMdmxDIZ1vWArrUyjxm1BTb8AocGpM574iP4+zpsfNqcbrIEGvnD/ORkmmRAQAQMbAyjm0PMdSg3E1Y9Bo/XMWOO/Qm1F0BkGDStnPM+x8aBz2vExMTg7Z2b3/HsKb/d/pTjcsMOxnwrOc7O81uezthdvXqV0NBQPD09qVixIrNmzbJZfunSJUJDQylVqhTu7u489NBD/PKL7SnZxYsXExAQgLu7O4888gizZ8/G19c3R9tPf6ki5dT/q6++ip+fH76+vrzyyivcuHGDESNGULp0aSpXrszSpUtt2hk1ahR33XUX7u7uVKtWjfHjx5OQkGATM3XqVMqXL4+XlxfPPfcco0ePvukyyZIlS6hduzaurq7UqlWLhQsXZtn/9JcqWrVqRXh4OOHh4fj4+FC2bFnGjx9P2pr7jz/+oGPHjri5uVG1alVWrVpFYGBgAf+PJh74AfOUeooSydORmawTmS4ezKO2lPhTwLl0MT6YiSYlJhLzNH3DNDFtkre9OzcDyCNHHXcuRf4GbarZzmtX3ZwPEJ8IP5y1jSlhMadTYn74AxKSbGNqlYU7fSDyTMH2PxPKb8E2Mfab38Ax93VHHHMeFOP8lqfCbsSIEWzfvp1PPvmEzZs3s23bNvbv329d3rt3b/bt28enn35KZGQkhmHQoUMHa1LZsWMHL7zwAoMGDeLgwYO0bduWadOm3dJAvv76a86ePcu3337L7NmzmThxIg8//DClSpVi9+7dvPDCC/Tr14/ffvvNuo6XlxfLli3jyJEjzJ07l8WLFxMREWFdvnLlSqZNm8brr7/ODz/8wJ133smiRYtstrty5UomTJjAtGnTOHr0KK+++irjx49n+fLluer/8uXLcXZ2Zs+ePcydO5fZs2ezZMkS6/LQ0FDOnj3Ltm3b+Pjjj3nnnXe4cCGz0+b55U8gEfOoKy0/zJ04I+eyiT+XZl5WMeXTLXcGSmex3fzkqOPOpXNXwM/Ddp6fp3lk+U8C/HkNEo0MYjzMdVPauMMJfF0zjylkym/YxNhvfgPH3Ncdccx5UIzzm3NuV7hy5Qrvvvsu77//Pq1btwbMnbZyZfOU4i+//MKnn37Kjh07uO+++wAzOQQEBLB+/Xq6devGvHnzeOihhxg+3Dxle9ddd7Fz504+//zzjDeaA6VLl+bNN9+kRIkSBAUFMWPGDK5du8bLL78MwJgxY3jttdf4/vvveeKJJwAYN26cdf3AwECGDx/O6tWrGTlyJADz5s0jLCyMPn36ADBhwgQ2b97MlSupX8jEiROZNWsWjz76KABVq1blyJEjvP322/Tq1SvH/Q8ICCAiIgKLxUJQUBA//fQTERERPP/88xw7doytW7eyd+9eGjY0j3aWLFlCzZo1M20vLi6OuLg463RsbGyO+yLiqJTfikd+A+U4kczk+ozdiRMniI+Pp0mTJtZ5pUuXJigoCICjR4/i7Oxss7xMmTIEBQVx9OhRAKKiomjcuLFNu+mnc+vuu++mRInU4fj5+VG3bl3rtJOTE2XKlLE5ClyzZg3NmjWjQoUKeHp6Mm7cOKKjo63Ls+vn1atXOXHiBGFhYXh6elo/U6dO5cSJE7nqf9OmTbFYLNbpkJAQfvnlFxITE4mKisLZ2Zl7773XurxGjRqUKlUq0/amT5+Oj4+P9RMQEJCr/pjKAk7A+XTzzwMVMlmnQjbxFdLMyyom/dH6DcwnqjLbbn5y1HHnUgVPOH/Vdt75K+DtAm4loaw7OFkyiLlqrpvSRnyied9KZjGFSPmteOQ3UI7LO0cccx4U4/xWLJ+KzUjJkiVtpi0WS4bzkpKSAIiMjKRnz5506NCBzz//nAMHDjB27Fji4+NzvM2UI9vFixdz8OBB6+fQoUPs2rXrFkd0a8aMGUNMTIz1c+ZMXq7n3wE0ANI+oZeUPB2SyToh6eLBfAIqJb4q5k6cNiYW8x6LlJgQ4G/M+0BSfJ287SYUPEcddy6FVIavTtnO23LSnA/mJYgG/vDVydTlSYY5nRLToCKULGEbE/UnRMdASF7+R22flN9uphyXV4445jwoxvkt14Vd9erVKVmyJLt3p97seOnSJX7++WcAateuzY0bN2yW//XXX0RFRVGnjvlUSFBQEHv37rVpN/10Qdu5cydVqlRh7NixNGzYkJo1a3L69GmbmOz66efnh7+/PydPnqRGjRo2n6pVq+aqP2l/XgC7du2iZs2aODk5ERQUxI0bNzhw4IB1+fHjx7l06VKm7bm4uODt7W3zyZuhwGJgOeZTTf0xn47qk7w8FBiTJn4Q5pNOs4BjwCRgHxCevNwCDAamAp8CPyW34Y/5+DxAbaA98Dzmu5V2JK//BIXzRCw45LivxMPBc+YHzMf9D54zkxDAmK0Qui41/oWGcPISjNxiPum1cC+sPQxDmqbGDG0Ki/fD8oNw9CL0/xyuJkCfYHO5jyuE1TdfGfDNKfNm5D6fmIkxN0+M5RPlt+KR30A57tY44JgdKL/l+h47T09PwsLCGDFiBGXKlKF8+fKMHTvWepmgZs2adOnSheeff563334bLy8vRo8eTaVKlejSpQsAAwcOpEWLFsyePZtOnTrx9ddf8+WXX9qcqi9oNWvWJDo6mtWrV9OoUSM2bNjAunXrbGIGDhzI888/T8OGDbnvvvtYs2YN//vf/6hWLfUJl8mTJ/PSSy/h4+ND+/btiYuLY9++fVy6dImhQ4cC0Lp1ax555BHCw8PJTHR0NEOHDqVfv37s37+fefPmWZ/Gq1WrFm3atKFv374sWrSIkiVLMmzYMNzc3ArhZ9YDuIj54slzmI+3byT1JtlobI8P7gNWAeOAl4GawHrgX2liRmImkb6YR3DNk9tMe4PpSsydvnVy+49hviOpsDjguPedhQfS3BQ/dLP53171YFlX+ONKahIEqFoKNjwFQzbB3N1Q2RuWdIZ2NVJjevwLLl6DCdvMm4WDK8DGnuZNyCki2kOJTeaLO+MSzSfPFnYsyJFmSvnN0fIbOOS+7ohjdqD8luvCDmDmzJlcuXKFTp064eXlxbBhw4iJSf2BLF26lEGDBvHwww8THx9PixYt+OKLL6yXDpo1a8Zbb73F5MmTGTduHO3atWPIkCHMnz8/s03mu86dOzNkyBDCw8OJi4ujY8eOjB8/nkmTJlljevbsycmTJxk+fDjXr1+ne/fu9O7dmz17Ut/Q/dxzz+Hu7s7MmTMZMWIEHh4e1K1b1+Yt9SdOnODPP//Msj+hoaH8888/NG7cGCcnJwYNGkTfvqkvblyxYgVhYWG0aNGCChUqMH36dA4fPoyrq2sWreaXcFKPzNLblsG8bsmfzFiAV5I/mSmNmUiKkoONu1UgGBMzX76sa8brHOiXdbvhjc1PZlydYUFH83MbUH5ztPwGDrevAw43ZgfKb/n2guJblfJ01HfffVfUXclS27ZtqVChAu+9916e23jyySdxcnLi/fffB/L28tPffvuNgIAAtm7dan16Lyt5f3mnFEu3+oLi4qgAX1B8q5TfCja/gXKcw3G0HJeL/JanM3b54Y033qBt27Z4eHjw5Zdfsnz58mxffFnYrl27xltvvUW7du1wcnLigw8+YOvWrWzZsiVP7d24cYOff/6ZyMhI+vXL5iggna+//porV65Qt25d/vjjD0aOHElgYCAtWrTIU19EpOAovym/iRSVInsqds+ePbRt25a6devy1ltv8eabb/Lcc88B5qP9aR+vT/tZuXJlofXRYrHwxRdf0KJFCxo0aMBnn33Gxx9/TJs26d/AnTOHDh2iYcOG3H333bzwwgu5WjchIYGXX36Zu+++m0ceeYRy5cqxbdu2m56ME5Gip/ym/CZSVG6bS7FpnT59+qY/fZPCz88PLy+vQu5R8afLFA7G0S5TwG19KTYt5beCoRznYBwtxxWHS7FZqVKlSlF3QUSkQCi/iUhBspsXFIuIiIg4OhV2IiIiInZChZ2IiIiInVBhJyIiImInVNiJiIiI2AkVdiIiIiJ2QoWdiIiIiJ1QYSciIiJiJ1TYiYiIiNgJFXYiIiIidkKFnYiIiIidUGEnIiIiYidU2ImIiIjYCRV2IiIiInZChZ2IiIiInVBhJyIiImInVNiJiIiI2AkVdiIiIiJ2QoWdiIiIiJ1QYSciIiJiJ5yLugMiBc6YVNQ9KHyWSUXdgyIQC7xW1J0QKXzKcQ4g5/lNZ+xERERE7IQKOxERERE7ocJORERExE6osBMRERGxEyrsREREROyECjsRERERO6HCTkRERMROqLATERERsRMq7ERERETshAo7ERERETuhwk5ERETETqiwExEREbETKuxERERE7IQKOxERERE7ocJORERExE6osBMRERGxEyrsREREROyECjsRERERO6HCTkRERMROqLATERERsRMq7ERERETshAo7ERERETuhwk5ERETETqiwExEREbETKuwkBxYAgYAr0ATYk038h0Ct5Pi6wBfplhvABKAi4Aa0AX5JF/N/QE/AG/AFwoAreex/Ln17Gjp9AP6zwDIZ1h/Lfp1tv8K9b4PLVKjxJiw7eHPMgj0QOAdcp0KTJbDnd9vl12/AixugzAzwfBUeWwvnC2nMqZ3Eob5rEcDhfu8dNsc5xvdcLAu7Vq1aMXjw4KLuRp4FBgYyZ86cou5GDq0BhgITgf1APaAdcCGT+J3Ak5i/vAeArsmfQ2liZgBvAm8BuwGP5Davp4npCRwGtgCfA98CfW99ODlxNR7q+cGCDjmLP3UJOq6CBwLhYD8Y3BSe+xQ2HU+NWXMIhm6GiS1hfz+z/Xbvw4WrqTFDNsJnP8OH3WB7bzh7GR5dm58jy4YDfte3IeW3wuaAv/cOmeMc53u2GIZhFOgWCsD//d//UbJkSby8vIq6K3ly8eJFPDw8cHd3L7RtxsbG4uPjA8RgHjnkVBOgETA/eToJCAAGAqMziO8BXMX8BU7RFAjG/OU3AH9gGDA8eXkM4AcsA54AjgJ1gL1Aw+SYjUAH4Lfk9XPBmJS7+LQsk2FdD+haK/OYUVtgwy9waEDqvCc+gr+vw8anzekmS6CRP8xPTqRJBgREwMDGMLo5xFyHcjNh1WPweB0z5tifUHsBRIZB08q57Pek3MWbnaR4f9exgA8xMTF4e+fmd/z2ovyWN8pxeeQwOa64f885z2+33Rm7+Pj4bGNKly5dbJMeQLly5Qo96eVNPPAD5unlFCWSpyMzWScyXTyYRzAp8aeAc+lifDB3upSYSMxT1g3TxLRJ3vbu3AygcET+Bm2q2c5rV92cDxCfCD+ctY0pYTGnU2J++AMSkmxjapWFO30g8kzB9t/sJPquC57y2+1Gv/c5UuxznGN9z/lS2CUlJTFjxgxq1KiBi4sLd955J9OmTQNg1KhR3HXXXbi7u1OtWjXGjx9PQkKCdd1JkyYRHBzMkiVLqFq1Kq6urtluL/2lisDAQKZOnUpoaCienp5UqVKFTz/9lIsXL9KlSxc8PT2555572Ldvn3Wdv/76iyeffJJKlSrh7u5O3bp1+eCDD2y2c/nyZXr27ImHhwcVK1YkIiLipm3HxcUxfPhwKlWqhIeHB02aNGHbtm1Z9j/9pQqLxcKiRYt46KGHcHNzo1q1anz00Uc26+zcuZPg4GBcXV1p2LAh69evx2KxcPDgwWx/Xnn3J5CIeQSSlh/mL3RGzmUTfy7NvKxiyqdb7gyUzmK7RejcFfDzsJ3n5wmxcfBPAvx5DRKNDGI8zHVT2rjDCXxdM48pUPquM6P8Zq/5DfR7n0PFPsc51vecL4XdmDFjeO211xg/fjxHjhxh1apV+PmZg/Xy8mLZsmUcOXKEuXPnsnjxYiIiImzWP378OB9//DH//e9/87wjR0RE0KxZMw4cOEDHjh155plnCA0N5emnn2b//v1Ur16d0NBQUq48X79+nQYNGrBhwwYOHTpE3759eeaZZ9izJ/VmyqFDh7Jjxw4+/fRTtmzZwnfffcf+/fttthseHk5kZCSrV6/mf//7H926daN9+/b88kv6GyizNn78eB577DF+/PFHevbsyRNPPMHRo0cB8xJDp06dqFu3Lvv372fKlCmMGjUqy/bi4uKIjY21+YhI7im/3X75DZTjRDLjfKsNXL58mblz5zJ//nx69eoFQPXq1WnevDkA48aNs8YGBgYyfPhwVq9ezciRI63z4+PjWbFiBeXKlctzPzp06EC/fv0AmDBhAosWLaJRo0Z069YNMI+sQ0JCOH/+PBUqVKBSpUoMHz7cuv7AgQPZtGkTa9eupXHjxly+fJnly5ezatUqWrduDcDSpUvx90+9Jh4dHc3SpUuJjo62zh8+fDgbN25k6dKlvPrqqznuf7du3XjuuecAmDJlClu2bGHevHksXLiQVatWYbFYWLx4Ma6urtSpU4fff/+d559/PtP2pk+fzuTJk3O8/YyVBZyA8+nmnwcqZLJOhWziK6SZVzFdTHCamPQ3tN7AfLoos+0WoQqecP6q7bzzV8DbBdxKglMJcLJkEHPVXDeljfhE856VtEe0aWMKlL7rjCi/3Z75DZTjClWxz3GO9T3f8hm7o0ePEhcXZ00O6a1Zs4ZmzZpRoUIFPD09GTduHNHR0TYxVapUuaWkB3DPPfdY/51yNF23bt2b5l24YP6QExMTmTJlCnXr1qV06dJ4enqyadMma99OnjxJQkICjRs3trbh4+NDUFCQdfqnn34iMTGRu+66C09PT+tn+/btnDhxIlf9DwkJuWk65Yg2KiqKe+65x+YyTtp+ZWTMmDHExMRYP2fO5OUehjuABsBXaeYlJU+HZLiGOf+rdPO2pImvivkLnTYmFvN+g5SYEOBvzHsiUnydvO0muRlA4QipDF+dsp235aQ5H8zLDw384auTqcuTDHM6JaZBRShZwjYm6k+IjoGQgILtv9lJ9F3fTPnt9sxvoBxXqIp9jnOs7/mWz9i5ublluiwyMpKePXsyefJk2rVrh4+PD6tXr2bWrFk2cR4eHpm0kHMlS5a0/ttisWQ6LykpCYCZM2cyd+5c5syZQ926dfHw8GDw4ME5urk5xZUrV3BycuKHH37AycnJZpmnZ2GcZcmci4sLLi4u+dDSUKAX5s2fjYE5mE8K9UleHgpUAqYnTw8CWgKzgI7AamAf8E7ycgswGJgK1MTcOcZjPh3UNTmmNtAeeB7z6aMEIBzzKaNcPi2WF1fi4fj/pU6fugQHz0FpN/NG3zFb4ffLsOIRc/kLDWH+Xhi5BZ6tD1+fgrWHYcNTqW0MbQq91kNDf2hcCebsgqsJ0CfYXO7jCmH1zdcFlHYzj4QHfmkmxdw+LZZnDvhdZ0P57fbMb6Acd0scMsc5zvd8y4VdzZo1cXNz46uvvrKeak+xc+dOqlSpwtixY63zTp8+faubzBc7duygS5cuPP20+ah2UlISP//8M3XqmI9hV6tWjZIlS7J3717uvPNOAGJiYvj5559p0aIFAPXr1ycxMZELFy5w//3331J/du3aRWhoqM10/fr1AQgKCuL9998nLi7Omsj27t17S9vLuR7ARcyXMJ7DPMW8kdQbRqOxPfF7H7AKGAe8jPkLvx74V5qYkZg7VF/Mo5nmyW2mval2JeYO0Dq5/ccw3xdUCPadhQeWp04P3Wz+t1c9WNYV/rhiHmWmqFrKTHBDNsHc3VDZG5Z0hnY1UmN6/AsuXoMJ28wbhYMrwMae5g3IKSLaQ4lN5ks74xLNp84WdizIkabjgN91NpTf7D2/gUP+3jtkjnOc7/mWCztXV1dGjRrFyJEjueOOO2jWrBkXL17k8OHD1KxZk+joaFavXk2jRo3YsGED69aty49+37KaNWvy0UcfsXPnTkqVKsXs2bM5f/68NfF5eXnRq1cvRowYQenSpSlfvjwTJ06kRIkS1qPju+66i549exIaGsqsWbOoX78+Fy9e5KuvvuKee+6hY8eO/P7777Ru3ZoVK1ZkeXnhww8/pGHDhjRv3pyVK1eyZ88e3n33XQCeeuopxo4dS9++fRk9ejTR0dG88cYbQOqResEKT/5kZFsG87olfzJjAV5J/mSmNOZOVQRaBYIxMfPly7pmvM6Bflm3G97Y/GTG1RkWdDQ/RcbBvutsKL85Qn4Dh/u9d9gc5xjfc748FTt+/HiGDRvGhAkTqF27Nj169ODChQt07tyZIUOGEB4eTnBwMDt37mT8+PH5sclbNm7cOO69917atWtHq1atqFChAl27drWJmT17NiEhITz88MO0adOGZs2aUbt2bZt7QZYuXUpoaCjDhg0jKCiIrl272hwFJyQkEBUVxbVr17Lsz+TJk1m9ejX33HMPK1as4IMPPrAmYW9vbz777DMOHjxIcHAwY8eOZcKECQA5en2CiOSd8pvym0hxUiz/8kRRuXr1KpUqVWLWrFmEhYXluZ2KFSsyZcoU66Udi8XCunXrbkq8WVm5ciV9+vQhJiYmy/uAUuT9rex24Fbeyl5c5ekvTxR39vGXJ4pKcc5voBzncBwux+U8v93ypVh7duDAAY4dO0bjxo2JiYnhlVfM061dunTJU3vXrl1jx44dnD9/nrvvvjtX665YsYJq1apRqVIlfvzxR0aNGkX37t1znPRERNJSfhOxT7ddYRcdHW09RZ+RI0eOWC8DFIY33niDqKgo7rjjDho0aMB3331H2bJl89TWO++8w5QpUxg8ePBNj/9n59y5c0yYMIFz585RsWJFunXrZn37vYgUD8pvGVN+E8k/t92l2Bs3bvDrr79mujwwMBBn59uuHr3t6TKFg3G4yxRQHC7FKr8VHOU4B+NwOa4YX4p1dnamRo0a2QeKiBQzym8iUtDy5alYERERESl6KuxERERE7IQKOxERERE7ocJORERExE6osBMRERGxEyrsREREROyECjsRERERO6HCTkRERMROqLATERERsRMq7ERERETshAo7ERERETuhwk5ERETETqiwExEREbETKuxERERE7IQKOxERERE7ocJORERExE6osBMRERGxEyrsREREROyECjsRERERO+Fc1B2QQhYzHbxdiroXhcsyqah7ICKFRTlOHJzO2ImIiIjYCRV2IiIiInZChZ2IiIiInVBhJyIiImInVNiJiIiI2AkVdiIiIiJ2QoWdiIiIiJ1QYSciIiJiJ1TYiYiIiNgJFXYiIiIidkKFnYiIiIidUGEnIiIiYidU2ImIiIjYCRV2IiIiInZChZ2IiIiInVBhJyIiImInVNiJiIiI2AkVdiIiIiJ2QoWdiIiIiJ1QYSciIiJiJ1TYiYiIiNgJFXYiIiIidkKFnYiIiIidUGEnIiIiYidU2ImIiIjYiVwVdq1atWLw4MGZLg8MDGTOnDm57sSkSZMIDg7OUWzv3r3p2rVrrrdxu8juZ3jb+fY0dPoA/GeBZTKsP5b9Ott+hXvfBpepUONNWHbw5pgFeyBwDrhOhSZLYM/vtsuv34AXN0CZGeD5Kjy2Fs5fyYcB5cYCIBBwBZoAe7KJ/xColRxfF/gi3XIDmABUBNyANsAv6WL+D+gJeAO+QBhQmON2xDGnUo67dcUqxym/4Vj7umOMOV/P2O3du5e+ffvmZ5M3mTt3LsuWLSvQbRSk//73v0yZMqWou5FzV+Ohnh8s6JCz+FOXoOMqeCAQDvaDwU3huU9h0/HUmDWHYOhmmNgS9vcz22/3Ply4mhozZCN89jN82A2294azl+HRtfk5smysAYYCE4H9QD2gHXAhk/idwJOYO+0BoGvy51CamBnAm8BbwG7AI7nN62liegKHgS3A58C3QMHuU6kcccy5oxyXvWKV45TfcJx93XHGnK+FXbly5XB3d890eUJCwi1vw8fHB19f31tup6iULl0aLy+vou5Gzj1UE6b+Gx6pnbP4t/ZBVV+Y1Q5ql4PwxvB4HYjYlRozexc8fy/0qQ91ysFbD4N7SfjPAXN5zHV49wDMbgf/rgoN/GFpF9h5Bnb9lu9DzNhs4HmgD1AHc8d1B/6TSfxcoD0wAqgNTAHuBeYnLzeAOcA4oAtwD7ACOAusT445CmwElmAeTTYH5gGrk+MKmiOOOXeU47JXrHKc8huOs687zphzXdjduHGD8PBwfHx8KFu2LOPHj8cwDODmyxQWi4VFixbRuXNnPDw8mDZtGgCvvfYafn5+eHl5ERYWxvXr1zPaVIbSX6Zo1aoVAwcOZPDgwZQqVQo/Pz8WL17M1atX6dOnD15eXtSoUYMvv/zSuk5iYiJhYWFUrVoVNzc3goKCmDt37k3jfOmll/D19aVMmTKMGjWKXr162Ww7KSmJ6dOnW9upV68eH330UZb9T3+ZIjAwkClTpvDkk0/i4eFBpUqVWLBggc06x44do3nz5ri6ulKnTh22bt2KxWJh/fr1Of65FZrI36BNNdt57aqb8wHiE+GHs7YxJSzmdErMD39AQpJtTK2ycKcPRJ4p2P6bnQR+wDytbu1k8nRkJutEposH88gtJf4UcC5djA/mzp4SE4l5qr5hmpg2ydvenZsB5IEjjjljynGp21aOS0f5LY3itK871phzXdgtX74cZ2dn9uzZw9y5c5k9ezZLlizJNH7SpEk88sgj/PTTTzz77LOsXbuWSZMm8eqrr7Jv3z4qVqzIwoULb2kQy5cvp2zZsuzZs4eBAwfSv39/unXrxn333cf+/ft58MEHeeaZZ7h27RpgJqvKlSvz4YcfcuTIESZMmMDLL7/M2rWpp8Jff/11Vq5cydKlS9mxYwexsbE3JZnp06ezYsUK3nrrLQ4fPsyQIUN4+umn2b59e676P3PmTOrVq8eBAwcYPXo0gwYNYsuWLYCZoLt27Yq7uzu7d+/mnXfeYezYsdm2GRcXR2xsrM2nUJy7An4etvP8PCE2Dv5JgD+vQaKRQYyHuW5KG3c4ga9r5jEF6k8gEfBLN98Pc0fOyLls4s+lmZdVTPl0y52B0llsN7844pgzphyXSjkuHeW3TOJv933dscbsnNsVAgICiIiIwGKxEBQUxE8//URERATPP/98hvFPPfUUffr0sU4/8cQThIWFERYWBsDUqVPZunVrro5o06tXrx7jxo0DYMyYMbz22muULVvW2qcJEyawaNEi/ve//9G0aVNKlizJ5MmTretXrVqVyMhI1q5dS/fu3QGYN28eY8aM4ZFHHgFg/vz5fPFF6o2TcXFxvPrqq2zdupWQkBAAqlWrxvfff8/bb79Ny5Ytc9z/Zs2aMXr0aADuuusuduzYQUREBG3btmXLli2cOHGCbdu2UaFCBQCmTZtG27Zts2xz+vTpNmMUkZxRjjMpx4kUT7k+Y9e0aVMsFot1OiQkhF9++YXExMQM4xs2bGgzffToUZo0aWIzLyVp5NU999xj/beTkxNlypShbt261nl+fmZFfeFC6k2SCxYsoEGDBpQrVw5PT0/eeecdoqOjAYiJieH8+fM0btzYpt0GDRpYp48fP861a9do27Ytnp6e1s+KFSs4ceJErvqffvwhISEcPXoUgKioKAICAqwJD7DpV2bGjBlDTEyM9XPmTGGc4gcqeML5q7bzzl8BbxdwKwll3cHJkkHMVXPdlDbiE+Hv65nHFKiygBNwPt3880CFm8MheX5W8RXSzMsqJv2NvDcwn6rKbLv5xRHHnDHlOJNyXAaU3zKJv933dccac4G/x87DwyP7oFtUsmRJm2mLxWIzLyVJJyUlAbB69WqGDx9OWFgYmzdv5uDBg/Tp04f4+Pgcb/PKFfOU+YYNGzh48KD1c+TIkWzvQSkMLi4ueHt723wKRUhl+OqU7bwtJ835YF6CaOAPX51MXZ5kmNMpMQ0qQskStjFRf0J0DIQEFGz/zU4CDYCv0sxLSp7O7H/QIeniwXwKKiW+KuaOnDYmFvM+i5SYEOBvzHtBUnydvG3bQiH/OeKY84dyXNEokhyn/JZGcdrXHWvMub4Uu3u37Q1/u3btombNmjg5OeVo/dq1a7N7925CQ0Nt2ihMO3bs4L777mPAgAHWeWmPQH18fPDz82Pv3r20aNECMO8D2b9/v/VdVHXq1MHFxYXo6OhcXZLISPrx79q1i9q1zae0goKCOHPmDOfPn7cele/du/eWtpcrV+Lh+P+lTp+6BAfPQWk382bfMVvh98uwwrycwwsNYf5eGLkFnq0PX5+CtYdhw1OpbQxtCr3WQ0N/aFwJ5uyCqwnQJ9hc7uMKYfXNVwaUdjOPhgd+aSbGppULaeBDgV6YN702xnz66SrmE1UAoUAlYHry9CCgJTAL6Ij51NM+4J3k5RZgMDAVqImZFMYD/piP0IP55FV7zCe33gISgHDgieS4guaIY76Zclww4CA5TvkNx9nXHWfMuS7soqOjGTp0KP369WP//v3MmzePWbNm5Xj9QYMG0bt3bxo2bEizZs1YuXIlhw8fplq1atmvnE9q1qzJihUr2LRpE1WrVuW9995j7969VK1a1RozcOBApk+fTo0aNahVqxbz5s3j0qVL1iNjLy8vhg8fzpAhQ0hKSqJ58+bExMSwY8cOvL296dWrFwC1atVi+vTp1vtYMrJjxw5mzJhB165d2bJlCx9++CEbNmwAoG3btlSvXp1evXoxY8YMLl++bL3XJu3logKz7yw8sDx1euhm87+96sGyrvDHFfNIM0XVUmaSG7IJ5u6Gyt6wpDO0q5Ea0+NfcPEaTNhm3iwcXAE29jRvQk4R0R5KbDJf3BmXaD55trBjQY40nR7ARcyXT54DgjEfW0+5UTYa2xPe9wGrMB99fxlzR18P/CtNzEjMRNIX8yiueXKbaW+iXom547dObv8xzPckFQZHHPPNlOMcKMcpv+E4+7rjjDnXhV1oaCj//PMPjRs3xsnJiUGDBuXqhZ09evTgxIkTjBw5kuvXr/PYY4/Rv39/Nm3alNuu5Fm/fv04cOAAPXr0wGKx8OSTTzJgwACb1wWMGjWKc+fOERoaipOTE3379qVdu3Y2R+1TpkyhXLlyTJ8+nZMnT+Lr68u9997Lyy+/bI2JiooiJiaGrAwbNox9+/YxefJkvL29mT17Nu3atQPM+17Wr1/Pc889R6NGjahWrRozZ86kU6dOuLq6ZtluvmgVCMbEzJcv65rxOgf6Zd1ueGPzkxlXZ1jQ0fwUmfDkT0a2ZTCvW/InMxbgleRPZkpjJpOi4ohjtqUc50A5Tvktk2XbMphnD/u6Y4zZYqS8oEmylJSURO3atenevfstvVU9JCSE1q1bM3XqVMB8x9PgwYNz9Sd4duzYQfPmzTl+/DjVq1fP0TqxsbH4+PhAzGjz1L8jsUwq6h5IoYgFfIiJiSm8e0rtiHJcMaYc5wBynt9yfcbOUZw+fZrNmzfTsmVL4uLimD9/PqdOneKpp57KfuUMxMXF8dNPP3H48GFeeumlXK27bt06PD09qVmzJsePH2fQoEE0a9YsxwlPRCQ95TgR+1TgT8XmVtrH6tN/vvvuu0LrR4kSJVi2bBmNGjWiWbNm/PTTT2zdutV6w29uffnll/z73/+mc+fOPP7447la9/Lly7z44ovUqlWL3r1706hRIz755JM89UNEipZy3M2U40Tyz213Kfb48eOZLqtUqRJubm6F2Bv7ocsUYv+Kx6VY5biCoRwn9q0YX4qtUaNG9kEiIsWUcpyIFKTb7lKsiIiIiOSNCjsRERERO6HCTkRERMROqLATERERsRMq7ERERETshAo7ERERETuhwk5ERETETqiwExEREbETKuxERERE7IQKOxERERE7ocJORERExE6osBMRERGxEyrsREREROyECjsRERERO6HCTkRERMROqLATERERsRMq7ERERETshAo7ERERETuhwk5ERETETjgXdQekcBiGYf4jNq5oO1IkYou6A1IozO/Z+rsuDkU5TuxbzvObxVAWdAi//fYbAQEBRd0NkQJ35swZKleuXNTdkEKmHCeOICf5TYWdg0hKSuLs2bN4eXlhsVgKdduxsbEEBARw5swZvL29C3XbRcURxwxFO27DMLh8+TL+/v6UKKG7TByNclzh0phv3/ymS7EOokSJEkV+FsPb29thEkAKRxwzFN24fXx8Cn2bcntQjisaGnPhyWl+02GtiIiIiJ1QYSciIiJiJ1TYSYFzcXFh4sSJuLi4FHVXCo0jjhkcd9zi2Bzx915jvn3p4QkRERERO6EzdiIiIiJ2QoWdiIiIiJ1QYSciIiJiJ1TYiYiIiNgJFXYiIiIidkKFnYiIiIidUGEnIiIiYidU2ImIiIjYif8HPfsaqu6vL5wAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fp_text_audio_scores = softmax(embeddings[ModalityType.AUDIO] @ embeddings[ModalityType.TEXT].T, axis=-1)\n",
    "int_text_audio_scores = softmax(quantized_embeddings[ModalityType.AUDIO] @ quantized_embeddings[ModalityType.TEXT].T, axis=-1)\n",
    "\n",
    "visualize_prob_matrices(fp_text_audio_scores, int_text_audio_scores, text_list, image_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d11e9584",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fp_audio_vision_scores = softmax(embeddings[ModalityType.VISION] @ embeddings[ModalityType.AUDIO].T, axis=-1)\n",
    "int_audio_vision_scores = softmax(quantized_embeddings[ModalityType.VISION] @ quantized_embeddings[ModalityType.AUDIO].T, axis=-1)\n",
    "\n",
    "visualize_prob_matrices(fp_audio_vision_scores, int_audio_vision_scores, text_list, image_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5173300",
   "metadata": {},
   "source": [
    "#### Compare File Size [$\\Uparrow$](#Table-of-content:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d87de6af",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_compression_rate(modality):\n",
    "    fp16_ir_model_size = Path(fp_model_paths[modality]).with_suffix(\".bin\").stat().st_size / 1024\n",
    "    quantized_model_size = Path(int8_model_paths[modality]).with_suffix(\".bin\").stat().st_size / 1024\n",
    "    print(f'Modality: {modality}')\n",
    "    print(f\"    * FP16 IR model size: {fp16_ir_model_size:.2f} KB\")\n",
    "    print(f\"    * INT8 model size: {quantized_model_size:.2f} KB\")\n",
    "    print(f\"    * Model compression rate: {fp16_ir_model_size / quantized_model_size:.3f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3d673a2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modality: text\n",
      "    * FP16 IR model size: 691481.76 KB\n",
      "    * INT8 model size: 396414.89 KB\n",
      "    * Model compression rate: 1.744\n",
      "Modality: vision\n",
      "    * FP16 IR model size: 1235995.30 KB\n",
      "    * INT8 model size: 620295.82 KB\n",
      "    * Model compression rate: 1.993\n",
      "Modality: audio\n",
      "    * FP16 IR model size: 168429.25 KB\n",
      "    * INT8 model size: 84856.83 KB\n",
      "    * Model compression rate: 1.985\n"
     ]
    }
   ],
   "source": [
    "for modality in modalities:\n",
    "    calculate_compression_rate(modality)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c5bd231",
   "metadata": {},
   "source": [
    "#### Compare inference time of the FP16 IR and quantized models [$\\Uparrow$](#Table-of-content:)\n",
    "To measure the inference performance of the `FP16` and `INT8` models, we use median inference time on calibration dataset.\n",
    "So we can approximately estimate the speed up of the dynamic quantized models.\n",
    "\n",
    "\n",
    "> **NOTE**: For the most accurate performance estimation, it is recommended to run `benchmark_app` in a terminal/command prompt after closing other applications with static shapes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "92ce5218",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def calculate_inference_time(model_path, calibration_data):\n",
    "    model = compile_model(model_path)\n",
    "    output_layer = model.output(0)\n",
    "    inference_time = []\n",
    "    for batch in calibration_data:\n",
    "        start = time.perf_counter()\n",
    "        _ = model(batch)[output_layer]\n",
    "        end = time.perf_counter()\n",
    "        delta = end - start\n",
    "        inference_time.append(delta)\n",
    "    return np.median(inference_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "108e7533",
   "metadata": {},
   "source": [
    "Vision model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c59a370",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance speed up: 1.121\n"
     ]
    }
   ],
   "source": [
    "fp16_latency = calculate_inference_time(fp_model_paths[ModalityType.VISION], vision_data)\n",
    "int8_latency = calculate_inference_time(int8_model_paths[ModalityType.VISION], vision_data)\n",
    "print(f\"Performance speed up: {fp16_latency / int8_latency:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4775b72a",
   "metadata": {},
   "source": [
    "Text model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "8ef63bf6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance speed up: 1.064\n"
     ]
    }
   ],
   "source": [
    "fp16_latency = calculate_inference_time(fp_model_paths[ModalityType.TEXT], text_data)\n",
    "int8_latency = calculate_inference_time(int8_model_paths[ModalityType.TEXT], text_data)\n",
    "print(f\"Performance speed up: {fp16_latency / int8_latency:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1d075b5",
   "metadata": {},
   "source": [
    "Audio model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "88ed82c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance speed up: 6.399\n"
     ]
    }
   ],
   "source": [
    "fp16_latency = calculate_inference_time(fp_model_paths[ModalityType.AUDIO], audio_calibration_data)\n",
    "int8_latency = calculate_inference_time(int8_model_paths[ModalityType.AUDIO], audio_calibration_data)\n",
    "print(f\"Performance speed up: {fp16_latency / int8_latency:.3f}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}