diff --git a/docs/source/quantum_five_qubit.ipynb b/docs/source/quantum_five_qubit.ipynb
index c558824..37145e7 100644
--- a/docs/source/quantum_five_qubit.ipynb
+++ b/docs/source/quantum_five_qubit.ipynb
@@ -4,14 +4,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Decoding The 5-qubit Code"
+    "# Decoding The 5-Qubit Code"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In this experiment, we decode the Surface code which protects a single qubit from all types of errors by using ``mdopt``. Here, we demonstrate direct-error input decoding, which means that the decoder takes a Pauli error as input and outputs the most likely logical operator. This pipeline is sufficient for threshold computation. In reality, the decoder could be shown a syndrome measurement, from which possible error patterns would be sampled. After each run, the algorithm yields a probability distribution over the Pauli operators (I, X, Z, Y) to apply to the encoded logical qubit."
+    "In this experiment, we decode the 5-qubit code using ``mdopt``. Here, we demonstrate direct-error input decoding, which means that the decoder takes a Pauli error as input and outputs the most likely logical operator. This pipeline is sufficient for threshold computation. After each run, the algorithm yields a probability distribution over the Pauli operators (I, X, Z, Y) to apply to the encoded logical qubit."
    ]
   },
   {
@@ -21,7 +21,6 @@
    "outputs": [],
    "source": [
     "import numpy as np\n",
-    "import qecstruct as qc\n",
     "import qecsim.paulitools as pt\n",
     "import matplotlib.pyplot as plt\n",
     "from matplotlib import colormaps\n",
@@ -49,7 +48,7 @@
     "    apply_bitflip_bias,\n",
     "    apply_depolarising_bias,\n",
     "    pauli_to_mps,\n",
-    "    decode_css,\n",
+    "    decode_custom,\n",
     "    css_code_stabilisers,\n",
     "    multiply_pauli_strings,\n",
     "    generate_pauli_error_string,\n",
@@ -57,6 +56,13 @@
     "from examples.decoding.visualisation import plot_parity_check_mpo"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let us first define the code. Here, we won't be using `qecstruct` as in the other examples because it lacks the machinery we need. Instead, we define the code as a list of stabilizers and logical operators."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 2,
@@ -64,16 +70,26 @@
    "outputs": [],
    "source": [
     "stabilizer_generators = [\n",
-    "    \"XZZXI\",  # 1001011000 -> 0, 3, 5, 6 -> 2, 5, 7, 8\n",
-    "    \"IXZZX\",  # 0010010110 -> 2, 5, 7, 8 -> 4, 7, 9, 10\n",
-    "    \"XIXZZ\",  # 1000100101 -> 0, 4, 7, 9 -> 2, 6, 9, 11\n",
-    "    \"ZXIXZ\",  # 0110001001 -> 1, 2, 6, 9 -> 3, 4, 8, 11\n",
+    "    \"XZZXI\",\n",
+    "    \"IXZZX\",\n",
+    "    \"XIXZZ\",\n",
+    "    \"ZXIXZ\",\n",
     "]\n",
-    "\n",
-    "logical_operators = [\n",
-    "    \"XXXXX\",  # X -> 0101010101 -> 1, 3, 5, 7, 9\n",
-    "    \"ZZZZZ\",  # Z -> 1010101010 -> 0, 2, 4, 6, 8\n",
-    "]"
+    "x_logical_operators = [\n",
+    "    \"XXXXX\",\n",
+    "]\n",
+    "z_logical_operators = [\n",
+    "    \"ZZZZZ\",\n",
+    "]\n",
+    "logical_operators = x_logical_operators + z_logical_operators\n",
+    "num_qubits = len(stabilizer_generators[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let us first take a look at the code in terms of the MPS sites where the checks will be applied."
    ]
   },
   {
@@ -82,18 +98,23 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "[[2, 5, 7, 8], [4, 7, 9, 10], [2, 6, 9, 11], [3, 4, 8, 11]]"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Stabilizer generators:\n",
+      "[2, 5, 7, 8]\n",
+      "[4, 7, 9, 10]\n",
+      "[2, 6, 9, 11]\n",
+      "[3, 4, 8, 11]\n"
+     ]
     }
    ],
    "source": [
-    "custom_code_checks(stabilizer_generators, logical_operators)"
+    "checks = custom_code_checks(stabilizer_generators, logical_operators)\n",
+    "\n",
+    "print(\"Stabilizer generators:\")\n",
+    "for check in checks:\n",
+    "    print(check)"
    ]
   },
   {
@@ -102,58 +123,90 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "[[[2], [5, 7], [3, 4, 6], [8]],\n",
-       " [[4], [7, 9], [5, 6, 8], [10]],\n",
-       " [[2], [6, 9], [3, 4, 5, 7, 8, 10], [11]],\n",
-       " [[3], [4, 8], [5, 6, 7, 9, 10], [11]]]"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MPS constraint sites:\n",
+      "[[2], [5, 7], [3, 4, 6], [8]]\n",
+      "[[4], [7, 9], [5, 6, 8], [10]]\n",
+      "[[2], [6, 9], [3, 4, 5, 7, 8, 10], [11]]\n",
+      "[[3], [4, 8], [5, 6, 7, 9, 10], [11]]\n"
+     ]
     }
    ],
    "source": [
-    "custom_code_constraint_sites(stabilizer_generators, logical_operators)"
+    "constraint_sites = custom_code_constraint_sites(\n",
+    "    stabilizer_generators, logical_operators\n",
+    ")\n",
+    "\n",
+    "print(\"MPS constraint sites:\")\n",
+    "for string in constraint_sites:\n",
+    "    print(string)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Logical operators:\n",
+      "[[6, 9, 11, 12], [8, 11, 13, 14], [6, 10, 13, 15], [7, 8, 12, 15]]\n",
+      "[[6, 8, 10, 12, 14], [7, 9, 11, 13, 15]]\n"
+     ]
+    }
+   ],
    "source": [
-    "custom_code_logicals(logical_operators)"
+    "logicals = custom_code_logicals(stabilizer_generators, logical_operators)\n",
+    "\n",
+    "print(\"Logical operators:\")\n",
+    "print(logicals[0])\n",
+    "print(logicals[1])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MPS logical constraint sites:\n",
+      "[[[0], [2, 4, 6, 8], [1, 3, 5, 7, 9], [10]]]\n",
+      "[[[1], [3, 5, 7, 9], [2, 4, 6, 8, 10], [11]]]\n"
+     ]
+    }
+   ],
    "source": [
-    "custom_code_logicals_sites(stabilizer_generators, logical_operators)"
+    "logicals_sites = custom_code_logicals_sites(x_logical_operators, z_logical_operators)\n",
+    "\n",
+    "print(\"MPS logical constraint sites:\")\n",
+    "print(logicals_sites[0])\n",
+    "print(logicals_sites[1])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This quantum error correcting code is defined on $2 * L * (L-1) + 1 = 13$ (where $L$ is the lattice size and an extra qubit handles the boundary conditions) physical qubits and has $2$ logical operators because it encodes $1$ logical qubit. This means we will need $13*2 + 2 = 28$ sites in our MPS."
+    "This quantum error correcting code is defined on $5$ physical qubits and has $2$ logical operators because it encodes $1$ logical qubit. This means we will need $5*2 + 2 = 12$ sites in our MPS."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
-    "num_logicals = code.num_x_logicals() + code.num_z_logicals()\n",
-    "num_sites = 2 * len(code) + num_logicals\n",
+    "num_logicals = len(x_logical_operators) + len(z_logical_operators)\n",
+    "num_sites = 2 * len(stabilizer_generators[0]) + num_logicals\n",
     "\n",
-    "assert num_sites == 28\n",
+    "assert num_sites == 12\n",
     "assert num_logicals == 2"
    ]
   },
@@ -166,7 +219,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -180,34 +233,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Here, we get the sites where the checks will be applied. We will need to construct MPOs using this data."
+    "The lists of sites in the previous cells identify the sites where we will apply the XOR constraints. However, the MPOs will also consist of other tensors, such as SWAPs (a.k.a. the tensors' legs crossings) and boundary XOR constraints. In what follows, we define the list of these auxiliary tensors."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "checks_x, checks_z = css_code_checks(code)\n",
-    "print(\"X checks:\")\n",
-    "for check in checks_x:\n",
-    "    print(check)\n",
-    "print(\"Z checks:\")\n",
-    "for check in checks_z:\n",
-    "    print(check)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "These lists display the sites where we will apply the XOR constraints. However, the MPOs will also consist of other tensors, such as SWAPs (a.k.a. the tensors' legs crossings) and boundary XOR constraints. In what follows, we define the list of these auxiliary tensors and the corresponding sites where they reside."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -215,73 +246,6 @@
     "logicals_tensors = [COPY_LEFT, XOR_BULK, SWAP, XOR_RIGHT]"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "constraints_sites = css_code_constraint_sites(code)\n",
-    "print(\"Full X-check lists of sites:\")\n",
-    "for string in constraints_sites[0]:\n",
-    "    print(string)\n",
-    "print(\"Full Z-check lists of sites:\")\n",
-    "for string in constraints_sites[1]:\n",
-    "    print(string)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let us now again take a look at the logical operators."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(code.x_logicals_binary())\n",
-    "print(code.z_logicals_binary())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We need to again translate them to our MPO language by changing the indices since we add the logical sites at the beginning of the MPS."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(css_code_logicals(code)[0])\n",
-    "print(css_code_logicals(code)[1])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now goes the same operation of adding sites where auxiliary tensors should be placed."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "logicals_sites = css_code_logicals_sites(code)\n",
-    "print(css_code_logicals_sites(code)[0])\n",
-    "print(css_code_logicals_sites(code)[1])"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -291,7 +255,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -308,9 +272,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 1/1 [00:00<00:00, 56.69it/s]\n",
+      "100%|██████████| 1/1 [00:00<00:00, 26.40it/s]\n",
+      "100%|██████████| 4/4 [00:01<00:00,  3.25it/s]\n"
+     ]
+    }
+   ],
    "source": [
     "entropies, bond_dims = [], []\n",
     "\n",
@@ -328,19 +302,18 @@
     "    entropies += entrps\n",
     "    bond_dims += bnd_dims\n",
     "\n",
-    "# for the X and the Z checks\n",
-    "for i in [0, 1]:\n",
-    "    error_mps, entrps, bnd_dims = apply_constraints(\n",
-    "        error_mps,\n",
-    "        constraints_sites[i],\n",
-    "        constraints_tensors,\n",
-    "        renormalise=renormalise,\n",
-    "        result_to_explicit=result_to_explicit,\n",
-    "        strategy=\"Optimised\",\n",
-    "        return_entropies_and_bond_dims=True,\n",
-    "    )\n",
-    "    entropies += entrps\n",
-    "    bond_dims += bnd_dims"
+    "# for the stabilizer checks\n",
+    "error_mps, entrps, bnd_dims = apply_constraints(\n",
+    "    error_mps,\n",
+    "    constraint_sites,\n",
+    "    constraints_tensors,\n",
+    "    renormalise=renormalise,\n",
+    "    result_to_explicit=result_to_explicit,\n",
+    "    strategy=\"Optimised\",\n",
+    "    return_entropies_and_bond_dims=True,\n",
+    ")\n",
+    "entropies += entrps\n",
+    "bond_dims += bnd_dims"
    ]
   },
   {
@@ -352,9 +325,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.figure(figsize=(4, 3))\n",
     "plt.imshow(entropies, cmap=\"viridis\")\n",
@@ -366,9 +350,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.figure(figsize=(4, 3))\n",
     "plt.imshow(bond_dims, cmap=\"viridis\", norm=LogNorm(vmin=2**1, vmax=2**10))\n",
@@ -391,20 +386,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2, 4, 8, 16, 32, 64, 32, 16, 8, 4, 2]\n"
+     ]
+    }
+   ],
    "source": [
     "print(error_mps.bond_dimensions)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 8/8 [00:01<00:00,  5.15it/s]\n"
+     ]
+    }
+   ],
    "source": [
-    "bond_dims = [np.inf, 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2]\n",
+    "bond_dims = [np.inf, 128, 64, 32, 16, 8, 4, 2]\n",
     "inv_bond_dims = [1 / bd for bd in bond_dims]\n",
     "errors = []\n",
     "for chi in tqdm(bond_dims):\n",
@@ -419,9 +430,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.figure(figsize=(4, 3))\n",
     "plt.plot(inv_bond_dims, errors, marker=\"o\", label=\"Truncation Error\")\n",
@@ -442,9 +464,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.86597587 0.05488773 0.05488773 0.02424866]\n"
+     ]
+    }
+   ],
    "source": [
     "sites_to_marginalise = list(range(num_logicals, len(error_state) + num_logicals))\n",
     "logical = marginalise(mps=error_mps, sites_to_marginalise=sites_to_marginalise).dense(\n",
@@ -462,9 +492,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 88%|████████▊ | 7/8 [00:04<00:00,  2.06it/s]/Users/aleksandrberezutskii/mdopt/mdopt/mps/canonical.py:274: RuntimeWarning: invalid value encountered in divide\n",
+      "  dense /= np.linalg.norm(dense, ord=norm)\n",
+      "100%|██████████| 8/8 [00:04<00:00,  1.66it/s]\n"
+     ]
+    }
+   ],
    "source": [
     "strategy = \"Optimised\"\n",
     "logical_values = [[] for _ in range(4)]\n",
@@ -492,17 +532,16 @@
     "            chi_max=max_bond_dim,\n",
     "            silent=True,\n",
     "        )\n",
-    "    for i in [0, 1]:\n",
-    "        error_mps = apply_constraints(\n",
-    "            error_mps,\n",
-    "            constraints_sites[i],\n",
-    "            constraints_tensors,\n",
-    "            renormalise=renormalise,\n",
-    "            result_to_explicit=result_to_explicit,\n",
-    "            strategy=strategy,\n",
-    "            chi_max=max_bond_dim,\n",
-    "            silent=True,\n",
-    "        )\n",
+    "    error_mps = apply_constraints(\n",
+    "        error_mps,\n",
+    "        constraint_sites,\n",
+    "        constraints_tensors,\n",
+    "        renormalise=renormalise,\n",
+    "        result_to_explicit=result_to_explicit,\n",
+    "        strategy=strategy,\n",
+    "        chi_max=max_bond_dim,\n",
+    "        silent=True,\n",
+    "    )\n",
     "\n",
     "    sites_to_marginalise = list(range(num_logicals, len(error_state) + num_logicals))\n",
     "    logical = marginalise(\n",
@@ -515,9 +554,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.figure(figsize=(4, 3))\n",
     "plt.plot(inv_bond_dims, logical_values[0], marker=\"o\", label=f\"Pr(I)\")\n",
@@ -531,9 +581,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAAE8CAYAAACcroXvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACLi0lEQVR4nOydd3yN1xvAv/fe7G1lEUlsMRIrsUOFGC2qRu2gaFW1DWq2VlujZlF7l59ZqoqKkFKbxN4rZhIEQci65/fHlcuVm8jNkOF8fd6P3PM+55znue97z/Oe8z7nHIUQQiCRSCQSSS5HmdMKSCQSiUSSHqTDkkgkEkmeQDosiUQikeQJpMOSSCQSSZ5AOiyJRCKR5Amkw5JIJBJJnkA6LIlEIpHkCaTDkkgkEkmeQDosiUQikeQJ3muH1aBBAxo0aJBt5bu5uREQEJBt5adGdtslMZyAgADc3Nyypeycus+ymtGjR6NQKHKs/ps3b2JmZsa+fftyTIdksuN+yYl2ISQkBIVCQUhIiDbt008/pX379hkqL1c4rKVLl6JQKDh69GhOq/JO+eOPP1AoFCxcuDBVmaCgIBQKBb/++us71CzvktzoJR9KpRInJyc+/PBDDh48mNPqvZUGDRro6G5jY0PZsmXp2rUrQUFBOa1evmbs2LH4+PhQp06dFOe2bNlC06ZNKVSoEGZmZpQpU4ZBgwbx4MGDDNd3584dRo8ezfHjxzOhdd5jyJAhbNiwgRMnThic1ygb9Mkz7NixI0frb9GiBba2tqxatYrPPvtMr8yqVatQqVR8+umn71i7vM2cOXOwsrJCrVZz8+ZNFixYQP369Tl8+DBeXl45rV6aFCtWjPHjxwPw7NkzLl++zB9//MHvv/9O+/bt+f333zE2NtbKX7hwAaUyVzx7ZoqRI0cydOjQHKn73r17LFu2jGXLlqU4N2jQIKZMmYKnpydDhgyhYMGChIaGMmvWLFavXk1wcDBly5Y1uM47d+4wZswY3NzcUtyTCxYsQK1WZ9QcveR0e5dMlSpVqF69OlOmTGH58uUG5X2vHZaJiUmO1m9qakrbtm1ZsmQJd+7cwdnZWef8ixcv2LhxI40bN8be3j6HtMybtG3blsKFC2s/t27dmooVK7Ju3bpc77BsbW3p0qWLTtqECRMYMGAAv/32G25ubkycOFF7ztTU9F2rmC0YGRlhZJQzTdLvv/+OkZERH330kU76//73P6ZMmUKHDh1YuXIlKpVKey4gIICGDRvSrl07QkNDs1T31x9Isoqcbu9ep3379owaNYrffvsNKyurdOfLU49lYWFhNGvWDBsbG6ysrGjUqJHeYZ6TJ0/i6+uLubk5xYoV48cff2TJkiUoFAquX7+uldM3pvvixQtGjx5NmTJlMDMzw8nJiTZt2nDlyhWtzOTJk6lduzaFChXC3NycatWqsX79+gzZ1KVLF9RqNatXr05x7u+//+bx48d07twZgCVLlvDBBx9gb2+PqakpHh4ezJkz5611JA+5vm476B9fBjh06BBNmzbF1tYWCwsLfH19U4zrP3nyhG+++QY3NzdMTU2xt7encePGhIaGpqrH+vXrUSgU/PvvvynOzZs3D4VCwenTpwGIiIigR48eFCtWDFNTU5ycnGjVqlUKG9KLo6MjQIpGJSoqil69euHg4ICZmRmenp4pnrKvX7+OQqFg8uTJzJ8/n5IlS2JqakqNGjU4cuRIiro2bdpExYoVMTMzo2LFimzcuDFDOr+OSqXi119/xcPDg1mzZvH48WPtuTffYSVf7//++48BAwZQpEgR7Ozs6Nu3L/Hx8Tx69Ihu3bpRoEABChQowHfffcebmzao1WqmT59OhQoVMDMzw8HBgb59+/Lw4UMdOTc3Nz788EP+++8/vL29MTMzo0SJEimenBMSEhgzZgylS5fGzMyMQoUKUbduXZ1hTn3vsBITExk3bpz2O3dzc2P48OHExcVlSI/U2LRpEz4+PikazzFjxlCgQAHmz5+v46wAvL29GTJkCKdOndL5/Tdo0ICKFSty7Ngxateujbm5Oe7u7sydO1crExISQo0aNQDo0aOHdhh46dKlQMp3WK/fg7Nnz6ZEiRJYWFjQpEkTbt68iRCCcePGUaxYMczNzWnVqhXR0dE6+upr72bOnEmFChWwsLCgQIECVK9enVWrVunI3L59m549e+Lg4ICpqSkVKlRg8eLFKb7DW7du0bp1aywtLbG3t+fbb79NcZ2Sady4Mc+ePTN8mFvkApYsWSIAceTIkVRlTp8+LSwtLYWTk5MYN26cmDBhgnB3dxempqbi4MGDWrlbt26JggULikKFCokxY8aIyZMni3LlyglPT08BiGvXrmllfX19ha+vr/ZzYmKiaNSokQDEp59+KmbNmiXGjx8vPvjgA7Fp0yatXLFixUS/fv3ErFmzxNSpU4W3t7cAxJYtW3R0dnV1Fd27d0/T9qSkJFGsWDFRrVq1FOfatGkjLCwsxJMnT4QQQtSoUUMEBASIadOmiZkzZ4omTZoIQMyaNUsn35t2JX+/r9suhBC7d+8WgNi9e7c2LTg4WJiYmIhatWqJKVOmiGnTponKlSsLExMTcejQIa1cp06dhImJiQgMDBQLFy4UEydOFB999JH4/fffU7U1NjZWWFlZiX79+qU417BhQ1GhQgXt59q1awtbW1sxcuRIsXDhQvHzzz+Lhg0bin///TfV8oUQYtSoUQIQFy5cEPfu3RORkZEiNDRUfPzxx8LMzEycPn1aR5/y5csLY2Nj8e2334pff/1V1KtXTwBi+vTpWrlr164JQFSpUkWUKlVKTJw4UUyaNEkULlxYFCtWTMTHx2tl//nnH6FUKkXFihXF1KlTxYgRI4Stra2oUKGCcHV1TVN3ITTX7vXv4U3GjRuX4l578z5Lvt5eXl6iadOmYvbs2aJr164CEN99952oW7eu6NSpk/jtt9/Ehx9+KACxbNkynXo+++wzYWRkJHr37i3mzp0rhgwZIiwtLUWNGjV07HV1dRVly5YVDg4OYvjw4WLWrFmiatWqQqFQ6HzXw4cPFwqFQvTu3VssWLBATJkyRXTs2FFMmDAhxbV7ne7duwtAtG3bVsyePVt069ZNAKJ169Y6cunVQx/x8fHC3NxcBAYG6qRfvHhRACIgICDVvMn3RufOnbVpvr6+wtnZWdjb24v+/fuLX3/9VdStW1cAYtGiRUIIISIiIsTYsWMFIPr06SNWrFghVqxYIa5cuaK1+/X7JbkeLy8v4eHhIaZOnSpGjhwpTExMRM2aNcXw4cNF7dq1xa+//ioGDBggFAqF6NGjh46ub7YL8+fP13638+bNEzNmzBC9evUSAwYM0MpERESIYsWKCRcXFzF27FgxZ84c0bJlSwGIadOmaeViY2NFmTJlhJmZmfjuu+/E9OnTRbVq1UTlypVTtDFCCJGQkCDMzc3FwIED07w2b5JnHFbr1q2FiYmJ9oIKIcSdO3eEtbW1qF+/vjbtq6++EgqFQoSFhWnTHjx4IAoWLPhWh7V48WIBiKlTp6aoX61Wa/+OjY3VORcfHy8qVqwoPvjgA5309DgsIYQYPHiwtpFN5vHjx8LMzEx07Ngx1XqFEMLf31+UKFFCJy2jDkutVovSpUsLf3//FPa6u7uLxo0ba9NsbW3Fl19++Vbb3qRjx47C3t5eJCYmatPu3r0rlEqlGDt2rBBCiIcPHwpA/PLLLwaXn9zovXnY2dmJ7du368hOnz5dADpONj4+XtSqVUtYWVmJmJgYIcSrxqJQoUIiOjpaK/vnn38KQPz111/aNC8vL+Hk5CQePXqkTduxY4cAssRhbdy4UQBixowZ2rTUHNab17FWrVpCoVCIzz//XJuWmJgoihUrpnO/7N27VwBi5cqVOnVv3749Rbqrq6sAxJ49e7RpUVFRwtTUVKcx8vT0FC1atEjT9jcd1vHjxwUgPvvsMx25QYMGCUDs2rXLYD30cfnyZQGImTNn6qRv2rQpRcOsDxsbG1G1alXtZ19fXwGIKVOmaNPi4uKEl5eXsLe31zr8I0eOCEAsWbIkRZmpOawiRYro3FvDhg0TgPD09BQJCQna9I4dOwoTExPx4sULHb1ev86tWrVK814TQohevXoJJycncf/+fZ30Tz/9VNja2mrbpOTf0tq1a7Uyz549E6VKldLrsIQQokyZMqJZs2Zp1v8meWJIMCkpiR07dtC6dWtKlCihTXdycqJTp078999/xMTEALB9+3Zq1aql856iYMGC2mG1tNiwYQOFCxfmq6++SnHu9aEKc3Nz7d8PHz7k8ePH1KtXL83hsLRIfl/xeld8w4YNvHjxQkfv1+t9/Pgx9+/fx9fXl6tXr+oMEWWU48ePc+nSJTp16sSDBw+4f/8+9+/f59mzZzRq1Ig9e/ZoXwTb2dlx6NAh7ty5Y1AdHTp0ICoqSmcYcv369ajVajp06KC108TEhJCQkBRDUOllw4YNBAUFsWPHDpYsWUKZMmX45JNP2L9/v1Zm69atODo60rFjR22asbExAwYM4OnTpymGLjt06ECBAgW0n+vVqwfA1atXAbh79y7Hjx+ne/fu2NraauUaN26Mh4dHhux4k+QhqydPnrxVtlevXjr3rY+PD0IIevXqpU1TqVRUr15dawPAunXrsLW1pXHjxtp74P79+1SrVg0rKyt2796tU4+Hh4f2uwAoUqQIZcuW1SnTzs6OM2fOcOnSpXTbunXrVgACAwN10gcOHAhohswN1UMfyZF+r19bePUdW1tbp5nf2tpa2/4kY2RkRN++fbWfTUxM6Nu3L1FRURw7dizN8tKiXbt2OveWj48PoGlDXh/u9vHxIT4+ntu3b6dalp2dHbdu3dI7rA0ghGDDhg189NFHCCF07gV/f38eP36sbfO2bt2Kk5MTbdu21ea3sLCgT58+qdZfoEAB7t+/nz7DX5InHNa9e/eIjY3VG4lTvnx5bSQYQHh4OKVKlUohpy/tTa5cuULZsmXf+vJ0y5Yt1KxZEzMzMwoWLEiRIkWYM2dOhp1G5cqVqVixIv/73/+0aatWraJw4cL4+/tr0/bt24efnx+WlpbY2dlRpEgRhg8fDpAlDiu5MenevTtFihTRORYuXEhcXJy2nkmTJnH69GlcXFzw9vZm9OjRb20YAO27sTVr1mjT1qxZg5eXF2XKlAE0QQQTJ05k27ZtODg4UL9+fSZNmkRERES6balfvz5+fn40btyYgIAAgoODsba21nkYCQ8Pp3Tp0iki7MqXL689/zrFixfX+ZzcwCU71WT50qVLp9AnI1Fk+nj69Cnw9kYUUuqb3NC5uLikSH/9weDSpUs8fvwYe3v7FPfB06dPiYqKSrMe0Hw3r5c5duxYHj16RJkyZahUqRKDBw/m5MmTaeofHh6OUqlM8dt1dHTEzs7urddHnx5pId54j5f8Hb/t4eDJkycproezszOWlpY6acn3d0bfw4Jh1xRI0/YhQ4ZgZWWFt7c3pUuX5ssvv9R5V33v3j0ePXrE/PnzU9wHPXr0ANDeC8nt7pvvINO674UQBs+7e6+jBDPC3r17admyJfXr1+e3337DyckJY2NjlixZkuJlpSF06dKFoUOHcvToUYoVK8bu3bvp27ev1nleuXKFRo0aUa5cOaZOnYqLiwsmJiZs3bqVadOmpRkCm9pNkZSUpPM5uYxffvkl1Ui65Cf89u3bU69ePTZu3MiOHTv45ZdfmDhxIn/88QfNmjVLVRdTU1Nat27Nxo0b+e2334iMjGTfvn38/PPPOnLffPMNH330EZs2beKff/7h+++/Z/z48ezatYsqVaqkWn5qWFlZ4ePjw59//smzZ89SNCbp4c2X7sm82dBlJ8lBKel5AEtNX33pr9ugVquxt7dn5cqVevMXKVIkXfW8Xmb9+vW5cuUKf/75Jzt27GDhwoVMmzaNuXPnpjqlI5n0NmoZvT6FChUCUjbuyQ8uaTnW8PBwYmJisqwH/TYMuaaQtu3ly5fnwoULbNmyhe3bt7NhwwZ+++03fvjhB8aMGaNtD7p06UL37t31llG5cmUDLXjFw4cP9T7cpUWecFhFihTBwsKCCxcupDh3/vx5lEql9gnD1dWVy5cvp5DTl/YmJUuW5NChQyQkJKQaVrphwwbMzMz4559/dMKJlyxZkl5z9NKxY0eGDRvGqlWrcHV1JSkpSWc48K+//iIuLo7NmzfrPGW9OTyjj+SewKNHj3TS33xCLVmyJAA2Njb4+fm9tVwnJyf69etHv379iIqKomrVqvz0009pOizQDK0tW7aM4OBgzp07hxBCOxz4pj4DBw5k4MCBXLp0CS8vL6ZMmcLvv//+Vt30kZiYCGh6KZaWlri6unLy5EnUarVOL+v8+fOA5l4yhGR5fcNe+u5dQ0lKSmLVqlVYWFhQt27dTJeXGiVLlmTnzp3UqVNHZxg6sxQsWJAePXrQo0cPnj59Sv369Rk9enSqDsvV1RW1Ws2lS5e0zgMgMjKSR48eGXx9UqN48eKYm5tz7do1nfQyZcpQpkwZNm3axIwZM/T2apOjED/88EOd9Dt37qR4MLp48SKANvovJ1f1SMbS0pIOHTrQoUMH4uPjadOmDT/99BPDhg2jSJEiWFtbk5SU9Nb2wNXVldOnT6foNaV23ycmJnLz5k1atmxpkL55YkhQpVLRpEkT/vzzT53udGRkJKtWraJu3brY2NgA4O/vz4EDB3Rmj0dHR6f6tPg6n3zyCffv32fWrFkpziU/qahUKhQKhU7v5Pr162zatCljxr2kePHi1KtXjzVr1vD777/j7u5O7dq1teeTn6Bef2J6/PhxuhxlsiPas2ePNi0pKYn58+fryFWrVo2SJUsyefJk7dDT69y7d0+b980hSHt7e5ydnVMNY30dPz8/ChYsyJo1a1izZg3e3t64u7trz8fGxvLixYsUNlhbW6erfH1ER0ezf/9+HB0dtXPamjdvTkREhM7wZGJiIjNnzsTKygpfX1+D6nBycsLLy4tly5bpfD9BQUGcPXs2Q3onk5SUxIABAzh37hwDBgzQ3u/ZQfv27UlKSmLcuHEpziUmJqZ48EkPb64IYWVlRalSpdK8ns2bNwdg+vTpOulTp04FNBPvswJjY2OqV6+ud6WdH374gYcPH/L555+nGJE4duwYEydOpGLFinzyySc65xITE5k3b572c3x8PPPmzaNIkSJUq1YNQOvMMvJ9ZgVvXhMTExM8PDwQQpCQkIBKpeKTTz5hw4YN2p796yS3B6C5Vnfu3NEJ74+NjU3RxiRz9uxZXrx4odPGpYdc1cNavHgx27dvT5H+9ddf8+OPPxIUFETdunXp168fRkZGzJs3j7i4OCZNmqSV/e677/j9999p3LgxX331FZaWlixcuJDixYsTHR2d5lNNt27dWL58OYGBgRw+fJh69erx7Nkzdu7cSb9+/WjVqhUtWrRg6tSpNG3alE6dOhEVFcXs2bMpVarUW8fk30aXLl3o06cPd+7cYcSIETrnmjRpgomJCR999BF9+/bl6dOnLFiwAHt7e+7evZtmuRUqVKBmzZoMGzaM6OhoChYsyOrVq7U9jmSUSiULFy6kWbNmVKhQgR49elC0aFFu377N7t27sbGx4a+//uLJkycUK1aMtm3b4unpiZWVFTt37uTIkSNMmTLlrXYaGxvTpk0bVq9ezbNnz5g8ebLO+YsXL9KoUSPat2+Ph4cHRkZGbNy4kcjIyHSv+LF+/XqsrKwQQnDnzh0WLVrEw4cPmTt3rvYe6NOnD/PmzSMgIIBjx47h5ubG+vXr2bdvH9OnT0/Xe6I3GT9+PC1atKBu3br07NmT6Oho7VwXfQ8B+nj8+LG2FxkbG6td6eLKlSt8+umneh1JVuLr60vfvn0ZP348x48fp0mTJhgbG3Pp0iXWrVvHjBkzdF6upwcPDw8aNGhAtWrVKFiwIEePHmX9+vX0798/1Tyenp50796d+fPn8+jRI3x9fTl8+DDLli2jdevWNGzYMLOmamnVqhUjRowgJiZG52Ggc+fOHDlyhBkzZnD27Fk6d+5MgQIFCA0NZfHixRQqVIj169enGJFxdnZm4sSJXL9+nTJlyrBmzRqOHz/O/PnztbIlS5bEzs6OuXPnYm1tjaWlJT4+PjoPb9lJkyZNcHR0pE6dOjg4OHDu3DlmzZpFixYttPf+hAkT2L17Nz4+PvTu3RsPDw+io6MJDQ1l586d2rlevXv3ZtasWXTr1o1jx47h5OTEihUrsLCw0Ft3UFAQFhYWNG7c2DClDYopzCaSw3BTO27evCmEECI0NFT4+/sLKysrYWFhIRo2bCj279+forywsDBRr149YWpqKooVKybGjx8vfv31VwGIiIgIrdybYZ5CaEK4R4wYIdzd3YWxsbFwdHQUbdu21QmnX7RokShdurQwNTUV5cqVE0uWLNE7hyS9Ye3JREdHC1NTUwGIs2fPpji/efNmUblyZWFmZibc3NzExIkTtaH4aYXrCyHElStXhJ+fnzA1NdXOVQkKCtIbchoWFibatGkjChUqJExNTYWrq6to3769CA4OFkJoQnQHDx4sPD09hbW1tbC0tBSenp7it99+S7etyXUrFArt9U3m/v374ssvvxTlypUTlpaWwtbWVvj4+OiEzKaGvrB2S0tLUatWLb35IyMjRY8ePUThwoWFiYmJqFSpUoow4+SQYn1h9oAYNWqUTtqGDRtE+fLlhampqfDw8BB//PFHijDl1EgOiU4+rKysROnSpUWXLl3Ejh079OZJLaz9zWkiyd/NvXv3dNK7d+8uLC0tU5Q7f/58Ua1aNWFubi6sra1FpUqVxHfffSfu3LmjU7e+cPU378Eff/xReHt7Czs7O2Fubi7KlSsnfvrpJ505Xfp+QwkJCWLMmDHa36OLi4sYNmyYTri2IXqkRmRkpDAyMhIrVqzQe37Tpk2icePGokCBAsLU1FSUKlVKDBw4MMV3mVxnhQoVxNGjR0WtWrWEmZmZcHV1TTFfUgjN1AgPDw9hZGSkE+KeWlj7m/dg8tSUdevW6aTruwfe/C7mzZsn6tevr/2dlyxZUgwePFg8fvw4xXfz5ZdfChcXF22b2KhRIzF//nwdufDwcNGyZUthYWEhChcuLL7++mvtVIg32xgfHx/RpUuXFN/H21AI8Q7fGOcg33zzDfPmzePp06epvqCUSCTvL7169eLixYvs3bs3U+U0aNCA+/fv6x1Gk2imz1StWpXQ0FCDl0nLE++wDOX58+c6nx88eMCKFSuoW7eudFYSiUQvo0aN4siRI7lie5H8zIQJE2jbtm2G1vTMVe+wsopatWrRoEEDypcvT2RkJIsWLSImJobvv/8+p1WTSCS5lOLFi6cI9pFkPfrWTU0v+dJhNW/enPXr1zN//nwUCgVVq1Zl0aJF1K9fP6dVk0gkEkkGeW/eYUkkEokkb5Mv32FJJBKJJP8hHZZEIpFI8gT58h1WZlGr1dy5cwdra+tcsXyKRCKRZBYhBE+ePMHZ2TnFgs95Bemw9HDnzp0Uqx9LJBJJfuDmzZsUK1Ysp9XIENJh6SF5WZKbN28atGZbQkICO3bs0C5lk9/I7/ZB/rcxv9sH+d/GjNoXExODi4tLhpYcyy1Ih6WH5GFAGxsbgx2WhYUFNjY2+faHkp/tg/xvY363D/K/jZm1Ly+/5sibA5kSiUQiee+QDksikUgkeQI5JJhFJKkFh65Fc+y+gkLXoqlVyh6VUpFC5vC1aKKevMDe2gxv94IZkpFIJJL3EemwsoDtp+8y5q+z3H38AlCx/NJRnGzNGPWRB00rOumR0ZARGYkkPyKEIDExMcUmiRkhISEBIyMjXrx4kSXl5TZSs0+lUmFkZJSn31G9DemwMsn203f54vdQ3lzfKuLxC774PZQ5XaoCZImMdFqS/Eh8fDx3794lNjY2S8oTQuDo6MjNmzfzZeOdln0WFhY4OTlhYmKSQ9plL9JhZYIktWDMX2dTOBnQ7L6nAEZvPgMoMi0z5q+zNPZwlMODknyFWq3m2rVrqFQqnJ2dMTExybSTUavVPH36FCsrqzw7QTYt9NknhCA+Pp579+5x7do1SpcunS9tlw4rExy+Fq0zfPcmAoiIiUuzjPTK3H38gsPXoqlVspDhikokuZT4+HjUajUuLi6pbqduKGq1mvj4eMzMzPJlo52afebm5hgbGxMeHq49n9/If1fzHRL15N3unfOu65NI3hX50bHkBPn9e8zf1mUz9tbv9gnmXdcnkUgkuQnpsDKBt3tBnGzNSG3EXQE42pjiaJN5GSdbTYi7RCKRvK9Ih5UJVEoFoz7yAEjhbJI/j25ZgdEtMy6TzKiPPGTAhUSSCklqwYErD/jz+G0OXn1Akjr37kt74cIFHB0defLkiUH5atasyYYNG7JJq7yBdFiZpGlFJ+Z0qYqjre5wnaOtmTYUPTMyCgVM7eAlQ9olklTYfvoudSfuouOCg3y9+jidFh6m+ZyjbD8dka31BgQEoFAoUCgUmJiYUKpUKcaOHUtiYmKa+YYNG8ZXX32lXYR2zpw52NnZcfPmTR25r776ijJlymjD/UeOHMnQoUNRq9XZY1AeQEYJZgFNKzrR2MORA5ej2LH3EE3q+aRY6SJZJq1VLF6XiYh5waRt57kb84LIGBlsIZHoI7V5kFFP4vlyVRhzlIpsfdhr2rQpS5YsIS4ujq1bt/Lll19ibGzMsGHDdOTi4+MxMTHhxo0bbNmyhZkzZ2rPff7552zcuJFevXqxY8cOAIKDg5kzZw579uzRRk82a9aMzz77jG3btlGvXr1ssyk3Ix1WFqFSKvBxL8iDcwKfVJZTUikVbw1Lf10mSS0YtO4EC/depXstN8xNVNmiu0SSWxBC8DwhfatTJKkFozafecscx7PUKVU4XcPp5sYqg+eAmZqa4ujoCMAXX3zBxo0b2bx5MxcuXODRo0fUqFGD2bNnY2pqyrVr11i7di2enp4ULVpUW4ZCoWDRokVUrFiRuXPn0qlTJ3r27ElgYCC1a9fWyqlUKpo3b86aNWukw5LkPlp5OTMj+CI3o5+z6vANetV1z2mVJJJs5XlCEh4//JMlZWnmOL6g0ugd6ZI/O9YfC5PMNYnm5uY8ePAA0PSSbGxsCAoK0p7fu3cv1atXT5HPxcWF6dOnM2DAALZu3YqVlRXjxo1LIeft7c2ECRMypWNeRr7DysUYq5T0a1AKgPl7rvAinU+eEonk3SKEYOfOnfzzzz988MEHAFhaWrJw4UIqVKhAhQoVAAgPD8fZ2VlvGT169KBixYr89ddfLFmyBFNT0xQyzs7O3Lx58719jyV7WLmcNlWL8mvwJe4+fsG6Y7foWtM1p1WSSLINc2MVZ8f6p0v28LVoApYceavc0h410jUlxNzY8CH3LVu2YGVlRUJCAmq1mk6dOjF69Gi+/PJLKlWqlGJNv+fPn6e6AsWJEycIDQ3FwsKCvXv34u3tnVJHc3PUajVxcWmvjpNfkQ4rl2NqpOJz35KM2nyGuSFX6FDdBRMj2TGW5E8UCkW6h+XqlS6Ck60ZEY9f6H2PpUATiVuvdJFsmxLSsGFD5syZg4mJCc7OzhgZvdLd0tIyhXzhwoV5+PBhivT4+Hi6detG586d8fX15fPPP+fDDz+kbNmyOnLR0dFYWlpibm6e9cbkAWTLlwfoUMOFItam3H70nI1ht3JaHYkkV5CeeZDZPX/R0tKSUqVKUbx4cR1nlRpVqlTh7NmzKdLHjh1LdHQ006ZNo3v37jRu3JgePXqkGPo7ffo0VapUyTL98xrSYeUBzIxV9K1fAoDfQq6QmPR+jl9LJG+S2vxFe2sTZneqkuvmL/r7+3PgwAGdfayOHDnCxIkTWbRoEba2tgDMmzePCxcuMG3aNJ38e/fupXHjxu9U59yEHBLMI3TyKc5vIVcIfxDLXyfv8HGVYjmtkkSSK3hzjmMRKxPKFjSigJ1tTquWgmbNmmFkZMTOnTvx9/cnLi6O7t2706NHD5o0aaKVc3JyYubMmfTq1Us7NHj79m3279/P8uXLc9CCnEU6rDyChYkRveq688s/F5i16zItPYvKpZokkpe8Pn9RrVYTExOT7XUuXbrU4HNGRkYMHz6cqVOn4u/vj6mpqd4hQoBOnTrRqVMn7edff/2VgIAAihUr9k7sy43IIcE8RLdartiaG3Pl3jO2nb6b0+pIJJIM0LdvX+rXr2/wWoL29vZ652a9T0iHlYewNjOmRx03AGbtuow6Fy/wKZFI9GNkZMSIESO0awmml4EDB+Lg4JBNWuUNpMPKY/So7Y6VqRHnI56w81xkTqsjkUgk7wzpsPIYthbGdKulmTw8c9dlhJC9LIlE8n4gHVYepFddd8yNVZy6/ZiQi/dyWh2JRCJ5J0iHlVWok1CE/0fR6AMowv8DtZ51/9RJcG0vnFqv+T+DMoWsTOlSszgAM4MvyV6WRCJ5L5Bh7VnB2c2wfQhGMXeoDhA+B2ycoelE8GipI0PMnVf5MiLzkt71S7DsQDihNx5x4MoDapcqnK0mSiQSSU4je1iZ5exmWNtN18kAxNzVpJ/dnHUyr2FvbUbHGi4A/Lrrkm6e9PTkJBKJJI8he1iZQZ2k6RGltYXc1sGvfc6EzPahUK4FKF+tKN3XtySrDt/g4NVojlyPpoZbQYN6aRKJRJKXkD2szBC+P2WPSAcBTyM0R2ZlYm7Dhl6wfyacXAtXQ3COv043TxtAMHPXZYN7aRJJvuH1UYXrqbxDziVcuHABR0dHgycO16xZkw0bNmSTVnkD2cPKDE/f8TyoMxs1x2t8DwwxVXE/3Ab1racoDeylSSR5njdGFZSAjZUTNJsIFVplW7UBAQEsW7YMAGNjY4oXL063bt0YPnx4miu3Dxs2jK+++ko7cdjNzY3w8PBU5a9fv46rqysjR47k22+/pVWr7LMptyN7WJnB6h3POvdoDZXag3t9KFIOzAsAYKJIwlnxEKU6IY3ML3tp4fvfiaoSyTshlVEFxdMIFOu6Z/uoQtOmTbl79y6XLl1i4MCBjB49ml9++SWFXHx8PAA3btxgy5YtBAQEaM8dOXKEu3fv6hznzp3D2dmZjz76iOLFNRHBzZo148mTJ2zbti1bbcrNyB5WZnCtrXk/FHMX/e+fFGDtpNmcJ7MyNs7QdnHK3lFiHOE3rrN+8S8MNFr3dp3fda9QIjEEISAhNn2y6iTY9h36fjMKBAKFpudVokH6RhWMLUBh2ILSpqamODo6AvDFF1+wceNGNm/ezIULF3j06BE1atRg9uzZmJqacu3aNdauXYunpydFixbVllGkSBFds9RqAgICsLW1ZeXKlShe6qRSqWjevDlr1qyhXr16BumZX5AOKzMoVZpghrXd0Hic1384L2/8ZhM1/2dWpukE/T86I1NcS5TF2L023EyHw3rXvUKJxBASYuFn5ywpSoHQ9LwmuKQvw/A7YJJyl2BDMDc358GDBwAEBwdjY2NDUFCQ9vzevXupXr16mmUMHTqUQ4cOcfjw4RTrDXp7ezNhwoRM6ZiXyfEhwdmzZ+Pm5oaZmRk+Pj4cPnw4Tfl169ZRrlw5zMzMqFSpElu3btU5//TpU/r370+xYsUwNzfHw8ODuXPnZp8BHi2h/XKweWOjOBtnTbpHy6yTSYOmzdtwRxQk9fVwFWBTVNMrlEgkWYoQgp07d/LPP//wwQcfAJrdiBcuXEiFChWoUKECAOHh4Tg7p+6Q//e//zF16lRWr15N6dKlU5x3dnbm5s2bKXYifl/I0R7WmjVrCAwMZO7cufj4+DB9+nT8/f25cOEC9vb2KeT3799Px44dGT9+PB9++CGrVq2idevWhIaGUrFiRQACAwPZtWsXv//+O25ubuzYsYN+/frh7OxMy5bZFNbt0RLKtSDx6h6O7/0Hr3r+GJWor9sjeilD+H7NsJyVg8Z5GCqTCmWc7JjnNIDed0cnh1ikJLVemkSSWzC20PR00kP4fljZ9u1ynden70HN2CJ99b7Gli1bsLKyIiEhAbVaTadOnRg9ejRffvkllSpVwsTEREf++fPnmJmZ6S0rNDSUXr16MWHCBPz9/fXKmJubo1ariYuLM1jX/ECO9rCmTp1K79696dGjh7YnZGFhweLFi/XKz5gxg6ZNmzJ48GDKly/PuHHjqFq1KrNmzdLK7N+/n+7du9OgQQPc3Nzo06cPnp6eb+25ZRqlCuFal9sFayFc6+p3DEoVuNeDSm01/2dUJhXqfNSTLxK+4a4omPKkz+dyHpYk96NQaIbl0nOU/EAzAqH/8UzzDsumqEYuPeUZ+P4KoGHDhhw/fpxLly7x/Plzli1bhqWlZlgx+f/XKVy4MA8fPkyRfu/ePT7++GM++eQTBg0alGp90dHRWFpaYm5ubrCu+YEc62HFx8dz7Ngxhg0bpk1TKpX4+flx4MABvXkOHDhAYGCgTpq/vz+bNm3Sfq5duzabN2+mZ8+eODs7ExISwsWLF5k2bVqqusTFxek8sSTv5pmQkEBCQlqRd7okyxqSJyspa2/BbcdG1L1THW/leex5RH3VCdqq9nL/Sii2mdQrp+17F+R3G3ObfQkJCQghUKvVGRjmUoD/BE00IArNO6uXiJdOTO0/XiOXDUNoQggsLCwoUaKENi3ZBiGE1q7X8fLy4syZMzrpCQkJtG3bFnt7e+bNm5fm93Dq1Cm8vLy0dbwpq1arEUKQkJCASqX7sJtbrnlmyDGHdf/+fZKSklJsSObg4MD58+f15omIiNArHxHxatLtzJkz6dOnD8WKFcPIyAilUsmCBQuoX79+qrqMHz+eMWPGpEjfsWMHFhaGDxO8/pL1XXLigYLTd5SAkoNqDwCOqUvTRvkfhe8f4tcly3B1KJJ2Iekgp+x7l+R3G3OLfUZGRjg6OvL06VNt6LdBFPXF+MM5mIeMQfH01S7cwsqR5w1GkVDUF7JpO/mEhAQSExP1blef2rm6devy9ddf8/DhQ61DGTRoEMePH2fTpk3cvHkzRVkFChTQDi2GhITg6+sLoHficXx8PM+fP2fPnj0kJibqnIuNTWf0ZS4m30UJzpw5k4MHD7J582ZcXV3Zs2cPX375Jc7Ozvj5+enNM2zYMJ2eW0xMDC4uLjRp0gQbG5t0152QkEBQUBCNGzfG2Ng407YYQpJaMH7KHkB3bPs2RfhPXZH6qlNYRx7Av/scVErDhz4gZ+17V+R3G3ObfS9evODmzZtYWVml+m7nrVTtAF5tUd84AE8jEJYOPClQEWtbO8wzMMyXXoyNjTEyMtLbRqR2LnnI7/Dhw9r3VIsWLQLQBmu8SXBwMA0aNOD27dscPnyYlStXAmBtba0NeU/mxYsXmJubU79+/RTfpz7HmtfIMYdVuHBhVCoVkZG684IiIyO18xrexNHRMU3558+fM3z4cDZu3EiLFi0AqFy5MsePH2fy5MmpOixTU1NMTU1TpBsbG2foR53RfJnh6JUHRMTofxG7NqkB9VWn8E/cRdiNR9QqnTKgxRBywr53TX63MbfYl5SUhEKhQKlUolRm4pW6UgklNKMoarUaYmK05WYXyatcGHLOxMSE4cOHM336dJo1awaQ7u2BZs2aRUBAAC4uLsSkYp9SqUShUOi9vrnhemeWHAu6MDExoVq1agQHB2vT1Go1wcHB1KpVS2+eWrVq6ciDZmgjWT75ndObF1GlUuX7MNCoJy9SPbdDXZ2HwgpnRTRcDU5VTiKRZD99+/alfv36Bq8laG9vz7hx47JJq7xBjg4JBgYG0r17d6pXr463tzfTp0/n2bNn9OjRA4Bu3bpRtGhRxo8fD8DXX3+Nr68vU6ZMoUWLFqxevZqjR48yf/58AGxsbPD19WXw4MGYm5vj6urKv//+y/Lly5k6dWqO2fkusLdOfTglHmM2JdWhh9E/lLm9Cej4zvSSSCS6GBkZMWLECIPzDRw4ECDfP3ynRY46rA4dOnDv3j1++OEHIiIi8PLyYvv27drAihs3buj0lmrXrs2qVasYOXIkw4cPp3Tp0mzatEk7Bwtg9erVDBs2jM6dOxMdHY2rqys//fQTn3/++Tu3713i7V4QJ1szIh6/0Lu405qkhvQw+oeCt4Lh2X2wlBs+SiSSvEWOB13079+f/v376z0XEhKSIq1du3a0a9cu1fIcHR1ZsmRJVqmXZ1ApFYz6yIMvfg9NsbgTwHlRnChrD+yfnIUTq6G2/u9cIpFIcis5vjSTJOtoWtGJOV2q4mirOzxoaqS5zEufv1wwM2yFZpFRiUQiyUPkeA9LkrU0rehEYw9HDl+LJurJC+ytzSjnZM0nv+1nxf0afG2+FNN75+HWUXCpkdPqSiQSSbqRPax8iEqpoFbJQrTyKkqtkoUoYGHCvK7VUJtYsyXxpZMKW56zSkokEomBSIeVRSSpkzgaeZQT8Sc4GnmUJD1bdCepkzgScYStV7dyJOJIhmUyQmkHa6a092RtYkMAEk+uh7inWVK2RCKRvAvkkGAWsDN8JxMOTyAyVjOpeV3wOhwsHBjqPRQ/Vz+9MkCGZDJD04pOnPJtwbX983FPjOT2/v9RtGHvTJcrkUgk7wLZw8okO8N3EhgSqONkAKJiowgMCWRn+M4sk8kKApuU42gBzSogD/Yu5OGzDKzfJpHkMlKMTIisGZnIDi5cuICjo2O6Jw7Hx8fj5ubG0aNHs1mz3I90WJkgSZ3EhMMTEHpmPomX/8YeGMvYA2MzJQMw8fDELBkeVCkV+Hf6liSUVFafZ/yKP0lKfddHiSTXszN8J/4b/On5T0+G7B3CZ0Gf0W5HO3beyJqHvNQICAhAoVCgUCgwMTGhVKlSjB07NsWis28ybNgwvvrqK6ytrVmxYgWWlpZcvnxZR+bOnTsUKFCAWbNmYWJiwqBBgxgyZEh2mpMnkA4rE4RGhaboEb3Jw7iHPIxLuf+NITICQURsBKFRoRnS801sHIoTW1yz0GaJW5v45Z8LWVKuRPKuSW1k4t6Lewz6d1CWjUykRtOmTbl79y6XLl1i4MCBjB49ml9++SWFXPJK9Ddu3GDLli0EBAQA0LVrV/z9/QkICNBZwaJ3795Uq1aNL7/8EoDOnTvz33//cebMmWy1J7cjHVYmuBd7L8/WZ127JwCfqPaw8N8L/H3y7ltySCTZjxCC2ITYdB1P4p4w/vB4vSMToHnQm3B4Ak/inqSrvPQuQvs6pqamODo64urqyhdffIGfnx+bN28mICCA1q1b89NPP+Hs7EzZsmUBWLt2LZ6enhQtWlRbxrx587h48aJ2+bilS5eyb98+lixZol2NvUCBAtSpU4fVq1cbrGN+QgZdZIIiFpnfWyrH6ivdBCztKfIsig+UYQxeb0opeyvKOlpnXR0SiYE8T3yOzyqfLCsvMjaS2qtrp0v2UKdDWBgbvv/d65ibm/PgwQNAsy2IjY2Nzt5je/fupXr16jp5ihQpwvz58+nYsSOenp58++23zJgxAxcXFx05b29v9u7dmyn98jqyh5UJqtpXxcHCAUUqW3QrUOBg7pAlMo4WjlS1r5pluqMyBi/NIrhf2OwjNj6JviuO8vh53t+VVCJ51wgh2LlzJ//88492XytLS0sWLlxIhQoVqFChAgDh4eE4OzunyN+6dWvat29P06ZN8fX1pXv37ilknJ2dCQ8Pz15Dcjmyh5UJVEoVQ72HEhgS+HKD7ldDCsnOZ6jPUIAMy4BmaGOI9xBUSt0trzNNla6wbwZecUfxtI3lxAP4ZnUYi7rXQJnBTR4lksxgbmTOoU6H0iV7LPIY/YL7vVXut0a/Uc2hWrrqNpQtW7ZgZWVFQkICarWaTp06MXr0aL788ksqVaqk3Sk4mefPn6e6UeX333/P8uXLGTlypH79zM3zxa7BmUH2sDKJn6sfUxtMxd5Cd1NEBwsHpjaYip+rX6ZkAPyK+2XJPKwUFC4NxWuhEGrmV7qIqZGS3RfuMX3nxayvSyJJBwqFAgtji3QdtZ1rp2tkorZz7XSV9+buvemhYcOGHD9+nEuXLvH8+XOWLVuGpaUlgPb/1ylcuDAPH+oPsDIyMtL5/02io6MpUuTdvobIbcgeVhbg5+pHQ5eGHL5zmKADQTSu1RhvZ2+dHlGyTGhUKPdi71HEoghV7aumKXPjyQ1mH5/N3tt7iXgWgaOl/p2YM0WVrnDjAA5X1jH+464ErjvFr7suU6GoLf4VsqE+iSSLSGuEI5lsGZl4DUtLS0qVKpVu+SpVqnD27NkM1XX69GmqVKmSobz5BdnDyiJUShXVHarjaeJJdYfqen8kKqWKGo41aF6iOTUca7xVpm/lvlS1r0pcUhwzw2Zmj+IVWoOJNTy8RpuC4QTUdgNg4NoTXI6SSzdJcjepjUzYm9sz2Xdy9oxMZAJ/f38OHDhAUpLhcyr37t1LkyZNskGrvIN0WLkYhULBoOqDAPjryl+ce3Au6ysxsYSKbTR/h61gRIvyeLsX5GlcIn1WHOXJCxmEIcnd+Ln68c8n/7DYfzET601kYeOFrG28Fr/iuctZATRr1gwjIyN27jRsftiBAwd4/Pgxbdu2zSbN8gbSYeVyKhWpRDP3ZggEU45OydBckbdStZvm/7N/Yhwfw+xOVXGyNePqvWcErj2BWq6EIcnlpBi9UGTfMGAyS5cuZdOmTQadMzIyYvjw4do5V6/j5uaGEAIvL68U56ZPn87gwYMxNzc8MCQ/IR1WHuDrql9jrDTmUMQh9t7OhnkYRatBkfKQ+AJOr6eItSlzulTDRKUk6Gwks3dffnsZEokkXfTt25f69esbtJZgpUqV+Pbbb7NZs9yPdFh5gKJWRelSvgsAU49OJVGd9lplBqNQQNWumr9DVwDg5WLHj60raurceZFd59NegkoikaQPIyMjRowYgbV1+ibpm5iYMHLkyPe+dwXSYeUZPqv8Gbamtlx5fIWNlzdmfQWVPwWlMdw9DhGnAGhfw4UuNYsjBHy9+jjXHzzL+nolEokknUiHlUewMbHhC88vAJgdNptnCVnsPCwLQbnmmr9f9rIAfviwAtVcC/DkRSL9Vh0nLvfu2iCRSPI50mHlIdqXaU9x6+I8ePGAJaeXZH0FVV4GX5xcAwkvADAxUjKnc1XsrU25FPWMVZeV2RP4IXmvkfdU1pDfv8cMOawrV64wcuRIOnbsSFRUFADbtm1775e+z26MVcZ8U+0bAJadWUbksyx+r1SyIdgUgxeP4PwWbbK9jRlzulTFWKXgeLSS+XuvZ229kvcWY2NjgPd+yaGsIvl7TP5e8xsGr3Tx77//0qxZM+rUqcOePXv46aefsLe358SJEyxatIj169dnh56Sl/gV98OriBfH7x1n1vFZjKszLusKV6rAqxPsmQRhK6DSqzkf1VwLMrJ5OUb9dY6pOy9R2aUA9cu838vESDKPSqXCzs5O++BrYZGxJZJeR61WEx8fz4sXL1Aq898gkj77hBDExsYSFRWFnZ0dKlX2h/XnBAY7rKFDh/Ljjz8SGBioE+XywQcfMGvWrCxVTpIShULBoBqD6LK1C39e/pMu5btQtmDZrKugSmeNw7oaAg/DoYCr9lTHGsXYdugMB6OUfPW/MP7qX5fihTK3HYNE4uioWQIs2WllFiEEz58/x9zcPNPOLzeSln12dnba7zM/YrDDOnXqFKtWrUqRbm9vz/3797NEKUnaeBbxxN/Nn3+u/8OUo1OY32R+1hVewA3cfeHav3B8JTQcrj2lUCho664m1tiOk7dj6Pv7Mf74ojbmJvnzaU7yblAoFDg5OWFvb09CQuZXVklISGDPnj3Ur18/Xw6NpWafsbFxvu1ZJWOww7Kzs+Pu3bu4u7vrpIeFhensoinJXr6u+jXBN4I5cPcA+27vo07ROllXeNVuGocVthJ8h2iGCl9irIRZHb1oM/cg5+7GMPSPk0zv4JUvn2Ql7xaVSpUlDa5KpSIxMREzM7N86bDyu31pYfAA76effsqQIUOIiIhAoVCgVqvZt28fgwYNolu3btmho0QPLtYudCrXCYDJRyeTpM7CePNyH4KZHcTcgqu7U5x2sjVjVqeqqJQK/jx+h0X/Xcu6uiUSiSQVDHZYP//8M+XKlcPFxYWnT5/i4eFB/fr1qV27dqobj0myhz6V+2BjYsPlR5f588qfWVewsRlUbq/5+7U5Wa9Ts0QhRrYoD8D4befZf0UOB0skkuzFYIdlYmLCggULuHLlClu2bOH333/n/PnzrFixIt+Pn+Y2bE1t6Vu5LwCzwmYRm5CFocFVXi7VdP5vePZAr0hAbTfaVClKklrQf1UYtx89z7r6JRKJ5A0yHPNZvHhxmjdvTvv27SldunRW6iQxgE/LfUoxq2Lce36PZWeWZV3BTpXByRPUCZqJxHpQKBT83KYSFZxtiH4Wz+crjvEiQS6FIZFIsgeDgy569uyZ5vnFixdnWBmJ4ZioTPim2jcM+ncQS84soW2ZthSxyKL5UVW6wt0TmjlZNb/QK2JmrGJul2q0nPUfp24/ZsTG00xuV1kGYUgkkizH4B7Ww4cPdY6oqCh27drFH3/8waNHj7JBRcnbaOLahMpFKvM88Tmzj8/OuoIrtQMjM4g6C7dDUxVzKWjBrE5VUSpgQ+gtVhwMzzodJBKJ5CUGO6yNGzfqHFu2bOHq1at06NCBmjVrZoeOkrfw+s7EGy9v5OLDi1lTsLkdlG+p+Ts07eHGOqUKM7RZOQDG/nWWw9eis0YHiUQieUmWrFuiVCoJDAxk2rRpBuedPXs2bm5umJmZ4ePjw+HDh9OUX7duHeXKlcPMzIxKlSqxdevWFDLnzp2jZcuW2NraYmlpSY0aNbhx44bBuuUlqthXobFrY9RCzdRjKXczzTDJ+2Sd/gPi014hvne9EnxY2YlEtaDfymNEPH6RdXpIJJL3nixbaOvKlSskJhq2seCaNWsIDAxk1KhRhIaG4unpib+/f6pLtOzfv5+OHTvSq1cvwsLCaN26Na1bt+b06dM6etStW5dy5coREhLCyZMn+f777zEzM8uUfXmBb6p+g5HCiH2397Hk1BK2Xt3KkYgjmZuj5VoXCrhD/BMU5zanKapQKJjUtjLlHK25/zSez38/RlyiDMKQSCRZg8FBF4GBgTqfhRDcvXuXv//+m+7duxtU1tSpU+nduzc9evQAYO7cufz9998sXryYoUOHppCfMWMGTZs2ZfDgwQCMGzeOoKAgZs2axdy5cwEYMWIEzZs3Z9KkSdp8JUuWNEivvEpxm+LUdq7Nntt7mBr6qpflYOHAUO+h+Ln6GV6oUglVusCucShPrITC/dIUtzAxYl7Xanw08z+O33zE6M1n+LF1JQ5fiybqyQvsrc3wdi+ISimDMiQSiWEY7LDCwsJ0PiuVSooUKcKUKVPeGkH4OvHx8Rw7doxhw4bplOXn58eBAwf05jlw4EAKh+nv78+mTZsAzSrGf//9N9999x3+/v6EhYXh7u7OsGHDaN26daq6xMXFERcXp/0cExMDaNbsMmRts2TZrFgPLSME3wxmz+09KdKjYqMIDAlkUr1JNHJpZHjBFdpjtPsnlDcPYmX18Vvtc7YxYVr7yny2IpT/Hb7J3yfvEvPiVe/b0caUkc3L4V/BwXBdspmcvobZTX63D/K/jRm1Lz98HwY7rN27Uy7VkxHu379PUlISDg66jZaDgwPnz5/XmyciIkKvfEREBKBZ7fnp06dMmDCBH3/8kYkTJ7J9+3batGnD7t278fX11Vvu+PHjGTNmTIr0HTt2YGFh+GrkQUFBBufJLGqhZnLMZL3nBJpN3X7870ee2zxHqTB8JNjHuhKOMSco/mAPQUFO6cpTpaCC0AcqYl4kAK96VBExL+i/+jg9y6jxLJQ7N5zLiWv4Lsnv9kH+t9FQ+/LDnmMGO6zcjFqtBqBVq1Z8++23AHh5ebF//37mzp2bqsMaNmyYTs8tJiYGFxcXmjRpgo2NTbrrT0hIICgoiMaNG7/zRSmPRh4lJjgmTZnH4jGO1R2p7lDd4PIV5wVs6I5L9H8U7ToHY7O0HXmSWjD+zB4gjted1cvSUADbIi34rnP9XDU8mJPX8F2Q3+2D/G9jRu1LHjnKy6TLYVWpUiXdE0FDQ1Ofr/M6hQsXRqVSERmpu2tuZGRkqvu5ODo6pilfuHBhjIyM8PDw0JEpX748//33X6q6mJqaYmpqmiLd2Ng4Qzd8RvNlhofxD9Mlt/7yekoUKIGDpYHDcR4tENuLYPbsHonhIRhVbJWm+NErD4iIiUv1vADuPo4j7NYTapUsZJgu74CcuIbvkvxuH+R/Gw21Lz98F+lyWGm9/8koJiYmVKtWjeDgYG35arWa4OBg+vfvrzdPrVq1CA4O5ptvvtGmBQUFUatWLW2ZNWrU4MKFCzr5Ll68iKurK/mZ9K5usSN8Bztv7KR+sfq0Ld2WukXrolKmYw1IlTHqSu1RHZytCb54i8OKepK+kPb0ykkkEkm6HNaoUaOypfLAwEC6d+9O9erV8fb2Zvr06Tx79kwbNditWzeKFi3K+PHjAfj666/x9fVlypQptGjRgtWrV3P06FHmz3+1geHgwYPp0KED9evXp2HDhmzfvp2//vqLkJCQbLEht1DVvioOFg5ExUZp31m9ia2JLSVsSxB2L4yQmyGE3AzBwcKBNqXb8HGpj3GySvvdlNqzC6qDs1Fc3glPIsA69Z1N7a3TN40gvXISiUSSZfOwMkKHDh2YPHkyP/zwA15eXhw/fpzt27drAytu3LjB3bt3tfK1a9dm1apVzJ8/H09PT9avX8+mTZuoWLGiVubjjz9m7ty5TJo0iUqVKrFw4UI2bNhA3bp137l97xKVUsVQb81UAMUb74wUL/+Nrj2a5c2X82erP+nm0Q07UzsiYyOZc2IO/hv86bezH8E3gklQpxJNVLg0DyxLoxBJcDzlrtOv4+1eECdbsxRvr17HyVYT4i6RSCTpQSGEMChMKykpiWnTprF27Vpu3LhBfHy8zvno6Ly/JE9MTAy2trY8fvzY4KCLrVu30rx58xwbL94ZvpMJhycQGfvqXZ+jhSNDvIekmIcVlxRHcHgwGy5t4HDEqxVGipgXoXWp1rQp3YZi1sW06QkJCZxeMYQqNxZBwZLw1TFI493m9tN3+eJ3zTtNfTdZ15qujGtdUc+ZnCM3XMPsJL/bB/nfxozal9F2LTdhcA9rzJgxTJ06lQ4dOvD48WMCAwNp06YNSqWS0aNHZ4OKEkPwc/Xjn0/+YbH/YibWm8hi/8Vs/2S73knDpipTmpdoziL/RWz5eAs9KvagoFlB7j2/x4JTC2j+R3P6BvVlx/UdJCRpel237XwQJpYQfQXC96epS9OKTszpUhVHW91hPytTzTuzVYdvsPuC/lVNJBKJ5E0MDmtfuXIlCxYsoEWLFowePZqOHTtSsmRJKleuzMGDBxkwYEB26CkxAJVSRQ3HGgblcbVxJbBaIF95fcXum7tZf3E9B+4eYP+d/ey/s5+CZgX5yP0jClAAUb41ihMrNduOuNVJs9ymFZ1o7OGos9JFDbcCDF5/ko1ht/lyZShr+tSiUjHbzJgskUjeAwzuYUVERFCpUiUArKysePz4MQAffvghf//9d9ZqJ3nnGKuMaeLWhPlN5rO1zVZ6V+pNYfPCRL+IZtm5ZUx/Mp3PFFFss7Qg/swmePH4rWWqlApqlSxEK6+i1CpZCCOVkomfVKZuqcLExifRY+kRbkbn/UmNEokkezHYYRUrVkwbCFGyZEl27NgBwJEjR/TOZZLkXVysXRhQdQA72u5gesPp1HWuiwIFRx5f4Dv7wjRyLsgvOwdw9fFVg8s2MVIyp0tVyjvZcP9pHN0XHyb6WfzbM0okkvcWgx3Wxx9/THBwMABfffUV33//PaVLl6Zbt24GrSUoyTsYK41pVLwRvzb4lUCbQHpX7I2DkSWPVCqWPwil1aZWdN/Wnb+u/MWLxJTzqpLUSRyJOJJi9XhrM2OW9qhBUTtzrt5/xmfLjvA8Xq7uLpFI9JPud1izZs2iS5cuTJgwQZvWoUMHihcvzoEDByhdujQfffRRtigpyT0UUBagc+XO9Cvdnn3zqrLe0pw9lpaERoUSGhXKhMMT+KjkR3xS+hNKFyitN2rx9dXjHWzMWNqjBp/M2U/ojUd8vTqMOV2q5arlmiQSSe4g3T2sESNG4OzsTOfOndm1a5c2vVatWgQGBkpn9Z5hZOOIb/EPmBl1nx2FPqC/V3+cLZ2JiY9h5bmVtNnchg83fsi3Id/qOCt4tXr8zvCdAJR2sGZBt+qYqJTsOBvJ6M1nMHC2hUQieQ9It8OKiIhg7ty53Llzh8aNG+Pu7s64ceO4efNmduonyc1U6QaAw5lN9K0QwNY2W5njNwe/4n6oUBEeE643W/JKHBMPT9QOD/qUKMS0Dl4oFLDiYDhz/r3ybmyQSCR5hnQ7LHNzc7p168bu3bu5dOkSXbt2ZdGiRbi7u9O0aVPWrVuXL/ZbkRhAqUZg7QzPH8L5v1EpVdQtWpdpDacxuYH+rU6SEQgiYiMIjXq1WHKLyk6MbKFZuHjS9gv8EXorW9WXSCR5iwwtzVSiRAnGjh3LtWvX2LZtG4UKFSIgIICiRYtmtX6S3IxSBV6dNH+HrdA5FZ+Uvoi/e7H3dD73quvOZ3XdAfhu/Un+u3Q/83pKJJJ8QabWElQoFBgZGaFQKBBCyB7W+0iVLpr/r+yGRze0yeldPV6f3PDm5fmwshOJasHnvx/jzJ23z/WSSCT5nww5rJs3bzJ27FhKlChB48aNuXPnDgsWLNBZqFbynlDQHdzqAQLCVmqTk1ePf3Mh3mQUKHC0cKSqfdUU55RKBVPae+LjXpCncYn0WHKEWw/lxGKJ5H0n3Q4rPj6e1atX06RJE9zd3VmwYAGdOnXi4sWL7Nq1i86dO2NmJreKeC+pqgm+4PhKeBlEkdbq8aB5hzXEe0iqe3GZGqmY3606ZRysiHoSR8CSIzyKlROLJZL3mXQ7LEdHRwICArCxseGvv/4iPDycH3/8kRIlSmSnfpK8QPmPwNQWHt+EqyHaZD9XP6Y2mIq9hX2KLO427jQq3ijNYm3NjVnawxtHGzMuRz2lz/JjvEiQE4slkveVdDuskSNHcvPmTdavX0+zZs1QKnN0Ky1JbsLYHCq30/z9RvDFm6vHT64/GTOVGddirrH5yua3Fu1sZ87SnjWwNjXi8PVoAtceR62Wc7QkkveRdHudwMBAihRJ34t0yXtIla6a/8//DbG6e6Ilrx7fvERz/N39+cLrCwCmHpvK47i3B1SUc7RhXrdqGKsUbD0Vwbi/z8qJxRLJe4jsJkmyBmcvcKwESfFwck2aol3Ld6WEbQmiX0QzK2xWuoqvXbIwk9t5ArBk33UW/XctsxpLJJI8hnRYkqyjanfN/6ErII0ekLHKmBE+IwBYe3EtZx+cTVfxrbyKMqxZOQB+/Pscf524kzl9JRJJnkI6LEnWUaktqEwh6gzcCU1T1NvJm2buzVALNT8d/Am1UKerij71SxBQ2w2AgWtPcODKg8xqLZFI8gjSYUmyDvMC4NFS83foirRlgUHVB2FpbMnJ+yfZeGljuqpQKBR8/6EHTSs4Ep+kps+Ko1yIeJIZrSUSSR4hXduLBAYGprvAqVOnZlgZST6gSlc4tQ5ObwD/n8HEIlVRewt7+nn245ejvzA9dDqNijfCzszurVWolAqmf+pFl4WHOBr+kIAlh/mjX22cbM2z0BCJRJLbSJfDCgsLS1dhCoXcw+i9x60e2LnCo3A4+yd4dUxTvFP5Tmy6solLDy8xI2wGo2qNSlc1ZsYqFnavzidz9nPl3jN6LDnC2s9rYWNmnBVWSCSSXEi6HNbu3buzWw9JfkGp1PSydv+omZP1FodlpDRihM8IArYHsOHiBtqUakOlIpXSVZWdhQlLe3jTZs5+zkc8oe/yYyztWQNTI/2rZ0gkkryNfIclyXq8OoFCCeH74MHb97Wq5lCNliVbIhCMOzhOu0dWenApaMHSHjWwNFFx4OoDBq87KScWSyT5lHT1sN7k6NGjrF27lhs3bhAfr7u+2x9//JEliknyMLZFoWQjuByk6WX5jX5rlm+rfcvuG7s5F32O9RfX06Fch3RXV8HZlrldq9FjyRE2n7iDk60Zw5qXz4QBEokkN2JwD2v16tXUrl2bc+fOsXHjRhISEjhz5gy7du3C1tY2O3SU5EWqvlz54vj/ICnxreKFzQvTv0p/AGaEzeDBc8PC1euVLsLETyoDMG/PVZbukxOLJZL8hsEO6+eff2batGn89ddfmJiYMGPGDM6fP0/79u0pXrx4dugoyYuUaQYWheFphKanlQ46lO1A+YLleRL/hOmh0w2u8pNqxRjsXxaAMVvOsu2U3O5GIslPGOywrly5QosWLQAwMTHh2bNnKBQKvv32W+bPn5/lCkryKEYm4Pmp5u90zMkCzZqDI2pqVsDYdHkTYVHpi059nX4NStLZpzhCwNdrjnPkevTbM0kkkjyBwQ6rQIECPHmimahZtGhRTp8+DcCjR4+IjZWb7EleI3lB3Avb4OxmOLUeru3V7pmlD88inrQp3QaAHw/+SKL67cOJr6NQKBjTsgJ+5e2JT1Tz2bKjXI6SE4slkvyAwQ6rfv36BAVphnjatWvH119/Te/evenYsSONGqW9v5HkPcO+HBQqCahhbVfY0AuWfQjTK2ocWCp8U/UbbE1tufjwImsupL2Qrj6MVEpmdqyKl4sdj58n0H3xEaJiXmTCEIlEkhsw2GHNmjWLTz/VDPWMGDGCwMBAIiMj+eSTT1i0aFGWKyjJw5zdrD+sPeYurO2WqtMqYFaAr6t+DcCssFnci71ncNXmJioWda+OWyELbj96TsCSIzx5kWBwORKJJPdgsMMqWLAgzs7OmsxKJUOHDmXz5s1MmTKFAgUKZLmCkjyKOgm2D0nl5Mt5UtuHpjo82KZUGyoWqsjThKdMOTYlQyoUsjJlWU9vCluZcPZuDP1WhhKfmL5FdiUSSe7DYIe1detW/vnnnxTpO3bsYNu2bVmilCQfEL4fYtLa/kNAzG2NnB5UShUja45EgYK/r/7NkYgjGVLDtZAli7rXwNxYxd5L9xn6x0m5+aNEkkcx2GENHTqUpKSUT8VqtZqhQ4dmSInZs2fj5uaGmZkZPj4+HD58OE35devWUa5cOczMzKhUqRJbt25NVfbzzz9HoVAwffr0DOkmySBPIzMtV6FwBdqVaQfAz4d+JkGdsSE9Txc7futcFZVSwR+ht5my42KGypFIJDmLwQ7r0qVLeHh4pEgvV64cly9fNliBNWvWEBgYyKhRowgNDcXT0xN/f3+ioqL0yu/fv5+OHTvSq1cvwsLCaN26Na1bt9ZGK77Oxo0bOXjwoHYIU/IOsXLIErkBVQdQwLQAlx9dZtW5VRlWp2E5e37+uCIAs3ZfZuWh8AyXJZFIcgaDHZatrS1Xr15NkX758mUsLS0NVmDq1Kn07t2bHj164OHhwdy5c7GwsGDx4sV65WfMmEHTpk0ZPHgw5cuXZ9y4cVStWpVZs3S3Wr99+zZfffUVK1euxNhYruD9znGtDTbOQBor+CuNwdopzWJsTW35ttq3APx2/Dcin6Wz56aHDjWK83Wj0gB8v+k0QWczXpZEInn3GLyWYKtWrfjmm2/YuHEjJUuWBDTOauDAgbRs2dKgsuLj4zl27BjDhg3TpimVSvz8/Dhw4IDePAcOHEixP5e/vz+bNm3Sflar1XTt2pXBgwdToUKFt+oRFxdHXFyc9nNMTAwACQkJJCSkfxgqWdaQPHkJQ+1TNP4Z1YYegAIFr94bJf+lUCcgFjQkqeVsRJlmqZbT3LU56y+u5+T9k0w8PJGJdSdm1AS+9HXjzqNY1h27zVf/C2V5j+pUcbHTnpfXMO+T323MqH354fsw2GFNmjSJpk2bUq5cOYoVKwbArVu3qFevHpMnTzaorPv375OUlISDg+6wkIODA+fPn9ebJyIiQq98RESE9vPEiRMxMjJiwIAB6dJj/PjxjBkzJkX6jh07sLBIfQPC1Eiep5ZfSb99Spzc+1Pp1krME16tOPHcuCAXHFvhGr2Xgs8uY7SuKxcdPuS80ycIhf6tQeol1uMUpwi6EUTRP4tSyrhUhvWvZQSn7ZScewQ9Fh/im4pJ2L+x96O8hnmf/G6jofblh4UdDHZYtra27N+/n6CgIE6cOIG5uTmVK1emfv362aGfwRw7dowZM2YQGhqa7g0lhw0bptNri4mJwcXFhSZNmmBjY5PuuhMSEggKCqJx48b5chgyY/Y1B/VIEm8e0ARYWDlg7FKLikoVJMWTFDwG1ZF5lIncQimzRyS1ng9W9npLenD0AasvriZEFcLn/p9jojLJsC0fNE6ky+KjnL4Tw/Jwa9b28aawlam8hvmA/G5jRu1LHjnKy2RoexGFQkGTJk1o0qRJpiovXLgwKpWKyEjddwmRkZE4OjrqzePo6Jim/N69e4mKitJZiDcpKYmBAwcyffp0rl+/nqJMU1NTTE1NU6QbGxtn6IbPaL68guH2GUOphvoKghaTwLUmbP4KZfh/KBd9AO2WgmutFOIDqg0g6EYQ12Ou879L/+OzSp9l2AY7Y2OW9PDmkzn7uREdS9+Vx/lf75qYvLRLXsO8T3630VD78sN3ka6gi19//ZUXL15o/07rMAQTExOqVatGcHCwNk2tVhMcHEytWikbLIBatWrpyIOma5ws37VrV06ePMnx48e1h7OzM4MHD9Y7f0ySC6jYBnrvhiLlNKu7L20BB2bDG/OlrE2sGVh9IADzTszj7tPMrcZexNqUpT1qUMDCmJO3HtN/VSiJSXJisUSSW0lXD2vatGl07twZMzMzpk2blqqcQqFI93ujZAIDA+nevTvVq1fH29ub6dOn8+zZM3r06AFAt27dKFq0KOPHjwfg66+/xtfXlylTptCiRQtWr17N0aNHtSvFFypUiEKFCunUYWxsjKOjI2XLljVIN8k7pEgZ+CwY/voaTq+Hf4bDzUPQchaYvRqW/bDEh2y4tIFjkceYeGQi0xtOz1S1JYpYsSigBp0WHGT3hXv88Nc56uT9B1GJJF+SLod17do1vX9nBR06dODevXv88MMPRERE4OXlxfbt27WBFTdu3ECpfNURrF27NqtWrWLkyJEMHz6c0qVLs2nTJipWrJileklyAFMr+GQhFK8J24fB2T8h8gy0XwEOmrl/CoWCET4jaPdXO4JvBLP31l7qFauXqWqrFi/AzI5V6bviKOuO3eZJMQUtssIeiUSSpRg8Dys76N+/P+Hh4cTFxXHo0CF8fHy050JCQli6dKmOfLt27bhw4QJxcXGcPn2a5s2bp1n+9evX+eabb7JBc0mWo1CAd2/ouR1sisGDy7CwEZx4tWp76QKl6VK+CwDjD48nLikutdLSTWMPB8a20jz0bL+lYt2xW5kuUyKRZC0GB128OQcqGYVCgZmZGaVKlaJVq1YULFgw08pJ3mOKVYe+e+CPz+DKLtjYRzNE2HQ8GJnyhdcXbLu2jZtPbrL49GK+8Pwi01V2qenK7ehnzNlzje83n8PJzpKG5fRHLEokknePwT2ssLAwFi1axPz58/n333/5999/WbBgAYsWLSI4OJjAwEBKlSrF2bNns0NfyfuEZSHovB58hwAKOLoIFjeFRzewNLZkcI3BACw6tYibT25mSZXf+pWiRhE1SWpBv5WhnLz1KEvKlUgkmcdgh9WqVSv8/Py4c+cOx44d49ixY9y6dYvGjRvTsWNHbt++Tf369fn222+zQ1/J+4ZSBQ2HaxyXeQG4Ewrz6sOlnfi7+ePj6ENcUhwTD2d89YvXUSgUfFpCTZ2ShXiekETPpUe48SDvT7iUSPIDBjusX375hXHjxulMqLW1tWX06NFMmjQJCwsLfvjhB44dO5alikrec0r7aYYInavA84ewsi2KkPEM9x6KkdKIf2/9y+4bu7OkKiMlzOroiYeTDfefxtN9yWGin8VnSdkSiSTjGOywHj9+rHcl9Xv37mlnUtvZ2REfL3/gkizGrjj0/Aeq9wIE/DuRElsG0710ewAmHJ7A88TnWVKVlakRS3vUoKidOdfuP6PXsiM8j9e/2aREInk3ZGhIsGfPnmzcuJFbt25x69YtNm7cSK9evWjdujUAhw8fpkyZMlmtq0QCRqbw4VT4eD4YmcOVXfTZ/zuOpgW58+wOC08tzLKq7G3MWNazBrbmxoTdeMSA1WEkqeXmjxJJTmGww5o3bx6NGjXi008/xdXVFVdXVz799FMaNWrE3LlzAc3eWAsXZl3DIZGkwLMD9N4FhUphEXOLITevALDk9BLCY7Jur6tS9tYs7F4dEyMlQWcjGbX5tNyxWCLJIQx2WFZWVixYsIAHDx4QFhZGWFgYDx48YP78+dr9sLy8vPDy8spqXSUSXRw8NEs6lW9Jo2dPqBP7nAR1AuMPjMtSp1LDrSAzOnihUMDvB2/wW8iVLCtbIpGknwxPHLaysqJgwYIULFgQKyurrNRJIkk/ZjbQfjkK/58ZFv0YYyHYF3GInaeWZ2k1zSo58cOHmtU2fvnnAn+EyonFEsm7xmCHpVarGTt2LLa2ttohQTs7O8aNG4daLRcOleQACgXU+hLXLpvpGau5BycemUjsidVZWk2POu70qV8CgO/Wn2TvpXtZWr5EIkkbgx3WiBEjmDVrFhMmTNAOCf7888/MnDmT77//Pjt0lEjSh2stenXaTlGhItJIxbyQ72DbUEjMuojVoU3L8ZGnM4lqwRe/h3LmzuMsK1sikaSNwQ5r2bJlLFy4kC+++ILKlStTuXJl+vXrx4IFC1Ks+SeRvGvM7YoztOEUAJbb2nA1dIFmu5LHt7OkfKVSweR2lalVohBP4xIJWHKEWw/lxGKJ5F1gsMOKjo6mXLlyKdLLlStHdHS0nhwSybulgWsjfIv5kqhQ8HMRe8Stw5rVMa6GZEn5pkYq5natRlkHa+49iaP74sM8ipXzDiWS7MZgh+Xp6cmsWbNSpM+aNQtPT88sUUoiySxDvYdiqjLlkKkR24uWhdj7sOJj2PMLZMG7VltzY5b2rIGTrRlX7j2j9/KjvEiQE4slkuzEYIc1adIkFi9ejIeHB7169aJXr154eHiwdOlSfvnll+zQUSIxmGLWxfis0mcA/GJryTOvjiDUsOtH+N+nmuWdMomTrTlLe3hjbWbEkesP+XbNcTmxWCLJRgx2WL6+vly8eJGPP/6YR48e8ejRI9q0acOFCxeoVy9zG+lJJFlJj4o9cLF24d7z+/xWtKRm92IjM7j0j2aI8E5Ypuso62jN/K7VMVEp2XY6gnFbzsqJxRJJNpGheVjOzs789NNPbNiwgQ0bNvDjjz+iVqvp06dPVusnkWQYU5Upw32GA7Dy3EouuvtArx1QwA0e3YBF/nBsKWTSwdQqWYjJ7TXD4Uv3X2fB3quZ1Fwikegjy3YcfvDgAYsWLcqq4iSSLKFu0br4FfcjSSTx08GfEI6Voc+/ULY5JMXBX1/Dpn4Qn7lIv5aezoxoXh6An7ee58/jWROVKJFIXpFlDksiya18V+M7zI3MCY0KZcvVLWBuBx1Wgt9oUCjhxCpY1BgeZG7Jpc/qudOjjhsAg9adYP+V+5nWXSKRvEI6LEm+x8nKiT6VNcPVk49OJiY+BpRKqPstdPsTLItA5GmY3wDFha0ZrkehUPB9Cw+aV3IkIUnQd8UxzkfEZJUZEsl7j3RYkveC7h7dcbNxI/pFNLPDZr864V4f+u4Fl5oQF4PR+m543F4N6sQM1aNUKpja3gtvt4I8eZFIwOIj3H2cNXt0SSTvO0bpFWzTpk2a5x89epRZXSSSbMNYZcyImiPovaM3qy+spnWp1pQvpHnnhI0TBGyBnaPhwCxKR21FvfJjaLcUrB0NrsvMWMX8btVoO/cAl6OeErD4CGs/r4WtuXGW2iSRvG+ku4dla2ub5uHq6kq3bt2yU1eJJFPUdKpJU7emqIWanw79hFq8NoFYZQz+P5HYZjEJSjOUNw5oQt+v78tQXXYWJizr6Y29tSkXIp/Qd8VR4hLlxGKJJDOku4e1ZMmS7NRDInknDKo+iD239nDi3gn+vPwnH5f+WOe8KN+Sf8/do9H9pSjunYNlH2mCM2p/pVkV3gCK2mkmFrefd4CDV6MZtO4kMzp4oVQaVo5EkkySWnDoWjTH7isodC2aWqXsUb1H95N8hyV5r3CwdKCfVz8Aph2bxuO4lKutPzNzIjFgO1TuACIJgr6HNV3gheErs3s42zC3SzWMlAr+OnGHCdvPZ9oGyfvJ9tN3qTtxF10WH2X5JRVdFh+l7sRdbD99N6dVe2dIhyV57+hUvhOl7ErxMO4hv4b+ql/IxBI+ngctpoLKBM5vgfkNIOK0wfXVLV2YX9pVBmD+nqss2XctE9pL3ke2n77LF7+HcvfxC530iMcv+OL30PfGaUmHJXnvMFYaa1fAWHdxHafvp+KEFAqo0Qt6bgdbF4i+Cgv94Pgqg+v8uEoxvmtaFoCxW86y7dRdktSCA1ce8Ofx2xy48kCuQyjRS5JaMOavs+i7O5LTxvx19r24f9L9DksiyU/UcKzBhyU+ZMvVLfx48EdWNl+JSqnSL1y0GvTdA3/0hss7YdMXcOMgNJsExmbprvML35LcffSCFQfD+ep/YdiaG/Pg2attSZxszRj1kQdNKzpl1jzJO0KtFiSo1SSpBQlJgsQkNYlqQULSa2lqNYlJb0lTv8yblLK8q/efpehZvY4A7j5+weFr0dQqWejdGZ8DSIcleW8ZWH0gITdDOPPgDBsubaB92fapC1sUhE7rYO9k2P0zhC6Du8eh/XLN2oTpQKFQMLplBU7cesTJW491nBW8Gt6Z06VqvnNaQgjUAhJeNuiJSWoSksTLhllP2ssGPTFJTYJakKRWv2zANY29Rk79hpPQpMUlJHL+hpJT/1xELRQaOR2HoC9vxhxMburURD1J3anlF6TDkry3FDYvTP8q/ZlweAIzQmfg5+qHtco69QxKJfh+p+lxbfgM7p7QhL63WQBl/NNdb1SM/oZFAAo0wzsNytojBJqn7aTXG/DXn8DVbzTgaaS9bGBfJCRy+o6Cm3uuoUbxmkPIWHmpO5iUed8tSrh9/R3X+bJmBRiplBgrFaiUCoxVSoxUCoyUSoxVKdOMlAqMVC/TlAqMXvvfWKkg+lkcIRffvsyXvXX6e/t5FemwJO81Hcp2YOOljVx4eIEZoTMYWWPk2zOVaqQZIlwXALePwqr2UG8gNBwBqQ0rvuTwtWgiYuJSPZ88vFPu++2GGWIQKgi/lI3lpx9tY61UonqtUdemJTfcKoXextxI9Vray7xKheDWjRuUKuGOibHRy7zJDuL18l45i1flvZaWioPRSXutPJVSo3NWT1tIUgvqTtxFxOMXet9jKQBHWzO83Qtmab25EemwJO81RkojRtYcSddtXfnj0h985PZR+jLauUCPbbBjBByeD3unwK2j8MkisCqSaraMDtsoFGD8WqNrrFK+0ZC+StNpzJW6Da1SAZF37+BavBgmRqk05m823OnpLbzZcL9MS5ZPbsxf70molAoUBs5tSw8JCQls3Xqd5s3KYmyc91cXUSkVjPrIgy9+D0UBOk4r+dsb9ZHHezEfSzosyXuPl70XrUu1ZtPlTUw4OoFOolP6MhqZQPNfwMUHNn8F1/7VDBG2WwrFffRmSe+wzcJu1alVspC2p5FVT+2axvwWzZtXzBeN+ftC04pOzOlSlTF/ndUJwHB8zwJ1ckVY++zZs3Fzc8PMzAwfHx8OHz6cpvy6desoV64cZmZmVKpUia1bX62wnZCQwJAhQ6hUqRKWlpY4OzvTrVs37ty5k91mSPIw31T9BmsTay48vMCR+COGZa7UFnrvhsJl4MkdWNocDs7RuzGkt3tBnGzNSM39KNBECzYsZ4+lqRGmRiq5MoYE0Dit/4Z8wO89q9OtdBK/96zOf0M+eG+cFeQCh7VmzRoCAwMZNWoUoaGheHp64u/vT1RUlF75/fv307FjR3r16kVYWBitW7emdevWnD6tmUsTGxtLaGgo33//PaGhofzxxx9cuHCBli1bvkuzJHmMQuaF+LrK1wDsfL6TB88fGFaAfTnovQsqfKxZ6X37UFjfA+Ke6IglD+8AKZzW+za8IzEclVKBj3tBqhUW+LgXfO/ukxx3WFOnTqV379706NEDDw8P5s6di4WFBYsXL9YrP2PGDJo2bcrgwYMpX74848aNo2rVqsyaNQvQLNIbFBRE+/btKVu2LDVr1mTWrFkcO3aMGzduvEvTJHmMtmXaUr5geV7wghnHZxhegKk1tF0CTSeC0gjObIT5DSHqnI5Y8vCOo63u8KCjrVm+DGmXSLKKHH2HFR8fz7Fjxxg2bJg2TalU4ufnx4EDB/TmOXDgAIGBgTpp/v7+bNq0KdV6Hj9+jEKhwM7OTu/5uLg44uJeRW7FxGg23UtISCAhISGd1qCVNSRPXiK/2wcwuMpgegX3Ysu1LbQu2Zqq9lUNL6RaLxQOlVD90QvFg0uIBR+Q1HwqomJbrUijsoVpULoeR8MfEvUkDntrU6q7FkClVGTr9/s+XMP8bmNG7csP30eOOqz79++TlJSEg4ODTrqDgwPnz+tfJDQiIkKvfEREhF75Fy9eMGTIEDp27IiNjY1emfHjxzNmzJgU6Tt27MDCwiI9pugQFBRkcJ68RH63r5pJNY7GH2XErhH0s+6HSpF2qHpqmLiOoPr13yjy9CxGf37O1X3rOVO0I2qlbrCDCngA/HNObzHZQn6/hpD/bTTUvtjY2GzS5N2Rr6MEExISaN++PUII5syZk6rcsGHDdHptMTExuLi40KRJk1SdXGr1BQUF0bhx43wZgZXf7QONjbH/xHKJS0TGR/K45GO6lOuS8QLV7UjaMxHVvqmUuL8TN5NoktosBttioE5CcfMAPI0EKweES623zuPKLO/LNczPNmbUvuSRo7xMjjqswoULo1KpiIyM1EmPjIzE0VH/Tq+Ojo7pkk92VuHh4ezatStNx2NqaoqpqWmKdGNj4wzd8BnNl1fI7/ZZKC0Y4DWAcYfHMe/UPFqUbIG9hX0GSzOGxqPAtSb80QflnVCUiz6AGp/B8d8h5rXoVRtnzfsvj+wPEMrv1xDyv42G2pcfvoscDbowMTGhWrVqBAcHa9PUajXBwcHUqlVLb55atWrpyIOma/y6fLKzunTpEjt37qRQofy9IKQk62lVshWVC1fmWcIzJh+dnPkCy/hD33/ByROeR8OeSbrOCiDmLqztBmc3Z74+iSQfkuNRgoGBgSxYsIBly5Zx7tw5vvjiC549e0aPHj0A6Natm05Qxtdff8327duZMmUK58+fZ/To0Rw9epT+/fsDGmfVtm1bjh49ysqVK0lKSiIiIoKIiAji4+P16iCRvIlSoWREzREoFUq2XdvGobuHMl9oATcI2AbGqb0XfTlva/tQUCdlvj6JJJ+R4w6rQ4cOTJ48mR9++AEvLy+OHz/O9u3btYEVN27c4O7dV5uT1a5dm1WrVjF//nw8PT1Zv349mzZtomLFigDcvn2bzZs3c+vWLby8vHByctIe+/fvzxEbJXkTj0IetC+jWcH9p0M/kZCUBVFWd0IhIa2X3wJibkO4vFclkjfJFUEX/fv31/aQ3iQkJCRFWrt27WjXrp1eeTc3N4SeFQYkkozQv0p/doTv4Nrja6w4t4KeFXtmrsCnkW+XAdjzi2bo0L0+mBfIXJ0SST4hx3tYEkluxtbUlsBqmgjSuSfmEvFM//SJdGPl8HYZ0KxLuLYbTCoBCxrBrh81va6s6OVJJHkU6bAkkrfQsmRLqtpX5XnicyYdmZS5wlxra6IB01pN0KIQePeBwmVBqDVbmOz5BZY0g4lusOpTODQP7l3Uu16hRJJfyRVDghJJbkahUDDcZzgdtnQgKDyIfbf3UadonYwVplRpQtfXdoPUNov4cPqr0PbHt+HqbriyC66GQOwDuLhNcwDYFIOSDaDkB+DeACxlRKwk/yJ7WBJJOihbsCwdy3UEYPzh8cQnZSLi1KMltF8ONm+sGWjjrEl/fR6WbVGo0gXaLoZBlzUbR/qNBndfUJlAzC0I+x3W94RfSsI8X9g5Gq7+C4mpbxQpkeRFZA9LIkknX3p9yfbr2wmPCWfpmaX0qdwn44V5tIRyLTTvpV6udIFr7bRXulAqNfO4nDyh7rcQHws39sOV3Zoj6gzcPa45/pumCZ93ra3pfZVoCPblM66vRJILkA5LIkknViZWDKo+iKF7h7Lg5AJalGhBUauiGS9QqQL3ehnPb2IBpfw0B8CTCM2w4ZVdGgf2LAou79QcAFaOqNx9KRZTAJ5WhwKZ0F0iyQGkw5JIDKC5e3M2XNrAkYgjTDg8gZkfzMxplV5h7Qien2oOISDq7CvnFb4PnkagPLWGagAz5oJDRSjZUNP7cq0NxuY5bYFEkibSYUkkBqBQKBjhM4K2m9sScjOEf2/+i6+Lb06rlRKFAhwqaI7aX0HCC7h5kKRLwTw5/id2z8Mh8rTm2D8TVKbgWuvV8KFDRc0QpESSi5AOSyIxkJJ2Jenq0ZUlZ5Yw/vB4fJx8MDMye3vGnMTYDEo0QO1Sh39fVKe5bw2Mbya//9oFT+5ohhOvhmjkLQq/6n2VbPgyFF8iyVmkw5JIMsDnnp/z97W/uf30NotOL+JLry9zWiXDsCwCldpqDiHg/sVXw4fX/4PY+3BqneYAKFLuVe/LrQ6YWOas/pL3EumwJJIMYGFswXc1vmPQv4NYfGoxH5X4iOI2xXNarYyhUECRspqj5heQGA+3Dr/qfd0Jg3vnNcfB30BpDMVrQokGGifm5Jnt+3hJJCAdlkSSYZq4NqGWUy0O3D3A+MPj+a3RbygUqa1gkYcwMgG3upqj0fcQG61ZKio5fP7xDbi+V3PsGqdZ67BEg1fDh3Z51HFLcj3SYUkkGUShUDDMZxhtNrfhv9v/sevmLhoVb5TTamU9FgWhwseaQwiIvvra8OFeeP4QzmzUHACFSr02fFgXzNK/a7dEkhbSYUkkmcDd1p0eFXqw4NQCJh6eSC2nWlikut9VPkChgEIlNYd3b81ivLePaZzX1d1w6yg8uKw5Ds8HpREUq/Gy9/UBOFcBlWx2JBlD3jkSSSbpXbk3W65u4e6zuyw4tYCvq36d0yq9O1Qv32cVrwkNh8GLx3Bt78u1D3dremM3DmiOkJ/B1FYzWbrkB5rhw4IlctoCSR5COiyJJJOYG5kzxHsI3+z+hqVnltKyZEvcbd1zWq2cwcwWyn+oOQAeXn8VvHHtX41DO79Fc4BmF+bk3pd7fTC3yyHFJXkB6bAkkizgA5cPqFe0Hntv7+XnQz8zv/H8/BGAkVkKuEH1HppDnaSJOEwePrx5SOPQji3RHAolOFd91fsqVkPTg5NIXiIdlkSSBSgUCoZ5D+PQn4c4ePcg/4T/Q1O3pjmtVu5CqYJi1TWH72CIewLX970aPrx/UbP31+2jsGcSmFhrgjaSHVihUpp3aJL3FumwJJIswsXGhV6VejHnxBx+OfwL9YrWw9JYTrBNFVNrKNtUcwA8vvWq93VlNzyP1t37y9bl1dyvEg000YuS9wrpsCSSLKRnxZ78deUvbj29xdwTcxlYfWBOq5R3sC0GVbtqDrUaIk6+6n3dOAiPb0LYCs2BQjNhObn35eIDRqY5bYEkm5EOSyLJQsyMzBjmM4wvg7/k97O/06pkK0oVKJXTauU9lEpw9tIc9QI1e3+F73+1+3LU2df2/pr6cu+vOhrn5VpfM19Mku+QDksiyWLqF6tPQ5eG7L65m58O/cRi/8UyACOzmFhAaT/NARBz9+Vivbtf2/srCC4HYQw0MS6ASr0NSjXSDB9a2eeg8pKsQjosiSQbGOI9hAN3DnA08ih/X/ubD0t8mNMq5S9snMCro+YQAiLPaIcPRfh+zBMewsnVmgPAoRKUbKAZQixeS+79lUeRDksiyQaKWhWld+XezAybyZSjU/At5ou1iXVOq5U/USjAsaLmqDOAxOdPOLL+V3zsn6O6FgIRpyDy5bF/JhiZaZxWyZfzv+wryL2/8gjSYUkk2URAhQA2X9lMeEw4vx3/jSHeQ3JapfcDIzPu2VRE/UFzVMY/wtN7usOHT+5o/r66G4J+0Gy1krxwb4mGmt6bJFciHZZEkk2YqEwY7j2cvjv7sur8KlqXak3ZgmVzWq33D6siULmd5hAC7l14Fbxx/T94dg9OrdUcAEXKv+p9udaWe3/lIqTDkkiykdpFa9PYtTFB4UH8dOgnljZdilIhh59yDIUC7MtpjppfQGIc3Dz8yoHdOQ73zmmOg7+BykQTMp/swBw95fBhDiIdlkSSzXxX4zv+u/0fYVFhbL6ymdalWue0SpJkjEw1i/G614NGP7y299fL7VMe33y191fwWDAvCCV8X22fYueS0xa8V0iHJZFkM46Wjnzu+TnTjk1j2rFpNHRpiK2pbU6rJdHHm3t/Pbjyqvd1ba9m9Q2dvb9Kv3r3Jff+ynakw5JI3gFdy3flz8t/cvXxVWaGzWRkzZE5rZLkbSgUULiU5tDZ++tl7+v2UXhwSXO8vvdXcu9L7v2V5chvUyJ5BxirjBnhM4JeO3qx9sJaPi79MRUKVchptSSGoLP313B4/kgzVJjswB5ee7X31+6fNFutuNd/5cAKvqdbzmQh0mFJJO8Ibydvmrk3Y9u1bfx08Cd+b/67DMDIy5jbQfmPNAdA9LVXofPJe3+d+0tzABRwfzV8KPf+yhDSYUkk75BB1Qex59YeTt0/xfqL63G3dede7D2KWBShqn1VVEpVTqsoySgF3TVH9Z6v7f31svd167CmB3b0GhxdrNn7q2i1V72vYtXTtfdXUmI8x04u5Wb0Xo6djKSGZwAqI5N3YFzuIFc83s2ePRs3NzfMzMzw8fHh8OHDacqvW7eOcuXKYWZmRqVKldi6davOeSEEP/zwA05OTpibm+Pn58elS5ey0wSJJF3YW9jTz7MfAD8e/JGe//RkyN4h9PynJ/4b/NkZvjOHNZRkCcl7f/l+Bz23wZDr0HE1ePfRBGoINdw6Av9OhCVNYaI7/K8jHJoP9y/rXbx353/j8V9eld6nZzJPeZzep2fiv7wqO/8b/+7tyyFy3GGtWbOGwMBARo0aRWhoKJ6envj7+xMVFaVXfv/+/XTs2JFevXoRFhZG69atad26NadPn9bKTJo0iV9//ZW5c+dy6NAhLC0t8ff358WLF+/KLIkkVRwsHQAQ6DZKUbFRBIYESqeVHzG1hrLNoPkv8NVR+OY0tJwJFdpoQuXjn8CFrbBtMMyqBtMrweav4PQfEBvNzv/GE3h5JZFvtNhRSgi8vPK9cVo57rCmTp1K79696dGjBx4eHsydOxcLCwsWL16sV37GjBk0bdqUwYMHU758ecaNG0fVqlWZNWsWoOldTZ8+nZEjR9KqVSsqV67M8uXLuXPnDps2bXqHlkkkKUlSJ/HLkV/0nkt2YBMPTyRJnfQu1ZK8a+xcoGo3aLcEBl+BPiHQaBS41dNMVn58E0KXw/oeJE1yZ8KFFZq7441V/8XLzxMvriQpMf6dm/GuydF3WPHx8Rw7doxhw4Zp05RKJX5+fhw4cEBvngMHDhAYGKiT5u/vr3VG165dIyIiAj8/P+15W1tbfHx8OHDgAJ9++mmKMuPi4oiLi9N+jomJASAhIYGEhIR025Msa0ievER+tw+y38ajkUeJjI1M9bxAEBEbQfM/mmNhbJH1Cgh48uQJS/9eCvl1x5O8bGMBY7CrjSI+FuKfQfxTYtXxRBql/m5TKBREqODIiaVUq9wjVbn88LvNUYd1//59kpKScHBw0El3cHDg/PnzevNERETolY+IiNCeT05LTeZNxo8fz5gxY1Kk79ixAwsLwxuNoKAgg/PkJfK7fZB9Np6IP5EuuTvP7mRL/clEPk7daeYX8oWNKtIVjAFw9OReIm85pHo+NjY2i5TKOWSUIDBs2DCdXltMTAwuLi40adIEG5v0z1xPSEggKCiIxo0bY2ycvpssL5Hf7YPst9E+0p51weveKvdtlW8pU6BMltefmJjIsWPHqFatGkZG+fPnn99svHj1H6Zd3/RWueqV61GtcvNUzyePHOVlcvRqFi5cGJVKRWSk7pNQZGQkjo6OevM4OjqmKZ/8f2RkJE5OTjoyXl5eess0NTXF1NQ0RbqxsXGGGq2M5ssr5Hf7IPts9Hb2xsHCgajYqBRBFwAKFDhYONC9YvdsCXFPSEjg8cnH1ClWJ99ew/xmYy0nb1Zd2UiU8tU7q9dRCIGDmpch7qnbmx++ixwNujAxMaFatWoEBwdr09RqNcHBwdSqVUtvnlq1aunIg2b4Jlne3d0dR0dHHZmYmBgOHTqUapkSybtCpVQx1HsooHFOr5P8eYj3EDkfS6JFZWTC0DKdAY1zep3kz0PKdH4v5mPleJRgYGAgCxYsYNmyZZw7d44vvviCZ8+e0aOH5uVht27ddIIyvv76a7Zv386UKVM4f/48o0eP5ujRo/Tv3x8AhULBN998w48//sjmzZs5deoU3bp1w9nZmdatW+eEiRKJDn6ufkxtMBV7C3uddAcLB6Y2mIqfq18qOSXvK351hzG1VGfs1brpDmqYWqozfnWH6c+Yz8jxAd4OHTpw7949fvjhByIiIvDy8mL79u3aoIkbN26gfG3/mdq1a7Nq1SpGjhzJ8OHDKV26NJs2baJixYpame+++45nz57Rp08fHj16RN26ddm+fTtmZmbv3D6JRB9+rn40dGlIaFSoXOlCki786g6jYc2BHDmxlKMn91K9cr33bqWLHHdYAP3799f2kN4kJCQkRVq7du1o165dquUpFArGjh3L2LFjs0pFiSTLUSlV1HCskdNqSPIQKiMTqlXuQeQtB6pVbp7mO6v8SI4PCUokEolEkh6kw5JIJBJJnkA6LIlEIpHkCXLFO6zchngZKmroRLuEhARiY2OJiYnJF3Me3iS/2wf538b8bh/kfxszal9yeyb0rASfV5AOSw9PnjwBwMXFJYc1kUgkkqzlyZMn2Nra5rQaGUIh8rK7zSbUajV37tzB2toahZ6Z5amRvKTTzZs3DVrSKa+Q3+2D/G9jfrcP8r+NGbVPCMGTJ09wdnbWmSqUl5A9LD0olUqKFSuW4fw2Njb58oeSTH63D/K/jfndPsj/NmbEvrzas0omb7pZiUQikbx3SIclkUgkkjyBdFhZiKmpKaNGjdK78nt+IL/bB/nfxvxuH+R/G/O7fWkhgy4kEolEkieQPSyJRCKR5Amkw5JIJBJJnkA6LIlEIpHkCaTDkkgkEkmeQDqstzB79mzc3NwwMzPDx8eHw4cPpym/bt06ypUrh5mZGZUqVWLr1q0654UQ/PDDDzg5OWFubo6fnx+XLl3KThPSJKvtCwgIQKFQ6BxNmzbNThPSxBD7zpw5wyeffIKbmxsKhYLp06dnusx3QVbbOHr06BTXsFy5ctloQdoYYt+CBQuoV68eBQoUoECBAvj5+aWQz8u/wfTYl9t+g1mKkKTK6tWrhYmJiVi8eLE4c+aM6N27t7CzsxORkZF65fft2ydUKpWYNGmSOHv2rBg5cqQwNjYWp06d0spMmDBB2Nraik2bNokTJ06Ili1bCnd3d/H8+fN3ZZaW7LCve/fuomnTpuLu3bvaIzo6+l2ZpIOh9h0+fFgMGjRI/O9//xOOjo5i2rRpmS4zu8kOG0eNGiUqVKigcw3v3buXzZbox1D7OnXqJGbPni3CwsLEuXPnREBAgLC1tRW3bt3SyuTl32B67MtNv8GsRjqsNPD29hZffvml9nNSUpJwdnYW48eP1yvfvn170aJFC500Hx8f0bdvXyGEEGq1Wjg6OopffvlFe/7Ro0fC1NRU/O9//8sGC9Imq+0TQvNjadWqVbboayiG2vc6rq6uehvzzJSZHWSHjaNGjRKenp5ZqGXGyez3nZiYKKytrcWyZcuEEHn/N/gmb9onRO76DWY1ckgwFeLj4zl27Bh+fn7aNKVSiZ+fHwcOHNCb58CBAzryAP7+/lr5a9euERERoSNja2uLj49PqmVmF9lhXzIhISHY29tTtmxZvvjiCx48eJD1BryFjNiXE2VmhuzU59KlSzg7O1OiRAk6d+7MjRs3MquuwWSFfbGxsSQkJFCwYEEg7/8G3+RN+5LJDb/B7EA6rFS4f/8+SUlJODg46KQ7ODgQERGhN09ERESa8sn/G1JmdpEd9gE0bdqU5cuXExwczMSJE/n3339p1qwZSUlJWW9EGmTEvpwoMzNklz4+Pj4sXbqU7du3M2fOHK5du0a9evW02+68K7LCviFDhuDs7Kx1Cnn9N/gmb9oHuec3mB3I1dolWcqnn36q/btSpUpUrlyZkiVLEhISQqNGjXJQM0l6adasmfbvypUr4+Pjg6urK2vXrqVXr145qJlhTJgwgdWrVxMSEoKZmVlOq5PlpGZffv4Nyh5WKhQuXBiVSkVkZKROemRkJI6OjnrzODo6pimf/L8hZWYX2WGfPkqUKEHhwoW5fPly5pU2gIzYlxNlZoZ3pY+dnR1lypTJU9dw8uTJTJgwgR07dlC5cmVtel7/DSaTmn36yKnfYHYgHVYqmJiYUK1aNYKDg7VparWa4OBgatWqpTdPrVq1dOQBgoKCtPLu7u44OjrqyMTExHDo0KFUy8wussM+fdy6dYsHDx7g5OSUNYqnk4zYlxNlZoZ3pc/Tp0+5cuVKnrmGkyZNYty4cWzfvp3q1avrnMvrv0FI2z595NRvMFvI6aiP3Mzq1auFqampWLp0qTh79qzo06ePsLOzExEREUIIIbp27SqGDh2qld+3b58wMjISkydPFufOnROjRo3SG9ZuZ2cn/vzzT3Hy5EnRqlWrHA2pzUr7njx5IgYNGiQOHDggrl27Jnbu3CmqVq0qSpcuLV68eJHr7YuLixNhYWEiLCxMODk5iUGDBomwsDBx6dKldJf5rskOGwcOHChCQkLEtWvXxL59+4Sfn58oXLiwiIqKyvX2TZgwQZiYmIj169frhHU/efJERyav/gbfZl9u+w1mNdJhvYWZM2eK4sWLCxMTE+Ht7S0OHjyoPefr6yu6d++uI7927VpRpkwZYWJiIipUqCD+/vtvnfNqtVp8//33wsHBQZiamopGjRqJCxcuvAtT9JKV9sXGxoomTZqIIkWKCGNjY+Hq6ip69+6dY425EIbZd+3aNQGkOHx9fdNdZk6Q1TZ26NBBODk5CRMTE1G0aFHRoUMHcfny5XdokS6G2Ofq6qrXvlGjRmll8vJv8G325cbfYFYitxeRSCQSSZ5AvsOSSCQSSZ5AOiyJRCKR5Amkw5JIJBJJnkA6LIlEIpHkCaTDkkgkEkmeQDosiUQikeQJpMOSSCQSSZ5AOiyJRCKR5Amkw5JI8hlLly7Fzs4u15WVnQQEBNC6deucVkOSzUiH9R6Sn3/cS5cuRaFQUL58+RTn1q1bh0KhwM3NLVt1uH79OgqFQnuYmJhQqlQpfvzxR3LLwjKv62dpaUnp0qUJCAjg2LFjOnIdOnTg4sWLOaRl+pkxYwZLly7NaTUk2Yx0WJIcQQhBYmJitpRtaWlJVFRUil1bFy1aRPHixbOlTn3s3LmTu3fvcunSJcaMGcNPP/3E4sWL31n9b2PJkiXcvXuXM2fOMHv2bJ4+fYqPjw/Lly/Xypibm2Nvb5+DWqYPW1vbPNETlGQO6bAkNGjQgAEDBvDdd99RsGBBHB0dGT16tPZ8p06d6NChg06ehIQEChcurG3c1Go148ePx93dHXNzczw9PVm/fr1WPiQkBIVCwbZt26hWrRqmpqb8999/nDhxgoYNG2JtbY2NjQ3VqlXj6NGj2nz//fcf9erVw9zcHBcXFwYMGMCzZ8/StMfIyIhOnTrpOIdbt24REhJCp06ddGSvXLlCq1atcHBwwMrKiho1arBz507t+fPnz2NhYcGqVau0aWvXrsXc3JyzZ8+mqUehQoVwdHTE1dWVzp07U6dOHUJDQ7Xn1Wo1Y8eOpVixYpiamuLl5cX27du155N7an/88QcNGzbEwsICT0/PFI546dKlFC9eHAsLCz7++ON0b4duZ2eHo6Mjbm5uNGnShPXr19O5c2f69+/Pw4cPtWW/7ghGjx6Nl5cXixcvpnjx4lhZWdGvXz+SkpKYNGkSjo6O2Nvb89NPP+nU9ejRIz777DOKFCmCjY0NH3zwASdOnEhR7ooVK3Bzc8PW1pZPP/1UZ5fj9evXU6lSJczNzSlUqBB+fn7ae+HNUYO4uDgGDBiAvb09ZmZm1K1blyNHjmjPJ9+PwcHBVK9eHQsLC2rXrs2FCxfS9d1JcoicXXtXkhN0795dtGrVSvvZ19dX2NjYiNGjR4uLFy+KZcuWCYVCIXbs2CGEEGLLli3C3NxcZ4uGv/76S5ibm4uYmBghhBA//vijKFeunNi+fbu4cuWKWLJkiTA1NRUhISFCCCF2794tAFG5cmWxY8cOcfnyZfHgwQNRoUIF0aVLF3Hu3Dlx8eJFsXbtWnH8+HEhhBCXL18WlpaWYtq0aeLixYti3759okqVKiIgICBV25YsWSJsbW1FaGiosLGxEc+ePRNCCDFu3DjRqlUrMW3aNOHq6qqVP378uJg7d644deqUuHjxohg5cqQwMzMT4eHhWpnZs2cLW1tbER4eLm7evCkKFCggZsyYkaoOySuih4WFadOOHDki7OzsxLJly7RpU6dOFTY2NuJ///ufOH/+vPjuu++EsbGxuHjxok455cqVE1u2bBEXLlwQbdu2Fa6uriIhIUEIIcTBgweFUqkUEydOFBcuXBAzZswQdnZ2wtbWNlX9hBACEBs3bkyRHhYWJgCxZs0ane8zmVGjRgkrKyvRtm1bcebMGbF582ZhYmIi/P39xVdffSXOnz8vFi9eLACdVcf9/PzERx99JI4cOSIuXrwoBg4cKAoVKiQePHigU26bNm3EqVOnxJ49e4Sjo6MYPny4EEKIO3fuCCMjIzF16lRx7do1cfLkSTF79mztPfnmPT1gwADh7Owstm7dKs6cOSO6d+8uChQooK0v+X708fERISEh4syZM6JevXqidu3aaX5vkpxFOqz3EH0Oq27dujoyNWrUEEOGDBFCCJGQkCAKFy4sli9frj3fsWNH0aFDByGEEC9evBAWFhZi//79OmX06tVLdOzYUQjxqoHYtGmTjoy1tbVYunSpXj179eol+vTpo5O2d+9eoVQqU9276PUG1svLSyxbtkyo1WpRsmRJ8eeff6ZwWPqoUKGCmDlzpk5aixYtRL169USjRo1EkyZNhFqtTjV/sqMxNzcXlpaWwtjYWAApbHF2dhY//fSTTlqNGjVEv379dMpZuHCh9vyZM2cEIM6dOyeE0FyH5s2b65TRoUOHDDus58+fC0BMnDhRCKHfYVlYWGgfVIQQwt/fX7i5uYmkpCRtWtmyZcX48eOFEJprZmNjk2I/ppIlS4p58+alWu7gwYOFj4+PEEKIY8eOCUBcv35drz2v39NPnz4VxsbGYuXKldrz8fHxwtnZWUyaNEkI8ep+3Llzp1bm77//FkCO7IslSR9ySFACkGKbbScnJ6KiogDNEFv79u1ZuXIlAM+ePePPP/+kc+fOAFy+fJnY2FgaN26MlZWV9li+fDlXrlzRKffNHVIDAwP57LPP8PPzY8KECTryJ06cYOnSpTpl+vv7o1aruXbt2ltt6tmzJ0uWLOHff//l2bNnNG/ePIXM06dPGTRoEOXLl8fOzg4rKyvOnTvHjRs3dOQWL17MyZMnCQ0N1QZ2vI01a9Zw/PhxTpw4wdq1a/nzzz8ZOnQooNnl9s6dO9SpU0cnT506dTh37pxO2uvXJnnX2ORrc+7cOXx8fHTkM7NzrngZFJKWfW5ublhbW2s/Ozg44OHhgVKp1ElL1vHEiRM8ffqUQoUK6VzLa9eu6VzvN8t9/R709PSkUaNGVKpUiXbt2rFgwQLtsOWbXLlyhYSEBJ3v1tjYGG9vb4O+W0nuwyinFZDkDoyNjXU+KxQK1Gq19nPnzp3x9fUlKiqKoKAgzM3Nadq0KaBp9AH+/vtvihYtqlOOqampzmdLS0udz6NHj6ZTp078/fffbNu2jVGjRrF69Wo+/vhjnj59St++fRkwYEAKfdMTPNG5c2e+++47Ro8eTdeuXTEySnm7Dxo0iKCgICZPnkypUqUwNzenbdu2xMfH68idOHGCZ8+eoVQquXv3brq2G3dxcaFUqVIAlC9fnitXrvD999/rvB9MD69fm2RH8vq1yUqSG3R3d/d06ZOsU1r3z9OnT3FyciIkJCRFWa+/H0urDJVKRVBQEPv372fHjh3MnDmTESNGcOjQoTR1fRvv8ruVZB7psCTponbt2ri4uLBmzRq2bdtGu3bttD92Dw8PTE1NuXHjBr6+vgaXXaZMGcqUKcO3335Lx44dWbJkCR9//DFVq1bl7Nmz2kbfUAoWLEjLli1Zu3Ytc+fO1Suzb98+AgIC+PjjjwFN43r9+nUdmejoaAICAhgxYgR3796lc+fOhIaGYm5ubpA+KpWKxMRE4uPjsbGxwdnZmX379ul8Z/v27cPb2zvdZZYvX55Dhw7ppB08eNAgvV5n+vTp2NjY4Ofnl+Ey3qRq1apERERgZGSUqSkFCoWCOnXqUKdOHX744QdcXV3ZuHEjgYGBOnIlS5bExMSEffv24erqCmiChI4cOcI333yTCUskOY10WJJ006lTJ+bOncvFixfZvXu3Nt3a2ppBgwbx7bffolarqVu3Lo8fP2bfvn3Y2NjQvXt3veU9f/6cwYMH07ZtW9zd3bl16xZHjhzhk08+AWDIkCHUrFmT/v3789lnn2FpacnZs2cJCgpi1qxZ6dJ56dKl/PbbbxQqVEjv+dKlS/PHH3/w0UcfoVAo+P7771M8YX/++ee4uLgwcuRI4uLiqFKlCoMGDWL27Nlp1v3gwQMiIiL4f/t275JcGMZx/Cs6FIFY2BuBDmJDU0hDLxYIEhRBL6sUWFOLS0iQkYSEISk5RkMg/QERJDg01KaLQVuDo1QSlEEQRDY8PEFUPg4Rz4HfZz2c63Cd5cd939f98vLC5eUl6XQan8+H1WoFIBwOE41Gcblc9Pf3c3BwwMXFxfvWayNCoRAjIyPs7OwwPT1NLpf7MGlYz/39PdfX1zw/P3N1dcXe3h5HR0dkMpkfHRH3+/0MDQ0xMzNDIpGgt7eXcrnMyckJs7Ozn7aJv5LP5zk9PWV8fJyOjg7y+TyVSuXL+3YtLS0sLy8TDodpa2vD4XCQSCR4enpiaWnpx/qS36fAkoYFAgG2trZwOp2fzl5isRjt7e3E43FKpRI2mw2Px8Pa2tq39cxmM3d3dywsLHBzc4Pdbmdubo7NzU3gz/nC2dkZkUiE0dFRarUaLpfr04h9Pc3NzXVXQqlUisXFRYaHh7Hb7ayurlKtVt+fZzIZstksxWIRi8WCxWLh8PAQr9fL1NQUExMT39b+u0oxm810d3czOTn5Ydw7FArx8PDAysoKt7e39PX1cXx8jNvtbri/wcFB9vf3iUajbGxs4Pf7WV9fJxaL/fPdYDAIQFNTEz09PXi9XgqFAh6Pp+HvN8JkMpHNZolEIgSDQSqVCl1dXYyNjdHZ2dlQDavVyvn5Obu7u1SrVZxOJ8lk8tv/v729zevrK/Pz8zw+PjIwMEAul6O1tfUnW5NfZqrV/pOr9yIiInVoSlBERAxBgSUiIoagwBIREUNQYImIiCEosERExBAUWCIiYggKLBERMQQFloiIGIICS0REDEGBJSIihqDAEhERQ3gDXPsJFFYkx+wAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 400x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.figure(figsize=(4, 3))\n",
     "plt.plot(inv_bond_dims, logical_values[1], marker=\"o\", label=f\"Pr(X)\")\n",
@@ -556,22 +617,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
-    "one_qubit_paulis = list(pt.ipauli(n_qubits=len(code), min_weight=1, max_weight=1))\n",
-    "two_qubit_paulis = list(pt.ipauli(n_qubits=len(code), min_weight=2, max_weight=2))[:99]"
+    "one_qubit_paulis = pt.ipauli(n_qubits=num_qubits, min_weight=1, max_weight=1)\n",
+    "two_qubit_paulis = pt.ipauli(n_qubits=num_qubits, min_weight=2, max_weight=2)\n",
+    "three_qubit_paulis = pt.ipauli(n_qubits=num_qubits, min_weight=3, max_weight=3)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "15it [00:00, 67.94it/s]\n"
+     ]
+    }
+   ],
    "source": [
     "one_qubit_outputs = [\n",
-    "    decode_css(code, error, bias_type=\"Bitflip\", renormalise=renormalise, silent=True)\n",
+    "    decode_custom(\n",
+    "        stabilizers=stabilizer_generators,\n",
+    "        x_logicals=x_logical_operators,\n",
+    "        z_logicals=z_logical_operators,\n",
+    "        error=error,\n",
+    "        chi_max=1e4,\n",
+    "        bias_type=\"Bitflip\",\n",
+    "        bias_prob=0,\n",
+    "        silent=True,\n",
+    "    )\n",
     "    for error in tqdm(one_qubit_paulis)\n",
     "]\n",
     "one_qubit_corrections_distribution = [output[0] for output in one_qubit_outputs]"
@@ -579,17 +658,64 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "90it [00:59,  1.51it/s]\n"
+     ]
+    }
+   ],
    "source": [
     "two_qubit_outputs = [\n",
-    "    decode_css(code, error, bias_type=\"Bitflip\", renormalise=renormalise, silent=True)\n",
+    "    decode_custom(\n",
+    "        stabilizers=stabilizer_generators,\n",
+    "        x_logicals=x_logical_operators,\n",
+    "        z_logicals=z_logical_operators,\n",
+    "        error=error,\n",
+    "        chi_max=1e4,\n",
+    "        bias_type=\"Bitflip\",\n",
+    "        bias_prob=0.1,\n",
+    "        silent=True,\n",
+    "    )\n",
     "    for error in tqdm(two_qubit_paulis)\n",
     "]\n",
     "two_qubit_corrections_distribution = [output[0] for output in two_qubit_outputs]"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "270it [03:01,  1.49it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "three_qubit_outputs = [\n",
+    "    decode_custom(\n",
+    "        stabilizers=stabilizer_generators,\n",
+    "        x_logicals=x_logical_operators,\n",
+    "        z_logicals=z_logical_operators,\n",
+    "        error=error,\n",
+    "        chi_max=1e4,\n",
+    "        bias_type=\"Bitflip\",\n",
+    "        bias_prob=0.1,\n",
+    "        silent=True,\n",
+    "    )\n",
+    "    for error in tqdm(three_qubit_paulis)\n",
+    "]\n",
+    "three_qubit_corrections_distribution = [output[0] for output in three_qubit_outputs]"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 25,
@@ -609,9 +735,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.hist(map_distribution_to_pauli(one_qubit_corrections_distribution))\n",
     "plt.show()"
@@ -619,77 +756,115 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 27,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.hist(map_distribution_to_pauli(two_qubit_corrections_distribution))\n",
     "plt.show()"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's now check by hand that some of the decoder's nontrivial outputs are indeed correct. First of all, from all one-qubit errors we get the Identity operator which corresponds to the fact that the surface code of distance $d$ (equal to 3 in our case) corrects errors on up to $ \\lfloor \\frac{d-1}{2} \\rfloor $ qubits. However, some of the two-qubit errors can be corrected as well. Let's check some of them. For this, let's take a look at the first 20 errors which result in the Identity logical operator as the output."
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 28,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "limit = 20\n",
-    "for i, correction in enumerate(\n",
-    "    map_distribution_to_pauli(two_qubit_corrections_distribution)\n",
-    "):\n",
-    "    if correction == \"I\":\n",
-    "        print(two_qubit_paulis[i])\n",
-    "    if i > limit:\n",
-    "        break"
+    "plt.hist(map_distribution_to_pauli(three_qubit_corrections_distribution))\n",
+    "plt.show()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To be able to track which parity check is triggered by which error, let's plot the tensor network we are building."
+    "Let's now check by hand that some of the decoder's nontrivial outputs are indeed correct. First of all, from all one-qubit errors we get the Identity operator which corresponds to the fact that the 5-qubit code corrects all one-qubit errors. However, this code can also correct some two-qubit errors."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [],
    "source": [
-    "plot_parity_check_mpo(code)"
+    "one_qubit_paulis = list(pt.ipauli(n_qubits=num_qubits, min_weight=1, max_weight=1))\n",
+    "two_qubit_paulis = list(pt.ipauli(n_qubits=num_qubits, min_weight=2, max_weight=2))\n",
+    "three_qubit_paulis = list(pt.ipauli(n_qubits=num_qubits, min_weight=3, max_weight=3))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We now want to dive a bit more into what is happening inside the decoder to be able to better understand the results. For example, the first error $(X_0 Z_1)$ from the list above would trigger the first $X$ parity check (parity check index 2) as well as the second $Z$ parity check (index 9). In the current setup the stabilisers are being set to $0$, which is the result of the fact that the $\\text{XOR}$ tensors we use project out the inputs of odd (i.e., equal to $1$) parity. After applying the logical-operator MPOs and performing marginalization, the process yields a marginal distribution over codewords, each reflecting different parities of the logical operators."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's now take a look at the errors which result in the $X$ logical operator as the output."
+    "Let's take a look at the errors which result in the Identity logical operator as the output."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 30,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ZIYII\n",
+      "YIZII\n",
+      "YIYII\n",
+      "XIIXI\n",
+      "YIIYI\n",
+      "XIIIX\n",
+      "YIIIX\n",
+      "YIIIY\n",
+      "IXXII\n",
+      "IXYII\n",
+      "IYXII\n",
+      "IYYII\n",
+      "IXIXI\n",
+      "IXIYI\n",
+      "IZIYI\n",
+      "IYIYI\n",
+      "IXIIY\n",
+      "IYIIZ\n",
+      "IYIIY\n",
+      "IIXYI\n",
+      "IIZZI\n",
+      "IIXIY\n",
+      "IIYIX\n",
+      "IIIXX\n",
+      "IIIZZ\n",
+      "IIIYX\n",
+      "IIIYY\n"
+     ]
+    }
+   ],
    "source": [
     "for i, correction in enumerate(\n",
     "    map_distribution_to_pauli(two_qubit_corrections_distribution)\n",
     "):\n",
-    "    if correction == \"X\":\n",
+    "    if correction == \"I\":\n",
     "        print(two_qubit_paulis[i])"
    ]
   },
@@ -697,160 +872,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Similarly to the previous case, the first error $(Y_0 Z_1)$ from the list above would trigger the first $X$ parity check which in its turn would trigger the $\\text{XOR}$ tensor corresponding to the $X$ logical-operator MPO therefore the $X$ logical as the most likely output."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Finally, let's take a look at how the MPO order optimisation looks visually and test the truncation effects."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "LATTICE_SIZE = 3\n",
-    "rep_code = qc.repetition_code(LATTICE_SIZE)\n",
-    "surface_code = qc.hypergraph_product(rep_code, rep_code)\n",
-    "\n",
-    "mpo_matrix_full_unoptimised = plot_parity_check_mpo(\n",
-    "    surface_code, optimise_order=False, return_matrix=True, plot_type=\"both\"\n",
-    ")\n",
-    "\n",
-    "mpo_matrix_xpart = plot_parity_check_mpo(\n",
-    "    surface_code, optimise_order=False, return_matrix=True, plot_type=\"X\"\n",
-    ")\n",
-    "\n",
-    "mpo_matrix_zpart = plot_parity_check_mpo(\n",
-    "    surface_code, optimise_order=False, return_matrix=True, plot_type=\"Z\"\n",
-    ")\n",
-    "\n",
-    "mpo_matrix_full = plot_parity_check_mpo(\n",
-    "    surface_code, optimise_order=True, return_matrix=True, plot_type=\"both\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "NUM_QUBITS = 2 * (LATTICE_SIZE - 1) * LATTICE_SIZE\n",
-    "NUM_EXPERIMENTS = 200\n",
-    "\n",
-    "SEED = 123\n",
-    "seed_seq = np.random.SeedSequence(SEED)\n",
-    "errors = {}\n",
-    "\n",
-    "max_bond_dims = [128, 64, 32, 16, 8, 4]\n",
-    "error_rates = np.linspace(0.05, 0.40, 11)\n",
-    "failures_statistics = {}\n",
-    "\n",
-    "rep_code = qc.repetition_code(LATTICE_SIZE)\n",
-    "surface_code = qc.hypergraph_product(rep_code, rep_code)\n",
-    "\n",
-    "for ERROR_RATE in error_rates:\n",
-    "    errors[LATTICE_SIZE, ERROR_RATE] = []\n",
-    "    for l in range(NUM_EXPERIMENTS):\n",
-    "        rng = np.random.default_rng(seed_seq.spawn(1)[0])\n",
-    "        random_integer = rng.integers(1, 10**8 + 1)\n",
-    "        SEED = random_integer\n",
-    "\n",
-    "        error = generate_pauli_error_string(\n",
-    "            len(surface_code),\n",
-    "            ERROR_RATE,\n",
-    "            seed=SEED,\n",
-    "            error_model=\"Bit Flip\",\n",
-    "        )\n",
-    "        errors[LATTICE_SIZE, ERROR_RATE].append(error)\n",
-    "\n",
-    "for CHI_MAX in max_bond_dims:\n",
-    "    print(f\"CHI_MAX = {CHI_MAX}\")\n",
-    "    for ERROR_RATE in tqdm(error_rates):\n",
-    "        failures = []\n",
-    "\n",
-    "        for l in range(NUM_EXPERIMENTS):\n",
-    "            error = errors[LATTICE_SIZE, ERROR_RATE][l]\n",
-    "            _, success = decode_css(\n",
-    "                code=surface_code,\n",
-    "                error=error,\n",
-    "                chi_max=CHI_MAX,\n",
-    "                multiply_by_stabiliser=True,\n",
-    "                bias_type=\"Bit Flip\",\n",
-    "                bias_prob=0.05,\n",
-    "                renormalise=True,\n",
-    "                silent=True,\n",
-    "                contraction_strategy=\"Optimised\",\n",
-    "            )\n",
-    "            failures.append(1 - success)\n",
-    "\n",
-    "        failures_statistics[LATTICE_SIZE, CHI_MAX, ERROR_RATE] = failures"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "failure_rates = {}\n",
-    "error_bars = {}\n",
-    "\n",
-    "for CHI_MAX in max_bond_dims:\n",
-    "    for ERROR_RATE in error_rates:\n",
-    "        failure_rates[LATTICE_SIZE, CHI_MAX, ERROR_RATE] = np.mean(\n",
-    "            failures_statistics[LATTICE_SIZE, CHI_MAX, ERROR_RATE]\n",
-    "        )\n",
-    "        error_bars[LATTICE_SIZE, CHI_MAX, ERROR_RATE] = sem(\n",
-    "            failures_statistics[LATTICE_SIZE, CHI_MAX, ERROR_RATE]\n",
-    "        )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "plt.figure(figsize=(5, 4))\n",
+    "We now  dive a bit more into what is happening inside the decoder to be able to better understand the results. For example, the first error $(Z_0 Y_2)$ from the list above would trigger all the parity checks. This can be seen from the actual tensor network we are building (see the image below). However, in the current setup the stabilisers are being set to $0$, which is the result of the fact that the $\\text{XOR}$ tensors we use project out the inputs of odd (i.e., equal to $1$) parity. After applying the logical-operator MPOs and performing marginalization, the process yields a marginal distribution over codewords, each reflecting different parities of the logical operators.\n",
     "\n",
-    "green_cmap = colormaps[\"viridis_r\"]\n",
-    "norm = Normalize(vmin=0, vmax=len(max_bond_dims) - 1)\n",
-    "\n",
-    "for index, CHI_MAX in enumerate(max_bond_dims):\n",
-    "    plt.errorbar(\n",
-    "        error_rates,\n",
-    "        [\n",
-    "            failure_rates[LATTICE_SIZE, CHI_MAX, ERROR_RATE]\n",
-    "            for ERROR_RATE in error_rates\n",
-    "        ],\n",
-    "        yerr=[\n",
-    "            error_bars[LATTICE_SIZE, CHI_MAX, ERROR_RATE] for ERROR_RATE in error_rates\n",
-    "        ],\n",
-    "        fmt=\"o--\",\n",
-    "        label=f\"Lattice size: {LATTICE_SIZE}, max bond dim: {CHI_MAX}\",\n",
-    "        linewidth=3,\n",
-    "        color=green_cmap(norm(index)),\n",
-    "    )\n",
-    "\n",
-    "plt.legend(fontsize=7)\n",
-    "plt.xlabel(\"Error rate\")\n",
-    "plt.ylabel(\"Failure rate\")\n",
-    "plt.grid()\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Great, so, we see the convergence in bond dimension (given bitflip noise, we converege to optimal decoding at the bond dimension equal to $2^6$ where $6$ is the maximum number of leg crossings encountered while applying MPOs, thus the curves with bond dimensions $2^6$ and $2^7$ are identically the same). Besides, we see how the curve moves to the right as we increase the bond dimension cutoff which is expected behaviour."
+    "<img src=\"5-qubit-decoder.png\" alt=\"Tensor-network error-based decoder for the 5-qubit code.\"/>"
    ]
   }
  ],
diff --git a/docs/source/quantum_surface.ipynb b/docs/source/quantum_surface.ipynb
index 373100c..6f233a2 100644
--- a/docs/source/quantum_surface.ipynb
+++ b/docs/source/quantum_surface.ipynb
@@ -230,12 +230,12 @@
     }
    ],
    "source": [
-    "constraints_sites = css_code_constraint_sites(code)\n",
+    "constraint_sites = css_code_constraint_sites(code)\n",
     "print(\"Full X-check lists of sites:\")\n",
-    "for string in constraints_sites[0]:\n",
+    "for string in constraint_sites[0]:\n",
     "    print(string)\n",
     "print(\"Full Z-check lists of sites:\")\n",
-    "for string in constraints_sites[1]:\n",
+    "for string in constraint_sites[1]:\n",
     "    print(string)"
    ]
   },
@@ -381,7 +381,7 @@
     "for i in [0, 1]:\n",
     "    error_mps, entrps, bnd_dims = apply_constraints(\n",
     "        error_mps,\n",
-    "        constraints_sites[i],\n",
+    "        constraint_sites[i],\n",
     "        constraints_tensors,\n",
     "        renormalise=renormalise,\n",
     "        result_to_explicit=result_to_explicit,\n",
@@ -609,7 +609,7 @@
     "    for i in [0, 1]:\n",
     "        error_mps = apply_constraints(\n",
     "            error_mps,\n",
-    "            constraints_sites[i],\n",
+    "            constraint_sites[i],\n",
     "            constraints_tensors,\n",
     "            renormalise=renormalise,\n",
     "            result_to_explicit=result_to_explicit,\n",
diff --git a/docs/source/shor.ipynb b/docs/source/shor.ipynb
index cc7cc70..4291f9d 100644
--- a/docs/source/shor.ipynb
+++ b/docs/source/shor.ipynb
@@ -216,12 +216,12 @@
     }
    ],
    "source": [
-    "constraints_sites = css_code_constraint_sites(code)\n",
+    "constraint_sites = css_code_constraint_sites(code)\n",
     "print(\"Full X-check lists of sites:\")\n",
-    "for string in constraints_sites[0]:\n",
+    "for string in constraint_sites[0]:\n",
     "    print(string)\n",
     "print(\"Full Z-check lists of sites:\")\n",
-    "for string in constraints_sites[1]:\n",
+    "for string in constraint_sites[1]:\n",
     "    print(string)"
    ]
   },
@@ -362,7 +362,7 @@
     "for i in [0, 1]:\n",
     "    error_mps = apply_constraints(\n",
     "        error_mps,\n",
-    "        constraints_sites[i],\n",
+    "        constraint_sites[i],\n",
     "        constraints_tensors,\n",
     "        renormalise=renormalise,\n",
     "        result_to_explicit=result_to_explicit,\n",