{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "230d48e7",
   "metadata": {},
   "source": [
    "Binned acquisition\n",
    "==================\n",
    "\n",
    "In this tutorial, we will demonstrate the sequencer-based acquisition binning procedure. The binning process is applied on the input path after real-time demodulation, (weighed) integration, IQ rotation and discretization. It allows storing both the integration and discretization\n",
    "results on the fly without intervention of the host PC in up to 131072 bins. It also allows the averaging of those bins on the fly\n",
    "(see section [Sequencer Acquisition](https://docs.qblox.com/en/main/cluster/q1_sequence_processor.html#acquisitions)).\n",
    "We will then use the module sequencers to sequence waveforms on the outputs and, simultaneously, acquire the resulting waveforms on the inputs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "559eb2ea",
   "metadata": {
    "tags": [
     "connectivity"
    ]
   },
   "source": [
    "We will show this by using a QRM and directly connecting outputs $\\text{O}^{[1-2]}$ to inputs $\\text{I}^{[1-2]}$, respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "964f4aba",
   "metadata": {
    "tags": []
   },
   "source": [
    "Setup\n",
    "-----\n",
    "\n",
    "First, we are going to import the required packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e27369a2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:48.325715Z",
     "iopub.status.busy": "2025-05-07T16:53:48.325416Z",
     "iopub.status.idle": "2025-05-07T16:53:49.196405Z",
     "shell.execute_reply": "2025-05-07T16:53:49.195382Z"
    },
    "tags": [
     "imports"
    ]
   },
   "outputs": [],
   "source": [
    "from __future__ import annotations\n",
    "\n",
    "import json\n",
    "import math\n",
    "from typing import TYPE_CHECKING, Callable\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.signal\n",
    "from qcodes.instrument import find_or_create_instrument\n",
    "\n",
    "from qblox_instruments import Cluster, ClusterType\n",
    "\n",
    "if TYPE_CHECKING:\n",
    "    from qblox_instruments.qcodes_drivers.module import Module"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12a542e7",
   "metadata": {},
   "source": [
    "### Scan For Clusters\n",
    "\n",
    "We scan for the available devices connected via ethernet using the Plug & Play functionality of the Qblox Instruments package (see [Plug & Play](https://docs.qblox.com/en/main/api_reference/tools.html#api-pnp) for more info)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a86d573f",
   "metadata": {},
   "source": [
    "`!qblox-pnp list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "da96cd8e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:49.200103Z",
     "iopub.status.busy": "2025-05-07T16:53:49.199677Z",
     "iopub.status.idle": "2025-05-07T16:53:49.203031Z",
     "shell.execute_reply": "2025-05-07T16:53:49.202331Z"
    }
   },
   "outputs": [],
   "source": [
    "cluster_ip = \"10.10.200.42\"\n",
    "cluster_name = \"cluster0\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bb0365e",
   "metadata": {},
   "source": [
    "### Connect to Cluster\n",
    "\n",
    "We now make a connection with the Cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ff6995dd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:49.205004Z",
     "iopub.status.busy": "2025-05-07T16:53:49.204725Z",
     "iopub.status.idle": "2025-05-07T16:53:50.063560Z",
     "shell.execute_reply": "2025-05-07T16:53:50.061709Z"
    },
    "lines_to_next_cell": 2
   },
   "outputs": [],
   "source": [
    "cluster = find_or_create_instrument(\n",
    "    Cluster,\n",
    "    recreate=True,\n",
    "    name=cluster_name,\n",
    "    identifier=cluster_ip,\n",
    "    dummy_cfg=(\n",
    "        {\n",
    "            2: ClusterType.CLUSTER_QCM,\n",
    "            4: ClusterType.CLUSTER_QRM,\n",
    "            6: ClusterType.CLUSTER_QCM_RF,\n",
    "            8: ClusterType.CLUSTER_QRM_RF,\n",
    "            10: ClusterType.CLUSTER_QTM,\n",
    "        }\n",
    "        if cluster_ip is None\n",
    "        else None\n",
    "    ),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c22b33a1",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "#### Get connected modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "66a7bd2d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:50.068029Z",
     "iopub.status.busy": "2025-05-07T16:53:50.067736Z",
     "iopub.status.idle": "2025-05-07T16:53:50.073303Z",
     "shell.execute_reply": "2025-05-07T16:53:50.072323Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_connected_modules(cluster: Cluster, filter_fn: Callable | None = None) -> dict[int, Module]:\n",
    "    def checked_filter_fn(mod: ClusterType) -> bool:\n",
    "        if filter_fn is not None:\n",
    "            return filter_fn(mod)\n",
    "        return True\n",
    "\n",
    "    return {\n",
    "        mod.slot_idx: mod for mod in cluster.modules if mod.present() and checked_filter_fn(mod)\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d3bc9041",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:50.076668Z",
     "iopub.status.busy": "2025-05-07T16:53:50.076358Z",
     "iopub.status.idle": "2025-05-07T16:53:50.095330Z",
     "shell.execute_reply": "2025-05-07T16:53:50.094358Z"
    },
    "tags": [
     "module_select"
    ]
   },
   "outputs": [],
   "source": [
    "# QRM modules\n",
    "modules = get_connected_modules(cluster, lambda mod: mod.is_qrm_type and not mod.is_rf_type)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8cdfb8f4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:50.098808Z",
     "iopub.status.busy": "2025-05-07T16:53:50.098216Z",
     "iopub.status.idle": "2025-05-07T16:53:50.102046Z",
     "shell.execute_reply": "2025-05-07T16:53:50.101077Z"
    }
   },
   "outputs": [],
   "source": [
    "# This uses the module of the correct type with the lowest slot index\n",
    "module = list(modules.values())[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88f3a2cc",
   "metadata": {},
   "source": [
    "### Reset the Cluster\n",
    "\n",
    "We reset the Cluster to enter a well-defined state. Note that resetting will clear all stored parameters, so resetting between experiments is usually not desirable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9eb8419f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:50.105354Z",
     "iopub.status.busy": "2025-05-07T16:53:50.105095Z",
     "iopub.status.idle": "2025-05-07T16:53:52.657113Z",
     "shell.execute_reply": "2025-05-07T16:53:52.655338Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, Flags: NONE, Slot flags: NONE\n"
     ]
    }
   ],
   "source": [
    "cluster.reset()\n",
    "print(cluster.get_system_status())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c27e042b",
   "metadata": {},
   "source": [
    "Generate waveforms and weights<a id='gen_wf'></a>\n",
    "------------------------------\n",
    "\n",
    "Next, we need to create the waveforms used by the sequence for playback on the outputs as well as weights used by the sequence for weighed\n",
    "integrations. To keep it straightforward, we use the DC offset from the sequencers as our waveform and define waveform weights in the cell\n",
    "below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b3056862",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:52.661773Z",
     "iopub.status.busy": "2025-05-07T16:53:52.661316Z",
     "iopub.status.idle": "2025-05-07T16:53:52.672037Z",
     "shell.execute_reply": "2025-05-07T16:53:52.670708Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Waveform and weight parameters\n",
    "waveform_weight_length = 600  # nanoseconds\n",
    "\n",
    "# These will be used as weights in the \"Weighed acquisition\" section\n",
    "waveforms_weights = {\n",
    "    \"gaussian\": {\n",
    "        \"data\": scipy.signal.windows.gaussian(\n",
    "            waveform_weight_length, std=0.12 * waveform_weight_length\n",
    "        ).tolist(),\n",
    "        \"index\": 0,\n",
    "    },\n",
    "    \"sine\": {\n",
    "        \"data\": [\n",
    "            math.sin((2 * math.pi / waveform_weight_length) * i)\n",
    "            for i in range(0, waveform_weight_length)\n",
    "        ],\n",
    "        \"index\": 1,\n",
    "    },\n",
    "    \"block\": {\"data\": [1.0 for _ in range(0, waveform_weight_length)], \"index\": 2},\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c138638c",
   "metadata": {},
   "source": [
    "Specify acquisitions\n",
    "--------------------\n",
    "\n",
    "We also need to specify the acquisitions so that the instrument can allocate the required memory for its acquisition list. In this case we will create 4 acquisition specifications that each create multiple bins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d3d37c9a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:52.676035Z",
     "iopub.status.busy": "2025-05-07T16:53:52.675626Z",
     "iopub.status.idle": "2025-05-07T16:53:52.682550Z",
     "shell.execute_reply": "2025-05-07T16:53:52.681221Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Acquisitions\n",
    "acquisitions = {\n",
    "    \"non_weighed\": {\"num_bins\": 10, \"index\": 0},\n",
    "    \"weighed\": {\"num_bins\": 10, \"index\": 1},\n",
    "    \"large\": {\"num_bins\": 131072, \"index\": 2},\n",
    "    \"avg\": {\"num_bins\": 10, \"index\": 3},\n",
    "    \"single\": {\"num_bins\": 1, \"index\": 4},\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bc3ea54",
   "metadata": {},
   "source": [
    "Create Q1ASM program\n",
    "--------------------\n",
    "\n",
    "Now that we have the waveform and acquisition specifications for the sequence, we need a simple Q1ASM program that sequences the waveforms and triggers the acquisitions.\n",
    "In this case we will simply trigger 10 non-weighed acquisitions and store each acquisition in a separate bin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "841082bd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:52.686572Z",
     "iopub.status.busy": "2025-05-07T16:53:52.686124Z",
     "iopub.status.idle": "2025-05-07T16:53:52.692448Z",
     "shell.execute_reply": "2025-05-07T16:53:52.691135Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Sequence program.\n",
    "seq_prog = \"\"\"\n",
    "      move    0,R0        #Loop iterator.\n",
    "      nop\n",
    "\n",
    "loop: acquire 0,R0,1200   #Acquire bins and store them in \"non_weighed\" acquisition.\n",
    "      add     R0,1,R0     #Increment iterator\n",
    "      nop                 #Wait a cycle for R0 to be available.\n",
    "      jlt     R0,10,@loop #Run until number of iterations is done.\n",
    "\n",
    "      stop                #Stop.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b203371",
   "metadata": {},
   "source": [
    "Upload sequence\n",
    "---------------\n",
    "\n",
    "Now that we have the waveform, weights and acquisition specifications and Q1ASM program, we can combine them in a sequence stored in a JSON file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "69c862aa",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:52.696270Z",
     "iopub.status.busy": "2025-05-07T16:53:52.695863Z",
     "iopub.status.idle": "2025-05-07T16:53:52.712279Z",
     "shell.execute_reply": "2025-05-07T16:53:52.710986Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Add sequence program, waveforms, weights and acquisitions to single dictionary and write to JSON file.\n",
    "sequence = {\n",
    "    \"waveforms\": waveforms_weights,\n",
    "    \"weights\": waveforms_weights,\n",
    "    \"acquisitions\": acquisitions,\n",
    "    \"program\": seq_prog,\n",
    "}\n",
    "with open(\"sequence.json\", \"w\", encoding=\"utf-8\") as file:\n",
    "    json.dump(sequence, file, indent=4)\n",
    "    file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "913bfad1",
   "metadata": {},
   "source": [
    "Let's write the JSON file to the instruments. We will use sequencer 0, which will drive outputs $\\text{O}^{[1-2]}$ and acquire on inputs $\\text{I}^{[1-2]}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7fc8ef31",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:52.716039Z",
     "iopub.status.busy": "2025-05-07T16:53:52.715622Z",
     "iopub.status.idle": "2025-05-07T16:53:52.820584Z",
     "shell.execute_reply": "2025-05-07T16:53:52.819104Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Upload sequence.\n",
    "module.sequencer0.sequence(\"sequence.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e508e358",
   "metadata": {},
   "source": [
    "Play sequence\n",
    "-------------\n",
    "\n",
    "The sequence has been uploaded to the instrument. Now we need to configure the sequencers. To keep it simple we will set a DC signal on the outputs of the instrument by enabling the sequencer offsets and disabling the modulation. These DC signals will then be acquired through the inputs. As such, we will also disable the demodulation on the input path. Furthermore, since we are running non-weighed integrations, we need to specify the integration length. This integration length will be used for every non-weighed integration moving forward. We will also put the integration result acquisition rotation to 0 degrees and acquisition threshold to 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3507854c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:52.824716Z",
     "iopub.status.busy": "2025-05-07T16:53:52.824265Z",
     "iopub.status.idle": "2025-05-07T16:53:52.861107Z",
     "shell.execute_reply": "2025-05-07T16:53:52.859642Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Map sequencer to specific outputs (but first disable all sequencer connections)\n",
    "module.disconnect_outputs()\n",
    "module.disconnect_inputs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3619024d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:52.864913Z",
     "iopub.status.busy": "2025-05-07T16:53:52.864502Z",
     "iopub.status.idle": "2025-05-07T16:53:52.880697Z",
     "shell.execute_reply": "2025-05-07T16:53:52.879368Z"
    },
    "tags": [
     "connect"
    ]
   },
   "outputs": [],
   "source": [
    "module.sequencer0.connect_sequencer(\"io0_1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9d9b3c28",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:52.884673Z",
     "iopub.status.busy": "2025-05-07T16:53:52.884228Z",
     "iopub.status.idle": "2025-05-07T16:53:52.951866Z",
     "shell.execute_reply": "2025-05-07T16:53:52.950370Z"
    }
   },
   "outputs": [],
   "source": [
    "# Configure scope mode\n",
    "module.scope_acq_sequencer_select(0)\n",
    "module.scope_acq_trigger_mode_path0(\"sequencer\")\n",
    "module.scope_acq_trigger_mode_path1(\"sequencer\")\n",
    "\n",
    "# Set AWG offsets\n",
    "module.sequencer0.offset_awg_path0(0.5)\n",
    "module.sequencer0.offset_awg_path1(0.5)\n",
    "\n",
    "# Configure integration\n",
    "module.sequencer0.integration_length_acq(1000)\n",
    "module.sequencer0.thresholded_acq_rotation(0)\n",
    "module.sequencer0.thresholded_acq_threshold(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ada59c2f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:52.955740Z",
     "iopub.status.busy": "2025-05-07T16:53:52.955284Z",
     "iopub.status.idle": "2025-05-07T16:53:52.978942Z",
     "shell.execute_reply": "2025-05-07T16:53:52.977593Z"
    },
    "tags": [
     "configure"
    ]
   },
   "outputs": [],
   "source": [
    "# Configure the sequencer\n",
    "module.sequencer0.mod_en_awg(False)\n",
    "module.sequencer0.demod_en_acq(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf1f1516",
   "metadata": {},
   "source": [
    "Now let's start the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9145258f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:52.982806Z",
     "iopub.status.busy": "2025-05-07T16:53:52.982346Z",
     "iopub.status.idle": "2025-05-07T16:53:52.997057Z",
     "shell.execute_reply": "2025-05-07T16:53:52.995717Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, State: STOPPED, Info Flags: ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n"
     ]
    }
   ],
   "source": [
    "# Arm and start sequencer.\n",
    "module.arm_sequencer(0)\n",
    "module.start_sequencer()\n",
    "\n",
    "# Print status of sequencer.\n",
    "print(module.get_sequencer_status(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86ea16ce",
   "metadata": {},
   "source": [
    "Retrieve acquisition\n",
    "--------------------\n",
    "\n",
    "Next, we will have a quick look at the input signal so that we can compare it to the integration results. Since we are integrating over a DC signal we are expecting the integration results to be roughly equal to the average DC value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d3bfdf56",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:53.001120Z",
     "iopub.status.busy": "2025-05-07T16:53:53.000702Z",
     "iopub.status.idle": "2025-05-07T16:53:53.896585Z",
     "shell.execute_reply": "2025-05-07T16:53:53.895865Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3oAAAIsCAYAAACk89smAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzddbwUVf8H8M9s3OQGIVw6REEQsBNBQgwsUH8qqA/6IIqP8WCgWJiYGI8JBqiUSQsGCIKIKCCCpOQFJARuwN3e+f2xdWZ2Zna2bvF5v16+5O7OzpzdnZ053xPfI8myLIOIiIiIiIhqDUtVF4CIiIiIiIhSi4EeERERERFRLcNAj4iIiIiIqJZhoEdERERERFTLMNAjIiIiIiKqZRjoERERERER1TIM9IiIiIiIiGoZBnpERERERES1jK2qC0Cx+f1+7N69G3l5eZAkqaqLQ0REREREVUSWZZSXl6NJkyawWPT77Rjo1QC7d+9G8+bNq7oYRERERERUTRQXF6NZs2a6zzPQqwHy8vIABL7M/Pz8Ki4NERERERFVlbKyMjRv3jwcI+hhoFcDhIZr5ufnM9AjIiIiIqKYU7qYjIWIiIiIiKiWYaBHRERERERUyzDQIyIiIiIiqmUY6BEREREREdUyDPSIiIiIiIhqGQZ6REREREREtQwDPSIiIiIiolqGgR4REREREVEtw0CPiIiIiIiolmGgR0REREREVMsw0CMiIiIiIqplGOgRERERERHVMgz0iIiIiIiIahkGekRERERERLUMAz0iIiIiIqJahoEeERERERFRLcNAj4iIiIiIqJZhoEdERHQUkn0+OJ8eAs/Mj6u6KERElAYM9IiIiI5C3u+/gOer9+B8/F9VXRQiIkoDBnpERERHIfnQ/qouAhERpREDPSIioqORLFd1CYiIKI0Y6BERER2NGOgREdVqDPSIiIiIiIhqGQZ6RERERyX26BER1WYM9CgtvL/+AMejN0EuOVCpx3W99Rjcn7yi/dwHz8H13jNpPb7vj6VwPHID/Pt2pfU4tZXs8QTSvX/3eVr27574GlyvPwRZNWTN9+evge9tT3Fajptqnunj4Hz+Lsh+f1UXpcq4xr8I15gnIfv9cD73H80lAmRZhnP0fXB//m4VlJBqEvfUD+B88Z6oa4Me2euF89mh8MyZnNJyuMY8Cdf4F1O6z8rkeuNhuCf9T/u5sU/D9eHzlVwiMuLfuQWOR26Ab+MflXpcz6xP4Bx1B2Sfr1KPezSSZLNXNaoyZWVlKCgoQGlpKfLz86u6OKaUnywBAGyXD0L2k+Mq5Zj+nVtw5LJjAQB1VvghSVL4OflwGQ6fVxB4bsEBSAX10lKG0Pu2nt0HOW9/k5Zj1GbuL8bA9eztAIC8lam9NMmyjMOnBNq2cqashLXdSeHnwt/bKd2Q88HClB43HULlzf7fLNjO61vFpal8ssuJw2dlAwAyH3wDrhfuAhB9znh//wmOm7tqPkfBho+XhwHg5xP+Tb3zLWxnXRBze8/sCXA+eiOA1H12/v1/40ifJgCAOksdkDKzUrLfyuLbvBYVV3cEEP2Z+A/ux5FeDQEAdX4qh5RTp9LLR9GOXNMJ/r/WAPYM5C1zVdpxQ7+3rBc/g/2CayrtuLWJ2diAPXqUVnLxX5V3LMeRyB+qng7Z44782+tJe1n82zak/Ri1kbx/d/p27nQIx/lbcxP/9pr1vcmlB6u6CFXD5w3/0797m/52ZYfSX5aajO28UcyOQpEP7kv9wV2RaxT8NbCnw3E4/M+o0QZuZ+Tfwu+Xqpb/rzWBfwh1pMrEJV7Sj4EepVWldsuLlRb1jUR8TujpS5vKOEZtlMahiHJFeeTfR8q0N6pp31tNK2+qiI01Rg03R+vnk4CjeRiwgmzyc7Ckofoknq81cUibWH514CA+xwYGCuG5kHYM9Ci9qqpVUn2TVFQMK6E1kRevxJitZCXiiBDoHdijs1ENCwyO0kBG0SvvNhhuxN+hMUXjWA0MLFJETuRzSMdvTyxHJYw8ST3hMzH6XbJRgUJ4jU47BnqUXpV5QVe0hqqCOa9b/zmqPtJ40Vf06OkNET1KA6caRxyKLQ53M8AeKw1GoyCOJmJQZfY8kdJQfRKOLdfE70OcF6/u0RPOtRr53ig9GOilHQM9Sq/K7NEzqrR4PPrPpQMDhsSkM9ATevT8tSXQq2nlTRWxYu6s0N/OqPGHlI7mz0cMSqpy6KZ4v6yJ34dYZq8q0Kvp743Sg4Fe2jHQo/SqouFA6rmBiqFeGjcZ9+Q34HrrsXQXK8y7eA6cTw6G7DCopFZz/oP74Hh8ELy//wTfptVwPPYv+HduSW6nQiXL/88eOB4fBMfw/4Nr7NPmd1FxGM4n/g3vElXWU0WPXiQZi2vcC5HH9+2CZ+6UBApuolyhdOxJLh2h7JlKX6DnL94Mx6M3wbf5z+jn9hTD8di/4HjgmkpJBS97PHA+czs8338ZeED4PctGgZ7I64Vv7XI4Hr0xrmU0ZJ8vsHxDEmn0ZacDzqduhXfhzIT3kR6RSpbziVsgu5wG29ZM3h9nwfnUrZCdDrg/fQuuNx+J3kgYZmi651doRHA+PQSy0VBFkxQ9XZUxxSAG74IZgfdm8rwwHFIt3pNr6TBh35+/Be6DKVxeyb97OxyP/Qu+Db+nbJ+p5J78BlxvP57EHgLXIN+aZcHPLo0J2Y5StqouANVy6ZxzpWbUYihWDFVzH2RZhuvFuwEA9r43wNKqXdqKGOJ6/xn4Vy2B7fwrYOt+WdqPlw6uF+6C99vP4J35EZCdCziOwL9hJXI/S3w9HnGujPPpW+H7cVbgj+8+h73fYFiOaRxzH+4PRsEz/UN4pn+oSPEtVwgZ4YKZvuTyUrj/95Di9c4R18N+0XUJvwc9npkfwfPFu/B88S7syaRjr6S5O457LoN/6zp4F85A3qISxXPOhwfCt3JR4I/vv0DGNUMh5ealrSyeaR/A8+UYeL4cA/tKWfkbNh3oeVBxS1fA5YS8aytyxi0297LZn8Dz2dvwfPY27Bdfn0DpA8sYeKa+D8/U96vXMgbC7837/RfwnHgGMv71QBUWKPUc9wSur1LTNnC/+TAAwHbhdbAe1ym8jWKYoensg5FAz/PVe7C0PgEZNwxLrrBmkwxVEsewKwAAlpbHI+Om+2O/QLzPqj/Ho6BHr+KG0wEEpgbkvPtdSvbpGH4N/H/+Cu/XE5C3vPoFyKG6k+3iAbC2bm/qNVqrulXceGbguYP7kPPWnNQVkNijR2lWmS134s3DINCLailNpHcgWcGgQww+ahrFEhLBpS38m1YnuVOhR2/reuVzJudi+Xdt1XxcHLoZOj/Mzu9KBfkf7SUd4iae22kcuunfui7wj8Ol0UXYvEb5QJorpfK+nbrHE3+zhsvC+rxAsGfC9/tPpo8ddR4mIKr81YS698q/t3qWMxXkv7dF/q0+pz1C75PZa4Jq6GY8vcS6hHtTdZrHZvq8MOjRU4yyqUbvLR3C185U7GtTsOG0Gs4xVlxvhREzMYl1MNU1278t+estKTHQo7SSK3OOnnjxUB/XaOimsL5aWibYawgHGJUYaKRcWuaoCDczdRBjNqjR60UWh26GzoHKbDVPVVDmrZxAz5D6uOmeZ6Gu5Oj16KkbllKQ3EIuT8FafJV0XYmb+jOpxXM+FUMr1eeTmNzHbXL4atRvIAUVcaPGyqpk9vct9uIZzNGr1GWXqkIq743VeT1F8XuM5x7g0w/0avM1qKpU07sP1RqVeJFSBJWqXjvZYEhMWnp1Yl30gpWJyuxRSrm0XJBTsN6hzmev6NELnQM18fOvThXAoLQ36ERVzHV64X3mf/dmyalYdD0djSKpoP5ManMlSxHoqeZwi885TV4T1MF7CnpcUnG+poXJSrxY/qg5i9U1iE2LFP6OqnNQLP6O4jn/GehVqmp696Fao4qGbka13ostturnxBZcdStkuoQqEzU6+UGa15FS3wDM3kj0Ar0KraGbNe/zV1QGq0vGsnQP3VT1lsji7zQ4bBhAdAUyBZVLMdBLeIkGizWx16Vb1GdSiytZ4nVefV9ij54xs+9NvA6o5+gdRUM3UxqsVJdrvBbxe4zn2mh0D2Ogl3IM9Ci9asDQTVlowY2aQJ6oGBerUE8ee/RUxJuF+gZgtnKgd2NU9OgF91UTP3+fwXleVdKdIVBdMdebV6veTp3FUOhZMzt8TNGjl2jDQLXt0TtKh26qr/PuBOboqX97qWjUrGZZN+NmlHVTkYylmly30qUW/44UxDmlMB+QKhvb1a87Sj67SlRN7z5Ua/j98MyZBOfLw3Rbw/0H9sIx8mb4Vv8Sc3eyLMP1vxFwPHJDIGV2eWBSvX/3NjgfuymyoUHClajeB7EFV0yzfaQ8kBL9l3nR5XA54XzmNnhDWSHVz+/eBscD18D5zO2QPRq9HaFjxmg99sz6BM6X79VNMuHf/zccT9wC35+/Bo7r98P50n81U8HLsgzna8PhmfZh4L09PSTwOb42XLF/2e2C89mhUe/Nt3Y5HE/cEkl/nI7Kq1iO4r+UTwVvDt7Fc+B85jZFgK63D/+urYFza/Ofyh694DmQbI+ef8dfcDw+CL4t8U2+9x/cB+cT/4Zv9S/wbfwDjpE3w797u+FrvL8tCJzzJf8IDyZfGZRlGa7XH4Rn+rjweeFd+n30djrnBYCEWuj92zcF3reY1Ee3kPpDNxUVc6Ecvq3r4Xz0xsguvB4gKyfyt/g5hnb77Wdw3H914DtdtyKwnTBHT963M/C9/b4Evs1/Bsqvk/xHQQwwdX7LnvlTUXHnJXB/MSbm7vzbNsAx8mZ4VywK/P7XLNPdVva44Rx1Bzw/TAcAeJfND1871RmIPRNegTeYqEY8LxIle71wPn8XPN99obuN9+dvUXFXX7gnvJrwcUwRrrWOh6+Hf0fk+qLoITZ7TVCf87If7slvwPHgtYFlYe6/Gp4ZH2m+1PX243B//q7iMf/fO5Tnq8sB5/N3RpYUCR02dL34e0dgu7JDcD45GI5HboDjgWvgeHwQ/Ns3wvvrD3A+8W/Ih8vMvR+BZ8Z4OF8Vsq/KMtyfvoWKu/rCu3Am/Pt2Ba6ra5crX2iUdVOnRy98LfxjaVQ55PLSwFI5vy0wLK9/9/bA7yDZZGAC98cvK5beUZQrdC3UWy5F497o+2uN+etFgjyzJxjWFwDA++sPcIwYAMeD18H787dRz4euF94FM2IfMEaPnmf6OLhefyi6PGKAqK4fJREke39bEFi2qrzE9Gvcn7wC14fPwzPjIzhfud84oVcNxeUVKL38PjgfHggAsJ3WA7bzL4/axPX0EHgXzoB3xviYqcf9a5bBPe75yAPZuch64DU4hl2pzGpoOFfHIBmLcHNyvfuEbkp098cvw/PlWHi+HKtbZu/3gcqN7eIBsJ3aLVIWjyd809MNVkJFCwavtm6XwnZGz+jnn74VvkWz4Z0+DnkrZXjnT4Vn0uvwAFGp4P1rlsHz0UvwAMjYsQmer94LP2freglsp50f+Ag+fSu8DID43ioGnhYo875dyHn7m/S0WhoNEQp+h467LgEASI1bIvPfDxvuw/Hfy+H/aw18P86E9eTzIpv4UtOj53jw/+BfvxK+n+agzry9pl/nenYovPO/gmf6h0BGJuB2wb9lLXI/0W/scNzaAwDg3xvJ7peKzHy+FYvgDq6Fl7F9IzxfvRc4NyRJETR7Jv8vfF6goJ5qJ/GXwzPtA3hnjIdU9xhk/TfGWnyKpCo+3d+z7POG24MdQ3ooKx9ej+L7lg/tB+o3UhzG+eC1kc1nfoS8lbKiR8/59BD4li8MfG918oHDZfCvWx5zSRFJnM/ldgGZWVHbuF76L+Q9O+D7aQ4yrr7NcH8VQ3pC3r8b3hnjA2UN/v61eKa+D8/n78Dz+Tuwr5ThuK1X4Im8Qs3vzXFzV+StlBXnhf2Kmw3Lo8f73WfwfPomPJ++qbukiOvNR+Bf+xt8i7+G/do7IdntCR0rFkWjzuEyOP57OXK/Whv4W2zgM3tNUN9H/P5wqvnwJvO+hP3yfyke8238A+73AuuCZlxze/hx58MDIB+IXEM80z+E9+uJ8Hz6luKzqxh0TmApm7/WIHfir3C9/Rg80z5QHuOX7yGH1nKz2ZD1aOzGA5FzpOr79vvhev7OwHPFf8HStA18S+bCO+tjRcp/xe/So866qT21wvXcfwJLe6iWwwEA16v3ay6Vo+Z44Gr41/4G75xJyPsl+eH4suMIXMFA137FLbDUO0bxvOfzdzTvkWEa98aKQecAR8rh3/A7cqesTLqMWkINBbaz+8B27kWa2ziGROoR3m8/jXre88WY8PUiVn1MjjFHz/nELQAAa7dLYTu5a+QJRc916gK90D0SGZnIGvFWzO1lRwVcr9yneMx2Ri/Yul6ccBmqI/boUXoJrXj+g/u0N1m1xPTu5CPK1snQAt3+jauUG8YzdNOlHej5d2zSLYd/fRwXavWSDWIvnkGlQlEx0VmM169azFo+qB9siDdX31/Klk+xMuv/27hnyf9XKLV+moduqqkT7Ozepr2d2KMXLKtcckAZFMVYXsFsq17oPJB1zm3d14npt4PfbTiNdqzXblkr/JH8ECjxnFF896obrtHvQd0zZOq4oZ4yM0uaiOeF26U/J1C43sj/7FE+V3FY2atgtsxC+Xx/Cj1nwZ4SU0uKiC38euecmBVWaxSAuO1+84sKy/u1l/WQ9+wwDNDlsoOmj6G7j0PRvaZR24hLHaRzjrQq8FD8BsXepwSHbpod9i/2NojDh9ULYst6yzWElrJZ+1vg/xo9RLKwYLdRb69m+TSufbI4D9ZxJPI7MMheGjU8VmfopuJ6puJbHd3Lp8W/8ffAP1KwaD0A5b3mSHSPqD/m70/j3hicOuCvhIXPk0kgJTYkxuQ1CNhE6vKkOemQXzUaSJfGiCq/Xr2iBmOgR+llYhK3HM/6K6qkBpLe8EGjtfIMkrHIYmXAoOxy6QHjcuocG1AGF0YT/+UDQkU1O1d7I/X7NwhQJFukpTy0YHjkSWE/sYKc0OeS5qGbUdTfm05QqJswwxsd6OkO0zI7JDKVi4SbTcEvVqBSkdRAPD/F71QV6BkOc02gHOEsqGYqZ+Jv0es2CPQMAhf1MgkmKhiyLCvLZzYjo5rYI6nzOUr2jMgf8VwTY7HqJILJyDL8DKRULAmh0XMZxZ9A8J0Ig/NXDNJMD+eOuo8kEGQYDd03mQBFyjD+jKOu9bFovQ8x2JEkSHq9LokkYzG6z5ote6rXmBN7HzUCfylWcqUqmKMni/csWyUN1jPqmUvwdbrnVhpo/dbjqo/WEAz0KK1kMxXmeG6QVtUFTCfYiArmjJZX0Bm6aXTziCfQi+rtEI9nUHGU9wmthnoX0TjWM1NUZlQ9UIqAOVYFI3iMtFyQjW766u9Nd1udz0CrQqnXem8ycJFy801tF0Wr7CYDZ8NhyIlQBMDCZ6T+fo0qpQmUI3RDNdUTIla8DHv0jHqolIGe+rhR6eCBlGXFVXxneuecOD/1SCoDPe1Kn5SRaTz0V/j+E802KmVmR/ahd44o5nWlNtBTzj1WfZdiYJ3AgulR78ejfR8zHB0gnl/qhhWzn3lGpuHT8QZ6WueeYiSNeiF08f0ZLa/g1wv0DO5ZVRToKX4XWiMOdH5TYVWRjMVxOPLvWOVLFYNGGsV5ofqOFcN4q3KJF617WiqvvdUEAz1KLzPDsuKhrgzrtTqrh9UYLZgu3tjdJnv0NBI56IrK8ObU/reKYniIbjCsuiga3fDEeSjqoYaWeHr0gs+n4YJsWPGMSp2vM2xR7zPwKQMaWZb15+OYbJ2UhB69eCrDmu/TbA+pojEiBUM39X4bqt+WYU9HIj0xFcGKiYmGHsWxPW79oaIG2fzkUtVQRHXFROsGbzbVfiwecQ6Y9j7FinFKW5X1eh8ysowDdPH3nWg2YiHQ0+2lFL//VA/dFM8H9ecuBkiJ9Oip7zHi8EaR0egS8foTtZyMyd92rF7TeL87je9J/G3ILoeyEi8+p2iEMurRE4ZYG91vUt1TZ5b4HWldF/R6yYN0RxqlkaKclfW5eQ0CNqPMqoZDNyuzRy/6/i8fim8aRk3AQI/SK0YFMO4MR+oKst4F1WAdvai5Xoqhm+KwOINKY0mKhm4azdETksvIehWgeIIt8b2pA3Cj9euiChZ6Pg0XZKPzRSPLnSat8ktSdIXL59PvsTE7FDFGFkddWueW2aFyRo0WiVCsIynsW31u6fRYADECdL3XhComZir36sy4OpVXo3LEHLoptoiHXpPoUE01M3PAxM+hIrosCRMqpYolJTKNh26mJNATs43qvCfFNTDVQzcN1scTh8rKiSyvoJ7rrdcToD6/FXO0DYJKcbivQUAea+hmvLS+J0WPnrNCEdwpGiQTWTC9OmY5FHuctM7bmOtiVsHQTbGcKVo2KFb9THG9VV8jjK4ZXoPXVWaPnsb1Pfb8y5qHWTcpIf69O+F+ZyTs198Fa7uT4Jk+Dt4l30DKzlWuayXyeeH68Hn4//gZ9gH3wDv/K81Js545k+CZMwn2iwdGZY6MztBkgWf2hOhjBS8knu+/hPe7z+D99rPwU4ZDKYOVWe8v8+D7JTrFPAB4Vy5WlMP58r3IvPdl3VY85xM3w9KqHZCVA8+EV2E958KoY/u3b4J73PPIuPkh+P/5G56p78ErvC/nozfC8vFSWI/tCNnjgWv0vZAdhyFHJciIXJido+5A5v2vQgq2XMtGFXXxYms20EtHq6XB0C3n44OQ87EwOV+v1VKr/JnZygxhAOD16AbarndGwtKmA+xX3gLXi/dALi9B5j3Pw9KklapQQtC+fzdQr2HgbXzzKXxrliFz2Eva54VGa71ktcL787fwzp+KzPtegefrifDO/wpSTh1lxUI491yvDYd/xybYLrkhkAnS5YT94gGa2W3V3F+MgW/5QnjnRpbiUNy41eU26nlzu+B88Z5AhdDpALKykXH17bB2OlP3JeGhmxr79e8phnvMk7APuAfW4zopAi7ns7fDdl5fzX26nrkN2e98C0mjl8P97hPKB1LYo+eZ9QnslwYy3nlmjId/xyZk/OeZ8PBm2SCro+z1BjK/ieeSqlfFu+QbeGaMB6xW2PsP0SyD86lbITuOIPOeF2Apag7XB6Mg1SmAJAzjEoevShlZMQJ0Yeim26VbdXV/9jbk0oPIGPwI3P8bAcuxHQPziy1WSI2aRco3chCy35yjnIsIKIId2eWE8/k74d+5BVJ2LmC1BZK1WK3IuPZO2IRrp2/NMrg/extwHIHsOAJL09bIfOB1SOL8JKN13ex6PXoOuMY+DamwATL+b2j0+/14NAA5upFFI2lH+LjCHGvxXHY8eiNy3vwaUn7d6NcJ1zfn07ci69GxgYyk9oxweR0PXQ/vN1O0jyuQ/X5TvUzuCa/C9f4z0a/fvlFZLjEI/edvoHX7wB8Gc/TE66/sCVwvrKd2V1yvHQ8PhJSRhYwhj0Mqah55scYcdfek/0F2ViDzlocUjzsevQlSRiYy7hwVlS1T5F08B55ZHwP2DNivGgLbSecKTwrfrVZPtNh44vUqzzkg6trp/uztqF3Ih8vgfPm/gMcN+zVD4Z32ITIGDQ/UFUzw/DANvl/mBe7xNpuinLLLGVh2Y/S9gM8H+9W3wTvtQ/26mR6vRzHEWfb74XrlPli7nAP7BdcYz681ajQ0mKPn37IWjpE3Q8qug8z7XlFk4fXvKYb73Sdgu+JmeGd/AtvFAxUZzSMFNdd4oJUjQUxe5f5iDLw/zkTGVbfBt2oJ/Ns3IGPwo7CecIqp/VcXDPQoIc4RA+BbuQie7z5D3k/l4TS6RuQDe+Ae8yQAwPvrfM1Wa9njgfORGwBZhm/ZvOhATx0IWCyKtYfCghcg5wNXRz+nbol1K4eFAYDj9t6678P9wShlkSa+CmunM2G74BrtF/h8qLjxTCArG3A6AhVy1bEdD1wF/6bV8P78jSJjWljFYVTcdBbyfioPpJv+9E3tY4np8D9/B9IxTZB566OK96ZJEegZD/sIz41LR8ubQe+OvH83nA8PiDygOzwl+iIvZWVrDP306lbkQ5+vpfmx8HwZSE1uadUOmUOfVB5JvLkKqdGdD10HALCeeAbsF16LKDo9eo47AhVZqah5YBkRreBD9b7DyyEEeb/9NGZabABwPXt79IOKm65qzpBB0OP5egK8M5VrhsVcLiX03jTOS8dD18G/agk8cyYib6lD0ULtWzZPt/fUt3IR3BNfi6r8aYlq8NGam2SyZdz52E3hQC+Umt567sWRlOKKHj3l5+idMwmeyf9THldVFsd/IqnSvV9P1CyDZ+r7AADLcZ1hv+g6uN98BACQee/oyH7FOU9Wm3GPsKIyptOD6vfD9dx/AABSXiHc45XrjmU+Njayu2Xz4Z09AfYrI/cK2edTnHO+lYvg+VQ7Lbqr9KAi0HOPewHe+V9FXgvA1vtq2E7vEdm/ItAzN0dP3r4R7nceD2xy9W2KAMl/cB9cr94feO66uxS70xtuK3vcyl+ScE75Vy+F638jkPXou1GvEyvR3hnj4T2lW2CZi6yc8PlkJsgDABwuBbSCSbGcLidco+81tz/xdcJ1zzCwFq553m8/CyypMPl/kJq1iTw+ZxIAwL9zM7JeiKT+l1TLucgeD1wv3QMAsF90neI57+xPAtuUHUL2y/rrN4aW6QEQWCZCuFYp5pBpDt0Uqs4uB2DLU/Z+qea3hn4jinIumQtvcI3K0G/a+/M3qPPNTt0yi5z39gMAWI7vgoz+g5XldDngXTQ7svxK8DOJm9Oh+J14v/scnomvwTPxtcCSHwZz7RR/xzNHDwiX29L2RMVSM44Hrg4sExWsQxktb2WK1tBNIQt16B7pWDQ7skF2HWQ/83Hix6wCHLpJCfGtXBT4RxxDjBSVM73XVZRHLgpaGZHUFwWdsfJxzfUSh1KaGKIk74u+EPu3bTAekw5oJ14JHjuUol0zyAsJfmbyXnM3AkC1DITpQK/qevRipen3ictoxDN0MyNLM9CLNTRPrMRopaxWzF3RqBD4t61XHE/z3yHiMLe9O9M6KVzWO1eNsqgZZS1MICV1uGKscV761y1XHlNVSTdaXkCOsTxImLpiolVRT2LopmJ5B4NkH35x/c+QZL778kPK81K41irm5no9xkNdjSrtIcK+fX/+Gv286vOL+g2peze1hsSHKvmqe4Zf4zocdW1UDHNWnfNiT4XetVE1705xfVaXXW9hcnXyEtW57C/WWbZEfZ4EvztJGC5ulql5hwkuTaBcFkScIqG/vILiPNBosPNtXKX8jauv6eI9W2f5EJ/J5Wo0iUNQNa4LYvAf/mzFXkCxEVTvc9WY02l4/9cRqo8oyul26s8ZjUXsrVVfd9VLLxgtryB+hkbLXRnc89XXeb/ZpULMNkJr1TGD10694dJRUwBqAAZ6lDRTmTWhXVGO2kZYY0iTxtBN7e0MymQ0dNNMYgiNSqZcfiih+SXhm4R6AWojRgGWuuVMaMHXzCoYek6xrESMQC+dE71jfYY6E/p1twnJzI56XPZ6Y85lUHx+qhu+LMvKYT1aSQzEdcRUC3tHEc/ldM9T0KvYGt24jYYxxjlHT/b7Iw0XBkOKw9urA65UZJVTDy3T6tGLIxmL7HapMhAKwwGN5oppvJdkkrHIFYeVQxGFiomiR8/rMf69KbJh6vToiUGkRsCqrmyqhyhGBSAawx8txzQJbqsKrDSuw1Hza4yWjxCTsehcG9Xzs5TX09hlBxD9W1OfyzbtBeKjPrvQcOSsbI2tYzDRM53IWpgAlI0ShnP0ItdfqU4kW7FWBmspN1/5/RrNc9fLgJ1MoirxeqZ1XVAk+QmWRRHYStHPq/eRqjX/QsTGHacj8TUFDdb5jcqKa3boZlSiFpPLMqQ5qY3miI2K8sB1XO83UwOzcjLQo+SZrAxFZb3ToNm6LVJfFPQuBEYXeRNDN9VCFTjZ7dJsdZZLDyaWGCN4MZEK6pt/jdHFTxWEySVCxc5sj57YoqcZTAUrs6lI7a8Wq7Ih3kz1evQ03qfm0E2vJ2ZFXlExVl/gnQ7lZ6VVIRB7sVVZP6PEk/k0hphJjvTOc73H/X5lpVx9nsV77ouVWDOJPtTfUyrWiVKfa1rBVRxJDeQj5crvVW/xaBMV/WSWV5CPlCsDsDIx0Iv06Mket/FvWCyzbo+ekJRDY+FuOFW9CuqgVl2R1AiWpLxgcCgmzfL7tQPLOAI92MShmzrnoLpxR+ylVX8mOr85dUNG1DVHp9EiqkcmOKdQXLLCLFNDkBMM9BSNEobr6Olc/zTOdSk3D36hpy7quiRci3TrDMncnxTJWDR+i1pDgsXzQRy6qdebmmiCIx2KcrociWewFecKq69V6rqTUcBmdC6oGhR171epWMvTiNaIDb8fcDr0syOnMlFWJWGgR0kzm5nOTJe3ehhG1AUgqpdBpwLi8+pePKJ6IBVDN3X2FzxuuHKhqmjKZYcqL9AzvPipe/SEQMOo50RMFiHuQ+vmH6zkJ9wCbCTWOlrid6e3YLrWDU5n6GasoXmKFnxVVsaov7V69ITWZsXnpdUQkcJAL9b6b7rnuV5PktejPH+iguY4e/TEyp2p5RVU35NR1juzE/FNJGOJa/iT47Byrpf4vgySsWgGrcksr1BRrkzMIJ6DqqGbhusOGqXKD20j9iLs2hL9vHroo/q9q85Tre8gPD9LrIAe2q/ZWKIO9AyvUeJQQr0ePVV5xB5Ds/M3oyq5qtdJOj166szIkR69+IdumloPMsHAQ3EOGA33FT/vWL+rnDrme/T0hnEn06Mn3oe0Gl3Ensvgeamb0EzvPDExkiEeiu/B7Uy4x1A2Wv5JDIB9PsPlFWSjHj3x8/N69EfnxNGjl8han3oNvXJFuX5PbA1cUJ2BHsVN0ctjs5lfYNbM0M2oFllVC5J6uJVuxdRrGAQq9qFaMF1zKGpwX6FFzKWGzZTPlx1MLMV88AYsFaaoR089dFPoUTKafyjr9OhpBnqhY6S4RRKIL3jU3Vbre5ek6N5JX+yhm36hYhxVCVX/HRqKKK4RJQ4rijVHzx3H8NkYYt6MTAzFU3C7otayU4g36BeCZFMLpqsrqqkYPmxmjl6soeTi64+U6/biKd6jiR6dpHv0xEqfMJJCPXRT7zcky7LxMLzQ4+JnpvWdqLP8qXvw1L8/reGPweGeisq9qhdHatBY83HToxj0All1j554fzK73p76s1O/Tm8Ysvp1we2ispaakM4ePej06Kkb3BTXxRjZHyVbhmGgp+jd1Zmjl8zSM3KsHj2t37NiPUjxt6MTTCRx/9QcaSOW0+lI/P4snitGPXpupzKYNlheISoIVC/LoHfuCY3aMacIJfJ+jYZn6o32qYFDN5l1k+KmqCz4fKYybgJQpmjW20YV6DkfuhaoUwB7v8Gw1G0I19O3Kl+g86OTXQ44n9ZOQ+5++zHYr7gFloZN4Hr/WUVGKs9nb8Peb3D0izxueBfNhvOZQAYo6ZgmigQUcunBxG6UjiNwPnOb6TXYfH/+Cvdbj+o+b3gxjFHpcb3/LKS6xyiCDNdL/4Xt4gHKLJ+h5/UqiQapvL2//xTIDujzwd73BljadIik0W97YnzDTVwOuKd+AHnfTmQMeRzutx+Df+t6+Df8HrWp5iRuU0M3I4Gef9USOJ/4N5CRicxhL0WnwF/6LeSyg8gYMjLy+pIDkA+XwfXKfeGsiIGya0wCF3tbYmQ+jcUxpCcsJ54BKSMLtksGwjvrY2QMeRyWhk0DG+gFejqJTBz3XKYMeoyGZQmco+6AfKQMmXeOgqVxi8Cma5eHf0fqffk2/wnPpNcVlSbfn79F99Ts2aF5PACBLKkmfouu5/4D3x9Lwz1qoQx4im3efizmfkKcj92E7JciWf7CafobNFa03rte+i+kug1hO69v9HkReg+fvonM/zwDKa8g7rVG5Ypy5blZFgn0PEKa91A2WU2q+XvOJ/+N3MkrAksehI5TcgDOhwcalsXz5VjF31HDoVQVLe8P06L2ER666TgC1+sPIuPu58MNbiGWVu3g++dvZY+b3w/X6GG6ZQtVtGXHEd1Mn+5PRsMz4VXYrxoC36oliiyfZudAyaUH4Hx6CGSXE5n/fTE66DI739Tnhfuzt+Fbudjc9iLV5+5bswzucS8APi+kuscEFkE3m8RIRa44DM+sTwKJp4Tfsnf2BLhad4ClRVv4Vv8CS/O24ef8f/xsuE/fykWRhG8A4Hah4p7LIGXlAjabYviq7rpnPh88P0yD99vPIGVmB1Lyz50MW49+8C6ZG7W5f/tGuD9+OfD9CCMGvN99DtcbDyPjzmeBskNwvfEw/Fv+jLx/lwPeX3+A64VIFlb/1nWouOcyWBq3hP1ind9IAj1ujpE3Q7JnIOOWEZEHJQnuKW/C/f6zijJJCQQ+7s/eUTR8h85V96TX4dvwezgbJhBYzsV+sZAFO3i98P76A7zffQ7bhZFsqK5nboPt1O6wtGoH9+fvwjVqqPJ1Otdr95sPw3ZWb1g7nq7IhqkpajkPP1yvDQ/cKzKyAon7jpTDclwnZN42Ev4De+F6Wfv64HrrEfhCCcFUamKPHgM9ipsi0Asug5Aq6ou2d/7UwP9njId9wD3RZdH50Xmmvgf/uhW6x3E+eQuyRrytGTSJaZfDx/G44bj70vDflnoNIVbF5UP7Ep4ToK4MGam44Qzd52S/X/OCKft8kKxWwxuLf+u6cKpum3Dx9kz/ULEcRHCPgf/pVaY97sBizBrc7z0N35JvAi+f/Qksnc6Cf/VSeBdMR535++IKlmVnBVxPBYJyy/FdFDc6U6/3eWP2nCjOdSD8WVhP7Q6pfiPFc/51K+Bft0IRsMkl/8C7aLZmZd7wuEnOA/Bv/hP+zYHKiOfzdwKP7dqKnHe+Dew/zkqGb8WPhs/rDQUNHdvS4nhk3hZIWV8x8DTVRpHXeqa8qVgqAgDcH78cV1kBaJyz2mKlHY8rw+2G3+H+6MXI33/8HA5cLMd2VGzreu0BALLheeGd/1UgnX6815Uj5crEDCbmRkdxu5S9Ets3wrtghmK5G9cbIzTnyRmK6tGL3SsmJnBxj38R1pO6wn9AWemztDwevt8WQN6/G7IsQ5IkeBfOhG/ZfP0dh9ZM/XGW7ia+4HPeRbOi56WanJvuXTgjfE5bj+8c3Ytgcr6pfLgUrpf+a2rbKKpjuj96SRm0JkE+Ug7nYzcBAKRQQ1LoOG8+HP639dTuSR3Hp/M96QUAst8XXoIAiFwTPBpr2gFAxe0X6DYguT98Dra+N8LzyWh4pn2gfNLlhHv8C+HrrVheHwCpbkPNfSbSAxUKtHwbhYyiXg9cL/9XVeDEhm66nrsDli7nKPdzpFzzvPPOnRw9FByBRkYA8KsyMVfc2gO5c4uVQR6CvX0G9/2KG85A3kpZeSwN6qGz/nXL4flkdPSG876Eve+NcBk0mIvrLkcX6LDpdSmri5pTUqo+4khQEC/DtOl7iqMf0+vRi1FB869drjucRTHhPkRdkc1QBjKBRAxpSE4SD70LZmg+hNEadYdLNf+tvXEwMY1RoKf3UtV36F8dWAA9HFDFE+gJ+/Kb6C2O4vXGrKjq3VzkvTt1hwx5f/0h8ofjiOE5rXvc0BC2FGbf9ItLU6R62G2sgNlgCKQiI2VZdFBSHdJZ23r2Q9aLnyHzceOAXazc+HdG5qyFrjXWsy4I/O04ojuUXaoXqBj6Q9cw4TqVPWYesp75BPYb79Mtg1xRrpg/qvWZxuRxRw+3Ui1nkNBvTh0cmbiXqDN1+ov/ivpNWVocF9y/K9zzrPu7Cy3JE+rRC33OWTn6GS21hqUaBHo5n/wS/rf4Pfv37owObk0G8n6N+59ZURlLjc6JOgXIfn1m1MPWbpfC0unMyAPBa5P4OYcaqGzdL496vX/zmniKbJ7etSfeTMAGowQAAOUl8G1dF/06l8OwYU7dWAgEGl/NZBvWE7pvAoBcXhqe42Y97fzAY87Ek7HIQlKlwH7078n+jb9HtlUvfL5zs3K///ytuaQEvB5zy1rpLV8SoppD7jeoA/r37oR/+4aYx9SV6NIVVYSBHsXNbPKVhPZtUPHWHKKh140ups7WIklx/VijKmXq/Xvcia9bYySeifdul+bFPdTradjCJwwP01zLShSq9OgN3TTqOYwR9MQ1R0+sYOyMTgQRk9cTOwjTuYH79+/Wf60qUPbv0Fkny0jwphaq9KeEOERMXckQhuQlIuZwFqPnxUQlGp93MvPVUiavEPYLrkFGv38bbiaucaYIboPnhL1/cOi5x6X7vuxXBxbpDZ1fYiXdenoP2PvegIyrNRa7Dx1XNUcvkZEGstsV1RgQ9dvNzYt/v+p19cwEenmFytccKY+eo1d4THiJmnA5dRpJbN0uC+wneN6FtrdfMxRSbr7ma0Isx3UK91rp9UZaTzoX1hPPgPXkroHtxAyo+3dHB7dm57jHGlpZx6Ds6qQ3BoGJVFAPtm6XRj1uO/9KSNl1ItuFGiR2CAF/cMi5rWd/SI2U89hj3lcA3XVxjehee1Jw3bB0OguW4zqHj6O1FApcDsPvUDOodiUxh85g//YrgtNo3M7E10UUf1tup/6aq1DVi1TZM6WM6FE9uhlMzdz345h3Lrtdxp0G+3dHXVfiUS3uSXFgoEfxS2OPnlEgoJlOW+8HZ2LCejw/Vr/qJqs1IT7mGoAJkIxu3urje9zR69xAeJ9GNxYhSI05XzDGHD3dxAZOR+zkFrGybupIpHVOPrgv8Zvh/t3hc1UK9SaksmzBHj2p7jHxF06PUEmJakFNtjc6VvbS0CK0WvPNxPNF6zeZ6jkRCQy5MZ3SXqjcKNavCwXuOcHgyOPWfV9SaN240LUwVEnPzIIUCl6Mrm+Ow8l/Zt7oBAnqipNY6TctRtZNTarGLrmiPLoSl5sXWW8vVuNNTrDcoR694PaWY5pEjdSIfm1e5Hek16MXyqIZ+o7Ea+v+3VEBotkhoOp7kJrR9xGd9Mbg/NDJAiplZSuG5IevTeK+Qv+22yPnehzC8zHjkM5Kt2SzQQo2aMhHyrWH2bqcht+hVs+97Eo8ENPdf2ZW5LficiSV7CW8b5dxj15U4jZxmLhWHUkvg6mJQC/mNAvx8/S4jQO9f/6GlB+9dnGse3lYDZunx0CP4hbPIsJxMxripfXD1elFk2wmAr04fqyyarx5aE0jxTYmsorGK65WJ49L+4IZep9GC6aLQ730FqANb2Dco6e7+LDRMMnQ+0ww81tcw8iCFX3/3iSGQgk9epZW7YzLti2JQC+Bio8uu1CBU39HqV68VyX8W9OaL+b1hlNjay5RkeqKnFGvjV4PeqwAIESsUGstJB3qBfP5dBuGLMEMkn51j55YBqNAz+fTHC4WF3f0tSRqqLLOPFwjUfcOvUbDgkglLKpnoPRgVIOglJsXybwZStSik14/EmwHMykHr0vSMU0CwYwBKTcvUtnXC1JDgVLwHiReW/3//B39ns0uTxSrR8+o7G51j57+b0o3q2dGlqLBw3C0gc2eUI9vQq9JZ6XbagsE96HjaK156XIYfoea9YIUBWKK/Wdmh5fgSGrBdFGMoZsKXo/yd+nQ6DXWur4bZP9VbKfzPYeXVVBkPHYZrsns1+nRi3Uvj5SlZq2lx0CP4pfGoZuG4gkC9NYmCpHluIZ2RC0GrHUzTMdcojoF5rfVSVMcuihpri+n2gYAECtgDc3Ri3PRbaPe2vA8nETnFcQzDy5YcYw5J8OA/5+/I4Fei+ONyxZvwgogcm7GqHjGQzHsKA1LYxgKvh/dcyDUu6JVEUhxT7nR8LxQZtCo15j8HrQW/FbsR+h10RvKFtWjF6ykKyrZMYamxxoiHYusMUfP/49qn1qNbHoNU6EKvHropk6joWJenuqzF397YVZb+HMLVfD0KmOSGGz7fJGe+WOaADF6bqWcvPC6d7oNnsHnQ99RrKGb4f3EyLQbKxmF7np80Bgym0iPXma24vORCg1GG9gS7NFLYDH4lCy1osdmV/boaQ7dNO7R06wXuJymrsGm1oYL7l/KyIp8P25n4gumi8d3mysnELxmiNMpNBr1NM87o+UVRHrBVei1njh69PbvhtYSRqFRAbHUtMybNSbrZklJCUaNGoU5c+bgn3/+CQ8BqlevHrp3744nnngCjRo1Mnz9o48+itmzZ8PhiFz0bDYbjj/+eDzzzDM455xzFK8pLy/HU089halTp+Lw4chJlpGRgS5duuCFF15Ahw4dwo9v2rQJnTt3RkGBfuVckiTMmjULp556atyfQVXz/bEU7k9Gw5vCLJvp4t/0h+Hzcsk/4UxhZqh79LQqWs6RNysfsGckXaGW4gj0nI/eCN/vP0U9LpcehPOFu+GdPUH3tXI888j8/kB6fJ2kLb6fv4H7oxchQYLtipthC81VMQr0gsOp0rIIu1pmFuCsgD+JQE/evxv+4DXI0tI40Eto/8HhswlVfHT4t22A85nbIbud8C3+OmX7NUOuKA+kIFdlXAvxLV8I748zIe/bFf1krORAcZJy86AxgDTwXP0iYOv66CdMfg+xEhlJQo+F99tPtbcJBXoH9sAx7MpIoCsGPDGGpvtX/2L4fCzORwbCv2m14jF5/254vp4I77wvYet7o/bi5hmZmp+tlJMH+Ug5vL/9AMcD1wQqZ7n5kcXQ1dvn1Q3vR92jJ+8t1sy0GKqkud96BP4/f9Vv0RcCEOd9/cPXPlNDN3OFoZs6wZKkGrqpuLa6nPAfUCX7CgV+yTa+iAFaRqayR8flgH9PMdwfjIL9+ruNe8H0AsasSI8RYDysXLJlKM5106pbJkOrLRyweud9Cd/yhVGbuF6933AXWiM6vD/N0f39O58eAsiy6XV5wz16Wdnh+4WYdTkZ7tcf1M12qub97jP4hWQ1mom1NH4z8t/b4V+/0nDfjidu0Vz+BgCcDw+EVNgAViFbqOxxAwb1De+cSbB0Pjv6CbONEzVsjl6NCPR8Ph969eqFyy+/HAsWLEC9evXCcxVKS0sxfvx4nHvuufjjjz+Qk6M99GbYsGEoLCzEmjVrkJsbSTzg9/uxZMkSDBw4ED/99BOaNIlE9Pfffz+sVitWrFiB/Px8xWvmzJmDK664Ar///nt4f0eOHMGZZ56JBQsWpOFTqHpyeQm8338Re0OB9by+8C2aHXvDrOyq6yk0QZ0q2MwcQKlOQdJDqOIJ9LSCPCCQ3ts76+PIAyn4rI2WhBBTMXumf4i8lcEeQKNeBo870HiTZLksrdrFHCopZWRBBrSDCrMcRyD/vS1wTLPj+hNhdsigSXprp1nPuTC87EU6yBXl4bTbWhz/uSjmPmznXwHvgunJF8aoRy+Ypj/qcSFtvKXDafCv/U3z9TEDPRO/Z6lew8Ai4WWHFO9XEfBoDB0HEBgBkILAWB3kAQCcDjgfuQEA4P1tAayqJSOQmaXfG5SbB3k/gNKDpu4hhj162zaEswyGWFocF6nY+v2GSwdYmrQK/9u7cEbkmMc01uy5lY5pEr52SeIcPT2hz0Cn11U9BFN2BRNeGCS9MEX87O0ZykDP7YTz8X/B9+sP8MwYF+4Fs/XsF17CKESvZ1DKyALEZCzHNAkEvloB/zGNzVeaFS+MkWU4BY2ncbHawr3RWkFeolwvRS8VFaJeXiaWUEAlZWSFG4lSSbGeoRGXE/4/f438rZUESms4JwD3xy8Z7lovyAMCATigure5XZCdFYb7jFrLsaCe6fpWTevRq2bNJ9qmTp2KVq1aYeTIkahfv35kQjqAgoIC3HPPPbjkkkswZoz+ArBz587FqFGjFEEeAFgsFnTt2hXXXXcdpk9XViKmTp2KV199VRHkhV7Tt29fnHnmmfjxR+P1pWqTRC4i2c9NRvbrM5H1osG6JACkwgbx7TiBIW1S45bajzdtjTo//IPsd75D9rjFyHxsLLKe+gjZ7y8M36z9wUp9mF5FSxRHIhU9sbLAmaFu2UtkSE0qGA1hlJ2OwFC2OHr0Mh8dA6koMtTO1v1yZH/wI7JGfmDwKoTnFsWzvljmQ29GPxi8kVlU2eVSKisbuXPi63m0ntETdRaVwnbZv0y/JmPwo7C0PkHzuezg2ntJScGchqxnPoFU1Dz8t6XTWYFrywuf6v62teglOMr56GdIx0QCOvsN9yLrlWnIevEzxdqSOW8bBMTlBkGWzR6YexZjWLlksyHn/YWB87v5sZEnxF5FqzVcKbZdcTOynvgQOZOWK+ZNWdp0CASMBmyXDzJ8XlfZoXCCGfvA/yL7zTnInfGX/ntTJQpRryuoJgZ6Ub3aoWuEPQO5U9cj56OfYWnULOb9KfPRMch6+UvY+lwb/WSd/MBi8EIwLRXWR9bLX8J+7Z2Rx3Lzot6jre8NymU3QkM39eaJB68b4XMqwQyMmfeORsag4VHHDRxcWbWTnY7IAtBCAJj19MfRGXf1vsPMbEgNiiKHyCtAzgc/IvPRMYqeOMuJZ8Da/uTwKI34SMidpZ9BOXfGX3HvMft/Jhqa9Upjsxu+D0vbExV/Zz6mH6RJzdtCEhoZUiYUUGVmw9KkJbLfW2DqZdnvLdCck5b56BhkjzVYfzKGULZZLbrLYcUYlhw3jzs8jD5nnLIBXGrWRvG3rc+1gevXF3+G5/nqsZ51ATIfew/WE8803K66qRGB3urVq9GjRw/DbXr37o3VqzVaIYOGDx+O7Gz94KB58+YoLo4kZ3C5XLDZbMjM1K/QN2vWTPGa2i7WjdRyQvRwVCk3D7Zul8J2/hXG+y6oH1dZbBf8n+rYp8R+zTkXaj5uv/A6SIX1YTurN2wnnYuM/rfCftlNsJ3aDdaOwQXKVWu46E5YF7dRBVRiJdW0BBIeqEVlfRSG1FjP65v0/s1mqjKcN+R2xj2XLeOqIbALwYztsn/BUq8h7FfeYvg6KRikx5M8x9KqvSJBhGJ/MW4OcVElA5EysmApah5XQ4itZ39IdfJhv+j62BuHjpOVA1uv/tr7C679loykE6pkZQeuJedfGX7I1v1y2LpdCnuf/zO96DSg33hi7XyWYj+27pfD3uMK2C+4RvF7lwrqRa0TFhrGZtSjJx3TJNBIGWvpFwDW4zoh46ohsLbtFHm9OGxO2I+lSWvYr7gZ1hNOUQyXs110PeyX3BDZqUYF3npsx4RS2gOAf3dg3rL9gv+D7dyLAr2eer1BquDaeo5xD64iI55er3ZmNiyt2gW+N0SS2OjJuGoI7L36Q7JHlzE07FMMKm19roW9V39lQ45Gj56t+xWw1BemjYTOlRgBfcZ1dwX+4XJGL3cilq3LOZqPW0/voWicUQSW6p4xtzO6gS+nDqScOrD1vlr5uO4cvSzFHCYpIwvWdich46ohsPW9MfLyXlcFnk9w6KalaWvdpEiWouZRwZUR2xU3w3beJbHn7OvuwGbYM2kPfYehv/sI9RLVvdvW/XJYO5yWWDlMCPVG207rDlvPftobCb9D22ndYVVdxyztTw58n6f3gC2O+0ekEBLsN+oPZdVL9JbQWp8GZGdFeHSQ1PJ4xTDNjGuU0wdsPfsFrl8NimLO0bNd8H/I6D8YFrEBrgaoEYHezp070bix8UW8SZMm2LFDv+V72LBhhq9fs2YN2rZtG/47MzMThYWFqKjQ7/4tLi5GmzZtdJ+vbaTC+sYXTIMx5bECo3h79NStbFJWEuuAGbU86pXbTKCnqlBGpb82sxi2mZ7DWFS9KeINX0py/TQg9jyycGp9o8nRLkdCC4uLlQmzE6nDPXrxJM/RC7glyfj8iVPU9xFK0BDPwunBcyaunlt7RjhLYFrEGEYTS/i3I1SyFRX2OIa9GX0u4rA1o+QWUb//0Pdm0CMdbigzce0Iv0YMXtS/s+B+xN+A4redm6esbGv91jOzE09mEQrehfNf7zqv/sytqkZBsWcegDIjns7oDfUwy2SGrYU/Z/F3Hvp8xeAmp070WmqqYCCcrMVoeFdOnXDvqxwjA6Nuj5LFqjyXxN+Daq6b7HJEBV6h7yTqO9M7PzOzdc9HRaKg0GeRjqGbQFzD2cPBf6LXaKvNMGCNStEv/MbUWR0lmz0tQyvDxM9F77NX9fRKFlUjj3j9S6CsUr2GhpnCdRtzE1jr05Bwv5Fy85TX9WaqIE3sxT/GOM4wm5SruqkRgZ7P54M1RqujzWaDN8GTZcaMGZg7dy769VO2gvTv3x933HEH9uzZo1j/yev14ptvvsHcuXNxyinKnqT9+/dj2LBh6Ny5M5o0aYKioiIUFRWhQ4cOGDx4MHbu3BmzPC6XC2VlZYr/qgNJkhQXekmYtwIgqbW49Cbl626vrrRkx7GweKx9ifRa3020ykelis7KUd6ATfTWmek5jJei0pWCQC/Wou7hhZ+NArkEA72oOSNmhColcfQy6QazOXUCvSsJ9opo7U8UTsQRR5KC8DkTR4u6ZLObO6erSui9iD13YmCqk0pfk9GQarESb9RLqPqszDSYhHuN4mi8UZzTqutFeD/i71kd9IkBiFZlNyNLM/tcPBQVYb3gWDx2ZlZgWKm4D3UFS5FhVOc6qXpcHFYYt+D3pwhYQg0mikAvL+q8kNTBQCjQM1imRmrQOFJ+l3EqfN318axWZUOgWJlVB0wuZ9Tw2fC5ojofdRs4MrP0z0extzm434R69CSD61zwGhhPgqpQA3LC0xViZA9VJ2WThPuAemkc+UiZ9j0qVQ2F4rkrfvZiGdXnheq+JX73phtOxdcf08Twe0/oHp8Mmz3qO7I0VXbOiMGb1vejSDqU4jnzlaVGBHrpcujQIQwaNAjDhg3DtGnTULeu8od55513YsGCBWjcuDHq1auHoqIiNGrUCNnZ2bjoooswduxY1KsXCVAaNmwIq9WKZs2a4euvv8aOHTuwZ88e7NmzBz///DNOPvlkXHzxxfDEWBT6ueeeQ0FBQfi/5s0TGPKXJuIPwaJqGUkmY2LcF+Kom5+JlkCdlmt16mnFXvVaqBMYugmbXdkqb+aGFWvifyKEi71k5nOLtbsYrVyh7HeGQze9Xvj3JDAMWhjyZLaiFys1vSad7yr8Hafoe1IHDOHhpUYt3eoJ5BmhHr04KhA2u3J4YjKV5jQI9z6IlVBb6nv0FN+j0Xeq16NndNwEevQUQ+X0evTEHjVV0Kfo7dMoYypaqBXH1Bv2JwacxzSJaiSU6qrWZBOXGtD77akeT+h3HXl19LGCn6+iwqsxR0/MzAggEujpLJ8R2mf4s/f7IeusBwtANxCQrDblfchojp7LER2UhParPh8NlldQfBZCA4Hiuwj9VlPdoxfqfYpjOkNormdCQScCn7Fhg5lRr7+qZ0suO6QZPEn1U3OtVQztFn9v4v7Vn686sBZHTCQwJUE6ponh957ssi9x0/jtWJq2Vj4g9uhpZJJVPBZPg2I1UiMDvQ0bNqBNmzbYuDGORZIFsixjypQp6NKlC+rWrYsVK1agc+fOim1cLhf69OmDESNGoKSkBIcOHcKePXuwd+9elJeX45tvvsGYMWNQUlISfk2TJk3wxx9/4L777kOzZs1gE1r+CgoK8J///AetWrWKmcBlxIgRKC0tDf9XneYBKioe6jlnZnv0tCoXcV6IoyqxJtaMkfVaTY2G2Oi1vptolVfPS5FsNuXF2FTLZHKt7Zp7FN5vrCyBpsT4LBx39YVj5M1R8xzV3O+OjPvQ4twv072fCbTKSTqVi3AFQisoMFuJFnsIVA0YkYQx+hUgqa5q2HPoc4inoqXq0UtV5SNVND9nsZIVzw3YKCDQCyTV5VENc5Vi9GoDQsUpjoBEUdlSn7cZ0UN01cM4lb33Oj16yRKPqfeZiUOsGzQOTAMQRI3oEBsN9XpWUzB/OUKO3mfoe6qTH/4ta2bdtFqVFcrg84Y9eqo1+5z3X2VQNJ2htRar8jerCPSU1wvfotnwFysTmYQbT9Tno953mJGl6A1XzHHW6k1KqEdPUv5fFOx9imvJmVCvWqI9euogXs3oGhEV6B3UDJ4U8zuTIX4u4m/SqNFOPRJFvIcm8PuyNGhs+L0nu+xLvMLfndi4XSdfcR4revS0Rs4In2s88/qrkxoZ6LVr1w5btmzB8cfHv35VcXExevfujbFjx2LOnDl49dVXNde9+/bbb9GuXTvcdtttUc9nZWWhT58+uPzyy/HWW2/FdfwTTjgBmzdvNtwmMzMT+fn5iv+qC0WPXktlxib7pTHWpQveDG29r4ner97wFD3q1mmDoS8htnO1EwBYT+mm+xrdMdv2DFi7XWp4PItq4rWtz7XKypaJG5b1bO0EMnETbkjhBDPQTqAT/75j9GY5K+CdMT754whCn71ehi/r6YHkTfZr/xP1nLpiI2ZU1JWdi4z+Q6IfD91ING74pjOmCpVt6ynnKcsWmtxv0NKtTmQUHnJWp8D8kE+bXTEUUp1sRC8jZ9K0skJqpbgPzeESW5wT7dGr1zDqsfD7M9mjZ+t6ieJv62nGycIAYeimel6MuF9VAgQxK546u2to/pHURMg4qh7GqQj8oq+xUmY27FdpnNcGLK3bR15fv5GygUXnMxMTpVhatQ9MAwgmcZKatIoaPmoVPl9JkmA99+LonWpcP6XQmpaq88ra7TLNcoXYg/ck8T4Uel+SJIXPD0tR8+g5euqhm8EGT0UiHHU5j2kCZGSGA17/lrW621r0MspalXP0rGcaJ02SDyjXHgxnqjXbo2e3K4aEWtudFHlOa+imONLAbKOXUY9e6HMXv/cY6fBDZbQ0bmG4nS6b3TjlvkGgZ1Ul0bGdf6Xmmqu2HjqJUwyo6xYAtOdJArCHku3Y7NFDeg3m6FmPU3Z+hB83+C1ZWrVXLo0SQ6wkfVrimTuo15Or6FlVX0dU9QP7RdeF/21tf7LpY1cnNWIdPTPz77xer6IHTcuyZctw7bXXYsSIEbj11lujT3rB+vXro3r51Dp16oRXX33VcBu1nJwcwwQv1Z0Y+Ej1GiJn4m+BNLZHymE99yLYr7gFRy7WvqjmTtsI/4bfgcws5bpuQOCmZbObT68vSciZvAIV1wfmSOpOZs8rRPaLn8HSuCWk5m2RXacQzidvCd/0Mu8dDevZfXQPk3nbSFiP7wLZ7YJ/y1p4Jv8vcPiMTGSPmgTfrz/Aemp3eH9bACmnDvy7twUu5pKkGCqaOeJt2K8aAs/sT8LrKEmZWVH9ddnjFgcmeHs9gMcNa8fTkP3eD3DcGl2RlBo2jbkWXNbLX0I+uA/W4zpDOqYx/Du3BBY+Dq45Yz3xDNivvzv8vjT38eQ4uD8ZDf9fa6Key/liDdxvP2ZYhlSzHN8F2aMmAQBsp/dA9tvfBLJiCrJHT4Vv+UJYz+wNz6eqxhjVzdn+f3fAdtYF0QveC6TCBsgY+iSsnc8GrFY47g4EmuFKjdUW3fdapwBQVa40952RhZwpv8O/txjyof0I/QKsp52PjIHBJFJCwJY9Zh48M8bBO3tCuGzKNxSsoNrtyJm0HN75U+Ee+5RxGVRDN62ndkf2u9/DEkxFnf3Bj/D/8TMc/71cbxfIfnU6PDPHR63LpSXjzmdhPaUbpJw8VFx3kuI560ldkfHvhwGLFf5t6wHJEgk8FWuFRf4t6/V6AMh+4+tA5Ts3P/AbFRewBiA1bY3sDwKjLCThHhJVoRfL2P0yZL85J9B45XFHBdS2y/4F21kXwPXa8MgabA2DlQuhrPZr/xM+Py2dz0bW48r07JZmbZA9Zh7kvTth63Gl4rmsZyfCv2OTYj27qMQs4rB0reGlWdnIfOB1SA0awz3mSQCBaxWcR+B69YHAe7lkILIefAPe5QsBtwu2cy6Cd9EsyEfKoxom9IbHS3WPQc74JfBvXReu3OW8OQfeZfNgO60HXGOfjBRz3GLYTjo3kBY9WGnMfn4KfL8tgOORgeHkUlq97Dkf/Aj/mmWwntwV3gUzINVvFLiOnq68fubO3gr/jr9gOa4T/H/+Gg4sFb0fwu8h+6Uv4N+5JRB4awzdVHy2bicAIGPwI/DMnQS5ONiwm5UTThJhadAYkiQhe+wPqLj53Mh84Tr5gWubLAfWe7Ra4d+yDposVkXPsq3rxbC88y0sLduh4qZI+nep+bGRMgCwX3snLO1OilSyTYyEyPk8ktE8d9YW+HdugbWD0EioNXRTGBUg5dXVnCKR+fA7gMUC1zO3BTc0mqMXPXTT2u4k3fXtcsb9BEuwESTzwTdgPasPXE8NDj+f9co0SLl5cL//DHy//qB9TJvNsEdMaxRJ7rQN8B/cpxi6a7/+btj73wrJZkP2ez/A/cEo+JZ+F3gPZ/dB9vHfAZlZcNxyXtT+tGQ99RH8OzbBt/RbeD57O/CgRrANANbzLkX2cZ1hadUeFQNUDbuq65Z4zbM0PxYZ/3kG7rceVR774bfhu/Lf8Ez5H3zLAsswSE1bI/OOpwMZnzMykfnA6/prBebmoc6cHfAt/xGWE8/QXBtValAE+Z89isey318I+H2wtGoP76JZcD2tbKDKGPQgLK3awfmEkHVbpzdWatAY2Lo+8G/VqIbcGX/Bv2k1rCeeAd+qJbCeezFsva+Gv3gzrCeeobW7aq9GBHrNmjXDnj17DLfZvXs3WrTQb7UpKSlB//79MWXKFHTtqr/OR0isoBEItPSJAejMmTORk5ODXr166b7G4XDEzCBanUWlV+6gvHBIRc0hNWoGeW900hnLMY1hOaYxfGuXR+9YkgIXKo1Az9KmQ6DFs6AeEBrK5vUqW1d0evTsPfsr0sPbzrsElvanwPfTnMDfva82DPilvELYg2tNuT97R9hxRjDde6ACau8R3TLl+31J5Li9r4JktSrHe2u0SNtOOjf6sdPOj5Sn5fGQtweGLNsu+D94JgYaGqwnn6e5sKldlTLf0rQ1PN8KaxpabbCde7FhoGe/fBA8Oj1ygfTslXsZsV1wjTKNvEagLuUVwHb+5YokSmGq8kq5+TFb/CWLBbBkwHb+5fALlaZwy6nG9UKqU2Bu4G1mFizNj4Wl+bHw/DAt/LDtgv+LZJYUzlHbGT0hH9wXCfTUw97EgK3dSZAaNosZ6MGeoWzJtNpgOzXS022p2wCW7safkbX7ZZAryqMDPfF3G9q24+mwndwVssZ8ZSknL3LOqwIJyaYzdNOgR8/WVdkb5N+2Xvn8eZfCEhr+ajIZiyRJihECvj+WKp/PK4T9koHw/bEUnk8DazCGWqJlIRiyntItHOjZe/XXnEdnO0N7oXlLk5bhimz4uGKPVE4dZfY5rR69jCxImVmw9ewfDvRsva8C3K5IoNezP6T8urALgab9koGaZZL1htBabbB2ORvWLpE055bmxyIjlKZc+P5C10DrSZEeEalOPmznXw4prxByKIuwxvXTUr9R+Dy1X66/jqSlSavwwukWYWSGoqVfGJJuado6MrdHff2wWBX3kNAUASkjE/ZeV8M9/oXA3wX1wos4h84F63GdkHHTA3C/83jgOM2Pg0215I1HuN4oWJVDN2GzC/e6SHnsFw2A+72nw39n3HivYp5SVHIgjWumVVjSQPFZhHcqzg+ro3iPAHTnsFqat4XtrN5CoGdwLw7+HsWeK8sJp+oGeuL5Y6nXEBn9/q0I9EL3bN+aZZFAz2aD9aSu8P22ILgTG6R6BkMrNXr0LC2Ph6Xl8fD+HFl/1H7hdeHy2047HzhcBkcw0JMyMmE9q3fgtaG6TgxSXgHsPQLLeoQCPcWQVvE6kJEZacyO1aOnClxtZ/SKCvSkOoFje7+L1CNs3S5TXBNs3S7VDfTsl/4LUl5h4P6s04Fju+D/FHUSS5sOivtRRv9bowI9+433wlKvIVyvPwj50P5AWXV69BTnpqq32dKoWXj0hC14LZGE60VNVCOGbnbq1Anz5s0z3GbevHno1KmT7vOjR4/GgAEDTAV5ANCmTRusXWv8g1u7di1at45c8Pbt24evv/7a8DUbN26s0UsyGP1AwgyGJgHaFQ7AYOx98HFLI2FOoLpCoTdHTyMbojg/JK5J2opU1vFN/A8PAxIXAk5krpgwHFDRop3o+7DZzCWHMMoqGU+gZ5B62ax4MpFqBvGqm7OUmxfj/akyk4nzLAzm6CnmaBhletSZZ6P4ftUt3cL5HzW0SN1Ka2bYlM2uOA+MerP0SJKkXfFpGn29i6R21xj6ZHQuKwKxBLNuGg3zNDlHL4pOohTFQtLHRPfoKa4jqWgwESvUOcqhm7rLK6hINrvyuhhPVk697yHWZ2n2+9NJ6Z8qigybetcZdQOA+m+XM/Jv8bctXvvF44i9sFrnvt5nZ1Vdu8XthPMuap/qXg71+0w2C2voty3Ow9SbWqG+VhkNNQ/VK4TfTyrWpYsaxqe6Dmpeo0JsdoM5pNpz5qL+TiSzti166Q+9Hj3F/lX3Q0l931Ofa1rzicNJoIRjqBs/DBK5KM53m017qL66t97EtTFcHp3lZhTbCsmf0nEdqW5qRKB35ZVXYufOnRg5ciQOHDigaKUvKyvDG2+8gdmzZ2PIEP25BsuXL0ffvuYXh77ooouwYsUKTJo0KWrYqN/vx9KlS/HCCy9g8OBIC1Hv3r3x+eefY+HChVE9CR6PBx9//DE2bNiAbt3054RVd5KqR09TrFTzepObdfYX+tErLmqqxC+6iVY0gk7Fjz+OSdri3C4zwYasUaFTpFxOYLKzolIv3szjyLAotuCaTqtvdKE1fE75+evON4lHkmsLRgUx2XWMGyfUC99n54QDVq313cLbCd+VVjav8HPieS/eaMUbkDpgFXqFom5m6m3NNCjY7MqWfaPKTYz9qKmz8wIwTCluNvmBYo5ePGvBGSWNMpt1U0VdMQl9lorJ+6HAX/zuEg0sdQsiJB3IVSZj0ZoHHS63eL+y2ZVzid1OmKYXRMcaIWMykZekk9I/VRQVVL3vP9b3JH5eYtAgrLmmCC5i3Y/0jmexKu8BeslYVN97VOAXdf1PINATv79Qj55YBr1zSB1UmpijJ/6mxDmscRE/N3WdRmfJCk02u+55opcFM/C38J0kcD8LBZ/isFJF5la9/cfq0VO/F616jsbyPZJ6yRGjxsWoz0LjnNdaqzKWUD1RZ7kZxTHFUTA1dMmEeNSIoZtWqxXff/89nn32WXTv3l0R7BUWFqJ79+5YvHgxcnMDLZYLFizA4MGDsWLFinAik4MHD+Lqq682XI+vV69emDhxIoBAQpS5c+fiwQcfxMMPPwynM3KhslgsaNOmDcaOHYsuXbqEH2/ZsiUmTpyIkSNHYsOGDfAJN72srCycffbZmD17NjIzq/F6VTGIk+p1Ez0YjbOHTqulLEPKyta+xYR69I5pgvAnqq5Q6M3R06qAG1ygDIkXPTPBkXgT0+jRS4Qi0BMrtzF6URVUyROMhq6a2r/RELf8euFhFIBG71Mikq0Qq29KuXmGgYLW+Wpp0Bj+8hJhfTfjZCxSnUL96lOGTsVC0aOnDvSE819dPlXlKarVVoOkSuyQaO+SVtbF0Dw/xXbizViSlKnazfboicFoHD16usMLAeU1LZ7PQKdHTy6PVErDvzPx2iW+h1QPgc7IjL3GXfgxZaAnXhdlVzyBnnbAFrOH2GwynXT36AmJesJrWKq3Ub0X9dwzWQhqFEuWCJVLxVz3GAlzdJOjWK2QxWy8OoGe+hyIWmYhFT16wveudb2RXTpLGEX9Fo0CvcB+xUAv4QXIFQuDKxeBN5NcKPxamz2wL63fiJg4SmtN3dBzCfXo2aNfK34udp1G6ahAT9Wjqh7tYosuW+g6ZtSjZyTqs8jNAw7uUz6mPgdN3PPD5TLTo5efXIN7TVMjAj0gsDzBiy++iBdffDHmtueffz7++kuZSnjp0qU6W+tr3bo1Pvvss9gbCs477zzMnz8/7mPVGMLNSv9GaDVuE9Rbc0qvZUWjR09WVyh0Az2NSq7ZbIhqiqGbJi7OYst9KDV0koEeEh1SJVLfyMwEiQbBgmElTh0Qp2IB+DgWD9ekStEvZWTqJ/OB9s1COqYJsHVdZJiSVjIWceimUcOATo+eZNCjJwsV44QXA1ZLQaCnGfBqDd3MVVUSxLm5Rr3TqVheIUZirxDdpQK0qCsLoc9SKx232NNvS1+gJ0kS5JwY14vwcDhVj54orh49nc82xmcZdT3Xoej9TkNLvBik6C6PoP6e1EGMOLpErHCHevRy83TXPtRq5NA9Dy1W5XVBsZ3weKweDvU1OZ7e8ZBY359eY4H6WCbW0VMEegYjJQyJSUfUwaJ6aoMRWdb/3Sp6OVW9WIrRE4kHeoqiiNcas3UVg6ybAAzvW4pzNY6G5ujezbzoe2dUY2Uc18YYvycAimkVhsOFa4na/w4ppcTeH4uQ7U1ku3ig4fOSxRJYg0+4qVpPPk/RWhvKgmY96wJYjgksrium9bZ2PjvyOgSy3GnSuADZztBPlmNE2UoWu0fP0jx6yJr11O6RcsSTVjk4FEKcqC+mIDe8QapI6h4kg4u5/YpABivb+VcGXltYH7YrAtkpbb0Caz9Zz9FetgIAbGcpE6Wo09Jrlk8jBbVyg+QWeVdkgwul3VadJ9Zul8JyfKC3PvQZiELnoiW4lqStb3QqdXHyttGNyt7n2sh2inWMIr+HUKp2SzBduPWEUyKvKVImoYpKlKBi7Xap5pCnqPNC87U6CVlCDUAalQrNlNQGi2wbBa6STqBnv3KwxtbarB2V83qseteDOHr7pToFigas0MgHW89AMiRLmw6RjRVDN5ObF6lm7Xi6slzCe9DsWQ3Oo5IaRpZuUFd8rPEswaLXMxfjvYWyqkqx1hQT17xKwWLvRqydztJ5QvleLM3bBsoT/N0pUsaLPXrBIczqDMGKhg2tc19vGLXVBouYEVL8PQSXOrK0P1k1B1CjkVMnGUvoumc9L/aUF+uJZ2o/HlwWw3717ZrPh5YbCK3JG7qn2PsFfs/W03vAErzW2fveGNjmgsBSGJbjOgcSnKmWHTEsZzCxkb3/rZEH8wrDDTWWouaac6ZD5YmSXzdS1pNViaOEnALqeX6K81xosLBpLMlh01q2StEjGUzsIyxBoliKRXFNVt47rZ2U31tUBnKDIFExOkfj921RXYvCVA15WqN8rKp6gu2C/4vev851SRHcBc/30HkVOs/EJaaOBjWmR4+qj9zpm+DfvU13TZGMmx+C5bhOsKkufKLsN+dCLj0AS1Fz+Leuh+3MXnC//0z4+ayH3oRvw++BoMzrgfWcC2E771Lkdj4b/u0bwxmYsl+fAe+vP8DW9RJkDLgH/nUr4Br/AvyrghkvNXqirJ3PQvY732omiTAUZ4+epVEzZH+4SNF6ZG1/MrLHzIOlUTNIzY6FpWFTWDqfBf+6FYpAVi13+ib416+E9by+yPl8NeTyEthO7ors9xdCqnuM4rOL531IVpviM7JdPgi27pfDdnqPwOcaXMfPfsXNsNRrCEvH0yHl5sN73qXhbJe2nv2Q/b9ZQF4hHDcrkx1Zz+wVuDFnZAIuZ6AyNPpexTYZt40MZ/wDgOznJsPzxbvwfBVINZ/13GTAZofzgeB6QEkGehkD/wtLUXPIjiOwnh7MaChUbm0XD0DWI+9Cdjnh+30xbBrBTebQp2A9vWc48M646QFY2nSA9aSu8K9aAvlIGWy9roLrxbuDO7Uh58u1kP/eDu93n8Mz/cPAe3vqI9jEDIY6yVgyBj8CS/uTYQuu+Whtf3Jg+YPGLSE1bR1IFV4nH7DZYWnYNKq8uVPXw1+8GbLbCduZvSF73Kj419mQxUWUTSRjyR41Ed5fvg/0rGTlhHv1wxUGraGbJ5yC7He/h/z39kBW3oL6yoqP1lBaPcLrxJ6OzPtegfXsPpBy6sAxNFJZyf16e9QurB1PR/Y73wXK6jgcVamIbBhHoJeRiZz3foBvzTJI+fUCmSsB2K+7C1KzNrCeJPwuFHN3tZeLSJT1hFOQ/c53irmwoeuF2LuY/eYcSIX1wz1LlnqB5Q/EYDV35mb4d26GtbNOwKNBHBab+fj7kSyHMYYP2/sNhuWYJrDESF+e7h49AMidswP+TX/AqrPuqnj9yRr9FSwtAoFezse/wLdqiaIxTmw8sR7fBdlvzYUluH5geJuYyViEe01OnfDyErBaIWXXRc7HSwPDdIVrWMaQx2DpcCpsp3SDf6eQJVgjSUZUj2Ew0Mt86E1Yu10K25m9o8ukYu1ydmCZG9V83Oznp8D7y/eBzM5T3gAAWNqeiMwH3wAkS7jxIWfib/Ct+hm2YAbUzLufh/XU7rCd3hPw++Bd8WO4kTDjhnthadUuXL/IGTMP3h9nwfXKfTHLmf3yV/D+Oh82ISiSJAk5nyyDb+Vi2M7rC/cHzwpvLHANyHzgdVjPvRhSdm7gM5QkyEfKYKnbAJl3PA1r57NhUy3hYWlQFFguSSO4lnLzkDNhWWCJDOF3n3HT/bC0OSHQ2OX3Qa44DOsp3aKWoxIb3HMmr4Dvj6Xhzw4IDBPWOi/U985Y10L1MF/Fc/XFRoboa2XO298Elp2yZ8C7fCE8H70Ufu96+8n4zzOwnnwebKech+wPFwFeD+TDZYr3Ft7/O9/Cu+JHSBYrLMdFEjGKc5FDDW72/7sDlsYtYQleyywtjwvUndRLE9VSDPQobpYWbcM3Ny2S3a5Ixa3FemykhTvc8yFWNHPzYe8Z6fEK/VtSpXaW8gojzwXT4vp3bIIrGOjpLU4sLrlgmnjRMzNHD4BNY0FvMV16aHkGi16lIsjSsGm4Ai+muhZTDkc2thgPv1FMNldmbrM0bBr+PMXPX7JYwqmGAeWyDZIkwXZeX8iqFPqhY4lp6P27tkZtIjVqDutJ58L3+0+Bvwvqw9azfzjQs/Xqrz8sKQFSbl54yQzxPYTYevYPJLLIzYOlp3avq1RQT/kZCOe85XyNteZsdljbnAC0OQHw+8OBXmjZDXG7MHE+kj0j6jdlOzPSE6W1vIfI0qqdohdPAmDrcSU8H78c2Uh9XmiQcvMU50X0BtHfjSRJirJGUQdURkNRFXP0hOtFVnZUuSxtT9RdKNl2VuzKa7xDKa0dT4/uUdO6FvrTO3RT/d5C1wvvj7Mij3U+G1KesiVdXPoACPQAavUCGhICPXvvqyOBXoxh5pLVqri+6BKHM6cpW56lqHm4p16TEKiL9xFLvWNgUf8OFY2Dds37jmLoptYwcbHxJycvsrxE8N6m7pUBVNcLYf5T1DBFQOM3G/iutH5TRjSXuamTH7XEj/WcixRLBgGB5Q/Ez07KzFLe/4XfkPo3ZWl5POzX3Wkq0JPyCjTfk/W4TrCGggWNTLhSdk7U+wjvMyNT93PSWi4pvGuNHi+t64XW+oMiS/1G0ecdtM8Lreuz4bXQqEevoXAuaSW9y68b/lzkskPh9WGjhm4K56S14+nhOo1W3UnxuoJ62vVMseEkWEbJag3XtUI06061FIduUvUhJnExGUhpEiupKZz3IgaNCU2gTiexIhWrUqVOyS22GCfzeWlVUtSfk9bnJsvK1vmsbOUNSZUwpkaOqRc/V7H8UZPfhUpdJWcDizovKuu4Uesaml1eIb1lNJPEJiFpDvRMSdf1S5z/KB4jkXlfWipx6KYu8b3EGsJvJoOjeL4LSToi+xCuCeIyLSbPT8V8QIO092FJLq8Qk8F86ISl8rdTRddBXam8DsU7Gsbg/FYkwol1zhjME7UIAWMq5psrGk4STdZTy9TAGhPVWmIFOJmKiCJFepoqa9Ut0BPFuuiqFsZWDM9I4iYv2TXm+6n/1sjiFXixEMipWuqjArskh25WBUkv0ItKIy1ULCq7IpsR3ZJdKdSBntEcPb3lFWoQcdmVKns/6bp++XQCPTk1gV5lDN2MSRGox8jKaCJoUJzvWo1Y4uvETL4mr4OKiq+YVl5PqoJyPWLipRRJZeOfVFXXQT0xspjHt684751GSdiEYY+6iYtC2xpkwlQ0PsSxTJQu4fdiMdOwcRRgoEfVh0VnCFsy+4ln2YFYFMsl1NwlMpS9S6q0+ilaLDdMVaHUHfMvHjdWBS7dgV469q9IfS6s4aSuoIjrO1X2Qq5p+N2YmgOh/q1r9WqExNOjl8i5nO7eDECZsKSKevTS11spZIMVj2F2+YRY0ry8ginie4x1rdBI7BElVnp3McNuIhmjxR49naWNDP9OtTQEeiklDgmPZ/mldEnpbzW+e5vR+S3eu2T18gjqbcXfrXqOnriOodFoDrOcwnqCyWY5ryUY6FG1IV44zLZWaqqMHr3qcANIlCK4kFPb8q7OqKXuwTPRkyDZ7TGCrZrXo6c7dFNNrBCne30fdYUuFa3i6rTYZtKfq39LRgGcrfKGbqaN3vIKNfmaEqK3dEWKeonSvWC6KfG8FzM9ejHudYp1+RLo8VAE3GaGxqWo91V39+kYuplKqZrKkCJJ1YUqSaxAT3E/V/foCWtXpmLopnykXDhs9f/sKgMDPao+UjT8QtEKl8IePUlMl1/NLiDhLGJZ2bBf+W8AgaUptCgW8s6uo+xVSrZHT90iZ2IdPXGpgBCLwRILoSUG0kWRCj9ZwYqZmIkvlI5dSyjdPYC09xqrEyKIaa4lvbUuY1Av7WAPLsVhJJQ2PbwPMWW8mokevVDSGZuwbIVZVp0lYVLJftmgwLFOPi81axeaFJXWPw1swe/SolqawOj3HA9JyChbVfNv5DgCoXjXS9NaysIiLp+S5P1Ma8kIS+sTlNuYWAInIcF7gZksnsmSjK4hMVjExexjLfdRw9iDGZ5DSwfFTXVfCC3tY4uRTE4SsgCrl5qwCEu7aK7zGKdwJu2jYCF0s6q+uYIoJFVj0cWkKSmsPFkaNkH2Bz8mNnwmzWyXDERWbj6sHU+DlFc3kNlMIwsaEGgVz5mwDPD7IWWrhsklO2wn1tBNiwU5k5YHllqo2wD+v7drB3pNWiH7vR8UQ/9yvloHeW8xrO3iu0nlfr0dRy5pGXO7nC/XQt6/G1aDZS7ilTt1PXx//qpYW8vSuEUgtbPGsBIprzCQ5t6ekfZhQ9bz+iL79ZmwtA1km5OyspHzyS/hfyfC0rApst9fCHjckA+XKtcU05FxywhYjj0xkOk0u465eUTQT4iU/eFi+JYvDK/NFg9Lq3bIHjNPmTo8xTL/+yKsp3QLZLurjKGiQZYWbZE9dr6iBT3VMu8aBWuXc8JZVnO+WAP54D7DLM3xsF9+cyB9ek4dWA0yGqZVgj16RnMwc6euD1wLO2gFes2R/d4CSAX1FMvQxMPo2mlpeRyyx84H/H7IFeWay8mkQu7MzfD9+Zu57KrJqJOPnCm/J/xy20XXI8tqAzIyI0FDLZFx+xOwnHBqVCOfKVnZyJ22UfFQzsRfA8tSxDhnLMc0DtzzNNbMk/IKkPPRz4HlQlIwd9jW+ypkvTJNs15xtGKgR9VHqiZUp3Hopu0U/bUBq5JksShS7NsvuNpwe63UzgBS3qOnNSdPvACHW/q10j6rbkbW1u2BBIIwS+MWsJxwKvzrlhtuF17+IIXEZTFERqmd1Wnu00WSpKj1iawx1jEzI9601ZI9A/bgunMxieenXo9e3QawmN2fBnH5k3SQMrPCv89wqnygUoI+9VpfqSa+NyDYQ5rCXlIpKxv2yzQWkK5M8QxtNJnBUb38iZrttO6BfyQ4kiTWtTPd5wWgfy1MNVvP/rAk0RMnZWTC3jd64fLaIK5rrYqt22WKDJlAcFkMnWUnol5vdM+LY63OWCRJirnc0NGGQzep+khVj16ahm4eFdKcjCVdx42pmg21pRSoqXP0RLXhPRxt4ujRUzR0peK7rolLy1DtUImjDyi1eNWg6iNVNzExuEtXMpZaKp75J5rUY+yrS3ZSBnq1g4kevRpFfA+sSNUMKU7GEh9ex2LitT490r3sBqUNAz2qPlKVjEW9fACZl+IevWqzsDxbwmsH4fxM5dpZVSWViZCokvjjWCpCnC+eikCPQQxVFV6faqyaf6ek2iNVQzcVc/Q4DTUuSbbaRWXdrDa9Lqwg1Q61ubJRm99bLRLPNVIMzFLR6MhAj6pKmpfdoPRhoEfVhu2cCwP/SHa4pTBHL20LA9dS1lPiS6ShJjVqrnzAZIrjUHbGdGUEtPXsF9h/JSQDoPQxWpqiprM0O7aqi0AmWM8JppI3kZlWkVk3FeneGejFJNX2Rj2TWYlTJrhEUPi8pxqH3R1UbdguHoCszGxYO5yW3I7EllMO3TQld9YW+Daugu38+FPSi+yX3gQprxBSTh1IdY8xPXTTfs1QSA0apy1lesbAYbA0bR1Yu4xqLEvT1oHlD4RlN2q6nE9XQS75B5Zmbaq6KGSC/YqbIeXXNZUpUMqpg5xxPwVSx2tkII4bA73YavlnlPv5mso93tT18P2xFLYeV1bqcSl1GOhRtSFJEuwmU/UaSuPyCrWVpWnrqMWuEyFlZcN+YfwLVUs2W8wlIZIh2e2wX3BN2vZPlSfdyx9UNuvxnau6CBQHyWqNK0W99aRzUnjw2h3EkDFbr6sUC7pXBkvDpkktV0NVj0M3qfaxcY4eERHVNgz0YqrNwXBtfm+UNgz0qNaROHSTiIhqG1b0j278/ikBDPSo9uHQTSIiqm1Y0Y+tNn9Gtfm9Udow0KPaR8y6yR49IiKqDWrB2pGUDAZ6FD9eNaj24dBNIiKqZWyn165EROlgPe38qi5C+rBHjxLATBVU+4hDN208xYmIqOazXTwAWRlZsHY8vaqLUu3kzt4K35+/wVabM0Qy0KMEsBZMtY4kBnrs0SMiolpAsljSugxNTWZp0gqWJq2quhjpxUCPEsChm1T7iAlYmIyFiIiIajoGepQABnpU+7BHj4iIiGoTiVV2ih/PGqp9rMy6SURERLUIe/QoAQz0qPbh0E0iIiKqTRjoUQIY6FGto0jGwgsjERER1XC22rx0BKUNs25S7SMGerJcdeUgIiIiSkLurC3wrVkG2wXXVHVRqAZioEe1D4drEhERUS1gadoalqatq7oYVENx6CbVPuzRIyIiIqKjHAM9qn2s7KgmIiIioqMbAz2qfTh0k4iIiIiOcgz0qNaRxEybHLpJREREREchBnpUq0mNmlV1EYiIiIiIKh0nM1GtlPPxUsjlJbAUNa/qohARERERVToGelQrWTudWdVFICIiIiKqMhy6SUREREREVMsw0CMiIiIiIqplGOgRERERERHVMgz0iIiIiIiIahkGekRERERERLUMAz0iIiIiIqJahoEeERERERFRLcNAj4iIiIiIqJZhoEdERERERFTLpDzQ8/v9kGU51bslIiIiIiIik5IO9EpLSzFixAiceuqpqF+/Pux2O3JycrBixQoAwMknn4yePXvi22+/TbqwREREREREFFtSgV5JSQk6duyId955B+eccw4effRRvPTSS3C5XNizZw8A4Omnn4YkSbj00kuxePHilBSaiIiIiIiI9NmSefHIkSPhcDiwYcMGNGrUCACwa9cu3H///eFtLr30UlxyySU47bTT8Nprr6Fr167JlZiIiIiIiIgMJdWjt3DhQgwYMCAc5OkexGLBJZdcguXLlydzOCIiIiIiIjIhqUDvr7/+QsuWLU1t26BBg/BwTiIiIiIiIkqfpAK9iooK5OTkmNrWbrfD7XYnczgiIiIiIiIyIemsm2aXUuCSC0RERERERJUjqUCvXr16KCkpMbVteXk56tatm8zhiIiIiIiIyISkAr22bdti7dq1prbduHEjjj322ISPVVJSguHDh6NTp05o3LgxioqKUFRUhA4dOmDo0KHYu3dvzNffeeedaN26dfi1RUVFaNasGXr27IklS5ZEvaa8vBwPPPAA2rZtq3hNixYtcNlll2m+d4fDgeeeew4nn3wymjRpEn7N8ccfj4EDB2Lz5s0JfwZERERERERmJBXo9evXD5999hnmzp1ruN2vv/6KyZMn46qrrkroOD6fD7169UJubi4WLFiA3bt3Y8+ePdizZw9+/vlntG/fHueeey4qKip09zFs2DDY7XasWbMm/No9e/Zgx44deOqppzBw4EDs3r1b8Zr7778fR44cwYoVKxSv2bZtG26//XZcccUVOHLkiOI1119/PXbs2IFZs2Zh165d4desXLkSF154IXr06BF1HCIiIiIiolSS5CQmz3k8Hlx44YVYuHAhTjjhBLRp0wZ2ux1Tp07F+eefjwYNGqC4uBi//vorunbtiu+++w52uz3u43zxxReYPHkyvvzyS91t7r77brRu3RrDhg3TfL5x48bYsmULsrOzNZ8fMWIEWrRogaFDh4Yfa9iwIYqLi5GZman5mhtuuAEDBw7ExRdfDAD47bffcPvtt2PZsmWwWLRj6FdeeQXbt2/H66+/rvte1MrKylBQUIDS0lLk5+ebfh0REREREdUuZmODpHr07HY75s+fjy+++AK9e/eGxWLBwYMH0b17d8iyDKfTiTPOOAOffvopFixYkFCQBwCrV69Gjx49DLfp3bs3Vq9erfv88OHDdYM8AGjevDmKi4vDf7tcLthsNt0gDwCaNWumeM3q1atx/vnn6wZ5ZspJRERERESULFsqdtKvXz/069cvFbvStHPnTnTu3NlwmyZNmmDHjh26z+v19IWsWbMGp512WvjvzMxMFBYWGi4hUVxcjN69eyvK2bhx46TKSURERERElKykl1eoDD6fD1ar1XAbm80Gr9eb0P5nzJiBuXPnRgWr/fv3xx133IE9e/Yolofwer345ptvMHfuXJxyyikpL6fL5UJZWZniPyIiIiIiIrNS0qNXUx06dAjDhg3DokWLMG3atKjlH+68806cddZZaNy4MQoLC5GZmQlZlnHw4EF4vV588cUXqFevXsrL9dxzz+HJJ59M+X6JiIiIiOjoUCN69NQ2bNiANm3aYOPGjQm9XpZlTJkyBV26dEHdunWxYsWKqKGhLpcLffr0wYgRI1BSUoJDhw5hz5492Lt3L8rLy/HNN99gzJgxhusIlpaWom3btliwYEFc5RsxYgRKS0vD/4nzAImIiIiIiGIx1aPXrVs3bNu2LemDtWnTJu6gR0u7du2wZcuWhF5bXFyMQYMGQZZlzJkzBx07dtTc7ttvv0W7du1w2223RT2XlZWFPn36YOPGjXjrrbfwyCOPaO6joKAAf/31V9xlzMzMNEwCQ0REREREZMRUoDdo0KCoXiVZlvHUU0/h4osvxhlnnKH5OlmWsWrVKsyePRsXXHBBwuvomZnX5vV6YbMZv51ly5bh2muvxYgRI3DrrbdCkiTdbdevXx8zAUynTp3w6quvprycREREREREyTAVcdxyyy2ajz/11FPo27cv7rjjDsPXT5gwAbfddpsiKIpHs2bNsGfPHsNtdu/ejRYtWug+X1JSgv79+2PKlCno2rVrzGOaCcYkSVIEds2aNcOaNWuSKicREREREVGyKmWO3g033IAWLVrgpZdeSuj1nTp1wrx58wy3mTdvHjp16qT7/OjRozFgwABTQR4QGGa6du1aw23Wrl2L1q1bK8r5ww8/wO/3J1xOIiIiIiKiZFVaMpY+ffpg/vz5Cb32yiuvxM6dOzFy5EgcOHBAsdRBWVkZ3njjDcyePRtDhgzR3cfy5cvRt29f08e86KKLsGLFCkyaNClqOKbf78fSpUvxwgsvYPDgweHHTz31VLRs2RJDhw7Frl27FOWsqKjAhAkT8Oqrr+LBBx80XQ4iIiIiIqJ4VdpkscaNG2Pv3r0JvdZqteL777/Hs88+i+7duyuCvcLCQnTv3h2LFy9Gbm4uAGDBggUYPHgwVqxYgfz8fADAwYMHcfXVVxuuc9erVy9MnDgRQCAhyty5c/Hggw/i4YcfhtPpDG9nsVjQpk0bjB07Fl26dFHsY9KkSXj11VfRt29f7N27N1zOvLw8nH766fjhhx/QpEmThD4HIiIiIiIiMyRZ7HaKk8ViwZtvvhlzjh4AvPnmm7jnnnvg8/kSPdxRq6ysDAUFBSgtLQ0HrkREREREdPQxGxskNXQzLy8P5eXlprY9cuQI8vLykjkcERERERERmZBUoNe2bVts3rzZ1LZbtmxBmzZtkjkcERERERERmZBUoNenTx9MmjQJmzZtMtxu48aNmDhxIi688MJkDkdEREREREQmJDVH78iRIzj11FOxbds29O3bFy1btkSdOnXCzx8+fBjbtm3D119/jVatWmH58uXhhClkHufoERERERERYD42SCrQAwC324233noLCxcuxLZt21BaWhp+rqCgAK1atUL37t1xxx13IDMzM5lDHbUY6BEREREREVCJgR6lHwM9IiIiIiICKinrJhEREREREVU/DPSIiIiIiIhqGQZ6REREREREtYwtmRd/8MEH2L59u+ntW7ZsiX//+9/JHJKIiIiIiIhiSCrQmzhxIrZu3ar7vNfrxa5duyBJEpo1a4Zjjz2WgR4REREREVGaJRXozZ8/P+Y2W7duxb///W80adIEEyZMSOZwREREREREZELa5+i1bt0aU6dOxfTp0zFp0qR0H46IiIiIiOioVynJWAoKCnDZZZdh3LhxlXE4IiIiIiKio1qlZd087rjjsGrVqso6HBERERER0VGr0gK9+vXr4+DBg5V1OCIiIiIioqNWpQV6brcbWVlZlXU4IiIiIiKio1alBXrFxcVo06ZNZR2OiIiIiIjoqFUpgd6BAwcwadIkdO3atTIOR0REREREdFRLah29b7/9Fjt37tR9/vDhw9ixYwc+/vhjSJKEp556KpnDERERERERkQlJBXr/+c9/sHnzZt3n8/Ly0KpVK1x33XV47LHH0KBBg2QOR0RERERERCYkFeht2rQpVeUgIiIiIiKiFKm0ZCxERERERERUORjoERERERER1TJJBXqjRo0yPXxz48aNGDVqVDKHIyIiIiIiIhOSCvQeffRRfPfdd6a2nTZtGl544YVkDkdEREREREQmVNrQzW3btqF169aVdTgiIiIiIqKjVqUEetu3b8fEiRPRq1evyjgcERERERHRUS2u5RU2bdqECRMmQJbl8GMzZ87Enj17NLevqKhAcXExZs2ahYYNG+Lxxx9PrrREREREREQUU1yB3urVq/HJJ58oAr1ly5Zh/fr1mtvn5uaiVatWePTRR3HPPfcgJycnudISERERERFRTJIsRm1xslgsePPNN3HHHXekskykUlZWhoKCApSWliI/P7+qi0NERERERFXEbGyQ1By9/Px8FBQUJLMLIiIiIiIiSrG4hm6q7dq1C7m5uakqCxEREREREaVAUj16DPKIiIiIiIiqH9OB3r59+7B48WKUlZWlszxERERERESUJNNDN0888UQcOHAAXbt2xcKFCwEAN910E7Zt22b6YK1atcLHH38cdyGJiIiIiIjIPNOBXmFhIf755x8UFhaGHzv22GNhtVpNH6xVq1bxlI2IiIiIiIgSYHp5Ba/Xi7///hvNmjWDJEnpLhcJuLwCEREREREB5mMD0z16NpsNzZs3T0nhiIiIiIiIKH2SyrpJRERERERE1U+lBXrTp09H+/btK+twRERERERER61KC/RWrlyJw4cPV9bhiIiIiIiIjlqm5+j5/f6EDuByubBmzRqMGzcOXbt2TWgfREREREREZJ6pQO/YY4+Na708LR07dsSLL76Y1D6IiIiIiIgoNlOB3rvvvovdu3cndICsrCy0bt0ap556alxr7hEREREREVFiTAV6F1xwQbrLQURERERERCnC5RWIiIiIiIhqGQZ6REREREREtYzprJtmidk5LRbGkURERERERJUt6Uhs//79uOuuu9C5c2fk5eXBbreH/8vLy0Pnzp1x1113Yd++fakoLxEREREREcWQVI/evn370KFDB0iShH/9619o1aoV8vLyws+Xl5dj27Zt+PjjjzFlyhT8+eefaNiwYdKFJiIiIiIiIn1JBXqPP/44AGD9+vWoX7++7nYPPfQQTjjhBIwcORLvvPNOMockIiIiIiKiGJIaurlkyRJcf/31hkEeADRo0ADXX389Fi9enMzhiIiIiIiIyISkAr3NmzejZcuWprZt0aIFtm7dmszhiIiIiIiIyISkAj2Hw4Hs7GxT22ZnZ8PhcCRzOCIiIiIiIjIhqUAvPz8fhw4dSlVZiIiIiIiIKAWSCvRatmyJnTt3pqosRERERERElAJJBXqXXHIJZs6cqVgkvTKUlJRg+PDh6NSpExo3boyioiIUFRWhQ4cOGDp0KPbu3Rvz9XfeeSdat24dfm1RURGaNWuGnj17YsmSJeFtN27ciKZNmyq2E//Lz8/Hk08+CQCoqKhAnTp1dLcN/Tdjxoy0fj5ERERERHR0S2p5heHDh2PSpEl46KGH8OKLL6aqTIZ8Ph969eqFyy+/HAsWLEC9evUgSRIAoLS0FOPHj8e5556LP/74Azk5OZr7GDZsGAoLC7FmzRrk5uaGH/f7/ViyZAkGDhyIn376CU2aNMHxxx+PXbt26ZbnjTfeQGlpKQDA7XajQYMG2LZtW+reMBERERERUZySCvReffVVtG3bFqNHj8YXX3yBs88+G1arVXPbDRs2AABuuukmxeMtWrTAM888Y/qYU6dORatWrTBy5Mio5woKCnDPPfdg8+bNGDNmDIYNG6a5j7lz52LLli1RiWQsFgu6du2K6667DtOnT8fQoUNjlmfHjh3o2LGj6fITERERERGlW1KB3o4dO+D3+9GtWzcAwO7du3W3zcnJQbdu3VBcXKx4XC8w1LN69Wr06NHDcJvevXtj2rRpus8PHz7cMFto8+bNo8qpxefzYebMmboBJRERERERUVVIKtAbP358ioph3s6dO9G5c2fDbZo0aYIdO3boPh8rMFuzZg1OO+20mGV56qmn0K1bNzRp0iTmtkRERERERJUlqWQsVcHn88XsBbTZbPB6vQntf8aMGZg7dy769eunu43X68Vdd92FxYsXY/To0YrnKioq8Nhjj+GUU05B06ZN0ahRIxQVFeH444/Hddddh/Xr18csg8vlQllZmeI/IiIiIiIis5Lq0atNDh06hGHDhmHRokWYNm0a6tatq7ldRUUFrrvuOhQVFWHu3Lmw2+3h57KystC8eXPIsoyvvvoKTZo0QUZGBgDgyJEjmD17Ni666CL8/vvvKCws1C3Lc889F87kSUREREREFK8a16OntmHDBrRp0wYbN25M6PWyLGPKlCno0qUL6tatixUrVhgODb333nvRsWNHjBkzRhHkAYFAb/ny5XjmmWfQqlWrcJAHALm5ufi///s/XHbZZfjyyy8NyzRixAiUlpaG/zMzX5CIiIiIiCgkJT16q1atwpo1a7B79244HA7d7Vq0aIFBgwal4pBh7dq1w5YtWxJ6bXFxMQYNGgRZljFnzpyY2TPXrl2Ln376CcuXLw8v6RCvE044AZs3bzbcJjMzE5mZmQntn4iIiIiIKKlA7/Dhw+jfvz/mzZsHWZZRr149w2yWxx57bNKBnpn5d16vFzab8VtbtmwZrr32WowYMQK33nqrqcBt5syZuP766xU9dfHKyclBRUVFwq8nIiIiIiKKJalA7+GHH8b8+fPxzjvv4MYbbzQM8lKlWbNm2LNnj+E2u3fvRosWLXSfLykpQf/+/TFlyhR07drV9LGXLl2Ku+++W/f5X375BZs3b8aAAQN0t3E4HJXyORERERER0dErqTl63377LQYNGoQhQ4ZUWvDSqVMnzJs3z3CbefPmoVOnTrrPjx49GgMGDIgryAOAXbt2oWnTprrPHz58OOb8u40bN6JNmzZxHZeIiIiIiCgeSQV6W7ZswYknnpiqsphy5ZVXYufOnRg5ciQOHDgAWZbDz5WVleGNN97A7NmzMWTIEN19LF++HH379o372IcPH0Zubq7u86effjpWrlyJr776Cn6/X/Gcz+fD119/jalTp6J///5xH5uIiIiIiMispAI9r9cbc027VLNarfj+++/hcDjQvXt3NGnSBEVFRSgqKsIZZ5yBNWvWYPHixeGAbMGCBWjbtq1iLbqDBw/i6quvDr9O67+BAwdGHTs/Px8FBQW6ZcvPz8f06dMxbtw4tGzZUrG/Vq1a4e2338b06dNRv3791H8wREREREREQZIsdonFqaioCIMGDcLzzz+fyjKRSllZGQoKClBaWor8/PyqLg4REREREVURs7FBUj16ffr0wezZs+Hz+ZLZDREREREREaVQUj16+/btQ48ePdC8eXP897//RatWrZCTk6O7fWFhIXukEsAePSIiIiIiAszHBkkFegAwefJk3HjjjTCzm4YNG+Lvv/9O5nBHJQZ6REREREQEmI8NklpHb9KkSbjxxhtx7rnnYsCAAWjWrJnhMguNGjVK5nBERERERERkQlKB3ssvv4yzzz4bCxcuhCRJqSoTERERERERJSGpZCwbNmzAxRdfzCCPiIiIiIioGkkq0HM4HCgsLExRUYiIiIiIiCgVkgr0CgsLcejQoVSVhYiIiIiIiFIgqUCva9euWLFiRarKQkRERERERCmQVKA3evRoLF26FOPGjUtVeYiIiIiIiChJSa2jd9NNN2HZsmXYtGkT6tWrh5YtWxoumN6qVSt8/PHHiR7uqMV19IiIiIiICKikdfTatGkDq9WKs88+29T2LVu2TOZwREREREREZEJSPXpUOdijR0REREREgPnYIKk5ekRERERERFT9MNAjIiIiIiKqZRjoERERERER1TJJJWMJWb58ORYvXoxt27ahtLRUd7uWLVti5MiRqTgkERERERER6Ugq0PP7/Rg0aBAmTpyIvLw8NGrUCH/99Rfat2+PevXqwev1YuXKlfB4PDjttNPg9XpTVW4iIiIiIiLSkdTQzffeew8TJkzAmDFjcPDgQcybNw+yLOOll17CokWL8PPPP2P37t247LLLkJ+fj/Hjx6eo2ERERERERKQnqUDvo48+whVXXIHBgwfDYrFAkqSoberVq4dJkybht99+w9ixY5M5HBEREREREZmQVKC3efNmnHzyyTG3y8nJwRVXXIFJkyYlczgiIiIiIiIyIalAb//+/ahfv76pbVu3bo21a9cmczgiIiIiIiIyodKWV6hXrx4OHTpUWYcjIiIiIiI6aiUV6NWrVw9lZWVRj8uyHPWY1vw9IiIiIiIiSr2kAr2mTZti48aN4b8bNGgAAJo9dyUlJeHniYiIiIiIKH2SCvQuv/xyTJ06FatWrQIAZGZm4thjj8XcuXOjtv3mm2/Qvn37ZA5HREREREREJiS1YPo999yDqVOn4pRTTsHNN9+M999/H48//jj+9a9/Yfv27Tj99NPh9/uxaNEirFy5Et99912qyk1EREREREQ6kgr0GjRogJ9//hmzZs2CxRLoHLzxxhtRVFSEd955B/Pnz4fVakXbtm3x9ttv48wzz0xJoYmIiIiIiEifJGtlTqFqpaysDAUFBSgtLUV+fn5VF4eIiIiIiKqI2dig0pZXICIiIiIiosrBQI+IiIiIiKiWYaBHRERERERUyzDQIyIiIiIiqmUY6BEREREREdUyDPSIiIiIiIhqGQZ6REREREREtQwDPSIiIiIiolqGgR4REREREVEtY0vFTjweD9avX49t27Zh//79yMrKwlVXXYXMzEz89NNPaNasGVq2bJmKQxEREREREVEMSQd6n332GYYPH47i4mLIsgwAkCQJDRo0QJ8+fXDrrbdiw4YNGDhwID788EPYbCmJLYmIiIiIiEhHUkM3f/nlF1x//fU455xzsGzZMhw4cADbt2+HLMvwer0AgJUrV+KDDz7AlClTMGbMmJQUmoiIiIiIiPQlFeg9/fTTOPXUUzFp0iSceuqpqFu3LiwW5S4zMzMxaNAg9OvXD5988klShSUiIiIiIqLYkgr01q1bh969e5vatkuXLti6dWsyhyMiIiIiIiITkgr0tm/fjsaNG5vaNi8vD//8808yhyMiIiIiIiITkgr0/H4/rFaruQNZuJIDERERERFRZUgq+rJYLPD5fKa29fl8kCQpmcMRERERERGRCUkFes2bN8fu3btNbbt//340b948mcMRERERERGRCUkFeu3bt8f3338fXj/PyIIFC9CuXbtkDkdEREREREQmJBXojRgxAsuXL8fAgQOxfPlyHDx4MLx+nt/vR0VFBTZs2IC77roLS5YswcMPP5ySQhMREREREZE+STbTHWdg/PjxGDFiBPbt2xd+TJZlxXy8Bg0a4Pnnn8fNN9+czKGOWmVlZSgoKEBpaSny8/OrujhERERERFRFzMYGSQd6AOB0OrF+/Xps27YNpaWl4cfz8vLQunVrtG/fHtnZ2cke5qjFQI+IiIiIiADzsYEtFQfLysrCSSedhJNOOikVuyMiIiIiIqIkcHE7IiIiIiKiWiapHr17770XFosFw4YNQ9OmTVNVJiIiIiIiIkpC0uvoffDBB2jTpg3+/e9/Y/369akqFxERERERESUoqUBv2LBh2LFjB55++mnMnTsXHTt2RL9+/bB06dJUlY+IiIiIiIjilPQcvby8PAwfPhxbt27FmDFjsG7dOpx77rk4//zzMWfOnFSUkYiIiIiIiOKQsmQsGRkZGDx4MNauXYvPP/8cTqcTffv2RefOnTFp0iT4fL5UHQolJSUYPnw4OnXqhMaNG6OoqAhFRUXo0KEDhg4dir1798Z8/Z133onWrVuHX1tUVIRmzZqhZ8+eWLJkSXjbjRs3omnTportxP/y8/Px5JNPhrf3er0YO3YsTj/9dMXr2rRpgyuuuAK///57yj4HIiIiIiIiLSnPummxWNC/f38sXboU8+fPR5MmTXDDDTfguOOOw4QJE5Lev8/nQ69evZCbm4sFCxZg9+7d2LNnD/bs2YOff/4Z7du3x7nnnouKigrdfQwbNgx2ux1r1qwJv3bPnj3YsWMHnnrqKQwcOBC7d+8GABx//PHYtWuXYjvxv2effRZWqzW87/vvvx/ffPMNJk+ejOLi4vB2a9euxeDBg9GvXz8Ge0RERERElFYpWTDdSFlZGf773/9i/PjxKCwsxMGDB5Pa3xdffIHJkyfjyy+/1N3m7rvvRuvWrTFs2DDN5xs3bowtW7boLuI+YsQItGjRAkOHDo1ZngceeAAdO3bEoEGD8Pfff+Pss8/GunXrdPf91Vdf4aOPPsL06dNj7juEC6YTERERERFgPjZI2zp6W7ZswbBhw9C8eXNMnDgRN9xwAxYuXJj0flevXo0ePXoYbtO7d2+sXr1a9/nhw4frBmJAIJtocXFxzLL4fD7MnDkTffr0AQCsX78ep512muG+e/XqZVg2IiIiIiKiZCW1jp6WhQsX4rXXXsPMmTNRr1493HPPPRg6dCgaN26ckv3v3LkTnTt3NtymSZMm2LFjh+7zej19IWvWrMFpp50WsyxPPfUUunXrhiZNmoTLFut9FhQUJN2rSUREREREZCQlgZ7b7cakSZPw+uuv448//kDHjh0xduxYDBgwAFlZWak4RJjP51PMidNis9ng9XoT2v+MGTMwd+5cPPvss7rbeL1eDBs2DGvXrsW0adPiKpsZLpcLLpcr/HdZWVnS+yQiIiIioqNHUkM39+3bhyeeeALNmzfHLbfcgubNm+O7777DH3/8gVtuuSXlQV46HTp0CIMGDcKwYcMwbdo01K1bV3O7iooK9O/fHy6XC3PnzkVeXl7Ky/Lcc8+hoKAg/F/z5s1TfgwiIiIiIqq9kgr0rrjiCowePRrXXnstNm7ciBkzZqBnz56pKpspGzZsQJs2bbBx48aEXi/LMqZMmYIuXbqgbt26WLFiheHQ0HvvvRcdO3bEmDFjYLfbY+7/5JNPxsSJE+Mq04gRI1BaWhr+z8x8QSIiIiIiopCkhm5+9tlnKCgoqNJMkO3atcOWLVsSem1xcTEGDRoEWZYxZ84cdOzY0XD7tWvX4qeffsLy5cshSZKpY6xcuTLucmVmZiIzMzPu1xEREREREQFJ9ug1b9680oM8M/PvvF4vbDbjGHbZsmXo1q0brr32WsybNy9mkAcAM2fOxPXXX4+MjIyEy0ZERERERJRupgM9n8+HnTt3prMspjRr1gx79uwx3Gb37t1o0aKF7vMlJSXo378/PvnkEwwZMsR079zSpUtx9tlnJ1W2srIy1KtXz9TxiIiIiIiIEmF66Ga7du2wdetWXHzxxZg1axYA4PHHH8e2bdtMH6xVq1Z46qmn4i6kqFOnTpgwYQLuvPNO3W3mzZuHTp066T4/evRoDBgwAF27do3r2Lt27ULTpk11n2/fvj1+++03VFRUICcnJ6GyERERERERJct0oFdeXg5ZlnHkyJHwY8XFxXElCok1nNKMK6+8Es8//zxGjhyJu+++G/Xq1Qv3yJWVleGjjz7C7NmzsWrVKt19LF++HA8++GDcxz58+DByc3N1ny8qKkL//v0xcOBAvPTSS2jTpg0slkCnqcvlwnfffYd7770XX331VdzHJiIiIiIiMst05LVmzRqsX78eJ510UvixcePGpaNMhqxWK77//ns8++yz6N69Ow4cOABZlgEAhYWF6N69OxYvXhwOyBYsWIDBgwdjxYoV4fmEBw8exNVXX2245l2vXr2ismXm5+ejoKDAsHwvvfQSPvjgA1x//fXYtWsX/H4/ACAnJwcnnngivvrqK5x88skJv38iIiIiIqJYJDkUJVG1VVZWhoKCApSWllZphlMiIiIiIqpaZmODpLJuEhERERERUfWTVKA3atQobNq0ydS2GzduxKhRo5I5HBEREREREZmQVKD36KOP4rvvvjO17bRp0/DCCy8kczgiIiIiIiIyodKGbm7btg2tW7eurMMREREREREdtSol0Nu+fTsmTpyIXr16VcbhiIiIiIiIjmpxLWy3adMmTJgwAWKizpkzZ2LPnj2a21dUVKC4uBizZs1Cw4YN8fjjjydXWiIiIiIiIooprkBv9erV+OSTTxSB3rJly7B+/XrN7XNzc9GqVSs8+uijuOeee5CTk5NcaYmIiIiIiCimpNbRs1gsePPNN3HHHXekskykwnX0iIiIiIgIqKR19PLz81FQUJDMLoiIiIiIiCjF4hq6qbZr1y7k5uamqixERERERESUAkn16DHIIyIiIiIiqn4qbR09IiIiIiIiqhxJB3r79+/H3XffjZNPPhl169aF1WrV/e+4445LRZmJiIiIiIjIQFJz9Pbt24cOHTrA7/fjhhtuQN++fTFq1Cjceeed6NKlC7xeL77//ntMmzYNt912Gy677LJUlZuIiIiIiIh0JLW8wm233YYvvvgC69atQ8OGDbFr1y40b94cs2bNwiWXXBLe7uOPP8bdd9+NtWvXokmTJikp+NGEyysQERERERFQScsrLFmyBAMGDEDDhg0Nt7vpppvQvHlzvPjii8kcjoiIiIiIiExIKtDbsmULWrVqZWrbCy64AHPnzk3mcERERERERGRCUoGew+FAdna2qW2Lioqwc+fOZA5HREREREREJiQV6NlsNng8HlPb5ubmwuFwJHM4IiIiIiIiMiGpQK9Ro0Y4dOhQ+G+bLZDE0+v1Rm3r9XphtVqTORwRERERERGZkFSg1759eyxatCj8d8OGDZGZmak5RDOUkZOIiIiIiIjSK6lAb9CgQfjhhx9w3333YdeuXZAkCd27d8cbb7yBLVu2hLdbtWoVPvroI5x//vnJlpeIiIiIiIhiSGodPQAYOXIkXn31VXTs2BE///wz1q9fj0suuQTbt29HQUEB/H4/ysvL0bFjR3z33Xdo1KhRqsp+1OA6ekREREREBJiPDZIO9ADA7XajoqIChYWFAACXy4W5c+di69atsFqtaNu2Lfr06cM5eglioEdERERERID52MCWioNlZGQgIyMj/HdmZiauuOKKVOyaiIiIiIiI4pTUHD0iIiIiIiKqfiot0Nu4cSNGjRpVWYcjIiIiIiI6alVaoDd9+nS8+OKLlXU4IiIiIiKio1alBXoLFizA8ccfX1mHIyIiIiIiOmqZSsby+OOPY9u2bQkdwOVy4c8//8S6deswderUhPZBRERERERE5pkK9Hbs2IHi4uKEDpCVlYVu3brhww8/xBlnnJHQPoiIiIiIiMg8U4He+PHj01wMIiIiIiIiShUur0BERERERFTLMNAjIiIiIiKqZRjoERERERER1TKm5ujFsnbtWsybNw/btm3D/v37kZWVhWeeeQYNGzbESy+9hKKiIlx55ZXIy8tLxeGIiIiIiIjIQNI9enfeeSe6dOmCxx9/HN9//z02bdqEDz74AL/99hsA4Pfff8ctt9yCc845B/v27Uu6wERERERERGQsqUBvwoQJePvtt/Hmm29i//79WLVqFT7//HPIshzeZuLEiVi3bh3+/vtvvPbaa8mWl4iIiIiIiGJIKtAbO3YsLr/8ctx2222w2QKjQCVJitqubdu2uOaaazB9+vRkDkdEREREREQmJBXobdq0CSeffLKpbVu3bo3du3cnczgiIiIiIiIyIalAb+/evWjQoIGpbXNyclBWVpbM4YiIiIiIiMiEpJOxaA3VTGY7IiIiIiIiSk5SgV5GRgacTqepbd1uNzIyMpI5HBEREREREZmQVKDXpk0bFBcXm9r277//RuvWrZM5HBEREREREZmQVKB3yimn4PPPP8eRI0cMt/N4PPjyyy9x6qmnJnM4IiIiIiIiMsGWzIufffZZdOjQAV26dMHQoUPRunVreDweSJKEVatWAQCKi4sxduxY7NmzB08//XRKCk1ERERERET6JFlc3TwB69atw0MPPYSFCxdqZtXMy8tDt27d8MILL6BDhw7JHOqoVVZWhoKCApSWliI/P7+qi0NERERERFXEbGyQdKAnKikpQWlpafjvvLw81KtXL1W7P2ox0CMiIiIiIsB8bJDU0E21wsJCFBYWpnKXREREREREFKek19EjIiIiIiKi6iWpQC+eUZ+//vorfv3112QOR0RERERERCbEFegdOHAAd911F0488URkZ2fDZrOhefPm6Nu3L3788UfN1xw8eBC33norzjrrLIwbNy4lhSYiIiIiIiJ9pufo/fPPPzjxxBPh9XoxaNAgHHvsscjIyMDu3bsxY8YM9OjRA59//jn69+8ffs24ceMwfPhw+Hw+vPvuuxg8eHBa3gQRERERERFFmM66OXToUHz++edYu3YtGjZsqHhOlmX0798fv/zyC3bv3o0///wTt99+O3766SfceOONePnll3HMMcek5Q0cDZh1k4iIiIiIAPOxgemhm4sXL8aAAQOigjwAkCQJ99xzD/bs2YPrr78eJ510Ev755x/Mnz8fH330EYM8IiIiIiKiSmQ60Nu0aRNat26t+3zLli0BADNmzMCTTz6JVatW4fzzz0+6gERERERERBQf03P03G43MjMzdZ/PyMgAAIwfPx7XXHNN8iUjIiIiIiKihKR8Hb3c3NxU7zKspKQEw4cPR6dOndC4cWMUFRWhqKgIHTp0wNChQ7F3796Yr7/zzjvRunXr8GuLiorQrFkz9OzZE0uWLIl6zfLly9GnTx80a9YsvH2jRo3QtGlT9OzZEz///LNi+3HjxqFOnTqK/av/O+644+DxeFL62RAREREREYWY7tGraj6fD7169cLll1+OBQsWoF69epAkCQBQWlqK8ePH49xzz8Uff/yBnJwczX0MGzYMhYWFWLNmjSIg9fv9WLJkCQYOHIiffvoJTZo0ARBYGqJfv3547733cMEFF8BiicTFsixj4cKFuPbaa7F8+fLwPMTS0lLcf//9eOKJJ9L0SRARERERERlLeY9eukydOhWtWrXCyJEjUb9+/XCQBwAFBQW45557cMkll2DMmDG6+5g7dy5GjRoV1etosVjQtWtXXHfddZg+fbpi+4suuggXXnihIsgDAglozj//fFxwwQVYtGhRit4lERERERFR8uIK9MTgKpltErF69Wr06NHDcJvevXtj9erVus8PHz4c2dnZus83b94cxcXF4b+3bduGY4891vCYF110kW4PIhERERERUVWIa+jmI488gueee07zOa/XCwC46aabdIOptm3bYv78+XEWMWDnzp3o3Lmz4TZNmjTBjh07dJ8fNmyY4evXrFmD0047Lfy32+1GYWGh4WuYeIaIiIiIiKob04Hehx9+iO3btyd1sBYtWiT8Wp/PB6vVariNzWYLB5zxmjFjBubOnYtnn31W8bjL5cLDDz+MefPmYceOHQitL19QUIBTTz0VTzzxBI4//njFa37//Xdcf/31WLlyJUpKSgAEejobN26Mfv364b777jPsBXS5XHC5XOG/y8rKEnpPRERERER0dDId6A0aNCiNxag6hw4dwrBhw7Bo0SJMmzYNdevWVTz/xhtvYNSoURgxYgTy8vLCj5eXl2PmzJno06cPVq1ahYKCAgCBXsvJkydj+PDh+N///ocGDRpAkiTIsozdu3fj8ccfx7BhwwznEj733HN48skn0/OGiYiIiIio1qsxyVjUNmzYgDZt2mDjxo0JvV6WZUyZMgVdunRB3bp1sWLFCs2hob169cJNN92kCPIAIC8vDwMGDMAll1yCL7/8Mvz4pZdeil9++QVXXXUVjjnmmPCcRUmS0LRpU7z99tuYOnUq3G63btlGjBiB0tLS8H/ivEEiIiIiIqJYaszyCmrt2rXDli1bEnptcXExBg0aBFmWMWfOHHTs2FF32/bt2xvu68QTT8TmzZtNHzszMxOtWrXCtm3booZ8itsYLU5PRERERERkpMb06JmZf+f1emGzGceuy5YtQ7du3XDttddi3rx5hkEeAMMsnQCQk5ODI0eOGG6j9ZqKioq4XkNERERERGRWjQn0mjVrhj179hhus3v3bsOELyUlJejfvz8++eQTDBkyJOZSELm5uXA6nYbbOBwORWKV559/Hn///XfM18QKIImIiIiIiBJVYwK9Tp06Yd68eYbbzJs3D506ddJ9fvTo0RgwYAC6du1q6pht2rTBpk2bDLdZt24d2rRpE/77zz//xG+//aa7vcfjwfbt29GqVStTZSAiIiIiIopXjQn0rrzySuzcuRMjR47EgQMHwsscAIHlB9544w3Mnj0bQ4YM0d3H8uXL0bdvX9PHvPjii7Fo0SJ89dVX8Pl8iud8Ph9mzZqFadOmoV+/fuHH+/Xrh6eeegp//fVX1P5KS0tx33334eKLL+YcPCIiIiIiSpsak4zFarXi+++/x7PPPovu3bsrgr3CwkJ0794dixcvRm5uLgBgwYIFGDx4MFasWIH8/HwAwMGDB3H11VcbrsfXq1cvTJw4EUBgLt3s2bMxYsQIDBs2TLG2nd1uR+fOnTFjxgzUr18//Hj//v1RUlKCq666Cvv374ff7wcQyLpZp04dXHXVVVFr9REREREREaWSJItdY1QtlZWVoaCgAKWlpeGglYiIiIiIjj5mY4MaM3STiIiIiIiIzGGgR0REREREVMsw0CMiIiIiIqplGOgRERERERHVMgz0iIiIiIiIahkGekRERERERLUMAz0iIiIiIh17DzuqughJK3G64PR6q+z4sixj35HUfI77jjjg8HhR4nTF3tjAEbcH5S4PAOBAhRMenz8VxatWGOgREREREWl467d1KHrtUzz14+9VXZSEHXK4UPflyWj5xhdVVoZBMxaj0aufYs5fO5Paz7ytu9Ho1U+R88IE1H15csLBns/vR/5Lk5D/0kRsKylHg1emoMt705MqW3XEQI+IiIiISMOdc38BAIyswYHe0l37AQD7jjirrAwfr94MAHhq0aqk9vP8ktWKv5f/fSCh/VR4fPDLMgDgw9//AgCs+6c0qbJVRwz0iIiIiIhqKUmq6hJE+ILBVapISOzN+eTIMM1suzVVxal2GOgREREREdVSiQZD6eDzpzbQS5THFylHli0S6Hn9tWueHgM9IiIiIqKjgD/FPWpVfXxLgjGsRwjobJZIOHTY7Um2SNUKAz0iIiIiolpKjIWquscq5UM3ExyXKmbY9AmfSbmr6jKTpgMDPao0+444IMfxA/fLMg5UVN3EYUqtMpc76dTOhxyuWpn+uCo4vd5wWulSpxtuny+h/ciyjP1VOMG/Jkvms/P6/TjoSC61uBl+WcY/vA4TGTri9qDCU30DBDEY8moMnSx3eeCopPLHGrrpq6Rrm9ijt6PsSPjf5ezRI4rfZ2u3otGrn+KxBStNv+aKz+ahwStTsHJPYhmVqPoocbpQ8NIkdBk7I+F9/F1egXqjJ+OU9xPfB0U0/9/nyH9pInaUHkbhy5NwwjvTEtrP8Hm/oeGrU/D52m0pLd/RYNh3y9Dw1SmYun573K/tPeEb1B89GVsOlaehZBHXT12IY16Zgp937kvrcYhqKq/fj7wXJyL/xYlV3ltmhrqMDo8X+S9NRNFrn1bK8cUkKFp6Bq9tGw6Yy4CZ6OxDMdB79Ze14X8z0CNKQCg98bM//WH6NbM2BdZaeeu39WkpE1Wehdv3AgA2HixLeB9fB9feWbO/JBVFOqrJsox/KgItpqHf15aSxAKGl5f+CSAQtFB8Xl+2DkAgWI7Xwh2B39SkNVtSWia1z4IBfOh7JiKlfyqckBEYkljqdFd1cWJS9+htCt6Xy1wexRDGdInVo/dj8Nr2yR+bTe0v0aGbbp3RQaGRLrUFAz2qFMfkZCX82prQQkbG9qdg6Jc10RnXFEW80adqtgS/ncQlc25XVlqFqk7gQFRd1bSfhnr6gxgo6QU/qWQ26Waq5/Kp6U0DYY8eUQIa5GQm/NrqkoqXEicGeolWGK0SL1ep4hLm44m/r3jm0FLq1IRzm9dhIm3iL6O6/kzE4ZLqxnPxuu9KcK52omUxku7GJY9OJ8Jhd/Wda5mI6n93oVpB7NGLtzKZ7lYdSr99QsKJRCuMNqHXozKGl9RmYquteDPVmqRP6WeLs0fP5U1/ZUyNPXpE2sSeoeo6Akm8tquv8+Jf1alHz+wVJ9H6AHv0iFKofnakR+9AnNmUGOjVfGKPnl4rWizi8DZnFVR0axMxUBC/j2Rac/krTVy8QzfFikhl9cIy0CPSJl5DE72/pZvYwKouoxjcubyVMEfP5LXE7DUn0Tqi3nfFQI8oAeJc2TX7DsWsnIgTmvcdcVbZkLKDDlf42GbT/bp9vpRP5tU6ts/vR4kzdplcXp/mAqByjOUrfH5/yiaWi4Feoi2eVuEkcqQ40Iv1WYjbHdI5D2RZjisltHhuxdouFUqcrvBnL97YxaA5VmvuIYcrfPM9UFG5v8sSZ2BpjXX/lCS8FESqJfrd+FXnSmix3nKXR/HexG2OuD3h5UnE60syv4V4ym+20pXoeXHQ4Yrr2hnv760mUL+fEqcrpaMXKuvzSvd3I+7f6w9cE1Kx7I7XxD1V672JAUNo9Io/xr1C/Zx6n+K1VovW/d/oMxdH1ajvweI1J/Rvcf8Ojze8dESp0w2Pz6/73rSoy/VPhTPqvWl9rj6/ufMo0VFCeoHetpLDmo9vOliGtftLalyyFgZ6VCk8vsgPsceEb3DLzJ90t91zuAKFL08K/71g+x7c/vXPaS2fll927Uf90ZMxcNqPGLN8A+qPnoxXTGSe6zJ2BvJfmpiyIOnjP/5C/dGTMWqxMmPp1V8uQOPXPsMuYf0XLce+9SXyXpyII6pg7/GFK9HglSmYvmGH5uvOHv81Cl+ehJ0x9m+G8iaT2EVZfFmqe/RCn8Vna7cabnfd1IWoN3oyft39T9RzQ+f8jPqjJ2P+1r9jHm/mxmLUHz0Z//3WOFPlG7+uQ/3Rk/G/ZWsNt4tl72EH6r48GeeO/xoA4BZucEeE+QhGAdTa/SWoN3oyLv90Hj5fuw0NXpmiWC4lnclYNh8sQ92XJyPjuY/R4d1pOO+jOWk8mjkvLFmN+qMn44OVG+N+7YCpC1F/9OTw3zaLhAqPF23e+gJdg+/tmUWrUH/0ZHzyx2a4vD7kvzQJRa9+ClmWFS3OibY+P/rDCtQfPRmTTWbtNPOznbZhOxq8MgUjF/4eV1mWFO9D/dGTkfncJ8h/aSLKXLGvnfd9/yvqj56MmRuL4zpWdTVh9WbUHz0ZzyxaBQDYeqgcdV+ejN4Tv03J/sev2oT6oyfjuTgyXyfq9q8D18Lvt+xOy/6HzF6C+qMnY8G2v9F3yvfo8O40XDT5u6T3e9mn81D35cnYrlPRB4A75ixF/dGT8e3mXeHHxCDz9A9n4fO123Dx5O9QT2eJgGu+XKC4j7y7fD3qj56M134J1C9W7T2IeqMno9/n83XLcdHk71D35cnYHMyY+eSPv6P+6MmYsDo6U+Vrv/yJIV8vCf+tvgeLvXihe8P5n8xF3ZcnY+uhctQbPRn1R0/GtpJyFL48CRnPfYx6oydjrYkM2KH39vLPayLH8PnRX/Xehs/7DfVHT8ZXwlIzry1bi/qjJ+OHbcb31IR79Hzar3t3xYZwJlLRf+YsRccx0zBNp85UXTHQo0qhbjkZ/8dfutvO3Lgz6rGxCVSmkvXy0sCFafKfW3H7nECged/3v8Z83frghX1JitadCgXFjyxYoXj8p+J9cHp9+MtgHS1ZlrGrvAIA8Me+Q4rnngkGjvd8+4vma0M3oa8SWONLrUxoAUu05VU8h1Ldoxf6LELLgOgJpZp/9ZfogH/MisA5+vjC2GtFhtLp/+/XdYbb3f1NoDz3xAgIYwktTbEs+J2KQzdLhUq10bCdd1dsAADM/msn7vxmKYD4lktJxkeqNNvLNALtyvbQ/OUAgMGzl8TYMtqnqjUHrZKE7aWH8U+FC8v/PgBZlvFY8Dy67esl2F56GH5ZRqnLA4/frwz0EmxdDn13d35jfM6HmOnRC/1+nl68Kq6yPLdEeR79tjv22qmhda8SWZqiOvr3rMB1PvS9fxyssC/Yvicl+785eB95+IcVMbZMXuh+/cSPv6dl/+//vgkAMPLH3/FtMJicv+3vpEcYzA0Gbx8Z1E9C18HHf4xc59X1m3u+/SVcrg+DZRV9Gbynhu4jQ+cErqfDvgvUL94M3hdmGDRifB9sUAzVpUKf9dA50Y3iof2GRPXo+SP3g9C9YXFxoP7y9vL1cHp9cHp9+ED1Xt4zUS8LvbcHVL/T6ar3Flq+5b7voutYsc6jRAO9WA2baqHrbl6mLaHjVRUGelQp4qncV5e5IJlWa9yvqawkCW6fLzwc0mgopHgB1Ptc62YZZ0RNxfchVkwTHbrp0RluWBWkJPuv5Eqe0dZASIZ02O1RDNEsEQI9t8nvJsNSubeO6nJNSBerJIUDNr8sh4dJAYBFkhTv3+PzK7LCJTufxOyZbOY7qJuVkVAZsm3KilOG9eirmqiHTdeGcz7B5c1Mc3p9yBTOlbIUDakz85uyCZlyE/3u9DaLZ9SLS3Vsq4kP3WPUo+dTD+uM/G1TXfctafiCtXYZ6/NM9dBNAHB4ozNvhgO9DHtCx6sqR9/VlKqE2QokUH2Sr2TZ4g/0FEkSUlkYlT2HHeF/G13kxMBTb7tYlbNUJGJUBnqJtr4JPXqe2pX+ON3EivPfhx2KpCulzsh3Y7ahIjOB30YytM6Y6prdLhFWi0XxGxEDOYskRWXFS8XQzRCjuprYQ2Lmuhyr0UiP+lobT6BX2Y0mlYXLWcTm8PoUwcfuwxUJ70s8100FekICJXVDtqzz76hj6jwbTx1Ifc22mmiEi56jJybkUj4njp5RB1zpWNpWqxE11ueRaKOI3tBNAHB4ou+FocY4BnpEGmpij15CgZ6YJCGNwcju8sgNzWvwef1/e+cdZkWRtfH3hsl5SBMZZoYchhwUkCAggmQUARVWF11XxbCugc8cWcGIrnmNgAqCARUDgjms6BIEyQjDMGQmp3tvf3/c6Z7qutXphkmc3/P4yNxO1d3VVXXqnHqPlow+u8A/KUp/cBboQMrl8ag8cH579EIYummVQDu4QD2CVmHrQUFJuepvNnTTrLR2fXtcRCFZ9SEDXl847TZNL53dpv52azweVTsTuEdPuy6aiQhgSYqqmzSyIiISxbW1lOaj8fSDgRAKjw9Lpcut6hfYftEqrBe9pMq47w5j2kDeM2T21WntZsXI59tBMx49nzV6AjEWGXYNN18nbY3Foxdk1U0AqBSEdcptbSwZegThixXJ4cbSwflj6JXWBC+kSo8CxqOnZzixDTjbuLPiKHHh+vHmgb4OXvHTX/lp9rgGD90MdUxSkGHrQUFJufYaPZNqlv6ENQeCqAo2RC65UOHkPHpqQ8+mGszV8B49E4NSPfSqcpVqNt/4XPHMAOh4uXlVvqgwdX2qj6TNjR1PM/BUhrqVrKhxqSaRDzP9olXYiZYiE2JArCfRx9Az+e60+lazCcUBgaFnYhaSn3jX8+iVMyGMvAEaGo+eL0Ztj9+hmzqThbxHjxXBIo8eccYhy56LJPxltD6o/OIy0xLBZVzuKPk4V+0Mt54s8unKKlS6XNh9stiwrDKRfgxm1TPt1gZgcvklScKek8VCj6B834eZEBW+kSupqhHK6JfVuBQ1OzbEpdqtLynNGt78fqcrfVMESJKEospqZRs/EJUNTjfnmWDfqQi2DlW4XD7XLq2uEdYzMykorFJcVa258L+oqtryZAVbxooal9CIET0f/llrnZOtB5uOnlQEgwD1AEfez+XxYOeJIrg9HpTXuFDtdqtUZM169Ioq655FQUm5ZgoLo3cvep5yWUXPRJb+Nnr38r3xZfWX05XeFAGlGm2VFmXVNarBJftd8IZeucutCt3WmlAqr61HVmTQAe+Mfll1DQ4WlanSovDPpqy6xmf2X+VdqW1jiquqVd49+fxAXVvFiwDJ9yt6dvzfxVU1StlOV1ahyuVW2k69a8vtxW6NtjYYHC4px3ETaVtEmBm7yt8/SzDaO7N9pIiyanUfqPVNFQfYTgLePo09A+vRK66qhsvj8VFw1erD2O+osMzYYFSHbqrvQ+vdmX037KSsPLapqHEp6VXYezpQXIqjTHkralyqOi/qE+XxwamKKhRXVavWo1W73aq+hPXoneTKb4NN9U1pXccKovZMrifs2IZFz6Pn217U1Tuza/ROV1bhREWV8l5IjIU4o/gh/6giex73iHZKAdEH9frm3ch8agVSn3hHkfD/1/dbcO83YsW22EeWKp3PvI++R9Li5fjp0DEM+M8axC9aiqTFy/Gv77f4HPf+jgNIWrwcUQvfRId/r1LKajQA8mcdkr9qeK/8bxeSFi/Hcxv/wD/X/YL2/16FLs+t9mnUbvtyI5IWL8cbjIQy2ykcKi5D/KKlGLf8CwDqAf7kFV8i9Yl3UFBSjoKSuo5h+e/7kLS4TtqZRz77nRt+RdLi5Xhvh1cx7LM9h5C0eLmPmtas1V8jcfEyJC1ejivWfOfTcMv3NPi1jxG/aKnSSd33zSYkLV6ONbvESmNsHfp872EkLV6upN04XVmFuEeWoteLH6iOeXWT97kuYqSdg8H7Ow/iLx9+K9y29dhpzFi1wfS5nvx5G5IWL8frm3ej2u1GyhNvI/vplZAkSTWYuPqTH5C0eDm+P1in5nrRqg3Ks75m7Y/K7x/uPIikxctxR63CHjsg/9f3WzVVPOX6MurNT9Hp2dU4f/kXSFq8DBEPv6GoAALmRBa2HTuNxMXLMPeDb/H+jgNIf/IdpDzxtlDN7G8fe+/tmwNHhOcSevTcbjz07WYkLV6Ot36vSxFw91f/Q/KjyzF95XokLV6OlzSU4SpqXEhctAztn1mFnSeKkLh4GSa9s874xjT4sbYtjHj4DcQ9slSZsJr/6U9IWuyVgtfiqwNHVIqvvEePNfw7/nsVHmbaOdHAqMrlRvLiZYhc+AaSH12OtXt8lYxl+FfZ/plViH1kKdouWYHsp99VfmfboooaF1o8uhwd/71KdSzraS8oKcfBojIkLFqGc9/8FIDXMGm3ZCWylqxEQUk54hctRdhDrytKhkr5a+vrVVy9eHPLHiQtXo6FjNrr4dIKjFv+OT7Y6W3n5XsuKClH8uLlOOf1tcq+nf69GnGPLEVBSTniHlmK8IdfR4d/r0LX594L+prPj3YdRNqT7yDl8bexlVM8NgNrBGkZRBev/gqJi5dhS+35X/5tJ5IWL8cL3PO0ysg31yJp8TJTuUVZymtciF9Ulxrp18ITwhQBB4pKVfXCDP/+5Q8kLV6OZ36pUyrm6748ubDnZDESFi1D2EOvI2HRMuw/7VWmvr+2j3n7d28anfX7vf3I9Z/9rDqXmRDQMD2PnuB9LfphK5IWL8drm+oUPc2s0ZPHNtH/ehPtlqzEvlMlSGCe8Rf7DiP1iXeUv4uqajDwlY+Uv7s8t9rn/C5JwuIftiL50eVIWLRM1fZUuz0+E8QysrK0jA3ebyrzqRWKEcqS98L7wvvT40iZb53z1Oa5zXjqHYx/6wuf7VoevTc271H1/7tr68XYZd5UHHrh/3JbJvfPrR57S9lGoZvEGcUDXG63bw+KB2oiQ0+W7690uZVcM7JkuRa/HvbKbssyvw98uwm/FZ5UtouOZwfALOsNZKv9md33VyTh8lpp7as/+RE/HToGAPizqMzHu/lIbYP106E6eXl2gCIbgJ/v80o78yFQ5TUu/FZ4AqcEM4u8BLOM/Bz4FARyqolHudyCbzG56F7ZtNvnOciKX/I9fLTLOwiVJZTnacjVszOT/974B4A6GW9Zgnzb8dOqY2RJ8VBIsPOS/ywrt5tPSSHn0pvzwbf4s6gMxVU1OFxagbIalyo8SO5k7/3mf8LrPLuxbnB3HZf+gPWYxIRpz0bK9eWr2oH15/sKhJ2hGW/DIz94jZE3tuzBd7WpRlweCVuP+Q565fd4r4aMttYaPTnlyF/X1NUZWdpfljDXqk9bj51GjceDg8VlSn1as0vbIDKCTzUhS7U//Yv33LdbkLXn1+jpDUhE3qi9p0tUIVh//0TcBgLqMGRX7fMQXocx4n4/dhpVbg/+LCpTG4DMPqcqq7G81gCX69PpymocLq3AiYoqTQMcqLvfF7l6MfcD7+QK/yw/3VugpCIBoEjBuyVJleZmf1EpJHjzU7LsLyoNaH2XCLlfcksS/nfkpMHedcjr2tj+R0sGXk738mRtnk051cdVAead/fbgUbg8Ej7abe172HbstE+/KUoRsLzW0LKSOkLux1mjhF9rdqrCO9HMpwGQ2+q7mJQlQN14Ycl/t6smZktNROOwbTP/fkRrTOU+aC4zQagZuqnRwB4pq8Tzv/ka8fwz33i4Lj3JHkH6JZfH4zNBK1Pl4g097XFMWY0L+4tKcaqyWnid7cd9cwj6g0eSsOXoKRRX1ajGezJaoa6XffANgLpn/0qtkS2Pj/Q9et53yue6DXfYfdRHGztNq7REo4NvYLQGgOKQujrvn9l1W/z1zMgph2l8lFq/y/gj9hAMkQR2Bq3a7TH0nrCzf0e5GVjRPRSUVFgqm5bBa1Ywgfds8jPnYVwY4AmNtT26C6eDtF7L36V3geZvkmFDbkqra1QePSvwdVtWvb2oazu8OXmo5nFm67yZSRA2dJkdRIvUzGS0xBu0PHqBwA7O9MpkFv5zOMqFf1lpT9hwZ7vNpnuvVW6Pz/vgByKnNCItALVHTy9cj/3G2G+WDe1i9ymprvF5n2zIuF4N4kOX5fvTC9HiJeMTGTXhkqoa1bclqr/BNvRYo9dKGKS8Npwto15+y2DDXtdqH8a35VqESqRFLi9fT7T6B76+yujlV5PRC93U+15Fd87/plfPrbQjWktm9NamVbvdqvKX6Ri9bIirGREYf/FIdboEoncTijV6WnWmKYqAkaFHBAT/gWkNAEWDdHb9h57MLQu/11GBm59Ha7BsNIj2RzTE39BNVnWOPc6M4ARrOB3jnofo+ILScsOyse9RO9ePuefjG7opqRpr/j1oPff6MPT0EBlzorWQVmHvX6286BJORpjpTvmBvlwPIhwO3YXkVS63qfdqxjBi65jK0BOE+MhofZKiOhhoh6sVnuQvfNt3jJuwkOu8GTVKPTEWEXz95wddp/UMPWZfPWEX1nBh2322rOw+JVUCQ48JGderB/z9mukd+HrLPoOC0nKVh1M0kC4IQMhDBHt/VtZry4Ye+4zN1nWjyUszsAN7K30YYH7tbihEPIC6uqinKqn1O1uP+UkDEXpiLHrvi/3e5Kvw34leG2Gl3dPqF/Umaau40M1iHWP/MPM9h7IP9kiS0odUuT0+SsFm7Ty+D9f16AVh8q+xQIYeERC+Hj3xFydqnFjvk5kZNMB3wHfMxBoCs7OMPFZSQsiocmFZGDzGRdQNvlUziyYGhWyjzT8P0XM/XFpuGJrCDpq02lCzhrBP6KZbLcJiNgxCN3yN6WSsetfM7i+63yO1g8NAOrnWMVHKv/mJAn9DRHjjWX524Q67rqFX7faYuheRKh3/FEuZkB9WDU/v/Foz/XpiLECdJ1ZLFEAEO8gLRroOX0NP/C2aGaixHiCHH4aeFblx9onreXDYa2h5Qtgw0tJql8+A3qxn18fQM3E//OCVLePhknJVH1MfHr1KzujVg21v5QTgrGFq5L2WHzPbj/gL+z71PMEitLw6/PsLvUdPXX9MefSYSQ6PJBlGLajW6Ol8n773Xvdv+Rq8UqaeIWbF0NOaTNE7R7XbrfpW5HBYEaxHz5821GwKFo8kKX1Itdvjs7bRikopi67qps5EVFODDD0iIPjGUGuAIfqgWO+TWaOB/8BPmFCU0xosGzVM9enRiw2r66BPVqjzmhmNcdiZ30BDN8sEM6KBhm7yRqXL4+HCZLxlNJqNNiuFbDWnDnsfeocKn2Vt5yPqFMzK/7eKrstjyK/xFE1SyEXUmxzhj5P3jXA4dAeD1W6PqZlMUcg0/72w9X9/Uanyb73vTksaXCRaUKUy7r3/tyKvztbLYKgu8tENfOimPFg3E3LqI8ZicAxffiuTVGYNPfYaKm8V8555A5BN3uz2eFRqwXoGP3+/Zr5o/p5V4hqlFT4pKngCkeYXwX5HRiGQrGEve/QquBB+PeTnw6bK8Vdchi2r1Wei1fby75M19KzkWzRCNtb4b1Er9JU1pkUTknqoQjd17oHfJspb6ePR0+mIrKSV0WrL9VRFq90e1XPRuzdW/Ze/lpn3amXJjjwR45Ekn3djts/n0yKJri9HV1Uy6r1NHTL0CL85UruonkUk9S9JkvCDOsqFbsrKWHp4JOMOjJ+5NZrNk6XyT1dWobB2ICJJkmaaBxl53YfcSVe6XKr1ZcXV1cogqNrtxq6Txcr5ZU6UV+JoWQUinOIwED4UU4SLmc1iFyqXVNUIB4gFpeWaA48dJ4prn0WdsSlJkrBz8dejd7KyShXKJA+IWzIGT35xGYoqve9FlpLWup4kSThaXtfh7DpZLFQAkzsHuU7K8EaaNyWEuszFVdXiMNiSchRXVQvrWAlTL6rdbhRXVaO0usbHcGY9bIcYr0JJdQ2cgpnv4tryiyYS5PviJzeO19ZlI4/esfJK1bPUQkvpEfAK/hwoKlUZg+zzOVRSjqNlFSiqrMauk8XYdbJY2VZW7VLuwftcvc9ONKdwvMJXNlvLK8NLrANqA6Wc69Dl973vVIlpjy//XjcdUYvOHC+vgtvjUU3kaMG2q2ZCN/kJHlEb6fJ4sOdksc82dvBzSMerVemqk13n3yfgHdix76SkukZlwFS5PapnomfoVbrc2MPUCzNrQvn7Yu/FmzuybrsolFWuO6K6wlLlcqPK5Ybb49H1ILP392dRKXadLFbtL1/nVEUVthw9rfwuGwJGES+lqnN52wQ296vcNp2qqFJ9Y1rI5dEKua5xe5SBb1l1ncw9m2pGa63Ub4UnsetksdKnsuGhfN42d2099ccAlJ8J74nUatO0PNOAcf/mrvX6lVbX6O7L55Nk95UkCS6PbxSF3pozs2uTvf2iePxwgJl44zlWXmnaa8g+MznBuNxnm2nnatyS0s7r4V2jx4b/6z8vvo8HfL+h0uoaYa5PWVGzwuXGAQ1hqqZG00oGQTQa1uw6iAlv+0qRs43Q1qOn0OOF93F5zw7CmHe2Mbnh858NDSvA20gaecr6vPQhtlw5CTabDeOWf67ZyVXUuPDdwSMY8tonmNQxE5/sOYRqtwcrpg3HJ7sPKcpgInacKELnZ+tkiwuuvwgDX/lIpVj306HjiF+0FHuvmYaJ76zD1lpZ+fcuHIlJndpi4+HjGPTKR3B7tNOrjl72me69AnUeqce59Ajxi5biweF9fPY/XFqB7MRY4bn6vvwhJnbMVCmlVbs96Pb8e5rXNYJ/XzNXf41F5/ZT/r7x8//C5ZGQEBGuzCBnPrUCUU4Hzm+fgVV//Ikf5o7TXMf5741/4F/f16VP6Prce8hOjMXOv09V7Zfz9Ep8O2ccOj+3Ghd1aYfXJnlFSdiZSAkSZqz6Ciu278eOq6egY4sEPPXzNlz/2c9YOLKvz7Uf/n4zJq/4Etf26yy878TIcGQ8uUI1cB+dnaba71smXcIOJr+dVujmj4eO4W8f/4DbB/fw2VZe40JMeJhqtnnhd5vxTK3yY4RT39D7vw2/KkqWVvGGfbqQ+8y7qplenmd++UMpD8/6Pwsx+72vMbVzFi58dwMAoG18DMbmpvvsO23leuXfZTUuJCxahn6pLYTnTVi0DA+P6IPbBucpv7GDlHJm4PD+jgOYzEjCX9uvM5aMHaR5PzK8MbK/qBSvbqpT/yurccH50OuG5wHUYZ92m/Hgrs9LH+LHv4zHwPRWAMTfZljttYdmtsHXc8732f79waOqZ8ojwVuOSKdTNdCaunI9vpszDg99t1llQPHKh5/vLVAp8up5dm/9ciNuZRSUzdja/D2/yKh6FpSqQzdFIYkFpeV4ffNuzPngWzw2uj9uHNhNcA0P0p58B067DW1iorD3VAkO3zBD6CVnJ5BW7ziA1TsOoGV0BPZdOx0/5h/D6GWfYVa3HKz8Y7/a2+jx4KFvN+OzvQXKb7wxdLy8UiX3vmL7fqR8FqUyoLKWrPQpkxYf7DyASe98iXvP6YWhbduonolMl+dWI7+4DHuvnY70J99B75RkvDphCHq++AEu79kBL08YrOlZOfvVjwF4vWCTOrZVFHEBbz8czSgBT3h7HT7Zcwhjc9PxyczRwvPZbTah8V9SXYM71v+KpVv3qn5fsysfD3OquICBoWdg7Lg8Hpz75qfY8Gch5vfvornf0q17kREfLdwmARjwnzWq39weT1DEWL4+cATD31gr3KZnwCz+8XekxorLq4c8CXDFmu8UdUsjlv++15RCrNsjqSYd+DXV7PPacvQU8l54HzO7Zav2yX36XVzaI1f5O+6RpcJrxYY7cazcWzf4d9NUIY8e4Rda+a7YhvPBWjn+/2zaZdhomjHyAO+sjFEYzO/HTiuN4adMZ+lTVrcbd2zwyi2/v/OgcszGwyfwn027NI8D4JOv75VNuzVlyR//eZti5AHe3EIA8Ovhk3DpGHlmkWezvha8k8cEufEKSyt0xRl4Oez8knJNiWYziN4XL+38z3W/+HRuFS43VtUOCO7++n+as6as3LbMvtOlOFSs9k7kl5Rj89FTqHS58VPBMeV3ts5WuTxYsX0/ACjGiJxzTpS6Q04R8bTAcCmtcaFQ4PWWpZ1F+Hj0NEIZX/htp3Cdpfysnba6pp2Vog+3OxAbHpr5vSq3BweLy3WNPB7RWp3lv+/DZe9/o/x9oLjM9FqhXxhZcR5ekp+tl+wA+a8ffafab51O/jsW0bzHRp3y6MGLTJkZ3LGpKfS+zW+4FDjyGzBj4MsRC3yY1o2f/2woxc+mOQCsKVF6TLSSel6VwyUVKmOJT/zsLY8Lc2rTN9ykkWqmsLQCJyuqcLSsEluOnkJZjUtJh8MjMmSPl1dh3+lSXFkr77/s972odntU33m12+3zLvj3/7HgWS/573ZL68JZrqxNy3D31/8TLj+QJAl7TnlTdsgTir8VnlTyk8n9pZ4nym6zweWRVEYeoG5/JUnCJ7VpSeT0JCLCNNrFkuoanzQnMgsE6U3Ya/PRM0bfnMsjKekhlv2+V3dfdiKSh08XUOly66454+vVVX06CttRvVRVWsrWMnLqJCvIz9KskQeYTwPikSSVWBIfgcHWu0d/9D5rfqI+v6TcVD8ipx86Xl4pXKKwctpwU2VuTJChR/iFVogU2wixA1x/1ruJqHZ7DA09wJwsdEWNGy2iInx+NyeWoG5o9ARfeCNWPr+/6Rd45EGd6J2IwqM8koS9p7RDN3i0DFiz64DM3qfemjObhevJFJT6Pg9ZRIQNHWVn3tl/m/VYalFSVWNKIZOFHeB7DT3teiV6rvJ9aa11C3fYVeumgomHC/k1w4isFOHvPik3TE4EWYH9htmBA//ezQg+AcaCMTzJURH45YoLhNuOqcL2PKbW5bDPzKi9Zb8leYyYxKQj0KIgAPEhXsCnyMIa5kCzl/h49ARhZWb6KJHxlizoQwDtZ1RSVePTf8zqloPfr5pcWw799agAVCGa/Ln9ga2n7DlkMTB2Eo59Ti2i1feu54m6sEuW8PcKDa9ahE6fyn+jct0NpM3m+wvDb4jZ7o9wGyBeb1fhcuveB2t8OGw2PDfubOHknZ7ejfycz89Nx1kZrXy2+yOWY1aMxWGzWVaHPVZeqWqjfUI3TTYQojEBAAxjvNhy6Obe075jpNndczCtSztT12pMkKFH+IXWIu1KLUMvSLlHqlweU8lMzXR4lS6xoacXJiU3gPwgW69Z5A09+fzBM/S8jZzonWgNNvaaWA8p86dGPL9axMT7b61wGjPw4Uk8VicLRM+jSLAOhX1G7D35K2YgU1JdYzkFADvAL6mq0e+sBXVc/k3re4vQGCAGixMV5owimQ7J8cLfeQPX6nnNoA7d1Ba+OF5e5TMJIVq3J/I66bUlEQ675oCHNfirPR5T9Yh9ZkYDXvbe5TVhWgYLizyZ5I8iXVGlur6KlFu1nkegcQ8FJer0CqcEHj0zys8icQatsmkNfEuqa3zaxLS4aMVQF327/PuPcIi/Y7MDXr6d1hIlkQ0RtkxsWVpERSr/rnF7dNfVdWqRIPxdpY7KtNnhGvcI+N6nmbprBJv6AzATuskav/7VT1HqgkqXW9czyn438nsUGf4i0RcZ+R1HhTlVQnAyZtNksJid/HFLkmUldD5Uk8/tZ2YNL6A9bmWfn2w0815Dfr+mBBl6hF9ozYywHSE7OAtWkslqt9uUEWfKo6dh6OmVVZZdtjJzyocJBdujJy8KPyx4J1YVKEVoevSYTl1u5EWDJbPPyqiOWK1DIg+nPNgsra5brK01IAvUC11SXaOZHkPLAFB79Fy6xqbYo1crAKNxfn86cCuIFrfrkR4nXgvCh2ZZPa8ZtMRYRIP5I6VqQ1NUN6x69MIdds0BDzuwqXK5NSdB2Pyb7DMzmqRg792KR09uY/hBnZlWhjfsRN7f6DDxQCpA5zoKSitU3hNRCJeZXK6iSUYto1rTo1dd47MtNTZKeX+iusW3F6x4lwg9bxjg206zf7PRDqKUIKwBxNa/wtIK3feUGhsl/J1tf9k228pEW4TDoVrn5w98/2nU/ruC4NEThQZWuNy6/XYRK5RW+/9wwQSJXq5CuR5HOcUqzP70E1bSK2iF3ppFL3RTD61INHaSLJZbw87W8Sgy9IgzCa0Phh1ghiJ0syqIoZuVLrcwxI0Pp+BzA1W73T4zcXr3x6tPyefnDaAop8MwiTuLPPPk8nhwvLwy4FBDLUTn5T0aciMvkrE244H1HhvcdBdCQ692sCmhbjCtJUEdjNBNrYG+Vv1kv5nS6hrdMohC3+R1T1r3ZDQADBSrIZZpGoZeoOc1gzr/GyvI4ws/sSV6r6LBhp6XOsLhEA7QeKrdHk1vUxIzUaWXwJlH5NEzU9tlrwc/qDOzLpOvr6JBboyGUJDV3Jg85TUuVR0SvT8z7Yvou9Ua5PMTBko0iOC+0+KiFQ9Wjdvj853y5dVrmmLCnEgwMNr587HtDFs+uf6yz4Y9lp2QOFxarmugaH3rlRqGnpX2PsxhU6WWEJFo8Exk41/u740NPXE4qxVE34CxR8/3GJH3Uy/8Uq7HkU6H8LlZSeEgYyUVgb+5jWX4emY6dFNj3MpOQsVyEwa5SXHKv8mjRzR7ymtc2HuqBPtPl2iurzhWxg5Ug5+D5GBxmancPmYGHn8WlQo9BfzMc+uYSNXfZdUu/HG8SPXbEZ28NHJZ5LCkU5XVOFzim+IgJtypq4jI0zbeq5zpYhSpWkVH6h0SFMpqXD5lP15eCUmShAMoORzR6N748AwWCeJwKz3yBY0629B718rUaHq/rK434ymprtEUGTLj5TxdVa07YcGLW8jXLCwt11xXphcOFQz00oGIZolbx0QKkyzzkyNW14TpzUjLxjD7bI0GCpuOnIRHklBW+063c98/nxtS5rjO+j49jx5LWY1LlYeQhR2khdntKCgpR1l1jWHdZdsrm81rSOmVVWbzUa9wBF+/8k3IkPPtquh5xWh4ZUqZtBv+sk+w5oZFNLiV64r87kVRE6xn52BRmSIVzxvDnVp4w5RF4XppsdFK/+CWJB8vS1FVNQ7VPuPS6hpdD1JcRJih56G0Nlpg76kSHOH6SjYCxVMrlc9ej02hwfazBaXluqkp0jSUHP84XgRXbZoiVnDD5ZEg1aYvMPLuhdn11YQBIDGiztArr3EL33ek04FWtf393lOlqHa7NcNRzQrI6SFKZ2J0v6LvRuTh1ZsyltvTKKdD+NyMllHondMMVtfoGeGqTXXirS/64wgRrIc/hjN8cxhDL8rZNBMVNM1SEw3CV38WYtxbX+ju859NuzAsqw12njDO2+MPCzm1Sy2mv7sB31zmKyHOwqt/yfDeg8z4GJVx2ZKRtZZ58uftmteRG+bsxFjsPFmMd//4U3htSfJey6zCYGZ8NLYdPw235FHKlx4XjdOV1UHzoIo4XVmNhEXLVL91enY1Lu2Ri4dG+KZz2Fmb3iIpMtzvcNXPdNRTtXhjyx6f395kZLdX7fgT1679Cb3aJAuP/3DXQdzz1W+Wr8teX1bs5DHTkb6zbb/udl6+HvAqhc5c/bXmMaH26Gkp3gFA6+hIH+M72umE026DmwubC7T+tkuIVeqdjN1mU1JlvH/RSEt18aqPf9BViAvTSJsgUsKVCXc4TA94Vm4Xt1Xs8a9u3o1XN5tTvBu1VJ225bL3v1F9G1q8v/MgrvjwOx9VYlOhmxYU73j+OFGEqz8xp9CnhZaxLMNLzt/z1W944NvN+Oqysbjvm02abZDs2blrw2+4/9tNaBsfg13XTPUZ+LZPisf240XYLzA40+KiEOaoG5rzE5CyGuhferbH0q17ES8It5OJCw8zDCXs+eL7yEmMw88Fx3228alPEhYtwxezxyh/s4qfz/26Q/n3w99tEZ4P8L5XLY/elR9/r6iQDslsrdr2Q/4xDH7tY917AbweIlEIIgv7/ms8HgwRnDc1Nkrxpk18Zx06JMcjTSPk9EcNtVUriMK9xyz7DG1ixNfUQjSxZUZQJdJpvg0ywlroZnD7oQe+3YxHf/wd49pnaI7rzMKHbuYkkkePOIMQzbyLmPPBtyr5+obihs/Vg2yn3YYnxgwwPI439Ob374I+KeL8XCKe0ci51U4jd118RBjiI8JwXf8ueHPyOeioIVDBMjwrBV1bJQJQe/TS4qI1wz/T4qJxUdd2qt/+3rcz4iPCLHkStXhjyx5DlcHGhJyW4X9HTmruc+83m/w+v57Uvz+I1pPysDn5RMgevdcnDkXrmEg47TakxkbhyTEDTNU7nrMzWhuGRMm0Yjzj8RFhGJrZBkPbtgk4jEfEqOw05LVOUg12PJKkGN4zVn2lij5oCCKc5jx6egTj2dltNk0jr2V0BFpGR6jaTaPUM1f27ij83YzKpt46K1nK3l/MeCxZ7v1mE9yShOs+/Ul3oslVK4W//k9vGo4DxWU4Xl6lDHx7tE7CtM5ZyEnytv/5Jb7ez5TYKFOD31c27Ua126O7ZnVCh0yf33gD+nh5laZRJuKxn7YZ7qN3vk9njfar/Zr/mW/qHBHhdjtaRlmLZhG1z+PaZ6i+qV0ni/GVzmRNKKhyeUyvOZMRifOYCWeMcjpxQYdMpMdFB2x8eUNOzU3QhWKteIXL7beRd885vZR/Z8RF47ycNMSGO9EuIRbTOtepxYZ6jXuoaJqlJhqEMbnpuGFAV8P9bNBeIxRqWBU/vvHbe810XD+gK54fd5bPcQ+N6IM3ahNo851oUlQENv51gqnrt0+Kw98FybMBr5dBxPIpw1D0z9m4+5xe6NE6CTv+PhVz8uoSe/761wkY1z5D+XvJeQOx/tKxiKy9P5fHo4S8pMVGCSX5bx7UDYeuvwjjcuvOE+Gw45nzB6Hon7Px1HnGBrAZ9FQGEwxmXBuac9ulBnyOBYPzcMeQPOMdLbLtb5Nx/B8zId0xVyWlvWbGuZbOI3dUl+bl4siNF6NmwRwU3DAD8wd0xY6/T4V0x1zd45ecN1D19yczR+HUzbOw+cpJhtduzYQVL518Dr6ecz7CHHbdFBL+0iYmEpuunAT3/81BzYLLfLZXutyaglIs57Rtg51/nxqUMkl3zFUlfg+3a6tumiUUz46dJvrv5Rfg2E0zcf2ArnhwuK+3/pFz+6FLyzo1xRZREXhO0L4C5tZNa3n0ACC/2Ph96eHvUgKjvkwWcWGjPmrcHmXN0qczR2Pl9BHKZBof3pwcFYFIp1NotGeYXMPKsnhUP5/fzBhZelhZf8Xz7PmDMDizDSL88B7x+SS1CHPYNcVerPDg8D5B9zZZpcbjEYZuDs1sI9jbi8jQ01sKIRPpdODszNbIv/4iVC+4DOsvOc9aYVHnnatwuUyHb4Zics9fnhwzQLUOL8xhx9pZY1ByyyXYd9109E6pi/jxI+tEo6DxPG2iSWBGLKRFdITmuqdQ05LJ68O72eW/Re73cIddaSx5j56Vhl9vDZSWR0/kTWPPE8UtmJbLLwvJuBmPXmqs2KMn3xsb3qL6t58ePd541VujFcUN4sx6iEMFf3Ut+W8rpMZGBcU7ysMO6NkBq1lvmoyRWp8RfPiVXK/MhLSw60fZZxSKgRWbRsJptwvXLJkZlGiJFfgLOyMc4XToDnjMhNkGum4N8G3vWCEPdgCZFuc7kI5yOlRrr6KcDthsNr9DhPn1MSxmBq56+Bs2LlqXx+LyeCBJkmr9b7nLpYSzRtUqicp1/ijnWZRDA0XfgVE4ogiboF3l891ZpdyPdBoybB0S5XvT46jO2neWMLvdtLCTHpEG32R9IQrtT4jUrgsiTxOfgkBEFKdy6099k8OIK11u0+Gb/uTpA0IzZgjnJhv5azTVcE2Whq/RRJPCzKCsRVREg3n02E6FH2zIjZpoQW2Ew6E0lnzcvBUpYHadBU+WhkdPNJBkyx7JLZiWB61y4+TySIp3Ii0uStiIyvfGKkqx5+Tj0s3Cdwx662D4wbZVIyXY8DnlZLGEQEiLi/arszRCqw5a7YQCNar4WXN5UKQl/sCWujWz7oSte1rJ3QOBH/j4+074by9Q2OcfrpNHDwDiI4y/j2Ao7fKiEqxXjX2OqQIxjUinQ1Un5PrIT+rwx2ih59ELFH8NPaOQU5dHQlFVtTrxN3OMfL9yHeSFbGQDRWSg+dsu82iFNZqViy8PoD9n65DV+zErChLmCI6hZ/RN1heiSY0EnfZAZOiVmqjv/Pv3p62TDb0Kl9u0R88fVU8AyIgP/B3zRDgcKuPOYVM/SwdTH4Iwr9YgNHyNJpoUZkKFWkZF+pVQNxiwi9B5QQe5wxV5NcIddk1vhxWlQq1OomV0hOZspqjzY2cVo5xO1T7yIEr23Lk8dWIsaXHRQmGECKfAoxceuEeP7yhEQgMy/EAm2DlprMbP8zN3rLqWv6TVg0ePxaqhF6jICeu9cdhsyqSCVjlSmcFXK8arwH4LzhDM0vKhTP6+E6fdHnB+Lha2fYhw6KdTMVNmK7nGzMJ+l+xkiNZAmv1dbpv06qXefWklAg8E+QlbyX1qhRqPxyfZtux1t4GJpqi9b35pgF7IodV6q+VJbanh0eubqr32nA21FyWPNl0mVa7H0Aw5w+zBCd202Wy6k7X1heh567VDQo+eydBNFn/aSfmYihrzHj2rKsoyWstfAsHr0WMMvRBMPDY0ZOgRlmA/CK2BeqTTEXCYjb+fGrtGjJculgfLokY03GFHuF18P1ZCObT2TYuN1jREjBpX3qsQyXn03EzYUFpstDCcS762lnHnb7iKj6Gn49HjleD0Zv39wepsMV9HRcm7rRqPaXHRITL0xF+EzeKXIspzaIUUZjDFLvbXagvYwRdbx4JR9/Tw8ej5+U4kSRJ6WvyFvddwh1333HERxt9HKNR12cEf+xxF6oOnKqtVhp7i0fPT0GO9bmYSuJtByV/np0fPCO9Em7qvYfOUye9Y67610g54j7HWRmp5gbXW6PXWERljDYtA8liydciMEZUYGW653Q2z23WfoxW0xgENjV44NB+dAsCUejcf3RRo6OYpk/XE36U9Rvkh/SHc4VBNpFrJZdxUIEOPsAQ7UNFaT7Fu/2HTi6i18PeDZgf7fK4rGdFglw3d5LEUulnbYPBHpMZGac5WixpXNnw0Ksyh2kceRMkeqWq3R8lnpDWrKTT0mHP627jxM4J6uap470OwxVn4RKdWEQ0U9FRERaTUo0evVXSk5dlHyZQQvjaiAQWg7cGJZOo8G2XIth1JkcFXY+W/Natrg4zw1wjhQzf1MDNwjQkLfl1jJ2DY8iZHRfiUucbt8Vmj5/2/9vPWM2DZyYNgzazLdTN0hp7k49GTE2Gz34WmoacTcmi1LZFD2/iweK1vrG18jOa52EmIQHKKsnXGTERQqoagmNE1RGtI/cFo4imUKWr01q7pRRbphXXqwbfb/oROy5MLR8oqMPCVj0wd469HLxSqlxFOOxe6qfcOmqbJ1DRLTTQYbAOckxiH8YwapBFjc9NxPqM6B2h/VJ9cPAq5SXH44CJtVcGE2rQArNLm46P7C/e9um8n5d/TumShZ5sk1XZv6Ka+R+/+Yb1Vv/N/A3UDo3WcepVokBQb7sT0LlnCkAx2UOxNBusrxiIbZ6cqq5UBUsvoSOFQfmStoiRr3LGNfF7rJIzISgEgNsAmdcxUye+nx0Xj44tH+aRM0Eocf8eQPJ/1RJf0yEU/ndAhFnmg3je1BfqntRTuE8ii6Qs6ZKB1TGDJ5iMcdoQ7HCFao1dXd1ZfOAI5iXH44KKR6JgcjzE5aT77t4yOwJW9O2Jyp7bKYLF/Wkucn2v8va6YNhy5SXF4YswA5CTG4bHR/dEhOR6vTBgMAPjnWd0RE+bEdf27KMc4dBQk/zGoG3qnJOPvfTthXPsMTOucpRrAvjZxiG55RDnD2ifFYfGofprrKs149FpERfiVUgIAFnFqk2ZhPRpyfZ1Xm44gKyEGn88ag+fHnYUOyfFYct5A3DiwK/qmtsC9jPy3zD3n9FLeiYxIme/F8Wfj05mjkZMYh9ndcwzLyHrj2MG+zWbz8Qxd1aejanJJPlbPc6NnvMzJy0WP1km4Y0ieZW+1iAiHHVNr5dFFqpttYiLx6gT9+mcUYl7j9vgouMrJ4dmBc78037aufVIczuP6RBYr65hzk+Lw2kSvcvSrE4coSoLn56bj1rO7KymCHDYbIp0OZMRF4/z26bjt7B4+53psdH9hjjd/YCddRG3Eo6PUfXbLqEhLk6uAt49umxCL0dlpujkG9ZCvaDTpabafsbpm8I4heZr3fcOArj4GZlZCjJLfUNQ+sGjdEV+3bTYbLuuRq5zfDLKaMp+3VA+zkSWJkeFKO79wZN+QhHabCd1cMDgPPdsk4fJeHYJ+/fqAEqYTlmA/iDC7HWsuHgXbA69q7m9DXTLd58edhbYJsXht027M/dCbADY+IkwYYjAoozV2XzNNtyxrZ47GoIzWeHbjH/j7Jz8CALq3TsL6S87DiDc/VfZrFR2Jf59fJ/kdGx6G/82bhP9b/yseqk3wHOHU8+h5f79jaE88++sOJUxySue2kADcxSTVls8xol0q/m9wnpJAOtLpUDVSl/fsgJe5QRoL28nabDZdMRZ5ttVptyHcYffpoOfmtUeXlokAtAdZDrsdX146tu6a3DsdlN4K7wmM7i/2HVb9rRXic//wPhjxxlrVb62iI/HfK7xpK3KeXqnpDbymX2c8zeQmHLf8c+F+/s62LRzZF7cKBjsipnbOwiqNXD1JtYNgkfcowmE3LSwggv3uJnfKwuROdbl9Pp01Bot+2Ipb1v2i/LZ53iTV+jgrTO/SDtO7tAMAXF+bTuXGgd2U7Y+c2w+PnOsr4R7pdKCm2vceFzMDuY8uHuWzvXvrJOy4ego6PbsaADAqO1WpV8duuhgtawcSbJ3cVds2/GNQd3R//j38fuy06pz8elve+C6/9RJEhTlx+5cbsfD7LT5lMiInKQ7b/jZF+Xvl9v248N0Nhsep1XS99eSF8WfjhfFnq/a7so93Yuqx0XVpTxx2G+7Y4G1rPps1BqNrDfyfL78AA/6zBoA3vcyCIT1w/vIvAHi//b/WGpJ7rp2Gj3fnY6lBYnS9gaw3YsI7mfPJzFFoER2JtDhf4RE9z4SeodcyKlJJ1fHCbzt1yzmtcxZWTh+B5MXLNMPUfps30ScB+D8GdVPVSZfHo/RHLImR4Th18ywAwKzVX2H57/uE13BJHpXiJlAXNsfWu/gI76D15i+83+mUTm2x6sKRuvfYMlp/8olvG2V6tkn26T+1UgQ9PLIvbh/cAwmLlgEA+qW2wI0Du+Hh76x/FzLdWiUq3yTbLvOD6E9mjsLY3AyEO+y47lNvzrzYcKdlj16Y3Q67zYbPmMTueuMSEXLZjOzbSKfDUKBHTlNzpLQCKU+8rbvvBxediwkdvbkPn/h5m7CfeHzMANzDjDM+nTkaY5gJgtS4aHxz2fkY+vonPse+O30EpnbOEj4P0bf+2qSheK021VTaE2+r0oaIMGsQspgNOZe/v38M6g4AuFzwnQZKBBe6yYuxAMCDI/rgwRG+6WWaCuTRIywRZjGWOUqg8shK+vo7+waIQx6ddrvP71qhGOxsVrjdrpoxYwcqqnArTkyBNy7Ya/GCKuy+vKwxD2+sqUI3a5+pQ/HoeY2ruPAw4Zof9lh/10OJFPcAX8l1vUS+fOgmO+DTM9L4gaGWx8xfyWYrAgFsnWnDeQCTa8OjRAPZQNXzjAY+/GxvKLyKRojqtNlXwk6CsOuMzAj2GKUn4feRPRre67KKgL4GutYaOp86afL9snUtEMVU9rtjn1FanDpEnG+jRevseMyur5MNVbVHz/sb/y2yUQt6dZMtr9H3LG/XUx4Ns9t9vAD831pRJVprFXlcHslnMCwrmerVE73wVhmj/HfBEjdhn4n8XAPx6KmfnXZ9lNfDqUJcI8IsLyUIxjrfOhVrfSNEy6skehdmysVG6+i9TyNhJK1QZ75vYKNwgrFOvm0IBFK0CIbKME+4w656ds1wiR4ZeoQ12AbYzKwb24nKg12tdQtW48O1Blf871rhEOzA1OvRq/ubVQjkBRTYf/ONKNtQ84M6tqE2GsC6uQYtllmLI697ctrUHj35vvn+ORhrxjQV9zgDUG9wwDfS7MBab/2B3mCJfR/+dgFWPIGRKkNPPWiW122JDb3AOlSjAQN7DzaEVqZeC9EAyOxYUSXBHuYbpqyH6Hn7GL7c2lQbs75VRjSo1spTx79P/m+tdTxsSKNV1Vl2/ZpoXRzgnZAJ15hskreLYJ+zvmJm3X0q6/HCnEqIoZLjkzOe2OcTq7OukO1TjMZb8iX0BuZhdrvP983/rWXMR2kYKzwuj69Hj2+TZdgJHzN12yh0M1hCRux55EFvQIaeynBkrsONGeQ1w1HcmMCqAeuvwcsuU3CYmDgAtN+baKLLTLnYOqH3PtnXIeqPtcZjfN0VhVoHQmy403BCIlgEIgqk9d6M1I+bA2ToEZZgGxMznQzbWdTl3Krr9NnZe71kuSLMG3rG0vS80caGzGgJKHg9eurGI0zj+UQ5HSpvoFEnz3ey7EBJ7lDYNXpA3Uw5L7ihZWRYadq0FrpbWYfAD8hizXr0IrQNvdbMe/I3ebSVQQLrmfAx9KK8dVn0vAOV6DfybrD1MFbDsxtq3AEMDNlJELYdcJh4NyIPkZ5Hj/03O3CwUg+MPHpahkEgHj3WW84aAJG6Hj31PbXSWIfakp3l1xVSERsqsuEpt00+Hj0n69HTPj/bZhrVeXmrXr0LE0zGmRXTYO9P7xjRGj0lykKn7TKK6gCMJ4iC5dFjn7UdwfXosWst+foo21R85I/l0E0/UyKw/Zds4Bq1Y3oGgz/lUkXc6Nz3ycq6718kBqXlmebrbgrTbwUjGXiwUluY4USF/yJ/Wn0wnzC9iabK04UMPcISao+ecSMmUi1Ue/TqPr5oE6EsLIphw3uwuM5Vq9NgBzS80caqWIlmOwENj56G98/Xo6d/r/ykoirs06kO3ZQVrELq0dMM3TRv6PFx+RGc0awFLzHO3k8bpoPxt4G2MivOvgdevEVWtnMIcq/pKXkFA6MQxPqAT59hBd5TbgWR2qpeKCtbf44zhp4VJTi+jeFDoIzW+4qOMeI4k2ibNeTZ87SOjuJUDtX1Tst40jLgfPYT5PME6iaCtEI3WeNdrz1iy2vo0avdg49+YAmvFUhS/2ZucMu20XrH1Hjq0tvI4dwnK7yTb3zdFHlE9TBqu62KlpihLnTT/3No1SHekJGNST7Kx6qHxd+UCGy/VpeuSL8d0/q2RZMBZgxxs0sYTjATPaKJPK3QTf6c7ARlMDx6wUpWb4YTOktDjNC61winI+T9c0PTZAy906dP45ZbbkGPHj2QmpqKlJQUpKSkoGvXrrj66qtx5MgRw+OvvfZaZGdnK8empKQgIyMDI0eOxPfff+9zzMaNGzFmzBhkZGQo+7dp0wbp6ekYOXIkfvjhB59jDh8+jKuuugpdunRRypmamoq8vDzcdtttKC42r0zUGFGv0TOuPqJFt+wHx3r0WmgkddVCvj7fmPJha1ozk7xHj20QzeQvEg0itEI3o8IclgazvJgEex0+j15dmWWPHoS/85hZIyJfTyuEyMxMntyE8p0/a2DppVrQW6PHyoP7OwFtZd0pOxnBd27ss+DrjxWpeH+6HLZ+hCK9gxlEIXRmPZnqb89a+UXX8FXdFHuU3EyZRSIIorV8gG8bE+ljTGiFbqq9/FbQCiljv6sW0RGcoWeui2cnthIizX2L7D3LA+Y6MRb1cfEahjaPKnTT5Bo9XY+e3S5oSwPz6PFG7LHySqXuZNa2R5oePZMGtbK/kaEXArl3+d0Fy6PHtn38mnx5iyp0M8Ifj55/z0Hl0bMZTxwA2u9N1EeaiUhg713PMDRaO6hlrPBjFDkFB2DcPpjRUAhmDkMjAolU0fTo2TmPXjN06TUJQ8/tduPcc89FTEwMNmzYgIKCAhQWFqKwsBA//PADOnfujMGDB6O8vFzzHDfeeCPCwsKwdetW5djCwkIcOHAA9913H2bPno2CggJl/5MnT2LKlCn4xz/+gQMHDij7HzlyBPn5+bjrrrswY8YMHDt2TDmmtLQUQ4YMQY8ePfDzzz/j8OHDKCwsREFBAdatW4ewsDCMGjUKnhAkua0vnAJDZtnkc5CdGIulk88xdQ4tMZaFI/qiQ3K8UNFP5vaze2Bgektc3rNO5nZW92z0bJOEm2qVAW02G2Z0bads1xogsQ1shNOhGhBkJcRifPsMTOiQqZkziz8G4JLDsoae06nyWhkN/O8c0hMdkuOxqPZZdG6ZgHPbpWJ6lyylU+ONkjoPp7aQCwA8MWYAcpPi8JBJFak5ebmaDWxseBgu7NJOd02YPDB6afxgZCd6F26f2y4VnVrUydMvOW8gcpPi8PCIPujaMhG92iSrrqG+Zt21FgzOQ+cWCbhraE9VyOqKacPRykCxToYNr/li9nlolxCLd6eP8NmvR+sk3HJ2d4xvn4GJHTPxf4Pz0K1VIgCgU4t4/POs7sq+s7rnIK91XQoPkZKXFv4It7D1sCGEWAD1d/bCuLORkxiHp8cONHVsuMOB6V2yMCo7FbcPzkPvlGTMZ9I3AMDns8agXUKsIikuw3+D8vlY2GeazOQUWziyL3IS4/D8uLNUHr0nxwxA+6Q4LBzZF4BX4VcexM/qluMzgMuIj1aljuEHXXIaBN7Lb4V7h/VCTmIcnuFUFqOcDkzqmIkxOWnokBxvKGf/5JgBPobroPRWGJ6Vgou7ZuPmQd3RuUUC7hOkj2EHS2w7Pr1LO2QlxGBs7TNgjaEBaS0xqWNb5e9z2rZBblIcWkZHYPEodVsfpuHRG5Wdimv6dValxTEz5gsTTMaNaJdifCC0vcx8W3esNmdsTJhTqWenNNboGYmxLOL6PqNv2ax30grBEGNx2m24uGs2RmSloAfTDi46t5+S9mFgekuMqE37w0f5mDHcMuKikZMYh9YxkRidnWq5jCmxUZjWuU69WO5P2XasfVIc7j2nl+oetL7bJ8cMRIfkeDx1nrk2DwAmdsxUGYh6933POb2QmxSHJRrn1xRjqW0f5f5qweA8pb0wSim0dPI5aJcQa5hbblqXLGWcxKdcYkmICMMrEwbjwxnnol1CLD6bNUZzXxGvTxyim/tRrlsiojVCpSOcDtWzCzTXbGOkSaRXWL16Ndq1a4e7777bZ1tCQgKuv/567NmzB88//zxuvPFG4TnWrl2LvXv3IipK7YGw2+0YMmQILr74Yrz//vu4+uqrlf3Hjh2L8847z+dcNpsNw4cPx+jRo/HNN99g6tSpAIDnnnsOkydPxrXXXuuzf6tWrXD//fdj06ZNeP/99zFlyhSf8zYFRKGbM7vnYGb3HOw2mUeFnQlmDb3sxFjs/PtUzeM6JMfjodqBF0tMbboElremDsfb214FoB2KofLo2dUDgginA2sEUvAsDpvNZyDFNhh8zqxwnVlhntS4aNWzsNts+ILLzecjeFA7ADHy6F0/oKsim29EbLgTz407W3efd6YNx/bjp9H1ufcAeHN5fT3nfEXOWb7X7q2TsPfa6cJz5CbHK3Lgtw3Ow2d7DuG82jQKeoOlNjFR2H6191t6Z9t+5Xc5RcCJ8kq0fOwtAN6BxU+Hjvtcm32Hw7JSsO+66cJBjiz7ztaLrVdNFt6PLIsvPwORp7BnmyR0bZnoI9se4bSjxGJ+4kA8YsGCnXGe16cj5vXpaOn4FdPqjOtf/zrRZ/uonDTsu863/ogGu3piLOnMLH7nlonYc6233sny7gAwf0BXzGe+keHtUnFg/oWaZbfZbPh45mihhPm1/Tpjbu3ElHryx9ogvX1yvFJW/tps6hO90E2g7t48kgTHg68B8Bop65n0KvI3xROmYahO6JipSMQD6rbpp8svwIu/1qVKyIyPUUn/j8lJR94L79eWl/Xo1V3389l1bZ/8jM3M7Ydxaspz8nLRrVWSzhF1sPfAryFlk6+fZLx38vM2o7opMhhuPqs7Vu84gO/zjwqP5wll6KbIUzqzWzaWTRmmmw4H8E5sLZ3iO/GbnRQnTJvEfguxJkM3wxx24fegx9kZrfHd3HHCbSLVTTmNy13n9FLqndYyg04t4nXHL11bJmLb8dOq397nUhbpefTYPlKv/Dxy+/jAiD54oHZyV5QqSUTf1JbYd910zF79NZb9XpeWZVLHTLy/86BS5gs6ZOJkbSoEGfl5tU+KU54jywUdMlXPelrnLLyrkbpIZlBGa/zJtMMv/7YTf/3IG4335SXnIS48DP1rU83w6K3R81exu6nQJDx6W7ZswYgRvjPsLKNGjcKWLVs0t99yyy0+Rh5LZmYmDh48qPy9f/9+5Obm6l5z7NixiI6uGzQEo5yNnTCdsCCzySxFKRf430X4+yma8ejxH7uZBfs2m81nVpntG/lBnRWhATP4hG5qzP6aCUPVwuykLvseUznhFithizIRXCiP1rWMFruz19ZaAyoyFILd8IueQYuoyKAkhQbU315DGXpmcyMFG9G3qifGoqU8KVpPHAxUqVoC8OiZhf129Ooxu81sWZwmj+Gvy3rhI7jjwgSTh6JzGF1DhJxbtK4c5r8Ntix6Hj3Weye3yRXyuukIPhqh7m8tzwHbVBiKsYQgdFNPddNmUqjFapPvjxjL0TLrwhx6xXLoGLgsfP2VMRy/mPRA+4tZMRZ/4Osq274Gq8z+KF+ybUCU06ErcKTd/zcJMyggmoRHLz8/H3l5ebr7pKWl4cCBA5rbtTx9Mlu3bkW/fnVhE9XV1UhMTNQ95sIL1TO8+fn5SE3VDyFIS0vD5s2bdfdpzDh11jP5s/YhEBU6s2jFtrMNFN94mzVaeRuSbRD5QZ1K2SwI43v++cuGq1HophXMhu+wA2leatm/NWfa6yXZgRZbf0QDJ7a+anXE/iq2WcEueApx4U5h5++PwdE4PHoNE/Ii+lb1EqZrKciGCq2cnGbXyFpFlXLE5Pdrtu3Vm+hj4Y2wCG5SjcVhF5/TaBLEzMDZZrP5PQnCloU9B+8ZOMV473iPDH89VpRG63thn52RYRos1U3R9UXFk6NjjD51q5N7kdw7MnNfZTUuS9cA9OuMKHRTBL8eV/nd4Bsy64H2F+01esGvI1pjOBF6T9OmMvSsl5OtZ5FOh8+7sdtsyhhGy6PH9x+0Rq+BcLvdcBgMvJ1OJ1wu6x8+AHzwwQdYu3atTzhlVVUVFixYgIEDB6oEYDp16oRZs2Zh586dqv2DVc6qqioUFxer/mssODUGLYD5BoX1pLGzZ0ahTP46WbRm6NgO1SjXkha8IaRKJ8GJsWhd21/4zlTu+MyKsZjBbJsXq6Oq58+96hku7KAxTDWo9T0Pawxr1a9QDJZ4RAMfrffin6HHekCbxPxd0BB9q3piLPWlECejaeiZkNf3B/bezaa8MFsWs4MxvrrrCVGxu4ZphG6KMOsN93cShFdYluHbkZOKR8/pu25apy3UmoC0Wxj8htbQ8607cn0ymgC0siYZUNe/WMFzDBZ6fZGSXsFPMRYjQ89MPxhIKK626mbg7Qz/ulkvoZFHL5SGE2vcRoU5fSZz2Uei1caFwive2Gj+d6jDqVOnMHfuXNx444147733kJSkjt1fsmQJOnfujC+++EIRViksLMQvv/yCCy64AGPGjEFRUVHQy/Xwww8jISFB+S8zM9P4oHpCN3TT5Kww2yCyjarxjJh/jaBWw60O1eQ8eibvhT8326iphBf4maYghOw5uc60pKrGpwxAYIaeWY8eOyvPX8+v0E2V4aI+H6+WKiMqKTvgaFBDT9DJx0WECWtBlQWZf5mIRuDRayhE3yr/PZsJ3QwVqoTR9RC6yQ7szDpZzXoXzQ5EfTx6DvabVd83u6el9Aomm5VwnbZED4dG/8Abqsp6PIFapN6ki1Y6Eishq6FU3RQh93dGEwiWPXpcm+6Pd8cM+qGbvmv0RIjEnwATeR9NPJJAjLJQhm569EI3Dd51KMVNVB49h8Onj+dDO0Xw7605irE0SUNvx44dyMnJ8fGomUWSJLz11lvo2bMnkpKS8OuvvwpDQ88991xcdtlliItTK/nExcVh1qxZGDduHN59913N62zYsAHt27e37JG7/fbbUVRUpPzHrh1saPwN3WQ9Pqy7nj2FkXSuvzPgWp2Snqy+WVl4vpHQ9uiZy7NlBb7M8vPzTZgeekOPhVfdCsSjJ0phoSVHLQpTYzsCLeO9Pmb0RGGjLaIihHXen27G33VIwaShlrOLFF/57ytWJ7Q41GipYAYjh5UI9nsz+/3qqeaymG0X+f3Ye+XbA/YbZb+HGIP1aWbD69WTIOa93VoePa2JIVH+N71JF6120ehdsOqBoZikko1+0USE3Jca1V2recnYiYYwhz1kec30xhhyfTOagDH7Dfhc20QLGUhfZCTGEgi+E+HG34NMKD16KkMuzOHTx7PtfkyYuX6xOQqzNElDr1OnTti7dy86drSm6gYABw8exKhRo/DCCy/gk08+weOPP46EhAThvp07d9Y9V/fu3bFnzx7N7cOHD8fu3bsRHx9vqYwRERGIj49X/ddYYDsyvlHiG5pXJgzG6gtHIDM+Bp9cPFq1bU5eLgaktcStZ/fAgLSWmJOnLXzz6oQhyEqIwasThvhVZq2Y+55tkjA0sw1mdG2ndAA3DeyGri0TMTevvalzT+iYoUoFwCLKmTW/fxf0aJ2EGd2yrdyCEF7i/e6hPQGoG9ZpnbMC6jysNNLXD+iCbq0ScWkP9bv0p+HMTozDgLSWuLir73Pq2ioRw7NSMKVTW9UzEBWVvbYNXtW4szNao2Ny3TdlZrB07zm9rBRf4ZFz+yEnUZ3Kol9qC3RIjscNA7qaMo4WDNZfnww0DjGWL2afh8z4GHxkoFYbbGZ2y0b3Vom4tl9nYb0AvOq+49pnYHR2GtrVpvjgWTPjXGTGx+DLS3yVlv1BTpFy48A69c5A0iv4g5Ghd1WfjujVJhmTOpmLGpnbsz26tEzAPwZ1091v0bn9kJ0YiyfGeNVnB2W0wlkZrTCrW47PvlkJsRiVnYqJHTNVg+jXJw4VtvsPj+iD3KQ43FXb3smpLz7XkGr3N3STjZgwkwM1VrC2rKegb5DrxTX9xOOLx0f3R7uEWEVGf8HgPFV7pU7kHrwh3BNjBiA7MRaPnOtVtpaf6weMQqPcl749dbiSbqRPSgufc1n16IU57JjaOQvDs1LQpWWiarJyyXkDffKsxoQ58dpE/fHAJzNH+dQLUalevmAwshJilBQoy6acg7bxMT7pou4b1hvtk+Jw61k9lPRNLWtz/17Z23gsarNBaQtaREXgnanDffYJdujmlE5tgzKR+cDw3qq6reeh57HiIWPTZpmB9YpHOZ1KqhnAm35jzYxz8VBte3Hn0Dxc0t3b/sipl/7Ss26cd3XfTujVJhkTOzaeCLpg0SQWc5hZ1+ZyueA0CD/5+eefMWPGDNx+++2YN2+esQdJR6UTAKKjo1FWVhb0cjZm9Dx6LDcM6KpIik/ulOWz/dWJQ5V//3T5BbrXnNOzPeb0NGd4idAKxXDY7fh6zvmq3x4d3R+Pju5v+tyRTid+mzdRkRJmmzSR0MyTFnLsGME+/x/mjkNu7WCALcNKQT44K1iZjHtijPje/Om7whx2zXpht9lUUvAyZozSZVOGAQAGMhLMRoOlri0TcZefht4/z+qOf57VHcVVdfkSHhjeB+fV5hszsoE7JsfjQRP5DhuDGMvIbP0UBKEiJjwMWzTSXMjYbDZDA3R8h0wc6BC8Tv6+4b1x3/Deqt/Ua0ZD3w8YhdgZpU7hiY8Ix7a/TTHcLzspTpVKxWm34/u544X72mw2VfoEmbw2ydh/nW99um1wHm5jJj/Oy03XrXfsLL+Rtzs23InSaldtmcWeRq2BbVx4mCqUf9G5/YTXE9ULltzkeFUakQdH9MGDI/oofQzr0fMnLF4LPu3OsKwUn+cq96X901oq205VVCH50eWq/fyZ3GNzl7ID+Hm9O+JaLqemGcbmZviUX1Suy3t1wOW96gyMvqktVRL+MncO7Yk7aycX3po6HG9NtVYeu82Gx0YPUFLviAgkZJX1gr4w7mzL6W30aJsQi/3XTUf6k+8A4NfoGYRumhxE2AC8PGEw/rNpl+lysevZI50On1QzAHBWRmvcXttevDH5HLyhke/53+efZfq6TY0mYXFkZGSgsLBQd5+CggK0bdtWc/vp06cxdepUvPXWWxgyxNgzFBMTg8pKffneiooKVXqFYJSzsaOSwtZZcN2Y3N9Gi6uDiSp0U+XRC/6nxnYKoUqSHUjSXJnGUhfYwZo6RYN+5xqMsZSW1zBo6RVU6SiaRLN+RsJ+TaESY2EJxvfb1LEyCcK2VVpGlFZ7ERfuRCmTXy9U75f1etb3+xX1paKJskBDL9konGB6LRuyKzJz6UDepzoE2u/TaKLOoWw+dDOUsCl9zgRRFX9pEk+mR48eWLdune4+69atQ48ePTS3P/roo5g1a5YpIw8AcnJysGuX/szC9u3bkZNTF4oSjHI2dsx69EIkmuUXZpXnggF7KbazC0WYFvv82QGMWUn1+qK+DD2jEBG2FKxhbNRRBaP8/nZCZt9kY/DoEcaw0QWNIXTzTEBP2IlHLQyjseZJa41eRFjIJ/f489Z3ShNRdIxo7XOgnkaXVHcdo8grKwRrYs2va5u4j0DeZ6jWNcpofQ+GqpuhKEwtocp92txoEobe5MmTkZ+fj7vvvhsnTpxQDWSLi4uxZMkSfPTRR7jyyis1z7Fx40aMHy8OHRFx/vnn45tvvsGqVavgdqtV8NxuN9asWYP33ntPlZLhb3/7Gz744AMsWbIEJSUlyu+SJOHEiRO46667UFBQgEmTJpkuR2NDb40eS2Px4tQ37MBKlToiBLO77OyqytAL+pUCo94MPQs3rvLo1YOhx3bCrEEarEdDhl7TgB3I1cdMeAOlNmxU6OXk5GEH41oDZ632IMxuV/WPoVNVZdJn1PMLFk2aOmy+5lMwPXrBpLF79AKZlFbnoAw+7Dt1a4jOiTA78ezPndcYKKQSXpqEoedwOPDFF1+goqICw4YNQ1pampLTbsCAAdi6dSu+/fZbxMR4FweL1C5PnjyJ6dOnK8eJ/ps9e7ayf3R0ND766CMsW7YMOTk5qv3atWuHZ599Fh988AFatKhbiBwTE4PvvvsOW7duRf/+/ZXce2lpaRg2bBiqqqqwbt062BvQ1R0oaqVKMvR42MbKSuoIf6hgZPhDFboZDEI90yhj5L1gi2EtdDPw8mvN5gZrhtlfCXmifmHbhGB6Ksxc70zFoRGyLYJ9I1peKa3IgZLqGlWfGCpVVbbaGKUCCDYiA8xms/l49QJt87VSTwRKQ45KzDwSdwDvM5jrNUWwkxhaS1REhLKGkkfPHE1mMUdCQgIeeeQRPPLII4b7ymqXLD/++KPla3bo0AErV660dExKSgqef/55y9dqKpgN3QxmXH1jwshg03omocgLxHaG7PnDHfagNYDBMHLqI0QNMJ/7EFCvYzOakQz2gI3Noch74kqYNT6A+RxIdpsNTrsNLo9EHr1GgJZgR33Pf4V68NcUcDGDUqNJkKgwJ07VJkBn2y3WcNGaUHJ7pHrx6DVk+KFWWxnusKOSmXgMOHQzRBMUVvqIYMPn0hURiEcv1JPrWh5DI6PebB/mT4RDY1um0lhpnqNxImSoQjcFH+aCwXnITYrDfD9UsoLNmhnnIi0uGl/MFstu+8NL4wcjIy4aL45Xq9X9a2RfZCXE4N5z6tTUBqS3RP+0lpgZhFQKIoa2bYM+KS1wGZfO4PNZY5AWF433Lhzp97k/uMj77NYF8OxenzgU6XHReKtW6TLUvDVlGNLjovHGpKHC7ewAKZbJqaM1KfHc+WchIy4aL4y3pkyoxZy8XPRJaYER7VKV3+4a2hPtEmLxwPDe+GTmKKTFRWPFtOF4ZcJg3XsRMb1zOwxIa6mZPoAIPW9O8tb5d6aJ6/yEDpno3ioRVwVREU/E/cN6o11CLBYMbrrrwf3hyTEDlAHvwpHeNAEdkuMxJLM1Jndqq2mAy23HqukjcM85vZCdGIvbzq57dmNz09GzTRKu6KUt//63vp3qJU+iDcDf+3ZG15aJmNLZV9E6FLww7mxkxEXj2XGDhNund26nyk8ZeOhmcD01T4wZgMz4GDw2yryidrB49vxByIyPwbPjjFUdhR5TP64ZimgB1njv0ToJZ2W0wvQuWZrXWjr5HG9bKEgjwSKPne6vVaL9rHb88rGJND1X9enkTXlxdnfzN3IGYpPIJG70FBcXIyEhAUVFRQ2eU+9oWQXaPP42AODpsQNxTb+GN+gIQg9ZlvxvfTopne2TP2/DDZ/9DAAou/USv5PgEgRxZjFj1Qa8s22/6rfdf5+K3OR43Pv1/3DP1/8DAPz4l/EYmN4qaNeV27Ehma3xzZxxQTtvsCgsLUfqE175/XvP6eV3ShoAyH36Xew97dU5kO6YG4TSNQ2GvvYxvj14VPWbDYDH5DOQ68jLFwxWpYwIBpIkwf7gawCAVdNH1NskA6GNWduAPHqEJVj3/Zm6Do9ommiu0WvCa2YJgqhfRFPjckhofYRuNtZ+12EL3tjgTBXZqE+FcKvUx5piIjTQCIewhN66PIJoKrCGHtVpgiACQW5P6kWMJSRnDRy2HQ3UXKlvkZnGgpbYjVVCXUcarzlKiCBDj7AEeT+Ipgq7Rk8WY3HabTRTSRCEaUSqm7L3ju0fzzSPHmvkBroiqL7zAzYWRCq5/q3RC7wsRPOBRu2EJUKhHkkQ9YEodJMmLgiCsILIhpEni9jggFAlTG+sE1PBVHg9U0M3m4onk6Q9mhY0yiEsQXLdRFOFVYKLlQ29ZpoGhCCI0KAX6s2usYoKC41HL6yR9sHBDN08UyfgRBPp/qSqCrXXt7FONhBizsyvifCbxho2QhBa3D20J9rGx+B2Rmq+U4t49GidhMkd2zZgyQiCaGo8PKIvMuKiceeQnshNisP1A+qUp9mQw2CHbj45ZgDS4qLx1HkDg3reYBHM0M3VF45ASmxUvaXmaSz8Z8JgpMZG4cXxZ2PltOFIiY3C2pmjTR9/VZ+O6NwiAdO7tAtJ+S7v2QHdWiViXPv0kJyfCA2UXqEJ0JjSKwB1Er7/Pn8Qru7buWELQxAmkCTJZxZS9BtBEIQRctvBtyEPfLMJd371m3efEKQFaOxtljw2uGtoT9w7rLf+zgY09nsNFex9+/MMQv3cztT30hih9AoEQRC1iDom6qwIgvAHue3g25BQry1rKm1WMNwHTeVegw17334pblLYJsFBhh5BEARBEESAnKlqkTwiZVKCIBoGMvQIgiAIgiACpKmoJhIEceZAhh5BEARBEESAkEfPCyk/EETjgQw9wm8oUpsgCIIgCBay8wii8UCGHmGZq/t2Qm5SHGZ3z23oohAEQRBEo+DmQd2QEReNO4bkNXRRGhQScyeIxoOzoQtAND3+ff5ZJLFLEARBEAypcdE4MP/CM75vJDOPIBoP5NEj/OJM78gIgiAIgof6RlLdJIjGBBl6BEEQBEEQRFCgyE2CaDyQoUcQBEEQBEEQBNHMIEOPIAiCIAiCCArk0COIxgMZegRBEARBEARBEM0MMvQIgiAIgiCIgLj17O5Ii4vGPwZ2a+iiEARRi02ihCeNnuLiYiQkJKCoqAjx8fENXRyCIAiCIAgfKPUSQdQPZm0D8ugRBEEQBEEQAUNGHkE0LsjQIwiCIAiCIAiCaGaQoUcQBEEQBEEQBNHMIEOPIAiCIAiCIAiimUGGHkEQBEEQBEEQRDODDD2CIAiCIAiCIIhmBhl6BEEQBEEQBEEQzQwy9AiCIAiCIAiCIJoZZOgRBEEQBEEQBEE0M8jQIwiCIAiCIAiCaGaQoUcQBEEQBEEQBNHMIEOPIAiCIAiCIAiimUGGHkEQBEEQBEEQRDODDD2CIAiCIAiCIIhmBhl6BEEQBEEQBEEQzQwy9AiCIAiCIAiCIJoZZOgRBEEQBEEQBEE0M8jQIwiCIAiCIAiCaGaQoUcQBEEQBEEQBNHMcDZ0AQhjJEkCABQXFzdwSQiCIAiCIAiCaEhkm0C2EbQgQ68JUFJSAgDIzMxs4JIQBEEQBEEQBNEYKCkpQUJCguZ2m2RkChINjsfjQUFBAeLi4mCz2Rq0LMXFxcjMzMTBgwcRHx/foGUhmgZUZwirUJ0hrEJ1hrAK1RnCs0rjuQAAFiFJREFUKo2pzkiShJKSEqSlpcFu116JRx69JoDdbkdGRkZDF0NFfHx8g1dyomlBdYawCtUZwipUZwirUJ0hrNJY6oyeJ0+GxFgIgiAIgiAIgiCaGWToEQRBEARBEARBNDPI0CMsERERgbvvvhsRERENXRSiiUB1hrAK1RnCKlRnCKtQnSGs0hTrDImxEARBEARBEARBNDPIo0cQBEEQBEEQBNHMIEOPIAiCIAiCIAiimUGGHkEQBEEQBEEQRDODDD2CIAiCIAiCIIhmBhl6hCGnT5/GLbfcgh49eiA1NRUpKSlISUlB165dcfXVV+PIkSMNXUQihLz55pvo1auX6t2npqaia9eueOyxx+ByuVT7r1u3DqNGjUK7du2U/TMzMzF06FCsWrUKIv2njRs3YuLEicjJyVGOSU9Px4ABA/DSSy/B7XbX1+0SIcTtdmPq1KlYsWKF6neqM8S6deswZMgQpKenK+9TrgcTJ07Etm3bVPvv2rULs2bNQocOHZR909LS0KdPH/zrX/9CVVWVzzUOHz6Mq666Cl26dFHas9TUVOTl5eG2225DcXFxfd0uEQSOHDmCefPmITs7W1VnsrOzMXv2bBw8eFC1vz9jmYqKCjz88MPo3bs30tLSlGM6duyI2bNnY8+ePfV1u4SflJaWYvz48XjxxRdVv/vThzTJdkciCB1cLpfUp08f6Z577pGOHz8ueTweZdvp06elJ554QsrNzZXKysoasJREqFi/fr3UrVs3aceOHT7bCgsLpQkTJkhPPfWU8tvq1aulHj16SN98841UXV2t/F5TUyNt3LhRGjJkiLRkyRLVeX755RcpOztb+uijj6TKykrld7fbLf3xxx/SpEmTpH/84x8huDuivlmwYIEUHh4uvfLKK8pvVGeInTt3SllZWdKPP/6o6mMkydsHvf3221KHDh2Ud33w4EEpMzNTWrp0qarv8Xg80oEDB6R58+ZJ06ZNU52npKREysnJkZYsWSIVFxerjjl69Kh0xx13SP3795fcbncI75QIJmPGjJHuv/9+qaKiQvV7TU2N9PLLL6vep79jmUmTJkl/+9vfpPz8fNUxpaWl0muvvSZlZmZKhw4dCuFdEoFQVFQkDRkyRMrKypIef/xx5Xd/+pCm2u6QoUfosmLFCmnq1Km6+1x33XXSY489Vk8lIuqTW265RXruuec0t//xxx/SgAEDlL+7desmbdq0SXP//Px8KS0tTXK5XMpv48ePlz744APNY0pLS6W2bdtKhYWFFktPNCbee+89qVevXtKVV16pMvSozhAPPvig9OCDD+ruM3LkSGnjxo2SJEnSNddco5pg4nG73VLPnj2lX3/9Vflt0aJF0k033aR7jQkTJkirVq2yUHKioTh9+rTUtm1bn4kBlsGDB0vbtm2TJMm/scx///tfqW/fvrqD8EcffVSaP3++xdIT9UF5ebk0cOBA6d5775XuvvtulaHnTx/SVNsdCt0kdNmyZQtGjBihu8+oUaOwZcuWeioRUZ+cddZZGD16tOb2zMxMJTympqYGx48fR15enub+6enpaNOmDQ4dOqT8ZlTHYmJi0LdvX+zYscOPOyAaA7t27cL111+PlStXIioqSvmd6gwBAPv370dubq7uPpMnT4bd7h2yGL1/u92OkSNHqvol6suaF0ePHkVqaipsNpvmPhkZGUr/5M/737JlC4YPH67UOzPHEI0HSZJw00034a677vLZ5k8f0lTbHTL0CF3y8/ORmpqqu09aWhoOHDhQTyUi6pPJkycjJydHc/vWrVvRvn17AEBhYSFatWpleE6+vhQVFSE2NtbSMUTToaysDNOmTcNTTz3lM5inOkMAQHV1NSIiInT3ue6669CrVy8A/vVL1Jc1L7Kzs3Hy5El4PB7NfQ4ePKj0X1Rnzjyio6Nx0UUXCbf504c01TpEhh6hi9vthsPh0N3H6XT6CHIQzZ9Dhw7hqquuwvz58wGYqyuAf/WF6ljTRJIkXHnllRg/fjwmTpzos53qDCFz+vRpXHfddejdu7dKWKNbt2648sorUVBQoOzrT79EfVnzwul0YsCAAfi///s/nDp1SiXYVFVVhTfeeAP79+9XDD2qM4RVglEfGkMdIkOPIAhLSJKEV199Fb169cLcuXMxffr0hi4S0Uh5+umncfjwYdx///0NXRSikbNw4UKMGTMG3333HQoLC1FYWIjDhw/ju+++Q7du3TB27FgaUBMq7rjjDjz77LNITk5Gy5YtkZKSgjZt2iA6Ohrz5s3DihUrdMMuCeJMgL4AwhI7duxATk4Odu7c2dBFIRqAnTt3YsyYMXj++efx6aef4vrrr9fd/5prrsE111xj6RoLFy4Uen+IpsV3332HRx99FMuXL4fT6TR9HNWZM5MZM2ZgwoQJiI6OVn6z2WxITEzE9ddfj4yMDHz99dfCY99880307t3b0vU2bNiA9u3bU0qFJsqxY8cwceJEvPjiiygtLcWJEydQWFiII0eOoLi4GG+88QYWLlyI6upq4fH+jGWKiorQvn17bNiwIUh3QTQW/OlDmkq7Y773JQgAnTp1wt69exu6GEQ943a78eCDD+Kll17Cfffdh8suu8zUTOkzzzxj+Vq33XabP0UkGhGFhYWYNWsWli1bhjZt2lg6lurMmUnnzp11t3fv3h179uzByJEjfbZdcskluOSSSyxdb/jw4di9e7elY4jGw1tvvYVJkybhwgsv9NkWExODCy+8ED/99BNWrFiB2bNn++zjz1gmISGB6kwzxZ8+pKm0O2ToEbqYiR12uVyWZuyJpkVpaSlmzZoFp9OJzZs3IzExUbif2Thzf+oL1bGmg8vlwowZM3DjjTdi8ODBuvtSnSFkWDVWEdHR0SgrKwPgX79EfVnz4o8//sCgQYN09+nRowf++9//Yvbs2VRnCMsEoz40hjpEtZPQJSMjA4WFhbr7FBQUoG3btvVUIqK+ufnmm5GRkYFnnnlGV8o6JSUFx48fNzwfX18SExNRWlqqq4BFdazp8N1332Hjxo34448/sHDhQp/tRUVFCA8Px8qVK/Hee+9RnSEQExODyspK3X0qKiqQlpYGoK5fatmypeb+BQUFikone4weVGeaDmYGxjabTRlk+/P+MzIysHXrVkvHEE0Df/qQptru0Bo9QpcePXpg3bp1uvusW7cOPXr0qKcSEfXJrl27sHbtWjz66KO6Rh7g7XhbtWqF//3vf5r7FBQU4MiRI0hPT1d+M6pjZWVl2LhxIzp16mS5/ET9M2zYMJSWluLIkSOKqAb734wZM/Daa69hzZo1VGcIAEBOTg527dqlu8/27dsVBUWj9+/xeLB+/XpVv0R9WfMiJycH27Zt091n27ZtyM7OBuDf++/RowfWr1+vm8KB6kzTxJ8+pMm2OyFLxU40C1wul9SvXz/prrvuko4fPy55PB5lW1FRkfTUU09Jubm5UmlpaQOWkggVb7/9tjR37lzT+7///vtS9+7dpW+++Uaqrq5Wfne5XNJvv/0mDRkyRHrqqadUx/z6669Su3btpDVr1kiVlZXK7263W9q1a5c0efJk6aabbgr8ZohGwZw5c6TVq1crf1OdIQoKCqTs7Gxp/fr1ktvtVm2rrq6W/vOf/0idO3dW3nV+fr6UmZkpvfnmm1JZWZmyr8fjkfLz86V58+ZJU6dOVZ2ntLRUysnJkZ566impuLhYdczx48elO++8U+rXr5/P9YnGybFjx6SsrCxp7dq1ksvlUm1zuVzSJ598IqWnp0sFBQXKb/6MZaZMmSJdeeWVUn5+vuqYsrIy6Y033pAyMzOlQ4cOhfBOiWBw9913S48//rjytz99SFNtd2ySxCQfIQgBRUVFePDBB/Hxxx/jxIkTSr6axMREDBs2DPfeey9SUlIauJREKHj22Wfxz3/+Uze8ISwsDD/99JMSVvXll1/ioYcewq5du1BVVaXsk5WVhRtvvBFTp0718Q7+9ttvuPvuu7F161aUl5cDAOx2O9LT0zFv3jxcccUVpvKtEY2f66+/HhMmTMCoUaOU36jOEBs3bsSCBQuwbds21NTUKL9HRETgrLPOwkMPPaR49ABg9+7duPPOO/HLL7+gpKQEgDdUr02bNrj44otxww03IDIyUnWNwsJC3H333fjqq69QVFQESZJgs9nQokULjB8/Hv/3f/+H+Pj4+rlhImA2bdqE2267DVu3blXVGafTiW7duuGBBx5A//79ld/9GctUVlbi8ccfx9tvv40jR44ox8TFxaF///64//77kZubWw93SwTCY489hoSEBFxxxRXKb/70IU2x3SFDjyAIgiAIgiAIoplBa/QIgiAIgiAIgiCaGWToEQRBEARBEARBNDPI0CMIgiAIgiAIgmhmkKFHEARBEARBEATRzCBDjyAIgiAIgiAIoplBhh5BEARBEARBEEQzgww9giAIgiAIgiCIZgYZegRBEARBEARBEM0MMvQIgiAIgiAIgiCaGWToEQRBEMQZQk1NDSorKxu0DJIkobS0tEHLQBAEcSZAhh5BEATRbFi6dClsNpvl/x566CHlHH/5y18QERGBjz/+uAHvJLi89tpr6NatG6KjozFt2rQGLcuLL76IuLg4ZGVl4cYbb0RVVVWDlocgCKK54mzoAhAEQRBEsBg5ciSefvppSJKk+v3YsWO47777MH/+fHTo0MHnuDFjxij//uqrr1BdXY1ffvkF48aNC3mZQ83999+Pu+66C5deeinmz5+PkSNHNmh5Lr74YsTGxmLz5s1YsmQJfv31V2zYsAE2m61By0UQBNHcsEl8b0gQBEEQzYzdu3ejQ4cOWL9+PYYPH66773333Yd3330Xzz//PAYNGlQ/BQwRRUVFyMzMxAMPPID58+c3dHF82LRpE3r37o1169ZhxIgRDV0cgiCIZgWFbhIEQRAEw1133YVNmzY1eSMPAD788EM4nU7MmzevoYsipGfPnhg7diyWLl3a0EUhCIJodpChRxAEQRDNlIMHD6J79+6Iiopq6KJo0rdvX+Tn5zd0MQiCIJodZOgRBEEQBMMXX3yB3NxceDwen23t27fHp59+itdffx09e/ZEZGQkbDYbWrRogcmTJ2P37t0AgLVr1+Lss89GXFwcbDYbEhIS0L9/f7z11lua15UkCe+99x6GDx+OjIwMRSgmLCwMHTt2xPTp07F9+3ZL91JQUIBWrVppbv/888+Rk5MDj8eDjz76CBMnTkRKSgocDgciIiLQpUsXzJ49G/v27dM8x9KlS9GzZ09ERUX5iNy0adMGs2bNQkFBgebxrVq10t1OEARB+AeJsRAEQRAEQ35+Pvbu3QuPxwO7XT0fumfPHjz00EPYsmULZs2ahUsvvRTh4eE4cOAAXn31VQwbNgzPPfccpkyZgokTJ2Ls2LFISkrC6dOn8fHHH2PmzJlwuVy45JJLfK5733334Z577sGwYcMwZ84ctGnTBna7HTU1NTh06BA+/PBD9OzZE+vWrcPQoUNN3UtJSQliY2M1tx86dAj79u3D7bffjscffxxjx47FX/7yF7Ru3Roejwf5+flYuXIlunbtil9++QXdunVTHf/VV1/hkksuwZQpU3DppZciMjJS2SZJEv744w+sXLkSM2fOxFdffSUsQ1xcHIqLi03dD0EQBGEeMvQIgiAIwgJbtmzB9u3b0aZNG9Xvf/3rX9G1a1dMnjwZL7/8MubOnavavmDBAgwbNgyLFy/2MfQKCgqwcOFC3HzzzXjkkUeECpQPPfQQRo0ahZtvvhk//fST6fKaUbP86KOPsHfvXmRkZPhse/DBB9G/f3/ceuutWLNmjWrbm2++iby8PLz77rua1xk5ciSmT5+OQ4cOIT093a/yEQRBENah0E2CIAiCsIDsbePp3Lkz+vfvjxYtWuCyyy7z2e5wODB79mz8/vvvPmGhP/30EyorK/HPf/5T0/AJDw/H/Pnz8fPPP+P06dNBuReZp59+WmjkAUB0dDSuvvpqbNiwwSdtxcGDB9GxY0ddY238+PG45ZZbEB8fH9QyEwRBEPqQoUcQBEEQFsjOztbclpGRgXbt2vmEfLLbXS4Xjh07pvp9//79iImJQevWrXWvnZOTAwD4888/LZZan7POOkt3e1ZWFsrKynD8+HHV78nJyYZGZ2RkJP71r38hLi4u0GISBEEQFqDQTYIgCIKwQHR0tOa2qKgow+0AUFFRofq9qKgIsbGxhuqTVVVVAOBjKAaKw+HQ3S4baUVFRSpxl6FDh+K6667D0qVLMWjQIERERKiOS05O1n0eBEEQROggQ48gCIIgGgFHjhxBZmamqX1Z0ZOG5K9//Su+/PJLobiMTMeOHfHoo4/iggsuqMeSEQRBEGToEQRBEEQjIDk5Ga+99prhfpGRkY0mmXtYWBhWrFiBffv2Yc+ePaisrFS2SZKEoqIiLF26FBdeeCF27NiBtm3bNmBpCYIgzizI0CMIgiCIBkbOt9dUvV7Z2dmaaxenTJmC5ORkfP7557jiiivquWQEQRBnLiTGQhAEQRANTHZ2Nk6cOIHy8nLd/Q4fPoysrCzs3bu3nkqmz7PPPqubTB0AYmJikJycjMLCwnoqFUEQBAGQoUcQBEEQDc6AAQMQERGBZ555Rne/559/HkePHkVKSko9lUyfxYsX48knn9Td59SpUzh+/Lhm+gaCIAgiNFDoJkEQBEE0MBkZGbj11ltxyy23YP369Uo+PrvdDrfbjaKiIvz000/4+OOPsWDBAtNKlk6n00fhM5hcdNFFWLx4MY4dO4ZevXopqqKAd41eSUkJ3n33XcTExOD8888XnqOmpgZOJw1HCIIggg21rARBEESzp0WLFkhLS0Nqaqrhvunp6cjOzhbmwsvNzUV6errmsVlZWbpGS0pKClq3bo3ExESfbffccw/y8vLw1FNP4aWXXkJBQQEAwG63o1WrVujYsSNeeeUVzJkzx/Ae2Ov9/PPPmtvT0tI075WldevWaN26NZKTk1W/33vvvQCA5cuX4+2334bb7VZtT0pKQl5eHtauXauZI/Do0aOm3gtBEARhDZskSVJDF4IgCIIgiODz7LPPYvHixdi9ezdsNltDF0fI5ZdfjvLycrz11lsNXRSCIIhmBa3RIwiCIIhmyogRI7Bv3z588cUXDV0UIadOncI777yDkSNHNnRRCIIgmh3k0SMIgiCIZsxFF12EtWvX4v7778egQYPQvXt3xMTENFh5PB4Pfv/9d2zfvh133nknSkpKsHfv3kaTBJ4gCKK5QB49giAIgmjGvPLKK5g5cyZuuOEGDBo0CBdeeGGDlufFF19EXl4eZsyYgRYtWuDbb78lI48gCCIEkEePIAiCIM4AysrKsGPHDsTHx6N9+/YNVo7i4mJs3rwZnTp1QqtWrRqsHARBEM0dMvQIgiAIgiAIgiCaGRS6SRAEQRAEQRAE0cwgQ48gCIIgCIIgCKKZQYYeQRAEQRAEQRBEM4MMPYIgCIIgCIIgiGYGGXoEQRAEQRAEQRDNDDL0CIIgCIIgCIIgmhlk6BEEQRAEQRAEQTQzyNAjCIIgCIIgCIJoZvw/f17DufcS08wAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x621 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Wait for the sequencer to stop with a timeout period of one minute.\n",
    "module.get_acquisition_status(0)\n",
    "\n",
    "# Move acquisition data from temporary memory to acquisition list.\n",
    "module.store_scope_acquisition(0, \"non_weighed\")\n",
    "\n",
    "# Get acquisition list from instrument.\n",
    "non_weighed_acq = module.get_acquisitions(0)[\"non_weighed\"]\n",
    "\n",
    "# Plot acquired signal on both inputs.\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "ax.plot(non_weighed_acq[\"acquisition\"][\"scope\"][\"path0\"][\"data\"][0:1000])\n",
    "ax.plot(non_weighed_acq[\"acquisition\"][\"scope\"][\"path1\"][\"data\"][0:1000])\n",
    "ax.set_xlabel(\"Time (ns)\")\n",
    "ax.set_ylabel(\"Relative amplitude\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27dbda1e",
   "metadata": {},
   "source": [
    "To check if the integration results match what we expect, we need to divide the integration results by the integration length which was set through the\n",
    "corresponding QCoDeS parameter. Note that the 'valid' key of the dictionary indicates if the bin was actually set during the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4ad7c07e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:53.899537Z",
     "iopub.status.busy": "2025-05-07T16:53:53.899339Z",
     "iopub.status.idle": "2025-05-07T16:53:53.909267Z",
     "shell.execute_reply": "2025-05-07T16:53:53.908897Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'integration': {'path0': [0.2613287738153395,\n",
       "   0.2614460185637518,\n",
       "   0.2615124572545188,\n",
       "   0.26152418172936004,\n",
       "   0.26156668295065955,\n",
       "   0.2613370786516854,\n",
       "   0.2615100146555936,\n",
       "   0.26147679531021006,\n",
       "   0.26150317537860285,\n",
       "   0.2613019052271617],\n",
       "  'path1': [0.2856038104543234,\n",
       "   0.2855158768930142,\n",
       "   0.28549975574010744,\n",
       "   0.2855569125549585,\n",
       "   0.28546555935515383,\n",
       "   0.28543820224719096,\n",
       "   0.2854865657059111,\n",
       "   0.285342940889106,\n",
       "   0.2855207620908647,\n",
       "   0.285419149975574]},\n",
       " 'threshold': [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],\n",
       " 'avg_cnt': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_len = module.sequencer0.integration_length_acq()\n",
    "bins = non_weighed_acq[\"acquisition\"][\"bins\"]\n",
    "bins[\"integration\"][\"path0\"] = [(val / int_len) for val in bins[\"integration\"][\"path0\"]]\n",
    "bins[\"integration\"][\"path1\"] = [(val / int_len) for val in bins[\"integration\"][\"path1\"]]\n",
    "bins"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58486194",
   "metadata": {},
   "source": [
    "Weighed acquisition\n",
    "-------------------\n",
    "\n",
    "In the following, we look into weighed integrations. This refers to integration with a weighting given by a particular weight that we specified earlier. This is equivalent to multiplying the acquired trace with a function (which specifies the weighting) and integrating the result.\n",
    "\n",
    "To do this, we will need to modify the sequence program slightly and reupload it. We will be using a gaussian weight to integrate over input path 0 and a sine weight to integrate over input path 1. The integration length of a weighed integration is determined by the weight length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5bd43f4e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:53.911178Z",
     "iopub.status.busy": "2025-05-07T16:53:53.911033Z",
     "iopub.status.idle": "2025-05-07T16:53:53.913372Z",
     "shell.execute_reply": "2025-05-07T16:53:53.913004Z"
    }
   },
   "outputs": [],
   "source": [
    "# Sequence program.\n",
    "seq_prog = \"\"\"\n",
    "      move            0,R0            #Loop iterator.\n",
    "      move            0,R1            #Weight for path 0.\n",
    "      move            1,R2            #Weight for path 1.\n",
    "      nop\n",
    "\n",
    "loop: acquire_weighed 1,R0,R1,R2,1200 #Acquire bins and store them in \"weighed\" acquisition.\n",
    "      add             R0,1,R0         #Increment iterator\n",
    "      nop                             #Wait a cycle for R0 to be available.\n",
    "      jlt             R0,10,@loop     #Run until number of iterations is done.\n",
    "\n",
    "      stop                            #Stop.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "607b1126",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:53.915249Z",
     "iopub.status.busy": "2025-05-07T16:53:53.915108Z",
     "iopub.status.idle": "2025-05-07T16:53:53.942750Z",
     "shell.execute_reply": "2025-05-07T16:53:53.942362Z"
    }
   },
   "outputs": [],
   "source": [
    "# Add sequence program, waveforms, weights and acquisitions to single dictionary and write to JSON file.\n",
    "sequence = {\n",
    "    \"waveforms\": waveforms_weights,\n",
    "    \"weights\": waveforms_weights,\n",
    "    \"acquisitions\": acquisitions,\n",
    "    \"program\": seq_prog,\n",
    "}\n",
    "with open(\"sequence.json\", \"w\", encoding=\"utf-8\") as file:\n",
    "    json.dump(sequence, file, indent=4)\n",
    "    file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "bc7f768a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:53.944871Z",
     "iopub.status.busy": "2025-05-07T16:53:53.944709Z",
     "iopub.status.idle": "2025-05-07T16:53:54.044238Z",
     "shell.execute_reply": "2025-05-07T16:53:54.043744Z"
    }
   },
   "outputs": [],
   "source": [
    "# Upload sequence.\n",
    "module.sequencer0.sequence(\"sequence.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4637003",
   "metadata": {},
   "source": [
    "Let's start the sequence and retrieve the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "3203a06f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:54.046731Z",
     "iopub.status.busy": "2025-05-07T16:53:54.046556Z",
     "iopub.status.idle": "2025-05-07T16:53:54.057484Z",
     "shell.execute_reply": "2025-05-07T16:53:54.057064Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, State: STOPPED, Info Flags: ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n"
     ]
    }
   ],
   "source": [
    "# Arm and start sequencer.\n",
    "module.arm_sequencer(0)  # Arm sequencer 0\n",
    "module.start_sequencer()  # Start all armed sequencers\n",
    "\n",
    "# Print status of sequencer.\n",
    "print(module.get_sequencer_status(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "eb3b02a7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:54.059669Z",
     "iopub.status.busy": "2025-05-07T16:53:54.059499Z",
     "iopub.status.idle": "2025-05-07T16:53:54.655979Z",
     "shell.execute_reply": "2025-05-07T16:53:54.655178Z"
    }
   },
   "outputs": [],
   "source": [
    "# Wait for the sequencer to stop with a timeout period of one minute.\n",
    "module.get_acquisition_status(0)\n",
    "\n",
    "# Get acquisition list from instrument.\n",
    "weighed_acq = module.get_acquisitions(0)[\"weighed\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c254a5c8",
   "metadata": {},
   "source": [
    "To check if the integration results match what we expect we need to divide the integration results by the integration length again. In this case the integration\n",
    "length is determined by the length of the weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f376673b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:54.659260Z",
     "iopub.status.busy": "2025-05-07T16:53:54.659056Z",
     "iopub.status.idle": "2025-05-07T16:53:54.664327Z",
     "shell.execute_reply": "2025-05-07T16:53:54.663904Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'integration': {'path0': [0.0784894086826377,\n",
       "   0.07848591721001666,\n",
       "   0.07852838088346747,\n",
       "   0.07852380434166092,\n",
       "   0.07856693902380525,\n",
       "   0.07851298785653253,\n",
       "   0.07856725722591244,\n",
       "   0.07848482617454165,\n",
       "   0.07850628691790791,\n",
       "   0.07848103559193985],\n",
       "  'path1': [-7.213482668764255e-05,\n",
       "   -1.0063141639633408e-07,\n",
       "   -1.7871025844613798e-06,\n",
       "   -6.552497341620271e-05,\n",
       "   -8.443930441973976e-05,\n",
       "   -6.653446960123787e-05,\n",
       "   2.4106196134846736e-05,\n",
       "   -3.048455737331161e-05,\n",
       "   4.054133497080138e-05,\n",
       "   -7.157956401060982e-06]},\n",
       " 'threshold': [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],\n",
       " 'avg_cnt': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_len = waveform_weight_length\n",
    "bins = weighed_acq[\"acquisition\"][\"bins\"]\n",
    "bins[\"integration\"][\"path0\"] = [(val / int_len) for val in bins[\"integration\"][\"path0\"]]\n",
    "bins[\"integration\"][\"path1\"] = [(val / int_len) for val in bins[\"integration\"][\"path1\"]]\n",
    "bins"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19f8d9be",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "Large number of bins\n",
    "--------------------\n",
    "The QRM supports up to 131072 bins. To show that, we need to change the program slightly. We will use the non-weighed acquisition program,\n",
    "however, we will now loop over the maximum number of acquisitions while storing each result in a separate bin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "22baf1c6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:54.667702Z",
     "iopub.status.busy": "2025-05-07T16:53:54.667407Z",
     "iopub.status.idle": "2025-05-07T16:53:54.670040Z",
     "shell.execute_reply": "2025-05-07T16:53:54.669640Z"
    }
   },
   "outputs": [],
   "source": [
    "# Sequence program.\n",
    "seq_prog = \"\"\"\n",
    "      move    0,R0            #Loop iterator.\n",
    "      nop\n",
    "\n",
    "loop: acquire 2,R0,1200       #Acquire bins and store them in \"large\" acquisition.\n",
    "      add     R0,1,R0         #Increment iterator\n",
    "      nop                     #Wait a cycle for R0 to be available.\n",
    "      jlt     R0,131072,@loop #Run until number of iterations is done.\n",
    "\n",
    "      stop                    #Stop.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "de2e7b8e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:54.672362Z",
     "iopub.status.busy": "2025-05-07T16:53:54.672218Z",
     "iopub.status.idle": "2025-05-07T16:53:54.678569Z",
     "shell.execute_reply": "2025-05-07T16:53:54.678139Z"
    }
   },
   "outputs": [],
   "source": [
    "# Add sequence program, waveforms, weights and acquisitions to single dictionary and write to JSON file.\n",
    "sequence = {\n",
    "    \"waveforms\": waveforms_weights,\n",
    "    \"weights\": waveforms_weights,\n",
    "    \"acquisitions\": acquisitions,\n",
    "    \"program\": seq_prog,\n",
    "}\n",
    "with open(\"sequence.json\", \"w\", encoding=\"utf-8\") as file:\n",
    "    json.dump(sequence, file, indent=4)\n",
    "    file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "fdd65533",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:54.681205Z",
     "iopub.status.busy": "2025-05-07T16:53:54.680971Z",
     "iopub.status.idle": "2025-05-07T16:53:54.780638Z",
     "shell.execute_reply": "2025-05-07T16:53:54.779508Z"
    }
   },
   "outputs": [],
   "source": [
    "# Upload sequence.\n",
    "module.sequencer0.sequence(\"sequence.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a4a1266",
   "metadata": {},
   "source": [
    "Let's start the sequence and retrieve the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "311dbf56",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:54.784592Z",
     "iopub.status.busy": "2025-05-07T16:53:54.784187Z",
     "iopub.status.idle": "2025-05-07T16:53:54.797981Z",
     "shell.execute_reply": "2025-05-07T16:53:54.796974Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, State: RUNNING, Info Flags: NONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n"
     ]
    }
   ],
   "source": [
    "# Arm and start sequencer.\n",
    "module.arm_sequencer(0)\n",
    "module.start_sequencer()\n",
    "\n",
    "# Print status of sequencer.\n",
    "print(module.get_sequencer_status(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ecaefe0d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:54.801616Z",
     "iopub.status.busy": "2025-05-07T16:53:54.801220Z",
     "iopub.status.idle": "2025-05-07T16:53:55.550994Z",
     "shell.execute_reply": "2025-05-07T16:53:55.549395Z"
    }
   },
   "outputs": [],
   "source": [
    "# Wait for the sequencer to stop with a timeout period of one minute.\n",
    "module.get_acquisition_status(0, timeout=1)\n",
    "\n",
    "# Get acquisition list from instrument.\n",
    "large_acq = module.get_acquisitions(0)[\"large\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f863215",
   "metadata": {},
   "source": [
    "Since the number of bins is now too large to simply print, we will check the number of bins and we will check the bins for NaN values which indicate that a bin is not written."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "07c46485",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:55.554887Z",
     "iopub.status.busy": "2025-05-07T16:53:55.554602Z",
     "iopub.status.idle": "2025-05-07T16:53:55.581721Z",
     "shell.execute_reply": "2025-05-07T16:53:55.580580Z"
    },
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of bins: 131072\n"
     ]
    }
   ],
   "source": [
    "int_len = module.sequencer0.integration_length_acq()\n",
    "bins = large_acq[\"acquisition\"][\"bins\"]\n",
    "bins[\"integration\"][\"path0\"] = [(val / int_len) for val in bins[\"integration\"][\"path0\"]]\n",
    "bins[\"integration\"][\"path1\"] = [(val / int_len) for val in bins[\"integration\"][\"path1\"]]\n",
    "\n",
    "print(\"Number of bins: {}\".format(len(bins[\"avg_cnt\"])))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3510c7b3",
   "metadata": {},
   "source": [
    "We will also plot the integration results in every bin to visualize the contents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "0f55f8a5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:55.584974Z",
     "iopub.status.busy": "2025-05-07T16:53:55.584776Z",
     "iopub.status.idle": "2025-05-07T16:53:55.744185Z",
     "shell.execute_reply": "2025-05-07T16:53:55.742906Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x621 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot bins\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "ax.plot(bins[\"integration\"][\"path0\"])\n",
    "ax.plot(bins[\"integration\"][\"path1\"])\n",
    "ax.set_xlabel(\"Bin index\")\n",
    "ax.set_ylabel(\"Relative amplitude\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "280439a8",
   "metadata": {},
   "source": [
    "Averaging\n",
    "--------------------\n",
    "\n",
    "As you may have noticed, the acquisition results also contain an average counter. This average counter reflects the number of times a bin has been averaged during the sequence.\n",
    "Each time the sequencer writes to the same bin the results are automatically accumulated and the average counter is increased. Upon retrieval of the acquisition results, each\n",
    "result is divided by the average counter and therefore automatically averaged. To show this we will change the sequence one last time. This time we will average 10 bins a 1000\n",
    "times each."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "275fc1b0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:55.746827Z",
     "iopub.status.busy": "2025-05-07T16:53:55.746635Z",
     "iopub.status.idle": "2025-05-07T16:53:55.751091Z",
     "shell.execute_reply": "2025-05-07T16:53:55.750155Z"
    }
   },
   "outputs": [],
   "source": [
    "# Sequence program.\n",
    "seq_prog = \"\"\"\n",
    "      move    0,R1         #Average iterator.\n",
    "\n",
    "avg:  move    0,R0         #Bin iterator.\n",
    "      nop\n",
    "\n",
    "loop: acquire 3,R0,1200    #Acquire bins and store them in \"avg\" acquisition.\n",
    "      add     R0,1,R0      #Increment bin iterator\n",
    "      nop                  #Wait a cycle for R0 to be available.\n",
    "      jlt     R0,10,@loop  #Run until number of avg iterations is done.\n",
    "      add     R1,1,R1      #Increment avg iterator\n",
    "      nop                  #Wait a cycle for R1 to be available.\n",
    "      jlt     R1,1000,@avg #Run until number of average iterations is done.\n",
    "\n",
    "      stop                 #Stop.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "226e91b1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:55.753507Z",
     "iopub.status.busy": "2025-05-07T16:53:55.752979Z",
     "iopub.status.idle": "2025-05-07T16:53:55.761303Z",
     "shell.execute_reply": "2025-05-07T16:53:55.760367Z"
    }
   },
   "outputs": [],
   "source": [
    "# Add sequence program, waveforms, weights and acquisitions to single dictionary and write to JSON file.\n",
    "sequence = {\n",
    "    \"waveforms\": waveforms_weights,\n",
    "    \"weights\": waveforms_weights,\n",
    "    \"acquisitions\": acquisitions,\n",
    "    \"program\": seq_prog,\n",
    "}\n",
    "with open(\"sequence.json\", \"w\", encoding=\"utf-8\") as file:\n",
    "    json.dump(sequence, file, indent=4)\n",
    "    file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "5a421632",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:55.764281Z",
     "iopub.status.busy": "2025-05-07T16:53:55.763676Z",
     "iopub.status.idle": "2025-05-07T16:53:55.864921Z",
     "shell.execute_reply": "2025-05-07T16:53:55.863381Z"
    }
   },
   "outputs": [],
   "source": [
    "# Upload sequence.\n",
    "module.sequencer0.sequence(\"sequence.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e2febad",
   "metadata": {},
   "source": [
    "Let's start the sequence and retrieve the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c6ec564f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:55.869562Z",
     "iopub.status.busy": "2025-05-07T16:53:55.868552Z",
     "iopub.status.idle": "2025-05-07T16:53:55.883633Z",
     "shell.execute_reply": "2025-05-07T16:53:55.882280Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, State: RUNNING, Info Flags: NONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n"
     ]
    }
   ],
   "source": [
    "# Arm and start sequencer.\n",
    "module.arm_sequencer(0)\n",
    "module.start_sequencer()\n",
    "\n",
    "# Print status of sequencer.\n",
    "print(module.get_sequencer_status(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a2b3287",
   "metadata": {},
   "source": [
    "Note that the average count of each bin is now set to a 1000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "85c72440",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:55.887617Z",
     "iopub.status.busy": "2025-05-07T16:53:55.887009Z",
     "iopub.status.idle": "2025-05-07T16:53:56.523697Z",
     "shell.execute_reply": "2025-05-07T16:53:56.522191Z"
    }
   },
   "outputs": [],
   "source": [
    "# Wait for the sequencer to stop with a timeout period of one minute.\n",
    "module.get_acquisition_status(0)\n",
    "\n",
    "# Get acquisition list from instrument.\n",
    "avg_acq = module.get_acquisitions(0)[\"avg\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "5c8d4934",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:56.526591Z",
     "iopub.status.busy": "2025-05-07T16:53:56.526407Z",
     "iopub.status.idle": "2025-05-07T16:53:56.537419Z",
     "shell.execute_reply": "2025-05-07T16:53:56.536478Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'integration': {'path0': [0.2611187547630679,\n",
       "   0.26111750854909627,\n",
       "   0.2611230009770396,\n",
       "   0.2611192950659502,\n",
       "   0.26112305862237417,\n",
       "   0.26112230532486563,\n",
       "   0.2611224684904739,\n",
       "   0.26112194088910606,\n",
       "   0.261117018075232,\n",
       "   0.26111670835368833],\n",
       "  'path1': [0.28508252467024914,\n",
       "   0.2850853849535907,\n",
       "   0.28508051343429414,\n",
       "   0.28508342598925257,\n",
       "   0.2850817938446507,\n",
       "   0.28508950464093796,\n",
       "   0.28508061309233024,\n",
       "   0.2850843194919394,\n",
       "   0.2850837508549096,\n",
       "   0.2850811465559355]},\n",
       " 'threshold': [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],\n",
       " 'avg_cnt': [1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000]}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_len = module.sequencer0.integration_length_acq()\n",
    "bins = avg_acq[\"acquisition\"][\"bins\"]\n",
    "bins[\"integration\"][\"path0\"] = [(val / int_len) for val in bins[\"integration\"][\"path0\"]]\n",
    "bins[\"integration\"][\"path1\"] = [(val / int_len) for val in bins[\"integration\"][\"path1\"]]\n",
    "bins"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe81ffbf",
   "metadata": {},
   "source": [
    "Stop\n",
    "----\n",
    "\n",
    "Finally, let's stop the sequencers if they haven't already and close the instrument connection. One can also display a detailed snapshot containing the instrument parameters before\n",
    "closing the connection by uncommenting the corresponding lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "cb594f2e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-05-07T16:53:56.539354Z",
     "iopub.status.busy": "2025-05-07T16:53:56.539193Z",
     "iopub.status.idle": "2025-05-07T16:54:02.649755Z",
     "shell.execute_reply": "2025-05-07T16:54:02.647629Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, State: STOPPED, Info Flags: FORCED_STOP, ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n",
      "Status: OKAY, State: STOPPED, Info Flags: FORCED_STOP, Warning Flags: NONE, Error Flags: NONE, Log: []\n",
      "\n",
      "Snapshot:\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module4:\n",
      "\tparameter                    value\n",
      "--------------------------------------------------------------------------------\n",
      "connected                     :\tTrue \n",
      "in0_gain                      :\t-6 (dB)\n",
      "in0_offset                    :\t0 (V)\n",
      "in1_gain                      :\t-6 (dB)\n",
      "in1_offset                    :\t0 (V)\n",
      "marker0_exp0_config           :\tbypassed \n",
      "marker0_exp1_config           :\tbypassed \n",
      "marker0_exp2_config           :\tbypassed \n",
      "marker0_exp3_config           :\tbypassed \n",
      "marker0_fir_config            :\tbypassed \n",
      "marker0_inv_en                :\tFalse \n",
      "marker1_exp0_config           :\tbypassed \n",
      "marker1_exp1_config           :\tbypassed \n",
      "marker1_exp2_config           :\tbypassed \n",
      "marker1_exp3_config           :\tbypassed \n",
      "marker1_fir_config            :\tbypassed \n",
      "marker1_inv_en                :\tFalse \n",
      "marker2_exp0_config           :\tbypassed \n",
      "marker2_exp1_config           :\tbypassed \n",
      "marker2_exp2_config           :\tbypassed \n",
      "marker2_exp3_config           :\tbypassed \n",
      "marker2_fir_config            :\tbypassed \n",
      "marker2_inv_en                :\tFalse \n",
      "marker3_exp0_config           :\tbypassed \n",
      "marker3_exp1_config           :\tbypassed \n",
      "marker3_exp2_config           :\tbypassed \n",
      "marker3_exp3_config           :\tbypassed \n",
      "marker3_fir_config            :\tbypassed \n",
      "marker3_inv_en                :\tFalse \n",
      "out0_exp0_config              :\tbypassed \n",
      "out0_exp1_config              :\tbypassed \n",
      "out0_exp2_config              :\tbypassed \n",
      "out0_exp3_config              :\tbypassed \n",
      "out0_fir_config               :\tbypassed \n",
      "out0_latency                  :\t0 (s)\n",
      "out0_offset                   :\t0 (V)\n",
      "out1_exp0_config              :\tbypassed \n",
      "out1_exp1_config              :\tbypassed \n",
      "out1_exp2_config              :\tbypassed \n",
      "out1_exp3_config              :\tbypassed \n",
      "out1_fir_config               :\tbypassed \n",
      "out1_latency                  :\t0 (s)\n",
      "out1_offset                   :\t0 (V)\n",
      "present                       :\tTrue \n",
      "scope_acq_avg_mode_en_path0   :\tFalse \n",
      "scope_acq_avg_mode_en_path1   :\tFalse \n",
      "scope_acq_sequencer_select    :\t0 \n",
      "scope_acq_trigger_level_path0 :\t0 \n",
      "scope_acq_trigger_level_path1 :\t0 \n",
      "scope_acq_trigger_mode_path0  :\tsequencer \n",
      "scope_acq_trigger_mode_path1  :\tsequencer \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module4_sequencer0:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq_I                    :\tin0 \n",
      "connect_acq_Q                    :\tin1 \n",
      "connect_out0                     :\tI \n",
      "connect_out1                     :\tQ \n",
      "cont_mode_en_awg_path0           :\tFalse \n",
      "cont_mode_en_awg_path1           :\tFalse \n",
      "cont_mode_waveform_idx_awg_path0 :\t0 \n",
      "cont_mode_waveform_idx_awg_path1 :\t0 \n",
      "demod_en_acq                     :\tFalse \n",
      "gain_awg_path0                   :\t1 \n",
      "gain_awg_path1                   :\t1 \n",
      "integration_length_acq           :\t1000 \n",
      "marker_ovr_en                    :\tFalse \n",
      "marker_ovr_value                 :\t0 \n",
      "mixer_corr_gain_ratio            :\t1 \n",
      "mixer_corr_phase_offset_degree   :\t-0 \n",
      "mod_en_awg                       :\tFalse \n",
      "nco_freq                         :\t0 (Hz)\n",
      "nco_freq_cal_type_default        :\toff (Hz)\n",
      "nco_phase_offs                   :\t0 (Degrees)\n",
      "nco_prop_delay_comp              :\t0 (ns)\n",
      "nco_prop_delay_comp_en           :\tFalse (ns)\n",
      "offset_awg_path0                 :\t0.49998 \n",
      "offset_awg_path1                 :\t0.49998 \n",
      "sync_en                          :\tFalse \n",
      "thresholded_acq_marker_address   :\t1 \n",
      "thresholded_acq_marker_en        :\tFalse \n",
      "thresholded_acq_marker_invert    :\tFalse \n",
      "thresholded_acq_rotation         :\t0 (Degrees)\n",
      "thresholded_acq_threshold        :\t0 \n",
      "thresholded_acq_trigger_address  :\t1 \n",
      "thresholded_acq_trigger_en       :\tFalse \n",
      "thresholded_acq_trigger_invert   :\tFalse \n",
      "trigger10_count_threshold        :\t1 \n",
      "trigger10_threshold_invert       :\tFalse \n",
      "trigger11_count_threshold        :\t1 \n",
      "trigger11_threshold_invert       :\tFalse \n",
      "trigger12_count_threshold        :\t1 \n",
      "trigger12_threshold_invert       :\tFalse \n",
      "trigger13_count_threshold        :\t1 \n",
      "trigger13_threshold_invert       :\tFalse \n",
      "trigger14_count_threshold        :\t1 \n",
      "trigger14_threshold_invert       :\tFalse \n",
      "trigger15_count_threshold        :\t1 \n",
      "trigger15_threshold_invert       :\tFalse \n",
      "trigger1_count_threshold         :\t1 \n",
      "trigger1_threshold_invert        :\tFalse \n",
      "trigger2_count_threshold         :\t1 \n",
      "trigger2_threshold_invert        :\tFalse \n",
      "trigger3_count_threshold         :\t1 \n",
      "trigger3_threshold_invert        :\tFalse \n",
      "trigger4_count_threshold         :\t1 \n",
      "trigger4_threshold_invert        :\tFalse \n",
      "trigger5_count_threshold         :\t1 \n",
      "trigger5_threshold_invert        :\tFalse \n",
      "trigger6_count_threshold         :\t1 \n",
      "trigger6_threshold_invert        :\tFalse \n",
      "trigger7_count_threshold         :\t1 \n",
      "trigger7_threshold_invert        :\tFalse \n",
      "trigger8_count_threshold         :\t1 \n",
      "trigger8_threshold_invert        :\tFalse \n",
      "trigger9_count_threshold         :\t1 \n",
      "trigger9_threshold_invert        :\tFalse \n",
      "ttl_acq_auto_bin_incr_en         :\tFalse \n",
      "ttl_acq_input_select             :\t0 \n",
      "ttl_acq_threshold                :\t0 \n",
      "upsample_rate_awg_path0          :\t0 \n",
      "upsample_rate_awg_path1          :\t0 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module4_sequencer1:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq_I                    :\toff \n",
      "connect_acq_Q                    :\toff \n",
      "connect_out0                     :\toff \n",
      "connect_out1                     :\toff \n",
      "cont_mode_en_awg_path0           :\tFalse \n",
      "cont_mode_en_awg_path1           :\tFalse \n",
      "cont_mode_waveform_idx_awg_path0 :\t0 \n",
      "cont_mode_waveform_idx_awg_path1 :\t0 \n",
      "demod_en_acq                     :\tFalse \n",
      "gain_awg_path0                   :\t1 \n",
      "gain_awg_path1                   :\t1 \n",
      "integration_length_acq           :\t1024 \n",
      "marker_ovr_en                    :\tFalse \n",
      "marker_ovr_value                 :\t0 \n",
      "mixer_corr_gain_ratio            :\t1 \n",
      "mixer_corr_phase_offset_degree   :\t-0 \n",
      "mod_en_awg                       :\tFalse \n",
      "nco_freq                         :\t0 (Hz)\n",
      "nco_freq_cal_type_default        :\toff (Hz)\n",
      "nco_phase_offs                   :\t0 (Degrees)\n",
      "nco_prop_delay_comp              :\t0 (ns)\n",
      "nco_prop_delay_comp_en           :\tFalse (ns)\n",
      "offset_awg_path0                 :\t0 \n",
      "offset_awg_path1                 :\t0 \n",
      "sync_en                          :\tFalse \n",
      "thresholded_acq_marker_address   :\t1 \n",
      "thresholded_acq_marker_en        :\tFalse \n",
      "thresholded_acq_marker_invert    :\tFalse \n",
      "thresholded_acq_rotation         :\t0 (Degrees)\n",
      "thresholded_acq_threshold        :\t0 \n",
      "thresholded_acq_trigger_address  :\t1 \n",
      "thresholded_acq_trigger_en       :\tFalse \n",
      "thresholded_acq_trigger_invert   :\tFalse \n",
      "trigger10_count_threshold        :\t1 \n",
      "trigger10_threshold_invert       :\tFalse \n",
      "trigger11_count_threshold        :\t1 \n",
      "trigger11_threshold_invert       :\tFalse \n",
      "trigger12_count_threshold        :\t1 \n",
      "trigger12_threshold_invert       :\tFalse \n",
      "trigger13_count_threshold        :\t1 \n",
      "trigger13_threshold_invert       :\tFalse \n",
      "trigger14_count_threshold        :\t1 \n",
      "trigger14_threshold_invert       :\tFalse \n",
      "trigger15_count_threshold        :\t1 \n",
      "trigger15_threshold_invert       :\tFalse \n",
      "trigger1_count_threshold         :\t1 \n",
      "trigger1_threshold_invert        :\tFalse \n",
      "trigger2_count_threshold         :\t1 \n",
      "trigger2_threshold_invert        :\tFalse \n",
      "trigger3_count_threshold         :\t1 \n",
      "trigger3_threshold_invert        :\tFalse \n",
      "trigger4_count_threshold         :\t1 \n",
      "trigger4_threshold_invert        :\tFalse \n",
      "trigger5_count_threshold         :\t1 \n",
      "trigger5_threshold_invert        :\tFalse \n",
      "trigger6_count_threshold         :\t1 \n",
      "trigger6_threshold_invert        :\tFalse \n",
      "trigger7_count_threshold         :\t1 \n",
      "trigger7_threshold_invert        :\tFalse \n",
      "trigger8_count_threshold         :\t1 \n",
      "trigger8_threshold_invert        :\tFalse \n",
      "trigger9_count_threshold         :\t1 \n",
      "trigger9_threshold_invert        :\tFalse \n",
      "ttl_acq_auto_bin_incr_en         :\tFalse \n",
      "ttl_acq_input_select             :\t0 \n",
      "ttl_acq_threshold                :\t0 \n",
      "upsample_rate_awg_path0          :\t0 \n",
      "upsample_rate_awg_path1          :\t0 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module4_sequencer2:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq_I                    :\toff \n",
      "connect_acq_Q                    :\toff \n",
      "connect_out0                     :\toff \n",
      "connect_out1                     :\toff \n",
      "cont_mode_en_awg_path0           :\tFalse \n",
      "cont_mode_en_awg_path1           :\tFalse \n",
      "cont_mode_waveform_idx_awg_path0 :\t0 \n",
      "cont_mode_waveform_idx_awg_path1 :\t0 \n",
      "demod_en_acq                     :\tFalse \n",
      "gain_awg_path0                   :\t1 \n",
      "gain_awg_path1                   :\t1 \n",
      "integration_length_acq           :\t1024 \n",
      "marker_ovr_en                    :\tFalse \n",
      "marker_ovr_value                 :\t0 \n",
      "mixer_corr_gain_ratio            :\t1 \n",
      "mixer_corr_phase_offset_degree   :\t-0 \n",
      "mod_en_awg                       :\tFalse \n",
      "nco_freq                         :\t0 (Hz)\n",
      "nco_freq_cal_type_default        :\toff (Hz)\n",
      "nco_phase_offs                   :\t0 (Degrees)\n",
      "nco_prop_delay_comp              :\t0 (ns)\n",
      "nco_prop_delay_comp_en           :\tFalse (ns)\n",
      "offset_awg_path0                 :\t0 \n",
      "offset_awg_path1                 :\t0 \n",
      "sync_en                          :\tFalse \n",
      "thresholded_acq_marker_address   :\t1 \n",
      "thresholded_acq_marker_en        :\tFalse \n",
      "thresholded_acq_marker_invert    :\tFalse \n",
      "thresholded_acq_rotation         :\t0 (Degrees)\n",
      "thresholded_acq_threshold        :\t0 \n",
      "thresholded_acq_trigger_address  :\t1 \n",
      "thresholded_acq_trigger_en       :\tFalse \n",
      "thresholded_acq_trigger_invert   :\tFalse \n",
      "trigger10_count_threshold        :\t1 \n",
      "trigger10_threshold_invert       :\tFalse \n",
      "trigger11_count_threshold        :\t1 \n",
      "trigger11_threshold_invert       :\tFalse \n",
      "trigger12_count_threshold        :\t1 \n",
      "trigger12_threshold_invert       :\tFalse \n",
      "trigger13_count_threshold        :\t1 \n",
      "trigger13_threshold_invert       :\tFalse \n",
      "trigger14_count_threshold        :\t1 \n",
      "trigger14_threshold_invert       :\tFalse \n",
      "trigger15_count_threshold        :\t1 \n",
      "trigger15_threshold_invert       :\tFalse \n",
      "trigger1_count_threshold         :\t1 \n",
      "trigger1_threshold_invert        :\tFalse \n",
      "trigger2_count_threshold         :\t1 \n",
      "trigger2_threshold_invert        :\tFalse \n",
      "trigger3_count_threshold         :\t1 \n",
      "trigger3_threshold_invert        :\tFalse \n",
      "trigger4_count_threshold         :\t1 \n",
      "trigger4_threshold_invert        :\tFalse \n",
      "trigger5_count_threshold         :\t1 \n",
      "trigger5_threshold_invert        :\tFalse \n",
      "trigger6_count_threshold         :\t1 \n",
      "trigger6_threshold_invert        :\tFalse \n",
      "trigger7_count_threshold         :\t1 \n",
      "trigger7_threshold_invert        :\tFalse \n",
      "trigger8_count_threshold         :\t1 \n",
      "trigger8_threshold_invert        :\tFalse \n",
      "trigger9_count_threshold         :\t1 \n",
      "trigger9_threshold_invert        :\tFalse \n",
      "ttl_acq_auto_bin_incr_en         :\tFalse \n",
      "ttl_acq_input_select             :\t0 \n",
      "ttl_acq_threshold                :\t0 \n",
      "upsample_rate_awg_path0          :\t0 \n",
      "upsample_rate_awg_path1          :\t0 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module4_sequencer3:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq_I                    :\toff \n",
      "connect_acq_Q                    :\toff \n",
      "connect_out0                     :\toff \n",
      "connect_out1                     :\toff \n",
      "cont_mode_en_awg_path0           :\tFalse \n",
      "cont_mode_en_awg_path1           :\tFalse \n",
      "cont_mode_waveform_idx_awg_path0 :\t0 \n",
      "cont_mode_waveform_idx_awg_path1 :\t0 \n",
      "demod_en_acq                     :\tFalse \n",
      "gain_awg_path0                   :\t1 \n",
      "gain_awg_path1                   :\t1 \n",
      "integration_length_acq           :\t1024 \n",
      "marker_ovr_en                    :\tFalse \n",
      "marker_ovr_value                 :\t0 \n",
      "mixer_corr_gain_ratio            :\t1 \n",
      "mixer_corr_phase_offset_degree   :\t-0 \n",
      "mod_en_awg                       :\tFalse \n",
      "nco_freq                         :\t0 (Hz)\n",
      "nco_freq_cal_type_default        :\toff (Hz)\n",
      "nco_phase_offs                   :\t0 (Degrees)\n",
      "nco_prop_delay_comp              :\t0 (ns)\n",
      "nco_prop_delay_comp_en           :\tFalse (ns)\n",
      "offset_awg_path0                 :\t0 \n",
      "offset_awg_path1                 :\t0 \n",
      "sync_en                          :\tFalse \n",
      "thresholded_acq_marker_address   :\t1 \n",
      "thresholded_acq_marker_en        :\tFalse \n",
      "thresholded_acq_marker_invert    :\tFalse \n",
      "thresholded_acq_rotation         :\t0 (Degrees)\n",
      "thresholded_acq_threshold        :\t0 \n",
      "thresholded_acq_trigger_address  :\t1 \n",
      "thresholded_acq_trigger_en       :\tFalse \n",
      "thresholded_acq_trigger_invert   :\tFalse \n",
      "trigger10_count_threshold        :\t1 \n",
      "trigger10_threshold_invert       :\tFalse \n",
      "trigger11_count_threshold        :\t1 \n",
      "trigger11_threshold_invert       :\tFalse \n",
      "trigger12_count_threshold        :\t1 \n",
      "trigger12_threshold_invert       :\tFalse \n",
      "trigger13_count_threshold        :\t1 \n",
      "trigger13_threshold_invert       :\tFalse \n",
      "trigger14_count_threshold        :\t1 \n",
      "trigger14_threshold_invert       :\tFalse \n",
      "trigger15_count_threshold        :\t1 \n",
      "trigger15_threshold_invert       :\tFalse \n",
      "trigger1_count_threshold         :\t1 \n",
      "trigger1_threshold_invert        :\tFalse \n",
      "trigger2_count_threshold         :\t1 \n",
      "trigger2_threshold_invert        :\tFalse \n",
      "trigger3_count_threshold         :\t1 \n",
      "trigger3_threshold_invert        :\tFalse \n",
      "trigger4_count_threshold         :\t1 \n",
      "trigger4_threshold_invert        :\tFalse \n",
      "trigger5_count_threshold         :\t1 \n",
      "trigger5_threshold_invert        :\tFalse \n",
      "trigger6_count_threshold         :\t1 \n",
      "trigger6_threshold_invert        :\tFalse \n",
      "trigger7_count_threshold         :\t1 \n",
      "trigger7_threshold_invert        :\tFalse \n",
      "trigger8_count_threshold         :\t1 \n",
      "trigger8_threshold_invert        :\tFalse \n",
      "trigger9_count_threshold         :\t1 \n",
      "trigger9_threshold_invert        :\tFalse \n",
      "ttl_acq_auto_bin_incr_en         :\tFalse \n",
      "ttl_acq_input_select             :\t0 \n",
      "ttl_acq_threshold                :\t0 \n",
      "upsample_rate_awg_path0          :\t0 \n",
      "upsample_rate_awg_path1          :\t0 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module4_sequencer4:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq_I                    :\toff \n",
      "connect_acq_Q                    :\toff \n",
      "connect_out0                     :\toff \n",
      "connect_out1                     :\toff \n",
      "cont_mode_en_awg_path0           :\tFalse \n",
      "cont_mode_en_awg_path1           :\tFalse \n",
      "cont_mode_waveform_idx_awg_path0 :\t0 \n",
      "cont_mode_waveform_idx_awg_path1 :\t0 \n",
      "demod_en_acq                     :\tFalse \n",
      "gain_awg_path0                   :\t1 \n",
      "gain_awg_path1                   :\t1 \n",
      "integration_length_acq           :\t1024 \n",
      "marker_ovr_en                    :\tFalse \n",
      "marker_ovr_value                 :\t0 \n",
      "mixer_corr_gain_ratio            :\t1 \n",
      "mixer_corr_phase_offset_degree   :\t-0 \n",
      "mod_en_awg                       :\tFalse \n",
      "nco_freq                         :\t0 (Hz)\n",
      "nco_freq_cal_type_default        :\toff (Hz)\n",
      "nco_phase_offs                   :\t0 (Degrees)\n",
      "nco_prop_delay_comp              :\t0 (ns)\n",
      "nco_prop_delay_comp_en           :\tFalse (ns)\n",
      "offset_awg_path0                 :\t0 \n",
      "offset_awg_path1                 :\t0 \n",
      "sync_en                          :\tFalse \n",
      "thresholded_acq_marker_address   :\t1 \n",
      "thresholded_acq_marker_en        :\tFalse \n",
      "thresholded_acq_marker_invert    :\tFalse \n",
      "thresholded_acq_rotation         :\t0 (Degrees)\n",
      "thresholded_acq_threshold        :\t0 \n",
      "thresholded_acq_trigger_address  :\t1 \n",
      "thresholded_acq_trigger_en       :\tFalse \n",
      "thresholded_acq_trigger_invert   :\tFalse \n",
      "trigger10_count_threshold        :\t1 \n",
      "trigger10_threshold_invert       :\tFalse \n",
      "trigger11_count_threshold        :\t1 \n",
      "trigger11_threshold_invert       :\tFalse \n",
      "trigger12_count_threshold        :\t1 \n",
      "trigger12_threshold_invert       :\tFalse \n",
      "trigger13_count_threshold        :\t1 \n",
      "trigger13_threshold_invert       :\tFalse \n",
      "trigger14_count_threshold        :\t1 \n",
      "trigger14_threshold_invert       :\tFalse \n",
      "trigger15_count_threshold        :\t1 \n",
      "trigger15_threshold_invert       :\tFalse \n",
      "trigger1_count_threshold         :\t1 \n",
      "trigger1_threshold_invert        :\tFalse \n",
      "trigger2_count_threshold         :\t1 \n",
      "trigger2_threshold_invert        :\tFalse \n",
      "trigger3_count_threshold         :\t1 \n",
      "trigger3_threshold_invert        :\tFalse \n",
      "trigger4_count_threshold         :\t1 \n",
      "trigger4_threshold_invert        :\tFalse \n",
      "trigger5_count_threshold         :\t1 \n",
      "trigger5_threshold_invert        :\tFalse \n",
      "trigger6_count_threshold         :\t1 \n",
      "trigger6_threshold_invert        :\tFalse \n",
      "trigger7_count_threshold         :\t1 \n",
      "trigger7_threshold_invert        :\tFalse \n",
      "trigger8_count_threshold         :\t1 \n",
      "trigger8_threshold_invert        :\tFalse \n",
      "trigger9_count_threshold         :\t1 \n",
      "trigger9_threshold_invert        :\tFalse \n",
      "ttl_acq_auto_bin_incr_en         :\tFalse \n",
      "ttl_acq_input_select             :\t0 \n",
      "ttl_acq_threshold                :\t0 \n",
      "upsample_rate_awg_path0          :\t0 \n",
      "upsample_rate_awg_path1          :\t0 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster0_module4_sequencer5:\n",
      "\tparameter                       value\n",
      "--------------------------------------------------------------------------------\n",
      "connect_acq_I                    :\toff \n",
      "connect_acq_Q                    :\toff \n",
      "connect_out0                     :\toff \n",
      "connect_out1                     :\toff \n",
      "cont_mode_en_awg_path0           :\tFalse \n",
      "cont_mode_en_awg_path1           :\tFalse \n",
      "cont_mode_waveform_idx_awg_path0 :\t0 \n",
      "cont_mode_waveform_idx_awg_path1 :\t0 \n",
      "demod_en_acq                     :\tFalse \n",
      "gain_awg_path0                   :\t1 \n",
      "gain_awg_path1                   :\t1 \n",
      "integration_length_acq           :\t1024 \n",
      "marker_ovr_en                    :\tFalse \n",
      "marker_ovr_value                 :\t0 \n",
      "mixer_corr_gain_ratio            :\t1 \n",
      "mixer_corr_phase_offset_degree   :\t-0 \n",
      "mod_en_awg                       :\tFalse \n",
      "nco_freq                         :\t0 (Hz)\n",
      "nco_freq_cal_type_default        :\toff (Hz)\n",
      "nco_phase_offs                   :\t0 (Degrees)\n",
      "nco_prop_delay_comp              :\t0 (ns)\n",
      "nco_prop_delay_comp_en           :\tFalse (ns)\n",
      "offset_awg_path0                 :\t0 \n",
      "offset_awg_path1                 :\t0 \n",
      "sync_en                          :\tFalse \n",
      "thresholded_acq_marker_address   :\t1 \n",
      "thresholded_acq_marker_en        :\tFalse \n",
      "thresholded_acq_marker_invert    :\tFalse \n",
      "thresholded_acq_rotation         :\t0 (Degrees)\n",
      "thresholded_acq_threshold        :\t0 \n",
      "thresholded_acq_trigger_address  :\t1 \n",
      "thresholded_acq_trigger_en       :\tFalse \n",
      "thresholded_acq_trigger_invert   :\tFalse \n",
      "trigger10_count_threshold        :\t1 \n",
      "trigger10_threshold_invert       :\tFalse \n",
      "trigger11_count_threshold        :\t1 \n",
      "trigger11_threshold_invert       :\tFalse \n",
      "trigger12_count_threshold        :\t1 \n",
      "trigger12_threshold_invert       :\tFalse \n",
      "trigger13_count_threshold        :\t1 \n",
      "trigger13_threshold_invert       :\tFalse \n",
      "trigger14_count_threshold        :\t1 \n",
      "trigger14_threshold_invert       :\tFalse \n",
      "trigger15_count_threshold        :\t1 \n",
      "trigger15_threshold_invert       :\tFalse \n",
      "trigger1_count_threshold         :\t1 \n",
      "trigger1_threshold_invert        :\tFalse \n",
      "trigger2_count_threshold         :\t1 \n",
      "trigger2_threshold_invert        :\tFalse \n",
      "trigger3_count_threshold         :\t1 \n",
      "trigger3_threshold_invert        :\tFalse \n",
      "trigger4_count_threshold         :\t1 \n",
      "trigger4_threshold_invert        :\tFalse \n",
      "trigger5_count_threshold         :\t1 \n",
      "trigger5_threshold_invert        :\tFalse \n",
      "trigger6_count_threshold         :\t1 \n",
      "trigger6_threshold_invert        :\tFalse \n",
      "trigger7_count_threshold         :\t1 \n",
      "trigger7_threshold_invert        :\tFalse \n",
      "trigger8_count_threshold         :\t1 \n",
      "trigger8_threshold_invert        :\tFalse \n",
      "trigger9_count_threshold         :\t1 \n",
      "trigger9_threshold_invert        :\tFalse \n",
      "ttl_acq_auto_bin_incr_en         :\tFalse \n",
      "ttl_acq_input_select             :\t0 \n",
      "ttl_acq_threshold                :\t0 \n",
      "upsample_rate_awg_path0          :\t0 \n",
      "upsample_rate_awg_path1          :\t0 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: OKAY, Flags: NONE, Slot flags: NONE\n"
     ]
    }
   ],
   "source": [
    "# Stop both sequencers.\n",
    "module.stop_sequencer()\n",
    "\n",
    "# Print status of both sequencers (should now say it is stopped).\n",
    "print(module.get_sequencer_status(0))\n",
    "print(module.get_sequencer_status(1))\n",
    "print()\n",
    "\n",
    "# Print an overview of the instrument parameters.\n",
    "print(\"Snapshot:\")\n",
    "module.print_readable_snapshot(update=True)\n",
    "\n",
    "# Reset the cluster\n",
    "cluster.reset()\n",
    "print(cluster.get_system_status())"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "all",
   "notebook_metadata_filter": "files_to_bundle_in_zip_file,is_demo,execute"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}