From 08fb83727bafafb83b679adbcf9456f3a51f3435 Mon Sep 17 00:00:00 2001 From: Sam-XiaoyueLi Date: Thu, 22 Feb 2024 22:27:40 +0800 Subject: [PATCH] Complete dbi_strategies_compare notebook --- examples/dbi/dbi_strategies_compare.ipynb | 254 ++++++++++++++++ .../dbi/dbi_strategy_magnetic_field.ipynb | 272 +++--------------- src/qibo/models/dbi/double_bracket.py | 48 ++-- src/qibo/models/dbi/utils.py | 6 +- 4 files changed, 327 insertions(+), 253 deletions(-) create mode 100644 examples/dbi/dbi_strategies_compare.ipynb diff --git a/examples/dbi/dbi_strategies_compare.ipynb b/examples/dbi/dbi_strategies_compare.ipynb new file mode 100644 index 0000000000..0afd3a9841 --- /dev/null +++ b/examples/dbi/dbi_strategies_compare.ipynb @@ -0,0 +1,254 @@ +{ + "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": [ + "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 *" + ] + }, + { + "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\", \"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", + "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.use_hyperopt" + ] + }, + { + "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)" + ] + }, + { + "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, max_evals=50)\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(Hamiltonian(nqubits=nqubits, matrix=h0), 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.use_hyperopt\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, max_evals=50)\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(Hamiltonian(nqubits=nqubits, matrix=h0), mode=DoubleBracketGeneratorType.single_commutator, scheduling=scheduling)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", + "d_coef = onsite_Z_decomposition(dbi_gradient.h.matrix, onsite_Z_ops)\n", + "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])" + ] + }, + { + "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_onsite_Z(dbi_gradient, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=50, n_taylor=5)\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')\n", + "plt.plot(off_diagonal_norm_history_pauli, label='Pauli-Z')\n", + "plt.plot(off_diagonal_norm_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, 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('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_magnetic_field.ipynb b/examples/dbi/dbi_strategy_magnetic_field.ipynb index ea0dbb3ad2..d324efdb38 100644 --- a/examples/dbi/dbi_strategy_magnetic_field.ipynb +++ b/examples/dbi/dbi_strategy_magnetic_field.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -26,7 +26,7 @@ "import matplotlib.pyplot as plt\n", "\n", "from qibo import hamiltonians, set_backend\n", - "from qibo.hamiltonians import SymbolicHamiltonian\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 *" @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -58,34 +58,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-02-22 16:06:03]: Using qibojit (numba) backend on /CPU:0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Initial off diagonal norm 31.576176740060667\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# backend\n", "set_backend(\"qibojit\", \"numba\")\n", @@ -99,38 +74,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 08:22:59]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The initial D coefficients: [(-0.2980910136757636+0j), (-0.17678355790937256+0j), (0.294550421681131+0j), (-0.2301056409534723+0j), (-0.07297191764284382+0j)]\n", - "Gradient: [ 482.57311611 272.8003344 -526.64628147 420.97083752 47.09691378]\n", - "s: 0.06953854599881942\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:228: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " grad[i] = s**3/3*da + s**2/2*db + 2*s*dc + s**2*ds*a + s*ds*b+ 2*ds*c\n" - ] - } - ], + "outputs": [], "source": [ "# generate the onsite Z operators\n", "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", @@ -144,58 +90,24 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:106: RuntimeWarning: overflow encountered in matmul\n", - " return a @ b - b @ a\n", - "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/double_bracket.py:106: RuntimeWarning: invalid value encountered in matmul\n", - " return a @ b - b @ a\n" - ] - } - ], + "outputs": [], "source": [ "iters = 30\n", "off_diagonal_norm_tot = [dbi.off_diagonal_norm]\n", - "num_iters = []\n", "s_step = [0]\n", "for i in range(iters):\n", - " s, d_coef, d, off_diagonal_norm_history = gradient_descent_onsite_Z(dbi, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", - " off_diagonal_norm_tot.append(off_diagonal_norm_history[-1])\n", - " num_iters.append(len(off_diagonal_norm_history))\n", + " s, d_coef, d = gradient_descent_onsite_Z(dbi, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", + " off_diagonal_norm_tot.append(dbi.off_diagonal_norm)\n", " s_step.append(s)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.title(str(nqubits) + ' spins magnetic field diagonalization')\n", "plt.plot(off_diagonal_norm_tot)\n", @@ -215,27 +127,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-22 16:08:15]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# generate the Hamiltonian\n", "nqubits = 5\n", @@ -250,78 +144,28 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|INFO|2024-02-22 16:13:45]: Using qibojit (numba) backend on /CPU:0\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:13:45]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[(-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j)]\n" - ] - } - ], + "outputs": [], "source": [ "# backend\n", "set_backend(\"qibojit\", \"numba\")\n", "# initialize dbi object\n", - "dbi_TFIM = DoubleBracketIteration(deepcopy(H_TFIM))\n", - "d_coef = onsite_Z_decomposition(dbi_TFIM.h.matrix)\n", - "print(d_coef)" + "dbi_TFIM = DoubleBracketIteration(deepcopy(H_TFIM))" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n", - "[Qibo 0.2.5|WARNING|2024-02-22 16:26:04]: Calculating the dense form of a symbolic Hamiltonian. This operation is memory inefficient.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The initial D coefficients: [(-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j)]\n", - "Gradient: [ -7.8132536 -17.94433184 -20.56560814 -17.94433184 -7.8132536 ]\n", - "s: 0.047896529653867745\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:228: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " grad[i] = s**3/3*da + s**2/2*db + 2*s*dc + s**2*ds*a + s*ds*b+ 2*ds*c\n" - ] - } - ], + "outputs": [], "source": [ "# generate the onsite Z operators\n", "onsite_Z_ops = generate_onsite_Z_ops(nqubits)\n", "d_coef = onsite_Z_decomposition(dbi_TFIM.h.matrix, onsite_Z_ops)\n", "d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)])\n", "grad, s = gradient_onsite_Z(dbi_TFIM,d,3, onsite_Z_ops)\n", + "print('Initial off-diagonal norm:', dbi.off_diagonal_norm)\n", "print('The initial D coefficients:', d_coef)\n", "print('Gradient:', grad)\n", "print('s:', s)" @@ -329,56 +173,25 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/pethidine/anaconda3/envs/DBF_qibo/lib/python3.11/site-packages/qibo/models/dbi/utils.py:228: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " grad[i] = s**3/3*da + s**2/2*db + 2*s*dc + s**2*ds*a + s*ds*b+ 2*ds*c\n" - ] - } - ], + "outputs": [], "source": [ - "iters = 30\n", + "NSTEPS = 30\n", "off_diagonal_norm_tot = [dbi_TFIM.off_diagonal_norm]\n", - "num_iters = []\n", "s_step = [0]\n", - "for i in range(iters):\n", - " s, d_coef, d, off_diagonal_norm_history = gradient_descent_onsite_Z(dbi_TFIM, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", - " off_diagonal_norm_tot.append(off_diagonal_norm_history[-1])\n", - " num_iters.append(len(off_diagonal_norm_history))\n", - " s_step.append(s)" + "for _ in range(NSTEPS):\n", + " s, d_coef, d = gradient_descent_onsite_Z(dbi_TFIM, d_coef, d, onsite_Z_ops=onsite_Z_ops, max_evals=100)\n", + " off_diagonal_norm_tot.append(dbi_TFIM.off_diagonal_norm)\n", + " s_step.append(s)\n", + " print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {s} with d_coef {d_coef}, loss {dbi_TFIM.off_diagonal_norm}\")" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$|| \\\\sigma(e^{sW}He^{-sW}) || $')" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAHFCAYAAAD7ZFORAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABXL0lEQVR4nO3dd3hTZf8G8DvpSDrTvVtayixQoJSNFAdLQBDZKlMQAbECL4qK8KovU/nhBFSWDFFZKirIrCAVyiyUDYW20AEt3W3aJOf3R2kklELaJjlpen+uKxfkJOecb04Pzc1znvM8EkEQBBARERFZIKnYBRAREREZC4MOERERWSwGHSIiIrJYDDpERERksRh0iIiIyGIx6BAREZHFYtAhIiIii8WgQ0RERBaLQYeIiIgsFoMOVXDgwAFIJJKHPv755x+T1nL9+nVIJBKsWbPGJPubO3dupZ/9/ke3bt0AAKNHj670PTt27ND5DB9//LF2P/cf48o+21NPPQWJRILg4GAjf+raY968edi+fXuF5eXH88CBAwbZz8mTJxEVFQWFQgGJRIKlS5fWaB9VWXf06NE1+pkHBwdj9OjR1dp3bfXgZzb2741z585h7ty5uH79eoXXavrzI8OzFrsAMl/z5s3Dk08+qbOsefPmJq3B19cXsbGxCA0NNcn+XnnlFfTq1Uv7PDU1FQMHDsTrr7+OESNGaJc7Oztr/25nZ4d9+/ZV2FaTJk0euz8nJyesXLlS55c0ACQmJuLAgQM6+6Gyc3LQoEEYMGCAzvKIiAjExsYiLCzMIPsZO3YsCgoKsGnTJri6uiI4OBj29vYG3YepGPrY1AbG/r1x7tw5/Pe//0W3bt0qhJrZs2fjjTfeMMp+qXoYdKhSDRs2RIcOHUStQSaTmbSGgIAABAQEaJ+X/48tKCio0jqkUmm1axw6dCi+/fZbXL58GQ0bNtQuX7VqFfz9/dGiRQucO3euWtuuS5ydnQ16npw9exbjx49H7969dZaL/e+hOgx9bGoDU//euJ+p/lNG+uOlKzK4a9euYdiwYfDz84NMJoO3tzeefvppnDp1Svue4OBg9O3bF9u2bUN4eDjkcjnq16+Pzz77TGdbD2uCLr+8lJCQgOHDh0OhUMDb2xtjx45FTk6Ozvo//fQT2rdvD4VCAXt7e9SvXx9jx4415sevku7duyMwMBCrVq3SLtNoNFi7di1GjRoFqVS/f6LdunVD8+bNERsbi06dOsHOzg7BwcFYvXo1AOC3335DREQE7O3t0aJFC+zcuVNn/StXrmDMmDFo2LAh7O3t4e/vj379+uHMmTMV9pWQkIAePXrA3t4enp6emDx5Mn777bcKl0fKa4qLi8MTTzyhPf4LFiyARqPR2WZubi5mzJiBkJAQ2Nrawt/fH9HR0SgoKNC+RyKRoKCgAGvXrq1wCbGyyzNHjhxBv3794O7uDrlcjtDQUERHR1d6HNesWQOJRAKVSoVly5Zp9/OofRw7dgzPPfcc3NzcIJfL0bp1a/z444+V7uPB/TVu3BgymQxNmzbFd999p9d6AFBaWoqZM2fCx8cH9vb26NKlC44ePVrhfQ+r+9ixYxg2bBiCg4O158rw4cNx48aNCusfOnQIHTt2hFwuh7+/P2bPno1vv/0WEolE59KNRqPBokWL0KRJE8hkMnh5eWHkyJFISUnR2Z6+50VxcTGmT5+OVq1aQaFQwM3NDR07dsTPP//82GPzsN8bj7oUXf459Dkua9asweDBgwEATz75ZIVL0A+7dFVcXIxZs2bpnN+TJ09Gdna2zvvKfy/u3LkTERERsLOzQ5MmTXR+P1DVsUWHKjV58mQMGzYM9vb26NixI2bPno0uXbo8dr1nn30WarUaixYtQlBQEO7cuYPDhw9X+Ed96tQpREdHY+7cufDx8cGGDRvwxhtvoKSkBDNmzHjsfl544QUMHToU48aNw5kzZzBr1iwA0P5SiI2NxdChQzF06FDMnTsXcrkcN27ceOhlpppSqVQ6zyUSCaysrB67nlQqxejRo7Fy5Up89NFHsLKywp9//omUlBSMGTOmSk3gaWlpGDNmDGbOnImAgAB8/vnnGDt2LJKTk7F582a88847UCgU+OCDDzBgwABcu3YNfn5+AIBbt27B3d0dCxYsgKenJ7KysrB27Vq0b98eJ0+eROPGjQGUXcqLioqCg4MDli1bBi8vL3z//feYMmVKpTW9+OKLmD59OubMmYNt27Zh1qxZ8PPzw8iRIwEAhYWFiIqKQkpKCt555x2Eh4cjISEB77//Ps6cOYM9e/ZAIpEgNjYWTz31FJ588knMnj0bAB55aW/Xrl3o168fmjZtiiVLliAoKAjXr1/Hn3/+Wek6ffr0QWxsLDp27IhBgwZh+vTpjzzm+/fvR69evdC+fXssX74cCoUCmzZtwtChQ1FYWFjhkuT91qxZgzFjxqB///745JNPkJOTg7lz50KpVOoVcMePH4/vvvsOM2bMQPfu3XH27FkMHDgQeXl5j133+vXraNy4MYYNGwY3NzekpqZi2bJlaNu2Lc6dOwcPDw8AQHx8PLp3745GjRph7dq1sLe3x/Lly7F+/foK23zttdfw9ddfY8qUKejbty+uX7+O2bNn48CBAzhx4oR2m4B+54VSqURWVhZmzJgBf39/lJSUYM+ePRg4cCBWr16tfZ++YmNjdZ4XFRXh5Zdfhlqthpubm97HpU+fPpg3bx7eeecdfPnll4iIiABQeUuOIAgYMGAA9u7di1mzZuGJJ55AfHw85syZg9jYWMTGxkImk2nff/r0aUyfPh1vv/02vL298e2332LcuHFo0KABunbtWqXPTPcIRA84ceKE8MYbbwjbtm0T/vrrL2HVqlVC06ZNBSsrK2Hnzp2PXPfOnTsCAGHp0qWPfF+9evUEiUQinDp1Smd59+7dBWdnZ6GgoEAQBEFITEwUAAirV6/WvmfOnDkCAGHRokU6606aNEmQy+WCRqMRBEEQPv74YwGAkJ2dre9Hr6B8/4sXL37o66NGjRIAVHh07tz5kdvYv3+/AED46aefhGvXrgkSiUTYsWOHIAiCMHjwYKFbt26CIAhCnz59hHr16j22zqioKAGAcOzYMe2yzMxMwcrKSrCzsxNu3rypXX7q1CkBgPDZZ59Vuj2VSiWUlJQIDRs2FN58803t8v/85z+CRCIREhISdN7fs2dPAYCwf//+CjUdOXJE571hYWFCz549tc/nz58vSKVSIS4uTud9mzdvFgAIv//+u3aZg4ODMGrUqAr1lh/P+/cfGhoqhIaGCkVFRZV+zsoAECZPnvzYfTRp0kRo3bq1UFpaqvPevn37Cr6+voJarX7oumq1WvDz8xMiIiK056sgCML169cFGxubx/7Mz58/LwDQ+dkIgiBs2LBBAKBzjB5W94NUKpWQn58vODg4CJ9++ql2+eDBgwUHBwfh9u3b2mVqtVoICwsTAAiJiYk69UyaNElnu0eOHBEACO+88452mb7nxcNqLC0tFcaNGye0bt1a57V69erpfOaH/d54cFv9+/cXHB0dhePHjz9ynw87Lj/99FOlx3TUqFE6P7+dO3c+9PfVDz/8IAAQvv76a53PIZfLhRs3bmiXFRUVCW5ubsKrr75aaZ30aLx0RRW0bt0aS5cuxYABA/DEE09gzJgxOHz4MHx9fTFz5sxHruvm5obQ0FAsXrwYS5YswcmTJytcpijXrFkztGzZUmfZiBEjkJubixMnTjy2zueee07neXh4OIqLi5GRkQEAaNu2LQBgyJAh+PHHH3Hz5s3HbrM67OzsEBcXp/NYuXKl3uuHhISgW7duWLVqFTIzM/Hzzz9X6/Kar68v2rRpo33u5uYGLy8vtGrVSttyAwBNmzYFAJ3meJVKhXnz5iEsLAy2trawtraGra0tLl++jPPnz2vfFxMTg+bNm1fo2Dp8+PCH1uTj44N27drpLAsPD9fZ944dO9C8eXO0atUKKpVK++jZs2e17xa6dOkSrl69inHjxkEul1d5fX1cuXIFFy5cwIsvvggAOrU/++yzSE1NxcWLFx+67sWLF3Hr1i2MGDFCe2kMAOrVq4dOnTo9dt/79+8HAO2+yw0ZMgTW1o9vqM/Pz8dbb72FBg0awNraGtbW1nB0dERBQUGFn/dTTz2l0xojlUoxZMiQh9bzYAtWu3bt0LRpU+zdu1dnuT7nBVB26blz585wdHSEtbU1bGxssHLlSp0aq2PKlCn47bff8NNPP2lbZAD9j0tVlLcgP3hsBg8eDAcHhwrHplWrVggKCtI+l8vlaNSo0UMvK5J+GHRILy4uLujbty/i4+NRVFRU6fskEgn27t2Lnj17YtGiRYiIiICnpyemTp1aoUndx8enwvrlyzIzMx9bk7u7u87z8ubf8vq6du2K7du3Q6VSYeTIkQgICEDz5s3x/fffP3bbVSGVShEZGanzKL/Uo69x48bh119/xZIlS2BnZ4dBgwZVuY7y5vf72draVlhua2sLoKzfQLlp06Zh9uzZGDBgAH799VccOXIEcXFxaNmypc7POzMzE97e3hX287BlQMWfEVD2c7p/m+np6YiPj4eNjY3Ow8nJCYIg4M6dO4/55BXdvn0bAHQ6lhtaeno6AGDGjBkVap80aRIAVFp7+fn9qH8Dj1LZ+tbW1g895g8aMWIEvvjiC7zyyivYtWsXjh49iri4OHh6elbr511ej6+vb4X3+vn5Vfj3rM95sXXrVgwZMgT+/v5Yv349YmNjERcXh7Fjx+qcu1X10UcfYfny5VixYoXOHZaA/selKjIzM2FtbQ1PT0+d5RKJBD4+PtU6NlQ17KNDehMEAQB0/gf6MPXq1dO2aFy6dAk//vgj5s6di5KSEixfvlz7vrS0tArrli/T55e1Pvr374/+/ftDqVTin3/+wfz58zFixAgEBwejY8eOBtmHIQwcOBCTJ0/GggULMH78eNjZ2Zl0/+vXr8fIkSMxb948neV37tyBi4uL9rm7u7v2C/5+D/tZ6svDwwN2dnaVdri8vzVBX+VfKg92hDWk8rpmzZqFgQMHPvQ9lQXe8vP7Uf8GHuX+9f39/bXLVSrVY/+TkJOTgx07dmDOnDl4++23tcvL+8Q8uB99ft7l9aSmplYIl7du3arWz3D9+vUICQnBDz/8oPM7R6lUVnlb5dasWYPZs2dj7ty5FVpNq3JcqsLd3R0qlQq3b9/WCTuCICAtLU3b8kzGwxYd0svdu3exY8cOtGrVqkqXAho1aoT33nsPLVq0qHA5KiEhAadPn9ZZtnHjRjg5Oek0JxuCTCZDVFQUFi5cCKBsQDhzYmdnh/fffx/9+vXDa6+9ZvL9SyQSnQ6RQNmdWg9e7ouKisLZs2cr3PK+adOmau+7b9++uHr1Ktzd3Su0jEVGRurcwaLv/2wbNWqE0NBQrFq1qkZfjI/SuHFjNGzYEKdPn35o3ZGRkXBycqp0XV9fX3z//ffa/0AAZZcTDx8+/Nh9l99ttmHDBp3lP/74Y4WO8Q+SSCQQBKHCz/vbb7+FWq3WWRYVFYV9+/bptExpNBr89NNPOu976qmnAKBCJ+W4uDicP38eTz/99GM/08PqtLW11Qk5aWlpet119TA7d+7E+PHjMXbsWMyZM+eh+9P3uDzYevwo5Z/9wWOzZcsWFBQUVOvYUNWwRYcqGDFiBIKCghAZGQkPDw9cvnwZn3zyCdLT0x870mh8fDymTJmCwYMHo2HDhrC1tcW+ffsQHx+v878koKxJ+7nnnsPcuXPh6+uL9evXY/fu3Vi4cCHs7e1r/Dnef/99pKSk4Omnn0ZAQACys7Px6aefwsbGBlFRUTXevqFNmzYN06ZNE2Xfffv2xZo1a9CkSROEh4fj+PHjWLx4cYX/nUdHR2PVqlXo3bs3PvjgA3h7e2Pjxo24cOECAOh9O/yD29yyZQu6du2KN998E+Hh4dBoNEhKSsKff/6J6dOno3379gCAFi1a4MCBA/j111/h6+sLJyenSltNvvzyS/Tr1w8dOnTAm2++iaCgICQlJWHXrl0VAkJ1rVixAr1790bPnj0xevRo+Pv7IysrC+fPn8eJEycqBIJyUqkUH374IV555RU8//zzGD9+PLKzs7V3ID5O06ZN8dJLL2Hp0qWwsbHBM888g7Nnz+Ljjz9+7CCTzs7O6Nq1KxYvXgwPDw8EBwcjJiYGK1eu1Gm9A4B3330Xv/76K55++mm8++67sLOzw/Lly7W3/Zf/vBs3bowJEybg888/h1QqRe/evbV3XQUGBuLNN9/U42jq6tu3L7Zu3YpJkyZh0KBBSE5OxocffghfX19cvny5SttKTEzE4MGDUb9+fYwZM6bCCO+tW7eu0nEpHzj166+/hpOTE+RyOUJCQh7aEt29e3f07NkTb731FnJzc9G5c2ftXVetW7fGyy+/XLUDQ1XGoEMVhIeH44cffsDy5cuRn58PNzc3dOnSBevWrXtsM6uPjw9CQ0Px1VdfITk5GRKJBPXr18cnn3yC119/Xee9rVq1wpgxYzBnzhxcvnwZfn5+WLJkSbV+KT5M+/btcezYMbz11lu4ffs2XFxcEBkZiX379qFZs2YG2YelKA+A8+fPR35+PiIiIrB161a89957Ou/z8/NDTEwMoqOjMXHiRNjb2+P555/HBx98gFGjRlX4QtCHg4MDDh48iAULFuDrr79GYmIi7OzsEBQUhGeeeUanRefTTz/VDntQflt6ZZ2Ve/bsib/++gsffPABpk6diuLiYgQEBFToxF4TTz75JI4ePYr//e9/iI6Oxt27d+Hu7o6wsLAKHXYfNG7cOADAwoULMXDgQAQHB+Odd95BTEyMXh2wV65cCW9vb6xZswafffYZWrVqhS1btmDYsGGPXXfjxo144403MHPmTKhUKnTu3Bm7d+9Gnz59dN7XsmVL7N69GzNmzMDIkSPh6uqKl19+GVFRUXjrrbegUCi07122bBlCQ0OxcuVKfPnll1AoFOjVqxfmz59frUvRY8aMQUZGBpYvX45Vq1ahfv36ePvtt5GSkoL//ve/VdrWjRs3kJ+fj0uXLuGJJ56o8HpiYiKCg4P1Pi4hISFYunQpPv30U3Tr1g1qtRqrV69+6HACEokE27dvx9y5c7F69Wr873//g4eHB15++WXMmzevQgsSGZ5EuL/dlMhEgoOD0bx5c+18UFS7TZgwAd9//z0yMzO1nZ3JcvXo0QPXr1/HpUuXxC6F6LHYokNEVfLBBx/Az88P9evXR35+Pnbs2IFvv/0W7733HkOOBZo2bRpat26NwMBAZGVlYcOGDdi9e3eVhlAgEhODDhFViY2NDRYvXoyUlBSoVCo0bNgQS5Ys4USGFkqtVuP9999HWloaJBIJwsLCsG7dOrz00ktil0akF166IiIiIovF28uJiIjIYjHoEBERkcVi0CEiIiKLVec7I2s0Gty6dQtOTk6PndqAiIiIzIMgCMjLy4Ofn98jByut80Hn1q1bCAwMFLsMIiIiqobk5ORHTuBb54NO+Vw0ycnJjx06nYiIiMxDbm4uAgMDK51TrlydDzrll6ucnZ0ZdIiIiGqZx3U7YWdkIiIislgMOkRERGSxGHSIiIjIYjHoEBERkcVi0CEiIiKLxaBDREREFotBh4iIiCwWgw4RERFZLAYdIiIislgMOkRERGSxGHSIiIjIYjHoEBERkcVi0DGSfKUKF9PyUKLSiF0KERFRncWgYySdF+xDz6V/IfFOgdilEBER1VkMOkbi72IHALiZXShyJURERHUXg46R+LveCzp3i0SuhIiIqO5i0DGS8hadlGwGHSIiIrEw6BhJAFt0iIiIRMegYyT/9tFh0CEiIhILg46RsI8OERGR+Bh0jKS8RScjTwmlSi1yNURERHUTg46RuDnYQm5TdnhTs4tFroaIiKhuYtAxEolEwn46REREImPQMSJ/V3sA7KdDREQkFgYdI+JYOkREROJi0DEijqVDREQkLgYdI+J8V0REROJi0DEi7Vg6vHRFREQkCgYdIypv0UnNLoZaI4hcDRERUd3DoGNE3s5yWEslUGkEZORxLB0iIiJTY9AxIiupBL4ucgDskExERCQGBh0j46CBRERE4mHQMTJ/l7JBA1PYokNERGRyDDpGVn7nFYMOERGR6THoGFkAL10RERGJhkHHyLRj6dzloIFERESmxqBjZPd3RhYEjqVDRERkSgw6RlZ+e3lxqQZZBSUiV0NERFS3MOgYmczaCl5OMgDsp0NERGRqDDom4M9ZzImIiETBoGMCHDSQiIhIHAw6JsCxdIiIiMTBoGMCHEuHiIhIHAw6JsA+OkREROJg0DGB8vmu2KJDRERkWgw6JlDeopNTVIp8pUrkaoiIiOoOBh0TcJRZQ2FnA4CXr4iIiEyJQcdE/r3FnHNeERERmQqDjomwQzIREZHpMeiYSHmLTgo7JBMREZkMg46JBLBFh4iIyOQYdEyE00AQERGZHoOOibCPDhERkekx6JhIeYtORp4SSpVa5GqIiIjqBgYdE3FzsIXcpuxwp2YXi1wNERFR3cCgYyISiYT9dIiIiEyMQceE/F3vzXnFfjpEREQmwaBjQhxLh4iIyLQYdEyIY+kQERGZFoOOCXG+KyIiItNi0DEh7Vg6vHRFRERkEgw6JlTeopOaXQy1RhC5GiIiIstn1kHnr7/+Qr9+/eDn5weJRILt27frvC4IAubOnQs/Pz/Y2dmhW7duSEhIEKdYPXg7y2EtlUClEZCRx7F0iIiIjM2sg05BQQFatmyJL7744qGvL1q0CEuWLMEXX3yBuLg4+Pj4oHv37sjLyzNxpfqxkkrgo5ADYIdkIiIiU7AWu4BH6d27N3r37v3Q1wRBwNKlS/Huu+9i4MCBAIC1a9fC29sbGzduxKuvvmrKUvXm72KHlLtFuJldhEixiyEiIrJwZt2i8yiJiYlIS0tDjx49tMtkMhmioqJw+PDhStdTKpXIzc3VeZhSeYfkFLboEBERGV2tDTppaWkAAG9vb53l3t7e2tceZv78+VAoFNpHYGCgUet8UIALgw4REZGp1NqgU04ikeg8FwShwrL7zZo1Czk5OdpHcnKysUvUwVvMiYiITMes++g8io+PD4Cylh1fX1/t8oyMjAqtPPeTyWSQyWRGr68y/i7l811x0EAiIiJjq7UtOiEhIfDx8cHu3bu1y0pKShATE4NOnTqJWNmj3d+iIwgcS4eIiMiYzLpFJz8/H1euXNE+T0xMxKlTp+Dm5oagoCBER0dj3rx5aNiwIRo2bIh58+bB3t4eI0aMELHqR/O9d3t5cakGWQUlcHcUr3WJiIjI0pl10Dl27BiefPJJ7fNp06YBAEaNGoU1a9Zg5syZKCoqwqRJk3D37l20b98ef/75J5ycnMQq+bHkNlbwdJLhdp4SN7OLGHSIiIiMSCLU8esnubm5UCgUyMnJgbOzs0n2OeDLv3EqORvLXoxA7xa+j1+BiIiIdOj7/V1r++jUZrzzioiIyDQYdEQQwEEDiYiITIJBRwTlgwayRYeIiMi4GHREoL10xRYdIiIio2LQEYF20EC26BARERkVg44Iylt0copKka9UiVwNERGR5WLQEYGjzBoKOxsAvHxFRERkTAw6IvHXdkjmnFdERETGwqAjEnZIJiIiMj4GHZGUt+iksEMyERGR0TDoiCSALTpERERGx6AjEn8OGkhERGR0DDoiYR8dIiIi42PQEUl5i05GnhJKlVrkaoiIiCwTg45I3BxsIbcpO/yp2cUiV0NERGSZGHREIpFI2E+HiIjIyBh0ROTvem/OK/bTISIiMgoGHRFxLB0iIiLjYtAREcfSISIiMi4GHRFxvisiIiLjYtARkXYsHV66IiIiMgoGHRGVt+ikZhdDrRFEroaIiMjyMOiIyNtZDmupBCqNgIw8jqVDRERkaAw6IrKSSuCjkANgh2QiIiJjYNARGQcNJCIiMh4GHZGVd0hOYYsOERGRwTHoiCzAhUGHiIjIWBh0RMZbzImIiIyHQUdk/i7l811x0EAiIiJDY9AR2f0tOoLAsXSIiIgMiUFHZL73bi8vLtUgq6BE5GqIiIgsC4OOyOQ2VvB0kgFgPx0iIiJDY9AxA9qxdHjnFRERkUEx6JgB3nlFRERkHAw6ZoBj6RARERkHg44ZYIsOERGRcTDomAH20SEiIjIOBh0zwBYdIiIi42DQMQPlLTo5RaXIV6pEroaIiMhyMOiYASe5DZzl1gB4+YqIiMiQGHTMhL/rvTmvsjnnFRERkaEw6JgJdkgmIiIyPAYdMxFwr0NyCjskExERGQyDjplgiw4REZHhMeiYCd5iTkREZHgMOmai/NIVW3SIiIgMh0HHTJRfusrIU0KpUotcDRERkWVg0DETbg62kNuU/ThSs4tFroaIiMgyMOiYCYlE8m+HZPbTISIiMggGHTOiHTSQ/XSIiIgMgkHHjJS36HAsHSIiIsNg0DEjvPOKiIjIsBh0zMi/fXQ43xUREZEhMOiYEQ4aSEREZFgMOmakvEUnNbsYao0gcjVERES1H4OOGfF2lsNaKoFKIyAjj2PpEBER1RSDjhmxkkrgo5ADYIdkIiIiQ2DQMTMcNJCIiMhwGHTMTHmH5BS26BAREdWYdXVWCgkJgUQiqfJ60dHRmDp1anV2WWcEuDDoEBERGUq1gs6aNWuqtbPg4OBqrVeX8BZzIiIiw6lW0ImKijJ0HXSPv0v5fFccNJCIiKim2EfHzNzfoiMIHEuHiIioJthHx8z43ru9vLhUg6yCErg7ykSuiIiIqPZiHx0zI7exgqeTDLfzlLiUno+ODDpERETVxj46ZqhLAw9sO3kTi3ZdwJaJnSCVVr31jIiIiNhHxyy91asJHGXWOJmUjY1Hk8Quh4iIqNYySNApLS1FcnIyLl68iKysLENssk7zUcgxvUcjAMDCnRc47xUREVE1VTvo5OfnY8WKFejWrRsUCgWCg4MRFhYGT09P1KtXD+PHj0dcXJwha61ApVLhvffeQ0hICOzs7FC/fn188MEH0Gg0Rt2vKYzsGIwW/grkFavw0Y7zYpdDRERUK1Ur6Pzf//0fgoOD8c033+Cpp57C1q1bcerUKVy8eBGxsbGYM2cOVCoVunfvjl69euHy5cuGrhsAsHDhQixfvhxffPEFzp8/j0WLFmHx4sX4/PPPjbI/U7KSSjDv+RaQSoBfTt/Cwcu3xS6JiIio1pEI1RisZfDgwXj//ffRokWLR75PqVRi5cqVsLW1xSuvvFLtIivTt29feHt7Y+XKldplL7zwAuzt7bFu3Tq9tpGbmwuFQoGcnBw4OzsbvMaamvtLAtYcvo5gd3vsjO4KuY2V2CURERGJTt/v72q16Pz000+PDTkAIJPJMGnSJKOEHADo0qUL9u7di0uXLgEATp8+jUOHDuHZZ5+tdB2lUonc3Fydhzmb3qMRvJ1luJ5ZiK/2XxG7HCIiolqlSkGnd+/e2L59O9RqtbHqqZK33noLw4cPR5MmTWBjY4PWrVsjOjoaw4cPr3Sd+fPnQ6FQaB+BgYEmrLjqnOQ2mNuvGQBgWcxVXMnIF7kiIiKi2qNKQWfmzJnYvHkzGjZsiFmzZuHKFXFbGH744QesX78eGzduxIkTJ7B27Vp8/PHHWLt2baXrzJo1Czk5OdpHcnKyCSuunl7NffBkY0+UqgW8u+0Mp4YgIiLSU7X66OTk5GDDhg1YtWoVFAoFJkyYgOeffx62trbGqLFSgYGBePvttzF58mTtso8++gjr16/HhQsX9NqGuffRKZecVYju/xeD4lINPh7cEoPaBIhdEhERkWiM1kdHpVJBo9Ggb9++WLNmDZ5//nnMnj0bfn5+NSq4OgoLCyGV6n4EKysri7i9/EGBbvZ44+mysXXm/X4edwtKRK6IiIjI/FVpCgi5XA4PDw+0bt0ajo6OcHJygoODA4YNGwYnJydj1Vipfv364X//+x+CgoLQrFkznDx5EkuWLMHYsWNNXospvPJECLafvImL6XlY8McFLBwULnZJREREZq1Kl662bNmCVatWoaCgAK+88goGDx4MmUy8SSfz8vIwe/ZsbNu2DRkZGfDz88Pw4cPx/vvv630ZrbZcuip37HoWBi2PBQD8+GpHtAtxE7kiIiIi09P3+7tafXRSUlKwcuVK/Pzzz+jatSsmTJiAsLCwGhUsltoWdADg7S3x2BSXjIZejvht6hOwteaUZUREVLcYdRydgIAAzJo1C3/88QcaNWqEgQMH4oknnqh2sVQ1b/duAncHW1zOyMc3B6+JXQ4REZHZqlIfneDgYCiVSgiCAHt7ezg7O8PJyQmhoaFQKBTGqpEe4GJvi3f7NMW0H0/js72X0S/cD0Hu9mKXRUREZHaqFHTOnz8POzs7Y9VCVfB8a39sPp6Cw1czMfvns1gzpi0kEonYZREREZmVKl26Kg85L730knbqhN9//x3btm0zfGX0SBKJBB8OaA5bKyliLt3Gb2dSxS6JiIjI7FSrj058fDycnZ1x7tw5zJgxAzt37kR0dLSBS6PHCfV0xGvdQgEAH/x6DrnFpSJXREREZF6qFXRsbGwgCALWrFmDd999FytWrMDBgwcNXRvp4bVuoQjxcEBGnhKf7LoodjlERERmpVpB59VXX0Xbtm2xefNmDBgwAABQUFBgyLpIT3IbK3zYvzkA4Lt/buB0cra4BREREZmRagWdCRMmYM+ePYiPj4eDgwOuXLmC9u3bG7o20lOXhh4Y0MoPggC8s+0MVGrLmwKDiIioOqo90pyLiwvy8/MBAA0aNHjkjOFkfO/2CYOz3BoJt3KxNvaG2OUQERGZhRoNqdujRw9D1UE15Okkw9u9mwIAPvnzIhbuvICzN3NQjYGviYiILEaVxtF5EL9EzcuwtoH49fQtxF7LxLIDV7HswFUEu9ujT7gv+rTwQ1NfJ461Q0REdUq15roqFx4ejvj4eEPWY3K1ca6rR1Gq1Nh9Lh2/xadi34UMKFX/9tep7+FQFnrCfdHYm6GHiIhqL6NO6lmOQce8FShV2HshA7/F38L+i7dRcl/oCfV0QJ9wP/QN90UjbycRqyQiIqo6Bh09WXLQuV++UoW959OxIz4VMRdvo+S+O7MaejmiT7gv+ob7ooEXQw8REZk/kwSdyMhIHDt2rLqrm4W6EnTul1dcij3nyy5v/XXpjk7oqe/hgFAvR9Rzs0c9d3sEuTugnps9/F3tYGNVo77rREREBmOSoGMJ6mLQuV9ucSn23OvT89fl2yhVP/x0sJJK4O9iVxZ+ykOQmwPquZf93d62Rv3aiYiIqoRBR091PejcL6ewFCeT7yIpqxA3MgtxI7MANzILkZRVqNOp+WE8HGUIdLODt5McXs4yeDnJ4OUkh+d9f3d3sIVUyg7QRERUc/p+f9f4v+E5OTn4z3/+g3379sHGxgb79u2Dr69vTTdLIlDY26BbY68KyzUaARl5yrLgk1WIpMzCe3+WPc8uLMWdfCXu5CsfuX0rqQQejrbwcpKXhR9nGTzv/d3HWY5AN3sEutmxdYiIiAymxt8okyZNwrVr17Bo0SK89NJLKCoqAgBER0cjJCQEb7zxRo2LJHFJpRL4KOTwUcjRvr57hddzikqRlFmIlLuFyMhTIiOvGBm5ynt/V+J2XjEyC0qg1ghIz1UiPffRgcjDUYYgNzsEuZVdJgu892eQuz28neRsFSIiIr3V+NKVm5sb9u7di9atW8PJyQmnT59G/fr1sXPnTrz33ntm31mZl65Mo1StQWZ+yQMhqLjsz1wl0nKLkJxVhJyi0kdux9ZKioD7QlD5o5m/An4KOccGIiKqI0x26QoAHB0dKyxr2LAhrly5YojNkwWwsZJqW4UeJaewFMl3y/oFlT+S7/15824RStQaXLtdgGu3Cyqs6+5gi+b+CrTwV6BFQNmfvgw/RER1Wo2DzrPPPouNGzdizpw5Osvz8/P5BUNVprC3gcJegeb+igqvqdQapOYUa4NPWSAqwpWMfFxOz0NmQQliLt1GzKXb2nU8HO8LP/cCkI8zww8RUV1R46Azf/58REZGAiib+0oikaCoqAgffPABIiIialwgUTlrK+m9Dsv26PTAa8WlalxIy8OZmzk4k5KNMzdzcSk9D3fyS3Dg4m0cuKgbfsqDT3iACzqGusNBxg7QRESWyCC3l1+5cgWvvfYa9u7dC3d3d+Tl5cHZ2Rm///67NgSZK/bRsVzFpWqcT83F2Zs5iE/JwZmbObickQ+1RveUt7WSolMDdzzT1BvPNPV+7OU1IiISnyjj6CQlJeH06dOwsbFB+/bt4erqaqhNGw2DTt1SXKrGufvCz9HELCRlFeq8p4W/oiz0hHkhzNeZl7mIiMyQ0YNO+WWq2o5Bp24TBAFXMvKx+3w69pxLx8nkbNz/L8JPIcczYWUtPe3ru0FmbSVesUREpGX0oOPg4IBWrVqhTZs22kdYWBik0to1HxKDDt3vdp4S+y9kYPf5dBy8fBvFpf+OCO0os0ZUI088E+aFbo284OpgK2KlRER1m9GDzldffYUTJ07g+PHjSEhIgFqthlwuR3h4uDb4REREoGXLltX+EKbAoEOVKS5V4+8rd7DnfDr2nM/A7bx/BzqUSoC2wW4Y0T4Iz7bw5YSnREQmZtI+OkqlEnZ2dnjnnXeQlZWFEydOID4+HkqlEmq1uqabNyoGHdKHRiMg/mYO9pxLx57z6biQlqd9zVchx8iOwRjRLggKexsRqyQiqjtM3hlZKpXi1KlTCA8PBwCo1WokJCRon5srBh2qjuSsQmw9cRPr/rmOO/klAAA7GysMjgzAmM4hCPFwELlCIiLLJnrQqS0YdKgmlCo1fjl1CysPJWpbeSQS4OkmXhjXpT461HeziE77RETmxqRTQBDVVTJrKwyODMSgNgE4fDUTKw8lYt+FDOw5X/YI83XGuC4h6NfSD7bW7MdDRGRq1W7RGT9+PNq0aYPIyEi0aNECdnZ2OH36NFq0aGHoGo2KLTpkaFcy8rH670RsOZGivWvLy0mGkR3rYUT7enDj3VpERDVm9EtXXbt2xenTp5GXlwdra2uoVCoMHDgQ3bp1Q0REBFq1agV7e/tqfwBTYdAhY7lbUIKNR5Ow9vB1ZNy7Y0tmLcXAiACM6xKMBl5OIldIRFR7mayPzuXLl3H8+HHtreYnT55EdnY2rKys0KhRIyQkJNRk80bHoEPGVqLS4LczZf14zt7M1S4f3CYAb/duAndHmYjVERHVTqJMAVEuMTERx44dw8mTJzFv3jxDb96gGHTIVARBwNHELHx7KBG7z6UDABR2NpjZqzGGtQ2ClZSdlomI9GWUoNO7d2+8+uqr6NevH6ysLGMofAYdEsPxG3fx3vazOJ9a1sLTMkCBjwa0QIsAhciVERHVDvp+f1fpNpCZM2di8+bNaNiwIWbNmoUrV67UuFCiuqhNPVf8OqUz5vQLg6PMGqdTcvDcl4cwe/tZ5BSWil0eEZHFqNalq5ycHGzYsAGrVq2CQqHAhAkT8Pzzz8PWtvbdTcIWHRJbRm4x/vf7efx86hYAwN3BFu882xQDI/w5Bg8RUSWM1kdHpVIhLy8PeXl5yM3NxYEDB/DZZ58hKysLd+7cqXHhpsagQ+bi8NU7mL39LK7eLgAAtAt2w4cDmqOxD+/OIiJ6kFGCjlwuh4eHB1q3bg1HR0c4OTnBwcEBTk5OcHJywn/+8x+DFG9KDDpkTkpUGqw8lIjP9l5GUakaVlIJxnYOxhvPNIKjjON7EhGVM0rQ2bJlC1atWoWCggK88sorGDx4MGSy2n1rLIMOmaOb2UX44NcE7EoouzvL21mG9/s2w7MtfHg5i4gIRr69PCUlBStXrsTPP/+Mrl27YsKECQgLC6tRwWJh0CFztv9CBub8koCkrEIAwBMNPfDf55qhvqejyJUREYnL6OPolJSU4O7du9iyZQs+++wzeHp64uDBg9UuWCwMOmTuikvVWHbgKpbFXEWJSgNbKylm9mqMcV1C2LpDRHWWUSb1DA4OhlKphCAIsLe3h7OzM5ycnBAaGgqFguN/EBmD3MYKb3ZvhOdb+2POLwmIuXQbH/12HnHXs7BoUEso7GzELpGIyGxVqUWnqKgIdnZ2xqzH5NiiQ7WJIAhY988NfLjjHErVAuq52+OrFyPQzI//0SCiusUoAwaWh5yXXnoJubllI7r+/vvv2LZtWw1KJSJ9SSQSjOwYjJ8mdoK/ix1uZBbi+a8OY9PRJBhhNhciolqvSkGnXHx8PJydnXHu3DnMmDEDO3fuRHR0tIFLI6LKtAp0wW9Tu+CpJl4oUWnw9tYzmP7TaRSWqMQujYjIrFQr6NjY2EAQBKxZswbvvvsuVqxYUSs7IhPVZi72tvh2ZCRm9moMqQTYeuImBnz5N67ezhe7NCIis1GtoPPqq6+ibdu22Lx5MwYMGAAAKCgoMGRdRKQHqVSCSd0aYMMrHeDhKMOl9Hw89/kh/Hr6ltilERGZhWoFnQkTJmDPnj2Ij4+Hg4MDrly5gvbt2xu6NiLSU8dQd/w+tQvah7ihoESN178/iTk/n4VSpRa7NCIiUVV7HB1LwbuuyJKo1Bos2X0JXx24CgBoGaDAly9GIMDVXuTKiIgMyyh3XT1MTk4OJkyYgAYNGqBp06ZITU2t6SaJqJqsraSY2asJVo2OhMLOBqdTctDns0PYfyFD7NKIiERR46AzadIknDlzBosWLcKNGzdQVFQEAIiOjsann35a4wKJqOqeauKNHa93QcsABXKKSjFmTRwW7bwAlVojdmlERCZV46Dzxx9/4KuvvsLAgQNhZWWlXd6rVy+sW7euppsnomoKdLPHjxM7YlTHegCArw5cxUsrj+B2nlLkyoiITKfGQQcAHB0rTjDYsGFDXLlyxRCbJ6Jqkllb4b/9m+Pz4a3hYGuFf65lYeCyv3GNt6ATUR1R46Dz7LPPYuPGjRWW5+fnc8JBIjPRr6Uffp7SBUFu9kjOKsILyw7jRNJdscsiIjK6Kk3q+TDz589HZGQkgLJ5eCQSCYqKivDBBx8gIiKixgUSkWE08HLEltc6YdzaOMSn5GDEN//g8+ER6B7mLXZpRERGU+MWncDAQPz99984dOgQCgsL0a5dO7i6uuLgwYNYuHChIWokIgPxdJJh04QOeLKxJ4pLNXh13TGs/+eG2GURERmNQcfRSUpKwunTp2FjY4P27dvD1dXVUJs2Go6jQ3WRSq3Be9vPYlNcMgBg8pOhmNGjMS83E1Gtoe/3d7WCTlJSEoKCgvR+/82bN+Hv71/V3ZgEgw7VVYIg4NO9l7F0z2UAwMAIfyx8IRw2Vga5R4GIyKiMOmBg27ZtMX78eBw9erTS9+Tk5OCbb75B8+bNsXXr1urshoiMSCKRIPqZRlj4QgtYSSXYeuImxq6JQ76SM6ATkeWoVmfk8+fPY968eejVqxdsbGwQGRkJPz8/yOVy3L17F+fOnUNCQgIiIyOxePFi9O7d29B1E5GBDG0bBC8nOSZtOIGDl+9g6IpYrB7dFl7OcrFLIyKqsRr10SkuLsbvv/+OgwcP4vr16ygqKoKHhwdat26Nnj17onnz5oas1Sh46YqoTHxKNsauicOd/BL4u9hh7dh2aOBVcYwsIiJzYNQ+Og/uqDYHBAYdon8lZRZi1OqjSLxTABd7G3w7MhKRwW5il0VEVIHJJvV0dXXFli1baroZIjIDQe722DyxI1oFuiC7sBQvfnsEO8+miV0WEVG11TjoCIKAZcuWoX379ujQoQOmTJmCI0eOGKI2IhKBu6MM34/vgGeaekOp0uC1Dcex9vB1scsiIqoWg9xHevr0abRr1w7dunXDxYsXERUVhTfffNMQmyYiEdjZWmH5SxF4sX0QBAGY80sC5v9xHhqNwYbdIiIyiRpPAQEAGzduRPfu3bXPz5w5gwEDBiAgIADTp083xC4qdfPmTbz11lv4448/UFRUhEaNGmHlypVo06aNUfdLZOmsraT4aEBz+LnYYfGui1gRcw2385RY9EI4rDnWDhHVEjX+beXu7o7AwECdZS1atMBnn32G5cuX13Tzj3T37l107twZNjY2+OOPP3Du3Dl88skncHFxMep+ieoKiUSCyU82wCeDW2rH2pm04QSKS9Vil0ZEpJcaB52WLVti5cqVFZY3aNAAycnJNd38Iy1cuBCBgYFYvXo12rVrh+DgYDz99NMIDQ016n6J6poX2gRgxUttYGstxZ/n0jmwIBHVGjUOOh999BG++OILjBgxAocOHUJubi7S09Mxb948hISEGKLGSv3yyy+IjIzE4MGD4eXlhdatW+Obb7555DpKpRK5ubk6DyJ6vGfCvLF2TDs42Frh8NVMvPjtEdwtKBG7LCKiR6px0OnQoQP++ecf3Lp1C926dYOrqyv8/PywefNmfPLJJ4aosVLXrl3DsmXL0LBhQ+zatQsTJ07E1KlT8d1331W6zvz586FQKLSPBy+7EVHlOoa6Y+P4DnCxt8Hp5GwM/ToW6bnFYpdFRFQpg85enpGRgePHj0Oj0aB9+/bw8PAw1KYfytbWFpGRkTh8+LB22dSpUxEXF4fY2NiHrqNUKqFUKrXPc3NzERgYyAEDiargUnoeXl55BOm5SgS62WHDuA4IcrcXuywiqkNMNmDg/by8vNC7d2/06dPH6CEHAHx9fREWFqazrGnTpkhKSqp0HZlMBmdnZ50HEVVNI28nbJ7YCUFu9kjOKsKg5YdxMS1P7LKIiCqo1feIdu7cGRcvXtRZdunSJdSrV0+kiojqjkC3slGUG3s7ISNPiSErYnEy6a7YZRER6ajWpauQkBBIJJIq7yw6OhpTp06t8nqViYuLQ6dOnfDf//4XQ4YMwdGjRzF+/Hh8/fXXePHFF/XaBue6IqqZ7MISjF4dh1PJ2bC3tcI3IyPRuYHxW3SJqG4z6qSeMTEx1SoqODjY4K0tO3bswKxZs3D58mWEhIRg2rRpGD9+vN7rM+gQ1VyBUoUJ647h7yuZsLWS4vMRrdGzmY/YZRGRBTPZ7OW1HYMOkWEoVWpM/f4kdiWkw0oqwaIXwvFCmwCxyyIiCyVKZ2Qiqrtk1lb4ckQEXogIgFojYPpPp7Hm70SxyyKiOq5ac12ZSx8dIjIv1lZSLB4UDmc7a6z++zrm/noOOUUqTH26QbV+ZxAR1VS1gs6aNWuqtbPg4OBqrUdEtYdUKsH7fcOgsLPB0j2X8X97LiGnqBTv9WkKqZRhh4hMq1pBJyoqytB1EJEFkUgkiH6mEZzlNvhgxzms+jsRucWlWDCwBWc+JyKT4m8cIjKasV1C8PG9mc83H0/hzOdEZHIMOkRkVIPaBOCrFyNga1U28/mY1Zz5nIhMh0GHiIyuZzMfrBnTFg62Voi9lokXv/kHWZz5nIhMgEGHiEyiUwMPbBzfAa72NjidkoMhK2KRmlMkdllEZOEYdIjIZFoGuuCniR3h4yzHlYx8DFoWi2u388Uui4gsGIMOEZlUAy8nbH6tI0I8HHAzuwhDVsQi4VaO2GURkYVi0CEikwtwtcePr3ZEmK8z7uSXYNiKf3A0MUvssojIAjHoEJEoPJ1k2PRqB7QLdkOeUoWXVx7BvgvpYpdFRBaGQYeIROMst8Hase3wVBMvKFUaTPjuOH4+dVPssojIgjDoEJGo7GytsOLlNujfyg8qjYDoH05hXex1scsiIgvBoENEorOxkuL/hrTCyI71IAjA7J8T8PneyxAEQezSiKiWY9AhIrMglUrw3+eaYepTDQAAn+y+hA93nIdGw7BDRNXHoENEZkMikWBaj8aY3TcMALDq70TM3BIPlVojcmVEVFsx6BCR2Rn3wGSgE9YdRwHnxyKiamDQISKzNKhNAJa9GAGZtRT7LmRgyIpYpOUUi10WEdUyDDpEZLZ6NPPB9xM6wN3BFgm3cjHgy79x7lau2GURUS3CoENEZi0iyBXbJ3dGqKcD0nKLMXj5Yey/mCF2WURUSzDoEJHZC3Szx9bXOqNjfXcUlKjxytpjWPfPDbHLIqJagEGHiGoFhX3ZKMqD2gRArREwe/tZ/O+3c7z9nIgeiUGHiGoNW2spFg8Kx4wejQAA3xxMxGsbjqOoRC1yZURkrhh0iKhWkUgkmPJUQ3w6rBVsraTYlZCOYV/HIiOPd2QRUUUMOkRUK/Vv5Y8N49vDxd4Gp1Ny8PyXh3EpPU/ssojIzDDoEFGt1TbYDdsmdUawuz1uZhfhhWWHcejyHbHLIiIzwqBDRLVaiIcDtk3qjLbBrsgrVmH06qP4MS5Z7LKIyEww6BBRrefqYIv1r7RH/1Z+UGkEzNwSj0U7L/COLCJi0CEiyyCztsLSoa20s59/deAqpm46ieJS3pFFVJcx6BCRxSif/XzxoHBYSyXYEZ+KoSticSu7SOzSiEgkDDpEZHEGRwbiu3HttHdk9f38EA5fYSdlorqIQYeILFKnUA/8OqULmvk5I6ugBC+tPILlMVchCOy3Q1SXMOgQkcUKdLPHltc6YVCbAGgEYMEfFzBpwwnkK1Vil0ZEJsKgQ0QWTW5jhcWDwvHRgOawsZLgj7Np6P/FIVzJyBe7NCIyAQYdIrJ4EokEL3Wohx9e7QgfZzmu3i5A/y8O4Y8zqWKXRkRGxqBDRHVGRJArfn29C9qHuKGgRI3XNpzAgj8uQKXWiF0aERkJgw4R1SmeTjJseKU9XukSAgBYHnMVo1YfRWa+UuTKiMgYGHSIqM6xtpLivb5h+Hx4a9jbWuHvK5no9/khnE7OFrs0IjIwBh0iqrP6tfTD9smdEeLhgFs5xRi8PBabjiaJXRYRGRCDDhHVaY28nfDzlM7oHuaNErUGb289g7e3xHPqCCILwaBDRHWes9wGK15qg//0bAyJBNgUl4whK2KRcrdQ7NKIqIYYdIiIAEilEkx+sgHWjimbOiI+JQe9Pz2I7SdvcjRlolqMQYeI6D5dG3ni1yld0DrIBXnFKkT/cApTvj+J7MISsUsjompg0CEiekCgmz1+erUjpnVvBCupBL/Fp6Ln0r9w8PJtsUsjoipi0CEieghrKymmPt0QW1/rhPoeDkjPVeLllUcx95cEdlQmqkUYdIiIHqFloAt+m/oEXu5QDwCw5vB19P38EM7ezBG5MiLSB4MOEdFj2Nla4cMBzbF6TFt4OslwJSMfA778G1/uvwK1hh2VicwZgw4RkZ6ebOyFXdFd0auZD1QaAYt3XcTQFbFIyuRt6ETmikGHiKgK3BxsseylCHw8uCUcZdY4duMuen/6F36MS+Zt6ERmiEGHiKiKJBIJBrUJwB9vPIG2wa4oKFFj5pZ4vLruOCcHJTIzDDpERNUU6GaPTRM64q1eTWBjJcGf59LRc+lB7LuQLnZpRHQPgw4RUQ1YSSV4rVsotk3qjIZejriTr8TYNccwc/NpDjJIZAYYdIiIDKC5vwK/vt4F47qEAAB+PJaCZ5bE4OdTnEKCSEwMOkREBiK3scLsvmH4aWJHNPByxJ38Eryx6RRGrY5DchbvzCISA4MOEZGBtQ12w29Tu2Ba90awtZLir0u30f3/YrAi5ipUao3Y5RHVKQw6RERGILO2wtSnG+KP6CfQob4biks1mP/HBfT74m+cTs4WuzyiOoNBh4jIiEI9HfH9+A5YNCgcLvY2OJ+aiwFf/Y25vyQgX6kSuzwii8egQ0RkZBKJBEMiA7FnWhQGtPKDIJTNmdV9SQx2n+Ot6ETGxKBDRGQiHo4yLB3WGt+NbYdANzuk5hRj/HfHMHHdcaTlFItdHpFFYtAhIjKxro088Wd0FCZGhcJKKsHOhDQ8syQG38Ve5yShRAbGoENEJAI7Wyu83bsJdrzeBa0CXZCvVOH9nxMwaPlhnLuVK3Z5RBZDItTxkaxyc3OhUCiQk5MDZ2dnscshojpIrRGw/p8bWLzrIvKVKkgkwNDIQEzv0RieTjKxyyMyS/p+f7NFh4hIZFZSCUZ1CsbuaV3RJ9wXggBsikvGkx8fwFcHrqC4VC12iUS1Flt02KJDRGYm7noWPtxxDvEpOQCAAFc7zOrdFM+28IFEIhG5OiLzoO/3N4MOgw4RmSGNRsD2UzexaOdFpOWW3ZHVNtgVs/uGITzARdziiMwAg46eGHSIyJwVlqiwIuYaVvx1FcWlZdNHDIzwx8yeTeCjkItcHZF4GHT0xKBDRLVBak4RFu+8iK0nbwIA7Gys8GpUfbzaNRR2tlYiV0dkenWyM/L8+fMhkUgQHR0tdilERAblq7DDkqGtsH1yZ7Sp54qiUjWW7rmMJz8+gK0nUqDh+DtED2UxQScuLg5ff/01wsPDxS6FiMhoWgW6YPPEjvhiRGv4u9ghLbcY0348jee/+hvHrmeJXR6R2bGIoJOfn48XX3wR33zzDVxdXcUuh4jIqCQSCfqG+2Hv9Cj8p2djONha4XRKDgYtj8Vr64/jSkae2CUSmQ2LCDqTJ09Gnz598Mwzz4hdChGRychtrDD5yQbY/59uGNY2EBIJ8MfZNPT4v78w/cfTSM4qFLtEItFZi11ATW3atAknTpxAXFycXu9XKpVQKpXa57m5HGqdiGo3Lyc5FrwQjjGdQ/DJnxfx57l0bDmRgl9O38TwdkGY8mQDeDnzDi2qm2p1i05ycjLeeOMNrF+/HnK5fv+I58+fD4VCoX0EBgYauUoiItNo7OOEr0dGYvvkzujSwAOlagHfxd5A18X7Mf+P87hbUCJ2iUQmV6tvL9++fTuef/55WFn9e2ulWq2GRCKBVCqFUqnUeQ14eItOYGAgby8nIotz+OodfLzrIk4kZQMAnGTWGN+1PsZ2CYGjrNY36FMdVyfG0cnLy8ONGzd0lo0ZMwZNmjTBW2+9hebNmz92GxxHh4gsmSAI2H8xA4t3XcL51LJL9W4OtpjULRQvdagHuQ3H4KHaqU4EnYfp1q0bWrVqhaVLl+r1fgYdIqoLNBoBv51JxZLdl5B4pwAA4OMsx+tPN8CQyEDYWNXqngxUB9XJAQOJiOjhpFIJ+rX0w+43u2LRC+HwU8iRlluMd7edxTNLYrD95E2oOeggWSCLa9GpKrboEFFdpFSpsfFIEr7cfwV38ss6KYd6OmBStwZ4rpUfW3jI7NXZS1dVxaBDRHVZgVKFNYevY0XMVeQWqwAAAa52mBgVikFtAtiHh8wWg46eGHSIiIC84lKs++cGVh5MROa929C9nGQY/0R9jGgfBAfepUVmhkFHTww6RET/KipR44e4JKz46xpSc4oBAC72NhjTKQSjOwVDYW8jcoVEZRh09MSgQ0RUUYlKg20nU7DswFVczyybSsJRZo2XOtTDuC4h8HSSiVwh1XUMOnpi0CEiqpz63m3pX+2/ggtpZZOFyqylGNY2EBOiQuHvYidyhVRXMejoiUGHiOjxNBoB+y5k4Iv9V3AqORsAYC2VYGCEP17r1gAhHg7iFkh1DoOOnhh0iIj0JwgCDl/NxJf7r+Dw1UwAgFQC9G7ui7FdQtCmnqvIFVJdwaCjJwYdIqLqOZF0F1/uu4K9FzK0y1oHuWBclxD0auYDa47FQ0bEoKMnBh0iopq5kJaLVYcSsf3kLZSoNQAAfxc7jOpUD0PbBkFhxzu1yPAYdPTEoENEZBi385RY/88NrP/nhnYsHgdbKwyODMSYzsGo585+PGQ4DDp6YtAhIjKs4lI1fj51EysPJeJSej4AQCIBeoR5Y1yX+mgb7AqJRCJylVTbMejoiUGHiMg4BEHAwct3sPJQImIu3dYub+GvwLguIegT7ss5tajaGHT0xKBDRGR8l9PzsOrvRGw9cRNKVVk/Hh9nOUZ2qocR7YLgYm8rcoVU2zDo6IlBh4jIdDLzldhwJAnfxd7AnXwlAMDWWoq+LXwxon0Q2tTjZS3SD4OOnhh0iIhMT6lS49fTqVh1KBHnUnO1yxt7O2FE+yA8H+EPZznv1qLKMejoiUGHiEg8giDgVHI2NhxJwo74WyguLbusZWdjhX4tffFi+3oID1CwlYcqYNDRE4MOEZF5yCkqxbYTKdhwJAmXM/K1y5v5OWNE+yD0b+UPR5m1iBWSOWHQ0RODDhGReREEAcdu3MXGI0n47UwqSu51XnawtUL/1v54sX0QmvkpRK6SxMagoycGHSIi83W3oARbTqRg45EkXLtToF3eMtAFL7YLQt+WvrC3ZStPXcSgoycGHSIi8ycIAmKvZWLjkSTsSkhDqbrsq8vB1gq9W/hiYIQ/OoS4QyplX566gkFHTww6RES1y518JX46loLvjyYhKatQu9xPIceA1v4YGOGPBl5OIlZIpsCgoycGHSKi2qm8L8/WEzexI/4W8opV2tfCAxR4vrU/+rX0g4ejTMQqyVgYdPTEoENEVPsVl6qx70IGtp5IwYGLt6HSlH21WUsliGrkiYERAXi6qRfkNlYiV0qGwqCjJwYdIiLLkpmvxK+nb2HbyZs4nZKjXe4kt0afFr4YGBGAyHqu7M9TyzHo6IlBh4jIcl3JyMe2kynYfvIWbmYXaZcHuNrhuZZ+6N3cF839nTkgYS3EoKMnBh0iIsun0Qg4kpiFbSdT8PuZNOQr/+3P4+9ih57NfNCzmTcig91gxZaeWoFBR08MOkREdUtRiRp7zqdj59k07L+YgcIStfY1dwdb9GjmjZ7NfNAp1AO21lIRK6VHYdDRE4MOEVHdVVyqxsHLd7DzbBr2nE9HTlGp9jUnmTWeauqFXs18ENXYkwMTmhkGHT0x6BAREQCUqjU4ci0LOxNSsSshHbfzlNrXZNZSRDXyRM9mPnimqTcU9pxZXWwMOnpi0CEiogdpNAJOJmdjV0Iadp5N0xmY0FoqQesgF0QEuaJ1kAtaB7nC21kuYrV1E4OOnhh0iIjoUQRBwPnUPOxMSMOus2m4mJ5X4T1+CjlaBbmgdWBZ+Gnur+CYPUbGoKMnBh0iIqqK63cKcPR6Fk4mZeNUcjYupuVC88A3qbVUgjA/Z7QKdClr9Ql0RT13e97GbkAMOnpi0CEiopooUKoQn5KDk8l3cTIpGyeTsnEnX1nhfa72Nmgd5Iqmvk4IcrNHoKs9At3s4auQw9qKd3dVFYOOnhh0iIjIkARBwM3sIm3oOZl8Fwk3c1Gi1jz0/dZSCfxc7BDoZocgN3sE3AtAZWHIDm4OtmwJeggGHT0x6BARkbEpVWqcT83DyaS7uHo7H8lZRUjOKkTK3aJKA1A5B1srBLqVhR9/Fzv4KOTwVcjh7fzvn3WxPxCDjp4YdIiISCwajYD0vGIkZxUhKasQyeWPu4VIyipEem7FS2AP42pvow0+Pgo5fJzt4KOQwUdhBx/nsmXOcmuLahnS9/ubox8RERGJRCqVwFdhB1+FHdqFuFV4vbhUjZS7RUi+WxaAbmUXIy2nCGm5xUjLKUZabjGKSzW4W1iKu4WluJBW8Y6wcnY2VvBylsHLSQYvJ/m9v8vh5SSDt7Nc+5rCzsaiAhGDDhERkZmS21ihgZcjGng5PvR1QRCQU1SKtNxipOYUIz3n3p+5un/mFJWiqFSNG5mFuJFZ+NBtlbO1lt4LQ2VByNtZBi9nOTwcbeHpJIOnoxweTrZwd5DViikyGHSIiIhqKYlEAhd7W7jY26KJT+WXb4pK1EjPLUZGnhIZecVIzy3783auEhl5Su1rOUWlKFFpkHK3CCl3iyrdXjlXext4Osng4Si7F4Jkus/v/d3dwRZSkSZLZdAhIiKycHa2Vgj2cECwh8Mj31dcqsbte2Eo474QdDtPiTv5StzOV+J2nhKZ+SVQaQTtJbNL6fmP3O7uN7uiobeTIT+S3hh0iIiICEDZpbLyO7weRaMRkF1Uitt5yn9DUF5ZELqT928gup2nRFZhCTwcZSb6BBUx6BAREVGVSKUSuDnYws3BFo19Ht1So1JrYCXSZSuAQYeIiIiMSOxRn82/uzQRERFRNTHoEBERkcVi0CEiIiKLxaBDREREFotBh4iIiCwWgw4RERFZLAYdIiIislgMOkRERGSxGHSIiIjIYjHoEBERkcVi0CEiIiKLxaBDREREFotBh4iIiCxWnZ+9XBAEAEBubq7IlRAREZG+yr+3y7/HK1Png05eXh4AIDAwUORKiIiIqKry8vKgUCgqfV0iPC4KWTiNRoNbt27ByckJEonEYNvNzc1FYGAgkpOT4ezsbLDtWiIeK/3xWFUNj5f+eKz0x2OlP2MeK0EQkJeXBz8/P0illffEqfMtOlKpFAEBAUbbvrOzM/8h6InHSn88VlXD46U/Hiv98Vjpz1jH6lEtOeXYGZmIiIgsFoMOERERWSwGHSORyWSYM2cOZDKZ2KWYPR4r/fFYVQ2Pl/54rPTHY6U/czhWdb4zMhEREVkutugQERGRxWLQISIiIovFoENEREQWi0GHiIiILBaDjpF89dVXCAkJgVwuR5s2bXDw4EGxSzI7c+fOhUQi0Xn4+PiIXZZZ+Ouvv9CvXz/4+flBIpFg+/btOq8LgoC5c+fCz88PdnZ26NatGxISEsQpVmSPO1ajR4+ucJ516NBBnGJFNn/+fLRt2xZOTk7w8vLCgAEDcPHiRZ338Nwqo8+x4rlVZtmyZQgPD9cOCtixY0f88ccf2tfFPqcYdIzghx9+QHR0NN59912cPHkSTzzxBHr37o2kpCSxSzM7zZo1Q2pqqvZx5swZsUsyCwUFBWjZsiW++OKLh76+aNEiLFmyBF988QXi4uLg4+OD7t27a+duq0sed6wAoFevXjrn2e+//27CCs1HTEwMJk+ejH/++Qe7d++GSqVCjx49UFBQoH0Pz60y+hwrgOcWAAQEBGDBggU4duwYjh07hqeeegr9+/fXhhnRzymBDK5du3bCxIkTdZY1adJEePvtt0WqyDzNmTNHaNmypdhlmD0AwrZt27TPNRqN4OPjIyxYsEC7rLi4WFAoFMLy5ctFqNB8PHisBEEQRo0aJfTv31+UesxdRkaGAECIiYkRBIHn1qM8eKwEgefWo7i6ugrffvutWZxTbNExsJKSEhw/fhw9evTQWd6jRw8cPnxYpKrM1+XLl+Hn54eQkBAMGzYM165dE7sks5eYmIi0tDSdc0wmkyEqKornWCUOHDgALy8vNGrUCOPHj0dGRobYJZmFnJwcAICbmxsAnluP8uCxKsdzS5darcamTZtQUFCAjh07msU5xaBjYHfu3IFarYa3t7fOcm9vb6SlpYlUlXlq3749vvvuO+zatQvffPMN0tLS0KlTJ2RmZopdmlkrP494jumnd+/e2LBhA/bt24dPPvkEcXFxeOqpp6BUKsUuTVSCIGDatGno0qULmjdvDoDnVmUedqwAnlv3O3PmDBwdHSGTyTBx4kRs27YNYWFhZnFO1fnZy41FIpHoPBcEocKyuq53797av7do0QIdO3ZEaGgo1q5di2nTpolYWe3Ac0w/Q4cO1f69efPmiIyMRL169fDbb79h4MCBIlYmrilTpiA+Ph6HDh2q8BrPLV2VHSueW/9q3LgxTp06hezsbGzZsgWjRo1CTEyM9nUxzym26BiYh4cHrKysKiTVjIyMComWdDk4OKBFixa4fPmy2KWYtfI703iOVY+vry/q1atXp8+z119/Hb/88gv279+PgIAA7XKeWxVVdqwepi6fW7a2tmjQoAEiIyMxf/58tGzZEp9++qlZnFMMOgZma2uLNm3aYPfu3TrLd+/ejU6dOolUVe2gVCpx/vx5+Pr6il2KWQsJCYGPj4/OOVZSUoKYmBieY3rIzMxEcnJynTzPBEHAlClTsHXrVuzbtw8hISE6r/Pc+tfjjtXD1OVz60GCIECpVJrHOWWSLs91zKZNmwQbGxth5cqVwrlz54To6GjBwcFBuH79utilmZXp06cLBw4cEK5duyb8888/Qt++fQUnJyceJ0EQ8vLyhJMnTwonT54UAAhLliwRTp48Kdy4cUMQBEFYsGCBoFAohK1btwpnzpwRhg8fLvj6+gq5ubkiV256jzpWeXl5wvTp04XDhw8LiYmJwv79+4WOHTsK/v7+dfJYvfbaa4JCoRAOHDggpKamah+FhYXa9/DcKvO4Y8Vz61+zZs0S/vrrLyExMVGIj48X3nnnHUEqlQp//vmnIAjin1MMOkby5ZdfCvXq1RNsbW2FiIgInVsSqczQoUMFX19fwcbGRvDz8xMGDhwoJCQkiF2WWdi/f78AoMJj1KhRgiCU3QY8Z84cwcfHR5DJZELXrl2FM2fOiFu0SB51rAoLC4UePXoInp6ego2NjRAUFCSMGjVKSEpKErtsUTzsOAEQVq9erX0Pz60yjztWPLf+NXbsWO33naenp/D0009rQ44giH9OSQRBEEzTdkRERERkWuyjQ0RERBaLQYeIiIgsFoMOERERWSwGHSIiIrJYDDpERERksRh0iIiIyGIx6BAREZHFYtAhojovODgYS5cuFbsMIjICBh0iMqnRo0djwIABAIBu3bohOjraZPtes2YNXFxcKiyPi4vDhAkTTFYHEZmOtdgFEBHVVElJCWxtbau9vqenpwGrISJzwhYdIhLF6NGjERMTg08//RQSiQQSiQTXr18HAJw7dw7PPvssHB0d4e3tjZdffhl37tzRrtutWzdMmTIF06ZNg4eHB7p37w4AWLJkCVq0aAEHBwcEBgZi0qRJyM/PBwAcOHAAY8aMQU5OjnZ/c+fOBVDx0lVSUhL69+8PR0dHODs7Y8iQIUhPT9e+PnfuXLRq1Qrr1q1DcHAwFAoFhg0bhry8POMeNCKqMgYdIhLFp59+io4dO2L8+PFITU1FamoqAgMDkZqaiqioKLRq1QrHjh3Dzp07kZ6ejiFDhuisv3btWlhbW+Pvv//GihUrAABSqRSfffYZzp49i7Vr12Lfvn2YOXMmAKBTp05YunQpnJ2dtfubMWNGhboEQcCAAQOQlZWFmJgY7N69G1evXsXQoUN13nf16lVs374dO3bswI4dOxATE4MFCxYY6WgRUXXx0hURiUKhUMDW1hb29vbw8fHRLl+2bBkiIiIwb9487bJVq1YhMDAQly5dQqNGjQAADRo0wKJFi3S2eX9/n5CQEHz44Yd47bXX8NVXX8HW1hYKhQISiURnfw/as2cP4uPjkZiYiMDAQADAunXr0KxZM8TFxaFt27YAAI1GgzVr1sDJyQkA8PLLL2Pv3r343//+V7MDQ0QGxRYdIjIrx48fx/79++Ho6Kh9NGnSBEBZK0q5yMjICuvu378f3bt3h7+/P5ycnDBy5EhkZmaioKBA7/2fP38egYGB2pADAGFhYXBxccH58+e1y4KDg7UhBwB8fX2RkZFRpc9KRMbHFh0iMisajQb9+vXDwoULK7zm6+ur/buDg4POazdu3MCzzz6LiRMn4sMPP4SbmxsOHTqEcePGobS0VO/9C4IAiUTy2OU2NjY6r0skEmg0Gr33Q0SmwaBDRKKxtbWFWq3WWRYREYEtW7YgODgY1tb6/4o6duwYVCoVPvnkE0ilZY3VP/7442P396CwsDAkJSUhOTlZ26pz7tw55OTkoGnTpnrXQ0TmgZeuiEg0wcHBOHLkCK5fv447d+5Ao9Fg8uTJyMrKwvDhw3H06FFcu3YNf/75J8aOHfvIkBIaGgqVSoXPP/8c165dw7p167B8+fIK+8vPz8fevXtx584dFBYWVtjOM888g/DwcLz44os4ceIEjh49ipEjRyIqKuqhl8uIyLwx6BCRaGbMmAErKyuEhYXB09MTSUlJ8PPzw99//w21Wo2ePXuiefPmeOONN6BQKLQtNQ/TqlUrLFmyBAsXLkTz5s2xYcMGzJ8/X+c9nTp1wsSJEzF06FB4enpW6MwMlF2C2r59O1xdXdG1a1c888wzqF+/Pn744QeDf34iMj6JIAiC2EUQERERGQNbdIiIiMhiMegQERGRxWLQISIiIovFoENEREQWi0GHiIiILBaDDhEREVksBh0iIiKyWAw6REREZLEYdIiIiMhiMegQERGRxWLQISIiIovFoENEREQW6/8BFFD6130ancUAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.title(str(nqubits) + ' spins TFIM magnetic field diagonalization')\n", "plt.plot(off_diagonal_norm_tot)\n", @@ -388,24 +201,21 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# the final matrix\n", "visualize_matrix(dbi_TFIM.h.matrix)" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Different initial `d`\n", + "Next, we show the effect of different choices of the initial direction of the gradient descent method." + ] } ], "metadata": { diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py index 13fbfff622..8ae4429c4a 100644 --- a/src/qibo/models/dbi/double_bracket.py +++ b/src/qibo/models/dbi/double_bracket.py @@ -225,22 +225,10 @@ def polynomial_step( if backup_scheduling is None: backup_scheduling = DoubleBracketScheduling.use_grid_search - def sigma(h: np.array): - return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) - - def Gamma(k: int): - r"""Computes the k_th Gamma function i.e $\Gamma_k=[W,...,[W,[W,H]]...]$, where we take k nested commutators with $W = [D, H]$""" - if k == 0: - return self.h.matrix - else: - W = self.commutator(d, sigma(self.h.matrix)) - result = self.h.matrix - for _ in range(k): - result = self.commutator(W, result) - return result - # list starting from s^n highest order to s^0 - sigma_gamma_list = np.array([sigma(Gamma(k)) for k in range(n + 2)]) + sigma_gamma_list = np.array( + [self.sigma(self.Gamma(k, d)) for k in range(n + 2)] + ) exp_list = np.array([1 / math.factorial(k) for k in range(n + 1)]) # coefficients for rotation with [W,H] and H c1 = [ @@ -258,7 +246,8 @@ def Gamma(k: int): power = k + j product_matrix = c1[k] @ c2[j] trace_coefficients[power] += 2 * np.trace(product_matrix) - roots = np.roots(list(reversed(trace_coefficients[: n + 1]))) + taylor_coefficients = list(reversed(trace_coefficients[:n])) + roots = np.roots(taylor_coefficients) error = 1e-3 real_positive_roots = [ np.real(root) @@ -267,7 +256,7 @@ def Gamma(k: int): ] # solution exists, return minimum s if len(real_positive_roots) > 0: - return min(real_positive_roots) + return min(real_positive_roots), taylor_coefficients # solution does not exist, resort to backup scheduling elif ( backup_scheduling == DoubleBracketScheduling.use_polynomial_approximation @@ -277,7 +266,12 @@ def Gamma(k: int): n=n + 1, d=d, backup_scheduling=backup_scheduling ) else: - return self.choose_step(d=d, scheduling=backup_scheduling) + print( + f"Unable to find roots with current order, resorting to {backup_scheduling}" + ) + return self.choose_step(d=d, scheduling=backup_scheduling), list( + reversed(trace_coefficients[: n + 1]) + ) def choose_step( self, @@ -292,7 +286,9 @@ def choose_step( if scheduling is DoubleBracketScheduling.use_hyperopt: return self.hyperopt_step(d=d, **kwargs) if scheduling is DoubleBracketScheduling.use_polynomial_approximation: - return self.polynomial_step(d=d, **kwargs) + # omit taylor coefficients + step, _ = self.polynomial_step(d=d, **kwargs) + return step def loss(self, step: float, d: np.array = None, look_ahead: int = 1): """ @@ -330,3 +326,17 @@ def energy_fluctuation(self, state): state (np.ndarray): quantum state to be used to compute the energy fluctuation with H. """ return self.h.energy_fluctuation(state) + + def sigma(self, h: np.array): + return h - self.backend.cast(np.diag(np.diag(self.backend.to_numpy(h)))) + + def Gamma(self, k: int, d: np.array): + r"""Computes the k_th Gamma function i.e $\Gamma_k=[W,...,[W,[W,H]]...]$, where we take k nested commutators with $W = [D, H]$""" + if k == 0: + return self.h.matrix + else: + W = self.commutator(d, self.sigma(self.h.matrix)) + result = self.h.matrix + for _ in range(k): + result = self.commutator(W, result) + return result diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py index 9a311adcf8..b0a89c116a 100644 --- a/src/qibo/models/dbi/utils.py +++ b/src/qibo/models/dbi/utils.py @@ -250,6 +250,8 @@ def gradient_onsite_Z( + s * ds * b + 2 * ds * c ) + grad = np.array(grad) + grad = grad / np.linalg.norm(grad) return grad, s @@ -291,13 +293,11 @@ def gradient_descent_onsite_Z( nqubits = int(np.log2(dbi_object.h.matrix.shape[0])) if onsite_Z_ops is None: onsite_Z_ops = generate_onsite_Z_ops(nqubits) - off_diagonal_norm_history = [dbi_object.off_diagonal_norm] if d is None: d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) grad, s = gradient_onsite_Z( dbi_object, d, n_taylor=n_taylor, onsite_Z_ops=onsite_Z_ops ) - off_diagonal_norm_history.append(dbi_object.loss(s, d)) # optimize gradient descent step with hyperopt if space is None: space = hyperopt.hp.loguniform("lr", np.log(lr_min), np.log(lr_max)) @@ -321,4 +321,4 @@ def func_loss_to_lr(lr): d_coef = [d_coef[j] - grad[j] * lr for j in range(nqubits)] d = sum([d_coef[i] * onsite_Z_ops[i] for i in range(nqubits)]) dbi_object(step=s, d=d) - return s, d_coef, d, off_diagonal_norm_history + return s, d_coef, d