diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 00000000..38289fb8
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,11 @@
+### PR Description
+
+<!-- Describe the PR's general purpose -->
+
+### Some notes
+
+- [ ] Please make sure that you placed the files in an appropriate folder
+- [ ] And that the files have indicative names.
+
+- [ ] Please note that Classiq runs automatic code linting, which may minorly alter some files.
+  - [ ] If you're familiar with `pre-commit`, you may run `pre-commit install`, and then at each commit, your files will be altered in a similar way
diff --git a/.github/workflows/Lint.yml b/.github/workflows/Lint.yml
new file mode 100644
index 00000000..867eccea
--- /dev/null
+++ b/.github/workflows/Lint.yml
@@ -0,0 +1,23 @@
+name: Lint
+
+on: [push, workflow_dispatch]
+
+permissions:
+  contents: read
+
+env:
+  FORCE_COLOR: 1
+  RUFF_OUTPUT_FORMAT: github
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - uses: pre-commit/action@v3.0.1
+        if: false
diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml
new file mode 100644
index 00000000..6b81f7b4
--- /dev/null
+++ b/.github/workflows/run_tests.yml
@@ -0,0 +1,48 @@
+name: "Test notebooks"
+
+on: [pull_request, workflow_dispatch]
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: "Install dependencies"
+        run: |
+          python -m pip install -U -r requirements.txt
+          python -m pip install -U -r requirements_tests.txt
+
+      - name: Get changed files - all
+        id: changed-files-all
+        uses: tj-actions/changed-files@v44
+      - name: Get changed files - ipynb
+        id: changed-files-ipynb
+        uses: tj-actions/changed-files@v44
+        with:
+          files: |
+            **.ipynb
+
+      - name: Set environment variables
+        run: |
+          if [ "${{ github.event_name }}" == 'pull_request' ]; then
+            echo "SHOULD_TEST_ALL_FILES=false" >> $GITHUB_ENV
+            echo "HAS_ANY_FILE_CHANGED=${{ steps.changed-files-all.outputs.any_changed }}" >> $GITHUB_ENV
+            echo "LIST_OF_FILE_CHANGED=${{ steps.changed-files-all.outputs.all_changed_files }}" >> $GITHUB_ENV
+            echo "HAS_ANY_IPYNB_CHANGED=${{ steps.changed-files-ipynb.outputs.any_changed }}" >> $GITHUB_ENV
+            echo "LIST_OF_IPYNB_CHANGED=${{ steps.changed-files-ipynb.outputs.all_changed_files }}" >> $GITHUB_ENV
+          elif [ "${{ github.event_name }}" == 'workflow_dispatch' ]; then
+            echo "SHOULD_TEST_ALL_FILES=true" >> $GITHUB_ENV
+            echo "HAS_ANY_FILE_CHANGED=None" >> $GITHUB_ENV
+            echo "LIST_OF_FILE_CHANGED=None" >> $GITHUB_ENV
+            echo "HAS_ANY_IPYNB_CHANGED=None" >> $GITHUB_ENV
+            echo "LIST_OF_IPYNB_CHANGED=None" >> $GITHUB_ENV
+          fi
+
+      - name: "Run tests"
+        run: python -m pytest tests
+        env:
+          JUPYTER_PLATFORM_DIRS: "1"
diff --git a/algorithms/algebraic/discrete_log/discrete_log.ipynb b/algorithms/algebraic/discrete_log/discrete_log.ipynb
index 4f119b3d..960d8353 100644
--- a/algorithms/algebraic/discrete_log/discrete_log.ipynb
+++ b/algorithms/algebraic/discrete_log/discrete_log.ipynb
@@ -65,7 +65,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 5,
    "id": "2bbc4aa3-8f61-433d-a1cd-c58df445a2fd",
    "metadata": {
     "execution": {
@@ -92,20 +92,20 @@
     "\n",
     "@qfunc\n",
     "def discrete_log_oracle(\n",
-    "    g: CInt,\n",
-    "    x: CInt,\n",
-    "    N: CInt,\n",
+    "    g_generator: CInt,\n",
+    "    x_element: CInt,\n",
+    "    N_modulus: CInt,\n",
     "    order: CInt,\n",
     "    x1: QArray[QBit],\n",
     "    x2: QArray[QBit],\n",
     "    func_res: Output[QArray[QBit]],\n",
     ") -> None:\n",
     "\n",
-    "    allocate(ceiling(log(N, 2)), func_res)\n",
+    "    allocate(ceiling(log(N_modulus, 2)), func_res)\n",
     "\n",
     "    inplace_prepare_int(1, func_res)\n",
-    "    modular_exp(N, x, func_res, x1)\n",
-    "    modular_exp(N, g, func_res, x2)"
+    "    modular_exp(N_modulus, x_element, func_res, x1)\n",
+    "    modular_exp(N_modulus, g_generator, func_res, x2)"
    ]
   },
   {
@@ -122,7 +122,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 6,
    "id": "d7fb63ac-023d-40ac-9395-13c1274d446f",
    "metadata": {
     "execution": {
@@ -140,9 +140,9 @@
     "\n",
     "@qfunc\n",
     "def discrete_log(\n",
-    "    g: CInt,\n",
-    "    x: CInt,\n",
-    "    N: CInt,\n",
+    "    g_generator: CInt,\n",
+    "    x_element: CInt,\n",
+    "    N_modulus: CInt,\n",
     "    order: CInt,\n",
     "    x1: Output[QArray[QBit]],\n",
     "    x2: Output[QArray[QBit]],\n",
@@ -155,7 +155,7 @@
     "    hadamard_transform(x1)\n",
     "    hadamard_transform(x2)\n",
     "\n",
-    "    discrete_log_oracle(g, x, N, order, x1, x2, func_res)\n",
+    "    discrete_log_oracle(g_generator, x_element, N_modulus, order, x1, x2, func_res)\n",
     "\n",
     "    invert(lambda: qft(x1))\n",
     "    invert(lambda: qft(x2))"
@@ -209,7 +209,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 7,
    "id": "8ef24bb4-b063-42d6-a5ea-ddcd5310ae13",
    "metadata": {
     "execution": {
@@ -224,8 +224,8 @@
     "from classiq import Constraints, create_model\n",
     "\n",
     "MODULU_NUM = 5\n",
-    "G = 3\n",
-    "X = 2\n",
+    "G_GENERATOR = 3\n",
+    "X_LOGARITHM = 2\n",
     "ORDER = MODULU_NUM - 1  # as 5 is prime\n",
     "\n",
     "\n",
@@ -235,12 +235,12 @@
     "    x2: Output[QNum],\n",
     "    func_res: Output[QNum],\n",
     ") -> None:\n",
-    "    discrete_log(G, X, MODULU_NUM, ORDER, x1, x2, func_res)"
+    "    discrete_log(G_GENERATOR, X_LOGARITHM, MODULU_NUM, ORDER, x1, x2, func_res)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 8,
    "id": "8e9d0b08-f3f8-4e95-a468-bfeec010d97c",
    "metadata": {
     "execution": {
@@ -272,7 +272,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "0aef2760-aa9a-4710-8c60-08333a0a9b0b",
    "metadata": {
     "execution": {
diff --git a/algorithms/algebraic/discrete_log/discrete_log.qmod b/algorithms/algebraic/discrete_log/discrete_log.qmod
index 51c9e0f4..d2b4ae34 100644
--- a/algorithms/algebraic/discrete_log/discrete_log.qmod
+++ b/algorithms/algebraic/discrete_log/discrete_log.qmod
@@ -1,16 +1,16 @@
-qfunc discrete_log_oracle<g: int, x: int, N: int, order: int>(x1: qbit[], x2: qbit[], output func_res: qbit[]) {
-  allocate<ceiling(log(N, 2))>(func_res);
+qfunc discrete_log_oracle<g_generator: int, x_element: int, N_modulus: int, order: int>(x1: qbit[], x2: qbit[], output func_res: qbit[]) {
+  allocate<ceiling(log(N_modulus, 2))>(func_res);
   inplace_prepare_int<1>(func_res);
-  modular_exp<N, x>(func_res, x1);
-  modular_exp<N, g>(func_res, x2);
+  modular_exp<N_modulus, x_element>(func_res, x1);
+  modular_exp<N_modulus, g_generator>(func_res, x2);
 }
 
-qfunc discrete_log<g: int, x: int, N: int, order: int>(output x1: qbit[], output x2: qbit[], output func_res: qbit[]) {
+qfunc discrete_log<g_generator: int, x_element: int, N_modulus: int, order: int>(output x1: qbit[], output x2: qbit[], output func_res: qbit[]) {
   allocate<ceiling(log(order, 2))>(x1);
   allocate<ceiling(log(order, 2))>(x2);
   hadamard_transform(x1);
   hadamard_transform(x2);
-  discrete_log_oracle<g, x, N, order>(x1, x2, func_res);
+  discrete_log_oracle<g_generator, x_element, N_modulus, order>(x1, x2, func_res);
   invert {
     qft(x1);
   }
@@ -22,3 +22,4 @@ qfunc discrete_log<g: int, x: int, N: int, order: int>(output x1: qbit[], output
 qfunc main(output x1: qnum, output x2: qnum, output func_res: qnum) {
   discrete_log<3, 2, 5, 4>(x1, x2, func_res);
 }
+
diff --git a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.qmod b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.qmod
new file mode 100644
index 00000000..afa2dbc1
--- /dev/null
+++ b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.qmod
@@ -0,0 +1,12 @@
+qfunc my_mcx(ctrl: qbit[], target: qbit) {
+  control (ctrl) {
+    X(target);
+  }
+}
+
+qfunc main(output ctrl: qbit[], output target: qbit) {
+  allocate<12>(ctrl);
+  allocate<1>(target);
+  my_mcx(ctrl, target);
+}
+
diff --git a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.synthesis_options.json b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.synthesis_options.json
new file mode 100644
index 00000000..eccba304
--- /dev/null
+++ b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.synthesis_options.json
@@ -0,0 +1,233 @@
+{
+  "constraints": {
+    "max_width": 18,
+    "optimization_parameter": "cx"
+  },
+  "preferences": {
+    "custom_hardware_settings": {
+      "basis_gates": [
+        "cx",
+        "u"
+      ],
+      "connectivity_map": [
+        [
+          0,
+          1
+        ],
+        [
+          1,
+          2
+        ],
+        [
+          2,
+          3
+        ],
+        [
+          3,
+          4
+        ],
+        [
+          4,
+          5
+        ],
+        [
+          6,
+          7
+        ],
+        [
+          7,
+          8
+        ],
+        [
+          8,
+          9
+        ],
+        [
+          9,
+          10
+        ],
+        [
+          10,
+          11
+        ],
+        [
+          12,
+          13
+        ],
+        [
+          13,
+          14
+        ],
+        [
+          14,
+          15
+        ],
+        [
+          15,
+          16
+        ],
+        [
+          16,
+          17
+        ],
+        [
+          0,
+          6
+        ],
+        [
+          6,
+          12
+        ],
+        [
+          1,
+          7
+        ],
+        [
+          7,
+          13
+        ],
+        [
+          2,
+          8
+        ],
+        [
+          8,
+          14
+        ],
+        [
+          3,
+          9
+        ],
+        [
+          9,
+          15
+        ],
+        [
+          4,
+          10
+        ],
+        [
+          10,
+          16
+        ],
+        [
+          5,
+          11
+        ],
+        [
+          11,
+          17
+        ],
+        [
+          1,
+          0
+        ],
+        [
+          2,
+          1
+        ],
+        [
+          3,
+          2
+        ],
+        [
+          4,
+          3
+        ],
+        [
+          5,
+          4
+        ],
+        [
+          7,
+          6
+        ],
+        [
+          8,
+          7
+        ],
+        [
+          9,
+          8
+        ],
+        [
+          10,
+          9
+        ],
+        [
+          11,
+          10
+        ],
+        [
+          13,
+          12
+        ],
+        [
+          14,
+          13
+        ],
+        [
+          15,
+          14
+        ],
+        [
+          16,
+          15
+        ],
+        [
+          17,
+          16
+        ],
+        [
+          6,
+          0
+        ],
+        [
+          12,
+          6
+        ],
+        [
+          7,
+          1
+        ],
+        [
+          13,
+          7
+        ],
+        [
+          8,
+          2
+        ],
+        [
+          14,
+          8
+        ],
+        [
+          9,
+          3
+        ],
+        [
+          15,
+          9
+        ],
+        [
+          10,
+          4
+        ],
+        [
+          16,
+          10
+        ],
+        [
+          11,
+          5
+        ],
+        [
+          17,
+          11
+        ]
+      ]
+    },
+    "random_seed": -1
+  }
+}
\ No newline at end of file
diff --git a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.qmod b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.qmod
new file mode 100644
index 00000000..afa2dbc1
--- /dev/null
+++ b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.qmod
@@ -0,0 +1,12 @@
+qfunc my_mcx(ctrl: qbit[], target: qbit) {
+  control (ctrl) {
+    X(target);
+  }
+}
+
+qfunc main(output ctrl: qbit[], output target: qbit) {
+  allocate<12>(ctrl);
+  allocate<1>(target);
+  my_mcx(ctrl, target);
+}
+
diff --git a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.synthesis_options.json b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.synthesis_options.json
new file mode 100644
index 00000000..54a8c00f
--- /dev/null
+++ b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.synthesis_options.json
@@ -0,0 +1,145 @@
+{
+  "constraints": {
+    "max_width": 18,
+    "optimization_parameter": "cx"
+  },
+  "preferences": {
+    "custom_hardware_settings": {
+      "basis_gates": [
+        "cx",
+        "u"
+      ],
+      "connectivity_map": [
+        [
+          0,
+          1
+        ],
+        [
+          0,
+          2
+        ],
+        [
+          0,
+          3
+        ],
+        [
+          0,
+          4
+        ],
+        [
+          0,
+          5
+        ],
+        [
+          0,
+          6
+        ],
+        [
+          0,
+          7
+        ],
+        [
+          0,
+          8
+        ],
+        [
+          0,
+          9
+        ],
+        [
+          0,
+          10
+        ],
+        [
+          0,
+          11
+        ],
+        [
+          0,
+          12
+        ],
+        [
+          0,
+          13
+        ],
+        [
+          0,
+          14
+        ],
+        [
+          0,
+          15
+        ],
+        [
+          0,
+          16
+        ],
+        [
+          1,
+          0
+        ],
+        [
+          2,
+          0
+        ],
+        [
+          3,
+          0
+        ],
+        [
+          4,
+          0
+        ],
+        [
+          5,
+          0
+        ],
+        [
+          6,
+          0
+        ],
+        [
+          7,
+          0
+        ],
+        [
+          8,
+          0
+        ],
+        [
+          9,
+          0
+        ],
+        [
+          10,
+          0
+        ],
+        [
+          11,
+          0
+        ],
+        [
+          12,
+          0
+        ],
+        [
+          13,
+          0
+        ],
+        [
+          14,
+          0
+        ],
+        [
+          15,
+          0
+        ],
+        [
+          16,
+          0
+        ]
+      ]
+    },
+    "random_seed": -1
+  }
+}
\ No newline at end of file
diff --git a/community/basic_examples/hw_aware_synthesis/hw_aware_synthesis.ipynb b/community/basic_examples/hw_aware_synthesis/hw_aware_synthesis.ipynb
new file mode 100644
index 00000000..7618195a
--- /dev/null
+++ b/community/basic_examples/hw_aware_synthesis/hw_aware_synthesis.ipynb
@@ -0,0 +1,645 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "S5a8KVmhRyCm"
+      },
+      "source": [
+        "# HW-aware Synthesis of MCX\n",
+        "\n",
+        "This tutorial consists of two parts,\n",
+        "1. How to create a 10-CONTROL MCX gate with Classiq\n",
+        "2. Classiq's Hardware-Aware Synthesis capability\n",
+        "\n",
+        "<!--This tutorial demonstrates Classiq's Hardware-Aware Synthesis capability. In this example we will implement and synthesize a simple MCX (Multiple Control-X) circuit with two different HW-aware configuration settings using Classiq's synthesis engine.-->\n",
+        "\n",
+        "\n",
+        "<!--The two different fictitious hardware created here demonstrates how to insert your own custom-designed machine. For comparison, we create two types of hardware with `cx, u` basis gates. The difference between them manifests in the connectivity map: one has grid connectivity while the other has star connectivity.-->\n",
+        "\n",
+        "<!--The two fictitious hardware created are using two different simulators, Classiq's Simulator and IonQ's Simulator. We will compare the depth of the circuit and we will optimise the number of cnot gates as they cause more errors and are very expensive. At the end of the tutorial we will also see the depth of both the circuits created.-->\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "AE1ksqSMC_MY"
+      },
+      "source": [
+        "## 1. How to create a 10-CONTROL MCX gate with Classiq"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CiCAjWxbC_Ma"
+      },
+      "source": [
+        "To create an MCX gate with 10 control qubits using Classiq, we will first define a quantum function called `my_mcx`, whose arguments are an array of qubits (of any size) to be used as control, and a single qubit argument to be used as the target."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "id": "N55CY8rJo6nu"
+      },
+      "outputs": [],
+      "source": [
+        "#importing all the necessary libraries from classiq\n",
+        "\n",
+        "from math import pi\n",
+        "from classiq import *"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "8jxKs0RkpLqf"
+      },
+      "outputs": [],
+      "source": [
+        "# define MCX quantum function\n",
+        "@qfunc\n",
+        "def my_mcx(ctrl: QArray[QBit], target: QBit) -> None:\n",
+        "    control(ctrl, lambda: X(target))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "DxI88JO1C_Mh"
+      },
+      "source": [
+        "Then, to create an MCX gate with 10 control qubits we will create a quantum main function that will simply execute our `my_mcx` function with 10 qubits allocated to the control argument."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "NIxnhfOgpSSI"
+      },
+      "outputs": [],
+      "source": [
+        "# define the MCX parameters within the quantum 'main' function\n",
+        "@qfunc\n",
+        "def main(ctrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n",
+        "    allocate(10, ctrl)\n",
+        "    allocate(1, target)\n",
+        "    my_mcx(ctrl, target)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Iu8uortFC_Mi"
+      },
+      "source": [
+        "To build our model we will use the `create_model` function:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "id": "iHVgE7SCpZBL"
+      },
+      "outputs": [],
+      "source": [
+        "# build a model\n",
+        "model = create_model(main)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CTi8GIBrC_Mk"
+      },
+      "source": [
+        "To constrain a circuit to only 20 qubits and optimize for circuit depth, we pass the max width and optimization parameter to a `Constraints` object and update our model"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "id": "zbzL6MksC_Ml"
+      },
+      "outputs": [],
+      "source": [
+        "from classiq import write_qmod\n",
+        "\n",
+        "constraints = Constraints(\n",
+        "    max_width=20, optimization_parameter=OptimizationParameter.DEPTH\n",
+        ")\n",
+        "model = set_constraints(model, constraints)\n",
+        "\n",
+        "write_qmod(model, \"mcx_10_ctrl_depth\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "bpBmDJcBC_Mm"
+      },
+      "source": [
+        "We can now synthesize our model, create a quantum program and view it:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "OebNdwj-C_Mn",
+        "outputId": "d6b32f26-36b9-42a8-f8d0-629dbcd5598d"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Opening: https://platform.classiq.io/circuit/c51e64f0-fc0a-43a8-b484-2ddf7366c956?version=0.42.0\n"
+          ]
+        }
+      ],
+      "source": [
+        "qprog = synthesize(model)\n",
+        "show(qprog)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "HDdeZAmNC_Mo"
+      },
+      "source": [
+        "Additionally, To get the transpiled circuit from our qprog object and print its depth:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "4Ykj96NcC_Mp",
+        "outputId": "759f30d6-34e5-4e17-9e68-ec112c1ef074"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Synthesized MCX depth is 52\n"
+          ]
+        }
+      ],
+      "source": [
+        "circuit = QuantumProgram.from_qprog(qprog)\n",
+        "print(f\"Synthesized MCX depth is {circuit.transpiled_circuit.depth}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "rF_sE_vHC_Mq"
+      },
+      "source": [
+        "# 2. Classiq's Hardware-Aware Synthesis capability"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "74aCfp3IC_Mq"
+      },
+      "source": [
+        "In the above section we have seen how to create a MCX circuit, add constraints to it and optimize its depth in Classiq. In this section we will check the hardware-aware synthesis capability of Classiq. In this example we will implement and synthesize a simple MCX (Multiple Control-X) circuit with two different HW-aware configuration settings using Classiq's synthesis engine.\n",
+        "\n",
+        "The two different fictitious hardware created here demonstrates how to insert your own custom-designed machine. For comparison, we create two types of hardware with `cx, u` basis gates. The difference between them manifests in the connectivity map: one has grid connectivity while the other has star connectivity.\n",
+        "\n",
+        "The two fictitious hardware created are using two different simulators: Classiq's Simulator and IonQ's Simulator. We will compare the depth of the circuit and we will optimise the number of cnot gates as it is important in quantum computation because they cause more errors and are very expensive.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# define MCX quantum function\n",
+        "@qfunc\n",
+        "def my_mcx(ctrl: QArray[QBit], target: QBit) -> None:\n",
+        "    control(ctrl, lambda: X(target))"
+      ],
+      "metadata": {
+        "id": "kDz3GbcKEwwB"
+      },
+      "execution_count": 10,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# define the MCX parameters within the quantum 'main' function\n",
+        "@qfunc\n",
+        "def main(ctrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n",
+        "    allocate(12, ctrl)\n",
+        "    allocate(1, target)\n",
+        "    my_mcx(ctrl, target)"
+      ],
+      "metadata": {
+        "id": "yOzokSMZEw78"
+      },
+      "execution_count": 11,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# build a model\n",
+        "model = create_model(main)"
+      ],
+      "metadata": {
+        "id": "5bGo7UFBEw_V"
+      },
+      "execution_count": 12,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "id": "NlxS3xSTC_Mr"
+      },
+      "outputs": [],
+      "source": [
+        "# define the hardware parameters\n",
+        "max_width = 18\n",
+        "\n",
+        "#Grid Connectivity\n",
+        "grid_connectivity = [\n",
+        "    [0, 1], [1, 2], [2, 3], [3, 4], [4, 5],  # Row 1\n",
+        "    [6, 7], [7, 8], [8, 9], [9, 10], [10, 11],  # Row 2\n",
+        "    [12, 13], [13, 14], [14, 15], [15, 16], [16, 17],  # Row 3\n",
+        "    [0, 6], [6, 12],  # Column 1\n",
+        "    [1, 7], [7, 13],  # Column 2\n",
+        "    [2, 8], [8, 14],  # Column 3\n",
+        "    [3, 9], [9, 15],  # Column 4\n",
+        "    [4, 10], [10, 16],  # Column 5\n",
+        "    [5, 11], [11, 17]   # Column 6\n",
+        "]\n",
+        "\n",
+        "#Star Connectivity\n",
+        "star_connectivity = [[0, i] for i in range(1, max_width-1)]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#Plotting Grid Connectivity\n",
+        "import matplotlib.pyplot as plt\n",
+        "import networkx as nx\n",
+        "\n",
+        "G = nx.Graph()\n",
+        "G.add_edges_from(grid_connectivity)\n",
+        "\n",
+        "# Define the positions of the nodes in a 3x6 grid\n",
+        "pos = {}\n",
+        "for i in range(3):\n",
+        "    for j in range(6):\n",
+        "        pos[i * 6 + j] = (j, -i)  # (x, y) coordinates\n",
+        "\n",
+        "# Plot the graph\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "nx.draw(G, pos, with_labels=True, node_size=500, node_color=\"skyblue\", font_size=16, font_color=\"black\", edge_color=\"gray\")\n",
+        "plt.title(\"3x6 Grid Connectivity Map\")\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 659
+        },
+        "id": "qVDIz-txBcRS",
+        "outputId": "62566d81-b841-4eb0-e4fa-046f1a6151bd"
+      },
+      "execution_count": 14,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#plotting Star Connectivity\n",
+        "import numpy as np\n",
+        "\n",
+        "G = nx.Graph()\n",
+        "G.add_edges_from(star_connectivity)\n",
+        "\n",
+        "# Define the positions of the nodes in a star configuration\n",
+        "pos = {}\n",
+        "pos[0] = (0, 0)  # Central node\n",
+        "angle_step = 360 / (len(star_connectivity))\n",
+        "for i in range(1, 18):\n",
+        "    angle = angle_step * (i - 1)\n",
+        "    radians = np.deg2rad(angle)\n",
+        "    pos[i] = (np.cos(radians), np.sin(radians))\n",
+        "\n",
+        "# Plot the graph\n",
+        "plt.figure(figsize=(10, 10))\n",
+        "nx.draw(G, pos, with_labels=True, node_size=500, node_color=\"skyblue\", font_size=16, font_color=\"black\", edge_color=\"gray\")\n",
+        "plt.title(\"Star Connectivity Map\")\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "0AEHYvxACpS7",
+        "outputId": "62c17d67-b8f0-403c-96ba-41bcc319619f"
+      },
+      "execution_count": 15,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x1000 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/sAAAQSCAYAAADwlOr+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3Qc52Hu/2ex6L0TJAACIED0vjMqFClKFItkqljVkuxYtq9jJ44dxzdO++VeuVw7uXHKTeI4jpOba9lWsaolWy4S1W3VmUUn2DvBBrABRCHa/P6QiZBiQ58t3885Oofcnd15SBGz77PvzDsex3EcAQAAAACAkBHhdgAAAAAAADC7KPsAAAAAAIQYyj4AAAAAACGGsg8AAAAAQIih7AMAAAAAEGIo+wAAAAAAhBjKPgAAAAAAIYayDwAAAABAiKHsAwAAAAAQYij7AABgSj7xiU+osLBwyq/bvXu3PB6PHnrooVnPBAAAzkXZBwAEhPb2dt11110qKChQbGyscnNztWbNGn37298+Z7u/+qu/0rPPPjvv+Xp7e/W1r31NdXV1SkxMVFxcnKqrq/Vnf/ZnOnDgwLznmWsHDhzQV7/6VbW0tMzpfn7xi1/oq1/96qy/b2FhoTwej1avXn3B5//jP/5DHo9HHo9Htm3P+v4BAHCbx3Ecx+0QAIDw9tZbb+n666/X4sWL9cADDygnJ0f79u3TO++8ox07dmj79u0T2yYmJuquu+6a19nhnTt3avXq1dq7d6/uvvtuLV++XNHR0Wpra9Njjz2m9PR0bd26dd7yzAfbtmWapr7//e/rE5/4xDnPjYyMaHx8XDExMVN6T8dxdPr0aUVFRcnr9UqSPv/5z+s73/mOZns4UlhYqMOHD2t4eFhdXV3Kyck55/nrrrtO7777roaGhmRZlgzDmNX9AwDgtki3AwAA8M1vflMpKSmyLEupqannPHfkyJE5339/f78SEhIu+Nzo6KjuuOMOHT58WK+99pqWL19+zvPf/OY39Td/8zdznjGQREVFTet1Ho9HsbGxs5zm4q655hpZlqXHH39cX/ziFyce379/v37961/r9ttv19NPPz1veQAAmE+cxg8AcN2OHTtUVVV1XtGXpOzs7Ilfezwe9ff36wc/+MHEKdhnZp337Nmjz33ucyorK1NcXJwyMjJ09913a/fu3ee830MPPSSPx6PXX39dn/vc55Sdna28vLyLZnv66afV2tqqv/zLvzyv6EtScnKyvvnNb57z2JNPPimfz6e4uDhlZmbqYx/7mLq6us7Z5hOf+IQSExPV1dWlD3/4w0pMTFRWVpa+/OUva2xsbGK7M9e5/93f/Z3+/d//XcXFxYqJiZFpmrIs67w8mzdv1l133aX09HTFxsbKMAz99Kc/PW+7EydO6Etf+pIKCwsVExOjvLw8ffzjH1dPT49ee+01maYpSfrkJz858Xd95myKs6/ZHxkZUXp6uj75yU+et4/e3l7Fxsbqy1/+8jl/lrPf5zvf+Y4kTezD4/HIcRwVFhbqtttuO+89h4aGlJKSos9+9rPnPfdBsbGxuuOOO/Too4+e8/hjjz2mtLQ0rVu37rzXtLW16ROf+ISWLFmi2NhY5eTk6FOf+pSOHj16znZf/epX5fF4tHnzZt1zzz1KTk5WRkaGvvjFL2poaOiy2QAAmGvM7AMAXFdQUKC3335bHR0dqq6uvuh2P/rRj/TpT39aV1xxhT7zmc9IkoqLiyVJlmXprbfe0r333qu8vDzt3r1b3/3ud3Xdddeps7NT8fHx57zX5z73OWVlZenBBx9Uf3//Rfd5pij/zu/8zqT+LA899JA++clPyjRN/fVf/7UOHz6sf/qnf9Kbb76p5ubmc77QGBsb07p163TllVfq7/7u7/TSSy/p7//+71VcXKzf//3fP+d9H330UfX19emzn/2sPB6PvvWtb+mOO+7Qzp07J2baN27cqGuuuUa5ubn68z//cyUkJOiJJ57Qhz/8YT399NO6/fbbJUmnTp3SihUrtGnTJn3qU59SY2Ojenp69NOf/lT79+9XRUWFvv71r+vBBx/UZz7zGa1YsUKStGzZsvP+vFFRUbr99tv1zDPP6Hvf+56io6Mnnnv22Wd1+vRp3XvvvRf8u/rsZz+rAwcOaMOGDfrRj3408bjH49HHPvYxfetb39KxY8eUnp4+8dzPfvYz9fb26mMf+9ik/n/cf//9Wrt2rXbs2DHxb+XRRx/VXXfddcEzFDZs2KCdO3fqk5/8pHJycrRx40b9+7//uzZu3Kh33nlHHo/nnO3vueceFRYW6q//+q/1zjvv6J//+Z91/Phx/fCHP5xUPgAA5owDAIDLXnzxRcfr9Tper9e5+uqrnT/90z91XnjhBWd4ePi8bRMSEpwHHnjgvMcHBgbOe+ztt992JDk//OEPJx77/ve/70hyli9f7oyOjl42W0NDg5OSkjKpP8fw8LCTnZ3tVFdXO4ODgxOPP//8844k58EHH5x47IEHHnAkOV//+tfP25/P55v4/a5duxxJTkZGhnPs2LGJx5977jlHkvOzn/1s4rEbbrjBqampcYaGhiYeGx8fd5YtW+YsXbp04rEHH3zQkeQ888wz5/0ZxsfHHcdxHMuyHEnO97///fO2eeCBB5yCgoKJ37/wwgvnZXEcx/nQhz7kLFmy5Lw/y9nv+Qd/8AfOhYYjW7ZscSQ53/3ud895/NZbb3UKCwsncl5MQUGBs379emd0dNTJyclx/tf/+l+O4zhOZ2enI8l5/fXXJ/4tWJY18boL/Tt67LHHHEnOG2+8MfHYV77yFUeSc+utt56z7ec+9zlHktPa2nrJfAAAzDVO4wcAuG7NmjV6++23deutt6q1tVXf+ta3tG7dOuXm5l7wFPQLiYuLm/j1yMiIjh49qpKSEqWmpqqpqem87X/3d393YpG4S+nt7VVSUtKkMti2rSNHjuhzn/vcOdemr1+/XuXl5fr5z39+3mt+7/d+75zfr1ixQjt37jxvu4985CNKS0s7ZztJE9seO3ZMr7zyiu655x719fWpp6dHPT09Onr0qNatW6dt27ZNXErw9NNPq66ubmKm/2wfnLmejFWrVikzM1OPP/74xGPHjx/Xhg0b9JGPfGTK7ydJpaWluvLKK/XII49MPHbs2DH98pe/1Ec/+tFJ5/R6vbrnnnv02GOPSZIeeeQR5efnT/z9fdDZ/46GhobU09Ojq666SpIu+O/oD/7gD875/Re+8AVJ799lAAAAN1H2AQABwTRNPfPMMzp+/Ljee+89/cVf/IX6+vp01113qbOz87KvHxwc1IMPPqj8/HzFxMQoMzNTWVlZOnHihE6ePHne9kVFRZPKlZycrL6+vkltu2fPHklSWVnZec+Vl5dPPH9GbGyssrKyznksLS1Nx48fP+/1ixcvPm87SRPbbt++XY7j6H/+z/+prKysc/77yle+Ium/FjvcsWPHJS+XmKrIyEjdeeedeu6553T69GlJ0jPPPKORkZFpl31J+vjHP64333xz4u/tySef1MjIyKQvqTjj/vvvV2dnp1pbW/Xoo4/q3nvvveiXBceOHdMXv/hFLViwQHFxccrKypr4t3Khf0dLly495/fFxcWKiIg4b60IAADmG2UfABBQoqOjZZqm/uqv/krf/e53NTIyoieffPKyr/vCF76gb37zm7rnnnv0xBNP6MUXX9SGDRuUkZGh8fHx87Y/ewb3UsrLy3Xy5Ent27dvyn+Wy5nMmQWX29b57S3rzvwZv/zlL2vDhg0X/K+kpGTmoS/i3nvvVV9fn375y19Kkp544gmVl5errq5uRu8ZFRU1Mbv/8MMPyzCMC36ZcilXXnmliouL9Ud/9EfatWuX7r///otue8899+g//uM/9Hu/93t65pln9OKLL+pXv/qVJF3w39EHTefMCAAA5gIL9AEAAtaZe58fPHhw4rGLlamnnnpKDzzwgP7+7/9+4rGhoSGdOHFiRhluueUWPfbYY3r44Yf1F3/xF5fctqCgQJK0ZcsWrVq16pzntmzZMvH8XFiyZImk9xfMW7169SW3LS4uVkdHxyW3mWppvfbaa7Vw4UI9/vjjWr58uV555RX95V/+5WVfd6n9pKena/369XrkkUf00Y9+VG+++ab+8R//cUq5zrjvvvv0jW98QxUVFaqvr7/gNsePH9fLL7+sr33ta3rwwQcnHt+2bdtF33fbtm3nnCWyfft2jY+PT9ytAAAAtzCzDwBw3auvvjoxQ322M9c9nz2Tm5CQcMEC7/V6z3uPb3/72+fcxm467rrrLtXU1Oib3/ym3n777fOe7+vrmyi1hmEoOztb//Zv/zZxOrsk/fKXv9SmTZu0fv36GWW5lOzsbF133XX63ve+d86XI2d0d3dP/PrOO+9Ua2urfvKTn5y33Zm/w4SEBEma9JclERERuuuuu/Szn/1MP/rRjzQ6OjqpU/gvt5/f+Z3fUWdnp/7kT/5EXq/3oiv7X86nP/1pfeUrXznny6APOnP2xAf/HV3qC4Yztw4849vf/rYk6aabbppWTgAAZgsz+wAA133hC1/QwMCAbr/9dpWXl2t4eFhvvfWWHn/8cRUWFp5zD3efz6eXXnpJ//AP/6BFixapqKhIV155pW6++Wb96Ec/UkpKiiorK/X222/rpZdeUkZGxoyyRUVF6ZlnntHq1at17bXX6p577tE111yjqKgobdy4UY8++qjS0tL0zW9+U1FRUfqbv/kbffKTn9TKlSt13333Tdx6r7CwUF/60pdm+ld1Sd/5zne0fPly1dTU6Hd/93e1ZMkSHT58WG+//bb279+v1tZWSdKf/Mmf6KmnntLdd9+tT33qU/L5fDp27Jh++tOf6t/+7d9UV1en4uJipaam6t/+7d+UlJSkhIQEXXnllZdc6+AjH/mIvv3tb+srX/mKampqVFFRcdnMPp9PkvSHf/iHWrdu3XmFfv369crIyNCTTz6pm266SdnZ2dP6uykoKNBXv/rVS26TnJysa6+9Vt/61rc0MjKi3Nxcvfjii9q1a9dFX7Nr1y7deuutuvHGG/X222/r4Ycf1v333z+jyxcAAJgVbt4KAAAAx3GcX/7yl86nPvUpp7y83ElMTHSio6OdkpIS5wtf+IJz+PDhc7bdvHmzc+211zpxcXGOpInb8B0/ftz55Cc/6WRmZjqJiYnOunXrnM2bNzsFBQXn3KrvQrdbm4zjx487Dz74oFNTU+PEx8c7sbGxTnV1tfMXf/EXzsGDB8/Z9vHHH3caGhqcmJgYJz093fnoRz/q7N+//5xtHnjgASchIeG8/Zy5pdsZZ25X97d/+7fnbSvJ+cpXvnLOYzt27HA+/vGPOzk5OU5UVJSTm5vr3Hzzzc5TTz11znZHjx51Pv/5zzu5ublOdHS0k5eX5zzwwANOT0/PxDbPPfecU1lZ6URGRp5zy7wP3nrvjPHxcSc/P9+R5HzjG9847/kL3XpvdHTU+cIXvuBkZWU5Ho/ngrfhO3M7u0cfffS85y7mzK33LuVC/xb279/v3H777U5qaqqTkpLi3H333c6BAwfO+7s+8/+ps7PTueuuu5ykpCQnLS3N+fznP3/ObRcBAHCLx3EucN4kAABAgPjSl76k//zP/9ShQ4cUHx/vdhxJ0le/+lV97WtfU3d3tzIzM92OAwDAebhmHwAABKyhoSE9/PDDuvPOOwOm6AMAEAy4Zh8AAAScI0eO6KWXXtJTTz2lo0eP6otf/KLbkQAACCqUfQAAEHA6Ozv10Y9+VNnZ2frnf/7ni94uDwAAXBjX7AMAAAAAEGK4Zh8AAAAAgBBD2QcAAAAAIMRQ9gEAAAAACDGUfQAAAAAAQgxlHwAAAACAEEPZBwAAAAAgxFD2AQAAAAAIMZR9AAAAAABCDGUfAAAAAIAQQ9kHAAAAACDEUPYBAAAAAAgxlH0AAAAAAEIMZR8AAAAAgBBD2QcAAAAAIMRQ9gEAAAAACDGUfQAAAAAAQgxlHwAAAACAEEPZBwAAAAAgxFD2AQAAAAAIMZR9AAAAAABCDGUfAAAAAIAQQ9kHAAAAACDEUPYBAAAAAAgxlH0AAAAAAEIMZR8AAAAAgBBD2QcAAAAAIMRQ9gEAAAAACDGUfQAAAAAAQgxlHwAAAACAEEPZBwAAAAAgxFD2AQAAAAAIMZR9AAAAAABCDGUfAAAAAIAQQ9kHAAAAACDEUPYBAAAAAAgxlH0AAAAAAEIMZR8AAAAAgBBD2QcAAAAAIMRQ9gEAAAAACDGUfQAAAAAAQgxlHwAAAACAEEPZBwAAAAAgxFD2AQAAAAAIMZR9AAAAAABCDGUfAAAAAIAQQ9kHAAAAACDEUPYBAAAAAAgxlH0AAAAAAEIMZR8AAAAAgBBD2QcAAAAAIMRQ9gEAAAAACDGUfQAAAAAAQgxlHwAAAACAEEPZBwAAAAAgxFD2AQAAAAAIMZR9AAAAAABCDGUfAAAAAIAQQ9kHAAAAACDEUPYBAAAAAAgxlH0AAAAAAEIMZR8AAAAAgBBD2QcAAAAAIMRQ9gEAAAAACDGUfQAAAAAAQgxlHwAAAACAEEPZBwAAAAAgxFD2AQAAAAAIMZR9AAAAAABCDGUfAAAAAIAQQ9kHAAAAACDEUPYBAAAAAAgxlH0AAAAAAEIMZR8AAAAAgBBD2QcAAAAAIMREuh0AAADMjTHHUffgmA4NjOrQwKhOjY5rbNyRN8KjxMgI5cRHKic+UllxXnk9HrfjAgCAWeRxHMdxOwQAAJg9J4fH1NIzpOaeIQ2Nvf8xHyFp/Kxtzv59rNejhsxY1WfGKiXaO89pAQDAXKDsAwAQIobGxvVqV79aj56WR9JUPuDPbF+XEaNVuQmK8XKlHwAAwYyyDwBACNjVO6zn9/RpYNSZUsn/II+khEiP1hckqSg5erbiAQCAeUbZBwAgyPm7B7Vhf/+UZ/Mv5sz7rMlLkC8rbhbeEQAAzDfO0QMAIIidKfrS7BT9s99nw/5++bsHZ+ldAQDAfGI1fgAAgtSu3uGJon8xT37l82r62eOX3Obrb+9TVEzsBZ/bsL9f6TFeTukHACDIUPYBAAhCQ2Pjen5P36RP3S+ov0IZ+UUXfC4i4uIr8Hsk/XxPn363Mo1F+wAACCKUfQAAgtCrXf1TWozP/PDH5Lv1vinvx5HUP+rola5+3bQ4acqvBwAA7uAregAAgsyJ02NqPXp61q7RvxxHUuvR0zo5PDZPewQAADNF2QcAIMi0Hh2SZ5736ZHU0jM0z3sFAADTxWn8AAAEkTHHUXPP0JRn9XfYv9Gh7Zt0uv+U4lPTlF/VqLLlqxUZHTOp1zuSmnuGtHxhvLye+f6qAQAATBVlHwCAINI9OKahsamfwN/8/BPnPZaUuUB3fuWfVHbNDZN6j6ExR92DY8qJZ/gAAECg8ziOM1+X/AEAgBlq6RnSr/admvT2v3n43+TxRqjkimuVmpOnkdODOrh1o17+3re0p9WSNzJKn/rXJ7XEuGZS73djfqLqMy98mz4AABA4KPsAAASRX+09pbajQxqf4fs4jqOH//gBdb72Sy0srdIf/vi1y74mQlJtRqxuXJw4w70DAIC5xgJ9AAAEkVOj4zMu+pLk8Xi0+vf+VJJ0cOtGnTjUddnXjEvqH52NvQMAgLlG2QcAIIiMjc/eCXlZRaUTvz55+MCkXjM6i/sHAABzh7IPAEAQ8UbM3kr4AyeOTfw6JmFyp+ZHzuL+AQDA3KHsAwAQRBIjI2btw7vthWclSTGJScoqKLns9hGSEiIZOgAAEAz4xAYAIIjkxEdO+pr9A1va1fn6rzQ2OnrO4+Pj47KefVgvfOebkqRl9/6uvFFRl32/8d/uHwAABD4+sQEACCJTKdvHD+zTw3/8gOKSU7WovFaJGVka6jupw9s368Sh/ZKkuhvv0A2f+ZM52T8AAHAPn9gAAASRrDivYr0eDY1dfqG8haVVuub+z6qrs0Xdu7dpT+t7kuMoMT1L1atvke/W+1S+fM2k9x3r9SgrzjuT+AAAYJ54HMdhWV0AAILI6wf69c7hQc3nB7hH0lUL4rRyUcI87hUAAEwX1+wDABBk6jNj57XoS5Lz2/0CAIDgQNkHACDIpER7VZcRo/m6CZ5HUl1GjFKiOYUfAIBgQdkHACAIrcpNUEKkZ84Lv0dSQqRHq3I5fR8AgGBC2QcAIAjFeCO0viBpzk/ndyStL0hSjJchAwAAwYRPbgAAglRRcrTW5M3tjPvavAQVJUfP6T4AAMDso+wDABDEfFlxE4V/tk7pP/M+a/MS1JgVN0vvCgAA5hO33gMAIATs6h3Wz/f0qX/UmdGp/Weu0V9fkMSMPgAAQYyyDwBAiBgaG9erXf1qPXpaHmlKpf/M9nUZMVqVm8A1+gAABDnKPgDMgzHHUffgmA4NjOrQwKhOjY5rbNyRN8KjxMgI5cRHKic+UllxXnk983VDNYSqk8NjaukZUnPPkIbG3v+Yj5A0Lkdnan2EPBr/7faxXo8aMmNVnxnL7fUwYxzvACAwUPYBYA5dvHT9l7N/T+nCbPpg6Tp6akB79u1TQX6+MhLjKV2YVRzvACCwUPYBYA5wOjUC0cGDB/Xv//7v+sxnPqOFCxe6HQchguMdAASmSLcDAECo2dU7rOf39Glg9P0h71S/UT2zfdvR09pxcpiF0gAELI53ABC4+PoUAGaRv3tQj+/o1cAMV0SX3h8E9486enxHr/zdg7MRDwBmDcc7AAhslH0AmCX+7kFt2N8vaeqzWxdz5n027O9nAAwgYHC8A4DAR9kHgFmwq3d4YuA7Vzbs79eu3uE53QcAXA7HOwAIDlyzDwAzNDQ2ruf39E1qYarRkWG9+9RDat/wnI7s3KqRoUHFp6Yrp6RCvlvuVe262y/6Wo+kn+/p0+9WprGIFQBXTOV4d7Zf/uPX9MYP/0WStOZzf65Vn/7jS27P8Q4AZo6yDwAz9GpX/6SuWT15+ID+3x/coyM7tyghNUMFdVcoOi5eJw93aVfTO4qOi79k2T9zTesrXf26aXHSrP4ZAGAyJnu8O9ue1vf064f/VR6PR5O9CRTHOwCYOco+AMzAidNjaj16+rLbjQwN6j9//y51796mGz77p7r+U38kb1TUxPPDgwPq2bvjsu/jSGo9elrLcuK5LzWAeTXZ493ZhgcH9ORXvqCkzAXKq2pQ56u/mPRrOd4BwMxwXhQAzEDr0SF5JrHda9//J3Xv3qYr7vi4Vn/2T84p+pIUHRevRWU1k9qnR1JLz9DUwwLADEz2eHe2F/7lGzq6d6du/x9/r9jEqc/Qc7wDgOmj7APANI05jpp7hi57OuvYyIjeffIhSdKKj//BjPfrSGruGdLYJE+HBYCZmuzx7mw77Tf19o//rxpuvkfly9dMa78c7wBg+jiNHwCmqXtwTENjlx+Adm1uU/+Jo0rOylHm4iU6tK1THa/8XH3dhxSXnKLChqtUes1qRURM/vvXoTFH3YNjyonnMA5g7k32eHfG6YFTeuprX1RiRpZu+fI3Z7RvjncAMD0cNQFgmg4NjE5uu22dkqTkBYv0q3/+ut74wb+cs0jV6w99W4vKa/Q7f/9DpS7Mm9L+GfwCmA+TPd6d8Yv/81Ud79qjj/39DxSXnDor++d4BwBTw2n8ADBNhwZGJ3UQHTh5TJJ0cHO7Xn/o27ry7k/qv//kHX3ljZ36b999SpkFxTqwuV0PffF+jY2MTGrfEZr64BsApmuyxztJ2vr2q3rv6R+odt3tqrr+QzPeN8c7AJgeyj4ATNOp0XGNT2bD387ij42OqO7GO3Tbn/+NsgqKFZuYpJIrV+q//etTioyJ1eHtm9T6wk8mte9xSf2jk9o7AMzYZI93Q329eubrf6SEtEzd+qd/PSv75ngHANND2QeAaRobn9z1q9HxiRO/vuLOj5/3fOrCPJUvXy1J2v7e65Pe/+gk9w8AMzXZ493zf/eXOnn4gG79s79WQlrGrO2f4x0ATB0XPwHANHkjJncTqvS8gv/6dW7hhbf57eN9PUcmvf/ISe4fAGZqsse7ja/+QhGRkXrnye/rnSe/f85z3bu3SZLsZx/V9nffUFJGtu773/8xqffleAcAU0fZB4BpSoyMUIR02VNbc8tr5fF45DiOBk4cVWpO7nnb9J84KkmKiUuY1L4jJCVEcnIWgPkx2eOdJI2PjmqX/62LPn/8wF4dP7BXqQvzJ7VvjncAMD2UfQCYppz4SLUcvfx2SZkLVFB/pXY3v6Pt776hReW15zw/NjKiXU1vS5Lyqhsmte/x3+4fAObDZI93X3ljx0Wfe/Irn1fTzx7Xms/9uVZ9+o8nvW+OdwAwPXxNCgDTNJXB5w2f+RNJ0mvf/yftbbMnHh8bHdXP/8+DOrZ/t2ISEuW79b452T8AzITbxxu39w8AwYgjJwBMU1acV7Fej4bGLr9wVMmV12rN5/5cG/71f+t7n75F+VUNSszI1oHN7Tp+YK+iYuN07199T0kZ2ZPad6zXo6w470z/CAAwKVM53s02jncAMD3M7APANHk9HjVkxmqyy0at+vQf65PfeUIlV67Ukd3btfmNFzU+PibfLffq84+8rPIVayf1Ph5JDZmx8npYsArA/Jjq8W62cLwDgOljZh8AZqA+M1ZvHx6c9PalV1+v0quvn9E+nd/uFwDm01SPdx9099f+RXd/7V+m9BqOdwAwfczsA8AMpER7VZcRM2+zXR5JdRkxSonmlFYA84vjHQAEF8o+AMzQqtwEJUR65nwA7JGUEOnRqtzJ3Z4PAGYbxzsACB6UfQCYoRhvhNYXJGmul61yJK0vSFKMl0M3AHdwvAOA4MERFABmQVFytNbkze0M1Nq8BBUlR8/pPgDgcjjeAUBwoOwDwCzxZcVNDIBn6xTXM++zNi9BjVlxs/SuADAzHO8AIPCxGj8AzCJfVpzSY7z6+Z4+9Y86MzrV9cw1q+sLkpjhAhBwON4BQGBjZh8AZllRcrQ+XZmm2owYSdOY9XLeHzLXZsTodyvTGPgCCFjnHO8cR3LGp/T6M8dHjncAMPuY2QeAORDrjdBNi5O0LCdeLT1Dau4Z0tDY+yU+QtLZw+Gzf+8dH9X4no369I0rlBHPoBdA4Iv1RmjNoji1P/cjZdWv0MmURZM63sV6PWrIjFV9Ziy31wOAOUDZB4A5lBLt1cpFCVq+MF7dg2M6NDCqQwOj6h8d1+i4o8gIjxIiI5QTH6mc+EhF9J/Qd5//jbpKspRRW+t2fACYlM7OTg0e69atlYuUmp4+qeNdVpxXXs9c38QPAMIXZR8A5oHX45kY4F5SfKaWLFki27ZVS9kHECQsy9KSJUuUkZEhSZM73gEA5hTX7ANAgDEMQ/v27dOhQ4fcjgIAl3Xw4EHt379fpmm6HQUAcBbKPgAEmLKyMiUlJcmyLLejAMBl2bat5ORklZaWuh0FAHAWyj4ABJiIiAj5fD61t7draGjI7TgAcFFDQ0Nqb2+Xz+dTRATDSgAIJByVASAANTY2amxsTK2trW5HAYCLam1t1djYmBobG92OAgD4AMo+AASgpKQkVVRUyLZtOY7jdhwAOI/jOLIsSxUVFUpMTHQ7DgDgAyj7ABCgDMNQT0+Pdu/e7XYUADjP7t27dfToURbmA4AARdkHgABVUFCgrKws2bbtdhQAOI9lWcrKytLixYvdjgIAuADKPgAEKI/HI8MwtGnTJvX19bkdBwAm9Pb2avPmzTJNUx6Px+04AIALoOwDQACrq6tTZGSk/H6/21EAYEJTU5OioqJUW1vrdhQAwEVQ9gEggMXExKi2tlZNTU0aGxtzOw4AaGxsTH6/X7W1tYqJiXE7DgDgIij7ABDgTNNUX1+ftmzZ4nYUANCWLVt06tQpGYbhdhQAwCVQ9gEgwC1YsECLFy9moT4AAcGyLC1evFgLFixwOwoA4BIo+wAQBAzD0K5du9Td3e12FABhrLu7W7t37+Z2ewAQBCj7ABAEKioqlJCQwOw+AFfZtq2EhARVVFS4HQUAcBmUfQAIApGRkWpoaFBra6uGh4fdjgMgDA0PD6u1tVWNjY3yer1uxwEAXAZlHwCChM/n0/DwsNrb292OAiAMtbW1aXh4WD6fz+0oAIBJoOwDQJBITU1VaWmpLMuS4zhuxwEQRhzHkW3bKi0tVUpKittxAACTQNkHgCBiGIYOHz6s/fv3ux0FQBjZt2+fDh8+zMJ8ABBEKPsAEESKi4uVlpYmy7LcjgIgjNi2rfT0dC1ZssTtKACASaLsA0AQ8Xg8MgxDnZ2d6u/vdzsOgDDQ39+vjRs3yjAMeTwet+MAACaJsg8AQaa+vl4ej0fNzc1uRwEQBpqamhQREaH6+nq3owAApoCyDwBBJj4+XtXV1bJtW+Pj427HARDCxsfH5ff7VV1drbi4OLfjAACmgLIPAEHIMAydPHlS27dvdzsKgBC2bds2nTx5koX5ACAIUfYBIAjl5uZq0aJFLNQHYE7Ztq1FixZp0aJFbkcBAEwRZR8AgpRhGNq+fbuOHTvmdhQAIejYsWPavn07s/oAEKQo+wAQpKqrqxUbGyu/3+92FAAhyLZtxcXFqaqqyu0oAIBpoOwDQJCKiopSQ0ODmpubNTIy4nYcACFkZGRELS0tqq+vV1RUlNtxAADTQNkHgCBmGIYGBwfV2dnpdhQAIWTjxo0aHByUYRhuRwEATBNlHwCCWHp6uoqLi1moD8Cssm1bJSUlSk9PdzsKAGCaKPsAEORM01RXV5cOHDjgdhQAIeDAgQPq6upiVh8AghxlHwCC3NKlS5WSkiLbtt2OAiAEWJallJQULV261O0oAIAZoOwDQJCLiIiQz+dTe3u7BgcH3Y4DIIgNDg6qo6NDPp9PEREMEwEgmHEUB4AQ0NDQoPHxcbW2trodBUAQa2lp0fj4uBobG92OAgCYIco+AISAxMREVVZWyrIsOY7jdhwAQchxHNm2raqqKiUkJLgdBwAwQ5R9AAgRpmnq2LFj2rVrl9tRAAShnTt36tixYyzMBwAhgrIPACEiPz9f2dnZ3IYPwLTYtq0FCxYoPz/f7SgAgFlA2QeAEOHxeGSaprZs2aLe3l634wAIIidPntSWLVtkGIY8Ho/bcQAAs4CyDwAhpKamRlFRUfL7/W5HARBE/H6/oqKiVFtb63YUAMAsoewDQAiJiYlRXV2dmpqaNDY25nYcAEFgbGxMTU1NqqurU3R0tNtxAACzhLIPACHGMAydOnVKmzdvdjsKgCCwadMm9ff3yzRNt6MAAGYRZR8AQkx2drYKCgpYqA/ApNi2rcLCQmVlZbkdBQAwiyj7ABCCTNPUnj17dOTIEbejAAhgR44c0Z49e7jdHgCEIMo+AISg8vJyJSYmMrsP4JIsy1JiYqLKy8vdjgIAmGWUfQAIQV6vV42NjWpra9Pp06fdjgMgAJ0+fVptbW1qbGyU1+t1Ow4AYJZR9gEgRPl8Po2MjKitrc3tKAACUFtbm0ZGRuTz+dyOAgCYA5R9AAhRycnJKisrk23bchzH7TgAAojjOLIsS+Xl5UpOTnY7DgBgDlD2ASCEmaapI0eOaO/evW5HARBA9u7dq+7ubhbmA4AQRtkHgBBWVFSkjIwM2bbtdhQAAcSyLGVkZKioqMjtKACAOULZB4AQ5vF4ZBiGOjs7derUKbfjAAgAp06d0qZNm2QYhjwej9txAABzhLIPACGurq5OERERampqcjsKgADQ1NSkiIgI1dfXux0FADCHKPsAEOLi4uJUU1Mjv9+v8fFxt+MAcNH4+Lj8fr9qamoUGxvrdhwAwByi7ANAGDBNU729vdq6davbUQC4aOvWrert7dUVV1zhdhQAwByj7ANAGFi4cKHy8vJYqA8Ic5ZlKS8vTzk5OW5HAQDMMco+AIQJwzC0Y8cOHT161O0oAFxw9OhR7dy5U6Zpuh0FADAPKPsAECaqqqoUFxfH7D4QpmzbVnx8vCorK92OAgCYB5R9AAgTkZGRamhoUEtLi0ZGRtyOA2AejYyMqKWlRQ0NDYqMjHQ7DgBgHnC0B2bZmOOoe3BMhwZGdWhgVKdGxzU27sgb4VFiZIRy4iOVEx+prDivvNzfGPPMMAy99dZb6ujoUENDg9txAMyTjo4ODQ0NyefzuR0FYYrxETD/KPvALDk5PKaWniE19wxpaMyR9P6pM2ff6CxCUstvL5eO9XrUkBmr+sxYpUR75zsuwlRaWpqWLl0q27Yp+0CYcBxHlmVp6dKlSktLczsOwgzjI8A9lH1ghobGxvVqV79aj56WR5Jz1nMfvKP5+Dmvc/TO4UG9fXhQdRkxWpWboBgvV9Zg7hmGoccee0xdXV3Kzc11Ow6AOXbgwAEdPHhQ999/v9tREEYYHwHuo+wDM7Crd1jP7+nTwOj7H2HOZbb/oDPbtx09rR0nh7W+IElFydGzmhH4oJKSEqWmpsq2bco+EAYsy1JqaqqKi4vdjoIwwfgICAx8TQZMk797UI/v6NXAqDPlD7EPciT1jzp6fEev/N2DsxEPuKiIiAj5fD51dHRoYGDA7TgA5tDAwIA6OjpkGIYiIhj2Ye4xPgICB0d9YBr83YPasL9f0tS/rb6YM++zYX8/H2iYcw0NDXIcRy0tLW5HATCHzvyMs0YH5gPjIyCwcBo/MEW7eocnPsgu5PiBvfrWzZNb7fgz//GcinzLznt8w/5+pcd4OWUNcyYhIUFVVVWybVtXX321PKx8DIQcx3Fk27aqqqoUHx/vdhyEuMuNjySp+RdPadvbr+rg1o3q6zmswb4TioqNU1ZBiaqu/5CuvvfTiolPvOjrGR8BU0PZB6ZgaGxcz+/pO2+hmbNFxyWo8ZaPXPQ9juzcqv0bmxWTkKjcyroLbuOR9PM9ffrdyjQWpcGcMQxDbW1t2rFjh0pKStyOA2CW7dixQ8ePH9cdd9zhdhSEuMmMjyTp3ae+r72tlrKKSrWovEbxKWk6dbRbe9tt7d/YLPu5R/WZ//tTJWflXPD1jI+AqaHsA1Pwalf/Za9BS0jL0N1f+5eLPv/9L9wrSapde7ui4xIuuM2Za9Re6erXTYuTZpAYuLi8vDzl5OTItm3KPhCCLMtSTk4OC3Fizk1mfCRJH/rS15W5eIniU869BWT/iWN6+L9/XLtb3tXP/+FB3ffX/37B1zM+AqaGr8SASTpxekytR0/P6Bq0k0cOatvbr0qSjA9/9JLbOpJaj57WyeGxGewRuDiPxyPDMLR161adOHHC7TgAZtGJEye0detWmabJZTqYU1MZHy2u8Z1X9CUpITVdaz//l5Kkbe+8dsn3YHwETB5lH5ik1qNDmulwqemnj8kZH9eC4nItrrn8df0eSS09QzPcK3BxNTU1io6Olt/vdzsKgFnk9/sVExOj6upqt6MgxM3G+EiSIrzvn3AcGXX56/EZHwGTQ9kHJmHMcdTcMzTjlWX9P/uxJMm47dKz+mc4kpp7hjTmzNaatsC5oqOjVVdXp+bmZo2OjrodB8AsGB0dVVNTk+rr6xUdzUJmmDuzNT463X9KL3/vW5KkipU3XnZ7xkfA5HDNPjAJ3YNjGhqb2QfKTv+bOrpvl7xR0WpYf/ekXzc05qh7cEw58fy4Ym6Ypqn33ntPmzZtUk1NjdtxAMxQZ2enBgYGZBiG21EQ4qY7Ptr69qtq/dXTcsYdnTp6RHvbbZ3uP6XSZat00x8+OKn3YHwEXB4/HcAkHBqY+Yyn/dyjkqSKleuUkJYx5f3zYYa5kpmZqaKiIlmWRdkHQoBt2yoqKlJmZqbbURDipjs+OrJzi5p+9vg5j9XddKfW//evKzYpeUr7Z3wEXByn8QOTcGhgdEY/LEOn+tTx0vOSJOO2+6f02gjNzpcNwKUYhqF9+/bp0KFDbkcBMAOHDh3Svn37ZJqm21EQBqY7Plr+0d/TXzd16xvvHtCXn3tPH/rvX9fWN1/W/7lruXb535rUezA+Ai6Psg9MwqnRcY3P4PVtL/xEI0MDSlmwSEuvXjWl145L6h+dyd6ByysrK1NSUpJs23Y7CoAZsCxLSUlJKisrczsKwsBMx0feqChl5Bdpxcd+X5/49o811HtCj//Pz2lkaPCyr2V8BFweZR+YhLHxmV2vf+YU/sZb7lVExNR/7EZnuH/gcrxerxobG9XW1qahIVY4BoLR0NCQ2tvb5fP5pvVZA0zVTMdHZ1tc41P2kjKdPNSl/Z0tk3oN4yPg0vgkACbBGzH9m8oc3rlF+zr879/T/Nb7pvUekTPYPzBZPp9Po6OjamtrczsKgGlobW3V2NiYGhsb3Y6CMDGT8dGFRMXFS5L6j/dManvGR8ClUfaBSUiMjJj2D4v97COSpCXGcqXnFU759RGSEiL5UcXcS0pKUkVFhSzLksPtjICg4jiObNtWeXm5kpKS3I6DMDGT8dEH9R8/qkNbN0qSMhcXX3Z7xkfA5fETAkxCTnzktK5JGxsZUcsvnpIkGR/+6LT2Pf7b/QPzwTAM9fT0aM+ePW5HATAFu3fvVk9PDwvzYV5NZXx0eOcWNf/iKY2cPv9Sse49O/Ton/03jQ6fVn6NoZyllZd9P8ZHwOXxEwJMwnQ/TDb/+kWdOtat2KQUVa1aP+/7B6aqsLBQmZmZsixLhYWFbscBMEm2bSszM1MFBQVuR0EYmcr4pP9Yj574H7+vZ7/5x1pUVqPkBYs0NjKsE4e6dGBzm5zxcWUXler+//0fc7J/IBzxEwJMQlacV7Fej4bGpnZq85mF+epvvENRMbHT2nes16OsOO+0XgtMlcfjkWEYevHFF9XX18fpwEAQ6Ovr06ZNm3TjjTfK4+EaZsyfqYyPsovLtPYP/j/tbn5H3bu368CWdo2Njio+JVXFV1yr6lXr5bv1PkVGx0xq34yPgMuj7AOT4PV41JAZq3cOD2oqdf+Bf3pkRvv1SGrIjJWXwRvmUV1dnV5++WU1NTVp5cqVbscBcBl+v1+RkZGqq6tzOwrCzFTGR4lpmbr+v31pVvbL+AiYHK7ZByapPjN2SkV/Nji/3S8wn2JjY1VbWyu/36+xsTG34wC4hLGxMTU1Nam2tlYxMZObEQVmE+MjIHBR9oFJSon2qi4jRvP1HbJHUl1GjFKiOUUN888wDPX19Wnr1q1uRwFwCVu2bFFfXx8L88E1jI+AwEXZB6ZgVW6CEiI9c/6B5pGUEOnRqtyEOd4TcGE5OTnKz8+XZVluRwFwCbZta/HixVqwYIHbURDGGB8BgYmyD0xBjDdC6wuS5vx0NUfS+oIkxXj5EYV7TNPUrl271NPT43YUABfQ3d2tXbt2yTAMt6MgzDE+AgITPynAFBUlR2tN3tx+o1w0dFBFydFzug/gcioqKhQfHy/btt2OAuACbNtWQkKCKioq3I4CaG/z2xppe31O97E2L4HxETAFlH1gGnxZcROFf7ZOWTvzPkWDB7T5xWf0xhtvzNI7A9MTGRmpxsZGtbS0aHh42O04AM4yPDys1tZWNTQ0KDKSmyvBXa+//rpee+01rSzKmrPx0dq8BDVmxc3SuwLhgU8HYJp8WXFKj/Hq53v61D/qzOjUtTPXoK0vSFJRcqZeHzmuV199VZJ07bXXzkpeYDp8Pp9+85vfqKOjQ42NjW7HAfBb7e3tGh4els/nczsKwtyZon/99ddPjFnmZnzEjD4wVZR9YAaKkqP16co0vdrVr9ajp+WRpvShdmb72owYrcpNmLgG7cy9zSn8cFtqaqpKS0tlWZYaGhrk4Z7GgOscx5Ft2yotLVVqaqrbcRDGLlT0pbkbHwGYGso+MEOx3gjdtDhJy3Li1dIzpOaeIQ2Nvf+RFiFp/Kxtz/59rNejhsxY1WfGXvD2MRR+BArTNPXII4+oq6tLeXl5bscBwt7+/ft16NAh3XDDDW5HQRi7WNE/Y67GRwAmj7IPzJKUaK9WLkrQ8oXx6h4c06GBUR0aGFX/6LhGxx1FRniUEBmhnPhI5cRHKivOK+9lZkkp/AgExcXFSktLk2VZlH0gANi2rbS0NBUXF7sdBWHqckX/bHMxPgIwOZR9YJZ5PZ6JD6zZQOGH2zwejwzD0CuvvKJ169YpPj7e7UhA2Orv79fGjRu1atUqLquBK6ZS9M822+MjAJfHBTBAEFi5cqWuu+46vfrqq6zSD1fU19dLkpqbm90NAoS55uZmeTyeiZ9JYD5Nt+gDcAdfrQFBghl+uCk+Pl7V1dWybVtXX321IiL4rhiYb+Pj4/L7/aquruYMG8w7ij4QfBitAUGEGX64yTRNnThxQjt27HA7ChCWtm/frhMnTsgwDLejIMxQ9IHgxMw+EGSY4YdbFi1apIULF8qyLC1dutTtOEDYsW1bixYtUm5urttREEYo+kDwYmYfCELM8MMNHo9Hpmlq27ZtOn78uNtxgLBy/Phxbdu2jVl9zCuKPhDcKPtAkKLwww3V1dWKjY2VbdtuRwHCim3bio2NVXV1tdtRECYo+kDwo+wDQYzCj/kWFRWl+vp6NTc3a3R01O04QFgYGRlRc3Oz6uvrFRUV5XYchAGKPhAaKPtAkKPwY74ZhqHBwUFt3LjR7ShAWOjs7NTg4CCn8GNeUPSB0MECfUAIYNE+zKeMjAwtWbJEtm2rrq7O7ThAyLMsS8XFxcrIyHA7CkIcRR8ILczsAyGCGX7MJ9M0tX//fh08eNDtKEBIO3DggLq6upjVx5yj6AOhh7IPhBAKP+ZLaWmpkpOTZVmW21GAkGbbtpKTk1VaWup2FIQwij4Qmij7QIih8GM+REREyOfzqb29XUNDQ27HAULS4OCg2tvb5fP5FBHBkA1zg6IPhC4+OYAQROHHfGhsbNT4+LhaWlrcjgKEpNbWVo2Pj6uxsdHtKAhRFH0gtLFAHxCiWLQPcy0xMVEVFRWybVtXXnmlPB6P25GAkOE4jizLUmVlpRITE92OgxBE0QdCHzP7QAhjhh9zzTRNHT16VLt27XI7ChBSdu3apWPHjsk0TbejIARR9IHwwMw+EOKY4cdcWrx4sbKzs2XbtpYsWeJ2HCBkWJal7Oxs5efnux0FIYaiD4QPZvaBMMAMP+aKx+ORYRjavHmzent73Y4DhITe3l5t2bJFpmlyeQxmFUUfCC+UfSBMUPgxV2praxUVFSW/3+92FCAk+P1+RUVFqaamxu0oCCEUfSD8cBo/EEY4pR9zISYmRrW1tWpqatK1114rr9frdiQgaI2NjampqUl1dXWKiYlxOw5CBEUfCE/M7ANhhhl+zAXTNHXq1Clt3rzZ7ShAUNu8ebNOnTolwzDcjoIQQdEHwhcz+0AYYoYfsy07O1sFBQWybVtVVVVuxwGClmVZKigoUHZ2tttREAIo+kB4Y2YfCFPM8GO2GYah3bt3q7u72+0oQFA6cuSI9uzZw+32MCso+gAo+0AYo/BjNlVUVCghIUGWZbkdBQhKtm0rMTFR5eXlbkdBkKPoA5Ao+0DYo/Bjtni9XjU2Nqq1tVXDw8NuxwGCyunTp9Xa2qrGxkYWucSMUPQBnEHZB0Dhx6zx+XwaGRlRW1ub21GAoNLe3q6RkRH5fD63oyCIUfQBnI0F+gBIYtE+zI6UlBSVlZXJtm35fD55PB63IwEBz3EcWZalsrIyJScnux0HQYqiD+CDmNkHMIEZfswGwzB0+PBh7du3z+0oQFDYt2+fjhw5wsJ8mDaKPoALYWYfwDmY4cdMLVmyROnp6bJtW4sXL3Y7DhDwLMtSRkaGioqK3I6CIETRB3AxzOwDOA8z/JgJj8cjwzC0ceNG9ff3ux0HCGinTp1SZ2enDMPgshdMGUUfwKVQ9gFcEIUfM1FfX6+IiAg1NTW5HQUIaM3NzYqIiFBdXZ3bURBkKPoALofT+AFcFKf0Y7ri4uJUXV0tv9+va665RhERfLcMfND4+Lhs21ZNTY3i4uLcjoMgQtEHMBmMvgBcEjP8mC7TNHXy5Elt27bN7ShAQNq6dat6e3tZmA9TQtEHMFnM7AO4LGb4MR2LFi1Sbm7uxC3FAJzLtm3l5uZq4cKFbkdBkKDoA5gKZvYBTAoz/JgOwzC0Y8cOHTt2zO0oQEA5evSoduzYwaw+Jo2iD2CqKPsAJo3Cj6mqqqpSXFycbNt2OwoQUGzbVlxcnKqqqtyOgiBA0QcwHZR9AFNC4cdUREVFqb6+Xs3NzRoZGXE7DhAQRkZG1NLSooaGBkVGckUlLo2iD2C6KPsApozCj6kwDENDQ0PauHGj21GAgNDR0aGhoSH5fD63oyDAUfQBzARfJwOYFhbtw2Slp6erpKRElmWpvr7e7TiA62zbVklJidLT092OggBG0QcwU8zsA5g2ZvgxWYZh6MCBA+rq6nI7CuCqrq4uHThwgIX5cEkUfQCzgZl9ADPCDD8mY+nSpUpJSZm41RgQrmzbVkpKikpKStyOggBF0QcwW5jZBzBjzPDjciIiIuTz+dTR0aHBwUG34wCuGBgYUEdHhwzDUEQEQzCcj6IPYDbxSQNgVlD4cTmNjY1yHEctLS1uRwFc0dLSIsdx1NDQ4HYUBCCKPoDZxmn8AGYNp/TjUhISElRZWSnbtnXVVVfJ4/G4HQmYN47jyLZtVVVVKSEhwe04CDAUfQBzgZl9ALOKGX5cimmaOnbsmHbu3Ol2FGBe7dixQ8ePH5dhGG5HQYCh6AOYK8zsA5h1zPDjYvLy8rRgwQJZlqXi4mK34wDzxrZt5eTkKC8vz+0oCCAUfQBziZl9AHOCGX5ciMfjkWma2rp1q06ePOl2HGBenDhxQlu3bpVhGFy+ggkUfQBzjbIPYM5Q+HEhNTU1io6Olt/vdzsKMC/8fr+io6NVU1PjdhQECIo+gPnAafwA5hSn9OODoqOjVVdXp6amJq1cuVJer9ftSMCcGR0dVXNzs+rq6hQdHe12HAQAij6A+cLMPoA5xww/PsgwDPX392vTpk1uRwHm1KZNm9Tf3y/TNN2OggBA0Qcwn5jZBzAvmOHH2bKyslRYWCjLslRdXe12HGDO2LatoqIiZWZmuh0FLqPoA5hvzOwDmDfM8ONspmlq7969Onz4sNtRgDlx+PBh7d27l9vtgaIPwBWUfQDzisKPM8rKypSYmCjbtt2OAswJy7KUlJSksrIyt6PARRR9AG6h7AOYdxR+SJLX65XP51NbW5tOnz7tdhxgVp0+fVptbW1qbGxkEcowRtEH4CbKPgBXUPghSY2NjRoZGVFbW5vbUYBZ1draqtHRUfl8PrejwCUUfQBuY4E+AK5h0T4kJyervLxclmXJMAx5PB63IwEz5jiObNtWRUWFkpKS3I4DF1D0AQQCZvYBuIoZfpimqe7ubu3du9ftKMCs2LNnj7q7u1mYL0xR9AEECmb2AbiOGf7wVlhYqIyMDFmWpYKCArfjADNm27YyMzNVWFjodhTMM4o+gEBC2QcQECj84cvj8cg0Tb344ovq6+vjtGcEtb6+Pm3atElr167lspQwQ9EHEGg4jR9AwOCU/vBVV1cnr9erpqYmt6MAM9LU1CSv16u6ujq3o2AeUfQBBCJm9gEEFGb4w1NsbKxqamrk9/u1YsUKRUTwXTSCz9jYmPx+v2pqahQbG+t2HMwTij6AQMVoCkDAYYY/PJmmqb6+Pm3ZssXtKMC0bN26VX19fTJN0+0omCcUfQCBjJl9AAGJGf7wk5OTo7y8vIlblgHBxrIs5efnKycnx+0omAcUfQCBjpl9AAGLGf7wY5qmdu7cqZ6eHrejAFPS09OjXbt2cbu9MEHRBxAMKPsAAhqFP7xUVlYqPj5etm27HQWYEtu2FR8fr8rKSrejYI5R9AEEC8o+gIBH4Q8fkZGRamhoUEtLi4aHh92OA0zK8PCwWlpa1NDQoMhIrpAMZRR9AMGEsg8gKFD4w4fP59Pp06fV0dHhdhRgUjo6OnT69GlO4Q9xFH0AwYavnwEEDRbtCw9paWlaunSpLMtSQ0ODPB6P25GAi3IcR5ZlqbS0VKmpqW7HwRyh6AMIRszsAwgqzPCHB9M0dejQIXV1dbkdBbikrq4uHTp0iNvthTCKPoBgxcw+gKDDDH/oKykpUWpqqmzbVl5enttxgIuyLEtpaWkqLi52OwrmAEUfQDBjZh9AUGKGP7R5PB4ZhqGOjg4NDAy4HQe4oIGBAW3cuFGGYXC5SQii6AMIdpR9AEGLwh/aGhoaJEnNzc0uJwEu7My/zfr6eneDYNZR9AGEAk7jBxDUOKU/dMXHx6u6ulq2bWvZsmXMnCKgjI+Py7ZtVVdXKz4+3u04mEUUfQChgpl9AEGPGf7QZRiGTpw4oe3bt7sdBTjHjh07dOLECRbmCzEUfQChhJl9ACGBGf7QlJubq4ULF8q2bS1dutTtOMAEy7K0cOFCLVq0yO0omCUUfQChhpl9ACGDGf7Qc2ahvq1bt+rEiRNuxwEkScePH9e2bdtkmiaXl4QIij6AUETZBxBSKPyhp6amRjExMbJt2+0ogCTJ7/crNjZW1dXVbkfBLKDoAwhVlH0AIYfCH1qioqJUX1+v5uZmjY6Ouh0HYW50dFTNzc2qr69XVFSU23EwQxR9AKGMsg8gJFH4Q4thGBoYGFBnZ6fbURDmOjs7NTAwIMMw3I6CGaLoAwh1LNAHIGSxaF/oyMzM1JIlS2Tbtmpra92OgzBmWZaWLFmijIwMt6NgBij6AMIBM/sAQhoz/KHDMAzt27dPhw4dcjsKwtTBgwe1f/9+brcX5Cj6AMIFZR9AyKPwh4aysjIlJSXJsiy3oyBM2bat5ORklZaWuh0F00TRBxBOKPsAwgKFP/hFRETI5/Opvb1dQ0NDbsdBmBkaGlJ7e7t8Pp8iIhg+BSOKPoBww6cVgLBB4Q9+jY2NGhsbU2trq9tREGZaW1s1NjamxsZGt6NgGij6AMIRC/QBCCss2hfckpKSVFFRIdu2dcUVV8jj8bgdCWHAcRxZlqWKigolJia6HQdTRNEHEK6Y2QcQdpjhD26GYainp0e7d+92OwrCxK5du3T06FEW5gtCFH0A4YyZfQBhiRn+4FVQUKCsrCxZlqWioiK34yAM2LatrKwsLV682O0omAKKPoBwx8w+gLDFDH9w8ng8MgxDmzdvVm9vr9txEOJ6e3u1efNmmabJZSNBhKIPAJR9AGGOwh+c6urqFBkZqaamJrejIMT5/X5FRUWptrbW7SiYJIo+ALyP0/gBhD1O6Q8+MTExqq2tld/v14oVK+T1et2OhBA0NjampqYm1dbWKiYmxu04mASKPgD8F2b2AUDM8Acj0zR16tQpbdmyxe0oCFGbN2/WqVOnZBiG21EwCRR9ADgXM/sA8FvM8AeXBQsWaPHixbIsS5WVlW7HQQiybVuLFy/WggUL3I6Cy6DoA8D5mNkHgLMwwx9cDMPQ7t271d3d7XYUhJju7m7t3r2b2+0FAYo+AFwYZR8APoDCHzwqKiqUkJAg27bdjoIQY1mWEhISVFFR4XYUXAJFHwAujrIPABdA4Q8OkZGRamhoUGtrq4aHh92OgxAxPDys1tZWNTY2svhjAKPoA8ClUfYB4CIo/MHBMAwNDw+rvb3d7SgIEW1tbRoZGZHP53M7Ci6Cog8Al8cCfQBwCSzaF/hSUlJUWloqy7LU2Ngoj8fjdiQEMcdxZNu2ysrKlJKS4nYcXABFHwAmh5l9ALgMZvgDn2maOnz4sPbv3+92FAS5ffv26fDhw9xuL0BR9AFg8pjZB4BJYIY/sC1ZskTp6emyLEv5+flux0EQs21b6enpWrJkidtR8AEUfQCYGmb2AWCSmOEPXB6PR4ZhqLOzU/39/W7HQZDq7+/Xxo0bZRgGl4MEGIo+AEwdZR8ApoDCH7jq6+vl8XjU3NzsdhQEqaamJkVERKi+vt7tKDgLRR8ApofT+MPImOOoe3BMhwZGdWhgVKdGxzU27sgb4VFiZIRy4iOVEx+prDivvMxoABfFKf2BKS4uTtXV1bJtW8uWLVNEBN9nY/LGx8fl9/tVXV2tuLg4t+Pgtyj6wNQw3sfZKPth4OTwmFp6htTcM6ShMUfS+6d0jJ+1TYSklqPv/zrW61FDZqzqM2OVEs39hYELofAHJtM01dLSou3bt6u0tNTtOAgi27Zt08mTJ2WapttR8FsUfWDyGO/jQij7IWxobFyvdvWr9ehpeSQ5Zz03/oFtx895naN3Dg/q7cODqsuI0arcBMV4mSEDPojCH3gWLVqkRYsWybIsyj6mxLZt5ebmatGiRW5HgSj6wGQx3selUPZD1K7eYT2/p08Do+//yDuX2f6DzmzfdvS0dpwc1vqCJBUlR89qRiAUUPgDj2maeu6553Ts2DGlp6e7HQdB4NixY9q+fbtuu+02t6NAFH1gshjv43L4+iYE+bsH9fiOXg2MOlP+of8gR1L/qKPHd/TK3z04G/GAkMOifYGlqqpKsbGx8vv9bkdBkLBtW3FxcaqqqnI7Stij6AOTw3gfk0HZDzH+7kFt2P/+badm+oN/xpn32bC/nwMAcBEU/sARFRWlhoYGNTc3a2RkxO04CHAjIyNqaWlRfX29oqKi3I4T1ij6wOQw3sdkcRp/CNnVOzzxg38pJw7u1+s/+La2v/u6ThzqkhxHSZkLVNh4lVZ87Pe1sLT6oq/dsL9f6TFeTvEBLoBT+gOHYRh6++231dnZqbq6OrfjIIBt3LhRg4ODMgzD7ShhjaIPTM6lxvtjIyPa1fS2tr71inb639TRvTs1PDSg+JQ05Vc16oo7P67yFWsvuw/G+6GDmf0QMTQ2ruf39OlyN9DY2+7XP96zQu888f80PDigpVddp7JrVksej5qff0L/8rE1at/w3EVf75H08z19Oj32wSU/AEjM8AeK9PR0FRcXy7Ist6MgwNm2rZKSEtZ3cBFFH5icy433dzW9pf/8/Tv16x99R71HDqig/kpVXb9eCWmZ2vTGC/rBFz+qn3zjj+U4lz4fgPF+6GBmP0S82tU/qWt2fvKNP9bp/lO64o6P69Y/+9/y/vaUxfHxcb30b3+jV//vP+iZb/yxyq9dp6iY2PNef+aanle6+nXT4qTZ/4MAIYAZ/sBgmqZ+/OMf68CBA6ywjgs6cOCAurq6dO+997odJWxR9IHJu9x43+OJUPUNN2vZfZ9RUePV5zzX9sJP9Pj/+H2998wPVVB/hRpv/shF98N4P3Qwsx8CTpweU+vR05ct+v0njunQto2SpDV/8BcTRV+SIiIitPqzf6qo2DgN9Z1U966tF30fR1Lr0dM6OTw2C+mB0MQMv/uWLl2qlJQU2bbtdhQEKMuylJKSoqVLl7odJSxR9IHJm8x4v/iKFfro337/vKIvSbXrblfjLe9/sdn0/BOX3R/j/dBA2Q8BrUeHLnv6viRFRk/+upv41IxLPu+R1NIzNOn3A8IRhd9dERER8vl8am9v1+Agiw3hXIODg+ro6JDP51NEBMOh+UbRB6ZmsuP9S1lUViNJOnm4a1LbM94Pfny6Bbkxx1Fzz9CkVuKMiU9UYcNVkqQN3/lrjZ21SvX4+Lhe+t63NDI0qNJrblBqTu4l38uR1NwzpLHLXPMDhDsKv7saGho0Pj6ulpYWt6MgwLS0tGh8fFyNjY1uRwk7FH1gaqYy3r+Unr07JUlJmQsmtT3j/eDHNftBrntwTENjk/8BvON//h899If36b1nfqjNv9mgvMp6eSIidGBLh3qPHFTD+nt065/970m919CYo+7BMeXE888IuBSu4XdPYmKiKisrZdu2rrrqKnk8M50XQShwHEe2bauqqkoJCQluxwkrFH1g6qY63r+Qvp7DavrZjyVJ1TfcPOnXMd4PbszsB7lDA6NT2j6rsES//9AvtPSq69R75KA6X/ulNr7ycx3v2qOM/CIt8S1TbOLkF+KY6v6BcMUMv3tM09SxY8e0c+dOt6MgQOzcuVPHjh3jdnvzjKIPTM9Mx9tjo6N6/H98TkOnepVTUqkr7nxgXvcP9/AVTZA7NDCqCEmTvTHG7pZ39ciXP6kIr1cf+avvqdhcrsioaO1ueU8//4f/qae//kfa0/qe7vzKP132vSLEDz8wFczwuyM/P1/Z2dmybVvFxcVux0EAsCxLCxYsUH5+vttRwgZFH5i+qY73P+jZv/qydrz3huJT03X/3/4/RUZNfh0vxvvBjZn9IHdqdHzSP/iDfSf18B9/Qv3He/TRv3tI9TfeoaSMbMUlp6ri2rX61L88rqjYeNnPPaod1m8u+37jkvpHuf8mMBXM8M8/j8cj0zS1ZcsWnTx50u04cNnJkye1detWGYbBZR3zhKIPzMxUxvsf9LO//f9kP/uI4pJT9d/+9UllFUztS2/G+8GNsh/kxsYnf/3O5l9vUP/xHqXlFmhxje+859PzCpVf/f5CRdvffX1S7zk6hf0DeB+Ff/7V1NQoKipKfr/f7Shwmd/vV1RUlGpra92OEhYo+sDMTWW8f7af/8ODeuux/1BsUoo+9a9PalH59I57jPeDF6fxBzlvxORnJU4e2i9Jl7wmPzYpWZI02HtiUu8ZOYX9A/gvnNI/v2JiYlRXV6empiatXLlSXq/X7UhwwdjYmJqamlRXV6foKdyOFtND0Qdmx1TG+2f88h+/pt88/F3FJibrU//6pPIq66e9f8b7wYuZ/SCXGBkx6f+JydkLJUndu7drqK/3vOfHRkZ0YFObJClt0eLLvl+EpIRI/gkB08UM//wyDEP9/f3atGmT21Hgkk2bNqm/v1+mabodJeRR9IHZM5XxviT96p+/rjd++C/vF/3vPqX8qoZp75vxfnDj/1yQy4mPnPQ1PKXX3KDouHiNDA3qmW98SacHTk08NzoyrOf//n/oxKH98kZGqWb1LZd9v/Hf7h/A9FH45092drYKCgpk27bbUeASy7JUWFiorKwst6OENIo+MLumMt5/8Tt/pdcf+vb7p+7PsOhLjPeDHf/ngtxUfvgS0zL14f/v7/TU1/5Q7Rt+qp32W8qrqpc3Mkr7O1vUe+SgPBERuuVP/0rpeYWzvn8AF8Yp/fPHNE099dRTOnLkiLKzs92Og3l0+PBh7d27V3fffbfbUUIaRR+YfZMdb3e+/iu9+p//R5KUkV+kd574T71zge0SUjP0oS99bdb3j8DD/7kglxXnVazXo6GxyS2c0bD+buUsrdCbj3xPu5rf0Y73fi3HcZSUuUD1N92lZff97sQifZfjHR9VRP8JKT5zBn8CABKFf76Ul5crMTFRlmVp/fr1bsfBPLJtW4mJiSorK3M7Ssii6AOzr6enR822X0qrkqJjL7nt4MnjE7/u6mxRV2fLBbdLXZg/6bIf6/UoK451boIVZT/IeT0eNWTG6p3Dg5rsOpkLS6t119e+PbMdO47G92zUd5//jZYsWSLDMFRWVqaICK4MAaaLwj/3vF6vGhsb9c4772j16tWKiYlxOxLmwenTp9XW1qarr76axRnnCEUfmD3j4+PasmWLLMvSrl27FB8fr5xleTocHXvJ8b7v1vvku/W+WcvhkdSQGSsvtykNWpT9EFCfGau3Dw/O7049Hn36xhXqKsmSbdt64oknlJSUJJ/Pp8bGRiUlXXzFfwAXR+Gfez6fT7/+9a/V1tbGQm1hoq2tTSMjI2psnNyZa5gaij4wO/r6+tTU1CS/36++vj7l5+fr9ttvV2VlpfrHPfruxuOXf5NZ5Oj9noHgRdkPASnRXtVlxKjt6OlJz+7PhEdSbUaMMuKjlVFbq9raWh06dEiWZenNN9/UG2+8oYqKChmGoYKCAnn4NhCYEgr/3EpOTlZ5ebls25ZhGByjQpzjOLIsS+Xl5UpOTnY7Tsih6AMz4ziO9uzZI8uytHnzZnm9XtXU1Mg0TeXk5ExslyK5Mt5PieZsqGBG2Q8Rq3ITtOPksPpHnTk9AHgkJUR6tCo34ZzHc3JydMstt2jNmjVqbW2Vbdv6wQ9+oKysLBmGobq6Ok6XBaaAwj+3DMPQj370I+3du1cFBQVux8Ec2rt3r7q7u3XTTTe5HSXkUPSB6Tt9+vTEmLm7u1uZmZlau3at6urqFBt74dl0t8f7CD6U/RAR443Q+oIkPb6jd07340haX5CkGO+Fr82PjY3VlVdeqSuuuEK7d++Wbdv61a9+pZdeekm1tbUyTVMLFiyY04xAqKDwz52ioiJlZGTItm3KfoizLEsZGRkqLCx0O0pIoegD03P48GFZlqW2tjaNjo6qoqJCN910kwoLCy97plmgjPcRPCj7IaQoOVpr8hK0YX//nO1jbV6CipKjL7udx+NRUVGRioqK1NvbO3H9kd/v1+LFi2UYhiorK1koCbgMCv/c8Hg8MgxDGzZs0Lp165SYmOh2JMyBU6dOadOmTVq7di2Xa8wiij4wNaOjo9q0aZNs29bevXuVlJSkZcuWqbGxccqXFwXSeB+Bj7IfYnxZcZKkDfv75ZFm5RSfM++zNi9Bjb99/6lITk7WddddpxUrVkysLPrMM8/ohRdeUENDgwzDUEpKyiwkBUIThX9u1NfX6+WXX1ZTUxN/pyGqqalJXq9XdXV1bkcJGRR9YPJOnjwp27bV3Nys/v5+FRUV6e6771ZZWdmMJrwCcbyPwETZD0G+rDilx3j18z19M76m58w1O+sLkmb8DZ/X61VlZaUqKyvV3d0t27YnFvUrLS2VYRgqLi5m9gW4AAr/7IuNjVVNTY38fr+WL1/OrUNDzPj4uPx+v2pqai56/SumhqIPXJ7jONqxY4ds29bWrVsVHR2turo6GYahrKysWdtPoI73EVgo+yGqKDlan65M06td/Wo9enrK3/qd2b42I0archNm/ZqdrKws3XTTTbrhhhvU3t4uy7L0yCOPKD09XYZhqL6+XnFxfKsInI3CP/tM01Rzc7O2bt2q8vJyt+NgFm3dulW9vb3cXnGWUPSBSxscHFRzc7Ns29bx48e1YMECrV+/XjU1NYqOnpsCHejjfbiPsh/CYr0RumlxkpblxKulZ0jNPUMaGnv/EBAhafysbc/+fazXo4bMWNVnxs757Taio6Pl8/nU2Nio/fv3y7Isvfzyy3rllVdUXV0t0zS1aNGiOc0ABBMK/+xauHCh8vLyZNs2ZT/EWJalvLy8c25dhemh6AMX19XVJdu21dHRIcdxVFlZqdtvv115eXnzcrZqMIz34R7KfhhIifZq5aIELV8Yr+7BMR0aGNWhgVH1j45rdNxRZIRHCZERyomPVE58pLLivPLO86n0Ho9H+fn5ys/P17p16ya+GW1padGiRYtkmqaqqqoUFRU1r7mAQEThn12GYejZZ5/V0aNHlZGR4XYczIKjR49q586duv32292OEvQo+sD5RkZG1NHRIdu2deDAAaWkpGjlypVqaGhQQoI7t6sLhvE+5h9lP4x4PZ6JH/BAlpCQoOXLl2vZsmXavn27LMvSc889d86Cfunp6W7HBFxF4Z89VVVVeuGFF2TbttatW+d2HMwC27YVHx+vyspKt6MENYo+cK5jx47Jsiy1tLRoaGhIJSUluu+++1RSUhIw674Ey3gf84N/BQhYERERKi0tVWlpqY4dOya/36/m5ma9/fbbKi4ulmmaWrp0acAcXIH5RuGfHZGRkWpoaFBTU5NWrVrFGURBbmRkRC0tLfL5fIqMZJgzXRR94H3j4+Patm2bLMvSjh07FBcXp8bGRvl8PiafEPD4FERQSE9P15o1a3Tdddeps7NTlmXpxz/+sVJSUuTz+dTQ0MB9shGWKPyzwzAMvfXWW+ro6FBDQ4PbcTADHR0dGhoaks/ncztK0KLoA9KpU6fU3Nwsv9+vkydPKjc3Vx/+8IdVWVnJl8IIGpR9BJWoqCjV1dWprq5OBw4ckG3beuONN/Taa6+psrJSpmkqPz+f2/chrFD4Zy4tLU1Lly6VbduU/SDmOI4sy9LSpUuVlpbmdpygRNFHOHMcR/v27ZNlWers7FRERIRqampkGAYLRiMoUfYRtBYtWqRbb71Va9asUWtrqyzL0ve//31lZ2fLNE3V1NQoJibG7ZjAvKDwz5xhGHrsscfU1dWl3Nxct+NgGrq6unTw4EHdf//9bkcJShR9hKvTp09P3Ar6yJEjE2eU1tXVcStoBDXKPoJeXFycrrrqKl155ZXatWuXLMvSL37xC23YsEF1dXUyDEPZ2dluxwTmHIV/ZkpKSpSamirLsij7Qcq2baWmpqq4uNjtKEGHoo9wdOTIEdm2rdbWVo2MjKisrEzr1q1TUVERZ4kiJFD2ETI8Ho+WLFmiJUuW6OTJk2pqapLf75dlWSooKJBpmiovL5fXy71EEboo/NMXEREhn8+n1157TWvXrlV8fLzbkTAFAwMD6ujo0PXXX8/CrVNE0Uc4GRsb0+bNm2VZlvbs2aOEhARdddVVamxsVEpKitvxgFlF2UdISklJmRi0bNq0SbZt66mnnlJiYuLECqrJycluxwTmBIV/+hoaGvTaa6+ppaVFy5YtczsOpqC5uVmSWHNhiij6CBe9vb3y+/1qamrSqVOnVFBQoLvuuouJIIQ0yj5CmtfrVXV1taqrq3XkyBFZlqV33nlHv/71r1VWVibTNDlVCyGJwj89CQkJqqqqkm3buvrqqzk2BAnHcWTbtqqqqjgjYwoo+gh1juNMXOK5ZcuWiYWeucQT4YKyj7CRnZ2t9evXa/Xq1Wpra5Nt2/rRj36kjIwMGYah+vp6xcbGuh0TmDUU/ukxDENtbW3asWOHSkpK3I6DSdi+fbtOnDihO++80+0oQYOij1A2ODio1tZW2bato0ePKjs7Wx/60IdYvBlhh7KPsBMTEyPTNGUYhvbu3SvbtrVhwwa9/PLLqqmpkWmaWrhwodsxgVlB4Z+6vLw85eTkyLIsyn6QsG1bOTk5LKw4SRR9hKqDBw/Ksiy1t7drfHxclZWVuvXWW7ktM8IWZR9hy+PxqKCgQAUFBVq3bt3Egn7Nzc3Ky8uTYRiqqqpSZCQ/JghuFP6p8Xg8MgxDzz//vE6cOKHU1FS3I+ESTpw4oa1bt+qWW25hMD8JFH2EmtHRUW3cuFGWZamrq0vJyclasWKFGhsblZiY6HY8wFW0GEBSYmKirr32Wi1fvlxbt26Vbdt69tln9cILL6ihoUGGYSgtLc3tmMC0UfinpqamRhs2bJDf79cNN9zgdhxcgm3biomJUXV1tdtRAh5FH6Hk+PHjsm1bzc3NGhwcVHFxsT7ykY+otLSUO3IAv0XZB84SERGh8vJylZeX6+jRo7JtW01NTXrrrbe0dOlSGYahkpISPkQQlCj8kxcdHa26ujo1NTVp5cqVnOEToEZHR9Xc3Kz6+npFR0e7HSegUfQRCsbHx7V9+3ZZlqXt27crNjZW9fX1MgxDGRkZbscDAg6jF+AiMjIytG7dOq1atUodHR2yLEuPPfaYUlNT5fP51NDQoISEBLdjAlNC4Z880zT13nvvadOmTaqpqXE7Di6gs7NTAwMDMgzD7SgBjaKPYNff36/m5mb5/X6dOHFCCxcu1K233qrq6mpFRUW5HQ8IWJR94DKioqLU0NCghoYGdXV1ybZtvfbaa3rttddUVVUlwzCUl5fHtaIIGhT+ycnMzFRRUZEsy6LsByjbtrVkyRJlZma6HSVgUfQRrBzH0f79+2XbtjZu3CiPx6Pq6moZhsFinMAkUfaBKcjNzVVubq7WrFmjlpYW2battrY25eTkyDAM1dTUcCopggKFf3JM09QTTzyhQ4cOKScnx+04OMuhQ4e0b98+3XPPPW5HCVgUfQSj4eFhtbe3y7ZtHTp0SGlpaVq1apXq6+sVHx/vdjwgqFD2gWmIj4/XsmXLdPXVV2vHjh2yLEvPP/+8NmzYoLq6OpmmyUwTAh6F//LKysqUlJQk27Z18803ux0HZ7EsS0lJSSorK3M7SkCi6CPY9PT0yLIstba2anh4WKWlpbrhhhtUXFzM2ZPANFH2gRnweDwqKSlRSUmJTpw4Ib/fr6amJr333nsqKiqSYRgqLy9nQT8ELAr/pUVERMjn8+nNN9/U6tWrFRsb63YkSBoaGlJ7e7uuueYajq8XQNFHsBgbG9OWLVtk27Z27dql+Ph4maYpn8/HbU+BWUDZB2ZJamqqbrjhBq1cuVKbNm2SZVl68sknlZSUJJ/Pp8bGRiUlJbkdEzgPhf/SGhsb9cYbb6itrU1XXHGF23EgqbW1VWNjY2psbHQ7SsCh6CMY9PX1TUyQ9PX1afHixbrjjjtUUVHB3U+AWcRPEzDLIiMjVVNTo5qaGh06dEi2bevNN9/UG2+8ofLycpmmqYKCAk5JQ0Ch8F9cUlKSysvLZVmWTNPkZ9dljuPItm1VVFTwBeoHUPQRyBzH0e7du2XbtjZt2qTIyEjV1tbKMAzWRAHmCGUfmEM5OTm6+eabtXr1arW1tcmyLP3gBz9QZmamTNNUbW0tpwUjYFD4L840Tf3gBz/Qnj17VFhY6HacsLZ792719PRo/fr1bkcJKBR9BKqhoSG1trbKtm319PQoMzNTN954I2MgYB5Q9oF5EBsbqyuuuEKmaWrPnj2yLEsvvPCCXnrpJb7VRkCh8F9YQUGBMjMzZVkWZd9ltm0rKytLBQUFbkcJGBR9BKJDhw7Jsiy1t7drbGxM5eXlWr9+PWc3AvOIsg/MI4/Ho8LCQhUWFqqvr09NTU3y+/3y+/3Kz8+XaZpcrwbXUfjP5/F4ZJqmXnjhBfX19XH6uEv6+vq0adMm3XjjjZSF36LoI5CMjo5OrFu0b98+JSUl6ZprrmHdIsAlNArAJUlJSVq5cqWWL1+urVu3yrIsPfPMM4qPj1djYyMr0cJVFP7z1dbW6qWXXlJTU9PE3w/ml9/vV2RkpOrq6tyOEhAo+ggUZ9+RaGBgQEVFRbrnnntUWloqr9frdjwgbFH2AZd5vV5VVFSooqJCPT09sm1blmXpzTff1NKlS2WaJveYhSso/OeKjY1VbW2t/H6/li9fzgB2no2NjampqUm1tbWKiYlxO47rKPpwm+M42rFjhyzL0tatWxUTE6P6+noZhqHMzEy34wEQZR8IKGcWrVm1apU6OjpkWZYeeeQRpaWlyTAM1dfXKz4+3u2YCCMU/nMZhiG/36+tW7eqoqLC7ThhZcuWLerr65Npmm5HcR1FH24aGBhQS0uLbNvW8ePHlZOTo1tuuUXV1dWKjo52Ox6As1D2gQAUHR2txsZGNTQ0qKurS5Zl6ZVXXtErr7yi6upqmaap3Nxct2MiTFD4/0tOTo7y8/NlWRZlf57Ztq3FixdrwYIFbkdxFUUfbnAcRwcOHJBlWero6JAkVVVV6Y477lBubi5nHwIBirIPBDCPx6O8vDzl5eVp7dq1E9+kt7a2auHChTJNU9XV1YqKinI7KkIchf+/mKapZ555ZuIWUph73d3d2rVrl+644w63o7iKoo/5NjIyMnGm4cGDB5Wamqrrr79e9fX1SkhIcDsegMug7ANBIiEhQddcc42uvvpqbd++XbZt66c//alefPHFiWvkMjIy3I6JEEbhf19FRYXi4+Nl27ZuvPFGt+OEBdu2lZCQENZnU1D0MZ+OHj0q27bV0tKioaEhLV26VPfff7+Ki4sVERHhdjwAk0TZB4JMRESESktLVVpaquPHj8u2bTU3N+udd97RkiVLZJqmSktL+TDGnKDwS5GRkWpsbJRlWVq1ahXXqM6x4eFhtba2yjTNsL0tKUUf82F8fHzi7kA7d+5UXFycfD6ffD6f0tLS3I4HYBrC81MTCBFpaWlas2aNrr/+em3cuFG2bevxxx9XcnKyfD6fGhsblZiY6HZMhBgKv+Tz+fSb3/xG7e3t8vl8bscJae3t7RoeHg7bv2eKPubaqVOn1NTUJL/fr97eXuXl5en2229XZWVl2H7BBoQKfoKBEHDmvtN1dXU6ePCgLMvSr3/9a73++uuqrKyUYRhavHgxC+hg1oR74U9NTVVpaals21ZjYyM/W3PEcRxZlqXS0lKlpqa6HWfeUfQxVxzH0d69e2VZljZt2iSv16uamhoZhqGFCxe6HQ/ALKHsAyFm4cKFuvXWW89Z0O+hhx5Sdna2DMPgHtWYNeFe+E3T1COPPKL9+/crPz/f7Tghaf/+/Tp8+LBWr17tdpR5R9HHXDh9+rTa2tpkWZa6u7uVkZGhNWvWqL6+XrGxsW7HAzDLKPtAiIqNjdVVV12lK6+8Urt27ZJt2/rlL3+pl156SbW1tTJNU9nZ2W7HRJAL58JfXFystLQ02bZN2Z8jlmUpLS1NxcXFbkeZVxR9zLYjR47Isiy1tbVpZGRE5eXluvHGG1VUVMSZSUAIo+wDIc7j8WjJkiVasmSJent75ff71dTUJNu2VVBQIMMwVFFRIa/X63ZUBKlwLfwej0eGYeiVV17R2rVruQ3VLOvv71dnZ6dWrVoVVmWEoo/ZMjY2pk2bNsmyLO3du1eJiYm66qqr5PP5lJyc7HY8APOAsg+EkeTk5IkB5ObNm2Xbtp5++mklJCSosbFRPp9PKSkpbsdEEArXwl9fX69XXnlFzc3NWr58udtxQkpzc7M8Ho/q6+vdjjJvKPqYDSdPnpz4Yr+/v1+FhYW66667VF5ezhf7QJih7ANhyOv1qqqqSlVVVTpy5Ihs29a7776r3/zmNyorK5NhGFqyZElYzaZh5sKx8MfHx6u6ulp+v1/Lli3jlpezZHx8XLZtq7q6WvHx8W7HmRcUfcyE4zjauXOnbNvWli1bFBUVpbq6OpmmqaysLLfjAXAJZR8Ic9nZ2frQhz6kG264Qe3t7bIsSw8//LDS09NlGIbq6+sVFxfndkwEiXAs/KZpqrW1Vdu3b1dpaanbcULC9u3bdfLkSRmG4XaUeUHRx3QNDg5OLMZ77Nixic/02tpaRUdHux0PgMso+wAkSTExMTIMQz6fT/v27ZNlWXrppZf0yiuvqLq6WqZpatGiRW7HRBAIt8K/aNEiLVy4ULZtU/ZniWVZWrRokXJzc92OMuco+piOAwcOyLIsdXR0aHx8XFVVVbrtttuUn5/PWXkAJlD2AZzD4/Fo8eLFWrx4sdatW6fm5mbZtq2Wlhbl5ubKMAxVVVUpKirK7agIYOFU+D0ej0zT1E9/+lMdP35caWlpbkcKaseOHdP27dt12223uR1lzlH0MRUjIyPauHGjbNtWV1eXUlJSdO2116qhoUGJiYluxwMQgCj7AC4qMTFRK1as0DXXXKNt27bJsiw999xzevHFF9XQ0CCfz6f09HS3YyJAhVPhr66u1osvvijbtrVmzRq34wQ1v9+v2NhYVVVVuR1lTlH0MVnHjh2b+NJ9cHBQJSUluvfee7V06VLWCQFwSZR9AJcVERGhsrIylZWVTQw6mpqa9NZbb6mkpESmaaqkpIRBB84TLoU/KipK9fX1am5u1vXXX6/ISD5ep2NkZETNzc1qaGgI6bOHKPq4nPHxcW3btk22bWv79u2KjY1VQ0ODDMPgS3YAk8ZoBMCUpKena+3atbr++uu1ceNGWZalxx57TCkpKTIMQw0NDdxvHOcIl8JvGIbeeecdbdy4UXV1dW7HCUqdnZ0aHBwM6YX5KPq4lP7+fjU1Ncnv9+vkyZNatGiRbrvtNi6fAzAtlH0A03JmJrO+vl5dXV2ybXtiEFtZWSnTNJWXl8dCQZAUHoU/IyNDxcXFsm2bsj9NlmWpuLg4ZGcuKfq4EMdxtG/fPtm2rY0bNyoiIkLV1dUyDCMsFqkEMHco+wBmLDc3V7m5uVq7du3ELYDa29u1YMECmaapmpoabgGEsCj8hmHo8ccf18GDB7Vw4UK34wSVAwcOqKurS/fee6/bUeYERR8fNDw8PHHL28OHDys9PV2rV6/mlrcAZg1lH8CsiYuL09VXX62rrrpKO3fulGVZ+vnPf64NGzaorq5OhmEoKyvL7ZhwUagX/tLSUiUnJ8uyLN16661uxwkqtm0rJSVFS5cudTvKrKPo42zd3d2ybVutra0aHh5WaWmp1qxZoyVLlnA2HIBZRdkHMOs8Ho+Ki4tVXFyskydPyu/3q6mpSe+9954KCwtlmqbKysrk9XrdjgoXhHLhj4iIkM/n069//WutXbtWsbGxbkcKCoODg2pvb9e1114bcgt9UvQhSWNjY9qyZYssy9Lu3buVkJCgK664Qj6fTykpKW7HAxCiKPsA5lRKSopWrVqllStXatOmTbIsS08++aQSExPl8/nU2Nio5ORkt2NinoVy4W9sbNTrr7+ulpYWXXXVVW7HCQqtra0aHx9XQ0OD21FmFUUfvb29EwvunTp1SosXL9add96piooKvvAGMOco+wDmhdfrVXV1taqrq3X48GHZtq23335bb7zxhsrLy2WapgoLCzmFMYyEauFPTExUZWWlbNvWlVdeyb/py3AcR5ZlqbKyUomJiW7HmTUU/fDlOI52794ty7K0efNmRUVFqba2VoZhaMGCBW7HAxBGKPsA5t2CBQu0fv16rV69Wm1tbbIsSz/84Q+VmZkpwzBUV1fH6c9hIlQLv2EYeuihh7Rr1y4tWbLE7TgBbdeuXTp27Jhuu+02t6PMGop+eBoaGlJra6ts21ZPT4+ysrJ00003qba2VjExMW7HAxCGKPsAXBMTEyPTNGUYhvbu3SvLsvTiiy/q5ZdfVk1NjUzTVE5OjtsxMcdCsfAvXrxY2dnZsm2bsn8ZlmUpOztb+fn5bkeZFRT98HPo0CFZlqX29naNjY2poqJCN998sxYvXsyZPQBcRdkH4DqPx6OCggIVFBSor69v4vrGpqYm5eXlyTRNVVZWKjKSQ1aoCrXC7/F4ZBiGfvnLX6q3t5d1KS6it7dXW7Zs0Yc+9KGQKEUU/fAxOjqqzs5OWZal/fv3Kzk5WcuXL1djY2NIXY4CILgxcgYQUJKSkrRy5UqtWLFCW7ZskW3b+slPfqIXXnhBDQ0N8vl8SktLczsm5kCoFf7a2lq99NJL8vv9uv76692OE5D8fr+ioqJUU1PjdpQZo+iHh+PHj8vv96u5uVkDAwNasmSJPvKRj6i0tDTk7iQBIPhR9gEEpIiICFVUVKiiokI9PT2ybVu2bevNN99UaWmpDMNQSUlJSMwG4r+EUuGPiYlRbW2tmpqadO2117Ly9geMjY2pqalJdXV1QX89M0U/tI2Pj2vHjh2yLEvbtm1TbGys6uvrZRiGMjIy3I4HABdF2QcQ8DIzM3XjjTdq1apV6ujokGVZevTRR5WamirDMNTQ0KD4+Hi3Y2KWhFLhN01Ttm1r8+bNqqqqcjtOQNm8ebNOnTolwzDcjjIjFP3QNTAwoObmZtm2rRMnTignJ0e33HKLampqFBUV5XY8ALgsyj6AoBEdHa3GxkY1NDSoq6tLtm3r1Vdf1auvvqrq6moZhqHc3Fxm+0NAqBT+7OxsFRQUyLZtyv4HWJalgoICZWdnux1l2ij6ocdxHHV1dcmyLG3cuFGSVF1drTvvvJPPFwBBh7IPIOh4PB7l5eUpLy9Pa9eunZh5aW1t1cKFC2UYBjMvISBUCr9hGHr66ad15MiRoC62s+nIkSPas2eP7rrrLrejTBtFP7SMjIyovb1dlmXp0KFDSk1N1fXXX8+ZYwCCGmUfQFCLj4/XNddco2XLlmn79u2ybVs/+9nPtGHDBtXV1ck0Ta6pDGKhUPgrKiqUkJAg27b1oQ99yO04AcGyLCUmJqq8vNztKNNC0Q8dZ9aEaWlp0enTp1VaWqpVq1axJgyAkEDZBxASPB6Pli5dqqVLl56zWvK7776rJUuWyDAMlZWVsVpyEAr2wu/1etXY2Kh3331XN9xwQ9AvRjdTp0+fVltbm6666qqgXLSQoh/8xsfHJ+72snPnTsXHx8swDBmGodTUVLfjAcCsoewDCDlpaWlavXq1rrvuuon7ID/xxBNKSkqSz+dTY2OjkpKS3I6JKQj2wu/z+fSb3/xG7e3tQb8g3Uy1tbVpZGREPp/P7ShTRtEPbn19fWpqapLf71dfX5/y8/N1++23q7KyUpGRDIkBhB6ObABCVmRkpGpra1VbW6uDBw9O3LrvjTfeUEVFhQzDUEFBAadqBolgLvwpKSkqKyuTZVny+Xxh+2/OcRzZtq2ysjIlJye7HWdKKPrByXEc7dmzR7Zta9OmTfJ6vaqpqZFpmsrJyXE7HgDMKco+gLCwcOFC3XLLLVqzZo1aW1tlWZZ+8IMfKCsrS4ZhhMS9vsNBMBd+wzD08MMPa9++fVq8eLHbcVyxd+9eHTlyROvWrXM7ypRQ9IPP6dOn1draKtu21d3drczMTK1du1Z1dXWKjY11Ox4AzAvKPoCwEhsbqyuvvFJXXHGFdu/eLcuy9Ktf/Uovv/yyamtrZRiGFixY4HZMXEKwFv4lS5YoPT1dlmWFbdm3bVsZGRkqKipyO8qkUfSDy+HDh2VZltra2jQ6OqqKigrddNNNKiwsDNszagCEL8o+gLDk8XhUVFSkoqIi9fb2TlzHadu2Fi9eLNM0VVFREZQLiIWDYCz8Ho9HhmHopZde0rp165SYmOh2pHl16tQpdXZ2as2aNUFTuij6wWFsbEydnZ2ybVt79+5VYmKili1bpsbGxqC7XAQAZhNlH0DYS05O1nXXXacVK1Zoy5YtsixLTz/9tBISEtTY2Cifz6eUlBS3Y+IDgrHw19fX65VXXlFzc7NWrFjhdpx51dTUpIiICNXV1bkdZVIo+oHv5MmTsm1bzc3N6u/vV2Fhoe6++26VlZXxRS0AiLIPABO8Xq8qKytVWVmp7u5u2bat9957T7/5zW9UWloq0zS1ZMmSoJmVDAfBVvjj4uJUXV0t27Z1zTXXhM2tIMfHx+X3+1VTU6O4uDi341wWRT9wOY6jHTt2yLZtbd26VdHR0aqrq5NhGMrKynI7HgAEFMo+AFxAVlaWbrrpJt1www1qb2+XZVl6+OGHlZ6eLsMwVF9fHxSlJRwEW+G/4oor1NLSom3btqmsrMztOPNi69at6u3tlWmabke5LIp+YBocHFRLS4ts29axY8e0YMECrV+/XjU1NYqOjnY7HgAEJMo+AFxCdHS0fD6fGhsbtX//flmWpZdfflmvvPKKqqurZZqmFi1a5HbMsBdMhX/hwoXKzc2VZVlhU/Zt21ZeXp4WLlzodpRLougHngMHDsiyLHV0dMhxHFVWVurDH/6w8vLyOMsKAC6Dsg8Ak+DxeJSfn6/8/HytW7dOzc3Nsm1bLS0tWrRokUzTVFVVlaKiotyOGraCqfCbpqlnn31Wx44dU3p6uttx5tTRo0e1Y8cOffjDH3Y7yiVR9APHyMiINm7cKMuydODAAaWkpGjlypVqaGhQQkKC2/EAIGhQ9gFgihISErR8+XItW7ZM27dvl2VZeu655/TCCy+ooaFBhmGEfIELVMFS+KuqqvTCCy/Itm2tXbvW7ThzyrZtxcXFqaqqyu0oF0XRDwzHjh2bWHBvaGhIJSUluu+++1RSUhI261sAwGyi7APANEVERKi0tFSlpaU6duyY/H6/mpub9fbbb6u4uFimaWrp0qUMUudZMBT+yMhINTQ0qKmpSddff33InhEyMjKilpYWNTY2KjIyMIccFH13jY+Pa9u2bbIsSzt27FBcXNzEXVD40hQAZiYwP3kBIMikp6drzZo1uu6669TZ2SnLsvTjH/9YKSkpE9f8c/rp/AmGwu/z+fTWW29p48aNqq+vdzvOnOjo6NDQ0JAMw3A7ygVR9N1z6tQpNTc3y+/36+TJk8rNzdWHP/xhVVZWhuyXXwAw3yj7ADCLoqKiVFdXp7q6uomFpd544w299tprqqyslGmays/PZ2GpeRDohT89PV0lJSWyLCtky75t21q6dKnS0tLcjnIeiv78cxxH+/btk2VZ6uzsVEREhGpqamQYBgudAsAcoOwDwBxZtGiRbrvtNq1du3billHf//73lZ2dLdM0VVNTo5iYGLdjhrRAL/ymaeqxxx5TV1eXcnNz3Y4zq7q6unTgwAHdd999bkc5D0V/fp0+fXriFqZHjhyZOBOqrq6OW5gCwByi7APAHIuLi9PVV1+tq666Sjt37pRt2/rFL36hDRs2qK6uToZhKDs72+2YISuQC39JSYlSUlJk23bIlX3btpWamqqSkhK3o5yDoj9/jhw5Itu21draqpGREZWVlWndunUqKiri7CYAmAeUfQCYJx6PR8XFxSouLtbJkyfl9/vV1NQky7JUWFgowzBUXl4ur9frdtSQE6iFPyIiQoZh6PXXX9fatWtDZpZzYGBAHR0dWrlyZUAtUEnRn3tjY2PavHmzLMvSnj17lJCQoKuuukqNjY1KSUlxOx4AhBXKPgC4ICUlRatWrdLKlSu1adMm2batp556SomJiRMrUScnJ7sdM6QEauFvaGjQa6+9ppaWFl199dVux5kVLS0tchxHDQ0NbkeZQNGfW729vRNfYJ46dUoFBQW68847VVFRwReYAOASyj4AuMjr9aq6ulrV1dU6cuSILMvSO++8o1//+tcqLy+XYRic8jqLArHwJyQkqLKyUrZt66qrrgr6/9eO48i2bVVVVQXMHSgo+nPDcRzt2rVLlmVpy5YtioqKUm1trUzT5NIkAAgAlH0ACBDZ2dlav369Vq9erba2NlmWpR/96EfKyMiQYRiqr69XbGys2zGDXiAWftM01d7erp07d6q4uNjtODOyY8cOHT9+XLfffrvbUSRR9OfC0NDQxKKjR48eVXZ2tm666SbV1tay6CgABBDKPgAEmJiYGJmmKcMwtHfvXtm2rQ0bNujll19WTU2NTNPUwoUL3Y4Z1AKt8Ofl5WnBggWyLCvoy75t28rJyVFeXp7bUSj6s+zgwYOyLEvt7e0aHx9XZWWlbrnlFi1evDjoz0gBgFBE2QeAAOXxeFRQUKCCggKtW7dOTU1N8vv9am5uVl5engzDUFVVlSIjOZRPRyAVfo/HI9M09fOf/1wnT54M2oXMTpw4oa1bt2r9+vWulz+K/uwYHR3Vxo0bZdu29u/fr+TkZK1YsUKNjY1KTEx0Ox4A4BIYIQJAEEhMTNS1116r5cuXa+vWrbIsS88++6xeeOEFNTQ0yDAMpaWluR0z6ARS4a+pqdGGDRvk9/u1atUq13LMhN/vV3R0tGpqalzNQdGfuePHj8u2bTU3N2twcFDFxcX6yEc+otLS0oC6wwIA4OIo+wAQRCIiIlReXq7y8nIdPXpUtm2rqalJb731lpYuXSrDMFRSUsJgfAoCpfBHR0errq5OTU1Nuvbaa4PujI3R0VE1NTWprq5O0dHRruWg6E/f+Pi4tm/fLtu2tW3bNsXGxqq+vl6GYSgjI8PteACAKQqukQQAYEJGRobWrVunVatWqaOjQ5Zl6bHHHlNqaqp8Pp8aGhoCZjX0QBcohd8wDL333nvatGmT67PjU7Vp0yYNDAzINE3XMlD0p6e/v1/Nzc3y+/06ceKEFi5cqFtvvVXV1dWKiopyOx4AYJoo+wAQ5KKiotTQ0KD6+nodOHBAlmXptdde02uvvaaqqiqZpqnc3FzXr6EOdIFQ+LOyslRYWCjbtoOu7FuWpaKiImVmZrqyf4r+1DiOo/3798u2bW3cuFHS+5eSGIah3Nxcl9MBAGYDZR8AQoTH41Fubq5yc3O1du3aiVtjtbW1KScnR6Zpqrq62tVTrANdIBR+0zT15JNP6vDhw1qwYMG87386Dh06pH379unuu+92Zf8U/ckbHh5We3u7bNvWoUOHlJaWplWrVqm+vl7x8fFuxwMAzCLKPgCEoPj4eC1btkxXX321duzYIcuy9LOf/UwvvvjixDW4bs3ABjq3C39ZWZkSExNlWZZuvvnmed33dNm2raSkJJWVlc37vin6k9PT0yPLstTa2qrTp0+rtLRUN9xwg4qLiznrBwBCFGUfAEKYx+NRSUmJSkpKdOLECfn9fjU1Nendd99VUVGRTNNUWVkZC/p9gJuF3+v1yufz6a233tKaNWsUExMzb/uejqGhIbW1tWnZsmXyer3zum+K/qWNj49r8+bNsm1bu3btUnx8vEzTlM/nU2pqqtvxAABzjLIPAGEiNTVVN9xwg1auXKlNmzbJsiw98cQTSkpKks/nU2Njo5KSktyOGTDcLPyNjY1644031NraqiuuuGLe9jsdbW1tGh0dlc/nm9f9UvQvrq+vT01NTfL7/err61N+fr7uuOMOVVRUBN1dHgAA08cRHwDCTGRkpGpqalRTU6NDhw7Jtm29+eabeuONN1ReXi7TNFVQUMCpvXKv8CcnJ6u8vFy2bcs0zYD9f+E4jizLUkVFxbx+UUTRP5/jONqzZ48sy9LmzZvl9XpVW1srwzCUk5PjdjwAgAso+wAQxnJycnTzzTdr9erVamtrk2VZ+sEPfqDMzEyZpqna2lrFxsa6HdNVbhV+0zT1wx/+UHv27FFhYeG87HOq9uzZo56eHn3oQx+at31S9M915jIKy7LU09OjzMxMrVu3jp9dAABlHwAgxcbG6oorrpBpmtq9e7ds29avfvUrvfTSS6qtrZVpmkGzMvxccKPwFxYWKjMzU7ZtB2zZtyxLmZmZ85aPov9fzpyV09bWprGxMZWXl2v9+vWclQMAmEDZBwBM8Hg8KioqUlFRkfr6+iYW9PP7/crPz5dpmmF73e98F36PxyPDMPTiiy+qr68v4NZT6Ovr0+bNm7Vu3bp5KZcUfWl0dHRivY19+/YpKSlJ11xzDettAAAuKPxGawCASUlKStJ1112nFStWaOvWrbIsS88884wSEhLU0NAQlit6z3fhr6ur08svv6ympqaJfQeKpqamievC51q4F/2z76QxMDCgoqIi3XPPPSotLZ33OyAAAIIHZR8AcEler1cVFRWqqKiYuFe3ZVl68803VVpaKsMwwupe3fNZ+GNjY1VTUyO/368VK1YEzC0Sx8bG5Pf75+W68HAt+o7jaMeOHbIsS9u2bVN0dLTq6+tlGIYyMzPdjgcACAKUfQDApGVmZuqmm27SDTfcoPb2dtm2rUceeURpaWkyDEP19fWKj493O+acm8/Cb5qmmpqatGXLFlVUVMzZfqZi69at6uvrk2EYc7qfcCz6AwMDamlpkW3bOn78+MQimtXV1YqOjnY7HgAgiFD2AQBTFh0dLZ/Pp8bGRu3fv1+2beuVV17RK6+8ourqapmmqdzcXLdjzqn5Kvw5OTnKz8+XbdsBU/Yty1J+fv6c3tItnIq+4zg6cOCALMtSR0eHJKmqqkp33HGHcnNzw+asGQDA7KLsAwCmzePxKD8/X/n5+Vq7dq2am5vl9/vV2tqqRYsWyTAMVVdXKyoqyu2oc2K+Cr9hGPrJT34ycWs1N/X09GjXrl2644475mwf4VL0R0ZG1NHRIcuydPDgQaWmpur6669XfX29EhIS3I4HAAhylH0AwKxISEjQ8uXLtWzZMm3fvl22beunP/2pXnzxxYlrjTMyMtyOOevmo/BXVlbqhRdekG3buvHGG2f9/afCtm3Fx8fP2VkG4VD0jx49Ktu21dLSoqGhIS1dulT33XefSkpKAmZdBgBA8KPsAwBmVUREhEpLS1VaWqrjx4/Ltm01NzfrnXfeUXFxsQzDUGlp6f/P3n9Hx3Ul6KHvV1XIOeecQ6HiOcwUI0hRFKVWGKl7kn3HMw5jX3vmja/jGl9fv7U863o89njeW7bf+M60Wh0ldVS3Wi2SEiUqNKW9qwqFDBAgwIBEAETOqKr3B5toUWJAqMKp8P3+6SZQVecTicLZX+1z9g6rUhPowh8VFQWr1QopJY4fP67Zvdurq6toaWmBqqoB2X4xnIu+1+vd2NXi2rVriI+Ph81mg6IoSE9P1zoeERGFIZZ9IiIKmPT0dDQ3N+PYsWPo6OiAlBKvvfYaUlJSNu75T0pK0jqmXwS68CuKgo8//hjt7e2w2Wx+fe3Nam9vx8rKCux2u99fO1yL/vz8PJxOJxwOB2ZnZ1FUVISvfOUraGxsDMgHJkRERPfwLENERAEXFRUFs9kMs9mMkZERCCHw4Ycf4oMPPkBDQwMURUFJSUnIL0QWyMKflpaGmpoaCCFgtVp3/e/K5/NBCIGamhqkpaX59bXDrej7fD7cuHEDUkp0dnZCr9ejqakJqqoiPz9f63hERBQhWPaJiGhX5efn45lnnkFzczPcbjeklHjllVeQk5MDRVFgMpkQGxurdcxtC2ThVxQF3/nOdzA0NISioiK/ve5mDA0NYXR0FCdOnPDr64ZT0V9ZWUFrayuklLh9+zYyMzPR3NwMi8WCuLg4reMREVGEYdknIiJNxMfHY9++fdi7dy8GBgYghMDbb7+NixcvwmQyQVVV5OTkaB1zWwJV+KuqqpCWlgYp5a6XfSEE0tPTUVlZ6bfXDJeif/v2bQgh0NrairW1NdTV1eH06dMoLy8P+atViIgodLHsExGRpnQ6HSoqKlBRUYHZ2Vk4HA44nU5IKVFaWgpFUVBfXw+DwaB11C0JROHX6XRQFAWXLl3CqVOnkJCQsOPX3IzFxUV0dHTg+PHjfiuvoV70PR4Purq6IKXE9evXkZSUhH379sFutyMlJUXreERERCz7REQUPFJSUjbKX3d3N4QQ+MEPfoDExETYbDbY7XakpqZqHXPTAlH4rVYrLl26BJfLhYMHD+749TbD5XIBACwWi19eL5SL/szMzMYHUgsLCygrK8OLL76Iurq6kPtAioiIwhvLPhERBR2DwYDGxkY0Njbi9u3bkFLi008/xUcffYTa2lqoqhoyl0j7u/AnJCTAaDRCSokDBw4E/O/A6/VCSgmj0eiXKwlCsej7fD5cu3YNUkr09PQgOjoaZrMZiqKE7K0mREQU/lj2iYgoqOXk5OCpp57CiRMn0NbWBiEEvvnNbyIzMxOKosBsNiM+Pl7rmI/k78KvKArcbjf6+vpQXV2943yP0t/fj+npabz44os7fq1QK/pLS0toaWmBlBJ37tzZ+FlsamoK6UUkiYgoMrDsExFRSIiNjYWiKLDb7bh58yaEELhw4QLefffdkNjWzJ+Fv7CwEPn5+ZBSBrzsCyGQn5+PgoKCHb1OKBX94eFhCCHQ3t4Or9eLhoYGPPvssyguLg6Jq0mIiIgAln0iIgoxOp0OJSUlKCkpwenTp+FyuSClhMvlQmFhIVRVRWNjI6Kigu8U56/Cf2+hvp/+9KeYmppCenq63zJ+3tTUFK5evYpnnnlmRyU3FIr+2toaOjo6IKXE0NAQUlJS8MQTT8BqtSIpKUnreERERFsWfCMhIiKiTUpKSsLhw4dx8OBBXL16FUII/PjHP8Y777wDq9UKRVECVoS3y1+Fv6mpCefPn4fD4cDJkyf9lu/zpJSIi4uD0Wjc9msEe9G/c+cOHA4HXC4XlpaWUFlZia9+9auorq6GXq/XOh4REdG2sewTEVHI0+v1qK2tRW1tLSYnJzdWS//kk09QVVUFVVVRVVUVNOXNH4U/OjoaFosFLpcLR48e9fuVDOvr63C5XLBYLIiOjt7WawRr0fd6vejr64MQAn19fYiLi9v4cCgjI0PreERERH7Bsk9ERGElMzMTp06dwrFjx9DR0QEhBL773e8iNTUViqLAarUiMTFR65h+KfyKouDTTz9FZ2cnTCaTX/N1dHRgaWkJiqJs6/nBWPQXFhY2bvuYmZlBQUEBnn32WTQ2Nm77Aw0iIqJgxbJPRERh6d7Mt8ViwdDQEKSUGwW0oaEBqqqiqKhI0wXXdlr4s7KyUFFRASGE38u+lBIVFRXIzMzc8nODqej7fD7cunULQgh0dnZCp9PBaDRCURQUFhZqmo2IiCiQWPaJiCjsFRYWorCwEM3NzRtbqbW1tSE3NxeqqqKpqQkxMTGaZNtp4VcUBa+//jpGRkb8thvByMgIbt26hZdffnnLzw2Wor+6urqxVePY2BgyMjJw4sQJWCyWoN+qkYiIyB9Y9omIKGIkJCTgwIED2L9/P/r7+yGlxFtvvYULFy7AbDZDVVVkZWXteq6dFP7a2lokJydDSolz5875JY8QAikpKaipqdnS84Kh6I+Pj0NKCbfbjdXVVdTU1KC5uRkVFRXcNo+IiCIKyz4REUUcnU6HqqoqVFVVYWZmZmNBv88++wzl5eVQFAW1tbUwGAy7lmm7hV+v18Nut+Pjjz9Gc3Mz4uLidpRjeXkZbW1tOHz48JYWNNSy6Hs8HvT09EAIgcHBQSQmJmLPnj2w2+1ITU3d1SxERETBgmWfiIgiWmpqKo4fP44nnngCXV1dkFLijTfeQHJyMmw2G+x2O5KTk3cly3YLv81mw+XLl+F2u7F3794dZWhpaYHX64XNZtv0c7Qq+rOzs3A6nXA4HJifn0dJSQleeOEF1NfX7+oHNURERMGIZZ+IiAhAVFQUmpqa0NTUhLGxMQgh8Mknn+Dy5cuor6+HoigoKysL+KXg2yn8ycnJqK+vhxACe/bs2XZGn88HKSUaGhqQlJS0qefsdtH3+XwYHByEEALd3d2Ijo6GyWSCoijIzc0N+PGJiIhCBcs+ERHRF+Tm5uLpp59Gc3Mz3G43pJR49dVXkZWVBUVRYDabd3y5/KNsp/CrqopXXnkFg4ODKC8v39ZxBwYGMDk5uel7/3ez6C8vL2/8W0xMTCA7OxtnzpyByWRCbGxsQI9NREQUilj2iYiIHiI2NhZ79uyBqqq4fv06pJQ4f/483n33XTQ1NUFVVeTl5QXk2Fst/CUlJcjOzoYQYttlX0qJnJwclJSUPPaxu1X0R0dHIYRAW1sbPB4P6uvr8fTTT6OkpIQL7hERET0Cyz4REdFj6HQ6lJWVoaysDHNzcxv3iTudThQXF0NRFDQ0NCAqyr+n1a0Ufp1OB1VV8fbbb2N2dhYpKSlbOtbs7Cy6u7tx5syZx5boQBf99fV1dHZ2QgiBW7duITk5GQcPHoTNZtu19ROIiIhCHcs+ERHRFiQnJ+PIkSM4fPgwenp6IKXEj370I7zzzjuwWq1QFAVpaWl+O95WCr/JZMLFixfhdDpx9OjRLR3H4XBs3P/+KIEs+lNTU3A4HHC5XFhcXERFRQVeeukl1NbWbmlnACIiImLZJyIi2ha9Xo/6+nrU19djYmICUkpIKfHxxx+jpqYGiqKgqqrKL5eab7bwx8bGwmQyweFw4PDhw5tekd7j8cDpdD72/vdAFH2fz4e+vj5IKdHb24vY2FhYLBYoioKsrCy/HIOIiCgSsezvMo/Ph/ElD0YX1zG6uI75dS88Xh8Meh2SovTIS4hCXkIUsuMNMPBeRCKikJCVlYUnn3wSx48fR3t7O4QQ+M53voP09HTY7XZYrVYkJCTs6BibLfyKokBKiZ6eHtTW1993zpmcNyB63zm8N2VA5tr8xjln/FoP5ufnoarqQ4/v76K/uLgIl8sFKSWmp6eRl5eHc+fOwWg0IiYmZsevT0REu4s9J/jofD6fT+sQkWBm1YOWiWW4Jpax7Ln7V64H4P3cYz7/5ziDDtasOFiy4pAaw72CiYhCic/nw9DQEKSUaG9vBwAYjUYoioLCwsIdzfZvpnT/P9/6Hpayy+DJr/7COccHQAfABz10G+cc3foqEiav43eP73ngOcdfRT+Qfy9ERKQN9pzgxbIfYMseLy4NLcA9ufKr4dXm3Xu8OTMWxwsTEWvg/YpERKHmizPY+fn5UBQFTU1NiI6O3tZrPqx8//qcswyf1wfdlu5zv/tBwBfPOf4o+mtra2hra4OUEiMjI0hLS4OiKH654oGIiLTBnhP8WPYDaGB2FT+7PofFdd+Wfvi/SAcgMUqHs6XJKE/hpY1ERKHI6/Wiv78fQghcvXoVcXFxMJvNUFUVmZmZW369L5bwQJxzbrh+uaOiPzk5CSEE3G43lpeX/b6WARERaYM9JzSw7AeIY3wJF24tbPlTroe59zrNRYmwZ8f74RWJiEgrD1p1XlVV1NTUbGnV+XuFv+7U8xiIy/f7OWet9QMcKc/eUtH3er0buxRcu3YNCQkJsFqtsNvtSE9P90M6IiLSEntO6GDZD4B7b4BA4RuBiCg8fHE/+ZSUFNjtdthsNiQlJW3qNV77pA0D8fkBy7jZc87c3BycTiccDgfm5uZQVFQEVVXR0NCAqCiuB0xEFA7Yc0ILy76fDcyu4rX+2Uc+Znp0CB+88lfo/eQ9zIwNIzYxCYV1Jhz42h+g7vCpTR3n5coUXupCRBRGRkZGIKVEW1sbPB4P6uvroaoqSkpKHnrJ+2bOOQDQduEn+OXrf4uR3g541taQWVwOy5kXcOi3/iEMm1g34GHnHJ/Ph+vXr0NKia6uLhgMBjQ1NUFRFOTnB+4DCCIi2n2bOeeMD/bh6pVLGOpyY6irFeMDvfB6PGj+w3+F47//J5s6DnuO/7Ds+9Gyx4v/1Tn1yHtXbna48PV/8jKWZqaQnJWLYqMNi9N3cLPdCc/6Go7/wT9H8z/6l488zr17W/6gIZ2LWRARhZnl5WW43W4IITA5OYns7GyoqgqTyYTY2NhfP24T5xwA+Omf/1t88t2/hj4qCpXKIcQkJKJffITluRmUWfbi9/77G4iOe/gsyoPOOSsrK3C73ZBSYnx8HJmZmVBVFWazGXFxcX76myAiomCx1XPOF2227LPn+BfLvh+9fWMOrZMrD30DrK0s4y+e24eZ0SGYTn0FL/77v9oYYN3scOGV//2rWJy+g9/772+get/RRx5LB8CUGYszJcl+/W8gIqLg4PP5MDg4CCEEuru7ER0dDZPJBEVRkJub+9hzDgB0XPo5vvUnfwcxCYn4+//rJyisNwMAFqYm8f/8g+cx2teJw7/zh3jqj/+vR2a5d86xxS5CSonW1lasra2hrq4OqqqirKyMC+4REYWxzZxzAED86JsYH+xHQV0TCupMeP9v/xKut17f0sw+e47/8CY6P5le8cA9ufLIx3Rc+jlmRocQl5yKr/zb/3zfTEpxoxXH/+BP8LM//7d476//82PLvg+Ae3IFB/ISuD8lEVEY0ul0KC8vR3l5OWZnZzfuh5dSorCqFhMNJ3B3SPRw7//tXwIAjv7df7pR9AEgMT0Tz/7r/xv/v793Dr987W9w/Pf/BHHJKQ99HR8A98QyPrv4bSQZfNi/fz9sNhtSUh7+HCIiCg+b6Tn3qM/9zn1/1um3/kEwe47/sOz7iXty+bErUt7qcAEACuvNiE9O/dL3q/YeAQBcd3+GuYkxJGflPvKYOgAtE8s4UpC4zdRERBQKUlJScPToURw+fBg9PT149+YsfF7fIwdRM7dHNs475jMvfOn7ZdZ9SM0rxMzoELo/vgjLk88/JoUPxidfwFcai2AwcPBFRBQpNtNz/I09xz94I4QfeHw+uCaWH/sGWF28u3JlQuqDtx5KTMsAcPfSzaHu1sce1wfANbEMD+/EICKKCAaDAbX19fDkV0P3mC36hrvbAADxqenIKCx94GOK6i0AgJFfPfaRdHrcRBKwha0BiYgotG225/gbe45/8IztB+NLHix7Hv+DmJSRBQC4M3T9gd+/c+vXX58aurGpYy97fBhf8mzqsUREFPo2e86ZGr57TknLK3zoY1LzCgAAd4YffF76Ip5ziIgiy2bPOYHAc87Osez7weji+qYeV6keBgAMd7kx/ICZ+09/8MrG/19ZmPP78YmIKPRt9nf+ysI8ACAmPuGhj4mJv3t55Mo8zzlERPRlWv/O1/r4oY5l3w9GF9c39RdZuecwym374fP58Oof/w66PngHy3OzuHNrED//r/8nXD97HYaou/sdP+7yzHv04JuAiCiSbPacEwg85xARRRaec0IbF+jzg/l1L7ybfOxv/qe/wbf++d/F9ZbP8Oof//Z93zv4m/8Agy2fYqizBfEpD76v/4u88GFyfhEjI5uflSEiotA1OW+AFzo8biX+2MQkAMDq0uJDH7O6dHctmdikzW1vxHMOEVFk2ew5JxC8ABbWN9uy6EFY9v3A4938fSxJGdn4B3/zM/R9+gH6xYdYnJ5CUmY2Go6eQVGDBf/xlBEAkFdVv8lX1OH6zRv46zd+to3kREQUaqL3nYM+p+Sxj0vPv/uYmbHhhz5mZnT4vsc+Hs85RESRZLPnnEBZ30LPoi9j2fcDwxb3j9TpdKjedxTV+47e9/XJmwOYmxhDQloGCupNm3w1H0qLi3Hc9Pe3lIGIiELTe1MG3Fzx4XGzLAV1TQCAxek7uDN0/YEr8t/qarn7WJ5ziIjoATZ7zgmUqC32LLofy74fJEXpoQc2fSn/w3z4zf8OANjz3O8gKjpmU8/RQ4fMpHjk5yft8OhERBQKMtfmMbSy/NhzTmpuAYoarbjV4YL77R/g2O//v+77/qDrCmZGhxAVE4u6gyc3dWyec4iIIstmzzmBoAeQGMUl5naCf3t+kJcQtek3wNi1Hix/YdVjz/o6Lv3Nf8VnP/gGMovLcez3/3jTx/b+6vhERBQZtnLOOfp7fwQAeP+Vv8JQl3vj6wvTd/CTP/uXAID9L/89xCWnbOr1eM4hIoosWznn+BvPOTvHvz0/2MoP4Wc/eBWf/fBVFNabkJKdD8/aKm60ScxPjiOzuBx/7398f2MrpEAcn4iIQttWfuc3HnsKB772B/jku/8L/+PvnEHlnsOIiU9A32cfYnluBqWWPWj+R/8qYMcnIqLQttXf+UNd7o0PkwHgzq1BAHc7UPflCxtf/+2/eAUp2Xl+Pz7dj397fpAdb0CcQYdlz+MXkKg9dBLTIzcx1N2KoU43DDExyC6twuHf/kPsf/nvIToufkvHjjPokB1v2G50IiIKIR6PB+PXeqBbT4cvanO3e537P/4jSs17cOX1v8X1VgHv+joyispw9H/7pzj4W/9w07eNAUA0vMjY/MOJiCjEbaXnAMDKwjxutju+9PWZseH7Foz1rK0+9rXYc3ZO5/P5uMShH3wwvIArY0vYzb9MHYB9ufE4UrC1KwGIiCi0zM7OwuFwwOl0Yn5+Hhl7T2Ehtwq7umCSz4v1q07E3+qAzWaD3W5HSsrmLv8nIqLQxZ4Tujiz7yeWrDj8cmxpV4/p+9VxiYgo/Ph8PgwMDEBKie7ubkRHR8NkMkFVVcSmZeJ/dEztbiCdHr952IYulwdXrlzBhx9+iLq6OiiKgvLycuh0XDGZiCgcseeELs7s+9HbN+bQOrmyK5966QCYMmNxpiR5F45GRES7ZXl5GS0tLZBSYnJyEtnZ2VBVFSaTCbGxsRuP0/Kcs7KygtbWVgghMD4+jszMTCiKAovFgrg4Ds6IiMINe05oYtn3oxWPF/+rcwoL676AvhF0ABKjdPiDhnTEGrihAhFROBgZGYEQAm1tbfB6vWhoaICiKCgpKXngrHkwnHN8Ph9u3LgBIQS6urpgMBhgNBqhqiry8/MDmIqIiHZTMJxzaOtY9v1sYHYVr/XPBvw4L1emoDyFqyQREYWy9fV1dHR0QEqJW7duISUlBXa7HTabDUlJj9/LPpjOOfPz83A6nXA4HJidnUVRURFUVUVDQwOionjXIBFRqAumcw5tDst+ADjGl3Dh1kLAXv9UUSJs2VtbtZ+IiILH1NQUpJRwuVxYWlpCRUUFVFVFTU0N9PrNz2R88MEHuDw4gWjTkYBlLV8ewcv7mzb9eK/Xi97eXgghcO3aNSQkJMBqtcJutyM9PT1gOYmIKPDYc0ILy36A3Hsj6AC/XOpy73X4BiAiCk1erxd9fX2QUuLq1auIi4uDxWKBoijIzMzc8ut98MEHeP/993Hs2DEk1qsBOeeULw2j+8KPcOzYMTzxxBNbfp3JyUlIKdHS0oLl5WVUV1dDVVVUVlZu6UMNIiIKHuw5oYNlP4AGZlfx1vW5Hd/bcu/elbOlybykhYgoxCwsLMDlcsHhcGB6ehr5+flQVRVGoxHR0dHbes3PF/17JTxQ55wHHWur1tbW0N7eDiEERkZGkJaWBkVRYLVakZCQsIO0RESkBfac0MCyH2DLHi8uDS3APbmy5U+/7j3enBmL44WJXKSCiChE+Hw+DA0NQQiBjo4OANhYuK6goGBH29Q9qnxvnHMmlgH4AN0Wzhs+L6DTP/Cc44/CD9z9exkeHoYQAu3t7QCAxsZGqKqKwsJCbt9HRBRC2HOCH8v+LplZ9aBlYhmuiWUse+7+lesBeD/3mM//Oc6ggzUrDpasOKTGGHY5LRERbcfq6urGDPbo6CjS09M3tqTzxwz2Zkr32NgY/uc3vg3jky/gJpK+cM7x4d4QSw/dxjknGl4s9Trxm4dtqCjI2faxt2JxcXFji8GpqSnk5eVtXPEQE8PZHSKiUMGeE7xY9neZx+fD+JIHo4vrGF1cx8K6F+teH6L0OiRG6ZGXEIW8hChkxxtg4AwHEVFImJiY2Lg3fWVlBTU1NRv3pvtrtnqzZfutt95Cd3c3/uiP/gjQ6+8750zOL+L6zZsoLS5GZlLCxjknIwb4//y3/4a6ujqcPXt2xxm2wufzob+/H0II9Pb2IjY2dmMtg6ysLL8cg4iIAo89J/hwL5xdZtDpNn7QiYgodHm9XvT09EAIgYGBASQkJEBVVdjtdqSlpfn1WJst2SsrK2htbcX+/fthMNydLfn8OWdkZA5//cbPcNz095Gff//WfjabDVeuXMHJkycRGxv7wNc/cuTuqv+XLl0CAL8Ufp1Oh6qqKlRVVWF6enpjl4JPP/0U5eXlUFUVtbW1XNCPiCjIsecEH/5LEBERbcHc3NzGfvJzc3MoLi7G888/j/r6+oDsJ7+V2fTW1lasra3BZrNt+Th2ux0ffvghWltboarqQx8XiMJ/T1paGk6ePImjR4+is7MTUkq8/vrrSE5Oht1uh81mQ3Jyst+OR0REFM5Y9omIiB7D5/Ph+vXrEEKgu7sbBoMBJpMJiqIgLy8vYMfdStH3+XwQQqCurg4pKSlbPlZKSgrq6uogpYSiKI+8/SCQhR8AoqKiYDKZYDKZMDo6CiEEPv74Y1y+fBl1dXVQVRWlpaVc0I+IiOgRWPaJiIgeYnl5Ga2trRBCYGJiAllZWTh9+jRMJhPi4uICeuyt3h9/48YNjI+P48yZM9s+pqIo+OY3v4kbN26gtLT0kY8NdOG/Jy8vD+fOnUNzczPcbjeklPjGN76B7OxsKIoCs9n80NsOiIiIIhnLPhER0ReMjY1BCIHW1lZ4PJ6Nhet2azZ5OwvhCSGQmZmJsrKybR+3vLwcmZmZkFI+tuwDu1f4ASAuLg579+7Fnj17MDg4CCklfvGLX+DixYswmUxQVRW5ubkBOz4REVGoYdknIiICsL6+jq6uLgghcPPmTSQnJ+PgwYO7fp/4dor+3Nwcurq6cOrUqR19GKHT6aAoCi5cuIDTp08jKSnpsc/ZzcJ/L2N5eTnKy8sxNzcHh8OxsYZCSUkJFEUJ2PoJREREoYRnQiIiimjT09NwOBxwuVxYWFhAeXk5XnrpJdTU1GysaL9btru1ndPphMFggNls3nEGi8WCd999F06nc9MZdrvw35OcnIyjR4/i8OHD6OnpgZQSP/zhD5GYmAir1QpFUZCamrorWYiIiIINyz4REUWcz+/tfvXqVcTExMBsNkNVVc32dt9u0fd6vXA4HGhqavLLOgJxcXFoamqCw+HAoUOHNr3lnVaFHwAMBgMaGhrQ0NCA8fFxSCk3FvWrqamBoiiorKzkgn5ERBRRWPaJiChiLC4uoqWlBVJKTE1NIS8vD2fPnkVTUxNiYmI0y7Xdog8APT09mJube+R2eVulqipcLhd6e3tRV1e36edpWfjvyc7OxpkzZ3DixAm0tbVBCIFvf/vbSE9Ph6IosFgsSEhI2PVcREREu41ln4iIwt7Q0BCEEGhvbwcANDY24rnnnkNRUZHms707KfoAIKVEUVGRX7cAzM/PR1FR0cZWflsRDIUfAGJiYmC322Gz2XDr1i1IKfHee+/h0qVLMBqNUBQFhYWFmmQjIiLaDSz7REQUltbW1tDe3g4pJYaHh5GWloajR4/CarUiMTFR63gAdl70JyYmcO3aNTz33HN+z6YoCn784x9jcnISmZmZW3pusBR+4O6CfsXFxSguLsapU6fgcrkgpURLSwsKCgqgKAqMRiOio6M1y0hERBQILPtERBRWJicnN8rc8vIyqqur8bWvfQ1VVVWbvv98N+y06AN3Z/UTEhLQ0NDg53R3r3545513IKXE6dOnt/z8YCr89yQmJuLQoUM4cOAA+vr6IKXEm2++ifPnz8NisUBRlC1/sEFERBSsWPaJiCjkeb1e9Pb2QkqJ/v5+xMfHw2azQVEUpKenax3vS/xR9FdXV9HS0gJFUQKyzVxUVBSsViucTieOHz++rZnvYCz8AKDX61FTU4OamhpMTU1BSgmXy4UrV66gsrISiqKgpqYmqD4cIiIi2iqWfSIiClnz8/Mbe6zPzs6iqKgIX/nKV9DY2Bi0+6z7o+gDQHt7O1ZWVmC32/2Y7n6KouCTTz5Be3s7rFbrtl4jWAv/Penp6WhubsaxY8fQ0dEBIQRee+01pKSkbNzzn5SUpHVMIiKiLQvOkRAREdFD+Hw+3LhxA1JKdHZ2Qq/Xo6mpCaqqIj8/X+t4j+Svou/z+SCEQE1NTUCvXEhPT0d1dTWEELBYLNtezDDYCz9w90oGs9kMs9mM4eFhSCnx4Ycf4oMPPkBDQwMURUFJSYnmCzoSERFtFss+ERGFhJWVFbS2tkJKidu3byMzMxPNzc0wm82Ij4/XOt5j+avoA3d3FxgdHcXx48f9lO7hVFXFd77zHQwPD+9o9fpQKPz3FBQU4JlnnkFzczPcbjeEEHjllVeQk5MDVVXR1NSE2NhYrWMSERE9Ess+EREFtdu3b0MIgdbWVqytraG2thanT59GeXl5yMyy+rPoA3cX5ktLS0NVVZUf0j1aZWUl0tLSIITY8VZ1oVT4ASA+Ph779u3D3r17MTAwACEEfv7zn+PChQswm81QFAU5OTlaxyQiInogln0iIgo6Ho8HXV1dkFLi+vXrSEpKwr59+2C325GSkqJ1vC3xd9FfXFxEe3s7jh07tisfduj1eiiKgkuXLuHUqVNISEjY0euFWuEH7m7fV1FRgYqKCszMzGysEyGEQGlpKVRVRV1dHQwGg9ZRiYiINrDsExFR0JiZmYHD4YDT6cTCwgJKS0vx4osvhmyR8nfRBwCXywUA214wbzusVisuXbqElpYWHDhwYMevF4qF/57U1NSNf8/u7m4IIfD9738fSUlJsNlsIfmBFBERhSeWfSIi0pTP59u4RLqnpwfR0dFhcYl0IIq+z+eDlBJGo3HHM+xbkZCQgMbGRkgpsX//fr9cURDKhR8ADAYDGhsb0djYiNu3b0NKiStXruDDDz9EbW0tVFUNqVtNiIgo/LDsExGRJpaWluB2uyGlxOTkJHJycvDUU0+FxeJngSj6ANDX14fp6Wm88MILfnvNzVJVFa2trejv7/fbWgGhXvjvufeze+LECbS1tUEIgW9+85vIzMyEoighs4gkERGFF5Z9IiLaVSMjIxBCoK2tDV6vFw0NDXjmmWdQXFwcFrOggSr6wN2F+fLz83e8UN52FBYWIi8vD0IIvy4MGC6FHwBiY2OhKArsdjtu3rwJIQQuXLiAd999N2S2hyQiovDBsk9ERAG3vr6Ojo4OCCEwNDSElJQUPPHEE7BarUhKStI6nt8EsuhPT0+jt7cX586d0+RDEZ1OB1VV8dOf/hTT09NIS0vz22uHU+EH7v5dlZSUoKSkBKdPn95Y0M/lcqGwsBCqqqKxsRFRURyGERFR4PAsQ0REATM1NQUpJVwuF5aWllBZWYmvfvWrqK6uhl6v1zqeXwWy6AN3Z/VjY2PR1NTk99feLKPRiPPnz8PhcODEiRN+fe1wK/z3JCUl4YknnsChQ4fQ29sLKSV+/OMf45133oHVaoWiKEhPT9c6JhERhSGWfSIi8iuv14u+vj4IIdDX14e4uDhYrVbY7XZkZmZqHS8gAl3019fX4XK5YLFYEB0d7ffX36yYmBhYLBY4nU4cOXLE7zPT4Vr4gbtbGNbV1aGurg6Tk5OQUsLpdOKTTz5BVVUVVFVFVVVV2H0IRkRE2mHZJyIiv1hYWIDL5YKUEjMzMygoKMCzzz6LxsZGTQtqoAW66ANAZ2cnFhcXoShKQF5/KxRFwaeffoqurq6AXGUQzoX/nszMTJw+fRrHjx9He3s7hBD47ne/i7S0NNjtdlitViQmJmodk4iIQhzLPhERbZvP58OtW7cghEBnZyd0Oh2MRiMURdFkEbndthtFH7h7CX9FRQWysrICdozNysrKQnl5OYQQAbulIBIKPwBER0fDarXCarViaGgIUsqNn6nGxkYoioKioqKwWLiSiIh2H8s+ERFt2erq6sYWY2NjY8jIyMDx48dhsVh2df93Le1W0R8dHcXNmzfx0ksvBewYW6WqKl5//XWMjo4iLy8vIMeIlMJ/T2FhIQoLC9Hc3IyWlhZIKdHa2oq8vDwoioKmpibExMRoHZOIiEIIyz4REW3axMQEhBBwu91YXV1FTU0NmpubUVFREVGzj7tV9AFACIHk5GTU1tYG9DhbUVtbi+TkZEgp8fTTTwfsOJFW+AEgISEBBw4cwP79+9Hf3w8pJd566y1cuHABZrMZqqoGxRUeREQU/Fj2iYjokTweD3p6eiClxMDAABITE7Fnzx7Y7XakpqZqHW/X7WbRX15eRltbGw4ePBhUC7fp9XrY7XZ8/PHHOHnyJOLi4gJ2rEgs/MDd7fuqqqpQVVWF6elpOBwOOJ1OfPbZZygvL4eiKKitrYXBYNA6KhERBSmWfSIieqDZ2Vk4nU44nU7Mzc2hpKQEzz//POrr6yN2f/DdLPoA4Ha74fF4YLPZAn6srbLZbLh8+TJaW1uxZ8+egB4rUgv/PWlpaThx4gSOHDmCrq4uSCnxxhtvIDk5GTabDXa7HcnJyVrHJCKiIBOZozUiInogn8+HwcFBCCHQ3d2NqKgomEwmqKqK3NxcreNpareLvs/ng5QS9fX1QVnkkpOTUVdXByEEVFUN+G0ckV74ASAqKgpNTU1oamrC2NgYhBD45JNPcPnyZdTX10NRFJSVlUXULTVERPRwLPtERITl5WW43W5IKTExMYHs7Gw8+eSTMJvNiI2N1Tqe5na76APA4OAgJiYmcPbs2V053naoqopvfOMbGBwcRHl5ecCPx8L/a7m5uXj66afR3Ny88d599dVXkZWVBUVRYDabA3p7BRERBT+WfSKiCDY6OgohBNra2uDxeFBfX4+zZ8+itLSUs4O/okXRB+4uzJednY3S0tJdO+ZWlZaWIisrC1LKXSn7AAv/F8XGxmLPnj1QVRXXr1+HlBLnz5/Hu+++i6amJqiqGrAdE4iIKLix7BMRRZj19XV0dnZCSombN28iOTkZBw8ehM1mC8rLxbWkVdGfnZ1Fd3c3nnzyyaD+0EWn00FVVfziF7/A3Nzcrv38sPB/mU6nQ1lZGcrKyjA3Nwen07mxqF9xcTEURUFDQ0PErrdBRBSJ+BufiChCTE9PQ0oJl8uFxcVFVFRU4KWXXkJtbW1QrfQeLLQq+gDgdDoRFRUFs9m8q8fdDpPJhIsXL8LhcODo0aO7dlwW/odLTk7GkSNHcPjwYfT09EAIgR/96Ed45513YLVaoSgK0tLStI5JREQBxrJPRBTGfD4f+vr6IKVEb28vYmNjYbFYoCgK9+p+BC2LvsfjgcPhgMlkCon1EuLi4mAymeB0OnH48OFd3QqOhf/R9Ho96uvrUV9fj4mJCUgpIaXExx9/jJqaGiiKgqqqqqC+eoSIiLaPZZ+IKAwtLi7C5XLB4XBgamoKeXl5OHfuHIxGI2JiYrSOF9S0LPoA0NPTg/n5eaiquuvH3i5FUeBwONDT04OGhoZdPTYL/+ZkZWXhySefxPHjx9He3g4hBL7zne8gPT0ddrsdVqsVCQkJWsckIiI/YtknIgoTPp8PQ0NDkFKivb0dAGA0GvH888+jsLCQs3eboHXRB+4uzFdSUhJSWx3m5eWhuLgYUspdL/sAC/9WxMTEwGazwWq1YmhoCEIIXLp0CZcuXYLRaISqqigoKODvCyKiMMCyT0QU4tbW1tDW1gYpJUZGRpCWloZjx45xpm6LgqHoj4+PY3BwEM8//7wmx98JVVXxwx/+EOPj48jOzt7147Pwb41Op0NRURGKiopw6tQptLS0QEoJt9uN/Px8qKoKo9GI6OhoraMSEdE2sewTEYWoyclJCCHgdruxvLyM6upq/OZv/iYqKyu54N4WBUPRBwApJRITE1FfX69Zhu2qr69HQkICpJQ4c+aMJhlY+LcnMTERBw8exP79+9Hf3w8hBN58802cP39+Y42PzMxMrWMSEdEWsewTEYUQr9eL3t5eCCFw7do1JCQkwG63w263Iz09Xet4ISlYiv7q6ircbjf27NkTktujRUVFwWazQQiBEydOaLY2BAv/9un1elRXV6O6uhpTU1MbW/dduXIFFRUVUFUVNTU1/DCRiChEhN5ogogoAs3Pz2/smz07O4uioiI899xz3Dd7h4Kl6ANAW1sbVldXYbfbNc2xE3a7HR9//DHa2to0/e9g4d+59PR0nDx5EkePHkVnZyeEEHjttdeQkpICu90Om82GpKQkrWMSEdEjcIRIRBSkfD4fbty4ASEEurq6YDAY0NTUBEVRkJ+fr3W8kBdMRd/n80EIgZqaGqSmpmqaZSfS0tJQU1MDKSVsNpumi7yx8PtHVFQUTCYTTCYTRkZGIKXERx99hA8++AD19fVQVRUlJSVc0I+IKAix7BMRBZmVlRW0trZCCIHx8XFkZmbi1KlTMJvNiIuL0zpeWAimog8At27dwtjYGJqbm7WOsmOKouDb3/42bt26heLiYk2zsPD7V35+Ps6dO4fm5uaNBf1eeeUVZGdnQ1VVmEwmxMbGah2TiIh+hWWfiChIjI2NQUqJ1tZWrK2toa6uDmfOnEFZWRlnzfwo2Io+cHe7vYyMDFRUVGgdZccqKyuRnp4OKaXmZR9g4Q+EuLg47Nu3D3v37sXAwACklHj77bdx8eJFmEwmqKqKnJwcrWMSEUU8ln0iIg15PB50dXVBCIEbN24gKSkJ+/fvh81mQ0pKitbxwk4wFv2FhQV0dnbixIkTYfGhjk6ng6IoeO+993Dq1CkkJiZqHYmFP0B0Oh0qKipQUVGB2dnZjQX9pJQoKSmBqqqor6+HwWDQOioRUURi2Sci0sDMzMzGwHhhYQFlZWX4jd/4DdTW1nJgHCDBWPQBwOVyQafTwWKxaB3FbywWCy5dugSXy4VDhw5pHQcAC3+gpaSkbLy3uru7IaXED37wAyQmJsJms8Fut4f0ehRERKGIZZ+IaJf4fD5cu3YNQgj09vYiOjoaZrMZqqoiOztb63hhLViLvtfrhZQSRqMR8fHxWsfxm4SEBBiNRjgcDhw4cCBotmpj4Q88g8GAxsZGNDY2Ynx8HEIIfPrpp/joo49QW1sLRVFQUVERFlexEBEFO5Z9IqIAW1pa2ljM6s6dO8jNzcVTTz0Fk8mk2V7kkSRYiz4A9PX1YWZmBqqqah3F7xRFQUtLC/r6+lBTU6N1nA0s/LsnOzsbTz31FE6ePLmx6Oi3vvUtZGRkQFEUWCyWsPqQi4go2LDsExEFyPDwMIQQaG9vh8/nQ0NDA5599lkUFxdzVmuXBHPRB+4uzFdQUICCggKto/hdYWEhCgoKIKUMqrIPsPDvtpiYGCiKArvdjps3b0JKiYsXL+K9996D0WiEqqph+R4gItIayz4RkR+tra2ho6MDUkoMDQ0hNTUVR44cgdVqDYqFyiJJsBf9O3fuoK+vD88++6zWUQJGURS8+eabmJqaQnp6utZx7sPCv/t0Oh1KSkpQUlKC06dPw+l0wuFwoKWlBYWFhVAUBY2NjYiOjtY6KhFRWGDZJyLygzt37kBKiZaWFiwtLaGqqgpf/epXUV1dHTT3K0eSYC/6AOBwOBAXF4fGxkatowSM0WjE+fPnIaVEc3Oz1nG+hIVfO4mJiTh8+DAOHjyIq1evQkqJn/zkJzh//jwsFgsURUFGRobWMYmIQhrLPhHRNnm93o1Bal9fH+Lj4zlIDQKhUPTX1tbgcrlgtVrDehYzOjoaFosFLpcLx44dQ1RU8A07WPi1pdfrUVtbi9ra2vs+NP3lL3+JqqoqKIrCD02JiLYp+M66RERBbmFhYePy05mZGRQWFuLZZ5/l5adBIBSKPgB0dnZiaWkJiqJoHSXgFEXBlStX0NHRAbPZrHWcB2LhDw4ZGRk4deoUjh07tnE71Pe+9z2kpqbCbrfDZrPxdigioi1g2Sci2gSfz7exsFRHRwf0ej0XlgoyoVL0gbsL81VWVkbEFSCZmZmorKyElDJoyz7Awh9M7l0RYrFYNhY6vXz5Mt5//300NjZCURQudEpEtAks+0REj7C6uorW1lZIKTE2NoaMjAycPHmSW0YFmVAq+sPDwxgaGsJXv/pVraPsGkVR8Nprr2FkZAT5+flax3koFv7gU1BQgGeffRanTp3a2MK0ra0Nubm5UBSFW5gSET0Cyz4R0QOMj49DCAG32421tTXU1taiubkZFRUVnE0KMqFU9IG7s/qpqamorq7WOsquqampQUpKCoQQeOaZZ7SO80gs/MEpPj4e+/fvx759+3Dt2jUIIfDzn/8cFy5cgNlshqqqyM7O1jomEVFQYdknIvoVj8eD7u5uSCkxODiIxMRE7N27F3a7HampqVrHowcItaK/tLSE9vZ2PPHEExG14Jher4fdbseHH36I5ubmoL8qhoU/eOl0OlRWVqKyshIzMzNwOBxwOp0QQqCsrAyKoqCurg4Gg0HrqEREmmPZJ6KINzs7uzFgnJ+fR2lpKV544QXU19dzwBjEQq3oA0BLSwu8Xi+sVqvWUXadzWbDBx98ALfbjX379mkd57FY+INfamoqjh8/jiNHjqCrqwtCCHz/+99HUlISbDYb7HY7UlJStI5JRKQZln0iikg+nw8DAwOQUqK7uxvR0dEwmUxQVRU5OTlax6PHCMWi7/P5IKVEQ0MDkpKStI6z65KSktDQ0AAhBPbu3RsSt8Ow8IcGg8EAo9EIo9GIsbExSClx5coVfPjhh6irq4OqqigrKwuJnzkiIn9i2SeiiLK8vLyxyNPk5CSys7Nx5swZmEwmxMbGah2PNiEUiz4AXLt2DXfu3MGzzz6rdRTNKIqCV155BQMDA6ioqNA6zqaw8IeW3NxcnD17FidPnkRrayuEEHj11VeRmZkJVVVhNpsRFxendUwiol3Bsk9EEWFkZARCCLS3t8Pj8aC+vh7nzp1DSUkJZ3tCSKgWfQCQUiInJwfFxcVaR9FMSUkJcnJyIIQImbIPsPCHotjYWKiqCkVRcOPGDQghcP78ebz77rtoamqCqqrIy8vTOiYRUUCx7BNR2FpfX0dnZyeEELh16xZSUlJw6NAh2Gy2iLyMOtSFctGfmZlBT08PnnrqqYj+cEmn00FRFLz99tuYnZ0NqfupWfhDk06nQ2lpKUpLSzE/Pw+n07mxRktRURFUVUVDQwOiojgkJqLww99sRBR2pqam4HA44HK5sLi4iIqKCrz88suoqamJqBXQw0koF30AcDgciI6ORlNTk9ZRNGcymXDx4kU4HA4cO3ZM6zhbwsIf2pKSkvDEE0/g0KFD6O3thRACP/rRj/DOO+/AarXCbrcjPT1d65hERH7Dsk9EYcHr9aK/vx9CCFy9ehVxcXGwWCxQFAWZmZlax6MdCPWi7/F44HQ6YTabuS4E7l5ebTKZ4HQ68cQTT4Tcjhcs/KFPr9ejrq4OdXV1mJychJQSDocDH3/8Maqrq6GqKiorK/nhMBGFPJZ9Igppi4uLcLlckFJienoa+fn5eOaZZ2A0GhEdHa11PNqhUC/6ANDV1YWFhQUoiqJ1lKChqurGThiNjY1ax9kyFv7wkZmZidOnT+P48eNoa2uDEALf+c53kJaWBkVRYLVakZCQoHVMIqJtYdknopDj8/kwNDQEIQQ6OjoAAEajES+++CIKCgoi+p7ocBIORR+4uzBfWVkZt3T8nJycHJSWlkIIEZJlH2DhDzfR0dGw2WywWq0YGhqClBKXLl3CpUuX0NjYCFVVUVhYyPMLEYUUln0iChmrq6tob2+HEAKjo6NIT0/H8ePHYbFYOPMSZsKl6N++fRvXr1/Hiy++qHWUoKOqKr7//e/j9u3bIftBCAt/+NHpdCgqKkJRURFOnTq1ceVYa2sr8vLyoKoqmpqaeOUYEYUEln0iCnoTExOQUqKlpQUrKyuoqanBiRMnUFlZyVmWMBQuRR8AhBBISkpCXV2d1lGCTl1dHZKSkiClxFNPPaV1nG1j4Q9fCQkJOHjwIA4cOIC+vj5IKfHTn/4U58+f31gTJisrS+uYREQPxbJPREHJ6/Wip6cHQggMDAwgISEBiqJAURSkpaVpHY8CJJyK/srKClpbW7Fv376QW4RuNxgMBthsNly5cgUnTpwI6cULWfjDm06nQ3V1NaqrqzE9PQ0pJVwuFz799FNUVFRAURTU1tZyQT8iCjos+0QUVObm5jb2QZ6bm0NxcTGee+457oMcAcKp6ANAa2sr1tbWYLfbtY4StOx2Oz788EO0tbWF/AKGLPyRIS0tDSdPnsTRo0fR2dkJKSVef/11JCcnw263w2azITk5WeuYREQAWPaJKAj4fD5cv34dQgh0d3fDYDCgqakJqqoiLy9P63i0C8Kt6Pt8PkgpUVdXh5SUFK3jBK2UlBTU1tZCCAG73R7yt+Ww8EeOqKgomEwmmEwmjI6OQgiBjz/+GJcvX0Z9fT0URUFpaWnI/0wTUWhj2ScizaysrMDtdkNKifHxcWRlZeH06dMwmUyIi4vTOh7tknAr+gBw48YN3L59G6dPn9Y6StBTVRXf/OY3cfPmTZSUlGgdZ8dY+CNPXl4ezp07h+bm5o1z2je+8Q1kZ2dDURSYzeaQvk2FiEIXyz4R7bqxsTEIIdDa2or19XXU19fjzJkzKCsr4yxIhAnHog/c3W4vMzMT5eXlWkcJeuXl5cjMzIQQIizKPsDCH6ni4uKwd+9e7NmzB4ODg5BS4he/+AUuXrwIk8kEVVWRm5urdUwiiiAs+0S0K9bX19HV1QUpJW7cuIHk5GQcOHAAdrud9zdGqHAt+vPz8+js7ERzczM/vNoEnU4HRVFw4cIFnD59GklJSVpH8gsW/sil0+lQXl6O8vJyzM7Owul0bqxFU1JSAkVRUF9fz3VoiCjg+FuGiAJqenoaDocDLpcLCwsLKC8vx2/8xm+gtraWK5RHsHAt+gDgdDqh1+thsVi0jhIyzGYz3n33XbhcLhw+fFjrOH7Dwk8pKSk4evQoDh8+jJ6eHkgp8cMf/hCJiYmwWq1QFAWpqalaxySiMMWyT0R+5/P50N/fDyklent7ERMTA7PZDEVRkJ2drXU80lg4F32v1wuHw4GmpiauO7EF8fHxaGpqgpQSBw8eDKstzFj4Cbi71WRDQwMaGhowPj4OKeXGon41NTVQFAWVlZW8GoiI/Ipln4j8ZnFxES0tLZBSYmpqCrm5uTh79iyampoQExOjdTwKAuFc9AGgt7cXs7OzUFVV6yghR1VVuFwuXL16FbW1tVrH8SsWfvq87OxsnDlzBidOnEBbWxuEEPj2t7+N9PR0KIoCq9WK+Ph4rWMSURhg2SeiHRsaGoKUEu3t7fD5fGhsbMRzzz2HoqIizlLQhnAv+sDdhfmKioqQn5+vdZSQk5+fj8LCQgghwq7sAyz89GUxMTGw2+2w2Wy4desWhBB47733cOnSJRiNRiiKgsLCQq1jElEIY9knom1ZW1tDe3s7pJQYHh5Gamoqjhw5AqvVisTERK3jUZCJhKI/OTmJ/v5+fOUrX9E6SshSVRU//vGPcefOHWRkZGgdx+9Y+OlBdDodiouLUVxcjNOnT8PlckFKiZaWFhQUFEBRFBiNRkRHR2sdlYhCDMs+EW3J5OTkxiBkeXkZ1dXV+NrXvoaqqqqwus+W/CcSij5wd1Y/Pj4ejY2NWkcJWY2NjXjnnXcgpcSpU6e0jhMQLPz0KImJiTh06BAOHDiAvr4+CCHw5ptv4vz587BYLFBVNSw/CCOiwGDZJ6LH8nq96O3thZQS/f39iI+Ph81mg6IoSE9P1zoeBbFIKfpra2toaWmBzWbjdlo7EBUVBavVCqfTiWPHjoXtTCYLPz2OXq9HTU0NampqcOfOnY1dba5cuYLKykqoqorq6mp+yE5Ej8QRCRE91Pz8/MbewLOzsygsLMRXvvIVNDY2stDQY0VK0QeA9vZ2LC8vQ1EUraOEPLvdjk8++QQdHR1hvX0hCz9tVkZGBpqbm3H06FF0dnZCCIHvfe97SE1Nhd1uh9VqRVJSktYxiSgIcbRORPfx+Xy4ceMGpJTo7OyEXq9HU1MTFEVBQUGB1vEoRERS0ff5fBBCoLq6mle6+EFGRgaqqqoghAjrsg+w8NPWREdHw2w2w2w2Y3h4GFJKXL58Ge+//z4aGhqgqiqKi4u5MC4RbWDZJyIAwMrKysYWQLdv396YSTCbzdwCiLYkkoo+AAwPD2NkZARf+9rXtI4SNlRVxXe/+10MDQ2F/WrkLPy0HQUFBXjmmWfQ3NwMt9sNIQS+/vWvIycnB6qqoqmpCbGxsVrHJCKNsewTRbjbt29DSgm32421tTXU1tbi9OnTKC8v5+wAbVmkFX0AEEIgLS0NVVVVWkcJG1VVVUhNTYWUMuzLPsDCT9sXHx+Pffv2Ye/evRgYGIAQAj//+c9x4cIFmM1mKIqCnJwcrWMSkUZY9okikMfjQXd3N4QQuH79OhITE7Fv3z7YbDakpqZqHY9CVCQW/cXFRbS3t+Po0aNcKMuP9Ho9FEXBBx98gObmZiQkJGgdKeBY+GkndDodKioqUFFRgZmZmY31doQQKC0thaqqqKurg8Fg0DoqEe0iln2iCDI7OwuHwwGn04n5+XmUlpbixRdf5ACAdiwSiz4AtLS0AACsVqu2QcKQ1WrF+++/j5aWFhw4cEDrOLuChZ/8ITU1deN3cVdXF6SU+P73v4+kpCTYbDbY7XakpKRoHZOIdgHLPlGY8/l8G5f29fT0bCzww0v7yF8itej7fD5IKdHY2IjExESt44SdxMRENDQ0QEqJ/fv3R8xtRSz85C8GgwFGoxFGoxG3b9+GEAJXrlzBhx9+iNraWqiqylv2iMIcyz5RmFpaWoLb7YaUEpOTk8jJycFTTz3FRXvIryK16ANAf38/pqam8Nxzz2kdJWypqoq2tjb09/dH1JoILPzkbzk5OTh79ixOnjyJ1tZWSCnxzW9+E5mZmVAUBRaLBXFxcVrHJCI/Y9knCjMjIyMQQqCtrQ1erxcNDQ145plnuB0P+V0kF33g7sJ8eXl5KCoq0jpK2CoqKkJubi6klBFV9gEWfgqM2NhYqKoKRVE2ttm9cOEC3n33XTQ1NUFVVeTn52sdk4j8hGWfKAysr6+jo6MDQggMDQ0hJSUFhw8fhs1mQ1JSktbxKAxFetGfnp5Gb28vnn76aX6IFkA6nQ6qquKtt97C9PQ00tLStI60q1j4KVB0Oh1KS0tRWlqK06dPbyzo53K5UFRUBEVR0NjYiKgoVgWiUMZ3MFEIm5qagpQSLpcLS0tLqKysxMsvv4yamhquDE4BE+lFHwAcDgdiY2PR1NSkdZSw19TUhAsXLsDhcODEiRNax9l1LPwUaElJSXjiiSdw6NAh9Pb2QkqJH//4x3jnnXdgtVqhKArS09O1jklE28CyTxRivF4v+vr6IIRAX18f4uLiYLFYoCgKMjMztY5HYY5F/+6VNE6nExaLBTExMVrHCXsxMTEwm81wuVw4cuRIRM40svDTbtDr9airq0NdXR0mJychpYTT6cQnn3yC6upqKIqCqqoqTiYQhZDIO2MShaiFhQW4XC44HA5MT0+joKAAzzzzDIxGI6Kjo7WORxGARf+urq4uLC4uQlEUraNEDFVV8dlnn6Grqytir6Zg4afdlJmZidOnT+P48eNob2+HEALf/e53kZaWBrvdDqvVyl1IiEIAyz5REPP5fLh16xaklOjo6IBOp4PRaISiKCgsLNQ6HkUQFv1fE0KgvLwcWVlZWkeJGFlZWSgvL4eUMmLLPsDCT7svOjoaVqsVVqsVQ0NDkFJunA8aGxuhKAqKioq4dglRkGLZJwpCq6uraGtrg5QSo6OjSE9Px/Hjx2GxWJCQkKB1PIowLPq/Njo6ips3b+Kll17SOkrEURQFb7zxBsbGxpCbm6t1HM2w8JNWCgsLUVhYiObmZrS0tEBKidbWVuTl5UFRFDQ1NfHWJqIgw7JPFEQmJiYghIDb7cbq6ipqampw4sQJVFZW8lNz0gSL/v2klEhOTkZtba3WUSJObW0tkpOTIYTA008/rXUcTbHwk5YSEhJw4MAB7N+/H/39/ZBS4q233sKFCxdgNpuhqiqvfCIKEiz7RBrzeDzo6emBlBIDAwNISEiAqqqw2+0Rt80UBRcW/fstLy+jtbUVBw8e5AJVGjAYDLDZbPjkk0/Q3NyM2NhYrSNpioWftKbT6VBVVYWqqipMT0/D4XDA6XTis88+Q3l5ORRFQW1tLQwGg9ZRiSIWyz6RRubm5jZOjHNzcygpKcHzzz+P+vr6iFxtmoILi/6Xtba2wuPxwGazaR0lYtntdly+fBlutxt79uzROo7mWPgpWKSlpeHEiRM4cuQIurq6IKXEG2+8geTkZNhsNtjtdiQnJ2sdkyjisFEQ7SKfz4fBwUFIKdHV1YWoqCiYTCaoqhrR96BScGHR/zKfzwchBOrq6jhg1VBycjLq6+shpYSqqry9CSz8FFyioqLQ1NSEpqYmjI6OQkqJTz75BJcvX0Z9fT0URUFZWRnfu0S7hGWfaBcsLy/D7XZDSomJiQlkZ2fjySefhNlsjvhLUSm4sOg/2PXr1zExMYGzZ89qHSXiKYqCV199FdevX0dZWZnWcYICCz8Fo7y8PDz99NM4efIkWltbIYTAq6++iqysLCiKArPZjLi4OK1jEoU1ln2iABodHYUQAm1tbfB4PKivr8fZs2dRWlrKT7Up6LDoP5wQAllZWSgtLdU6SsQrKytDVlYWpJQs+5/Dwk/BKi4uDnv27IGqqrh+/TqEEDh//jzeffddNDU1QVVV5OXlaR2TKCyx7BP52fr6Ojo7OyGlxM2bN5GcnIyDBw/CZrPx8l8KWiz6Dzc3N4fu7m6cPn2aH9IFAZ1OB0VRcP78eczNzfH36uew8FMw0+l0KCsrQ1lZGebm5uB0OjfWLiouLoaqqly3iMjP+G4i8pPp6WlIKeFyubC4uIjy8nK89NJLqK2t5crdFNRY9B/N6XTCYDDAZDJpHYV+xWw2491334XT6dwouHQXCz+FguTkZBw5cgSHDh1Cb28vhBD44Q9/iISEhI0F/bgjEdHOsewT7YDP50NfXx+klOjt7UVsbCwsFgsUReEesxQSWPQfzePxwOFwwGQy8d7SIBIXF4empiY4HA4cPnyYH6h+AQs/hQqDwYD6+nrU19djYmICUkoIIfDRRx+hpqYGqqqisrKSV1URbRPLPtE2LC4uwuVyweFwYGpqCnl5eTh37hyMRiNiYmK0jke0KSz6j9fb24u5uTkoiqJ1FPoCVVXhdDrR09OD+vp6reMEHRZ+CjVZWVl48skncfz4cbS3t0MIgW9/+9tIT0+HoiiwWCxISEjQOiZRSGHZJ9okn8+H4eFhCCHQ3t4OAGhsbMTzzz+PwsJCfupMIYVFf3OEECguLubiUUEoLy8PxcXFkFKy7D8ECz+FopiYGNhsNlitVgwNDUEIgffeew/vvfcejEYjVFVFQUEBx11Em8CyT/QYa2trG58wj4yMIC0tDceOHYPFYkFiYqLW8Yi2jEV/cyYmJjAwMIDnn39e6yj0EIqi4Ec/+hEmJiZ469RDsPBTqNLpdCgqKkJRURFOnTqFlpYWSCnhdruRn58PVVVhNBoRHR2tdVSioMWyT/QQk5OTkFKipaUFy8vLqK6uxm/+5m+isrKS94dSyGLR3zwhBBISEjhrHMQaGhrwzjvvQEqJJ598Uus4QYuFn0JdYmIiDh48iP3792+slfTmm2/i/PnzG2slZWZmah2TKOiw7BN9jtfr3VgV9tq1a4iPj4fdbofdbkd6errW8Yh2hEV/81ZXV+F2u6GqKreBCmJRUVGwWq2QUuL48eNcM+URWPgpHOj1etTU1KCmpgZTU1MbuyBduXIFFRUVUFUVNTU1nJQh+hWOYIgAzM/Pb+z3Ojs7i6KiIjz33HNoaGjgQJ/CAov+1rS1tWFlZQV2u13rKPQYiqLg448/Rnt7O2w2m9ZxghoLP4WT9PR0NDc349ixY+jo6ICUEq+99hpSUlJgt9ths9mQlJSkdUwiTbHFUMTy+Xy4ceMGhBDo6uqCwWBAU1MTFEVBfn6+1vGI/IZFf2t8Ph+klKipqeE+zyEgLS0NNTU1EELAarVy0a7HYOGncBMVFQWz2Qyz2YyRkREIIfDhhx/igw8+QENDAxRFQUlJCX83UERi2aeIs7KygtbWVgghMD4+jszMTDQ3N8NisXAfbQo7LPpbd+vWLYyOjuLEiRNaR6FNUhQF3/nOdzA0NISioiKt4wQ9Fn4KV/n5+XjmmWfuW9DvlVdeQU5ODhRFgclkQmxsrNYxiXYNyz5FjNu3b0MIgdbWVqytraGurg5PPvkkysvL+WkvhSUW/e2RUiI9PR2VlZVaR6FNqqqqQlpaGoQQLPubxMJP4SwuLg779u3D3r17MTAwACkl3n77bVy8eBEmkwmqqiInJ0frmEQBx7JPYc3j8aCrqwtCCNy4cQNJSUnYt28f7HY7UlJStI5HFDAs+tuzsLCAjo4OHD9+nB8ChhCdTgdFUXDp0iWcPn0aCQkJWkcKCSz8FO50Oh0qKipQUVGB2dlZOBwOOJ1OSClRWloKRVFQX18Pg8GgdVSigGDZp7A0MzOz8Qt9YWEBZWVlePHFF1FXV8df6BT2WPS3z+VyAQAsFou2QWjLrFYrLl26BJfLhYMHD2odJ2Sw8FOkSElJ2Tgvdnd3Q0qJH/zgB0hMTITNZoPdbkdqaqrWMYn8imWfwobP58O1a9cgpURPTw+io6NhNpuhqiqys7O1jke0K1j0t8/r9cLhcMBoNHJmOAQlJCTAaDRCSon9+/dz660tYOGnSGIwGNDY2IjGxkbcvn0bUkp8+umn+Oijj1BbWwtFUVBRUcGruygssOxTyFtaWtpYhOXOnTvIzc3FU089BZPJxD2XKaKw6O9MX18fpqen8eKLL2odhbZJURS43W709/ejurpa6zghhYWfIlFOTg6eeuopnDx5cmPx5m9961vIyMiAoiiwWCyIj4/XOibRtrHsU8gaHh6GEALt7e3wer1obGzEs88+i+LiYn4aSxGHRX/npJQoKChAYWGh1lFomwoLC5Gfnw8hBMv+NrDwU6SKiYmBoiiw2+24efMmpJS4ePEi3nvvPRiNRqiqioKCAq1jEm0Zyz6FlLW1NXR0dEBKiaGhIaSmpuKJJ56AzWZDYmKi1vGINMGiv3NTU1O4evUqnnnmGa2j0A7odDqoqoo333wTU1NTSE9P1zpSyGHhp0im0+lQUlKCkpISnDp1Ci6XCw6HAy0tLSgsLISiKGhsbER0dLTWUYk2hWWfQsKdO3cgpURLSwuWlpZQVVWFr371q6iuruZ9mRTRWPT9Q0qJuLg4GI1GraPQDhmNRpw/fx4OhwMnT57UOk5IYuEnApKSknD48GEcPHgQV69ehZQSP/nJT3D+/HlYLBYoioKMjAytYxI9Ess+BS2v17vxy7Wvrw/x8fH85Ur0OSz6/rG+vg6XywWLxcLZmjAQHR0Ni8UCl8uFo0ePIiqKQ53tYOEnukuv16O2tha1tbUbk08ulwu//OUvUVVVBUVROPlEQYtnQAo6CwsLcDqdcDgcmJmZQWFhIZ599lleNkX0OSz6/tPR0YGlpSUoiqJ1FPITRVFw5coVdHZ2wmQyaR0nZLHwE90vIyMDp06dwrFjx9DR0QEhBL73ve8hNTUVdrudt5VS0GHZjyAenw/jSx6MLq5jdHEd8+teeLw+GPQ6JEXpkZcQhbyEKGTHG2DY5QXufD7fxoIoHR0d0Ov1XBCF6CFY9P1LSonKykpkZmZqHYX8JDMzExUVFRBCsOzvEAs/0Zfdu4LIYrFgaGgIUkpcvnwZ77//PhobG6EoimYLRgfzeJ92H8t+BJhZ9aBlYhmuiWUse3wAAD0A7+ceowfQMnn3/8cZdLBmxcGSFYfUGENAs62urqK1tRVSSoyNjSEjIwMnT57kVidED8Gi718jIyO4desWXn75Za2jkJ+pqorXXnsNIyMjyM/P1zpOSGPhJ3q4wsJCFBYW4tSpUxtbQbe1tSE3NxeqqqKpqWlXtoIO5vE+aYdlP4wte7y4NLQA9+QKdAB8n/ue9wuP9d73PB+ujC3hl2NLMGfG4nhhImIN/r0PaXx8HEIIuN1urK2toaamBs3NzaioqOC2eUQPwaLvf0IIpKSkoKamRuso5Gc1NTVISUmBlBLnzp3TOk7IY+EnerT4+Hjs378f+/btw7Vr1yCEwFtvvYULFy7AbDZDURRkZ2f7/bjBPN4n7bHsh6mB2VX87PocFtfvvuV9j3n8F917fOvkCvpnVnG2NBnlKTv7VNLj8aC7uxtSSgwODiIxMRF79+6F3W5Hamrqjl6bKNyx6Pvf8vIy2tracPjwYS6sFIb0ej3sdjs++ugjNDc3Iy4uTutIIY+Fn+jxdDodKisrUVlZiZmZGTgcDjidTnz22WcoKyuDqqqora2FwbDz2fRgHO9TcGHZD0OO8SVcuLXwpU/3tsMHYGHdh9f6Z9FclAh79tYvrZ+dnd34RTc/P4+SkhK88MILqK+v98svOqJwx6IfGC0tLfB6vbDZbFpHoQCx2Wz44IMP4Ha7sXfvXq3jhAUWfqLNS01NxfHjx3HkyBF0dXVBCIE33ngDSUlJGwv6paSkbOu1g228T8GJZT/M3HvjAzt/499z73Xuve5mfgH4fD4MDg5CCIHu7m5ER0fDZDJBURTk5ub6KRlR+GPRDwyfzwcpJRoaGpCUlKR1HAqQpKQk1NfXQwiBPXv28DYxP2HhJ9oag8EAo9EIo9GIsbExSCnxy1/+EpcvX0ZdXR1UVUVZWdmmf0cFy3ifgh/LfhgZmF3Fdz5y4+qVSxjqcmOoqxXjA73wejxo/sN/heO//yePfH7fpx/gw2/9D9zqcGF1aRHp+UVoPP40jv7eP0Nswt3B8IVbC8iINTz0Ep/l5WW43W4IITA5OYns7GycOXMGJpMJsbGxfv9vJgpnLPqBMzAwgMnJSd7LHQFUVcUrr7yCwcFBlJeXax0nbLDwE21Pbm4uzp49i5MnT6K1tRVCCLz66qvIysqCoigwm82PvO1op+N9r9cL11uvw/XWGxjt7cDywhwSUtOQXVYD48lz2P/S7z12vE+hg2U/TCx7vPjZ9Tl8+sbX8fF3/3rLz//oW/8Tb/2XP4VOp0OZdR+SMrMx6LqC9//2L9Hx3s/wD/7mZ0hMz4QOwFvX5/AHDen3LeIxOjoKIQTa2trg8XhQX1+Pc+fOoaSkhDMpRNvAoh9YUkrk5OSgpKRE6ygUYCUlJcjOzoYQgmXfz1j4ibYvNjYWqqpCURTcuHEDQgicP38e7777LpqamqCqKvLy8u57zk7H+8tzs3j1j38bA85fIjYpGaUmFXHJqZi9PYLhnjasLMxh/0u/99DxPoUelv0wcWloAYvrPuRW1eHw7/xjFNQ1oaDOhPf/9i/heuv1Rz53uLsVP/+v/w56gwG/+5ffQu3BkwCA1aVFvPrHv4P+zy7jx//xn+O3/vzrG/f0vDe0gOaCeHR2dkIIgVu3biElJQWHDh2CzWbjZbFEO8CiH1izs7Po7u7GmTNn+GFkBNDpdFBVFW+//TZmZ2e3fX8sPRgLP9HO6HQ6lJaWorS0FHNzc3A6nRtrXRUVFUFVVTQ0NCAqKmpH432fz4dv/snvYsD5S+x54e/gqT/+9xtX7gLA+toqRq923n0sfj3eP1OSHMj/fAowlv0wML3igXtyBQCgPvc7931Pp3/8QPb9r/83+Hw+KM98baPoA0BMfAJe+Hd/iT9/RkH7uz/D7YGryCmvhg+Ae2IZbT/5JpbujKOiogIvv/wyampquKI10Q6x6Aeew+HYWEeEIoPJZMLFixfhdDpx9OhRreOEHRZ+Iv9ITk7GkSNHcPjwYfT09EBKiR/96Ed455130GDfi7b0BgDbG+87fvIdXJMfo3r/MTz3b//zl74fFR2DogbLxp99ANyTKziQl4DUGC6oHapY9sOAe3J52ytxrq+tovvDiwAA85MvfOn76QXFKDXvwaDrCjovvYWc8j/61Xd8yLYexjP1BcjMzNxudCL6HBb9wPN4PHA6nVxHJMLExsbCZDLB4XDg8OHD3AkmAFj4ifxHr9ejvr4e9fX1mJiYgJQSLVOr8KV6odvmxNon3/tfAIAnfvefbPo5OgAtE8s4UpC4rWOS9lj2Q5zH54NrYnnbK3FOXO/H2vIiANz3ad7nFTZYMOi6guGetl9/UafHTEoB0jIytnlkIvo8Fv3d0d3djfn5eaiqqnUU2mWKokBKiZ6eHjQ0NGgdJyyx8BP5X1ZWFppPn0ZX6yRWvNt7jbnJ2xjp7YDeYECpWcWdW4NovfATTA3fRGxCIoqNNtQfPYOo6PsX5PMBcE0s41B+Agy87S0kseyHuPElD5Y92990Y2roBgAgLjkVsYkPvs8+LbcQAHDnV4+9Z9njw/iSB3kJ/DEi2gkW/d0jhEBpaSlycnK0jkK7LDc3FyUlJRBCsOwHEAs/kf+NL3m2XfQBbNyLn5CaAfHjb+Hn/+X/hGd97b7HZBSV4bf/8yvIr2m87+sc74c23mAd4kYX13f0/JXFeQB3789/mJiEu5furCzM+f34RJGORX/33L59G9evX4eiKFpHIY2oqorBwUGMj49rHSWsHTlyBEePHsWlS5dw+fJlreMQhbydjrcXZ6bu/u/sFH76n/4N6o8+iX/2+mX8+48G8I9eeRvFRjvu3BrE1//Jy1iYvuP345N2WPZD3Ojiumb/iHrwzU+0Eyz6u0tKicTERNTX12sdhTRSX1+PxMRECCG0jhL2WPiJ/Gen432f7+5VwN71dZSYVPzWf/pb5FXVIzYhCSUmBX/vf3wfSZnZmJsYw5U3vn7fczneD20s+yFuft2LHVzVs7HlxurS4kMfs7q4cPexifdvveEFsLC+k6MTRS4W/d21srICt9sNm83GxdkimMFggM1mg9vtxurqqtZxwh4LP5F/+Gu8DwB7XvjdL38/MQnWp34DAND/6Qf3fY/j/dDGsh/iPN7t368P3F1tHwCW52awsjD/wMdMjw3d99jPW9/h8YkiEYv+7mtra8Pa2hrsdrvWUUhjdrsda2traG1t1TpKRGDhJ9q5nY73M4pKf/3/C0sf+Jj0X319dmLsS9/jeD90seyHOMMm9tV8lKyyKkTH3b1f/1ZnywMfM/SrrxfWfXlP6qgdHp8o0rDo7z6fzwchBGpra5Gamqp1HNJYamoqampqIKXcuLSVAouFn2hndjzeL6ncWIh78QH35H/+67EJX95mj+P90MWyH+KSovQ7+keMio5B3eGTAAD3L37wpe9PDd/Ejda79zY2HDt73/f0ABKj+CNEtFks+tq4efMmbt++zYX5aIOqqhgbG8PNmze1jhIxWPiJtm+n431DVBQajj4FAOj7wmX69/RdeR8AUNRou+/rHO+HNv7Lhbi8hKgd3cMDAEf+7j+FTqeD483voufjdze+vrq0iB/8hz+C1+OB8cTTyCmvvu953l8dn4gej0VfO0IIZGRkoKKiQusoFCQqKiqQkZEBKaXWUSIKCz/R9vhjvH/09/4IhqhoiB99C12Xz9/3vcvf+P9isOVT6A0G7H/p9+77Hsf7oY3/ciHui2++oS43fvJn/3Ljz3duDQIAPvvBq+i+fGHj67/9F68gJTsPAFBYb8ZTf/wf8NZ/+VN8459+DeX2A0hMz8Kg6wrmJsaQXVaFr/yb/7yp4xPRl7Hoa2d+fh6dnZ04efIkdDpehkh36XQ6KIqCixcv4vTp00hM/PJlqxQYR44cAQBcunQJAPg7kWgT/DHezymvxnN/+l/wg//rn+HVP/otFDZYkF5QjLG+bowPXoXeYMCz//rPkVfd8NjjU+jgv1yIy443IM6gw7Ln7n2HKwvzuNnu+NLjZsaGMTM2vPFnz9r9qxAf+u1/iLzqenz4zf+Omx0urC0tIjWvEEf/t3+Go7/3Rxv3+XxenEGH7Hiuak30KCz62nK5XNDr9bBYLFpHoSBjsVjw3nvvwel04vDhw1rHiSgs/ERb46/xvv3cV5FTUYvLr/wVBl2fYrS3Awlp6WhqfgaHf+cfo9ho++JLcrwf4lj2Q5xBp4M1Kw5XxpbgA1ChHMSfOce39VpVe4+gau+RTT1WB8CaFQcDZ8qIHopFX1terxdSSjQ1NSE+Pl7rOBRk4uPjYTQa4XA4cPDgQej1vLNxN7HwE22eP8f7xY1W/Naff31Tj+V4P/TxzBYGLFlx2O31hH2/Oi4RPRiLvvauXr2K2dlZqKqqdRQKUqqqYmZmBlevXtU6SkTiPfxEm8fxPm0Hy34YSI0xwJwZi936zE0HwJwZi9QYXtJD9CAs+sFBCIHCwkLk5+drHYWCVEFBAQoLC7lQn4ZY+Ik2h+N92g6W/TBxvDARiVG6gP8C0AFIjNLheCEXMyJ6EBb94HDnzh309/dzVp8eS1EU9PX14c6dB+89TYHHwk+0ORzv01ax7IeJWIMeZ0uTA355jw/A2dJkxBr4o0P0RSz6wUNKifj4eDQ2NmodhYJcY2Mj4uPjObuvMRZ+osfjeJ+2iv+CYaQ8JQbNRYH9BO5UUSLKU2ICegyiUMSiHzzW1tbgcrlgtVoRFcV1aOnRoqOjYbFY0NLSgrW1Na3jRDQWfqLH43iftoJlP8zYs+M3fgH46xKfe69zqigRtmyuaE30RSz6waWjowPLy8uw2+1aR6EQoSgKlpaW0NHRoXWUiMfCT/R4HO/TZnHKIwzZs+OREWvAW9fnsLDu29GlPvfu2TlbmsxP+IgegEU/+AghUFVVhYyMDK2jUIjIyMhAVVUVpJSwWCxax4l43JaP6PE43qfN4Mx+mCpPicHvN6TDlBkLYOuf+t17vCkzFn/QkM43PtEDsOgHn6GhIQwPD3NhPtoyRVE2fn5Ie5zhJ3o8jvfpcTizH8biDHqcKUnGgbwEtEwswzWxjGXP3c/99AC8n3vs5/8cZ9DBmhUHS1Yct9sgeggW/eAkpURqaiqqqqq0jkIhprq6GqmpqRBC4Nlnn9U6DoEz/ESbwfE+PQrLfgRIjTHgSEEiDuUnYHzJg9HFdYwurmNh3Yt1rw9Reh0So/TIS4hCXkIUsuMNMOh2axdPotDDoh+clpaW0N7ejiNHjkCv54VrtDV6vR52ux2XL1/GqVOnEB/Pe1aDAQs/0eZwvE8PwrIfQQw63cYbnIi2h0U/eLW0tMDn88FqtWodhUKUzWbD+++/j5aWFuzfv1/rOPQrLPxEm8fxPn0efwqIiDaJRT94+Xw+SCnR0NCAxMTAbklE4SsxMRGNjY2QUmLfvn3QcdYraLDwExFtHa9zJCLaBBb94Hbt2jXcuXOHC/PRjimKgjt37uDatWtaR6Ev4KJ9RERbw5l9IqLHYNEPfkII5ObmoqioSOsoFOKKi4uRm5sLKSUqKyu1jkNfwBl+IqLN48w+EdEjsOgHv5mZGfT29kJVVV52TTum0+mgKAp6enowMzOjdRx6AM7wExFtDss+EdFDsOiHBiklYmJi0NTUpHUUChMmkwnR0dFwOBxaR6GHYOEnIno8XsZPRPQALPqhYX19HS6XC2azGTExMVrHoTARExMDs9kMp9OJI0eOwGDgHtTBiJf0ExE9Gmf2iYi+gEU/dHR1dWFhYQGKomgdhcKMqqpYWFhAV1eX1lHoETjDT0T0cJzZJyL6HBb90CKlRFlZGbKzs7WOQmEmOzsbZWVlEELAaDRqHYcegTP8REQPxpl9IqJfYdEPLWNjY7hx4wa326OAURQFN27cwNjYmNZR6DE4w09E9GUs+0REYNEPRUIIJCUloba2VusoFKbq6uqQlJQEKaXWUWgTWPiJiO7Hsk9EEY9FP/SsrKygtbUVdrudi6dRwBgMBthsNrS2tmJlZUXrOLQJLPxERL/Gsk9EEY1FPzS53W6sr6/DZrNpHYXCnN1ux9raGlpbW7WOQpvEwk9EdBcX6COiiMWiH5p8Ph+klKirq0NKSorWcSjMpaSkoK6uDkIIKIoCnU6ndSTaBC7aR0TEmX0iilAs+qHr+vXrGB8f58J8tGsURcH4+Dhu3LihdRTaAs7wE1Gk48w+EUUcFv3QJqVEVlYWysrKtI5CEaK8vByZmZkQQqC0tFTrOLQFnOEnokjGsk9EEYVFP7TNzc2hq6sLp06d4uXUtGt0Oh1UVcX58+cxPz+PpKQkrSPRFrDwE1Gk4mX8RBQxWPRDn9PphMFggNls1joKRRiz2QyDwQCn06l1FNoGXtJPRJGIM/tEFBFY9EOf1+uFw+FAU1MT4uLitI5DESYuLg5NTU1wOBw4dOgQ9HrOl4QazvATUaThmYqIwh6Lfnjo6enB3NwcF+YjzaiqitnZWfT29modhbaJM/xEFEk4s09EYY1FP3xIKVFcXIy8vDyto1CEysvLQ1FREYQQqKur0zoObRNn+IkoUnBmn4jCFot++JiYmMC1a9egKIrWUSjCqaqKa9euYXJyUusotAOc4SeiSMCyT0RhiUU/vEgpkZCQgIaGBq2jUIRraGhAQkICpJRaR6EdYuEnonDHsk9EYYdFP7ysrq6ipaUFVqsVUVG8+4y0FRUVBavVipaWFqytrWkdh3aIhZ+IwhnLPhGFFRb98NPe3o6VlRVewk9Bw263Y3l5Ge3t7VpHIT9g4SeicMUpEiIKGyz64cfn80EIgZqaGqSlpWkdhwgAkJ6ejurqagghYLFYoNPptI5EO8RF+4goHHFmn4jCAot+eBoaGsLo6Chn9SnoqKqKkZERDA8Pax2F/IQz/EQUbjizT0Qhj0U/fEkpkZaWhqqqKq2jEN2nsrISaWlpEEKgsLBQ6zjkJ5zhJ6Jwwpl9IgppLPrha3FxEe3t7VAUhZdJU9DR6/VQFAXt7e1YXFzUOg75EWf4iShcsOwTUchi0Q9vLpcLAGC1WjVOQvRg9342W1patA1CfsfCT0ThgJfxE1FIYtEPbz6fD1JKGI1GJCQkaB2H6IESEhLQ2NgIKSX279/PK1DCDC/pJ6JQx5l9Igo5LPrhr6+vD9PT01yYj4KeqqqYmppCf3+/1lEoADjDT0ShjDP7RBRSWPQjgxAC+fn5XPiMgl5hYSHy8vIghOBCkmGKM/xEFKo4s09EIYNFPzJMTU3h6tWrXJiPQoJOp4Oqqujt7cX09LTWcShAOMNPRKGIZZ+IQgKLfuRwOByIjY1FU1OT1lGINsVoNCI2NhZSSq2jUACx8BNRqGHZJ6Kgx6IfOdbX1+FyuWCxWBAdHa11HKJNiYmJgcVigcvlwvr6utZxKIBY+IkolLDsE1FQY9GPLJ2dnVhcXOTCfBRyFEXB4uIiOjs7tY5CAcbCT0Shggv0EVHQYtGPPEIIVFRUICsrS+soRFuSlZWF8vJySClhMpm0jkMBxkX7iCgUcGafiIISi37kGRkZwa1btzirTyFLVVXcvHkTo6OjWkehXcAZfiIKdiz7RBR0WPQjk5QSycnJqK2t1ToK0bbU1tYiOTkZQgito9AuYeEnomDGsk9EQYVFPzItLy+jra0Ndrsdej1PTRSa9Ho97HY72trasLy8rHUc2iUs/EQUrDiiIqKgwaIfudxuNzweD2w2m9ZRiHbEZrPB4/HA7XZrHYV2EQs/EQUjLtBHREGBRT9y+Xw+CCFQX1+P5ORkreMQ7UhycjLq6+shpcSePXug0+m0jkS7hIv2EVGw4cw+EWmORT+yDQ4OYnJyEqqqah2FyC8URcHExAQGBwe1jkK7jDP8RBRMOLNPRJpi0SchBLKzs1FSUqJ1FCK/KC0tRXZ2NqSUKC8v1zoO7TLO8BNRsODMPhFphkWfZmdn0d3dDVVVebkzhQ2dTgdFUdDV1YW5uTmt45AGOMNPRMGAZZ+INMGiTwDgdDoRHR0Nk8mkdRQivzKbzYiKioLD4dA6CmmEhZ+ItMbL+Ilo17HoEwB4PB44HA6YTCbExsZqHYfIr2JjY2EymeB0OnH48GEYDAatI5EGeEk/EWmJM/tEtKtY9Omenp4ezM/PQ1EUraMQBYSqqpibm0NPT4/WUUhDnOEnIq1wZp+Idg2LPn2eEAIlJSXIzc3VOgpRQOTm5qKkpARSSjQ0NGgdhzTEGX4i0gJn9oloV7Do0+eNj49jcHCQ2+1R2FMUBQMDAxgfH9c6CmmMM/xEtNtY9oko4Fj06YuklEhMTER9fb3WUYgCqr6+HomJiZBSah2FggALPxHtJpZ9IgooFn36otXVVbjdbthsNi5aRmEvKioKVqsVbrcbq6urWsehIMDCT0S7hWWfiAKGRZ8epK2tDaurq7Db7VpHIdoVdrsdq6uraGtr0zoKBQkWfiLaDVygj4gCgkWfHsTn80EIgZqaGqSmpmodh2hXpKWloaamBlJK2Gw26HQ6rSNREOCifUQUaJzZJyK/Y9Gnh7l16xbGxsa4MB9FHEVRMDo6ilu3bmkdhYIIZ/iJKJA4s09EfsWiT48ihEBGRgYqKiq0jkK0qyorK5Geng4pJYqLi7WOQ0GEM/xEFCic2Sciv2HRp0dZWFhAZ2cnFEXhZcwUcXQ6HRRFQUdHBxYWFrSOQ0GGM/xEFAgs+0TkFyz69DhOpxM6nQ4Wi0XrKESasFgs0Ol0cLlcWkehIMTCT0T+xsv4iWjHWPTpcbxeLxwOB4xGI+Lj47WOQ6SJhIQEGI1GSClx4MAB6PWcc6H78ZJ+IvInnmWIaEdY9Gkzrl69ipmZGS7MRxFPURTMzMygr69P6ygUpDjDT0T+wpl9Ito2Fn3aLCklCgoKUFBQoHUUIk0VFhaioKBgYwtKogfhDD8R+QNn9oloW1j0abPu3LmDvr4+zuoT/YqiKOjr68OdO3e0jkJBjDP8RLRTLPtEtGUs+rQVUkrExcWhsbFR6yhEQcFoNCIuLg4Oh0PrKBTkWPiJaCdY9oloS1j0aSvW1tbQ0tICq9WK6OhoreMQBYXo6GhYLBa4XC6sra1pHYeCHAs/EW0Xyz4RbRqLPm1VR0cHlpaWoCiK1lGIgoqiKFhaWkJnZ6fWUSgEsPAT0XZwgT4i2hQWfdoOKSUqKyuRkZGhdRSioJKZmYnKykoIIWA2m7WOQyGAi/YR0VZxZp+IHotFn7ZjeHgYQ0NDXJiP6CEURcHQ0BCGh4e1jkIhgjP8RLQVLPtE9Egs+rRdQgikpqaiurpa6yhEQammpgapqamQUmodhUIICz8RbRbLPhE9FIs+bdfS0hLa29tht9uh1/NUQ/Qger0edrsdbW1tWFpa0joOhRAWfiLaDI7AiOiBWPRpJ1paWuD1emGz2bSOQhTUrFYrvF4v3G631lEoxLDwE9HjcIE+IvoSFn3aCZ/PByklGhsbkZiYqHUcoqCWlJSEhoYGCCGwd+9e6HQ6rSNRCOGifUT0KJzZJ6L7sOjTTl27dg137tzhdntEm6SqKu7cuYOBgQGto1AI4gw/ET0MZ/aJaAOLPvmDlBK5ubkoLi7WOgpRSCguLkZOTg6EEKioqNA6DoUgzvAT0YNwZp+IALDok3/MzMygp6cHiqLwcmSiTdLpdFBVFT09PZidndU6DoUozvAT0Rex7BMRiz75jcPhQHR0NEwmk9ZRiEJKU1MToqOj4XA4tI5CIYyFn4g+j5fxE0U4Fn3yF4/HA6fTCbPZjJiYGK3jEIWU2NhYmM1mOJ1OPPHEEzAYDFpHohDFS/qJ6B7O7BNFMBZ98qeuri4sLCxAVVWtoxCFJEVRMD8/j+7ubq2jUIjjDD8RAZzZJ4pYLPrkb1JKlJWVITs7W+soRCEpJycHpaWlEEKgsbFR6zgU4jjDT0Sc2SeKQCz65G+3b9/G9evXud0e0Q6pqorr16/j9u3bWkehMMAZfqLIxrJPFGFY9CkQhBBISkpCXV2d1lGIQlpdXR2SkpIgpdQ6CoUJFn6iyMWyTxRBWPQpEFZWVtDa2gqbzcZFxYh2yGAwwGazwe12Y2VlRes4FCZY+IkiE8s+UYRg0adAaW1txdraGux2u9ZRiMKC3W7H2toa2tratI5CYYSFnyjycIE+ogjAok+B4vP5IKVEXV0dUlJStI5DFBZSUlJQW1sLIQTsdjt0Op3WkShMcNE+osjCmX2iMMeiT4F048YN3L59mwvzEfmZqqq4ffs2bt68qXUUCjOc4SeKHJzZJwpjLPoUaEIIZGZmory8XOsoRGGlvLwcmZmZEEKgpKRE6zgUZjjDTxQZOLNPFKZY9CnQ5ufn0dXVBUVReJkxkZ/pdDooioLOzk7Mz89rHYfCEGf4icIfyz5RGGLRp93gdDqh1+thsVi0jkIUlsxmM/R6PZxOp9ZRKEyx8BOFN17GTxRmWPRpN3i9XjgcDjQ1NSEuLk7rOERhKT4+Hk1NTXA4HDh06BD0es7RkP/xkn6i8MWzBlEYYdGn3dLb24vZ2Vmoqqp1FKKwpqoqZmdn0dvbq3UUCmOc4ScKT5zZJwoTLPq0m4QQKCoqQn5+vtZRiMJafn4+CgsLN7a4JAoUzvAThR/O7BOFARZ92k2Tk5O4du0at9sj2iWqqqK/vx+Tk5NaR6Ewxxl+ovDCsk8U4lj0abdJKREfH4/GxkatoxBFhMbGRsTHx0NKqXUUigAs/EThg2WfKISx6NNuW1tbQ0tLC6xWK6KieCcY0W6IioqC1WpFS0sL1tbWtI5DEYCFnyg8sOwThSgWfdJCe3s7lpeXeQk/0S5TFAXLy8tob2/XOgpFCBZ+otDHaRmiEMSiT1rw+XwQQqC6uhrp6elaxyGKKOnp6aiuroaUElarVes4FCG4aB9RaOPMPlGIYdEnrQwPD2NkZITb7RFpRFEUDA8PY2hoSOsoFEE4w08UujizTxRCWPRJS0IIpKWlobKyUusoRBGpqqoKaWlpkFKisLBQ6zgUQTjDTxSaOLNPFCJY9ElLi4uLaG9vh6Io0Ot56iDSgl6vh91uR3t7OxYXF7WOQxGGM/xEoYcjNqIQwKJPWmtpaQEA3itMpDGr1Qqfz7fxniTaTSz8RKGFl/ETBTkWfdKaz+eDlBKNjY1ISEjQOg5RREtMTERjYyOklNi/fz90Op3WkSjC8JJ+otDBsk/kZx6fD+NLHowurmN0cR3z6154vD4Y9DokRemRlxCFvIQoZMcbYHjMII1Fn4JBf38/pqam8Pzzz2sdhYhwd6G+1tZW9Pf3o6qqSus4FIG2U/j9OT4ios1h2Sfyk5lVD1omluGaWMayxwfg7n0y3s89Rg+gZfLu/48z6GDNioMlKw6pMYYvvR6LPgULIQTy8vK4IBhRkCgqKkJeXh6klCz7pJnNFn5/j4+IaPNY9ol2aNnjxaWhBbgnV6AD4Pvc97xfeKz3vuf5cGVsCb8cW4I5MxbHCxMRa7i7jAaLPgWL6elp9Pb24ty5c7xcmChI6HQ6KIqCt956C9PT00hLS9M6EkWoRxX+QIyPiGhrWPaJdmBgdhU/uz6HxfW7pzDfYx7/Rfce3zq5gv6ZVZwtTcYN1y9Z9CloOBwOxMbGwmg0ah2FiD6nqakJFy5cgMPhwIkTJ7SOQxHsQYU/EOOj8pQYPyUmihws+0Tb5BhfwoVbC1/6tHo7fAAW1n14rX8Wa4MTLPoUFNbX1+F0OmGxWBATw0EWUTCJiYmB2WyGy+XCkSNHEBXFIR1p5/OFfyQ6HQNx+X4fHzUXJcKeHb/TqEQRhdfEEG3DvaIP7PxEds+914k2HUFiveqnVyXavq6uLiwuLkJRFK2jENEDqKqKhYUFdHV1aR2FCEeOHEFd8/MYiMsH4P/x0YVbC3CML/npVYkiA8s+0RYNzK5uFP1AuXBrAQOzqwE9BtHjCCFQXl6OrKwsraMQ0QNkZWWhvLwcUkqtoxBhYHYVA/H5AT0Gx0dEW8Nrvoi2YNnjxc+uz2FisA+9Vy5hqMuNoa5WjA/0wuvxoPkP/xWO//6fPPC506ND6Pno4q+e48ZYfzc8a6tQvvJbeOHf/eV9j9UBeOv6HP6gIZ2L0pAmRkdHcfPmTbz00ktaRyGiR1AUBW+88QbGxsaQm5urdRyKUDsZH138n/8J7/71nz/y9f/4B58gp7ya4yOiLWLZJ9qCS0MLWFz34ZdvfB2ffPevt/Tc9nd/irf+4k839dh796i9N7SAMyXJ20hKtDNSSiQnJ6O2tlbrKET0CLW1tUhOToYQAk8//bTWcShC7WR8dE9+TSPyax+8GGxc0t2xEMdHRFvDsk+0SdMrHrgnVwAAeVV1OPw7/xgFdU0oqDPh/b/9S7jeev2Rz88oLMX+r/4+CutMKKgzoe3CT3Dpb/7rQx/vA+CeXMGBvATuM0u7anl5Ga2trTh48CD0es6cEAUzg8EAm82GTz75BM3NzYiNjdU6EkWYnY6P7mk4+hRO/sN/8djHcXxEtHks+0Sb5J5c3lhZVn3ud+77nk7/+P3HG46eQcPRMxt/7njvrcc+RwegZWIZRwoSt5iWaPvcbjc8Hg9sNpvWUYhoE+x2Oy5fvgy32409e/ZoHYcizE7HR9vB8RHR5nDKhmgTPD4fXBPLfltZdrN8AFwTy/D4dvvIFKl8Ph+klKirq0NyMi+RJAoFycnJqK+vhxACPp4vaBdxfEQU3DizT7QJ40seLHu0OaEse3wYX/IgL4FvVwq8wcFBTExM4OzZs1pHIaItUBQFr776Kq5fv46ysjKt41CE8Of4aLi7Fb/4q/+AxZlpxCWloKCuCfVPnEZsYtIDH8/xEdHj8d1BtAmji+uaH58nM9oNUkpkZWWhtLRU6yhEtAVlZWXIysqCEIJln3aNP8dHXZffQdfld+77WlxSCs79i/8I29MvP/T4HB8RPRzfHUSbMLq4Dj0ArwbH1kP7DxsoMszNzaGrqwtPPvkkdLrA3GdJRIGh0+mgKArOnz+Pubk53oZDu8If46OMojKc/if/FjUHTyA9vxgAMHatBx98/a/Q/eF5vPHv/gl0egOsT7143/M4PiJ6PN6zT7QJ8+teTYo+cPcEurCu1dEpkjgcDkRFRcFkMmkdhYi2wWw2w2AwwOl0ah2FIoQ/xke2p1/C0d/7IxTUNiE+JQ3xKWkos+zF3/lv38b+r/4+AOCtv/hTrK+t3vc8jo+IHo9ln2gTPF5tF4BZ1/j4FP48Hg+cTidMJhPi4uK0jkNE2xAXF4empiY4HA54PB6t41AECPT46OQ/+BfQGwxYmJrAzTbHl77P8RHRo7HsE22CIUBbx2xWlMbHp/DX09ODubk5KIqidRQi2gFVVTE3N4fe3l6to1AECPT4KCE1HYnpWQCAmdsjX/o+x0dEj8ayT7QJSVF6zd4segCJUXyrUmBJKVFcXIy8vDytoxDRDuTl5aG4uBhCCK2jUAQI9PjI6/FgeX4OABCbcP+q/BwfET0e3yFEm5CXEKXpPftcaZYCaXx8HAMDA1BVVesoROQHiqJgYGAAExMTWkehMBfo8VHXB7/A2vIidDodihrM932P4yOix2PZJ9oErU8mWh+fwpuUEomJiaivr9c6ChH5QUNDAxISEiCl1DoKhbmdjk+mR27B9dYbWFtZ/tL3Oi79HD/4f/8xAMB85kUkZ+X6/fhE4Y7vEKJNyI43IM6gw7Ln7kIwQ11u/OTP/uXG9+/cGgQAfPaDV9F9+cLG13/7L15BSvbdy6Jnx0fxrT/5uxvfm7k9DADo+uAd/PfffXLj68/+6/8bhfW//vQ6zqBDdrzB7/9NRACwuroKt9sNVVURFcVTAlE4iIqKgs1mgxACx48fR0xMjNaRKEztdHy0ODuF1//0D/HjP/s/UFDbhJScfKyvLGPsWg8mb1wDAFQoh/CVf/OfvnRsjo+IHo8jO6JNMOh0sGbF4crYEnwAVhbmcbP9y6vCzowNY2ZseOPPns9tE+NZW33gcxamJrAw9etLLVcW5jf+vw6ANSsOBu55TgHS1taG1dVV2O12raMQkR/Z7XZ89NFHaG9vh81m0zoOhamdjo9Scwtx5O/+77jV0YLJmwMY7m6FZ20NCWkZqDt8CuYzL8B06ivQ6++/GJnjI6LNYdkn2iRLVhx+ObYEAKhQDuLPnONben56QcmWn+P71XGJAsHn80FKiZqaGqSlpWkdh4j8KC0tDTU1NRBCwGq1QsdSRAGyk/FRYloGnvyn/27Lx+T4iGhzeM8+0SalxhhgzozFbg2XdADMmbFIjeElahQYt27dwujoKLfbIwpTqqpidHQUQ0NDWkehMMbxEVHwYtkn2oLjhYlIjNIF/ISmA5AYpcPxwsQAH4kimZQS6enpqKys1DoKEQVAZWUl0tPTuQ0fBRzHR0TBiWWfaAtiDXqcLU2GL8DH8QE4W5qMWAPfohQYCwsL6OjogKIovLyXKEzpdDooioKOjg4sLi5qHYfCGMdHRMGJ7xSiLSpPiUFzUWA/UT5VlIjyFK6eTIHjcrmg0+lgsVi0jkJEAXTvPe5yubQNQmGP4yOi4MOyT7QN9uz4jROav+ZE773OqaJE2LLj/fSqRF/m9XrhcDhgNBqRkJCgdRwiCqCEhAQYjUZIKeH1erWOQ2GO4yOi4MKyT7RN9ux4vFyZ4pd71O7dg/ZyZQpPZBRwfX19mJ6e5sJ8RBFCVVVMT0+jv79f6ygUATg+IgoeLPtEO1CeEoPfb0iHKTMWwNY/xb73eFNmLP6gIZ2XptGukFKioKAAhYWFWkchol1QUFCA/Px8LtRHu4bjI6LgEKV1AKJQF2fQ40xJMg7kJaBlYhmuiWUse+4uUaMH8PmLJj//5ziDDtasOFiy4rh9DO2aqakpXL16Fc8884zWUYhol+h0OqiqijfffBNTU1NIT0/XOhJFAI6PiLTHsk/kJ6kxBhwpSMSh/ASML3kwuriO0cV1LKx7se71IUqvQ2KUHnkJUchLiEJ2vAEGroJOu0xKibi4OBiNRq2jENEuMhqNOH/+PBwOB06ePKl1HIogHB8RaYdln8jPDDrdxgmLKJisr6/D5XLBYrEgOjpa6zhEtIuio6NhsVjgcrlw9OhRREXxHEW7i+Mjot3He/aJiCJER0cHlpaWuDAfUYRSFAWLi4vo7OzUOgoREe0Cln0iogghpURlZSUyMzO1jkJEGsjMzERFRQUX6iMiihAs+0REEWBkZAS3bt3irD5RhFNVFbdu3cLIyIjWUYiIKMBY9omIIoAQAikpKaipqdE6ChFpqKamBikpKZzdJyKKACz7RERhbmlpCW1tbbDb7dDr+WufKJLp9XrY7Xa0tbVheXlZ6zhERBRAHPUREYU5t9sNr9cLm82mdRQiCgI2mw1erxctLS1aRyEiogBi2SciCmM+nw9CCDQ0NCApKUnrOEQUBJKSklBfXw8pJXw+n9ZxiIgoQFj2iYjC2MDAAO7cucOF+YjoPqqqYnJyEgMDA1pHISKiAGHZJyIKY0II5OTkoKSkROsoRBRESkpKkJ2dDSml1lGIiChAWPaJiMLU7Owsenp6oCgKdDqd1nGIKIjodDqoqoru7m7Mzs5qHYeIiAKAZZ+IKEw5HA5ER0fDZDJpHYWIgpDJZEJ0dDQcDofWUYiIKABY9omIwpDH44HT6YTJZEJsbKzWcYgoCMXGxsJkMsHpdMLj8Wgdh4iI/Ixln4goDHV3d2N+fh6qqmodhYiCmKqqmJ+fR3d3t9ZRiIjIz1j2iYjCkBACpaWlyMnJ0ToKEQWxnJwclJaWcqE+IqIwxLJPRBRmbt++jevXr3NWn4g2RVEUDA4OYnx8XOsoRETkRyz7RERhRkqJpKQk1NXVaR2FiEJAfX09EhMTIYTQOgoREfkRyz4RURhZWVmB2+2GzWaDwWDQOg4RhQCDwQCbzQa3243V1VWt4xARkZ+w7BMRhZG2tjasra3BbrdrHYWIQojdbsfa2hpaW1u1jkJERH7Csk9EFCZ8Ph+EEKitrUVKSorWcYgohKSmpqK2thZSSvh8Pq3jEBGRH7DsExGFiZs3b+L27dtcmI+ItkVRFIyNjeHmzZtaRyEiIj9g2SciChNCCGRmZqK8vFzrKEQUgioqKpCRkcFt+IiIwgTLPhFRGJifn0dnZycURYFOp9M6DhGFIJ1OB0VR0NHRgYWFBa3jEBHRDrHsExGFAZfLBb1eD7PZrHUUIgphFosFer0eTqdT6yhERLRDLPtERCHO6/VCSommpibEx8drHYeIQlh8fDyMRiMcDge8Xq/WcYiIaAdY9omIQtzVq1cxOzvLhfmIyC9UVcXMzAyuXr2qdRQiItoBln0iohAnhEBhYSHy8/O1jkJEYaCgoACFhYVcqI+IKMSx7BMRhbA7d+6gv7+fs/pE5FeKoqCvrw937tzROgoREW0Tyz4RUQiTUiI+Ph6NjY1aRyGiMNLY2Ij4+HjO7hMRhTCWfSKiELW2tgaXywWr1YqoqCit4xBRGImOjobFYkFLSwvW1ta0jkNERNvAsk9EFKLa29uxvLwMu92udRQiCkOKomBpaQkdHR1aRyEiom1g2SciClFSSlRVVSEjI0PrKEQUhjIyMlBVVQUhhNZRiIhoG1j2iYhC0NDQEIaHh7kwHxEFlKIoGB4extDQkNZRiIhoi1j2iYhCkJQSqampqKqq0joKEYWx6upqpKamcqE+IqIQxLJPRBRiFhcX0d7eDkVRoNfz1zgRBY5er4fdbkd7ezuWlpa0jkNERFvAUSIRUYhpaWmBz+eD1WrVOgoRRQCbzQav14uWlhatoxAR0Raw7BMRhRCfzwcpJRoaGpCYmKh1HCKKAImJiWhsbISUEj6fT+s4RES0SSz7REQhpL+/H1NTU1yYj4h2laIouHPnDq5du6Z1FCIi2iSWfSKiECKlRG5uLoqKirSOQkQRpLi4GLm5udyGj4gohLDsExGFiOnpafT29kJVVeh0Oq3jEFEE0el0UBQFvb29mJmZ0ToOERFtAss+EVGIcDgciImJQVNTk9ZRiCgCmUwmxMTEwOFwaB2FiIg24f/f3r1G2XWW9wH/nznj0UijS2RJ9ViWLSm4lSwjxrY0gQU1Tg02C0xSqBdZTTGs0mXcxiS0lCyg7aoJrJUCDrQmYQViJzZJswBjoLWxkxrZGEPwBd1lk/EN62JJlpiRbV1mNCPPOacfZAmNrtbMmcvZ/v2+nbPfvd9nvjxn/2fv/W5hH6ABDA4OZu3ateno6EhLS8t4lwO8BrW0tKSjoyNr1qxJpVIZ73IAOAVhH6ABdHV1pbe318J8wLhavnx5ent709XVNd6lAHAKwj5AA1i1alUWLlyY2bNnj3cpwGvYnDlzsmDBAgv1ATQAYR9ggtu5c2e2bNmS5cuXj3cpAOns7MyWLVuyc+fO8S4FgJMQ9gEmuJUrV2batGlZtGjReJcCkEWLFmXq1KlZtWrVeJcCwEkI+wAT2MDAQDZs2JBLLrkk5XJ5vMsBSLlczrJly7Jhw4YMDAyMdzkAnICwdyh9PAAAEaRJREFUDzCBrV+/PoODg1m2bNl4lwJw2CWXXJKXX345GzZsGO9SADgBYR9ggqrValm1alUuuOCCTJs2bbzLAThs+vTpWbx4cVauXJlarTbe5QBwHMI+wAS1efPmdHd3W5gPmJA6OzvT3d2dLVu2jHcpAByHsA8wQa1atSqzZ8/OggULxrsUgGMsWLAgs2bN8ho+gAlK2AeYgPbu3Zuurq4sX748pVJpvMsBOEapVEpnZ2e6urqyb9++8S4HgKMI+wAT0Jo1a1Iul9PR0THepQCcUEdHR8rlctasWTPepQBwFGEfYIKpVqtZvXp1li5dmtbW1vEuB+CEWltbs3Tp0qxevTrVanW8ywHgCMI+wATz5JNPZu/evens7BzvUgBOqbOzM3v27MlTTz013qUAcARhH2CCWbVqVc4999y0t7ePdykAp9Te3p558+ZZqA9gghH2ASaQnp6ePPvss163BzSUzs7OPPvss9m1a9d4lwLAK5rHuwCA14JKrZbu/ZXs6BvMjr7B7BusplKtpdxUytTmprRPaU77lOasXbU6U6ZMyZIlS8a7ZIBXbcmSJbn33nuzcuXKXPGOd7yqfjdncjllbxsBGDXCPsAo2n2gknU9/Vnb05/+Si3JwVuqjlzGqinJukMXw2ZemPY3z0tvtZQZY1wrwHA1NzdnybLfyLoXX07Xhl0ZeKXJnazftZZLuXh2ay6a3ZoZLeUxrhig+IR9gFHQX6nmgW29Wb9rIKUktSO2Hb1e9ZDPLa3Z2dKar/78xXTMmpTLz2nLpLInroCJ61C/e2zmhanNqB4O+snJ+11/pZZHdu7Pwzv363cAo0DYB6izjXsO5O7Ne9M3eDDi104x/miHxm/YNZBf7D6Qq+ZPy8LpLXWtEaAeju53pabTC+v6HcDo8e9TgDpa3b0/t/9iT/oGa6cd8o9WS9I7WMvtv9iT1d3761EeQN3odwATm7APUCeru/dnxdbeJKd/Nf9EDh1nxdZeJ8DAhKHfAUx8buMHqIONew7kG/+wPk8/8kC2da3Ptq4N6d74VKqVSq64/lO5/NqPH7NPtVrNc4+tylMP/TC/WPmT/HLj0xno3ZvWqdMzd9HSXPJb/zoXvfPqlF5ZrXrF1t6cOansFldgXA2n353Iw9++NXd9/pNJkuXveX+uvuGmJPodQD0I+wAj1F+p5u7Ne/PoHbflp9+8+VXv98LWTfnah65KkkyeMTPzLujI5Om/lhe2bc4zjz6YZx59MBvu/T95/xdvS/MZLSkluWfz3nx4yUyLWAHjYrj97nhe2Lop/+/Ln0mpVEqtNvT+AP0OYOSEfYARemBbb/oGaznr/MW59AMfydzFSzN38Rvyo1tvytp7vn3C/UqlUl7XeWku/eBH8k/f9JtpKv/q1VPPrv5p/vqj/yZP/OQHefC2P83brvvDw8+0/nBbb9553rQx+MsAhhpuvztatVrNHZ/+g6RUysXv/p2s+f7tQ7brdwAjJ+wDjMBLA5Ws3zWQJOl87weGbCs1lU6676xzF+bav/jecbf9+rK35LIPfTQr/vzzWXP37XnbdX+Y5OAJ8PpdA3lz+xTvpQbG1Ej63dEe+sbN2bT2kfz2p76Q3hd6jjtGvwMYGfdFAYzA+l39Ob1T3Fdv7qKlSZLdO7cP+b6UZF1P/yjNCnB89ep33ZueyQ/+/H9k4bI3503v+9BJx+p3AMMn7AMMU6VWy9qe/rqtRH20ni3PJkmmzT5ryPe1JGt7+lOpjdbMAEPVq99VK5XcccPvJynl6htuOrwA6YnodwDDJ+wDDFP3/kr6K6NzAnpgf18e+tZfJkle/7Z3H7O9v1JL9/7KqMwNcLR69bsf/81X8tzjq3PlR/5LZp278FXto98BDI+wDzBMO/oGR+3Yd37+E3lx2+ZMn9Oe3/x3/2nM5wc4Uj36zY5nunLf127M/I7OvPl3rxvz+QFea4R9gGHa0Tc4Kk30/lu+lDXfvz3Nk1rzu1/4y7T92pnHjGmKk19g7Iy031UGB3PHDb+fUlNTrv70n6ap6dUfTb8DGB5hH2CY9g1WU63zMX/yt1/NfV/9fJpbJuWaL349Cy5643HHVZP0DtZ7doDjG2m/e+Cv/le2P7Ehb//3n8icBeef1r76HcDwePUewDBVqvV9Xv+hb92Sv/ufN6R8Rkve/ye3ZtFb3nbS8YN1nh/gREba7/7xgXuSJE/8+N48+dP7hmx7cftzSZIn/2FFbv7wv0ySXHfLnUPG6HcAp0/YBxim8mm+V/pkHr79r/L9G//rK0H/tiy+9MpT7tNcx/kBTqZe/W7TukdPuG1vzy+zt+eXx92m3wGcPmEfYJimNjelKRnxrfyPfufruesLnzoc9C9466mDflOStmZPYgFjY6T97qPf+tEJt933tRtz/81/kuXveX+uvuGmY7brdwDDo3MCDFP7lOYRB/2ffe9/587PfeK0gn5y8IS7fYr/1wJjox79brj0O4Dh0TkBhunok89tXetz5+c+efjzC1s3JUl+9t2/yRM/XnH4+2u+9PVMn9Oe7U8+lv/7xx9PrVbLmefMz+P335XH77/ruHO97zNfOeX8AKNlpP2u3vMDcGo6J8AwzZlcTmu5lP7KwYWjBnr35bnHVx8zbvfO7dm9c/vhz5WXDyRJ+vfuSa12cN/uTU+ne9PTJ5zr6LDfWi5lzuTyiP8GgFdjpP1uJPQ7gOEp1Q6daQJw2h7c3ptHdu7PWDbSUpI3nTU5l81tG8NZKYLnn38+N998c6677rqcffbZ410ODUa/A2gsntkHGIGLZreO6YlvktRemRdgLOl3AI1F2AcYgRkt5XTMmpSxeilUKUnHrEmZ0eKWVmBs6XcAjUXYBxihy89pS1tzadRPgEtJ2ppLufwct7MC40O/A2gcwj7ACE0qN+Wq+dNG/fbWWpKr5k/LpLLWDYwP/Q6gceigAHWwcHpLrpg3ulegrpzXloXTW0Z1DoBT0e8AGoOwD1Any+ZMPnwCXK9bXA8d58p5bblkzuQ6HRVgZPQ7gImvebwLACiSZXMm58xJ5dyzeW96B2sjutX10DOrV82f5goXMOHodwATmyv7AHW2cHpLrl0yM2+YNSnJ6V/1OjT+DbMm5cNLZjrxBSYs/Q5g4irVarWxfmUqwGvG7gOVrOvpz9qe/vRXDrbbpiTVI8Yc+bm1XMrFs1tz0exWr5tixCq1Wrr3V7KjbzA7+gaza19fNj+3NfPPnZdZU6ekfUpz2qc0Z87kcsqlsXqhGkWl3wFMLMI+wBg4OnT1DlYzWK2luamUtuYmoYu6OnHoquXgtdRamlISuhgV+h3AxCDsA0BB9FeqeWBbb9bvGngl0r96h8Z3zJqUy89p88ozAGhwwj4AFMDGPQdy9+a96bNQGgAQYR8AGt7q7v1ZsbX3tK/mn8ih41wxry3LvAINABqSe/QAoIEdCvpJfYL+kcdZsbU3q7v31+moAMBYEvYBoEFt3HPgcNAfLSu29mbjngOjOgcAUH9u4weABtRfqeaWf3wxm595Ok898kC2da3Ptq4N6d74VKqVSq64/lO5/NqPH3ffJ396Xx6//+48/+Tj2dP9fPp2v5TyGWdk1rwFWfSWt+efX/N7aZs5K8mvnuH/8JKZFu0DgAbSPN4FAACn74FtvekbrOXhO27LQ9+8+bT2Xfd33826v/9OZp27MGe97oK0zZyVvpdeyHM/X5sf3fblrLrzG7n2L76Xs163OLUkvYO1/HBbb9553rTR+WMAgLoT9gGgwbw0UMn6XQNJkvbzF+fSD3wkcxcvzdzFb8iPbr0pa+/59kn3v/SD1+ddH/ujTJt91pDvB/r25buf+Y95bMVd+e5nP5br//rvkxx8hn/9roG8uX1KZrSUR+VvAgDqS9gHgAazflf/4RXzO9/7gSHbSk2lU+4/d9HS434/acrUvOtjn81jK+7Kc4+tSv++vWmdevBqfinJup7+XDa3bYTVAwBjwcN3ANBAKrVa1vb0123l/aM1lQ9euS81NaXc/KtrArUka3v6U7HUDwA0BGEfABpI9/5K+iujE7gHDwzkB1/54yTJ+W+8LGe0Th6yvb9SS/f+yqjMDQDUl9v4AaCB7OgbrNuxtnWtz0PfuiW1Wi29L+7Ktp+vS+9LuzLvwotz9ae/fML526c4fQCAic6vNQA0kB19g2lKUq3DsV7asS1rvn/7kO/Of+Nlee9/+2Jm/JOzjxnflPr+swEAGD3CPgA0kH2D1boE/SS58F+8K59b051qpZLdO7fnmZ89mPu+dmNu+p235n2f/UqWvv23h4yvJukdrNfsAMBo8sw+ADSQSrX+z+s3lcuZOffcdL7nmvyHW+9OUsp3/uij2duz85ixg6MwPwBQf8I+ADSQ8qt4td5IzJx7Xn59+VtyoK83Tz/y4DHbm0d5fgCgPoR9AGggU5ubRv3Hu2XylCRJ74s9Q75vStLW7NQBABqBX2wAaCDtU5rr9sz+8QweGMjmdY8mSWaf97oh26qvzA8ATHzCPgA0kJGG7X0vdOeRO25L/769x2zb/cvn8+3/fn32dO/IzLnn5fw3XVb3+QGAsVGq1WpW2gGABlGp1fJnj72Q/srBn+9tXetz5+c+eXj7C1s3pfelXZlx1txMn/Or1+dd86WvZ/qc9ry4fUtufPeylM9oydmLXp+ZZ5+bpJaXdmzP9ic2pPLygUyf055/+2ffzNn/7PVD5m4tl/IHS89MueS5fQCY6Px7HgAaSLlUysWzW/PIzv2pJRno3ZfnHl99zLjdO7dn987thz9XXj6QJGmbOTvv+s+fzaY1D2fHM13p3vhUXh7oz+SpM3Le0mVZ/NZ35Df+1QfTOnXakOOVklw8u1XQB4AG4co+ADSY3Qcq+erPXxzzeX/vwpmZ0VIe83kBgNPnmX0AaDAzWsrpmDUpY3WNvZSkY9YkQR8AGoiwDwAN6PJz2tLWXBr1wF9K0tZcyuXntI3yTABAPQn7ANCAJpWbctX8aRntZ/FqSa6aPy2Tyk4ZAKCR+OUGgAa1cHpLrpg3ulfcr5zXloXTW0Z1DgCg/oR9AGhgy+ZMPhz463VL/6HjXDmvLZfMmVynowIAY8lq/ABQABv3HMg9m/emd7A2olv7Dz2jf9X8aa7oA0ADE/YBoCD6K9U8sK0363cNpJScVug/NL5j1qRcfk6bZ/QBoMEJ+wBQMLsPVLKupz9re/rTXzn4M9+UpHrEmCM/t5ZLuXh2ay6a3er1egBQEMI+ABRUpVZL9/5KdvQNZkffYHoHqxms1tLcVEpbc1PapzSnfUpz5kwup1wa7Zf4AQBjSdgHAACAgvFAHgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwQj7AAAAUDDCPgAAABSMsA8AAAAFI+wDAABAwfx/B/W5VoBRw9UAAAAASUVORK5CYII=\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#Grid Preferences\n",
+        "preferences_grid = Preferences(\n",
+        "    custom_hardware_settings=CustomHardwareSettings(\n",
+        "        basis_gates=[\"cx\", \"u\"],\n",
+        "        connectivity_map=grid_connectivity,\n",
+        "    ),\n",
+        "    random_seed=-1,\n",
+        ")\n",
+        "\n",
+        "\n",
+        "#Star Preferences\n",
+        "preferences_star = Preferences(\n",
+        "    custom_hardware_settings=CustomHardwareSettings(basis_gates=[\"cx\", \"u\"],\n",
+        "                                                    connectivity_map=star_connectivity,),\n",
+        "    random_seed=-1,\n",
+        ")"
+      ],
+      "metadata": {
+        "id": "1ogjh7qTGJd3"
+      },
+      "execution_count": 16,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "id": "_3KIstIjC_Ms"
+      },
+      "outputs": [],
+      "source": [
+        "# define synthesis engine constraints\n",
+        "constraints = Constraints(optimization_parameter=\"cx\", max_width=max_width)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "id": "wviSbVIqsavi"
+      },
+      "outputs": [],
+      "source": [
+        "# define models with different preferences\n",
+        "model = set_constraints(model, constraints)\n",
+        "model_grid = set_preferences(model, preferences_grid)\n",
+        "model_star = set_preferences(model, preferences_star)\n",
+        "\n",
+        "\n",
+        "# write models to files\n",
+        "write_qmod(model_grid, \"hardware_aware_mcx_grid\")\n",
+        "write_qmod(model_star, \"hardware_aware_mcx_star\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "hWP-uuNmsf5g",
+        "outputId": "762decbc-3005-4419-bb7e-6e14571db2a3"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Opening: https://platform.classiq.io/circuit/4e728c67-0064-4699-87cd-e689b15937e7?version=0.42.0\n"
+          ]
+        }
+      ],
+      "source": [
+        "qprog_grid= synthesize(model_grid)\n",
+        "show(qprog_grid)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "7-1tx3a3squr",
+        "outputId": "65034a5d-dd40-42e4-b045-88e2a9401c37"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Synthesized MCX cx-count for grid connectivity is 117\n",
+            "Opening: https://platform.classiq.io/circuit/4e728c67-0064-4699-87cd-e689b15937e7?version=0.42.0\n"
+          ]
+        }
+      ],
+      "source": [
+        "circuit_grid = QuantumProgram.from_qprog(qprog_grid)\n",
+        "\n",
+        "print(f\"Synthesized MCX cx-count for grid connectivity is {circuit_grid.transpiled_circuit.count_ops['cx']}\")\n",
+        "circuit_grid.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "cYcpNdbos3is",
+        "outputId": "fd1c4e8b-623a-425f-bebe-a39d7f051f7f"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Opening: https://platform.classiq.io/circuit/b94a1120-5b81-4a27-a949-b90e018518e0?version=0.42.0\n"
+          ]
+        }
+      ],
+      "source": [
+        "qprog_star = synthesize(model_star)\n",
+        "show(qprog_star)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "FySbcicutSXk",
+        "outputId": "c1d536d1-67e4-4f99-95d1-60884614ed2d"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Synthesized MCX cx-count for star connectivity is 114\n",
+            "Opening: https://platform.classiq.io/circuit/b94a1120-5b81-4a27-a949-b90e018518e0?version=0.42.0\n"
+          ]
+        }
+      ],
+      "source": [
+        "circuit_star = QuantumProgram.from_qprog(qprog_star)\n",
+        "\n",
+        "print(f\"Synthesized MCX cx-count for star connectivity is {circuit_star.transpiled_circuit.count_ops['cx']}\")\n",
+        "circuit_star.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "4p-TBa9ztebZ",
+        "outputId": "39293b2b-7081-4267-f3b5-005f37ee830b"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Synthesized Depth for grid connectivity is 82\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(f\"Synthesized Depth for grid connectivity is {circuit_grid.transpiled_circuit.depth}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "EVxTVGqf1HIS",
+        "outputId": "53561623-3c04-4931-d8f3-b6d82c680be5"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Synthesized Depth for star connectivity is 191\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(f\"Synthesized Depth for star connectivity is {circuit_star.transpiled_circuit.depth}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Conclusion:** Given the connectivity of the hardware and its preferences the engince optimizes the constraints of the model. In this case the constraits were `max_width` which is the maximum number of qubits it can use and the number of `cx gates`. Our main aim is to minimize the number of cx gates.\n",
+        "\n",
+        "With `Star Connectivity` the minimum number of cx gates required after transpiling the circuit is just 114 and depth of the circuit turned out to be 191.\n",
+        "\n",
+        "Whereas with `Grid Connectivity`  the minimum number of cx gates required after transpiling the circuit is 117 and depth of the circuit is 82.\n",
+        "\n",
+        "Looking at the both the cases we can come to a conclusion that star connectivity is more favourable to synthesize and execute a `mcx circuit`.\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "b043xgbpHGEO"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "0oDCHQ3Pczgt"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.8.5"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.qmod b/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.qmod
new file mode 100644
index 00000000..293534ae
--- /dev/null
+++ b/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.qmod
@@ -0,0 +1,12 @@
+qfunc my_mcx(ctrl: qbit[], target: qbit) {
+  control (ctrl) {
+    X(target);
+  }
+}
+
+qfunc main(output ctrl: qbit[], output target: qbit) {
+  allocate<10>(ctrl);
+  allocate<1>(target);
+  my_mcx(ctrl, target);
+}
+
diff --git a/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.synthesis_options.json b/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.synthesis_options.json
new file mode 100644
index 00000000..1c4b772e
--- /dev/null
+++ b/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.synthesis_options.json
@@ -0,0 +1,6 @@
+{
+  "constraints": {
+    "max_width": 20,
+    "optimization_parameter": "depth"
+  }
+}
\ No newline at end of file
diff --git a/community/basic_examples/vqe/vqe.ipynb b/community/basic_examples/vqe/vqe.ipynb
new file mode 100644
index 00000000..56771c63
--- /dev/null
+++ b/community/basic_examples/vqe/vqe.ipynb
@@ -0,0 +1,309 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Variational Quantum Eigensolver (VQE) with Classiq\n",
+    "\n",
+    "The variational quantum eigensolver (VQE) is arguably the most common variational quantum algorithm. It combines quantum and classical techniques to solve optimization problems from industries such as finance, logistics, and chemistry. VQE works because of the variational principle, which defines the relationship between the lowest energy of a system and the expectation value of a given state, declaring a lower bound to the expectation value.\n",
+    "\n",
+    "We are going to create a VQE algorithm to estimate the minimum energy(eigenvalue) of the following Hamiltonian\n",
+    "$$Z+0.1X$$ \n",
+    "where $Z$ and $X$ are Pauli Operators and the ansatz we take is a single qubit $RY$ gate "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import List\n",
+    "\n",
+    "from classiq import *\n",
+    "\n",
+    "#Defining the Hamiltonian from the problem\n",
+    "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], \n",
+    "                        [            \n",
+    "            PauliTerm([Pauli.Z], 1),\n",
+    "            PauliTerm([Pauli.X], 0.1)])\n",
+    "\n",
+    "#Defining the Ansatz for the Problem\n",
+    "@qfunc\n",
+    "def main(q: Output[QBit], angles: CArray[CReal, 1]) -> None:\n",
+    "    allocate(1, q)\n",
+    "    RY(angles[0], q) \n",
+    "\n",
+    "#Defining the Variational Quantum Eigensolver primitives with proper paramters\n",
+    "@cfunc\n",
+    "def cmain() -> None:\n",
+    "    res = vqe(\n",
+    "        HAMILTONIAN, #Hamiltonian of the problem\n",
+    "        False, #Maximize Parameter\n",
+    "        [],\n",
+    "        optimizer=Optimizer.COBYLA, # Classical Optimizer\n",
+    "        max_iteration=1000,\n",
+    "        tolerance=0.001,\n",
+    "        step_size=0,\n",
+    "        skip_compute_variance=False,\n",
+    "        alpha_cvar=1.0,\n",
+    "    )\n",
+    "    save({\"result\": res})\n",
+    "\n",
+    "qmod = create_model(main, classical_execution_function=cmain)\n",
+    "qprog = synthesize(qmod)\n",
+    "write_qmod(qmod, name=\"vqe_primitives\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now model and get the results for the created vqe primitive:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Opening: https://platform.classiq.io/circuit/8758a1e5-bd68-4be4-896e-7fd4e98d9a95?version=0.42.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "show(qprog)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The list of other optimizers can be found here: [Link](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/ground-state-solving/advanced-usage/solver-customization/)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "estimation = execute(qprog)\n",
+    "# res.open_in_ide()\n",
+    "vqe_result = estimation.result()[0].value"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Minimal energy of the Hamiltonian -1.015625\n",
+      "Optimal parameters for the Ansatz {'angles_0': 3.2430102953668842}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Minimal energy of the Hamiltonian\", vqe_result.energy)\n",
+    "print(\"Optimal parameters for the Ansatz\", vqe_result.optimal_parameters)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Mathematical Background"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To find the minimal energy of the Hamiltonian \n",
+    "$H = Z + 0.1X$ \n",
+    "using the Variational Quantum Eigensolver (VQE) with an ansatz that consists of a simple \n",
+    "$RY$ \n",
+    "gate, we can follow these steps:\n",
+    "\n",
+    "__First we define the Hamiltonian__:<br>\n",
+    "The Hamiltonian is given by:\n",
+    "\n",
+    "$$\n",
+    "H = Z + 0.1X\n",
+    "$$\n",
+    "\n",
+    "where \n",
+    "$Z$ \n",
+    "and \n",
+    "$X$ \n",
+    "are the Pauli-Z and Pauli-X operators, respectively.\n",
+    "\n",
+    "__We can write the given Pauli matrices:__<br>\n",
+    "The Pauli-Z and Pauli-X matrices are:\n",
+    "\n",
+    "$$\n",
+    "Z = \\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix}, \\quad X = \\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix}\n",
+    "$$\n",
+    "\n",
+    "__Taking the Ansatz__:<br>\n",
+    "We use a single \n",
+    "$RY$ \n",
+    "gate as the ansatz. The \n",
+    "$RY(\\theta)$ \n",
+    "gate is defined as:\n",
+    "\n",
+    "$$\n",
+    "RY(\\theta) = \\begin{pmatrix} \\cos\\left(\\frac{\\theta}{2}\\right) & -\\sin\\left(\\frac{\\theta}{2}\\right) \\\\ \\sin\\left(\\frac{\\theta}{2}\\right) & \\cos\\left(\\frac{\\theta}{2}\\right) \\end{pmatrix}\n",
+    "$$\n",
+    "\n",
+    "The ansatz state can be written as:\n",
+    "\n",
+    "$$\n",
+    "|\\psi(\\theta)\\rangle = RY(\\theta)|0\\rangle\n",
+    "$$\n",
+    "\n",
+    "We now proceed to the expectation value calculation:<br>\n",
+    "The goal is to find the expectation value of the Hamiltonian \n",
+    "$H$ \n",
+    "with respect to the ansatz state \n",
+    "$|\\psi(\\theta)\\rangle$:\n",
+    "\n",
+    "$$\n",
+    "E(\\theta) = \\langle \\psi(\\theta) | H | \\psi(\\theta) \\rangle\n",
+    "$$\n",
+    "\n",
+    "This involves calculating the expectation values of \n",
+    "$Z$ \n",
+    "and \n",
+    "$X$ \n",
+    "with respect to \n",
+    "$|\\psi(\\theta)\\rangle$.\n",
+    "\n",
+    "__Calculations can be proceed__: <br>\n",
+    "The expectation value of \n",
+    "$Z$ \n",
+    "with respect to \n",
+    "$|\\psi(\\theta)\\rangle$ \n",
+    "is:\n",
+    "\n",
+    "$$\n",
+    "\\langle \\psi(\\theta) | Z | \\psi(\\theta) \\rangle = \\cos(\\theta)\n",
+    "$$\n",
+    "\n",
+    "The expectation value of \n",
+    "$X$ \n",
+    "with respect to \n",
+    "$|\\psi(\\theta)\\rangle$ \n",
+    "is:\n",
+    "\n",
+    "$$\n",
+    "\\langle \\psi(\\theta) | X | \\psi(\\theta) \\rangle = \\sin(\\theta)\n",
+    "$$\n",
+    "\n",
+    "Therefore, the total expectation value is:\n",
+    "\n",
+    "$$\n",
+    "E(\\theta) = \\cos(\\theta) + 0.1\\sin(\\theta)\n",
+    "$$\n",
+    "\n",
+    "__Minimizing the Energy__:<br>\n",
+    "To find the minimal energy, we need to minimize \n",
+    "$E(\\theta)$ \n",
+    "with respect to \n",
+    "$\\theta$. \n",
+    "This can be done by solving the equation:\n",
+    "\n",
+    "$$\n",
+    "\\frac{dE(\\theta)}{d\\theta} = -\\sin(\\theta) + 0.1\\cos(\\theta) = 0\n",
+    "$$\n",
+    "\n",
+    "Solving this gives:\n",
+    "\n",
+    "$$\n",
+    "\\tan(\\theta) = 0.1\n",
+    "$$\n",
+    "\n",
+    "$$\n",
+    "\\theta = \\tan^{-1}(0.1)\n",
+    "$$\n",
+    "\n",
+    "__Minimal Energy__:<br>\n",
+    "Substitute \n",
+    "$\\theta$ \n",
+    "back into the expression for \n",
+    "$E(\\theta)$:\n",
+    "\n",
+    "$$\n",
+    "E_{\\text{min}} = \\cos(\\tan^{-1}(0.1)) + 0.1\\sin(\\tan^{-1}(0.1))\n",
+    "$$\n",
+    "\n",
+    "Using the identities:\n",
+    "\n",
+    "$$\n",
+    "\\cos(\\tan^{-1}(x)) = \\frac{1}{\\sqrt{1+x^2}}, \\quad \\sin(\\tan^{-1}(x)) = \\frac{x}{\\sqrt{1+x^2}}\n",
+    "$$\n",
+    "\n",
+    "For \n",
+    "$x = 0.1$:\n",
+    "\n",
+    "$$\n",
+    "E_{\\text{min}} = \\frac{1}{\\sqrt{1+0.01}} + 0.1 \\cdot \\frac{0.1}{\\sqrt{1+0.01}} = \\frac{1}{\\sqrt{1.01}} + \\frac{0.01}{\\sqrt{1.01}} = \\frac{1.01}{\\sqrt{1.01}} = \\sqrt{1.01}\n",
+    "$$\n",
+    "\n",
+    "Thus, the minimal energy is:\n",
+    "\n",
+    "$$\n",
+    "E_{\\text{min}} = \\sqrt{1.01}\n",
+    "$$\n",
+    "\n",
+    "However, considering that the eigenvalues of \n",
+    "$Z$ \n",
+    "are \n",
+    "$\\pm 1$, \n",
+    "the minimal energy will actually be:\n",
+    "\n",
+    "$$\n",
+    "E_{\\text{min}} = -\\sqrt{1.01}\n",
+    "$$\n",
+    "\n",
+    "Thus, the minimal energy is:\n",
+    "\n",
+    "$$\n",
+    "E_{\\text{min}} = -\\sqrt{1.01} \\approx -1.004987562112089\n",
+    "$$\n",
+    "\n",
+    "__It is very similar to the result which we observed based on the VQE primitive in the Classiq simulator.__\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/community/basic_examples/vqe/vqe_primitives.qmod b/community/basic_examples/vqe/vqe_primitives.qmod
new file mode 100644
index 00000000..9a094c96
--- /dev/null
+++ b/community/basic_examples/vqe/vqe_primitives.qmod
@@ -0,0 +1,20 @@
+HAMILTONIAN: PauliTerm[] = [
+  PauliTerm {
+    pauli=[Pauli::Z],
+    coefficient=1
+  },
+  PauliTerm {
+    pauli=[Pauli::X],
+    coefficient=0.1
+  }
+];
+
+qfunc main<angles: real[1]>(output q: qbit) {
+  allocate<1>(q);
+  RY<angles[0]>(q);
+}
+
+cscope ```
+res = vqe(HAMILTONIAN, False, [], optimizer=Optimizer.COBYLA, max_iteration=1000, tolerance=0.001, step_size=0, skip_compute_variance=False, alpha_cvar=1.0)
+save({'result': res})
+```
\ No newline at end of file
diff --git a/community/basic_examples/vqe/vqe_primitives.synthesis_options.json b/community/basic_examples/vqe/vqe_primitives.synthesis_options.json
new file mode 100644
index 00000000..9e26dfee
--- /dev/null
+++ b/community/basic_examples/vqe/vqe_primitives.synthesis_options.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 00000000..aafa6dbd
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,19 @@
+[tool.pytest.ini_options]
+python_files = "test_*.py"
+
+# treat all warnings as errors
+filterwarnings = "error"
+
+[tool.isort]
+profile = "black"
+combine_as_imports = true
+
+known_classiq = "classiq"
+sections = [
+    "FUTURE",
+    "STDLIB",
+    "THIRDPARTY",
+    "FIRSTPARTY",
+    "CLASSIQ",
+    "LOCALFOLDER",
+]
diff --git a/requirements_tests.txt b/requirements_tests.txt
new file mode 100644
index 00000000..6cce43af
--- /dev/null
+++ b/requirements_tests.txt
@@ -0,0 +1,3 @@
+pytest
+
+testbook
diff --git a/tests/test_dummy.py b/tests/test_dummy.py
new file mode 100644
index 00000000..4adc209f
--- /dev/null
+++ b/tests/test_dummy.py
@@ -0,0 +1,2 @@
+def test_dummy() -> None:
+    assert 1 + 1 == 2
diff --git a/tests/test_links.py b/tests/test_links.py
new file mode 100644
index 00000000..1751d45d
--- /dev/null
+++ b/tests/test_links.py
@@ -0,0 +1,44 @@
+import re
+from collections.abc import Iterable
+
+import httpx
+import nbformat
+from utils_for_tests import iterate_notebooks
+
+# the regex below is taken from this stackoverflow:
+#   https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url
+#   I only removed the brackets in the regex
+URL_REGEX = r"https?:\/\/[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b[-a-zA-Z0-9()@:%_\+.~#?&//=]*"
+# urls come in `[title](url)`
+URL_IN_MARKDOWN_REGEX = re.compile(r"(?<=\]\()%s(?=\s*\))" % URL_REGEX)
+
+
+def test_links() -> None:
+    for notebook_path in iterate_notebooks():
+        for cell_index, url in iterate_links_from_notebook(notebook_path):
+            assert _test_single_url(
+                url
+            ), f'Broken link found! in file "{notebook_path}", cell number {cell_index} (counting only markdown cells), broken url: "{url}"'
+
+
+def iterate_links_from_notebook(filename: str) -> Iterable[tuple[int, str]]:
+    with open(filename) as f:
+        notebook_data = nbformat.read(f, nbformat.NO_CONVERT)  # type: ignore[no-untyped-call]
+
+    markdown_cells = [c for c in notebook_data["cells"] if c["cell_type"] == "markdown"]
+    for cell_index, cell in enumerate(markdown_cells):
+        found_urls = re.findall(URL_IN_MARKDOWN_REGEX, cell["source"])
+        for url in found_urls:
+            yield cell_index, url
+
+
+def _test_single_url(url: str) -> bool:
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
+    }
+
+    try:
+        response = httpx.head(url, headers=headers, follow_redirects=True)
+        return response.is_success
+    except httpx.HTTPError:
+        return False
diff --git a/tests/utils_for_tests.py b/tests/utils_for_tests.py
new file mode 100644
index 00000000..f2f80fb5
--- /dev/null
+++ b/tests/utils_for_tests.py
@@ -0,0 +1,24 @@
+import os
+from collections.abc import Iterable
+from pathlib import Path
+
+ROOT_DIRECTORY = Path(__file__).parent
+
+
+def iterate_notebooks() -> Iterable[str]:
+    if os.environ.get("SHOULD_TEST_ALL_FILES", "") == "true":
+        notebooks_to_test = _get_all_notebooks()
+    else:
+        if os.environ.get("HAS_ANY_IPYNB_CHANGED", "") == "true":
+            notebooks_to_test = os.environ.get("LIST_OF_IPYNB_CHANGED", "").split()
+        else:
+            notebooks_to_test = []
+
+    return notebooks_to_test
+
+
+def _get_all_notebooks(directory: Path = ROOT_DIRECTORY) -> Iterable[str]:
+    for root, _, files in os.walk(directory):
+        for file in files:
+            if file.endswith(".ipynb"):
+                yield os.path.join(root, file)
diff --git a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.qmod b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.qmod
index b3cb692e..c90b9c72 100644
--- a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.qmod
+++ b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.qmod
@@ -1,7 +1,8 @@
 qfunc main(output z: qnum) {
   x: qnum;
   y: qnum;
-  allocate<2>(x);
-  allocate<1>(y);
+  prepare_int<2>(x);
+  prepare_int<1>(y);
   z = (((2 * x) + y) + max(3 * y, 2)) > 4;
 }
+
diff --git a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.synthesis_options.json b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.synthesis_options.json
index d9217744..b90a8354 100644
--- a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.synthesis_options.json
+++ b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.synthesis_options.json
@@ -6,4 +6,4 @@
   "preferences": {
     "random_seed": 424788457
   }
-}
+}
\ No newline at end of file
diff --git a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.qmod b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.qmod
index b3cb692e..c90b9c72 100644
--- a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.qmod
+++ b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.qmod
@@ -1,7 +1,8 @@
 qfunc main(output z: qnum) {
   x: qnum;
   y: qnum;
-  allocate<2>(x);
-  allocate<1>(y);
+  prepare_int<2>(x);
+  prepare_int<1>(y);
   z = (((2 * x) + y) + max(3 * y, 2)) > 4;
 }
+
diff --git a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.synthesis_options.json b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.synthesis_options.json
index d0862a5e..63d39997 100644
--- a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.synthesis_options.json
+++ b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.synthesis_options.json
@@ -6,4 +6,4 @@
   "preferences": {
     "random_seed": 424788457
   }
-}
+}
\ No newline at end of file
diff --git a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_expressions.ipynb b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_expressions.ipynb
index bbe1e0ea..d6c1eccf 100644
--- a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_expressions.ipynb
+++ b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_expressions.ipynb
@@ -26,7 +26,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 10,
    "id": "674d1423-6ac5-4f6b-8328-7073a72c0a28",
    "metadata": {
     "execution": {
@@ -38,7 +38,7 @@
    },
    "outputs": [],
    "source": [
-    "from classiq import Output, QBit, QNum, allocate, create_model, qfunc, synthesize\n",
+    "from classiq import Output, QBit, QNum, prepare_int, create_model, qfunc, synthesize, execute\n",
     "from classiq.qmod.symbolic import max\n",
     "\n",
     "\n",
@@ -46,8 +46,8 @@
     "def main(z: Output[QNum]):\n",
     "    x = QNum(\"x\")\n",
     "    y = QNum(\"y\")\n",
-    "    allocate(2, x)\n",
-    "    allocate(1, y)\n",
+    "    prepare_int(2, x)\n",
+    "    prepare_int(1, y)\n",
     "    z |= (2 * x + y + max(3 * y, 2)) > 4\n",
     "\n",
     "\n",
@@ -64,9 +64,17 @@
     "2. Optimizing over depth and constraining the maximal width to 12 qubits."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "5474a102",
+   "metadata": {},
+   "source": [
+    "Optimizing over depth and constraining the maximal width to 9 qubits"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 11,
    "id": "ba0e933a-9878-4ce2-b5af-2e4c65638f60",
    "metadata": {
     "execution": {
@@ -81,7 +89,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Opening: https://platform.classiq.io/circuit/f35614a2-c0d0-4c1c-adfa-c56059093fc4?version=0.41.0.dev39%2B79c8fd0855\n"
+      "Opening: https://platform.classiq.io/circuit/737ef5dd-eba0-49f5-9a61-25814ca2f523?version=0.42.0\n",
+      "The result of the arithmetic calculation:  [{'z': 1.0}: 2048]\n"
      ]
     }
    ],
@@ -104,6 +113,12 @@
     "qprog = synthesize(qmod)\n",
     "show(qprog)\n",
     "\n",
+    "job = execute(qprog)\n",
+    "result = job.result()\n",
+    "parsed_counts = result[0].value.parsed_counts\n",
+    "print(\"The result of the arithmetic calculation: \",parsed_counts)\n",
+    "\n",
+    "\n",
     "write_qmod(qmod, \"arithmetic_demo_9_qubits\")"
    ]
   },
@@ -112,12 +127,12 @@
    "id": "2397fbdd-3a20-4e8f-bc53-6ff7b588b7ee",
    "metadata": {},
    "source": [
-    "Change the quantum model constraint to treat the second scenario:"
+    "Change the quantum model constraint to treat the second scenario for optimizing over depth and constraining the maximal width to 12 qubits: "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 12,
    "id": "77d24a43-5114-46a0-8309-33af8fdc75fb",
    "metadata": {
     "execution": {
@@ -132,7 +147,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Opening: https://platform.classiq.io/circuit/7082e6e8-1fd9-4e77-a316-44a104146982?version=0.41.0.dev39%2B79c8fd0855\n"
+      "Opening: https://platform.classiq.io/circuit/00705127-ab37-41d3-b8a6-71939bf39146?version=0.42.0\n",
+      "The result of the arithmetic calculation:  [{'z': 1.0}: 2048]\n"
      ]
     }
    ],
@@ -143,8 +159,50 @@
     "qprog = synthesize(qmod)\n",
     "show(qprog)\n",
     "\n",
+    "job = execute(qprog)\n",
+    "result = job.result()\n",
+    "parsed_counts = result[0].value.parsed_counts\n",
+    "print(\"The result of the arithmetic calculation: \",parsed_counts)\n",
+    "\n",
+    "\n",
     "write_qmod(qmod, \"arithmetic_demo_12_qubits\")"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ad94a769",
+   "metadata": {},
+   "source": [
+    " ### Mathematical Background\n",
+    " \n",
+    " The given mathematical expression:\n",
+    " $$z = (2 \\cdot x + y + \\max(3 \\cdot y, 2)) > 4$$ \n",
+    " is solved by the automatic arithmetic operation management, optimizing over depth and constraining the maximal width to 9 and 12 qubits, which outputs the value for z.\n",
+    " \n",
+    " __The `parsed_counts` result:__\n",
+    " - Optimizing over depth and constraining the maximal width to 9 qubits: `[{'z': 1.0}: 2048]`\n",
+    " - Optimizing over depth and constraining the maximal width to 12 qubits: `[{'z': 1.0}: 2048]`\n",
+    "\n",
+    "Both the result are same which verifies the arithmetic expression to be True.\n",
+    " \n",
+    " __The expected result__:<br>\n",
+    " \n",
+    " Allocated values:\n",
+    " \n",
+    " $$x = 2\\\\ y = 1$$\n",
+    " \n",
+    " \n",
+    " Expression Calculation:\n",
+    "\n",
+    " $$2 \\cdot x + y = 2 \\cdot 2 + 1 = 4 + 1 = 5 \\\\ 3 \\cdot y = 3 \\cdot 1 = 3 \\\\ \\max(3 \\cdot y, 2) = \\max(3, 2) = 3$$\n",
+    " \n",
+    " Therefore:\n",
+    " \n",
+    " $$2 \\cdot x + y + \\max(3 \\cdot y, 2) = 5 + 3 = 8$$\n",
+    " \n",
+    " As $$8 > 4 \\implies \\text{True}$$\n",
+    " Z is assigned the value True : $Z \\implies 1$"
+   ]
   }
  ],
  "metadata": {
@@ -163,7 +221,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.11.1"
   }
  },
  "nbformat": 4,