diff --git a/double_bracket_flow_as_a_diagonalization_quantum_algorithm b/double_bracket_flow_as_a_diagonalization_quantum_algorithm
new file mode 160000
index 0000000000..808dd6325b
--- /dev/null
+++ b/double_bracket_flow_as_a_diagonalization_quantum_algorithm
@@ -0,0 +1 @@
+Subproject commit 808dd6325b327a756a4b6ae5a4d560e01d1790cb
diff --git a/examples/dbi/dbi_cost_functions_and_d_gradients_tutorial.ipynb b/examples/dbi/dbi_cost_functions_and_d_gradients_tutorial.ipynb
new file mode 100644
index 0000000000..569fef850f
--- /dev/null
+++ b/examples/dbi/dbi_cost_functions_and_d_gradients_tutorial.ipynb
@@ -0,0 +1,705 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Double-bracket Iteration other cost functions and respective scheduling\n",
+    "\n",
+    "This notebook presents two additional cost functions for the double-bracket flow: least-squares and energy fluctuation with their respectice scheduling methods."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from copy import deepcopy\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from qibo import hamiltonians, set_backend\n",
+    "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n",
+    "from qibo.models.dbi.utils import *\n",
+    "from qibo.models.dbi.utils_scheduling import *"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Least-squares\n",
+    "\n",
+    "The cost function is defined as: $\\frac{1}{2}||D-H_k||^2 =\\frac{1}{2}(||D||^2+||H||^2) -Tr(D H_k)$ as in (the negative of https://epubs.siam.org/doi/abs/10.1137/S0036141092229732?journalCode=sjmael) We seek to minimize this function at each DBF iteration. For numerical optimizations, we also ignore the norm of H term as for a given hamiltonian it is fixed through out the flow.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"numpy\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 5\n",
+    "h = 3.0\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# define the least-squares cost function\n",
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# generate data for plotting sigma decrease of the first step\n",
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))/2**nqubits\n",
+    "s_space = np.linspace(1e-5, 1.0, 500)\n",
+    "off_diagonal_norm_diff = []\n",
+    "potential = []\n",
+    "for s in s_space:\n",
+    "    dbi_eval = deepcopy(dbi)\n",
+    "    dbi_eval(s,d=d)\n",
+    "    off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n",
+    "    potential.append(dbi_eval.least_squares(d=d))\n",
+    "\n",
+    "# grid_search\n",
+    "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n",
+    "print('grid_search step:', step_grid)\n",
+    "# hyperopt\n",
+    "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n",
+    "print('hyperopt_search step:', step_hyperopt)\n",
+    "# polynomial\n",
+    "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n",
+    "print('polynomial_approximation step:', step_poly)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the results\n",
+    "plt.figure()\n",
+    "plt.plot(s_space, potential)\n",
+    "plt.xlabel('s')\n",
+    "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n",
+    "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n",
+    "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n",
+    "plt.title('First DBI step')\n",
+    "plt.ylabel('Least squares cost function')\n",
+    "plt.legend()\n",
+    "plt.figure()\n",
+    "plt.plot(s_space, off_diagonal_norm_diff)\n",
+    "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n",
+    "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n",
+    "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n",
+    "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n",
+    "plt.xlabel('s')\n",
+    "plt.title('First DBI step')\n",
+    "plt.legend()\n",
+    "print('The minimum for cost function in the tested range is:', step_grid)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Comparison of the least-squares cost function with the original cost function using the polynomial scheduling method"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n",
+    "off_diagonal_norm_diff_least_squares = [dbi.off_diagonal_norm]\n",
+    "iters = 100\n",
+    "dbi_ls = deepcopy(dbi)\n",
+    "cost = DoubleBracketCostFunction.off_diagonal_norm\n",
+    "dbi_od = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "for _ in range(iters):\n",
+    "    step_poly = dbi_od.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n",
+    "    dbi_od(step_poly,d=d)\n",
+    "    step_poly = dbi_ls.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n",
+    "    dbi_ls(step_poly,d=d)\n",
+    "    off_diagonal_norm_diff.append(dbi_od.off_diagonal_norm)\n",
+    "    off_diagonal_norm_diff_least_squares.append(dbi_ls.off_diagonal_norm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure()\n",
+    "plt.plot(range(iters+1), off_diagonal_norm_diff, label=r'Off-diagonal norm')\n",
+    "plt.plot(range(iters+1), off_diagonal_norm_diff_least_squares, label=r'Least squares')\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')\n",
+    "plt.legend()\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Energy fluctuation\n",
+    "\n",
+    "This cost function is defined as: $\\Xi_k^2 (\\mu) = \\langle \\mu | H_k^2| \\mu \\rangle - \\langle \\mu | H_k| \\mu \\rangle^2$. We must specify the state $| \\mu \\rangle$ for which we want to minimize the fluctuation. The overall diagonalization isn't guaranteed.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"numpy\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 3\n",
+    "h = 3.0\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# define the energy fluctuation cost function\n",
+    "cost = DoubleBracketCostFunction.off_diagonal_norm\n",
+    "# define the state\n",
+    "state = np.zeros(2**nqubits)\n",
+    "state[3] = 1\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost, ref_state=state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# generate data for plotting sigma decrease of the first step\n",
+    "d = np.diag(np.linspace(2**nqubits,1,2**nqubits))/2**nqubits\n",
+    "s_space = np.linspace(-1, 1, 1000)\n",
+    "off_diagonal_norm_diff = []\n",
+    "fluctuation = []\n",
+    "for s in s_space:\n",
+    "    dbi_eval = deepcopy(dbi)\n",
+    "    dbi_eval(s,d=d)\n",
+    "    off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n",
+    "    fluctuation.append(dbi_eval.energy_fluctuation(state=state))\n",
+    "\n",
+    "# grid_search\n",
+    "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n",
+    "print('grid_search step:', step_grid)\n",
+    "# hyperopt\n",
+    "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n",
+    "print('hyperopt_search step:', step_hyperopt)\n",
+    "# polynomial\n",
+    "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n",
+    "print('polynomial_approximation step:', step_poly)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the results\n",
+    "plt.figure()\n",
+    "plt.plot(s_space, fluctuation)\n",
+    "plt.xlabel('s')\n",
+    "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n",
+    "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label ='hyperopt')\n",
+    "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n",
+    "plt.title('First DBI step')\n",
+    "plt.ylabel('Energy fluctuation')\n",
+    "plt.legend()\n",
+    "plt.figure()\n",
+    "plt.plot(s_space, off_diagonal_norm_diff)\n",
+    "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n",
+    "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n",
+    "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n",
+    "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n",
+    "plt.xlabel('s')\n",
+    "plt.title('First DBI step')\n",
+    "plt.legend()\n",
+    "print('The minimum for cost function in the tested range is:', step_grid)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n",
+    "energy_fluc = [dbi.energy_fluctuation(state=state)]\n",
+    "iters = 10\n",
+    "dbi_ = deepcopy(dbi)\n",
+    "for _ in range(iters):\n",
+    "    step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n",
+    "    dbi_(step_poly,d=d)\n",
+    "    off_diagonal_norm_diff.append(dbi_.off_diagonal_norm)\n",
+    "    energy_fluc.append(dbi_.energy_fluctuation(state=state))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure()\n",
+    "plt.plot(range(iters+1), off_diagonal_norm_diff)\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(range(iters+1), energy_fluc)\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel(r'Energy fluctuation')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "iters = 30\n",
+    "states = [0,1,2,3,4,5,6,7]\n",
+    "energy = np.empty((len(states),iters))\n",
+    "\n",
+    "\n",
+    "d = (np.diag(np.linspace(1,2**nqubits,2**nqubits)))\n",
+    "for i in range(len(states)):\n",
+    "    dbi_ = deepcopy(dbi)\n",
+    "    dbi_.state = states[i]\n",
+    "    for j in range(iters):\n",
+    "        step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n",
+    "        if step_poly is not None:\n",
+    "            dbi_(step_poly, d=d)\n",
+    "        energy[i,j] = np.real(dbi_.h.matrix[states[i],states[i]])\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "eigvals = np.linalg.eigh(dbi_.h.matrix)[0]\n",
+    "print('Eigenvalues:', eigvals )\n",
+    "plt.figure()\n",
+    "for i in range(len(states)):\n",
+    "    plt.plot(range(iters), energy[i,:],'.', label='State ' + str(states[i]))\n",
+    "for eigvals in eigvals:\n",
+    "    plt.axhline(y=eigvals, color='r', linestyle='--')\n",
+    "plt.xlabel('Iterations')\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Gradients for finding optimal $D$\n",
+    "\n",
+    "An advantage of the least-squares cost function is that one can use gradient descent and the learning is more stable than with the off-diagonal cost function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qibo.models.dbi.utils_gradients import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"numpy\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 3\n",
+    "h = 3.0\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# define the energy fluctuation cost function\n",
+    "cost = DoubleBracketCostFunction.energy_fluctuation\n",
+    "# define the state\n",
+    "state = np.zeros(2**nqubits)\n",
+    "state[3] = 1\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost, ref_state=state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "nqubits = 5\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "params = np.linspace(1,2**nqubits,2**nqubits)\n",
+    "\n",
+    "step = 1e-2\n",
+    "iterations = 200\n",
+    "d, loss, grad, diags = gradient_descent_dbr_d_ansatz(dbi, params, iterations, step)\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(range(iterations+1), loss)\n",
+    "plt.xlabel('Learning iterations')\n",
+    "plt.ylabel('Loss: Least squares')\n",
+    "\n",
+    "plt.figure()\n",
+    "for i in range(2**nqubits):\n",
+    "    plt.plot(diags[i,:], label='State ' + str(i))\n",
+    "plt.xlabel('Learning iterations')\n",
+    "plt.ylabel('Diagonal elements')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Training for $D$ can greatly improve the decrease of the off-diagonal norm at each iteration. Nonetheless, during training the ascending values condition may be no longer satisfied creating a exponential decrease after few iterations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "nqubits = 5\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=3.0)\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "params = np.linspace(1,2**nqubits,2**nqubits)\n",
+    "d_fixed = np.diag(params)\n",
+    "dbi_trained = deepcopy(dbi)\n",
+    "flows = 50\n",
+    "iterations = 200\n",
+    "off_diagonal_norm = np.empty((2,flows+1))\n",
+    "off_diagonal_norm[0,0] = dbi_trained.off_diagonal_norm\n",
+    "off_diagonal_norm[1,0] = dbi.off_diagonal_norm\n",
+    "d_trained, loss, grad, diags = gradient_descent_dbr_d_ansatz(dbi_trained, params, iterations,step)\n",
+    "for i in range(flows):\n",
+    "\n",
+    "    s = dbi_trained.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d_trained, n=3)\n",
+    "    dbi_trained(s,d=d_trained)\n",
+    "    off_diagonal_norm[0,i+1] = dbi_trained.off_diagonal_norm\n",
+    "    s = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d_fixed, n=3)\n",
+    "    dbi(s,d=d_fixed)\n",
+    "    off_diagonal_norm[1,i+1] = dbi.off_diagonal_norm\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(off_diagonal_norm[0,:], label='Trained')\n",
+    "plt.plot(off_diagonal_norm[1,:], label='Untrained')\n",
+    "plt.legend()\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A solution can be to redo the training at each step, with a $D$ having ascending values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "nqubits = 5\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=3.0)\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "params = np.linspace(1,2**nqubits,2**nqubits)\n",
+    "d_fixed = np.diag(params)\n",
+    "dbi_trained = deepcopy(dbi)\n",
+    "flows = 50\n",
+    "iterations = 20\n",
+    "off_diagonal_norm = np.empty((2,flows+1))\n",
+    "off_diagonal_norm[0,0] = dbi_trained.off_diagonal_norm\n",
+    "off_diagonal_norm[1,0] = dbi.off_diagonal_norm\n",
+    "\n",
+    "for i in range(flows):\n",
+    "    d_trained, loss, grad, diags = gradient_descent_dbr_d_ansatz(dbi_trained, params, iterations,step)\n",
+    "    s = dbi_trained.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d_trained, n=3)\n",
+    "    dbi_trained(s,d=d_trained)\n",
+    "    off_diagonal_norm[0,i+1] = dbi_trained.off_diagonal_norm\n",
+    "    s = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d_fixed, n=3)\n",
+    "    dbi(s,d=d_fixed)\n",
+    "    off_diagonal_norm[1,i+1] = dbi.off_diagonal_norm\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(off_diagonal_norm[0,:], label='Trained')\n",
+    "plt.plot(off_diagonal_norm[1,:], label='Untrained')\n",
+    "plt.legend()\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The numerical gradients may be preferred as they decrease more the loss at each iteration and are computationally faster. They may be more precise as the previous analytic since the analytic computations use the polynomial approximation as a starting point"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nqubits = [3,4,5,6]\n",
+    "iterations = 30\n",
+    "step = 1e-2\n",
+    "differences = np.empty((len(nqubits),iterations+1))\n",
+    "loss_max = np.empty(len(nqubits))\n",
+    "for q in range(len(nqubits)):\n",
+    "    # define the hamiltonian\n",
+    "    H_TFIM = hamiltonians.TFIM(nqubits=nqubits[q], h=h)\n",
+    "\n",
+    "    # define the least-squares cost function\n",
+    "    cost = DoubleBracketCostFunction.least_squares\n",
+    "    # initialize class\n",
+    "    dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "    loss_max [q] = dbi.least_squares(d=np.diag(np.linspace(1,2**nqubits[q],2**nqubits[q])))\n",
+    "    params = np.linspace(1,2**nqubits[q],2**nqubits[q])\n",
+    "    d_analytic, loss_analytic, grad_analytic, diags_analytic = gradient_descent_dbr_d_ansatz(dbi, params, iterations, step)\n",
+    "    params = np.linspace(1,2**nqubits[q],2**nqubits[q])\n",
+    "    d_numerical, loss_numerical, grad_numerical, diags_numerical = gradient_descent_dbr_d_ansatz(dbi, params,iterations,step, analytic=False)\n",
+    "    differences[q,:] = loss_analytic - loss_numerical\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure()\n",
+    "for q in range(len(nqubits)):\n",
+    "    plt.plot(differences[q,:],label= 'nqubits = {}'.format(nqubits[q]))\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel('Difference in analytic and numerical loss function')\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.title('Normalized difference')\n",
+    "for q in range(len(nqubits)):\n",
+    "    plt.plot(differences[q,:]/loss_max[q],label= 'nqubits = {}'.format(nqubits[q]))\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel('Difference in analytic and numerical loss function')\n",
+    "plt.legend()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1-local ansatz\n",
+    "\n",
+    "We can consider, as an alternative to the a fully parametrized diagonal, a diagonal matrix of the form: $D = \\sum \\alpha_i Z_i$. This has the advantage of having a linear number of parameters to optimize instead of an exponential as well as being easier to implement in a quantum computer "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"numpy\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 5\n",
+    "h = 3.0\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# define the least-squares cost function\n",
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbi_eval = deepcopy(dbi)\n",
+    "params = np.linspace(1,2**nqubits,2**nqubits)\n",
+    "d_opt, loss_opt, grad_opt, diags_opt = gradient_descent_dbr_d_ansatz(dbi, params,  100,1e-2, analytic=False, d_type = d_ansatz_type.element_wise)\n",
+    "flows = 50\n",
+    "off_diagonal_norm = np.empty((flows+1,2))\n",
+    "off_diagonal_norm[0,:] = dbi_eval.off_diagonal_norm\n",
+    "for i in range(flows):\n",
+    "    step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d_opt,n=3)\n",
+    "    dbi_eval(step_poly,d=d_opt)\n",
+    "    off_diagonal_norm[i+1,0] = dbi_eval.off_diagonal_norm\n",
+    "\n",
+    "\n",
+    "\n",
+    "dbi_eval = deepcopy(dbi)\n",
+    "params = np.linspace(1,nqubits,nqubits)\n",
+    "d_opt, loss_opt, grad_opt, diags_opt = gradient_descent_dbr_d_ansatz(dbi, params,  30, 1e-3, analytic=False, d_type = d_ansatz_type.local_1)\n",
+    "best = np.argmin(loss_opt)\n",
+    "d_opt = d_ansatz(diags_opt[:,best], d_ansatz_type.local_1)\n",
+    "for i in range(flows):\n",
+    "    step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d_opt,n=3)\n",
+    "    dbi_eval(step_poly,d=d_opt)\n",
+    "    off_diagonal_norm[i+1,1] = dbi_eval.off_diagonal_norm\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure()\n",
+    "plt.plot(off_diagonal_norm[:,0],label='element-wise ansatz')\n",
+    "plt.plot(off_diagonal_norm[:,1],label='1-local ansatz')\n",
+    "plt.xlabel('Flows Iterations')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"numpy\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 5\n",
+    "h = 3.0\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# define the least-squares cost function\n",
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbi_eval = deepcopy(dbi)\n",
+    "params = np.linspace(1,nqubits,nqubits)\n",
+    "d_opt, loss_opt, grad_opt, diags_opt = gradient_descent_dbr_d_ansatz(dbi, params,  20, 1e-3, analytic=False, d_type = d_ansatz_type.local_1)\n",
+    "best = np.argmin(loss_opt)\n",
+    "\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(loss_opt)\n",
+    "\n",
+    "s = np.linspace(-0.1,0.1,100)\n",
+    "least_squares = np.empty(100)\n",
+    "off_diagonal_norm = np.empty(100)\n",
+    "for i in range(100):\n",
+    "    dbi_eval(s[i],d=d_opt)\n",
+    "    least_squares[i] = dbi_eval.least_squares(d=d_opt)\n",
+    "    off_diagonal_norm[i] = dbi_eval.off_diagonal_norm\n",
+    "plt.figure()\n",
+    "plt.plot(s,loss)\n",
+    "plt.xlabel('s')\n",
+    "plt.ylabel('Least squares cost function')\n",
+    "plt.figure()\n",
+    "plt.plot(s,off_diagonal_norm)\n",
+    "plt.xlabel('s')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')\n",
+    "\n",
+    "\n",
+    "print(np.diag(d_opt))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "dbi",
+   "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.7"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "43f1f904380137ff38e17e8a93371c4872e6bababc18e270d8a0497ea5c7ea38"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/dbi/dbi_costs.ipynb b/examples/dbi/dbi_costs.ipynb
new file mode 100644
index 0000000000..000fffd14f
--- /dev/null
+++ b/examples/dbi/dbi_costs.ipynb
@@ -0,0 +1,681 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Double-bracket Iteration other cost functions and respective scheduling\n",
+    "\n",
+    "This notebook presents two additional cost functions for the double-bracket flow: least-squares and energy fluctuation with their respectice scheduling methods."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 192,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from copy import deepcopy\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from qibo import hamiltonians, set_backend\n",
+    "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n",
+    "from qibo.models.dbi.utils import *\n",
+    "from qibo.models.dbi.utils_scheduling import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Least-squares\n",
+    "\n",
+    "The cost function is defined as: $\\frac{1}{2}||D-H_k||^2 =\\frac{1}{2}(||D||^2+||H||^2) -Tr(D H_k)$ as in https://epubs.siam.org/doi/abs/10.1137/S0036141092229732?journalCode=sjmael. We seek to maximize this function at each iteration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 184,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.5|INFO|2024-03-20 10:46:15]: Using qibojit (numba) backend on /CPU:0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"qibojit\", \"numba\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 9\n",
+    "h = 3.0\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# define the least-squares cost function\n",
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 189,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "grid_search step: 0.39394545454545454\n",
+      "hyperopt_search step: 0.017463998220887386\n",
+      "polynomial_approximation step: 0.0010293852957746303\n"
+     ]
+    }
+   ],
+   "source": [
+    "# generate data for plotting sigma decrease of the first step\n",
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))/2**nqubits\n",
+    "s_space = np.linspace(1e-5, 0.3, 100)\n",
+    "off_diagonal_norm_diff = []\n",
+    "potential = []\n",
+    "for s in s_space:\n",
+    "    dbi_eval = deepcopy(dbi)\n",
+    "    dbi_eval(s,d=d)\n",
+    "    off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n",
+    "    potential.append(dbi_eval.least_squares(D=d))\n",
+    "\n",
+    "# grid_search\n",
+    "#step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n",
+    "print('grid_search step:', step_grid)\n",
+    "# hyperopt\n",
+    "#step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n",
+    "print('hyperopt_search step:', step_hyperopt)\n",
+    "# polynomial\n",
+    "#step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n",
+    "print('polynomial_approximation step:', step_poly)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 191,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n",
+      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The minimum for cost function in the tested range is: 0.39394545454545454\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAHFCAYAAAAQU+iSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABQyklEQVR4nO3deXgTdeIG8HeSNOmdnrT0oC33TaGFcqhF5VQXPEAORUBAERFR1B+oK63rgrvC4ipyiEABFVCOxVtQEbkK9OIoN7S09CSUNj3TNpnfH0i0AiVtk06O9/M8eXw6nZm8GUfzduY7M4IoiiKIiIiI7IxM6gBERERElsCSQ0RERHaJJYeIiIjsEksOERER2SWWHCIiIrJLLDlERERkl1hyiIiIyC6x5BAREZFdYskhIiIiu8SSQ+TgEhISIAjCLV+vvPIKMjMzIQgCEhISzPaey5Yta9D6wsPDjZlkMhnUajU6deqEp556Cjt37rzlMn/9LG5ubujUqRPi4+NRXl5eZ95JkybB3d29KR/JqKGfjYgsRyF1ACKyDmvXrkXHjh3rTAsKCkJAQAAOHjyINm3amO29li1bBj8/P0yaNMnkZQYMGIBFixYBAMrKynDmzBls2rQJQ4cOxWOPPYaNGzfCycmpzjKjRo3CnDlzjMvs2bMHb7/9No4dO4atW7ea7fP8WWM+GxFZBksOEQEAunbtiujo6Fv+rm/fvndcvqKiAq6uruaOZeTl5VUnx6BBg/D8888jLi4O8fHxePPNN/Gvf/2rzjIBAQE3LXPp0iV89tlnqKqqgrOzs8XyEpH0eLqKiOp1q9NVcXFxEAQBKSkpGDVqFLy9vY1Hei5evIixY8ciKCgIKpUKAQEBuP/++5GWlgbg+qmn9PR07Nmzx3gqKTw8vNH54uLi0KVLFyxduhRVVVV3nF+tVkMQBMjl8ga/V1M/m1arxSuvvIKIiAgolUoEBwdj9uzZN50+EwQBM2fOxMqVK9G+fXuoVCp07twZmzZtanBmIkfGIzlEBADQ6/Wora2tM02hqP9/EY8++ijGjh2L6dOnG7+oH3jgAej1evz73/9Gq1atoNFocODAARQXFwMAtm/fjlGjRkGtVmPZsmUAAJVK1aTsf/vb3/Duu+8iKSkJd911l3G6KIrGz3TjdNW6deswduzYm05tmaIpn62iogKxsbG4fPkyXn/9dXTv3h3p6el46623cPz4cfz0008QBMH4Xl999RV2796Nt99+G25ubli2bBnGjRsHhUKBUaNGNXZTETkWkYgc2tq1a0UAt3zV1NSIGRkZIgBx7dq1xmXmz58vAhDfeuutOuvSaDQiAPH999+v9z27dOkixsbGmpwxLCxMfPDBB2/7++XLl4sAxM2bNxun3e4zDR8+XCwrK6uz/MSJE0U3N7d6MzT1sy1cuFCUyWTikSNH6kzfsmWLCED87rvv6mR3cXER8/PzjdNqa2vFjh07im3btq33/YnoDzySQ0QAgPXr16NTp051pt3pSM5jjz1W52cfHx+0adMG7733HvR6Pe6991706NEDMpllz4yLonjL6Y8//jheffVVAEBlZSXS0tLwj3/8A8OGDcNPP/3UoCNITf1s33zzDbp27YrIyMg6R8yGDh0KQRDw66+/Yvjw4cbp999/PwICAow/y+VyjBkzBvHx8bh8+TJCQkJMzk7kqDgmh4gAAJ06dUJ0dHSd1520bNmyzs+CIODnn3/G0KFD8e9//xu9evWCv78/Zs2ahdLSUktFx6VLlwBcvxrsz/z9/Y2f5e6778YLL7yADz74APv27WvwZd5N/WwFBQU4duwYnJyc6rw8PDwgiiI0Gk2d+QMDA29ax41pV69ebVB2IkfFIzlE1Gh/HkNyQ1hYGFavXg0AOHv2LL744gvExcWhuroaK1asMHsGURTx9ddfw83NzaRi1r17dwDA0aNHG/xeTflsfn5+cHFxwZo1a277+z/Lz8+/aZ4b03x9fRucncgRseQQkcW0b98eb775JrZu3YqUlBTjdJVKhcrKSrO8R3x8PE6ePInXX3/dpEvCb1wJ1aJFiya9b0M/20MPPYQFCxbA19cXERERd1z/zz//jIKCAuMpK71ej82bN6NNmzY8VUVkIpYcIjKbY8eOYebMmRg9ejTatWsHpVKJX375BceOHcPcuXON83Xr1g2bNm3C5s2b0bp1azg7O6Nbt271rru4uBiJiYkAgPLycuPNAPfu3YvHH38c8fHxNy1TUFBgXKaqqgppaWl455134OXlhcmTJzfrZ5s9eza2bt2Ke+65By+99BK6d+8Og8GArKws7Ny5E3PmzEFMTIxxPX5+frjvvvvw97//3Xh11enTp3kZOVEDsOQQkdkEBgaiTZs2WLZsGbKzsyEIAlq3bo3FixfjhRdeMM4XHx+PvLw8TJs2DaWlpQgLC0NmZma9696/fz/69etnfERDcHAw+vTpgzfffBNDhgy55TJbtmzBli1bAABOTk4IDQ3FiBEj8MYbbyAsLKxZP5ubmxv27t2Ld999Fx9//DEyMjLg4uKCVq1aYdCgQTfdK2jEiBHo0qUL3nzzTWRlZaFNmzb47LPPMGbMmAblJnJkgni7yxKIiEgSgiDg+eefx9KlS6WOQmTTeHUVERER2SWWHCIiIrJLHJNDRGRlOIqAyDx4JIeIiIjsEksOERER2SWWHCIiIrJLDj0mx2AwIDc3Fx4eHre8PT0RERFZH1EUUVpaiqCgoHofkuvQJSc3NxehoaFSxyAiIqJGyM7OrvcxJw5dcjw8PABc30ienp4SpyEiIiJTaLVahIaGGr/Hb8ehS86NU1Senp4sOURERDbmTkNNOPCYiIiI7BJLDhEREdkllhwiIiKySw49JoeIiIikodfrUVNTc8vfOTk5QS6XN/k9WHKIiIio2YiiiPz8fBQXF9c7n5eXFwIDA5t0HzuWHCIiImo2NwpOixYt4OrqelOJEUURFRUVKCwsBAC0bNmy0e/FkkNERETNQq/XGwuOr6/vbedzcXEBABQWFqJFixaNPnXFgcdERETULG6MwXF1db3jvDfmud24HVOw5BAREVGzMmWcjTmeKcmSQ0RERHbJ5kvOsmXLEBERAWdnZ0RFRWHv3r1SRyIiIiIrYNMlZ/PmzZg9ezbeeOMNpKam4u6778bw4cORlZUldTQiIiKSmE2XnP/85z+YMmUKpk6dik6dOuH9999HaGgoli9fLmmuwtIqXL5WgdziShRoq1BYWgVNmQ4lFTWorNZDbxAlzUdERCQlUbzz96Ap89yJzV5CXl1djeTkZMydO7fO9CFDhuDAgQO3XEan00Gn0xl/1mq1Fsn26pfHsOfslXrnkcsEqBQyuCrlcFHK4aZUwEUph7tKAU8XJ3g6O8HTRQG1ixO8XZXwcfvj5eemgqeLwiyDsoiIiJqLk5MTAKCiosJ4mfjtVFRU1FmmMWy25Gg0Guj1egQEBNSZHhAQgPz8/Fsus3DhQsTHx1s8m5NcBpVCBlEEDKIIvSjir4VUbxBRUa1HRbW+Ue+hUsjQwlOFFh7OCPBUoaXaBUFeLghSOyPIywXB3i7wdVOyCBERkdWQy+Xw8vIy3ujvTjcD9PLyatLjHWy25Nxwq41zuy/2efPm4eWXXzb+rNVqERoaavZMn0yMvmmaKIqoNYjQ1RpQ/ftLV6tHZY0e5To9Kqv1KK+uRVlVLbRVNdBWXv9ncUUNiiuqcbW8GkXl1bhWXo1SXS10tQZkF1Uiu6jytjnclHKE+rii1e+vcD83tPZ3Qxt/d7TwULEAERFRswsMDAQAY9G5nRuPdWgKmy05fn5+kMvlNx21KSwsvOnozg0qlQoqlao54t1EEAQ4yQU4yWVAEyNU1ehRqNWhsLQKhaU6FGirkF9ShZziSuQWVyK3uAoFpVUor9bjdH4pTueX3rQOd5UCrf3d0K6FBzoEuqNdgAc6BHigpdqZ5YeIiCxGEAS0bNkSLVq04AM6b0epVCIqKgq7du3CI488Ypy+a9cujBw5UsJklufsJEcrX1e08r39HSN1tXpcvlaJrKIKZBdVIFNTgQxNGS5qypFdVIEyXS2OXS7BscsldZbzdFagc5AnOrdU//5PT7QLcL9ezoiIiMxELpebpcjUx2ZLDgC8/PLLmDBhAqKjo9GvXz98/PHHyMrKwvTp06WOJjmVQo42/u5o4+9+0+90tXpkXa3A+cIynC0ow9nCUpzNL0WGphzaqlokXixC4sWiP61Lhi5Bnuge4oXuIWp0D/FCG383HvEhIiKrZtMlZ8yYMbh69Srefvtt5OXloWvXrvjuu+8QFhYmdTSrplLI0S7AA+0CPDC82x/TdbV6nC8sw8lcLU7maa//M1eLUl0tUrKKkZJVbJzXy9UJPUO90KuVN6LCvBHZyguuSpvenYiIyM4IojkuRLdRWq0WarUaJSUl8PT0lDqOVTIYRGReLTee2jp2uRjHc0qgqzXUmU8hE9A1WI2YCB/0ifBBdJgP1K6Nv+yPiIjodkz9/mbJYclpsOpaA07laZGSdQ0pWcVIzixCbklVnXkEAegapEb/Nr7o39YPvcO9eaSHiIjMgiXHBCw55nP5WgUOZxThSGYRDl0swkVNeZ3fK2QCeoV5I7a9P+5p548uQZ6QyTimh4iIGo4lxwQsOZZToK3CwQtXceCCBvvPX0VOcd37+fi4KXF3Oz/c26EFYtv7w9tNKVFSIiKyNSw5JmDJaR6iKOLS1QrsPa/Bb2ev4OCFqyjT1Rp/LxOAnq28cV/HFhjUKQDtA9x55RYREd0WS44JWHKkUaM3IDWrGL+eKcQvpwtvullhmK8rBncKwJAugYgK84acp7WIiOhPWHJMwJJjHXKKK7H7dCF+PlWA/ReuovpPV275uikxpEsAhndtiX5tfHlTQiIiYskxBUuO9SnX1eK3s1ew82QBfjldiJLKP275rXZxwpDOAXige0vc1daPhYeIyEGx5JiAJce61egNOHSxCN+dyMOPJ/Jxtbza+DtvVycM79YSI3oEoU+4D6/UIiJyICw5JmDJsR16g4jDGUX47ngevjueV6fwBHo6Y0RkEB7pGYxOLfnvkYjI3rHkmIAlxzbV6g04ePEqvj6ai+9P5KO06o8rtToGeuDRXsEYGRmMAE9nCVMSEZGlsOSYgCXH9ulq9fj1zBVsT8nBL6cLUa2/PmhZJgCx7f3xeHQo7u8UAKWC43eIiOwFS44JWHLsS3FFNb49nodtKTlIvnTNON3b1QkjI4Mxtk8oOgby3zMRka1jyTEBS479unilDFuSL2NrymUUaHXG6T1beWFc71Z4qEdLPkuLiMhGseSYgCXH/ukNIn47dwVfHMnGrpMFqDVc393dVQo83DMIT/YN49EdIiIbw5JjApYcx3KlVIctyZex6UgWLl2tME7vE+6DJ/uFYViXQI7dISKyASw5JmDJcUwGg4gDF67is0OXsPNkAfS/H93xc1dhfJ9QPNk3DC14ZRYRkdViyTEBSw7ll1Rh05EsbDycZRy7o5AJeLB7S0zqH46erbwlTkhERH/FkmMClhy6oUZvwM70AiQcyMCRzD+uzOoR6oWpd0VgeNdAKPgYCSIiq8CSYwKWHLqVEzklWLs/E18fzTXedyfYywWTB4RjTO9QeDg7SZyQiMixseSYgCWH6qMp02HDwUvYkHgJRb8/RsJdpcD4mFZ4ekAEAtUct0NEJAWWHBOw5JApqmr02J6ag0/2XsSFK+UAACe5gIcjg/FsbGu0beEhcUIiIsfCkmMClhxqCINBxO4zhVi55yIOZxYZpw/uHIDn722LyFAv6cIRETkQlhwTsORQYyVfKsLyXy/ip1MFxml3t/PD8/e2RUyEDwRBkDAdEZF9Y8kxAUsONdW5glIs33MBO9JyjffbiQ7zxgv3t8M97fxYdoiILIAlxwQsOWQu2UUVWLHnAr5Mumy8Iisy1AsvDmqHge39WXaIiMyIJccELDlkbgXaKnz820V8dugSqmqul50eoV6YfX87DOzAskNEZA4sOSZgySFLuVKqw8e/XcCGxD/KTmSoF14Z0gED2vqy7BARNQFLjglYcsjSrpTqsGrvRaw/mGksOzERPpgzpAP6RPhInI6IyDax5JiAJYeaS2FpFZbtvoDPD2UZx+zc3c4Prw3tiG4haonTERHZFpYcE7DkUHPLK6nE0l/OY/ORbNT+fjXWg91bYs7g9mjt7y5xOiIi28CSYwKWHJJKdlEFluw6i+1pORBFQC4T8Hh0CF68vz0fF0FEdAemfn/b7GOV//nPf6J///5wdXWFl5eX1HGIGiTUxxX/GROJ71+8G4M6tYDeIGLj4WwMXLQbi348g9KqGqkjEhHZPJstOdXV1Rg9ejSee+45qaMQNVrHQE98MrE3tkzvh+gwb1TVGLB093nEvvcr1h3IRHWtQeqIREQ2y+ZPVyUkJGD27NkoLi5u8LI8XUXWRBRF7DpZgHd/OI2Lvz8INNzXFXOHd8LQLgG87JyI6Hemfn8rmjGT5HQ6HXQ6nfFnrVYrYRqiugRBwJAugbivYwtsTsrGkl3nkHm1AtM/TUZMhA/+/lBndA3mlVhERKay2dNVjbFw4UKo1WrjKzQ0VOpIRDdRyGV4IiYMv746EC/c1xYqhQyHMorwt6X78PIXacgvqZI6IhGRTbCqkhMXFwdBEOp9JSUlNXr98+bNQ0lJifGVnZ1txvRE5uWuUmDOkA7Y/cpAPNIzGKIIbEvJwb2LfsXSX86hqkYvdUQiIqtmVWNyNBoNNBpNvfOEh4fD2fmPS2w5JoccxdHsYrz9zUkkX7oGAAjxdsEbD3TCsK6BHK9DRA7FJsfk+Pn5wc/PT+oYRFapR6gXtkzvh6+O5uLd70/j8rVKPPdZCvq29kH8iK7oEOghdUQiIqtiVaerGiIrKwtpaWnIysqCXq9HWloa0tLSUFZWJnU0IosRBAEjI4Px85xYzLq/HVQKGRIvFuGBD/Yi/ut0aHl/HSIiI6s6XdUQkyZNwrp1626avnv3bgwcONCkdfB0Fdm67KIK/PPbU/ghPR8A4OeuxNzhnfBoz2DIZDyFRUT2iY91MAFLDtmL385eQdzX6cb760SFeeOdh7uiU0vu10Rkf1hyTMCSQ/akutaAtfsz8N+fz6GiWg+5TMDk/uGYPbg93FVWNfyOiKhJ7P7ZVURUl1Ihw7OxbfDznFg80C0QeoOIT/Zl4P7Fv+LbY3lw4L9niMhBseQQ2ZmWahcseyIKCZN7I8zXFQVaHZ7/PAWTE44gu6hC6nhERM2GJYfITg3s0AI/zr4Hs+5vB6Vchl/PXMHgJXuwYs8F1Oj54E8isn8sOUR2zNlJjpcHt8f3s+9G39Y+qKox4N3vT+NvH+5DStY1qeMREVkUSw6RA2jj746N0/pi0ege8HZ1wun8Ujy2/ADivkpHua5W6nhERBbBkkPkIARBwKioEPw8ZyAe7XX9WVgJBzIxZMlv2H2mUOp4RERmx5JD5GB83JT4z+ORWP90H4R4uyCnuBKT1x7Bi5tScbVMJ3U8IiKzYckhclD3tPfHzpfuwbS7IyATgB1puRi85Dd8fTSXl5sTkV1gySFyYK5KBd54sDO2zxiAjoEeKCqvxgsbUzH902QUaqukjkdE1CQsOUSEHqFe+GrmXZg9qB0UMgE/phdg0H/2YEvyZR7VISKbxZJDRACu3zF59qD2+PqFu9AtWA1tVS1e+fIopq5L4lEdIrJJLDlEVEenlp7YPqM/Xh3aAUq5DD+fLsTgJb/hf6k5PKpDRDaFJYeIbqKQy/D8vW2NR3VKKmswe3Mant2QjCulvAKLiGwDSw4R3VaHQA9sm9Efcwa3h5NcwM6TBRj6/m/44US+1NGIiO6IJYeI6uUkl+GF+9thx/N3Ga/Amv5pMl7+Ig0llTVSxyMiui2WHCIySecgT+yYOQAzBraBTAC2peRg2Pu/Yd85jdTRiIhuiSWHiEymUsjx2rCO+HJ6P4T5uiKvpApPrj6Et78+iaoavdTxiIjqYMkhogaLCvPB9y/ejSf7tgIArNmfgRFL9+FkrlbiZEREf2DJIaJGcVUq8M7D3bBmUjT83JU4W1CGhz/aj49/uwCDgZeaE5H0WHKIqEnu6xiAH2ffg8GdA1CtN2DBd6fxxCeHkFdSKXU0InJwLDlE1GS+7ip8PCEK/3qsG1yVchy8eBXD3t+LH07kSR2NiBwYSw4RmYUgCBjTuxW+nXU3uodcv4Hg9E9TMG/bMVRU10odj4gcEEsOEZlVhJ8btkzvj+mxbSAIwMbD2Xjow31Izy2ROhoRORiWHCIyO6VChrnDO+KzKTEI8FTh4pVyPPLRAazdn8HnXxFRs2HJISKL6d/WDz+8eA8Gdbo+KDn+65OYtj4JReXVUkcjIgfAkkNEFuXtpsSqp6IQ97fOUMpl+OlUIR74714kXrwqdTQisnMsOURkcYIgYNKACGx/vj9a+7shX1uF8asS8cHP56DnPXWIyEJYcoio2XQJUuPrmXfhsV4hMIjAf3adxVNrDuFKqU7qaERkh1hyiKhZuakUWPx4Dywa3QMuTnLsP38Vw/+7F/vP80GfRGReLDlEJIlRUSH4+oUB6BDgAU2ZDk+uPoT3fzrL01dEZDY2WXIyMzMxZcoUREREwMXFBW3atMH8+fNRXc0rNohsSdsWHvjf8wMwtncoRBF4/6dzmLT2MDRlPH1FRE1nkyXn9OnTMBgMWLlyJdLT07FkyRKsWLECr7/+utTRiKiBXJRyvPtYd/zn8eunr/ae0+DBD/biSGaR1NGIyMYJop3cmeu9997D8uXLcfHiRZOX0Wq1UKvVKCkpgaenpwXTEZEpzhaUYsZnKThfWAa5TMBrQzvgmXtaQxAEqaMRkRUx9fvbJo/k3EpJSQl8fHzqnUen00Gr1dZ5EZH1aB/ggR3PD8DDkUHQG0Qs/P40nt2QDG1VjdTRiMgG2UXJuXDhAj788ENMnz693vkWLlwItVptfIWGhjZTQiIylZtKgSVjIvHPR7pCKZdh58kCjPhwH07l8Y8SImoYqyo5cXFxEASh3ldSUlKdZXJzczFs2DCMHj0aU6dOrXf98+bNQ0lJifGVnZ1tyY9DRI0kCAKeiAnDl9P7IdjLBZlXK/DIsv3YlnJZ6mhEZEOsakyORqOBRlP/vTLCw8Ph7OwM4HrBuffeexETE4OEhATIZA3rbByTQ2T9rpVX48XNafjt7BUAwJN9W+Gth7pAqbCqv9GIqBmZ+v1tVSWnIXJycnDvvfciKioKn376KeRyeYPXwZJDZBv0BhEf/HwOH/xyDqII9GrlhWVPRCFQ7Sx1NCKSgF0PPM7NzcXAgQMRGhqKRYsW4cqVK8jPz0d+fr7U0YjIAuQyAS8Nbo/VE6Ph6axASlYxHvpwHw7xIZ9EVA+bPJKTkJCAyZMn3/J3Dfk4PJJDZHsuXS3HsxuScTq/FHKZgDce6ITJA8J5mTmRA7H701XmwJJDZJsqqmsxb9tx7EjLBQA82jMYCx7tBmenhp+2JiLbY9enq4jIsbkqFXh/TCT+/lBnyGUCtqXmYNSKA8gprpQ6GhFZEZYcIrJJgiBgyl0R2DClD7xdnXAiR4sRH+7DwQscp0NE17HkEJFN69/GD1+/cBe6BHniank1nlx9CAn7Mxo0Po+I7BNLDhHZvBBvV2yZ3t/4OIi4r09i7tbj0NXqpY5GRBJiySEiu+CilGPJmEi8/kBHyARgc1I2xq86hCulOqmjEZFEWHKIyG4IgoBn7mmDNZN6w8NZgeRL1zBi6T4cv1widTQikgBLDhHZnYEdWmDH8wPQ2t8NeSVVGLXiAL4+mit1LCJqZiw5RGSXWvu743/PD8C9HfyhqzXghY2p+M/OMzAYOCCZyFGw5BCR3fJ0dsInE3vjmXtaAwA++OU8ZnyWgorqWomTEVFzYMkhIrsmlwl4/YFOWDS6B5RyGX5Iz8eo5Qd540AiB8CSQ0QOYVRUCDY+EwM/dyVO5mkxcul+pGZdkzoWEVkQSw4ROYyoMB/smHkXOgZ6QFOmw5iPE/EVByQT2S2WHCJyKMFeLtjyXH8M6tQC1bUGzNqYiiW7zvIOyUR2iCWHiByOu0qBlROijQOS//vzObywMRVVNbxDMpE9YckhIod0Y0Dyvx7rBoVMwDfH8jBuVSI0ZbxDMpG9YMkhIoc2pncrbJgSA09nBVKzivHIsv04X1gqdSwiMgOWHCJyeP3a+GL78wMQ5uuK7KJKPLLsAPaf10gdi4iaiCWHiAhAG393bJ8xANFh3iitqsXENYex+UiW1LGIqAlYcoiIfufjpsSnU2MwMjIItQYR/7f1OBb9eIZXXhHZKJYcIqI/cXaS4/0xkZh1X1sAwNLd5zF7cxp0tbzyisjWKBoyc0REBARBaPCbzJ49G7NmzWrwckREUhAEAS8P6YAQH1e8vu04dqTlIq+4CisnRMHbTSl1PCIykSA24Djsnj17GvUm4eHhCAsLa9SylqTVaqFWq1FSUgJPT0+p4xCRFdp3ToPnPk1Gqa4Wrf3ckDC5D1r5ukodi8ihmfr93aCSY29YcojIFGfySzF57WHkllTBz12J1RN7o0eol9SxiByWqd/fHJNDRHQHHQI9sP35Aejc0hOasmqM/TgRP58qkDoWEd0BSw4RkQkCPJ3xxfR+uLudHypr9Ji2PgmfHbokdSwiqgcHHhMRmchdpcCaSb3x+rbj+DL5Mt7YfgJ5xVWYM6R9o/7fSESW1aCSk5CQ0Kg3CQ8Pb9RyRETWxkkuw79HdUeQlwv++/M5LN19HnklVXj3sW5wkvPgOJE14cBjDjwmokbafCQLr28/Ab1BRGx7fyx7ohfcVA3625GIGqFZBh7X1NQgOzsbZ86cQVFRUVNWRURkc8b0boWPJ0TB2UmGPWev8CnmRFamwSWnrKwMK1euxMCBA6FWqxEeHo5OnTrB398fYWFhmDZtGo4cOWKJrEREVuf+TgHYOK0vfNyUOHa5BI8tP4BMTbnUsYgIDSw5S5YsQXh4OFatWoX77rsP27ZtQ1paGs6ePYuDBw9i/vz5qK2txeDBgzFs2DCcO3fOUrmJiKxGz1be2DK9H0J9XHDpagVGrTiAEzklUscicngNGpMzevRovPXWW+jWrVu98+l0OqxevRpKpRJTp05tcshbGTFiBNLS0lBYWAhvb28MGjQI//rXvxAUFGTyOjgmh4jMqbC0CpPXHkF6rhZuSjlWTojGXe38pI5FZHfs/o7HS5YsQb9+/dCyZUvk5OTglVdeAQAcOHDA5HWw5BCRuZVW1eDZDck4cOEqnOQCFj8eiRE9TP/ji4jurNlLztq1azF58mRzrKpRvvrqKzz88MPQ6XRwcnIyaRmWHCKyBF2tHi9vPopvj+cBAOb/rTMmD4iQOBWR/Wj2xzps27YNu3fvNv5cWVmJJ554wlyrr1dRURE+++wz9O/fv96Co9PpoNVq67yIiMxNpZDjg3E98VS/6w8mjv/6JBbvPAMbPXBOZLPMVnI+/fRTvPHGGzh9+jTOnTuHu+++GwMHDjTX6m/p//7v/+Dm5gZfX19kZWVhx44d9c6/cOFCqNVq4ys0NNSi+YjIccllAuJHdMGcwe0BAB/+ch5v/O/6PXWIqHk0+XTVyy+/jMjISERGRkKpVGL8+PEQRRFr1qxBz549G7SuuLg4xMfH1zvPkSNHEB0dDQDQaDQoKirCpUuXEB8fD7VajW+++ea2t1fX6XTQ6f64h4VWq0VoaChPVxGRRX2aeAl/33ECogg80C0QS8ZEQqWQSx2LyGY125icHTt24NixYzh27BhOnz6N3Nxc9O3bF/fccw+6du2KBx980OR1aTQaaDSaeucJDw+Hs7PzTdMvX76M0NBQHDhwAP369TPp/Tgmh4iay3fH8zB7Uxqq9Qb0b+OLj5+KhjvvjkzUKKZ+fzf5v7CRI0di5MiRxp8rKytx4sQJHDt2DD/99FODSo6fnx/8/Bp3ueWNrvbnIzVERNbigW4toXZxwjPrk3DgwlWMX5WIhMl94OOmlDoakd1q8JEcURQlf9ru4cOHcfjwYdx1113w9vbGxYsX8dZbbyEvLw/p6elQqVQmrYdHcoiouR27XIyJaw7jWkUN2rZwx4YpfdBS7SJ1LCKbYrGrq9zd3TFgwADMmjUL69atw4kTJ2AwGJoUtqFcXFywbds23H///ejQoQOefvppdO3aFXv27DG54BARSaF7iBe+nN4PLdXOOF9YhlHLDyKDj4EgsogGH8lZtmwZUlJSkJycjPT0dOj1ejg7O6N79+6IiopCVFQUevXqhR49elgqs9nwSA4RSeXytQpMWH0YGZpy+Lkrse7pPugSpJY6FpFNaJaBxzqdDi4uLnj99ddRVFSElJQUHDt2DDqdDnq9vrGrbTYsOUQkJU2ZDk+tPoyTeVp4OCuwdlJvRIf7SB2LyOo129VVMpkMaWlp6N69OwBAr9cjPT3d+LM1Y8khIqlpq2owNSEJhzOL4OIkx8oJUbinvb/UsYisWrPf8fgGuVxuEwWHiMgaeDo7Yd3TfRDb3h+VNXpMXZeEH07kSR2LyC6YveQQEVHDuCjlWPVUNB7s1hLVegNmfJaCLcmXpY5FZPMafJ+cadOmISoqCtHR0ejWrRsASH5JORGRrVMqZPhgXE+4qxTYnJSNV748inJdLSb2D5c6GpHNanDJOXPmDL744guUlpZCobi+eHx8PAYOHIhevXohMjISrq6uZg9KRGTv5DIB7z7WDe7OCqzel4H5X6WjvLoWMwa2lToakU1q9MDjc+fOITk52Xg5eWpqKoqLiyGXy9G+fXukp6ebO6vZceAxEVkjURSx5Kdz+ODncwCAmfe2xZwh7XnUnOh3Fn+sQ7t27dCuXTuMHTvWOC0jIwNJSUlITU1t7GqJiByeIAh4eXB7uCrlePf701i6+zzKq2vx1kOdWXSIGqBBR3KysrLQqlUrk1eek5OD4ODgRgVrDjySQ0TWbsPBTPx9x/Uj42OiQ7Hg0W6Qy1h0yLFZ5BLy3r17Y9q0aTh8+PBt5ykpKcGqVavQtWtXbNu2rSGrJyKiv5jQLxyLRveATAA2J2Xj5S/SUKtv3kfpENmqBp2uOnXqFBYsWIBhw4bByckJ0dHRCAoKgrOzM65du4aTJ08iPT0d0dHReO+99zB8+HBL5SYichijokLg4iTHi5tSsSMtF7oaAz4Y1xNKBe8CQlSfRg08rqqqwnfffYe9e/ciMzMTlZWV8PPzQ8+ePTF06FB07drVElnNjqeriMiW7DpZgOc/S0G13oD7OrbAsid6wdlJLnUsomZn8cc6aLVamy8GLDlEZGv2nL2CZ9YnQVdrwF1t/fDxU1FwVTb6GhIim2Txxzp4e3tj69atjV2ciIgaIba9PxIm94GrUo595zWYtOYIynS1UsciskqNLjmiKGL58uWIiYlB3759MXPmTBw6dMic2YiI6Bb6tfHFhikx8FApcDizCE+tPgRtVY3UsYisTpNGrR09ehR9+vTBwIEDcebMGcTGxuKll14yVzYiIrqNqDBvfDYtBp7OCqRkFePJTw6hpIJFh+jPmnQi9/PPP8fgwYONPx8/fhwPP/wwQkJCMGfOnCaHIyKi2+se4oWNz/TFk58cwrHLJRi3KhGfTo2Bj5tS6mhEVqHRR3J8fX0RGhpaZ1q3bt3wwQcfYMWKFU0ORkREd9YlSI1Nz/SDn7sSJ/O0GPdxIjRlOqljEVmFRpecHj16YPXq1TdNb9u2LbKzs5sUioiITNch0AObnumLFh4qnCkoxbiPE1FYWiV1LCLJNbrkvPPOO1i6dCnGjx+Pffv2QavVoqCgAAsWLEBERIQ5MxIR0R20beGBzc/2Q6CnM84VlmHsx4ko0LLokGNrdMnp27cvEhMTkZubi4EDB8Lb2xtBQUHYsmULFi9ebM6MRERkggg/N2x+ti+C1M64eKUcYz9ORH4Jiw45rkbfDPDPCgsLkZycDIPBgJiYGPj5+Zkjm8XxZoBEZI+yiyow9uNE5BRXIszXFRun9UWQl4vUsYjMxuJ3PLYHLDlEZK+yiyowblUiLl+rRCsfV2x8pi+CWXTITlj8jsdERGS9Qn1csfnZfmjl44qsogqM/fggcoorpY5F1KxYcoiI7FSwlws2PdMXYb6uyC6qxNiPD+LytQqpYxE1G7OUnJSUFFRXV5tjVUREZEZBNxWdRBYdchhmKTm9e/dGZmamOVZFRERm1lJ9veiE+7ri8jUWHXIcZik5Djx2mYjIJrRUu2DjX4oOx+iQveOYHCIiB3H9iE6/PxWdg8hl0SE7xpJDRORAAtXO2PiXMTosOmSvWHKIiBxMS7ULNk7ra7y8fNyqROSVsOiQ/bH5kqPT6RAZGQlBEJCWliZ1HCIimxDkdX2MTqiPCy5drcA4PgKC7JDNl5zXXnsNQUFBUscgIrI5wV7Xj+iEeLsg82oFxq/i08vJvth0yfn++++xc+dOLFq0SOooREQ2KcT7+rOtgr1ccFFTjvGrDkFTppM6FpFZmKXkzJ8/v9kfyllQUIBp06Zhw4YNcHV1bdb3JiKyJ6E+rvh8WgwCPZ1xvrAMT6w6hKJy3uCVbJ/ZSo6Pj485VmUSURQxadIkTJ8+HdHR0SYvp9PpoNVq67yIiAgI83XDxmf6ooWHCmcKSvHEJ4dwjUWHbJxVna6Ki4uDIAj1vpKSkvDhhx9Cq9Vi3rx5DVr/woULoVarja/Q0FALfRIiItsT4Xe96Pi5q3AqT4sJaw6hpLJG6lhEjSaIVnS7Yo1GA41GU+884eHhGDt2LL7++msIgmCcrtfrIZfL8cQTT2DdunW3XFan00Gn++Ncs1arRWho6B0f1U5E5EjOFZRi7MeJuFpejR6hXvh0Sh94ODtJHYvISKvVQq1W3/H726pKjqmysrLqnGrKzc3F0KFDsWXLFsTExCAkJMSk9Zi6kYiIHM2pPC3GrUpEcUUNosO8se7pPnBTKaSORQTA9O9vm9xjW7VqVednd3d3AECbNm1MLjhERHR7nVp64tMpMRi/KhFJl65hyrojWDupD1yUcqmjEZnMqsbkEBGR9egarMb6KTFwVymQeLEI09YnoapGL3UsIpM16HRVREREnXEwppo9ezZmzZrV4OUsjaeriIjuLPlSESasPoyKaj3u69gCK56MglLBv5FJOhYZk7Nnz55GhQkPD0dYWFijlrUklhwiItMcvHAVk9Yehq7WgOFdA/HhuJ5QyFl0SBp2PfDYXFhyiIhM99vZK5i6LgnVegNGRgbhP49HQi5r+NF9oqYy9fubNZyIiExyT3t/LHuiFxQyATvScjFv2zEYDA77dzLZgAZdXWVvY3KIiKhhBnUOwH/H9sQLG1PwRdJlODvJET+iS6O+G4gsrUElJyEhoVFvEh4e3qjliIjI+jzYvSV0tT0w58ujWH/wElyUcswd1pFFh6xOg0pObGyspXIQEZENebRXCCpr9Hhj+wms3HMRbkoFZt3fTupYRHVwTA4RETXKEzFhePPBTgCA/+w6i0/2XpQ4EVFdTbrjcU1NDfLz81FRUQF/f/9mfRI5ERFJb+rdrVFZrcfiXWfxzren4Owkx5N9re+WIeSYGnwkp6ysDCtXrsTAgQOhVqsRHh6Ozp07w9/fH2FhYZg2bRqOHDliiaxERGSFZt7XFs8NbAMAePN/J7At5bLEiYiua1DJWbJkCcLDw7Fq1Srcd9992LZtG9LS0nDmzBkcPHgQ8+fPR21tLQYPHoxhw4bh3LlzlspNRERWQhAEvDa0Ayb1DwcAvLrlGH44kS9tKCI08GaAo0ePxltvvYVu3brVO19VVRXWrFkDpVKJqVOnNjmkpfBmgERE5mMwiHht6zFsSb4MJ7mATyb2Rmx7f6ljkR3iHY9NwJJDRGReeoOIWRtT8e3xPDg7ybD+6Rj0ieB4TTIvU7+/mzTw+Ibi4mL8+OOPyMnJgSAIaNmyJYYOHQpvb29zrJ6IiGyEXCZgyZhIVFTXYveZK3g64Qg+nxaD7iFeUkcjB9TkS8hXr16NPn36IDExEQaDAXq9HomJiejbty9Wr15tjoxERGRDlAoZlj8ZhZgIH5TpajFxzWGcKyiVOhY5oCafrurQoQOSk5Ph7u5eZ3ppaSmioqJw9uzZJgW0JJ6uIiKynDJdLZ745BCOZhcjwFOFLdP7I9THVepYZAea7QGdgiCgrKzspullZWW8xTcRkQNzVymQMKk32ge4o0CrwxOfHEKBtkrqWORAmjwmZ9GiRYiNjUXXrl0RHBwMALh8+TLS09OxePHiJgckIiLb5e2mxKdTYjBqxUFkFVVgwupD2PxMP3i7KaWORg7ALFdX6fV6HD58GLm5uRBFEcHBwejTpw/kcrk5MloMT1cRETWP7KIKjFpxAAVaHXqEqPHZtL5wV5nl2hdyQBa7hFwURbs5DcWSQ0TUfM4VlOLxlQdxraIG/Vr7Yu3k3nB2su4/hsk6WWxMjru7OwYMGIBZs2Zh3bp1OHHiBAwGQ5PCEhGR/WsX4IH1T8fAXaXAwYtX8cLGVNTq+f1BltPgIznLli1DSkoKkpOTkZ6eDr1eD2dnZ3Tv3h1RUVGIiopCr1690KNHD0tlNhseySEian4HL1zFxLWHUV1rwKO9grFoVA/IZPZxhoCaR7Pc8Vin08HFxQWvv/46ioqKkJKSgmPHjkGn00Gv1zd2tc2GJYeISBo/nSzAs58mQ28QMal/OOb/rbPdDIUgy2uWOx6rVCoAwOOPP47u3bsDuD4IOT09vSmrJSIiOzeocwAWje6OlzYfRcKBTKhdnPDS4PZSxyI70+T75PyVXC43Fh4iIqLbeaRnCOJHdAEA/Pfnc0jYnyFxIrI3Zi85REREpprYPxwvDbp+BCfu65P4X2qOxInInjS45EybNg0rVqxAUlISdDodAPA8KhERNdqs+9tiUv9wAMArXx7F7tOF0gYiu9Hggcf33HMPjh49itLSUigUCtTW1uLRRx/FwIED0atXL0RGRsLV1TaeTcKBx0RE1sFgEDHny6PYnpoDlUKGT6fGoHe4j9SxyEpZ/Oqqc+fOITk52Xg5eWpqKoqLiyGXy9G+fXubGHzMkkNEZD1q9AY8uyEZv5wuhIezApuf6YfOQfx/M92sWS4h/6uMjAwkJSUhNTUVCxYsMNdqLYYlh4jIulRW6/HUmkM4knkN/h4qbJ3eH618bePsADUfi5ScrKwstGrVyuQQOTk5xod2WiOWHCIi61NSWYOxHyfiVJ4WrXxcseW5fmjh4Sx1LLIiFnmsQ+/evTFt2jQcPnz4tvOUlJRg1apV6Nq1K7Zt29aQ1RMREUHt4oR1T/dGKx9XZBVVYOKaI9BW1Ugdi2xQg47kFBUVYcGCBVizZg2cnJwQHR2NoKAgODs749q1azh58iTS09MRHR2NN998E8OHD7dk9ibjkRwiIut16Wo5Hlt+EJoyHfpE+GD90334QE8CYKEjOT4+Pli0aBFyc3OxfPlytG/fHhqNBufOnQMAPPHEE0hOTsb+/fstXnDCw8MhCEKd19y5cy36nkRE1HzCfN2w7une8FApcDijCDM/5wM9qWEaPfBYq9VKevQjPDwcU6ZMwbRp04zT3N3d4e7ubvI6eCSHiMj6Hbp4FRPWXH+g55joULz7WDfen83BWeRIzp95e3tj69atjV3cLDw8PBAYGGh8NaTgEBGRbYhp7Yul43pCJgCbk7KxaOcZqSORjWj0kRyZTIb77rsPpaWlEAQB0dHRmDBhAmJiYsyd8ZbCw8Oh0+lQXV2N0NBQjB49Gq+++iqUSuVtl9HpdMa7NAPXm2BoaCiP5BAR2YBNh7Mwd9txAMD8v3XG5AEREiciqVj8SA4AHD16FH369MHAgQNx5swZxMbG4qWXXmrKKk324osvYtOmTdi9ezdmzpyJ999/HzNmzKh3mYULF0KtVhtfoaGhzZKViIiabmyfVnh1aAcAQPzXJ7Ejjc+5ovo16UjOjz/+iMGDBxunHT9+HA8//DBmzJiBOXPmNHidcXFxiI+Pr3eeI0eOIDo6+qbpW7duxahRo6DRaODr63vLZXkkh4jItomiiPivTyLhQCac5AJWT+yNe9r7Sx2LmpnF73js7++PvXv3omPHjnWmf/vtt5g9e7bxiquG0Gg00Gg09c4THh4OZ+ebbwqVk5ODkJAQJCYmmnzKjAOPiYhsj8Eg4sXNafj6aC5clXJsnNYXPUK9pI5FzcjU729FY9+gR48eWL16Nd57770609u2bYvs7OxGrdPPzw9+fn6NWjY1NRUA0LJly0YtT0REtkEmE7B4dA9cK6/GvvMaTE44gq3P9UeEn5vU0cjKNHpMzjvvvIOlS5di/Pjx2LdvH7RaLQoKCrBgwQJERFh2MNjBgwexZMkSpKWlISMjA1988QWeffZZjBgxokGPnSAiItukVMiwYkIUugWrUVRejafWHEJhaZXUscjKNLrk9O3bF4mJicjNzcXAgQPh7e2NoKAgbNmyBYsXLzZnxpuoVCps3rwZAwcOROfOnfHWW29h2rRp2Lhxo0Xfl4iIrIe7SoG1k3sjzNcV2UWVfPwD3cQsTyEvLCxEcnIyDAYDYmJiGn3KqblxTA4Rke27/viHA9CUVaNfa18kPN0bKgUf/2DPLD7w2B6w5BAR2YcTOSUY+3EiynS1eLB7S3w4tidkMt4V2V41y31yiIiIrEHXYDVWToiCk1zAt8fy8PY3J+HAf8PT7xp0dVVERESjnhcye/ZszJo1q8HLERERmWpAWz8sGt0DL25KQ8KBTASqnTE9to3UsUhCDSo5CQkJjXqT8PDwRi1HRETUECMjg3GlVId3vj2Fd78/DX93FR6LCpE6FkmkQSUnNjbWUjmIiIjMYurdrVGgrcKqvRn4v63H4OuuxMAOLaSORRLgmBwiIrI784Z3wsjIINQaRMz4LAXHL5dIHYkkwDE5RERkd2QyAe+N6gFNmQ77z1/F5ITD2PbcALTydZU6GjWjBl1CvmfPnka9SXh4OMLCwhq1rCXxEnIiIvtWWlWDx1cm4lSeFhF+btgyvR983VVSx6Im4n1yTMCSQ0Rk/wq0VXh02QHkFFeiR6gXNk6Lgauy0Y9uJCvA++QQEREBCPB0xrqn+8DL1QlHs4vxwuepqNUbpI5FzYAlh4iI7F7bFu5YPTEaKoUMP58uxN93nODNAh0ASw4RETmEqDAffDCuJ2QCsPFwNpb+cl7qSGRhLDlEROQwhnYJRNyILgCAxbvO4sukbIkTkSWx5BARkUN5ql+48XEP87Ydx56zVyRORJbCkkNERA7ntaEd8PDvNwt87tNknMjhzQLtEUsOERE5HJlMwL9H9cCAtr6oqNZj0tojyC6qkDoWmRlLDhEROSSlQoblT0ahY6AHNGU6TFp7GMUV1VLHIjNiySEiIofl6eyEhMl90FLtjAtXyvHM+mRU1eiljkVmwpJDREQOLVDtjLWTe8NDpcDhzCLM+fIoDAbeQ8cesOQQEZHD6xjoiZUTouAkF/DtsTws/P6U1JHIDFhyiIiIAPRv64f3RvUAAKzam4GE/RkSJ6KmYskhIiL63cM9g/Hq0A4AgPhvTmJner7EiagpWHKIiIj+ZMbANhjXpxVEEZi1KRWpWdekjkSNxJJDRET0J4Ig4B8ju+DeDv6oqjFg6rokXLpaLnUsagSWHCIior9QyGVYOr4XugZ74mp5NSatPYKict5Dx9aw5BAREd2Cm0qBNRN7I9jLBRmackxbn8R76NgYlhwiIqLbaOHpjITJveHprEDypWuY8wXvoWNLWHKIiIjq0S7AAytu3EPneB7+9cNpqSORiVhyiIiI7qB/Gz/8e1R3AMDK3y5iQ+IliRORKVhyiIiITPBIzxDMGdweADB/xwn8crpA4kR0Jyw5REREJpp5X1s8Hh0CgwjM/DwVJ3JKpI5E9bDpkvPtt98iJiYGLi4u8PPzw6OPPip1JCIismOCIOCfj3TD3e38UFGtx9MJR5BTXCl1LLoNmy05W7duxYQJEzB58mQcPXoU+/fvx/jx46WORUREds5JLsNHT/RChwAPFJbq8PTaI9BW1Ugdi25BEEXR5q6Fq62tRXh4OOLj4zFlypRGr0er1UKtVqOkpASenp5mTEhERPYup7gSj3y0H4WlOtzV1g9rJ/eGk9xmjx3YFFO/v23y30ZKSgpycnIgk8nQs2dPtGzZEsOHD0d6enq9y+l0Omi12jovIiKixgj2csGaSb3hqpRj33kN3th+HDZ43MCu2WTJuXjxIgAgLi4Ob775Jr755ht4e3sjNjYWRUVFt11u4cKFUKvVxldoaGhzRSYiIjvUNViND8f1hEwAvki6jI92n5c6Ev2JVZWcuLg4CIJQ7yspKQkGgwEA8MYbb+Cxxx5DVFQU1q5dC0EQ8OWXX952/fPmzUNJSYnxlZ2d3VwfjYiI7NT9nQIQP6ILAGDRzrPYkZYjcSK6QSF1gD+bOXMmxo4dW+884eHhKC0tBQB07tzZOF2lUqF169bIysq67bIqlQoqlco8YYmIiH43oV84Ll2twCf7MvDql8cQ5OWC3uE+UsdyeFZVcvz8/ODn53fH+aKioqBSqXDmzBncddddAICamhpkZmYiLCzM0jGJiIhuMu+BTsi+VoEf0wvwzPokbJ8xAOF+blLHcmhWdbrKVJ6enpg+fTrmz5+PnTt34syZM3juuecAAKNHj5Y4HREROSK5TMD7Y3qiR4ga1ypqMDnhCK6VV0sdy6HZZMkBgPfeew9jx47FhAkT0Lt3b1y6dAm//PILvL29pY5GREQOykUpx6qJ0Qj2ckGGphzPbkiGrlYvdSyHZZP3yTEX3ieHiIgs4WxBKR5bdgClulqMjAzC+2MiIQiC1LHshl3fJ4eIiMiatQ/wwPIno6CQCdiRlov3fzondSSHxJJDRERkAXe188M7D3cFAPz353PYnnpZ4kSOhyWHiIjIQsb2aYXpsW0AAP+35TgOXbwqcSLHwpJDRERkQa8N7YAHugWiWm/As58mI0NTLnUkh8GSQ0REZEEymYD/PB6JyFAvFFfUYPLaw7y0vJmw5BAREVmYs5Mcq56KRoi3CzKvVvDS8mbCkkNERNQM/D1UWDOpNzxUChzOLMK8rXxquaWx5BARETWT9gEeWPZkL8hlAral5mDpL3xquSWx5BARETWju9v54x8jr19avngXn1puSSw5REREzWx8TCtMuzsCAPDqlmNIvlQkcSL7xJJDREQkgbnDO2Fw5wBU1xrwzPpkZF2tkDqS3WHJISIikoBcJuC/YyPRNdgTV8ur8fS6IyiprJE6ll1hySEiIpKIq1KBT57qjUBPZ5wvLMPMz1NQozdIHctusOQQERFJKFDtjE8mRsPFSY695zSY/1U6Ly03E5YcIiIiiXUNVuODcT0hCMDnh7Kwel+G1JHsAksOERGRFRjcOQBvPNAJAPDP707hp5MFEieyfSw5REREVmLKXREY16cVRBGYtSkVJ3O1UkeyaSw5REREVkIQBLw9sgsGtPVFRbUeU9YdQaG2SupYNoslh4iIyIo4yWVYNj4Krf3dkFdShWnrk1BZzYd5NgZLDhERkZVRuzph7aTe8HZ1wtHLJZjzZRoMBl5x1VAsOURERFYozNcNK56MgpNcwHfH87F41xmpI9kclhwiIiIrFdPaF+8+2h0A8NHuC9iWclniRLaFJYeIiMiKPRYVghkD2wAA5m49jiOZfJinqVhyiIiIrNwrQzpgWJdAVOsNeHYDH+ZpKpYcIiIiKyeTCfjPmB7oFqxGUXk1pqw7Am0VH+Z5Jyw5RERENsBVqcAnE6MR6OmMc4VlmPl5Kmr5MM96seQQERHZiADPPx7m+dvZK/jHNyeljmTVWHKIiIhsSNdgNZaMiQQArDt4CRsOZkqax5qx5BAREdmYYV0D8dqwDgCAuK9PYu+5KxInsk4sOURERDboudg2eLRXMPQGETM+S8H5wjKpI1kdlhwiIiIbJAgCFj7aDdFh3iitqsWUdUdwrbxa6lhWxSZLzq+//gpBEG75OnLkiNTxiIiImoVKIcfKCVEI8XbBpasVmP5pMqprecXVDTZZcvr374+8vLw6r6lTpyI8PBzR0dFSxyMiImo2vu4qrJ7YG+4qBQ5lFOHv/zsBUeTDPAEbLTlKpRKBgYHGl6+vL7766is8/fTTEARB6nhERETNqkOgBz4c1xMyAdiclI3V+zKkjmQVbLLk/NVXX30FjUaDSZMm1TufTqeDVqut8yIiIrIH93Zsgdcf6AQAWPDdKfxyukDiRNKzi5KzevVqDB06FKGhofXOt3DhQqjVauPrTvMTERHZkil3RWBcn1AYRGDWxjScyS+VOpKkrKrkxMXF3XZA8Y1XUlJSnWUuX76MH3/8EVOmTLnj+ufNm4eSkhLjKzs721IfhYiIqNkJgoD4EV3Rt7UPynTXr7i6WqaTOpZkBNGKRidpNBpoNJp65wkPD4ezs7Px53/84x/48MMPkZOTAycnpwa9n1arhVqtRklJCTw9PRuVmYiIyNpcK6/Gw8v249LVCvQO98anU2OgUsiljmU2pn5/W1XJaShRFNGmTRs8+uijWLRoUYOXZ8khIiJ7db6wDI8s24/SqlqMigrBe6O6283FOaZ+f1vV6aqG+uWXX5CRkWHSqSoiIiJH0raFOz4a3wtymYAtyZexau9FqSM1O5suOatXr0b//v3RqVMnqaMQERFZnXva++PvD17/jlz4/Wn8dNKxrriy6dNVTcXTVUREZO9EUcSb/zuBzw5lwU0px9YZ/dEx0La/8xzidBURERHVTxAExI3ogv5tfFFerceUhCRoHOSKK5YcIiIiO+ckl2HZE70Q7uuKnOJKTN+QDF2tXupYFseSQ0RE5AC8XJX4ZGJveDgrkHTpGt7Ybv/PuGLJISIichA3rriSCXCIK65YcoiIiBzIPe398feHOgO4fsXVz6fs94orlhwiIiIHM6l/OMb1CYUoArM2ptrtM65YcoiIiBzMjWdcxUT4oLxaj6nrj6CovFrqWGbHkkNEROSAlAoZVjwZhVY+rsguqsT0T5NRXWuQOpZZseQQERE5KG83JT6ZGA13lQKHM4rw1g77uuKKJYeIiMiBtQ/wwIfjekIQgE1HsrF2f6bUkcyGJYeIiMjB3duxBV4ffv0ZV+98exJ7zl6ROJF5sOQQERERpt4dgdFRITCIwMzPU3C+sEzqSE3GkkNEREQQBAHvPNIV0WHeKK2qxbT1SSipqJE6VpOw5BAREREAQKWQY8WEKAR7uSBDU47nP09Brd52r7hiySEiIiIjP3cVVj0VDVelHPvOa/DOt6ekjtRoLDlERERUR+cgTywZEwkASDiQic8PZUkbqJFYcoiIiOgmQ7sE4tWhHQAAb+04gYMXrkqcqOFYcoiIiOiWZgxsgxE9glBrEDHjs2RkXa2QOlKDsOQQERHRLQmCgH+P6o4eIWpcq6jB1PVHUFplO1dcseQQERHRbTk7ybFyQjRaeKhwtqAML21Og95gG49+YMkhIiKiegWqnfHxU9FQKmT46VQhFu08I3Ukk7DkEBER0R1FhnrhvVHdAQDLf72A7amXJU50Zyw5REREZJKRkcGYMbANAOD/th5HatY1iRPVjyWHiIiITPbKkA4Y1CkA1bUGPLshGfklVVJHui2WHCIiIjKZTCbg/bGR6BDggcJSHZ7ZkISqGr3UsW6JJYeIiIgaxF2lwCcTo+Ht6oRjl0vw2pZjEEXru+KKJYeIiIgaLNTHFcufjIJCJuCro7lY9usFqSPdhCWHiIiIGqVva1/Ej+wCAFi08wx2nSyQOFFdLDlERETUaE/EhOGpfmEQRWD2plScztdKHcmIJYeIiIia5O8PdUb/Nr4or9Zj2vokFJVXSx0JAEsOERERNZGTXIaPxvdCmK8rsosqMeOzZNToDVLHst2Sc/bsWYwcORJ+fn7w9PTEgAEDsHv3bqljEREROSRvNyVWPRUNd5UCiReLEP91utSRbLfkPPjgg6itrcUvv/yC5ORkREZG4qGHHkJ+fr7U0YiIiBxS+wAP/HdsJAQB+DQxCxsSL0maxyZLjkajwfnz5zF37lx0794d7dq1w7vvvouKigqkp0vfHImIiBzV/Z0C8NrQjgCAuK/SceCCRrIsNllyfH190alTJ6xfvx7l5eWora3FypUrERAQgKioqNsup9PpoNVq67yIiIjIvKbHtsbDkUHwdFZAJgiS5VBI9s5NIAgCdu3ahZEjR8LDwwMymQwBAQH44Ycf4OXlddvlFi5ciPj4+OYLSkRE5IAEQcC7j3WHpkyHEG9XyXJY1ZGcuLg4CIJQ7yspKQmiKGLGjBlo0aIF9u7di8OHD2PkyJF46KGHkJeXd9v1z5s3DyUlJcZXdnZ2M346IiIix+HsJJe04ACAIFrRwyY0Gg00mvrP3YWHh2P//v0YMmQIrl27Bk9PT+Pv2rVrhylTpmDu3LkmvZ9Wq4VarUZJSUmd9RAREZH1MvX726pOV/n5+cHPz++O81VUVAAAZLK6B6JkMhkMBumvyyciIiLpWdXpKlP169cP3t7emDhxIo4ePYqzZ8/i1VdfRUZGBh588EGp4xEREZEVsMmS4+fnhx9++AFlZWW47777EB0djX379mHHjh3o0aOH1PGIiIjICljVmJzmxjE5REREtsfU72+bPJJDREREdCcsOURERGSXWHKIiIjILrHkEBERkV1iySEiIiK7xJJDREREdoklh4iIiOwSSw4RERHZJat6dlVzu3EfRK1WK3ESIiIiMtWN7+073c/YoUtOaWkpACA0NFTiJERERNRQpaWlUKvVt/29Qz/WwWAwIDc3Fx4eHhAEwWzr1Wq1CA0NRXZ2Nh8XcQfcVg3D7WU6bivTcVuZjtvKdJbcVqIoorS0FEFBQZDJbj/yxqGP5MhkMoSEhFhs/Z6envyPwETcVg3D7WU6bivTcVuZjtvKdJbaVvUdwbmBA4+JiIjILrHkEBERkV1iybEAlUqF+fPnQ6VSSR3F6nFbNQy3l+m4rUzHbWU6bivTWcO2cuiBx0RERGS/eCSHiIiI7BJLDhEREdkllhwiIiKySyw5REREZJdYcky0bNkyREREwNnZGVFRUdi7d2+98+/ZswdRUVFwdnZG69atsWLFipvm2bp1Kzp37gyVSoXOnTtj+/btlorfrMy9rRISEiAIwk2vqqoqS36MZtGQbZWXl4fx48ejQ4cOkMlkmD179i3n435l2rbifnXdtm3bMHjwYPj7+8PT0xP9+vXDjz/+eNN83K9M21b2vF8BDdte+/btw4ABA+Dr6wsXFxd07NgRS5YsuWk+i+5bIt3Rpk2bRCcnJ3HVqlXiyZMnxRdffFF0c3MTL126dMv5L168KLq6uoovvviiePLkSXHVqlWik5OTuGXLFuM8Bw4cEOVyubhgwQLx1KlT4oIFC0SFQiEmJiY218eyCEtsq7Vr14qenp5iXl5enZeta+i2ysjIEGfNmiWuW7dOjIyMFF988cWb5uF+dZ0p24r71XUvvvii+K9//Us8fPiwePbsWXHevHmik5OTmJKSYpyH+9V1pmwre92vRLHh2yslJUX8/PPPxRMnTogZGRnihg0bRFdXV3HlypXGeSy9b7HkmKBPnz7i9OnT60zr2LGjOHfu3FvO/9prr4kdO3asM+3ZZ58V+/bta/z58ccfF4cNG1ZnnqFDh4pjx441U2ppWGJbrV27VlSr1WbPKrWGbqs/i42NveUXN/erm91uW3G/ur3OnTuL8fHxxp+5X93eX7eVve5Xomie7fXII4+ITz75pPFnS+9bPF11B9XV1UhOTsaQIUPqTB8yZAgOHDhwy2UOHjx40/xDhw5FUlISampq6p3nduu0BZbaVgBQVlaGsLAwhISE4KGHHkJqaqr5P0Azasy2MgX3q4bhfnUzg8GA0tJS+Pj4GKdxv7q1W20rwP72K8A82ys1NRUHDhxAbGyscZql9y2WnDvQaDTQ6/UICAioMz0gIAD5+fm3XCY/P/+W89fW1kKj0dQ7z+3WaQssta06duyIhIQEfPXVV9i4cSOcnZ0xYMAAnDt3zjIfpBk0ZluZgvuV6bhf3drixYtRXl6Oxx9/3DiN+9Wt3Wpb2eN+BTRte4WEhEClUiE6OhrPP/88pk6davydpfcth34KeUMIglDnZ1EUb5p2p/n/Or2h67QV5t5Wffv2Rd++fY2/HzBgAHr16oUPP/wQH3zwgbliS8IS+wD3K9Nwv7rZxo0bERcXhx07dqBFixZmWae1M/e2suf9Cmjc9tq7dy/KysqQmJiIuXPnom3bthg3blyT1mkqlpw78PPzg1wuv6lVFhYW3tQ+bwgMDLzl/AqFAr6+vvXOc7t12gJLbau/kslk6N27t03/ZdSYbWUK7leN5+j71ebNmzFlyhR8+eWXGDRoUJ3fcb+qq75t9Vf2sF8BTdteERERAIBu3bqhoKAAcXFxxpJj6X2Lp6vuQKlUIioqCrt27aozfdeuXejfv/8tl+nXr99N8+/cuRPR0dFwcnKqd57brdMWWGpb/ZUoikhLS0PLli3NE1wCjdlWpuB+1XiOvF9t3LgRkyZNwueff44HH3zwpt9zv/rDnbbVX9nDfgWY779DURSh0+mMP1t83zLL8GU7d+OyudWrV4snT54UZ8+eLbq5uYmZmZmiKIri3LlzxQkTJhjnv3FZ9EsvvSSePHlSXL169U2XRe/fv1+Uy+Xiu+++K546dUp899137eqSTHNuq7i4OPGHH34QL1y4IKampoqTJ08WFQqFeOjQoWb/fObU0G0liqKYmpoqpqamilFRUeL48ePF1NRUMT093fh77ld/uNO24n513eeffy4qFArxo48+qnPJc3FxsXEe7lfXmbKt7HW/EsWGb6+lS5eKX331lXj27Fnx7Nmz4po1a0RPT0/xjTfeMM5j6X2LJcdEH330kRgWFiYqlUqxV69e4p49e4y/mzhxohgbG1tn/l9//VXs2bOnqFQqxfDwcHH58uU3rfPLL78UO3ToIDo5OYkdO3YUt27daumP0SzMva1mz54ttmrVSlQqlaK/v784ZMgQ8cCBA83xUSyuodsKwE2vsLCwOvNwv7ruTtuK+9V1sbGxt9xWEydOrLNO7lembSt73q9EsWHb64MPPhC7dOkiurq6ip6enmLPnj3FZcuWiXq9vs46LblvCaL4+yhPIiIiIjvCMTlERERkl1hyiIiIyC6x5BAREZFdYskhIiIiu8SSQ0RERHaJJYeIiIjsEksOERER2SWWHCIiIrJLLDlERERkl1hyiIiIyC6x5BCR3dmyZQu6desGFxcX+Pr6YtCgQSgvL5c6FhE1M4XUAYiIzCkvLw/jxo3Dv//9bzzyyCMoLS3F3r17wcf0ETkePqCTiOxKSkoKoqKikJmZibCwMKnjEJGEeLqKiOxKjx49cP/996Nbt24YPXo0Vq1ahWvXrkkdi4gkwCM5RGR3RFHEgQMHsHPnTmzfvh35+fk4dOgQIiIipI5GRM2IJYeI7Jper0dYWBhefvllvPzyy1LHIaJmxIHHRGRXDh06hJ9//hlDhgxBixYtcOjQIVy5cgWdOnWSOhoRNTOWHCKyK56envjtt9/w/vvvQ6vVIiwsDIsXL8bw4cOljkZEzYynq4iIiMgu8eoqIiIiskssOURERGSXWHKIiIjILrHkEBERkV1iySEiIiK7xJJDREREdoklh4iIiOwSSw4RERHZJZYcIiIiskssOURERGSXWHKIiIjILrHkEBERkV36f2gmI3l9RJFTAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot the results\n",
+    "plt.figure()\n",
+    "plt.plot(s_space, potential)\n",
+    "plt.xlabel('s')\n",
+    "#plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n",
+    "#plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n",
+    "#plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n",
+    "plt.title('First DBI step')\n",
+    "plt.ylabel('Least squares cost function')\n",
+    "plt.legend()\n",
+    "plt.figure()\n",
+    "plt.plot(s_space, off_diagonal_norm_diff)\n",
+    "#plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n",
+    "#plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n",
+    "#plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n",
+    "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n",
+    "plt.xlabel('s')\n",
+    "plt.title('First DBI step')\n",
+    "plt.legend()\n",
+    "print('The minimum for cost function in the tested range is:', step_grid)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Comparison of the least-squares cost function with the original cost function using the polynomial scheduling method"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n",
+    "off_diagonal_norm_diff_least_squares = [dbi.off_diagonal_norm]\n",
+    "iters = 100\n",
+    "dbi_ls = deepcopy(dbi)\n",
+    "cost = DoubleBracketCostFunction.off_diagonal_norm\n",
+    "dbi_od = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "for _ in range(iters):\n",
+    "    step_poly = dbi_od.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n",
+    "    dbi_od(step_poly,d=d)\n",
+    "    step_poly = dbi_ls.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n",
+    "    dbi_ls(step_poly,d=d)\n",
+    "    off_diagonal_norm_diff.append(dbi_od.off_diagonal_norm)\n",
+    "    off_diagonal_norm_diff_least_squares.append(dbi_ls.off_diagonal_norm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x2105e8949a0>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABo2ElEQVR4nO3dd3hUddrG8e+kTXpCekICCSW0UAWpUhRUVBRx7QVWF9dVVNbXsqtbdFUQFdaOrgVZGzZwsYDUIIL03jsESAjpvZ/3j5MMRCAmkGQmk/tzXXMlc+bMmSdnI7n3Vy2GYRiIiIiIOAkXexcgIiIiUp8UbkRERMSpKNyIiIiIU1G4EREREaeicCMiIiJOReFGREREnIrCjYiIiDgVN3sX0NgqKio4fvw4fn5+WCwWe5cjIiIitWAYBrm5uURFReHiUnPbTLMLN8ePHycmJsbeZYiIiMh5SEpKIjo6usZzml248fPzA8yb4+/vb+dqREREpDZycnKIiYmx/R2vSbMLN1VdUf7+/go3IiIiTUxthpRoQLGIiIg4FYUbERERcSoKNyIiIuJUmt2YGxGR5qK8vJzS0lJ7lyFSK+7u7ri6utbLtRRuREScjGEYpKSkkJWVZe9SROokMDCQiIiIC16HTuFGRMTJVAWbsLAwvL29tWCpODzDMCgoKCA1NRWAyMjIC7qewo2IiBMpLy+3BZvg4GB7lyNSa15eXgCkpqYSFhZ2QV1UGlAsIuJEqsbYeHt727kSkbqr+r290LFiCjciIk5IXVHSFNXX763CjYiIiDgVhRsRERFxKgo3IiLS5BQUFHDDDTfg7++PxWIhKyvrrMdqY+jQoUycONH2PDY2lldeeaVB6m5o48aNY/To0fYuw+4UbupJUWE+yYf3kHb8sL1LERFpspKSkrjnnnuIiorCw8OD1q1b8/DDD5Oenl7tvJkzZ7J8+XJWrlxJcnIyAQEBZz12PtauXcu9995bHz+O2InCTT3Z+Mk/iJzRh32z/2nvUkREmqQDBw7Qu3dv9uzZw2effca+fft4++23Wbx4Mf379ycjI8N27v79++nUqRMJCQm2Rd/Odux8hIaGarZZHTnaStgKN/XExScIAPeiTDtXIiJSnWEYFJSU2eVhGEat63zggQfw8PBgwYIFDBkyhFatWjFy5EgWLVrEsWPHeOqppwCzG2nq1Kn89NNPWCwWhg4detZjZ5Ofn89dd92Fr68vkZGRTJ069Yxzft0tNW3aNLp27YqPjw8xMTHcf//95OXlVXvPu+++S0xMDN7e3lx//fVMmzaNwMDAaudMnz6dtm3b4uHhQYcOHfjoo4+qvW6xWHjvvfe4/vrr8fb2pn379sydO9f2enl5Offccw9xcXF4eXnRoUMHXn311VrfX4APP/yQwMBAfvzxRzp16oSvry9XXnklycnJtnMqKir417/+RXR0NFarlR49ejB//nzb64cOHcJisfDFF18wdOhQPD09+fjjj21dYpMmTSI8PJzAwECeeeYZysrKeOyxxwgKCiI6OpoPPvigTjWfDy3iV0/c/EIB8CjJsm8hIiK/UlhaTud//GiXz97xryvw9vjtPzUZGRn8+OOPPP/887bF3KpERERw++238/nnn/PWW28xe/Zs/vKXv7Bt2zZmz56Nh4cHwFmP/dpjjz3G0qVLmTNnDhERETz55JOsX7+eHj16nLM2FxcXXnvtNWJjYzl48CD3338/jz/+OG+99RYAK1as4L777mPKlClce+21LFq0iL///e/VrjFnzhwefvhhXnnlFYYPH853333H73//e6Kjoxk2bJjtvGeeeYYXX3yRl156iddff53bb7+dw4cPExQUREVFBdHR0XzxxReEhISwcuVK7r33XiIjI7npppt+8x5XKSgo4OWXX+ajjz7CxcWFO+64g0cffZRPPvkEgFdffZWpU6fyzjvv0LNnTz744AOuvfZatm/fTvv27W3XeeKJJ5g6dSozZszAarWybNkylixZQnR0ND/99BMrVqzgnnvu4ZdffmHw4MGsXr2azz//nPvuu48RI0YQExNT65rrSi039cTT3ww33mXZdq5ERKTp2bt3L4Zh0KlTp7O+3qlTJzIzMzl58iRBQUF4e3vj4eFBREQEQUFBZz32a3l5ebz//vu8/PLLjBgxgq5duzJz5kzKy8trrG3ixIkMGzaMuLg4Lr30Up599lm++OIL2+uvv/46I0eO5NFHHyU+Pp7777+fkSNHVrvGyy+/zLhx47j//vuJj4/nkUceYcyYMbz88svVzhs3bhy33nor7dq1Y9KkSeTn57NmzRrA3FjymWeeoU+fPsTFxXH77bczbty4arXURmlpKW+//Ta9e/emV69eTJgwgcWLF1er9YknnuCWW26hQ4cOTJkyhR49epwxyHrixImMGTOGuLg4oqKiAAgKCuK1116jQ4cO3H333XTo0IGCggKefPJJ2rdvz1//+lc8PDxYsWJFnWquK7Xc1BPvQDPc+FYo3IiIY/Fyd2XHv66w22fXh6rurdqOo1m+fHm1gPHOO++QkJBASUkJ/fv3tx0PCgqiQ4cONV5r6dKlTJo0iR07dpCTk0NZWRlFRUXk5+fj4+PD7t27uf7666u95+KLL+a7776zPd+5c+cZg5QHDhx4RrdSt27dbN/7+Pjg5+dn228J4O233+a9997j8OHDFBYWUlJSUmOr09l4e3vTtm1b2/PIyEjbZ+Tk5HD8+HEGDhx4Rq2bN2+udqx3795nXLtLly64uJxqNwkPDychIcH23NXVleDg4Go/U0NQuKknfkHhAAQYuZSXV+DqqkYxEXEMFoulVl1D9tSuXTssFgs7duw461TmXbt20aJFC0JCQmp1vd69e7Np0ybb8/DwcPbv31/nug4fPsxVV13Ffffdx7PPPktQUBA///wz99xzj20QrWEYZ4Sus401Ots5vz7m7u5+xnsqKioA+OKLL/jzn//M1KlT6d+/P35+frz00kusXr26Tj/T2T7j1/XWplYfH59aXbumn6mh6C9wPQkINsONp6WUrOws+xYjItLEBAcHM2LECN566y0KCwurvZaSksInn3zCzTffXOuWGy8vL9q1a2d7+Pn50a5dO9zd3Vm1apXtvMzMTPbs2XPO66xbt46ysjKmTp1Kv379iI+P5/jx49XO6dixo63r6PT3na5Tp078/PPP1Y6tXLnynN1wZ7N8+XIGDBjA/fffT8+ePWnXrt15Bbaa+Pv7ExUVdcG12ptjR/kmxN3Tj2LcsVJKTsYJgs/S3ysiIuf2xhtvMGDAAK644gqee+454uLi2L59O4899hgtW7bk+eefv6Dr+/r6cs899/DYY48RHBxMeHg4Tz31VLVulF9r27YtZWVlvP7664waNYoVK1bw9ttvVzvnwQcfZPDgwUybNo1Ro0axZMkS5s2bVy2IPfbYY9x000306tWLyy67jG+//ZbZs2ezaNGiWtffrl07/vvf//Ljjz8SFxfHRx99xNq1a4mLi6v7zajBY489xj//+U/atm1Ljx49mDFjBps2bbINOG4K1HJTXywWci1+AORmNmxfooiIM2rfvj3r1q2jbdu23HzzzbRt25Z7772XYcOG8csvv5x1kHBdvfTSSwwePJhrr72W4cOHM2jQIC666KJznt+jRw+mTZvGlClTSEhI4JNPPmHy5MnVzhk4cCBvv/0206ZNo3v37syfP58///nPeHp62s4ZPXo0r776Ki+99BJdunThnXfeYcaMGeecsn429913H2PGjOHmm2+mb9++pKenc//999f5HvyWhx56iP/7v//j//7v/+jatSvz589n7ty51WZKOTqLUZdFCJxATk4OAQEBZGdn4+/vX6/XPvRcD2LLDrJm0HtcPPzGer22iEhtFBUVcfDgQeLi4qr9cZXGNX78eHbt2sXy5cvtXUqTUtPvb13+fqtbqh4VugVCGRTnpNm7FBERaURV08t9fHyYN28eM2fOtK2DI41P4aYelVoDoQjK8hRuRESakzVr1vDiiy+Sm5tLmzZteO211/jDH/5g77KaLYWbelTuGQTZQEH6b54rIiLOo64L6UnD0oDiemTxNge7uRRqfykRERF7UbipR66+5uJS7sUKNyIiIvaicFOP3P3McOOp/aVERETsRuGmHnkFmPtL+SjciIiI2I3CTT3yCTS3YPA3sqmoaFbLB4mIiDgMhZt65BcUBkAgeWQXltq5GhERkeZJ4aYeWf3NbikvSwkZWeqaEhGpi3Hjxp11R/DGYrFY+Oabb+z2+VJ/FG7qk4cvpZVLB+VmnrBzMSIi0lyUlJTYuwSHonBTnywWcl3M/S7yFW5EROrVjh07uOqqq/D19SU8PJw777yTtLRTK8LPnz+fQYMGERgYSHBwMNdccw379++3vV5SUsKECROIjIzE09OT2NhY2yaYsbGxAFx//fVYLBbb81+r6RoAe/fuZfDgwXh6etK5c2cWLlxYrUUoMTERi8VCVlaW7T2bNm3CYrFw6NAhANLT07n11luJjo7G29ubrl278tlnn1WrY+jQoUyYMIFHHnmEkJAQRowYUat79NVXX9G1a1e8vLwIDg5m+PDh5Ofn1+l/h6ZA4aaeFbgGAFCUc9LOlYiIVDIMKMm3z6Oe9mZOTk5myJAh9OjRg3Xr1jF//nxOnDjBTTfdZDsnPz+fRx55hLVr17J48WJcXFy4/vrrqaioAOC1115j7ty5fPHFF+zevZuPP/7YFmLWrl0LwIwZM0hOTrY9/7WarlFRUcGYMWNwdXVl1apVvP322zzxxBN1/lmLioq46KKL+O6779i2bRv33nsvd955J6tXr6523syZM3Fzc2PFihW88847v3mPkpOTufXWW7n77rvZuXMniYmJjBkzBmfcP1vbL9SzYo9AKIUSbZ4pIo6itAAmRdnns588Dh4+F3yZ6dOn06tXLyZNmmQ79sEHHxATE8OePXuIj4/nhhtuqPae999/n7CwMHbs2EFCQgJHjhyhffv2DBo0CIvFQuvWrW3nhoaaYyYDAwOJiIg4Zx01XWPRokXs3LmTQ4cOER0dDcCkSZMYOXJknX7Wli1b8uijj9qeP/jgg8yfP58vv/ySvn372o63a9eOF1980fb8H//4R433KC8vj7KyMsaMGWOru2vXrnWqralQy009K7W2AMDI1/5SIiL1Zf369SxduhRfX1/bo2PHjgC2rqf9+/dz22230aZNG/z9/YmLiwPMQALmgOVNmzbRoUMHHnroIRYsWFDnOmq6xs6dO2nVqpUt2AD079+/zp9RXl7O888/T7du3QgODsbX15cFCxbYfo4qvXv3rvb8t+5R9+7dueyyy+jatSs33ngj7777LpmZzrmivlpu6pnhZYYbCjPsW4iISBV3b7MFxV6fXQ8qKioYNWoUU6ZMOeO1yMhIAEaNGkVMTAzvvvsuUVFRVFRUkJCQYBts26tXLw4ePMi8efNYtGgRN910E8OHD+err76qdR01XeNs3TsWi6XacxcXs03h9HNLS6svHTJ16lT+/e9/88orr9C1a1d8fHyYOHHiGYOGfXyqt4j91j1ydXVl4cKFrFy5kgULFvD666/z1FNPsXr1alsQdBYKN/XM4hMMgGuRwo2IOAiLpV66huypV69efP3118TGxuLmduafrvT0dHbu3Mk777zDJZdcAsDPP/98xnn+/v7cfPPN3Hzzzfzud7/jyiuvJCMjg6CgINzd3SkvL//NWs51jc6dO3PkyBGOHz9OVJTZDfjLL79Ue29V91dycjItWpj/Z3jTpk3Vzlm+fDnXXXcdd9xxB2CGlr1799KpU6cLukdghq2BAwcycOBA/vGPf9C6dWvmzJnDI4888ps/d1Oibql65uZr/uJaS7LsW4iISBOUnZ3Npk2bqj2OHDnCAw88QEZGBrfeeitr1qzhwIEDLFiwgLvvvpvy8nJatGhBcHAw//nPf9i3bx9Lliw54w/2v//9b2bNmsWuXbvYs2cPX375JREREQQGBgLmjKnFixeTkpJyzu6amq4xfPhwOnTowF133cXmzZtZvnw5Tz31VLX3t2vXjpiYGJ5++mn27NnD999/z9SpU884p6qFZefOnfzxj38kJSXlN+/db92j1atXM2nSJNatW8eRI0eYPXs2J0+e/M3Q1BQ5VLiZPn063bp1w9/fH39/f/r378+8efNsr48bNw6LxVLt0a9fPztWfCZPf22eKSJyvhITE+nZs2e1xz/+8Q+ioqJYsWIF5eXlXHHFFSQkJPDwww8TEBCAi4sLLi4uzJo1i/Xr15OQkMCf//xnXnrppWrX9vX1ZcqUKfTu3Zs+ffpw6NAhfvjhB1tX0dSpU1m4cCExMTH07NnzrPXVdA0XFxfmzJlDcXExF198MX/4wx94/vnnq73f3d2dzz77jF27dtG9e3emTJnCc889V+2cv//97/Tq1YsrrriCoUOHEhERUavFDX/rHvn7+/PTTz9x1VVXER8fz9/+9jemTp1a5wHPTYHFcKA5YN9++y2urq60a9cOMKe5vfTSS2zcuJEuXbowbtw4Tpw4wYwZM2zv8fDwICgoqNafkZOTQ0BAANnZ2fj7+9f7z5C+8TuC/3c72yti6fzMpjP6W0VEGlJRUREHDx4kLi4OT09Pe5cjmF1Bc+bMsevqy01FTb+/dfn77VBjbkaNGlXt+fPPP8/06dNZtWoVXbp0AcBqtdY4Te/XiouLKS4utj3Pycmpn2LPwbeFub9UgCWPnMIyArzdG/TzREREpDqH6pY6XXl5ObNmzSI/P7/aVLrExETCwsKIj49n/PjxpKam1nidyZMnExAQYHvExMQ0aN1V+0sFkUt6fvFvnC0iIiL1zaFabgC2bt1K//79KSoqwtfXlzlz5tC5c2cARo4cyY033kjr1q05ePAgf//737n00ktZv349Vqv1rNf761//Wm1QWU5OTsMGHG+zi8zbUkxmdg6E+jbcZ4mIiMNzoNEfzYbDhZsOHTqwadMmsrKy+Prrrxk7dizLli2jc+fO3HzzzbbzEhIS6N27N61bt+b7779nzJgxZ72e1Wo9Z/BpEFZ/ynDFjXJyM1MBO60KKiIi0kw5XLeUh4cH7dq1o3fv3kyePJnu3bvz6quvnvXcyMhIWrduzd69exu5yhpYLORV7i9VmF1zl5mISENRa4E0RfX1e+tw4ebXDMOoNiD4dOnp6SQlJdlWp3QURW5muNH+UiLS2NzdzUkMBQUFdq5EpO6qfm+rfo/Pl0N1Sz355JOMHDmSmJgYcnNzmTVrFomJicyfP5+8vDyefvppbrjhBiIjIzl06BBPPvkkISEhXH/99fYuvZoSjxZQfJDSXO0MLiKNy9XVlcDAQNtkC29vby1JIQ7PMAwKCgpITU0lMDAQV1fXC7qeQ4WbEydOcOedd5KcnExAQADdunVj/vz5jBgxgsLCQrZu3cp///tfsrKyiIyMZNiwYXz++ef4+fnZu/Rqyj0DIReMAm2eKSKNr2q5jN+aTSriaH5rV/bacqhw8/7775/zNS8vL3788cdGrOb8GV7m/lIuhc6526qIODaLxUJkZCRhYWFnbMoo4qjc3d0vuMWmikOFG2fh4mtuweBWrHAjIvbj6upab38sRJoShx9Q3BR5+JktN56lWfYtREREpBlSuGkAngHmKsXeZdmajikiItLIFG4agE9gOACB5JBbXGbnakRERJoXhZsGULW/VAtLHhl5JXauRkREpHlRuGkIXi0AaEEu6fkKNyIiIo1J4aYheJsDin0sxWTl5Nq5GBERkeZF4aYheAZQXnlr87NO2LkYERGR5kXhpiFYLBTYNs/UFgwiIiKNSeGmgRR5BALaPFNERKSxKdw0kLLKcFORr3AjIiLSmBRuGki5VxAARoG2YBAREWlMCjcNxFI5Y8qtSDuDi4iINCaFmwbiVrl5pkdJln0LERERaWYUbhpI1SrFnqXaX0pERKQxKdw0EK9As+UmwMghv6TcztWIiIg0Hwo3DcTqFwZAoCWP1JwiO1cjIiLSfCjcNJTKAcVB5HIko8DOxYiIiDQfCjcNxducCt7CksvhdIUbERGRxqJw01Aqw42vpYikk1rrRkREpLEo3DQUawAVFlcAMk6m2LkYERGR5kPhpqG4uFDi0xIAI32fnYsRERFpPhRuGpAR1gmAwLx9lFdorRsREZHGoHDTgDwjuwDQzkjieFahnasRERFpHhRuGpAlvDMA7V2Ocig9387ViIiINA8KNw0prCMAHSxJHEpTuBEREWkMCjcNKbg9FbgSYCkgI/mQvasRERFpFhRuGpK7J7k+rQAoP7HLzsWIiIg0Dwo3DawkKB4A76zddq5ERESkeVC4aWAekQkAhBQeoELTwUVERBqcwk0D843pCkA7kkjR7uAiIiINTuGmgblGVE4HtxzlUFqunasRERFxfgo3DS2oDaW442MpJu2otmEQERFpaAo3Dc3VnXSv1gAUH99u52JEREScn8JNI8gPaAeAW5qmg4uIiDQ0hZtGYAk1x90E5KpbSkREpKEp3DQC72hzOnhEySEMQ9PBRUREGpLCTSMIiusBQFuOcTK7wL7FiIiIODmFm0bgERJHER5YLaUkH9ph73JEREScmsJNY3Bx4bi7OWMq78hWOxcjIiLi3Bwq3EyfPp1u3brh7++Pv78//fv3Z968ebbXDcPg6aefJioqCi8vL4YOHcr27U1jenWWrzljykhVy42IiEhDcqhwEx0dzQsvvMC6detYt24dl156Kdddd50twLz44otMmzaNN954g7Vr1xIREcGIESPIzXX8lX9LgzsC4JW1186ViIiIODeHCjejRo3iqquuIj4+nvj4eJ5//nl8fX1ZtWoVhmHwyiuv8NRTTzFmzBgSEhKYOXMmBQUFfPrpp/Yu/Td5RJrTwUMKD9i5EhEREefmUOHmdOXl5cyaNYv8/Hz69+/PwYMHSUlJ4fLLL7edY7VaGTJkCCtXrjzndYqLi8nJyan2sIcWsd0BiCo7hlFWbJcaREREmgOHCzdbt27F19cXq9XKfffdx5w5c+jcuTMpKSkAhIeHVzs/PDzc9trZTJ48mYCAANsjJiamQes/l4iYtuQYXrhbyslK2mmXGkRERJoDhws3HTp0YNOmTaxatYo//elPjB07lh07Tg3CtVgs1c43DOOMY6f761//SnZ2tu2RlJTUYLXXxNPDjcMurQDIPLTZLjWIiIg0B272LuDXPDw8aNfOnFnUu3dv1q5dy6uvvsoTTzwBQEpKCpGRkbbzU1NTz2jNOZ3VasVqtTZs0bV00qsNFOym+Pg2e5ciIiLitByu5ebXDMOguLiYuLg4IiIiWLhwoe21kpISli1bxoABA+xYYe3lBVbOmDq5xc6ViIiIOC+Harl58sknGTlyJDExMeTm5jJr1iwSExOZP38+FouFiRMnMmnSJNq3b0/79u2ZNGkS3t7e3HbbbfYuvVbKovvCcQjP3oxRVoLFzcPeJYmIiDgdhwo3J06c4M477yQ5OZmAgAC6devG/PnzGTFiBACPP/44hYWF3H///WRmZtK3b18WLFiAn5+fnSuvnUEDh5C12odA8tm6bjld+11m75JEREScjsVoZttU5+TkEBAQQHZ2Nv7+/o3++TunXUOnnOV85n83tz7y70b/fBERkaaoLn+/HX7MjbOJ7DEcgIjM9Ww8kmnnakRERJyPwk0jC+x0KQB9XHYzfcluO1cjIiLifBRuGlt4F8qtAfhaijixezU7k+2zYrKIiIizUrhpbC6uuMYOBKCvy07eXLrPzgWJiIg4F4Ube4gdBEA/l518vzWZ/Sfz7FyQiIiI81C4sYfWZstNf7c9uBjlTE/cb+eCREREnIfCjT1EdAVrAF5GAZ0th/lm4zEy8kvsXZWIiIhTULixBxdXaG1uGXGl717KKgx1TYmIiNQThRt7qRxU3N9lJwBHMwvsWY2IiIjTULixl8pBxZ1Kt+NCBUczCu1ckIiIiHNQuLGXiG5g9cerIp/OlkMkqeVGRESkXijc2IuLK7TqD5hTwo9mquVGRESkPijc2FNl11RfhRsREZF6o3BjT7Zws4uUrHzKK5rVBu0iIiINQuHGniK6YVj98bcU0ME4SEpOkb0rEhERafIUbuzJ1Q1LZevNQJdtHM3QoGIREZELpXBjb22GAma4SdK4GxERkQumcGNvcUMAuNhlN8lpGXYuRkREpOlTuLG30A7ke4RgtZTifnydvasRERFp8hRu7M1iISPc3GcqIn2VnYsRERFp+hRuHEBZ7GAA4vPX27kSERGRpk/hxgH4dRwOQMeK/ZTladyNiIjIhVC4cQBBkbHsM1riYjHI2rHY3uWIiIg0aQo3DsDFxcIWjx4AlO1bat9iREREmjiFGwdxOOBiAHyO/WznSkRERJo2hRsHkRPRl3LDgl/+YchKsnc5IiIiTZbCjYMIDQlls9HWfHJwmX2LERERacIUbhxEdAtvfq5IMJ8cSLRrLSIiIk2Zwo2DiGnhxYryruaTA4lgGHatR0REpKlSuHEQ0S282Wi0o8CwQv5JSN1h75JERESaJIUbBxHi64GLu5U1FR3NA+qaEhEROS8KNw7CYrFUH3ezZ759CxIREWmiFG4cSHQLL36s6G0+OfQz5KXatyAREZEmSOHGgUS38CLJCCfFpxMYFbBzrr1LEhERaXIUbhxITAtvAFZ7DzEPbJtjx2pERESaJoUbBxJdGW7mGf3MA4dXQG6KHSsSERFpehRuHEh0Cy8ANub4QXQfwIAd/7NvUSIiIk2Mwo0DqQo3J3KKKes02jy4bbb9ChIREWmCFG4cSJCPB94ergAcb3mFeTBpFWQfs2NVIiIiTYvCjQMx17oxW28OlQRCq/7mCzu+sVtNIiIiTY3CjYOpGlR8NLMQulxvHtyuWVMiIiK15VDhZvLkyfTp0wc/Pz/CwsIYPXo0u3fvrnbOuHHjsFgs1R79+vWzU8X1L6ay5eZoZgF0vg6wwNG1kHXEvoWJiIg0EQ4VbpYtW8YDDzzAqlWrWLhwIWVlZVx++eXk5+dXO+/KK68kOTnZ9vjhhx/sVHH9iwkyW24OpeeDXwTEDjJfUOuNiIhIrbjZu4DTzZ9ffT+lGTNmEBYWxvr16xk8eLDtuNVqJSIiorHLaxSdI/0B2HI02zzQZTQcWm6Gm4EP268wERGRJsKhWm5+LTvb/AMfFBRU7XhiYiJhYWHEx8czfvx4UlPPvQdTcXExOTk51R6OrGt0ABaLOeYmLa8YOl0HFhc4vhHS99u7PBEREYfnsOHGMAweeeQRBg0aREJCgu34yJEj+eSTT1iyZAlTp05l7dq1XHrppRQXF5/1OpMnTyYgIMD2iImJaawf4bz4ebrTLtQXgM1JWeAbCm2GmS9unmW/wkRERJoIhw03EyZMYMuWLXz22WfVjt98881cffXVJCQkMGrUKObNm8eePXv4/vvvz3qdv/71r2RnZ9seSUlJjVH+BekeEwhUhhuAHreZXzd/BhUVdqlJRESkqXDIcPPggw8yd+5cli5dSnR0dI3nRkZG0rp1a/bu3XvW161WK/7+/tUejq5HZbjZWBVuOl4N1gDIToLDP9utLhERkabAocKNYRhMmDCB2bNns2TJEuLi4n7zPenp6SQlJREZGdkIFTaOHqe13BiGAe5ekFC55s2mT+1XmIiISBPgUOHmgQce4OOPP+bTTz/Fz8+PlJQUUlJSKCwsBCAvL49HH32UX375hUOHDpGYmMioUaMICQnh+uuvt3P19adDhB9WNxdyiso4lF5gHuxxu/l1x1wozrNfcSIiIg7OocLN9OnTyc7OZujQoURGRtoen3/+OQCurq5s3bqV6667jvj4eMaOHUt8fDy//PILfn5+dq6+/ri7upDQMgCATUmZ5sHoPhDUFkrztVO4iIhIDRxqnRvDMGp83cvLix9//LGRqrGv7tGBrD+cyeakbK7vGQ0WizmweMmzZtdUz9vtXaKIiIhDcqiWGzmle0xVy03WaQdvASzmoOLMQ/YoS0RExOEp3DionjEtANhxPIfisnLzYEA0tBlifq81b0RERM6qTt1ScXFxWCyWOn/IxIkTeeihh+r8vuYsJsiLFt7uZBaUsis517b2DT1uhwOJZtfU4MfBRflURETkdHUKNx9++OF5fUhsbOx5va85s1gsdI8JJHH3STYfzToVbjpeAx5+kHUYjvwCsQPtWqeIiIijqVO4GTJkSEPVIWfRozLcbDqSxV39Kw96eJubaW78CNbPULgRERH5FfVpOLCq1ppNR7Oqv9DnD+bXrV9ByrZGrUlERMTRKdw4sO7RgQAcOJlPdmHpqReiekCXMYABi5+xR2kiIiIOSwOKHViQjwetg705nF7AlqNZXNI+9NSLl/4Nds6FvQvg4HKIu8R+hYqIiDgQDSh2cN2jAzmcXsDmpF+Fm+C2cNE4WPseLPon/GGxudCfiIhIM6cBxQ6ue0wgczcfZ1NS9pkvDn4cNn0Gx9abrTidr2v8AkVERBzMBY25KS0tJSkpid27d5ORkVFfNclpqnYI31S1Q/jp/MJhwATz+8X/gvJSREREmrs6h5u8vDzeeecdhg4dSkBAALGxsXTq1InQ0FBat27N+PHjWbt2bUPU2ix1ifLHzcVCWl4xRzMLzzyh/wTwDoH0feb0cBERkWauTuHm3//+N7Gxsbz77rtceumlzJ49m02bNrFnzx5++eUX/vnPf1JWVsaIESO48sor2bt3b0PV3Wx4urvSs1UgAMv2nDzLCf4w5HHz+8QXoDi38YoTERFxQBbjt7biPs2NN97IP/7xD7p27VrjecXFxbz//vt4eHjwhz/84YKLrE85OTkEBASQnZ2Nv7+/vcuplTeX7uOlH3dzWccw3h/X58wTykrgzT7mZpq974FrpjV6jSIiIg2pLn+/6xRunEFTDDc7k3MY+epyPN1d2PSPy/F0dz3zpAPL4L/Xmt/fNffUBpsiIiJOoC5/v+ttEb8ZM2bU16XkVzpG+BEZ4ElRaQWrDqSf/aQ2Q8xWG4C5E6A4r/EKFBERcSD1Fm5mz57N0qVLbc8LCwu5/fbb6+vyzZrFYmFohzAAEnefZdxNlRHPQEAryDpirn0jIiLSDNVbuPn444956qmn2LVrF3v37uWSSy5h6NCh9XX5Zm9YB3MBvyW7Us+cEl7F6gfXvWF+v/Y9OPhTI1UnIiLiOOq0iN/ZPPLII/To0YMePXrwwQcfcNttt2EYBh988AE9e/asjxoFGNguBA9XF45kFLD/ZD7twnzPfmKbIdD7blj3AfzvAfjTL2A9x7kiIiJO6IJbboYMGcLhw4d59tlnufHGGzl8+DBRUVEsWLCA77//vj5qFMDH6kbfNkEAJO5OrfnkEf861T214KlGqE5ERMRxXHC4ue666/j73//Ol19+ydatWzl69ChPP/00ISEhLFq0qD5qlErDKsfdLNn1G+HG1j1lgfUfwtavGrw2ERERR1HnqeCGYZzXzuCOoilOBa9yKC2foS8n4u5qYcPfR+Dn6V7zG5Y8Bz+9BB6+cG8ihLRvlDpFRETqW4NOBff19WXgwIE89NBDzJw5k23btlFRUXHexUrtxYb4EBfiQ2m5wYp9ab/9hqF/hdhLoCQPvhwHpWfZvkFERMTJ1DncvPTSS3Tq1Inly5czfvx4unfvjp+fH/3792fChAnMmDGDzZs3N0StQh26pgBcXOGG98AnFE5sg3mPN3B1IiIi9ndBKxQXFxfj5eXFk08+SUZGBhs2bGDLli0UFxdTXl5en3XWm6bcLQWwfO9J7nx/DaF+VtY8eVntuggPJMJ/RwMGXP8f6H5zA1cpIiJSv+ry9/uCpoJbrVYAbrrpJrp16wZAeXk527dvv5DLSg0ujgvC28OVk7nFbD+eQ0LLgN9+U5uhMOQJWPYCfDcRIhIgvEtDlyoiImIX9baIXxVXV1db0JH6Z3VzZWC7EKCWXVNVhjxuhpzSAvjsVijIaJgCRURE7Kzew400vOGdzHE3324+fu7Vin/NxRV+NwNaxELWYfhyLJSXNlyRIiIidlLncDN+/Hjefvtt1q1bR3FxMUCTnhreFI3sGonVzYW9qXlsPppd+zd6B8Etn5lTww/+BAv+1nBFioiI2Emdw83u3bt54oknuPjii/Hz8wPgmWee4Y033mDlypUUFBTUe5FSnb+nO1d1jQTgi3VJdXtzeGe4/h3z+9Vvw4aP6rk6ERER+zrv2VJ79+5l/fr1bNiwgfXr17Nx40aysrJwdXUlPj7eYQcVN/XZUlVW7k/jtndX42d1Y81Tw/HycK3bBRKnQOIkcHGHcd9Bq34NU6iIiEg9aJTZUu3bt6d9+/bccssttmMHDx5k3bp1bNy48XwvK7XULy6YmCAvkjIKmbctmTG9out2gcGPmWvf7JwLn94EY7+FyO4NU6yIiEgjqlO31JEjR2p8PS4ujhtvvJFJkyYBcOzYsfOvTGrk4mLhxotigPPomjIvANe/DTH9oCjbXAfnhGO2tomIiNRFncJNnz59GD9+PGvWrDnnOdnZ2bz77rskJCQwe/bsCy5Qzu2Gi6KxWGDVgQwOp+fX/QIePnD7l9DyIijMgP9eByf31H+hIiIijahO3VI7d+5k0qRJXHnllbi7u9O7d2+ioqLw9PQkMzOTHTt2sH37dnr37s1LL73EyJEjG6puAVoGejGoXQjL96bx1fqj/N/lHep+EU9/uONrmHktpGyBmaPg9z9AcNv6L1hERKQRnNeA4qKiIn744QeWL1/OoUOHKCwsJCQkhJ49e3LFFVeQkJDQELXWC2cZUFzl283HefCzjUQGePLzE5fi6nKe0/Lz02HmNZC6A/yj4a7/QUi7+i1WRETkPNXl7/d5z5bKyclpkuHA2cJNcVk5fSctJquglA9/34ehlRtrnpe8VPjwakjbA94hcMdXENWz/ooVERE5T3X5+33eKxS3aNGCr7/++nzfLvXE6ubK6B4tAfhy3dELu5hvGIz7ASJ7QEEafHiNuemmiIhIE3Le4cYwDKZPn07fvn3p168fEyZMYPXq1fVZm9TSjb3NaeALdqSQnld8YRfzDTXXvYkbAiV58MmNsH1OPVQpIiLSOC5ob6nNmzdz8cUXM3ToUHbv3s2QIUP485//XF+1SS11iQqgW3QApeUGM385fOEXtPqZs6g6XwflJfDl72H1O3B+PZgiIiKN6oLCzaeffsrrr7/OCy+8wMKFC1m7di1z585l6tSp9VWf1NIfB5uzm2auPER+cdmFX9DNam602ftuwIB5j8O3D0NZyYVfW0REpAGdd7gJDg4mJiam2rGuXbvy2muv8fbbb5/XNSdPnkyfPn3w8/MjLCyM0aNHs3v37mrnGIbB008/TVRUFF5eXgwdOtRht3poTFcmRBAb7E12YSmz1p7Hon5n4+IKV0+DEc8CFtgwE/57LeSdrJ/ri4iINIDzDjfdu3fn/fffP+N4u3btSEo6vz+uy5Yt44EHHmDVqlUsXLiQsrIyLr/8cvLzTy1Q9+KLLzJt2jTeeOMN1q5dS0REBCNGjCA3N/d8fxSn4Opi4d7K1pv3lh+gpKyifi5sscDAh+C2L8DqD0d+gXeHQfKW+rm+iIhIPTvvqeCrVq1i2LBhXH/99dx///1069aNwsJCHn/8cdasWcPOnTsvuLiTJ08SFhbGsmXLGDx4MIZhEBUVxcSJE3niiScAKC4uJjw8nClTpvDHP/7xjGsUFxdTXHxqkG1OTg4xMTFOMxX8dEWl5Vzy4lJO5hbz0u+6cWPvmN9+U12c3AOf3QIZ+8HdG659Hbr+rn4/Q0RE5CwaZSp4v379WLVqFcePH2fo0KG0aNGCqKgovvrqq3obc5OdnQ1AUFAQYG7MmZKSwuWXX247x2q1MmTIEFauXHnWa0yePJmAgADb49ddac7E092VewbFAfD2sv1UVNTzAODQeBi/GNpeCqUF8PU9MO8JKC+t388RERG5AOfdcnO61NRU1q9fT0VFBX379iUkJOSCCzMMg+uuu47MzEyWL18OwMqVKxk4cCDHjh0jKirKdu69997L4cOH+fHHH8+4TnNquQHILSplwAtLyC0q4z93XsTlXSLq/0MqymHp87C8MsTG9IObZoJfA3yWiIgIjdRyc7qwsDBGjhzJ1VdfXS/BBmDChAls2bKFzz777IzXLJbqWwwYhnHGsSpWqxV/f/9qD2fm5+nOnf1aA/BW4n7qIbueycUVLvsH3PKpOQ4naRW8MxgOraj/zxIREamjegk39e3BBx9k7ty5LF26lOjoaNvxiAizZSAlJaXa+ampqYSHhzdqjY7s9wPj8HBzYVNSFqsPZjTcB3W8Gu5NhLDOkHfC3Jtq6WQor4ep6CIiIuepTuEmLi6ONm3a1Pnx2muv1er6hmEwYcIEZs+ezZIlS4iLizvj8yMiIli4cKHtWElJCcuWLWPAgAF1+VGcWqiflRsvMkPhK4v2NEzrTZXgtvCHRdD9NjAqYNkLZsjJqqfp6CIiInXkVpeTP/zww/P6kNjY2Fqd98ADD/Dpp5/yv//9Dz8/P1sLTUBAAF5eXlgsFiZOnMikSZNo37497du3Z9KkSXh7e3PbbbedV23O6k9D2/Ll+qOsOpDBwh0nGmbsTRUPH7h+ujnQ+Ls/m9PF3x5ozqbqfF3Dfa6IiMhZ1MuA4vpyrnEzM2bMYNy4cYDZuvPMM8/wzjvvkJmZSd++fXnzzTdJSEio1Wc4267gNXlx/i7eStxPXIgPP04cjIdbI/RCZhw0Z1EdW28+73UXXDEZrL4N/9kiIuK06vL326HCTWNoTuEmt6iUYS8nkpZXwt+v6WybJt7gykvN2VQ/vwIYENQWbngPWvZqnM8XERGn02DhJi4u7pytKzWZOHEiDz30UJ3f1xCaU7gB+GzNEf46eysBXu4se2wogd4ejffhB3+C2X+E3OPg4gbDnoKBD5uzrUREROqgwcLNsmXLzqug2NhYWrdufV7vrW/NLdyUVxhc/dpydqXkMm5ALE9f26VxCyjIgO8mwo7/mc9bDYDRb0JQm8atQ0REmjR1S9WguYUbgJ/3pnHH+6txc7Hw458H0za0kce/GAZs+gR+eBxK882tG0b8C3rfAy4OuRqBiIg4mEZfxE8c26D2IVzaMYyyCoPJP1z4nl91ZrFAzzvg/pXQepC5dcMPj8JHozVlXERE6p3CTTPx5FWdcHWxsGhnKot2nLBPES1iYey3cOUUcPOCg8vgrf6wfqbZuiMiIlIPFG6aiXZhvrbZUk/O2Up2gZ02u3RxgX73wZ9WQExfKMmFbx+CT34H2cfsU5OIiDgVhZtm5JER8bQJ9SE1t5hnvt1u32KC28Lv58Hlz4GrFfYtMltxNn2qVhwREbkgCjfNiKe7Ky/f2B0XC8zeeMx+3VNVXFxhwINw38/QsjcUZ8M3f4JPb9JYHBEROW8KN81Mr1YtGH+JOQ37r3O2klVQYueKgNB4uPtHGP4MuHrA3gXwVj9Y/R+oqLB3dSIi0sQo3DRDfx4RT9tQH07mFvPMtzvsXY7J1Q0GTTRbcWL6QUkezHsMZlwJJ3fbuzoREWlCFG6aodO7p+ZsPMaC7Sn2LumU0A7mWJyrXgYPX0haDW8PgsQpUOYArUwiIuLwFG6aqZ6tWjB+sNk99dhXWzicnm/nik7j4gIXj4cHVkP7K6C8BBInwX+GwNF19q5OREQcnMJNM/bIiHh6tgoku7CUP360noKSMnuXVF1ANNz2OdzwPngHQ+oOeG84zPsLFOfZuzoREXFQCjfNmNXNlbfvuIhQPyu7UnJ57KstONxuHBYLdP0dPLAWut0CGLB6ujngePc8e1cnIiIOSOGmmQv392T67b1wc7Hw/ZZk3vnpgL1LOjufYBjzDtz+NQS0guwk+OwWmHW7Fv8TEZFqFG6E3rFB/LNyt/AX5+/ipz0n7VxRDdoPhwdWwcCHweIKu76DNy+GX96CcgfrVhMREbtQuBEA7ujbipt7x1BhwIOfbWRfqgOPafHwMXcVv285RF9sThv/8a/w7jA4tt7e1YmIiJ0p3AgAFouFZ67rQo8Yc4Dx2A/WkJxdaO+yahbexVz875pXwDMAUrbAu5fB949CUba9qxMRETtRuBEbT3dX3h/bmzYhPhzLKmTsB2scYwXjmri4QO/fw4R10O1mwIC178IbF8O22dqnSkSkGVK4kWqCfa38956LCfe3sudEHvfMXEdhSbm9y/ptvmEw5j9w5zcQ1BbyUuCr38NHoyFtr72rExGRRqRwI2eIbuHNf+/ui7+nG+sPZ/LApxsoLW8iezy1HQZ/WglD/2ruNn4g0dxtfNEzUOJACxWKiEiDUbiRs+oQ4ccH4/rg6e7Ckl2p/N8XmylrKgHH3ROG/uXUCscVpfDzNLOrasdcdVWJiDg5hRs5p96xQbxVuQbO3M3HefjzTU2nBQcgKM5c4fiWz8y1cXKOwhd3wsc3QNo+e1cnIiINROFGanRpx3Deur0X7q7mIn8PfrqRkrImFHAsFuh4ldmKM/gxcPWA/Ythen9Y/C91VYmIOCGFG/lNl3eJ4J07L8LD1YX521O4/5MNFJc1gUHGp/Pwhkv/BvevgnbDzc04l081u6q2z1FXlYiIE1G4kVq5tGM4747tjdXNhUU7T/CnjzdQVNrEAg5AcFu4/Su4+RMIiDG7qr4cB/+9FlJ32rs6ERGpBwo3UmtD4kOrDTK+6/01ZBeW2rusurNYoNM18MAaGPKEOavq4E8wfaC543hhlr0rFBGRC6BwI3UysF0I/727L35WN9YcyuDmd34hNafI3mWdHw9vGPYkTFgDHa8Bo9zccfz1i2D9h1DRBFumRERE4Ubq7uK4ID7/Y39CfK3sSsnlhrdXcjCtCQ/MbRELt3wCd8yGkHgoSINvH4b/DIXDv9i7OhERqSOFGzkvnaP8mf2nAbQO9iYpo5DfTV/J1qNNfD+ndpeZCwBeMRmslXtVzbgSvrobso/auzoREaklhRs5b62CvfnqvgF0jvQnPb+Em//zC4t3nrB3WRfG1R363w8PbYBeYwELbPsaXu8NiVOg1ME3ExUREYUbuTChflZm/bEfA9sFU1BSzvj/rmPmykP2LuvC+YTAta/BH5dBqwFQVgiJkzR1XESkCVC4kQvm7+nOh7+/mJt7x1BhwD/nbudf3+6gvMIJAkBkd/j9D/C7D8A/GrKPmFPHP7gSjq6zd3UiInIWCjdSL9xdXXjhhq48dkUHAD5YcZD7Pl5PfnGZnSurBxYLJNwAE9bCkL+AmxckrYL3LoMvfw+Zh+xdoYiInMZiGM2rfT0nJ4eAgACys7Px9/e3dzlO6dvNx/m/LzdTUlZBxwg/3hvbm+gW3vYuq/7kHIclz8OmTwDD3NKh7x/N7R08A+xdnYiIU6rL32+13Ei9G9U9is/G97NNFb/ujRWsOZhh77Lqj38UjH4T/vgTxA0xt3JY+Tq81gvWzdD6OCIidqZwIw3iotYtmDthIAktzZlUt7+3illrjti7rPoV2Q3u+h/c9gUEtzfXx/luIrwzGA4ss3d1IiLNlrqlpEEVlpTz6Feb+X5LMgB39W/N367ujIebk+Xq8lJY+x4kToaiyvV+2g03N+uM6mnf2kREnEBd/n4r3EiDMwyDN5fu4+UFewDo3boFb93eizB/TztX1gAKMsyAs+4DqKgcTN3pWhj2FIR1tG9tIiJNmMJNDRRu7GfxzhNM/HwTuUVlhPpZmX57L3rHBtm7rIaRcRASX4AtnwMGWFyg+61mS45/lL2rExFpcprsgOKffvqJUaNGERUVhcVi4Ztvvqn2+rhx47BYLNUe/fr1s0+xUmeXdQpn7oRBxIf7cjK3mFv+s4r//nIIp8zXQXEw5h24/xfoNAqMCnN21Wu9YOkkKM6zd4UiIk7LocJNfn4+3bt354033jjnOVdeeSXJycm2xw8//NCIFcqFigvxYc79A7m6WyRlFQb/+N92Jn6+yTnWwzmbsE5w88fwhyUQ089c6XjZFHPn8Q3/hXIn/blFROzIYbulLBYLc+bMYfTo0bZj48aNIysr64wWnbpQt5RjMAyD95Yf5IX5uyivMGgX5sv023vRPtzP3qU1HMOAnXNh4T9OLfzXIhYGToQet4Gb1Y7FiYg4tibbLVUbiYmJhIWFER8fz/jx40lNTa3x/OLiYnJycqo9xP4sFgvjB7fh83v7EeHvyb7UPK59YwWzNzjx7tsWC3S+Dh5YA5c/D97BZsj5biK82h1+eRNK8u1dpYhIk9ekws3IkSP55JNPWLJkCVOnTmXt2rVceumlFBcXn/M9kydPJiAgwPaIiYlpxIrlt/SODeL7hwZxSfsQCkvLeeSLzTzx1RYKS5x4ITw3KwyYABO3wpUvgF8U5CbDj0/Caz3NhQDVXSUict6aVLfUryUnJ9O6dWtmzZrFmDFjznpOcXFxtfCTk5NDTEyMuqUcTHmFwRtL9vHK4j0YBrQP8+X123rSMaIZ/G9UVgybZ8HP0051V4V2hBH/gvaXmy0+IiLNnFN3S50uMjKS1q1bs3fv3nOeY7Va8ff3r/YQx+PqYuHh4e355J6+hPlZ2Zuax3VvrODjVYedczbV6dyscNFYeGAtXDkFvFrAyV3w6U0wcxTsX2qO1xERkVpp0uEmPT2dpKQkIiMj7V2K1JMB7UKY9/AlDO0QSnFZBX/7Zhv3f7KBrIISe5fW8Nw8oN998NAmGPgwuFrh0HL4aDRMH2DOriottHeVIiIOz6HCTV5eHps2bWLTpk0AHDx4kE2bNnHkyBHy8vJ49NFH+eWXXzh06BCJiYmMGjWKkJAQrr/+evsWLvUq2NfKB2P78LerO+HuamHethSufGU5K/el2bu0xuEVaHZJPbgOLv4juPtA6g6Y+yD8uwsse1EDj0VEauBQY24SExMZNmzYGcfHjh3L9OnTGT16NBs3biQrK4vIyEiGDRvGs88+W6dBwpoK3rRsOZrFw7M2cTAtH4sF7r2kDY9cHo/VzdXepTWewizY+BGs/g9kV24+6hdprnbc/VZwaUb3QkSaLW2/UAOFm6anoKSMZ7/byWeVu4p3jvTn1Vt6OPeaOGdTXgY7voHF/4Ksw+ax8K5w+bPQZqgGHouIU1O4qYHCTdO1YHsKT3y9hcyCUjzcXHjs8g7cPSgOV5dm9ke9rBhWvwM/vQzFlTuQR/WEi++FLmPA3Qk3JBWRZk/hpgYKN01bak4Rj3+9hcTdJwG4ODaIl27sRutgHztXZgf56eZWDus/hPLK5Q68gqDXXXDxeAiItmt5IiL1SeGmBgo3TZ9hGHy+Nolnv9tBfkk53h6uPHlVJ27v2wpLc+yayU8zZ1Kt+wCyk8xjbp7mtg4DHwYPb7uWJyJSHxRuaqBw4zySMgp47KvNrDqQAUD/NsG8cEPX5tmKA1BRDnvmw8o34MhK81hADFz+nLntQ3MMfiLiNBRuaqBw41wqKgxm/nKIKfN3UVRagae7C49e3oHfD2yGY3GqGAbs+B8s+NuplpzYS2DoX6D1QIUcEWmSFG5qoHDjnA6n5/OXr7fyy4F0AHq2CuTFG7o1vxlVpyspgBWvwopXoKzIPBbRDfrdDwljtAu5iDQpCjc1ULhxXoZh8NmaJCb9sJO84jLcXS3cN6QtDwxrh6d7M14LJvOwGXA2fQZllSsc+4ZD/wfMoOPqbtfyRERqQ+GmBgo3zi85u5C/zdnG4l2pAMQGe/Pc6K4Mah9i58rsrCDDnFm15l3IPW4eC+0Eo16BVv3sWZmIyG9SuKmBwk3zYBgGP25P4Z9zt3Mix5wmPbpHFE9e3Ykwv2a+Dkx5KWz5HBb+AwrMbjx6jYURz5ibdoqIOCCFmxoo3DQvuUWlTF2wh5m/HMIwwM/qxsQR8Yzt3xo3V4faWq3xFWSYAWfjR+Zzn1AY9Ii5Q7lHM51xJiIOS+GmBgo3zdPmpCz+/r9tbDlqrujbIdyPZ67rQr82wXauzAEcXgnfToS03eZzryBzLM7Ff1BLjog4DIWbGijcNF/lFQZfrEvixfm7yCwoBWBU9yieuLID0S2a+UJ3ZSWw+VP4+RXIPGge8/CDfn+CSx4Bdy+7licionBTA4Ubycwv4eUFu/l0zREMA6xuLoy/pA1/GtoWH6ubvcuzr6rNOZdPg9Tt5rHgdjDqNYgdaNfSRKR5U7ipgcKNVNl2LJvnvt9hW+E41M/KY1d04IZe0c13AcAqVQsBznsC8lLMY73vhuHPgKf+uxGRxqdwUwOFGzmdYRgs2HGCST/s5HB6AQAdI/x44sqODO0Q2jz3qjpdYZY56HjDTPO5XxRc+hR0u1nr44hIo1K4qYHCjZxNcVk5/115mNeX7CWnqAyAvnFB/GVkR3q20qBaDv4E3z4MGQfM5y1iYfBjCjki0mgUbmqgcCM1yS4o5a3EfcxYeYiSsgoAruwSwZ9HxNMhohlv5QBQWmguALjiVShIM48Ftoahf4Xut2jPKhFpUAo3NVC4kdo4nlXItIV7+HrDUQzD/Lt9bfcoJg6PJy6kma8BU5IP6z4wQ07+SfNY7CVwzSsQ0s6upYmI81K4qYHCjdTFnhO5/HvhHuZtMwfVurpYGNOzJRMubUfrYIUcVr8Dy14096xytZpdVQMfBjcPe1cnIk5G4aYGCjdyPrYdy+bfC/fY9qtydbFwXY8oJgxrR5tQXztXZ2eZh+C7R2D/YvN5aEdzVlX8FeqqEpF6o3BTA4UbuRAbjmTy2uK9JO42u2NcLHBNtygmXNqO+PBmPCbHMGDb1+bU8arxOBHdYMgT0PFqhRwRuWAKNzVQuJH6sDkpi9eX7GPRzhO2Y8M7hXHfkLb0jg2yY2V2VpABK16BNe9Bab55LLwrDP2LQo6IXBCFmxoo3Eh92n48mzeX7mPethSq/kvqE9uC+4a0ZViHMFya62KA+emw6k1Y/R8oyTWPxQ2GkS9CWCf71iYiTZLCTQ0UbqQhHDiZx7vLD/D1+mOUlJtTyNuG+nDPoDaM6dUST3dXO1doJwUZ8MsbsPINKC8GiytcPN5sydGmnCJSBwo3NVC4kYZ0IqeID34+yKerj5BbbC4GGOTjwR19W3Fn/1hC/ax2rtBOMg/Bj0/Bru/M597BMOAh6P178Aywa2ki0jQo3NRA4UYaQ25RKV+sO8oHPx/kWFYhAO6uFq7pFsXYAbH0iAm0b4H2sn+pOeg4bbf53MPPDDj9/gT+UfatTUQcmsJNDRRupDGVlVewYMcJ3lt+gA1HsmzHu8cEMm5Aa67qGonVrZl1WZWXwpYvYOVrcHKXeczF3VzleMgTEBhj3/pExCEp3NRA4UbsZcvRLD5ceYjvNifbxuUE+XhwY+9obr+4Na2Cve1cYSOrqIB9C82Vjg+vMI+5ekDve+CS/wPfUPvWJyIOReGmBgo3Ym9pecV8tvoIn645QnJ2ke344PhQbu/biks7huHu6mLHCu3gyGpY8iwcWm4+d/eB/vdD3z+BT7B9axMRh6BwUwOFG3EUZeUVLNmVyserj/DTnpO246F+Vm68KJpb+rRqXq05hgEHEmHxv+D4BvOYqxUSxkCf8RB9kV3LExH7UripgcKNOKLD6fl8uuYIX68/Slpeie34wHbB3NQ7hiu6RDSf6eSGYc6q+ullSN506nhUT7j4j5Bwg/auEmmGFG5qoHAjjqykrILFO0/w2doklu89aVsY0M/TjWu7R3FT7xi6RQdgaQ4r/RoGHFsPa96F7bOhvDL0+beEfvfDRWPB2oy3vBBpZhRuaqBwI01FUkYBX60/ylfrj9qmkwO0D/PlhouiGd2jJREBnnassBHlp8GG/5q7kOeZO7RjDYA+90DvuzXDSqQZULipgcKNNDUVFQa/HEjni3VJzN+WQnGZOdPKYoFB7UIY06slV3SJwNvDzc6VNoKyYtg8y5xGnr6v8qAF4i6BHrdDp1Hg4WPXEkWkYSjc1EDhRpqy7MJSftiazOwNR1l7KNN23NvDlSu6RHBdjygGtQvBzdlnW1VUwO7vzZacqhlWAB6+0OV6c2HAlhqALOJMFG5qoHAjzuJwej5zNh5j9oZjHMkosB0P8fXgmm5RXNsjip4xgc4/PifzMGz5HDZ9Ym7zUCWyh9ll1fV3as0RcQIKNzVQuBFnYxgGG5Oy+GbjMb7bkkxG/qnZVq2CvBnVPZJru7ekQ4STD741DDi8EtZ/CDu+OTUA2epvdld1uR7ihmimlUgTpXBTA4UbcWal5RUs33uSuZuOs2DHCQpKym2vxYf7MqpbFNd0jyIuxMlbMvLTzZacdR9A5sFTxz0DoOM1ZtBpMwxcm8E4JREnoXBTA4UbaS4KSspYvDOV/206zrI9qZSWn/pPPaGlP9d0i+LqrpHEBDnxQoEVFXBkJWz/BnbOhbwTp17zCYWE30G3m8w1dJy9+06kiVO4qYHCjTRH2QWl/Lgjhe+2JLNiXxrlFaf+s+8eHcDV3SK5qmsk0S2cOeiUw5FVsH2O+ShIO/VaSLzZdRV/pTkQ2aWZLJgo0oQo3NRA4Uaau/S8YuZtS+GHrcmsOpDOaTmH7jGBXN01wvmDTnkp7F9qDkTe9T2UnVpHCO9gaH+5GXTaDQerr/3qFBGbJhtufvrpJ1566SXWr19PcnIyc+bMYfTo0bbXDcPgmWee4T//+Q+ZmZn07duXN998ky5dutT6MxRuRE45mVvM/O0pfL/lOKsPZnD6vwbdowO4qqvZouPUXVfFubB7PuyZB/sWQVH2qdfcPM2A02kUxF8BXi3sV6dIM9dkw828efNYsWIFvXr14oYbbjgj3EyZMoXnn3+eDz/8kPj4eJ577jl++ukndu/ejZ9f7WaCKNyInF1qbhE/bkvh+63JrDmYUa1Fp2vLAEZ2jWBkQqRzD0YuL4Wk1bB7nrm/1elTy13cIKYvtBlqDkaO6qkBySKNqMmGm9NZLJZq4cYwDKKiopg4cSJPPPEEAMXFxYSHhzNlyhT++Mc/1uq6Cjciv62qRWfeWbquOkb4cVXXSEYmRNA+3ImnlxsGnNgGO7+FHXPh5M7qr1sDoM1gswur/eXgF2GfOkWaCacMNwcOHKBt27Zs2LCBnj172s677rrrCAwMZObMmWe9TnFxMcXFxbbnOTk5xMTEKNyI1FJ6XjELdpzgh63JrNyfXm0wcttQH67qGsmVCRF0jvR37gUDMw6Y43QOLIWDP1XvvgKI6GZ2XcUNhug+4O5lnzpFnFRdwk2TaVNNSTE3ywsPD692PDw8nMOHD5/zfZMnT+aZZ55p0NpEnFmwr5VbL27FrRe3IjO/hIU7TzB/WwrL955k/8l8Xl+yj9eX7KNVkDcjEyK4MiGCHs64MnJQG/PR5x5z5tXxjeYYnT0/wvENkLLFfPz0Eri4m7OuYgdC64HQqj94OPG4JREH02RablauXMnAgQM5fvw4kZGRtvPGjx9PUlIS8+fPP+t11HIj0jByikpZsjOVeduSSdx90rahJ0BkgCdXdIlgZEIEvWODcHVxsqDza3mpsG8x7FsIh1ac2rm8iqtH9fE6kd01Xkekjpyy5SYiwuzPTklJqRZuUlNTz2jNOZ3VasVqtTZ4fSLNjb+nO6N7tmR0z5YUlJSRuPsk87alsGTnCZKzi/hw5SE+XHmIEF8rl3cJZ2RCBP3aBOPujJt6+oZBj1vNh2GYXViHV8LhFWYXVs4xc4PPQ8thybPg7m227ET3gZiLIfpi8Am2908h4jSaTLiJi4sjIiKChQsX2sbclJSUsGzZMqZMmWLn6kSaN28PN9u08aLScpbvTWPetmQW7ThBWl4xn64+wqerjxDo7c7wTuFc2SWCQe1D8HR3wsXyLBYIbms+et1php30/eZYnQOJZsApyj4VdqqEdqrsxhoArQeB37n/T5uI1MyhuqXy8vLYt28fAD179mTatGkMGzaMoKAgWrVqxZQpU5g8eTIzZsygffv2TJo0icTERE0FF3FQJWUV/HIgnfnbUliwPYX00zb19LW6MaxjGCMTIhgSH4qPtcn8f60LU1EBaXvg6Bpz2nnSWkjbfeZ5Aa2gZU+I6gUte5m7nHvq3yxpvprsbKnExESGDRt2xvGxY8fy4Ycf2hbxe+edd6ot4peQkFDrz1C4EbGP8gqDtYcymL8thfnbUkjJKbK9ZnVzYUh8KFcmRHBZp3ACvNztWKkd5Ked6sY6tMKcgs6v/2m2QHgXc+xOq35md1Zga+2JJc1Gkw03jUHhRsT+KioMNh/NYv62FOZtS+FIRoHtNTcXCwPahXBllwhGdA4n1K8Zjpkryobjm8xZWMc2mDOzspPOPM8rCCK7mdPQI7ubj6C24OKE45qk2VO4qYHCjYhjMQyDncm5zN+ewvxtyew5kWd7zWKBPrFBXNklgisSImgZ2IzXjslJruzGquzOSt4MFaVnnucZYHZlRfeGlr3NwOMXoRYeafIUbmqgcCPi2PafzOPH7WbX1Zaj1RfK69oygCsTIriiSzjtwpx4deTaKC2C1B3m2jrJlWvspGyFsqIzz/UKMru0whMgoitE9YCQDpqOLk2Kwk0NFG5Emo5jWYX8uC2F+dtTWHuo+saebUN9uKJLBFd0iaBbdIDzLRp4PspL4cR2OLYOjq6HY+shfS8YFWee6+ZVGXR6msEnrDOEdtCgZXFYCjc1ULgRaZpO5hazaOcJftyewop9aZSWn/qnK8Lfk8u7hHN55wj6tglyzrV0zldpIZzcZYaelG1m607yZijJPfv5/tEQ3rlyHE/leJ4WserWErtTuKmBwo1I05dTVMrSXaks2H6CxN2p5JeU217z93Tj0o5hjOgcwZAOofg2lynmdVFRARn7zYHKxzeZ3Vsnd0Fu8tnPtwZAWEcIiYfQjmYLT2gHCIhR6JFGo3BTA4UbEedSVFrOL/vT+XF7Cot2niAt79RaOh6uLgxoF8zwTuEM7xRORICnHSttAgozIXWXORU9ZYvZwpO6E8pLzn6+NaByLE8XiEgwg09we622LA1C4aYGCjcizqu8wmDjkUwW7jjBgh0nOJiWX+31ri0DuKxTGMM7hdMlysl3Ma8vZSXmooMnd1V+3W1+Tdt79tlaAF4tzJATGm+O5QnrBGFdzG0qdM/lPCnc1EDhRqR5MAyD/SfzWLDjBIt2nGBjUla1AckR/p5c2imMyzqGMaBtCF4eTrgVREMqKzEHK6dsgxNbzTE9aXvPvh5PFe9gM/QEt4PgNuaaPCGVz92a4XpGUicKNzVQuBFpnk7mFrN0VyoLd57g571pFJaeGqdjdXNhQNtghnUMY1iHMGKCvO1YaRNXUmCO50nba7bypO4wHxkHzj5rC8DiCkFxZrdWWCcz7AS1gRZx4BOi1h4BFG5qpHAjIkWl5aw6kM7inaks2ZXKsazCaq+3DfVhWIcwhnQIpU9skHNu8NnYSgvNsJO+z9xINGO/+TVtLxRnn/t9Hn5m8AmJPzWQOaSDeUytPc2Kwk0NFG5E5HSGYbD7RC6Ju0+yZFcq6w9nUl5x6p9FT3cX+rcJZkh8KIPjQ4kL8dFYnfpkGJCbAid3Vrb07DRbeTIOQs4xztxjq4oF/KPMaeotYs1WnpB2ld1ebcG9Ga9m7aQUbmqgcCMiNckuLGX53pMs232Sn/ae5EROcbXXWwZ6cUn7EAa1D2Fg2xBa+HjYqdJmoLQIsg6brT1VA5mrvpbk1fBGCwTGmF1bga3MDUYDW5shKLgteAc11k8g9UjhpgYKNyJSW1WtOst2n2TZnpOsO5RJSfmpcSMWC3SO9GdguxAGtguhT2wLvD20rk6DMwwoSIfMQ5WPg5B+wBzgnLbH3Hi0Jl4tKsf1tDUDT2ArMwwFxEBANLg2s13pmwiFmxoo3IjI+SooKWPNwQyW701j+d6T1Tb5BHB3tdAjJpD+bYLp1yaYXq1baLxOYzMMyE8zg07mIcg6ApmHK79WdXXVwOJihpzgtmbLT1BbaNHaDD0BMWYwUrekXSjc1EDhRkTqS2pOESv3p7NiXxor96efMTDZw9WFHjGBXBwXxMVxQfRq3UIrJttbSYE5pid9n/nIOgxZSeYU9qwkKC+u+f1uXmYrT9U4n6A482tgKwhoae7KLg1C4aYGCjci0hAMw+BwegGrDqSz6kA6vxxIP2O8jquLhYQof3rHBtG7dQsuim1BmJ9WTXYYFRWQd6JyQHPVY39l+DkK+am/fQ0PPzPkBERXjvNpfWrQs1p+LojCTQ0UbkSkMRiGwcG0fNYczGDNoQzWHMzgaGbhGee1CvKmd+sW9GwVSM9WLegY4YebNv50TGXFZrdW1hFzNlfmwVNfs4+a21f8FjdP8IsE/5bmbK/AVmYAqhr47N8S3DRI/WwUbmqgcCMi9nIsq5C1BzNYdziDdYcy2X0il1//C+zl7kq36AB6tAqkR3Qg3WMCiQzw1PTzpqAkH3KOm0En+6jZ5WUb9HwI8k/W7jreIZUBKNL8GhBjdoUFtjK/94sE1+bXvalwUwOFGxFxFDlFpWw8ksWGw5lsOJLJpqQscovKzjgv1M9K9+gAEloG0K3yq7qzmqDSInPn9dzkyhCUZLYCnT7o+bfG/ABgAZ9Q8Is49aia6VX18IsCd+f6HVG4qYHCjYg4qooKcz+sDUcy2Xw0m81JWexKya22qGCVcH8rCVEBdInyp3NUAAkt/WkZ6KUWnqbMMKAgA3KPmwsbVoWgrCTIrgxB2cfOvWHpr3kGgG8E+IWbX/2jzODj39IcF+QXZa7549I0ZvQp3NRA4UZEmpLCknJ2JGez5Wg2W49ms/VYNvtO5p3RnQUQ4OVOxwg/OkX60ynS/No+zE+bgjqTinJzjZ/cFPORl3JaV1jSqS6xsqLaXc/iau7f5RsGvuGnxgMFVI4J8o0wX/MOtnsIUripgcKNiDR1+cVl7EjOYfuxbLYfz2H78Rz2puZSWn7mP+cWC8QG+9Ah3I/4CD86RvjRPsyX2BAf3DVw2TkZhjm4OS/VnP2Vd+K0rrCj5qDo7GOVY4BqGwEsZsDxDTttPFDUqXFBPqHm6z6h4OHTIDPCFG5qoHAjIs6ouKycfal57EzOZVdyDjtTctiZnEtGfslZz3dzsRAX4kN8uB9tw3xpF+ZL21Af2ob6auHB5qK8DArSKgNQ6mldYZXhJ+eY+VpBBrUPQZhrAQ2YAJf+rV7Lrcvf7+Y33FpExAlZ3VzpEhVAl6hTi8gZhkFaXgm7U3LZfSKX3Sk57DmRx77UPPKKy9ibmsfe1OqrLFssEN3CizYhvrQJ9aFNiA9tQs3vw/08cXHRmB6n4ep2akByTcrLzK6w/JOntQIlm2ODco6bwSg/zVwHqKwIygrB1b7T2dVyIyLSzBiGwfHsIvaeyGVvZdjZd9L8ml147sGqnu4uxAb7EBfiQ2yID7HB3rQO9iE22IcwP6uCT3NnGOZ0+II0cPcB39B6vby6pWqgcCMicnaGYZCeX8L+1DwOpOVz4GQeB07mcyAtn6SMAsrOMmuriqe7CzEtvGkd7E2rIB9aBXnROtiHmCAvolt4q6tLLpi6pUREpM4sFgshvlZCfK30bRNc7bXS8gqOZhZyKM0MO4fS8jmcUcDh9HyOZhZSVFpx1m6uKmF+VloFeRMT5E10Cy9iWphfo1t4ExnoqcHNUq/UciMiIhektLyCY5mFHM4o4EhGAUfS8zmSUcDh9AKOZhaSV3zmwoSns1ggwt+TloFetGzhZfsaFehFdKD51UcbjjZ7arkREZFG4+7qYo7BCfE54zXDMMgsKCWpMvgczSzkaKb5Nanya0lZBcnZRSRnF7Hu8Nn3Zwr0dicywIuWgZ5EBXoRGeBFVKAnkQFeRAZ4EhGg1h85ReFGREQajMViIcjHgyAfD7rHBJ7xetWMrqOZBRzLKuRoZiHHswo5llnIsSzzkVtURlZBKVkFpexMzjnH50Cor9UWdE4PPVXfh/lbsbpp7E9zoG4pERFxaDlFpSRnFXE8q5Dj2Wb4Sc4q4lhWIcnZRaRkF1FSXlGrawX7eBAR4EmEv6fta/hpz8P9PfH3dNM2Fg5I3VIiIuI0/D3d8Y9wp0OE31lfr6gwZ3mlZBdxPLuw2teU7CJScswur5KyCtLzS0jPL2H78bO3AIG5M7sZdKyE+1cGINvDPKZWIMemcCMiIk2ai4uFUD8roX5WukYHnPUcwzDIyC8hJaeIE5Vh5/TwcyLH/D6nqIzC0nIOpuVzMC2/xs9t4e1+ltDjSbif1fzqb84801igxqdwIyIiTs9isRDsayXY11ptFedfKywpN4NOZeAxH8Wk5BSRetr3JWUVZBaUkllQyq6U3Bo+1+wKC/Uzw06YX2UIqgxAVc9D/RSC6pPCjYiISCUvD9dzzvyqYhgG2YWlnMgptgWhk7nF1cLQicpjZRXmgOm0vBJ2Jtf82WYIOhV6bI9fhSAtiPjbFG5ERETqwGKxEOjtQaC3xznHAYE5FiijoITUyrCTmltkfm/7WszJnCJO5hVTWm7YxgPV1BIE4O/pZoYgP3PsT1jl96G2MGQl1K95D4xWuBEREWkALi6nVnzuHHXu2T0VFQZZhaWVAaiY1F9/zS22BaPisgpyisrIKSpj/8maxwRZ3VxOBZ7Twk9oZQCqOhbs44Gbk3WJKdyIiIjYkYvLqbWAOkWe+zzDMMgpLONknhl0Tg89J/OKK4+ZgSi3qIzisorKRRMLa/z8qnFBIb5mF1ior9U2QDvUz0qob1VrkBU/a9NoDVK4ERERaQIsFgsB3u4EeLvTLuzc3WEARaXlnKwMPyerWn9yim3HUnPN79PyiqkwsI0L+q0usarWoKrQU/V9iK/1jOP2HBukcCMiIuJkPN1diancqLQm5RXmFPmq0JOWV1ItEKXlmq1CJ+vYGjRuQCxPX9ulPn+kOlG4ERERaaZcT1sjqDM1r/pbWGK2BlWFnaqvaVXPc08dD/WzNtJPcHZNKtw8/fTTPPPMM9WOhYeHk5KSYqeKREREmgcvD1daBXvTKrjm1iDDMCivsO/OTk0q3AB06dKFRYsW2Z67umq+v4iIiKOwWCy4udp30HGTCzdubm5ERETU+vzi4mKKi4ttz3Nyzr2fiIiIiDR9TW5i+969e4mKiiIuLo5bbrmFAwcO1Hj+5MmTCQgIsD1iYmIaqVIRERGxB4thGPbtGKuDefPmUVBQQHx8PCdOnOC5555j165dbN++neDg4LO+52wtNzExMbXaMl1EREQcQ05ODgEBAbX6+92kws2v5efn07ZtWx5//HEeeeSRWr2nLjdHREREHENd/n43uW6p0/n4+NC1a1f27t1r71JERETEQTTpcFNcXMzOnTuJjKxhvWoRERFpVppUuHn00UdZtmwZBw8eZPXq1fzud78jJyeHsWPH2rs0ERERcRBNair40aNHufXWW0lLSyM0NJR+/fqxatUqWrdube/SRERExEE0qXAza9Yse5cgIiIiDq5JdUuJiIiI/BaFGxEREXEqCjciIiLiVBRuRERExKk0qQHF9aFqQWZtoCkiItJ0VP3drs3GCs0u3OTm5gJoA00REZEmKDc3l4CAgBrPadJ7S52PiooKjh8/jp+fHxaLpV6vXbUpZ1JSkvatakC6z41D97lx6D43Dt3nxtGQ99kwDHJzc4mKisLFpeZRNc2u5cbFxYXo6OgG/Qx/f3/9x9MIdJ8bh+5z49B9bhy6z42joe7zb7XYVNGAYhEREXEqCjciIiLiVBRu6pHVauWf//wnVqvV3qU4Nd3nxqH73Dh0nxuH7nPjcJT73OwGFIuIiIhzU8uNiIiIOBWFGxEREXEqCjciIiLiVBRuRERExKko3NSTt956i7i4ODw9PbnoootYvny5vUtq0iZPnkyfPn3w8/MjLCyM0aNHs3v37mrnGIbB008/TVRUFF5eXgwdOpTt27fbqWLnMHnyZCwWCxMnTrQd032uH8eOHeOOO+4gODgYb29vevTowfr1622v6z5fuLKyMv72t78RFxeHl5cXbdq04V//+hcVFRW2c3Sfz89PP/3EqFGjiIqKwmKx8M0331R7vTb3tbi4mAcffJCQkBB8fHy49tprOXr0aMMUbMgFmzVrluHu7m68++67xo4dO4yHH37Y8PHxMQ4fPmzv0pqsK664wpgxY4axbds2Y9OmTcbVV19ttGrVysjLy7Od88ILLxh+fn7G119/bWzdutW4+eabjcjISCMnJ8eOlTdda9asMWJjY41u3boZDz/8sO247vOFy8jIMFq3bm2MGzfOWL16tXHw4EFj0aJFxr59+2zn6D5fuOeee84IDg42vvvuO+PgwYPGl19+afj6+hqvvPKK7Rzd5/Pzww8/GE899ZTx9ddfG4AxZ86caq/X5r7ed999RsuWLY2FCxcaGzZsMIYNG2Z0797dKCsrq/d6FW7qwcUXX2zcd9991Y517NjR+Mtf/mKnipxPamqqARjLli0zDMMwKioqjIiICOOFF16wnVNUVGQEBAQYb7/9tr3KbLJyc3ON9u3bGwsXLjSGDBliCze6z/XjiSeeMAYNGnTO13Wf68fVV19t3H333dWOjRkzxrjjjjsMw9B9ri+/Dje1ua9ZWVmGu7u7MWvWLNs5x44dM1xcXIz58+fXe43qlrpAJSUlrF+/nssvv7za8csvv5yVK1faqSrnk52dDUBQUBAABw8eJCUlpdp9t1qtDBkyRPf9PDzwwANcffXVDB8+vNpx3ef6MXfuXHr37s2NN95IWFgYPXv25N1337W9rvtcPwYNGsTixYvZs2cPAJs3b+bnn3/mqquuAnSfG0pt7uv69espLS2tdk5UVBQJCQkNcu+b3caZ9S0tLY3y8nLCw8OrHQ8PDyclJcVOVTkXwzB45JFHGDRoEAkJCQC2e3u2+3748OFGr7EpmzVrFhs2bGDt2rVnvKb7XD8OHDjA9OnTeeSRR3jyySdZs2YNDz30EFarlbvuukv3uZ488cQTZGdn07FjR1xdXSkvL+f555/n1ltvBfT73FBqc19TUlLw8PCgRYsWZ5zTEH8rFW7qicViqfbcMIwzjsn5mTBhAlu2bOHnn38+4zXd9wuTlJTEww8/zIIFC/D09DznebrPF6aiooLevXszadIkAHr27Mn27duZPn06d911l+083ecL8/nnn/Pxxx/z6aef0qVLFzZt2sTEiROJiopi7NixtvN0nxvG+dzXhrr36pa6QCEhIbi6up6RPFNTU89IsVJ3Dz74IHPnzmXp0qVER0fbjkdERADovl+g9evXk5qaykUXXYSbmxtubm4sW7aM1157DTc3N9u91H2+MJGRkXTu3LnasU6dOnHkyBFAv8/15bHHHuMvf/kLt9xyC127duXOO+/kz3/+M5MnTwZ0nxtKbe5rREQEJSUlZGZmnvOc+qRwc4E8PDy46KKLWLhwYbXjCxcuZMCAAXaqqukzDIMJEyYwe/ZslixZQlxcXLXX4+LiiIiIqHbfS0pKWLZsme57HVx22WVs3bqVTZs22R69e/fm9ttvZ9OmTbRp00b3uR4MHDjwjKUM9uzZQ+vWrQH9PteXgoICXFyq/1lzdXW1TQXXfW4YtbmvF110Ee7u7tXOSU5OZtu2bQ1z7+t9iHIzVDUV/P333zd27NhhTJw40fDx8TEOHTpk79KarD/96U9GQECAkZiYaCQnJ9seBQUFtnNeeOEFIyAgwJg9e7axdetW49Zbb9WUznpw+mwpw9B9rg9r1qwx3NzcjOeff97Yu3ev8cknnxje3t7Gxx9/bDtH9/nCjR071mjZsqVtKvjs2bONkJAQ4/HHH7edo/t8fnJzc42NGzcaGzduNABj2rRpxsaNG21LntTmvt53331GdHS0sWjRImPDhg3GpZdeqqngju7NN980WrdubXh4eBi9evWyTVmW8wOc9TFjxgzbORUVFcY///lPIyIiwrBarcbgwYONrVu32q9oJ/HrcKP7XD++/fZbIyEhwbBarUbHjh2N//znP9Ve132+cDk5OcbDDz9stGrVyvD09DTatGljPPXUU0ZxcbHtHN3n87N06dKz/ps8duxYwzBqd18LCwuNCRMmGEFBQYaXl5dxzTXXGEeOHGmQei2GYRj13x4kIiIiYh8acyMiIiJOReFGREREnIrCjYiIiDgVhRsRERFxKgo3IiIi4lQUbkRERMSpKNyIiIiIU1G4EREREaeicCMiTi82NpZXXnnF3mWISCNRuBGRejVu3DhGjx4NwNChQ5k4cWKjffaHH35IYGDgGcfXrl3Lvffe22h1iIh9udm7ABGR31JSUoKHh8d5vz80NLQeqxERR6eWGxFpEOPGjWPZsmW8+uqrWCwWLBYLhw4dAmDHjh1cddVV+Pr6Eh4ezp133klaWprtvUOHDmXChAk88sgjhISEMGLECACmTZtG165d8fHxISYmhvvvv5+8vDwAEhMT+f3vf092drbt855++mngzG6pI0eOcN111+Hr64u/vz833XQTJ06csL3+9NNP06NHDz766CNiY2MJCAjglltuITc313bOV199RdeuXfHy8iI4OJjhw4eTn5/fQHdTROpC4UZEGsSrr75K//79GT9+PMnJySQnJxMTE0NycjJDhgyhR48erFu3jvnz53PixAluuummau+fOXMmbm5urFixgnfeeQcAFxcXXnvtNbZt28bMmTNZsmQJjz/+OAADBgzglVdewd/f3/Z5jz766Bl1GYbB6NGjycjIYNmyZSxcuJD9+/dz8803Vztv//79fPPNN3z33Xd89913LFu2jBdeeAGA5ORkbr31Vu6++2527txJYmIiY8aMQfsQizgGdUuJSIMICAjAw8MDb29vIiIibMenT59Or169mDRpku3YBx98QExMDHv27CE+Ph6Adu3a8eKLL1a75unjd+Li4nj22Wf505/+xFtvvYWHhwcBAQFYLJZqn/drixYtYsuWLRw8eJCYmBgAPvroI7p06cLatWvp06cPABUVFXz44Yf4+fkBcOedd7J48WKef/55kpOTKSsrY8yYMbRu3RqArl27XsDdEpH6pJYbEWlU69evZ+nSpfj6+toeHTt2BMzWkiq9e/c+471Lly5lxIgRtGzZEj8/P+666y7S09Pr1B20c+dOYmJibMEGoHPnzgQGBrJz507bsdjYWFuwAYiMjCQ1NRWA7t27c9lll9G1a1duvPFG3n33XTIzM2t/E0SkQSnciEijqqioYNSoUWzatKnaY+/evQwePNh2no+PT7X3HT58mKuuuoqEhAS+/vpr1q9fz5tvvglAaWlprT/fMAwsFstvHnd3d6/2usVioaKiAgBXV1cWLlzIvHnz6Ny5M6+//jodOnTg4MGDta5DRBqOwo2INBgPDw/Ky8urHevVqxfbt28nNjaWdu3aVXv8OtCcbt26dZSVlTF16lT69etHfHw8x48f/83P+7XOnTtz5MgRkpKSbMd27NhBdnY2nTp1qvXPZrFYGDhwIM888wwbN27Ew8ODOXPm1Pr9ItJwFG5EpMHExsayevVqDh06RFpaGhUVFTzwwANkZGRw6623smbNGg4cOMCCBQu4++67awwmbdu2paysjNdff50DBw7w0Ucf8fbbb5/xeXl5eSxevJi0tDQKCgrOuM7w4cPp1q0bt99+Oxs2bGDNmjXcddddDBky5KxdYWezevVqJk2axLp16zhy5AizZ8/m5MmTdQpHItJwFG5EpME8+uijuLq60rlzZ0JDQzly5AhRUVGsWLGC8vJyrrjiChISEnj44YcJCAjAxeXc/yT16NGDadOmMWXKFBISEvjkk0+YPHlytXMGDBjAfffdx80330xoaOgZA5LBbHH55ptvaNGiBYMHD2b48OG0adOGzz//vNY/l7+/Pz/99BNXXXUV8fHx/O1vf2Pq1KmMHDmy9jdHRBqMxdDcRREREXEiarkRERERp6JwIyIiIk5F4UZEREScisKNiIiIOBWFGxEREXEqCjciIiLiVBRuRERExKko3IiIiIhTUbgRERERp6JwIyIiIk5F4UZEREScyv8DgGzUgTVUL8UAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "plt.plot(range(iters+1), off_diagonal_norm_diff, label=r'Off-diagonal norm')\n",
+    "plt.plot(range(iters+1), off_diagonal_norm_diff_least_squares, label=r'Least squares')\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')\n",
+    "plt.legend()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Energy fluctuation\n",
+    "\n",
+    "This cost function is defined as: $\\Xi_k^2 (\\mu) = \\langle \\mu | H_k^2| \\mu \\rangle - \\langle \\mu | H_k| \\mu \\rangle^2$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 183,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.5|INFO|2024-03-20 10:23:17]: Using qibojit (numba) backend on /CPU:0\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[-3. -1. -1. -0. -1. -0. -0. -0.]\n",
+      " [-1.  1. -0. -1. -0. -1. -0. -0.]\n",
+      " [-1. -0.  1. -1. -0. -0. -1. -0.]\n",
+      " [-0. -1. -1.  1. -0. -0. -0. -1.]\n",
+      " [-1. -0. -0. -0.  1. -1. -1. -0.]\n",
+      " [-0. -1. -0. -0. -1.  1. -0. -1.]\n",
+      " [-0. -0. -1. -0. -1. -0.  1. -1.]\n",
+      " [-0. -0. -0. -1. -0. -1. -1. -3.]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"qibojit\", \"numba\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 3\n",
+    "h = 1.0\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# define the energy fluctuation cost function\n",
+    "cost = DoubleBracketCostFunction.energy_fluctuation\n",
+    "# define the state\n",
+    "state = 0\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost, state=state)\n",
+    "print(np.real(dbi.h.matrix))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 175,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "grid_search step: 0.33334\n",
+      "hyperopt_search step: 0.33819673200950817\n",
+      "polynomial_approximation step: 0.10712604100508318\n"
+     ]
+    }
+   ],
+   "source": [
+    "# generate data for plotting sigma decrease of the first step\n",
+    "d = np.diag(np.linspace(2**nqubits,1,2**nqubits))\n",
+    "s_space = np.linspace(1e-5, 0.9, 1000)\n",
+    "off_diagonal_norm_diff = []\n",
+    "fluctuation = []\n",
+    "for s in s_space:\n",
+    "    dbi_eval = deepcopy(dbi)\n",
+    "    dbi_eval(s,d=d)\n",
+    "    off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n",
+    "    fluctuation.append(dbi_eval.energy_fluctuation(state=state))\n",
+    "\n",
+    "# grid_search\n",
+    "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n",
+    "print('grid_search step:', step_grid)\n",
+    "# hyperopt\n",
+    "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n",
+    "print('hyperopt_search step:', step_hyperopt)\n",
+    "# polynomial\n",
+    "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n",
+    "print('polynomial_approximation step:', step_poly)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 176,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The minimum for cost function in the tested range is: 0.33334\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACLdElEQVR4nOzdeVyU1f7A8c8zMzDsgyCrILgrqIg77pZLmZW3XLqVZuu1NC1bbbnpvb+yPSuz1aVVrdSym5lL7uIubriLgggiKvs+8/z+QKZIVAaB2b7v12teOs+c55nvMMB8Oed7zlFUVVURQgghhHAiGmsHIIQQQghR3yQBEkIIIYTTkQRICCGEEE5HEiAhhBBCOB1JgIQQQgjhdCQBEkIIIYTTkQRICCGEEE5HEiAhhBBCOB1JgIQQQgjhdCQBEkJc0bx581AUpcrb008/zcmTJ1EUhXnz5tXac86aNcui60VGRppj0mg0GAwG2rRpw5gxY1ixYkWV5/z9tXh6etKmTRumTZtGfn5+pbZjx47Fy8vrel6SmaWvTQhRd3TWDkAIYfvmzp1L69atKx0LDQ0lKCiI+Ph4mjVrVmvPNWvWLBo2bMjYsWOrfU7Pnj15++23AcjLy+Pw4cMsWLCAwYMHc+eddzJ//nxcXFwqnTN8+HCeeuop8znr1q3jP//5D3v37mXRokW19nr+qiavTQhRNyQBEkJcU9u2bencuXOVj3Xv3v2a5xcUFODh4VHbYZn5+vpWimPAgAGMHz+eqVOnMm3aNF566SXeeOONSucEBQVdds6pU6f49ttvKSoqws3Nrc7iFUJYnwyBCSFqrKohsKlTp6IoCrt27WL48OE0aNDA3EN04sQJ7rrrLkJDQ9Hr9QQFBXHjjTeSkJAAlA9nHThwgHXr1pmHpyIjI2sc39SpU4mOjmbmzJkUFRVds73BYEBRFLRarcXPdb2vLScnh6effpomTZrg6upKo0aNeOKJJy4bklMUhQkTJvDpp5/SsmVL9Ho9UVFRLFiwwOKYhXBm0gMkhLgmo9FIWVlZpWM63dV/fdxxxx3cddddjBs3zvwhPmTIEIxGI2+++SaNGzcmMzOTzZs3k5WVBcCSJUsYPnw4BoOBWbNmAaDX668r9ltvvZXXX3+dHTt20KtXL/NxVVXNr6liCOzLL7/krrvuumy4rDqu57UVFBTQt29fTp8+zQsvvED79u05cOAA//73v9m3bx+rVq1CURTzcy1dupQ1a9bwn//8B09PT2bNmsU///lPdDodw4cPr+mXSgjnogohxBXMnTtXBaq8lZaWqklJSSqgzp0713zOK6+8ogLqv//970rXyszMVAF1xowZV33O6OhotW/fvtWOMSIiQr3llluu+PjHH3+sAurChQvNx670mm6++WY1Ly+v0vn33Xef6unpedUYrve1TZ8+XdVoNOr27dsrHf/xxx9VQF22bFml2N3d3dX09HTzsbKyMrV169Zq8+bNr/r8Qog/SQ+QEOKavvrqK9q0aVPp2LV6gO68885K9/38/GjWrBlvvfUWRqOR/v37ExMTg0ZTtyPxqqpWeXzkyJE888wzABQWFpKQkMB///tfbrrpJlatWmVRz9P1vrb//e9/tG3blg4dOlTqaRs8eDCKorB27Vpuvvlm8/Ebb7yRoKAg832tVsuoUaOYNm0ap0+fJiwsrNqxC+GspAZICHFNbdq0oXPnzpVu1xISElLpvqIorF69msGDB/Pmm2/SsWNHAgICmDhxIrm5uXUVOqdOnQLKZ639VUBAgPm19O7dm8cff5wPPviAjRs3WjxV/Xpf29mzZ9m7dy8uLi6Vbt7e3qiqSmZmZqX2wcHBl12j4tj58+ctil0IZyU9QEKIOvHXmpUKERERzJ49G4AjR47w/fffM3XqVEpKSvjkk09qPQZVVfnll1/w9PSsVtLWvn17APbs2WPxc13Pa2vYsCHu7u7MmTPnio//VXp6+mVtKo75+/tbHLsQzkgSICGEVbRs2ZKXXnqJRYsWsWvXLvNxvV5PYWFhrTzHtGnTSExM5IUXXqjWtPaKGVuBgYHX9byWvrahQ4fy2muv4e/vT5MmTa55/dWrV3P27FnzMJjRaGThwoU0a9ZMhr+EqCZJgIQQ9WLv3r1MmDCBESNG0KJFC1xdXfnjjz/Yu3cvzz//vLldu3btWLBgAQsXLqRp06a4ubnRrl27q147KyuLLVu2AJCfn29eCHHDhg2MHDmSadOmXXbO2bNnzecUFRWRkJDA//3f/+Hr68v9999fr6/tiSeeYNGiRfTp04cnn3yS9u3bYzKZSE5OZsWKFTz11FN069bNfJ2GDRtyww038PLLL5tngR06dEimwgthAUmAhBD1Ijg4mGbNmjFr1ixSUlJQFIWmTZvyzjvv8Pjjj5vbTZs2jbS0NB5++GFyc3OJiIjg5MmTV732pk2biIuLM29r0ahRI7p27cpLL73EoEGDqjznxx9/5McffwTAxcWF8PBwbrvtNl588UUiIiLq9bV5enqyYcMGXn/9dT777DOSkpJwd3encePGDBgw4LK1kG677Taio6N56aWXSE5OplmzZnz77beMGjXKoriFcGaKeqUpEkIIIWyOoiiMHz+emTNnWjsUIeyazAITQgghhNORBEgIIYQQTkdqgIQQwo5I1YIQtUN6gIQQQgjhdCQBEkIIIYTTkQRICCGEEE5HaoCqYDKZOHPmDN7e3lUu5y+EEEII26OqKrm5uYSGhl5zM2JJgKpw5swZwsPDrR2GEEIIIWogJSXlmtvCSAJUBW9vb6D8C+jj42PlaISoB/n5EBpKvg5Cny4/dOapM3i6elo3LiGEsEBOTg7h4eHmz/GrkQSoChXDXj4+PpIACeeg1Zb/owCX9gz18fGRBEgIYZeqU74iRdDiuhiLjBwYcYADIw5gLDJaOxwhhBCiWiQBEtfHCOd+PMe5H8+B5D9CCCHshAyBCSHMdCa4L/oe0OnQaeTXgxDCcclvOCGEmd4I827+FDyl9kfYNqPRSGlpqbXDEFbg6up6zSnu1SEJkBBCCLuhqirp6elkZWVZOxRhJRqNhiZNmuDq6npd15EESAhhpgIFJfngAh4uHrIQqLA5FclPYGAgHh7yPepsKhYqTktLo3Hjxtf1/ksCJIQwK3ABrw+CAMibkifT4IVNMRqN5uTH39/f2uEIKwkICODMmTOUlZXh4uJS4+tYdRbYxx9/TPv27c3r7cTFxfHbb79d9Zx169bRqVMn3NzcaNq0KZ988sllbRYtWkRUVBR6vZ6oqCiWLFlSVy9BCCFEPamo+fHw8LByJMKaKoa+jMbrm3ps1QQoLCyM119/nR07drBjxw5uuOEGbr/9dg4cOFBl+6SkJIYMGULv3r3ZvXs3L7zwAhMnTmTRokXmNvHx8YwaNYrRo0ezZ88eRo8ezciRI9m6dWt9vSwhhBB1SIa9nFttvf+KqqpqrVyplvj5+fHWW2/x4IMPXvbYc889x9KlSzl48KD52Lhx49izZw/x8fEAjBo1ipycnEo9STfddBMNGjRg/vz51YohJycHg8FAdna2rAR9DcZ8Ixu8NgDQO683Wk+tlSMSNZKfD15e5LuA14vlh2QITNiaoqIikpKSaNKkCW5ubtYOR1jJ1b4PLPn8tpmFEI1GIwsWLCA/P5+4uLgq28THxzNo0KBKxwYPHsyOHTvMXaNXarN58+YrPndxcTE5OTmVbkIIIYQ1nTx5EkVRSEhIuGKbtWvXoiiKXc+KUxSFn376qd6f1+oJ0L59+/Dy8kKv1zNu3DiWLFlCVFRUlW3T09MJCgqqdCwoKIiysjIyMzOv2iY9Pf2KMUyfPh2DwWC+yU7wQgghrC08PJy0tDTatm1r7VAcktUToFatWpGQkMCWLVt49NFHue+++0hMTLxi+7+P/VWM4P31eFVtrjZmOGXKFLKzs823lJSUmrwUcQ0FJWVk5BSRWySLlwkhxNWUlJSg1WoJDg5Gp7PfCdu2vFil1RMgV1dXmjdvTufOnZk+fToxMTG8//77VbYNDg6+rCcnIyMDnU5nnhJ5pTZ/7xX6K71eb56JJjvAW0gLAcMDCBgeAFWU/+xKvsiUxfvo+fofRP37d7q+tpp2U1fQ7bVVTP4+gY1HM7GxMjSnplVheMthDI8ajlYj9VxC1Jbc3FzuuecePD09CQkJ4b333qNfv3488cQTAERGRvJ///d/jB07FoPBwMMPP1zlENiyZcto2bIl7u7u9O/fn5MnT1Y7hlOnTnHrrbfSoEEDPD09iY6OZtmyZebHExMTGTJkCF5eXgQFBTF69Gjz6ArA8uXL6dWrF76+vvj7+zN06FCOHz9ufrwi3u+//55+/frh5ubGN998A8CcOXOIjo5Gr9cTEhLChAkTKsWWmZnJP/7xDzw8PGjRogVLly614KtbM1ZPgP5OVVWKi4urfCwuLo6VK1dWOrZixQo6d+5sXgvgSm169OhRNwE7Oa2blugfoon+IRqt258fmMfP5XHvF1u5Y9Zm5m9LJjWrEADNpY64sznFLN6Vyr2zt3LHx5vZezrLCtGLv3Mrgx9u+4YfRvyAm06KTIWNU9XyAn5r3Cz8w23y5Mls2rSJpUuXsnLlSjZs2MCuXbsqtXnrrbdo27YtO3fu5OWXX77sGikpKdxxxx0MGTKEhIQEHnroIZ5//vlqxzB+/HiKi4tZv349+/bt44033sDLywuAtLQ0+vbtS4cOHdixYwfLly/n7NmzjBw50nx+fn4+kydPZvv27axevRqNRsM//vEPTCZTped57rnnmDhxIgcPHmTw4MF8/PHHjB8/nkceeYR9+/axdOlSmjdvXumcadOmMXLkSPbu3cuQIUO45557uHDhQrVfW42oVjRlyhR1/fr1alJSkrp37171hRdeUDUajbpixQpVVVX1+eefV0ePHm1uf+LECdXDw0N98skn1cTERHX27Nmqi4uL+uOPP5rbbNq0SdVqterrr7+uHjx4UH399ddVnU6nbtmypdpxZWdnq4CanZ1dey/WiXyz5aTa4sVlasRz/1ObTflVnbwwQV17OEPNyi9RVVVVc4tK1c3HMtUXl+xVW71U3q7plF/V91cdUY1Gk5Wjd1J5eapa/iu9/P9C2KDCwkI1MTFRLSwsLD/w1+/b+r5Z8HOSk5Ojuri4qD/88IP5WFZWlurh4aFOmjRJVVVVjYiIUIcNG1bpvKSkJBVQd+/erapq+WdmmzZtVJPpz9+Tzz33nAqoFy9evGYc7dq1U6dOnVrlYy+//LI6aNCgSsdSUlJUQD18+HCV52RkZKiAum/fvkrxzpgxo1K70NBQ9cUXX7xiXID60ksvme/n5eWpiqKov/32W5XtL/s++AtLPr+tOrB49uxZRo8eTVpaGgaDgfbt27N8+XIGDhwIlGekycnJ5vZNmjRh2bJlPPnkk3z00UeEhobywQcfcOedd5rb9OjRgwULFvDSSy/x8ssv06xZMxYuXEi3bt3q/fU5G5NJZdovB/gy/hQAfVoG8OqwtoT7VV60zEuvI66ZP3HN/Jl4Ywv+80si/9ubxrsrj3AoPYf3RnVAr5PhFyGEYzhx4gSlpaV07drVfMxgMNCqVatK7Tp37nzV6xw8eJDu3btXqmm90qzpqkycOJFHH32UFStWMGDAAO68807at28PwM6dO1mzZo25R+ivjh8/TsuWLTl+/Dgvv/wyW7ZsITMz09zzk5ycXKlQ+6+vIyMjgzNnznDjjTdeNbaKOAA8PT3x9vYmIyOj2q+tJqyaAM2ePfuqj8+bN++yY3379r2s2/Dvhg8fzvDhw68nNFFNf10HaNW3Dfhm72kUBZ4d3JpxfZtec8GqQG83Zt7dkT4tU3hxyT6W7UunpGwXs+7phKvO5kZoHV6+C3i9Xf4LUNYBEjbPwwPy8qz33NWkVjFZ56/HK3h6Xv3n7e/tLfXQQw8xePBgfv31V1asWMH06dN55513ePzxxzGZTNx666288cYbl50XEhICwK233kp4eDiff/45oaGhmEwm2rZtS0lJyRVfh7u7e7Vi+/uWFoqiXDa0VtvkE0bUmu93nEajwLsjY3i0XzOLVusc2Tmcefd3Ra/TsOpgBhPn78ZokuJoIcRVKAp4elrnZsHvt2bNmuHi4sK2bdvMx3Jycjh69KhFLzcqKootW7ZUOvb3+9cSHh7OuHHjWLx4MU899RSff/45AB07duTAgQNERkbSvHnzSjdPT0/Onz/PwYMHeemll7jxxhtp06YNFy9evObzeXt7ExkZyerVqy2Ksz5IAiSui8ZDQ/pvETz+eD4lLvDuyA78IzasRtfq2bwhX9zXGVedhuUH0nlnxeFajlYIIeqft7c39913H8888wxr1qzhwIEDPPDAA2g0Gov+UBw3bhzHjx9n8uTJHD58mO+++67KkZIreeKJJ/j9999JSkpi165d/PHHH7Rp0wYoL5C+cOEC//znP9m2bRsnTpxgxYoVPPDAAxiNRho0aIC/vz+fffYZx44d448//mDy5MnVet6pU6fyzjvv8MEHH3D06FF27drFhx9+WO2464okQOK67Dx1kZfWHyTXA54a1JJhsY2u63q9WwTw1vDyseBZa4+zdM+Z2ghTCCGs6t133yUuLo6hQ4cyYMAAevbsSZs2bSza0qNx48YsWrSIX375hZiYGD755BNee+21ap9vNBoZP348bdq04aabbqJVq1bMmjULgNDQUDZt2oTRaGTw4MG0bduWSZMmYTAY0Gg0aDQaFixYwM6dO2nbti1PPvkkb731VrWe97777mPGjBnMmjWL6Ohohg4danHvV12wub3AbIHsBVY9OUWl3DxjA6lZhQxtH8KH/4yttU3qpv92kE/XncBLr+O3Sb0vK6QWtUz2AhN2wJH2AsvPz6dRo0a88847Ve59Ka7M4fYCE/Zn6s8HOJtZyKPrPXh0vQdqSe3l0s8Obk2XyAbkFZfx1Pd7pB5ICGHXdu/ezfz58zl+/Di7du3innvuAeD222+3cmTOSxIgUSOrEs+yeHcqOhW6xSuc+zQdtaz2khStRuHdkR3w0uvYdvICszeeqLVrCyGENbz99tvExMQwYMAA8vPz2bBhAw0bNqy169988814eXlVebNkqMxZ2O8GI8JqCkrKeGXpAQDu79kE3q2btRrC/Tz499Aonl20l/dWHmVo+1BCfas3pVLUjFaFIU0Gg04rW2EIUYtiY2PZuXNnnT7HF198QWFhYZWP+fn51elz2yNJgITFPvzjGKlZhTTydeex/s3YSd0tVjWicxg/7jzNtpMX+M8viXwyulOdPZco3wrj1zsXlU/zFULYlUaNrm8SirORITBhkVPn8/liQ/lw1Cu3RuHhWrc5tKIo/HdYW7QaheUH0ll7uG5XBhVCCOEcJAESFnlnxRFKjSq9WzRkUHRwvTxnq2Bv7u8RCcDrvx2SgmghhBDXTRIgUW37U7PN6/I8d1Pren3uCTc0x8dNx6H0XJbsTq3X53Ym+S7gOSMQz9c8yS/Jt3Y4QghRZyQBEtX25u/lKzPfFhNK20aGen1uXw9XHuvfHIB3VxymqNRYr8/vTArKCigoLbB2GEIIUackARLVsvXEedYfOYdOo/DUoJZWiWFsj0hCDG6cyS7ihx0pVolBCCGEY5AESFTLrLXHARjROZwIf+vMEHJz0fJov2YAfLLuBCVldbtTsBBC1JZ+/frxxBNPWDsM8ReSAIlrOnAmm3VHzqFRYFzfplaNZWTncAK89aRmFfKT1AIJIYRNmDp1Kh06dLB2GBaRBEhc08eXen9uaR9qtd6fCm4uWh7pXZ6EzVp7jDKj9AIJIURNGI1GTCbn/R0qCZC4qpOZ+SzblwbAo32bWTmacnd3a0wDDxdOni9g2f50a4cjhBDVYjKZePbZZ/Hz8yM4OJipU6cC8MADDzB06NBKbcvKyggODmbOnDlA+RDahAkTmDBhAr6+vvj7+/PSSy/x1/3MS0pKePbZZ2nUqBGenp5069aNtWvXmh+fN28evr6+/O9//yMqKgq9Xs+pU6e4ePEiY8aMoUGDBnh4eHDzzTdX2q294ryffvqJli1b4ubmxsCBA0lJSTE/Pm3aNPbs2YOiKCiKwrx58+rmi1iLJAESVzVnUxImFfq1CiAqtIqddTVg6GvA0NdQb99NnnodY3s0KY9vY1L9PKmT0KjQN6wXfSP6olHk14OwD/kl+Ve8FZUVVbttYWlhtdrW1Jdffomnpydbt27lzTff5D//+Q8rV67koYceYvny5aSlpZnbLlu2jLy8PEaOHFnpfJ1Ox9atW/nggw947733+OKLL8yP33///WzatIkFCxawd+9eRowYwU033VQpmSkoKGD69Ol88cUXHDhwgMDAQMaOHcuOHTtYunQp8fHxqKrKkCFDKC0trXTeq6++ypdffsmmTZvIycnhrrvuAmDUqFE89dRTREdHk5aWRlpaGqNGjarx16m+yFYY4opyi0pZtPM0AA/1qrr2R+uuJXZtbH2GBcA93Rvz0ZpjJKRksTv5IrGNG9R7DI7IvQzW3rVctsIQdsVrutcVHxvSYgi/3v2r+X7g24FXXOahb0Rf1o5da74f+X4kmQWZl7VTX6nZYqzt27fnlVdeAaBFixbMnDmT1atX8/rrr9OqVSu+/vprnn32WQDmzp3LiBEj8PL687WFh4fz3nvvoSgKrVq1Yt++fbz33ns8/PDDHD9+nPnz53P69GlCQ0MBePrpp1m+fDlz5841b4ZaWlrKrFmziImJAeDo0aMsXbqUTZs20aNHDwC+/fZbwsPD+emnnxgxYoT5vJkzZ9KtWzegPBlr06YN27Zto2vXrnh5eaHT6QgOrp8FcmuD/IknrmjxrlTyS4w0C/CkZ3N/a4dTSUMvPbfGlP+Qz9t80rrBCCFENbRv377S/ZCQEDIyyrf3eeihh5g7dy4AGRkZ/PrrrzzwwAOV2nfv3h1FUcz34+LiOHr0KEajkV27dqGqKi1btqy0C/y6des4fvy4+RxXV9dKcRw8eBCdTmdObAD8/f1p1aoVBw8eNB/T6XR07tzZfL9169b4+vpWamNvpAdIVElVVb6KPwnAmLjISj90tuL+npEs2nWaX/em8cKQNgT5uFk7JCGEFeRNybviY1qNttL9jKevvJ/g34d9T046eV1x/Z2Li0ul+4qimIuQx4wZw/PPP098fDzx8fFERkbSu3fval/bZDKh1WrZuXMnWm3l1/zXXiR3d/dKv8//WkP0V6qqXvZ7v6rPAVv8bKguSYBElTYfP8/xc/l4umq5o+OVdxg25hvZErkFgO4nu6P11F6xbW1r28hAl8gGbD95kW+2nOKpQa3q7bkdVb4LRH4UAYrCyUkn8XSVoTBh+yz5Pq2rttfL39+fYcOGMXfuXOLj47n//vsva7Nly5bL7rdo0QKtVktsbCxGo5GMjAyLEqeoqCjKysrYunWreQjs/PnzHDlyhDZt2pjblZWVsWPHDrp27QrA4cOHycrKonXr8m2RXF1dMRrta4V+GQITVfo6/hQAd3QMw9vN5aptSzNLKc0svWqbulJRDL1we4pMia8lmYXnq6x7EELUrYceeogvv/ySgwcPct999132eEpKCpMnT+bw4cPMnz+fDz/8kEmTJgHQsmVL7rnnHsaMGcPixYtJSkpi+/btvPHGGyxbtuyKz9miRQtuv/12Hn74YTZu3MiePXu49957adSoEbfffru5nYuLC48//jhbt25l165d3H///XTv3t2cEEVGRpKUlERCQgKZmZkUFxfX8len9kkCJC6TmVfMqoNnAbi3e8RV22rcNXTZ34Uu+7ugca//b6eBUUH4e7qSkVvMmsPn6v35hRCitgwYMICQkBAGDx5sLmT+qzFjxlBYWEjXrl0ZP348jz/+OI888oj58blz5zJmzBieeuopWrVqxW233cbWrVsJDw+/6vPOnTuXTp06MXToUOLi4lBVlWXLllUasvPw8OC5557j7rvvJi4uDnd3dxYsWGB+/M477+Smm26if//+BAQEMH/+/Fr4itQtRb3SAKATy8nJwWAwkJ2djY9PFVO/HdwXG07wf78eJCbcl5/H97R2ONf02rKDfLb+BAPaBPLFfV2sHY59ys8HLy/yXcDrxfJDeVPyZAhM2JSioiKSkpJo0qQJbm6OV/NXUFBAaGgoc+bM4Y477qj0WL9+/ejQoQMzZsyo97jmzZvHE088QVZWVr0/d1Wu9n1gyee39ACJSlRV5ftLG42O6BRm5WiqZ1SX8r9u/jiUQXp20TVaCyGEbTGZTJw5c4aXX34Zg8HAbbfdZu2QnIIkQKKSvaezOXI2D71OY55mfjWmEhNJU5NImpqEqcQ6NTjNArzoGumHSYUfd8ou8UII+5KcnEyjRo34/vvvmTNnDjqdzE+qD/JVFpX8cCmBuKltMAb3qxc/A6ilKqemlRdMN36mMbjWaXhXNKpLONtOXmDhjhTG929u11MzhRDOJTIy8orT0Sv8dUuL+jZ27FjGjh1rteevK9IDJMyKSo0sTTgDlO+6bk+GtAvBS68j5UIhO09dtHY4dkujQuegjnQO7SxbYQghHJr8hhNm646cI6eojBCDG3FNbWvl52txd9UyOLp8CfafElKtHI39ci+D7aPXs/3h7bi7uFs7HCGEqDOSAAmzpXvKe3+Gtg9Bo7G/IaRhseU1S//bm0ZJmawJJIQQ4sqsmgBNnz6dLl264O3tTWBgIMOGDePw4cNXPWfs2LEoinLZLTo62txm3rx5VbYpKpIZQleSX1zG6ktr/9wWc+WVn21Zj2YNCfDWk1VQyvojsiaQEEKIK7NqArRu3TrGjx/Pli1bWLlyJWVlZQwaNIj8/PwrnvP++++TlpZmvqWkpODn52fesbaCj49PpXZpaWkOuW5EbVl18CxFpSYi/T1o28g+1z7SahRubV/eCyTDYDVT4AKRn0UROSPyijtmCyGEI7DqLLDly5dXuj937lwCAwPZuXMnffr0qfIcg8GAwWAw3//pp5+4ePHiZfumKIpCcHBw7QftoH65NPx1a0yoXc+gGhYbypxNSaxMPEtuUek1t/EQlanAqZzk8v/LGqlCCAdmUzVA2dnZAPj5+VX7nNmzZzNgwAAiIipv2ZCXl0dERARhYWEMHTqU3bt312qsjiSroIR1l4aMbqvG2j+2rF0jA00DPCkuM/H7gbPWDkcIIWrFvHnz8PX1tXYY1TJ16lQ6dOhg0TmKovDTTz/VSTxXYjMJkKqqTJ48mV69etG2bdtqnZOWlsZvv/3GQw89VOl469atmTdvHkuXLmX+/Pm4ubnRs2dPjh49WuV1iouLycnJqXRzJr8fSKfUqNI62JsWQd7WDue6KIrCsA7lNUwVRd1CCCHqz9NPP83q1autHcY12UwCNGHCBPbu3WvRBmoVGfGwYcMqHe/evTv33nsvMTEx9O7dm++//56WLVvy4YcfVnmd6dOnm4fWDAbDNTeOczT/25sGUK2Vn+3BLe1DANh8LJPsAuvsUi+EEM7Ky8sLf3/bX0rFJhKgxx9/nKVLl7JmzRrCwqq3/5SqqsyZM4fRo0fj6nr15Yc1Gg1dunS5Yg/QlClTyM7ONt9SUpxnO4XsglLij58HyhcTdATNArxoFeRNmUk172ovhBDW1K9fPyZMmMCECRPw9fXF39+fl156yVxrd/HiRcaMGUODBg3w8PDg5ptvvuJn1smTJ9FoNOzYsaPS8Q8//JCIiAhUVWXt2rUoisLq1avp3LkzHh4e9OjR47KZ1h9//DHNmjXD1dWVVq1a8fXXX1d6XFEUPv30U4YOHYqHhwdt2rQhPj6eY8eO0a9fPzw9PYmLi+P48ePmc/4+BLZ9+3YGDhxIw4YNMRgM9O3bl127dl3Pl7NWWDUBUlWVCRMmsHjxYv744w+aNGlS7XPXrVvHsWPHePDBB6v1PAkJCYSEVP0Br9fr8fHxqXRzFn8cPkuZSaVlkBdNGjrOzt83tS0vgP9tf5qVIxFC1DVjvtHim+kva4WZykzlxwuN1bpuTX355ZfodDq2bt3KBx98wHvvvccXX3wBlC/xsmPHDpYuXUp8fDyqqjJkyBBKSy/vxY6MjGTAgAHMnTu30vG5c+eal4qp8OKLL/LOO++wY8cOdDodDzzwgPmxJUuWMGnSJJ566in279/Pv/71L+6//37WrFlT6br//e9/GTNmDAkJCbRu3Zq7776bf/3rX0yZMsWchE2YMOGKrzs3N5f77ruPDRs2sGXLFlq0aMGQIUPIzc21/ItYi6w6C2z8+PF89913/Pzzz3h7e5Oeng6Uz/Rydy9fhXbKlCmkpqby1VdfVTp39uzZdOvWrcp6oWnTptG9e3datGhBTk4OH3zwAQkJCXz00Ud1/6LszO/7y3tIKlZRtpgCHlEe5v/bipvbBfP+6qOsP5pJXnEZXnrZ9q46FCDKvzVoNHY9G1A4lw1eGyw+J+r7KAJHBAKQuSSTxJGJGPoaiF0ba26zJXILpZmXJyD91H41ijM8PJz33nsPRVFo1aoV+/bt47333qNfv34sXbqUTZs20aNHDwC+/fZbwsPD+emnny5b5gXgoYceYty4cbz77rvo9Xr27NlDQkICixcvrtTu1VdfpW/fvgA8//zz3HLLLRQVFeHm5sbbb7/N2LFjeeyxxwCYPHkyW7Zs4e2336Z///7ma9x///2MHDkSgOeee464uDhefvllBg8eDMCkSZMum4n9VzfccEOl+59++ikNGjRg3bp1DB061NIvY62xag/Qxx9/THZ2Nv369SMkJMR8W7hwoblNWloaycnJlc7Lzs5m0aJFV+z9ycrK4pFHHqFNmzYMGjSI1NRU1q9fT9euXev09dibolKjefbXoKiaJUBaDy1dD3Sl64GuaD20tRnedWkV5E3Thp6UlJn441CGtcOxGx6lcOD+HRx47AAeLh7WDkcIh9K9e/dKf1jExcVx9OhREhMT0el0dOvWzfyYv78/rVq14uDBg1Vea9iwYeh0OpYsWQLAnDlz6N+/P5GRkZXatW/f3vz/ilGQjIzy34kHDx6kZ8+eldr37Nnzsuf86zWCgoIAaNeuXaVjRUVFV5xAlJGRwbhx42jZsqW51jYvL++yz/b6ZtU/i6uzzsi8efMuO2YwGCgouPIibe+99x7vvffe9YTmFDYczaSw1EgjX3e7XfzwShRF4aa2wcxae5zf9qXZ/fR+IcSV9c7rbfE5iv7PRKThPxqWX+NvXQLdT3a/3tCui6qqV+yJdXV1ZfTo0cydO5c77riD7777jhkzZlzWzsXlz7XQKq5lMpkuO3a156zqGte67l+NHTuWc+fOMWPGDCIiItDr9cTFxVFSUlJl+/piE0XQwjpWHCgfchwYFeSQwx0VRd1rD5+joKTMytEIIeqK1lNr8U2j+/PjT6PTlB9311brujW1ZcuWy+63aNGCqKgoysrK2Lp1q/mx8+fPc+TIEdq0aXPF6z300EOsWrWKWbNmUVpayh133GFRPG3atGHjxo2Vjm3evPmqz1kTGzZsYOLEiQwZMoTo6Gj0ej2ZmZm1+hw1IQmQkyozmswzpAZFB9X4OsYCI9uit7EtehvGgpoXB9aF6FAfwhq4U1hqZN1h2RusOgpcIHpuZ6JnRctWGELUspSUFCZPnszhw4eZP38+H374IZMmTaJFixbcfvvtPPzww2zcuJE9e/Zw77330qhRI26//fYrXq9NmzZ0796d5557jn/+85/m2tnqeuaZZ5g3bx6ffPIJR48e5d1332Xx4sU8/fTT1/tSK2nevDlff/01Bw8eZOvWrdxzzz0Wx1oXJAFyUjtOXeRiQSkNPFzoGln9lbcvo0JBYgEFiQXl+yjYEEVRzMXdqw5KHVB1qEDi+UMknkuUrTCEqGVjxoyhsLCQrl27Mn78eB5//HEeeeQRoHwGV6dOnRg6dChxcXGoqsqyZcsqDTVV5cEHH6SkpKTS7K7qGjZsGO+//z5vvfUW0dHRfPrpp8ydO5d+/frV5OVd0Zw5c7h48SKxsbGMHj2aiRMnEhgYWKvPUROKKr/lLpOTk4PBYCA7O9thp8T/3/8S+WJjEnd2DOOdkTE1vo5qVMnakAWAb29fFK1tDaVtPp7J3Z9vxc/Tle0vDkCrsa34bEZ+Pnh5ke8CXi+WH8qbkoenq+MsjSDsX1FREUlJSTRp0sTuNrfu168fHTp0qLJO53q8+uqrLFiwgH379tXqdW3Z1b4PLPn8lh4gJ7XmcHmPyI1tri8LV7QKDfo1oEG/BjaX/AB0ifTD203HhfwSElIuWjscIYSoFXl5eWzfvp0PP/yQiRMnWjscuyQJkBNKPl/A8XP5aDUKvVo0tHY4dcpFq6Ffq/IkT4bBhBCOYsKECfTq1Yu+ffvWaPhLSALklNYeKU8EOkc0wMft6uPL12IqNZH6USqpH6ViKq16CqS1DbjUy7VatsUQQljJ2rVra3X4a968eRQXF7Nw4UK0WttZg82eSALkhCoWBuzf+vqL0NQSlaMTjnJ0wlHUEtssJ+vbMgCtRuHI2TxSLsjMJiGEEJIAOZ3CEqN589MbaiEBsge+Hq50imgAIJujXoMCRPg0JsIQ4ZBrQwnHIHN3nFttvf+SADmZLSfOU1xmopGvOy0CvawdTr35cxhM6oCuxqMUTj6SyMknTspWGMLmVEwJv9pOAMLxVawgfb1Df7JDpJOpmP3Vr1WAU/2Ff2ObIF5bdoitSefJLSrF+zprn4QQ9U+r1eLr62vey8rDw8Opfo+J8u02zp07h4eHBzrd9aUwkgA5EVVV/6z/aeUcw18VmgV4EeHvwanzBcQfP8+g6Jpt/iqEsK7g4PKf3YokSDgfjUZD48aNrzv5lQTIiRw/l8/pi4W4ajX0aO5v7XDqXd+WAXwVf4p1R85JAnQFhTro83Uf0GpYP3Y97i7WX65eiL9SFIWQkBACAwMpLS21djjCClxdXdForr+CRxIgJ7LxaPl+WF2aNMDD1fne+j4tyhOg9UfPXXWXZWdmUmDH2V3l/1dtc1kDIaB8OEymf4vrIUXQTmTjsfLdd3s1D7ByJNYR18wfF61CyoVCTp6XIkohhHBmkgA5iVKjiS0nLgDQq7ljr/58JZ56HZ0jyjd+XXdY6geEEMKZSQLkJPakZJFXXEYDDxeiQx1zg9fq6NOyvPdr/dFMK0cihBDCmiQBchIbLn3g92jeEI0T74jep2V571f88fMUlxmtHI0QQghrkQTISWwy1/845/BXhagQHwK89RSWGtlxUnaHF0IIZyUJkBPILSpld0oWUDcJkEtDF1wa2sfCgoqi0LtF+ddg/ZFzVo7GNjV096ehh3MnykIIxycJkBPYeuICRpNKpL8H4X61u72B1lNLz3M96XmuJ1pP+5iS2vdSHdA6SYAu41kK58af4twz5/B09bR2OEIIUWckAXICFdPfezr58FeF3i0CUBQ4lJ7L2Zwia4cjhBDCCiQBcgIbLi2AWDH04+z8PF1p18gA/FkbJYQQwrlIAuTg0rILOX4uH40CcU1rPwEyFhrZ3W83u/vtxlhoP7OqejQr/1psOnbeypHYlkId9FtwE/3m9aOwtNDa4QghRJ1xvv0QnMzmSx/w7cJ8MXjUQaGyCbLXZZv/by96NPPnk3XHiT+eKdti/IVJgXWnN5b/X7bCEEI4MEmAHNyWE+UJUFzTutn8VNErRH0fZf6/vegS6YeLVuFMdhEnzxfQpKEU/AohhDORITAHtyWpPAHq3tSvTq6v0WkIHBFI4IhANDr7+XZyd9US27gBAJuPSx2QEEI4G/v5xBIWS80qJOVCIVqNQufIukmA7FnPS3VAm49LHZAQQjgbSYAc2NZLw1/tGhnw0tfNaKepzETGDxlk/JCBqcy+akZ6NC8fFow/fh6TSbVyNEIIIeqTJEAOrKL+p1sdDX8BqMUqiSMTSRyZiFpsX0lETJgvHq5aLuSXcPhsrrXDEUIIUY8kAXJgW05cAKB7HRVA2ztXnYYul4YGZT2gP3noPPBwqd0Vw4UQwtZYNQGaPn06Xbp0wdvbm8DAQIYNG8bhw4eves7atWtRFOWy26FDhyq1W7RoEVFRUej1eqKioliyZEldvhSbcyarkOQLBeX1PxENrB2OzerR7M9hMFG+FUb+Exnkv5AvW2EIIRyaVROgdevWMX78eLZs2cLKlSspKytj0KBB5OfnX/Pcw4cPk5aWZr61aNHC/Fh8fDyjRo1i9OjR7Nmzh9GjRzNy5Ei2bt1aly/Hpmy9NPurbSMD3m72sVGpNVRsD7I16QJlRvuqYRJCCFFzVl0HaPny5ZXuz507l8DAQHbu3EmfPn2uem5gYCC+vr5VPjZjxgwGDhzIlClTAJgyZQrr1q1jxowZzJ8/v1Zit3Vbjl8a/mois7+upk2IDwZ3F7ILS9mbmk3HxtJbJoQQzsCmaoCys8tXFPbzu/aHdmxsLCEhIdx4442sWbOm0mPx8fEMGjSo0rHBgwezefPm2gvWxv25/o/U/1yNVqOYF4mUYTAo0sEti+7klu9uoahMNooVQjgum0mAVFVl8uTJ9OrVi7Zt216xXUhICJ999hmLFi1i8eLFtGrVihtvvJH169eb26SnpxMUFFTpvKCgINLT06u8ZnFxMTk5OZVu9iwtu5BT5wvQKNA5Uno0rqViltzWpAtWjsT6jAosS/qdZUeXYTTZz95uQghhKZvZCmPChAns3buXjRs3XrVdq1ataNWqlfl+XFwcKSkpvP3225WGzf6+t9PV9nuaPn0606ZNu47obcvWS7O/2kn9T7V0vTRMuPNkeR2QTmszfxcIIYSoIzbxm/7xxx9n6dKlrFmzhrCwMIvP7969O0ePHjXfDw4Ovqy3JyMj47JeoQpTpkwhOzvbfEtJSbE4Bluy7WR5AtRV6n+qpXWwD95uOvJLjCSm2XfvnxBCiOqxagKkqioTJkxg8eLF/PHHHzRp0qRG19m9ezchISHm+3FxcaxcubJSmxUrVtCjR48qz9fr9fj4+FS62bMdlxIg2f6ierQaha6XvlYVvWdCCCEcm1WHwMaPH893333Hzz//jLe3t7nXxmAw4O7uDpT3zqSmpvLVV18B5TO8IiMjiY6OpqSkhG+++YZFixaxaNEi83UnTZpEnz59eOONN7j99tv5+eefWbVq1TWH1xxBVkEJR87mAcj6Pxbo2sSP1Ycy2Jp0gYf7NLV2OEIIIeqYVROgjz/+GIB+/fpVOj537lzGjh0LQFpaGsnJyebHSkpKePrpp0lNTcXd3Z3o6Gh+/fVXhgwZYm7To0cPFixYwEsvvcTLL79Ms2bNWLhwId26davz12Rtu5IvAtC0oSf+XnorR2M/KoYLt5+8gMmkotFUXS8mhBDCMVg1AVLVa+8dNW/evEr3n332WZ599tlrnjd8+HCGDx9e09Ds1vaT5QmQzP6yTNtGBjxctWQXlnIkI5fWwfY9DCqEEOLqbGYWmKgdOysSoIj6qf/Remrpp/arl+eqSy5aDZ0iGrDhaCZbT1xw2gTIsxTUp/PAU7bBEEI4NpuYBSZqR3GZkYTTWYD0ANVERSH0NlkPSAghHJ4kQA5kf2oOJWUm/D1dadJQ/oK3VLdLK0JvTbpQreFZIYQQ9ksSIAdSMf29U0SDKy76WNuMRUYOjDjAgREHMBbZ98rB7cMMuOo0ZOYVcyLz2hvyOqIiHYxYei8jfhghW2EIIRyaJEAOxCoF0EY49+M5zv14Duw7/8HNRUtsuC/gvMNgRgV+PPITPyb+KFthCCEcmiRADkJVVXaeqv8FEBVXhRYzW9BiZgsUV/ufOt6tidQBCSGEM5BZYA7i+Ll8LhaUotdpaBtqqLfn1bhoaDS+Ub09X13r2sQfOMbWE+evun+cEEII+yY9QA6iovcnJtwXV528rTXVMcIXnUbhTHYRZ7KlBkYIIRyVfFI6CHP9Tz1vf6EaVS6uvcjFtRdRjfY/c8rDVUdUaPkaQBVF5UIIIRyPJEAOYuep8gSoSz1vgGoqMrGn/x729N+DqchUr89dVzpdSiJ3XfqaCiGEcDySADmAzLxiki5N2+7YWBZAvF4VCdAOSYCEEMJhSRG0A0hIzgKgRaAXBg8X6wbjACoSoINpOeQVl+Gld54fE49SyJt4Fjw98XDxsHY4QghRZ6QHyAHsTinvqehwaQ0bcX1CDO408nXHpMKelCxrh1OvFMDT1RNPV0+ZASeEcGiSADmA3Zd6gGJl+KvWmIfBTsowmBBCOCJJgOyc0aSaeyliG/taNRZHUrGa9o5TzjUTrFgLY3/7F2N/GktxWbG1wxFCiDojCZCdO5aRR36JEQ9XLS2DvK0djsOoKCZPSM7CaLL/6f3VVaaBLw98y5d7vqTMVGbtcIQQos5IAmTndieXD9G0DzOg1UjNRm1pHeyNp6uW3OIyjpzNtXY4QgghapkkQHZO6n/qhk6rMX9NZTq8EEI4nhrN7129ejWrV68mIyMDk6ny4ndz5syplcBE9SRU1P/IDLBa1zGiARuPZbLr1EVGd4+wdjhCCCFqkcUJ0LRp0/jPf/5D586dCQkJkamyVpRbVMqRjPLhmQ5SAF3rOkc4ZyG0EEI4A4sToE8++YR58+YxevTouohHWGDv6WxUFRr5uhPo7WbtcBxOh8a+KAqkXCgkI6eIQB/5GgshhKOwuAaopKSEHj161EUswkIJMv29Tvm4udDq0sy6nVIHJIQQDsXiBOihhx7iu+++q4tYhIUqZoBZswBa46GhR0YPemT0QOPheDX1f64H5BwJkEcpZDyWRMbTGbIVhhDCoVk8BFZUVMRnn33GqlWraN++PS4ulfeeevfdd2stOHFlqqqaZ4BZcwsMRVFwDXC12vPXtU4RDfhmS7LTJEAKEOARAJ6e1g5FCCHqlMUJ0N69e+nQoQMA+/fvr/SYFETXn5QLhZzPL8FFqxAd6mPtcBxW5wg/AA6kZlNUasTNRWvliIQQQtQGixOgNWvW1EUcwkIVG6BGhRqs+qFsKjZxbPIxAJq/2xyN3rGGwcIauBPgredcbjH7U7PpHOln7ZDqVLEWJq96EnQuvDv4XfQ6vbVDEkKIOnFdn1anT58mNTW1tmIRFjAvgGjl9X/UMpUzs85wZtYZ1DLH2zJCURTzEGPF19yRlWlgVsLnzNoxS7bCEEI4NIsTIJPJxH/+8x8MBgMRERE0btwYX19f/vvf/162KKKoO7ttZAaY4qIQ8UoEEa9EoLg45hBoxde4YtadEEII+2fxENiLL77I7Nmzef311+nZsyeqqrJp0yamTp1KUVERr776al3EKf6iuMzIwTM5AMSGW3cLDI2rhiZTm1g1hrr2Zw+QcxRCCyGEM7A4Afryyy/54osvuO2228zHYmJiaNSoEY899pgkQPUg8UwOJUYTfp6uhPu5Wzsch9c+zBeNAmeyizibU0SQLIgohBB2z+IhsAsXLtC6devLjrdu3ZoLF2TLgPqwLzUbKN8B3toz71STSv6BfPIP5KOaHK8GCMBLr6PlpQURnaEOSAghnIHFCVBMTAwzZ8687PjMmTOJiYmx6FrTp0+nS5cueHt7ExgYyLBhwzh8+PBVz1m8eDEDBw4kICAAHx8f4uLi+P333yu1mTdvHoqiXHYrKiqyKD5btSelIgHytW4ggKnQxPa229nedjumQsetAauoA6qYfSeEEMK+WTwE9uabb3LLLbewatUq4uLiUBSFzZs3k5KSwrJlyyy61rp16xg/fjxdunShrKyMF198kUGDBpGYmIjnFRZiW79+PQMHDuS1117D19eXuXPncuutt7J161ZiY2PN7Xx8fC5LptzcHGPoYl9qFgDtGxmsG4gTiQ1vwPxtKSRID5AQQjgEixOgvn37cuTIET766CMOHTqEqqrccccdPPbYY4SGhlp0reXLl1e6P3fuXAIDA9m5cyd9+vSp8pwZM2ZUuv/aa6/x888/88svv1RKgBRFITg42KJ47EF+cRnHMvKA8iEwUT86XOoB2ns6mzKjCZ3WsdY7quBeBkkPHwAPD9xdpL5MCOG4LE6AAEJDQ+uk2Dk7u3xox8+v+ovNmUwmcnNzLzsnLy+PiIgIjEYjHTp04L///W+lBMleHTiTg0mFYB832Z28HjUP8MJbryO3uIwjZ/OIctDVtzUqRBoiZCsMIYTDq1YCtHfvXtq2bYtGo2Hv3r1Xbdu+ffsaBaKqKpMnT6ZXr160bdu22ue988475OfnM3LkSPOx1q1bM2/ePNq1a0dOTg7vv/8+PXv2ZM+ePbRo0eKyaxQXF1NcXGy+n5OTU6PXUB/2ns4CpPenvmk0Cu3DDWw6dp7dKRcdNgESQghnUa0EqEOHDqSnpxMYGEiHDh1QFAVVvXzGj6IoGI3GGgUyYcIE9u7dy8aNG6t9zvz585k6dSo///wzgYGB5uPdu3ene/fu5vs9e/akY8eOfPjhh3zwwQeXXWf69OlMmzatRnHXt72n/5wBJupXbHgDNh07T0JyFvd0i7B2OHWiRAsvrn0RXFx49cZXcdU67ka3QgjnVq0EKCkpiYCAAPP/a9vjjz/O0qVLWb9+PWFhYdU6Z+HChTz44IP88MMPDBgw4KptNRoNXbp04ejRo1U+PmXKFCZPnmy+n5OTQ3h4ePVfQD36swfI16pxOCPzgogOvCJ0qQbe3vE+AFP7TZUESAjhsKqVAEVE/PnX7qlTp+jRowc6XeVTy8rK2Lx5c6W216KqKo8//jhLlixh7dq1NGlSvRWF58+fzwMPPMD8+fO55ZZbqvU8CQkJtGvXrsrH9Xo9er3tb/qYXVDKyfMFALSTGWD1rqIQ+lhGHtmFpRjcXawbkBBCiBqzeCpL//79q1zwMDs7m/79+1t0rfHjx/PNN9/w3Xff4e3tTXp6Ounp6RQWFprbTJkyhTFjxpjvz58/nzFjxvDOO+/QvXt38zkVBdQA06ZN4/fff+fEiRMkJCTw4IMPkpCQwLhx4yx9uTalYgHExn4eNPCUv8zrW0MvvXnl7YqeOCGEEPbJ4gRIVdUqVx8+f/78FdfuuZKPP/6Y7Oxs+vXrR0hIiPm2cOFCc5u0tDSSk5PN9z/99FPKysoYP358pXMmTZpkbpOVlcUjjzxCmzZtGDRoEKmpqaxfv56uXbta+nJtyt5L6/+0k/ofq6nYe03WAxJCCPtW7Wnwd9xxB1Be6Dx27NhKQ0ZGo5G9e/fSo0cPi568qkLqv5s3b16l+2vXrr3mOe+99x7vvfeeRbHYg72XVoCOkQTIajqE+7J0zxmHrgMSQghnUO0EyGAo/9BVVRVvb2/c3f9cJM3V1ZXu3bvz8MMP136EwqxiCKxdI1/rBuLEKrbESEjJumJvqBBCCNtX7QRo7ty5AERGRvL0009bPNwlrk9mXjGpWYUoCrRtJGvQWEtUqA+uWg0X8ktIvlBAhL/8HAghhD2yeCXoV155pS7iENew79L6P00beuLtZjuzjzTuGrrs72L+v6PT67REhfqQkJLF7uQsh0uA3Mtg/9ht4C5bYQghHFuNtsL48ccf+f7770lOTqakpKTSY7t27aqVwERley7NOoqxsfV/FI2CZ7RjJQHXEtvYl4SULBJSshgW28ja4dQqjQrRDaNkKwwhhMOz+E/2Dz74gPvvv5/AwEB2795N165d8ff358SJE9x88811EaPgzx4gmQFmfRULIiZIIbQQQtgtixOgWbNm8dlnnzFz5kxcXV159tlnWblyJRMnTqy0Fo+oPaqqsje1YgsMX+sG8zemEhNJU5NImpqEqcRk7XDqRcV7kJiWQ0mZY73mEi1M3fQqU9dOpcRYcu0ThBDCTlmcACUnJ5unu7u7u5ObmwvA6NGjmT9/fu1GJwBIzyniXG4xWo1CVIhtFUCrpSqnpp3i1LRTqKXXXtbAEUT6e+DjpqOkzMSRs7nWDqdWlWpgWvx0pq2bRqmx1NrhCCFEnbE4AQoODub8+fNA+RYZW7ZsAcr3CKvOuj7CchUboLYM8sbdVWvlaCpTdAqhj4US+lgois45poQrimLuBdojK0ILIYRdsjgBuuGGG/jll18AePDBB3nyyScZOHAgo0aN4h//+EetByj+sgGqDe7/pdFraPlRS1p+1BKN3vFngVVof6kWq2JxSiGEEPbF4llgn332GSZTed3DuHHj8PPzY+PGjdx66612v9eWrdqXmgNIAbQtkR4gIYSwbxYnQBqNBo3mz7/0R44cyciRI2s1KPEnVVU5YF4B2vYSIFVVKc0srxVxaejiNCsjx4SXvxdHM/IoLDHa3NCkEEKIq7M4AVq/fv1VH+/Tp0+NgxGXS88p4nx+CVqNQqtgb2uHcxlTgYnNgZsB6J3XG62ncyQCwT5uBHjrOZdbzIEz2XSO9LN2SEIIISxgcQLUr1+/y4799a9+o9F4XQGJyvZfGv5qEeiFm4tzJBf2QFEUYsIMrDqYwZ7TkgAJIYS9sbhq9eLFi5VuGRkZLF++nC5durBixYq6iNGp7b80/NXWBoe/nF1FHdBeB6oDciuDbfesY9tD23DTuVk7HCGEqDMW9wBV7Ar/VwMHDkSv1/Pkk0+yc+fOWglMlDtwpjwBig61rfV/xF9mgp12nJlgWhW6hHSSrTCEEA6v1uYtBwQEcPjw4dq6nLikYghMeoBsT0UPUFJmPtmFsmigEELYE4t7gPbu3VvpvqqqpKWl8frrrxMTE1NrgQk4l1tMek4RigJtbGwFaAF+nq6E+7mTcqGQfaez6dWiobVDum4lWnh/2wxwdWVS90m4al2tHZIQQtQJixOgDh06oCjKZas+d+/enTlz5tRaYOLP4a8mDT3x0lv8Vol60D7Ml5QLhew5neUQCVCpBp5d/xIAj3V5TBIgIYTDsvhTNSkpqdJ9jUZDQEAAbm5SMFnbDpy5NPwVKsNftqpDmC+/7k1jj+wML4QQdsXiGqB169YRHBxMREQEERERhIeH4+bmRklJCV999VVdxOi0KnqA2jaS4S9b5YiF0EII4QwsToDuv/9+srMv/2Wfm5vL/fffXytBiXLmAmjpAbJZbRsZ0CjlC1Zm5BRZOxwhhBDVZHECpKpqldsdnD59usop8qJmsgtKSb5QAEC0JEA2y1Ovo3mgFwB7pBdICCHsRrVrgGJjY1EUBUVRuPHGG9Hp/jzVaDSSlJTETTfdVCdBOqMDaeUfpuF+7hg8XKwcjbia9mG+HDmbx97TWQyMCrJ2OEIIIaqh2gnQsGHDAEhISGDw4MF4eXmZH3N1dSUyMpI777yz1gN0VgcuDX9Fh0jvj62LCTPw487T0gMkhBB2pNoJ0CuvvAJAZGQkd911F3q9vs6CErDfTgqgNW4aYtbEmP/vjP66JcaVhojthVsZrBm5DNzdZSsMIYRDs3gafFRUFAkJCXTr1q3S8a1bt6LVauncuXOtBefMKvYAi7bxFaAVrUKDfg2sHYZVtQ7xxkWrkFVQSsqFQhr7e1g7pBrTqtCvcR/ZCkMI4fAs/pN9/PjxpKSkXHY8NTWV8ePH10pQzi6/uIwTmfmAzACzB3qd1rxS9x4H2hhVCCEcmcUJUGJiIh07drzseGxsLImJibUSlLM7lJ6DqkKQj54Ab9seajSVmkj9KJXUj1IxlZqsHY7V/LkeUJZ1A7lOpRr4aPenfLTtI0qNsr+ZEMJxWZwA6fV6zp49e9nxtLS0SjPDRM3Z0/o/aonK0QlHOTrhKGqJeu0THFRFHZC9F0KXaGHC6qeY8NsESowl1g5HCCHqjMUJ0MCBA5kyZUqlxRCzsrJ44YUXGDhwYK0G56zspf4HAC0EDA8gYHgAaK0djPXEXEqA9qdmYzQ5byIohBD2wuIum3feeYc+ffoQERFBbGwsUD41PigoiK+//rrWA3RG+817gNn2DDAArZuW6B+irR2G1TUP9MLDVUtBiZET5/JoEeRt7ZCEEEJchcU9QI0aNWLv3r28+eabREVF0alTJ95//3327dtHeHi4RdeaPn06Xbp0wdvbm8DAQIYNG8bhw4eved66devo1KkTbm5uNG3alE8++eSyNosWLSIqKgq9Xk9UVBRLliyxKDZrKSo1cvRsLlC+zYKwD1qNQtSlQuh9qfY9DCaEEM6gRgu3eHp68sgjj/DRRx/x9ttvM2bMGFxcLF+teN26dYwfP54tW7awcuVKysrKGDRoEPn5+Vc8JykpiSFDhtC7d292797NCy+8wMSJE1m0aJG5TXx8PKNGjWL06NHs2bOH0aNHM3LkSLZu3VqTl1uvjpzNpcyk0sDDhRCDrMNiT9rJxqhCCGE3LB4Cu9aO72PGjKn2tZYvX17p/ty5cwkMDGTnzp306dOnynM++eQTGjduzIwZMwBo06YNO3bs4O233zavRD1jxgxzrRLAlClTWLduHTNmzGD+/PnVjs8azAXQjQx2saCeMd/IBq8NAPTO643W03kLgdpd6rHbLz1AQghh8yxOgCZNmlTpfmlpKQUFBbi6uuLh4WFRAvR3FYXVfn5+V2wTHx/PoEGDKh0bPHgws2fPprS0FBcXF+Lj43nyyScva1ORNNmyihWgZQNU+1MxFf7AmRyMJhWtxvYTWCGEcFYWJ0AXL1687NjRo0d59NFHeeaZZ2ociKqqTJ48mV69etG2bdsrtktPTycoqPKGk0FBQZSVlZGZmUlISMgV26Snp1d5zeLiYoqLi833c3Jyavw6rlfipQLoKDsogBaVNWn4ZyH08XN5tLTDQmi9Ef73jx/BzQ29zrbXoBJCiOtRK5s3tWjRgtdff/2y3iFLTJgwgb1791ZriOrvQ0Oqql52vKo2VxpSmj59OgaDwXyztJi7thhNKofSL22CKgmQ3dFqFPP7ts9O64B0Jril2U3c0vIWdBpZ10sI4bhqbfdKrVbLmTNnanTu448/ztKlS1mzZg1hYWFXbRscHHxZT05GRgY6nQ5/f/+rtvl7r1CFinWNKm5VbfVRH06ez6eo1IS7i5ZIf9mLyR61a+QLyEwwIYSwdRb/ibd06dJK91VVJS0tjZkzZ9KzZ0+LrqWqKo8//jhLlixh7dq1NGnS5JrnxMXF8csvv1Q6tmLFCjp37myeiRYXF8fKlSsr1QGtWLGCHj16VHlNvV5vE7vbVwx/tQr2lvoRO9UuzL6nwpdq4Nv934Bezz3t7sFFa/nsTiGEsAcWJ0DDhg2rdF9RFAICArjhhht45513LLrW+PHj+e677/j555/x9vY299oYDAbc3d2B8t6Z1NRU8+yzcePGMXPmTCZPnszDDz9MfHw8s2fPrjR0NmnSJPr06cMbb7zB7bffzs8//8yqVavYuHGjpS+3XiWmSf2PvavoAUo8k0OZ0YROW2udrPWiRAv3Lx8HwIioEZIACSEclsUJkMlUextefvzxxwD069ev0vG5c+cyduxYoHyPseTkZPNjTZo0YdmyZTz55JN89NFHhIaG8sEHH5inwAP06NGDBQsW8NJLL/Hyyy/TrFkzFi5cSLdu3Wot9rpgLoAOkQTIXjVt6Imnq5b8EiPHz+XTKtj+CqGFEMIZWLXKsaJ4+WrmzZt32bG+ffuya9euq543fPhwhg8fXtPQrOKg9ADZPY1GITrUwLaTF9iXmi0JkBBC2KhqJUCTJ0+u9gXffffdGgfjzM7lFpORW4yiQGv50LRr7cIuJUCnsxje6epF/UIIIayjWgnQ7t27q3Uxe1i52FZV9P408ffEw1WmH9uzihWh7bUQWgghnEG1Pmnff/99oqOj0Wqdd5uDulZRAN1Ghr/sXsWeYIlp9lkILYQQzqBav5ljY2O5cOECAE2bNuX8+fN1GpQzMtf/SAG03Wvi74mXXkdRqYlj5/KsHY4QQogqVKsHyNfXlxMnThAQEMDJkydrdSaYKGevM8AUvULU91Hm/4uKQmgftiZdYN/pbFoH2897qjfC97d+BXrZCkMI4diqlQDdeeed9O3bl5CQEBRFoXPnzlccDjtx4kStBugMikrL944C+5sBptFpCBwRaO0wbE67RobyBCg1mxGdrbO1Sk3oTDCi1R3gKSuRCyEcW7USoM8++4w77riDY8eOMXHiRB5++GG8vWWmUm05nJ6LSQV/T1cCveWvbkdQUQckhdBCCGGbqj3d6KabbgJg586dTJo0SRKgWvTX9X/sbSadqcxE5pJMABr+oyEanRT8wp8zwextRegyDSw5vBj0bvyjzT9kQ1QhhMOy+Lfb3Llz6yIOp2aeAWZn9T8AarFK4shEAHrn9bby0pq2I/JSIXRecRlHM/Ls5r0t1sLIX8YAkDclD50sySCEcFD28Wepg7PXAmgANGDoa8DQ1yDfTX+h0Si0bWTfG6MKIYQjk48sKzOZVLveAkPrriV2bSyxa2PRuss6UX9VMQy2XxIgIYSwOZIAWVnKxQLyS4y46jQ0bSgzbxxJ20sJ0N7TkgAJIYStsTgBys/Pr4s4nFbF8FerIG+7KZQV1dM+zBcoL3IvNcraWUIIYUss/sQNCgrigQceYOPGjXURj9NJtPMVoI35RjYFbGJTwCaM+UZrh2NTIvw88NbrKC4zcfSsrAgthBC2xOIEaP78+WRnZ3PjjTfSsmVLXn/9dc6cOVMXsTkFcwG0Hdb/VCjNLKU0s9TaYdic8kJoqQMSQghbZHECdOutt7Jo0SLOnDnDo48+yvz584mIiGDo0KEsXryYsrKyuojTYdlzAbS4NntbENHVCHNv+oS5t8/FVetq7XCEEKLO1LjoxN/fnyeffJI9e/bw7rvvsmrVKoYPH05oaCj//ve/KSgoqM04HdLF/BLOZBcB0DpYFpZ0RBUzwfbaSQLkYoKxbe9lbIexuGhdrB2OEELUmRqvcpaens5XX33F3LlzSU5OZvjw4Tz44IOcOXOG119/nS1btrBixYrajNXhVPT+NPbzwNtNPmwcUUUCVFEI7SKF7kIIYRMsToAWL17M3Llz+f3334mKimL8+PHce++9+Pr6mtt06NCB2NjY2ozTIdl7AbS4tgh/D7zddOQWlXHkbC7RoQZrh3RVZRr4/fhycHNjcPPBshWGEMJhWfzb7f777+euu+5i06ZNdOnSpco2TZs25cUXX7zu4BxdotT/ODxFUWjXyMDm4+fZn5pt8wlQsRaGLhkOyFYYQgjHZvFvt7S0NDw8PK7axt3dnVdeeaXGQTmLihlg9rJPlKiZigRoX2o2o6r+m0EIIUQ9szgBKisrIycn57LjiqKg1+txdZWZI9VRXGbkWEb52jDSA+TYzDPBZEVoIYSwGRYnQL6+viiKcsXHw8LCGDt2LK+88goajRR8XsnRs3mUmVQM7i6EGtysHY6oQ+ZC6PRcSspMuOrk50IIIazN4gRo3rx5vPjii4wdO5auXbuiqirbt2/nyy+/5KWXXuLcuXO8/fbb6PV6XnjhhbqI2SEc/EsB9NUSSmH/Gvt54OOmI+dSIXTF4ohCCCGsx+IE6Msvv+Sdd95h5MiR5mO33XYb7dq149NPP2X16tU0btyYV199VRKgq6gogJb6H8enKArtwgxsOlZeCC0JkBBCWJ/FffHx8fFVTnGPjY0lPj4egF69epGcnHz90TkwR9gCQ1RfRdJjLytCCyGEo7O4BygsLIzZs2fz+uuvVzo+e/ZswsPDATh//jwNGjSonQgdkKqqDrMGkOKq0GJmC/P/RdXaN/IFbD8BcjXCzBvfAVe9bIUhhHBoFidAb7/9NiNGjOC3336jS5cuKIrC9u3bOXToED/++CMA27dvZ9SoUbUerKNIzSokt6gMF61C80Ava4dzXTQuGhqNb2TtMGxeRSH0oTTbLoR2McH42H+Bp6e1QxFCiDplcQJ02223ceTIET755BMOHz6MqqrcfPPN/PTTT0RGRgLw6KOP1nacDqVi+Kt5oLfNfhCK2hXu547B3YXswlIphBZCCBtgUQJUWlrKoEGD+PTTT5k+fXpdxeTwHGX4C0A1qmRtyALAt7cvilaGwapSsSL0xmOZ7LPhQmijAhuS14O7O70b90ar0Vo7JCGEqBMWdT+4uLiwf/9+mbZ9nRypANpUZGJP/z3s6b8HU5HJ2uHYtIqkZ68NL4hYpIP+3w+h/5f9KSorsnY4QghRZywefxkzZgyzZ8+ui1icxsF0x+kBQgGPKA88ojxA8uKran9pRej9Nl4ILYQQzsDiGqCSkhK++OILVq5cSefOnfH8W7Hku+++W+1rrV+/nrfeeoudO3eSlpbGkiVLGDZs2BXbjx07li+//PKy41FRURw4cAAoX6jx/vvvv6xNYWEhbm7WX3E5u7CUlAuFgGMkQFoPLV0PdLV2GHbBXAidnkNxmRG9ToaXhBDCWixOgPbv30/Hjh0BOHLkSKXHLB0ay8/PJyYmhvvvv58777zzmu3ff//9StPvy8rKiImJYcSIEZXa+fj4cPjw4UrHbCH5ATh0qf6nka87Bg8XK0cj6lNYA3caeLhwsaCUw+m5tA/ztXZIQgjhtCxOgNasWVNrT37zzTdz8803V7u9wWDAYPizePSnn37i4sWLl/X4KIpCcHBwrcVZm2QFaOdVviK0L+uPnGPv6WxJgIQQwopqPAf72LFj/P777xQWlg/nqKpaa0FV1+zZsxkwYAARERGVjufl5REREUFYWBhDhw5l9+7dV71OcXExOTk5lW51xbwHmAMUQAMYC4xsi97GtuhtGAuM1g7H5rVvJDvDCyGELbA4ATp//jw33ngjLVu2ZMiQIaSlpQHw0EMP8dRTT9V6gFeSlpbGb7/9xkMPPVTpeOvWrZk3bx5Lly5l/vz5uLm50bNnT44ePXrFa02fPt3cu2QwGMwrWteFP6fAe9fZc9QrFQoSCyhILID6z4HtTrtLhdB7pRBaCCGsyuIE6Mknn8TFxYXk5GQ8PDzMx0eNGsXy5ctrNbirmTdvHr6+vpcVTXfv3p17772XmJgYevfuzffff0/Lli358MMPr3itKVOmkJ2dbb6lpKTUScylRhNH0vMAiAqxzXVgRN2qmAl25GwuRaW212PmYoI3+/wfbw54Exet1KgJIRyXxTVAK1as4PfffycsLKzS8RYtWnDq1KlaC+xqVFVlzpw5jB49GlfXq+9XpNFo6NKly1V7gPR6PXq9vrbDvMyJc/mUGE1463WENXCv8+cTtifYx42GXnoy84pJTMuhY2Pb2jPP1QjPdH1CtsIQQjg8i3uA8vPzK/X8VMjMzKyXJAJg3bp1HDt2jAcffPCabVVVJSEhgZCQkHqI7OqyC0tpFuBJVKgPGo0smuOMFEUx9wJJHZAQQliPxQlQnz59+Oqrr8z3FUXBZDLx1ltv0b9/f4uulZeXR0JCAgkJCQAkJSWRkJBAcnIyUD40NWbMmMvOmz17Nt26daNt27aXPTZt2jR+//13Tpw4QUJCAg8++CAJCQmMGzfOotjqQtcmfqx+qh/fPdzd2qEIK2pnwytCGxXYnraT7anbMZpsb4hOCCFqi8VDYG+99Rb9+vVjx44dlJSU8Oyzz3LgwAEuXLjApk2bLLrWjh07KiVNkydPBuC+++5j3rx5pKWlmZOhCtnZ2SxatIj333+/ymtmZWXxyCOPkJ6ejsFgIDY2lvXr19O1q+0s1qeV3h+nZu4BSs2ybiBVKNJB12/7ApA3JQ9PVxkKE0I4JkWtwfz19PR0Pv74Y3bu3InJZKJjx46MHz/eJoaZakNOTg4Gg4Hs7Gx8fBxjunpdMeYb2eC1AYDeeb3ResrqxteSkVNE19dWo1Fg39TBeOot/juk9uXng5cX+S7g9WL5IUmAhBD2xpLP7xr95g0ODmbatGk1Ck4IZxfo40awjxvpOUUkpuXQJdLP2iEJIYTTqVEClJWVxbZt28jIyMBkqrwDeFU1O0KIytqFGUhPLGLv6WxJgIQQwgosToB++eUX7rnnHvLz8/H29q60/5eiKJIACVEN7RsZWJl4VnaGF0IIK7F4FthTTz3FAw88QG5uLllZWVy8eNF8u3DhQl3EKITDMa8IfTrLuoEIIYSTsjgBSk1NZeLEiVWuBSSEqJ6KqfAnMvPJLSq1cjRCCOF8LB4CGzx4MDt27KBp06Z1EY+wM4qLQsQrEeb/i+rx99LTyNed1KxCDpzJoXtTf2uHBJRvhfFK3BRwdZWtMIQQDs3iBOiWW27hmWeeITExkXbt2uHiUvmX5G233VZrwQnbp3HV0GRqE2uHYZfahxlIzSpk3+lsm0mAXI0wteeLshWGEMLhWZwAPfzwwwD85z//uewxRVEwGmX1WCGqo20jA7/tT5ed4YUQwgosToD+Pu1dODfVpFJwsAAAjzYeKLLKdbX9uSdYlnUD+QuTAgczEyHfgzYBbdAoFpcJCiGEXbCBJWiFPTMVmtjedjsgK0FbqqIQ+uT5ArILSjF4WL/mplAHbeeVbxsjK0ELIRxZtf+8GzJkCNnZf3bVv/rqq2RlZZnvnz9/nqioqFoNTtgHl4YuuDS0/oe3vfH1cKWxX/lsyv1nZBhMCCHqU7UToN9//53i4mLz/TfeeKPSuj9lZWUcPny4dqMTNk/rqaXnuZ70PNdTen9q4M/1gCQBEkKI+lTtBOjve6bWYA9VIcTftG9kuzvDCyGEI5MKRyGsSHqAhBDCOqqdACmKUmnfr4pjwrkZC43s7reb3f12YyyUJRAs1fZSD9Dpi4VcyC+xcjRCCOE8qj0LTFVVxo4di16vB6CoqIhx48bheWnBtL/WBwknYoLsddnm/wvL+Li50LShJycy89mXmk3flgHWDkkIIZxCtROg++67r9L9e++997I2shO8EJZrF2YoT4BOZ1k9AXIxwdOdJ4GLi2yFIYRwaNVOgObOnVuXcQjhtNo1MvBzwhmbqANyNcJb/V6VrTCEEA5PFkIUwsrah/kCsE+2xBDiuhhNKmeyCrlYUEJOYRn5JWXoNAouWg1ebjoa+boT4KVHIyvWCyQBEsLqokN9UBRIyy4iI7eIQG83q8ViUiA5+xSUetDY0Fi2whA2y2RSOZSey45TF9hx8iKH03NJOp9PSdnVixFdtArNArzoEO5Lh3BfercMoJGvez1FLWyJJEBCWJmnXkfzAC+OZuSxPzWbG1pbLwEq1EGTz6MB2QpD2J7iMiObj59nxYGzrEw8S2be5ZNvXLUa/DxdMbi74KHXYjKplBhVsgtKOJtbTKmxPHE6lJ7Lgu0pAESF+DA4OpjhncMkGXIikgAJYQPahRk4mpHH3tPZ3NA6yNrhCGFTDqfnsmB7Mkt2p5JVUGo+7umqpWNEAzpH+NE+zECzAC8aNXBHe4UhrjKjifScIvan5rDndBbbki6wK/kiiWk5JKblMGP1Efq1DGBMXCT9WgXIUi8OThIgIWxA+0YGFu9KZZ8NFEKLyi7ml3AiM5+UCwXkFZdRVGpEp1HwdnOhobeepg09CfW98oeuqBmjSWVlYjqfb0hi56mL5uOB3noGRQcxODqYbk38cdVVf5hWp9UQ1sCDsAYe3NQ2GIDzecWsPpTBkl2pxJ84z5rD51hz+BxtG/kw8YYWDIwKkkTIQUkCJIQNaHepEHpvajaqqsovXCsqKTOx5nAGaw5lsPn4eZIvFFzzHDcXDR3Cfeka6Udcs4Z0iWyATiv1UzVRVGpk8a5UPt9wgqTMfAB0GoUBbYIY1TWcPi0CajXZ9PfSM7JzOCM7h3PiXB7fbk3mu63J7E/N4ZGvdxLb2JdXbo2mQ7hvrT2nsA2SAAlhA6JCfNBqFM7lFnM2p5hgg/XqgJxVenYRX2w4weLdqZetyh1qcCPC3xMfdx1uLlpKjSZyi8o4m1PEyfMFFJWa2HLiAltOXOCDP47h5+nKwDZB3B4bSlxTf0loq8FkUvll7xneXH6Y1KxCAHzcdIyJi2RMj4h6mRzQNMCLl4dG8Vi/ZszemMS8zSfZnZzFsI82cUfHRrw4pA3+Xvo6j0PUD0mAhLAB7q5aWgR6cSg9lz2nswg2BFs7JKdxPq+YD/84xnfbks0ziAK89QxtH0KfFgF0jmyAt9uVF4U0mlSSMvPYlnSRbUnnWXfkHBfyS1i4I4WFO1Jo2tCTf3ZtzPBOYTTwdK2vl2VX4o+f57VlB81LQQT7uPFIn6aM6hKOp77+P6b8vfQ8e1Nr7usRyZvLD7No12kW70pl3eFz/N+wttzcLqTeYxK1TxIgIWxEh3BfDqXnkpCSxeBoSYDqmqqq/LDzNK8tO2gurO0a6ce/+jalb8uAag9haTUKzQO9aR7ozd3dGlNmNLE16QL/23uGpQlnOJGZz6vLDvLOysPc1aUxD/dpKjONLjmWkcvrvx1i1cEMALz0Oh7t14wHezXBzUVr5eggyMeNd0bGcG/3xjy/aB+Hz+by6Le7uKV9CP93e1tJaGvIZFL5eN1xRnQKI9DHer3diqqqqtWe3Ubl5ORgMBjIzs7Gx8fH2uHYNFOxiWOTjwHQ/N3maPRS91BT87clM2XxPno08+e7h7vX75Pn54OXF8VamLzoYdC58O7gd9HrHLO7/0J+CU8uTGDdkXMAtA725uWhUfRoVrvDVXnFZSxNOMM3W06RmJYDlNez3N6hERNuaE6Ths65zMC53GJmrDrCgu0pGE0qWo3CPd0aM/HGFjS00SGm4jIjH64+xsfrjmM0qYQa3Jh5T0c6Nm5g7dDszrJ9aTz27S4aeunZ9Hx/9LraS3Yt+fyWBKgKkgAJaziYlsPN72/AS69jzyuD6ndW0aUECIC8PIfeCmPnqYtM+G4XadlF6HUanhzYkgd7NcGlDouWVVVl07HzzFp7jM3HzwPlPUcjOoUx8cYWhDpJj1BhiZEvNpzgk3XHyS8xAjAwKojnb25NswAvK0dXPXtPZzFpQQJJmfnoNArP39yaB3s1kTqvaiozmhg8Yz3Hz+Uz6cYWPDmwZa1eXxKg6yQJkLAGo0ml3dTfKSgxsuLJPrQM8q6/J3eSBOh/e88weeEeSowmmjb05KN7OtImpH5/xhNSsvhg9VH+OFQ+7OOq1XBv9wge69/MZns/rpfRpLJo12neWXGYsznlixfGhBl4YUgbujX1t3J0lsstKuX5xfv4dW8aALe0C+HtETG4u1p/2M7WVfR0N/BwYf2z/a9aX1cTlnx+Sw2QuC6qqlKaWV4/4dLQRf4Kug5ajULbRga2JV0gISWrfhOgS1Qgs+AcUEBDj4YO9X7O3pjEf/+XCMDg6CDeGdkBLysU2HYI92XO2C7sPHWBN5cfZmvSBeZsSmLB9mQe6NmEh/s0xeBeux8K1rT+yDleW3aQQ+m5AIQ1cOfZm1oztF2I3e7J5e3mwsx/xtK9iR//+V8iv+5LI/lCAZ+P6SwzOK8iv7iMd1ceAeDxG1rUevJjKasWbKxfv55bb72V0NBQFEXhp59+umr7tWvXoijKZbdDhw5Vardo0SKioqLQ6/VERUWxZMmSOnwVzs1UYGJz4GY2B27GVHD1PXjEtcVeWmskISXLKs9f4AKBs5oQ+HYgBaXXXv/GXny05pg5+bkvLoJZ93SySvLzV50i/FjwSHe+frArMWEGCkqMzFxzjD5vruHjtccpvDREZK8OpecwZs42xszZxqH0XHzcdLw4pA2rn+rLbTGhdpv8VFAUhdFxkXz3cHf8PF3Zl5rN7R9tlMVMr+LzDSc4l1tMhL8H93aPsHY41k2A8vPziYmJYebMmRadd/jwYdLS0sy3Fi1amB+Lj49n1KhRjB49mj179jB69GhGjhzJ1q1bazt8IWpdxWJrCclZVo3DkXy+/gRv/X4YgKcHtWTqbdE2s2qzoij0bhHAT+N78sm9nWgR6EV2YSlvLD9En7fW8HX8yWtu7mlrTl8s4Knv93Dz+xtYf+QcLlqFB3s1Yd0z/Xm4T9NaLXi1BV0i/fh5fE9aBnlxNqeYEZ9uZlXiWWuHZXMycov4bP0JAJ4d3NqiFbzris3UACmKwpIlSxg2bNgV26xdu5b+/ftz8eJFfH19q2wzatQocnJy+O2338zHbrrpJho0aMD8+fOrFYvUAAlrOZNVSI/X/0CrUdg/dXD91RRcqgHKdwGvF8sPOcJmqN9tTeaFJfsAmDywJRNvbHGNM6zLaFL5OSGV91YdIeVC+WKA4X7uPDmgJbd3aGQziVtVLuaX8NGaY3wVf4oSY3nSdkv7EJ4d3IoIf/v+PqqO3KJSHp+/m7WHz6HVKEy/ox0jO4dbOyyb8cKSfXy3NZnYxr4sfrRHnQ2vW/L5bf0UrAZiY2MJCQnhxhtvZM2aNZUei4+PZ9CgQZWODR48mM2bN1/xesXFxeTk5FS6CWENIQY3Ar31GE0q+89IV/r1WHs4g5d/3g/A+P7NbD75gfI6sDs6hrF6cj/+e3s0Ad56Ui4UMvn7Pdz8/nqW70/DZLKJv1nNsgpKmLHqCH3eXMMXG5MoMZqIa+rPz+N78tHdHZ0i+YHyuqDPx3Tmzo5hGE0qz/64l4/XHsdG+his6lhGLgu3pwDw4pA2NlNbaFdF0CEhIXz22Wd06tSJ4uJivv76a2688UbWrl1Lnz59AEhPTycoqPJu2kFBQaSnp1/xutOnT2fatGl1GrsQ1aEoCh3CfVmReJaE5Cy6RPpZOyS7dDAth/Hf7sJoUrmzYxhPD2pl7ZAs4qrTMDoukjs7hfHl5lN8su44R87mMe6bXTQN8OSR3k0ZFtvIqosFnsst5ouNJ/gm/pR5SntUiA/P3dyaPi0cq4C+uly0Gt4e0Z6G3q58uu4Ebyw/RGZeMS8OaWP3NU/XY/qyQxhNKoOjg+hsQ7/T7CoBatWqFa1a/fmLLC4ujpSUFN5++21zAgRc9oN3rc0lp0yZwuTJk833c3JyCA+XrsvqMBYZOTS6vAi99det0bo51vi+NcRUJEBWKoS2d9kFpTz81Q7yS4zENfVn+h3t7PbD2MO1fGXku7s15osNJ5i3+SQnzuXz/OJ9vL3iCGN7RDCyc3i9rqa793QWX8Wf4pc9Zyi+VJ/UOtibCTc0Z0hb+53ZVVsURWHKzW1o6Knn1WUHmb0xibyiMl67o51ND2HWlT8OnWX1oQxctArP3tTa2uFUYlcJUFW6d+/ON998Y74fHBx8WW9PRkbGZb1Cf6XX69HrHXP9jTpnhHM/XlpNd55tfXPbK2vPBLNnJpPK5O8TOH2xkMZ+HnxybyebKLa8XgZ3F54a1Ip/9W3Ggm3JzN6YRFp2EW+vOMJ7q47Sv1UgIzuH0adlQJ30Cp3LLea3/Wks2pXKnr98X8aE+/J4/+bc2CbQbpPMuvJwn6Y08HTl2R/3sHBHCiVGE28Nb1/tLVYcQVGpkalLy2dfPtCric0tdmn3CdDu3bsJCflzY7q4uDhWrlzJk08+aT62YsUKevToYY3whLBYuzADigKpWYWcyy0mwLv+knOdCe6Lvgd0OnQa+/v18On6E6w+lIGrTsOsezpi8HCc9XSgfK+sh3o35b4ekfyy5wzfbk1m56mLrDp4llUHz+LpqqVfq0AGRgUR18yfoBr2DKmqypGzeWw8lskfh84Sf/w8FaVHrloNQ9oFMzouko6NfSXxuYrhncJwc9EwaUECS3anUmI0MWNUhzpdddyWfL7+BMkXCgjy0fP4DbZXg2fV33B5eXkcO3bMfD8pKYmEhAT8/Pxo3LgxU6ZMITU1la+++gqAGTNmEBkZSXR0NCUlJXzzzTcsWrSIRYsWma8xadIk+vTpwxtvvMHtt9/Ozz//zKpVq9i4cWO9vz4hasLbzYUWgV4cOZtHQkoWA6Ou3HtZ2/RGmHfzp3a5EvS2pAu89Xv5cOy026Jp28hg5YjqjotWwx0dw7ijY5i5wPSXPWmk5xTx6740ft1XvkJxWAN3Yhs3oFmAJ00DvAgxuOHr7oKPuwuqCqVGE4WlRs7mFHE2p5jj5/JIPJPDgTPZZOaVVHrOmHBfbm0fwrDYRg67YnVdGNo+FBethgnf7eLXvWmUlJmYeXeswy0H8HenLxbw0dryz/cXb4my+rpbVbFqRDt27KB///7m+xV1OPfddx/z5s0jLS2N5ORk8+MlJSU8/fTTpKam4u7uTnR0NL/++itDhgwxt+nRowcLFizgpZde4uWXX6ZZs2YsXLiQbt261d8LE+I6xYT5cuRsHnvqOQGyV3nFZUz+PgGTCnfENuKuLs5Tw9c80JsXb4nihSFt2Jeaze8H0llz6ByH0nM4fbGQ0xcLa3RdNxcNXZv406u5PzdFh9DY36OWI3ceg6OD+Wx0Z/71zU5WJp7lX1/v5JN7O9nEjvd15b//S6So1ES3Jn7c2j7k2idYgc2sA2RLZB2g6jPmG9ngtQGA3nm90Xo67g90ffp26yleXLKfXs0b8s1D9ZC8X1oHSAUKLpwFT088XDzsZnjj+UV7WbA9hbAG7vw2qbfVl9i3BblFpSSkZHHgTA4nzuVx4lw+mXnFZBWWkltUhgLotApuLloCvfUE+bgR7udBdKgPbUJ8iA71cfheivq28WgmD321naJSE72aN+TzMZ0dcv+w5fvTGffNTrQahWUTe9MquP629ZG9wISwcxUrQu9JycJkUuttZk2BC3h9UN7jZC8LIf5x6CwLtqegKPD2iBhJfi7xdnOhd4sAercIsHYo4pJeLRoy7/6uPDBvOxuPZXLf3G3MGdvFJoeHaiq7oNS8/ta/+jSt1+THUs5RiSWEnWkV5I2bi4bc4jJOZOZZOxyblV1QynOLyld6fqBnE7rb4c7iwrl0b+rP1w92w1uvY1vSBcbM3kpOUam1w6o1ry5L5FxuMU0DPG1+8VFJgISwQTqthnaXingTUmRF6Ct54/dD5l+2zwy2r8UOhfPqFNGAbx7qho+bjl3JWdz7xVayCkqufaKN23D0HN/vOI2iwJt3trf5GidJgISwUeaNUVMuWjcQG7Xz1EW+21o+SWL6P9rZ/C9bIf4qJtyX+Y90p4GHC3tPZ3P351u5kG+/SVBWQQnP/LAXgPviIm1qxecrkQRICBsVcykB2i07w1+m1GjixUubnA7vFEY3GfoSdig61MCCR+Jo6KUnMS2Huz6L51xusbXDspiqqjy/aB/pOUU0bWg/vbGSAAlhozpFNADgUHou+cVlVo7GtszdlMSh9FwaeLjwwpA21g5HiBprFezNgke6E+Sj58jZPEZ9Fk96dpG1w7LIwu0pLD+QjotW4f27YvG0k6JuSYCEsFEhBndCDW4YTWql7QecXUZOETNWHQVgypA2+Hm6WjkiIa5P80AvFj4SR6jBjRPn8hn1WTypWTVbv6m+HcvIY9ov5dtdPD2oFe3C7GcBUkmAxPXRQsDwAAKGB4CUYNS6TpfG0Xeeqp86IK0Kw1sOY3jUcLQa23xD315xmIISIzHhvgzvGGbtcISoFZENPVn4rzjC/dw5db6AkZ/Ek3y+wNphXVVuUSmPfL2DwlIjPZv783DvptYOySKSAInronXTEv1DNNE/RMtO8HWgU2NfAHYm108C5FYGP9z2DT+M+AE3Xf3tMF5d+1Oz+WHnaQD+PbSN0+88LhxLuJ8HCx+Jo0lDT1KzChn+yWYOnLHNWaDlGw/v4cS5fEIMbswYFWt3P4+SAAlhwzpFlPcA7Tp1EZPJuRdtV1WV//s1EVWFoe1DzF8bIRxJqK87Cx/pTqsgbzJyixn16RY2Hs20dliXmbH6KCsTz+Kq0/DJvZ3qddPm2iIJkBA2rE2IN+4uWnKKyjh2zrkXRFyReJYtJy7gqtPw/M2trR2OEHUm0MeN78fF0b2pH3nFZYydu40lu09bOyyz+duS+WB1eR3e/w1ra56xam8kARLXxZhvZK2ylrXKWoz5RmuH43B0Wo15PaD6qAPKdwHlbS+UaQr5Jfl1/nzVVWo0MX3ZQQAe6tWEsAayMadwbAZ3F758oCu3xoRSZlJ5cuEeZv5xFGtv37kq8ax5CYrHb2jOyM72u/GwJEBC2LiK6fA7Tjrvgojf70jh5PkCGnq58lj/5tYOR4h6oddpeX9UBx7pU15c/PaKI4z/bpfVlsX449BZHvt2FyYVRnQKY/LAllaJo7bYx2R9YbM0Hhp6ZPQw/1/Uvk6R5QnQrnoqhLY1RaVGc3f7+P7NHWrjSCGuRaNReGFIGyL9PXll6X6W7UvnWEYen47uTJOG9bdZ8YoD6Yz/bhelRpXB0UG8dkc7FMW+ip7/Tj6xxHVRFAXXAFdcA1zt/ofBVnUML0+AkjLzOZ9nf6vEXq9vtpzibE4xoQY37u7W2NrhCGEVd3drzIJH4gj0Ll8w8dYPN/LDjpR6GRL7ZsspHv22PPm5pV0IM+/uiIvW/tMH+38FQjg4g4cLLQK9gPpbD8hW5BaV8tGaYwA8MaAlep0stSCcV6eIBvzv8V50iWxAXnEZz/y4l0e/2VVnfxiVGk288vN+XvppP0aTyh0dG/H+XR0cIvkBSYDEdTIVmzgy/ghHxh/BVGyydjgOq/OlYbD6Wg/IVszZeJKLBaU0bejJHR0bWTscIawu0MeNBY/E8czgVug0CssPpHPDO+v4Ov4kxlpcKuP4uTyGf7yZL+NPAfDM4Fa8MyIGnYMkPyAJkLhOapnKmVlnODPrDGqZc69TU5c6Nr5UB+REPUBZBSV8vuEEAE8ObOlQv3iFuB5ajcL4/s35aXxPWgd7k11Yyss/H2DohxtZlXj2uobFCkuMvLfyCEPe38Ce09n4uOn45N5OjO/f3OHKHKSaUAg7UDETbM/pbIrLjHU2FKRVYUiTwaDTWn0rjDkbk8grLqN1sDe3tAuxaixC2KK2jQz87/FefLctmXdWHOFgWg4PfbWD1sHejImL5JZ2IRg8XKp1rayCEuZvS2HupiQyLu1I37O5P2+PiCHE4F6XL8NqJAESwg40aeiJn6crF/JLOHAmx9wjVNvcyuDXOxeBZ/3NLqlKTlEpczefBGDijS3sbol9IeqLTqthTFwkQ9uH8tn6E3yz5RSH0nN5Yck+pi49QI/m/nRt4keHcF/CG3jg6+GCRlHILizl9MVC9p7OYuOxTDYezaTs0hBaI193XhjShiHtgh2u1+evJAESwg4oikLHxg1YdfAsO05eqLMEyFZ8HX+K3KIymgd6cVN0sLXDEcLm+Xm68vzNrXm0bzMW7khm8a5UDqXnsvbwOdYePleta0SF+PBArybcFhOKq87xh5wlARLCTnRr4seqg2fZeuICj/RpZu1w6kx+cRlfXKr9mdC/ufT+CGEBg4cLj/RpxiN9mnEoPYdNx86zPekCh9JzOJNVRImxfLKKi1Yh0NuNqFAfOjZuwMCoIJpfmm3qLCQBEsJOdGtavvnntpMXMJpUtHWQGOS7QOCMQFAg4+kMPF3rfyjsu63JXCwoJcLfg6HtpfZHiJpqHexD62AfHuzVBCjfwb3EaMKkqrjptE7/x4Xj93EJ4SCiQnzw0uvILSrjYFpOnT1PQVkBBaUFdXb9qykqNfLZpd6f8f2ay8wvIWqRRqPg5qLFw1Xn9MkPSAIkhN3QaTXm9YC2Jl2wcjR1Y+H2FM7lFtPI151hsbLujxCi7kgCJIQd6dbEH4CtJ85bOZLaV1Jm4pN1xwEY17epUxRhCiGsR37DCGFHKuqAtp+8gKkWV321BT8lpJKWXUSgt54RncOtHY4QwsFJAiSEHWnXyIC7i5aLBaUczcizdji1xmRS+Xx9ee3Pg72a4OYie34JIeqWJEBC2BEXrca8KvTWJMcZBlt35BxHM/Lw0uv4p+z4LoSoB5IAieujAUNfA4a+BvluqifdmpQPg209UfuF0BoV+ob1om9EXzRK/b2hn64vr/35Z9dwfNyqt3S/EEJcD1kHSFwXrbuW2LWx1g7DqXRreqkQOuk8qqrW6lL17mWw9q7l9boVxt7TWWw5cQGdRuH+nk3q7XmFEM7Nqn+zr1+/nltvvZXQ0FAUReGnn366avvFixczcOBAAgIC8PHxIS4ujt9//71Sm3nz5qEoymW3oqKiOnwlQtSfmHADep2GzLwSjp/Lt3Y41+2zS7U/t8aEEurrmJsuCiFsj1UToPz8fGJiYpg5c2a12q9fv56BAweybNkydu7cSf/+/bn11lvZvXt3pXY+Pj6kpaVVurm5udXFSxCi3ul1WmIb+wL2XweUcqGAZfvSAHi4d1MrRyOEcCZWHQK7+eabufnmm6vdfsaMGZXuv/baa/z888/88ssvxMb+OQyjKArBwbKBYn0w5hvZErkFgO4nu6P1lNk79aF7U3+2nLjA5uPnuadbRK1dN98FIj+KAEXh5KSTdb4VxuyNSZhU6N2iIVGhPnX6XEII8Vd2XbZqMpnIzc3Fz8+v0vG8vDwiIiIICwtj6NChl/UQ/V1xcTE5OTmVbqL6SjNLKc0stXYYTqVX84YAbD6WWevrAWUWniezILNWr1mVrIISFm5PAeCRPtL7I4SoX3adAL3zzjvk5+czcuRI87HWrVszb948li5dyvz583Fzc6Nnz54cPXr0iteZPn06BoPBfAsPl0XYqkvjrqHL/i502d8FjbtdfzvZlZhwX7z0Oi4WlJJYh/uC1aVvtyZTWGqkTYiPOaETQoj6YrefWPPnz2fq1KksXLiQwMBA8/Hu3btz7733EhMTQ+/evfn+++9p2bIlH3744RWvNWXKFLKzs823lJSU+ngJDkHRKHhGe+IZ7Ykim+vVGxethu6XVoXecLTue2tqW1GpkbmbTgLwSJ8mtTqTTQghqsMuE6CFCxfy4IMP8v333zNgwICrttVoNHTp0uWqPUB6vR4fH59KNyFsXUWvycZj56wcieV+TkglM6+YEIMbQ9uHWjscIYQTsrsEaP78+YwdO5bvvvuOW2655ZrtVVUlISGBkJCQeojO+ZhKTCRNTSJpahKmEpO1w3EqvVoEALD95EWKSo1Wjqb6TCbVPPX9gZ5NcNHa3a8hIYQDsOossLy8PI4dO2a+n5SUREJCAn5+fjRu3JgpU6aQmprKV199BZQnP2PGjOH999+ne/fupKenA+Du7o7BYABg2rRpdO/enRYtWpCTk8MHH3xAQkICH330Uf2/QCeglqqcmnYKgMbPNAZXKwfkRJoFeBJicCMtu4htSRfo0zLA2iFVy5rDGRw/l4+3XsddXaXeTghhHVb902vHjh3Exsaap7BPnjyZ2NhY/v3vfwOQlpZGcnKyuf2nn35KWVkZ48ePJyQkxHybNGmSuU1WVhaPPPIIbdq0YdCgQaSmprJ+/Xq6du1avy9OiDqmKMpfhsFqpw5Io0LnoI50Du1cZ1thfHqp9+fubo3xlm0vhBBWoqiqWrtzaB1ATk4OBoOB7OxsqQe6BmO+kQ1eGwDonddb1gGqZz8npDJpQQJRIT4sm9S75hfKzwcvr/L/5+XV2VYYCSlZDPtoEzqNwobn+hNikJWfhRC1x5LPbxl8F8KO9bzUA5SYlkNmXrGVo7m2zy/1/twWEyrJjxDCqiQBEsKONfTSExVS/lfO+iO2PRss+XwBv+2/tO2FLHwohLAySYCEsHP9W5cXP/9xKOO6r1XgApGfRRE5I5KC0oLrvt5fzd54ApMKfVoG0CZEhpaFENYlCZAQdu6G1kFAeQ9QqfH6liJQgVM5yZzKPkVtlgdezC/h+x2nAXhENj0VQtgASYCEsHMdwn3x83Qlp6iMnacuWjucKn279RSFpUaiQnzo2dzf2uEIIYQkQELYO61GoV/L2hsGq21FpUbmbS5fK+qRPk1l2wshhE2QBEgIB3BDm/L98GwxAfppd/m2F6EGN25pLyuyCyFsgyRAQjiA3i0C0GkUjmXkcep8vrXDMTOZVD7fcGnbi16y7YUQwnbIbyMhHIDB3YXOkQ0AWH3QdnqB/jj057YXo7rIthdCCNshCZC4Pgp4RHngEeUBUtphVQPalM8GW34gvcbXUIAo/9ZEBUTVSq3OZ5d6f+7uLtteCCFsi1U3QxX2T+uhpesB2WfNFtzcLoT/+/Ug209eICOniEAfN4uv4VEKB+7fUStbYSSkZLEt6QIuWoX7ezS57usJIURtkh4gIRxEI193OoT7oqrw+3X0AtWWWWuOAXBbTCOCDZYnY0IIUZckARLCgdzSrnyW1a/70qwax5GzuaxIPIuiwKP9ZOFDIYTtkQRIXBdjgZFt0dvYFr0NY4HR2uE4vZvaBgOwLekC53It3xy1wAWi53Ymelb0dW2FUdH7c1N0MM0DvWt8HSGEqCuSAInro0JBYgEFiQXl+ygIqwr38yAmzICphsNgKpB4/hCJ5xJrvBXGqfP5LN1zBoDx/ZvX6BpCCFHXJAES10XjpiFmTQwxa2LQuMm3ky0YUjEMttc6w2CfrDuOSYW+LQNo28hglRiEEOJa5BNLXBdFq9CgXwMa9GuAopV58LagYrXlLUnnOX2xdnd0v5a07EJ+3Fm+6emEG6T3RwhhuyQBEsLBhDXwoEczf1QVluxKrdfn/nTdCUqNKl2b+NEl0q9en1sIISwhCZC4LqZSE6kfpZL6USqmUpO1wxGX3NkxDIBFu07XuJbHUqlZhXy3NRmAiTe0qJfnFEKImpIESFwXtUTl6ISjHJ1wFLVEqqBtxU1tg/Fw1XLyfAE7T12sl+f8cPVRSowmujf1o2dz/3p5TiGEqClJgIRwQJ56nbkYesH2lGqfpwARPo2JMERYtBVGUmY+P1yq/XlmcKta2UZDCCHqkiRAQjiof3Yt33x06Z4zXMwvqdY5HqVw8pFETj5xEg8Xj2o/13srj2A0qfRvFUCnCKn9EULYPkmAhHBQHRs3oG0jH0rKTBb1AlnqYFoOv+wtX/fnqUGt6ux5hBCiNkkCJISDUhSF++IiAfhmyymMptqv0VJVlf/8koiqlk+/l3V/hBD2QhIgIRzYrTGhNPBwITWrkBXVWBm6UAddvu5Dl8+7UFhaeM32vx84S/yJ8+h1Gp6/qXVthCyEEPVCEiAhHJibi5Z7u0cA8OEfx645Jd6kwI6zu9hxZgcm9erLGhSVGnl1WSIA/+rTlHC/6tcMCSGEtUkCJISDe6BnEzxdtSSm5bAy8WytXfez9SdIuVBIsI8b4/o1q7XrCiFEfZAESAgH18DTlft6RALw/uqjtbIw4tGzucz8o3zH9ylDWuPhqrvuawohRH2SBEgIJ/BQ76Z4umo5cCbHvFN7TRlNKs/8uJcSo4kbWgdyW0xoLUUphBD1RxIgIZyAn6cr4/qWD1NNX3aI/OKyGl/r47XHSEjJwluv49V/tJVFD4UQdkkSICGcxMN9mhLu5056ThHvrTxSo2vEHz/Pu5fO/fetUYQY3GszRCGEqDdWTYDWr1/PrbfeSmhoKIqi8NNPP13znHXr1tGpUyfc3Nxo2rQpn3zyyWVtFi1aRFRUFHq9nqioKJYsWVIH0YsKLg1dcGnoYu0wxDW4uWiZdls0ALM3JbH5eGaV7Rq6+9PQo+Flx9OyC5m4YDcmtXyz1RGdw+s0XiGEqEtWTYDy8/OJiYlh5syZ1WqflJTEkCFD6N27N7t37+aFF15g4sSJLFq0yNwmPj6eUaNGMXr0aPbs2cPo0aMZOXIkW7durauX4dS0nlp6nutJz3M90XpqrR2OuIYbWgfxz67hqCo8sSCBtOzKa/14lsK58ac498w5PF09zcezC0u5b842zuUW0zLIi/8Oi67v0IUQolYpam1MCakFiqKwZMkShg0bdsU2zz33HEuXLuXgwYPmY+PGjWPPnj3Ex8cDMGrUKHJycvjtt9/MbW666SYaNGjA/PnzqxVLTk4OBoOB7OxsfHx8avaChLBR+cVl/GPWJo6czaN1sDfzH+5OA0rBy6u8QV4eeP6Z/GTmFXPfnG0cOJNDoLeexY/1IKyBrPkjhLA9lnx+21UNUHx8PIMGDap0bPDgwezYsYPS0tKrttm8efMVr1tcXExOTk6lmxCOylOvY87YLgR46zmUnsudH2/meEZelW13nLzA7TM3ceBMDv6ernz5QFdJfoQQDsGuEqD09HSCgoIqHQsKCqKsrIzMzMyrtklPv/I2ANOnT8dgMJhv4eFS21BdxkIju/vtZne/3RgLjdYOR1RTWAMP5j/cjUa+7pzIzOcfszYB5VthdP96EDEf9eCRrzcx/JN4UrMKaeznwQ/j4mgTIj2iQgjHYFcJEHDZlNuKEby/Hq+qzdWm6k6ZMoXs7GzzLSWl7nbOdjgmyF6XTfa6bLj6zgnCxjQP9GbJYz3o3yqAUmP5z5FJga1nN7M3M57ll/YOu7NjGL9O7EXTAC9rhiuEELXKrpZvDQ4OvqwnJyMjA51Oh7+//1Xb/L1X6K/0ej16vb72A3YCil4h6vso8/+FfQn0cWPO2C5s3BMI71V+7K4uYTzQsw2tg6XXRwjheOyqByguLo6VK1dWOrZixQo6d+6Mi4vLVdv06NGj3uJ0JhqdhsARgQSOCESjs6tvJ3GJoij0bhFw2fFXbm0ryY8QwmFZtQcoLy+PY8eOme8nJSWRkJCAn58fjRs3ZsqUKaSmpvLVV18B5TO+Zs6cyeTJk3n44YeJj49n9uzZlWZ3TZo0iT59+vDGG29w++238/PPP7Nq1So2btxY769PCCGEELbJqn+y79ixg9jYWGJjYwGYPHkysbGx/Pvf/wYgLS2N5ORkc/smTZqwbNky1q5dS4cOHfjvf//LBx98wJ133mlu06NHDxYsWMDcuXNp37498+bNY+HChXTr1q1+X5yTMJWZyPghg4wfMjCVSRGQEEII+2Az6wDZElkHqPqM+UY2eG0AoHdeb1kM0V7l54OXF/ku4PVi+aG8KXmVFkMUQghbZ8nnt10VQQsh6p6HzgOknl0I4eAkARJCmHmWQv4TGZVWghZCCEck03aEEEII4XQkARJCCCGE05EESAhhVqSDWxbdyS3f3UJRWZG1wxFCiDojNUBCCDOjAsuSfi//v0n2dhNCOC7pARJCCCGE05EESAghhBBORxIgIYQQQjgdSYCEEEII4XQkARJCCCGE05FZYFWo2B4tJyfHypHYPmO+kXzygfKvl9Yoe4HZpfzy9zBfBS7Nfs/JycHoKjPBhBD2o+JzuzrbnMpmqFU4ffo04eHh1g5DCCGEEDWQkpJCWFjYVdtIAlQFk8nEmTNn8Pb2RlFqd1fInJwcwsPDSUlJkZ3mbYC8H7ZF3g/bIu+H7ZH35OpUVSU3N5fQ0FA0mqtX+cgQWBU0Gs01M8fr5ePjI9+8NkTeD9si74dtkffD9sh7cmUGg6Fa7aQIWgghhBBORxIgIYQQQjgdSYDqmV6v55VXXkGv11s7FIG8H7ZG3g/bIu+H7ZH3pPZIEbQQQgghnI70AAkhhBDC6UgCJIQQQginIwmQEEIIIZyOJEBCCCGEcDqSANWBWbNm0aRJE9zc3OjUqRMbNmy4avt169bRqVMn3NzcaNq0KZ988kk9ReocLHk/Fi9ezMCBAwkICMDHx4e4uDh+//33eozW8Vn681Fh06ZN6HQ6OnToULcBOhlL34/i4mJefPFFIiIi0Ov1NGvWjDlz5tRTtI7P0vfj22+/JSYmBg8PD0JCQrj//vs5f/58PUVr51RRqxYsWKC6uLion3/+uZqYmKhOmjRJ9fT0VE+dOlVl+xMnTqgeHh7qpEmT1MTERPXzzz9XXVxc1B9//LGeI3dMlr4fkyZNUt944w1127Zt6pEjR9QpU6aoLi4u6q5du+o5csdk6ftRISsrS23atKk6aNAgNSYmpn6CdQI1eT9uu+02tVu3burKlSvVpKQkdevWreqmTZvqMWrHZen7sWHDBlWj0ajvv/++euLECXXDhg1qdHS0OmzYsHqO3D5JAlTLunbtqo4bN67SsdatW6vPP/98le2fffZZtXXr1pWO/etf/1K7d+9eZzE6E0vfj6pERUWp06ZNq+3QnFJN349Ro0apL730kvrKK69IAlSLLH0/fvvtN9VgMKjnz5+vj/CcjqXvx1tvvaU2bdq00rEPPvhADQsLq7MYHYkMgdWikpISdu7cyaBBgyodHzRoEJs3b67ynPj4+MvaDx48mB07dlBaWlpnsTqDmrwff2cymcjNzcXPz68uQnQqNX0/5s6dy/Hjx3nllVfqOkSnUpP3Y+nSpXTu3Jk333yTRo0a0bJlS55++mkKCwvrI2SHVpP3o0ePHpw+fZply5ahqipnz57lxx9/5JZbbqmPkO2ebIZaizIzMzEajQQFBVU6HhQURHp6epXnpKenV9m+rKyMzMxMQkJC6ixeR1eT9+Pv3nnnHfLz8xk5cmRdhOhUavJ+HD16lOeff54NGzag08mvq9pUk/fjxIkTbNy4ETc3N5YsWUJmZiaPPfYYFy5ckDqg61ST96NHjx58++23jBo1iqKiIsrKyrjtttv48MMP6yNkuyc9QHVAUZRK91VVvezYtdpXdVzUjKXvR4X58+czdepUFi5cSGBgYF2F53Sq+34YjUbuvvtupk2bRsuWLesrPKdjyc+HyWRCURS+/fZbunbtypAhQ3j33XeZN2+e9ALVEkvej8TERCZOnMi///1vdu7cyfLly0lKSmLcuHH1Eardkz+palHDhg3RarWXZesZGRmXZfUVgoODq2yv0+nw9/evs1idQU3ejwoLFy7kwQcf5IcffmDAgAF1GabTsPT9yM3NZceOHezevZsJEyYA5R/Aqqqi0+lYsWIFN9xwQ73E7ohq8vMREhJCo0aNMBgM5mNt2rRBVVVOnz5NixYt6jRmR1aT92P69On07NmTZ555BoD27dvj6elJ7969+b//+z8ZQbgG6QGqRa6urnTq1ImVK1dWOr5y5Up69OhR5TlxcXGXtV+xYgWdO3fGxcWlzmJ1BjV5P6C852fs2LF89913MpZeiyx9P3x8fNi3bx8JCQnm27hx42jVqhUJCQl069atvkJ3SDX5+ejZsydnzpwhLy/PfOzIkSNoNBrCwsLqNF5HV5P3o6CgAI2m8se4VqsF/hxJEFdhreprR1UxjXH27NlqYmKi+sQTT6ienp7qyZMnVVVV1eeff14dPXq0uX3FNPgnn3xSTUxMVGfPni3T4GuRpe/Hd999p+p0OvWjjz5S09LSzLesrCxrvQSHYun78XcyC6x2Wfp+5ObmqmFhYerw4cPVAwcOqOvWrVNbtGihPvTQQ9Z6CQ7F0vdj7ty5qk6nU2fNmqUeP35c3bhxo9q5c2e1a9eu1noJdkUSoDrw0UcfqREREaqrq6vasWNHdd26debH7rvvPrVv376V2q9du1aNjY1VXV1d1cjISPXjjz+u54gdmyXvR9++fVXgstt9991X/4E7KEt/Pv5KEqDaZ+n7cfDgQXXAgAGqu7u7GhYWpk6ePFktKCio56gdl6XvxwcffKBGRUWp7u7uakhIiHrPPfeop0+frueo7ZOiqtJPJoQQQgjnIjVAQgghhHA6kgAJIYQQwulIAiSEEEIIpyMJkBBCCCGcjiRAQgghhHA6kgAJIYQQwulIAiSEEEIIpyMJkBBCCCGcjiRAQgghhHA6kgAJIYQQwulIAiSEcBo//vgj7dq1w93dHX9/fwYMGEB+fr61wxJCWIHO2gEIIUR9SEtL45///Cdvvvkm//jHP8jNzWXDhg3IdohCOCfZDFUI4RR27dpFp06dOHnyJBEREdYORwhhZTIEJoRwCjExMdx44420a9eOESNG8P/t270Jg1AYhtFvAsu0Yukigaxz9xDsM4R9II2FcDcJWAj2kmyRW3znTPCWD/fn+XzGcRytZwGNOAEC0vh+v7FtW7xer1iWJT6fT9RaYxiG1tOAPxNAQErXdUXf91FKiVJK6znAn3kEDaRQa433+x33+z1ut1vUWmPf9xjHsfU0oAEBBKTQdV2s6xrzPMd5ntH3fUzTFI/Ho/U0oAFXYABAOn6BAQDpCCAAIB0BBACkI4AAgHQEEACQjgACANIRQABAOgIIAEhHAAEA6QggACAdAQQApCOAAIB0fhYLgRkvNuMXAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot the results\n",
+    "plt.figure()\n",
+    "plt.plot(s_space, fluctuation)\n",
+    "plt.xlabel('s')\n",
+    "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n",
+    "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label ='hyperopt')\n",
+    "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n",
+    "plt.title('First DBI step')\n",
+    "plt.ylabel('Energy fluctuation')\n",
+    "plt.legend()\n",
+    "plt.figure()\n",
+    "plt.plot(s_space, off_diagonal_norm_diff)\n",
+    "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n",
+    "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n",
+    "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n",
+    "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n",
+    "plt.xlabel('s')\n",
+    "plt.title('First DBI step')\n",
+    "plt.legend()\n",
+    "print('The minimum for cost function in the tested range is:', step_grid)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 177,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "off_diagonal_norm_diff = [dbi.off_diagonal_norm]\n",
+    "energy_fluc = [dbi.energy_fluctuation(state=state)]\n",
+    "iters = 10\n",
+    "dbi_ = deepcopy(dbi)\n",
+    "for _ in range(iters):\n",
+    "    step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n",
+    "    dbi_(step_poly,d=d)\n",
+    "    off_diagonal_norm_diff.append(dbi_.off_diagonal_norm)\n",
+    "    energy_fluc.append(dbi_.energy_fluctuation(state=state))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 178,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Energy fluctuation')"
+      ]
+     },
+     "execution_count": 178,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "plt.plot(range(iters+1), off_diagonal_norm_diff)\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(range(iters+1), energy_fluc)\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel(r'Energy fluctuation')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 179,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\andre\\AppData\\Local\\Temp\\ipykernel_23312\\3703842558.py:14: ComplexWarning: Casting complex values to real discards the imaginary part\n",
+      "  energy[i,j] = dbi_.h.matrix[states[i],states[i]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "iters = 30\n",
+    "states = [0,1,2,3,4,5,6,7]\n",
+    "energy = np.empty((len(states),iters))\n",
+    "\n",
+    "\n",
+    "d = (np.diag(np.linspace(1,2**nqubits,2**nqubits)))\n",
+    "for i in range(len(states)):\n",
+    "    dbi_ = deepcopy(dbi)\n",
+    "    dbi_.state = states[i]\n",
+    "    for j in range(iters):\n",
+    "        step_poly = dbi_.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=3)\n",
+    "        if step_poly is not None:\n",
+    "            dbi_(step_poly,d=d)\n",
+    "        energy[i,j] = dbi_.h.matrix[states[i],states[i]]\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 181,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Eigenvalues: [-4.00000000e+00 -3.46410162e+00 -8.06606266e-16  3.61709753e-17\n",
+      "  2.32474753e-15  2.00000000e+00  2.00000000e+00  3.46410162e+00]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 0, 'Iterations')"
+      ]
+     },
+     "execution_count": 181,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "eigvals = np.linalg.eigh(dbi_.h.matrix)[0]\n",
+    "print('Eigenvalues:', eigvals )\n",
+    "plt.figure()\n",
+    "for i in range(len(states)):\n",
+    "    plt.plot(range(iters), energy[i,:],'.', label='State ' + str(states[i]))\n",
+    "for eigvals in eigvals:\n",
+    "    plt.axhline(y=eigvals, color='r', linestyle='--')\n",
+    "plt.xlabel('Iterations')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Gradients for finding optimal $D$\n",
+    "\n",
+    "An advantage of the least-squares cost function is that one can use gradient descent and the learning is more stable than with the off-diagonal cost function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Diagonal elements')"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAGwCAYAAABIC3rIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABkN0lEQVR4nO3deVwV9f7H8ddh348gsiki5i64oSlaaaaouZalpZFWP9tNU1use7u2qi22XFvMblqm2WKWlVFmqRniTrkiuYKCIMsBFAFhfn9wOzdSC/TgYXk/H495FDPfM3xmrrfzdua7mAzDMBARERGpxxzsXYCIiIiIvSkQiYiISL2nQCQiIiL1ngKRiIiI1HsKRCIiIlLvKRCJiIhIvadAJCIiIvWek70LqC3Kyso4duwY3t7emEwme5cjIiIilWAYBvn5+YSEhODgcP7nQApElXTs2DFCQ0PtXYaIiIhcgJSUFJo0aXLe4wpEleTt7Q2U31AfHx87VyMiIiKVkZeXR2hoqPV7/HwUiCrp99dkPj4+CkQiIiK1zN91d1GnahEREan3FIhERESk3lMgEhERkXpPgUhERETqPQUiERERqfcUiERERKTeUyASERGRek+BSEREROo9BSIRERGp9xSIREREpN5TIBIREZF6T4FIRERE6j0FIjsrKzNYk5SBYRj2LkVERKTeUiCyo9Iyg+vejGf8gs2sSz5h73JERETqLQUiO3J0MNEtzBeAF77dq6dEIiIidqJAZGf39LkMTxdHdh7NI25nur3LERERqZcUiOysoZcrd1zZHIAXv0uitExPiURERC41BaIa4P+uDKeBhzP7M0+yfPtRe5cjIiJS7ygQ1QA+bs7c0/syAF5etY+iM6V2rkhERKR+USCqIcb1bEagjytHcwtZuinF3uWIiIjUKwpENYSbsyMT+7YE4N8//Map4jN2rkhERKT+UCCqQUZ1DaWpnwcnCopYGH/I3uWIiIjUGwpENYiLkwMP9i9/SvTWmv1YTpXYuSIREZH6QYGohhnWsTFtgrzJO32GN9b+Zu9yRERE6gUFohrG0cHEwwNbA7Dw50OkWQrtXJGIiEjdp0BUA13dOoDLm/lRdKaMV1Yl27scERGROk+BqAYymUw8MqgNAJ9sTeG3jHw7VyQiIlK3KRDVUFFhvvRvF0iZAS98m2TvckREROo0BaIa7OEBrXEwwbe7jrPtSI69yxEREamzFIhqsJaB3twQ1QSAWd/sxTC08KuIiEh1UCCq4Sb3a4WLkwObDmazJinT3uWIiIjUSQpENVxIA3fG92wGlD8lKi3TUyIRERFbUyCqBe7r0wKzuzNJx/NZtjXV3uWIiIjUOQpEtYDZw5n7r24BwEurkigsLrVzRSIiInWLAlEtcWvPMJr4unM8r4h3fz5o73JERETqFLsGohkzZmAymSpsQUFB1uPjx48/63iPHj0qnKOoqIiJEyfi7++Pp6cnw4YNIzW14mulnJwcYmNjMZvNmM1mYmNjyc3NvRSXaDOuTo48NKB8SY831+wnq6DIzhWJiIjUHXZ/QtS+fXvS0tKs244dOyocHzhwYIXjK1eurHB88uTJLF++nKVLl7J+/XoKCgoYMmQIpaX/e600ZswYEhMTiYuLIy4ujsTERGJjYy/J9dnS0A4hRDT2oaDoDK+t1pIeIiIituJk9wKcnCo8FfozV1fX8x63WCz85z//YdGiRfTr1w+ADz74gNDQUL7//nsGDBjAnj17iIuLIyEhge7duwMwf/58oqOjSUpKonXr1ra/qGri4GDisUFtGfPORhZvPML4XuGE+3vauywREZFaz+5PiJKTkwkJCSE8PJybbrqJAwcOVDi+Zs0aAgICaNWqFRMmTCAjI8N6bOvWrZSUlBATE2PdFxISQkREBPHx8QBs2LABs9lsDUMAPXr0wGw2W9ucS1FREXl5eRW2mqBnC3/6tG7EmTKD5+P22rscERGROsGugah79+68//77fPvtt8yfP5/09HR69uxJVlYWAIMGDWLx4sX88MMPvPTSS2zevJm+fftSVFTefyY9PR0XFxd8fX0rnDcwMJD09HRrm4CAgLN+d0BAgLXNucycOdPa58hsNhMaGmqry75ojw5qg8kE3+xMZ+vhbHuXIyIiUuvZNRANGjSIkSNHEhkZSb9+/fj6668BeO+99wAYPXo0gwcPJiIigqFDh/LNN9+wb98+a7vzMQwDk8lk/fmP/36+Nn82ffp0LBaLdUtJSbmQS6wWbYJ8GBVVHtCe/mqPlvQQERG5SHZ/ZfZHnp6eREZGkpx87g7DwcHBhIWFWY8HBQVRXFxMTk7FhU8zMjIIDAy0tjl+/PhZ58rMzLS2ORdXV1d8fHwqbDXJ1JhWeLg4kpiSy5e/ptm7HBERkVqtRgWioqIi9uzZQ3Bw8DmPZ2VlkZKSYj0eFRWFs7Mzq1atsrZJS0tj586d9OzZE4Do6GgsFgubNm2yttm4cSMWi8XapjYK8HHj7t6XATD7m72cLtFkjSIiIhfKroFo2rRprF27loMHD7Jx40ZuuOEG8vLyGDduHAUFBUybNo0NGzZw6NAh1qxZw9ChQ/H39+e6664DwGw2c8cddzB16lRWr17N9u3bueWWW6yv4ADatm3LwIEDmTBhAgkJCSQkJDBhwgSGDBlSq0aYncuEK5sT5OPG0dxCFsYfsnc5IiIitZZdA1Fqaio333wzrVu35vrrr8fFxYWEhATCwsJwdHRkx44dDB8+nFatWjFu3DhatWrFhg0b8Pb2tp7j5ZdfZsSIEYwaNYpevXrh4eHBl19+iaOjo7XN4sWLiYyMJCYmhpiYGDp06MCiRYvscck25e7yv8kaX//hN03WKCIicoFMhnrkVkpeXh5msxmLxVKj+hOVlRkMe309O4/mEdsjjKdHRNi7JBERkRqjst/fNaoPkVSdg4OJx69tB8CSTUf4LSPfzhWJiIjUPgpEdUD0ZQ3p3y6Q0jKDZ7/eY+9yREREah0FojrisWvb4uxo4sekTNYkZfz9B0RERMRKgaiOCPf3ZFx0MwCe+XoPJaVl9i1IRESkFlEgqkMmXtMSP08XfssoYMnGI/YuR0REpNZQIKpDzO7OTOnfCoCXv99H7qliO1ckIiJSOygQ1TE3dQuldaA3uadKeOX7cy+BIiIiIhUpENUxTo4OPDG0fBj+ooTDGoYvIiJSCQpEdVCvFv70a1s+DP8ZDcMXERH5WwpEddTjg8uH4a9JyuTHvRqGLyIi8lcUiOqocH9PbusVDsBTX+2m+IyG4YuIiJyPAlEdNrFvC/y9XDl44iQLfj5o73JERERqLAWiOszbzZlHBrYG4LXVyWTknbZzRSIiIjWTAlEdN7JLEzqGNuBkcSmz45LsXY6IiEiNpEBUxzk4mJjx32H4y7alsv1Ijp0rEhERqXkUiOqBzk19uSGqCQAzVuyirMywc0UiIiI1iwJRPfHwwNZ4uTrxS6qFT7el2rscERGRGkWBqJ4I8HbjgWtaAPB83F4shSV2rkhERKTmUCCqR8b3DOeyRp6cKCjm5VX77F2OiIhIjaFAVI+4ODnw5LAIAN7fcIg9aXl2rkhERKRmUCCqZ65o6c+1kUGUGfDEFzsxDHWwFhERUSCqhx4f3A53Z0c2H8rhi8Rj9i5HRETE7hSI6qHGDdy5v295B+tnV+4h/7Q6WIuISP2mQFRP/d+V4YT7e5KZX8Sr3yfbuxwRERG7UiCqp1ydHPnXf2ewXhB/iKT0fDtXJCIiYj8KRPVYn9YBxLQLpLTM4J+fq4O1iIjUXwpE9dy/hrXH3dmRTYey+WzbUXuXIyIiYhcKRPVc4wbuTOrXEoDnVu7BckodrEVEpP5RIBJu7xVOywAvsk4W8/y3e+1djoiIyCWnQCS4ODnw9IjyGayXbDpCYkqufQsSERG5xBSIBIAezRtyfefGGAb84/MdlJapg7WIiNQfCkRiNf3atni7ObHzaB4fJBy2dzkiIiKXjF0D0YwZMzCZTBW2oKAg63HDMJgxYwYhISG4u7vTp08fdu3aVeEcRUVFTJw4EX9/fzw9PRk2bBipqakV2uTk5BAbG4vZbMZsNhMbG0tubu6luMRapZG3Kw8PaA3Ai98mkZF32s4ViYiIXBp2f0LUvn170tLSrNuOHTusx55//nnmzJnD3Llz2bx5M0FBQfTv35/8/P9NIjh58mSWL1/O0qVLWb9+PQUFBQwZMoTS0lJrmzFjxpCYmEhcXBxxcXEkJiYSGxt7Sa+zthjTPYyOTczkF53hya9227scERGRS8Owo3/9619Gx44dz3msrKzMCAoKMmbNmmXdd/r0acNsNhtvvfWWYRiGkZubazg7OxtLly61tjl69Kjh4OBgxMXFGYZhGLt37zYAIyEhwdpmw4YNBmDs3bv3vLWdPn3asFgs1i0lJcUADIvFcjGXXCvsSM01wh/9ygh75Cvjh73H7V2OiIjIBbNYLJX6/rb7E6Lk5GRCQkIIDw/npptu4sCBAwAcPHiQ9PR0YmJirG1dXV3p3bs38fHxAGzdupWSkpIKbUJCQoiIiLC22bBhA2azme7du1vb9OjRA7PZbG1zLjNnzrS+YjObzYSGhtr0umuyiMZmbu8VDsA/P99JYXHp33xCRESkdrNrIOrevTvvv/8+3377LfPnzyc9PZ2ePXuSlZVFeno6AIGBgRU+ExgYaD2Wnp6Oi4sLvr6+f9kmICDgrN8dEBBgbXMu06dPx2KxWLeUlJSLutba5sH+rQgxu5GaU8hrP2jxVxERqdvsGogGDRrEyJEjiYyMpF+/fnz99dcAvPfee9Y2JpOpwmcMwzhr35/9uc252v/deVxdXfHx8amw1Seerk48Obx8bqL56w5o8VcREanT7P7K7I88PT2JjIwkOTnZOtrsz09xMjIyrE+NgoKCKC4uJicn5y/bHD9+/KzflZmZedbTJ6mof7tABrQP5EyZwWPLd1CmuYlERKSOqlGBqKioiD179hAcHEx4eDhBQUGsWrXKery4uJi1a9fSs2dPAKKionB2dq7QJi0tjZ07d1rbREdHY7FY2LRpk7XNxo0bsVgs1jZyfjOGtcfTxZGth3P4cPMRe5cjIiJSLewaiKZNm8batWs5ePAgGzdu5IYbbiAvL49x48ZhMpmYPHkyzz33HMuXL2fnzp2MHz8eDw8PxowZA4DZbOaOO+5g6tSprF69mu3bt3PLLbdYX8EBtG3bloEDBzJhwgQSEhJISEhgwoQJDBkyhNatW9vz8muFYLM7U2PK79OslXs5rrmJRESkDnKy5y9PTU3l5ptv5sSJEzRq1IgePXqQkJBAWFgYAA8//DCFhYXce++95OTk0L17d7777ju8vb2t53j55ZdxcnJi1KhRFBYWcs0117Bw4UIcHR2tbRYvXswDDzxgHY02bNgw5s6de2kvthYb17MZX/xyjF9ScvnXF7t4KzbK3iWJiIjYlMkwDHUMqYS8vDzMZjMWi6XedbAG2JOWx9B/r+dMmcG82CgGtA/6+w+JiIjYWWW/v2tUHyKpudoG+zDhquYAPPHFTvJOl9i5IhEREdtRIJJKm3RNS5o19OB4XhHPx+21dzkiIiI2o0Aklebm7Mhz10UC8EHCEbYcyrZzRSIiIrahQCRV0rOFPzdGNQHg0c92UHRGy3qIiEjtp0AkVfb44Lb4e7nwW0YBr//wm73LERERuWgKRFJlDTxceOq/y3q8sWY/e9Ly7FyRiIjIxVEgkgsyKCLIuqzHw5/+ypnSMnuXJCIicsEUiOSCmEwmnh4egY+bEzuOWvjP+oP2LklEROSCKRDJBQvwceMfQ9oBMGfVPg6eOGnnikRERC6MApFclBujmnBlS3+KzpTxyLJfKSvTxOciIlL7KBDJRTGZTDx3XSQeLo5sOpjN4k1H7F2SiIhIlSkQyUUL9fPg4QGtAZi1cg8p2afsXJGIiEjVKBCJTdwa3YzLm/lxsriURz/7Fa0ZLCIitYkCkdiEg4OJ52/ogJuzAz//lsWHm1LsXZKIiEilKRCJzTTz9+ShAW0AePbr3aTm6NWZiIjUDgpEYlPjezaja5gvJ4tLmf7ZDr06ExGRWkGBSGzK8b+vzlydHPgp+QQfbdarMxERqfkUiMTmmjfy4qH/jjp75us9enUmIiI1ngKRVIvbeoUTFeZLQdEZHv5UEzaKiEjNpkAk1cLRwcSLN3bEzdmB+P1ZfLDxsL1LEhEROS8FIqk24f6ePDqwfNTZzJV7OaS1zkREpIZSIJJqdWt0M6KbN6SwpJRpn/xCqV6diYhIDaRAJNXq9wkbvVyd2HI4h3fXH7R3SSIiImdRIJJqF+rnwT8GtwXghe+SSD6eb+eKREREKlIgkktidLdQ+rRuRPGZMqZ8/AslpWX2LklERMRKgUguCZPJxOyRHWjg4cyOoxb+vTrZ3iWJiIhYKRDJJRPo48YzIyIAeH3NfrYfybFzRSIiIuWqHIi2bdvGjh07rD9/8cUXjBgxgscee4zi4mKbFid1z5AOIQzvFEJpmcGUj3/hVPEZe5ckIiJS9UB01113sW/fPgAOHDjATTfdhIeHB5988gkPP/ywzQuUuuepYREE+bhx8MRJnlu5x97liIiIVD0Q7du3j06dOgHwySefcNVVV7FkyRIWLlzIsmXLbF2f1EFmD2devLEjAB8kHGFNUoadKxIRkfquyoHIMAzKyspHCH3//fdce+21AISGhnLixAnbVid11hUt/RnfsxkAD3/6Kzkn9bpVRETsp8qBqGvXrjzzzDMsWrSItWvXMnjwYAAOHjxIYGDgBRcyc+ZMTCYTkydPtu4bP348JpOpwtajR48KnysqKmLixIn4+/vj6enJsGHDSE1NrdAmJyeH2NhYzGYzZrOZ2NhYcnNzL7hWsY1HBrbhskaeZOQXMf2zHRiGZrEWERH7qHIgeuWVV9i2bRv3338/jz/+OC1atADg008/pWfPnhdUxObNm3n77bfp0KHDWccGDhxIWlqadVu5cmWF45MnT2b58uUsXbqU9evXU1BQwJAhQygtLbW2GTNmDImJicTFxREXF0diYiKxsbEXVKvYjruLI6/e1BlnRxNxu9L5ZEvq339IRESkGpgMG/21/PTp0zg6OuLs7FylzxUUFNClSxfeeOMNnnnmGTp16sQrr7wClD8hys3N5fPPPz/nZy0WC40aNWLRokWMHj0agGPHjhEaGsrKlSsZMGAAe/bsoV27diQkJNC9e3cAEhISiI6OZu/evbRu3fqc5y4qKqKoqMj6c15eHqGhoVgsFnx8fKp0jfLX3lyzn9lxe/FwcWTlA1fSzN/T3iWJiEgdkZeXh9ls/tvv7wuahyg3N5d33nmH6dOnk52dDcDu3bvJyKh659j77ruPwYMH069fv3MeX7NmDQEBAbRq1YoJEyZU+B1bt26lpKSEmJgY676QkBAiIiKIj48HYMOGDZjNZmsYAujRowdms9na5lxmzpxpfcVmNpsJDQ2t8rVJ5dx5VXO6h/txqriUyR8lahZrERG55KociH799VdatmzJ7NmzefHFF619cZYvX8706dOrdK6lS5eybds2Zs6cec7jgwYNYvHixfzwww+89NJLbN68mb59+1qf3KSnp+Pi4oKvr2+FzwUGBpKenm5tExAQcNa5AwICrG3OZfr06VgsFuuWkpJSpWuTynN0MDFndCe83ZxITMnl3z/8Zu+SRESknqlyIJoyZQq33XYbycnJuLm5WfcPGjSIdevWVfo8KSkpTJo0iQ8++KDCef5o9OjRDB48mIiICIYOHco333zDvn37+Prrr//y3IZhYDKZrD//8d/P1+bPXF1d8fHxqbBJ9WncwJ1nr4sEYO4PyWw9nG3nikREpD6pciDavHkzd91111n7Gzdu/JdPXP5s69atZGRkEBUVhZOTE05OTqxdu5bXXnsNJyenCp2ifxccHExYWBjJyeXrYAUFBVFcXExOTsUlIDIyMqwj3oKCgjh+/PhZ58rMzLyoUXFie8M6hnBd58aUGTBpaSJ5p0vsXZKIiNQTVQ5Ebm5u5OXlnbU/KSmJRo0aVfo811xzDTt27CAxMdG6de3albFjx5KYmIijo+NZn8nKyiIlJYXg4GAAoqKicHZ2ZtWqVdY2aWlp7Ny50zriLTo6GovFwqZNm6xtNm7ciMViueBRcVJ9nhzenlA/d1JzCvnH8p0aii8iIpdElQPR8OHDeeqppygpKf/bu8lk4siRIzz66KOMHDmy0ufx9vYmIiKiwubp6UnDhg2JiIigoKCAadOmsWHDBg4dOsSaNWsYOnQo/v7+XHfddQCYzWbuuOMOpk6dyurVq9m+fTu33HILkZGR1k7abdu2ZeDAgUyYMIGEhAQSEhKYMGECQ4YMOe8IM7EfHzdnXr2pM44OJlb8cozPth21d0kiIlIPVDkQvfjii2RmZhIQEEBhYSG9e/emRYsWeHt78+yzz9qsMEdHR3bs2MHw4cNp1aoV48aNo1WrVmzYsAFvb29ru5dffpkRI0YwatQoevXqhYeHB19++WWFJ0yLFy8mMjKSmJgYYmJi6NChA4sWLbJZrWJbXZr68mC/lgA88cVODp04aeeKRESkrrvgeYh++OEHtm3bRllZGV26dDnvsPm6orLzGIhtlJYZjJmfwMaD2XRoYubTu3vi4nRBs0SIiEg9Vtnv7yoFojNnzuDm5kZiYiIRERE2KbS2UCC69I7lFjLo1Z+wFJZwd+/LeHRQG3uXJCIitUy1TMzo5OREWFjYOUeAidhaSAN3Zo8sH4o/b91+fkrOtHNFIiJSV1X5HcQ//vGPCjNUi1SngRHBjOneFMOABz/6hcz8or//kIiISBVVuQ9R586d+e233ygpKSEsLAxPz4rrTm3bts2mBdYUemVmP6dLShk+92eSjudzZUt/3rvtchwczj+ppoiIyO8q+/3tVNUTjxgx4mLqEqkyN2dH5o7pzNC56/kp+QTz1h3gnj6X2bssERGpQ2y22n1dpydE9vfR5iM8smwHjg4mPr4rmqgw37//kIiI1GvVutq9iD2M6hrKsI4hlJYZPPDhdiyntLSHiIjYRpUDUWlpKS+++CKXX345QUFB+Pn5VdhEqovJZOLZ6yIIa+jB0dxCHl72i5b2EBERm6hyIHryySeZM2cOo0aNwmKxMGXKFK6//nocHByYMWNGNZQo8j/ebs7MvbkLzo4mvt11nIXxh+xdkoiI1AFVDkSLFy9m/vz5TJs2DScnJ26++WbeeecdnnjiCRISEqqjRpEKIpuYefzatgA8t3IPv6Tk2rcgERGp9aociNLT04mMLJ8sz8vLC4vFAsCQIUP4+uuvbVudyHmM69mMQRFBlJQa3Ldkm/oTiYjIRalyIGrSpAlpaWkAtGjRgu+++w6AzZs34+rqatvqRM7DZDIx+4YONPXzIDWnkIc+VX8iERG5cFUORNdddx2rV68GYNKkSfzzn/+kZcuW3Hrrrdx+++02L1DkfHzcnHl9TBdcHB34bvdx3v35kL1LEhGRWuqi5yFKSEggPj6eFi1aMGzYMFvVVeNoHqKa6/0Nh3jii104OZj4+O5oujTV/EQiIlKuWla7r88UiGouwzC4f8l2vt6RRojZja8euBI/Txd7lyUiIjVAtS3d8f777//l8VtvvbWqpxS5KCaTiVkjI9mdlsfBEyeZ/FEiC8d303pnIiJSaVV+QuTrW/F1RElJCadOncLFxQUPDw+ys7NtWmBNoSdENd/e9DxGvP4zp0vKeLBfKyb1a2nvkkRExM6qbemOnJycCltBQQFJSUlcccUVfPjhhxdVtMjFaBPkw7MjyqeEeGX1Pn5KzrRzRSIiUlvYZC2zli1bMmvWLCZNmmSL04lcsJFRTbj58lAMAyYtTeRYbqG9SxIRkVrAZou7Ojo6cuzYMVudTuSC/Wtoe9qH+JB9spj7lmyj+EyZvUsSEZEarsqdqlesWFHhZ8MwSEtLY+7cufTq1ctmhYlcKDdnR94cG8WQf//E9iO5PP3Vbp4eEWHvskREpAarcqdqB4eKD5VMJhONGjWib9++vPTSSwQHB9u0wJpCnaprnx/2Huf2hVsAeOnGjoyMamLnikRE5FKrtmH3ZWV6/SC1Q982gUy6piWvrk7mseU7aBPsTfsQs73LEhGRGshmfYhEaqJJ17SkT+tGFJ0p4+4PtpJ7qtjeJYmISA1U5SdEU6ZMqXTbOXPmVPX0Ijbl4GDildGdGDp3PSnZhUz+KJF3x2nSRhERqajKgWj79u1s27aNM2fO0Lp1awD27duHo6MjXbp0sbYzmfSFIzVDAw8X3hwbxcg341mTlMkr3+9jSkxre5clIiI1SJUD0dChQ/H29ua9996zzlqdk5PDbbfdxpVXXsnUqVNtXqTIxYpobOa56yKZ+skvvPbDb7RvbGZA+yB7lyUiIjVElUeZNW7cmO+++4727dtX2L9z505iYmLq7FxEGmVWN8xYsYuF8YfwdHHki/t70SLA294liYhINaq2pTvy8vI4fvz4WfszMjLIz8+v6ulELqnHB7ele7gfJ4tLufP9reSdLrF3SSIiUgNUORBdd9113HbbbXz66aekpqaSmprKp59+yh133MH1119fHTWK2IyzowOvj+1CiNmNAydO8uDSRMrKqvSQVERE6qAqB6K33nqLwYMHc8sttxAWFkZYWBhjx45l0KBBvPHGG9VRo4hN+Xu58lZsFC5ODqzem8Erq5PtXZKIiNhZlQORh4cHb7zxBllZWdYRZ9nZ2bzxxht4enpecCEzZ87EZDIxefJk6z7DMJgxYwYhISG4u7vTp08fdu3aVeFzRUVFTJw4EX9/fzw9PRk2bBipqakV2uTk5BAbG4vZbMZsNhMbG0tubu4F1yq1X4cmDZh5XSQAr61OJm5nmp0rEhERe7rgiRk9PT3p0KED4eHhrFq1ir17915wEZs3b+btt9+mQ4cOFfY///zzzJkzh7lz57J582aCgoLo379/hb5KkydPZvny5SxdupT169dTUFDAkCFDKC0ttbYZM2YMiYmJxMXFERcXR2JiIrGxsRdcr9QNI6OacFuvZgBM+fgX9qbn2bcgERGxH6OKbrzxRuPf//63YRiGcerUKaNly5aGs7Oz4eTkZHz66adVPZ2Rn59vtGzZ0li1apXRu3dvY9KkSYZhGEZZWZkRFBRkzJo1y9r29OnThtlsNt566y3DMAwjNzfXcHZ2NpYuXWptc/ToUcPBwcGIi4szDMMwdu/ebQBGQkKCtc2GDRsMwNi7d+956zp9+rRhsVisW0pKigEYFoulytcoNVfJmVJj7PwEI+yRr4xes1YbWQVF9i5JRERsyGKxVOr7u8pPiNatW8eVV14JwPLlyzEMg9zcXF577TWeeeaZKgey++67j8GDB9OvX78K+w8ePEh6ejoxMTHWfa6urvTu3Zv4+HgAtm7dSklJSYU2ISEhREREWNts2LABs9lM9+7drW169OiB2Wy2tjmXmTNnWl+xmc1mQkNDq3xtUvM5OTowd0xnwhp6kJpTyL2Lt1JSqvX6RETqmyoHIovFgp+fHwBxcXGMHDkSDw8PBg8eTHJy1TqnLl26lG3btjFz5syzjqWnpwMQGBhYYX9gYKD1WHp6Oi4uLtYJIs/XJiAg4KzzBwQEWNucy/Tp07FYLNYtJSWlStcmtUcDDxfm39oVTxdHEg5k88xXu+1dkoiIXGJVDkShoaFs2LCBkydPEhcXZ306k5OTg5ubW6XPk5KSwqRJk/jggw/+8nN/XgLEMIy/XRbkz23O1f7vzuPq6oqPj0+FTequVoHevHJTZ0wmeG/DYT7cdMTeJYmIyCVU5UA0efJkxo4dS5MmTQgJCaFPnz5A+au0yMjISp9n69atZGRkEBUVhZOTE05OTqxdu5bXXnsNJycn65OhPz/FycjIsB4LCgqiuLiYnJycv2xzrokkMzMzz3r6JPVb/3aBTO3fCoB/fr6TDfuz7FyRiIhcKlUORPfeey8JCQm8++67rF+/HgeH8lM0b968Sn2IrrnmGnbs2EFiYqJ169q1K2PHjiUxMZHmzZsTFBTEqlWrrJ8pLi5m7dq19OzZE4CoqCicnZ0rtElLS2Pnzp3WNtHR0VgsFjZt2mRts3HjRiwWi7WNyO/uu7oFwzqGcKbM4J7FWzmcddLeJYmIyCVQ5bXMqlOfPn3o1KkTr7zyCgCzZ89m5syZLFiwgJYtW/Lcc8+xZs0akpKS8PYuX4Pqnnvu4auvvmLhwoX4+fkxbdo0srKy2Lp1K46OjgAMGjSIY8eOMW/ePADuvPNOwsLC+PLLLytdm9Yyqz9Ol5Qyet4Gfkm10CLAi8/u7YmPm7O9yxIRkQtQbWuZXUoPP/wwkydP5t5776Vr164cPXqU7777zhqGAF5++WVGjBjBqFGj6NWrFx4eHnz55ZfWMASwePFiIiMjiYmJISYmhg4dOrBo0SJ7XJLUAm7Ojsy/tStBPm78llHAAx9up1TLe4iI1Gk16glRTaYnRPXPzqMWbngrntMlZdzeK5wnhrazd0kiIlJFdeIJkYg9RTQ2M2dUJwDe/fkgizcetm9BIiJSbaociI4cOcK5HioZhsGRIxqqLHXLtZHB1pFnT3yxi5+SM+1ckYiIVIcqB6Lw8HAyM8/+UsjOziY8PNwmRYnUJPf3bcH1nRtTWmZw7wfbSD6e//cfEhGRWqXKgeh8ExoWFBRUaWJGkdrCZDIxc2QklzfzI7/oDLct3MyJgiJ7lyUiIjbkVNmGU6ZMAcq/HP75z3/i4eFhPVZaWsrGjRvp1KmTzQsUqQlcnRx5KzaK6974mcNZp7jz/S0smdADN2fHv/+wiIjUeJUORNu3bwfKnxDt2LEDFxcX6zEXFxc6duzItGnTbF+hSA3h5+nCu+O7cd3rP7PtSC7TPvmF127qjIPDXy8lIyIiNV+Vh93fdtttvPrqq/Vu6LmG3cvv4vef4Nb/bCqfzbrPZTwysI29SxIRkfOotmH3CxYsqHDCvLw8Pv/8c/bu3XthlYrUMj0v82fWyA4AvLlmP0s2anSliEhtV+VANGrUKObOnQtAYWEhXbt2ZdSoUURGRrJs2TKbFyhSE90Q1YTJ/VoC8M8vdrImKcPOFYmIyMWociBat24dV155JQDLly/HMAxyc3N57bXXqrS4q0htN+mallzfpXw4/n2Lt7H7WJ69SxIRkQtU5UBksVjw8/MDIC4ujpEjR+Lh4cHgwYNJTk62eYEiNZXJZGLW9R2Ibt6Qk8Wl3LZwE8dyC+1dloiIXIAqB6LQ0FA2bNjAyZMniYuLIyYmBoCcnBzNQyT1jouTA2/FRtEywIvjeUWMX7AJS2GJvcsSEZEqqnIgmjx5MmPHjqVJkyaEhITQp08foPxVWmRkpK3rE6nxzO7OLLz9cgK8Xdl3vIA7399C0ZlSe5clIiJVcEGr3W/dupUjR47Qv39/vLy8APj6669p0KABvXr1snmRNYGG3cvf2X0sj1HzNlBQdIahHUN4dXQnzVEkImJnlf3+vqBAVB8pEEllrE8+wfgF5XMU3XlVcx67tq29SxIRqdcq+/1d6Zmq/yg1NZUVK1Zw5MgRiouLKxybM2fOhZxSpE64oqU/z9/QgSkf/8Lb6w4Q5OPG7Vdo0WMRkZquyoFo9erVDBs2jPDwcJKSkoiIiODQoUMYhkGXLl2qo0aRWuX6Lk1Is5zmhW+TePrr3TTydmVoxxB7lyUiIn+hyp2qp0+fztSpU9m5cydubm4sW7aMlJQUevfuzY033lgdNYrUOvf2uYxx0WEYBkz5OJH1ySfsXZKIiPyFKgeiPXv2MG7cOACcnJwoLCzEy8uLp556itmzZ9u8QJHayGQy8cTQ9gzuEExJqcFdi7aw86jF3mWJiMh5VDkQeXp6UlRUBEBISAj79++3HjtxQn8LFvmdo4OJOaM60vOy8okbxy/YxOGsk/YuS0REzqHKgahHjx78/PPPAAwePJipU6fy7LPPcvvtt9OjRw+bFyhSm7k6OTIvNop2wT6cKCgm9j+byMg/be+yRETkT6ociObMmUP37t0BmDFjBv379+ejjz4iLCyM//znPzYvUKS283ZzZuHt3Qj1c+dI9inGvbtZs1mLiNQwmoeokjQPkVysw1knGfnmBk4UFNGtmS/v394ddxdHe5clIlKnVfb7u8pPiAByc3N55513mD59OtnZ2QBs27aNo0ePXli1IvVAWENP3r/9crzdnNh8KIf7l2yjpLTM3mWJiAgXEIh+/fVXWrVqxezZs3nxxRfJzc0FYPny5UyfPt3W9YnUKe1CfHh3fDdcnRxYvTeDhz/9lbIyPaQVEbG3KgeiKVOmMH78eJKTkyusbj9o0CDWrVtn0+JE6qJuzfx485YuODqYWL79KE99tRu9uRYRsa8qB6LNmzdz1113nbW/cePGpKen26Qokbqub5tAXryxAwAL4w/x8vfJdq5IRKR+q3IgcnNzIy8v76z9SUlJNGrUyCZFidQH13VuwpPD2gPw2upk5q87YOeKRETqryoHouHDh/PUU09RUlI+bNhkMnHkyBEeffRRRo4cafMCReqycT2b8dCA1gA8u3IPH246YueKRETqpyoHohdffJHMzEwCAgIoLCykd+/etGjRAi8vL5599tnqqFGkTru3z2Xc3fsyAB5bvoMVvxyzc0UiIvVPlVe79/HxYf369fzwww9s27aNsrIyunTpQr9+/aqjPpE6z2Qy8cjA1hQUlfBBwhGmfJSIu7Mj/dsF2rs0EZF644LmIQLo27cv06ZN4+GHH6Zfv37s2bOH5s2bV+kcb775Jh06dMDHxwcfHx+io6P55ptvrMfHjx+PyWSqsP15eZCioiImTpyIv78/np6eDBs2jNTU1AptcnJyiI2NxWw2YzabiY2NtU4XIFITmEwmnhoWwXWdG3OmzOC+xdtYty/T3mWJiNQbFxyI/qy4uJjDhw9X6TNNmjRh1qxZbNmyhS1bttC3b1+GDx/Orl27rG0GDhxIWlqadVu5cmWFc0yePJnly5ezdOlS1q9fT0FBAUOGDKG0tNTaZsyYMSQmJhIXF0dcXByJiYnExsZe3AWL2JiDg4kXbujAoIggikvLuHPRFhIOZNm7LBGResFmS3f88ssvdOnSpUIQuRB+fn688MIL3HHHHYwfP57c3Fw+//zzc7a1WCw0atSIRYsWMXr0aACOHTtGaGgoK1euZMCAAezZs4d27dqRkJBgXYMtISGB6Oho9u7dS+vWrStVl5bukEul+EwZd3+wlR/2ZuDh4siiO7oTFeZr77JERGqlal26ozqUlpaydOlSTp48SXR0tHX/mjVrCAgIoFWrVkyYMIGMjAzrsa1bt1JSUkJMTIx1X0hICBEREcTHxwOwYcMGzGazNQwB9OjRA7PZbG1zLkVFReTl5VXYRC4FFycH3hjbhSta+HOquJTx725iR6rF3mWJiNRpdg9EO3bswMvLC1dXV+6++26WL19Ou3btgPLZrxcvXswPP/zASy+9xObNm+nbty9FRUUApKen4+Ligq9vxb89BwYGWieJTE9PJyAg4KzfGxAQ8JcTSc6cOdPa58hsNhMaGmqrSxb5W27Ojrx9axSXN/Mjv+gMse9uZPcxhXIRkepS6VFmvr6+mEym8x4/c+bMBRXQunVrEhMTyc3NZdmyZYwbN461a9fSrl0762swgIiICLp27UpYWBhff/01119//XnPaRhGhVrPVfef2/zZ9OnTmTJlivXnvLw8hSK5pDxcnHj3tm7c8s5GElNyGftOAh/e2YM2QXplKyJia5UORK+88kq1FODi4kKLFi0A6Nq1K5s3b+bVV19l3rx5Z7UNDg4mLCyM5OTyZQ6CgoIoLi4mJyenwlOijIwMevbsaW1z/Pjxs86VmZlJYOD5hzW7urri6up6UdcmcrG8XJ14/47LiX1nI7+kWhg7fyNL7+xBy0Bve5cmIlKnVDoQjRs3rjrrsDIMw/pK7M+ysrJISUkhODgYgKioKJydnVm1ahWjRo0CIC0tjZ07d/L8888DEB0djcViYdOmTVx++eUAbNy4EYvFYg1NIjWZj5sz79/enbH/SWDn0Txu/m8oahHgZe/SRETqDJuNMrsQjz32GIMGDSI0NJT8/HyWLl3KrFmziIuLIzo6mhkzZjBy5EiCg4M5dOgQjz32GEeOHGHPnj14e5f/Dfmee+7hq6++YuHChfj5+TFt2jSysrLYunUrjo6OQHlfpGPHjlmfOt15552EhYXx5ZdfVrpWjTITe8s5WcyYdzayJy2PAG9Xlt7Zg+aNFIpERP5KrRhldvz4cWJjY2ndujXXXHMNGzduJC4ujv79++Po6MiOHTsYPnw4rVq1Yty4cbRq1YoNGzZYwxDAyy+/zIgRIxg1ahS9evXCw8ODL7/80hqGABYvXkxkZCQxMTHExMTQoUMHFi1aZI9LFrlgvp4uLP6/7rQJ8iYjv4ib3k7gQGaBvcsSEakT7PqEqDbREyKpKU4UFDF2/kaSjucT4O3Kh3f24DI9KRIROada8YRIRKrO38uVJRMqPin6LUNPikRELoYCkUgt1NDL1fr6LDO/iJvnKxSJiFyMCwpE69atY8uWLRX2bdmyhXXr1tmkKBH5ew29XFkyoYc1FN30dgL7jufbuywRkVrpgvoQOTg40KZNG3bv3m3d17ZtW/bt23fRa5nVVOpDJDXVH0ef+Xm68MEd3WkXoj+jIiJQzX2IDh48yPfff19h3+rVqzlw4MCFnE5ELoKvpwsfTuhOZGMz2SeLuXl+gtY+ExGpogsKRGFhYYSEhFTYFxISQlhYmE2KEpGqaeDhwgf/153OTRtgKSxhzDsJbDuSY++yRERqjSoHopSUFFJTU60/b9q0icmTJ/P222/btDARqRqzuzOL7uhOt2a+5J8+Q+w7G9l0MNveZYmI1ApVDkRjxozhxx9/BMpXku/fvz+bNm3iscce46mnnrJ5gSJSeV6uTrx3++VEN2/IyeJSbn13Iz8lZ9q7LBGRGq/KgWjnzp3WNcE+/vhjIiIiiI+PZ8mSJSxcuNDW9YlIFXm4OLHgtm70ad2I0yVl3LFwC9/tSrd3WSIiNVqVA1FJSYl1Ffjvv/+eYcOGAdCmTRvS0tJsW52IXBA3Z0fmxUYxKCKI4tIy7lm8jS8Sj9q7LBGRGqvKgah9+/a89dZb/PTTT6xatYqBAwcCcOzYMRo2bGjzAkXkwrg6OfLvmztzfZfGlJYZTP4okaWbjti7LBGRGqnKgWj27NnMmzePPn36cPPNN9OxY0cAVqxYYX2VJiI1g5OjAy/e0JFbejTFMODRz3bwzk+aHkNE5M8uaGLG0tJS8vLy8PX1te47dOgQHh4eBAQE2LTAmkITM0ptZhgGs+L2Mm9teRi6/+oWTI1phclksnNlIiLVq9omZiwsLKSoqMgahg4fPswrr7xCUlJSnQ1DIrWdyWRi+qC2PDywNQBzf/yNJ77YRVlZlf8+JCJSJ1U5EA0fPpz3338fgNzcXLp3785LL73EiBEjePPNN21eoIjYzr19WvDMiAhMJliUcJgHP06kpLTM3mWJiNhdlQPRtm3buPLKKwH49NNPCQwM5PDhw7z//vu89tprNi9QRGzrlh5hvHpTZ5wcTHyReIw739/CqeIz9i5LRMSuqhyITp06hbe3NwDfffcd119/PQ4ODvTo0YPDhw/bvEARsb1hHUOYf2tX3Jwd+DEpk7HvbCT3VLG9yxIRsZsqB6IWLVrw+eefk5KSwrfffktMTAwAGRkZ6mwsUotc3SaAxf/XHbO7M9uP5HLjWxtIsxTauywREbuociB64oknmDZtGs2aNePyyy8nOjoaKH9a1LlzZ5sXKCLVJyrMj0/ujibIx43kjAJGvhHPbxn59i5LROSSu6Bh9+np6aSlpdGxY0ccHMoz1aZNm/Dx8aFNmzY2L7Im0LB7qcuO5hYS+5+NHMg8SQMPZ/4zrhtRYb5//0ERkRqust/fFxSIfpeamorJZKJx48YXeopaQ4FI6rrsk8XctnAzv6Tk4urkwNwxXejfLtDeZYmIXJRqm4eorKyMp556CrPZTFhYGE2bNqVBgwY8/fTTlJVp+K5IbeXn6cKHE7pzdetGFJ0p465FW1i8UQMlRKR+qHIgevzxx5k7dy6zZs1i+/btbNu2jeeee45///vf/POf/6yOGkXkEvFwcWL+rV25qVsoZQY8vnwnL32XxEU8SBYRqRWq/MosJCSEt956y7rK/e+++OIL7r33Xo4erZsrauuVmdQnhmHw6upkXvk+GYCRXZow8/pIXJyq/HcoERG7qrZXZtnZ2efsON2mTRuys7OrejoRqYFMJhOT+7Vi9shIHB1MLNuWym0LN5F3usTepYmIVIsqB6KOHTsyd+7cs/bPnTuXjh072qQoEakZRndryjvjuuLh4sjPv2Vxw5vxHM3VXEUiUvdU+ZXZ2rVrGTx4ME2bNiU6OhqTyUR8fDwpKSmsXLnSuqxHXaNXZlKf7Txq4faFm8nIL6KRtysLxncjorHZ3mWJiPytantl1rt3b/bt28d1111Hbm4u2dnZXH/99SQlJdXZMCRS30U0NvP5fb1oHehNZn4Ro+Zt4Pvdx+1dloiIzVzUPER/lJKSwr/+9S/effddW5yuxtETIhHIO13CvR9sY/1vJzCZ4B+D23F7r2aYTCZ7lyYick7V9oTofLKzs3nvvfdsdToRqYF83JxZcFs3br48FMOAp7/azT8+30lJqeYgE5HaTWNoRaRKnB0deO66SB6/ti0mEyzeeITbF27GUqgRaCJSe9k1EL355pt06NABHx8ffHx8iI6O5ptvvrEeNwyDGTNmEBISgru7O3369GHXrl0VzlFUVMTEiRPx9/fH09OTYcOGkZqaWqFNTk4OsbGxmM1mzGYzsbGx5ObmXopLFKmTTCYTE65qzrxbonB3duSn5BOMfDOew1kn7V2aiMgFsWsgatKkCbNmzWLLli1s2bKFvn37Mnz4cGvoef7555kzZw5z585l8+bNBAUF0b9/f/Lz/7ca9+TJk1m+fDlLly5l/fr1FBQUMGTIEEpLS61txowZQ2JiInFxccTFxZGYmEhsbOwlv16RuiamfRCf3B1NoI8rv2UUMPz1n4nff8LeZYmIVFmlO1Vff/31f3k8NzeXtWvXVggiF8LPz48XXniB22+/nZCQECZPnswjjzwClD8NCgwMZPbs2dx1111YLBYaNWrEokWLGD16NADHjh0jNDSUlStXMmDAAPbs2UO7du1ISEige/fuACQkJBAdHc3evXtp3bp1pepSp2qR8zued5o739/CL6kWnBxMPDm8PWO7h9m7LBER23eq/v110/m2sLAwbr311gsuuLS0lKVLl3Ly5Emio6M5ePAg6enpxMTEWNu4urrSu3dv4uPjAdi6dSslJSUV2oSEhBAREWFts2HDBsxmszUMAfTo0QOz2Wxtcy5FRUXk5eVV2ETk3AJ93PjormiGdQzhTJnB48t38q8vdnJGna1FpJZwqmzDBQsWVEsBO3bsIDo6mtOnT+Pl5cXy5ctp166dNawEBgZWaB8YGMjhw+UrcKenp+Pi4oKvr+9ZbdLT061tAgICzvq9AQEB1jbnMnPmTJ588smLujaR+sTN2ZFXb+pE6yBvXvg2ifc2HCY5o4DXx3TB19PF3uWJiPwlu48ya926NYmJiSQkJHDPPfcwbtw4du/ebT3+5/lNDMP42zlP/tzmXO3/7jzTp0/HYrFYt5SUlMpekki9ZTKZuO/qFrx1SxQeLo7E789i6Nz17EnTE1YRqdnsHohcXFxo0aIFXbt2ZebMmXTs2JFXX32VoKAggLOe4mRkZFifGgUFBVFcXExOTs5ftjl+/OwZdTMzM896+vRHrq6u1tFvv28iUjkDI4JYfm8vmvp5kJpTyPVvxPP1r2n2LktE5LzsHoj+zDAMioqKCA8PJygoiFWrVlmPFRcXs3btWnr27AlAVFQUzs7OFdqkpaWxc+dOa5vo6GgsFgubNm2yttm4cSMWi8XaRkRsr3WQNyvu78WVLf0pLCnlviXbeOHbvZSW2WRyfBERm6p0H6Lq8NhjjzFo0CBCQ0PJz89n6dKlrFmzhri4OEwmE5MnT+a5556jZcuWtGzZkueeew4PDw/GjBkDlHf0vuOOO5g6dSoNGzbEz8+PadOmERkZSb9+/QBo27YtAwcOZMKECcybNw+AO++8kyFDhlR6hJmIXJgGHi4sGN+N2XF7mf/TQV7/cT87j+bx6k2daOChfkUiUnPYNRAdP36c2NhY0tLSMJvNdOjQgbi4OPr37w/Aww8/TGFhIffeey85OTl0796d7777Dm9vb+s5Xn75ZZycnBg1ahSFhYVcc801LFy4EEdHR2ubxYsX88ADD1hHow0bNoy5c+de2osVqaecHB14fHA72oeYefSzX1m7L5Ohc9cz75autAvRq2gRqRlstrhrXad5iEQu3u5jedz1wRZSsgtxc3Zg1vUdGNG5sb3LEpE67JIv7ioi8nfahfjw5f1X0LtVI06XlDH5o0RmrNhF8RnNVyQi9qVAJCKXVAMPF94d342JfVsAsDD+EKPf3sCx3EI7VyYi9ZkCkYhcco4OJqbGtOY/47ri4+bE9iO5DPn3en5KzrR3aSJSTykQiYjdXNM2kK8fuJKIxj5knyzm1nc38er3yRqaLyKXnAKRiNhVqJ8Hn97dk5svb4phwMvf72Pcu5vIzC+yd2kiUo8oEImI3bk5OzLz+kjmjOqIu7Mj6387wbWv/cSG/Vn2Lk1E6gkFIhGpMa7v0oQV9/eiZYAXmflFjH0ngddW6xWaiFQ/BSIRqVFaBnrzxf29uDGqCWUGzFm1j1vf3UhG3ml7lyYidZgCkYjUOB4uTrxwY0devLH8FdrPv2Ux6NWf+DEpw96liUgdpUAkIjXWDVFN+HLiFbQJ8ibrZDG3LdjMM1/t1kSOImJzCkQiUqO1CPDi8/t6MS46DIB31h9k5JvxHMgssHNlIlKXKBCJSI3n5uzIk8MjeDs2igYezuw4amHwa+v5aPMRtByjiNiCApGI1Box7YP4ZtKVRDdvSGFJKY8s28E9H2wj52SxvUsTkVpOgUhEapVgszsf/F93Hh3UBmdHE3G70hn46jrWJ5+wd2kiUospEIlIrePoYOLu3pfx2T29aN7Ik+N5Rdzyn408+eUuTpeU2rs8EamFFIhEpNaKbGLmq4lXMLZ7UwAW/HyIIf9ez45Ui50rE5HaRoFIRGo1Dxcnnr0ukgW3daORtyu/ZRRw3Rs/89rqZM6Uani+iFSOApGI1AlXtw7gu8lXMTgymDNlBnNW7WPkm/EkH8+3d2kiUgsoEIlIneHr6cLcMZ15ZXQnfNyc+CXVwuB/r2fe2v1aD01E/pICkYjUKSaTiRGdG/Pdg725unUjis+UMfObvdz4Vjz7NZmjiJyHApGI1ElBZjfeHd+N52/ogLerE9uO5HLtqz8xb+1+9S0SkbMoEIlInWUymRjVNZS4B6/iypb+FP33adHIN+NJSlffIhH5HwUiEanzGjdw5/3bLy9/WvTfvkVD/v0Tr3y/TwvFigigQCQi9cTvT4u+n9Kbfm0DKSk1eOX7ZIb+ez3bjuTYuzwRsTMFIhGpVwJ93Jh/axSv3dyZhp4uJB3PZ+Sb8fzri50UFJ2xd3kiYicKRCJS75hMJoZ1DOH7Kb0Z2aUJhgHvbThM/zlrWbX7uL3LExE7UCASkXrL19OFl0Z15IM7utPUz4M0y2kmvL+FuxZt4Vhuob3LE5FLSIFIROq9K1r68+3kq7i792U4OZj4dtdx+s1Zyzs/HdAQfZF6QoFIRARwd3Hk0UFt+PqBK+nWzJdTxaU88/Uehs79ma2Hs+1dnohUMwUiEZE/aB3kzUd3RvP8yA408HBmT1oeI9/cwLRPfuFEQZG9yxORaqJAJCLyJw4OJkZ1C+WHqX0Y3TUUgE+3pnL1i2tY+PNBvUYTqYPsGohmzpxJt27d8Pb2JiAggBEjRpCUlFShzfjx4zGZTBW2Hj16VGhTVFTExIkT8ff3x9PTk2HDhpGamlqhTU5ODrGxsZjNZsxmM7GxseTm5lb3JYpILebn6cLsGzrw2b09iWjsQ/7pM8z4cjdD5/7MxgNZ9i5PRGzIroFo7dq13HfffSQkJLBq1SrOnDlDTEwMJ0+erNBu4MCBpKWlWbeVK1dWOD558mSWL1/O0qVLWb9+PQUFBQwZMoTS0lJrmzFjxpCYmEhcXBxxcXEkJiYSGxt7Sa5TRGq3Lk19+eK+K3hmRARm9/LXaKPfTuC+JdtIzTll7/JExAZMhmEY9i7id5mZmQQEBLB27VquuuoqoPwJUW5uLp9//vk5P2OxWGjUqBGLFi1i9OjRABw7dozQ0FBWrlzJgAED2LNnD+3atSMhIYHu3bsDkJCQQHR0NHv37qV169Z/W1teXh5msxmLxYKPj49tLlhEap3sk8W89F0SH246QpkBrk4O3N37Mu7ufRnuLo72Lk9E/qSy3981qg+RxWIBwM/Pr8L+NWvWEBAQQKtWrZgwYQIZGRnWY1u3bqWkpISYmBjrvpCQECIiIoiPjwdgw4YNmM1maxgC6NGjB2az2drmz4qKisjLy6uwiYj4ebrw7HWRfDXxSrqH+1F0poxXVyfT96U1LN+eSllZjfk7pohUQY0JRIZhMGXKFK644goiIiKs+wcNGsTixYv54YcfeOmll9i8eTN9+/alqKh8tEd6ejouLi74+vpWOF9gYCDp6enWNgEBAWf9zoCAAGubP5s5c6a1v5HZbCY0NNRWlyoidUC7EB+W3tmDN8Z2oXEDd9Isp3nwo18Y8cbPbDqoYfoitU2NCUT3338/v/76Kx9++GGF/aNHj2bw4MFEREQwdOhQvvnmG/bt28fXX3/9l+czDAOTyWT9+Y//fr42fzR9+nQsFot1S0lJuYCrEpG6zGQycW1kMKun9uaRgW3wcnXi11QLo+Zt4O5FWzl44uTfn0REaoQaEYgmTpzIihUr+PHHH2nSpMlftg0ODiYsLIzk5GQAgoKCKC4uJien4mrVGRkZBAYGWtscP372+kSZmZnWNn/m6uqKj49PhU1E5FzcnB25p89lrHmoD2O7N8XBBHG70uk/Zy1PfLFT8xeJ1AJ2DUSGYXD//ffz2Wef8cMPPxAeHv63n8nKyiIlJYXg4GAAoqKicHZ2ZtWqVdY2aWlp7Ny5k549ewIQHR2NxWJh06ZN1jYbN27EYrFY24iIXCx/L1eevS6SuMlX0bdNAGfKDN7fcJjez//Iq98nc7LojL1LFJHzsOsos3vvvZclS5bwxRdfVBjpZTabcXd3p6CggBkzZjBy5EiCg4M5dOgQjz32GEeOHGHPnj14e3sDcM899/DVV1+xcOFC/Pz8mDZtGllZWWzduhVHx/JRH4MGDeLYsWPMmzcPgDvvvJOwsDC+/PLLStWqUWYiUlUb9mcx65s9/JJaPmDE38uV+6++jJu7N8XVSSPSRC6Fyn5/2zUQna//zoIFCxg/fjyFhYWMGDGC7du3k5ubS3BwMFdffTVPP/10hU7Op0+f5qGHHmLJkiUUFhZyzTXX8MYbb1Rok52dzQMPPMCKFSsAGDZsGHPnzqVBgwaVqlWBSEQuhGEYfL0jjRe+TeJwVvmcRY0buPNg/1Zc17kxjg7n/u+giNhGrQhEtYkCkYhcjJLSMj7anMJrq5PJyC/vU9QiwIsH+7ViUEQQDgpGItVCgcjGFIhExBYKi0t5b8Mh3lyzH0thCQBtgrx5sH8rYtoFnvfJuYhcGAUiG1MgEhFbshSW8O76g7y7/iD5/+1sHdHYhwf7taJvmwAFIxEbUSCyMQUiEakOuaeKmf/TARb8fIhTxeXrL0Y09uGBvi3prydGIhdNgcjGFIhEpDplFRTx9k8HWLThsDUYtQ32YWLfFgxsrz5GIhdKgcjGFIhE5FLIPlnMf9Yf4L34wxT891VaiwAv7u59GcM7heDsWCPm0xWpNRSIbEyBSEQupdxTxbz78yEW/HyQ/NPlwahxA3fuvKo5o7uF4uaseYxEKkOByMYUiETEHvJPl7B44xHe+emgdQmQhp4ujOvZjNgeYfh6uti5QpGaTYHIxhSIRMSeTpeU8smWFOatO0BqTiEA7s6OjOrahP+7sjmhfh52rlCkZlIgsjEFIhGpCc6UlvH1jjTeXneAXcfyAHAwwaCIYG6/IpyoMF87VyhSsygQ2ZgCkYjUJIZh8PNvWcxbt5+fkk9Y93cKbcAdV4QzKCIIJ3XAFlEgsjUFIhGpqfak5fHu+oN8kXiM4tIyAELMboztEcbNlzfFT/2MpB5TILIxBSIRqeky84v4IOEwHyQcJutkMQAuTg4M6xjC+J7NiGhstnOFIpeeApGNKRCJSG1xuqSUr35N4734Q+w4arHu79K0Abf0COPayGAN25d6Q4HIxhSIRKS2MQyDbUdyeS/+ECt3pHGmrPw/974eztzYNZSx3ZsS1tDTzlWKVC8FIhtTIBKR2iwj/zQfbUrhw01HOGY5bd1/RQt/bro8lJh2Qbg4qRO21D0KRDamQCQidcGZ0jJ+TMpkUcJhfkrO5PdvAD9PF0Z2aczobk1pEeBl3yJFbEiByMYUiESkrknJPsXHW1L4eEsKx/OKrPujwnwZ1bUJgzuE4OXqZMcKRS6eApGNKRCJSF31+1OjpZuOsGZfJqX/7Wvk7uzItZHBjIxqTI/whjg4mOxcqUjVKRDZmAKRiNQHGXmn+Wz7UT7eksKBzJPW/Y0buDOicwjXd2nCZY30Sk1qDwUiG1MgEpH65PcRap9uTeGrX9PIP33GeqxjEzPDOzVmSMdgArzd7FilyN9TILIxBSIRqa9Ol5Syek8Gn21LrfBKzcEEvVr4M6xjCAMigvBxc7ZzpSJnUyCyMQUiEZHy2bC//vUYX/xyjO1Hcq37XRwd6N26EUM6BNOvbSCe6owtNYQCkY0pEImIVHQ46yQrEsvD0W8ZBdb9bs4O9G0TwKCIYPq2CVA4ErtSILIxBSIRkXMzDIOk4/l89UsaX/56jMNZp6zHXJ0c6NO6EddGBnN1mwC9VpNLToHIxhSIRET+nmEY7Dyax8qdaazckVYhHDk7muh5mT8D2gfRv10gjbxd7Vip1BcKRDamQCQiUjWGYbAnLZ+VO9JYuTOtwjB+kwm6NPWlf7tA+rUN1OzYUm0UiGxMgUhE5OL8lpHPt7uO8+2udH5NtVQ41tzfk37tAunbJoCoMF+cHbWumtiGApGNKRCJiNjOsdxCVu85zqo9GWzYf4KS0v99FXm7OXFVq0b0bR1An9aNaOilV2ty4RSIbEyBSESkeuSfLuGn5BOs2n2cNUkZ5JwqsR4zmaBDYzO9WwfQu1UjOoU2wFFLiEgVKBDZmAKRiEj1Ky0zSEzJ5ce9Gazem8GetLwKx83uzlzR0p+rWvpzZctGhDRwt1OlUlsoENmYApGIyKV3PO80a/dlsjYpk5+SM8n7wxIiAJc18uTKlo3o1cKf7s39NKxfzlLZ72+79lqbOXMm3bp1w9vbm4CAAEaMGEFSUlKFNoZhMGPGDEJCQnB3d6dPnz7s2rWrQpuioiImTpyIv78/np6eDBs2jNTU1AptcnJyiI2NxWw2YzabiY2NJTc3t7ovUURELkKgjxujuoby+tgubPtnfz69O5pJ17SkS9MGOJhgf+ZJFsYfYsL7W+j81CpGvP4zL3y7l/jfTnC6pNTe5UstYtcnRAMHDuSmm26iW7dunDlzhscff5wdO3awe/duPD09AZg9ezbPPvssCxcupFWrVjzzzDOsW7eOpKQkvL29Abjnnnv48ssvWbhwIQ0bNmTq1KlkZ2ezdetWHB0dARg0aBCpqam8/fbbANx55500a9aML7/8slK16gmRiEjNYiksYcP+E/yUfIL4/VkcPHGywnEXRwc6N21A9GUN6dG8IZ1CG+Dm7GinasVeauUrs8zMTAICAli7di1XXXUVhmEQEhLC5MmTeeSRR4Dyp0GBgYHMnj2bu+66C4vFQqNGjVi0aBGjR48G4NixY4SGhrJy5UoGDBjAnj17aNeuHQkJCXTv3h2AhIQEoqOj2bt3L61bt/7b2hSIRERqtqO5hfz82wnifysPSBn5RRWOuzg50Cm0Ad3D/bg83I8uTX21rEg9UNnv7xr1J8FiKZ+Xws/PD4CDBw+Snp5OTEyMtY2rqyu9e/cmPj6eu+66i61bt1JSUlKhTUhICBEREcTHxzNgwAA2bNiA2Wy2hiGAHj16YDabiY+PP2cgKioqoqjof/9nysvLO6uNiIjUHI0buDOqayijuoZiGAYHT5xkw4EsNuzPIuFANicKith0MJtNB7MBcHQw0T7Eh65hfnRr5ktUM18CvN3sfBViLzUmEBmGwZQpU7jiiiuIiIgAID09HYDAwMAKbQMDAzl8+LC1jYuLC76+vme1+f3z6enpBAQEnPU7AwICrG3+bObMmTz55JMXd1EiImIXJpOJ5o28aN7Ii7Hdw6wB6fdAtPFgNkdzC/k11cKvqRbe/fkgAGENPYhq6kuXMF+iwnxpFeitYf71RI0JRPfffz+//vor69evP+uYyVTxD6NhGGft+7M/tzlX+786z/Tp05kyZYr157y8PEJDQ//yd4qISM30x4B00+VNgfJXbFsOZbPlUA6bD2WTdDyfw1mnOJx1is+2HwXA08WRjqEN6BTagM5NfekU2kBrsNVRNSIQTZw4kRUrVrBu3TqaNGli3R8UFASUP+EJDg627s/IyLA+NQoKCqK4uJicnJwKT4kyMjLo2bOntc3x48fP+r2ZmZlnPX36naurK66u+kMvIlJXNW7gTuNOjRneqTFQ3kk7MSWXrYdz2HY4h+1HcjhZXEr8/izi92dV+FzHUDMdmzSgQ5MGRDYx46W+SLWeXf8XNAyDiRMnsnz5ctasWUN4eHiF4+Hh4QQFBbFq1So6d+4MQHFxMWvXrmX27NkAREVF4ezszKpVqxg1ahQAaWlp7Ny5k+effx6A6OhoLBYLmzZt4vLLLwdg48aNWCwWa2gSEZH6zezuTO9WjejdqhFQPklkckY+24/ksv1IDokpuSRnFHA0t5CjuYWs3FHe5cJkKl+LLbKxmcgmDYhsbKZ9iI86bNcydh1ldu+997JkyRK++OKLCh2bzWYz7u7ls4/Onj2bmTNnsmDBAlq2bMlzzz3HmjVrzhp2/9VXX7Fw4UL8/PyYNm0aWVlZZw27P3bsGPPmzQPKh92HhYVp2L2IiFRa/ukSdhy18EuKhV9Tc/klJZdjltNntTOZILyhJ+3/G44iQsy0DfbWumx2UCuG3Z+v/86CBQsYP348UP4U6cknn2TevHnk5OTQvXt3Xn/9dWvHa4DTp0/z0EMPsWTJEgoLC7nmmmt44403KvT5yc7O5oEHHmDFihUADBs2jLlz59KgQYNK1apAJCIi55KZX8TOo+Wds3cctbDjaC7H84rO2TbQx5W2wT60C/ahbbAPbYK8Cff3xMnRrvMk12m1IhDVJgpEIiJSWScKith1LI+dRy3sPpbHrmMWDmWdOmdbFycHWgZ40TrImzZB3rQK9KZ1kDdBPm5/O4BI/p4CkY0pEImIyMUoKDpDUnoeu9Py2X0sj73peSSl53Oq+NxLjHi7OdEq0JuWAV60tP7TS0GpihSIbEyBSEREbK2szCAl5xR70/PZm5bPvuP5JB3P5+CJk5SWnfvr2dPFkcsCvGjRyIvLAry4rJEnzRt5EdbQA1cnLU3yZwpENqZAJCIil0rRmVIOZJ4kOaOA347nk5xRQHJGAYdOnOTMeYKSgwka+7rT3N+LcH/PCltIA/d6O8GkApGNKRCJiIi9FZ8p40j2SX7LKGB/Zvk/D2QWcCDzJPlFZ877ORdHB5r4udOsoSdhDT1o1tCTpg09aOrnQRNf9zr9ZKlWrmUmIiIi5+fi5ECLAG9aBHhX2G8YBpkFRRzIPMmBzJMcyjrJwRPl25GsUxSXllmP/ZnJBME+boT6edDE14NQP3dCfT0I9Sv/9wBvt3rxdElPiCpJT4hERKQ2Ki0zOJZbyJHsUxzKKg9IB0+c5Ej2KY5knzpvp+7fOTuaCDa708TXvXx2b193Qhq406RB+T+DG7jV6CdMemVmYwpEIiJS1xiGQdbJ4vJwlHWKlOxTpOScIiW7kJScU6RZTp+3c/cf+Xu5EGx2J6SBG8Fmd4LNbgSZ//fvAT6udgtNemUmIiIif8lkMuHv5Yq/lytdmvqedfxMaRnH84tIzT7F0dxCUnMKOfbfpUt+/+fpkjJOFBRzoqCYHUct5/1dfp4uBPq4EeTjSqCPG4E+5UEp0Pu///Rxw9/L1W6v5xSIRERE5JycHB3KX5M1cD/nccMwyDlVwrHcQtIsp0mzFHIs9zTplvKf0/NOk245TdGZMrJPFpN9spg9aef/fW/d0oWBEcHnb1CNFIhERETkgphMJvw8XfDzdCGisfmcbQzDIPdUCel5pzn+3y3dUsTx/NNk5BWRkV++LzO/iAAft0t8Bf+jQCQiIiLVxmQy4evpgq+nC22Dz9+HpzJ9laqTApGIiIjYnb2H9mt5XREREan3FIhERESk3lMgEhERkXpPgUhERETqPQUiERERqfcUiERERKTeUyASERGRek+BSEREROo9BSIRERGp9xSIREREpN5TIBIREZF6T4FIRERE6j0FIhEREan3tNp9JRmGAUBeXp6dKxEREZHK+v17+/fv8fNRIKqk/Px8AEJDQ+1ciYiIiFRVfn4+ZrP5vMdNxt9FJgGgrKyMY8eO4e3tjclkuuDz5OXlERoaSkpKCj4+PjasUP5M9/rS0b2+dHSvLx3d60unOu+1YRjk5+cTEhKCg8P5ewrpCVElOTg40KRJE5udz8fHR/8Hu0R0ry8d3etLR/f60tG9vnSq617/1ZOh36lTtYiIiNR7CkQiIiJS7ykQXWKurq7861//wtXV1d6l1Hm615eO7vWlo3t96eheXzo14V6rU7WIiIjUe3pCJCIiIvWeApGIiIjUewpEIiIiUu8pEImIiEi9p0B0Cb3xxhuEh4fj5uZGVFQUP/30k71LqvVmzpxJt27d8Pb2JiAggBEjRpCUlFShjWEYzJgxg5CQENzd3enTpw+7du2yU8V1x8yZMzGZTEyePNm6T/fado4ePcott9xCw4YN8fDwoFOnTmzdutV6XPfaNs6cOcM//vEPwsPDcXd3p3nz5jz11FOUlZVZ2+heX5h169YxdOhQQkJCMJlMfP755xWOV+a+FhUVMXHiRPz9/fH09GTYsGGkpqZWT8GGXBJLly41nJ2djfnz5xu7d+82Jk2aZHh6ehqHDx+2d2m12oABA4wFCxYYO3fuNBITE43BgwcbTZs2NQoKCqxtZs2aZXh7exvLli0zduzYYYwePdoIDg428vLy7Fh57bZp0yajWbNmRocOHYxJkyZZ9+te20Z2drYRFhZmjB8/3ti4caNx8OBB4/vvvzd+++03axvda9t45plnjIYNGxpfffWVcfDgQeOTTz4xvLy8jFdeecXaRvf6wqxcudJ4/PHHjWXLlhmAsXz58grHK3Nf7777bqNx48bGqlWrjG3bthlXX3210bFjR+PMmTM2r1eB6BK5/PLLjbvvvrvCvjZt2hiPPvqonSqqmzIyMgzAWLt2rWEYhlFWVmYEBQUZs2bNsrY5ffq0YTabjbfeesteZdZq+fn5RsuWLY1Vq1YZvXv3tgYi3WvbeeSRR4wrrrjivMd1r21n8ODBxu23315h3/XXX2/ccssthmHoXtvKnwNRZe5rbm6u4ezsbCxdutTa5ujRo4aDg4MRFxdn8xr1yuwSKC4uZuvWrcTExFTYHxMTQ3x8vJ2qqpssFgsAfn5+ABw8eJD09PQK997V1ZXevXvr3l+g++67j8GDB9OvX78K+3WvbWfFihV07dqVG2+8kYCAADp37sz8+fOtx3WvbeeKK65g9erV7Nu3D4BffvmF9evXc+211wK619WlMvd169atlJSUVGgTEhJCREREtdx7Le56CZw4cYLS0lICAwMr7A8MDCQ9Pd1OVdU9hmEwZcoUrrjiCiIiIgCs9/dc9/7w4cOXvMbabunSpWzbto3NmzefdUz32nYOHDjAm2++yZQpU3jsscfYtGkTDzzwAK6urtx666261zb0yCOPYLFYaNOmDY6OjpSWlvLss89y8803A/pzXV0qc1/T09NxcXHB19f3rDbV8d2pQHQJmUymCj8bhnHWPrlw999/P7/++ivr168/65ju/cVLSUlh0qRJfPfdd7i5uZ23ne71xSsrK6Nr164899xzAHTu3Jldu3bx5ptvcuutt1rb6V5fvI8++ogPPviAJUuW0L59exITE5k8eTIhISGMGzfO2k73unpcyH2trnuvV2aXgL+/P46Ojmcl2oyMjLPSsVyYiRMnsmLFCn788UeaNGli3R8UFASge28DW7duJSMjg6ioKJycnHBycmLt2rW89tprODk5We+n7vXFCw4Opl27dhX2tW3bliNHjgD6c21LDz30EI8++ig33XQTkZGRxMbG8uCDDzJz5kxA97q6VOa+BgUFUVxcTE5Oznnb2JIC0SXg4uJCVFQUq1atqrB/1apV9OzZ005V1Q2GYXD//ffz2Wef8cMPPxAeHl7heHh4OEFBQRXufXFxMWvXrtW9r6JrrrmGHTt2kJiYaN26du3K2LFjSUxMpHnz5rrXNtKrV6+zpo/Yt28fYWFhgP5c29KpU6dwcKj4Vejo6Ggddq97XT0qc1+joqJwdnau0CYtLY2dO3dWz723eTdtOaffh93/5z//MXbv3m1MnjzZ8PT0NA4dOmTv0mq1e+65xzCbzcaaNWuMtLQ063bq1Clrm1mzZhlms9n47LPPjB07dhg333yzhszayB9HmRmG7rWtbNq0yXBycjKeffZZIzk52Vi8eLHh4eFhfPDBB9Y2ute2MW7cOKNx48bWYfefffaZ4e/vbzz88MPWNrrXFyY/P9/Yvn27sX37dgMw5syZY2zfvt063Uxl7uvdd99tNGnSxPj++++Nbdu2GX379tWw+7rg9ddfN8LCwgwXFxejS5cu1qHhcuGAc24LFiywtikrKzP+9a9/GUFBQYarq6tx1VVXGTt27LBf0XXInwOR7rXtfPnll0ZERITh6upqtGnTxnj77bcrHNe9to28vDxj0qRJRtOmTQ03NzejefPmxuOPP24UFRVZ2+heX5gff/zxnP99HjdunGEYlbuvhYWFxv3332/4+fkZ7u7uxpAhQ4wjR45US70mwzAM2z93EhEREak91IdIRERE6j0FIhEREan3FIhERESk3lMgEhERkXpPgUhERETqPQUiERERqfcUiERERKTeUyASERGRek+BSERqtGbNmvHKK69U++8xmUx8/vnn1f57qmLNmjWYTCZyc3PtXYpInaeZqkWE8ePHk5ubW+MCAUBmZiaenp54eHhU6+9JT0/H19cXV1dXDh06RHh4ONu3b6dTp07V+nt/16dPHzp16lQh/BUXF5OdnU1gYCAmk+mS1CFSXznZuwARqZ9KSkpwdnb+23aNGjW6BNVAUFBQtZy3std5Li4uLtVWl4hUpFdmIvK3du/ezbXXXouXlxeBgYHExsZy4sQJ6/G4uDiuuOIKGjRoQMOGDRkyZAj79++3Hj906BAmk4mPP/6YPn364ObmxgcffMD48eMZMWIEL774IsHBwTRs2JD77ruPkpIS62f//MrMZDLxzjvvcN111+Hh4UHLli1ZsWJFhXpXrFhBy5YtcXd35+qrr+a9997721dPf3xlFh4eDkDnzp0xmUz06dPH2m7BggW0bdsWNzc32rRpwxtvvPG315mVlcXNN99MkyZN8PDwIDIykg8//ND6ufHjx7N27VpeffVVTCYTJpOJQ4cOnfOV2bJly2jfvj2urq40a9aMl156qcJ1NGvWjOeee47bb78db29vmjZtyttvv209XlxczP33309wcDBubm40a9aMmTNnnve+iNQb1bJkrIjUKuPGjTOGDx9+zmPHjh0z/P39jenTpxt79uwxtm3bZvTv39+4+uqrrW0+/fRTY9myZca+ffuM7du3G0OHDjUiIyON0tJSwzAM4+DBgwZgNGvWzFi2bJlx4MAB4+jRo8a4ceMMHx8f4+677zb27NljfPnll4aHh0eFld3DwsKMl19+2fozYDRp0sRYsmSJkZycbDzwwAOGl5eXkZWVZf1dzs7OxrRp04y9e/caH374odG4cWMDMHJycs57DwBj+fLlhmEYxqZNmwzA+P777420tDTrud9++20jODjYeg3Lli0z/Pz8jIULF/7ldaamphovvPCCsX37dmP//v3Ga6+9Zjg6OhoJCQmGYRhGbm6uER0dbUyYMMFIS0sz0tLSjDNnzlhXC/+97i1bthgODg7GU089ZSQlJRkLFiww3N3djQULFlS4X35+fsbrr79uJCcnGzNnzjQcHByMPXv2GIZhGC+88IIRGhpqrFu3zjh06JDx008/GUuWLPnrPyAi9YACkYj8ZSD65z//acTExFTYl5KSYgBGUlLSOT+TkZFhAMaOHTsMw/hfUHjllVfO+r1hYWHGmTNnrPtuvPFGY/To0dafzxWI/vGPf1h/LigoMEwmk/HNN98YhmEYjzzyiBEREVHh9zz++ONVCkS/17t9+/YKbUJDQ88KD08//bQRHR39l9d5Ltdee60xdepU68+9e/c2Jk2aVKHNnwPRmDFjjP79+1do89BDDxnt2rWz/hwWFmbccsst1p/LysqMgIAA48033zQMwzAmTpxo9O3b1ygrK/vbGkXqE70yE5G/tHXrVn788Ue8vLysW5s2bQCsr8X279/PmDFjaN68OT4+PtZXTkeOHKlwrq5du551/vbt2+Po6Gj9OTg4mIyMjL+sqUOHDtZ/9/T0xNvb2/qZpKQkunXrVqH95ZdfXtnLPa/MzExSUlK44447KtyLZ555psLrQTj7OktLS3n22Wfp0KEDDRs2xMvLi+++++6s+/N39uzZQ69evSrs69WrF8nJyZSWllr3/fH+mEwmgoKCrPdn/PjxJCYm0rp1ax544AG+++67KtUgUlepU7WI/KWysjKGDh3K7NmzzzoWHBwMwNChQwkNDWX+/PmEhIRQVlZGREQExcXFFdp7enqedY4/dzg2mUyUlZX9ZU1/9RnDMM4akWXYYDDt7+efP38+3bt3r3Dsj4EOzr7Ol156iZdffplXXnmFyMhIPD09mTx58ln35+9U9tr+6v506dKFgwcP8s033/D9998zatQo+vXrx6efflqlWkTqGgUiEflLXbp0YdmyZTRr1gwnp7P/k5GVlcWePXuYN28eV155JQDr16+/1GVatWnThpUrV1bYt2XLliqdw8XFBaDCU5fAwEAaN27MgQMHGDt2bJXO99NPPzF8+HBuueUWoDxcJScn07Zt2wq/84+/71zatWt31r2Nj4+nVatWZ4Wyv+Lj48Po0aMZPXo0N9xwAwMHDiQ7Oxs/P78qXJVI3aJAJCIAWCwWEhMTK+zz8/PjvvvuY/78+dx888089NBD+Pv789tvv7F06VLmz5+Pr68vDRs25O233yY4OJgjR47w6KOP2ucigLvuuos5c+bwyCOPcMcdd5CYmMjChQsBKj2XT0BAAO7u7sTFxdGkSRPc3Nwwm83MmDGDBx54AB8fHwYNGkRRURFbtmwhJyeHKVOmnPd8LVq0YNmyZcTHx+Pr68ucOXNIT0+vEIiaNWvGxo0bOXToEF5eXucMJ1OnTqVbt248/fTTjB49mg0bNjB37twKI93+zssvv0xwcDCdOnXCwcGBTz75hKCgIBo0aFDpc4jURepDJCJA+azInTt3rrA98cQThISE8PPPP1NaWsqAAQOIiIhg0qRJmM1mHBwccHBwYOnSpWzdupWIiAgefPBBXnjhBbtdR3h4OJ9++imfffYZHTp04M033+Txxx8HwNXVtVLncHJy4rXXXmPevHmEhIQwfPhwAP7v//6Pd955h4ULFxIZGUnv3r1ZuHChtc/U+fzzn/+kS5cuDBgwgD59+hAUFMSIESMqtJk2bRqOjo60a9eORo0anbN/UZcuXfj4449ZunQpERERPPHEEzz11FOMHz++UtcF4OXlxezZs+natSvdunXj0KFDrFy5EgcHfR1I/aaZqkWkznv22Wd56623SElJsXcpIlJD6ZWZiNQ5b7zxBt26daNhw4b8/PPPvPDCC9x///32LktEajAFIhGpc5KTk3nmmWfIzs6madOmTJ06lenTp9u7LBGpwfTKTEREROo99aITERGRek+BSEREROo9BSIRERGp9xSIREREpN5TIBIREZF6T4FIRERE6j0FIhEREan3FIhERESk3vt/Dhw69OgpvawAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "nqubits = 5\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "\n",
+    "step = 1e-2\n",
+    "iterations = 100\n",
+    "d, loss, grad, diags = gradient_ascent(dbi, d,step, iterations)\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(range(iterations+1), loss)\n",
+    "plt.xlabel('Learning iterations')\n",
+    "plt.ylabel('Loss: Least squares')\n",
+    "\n",
+    "plt.figure()\n",
+    "for i in range(2**nqubits):\n",
+    "    plt.plot(diags[i,:], label='State ' + str(i))\n",
+    "plt.xlabel('Learning iterations')\n",
+    "plt.ylabel('Diagonal elements')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$||\\\\sigma(H_k)||$')"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "nqubits = 5\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=3.0)\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "d_fixed = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "d_trained = deepcopy(d_fixed)\n",
+    "dbi_trained = deepcopy(dbi)\n",
+    "flows = 10\n",
+    "iterations = 30\n",
+    "off_diagonal_norm = np.empty((2,flows+1))\n",
+    "off_diagonal_norm[0,0] = dbi_trained.off_diagonal_norm\n",
+    "off_diagonal_norm[1,0] = dbi.off_diagonal_norm\n",
+    "\n",
+    "for i in range(flows):\n",
+    "    d_trained, loss, grad, diags = gradient_ascent(dbi_trained, d_trained,step, iterations)\n",
+    "    s = dbi_trained.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d_trained, n=3)\n",
+    "    dbi_trained(s,d=d_trained)\n",
+    "    off_diagonal_norm[0,i+1] = dbi_trained.off_diagonal_norm\n",
+    "    s = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d_fixed, n=3)\n",
+    "    dbi(s,d=d_fixed)\n",
+    "    off_diagonal_norm[1,i+1] = dbi.off_diagonal_norm\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(off_diagonal_norm[0,:], label='Trained')\n",
+    "plt.plot(off_diagonal_norm[1,:], label='Untrained')\n",
+    "plt.legend()\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "c4f92193806e2908606a5f23edd55a5282f2f433b73b1c504507f9256ed9f0b4"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb
new file mode 100644
index 0000000000..00c2807a93
--- /dev/null
+++ b/examples/dbi/dbi_group_commutators_evolution_oracles_and_gci_transpiling.ipynb
@@ -0,0 +1,951 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2dae9ffe",
+   "metadata": {},
+   "source": [
+    "## This compares to DoubleBracketIteration whenever possible"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b161521d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import inspect\n",
+    "import sys\n",
+    "sys.path.append(\"../../tests\")\n",
+    "from test_models_dbi import *\n",
+    "def print_function_source_code( func ):\n",
+    "    out = inspect.getsourcelines(func)  \n",
+    "    from functools import reduce\n",
+    "    print(reduce(str.__add__, out[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "950eef89",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.7|INFO|2024-04-29 17:10:31]: Using numpy backend on /CPU:0\n"
+     ]
+    }
+   ],
+   "source": [
+    "import qibo\n",
+    "backend = qibo.backends.construct_backend(\"numpy\")\n",
+    "qibo.set_backend(\"numpy\")\n",
+    "nqubits = 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9bb4a0a0",
+   "metadata": {},
+   "source": [
+    "# Test frame shifted oracles\n",
+    "\n",
+    "In a group commutator iteration (GCI) we have\n",
+    "$$J_{k+1}= U_k^\\dagger J_k U_k$$\n",
+    "which is obtained by a product formula for $U_k$.\n",
+    "We will use two examples\n",
+    "$$A_k = e^{is D} e^{is J_k} e^{-isD}$$\n",
+    "and\n",
+    "$$B_k = e^{-is J_k}e^{is D} e^{is J_k} e^{-isD}$$\n",
+    "In both cases $D$ is fixed, which amounts to a product formula approximation of the BHMM scheme.\n",
+    "\n",
+    "For $B_k$ we have the group commutator bound, see below. For $A_k$ we will have that\n",
+    "$$J_{k+1}= A_k^\\dagger J_k A_k= B_k^\\dagger J_k B_k$$\n",
+    "because of a reduction by means of a commutator vanishing (the ordering was chosen on purpose).\n",
+    "\n",
+    "This means that $A_k$ and $B_k$ schemes should give the same `GroupCommutatorIterationWithEvolutionOracles.h`. Additionally that should be also `DoubleBracketIteration.h` as long as the ordering is correct.\n",
+    "\n",
+    "If we operate in the `EvolutionOracleType.hamiltonian_simulation` there will be deviations based on the `EvolutionOracle.eps_trottersuzuki` threshold.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d65bc873",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.7|WARNING|2024-04-29 17:10:31]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n",
+      "[Qibo 0.2.7|WARNING|2024-04-29 17:10:31]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "def test_gci_frame_shifted_oracles(backend,nqubits,mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation):\n",
+      "    \"\"\"In a group commutator iteration (GCI) we have\n",
+      "$$J_{k+1}= U_k^\\dagger J_k U_k$$\n",
+      "which is obtained by a product formula for $U_k$.\n",
+      "We will use two examples\n",
+      "$$A_k = e^{is D} e^{is J_k} e^{-isD}$$\n",
+      "\n",
+      "This means that $A_k$ and $B_k$ schemes should give the same `Groupand\n",
+      "$$B_k = e^{-is J_k}e^{is D} e^{is J_k} e^{-isD}$$\n",
+      "In both cases $D$ is fixed, which amounts to a product formula approximation of the BHMM scheme.\n",
+      "\n",
+      "For $B_k$ we have the group commutator bound, see below. For $A_k$ we will have that\n",
+      "$$J_{k+1}= A_k^\\dagger J_k A_k= B_k^\\dagger J_k B_k$$\n",
+      "because of a reduction by means of a commutator vanishing (the ordering was chosen on purpose).\n",
+      "CommutatorIterationWithEvolutionOracles.h`. Additionally that should be also `DoubleBracketIteration.h` as long as the ordering is correct.\n",
+      "\n",
+      "If we operate in the `EvolutionOracleType.hamiltonian_simulation` there will be deviations based on the `EvolutionOracle.eps_trottersuzuki` threshold.\"\"\"\n",
+      "    \n",
+      "    h_x = SymbolicHamiltonian(\n",
+      "            symbols.X(0)\n",
+      "        + symbols.Z(0) * symbols.X(1)\n",
+      "        + symbols.Y(2)\n",
+      "        + symbols.Y(1) * symbols.Y(2),\n",
+      "        nqubits=3,\n",
+      "    )\n",
+      "    d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n",
+      "    h_input = h_x + d_0\n",
+      "\n",
+      "    dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n",
+      "\n",
+      "    evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle)   \n",
+      "    gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n",
+      "\n",
+      "    evolution_oracle_diagonal_target =  EvolutionOracle(d_0, \"D0\",\n",
+      "               mode_evolution_oracle)\n",
+      "\n",
+      "    from numpy.linalg import norm\n",
+      "    \n",
+      "    if mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation:\n",
+      "        threshold = evolution_oracle.eps_trottersuzuki * 10\n",
+      "    else:\n",
+      "        threshold = 1e-12\n",
+      "    \n",
+      "    r = .01\n",
+      "    for _ in range(3):\n",
+      "        a = dbi.h.exp(r)\n",
+      "        b = gci.iterated_hamiltonian_evolution_oracle.eval_unitary(r)\n",
+      "\n",
+      "        assert norm(a-b) < threshold\n",
+      "        a = dbi.eval_dbr_unitary(r,d = d_0.dense.matrix,mode=DoubleBracketGeneratorType.group_commutator)\n",
+      "        b = gci.eval_gcr_unitary(r, evolution_oracle_diagonal_target)\n",
+      "\n",
+      "        assert norm(a-b) < threshold\n",
+      "        dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n",
+      "        gci(r, diagonal_association= evolution_oracle_diagonal_target )\n",
+      "        \n",
+      "        k_r = dbi.h.matrix\n",
+      "        j_r = gci.h.matrix\n",
+      "\n",
+      "        assert norm(a-b) < threshold\n",
+      "        \n",
+      "        assert norm(norm(dbi.sigma(k_r))-norm(dbi.sigma(j_r))) < threshold\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print_function_source_code(test_gci_frame_shifted_oracles) \n",
+    "\n",
+    "test_gci_frame_shifted_oracles(backend,nqubits)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "47301c6c",
+   "metadata": {},
+   "source": [
+    "The regular implementation in `DoubleBracketIteration` should be viewed as using classical dynamic programming: memoization of the updated Hamiltonian is used explicitly. Instead, using `FrameShiftedEvolutionOracle` we can store a sequence of recursive rotations such that eventually the iteration gives the same result.\n",
+    "    This function tests numerical agreement using the numpy backend."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b4004f8f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.7|WARNING|2024-04-29 17:10:34]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n",
+      "[Qibo 0.2.7|WARNING|2024-04-29 17:10:34]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "def test_gci_implementation_normal_and_oracles(backend,nqubits,mode_evolution_oracle = EvolutionOracleType.numerical):\n",
+      "    \"\"\"The regular implementation in `DoubleBracketIteration` should be viewed as using classical dynamic programming: memoization of the updated Hamiltonian is used explicitly. Instead, using `FrameShiftedEvolutionOracle` we can store a sequence of recursive rotations such that eventually the iteration gives the same result.\n",
+      "    This function tests numerical agreement using the numpy backend.\n",
+      "    \"\"\"\n",
+      "    h_x = SymbolicHamiltonian(\n",
+      "            symbols.X(0)\n",
+      "        + symbols.Z(0) * symbols.X(1)\n",
+      "        + symbols.Y(2)\n",
+      "        + symbols.Y(1) * symbols.Y(2),\n",
+      "        nqubits=3,\n",
+      "    ) \n",
+      "    d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n",
+      "    h_input = h_x + d_0\n",
+      "\n",
+      "    dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n",
+      "\n",
+      "    evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle)   \n",
+      "    gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n",
+      "\n",
+      "    evolution_oracle_diagonal_target =  EvolutionOracle(d_0, \"D0\",\n",
+      "               mode_evolution_oracle)\n",
+      "\n",
+      "    from numpy.linalg import norm\n",
+      "\n",
+      "    times = np.linspace(1e-5,1,5)\n",
+      "    for r in times:\n",
+      "\n",
+      "        dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n",
+      "        k_r = dbi.h.matrix\n",
+      "        dbi.h = deepcopy(h_input.dense) \n",
+      "        gci(r, diagonal_association= evolution_oracle_diagonal_target )\n",
+      "        j_r = gci.h.matrix\n",
+      "        gci.h = deepcopy(h_input.dense) \n",
+      "        gci.iterated_hamiltonian_evolution_oracle = deepcopy(evolution_oracle) \n",
+      "\n",
+      "        assert norm(k_r-j_r) < 1e-12\n",
+      "\n",
+      "    r = 1\n",
+      "    for _ in range(3):\n",
+      "        dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n",
+      "        gci(r, diagonal_association= evolution_oracle_diagonal_target )\n",
+      "        k_r = dbi.h.matrix\n",
+      "        j_r = gci.h.matrix\n",
+      "        \n",
+      "        assert norm(k_r-j_r) < 1e-12 \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print_function_source_code(test_gci_implementation_normal_and_oracles)\n",
+    "\n",
+    "        \n",
+    "test_gci_implementation_normal_and_oracles(backend,nqubits, mode_evolution_oracle = EvolutionOracleType.numerical)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d9771f86",
+   "metadata": {},
+   "source": [
+    "#### Remark:\n",
+    "If Hamiltonian_simulation is used as the mode then the eps_trottersuzuki might be too law to pass this assertion."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f4d7a01",
+   "metadata": {},
+   "source": [
+    "# Check the numerical mode of evolution oracles"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e81631c7",
+   "metadata": {},
+   "source": [
+    "This is testing the following:\n",
+    "\n",
+    "`dbi_exact` runs $V_{exact} = e^{-sW}$ and rotates $H_1 = V_{exact}^\\dagger H_0 V_{exact}$.\n",
+    "\n",
+    "`dbi_GC` runs $V_{GC} = GC$ and rotates $K_1 = V_{GC}^\\dagger H_0 V_{GC}$.\n",
+    "\n",
+    "We assert that dbi_exact and dbi_GC should be within the approximation bound of the GC\n",
+    "$$||J_1-H_1||\\le2 ||H_0||\\,||R-V||\\le C ||H_0|| s^{3/2}$$\n",
+    "\n",
+    "`gci` runs $V_{EO,GC} = GC$ and rotates $J_1 = V_{EO,GC}^\\dagger H_0 V_{EO,GC}$.\n",
+    "\n",
+    "We assert that gci and dbi2 should be within machine precision for the correct sorting.\n",
+    "$$||J_1-K_1||\\le2 ||H_0||\\,||R-Q||\\le \\epsilon$$\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7e99a090",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "def test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps):\n",
+      "    \"\"\"\n",
+      "\n",
+      "    This is testing the following:\n",
+      "\n",
+      "    `dbi_exact` runs $V_{exact} = e^{-sW}$ and rotates $H_1 = V_{exact}^\\dagger H_0 V_{exact}$.\n",
+      "\n",
+      "    `dbi_GC` runs $V_{GC} = GC$ and rotates $K_1 = V_{GC}^\\dagger H_0 V_{GC}$.\n",
+      "\n",
+      "    We assert that dbi_exact and dbi_GC should be within the approximation bound of the GC\n",
+      "    $$||J_1-H_1||\\le2 ||H_0||\\,||R-V||\\le C ||H_0|| s^{3/2}$$\n",
+      "\n",
+      "    `gci` runs $V_{EO,GC} = GC$ and rotates $J_1 = V_{EO,GC}^\\dagger H_0 V_{EO,GC}$.\n",
+      "\n",
+      "    We assert that gci and dbi2 should be within machine precision for the correct sorting.\n",
+      "    $$||J_1-K_1||\\le2 ||H_0||\\,||R-Q||\\le \\epsilon$$\n",
+      "    \"\"\"\n",
+      "    from numpy.linalg import norm\n",
+      "    h_x = SymbolicHamiltonian(\n",
+      "        symbols.X(0)\n",
+      "        + symbols.Z(0) * symbols.X(1)\n",
+      "        + symbols.Y(2)\n",
+      "        + symbols.Y(1) * symbols.Y(2),\n",
+      "        nqubits=3,\n",
+      "    )\n",
+      "    d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n",
+      "    h_input = h_x + d_0\n",
+      "\n",
+      "    dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n",
+      "\n",
+      "    w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n",
+      "    norms_bound = 0.5*t_step**1.48 * (\n",
+      "        np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n",
+      "    )\n",
+      "\n",
+      "    v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n",
+      "    v_gc = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)\n",
+      "    assert norm(v_exact - v_gc) < norms_bound\n",
+      "\n",
+      "    dbi(t_step, d = d_0.dense.matrix )\n",
+      "    h_1 = dbi.h.matrix\n",
+      "\n",
+      "    dbi.h = deepcopy(h_input.dense)\n",
+      "    dbi(t_step, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n",
+      "    k_1 = dbi.h.matrix\n",
+      "\n",
+      "    assert norm(h_1-k_1) < 2 * norm(h_input.dense.matrix) * norms_bound   \n",
+      "\n",
+      "    evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n",
+      "                        mode_evolution_oracle = EvolutionOracleType.numerical)    \n",
+      "\n",
+      "    evolution_oracle_diagonal_target =  EvolutionOracle(d_0, \"D0\",\n",
+      "                        mode_evolution_oracle = EvolutionOracleType.numerical)\n",
+      "\n",
+      "    gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n",
+      "\n",
+      "    u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target )\n",
+      "    assert norm(u_gc_from_oracles['forwards'].conj().T - u_gc_from_oracles['backwards']) < 1e-12\n",
+      "\n",
+      "    assert norm(v_exact - gci.eval_gcr_unitary(t_step, evolution_oracle_diagonal_target)) < norms_bound\n",
+      "\n",
+      "    gci(t_step, diagonal_association= evolution_oracle_diagonal_target )\n",
+      "    j_1 = gci.h.matrix\n",
+      "\n",
+      "    assert norm(h_1-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound  \n",
+      "\n",
+      "    assert norm(j_1-k_1) < 1e-12\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print_function_source_code(test_gci_evolution_oracles_types_numerical)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "583ca695",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.7|WARNING|2024-04-29 17:10:34]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n",
+      "[Qibo 0.2.7|WARNING|2024-04-29 17:10:34]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n"
+     ]
+    }
+   ],
+   "source": [
+    "t_step =0.01\n",
+    "eps = 1e-2\n",
+    "test_gci_evolution_oracles_types_numerical(nqubits,backend,t_step, eps)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f0b06ec",
+   "metadata": {},
+   "source": [
+    "## Check numerical GCI with evolution oracles against `DoubleBracketIteration`\n",
+    "\n",
+    "Basically we have again a bound for how $H_k$ differs from $J_k$ for various duriations of the DBR.\n",
+    "\n",
+    "The plots below show that the GCI implementation for 1 step agrees precisely"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "a2c2422b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.7|WARNING|2024-04-29 17:10:34]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n",
+      "/home/marek/.local/lib/python3.10/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n",
+      "  warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n",
+      "[Qibo 0.2.7|WARNING|2024-04-29 17:10:35]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7ff19b1b8a30>]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "h_x = SymbolicHamiltonian(\n",
+    "        symbols.X(0)\n",
+    "    + symbols.Z(0) * symbols.X(1)\n",
+    "    + symbols.Y(2)\n",
+    "    + symbols.Y(1) * symbols.Y(2),\n",
+    "    nqubits=3,\n",
+    ")\n",
+    "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n",
+    "h_input = h_x + d_0\n",
+    "\n",
+    "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n",
+    "dbi.mode = DoubleBracketGeneratorType.single_commutator\n",
+    "\n",
+    "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n",
+    "                        mode_evolution_oracle = EvolutionOracleType.numerical)    \n",
+    "\n",
+    "evolution_oracle_diagonal_target =  EvolutionOracle(d_0, \"D0\",\n",
+    "           mode_evolution_oracle = EvolutionOracleType.numerical)\n",
+    "\n",
+    "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n",
+    "\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from numpy.linalg import norm\n",
+    "norms  = []\n",
+    "norms2  = []\n",
+    "norms_bound = []\n",
+    "times = np.linspace(1e-5,1,30)\n",
+    "for r in times:\n",
+    "    dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.single_commutator )\n",
+    "    h_r = dbi.h.matrix\n",
+    "    dbi.h = deepcopy(h_input.dense) \n",
+    "    dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n",
+    "    k_r = dbi.h.matrix\n",
+    "    dbi.h = deepcopy(h_input.dense) \n",
+    "    gci(r, diagonal_association= evolution_oracle_diagonal_target )\n",
+    "    j_r = gci.h.matrix\n",
+    "    gci.h = deepcopy(h_input.dense) \n",
+    "    \n",
+    "    w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n",
+    "    norms_bound.append(norm(h_input.dense.matrix)*r**1.48 * (\n",
+    "        np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n",
+    "    ))\n",
+    "   \n",
+    "    norms.append(norm(h_r -k_r ))\n",
+    "    norms2.append(norm(h_r-j_r))\n",
+    "    \n",
+    "plt.loglog(times, norms_bound)\n",
+    "plt.loglog(times,norms, \n",
+    "          '-s')\n",
+    "plt.loglog(times,norms2, '-x')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e89586e",
+   "metadata": {},
+   "source": [
+    "### This is captured in the following test\n",
+    "(we restrict to both group commutator modes as for more steps there will be deviations)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "40308fc2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.7|WARNING|2024-04-29 17:10:36]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.007946732303441253\n",
+      "0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "evolution_oracle = EvolutionOracle(h_input, \"ZX\",\n",
+    "                    mode_evolution_oracle = EvolutionOracleType.numerical)    \n",
+    "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n",
+    "evolution_oracle_diagonal_target =  EvolutionOracle(d_0, \"D0\",\n",
+    "           mode_evolution_oracle = EvolutionOracleType.numerical)\n",
+    "\n",
+    "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n",
+    "#gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator\n",
+    "\n",
+    "u_gc_from_oracles = gci.group_commutator( t_step, evolution_oracle_diagonal_target )   \n",
+    "u_gci = u_gc_from_oracles['forwards']\n",
+    "\n",
+    "assert norm(u_gci.conj().T - u_gc_from_oracles['backwards']) < 1e-12\n",
+    "\n",
+    "\n",
+    "v_exact = dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.single_commutator)\n",
+    "w = dbi.commutator(h_input.dense.matrix,d_0.dense.matrix)\n",
+    "norms_bound = 0.5*t_step**1.48 * (\n",
+    "    np.linalg.norm(dbi.commutator(h_input.dense.matrix,w)) + np.linalg.norm(dbi.commutator(d_0.matrix,w))\n",
+    ")\n",
+    "assert norm(v_exact - u_gci) < norms_bound\n",
+    "u_gcr = gci.eval_gcr_unitary(t_step,evolution_oracle_diagonal_target )\n",
+    "assert norm(v_exact - u_gcr) < norms_bound\n",
+    "print(norm(v_exact-u_gcr))\n",
+    "print(norm(dbi.eval_dbr_unitary(t_step, d=d_0.dense.matrix, mode=DoubleBracketGeneratorType.group_commutator)-u_gci))\n",
+    "gci(t_step, diagonal_association= evolution_oracle_diagonal_target )\n",
+    "\n",
+    "j_1 = gci.iterated_hamiltonian_evolution_oracle.h.matrix\n",
+    "assert norm(dbi.h.matrix-j_1) < 2 * norm(h_input.dense.matrix) * norms_bound   \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fe2c0711",
+   "metadata": {},
+   "source": [
+    "### Next many steps: the `DoubleBracketIteration` implementation agrees with evolution oracles for the gc mode. In the exact commutator exponential a deviation builds up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "2b895267",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7ff19abea650>]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "r=0.01\n",
+    "\n",
+    "norms_it  = []\n",
+    "norms_it2  = []\n",
+    "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n",
+    "dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n",
+    "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n",
+    "for _ in range(15):\n",
+    "    dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.single_commutator )\n",
+    "    dbi2(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n",
+    "    gci(r, diagonal_association= evolution_oracle_diagonal_target )\n",
+    "    h_r = dbi.h.matrix\n",
+    "    k_r = dbi2.h.matrix\n",
+    "    j_r = gci.h.matrix\n",
+    "    norms_it.append(norm(k_r-j_r))\n",
+    "    norms_it2.append(norm(h_r-j_r))    \n",
+    "plt.plot(norms_it)\n",
+    "plt.show()\n",
+    "plt.plot(norms_it2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1e6319bf",
+   "metadata": {},
+   "source": [
+    "## Simple test of group commutator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "ec6361ca",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def test_exact_dbr_vs_gc_bound(nqubits,backend):\n",
+    "    dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n",
+    "    dbi.mode = DoubleBracketGeneratorType.single_commutator\n",
+    "\n",
+    "\n",
+    "    dbi2 = DoubleBracketIteration(deepcopy(h_input.dense))\n",
+    "    dbi2.mode = DoubleBracketGeneratorType.group_commutator\n",
+    "\n",
+    "    import matplotlib.pyplot as plt\n",
+    "    norms  = []\n",
+    "    for r in np.linspace(1e-5,0.1,30):\n",
+    "        dbi(r, d=d_0.dense.matrix)\n",
+    "        dbi2(r, d=d_0.dense.matrix)\n",
+    "        norms.append(norm(dbi.h.matrix- dbi2.h.matrix))\n",
+    "    \n",
+    "    #plt.plot(np.linspace(1e-5,.1,30), [x**1.5*1000 for x in np.linspace(1e-5,.1,30)])\n",
+    "    plt.plot(np.linspace(1e-5,.1,30),norms)\n",
+    "test_exact_dbr_vs_gc_bound(nqubits,backend)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0fc17c2d",
+   "metadata": {},
+   "source": [
+    "## Check the GC bound is valid and corectly implemented in DoubleBracketIteration\n",
+    "\n",
+    "The bound is $$||e^{-t[D,H]}-GC(s=\\sqrt{t})||\\le t^{3/2}(||[H,[D,H]||+||[D,[D,H]]||$$\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "8ecce261",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "@pytest.mark.parametrize(\"nqubits\", [3])\n",
+      "def test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits):\n",
+      "    r\"\"\"The bound is $$||e^{-[D,H]}-GC||\\le s^{3/2}(||[H,[D,H]||+||[D,[D,H]]||$$ which we check by a loglog fit.\"\"\"\n",
+      "    h0 = random_hermitian(2**nqubits, backend=backend)\n",
+      "    d = backend.cast(np.diag(np.diag(backend.to_numpy(h0))))\n",
+      "    dbi = DoubleBracketIteration(\n",
+      "        Hamiltonian(nqubits, h0, backend=backend),\n",
+      "        mode=DoubleBracketGeneratorType.group_commutator,\n",
+      "    )\n",
+      "\n",
+      "    times = np.linspace(0.001, 0.01, 10)\n",
+      "    norms = []\n",
+      "    norms_bound = []\n",
+      "    for s in times:\n",
+      "        u = dbi.eval_dbr_unitary(\n",
+      "            s, d=d, mode=DoubleBracketGeneratorType.single_commutator\n",
+      "        )\n",
+      "        v = dbi.eval_dbr_unitary(\n",
+      "            s, d=d, mode=DoubleBracketGeneratorType.group_commutator\n",
+      "        )\n",
+      "\n",
+      "        norms.append(np.linalg.norm(u - v) )\n",
+      "        w = dbi.commutator(h0,d)\n",
+      "        norms_bound.append(0.5*s**1.48 * (\n",
+      "            np.linalg.norm(dbi.commutator(h0,w)) + np.linalg.norm(dbi.commutator(d,w))\n",
+      "        ))\n",
+      "        assert np.linalg.norm(u - v) < 10 * s**1.49 * (\n",
+      "                np.linalg.norm(h0) + np.linalg.norm(d)\n",
+      "            ) * np.linalg.norm(h0) * np.linalg.norm(d)\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print_function_source_code(test_double_bracket_iteration_eval_dbr_unitary)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "bcfab105",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "test_double_bracket_iteration_eval_dbr_unitary(backend, nqubits)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c708df6a",
+   "metadata": {},
+   "source": [
+    "### We repeat the function in order to plot the bound"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "d4cff4ad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "r\"\"\"The bound is $$||e^{-[D,H]}-GC||\\le s^{3/2}(||[H,[D,H]||+||[D,[D,H]]||$$\"\"\"\n",
+    "h0 = random_hermitian(2**nqubits, backend=backend)\n",
+    "d = backend.cast(np.diag(np.diag(backend.to_numpy(h0))))\n",
+    "dbi = DoubleBracketIteration(\n",
+    "    Hamiltonian(nqubits, h0, backend=backend),\n",
+    "    mode=DoubleBracketGeneratorType.group_commutator,\n",
+    ")\n",
+    "\n",
+    "times = np.linspace(0.001, 0.01, 10)\n",
+    "norms = []\n",
+    "norms_bound = []\n",
+    "for s in times:\n",
+    "    u = dbi.eval_dbr_unitary(\n",
+    "        s, d=d, mode=DoubleBracketGeneratorType.single_commutator\n",
+    "    )\n",
+    "    v = dbi.eval_dbr_unitary(\n",
+    "        s, d=d, mode=DoubleBracketGeneratorType.group_commutator\n",
+    "    )\n",
+    "\n",
+    "    norms.append(np.linalg.norm(u - v) )\n",
+    "    w = dbi.commutator(h0,d)\n",
+    "    norms_bound.append(0.5*s**1.48 * (\n",
+    "        np.linalg.norm(dbi.commutator(h0,w)) + np.linalg.norm(dbi.commutator(d,w))\n",
+    "    ))\n",
+    "    assert np.linalg.norm(u - v) < 10 * s**1.49 * (\n",
+    "            np.linalg.norm(h0) + np.linalg.norm(d)\n",
+    "        ) * np.linalg.norm(h0) * np.linalg.norm(d)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "914f2c09",
+   "metadata": {},
+   "source": [
+    "Unfortunately we cannot assume that \n",
+    "`assert popt[0] < 1.51`\n",
+    "because in principle data satisfying the bound can be ragged and could have a large slope.\n",
+    "When the bound is saturated, however, then the following fit works:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "05128816",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scipy.optimize import curve_fit\n",
+    "popt, pcov = curve_fit( (lambda x, a, b: a*x+b ), [np.log(t) for t in times], [np.log(n) for n in norms])\n",
+    "assert popt[0] < 1.51"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5c757242",
+   "metadata": {},
+   "source": [
+    "In practice that assertion usually goes through. We check this further by these plots"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "62c60671",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7ff19aae9720>]"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAAsTAAALEwEAmpwYAAAs0klEQVR4nO3deXxU9bnH8c+TFcISIOxZSNh3BcKmiAuCu7igIFWxorQqtb33trfe9tqqtbX2dq90wR1cUAE1ioqyqCBrwk4ADSFAQghZIEDINpnn/nFGGzFIgEnOZOZ5v16+OjPnJPPMKfnml9/5LaKqGGOMCV5hbhdgjDGmYVnQG2NMkLOgN8aYIGdBb4wxQc6C3hhjglyE2wWcrH379pqcnOx2GcYY06RkZGQUqWqHuo4FXNAnJyeTnp7udhnGGNOkiMjeUx2zrhtjjAlyFvTGGBPkLOiNMSbIWdAbY0yQs6A3xpggZ0FvjDFBzoLeGGOCnAW9McYEgvTnIWtJg3xrC3pjjHGT1wsfPgzv/gg2vtwgb1GvoBeRK0Vkl4hkichDdRyPFpHXfMfXikhyrWODRWS1iGwXka0i0syP9RtjTNNVXQ5vTINVf4Xh98BNTzfI25x2CQQRCQdmAeOBXGC9iKSpamat06YDh1W1p4hMAZ4EJotIBPAScIeqbhaROKDa75/CGGOamuOH4NXbIC8DrngCRt0HIg3yVvVp0Y8AslQ1W1WrgHnAxJPOmQi86Hs8HxgnIgJMALao6mYAVS1W1Rr/lG6MMU3UoZ3wzDgo2A6TX4LR9zdYyEP9gj4e2F/rea7vtTrPUVUPUArEAb0BFZHFIrJBRP67rjcQkRkiki4i6YWFhWf6GYwxpunI/hienQCeSvjue9Dv2gZ/y4a+GRsBjAG+4/vfG0Vk3MknqepsVU1V1dQOHepcZdMYY5q+DXPhpZshNh7uWQLxQxvlbesT9HlAYq3nCb7X6jzH1y8fCxTjtP4/VdUiVT0BvAc0ziczxphA4fXCkkchbSakjIW7P4A2SY329vUJ+vVALxFJEZEoYAqQdtI5acA03+NJwDJVVWAxMEhEYny/AC4GMjHGmFBRXQ4L7oaVf4Rhd8HU16FZbKOWcNpRN6rqEZGZOKEdDjynqttF5DEgXVXTgGeBuSKSBZTg/DJAVQ+LyB9xflko8J6qLmqgz2KMMYGlrMgZWZO7Dsb/Ci74QYPedD0VcRregSM1NVVthyljTJNX+Dm8cgscOwg3zYb+Jw9W9C8RyVDV1LqOBdxWgsYY0+TtWQGvfQfCo+CuRZBQZ/42GlsCwRhj/GnTqzD3RmjVBe5Z6nrIg7XojTHGP1Th4yfgkych5WK4dQ40b+N2VYAFvTHGnDtPJbz9AGx9A4bcDtf8CSKi3K7qKxb0xhhzLsqKnf74fath3C9gzH+6MrLm21jQG2PM2SreDS9PgtI8mPQcDLzZ7YrqZEFvjDFnY+8qmDcVJAymvQNJI92u6JRs1I0xxpypLa/DnIkQ095ZsyaAQx6sRW+MMfWnCp/8Dj7+DSRfBJPnQvO2bld1Whb0xhhTH55KSHsQtsyD86bCdX8JqJE138aC3hhjTudECbx2B+xdCZf+HMb+JOBG1nwbC3pjjPk2Jdnw8q1wZK+zp+vgW92u6IxZ0BtjzKnsWwvzbgP1wp1vQ7cL3K7orNioG2OMqcu2BfDidc7a8fcsbbIhDxb0xhjzdarw6e9h/t3OVn/3LIW4Hm5XdU6s68YYY77kqYJ3/wM2vQSDboWJT0FEtNtVnTMLemOMASg/Aq/fAXs+hYsfgksealIja76NBb0xxhzOcUbWlGTDDf+E829zuyK/sqA3xoS2/evh1Sng9cCdb0HyGLcr8ju7GWuMCV2bXoEXrobols6aNUEY8mAtemNMKKrxwEe/gDWzIGUs3PIixLRzu6oGY0FvjAktJ0qcoZPZy2Hk92HCryE8uKMwuD+dMcbUdmgHvHoblObC9U/B0DvcrqhRWNAbY0LDzvdg4b0QGQN3LQr4NeT9qV43Y0XkShHZJSJZIvJQHcejReQ13/G1IpLsez1ZRMpFZJPvv3/6uX5jjPl2qvDp/zm7QcX1hBkfh1TIQz1a9CISDswCxgO5wHoRSVPVzFqnTQcOq2pPEZkCPAlM9h3brarn+7dsY4yph6oyeOt+yHzLmel6/V8hsrnbVTW6+rToRwBZqpqtqlXAPGDiSedMBF70PZ4PjBMJkillxpim6cg+eO4K2JEG438FN80OyZCH+gV9PLC/1vNc32t1nqOqHqAUiPMdSxGRjSLyiYhcVNcbiMgMEUkXkfTCwsIz+gDGGPMNOZ/B7Evg8D6Y+gZc+GDQLGdwNhp6wlQ+kKSqQ4D/BF4RkdYnn6Sqs1U1VVVTO3To0MAlGWOC2vpnYc710Lwd3LsUel3udkWuq0/Q5wGJtZ4n+F6r8xwRiQBigWJVrVTVYgBVzQB2A73PtWhjjPkGTxW88yNY9J/Q4zIn5Nv3cruqgFCfoF8P9BKRFBGJAqYAaSedkwZM8z2eBCxTVRWRDr6buYhId6AXkO2f0o0xxud4IcyZCBnPw5j/gNvmORuGGKAeo25U1SMiM4HFQDjwnKpuF5HHgHRVTQOeBeaKSBZQgvPLAGAs8JiIVANe4PuqWtIQH8QYE6LyN8O870BZIdz8LAya5HZFAUdU1e0aviY1NVXT09PdLsMY0xRsWwBvPeCsUzPlZeg6xO2KXCMiGaqaWtcxmxlrjGl6vF5Y/jis+AMkjoLJc6FlR7erClgW9MaYpqXiKCycAZ+/D0PvhKt/HxTb/TUkC3pjTNNRvNtZlKw4ywn44feE9Pj4+rKgN8Y0DVlLYf53QcLhzrchpc75l6YOtsOUMSawqcKqp+DlSdA6AWYst5A/Q9aiN8YEruoKePdHsPlV6Hc93PAPZ9s/c0Ys6I0xgeloPrz2HcjLgEt/Dhf9GMKsE+JsWNAbYwLP/vXw2u1QdRwmvwz9rnW7oibNgt4YE1g2vQLv/BBadYE73oRO/d2uqMmzoDfGBIYaD3z0MKz5O6SMhVtedGa8mnNmQW+Mcd+JEph/N2Qvh5H3wYTHIdziyV/sShpj3HVohzMJ6mgeTJwFQ253u6KgY0FvjHHPzvdg4b0QGQN3LYLEEW5XFJQs6I0xjc9bA5/+H3z8hLPi5OSXIfbkHUqNv1jQG2MaV1kxLLwHdi+D826Da/8Uspt2NxYLemNM49m/Ht6YBmVFcN1fYOg0W5SsEVjQG2Maniqsmw2Lfw6tu8L0D6Hr+W5XFTIs6I0xDavyGKT9ALa/CX2uhhv+Ds3bul1VSLGgN8Y0nIJMeP1OKNkNlz8KFzxo69W4wILeGNMwNr/mrDwZ1RKmvQPJY9yuKGRZ0Btj/Ku6Aj54CDKeh24XwqTnoFVnt6sKaRb0xhj/OZwDr0+D/E1w4Y/gsodtKYMAYP8PGGP8Y9cH8OYMUGDKq9D3arcrMj4W9MaYc1PjgeW/hpV/hM6D4dY50C7F7apMLfW6/S0iV4rILhHJEpGH6jgeLSKv+Y6vFZHkk44nichxEfmxn+o2xgSCYwUw9wYn5IdOg+kfWcgHoNO26EUkHJgFjAdygfUikqaqmbVOmw4cVtWeIjIFeBKYXOv4H4H3/Ve2McZ1e1fBG9+FilJnL9fzp7pdkTmF+rToRwBZqpqtqlXAPGDiSedMBF70PZ4PjBNx5jWLyA3AHmC7Xyo2xrhLFT77K7xwLUS1gHuWWMgHuPoEfTywv9bzXN9rdZ6jqh6gFIgTkZbAT4FHv+0NRGSGiKSLSHphYWF9azfGNLbyI85erh897OzjOuNj6DzQ7arMaTT0zdhHgD+p6nH5loWLVHU2MBsgNTVVG7gmY8zZyN/szHItzYUrnoBR99mCZE1EfYI+D0is9TzB91pd5+SKSAQQCxQDI4FJIvI7oA3gFZEKVX3qXAs3xjSiDXNg0Y8hJg7ueg+SRrpdkTkD9Qn69UAvEUnBCfQpwMkdcmnANGA1MAlYpqoKXPTlCSLyCHDcQt6YJqTqBLz3E9j0EnS/BG56Blp2cLsqc4ZOG/Sq6hGRmcBiIBx4TlW3i8hjQLqqpgHPAnNFJAsowfllYIxpyop3O101Bdtg7H/DJQ9BWLjbVZmzIE7DO3CkpqZqenq622UYE9oy0+Ct+53lC256GnqNd7sicxoikqGqqXUds5mxxph/q6mGJY/A6qcgfhjc8iK0STztl5nAZkFvjHEcPeBMgNq/BobfC1f8GiKi3a7K+IEFvTEGsj+G+dOhuhxufhYGTXK7IuNHFvTGhDKvF1b8wVmUrH1vmDwXOvRxuyrjZxb0xoSqEyWwcAZkfQSDboFr/wzRLd2uyjQAC3pjQlFuBrwxDY4XwDV/gNTpNss1iFnQGxNKvF5Y+w9nZE3LTnD3B87oGhPULOiNCRXHCuCt+2D3Uuh9Fdzwd4hp53ZVphFY0BsTCj5f7EyAqjpuXTUhyILemGBWXQ4fPgzrn4ZOA52hkx37ul2VaWQW9MYEq4Ltztj4wh0w6n4Y90uIbOZ2VcYFFvTGBBtVWDfback3i4XvLIBel7tdlXGRBb0xweR4Ibx9P3zxIfSaABP/bssKNwFFxyt5buUeEtrGMHVkkt+/vwW9McHiiyXw1veh4ihc9TsYMcNuuAa4/NJy/vVJNvPW76PS42Xa6OQGeR8LemOauuoKZ1z82n9Ax/5w59vQaYDbVZlvkVNUxj8/2c2CDbmowg1D4rnvkh706NAwM5Mt6I1pyg7tgAX3OJuDjJgB4x+DyOZuV2VOYdfBY8xansW7Ww4QER7GbSOSmDG2OwltYxr0fS3ojWmKVCH9WVj8c4hqCVNfh95XuF2VOYVN+48wa3kWH2UW0CIqnHvHdmf6mBQ6tmqcUVAW9MY0NWVFkPYD2PUe9BgHN/wDWnVyuypzElVlTXYJs5ZnsTKriNjmkfzo8l7cdUEybWKiGrUWC3pjmpLdy+DN70P5YbjiCRj5fQgLc7sqU4uqsnzXIWYt303G3sN0aBXNz67uy9SR3WgZ7U7kWtAb0xR4KmHpY84Wf+37wO0LoPMgt6sytdR4lQ+2HWTW8iwy848S36Y5v5o4gFtSE2kW6e6m6hb0xgS6ws9hwd1wcKuzRs2ExyGqYW/emfqrrvHy1sY8/vHJbrILy+jeoQW/v+U8Jp7flcjwwPhry4LemEClChnPwwc/c0bSTHkV+l7tdlXGp6K6htfT9/OvT7LJO1JO/y6tmTV1KFcO7Ex4WGDNX7CgNyYQnShxbrjufBe6XwI3/BNad3G7KgMcr/Tw8pq9PL1iD0XHKxnWrS2P3zCQS/p0QAJ0gpoFvTGBJvsTePN7zuia8b+C0TPthmsAOHKiiuc/y+GFVTmUlldzUa/2PHDpEEamtAvYgP9SvYJeRK4E/gKEA8+o6m9POh4NzAGGAcXAZFXNEZERwOwvTwMeUdU3/VW8MUHFUwXLH4fP/gpxPeG2edD1fLerCnmHjlXw7Io9vLRmL2VVNUzo34kHLu3JeYlt3C6t3k4b9CISDswCxgO5wHoRSVPVzFqnTQcOq2pPEZkCPAlMBrYBqarqEZEuwGYReUdVPX7/JMY0ZUVZsGA65G+CodPgyicgqoXbVYW03MMn+Ncn2byWvh9PjZfrzuvK/Zf0pE/nVm6Xdsbq06IfAWSpajaAiMwDJgK1g34i8Ijv8XzgKRERVT1R65xmgJ5zxcYEE1XYOBfe/ylERMPkl6DfdW5XFdJ2Fx7n78t38/amPERg0rAEvje2B8ntm+4v3voEfTywv9bzXGDkqc7xtd5LgTigSERGAs8B3YA76mrNi8gMYAZAUpL/l+g0JiCVH4Z3fgiZb0PyRXDjvyA23u2qQtb2A6X8fflu3tuWT3REGHeM7saMsd3pEtv01w5q8JuxqroWGCAi/YAXReR9Va046ZzZ+PryU1NTrdVvgl/OSlg4A44XwOWPwAUPQpi7k2pCkaqSvvcwf1+exfJdhbSKjuD+S3pw94UpxLWMdrs8v6lP0OcBibWeJ/heq+ucXBGJAGJxbsp+RVV3iMhxYCCQftYVG9OU1VTDx0/Aij9CuxSY/iHED3O7qpBT41U+3H6Q2Suy2bjvCO1aRPHjCb25Y3Qysc0j3S7P7+oT9OuBXiKSghPoU4CpJ52TBkwDVgOTgGWqqr6v2e/rzukG9AVy/FW8MU1K4S546z7Iy4Aht8OVT0J0w6w/bupWXlXD/Iz9PLNyD3uLT9AtLoZfTRzApGGJNI8K3r+oThv0vpCeCSzGGV75nKpuF5HHgHRVTQOeBeaKSBZQgvPLAGAM8JCIVANe4H5VLWqID2JMwKrxwOq/wfInnKULbnkBBtzodlUhpfh4JXNW72Xumr2UlFVxfmIbHrqyLxMGBN4s1oYgqoHVJZ6amqrp6dazY4JEQSa8/QAc2OCMprn6D7akcCPaU1TGMyuymZ+RS6XHy+X9OvG9i7uT2q1twE9yOlMikqGqqXUds5mxxjSEmmpY+Wf45Elo1homPe+04oMsXAJVxt4SZn+azYeZBUSGh3Hz0Himj+lOz46h2VVmQW+Mvx3cCm/dDwe3OOF+9e+hRXu3qwp6NV7lo8wCnl6RTcbew7SJiWTmpT25c3QyHVoFzwias2FBb4y/eKpgxR9gxe+heVu4dS70v97tqoJeRXUNCzbk8syKPewpKiOxXXMevX4At6QmEBNlEQcW9Mb4x4FNTl98wTYYdAtc9TuIaed2VUGtpKyKOatzmLPaucF6XkIss6YO5YoBnYgIkHXgA4UFvTHnwlMJn/wOVv4JWnSwNeMbQU5RGc+u3MMbGfupqPYyrm9HZoztzogmsIqkWyzojTlbeRnw1gNQuAPOmwpX/sbpsjENYsO+w8z+JJvFmQeJDAvjxiHx3Ds2hZ4dm94iY43Ngt6YM1VdAR//Blb9DVp2hqlvQO8JblcVlLxeZckO5wbr+pzDtG7mLFEwbXQyHVs3c7u8JsOC3pgzsX+dM6Km+AsYeqezf2uzWLerCjoV1TUs3JDHMyuyyS4qI6Ftc355XX9uTU2kRbTF1pmyK2ZMfVSdgOW/htWzIDYBbl8IPce5XVXQOVxWxdw1e5mzOoei41UMio/lb7cN4aqBne0G6zmwoDfmdPauckbUlGRD6t1w+aPOJCjjN/uKT/DsymxeT8+lvLqGS/t0YMbYHozqbjdY/cGC3phTqSqDJY/CutnQJgnuTIPuF7tdVVDZtP8IT3+azfvb8gkPE244P557x3andye7wepPFvTG1GXPCkibCYdzYMQMGPdLW2nST6prvCzefpAXPsshfe9hWjWL4HsX9+CuC5LpZDdYG4QFvTG1VR6Dj34J6c9C2xS46z1IvtDtqoJC8fFKXl23j5fW7OPg0Qq6xcXw8LX9mTw8kZZ2g7VB2dU15ku7l0Pag1C6H0Y9AJf9r7OssDkn2/JKeWFVDmmbD1Dl8XJRr/b85qaBXNK7I2EhsERwILCgN6aiFD58GDa8CHE94e7FkHTytsjmTHzZPfPiqhzW5xwmJiqcyamJTLugm01wcoEFvQltXyyBdx6EY/nOvq2X/gwim/5m0G4pPl7JvPX7mbt6LwePVpDULob/vaYft6QmBuUWfU2FBb0JTeWHYfHPYdPL0KEv3DoHEurcs8HUw7a8Ul5clcPbtbpnfn3jQC7p0zEkdnAKdBb0JvTseh/e+RGUFcJF/wUX/xQiQnu98rPhqfHyYWYBL3yWw7qcEppHhnNragLTRifTy4ZHBhQLehM6TpTABw/Blteg4wCYOg+6DnG7qianpKzKN3pmL/mlFSS2a27dMwHOgt4EP1XY8Q4s+i8oL3Fa8Bf9GCKi3K6sSdl+wOmeeWuT0z0zpmd7Hps4kMv6WvdMoLOgN8GteLfTiv/iQ+g8CG5fAF0Gu11Vk+Gp8fJRZgHPr8ph3R6ne+aWYQlMuyDZZq82IRb0JjhVnXA2A/nszxAeDRN+DSO/B+HWtVAfh8uqfKNncjhQWkFC2+b8/Op+3JqaSGyMXcOmxoLeBBdV2PUevP8QlO5ztvUb/yto3cXtypqEzANHfd0zeVR6vFzQI45Hrh/AuH6drHumCbOgN8GjdjdNh35w1yJIHuN2VQHPU+NlyY4Cnv8sh7V7SmgWGcbNw5zRM306W/dMMKhX0IvIlcBfgHDgGVX97UnHo4E5wDCgGJisqjkiMh74LRAFVAE/UdVlfqzfGOumOUtfds+8tGYveUfKiW/TnJ9d3ZdbUxNpE2M3qoPJaYNeRMKBWcB4IBdYLyJpqppZ67TpwGFV7SkiU4AngclAEXCdqh4QkYHAYiDe3x/ChChVZ0z8Bz+FI9ZNU1/b8kp5ac1e3tzodM+M7h7HL67rz+XWPRO06tOiHwFkqWo2gIjMAyYCtYN+IvCI7/F84CkREVXdWOuc7UBzEYlW1cpzrtyEtpJseP+n/+6mmfYupFzkdlUBq6zSwzubD/DKun1syS2lWWQYNw2NZ9oFyfTtbJuoBLv6BH08sL/W81zg5BWfvjpHVT0iUgrE4bTov3QzsKGukBeRGcAMgKSkpHoXb0JQdbnTTbPyz07XjHXTfKvtB0p5Ze0+3t50gOOVHnp3askj1/XnxiEJNnomhDTKzVgRGYDTnTOhruOqOhuYDZCamqqNUZNpYqybpt5OVPla72v3sTm3lOiIMK4Z3IXvjExiaFJb25ovBNUn6POAxFrPE3yv1XVOrohEALE4N2URkQTgTeBOVd19zhWb0FOS7QyX/GKxswCZddPUKfPAUV5Zt5e3Njqt914dW/LL6/pzk7XeQ159gn490EtEUnACfQow9aRz0oBpwGpgErBMVVVE2gCLgIdU9TO/VW1Cg3XTnNaJKg/vbs7nlXX72LT/CFERYVw7qAtTRyYxrJu13o3jtEHv63OfiTNiJhx4TlW3i8hjQLqqpgHPAnNFJAsowfllADAT6An8QkR+4Xttgqoe8vcHMUFm1/vw/n9bN80p7Dx4lFfW7uPNDXkcq/TQs2NLfnFtf24aGm9DI803iGpgdYmnpqZqenq622UYt5zcTXP1762bxqe8qoZ3tzgjZzbuc1rvVw/szNSR3RiebK33UCciGapa56YKNjPWBAbrpjmlXQeP8cravSzcmMexCg89OrTgf6/px81DE2jbwlrv5vQs6I37dr3vjIk/shcGToIJj4d8N01FdQ3vbsnn1XX7yNh7mKjwMK4a1JmpI5IYkdLOWu/mjFjQG/fYaJpv+LzgGK+s3cfCDbkcrfDQvb3Ter9paALtrPVuzpIFvWl81eVOF83KP/m6aR6Hkd8P2W6aiuoa3tuazytr95Hua71fObAzt41IYlR3a72bc2dBbxqXddN8JevQMV5eu4+FG/IoLa8mpX0LfnZ1X24emkBcS9vD1viPBb1pHCV7nCWEP//A103zDqSMdbuqRldRXcP72/J5de1+1uWUEBkuXDGgM1NHJjG6e5y13k2DsKA3Dcu6aVBVNueWsiAjl7TNBygtryY5Lob/uaovk4ZZ6900PAt60zC8NbB5Hnz8BJTu93XT/Apad3W7skaTX1rOwg15LNyQy+7CMqIjwrhiQGemDE9kVPc4wmxJYNNILOiNf6nCzkWw7FdQuBO6DoUb/hEyo2lOVHlYvP0gCzLy+Gx3EaowIrkd917UnasHd6F1s9D5S8YEDgt64z97VsCSRyAvHeJ6wa1zoN/1EOT9zl6vsnZPCQs25PL+1nzKqmpIbNecBy/rxU1D4+kW18LtEk2Is6A35y5/Myx5FHYvhdbxcP3f4LypEB7c/7xyispYuCGXhRvzyD1cTsvoCK4Z3IWbhyYwPLmddc2YgBHcP4mmYRXvhuW/hm0LoHlb50br8HsgsrnblTWY0vJqFm3JZ8GGXDL2HkYExvRsz0+u6MOE/p1pHhXudonGfIMFvTlzR/Ph09/BhjkQHgVjfwIX/ACaxbpdWYPw1HhZkVXEgoxcPswsoMrjpWfHlvz0yr7cOCSezrHN3C7RmG9lQW/qr/wwfPYXWPNP8FbDsO86Id+qk9uVNYidB4+ycEMeb27Mo/BYJW1iIrlteCI3DU1gcEKsjXk3TYYFvTm9qhOw7l/OWPiKo8768Jf+DNqluF2Z3xUfr+TtTQdYsCGX7QeOEhEmXNq3IzcPTeCyvh2Jighzu0RjzpgFvTm1mmrY+BJ88iQcy4deV8C4h6HzILcr86tKTw3Ldx5ifkYeH+86hMerDIqP5ZfX9ef687rahCbT5FnQm2/yeiHzLVj2OJTshsSRMOk56HaB25X5Te3Zqu9sOcCRE9V0bBXN9DEp3DQ0gT6dW7ldojF+Y0Fv/k0Vdi+DpY86QyY79ofb5kHvK4NmLHx+aTlvbsxjQca/Z6tOGNCZm4fGM6ZneyLCrWvGBB8LeuPITXcmO+WsgDZJcOO/nL74sKY/XPBYRTUfZRawcMO/Z6sOT25rs1VNyLCgD3WFu2DpY7DzXYhpD1f9DobdBRFNu1/6eKWHpTsKeHdLPp98XkiVx0tC2+b84LJe3GyzVU2IsaAPVUf2w8e/hc2vQGQLuPTnMOo+iG66fdNllR6W7TzEoi35LN91iEqPl86tm3H7yG5cM7gLQxLb2GxVE5Is6ENNWTGs/COsexpQGHkfXPRf0CLO7crOyokqD8t3FrJo6wGW7TxERbWXjq2iuW1EEtcO7sLQpLYW7ibkWdCHisrjsObv8NlfobrMWYvmkoegTaLblZ2x8qoaPt51iHe35rNsxyHKq2to3zKaW1MTuWZQF1KT2xFu4W7MV+oV9CJyJfAXIBx4RlV/e9LxaGAOMAwoBiarao6IxAHzgeHAC6o605/Fm3rwVELGC/Dp/0FZIfS9Fi57GDr2dbuyM1JRXcMnnxeyaEs+S3YUcKKqhrgWUdw8LJ5rBnVlRIqFuzGnctqgF5FwYBYwHsgF1otImqpm1jptOnBYVXuKyBTgSWAyUAE8DAz0/Wcai7cGtr7hLDp2ZB8kXwRTXoXE4W5XVm8V1TWs+KKIRVsO8FFmAWVVNbSNiWTi+fFcO7gLI1Pa2XBIY+qhPi36EUCWqmYDiMg8YCJQO+gnAo/4Hs8HnhIRUdUyYKWI9PRfyeZbVZfDpldg9SxnslPnwXD7n6DHuCYxFr7SU8PKL4pYtCWfjzILOFbpoU1MJNed15VrBndhdPc4C3djzlB9gj4e2F/reS4w8lTnqKpHREqBOKDIH0WaejheCOufgfVPw4li6DoEbnkB+k2EsMAOxiqPl8+yinh3Sz4fZh7kWIWH2OaRXDWoM9cM7soFPeKItHA35qwFxM1YEZkBzABISkpyuZompugLWP2Usz+rpwJ6X+UsGdztgoBuwVfXeFm1u5hFWw6weHsBpeXVtGoWwRUDOnPN4C5c2KO9LSBmjJ/UJ+jzgNpDMxJ8r9V1Tq6IRACxODdl60VVZwOzAVJTU7W+XxeyVGHvKifgd70H4dFw/m0w6gHo0Nvt6k7JU+NldXYxi7bk88H2gxw5UU2r6AjG9+/ENYO7MKZXe6Ijmv5MXGMCTX2Cfj3QS0RScAJ9CjD1pHPSgGnAamASsExVLbD9rcYDO9Jg1d/gwAZo3g4u/ikMvxdadnC7ujp5arys21PCO1vyWbz9ICVlVbSICveFe1cu6tWeZpEW7sY0pNMGva/PfSawGGd45XOqul1EHgPSVTUNeBaYKyJZQAnOLwMARCQHaA1EicgNwISTRuyY06k8DhvnOuPgj+yDdj3gmj/CebdBVIzb1X1DaXk1n35eyLKdh1i+6xBHTlQTExXO5f2clvvFvTtYuBvTiCTQGt6pqamanp7udhmB4Wi+s+FH+nNQUQpJo2H0TOhzVcAtNpZdeJxlOw+xZEcB63MOU+NV2sZEcmmfjozv34lL+nS0/VSNaUAikqGqqXUdC4ibseYkBZlO//uW10FroN91MPoHATUGvrrGy/qcEpbuOMSynYfYU1QGQN/Orfje2O6M69eR8xPb2iQmYwKABX2gUIXsj53+991LITIGUr/rLDTWrrvb1QFQUlbFx7sOsXTnIT7dVcixSg9R4WGM7hHHdy9M5tI+HUlsF3hdScaEOgt6t9VUw7aFTsAXbIUWHZ0lClLvhph2rpamqnxecJwlOwpYtvMQG/YdRhU6tIrm6kFdGNevIxf2bE+LaPtnZEwgs59Qt1SUOmvQrPknHDsAHfrCxFnOZh8urgVfUV3Dmuxilu08xNIdh8g7Ug7AoPhYHrysF+P6dWRg11hbEdKYJsSCvrEd2Q9r/wkZL0LVMUgZC9f/FXpe7toEp0NHK1i+ywn2lVlFnKiqoVlkGGN6dmDmZT25tE9HOsc2c6U2Y8y5s6BvLAc2Od0z2990ng+8GS6YCV3Oa/RSVJVteUdZutPpktmSWwpA19hm3DQ0nnH9OjG6e5wNgTQmSFjQNySvF7KWwKq/OnuxRrWC0ffDyO9DbEKjlnKiysNnWcUs84V7wdFKRGBIYht+ckUfLuvbkb6dWyEBvGyCMebsWNA3hOoK2Po6rHoKinZB63iY8DgMvROaxTZaGXlHylm2o4ClOw+xancxVR4vLaMjGNu7PZf17cQlfTrQvmXT3hvWGHN6FvT+ogoHtzprwG+eB2WHoPMguOlpGHAjhEc2eAlFxytZk13MmuxiVu8uZnehM7Y9qV0M3xmZxOX9OjE8uZ0tFmZMiLGgP1cle2DbfNjyhtN6D4uAXhOc7pmUsQ16g7WkrIq12cWs9oX75wXHAWgRFc7wlHZMHp7IZX070aNDC+uSMSaEWdCfjeOFsH2h03rPXe+81u1CGPV96H9Dg41/P3KiijXZJV+12ncePAZA88hwUpPbcsOQeEZ1j2NQfKyt326M+YoFfX1VHoMd7zrhnv2xszRBp0Fw+aPOCJoG2GS79EQ163JKWL3bCfYdB4+iCs0iw0jt1o4fT+jC6B5xDIpvY90xxphTsqD/Np5KZ9TM1jdg1/vOxh5tkmDMj5yJTR37+fXtjlZUs36P02JfnV3M9gNOsEdFhDEsqS3/cXlvRveIY3BCrK3bboypNwv6k3m9sPczJ9wz34aKIxATB0PugMG3QsJwv/W7H6/0sD6nhDW7nWDflleKVyEqPIwhSW344bhejOoex/mJbWxMuzHmrFnQg2/EzBZntchtC50lCSJbQL9rYdCt0P1iv4yaKav0kL738FejYrbmlVLjVSLDhSGJbZl5aU9G9YhjaFJbC3ZjjN+EdtCXZMPW+U7rvehzZ8RMz/FwxePO3qvnuKlHeVUNGXsPszq7iDXZJWzefwSPV4kIE85LbMN9F/dgVPc4hnVra2u1G2MaTOgF/bECZxmCrW9Anm+Dk24Xwqj7of/EcxoxU3C0gm15pWzef4TV2cVs2n+E6holPEwYnBDLvWO7M7p7HKnJbYmJCr1Lb4xxR2ikTcVR2Fl7xIzXGTEz/jFnxMwZLkegquQdKWdb3lG2HyhlW14p2w4cpfBYJQBh4qz2ePeYFF+wt6OlLeVrjHFJ8KaPpxK++MhZiuDzxb4RM91gzH/CoEn1HjHj9Sp7S074wryU7XlH2XaglCMnqgEIDxN6dWzJ2F4dGBjfmoHxsfTr0tqC3RgTMIIrjbw1kLPSN2ImDSpLIaa9s8bMoFtOO2LGU+Mlu6jMCXVfoGceOMrxSg/gjIbp07kVVw3szICusQyMj6Vv51Z249QYE9CCJ+hz0+G12+FYPkS1hL7XOuHe/RII/+bHrPJ4+eLQsa9a6NvySsnMP0pFtRdwJiX169KaG4fEMyg+lgHxrenVsZVNTDLGNDnBE/RxPSB+GAy86RsjZiqqa9h58Bjb8kp9fepH2XXwGFU1Tqi3jI6gf9fWTB3R7avul+7tWxBhywgYY4JA8AR987Yw5WXKKj1kHjjKtryCr26WfnHoODVeBSC2eSSD4mP57phkBvq6X7q1i7Gt8YwxQStogn5bXik/nLeR7KIy1Ml02reMYmB8LJf368TA+FgGxrcmvk1zW8nRGBNS6hX0InIl8BcgHHhGVX970vFoYA4wDCgGJqtqju/Y/wDTgRrgQVVd7Lfqa2nfMpruHVpy/XnxX3W/dGwVbaFujAl5pw16EQkHZgHjgVxgvYikqWpmrdOmA4dVtaeITAGeBCaLSH9gCjAA6AosEZHeqlrj7w/SObYZT9+Z6u9va4wxTV597jaOALJUNVtVq4B5wMSTzpkIvOh7PB8YJ05TeiIwT1UrVXUPkOX7fsYYYxpJfYI+Hthf63mu77U6z1FVD1AKxNXza40xxjSggBg/KCIzRCRdRNILCwvdLscYY4JKfYI+D6i9fVKC77U6zxGRCCAW56Zsfb4WVZ2tqqmqmtqhQ4f6V2+MMea06hP064FeIpIiIlE4N1fTTjonDZjmezwJWKaq6nt9iohEi0gK0AtY55/SjTHG1MdpR92oqkdEZgKLcYZXPqeq20XkMSBdVdOAZ4G5IpIFlOD8MsB33utAJuABHmiIETfGGGNOTfTL2UUBIjU1VdPT090uwxhjmhQRyVDVOseYB8TNWGOMMQ0n4Fr0IlII7D2Hb9EeKPJTOU2dXYuvs+vxb3Ytvi4Yrkc3Va1zNEvABf25EpH0U/35EmrsWnydXY9/s2vxdcF+PazrxhhjgpwFvTHGBLlgDPrZbhcQQOxafJ1dj3+za/F1QX09gq6P3hhjzNcFY4veGGNMLRb0xhgT5IIm6EXkShHZJSJZIvKQ2/W4SUQSRWS5iGSKyHYR+aHbNblNRMJFZKOIvOt2LW4TkTYiMl9EdorIDhEZ7XZNbhKR//D9nGwTkVdFpJnbNflbUAR9rV2wrgL6A7f5drcKVR7gv1S1PzAKeCDErwfAD4EdbhcRIP4CfKCqfYHzCOHrIiLxwINAqqoOxFnPa4q7VflfUAQ99dsFK2Soar6qbvA9PobzgxyyG76ISAJwDfCM27W4TURigbE4CxGiqlWqesTVotwXATT3LbEeAxxwuR6/C5agt52sTkFEkoEhwFqXS3HTn4H/Brwu1xEIUoBC4HlfV9YzItLC7aLcoqp5wO+BfUA+UKqqH7pblf8FS9CbOohIS2AB8CNVPep2PW4QkWuBQ6qa4XYtASICGAr8Q1WHAGVAyN7TEpG2OH/9pwBdgRYicru7VflfsAR9vXayCiUiEokT8i+r6kK363HRhcD1IpKD06V3mYi85G5JrsoFclX1y7/w5uMEf6i6HNijqoWqWg0sBC5wuSa/C5agr88uWCFDRASnD3aHqv7R7XrcpKr/o6oJqpqM8+9imaoGXYutvlT1ILBfRPr4XhqHszFQqNoHjBKRGN/PzTiC8Ob0aXeYagpOtQuWy2W56ULgDmCriGzyvfYzVX3PvZJMAPkB8LKvUZQNfNflelyjqmtFZD6wAWe02kaCcDkEWwLBGGOCXLB03RhjjDkFC3pjjAlyFvTGGBPkLOiNMSbIWdAbY0yQs6A3xpggZ0FvjDFB7v8BuWg8g2U3swkAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "plt.plot(norms)\n",
+    "plt.plot(norms_bound)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "038df7d5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7ff19ab5cb20>]"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.loglog(times,norms)\n",
+    "plt.loglog(times,norms_bound)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3bcc8be4",
+   "metadata": {},
+   "source": [
+    "Usually random Hamiltonian matrices give something $a\\approx 1.49$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "6cd3e03b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1.49083955, 3.49249848])"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "popt"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/dbi/dbi_imperfect_inversions.ipynb b/examples/dbi/dbi_imperfect_inversions.ipynb
new file mode 100644
index 0000000000..1592dc5bc5
--- /dev/null
+++ b/examples/dbi/dbi_imperfect_inversions.ipynb
@@ -0,0 +1,229 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.7|INFO|2024-05-21 13:57:42]: Using numpy backend on /CPU:0\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from qibo.hamiltonians import SymbolicHamiltonian\n",
+    "from qibo import symbols\n",
+    "from scipy.linalg import expm\n",
+    "from qibo import hamiltonians, set_backend\n",
+    "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n",
+    "\n",
+    "from copy import deepcopy\n",
+    "# Hamiltonian\n",
+    "set_backend(\"numpy\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def h(nqubits, alpha, beta):\n",
+    "    \"\"\"\n",
+    "    $H_nn = \\sum_{i=0}^{n-1}+\\alpha*\\sum_{i=0}^{n-2} Z_i Z_{i+2} + \\beta*\\sum_{i=0}^{n} X_i$\n",
+    "    \"\"\"\n",
+    "    op_list = [symbols.Z(i)*symbols.Z(i+1) for i in range(nqubits-1)]\n",
+    "    symbolHam = 0\n",
+    "    for op in op_list:\n",
+    "        symbolHam += op\n",
+    "        \n",
+    "    op_list = [symbols.Z(i)*symbols.Z(i+2) for i in range(nqubits-2)]\n",
+    "    for op in op_list:\n",
+    "        symbolHam += alpha*op\n",
+    "    op_list = [symbols.X(i) for i in range(nqubits)]\n",
+    "    for op in op_list:\n",
+    "        symbolHam += beta*op\n",
+    "    h = SymbolicHamiltonian(symbolHam, nqubits=nqubits)\n",
+    "    h = h.dense.matrix\n",
+    "    return h\n",
+    "\n",
+    "def x_inv_odd(nqubits):\n",
+    "    \"\"\"\n",
+    "    returns product of X_i for odd i\n",
+    "    $X_{odd} = \\prod_{i=0}^{n-1} X_{2i+1}$\n",
+    "    \"\"\"\n",
+    "    op_list = [symbols.X(i) for i in range(nqubits) if i%2==1]\n",
+    "    symbolHam = 1\n",
+    "    for op in op_list:\n",
+    "        symbolHam *= op\n",
+    "    h = SymbolicHamiltonian(symbolHam, nqubits=nqubits)\n",
+    "    h = h.dense.matrix\n",
+    "    return h\n",
+    "\n",
+    "def z_product(nqubits):\n",
+    "\n",
+    "    op_list = [symbols.Z(i) for i in range(nqubits)]\n",
+    "    symbolHam = 1\n",
+    "    for op in op_list:\n",
+    "        symbolHam *= op\n",
+    "    h = SymbolicHamiltonian(symbolHam, nqubits=nqubits)\n",
+    "    h = h.dense.matrix\n",
+    "    return h"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "alpha = np.linspace(0,1,50)\n",
+    "beta = np.linspace(0,1,50)\n",
+    "nqubits = 5\n",
+    "x = x_inv_odd(nqubits)\n",
+    "inversion_measure = np.empty((len(alpha),len(beta)))\n",
+    "for a in range(len(alpha)):\n",
+    "    for b in range(len(beta)):\n",
+    "        ham = h(nqubits,alpha[a],beta[b])\n",
+    "        inversion_measure[a,b] = np.linalg.norm(ham+x@ham@x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "mesh_alpha, mesh_beta = np.meshgrid(alpha,beta)\n",
+    "plt.contourf(mesh_alpha,mesh_beta,inversion_measure,levels=50)\n",
+    "plt.title(r\"$||H+X_{odd} H X_{odd}||$\")\n",
+    "plt.xlabel(r\"2nd coupling\")\n",
+    "plt.ylabel(r\"External Field\")\n",
+    "plt.colorbar()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def imperfect_gci(H,D,s,inversion,order):\n",
+    "    U = expm(1j*np.sqrt(s/order)*D)@expm(1j*np.sqrt(s/order)*H)@expm(-1j*np.sqrt(s/order)*D)\n",
+    "    U_order = np.linalg.matrix_power(U,order) \n",
+    "    U_dag = expm(-1j*np.sqrt(s/order)*D)@inversion@expm(1j*np.sqrt(s/order)*H)@inversion@expm(1j*np.sqrt(s/order)*D)\n",
+    "    U_dag_order = np.linalg.matrix_power(U_dag,order)\n",
+    "\n",
+    "    return U_dag_order@H@U_order\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x217ffa48a60>"
+      ]
+     },
+     "execution_count": 73,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "H = h(nqubits,1,3)\n",
+    "d = np.diag(np.linspace(0,2**nqubits,2**nqubits))\n",
+    "hamiltonian = hamiltonians.Hamiltonian(nqubits, H)\n",
+    "dbi = DoubleBracketIteration(deepcopy(hamiltonian),mode=DoubleBracketGeneratorType.single_commutator,cost=DoubleBracketCostFunction.least_squares)\n",
+    "s = np.linspace(0,0.1,100)\n",
+    "inversion = x_inv_odd(nqubits)\n",
+    "off_diagonal_norm = np.empty((len(s),3))\n",
+    "for step in range(len(s)):\n",
+    "    dbi_eval = deepcopy(dbi)\n",
+    "    h_gci = imperfect_gci(H,d,s[step],inversion,1)\n",
+    "    off_diagonal_norm[step,0] = np.linalg.norm(h_gci-np.diag(np.diag(h_gci)))\n",
+    "    dbi_eval(s[step],d=d)\n",
+    "    off_diagonal_norm[step,1] = dbi_eval.off_diagonal_norm\n",
+    "    dbi_eval = deepcopy(dbi)\n",
+    "    dbi_eval.mode = DoubleBracketGeneratorType.group_commutator\n",
+    "    order = 1\n",
+    "    for _ in range(order):\n",
+    "        dbi_eval(s[step]/order,d=d)\n",
+    "    off_diagonal_norm[step,2] = dbi_eval.off_diagonal_norm\n",
+    "\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(s,off_diagonal_norm[:,1],label=\"DBI\")\n",
+    "plt.plot(s,off_diagonal_norm[:,2],label=\"GCI\")\n",
+    "plt.plot(s,off_diagonal_norm[:,0],label=\"Imperfect GCI\")\n",
+    "plt.xlabel(r\"Step Size\")\n",
+    "plt.ylabel(r\"Off Diagonal Norm\")\n",
+    "plt.legend()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "dbi",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "43f1f904380137ff38e17e8a93371c4872e6bababc18e270d8a0497ea5c7ea38"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/dbi/dbi_misc.ipynb b/examples/dbi/dbi_misc.ipynb
new file mode 100644
index 0000000000..1a8a4da3e7
--- /dev/null
+++ b/examples/dbi/dbi_misc.ipynb
@@ -0,0 +1,944 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from copy import deepcopy\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from qibo import hamiltonians, set_backend\n",
+    "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n",
+    "from qibo.models.dbi.utils import *\n",
+    "from qibo.models.dbi.utils_scheduling import *"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Normalization of D"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.5|INFO|2024-03-21 14:14:06]: Using qibojit (numba) backend on /CPU:0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"qibojit\", \"numba\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 7\n",
+    "h = 3.0\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# define the least-squares cost function\n",
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "factor = np.array([1,2**nqubits])\n",
+    "s_space = np.linspace(1e-5, 1.0, 100)\n",
+    "off_diagonal_norm_diff = np.empty((len(factor)+1,len(s_space)))\n",
+    "potential = np.empty((len(factor)+1,len(s_space)))\n",
+    "for i in range(len(factor)):\n",
+    "# generate data for plotting sigma decrease of the first step\n",
+    "    d = np.diag(np.linspace(1,2**nqubits,2**nqubits))/factor[i]\n",
+    "    for s in range(len(s_space)):\n",
+    "        dbi_eval = deepcopy(dbi)\n",
+    "        dbi_eval(s_space[s],d=d)\n",
+    "        off_diagonal_norm_diff[i,s] = (dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n",
+    "        potential[i,s] = dbi_eval.least_squares(D=d)\n",
+    "    \"\"\"\n",
+    "    # grid_search\n",
+    "    step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search,d=d)\n",
+    "    print('grid_search step:', step_grid)\n",
+    "    # hyperopt\n",
+    "    step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d, max_evals=100, step_max=0.6)\n",
+    "    print('hyperopt_search step:', step_hyperopt)\n",
+    "    # polynomial\n",
+    "    step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d, n=3)\n",
+    "    print('polynomial_approximation step:', step_poly)\n",
+    "    \"\"\"\n",
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "step = 1e-2\n",
+    "iterations = 200\n",
+    "d, loss, grad, diags = gradient_ascent(dbi, d,step, iterations)\n",
+    "for s in range(len(s_space)):\n",
+    "        dbi_eval = deepcopy(dbi)\n",
+    "        dbi_eval(s_space[s],d=d)\n",
+    "        off_diagonal_norm_diff[2,s] = (dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)\n",
+    "        potential[2,s] = dbi_eval.least_squares(D=d)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Least squares cost function')"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlYAAAHFCAYAAAAwv7dvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9eZgU1b0+/vY+ezMw7CKoKAEBFYmKGpcYcNdI7tVcDJGrwRi9IQomUXONSx7FuMar94teY2ISySW/ew25iUSE4B4FccGAEFwRiMPO7DO91u+P7nPq1KlzTp3q6ZnumTnv8/DodFd1V3VVnfM57+f9vJ+AZVkWDAwMDAwMDAwMuo1gqQ/AwMDAwMDAwKC/wARWBgYGBgYGBgZFggmsDAwMDAwMDAyKBBNYGRgYGBgYGBgUCSawMjAwMDAwMDAoEkxgZWBgYGBgYGBQJJjAysDAwMDAwMCgSDCBlYGBgYGBgYFBkWACKwMDAwMDAwODIsEEVgYGBr7x1FNPIRAI0H8VFRUYMWIEzjzzTCxevBh79uwp2bH99re/xc9+9rOSfX+5IBAI4Pbbb6d/v/TSSwgEAnjppZd69Thuv/12BAKBXv1OA4NSwgRWBgYGBeOXv/wl3njjDaxevRr/+Z//iWOPPRY//elPMXHiRPzlL38pyTGZwEqMadOm4Y033sC0adNKfSgGBv0a4VIfgIGBQd/F5MmTMX36dPr31772Ndxwww049dRTMXv2bHz44YcYPnx4CY+wPJBKpRAIBBAOl27Iraurw0knnVSy7zcwGCgwjJWBgUFRceihh+KBBx5Aa2srHn/8ceW2JKX44osv4jvf+Q4aGhowZMgQzJ49G59//rlj22w2i3vvvRdf+MIXEIvFMGzYMHzzm9/Ezp076TZnnHEGVqxYgc8++8yRqlRh3LhxuOCCC7By5UpMmzYNlZWV+MIXvoBf/OIXrm03bdqEiy++GPX19aioqMCxxx6LX/3qV45tSMrtN7/5DRYtWoTRo0cjFovho48+wrx581BTU4O///3vOPvss1FdXY2RI0finnvuAQCsXbsWp556Kqqrq3HUUUe5Pnvv3r249tprMWnSJNTU1GDYsGH48pe/jFdffVV5juxxkVTgtm3bHL8R/4/FX/7yF5x11lmoq6tDVVUVTjnlFKxZs8b1HStWrMCxxx6LWCyGww47DPfff7/ncRkY9DcYxsrAwKDoOO+88xAKhfDKK69obf+tb30L559/Pn77299ix44d+P73v49vfOMbeOGFF+g23/nOd/Bf//Vf+Ld/+zdccMEF2LZtG2699Va89NJLeOedd9DQ0ID/9//+H66++mp8/PHHWL58ufbxvvfee1i0aBFuuukmDB8+HD//+c9x1VVXYfz48TjttNMAAFu3bsXJJ5+MYcOG4T/+4z8wZMgQPP3005g3bx52796NH/zgB47PvPnmmzFjxgw89thjCAaDGDZsGIAcezV79mxcc801+P73v4/f/va3uPnmm9HS0oJnnnkGP/zhD3HIIYfgkUcewbx58zB58mQcf/zxAIADBw4AAG677TaMGDECbW1tWL58Oc444wysWbMGZ5xxhvY5jxw5Em+88Ybjtb179+Ib3/gGRo8eTV97+umn8c1vfhMXX3wxfvWrXyESieDxxx/H2Wefjeeffx5nnXUWAGDNmjW4+OKLMWPGDCxbtgyZTAb33nsvdu/erX1MBgb9ApaBgYGBT/zyl7+0AFjr16+XbjN8+HBr4sSJWp9z7bXXOl6/9957LQBWY2OjZVmWtWXLFuF269atswBYt9xyC33t/PPPt8aOHat9LmPHjrUqKiqszz77jL7W2dlpDR482Pr2t79NX/v6179uxWIxa/v27Y79zz33XKuqqspqamqyLMuyXnzxRQuAddppp7m+64orrrAAWM888wx9LZVKWUOHDrUAWO+88w59ff/+/VYoFLIWLlwoPfZ0Om2lUinrrLPOsi655BLHewCs2267jf5NjuvFF18UflZ7e7t1wgknWCNHjrS2bdtGXxs8eLB14YUXOrbNZDLWMcccY51wwgn0tRNPPNEaNWqU1dnZSV9raWmxBg8ebJmpxmAgwaQCDQwMegSWZWlve9FFFzn+njp1KgDgs88+AwC8+OKLAIB58+Y5tjvhhBMwceJEYVrKD4499lgceuih9O+KigocddRR9PsB4IUXXsBZZ52FMWPGOPadN28eOjo6XOzP1772NeF3BQIBnHfeefTvcDiM8ePHY+TIkTjuuOPo64MHD8awYcMcxwAAjz32GKZNm4aKigqEw2FEIhGsWbMGW7Zs8X/ieWQyGVx22WXYsmUL/vznP2Ps2LEAgNdffx0HDhzAFVdcgXQ6Tf9ls1mcc845WL9+Pdrb29He3o7169dj9uzZqKiooJ9bW1uLCy+8sODjMjDoizCpQAMDg6Kjvb0d+/fvx5QpU7S2HzJkiOPvWCwGAOjs7AQA7N+/H0AufcVj1KhRruDDL/jvJ8dAvp8cg+z72WMkEG0LAFVVVY7gAwCi0SgGDx7s2jYajaKrq4v+/eCDD2LRokW45ppr8JOf/AQNDQ0IhUK49dZbuxVYXXPNNVi5ciXVSBGQNN4//dM/Sfc9cOAAAoEAstksRowY4Xpf9JqBQX+GCawMDAyKjhUrViCTyfjS/KhAAp/GxkYccsghjvc+//xzNDQ0FOV7vI6hsbHR9ToR2fPH0BPeTU8//TTOOOMMLFmyxPF6a2trwZ95++234+c//zl++ctfYtasWY73yDk98sgj0orC4cOH06rHXbt2ud4XvWZg0J9hUoEGBgZFxfbt23HjjTciHo/j29/+dlE+88tf/jKAXGDBYv369diyZQsVUANupqlYOOuss/DCCy+4qhV//etfo6qqqlesDAKBAGXzCP72t7+50pC6ePLJJ3HHHXfgzjvvdKVZAeCUU07BoEGDsHnzZkyfPl34LxqNorq6GieccAJ+//vfOxi21tZW/OlPfyro2AwM+ioMY2VgYFAwNm3aRHU3e/bswauvvopf/vKXCIVCWL58OYYOHVqU75kwYQKuvvpqPPLIIwgGgzj33HNpVeCYMWNwww030G2nTJmC3//+91iyZAmOP/54BINBh9dWobjtttvw7LPP4swzz8SPf/xjDB48GEuXLsWKFStw7733Ih6Pd/s7vHDBBRfgJz/5CW677Tacfvrp2Lp1K+68804cdthhSKfTvj7rjTfewDXXXINTTjkFM2fOxNq1ax3vn3TSSaipqcEjjzyCK664AgcOHMA//dM/YdiwYdi7dy/ee+897N27l7JnP/nJT3DOOedg5syZWLRoETKZDH7605+iurqaVjMaGAwEmMDKwMCgYPzrv/4rgJwWaNCgQZg4cSJ++MMf4lvf+lbRgiqCJUuW4IgjjsCTTz6J//zP/0Q8Hsc555yDxYsXOzRS3/ve9/D+++/jlltuQXNzMyzL8iWkl2HChAl4/fXXccstt+C6665DZ2cnJk6ciF/+8pdCtqcn8KMf/QgdHR148sknce+992LSpEl47LHHsHz5ct+tarZu3Yp0Oo2//vWvmDFjhut98pt94xvfwKGHHop7770X3/72t9Ha2ophw4bh2GOPdZz3zJkz8Yc//AH//u//jssuuwwjRozAtddei87OTtxxxx3dOW0Dgz6FgFWMEcfAwMDAwMDAwMBorAwMDAwMDAwMigUTWBkYGBgYGBgYFAkmsDIwMDAwMDAwKBJMYGVgYGBgYGBgUCSYwMrAwMDAwMDAoEgwgZWBgYGBgYGBQZFgfKx6GdlsFp9//jlqa2t7pOWFgYGBgYGBQfFhWRZaW1sxatQoBINyXsoEVr2Mzz//HGPGjCn1YRgYGBgYGBgUgB07drh6lrIwgVUvo7a2FkDuwtTV1ZX4aAwMDAwMDAx00NLSgjFjxtB5XAYTWPUySPqvrq7OBFYGBgYGBgZ9DF4yHiNeNzAwMDAwMDAoEkxgZWBgYGBgYGBQJJjAysDAwMDAwMCgSDCBlYGBgYGBgYFBkWACKwMDAwMDAwODIsEEVgYGBgYGBgYGRYIJrAwMDAwMDAwMigQTWBkYGBgYGBgYFAkmsDIwMDAwMDAwKBJMYGVgYGBgYGBgUCSYwMrAwMDAwMDAoEgwgZWBgYGBgYGBQZFgAisDAw90JjOlPgQDAwMDgz4CE1gZGCiw9pP9mHL783jilU9KfSgGBgYGBn0AJrAyMFBg0z+akc5a2LCzqdSHYmBgYGDQB2ACKwMDBZKZLAAgk7FKfCQGxUZLVwpNHclSH4aBgUE/gwmsDAwUSKVzAVXGMoFVf4JlWTjv4Vdx1gMvI5nOlvpwDAwM+hFMYGVgoECKMFZZE1j1JyQzWew82In97Um0dqVKfTgGBgb9CCawMjBQgARWaRNY9SukmdSuCZoNDAyKCRNYGRgokMpPwFkz+fYrkIAZMEGzgYFBcVHSwGrJkiWYOnUq6urqUFdXhxkzZuC5556j7wcCAeG/++67j25zxhlnuN7/+te/7viegwcPYu7cuYjH44jH45g7dy6ampoc22zfvh0XXnghqqur0dDQgAULFiCZdApbN27ciNNPPx2VlZUYPXo07rzzTlhGe9OvYTNWRofTn5BkAytTmGBgYFBEhEv55YcccgjuuecejB8/HgDwq1/9ChdffDHeffddHH300WhsbHRs/9xzz+Gqq67C1772Ncfr8+fPx5133kn/rqysdLw/Z84c7Ny5EytXrgQAXH311Zg7dy7+9Kc/AQAymQzOP/98DB06FK+99hr279+PK664ApZl4ZFHHgEAtLS0YObMmTjzzDOxfv16fPDBB5g3bx6qq6uxaNGi4v4wBmUDo7Hqn0gxwZQJmg0MDIqJkgZWF154oePvu+66C0uWLMHatWtx9NFHY8SIEY73/+///g9nnnkmDj/8cMfrVVVVrm0JtmzZgpUrV2Lt2rU48cQTAQBPPPEEZsyYga1bt2LChAlYtWoVNm/ejB07dmDUqFEAgAceeADz5s3DXXfdhbq6OixduhRdXV146qmnEIvFMHnyZHzwwQd48MEHsXDhQgQCgWL9LAZlhKQJrPol0gxjZa6tAQC8+ekB/KOpA5ccd0ipD8Wgj6NsNFaZTAbLli1De3s7ZsyY4Xp/9+7dWLFiBa666irXe0uXLkVDQwOOPvpo3HjjjWhtbaXvvfHGG4jH4zSoAoCTTjoJ8Xgcr7/+Ot1m8uTJNKgCgLPPPhuJRAJvv/023eb0009HLBZzbPP5559j27Zt3T5/g/IEYTbM5Nu/YDRWBjyuX/Yubvjde/i8qbPUh2LQx1FSxgrI6ZZmzJiBrq4u1NTUYPny5Zg0aZJru1/96leora3F7NmzHa9ffvnlOOywwzBixAhs2rQJN998M9577z2sXr0aALBr1y4MGzbM9XnDhg3Drl276DbDhw93vF9fX49oNOrYZty4cY5tyD67du3CYYcdJjy/RCKBRCJB/25paVH9HAZlhlR6YFUFZrIWQsH+z74m06Yq0MCJps6c7UZrV7rER9Lz+LypE+s+3Y8Lpo5CJFQ2/Eq/QckDqwkTJmDDhg1oamrCM888gyuuuAIvv/yyK7j6xS9+gcsvvxwVFRWO1+fPn0//f/LkyTjyyCMxffp0vPPOO5g2bRoACNN0lmU5Xi9kGyJcV6UBFy9ejDvuuEP6fl9ENmth58FOHDqkqtSH0uMYSBqr5o4UZj70Ms6cMAw//aeppT6cHgWrqxooQbOBGqSIYSBo7u7+8xY8+7dG1MQimDlpuPcOBr5Q8lA1Go1i/PjxmD59OhYvXoxjjjkGDz/8sGObV199FVu3bsW3vvUtz8+bNm0aIpEIPvzwQwDAiBEjsHv3btd2e/fupYzTiBEjKDNFcPDgQaRSKeU2e/bsAQAX28Xi5ptvRnNzM/23Y8cOz3Mod/zsLx/gtPtexOrN7t+1vyGVHTipwA/2tGJPawJ//XhfqQ+lx5FyaKz6/0RqoIZlWQNKT3mgPVfxfrDdtHTqCZQ8sOJhWZYjdQYATz75JI4//ngcc8wxnvu///77SKVSGDlyJABgxowZaG5uxptvvkm3WbduHZqbm3HyySfTbTZt2uSoQly1ahVisRiOP/54us0rr7zisGBYtWoVRo0a5UoRsojFYtROgvzr6/h4XzsAYFv+v/0ZJBU4EAZbEmwMBM8uNhVo7BYMWNZyIDCYNjvX/8+1FChpYHXLLbfg1VdfxbZt27Bx40b86Ec/wksvvYTLL7+cbtPS0oL/+Z//EbJVH3/8Me6880689dZb2LZtG/785z/jn//5n3HcccfhlFNOAQBMnDgR55xzDubPn4+1a9di7dq1mD9/Pi644AJMmDABADBr1ixMmjQJc+fOxbvvvos1a9bgxhtvxPz582kgNGfOHMRiMcybNw+bNm3C8uXLcffddw/IisCBpDuiqcAB4FeWGkCDLZvuGQhBs4EaqQHma2azc4at7QmUVGO1e/duzJ07F42NjYjH45g6dSpWrlyJmTNn0m2WLVsGy7LwL//yL679o9Eo1qxZg4cffhhtbW0YM2YMzj//fNx2220IhUJ0u6VLl2LBggWYNWsWAOCiiy7Co48+St8PhUJYsWIFrr32WpxyyimorKzEnDlzcP/999Nt4vE4Vq9ejeuuuw7Tp09HfX09Fi5ciIULF/bET1PWIA9ldkAEG/kgcgAMtgORnQMGRiBpoMZA8zUj52ju/Z5BSQOrJ5980nObq6++GldffbXwvTFjxuDll1/2/IzBgwfj6aefVm5z6KGH4tlnn1VuM2XKFLzyyiue39ffMZCCjeQAslsYSH0RTVWgAYvUAPM1o6nAATCGlwJlp7EyKH+k0iTY6P8ru4EUbAwkob5hrAxYDLT7ITmAxrVSwARWBr6RHFC6owGU9qTauf4fMDs1Vv3/fA3USLEM5gBgcdKZgbM4LgVMYGXgG8kBJF63KfP+PwDZVYElPpBeADuRDoT72EANR1PuAfAApA1j1aMwgZWBb9BKuQGwshtI3jZ22rP/TyzJAaapMVBjoBnGJo3GqkdhAisD3xhYFgQD6Vxz55i1+r+XVXqAldcbqJEaYMUMpiqwZ2ECKwPfGEiNiQeqBUF/DyTZ8vqBcG0N1EgOsEDbaKx6FiawMvCNgZUeGzimmQOp5Dw5wKrADNQYSPc+YKoCexomsDLwjeQAYXHY/mHWAEiPOU0S+/u5Fl4VuKelq9/f+wMN7P2QGgAsTnoAeRGWAiawMvCNgeLtxJ9f/0+PDZxVe7rAIPJvO5twwt1rcNsfN/XEYRkUAZ3JDF75YC9dAOogPYBSw5msBXKK/X0MLxVMYGXgGwOlWW+Ks1jo7wPuQAqsCj3XD3e3Of5rUH5Y8vLH+OYv3sT/99YO7X0GksaqO2ytgR5MYGXgC5ZlDRjdUYobYPt/sDFw+qUVqrEaSPrCvopdzZ0AcilbXQykRQV7v/f3MbxUMIGVgS8kB1TlmDO46O+D0ICaXNgg0of5ayKVAWC3/+kr2HmwA6s374bVz59ZwF4g+LlGA6mlTXoAPeelggmsDHzBUaY+gChzoP8PQqkBmg4pjLHqW4zeTc9sxPxfv4X3djb72u/37+zEXz/a10NH1TOgFW8+AmaHE38/77IwkNKepYIJrAx8IZUeOCs7drAFBkJgNXAEvIU6r9N2Tn1sQtrbmgAA7Mv/Vwe7W7qw8P97D99btqGHjqpnQMYoPpWv3GcAOa+nB1DKv1QwgZWBL7Ar/f7emDg5gBmr/p7mLbQqMNFH+2QWUsnb0pkCALR2pXrkmHoKhbRmYheM/f05H0gVkKWCCawMfCExkBgrl8aqf6/uBpLGqtBz7aseboWI7hN99FxTBfTBG0gebsYct+dhAisDX3AwVv38oeQDq34eVzknlz6W6vKLQvVkCZpm6ls3Q0EsDsNy9SXRe7IAVtGZGu5b19YvHA2n+/lzXiqYwMrAFwZSST6v0ej/5ztwGKukIx3ioyqwj7I46W6yOH3pfAsSr7PO6/082DAaq56HCawMfGEgTb4Duiqwnw+46UKrAgsQRpcDkgUwVsk+mvYn97Efu4WBpDsqtHDDQB8msDLwhcQAEnkOPB8r+/z6e2FCoQuERDqT36dvBZ6FiNf7qrdTqpuMVV8610JQaOGGgT5MYGXgC4ax6r8YSD5WyQInl0L0O+UAEjQXIl4H+pZnXSHi9QGlsRpAz3mpYAIrA18YSCu75ADzsUoOIDayUPdpW7/Td36fTNai5+jL26mPpoZpunYAsHOFwFQF9jxMYGXgCwOZservg9BA6iFW6ESaSPU98XqhTXf76rNeUCrQ4bzed861EKQLLNww0IcJrAx8gWVx+tJgWwhcdgtGd9RvkCpwcklSYXTfmZAKrXhjGcy+1BuxEFaRvZ79/d5PDyCX+VLBBFYGvjCQmjDzA3N/X8kOpHZFjoo3Xz5WOfG6ZfUdH7dCK94cgXYfuvdpSxtf7NzAsSBw6At9Xte3PzuAd7YfLPYh9TuYwMrAFwZS64cB19ImO3DYyHSBDIWTxekbE3DhDaf7ZrBRiFB/II1rheoLO5MZXP7zdZj783X9vlF1dxEu9QEY9C0MpMoxV1VgP2foBmoqsJCqQKDv/EYOsbKPCbEv+lhZlmWnawsW6veNcy0UhRqE7m1NoCuvMUykswiHDC8jg/llDHxhIDVhdtst9O9VmjMVOHDOtVALgr5iElqog3pfXEQ5CjD8BJF98FwLRaEGofvaE/T/+3vw2V2YwMrAFwZWE+YBprEaQO7TqWxhQWRfZKyKIV7vi+fqZ3waSG1e0gXeD/tamcDKpAKVMIGVgS843Ln7yGBbKNiJBejfDJ1lWVyw0X/PFSg8iEz2QVbPGSAV2D+vj5wra5vgp1H2QE2D+znX/e3JgvYbiDCBlYEvDCQtwkDyscpkLbBxY38eOLOMYSbg08eqwGrCUqJw8XrfCzYKTekNqHGtQLZ2f5vNWPUl+41SwARWBr4wsFZ2A6cqkE8J+DnXt7YdwFf/86/YsKOpyEfVM+DZF91zZYXRfvYrNZy6owLZuT4SRDpdxf1orAZOGrxQ+419bQxj1Ufuh1LBBFYGvtAXdReFojvBRl9DocEGADz7t0Zs2NGElZt2FfuwegSFaucSXGrYT6qplCjUn6wvLqJSBRYXFKpDKzWaO1P49z9sxNuf6XtL8edqaUoc2FRgX0kNlwomsDLwhb64Yi8UAykVmEoXfq5dqZxpZl8RtLrPVe+4+6qvWaENhtkAo69MpM5KRv1jThf4G5Uaf9m8G0+v3Y7HXv5Yex8+cNS9jdlUYF+590sFE1gZ+IJjFduPxdzAQE8F6k8uhMnpK4FnoQEzX8zQV5gNZ4BUYFVgHznXpENw74exKkxzV2p0JNMA7MWNDviAU3dhsZ9JBfYVtrZUKGlgtWTJEkydOhV1dXWoq6vDjBkz8Nxzz9H3A4GA8N99991Ht0kkEvjud7+LhoYGVFdX46KLLsLOnTsd33Pw4EHMnTsX8Xgc8Xgcc+fORVNTk2Ob7du348ILL0R1dTUaGhqwYMECJJNJxzYbN27E6aefjsrKSowePRp33nmnNo3aX5DiegX25/MfUKnAbrBzZFDvK4MtP+HqXlc+FdhX7odCW9Mk+6Cgu+Bqzz7KxBNtGB/0q1DognF/u2GsdFHSwOqQQw7BPffcg7feegtvvfUWvvzlL+Piiy/G+++/DwBobGx0/PvFL36BQCCAr33ta/Qzrr/+eixfvhzLli3Da6+9hra2NlxwwQXIZOwIfs6cOdiwYQNWrlyJlStXYsOGDZg7dy59P5PJ4Pzzz0d7eztee+01LFu2DM888wwWLVpEt2lpacHMmTMxatQorF+/Ho888gjuv/9+PPjgg73wS5UPBhKL09Opn03/aMa//2Gjg2IvFVzX1ccEbKcC+8a94EoFah43P3n1FbuFVKGC7j5oLcHrwnQXfn3RDBWwr5EvawluHNMJmjNZCwdYjVUJfqOuVAbn/OwV3Pz7jb3+3X5R0pY2F154oePvu+66C0uWLMHatWtx9NFHY8SIEY73/+///g9nnnkmDj/8cABAc3MznnzySfzmN7/BV77yFQDA008/jTFjxuAvf/kLzj77bGzZsgUrV67E2rVrceKJJwIAnnjiCcyYMQNbt27FhAkTsGrVKmzevBk7duzAqFGjAAAPPPAA5s2bh7vuugt1dXVYunQpurq68NRTTyEWi2Hy5Mn44IMP8OCDD2LhwoUIBAI9/XOVBRKCNi/9tS9Sd3RHOvj5q5/gDxs+x5HDanHFyeOK+tl+4WLnfDCRhMnpizocwA9j5Uy39BUWp9DWNH1dvA7k7uto2Hts7qtdB5IFpOFdqUCNIKmpI+nQYpXifvhkbzv+vqsVu1q6sHj2lF7/fj8oG41VJpPBsmXL0N7ejhkzZrje3717N1asWIGrrrqKvvb2228jlUph1qxZ9LVRo0Zh8uTJeP311wEAb7zxBuLxOA2qAOCkk05CPB53bDN58mQaVAHA2WefjUQigbfffptuc/rppyMWizm2+fzzz7Ft27bi/Ah9APzA1VcG3ELQ0y1tOpK5iZpdCZYK3WEiCWPVV+4FV1VggRqrvsJssOfX31va8CyzbpDUVxuQk2vkLxXI3//e++7nxqhSFKqQhY2fcy0VSh5Ybdy4ETU1NYjFYrjmmmuwfPlyTJo0ybXdr371K9TW1mL27Nn0tV27diEajaK+vt6x7fDhw7Fr1y66zbBhw1yfN2zYMMc2w4cPd7xfX1+PaDSq3Ib8TbYRIZFIoKWlxfGvL2MgVcqRc4vmm436GUt+/85OfOPn69DUIQ+ayOe3dqULP8giwT0h+Qms8qvmPjL5Fhow94dUoJ+UUV9MBRZSYGBZVp81CCXPbaFMJKAXSO7j5Aql+I0KSXuWCiUPrCZMmIANGzZg7dq1+M53voMrrrgCmzdvdm33i1/8ApdffjkqKio8P9OyLEdqTpSmK8Y2JH+vSgMuXryYiubj8TjGjBnjefzlDFepbh8ahPyCPMgVERJY6T/Qv1n7GV77aB/WfrJfug0ZIFq6Ut04yuKAD4r8NSbuY+L1AoNIXrzeVybgQr3nkn2wUs7tUeZ9T7q6DvhcIOw40OGrKq+YKCTY4J91nQURaw4KlCbQppKDjFX2807JA6toNIrx48dj+vTpWLx4MY455hg8/PDDjm1effVVbN26Fd/61rccr48YMQLJZBIHDzrN0fbs2UPZpBEjRmD37t2u7927d69jG551OnjwIFKplHKbPXv2AICLyWJx8803o7m5mf7bsWOHdNu+APeqvbxv8O6ADFYVkRAAf+fansixUEnFoEUGtJbO0gdWrmDDl3i9b9ktkFV+LEwC5v6dCnTYLfhyXreDhb6SHiskaC40NQwAH+5uxen3vYh/++272vsUEzTY6EZVoM758gU2pbj32YUNz7CXG0oeWPGwLAuJhPMiPvnkkzj++ONxzDHHOF4//vjjEYlEsHr1avpaY2MjNm3ahJNPPhkAMGPGDDQ3N+PNN9+k26xbtw7Nzc2ObTZt2oTGxka6zapVqxCLxXD88cfTbV555RWHBcOqVaswatQojBs3Tno+sViM2kmQf30Z/A1d7JXDp/va8eLWPUX9zEJBBlwSWPk5V6KfUq2YyaqvHFOB/nys8ueq+H3aE2k8vfYz7G7pKuwAiwgyKVRF/QXMbruF8h7cCQoVoTu8nfpIEMnfxzpMTqG6LAD460f7kLWAbfvbtfcpJsj5+fLsctmNaGisXIxV6VKBQPmz4yUNrG655Ra8+uqr2LZtGzZu3Igf/ehHeOmll3D55ZfTbVpaWvA///M/LrYKAOLxOK666iosWrQIa9aswbvvvotvfOMbmDJlCq0SnDhxIs455xzMnz8fa9euxdq1azF//nxccMEFmDBhAgBg1qxZmDRpEubOnYt3330Xa9aswY033oj58+fTQGjOnDmIxWKYN28eNm3ahOXLl+Puu+8eUBWBQM9rrBb897v411+ux8d724r6uYWAnGtlAYxVZ9LbgoCwWWWZCvRTFUg1VvLB7o/vfY5//8Mm/OwvHxZ2gEUEz0T296rAQvVDhdo0lBKFMK9uw0z932jjP1qEn9FbKCwVWABj1V56jRX7/JW7gL2klfK7d+/G3Llz0djYiHg8jqlTp2LlypWYOXMm3WbZsmWwLAv/8i//IvyMhx56COFwGJdeeik6Oztx1lln4amnnkIoFKLbLF26FAsWLKDVgxdddBEeffRR+n4oFMKKFStw7bXX4pRTTkFlZSXmzJmD+++/n24Tj8exevVqXHfddZg+fTrq6+uxcOFCLFy4sNg/S1mjp32s9rbmHuBdzV04YmhNUT/bL5J0AvaXMgJsxkplQUAGuHJgrLpVFZj2DiIP5kX8Ow92FHB0xQUfMBO/I68Fkp9U4Osf7cOhQ6pwSH1VN4+2+3AYfRYsXu8jQWQBUgU+FWhZOXY6GPReMG/6R7PwM3oLyWKkAgvRWJUgkEz2oVRgSQOrJ5980nObq6++GldffbX0/YqKCjzyyCN45JFHpNsMHjwYTz/9tPJ7Dj30UDz77LPKbaZMmYJXXnlFfcD9HPzkUuzAiqyM2xLlE2z4ZTayWQudxI1cMeCly4ixKlRjlcladFJRB5G5bUjgXErwKV4gdx7hkHoi1RWvf7SnFXN+vg7HHBLH//3bqd082u6DvZYFu5H3kVRgIVYCIrYnnbUQ9QisOpMZfLinVft7egIFpQIL0JSVncaqzBmrstNYGZQ3uiP09PP57WUQWJHBo9KnFqeLoaxV+6QYjVWpWwMVGjCz9LxqsCUrXL5suxSgjFXUDqx0rq2bsRIP7ntacue4ubGlLETfDrsFX02Y2f1Kfx46cOmlNAIAsk+ECax1rtvmxhZqmlkqDRo5dl+pwCz/rOv7WA2ujuY/w2isVDCBlYEvuMTrRQ4IyGRVDoEVZazC/hgrkgbMfYZ3VWAmazn2KQX4gVI7iEzppYvIxHygPVnyYCPFpXgBvWur6/VlT3ZWWaU+AZ+9Ah02DeU9kRG4fay8jzstYDB1AtCNO5t8fU9PgLA4lqU/PrH9XgG9oJCI14fV5gyyS2O3kGH+v7zvRxNYGfhCd8ry9T4/93ltidIGGoDAx0oziOxMsiyOt8YKKH060KWx0jxX1r9H51yzVumd5sk9Vhnxx1glUvy9Lz5f9pn4ZF9pqsVYJJmJVDdgzmQtRwuTPqOxKshuwZnyB/QCUCJc1/2enkAh5q980OgVkHWlMlSaMSKe85EsBUOXNKlAg/6KntZYkYe+PBgrZypQd7XvYKw0WBwAaOks7fm6rqvmuSY0Bc4sc1fqdCCZgGKcxsoLyYxeVSC7mv9kb+kDq0KqAvuuZ1fhdgvE1wzQ+52IcB0oYSqwAEE3f6xeaV6SBoyGgqivIqnAUjBWbBBZ3vejCawMfIEMVKG8sNNPWb4XWAfkchSv605KHUn72FUDO8t4tJacsSo0FcimPRXnygzEZRNYhYIg+mSdiULXHJf9LT/dVz62IYB+NZfb16y8JzICt/O6BmOVv67RcJDqrLzOlxWuA6VrQO6o3NQMNsj9QIpgvdK8RLg+pCaKcP6BKY3dgmGsDPohcj21cg9UFa2UK94Nzk4ApWasslmLDh7UILTIqUB2Eih1KpAcpz2x6F1XNrBSTUbpsmKscscSCQURDupbabgNQr0Zq0/LIBVYiEGoO6VW3hMZQSFmn+R+iIaCdMHotR8RrhOZgB+NUzFRUCqQS4V7BWREXzWkJkorZ0teFZgpvVREBRNYGWiDDQRiNLAq5uczgVWytIEVuwL1axCqK15nz7fUqcBC2Tldet6RCmwttcYqH0SGA/ZEqlM9ppkeY8+1PFKB9vHoVvf1dMq/p8Dbm+ikjMizzgbaXvcDSQNOHT2I+a7Sejvpfj8JGnVtZPYSxqo6Zv8+JTcILe/70QRWBtpgH9zKKHnAijeYsINZqcXr7IBc6ZOdY4NC1e/DDk6lTgUmuVWs7kTqEK8rz7X8UoHhYJCmNgphrGTnyz4njc1djtRwKVAMxqrcNS0EhRjdkmAsHGICbY/9NuYDq+MOHURfK4kFQUZvYcOCnG9FXlPmqbFiGCt7IVLaILLcDUJNYGWgDfbG9jsB64BliUqdCmQHDkL369LfzlSgeB/Lshy/XUuJ3dfTGX+rWAKH3YKGtQRQepNQmvoJBxEK6aV+APv+j4TUky//O5Q6HcgHVjqeaT3dYaGnUEivQGdqWC/Q3iQKrPoIY0UCqYqo3oKRaKyG1sS0NWg9AaOxMuiXIA9uMJCblIDiPmDshFTqwCopOFddjZVOKpB/vaWz1OJ1zlqiAINQ1cDOvre3TBirSCjgS4xLBnZbm+LNWAGlD6yS3L3m51z97FMO4FNEWuL1/PWKhoK2hkgRbOSE67mihGPGDGI+p9SMlW5VIH8f61UF5hirPMtVYrsFYxBq0G9gOxQH6QNWVMaKeVhKXRVIBo4wc666k0unRqUcP3CXmrHiU4HaGquUkw2Rgf08vu9YbyPluI/1NVYkiKyO5TqBye0WOMaqxDorXneklR5zVdeV90RGUIjoPukItL3HNeKo31ATw4i6CobBLDVj5X1dWX8yXXZ6H6Ox8lvcUkz0+ybM2WwWH330Efbs2YMs9wOfdtppRTkwg/KDo3qGlqkXM7AqH8aKlmCHggjllx/6zuveGisXY1Vyu4UCU4Fc+x5ZM2N2wiu5xipdWFUgGcyrouqVPh+ElNokVOTtxJphiqBrLVFuKEQblmZSgSTQVu1H0oBTRtchEMgFY6lMptcr5dKZrMPEVS/t6ZZz+NFY7ch3EihFi6O+lAr0HVitXbsWc+bMwWeffebK1QcCAWTKvAzSoHBQjUnYnpCyxUwFOjRWpRav26tYv+ycTiqQn3xby0xjVQhjRfaLCJoZs5POgfYkslkLQY8mtz0FuwpMX6wM2MyGF2NFrnlDTRT72pJlF1jpMVZ9U2PF+uxlspYW08YymDoaq400sIoDyIneker99BQ/tmi172HOi6b9Pfbb355bCDXUxBAJkX1Kmwrsd+L1a665BtOnT8emTZtw4MABHDx4kP47cOBATxyjQQ9hT2sXvnz/S3j85Y+1tme1CH4mJF2wk28yky3pqiQpGGy1U4EaPlblp7HiqwL1fnu2KhBQsDjM52WyFg52lC4dWIhYGbCDyCoP0S8516OG1wIAPtnbVtIm2+4JWD+ItPcp74mMgKS0q3wsEJyLKO+0HmGsJucDKxJs9Dar5+6LqF8BCegtoizLElYFlsIQtS8xVr4Dqw8//BB33303Jk6ciEGDBiEejzv+GfQdvPNZEz7Z144/b2zU2p4GG4z/TzGbMPODeSnTgezkGwz4q4RhGSs5q8FrrEptt1CYeJ1NBQLyAZcf9Eups7LL6/UNIQGGsYrmGSuPwoTxw2oQCOTYyP0l7I9YCPvU132sqmL5NJePIDISCiIcUt//XSlbuD7lkDxjRdOHvTvZJ/gWSzrsXP4+D2gWILV0pukYNrg66mshUmz0a8bqxBNPxEcffdQTx2LQyyADgW6n8FTaHoD8iH51wX9WKQXsZJCKhv2xGoAzsJKtrPiAq9xSgdpVgVwqUJYi4AOXUuqsbObVXiDo+VjlrmuVZyrQThmOilcCKG1lYCGC7kKaGZcDyHFX0eBX41yJ5i7szU7bwvUoRtTlGhJTxqqX02MFpQLJgjEYRESjKGdfPg1YWxFGLByyf5+SOK/3Y/H6d7/7XSxatAi7du3ClClTEIlEHO9PnTq1aAdn0LMgD6Ju9J8UpAKLa7fAMVYlNFZkK4VCPr1bOlOseF1PY1UuqUC/GitdxooMxMEAkLVKHFhlbTbSTxqHitfpb6Q+10gwgMOHVuMfTZ34ZG8bvjhucLePvRAU1D/PB8v1/721A5s/b8EJhw3GiYcNxpCaWGEHWgSQ59ZPdSu5jlGNBSObBiRFGjoWDT0BPrjgbTVEoOa4zLimuh9IGrAhf03DoeIbQ+uiL9kt+A6svva1rwEArrzySvpaIBCg1UBGvN53QB4o3eg/xbA4PdGEma80KYdUYDgYRCjgT2PV4UNjFQ0HkUxnkUhnkUhnEAurq7V6CnRCihZuEAqo0mO57YbWxrC7JVFSk1AR86ojxk1yaSYvPVkkFMThDdV49cN9JRWwu/vn+U8Fyu7jRDqDW36/Eemshade3wYAmDC8FjOOGILvnHEEhudZnd5Ciq/c9JHiDQcDDDst3m/jTqdwnewH9L63k+41YiHWF8r3ow2Yq6MAUGLGqu9orHwHVp9++mlPHIdBCUAGFN2bNJl2P5RFtVvgjqOUbW1SjgrIvJ6sAPG6tCowP5jVV0WwuyU3eLV2pRGrKU1glSpgpQ8IjCSl55t7fWS8MhdYlUEqsFCDUKqx8qgKDIeCOKyhGkDpegbmGqf7TwWyvmadqYz0XJPpLH3vyGE1+HBPG7bubsXW3a0AgNsvOro7h+8b9Lg9LDFYsKlAr6Iccl5Hj6qjr5UuFei/wCCdZe99jVQgCaxq8oFViYT6AKex6m+B1dixY3viOAxKAL+pQHZCCvoMNnTAD/ilZazcOhxd+tspXlczVhWREGpiYbQl0mjpTFHKvbeRpsfjU7zOVwV6pMdGxiuwYUdpGzGzqUA/KW0XY+WR5o2EAjh8aA2A0mmsci1scv9P2FE/DaerornASvb7sJ/13Pe+hJauNO57fiv++83tJUlv8wsErUo5Rrwe8RCvkzFpUFWUvkZSgb1dKccvarRSgWmbiQ9rSBz20YrAfCrQ51hYLKQzWcfzVu7i9YIMQj/++GP87Gc/w5YtWxAIBDBx4kR873vfwxFHHFHs4zPoQfhNBSaZFEqPMFZlJF53uswXLl738rEKBwOoq8gHViUUsBdsEOoKrNSpwBHxXGqopBor9j7W1MdkshY9tyoPSwo7jRygjNVn+9uRyVr0Xuot8M3Ek+msLx+rymgIaJezIWyVWSgYwODqKI4angsmSzH52eJ1/VSgcBHlwbyyXm2U+ekLqUDCWDGV3argk3pYkVSghi6rJ8DfS+XOWPmuCnz++ecxadIkvPnmm5g6dSomT56MdevW4eijj8bq1at74hgNegh+U4EOH6uAd36ex4e7W/Hu9oPS93uasdqwowlbd7VqbctqEfzqyToZ0b10QmI+v64yVwDSWkLLhWSBgRW/apa38LEZK6A8qgLDPsxf2WeEVAXK+0CSzw9i9KBKRMNBpDIWduZdq3sTLIviK9jg+iLKfh96HweDVMxNWJ9SCIztgFB9jZz7iHRHkvNlgnIC2tKm1w1CC0gFMtdLT2MlY6xKG0T2O8bqpptuwg033IB77rnH9foPf/hDzJw5s2gHZ9CzIA9iOmtpOWELxeua97dlWfiXJ9ahpTOFt279CuoqIq5tUlwD1WIGVm2JNC59/A3UVYTx1r9736NphrGibU80BmnLstCRYsXrkgE6a0/uZPJq6SwfxkqX6k9oGoTajFXOfqAcAquoD+aVHdiJxkqaHmNYjWAwgMOGVGPr7lZ8sq8dY4dUd/v4/YDVLeo23QXsicsOxjyYV4bBidLAqncn35yeLPed1VRjpc9Ysb5msrRekgnCCMj40NttXgoyCGWul47GijUHBaC1T09AdwFXLvDNWG3ZsgVXXXWV6/Urr7wSmzdvLspBGfQOeKdzL7CDSthnM85EOot9bQkkM1k0d4iZGX4wK6Z4vbkzhWQ6i31tSV89taLhAPJjibbAmSW2vDRH4WCQBpmlZKzI8XgxFDxc4nUNjRWQG7CLqc/zAyEb6XEsxEMnGABiYZL6kbGRTlbj8KGlE7CzaUkv/RALnsH0MkMNM4uySLg0hpnsGOYVELJgU4FeuiNW/E0QLhFjVYg7vqN9j47GimlnA5TwXHnGqr+lAocOHYoNGza4Xt+wYQOGDRtWjGMy6CWwD6JOYMU+lLYbud53sc7i0nQRN3gXk7FiV+68LkgERxBJ+iJqpAJZfRXgrbGKhAI0FVhK9/VCqwL9trQZXltBP7+5RN5dzlW7HmNFAshomNVlqQXdpIKK6Kw+3dfWzSP3D/aZtdkYfZGzV4DCstgEJIDr7cnPoSejqUCfwYaHXkqcCuxDVYHMvamlsaI+Vk7Gqred1xOcX165B1a+U4Hz58/H1VdfjU8++QQnn3wyAoEAXnvtNfz0pz/FokWLeuIYDXoIbDClc6Mm6eTi7ffCg3UW99KmEBQ1sGI+O5HOolZz+3DQX1/EDs7UVC76tRmr2orcY1jKVCC5tpXR3MBpWdBKD7t8rAS/EZuiqYyGEK+MoLkzhX1tCdRXR13b9zREPS+9GtGy5rheEyllNfKfbQdWvc9YsUa3fljmZN6PsIqmPb2ZV4JSaazYxVOVD7sF5yLKQ2MlTAWWR1WgH+PXaMh7DE+ms3TxM6TayVj1evueAiogSwnfgdWtt96K2tpaPPDAA7j55psBAKNGjcLtt9+OBQsWFP0ADXoOjlSgRmDFTkhBnyJGZ2ClFnQTFLMqkA0idRirlCiI1HiYecZKOvkyrElZpALz15E1KM1YFoJQB1ZkJUlK+UXXlp2kIqEAhtbG0NyZwt7WBI4c7hXiFh9pwUTqyVjlA8hYJORpv5HiGCtiuVCaVCDLxugbWRLGysuJn9UKEpRKY0XO1ZGu1XFeJ7+Rh4+VZVnC8y0VY1WIoJtd0Hnd+6RReigYQDzPqpeqV6ArsEqXtxG578AqEAjghhtuwA033IDW1lyFVW1t7w+OBt1Hyi9jxQzS+UygdqVcq1Yq0E5HdaYyRW1pww7yPMsi3t6dQtFjrPKBRiiIZCbr2eIlGgqirjLPWJWR3QKQGzyZP4Ugv2VtLIz96aRwcmF/t3AoiIaaKD7ag5KZhCYdE6lmVaCDsfJiNZyT7+F5xqqxuQsdyTRlgXoDKYepr3+NlRfzw97HBKVirETNlP3YLUSCAaWGyOEJxjJWJWJx3OJ1jXNN2/dmyENzRwpMBldH6UI6XKKgua9VBfrWWLGora01QVUfhiMVqPVQ5gdpdkLSfMC0UoH5B3xQVW51VEzxerIbGis/dgskFUiCJcsSD1zsyrc2z1iVql8gn6oj8AokLcuivQJrKogbufs+Ygf8cDBAhbDEfLC34ZhItRmr3HnGmHtfrp+zS9oBoL46ivr8Pd3b6UDWt8hLG8aCD6x0g0jAFnb39uSXYoI8P61XRM+66Ddir7eoKrC3K+Vcjvoa58r2RfRiMGlFIJOuLxfGiq8gLzdoLZ2mTZuGNWvWoL6+Hscddxz1KxHhnXfeKdrBGfQs/KYCie4iEgrSvLx+KlCfsRpUFUVjc1cPaqw0UoGCFIrOYELa2dRVRmjgkMpkEQo6qR975chWBZaGsWIH1gpGhOwVNKcy9gpe1eYlzU1IdmDV+4xVJmuBHGIkFNRusE0Zq7CGDkeQLjqsoRoHtzfhk73tOHpUvFvn4AeivohaFgRUc6e232C1iASRcIk0VgwT6YdFcravkrM4LPssCiRLXimnJdQnaeoAUxEr3m8/VxFI9gN633mdLGxIl4pyZ6y0AquLL74YsViM/r8qsDLoO+AF3Z7bp4kOJwgS8+hUygHOoEH2UJDjGZTP5xczsHJqrHSqZ2yRZ5CZSEmzcRlIKpD16RIGG8TrKBhgUoGlYazYQZJNBXoNnl1MgFqTN80UrZp5d+6htfnAqgSNmNl7nu0D6TUpkkksFvZ2a2c1XASkGTHRrfQWhCxOAYxVVlLMYJ+rQGPVy6wCLa5hq/t82C149Y5kxfGRoCgV2MvnWwBjxXp2ed0PpO0U8bACSmgQmj9uGlj1h6rA2267jf7/7bff3lPHYtDL8KuxYgegdMbfA8bqh/hmy/bn86nAnrFb0GGsRJVCQG6CCSnWFSxj5fhurgUgK3AudSqQnQBj4SCCgdx5erE4JKUaCNjMhogh4FNjpHS7FIwVn5bU1c8laGAV8pxcWCsNAmJH0PsWBALdkY8JuDLiTA1H+cAqa38+Qck1VuGALxbJNnRlGUxRSpsIvwOOANMO4kpzvhWRILpS4sIRHqwmLuylscozVqQiEChd+x5SPFJTEQZayt9uwbfG6vDDD8f+/ftdrzc1NeHwww8vykEZ9A7YFZaeQSg7SPtrwuxMBarL1Elg1Z5Iw9JkxLxQsHidqRRij1EGorGqjdlrFpGA3eFjldcnlSoVSK4rYZR0NWVksKsIh+yJTKhNcabGSqmx4nUyumle22pEw+uIqbwiICyODjNcTCQFbIyO3QJfFZjbz32+SSa1RFAyjVXaHUTqsEiiHqii/UR6stx+JWKs8sdd7cezi6SpWX2h5Lib2nNjNtEHAvDdkL5YIPcSsaZJZrJFmxt6Ar4Dq23btiGTca/4E4kEdu7cWZSDMugd+K4KFOk1imi3kKaMVY7RyFrFm4jY79SyW8jYAxAbWHlNwKSdTWU0RCdTcXrMnnxpr8BEutdFoQDru5Tr9+bViJaAMH+xiDr1wrtzl1JjRQJaEkCGNFNGbGDlbbdQfoxV2Oczm6CpQN0FQukZKzbtGfERALDXS1UlyjvqE4RLxdDl76WqGGGLNZjItM2Ue93HvPs+UDprCVZjRdDbgawfaNf9/vGPf6T///zzzyMetwWYmUwGa9aswWGHHVbcozPoURSaCoyGgwgl/VWHsIyVbCVLXmf1SW2JtOPBLhR+NVaivoiA9/mSVGBVNIRwKIBkRjwIsT5WZBUGAG1dacSr3H0UexJ2SX6+pDoYBJDVSAXajJWqTJ1PFzXU2oGVl2at2EgyATP7X92WNrGwhkEo52MFMIFViQTdOsamjv3IpM1UiYqKGdJc0AzY51oqH6tC055eOjQ2cGMR0VyIFBvkuP0wVnZVYMDz3k8KFghscN6bzy7PWJHXWMf/coL2UX31q1/FV7/6VQQCAVxxxRX0769+9av4+te/jtWrV+OBBx7w9eVLlizB1KlTUVdXh7q6OsyYMQPPPfecY5stW7bgoosuQjweR21tLU466SRs376dvn/GGWcgEAg4/n396193fMbBgwcxd+5cxONxxONxzJ07F01NTY5ttm/fjgsvvBDV1dVoaGjAggULkEw6UxUbN27E6aefjsrKSowePRp33nlnWdORXnCmAnVYHHtg0e2xRuCHsYqEArSJarEE7H4Zq6TA/wfQYKySNmOlcmQmA3c0FEQsHKKGhqUQsLO+TgB86I5y51oRUZe3p7l0EdFYpTK939aGnxx1UxsJIWNlCZ//FBe8AbbxaqnavERC+noywL4nYhH73hftl1QwVpms1asMrMhlXk+8zjzrSo2VOBXoxzOrmKCpwJif9j120G8ftySlnXaOC4AzyOrNa0s1VixjVcY6K23GKpu/aQ477DCsX78eDQ0N3f7yQw45BPfccw/Gjx8PAPjVr36Fiy++GO+++y6OPvpofPzxxzj11FNx1VVX4Y477kA8HseWLVtQUVHh+Jz58+fjzjvvpH9XVlY63p8zZw527tyJlStXAgCuvvpqzJ07F3/6058A5Bi3888/H0OHDsVrr72G/fv344orroBlWXjkkUcAAC0tLZg5cybOPPNMrF+/Hh988AHmzZuH6urqPtvKpzsGod0KrCTfRVdT4SCqY2G0JzNFE7A7xet+0gM5Mbd9jHqBVVUkrEyJ8IN0bUUEibZESQIrPsWhy+IQxioWDtnpENWElA9QY+EQ6irCaOlKY19bgqZ+ewNpLoj0MvskSDAVZ+zkIipmoEFzWMBYlVC87kfQTfaL5Ssn05IgSZwKtH8QkdVIT8FxrlQHp3+uXr0j5anA0lYFVkV9pAJF5+rRYow9X6fe1EK4dy4tc65hhIIBZLJWWVsu+LYA/vTTT4v25RdeeKHj77vuugtLlizB2rVrcfTRR+NHP/oRzjvvPNx77710G5FAvqqqCiNGjBB+x5YtW7By5UqsXbsWJ554IgDgiSeewIwZM7B161ZMmDABq1atwubNm7Fjxw6MGjUKAPDAAw9g3rx5uOuuu1BXV4elS5eiq6sLTz31FGKxGCZPnowPPvgADz74IBYuXNgnLSi6UxXoP7DyFq/bWpwgamJh7GlNoL1IJqFO8br3Z7Jd7InuKJO1PMX6nXnxenWMTY+pWI3coFVXGca+tkRJBOx21V7ueHWvLfkdKyLspC2YfLM2a0LQUBtDS1cae1uTGN+Lvdv59EZIs8qJ2i1EnKlhPnCwLDsAcTJWJQqsGNbBD2PlFILnAithxSc5V0GLFyD3+xQjla8DUfpeq+E0kwpU3Q/yVKB+EFdMEFa9xgdjlXacq5dW0H2+7LXtTcsFljGOhPKBVRkzVr4TlAsWLMB//Md/uF5/9NFHcf311xd8IJlMBsuWLUN7eztmzJiBbDaLFStW4KijjsLZZ5+NYcOG4cQTT8Qf/vAH175Lly5FQ0MDjj76aNx444201Q4AvPHGG4jH4zSoAoCTTjoJ8Xgcr7/+Ot1m8uTJNKgCgLPPPhuJRAJvv/023eb000+nfl5km88//xzbtm0r+LxLCYdBqJ/qmbA/TxxAz8eK1R0RertYqUCHxkrHIDQtSxnppwJVjBXv/1NXQssFWSpQl8WJRUIe4nVbQE1QKgE7G7zn/uvTIDQUUqaG2QDeobGiVYG92+PM6WPlv6VN1Ms0U9GEmX2/N8A+s7rsHG8Yq7of2PGJBWWsSuTtRAoMtPRkgl6B3horMWOl23WjGGA7H5BnqZwZK9+B1TPPPINTTjnF9frJJ5+M//3f//V9ABs3bkRNTQ1isRiuueYaLF++HJMmTcKePXvQ1taGe+65B+eccw5WrVqFSy65BLNnz8bLL79M97/88svx3//933jppZdw66234plnnsHs2bPp+7t27cKwYe4l8bBhw7Br1y66zfDhwx3v19fXIxqNKrchf5NtREgkEmhpaXH8KxckC2SsYkwTZp3SbcAZWMmpZ0Zjla90KVYqkD2/hIZ4nR9UQgG9CbgzZYvXIwoNA9+ol4gyS9EvkKf8dXVHXY42LwrxukDgPLRkgZUdMAA+9GS0CXPQMbHy97LDgFRUFVgqbycm9SPrX+nYT7MC2P49nQJnyhj14vkmmPtYV7zOG8aq7n1RoAEwGqteZ6xyz191TO4hx4PtFeipsRKI19lnWOc+KhbYXp3REukV/cB3KnD//v2OikCCuro67Nu3z/cBTJgwARs2bEBTUxOeeeYZXHHFFXj55ZcxaNAgADmn9xtuuAEAcOyxx+L111/HY489htNPPx1ATl9FMHnyZBx55JGYPn063nnnHUybNg0AhGk6vqKhkG2IcFWVBly8eDHuuOMO5W9QKvhPBeYDH7ath8aipSuVcUwosgGAneBJpUupxOu8BkqX2aCMVSTMeOKIUihOgTO1XCihxspvpRytCoyofaxEJpKlMgnlJ4uwpsaKFHewlWOAewJmJ3KHj1UZaKyo+aVW/zy3pkwUbFAWJ+gMNki6pjcDq5SAUfea/JNcIKzS3LEidxalqwrMfR9hrHSCdrZoxrM1E8dkA3DIIootXhc5+xOwC5so8Ukr48DKN2M1fvx4KgJn8dxzzxVkEBqNRjF+/HhMnz4dixcvxjHHHIOHH34YDQ0NCIfDmDRpkmP7iRMnOqoCeUybNg2RSAQffvghAGDEiBHYvXu3a7u9e/dSxmnEiBEu1ungwYNIpVLKbfbs2QMALiaLxc0334zm5mb6b8eOHdJtexvOVKBOpZxIvO59c/O6IWlVIENTk1Rg0cTrBQZWNBWoWWXU4bBbkJed821P7FRg6TRWvlkcWhXInqtIvO7W4dBUYGtpWryQQECXnWN9rBxeX3wqMOucqAlKZRAqFHT7qJRzVEGq/Nh400yPRtU9ATZo1rWWcPSxDDIaK6VQX1wV2OupQGoQmu/n6FO8brOKsqpAsaZMtWAsFLtbuvDFu/6Cu1ZsFr5P2MhYOMTYefSjwGrhwoX4wQ9+gNtuuw0vv/wyXn75Zfz4xz/GTTfdRJml7sCyLCQSCUSjUXzxi1/E1q1bHe9/8MEHGDt2rHT/999/H6lUCiNHjgQAzJgxA83NzXjzzTfpNuvWrUNzczNOPvlkus2mTZvQ2NhIt1m1ahVisRiOP/54us0rr7zisGBYtWoVRo0ahXHjxkmPJxaLUTsJ8q9c4DcVyKYV/IjXeRbGS2MVcWisii9e16sKtNk5wEcqMC9ez6UC5ekxnhGrqyhdv0A+xaGrxbGrAoPKVTvf0gZweln1JvgScn0fK/tcAXnwyaY9WSa7VIwVq+XTDSJZNoK1G1HpjlyC7hJMfg4/KmYhpLLEIfuE8m1qVJVyslRgqZsw+7NbsPWOXk78fNqcwE9Tel28t6MJ+9uTePmDvcL3CWMVDQdL9iz5ge9U4JVXXolEIoG77roLP/nJTwAA48aNw5IlS/DNb37T12fdcsstOPfcczFmzBi0trZi2bJleOmllygj9v3vfx+XXXYZTjvtNJx55plYuXIl/vSnP+Gll14CAHz88cdYunQpzjvvPDQ0NGDz5s1YtGgRjjvuOKoDmzhxIs455xzMnz8fjz/+OICc3cIFF1yACRMmAABmzZqFSZMmYe7cubjvvvtw4MAB3HjjjZg/fz4NhObMmYM77rgD8+bNwy233IIPP/wQd999N3784x/3yYpAoPCqwFhYvxUIoM9YJRndUU1eN9Ce7AHxupaPVWG6I7F4XVEpR6sCi5sK7Eim0dyZwsh4pee2fHqskKpAlV6Dpj1FjFUvB1asQSIAJUPBIskFVpFgAEm402oyr6NYyTVW+s8s+3x6Oc2L2Mjc9/V+uobt78kG8ems5WKZ6D5p8b2vOld3YFUaN3JynUhVoFYqkBYzeGus1JqyTFHZSDLOk/FTdiysQW+ijBkr34EVAHznO9/Bd77zHezduxeVlZWoqakp6Mt3796NuXPnorGxEfF4HFOnTsXKlSsxc+ZMAMAll1yCxx57DIsXL8aCBQswYcIEPPPMMzj11FMB5NKIa9aswcMPP4y2tjaMGTMG559/Pm677TaEQnaJ79KlS7FgwQLMmjULAHDRRRfh0Ucfpe+HQiGsWLEC1157LU455RRUVlZizpw5uP/+++k28Xgcq1evxnXXXYfp06ejvr4eCxcuxMKFCws693KAMxWoL3zMeTvpVwW6AitJ13sRY9UTPlY6zuus3QJgr9K8Mp+287qtsRIP0oQ54RirIqUC//WX6/HO9oP4601fxrDaCuW2fFrSb1VgRTikFK/zQn0AGJpnrPa29m5gleTO1S9jxadLeQ0PHzATlIPGSrd/Hq878mMbYu9XOsaKNfoEctdW5vjgx8NNmgr0URRQTJB7krS0KXZVoEi8ntu3+IxVWz4zIQusSFUgy1j1C4NQEYYOHdqtL3/yySc9t7nyyitx5ZVXCt8bM2aMo0JQhsGDB+Ppp59WbnPooYfi2WefVW4zZcoUvPLKK57f1xeQzVqOoMhXesxnE2aehfHSWEVCQboK6xHxuo7dAu/QrRDwEliWRVdejqpAZSsQUhWY11gVibH6eG87UhkL2/d3eAZWrgpITY0VrQpkfaxUE1KQZayIeD3Zq60x7Koo7lx1fazyFUmsuzgLWUl+yQIropPxwTKzE1bEYwLmbUMIoppBXDGRYoJf9vdXeWmxYm4AShZHZhBaKsaKPLe+mjAzVYFe9z7VFUoNUYt3L5NxvkOSoUgwz1+/tFsgLNOoUaMQDocRCoUc/wz6BvjVldeAb1mWYwLWTaEAbsZK9kCw1WnF9rFyGoT6Y+cAPY1VIp2lnjiVUdsgVHS+/GqwrjJ3vsUyCCWl2O2SFaDqWLy0FwRUvB62vZ2E4nWBwJmkApOZbK9aTPCpQG0fKxljxZ0v7UXITUYkFVg68bp+mxdWSxn0aFSdElR8sn/3JmNlVzIGHAyaKuBJMoEGoL4feLaToCcCDR3QJsxEvO6hJ8ttw+jQNA1CXefrww9NF2Sc70qJe5Syz1+/1FjNmzcP27dvx6233oqRI0f2WX3RQAc/2HjdpGxgEg0HtcXcgJuF0bJbKHIqkJ3QEjoaqwJMMzuZIKaKNc1UVVMRjVWRGSty/B0av5+UxdH0dmLtFtTGivYAXREJoTYWRmsi19YmXtk7jaf5yVG/V6Dt2QXIJ2DexZ4gGiqN945IY+Ulsk6lnb+Rym5BlOYF7BR3b7IKDmuJYACBAGBZ6hSdzMNNXMkrZiNV5rg9CdqEme2fl7EcnmLufezrRc41a4mtDvgxkCCswd77BTvOd6Yyjp6AgPP5o4xVfwqsXnvtNbz66qs49thje+BwDHoLspW2zvZ+mzATFiYaCiKZyUrTA6zWh4rXi1YVyARWftr3UG8n71VaR4rxOtL1/2F6BQLFc14ng44OY+VOh2iK19N2KlDLWoIbuOsqI2hNpHu1jQ8fROqeK6+xkp2vLdSXaKx6mdVgq8BCmrpIYr3iCj4VwQafCqSMVW+K10lASAsMcuONirHiU/4qtpa3YCEol6pAIHeMfBUfC0evQOY8MpaFIOxraFmWi8km0E2f+wGbmehIpl2BFdsJoF/aLYwZM8aTbjQof/ADvDdj5RS0FhJY1VdHXJ8l+o5wKFBSg1C+zQUAuppTTUrEaqEy6tThaPlYManA7j5f6YydkpRpFljI+udpG4Sy4nXRhCQJNioiwfzn9F6bF3cFpGZVIDepyhirlExzVGK7hahDhK4+hiSjywLU6TFRSxtAfe/3FFxCdIXoXraPiq2VpwJ7/1xZjSzxsQL0fbtcRrfcfpmsBTIMSXsjFjUVaI8BnYLFYIKxdomWKK3uB74Dq5/97Ge46aab+mx/PIMc/KYCyfuBgLNlRUYjCCDi9cHVMeV3sRVVpTQI5dtcAMzkojhf1hwUgHIio8FG0MlYpbMWbYtTKNigWYfx41M/JCbQNQiNeTVhlgQbJADt7vkue3M7Trz7L9jS2OK5rYud060KpM7P3LWVOK/zk2+pAithKlDTbsH+jfKBg1LQLROv934qkNfPaaUC8+kzEiT56hWomU4uJthnvCIaAlHkeGYemHGH7fvHHzsbJPL3sp9m3rpoczBW7vHAtluwi4LKWbzuOxV42WWXoaOjA0cccQSqqqoQiTi1EQcOHCjawRn0HPymAtkVeyCgNtLjQRirIdW5SjCv3lThUKDoVYFsk+kuryCSY+cARmOlOF/WwwpQr+zSjNYByK06g4Gc3qG1K03bVBQCdvLWYazcq3Z/jFUsHKKfIW44TQZzjrHKV9jpaN5U+MuWPdjdksBfP9qHiSPrlNvyYmXdSYJnrEIS/VxK4NkFOH2serUKkrm22fyiQLvhdNjJ/IjSY6J2Rbm/S6uxYv+rkwrkm3KrrCXcqcDerwpkf9do3rcrmcl6Bncig1DAfU84x8CeT33yqUAeIsZKZttTDvA9ev/sZz/rgcMw6G24AitN8XqUo8y1UoEJwlhFhd8NkJy+vdonD3N7MqPsIaULVutBepjxAwYB3+YC0JuAOyWMlei35R2rA4EA6iojaOpIoaUzheF1aosEFZyBlQZjJfHs0rVbyKX05JM2YTr437tYjBVhzg60e7fHkfkWeU0SrI9Obn9JKjAtDiJZ3Usyk6W2DT0N9pkigZVnY2KZaaYw2HBXfJLvy73fmywOl8LUqNZzta4qwCC0FFWB7DNO+jkmM97BBpsKdDJWfErbvbgkKC1jxYjXNdqwlQq+A6srrriiJ47DoJfB6wF0xeuuKjmtVGDuoSGBlSjQYCeoSCjgmHg6BFUifsEPeom0PLBibR9IQGdX0GikAiO5Y6UrWaHuyD0h1VaEc4FVNysDE34ZKz4VSJv1egQbjLcMuZ9E6SKZwJl4C+nYX+gcx8EO78CKTwX6Zaz4ljb8fWV7sYlTY0Du/u+9wIqwTwGQ+NWzL6Is+FReW74qsPfF67xFik7BiTsVqNKTidnIntAceYFNwQaDRIie0RjH7XGHZB7SWcvNvHIZChbhHmDo2A4bfGCVztgWDP3WbkHVABnIGW0alD/8Mlay1g9+xOtDFIwVOyiFQ0FURII0NdaecFeJ+AX/nV2KYI1vZwPosTgdLvG6d1qBnYBzlgud3fZ18q2x4uwQCmGsutIKPZmE1SCBlUis6gc0sGr3Dkj5a6sz+VqW5WppIxevSxgrLrDqLTjPN/f/uu17bPG6PHCQivVLIOjmA0JVVS7dx3U/yO99mUGojki+2OCPW7WIYyFqX5XOWm6NVVp8XYGe0ZSx4xS/GGQXiqxBaG/eW37he7YaN26cUh+QKWN6zsCG78BKUj3jpwnz4BoSWIkqbuzvJw1sq2NhtHal0ZZIY7jnt6jBf6dKwC4Keuzzlf9OJKVlpwK9qwLZCbiuSJYLfjVW7v553uwcwFQFRkKI5AdGoXg9Kw42KklVoIYTvgokTXdAg7HiWQcdxirNVIkSpkkm6Kbida7kPRgMIBIKIJWxerWaiQ30yKF6pgJ5ry8FgylvaVM6jRXxcVJ5UhGw3R4AJtBWPLNSJ/LeFK9zwS95dr1Tge5AMgG5xoq/jwFvxuqlrXuwq7kLXz9Bn2RRpQIdac8+UhXoO7B69913HX+nUim8++67ePDBB3HXXXcV7cAMehZksCEmep4UsmsVqx9YtegwVoIqlJp8YFUMATt/fqr0k0hLYQdW8u9wi9dVeg13WqGW9AvsLmPFDDg6jFXSVRWox1ixpn0q00BZVSBNBRaNsfKvsVIZmxLwAzsgF3RTMbdAExgNBZHKZHqVsaKpz3AAWUvvmSXaFb5yUtxgu4w0VjIWR8tuwTvQTgqeWcBOBVpW7rcNCa59seGy/9CslLMlCOx+Gdf5ilh7Aq+x/8b/+Rv2tSXwpaOGYvQgvSbw7DPBM9jk+SaVjLQqsD8FVsccc4zrtenTp2PUqFG47777MHv27KIcmEHPggwoVZEQ2pPegz0vXrebMHvpcOzPJnYLqsqxYMAe3IppucCfnx5j5U4FqhgrElgRD66wYnLhV8pAzjATcPdW9At2cC2kKpAGDR7Mhsh5XZUu4n2sKiNFEq/n9z/Y4f278ayDqnk0gTCwkgi6ZWlPsm970lsHU0ywuiNyrF7MSsrlY6WqbnVO8ASlbsIM6DFJrlSg0mVenQok24SCPa+f4xkr3Uo9t/Gx7D4WX1d2H9nvShj3/W0JrcCKXzjLGCvKzvVHg1AZjjrqKKxfv75YH2fQw6CBVT540TUI5QcgL/abddUenDcIFX0Xv5ICwPQL7H56mRw/yWInFOknmwa3B8ygBovTyTRgBthqIec+lmXR1R5b8mynArsXSCZSbGDlv1egTnosk7V7R1ZEQlL7gdzn2CtOFrEiideJfcbBjqSnuSrPOuhorPgVMyA3FhW17yEoheiWNbXUdZnnDWO1DEIlvl29axAqTuvp2C3oGITKUoFsoNVbAna+QbKOIStr+unV0knmTwaoBf5sT1ndjgr8wrndpbFytpPql+L1lpYWx9+WZaGxsRG33347jjzyyKIdmEHPgjyANbEw9rYmcjoSha1BIs1NvpqMFXm4qqMhqk8RPfx0Zc18v93WpvuMFRkoSHoxoZjMRSaPdiDpXRVIUoFk0ONXkez5sxOSnQrsLmPFCkF1AiuJzkQzPRYL2544qjSvy26hyIxVJmuhpSut7Dvo8uzSaEzMr5hz+4v3o7+l4Dki938pNFY5g1C9ai77fHPHS38jRREGHzRTjVUJzjXmg8Vx22/YaT1+PJSlAp0O5r1zvjSDEOYCKw0zVIBdWIiDJF5Ty8JuuC5PDQP6zDu/cJalAsnzE+uPBqGDBg1yidcty8KYMWOwbNmyoh2YQc/CbuBp09bJTBYVEhrbFoY6VzpZC0rDQ/Jw1VZElOkBqk1hJi+SUutuKpD1yKqriKC1K60UTItocJ3WJy4fK0qZc6wGM/ix32GnAouosSrIINQ72GBTqblUoKpyTDwhFaulDRuoNHUklYEVzzroaAX5FTMgTyHK2vcApVlps/dyl2Y1F89WqLSCopQ2+3dvupHLgiSRBQiBncp0srVA7tyizN+yVGDIsU0vMVZEB8cFkSp7C6c3lVObJV0gKDVW7u9i721drSg/vvOLQb5PJ8kklHMq0Hdg9eKLLzr+DgaDGDp0KMaPH49wuHsl8Qa9BxpYMQ7fiXSWCopl2/ODFpCblESaEsAOEmorwo5VPr8aFPUcK5b7OjvYEVZIlX4SrdbI6SmbMFPGyqmxUjNWbCowz1h1syrQ4WPlw26Bb9+jqgokgSnpG6lq38O2KmJRSVOBhQdW6UzWMSkcaE9i7JBq6fY868AGkbIFAj+wA/KATCbUB8AYG5Yg2AgHtFOBbtNMRdDMMdkEdhPmUlgQ5NkYDcYqyaUy2fOQX1vnfRwI2BWfskDysZc/xtjBVTh3ykjt81HBrQ3zTgWKCoSkGqu0c0xgIZM45F6zz79NM7DidaD837zVSTTU+8yvX2hFQtOmTcOaNWtQX1+Pl19+GTfeeCOqqqp6+tgMehDkoahiGniqVtL8YMvOkemsBZnfoc1YhR0PaSqbRYxhx0QTUnXRAiv7vOzASsFYCSYLHcaqg9gtRJw+VvwA5KDkmeCS9AvsdiqQuY7JfMWNquN9mktfBSWDLYsE084mt69/xoqkTLujseIHVy+TUJnzOpBjX0XrA77FCyCfyGSGmez+vcVYsUxtOBhUpnBYuHysVKaZkpY2pegV6Pax8lMV6GRrgdy5VSIk2FagOwrmKj5F37V9fwfuee7vGFIdLVpgleA0VlENhpBcK9LvFfDWWEUF56pqecXe27rMu5d4nTDGvHi9nDVWWuL1LVu2oL29HQBwxx130P836LtgU3s6K2mZsSKgZjZaKGMVcaS9XE2gBZOvXRXYvVSRM7DKBS86dgtsOkcnZeQSrwfFk4vtYRVwMCR1lbnz7XYqkPs+LwNOmdO2qgKSMFYknafS4fB9EQlIUNYdjZUrsPIwCeVZB1UjWvodXBAJyH8jWoQRlAdWqsKJYoINoKKhoNY9DDgF74DcZR5gry2nO/LwsUplsvjft3di58EOz/PQBa870jG6dTduZph41xilSI8p2tqQll7NnSnP4gpduDVW3po2W//nTmnLNFaiBZlKu8Zeb12NFT++y1KBvHaunAMrLcbq2GOPxb/+67/i1FNPhWVZuO+++1BTUyPc9sc//nFRD9CgZ0B7moVyhmuE2ZCB78PFM1YyOFOBDGPlCjbcK99iidfJwx4M2EGPanITaqw00ihEhEl9rMLiFbOMwekJg1Agp7OKV2kIujn9nFpjxTNW8hJsmbcT7RXYDR8r/jrqMlbERJJPaYvAewYB8nSIrH0PwDRi7qUJgQ0UI+GAlJ3g4Srll0y+lmV5aqxkjNWLf9+DG//nPZw/ZST+8/JpWuejQiZrV9rqWCcQ8IwVe4vKKj5FgZVKY0h+z3S+krYY7YwKSwW6703Zcas0Vqrxgf1+v4xVZSSEzlTGNR70RbsFrcDqqaeewm233YZnn30WgUAAzz33nFBPFQgETGDVR8D2TIuGg0BCLxUo1FgpHmZWvB4KBmibGn4lK9LhUMZKQ4CtAjtI6PSn48vNAT3TTNt5Pd8rUDKRyTRHdT2QCgS8KwNl3jZKQXf+XGMR58AuMkmUleRX5AfI7jiv89WdXo2Yk0xqDHCLlYX7CDVW4nSI0seql40NWX0T29jc23mdT4+pJ1/AfS97tR3Zn79Oe1q71CehCVHTYJ3UJx0b8teW7Z8na1ekavMimuwdnRASmSIFVpwFgU4qUPAcUsZKsvgrNIgEbKbOC0S8Pqwuhs/2dwjsFpyLOLpA6euB1YQJE2jFXzAYxJo1azBs2LAePTCDngUbPOgM+Lbzel6Hw4wtqkbMZNVChNmRUBCJdFaqOxKlArvNWDF6BJ1KNJFIlVZBavQK9Gppk5YwVqywPp3JCivLdOAOrNS/H9+GRaWhICDeURWkxUuIDVCcJonUx0qmseoGY8UHZV4moSqNlWyBIKoKlKWZZC1eAEYb0ksTAt8mSkeoDwjSYxLDWHYSd7mRe1RukcC8u1YbBOKKN327BfY+CIck/fMULI4qaHX07kymUZ/vQNEduNKeWqlAd2Ao6/unMgi1K2LV4nW/jNXQmlxgJWOs7FRgP9FYschmsyao6gcgq1mSCgTUAz4/IQUCAWl+ngUrXgeYlWxaPGixwUTxqgLtVBdZ9ejYLUQ0JlIWvI+VTHchY3CqmabQ3TFF5a+j12fJNVbedgskUHV6+Uiqqbhgg7KH3RggecbKq60NLa8nC4RggJrG+mGsQpJJW1UV2NupQHZyJJVrBDoeZbxWiU/zyqpbAe/Jj7AQOj5rOuD1ZIC6oMLeT85GylL4Ko2ViDFy9u4szvnyrLqKRSJQLRjlLW3c97HKfoPVPPoOrGpznTl0xevlnAosbEls0OfBDro6VRYJobeTTmBli9cBO1iRaayiAsaqu+J1dpAggYDKIFTsY+Ut6OZ9rCKSAdpuesylT5gGo7o0ugh+GSt+JRvUCCJ5ep5laHQ1ZdQgtFsaKy4V6KmxcovLvQJJ/lzZfVyMlaRKDmDF670bWPGO+oCHIaqkUs5tP8CwRK4mzOrJj/wG3bn2LFjmidy/KkE5Ad8nE5AHG3qpQHV6zM8i8W87m3Duw6/ilQ/2ut5zeTtJFqwsUgLmWFbxqTIIVdpvdEO8PowGVjK7BafxcjnbLZjAaoDCngACWlWBhOESsTh6gRVJBYqrhUTVVMUSr7MrTZK6UqUChRorjybMybTtp1QVIT5W6pW+SIdTU4Q2PvyA0+6pseJEvwUwVuxvxZ+vLXB2ni/RZ3WlMwVXS/Hi9SaPwEroUeYh6uZTEQDDavDnKmEjgd4vE7cDWoEuUoPFcXkdSTRWISaYIfDSWCWLzFiJmgYXYrcAyO//YqQC/Zzvc5t2YUtjC5792+fS4yaeThGNIDIl+I2k7JxgvKf7KFKs3UoF1pJespbjc2RBZL9KBRr0DwhTgT7E64CeoJsVrwNyQalId1Q8HytbqE/ST6rVTkqwivWyIGBX3rQqUDLYytqAAHZg1dYdxoob8Do8fj+587qCwaSBVe5cVanhtIAlAmzGyrLk1+PNTw/g3pV/l96bdnVi7rMPeNotOFOB7HFJqwL9GIQyCxYeZBKULWDe+Hg/LnzkNby3o0l5Drrg2RiHDk4RbLh9rMh9LNbhiO5jb8aquBor0WLIq1kwIL5env3zVKaZHukxP4HV/rYEAPEiy92EOf97q1KBgqKZQjRWKllEQT5WSWdgBTh/J35hEzOpQINyBTuZ+gms2FSdjgVBa8LJWMny46LArVgtbVgdhY54XXQsXumxjlTuGMPBgGfHeZmDM1Cc9GfBVYEaTXcJeG8Zdj/ZtXW3tLFTa7LU7L0r/47/99LHeP3jfZLjyJ3byHgFgBxjpWK/RKyDl72EULwuYWRIMKMUr0uesxUbP8fGfzTj+fd3SY/fD+yUs/O6su+JwC5E2P3cQaSKwREz0wTk/kmms56+WjoQaqV0GCvBIor8v7QqUBBI0gWj4No6NVb6Y9n+thz7KmpLZRfkcGlPjTE8LAwifaQ9Fb8r++x3pjJawQ8Z3wdVRem9xi5UZU2Ys5a6MKGU8B1YHX744di/f7/r9aamJhx++OFFOSiDngc76NqpQEV6TCTgDRSeCpSJ19kHmbA3iXS2Ww8Qm/6JabRRUVXPyMxQeeF6bh/xKlKkdSCoJYFVN0xC/WusnJOLjnaui2OsAHl7DJXXER1IJdejKe/pJes7RgKyEfnAKp21aDAvgm1Eq5/SLoSxEtoteBiEdibzuqMiV8qxVgI6HmX8+cr2UXl2ybSUBGwg7SfYkEEcIHnfx6rUMBs0Z7IWyMeoAkkvFsdPin9fvhBDxNjzgaSO071oUVGIxkr1vLhkCBqLYrJNTSxMx082mHQbhNrHVK6WC74Dq23btiEjmIATiQT+8Y9/FOWgDHoeSZ+pQNUApFMVSDyaaH5cIl5nJ7xiVcmxLWrIw+m7V6BEi0DAC9fJ9wEiob6c1agugq6MnxhVGquswFjRj0GoI7CSeOmoUkZUwC4JJkgaUxYIk0G3riJCf3tVZaAoaFaVj7PfITIIdQcbhVcFknPsblNqAj/CbMd+vMZK4qovClIJ7OpfSbDKMhtF0FmpAyQdiYN7EcWOaw47B1EqUNJlgT02wC9jVeRUoPBc1XIFvy7zPIOrkw4k51cdC9NnuFOQCuSrAgH5/VVqaHdN/uMf/0j///nnn0c8Hqd/ZzIZrFmzBuPGjSvqwRn0HBypQB0fKx8iT3YfMgHXMj5WufckrAYz+ZJ2O8lMFm0e7uEqCA1CFXYL4rLk3H9l59pBAyv7kZJR5qqVfk0+AFWxLl4gA3l9VQS7WxJKjRWrCeGrx9SpQHd6TNYbUZX6jEVCaE2kpcEECQpl73dRo9IQ6qui6Eh2ShsxZ7IWCOEYFdzH0pY2ZMUcEewj1R3Jgw3vwKo4q3DZM5uE2tTXnRpWC/VFqTFdjRVQHAG7KBXoR7wuqgBmz1fW35O+pmjpxLJzfhaIqlRgQhL8qlKBScG9KdVY5QMWUUsb1bjPX28ds+M2yliF8vKPhOOecFcg5yxSLAtIZDIACpsXehLagdVXv/pVADk6+YorrnC8F4lEMG7cODzwwANFPTiDnoMjFahRBs7rLgBWdyTej12tkLQedQjmHkDZ6rc6FkKyI9s9Bidj+6BQ8bqO3QKb9iQCZ2kq0G7LQCBjrFT95IpRCUkm7vqqKHa3JJSMlcM9m6se02ppE3GnPv2kxyqjuX2kjFX+d5WxGmyaoL46gn80daJJYhLqmBzZiVSRxgHYljb2ucpKzlW6IxKYydIX5DcotgVBVMDGqATdMh8rqVBf0U9OqrFinr9ipD5VCz+leJ0zxwXECwvRc8LC9pESMVZsEKn3XHck0/R3EaYCeRbHj4+V4FxlGiuxeF3OjvGLBi/GyrIsen7VklRgklvYBAI5+UoirW7DVkpoB1bZ/A1z2GGHYf369WhoaOixgzLoeQhTgUq/FzKI6uuOSBqwKhqiExnZ350KFE9I1bEwDnakuiVgZ/UXOm1UVBVGsoFLnAqUTL6K6iK7KrD7gVW8MreSUw3m7ArXj8YqwTVhBsQpAsuyhN5RBCr7iyTj0C9jcdjjqK/KOVrL2tqw95yjX5pHVSBtwiw4V3dhgpyN1GWsiq6xcqQw1efK7hfl7ge3iSS5roUwVmx6rIiMlcOjyZuxslkc5n4QPLfkuoYYB3sW2j5WmoEVYasASSqQu0YyiQULUc9Omau+aAx07SMIIvnr7RVYJRibGlkqkBqEMvcxCaxU7YpKCd8aq08//dQVVDU1NRXreAx6CX6rAkWr9qCHNoUXrpPvy32/XnqsGO7r7CChx1i5gzxyrrIUili8bgcoWccgLU+hVBchsCJpAhJoqNIPZDUfDNgTqI7LPN+EWbYfO4GLBmna1kYQTLCDqyzYYI9jcL5ViKwRM3ufsiXnXhorYRNmD28nlY+VjBnuzJ9L8SwIyLEIFgg6/fO4SVtmdKsyQ5VNfGwq0A9Dt3LTLnzj5+vQ2NzpeF3sY6Vm1HPHJ9dmsecrCsBY2L+RgLHiegXqYF9eXwXk7geXuNxliaGTChTdD+LFn9JaQtGDkb+3vUxC2XG9OhpGZV5KIUwFMgub3vaE8wvfgdVPf/pT/O53v6N///M//zMGDx6M0aNH47333ivqwRn0HFj/Fn8aK4HIU8JYtXAeVrn9xStZWXqsGF5WDoNQnarAtDst6RVsdOQ/r1qgsQKc6Qg77SnQWBWxKrC+Ove7qyYuof1A/rhUfRF5g1CAtSCwz5X9vUTBhqopNru6l4vXba0XCSRlgVWKYR1YQ0svhi7JtdRgz0Uq+hVMwF6TAfEGSxQpsEqLGCsdjzLtqkD3RE3AWhaIftdCLQj+Y82HeO2jfXjh73ucnyeqePPRhFlc8Zl1bye4hwF5MUPu2PyzcyxjldtP7EbOM1bqVKAiiPTRF1H1vPDjutcCkSz6KiMhhIIBVOcXWh2CqkB2Ud/vAqvHH38cY8aMAQCsXr0af/nLX7By5Uqce+65+P73v1/0AzToGbDpMZ0eZqIVjFezXhFjJSsLZiv3WFQXwYmcTW3YVYHedgsOzy6PtGcn14AZcJ4LOwGLKiAJisLQ5QOBQYSx0kgF+jV+VbZ5Yc7VS/RboWhr06EVWGXp59ipQPEqWdb/TNXnjf0OkWeXzNtJVSnnqbEqciowKgiadfrnuZ34+clXzlg5nPgF58syG7rne6A9ic2NLQCAlk7nPU3vY0fwK07XCvfzqJxUpe8BfRZHOxXYnnD8zY9/vA5Ux3ldJLeQLRj5wI2FzJ+P3Y/AKxXYxuirAJvBVhmEsuegsggqJbQ1VgSNjY00sHr22Wdx6aWXYtasWRg3bhxOPPHEoh+gQc+ALU/2o7FyVs/k/isbpPk+gbnvCzg+j0Am+q0WiBn9gl2V6jT+FZZuewQbolQgu78jsBJUQBLU5IPQYlUFsscmgsh52stlHhAzViJjRUf6TTBIV0bk4nV2MpFNvgnGed3LbkF2j3ktEFQ+VlJrCZWPlSQNXWyNlYjFkfWvdOzHTWRydo7cx3IxNyB+ZhyBlSaLs/YT2z+RTzGJFkMqbym6HymsEOmOmP28UoHEyd8zFah5rvs4xopnfhJcQKjT5kV0DiFPjZWcsfLqFQh4VwWScZ0U7VQJAiueQWX/P1mmdgu+Gav6+nrs2LEDALBy5Up85StfAZATqYr8rVRYsmQJpk6dirq6OtTV1WHGjBl47rnnHNts2bIFF110EeLxOGpra3HSSSdh+/bt9P1EIoHvfve7aGhoQHV1NS666CLs3LnT8RkHDx7E3LlzEY/HEY/HMXfuXJcubPv27bjwwgtRXV2NhoYGLFiwAMmk8+beuHEjTj/9dFRWVmL06NG48847C+5xVmr4TwW6KXMyIclSRnY7G3d6jF/ZySakYmiOWP0FCQQyWUu6khWu7BSCTUAsXmcHsJQgrSBiNYqR+iTnSxkrlWFmgV5HJDCtCLOVcu5VMznvAKPhYqFKzbLBtGzy7WJSgYM0U4H8KtwrzStkrDx8rEQrfa8FTGex7RYELI5OuyJ5iyP9ak/2fhLpfth0p26w8dePbPd9ngkROq9rBJHiVKB7P1VqjN3Hq1JO97n2TAW6GCudVKC7KjDipbFSXFux87rzNb+MFZFSdDpSgW5rF53+tqWE78Bq9uzZmDNnDmbOnIn9+/fj3HPPBQBs2LAB48eP9/VZhxxyCO655x689dZbeOutt/DlL38ZF198Md5//30AwMcff4xTTz0VX/jCF/DSSy/hvffew6233oqKigr6Gddffz2WL1+OZcuW4bXXXkNbWxsuuOACR5A3Z84cbNiwAStXrsTKlSuxYcMGzJ07l76fyWRw/vnno729Ha+99hqWLVuGZ555BosWLaLbtLS0YObMmRg1ahTWr1+PRx55BPfffz8efPBBvz9hWYBNBfqqCnSwOLn/ejFWdULxOsdYSQauYqTGRBorQM5aqQStXj5WlYzGKhAICNNjqsqx2iIGkiQ1ppq4xJVjGlWB1D9KJBYWCfXFQ02lIrBigynZtUowtg9e4nXyu/CBgLfGyp32lBnGqoINsr9oAWNZFg2oujwCDd3FnMoMVXau2azlaprt1ZRYtEBgq+eKlQp842ObseKZELHGSh1Esvovr/3SgsCNhSrtWJDGiksF8uNBQalAQVVgIX0RVcE5ua6kItkrsGqXpALbFQah7HGVq8bKdyrwoYcewrhx47Bjxw7ce++9qKmpAZBLEV577bW+PuvCCy90/H3XXXdhyZIlWLt2LY4++mj86Ec/wnnnnYd7772XbsO2zWlubsaTTz6J3/zmN5Q5e/rppzFmzBj85S9/wdlnn40tW7Zg5cqVWLt2LU1VPvHEE5gxYwa2bt2KCRMmYNWqVdi8eTN27NiBUaNGAQAeeOABzJs3D3fddRfq6uqwdOlSdHV14amnnkIsFsPkyZPxwQcf4MEHH8TChQsRCIgp4nJFob0CRa69co2VW7welQwAMndu24m8+xqrSDjgWPV0pTI0cBNtzzbq9Wrf0yFgrIDcgJvOWhyLI7cfKC5jlfvd25NpWJYlvEfFk6/3Sp/VNhGI3KdVAmd2f7F4nQmspD5WIrsFtY8VH7x7MVbCgd1D9Cu6tioto26gse6T/fjWr9/Cv58/EZd98VDpdrljcTN0XqaZbBDAi9fdiyF3+o1FJBRAJmsJF2x+xeuNzZ34ZF87/VvGWImsJWTidYebukf/PO2qwCIJ9V2MFTf+ycTrKqG+n3ZO1CBUpbFSpAKH1ETR3JlCm2ZVIBmHxXYL7oVNzMPOo9TwzVhFIhHceOONePjhh3HcccfR16+//np861vfKvhAMpkMli1bhvb2dsyYMQPZbBYrVqzAUUcdhbPPPhvDhg3DiSeeiD/84Q90n7fffhupVAqzZs2ir40aNQqTJ0/G66+/DgB44403EI/HHfqvk046CfF43LHN5MmTaVAFAGeffTYSiQTefvttus3pp5+OWCzm2Obzzz/Htm3bpOeVSCTQ0tLi+FcOSLGpQF9NmPVZHKqxirkZK36wTQlWjkBxUoFsRU8gYJ+vTBAtWv16pcc6BOJ1wGZqnMGGXL9ABhjdzvAi8Bory5KX+Av7h3kI9QFGY8WK1wVMl0jDwqJC0dKGdYyXaqyYQZcwVrJGzOTa8ZOFfR9LWDFBKqKQ5rUqZpi9F/lAnMW6Tw+gtSuNP773ufB9FqLyeq/72BlsOCdtWVNiURDJ7ucl6CY9ElV4/aP9jr9bOjmNlYBR9ypKEJ0ru5/IIFSeCpQzRoX0CiR2C+Sx4TWm0pY2PsXrtJhBIs0QMXSqhRc5riH5Z9E7FWi3swHA2C3IDULZ4ypXxsp3YAXkUnTf/e538ZWvfAUzZ87EggUL8MknnxR0ABs3bkRNTQ1isRiuueYaLF++HJMmTcKePXvQ1taGe+65B+eccw5WrVqFSy65BLNnz8bLL78MANi1axei0Sjq6+sdnzl8+HDs2rWLbjNs2DDX9w4bNsyxzfDhwx3v19fXIxqNKrchf5NtRFi8eDHVdsXjcSr8LzUcqUCNfLWwCbNuYMWmAom/DSc67EkfK17oSU1CJVoWVXpMpiejqcAIF1iF3StZPtXCgvxWOfM7/4NGNmsbcsYro/R12e8nOtegn6pAgXjdmfZUT0hE8ybWWDGMlVS8zmqsIvS4ReL/lCQV6OXtJBSvy7ydVD5WCi0jHzjKzpfcZ5v+0eKZEhQF8KqKLv7YvAxCUx5spGyyz3IsVmfK+9l+PZ8GPOaQOAD3hJ0UsGdeQn1ZYYUocPCsClQwgc5zdXtSiUDE6yPjlQBEqUDnIkGvKlCUdRCP4TpNmEUBK2WsqnMEhG4qkIjXq4XidbdBqKwIqlzgO7B6/vnnMWnSJLz55puYOnUqJk+ejHXr1mHSpElYvXq17wOYMGECNmzYgLVr1+I73/kOrrjiCmzevJk6vV988cW44YYbcOyxx+Kmm27CBRdcgMcee0z5mXzaQ5QCKcY2ZGBTpQFvvvlmNDc3039E+F9q+E8Fylkc2UDhy8dKMiERMWP3GCsusCImoRL3dWV6zNN53ZlaFK1kZVofgG88LT7ndCarYNvs76mMhmigJ9N2iLQUOhorEWNFU0aCHmuyyVfVhNkvY1URCSkrA2WThWdVoFAYLUmhCHQsBKrnjA/yZedLRL3NnSnsPNgp3IYei4JlljNWJJVpe315tbSReTvJJj9+AeelO7IsC69/nBOunz15BACRxkq+GJIFG+R11hwXEJ+vyp+MfV3Y0iatd20JslkLB/Iaq7FDqgAoUoG8eF2ZCnSnqWWiexXzquqLSPYbXEMYK71UIBnn+apAy7LUjFV/SQXedNNNuOGGG7Bu3To8+OCDeOihh7Bu3Tpcf/31+OEPf+j7AKLRKMaPH4/p06dj8eLFOOaYY/Dwww+joaEB4XAYkyZNcmw/ceJEWhU4YsQIJJNJHDx40LHNnj17KJs0YsQI7N692/W9e/fudWzDs04HDx5EKpVSbrNnT86kjmeyWMRiMVr1SP6VA9gHx6sq0LIs4cBVCGMVldDzMo0V2belG6kxfpBQ6XoAtbeTVGOVkqQCRSwOTY+J9Au215YomLQsCxf/519x1gMvC6+XQyMTCtoaNYm2QzRh2M7T8vtBbLcgEOor9GSA2nldi7GiWq/c59smoe4BXcaeeVYFilzmBfcx2+RZ5UaezGRdbBNf9SizZGAn5fc/bxZuQyBO86qDSBVbK18M+WOs+HPzCqy27e9AY3MXoqEgzpyQyz64NFaEgRc0BffqASm7H5ymvh6pQEXak39OvXRWTZ0pkEMeU58LrNixQDQek+uqbGnDaE3t4xanwVWGqKpeouR5HFyllwok45I7FZih30G+JuYwCJUXgpQDfAdWW7ZswVVXXeV6/corr8TmzZu7fUCWZSGRSCAajeKLX/witm7d6nj/gw8+wNixYwEAxx9/PCKRiIMpa2xsxKZNm3DyyScDAGbMmIHm5ma8+eabdJt169ahubnZsc2mTZvQ2NhIt1m1ahVisRiOP/54us0rr7zisGBYtWoVRo0ahXHjxnX7vHsb7KDrFf2zD5Cf1a9IvG77rUhWvxzVPrQ2RynvbelSnY4SvF6ATMIyh2uR3ku/KtAtXmePAWAnePGEpOoX2JnK4P3PW/CPpk5H2wsCdqCJhAKUQZNpO1QaK9m5Oga7sJd4Xb7yBdhegYL0mMMgVKJ/oqnA3OcQt3kRYyWzWwh5MHQJIWPlDpidTZ7ljBXg1rzxvSvlTant1zf9Q63XLITFEXkGyYIxm40UTyNRSbCR4Gx5VGa9gG2zcNyhgzAsPx60JdJiRkkQRMpYHFnwIOqf55UKVKVY+Wvt1dZmf/65jldGaHqbDcbY35M2YVb4aNFzoP55gjGc11gJFpcEYcXCixWvA0BbMq3s4NBONVbOVCB59tnfzsFY9Te7haFDh2LDhg2u1zds2CDUMqlwyy234NVXX8W2bduwceNG/OhHP8JLL72Eyy+/HADw/e9/H7/73e/wxBNP4KOPPsKjjz6KP/3pT7T6MB6P46qrrsKiRYuwZs0avPvuu/jGN76BKVOm0CrBiRMn4pxzzsH8+fOxdu1arF27FvPnz8cFF1yACRMmAABmzZqFSZMmYe7cuXj33XexZs0a3HjjjZg/fz5lmObMmYNYLIZ58+Zh06ZNWL58Oe6+++4+WREI+EsFOnQXonSItAmzqlegZPXLMRvD63LWGntaE8oHVIUkV+Fim4R6pQL102MiHyuATQW6hbCyCYmYhIpSgU0MEyOakNiJMRAIMNS6B2OlIcwWfa+oMbFI9Cs71wpBFRABy1h1pjJCTVEXlyZQNWKWtRJSMVZsKiIquB9E2jlAwlgxr/ETAl/1KPPtYl/f5MVYKRqn+2Gs2PuBvQaqnpfsZ3SXsSI2C6eMb3As0ti2T+Q7RF5jXqlAPlgS3f9eqUCb5VJrrABvs2OirxpSE6ULozYmGGM/L8alAvWqAn1orES9AlXtewhjlRevW5b6fGXO6+TZF2n+ADuQVPVGLCV82y3Mnz8fV199NT755BOcfPLJCAQCeO211/DTn/7U4fukg927d2Pu3LlobGxEPB7H1KlTsXLlSsycORMAcMkll+Cxxx7D4sWLsWDBAkyYMAHPPPMMTj31VPoZDz30EMLhMC699FJ0dnbirLPOwlNPPYUQQxsuXboUCxYsoNWDF110ER599FH6figUwooVK3DttdfilFNOQWVlJebMmYP777+fbhOPx7F69Wpcd911mD59Ourr67Fw4UIsXLjQ709YcliW06vGKxUoK0u2GxOL97N9rBjGKiwebNOSSW9obQyBQO4hPtCRRENNDH7BTxYxL/G6YCL1EnTL7BbsMmyGxfGolCN6AxGNzgZWIlaD6hHy30uOR85YuScMEtzKqgLZ383RZkKQIvA6V1pIIAhy2WAwkxflsxYYgFO8DkDpZSWr7FJVBTomMTaIFKza2f8XnS/7W/HPGn/+XuJ1ANj0j2apjQYgZuhURpbOfRgROPP/maxlByyKJsyAHdDxgYWLwVEEVtmsra86+Ygh+e4JQXSlsmjpSiGeZ3TYRuv2ceulPflrJWLodFOBOm1evAJJ4mHVUB1j7GbcVXLs8YQ1GBxx70j3M+tMNbrvLZW1BHnG6ioiiIQCSGUstHalHQExC7fdAjEIzf1GRAcbCTn7e5Y7Y+U7sLr11ltRW1uLBx54ADfffDOAnMXB7bffjgULFvj6rCeffNJzmyuvvBJXXnml9P2Kigo88sgjeOSRR6TbDB48GE8//bTyew499FA8++yzym2mTJmCV155RX3AfQDsqibMMFayknxy8/Lu2TZjJfqOLJ34RRorV2AlqZSLhIIYUh3DvrYEdjV3dS+woqlAdSNmOgH7WOl30lSg85EqpFLOZqzcx9fUaQcMosCQF7WSlaCs8koUbBDSUO5Ebgcz7KQeUqY91RorIWPFnX9XOuNKFfN+WqpGzDKbCxVjJVsxq7yO2PdZBAK5RUwyk3ULmjnLAWkqkHl9X1sSe1oTlNXlwQrR6XHRNJeanRZV/wK58yXZX6JrkrGRlEVJ84EVz87JGY2/72rFwY4UqqIhHDNmEICctKArlXAI2FXFNXLGSh1o++kVKNIXEpDftLYijNautGeF836GsSIBhzMVmKXHSY7Vq9qTPTZHVaCHVlCksWJlEXxgz8ouaisiONCeVOqs5OL1tJQtJp8P9CONVSAQwA033ICdO3fSSredO3fie9/7Xp9MiQ1EsANNVENjxQ5AjomUCrrd+7E0fY0gFZjkBiCRszvB8LpcMLWntTCdFb8KJ3ocUSBZiFA/ncnSfaoi3horr0o5W2PlFmA3e6QC+YlRm7ESaGosS2wvQQK6Ct5aQqDXkKXfCOwKTfe14NOXfLosncnSyY+wQSqTUFmlE60K9PBbEjWBFbrMhwLSsVA2IfDXUhb080HIpn/I04Hia+tf0M2m5zMCNlKmn5Olp/wwOIStOuGwwfTzyEKNnbCTlNlQM6gsZF5NIhd171SgnAm0feW8OyEAtsZqSE0UVQK9pSjYiFCW2bu6NeyhsWKvl7DBNrO/rHlzJBRkrpO8MpBPBZLxKmvlnj3b1kWcCShXxsp3YPXpp5/iww8/BADU1taitrYWAPDhhx8qjTINygdO/5aA0hGafV1mrCgauMigVxkJid2QJU2YRdVjI/Ir8t0tbrG2DngaX+WdJNPJqM6VZRF48bptEOrW4kgZq5hbV0HQ1OkRWOWFwZSxEhjusVC1PWGPlYWoIhBg0iEFtLQRMVb8BMSzOM6gJ/c5g/Pi9SYBYyVL5+gwVlF+UcGt2gHGw0pyroC8TJw/Ny/x+uEN1QDUAnaloNuHy7zjfhBpBSXna4vXxalA8rkq+wHiX3XyEUPoa0RawJqEioToKlsAgBVoe2vuPA1CJYxROpOlgQ4x7PVirPbl9YENNTHq7yRqSuxIezLXS8bQiXoFiph49t4UNmHmUsMsWGsSHbNjsuDjU4FA7pz5huAE/Y6xmjdvHnUsZ7Fu3TrMmzevGMdk0MPgUxbRkLp01WtlJ2I1WgQNmAFFKlCR0x9GA6vCGCueDVPZLcj0ZCo3chIUBAPuAUBEtas8YgDGbV4wILEpLtGElOCC4CqPlkApQeDDpo5Eq19RiwlAPLmoeucBTJAr1FjxLI5cq0N+90EK8bosFahiI0WBBiBetac8GBxAbhLqZqzEzyLZbvq4egBqAbsw2PAUr8urRAFOKygo32dBfawkgdWgfD85mVA/lcli3ScksGqgr4sYq5TgWHgtmOvzJQscka+Z6PNZyHyk2HOvr/bLWMUY8bqAsWKeP/aekwZWAo81UaAtGwPtfeTflWSCPnqdFIGk3Sswdy6hoN0ZoyOZts1B+3tg9e677+KUU05xvX7SSScJqwUNyg+sqJVt8SKjVZOSlZ1K0C2qCMx9hngVq6oeI6nAQgMruXjdPcCxjvBCxkrwG9nC9bArBSTyt/FqBUJ+M+9UoIbGSpexYvsisoGVIJBMyBgrxUpfWhWoYKz4lb2bsbIdmYmwVS1eVzMUogk4IVkxi1btXnoyAFI9I38vyoINcq99cdxgAMD7ilSgMKXtxeIIBO/BYIC2VhGbZnporFxVgblziDNO+aIJcvPnLWhPZhCvjGDSyDr6eh1t8Gs/CyIpQYRJaYsCSduJX+c+Vj+zsnuIPS/9VGCesaqOCjtPiCog2WsgqwxMCp7FkGLhx7O0BKqFF7svEazLUoGWZdGKQbZnazWju5Q9f+UuXi9IY9Xa2up6vbm5GZmM+oYxKA/wIkYy2LPd3ll4Na8VMVYiDyv2M3iNlYrF6W4qkG+qrLJbYAdGh+hXsdInQQufBgQYQ1ShoFtdFShMBWpWBZJrKuoWz0KcLmIGTsEg3UUbH/PWEu6JlLIaEm1KJaOx4u8jMgGR34kPNrpS7kFXZRAqTQWS6jGF8NjF1grSpV7aOfZzvNy4RdfWsiz6+vR8YPV5cxdlOHiInimVQzh7XO7zFTAbJH0v01jR9lVqxgoQB5J7W3PnNW5IlaMirE5gGiysgPRgcUQVkIC4SpQ8s6LeeYCCscqfayBgH7eXQej+diJej1H2ukNgt8AeS5ARsssE7KqWNo4Ub1o9PoUcjBU/jtu/k4hZZNGZylA/PLbjBPXeYwIrGWPVb5owf+lLX8LixYsdQVQmk8HixYsdNggG5Qu+y3nUIz8v11jJ9Rp+GSuV7mh4N1OBvNmdbRCqGmzFmhrRuco8rACxqJVOSJLVb02Fm/4nYKsCRQanSW6CoYyVtFegvJoKEE/ACUFAk/sMwSDtMfmywRnL4rCrWRIs8YEwrU5kmDPWIJT3vSqkKlCWinAEVvnP9WI1APu68JVxrjSn4Np2pbK0WmtobQyH5XVW738u1lmJPco8NFYyVk/kqi/5PQlkBqFkPKmpiNDfsUNQtdqaEC/O6gRMSEqgH2KPS6ifkxy/6D5W2Q8Acs8sNjVfRdknNQGxjxGvV9OFUZrez7IMgiz1SiBswqzQWMkqIAOBgNz/ihlrRdeJBRnfAgHn2FnJVAaKuh4A6r6b5QDfdgv33nsvTjvtNEyYMAFf+tKXAACvvvoqWlpa8MILLxT9AA2KD56lYAOmRDrrYiJSktUa2U3E4pCHqY4bFKmxmysVSCYlkcZKnQpsT6Qx54m1mHFEA2469wuu95Pc8VfQqkB5KtCdLsrtK9JYsalAHkLdkWdVoNu7hsDBWAlW+a6qQIH4VbQ9e76BQC71I6swkjJWQvG6ON1CwH5GZyrDtLixg4ghNTHsaU24qgJFgy4JwkgjZvb+k+lkdDRWrlSggLFSNdcmIEFgIYwVy3RURkI4elQdPt3Xjk2fN+O0o4a6tqf3cpANNtSshoydDgmYrpQH8+qlsYqFg6iMhtDalRbey7LFGW1z1enBWAmCXxZyuwW57kieChQHrCy7VO1h1gvkxiRy3g3VMVvHauWeicpoSMhYAbnr3IWsNBUoGmNFXl+ye8BxvqEA0lnLMY6zFdU64nXqus5JKKqYVCC/UOSPW2YRVGr4ZqwmTZqEv/3tb7j00kuxZ88etLa24pvf/Cb+/ve/Y/LkyT1xjAZFBqW18w8tOzCKVgDywdb9UBJ4MVY8Za7SpxDGal9bUsiovf3ZQby3sxm/f2en6z3R8avE67LVmsrbibazibiPXcTQefpYxXLBgEi83sxWBQoCQz4QqOZ6b/FIS0weVdVjXZJVpKjrvZc7d654wq15YycfUuknqwpkGSu2EXMTZ7kgEuo7j1vAWEkmMXbVTs7Rq8ULINeGkHNXNqVO2v5hoWAAk0fHAQDvSyoDRWJ6L1d9r9SnaAKWBRtSjRXjg8Y33WVBqv7cgVWeCWE0iCqLlNwxuM/Xi8F0WEt4pgLFASv7PLIpLhlI0UU4GEBdZZjeD4DN8MgyCGTMkgbNWffYpmqcLmuunTs+UUDm1Kd6pQJ54TpBFSNfoAbA3Nha7qlA34wVkDMEvfvuu4t9LAa9BD4V6DAuFKUCpf4/uf+KBuk2rrkmgcx/RLVKGlwVpS6+e1sTGDWo0vH+Z/vbAagMP50DhcpuQa4ns4Ww2azl0HwkJAxObj/C0LHpMTk7B9gDjTAV6GCs5NfK5WMlE6+nZav2AJCRVAVKBjuhXiPrHWxURHL3XqcjsLLTq5WR3D3EB8Lk+vEBXn1VFB3JThzoSOLQIVX0dVnqx+4VqEp7uq9tKJhbtZNA0o94XVYVWF8VQWdzRtw7MeVMOU8elQusZJWBKh8rLzdyd/88d1qP2kt4+FjxiyhWN5MLNhLCQNJenHGpwEo3YyVjXsP5a6TWjooZTHaB4J0KVKc92YbosrQ84DQHDQQCCARyYu72ZAbtiTSG1saknn/k2nqmAgUVwKy+0KtqOXe+ctE7OV9bvC4+X97DisB2X0/TuaXfG4Qa9H2IHhzVjVoIYyXX4bhXGmyLHdEgHQwGMKw2x1rtEqQDP9vfAUDuh+OuCpQ7r8uMAFWVcrLKFYBdRbonJJmGoVahsWKr3VSMFdVYCcSvLLwq5cSpwNw+FS67BRU7Jx+kRU74JBCsioZtd3YZY8X9jrJGzDJ7AKWPlWL1zgcOXoaZ7LG6A6vc38QuQnQvd3Ip56NH1QHI3f8sk0mQSrsnJVkAQOCHsaKN02UaKwmrwAar5NoLGStBSywAqI2JNFaSYEPRL9DL10zY89KjKpDXJLILHZuxkgdWe4m+qtruMEG1Wfn9ZPY3Xv0CRcUVIgYzIQncWIieGb6nrJdBKN/OhqCSYTHpvRKRaKzKlLEygVU/QDKdxc9f/QTX/OZtYaNaHqKVtSqw8hxsBd8pe/ipoJX5Hocpp2TgIjqrPYLAals+sEplLNcAalmWSwsSo4yVIohUaGpkgk1RmkBUheVVpl4tKLHOHW/GoSngNUcAXFU0noyVzMtH0WhVZhAaEexDNVYKQbetq2ICqwTLWIkZRpsp5AIriZeVLBWoWiCori0/KYlayPCQGoTmryUJCkXXlqac879XfXUUo/Ps7WaBgF3VUFnEzuWOS8FggmdxyGJInR7jz5WY2LKpQLHGSpwKtO0WWI2VOFWncl+XB2Midk48LtDv8agKjIYZxkqRCmQZK4IaTvTuZZop18+5r61YY+XNvFKpgIDpCgZy94tXKrCNa2dDUM0EVuTekZ0ra49TTjCBVT/AntYu3Pv8Vqx8fxdWbd7tub1oQFFVWcjSAyEBjUwgNVak4nU3gwPI0woqywWSCgTck6/DRZjrFSgUr3usYgH3IC0zzARkPlbqFAoVfXKBVRNnIaBkrGhgpdZY8RWTBHa7IlGlnExj5Z7EvKoCAZv5YlObHZSxCkl7O8rSdLJ+gdKKN42qQCEbGXL+Rr40VpImzLIKSMDu98hWUE0enWOt3hekA8WNid3pWhZe1iriwgR1KlDKWEWYwEpUFeglXmcZK4nuSOaI7thHwmCK9GS8NQP/PTLDTAdjpUwF5hswMz1RaSPm/DMhS2l7pwLd94OonyIdEyRBJLufqFcmGXtsg1AZY5UXr0tSgWxVoNQg1DBWBj2FQ+qrcPWXDgcA3P3nLcKAgYVowLVvVFEJv3oVK2KsZCkUMvkmM1m7fJgNfiSTEhGw86nAbNbC9gMd9G8+hcIGNLbGytt5XXaugDvYUE2+ogHXK2VEAqtk2tmsl7VaACRVgfR3z51jlUclkh+dCYG8pY28AlK1+q0QMFYkEKyOhaVtb7okv7vMJFTGOhSyQGD3I7+hTtpTZhBKGSuSClQwVqyW7+i8zkpkuSBmrOQMDqBgpwWMjFe7IrsJs3whUqlIBcq88AhjxfpYyYpOVKlPufO6gp2Tnavkd3XYLSjYOQLqYVVtM1Z8QCZdtEpYMwKRWW8hQWTuu9zPOq/98tJY2alA58Ko0sFYiZ/xcrdb8B1YdXZ2oqPDnsg+++wz/OxnP8OqVauKemAG/vCdM47AsNoYPtvfgV/+dZtyW1UqUFS+KlvBqFgN2cPPBlq0TN0RWIkfZpnlwu7WLi495jx+NuVIqwKJ87qQsRIPKqGAPLBSpwLd9LxXTzl2Bceubl2MlY7zeswWfguvk4/KKP57pYyVsJ+cfJAmqb5OQVWgg7Hifawk+gtZI+aCqgIV15avjNLysZI8Z+Rv0k+uU3BtWUE/AWGsRM2YVe1pvMXrGiyOxwJB3ivQniwrlalAorESM1bJdJYG47IFgsoQVXa9xFWBahZH1pdQrLGSB1b7mHY2BDWcTlJuQSDXkwH6VaKyMYGFaD++hRLVinalhRIVqXidWUjJGKt+14T54osvxq9//WsAQFNTE0488UQ88MADuPjii7FkyZKiH6CBHqpjYfzwnJyH06MvfERdi0XwmwqUPciq0m1Z+pAVDtOVfn7/UDAgbKEAAMPz4vU9XCqQCNcJ3IyVM+8P2BOxyCA0KamSCwZzFTq54xVPiqJUIF21i8rUFSkUskJrUwRWOs7r7CQsYq1klWwqjZVM2yTqzZbWqgqUa6yqo2Gm7Y34d69wMVbiRszePlbyQFWc5nVO2lo+VmFxX04SWBDxusggVGRESyoDP97b5ri+WaYSzuG07TX5ejC2Iq2gb42Vw4JAJV4XM1Y10TB9Flu70shkLergrVPNSI8/rb4fRD5WnqlASUubaDjEaKz0qgIJyG/E2y3wQZ4s9QqQZuH57RxVgXKNlcxagv0uh4kqN/aQ65bOWsJFoEy8bov1M9Kxtd9VBb7zzjvUGPR///d/MXz4cHz22Wf49a9/jf/4j/8o+gEa6OOS40bjmEPiaEuk8cCqrdLtlKlABWPl0iIomjDLVvrsgE1SBCpzUIIRcbH7OquvAtyDlmj1VYjdAnt8/PyrYqzEjYm9xaGiykASKJDvER0/L2wlnkeAePLyspcQXtv8IMnbS/CaI8DbxwqwvZtEPlY64nXe9kHWiFlapq4IImVCYYDtH+lkXguyWyAaK4lnF8D6pdkT0bC6CgyujiJrAZ/us58FdoL3Y7cge26VqUBPCwLZQiRIz0Vtt+CceIPBAJ2MW7pSjs+XXluRxkrK/AiCBs1UIN+XkK3SJYxVKiPujQgA+9uJxkokXueqAiXHLQwimfMPCwLtdNairJKOQajakiLPlkdDtMekqDKwXWLJY6dM09LnT1ZdWy7wHVh1dHSgtrYWALBq1SrMnj0bwWAQJ510Ej777LOiH6CBPoLBAH584SQAwO/e2iFMDwAeVYGKAcjF4gTcDxeBTo818l08hSwCacTMa6y2eTJW7tVXhY7dgrIKTJ7a4MGLhS3LZhJUgaSoMrApX1JPhPzCwIobdAOBgF0ZKBDNemus5FWB/PnavQJFQn0dxsr+XWlVYCwkrBpkt+dXs1KNlVRT4161EyivLaer0TlXu0ycc1rnGCuh3ULKzVgBwNB82uhgu7vFC/udgLjFEguv4g1R6sdvSxuWhZDpjtKZLA0k6yqdjBXAtrVJO9KqrvY0Ck2ZdwWk/1Qg4AxikgIzVEDOWlHGqpoVrztTiLJgQ8VGyoJPUUNlLYNQQfDJV4IHAmwA7D7fNql4nbFbkDx/KnauHOA7sBo/fjz+8Ic/YMeOHXj++ecxa9YsAMCePXtQV1dX9AM08Ifjxw7GRceMgmUBdz67WZjbFgVKqhWAt9+L+zhkeXpiRsoeh1d1EZBbmQO5gZQdlLZzgRU/+YoGiQqm8S8PmY8VINeUKRkrRqyf+3x7X1XVjagykKQCCXuno7EC1O7r0rYeGlWB7ibMInZOrcNhP0eksXKkAmWMFe9jJWnE7OXZpWKsdOwW6Lnq2C0w9142a9HfdLBCvN7JsHgsCMt1gAkkRdpCwH7GpHYLkt6IorY/Xtc2ImlfxTKNlZLiCpap5Rkr9rVWF2Olv0Dwdl53pz3l7Xvsz5BVykVCQfq7inRWlmUJU4HV3MLIS78qCjbYAEjeF9RyfL7SIFThY8V+fq2iX6BMvM5WMnvZLaSzlpBVLzV8B1Y//vGPceONN2LcuHE44YQTMGPGDAA59uq4444r+gEa+MdN534BFZEg3vz0AFZu2uV6X2gQqtJYSVIoQYU2ReZjxX5vigs2VCv92liYTiiszmoblwrkdTiiYyepwHTWcqUIVKtwWU85pUEox1g5JgGFyJmn/wGgOV8VSBgrEashSuXoMVbeq3YCeVWgmx3QcSOvEIrXbTNMeWAlDvBIGuVAe5JjD9TnqgoixQahzvvfy0YDEC9g2ACfBIWJdNY1YfA+VgSUoWNSnyJtIeBOX/KQsce2RxkTbKRJCl+msRKPKVSQHApKqwJJGrAiEhTeO4SxaulMO8YzXqOp6o3oh631YudY5ocNal2GvSSQFDyLrYk0DSTEjBWxWxAfi04qMMDdD+y1y3DMq55BqDv4ZHVoKi8rufO6uwmzzG4BKE8Bu+/A6p/+6Z+wfft2vPXWW3j++efp62eddRYeeuihoh6cQWEYNagS804+DADw7N8aXe+LHhxV7yVZkKSz0o+JJqSwcwDQWekHAgGX5YJlWVS8fkh9zihRJl5nBarsRNzFDfqqVCAJHFyBlaQ6jd2Hb3uSe09+viSwYvsFEsZqZFw/FQgwjZgVqU+Zfk4UNNs2B7zzupuh8BLqAzKNFUkThJj3xRM0H9A21MQQCweRyVpobLJTx7JUoNZ9LOgDadstcFpBHY0V8xux5z2o2k57ySwZKqVVkHZgJa/2lKfG2HNwC7oFqR8PjzJZuoayEIyPFX8vy4TrBA7GSuAwT6AUr8uYeIFW0Et35OhLyOqOJL5yIsaKsFXV0ZAjeK7iFllySwxFKlB27zPXjl/8qRh10W8kOi5VF4l2SWDltFsQp/vZYLgcGzH7DqwAYMSIEaitrcXq1avR2dkJAPjiF7+IL3zhC0U9OIPCMX5YDQC3ySQgngCUdgsyCwIi5hb5WKksCLgBV+dBBoBhtU7LhQPtSbQl0ggEgKOG53R/nVxKQRhEMv8vSx2KaHBbUyYuqRYGkdzAzg66Ko1VjVC8nptsSIApYjVEqRxKrQva2shadaiYDdbgkUVEoFWiwYyCnRNXBdotbWQGoTIfq2AwgDGDcz0CWY8zL4ZC2CtQoTfhK6p0hPoiZpgsBqKhIC01Z18nENktAGJNmYx5UgWRAMvQidO8IgsCaUsbmcaK0cZVSqoCZcJ1AtvLKiX1sGKPW6gD9Qo+ffTPCwQCQvPVBA0MSGAlrwyk5qC1McfrJFXW7mG3QP4WPbM07cm36mIYvnTWOR7rNGFmr63o91SlAsk156sCq2mvQLndAnts5aiz8h1Y7d+/H2eddRaOOuoonHfeeWhszDEi3/rWt7Bo0aKiH6BBYaArQUUlWFSUChTcpNLmtYrJV5Z2Yb/LlQpUTEiAHVCQVCARro+sq8CgSnE1lagTfDAYkFbWqYT0sooqWXUa4E6hpJlzlVlLAPYqrk0gXieMVe67xalPp8ZK3tbGy2lbFDR3SZpO2ytm94Skx1jZ5+JswiwWOKuYwrH5wOqzA0ylnKwqUDCR8t8RVdgt0Ps4K7/nCUQLmE4mtRoOBem9x9+bhHGs5FqAiBgr2e+uajjN7icLPsk5shYHcrsFMWOVcAi6xfq/lk5dxiqtZJNUppl+zHELbfPCBwZVMfkiZ1+b2xwUsAMNmgrM/35uM9TccSsLkASLEDLsZgrQWGUEv5GIsVKmAqPiVGB7Mu0KTAlYrW45Vgb6DqxuuOEGRCIRbN++HVVVduf4yy67DCtXrizqwRkUDroSFLSKEPaMUtkteIjXhYyVwguF11jp6HAAW7RNUoHb85Pm2CHV1L2b11jJBt0KCUOnCghlWhxR8EZAV3a8tYRi0AJymjKANwjNa6yYwMoVSArStvZgLg+s+FSgWmMlHuxE7AANJFUaK0FlWDtrtxDNBxq8QajETwuAmLHycNpWGaiq7BZ4xkp1riSl4TC1TTkD1ZhAcwbIxeuEsRIFVtIqOa+WNq4qLOe5ysr3RfvwE73IeZ0PmmXmoARsVaCKYVGlx9KSMaqQVKDjuwQWBNSwV7HIIVYLrDko4K4QJuMxz5CrKuVUTaT59LCOQahoESUaO1VVgXYqUOy83pXKUmJANY+UY2AlvmsVWLVqFZ5//nkccsghjtePPPJIY7dQRlC1ihCmApXidfHNLUuNqfYBWFGrMz3mFWzwqcBt+3KT5tghVfYALQk0+NVXRSSElq60IhUon0ilvQIFEzw/2OqkxgAJY5VPBQ6pjiEaCiKZyUoZOnbQtQdz/6lAoaA7JWOs3JO2jn5O5ITfwZRix8IejJWATRo7JB9Y7RelAr0nUgKd+9jtY+WvKrCLMlG586iMhNDalXadbye3HUG9MLDStxJgIdNG8horncbptpZSHFhFGed1fgFIUkd1HoxVS2dKybCoNGVkbJA5r4sMQlXXVsc0U9W7k2isWA8rgA2snHYLflraqDzHwqEAkhl30KzDzglb4TgYK3EqMJu1HG2rWLALB9LGS/SMR8NBtCcz/SMV2N7e7mCqCPbt24dYLCbYw6AUUPWlEqUCVXYLUr2GakJSriK5VKCCJWLBpwKJOejYIdVSEayUsZIIolUDqDQVqJjged2FjrUEwIjX84NpVypDJ9Z4VYQGca6m08KqQLupKQ+ZPkUkViYggn+Z3YJTvO7N4ojamnSkWMbKZnlYTZnKY+pQEWMlmYB1WtooDULpSl/OChCIA6v875m/f+zzlWisuN99sKDptKzgRFUll9svPwFL2EibnbP392xpw/UKFDmv80yzvsYqrWRYCqsKzAcNAj82nUo5USUqrQqkeim5xoqtCATcLJeMVVe1tFH9RnzPS1oMoCFeV50r4Gxrw4Jl7HiNVUU4RJ31iWWK6FhUuuBSw3dgddppp9GWNkAu15nNZnHffffhzDPPLOrBGRQOu2u8nneRlkGopFLIT69AwA7o+JY2XiwOnwr87IDNWFVQho4Xr4uPg0yUfOuQQuwWROk3ArdQXy/taVcF5gYWojkJBnJpQlkKRRxYydlLGcsiCyKzWcsxMbIg5yTyOlIFktSwlRkgWcaKrYJjB1FVKyEaWO3vYBylZSltEkSK2FrVteX1c97nKtIykmtIUqIVYXGw0clYULAgPlYH21P2uUqCSF3GSiZ6J8wre/whCRvpqbGKsIEVx1gl1IEVZay6UspnSl0VKF5U8IG2sz2Q/LmljJGgUi6mwVjta3d7WAHuVKBsvFH1z1Pdm/yzriNeF42FouxAnURjRdi3UDAgLD4hz7yq84Fqzio1fKcC77vvPpxxxhl46623kEwm8YMf/ADvv/8+Dhw4gL/+9a89cYwGBaBSaQrpNxUoXu3ITCRVvbvYz+GrAr1YHNIvcHdLl8NqYeyQKuxqzgVbfPNaWSm2rLGvTirQzVjJmRM+FaFDswN2VSAZgIhwPV4ZQTAYYExOxalPNtiolghmVddJNgGzg5hMvE7aYwQCAaZSzpux6hJorCojIcf3dKYyDgYrdxxyjVVrIo2mjhQGVUWk4nJVsKFqwixLj/lOBRKtWP69CsmiyPaxch4L0VglM1m0JzOoiYU9K95kLW2k+xF2mjKv9rnKijBEGqtM1rI1QuEQHUM6Uhl6zwB26kguXmc0VkqDXjmrLhsb+B6QjvZAylSgmx3zpbESNGDO7eNshSO3W5CzzLIG5ABzH7s0VopzFaRYlanAhDMVaAvXQ8L7pyoacsxdYo9AwoiWX2Dlm7GaNGkS/va3v+GEE07AzJkz0d7ejtmzZ+Pdd9/FEUcc0RPHaFAA2IifH1SEBqFK53XxCkY6+TKfodRYcYO0Kl0EAMPybW0S6Sx2HuykmpKxQ6qF6ST22N2pQJJKk6QCw+6HXdbSRs1YOQdbHQYHsIMhsnIn+irS8sRmrOT6FYIqyWDuFCBLUj9cYQKbeuSbH7NVnXwgqWSsOLF2hmnaWh0LIxS0K4DYYMNureNmrCoiIdoGafuBDmcTWp6dU2qs5KyYbKWvSgWKUu7Un4pqrMRpXns7zvcnEqKfS0xCvTyaRAwOew5exQw6BScixoo97xijsbIsJxvZ4pUKZDRWSvE6x7Sx0A20Hd0SlIJuNzsma4quqgps4KsCGXF3eyItDXz4TAALeq6CcU1WmKCyv6FN2j3E67KqQFkDZgKelRVnPvoJY5VKpTBr1iw8/vjjuOOOO3rqmAyKAL4vFbvyE1XD0Hy1j1Jd6mPlN7Aiota0k7GSdY4nqIiEEK+MoLkzhfXbDgDICT1rmHSRVGMV5gMrMeOjY7fAV0GqNFb8YKtrLcE7rxP9zKCq3HWskGjKRIGVrKWNTiuQDHc/kIAnFAy4gzHm73TGQiSkx+LwPlVsOpfcxxWRnFifPV9V0QAAjB1cjd0tCXx2oIP6nOWORZ+xUqUi+Ek7LdEnsRAahBLmjWisBIUY6UyW7sNrrAKBAAZXR9HY3IUD7UmMGVwl1Q+JyuRF5+v2sSIMhZPFUd3HtO0Iaz/APG/RcJAWwAC5wJHcC952C7YoOqlYDKlZHHHQT87VsnJjm1NP5q2xSosMQvO/J63QFYrXxYxVOBRELBxEIp1Fe9KugpT3z5OL10VBv0tjpRM0q5zXmeOirbkkgRUvXCfgK19FY2s5N2L2xVhFIhFs2rRJ6b9jUB6IhYNUACivlBNorETidQllLq2SyzeYDQTEAy+/sqIOzh4aK8Bu5/Lmp7nAauyQagDifnPsd/ATTIw2YhazT6JBhbTw4QfphGBAIeAFrbrWEjVcVWAzYazyol3CFrHna1mWUCNTJRHMOlbiMoNQiWcXz1YBPGPlPF/VteWvHWFmWP1FhUBTRqsTBYMuYKcDdxzo4NI5EnZOEFixHlM8XOkxnV6BgpR7F8dYiQxRWdd8vioQYLysOghjJUvpyQMNx368E7+LxfFOabOaI7L4IucdzI8NIcZTjj1HT7uFSvv5SAiYEvsYFOJ1j3GNHDsZE/j2QNLzFRiE8qlAXguazmSpUJvXWAHOykBp8Ku0W5Cn9wrTWMn1ZE7xurgqUNbOhoC/x3X0q+UE36nAb37zm3jyySd74lgMiohAIEBXtnx6zE5ZMKlAhcbKy0RS5usUCQWFQTj/QOhWygF2OtAOrHKTp0ygLRPjVkjSLaoKRdH5ssGMSmBJJyTNVCDvvE7KjmkqUMBYsYGSH8YqFAzQoJFApiejFWwCU84Ix1ix36FjEEqYv3Yq0rb1F6Lz9WKsiID9s/3tXFNiWZrLfe/L0m8A41HGpYyUPlb5Y2WZG773ooh9JcFXMCC+z/h+gV7ecyJ2zrIsKWMb4oNIjb6I7O9M7nu24IBeWzpO2cGGl8aK2DBkLXvRIX5mndeIhde4Bjg1YV5SBWWlnEdLmz2tCfrdJEhmQdKBbYm0ogmzIhXow0ZG5eVHINaTue85aSow6ZUK5Bkr+dhajlWBvsXryWQSP//5z7F69WpMnz4d1dXVjvcffPDBoh2cQfdQGQ2jPZlxTaiqVKAosJIJeGWTr8zAjoCnrHVZHMC2XPhkX95qYXDu/hNNvIC8YamMsVKt7Oj5MqlA9qFWpos4xsqLnavJD8BErEo0VnHKWLnPl00vscci01ip/X/EEzBvZsmCjc1cvl0quwWiB8zk9IB2O5uQaxtyvdKZLP1s0e8OMF5WBzocKVg+2JcJulXpN8DdCkfH64ht85LNWggGAwwrlmesBBYEbFNq0WKFNwn1aq6tskgB3OlMXqzsh7HKbW8hFhZ3KaiKhtDcmXKMU152C7FwkHq57csba6oaZQsrPmXpUi4g9GrdQ79LyOJkHPuSAIk36/28KdcabkS8QsiKVTOWKbLj1koFKoJPt4+V/D4WMdqigI8EwIn8OEbea6NVv2K22aWxEhy3as4qNXwHVps2bcK0adMAAB988IHjPZMiLC+Q6iEXiyMYFGm+2pffi1q8LvNB4RkrnSoUApIKJBjXkJs8ZfYDch8rCWOlKt0WTMDs71UsE0nALVglVYFEY8W6E9NjYbVtbCqQ6b3FQhX0EKqf18/ZgnH3PqRfWipjuRkrlUEo2xQ7ZS8E2FYXMS5d6Axo1anA7fs7CjJ+9Uq/uT3KvINm9h5JZrKoCIZcLCC1WxA0pRYdB+DuF+jVXFso5mYZT2na34cOhw2s0lkgZt+v7OeL+gXaqUAxYxUIBFBbEcb+9iQ11pSZX/LnRiBb0LHXL5OxtAIN53exLI4eY/WPfGA1elCl8LNZywWvqkAlYyV4DvnjVvVe5L9L3E+R0VgxgXFrV4rqx/xorKKhoItRZ79HVohRSvgOrF588cWeOA6DHkBVRDyhClOBEpdk9jWZtw0v5vYKrMhg72JxtBgrp7DTU2NFWBlugrHF6zLGSk9jlUiJgxkCdz85PXYuHAqiIhJEVyqLtkTarbEStD0hv3uYS+3JNVbylbiUsaLpN/EEHw4GkcpkXMGG6nzZIK0zlbHb2cRYxsp5vl5MIWCnAhtbuuhnqtg5IlYmv12nR/qN15nopHldgVUkZDuqR4hBqDvo70ylHdvwsPsF5u4TWTqHF2az90nSkS5Vp/3TGgFzKK+hyqXTnJM2z1jlzjF3vqmM3VFAxliR9/a3JylLJ9Y4kmuknx5jTymdtWiHCO9UoDvY4GUClLFK8oxVzi7GK7BqS2QUPlaqqkDVgpHTWEm0Z6J9vOwWQsEAtU5o7Uq7AiudVKB8HiGMlbsQoNTwrbEy6DuojIqDDVH1EhFC+ukVaAcazn2SefG6bDJ12S1oiH4JhnGMFWm2KztXWkGjzVhpiDyZQJId5ESMLetjZVkWDfR0gsiaWC6IakukqcaKtC8RCZxlAS2rsbIs96AvCgS8PLtEYm72s6h4XSPYCDIi9c5khpais+kAXneUYFIsotUskKsYrYqGYFnAtnzqWMhYMcfGThRe6Te+TJ2m2BXXln2P/P78byrSWLFNqUUYTE1C1RorNs3Es1as5o5PR/Hl9bTgxCs9xnlZiSpoebaZdemuUQRWxH2dVNOpxevO+zibtaQVq4FAwBFskHvYOxWoqAoMk2vr9KcjIKnAUbLAKmpXS5JHmD8edUsb72fdT5o3LEix2npW53eIdFZe4nX22ZctnGJ0Him/VGBBgdX69evxgx/8AF//+tcxe/Zsxz8/WLJkCaZOnYq6ujrU1dVhxowZeO655+j78+bNQyAQcPw76aSTHJ9xxhlnuLb5+te/7tjm4MGDmDt3LuLxOOLxOObOnYumpibHNtu3b8eFF16I6upqNDQ0YMGCBUgmk45tNm7ciNNPPx2VlZUYPXo07rzzTsdEVW6oklSgiJgKpY8VZX1kjBW/vVvD5dzPyY7pikMBZyqwriJMU2NEA8P7dsk0VhW0Ga4kFahoYcJ+vsocFHD+xmlmkNYJImsYwerBdk5jJWDoSEDL/+6E+WErnMjfgL/0GG8NwIOtBGPF0F6aMraNC7lfq5kggg8kZY2gWQQCAcpafbxXHljxYmUCchyy9Ju7TN07iAwEAq5CEZ6xEl1br1Qg7RfoqgrkdTjic2WPR7So4PVDtu5IfR/z6RpRGyLezJhMwJWRkHJyJxP2/naSCvRmFQkcVaLKdkXZAlKB8ko5GWP1D6/AKh+ANDFti/w4r6uCJV7ioPLls/dxj4WyimqRSagfxkr2jEdC8jmr1PAdWC1btgynnHIKNm/ejOXLlyOVSmHz5s144YUXEI/HfX3WIYccgnvuuQdvvfUW3nrrLXz5y1/GxRdfjPfff59uc84556CxsZH++/Of/+z6nPnz5zu2efzxxx3vz5kzBxs2bMDKlSuxcuVKbNiwAXPnzqXvZzIZnH/++Whvb8drr72GZcuW4ZlnnsGiRYvoNi0tLZg5cyZGjRqF9evX45FHHsH9999f1mJ9adsTAY1PBg0+NWZZ9mTMr5DsJsw8Y6Ve4ZG0HO9j5Ue8DgDjGqpdVWOAc0KS+VjFPAxCRcceCriDDVVbFcA5yaYzbIWRRmDFVAY2d4oNQtnjT6TFx84Kr1ljQp1UIO93RDVWEsaKDTbYQddrUmLbuFB2JuZmrMi9LBJBi0ADqz1tueNQGL8Cznu504MlcqXHNG1D+EWM/ZtygRXz3HodC+0XmA8y0pJnircSYKF6bmWshtdiyBbr5xkrQQVtFVcV2EIaMFeqlSpEf6VKBcrE6yo9WW4/m/3xnwr01lh1JDMO/aLNWDkZeQKyyDjABlYuxkpe3WozmN4aK51AUlRtKWPMRYwVYeyqJfdzpZ9UYH/QWN1999146KGHcN1116G2thYPP/wwDjvsMHz729/GyJEjfX3WhRde6Pj7rrvuwpIlS7B27VocffTRAIBYLIYRI0YoP6eqqkq6zZYtW7By5UqsXbsWJ554IgDgiSeewIwZM7B161ZMmDABq1atwubNm7Fjxw6MGjUKAPDAAw9g3rx5uOuuu1BXV4elS5eiq6sLTz31FGKxGCZPnowPPvgADz74IBYuXFiWwn2RKBSQpAIl4nV28NVtwuypsZLYLeiI1xtqoggEchoRMmkCnE4n39aD/Q55E2Y9p3bATodkBYOJbFUlqzDSYedICq+tK01XqrzGSicVyBsMEnYjpZEKdPlYeXhH0XRIxnLs63W+VIyfZjRWTEBYwYn1VaasLMg98tHefGAlCHocYmXmmHkmybUfx8boMhuxcBBtCftec2msaLslJsij24iH7HpOvC5jatnz51NGsr6aAPuscyyzB/NK9qNpT41eli0eVgsEZMIm+6nS97zdAhv8iM6Bvf8py6ydCsx9V5axaqA+VoxusCudoYEWYawOqVczVsTrKhBwe2rZLV78VQXyTLzKJJmAvx9y+3kwVn5SgRGWsRI/f+VcFeibsfr4449x/vnnA8gFPe3t7QgEArjhhhvwX//1XwUfSCaTwbJly9De3o4ZM2bQ11966SUMGzYMRx11FObPn489e/a49l26dCkaGhpw9NFH48Ybb0Rrayt974033kA8HqdBFQCcdNJJiMfjeP311+k2kydPpkEVAJx99tlIJBJ4++236Tann346YrGYY5vPP/8c27Ztk55XIpFAS0uL419vQdaIWcRUyFxsHe7ckjYX0sBKU2PlxyA0HAqiIS+AHDfEtvoIBAJCbYrM1V1kV8Bur2tBIFqBs2AnslTatgjQSQWSiaOpI0mriGhVoA+NFWAPYCwLogoiaZrXZRCaTwVKNVYk9ZJ13DteE7BIY8UOunylnJeHFcGhQzjGSlSUwImVCbx0TTyrp1uEQf13UoSxIr8pEa/nry1zrbw1ViSwSuUndIkwOxigxsEuplnx3Nrpe04X6amxci6iRC2CeH2kl9UCAV8xqGrC7NaB5v4WBSiAk43UTwU6fyNRxXBFOER/f8LatHSl6DmPjOulAqMht6ZTZZiprArk2UgNHyv+fmD/X85Y+UgFMq97VZf3i8Bq8ODBNHAZPXo0Nm3aBABoampCR0eH7wPYuHEjampqEIvFcM0112D58uWYNGkSAODcc8/F0qVL8cILL+CBBx7A+vXr8eUvfxmJRILuf/nll+O///u/8dJLL+HWW2/FM88849B67dq1C8OGDXN977Bhw7Br1y66zfDhwx3v19fXIxqNKrchf5NtRFi8eDHVdsXjcYwZM8bPz9MtyMrsRVoQmXidXf3ImjBnLTi0ZqqVL/s5hRiEArbOikyaBCIBu6w6yjZqFJ+vkLEKuFdpXuxcMBigE3fah9kgYA+mO/Or2UDAXv3x9gOAOpVDAjG2zFtVsSfTpqh8rABW1Go5GBGvCZj1IaOMFetjxVXKqfoEsiCMFTlvUSqQFysT8D38ePBsiI61BMCyw85zsTVW+SCTrQoU/CYsSMCdyVq5xsQKDZTM2FfVI87tzi1PLbGIcsGGUGPFpT7twMqLsfIOrGTidVbcL8o2ODVWepW8fNpR5CsXDNrGzURn1ZivCBxUFZEyOCRlRrSWKlbRT19EwH7WeY2V0m5BpLGSBOa1XFubLY0t+DRfTKJjtyDVryoq2UsN36nAL33pS1i9ejWmTJmCSy+9FN/73vfwwgsvYPXq1TjrrLN8H8CECROwYcMGNDU14ZlnnsEVV1yBl19+GZMmTcJll11Gt5s8eTKmT5+OsWPHYsWKFTR4mj9/vmObI488EtOnT8c777xD/bZEDw7bSb3QbUgwoUoD3nzzzVi4cCH9u6WlpdeCqwr6AHt7NclSgar2NHwKhaf95YEVn9P3pp5ZXHXqYfjft3di5kRnoCvSlEnF65JUoGolLkqPiSYKHpFQLg2XymR9pT3Jau4fB3OBVV1FhB6DirESHYvImFCpsZKkeVXO64BT5EwGcxkrwILtjydirNxVgd7idcCZLgbkrGgoGMinfdyMlSz9Fsr/bnZLG70JmPze5Bz4tjnCljZJdUAbC4dQEwujLZHGgY6kp1iZtcQgSKoWFQVqrPhFFE3hMufBpwJt13X19MS/LzbodWuBAJuVkY05BTFW3HfJrFiqYjnjZsJY/aMpR0iMkrBVAJsKtBkrHjSI9ZkK5ANCLY2VwNpBngq0G2b//NVPcO/KrUhmshgZr8C0sfXCz9exWyjnXoG+A6tHH30UXV25CPvmm29GJBLBa6+9htmzZ+PWW2/1fQDRaBTjx48HAEyfPh3r16/Hww8/7BKgA8DIkSMxduxYfPjhh9LPmzZtGiKRCD788ENMmzYNI0aMwO7du13b7d27lzJOI0aMwLp16xzvHzx4EKlUyrENz0yRtCTPZLGIxWKO9GFvwk4F6lcFZrIWMlmLESHLV3bsHJXOWiDkQUIxYbPf5aeaisVXjxuNrx432vW6SFNm+1jJAitxOkQl8hRrrOTMCQms0hlL28cKsMXrO/OBVX2VvUK3K8f02DORMWFS8bsHBUJ9QG0QCjjF65QR00jxssEEMeasElQF2qlAte0DwSH1VVSTB6gn0gTsIAmwGQUZS8RranQnYJl4vYLTWImqAmXHAgD11ZFcYNWetIMkBfvkR7zOl9enNRkrwhBSuwVBQCyrCpT1CSQgdgv0uzSOm8DrWrFpPd3iGv672N+THTuroyHshX1//SPPWMkqAgFBYKUyI1Z6dqn1ZJmsRau81b0C3QsvWYcOwiz++o3P6G/ylYnDcM/XpiqqAr3tFmh1bRkyVgWlAokWKRgM4gc/+AH++Mc/4sEHH0R9vTj69APLshypPhb79+/Hjh07lCL5999/H6lUim4zY8YMNDc3480336TbrFu3Ds3NzTj55JPpNps2bUJjYyPdZtWqVYjFYjj++OPpNq+88orDgmHVqlUYNWoUxo0bV/D59iRoYKWTCmSNC5kVgGplJxP9yuwZCOzcuNP/Ryc9poIfjRV5WLtkdgtCLY5cY6UsTWaqdex0kUZgFXUGVnGmh5jdX0+QClQxVkmWsZKfqyxd1EWr8WR2C+5UoE7AzFY5dgha2vCVcl2a4vVoOOhgAkSpQEDcL9CrEo/fR7c1Ex9YdXJslIix8joWwFkZqEpLSoMNxXMb5s1QNYMNW1BNAiu3JUhV1Hm+Xn0CCXjGSpwKJBorcSpQNuY4GSvdVKDzN5ItdCq5Rc7nHsJ1wA6sqHO9IhXox4sQELNzsm3598TO6857jlynZCaLykgId18yBU98czrVyoqgw1jxHmnlBN+M1fbt25XvH3roodqfdcstt+Dcc8/FmDFj0NraimXLluGll17CypUr0dbWhttvvx1f+9rXMHLkSGzbtg233HILGhoacMkllwDICemXLl2K8847Dw0NDdi8eTMWLVqE4447DqeccgoAYOLEiTjnnHMwf/58yoJdffXVuOCCCzBhwgQAwKxZszBp0iTMnTsX9913Hw4cOIAbb7wR8+fPR11dHYCcZcMdd9yBefPm4ZZbbsGHH36Iu+++Gz/+8Y/LsiIQEDM4rLeQIxXI/H8ynaX76qx0AKdppld3dH5l5cfbSQXRSl+m96LO6wzjw/aGE7s4i1Zp3qlAMikl05a/VGB+QNqXN0AcVMkyVm4djsxuAWAYK8ZuQVaSD6iqAnXF63Yq0EtzBNiaN4fzusgglJugvVKBADBmcCWtupJNFuS4HT5WRPsk01hx6VJd5pVfaZNzIt8jstKwj0U+ZLNeVtTUUsMxnkCly+IZCl1rCd7HSpSuruQ0Ry2dmoyVS2OlqgoUM1ayMaogHyvO10xu2OtMy3tZLQC2px2BMhXo2yDUvh+SmoGVaCFCzZi58z16VByBADBldBw/u+xYHD60Rvq5BE6NlawqUKwLLgf4DqzGjRunDCQyGX17+d27d2Pu3LlobGxEPB7H1KlTsXLlSsycOROdnZ3YuHEjfv3rX6OpqQkjR47EmWeeid/97neora0FkEsjrlmzBg8//DDa2towZswYnH/++bjtttsQCtkXY+nSpViwYAFmzZoFALjooovw6KOP0vdDoRBWrFiBa6+9FqeccgoqKysxZ84c3H///XSbeDyO1atX47rrrsP06dNRX1+PhQsXOvRT5QZRoMEOpuyDww4aOV2V3TyT35bAEViJTPE0NVYyHZRfVAgYOrnGiuhc7G03N7Ygk7VQVxHGUMFqihd5At7nmvtutxBWh8XhhZ2DBKlA7apAgVmsrJ8ce3yuXoEeBqFhZsD101ybZRtpr8CYm7EilXIirY4MYwdXY+0nB/LHp2Yo2OfD28fKTmlblqUdbLCMVSZr0etWQdy5mSIMovP0y1ip9FIyNlJnUeGuHNMVr/OpQHdVIE0FJgpjrNQ2ERKhvuT42UBSt1sC39JGJuYmFW+EsSIaSlUqkG9KrGTnVKlAwb3JaqycbY3k19Ye0wSZCu7YTjhsMN760VdQXxWVdkngUamTCuxPGqt3333X8XcqlcK7776LBx98EHfddZevz3ryySel71VWVuL5559X7j9mzBi8/PLLnt8zePBgPP3008ptDj30UDz77LPKbaZMmYJXXnnF8/vKBbwoFODsE5gHJxAIIBoOIpl2PlxNHc7mvyxkZepe3k68yNJvVaAMfD85QOFjFXazAm9+mpt8p48bLBwAyEeIdAVKxopxZKYtXjRSgbV8YFUp0FglRYGVe/Ilg3mHIOgUHYtoRQp4G4SyVYF+tHOshqo9IWCsos5rm+CCERXY6lFREAmIg40OAXMm28e5YFGfb4xZabOBPQkwyG9B0lDRcIDqJNUaK5uxUorXJT3lZBMjuw8VOGf1FgiuljYCppG3hdG1W4jraKwEtgDs8cgZTDtwINfWb0sbWSeEaroA5BkreWDFa5GUVYEZy1V4ZWs71RorlslTESiU5RLYLYh+0yGKtJ8I1T5Sgf2iKvCYY45xvTZ9+nSMGjUK9913n++2NgY9B14UCqjtE2Ihd2C1uyUnrBxW66apAwG7yWpW0D/PSxhKtvPDbKggspfwYxC6flsusPriuMHCzxelUHQ0VrYeIast+gXcjJVDY0UNNRnxuiK9QUq82xnGSpUKlGqsPAxCWRZHl8EBWM1Yll6/aiagcbe00XNeB4AxTGWg7B4LCVbgdlWgt0EoO8F4MRu0mimTddyr5Ddl06xd6Qyi4aDnsQCMl1V7UsnIeDJWigCFb8Ls18fKZhqZVKDLIFTXbsGbxZHpybzGnDATOHiNZ/Z3OYM42djAFpKkM1nsyo+xhygZKy4VqBCvk2NgFxEqY2KHxiqtNz7xQaSjQ4fGYscLlRqpwHKuCuz+L5DHUUcdhfXr1xfr4wyKAF4UCji1Brz2RWS5sKc1p+8ZVidecYi0OL7tFnxocVQQ9ViTie/JQ5nO5nRPlmXhrW0HAQAnHCYuwhBrrLxF1A4LAh9Cfb4BraMqkEsnkf8HJFWBhLEStbQRsDiyqsCEl90Cu9L3oSejmrFkhqZIqgSpQJdBqId4HbAbdQOqVKAd/BL4aWnj6D2nWRWYSGVpYBwN282ko6EgZYNJ6tPLUwsA6vOB94H2lIeVhpjFUYnXC2nUy36WLV53H5fbx0rPboFncYQ9DjlBOYFnVSBj/prSbGnj8rGSjD2s9cnu1gSyVm5flZibX2SJ2/AwgZRLU6ZirNwaK5WHVW4f/n7Q96zTQTQUpN/h3dKm/AIr34wV7xxuWRYaGxtx++2348gjjyzagRl0H7woFHAOKDzVS20QGFZLxVgBuQEoCc6CgA7qEtEht4pVGRP6gUhTRjVWXPDABgZd6Sx2NXdhf3sSsXAQU0YPEn5+UBhYaYjXmUAy7SOI5CcONh3LTrCJfGsMpY9V1M1YqVKBMm2Kl81BuMAgkjJSTBNmh0Goy8dKz24BcHpZyVKBogVCp6Z4PRdEMhOLl8aKYWxpRSBzzUgXgfZkhh6Djt3C4Orc/XGwI6n01JIbhMpTXm6vI3Lv6Gms+Eo5p49Vnmn2mQoMh4KojoZoIK7ShvHpIq/AUNTSxisVyBvGyhY6LGNF0oAj45VK/VEsHKTZAdFn8ueSSluATXBrpYadnl3+9GTs76tTUOKFQCCAqmgIrV3pPtmE2XdgNWjQIKFR5pgxY7Bs2bKiHZhB9yH2dZIPuLwjNADsac0FVsNljJWA2fBkrKiPldNuQcfvSAWqw3HojvKO2xLGCshN1iQNeOyYQdLjFgmcdcTropSRDl3uCqwq7ZGSTcV1JvOBlYKKVzFWSud1jtXwMghlUy9+gkhyr7Z0puh9IawKTDmZDx3GalBVBLUVYbR2pRWpH5HGSp1+o5MvY/waDMBToEsZq3TWdl3nAqaKfGBFztfLrBSwGauD7Ul6fdR9IDmNlYLl4gNPem01WRwdjRUJqAljxVf9iVBbEbEDKx92C14FM2yw4TcV6PKxcgVW9vnawnV5RSCQCzSqoyGaJlU1TgfcVZAqSxs2+PSqluT34dlyoDiMFQAaWHn1nO0XjNWLL77o+DsYDGLo0KEYP348wmHfH2fQgxD5WKlaG5DX2DYve1pyqcDhdeIHP0QHIEbr41ExxK80/BqEyiD2sRKvwoNBW6yfSGexPi9cP+Ewsb4KsCeXrO9UIFN148PHyq2xsica9vhJOknV603EWNFUnagqkAycFhdYeTB0NPhkgkidgZYEivvbbZ84mUGoZVmeRqUsAoEADh1chfc/b9FiKAjsVKBMvG7rjmyzVe/jYauZZC2C+NSnV0sbwNZYHehIYlhtbiGkSgW6nddV9wOvsSLPlZd43cmCiw1C7aC5K2UHkzqBVV1lGLtanN/lOO6QOIhUpT0B58LCfypQbi0B2NewPZGhNiAq4TpBTSxMAyvRcQcCAURCAYepKYFOr0B/fRE5OUf+v6FgwLPLgi5yz11iYFQFnn766T1xHAY9gKr86pZUe0RCQeWDExVQq7tbSSpQzVixz7HMz4SA11jZaYtuBlYisb6ClakggUkqgzc9hOtAYXoy9rtTjO5IJ4h0M1bOiYYcPwkAVEL6Q+pz6bC3PzuIpo4kBlVFlakfWYNt716B5FyzvgJmMrnub7OdpdlrVslVyum2tCEggZXsWPiGygDQka/E80oFplhrCY1JxRlY5b6PZ8UqmUWRZVk0wNKpCmzuTNE0mh/ndZutcH8HW3EGQDuQdInXBQsR9pz2ttrm0LzGUARW4O6nKtBO70kWf6xtiGbDab6ljVxjRcaptG0OqhFYORoTKzwCU5mMq62NquODQ2OlyGiw4APthMdiuhCQZ0JuRtyPAqs//vGP2ttedNFFfj/eoIhgJ4SOZAbxyqBeKjBtV3p4MlaCtIJXsMFrrIpVFchrrLJsqbTgWCoiOWp927527DzYiWAA0t5VgHjy9WO3kGYq5XQGoFAwp7Uh5zOIqQoEcte3pStNgx3V7/7FcfWYNLIOmxtb8Mu/bsMNM49SsmeyyZfaHEi0TeS8Mhn7t9draZPb5kCesarmU2NRJnWbzniK6HkcP7Yez23ahcOGVAvfDwWdbAPgQ7zO2mjoMFY0hWFrqPjJg/weXakMEuksbTOiEq+TwNuy7ABFbf7KpQKVjJXz3k/raqy49lUiFodNa5NimepoSIv5YE1ERfo5XhtGoNIXAjILAj0WRzcV2J7IaFktELAMtpdcwZ0KlC9ywswz67d9j0snW6Q0IGCL/GOSz4xx91Y5wXdg9dWvfhWBQIA2ICbgXwsEAr7MQg2Kj0jItkPoTGYQr4woU4F8lUVLZ5pOpEMljFWYpsfs17zKbl1uzD7SYyoQjRUJNLwqtUjJ96sf7gOQcwiW9a4CGBaHufWTtMWLN2Pl8HbSPNeaijCdfHnfHt6CQKWRCQQCuO7M8bjut+/gqde3Yf5phzPpEEFVoCCIZL9LlvpkV+2F+lgB7vRbzlcnFzR0JTO2VkdDvA4AV55yGM6aOBzjhlQJ3+dX4IC3YNx5rvqLA3LMbCqwkjsPNq3NpvJlaUkgF9TFKyNo7kxRJkxcKScTr/vXWHlpBXU0VsFgABWRILpSWezJF8t4WS0QeDFWtHelpAmzLBXo0FhppwKdKVa587rNWB1oz22jFVix3k6SZ4oPZAnUTbntYEy3kMilsfLIUhSCMYOrsH7bQYyWtPop51Sg719h1apVOPbYY/Hcc8+hqakJzc3NeO655zBt2jQ8//zzyGazyGazJqgqAwQCAepfRIShtouwINDgblSSBoxXRqTMQFCw+lW5tQP2Q2v7WBWHRubLtr1KgMlK+dUP9wJQpwEBNWOlEnuS/ZI+fawAOx1YVxF2reB5QXdS0IeNxTmTR+Dwhmo0d6bw23WfKY0PwwIGJ6dt8iFeL6AqkIAPZkilHJALvhKavQIJgsEADmuolpoe8oEDm37TaWnj57qyKfdODY0VaWcTDQc9WZwh1U5WUxwkSTRWPnysUh6MD4E0FcgFkiRg3E0DK701P7udSjfq33nd/o30U4FOtkg2NhAbkfakP42VDmPFa9oIVFkBh8u8NjvnTHuqMiGF4s6LJ+P3156Mk48YIny/nO0WfP8K119/PR5++GGcffbZqKurQ21tLc4++2w8+OCDWLBgQU8co0E3wLbHANQl1bzGyk4Dyv1VRNVU3r0CnZR5sZow86xHilnJCAOr/PYf720HIPevIggKgg2d1iqsQSh1rNZlrPKDKZ8GZL+zUyMVCOQG0GvOOAIA8MSrn9KydlE6R9W9Pvfd6lQEW6auozviNUZVAuaQDST99ArUAW8v0ZXKghDwXs7rqUzW9mLTCKzIMSfSWdpE26WxYq4tEa6rzEEJ6rnAShhsSFOBxJpEEFhxwmxdNtIlXpcExOTcdudTgbqBVR3D4nr192QzKqpCD34/3WDDL2O1u7kLbfkuA6M1xesE0lRgyBncEajuT/aZ9VoU8/vwjFUxzEEJamJhTDu0XroYYjMffAat1PD9K3z88ceIx+Ou1+PxOLZt21aMYzIoIvjKQD+pQC8PK0Ds7aSrscpaTnPFojFWNIhUV6rwOqHp2oyVyLNLlQpkgg2fFZBEZyBqKVTJ6HDYY1EFG5ccNxqjB1Vib2sCL3+wJ3d8wgkpv9K33EEkoHBeZxgKP30R+aCB11gBzsDZ1nrpMVZe4Bkr1vtN6rzOsDg0taQRMLMpDC/GqiuV1fKwIqjnAnC13YKMxVFp7nhdpIfGysVYiVlVsgAkY05dpW4qUM1YsYs1lsFu6sxZOvDpdYIQwz7ppgJ53ZEs2CDPdGs+qBpcHVVq5wiqHKlAtaA7xaXHKKMkal9FWL2MndL2CpD4gFXVDqmnwB5jubFWvn+FL37xi7j++uvR2NhIX9u1axcWLVqEE044oagHZ9B9VNBUoJPFEQ24fM7ay3UdkAQbns7r7GCX9aVPUYFvaePlP8NOZocPrVY6HwNME2Y22NDQ+oh8rHTPtSaWG/hFEwDP0Hn1aCTfe/Vph9PjkR2LmLHKfU8woLDSYPvn+bAgcKcC3YwF687utyrQC3yalzwvMUX6jW2DQ9v36KQCmQWMLLUqakqtM/kSk1D6XR6GkCxUzy21GrFyRSHazuucxsrLgoCw5LoaK9aSwY8bOSmSGFztZoLZ/TK+UoHOINI+V77i03lve3lYEbCMlUgXCbgNWQnoOYgE/kzQrC1eZwK0tI/7oZhgr3e56ax8/wq/+MUvsGfPHowdOxbjx4/H+PHjceihh6KxsVHZVNmgNOAbMasmU3KjkkmLrB5lFYGAONjwYk7YySfBtGTpbksbvlGv1yqKHfBO8GCrAHETZjp46jBWGf2Bi6CGMlbuCcDur+dtt8Disi+OQUON/XlKsTKzymeDABk97wgiaVVgAYxVzB1E2P0RM54ier/gWRwdewPWn8xPUQJhGxIMY6WyW9A5FgKdVKDMgoAuEjyYH3Yi9dRYcWJqme8bTQV2S2MlSnOJGat9bbkATtYcWFQV6Nk/j+s3KU8FOs99VNw7DQg4FxvSFCYXyBKoNHGyJswqsGN4OmN5LqZ7AtGQ+NqWA3xXBY4fPx5/+9vfsHr1avz973+HZVmYNGkSvvKVryi7YRuUBna7iBztrGrP4Gas1B5WgB1ssCuklEdAw9LRbMVT0TRWSW89GeBkmbyE64BY9CsT47JgV7J+tDiA7eVTL0gFyhgrWZqA3e+qUw/HT1f+XXosIibSyxwUcLqR+2lp4xYzC1KB+cm4i2WsNKsCvcCLs3WaHrMsjqoXGw9HKpC0tOHOI8akeantg8J1nWAwF4CrfKz4ik+i9xEFNeyiJ8MwdN7Nelm21rYbkTFWfgMrkjIMBCBkFh2MVcbNWPFifwJnmlfT20misXKfK89Y6QVW7GLDq82LKxWoCA6dFZB6QST7W7NMl5cOrZgIBgMIBwN5/63yYqwKskoPBAKYNWsWZs2aBQBoamoyQVWZwl75OulpZSoww4vXNRirjJuxkq1e2AeC1bJ4rZK8QBmcdFYrXcHqhFSO6wQiN3Kd6jRbUMqkAjXF61NGxx3/ZcHqcAA9s1KCb5x0KP7fSx+htSstDB5EOhwvc1DAuWrXXekDuYmC2CkA4lQgW4hBWDqZ1ssveIZOp+kxGzCS30aHiWQDK8ISqcTrflKBbsZKPpHyq3xSzCAy5nRPpJoWBGFbd8SyKHxATFsa5Y9Bx3U9t13eCDUUFM5BgYBtOcPey8SIdkiNOLBysDh+qwJ5PRm3X878NkB/w0MkdgI8HKlAj0WrKxWoTPvbAaGuLIN9P52xekS8roNoOIh0MlN2gZXvX+GnP/0pfve739G/L730UgwZMgSjR4/Ge++9V9SDM+g++EbMylSgxG5BxVgJgw0NCwLy/R0Oxqq7qUB74ulKZ5hO7TKNVe4YRtRVaA1uwYC9siPQGVCo7sGnoBsALvvioXj737+Cf54+Rnr8nT5TgUBOw/Kzy47FpdMPwSnjG1zvU38ywXVVBVYsO5f2kR4LBAKOIEklXu9K2W18isdYOa8tYXiVvlFMsEGugZ+qQEcTZo2qQJ1UoIuxEqZ+nOwcAWGsRF5u/ESqa5HCumOzxQ/82MD3QNRmrPIBmCoVzwc8lmV5aqzCgjSv7rnSVKBibGDvK13GqkrHbiHsPFcgd74qplyosfIYQ1hyMJ0tjXid/b4+L15//PHHMWZMbpBfvXo1Vq9ejeeeew7nnnsuvv/97xf9AA26B74qUJUKjDGDoI7rOsC2tNEXrwP2IOUIrLqpsWIn5o5khtLhsgCPTF5fPGywFuMqciNPpLzTYyxDkC6gAlKmA+F7I+pUKLI4a+Jw3PtPxwgDJTalR6DTn481n6TWEprnygbGIrsFcpxtiRS934olXndXBeowVvZ5FcpYUd2aoAkzkGNEddKSBCxjFQ4GhA2hZa76hLESBTX8RKovXrcDbXJ/hoIBF9PFB426gdURQ2tw/pSRuPLUw6Tb8J5sbYk0PZYh1RLjY5Z51U4FclWBinGQXTjoBlY1TCrQqzCIZXBylXv594uksSJ9CXP7Fa8AyS/K1STUdyqwsbGRBlbPPvssLr30UsyaNQvjxo3DiSeeWPQDNOgeyMTQwelwVKnAVCar5boOiFNGOg8n+S7CpIWDgW6nk1kH585kxvNhP3fKCLy57QC+OWOs1ueTKrCsT8YqTOl5xjSzmy7zgMB5vYgCUpETuZc5KMBXQPpbxVYwxy1irIi9RFNHir5WLPG6rTNxVgWqWKKwQCuosziwi0RsYXoFd80KTQWyDIzsd+dbrwA5VsNmrNxpuEDATt+Tfo2A9/lGmfvBTpuLGBznuemmAoPBAP7z8mnKbXL3ZIaOUSQNWBUNSX9TltXTTQVGOA2mirlnFw66VYEsyyW9toJUIPv/Ko8ytpm4bsstUunsZU7cU4j2F8aqvr4eO3bsAACsXLkSX/nKVwDkHkzjtl5+cPlYKYINdrWzR8N1HWAEvLTrvd3XTKcxMTmuYq10WBYn5RH0HD92MP74b6dqCdcBm50jA1WWmWBUEzxtOp321+bFC27n9eJZEJCYQaSx0hKvszocTSaSZW34knTAPt/mTjawKq54nVYFagRW7GmRa6Al1HcwVuKgqaLAqkA2FejdcNoZNJO/ZWwRe211LQhYxkpl6sqPMbp2CzpgmRUA2O+RBgScrJ52KjDs/B7VQodcy2goiAYJa8ZDxyA0KkgFsv8vNgNmNFY+HNRZPZdXoVBPQdbCp9TwzVjNnj0bc+bMwZFHHon9+/fj3HPPBQBs2LAB48ePL/oBGnQPvLeTikUgN2kik8VuDdd1wM1YsSsHncCqPamvTdFBZSSEg0ihM8VorIr0sPPVVA4xrjIVmH/4s2wT5mIwVs7gtJgCUjFj5UO87rMxMeBMdak0VsTcMRoKClNdhYD37bLTb/IhkqRDUhmLVkz6rQrskojwadCczjBCeu/hujbf+iiTtaSTXEhgt9CaSOXPSR7ARUJBJNLZvMZKV+Rsl//LrBaAwlOBOghzTNJ+D6sFgL0fsvqpQOZ3tSy1oJuc76hBFdr3MNvSRqYp4/uw8v/v5cTvxw4mxLC8fmUIxQLfLaRc4PvufeihhzBu3Djs2LED9957L2pqagDkUoTXXntt0Q/QoHugBqGcG7loAmAHfB3XdYAROXPeLYCeG3mnD22KDtiVvp+qNB3wk69DjKtMBeYnF8azqziBlT35ZvIpGqA4g5soxWuL1/2lPXV8rHKfq6exas6nAovZ8JXXHekKxkk6xA/zKjIIdTFWTNDsx3k9GAygviqCfW1JeeUYl/YEmIrAWFirn2JSk3llfaxUxRU9Glhx2icvqwXAqcvSZ+eclhRqjVXu/HT1Vbl97N9I2jyaMykF7MV0UGJJ4biuPuQEbCBJxeuSQqGeQr/RWEUiEdx4442u16+//vpiHI9BkWGnAnMDZ1LDIDSXCvR2XQfYJsxOxkrmK0NgpwLl/eoKQRWjKSu2G7ArsGKcyFXHTx7+LiYQKwZDx/p2OQLaojBW9vFlsxaCwYBvxsqPjxXgzViR4KOpMzcxqvoz+kUo5Ly2usFMJBhEF+w0l55BqD0hdeSrD/lglU1p2xWKeudbXxXNBVaSSU4UNLcR4bogoCVgU4i6tiH0XNOWMhXIs3HFTQU607z7dQIrZh9dbyfeRFVlHkwWDr4CKzYVKHmmaCqQGQ/sIhK15s7ZF1EjFSjYr/erAnPHkCizwKp3fwWDXgcNrFL6qUCWsVJVBAKC9Bgj2FSJ0W3xeg9prJhgo1j0ND8hsStw1bmSyZYEJoC+j5UKdrooW/TAKsRMIvz5KtOeZBWb9V8ByQYXwpY2Yad4vScYKzJBdEi0TzzI72QzVvqpQABo6SSBlbgq0CFe1wwkSWWgnLFypsYA1hxUHtCwzI+qRYrwu7JZpakrHzSKLB8KBX9tiXh9sMTDit2HFerr+liR71KlAonh76GDq7TOAXBef2kTZub5o8fiMQ6yGiu/4nUgf64lcF5nv6/Pa6wM+hZsHyvvVCDrr7OXMFaKikDA3YRZ9wEjg1CHjwlJB+yEpGLnCgEZtLKuQEM94ZEJiTVDLSZj1ZXMIJEvHAl4sGe64J22AT2NFe2fl2ErIP2nAlUtbWgqsEgeVoDb26lTM5gh94Q/Hyv7M1u7cuei04RZpyoQsAXs/397Zx8eVXXt/++8kwQyDQkhBEKAgkh4sUquEKiXohBEXqzeq7Z4U+hV1B9atAFa0V69+FTxXahWrtdr1V5p8blafOpbCOUpbwoRECoQK1RFQRJAyBshJGFyfn9M9pl9zsxk9jnZZyZnZn2eJw9k5sxk731mzl5nre9aK/pGGu6x6qo4KMMdQawcs6UN01hxdawifV/4de7tc3fp7TaKviL66ebgta0r0Xh3hPrsb3V1Lbz1+8PQp5cb8yYMFp0GnE4H+vRyRy3qy49BEwqM0e2Bb7AtWseK/1tGPV0y8XZ+lmwfCiTsRZouK7DLUGA3PFb6UGAsb0KoQGhnKFCyx6qlPVTHSuQiIYI+U040Cy+kJ+s6O8cofG9EUU+hKE7uPYIXZpdYKFBTxdmYeJ1/30hGBHu+qdO7IqvUAhD+OT4nqLFir2PnViQUyN9EMNsmaq9AvqWNaCgwhseK30gZXRUHZTBjo5X3vAoWzWwPxAoFhuaWKVFfFRyDdr6xioMCWo2VaLsil9Ohdg9o7+jaizM4Ox3LZlxscCbAL66+GJ+fPIvC7MieLk+EUGDbha6NYG0oUPxmNOSxUtR9JWHidfJYEfFE34S5y1CgK2T9Mx2LaFYgq9AtmkGjDwXK0ljxhqRMMTcQninXKli7RR8KlFGzCwgZFud5w0pa+YFwj5UqXhcohnpBkwEpNletxiq6eD30u0yPVefmwlraqKLyri+RbL6hAqGx5+pwOOB1OzV32dEqr7dd6EBzp9HTVYYiT98Mj2ZsYWOO6LEKes669FixuXLjjmU086EakfIDgFx9FaA1AADg2xjtbPjXsGxPQOwGweN0oq3TWytbigAAZRO7rrkXqaVNqCh07M+DEc8THy5tk3wTK0qk8hI9AcOrMGzYMJw+fTrs8fr6egwbNkzKoAh5sIuxSCiQz1ZiVddjZQXqazu1BcSMDX0dK1kGQRon6A7VsZKcFaiIa46A8LlKKy3BeTVEPYWiaHvDaUOBXYnGI/UKFC2GyhtKkUId+sd6QlagW+fFEfXO6QXN0XoFAkDduVBBSxGy0rv2WLlYCIfXWKk9+mKL1/nG6UbavHRVB01rWEn2WOluiM50hgKjVV0Hwr+zgKCxwSVvtCagf16kFi+xkkj4fq9GWtOEeqB2JC4U2Pn3Nn16EmurvsJf/34Sn9U2qTcKicLwJ/jIkSMRC4G2trbim2++kTIoQh7sgnVeLbcQOxR4qqlVqOo6wLmRBaoN87ALcrNVHqv2gHohkV7HSte93hsjJOXRaaxkCNcBbdsT2XfHfPPaDtWwEhev87WOhFvadM4n3euKWNtHHx6UGQrk6xYBYi1t+NcZLRvidTuB1tDv+jXlf2d1u0QNqwH+YKZZtOrlHtOhQONJGLzhdbaVGVbRw7yAfMOKF91r+gQKeKz48L2IN1IVyscIBVpFpKr6sYoSmymGGnxdBIMszh4rVotsy6FT2HLolOa5Pb+a1mWtMisR/gT/+c9/Vv+/YcMG+P1+9fdAIIBNmzZhyJAhUgdHdB+1pU3bhWAzzi5DgcHH2EU2VtV1gGtMrBgTr4eVW7BAY8V8bbLLLRjJkgNCc1M3X8neOb6Zr8yLODOs9B4rkUr8fOaYqLHHapBFa3ysL6JprceqU9cU4/Pv0Z9bwRsE/jz53OGFTp1OB3zuYEFO1udNVLw+rSgXy2dejCsvzo34fETxehftbBhsjdjnwOlAzOKW/HfvbGv0bE7+nMsOBfLi9cbzF9SbS5E6VrwRKSKoj+Tp8rnk3QDEgi/lwYhVGoMP36s33kJ1rMJF79HCjVbxsyuHY4C/F74+cw7H61twvP48jje0oKUt0KWGzmqEDasf/vCHAIJ3svPnz9c85/F4MGTIEDz11FNSB0d0H3Yx7lCChkBXdy/6TTmWvgoIb48hKn5kFwDZWYF8/R8WprSqjpWwEanTeMjyzvGhs8bOUI5Mw8rtdKANETRWXYYCI2SOCfcKDHmsIsHE+urxUutYacNFoTpWXV8iVc9GmzGhPn+eos0jzevS1OeJNRaGz+3C7VO+G/V5XqzMEMoKDNOTiWeOAaFwY6xyC/JDgSEDgFVdz/C6hG4Q2FxFk0JCGcBcCDGuocDOLEzOY1XT0AIguljfTBNmgDfIuq4ybyXfSffi1ivCJUgtbQEpOlazCH+COzrvPocOHYpdu3YhJyfHskER8uDvuPnGxJG+OPo7yVgZgUB4mrpxj5XkOlaceJ3NUdZdlGpEqhqr2L3zgPDNVlqVec6D08javMj0WOn0cyGPlYB4nfNYCYcCvV0bVvqN0EqPFQvbxvISsXPbakC8Dmi/f9FS54Pntz3mcUaJVJ37bKcmpSujRp8BKZo5xjyfLBTojeDB8bmdakadfI9V6MZGrboeI0TEXtNi8LyytW3mSqvENxTIvHOhc/uPk2cBABf17x35NZ1jVpTQzZOQxoqvf2XgdfFA1LtrFYZX4csvvwwzqurr62WNh5CM2+VUL+ItMaqR6y8AsfRVAMDeJqATr8cUdLuZxopVXperO7KiVyBfs0tRuMrKghorhizxutPpUM9ZA9c/TxZ8LzAglA2mD8nx8FlJotW5Gcxgy4ii8wkzrKzICmShQMHGxyFjw5hWkB97NEOV3xwcDnlZkJGaMKsFQgXKLRip2QWEPv9qKDDCPBwOh2o4ZqbJ1liFjA2RBswAV59MTTgRW3tVT9ka+jzIrMkVi0ihwMOdhtXw3MiGFT8+I5ICXruWKPF6T8XwKjz22GN4/fXX1d9vuOEG9O3bFwMHDsTf/vY3qYMj5JDGlVzoKhSoN0CMeKz0tZ1ii9f1His5Fx++vASr3yJL06QvQWA0KzDS+3QXthk1npfvsdJ7cVrVrMDofyNUIFSJKZrVc9ngLGRneDF1ZL+Iz4dnBVpTxyq4UQTnLGpYsTUSDgW6eMMqtocuzeOSFtpwR9h8RUKBHp13TvRmiL3urFp/LPLr2FrL9lh5uHPEqq7ndCFcB7hsT4OeGLa2rERGvENjngjlB/6hGlZ9Ir+G+36qCTYGhPoBLhQYb/F6T8XwKrzwwgsoKCgAAGzcuBF/+ctfUFFRgZkzZ2LZsmXSB0h0H20JguihwDCNlSmPlTGNVYvBNPVY8Borq3oFAsFwoHgoUHuRkukuZ14M1WNlSaacuHhd1ZOZqGNVmJ2B3b+ahruuHBHx+bjUsero0OhjYum49OdW9I5dRGOlbfEj34iMqLEy4LESDbGrSTHnuy7sym4AZRcI5Q1JVmohlsdK72USnStbW+aJj7dhpQ/ztrQFcLTuHABgRJRQoMZjxWnKhP9Wh6LWLySPVRDDn+CamhrVsHrnnXdw4403orS0FEOGDMGECROkD5DoPulcZqBIViAj10KNFa97CI5HkqCbK7fQLllQ6dJ5rMTb9+g8VhIzZ1SPVWfPOZkXtvCCqLFDgWwTU5TQZ8FImLcrr4zL6YDX5eRqdsk0NkJ6EeZFdTpiG80uk+eWN4Cjaaf4x2VqRiI2YRbpFagTdIuHx4LHNcXwWLGisNHKRJglVEU9FAoU1ViFfjc2V2acx9vQ8Oi8kZ+fOgtFCfYmjJYFyX8/DVVeV0vtdN0XMRUxvApZWVk4evQoAKCiogLTpk0DACiKErG+VVesWbMG48aNQ2ZmJjIzM1FSUoL3339ffX7BggVwOByan4kTJ2reo7W1FT/72c+Qk5ODjIwMzJ07F8eOHdMcU1dXh7KyMvj9fvj9fpSVlYXpwr7++mvMmTMHGRkZyMnJweLFi9HW1qY5Zv/+/ZgyZQrS0tIwcOBAPPTQQ1AUBT2dtAjGRuRQoPYxQ1mBJsstqL9L0lhFLBAqyZDRF80UDwXqLtKS5gqEvB3MYyVT0K3fgI2I1/njZRqS/N+2Yq6BDoVrZ+OOGX7Tl1cwFwqMorHiDKt0warrIuhrHSmKwhlWsXsFqu17RL04rGZdjPDYwiuGobSoPyYM6yv0vqLw2WuqeD2mx0qfcCJ3rlbh0Z1bFgYckdsn6mc5kjJBqFcgd33oaeL1RGP423r99ddj3rx5GDFiBE6fPo2ZM2cCAPbt24fhw4cbeq9Bgwbh0UcfVV/36quv4tprr8XevXsxevRoAMDVV1+Nl19+WX2N16v9Qtxzzz14++23sW7dOmRnZ2PJkiWYPXs29uzZA1dn9sm8efNw7NgxVFRUAABuu+02lJWV4e233wYQrMM1a9Ys9OvXD9u3b8fp06cxf/58KIqCZ599FgDQ2NiI6dOnY+rUqdi1axcOHTqEBQsWICMjA0uWLDG6jHEl3RseCoz0BdC32ohVdR0IbwVi1rCSVo2ca15rVRNmINiIWRWvC9Y6Ysi8i+1locYqPBQY21PEG8hGi2aKkOZ1qaUlrMoKZOMW8RLpQ0aidaz4sUf7O7281nis9J7I8+0d6v+7DAWyTDmmixS8QQgPBUZ+3b+MH4R/GT9I6D2NEGoe3aE2YO6qnU3wNebC92xNzllQV07o76uV14Pn8/DJJgDA8ChhQCB43fe4HBrNnYghyetrSbyuxbBh9cwzz2DIkCE4evQoHn/8cfTuHTxhNTU1WLRokaH3mjNnjub3hx9+GGvWrMHOnTtVw8rn8yEvLy/i6xsaGvDSSy/hf//3f1XP2WuvvYaCggL85S9/wYwZM/Dpp5+ioqICO3fuVEOVL774IkpKSvDZZ59h5MiRqKysRHV1NY4ePYr8/HwAwFNPPYUFCxbg4YcfRmZmJtauXYvz58/jlVdegc/nw5gxY3Do0CE8/fTTKC8vT2jNjFiwzfdcW0C9k4n2BfC5QoaVWFag1qsh+gXTPy+73MK5tguhJsyysgK5U8x7rGLNNTysYEUo0IKsQK4RraIoat+0rjxWvKFxXm1MLNNj5Yr4/+4SyoBUDDU9Dr9BMKGximKo9hIIF5rBxengAKCpM1vP4eh6ziFBNyt0K5oV2CnobovdEskKQl6ckHi9bxftbADzusgwj1XCQoF6j1V0wwoIfiZ4w0pk3Lx3LBQK7Ln7YDwxfNY9Hg+WLl2K1atX49JLL1Ufv+eee3DrrbeaHkggEMC6devQ3NyMkpIS9fHNmzcjNzcXF110ERYuXIiTJ0+qz+3Zswft7e0oLS1VH8vPz8eYMWPw4YcfAgB27NgBv9+v0X9NnDgRfr9fc8yYMWNUowoAZsyYgdbWVuzZs0c9ZsqUKfD5fJpjjh8/jiNHjkSdV2trKxobGzU/8UbVWLUH1DuZaJs7u+B/Jz121XUgVOuINWEWjbXr74hkFwiNVVrCDKzNC8CyAgVLS4TpcOSL162oY6XP+mFRb5FegdrHJHqsuL8ts9wCXyZCbWcj8vkPCwUa91j1EiiIKlO87lG1McETygvXY2ncAK4EgWhWoG6zlelpFIEXr58WDAWGe6xEQ4Faj1W856oPBcYqtcDQn0vRGmVAp8eKQoEaTAfuq6ur8fXXX4fpkObOnWvoffbv34+SkhKcP38evXv3xvr161FUVAQAmDlzJm644QYUFhbiyy+/xH/8x3/gyiuvxJ49e+Dz+VBbWwuv14usrCzNe/bv3x+1tbUAgNraWuTmhrd2yM3N1RzTv39/zfNZWVnwer2aY/Qte9hramtrMXTo0IjzW7lyJVasWGFoTWTDKja3xBCvA6GNOVfAWwWEe6yEyy24rTE2mMfqfHtHyKMk8S6KFTvkyy2ICvUZouEiEdh8G6woEMrp5/gK4F15rPgegwy5GivOsLKoV+A5Ax6r8HMrz2MVL/F6qAFz16JxNjfmuRQ1NsJC4fE2Nrg2S3WqeN2oxko0FJjYrEBevN56IYCvTndmBEYptcAIC2kbqKp/IZC4yus9FcOG1RdffIHrrrsO+/fvh8PhUMXb7E7HqIB95MiR2LdvH+rr6/Hmm29i/vz52LJlC4qKinDTTTepx40ZMwbFxcUoLCzEu+++i+uvvz7qeyqKornzinQXJuMY/dwjsXz5cpSXl6u/NzY2qlmV8SJUjbwjZiiQfTFEalgBfHuM4PuKGhvh4nW5HisAaodzmXdRzEPXrTpWMg2Nzk252QJNh5szNpgQ3eEQCH3qDSupYv3Yom8z8ALnlvaQeD3m60x6NjSV172R58EbkXI9ViHvHCDWgBmIoLEymCnHSJTH6kxzmzrn2AVCuxcKZAVC415ugSvaeeTbcwh0KOjjc8dMRDLzOeZDykayCVMBw6tw9913Y+jQoThx4gTS09Nx8OBBbN26FcXFxdi8ebPhAXi9XgwfPhzFxcVYuXIlLrnkEqxevTrisQMGDEBhYSEOHz4MAMjLy0NbWxvq6uo0x508eVL1JuXl5eHEiRNh73Xq1CnNMcwzxairq0N7e3uXx7CwpN7bxePz+dSsR/YTb5ixca491IA0aiiw84shoq8CuCbMeo1VjAuKfnOW5bHiNyMmcpb5ZedFziGhvlgRSfV3maFA3YZrlcaqtT1kRMbMlAvTz8nXlAXHYk3NLjUUKCRet1BjpTGs5GUFhs5rp8ZKoDgowJdbMNgXMcywiq/Gil3rahvPAwhWl481hnAPjrFQoOqxirOhEaq83qERrsf6zvL7gcflMNQX8XyC+iL2ZAyvwo4dO/DQQw+hX79+cDqdcDqd+P73v4+VK1di8eLF3R6QoihobW2N+Nzp06dx9OhRDBgwAAAwfvx4eDwebNy4UT2mpqYGBw4cwKRJkwAAJSUlaGhowEcffaQeU1VVhYaGBs0xBw4cQE1NjXpMZWUlfD4fxo8frx6zdetWTeizsrIS+fn5YSHCngafFRirzYthj1WUxsSxjJnwzVfOF9LFtXlhuiOpHitO5CzqsXI5HeCvUzJDgfpN2aqsQJHioPrXMWQakryxY0lWYMCoeN2kx0ogK9CqUKC+Wjzz7MbyWDHPo9qEWfBzrF+TuOuOOsd9otOw6hsjDAiYF6+zNUl0VmB7QBEWrgNar7KoMejWzdXIa5Mdw6sQCATUTMCcnBwcP34cAFBYWIjPPvvM0Hvdd9992LZtG44cOYL9+/fj/vvvx+bNm3HzzTfj7NmzWLp0KXbs2IEjR45g8+bNmDNnDnJycnDdddcBAPx+P2655RYsWbIEmzZtwt69e/Fv//ZvGDt2rJolOGrUKFx99dVYuHAhdu7ciZ07d2LhwoWYPXs2Ro4cCQAoLS1FUVERysrKsHfvXmzatAlLly7FwoULVQ/TvHnz4PP5sGDBAhw4cADr16/HI4880uMzAoHQRZndmQICoUBRj1UUwypR4nUgtCGyjUNqvSPOQ9fGxOsxQlIOh0OjvZFraFgXZuG1OCLFQRnhdbusMSQt91iZMSJNaKyiJQNoPFYSM+ncUUKBXdWwCr6uMxRouFegdk1khnBFYOfoZGNnqYUYYUDAnJgbiNTSJjHeuaDHKlTDKhb851i0LQ1bo3PtIcOKQoFBDPuXx4wZg08++QTDhg3DhAkT8Pjjj8Pr9eK///u/MWzYMEPvdeLECZSVlaGmpgZ+vx/jxo1DRUUFpk+fjpaWFuzfvx+///3vUV9fjwEDBmDq1Kl4/fXX0adP6IPyzDPPwO1248Ybb0RLSwuuuuoqvPLKK2oNKwBYu3YtFi9erGYPzp07F88995z6vMvlwrvvvotFixZh8uTJSEtLw7x58/Dkk0+qx/j9fmzcuBF33nkniouLkZWVhfLyco1+qqeSrkvJB6KnSvfrrEg8tF/suxwg/O5XrYptVLwuuX9ePbi5WhEe6+gQLrcABC947MZOaksb3YVbrhcn+F5aj5XAXE1uSiLwoU+pGiuu1pGRUKDZsKdGYxWt8jpnNFvhsQroxOuxDCuXGgo0qLHSfSa9rvgaG+ycsGtTrFILgPlQoNqEOUGV1/lQ4D9OiGUEAtrrr7ARqcsSdcW54XRPxrBh9atf/QrNzc0AgF//+teYPXs2rrjiCmRnZ2uaM4vw0ksvRX0uLS0NGzZsiPkevXr1wrPPPqsW8oxE37598dprr3X5PoMHD8Y777zT5TFjx47F1q1bY46pp8EuyqyIJBD9znrFtaNx3aUDccXwHKH31heRTLTGCgjfqGR6w/hNSdUdCXgTtBcu+VmBDOtCgeJtZHhPhsMRvkl1B6s1Vhc6FLSoldetC3tqyi0IVF63yrDiq67HCgWyMBfLSxDdgMM0VnH2WOnPSawGzEA3xOtOncYqQaHADgX44lsDhhX3nRUOBaqlJcQbN6cKhg2rGTNmqP8fNmwYqqurcebMGWRlZfX4kFiqktYpfG3gPVZRvgQD/GkYMDZN+L31hpVoN3j9hcuKauQMqzRWbQaqDfNjkJklpzfqrKpjZcxjxRmREueq//syN2h1rgGFK7cQ+/Ko1xmJbi4+geKfVmUF8p+/Cx2KmuTR29d1uYUwob5NNFb6ccbKCATMG8zMQFFrviUoKxAI6qzSPC4M/E7s6zl/boWF+mpTbqq6rsf0SvzjH//Ahg0b0NLSgr59+8ocEyEZFgpsUMXcYlkfIkQTr8fUWIXVsbKJF0dTbkFMYwVoDSursuQAuWEW3otzXp2riMeK15PJvdnSeqys0ZOpLW2ENFbmwp6arEABwypNYq9AF3dOAh1ifQKB7jcmZsQ7K1D/90UMq/A2VOb0ZInyWDGG5/ZWdbBdYSoUqJbfSIx3ridjeCVOnz6Nq666ChdddBGuueYaNZPu1ltv7fE981IVdrfb2BL8Asj0mLCNxWgTZitDgfq7e2s0VlyvQIELCr8pWdWUGLAqFNihhj1FsgL5i7RM7Zz+78tsaePmPJFGsgLDjA3B+YoYVmmWeax4r0YHzrKsQEGNFcMuxob+HOX0jq2x0p9Go7ojRvwrr2v/nkhGIKATr5vMCiSPVQjDK/Hzn/8cHo8HX3/9NdLT09XHb7rpJrXJMdGzUAuEqqJTeZsd+y6FaayMlluwqJ9c8G/J1Fh1ahgMlFsIjsGaUGCYx8oiL47aJ9DgXGVnCfHn1pKaXQbF62ZrlPFjj6qx8lpvWGk8VjHLLZicq5v/7Mdf4Kz/vol4rBwOh/YGwaDuiBFvY8PldGiMwq6aL/Pw10jhrMDOuakFY8ljpWLYv1xZWYkNGzZg0CBtF/IRI0bgq6++kjYwQh7WCpw7s6kC+l6BXV88w8stWClel/feTs7YaDUi6LZIvK43ImVeyLUaKwNCfYu8c0Do3HpdTqEQhyiqwayExLgiGiuz2WOaOlbRQoG8DsuCljZAUIdjtECo+rvBTDkg/h4c/d8HYrezYbicDjXbWdg7p/fqJWS+TvWmb7hgdjf/mRCdq0vnsaJSCyEMr0Rzc7PGU8X49ttvNQ2KiZ5Duk6fITUUqG/CrJYg6HojsLLNS7juyBpjw0h/LK3uyDqhvhVGs0a8LjJXTShQ7sWWGRiyN2h+Y2GGhliBUL2gW6LGyhvb+DID740JdIQMqz4xegW6THpj+DUSMcxlo/++ZQuUWwDM6o4SG/YEtGMd0T92DStA+7kVb1WkrWtGocAQhlfin//5n/H73/9e/d3hcKCjowNPPPEEpk6dKnVwhBz0d7vRaliZIWoT5lgaK93zUj1W3HzdTodUzwabb+uFDjX8KbLJ83eBUus66cJIllQj71DQaqDyuttEhpEobL6yN2h+E2VZcmItbazzWGk1VvLE64A29Gm03AJD1IjUGFaJMDRMZAUC5m6G9Oc/MYaVQ/3bBVliGd4aj5XgmMMSNygUqGL42/rEE0/gBz/4AXbv3o22tjb84he/wMGDB3HmzBl88MEHVoyR6CZWirmZp6nDcOV1/Z2+NeEx2e5pdgFijXoB0dpOccoKlOmxitC+R6jcgiYUaI3GylqPVVDMLeIl4s+l2ymebavVWEU3rNK9LlwIKMhMk2tYsXDRhYB4VmB4CQLjc02EYcWPu08vt/B3xEz43soyMqKw79ywnAxTBqHR9j2MWEWhUwnD39aioiJ88sknWLNmDVwuF5qbm3H99dfjzjvvVHv4ET2LMDG3xPAMa8Ksr7we60IUprGSeMHlDUnZHhO9rgAQDAVaFB6zUmPl4s6tkV6BWqG+3PUfntsbvTxOjM6X28ycHyczIsUKhPJeDfG5aupxRfn8uF1OvDT/n9Ae6LDMY3W29YLqeY3ZK9BkGyr+uER4cHjjQiQjkGHGi9MTQoHsGiAaBgT0GitRj5X+Gh7fpISejKlva15eHlasWKF57OjRo/j3f/93/O53v5MyMEIeLqcDPndI0CjzC6Cv4iyqOwrPCrRGvC77wqZv4yCa5aQxNuziseLKLYQqrxszImV7DHP79MJH909DhkWGBo/RrEAjn2FmKPX2ubsMVZd8N1v4PY3Axl13LthU3umIbUiabVXE3zTFu4YVoDXsRMOAgLmbobAq8wkMBYqWWgDMhe/D2zmRx4ohbSXOnDmDV199VdbbEZLRenGs2HwVXOhQQhWHEyhe72XRXIHQfJtbjXWvd2tc7RZmBVpSeR2hcgsJzgoEgMxeHukp+w5HuIEs4iUyO9f876Rh8VUj8B+zR4kPUiJsrHXnOmtY+dwxw5hmyy0kWmPFGw0iDZgZLhPfWf1nIJHidZFWNgwzdazC65qRYcWQe9tH9FjSvW71IirTOxSpYCYQ+4LC6q2E+o5Z48WxyrA616mxEt0oLGtpo29wa4nGqsNgX0Tu7ldyVqCVuJwONSwGiGmszNQ6YpRPv8jQ8TJh56ih02MVKyMQiBD6MdHSJt59AvV/X7TUAqD97JoOBca54TQA3DxhMDYcPIErRoj1ewV0N34mbhaNvC4VIMMqReA1HdaEAjvU4qCAmKHE11uxqo6VbI2VPhQoesH1WOSxcurCvFaUljBaINRqj5VVeJwOtHX+3+d2CnnFtEakfeYayWMl+prQ72Y8Voktt2AkFOgyEQrsCXWsFkweigWThxp6DX+DINyEWbcmJF4PQSuRIvBhDSsKZgY4j5XTIXbR9Wp0R1aJ1+V+xJlYn4UCRTcK/iJkVW0nQHY18uB78XWsRDxWHqc159Vq+I1UtNK5y8Sdfk/ApdNYxSoOCkTSWBnX4iQkS447r6I1rAB9eEw0FJh48boZTDVhtrDIs90R9lhdf/31XT5fX1/f3bEQFqKt7WSFDieUki/sxXE7gdbO/1tUbkG6eF0timcsFGilFydYobsdHpfkml2arMDOcgsC89UYG7by4oTmJpqFpzEi7TTXzrHWd3qsYpVa4F/DEG44rSkQmjjNEWAsFCgjPGYX3ZGpYqiUFRgVYcPK7/fHfP4nP/lJtwdEWAN/Bx6r3YwRmAcnwGcEmqidItOzkWapeD34fueMhgKd1t21s/nKfl+1MXHAYLkFp3VGpJXwHgrRFjJmRL89AXZzVc88VgKhwLA6VsIaqwSL111mPVbGtYL64+zjsTJjWCVeT9ZTETasXn75ZSvHQViMVYJudfPtUEINmE0Iuq0Sr8s2Ntgwz6mhQFHvnDVGJD8G2RdxNeNTCYV5xbIC7RkKdJsIBdpVT8bGWt9iwGOlT683oS9MiMaKO69GNFYeU6FA7XGJMCTNYKbWWLh43T6ff6uxx1knuo1VocBIWYGixoxXY1hZJF6Xbmx0eqw6Q4HiVZx5Y0PuBUj1WFlUs0vTK9Bg5XU7hQL5u3YRAxKwrvCr1ehDgULi9bCsQAMh/04S47EK/c0cA6FAjRfHhBEJ2MljZdyjrv88kHg9BGUFpghWhQKZDkdRYFxjZVGFbr55rWindlHYOFkoUPQOXJMVKHkD7uW2xrDijebzF1iB0OQVr5vyWFnYF9FK2LjrulFuwUxLm0QYGhleF0bnZyLQoSDbQOV1t4nvbHh4zB6ff3Pte/TJDPaYazwgwypFsCorkP9yGS5BwBl4Mgs+WjVXICTMbmkzFgrUhscs8ljJ1lhpKq+Le6zMZFP1BMxkBWoLv9pnY2FzbWgR91iFV9o2o7GKfyjQ4XDgz3d9H4Cx64xGYyV4M9oTCoSawYx3jupYRYcMqxSBD4/JDFnwb9XSufkKt7roPM7rcgo3rxWBz1yTblip5RaMhQLN6DVEYcaOV/KmxTIM242K1zWNie1zseXHmuYRuzR2p0BoImGbIuuUIFJuIaxAqIkklURkBQLmbtzMZMrpj7OLYWWmCXNPaDjdU6GVSBE0mXJSC4R2w2PV+UWU7cFxu5zql9yqyuvMiBSuY2VR5XUgZOxYpbFqvdChVsjvJTBfK71zVmLOY8VnjtlnrvpNsY8JjZVw0cwEZwWaxUwfSP41Tod9SnCY0liZTGZIBWglUoR0y4pIhi4czNgwWm7BiotPyItjjcaqPaB0vr8JPZl0j1Xw3MoWj6pC/U7vHCDmcbCyCbOV8OdFXGNlz6xAl85QMNXSRlRjxX1H7OLBAfR1rIyHPb1uuZ54KzHzndV/Hki8HoJWIkWwKhTIf7kM13ayyKsEhDx0VnmsGOK9Arl0Ztl1rCz2WJ3lDSuBv2FVUoLVmKljpS23YJ/Lqd4oEgkFhjdON+Oxsk+tI201cuO6IzuFxszoIvXHUbmFEPY580S30Ai6pRYIDf1fbXvSAwwrNt+eYlhZqcUJeeesmWtzW6jKvMgduMvCuVqJmaxAzYZkUyMSMFcg1MwGnPyhQN5jZR8jUqOxEjxHZjV3qQCtRIqQpilBIO+0OxyOkO6ozZh4nY3DihCK1bojRo/ICvRYmxXIiqGK1nbSlpawp7GRJtjSxm3T0hL676iVLW3sqrHSZsoltxFpRmMVVmXeRp9/q6GVSBH4LCfZ4Rl2ATIeCnR0/mtBKNBjjTdM34tPpClxcBzW1bHypweLHmamyU3ydepCgSKlFgD7Ghv8uNNFC4TavNwCQ6zyul68bqLcguC69gRM9c9LcM0us5iZq9PpAO/AJvF6CCq3kCKka7IC5Xs22mBGvO5UXy+bUG0na8TrDKNzBeR7rOZeko8zZ9sw93v5Ut+XzwoEjGRAplAdK5vW7NJnr6WJtCrS3RCIGs0uZ9CrHehQbOXV0OjnBK9R/HF2mqvZ2nMep1PtEUvi9RBkWKUI6VY2Ju68bWEaK/ECoRaK1z1Wide17ydal0dbbkHuBuxP8+DuaSOkvicQ7tUw5bGyUSiQH2svE5XXbVWzi9s8e/vchrVzgDHDweMKGlaJqmNlBnY+PS6HcHafPivQLmhE9wbG7XI6gOBlnzxWHLQSKUIvTRNmyaFAFwsFXuh8f2MaKyvu9LM6w2MiaeRG0E9NXI8QKi1hnxRs7dyE++fZNFNO47Ey0SvQXh6r0HkR/Y6E1bEy4tno/BzYS3dkXKrg4sJjtjKsTGisAPtmQVoNeaxSBCs9VuyC29LOQkbGNFZWbL53Th2Owux0zL5kgNT37a7Hyl61jnQeKzN9EW00X20dK7FLo9PpgNMBdCj2Ore8kSSSEQho56p/j1gM/E4a/nHyLPpn9jI0zkTi5m6GjMDCY3YyNLShQAOGlU1r1lkNGVYpgpX985wOlhVosM2LhRqrITkZuOtK+eGx8KxAY14cO1189IaCsBFp0/AYbzSL1rECgnNsC3TYa67cuRURrjPYXI2ExwDg97dcjrrmduQYaIKcaJixYdTz5HY50Bawm8fKeLkFQC/Wt8+NhdWQYZUi9PI44XAEe4PJ9iKEPFbmxOt2ugDpswJF52pVix0rcTq6Z0Tq/9/T4UtDiIrXgZDOxE6fY43HyoBhxeZq1IjM7dMLuX3s460CQkaD0e+s26RBlkhcJr3MWrG+fTI+rcY+Z57oFg6HwzJBNzM21DpWghcUduGxq8AZMOLFMRdWSCT6sZoRr9vJkDSTFQiEjEd7ndvQeRENBQLcXG1kMJtF/c4anKsdbxg9EjRWVHk9hH3OPNFtrDKs3DrDSriJp3rhss/H0GxmlJUZkFYRnhVowmNlJ2ODG7exUKD9Psf8eTEWCrRfSNssZsTrQOhzZKfyA+Y1VuYMsmQnoSuxZs0ajBs3DpmZmcjMzERJSQnef//9iMfefvvtcDgcWLVqlebxH/zgB3A4HJqfH/3oR5pj6urqUFZWBr/fD7/fj7KyMtTX12uO+frrrzFnzhxkZGQgJycHixcvRltbm+aY/fv3Y8qUKUhLS8PAgQPx0EMPQVGUbq9DvMhMC2b/GLkbF8GlDwUa9FjZ6Qvp0ofHBI2NUXmZ+F7Bd/Avlw20YliWoL9TF/VYeWzusXI5HQbv2q3LbrUK3gg0kjnrctpvrmZRQ3qGQ4H281iZLXRrVpuV7CRUYzVo0CA8+uijGD58OADg1VdfxbXXXou9e/di9OjR6nFvvfUWqqqqkJ8fuQDiwoUL8dBDD6m/p6WlaZ6fN28ejh07hoqKCgDAbbfdhrKyMrz99tsAgEAggFmzZqFfv37Yvn07Tp8+jfnz50NRFDz77LMAgMbGRkyfPh1Tp07Frl27cOjQISxYsAAZGRlYsmSJvEWxkOUzL8aer+owJt8v9X3NGlZTR+bi3U9qcL2NjQ3RDMg0rwtv3TnZiiFZRneF+vr/93TYhpjucRkSZofCvPbZWMxkBQJcJq+N5moWl+lQoA01VibLhrg0Giv7zNdqEmpYzZkzR/P7ww8/jDVr1mDnzp2qYfXNN9/grrvuwoYNGzBr1qyI75Oeno68vLyIz3366aeoqKjAzp07MWHCBADAiy++iJKSEnz22WcYOXIkKisrUV1djaNHj6rG21NPPYUFCxbg4YcfRmZmJtauXYvz58/jlVdegc/nw5gxY3Do0CE8/fTTKC8vt0VtotLReSgdHXmdugO7iz3fWW5B9As2JCcDb/y/SdLHYyVhoUAbXTyNoi8tIeyx0oQC7bM+7NwaCQMC9tQduUwaVqHwmH3mahazTeKZN9BOhobHRDHU4PH29E5bTY9ZiUAggHXr1qG5uRklJSUAgI6ODpSVlWHZsmUaD5aetWvXIicnB6NHj8bSpUvR1NSkPrdjxw74/X7VqAKAiRMnwu/348MPP1SPGTNmjMYjNmPGDLS2tmLPnj3qMVOmTIHP59Mcc/z4cRw5ciTq2FpbW9HY2Kj5STbCimYms7ERlimXOnMVrWPl0oQC7bMBu80aVjYMj/FjNZIVaEc9mVlMa6zsmBVoMuzJh8/1N52pTMLLLezfvx8lJSU4f/48evfujfXr16OoqAgA8Nhjj8HtdmPx4sVRX3/zzTdj6NChyMvLw4EDB7B8+XL87W9/w8aNGwEAtbW1yM3NDXtdbm4uamtr1WP69++veT4rKwter1dzzJAhQzTHsNfU1tZi6NChEce3cuVKrFixQmAl7Ives2GnOzWjpJTHKkxjZaYauX3WR/VYGWwUbHYDTiT8dzbTiGFlw7IhZnGb9M7ZMSuQ1aAyOmY17JkCnwcjJNywGjlyJPbt24f6+nq8+eabmD9/PrZs2YKWlhasXr0aH3/8cZeuyYULF6r/HzNmDEaMGIHi4mJ8/PHHuOyyywAg4usVRdE8buYYJlzvanzLly9HeXm5+ntjYyMKCgqiHm9HwhoT2+iCYpRwjVXy1m4xW27ByobTVsLmazS5w/4aK3Hxulljw44wT14fA+sDcFmB61OKrwAAF0dJREFUNro2DMvpjR9+Lx9F+ZmGXpdKoWEjJNyw8nq9qni9uLgYu3btwurVqzFq1CicPHkSgwcPVo8NBAJYsmQJVq1aFTX8dtlll8Hj8eDw4cO47LLLkJeXhxMnToQdd+rUKdXjlJeXh6qqKs3zdXV1aG9v1xzDvFeMkydPAkCYt4vH5/NpwofJiD5klMx3s2EtbZLYiNR758yI1+30WWDnVrSdDYNlhooanj0Bt8lQoCroToGwz7RR/fHLqy/GtFHhEY+u8NgwK9DpdGDVjy41/Do7eufiQY9bDUVR0NrairKyMnzyySfYt2+f+pOfn49ly5Zhw4YNUV9/8OBBtLe3Y8CAYI+4kpISNDQ04KOPPlKPqaqqQkNDAyZNmqQec+DAAdTU1KjHVFZWwufzYfz48eoxW7du1ZRgqKysRH5+fliIMNVIqfCYzohMZhd4d4uhRnqPngwzNoxqrO6aOhw3jB+EicOyrRiWJZgVr6dSKLCXx4X/94PvYkT/PoZe57ZhVqBZzJakSHYS6rG67777MHPmTBQUFKCpqQnr1q3D5s2bUVFRgezsbGRnay9UHo8HeXl5GDlyJADg888/x9q1a3HNNdcgJycH1dXVWLJkCS699FJMnhxMbR81ahSuvvpqLFy4EC+88AKAYLmF2bNnq+9TWlqKoqIilJWV4YknnsCZM2ewdOlSLFy4EJmZQdfovHnzsGLFCixYsAD33XcfDh8+jEceeQQPPPCALTICrSTcs5G8XzJ9erG+xU0yoZ+beIFQe2YKmQ0FTi/qj+lF0b3WPRH+vBjSWNlQTxZvmEGVzNdBhlrXLAXmaoSEGlYnTpxAWVkZampq4Pf7MW7cOFRUVGD69OlCr/d6vdi0aRNWr16Ns2fPoqCgALNmzcKDDz4IF9e3aO3atVi8eDFKS0sBAHPnzsVzzz2nPu9yufDuu+9i0aJFmDx5MtLS0jBv3jw8+eST6jF+vx8bN27EnXfeieLiYmRlZaG8vFyjn0pVUsljxYdQknmeQCSNlXHxup00VleNysWGg7W4/rJBiR6K5Wg8VmZCgTY6r/Hmx5cPxoWAgikX9Uv0UCyHxOuRSahh9dJLLxk6Xq+rKigowJYtW2K+rm/fvnjttde6PGbw4MF45513ujxm7Nix2Lp1a8y/l2roN+BkvpvlGxMn+x2pWU+kRrxuI0H38Nw++NMiexVxNQv7zjodxrIg7SjUjzczRudhhgX1AnsidsyIjQcJF68T9kcfMkpmT46mm3sSzxMI3zxFPVYupwPTi/qj4Vw7sjO8VgyN6CYsXNvb5zZWZV4VK5PHiuCKqCb5tdAoZFgR3Sas3EIS373wXpxk91jp5WNGst5e/Emx5NEQMmHfWSN9AvnXkceKAELXQzs1nI4HtBpEt0klj5XWsLJPnRozOBwOjdEsWnmd6PkM7psOpwMY0b+3odeRxorgYRorD3kwNZDHiug2qeSxSqVQINBpNHcEC+GKhgKJnk9B33Rs++WVhkO16kZKHisC5lvhJDtkWBHdJpWyAlMpFAgEDUlWuS0V5ptKDPxOmuHXhNLryUNB8H0y6drAQ6tBdBu+aGayN+N0pZjHip8veawI0lgRPHZsOB0PaDWIbqOp7ZTkdy6p6LFipMJ8ia5JpV6BRGzULNEkv+4bhVaD6DZ8badkv3Ph79STfa5AKPTjdSd3lXlCDHYTRaEfAqBK/NGg1SC6De/VSPYvGB8BSfasQCB0bslbRQCh8gxGyzQQyUl272DyQ04fqlfHQ+J1otu4OGsj2TdgdwrNFQiFPklfRQDATycPgT/Ng5v+qSDRQyF6ADf9UwGye/tSon2PEciwIroN76RK9vBYqorXjRQHJZKXAf403Dl1eKKHQfQQ0r1uzL0kP9HD6HHQ1ZLoNrzHKtlFjKlUIBQIhQKpOChBEIQYyb0LEnFBo7FK8vo2qVYglEKBBEEQxkj+nYGwHD5bLLU8Vsk9V4DrBZYCcyUIgpABXS2JbpNKXhy+GKovBXRHLL2ePFYEQRBiJP/OQFiOVtCd3Buw0+kAs62S3TsHhAxJEq8TBEGIQVdLottoDKsUqMis1nZKAS+OK4XmShAEIQMyrIhuk0qhQIAzNlLAY8XqdlFWIEEQhBjJvzMQlqNpaZMCxgYLj6WCxirksUr+uRIEQciArpZEt9E0YU4lj1UKzFUVr5PHiiAIQojk3xkIy+E9VsneKxDgOrqngGFFldcJgiCMQVdLotukmsaKGZKpUHk9lBWY/HMlCIKQQfLvgoTlpFr/PGZIpsJcUynsSRAEIQO6WhLdRlONPAVCgdm9vQCAfr19CR6J9fT2Bfu0+9M8CR4JQRCEPXAnegCE/eENq1TQWD3740vx1ZlzGJKTkeihWM6iqcNR0Dcd14wbkOihEARB2AIyrIhuk2qhwGH9emNYv96JHkZcGJ7bGz+fflGih0EQBGEbkn8XJCwn1cTrBEEQBBEN2gWJbuNyhj5GZFgRBEEQqQztgkS34WVVqaCxIgiCIIho0C5IdBveY0Vp+QRBEEQqQ7sg0W1cKdYrkCAIgiCiQbsg0W1SLSuQIAiCIKJBuyDRbfgmzKSxIgiCIFIZ2gWJbsM3YSaPFUEQBJHK0C5IdBuqY0UQBEEQQRK6C65Zswbjxo1DZmYmMjMzUVJSgvfffz/isbfffjscDgdWrVqleby1tRU/+9nPkJOTg4yMDMydOxfHjh3THFNXV4eysjL4/X74/X6UlZWhvr5ec8zXX3+NOXPmICMjAzk5OVi8eDHa2to0x+zfvx9TpkxBWloaBg4ciIceegiKonR7HeyORmNFoUCCIAgihUnoLjho0CA8+uij2L17N3bv3o0rr7wS1157LQ4ePKg57q233kJVVRXy8/PD3uOee+7B+vXrsW7dOmzfvh1nz57F7NmzEQgE1GPmzZuHffv2oaKiAhUVFdi3bx/KysrU5wOBAGbNmoXm5mZs374d69atw5tvvoklS5aoxzQ2NmL69OnIz8/Hrl278Oyzz+LJJ5/E008/bcHK2AtNE2byWBEEQRCpjNLDyMrKUv7nf/5H/f3YsWPKwIEDlQMHDiiFhYXKM888oz5XX1+veDweZd26depj33zzjeJ0OpWKigpFURSlurpaAaDs3LlTPWbHjh0KAOXvf/+7oiiK8t577ylOp1P55ptv1GP++Mc/Kj6fT2loaFAURVGef/55xe/3K+fPn1ePWblypZKfn690dHQIz6+hoUEBoL5vMnCotlEp/OU7SuEv31G+PHU20cMhCIIgCOmI7t89xr0QCASwbt06NDc3o6SkBADQ0dGBsrIyLFu2DKNHjw57zZ49e9De3o7S0lL1sfz8fIwZMwYffvghAGDHjh3w+/2YMGGCeszEiRPh9/s1x4wZM0bjEZsxYwZaW1uxZ88e9ZgpU6bA5/Npjjl+/DiOHDkSdV6tra1obGzU/CQbTtJYEQRBEASAHiBe379/P3r37g2fz4c77rgD69evR1FREQDgscceg9vtxuLFiyO+tra2Fl6vF1lZWZrH+/fvj9raWvWY3NzcsNfm5uZqjunfv7/m+aysLHi93i6PYb+zYyKxcuVKVdvl9/tRUFAQ9Vi7QuJ1giAIggjiTvQARo4ciX379qG+vh5vvvkm5s+fjy1btqClpQWrV6/Gxx9/DAeXzi+Coiia10R6vYxjlE7helfjW758OcrLy9XfGxsbk864ogKhBEEQBBEk4YaV1+vF8OHDAQDFxcXYtWsXVq9ejVGjRuHkyZMYPHiwemwgEMCSJUuwatUqHDlyBHl5eWhra0NdXZ3Ga3Xy5ElMmjQJAJCXl4cTJ06E/d1Tp06pHqe8vDxUVVVpnq+rq0N7e7vmGL1n6uTJkwAQ5sni8fl8mvBhMkJZgQRBEAQRpMftgoqioLW1FWVlZfjkk0+wb98+9Sc/Px/Lli3Dhg0bAADjx4+Hx+PBxo0b1dfX1NTgwIEDqmFVUlKChoYGfPTRR+oxVVVVaGho0Bxz4MAB1NTUqMdUVlbC5/Nh/Pjx6jFbt27VlGCorKxEfn4+hgwZYtl62AEyrAiCIAgiSEI9Vvfddx9mzpyJgoICNDU1Yd26ddi8eTMqKiqQnZ2N7OxszfEejwd5eXkYOXIkAMDv9+OWW27BkiVLkJ2djb59+2Lp0qUYO3Yspk2bBgAYNWoUrr76aixcuBAvvPACAOC2227D7Nmz1fcpLS1FUVERysrK8MQTT+DMmTNYunQpFi5ciMzMTADBkg0rVqzAggULcN999+Hw4cN45JFH8MADDxgOVSYbORk+fH94DvpmeDVCdoIgCIJINRJqWJ04cQJlZWWoqamB3+/HuHHjUFFRgenTpwu/xzPPPAO3240bb7wRLS0tuOqqq/DKK6/A5XKpx6xduxaLFy9Wswfnzp2L5557Tn3e5XLh3XffxaJFizB58mSkpaVh3rx5ePLJJ9Vj/H4/Nm7ciDvvvBPFxcXIyspCeXm5Rj+VqjidDrx264TYBxIEQRBEkuNQFCodHk8aGxvh9/vR0NCgesMIgiAIgujZiO7fJIghCIIgCIKQBBlWBEEQBEEQkiDDiiAIgiAIQhJkWBEEQRAEQUiCDCuCIAiCIAhJkGFFEARBEAQhCTKsCIIgCIIgJEGGFUEQBEEQhCTIsCIIgiAIgpAEGVYEQRAEQRCSIMOKIAiCIAhCEmRYEQRBEARBSIIMK4IgCIIgCEm4Ez2AVENRFADBLtkEQRAEQdgDtm+zfTwaZFjFmaamJgBAQUFBgkdCEARBEIRRmpqa4Pf7oz7vUGKZXoRUOjo6cPz4cfTp0wcOh0Pa+zY2NqKgoABHjx5FZmamtPcltNA6xwda5/hBax0faJ3jg5XrrCgKmpqakJ+fD6czupKKPFZxxul0YtCgQZa9f2ZmJn1p4wCtc3ygdY4ftNbxgdY5Pli1zl15qhgkXicIgiAIgpAEGVYEQRAEQRCSIMMqSfD5fHjwwQfh8/kSPZSkhtY5PtA6xw9a6/hA6xwfesI6k3idIAiCIAhCEuSxIgiCIAiCkAQZVgRBEARBEJIgw4ogCIIgCEISZFgRBEEQBEFIggwrG/H8889j6NCh6NWrF8aPH49t27Z1efyWLVswfvx49OrVC8OGDcN//dd/xWmk9sbIOv/pT3/C9OnT0a9fP2RmZqKkpAQbNmyI42jti9HPM+ODDz6A2+3G9773PWsHmCQYXefW1lbcf//9KCwshM/nw3e/+1387ne/i9No7Y3RtV67di0uueQSpKenY8CAAfjpT3+K06dPx2m09mPr1q2YM2cO8vPz4XA48NZbb8V8TUL2QYWwBevWrVM8Ho/y4osvKtXV1crdd9+tZGRkKF999VXE47/44gslPT1dufvuu5Xq6mrlxRdfVDwej/LGG2/EeeT2wug633333cpjjz2mfPTRR8qhQ4eU5cuXKx6PR/n444/jPHJ7YXSdGfX19cqwYcOU0tJS5ZJLLonPYG2MmXWeO3euMmHCBGXjxo3Kl19+qVRVVSkffPBBHEdtT4yu9bZt2xSn06msXr1a+eKLL5Rt27Ypo0ePVn74wx/GeeT24b333lPuv/9+5c0331QAKOvXr+/y+ETtg2RY2YTLL79cueOOOzSPXXzxxcq9994b8fhf/OIXysUXX6x57Pbbb1cmTpxo2RiTAaPrHImioiJlxYoVsoeWVJhd55tuukn51a9+pTz44INkWAlgdJ3ff/99xe/3K6dPn47H8JIKo2v9xBNPKMOGDdM89pvf/EYZNGiQZWNMJkQMq0TtgxQKtAFtbW3Ys2cPSktLNY+Xlpbiww8/jPiaHTt2hB0/Y8YM7N69G+3t7ZaN1c6YWWc9HR0daGpqQt++fa0YYlJgdp1ffvllfP7553jwwQetHmJSYGad//znP6O4uBiPP/44Bg4ciIsuughLly5FS0tLPIZsW8ys9aRJk3Ds2DG89957UBQFJ06cwBtvvIFZs2bFY8gpQaL2QWrCbAO+/fZbBAIB9O/fX/N4//79UVtbG/E1tbW1EY+/cOECvv32WwwYMMCy8doVM+us56mnnkJzczNuvPFGK4aYFJhZ58OHD+Pee+/Ftm3b4HbTZUsEM+v8xRdfYPv27ejVqxfWr1+Pb7/9FosWLcKZM2dIZ9UFZtZ60qRJWLt2LW666SacP38eFy5cwNy5c/Hss8/GY8gpQaL2QfJY2QiHw6H5XVGUsMdiHR/pcUKL0XVm/PGPf8R//ud/4vXXX0dubq5Vw0saRNc5EAhg3rx5WLFiBS666KJ4DS9pMPJ57ujogMPhwNq1a3H55ZfjmmuuwdNPP41XXnmFvFYCGFnr6upqLF68GA888AD27NmDiooKfPnll7jjjjviMdSUIRH7IN362YCcnBy4XK6wO5+TJ0+GWeOMvLy8iMe73W5kZ2dbNlY7Y2adGa+//jpuueUW/N///R+mTZtm5TBtj9F1bmpqwu7du7F3717cddddAIIGgKIocLvdqKysxJVXXhmXsdsJM5/nAQMGYODAgfD7/epjo0aNgqIoOHbsGEaMGGHpmO2KmbVeuXIlJk+ejGXLlgEAxo0bh4yMDFxxxRX49a9/TVEFCSRqHySPlQ3wer0YP348Nm7cqHl848aNmDRpUsTXlJSUhB1fWVmJ4uJieDwey8ZqZ8ysMxD0VC1YsAB/+MMfSB8hgNF1zszMxP79+7Fv3z7154477sDIkSOxb98+TJgwIV5DtxVmPs+TJ0/G8ePHcfbsWfWxQ4cOwel0YtCgQZaO186YWetz587B6dRuwS6XC0DIq0J0j4Ttg5ZK4wlpsFTel156SamurlbuueceJSMjQzly5IiiKIpy7733KmVlZerxLM305z//uVJdXa289NJLVG5BAKPr/Ic//EFxu93Kb3/7W6Wmpkb9qa+vT9QUbIHRddZDWYFiGF3npqYmZdCgQcq//uu/KgcPHlS2bNmijBgxQrn11lsTNQXbYHStX375ZcXtdivPP/+88vnnnyvbt29XiouLlcsvvzxRU+jxNDU1KXv37lX27t2rAFCefvppZe/evWpJi56yD5JhZSN++9vfKoWFhYrX61Uuu+wyZcuWLepz8+fPV6ZMmaI5fvPmzcqll16qeL1eZciQIcqaNWviPGJ7YmSdp0yZogAI+5k/f378B24zjH6eeciwEsfoOn/66afKtGnTlLS0NGXQoEFKeXm5cu7cuTiP2p4YXevf/OY3SlFRkZKWlqYMGDBAufnmm5Vjx47FedT24a9//WuX19uesg86FIV8jgRBEARBEDIgjRVBEARBEIQkyLAiCIIgCIKQBBlWBEEQBEEQkiDDiiAIgiAIQhJkWBEEQRAEQUiCDCuCIAiCIAhJkGFFEARBEAQhCTKsCIIgCIIgJEGGFUEQBEEQhCTIsCIIgiAIgpAEGVYEQRASeOONNzB27FikpaUhOzsb06ZNQ3Nzc6KHRRBEnHEnegAEQRB2p6amBj/+8Y/x+OOP47rrrkNTUxO2bdsGasVKEKkHNWEmCILoJh9//DHGjx+PI0eOoLCwMNHDIQgigVAokCAIoptccskluOqqqzB27FjccMMNePHFF1FXV5foYREEkQDIY0UQBCEBRVHw4YcforKyEuvXr0dtbS2qqqowdOjQRA+NIIg4QoYVQRCEZAKBAAoLC1FeXo7y8vJED4cgiDhC4nWCIIhuUlVVhU2bNqG0tBS5ubmoqqrCqVOnMGrUqEQPjSCIOEOGFUEQRDfJzMzE1q1bsWrVKjQ2NqKwsBBPPfUUZs6cmeihEQQRZygUSBAEQRAEIQnKCiQIgiAIgpAEGVYEQRAEQRCSIMOKIAiCIAhCEmRYEQRBEARBSIIMK4IgCIIgCEmQYUUQBEEQBCEJMqwIgiAIgiAkQYYVQRAEQRCEJMiwIgiCIAiCkAQZVgRBEARBEJIgw4ogCIIgCEISZFgRBEEQBEFI4v8Dui0lHS1/IVMAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot the results\n",
+    "plt.figure()\n",
+    "plt.plot(s_space, off_diagonal_norm_diff[0,:],label= 'No normalization')\n",
+    "plt.plot(s_space, off_diagonal_norm_diff[1,:],label= 'Normalization')\n",
+    "plt.plot(s_space, off_diagonal_norm_diff[2,:],label= 'Gradient Ascent')\n",
+    "plt.xlabel('s')\n",
+    "plt.ylabel(r'$||\\sigma(H_0)||-||\\sigma(H_k)||$')\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.title('D not normalized')\n",
+    "plt.plot(s_space, potential[0,:],label= 'No normalization')\n",
+    "plt.xlabel('s')\n",
+    "plt.ylabel('Least squares cost function')\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.title('D normalized')\n",
+    "plt.plot(s_space, potential[1,:],label= 'Normalization')\n",
+    "plt.xlabel('s')\n",
+    "plt.ylabel('Least squares cost function')\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.title('D optimized')\n",
+    "plt.plot(s_space, potential[2,:],label= 'Gradient Ascent')\n",
+    "plt.xlabel('s')\n",
+    "plt.ylabel('Least squares cost function')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "dbi_eval = deepcopy(dbi)\n",
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "flows = 50\n",
+    "off_diagonal_norm = np.empty((flows+1,3))\n",
+    "off_diagonal_norm[0,:] = dbi_eval.off_diagonal_norm\n",
+    "for i in range(flows):\n",
+    "    step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d)\n",
+    "    dbi_eval(step_poly,d=d)\n",
+    "    off_diagonal_norm[i+1,0] = dbi_eval.off_diagonal_norm\n",
+    "\n",
+    "\n",
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))/2**nqubits\n",
+    "dbi_eval = deepcopy(dbi)\n",
+    "for i in range(flows):\n",
+    "    step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d)\n",
+    "    dbi_eval(step_poly,d=d)\n",
+    "    off_diagonal_norm[i+1,1] = dbi_eval.off_diagonal_norm\n",
+    "\n",
+    "dbi_eval = deepcopy(dbi)\n",
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "step = 1e-2\n",
+    "iterations = 200\n",
+    "d, loss, grad, diags = gradient_ascent(dbi_eval, d,step, iterations)\n",
+    "for i in range(flows):\n",
+    "    step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d)\n",
+    "    dbi_eval(step_poly,d=d)\n",
+    "    off_diagonal_norm[i+1,2] = dbi_eval.off_diagonal_norm\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 95,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x1ae5218b340>"
+      ]
+     },
+     "execution_count": 95,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "plt.plot(off_diagonal_norm[:,0],label= 'No normalization')\n",
+    "plt.plot(off_diagonal_norm[:,1],label= 'Normalization')\n",
+    "plt.plot(off_diagonal_norm[:,2],label= 'Gradient Ascent')\n",
+    "plt.xlabel('Flows Iterations')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Hyperopt does it get stuck"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.5|INFO|2024-03-21 15:05:50]: Using qibojit (numba) backend on /CPU:0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"qibojit\", \"numba\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 7\n",
+    "h = 3.0\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# define the least-squares cost function\n",
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "dbi_eval = deepcopy(dbi)\n",
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "flows = 50\n",
+    "off_diagonal_norm = np.empty(flows+1)\n",
+    "off_diagonal_norm[0] = dbi_eval.off_diagonal_norm\n",
+    "for i in range(flows):\n",
+    "    step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.hyperopt,d=d)\n",
+    "    dbi_eval(step_poly,d=d)\n",
+    "    off_diagonal_norm[i+1] = dbi_eval.off_diagonal_norm\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 81,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x1fa9e086be0>"
+      ]
+     },
+     "execution_count": 81,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABVTUlEQVR4nO3deVxU9f4/8NdsDNsAsg2MrCq4IbiQippgLmVmmm1mi/4s66ZWZN80s+8N77cw7abltWy5pbZ429S2a26luCuiIKLiBsgqosCwDAMzc35/IJMoIigzZxhez8djHso5Z868Pdec1/2sEkEQBBARERHZCanYBRARERG1JYYbIiIisisMN0RERGRXGG6IiIjIrjDcEBERkV1huCEiIiK7wnBDREREdkUudgHWZjKZUFBQAJVKBYlEInY5RERE1AKCIKCiogIajQZSafNtMx0u3BQUFCAwMFDsMoiIiOgW5ObmIiAgoNlrOly4UalUAOofjpubm8jVEBERUUtotVoEBgaav8eb0+HCTUNXlJubG8MNERFRO9OSISUcUExERER2heGGiIiI7ArDDREREdmVDjfmhoiI7JfJZEJtba3YZdAtUCgUkMlkbXIvhhsiIrILtbW1yMrKgslkErsUukUeHh7w8/O77XXoGG6IiKjdEwQBhYWFkMlkCAwMvOkib2RbBEFAdXU1iouLAQD+/v63dT+GGyIiavcMBgOqq6uh0Wjg7Owsdjl0C5ycnAAAxcXF8PX1va0uKkZbIiJq94xGIwDAwcFB5ErodjQE07q6utu6D8MNERHZDe4Z2L611f9+NhVuKioqEB8fj+DgYDg5OWHIkCFITk42nxcEAQkJCdBoNHByckJcXBwyMjJErJiIiIhsjU2Fm2eeeQZbt27FV199hfT0dIwZMwajRo1Cfn4+AGDJkiVYunQpVqxYgeTkZPj5+WH06NGoqKgQuXIiIiKyFTYTbnQ6HdatW4clS5Zg+PDh6NatGxISEhAaGoqVK1dCEAS8//77WLBgASZNmoSIiAisWbMG1dXVWLt2rdjlExERkY2wmXBjMBhgNBrh6OjY6LiTkxN2796NrKwsFBUVYcyYMeZzSqUSsbGx2Lt37w3vq9frodVqG70sQW8wIq+0Ghe0NRa5PxER2adp06Zh4sSJ1x3fsWMHJBIJysrKrF6TJYSEhOD999+3ymfZTLhRqVSIiYnB//3f/6GgoABGoxFff/01Dhw4gMLCQhQVFQEA1Gp1o/ep1WrzuaYsWrQI7u7u5ldgYKBF6l/x5xkMW7wdH24/Y5H7ExERWVt7Xe3ZZsINAHz11VcQBAGdO3eGUqnE8uXLMWXKlEZz3a8dSS0IQrOjq+fPn4/y8nLzKzc31yK1e7sqAQAXK/QWuT8REbWcIAiorjWI8hIEoU3/LFVVVXBzc8OPP/7Y6Pivv/4KFxcXVFRUIDs7GxKJBN9++y2GDBkCR0dH9O7dGzt27Gj0nuPHj+Pee++Fq6sr1Go1nnzySZSUlJjPx8XFYfbs2ZgzZw68vb0xevRoAEBSUhIGDhwIpVIJf39/vPbaazAYDNe9b/bs2fDw8ICXlxfeeOMN87OIi4tDTk4OXn75ZUgkEovParOpRfy6du2KpKQkVFVVQavVwt/fH48++ihCQ0Ph5+cHACgqKmq0cmFxcfF1rTlXUyqVUCqVFq/dR8VwQ0RkK3R1RvT6+2ZRPvv4P+6Gs0Pbfb26uLhg8uTJWLVqFR566CHz8YafVSoVLl26BAB49dVX8f7776NXr15YunQp7r//fmRlZcHLywuFhYWIjY3FjBkzsHTpUuh0OsybNw+PPPII/vzzT/N916xZg+effx579uyBIAjIz8/Hvffei2nTpuHLL7/EyZMnMWPGDDg6OiIhIaHR+55++mkcOHAAhw4dwrPPPovg4GDMmDED69evR1RUFJ599lnMmDGjzZ7NjdhUuGng4uICFxcXlJaWYvPmzViyZIk54GzduhX9+vUDUN9clpSUhMWLF4tc8V/hpqSS4YaIiFrnt99+g6ura6NjDQsTAvWziYcMGYKCggJoNBqUlJTgt99+w9atWxu9Z/bs2XjwwQcBACtXrsSmTZvw+eefY+7cuVi5ciX69++PxMRE8/VffPEFAgMDcerUKYSHhwMAunXrhiVLlpivWbBgAQIDA7FixQpIJBL06NEDBQUFmDdvHv7+97+bt7oIDAzEsmXLIJFI0L17d6Snp2PZsmWYMWMGPD09IZPJoFKpzI0VlmRT4Wbz5s0QBAHdu3fHmTNn8Oqrr6J79+74f//v/0EikSA+Ph6JiYkICwtDWFgYEhMT4ezsjClTpohdOruliIhsiJNChuP/uFu0z26tESNGYOXKlY2OHThwAE888QQAYODAgejduze+/PJLvPbaa/jqq68QFBSE4cOHN3pPTEyM+fdyuRzR0dE4ceIEACAlJQXbt2+/LkQBwNmzZ83hJjo6utG5EydOICYmplFX0tChQ1FZWYm8vDwEBQUBAAYPHtzompiYGLz33nswGo1tttt3S9lUuCkvL8f8+fORl5cHT09PPPjgg3j77behUCgAAHPnzoVOp8PMmTNRWlqKQYMGYcuWLVCpVCJX/lfLTVWtEdW1hjZtkiQiotaRSCTt6t9hFxcXdOvWrdGxvLy8Rj8/88wzWLFiBV577TWsWrXK/H/8b6bhGpPJhPHjxzfZ23H1cA8XF5dG55oa29owlsZWV4S2qQHFjzzyCM6ePQu9Xo/CwkKsWLEC7u7u5vMSiQQJCQkoLCxETU0NkpKSEBERIWLFf3FxkJnTeklF+xxdTkREtuuJJ57A+fPnsXz5cmRkZGDq1KnXXbN//37z7w0GA1JSUtCjRw8AQP/+/ZGRkYGQkBB069at0evaQHO1Xr16Ye/evY0GSu/duxcqlQqdO3du8rMbfg4LCzO32jg4ODTqarMkmwo37ZlEIoG3qn7DtouVXOuGiIjaVqdOnTBp0iS8+uqrGDNmDAICAq675sMPP8SGDRtw8uRJzJo1C6WlpZg+fToAYNasWbh8+TIee+wxHDx4EOfOncOWLVswffr0ZkPHzJkzkZubixdeeAEnT57Ezz//jDfffBNz5swxj7cBgNzcXMyZMweZmZn4z3/+g3/961946aWXzOdDQkKwc+dO5OfnN5qhZQkMN23Ih+NuiIjIgp5++mnU1taaA8u13nnnHSxevBhRUVHYtWsXfv75Z3h7ewMANBoN9uzZA6PRiLvvvhsRERF46aWX4O7u3iikXKtz587YuHEjDh48iKioKPztb3/D008/jTfeeKPRdU899RR0Oh0GDhyIWbNm4YUXXsCzzz5rPv+Pf/wD2dnZ6Nq1K3x8fNrgadxY++mQbAfM08Er2S1FREQts3r16iaPx8XFXbdmTmFhIby8vDBhwoQm39OzZ8/ruoeuFhYWhvXr19/w/LXr4jSIjY3FwYMHb/g+AFAoFHj//fevGxjdYPDgwUhLS2v2Hm2F4aYNccYUERFZQnV1NbKysrBo0SI899xzcHBwELskm8ZuqTbEhfyIiMgSlixZgr59+0KtVmP+/Plil2Pz2HLThriQHxERWUJCQkKj1YCvFRIS0ubbPrTGjbqzxMKWmzbEbikiInGJ+QVPt6+t/vdjuGlD7JYiIhJHw1oq7XUXa6pXXV0NAObFe28Vu6XaUMNU8JJK/U13KyciorYjl8vh7OyMixcvQqFQNDu1mWyPIAiorq5GcXExPDw8bnu7BoabNtTQcqM3mFChN8DN8faSJxERtYxEIoG/vz+ysrKQk5Mjdjl0izw8PNpkY02GmzbkqJBBpZSjQm/AxQo9ww0RkRU5ODggLCyMXVPtlEKhaLMNNhlu2piPSokKvQElFXp09bl+51UiIrIcqVQKR0dHscsgkbFTso2ZZ0xxOjgREZEoGG7aGGdMERERiYvhpo1xIT8iIiJxMdy0MW/X+v0+2HJDREQkDoabNsZuKSIiInEx3LSxv7qlOBWRiIhIDAw3bYz7SxEREYmL4aaNXT2g2GTiBm5ERETWxnDTxrxc6sONwSSgXFcncjVEREQdD8NNG3OQS+HhXL/tAhfyIyIisj6GGwvw4bgbIiIi0TDcWEDDoGIu5EdERGR9DDcWwLVuiIiIxMNwYwHmcMOWGyIiIqtjuLEArnVDREQkHoYbC2C3FBERkXgYbiyAWzAQERGJh+HGArgzOBERkXgYbiygoeXmcpUeRm7BQEREZFUMNxbg5aKEVAKYBOByFbumiIiIrInhxgJkUgk8Xdg1RUREJAaGGwsxTwfnWjdERERWxXBjIeYZU2y5ISIisiqGGwvxYcsNERGRKBhuLIQL+REREYnDpsKNwWDAG2+8gdDQUDg5OaFLly74xz/+AZPJZL5GEAQkJCRAo9HAyckJcXFxyMjIELHqpv21kB/DDRERkTXZVLhZvHgxPv74Y6xYsQInTpzAkiVL8O677+Jf//qX+ZolS5Zg6dKlWLFiBZKTk+Hn54fRo0ejoqJCxMqvx/2liIiIxGFT4Wbfvn2YMGECxo0bh5CQEDz00EMYM2YMDh06BKC+1eb999/HggULMGnSJERERGDNmjWorq7G2rVrRa6+MXZLERERicOmws2wYcPwxx9/4NSpUwCAtLQ07N69G/feey8AICsrC0VFRRgzZoz5PUqlErGxsdi7d2+T99Tr9dBqtY1e1sBuKSIiInHIxS7gavPmzUN5eTl69OgBmUwGo9GIt99+G4899hgAoKioCACgVqsbvU+tViMnJ6fJey5atAgLFy60bOFNaOiWKq2uQ63BBAe5TeVIIiIiu2VT37jfffcdvv76a6xduxaHDx/GmjVr8M9//hNr1qxpdJ1EImn0syAI1x1rMH/+fJSXl5tfubm5Fqv/ah5OCsil9TVdqmLrDRERkbXYVMvNq6++itdeew2TJ08GAPTp0wc5OTlYtGgRpk6dCj8/PwD1LTj+/v7m9xUXF1/XmtNAqVRCqVRavvhrSKUSeLsqUaStQUlFLfzdnaxeAxERUUdkUy031dXVkEoblySTycxTwUNDQ+Hn54etW7eaz9fW1iIpKQlDhgyxaq0t4a26sr9UZY3IlRAREXUcNtVyM378eLz99tsICgpC7969ceTIESxduhTTp08HUN8dFR8fj8TERISFhSEsLAyJiYlwdnbGlClTRK7+ej6cDk5ERGR1NhVu/vWvf+F///d/MXPmTBQXF0Oj0eC5557D3//+d/M1c+fOhU6nw8yZM1FaWopBgwZhy5YtUKlUIlbetL9mTNWKXAkREVHHIREEQRC7CGvSarVwd3dHeXk53NzcLPpZSzadxEc7zmLakBAk3N/bop9FRERkz1rz/W1TY27sDRfyIyIisj6GGwsyhxsu5EdERGQ1DDcW1LCQXwlbboiIiKyG4caC2C1FRERkfQw3FtQQbir0BtTUGUWuhoiIqGNguLEglVJu3lOKrTdERETWwXBjQRKJ5K+F/DiomIiIyCoYbizMvJAfW26IiIisguHGwrzZckNERGRVDDcW9lfLDbdgICIisgaGGwv7ayE/7gxORERkDQw3Fubj6gCAs6WIiIisheHGwrgzOBERkXUx3FgYVykmIiKyLoYbCzPPlmK4ISIisgqGGwtrCDe6OiOq9AaRqyEiIrJ/DDcW5qKUw8VBBoCtN0RERNbAcGMF3iou5EdERGQtDDdW0LC/FLdgICIisjyGGyvwYcsNERGR1TDcWAFnTBEREVkPw40V/LWQH8MNERGRpTHcWAEX8iMiIrIehhsrYLcUERGR9TDcWAH3lyIiIrIehhsruLpbShAEkashIiKybww3VuDl4gAAqDWaoNVxCwYiIiJLYrixAkeFDG6OcgBc64aIiMjSGG6shDOmiIiIrIPhxkrMM6bYckNERGRRDDdWYp4xxZYbIiIii2K4sRLuL0VERGQdDDdWwoX8iIiIrIPhxkq4vxQREZF1MNxYCWdLERERWQfDjZX4sFuKiIjIKhhurKSh5eZSVS1MJm7BQEREZCk2FW5CQkIgkUiue82aNQsAIAgCEhISoNFo4OTkhLi4OGRkZIhcdct4ujhAIgGMJgGl1dxAk4iIyFJsKtwkJyejsLDQ/Nq6dSsA4OGHHwYALFmyBEuXLsWKFSuQnJwMPz8/jB49GhUVFWKW3SIKmRSdnOv3mOLu4ERERJZjU+HGx8cHfn5+5tdvv/2Grl27IjY2FoIg4P3338eCBQswadIkREREYM2aNaiursbatWvFLr1FOO6GiIjI8mwq3FyttrYWX3/9NaZPnw6JRIKsrCwUFRVhzJgx5muUSiViY2Oxd+/eG95Hr9dDq9U2eonFW1XfcnOxska0GoiIiOydzYabn376CWVlZZg2bRoAoKioCACgVqsbXadWq83nmrJo0SK4u7ubX4GBgRar+WYaWm5KKtgtRUREZCk2G24+//xzjB07FhqNptFxiUTS6GdBEK47drX58+ejvLzc/MrNzbVIvS3BLRiIiIgsTy52AU3JycnBtm3bsH79evMxPz8/APUtOP7+/ubjxcXF17XmXE2pVEKpVFqu2FZQuzkCAE4Uitc1RkREZO9ssuVm1apV8PX1xbhx48zHQkND4efnZ55BBdSPy0lKSsKQIUPEKLPVRvWsD2G7z5SgoEwncjVERET2yebCjclkwqpVqzB16lTI5X81LEkkEsTHxyMxMREbNmzAsWPHMG3aNDg7O2PKlCkiVtxyId4uiOniBUEAfkzJE7scIiIiu2Rz3VLbtm3D+fPnMX369OvOzZ07FzqdDjNnzkRpaSkGDRqELVu2QKVSiVDprXn0jkDsO3cJ3yXnYvaIbpBKbzxeiIiIiFpPIghCh9oLQKvVwt3dHeXl5XBzc7P659fUGTHw7W3Q1hjw1dMDcWeYj9VrICIiam9a8/1tc91S9s5RIcPEfp0BAN8lizdzi4iIyF4x3Ijg0Tvq19rZknEBpVVc84aIiKgtMdyIoLfGHRGd3VBrNGHDkXyxyyEiIrIrDDciefSOIAD1XVMdbNgTERGRRTHciOT+KA2UcikyL1QgLa9c7HKIiIjsBsONSNydFBjXp36l5e+Sz4tcDRERkf1guBHRI1cGFv+SWoAqvUHkaoiIiOwDw42IBoV6IsTLGVW1Rvw3vVDscoiIiOwCw42IJBKJufWGa94QERG1DYYbkT3UPwAyqQQpOaU4U1whdjlERETtHsONyHzdHDGiuy8Att4QERG1BYYbGzD5StfU+sP5qDWYRK6GiIiofWO4sQFx3X3gq1LiUlUt/jhxQexyiIiI2jWGGxsgl0nx0IAAAMB3h9g1RUREdDsYbmzEI9H1XVNJpy6ioEwncjVERETtF8ONjQjxdsHgLp4QBODHlDyxyyEiImq3GG5syOSrNtM0mbiZJhER0a1guLEh90T4QeUoR36ZDnvOlohdDhERUbvEcGNDHBUyPNCvMwDgw+1n2HpDRER0CxhubMwzw7rAUSHF/nOX8c1B7hZORETUWgw3NibIyxnz7ukBAFi08QRyL1eLXBEREVH7wnBjg6bGhGBgqCeqa42Y++NRdk8RERG1AsONDZJKJXj3oUg4KWTYd+4Svj6QI3ZJRERE7QbDjY0K9nLBvHu6AwAWbTyJ85fYPUVERNQSDDc27KmYEAwK9YSuzohXf0xj9xQREVELMNzYsPruqSg4O8hwIOsyvtrP7ikiIqKbYbixcUFeznhtbP3sqXd+P4mcS1UiV0RERGTbGG7agScGBWNwl4buKc6eIiIiag7DTTtwdffUwazL+HJfttglERER2SyGm3Yi0NMZ8xu6pzadRHYJu6eIiIiawnDTjjw+KBhDunqhps7Exf2IiIhugOGmHZFKJVj8YCRcHGQ4mH0ZX+zJErskIiIim8Nw084Eejrj9XE9AdTPnkrOvixyRURERLaF4aYdmjIwCPdF+sNgEjDzm8Mo1taIXRIREZHNYLhphySS+u6pcLUrLlboMXvtEdQZTWKXRUREZBMYbtopF6UcHz8xACqlHAezLyNx4wmxSyIiIrIJDDftWBcfV7z3SBQAYNWebPycmi9yRUREROKzuXCTn5+PJ554Al5eXnB2dkbfvn2RkpJiPi8IAhISEqDRaODk5IS4uDhkZGSIWLG4xvT2w6wRXQEAr61Lx8kircgVERERicumwk1paSmGDh0KhUKB33//HcePH8d7770HDw8P8zVLlizB0qVLsWLFCiQnJ8PPzw+jR49GRUWFeIWLbM7o7rgzzBu6OiP+9lUKynV1YpdEREQkGokgCDazEtxrr72GPXv2YNeuXU2eFwQBGo0G8fHxmDdvHgBAr9dDrVZj8eLFeO655276GVqtFu7u7igvL4ebm1ub1i+my1W1GP+v3cgv02FUT198+mQ0pFKJ2GURERG1idZ8f9tUy80vv/yC6OhoPPzww/D19UW/fv3w2Wefmc9nZWWhqKgIY8aMMR9TKpWIjY3F3r17m7ynXq+HVqtt9LJHni4OWPlEfzjIpdh2ohgf7TgjdklERESikLfm4tDQUEgkrW8NiI+Px4svvnjT686dO4eVK1dizpw5eP3113Hw4EG8+OKLUCqVeOqpp1BUVAQAUKvVjd6nVquRk5PT5D0XLVqEhQsXtrrm9igywAP/N6E35q1Lx3tbT6FPgAdiw33ELouIiMiqWhVuVq9efUsfEhIS0qLrTCYToqOjkZiYCADo168fMjIysHLlSjz11FPm664NWIIg3DB0zZ8/H3PmzDH/rNVqERgY2Mo/Qfvx6B1BSM0tw38O5uKlb4/g19nDEOjpLHZZREREVtOqcBMbG2upOgAA/v7+6NWrV6NjPXv2xLp16wAAfn5+AICioiL4+/ubrykuLr6uNaeBUqmEUqm0UMW2KeH+3jheoEVaXjmmr07Gd8/FwNPFQeyyiIiIrMKmxtwMHToUmZmZjY6dOnUKwcHBAOq7xfz8/LB161bz+draWiQlJWHIkCFWrdWWKeUyrHxiAPzcHHG6uBLTVh1ERQ1nUBERUcdgU+Hm5Zdfxv79+5GYmIgzZ85g7dq1+PTTTzFr1iwA9d1R8fHxSExMxIYNG3Ds2DFMmzYNzs7OmDJlisjV2xaNhxO+fmYgPF0ccDSvHM+sOYSaOqPYZREREVlcq6aCW3pAMQD89ttvmD9/Pk6fPo3Q0FDMmTMHM2bMMJ8XBAELFy7EJ598gtLSUgwaNAgffvghIiIiWnR/e50KfiPH8svx2Kf7UaE34K4evvjkyQFQyGwq0xIREd1Ua76/WxVukpKSbqmgkJAQc9eS2DpauAGAg1mX8eTnB6A3mDA+SoP3H+0LGdfAISKidsRi4cYedMRwAwDbM4sxY80hGEwCpgwKwtsTI26pFY6IiEgMVlvEr66uDrm5ucjMzMTly5dv51ZkYSO6+2LZo30hkQBrD5zHks2ZN38TERFRO9TqcFNZWYlPPvkEcXFxcHd3R0hICHr27AkfHx8EBwdjxowZSE5OtkStdJvGR2mQ+EAfAMDKHWe5ijEREdmlVoWbZcuWISQkBJ999hnuuusurF+/HqmpqTh16hT27duHN998EwaDAaNHj8Y999yD06dPW6puukWPDQzC6/f2AAAs2ZSJr/c3vbIzERFRe9WqMTcPP/ww/v73v6NPnz7NXqfX6/H555/DwcEBzzzzzG0X2ZY66piba/1zcyZWbD8DiQRY+kgUHugXIHZJREREN8QBxc1guKknCALe/CUDX+7LgVQCvPtQFB4cwIBDRES2SZRdwVetWtVWtyIrkEgkSBjfG48NDIJJAP7nxzR8n5wrdllERES3rc3Czfr167F9+3bzzzqdDo8//nhb3Z4sQCqV4O2JEXhycDAEAZi77ijWHjgvdllERES3pc3Czddff40FCxbg5MmTOH36NO68807ExcW11e3JQqRSCf4xoTf+39AQAMDrG9Lx5b5sUWsiIiK6Ha3aFbwpc+bMQd++fdG3b1988cUXmDJlCgRBwBdffIF+/fq1RY1kYRKJBH+/rxcUMik+3XkOf/85AwajgOnDQsUujYiIqNVuO9zExsbi6NGj+PXXX3Hy5EkUFBRg8ODB2LJlCwoKCjBu3Li2qJMsTCKRYP7YHpBLJfhox1n847fjMJhMeHZ4V7FLIyIiapU2ny2l0+lw7NgxHD16FMeOHcOyZcva8va3jbOlmicIApZtPYXlf9Yv8Pfq3d0xa0Q3kasiIqKOzqJTwQVBaNd7EjHctMwH205j2bZTAICXR4XjpVFhIldEREQdWWu+v1vdLeXq6oq+fftiwIAB5levXr0glbbZ2GSyAS+NCoNcJsG7mzOxbNsplFbX4rWxPeCokIldGhERUbNa3XLz0Ucf4fDhw0hJSUFGRgaMRiMcHR0RGRlpDjv9+/dHVFSUpWq+LWy5aZ1Pd55F4saTAIDuahWWPdoXvTR8bkREZF1WW6FYr9fDyckJr7/+Oi5fvozDhw/j6NGj0Ov1MBqNt3pbi2K4ab1txy/gtfVHUVJZCweZFK+MCcczd3aBTNp+uyeJiKh9ser2C1KpFKmpqYiMjAQAGI1GZGRkmH+2NQw3t6akUo/X1qVj24kLAICBoZ5Y+kgUAjo5i1wZERF1BKJsv9BAJpPZbLChW+ftqsRnTw3AO5P6wNlBhoNZlzH2/V1Yl5KHDrY9GRER2TiOAqYWk0gkmDwwCL+/dCf6B3mgQm/AKz+kYdbawyitqhW7PCIiIgC3EG5mzJiBjz/+GIcOHYJerweAdj01nFov2MsF3z8Xg/8ZEw65VIKN6UW4+/2d2JheCJOJrThERCSuVo+5GT58ONLS0lBRUQG5XA6DwYBJkyYhLi4O/fv3R9++feHsbLvjMDjmpm2l55Uj/rsjOHuxCgDQy98Nc0aHY2RPX4ZeIiJqM1YZUHz69GmkpKSYp4UfOXIEZWVlkMlkCA8PR0ZGxi0Vb2kMN21PV2vEyh1n8MWebFTqDQCAyAB3vDw6HHHhPgw5RER026w6W+pqWVlZOHToEI4cOYLExMS2um2bYrixnNKqWny66xxW78mGrq5+KYD+QR6YM7o7hnbzYsghIqJbZrFwc/78eQQFBbW4kPz8fHTu3LnF11sDw43llVTq8UnSWXy5Lwd6gwlA/dTxOaPDMbiLl8jVERFRe2SxqeB33HEHZsyYgYMHD97wmvLycnz22WeIiIjA+vXrW3N7shPerkosGNcLu+aOwLQhIXCQS3Ew6zImf7ofj3yyD3+evMDp40REZDGtarm5fPkyEhMT8cUXX0ChUCA6OhoajQaOjo4oLS3F8ePHkZGRgejoaLzxxhsYO3asJWu/JWy5sb7Cch0+2n4W3yafR52x/q9bd7UKzw7vgvFRGjjIuSIBERE1z+JjbmpqarBx40bs2rUL2dnZ0Ol08Pb2Rr9+/XD33XcjIiLilou3NIYb8RSV12DVnix8c+C8eeCxv7sjnh4WiskDg+CqbPU+rkRE1EFYZUCxVqttl+GA4UZ82po6fLP/PL7Yk4WLFfVrJakc5XhycDCmDQ2Br8pR5AqJiMjWWCXcyGQyfP/993jwwQdvqUixMNzYDr3BiJ+O5OOTnedw7so6OQ4yKSb202DqkBD01riLXCEREdkKq4QbqVSKu+66CxUVFZBIJIiOjsaTTz6JQYMG3VLR1sJwY3tMJgHbTlzAx0lncfh8mfn4wBBPTB0SgjG91VDIOC6HiKgjs1q48fLywuTJk+Hi4oKUlBTs2rULzz//PJYtW3ZLhVsDw41tS8kpxeq92fg9vRCGK1s5+Lk54smYYEy+IxBerkqRKyQiIjFYLdxs3rwZo0ePNh9LT0/HxIkTMXPmTLzyyiu3cluLY7hpHy5oa/DN/hysPXgeJZX1m3I6yKW4P0qDaUNCENGZXVZERB2JVcKNj48Pdu3ahR49ejQ6/t///hfx8fE4ffr0rdzW4hhu2he9wYj/Hi3E6r3ZOJpXbj4eFeCOBwcEYHykBp1cHESskIiIrMEq4WbUqFHo168f3n333UbHMzMzERUVhZqamlu5rcUx3LRPgiDgSG4ZVu/JxsaruqwUMgnu6uGLB/sHIK67L9fMISKyU1YJN/v378eIESPwwAMPYObMmYiMjIROp8PcuXNx8OBBnDhx4paKtzSGm/avpFKPn1MLsC4lD8cLtebjni4OuD9Kgwf7ByCisxv3siIisiNW2zgzLS0NL730Enbv3m1eTt/R0RE//PAD7r333lu9rUUx3NiXE4VarD+chw1HClBSqTcfD1e74oF+ARgf5Y+ATs4iVkhERG3B6ruCFxcXIyUlBSaTCYMGDYK3t/ft3tJiGG7sk8Fowq4zJViXkoctxy+g9sqGnQAwILgT7o/S4N4+/vBRcbYVEVF7ZPVw01YSEhKwcOHCRsfUajWKiooA1I+7WLhwIT799FOUlpZi0KBB+PDDD9G7d+8WfwbDjf0r19VhY3ohfkktwP6sS2j4Gy6VAEO7eWN8lAZ39/aDu5NC3EKJiKjFWvP9bXOb+fTu3Rvbtm0z/yyTycy/X7JkCZYuXYrVq1cjPDwcb731FkaPHo3MzEyoVCoxyiUb5O6kwGMDg/DYwCBc0Nbgt6OF+CWtAGm5Zdh1ugS7TpfgjQ3HENfdB+Mi/TGihy/cHBl0iIjsRatabkJDQ29pkGZ8fDxefPHFm16XkJCAn376CampqdedEwQBGo0G8fHxmDdvHgBAr9dDrVZj8eLFeO6551pUC1tuOq6cS1X4Na0Av6QV4NSFSvNxhUyCwV28MKaXGqN6qeHv7iRilURE1BSLdUslJSXdUkEhISEIDg6+6XUJCQl499134e7uDqVSiUGDBiExMRFdunTBuXPn0LVrVxw+fBj9+vUzv2fChAnw8PDAmjVrmrynXq+HXv/XQFOtVovAwECGmw7uZJEWv6YVYEvGBZwurmx0LjLAHaN7qjGmtx/C1a6cdUVEZAPa7Zib33//HdXV1QgPD8eFCxfw1ltv4eTJk8jIyEBmZiaGDh2K/Px8aDQa83ueffZZ5OTkYPPmzU3es6lxPAAYbsjs3MVKbD1+AVuPX0DK+VJc/V9EkKcz7urhi9juPhgc6gUnB9mNb0RERBbTbsPNtaqqqtC1a1fMnTsXgwcPxtChQ1FQUAB/f3/zNTNmzEBubi42bdrU5D3YckOtcbFCjz9O1AedXWdKGs26cpBLMSjUE8PDfBDb3QdhvmzVISKyFosNKLb0mJtrubi4oE+fPjh9+jQmTpwIACgqKmoUboqLi6FWq294D6VSCaWS03+pZXxUSkweGITJA4NQpTdg1+mLSDp1ETtPlSC/TGcekPz2xhPwc3PE8HBvxIb7Ymg3L3g4cxsIIiJb0Kpws3r16lv6kJCQkFt6n16vx4kTJ3DnnXciNDQUfn5+2Lp1q3nMTW1tLZKSkrB48eJbuj9Rc1yUctwT4Y97IvwhCALOXqxE0qkS7Dx1EfvPXUKRtgbfH8rD94fyIJEAvfzdENPFC0O6eeGOEE+oOAOLiEgUNtUt9T//8z8YP348goKCUFxcjLfeegtJSUlIT09HcHAwFi9ejEWLFmHVqlUICwtDYmIiduzY0aqp4JwtRW2hps6Ig1mXsfNUfcvOtYOSZVIJ+nR2x5CuXojp6oXoYE+O1yEiug3tdp2bvLw8PPbYYygpKYGPjw8GDx6M/fv3m2dazZ07FzqdDjNnzjQv4rdlyxaucUNW56iQYXi4D4aH++ANAMUVNdh/7jL2nS3BvrOXkH2pGqm5ZUjNLcNHO85CIZOgb6AHBnfxwqBQLwwI7sSwQ0RkITbVcmMNbLkha8gv02Hf2UvYeyXsFJbXNDqvkEkQGeCBwV08zWHHRWlT/1+DiMim2M1sKUtguCFrEwQBOZeqsf/cJRzIuoz9564PO3KpBH0C3DEwxBMDgjthQHAneLlyIDwRUQOGm2Yw3JDYBEFA7mUd9mddqg885y4jv0x33XVdvF3QP7gTooM7ITqkE7p4u0Iq5dRzIuqYGG6awXBDtij3cjUOZF1GSs5lHMouvW6AMgB4OCvQP6i+Vad/UCdEBbrD2YFdWUTUMTDcNIPhhtqDsupaHD5fipScUhzKLkVaXhlq6kyNrpFJJejl74b+QR7ofyXwBHRy4sKCRGSXGG6awXBD7VGd0YTjBVocyinF4Zz60FOkrbnuOl+VEgOCO6FfkAeiAjwQ0dmdA5WJyC4w3DSD4YbsRUGZDik5pTh8vj7wZBRoYTA1/s9ZKgHCfFWICnRHVGB94Onup4JCJhWpaiKiW8Nw0wyGG7JXNXVGHM0rR0pOKdJyy5CWV3bdrCwAUMqliOjsjsiA+lefzh7o4u3CwcpEZNMYbprBcEMdSbG2Bml55eawk5ZbBm2N4brrXJVy9Na41YedAA9EdnZHsJczx+8Qkc1guGkGww11ZCaTgOxLVUjLK8PRvHKk55XjWEH5dYOVAcDNUY6Izu7oE+COPp3rX0GeDDxEJA6Gm2Yw3BA1ZjCacPZiFY7mlSE9vxxH88pxvFCLWkMzgaezu/lXtvAQkTUw3DSD4Ybo5uqMJmQWVeBYfjnS88txLL8cJworUGu8PvC4KuXo7qdCDz8Vevi7oaefCuF+KrhxV3QiakMMN81guCG6NbUGE05duCbwFFU02cIDAJ09nNDTX4Uefm7o7qdCdz8VQr1d2sVMrYIyHfQGE0K9XcQuhYiuYLhpBsMNUdupM5qQVVKFE4VanCyqwMlCLTKLKlDQxCwtoH7D0C7ergi/0tITrlahu1qFgE5ONjNb62KFHqOXJaHOYMLe+SPh7sQWKCJb0Jrvb67uRUS3TCGTIlxdH1ImXHW8vLoOJ4uuBJ6i+sBz6kIlKvUGZF6oQOaFCvya9tf1TgoZwtSuCPNVIVxdH37C1Spo3B2tPp5nyaaTKKuuAwCcKa7AgGBPq34+Ed0+hhsianPuzgoM6uKFQV28zMcEQUBBeQ0yi7TILKrEqQsVyCyqwJmLldBdWaPnaF55o/u4KuXo5utaH3jUKoSpVQjzdYW/hULPkfOl+CElz/xzzqVqhhuidojhhoisQiKRoLOHEzp7OOGuHmrzcYPRhOxL1Th9ob5151RxBU5fqMC5i1Wo1BuQmluG1NyyRvdqCD1hvq7mFp8wtSs07rfevWU0Cfj7zxkA6ld2Ngn14YaI2h+GGyISlVwmRTdfV3TzdcXYPn8drzOakF1SVR94LlTgdHF9+MkuuXHocXaQYWRPNd59KBKOClmr6vj+UC7S88uhUsrxcHQgvtiThfOXGW6I2iOGGyKySQqZtL4bSq3COPibj9caTMi5VIXTxQ2hpxJnLlTiXEklqmuN+DWtABIAH0zu2+Kuq7LqWizZdBIA8PLocKjdHPHFnixkX6qyxB+NiCyM4YaI2hUH+V+h594+f4WeOqMJO09dxHNfpeCXtAJ09XHFS6PCWnTP97acQml1HbqrVXgqJhgniyoAAOfZLUXULtn+ghNERC2gkEkxsqca/zcxAgCwbNsp/Ha04KbvO5Zfjm8O5AAAEu7vDblMiiAvZwDApapaVOqv34uLiGwbww0R2ZXHBgbhmWGhAIBXvk+7blzO1QRBwJu/ZMAkAOOjNIjpWj+7y81RgU7O9evb5LBriqjdYbghIrsz/96eGNnDF3qDCTO+PISCMl2T1204ko+UnFI4O8jw+r09Gp0L9qpfnZhdU0TtD8MNEdkdmVSCDx7rhx5+Klys0OPpNYdQdU33UkVNHRI31g8ifuGuMPi7OzU6H3ylayqb4Yao3WG4ISK75KqU499To+Ht6oAThVrEf5cKk+mv3WaW/3EaJZV6hHq7YPqwkOveH+xZH27OX2a3FFF7w3BDRHYroJMzPn0qGg5yKbYev4DFm+tbak5fqMCqPdkAgDfH94JSfv2aOEFXuqW4kB9R+8NwQ0R2rX9QJ7z7UCQA4JOkc/j+UC4Sfs2AwSRgdC814rr7Nvm+kCvdUgw3RO0P17khIrs3oW9nnL1YheV/nMa8dUchCPXr5fz9vl43fE/DdPCCch30BmOTrTtEZJvYckNEHUL8yDCMi/SHcGXYzfOxXRF4ZVxNU3xclXB2kEEQgLzSpmdbEZFtYssNEXUIUqkE7z0chWq9AdW1Rjwf17XZ6yUSCYI8nXGyqALnL1Wjq4+rlSolotvFcENEHYajQoZV/29gi68P9qoPN1zIj6h9YbcUEdENNCzkl8PdwYnaFYYbIqIbCPLkjCmi9ojhhojoBoLN08HZLUXUnjDcEBHdQLBnfbdUbqmu0erGRGTbGG6IiG5A4+EIuVSCWoMJRdoascshohZiuCEiugG5TIqATvUbamaza4qo3WC4ISJqRsMeU+c5qJio3bDZcLNo0SJIJBLEx8ebjwmCgISEBGg0Gjg5OSEuLg4ZGRniFUlEdq9hd3BOBydqP2wy3CQnJ+PTTz9FZGRko+NLlizB0qVLsWLFCiQnJ8PPzw+jR49GRUWFSJUSkb1rmDHFlhui9sPmwk1lZSUef/xxfPbZZ+jUqZP5uCAIeP/997FgwQJMmjQJERERWLNmDaqrq7F27VoRKyYie/bXQn4cc0PUXthcuJk1axbGjRuHUaNGNTqelZWFoqIijBkzxnxMqVQiNjYWe/fuveH99Ho9tFptoxcRUUuZ17opqYYgcDo4UXtgU+Hm22+/xeHDh7Fo0aLrzhUVFQEA1Gp1o+Nqtdp8rimLFi2Cu7u7+RUYGNi2RRORXWtYpbhCb0BpdZ3I1RBRS9hMuMnNzcVLL72Er7/+Go6Ojje8TiKRNPpZEITrjl1t/vz5KC8vN79yc3PbrGYisn+OChn83Or/TeJKxUTtg82Em5SUFBQXF2PAgAGQy+WQy+VISkrC8uXLIZfLzS0217bSFBcXX9eaczWlUgk3N7dGLyKi1ghqGFTMGVNE7YLNhJuRI0ciPT0dqamp5ld0dDQef/xxpKamokuXLvDz88PWrVvN76mtrUVSUhKGDBkiYuVEZO8apoNnlzDcELUHcrELaKBSqRAREdHomIuLC7y8vMzH4+PjkZiYiLCwMISFhSExMRHOzs6YMmWKGCUTUQdhHlTMGVNE7YLNhJuWmDt3LnQ6HWbOnInS0lIMGjQIW7ZsgUqlErs0IrJjwVylmKhdkQgdbG6jVquFu7s7ysvLOf6GiFrkaF4Z7l+xBz4qJZIXjLr5G4iozbXm+9tmxtwQEdmqYM/6lpuLFXpU1xpEroaIbobhhojoJtydFXB3UgAActg1RWTzGG6IiFogpGFQMcMNkc1juCEiaoGghkHFnDFFZPMYboiIWqBhrRu23BDZPoYbIqIWCGK3FFG7wXBDRNQC5pYbdksR2TyGGyKiFgjxrh9zU1BWgzqjSeRqiKg5DDdERC3gq1LCUSGF0SQgv1QndjlE1AyGGyKiFpBIJAgyd01x3A2RLWO4ISJqoaArKxXnXOK4GyJbxnBDRNRCXMiPqH1guCEiaqFghhuidoHhhoiohbhKMVH7wHBDRNRCV69SbDIJIldDRDfCcENE1EKdOzlBJpVAbzChuEIvdjlEdAMMN0RELaSQSdHZwwkAZ0wR2TKGGyKiVjAPKuZaN0Q2i+GGiKgVGhbyO88ZU0Q2i+GGiKgVQq7MmMpmtxSRzWK4ISJqhaAr3VLn2S1FZLMYboiIWoEL+RHZPoYbIqJWaBhzU66rQ1l1rcjV2K6TRVr8cCgXgsD1gMj65GIXQETUnjg7yOGjUuJihR45l6rh4ewgdkk2x2A04enVh5BfpoOniwNG9lSLXRJ1MGy5ISJqpRBOB2/WnyeLkV+mAwBsO1EscjXUETHcEBG1UpDnlT2mOGOqSV/tzzH/PimzmF1TZHUMN0RErcRBxTeWXVKFXadLIJEADjIpCsprcOpCpdhlUQfDcENE1EpcpfjGvjlQ32oTG+6Dod28AADbM9k1RdbFcENE1ErBVxby4/5SjdXUGfH9oTwAwJODgzGihy8AYPtJhhuyLoYbIqJWCr4yHfyCVo9NxwpRZzSJXJFt+DWtAOW6OnT2cEJcd1/EhdeHm0M5pdDW1IlcHXUkDDdERK3k4aww7w7+t68PI2bRn3jn95PIKunYLTlfHzgPAHh8cBBkUgmCvJzRxccFRpOAPadLRK6OOhKGGyKiVpJIJPjhbzF4Pq4rvF2VKKnU4+Oksxjxzx2Y/Ok+/Jyaj5o6o9hlWtXRvDKk5ZZBIZPgkehA8/ER3a90TXHcDVkRF/EjIroFGg8nzLunB+aMDsefJ4vx7cHzSDp1EfvPXcb+c5fh7qTAA/06Y8qgIISrVWKXa3FfX5n+fW8ff3i7Ks3HR3T3xee7s7A98yIEQYBEIhGrROpAGG6IiG6DQibF3b39cHdvPxSU6fDDoTx8fygX+WU6rN6bjTX7svFQ/wC8end3+Lo5il2uRZRX1+GXtAIA9QOJr3ZHaCc4O8hwsUKPjAItIjq7i1EidTDsliIiaiMaDye8NCoMO+eOwJrpAzGmlxqCAPyQkoe4f+7Ah9vP2GV31Y+H81BTZ0IPPxUGBHdqdE4pl2FoN28AwA52TZGVMNwQEbUxmVSC2HAffPpUNNY9PwR9Az1QXWvEu5szMfK9JPyaVmA3q/aaTIK5S+rJmOAmu53iuvsAAHZkXrRqbdRxMdwQEVnQgOBOWP/8EHwwuS/83R2RX6bDC/85goc+3ofU3DKxy7tte89eQlZJFVyVckzs27nJa+KuDCo+fL6UO6mTVdhUuFm5ciUiIyPh5uYGNzc3xMTE4PfffzefFwQBCQkJ0Gg0cHJyQlxcHDIyMkSsmIjo5qRSCSb07Yw/X4nDnNHhcFLIkJJTiokf7sGc71KRUVCOY/nl2H/uEv44cQE/p+Zj7YHz+GznOSzbegpv//c4/vXHaZtcNPCr/dkAgEn9O8NF2fQwzs4eTuiuVsEkADs5JZyswKYGFAcEBOCdd95Bt27dAABr1qzBhAkTcOTIEfTu3RtLlizB0qVLsXr1aoSHh+Ott97C6NGjkZmZCZXK/mcjEFH75uQgw4sjw/BIdCCWbD6J9Yfzsf5I/asl3tt6CoO7eOKR6ECMjfCHk4PMwhU3r7BcZ971+4lrBhJfK66HDzIvVGDHyWLcH6WxRnnUgUkEG+/49fT0xLvvvovp06dDo9EgPj4e8+bNAwDo9Xqo1WosXrwYzz33XIvup9Vq4e7ujvLycri5uVmydCKiZqXllmHxppNIzy+Hi4McLkoZXJVyODvI4aKUw1Upg7NSDlelHCcKtdh9pgQN/2K7KuUYH6XBI9EB6BvoIcoU66VbT2H5H6cxKNQT3z0X0+y1+89dwuRP98PLxQHJC0ZBKuWUcGqd1nx/21TLzdWMRiN++OEHVFVVISYmBllZWSgqKsKYMWPM1yiVSsTGxmLv3r03DDd6vR56vd78s1artXjtREQtERXogbUzBrf4+vwyHdal5OGHlFzkXtbhPwfP4z8HzyPM1xWPRAdiTG813BwVcHKQQSmXWjTw1BlN+M/B+hWJb9ZqA9SPPVIp5bhUVYv0/HJEBXpYrDYimws36enpiImJQU1NDVxdXbFhwwb06tULe/fuBQCo1epG16vVauTk5NzwfosWLcLChQstWjMRkTV09nDCiyPDMHtENxzIuowfDuVi47FCnC6uxNsbT+DtjSfM10okgKNcBmcHGRwVMjg5yOCkkKGTiwN6+qvQy98NvTXuCPV2gewWWlG2ZFzAxQo9vF2VuLu3302vV8ikGBbmjd+PFWF7ZjHDDVmUzYWb7t27IzU1FWVlZVi3bh2mTp2KpKQk8/lr/5/IzVa8nD9/PubMmWP+WavVIjAw8IbXExHZOqlUgpiuXojp6oWECb3xW1ohfkjJRUa+FrVXNvEUBEBXZ4SuiXV1dp76a0q2o0KKHn5u6KVxuxJ43NDdTwVnh+a/Hhqmfz82MBAO8pbNTRnR3fdKuLmI+FHhLf3jErWazYUbBwcH84Di6OhoJCcn44MPPjCPsykqKoK/v7/5+uLi4utac66mVCqhVCpveJ6IqD1zc1RgyqAgTBkUBAAwGE2oMZigqzWi5kq4qa41mn8uLK/B8cJyHC/Q4kRhBXR1RqTmll03LV3j7oguPq7o4uOCLt4u5t9r3J1wrqQS+85dglQCPDYwqMW1xl5Z7+ZoXhlKKvWNtmkgaks2F26uJQgC9Ho9QkND4efnh61bt6Jfv34AgNraWiQlJWHx4sUiV0lEZBvkMilcZVK43mBa9tWMJgHZl6pwvECL44VaZBRocbygHCWVtSgor0FBeQ12n2k8ddtR8de9R/VUQ3Nld/SWULs5orfGDRkFWuw8dRGT+ge07g9H1EI2FW5ef/11jB07FoGBgaioqMC3336LHTt2YNOmTZBIJIiPj0diYiLCwsIQFhaGxMREODs7Y8qUKWKXTkTU7sikEnT1cUVXH1eMv2p69uWqWpy7WIlzF6twtqT+13MXK3H+cjVq6kyoqatfiG/qkJBWf+aI7r7IKNBiRybDDVmOTYWbCxcu4Mknn0RhYSHc3d0RGRmJTZs2YfTo0QCAuXPnQqfTYebMmSgtLcWgQYOwZcsWrnFDRNSGPF0c4OniiegQz0bHDUYT8kp1OFdS2WjPqNaI6+6DFdvPIOnURRhNwi0NZia6GZtf56atcZ0bIiLxGIwmDHhrG8p1dVj3fAwGBHve/E1EaN33t01tv0BERPZNLpNieHj9wOLtJ7mRJlkGww0REVnViCuzprZnFotcCdkrhhsiIrKq4eE+kEiAjAItirU1YpdDdojhhoiIrMrbVYnIAA8AwI5T7JqitsdwQ0REVhd3ZdzNDnZNkQUw3BARkdWN6OELANh1qgTF2hp0sIm7ZGE2tc4NERF1DJGd3eHl4oBLVbUYmPgHXBxkCPZyQYi3c/2vXvW/hnq7wFeltOgO52R/GG6IiMjqpFIJXhnTHR/tOIP8Mh2qao04Xli/DcS1vF0d8L/39cKEvp1FqJTaIy7iR0REotIbjMgr1SG7pArZl6qRc+mvX/NKdTCa6r+mJvbV4B8TI+DmqBC5YhJDa76/2XJDRESiUspl5j2urqU3GPHh9rNY8edp/JRagOTsUix7tC8GhnJlY7oxDigmIiKbpZTLMGd0OH74WwwCPZ2QX6bD5E/34d3NJ1FnNIldHtkohhsiIrJ5A4I9sfHFO/HQgACYBODD7Wfx4Mq9OHexUuzSyAYx3BARUbugclTgnw9H4aPH+8PdSYGjeeUYt3w31h443+xUcqNJgLamDhcr9NDVGjntvAPggGIiImp3Cst1eOX7NOw9ewkAMDDUE52cFajUG1BZY0DFlV8r9QZU1xobvVcmlcDFQQaVowIuShlclXK4OirgqpTBz80JL48Og4qDlm0OBxQTEZFd83d3wtdPD8Lnu7Pw7uZMHMy63OL31rfkGKCtMTR5vlJfhyUPRbVVqSQChhsiImqXpFIJZgzvgrjuPkg6dRGOChlUjnK4KuVwUdb/evXPDjIpquuM5hadSr0BVXoDKmrqfy3S1uCfWzLx/aE83BepwfArW0RQ+8NwQ0RE7VqYWoUwtapF17peCT03crFCj9V7szF/fTo2vzy82WvJdnFAMRER0RWv3t0dAZ3qp5wv2XRS7HLoFjHcEBERXeGilOOdSZEAgC/35bRqLA/ZDoYbIiKiqwwL88aj0YEAgHnrjqKmzniTd5CtYbghIiK6xuvjekLtpkRWSRWWbT0ldjnUSgw3RERE13B3UuDtiX0AAJ/tOoe03DJxC6JWYbghIiJqwqheakzoq4FJAOb+eBS1Btvby0oQBJTr6sQuw+Yw3BAREd3Am+N7w8vFAZkXKvDh9jNil9NIdkkVJn+6H33/sQUf7bCt2sTGcENERHQDni4OWDihNwDgw+1ncKJQK3JF9Sssf747C/d8sBMHsi5DEIAlmzKxak+W2KXZDIYbIiKiZozr448xvdQwmATM/fEoDEbxuqfOXqzEI5/sw//9dhw1dSYM6eqFp4eFAgAW/noc3yWfF602W8KlF4mIiJohkUjw1sQI7D93Cen55fj37iz8LbarVWswGE349+4sLN16CrUGE1yVcsy/twemDAwCAEglwGe7svDa+nQ4KmSY0LezVeuzNdwVnIiIqAV+OJSLV388CgeZFFGB7nBzVMDdSQG3Ky93JwXcHOVwd1LAy9UB3XxVcHe6/d3FT12owKs/pCEtrxwAcGeYN955MBKdPZzM1wiCgDd+OoZvDpyHTCrBysf7Y0xvv9v+bFvSmu9vhhsiIqIWEAQBM75MwbYTF1r8Ho27I3r4u6GHnwo9/N3Q00+FUG8XyGU3HhVSazBBW1MHra4OG9MLsfyPM6g1mqBylON/x/XCw9EBkEgk173PZBLwPz+kYf2RfDjIpPh8WjTuDLOfzT8ZbprBcENERLfKZBKQnH0Zl6tqUa6rQ7muDtqaK7/qDOZjxdoaFJTXNHkPB7kUYb6uCPZyhq7WCG2NAdor99HqDNA1sSLyXT18kfhAH/i5OzZbn8Fowuy1R7ApowiOCim+nD4IA0M92+TPLjaGm2Yw3BARkTWU6+pw6kIFThZqcaKo/tfMogpU1bZsOweVUg4fNyVeuKsbJvbt3GRrTVNqDSY8+9Uh7Mi8CFelHGtnDEJkgMdt/ElsA8NNMxhuiIhILCaTgLxSHU4UaZFfqoOroxxujgq4Ocn/GsPjqICroxwyacvCTFNq6oyYtuog9p+7DA9nBb59djB6+LXv7zyGm2Yw3BARUUdQqTfgiX8fQGpuGbxdlXj93h64J8IPzg7tc6I0w00zGG6IiKijKK+uw+TP9psXH3R2kGFshD8e7N8Zg7t4QXobrUPWxnDTDIYbIiLqSMp1dVi9Jxvrj+Qh51K1+bjG3REP9O+MSf0D0NXHVcQKW4bhphkMN0RE1BEJgoCUnFKsO5yP344WoKLGYD7XN9ADD/bvjPFRGng4O4hY5Y0x3DSD4YaIiDq6mjoj/jhRjHWH85B06iKMpvoo4CCTYmRPXzzYPwCx3X2gaGY9Hmtrzfe37VQNYNGiRbjjjjugUqng6+uLiRMnIjMzs9E1giAgISEBGo0GTk5OiIuLQ0ZGhkgVExERtT+OChnGRfrji2l3YP/8kfjf+3qhp78bao0m/H6sCM98eQgxi/7AP349juMF4m8W2lo21XJzzz33YPLkybjjjjtgMBiwYMECpKen4/jx43BxcQEALF68GG+//TZWr16N8PBwvPXWW9i5cycyMzOhUqlu+hlsuSEiImra8QIt1h3Ow8+p+SiprDUf7+nvhgf7d8aEvp3ho1KKUpvddEtdvHgRvr6+SEpKwvDhwyEIAjQaDeLj4zFv3jwAgF6vh1qtxuLFi/Hcc8/d9J4MN0RERM2rM5qw89RFrDuch23Hi1F7ZSd0qQQIV6sQFeCBqEAPRAW6I1ytskr3VWu+v216snt5ef0mYZ6e9UtHZ2VloaioCGPGjDFfo1QqERsbi7179zYZbvR6PfR6vflnrbb9Na8RERFZk0ImxcieaozsqUZZdS1+TSvAj4fzkZZbhpNFFThZVIHvDuUCAJRyKSI6u18JPPW/Bns5t3hFZUuw2XAjCALmzJmDYcOGISIiAgBQVFQEAFCr1Y2uVavVyMnJafI+ixYtwsKFCy1bLBERkZ3ycHbAkzEheDImBBe0NUjNLUNabhmO5pUjLa8MFTUGpOSUIiWn1PyexwYGYtGkSNFqttlwM3v2bBw9ehS7d+++7ty1aVAQhBsmxPnz52POnDnmn7VaLQIDA9u2WCIiog5A7eaIu3v74e7efgDqt5PIulSFo3llSMstR2puGY4XatFdffMxsJZkk+HmhRdewC+//IKdO3ciICDAfNzPr/5hFhUVwd/f33y8uLj4utacBkqlEkqlOIOfiIiI7JlUKkFXH1d09XHFA/3qv69rDSbz1HLR6hL1068hCAJmz56N9evX488//0RoaGij86GhofDz88PWrVvNx2pra5GUlIQhQ4ZYu1wiIiK6hoNcCicHmag12FTLzaxZs7B27Vr8/PPPUKlU5jE27u7ucHJygkQiQXx8PBITExEWFoawsDAkJibC2dkZU6ZMEbl6IiIisgU2FW5WrlwJAIiLi2t0fNWqVZg2bRoAYO7cudDpdJg5cyZKS0sxaNAgbNmypUVr3BAREZH9s+l1biyB69wQERG1P+12+wUiIiKi28VwQ0RERHaF4YaIiIjsCsMNERER2RWGGyIiIrIrDDdERERkVxhuiIiIyK4w3BAREZFdYbghIiIiu8JwQ0RERHbFpvaWsoaG3Sa0Wq3IlRAREVFLNXxvt2TXqA4XbioqKgAAgYGBIldCRERErVVRUQF3d/dmr+lwG2eaTCYUFBRApVJBIpG06b21Wi0CAwORm5vLTTktiM/ZOvicrYPP2Tr4nK3Dks9ZEARUVFRAo9FAKm1+VE2Ha7mRSqUICAiw6Ge4ubnxPx4r4HO2Dj5n6+Bztg4+Z+uw1HO+WYtNAw4oJiIiIrvCcENERER2heGmDSmVSrz55ptQKpVil2LX+Jytg8/ZOvicrYPP2Tps5Tl3uAHFREREZN/YckNERER2heGGiIiI7ArDDREREdkVhhsiIiKyKww3beSjjz5CaGgoHB0dMWDAAOzatUvsktq1nTt3Yvz48dBoNJBIJPjpp58anRcEAQkJCdBoNHByckJcXBwyMjLEKbYdW7RoEe644w6oVCr4+vpi4sSJyMzMbHQNn/XtW7lyJSIjI80Lm8XExOD33383n+cztoxFixZBIpEgPj7efIzPum0kJCRAIpE0evn5+ZnPi/2cGW7awHfffYf4+HgsWLAAR44cwZ133omxY8fi/PnzYpfWblVVVSEqKgorVqxo8vySJUuwdOlSrFixAsnJyfDz88Po0aPNe4dRyyQlJWHWrFnYv38/tm7dCoPBgDFjxqCqqsp8DZ/17QsICMA777yDQ4cO4dChQ7jrrrswYcIE8z/2fMZtLzk5GZ9++ikiIyMbHeezbju9e/dGYWGh+ZWenm4+J/pzFui2DRw4UPjb3/7W6FiPHj2E1157TaSK7AsAYcOGDeafTSaT4OfnJ7zzzjvmYzU1NYK7u7vw8ccfi1Ch/SguLhYACElJSYIg8FlbUqdOnYR///vffMYWUFFRIYSFhQlbt24VYmNjhZdeekkQBP59bktvvvmmEBUV1eQ5W3jObLm5TbW1tUhJScGYMWMaHR8zZgz27t0rUlX2LSsrC0VFRY2euVKpRGxsLJ/5bSovLwcAeHp6AuCztgSj0Yhvv/0WVVVViImJ4TO2gFmzZmHcuHEYNWpUo+N81m3r9OnT0Gg0CA0NxeTJk3Hu3DkAtvGcO9zGmW2tpKQERqMRarW60XG1Wo2ioiKRqrJvDc+1qWeek5MjRkl2QRAEzJkzB8OGDUNERAQAPuu2lJ6ejpiYGNTU1MDV1RUbNmxAr169zP/Y8xm3jW+//RaHDx9GcnLydef497ntDBo0CF9++SXCw8Nx4cIFvPXWWxgyZAgyMjJs4jkz3LQRiUTS6GdBEK47Rm2Lz7xtzZ49G0ePHsXu3buvO8dnffu6d++O1NRUlJWVYd26dZg6dSqSkpLM5/mMb19ubi5eeuklbNmyBY6Ojje8js/69o0dO9b8+z59+iAmJgZdu3bFmjVrMHjwYADiPmd2S90mb29vyGSy61ppiouLr0ut1DYaRuTzmbedF154Ab/88gu2b9+OgIAA83E+67bj4OCAbt26ITo6GosWLUJUVBQ++OADPuM2lJKSguLiYgwYMAByuRxyuRxJSUlYvnw55HK5+XnyWbc9FxcX9OnTB6dPn7aJv9MMN7fJwcEBAwYMwNatWxsd37p1K4YMGSJSVfYtNDQUfn5+jZ55bW0tkpKS+MxbSRAEzJ49G+vXr8eff/6J0NDQRuf5rC1HEATo9Xo+4zY0cuRIpKenIzU11fyKjo7G448/jtTUVHTp0oXP2kL0ej1OnDgBf39/2/g7bZVhy3bu22+/FRQKhfD5558Lx48fF+Lj4wUXFxchOztb7NLarYqKCuHIkSPCkSNHBADC0qVLhSNHjgg5OTmCIAjCO++8I7i7uwvr168X0tPThccee0zw9/cXtFqtyJW3L88//7zg7u4u7NixQygsLDS/qqurzdfwWd+++fPnCzt37hSysrKEo0ePCq+//roglUqFLVu2CILAZ2xJV8+WEgQ+67byyiuvCDt27BDOnTsn7N+/X7jvvvsElUpl/t4T+zkz3LSRDz/8UAgODhYcHByE/v37m6fS0q3Zvn27AOC619SpUwVBqJ9q+Oabbwp+fn6CUqkUhg8fLqSnp4tbdDvU1DMGIKxatcp8DZ/17Zs+fbr53wcfHx9h5MiR5mAjCHzGlnRtuOGzbhuPPvqo4O/vLygUCkGj0QiTJk0SMjIyzOfFfs4SQRAE67QREREREVkex9wQERGRXWG4ISIiIrvCcENERER2heGGiIiI7ArDDREREdkVhhsiIiKyKww3REREZFcYboiIiMiuMNwQUZPi4uIQHx8vdhk2bdq0aZg4caLYZRDRNRhuiDqoadOmQSKRXPc6c+aM2KVdZ/Xq1fDw8DD/nJCQgL59+1rt87OzsyGRSJCamtro+AcffIDVq1dbrQ4iahm52AUQkXjuuecerFq1qtExHx8fkaqxvrq6OigUilt+v7u7extWQ0RthS03RB2YUqmEn59fo5dMJmvy2tLSUjz11FPo1KkTnJ2dMXbsWJw+fRoAIAgCfHx8sG7dOvP1ffv2ha+vr/nnffv2QaFQoLKyEkB960tQUBCUSiU0Gg1efPHFFtW8evVqLFy4EGlpaebWpobWk/Lycjz77LPw9fWFm5sb7rrrLqSlpZnf29Di88UXX6BLly5QKpUQBAGbNm3CsGHD4OHhAS8vL9x33304e/as+X2hoaEAgH79+kEikSAuLg7A9d1Ser0eL774Inx9feHo6Ihhw4YhOTnZfH7Hjh2QSCT4448/EB0dDWdnZwwZMgSZmZnma9LS0jBixAioVCq4ublhwIABOHToUIueDRHVY7ghohaZNm0aDh06hF9++QX79u2DIAi49957UVdXB4lEguHDh2PHjh0A6oPQ8ePHUVdXh+PHjwOo/2IfMGAAXF1d8eOPP2LZsmX45JNPcPr0afz000/o06dPi+p49NFH8corr6B3794oLCxEYWEhHn30UQiCgHHjxqGoqAgbN25ESkoK+vfvj5EjR+Ly5cvm9585cwbff/891q1bZ+5mqqqqwpw5c5CcnIw//vgDUqkUDzzwAEwmEwDg4MGDAIBt27ahsLAQ69evb7K2uXPnYt26dVizZg0OHz6Mbt264e677270+QCwYMECvPfeezh06BDkcjmmT59uPvf4448jICAAycnJSElJwWuvvXZbrUtEHZLV9h8nIpsydepUQSaTCS4uLubXQw89ZD4fGxsrvPTSS4IgCMKpU6cEAMKePXvM50tKSgQnJyfh+++/FwRBEJYvXy5EREQIgiAIP/30kxAdHS1MmjRJ+PDDDwVBEIQxY8YI8+bNEwRBEN577z0hPDxcqK2tbVGtq1atEtzd3c0/v/nmm0JUVFSja/744w/Bzc1NqKmpaXS8a9euwieffGJ+n0KhEIqLi5v9vOLiYgGAkJ6eLgiCIGRlZQkAhCNHjjS6burUqcKECRMEQRCEyspKQaFQCN988435fG1traDRaIQlS5YIgiAI27dvFwAI27ZtM1/z3//+VwAg6HQ6QRAEQaVSCatXr27+gRBRs9hyQ9SBjRgxAqmpqebX8uXLm7zuxIkTkMvlGDRokPmYl5cXunfvjhMnTgCon12VkZGBkpISJCUlIS4uDnFxcUhKSoLBYMDevXsRGxsLAHj44Yeh0+nQpUsXzJgxAxs2bIDBYLitP0tKSgoqKyvh5eUFV1dX8ysrK6tRF1NwcPB144rOnj2LKVOmoEuXLnBzczN3Q50/f77Fn3/27FnU1dVh6NCh5mMKhQIDBw40P6MGkZGR5t/7+/sDAIqLiwEAc+bMwTPPPINRo0bhnXfeaVQ7EbUMww1RB+bi4oJu3bqZXw1ftNcSBOGGxyUSCQAgIiICXl5eSEpKMoeb2NhYJCUlITk5GTqdDsOGDQMABAYGIjMzEx9++CGcnJwwc+ZMDB8+HHV1dbf8ZzGZTPD3928U1lJTU5GZmYlXX3210Z/5WuPHj8elS5fw2Wef4cCBAzhw4AAAoLa2tsWf3/CMGp7H1cevPXZ1N1PDuYYusISEBGRkZGDcuHH4888/0atXL2zYsKHFdRARww0RtUCvXr1gMBjMX/oAcOnSJZw6dQo9e/YEAPO4m59//hnHjh3DnXfeiT59+qCurg4ff/wx+vfvD5VKZX6/k5MT7r//fixfvhw7duzAvn37kJ6e3qJ6HBwcYDQaGx3r378/ioqKIJfLGwW2bt26wdvb+4b3unTpEk6cOIE33ngDI0eORM+ePVFaWnrd5wG47jOv1q1bNzg4OGD37t3mY3V1dTh06JD5GbVUeHg4Xn75ZWzZsgWTJk26bkYbETWP4YaIbiosLAwTJkzAjBkzsHv3bqSlpeGJJ55A586dMWHCBPN1cXFxWLt2LSIjI+Hm5mYOPN988415hhFQP+Pp888/x7Fjx3Du3Dl89dVXcHJyQnBwcIvqCQkJQVZWFlJTU1FSUgK9Xo9Ro0YhJiYGEydOxObNm5GdnY29e/fijTfeaHa2UadOneDl5YVPP/0UZ86cwZ9//ok5c+Y0usbX1xdOTk7YtGkTLly4gPLy8uvu4+Ligueffx6vvvoqNm3ahOPHj2PGjBmorq7G008/3aI/l06nw+zZs7Fjxw7k5ORgz549SE5ObnU4IuroGG6IqEVWrVqFAQMG4L777kNMTAwEQcDGjRsbdbGMGDECRqOxUZCJjY2F0Wg0j7cBAA8PD3z22WcYOnQoIiMj8ccff+DXX3+Fl5dXi2p58MEHcc8992DEiBHw8fHBf/7zH0gkEmzcuBHDhw/H9OnTER4ejsmTJyM7OxtqtfqG95JKpfj222+RkpKCiIgIvPzyy3j33XcbXSOXy7F8+XJ88skn0Gg0jQLd1d555x08+OCDePLJJ9G/f3+cOXMGmzdvRqdOnVr055LJZLh06RKeeuophIeH45FHHsHYsWOxcOHCFr2fiOpJhBt1phMRERG1Q2y5ISIiIrvCcENERER2heGGiIiI7ArDDREREdkVhhsiIiKyKww3REREZFcYboiIiMiuMNwQERGRXWG4ISIiIrvCcENERER2heGGiIiI7Mr/B1gAD4CkWu7VAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "plt.plot(off_diagonal_norm[:],label= 'Hyperopt')\n",
+    "plt.xlabel('Flows Iterations')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Difference between numerical gradients and analytic ones\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.5|INFO|2024-03-21 14:20:15]: Using qibojit (numba) backend on /CPU:0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"qibojit\", \"numba\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 7\n",
+    "h = 3.0\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# define the least-squares cost function\n",
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nqubits = [3,4,5,6,7]\n",
+    "iterations = 100\n",
+    "step = 1e-2\n",
+    "differences = np.empty((len(nqubits),iterations+1))\n",
+    "loss_max = np.empty(len(nqubits))\n",
+    "for q in range(len(nqubits)):\n",
+    "    # define the hamiltonian\n",
+    "    H_TFIM = hamiltonians.TFIM(nqubits=nqubits[q], h=h)\n",
+    "\n",
+    "    # define the least-squares cost function\n",
+    "    cost = DoubleBracketCostFunction.least_squares\n",
+    "    # initialize class\n",
+    "    dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "    loss_max [q] = dbi.least_squares(D=np.diag(np.linspace(1,2**nqubits[q],2**nqubits[q])))\n",
+    "    d = np.diag(np.linspace(1,2**nqubits[q],2**nqubits[q]))\n",
+    "    d_analytic, loss_analytic, grad_analytic, diags_analytic = gradient_ascent(dbi, d,step, iterations)\n",
+    "    d = np.diag(np.linspace(1,2**nqubits[q],2**nqubits[q]))\n",
+    "    d_numerical, loss_numerical, grad_numerical, diags_numerical = gradient_ascent(dbi, d,step, iterations, analytic=False)\n",
+    "    differences[q,:] = loss_analytic - loss_numerical\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x1fa9cb63940>"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "for q in range(len(nqubits)):\n",
+    "    plt.plot(differences[q,:],label= 'nqubits = {}'.format(nqubits[q]))\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel('Difference in analytic and numerical loss function')\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.title('Normalized difference')\n",
+    "for q in range(len(nqubits)):\n",
+    "    plt.plot(differences[q,:]/loss_max[q],label= 'nqubits = {}'.format(nqubits[q]))\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel('Difference in analytic and numerical loss function')\n",
+    "plt.legend()\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Difference in optimization moments\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.5|INFO|2024-03-21 14:44:56]: Using qibojit (numba) backend on /CPU:0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"qibojit\", \"numba\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 7\n",
+    "h = 3.0\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# define the least-squares cost function\n",
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbi_eval = deepcopy(dbi)\n",
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "step = 1e-2\n",
+    "iterations = 100\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "flows = 100\n",
+    "dbi_eval = deepcopy(dbi)\n",
+    "dbi_eval2 = deepcopy(dbi)\n",
+    "d_not_optimized = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "step = 1e-2\n",
+    "iterations = 100\n",
+    "d_optimized, loss, grad, diags = gradient_ascent(dbi_eval, d,step, iterations,analytic=False)\n",
+    "off_diagonal_norm = np.empty((flows+1,3))\n",
+    "off_diagonal_norm[0] = dbi_eval.off_diagonal_norm\n",
+    "for i in range(flows):\n",
+    "    step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d)\n",
+    "    dbi_eval(step_poly,d=d)\n",
+    "    step_poly = dbi_eval2.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d_not_optimized)\n",
+    "    dbi_eval2(step_poly,d=d_not_optimized)\n",
+    "    off_diagonal_norm[i+1,0] = dbi_eval.off_diagonal_norm\n",
+    "    off_diagonal_norm[i+1,1] = dbi_eval2.off_diagonal_norm\n",
+    "\n",
+    "dbi_eval3 = deepcopy(dbi)\n",
+    "d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "for i in range(flows):\n",
+    "    d = np.diag(np.linspace(1,2**nqubits,2**nqubits))\n",
+    "    d_opt, loss, grad, diags = gradient_ascent(dbi_eval3, d,step, 20,analytic=False)\n",
+    "    step_poly = dbi_eval3.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d_opt)\n",
+    "    dbi_eval3(step_poly,d=d_opt)\n",
+    "    off_diagonal_norm[i+1,2] = dbi_eval3.off_diagonal_norm   "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x1faa03a5940>"
+      ]
+     },
+     "execution_count": 76,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "plt.plot(off_diagonal_norm[:,0],label= 'Optimized at beginning')\n",
+    "plt.plot(off_diagonal_norm[:,1],label= 'Not optimized')\n",
+    "plt.plot(off_diagonal_norm[:,2],label= 'Optimized at each step')\n",
+    "plt.xlabel('Flows Iterations')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')\n",
+    "plt.legend()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.5|INFO|2024-03-21 16:37:52]: Using qibojit (numba) backend on /CPU:0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"qibojit\", \"numba\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 7\n",
+    "h = 3.0\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# define the least-squares cost function\n",
+    "cost = DoubleBracketCostFunction.least_squares\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "end = np.linspace(1.1,10*2**nqubits,100)\n",
+    "loss = np.empty(100)\n",
+    "spacing = np.empty(100)\n",
+    "for i in range(100):\n",
+    "    dbi_eval = deepcopy(dbi)\n",
+    "    d = np.diag(np.linspace(1,end[i],2**nqubits))\n",
+    "    spacing[i] = d[1,1] - d[0,0]\n",
+    "    step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d,n = 3)\n",
+    "    dbi_eval(step_poly,d=d)\n",
+    "    loss[i] = dbi_eval.off_diagonal_norm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Loss function')"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "plt.plot(spacing,loss)\n",
+    "plt.xlabel('Spacing')\n",
+    "plt.ylabel('Loss function')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def d_poly_spacing(nqubits,degree):\n",
+    "    d = np.empty(2**nqubits)\n",
+    "    for i in range(len(d)):\n",
+    "        d[i] = 1 + i**degree\n",
+    "    return np.diag(d)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "degrees = np.linspace(0.1,5,100)\n",
+    "nqubits = [3,4,5,7]\n",
+    "h = 3.0\n",
+    "\n",
+    "loss = np.empty((100,len(nqubits)))\n",
+    "best_degree = np.empty(len(nqubits))\n",
+    "for q in range(len(nqubits)):\n",
+    "    H_TFIM = hamiltonians.TFIM(nqubits=nqubits[q], h=h)\n",
+    "    dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "    for i in range(100):\n",
+    "        dbi_eval = deepcopy(dbi)\n",
+    "        d = d_poly_spacing(nqubits[q],degrees[i])\n",
+    "        step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d,n = 3)\n",
+    "        dbi_eval(step_poly,d=d)\n",
+    "        loss[i,q] = dbi_eval.off_diagonal_norm\n",
+    "    best_degree[q] = degrees[np.argmin(loss[:,q])]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1.18888889 1.13939394 1.13939394 1.13939394]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "plt.plot(degrees,loss[:,3],label = f'{nqubits[q]} qubits')\n",
+    "plt.xlabel('Degree')\n",
+    "plt.ylabel('Loss function')\n",
+    "plt.legend()\n",
+    "print(best_degree)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x1f7381d9ee0>"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABvjUlEQVR4nO3dd1yVdf/H8ddhbxRkKiIoOHGP3JYrNa0sG7YtG7as7tbd/Su9K00rK6u7rLvM9l2ZZcuRg9wiinsLLkQcyN5cvz8uOUoaoQLnAO/n43Eecq7rOud8uCJ5+50WwzAMRERERGoJB1sXICIiIlKZFG5ERESkVlG4ERERkVpF4UZERERqFYUbERERqVUUbkRERKRWUbgRERGRWsXJ1gVUt5KSEpKTk/H29sZisdi6HBEREakAwzDIzMwkNDQUB4fy22bqXLhJTk4mLCzM1mWIiIjIRTh48CCNGjUq95o6F268vb0B8+b4+PjYuBoRERGpiIyMDMLCwqy/x8tT58JNaVeUj4+Pwo2IiEgNU5EhJRpQLCIiIrWKwo2IiIjUKgo3IiIiUqvUuTE3IiI1TXFxMYWFhbYuQ6RKOTs74+joWCnvpXAjImKnDMMgJSWFU6dO2boUkWpRr149goODL3kdOoUbERE7VRpsAgMD8fDw0MKjUmsZhkFOTg6pqakAhISEXNL7KdyIiNih4uJia7Dx9/e3dTkiVc7d3R2A1NRUAgMDL6mLSgOKRUTsUOkYGw8PDxtXIlJ9Sn/eL3WMmcKNiIgdU1eU1CWV9fNuV+EmMzOT8ePHEx4ejru7Oz169CAuLs563jAMJkyYQGhoKO7u7vTr14+tW7fasGIRERGxN3YVbu655x4WLlzIZ599xubNmxk0aBADBgzg8OHDAEydOpVp06bxzjvvEBcXR3BwMAMHDiQzM9PGlYuIiIi9sJtwk5uby+zZs5k6dSp9+vShWbNmTJgwgYiICN577z0Mw+DNN9/kueeeY+TIkbRp04ZZs2aRk5PDl19+aevyRUSkGjRp0oQ333yzVnzO0qVLsVgslT7Vv1+/fowfP75S37OmsZtwU1RURHFxMW5ubmWOu7u7s3z5chITE0lJSWHQoEHWc66urvTt25eVK1f+5fvm5+eTkZFR5lEVSopLSN63jaMHdlfJ+4uI1CWffPIJ9erVO+d4XFwc9957b/UXJDWK3YQbb29vunfvzosvvkhycjLFxcV8/vnnrFmzhiNHjpCSkgJAUFBQmdcFBQVZz53P5MmT8fX1tT7CwsKqpP64D8cR+ml39v7yRpW8v4iIQEBAgGaQ2QF7XzHbbsINwGeffYZhGDRs2BBXV1emT5/O6NGjy8x1//NIasMwyh1d/eyzz5Kenm59HDx4sEpqLwmKASD4ZNzfXCkicnEMwyCnoMgmD8MwKlxnfn4+jzzyCIGBgbi5udGrV68yk0NKu2N++eUX2rVrh5ubG926dWPz5s3W83fddRfp6elYLBYsFgsTJkwAzu0uslgszJgxg6uuugoPDw9atmzJqlWr2LNnD/369cPT05Pu3buzd+9e62v27t3L1VdfTVBQEF5eXnTp0oXff//9gv5b3HnnnVxzzTVMnDiRwMBAfHx8uO+++ygoKKjwfThbdnY2Pj4+fPfdd2WO//TTT3h6ev7l2NLs7Gxuv/12vLy8CAkJ4fXXXz/nmoKCAp566ikaNmyIp6cn3bp1Y+nSpWWu+fDDDwkLC8PDw4Nrr72WadOmlWk5mzBhAu3bt+fjjz8mMjISV1dXDMMgPT2de++913oPrrjiCjZu3HjO99CpUyfc3NyIjIxk4sSJFBUVlXd7L5ldLeLXtGlTYmNjyc7OJiMjg5CQEG688UYiIiIIDg4GzBU7z165MDU19ZzWnLO5urri6upa5bV7tbgcNkJ44R7ISwc33yr/TBGpW3ILi2n1/HybfPa2fw/Gw6VivzKeeuopZs+ezaxZswgPD2fq1KkMHjyYPXv24OfnZ73uySef5K233iI4OJh//vOfjBgxgl27dtGjRw/efPNNnn/+eXbu3AmAl5fXX37eiy++yLRp05g2bRpPP/00o0ePJjIykmeffZbGjRszZswYHnroIX777TcAsrKyGDp0KC+99BJubm7MmjWL4cOHs3PnTho3blzhe7Jo0SLc3NxYsmQJSUlJ3HXXXTRo0ICXX375gu4DgKenJzfddBMzZ87k+uuvtx4vfe7t7X3eGp588kmWLFnCnDlzrPcxPj6e9u3bW6+56667SEpK4uuvvyY0NJQ5c+Zw5ZVXsnnzZqKiolixYgX3338/U6ZMYcSIEfz+++/83//93zmftWfPHr755htmz55tbXQYNmwYfn5+/Prrr/j6+jJjxgz69+/Prl278PPzY/78+dx6661Mnz6d3r17s3fvXmu34gsvvFDhe32h7KrlppSnpychISGkpaUxf/58rr76amvAWbhwofW6goICYmNj6dGjhw2rNTWJiCKxJAhHSsjetczW5YiI2ER2djbvvfcer776KkOGDKFVq1Z8+OGHuLu789FHH5W59oUXXmDgwIHExMQwa9Ysjh49ypw5c3BxccHX1xeLxUJwcDDBwcHlhpu77rqLG264gejoaJ5++mmSkpK45ZZbGDx4MC1btuTRRx8t01LRrl077rvvPmJiYoiKiuKll14iMjKSuXPnXtD36uLiwscff0zr1q0ZNmwY//73v5k+fTolJSUXdB9K3XPPPcyfP5/k5GQAjh8/zs8//8yYMWPOe31WVhYfffQRr732Wpn7WFxcbL1m7969fPXVV3z77bf07t2bpk2b8o9//INevXoxc+ZMAN5++22GDBnCP/7xD6Kjoxk3bhxDhgw55/MKCgr47LPP6NChA23btmXJkiVs3ryZb7/9ls6dOxMVFcVrr71GvXr1rC1QL7/8Ms888wx33HEHkZGRDBw4kBdffJEZM2Zc0L2+UHbVcjN//nwMw6B58+bs2bOHJ598kubNm3PXXXdhsVgYP348kyZNIioqiqioKCZNmoSHhwejR4+2del4uzmz2LktEcULydy5BM+2V9m6JBGpZdydHdn278E2++yK2Lt3L4WFhfTs2dN6zNnZma5du7J9+/Yy13bv3t36tZ+fH82bNz/nmopo27at9evSlvyYmJgyx/Ly8sjIyMDHx4fs7GwmTpzIzz//THJyMkVFReTm5nLgwIEL+tx27dqVGf/TvXt3srKyOHjwIOnp6RW+D6W6du1K69at+fTTT3nmmWf47LPPaNy4MX369Dnv9Xv37qWgoOC897HU+vXrMQyD6OjoMq/Nz8+3buuxc+dOrr322nNq+fnnn8scCw8PJyAgwPo8Pj6erKysc7YHyc3NtXYDxsfHExcXZ23NAnNrkby8PHJycqps/JRdhZv09HSeffZZDh06hJ+fH9dddx0vv/wyzs7OgNnEl5uby7hx40hLS6Nbt24sWLDgL5vrqtuR+p3h+EKcD66wdSkiUgtZLJYKdw3ZSunYnAsdH1nqYlaoLf0dcfbrz3espKQEMLty5s+fz2uvvUazZs1wd3fn+uuvLzNe5lJYLJaLvg/33HMP77zzDs888wwzZ860/uP+fCoyDqqkpARHR0fi4+PP2auptDXsfDWd7709PT3Pee+QkJBzxu8A1vE6JSUlTJw4kZEjR55zzZ9nR1cmu/q/5IYbbuCGG274y/Olg8pKB5bZm4JGPeA41M/YAbmnwL2erUsSEalWzZo1w8XFheXLl1tb1QsLC1m3bt05a6+sXr3aOsYlLS2NXbt20aJFC8Ds8jm7e6UyLVu2jDvvvNPaWpGVlUVSUtIFv8/GjRvJzc21bvi4evVqvLy8aNSoEf7+/hW+D2e79dZbeeqpp5g+fTpbt27ljjvu+MtrmzVrhrOz83nvY9++fQHo0KEDxcXFpKam0rt37/O+T4sWLVi7dm2ZY+vWrfvb779jx46kpKTg5OREkyZN/vKanTt30qxZs799v8pkV+GmpgsNi2Tv+hCaOhyB/SuhxVBblyQiUq08PT154IEHePLJJ/Hz86Nx48ZMnTqVnJwc7r777jLX/vvf/8bf35+goCCee+45GjRowDXXXAOYs6KysrJYtGiRtfunsrowmjVrxvfff8/w4cOxWCz83//9n7VV50IUFBRw9913869//Yv9+/fzwgsv8NBDD+Hg4HBB9+Fs9evXZ+TIkTz55JMMGjSIRo0a/eW1Xl5e3H333Tz55JNl7qODw5nhtNHR0dxyyy3cfvvtvP7663To0IHjx4+zePFiYmJiGDp0KA8//DB9+vRh2rRpDB8+nMWLF/Pbb7/9bSvagAED6N69O9dccw1TpkyhefPmJCcn8+uvv3LNNdfQuXNnnn/+ea666irCwsIYNWoUDg4ObNq0ic2bN/PSSy9d8D2vKLscUFxTRQd5sbqklfkkabltixERsZFXXnmF6667jttuu42OHTuyZ88e5s+fT/369c+57tFHH6VTp04cOXKEuXPn4uLiAkCPHj24//77ufHGGwkICGDq1KmVVt8bb7xB/fr16dGjB8OHD2fw4MF07Njxgt+nf//+REVF0adPH2644QaGDx9epmehovfhz+6++24KCgr+ciDx2V599VX69OnDiBEjGDBgAL169aJTp05lrpk5cya33347TzzxBM2bN2fEiBGsWbPGuu5bz549ef/995k2bRrt2rVj3rx5PPbYY3/bbWSxWPj111/p06cPY8aMITo6mptuuomkpCTr2KfBgwfz888/s3DhQrp06cJll13GtGnTCA8P/9vv7VJYjAtZvKAWyMjIwNfXl/T0dHx8fCr1vXMKinh64gu87fwORYFtcBqnsTcicnHy8vJITEwkIiKiSscm2MLSpUu5/PLLSUtLO+8qxDXBnXfeyalTp/jhhx8q/b2/+OILHn30UZKTk61hr7qNHTuWHTt2sGxZ9c7+Le/n/kJ+f6tbqhJ5uDhx0KcT5IJj6lbIOQkefn//QhERqfNycnJITExk8uTJ3HfffdUabEqnk3t6evLbb78xa9Ys/vOf/1Tb51c2dUtVsgbBYewpCcWCYY67ERERqYCpU6fSvn17goKCePbZZ6v1s9euXWtdK+f9999n+vTp3HPPPdVaQ2VSt1QlmzpvByHLn+M2p9+h2wMw5JVK/wwRqf1qc7eUyF+prG4ptdxUsugg77MGFWulYhERkeqmcFPJzHDT0nxydIs57kZERESqjcJNJYsM8CTN4suukobmAU0JFxERqVYKN5XMzdmRJg08WaX1bkRERGxC4aYKRAdq3I2IiIitKNxUgeggL9aUjrtJ3QbZx21bkIhINerXr1+Z/ZOaNGnCm2++abN67N2f75dcOi3iVwWig705iQ/7HcMJL95vdk21vsbWZYmI2ERcXNw5O0rLGd9//32ZXczl0qnlpgpEB3kDsLzodOuNxt2ISB0WEBBQaZteXorCwkJbl3Befn5+eHt727qMWkXhpgo08ffE2dHCH4UtzAMadyMiddifu6UsFgv//e9/ufbaa/Hw8CAqKoq5c+eWec22bdsYOnQoXl5eBAUFcdttt3H8+Jku/nnz5tGrVy/q1auHv78/V111FXv37rWeT0pKwmKx8M0339CvXz/c3Nz4/PPPz1vfhAkTaNy4Ma6uroSGhvLII4+Uqf3FF19k9OjReHl5ERoayttvv13m9dOmTSMmJgZPT0/CwsIYN24cWVlZZa5ZsWIFffv2xcPDg/r16zN48GDS0tKA83fjTZo0iTFjxuDt7U3jxo354IMPyrzfypUrad++PW5ubnTu3JkffvgBi8VCQkLCX/+HqEMUbqqAi5MDEQ08z4y7ObYDso7ZtigRqfkMAwqybfOo5MXsJ06cyA033MCmTZsYOnQot9xyCydPmuuCHTlyhL59+9K+fXvWrVvHvHnzOHr0KDfccIP19dnZ2Tz++OPExcWxaNEiHBwcuPbaaykpKSnzOU8//TSPPPII27dvZ/DgwefU8d133/HGG28wY8YMdu/ezQ8//EBMTEyZa1599VXatm3L+vXrefbZZ3nsscdYuHCh9byDgwPTp09ny5YtzJo1i8WLF/PUU09ZzyckJNC/f39at27NqlWrWL58OcOHD6e4uPgv78/rr79O586d2bBhA+PGjeOBBx5gx44dAGRmZjJ8+HBiYmJYv349L774Ik8//fQF3P3aT2Nuqkh0kDe7jmZxwjMK/+zdZutNm5G2LktEarLCHJgUapvP/mcyuFTeuJk777yTm2++GYBJkybx9ttvs3btWq688kree+89OnbsyKRJk6zXf/zxx4SFhbFr1y6io6O57rrryrzfRx99RGBgINu2baNNmzbW4+PHj2fkyL/+u/fAgQMEBwczYMAAnJ2dady4MV27di1zTc+ePXnmmWcAiI6OZsWKFbzxxhsMHDjQ+hmlIiIiePHFF3nggQesG09OnTqVzp07l9mIsnXr1uXen6FDhzJu3DjADGhvvPEGS5cupUWLFnzxxRdYLBY+/PBD3NzcaNWqFYcPH2bs2LHlvmddopabKlI67marazvzgMbdiIhYtW3b1vq1p6cn3t7epKamAhAfH8+SJUvw8vKyPlq0MLv5S7ue9u7dy+jRo4mMjMTHx4eIiAjADCtn69y5c7l1jBo1itzcXCIjIxk7dixz5syhqKiozDXdu3c/5/n27dutz5csWcLAgQNp2LAh3t7e3H777Zw4cYLs7GzgTMvNhTj7/lgsFoKDg633Z+fOnbRt27bM3kt/DmR1nVpuqkh0kBcAywpb0Ac07kZELp2zh9mCYqvPrsy3+9PsIIvFYu1SKikpYfjw4UyZMuWc14WEhAAwfPhwwsLC+PDDDwkNDaWkpIQ2bdpQUFBQ5vq/m6UVFhbGzp07WbhwIb///jvjxo3j1VdfJTY2ttwZTBaLBYD9+/czdOhQ7r//fl588UX8/PxYvnw5d999t3UAs7u7+9/cjXOVd38Mw7B+fqk6tgf231K4qSKlLTdzTzXhn44WLMd3QeZR8A6ycWUiUmNZLJXaNWSvOnbsyOzZs2nSpAlOTuf+mjpx4gTbt29nxowZ9O7dG4Dlyy++ddzd3Z0RI0YwYsQIHnzwQVq0aMHmzZvp2LEjAKtXry5z/erVq60tSevWraOoqIjXX38dBwezM+Sbb74pc33btm1ZtGgREydOvOgaz1baNZWfn4+rq6u1DjlD3VJVJNzfExcnB44WelDYQKsVi4hU1IMPPsjJkye5+eabWbt2Lfv27WPBggWMGTOG4uJi6tevj7+/Px988AF79uxh8eLFPP744xf1WZ988gkfffQRW7ZsYd++fXz22We4u7sTHh5uvWbFihVMnTqVXbt28e677/Ltt9/y6KOPAtC0aVOKiop4++23ra9///33y3zGs88+S1xcHOPGjWPTpk3s2LGD9957r8zsrwsxevRoSkpKuPfee9m+fTvz58/ntddeAzinRaeuUripIo4OFpoFmF1TR/y6mAc17kZE5G+FhoayYsUKiouLGTx4MG3atOHRRx/F19cXBwcHHBwc+Prrr4mPj6dNmzY89thjvPrqqxf1WfXq1ePDDz+kZ8+e1haWn376CX9/f+s1TzzxBPHx8XTo0IEXX3yR119/3Trzqn379kybNo0pU6bQpk0bvvjiCyZPnlzmM6Kjo1mwYAEbN26ka9eudO/enR9//PG8rVIV4ePjw08//URCQgLt27fnueee4/nnnwcoMw6nLrMYdayjLiMjA19fX9LT0/Hx8anSzxr/9QZ+SEjm3U4pDNv6OPg3g4fjq/QzRaR2yMvLIzExkYiICP3CsqEmTZowfvx4u98e4YsvvuCuu+4iPT39osb42Ivyfu4v5Pe3xtxUoajT426WFUQxDAuc2AMZR8AnxMaViYhITfbpp58SGRlJw4YN2bhxI08//TQ33HBDjQ42lUndUlWo+elwk3AMCDk9rU9dUyIicolSUlK49dZbadmyJY899hijRo06ZxXjukwtN1WodMbUvmPZlPTujcORjeag4rajbFyZiIhURFJSkq1LOK+nnnqqzCrIUpZabqpQo/ruuDs7UlBcwlH/0wtJacaUiIhIlVK4qUIODhaiTi/mt8WxNVgc4OQ+SD9s48pEpKaoY3M+pI6rrJ93hZsqVto1te2kBUK0FYOIVEzpCrU5OTk2rkSk+pT+vJe3OnRFaMxNFSvdhmHX0Uxo0huSN0DSH9DuRhtXJiL2zNHRkXr16ln3E/Lw8NACbVJrGYZBTk4Oqamp1KtXD0dHx0t6P4WbKlY6HXzX0Uzo0htWTlfLjYhUSHBwMIA14IjUdvXq1bP+3F8KhZsqVjodPPF4NgUNe+JicYS0JDh1AOo1tm1xImLXLBYLISEhBAYGWjdhFKmtnJ2dL7nFppTCTRUL8XXD29WJzPwiEjMdaN6wIxyKg8Rl0OEWW5cnIjWAo6Njpf2lL1IXaEBxFbNYzsyYso67AU0JFxERqSIKN9Ug+uxxNxF9zIOJf4CmeIqIiFQ6hZtqUCbchHUDB2fIOGyueSMiIiKVSuGmGpwJN1ng4gFhXc0TiX/YsCoREZHaSeGmGpSudbP/RDZ5hcUadyMiIlKFFG6qQYC3K/U8nCkxYO+xLIg4HW4Sl2ncjYiISCVTuKkGFouF6MCzxt006gJObpCdCsd22rg6ERGR2kXhpppEB5dOB88CJ1dzYDGoa0pERKSSKdxUE+ug4pRM84C1a0qDikVERCqTwk01iSrtlkotDTd9zT+TlkFJiY2qEhERqX3sKtwUFRXxr3/9i4iICNzd3YmMjOTf//43JWf98jcMgwkTJhAaGoq7uzv9+vVj69atNqy6YkpnTB08mUt2fhGEdgBnT8hNg1T7r19ERKSmsKtwM2XKFN5//33eeecdtm/fztSpU3n11Vd5++23rddMnTqVadOm8c477xAXF0dwcDADBw4kMzPThpX/PX8vVxp4uQCwJzULHJ0hvId5MlHjbkRERCqLXYWbVatWcfXVVzNs2DCaNGnC9ddfz6BBg1i3bh1gttq8+eabPPfcc4wcOZI2bdowa9YscnJy+PLLL21c/d8rs1IxaNyNiIhIFbCrcNOrVy8WLVrErl27ANi4cSPLly9n6NChACQmJpKSksKgQYOsr3F1daVv376sXLnyvO+Zn59PRkZGmYetlIabnaWDiksX89u/EkqKbVSViIhI7eJk6wLO9vTTT5Oenk6LFi1wdHSkuLiYl19+mZtvvhmAlJQUAIKCgsq8LigoiP3795/3PSdPnszEiROrtvAKimnoC8CKvSfMAyHtwNUX8tPhyEZo2NGG1YmIiNQOdtVy87///Y/PP/+cL7/8kvXr1zNr1ixee+01Zs2aVeY6i8VS5rlhGOccK/Xss8+Snp5ufRw8eLDK6v87V7QIxNHBwvYjGRw4kQMOjtCkp3lSXVMiIiKVwq7CzZNPPskzzzzDTTfdRExMDLfddhuPPfYYkydPBiA4OBg404JTKjU19ZzWnFKurq74+PiUedhKfU8XukX4ATB/6+nvQftMiYiIVCq7Cjc5OTk4OJQtydHR0ToVPCIiguDgYBYuXGg9X1BQQGxsLD169KjWWi/W4NZmQLOGm4g+5p/7V0FxoY2qEhERqT3sKtwMHz6cl19+mV9++YWkpCTmzJnDtGnTuPbaawGzO2r8+PFMmjSJOXPmsGXLFu688048PDwYPXq0jauvmEGtzRam+ANppGbmQWArcPeDwmw4vN7G1YmIiNR8djWg+O233+b//u//GDduHKmpqYSGhnLffffx/PPPW6956qmnyM3NZdy4caSlpdGtWzcWLFiAt7e3DSuvuBBfd9o18mXjoXQWbjvKLd3CoUkv2D4Xkv6Axt1sXaKIiEiNZjEMw7B1EdUpIyMDX19f0tPTbTb+5j9L9zB13k76RAfw6ZiusPZD+PUf5pYMd8y1SU0iIiL27EJ+f9tVt1RdUTruZtXe42TkFZ4Zd3NwDRTl27AyERGRmk/hxgaaBnjRLNCLwmKDJTtSoUE0eAVBUR4cirN1eSIiIjWawo2NXHm69WbelhSwWM5MCdc+UyIiIpdE4cZGSrumlu48Rl5hsfaZEhERqSQKNzbSpqEPDeu5k1tYzLLdx8+MuzkUBwU5ti1ORESkBlO4sRGLxcLAVuaaN/O3pkD9CPBpBCWF5sBiERERuSgKNzZ0ZRuza+r37UcpKjHUNSUiIlIJFG5sqEsTP/w8XTiVU8jaxJNnuqa0z5SIiMhFU7ixIUcHCwNaBgKnu6ZKZ0wdXg/5mTasTEREpOZSuLGxMxtpHqXEpxHUbwJGsbmRpoiIiFwwhRsb69msAZ4ujqRk5LHpcPqZrqnt2oZBRETkYijc2JibsyP9WpzVNdXqGvPEhs9g3ce2K0xERKSGUrixA9auqS0pGE2vgH7Pmid+eQJ2/mbDykRERGoehRs7cHnzAFwcHdh3PJs9qVnQ92nocBsYJfDtXXBona1LFBERqTEUbuyAt5szPZv5A6e7piwWuOoNaDYQinLhyxvgxF4bVykiIlIzKNzYibNnTQHg6AyjPoGQ9pBzAj6/DrKO2aw+ERGRmkLhxk4MaBWEgwU2H07nUNrpvaVcveCWb6FeOKQlmi04Bdm2LVRERMTOKdzYiQZernRu4gfAgtLWGwCvQLh1Nrj7QfJ6+G4MFBfZqEoRERH7p3BjR850TaWUPdEgCm7+GpzcYNc8+PUJMAwbVCgiImL/FG7syKDTu4THJZ3kRFZ+2ZONu8F1/wUsEP8JLHut2usTERGpCRRu7EiYnwetQ30oMcydws/RcjgMfdX8evFLsOX76i1QRESkBlC4sTNXnu6a+nLNAYzzdT11HQvdHzK/Xvl2NVYmIiJSMyjc2JmbujbGw8WRjYfSzx17U6rHw+afyeshK7X6ihMREakBFG7sTIC3K/f0igDg1fk7KSouOfci72AIaWd+vXthNVYnIiJi/xRu7NDYPpHU93Bm77Fsvl9/+PwXRQ02/9y9oPoKExERqQEUbuyQt5szD17eDIA3ft9FXmHxuRdFDTL/3LsYigursToRERH7pnBjp269LJxQXzeOpOfx2ar9517QsCN4+EN+BhxYXf0FioiI2CmFGzvl5uzI+IHRALy7dA8ZeX9qnXFwNDfWBHVNiYiInEXhxo6N7NCQZoFenMop5MM/9p17QfTprimFGxERESuFGzvm5OjAPwY1B+C/yxI5lvmnVYubXgEWRzi2A9LO03UlIiJSBync2LnBrYNoF1aP3MJi3l68u+xJ9/oQ1s38Wq03IiIigMKN3bNYLDx9pdl68+WaAxw4kVP2AnVNiYiIlKFwUwP0aNqA3lENKCoxmLZwZ9mTpVPCE/+AgpxzXywiIlLHKNzUEE9f2QKAHzcmsy0548yJwFbg0wiK8iBpmY2qExERsR8KNzVEm4a+XNU2BMOA1xac1XpjsahrSkRE5CwKNzXIE4Oa4+hgYfGOVNYmnjxzonQrhl0L4Hw7iYuIiNQhCjc1SEQDT27sEgbAlHk7MEqDTERvcHSF9APmtHAREZE6TOGmhnm0fxSuTg7E709j3pYU86CLpxlwQF1TIiJS5ync1DBBPm7c1TMCgEe/TuDLNQfME2d3TYmIiNRhCjc10KP9o7iydTAFxSX8c85mnpm9ifzI/ubJA6sg95RN6xMREbElhZsayN3Fkfdu7chTVzbHYoGv4w5ywzcpFPlFgVEM+5bYukQRERGbUbipoSwWC+P6NWPWXV3xdXdm48FTfJVmroWjrikREanLFG5quD7RAfz8cC9ahvjwa35bAHK3z8MoKbZxZSIiIrZhV+GmSZMmWCyWcx4PPvggAIZhMGHCBEJDQ3F3d6dfv35s3brVxlXbXpifB98/0IPQmH5kGu64F5xk2qxvyC1QwBERkbrHrsJNXFwcR44csT4WLlwIwKhRowCYOnUq06ZN45133iEuLo7g4GAGDhxIZmamLcu2C+4ujrx2UxdOBPUEwHHvAka+t5K9x7JsXJmIiEj1sqtwExAQQHBwsPXx888/07RpU/r27YthGLz55ps899xzjBw5kjZt2jBr1ixycnL48ssv//I98/PzycjIKPOorSwWC026XwvAQKeNbD+SweA3/mDC3K2czC6wcXUiIiLVw67CzdkKCgr4/PPPGTNmDBaLhcTERFJSUhg0aJD1GldXV/r27cvKlSv/8n0mT56Mr6+v9REWFlYd5dtOs4EAtGYv1zRzoqjE4JOVSfR9dQkzYveSV6iuKhERqd3sNtz88MMPnDp1ijvvvBOAlBRzNd6goKAy1wUFBVnPnc+zzz5Lenq69XHw4MEqq9kueAdBSHsA3ux0nC/u6UarEB8y84qY/NsO+r8ey48Jhykp0R5UIiJSO9ltuPnoo48YMmQIoaGhZY5bLJYyzw3DOOfY2VxdXfHx8SnzqPWiT69WvHs+PZs14OeHe/HaqHYE+7hx+FQuj36dwLX/WcGafSdsW6eIiEgVsMtws3//fn7//Xfuuece67Hg4GCAc1ppUlNTz2nNqfNKt2LYuwSKC3FwsHB9p0Ys+Uc//jEoGk8XRzYeSufGD1Yz9tN1bD9Se8chiYhI3WOX4WbmzJkEBgYybNgw67GIiAiCg4OtM6jAHJcTGxtLjx49bFGm/QrtAB4NID8DDqy2HnZ3ceShK6JY+uTl3NKtMY4OFhZuO8qQt5Zxy39Xs3jHUXVXiYhIjWd34aakpISZM2dyxx134OTkZD1usVgYP348kyZNYs6cOWzZsoU777wTDw8PRo8ebcOK7ZCDA0SZA4vZPf+c0wHerrx8bQzzHu3NsJgQHCywYs8JxnyyjgHTYvlsVRI5BUXVXLSIiEjlsBiGYVf/VF+wYAGDBw9m586dREdHlzlnGAYTJ05kxowZpKWl0a1bN959913atGlT4ffPyMjA19eX9PT02j3+Zsts+G4MBLaGcX89mwzgUFoOs1Ym8fXag2Tmm6HG192Zm7s25o4e4YT4uldHxSIiIn/pQn5/2124qWp1JtzknISpkYABT+wE7+C/fUlWfhHfrTvIzJVJ7D+RA4Cjg4WhMSHc2q0xXSP8yh28LSIiUlUUbspRZ8INwIy+cCQBrp0B7W6q8MuKSwwWbT/KR8sTWZN40no8zM+dkR0aMbJjQ8L9PaugYBERkfNTuClHnQo3v0+E5dOg7U0wcsZFvcWWw+l8uiqJXzenkJV/ZhxOlyb1GdmxEUNjQvB1d66sikVERM5L4aYcdSrcJP4Bs4aDV5DZNXUJXUq5BcUs2JbCd/GHWLHnOKWTqlycHBjUKojrOjaid1QDnBztboy6iIjUAgo35ahT4aYoH6Y0gcIceGAlBLWulLdNSc/jh4TDzI4/xO7UMxtz1vdwZlCrYIa2DaFHU3+cFXRERKSSKNyUo06FG4DPr4c9C2HQS9Dj4Up9a8Mw2HI4g9nrD/HTxmROnLU5p6+7MwNbBTEsJoSezRrg4qSgIyIiF0/hphx1Ltysehfm/xOa9ofbvq+yjykqLmFt4kl+2XyE+VtTOJ51Juh4uzkxsGUQQ2JC6B3VADdnxyqrQ0REaieFm3LUuXCTuh3+cxk4ucPTSeDsVuUfWVxiEJd0kl83H+G3LSkcy8y3nnN3dqRPdAMGtAziihaB+Hu5Vnk9IiJS8ynclKPOhRvDgGktIfMI3P4jRPar1o8vKTGIP5DGL5uOMG9LCikZedZzFgt0bFyfAS2DGNgqkKYBXlpHR0REzkvhphx1LtwAzLkfNn4FPcfDwIk2K8MwDLYmZ7Bw21F+336UrcllN+xs4u9htui0DKRzuJ/G6YiIiJXCTTnqZLjZ9A18PxaC28L9y2xdjVXyqVwWbT/Kwu2prNp7nMLiMz+KXq5O9GrWgMtbBNA3OpBg36rvThMREfulcFOOOhluslLhtSjz6yf3gmcD29ZzHln5RSzbdYyF248Su/NYmZlXAC1DfLi8eQCXtwikQ1g9racjIlLHKNyUo06GG4D3esHRzXDdRxBzva2rKVdJicHmw+ks2ZnK0p3H2HjoFGf/lPq4OdE7KoA+0Q3oEx2gjT1FROoAhZty1Nlws+BfsPJtaH8rXPOurau5ICey8vlj9zGW7DhG7K5jpOcWljkfFehFn+gA+kQH0C3CT1PNRURqIYWbctTZcLNnEXw+EnwawmNbL2krBlsqKi5h46FTxO46zrLdx9h48JR1Kwgwt4PoFuFHn6gAekc3oHmQt2ZgiYjUAgo35aiz4aYwF14Jh+J8eDAOAqJtXVGlOJVTwIo9J/hj1zH+2H2MI+l5Zc438HKlVzN/ekUF0KtZAw1MFhGpoRRuylFnww3Ap1fDvqVw5RS47H5bV1PpDMNg77EsYncd549dx1iTeIK8wpIy1zQL9KJXswb0ataAbpF+eLtpR3MRkZpA4aYcdTrcLH8Tfn8Boq+E0f+zdTVVLr+omPX7T7F8zzGW7znB5kNlu7AcHSy0D6tHj6b+9GjagI7h9XB10ngdERF7pHBTjjodbo5sghm9wdnT3IrBycXWFVWr9JxCVu07zrLdx1mx5zhJJ3LKnHd1cqBLEz96NPOnZ9MGtGnoi6ODxuuIiNgDhZty1OlwU1JirneTcxzu/BWa9LR1RTZ18GQOK/ceZ8WeE6zce4LjWfllznu7OXFZpD89mvrTvak/0YHeOCjsiIjYhMJNOep0uAGYfQ9s/hb6PAlX/MvW1dgNwzDYnZrFij3HWbn3BKv3nSAzr6jMNX6eLlwW6Uf3SDPsaC8sEZHqo3BTjjofbjZ8AT+Og4adYOxiW1djt4qKS9iSnMGKPcdZve8E65LSyC0sLnNNgLcrl0X6W8NOE38PhR0RkSqicFOOOh9uMpLNXcItDuZWDB5+tq6oRigoMtfXWbX3BKv2niD+QBoFRWVnYgX5uNItwp/LIv3pFulHZANPhR0RkUqicFOOOh9uAN7tBsd2wKhZ0PoaW1dTI+UVFpNw8HTY2XeChAOnKCguG3YCvF3pFuHHZZFm4GkaoLAjInKxFG7KoXAD/PYMrHkPOt0Jw9+ydTW1Ql5hMRsOnGL1PnO8zoaDp85p2Wng5ULXCD+6NvGjW6Q/zYM0QFlEpKIUbsqhcAPsWgBfjoJ6jeHRTTV2KwZ7Vtqys2bfSVbvO8H6A2nk/yns+Lo706VJfbpF+NM1wo/WoT7a7VxE5C8o3JRD4QYoyDa3YigphIfXg39TW1dU6+UXFbPpUDpr9p1gTeJJ4venkVNQdoCyp4sjHcPr0y3Cj64R/rRt5KtNQEVETruQ399O1VST2BMXTwjrBvuXw74lCjfVwNXJkS5N/OjSxI+HgMLiErYmZ7A28QRrE0+yNvEkGXlFLNttLjII4OLoQPuwenSJqE/XCH86hdfHy1X/y4qI/B213NRVf7wGi1+EFlfBTV/Yupo6r7jEYEdKBnGJJ4lLSmNN4slzFhV0sEDrUF+6NPGja4QfXZrUx9/L1UYVi4hUL3VLlUPh5rTD8fDhFeDqA08lgqNaBOyJYRgkncg53bKTRlzSSQ6czDnnuqYBnnSN8KdrRH26NPGjUX0PG1QrIlL1qizcREREXNRU1vHjx/PII49c8OuqgsLNaSXFMDUS8k7B3QshrKutK5K/kZKex5rEE8QlnSQuMY2dRzPPuSbU182ckXV6kLKmn4tIbVFl4SY2NvaiCmrSpAnh4eEX9drKpnBzlm/ugG0/QL9nod8ztq5GLlBadgHr9putOmsTT7LlcDpFJWX/dy6dfl46I0vTz0WkplK3VDkUbs6y/lOY+zDUbwIPrQNHZ1tXJJcgp6CIDQdOsSbxJGsTT7DhwKlzpp/X83CmSxM/6+KCrUJ8FHZEpEZQuCmHws1Z8rPgrXbmLuEj3oGOt9m6IqlEFZl+Xt/DmR7NGtC7WQN6NmtAmJ/G7IiIfVK4KYfCzZ+sfAcWPAe+jeHheHBysXVFUkUKi0vYcjidtYnmwoJrE0+S/aewE+7vQa9mDejVrAE9mjbA10OteSJiHzSguBwKN39SkAPT20PWUbjqDeg8xtYVSTUpLC5h48FTLNt9nBV7jrPh4CmKzxqz42CBdmH1GNQqmEGtg2ga4GXDakWkrtOA4nIo3JzH6vdh3tPg0xAe2QBOWjulLsrMK2TNvpMs32OGnd2pWWXONw3wZFDrYAa1CqJdo3oaqyMi1UrdUuVQuDmPwjyY3gEyk2Hoa9B1rK0rEjtwJD2XRdtTWbDtKKv2Hqew+MxfFYHergxoFcSgVkF0b+qPq5O2iRCRqlVt4aawsJCUlBRycnIICAjAz8/vYt+q2ijc/IW4/8IvT4BXMDyaAM7utq5I7EhGXiFLdx5jwdYUlu48RlZ+kfWcr7szI9qFcn2nRrRt5Kt1dUSkSlRpuMnKyuKLL77gq6++Yu3ateTn52MYBhaLhUaNGjFo0CDuvfdeunTpcknfRFVRuPkLRfnwdidIPwiDJ0P3cbauSOxUflExq/edZMHWFBZsO8qxzDPbREQFenFdp0Zc26EhQT5uNqxSRGqbKgs3b7zxBi+//DJNmjRhxIgRdO3alYYNG+Lu7s7JkyfZsmULy5YtY86cOVx22WW8/fbbREVFXfI3VJkUbsoR/wn89Ch4BsCjG80NNkXKUVxisHLvcb6LP8S8LSnWdXUcLNAnOoDrOzViQMsg7W4uIpesysLNqFGjeP7554mJiSn3uvz8fD766CNcXFy45557Kvr21ULhphzFhWbrzan9MPBF6GkfM9ykZsjIK+SXTUeYHX+IdfvTrMd93Jy4un1DbuseTnSQtw0rFJGaTAOKy6Fw8zc2fAE/jgMPf7P1xlW/jOTCJR7PZnb8Ib5ff4jk9Dzr8e6R/tzePZyBrYJwcnSwYYUiUtPYJNzMnDmTu+66qzLeqkop3PyN4iJ4twuc3Af9n4feT9i6IqnBSkoMVuw9zuer97Nw21FKl9EJ8XXjlm6NubFLYwK8tfSAiPy9C/n9XWn/dPr+++9ZsmSJ9Xlubi633HLLBb/P4cOHufXWW/H398fDw4P27dsTHx9vPW8YBhMmTCA0NBR3d3f69evH1q1bK+V7EMDRCfqe3kRzxXTIy7BtPVKjOThY6B0VwIzbOrPs6St48PKm+Hu6cCQ9j9cW7KLHK4sY//UG4venUccakUWkClVauPn888957rnn2LFjB7t376Z3797069fvgt4jLS2Nnj174uzszG+//ca2bdt4/fXXqVevnvWaqVOnMm3aNN555x3i4uIIDg5m4MCBZGZmVta3IjHXQ4NoyDsFa963dTVSSzSs586Tg1uw8tkreOPGdrQPq0dhscEPCclc995Krn53BXM3JlNUXPL3byYiUo5L7pZ6/PHHad++Pe3bt8fFxYXRo0djGAYff/wxHTp0uKD3euaZZ1ixYgXLli0773nDMAgNDWX8+PE8/fTTgDl4OSgoiClTpnDfffed85r8/Hzy889MVc3IyCAsLEzdUn9ny2z4bgy4+sL4TeBez9YVSS206dApPl21n7kbkyk4PdOqYT13xvSK4MYuYXi5Otm4QhGxF9XaLdW3b1/279/Piy++yKhRo9i/fz+hoaEsWLCAX3755YLea+7cuXTu3JlRo0YRGBhIhw4d+PDDD63nExMTSUlJYdCgQdZjrq6u9O3bl5UrV573PSdPnoyvr6/1ERYWdnHfaF3T6loIbAX56bDqXVtXI7VU20b1eG1UO1Y9cwWPDYjG39OFw6dyefHnbfSYvIgp83ZwNCPv799IROQslT5bKjc3ly1btrBp0ya2bNnCG2+8UeHXurmZi349/vjjjBo1irVr1zJ+/HhmzJjB7bffzsqVK+nZsyeHDx8mNDTU+rp7772X/fv3M3/+/HPeUy03l2DbXPjmNnDxNltvPOx/BWqp2fIKi/l+/WH+u2wf+45nA+DsaOHq9g0Z2zuS5sGavSdSV1XpbKnS1YirgouLC507dy7TCvPII48QFxfHqlWrrOEmOTmZkJAQ6zVjx47l4MGDzJs3728/Q7OlLkBJCXzQB1I2Q/tbYPh0c8CxSBUrKTFYtCOVD//Yx9qkk9bjfaMDuL9vUy6L9NM2DyJ1TJV2S3l5edGzZ08eeeQRZs2axZYtWygpqZwBgCEhIbRq1arMsZYtW3LgwAEAgoODAUhJSSlzTWpqKkFBQZVSg5zFwQH6v2B+nfAFfHEd5Jws/zUilcDBwcLAVkF8c3935ozrwbCYEBwsELvrGDd/uJpr/rOSeVtSKCnRDCsROdcFh5tXX32Vli1bsmzZMsaOHUu7du3w9vame/fuPPTQQ8ycOZONGzdeVDE9e/Zk586dZY7t2rWL8PBwACIiIggODmbhwoXW8wUFBcTGxtKjR4+L+kz5G1EDYdQn4OwB+5bCB/3MlhyRatKhcX3evaUjS/9xObddFo6rkwMbD57i/s/jGfBGLP+LO0B+UbGtyxQRO3JJY27y8/Nxd3fnn//8JydPnmT9+vVs2rSJ/Px8iosv/C+buLg4evTowcSJE7nhhhtYu3YtY8eO5YMPPrCumTNlyhQmT57MzJkziYqKYtKkSSxdupSdO3fi7f33/fHqlrpIR7fC16MhLQmc3OGad6HNdbauSuqg41n5fLIiiU9XJZGRZ+5OHuTjypieEYzu1hhvN2cbVygiVaFaVyh2cHAgISGBtm3bAlBcXMzWrVutzy/Uzz//zLPPPsvu3buJiIjg8ccfZ+zYsdbzhmEwceJEZsyYQVpaGt26dePdd9+lTZs2FXp/hZtLkHMSZt8Nexebz3s8AgMmgIM2RZTql5VfxFdrDvDf5fs4mmFOGvB2c+LWy8K5q0cTArUruUitYtNwY+8Ubi5RSTEs+jeseNN8Hnk5XP+xZlKJzeQXFfPjhmTe/2Mv+46ZM6xcHB24pkMo9/aJpFmgZliJ1AYKN+VQuKkkW76HHx+Ewhyo3wRu/AKCK9Z6JlIVSkoMFm4/ygd/7CP+rF3J+7cIZGyfSLpFaIaVSE1WpeFm7NixdOrUic6dOxMTE4O7uzsbN24kJibmkoquLgo3lShlizkO59R+c8DxiLfNrRtEbCx+/0lmxO5j4fajlP4N166RL/f2acqVbYJxdFDIEalpqjTc9OnTh40bN5KZmYmTkxNFRUWMHDmSfv360bFjR9q3b4+Hh8clfQNVSeGmkuWcNLdp2Hd609QuY2Hwy+CknZ7F9vYdy+K/yxP5Lv6QdXuHxn4e3N0rgus7NcJT2zuI1BjV0i21e/du4uPjWb9+PfHx8WzYsIFTp07h6OhIdHS03e7UrXBTBYqLYOkkWPa6+Ty0ozl9vH64TcsSKXU8K59PVybx6er9nMopBMzBxzd3bczt3cNpVN9+/0EmIqZqHXNztsTERNatW8eGDRuYNGlSZb1tpVK4qUK7FsCceyE3DdzqwbUzoPmVtq5KxCqnoIjv4g8xc0USiae3d3CwwJVtghnTM4JO4fU1LkfETlVZuDlw4ACNGzeucCGHDx+mYcOGFb6+OijcVLFTB+DbO+FwvPm812Nw+b+0bYPYlZISg6W7Uvl4eRLL9xy3Hm/byJcxPSMYGhOCi9Ml7yssIpWoyrZf6NKlC2PHjmXt2rV/eU16ejoffvghbdq04fvvv7+Qt5faoF5juGsedL3PfL78Dfj0ashMKf91ItXIwcHCFS2C+Pyebswb35ubuoTh4uTApkPpjP9fAr2mLOadxbs5kZX/928mInbnglpuTp48yaRJk/j4449xdnamc+fOhIaG4ubmRlpaGtu2bWPr1q107tyZf/3rXwwZMqQqa78oarmpRlvnwI8PQ0EmeAbC9R9BRB9bVyVyXiey8vlq7QE+XbWf1Ewz1Lg4OTCiXSh39mhCm4a+Nq5QpG6r8jE3eXl5/PrrryxbtoykpCRyc3Np0KABHTp0YPDgwRVeLdgWFG6q2fE98M3tkLoVLA5w+XPQ63FzU04RO1RQVMIvm5P5ZEUSGw+lW493Dq/PnT2bMLh1MM6O+vkVqW7VMqA4IyOjRoYDhRsbKMiBX5+EhM/N59FXwrXvg3t929Yl8jc2HEjjk5VJ/LLpCEWndyAP9nHjtu7h3NQlDH8vLXkgUl2qJdw4OjryzTffcN11NWvzRIUbG1r/KfzyDyjOh3rhcONnENLO1lWJ/K2jGXl8seYAX67Zz/GsAkBdViLVrVrCjYODA1dccQWZmZlYLBY6d+7MbbfdRrdu3S6q6OqicGNjRzbC/24zVzV2dIVhr0PH22xdlUiF5BcV88umI8xckcTmw+qyEqlO1RZu/P39uemmm/D09CQ+Pp5ly5bxwAMP8MYbb1xU4dVB4cYO5KbBnPth1zzzeYfbYOir4Oxu27pEKsgwDNYfOMWslUn8urlsl9WtlzXmpq6NaaAuK5FKVW3hZv78+QwcONB6bPPmzVxzzTWMGzeOJ5544mLetsop3NiJkhJYPg2WvAxGCQS3hRs+Bb8IW1cmckHOdFkd4PjpqeMujg4MP91lFdNIXVYilaFawk1AQADLli2jRYsWZY7/8ssvjB8/nt27d1/M21Y5hRs7s3cJzL4bck6Amy9c+4FWNZYaKb+omF83H+GTlfvZePCU9XjHxvW4s2cEQ9qoy0rkUlRLuBkwYAAdOnTg1VdfLXN8586dtGvXjry8vIt52yqncGOH0g/Dt3fAoTjzee8nzCnjDo62rUvkIm04kMaslUn8svkIhcXmX7GB3q7c0i2c0d0aE+CtLiuRC1Ut4Wb16tVcfvnlXHvttYwbN462bduSm5vLU089xdq1a9m+fftFFV/VFG7sVFEBLPgXrJ1hPo/sB9d9BJ4NbFqWyKVIzczjqzUH+XzNfo6dXhjQ2dHCVW1DuaNHE9qH1bNtgSI1SLVtnLlx40YeffRRli9fTunbuLm58e233zJ06NCLfdsqpXBj5zZ/B3MfhsIc8GkEN8yCRp1tXZXIJSkoKuG3LUeYtTKJ9QdOWY+3C6vHnT3CGRoTgquTWipFylPtu4KnpqYSHx9PSUkJ3bp1o0ED+/3XtsJNDZC6Hf53K5zYAw7OcOVk6HIPaLdmqQU2HTrFJyuT+HnjEQqKSwBo4OXK6K5hjO4WTrCvm40rFLFP1R5uahKFmxoiLwN+HAfbfzKft70RrnoTXDxsWpZIZTmelc9Xaw7w+Zr9HM0wu6wcHSxc2TqY27qH0y3CD4sCvYiVwk05FG5qEMOAVe/AwhfAKIbA1uaqxv5NbV2ZSKUpLC5hwdajzFqVxNrEk9bjzYO8ub1HONe0b4inq5MNKxSxD1UWbiIiIi7qXxLjx4/nkUceueDXVQWFmxooaTl8exdkp4Krj7kvVYthtq5KpNJtP5LBp6v288OGw+QWFgPg7ebEqE5h3NY9nIgGnjauUMR2qizcxMbGXlRBTZo0ITw8/KJeW9kUbmqojCPw7Z1wcLX5vNdjcMX/abq41ErpuYV8F3+Iz1YlkXQix3q8d1QDbukWzoCWgThpzRypY9QtVQ6FmxqsuBAWPg+r/2M+j+wH130Mnv42LUukqpSUGPyx+xizViaxdNcxSv+2DvZx46auYdzUpbEGIEudoXBTDoWbWmDLbPjxYSjMBt8wc7p4w062rkqkSh08mcOXaw/wTdxBTmSbO5M7OlgY2DKIWy8Lp0dTfxwcNABZai+NuSmHwk0tkbodvr4FTu4FRxcY+hp0usPWVYlUufyiYuZtSeGL1QdYm3RmAHJEA09u6daYkR0b4efpYsMKRaqGxtyUQ+GmFslLhzkPwM5fzOcdb4chr4KzmumlbtiZkskXa/bz/frDZOUXAeamnYNaB3Fz18Z0j1RrjtQe6pYqh8JNLVO6u/jilwADQjvADZ9BvTBbVyZSbbLzi/gxIZmv1h5g8+F06/HGfh7c2CWMUZ0aEeij0C81m8JNORRuaqk9v8PseyA3DTz84fqPzQHHInXMlsPpfB13gB83JJN5ujXH0cHCFS0CublrGH2jA3FUa47UQAo35VC4qcXS9pvbNqRsAosD9H8eeo7Xtg1SJ+UWFPPL5iN8vfYA6/anWY8H+7gxsmNDru/UiMgALxtWKHJhFG7KoXBTyxXmwi9PQMIX5vMWV8E174Gb/ltL3bX7aCb/izvI7PWHSMsptB7vFF6fUZ0aMaxtCN5uzjasUOTvKdyUQ+GmDjAMWPcx/PY0lBSCfxTc+DkEtrB1ZSI2lV9UzKLtqXwXf4ilO1MpOf23v5uzA0PahHB9p0YahCx2S+GmHAo3dcihdfC/2yAzGZw94Zp3ofW1tq5KxC6kZuQxZ8Nhvo0/xJ7ULOvxhvXcua5jQ67t2EjbPYhdUbgph8JNHZN1DL67C5KWmc97PAz9J4CjNiIUATAMg4SDp/gu/hBzNyaTmVdkPdc+rB4jOzbkqrahWjtHbE7hphwKN3VQcREsmggrp5vPm/SG62eCV4Bt6xKxM3mFxczfmsL36w+zbPcxa7eVk4OFfs0DGdmxIVe0CMTNWXu6SfVTuCmHwk0dtvUH+PFBKMgC71C44VMI62LrqkTsUmpmHj9tPMKcDYfYcjjDetzbzYlhMSFc26EhXZr4aXyOVBuFm3Io3NRxx3aa2zac2A0OzjBkCnQeo+niIuXYfTST7zcc5scNh0lOz7Meb1jPneHtQrm6fSgtQ/T3qVQthZtyKNwIeRlmC872uebzdjfDsGng4mHbukTsXEmJwerEE8xZf5h5W1KsiwQCNA/yZkT7UEa0CyXMT/8vSeVTuCmHwo0A5nTxFW+ZY3GMEgiKgRs/Bb9IW1cmUiPkFRazZEcqPyQcZsmOYxQUl1jPdQ6vz9XtQxmmgchSiRRuyqFwI2Uk/gHf3gU5x8HVF0Z+AM2vtHVVIjVKem4h87Yc4ceEZFbtO4Fx1kDkXlENGNEulEGtg/Fy1SxFuXgKN+VQuJFzpB+Gb++AQ3Hm8z5PQr9nwUEzQkQu1NGMPH7amMwPCYfLDER2dXKgf8tARrQLpV9zzbiSC6dwUw6FGzmvogJY8Bys/cB83vQKuO4j8PCzbV0iNdjeY1n8tDGZuRuT2Xcs23rc29WJQa2DGdE+lJ5N/XFydLBhlVJTXMjvb7v6iZowYQIWi6XMIzg42HreMAwmTJhAaGgo7u7u9OvXj61bt9qwYqk1nFxg6Ksw8kNwcoe9i2FGXzi83taVidRYTQO8GD8gmkWP9+Xnh3txb59IQnzdyMwvYvb6Q9zx8Vq6TVrE//2whbikk5SU1Kl/a0sVsquWmwkTJvDdd9/x+++/W485OjoSEGAutjZlyhRefvllPvnkE6Kjo3nppZf4448/2LlzJ97e3hX6DLXcyN9K2QLf3AYn94Hj6dDT8Q5NFxepBCUlBuv2pzF342F+3ZzCyewC67lQXzeGtwtleLtQWof6YNH/c3KWGtstNWHCBH744QcSEhLOOWcYBqGhoYwfP56nn34agPz8fIKCgpgyZQr33XdfhT5D4UYqJPcU/DAOdv5iPm93Mwx7HVy0145IZSksLmHFnuPM3ZjMgq1HyTpranlkA09r0GkW6GXDKsVe1NhuKYDdu3cTGhpKREQEN910E/v27QMgMTGRlJQUBg0aZL3W1dWVvn37snLlyr98v/z8fDIyMso8RP6Wez1zJ/H+L4DFATZ+Bf8dAMd327oykVrD2dGBfs0DmXZDe9b9awDv39qRoTHBuDo5sO94Nm8t2s2AabEMfWsZ78fu5fCpXFuXLDWEXbXc/Pbbb+Tk5BAdHc3Ro0d56aWX2LFjB1u3bmXnzp307NmTw4cPExoaan3Nvffey/79+5k/f/5533PChAlMnDjxnONquZEKS1wG342B7FRw8YIRb0ObkbauSqTWyswr5PftR5mbkMyy3ccpOmssTufw+oxoH8rQmBAaeLnasEqpbjW2W+rPsrOzadq0KU899RSXXXYZPXv2JDk5mZCQEOs1Y8eO5eDBg8ybN++875Gfn09+fr71eUZGBmFhYQo3cmEyU+C7u2H/cvN51/tg0EvmQGQRqTJp2QX8tiWFHxMOszbppHUNHUcHCz2a+jOiXSiD2wTj4+Zs20KlytWacAMwcOBAmjVrxpNPPknTpk1Zv349HTp0sJ6/+uqrqVevHrNmzarQ+2nMjVy04iJY8jIsn2Y+b9gZRn0C9cJsWpZIXZGSnsfPm8yp5ZsOpVuPuzg5cHnzAK5ur13La7MaPebmbPn5+Wzfvp2QkBAiIiIIDg5m4cKF1vMFBQXExsbSo0cPG1YpdYajEwx4AW7+H7jVg8PrYEZv2L3wb18qIpcu2NeNe3pHMvehXiz5Rz8eHxhNs0AvCopKmL/1KOO+WE/nl37n8W8SWLozlaKztoSQusWuWm7+8Y9/MHz4cBo3bkxqaiovvfQSsbGxbN68mfDwcKZMmcLkyZOZOXMmUVFRTJo0iaVLl2oquFS/tP3mqsbJG8znvf9hrmrsqOXlRaqTYRhsP5LJ3I3J/LQxucygY39PF4bGhHB1+1A6Nq6Pg4OmltdkNbZb6qabbuKPP/7g+PHjBAQEcNlll/Hiiy/SqlUrwPwhnjhxIjNmzCAtLY1u3brx7rvv0qZNmwp/hsKNVJqifJj/T4j7r/m8cQ+47r/g29C2dYnUUSUlBusPpPFjQjK/bD5SZg2dhvXcuapdCFe3a0jLEG+toVMD1dhwUx0UbqTSbf4OfhoPBZng7gfXvg/Rg21dlUiddvYaOvO3pJBdUGw9FxXoxdXtQxnRriGN/T1sWKVcCIWbcijcSJU4sRe+uwuObDSf93gYrnhes6lE7EBeYTGLd6QyNyGZxTtSKThrLE6HxvUY0S6UYW1DCPR2s2GV8ncUbsqhcCNVpigfFj4Pa943nzfsDNd/DPXDbVuXiFil5xYyf2sKcxOSWbn3OKVL6DhYoGezBppabscUbsqhcCNVbvvP8OM4yEsHN18Y8Q60GmHrqkTkT1Iz8/hl0xF+TEgm4eAp63EXJweuaB7IiPahmlpuRxRuyqFwI9Xi1AFzVeNDcebzrvfCwBfBWc3eIvZo/4ls5iYk8+PGZPakZlmPe7k6Mah1EFe3b0jPpv44Odr1Ciq1msJNORRupNoUF8Kif8PK6ebz4Bi47iMIaG7bukTkL/3d1PJhbUMY0U5Ty21B4aYcCjdS7XYvhDn3Qc4JcHKHwS9D5zGgqagidq0iU8uHtw2ldaiPppZXA4WbcijciE1kpsCc+2HfEvN582HmBpye/ratS0QqxDq1PCGZ+VvLTi2PDPBkRLtQhrcLpWmAlw2rrN0UbsqhcCM2U1ICa96D3ydAcQF4BZlr4jS9wtaVicgFyCssZsmOVOZuTGbRjlQKis5MLW8d6sOIdqFc1S6UhvXcbVhl7aNwUw6FG7G5I5tg9j1wfKf5vPtD0P95cHK1bV0icsEy8wpZuO0oP21MZtnu4xSVnPmV2im8Ple1DWFoTAhBPppMcKkUbsqhcCN2oSAHFvwL1n1kPtdgY5Ea72R2Ab9tOcJPG5NZk3iS0t+uFgt0beLHVe1CGdImmAZe+ofMxVC4KYfCjdiVnb/Bjw+eGWw86EXoco8GG4vUcEcz8vh1sxl01h84ZT3uYIEeTRtwVdsQrmwTTD0PrWJeUQo35VC4EbuTmQI/PAB7F5vPIy+Hq98B30a2rUtEKsXhU7n8simZnzcdYdOhdOtxJwcLPZs1YFhMCINaByno/A2Fm3Io3IhdKimBtR/A7y9AUR64+sKQKdDuJrXiiNQi+09k8/OmI/y86Qjbj2RYjzs5WOjRrAHDYoIZ1CqY+p4KOn+mcFMOhRuxa8d3m1PGD68zn7e4Cq56A7wCbVuXiFS6fcey+HXzEX7ZnFIm6Dg6WOjR1J9hMSEMbq2gU0rhphwKN2L3iovMVY2XTIKSQvDwh2HToPU1tq5MRKrIvmNZ/LYlhV82HWHbn4LOZZF+XNkmhMGtg+r0zuUKN+VQuJEaI2WL2YpzdLP5PGYUDJkKHn62rUtEqlTi8WyzRedPQcdigU6N63Nlm2CubBNMo/oeNqyy+inclEPhRmqUogL4YyosmwZGMXgFw4jpED3Y1pWJSDVIOp7N/K0p/LYlpczO5QAxDX2tQacurIyscFMOhRupkQ7Fww/3w/Fd5vOYUXDlK+DZwLZ1iUi1ST6Vy4LTQScu6SRnrRdIVKAXA1sFMah1MG0b+tbKTT0VbsqhcCM1VmEuLH4JVv8HjBJzLM6Vr5hBRzOqROqU41n5LNx2lN+2pLByT9mVkYN8XM2g0yqYyyL9cXFysGGllUfhphwKN1LjHY6HuY/A0S3m82YDzRlV9cJsW5eI2ER6biFLd6ayYNtRlu5ILbOpp7erE5e3CGRgqyD6Ng/Ax83ZhpVeGoWbcijcSK1QXAgr3oTYqeYmnC5e0P8Fc3Vjh9rxrzQRuXD5RcWs3HuCBVuPsnDbUY5n5VvPOTlY6Bbpx4CWQQxoGUSYX80akKxwUw6FG6lVju2Cnx6BA6vM5426woi3IbCFbesSEZsrKTHYcPAUC7alsHDrUfYdzy5zPjrIi/4tgxjQMpD2YfVxtPNxOgo35VC4kVqnpMTcgPP3CVCQBY4u0PsJ6DkenOvumhgiUta+Y1ks2p7K79uPsm5/GsVnjdPx93ShX/NA+rcMpFdUA7vsvlK4KYfCjdRa6Yfg58dh93zzuV8kDHkVogbYti4RsTuncgqI3XWMhduOErvrGJl5RdZzTg4WOjepz+XNA7miRSDNAr2w2MGkBYWbcijcSK1mGLB1Dsx7FrJSzGMtR8CVk7URp4icV2FxCXGJJ1m0I5UlO1PZd6xs91Wj+u5c3jyQy1sE0D2yAe4ujjapU+GmHAo3UifkZcDSV2DN++bif86e0O9puGwcONpfc7OI2I+k49ks3ZnK4p3HWL3vBAVFJdZzrk4OdIv0p290AH2jA2ga4FltrToKN+VQuJE6JWUL/PIEHFxtPg9oCcNehyY9bVuXiNQIOQVFrNp7gsU7UlmyI5Xk9Lwy5xvWc6fP6aDTo5l/lY7VUbgph8KN1DklJbDxK1j4f5BzwjzW9iYY9KJ2GxeRCjMMg92pWfyx6xixu46xZt9JCorPtOo4Oljo1Lg+fZsH0L9lIC2CK/d3rMJNORRupM7KOQmLX4R1MwEDXH2gz5PQ7T5wcrV1dSJSw+QUFLFm30lidx3jj13Hykw1v6VbY16+NqZSP0/hphwKN1LnHY43u6qSN5jP60fA4Jeh+VBt4yAiF+3AiRxid5tBZ3S3xlzevHJbhhVuyqFwI4LZVbXpa/h94plZVRF9zVlVQa1tW5uIyHlcyO9vrdMuUhc5OED70fBwvLngn6MrJMbC+73g58cg+7itKxQRuWgKNyJ1masX9H8eHoqDVteYu42v+ximd4SV70BRga0rFBG5YAo3IgL1w+GGWXDnrxDcFvLTYcFz8G5X2PK92Y0lIlJDKNyIyBlNesK9S2HEO+AZCGmJ8N1d8N8rYF+srasTEakQhRsRKcvBETreBo9sgH7/BBcvc2bVpyPgs5FwZJOtKxQRKZfCjYicn6uXuWXDIwnQ9T5wcIa9i2BGb5g9FtKSbF2hiMh5KdyISPm8AmDoVHhoLbS53jy2+Rt4uzP89rRmVomI3VG4EZGK8YuE6z+Ce2Oh6RVQUmhuzPlWO1j0b3MFZBERO6BwIyIXJrQ93DYHbvsBQtpDQRYsex3ebAtLJkHuKdvWJyJ1nsKNiFycppebM6tu/AKC2kBBJsROMUNO7FTIy7B1hSJSRynciMjFs1ig5VVw3zIYNQsCWphr5Cx5Gd5qa7bo5GfZukoRqWO0t5SIVJ6SYtg6B5a+Aid2m8c8/KHHI9DlbnD1tm19IlJj1Yq9pSZPnozFYmH8+PHWY4ZhMGHCBEJDQ3F3d6dfv35s3brVdkWKSFkOjhBzPTy4Bq79wByEnHMCfn8B3mgDSyZr4LGIVDm7DDdxcXF88MEHtG3btszxqVOnMm3aNN555x3i4uIIDg5m4MCBZGZm2qhSETkvB0dodyM8GAdX/wf8m0HeKYh9Bd6MgQX/B5lHbV2liNRSdhdusrKyuOWWW/jwww+pX7++9bhhGLz55ps899xzjBw5kjZt2jBr1ixycnL48ssvbVixiPwlRyfocAs8uBaunwlBMebsqpXTzZDzyxNw6oCtqxSRWsbuws2DDz7IsGHDGDBgQJnjiYmJpKSkMGjQIOsxV1dX+vbty8qVK//y/fLz88nIyCjzEJFq5uAIbUbC/cvg5v9Boy5QnA9x/4XpHeCHcXBsl62rFJFawq7Czddff8369euZPHnyOedSUlIACAoKKnM8KCjIeu58Jk+ejK+vr/URFhZWuUWLSMVZLND8Srh7Idw+FyL6QkkRJHxh7kD+1WjYvwrq1jwHEalkdhNuDh48yKOPPsrnn3+Om5vbX15nsVjKPDcM45xjZ3v22WdJT0+3Pg4ePFhpNYvIRbJYILIv3DEX7v4dmg8FDNj5C8y8Ev47ALb+YM6+EhG5QHYTbuLj40lNTaVTp044OTnh5OREbGws06dPx8nJydpi8+dWmtTU1HNac87m6uqKj49PmYeI2JGwLnDzV+bg4453gKMrHF4H394Bb3eENR9AQbatqxSRGsRuwk3//v3ZvHkzCQkJ1kfnzp255ZZbSEhIIDIykuDgYBYuXGh9TUFBAbGxsfTo0cOGlYtIpQiIhhHT4bEt0OcpcK9v7jz+25PwRmtY/JJmWIlIhTjZuoBS3t7etGnTpswxT09P/P39rcfHjx/PpEmTiIqKIioqikmTJuHh4cHo0aNtUbKIVAWvQLjiOeg1HhK+hFXvQloi/PEqrHgLWo+EbvdBw462rlRE7JTdhJuKeOqpp8jNzWXcuHGkpaXRrVs3FixYgLe3Vj0VqXVcPKHrWOg8Bnb8AivfhkNrYdPX5qNRVzPktLoaHJ1tXa2I2BFtvyAiNceheFg7A7Z8DyWF5jHvEOh8N3S+Czwb2LY+EakyF/L7W+FGRGqezKMQPxPiPoLsVPOYoyu0uQ663QuhHWxbn4hUOoWbcijciNQiRQWw7QdY/R4krz9zPLSjuVFn65Hg4mGz8kSk8ijclEPhRqSWOrQO1rx/en2c011Wbr7QbrTZZRXQ3KblicilUbgph8KNSC2XdQwSPod1M+HU/jPHm/Q2Q06L4eDkYrv6ROSiKNyUQ+FGpI4oKYG9i2Hdx7DrNzBKzOOeAdDhVuhwG/g3tW2NIlJhCjflULgRqYPSD8H6TyF+FmSdtcp5eC/oeDu0GgHO7rarT0T+lsJNORRuROqw4kLY+ZsZdPb8Dpz+68/VF2KuN4NOaHtbVigif0HhphwKNyICmK05CV/C+s8g/cCZ48Ex0OF2aDvK3AJCROyCwk05FG5EpIySEkiMhQ2fwfafoLjAPO7oCs2HQPvR0LQ/ONaoBd1Fah2Fm3Io3IjIX8o5CZu+MbutUreeOe4ZCG1vgHY3mS07IlLtFG7KoXAjIn/LMCBlEyR8BZu/hZzjZ84FxUD7myFmlLnJp4hUC4WbcijciMgFKS40Bx8nfAm75p3ptrI4QrP+EHMDtBhqbvQpIlVG4aYcCjcictFyTsLW780WncPrzhx39oQWw8zWnKaXa5dykSqgcFMOhRsRqRTHd5vjczZ/C2mJZ457+EPra80WnbCuYLHYrkaRWkThphwKNyJSqQwDDsebIWfLbMg+duZcvcbQ5npoMxKC2ijoiFwChZtyKNyISJUpLoLEpbD5O3NaeUHWmXP+UWaLTpuRENjSZiWK1FQKN+VQuBGRalGQY+5pteV72L0QivPPnAtoAa1HmmEnINp2NYrUIAo35VC4EZFql59pbvuwdY4586p0xhWY3VWtr4GWVyvoiJRD4aYcCjciYlO5p04Hne/NXctLis6ca9Dc3MSz5QhzsUCN0RGxUrgph8KNiNiNnJOw4xfY9iPsWwolhWfO1Y+AlsOh1dXQsJOCjtR5CjflULgREbuUewp2zYftc82uq6K8M+d8GppBp8UwaNxD+1xJnaRwUw6FGxGxe/lZsGchbJsLuxeUnXXlXh+iBptBp1l/rYwsdYbCTTkUbkSkRinMhb1LYMfP5lid3JNnzjm6misitxgG0UPAK8B2dYpUMYWbcijciEiNVVwEB9eY43R2/Ayn9p910mKuiBx9JTQfYk431zgdqUUUbsqhcCMitYJhQOq200HnFziSUPZ8vfDTQedKCO8JTq42KVOksijclEPhRkRqpfRD5q7lO+dB4h9lFw108YKmV5hhJ2qQuq+kRlK4KYfCjYjUegXZ5tTyXfPMGVhZR886aYGGHaHZQDPohHYABwdbVSpSYQo35VC4EZE6paTE7LLaNd/cDuLIxrLnPfyh2QAz6DS9Ajz8bFKmyN9RuCmHwo2I1GmZKeY6OrsXmLOw8jPOnLM4QMPOEDUQmvaH0Pbg4GizUkXOpnBTDoUbEZHTigvh4Foz6Oz5HY5uKXvevT5EXm626DTrDz6htqlTBIWbcinciIj8hfTD5uKBe36HfX9AfnrZ8wEtzZDT9HJzBpazu23qlDpJ4aYcCjciIhVQXASH18GeRbB3ERxeD5z168LJDRpfBpH9zNad4LYamCxVSuGmHAo3IiIXIeekOQNr7yLYsxgyk8ued/eDiD5mq05kP6jfxAZFSm2mcFMOhRsRkUtkGHB8lzkged9SSFoOBZllr6kfYYaciD7QpLfW1pFLpnBTDoUbEZFKVlwIh+PNoLNvKRyKg5KistcEtjaDTkQfCO8B7vVsUKjUZAo35VC4ERGpYvmZZmtO4h/m48+zsCwOENL+dNjpDWGXgauXTUqVmkPhphwKNyIi1Sz7OCQtOx12lsGJ3WXPOziZKyWH9zS7sBp3A1dv29QqdkvhphwKNyIiNpaRbIacxFgz9Jw6UPa8xdFcQNAadi4DN/19Xdcp3JRD4UZExM6k7Yf9KyBpxemws7/seYsDBMeYYadxd3PMjmcD29QqNqNwUw6FGxERO3fq4Omws8wcu5OWdO41DZpDePczgadeWLWXKdVL4aYcCjciIjVM+mE4sMoMPPtXwbHt517j29gcq9P4MnOAcmBL7YtVyyjclEPhRkSkhss5eTrsrDQfRzaCUVz2GldfCOtiBp3Gl0HDTuDiYZt6pVIo3JRD4UZEpJbJzzLX1jm4xgw9h9ZBQVbZaxyczC0iwrpBWFfz4dvINvXKRamx4ea9997jvffeIykpCYDWrVvz/PPPM2TIEAAMw2DixIl88MEHpKWl0a1bN959911at25d4c9QuBERqeWKi8y1dQ6ugQOrzceft4sA8GlohpxGXc3QExwDTi7VX69USI0NNz/99BOOjo40a9YMgFmzZvHqq6+yYcMGWrduzZQpU3j55Zf55JNPiI6O5qWXXuKPP/5g586deHtXbE0EhRsRkTrGMCD9IBxYA4fWmqEnZcu5XVlObuZ6O406Q8PO0KgL+Da0Tc1yjhobbs7Hz8+PV199lTFjxhAaGsr48eN5+umnAcjPzycoKIgpU6Zw3333Vej9FG5ERISCbHOn84NrznRp5aade513qBl2Gp0OOyHtNXbHRi7k97dTNdV0wYqLi/n222/Jzs6me/fuJCYmkpKSwqBBg6zXuLq60rdvX1auXPmX4SY/P5/8/Hzr84yMjCqvXURE7JyLp7n1Q0Rv87lhwIk9cHAtHF5nBp6j28zurO1zzQeYCwwGtTbDTmhHc6ByQHPNzLIzdhduNm/eTPfu3cnLy8PLy4s5c+bQqlUrVq5cCUBQUFCZ64OCgti/f//53gqAyZMnM3HixCqtWUREajiLBRpEmY8Ot5jHCrIhOeFM2Dm0DjKPQMom88HH5nUuXmaLTsPTYadhJ3OwssVio29G7C7cNG/enISEBE6dOsXs2bO54447iI2NtZ63/OmHxTCMc46d7dlnn+Xxxx+3Ps/IyCAsTIs9iYjI33DxhCY9zUep9MNm0Eleb3ZrJW8wZ2btX24+SnkGmuN3QjuYoSe0A3gFVv/3UEfZXbhxcXGxDiju3LkzcXFxvPXWW9ZxNikpKYSEhFivT01NPac152yurq64urpWbdEiIlI3+DY0H62vMZ+XFMPxXXA4/szj6FbIToXd881HKZ+GZwJP6cPDzybfRm1nd+HmzwzDID8/n4iICIKDg1m4cCEdOnQAoKCggNjYWKZMmWLjKkVEpE5ycDRXQw5sCR1uNY8V5kLKZrNLK/l0686xnZBx2Hzs+PnM6+s1Nru0QtqZm4WGtNe+WZXArsLNP//5T4YMGUJYWBiZmZl8/fXXLF26lHnz5mGxWBg/fjyTJk0iKiqKqKgoJk2ahIeHB6NHj7Z16SIiIiZn9zMLBZbKzzLH6SRvONOddXKvuSP6qQNnBiwD+DQ6HXTanQ4+bcE7uLq/ixrNrsLN0aNHue222zhy5Ai+vr60bduWefPmMXDgQACeeuopcnNzGTdunHURvwULFlR4jRsRERGbcPUydzMP73HmWO4pM/Ac2Wi28hxJMGdsZRwyH2e38HgGmiEnuO3p0NMW6kdo0PJfsPt1biqb1rkRERG7lZdhdmkdSTgdeDbCid1glJx7rauPuapycNvTf8ZAQItau8pyrVrEr7Ip3IiISI1SkG2uuZOy0Qw7RzZB6jYoLjj3Wgdnc92d0rATHANBbWrFwGWFm3Io3IiISI1XXGgOUk7ZZIado1vMr/PSz3+9T0Mz5AS1huA25td+TcHRrkanlEvhphwKNyIiUiuV7qGVssXs2krZZP556i8WunVyM7uxSkNP6cNOZ2sp3JRD4UZEROqUvHRz7Z2jW80WnqNbzW6uwuzzX+8ZCEGtzNAT2Mr8OqCFOQvMhhRuyqFwIyIidV5JCaQl/in0bIG0pPNfb3EAv0gz7AS2OrO2TzV2bSnclEPhRkRE5C/kZ8GxHWbgSd125s+cE+e/3tEFGkSbQSegxZngUy8cHBwqtbRasSu4iIiIVDNXL3PH80adzxwzDMhKhdTT3VnHtkPqdkjdYXZtlbb6nK3TnTD8rWot/WwKNyIiIvLXLBbwDjIfTa84c7ykxBzAnLrdbN1JPR16ju+CBs1tVy8KNyIiInIxHBygfrj5aH7lmePFRVBSaLu6ULgRERGRyuToZPP1cyp3tI+IiIiIjSnciIiISK2icCMiIiK1isKNiIiI1CoKNyIiIlKrKNyIiIhIraJwIyIiIrWKwo2IiIjUKgo3IiIiUqso3IiIiEitonAjIiIitYrCjYiIiNQqCjciIiJSq9S5XcENwwAgIyPDxpWIiIhIRZX+3i79PV6eOhduMjMzAQgLC7NxJSIiInKhMjMz8fX1Lfcai1GRCFSLlJSUkJycjLe3NxaLpVLfOyMjg7CwMA4ePIiPj0+lvrecoftcPXSfq4fuc/XQfa4eVXmfDcMgMzOT0NBQHBzKH1VT51puHBwcaNSoUZV+ho+Pj/7nqQa6z9VD97l66D5XD93n6lFV9/nvWmxKaUCxiIiI1CoKNyIiIlKrKNxUIldXV1544QVcXV1tXUqtpvtcPXSfq4fuc/XQfa4e9nKf69yAYhEREand1HIjIiIitYrCjYiIiNQqCjciIiJSqyjciIiISK2icFNJ/vOf/xAREYGbmxudOnVi2bJlti6pRvvjjz8YPnw4oaGhWCwWfvjhhzLnDcNgwoQJhIaG4u7uTr9+/di6dattiq3BJk+eTJcuXfD29iYwMJBrrrmGnTt3lrlG9/rSvffee7Rt29a6sFn37t357bffrOd1j6vG5MmTsVgsjB8/3npM97pyTJgwAYvFUuYRHBxsPW/r+6xwUwn+97//MX78eJ577jk2bNhA7969GTJkCAcOHLB1aTVWdnY27dq145133jnv+alTpzJt2jTeeecd4uLiCA4OZuDAgda9w6RiYmNjefDBB1m9ejULFy6kqKiIQYMGkZ2dbb1G9/rSNWrUiFdeeYV169axbt06rrjiCq6++mrrX/a6x5UvLi6ODz74gLZt25Y5rntdeVq3bs2RI0esj82bN1vP2fw+G3LJunbtatx///1ljrVo0cJ45plnbFRR7QIYc+bMsT4vKSkxgoODjVdeecV6LC8vz/D19TXef/99G1RYe6SmphqAERsbaxiG7nVVql+/vvHf//5X97gKZGZmGlFRUcbChQuNvn37Go8++qhhGPp5rkwvvPCC0a5du/Oes4f7rJabS1RQUEB8fDyDBg0qc3zQoEGsXLnSRlXVbomJiaSkpJS5566urvTt21f3/BKlp6cD4OfnB+heV4Xi4mK+/vprsrOz6d69u+5xFXjwwQcZNmwYAwYMKHNc97py7d69m9DQUCIiIrjpppvYt28fYB/3uc5tnFnZjh8/TnFxMUFBQWWOBwUFkZKSYqOqarfS+3q+e75//35blFQrGIbB448/Tq9evWjTpg2ge12ZNm/eTPfu3cnLy8PLy4s5c+bQqlUr61/2useV4+uvv2b9+vXExcWdc04/z5WnW7dufPrpp0RHR3P06FFeeuklevTowdatW+3iPivcVBKLxVLmuWEY5xyTyqV7XrkeeughNm3axPLly885p3t96Zo3b05CQgKnTp1i9uzZ3HHHHcTGxlrP6x5fuoMHD/Loo4+yYMEC3Nzc/vI63etLN2TIEOvXMTExdO/enaZNmzJr1iwuu+wywLb3Wd1Sl6hBgwY4Ojqe00qTmpp6TmqVylE6Il/3vPI8/PDDzJ07lyVLltCoUSPrcd3ryuPi4kKzZs3o3LkzkydPpl27drz11lu6x5UoPj6e1NRUOnXqhJOTE05OTsTGxjJ9+nScnJys91P3uvJ5enoSExPD7t277eJnWuHmErm4uNCpUycWLlxY5vjChQvp0aOHjaqq3SIiIggODi5zzwsKCoiNjdU9v0CGYfDQQw/x/fffs3jxYiIiIsqc172uOoZhkJ+fr3tcifr378/mzZtJSEiwPjp37swtt9xCQkICkZGRutdVJD8/n+3btxMSEmIfP9PVMmy5lvv6668NZ2dn46OPPjK2bdtmjB8/3vD09DSSkpJsXVqNlZmZaWzYsMHYsGGDARjTpk0zNmzYYOzfv98wDMN45ZVXDF9fX+P77783Nm/ebNx8881GSEiIkZGRYePKa5YHHnjA8PX1NZYuXWocOXLE+sjJybFeo3t96Z599lnjjz/+MBITE41NmzYZ//znPw0HBwdjwYIFhmHoHlels2dLGYbudWV54oknjKVLlxr79u0zVq9ebVx11VWGt7e39feere+zwk0leffdd43w8HDDxcXF6Nixo3UqrVycJUuWGMA5jzvuuMMwDHOq4QsvvGAEBwcbrq6uRp8+fYzNmzfbtuga6Hz3GDBmzpxpvUb3+tKNGTPG+vdDQECA0b9/f2uwMQzd46r053Cje105brzxRiMkJMRwdnY2QkNDjZEjRxpbt261nrf1fbYYhmFUTxuRiIiISNXTmBsRERGpVRRuREREpFZRuBEREZFaReFGREREahWFGxEREalVFG5ERESkVlG4ERERkVpF4UZERERqFYUbETmvfv36MX78eFuXYdfuvPNOrrnmGluXISJ/onAjUkfdeeedWCyWcx579uyxdWnn+OSTT6hXr571+YQJE2jfvn21fX5SUhIWi4WEhIQyx9966y0++eSTaqtDRCrGydYFiIjtXHnllcycObPMsYCAABtVU/0KCwtxdna+6Nf7+vpWYjUiUlnUciNSh7m6uhIcHFzm4ejoeN5r09LSuP3226lfvz4eHh4MGTKE3bt3A2AYBgEBAcyePdt6ffv27QkMDLQ+X7VqFc7OzmRlZQFm60vjxo1xdXUlNDSURx55pEI1f/LJJ0ycOJGNGzdaW5tKW0/S09O59957CQwMxMfHhyuuuIKNGzdaX1va4vPxxx8TGRmJq6srhmEwb948evXqRb169fD39+eqq65i79691tdFREQA0KFDBywWC/369QPO7ZbKz8/nkUceITAwEDc3N3r16kVcXJz1/NKlS7FYLCxatIjOnTvj4eFBjx492Llzp/WajRs3cvnll+Pt7Y2Pjw+dOnVi3bp1Fbo3ImJSuBGRCrnzzjtZt24dc+fOZdWqVRiGwdChQyksLMRisdCnTx+WLl0KmEFo27ZtFBYWsm3bNsD8xd6pUye8vLz47rvveOONN5gxYwa7d+/mhx9+ICYmpkJ13HjjjTzxxBO0bt2aI0eOcOTIEW688UYMw2DYsGGkpKTw66+/Eh8fT8eOHenfvz8nT560vn7Pnj188803zJ4929rNlJ2dzeOPP05cXByLFi3CwcGBa6+9lpKSEgDWrl0LwO+//86RI0f4/vvvz1vbU089xezZs5k1axbr16+nWbNmDB48uMznAzz33HO8/vrrrFu3DicnJ8aMGWM9d8stt9CoUSPi4uKIj4/nmWeeuaTWJZE6qdr2HxcRu3LHHXcYjo6Ohqenp/Vx/fXXW8/37dvXePTRRw3DMIxdu3YZgLFixQrr+ePHjxvu7u7GN998YxiGYUyfPt1o06aNYRiG8cMPPxidO3c2Ro4cabz77ruGYRjGoEGDjKefftowDMN4/fXXjejoaKOgoKBCtc6cOdPw9fW1Pn/hhReMdu3alblm0aJFho+Pj5GXl1fmeNOmTY0ZM2ZYX+fs7GykpqaW+3mpqakGYGzevNkwDMNITEw0AGPDhg1lrrvjjjuMq6++2jAMw8jKyjKcnZ2NL774wnq+oKDACA0NNaZOnWoYhmEsWbLEAIzff//des0vv/xiAEZubq5hGIbh7e1tfPLJJ+XfEBEpl1puROqwyy+/nISEBOtj+vTp571u+/btODk50a1bN+sxf39/mjdvzvbt2wFzdtXWrVs5fvw4sbGx9OvXj379+hEbG0tRURErV66kb9++AIwaNYrc3FwiIyMZO3Ysc+bMoaio6JK+l/j4eLKysvD398fLy8v6SExMLNPFFB4efs64or179zJ69GgiIyPx8fGxdkMdOHCgwp+/d+9eCgsL6dmzp/WYs7MzXbt2td6jUm3btrV+HRISAkBqaioAjz/+OPfccw8DBgzglVdeKVO7iFSMwo1IHebp6UmzZs2sj9JftH9mGMZfHrdYLAC0adMGf39/YmNjreGmb9++xMbGEhcXR25uLr169QIgLCyMnTt38u677+Lu7s64cePo06cPhYWFF/29lJSUEBISUiasJSQksHPnTp588sky3/OfDR8+nBMnTvDhhx+yZs0a1qxZA0BBQUGFP7/0HpXej7OP//nY2d1MpedKu8AmTJjA1q1bGTZsGIsXL6ZVq1bMmTOnwnWIiMKNiFRAq1atKCoqsv7SBzhx4gS7du2iZcuWANZxNz/++CNbtmyhd+/exMTEUFhYyPvvv0/Hjh3x9va2vt7d3Z0RI0Ywffp0li5dyqpVq9i8eXOF6nFxcaG4uLjMsY4dO5KSkoKTk1OZwNasWTMaNGjwl+914sQJtm/fzr/+9S/69+9Py5YtSUtLO+fzgHM+82zNmjXDxcWF5cuXW48VFhaybt066z2qqOjoaB577DEWLFjAyJEjz5nRJiLlU7gRkb8VFRXF1VdfzdixY1m+fDkbN27k1ltvpWHDhlx99dXW6/r168eXX35J27Zt8fHxsQaeL774wjrDCMwZTx999BFbtmxh3759fPbZZ7i7uxMeHl6hepo0aUJiYiIJCQkcP36c/Px8BgwYQPfu3bnmmmuYP38+SUlJrFy5kn/961/lzjaqX78+/v7+fPDBB+zZs4fFixfz+OOPl7kmMDAQd3d35s2bx9GjR0lPTz/nfTw9PXnggQd48sknmTdvHtu2bWPs2LHk5ORw9913V+j7ys3N5aGHHmLp0qXs37+fFStWEBcXd8HhSKSuU7gRkQqZOXMmnTp14qqrrqJ79+4YhsGvv/5apovl8ssvp7i4uEyQ6du3L8XFxdbxNgD16tXjww8/pGfPnrRt25ZFixbx008/4e/vX6FarrvuOq688kouv/xyAgIC+Oqrr7BYLPz666/06dOHMWPGEB0dzU033URSUhJBQUF/+V4ODg58/fXXxMfH06ZNGx577DFeffXVMtc4OTkxffp0ZsyYQWhoaJlAd7ZXXnmF6667jttuu42OHTuyZ88e5s+fT/369Sv0fTk6OnLixAluv/12oqOjueGGGxgyZAgTJ06s0OtFxGQx/qozXURERKQGUsuNiIiI1CoKNyIiIlKrKNyIiIhIraJwIyIiIrWKwo2IiIjUKgo3IiIiUqso3IiIiEitonAjIiIitYrCjYiIiNQqCjciIiJSqyjciIiISK3y/4kRI8oLsqEvAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "n_qubits = 7\n",
+    "d = d_poly_spacing(n_qubits,best_degree[2])\n",
+    "step = 1e-2\n",
+    "iterations = 50\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=n_qubits, h=h)\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "d_optimized, loss, grad, diags = gradient_ascent(dbi, d,step, iterations,analytic=False)\n",
+    "\n",
+    "flows = 50\n",
+    "off_diagonal_norm = np.empty((flows+1,2))\n",
+    "off_diagonal_norm[0,:] = dbi.off_diagonal_norm\n",
+    "for i in range(flows):\n",
+    "    step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d_optimized)\n",
+    "    dbi(step_poly,d=d_optimized)\n",
+    "    off_diagonal_norm[i+1,0] = dbi.off_diagonal_norm\n",
+    "\n",
+    "d = d_poly_spacing(n_qubits,1)\n",
+    "dbi2 = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "d_optimized, loss, grad, diags = gradient_ascent(dbi2, d,step, iterations,analytic=False)\n",
+    "for i in range(flows):\n",
+    "    step_poly = dbi2.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d_optimized)\n",
+    "    dbi2(step_poly,d=d_optimized)\n",
+    "    off_diagonal_norm[i+1,1] = dbi2.off_diagonal_norm\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(off_diagonal_norm[:,0],label= 'optimal poly degree')\n",
+    "plt.plot(off_diagonal_norm[:,1],label= 'linear spacing')\n",
+    "plt.xlabel('Flows Iterations')\n",
+    "plt.ylabel(r'$||\\sigma(H_k)||$')\n",
+    "plt.legend()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def delta_to_d(delta):\n",
+    "    d = np.empty(len(delta))\n",
+    "    d[0] = 0\n",
+    "    for i in range(len(d)-1):\n",
+    "        d[i+1] = d[i] + delta[i]\n",
+    "    return np.diag(d)\n",
+    "\n",
+    "def d_to_delta(d):\n",
+    "    delta = np.empty(len(d)-1)\n",
+    "    for i in range(len(d)-1):\n",
+    "        delta[i] = d[i+1,i+1]-d[i,i]\n",
+    "    return delta\n",
+    "\n",
+    "def polynomial(x,degree,coefficients):\n",
+    "    y = np.empty(len(x))\n",
+    "    for i in range(degree):\n",
+    "        y += coefficients[i]*x**i\n",
+    "    return y\n",
+    "\n",
+    "def gradient_delta_polynomial(dbi, degree, coefficients,h=1e-5):\n",
+    "    grad = np.empty(degree)\n",
+    "    dim = dbi.h.matrix.shape[0]\n",
+    "    delta = polynomial(np.linspace(0,1,dim),degree,coefficients)\n",
+    "    d = delta_to_d(delta)\n",
+    "    dbi_eval = deepcopy(dbi)\n",
+    "    angle = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d)\n",
+    "    dbi_eval(angle,d=d)\n",
+    "    norm = dbi_eval.off_diagonal_norm\n",
+    "    for i in range(len(grad)):\n",
+    "        new_coeff = np.copy(coefficients)\n",
+    "        new_coeff[i] += h\n",
+    "        new_delta = polynomial(np.linspace(0,1,dim),degree,new_coeff)\n",
+    "        new_d = delta_to_d(new_delta)\n",
+    "        dbi_eval = deepcopy(dbi)\n",
+    "        angle = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=new_d)\n",
+    "        dbi_eval(angle,d=new_d)\n",
+    "        new_norm = dbi_eval.off_diagonal_norm\n",
+    "        grad[i] = (new_norm-norm)/h\n",
+    "\n",
+    "    return grad\n",
+    "\n",
+    "\n",
+    "def optimize_poly(dbi, step, iterations, degree):\n",
+    "    coefficients = np.random.rand(degree)\n",
+    "    dim = dbi.h.matrix.shape[0]\n",
+    "    delta = polynomial(np.linspace(0,1,dim),degree,coefficients)\n",
+    "    d = delta_to_d(delta)\n",
+    "    loss = np.empty(iterations)\n",
+    "    grad = np.empty(degree)\n",
+    "    for i in range(iterations):\n",
+    "        dbi_eval = deepcopy(dbi)\n",
+    "        step_poly = dbi_eval.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation,d=d)\n",
+    "        dbi_eval(step_poly,d=d)\n",
+    "        loss[i] = dbi_eval.off_diagonal_norm\n",
+    "        grad = gradient_delta_polynomial(dbi_eval, degree, coefficients)\n",
+    "        coefficients -= step*grad\n",
+    "        delta = polynomial(np.linspace(0,1,dim),degree,coefficients)\n",
+    "        d = delta_to_d(delta)\n",
+    "    return coefficients, loss, grad\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1f73abd7520>]"
+      ]
+     },
+     "execution_count": 106,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGfCAYAAAB1KinVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA+CklEQVR4nO3dfXhU9Z3//9eZm0wgkEASIYmGu4qigMiN1qpVKCwUUb79dStLtUp3e7nr/lYrC3SV7XbV7rq4V6+vN4Wl3lx8ay9l1/76LfJV2m0bLAX5squFGOSmyo1R7pICgrmFydyc3x+TczIzmZlkkjlnAj4f1xXjzJmZnDkznM/7fD7vz/tjmKZpCgAAYADx5HsHAAAAkhGgAACAAYcABQAADDgEKAAAYMAhQAEAAAMOAQoAABhwCFAAAMCAQ4ACAAAGHAIUAAAw4BCgAACAAceX7RO2bdumH/zgB9q1a5caGhr02muv6Stf+UrKx/7VX/2VXnjhBT399NNaunSpfX8wGNSKFSv0H//xHzp37pxmz56ttWvX6rLLLuvVPkSjUZ04cUJDhw6VYRjZvgUAAJAHpmmqpaVFVVVV8ngy95FkHaC0tbVpypQp+vM//3P96Z/+adrHbdy4UW+//baqqqq6bVu6dKneeOMNvfrqqyorK9Py5ct1++23a9euXfJ6vT3uw4kTJ1RdXZ3trgMAgAHg6NGjPXZKZB2gzJ8/X/Pnz8/4mOPHj+uBBx7Qr3/9ay1YsCBhW1NTk9atW6eXX35Zc+bMkSS98sorqq6u1ubNmzVv3rwe92Ho0KGSYm+wuLg427cAAADyoLm5WdXV1XY7nknWAUpPotGo7rnnHn3nO9/RxIkTu23ftWuXQqGQ5s6da99XVVWlSZMmaceOHSkDlGAwqGAwaN9uaWmRJBUXFxOgAABwgelNekbOk2T/9V//VT6fT9/+9rdTbm9sbFRBQYGGDx+ecP/IkSPV2NiY8jmrVq1SSUmJ/cPwDgAAF7ecBii7du3Ss88+q5deeinr5FXTNNM+Z+XKlWpqarJ/jh49movdBQAAA1ROA5S33npLJ0+e1KhRo+Tz+eTz+fTxxx9r+fLlGjNmjCSpoqJCHR0dOnv2bMJzT548qZEjR6Z83UAgYA/nMKwDAMDFL6cByj333KP33ntPdXV19k9VVZW+853v6Ne//rUkafr06fL7/aqpqbGf19DQoL179+rGG2/M5e4AAIALVNZJsq2trTp06JB9u76+XnV1dSotLdWoUaNUVlaW8Hi/36+KigpdeeWVkqSSkhJ961vf0vLly1VWVqbS0lKtWLFCkydPtmf1AACAz7asA5SdO3dq1qxZ9u1ly5ZJkpYsWaKXXnqpV6/x9NNPy+fzadGiRXahtpdeeqlXNVAAAMDFzzBN08z3TmSrublZJSUlampqIh8FAIALRDbtN2vxAACAAYcABQAADDgEKAAAYMAhQAEAAAMOAQoAABhwCFAADEhtwbCe23pYH3/Slu9dQafDp1rVdC6U793AZwQBCoABadN7J/Tkf76vZzcfzPeuQNKxs+36k6e26r6f7Mz3ruAzggAF/RaORHX803P53g1cZE63dkiSTrUG87wnkKSPP2lX1JQ+PN2a713BZwQBCvrtsTf26aYnf6udH53J967gItIaDEuKDfUg/1rOhxN+A04jQEG/fdDYEvv9x5Y87wkuJq2dDWErAcqAYH0OwXBUHeFonvcGnwUEKOg364qqlSsr5JDVIPK9Ghhaz3clx9KrBTcQoKDf7IaEkxZyyB5S4Hs1IMT/++bfOtxAgIJ+s05WjE0jl1qDoc7fYV2Aa5pedOIDRf6tww0EKOgX0zTJFYAjrO+TaUrtHZE87w3ih9r4tw43EKCgX4LhqMLR2NUtuQLIJRrEgaU1oQeFYm1wHgEK+qWFRgQOIedhYCFghNsIUNAvCVdVnLSQQwkBCr1zeUcOCtxGgIJ+iW846PZFroQiUZ0PddXa4Io9/+hBgdsIUNAvLcGuoISrXORKcp0Nrtjzjx4tuI0ABf3CVRWckByQ8N3KP3KC4DYCFPRL/ImqvSOiSJR6Fei/5AawleHDvEscziVAgfMIUNAv3RoSrqyQA3yvBpZgOKKOSHxOEAEjnEeAgn6hKx5OSM5xaA1SqC2fun8e/DuH8whQ0C/du+I5caH/kqesc8WeX/w7Rz4QoKBfkmdb0JAgF7pdsdMg5lVyTyk1j+AGAhT0S3LDQfIccqF74Mv3Kp/oQUE+EKCgX7p3xXPiQv9Z36vSooLYbRrEvLICEj4PuIkABf1CVzycYH2PKooLY7cJfPPKOv7W53EuFFE4blYP4AQCFPSLdeIqGeRPuA30h5XLVFlCgDIQWD1aFZ2fhyS1MbMKDiNAQb9YDYfVkND1i1xoTWoQ6ZnLr/ghngJfrNloISEeDiNAQb9YAUkFV7rIIet7RQ/KwGD1aA0J+DQ04Ou8j88EziJAQb8kd8WzojFywWr8RnbmPATDUXWEyXnIF6sHZWihT0MKfQn3AU4hQEGfhSJRnQ/FGo2K4kGSuKpCbliNnxWgSN2nHsM9Vg7KkIBPQzp7UKiFAqcRoKDP4huMipKAJHJQkBtWoDtssF+D/N6E++A+K2AcUujTUHpQ4BICFPSZFYwU+j0aNjhWH4FGBLnQGn/F3tkgEvzmT8LnEWDGHtxBgII+6zpp+bsS52hE0E+maXZ9twpJyhwIrGM/lB4UuIgABX0Wf9KyE+doRNBP7R0RmWbs/4cG/HHfLRKw88Ue4gn4yUGBawhQ0GddJ62uxDmuqtBfVpDr9Rgq9Hu6vlsUBsublpRDbgSMcBYBCvos1UmrtSOsaNTM527hAtcSF/gahkHwOwAkTDPm84BLCFDQZwmZ/Z2Jc6YptYe40kXfxSdkxv9miCc/wpGoznX+mx4SiMtBYYgHDiNAQZ9ZDcbQgE+Ffo+8HiN2P1dW6If4oUNJFAbLs/g1d4rih3MJUOAwAhT0WXwPimEYcVdWXOmi7+yy6oWJPSgkZeaHteZOwOdRga8rJ4hp33AaAQr6rCVNVzwnLvSHlQxLD8rAED9bTxIz9uAaAhT0WXwPiiS6fpETrecTe1Cog5JfyUNuVr4ZASOcRoCCPrOvrKwTF1e6yIHk7xVX7PnVEky8ECFJFm4hQEGftQZT96AwxIP+6D50SGn1fEqbtBykpACcRYCCPmuJqy4pSUMKY79JZkR/JA8dFgW8CffDXfFLWsR+++xtbR18JnAOAQr6LG29ChoS9EPy92ooPSh5ZVWMtYZ2Aj6P/N7OkgJ8JnAQAQr6LL66ZPxvphmjP6iDMrAkfx7x1X0ZzoWTCFDQZ+krfnLSQt8lJ2Xa3yuWUciL5M8j/v8JUOAkAhT0STRqkiQLR3Sb1tr5/WIZhfxI/jxi/8+wG5xHgII+iU+OS5XdD/SV9d2Kz3nwsYxC3iQXapPiatPwecBBBCjoE+uk5fcaCvhiXyNOWsiF1qTZYYZhEPzmUfJQrhR/MUK+GZxDgII+ie/2NYzY1e3QQrp90X8pcx7Ib8qblpRDPAznwnlZByjbtm3THXfcoaqqKhmGoY0bNyZsf+yxxzRhwgQVFRVp+PDhmjNnjt5+++2Ex8ycOVOGYST8LF68uF9vBO4icQ5OCIYj6ghHJaVuEOmdc1/XEI/fvo8eLbgh6wClra1NU6ZM0Zo1a1Juv+KKK7RmzRrt2bNH27dv15gxYzR37lydOnUq4XH33XefGhoa7J/nn3++b+8AeZHcDR/7f05a6J+2YFcSbMoAhSEF1yWXE4j/fwJGOMnX80MSzZ8/X/Pnz0+7/a677kq4/dRTT2ndunV67733NHv2bPv+wYMHq6KiIts/jwEieb0UKXGNDtM07aEfoLesBm9wgVdeT9f3h965/EmVg8ICjnCDozkoHR0deuGFF1RSUqIpU6YkbFu/fr3Ky8s1ceJErVixQi0tLU7uCnIsuRy51HUCi0RNnQ9F87JfuLC1dPaQFAUSr53oncuPVOUEpLgcFD4POCjrHpTe2LRpkxYvXqz29nZVVlaqpqZG5eXl9va7775bY8eOVUVFhfbu3auVK1dq9+7dqqmpSfl6wWBQwWDQvt3c3OzEbiML1okpviEZXOCVYcTqVbQEQxpU4M3X7uECZQ8nJAUoDCnkR6pyAlLXult8HnCSIwHKrFmzVFdXp9OnT+vFF1/UokWL9Pbbb2vEiBGSYvknlkmTJmn8+PGaMWOGamtrNW3atG6vt2rVKj3++ONO7Cr6KFXxJqsEdsv5sFrOhzViaL72Dhcqq0GMv1qXEqvJwj2pyglI8bN4yAmCcxwZ4ikqKtLll1+uG264QevWrZPP59O6devSPn7atGny+/06ePBgyu0rV65UU1OT/XP06FEndhtZsJIVhyY1JNRCQX+kmtIau80Vez6kKicgJeabAU5xpAclmWmaCUM0yfbt26dQKKTKysqU2wOBgAKBgFO7hz5IlTgndV75NnHiQt9k/F6J75XbUpUTkJj2DXdkHaC0trbq0KFD9u36+nrV1dWptLRUZWVleuKJJ7Rw4UJVVlbqk08+0dq1a3Xs2DHdeeedkqTDhw9r/fr1uu2221ReXq79+/dr+fLlmjp1qm666abcvTM4Kv2VLrMt0Hepkq8laUjAm7Ad7khVTkCKm1VFwAgHZR2g7Ny5U7NmzbJvL1u2TJK0ZMkSPffcc3r//ff1k5/8RKdPn1ZZWZmuu+46vfXWW5o4caIkqaCgQG+++aaeffZZtba2qrq6WgsWLNCjjz4qr5ekygtFW7orK6rJoh9STV+XuhpIGkR3pfs84qcZU1IATsk6QJk5c6ZMM/2S5xs2bMj4/Orqam3dujXbP4sBpscTF8lz6IOWdD0ozOLJi7Q9WvErTHdEuk0LB3KBtXjQJ+kaEpLn0B+tKaavS9RByZeWNDlBg/xeWXX0+EzgFAIU9EnaZEYKOKEfeqyDwvfKVel6UKySAhL5ZnAOAQr6pGsBMbrikTupqpZK9KDki11OIMUQDquXw2kEKMiaaZrps/tpSNAPXT1zqWeNdISjCoYj3Z4HZ6TrKZWo7gvnEaAga8FwVOFoLFE6bQ4KJy30QboGsaig63b8isdwVrpcM4kVpuE8AhRkzTppGYY02J84NZzpoOgPOwclqUH0egwNLqAWitsy9aBYQUsznwccQoCCrNknrQKfPJ7E+gfkoKA/MjaIdgI2V+xuSRcwSlSThfMIUJC1dJn9Ejko6Lto1EybJBt/Hw2ie9LlBEnMrEolGI7oqZoDeu/Yp/nelYsCAQqyZl3BZkqcY5VTZKstbqXilN8tgl/X9S4Hhc/D8rOdx/TDNw/q71/bk+9duSgQoCBrve1ByVRxGEhmNXQ+j6GAr/upiQUD3Zd5yK0z34weLdvWA6ckSXuPN+tUS/oFctE7BCjIWm8S50IRU8Fw1NX9woUtPvBNtbYLV+zuMk0zbb0jiYAxWSgS1X8d/sS+vf3QqTzuzcWBAAVZy3TSip8OyokL2UhXVt1iXbGTg+KO86GoIlY5gUxDbgznSpJqPz6bcM5768DpPO7NxYEABVmzx6VTnLS8HkNFTAdFH7T1GKB0fq8IfF1h5ZoZhuwp3vHoQUm07WCsx+Sy4YM6b59WNMowd38QoCBrmTL7JUpgo28yTWmVuhpEch7c0Rp3IZJqyG0on0eCbZ09Jn8z63INLvDqdGtQf2hszvNeXdgIUJC1TEmy8fdz4kI2ej3EQ+DrCnsoN+3nkdselHMdkQs2sf6T1qD2nmiSJM2eMEJfGFcmSXrrIMM8/UGAgqy5feLCZ0NX4Ju6Z446KO7q6UIkl3VQfrOvURMf/ZV++Oahfr9WPmw/dFqmKU2oGKoRxYX64vhySdK2AyTK9gcBCrKWqTaCFH/iInkOvZdpdpjUFRDH10uBc7JJWu5Pz0c4EtWq/3xfUVNa+7tDamw63+fXyhdreOfWKy6RJN3S+XvnR2fVzve1zwhQkLXWDIXa4u/P9kp3ywcnNe2favR/6o73bwdxQeoKULonZMbuZ+jQTb3t0QpHTZ0P9b2kwP+pO6H6022SYguRrtlysM+vlQ+maeqtzgRZKzAZW16kS4cNUkckqrc/PJPP3bugEaAga5nKkUvxa6b0viEJRaJ6/PV9OtPWoe+/sZ/hoc+grtlhPQzx8N1wRU9DuYP9Xlm5s31dHykciWr1b2MByZ9cPVKS9NPfH9XRM+19er18eL+xRSdbghrk92rGmOGSJMMw7GBlK8M8fUaAgqzZsy3S9aD0IVdgQ+0xffRJ7KT0SVuH1r1V38+9xIWmt4EvOSju6GnIzeMxNKSgf5/Ja+8e10eftKu0qEDP/Nm1+uL4coUipn745oXTi2LlmdwwrlQBX1fv361XdOahHCRA6SsCFGStp4Yk2zVTguGInRx34+di2e8vvvWhPmmlVPRnSRvJ1wNKT7lm8dv68pmEIlGt/m3s3/1f3jJORQGfls+9UpL089pjOnyqNevXzAcrAPni+EsS7v/C58rl9Rj68FSbjp29cHqEBhIClDgfnmrVtH+q0a0/2JLvXRnQMhVqk7LvQfnp74/q+KfnNGJoQOuWXKdJlxarNRjW2t8dzs0O44LQ2+nrrcEwBbBc0FOuWfy2vvSgvFZ7XEfOtKusqED3fmG0JOna6mGac9VIRU3pmc2Ze1Eams5pxc9268vPbNOG2mN5+U60d4T1+/qzkrryTywlg/y6tnqYJKYb91X6b95nkGEYOtPWoVCENWTS6QhH7TV2esrub+7FSet8KKI1nVdRD37pcg0q8Orv5k3Qvf/rHb38Xx/rL24eq0uHDcrR3mMg63nWSNf9bR1huyAgnNFT4TwpruZRlj0ooUhUqzuTYf/q1nEaHLdExrI/uUKb//BHvbH7hP7fmZ/TVZXFCc9t7wjrhW0f6rmth+3k3GX/3279ZMdH+t7tV2vGmNKs9qU/3q4/o45IVJcOG6TPXVLUbfsXx5dr18dnte3AKX39+lE5+7vBcEQ7Dn2i3+z/o45/ei5hm2nG1kELhiI6H4oqGI4oFDHtbZJkKrZeWigSVUc4qlAkKr/XoysqhurqymJdXVWsqyuLNaFiqIoyBKhOI0CJ4/PEMr7CEa7O0mmLOxGl++IOyWKa8Sv//bFOtgR16bBBWnRdtaTYP+ovjCvTf334iZ6pOaAf3DklB3uOgc6+Yk/TIAZ8Hvm9hkKR2CJ2F3OA0hYMa/exT3XszDldXVWsqyqL5fV0r+bqlGjU1Kfnet+D8tbBUyotKtCYsiKVDylIqDzbEY7qXChWhM00Y43jpvdO6OiZcyofUqBv3DA64TWvrirW7ddUatN7DXriF3/QPV8YrVi7aupUS1D/tuWwGptjU5FnjB6uGy8v1//aXq/dx5r0tef+SwsmV+r2ayplGIY8RuzC01CsZL+1W4YMqZeH02sY8noMeTp/ez2x1/Qaht7YfUKSdMsV5Smr7d5yxSV6ZvNBbT90Wu83NisYil3gBcMRe50jS+dblClTybO2DSO2z2fbO/Tm+yf1u/dPqq0j0rs30EvhaES7j36q3Uc/te8bNtivd7/3JynfmxsIUOL4vLEPIfmL45QzbR061RLU+BFD5HHx5NMf1lhzod8jvzf1CGFvc1Da4oZxHpo93k4wMwxDf/flK/X/rN2hn9ce01/eMk7jRw7N1VtAPzQ0ndOHp9pkmvEneykUNRUMRTpPvl1XZR3hqDoisf+PRGMn3qhpypS6nYRPt3RISp+DYhiGhgR8Otse0vNbP1TxIL9M01S084WMzhbH2q9I1FTENBWNmkrXKer3GQp4Y99lv89jX6RYzLgGI9r5/8ms9xHbl+7vKx3DiJ1z/J5Y4OX1GDp0slW7jpzVHxpaEs5DQwM+zRgzXJ8fV6YxZUXyeQz5vIZ8Ho88nq73nu7vJL8X04z1RJxsCepk83mdbAnqj83ndao1qFMtQZ1u7bD/fqYr6EuGBCRJr/z3Eb3y30fsfR0c8Kq9I6JzHRGFM5xP77/1cwm9J5alc67QL/c0aPuh09p+qPvwyGXDB2nl/Kt02+QKGYahe24YradqPtBPf39Uv9jToF/saUj7N51wS1L+ieWaS0tUXOhT8/mwvvzMWzn9myOLA5p7dYWuuaxEnqQAIuD3qNDnVaHfq0DnudoK0qTY98XnNVTg86ig8/vfGgzr/cZm7T/RrP0Nsd/jLinKW3AiEaAksK5QQlHnhng+be/Qr/c1atN7Ddpx+BNFoqZKiwp0y/hyzbxyhG654hKVFhVk/brRaOxEHY07Cfm9npxfdfU0FVTq6hJubApqQ+0x+b0e+x9Cga/r/3+5t0Fn2jo0trxIX512acJrTB01XPMmjtSv9/1Rq/7zfa29e5oK/anrYyBRNGrq2Nlz6ohE7CvW3kpuxMLRqPYeb9bvPzqj3390RsfOnuv5RfrBMKThGb7/pUUFOtse0ks7PnJ0PwaCqpJCjSobrL3Hm9USDGvLB6e05QN3Z4R87pIifX5s+iGTpXOuUPEgvw6falX96TYd//ScWoLhXg35XF1ZrLs/PzrltstHDNF3F1ytTe+d6GxYYyGYx2PoSxNG6Js3jkk4H1wyNKBVX71G935hjNZsOaQ/Np3vDIKtc6LsyDFVcJyOqVhwG40PdjuD4mg0FgSPLhusmVeOSPl8n9ejv7xlnF7Y9qH8Xo8CPo8K/V4V+BLPzfGBQ3zgn7y/Pq+hL4wr09yJFbrm0pKcX9hePmKIbr+myr59PpTbXppsGeYFuPhBc3OzSkpK1NTUpOLi4p6f0Etn2zo09Z9qJEmH/+W2PjXupmlq7/Fm/WJPgz481apoZ7+dacZ6FHZ9fDbhiqLQ70kocmQYUnGhP6FB93uNhCtPmbK7Cc+HojofSn+VMrjAqyEBn4YU+mKLfqnrCx9/NWj9w4jfHjW7dzWeC0VUf7pNY8uLtGXFzJR/89DJFs15aluvj9mzi6/V/7j20m73H/xji+Y9s01RM3ZVtuCaSn112mW6bszwvEb1PTFNU4dPtepcR1Txu2kY8VfbqZ9rGLEr1qJA7HMb5Pf26r0e//Scth88pe2HPtGOQ6f1SVtHDt5Jdx4jVoTK6j2zvkc+j0cBf+wEXODzqqDzZOzvvErze2O9E9Z78RiGUr2tay4rSfldsOw4fFpv7G6QYcS63q0u/HjWKc3jMbq65z3d+xhMSSGrpycS6/lJ9bkYnf+J/zeSvO/2ts4H9+braZqmwp15AKGoqXAkqqphgzRjdKmmjR6mypJY7lU4EtX7jS16u/6M3qn/RKdbOxSOmopEowpHzIw9FPF/yx7y6Ny/gM+jEcWFGjE0oJGdv0cUB3TJkEJdMjSgsiEFaXtJ0zkfiujomXYFw1ENKvBqcIFXg/0+BfyxBjk+2DBSfHa4+GXTfhOgxL/u+ZCueew3kqQP/vnLCXPa40Wipk63BmNdyJ0/Z9o79Jt9f9Qv9zToSA9Fhq6qjI2xLphcqUuHD1Ltx2f1uwOntOX9k3q/sSVn78dJsyeM0LpvXpdym2ma+p+/OaA/NDTb3fuhiBnr7u/s8reSbaePHqa1d09PGwz+713H9HTNgYREsOrSQaoqGSTTlH01Yw05eKwrLcOI65qPhWKD/F7d+LkyzbxyhCZWFef05GiapnYfa9Iv9zToF+81dEtc6yuPEevZs3pC7MbXMOwG2GOo23h0gc/TGdwooVHo8X0o7vGdzx1bXqTrx5bqujGlmjZ6eMacBADIhAClj851RHTVP/5KkrTv8Xkpx16jUVO3r96u/Q3pl9Eu9Hs0e8JIfX5cqT32ZzUo11YP0+UjhqR97unWoD5tDyWM3YfCUfsKzrpi9HmNzjHGWJdhwGddoRgyPJ15ARFTrefDagmG1Ho+rLaOsN2QW0liVo9JfHKWdWWT3LBZXxSPIU0bNdy17O5o1NQ7H53Rz3cd0y/3NOQkOWzE0IBuveISjb2kKOHKOGpK5zrCauuIqL0jrLZgROFo1D5eVgBkyuphinX17j3RlDD8Mcjv1bDBsWEwM/nYxv29ZOGoqfaOiP1Z9ZbXY2jKZSW6+fJy3Tz+El1bPUwFPqoIABhYsmm/uRSKYyXJSkrbbdrWEbaDE39nkprPE+vG/vy4Ui2YXKVZEy5JmfjVG+VDAirvTDzLhb7ksww0Ho+hG8aV6YZxZfr+/5ikHYdP63woagdrVudL11htbNw5uSfgZEtQWw+c0v89dFonW4L62a5jOd3PwQVezb5qpBZMrtDMK0f0K2cmGjV1LhRRazCsSNRMCGwk2flG0c4evLIhBRf1rBYAnz0EKHHiM/jDadL+4zPr3/+n+a5O/YM0qDMI6Ktv3DBawXBEOz+K1SY409aRkIRmGLFAY3CBT0UFXg0O+OwcILNzqChqxnqRPFZwZBgaMTSgW8ZfokEFuUnk9XiMzlwU/okC+Gzi7BfH6Eyos/JKUgnF1UghNrkwBXxe3XR5uW66vDzfuwIASINB6iRdU41TByjhzinIfq9BBjoAAA4hQEnit6vJph7isarM+jwcOgAAnEIrm8TqQUmXJGvdn1xxEgAA5A4BShKrMFG69XisnpX4GT8AACC3CFCSWIFHOE25e7sHJcsKiwAAoPdoZZNYuSXpe1AY4gEAwGkEKEm6elDSTDOOMsQDAIDTCFCSeHuYxWPVR/EziwcAAMfQyiaxAo+0PSidgQsVZAEAcA4BSpIepxlHSJIFAMBptLJJ/N4eCrXFVZIFAADOIEBJYvWM9NiDwhAPAACOIUBJ0pUk21MlWQ4dAABOoZVN4u+hUFuISrIAADiOACWJt4dCbREqyQIA4Dha2ST2asbpSt2TgwIAgOMIUJL0NM3YriRLgAIAgGMIUJL0tJqxXUmWIR4AABxDK5ukx7V4OgMXKskCAOAcApQkPa3FE2YWDwAAjiNASdLTWjxhFgsEAMBxtLJJvN4eCrVZQzz0oAAA4JisA5Rt27bpjjvuUFVVlQzD0MaNGxO2P/bYY5owYYKKioo0fPhwzZkzR2+//XbCY4LBoB588EGVl5erqKhICxcu1LFjx/r1RnKlx2nG1lo85KAAAOCYrAOUtrY2TZkyRWvWrEm5/YorrtCaNWu0Z88ebd++XWPGjNHcuXN16tQp+zFLly7Va6+9pldffVXbt29Xa2urbr/9dkUikb6/kxzx9jDEE2I1YwAAHOfL9gnz58/X/Pnz026/6667Em4/9dRTWrdund577z3Nnj1bTU1NWrdunV5++WXNmTNHkvTKK6+ourpamzdv1rx587LdpZzqaTXjSJQkWQAAnOZoN0BHR4deeOEFlZSUaMqUKZKkXbt2KRQKae7cufbjqqqqNGnSJO3YscPJ3emVHgu1UUkWAADHZd2D0hubNm3S4sWL1d7ersrKStXU1Ki8vFyS1NjYqIKCAg0fPjzhOSNHjlRjY2PK1wsGgwoGg/bt5uZmJ3ZbUtfQTfrVjK1KsgzxAADgFEda2VmzZqmurk47duzQl7/8ZS1atEgnT57M+BzTNGUYqXslVq1apZKSEvunurraid2WFJ8k21MlWXpQAABwiiMBSlFRkS6//HLdcMMNWrdunXw+n9atWydJqqioUEdHh86ePZvwnJMnT2rkyJEpX2/lypVqamqyf44ePerEbkuKn2acOgelq5IsPSgAADjFlVbWNE17iGb69Ony+/2qqamxtzc0NGjv3r268cYbUz4/EAiouLg44ccpVgG2SLpCbZ2BCz0oAAA4J+sclNbWVh06dMi+XV9fr7q6OpWWlqqsrExPPPGEFi5cqMrKSn3yySdau3atjh07pjvvvFOSVFJSom9961tavny5ysrKVFpaqhUrVmjy5Mn2rJ58spJkQz1UkiVJFgAA52QdoOzcuVOzZs2yby9btkyStGTJEj333HN6//339ZOf/ESnT59WWVmZrrvuOr311luaOHGi/Zynn35aPp9PixYt0rlz5zR79my99NJL8nq9OXhL/dPTNOOuSrIM8QAA4JSsA5SZM2fKNFP3LkjShg0benyNwsJCrV69WqtXr872zzuup0JtVJIFAMB5dAMk8fXUgxKlkiwAAE6jlU1iD/GkTZIlBwUAAKcRoCSxh3jSFGoLRSh1DwCA0whQkli5JWmnGduzeDh0AAA4hVY2Sdc048w5KNRBAQDAOQQoSfw9rcXTOcTjJQcFAADHEKAk6Wk1Yytw8TOLBwAAx9DKJul5mrG1mjE9KAAAOIUAJYnVM9Jjkiw5KAAAOIYAJUmPSbIRZvEAAOA0Wtkk9mrG6ZJko9RBAQDAaQQoSXpczZgeFAAAHEcrm6Sn1YypJAsAgPMIUJL0NM3YSp7104MCAIBjaGWT9FSozRr68dKDAgCAYwhQklhDN2mnGXcO8fipgwIAgGMIUJJkmmYcjZqy4hYflWQBAHAMrWwSK7fENGMBSbz4vBSSZAEAcA4BSpL43JLkXpRw3G1K3QMA4BwClCTxs3OSE2VDcbepgwIAgHNoZZN443pGkqcaxyfO0oMCAIBzCFCSxAceycXarNseQ/IQoAAA4BgClCQejyEr9kieahyyVzLmsAEA4CRa2hSsACR5PR5rAUFqoAAA4CwClBSsACR5RWNrVo+XAAUAAEcRoKSQrlibNavHzxAPAACOoqVNId16PFYdFIq0AQDgLAKUFLpWNE7dg0INFAAAnEVLmwI9KAAA5BcBSgpdPSipK8lSpA0AAGcRoKRg9ZAkF2qz6qIwxAMAgLNoaVOw1uPpVqgtwhAPAABuIEBJoWuacVIOSoRKsgAAuIGWNgV/Zw9JJHkWT5RKsgAAuIEAJQW7ByXNLB4qyQIA4CwClBR86aYZU0kWAABX0NKm4EtXqM1ezZgeFAAAnESAkkL6HpTOWTwM8QAA4CgClBTs1YyTpxlTBwUAAFfQ0qaQbjXjCHVQAABwBQFKClYSbHIPip2DwhAPAACOIkBJId004xCF2gAAcAUtbQrp1uKxbvsZ4gEAwFEEKCn40qxmbN2mUBsAAM4iQEkh7TTjqDXNmMMGAICTaGlT6JpmnDzEY1WSpQcFAAAnEaCk4O3sIem2mnGUJFkAANxAS5tC12rGVJIFACAfCFBS6JpmnDjEQyVZAADcQUubQrok2UiExQIBAHADAUoK6aYZh6IM8QAA4AYClBTSF2ojSRYAADfQ0qbgS7OasXWbacYAADiLACUFX5ppxlbSLJVkAQBwVtYByrZt23THHXeoqqpKhmFo48aN9rZQKKSHH35YkydPVlFRkaqqqnTvvffqxIkTCa8xc+ZMGYaR8LN48eJ+v5lc6ZpmnDTEY/WgMIsHAABHZd3StrW1acqUKVqzZk23be3t7aqtrdX3vvc91dbWasOGDTpw4IAWLlzY7bH33XefGhoa7J/nn3++b+/AAXahtm6rGXcmyTLEAwCAo3zZPmH+/PmaP39+ym0lJSWqqalJuG/16tW6/vrrdeTIEY0aNcq+f/DgwaqoqMj2z7siXZJshMUCAQBwheNjFU1NTTIMQ8OGDUu4f/369SovL9fEiRO1YsUKtbS0OL0rvZZ2NWN7LR6GeAAAcFLWPSjZOH/+vB555BHdddddKi4utu+/++67NXbsWFVUVGjv3r1auXKldu/e3a33xRIMBhUMBu3bzc3NTu522kJt1EEBAMAdjgUooVBIixcvVjQa1dq1axO23Xffffb/T5o0SePHj9eMGTNUW1uradOmdXutVatW6fHHH3dqV7vpeZoxPSgAADjJkZY2FApp0aJFqq+vV01NTULvSSrTpk2T3+/XwYMHU25fuXKlmpqa7J+jR486sds2K0AJJc3isZJmyUEBAMBZOe9BsYKTgwcPasuWLSorK+vxOfv27VMoFFJlZWXK7YFAQIFAINe7mpbVQ5J2NWNm8QAA4KisA5TW1lYdOnTIvl1fX6+6ujqVlpaqqqpKX/va11RbW6tNmzYpEomosbFRklRaWqqCggIdPnxY69ev12233aby8nLt379fy5cv19SpU3XTTTfl7p31Q9dqxgzxAACQD1kHKDt37tSsWbPs28uWLZMkLVmyRI899phef/11SdK1116b8LwtW7Zo5syZKigo0Jtvvqlnn31Wra2tqq6u1oIFC/Too4/K6/X2463kTrppxtaQD0M8AAA4K+sAZebMmTJNM+32TNskqbq6Wlu3bs32z7rKKnXffYiHSrIAALiBljYFqwclOUnWqotCDgoAAM4iQEnBnmYcSZMkyxAPAACOIkBJId1qxtYQj48kWQAAHEVLm0LXasZUkgUAIB8IUFLommacerFAclAAAHAWAUoKqQq1maZp10XxMYsHAABH0dKmYPWgxC8WGB+s+OlBAQDAUQQoKaSaZhyOC1Ao1AYAgLMIUFKwhnBMU4p2BibhhB4UDhsAAE6ipU0hPgnW6kWJL3vPLB4AAJxFgJJCfCn7SIoeFIZ4AABwFgFKCvEBiDVzxy7S5jFkGAQoAAA4iQAlhfghHKsHxaqJQg0UAACcR4CSgsdjyIpRrNwTK1BhJWMAAJxHa5uGtd5OyM5BiQUqXnpQAABwHAFKGskrGlNFFgAA99DapmEFKF3TjDuHeOhBAQDAcQQoaSSvx2MP8TDFGAAAxxGgpJG8orFVB4UqsgAAOI/WNo3kHhR7mjE9KAAAOI4AJY2uHpRYgGIFKgzxAADgPAKUNKyCbFYdlK4kWQ4ZAABOo7VNw55mTCVZAABcR4CShlXvxCrURiVZAADcQ2ubhtVTEumcXhwiBwUAANcQoKThS0qSDTPEAwCAawhQ0vAlF2ojSRYAANfQ2qbhS1OojSEeAACcR4CShtWDYvWcWKXuWYsHAADnEaCk0X2aMasZAwDgFlrbNJJXM7Zm81DqHgAA5xGgpNE1zTipB4UhHgAAHEeAkoZdqC2SOIvHxyweAAAcR2ubRnKhNoZ4AABwDwFKGsmF2qxKsiTJAgDgPFrbNLoXamOaMQAAbiFAScPqQQknFWojSRYAAOcRoKSRvJqxlSTrZYgHAADH0dqmkTzN2K4kS5IsAACOI0BJI3ktnhDTjAEAcA2tbRrJSbIRexYPPSgAADiNACWNbtOMO3tSSJIFAMB5BChpJBdqo5IsAADuobVNo2uasZUkyxAPAABuIUBJo9s0Y0rdAwDgGgKUNNIN8fgZ4gEAwHG0tml0W824M1Dx0oMCAIDjCFDS6Faoze5BIUABAMBpBChpdCvUxmrGAAC4htY2je6F2jqHeOhBAQDAcQQoaXSbZmwN8dCDAgCA42ht07CHeKLWWjxUkgUAwC0EKGl0X82YJFkAANxCgJJGt2nGnb+9DPEAAOA4Wts0rCEeu1AblWQBAHBN1gHKtm3bdMcdd6iqqkqGYWjjxo32tlAopIcffliTJ09WUVGRqqqqdO+99+rEiRMJrxEMBvXggw+qvLxcRUVFWrhwoY4dO9bvN5NL1iyebkmyVJIFAMBxWbe2bW1tmjJlitasWdNtW3t7u2pra/W9731PtbW12rBhgw4cOKCFCxcmPG7p0qV67bXX9Oqrr2r79u1qbW3V7bffrkgk0vd3kmNWDko4KQeFSrIAADjPl+0T5s+fr/nz56fcVlJSopqamoT7Vq9ereuvv15HjhzRqFGj1NTUpHXr1unll1/WnDlzJEmvvPKKqqurtXnzZs2bN68PbyP3uqYZRxN+kyQLAIDzHB+vaGpqkmEYGjZsmCRp165dCoVCmjt3rv2YqqoqTZo0STt27Ej5GsFgUM3NzQk/TktezdiuJMsQDwAAjnO0tT1//rweeeQR3XXXXSouLpYkNTY2qqCgQMOHD0947MiRI9XY2JjydVatWqWSkhL7p7q62sndltR9mnHELnVPDwoAAE5zLEAJhUJavHixotGo1q5d2+PjTdOUYaRu/FeuXKmmpib75+jRo7ne3W7i1+IxTZMABQAAFzkSoIRCIS1atEj19fWqqamxe08kqaKiQh0dHTp79mzCc06ePKmRI0emfL1AIKDi4uKEH6dZQzyRqGnXQpEY4gEAwA05b22t4OTgwYPavHmzysrKErZPnz5dfr8/IZm2oaFBe/fu1Y033pjr3ekzexZPpKv3RKIHBQAAN2Q9i6e1tVWHDh2yb9fX16uurk6lpaWqqqrS1772NdXW1mrTpk2KRCJ2XklpaakKCgpUUlKib33rW1q+fLnKyspUWlqqFStWaPLkyfasnoGga5px1F6PJ/5+AADgnKwDlJ07d2rWrFn27WXLlkmSlixZoscee0yvv/66JOnaa69NeN6WLVs0c+ZMSdLTTz8tn8+nRYsW6dy5c5o9e7Zeeukleb3ePr6N3LOGeKKm1BHuClBYzRgAAOdlHaDMnDlTpmmm3Z5pm6WwsFCrV6/W6tWrs/3zronvKTkfihWQ8xiShyEeAAAcR3dAGvG5JudD1jo8HC4AANxAi5tGfDBi9aCQfwIAgDsIUNJI7EGJdLsPAAA4hwAlDY/HkBWP2EM81EABAMAVtLgZWAEJPSgAALiLACUDKyA5H44FKH56UAAAcAUtbgZ2gNI5xOOlBwUAAFcQoGTQbYiHWTwAALiCACWDrh6UziEe6qAAAOAKWtwMkgMUhngAAHAHAUoGXUM8sRwUP0M8AAC4ggAlAyvn5Jydg8LhAgDADbS4GSQP8VAHBQAAdxCgZGCtx9NVSZYABQAANxCgZGAFJFahNlYzBgDAHbS4GdhDPB1WJVl6UAAAcAMBSgb2EE+YacYAALiJACUDe4iH1YwBAHAVLW4GVkByzhrioQcFAABXEKBkkLyasZckWQAAXEGLm4EVoASpJAsAgKsIUDLoykFhNWMAANxEgJKBNYvHLnXPEA8AAK6gxc2AUvcAAOQHAUoG1pBO1LRuc7gAAHADLW4GybN26EEBAMAdBCgZJM/aIUkWAAB3EKBkkJwU62eIBwAAV9DiZpDcY8IQDwAA7iBAySA5IGGxQAAA3EGAkkFygMIQDwAA7qDFzSB5WjFJsgAAuIMAJYPkIR1yUAAAcAcBSgbdphlT6h4AAFfQ4maQHJAwxAMAgDsIUDLoPs2YwwUAgBtocTOgBwUAgPwgQMmg+zRjAhQAANxAgJJBco9J8uKBAADAGbS4GSRPM/YzzRgAAFcQoGSQXDk2uXAbAABwBi1uBsk5KCTJAgDgDgKUDFjNGACA/CBAyaDbNGOSZAEAcAUtbgZMMwYAID8IUDJITopNntUDAACcQYCSQbdpxsziAQDAFbS4GXRbzZghHgAAXEGAkkFyUixDPAAAuIMAJYPkHhM/s3gAAHAFLW4GFGoDACA/CFAyoA4KAAD5QYubQbdKsvSgAADgCgKUDLoN8ZAkCwCAK7IOULZt26Y77rhDVVVVMgxDGzduTNi+YcMGzZs3T+Xl5TIMQ3V1dd1eY+bMmTIMI+Fn8eLFfX0Pjokv1ObzxPYTAAA4L+sApa2tTVOmTNGaNWvSbr/pppv05JNPZnyd++67Tw0NDfbP888/n+2uOC5+WjFTjAEAcI8v2yfMnz9f8+fPT7v9nnvukSR99NFHGV9n8ODBqqioyPbPuyq+UBtVZAEAcE/eWt3169ervLxcEydO1IoVK9TS0pL2scFgUM3NzQk/boiftUOCLAAA7sm6ByUX7r77bo0dO1YVFRXau3evVq5cqd27d6umpibl41etWqXHH3/c5b1MTIolQRYAAPfkJUC577777P+fNGmSxo8frxkzZqi2tlbTpk3r9viVK1dq2bJl9u3m5mZVV1c7vp8ejyGPIUVNaqAAAOCmAdHqTps2TX6/XwcPHky5PRAIqLi4OOHHLVZgwhAPAADuGRAByr59+xQKhVRZWZnvXenGCkwY4gEAwD1ZD/G0trbq0KFD9u36+nrV1dWptLRUo0aN0pkzZ3TkyBGdOHFCkvTBBx9IkioqKlRRUaHDhw9r/fr1uu2221ReXq79+/dr+fLlmjp1qm666aYcva3csaYX+5jFAwCAa7JudXfu3KmpU6dq6tSpkqRly5Zp6tSp+sd//EdJ0uuvv66pU6dqwYIFkqTFixdr6tSpeu655yRJBQUFevPNNzVv3jxdeeWV+va3v625c+dq8+bN8nq9uXpfOWNNL6YHBQAA9ximaZr53olsNTc3q6SkRE1NTY7no1z/xGadbAlq0qXF2vTgFx39WwAAXMyyab8Zt+iB1XPCLB4AANxDq9sDK/fEzyweAABcQ4DSA3pQAABwH61uD+xpxvSgAADgGgKUHng9zOIBAMBtBCg98HupgwIAgNtodXvQlYNCDwoAAG4hQOlB11o8HCoAANxCq9sDKznWTw8KAACuIUDpgbUWj5cABQAA1xCg9MBei4chHgAAXEOr2wOr54RKsgAAuIcApQdWYMIQDwAA7iFA6YE1i8fPEA8AAK6h1e0BdVAAAHAfAUoP7LV4CFAAAHANAUoPhg0ukCSVdP4GAADO8+V7Bwa6+744TpcNH6SvTL0037sCAMBnBgFKDy4ZGtC9XxiT790AAOAzhSEeAAAw4BCgAACAAYcABQAADDgEKAAAYMAhQAEAAAMOAQoAABhwCFAAAMCAQ4ACAAAGHAIUAAAw4BCgAACAAYcABQAADDgEKAAAYMAhQAEAAAPOBbmasWmakqTm5uY87wkAAOgtq9222vFMLsgApaWlRZJUXV2d5z0BAADZamlpUUlJScbHGGZvwpgBJhqN6sSJExo6dKgMw8jpazc3N6u6ulpHjx5VcXFxTl8biTjW7uFYu4dj7R6OtXtydaxN01RLS4uqqqrk8WTOMrkge1A8Ho8uu+wyR/9GcXExX3iXcKzdw7F2D8faPRxr9+TiWPfUc2IhSRYAAAw4BCgAAGDAIUBJEggE9OijjyoQCOR7Vy56HGv3cKzdw7F2D8faPfk41hdkkiwAALi40YMCAAAGHAIUAAAw4BCgAACAAYcABQAADDgEKHHWrl2rsWPHqrCwUNOnT9dbb72V71264K1atUrXXXedhg4dqhEjRugrX/mKPvjgg4THmKapxx57TFVVVRo0aJBmzpypffv25WmPLx6rVq2SYRhaunSpfR/HOneOHz+ub3zjGyorK9PgwYN17bXXateuXfZ2jnVuhMNh/cM//IPGjh2rQYMGady4cfr+97+vaDRqP4Zj3Xfbtm3THXfcoaqqKhmGoY0bNyZs782xDQaDevDBB1VeXq6ioiItXLhQx44d6//OmTBN0zRfffVV0+/3my+++KK5f/9+86GHHjKLiorMjz/+ON+7dkGbN2+e+eMf/9jcu3evWVdXZy5YsMAcNWqU2draaj/mySefNIcOHWr+/Oc/N/fs2WP+2Z/9mVlZWWk2Nzfncc8vbO+88445ZswY85prrjEfeugh+36OdW6cOXPGHD16tPnNb37TfPvtt836+npz8+bN5qFDh+zHcKxz45//+Z/NsrIyc9OmTWZ9fb35s5/9zBwyZIj5zDPP2I/hWPfdL3/5S/O73/2u+fOf/9yUZL722msJ23tzbO+//37z0ksvNWtqasza2lpz1qxZ5pQpU8xwONyvfSNA6XT99deb999/f8J9EyZMMB955JE87dHF6eTJk6Ykc+vWraZpmmY0GjUrKirMJ5980n7M+fPnzZKSEvO5557L125e0FpaWszx48ebNTU15q233moHKBzr3Hn44YfNm2++Oe12jnXuLFiwwPyLv/iLhPu++tWvmt/4xjdM0+RY51JygNKbY/vpp5+afr/ffPXVV+3HHD9+3PR4POavfvWrfu0PQzySOjo6tGvXLs2dOzfh/rlz52rHjh152quLU1NTkySptLRUklRfX6/GxsaEYx8IBHTrrbdy7Pvob/7mb7RgwQLNmTMn4X6Ode68/vrrmjFjhu68806NGDFCU6dO1Ysvvmhv51jnzs0336w333xTBw4ckCTt3r1b27dv12233SaJY+2k3hzbXbt2KRQKJTymqqpKkyZN6vfxvyAXC8y106dPKxKJaOTIkQn3jxw5Uo2NjXnaq4uPaZpatmyZbr75Zk2aNEmS7OOb6th//PHHru/jhe7VV19VbW2tfv/733fbxrHOnQ8//FA/+tGPtGzZMv393/+93nnnHX37299WIBDQvffey7HOoYcfflhNTU2aMGGCvF6vIpGInnjiCX3961+XxPfaSb05to2NjSooKNDw4cO7Paa/7ScBShzDMBJum6bZ7T703QMPPKD33ntP27dv77aNY99/R48e1UMPPaTf/OY3KiwsTPs4jnX/RaNRzZgxQ//yL/8iSZo6dar27dunH/3oR7r33nvtx3Gs+++nP/2pXnnlFf37v/+7Jk6cqLq6Oi1dulRVVVVasmSJ/TiOtXP6cmxzcfwZ4pFUXl4ur9fbLdo7efJkt8gRffPggw/q9ddf15YtW3TZZZfZ91dUVEgSxz4Hdu3apZMnT2r69Ony+Xzy+XzaunWrfvjDH8rn89nHk2Pdf5WVlbr66qsT7rvqqqt05MgRSXyvc+k73/mOHnnkES1evFiTJ0/WPffco7/927/VqlWrJHGsndSbY1tRUaGOjg6dPXs27WP6igBFUkFBgaZPn66ampqE+2tqanTjjTfmaa8uDqZp6oEHHtCGDRv029/+VmPHjk3YPnbsWFVUVCQc+46ODm3dupVjn6XZs2drz549qqurs39mzJihu+++W3V1dRo3bhzHOkduuummbtPlDxw4oNGjR0vie51L7e3t8ngSmyqv12tPM+ZYO6c3x3b69Ony+/0Jj2loaNDevXv7f/z7lWJ7EbGmGa9bt87cv3+/uXTpUrOoqMj86KOP8r1rF7S//uu/NktKSszf/e53ZkNDg/3T3t5uP+bJJ580S0pKzA0bNph79uwxv/71rzNFMEfiZ/GYJsc6V9555x3T5/OZTzzxhHnw4EFz/fr15uDBg81XXnnFfgzHOjeWLFliXnrppfY04w0bNpjl5eXm3/3d39mP4Vj3XUtLi/nuu++a7777rinJfOqpp8x3333XLrHRm2N7//33m5dddpm5efNms7a21vzSl77ENONc+7d/+zdz9OjRZkFBgTlt2jR7Kiz6TlLKnx//+Mf2Y6LRqPnoo4+aFRUVZiAQMG+55RZzz549+dvpi0hygMKxzp033njDnDRpkhkIBMwJEyaYL7zwQsJ2jnVuNDc3mw899JA5atQos7Cw0Bw3bpz53e9+1wwGg/ZjONZ9t2XLlpTn6CVLlpim2btje+7cOfOBBx4wS0tLzUGDBpm33367eeTIkX7vm2Gaptm/PhgAAIDcIgcFAAAMOAQoAABgwCFAAQAAAw4BCgAAGHAIUAAAwIBDgAIAAAYcAhQAADDgEKAAAIABhwAFAAAMOAQoAABgwCFAAQAAAw4BCgAAGHD+f3nbYIkWXrxYAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "H_TFIM = hamiltonians.TFIM(nqubits=7, h=5.0)\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator,cost=cost)\n",
+    "matrix = dbi.h.matrix\n",
+    "eigenenergies = np.diag(np.linalg.eigh(matrix)[0])\n",
+    "delta = d_to_delta(eigenenergies)\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.plot(delta,'.')\n",
+    "plt.xlabel('Index')\n",
+    "plt.ylabel(r'$\\Delta$')\n",
+    "\n",
+    "d, loss, grad = optimize_poly(dbi, 1e-3, 100, 3)\n",
+    "plt.figure()\n",
+    "plt.plot(loss)\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.9.18"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "c4f92193806e2908606a5f23edd55a5282f2f433b73b1c504507f9256ed9f0b4"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/dbi/dbi_scheduling.ipynb b/examples/dbi/dbi_scheduling.ipynb
new file mode 100644
index 0000000000..a0ac88e6a6
--- /dev/null
+++ b/examples/dbi/dbi_scheduling.ipynb
@@ -0,0 +1,456 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Double-bracket Iteration Scheduling Strategies\n",
+    "\n",
+    "This notebook presents the different strategies for scheduling the step durations for the double-bracket iteration algorithm and their resepctive accuracies."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Import the dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from copy import deepcopy\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from qibo import hamiltonians, set_backend\n",
+    "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n",
+    "from qibo.models.dbi.utils import *\n",
+    "from qibo.models.dbi.utils_scheduling import *\n",
+    "from qibo.models.dbi.utils_strategies import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Canonical\n",
+    "Set up the basic test case with the transverse field ising model hamiltonian and the canonical bracket as the generator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"qibojit\", platform=\"numba\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 5\n",
+    "h = 3\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n",
+    "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We first run a sweep of step duration to map the off-diagonal norm in this range."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# generate data for plotting sigma decrease of the first step\n",
+    "s_space = np.linspace(1e-5, 0.6, 100)\n",
+    "off_diagonal_norm_diff = []\n",
+    "for s in s_space:\n",
+    "    dbi_eval = deepcopy(dbi)\n",
+    "    dbi_eval(s)\n",
+    "    off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The default scheduling strategy is grid search: `DoubleBracketScheduling.\n",
+    "grid_serach`. This strategy specifies a list of step durations to test one by one and finds the one that maximizes the cost function (off-digonal norm of Hamiltonian)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# grid_search\n",
+    "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search)\n",
+    "print('grid_search step:', step_grid)\n",
+    "# hyperopt\n",
+    "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt, max_evals=100, step_max=0.6)\n",
+    "print('hyperopt_search step:', step_hyperopt)\n",
+    "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, n=5)\n",
+    "print('polynomial_approximation step:', step_poly)\n",
+    "step_sa = dbi.choose_step(scheduling=DoubleBracketScheduling.simulated_annealing)\n",
+    "print('simulated_annealing step:', step_sa)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the results\n",
+    "plt.plot(s_space, off_diagonal_norm_diff)\n",
+    "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n",
+    "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n",
+    "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n",
+    "plt.axvline(x=step_sa, color='b', linestyle=':',label='simulated annealing')\n",
+    "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n",
+    "plt.xlabel('s')\n",
+    "plt.title('First DBI step')\n",
+    "plt.legend()\n",
+    "print('The minimum for cost function in the tested range is:', step_grid)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Specified diagonal operator\n",
+    "\n",
+    "While for the cannonical case, all the scheduling methods are accurate, it is important to realize that the global minimum of the loss function is not always so obvious. It is thus necessary to show whether the 3 converges to an agreeable step duration using different iteration generators, such as the Pauli 'ZZ..Z' operator and 'ZZ..I' operator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate the digaonal operators\n",
+    "Z_str = \"Z\"*nqubits\n",
+    "ZI_str = \"Z\"*(nqubits-1)+\"I\"\n",
+    "Z_op = SymbolicHamiltonian(str_to_symbolic(Z_str)).dense.matrix\n",
+    "ZI_op = SymbolicHamiltonian(str_to_symbolic(ZI_str)).dense.matrix\n",
+    "op_dict = {Z_str:Z_op, ZI_str: ZI_op}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n",
+    "d_str = ZI_str\n",
+    "d = op_dict[d_str]\n",
+    "# generate data for plotting sigma decrease of the first step\n",
+    "s_space = np.linspace(1e-5, 0.6, 100)\n",
+    "off_diagonal_norm_diff = []\n",
+    "for s in s_space:\n",
+    "    dbi_eval = deepcopy(dbi)\n",
+    "    dbi_eval(s,d=d)\n",
+    "    off_diagonal_norm_diff.append(dbi_eval.off_diagonal_norm - dbi.off_diagonal_norm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# grid_search\n",
+    "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_max=0.6, d=d)\n",
+    "grid_min = dbi.loss(step=step_grid, d=d)-dbi.off_diagonal_norm\n",
+    "print('grid_search step:', step_grid, 'loss', grid_min)\n",
+    "# hyperopt\n",
+    "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt, d=d, max_evals=100, step_max=0.6)\n",
+    "hyperopt_min = dbi.loss(step=step_hyperopt, d=d)-dbi.off_diagonal_norm\n",
+    "print('hyperopt_search step:', step_hyperopt, 'loss', hyperopt_min)\n",
+    "# polynomial expansion\n",
+    "step_poly = dbi.choose_step(scheduling=DoubleBracketScheduling.polynomial_approximation, d=d, n=5)\n",
+    "poly_min = dbi.loss(step=step_poly, d=d)-dbi.off_diagonal_norm\n",
+    "print('polynomial_approximation step:', step_poly, 'loss', poly_min)\n",
+    "# simulated annealing\n",
+    "step_sa = dbi.choose_step(scheduling=DoubleBracketScheduling.simulated_annealing, d=d)\n",
+    "sa_min = dbi.loss(step=step_sa, d=d)-dbi.off_diagonal_norm\n",
+    "print('simulated_annealing step:', step_sa, 'loss', sa_min)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the results\n",
+    "plt.plot(s_space, off_diagonal_norm_diff)\n",
+    "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n",
+    "plt.text(x=step_grid, y=grid_min, s=f'grid min \\n{round(grid_min,3)}')\n",
+    "plt.text(x=step_poly, y=poly_min, s=f'poly min \\n{round(poly_min,3)}')\n",
+    "plt.text(x=step_sa, y=sa_min, s=f'sa min \\n{round(sa_min,3)}')\n",
+    "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n",
+    "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n",
+    "plt.axvline(x=step_sa, color='b', linestyle=':',label='simulated annealing')\n",
+    "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n",
+    "plt.xlabel('s')\n",
+    "plt.title(f'First DBI step with D={d_str}')\n",
+    "plt.legend()\n",
+    "print('The minimum for cost function in the tested range is:', step_grid)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We see that there are two similar \"minimal point\" at 0.03 and 0.22, with the latter being the absolute minimum by an insignificant advantage. However, for practical reasons, we prefer taking the first close-minimum calculated by polynomial approximation. Hence, we can use the polynomial approximation to restrict the search area and obtain better results. For example, we define a search range of 0.1 around the polynomial step."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Use polynomial expansion as an restriction for hyperopt/grid range"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search_range = 0.1\n",
+    "if step_poly < search_range/2:\n",
+    "    step_min = 0\n",
+    "    step_max = search_range\n",
+    "else:\n",
+    "    step_min = step_poly - search_range/2\n",
+    "    step_max = step_poly + search_range/2\n",
+    "# grid_search\n",
+    "step_grid = dbi.choose_step(scheduling=DoubleBracketScheduling.grid_search, step_min=step_min, step_max=step_max, d=d)\n",
+    "print('grid_search step:', step_grid)\n",
+    "# hyperopt\n",
+    "step_hyperopt = dbi.choose_step(scheduling=DoubleBracketScheduling.hyperopt, step_min=step_min, step_max=step_max, max_evals=100, d=d,)\n",
+    "print('hyperopt_search step:', step_hyperopt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot the results\n",
+    "plt.plot(s_space, off_diagonal_norm_diff)\n",
+    "plt.axvline(x=step_grid, color='r', linestyle='-',label='grid_search')\n",
+    "plt.axvline(x=step_hyperopt, color='g', linestyle='--',label='hyperopt')\n",
+    "plt.axvline(x=step_poly, color='m', linestyle='-.',label='polynomial')\n",
+    "plt.ylabel(r'$||\\sigma(H_0)||-\\sigma(H_k)||$')\n",
+    "plt.xlabel('s')\n",
+    "plt.title(r'Restrict $s$ with polynomial')\n",
+    "plt.legend()\n",
+    "print('The minimum for cost function in the tested range is:', step_grid)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Hence, we see that the strategy is indeed effective for finding the first minimum of the loss funciton for both the Z operator and the ZI operator."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Compare in Pauli-Z strategy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qibo.quantum_info import random_hermitian\n",
+    "from qibo.hamiltonians import Hamiltonian"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"qibojit\", platform=\"numba\")\n",
+    "nqubits = 4\n",
+    "h0 = random_hermitian(2**nqubits)\n",
+    "\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(Hamiltonian(nqubits=nqubits, matrix=h0)),mode=DoubleBracketGeneratorType.single_commutator)\n",
+    "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "generate_local_Z = generate_Z_operators(nqubits)\n",
+    "Z_ops = list(generate_local_Z.values())\n",
+    "Z_names = list(generate_local_Z.keys())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "NSTEPS = 8\n",
+    "scheduling_list = [DoubleBracketScheduling.grid_search,\n",
+    "                   DoubleBracketScheduling.hyperopt,\n",
+    "                   DoubleBracketScheduling.polynomial_approximation,\n",
+    "                   DoubleBracketScheduling.simulated_annealing,]\n",
+    "scheduling_labels = ['grid search',\n",
+    "                     'hyperopt',\n",
+    "                     'polynomial',\n",
+    "                     'simulated_annealing']\n",
+    "Z_optimal_scheduling = []\n",
+    "s_scheduling = []\n",
+    "off_norm_scheduling =[]\n",
+    "for i,scheduling in enumerate(scheduling_list):\n",
+    "    # reinitialize\n",
+    "    dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=deepcopy(h0)), mode=DoubleBracketGeneratorType.single_commutator)\n",
+    "    Z_optimal = []\n",
+    "    # add in initial values for plotting\n",
+    "    off_diagonal_norm_history = [dbi.off_diagonal_norm]\n",
+    "    steps = [0]\n",
+    "    print(f'----------Scheduling {scheduling_labels[i]}----------')\n",
+    "    for _ in range(NSTEPS):\n",
+    "        dbi, idx, step, flip_sign = select_best_dbr_generator(dbi, Z_ops, scheduling=scheduling, compare_canonical=False)\n",
+    "        off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n",
+    "        steps.append(steps[-1]+step)\n",
+    "        if flip_sign < 0:\n",
+    "            Z_optimal.append('-' + Z_names[idx])\n",
+    "        else:\n",
+    "            Z_optimal.append(Z_names[idx])\n",
+    "        print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}, loss {dbi.off_diagonal_norm}\")\n",
+    "    Z_optimal_scheduling.append(Z_optimal)\n",
+    "    s_scheduling.append(steps)\n",
+    "    off_norm_scheduling.append(off_diagonal_norm_history)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure()\n",
+    "for i, scheduling in enumerate(scheduling_labels):\n",
+    "    plt.plot(s_scheduling[i], off_norm_scheduling[i], '-o', label=scheduling)\n",
+    "plt.xlabel(\"Step durations\")\n",
+    "plt.ylabel(\"Norm off-diagonal restriction\")\n",
+    "plt.title(\"Compare Variational Pauli-Z using different scheduling strategies\")\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## When polynomial approximation has no solution\n",
+    "\n",
+    "In some cases, the prescribed taylor expansion order `n` may not be sufficient to produce a meaningful step duration (real positive). In these cases, we rely on a backup scheduling method in `choose_step`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hamiltonian\n",
+    "set_backend(\"qibojit\", platform=\"numba\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 5\n",
+    "h = 3\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n",
+    "dbi.scheduling = DoubleBracketScheduling.polynomial_approximation\n",
+    "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For demonstration purposes, we let `n=1` which is a linear fit to the loss function. This results in no valid solutions and function `polynomial_step` returns `None`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for n in range (5):\n",
+    "    step = polynomial_step(dbi, n=n)\n",
+    "    print(n, step)\n",
+    "print(dbi.choose_step(n=1))"
+   ]
+  }
+ ],
+ "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.7"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "48caf7dabad7b721a854729228548373f17e53f40870080394d552284aea7c35"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/dbi/dbi_strategies_compare.ipynb b/examples/dbi/dbi_strategies_compare.ipynb
new file mode 100644
index 0000000000..54d7fe4dff
--- /dev/null
+++ b/examples/dbi/dbi_strategies_compare.ipynb
@@ -0,0 +1,467 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# DBI strategies comparison\n",
+    "\n",
+    "This notebook is a comparison of the so-far developed diagonalization strategies for DBI, including the canonical, Pauli-Z, and magnetic field strategies. On top of these, we also show case the use of invariant DBI generators such as 'BHMM'."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "from copy import deepcopy\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from qibo import hamiltonians, set_backend\n",
+    "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n",
+    "from qibo.quantum_info import random_hermitian\n",
+    "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration, DoubleBracketCostFunction\n",
+    "from qibo.models.dbi.utils import *\n",
+    "from qibo.models.dbi.utils_scheduling import *\n",
+    "from qibo.models.dbi.utils_strategies import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def visualize_matrix(matrix, title=\"\"):\n",
+    "    \"\"\"Visualize hamiltonian in a heatmap form.\"\"\"\n",
+    "    fig, ax = plt.subplots(figsize=(5,5))\n",
+    "    ax.set_title(title)\n",
+    "    try:\n",
+    "        im = ax.imshow(np.absolute(matrix), cmap=\"inferno\")\n",
+    "    except TypeError:\n",
+    "        im = ax.imshow(np.absolute(matrix.get()), cmap=\"inferno\")\n",
+    "    fig.colorbar(im, ax=ax)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test on random Hamiltonian\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# backend\n",
+    "set_backend(\"qibojit\", platform=\"numba\")\n",
+    "# initialize dbi object\n",
+    "nqubits = 5\n",
+    "h0 = random_hermitian(2**nqubits, seed=2)\n",
+    "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0))\n",
+    "cost = DoubleBracketCostFunction.off_diagonal_norm\n",
+    "print(\"Initial loss\", dbi.least_squares(d=dbi.diagonal_h_matrix))\n",
+    "visualize_matrix(dbi.h.matrix, title=f'Random hamiltonian with L={nqubits}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# iterations steps\n",
+    "NSTEPS = 15\n",
+    "# choose polynomial scheduling\n",
+    "scheduling = DoubleBracketScheduling.simulated_annealing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Canonical"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize DBI class for the canonical case\n",
+    "dbi_canonical = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.canonical, scheduling=scheduling, cost=cost)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Canonical\n",
+    "loss_history_canonical = [dbi_canonical.off_diagonal_norm]\n",
+    "steps_canonical_plot = [0]\n",
+    "for s in range(NSTEPS):\n",
+    "    # same settings as iteration from list\n",
+    "    d = dbi.diagonal_h_matrix\n",
+    "    step = dbi_canonical.choose_step(d=d)\n",
+    "    dbi_canonical(step=step)\n",
+    "    print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}, loss {dbi_canonical.off_diagonal_norm}\")\n",
+    "    loss_history_canonical.append(dbi_canonical.off_diagonal_norm)\n",
+    "    steps_canonical_plot.append(steps_canonical_plot[-1]+step)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Pauli-Z"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize DBI class for the Pauli-Z strategy\n",
+    "set_backend(\"pytorch\", platform=\"numba\")\n",
+    "dbi_pauli = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling, cost=cost)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "generate_local_Z = generate_Z_operators(nqubits)\n",
+    "Z_ops = list(generate_local_Z.values())\n",
+    "Z_names = list(generate_local_Z.keys())\n",
+    "Z_optimal = []\n",
+    "# add in initial values for plotting\n",
+    "loss_history_pauli = [dbi_pauli.off_diagonal_norm]\n",
+    "steps_pauli_plot = [0]\n",
+    "scheduling = DoubleBracketScheduling.simulated_annealing\n",
+    "for _ in range(NSTEPS):\n",
+    "    dbi_pauli, idx, step, flip_sign = select_best_dbr_generator(dbi_pauli, Z_ops, scheduling=scheduling, compare_canonical=False)\n",
+    "    d = Z_ops[idx]\n",
+    "    loss_history_pauli.append(dbi_pauli.off_diagonal_norm)\n",
+    "    steps_pauli_plot.append(steps_pauli_plot[-1]+step)\n",
+    "    if flip_sign < 0:\n",
+    "        Z_optimal.append('-' + Z_names[idx])\n",
+    "    else:\n",
+    "        Z_optimal.append(Z_names[idx])\n",
+    "    print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}, loss {dbi_pauli.off_diagonal_norm}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Magnetic field"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize DBI class for the canonical case\n",
+    "dbi_gradient = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling, cost=cost)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=2)\n",
+    "d_coef = decompose_into_Pauli_basis(dbi.h.matrix, list(pauli_operator_dict.values()))\n",
+    "d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loss_history_gradient = [dbi_gradient.off_diagonal_norm]\n",
+    "steps_gradient_plot= [0]\n",
+    "for _ in range(NSTEPS):\n",
+    "    step, d_coef, d = gradient_descent_pauli(dbi_gradient, d_coef, d, pauli_operator_dict=pauli_operator_dict)\n",
+    "    dbi_gradient(d=d,step=step)\n",
+    "    loss_history_gradient.append(dbi_gradient.off_diagonal_norm)\n",
+    "    print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with d_coef {d_coef}, loss {dbi_gradient.off_diagonal_norm}\")\n",
+    "    steps_gradient_plot.append(steps_gradient_plot[-1]+step)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.title(str(nqubits) + ' random Hamiltonian diagonalization')\n",
+    "plt.plot(loss_history_canonical, label='canonical')\n",
+    "plt.plot(loss_history_pauli, label='Pauli-Z')\n",
+    "plt.plot(loss_history_gradient, label='gradient')\n",
+    "plt.legend()\n",
+    "plt.xlabel('Iteration')\n",
+    "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.title(str(nqubits) + ' random Hamiltonian diagonalization')\n",
+    "plt.plot(steps_canonical_plot, loss_history_canonical, marker='o', label='canonical')\n",
+    "plt.plot(steps_pauli_plot, loss_history_pauli, marker='o', label='Pauli-Z')\n",
+    "plt.plot(steps_gradient_plot,loss_history_gradient, marker='o', label='gradient')\n",
+    "plt.legend()\n",
+    "plt.xlabel('Iteration')\n",
+    "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test on TFIM\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# backend\n",
+    "set_backend(\"qibojit\", platform=\"numba\")\n",
+    "# initialize dbi object\n",
+    "# hamiltonian parameters\n",
+    "# define the hamiltonian\n",
+    "nqubits = 5\n",
+    "h = 1\n",
+    "H_TFIM = SymbolicHamiltonian( - h*symbols.Z(nqubits-1), nqubits=nqubits)\n",
+    "# add linear interaction terms\n",
+    "for i in range(nqubits-1):\n",
+    "    H_TFIM -= SymbolicHamiltonian(symbols.X(i)*symbols.X(i+1) + h*symbols.Z(i), nqubits=nqubits)\n",
+    "H_TFIM = H_TFIM.dense\n",
+    "\n",
+    "# initialize class\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n",
+    "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)\n",
+    "visualize_matrix(dbi.h.matrix, title=f'Random hamiltonian with L={nqubits}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# iterations steps\n",
+    "NSTEPS = 15\n",
+    "# choose polynomial scheduling\n",
+    "scheduling = DoubleBracketScheduling.simulated_annealing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Canonical"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize DBI class for the canonical case\n",
+    "dbi_canonical = DoubleBracketIteration(deepcopy(H_TFIM), mode=DoubleBracketGeneratorType.canonical, scheduling=scheduling)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Canonical\n",
+    "off_diagonal_norm_history_canonical = [dbi_canonical.off_diagonal_norm]\n",
+    "steps_canonical_plot = [0]\n",
+    "for s in range(NSTEPS):\n",
+    "    # same settings as iteration from list\n",
+    "    step = dbi_canonical.choose_step(d=dbi.diagonal_h_matrix)\n",
+    "    dbi_canonical(step=step)\n",
+    "    print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}, loss {dbi_canonical.off_diagonal_norm}\")\n",
+    "    off_diagonal_norm_history_canonical.append(dbi_canonical.off_diagonal_norm)\n",
+    "    steps_canonical_plot.append(steps_canonical_plot[-1]+step)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Pauli-Z"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize DBI class for the Pauli-Z strategy\n",
+    "dbi_pauli = DoubleBracketIteration(deepcopy(H_TFIM), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "generate_local_Z = generate_Z_operators(nqubits)\n",
+    "Z_ops = list(generate_local_Z.values())\n",
+    "Z_names = list(generate_local_Z.keys())\n",
+    "Z_optimal = []\n",
+    "# add in initial values for plotting\n",
+    "off_diagonal_norm_history_pauli = [dbi_pauli.off_diagonal_norm]\n",
+    "steps_pauli_plot = [0]\n",
+    "scheduling = DoubleBracketScheduling.simulated_annealing\n",
+    "for _ in range(NSTEPS):\n",
+    "    dbi_pauli, idx, step, flip_sign = select_best_dbr_generator(dbi_pauli, Z_ops, scheduling=scheduling, compare_canonical=False)\n",
+    "    off_diagonal_norm_history_pauli.append(dbi_pauli.off_diagonal_norm)\n",
+    "    steps_pauli_plot.append(steps_pauli_plot[-1]+step)\n",
+    "    if flip_sign < 0:\n",
+    "        Z_optimal.append('-' + Z_names[idx])\n",
+    "    else:\n",
+    "        Z_optimal.append(Z_names[idx])\n",
+    "    print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}, loss {dbi_pauli.off_diagonal_norm}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Magnetic field"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize DBI class for the canonical case\n",
+    "dbi_gradient = DoubleBracketIteration(deepcopy(H_TFIM), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=2)\n",
+    "d_coef = decompose_into_Pauli_basis(dbi.h.matrix, list(pauli_operator_dict.values()))\n",
+    "d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "initial_s = polynomial_step(dbi_object=dbi, d=d, n=4)\n",
+    "print(initial_s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "off_diagonal_norm_history_gradient = [dbi_gradient.off_diagonal_norm]\n",
+    "steps_gradient_plot= [0]\n",
+    "for _ in range(NSTEPS):\n",
+    "    step, d_coef, d = gradient_descent_pauli(dbi_gradient, d_coef, d, pauli_operator_dict=pauli_operator_dict)\n",
+    "    dbi_gradient(d=d,step=step)\n",
+    "    off_diagonal_norm_history_gradient.append(dbi_gradient.off_diagonal_norm)\n",
+    "    print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with d_coef {d_coef}, loss {dbi_gradient.off_diagonal_norm}\")\n",
+    "    steps_gradient_plot.append(steps_gradient_plot[-1]+step)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.title(str(nqubits) + ' random Hamiltonian diagonalization')\n",
+    "plt.plot(off_diagonal_norm_history_canonical, label='canonical', marker='o')\n",
+    "plt.plot(off_diagonal_norm_history_pauli, label='Pauli-Z', marker='o')\n",
+    "plt.plot(off_diagonal_norm_history_gradient, label='gradient', marker='o')\n",
+    "plt.legend()\n",
+    "plt.xlabel('Iteration')\n",
+    "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.title(str(nqubits) + ' random Hamiltonian diagonalization')\n",
+    "plt.plot(steps_canonical_plot, off_diagonal_norm_history_canonical, marker='o', label='canonical')\n",
+    "plt.plot(steps_pauli_plot, off_diagonal_norm_history_pauli, marker='o', label='Pauli-Z')\n",
+    "plt.plot(steps_gradient_plot,off_diagonal_norm_history_gradient, marker='o', label='gradient')\n",
+    "plt.legend()\n",
+    "plt.xlabel('Duration')\n",
+    "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "DBF_qibo",
+   "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.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/dbi/dbi_strategy_Ising_model.ipynb b/examples/dbi/dbi_strategy_Ising_model.ipynb
new file mode 100644
index 0000000000..ad3b1b5d73
--- /dev/null
+++ b/examples/dbi/dbi_strategy_Ising_model.ipynb
@@ -0,0 +1,368 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Double-Bracket Iteration Strategy: magnetic field (Ising model)\n",
+    "This notebook shows the diagonalization process of DBI using the magnetic field strategy, which varies the diagonal operator $D$ by gradient descent. To find the gradient with respect to $D$, parameterization of $D$ is required. For the purpose of this notebook, we represent it by the Ising model, i.e.\n",
+    "\n",
+    "$$ D = \\sum \\alpha_i Z_i +\\sum \\beta_{ij}Z_iZ_j$$\n",
+    "\n",
+    "\n",
+    "The gradients are calculated under the premise that the diagonalization gain curve can be fitted by a polynomial, and that the iteration step duration is taken at the first dip of the curve."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from copy import deepcopy\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from qibo import hamiltonians, set_backend\n",
+    "from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian\n",
+    "from qibo.quantum_info import random_hermitian\n",
+    "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketScheduling, DoubleBracketIteration\n",
+    "from qibo.models.dbi.utils import *\n",
+    "from qibo.models.dbi.utils_strategies import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def visualize_matrix(matrix, title=\"\"):\n",
+    "    \"\"\"Visualize hamiltonian in a heatmap form.\"\"\"\n",
+    "    fig, ax = plt.subplots(figsize=(5,5))\n",
+    "    ax.set_title(title)\n",
+    "    try:\n",
+    "        im = ax.imshow(np.absolute(matrix), cmap=\"inferno\")\n",
+    "    except TypeError:\n",
+    "        im = ax.imshow(np.absolute(matrix.get()), cmap=\"inferno\")\n",
+    "    fig.colorbar(im, ax=ax)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test on random Hamiltonian"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# backend\n",
+    "set_backend(\"qibojit\", platform=\"numba\")\n",
+    "# initialize dbi object\n",
+    "nqubits = 5\n",
+    "h0 = random_hermitian(2**nqubits, seed=2)\n",
+    "scheduling = DoubleBracketScheduling.hyperopt\n",
+    "mode = DoubleBracketGeneratorType.single_commutator\n",
+    "n_taylor = 5\n",
+    "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)\n",
+    "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)\n",
+    "visualize_matrix(dbi.h.matrix, title=f'Random hamiltonian with L={nqubits}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Order 1: $D=\\sum \\alpha_iZ_i$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# generate pauli_operator_dict\n",
+    "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=1)\n",
+    "d_coef = decompose_into_Pauli_basis(dbi.h.matrix, list(pauli_operator_dict.values()))\n",
+    "d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])\n",
+    "grad, s = gradient_Pauli(dbi, d=d, pauli_operator_dict=pauli_operator_dict)\n",
+    "print('The initial D coefficients:', d_coef)\n",
+    "print('Gradient:', grad)\n",
+    "print('s:', s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "iters = 15\n",
+    "off_diagonal_norm_1 = [dbi.off_diagonal_norm]\n",
+    "s_step = [0]\n",
+    "for i in range(iters):\n",
+    "    s, d_coef, d = gradient_descent_pauli(dbi, d_coef=d_coef, d=d, pauli_operator_dict=pauli_operator_dict, max_evals=100)\n",
+    "    dbi(step=s, d=d)\n",
+    "    off_diagonal_norm_1.append(dbi.off_diagonal_norm)\n",
+    "    s_step.append(s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.title(str(nqubits) + ' spins random hamiltonian')\n",
+    "plt.plot(off_diagonal_norm_1)\n",
+    "plt.xlabel('Iteration')\n",
+    "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Order 2: $D=\\sum \\alpha_iZ_i + \\beta_{ij}Z_iZ_j$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0), scheduling=scheduling, mode=mode)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# generate pauli_operator_dict\n",
+    "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=2)\n",
+    "d_coef = decompose_into_Pauli_basis(dbi.h.matrix, list(pauli_operator_dict.values()))\n",
+    "d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])\n",
+    "grad, s = gradient_Pauli(dbi, d=d, pauli_operator_dict=pauli_operator_dict)\n",
+    "print('The initial D coefficients:', d_coef)\n",
+    "print('Gradient:', grad)\n",
+    "print('s:', s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "iters = 15\n",
+    "off_diagonal_norm_2 = [dbi.off_diagonal_norm]\n",
+    "s_step = [0]\n",
+    "for i in range(iters):\n",
+    "    s, d_coef, d = gradient_descent_pauli(dbi, d_coef=d_coef, d=d, pauli_operator_dict=pauli_operator_dict, max_evals=100)\n",
+    "    dbi(step=s, d=d)\n",
+    "    off_diagonal_norm_2.append(dbi.off_diagonal_norm)\n",
+    "    s_step.append(s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.title(str(nqubits) + ' spins random hamiltonian')\n",
+    "plt.plot(off_diagonal_norm_1, label='order 1')\n",
+    "plt.plot(off_diagonal_norm_2, label='order 2')\n",
+    "plt.legend()\n",
+    "plt.xlabel('Iteration')\n",
+    "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test on TFIM\n",
+    "Here we choose to customize our TFIM in the X axis using `SymbolicHamiltonian`. It is also possible to use Hadamard gate to rotate the TFIM inbuilt in `qibo`.\n",
+    "\n",
+    "$$ H = -(\\sum X_i X_{i+1} + \\sum hZ_i)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# generate the Hamiltonian\n",
+    "nqubits = 5\n",
+    "h = 1\n",
+    "H_TFIM = SymbolicHamiltonian( - h*symbols.Z(nqubits-1), nqubits=nqubits)\n",
+    "# add linear interaction terms\n",
+    "for i in range(nqubits-1):\n",
+    "    H_TFIM -= SymbolicHamiltonian(symbols.X(i)*symbols.X(i+1) + h*symbols.Z(i), nqubits=nqubits)\n",
+    "H_TFIM = H_TFIM.dense\n",
+    "visualize_matrix(H_TFIM.matrix, title=f'TFIM with L={nqubits} h={h}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# backend\n",
+    "set_backend(\"qibojit\", platform=\"numba\")\n",
+    "# initialize dbi object\n",
+    "dbi_TFIM = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Order 1: $D=\\sum \\alpha_iZ_i$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbi_TFIM_1 = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)\n",
+    "# generate pauli_operator_dict\n",
+    "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=1)\n",
+    "d_coef = decompose_into_Pauli_basis(dbi_TFIM_1.h.matrix, list(pauli_operator_dict.values()))\n",
+    "d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])\n",
+    "grad, s = gradient_Pauli(dbi_TFIM_1, d=d, pauli_operator_dict=pauli_operator_dict)\n",
+    "print('The initial D coefficients:', d_coef)\n",
+    "print('Gradient:', grad)\n",
+    "print('s:', s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "NSTEPS = 15\n",
+    "off_diagonal_norm_1 = [dbi_TFIM_1.off_diagonal_norm]\n",
+    "s_step = [0]\n",
+    "for i in range(NSTEPS):\n",
+    "    s, d_coef, d = gradient_descent_pauli(dbi_TFIM_1, d_coef=d_coef, d=d, pauli_operator_dict=pauli_operator_dict, max_evals=100)\n",
+    "    dbi_TFIM_1(step=s, d=d)\n",
+    "    off_diagonal_norm_1.append(dbi_TFIM_1.off_diagonal_norm)\n",
+    "    s_step.append(s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.title(f'n={nqubits} h={h} TFIM, order=1')\n",
+    "plt.plot(off_diagonal_norm_1)\n",
+    "plt.xlabel('Iteration')\n",
+    "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# the final matrix\n",
+    "visualize_matrix(dbi_TFIM.h.matrix)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Order 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbi_TFIM_2 = DoubleBracketIteration(deepcopy(H_TFIM), scheduling=scheduling, mode=mode)\n",
+    "# generate pauli_operator_dict\n",
+    "pauli_operator_dict = generate_pauli_operator_dict(nqubits=nqubits, parameterization_order=2)\n",
+    "d_coef = decompose_into_Pauli_basis(dbi_TFIM_2.h.matrix, list(pauli_operator_dict.values()))\n",
+    "d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])\n",
+    "grad, s = gradient_Pauli(dbi_TFIM_2, d=d, pauli_operator_dict=pauli_operator_dict)\n",
+    "print('The initial D coefficients:', d_coef)\n",
+    "print('Gradient:', grad)\n",
+    "print('s:', s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "NSTEPS = 15\n",
+    "off_diagonal_norm_2 = [dbi_TFIM_2.off_diagonal_norm]\n",
+    "s_step = [0]\n",
+    "for i in range(NSTEPS):\n",
+    "    s, d_coef, d = gradient_descent_pauli(dbi_TFIM_2, d_coef=d_coef, d=d, pauli_operator_dict=pauli_operator_dict, max_evals=100)\n",
+    "    dbi_TFIM_2(step=s, d=d)\n",
+    "    off_diagonal_norm_2.append(dbi_TFIM_2.off_diagonal_norm)\n",
+    "    s_step.append(s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.title(f'n={nqubits} h={h} TFIM')\n",
+    "plt.plot(off_diagonal_norm_1, label='order 1')\n",
+    "plt.plot(off_diagonal_norm_2, label='order 2')\n",
+    "plt.legend()\n",
+    "plt.xlabel('Iteration')\n",
+    "plt.ylabel(r'$|| \\sigma(e^{sW}He^{-sW}) || $')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "DBF_qibo",
+   "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.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/dbi_strategy_Pauli-Z.ipynb
similarity index 94%
rename from examples/dbi/DBI_strategy_Pauli-Z_products.ipynb
rename to examples/dbi/dbi_strategy_Pauli-Z.ipynb
index 0f76a36245..2b60e12896 100644
--- a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb
+++ b/examples/dbi/dbi_strategy_Pauli-Z.ipynb
@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -40,7 +40,9 @@
     "\n",
     "from qibo import hamiltonians, set_backend\n",
     "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration\n",
-    "from qibo.models.dbi.utils import *"
+    "from qibo.models.dbi.utils import *\n",
+    "from qibo.models.dbi.utils_scheduling import *\n",
+    "from qibo.models.dbi.utils_strategies import *"
    ]
   },
   {
@@ -122,31 +124,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[Qibo 0.2.4|INFO|2024-01-24 19:59:31]: Using qibojit (numba) backend on /CPU:0\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Initial off diagonal norm 8.48528137423857\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# set the qibo backend (we suggest qibojit if N >= 20)\n",
     "# alternatives: tensorflow (not optimized), numpy (when CPU not supported by jit)\n",
     "set_backend(\"qibojit\", \"numba\")\n",
     "\n",
     "# hamiltonian parameters\n",
-    "nqubits = 2\n",
+    "nqubits = 5\n",
     "h = 3\n",
     "\n",
     "# define the hamiltonian\n",
@@ -160,20 +147,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[-2.-0.j -0.-0.j -0.-0.j -0.-0.j]\n",
-      " [-0.-0.j  2.-0.j -0.-0.j -0.-0.j]\n",
-      " [-0.-0.j -0.-0.j  2.-0.j -0.-0.j]\n",
-      " [-0.-0.j -0.-0.j -0.-0.j -2.-0.j]]\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "print(H_TFIM.matrix)"
    ]
@@ -219,8 +195,9 @@
     "# add in initial values for plotting\n",
     "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n",
     "steps = [0]\n",
+    "scheduling = DoubleBracketScheduling.use_hyperopt\n",
     "for _ in range(NSTEPS):\n",
-    "    dbi, idx, step, flip_sign = select_best_dbr_generator(dbi, Z_ops, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n",
+    "    dbi, idx, step, flip_sign = select_best_dbr_generator(dbi, Z_ops, scheduling=scheduling, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n",
     "    off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n",
     "    steps.append(steps[-1]+step)\n",
     "    if flip_sign < 0:\n",
@@ -294,7 +271,6 @@
     "        step_max = 1,\n",
     "        space = hp.uniform,\n",
     "        optimizer = tpe,\n",
-    "        max_evals = max_evals,\n",
     "    )\n",
     "    dbi_canonical(step=step)\n",
     "    print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}, loss {dbi_canonical.off_diagonal_norm}\")\n",
@@ -389,7 +365,7 @@
     "off_diagonal_norm_history_mixed = [dbi_mixed.off_diagonal_norm]\n",
     "steps = [0]\n",
     "for _ in range(NSTEPS):\n",
-    "    dbi_mixed, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed, Z_ops, compare_canonical=True, max_evals=max_evals)\n",
+    "    dbi_mixed, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed, Z_ops, scheduling=scheduling, compare_canonical=True, max_evals=max_evals, step_max=step_max)\n",
     "    off_diagonal_norm_history_mixed.append(dbi_mixed.off_diagonal_norm)\n",
     "    steps.append(steps[-1]+step)\n",
     "    if idx == len(Z_ops):\n",
@@ -479,7 +455,7 @@
     "remaining_NSTEPS = NSTEPS - cannonical_NSTEPS\n",
     "dbi_mixed_can.mode = DoubleBracketGeneratorType.single_commutator\n",
     "for _ in range(remaining_NSTEPS):\n",
-    "    dbi_mixed_can, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed_can, Z_ops, compare_canonical=False)\n",
+    "    dbi_mixed_can, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed_can, Z_ops, scheduling=scheduling, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n",
     "    off_diagonal_norm_history_mixed_can.append(dbi_mixed_can.off_diagonal_norm)\n",
     "    steps_mixed_can.append(step)\n",
     "    if idx == len(Z_ops):\n",
diff --git a/examples/dbi/extracting_dbi_circuits.ipynb b/examples/dbi/extracting_dbi_circuits.ipynb
new file mode 100644
index 0000000000..f281e4232a
--- /dev/null
+++ b/examples/dbi/extracting_dbi_circuits.ipynb
@@ -0,0 +1,3712 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2dae9ffe",
+   "metadata": {},
+   "source": [
+    "## This compares to DoubleBracketIteration whenever possible\n",
+    "\n",
+    "Note that we are not using the reduced group commutator so just 4 steps of the iteration using circuit representations uses quite a lot of time (several seconds)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b161521d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.7|INFO|2024-05-03 09:28:36]: Using numpy backend on /CPU:0\n"
+     ]
+    }
+   ],
+   "source": [
+    "import inspect\n",
+    "import sys\n",
+    "sys.path.append(\"../../tests\")\n",
+    "from test_models_dbi import *\n",
+    "def print_function_source_code( func ):\n",
+    "    out = inspect.getsourcelines(func)  \n",
+    "    from functools import reduce\n",
+    "    print(reduce(str.__add__, out[0]))\n",
+    "import qibo\n",
+    "backend = qibo.backends.construct_backend(\"numpy\")\n",
+    "qibo.set_backend(\"numpy\")\n",
+    "nqubits = 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "id": "d8eac22c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.7|WARNING|2024-05-03 09:52:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n",
+      "[Qibo 0.2.7|WARNING|2024-05-03 09:52:46]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n"
+     ]
+    }
+   ],
+   "source": [
+    "r=0.01\n",
+    "mode_evolution_oracle = EvolutionOracleType.hamiltonian_simulation\n",
+    "h_x = SymbolicHamiltonian(\n",
+    "        symbols.X(0)\n",
+    "    + symbols.Z(0) * symbols.X(1)\n",
+    "    + symbols.Y(2)\n",
+    "    + symbols.Y(1) * symbols.Y(2),\n",
+    "nqubits=3,\n",
+    ")\n",
+    "d_0 = SymbolicHamiltonian(symbols.Z(0), nqubits=3)\n",
+    "h_input = h_x + d_0\n",
+    "\n",
+    "dbi = DoubleBracketIteration(deepcopy(h_input.dense))\n",
+    "\n",
+    "evolution_oracle = EvolutionOracle(h_input, \"ZX\", mode_evolution_oracle)   \n",
+    "gci = GroupCommutatorIterationWithEvolutionOracles( deepcopy(evolution_oracle ))\n",
+    "gci.mode_double_bracket_rotation = DoubleBracketRotationType.group_commutator_reduced\n",
+    "evolution_oracle_diagonal_target =  EvolutionOracle(d_0, \"D0\",\n",
+    "   mode_evolution_oracle)\n",
+    "evolution_oracle.eps_trottersuzuki = 1e-1\n",
+    "from numpy.linalg import norm\n",
+    "\n",
+    "for _ in range(4):\n",
+    "    dbi(r, d = d_0.dense.matrix, mode = DoubleBracketGeneratorType.group_commutator )\n",
+    "    gci(r, diagonal_association= evolution_oracle_diagonal_target )\n",
+    "\n",
+    "k_r = dbi.h.matrix\n",
+    "j_r = gci.h.matrix\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "id": "cad5fe99",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "u = gci.iterated_hamiltonian_evolution_oracle.get_composed_circuit()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "id": "e6bebcb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "q = u.queue"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "id": "efa7f839",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n",
+      "Unitary\n"
+     ]
+    }
+   ],
+   "source": [
+    "for g in q:\n",
+    "    print(g.name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 109,
+   "id": "c8eded43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "it = 0\n",
+    "for g in u.queue:\n",
+    "    if g.matrix().shape[0] == 4:\n",
+    "        it = it+1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 110,
+   "id": "6a1bd68f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1932"
+      ]
+     },
+     "execution_count": 110,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "it"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 111,
+   "id": "1d8388e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "h0 = h_input.dense.matrix\n",
+    "h_end = u.unitary().conj().T @ h0 @ u.unitary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 112,
+   "id": "fc364e18",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.0011754492342204688"
+      ]
+     },
+     "execution_count": 112,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "norm(h_end - dbi.h.matrix)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "14dbec14",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gci.input_hamiltonian_evolution_oracle.eps_trottersuzuki"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dfce7a1b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "norm(h_end - dbi.h.matrix)/gci.input_hamiltonian_evolution_oracle.eps_trottersuzuki"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e3459bcb",
+   "metadata": {},
+   "source": [
+    "We conclude that this is fine. Feel free to change to the numerical mode where the error will start piling up merely from the floating point operations and will build up from the double digit precision."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a9ea4c1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "c= qibo.Circuit(nqubits=4)\n",
+    "c.add(gates.CNOT(1,3))\n",
+    "c.add(gates.Z(2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5dc9d7fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "g = c.queue[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "3a39c34c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(3,)"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "g.target_qubits"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "7d4ffd2a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<qibo.gates.gates.CNOT at 0x7fc55a0bf250>"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "g"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "eea836f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'TNS' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_44195/2756981244.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mg\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mqueue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mqibo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgates\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgates\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCNOT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m         \u001b[0mTNS\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_CNOT\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget_qubits\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontrol_qubits\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'TNS' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "for g in c.queue:\n",
+    "    if isinstance(g,qibo.gates.gates.CNOT):\n",
+    "        TNS.apply_CNOT(g.target_qubits,g.control_qubits)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "400168cb",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/qibo/models/dbi/double_bracket_evolution_oracles.py b/src/qibo/models/dbi/double_bracket_evolution_oracles.py
new file mode 100644
index 0000000000..95bf5e0250
--- /dev/null
+++ b/src/qibo/models/dbi/double_bracket_evolution_oracles.py
@@ -0,0 +1,168 @@
+from enum import Enum, auto
+
+import hyperopt
+import numpy as np
+
+from qibo import Circuit
+from qibo.config import raise_error
+from qibo.hamiltonians import AbstractHamiltonian, SymbolicHamiltonian
+
+
+class EvolutionOracleType(Enum):
+    text_strings = auto()
+    """If you only want to get a sequence of names of the oracle"""
+
+    numerical = auto()
+    """If you will work with exp(is_k J_k) as a numerical matrix"""
+
+    hamiltonian_simulation = auto()
+    """If you will use SymbolicHamiltonian"""
+
+
+class EvolutionOracle:
+    def __init__(
+        self,
+        h_generator: AbstractHamiltonian,
+        name,
+        mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.text_strings,
+    ):
+        if (
+            mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation
+            and type(h_generator) is not SymbolicHamiltonian
+        ):
+            raise_error(
+                TypeError,
+                "If the evolution oracle mode will be to make Trotter-Suzuki decompositions then you must use the SymbolicHamiltonian generator",
+            )
+        if h_generator is None and name is None:
+            raise_error(
+                NotImplementedError,
+                "You have to specify either a matrix and then work in the numerical mode, or SymbolicHamiltonian and work in hamiltonian_simulation mode or at least a name and work with text_strings to list DBI query lists",
+            )
+
+        self.h = h_generator
+        self.name = name
+        self.mode_evolution_oracle = mode_evolution_oracle
+        self.mode_find_number_of_trottersuzuki_steps = True
+        self.eps_trottersuzuki = 0.0001
+        self.please_be_verbose = False
+
+    def __call__(self, t_duration: float):
+        """Returns either the name or the circuit"""
+        return self.circuit(t_duration=t_duration)
+
+    def eval_unitary(self, t_duration):
+        """This wraps around `circuit` and always returns a unitary"""
+        if self.mode_evolution_oracle is EvolutionOracleType.numerical:
+            return self.circuit(t_duration)
+        elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation:
+            return self.circuit(t_duration).unitary()
+
+    def circuit(self, t_duration: float = None):
+        """This function returns depending on `EvolutionOracleType` string, ndarray or `Circuit`.
+        In the hamiltonian_simulation mode we evaluate an appropriate Trotter-Suzuki discretization up to `self.eps_trottersuzuki` threshold.
+        """
+        if self.mode_evolution_oracle is EvolutionOracleType.text_strings:
+            return self.name + str(t_duration)
+        elif self.mode_evolution_oracle is EvolutionOracleType.numerical:
+            return self.h.exp(t_duration)
+        elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation:
+            return self.discretized_evolution_circuit_binary_search(
+                t_duration, eps=self.eps_trottersuzuki
+            )
+
+    def discretized_evolution_circuit_binary_search(self, t_duration, eps=None):
+        nmb_trottersuzuki_steps = 1  # this is the smallest size
+        nmb_trottersuzki_steps_right = 800  # this is the largest size for binary search
+        if eps is None:
+            eps = self.eps_trottersuzuki
+        target_unitary = self.h.exp(t_duration)
+
+        from copy import deepcopy
+
+        def check_accuracy(n_steps):
+            proposed_circuit_unitary = np.linalg.matrix_power(
+                deepcopy(self.h).circuit(t_duration / n_steps).unitary(),
+                n_steps,
+            )
+            norm_difference = np.linalg.norm(target_unitary - proposed_circuit_unitary)
+            return norm_difference < eps
+
+        nmb_trottersuzuki_steps_used = nmb_trottersuzki_steps_right
+        while nmb_trottersuzuki_steps <= nmb_trottersuzki_steps_right:
+            mid = (
+                nmb_trottersuzuki_steps
+                + (nmb_trottersuzki_steps_right - nmb_trottersuzuki_steps) // 2
+            )
+            if check_accuracy(mid):
+                nmb_trottersuzuki_steps_used = mid
+                nmb_trottersuzki_steps_right = mid - 1
+            else:
+                nmb_trottersuzuki_steps = mid + 1
+        nmb_trottersuzuki_steps = nmb_trottersuzuki_steps_used
+
+        from functools import reduce
+
+        circuit_1_step = deepcopy(self.h.circuit(t_duration / nmb_trottersuzuki_steps))
+        combined_circuit = reduce(
+            Circuit.__add__, [circuit_1_step] * nmb_trottersuzuki_steps
+        )
+        assert (
+            np.linalg.norm(combined_circuit.unitary() - target_unitary) < eps
+        ), f"{np.linalg.norm(combined_circuit.unitary() - target_unitary)},{eps}, {nmb_trottersuzuki_steps}"
+        return combined_circuit
+
+
+class FrameShiftedEvolutionOracle(EvolutionOracle):
+    def __init__(
+        self,
+        base_evolution_oracle: EvolutionOracle,
+        name,
+        before_circuit,
+        after_circuit,
+    ):
+
+        assert isinstance(before_circuit, type(after_circuit))
+
+        self.h = base_evolution_oracle.h
+        self.base_evolution_oracle = base_evolution_oracle
+        self.name = name + "(" + base_evolution_oracle.name + ")"
+        self.mode_evolution_oracle = base_evolution_oracle.mode_evolution_oracle
+        self.before_circuit = before_circuit
+        self.after_circuit = after_circuit
+
+    def circuit(self, t_duration: float = None):
+
+        if self.mode_evolution_oracle is EvolutionOracleType.text_strings:
+            return self.name + "(" + str(t_duration) + ")"
+        elif self.mode_evolution_oracle is EvolutionOracleType.numerical:
+            return (
+                self.before_circuit
+                @ self.base_evolution_oracle(t_duration)
+                @ self.after_circuit
+            )
+        elif self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation:
+
+            return (
+                self.after_circuit
+                + self.base_evolution_oracle.circuit(t_duration)
+                + self.before_circuit
+            )
+        else:
+            raise_error(
+                ValueError,
+                f"You are using an EvolutionOracle type which is not yet supported.",
+            )
+
+    def get_composed_circuit(self):
+        c = self.circuit(0)
+        fseo = self
+        while isinstance(fseo, FrameShiftedEvolutionOracle):
+            if self.mode_evolution_oracle is EvolutionOracleType.numerical:
+                c = fseo.after_circuit @ c
+            elif (
+                self.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation
+            ):
+                c = c + fseo.after_circuit
+            fseo = fseo.base_evolution_oracle
+        return c
diff --git a/src/qibo/models/dbi/group_commutator_iteration_transpiler.py b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py
new file mode 100644
index 0000000000..07fc1af4fb
--- /dev/null
+++ b/src/qibo/models/dbi/group_commutator_iteration_transpiler.py
@@ -0,0 +1,237 @@
+from enum import Enum, auto
+
+import hyperopt
+import numpy as np
+
+from qibo import *
+from qibo import symbols
+from qibo.config import raise_error
+from qibo.hamiltonians import Hamiltonian, SymbolicHamiltonian
+from qibo.models.dbi import *
+from qibo.models.dbi.double_bracket import *
+from qibo.models.dbi.double_bracket_evolution_oracles import *
+
+
+class DoubleBracketRotationType(Enum):
+    # The dbr types below need a diagonal input matrix $\hat D_k$   :
+
+    single_commutator = auto()
+    """Use single commutator."""
+
+    group_commutator = auto()
+    """Use group commutator approximation"""
+
+    group_commutator_reordered = auto()
+    """Use group commutator approximation with reordering of the operators"""
+
+    group_commutator_reduced = auto()
+    """Use group commutator approximation with a reduction using symmetry
+
+    """
+    ## Reserving for later development
+    exact_GWW = auto()
+    r""" $e^{-s [\Delta(H),H]}$"""
+    group_commutator_imperfect = auto()
+    """Use group commutator approximation"""
+
+    group_commutator_reduced_imperfect = auto()
+    """Use group commutator approximation:
+    symmetry of the Hamiltonian implies that with perfect reversion of the input evolution the first order needs less queries.
+    We extrapolate that symmetry to the imperfect reversal.
+    Note that while may not be performing a similarity operation on the generator of the double bracket iteration,
+    the unfolded operation applied to a state vector will still be unitary:
+
+    """
+
+
+class GroupCommutatorIterationWithEvolutionOracles(DoubleBracketIteration):
+    """
+    Class which will be later merged into the @super somehow"""
+
+    def __init__(
+        self,
+        input_hamiltonian_evolution_oracle: EvolutionOracle,
+        mode_double_bracket_rotation: DoubleBracketRotationType = DoubleBracketRotationType.group_commutator,
+        mode_evolution_oracle: EvolutionOracleType = EvolutionOracleType.numerical,
+    ):
+        if mode_double_bracket_rotation is DoubleBracketRotationType.single_commutator:
+            mode_double_bracket_rotation_old = (
+                DoubleBracketGeneratorType.single_commutator
+            )
+        else:
+            mode_double_bracket_rotation_old = (
+                DoubleBracketGeneratorType.group_commutator
+            )
+        super().__init__(
+            input_hamiltonian_evolution_oracle.h.dense, mode_double_bracket_rotation_old
+        )
+
+        self.input_hamiltonian_evolution_oracle = input_hamiltonian_evolution_oracle
+
+        self.mode_double_bracket_rotation = mode_double_bracket_rotation
+
+        self.gci_unitary = []
+        self.gci_unitary_dagger = []
+        self.iterated_hamiltonian_evolution_oracle = deepcopy(
+            self.input_hamiltonian_evolution_oracle
+        )
+
+    def __call__(
+        self,
+        step_duration: float,
+        diagonal_association: EvolutionOracle,
+        mode_dbr: DoubleBracketRotationType = None,
+    ):
+
+        # Set rotation type
+        if mode_dbr is None:
+            mode_dbr = self.mode_double_bracket_rotation
+
+        if mode_dbr is DoubleBracketRotationType.single_commutator:
+            raise_error(
+                ValueError,
+                "single_commutator DBR mode doesn't make sense with EvolutionOracle",
+            )
+
+        # This will run the appropriate group commutator step
+        double_bracket_rotation_step = self.group_commutator(
+            step_duration, diagonal_association, mode_dbr=mode_dbr
+        )
+
+        before_circuit = double_bracket_rotation_step["backwards"]
+        after_circuit = double_bracket_rotation_step["forwards"]
+
+        self.iterated_hamiltonian_evolution_oracle = FrameShiftedEvolutionOracle(
+            deepcopy(self.iterated_hamiltonian_evolution_oracle),
+            str(step_duration),
+            before_circuit,
+            after_circuit,
+        )
+
+        if (
+            self.input_hamiltonian_evolution_oracle.mode_evolution_oracle
+            is EvolutionOracleType.numerical
+        ):
+            self.h.matrix = before_circuit @ self.h.matrix @ after_circuit
+
+        elif (
+            self.input_hamiltonian_evolution_oracle.mode_evolution_oracle
+            is EvolutionOracleType.hamiltonian_simulation
+        ):
+
+            self.h.matrix = (
+                before_circuit.unitary() @ self.h.matrix @ after_circuit.unitary()
+            )
+
+        elif (
+            self.input_hamiltonian_evolution_oracle.mode_evolution_oracle
+            is EvolutionOracleType.text_strings
+        ):
+            raise_error(NotImplementedError)
+        else:
+            super().__call__(step_duration, diagonal_association.h.dense.matrix)
+
+    def eval_gcr_unitary(
+        self,
+        step_duration: float,
+        eo1: EvolutionOracle,
+        eo2: EvolutionOracle = None,
+        mode_dbr: DoubleBracketRotationType = None,
+    ):
+        u = self.group_commutator(step_duration, eo1, eo2, mode_dbr=mode_dbr)[
+            "forwards"
+        ]
+        if eo1.mode_evolution_oracle is EvolutionOracleType.hamiltonian_simulation:
+            return u.unitary()
+        elif eo1.mode_evolution_oracle is EvolutionOracleType.numerical:
+            return u
+
+    def group_commutator(
+        self,
+        t_step: float,
+        eo1: EvolutionOracle,
+        eo2: EvolutionOracle = None,
+        mode_dbr: DoubleBracketRotationType = None,
+    ):
+        s_step = np.sqrt(t_step)
+
+        if eo2 is None:
+            eo2 = self.iterated_hamiltonian_evolution_oracle
+
+        assert eo1.mode_evolution_oracle.value is eo2.mode_evolution_oracle.value
+
+        if mode_dbr is None:
+            gc_type = self.mode_double_bracket_rotation
+        else:
+            gc_type = mode_dbr
+
+        if gc_type is DoubleBracketRotationType.single_commutator:
+            raise_error(
+                ValueError,
+                "You are trying to get the group commutator query list but your dbr mode is single_commutator and not an approximation by means of a product formula!",
+            )
+
+        if gc_type is DoubleBracketRotationType.group_commutator:
+            query_list_forward = [
+                eo2.circuit(-s_step),
+                eo1.circuit(s_step),
+                eo2.circuit(s_step),
+                eo1.circuit(-s_step),
+            ]
+            query_list_backward = [
+                eo1.circuit(s_step),
+                eo2.circuit(-s_step),
+                eo1.circuit(-s_step),
+                eo2.circuit(s_step),
+            ]
+        elif gc_type is DoubleBracketRotationType.group_commutator_reordered:
+            query_list_forward = [
+                eo1.circuit(s_step),
+                eo2.circuit(-s_step),
+                eo1.circuit(-s_step),
+                eo2.circuit(s_step),
+            ]
+            query_list_backward = [
+                eo2.circuit(-s_step),
+                eo1.circuit(s_step),
+                eo2.circuit(s_step),
+                eo1.circuit(-s_step),
+            ]
+        elif gc_type is DoubleBracketRotationType.group_commutator_reduced:
+            query_list_forward = [
+                eo1.circuit(s_step),
+                eo2.circuit(s_step),
+                eo1.circuit(-s_step),
+            ]
+            query_list_backward = [
+                eo1.circuit(s_step),
+                eo2.circuit(-s_step),
+                eo1.circuit(-s_step),
+            ]
+
+        else:
+            raise_error(
+                ValueError,
+                "You are in the group commutator query list but your dbr mode is not recognized",
+            )
+
+        eo_mode = eo1.mode_evolution_oracle
+        from functools import reduce
+
+        if eo_mode is EvolutionOracleType.text_strings:
+            return {
+                "forwards": reduce(str.__add__, query_list_forward),
+                "backwards": reduce(str.__add__, query_list_backward),
+            }
+        elif eo_mode is EvolutionOracleType.hamiltonian_simulation:
+            return {
+                "forwards": reduce(Circuit.__add__, query_list_forward[::-1]),
+                "backwards": reduce(Circuit.__add__, query_list_backward[::-1]),
+            }
+        elif eo_mode is EvolutionOracleType.numerical:
+            return {
+                "forwards": reduce(np.ndarray.__matmul__, query_list_forward),
+                "backwards": reduce(np.ndarray.__matmul__, query_list_backward),
+            }
+        else:
+            raise_error(ValueError, "Your EvolutionOracleType is not recognized")
diff --git a/src/qibo/models/dbi/utils_analytical.py b/src/qibo/models/dbi/utils_analytical.py
new file mode 100644
index 0000000000..240003ee7e
--- /dev/null
+++ b/src/qibo/models/dbi/utils_analytical.py
@@ -0,0 +1,217 @@
+import math
+from typing import Optional
+
+import numpy as np
+
+from qibo.models.dbi.utils import commutator, covariance, variance
+
+
+def dGamma_di_Pauli(dbi_object, n: int, Z_i: np.array, d: np.array):
+    """Computes the derivatives $\frac{\\partial \\Gamma_n}{\\partial \alpha_i}$ where the diagonal operator $D=\\sum \alpha_i Z_i$.
+
+    Args:
+        dbi_object (DoubleBracketIteration): the target dbi object
+        n (int): the number of nested commutators in `Gamma`
+        i (int/tupple): the index of onsite-Z coefficient
+        d (np.array): the diagonal operator
+
+    Returns:
+        (list): [dGamma_0_di, dGamma_1_di, ..., dGamma_n_di]
+    """
+    nqubits = int(np.log2(dbi_object.h.matrix.shape[0]))
+    dGamma_di = [np.zeros((2**nqubits, 2**nqubits))] * (n + 1)
+    Gamma_list = dbi_object.generate_Gamma_list(n=n + 2, d=d)
+    W = dbi_object.commutator(dbi_object.backend.cast(d), dbi_object.h.matrix)
+    dW_di = dbi_object.commutator(dbi_object.backend.cast(Z_i), dbi_object.h.matrix)
+    for k in range(n + 1):
+        if k == 0:
+            continue
+        elif k == 1:
+            dGamma_di[k] = dW_di
+        else:
+            dGamma_di[k] = dbi_object.commutator(
+                dW_di, Gamma_list[k - 1]
+            ) + dbi_object.commutator(W, dGamma_di[k - 1])
+    return dGamma_di
+
+
+def ds_di_Pauli(
+    dbi_object,
+    d: np.array,
+    Z_i: np.array,
+    taylor_coef: Optional[list] = None,
+):
+    r"""Return the derivatives of the first 3 polynomial coefficients with respect to onsite Pauli-Z coefficients\
+        Args:
+            dbi_object (DoubleBracketIteration): the target dbi object
+            d (np.array): the diagonal operator
+            i (int): the index of onsite-Z coefficient
+            taylor_coef (list): coefficients of `s` in the taylor expansion of math:`\\frac{\\partial ||\sigma(e^{sW}He^{-sW})||^2}{\\partial s}`, from the highest order to the lowest.
+            onsite_Z_ops (list): onsite Z operators of `dbi_object.h`
+        Returns:
+            floats da, db, dc, ds
+    """
+    # generate the list of derivatives w.r.t ith Z operator coefficient
+    dGamma_di = dGamma_di_Pauli(dbi_object, n=4, Z_i=Z_i, d=d)
+    Gamma_list = dbi_object.generate_Gamma_list(n=4, d=d)
+
+    def derivative_product(k1, k2):
+        r"""Calculate the derivative of a product $\sigma(\Gamma(n1,i))@\sigma(\Gamma(n2,i))"""
+        return dbi_object.sigma(dGamma_di[k1]) @ dbi_object.sigma(
+            Gamma_list[k2]
+        ) + dbi_object.sigma(dbi_object.sigma(Gamma_list[k1])) @ dbi_object.sigma(
+            dGamma_di[k2]
+        )
+
+    # calculate the derivatives of s polynomial coefficients
+    da = np.trace(3 * derivative_product(1, 2) + 3 * derivative_product(3, 0))
+    db = np.trace(2 * derivative_product(1, 1) + 2 * derivative_product(0, 2))
+    dc = np.trace(2 * derivative_product(1, 0))
+
+    ds = 0
+    if taylor_coef != None:
+        a, b, c = taylor_coef[len(taylor_coef) - 3 :]
+        delta = b**2 - 4 * a * c
+        ddelta = 2 * (b * db - 2 * (a * dc + da * c))
+
+        ds = (-db + 0.5 * ddelta / np.sqrt(delta)) * a - (-b + np.sqrt(delta)) * da
+        ds /= 2 * a**2
+
+    return da, db, dc, ds
+
+
+def gradient_Pauli(
+    dbi_object,
+    d: np.array,
+    pauli_operator_dict: dict,
+    use_ds=False,
+    n=3,
+    **kwargs,
+):
+    r"""Calculate the gradient of loss function with respect to onsite Pauli-Z coefficients
+    Args:
+        dbi_object (DoubleBracketIteration): the target dbi object
+        d (np.array): the diagonal operator
+        n_taylor (int): the highest order of the taylore expansion of  w.r.t `s`
+        onsite_Z_ops (list): list of Pauli-Z operators
+        taylor_coef (list): coefficients of `s` in the taylor expansion of math:`\\frac{\\partial ||\sigma(e^{sW}He^{-sW})||^2}{\\partial s}`
+        use_ds (boolean): if False, ds is set to 0
+    """
+    # n is the highest order for calculating s
+
+    # pauli_index is the list of positions \mu
+    pauli_operators = list(pauli_operator_dict.values())
+    num_paul = len(pauli_operators)
+    grad = np.zeros(num_paul)
+    coef = off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n=n)
+    s = dbi_object.choose_step(
+        d=d,
+        **kwargs,
+    )
+
+    a, b, c = coef[len(coef) - 3 :]
+
+    for i, operator in enumerate(pauli_operators):
+        da, db, dc, ds = ds_di_Pauli(
+            dbi_object, d=d, Z_i=operator, taylor_coef=[a, b, c]
+        )
+        if use_ds is True:
+            ds = 0
+        grad[i] = (
+            s**3 / 3 * da
+            + s**2 / 2 * db
+            + 2 * s * dc
+            + s**2 * ds * a
+            + s * ds * b
+            + 2 * ds * c
+        )
+    grad = np.array(grad)
+    grad = grad / np.linalg.norm(grad)
+    return grad, s
+
+
+def dGamma_diDiagonal(d, H, n, i, dGamma, Gamma_list):
+    # Derivative of gamma with respect to diagonal elements of D (full-diagonal ansatz)
+    A = np.zeros(d.shape)
+    A[i, i] = 1
+    B = commutator(commutator(A, H), Gamma_list[n - 1])
+    W = commutator(d, H)
+    return B + commutator(W, dGamma[-1])
+
+
+def dpolynomial_diDiagonal(dbi_object, s, d, H, i):
+    # Derivative of polynomial approximation of potential function with respect to diagonal elements of d (full-diagonal ansatz)
+    # Formula can be expanded easily to any order, with n=3 corresponding to cubic approximation
+    derivative = 0
+    A = np.zeros(d.shape)
+    Gamma_list = dbi_object.generate_Gamma_list(4, d)
+    A[i, i] = 1
+    dGamma = [commutator(A, H)]
+    derivative += np.real(
+        np.trace(Gamma_list[0] @ A) + np.trace(dGamma[0] @ d + Gamma_list[1] @ A) * s
+    )
+    for n in range(2, 4):
+        dGamma.append(dGamma_diDiagonal(d, H, n, i, dGamma, Gamma_list))
+        derivative += np.real(
+            np.trace(dGamma[-1] @ d + Gamma_list[n] @ A) * s**n / math.factorial(n)
+        )
+
+    return derivative
+
+
+def off_diagonal_norm_polynomial_expansion_coef(dbi_object, d, n):
+    if d is None:
+        d = dbi_object.diagonal_h_matrix
+    # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H
+    W = dbi_object.commutator(
+        dbi_object.backend.cast(d), dbi_object.sigma(dbi_object.h.matrix)
+    )
+    Gamma_list = dbi_object.generate_Gamma_list(n + 2, d)
+    sigma_Gamma_list = list(map(dbi_object.sigma, Gamma_list))
+    exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)])
+    # coefficients for rotation with [W,H] and H
+    c1 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[1:]
+    c2 = exp_list.reshape((-1, 1, 1)) * sigma_Gamma_list[:-1]
+    # product coefficient
+    trace_coefficients = [0] * (2 * n + 1)
+    for k in range(n + 1):
+        for j in range(n + 1):
+            power = k + j
+            product_matrix = c1[k] @ c2[j]
+            trace_coefficients[power] += 2 * np.trace(product_matrix)
+    # coefficients from high to low (n:0)
+    coef = list(reversed(trace_coefficients[: n + 1]))
+    return coef
+
+
+def least_squares_polynomial_expansion_coef(dbi_object, d: np.array = None, n: int = 3):
+    if d is None:
+        d = dbi_object.diagonal_h_matrix
+    # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H
+    Gamma_list = dbi_object.generate_Gamma_list(n + 1, d)
+    exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)])
+    # coefficients
+    coef = np.empty(n)
+    for i in range(n):
+        coef[i] = np.real(exp_list[i] * np.trace(d @ Gamma_list[i + 1]))
+    coef = list(reversed(coef))
+    return coef
+
+
+def energy_fluctuation_polynomial_expansion_coef(
+    dbi_object, d: np.array = None, n: int = 3, state=0
+):
+    if d is None:
+        d = dbi_object.diagonal_h_matrix
+    # generate Gamma's where $\Gamma_{k+1}=[W, \Gamma_{k}], $\Gamma_0=H
+    Gamma_list = dbi_object.generate_Gamma_list(n + 1, d)
+    # coefficients
+    coef = np.empty(3)
+    coef[0] = np.real(2 * covariance(Gamma_list[0], Gamma_list[1], state))
+    coef[1] = np.real(2 * variance(Gamma_list[1], state))
+    coef[2] = np.real(
+        covariance(Gamma_list[0], Gamma_list[3], state)
+        + 3 * covariance(Gamma_list[1], Gamma_list[2], state)
+    )
+    coef = list(reversed(coef))
+    return coef
diff --git a/src/qibo/models/dbi/utils_gradients.py b/src/qibo/models/dbi/utils_gradients.py
new file mode 100644
index 0000000000..7790f3d2c5
--- /dev/null
+++ b/src/qibo/models/dbi/utils_gradients.py
@@ -0,0 +1,198 @@
+import math
+from copy import deepcopy
+from enum import Enum, auto
+
+import numpy as np
+
+from qibo import symbols
+from qibo.hamiltonians import SymbolicHamiltonian
+from qibo.models.dbi.utils import commutator
+from qibo.models.dbi.utils_scheduling import polynomial_step
+
+
+class d_ansatz_type(Enum):
+
+    element_wise = auto()
+    local_1 = auto()
+    # local_2 = auto() # for future implementation
+    # ising = auto() # for future implementation
+
+
+def d_ansatz(params: np.array, d_type: d_ansatz_type):
+    r"""
+    Creates the $D$ operator for the double-bracket iteration ansatz depending on the type of parameterization.
+    If $\alpha_i$ are our parameters and d the number of qubits then:
+
+    element_wise: $D = \sum_{i=0}^{2^d} \alpha_i |i\rangle \langle i|$
+    local_1: $D = \sum_{i=1}^{d} \alpha_i Z_i$
+    Args:
+        params(np.array): parameters for the ansatz.
+        d_type(d_ansatz type): type of parameterization for the ansatz.
+    """
+
+    if d_type is d_ansatz_type.element_wise:
+        d = np.zeros((len(params), len(params)))
+        for i in range(len(params)):
+            d[i, i] = params[i]
+
+    elif d_type is d_ansatz_type.local_1:
+
+        op_list = [params[i] * symbols.Z(i) for i in range(len(params))]
+        symbolHam = op_list[0]
+        for i in range(len(params) - 1):
+            symbolHam += op_list[i + 1]
+
+        d = SymbolicHamiltonian(symbolHam, nqubits=len(params))
+        d = d.dense.matrix
+    else:
+        raise ValueError(f"Parameterization type {type} not recognized.")
+
+    return d
+
+
+def dGamma_diDiagonal(d, h, n, i, dGamma, gamma_list):
+    r"""
+    Gradient of the nth gamma operator with respect to the ith diagonal elements of D.
+    $Gamma_{n} = [W,[W,...,[W,H]]...]]$,
+    $\frac{\partial Gamma_{n}}{\partial D_{ii}} = \partial_{D_{ii}} W\Gamma_{n-1}-\partial_{D_{ii}}\Gamma_{n-1} W$.
+    and thus is can be computed recursively.
+    Args:
+        d(np.array): D operator.
+        h(np.array): Hamiltonian.
+        n(int): nth Gamma operator.
+        i(int): Index of the diagonal element of D.
+        dGamma(list): List of the n-1 derivatives of the gamma operators (better to keep them in memory than to calculate at each iteration).
+        gamma_list(list): List of the n gamma operators.
+    Returns:
+        (float): Derivative of the nth gamma operator with respect to the ith diagonal elements of D.
+    """
+    dD_di = np.zeros(d.shape)
+    dD_di[i, i] = 1
+    dW_di = commutator(commutator(dD_di, h), gamma_list[n - 1])
+    w = commutator(d, h)
+    return dW_di + commutator(w, dGamma[-1])
+
+
+# def dpolynomial_diDiagonal(dbi_object, d, h, i): #element_wise_ansatz
+def derivative_scalar_product_dbr_approx_element_wise_ansatz(dbi_object, d, h, i):
+    r"""
+    TODO: add formula and explain terms
+    Gradient wrt the ith diagonal elements of D.
+    We make Double_bracket rotation with duration given by the minimzer of the ´polynomial_step´ function.
+    Gradient of the Taylor expansion of the least squares loss function as a function of $s$ the duration of Double-Bracket rotation element-wise ansatz:
+    $\partial_{D_{ii}} \text{Tr}(H_k@D) \approx \sum_{k=0}^{n} \frac{1}{k!!} \partial_{D_ii}\text{Tr}(\Gamma_{k}D)$.
+    Args:
+        dbi_object(DoubleBracketIteration): DoubleBracketIteration object.
+        d(np.array): D operator.
+        h(np.array): Hamiltonian.
+        i(int): Index of the diagonal element of D.
+    Returns:
+        derivative(float): Derivative of the polynomial expansion with respect to the ith diagonal elements of D.
+    """
+    derivative = 0
+    s = polynomial_step(dbi_object, n=3, d=d)
+    dD_di = np.zeros(d.shape)
+    gamma_list = dbi_object.generate_Gamma_list(4, d)
+    dD_di[i, i] = 1
+    dGamma = [commutator(dD_di, h)]
+    derivative += np.real(
+        np.trace(gamma_list[0] @ dD_di)
+        + np.trace(dGamma[0] @ d + gamma_list[1] @ dD_di) * s
+    )
+    for n in range(2, 4):
+        dGamma.append(dGamma_diDiagonal(d, h, n, i, dGamma, gamma_list))
+        derivative += np.real(
+            np.trace(dGamma[-1] @ d + gamma_list[n] @ dD_di) * s**n / math.factorial(n)
+        )
+
+    return derivative
+
+
+def gradientDiagonalEntries(
+    dbi_object, params, h, analytic=True, d_type=d_ansatz_type.element_wise, delta=1e-4
+):
+    r"""
+    Gradient of the DBI with respect to the parametrization of D. If analytic is True, the analytical gradient of the polynomial expansion of the DBI is used.
+    As the analytical gradient is applied on the polynomial expansion of the cost function, the numerical gradients may be more accurate.
+
+    Args:
+        dbi_object(DoubleBracketIteration): DoubleBracketIteration object.
+        params(np.array): Parameters for the ansatz (note that the dimension must be 2**nqubits for full ansazt and nqubits for Pauli ansatz).
+        h(np.array): Hamiltonian.
+        analytic(bool): If True, the gradient is calculated analytically, otherwise numerically.
+        d_type(d_ansatz_type): Ansatz used for the D operator. Options are 'Full' and '1-local'.
+        delta(float): Step size for numerical gradient.
+    Returns:
+        grad(np.array): Gradient of the D operator.
+    """
+
+    grad = np.zeros(len(params))
+    d = d_ansatz(params, d_type)
+    if analytic == True:
+        for i in range(len(params)):
+            derivative = derivative_scalar_product_dbr_approx_element_wise_ansatz(
+                dbi_object, d, h, i
+            )
+            grad[i] = d[i, i] - derivative
+    else:
+        for i in range(len(params)):
+            params_new = deepcopy(params)
+            params_new[i] += delta
+            d_new = d_ansatz(params_new, d_type)
+            grad[i] = (dbi_object.loss(0.0, d_new) - dbi_object.loss(0.0, d)) / delta
+    return grad
+
+
+def gradient_descent_dbr_d_ansatz(
+    dbi_object,
+    params,
+    nmb_iterations,
+    lr=1e-2,
+    analytic=True,
+    d_type=d_ansatz_type.element_wise,
+):
+    r"""
+    Optimizes the D operator using gradient descent evaluated at the at the rotaion angle found using the polynomial expansion.
+    - Declare variables
+    - Calculate initial loss
+    - Iterate, learning at each the optimal D and measure loss
+    - Return values
+    Args:
+        dbi_object(DoubleBracketIteration): DoubleBracketIteration object.
+        params(np.array): Initial parameters for the ansatz (note that the dimension must be 2**nqubits for full ansazt and nqubits for Pauli ansatz).
+        nmb_iterations(int): Number of gradient descent iterations.
+        lr(float): Learning rate.
+        analytic(bool): If True, the gradient is calculated analytically, otherwise numerically.
+        d_type(d_ansatz_type): Ansatz used for the D operator.
+    Returns:
+        d(np.array): Optimized D operator.
+        loss(np.array): Loss function evaluated at each iteration.
+        grad(np.array): Gradient evaluated at each iteration.
+        params_hist(np.array): Parameters evaluated at each iteration.
+    """
+
+    h = dbi_object.h.matrix
+    d = d_ansatz(params, d_type)
+    loss = np.zeros(nmb_iterations + 1)
+    grad = np.zeros((nmb_iterations, len(params)))
+    dbi_new = deepcopy(dbi_object)
+    s = polynomial_step(dbi_object, n=3, d=d)
+    dbi_new(s, d=d)
+    loss[0] = dbi_new.loss(0.0, d)
+    params_hist = np.empty((len(params), nmb_iterations + 1))
+    params_hist[:, 0] = params
+
+    for i in range(nmb_iterations):
+        dbi_new = deepcopy(dbi_object)
+        grad[i, :] = gradientDiagonalEntries(
+            dbi_object, params, h, analytic=analytic, d_type=d_type
+        )
+        for j in range(len(params)):
+            params[j] = params[j] - lr * grad[i, j]
+        d = d_ansatz(params, d_type)
+        s = polynomial_step(dbi_new, n=3, d=d)
+        dbi_new(s, d=d)
+        loss[i + 1] = dbi_new.loss(0.0, d=d)
+        params_hist[:, i + 1] = params
+
+    return d, loss, grad, params_hist
diff --git a/src/qibo/models/dbi/utils_scheduling.py b/src/qibo/models/dbi/utils_scheduling.py
new file mode 100644
index 0000000000..54c728e5f5
--- /dev/null
+++ b/src/qibo/models/dbi/utils_scheduling.py
@@ -0,0 +1,219 @@
+import math
+from functools import partial
+from typing import Optional
+
+import hyperopt
+import numpy as np
+
+from qibo.models.dbi.utils_analytical import (
+    energy_fluctuation_polynomial_expansion_coef,
+    least_squares_polynomial_expansion_coef,
+    off_diagonal_norm_polynomial_expansion_coef,
+)
+
+error = 1e-3
+
+
+def grid_search_step(
+    dbi_object,
+    step_min: float = 1e-5,
+    step_max: float = 1,
+    num_evals: int = 100,
+    space: Optional[np.array] = None,
+    d: Optional[np.array] = None,
+):
+    """
+    Greedy optimization of the iteration step.
+
+    Args:
+        step_min: lower bound of the search grid;
+        step_max: upper bound of the search grid;
+        mnum_evals: number of iterations between step_min and step_max;
+        d: diagonal operator for generating double-bracket iterations.
+
+    Returns:
+        (float): optimized best iteration step (minimizing off-diagonal norm).
+    """
+    if space is None:
+        space = np.linspace(step_min, step_max, num_evals)
+
+    if d is None:
+        d = dbi_object.diagonal_h_matrix
+
+    loss_list = [dbi_object.loss(step, d=d) for step in space]
+
+    idx_max_loss = np.argmin(loss_list)
+    return space[idx_max_loss]
+
+
+def hyperopt_step(
+    dbi_object,
+    step_min: float = 1e-5,
+    step_max: float = 1,
+    max_evals: int = 500,
+    space: callable = None,
+    optimizer: callable = None,
+    look_ahead: int = 1,
+    d: Optional[np.array] = None,
+):
+    """
+    Optimize iteration step using hyperopt.
+
+    Args:
+        step_min: lower bound of the search grid;
+        step_max: upper bound of the search grid;
+        max_evals: maximum number of iterations done by the hyperoptimizer;
+        space: see hyperopt.hp possibilities;
+        optimizer: see hyperopt algorithms;
+        look_ahead: number of iteration steps to compute the loss function;
+        d: diagonal operator for generating double-bracket iterations.
+
+    Returns:
+        (float): optimized best iteration step (minimizing loss function).
+    """
+    if space is None:
+        space = hyperopt.hp.uniform
+    if optimizer is None:
+        optimizer = hyperopt.tpe
+    if d is None:
+        d = dbi_object.diagonal_h_matrix
+
+    space = space("step", step_min, step_max)
+
+    best = hyperopt.fmin(
+        fn=partial(dbi_object.loss, d=d, look_ahead=look_ahead),
+        space=space,
+        algo=optimizer.suggest,
+        max_evals=max_evals,
+    )
+    return best["step"]
+
+
+def polynomial_step(
+    dbi_object,
+    n: int = 2,
+    n_max: int = 5,
+    d: np.array = None,
+    coef: Optional[list] = None,
+    cost=None,
+):
+    r"""
+    Optimizes iteration step by solving the n_th order polynomial expansion of the loss function.
+    e.g. $n=2$: $2\Trace(\sigma(\Gamma_1 + s\Gamma_2 + s^2/2\Gamma_3)\sigma(\Gamma_0 + s\Gamma_1 + s^2/2\Gamma_2))
+    Args:
+        n (int, optional): the order to which the loss function is expanded. Defaults to 4.
+        n_max (int, optional): maximum order allowed for recurring calls of `polynomial_step`. Defaults to 5.
+        d (np.array, optional): diagonal operator, default as $\delta(H)$.
+        backup_scheduling (`DoubleBracketScheduling`): the scheduling method to use in case no real positive roots are found.
+    """
+    if cost is None:
+        cost = dbi_object.cost
+
+    if d is None:
+        d = dbi_object.diagonal_h_matrix
+
+    if n > n_max:
+        raise ValueError(
+            "No solution can be found with polynomial approximation. Increase `n_max` or use other scheduling methods."
+        )
+    if coef is None:
+        coef = dbi_object.cost_expansion(d=d, n=n)
+    roots = np.roots(coef)
+    real_positive_roots = [
+        np.real(root) for root in roots if np.imag(root) < error and np.real(root) > 0
+    ]
+    # solution exists, return minimum s
+    if len(real_positive_roots) > 0:
+        sol = min(real_positive_roots)
+        for s in real_positive_roots:
+            if dbi_object.loss(s, d) < dbi_object.loss(sol, d):
+                sol = s
+        return sol
+    # solution does not exist, return None
+    else:
+        return None
+
+
+def simulated_annealing_step(
+    dbi_object,
+    d: Optional[np.array] = None,
+    initial_s=None,
+    step_min=1e-5,
+    step_max=1,
+    s_jump_range=None,
+    s_jump_range_divident=5,
+    initial_temp=1,
+    cooling_rate=0.85,
+    min_temp=1e-5,
+    max_iter=200,
+):
+    """
+    Perform a single step of simulated annealing optimization.
+
+    Parameters:
+        dbi_object: DBI object
+            The object representing the problem to be optimized.
+        d: Optional[np.array], optional
+            The diagonal matrix 'd' used in optimization. If None, it uses the diagonal
+            matrix 'diagonal_h_matrix' from dbi_object.
+        initial_s: float or None, optional
+            Initial value for 's', the step size. If None, it is initialized using
+            polynomial_step function with 'n=4'. If 'polynomial_step' returns None,
+            'initial_s' is set to 'step_min'.
+        step_min: float, optional
+            Minimum value for the step size 's'.
+        step_max: float, optional
+            Maximum value for the step size 's'.
+        s_jump_range: float or None, optional
+            Range for the random jump in step size. If None, it's calculated based on
+            'step_min', 'step_max', and 's_jump_range_divident'.
+        s_jump_range_divident: int, optional
+            Dividend to determine the range for random jump in step size.
+        initial_temp: float, optional
+            Initial temperature for simulated annealing.
+        cooling_rate: float, optional
+            Rate at which temperature decreases in simulated annealing.
+        min_temp: float, optional
+            Minimum temperature threshold for termination of simulated annealing.
+        max_iter: int, optional
+            Maximum number of iterations for simulated annealing.
+
+    Returns:
+        float:
+            The optimized step size 's'.
+    """
+
+    if d is None:
+        d = dbi_object.diagonal_h_matrix
+    if initial_s is None:
+        initial_s = polynomial_step(dbi_object=dbi_object, d=d, n=4)
+        if initial_s is None:
+            initial_s = step_min
+    if s_jump_range is None:
+        s_jump_range = (step_max - step_min) / s_jump_range_divident
+    current_s = initial_s
+    current_loss = dbi_object.loss(d=d, step=current_s)
+    temp = initial_temp
+
+    for _ in range(max_iter):
+        candidate_s = max(
+            step_min,
+            min(
+                current_s + np.random.uniform(-1 * s_jump_range, s_jump_range), step_max
+            ),
+        )
+        candidate_loss = dbi_object.loss(d=d, step=candidate_s)
+
+        # Calculate change in loss
+        delta_loss = candidate_loss - current_loss
+
+        # Determine if the candidate solution is an improvement
+        if delta_loss < 0 or np.random.rand() < math.exp(-delta_loss / temp):
+            current_s = candidate_s
+            current_loss = candidate_loss
+        # Cool down
+        temp *= cooling_rate
+        if temp < min_temp:
+            break
+
+    return current_s
diff --git a/src/qibo/models/dbi/utils_strategies.py b/src/qibo/models/dbi/utils_strategies.py
new file mode 100644
index 0000000000..86be56f55f
--- /dev/null
+++ b/src/qibo/models/dbi/utils_strategies.py
@@ -0,0 +1,182 @@
+import hyperopt
+
+from qibo.models.dbi.double_bracket import *
+from qibo.models.dbi.utils import cs_angle_sgn, generate_pauli_operator_dict
+from qibo.models.dbi.utils_analytical import *
+from qibo.models.dbi.utils_scheduling import polynomial_step
+
+
+def select_best_dbr_generator(
+    dbi_object: DoubleBracketIteration,
+    d_list: list,
+    step: Optional[float] = None,
+    compare_canonical: bool = True,
+    scheduling: DoubleBracketScheduling = None,
+    **kwargs,
+):
+    """Selects the best double bracket rotation generator from a list and execute the rotation.
+
+    Args:
+        dbi_object (`DoubleBracketIteration`): the target DoubleBracketIteration object.
+        d_list (list): list of diagonal operators (np.array) to run from.
+        step (float): fixed iteration duration.
+            Defaults to ``None``, optimize with `scheduling` method and `choose_step` function.
+        compare_canonical (boolean): if `True`, the diagonalization effect with operators from `d_list` is compared with the canonical bracket.
+        scheduling (`DoubleBracketScheduling`): scheduling method for finding the optimal step.
+
+    Returns:
+        The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction.
+    """
+    if scheduling is None:
+        scheduling = dbi_object.scheduling
+    norms_off_diagonal_restriction = [dbi_object.off_diagonal_norm] * (len(d_list) + 1)
+    optimal_steps = np.zeros(len(d_list) + 1)
+    flip_list = np.ones(len(d_list) + 1)
+    for i, d in enumerate(d_list):
+        # prescribed step durations
+        dbi_eval = deepcopy(dbi_object)
+        d = dbi_eval.backend.cast(d)
+        flip_list[i] = cs_angle_sgn(dbi_eval, d)
+        if flip_list[i] != 0:
+            if step is None:
+                step_best = dbi_eval.choose_step(
+                    d=flip_list[i] * d, scheduling=scheduling, **kwargs
+                )
+            else:
+                step_best = step
+            dbi_eval(step=step_best, d=flip_list[i] * d)
+            optimal_steps[i] = step_best
+            norms_off_diagonal_restriction[i] = dbi_eval.off_diagonal_norm
+    # canonical
+    if compare_canonical is True:
+        dbi_eval = deepcopy(dbi_object)
+        dbi_eval.mode = DoubleBracketGeneratorType.canonical
+        if step is None:
+            step_best = dbi_eval.choose_step(scheduling=scheduling, **kwargs)
+        else:
+            step_best = step
+        dbi_eval(step=step_best)
+        optimal_steps[-1] = step_best
+        norms_off_diagonal_restriction[-1] = dbi_eval.off_diagonal_norm
+    # find best d
+    idx_max_loss = np.argmin(norms_off_diagonal_restriction)
+    flip = flip_list[idx_max_loss]
+    step_optimal = optimal_steps[idx_max_loss]
+    dbi_eval = deepcopy(dbi_object)
+    if idx_max_loss == len(d_list) and compare_canonical is True:
+        # canonical
+        dbi_eval(step=step_optimal, mode=DoubleBracketGeneratorType.canonical)
+
+    else:
+        d_optimal = flip * d_list[idx_max_loss]
+        dbi_eval(step=step_optimal, d=d_optimal)
+    return dbi_eval, idx_max_loss, step_optimal, flip
+
+
+def gradient_descent_pauli(
+    dbi_object: DoubleBracketIteration,
+    d_coef: list,
+    d: Optional[np.array] = None,
+    pauli_operator_dict: dict = None,
+    parameterization_order: int = 1,
+    n: int = 3,
+    onsite_Z_ops: Optional[list] = None,
+    lr_min: float = 1e-5,
+    lr_max: float = 1,
+    max_evals: int = 100,
+    space: callable = None,
+    optimizer: callable = None,
+    verbose: bool = False,
+    use_ds: bool = True,
+):
+    """calculate the elements of one gradient descent step on `dbi_object`.
+
+    Args:
+        dbi_object (DoubleBracketIteration): the target dbi object
+        d_coef (list): the initial decomposition of `d` into Pauli-Z operators
+        d (np.array, optional): the initial diagonal operator. Defaults to None.
+        n_taylor (int, optional): the highest order to expand the loss function derivative. Defaults to 2.
+        onsite_Z_ops (list, optional): list of onsite-Z operators. Defaults to None.
+        lr_min (float, optional): the minimal gradient step. Defaults to 1e-5.
+        lr_max (float, optional): the maximal gradient step. Defaults to 1.
+        max_evals (int, optional): the max number of evaluations for `hyperopt` to find the optimal gradient step `lr`. Defaults to 100.
+        space (callable, optional): the search space for `hyperopt`. Defaults to None.
+        optimizer (callable, optional): optimizer for `hyperopt`. Defaults to None.
+        verbose (bool, optional): option to print out the 'hyperopt' progress. Defaults to False.
+        use_ds (bool, optional): if False, ds is set to 0. Defaults to True.
+
+    Returns:
+        the optimal step found, coeffcients of `d` in Pauli-Z basis, matrix of `d`
+
+    """
+    nqubits = int(np.log2(dbi_object.h.matrix.shape[0]))
+    if pauli_operator_dict is None:
+        pauli_operator_dict = generate_pauli_operator_dict(
+            nqubits, parameterization_order
+        )
+
+    grad, s = gradient_Pauli(
+        dbi_object, d, n=n, pauli_operator_dict=pauli_operator_dict, use_ds=use_ds
+    )
+    # optimize gradient descent step with hyperopt
+    if space is None:
+        space = hyperopt.hp.loguniform("lr", np.log(lr_min), np.log(lr_max))
+    if optimizer is None:
+        optimizer = hyperopt.tpe
+
+    def func_loss_to_lr(lr):
+        d_coef_eval = [d_coef[j] - grad[j] * lr for j in range(nqubits)]
+        d_eval = sum(
+            [
+                d_coef_eval[i] * list(pauli_operator_dict.values())[i]
+                for i in range(nqubits)
+            ]
+        )
+        return dbi_object.loss(step=s, d=d_eval)
+
+    best = hyperopt.fmin(
+        fn=func_loss_to_lr,
+        space=space,
+        algo=optimizer.suggest,
+        max_evals=max_evals,
+        verbose=verbose,
+    )
+    lr = best["lr"]
+
+    d_coef = [d_coef[j] - grad[j] * lr for j in range(nqubits)]
+    d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])
+    return s, d_coef, d
+
+
+def gradientDiagonal(dbi_object, d, H, n=3):
+    # Gradient of potential function with respect to diagonal elements of D (full-diagonal ansatz)
+    grad = np.zeros(len(d))
+    for i in range(len(d)):
+        s = polynomial_step(dbi_object, n=3, d=d)
+        derivative = dpolynomial_diDiagonal(dbi_object, s, d, H, i)
+        grad[i] = d[i, i] - derivative
+    return grad
+
+
+def gradient_ascent(dbi_object, d, step, iterations):
+    H = dbi_object.h.matrix
+    loss = np.zeros(iterations + 1)
+    grad = np.zeros((iterations, len(d)))
+    dbi_eval = deepcopy(dbi_object)
+    s = polynomial_step(dbi_object, n=3, d=d)
+    dbi_eval(s, d=d)
+    loss[0] = dbi_eval(d)
+    diagonals = np.empty((len(d), iterations + 1))
+    diagonals[:, 0] = np.diag(d)
+
+    for i in range(iterations):
+        dbi_eval = deepcopy(dbi_object)
+        grad[i, :] = gradientDiagonal(dbi_object, d, H)
+        for j in range(len(d)):
+            d[j, j] = d[j, j] - step * grad[i, j]
+        s = polynomial_step(dbi_object, n=3, d=d)
+        dbi_eval(s, d=d)
+        loss[i + 1] = dbi_eval.least_squares(d)
+        diagonals[:, i + 1] = np.diag(d)
+
+    return d, loss, grad, diagonals
diff --git a/tests/test_dbi.ipynb b/tests/test_dbi.ipynb
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/test_models_dbi_strategies.py b/tests/test_models_dbi_strategies.py
new file mode 100644
index 0000000000..89aad6ea9f
--- /dev/null
+++ b/tests/test_models_dbi_strategies.py
@@ -0,0 +1,63 @@
+"""Testing DoubleBracketIteration strategies"""
+
+import numpy as np
+import pytest
+
+from qibo.hamiltonians import Hamiltonian
+from qibo.models.dbi.double_bracket import (
+    DoubleBracketCostFunction,
+    DoubleBracketGeneratorType,
+    DoubleBracketIteration,
+    DoubleBracketScheduling,
+)
+from qibo.models.dbi.utils import *
+from qibo.models.dbi.utils_strategies import (
+    gradient_descent_pauli,
+    select_best_dbr_generator,
+)
+from qibo.quantum_info import random_hermitian
+
+NSTEPS = 1
+seed = 5
+"""Number of steps for evolution."""
+
+
+@pytest.mark.parametrize("nqubits", [2, 3])
+def test_select_best_dbr_generator(backend, nqubits):
+    scheduling = DoubleBracketScheduling.grid_search
+    h0 = random_hermitian(2**nqubits, backend=backend, seed=seed)
+    dbi = DoubleBracketIteration(
+        Hamiltonian(nqubits, h0, backend=backend),
+        mode=DoubleBracketGeneratorType.single_commutator,
+        scheduling=scheduling,
+    )
+    initial_off_diagonal_norm = dbi.off_diagonal_norm
+    generate_local_Z = generate_Z_operators(nqubits)
+    Z_ops = list(generate_local_Z.values())
+    for _ in range(NSTEPS):
+        dbi, idx, step, flip_sign = select_best_dbr_generator(
+            dbi, Z_ops, scheduling=scheduling, compare_canonical=True
+        )
+    assert dbi.off_diagonal_norm < initial_off_diagonal_norm
+
+
+@pytest.mark.parametrize("nqubits", [2, 3])
+def test_gradient_descent_pauli(backend, nqubits):
+    scheduling = DoubleBracketScheduling.grid_search
+    h0 = random_hermitian(2**nqubits, backend=backend, seed=seed)
+    dbi = DoubleBracketIteration(
+        Hamiltonian(nqubits, h0, backend=backend),
+        mode=DoubleBracketGeneratorType.single_commutator,
+        scheduling=scheduling,
+    )
+    initial_off_diagonal_norm = dbi.off_diagonal_norm
+    pauli_operator_dict = generate_pauli_operator_dict(
+        nqubits=nqubits, parameterization_order=2
+    )
+    d_coef = decompose_into_Pauli_basis(
+        dbi.h.matrix, list(pauli_operator_dict.values())
+    )
+    d = sum([d_coef[i] * list(pauli_operator_dict.values())[i] for i in range(nqubits)])
+    step, d_coef, d = gradient_descent_pauli(dbi, d_coef, d)
+    dbi(d=d, step=step)
+    assert dbi.off_diagonal_norm < initial_off_diagonal_norm
diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py
index 9f55171547..624b9d5ed1 100644
--- a/tests/test_models_dbi_utils.py
+++ b/tests/test_models_dbi_utils.py
@@ -49,3 +49,50 @@ def test_select_best_dbr_generator(backend, nqubits, step):
         )
 
     assert initial_off_diagonal_norm > dbi.off_diagonal_norm
+
+
+@pytest.mark.parametrize("nqubits", [3, 4, 5])
+@pytest.mark.parametrize("d_option", ["delta_H", "min_max"])
+def test_gradient_descent_onsite_Z(backend, nqubits, d_option):
+    h0 = random_hermitian(2**nqubits, seed=1, backend=backend)
+    dbi = DoubleBracketIteration(
+        Hamiltonian(nqubits, h0, backend=backend),
+        mode=DoubleBracketGeneratorType.single_commutator,
+    )
+    initial_off_diagonal_norm = dbi.off_diagonal_norm
+    onsite_Z_ops = generate_onsite_Z_ops(nqubits)
+    if d_option == "delta_H":
+        d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)
+    if d_option == "min_max":
+        d_min_max = diagonal_min_max(dbi.h.matrix)
+        d_coef = onsite_Z_decomposition(d_min_max, onsite_Z_ops)
+    d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])
+    iters = 15
+    for _ in range(iters):
+        # calculate elements of gradient descent
+        s, d_coef, d = gradient_descent_onsite_Z(
+            dbi, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100
+        )
+        # double bracket rotation with the results
+        dbi(step=s, d=d)
+    # when onsite_Z_ops not given
+    s, d_coef, d = gradient_descent_onsite_Z(dbi, d_coef, max_evals=100)
+    dbi(step=s, d=d)
+    assert initial_off_diagonal_norm > dbi.off_diagonal_norm
+
+
+@pytest.mark.parametrize("nqubits", [3, 4, 5])
+def test_dGamma_di_onsite_Z(nqubits):
+    h0 = random_hermitian(2**nqubits, seed=1)
+    dbi = DoubleBracketIteration(
+        Hamiltonian(nqubits, h0),
+        mode=DoubleBracketGeneratorType.single_commutator,
+    )
+    onsite_Z_ops = generate_onsite_Z_ops(nqubits)
+    d_coef = onsite_Z_decomposition(dbi.h.matrix, onsite_Z_ops)
+    d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])
+    # provide onsite_Z_ops or not gives the same result
+    dGamma_di_onsite_Z_with_Z_ops = dGamma_di_onsite_Z(dbi, 3, 1, d, onsite_Z_ops)
+    assert (
+        dGamma_di_onsite_Z_with_Z_ops[-1] == dGamma_di_onsite_Z(dbi, 3, 1, d)[-1]
+    ).all()
diff --git a/tests/test_models_dbi_utils_scheduling.py b/tests/test_models_dbi_utils_scheduling.py
new file mode 100644
index 0000000000..392727f144
--- /dev/null
+++ b/tests/test_models_dbi_utils_scheduling.py
@@ -0,0 +1,30 @@
+"""Unit testing for utils_scheduling.py for Double Bracket Iteration"""
+
+import numpy as np
+import pytest
+
+from qibo.hamiltonians import Hamiltonian
+from qibo.models.dbi.double_bracket import (
+    DoubleBracketGeneratorType,
+    DoubleBracketIteration,
+    DoubleBracketScheduling,
+)
+from qibo.models.dbi.utils_scheduling import polynomial_step
+from qibo.quantum_info import random_hermitian
+
+NSTEPS = 1
+seed = 10
+"""Number of steps for evolution."""
+
+
+@pytest.mark.parametrize("nqubits", [5, 6])
+def test_polynomial_fail_cases(backend, nqubits):
+    h0 = random_hermitian(2**nqubits, backend=backend, seed=seed)
+    dbi = DoubleBracketIteration(
+        Hamiltonian(nqubits, h0, backend=backend),
+        mode=DoubleBracketGeneratorType.single_commutator,
+        scheduling=DoubleBracketScheduling.polynomial_approximation,
+    )
+    with pytest.raises(ValueError):
+        polynomial_step(dbi, n=2, n_max=1)
+    assert polynomial_step(dbi, n=1) == None