Repository: amazon-braket/amazon-braket-algorithm-library (language: python)

Issue:
Quantum phase estimation cleanup
*Issue #, if available:*

*Description of changes:*
- Clean up quantum phase estimation implementation, notebook code, and tests
- Add notebook template

*Testing done:*
- Unit tests
- Ran simulator code in a notebook

## Merge Checklist

_Put an `x` in the boxes that apply. You can also fill these out after creating the PR. If you're unsure about any of them, don't hesitate to ask. We're here to help! This is simply a reminder of what we are going to look for before merging your pull request._

#### General

- [x] I have read the [CONTRIBUTING](https://github.com/aws-samples/amazon-braket-algorithm-library/blob/main/CONTRIBUTING.md) doc
- [x] I used the commit message format described in [CONTRIBUTING](https://github.com/aws-samples/amazon-braket-algorithm-library/blob/main/CONTRIBUTING.md#commit-your-change)
- [x] I have updated any necessary documentation, including [READMEs](https://github.com/aws-samples/amazon-braket-algorithm-library/blob/main/README.md) and [API docs](https://github.com/aws-samples/amazon-braket-algorithm-library/blob/main/CONTRIBUTING.md#documentation-guidelines) (if appropriate)

#### Tests

- [x] I have added tests that prove my fix is effective or that my feature works (if appropriate)
- [x] I have checked that my tests are not configured for a specific region or account (if appropriate)

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.



Discussion / hints:

Fix patch:
diff --git a/.gitignore b/.gitignore
index 4904d39f..0d4e8efa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,6 +3,7 @@
 *.swp
 *.idea
 build_files.tar.gz
+.DS_Store
 
 .ycm_extra_conf.py
 .tox
diff --git a/README.md b/README.md
index 847260ca..1b4e4483 100644
--- a/README.md
+++ b/README.md
@@ -14,4 +14,3 @@ See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more inform
 ## License
 
 This project is licensed under the Apache-2.0 License.
-
diff --git a/doc/conf.py b/doc/conf.py
index 5d587735..79c3347f 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -7,7 +7,7 @@
 project = "amazon-braket-algorithm-library"
 version = pkg_resources.require(project)[0].version
 release = version
-copyright = "{}, Amazon.com".format(datetime.datetime.now().year)
+copyright = f"{datetime.datetime.now().year}, Amazon.com"
 
 extensions = [
     "sphinxcontrib.apidoc",
@@ -26,7 +26,7 @@
 default_role = "py:obj"
 
 html_theme = "sphinx_rtd_theme"
-htmlhelp_basename = "{}doc".format(project)
+htmlhelp_basename = f"{project}doc"
 
 napoleon_use_rtype = False
 
diff --git a/examples/QAOA.ipynb b/examples/QAOA.ipynb
index e248a974..5047ea8c 100644
--- a/examples/QAOA.ipynb
+++ b/examples/QAOA.ipynb
@@ -23,195 +23,18 @@
     "While we demonstrate our proof-of-concept approach using classical simulators for circuit execution, our code could in principle be run on actual quantum hardware by simply changing the definition of the ```device``` object (provided that the gate set used in the ansatz is supported by the device, as is the case here for IonQ; for Rigetti we need to apply one more extra trick as shown below). "
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "9c64bde4",
-   "metadata": {},
-   "source": [
-    "## BACKGROUND: THE QUANTUM APPROXIMATE OPTIMIZATION ALGORITHM"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f1c3944e",
-   "metadata": {},
-   "source": [
-    "In this tutorial we will try to solve for the optimal _classical_ bitstring $z$ using the Quantum Approximate Optimization Algorithm (QAOA). \n",
-    "To this end, we first promote the classical spin variables $z_{i}=-1,1$ to quantum-mechanical variables $\\sigma_{i}^{z}$ (with the Pauli matrix $\\sigma_{i}^{z}$ representing the observable corresponding to spin along the $z$ coordinate axis in three-dimensional Euclidean space $\\mathbb{R}^{3}$). \n",
-    "This leads to the following quantum mechanical cost Hamiltonian encoding the optimization problem\n",
-    "\n",
-    "$$\\hat{H}_{C}=\\sum_{i>j} J_{i,j} \\sigma_{i}^{z} \\sigma_{j}^{z},$$\n",
-    "\n",
-    "which can be written as a matrix of size $(2^{N}, 2^{N})$ with diagonal elements only corresponding to all possible classical values for the cost function $H_{C}$. \n",
-    "The ground state of $\\hat{H}_{C}$ corresponds to the optimal solution of the classical combinatorial problem.\n",
-    "\n",
-    "__QAOA ansatz__: Finding this ground state is generically hard. \n",
-    "To approximate this groundstate, QAOA prepares a parametrized ansatz state (corresponding to a parameterized  gate  sequence),  whose  parameters  are iteratively updated by a classical optimizer in a closed loop. \n",
-    "Specifically, QAOA involves a specific ansatz wavefunction parametrized by a parameter family $(\\vec{\\beta}, \\vec{\\gamma})$, embedded into a larger classical optimization loop to find the optimal values for these parameters. \n",
-    "As shown in Ref.[1], good approximate solutions to the problem class considered here can be found by preparing the variational state \n",
-    "\n",
-    "$$|\\gamma, \\beta \\rangle = U_{x}(\\beta_{p})U_{zz}(\\gamma_{p}) \\cdots U_{x}(\\beta_{1})U_{zz}(\\gamma_{1}) |s\\rangle$$\n",
-    "\n",
-    "with single qubit rotations induced by $U_{x}(\\beta) = \\exp(-i\\beta \\sum_{i}\\sigma_{i}^{x})$, \n",
-    "and interactions described by $U_{zz}(\\gamma) = \\exp(-i\\gamma H_{C})$,\n",
-    "starting initially from a product of $\\sigma^{x}$ eigenstates, i.e.,\n",
-    "$|s\\rangle =|-,-,\\dots\\rangle$, with $|-\\rangle = (|0\\rangle -|1\\rangle  )/\\sqrt{2}$. \n",
-    "The family of states $|\\gamma, \\beta \\rangle$ is prepared by alternating single-qubit operations $U_{x}(\\beta_{p})$ with targeted spin-spin interactions generated by the cost Hamiltonian $H_{C}$. \n",
-    "The depth $p$ can be interpreted as a hyperparameter. \n",
-    "For $p$ layers of QAOA blocks, there are $2p$ classical parameters to optimize over, \n",
-    "since each layer $k$ is characterized by just two variational parameters, $\\gamma_{k}$ and $\\beta_{k}$. \n",
-    "The preparation step outlined above is followed by a measurement in the computational basis, giving a classical string $z$, with which one can evaluate the objective function $H_{C}$ of the underlying combinatorial problem at hand. \n",
-    "Taking several measurements shots one can build the expectation value $E(\\beta, \\gamma) = \\langle H_{C} \\rangle$ that we report as the objective function to the classical minimizer (while other choices could be possible as well). \n",
-    "Repeating this procedure will provide an optimized string $z$, with the quality of the result improving as the depth of the quantum circuit $\\sim 2p$ is increased [1]. \n",
-    "In fact, in principle (in the absence of noise and other imperfections), QAOA can reach the global optimum of any cost function in the limit $p \\rightarrow \\infty$ [1], approaching the adiabatic protocol. \n",
-    "Thus, in theory the computational power of QAOA increases with $p$, but in practice the number of layers that can be executed without errors on NISQ devices is limited due noise and imperfections. \n",
-    "\n",
-    "__Optimization__: Since we are primarily interested in solving the classical optimization problem, within this routine it is sufficient to keep track of the best classical bitstring. \n",
-    "This means that the wavefunction prepared by the quantum circuit $|\\gamma, \\beta \\rangle$ has to have some overlap with the optimal solution $|z^{*} \\rangle$ that we can read out as bitstring $z^{*}$ in the measurement shots. \n",
-    "To this end, in principle (i.e., without any training), we could just sample from a completely uniform state that is prepared in a superposition of all computational basis states, as prepared by applying Hadamard gates to all qubits: $|\\mathrm{uniform}\\rangle = 1/\\sqrt{2^{N}}\\sum_{i}|z_{i}\\rangle$. \n",
-    "In that case (assuming a single optimal solution) the success probability per shot amounts to $p_{\\mathrm{success}}=1/2^{N}$. \n",
-    "We can then amplify our success chances by just taking many measurement shots. \n",
-    "For large systems, however, this approach is not scalable as we would need to take an exponentially increasing number of measurements. \n",
-    "That is why we train our circuits, update the parameters, with the goal to increase our success chances to find the optimal bitstring. \n",
-    "We can quantify our success chances as follows [6]. \n",
-    "For a given wavefunction $|\\gamma, \\beta \\rangle$ the probability to find the optimal solution in a single shot is given by \n",
-    "\n",
-    "$$ p_{\\mathrm{success}}(\\gamma, \\beta) = |\\langle z^{*}|\\gamma, \\beta \\rangle |^{2},$$\n",
-    "\n",
-    "where $z^{*}$ denotes the optimal bitstring. \n",
-    "If we perform $M$ repeated measurements, the overall probability $P$ for observing this solution at least once is given by \n",
-    "\n",
-    "$$ P = 1 - (1-p_{\\mathrm{success}}(\\gamma, \\beta))^{M}, $$ \n",
-    "\n",
-    "since the term $(1-p_{\\mathrm{success}}(\\gamma, \\beta))^{M}$ gives the probability of _not_ obtaining $z^{*}$ in repeated $M$ trials. \n",
-    "Therefore, to have an overall success chance up to $\\epsilon$ close to 100%, i.e., $P \\geq 1-\\epsilon$, the number of required shots has to be \n",
-    "\n",
-    "$$ M \\geq \\frac{\\log(\\epsilon)}{\\log(1-p_{\\mathrm{success}}(\\gamma, \\beta))}.$$\n",
-    "\n",
-    "Let us illustrate this results as follows: \n",
-    "If we do not know anything and just resort to a uniform superposition $|\\mathrm{uniform}\\rangle$, for a small system with $N=10$ qubits we can find the optimal solutions with 80% success probability by taking at least $\\sim 1650$ shots. \n",
-    "For just $N=20$ qubits, however, this number amounts to $\\sim 1.7 \\times 10^{6}$, making this naive approach unfeasible. \n",
-    "Conversely, if we can train the quantum circuit to obtain $p_{\\mathrm{success}}(\\gamma, \\beta) \\sim 0.1$, we only need $\\sim 15$ shots to have $P\\geq 80\\%$. \n",
-    "Below we will track and illustrate the best classical optimum as our algorithm proceeds towards a local or (ideally) global optimum.  \n",
-    "\n",
-    "__Objective function__: Finally, some more details on the definition of the cost function are in order. \n",
-    "Following the standard approach [1, 4], QAOA tries to minimize the expectation value $\\langle \\hat{H}_{C} \\rangle$, but does _not_ explicitly maximize the success probability [6]. \n",
-    "However, a low expectation value for $\\langle \\hat{H}_{C} \\rangle$ does not necessarily translate to a high success probability $p_{\\mathrm{success}}(\\gamma, \\beta)$, as can be understood from the following example:\n",
-    "Consider (for example) a variational state that is a linear combination of low energy excited eigenstates of the cost Hamiltonian $\\hat{H}_{C}$ other than the ground state $|z^{*}\\rangle$. \n",
-    "By definition, this state will have a relatively low expectation value $\\langle \\hat{H}_{C} \\rangle$ while the success probability is zero (as this low energy state does not have any overlap with the ground state). \n",
-    "Similarly, a variational state that is a linear combination of the ground state with very high energy eigenstates could have a high success probability $p_{\\mathrm{success}}(\\gamma, \\beta)$, while (at the same time) reporting a high cost value to the classical optimizer.\n",
-    "To address this issue, alternative methods for the optimization of the variational parameters have recently been proposed. \n",
-    "While for simplicity we follow the majority of the literature and take $\\langle \\hat{H}_{C} \\rangle$ as cost value that we report to the classical optimizer, here we do mention a potential alternative for future research: \n",
-    "One approach is to use the Gibbs objective function, defined as $\\mathrm{cost}=-\\mathrm{log} \\langle \\exp(-\\eta \\hat{H}_{C})\\rangle$, with the hyperparameter $\\eta>0$ [7]. \n",
-    "As compared to the simple expectation value $\\langle \\hat{H}_{C} \\rangle$, this definition of the cost value shows stronger rewards for low energy states, thereby increasing the success probability. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f0d9eefd",
-   "metadata": {},
-   "source": [
-    "## IMPLEMENTATION OF QAOA WITH BRAKET "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9969a17d",
-   "metadata": {},
-   "source": [
-    "We consider a graph coloring problem.\n",
-    "Given a graph $G=(V,E)$, made of a set vertices (also called nodes) $V$ and edges $E$, our goal is to color each node red or blue, then score a point for each node that is next to a node of different color. \n",
-    "We strive to find the optimal coloring that scores the largest number of points.\n",
-    "To this end, we will address the dual problem of finding the minimum energy of the corresponding Ising Hamiltonian. \n",
-    "To get started, we first use the open-source ```networkx``` library to visualize the problem graph. \n",
-    "Feel free to play with the parameters $n$ (for the number of nodes) and $m$ (for the number of edges) below to consider other graphs of your choice. "
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "id": "74ae3d4c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import networkx as nx\n",
-    "import random\n",
-    "import numpy as np"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 11,
    "id": "bd0a975d",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from braket.aws import AwsSession, AwsDevice\n",
+    "import numpy as np\n",
     "from braket.devices import LocalSimulator\n",
-    "from braket.experimental.algorithms.qaoa.qaoa import qaoa, run_qaoa, get_qaoa_results "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "f27062fc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# setup Erdos Renyi graph\n",
-    "n = 10  # number of nodes/vertices\n",
-    "m = 20  # number of edges\n",
-    "seed = 42\n",
-    "np.random.seed(seed)\n",
-    "random.seed(a=seed)\n",
+    "from scipy.optimize import minimize\n",
     "\n",
-    "# define graph object\n",
-    "G = nx.gnm_random_graph(n, m, seed=seed)\n",
-    "# positions for all nodes\n",
-    "pos = nx.spring_layout(G)\n",
-    "\n",
-    "# choose random weights\n",
-    "for (u, v) in G.edges():\n",
-    "    G.edges[u,v]['weight'] = random.uniform(0, 1)\n",
-    "\n",
-    "# draw graph\n",
-    "nx.draw(G, pos)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "75f8359a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# set Ising matrix \n",
-    "Jfull = nx.adjacency_matrix(G).todense()\n",
-    "Jfull = np.array(Jfull)\n",
-    "\n",
-    "# get off-diagonal upper triangular matrix\n",
-    "J = np.triu(Jfull, k=1).astype(np.float64)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b75a3f9c",
-   "metadata": {},
-   "source": [
-    "## QAOA SIMULATION ON LOCAL SCHROEDINGER SIMULATOR"
+    "from braket.experimental.algorithms.qaoa import evaluate_circuit, evaluate_loss, qaoa"
    ]
   },
   {
@@ -234,125 +57,140 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "id": "9f248587",
+   "execution_count": 12,
+   "id": "50e4d13a",
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "device = LocalSimulator()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "fea7dc2a",
-   "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[0.         0.18882722]\n",
+      " [0.65337755 0.        ]]\n"
+     ]
+    }
+   ],
    "source": [
-    "##################################################################################\n",
-    "# set up hyperparameters\n",
-    "##################################################################################\n",
-    "\n",
-    "# User-defined hypers\n",
-    "DEPTH = 3  # circuit depth for QAOA\n",
-    "SHOTS = 10  # number measurements to make on circuit\n",
-    "OPT_METHOD = 'Powell'  # SLSQP, COBYLA, Nelder-Mead, BFGS, Powell, ...\n",
+    "n_qubits = 2\n",
+    "n_layers = 1\n",
     "\n",
-    "# set up the problem\n",
-    "n_qubits = J.shape[0]\n",
+    "coupling_matrix = np.diag(np.ones(n_qubits - 1), 1)\n",
+    "coupling_matrix = np.random.rand(n_qubits, n_qubits)\n",
+    "for i in range(n_qubits):\n",
+    "    coupling_matrix[i, i] = 0  # remove diagonal elements\n",
     "\n",
-    "# initialize reference solution (simple guess)\n",
-    "bitstring_init = -1 * np.ones([n_qubits])\n",
-    "energy_init = np.dot(bitstring_init, np.dot(J, bitstring_init))\n",
-    "\n",
-    "# set metrics to keep track of results\n",
-    "metrics = {\n",
-    "    'count': 1,                           # Elapsed optimization steps\n",
-    "    'optimal_energy': energy_init,        # Global optimal energy\n",
-    "    'opt_energies': [],                   # Optimal energy at each step\n",
-    "    'global_energies': [],                # Global optimal energy at each step\n",
-    "    'optimal_bitstring': bitstring_init,  # Global optimal bitstring\n",
-    "    'opt_bitstrings': [],                 # Optimal bitstring at each step\n",
-    "    'costs': [],                          # Cost (average energy) at each step\n",
-    "    'res': None,                          # Quantum result object\n",
-    "    'params': []                          # Track parameters\n",
-    "}\n",
-    "\n",
-    "# set options for classical optimization\n",
-    "options = {'disp': True, 'maxiter': 500}"
+    "print(coupling_matrix)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "id": "eec5582f",
+   "execution_count": 13,
+   "id": "6e26acc1",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Circuit depth hyperparameter: 3\n",
-      "Problem size: 10\n",
-      "Training in progress...\n",
-      "Optimization terminated successfully.\n",
-      "         Current function value: -0.937169\n",
-      "         Iterations: 2\n",
-      "         Function evaluations: 243\n"
+      "T  : |0|1|              2              |3|4|              5              |6|     7      |          Result Types           |\n",
+      "                                                                                                                           \n",
+      "q0 : -H-C-------------------------------C-X-Rz(0.653377548398525*gamma_0)-X-Rx(2*beta_0)-Expectation(Z@Z)-Expectation(Z@Z)-\n",
+      "        |                               | |                               |              |                |                \n",
+      "q1 : -H-X-Rz(0.188827220663023*gamma_0)-X-C-------------------------------C-Rx(2*beta_0)-Expectation(Z@Z)-Expectation(Z@Z)-\n",
+      "\n",
+      "T  : |0|1|              2              |3|4|              5              |6|     7      |          Result Types           |\n",
+      "\n",
+      "Unassigned parameters: [beta_0, gamma_0].\n"
      ]
     }
    ],
    "source": [
-    "##################################################################################\n",
-    "# run QAOA optimization on graph \n",
-    "##################################################################################\n",
-    "\n",
-    "print('Circuit depth hyperparameter:', DEPTH)\n",
-    "print('Problem size:', n_qubits)\n",
-    "\n",
-    "# kick off training\n",
-    "result, tracker = run_qaoa(\n",
-    "    device = device, options=options, p=DEPTH, ising=J, n_qubits=n_qubits, n_shots=SHOTS, \n",
-    "    opt_method=OPT_METHOD, metrics=metrics)"
+    "circ = qaoa(n_qubits, n_layers, coupling_matrix)\n",
+    "print(circ)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "id": "12e0dad7",
+   "execution_count": 14,
+   "id": "223d34d0",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Optimal energy: -6.486032631497276\n",
-      "Optimal classical bitstring: [-1  1 -1 -1  1 -1  1  1 -1 -1]\n",
-      "Final average energy (cost): -0.937169150437591\n",
-      "Final angles: [4.88261413 2.60870766 2.26309012 1.6607821  1.28592103 2.39641137]\n"
+      "[0.1888272206630226, 0.6533775483985252]\n"
      ]
     }
    ],
    "source": [
-    "get_qaoa_results(result, tracker)"
+    "idx = coupling_matrix.nonzero()\n",
+    "js = [coupling_matrix[qubit_pair] for qubit_pair in zip(idx[0], idx[1])]\n",
+    "print(js)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "id": "060533af",
+   "execution_count": 15,
+   "id": "c700195c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = LocalSimulator()\n",
+    "\n",
+    "losses = []\n",
+    "\n",
+    "\n",
+    "def loss(values, device, circ, shots, js):\n",
+    "    global losses\n",
+    "    task = evaluate_circuit(device, circ, values, shots=shots)\n",
+    "    loss = evaluate_loss(task, js)\n",
+    "    losses.append(loss)\n",
+    "    return loss\n",
+    "\n",
+    "\n",
+    "# set bounds for search space\n",
+    "init_values = np.random.rand(2 * n_layers)\n",
+    "\n",
+    "bounds = [(0, 2 * np.pi) for _ in range(2 * n_layers)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "bc524eef",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result = minimize(\n",
+    "    loss,\n",
+    "    init_values,\n",
+    "    args=(device, circ, 0, js),\n",
+    "    options={\"disp\": True, \"maxfev\": 150},\n",
+    "    method=\"Nelder-Mead\",\n",
+    "    bounds=bounds,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "16df2abe",
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Optimization on graph with n=10 vertices, m=20 edges, optimized with Powell and 10 shots per call; seed=42.\n"
-     ]
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x12b59b580>]"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkYAAAGwCAYAAABM/qr1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhU5d3/8c9kmyRkYQlJJpAFWUVQNsumBqwgKCCgFkQRFGkRURAVQVCCj5CCZXksWpcqYosFLaD+RCFUlqeFIFsURBpQgkQgoggJGExIcn5/kAyEbDNhZs4keb+ua64rc+acme+cTsun9/0997EYhmEIAAAA8jG7AAAAAG9BMAIAAChGMAIAAChGMAIAAChGMAIAAChGMAIAAChGMAIAACjmZ3YB3q6oqEjHjh1TaGioLBaL2eUAAAAHGIahM2fOKCYmRj4+jo8DEYyqcOzYMcXGxppdBgAAqIbMzEw1bdrU4f0JRlUIDQ2VdOHEhoWFmVwNAABwRE5OjmJjY+3/jjuKYFSFkumzsLAwghEAADWMs20wNF8DAAAUIxgBAAAUIxgBAAAUIxgBAAAUIxgBAAAUIxgBAAAUIxgBAAAUIxgBAAAUIxgBAAAUIxgBAAAUIxgBAAAUIxgBAAAU4yayJjmbV6DTufkK9PdVRIjV7HIAAIAYMTLNkv9k6Ia5G/WndelmlwIAAIoRjEwS4Hfh1OcXFJlcCQAAKEEwMklJMMorJBgBAOAtCEYmYcQIAADvQzAySYAvwQgAAG9DMDKJ1d9XEsEIAABvQjAyiX3EiB4jAAC8BsHIJFZ6jAAA8DoEI5PQfA0AgPchGJnEHoyYSgMAwGsQjEzCVWkAAHgfgpFJ7As8EowAAPAaBCOTXOwxKjS5EgAAUIJgZJKSqTRGjAAA8B4EI5NYL2m+NgzD5GoAAIBEMDJNyVSaYUgFRQQjAAC8AcHIJCXBSOLKNAAAvAXByCQlPUYSwQgAAG9BMDKJn6+PfCwX/maRRwAAvAPByERWP19JjBgBAOAtCEYmYpFHAAC8C8HIRNxIFgAA70IwMpH9fmn0GAEA4BVqTDAaNGiQ4uLiFBgYKJvNppEjR+rYsWOVHmMYhpKSkhQTE6OgoCD16tVL+/bt81DFVbMyYgQAgFepMcGod+/eeu+995Senq6VK1fq22+/1V133VXpMfPmzdOCBQu0ePFi7dixQ9HR0erTp4/OnDnjoaorx1QaAADexc/sAhz1+OOP2/+Oj4/X1KlTNXjwYJ0/f17+/v5l9jcMQ4sWLdL06dM1dOhQSdLSpUsVFRWld999V3/4wx88VntF7MGokBvJAgDgDWrMiNGlfv75Zy1btkw9evQoNxRJUkZGhrKystS3b1/7NqvVqsTERG3durXC987Ly1NOTk6ph7vYe4wYMQIAwCvUqGD09NNPq169emrUqJGOHDmiDz/8sMJ9s7KyJElRUVGltkdFRdlfK09ycrLCw8Ptj9jYWNcUXw4u1wcAwLuYGoySkpJksVgqfezcudO+/1NPPaW0tDSlpKTI19dX999/f5V3prdYLKWeG4ZRZtulpk2bpuzsbPsjMzPzyr5kJQhGAAB4F1N7jCZMmKDhw4dXuk9CQoL974iICEVERKhVq1a6+uqrFRsbq23btql79+5ljouOjpZ0YeTIZrPZt584caLMKNKlrFarrFark9+kephKAwDAu5gajEqCTnWUjBTl5eWV+3qzZs0UHR2t9evXq2PHjpKk/Px8bd68WXPnzq1ewS7GVWkAAHiXGtFjtH37di1evFhffPGFvvvuO23cuFEjRoxQ8+bNS40WtWnTRqtXr5Z0YQpt0qRJmjNnjlavXq2vvvpKo0ePVnBwsEaMGGHWVynl4lVpBCMAALxBjbhcPygoSKtWrdLMmTP1yy+/yGazqV+/flq+fHmpaa/09HRlZ2fbn0+ZMkXnzp3T+PHjderUKXXt2lUpKSkKDQ0142uUwQKPAAB4lxoRjNq3b68NGzZUud/ljdgWi0VJSUlKSkpyU2VXxurnK4lgBACAt6gRU2m1FVNpAAB4F4KRibgqDQAA70IwMhHrGAEA4F0IRibicn0AALwLwchE9qk0eowAAPAKBCMTXRwxKjS5EgAAIBGMTMVUGgAA3oVgZCIrzdcAAHgVgpGJuFwfAADvQjAyEQs8AgDgXQhGJqLHCAAA70IwMhFTaQAAeBeCkYlY+RoAAO9CMDKR1c9XEj1GAAB4C4KRiegxAgDAuxCMTGQlGAEA4FUIRibicn0AALwLwchEJVelFRYZKiwyTK4GAAAQjExUMmIkMZ0GAIA3IBiZiGAEAIB3IRiZyM/HIovlwt95BYXmFgMAAAhGZrJYLPY+IxZ5BADAfAQjk3FlGgAA3oNgZDLWMgIAwHsQjEzGjWQBAPAeBCOTMZUGAID3IBiZjPulAQDgPQhGJrP6+UoiGAEA4A0IRiYrGTHicn0AAMxHMDKZvfmaHiMAAExHMDIZPUYAAHgPgpHJCEYAAHgPgpHJLgYj7pUGAIDZ/MwuoK6zFvcYvbPtO21M/7HUa12vaqjxvVqYURYAAHVSjRkxGjRokOLi4hQYGCibzaaRI0fq2LFjlR4zevRoWSyWUo9u3bp5qGLH2OoHSpIO/fiLNh/4sdRj3tp05fx63uQKAQCoO2rMiFHv3r31zDPPyGaz6ejRo3ryySd11113aevWrZUe169fPy1ZssT+PCAgwN2lOuWR3i3U1hauc+dLT6U99c8vZRjSr+cLFRbob1J1AADULTUmGD3++OP2v+Pj4zV16lQNHjxY58+fl79/xcHBarUqOjra4c/Jy8tTXl6e/XlOTk71CnZQcICfbr/WVmb7M6v3Kr+gSOcLDbd+PgAAuKjGTKVd6ueff9ayZcvUo0ePSkORJG3atEmRkZFq1aqVxo4dqxMnTlS6f3JyssLDw+2P2NhYV5busJL1jc5ztRoAAB5To4LR008/rXr16qlRo0Y6cuSIPvzww0r379+/v5YtW6YNGzZo/vz52rFjh26++eZSI0KXmzZtmrKzs+2PzMxMV38Nh5RcrXaehR8BAPAYU4NRUlJSmeboyx87d+607//UU08pLS1NKSkp8vX11f333y/DqHiqadiwYbr99tvVrl07DRw4UJ9++qkOHDigNWvWVHiM1WpVWFhYqYcZ/H0tklgRGwAATzK1x2jChAkaPnx4pfskJCTY/46IiFBERIRatWqlq6++WrGxsdq2bZu6d+/u0OfZbDbFx8fr4MGDV1K2R/iXTKXRYwQAgMeYGoxKgk51lIwUVTYtdrmTJ08qMzNTNlvZZmdvY+8xYsQIAACPqRE9Rtu3b9fixYv1xRdf6LvvvtPGjRs1YsQINW/evNRoUZs2bbR69WpJ0tmzZ/Xkk08qNTVVhw8f1qZNmzRw4EBFRERoyJAhZn0Vh/nTfA0AgMfViMv1g4KCtGrVKs2cOVO//PKLbDab+vXrp+XLl8tqtdr3S09PV3Z2tiTJ19dXe/fu1TvvvKPTp0/LZrOpd+/eWrFihUJDQ836Kg7z97vQY5THiBEAAB5TI4JR+/bttWHDhir3u7QROygoSOvWrXNnWW7FiBEAAJ5XI6bS6iKarwEA8DyCkZei+RoAAM8jGHkp1jECAMDzCEZeyp8RIwAAPI5g5KX8/Wi+BgDA0whGXspK8zUAAB5HMPJSJVNp9BgBAOA5BCMvVbLAIz1GAAB4DsHIS9F8DQCA5xGMvFTJOkb5NF8DAOAxBCMvxcrXAAB4ntP3SjMMQ//85z+1ceNGnThxQkVFpUc0Vq1a5bLi6jKarwEA8Dyng9HEiRP1+uuvq3fv3oqKipLFYnFHXXWevfmaqTQAADzG6WD097//XatWrdJtt93mjnpQjHulAQDgeU73GIWHh+uqq65yRy24BD1GAAB4ntPBKCkpSbNmzdK5c+fcUQ+K0WMEAIDnOT2Vdvfdd+sf//iHIiMjlZCQIH9//1Kv796922XF1WUBfkylAQDgaU4Ho9GjR2vXrl267777aL52I39fVr4GAMDTnA5Ga9as0bp163TDDTe4ox4UszdfF9BjBACApzjdYxQbG6uwsDB31IJL0GMEAIDnOR2M5s+frylTpujw4cNuKAcl/P24JQgAAJ7m9FTafffdp9zcXDVv3lzBwcFlmq9//vlnlxVXl9FjBACA5zkdjBYtWuSOOnAZFngEAMDznA5Go0aNckcduAwLPAIA4HlOB6MjR45U+npcXFy1i8FFNF8DAOB5TgejhISEStcuKiwsvKKCcEGAHz1GAAB4mtPBKC0trdTz8+fPKy0tTQsWLNDs2bNdVlhdZ59K46o0AAA8xulgdN1115XZ1qVLF8XExOjFF1/U0KFDXVJYXXfxliD0GAEA4ClOr2NUkVatWmnHjh2uers679IeI8MgHAEA4AlOjxjl5OSUem4Yho4fP66kpCS1bNnSZYXVdSXBSJIKigz7ukYAAMB9nA5G9evXL9N8bRiGYmNjtXz5cpcVVtcFXBKMzhcWlQpKAADAPZwORhs3biz13MfHR40bN1aLFi3k5+f026ECl44Q5RcUKTjAxGIAAKgjnE4yiYmJ7qgDl/H1schikQyDtYwAAPCUag3xHD16VFu2bNGJEydUVFT6H+3HHnvMJYVVJC8vT127dtWXX36ptLQ0dejQocJ9DcPQrFmz9Prrr+vUqVPq2rWrXn75ZV1zzTVurdEVLBaL/H19lF9QxJVpAAB4iNPBaMmSJRo3bpwCAgLUqFGjUv1GFovF7cFoypQpiomJ0ZdfflnlvvPmzdOCBQv09ttvq1WrVnrhhRfUp08fpaenKzQ01K11ukJASTBiLSMAADzC6Y7e5557Ts8995yys7N1+PBhZWRk2B+HDh1yR412n376qVJSUvSnP/2pyn0Nw9CiRYs0ffp0DR06VO3atdPSpUuVm5urd9991611ukpJnxGrXwMA4BlOB6Pc3FwNHz5cPj6evUrqhx9+0NixY/W3v/1NwcHBVe6fkZGhrKws9e3b177NarUqMTFRW7durfC4vLw85eTklHqYhfulAQDgWU6nmzFjxuj99993Ry0VMgxDo0eP1rhx49SlSxeHjsnKypIkRUVFldoeFRVlf608ycnJCg8Ptz9iY2OrX/gVst8WhB4jAAA8wukeo+TkZA0YMEBr165V+/bt5e/vX+r1BQsWOPxeSUlJmjVrVqX77NixQ1u3blVOTo6mTZvmbLnlrrlU2U1wp02bpsmTJ9uf5+TkmBaOrPbbgjBiBACAJzgdjObMmaN169apdevWklSm+doZEyZM0PDhwyvdJyEhQS+88IK2bdsmq9Va6rUuXbro3nvv1dKlS8scFx0dLenCyJHNZrNvP3HiRJlRpEtZrdYyn2MWbiQLAIBnOR2MFixYoLfeekujR4++4g+PiIhQRERElfu99NJLeuGFF+zPjx07pltvvVUrVqxQ165dyz2mWbNmio6O1vr169WxY0dJUn5+vjZv3qy5c+dece2e4O93IWjSYwQAgGc4HYysVqt69uzpjloqFBcXV+p5SEiIJKl58+Zq2rSpfXubNm2UnJysIUOGyGKxaNKkSZozZ45atmypli1bas6cOQoODtaIESM8Wn910WMEAIBnOd18PXHiRP35z392Ry1XLD09XdnZ2fbnU6ZM0aRJkzR+/Hh16dJFR48eVUpKSo1Yw0i6NBgxYgQAgCc4PWK0fft2bdiwQR9//LGuueaaMs3Xq1atcllxFUlISJBhlB1FuXybxWJRUlKSkpKS3F6TO5TcSDafHiMAADzC6WBUv359DR061B214DIlCzzSYwQAgGdU65Yg8Aym0gAA8CzPLl8Np/j7cbk+AACe5NCIUadOnfTZZ5+pQYMG6tixY6XrFe3evdtlxdV1AVyVBgCARzkUjO644w77ooeDBw92a0G4iB4jAAA8y6FgNHPmzHL/hnsFcEsQAAA8yunm6xL5+fk6ceKEiopK/6N9+WKMqD6arwEA8Cyng9GBAwc0ZswYbd26tdT2kpuzFhYWuqy4uo4eIwAAPMvpYPTAAw/Iz89PH3/8sWw2m9M3joXj/FngEQAAj3I6GH3xxRfatWuX2rRp4456cAmm0gAA8Cyn1zFq27atfvrpJ3fUgsv4+xVflcaIEQAAHuF0MJo7d66mTJmiTZs26eTJk8rJySn1gOsEMGIEAIBHOT2Vdsstt0iSfvvb35baTvO16/nTfA0AgEc5HYw2btzojjpQDnvzNSNGAAB4hNPBKDEx0R11oBwlK18zlQYAgGc4FIz27Nmjdu3aycfHR3v27Kl032uvvdYlhYGVrwEA8DSHglGHDh2UlZWlyMhIdejQQRaLRYZRtu+FHiPXsjdfF9BjBACAJzgUjDIyMtS4cWP73/AMeowAAPAsh4JRfHx8uX/DvfyZSgMAwKOqdRPZo0ePasuWLeXeRPaxxx5zSWGg+RoAAE9zOhgtWbJE48aNU0BAgBo1alTqXmkWi4Vg5ELcRBYAAM9yOhg999xzeu655zRt2jT5+Di9cDacwE1kAQDwLKeDUW5uroYPH04o8oCSYJTz63l9+MXRar+Pn4+PbmoVodBAf1eVBgBAreR0MBozZozef/99TZ061R314BJBAb6SpDO/Fmji8i+u6L2GdYnV3LtYYwoAgMo4HYySk5M1YMAArV27Vu3bt5e/f+lRiAULFrisuLouoVGwHrqhmfZnVf/mvD+eydOBH87q6OlzLqwMAIDayelgNGfOHK1bt06tW7eWpDLN13Adi8WiGQPaXtF7rP0qS+P+vkvnzrPwJgAAVXE6GC1YsEBvvfWWRo8e7YZy4Gol03Hn8glGAABUxekOaqvVqp49e7qjFrhBkP+FYPQrI0YAAFTJ6WA0ceJE/fnPf3ZHLXCDkmDEVBoAAFVzeipt+/bt2rBhgz7++GNdc801ZZqvV61a5bLicOWCAi5kX4IRAABVczoY1a9fX0OHDnVHLXCDQH96jAAAcFS1bgmCmqNkKi2voEhFRYZ8fLhyEACAirB8dS1XclWaJP1awKgRAACVIRjVcoF+F4MR02kAAFSuxgWjvLw8dejQQRaLRV98UfltMkaPHi2LxVLq0a1bNw9V6h18fCyy+tGADQCAI2pcMJoyZYpiYmIc3r9fv346fvy4/fHJJ5+4sTrvVDKdxlpGAABUzunmazN9+umnSklJ0cqVK/Xpp586dIzValV0dLTDn5GXl6e8vDz785yc6t+nzFsE+fvqtM7rXH6R2aUAAODVHApGL730ksNv+Nhjj1W7mMr88MMPGjt2rD744AMFBwc7fNymTZsUGRmp+vXrKzExUbNnz1ZkZGSF+ycnJ2vWrFmuKNlrsMgjAACOsRiGYVS1U7NmzRx7M4tFhw4duuKiLmcYhm677Tb17NlTM2bM0OHDh9WsWTOlpaWpQ4cOFR63YsUKhYSEKD4+XhkZGXr22WdVUFCgXbt2yWq1lntMeSNGsbGxys7OVlhYmMu/myfc9r//1tfHc7T0wd8osVVjs8sBAMDtcnJyFB4e7vS/3w6NGGVkZFS7sMokJSVVOTqzY8cObd26VTk5OZo2bZpT7z9s2DD73+3atVOXLl0UHx+vNWvWVLhIpdVqrTA01VTcSBYAAMeY2mM0YcIEDR8+vNJ9EhIS9MILL2jbtm1lAkuXLl107733aunSpQ59ns1mU3x8vA4ePFjtmmsibiQLAIBjqhWMvv/+e3300Uc6cuSI8vPzS722YMECh98nIiJCERERVe730ksv6YUXXrA/P3bsmG699VatWLFCXbt2dfjzTp48qczMTNlsNoePqQ0C6TECAMAhTgejzz77TIMGDVKzZs2Unp6udu3a6fDhwzIMQ506dXJHjYqLiyv1PCQkRJLUvHlzNW3a1L69TZs2Sk5O1pAhQ3T27FklJSXpzjvvlM1m0+HDh/XMM88oIiJCQ4YMcUud3oqpNAAAHOP0OkbTpk3TE088oa+++kqBgYFauXKlMjMzlZiYqLvvvtsdNTosPT1d2dnZkiRfX1/t3btXd9xxh1q1aqVRo0apVatWSk1NVWhoqKl1elqQPws8AgDgCKdHjPbv369//OMfFw7289O5c+cUEhKi559/XnfccYcefvhhlxd5uYSEBJV3Md2l24KCgrRu3Tq311IT0GMEAIBjnB4xqlevnv1y9piYGH377bf213766SfXVQaXCWQqDQAAhzg9YtStWzdt2bJFbdu21e23364nnnhCe/fu1apVq+rcfchqChZ4BADAMU4HowULFujs2bOSLqxDdPbsWa1YsUItWrTQwoULXV4grhzBCAAAxzgdjK666ir738HBwXrllVdcWhBcj5vIAgDgGKd7jHbs2KHPP/+8zPbPP/9cO3fudElRcC37Okb0GAEAUCmng9EjjzyizMzMMtuPHj2qRx55xCVFwbWYSgMAwDFOB6Ovv/663IUcO3bsqK+//tolRcG1LgajIpMrAQDAuzkdjKxWq3744Ycy248fPy4/P1NvvYYK2HuMmEoDAKBSTgejPn36aNq0afYVpiXp9OnTeuaZZ9SnTx+XFgfX4F5pAAA4xukhnvnz5+umm25SfHy8OnbsKEn64osvFBUVpb/97W8uLxBXjh4jAAAc43QwatKkifbs2aNly5bpyy+/VFBQkB544AHdc8898vf3d0eNuEJMpQEA4JhqNQXVq1dPv//9711dC9yEESMAABzjUDD66KOP1L9/f/n7++ujjz6qdN9Bgwa5pDC4TkkwKigydL6wSP6+TreWAQBQJzgUjAYPHqysrCxFRkZq8ODBFe5nsVhUWMiohLcJDLgYhM6dLyQYAQBQAYeCUVFRUbl/o2YI8PWRj0UqMi70GYUF0gsGAEB5XDJ0cPr0aVe8DdzEYrHQZwQAgAOcDkZz587VihUr7M/vvvtuNWzYUE2aNNGXX37p0uLgOiVXphGMAAComNPB6LXXXlNsbKwkaf369frXv/6ltWvXqn///nrqqadcXiBcgxvJAgBQNacv1z9+/Lg9GH388cf63e9+p759+yohIUFdu3Z1eYFwDabSAAComtMjRg0aNFBmZqYkae3atbrlllskSYZhcEWaF7Mv8kgwAgCgQk6PGA0dOlQjRoxQy5YtdfLkSfXv31/ShduCtGjRwuUFwjUuTqVxVSEAABVxOhgtXLhQCQkJyszM1Lx58xQSEiLpwhTb+PHjXV4gXIOpNAAAquZ0MPL399eTTz5ZZvukSZNcUhDcg2AEAEDVnO4xWrp0qdasWWN/PmXKFNWvX189evTQd99959Li4DrcSBYAgKo5HYzmzJmjoKAgSVJqaqoWL16sefPmKSIiQo8//rjLC4RrBDJiBABAlZyeSsvMzLQ3WX/wwQe666679Pvf/149e/ZUr169XF0fXKRkKm3NnuPK+OkXp48PC/TTo79tqYgQq6tLAwDAazgdjEJCQnTy5EnFxcUpJSXFPkoUGBioc+fOubxAuEZU2IVAk/7DGaX/cKZa7xHbMFgP3XiVK8sCAMCrOB2M+vTpo4ceekgdO3bUgQMHdPvtt0uS9u3bp4SEBFfXBxe5r1u8woP8dTavwOljP/0qS7u+O6Vf8piGAwDUbk4Ho5dfflkzZsxQZmamVq5cqUaNGkmSdu3apXvuucflBcI16ln9NPw3cdU69vtT57Tru1M6X8gaSACA2s3pYFS/fn0tXry4zPZZs2a5pCB4nwC/Cz36BCMAQG3ndDAqkZubqyNHjig/P7/U9muvvfaKi4J38fe1SJLyCUYAgFrO6WD0448/avTo0Vq7dm25r3O/tNrH35cRIwBA3eD0OkaTJk3S6dOntW3bNgUFBWnt2rVaunSpWrZsqY8++sgdNcJk9mBUYJhcCQAA7uV0MNqwYYMWLlyo66+/Xj4+PoqPj9d9992nefPmKTk52R01SpISEhJksVhKPaZOnVrpMYZhKCkpSTExMQoKClKvXr20b98+t9VYWwUwYgQAqCOcDka//PKLIiMjJUkNGzbUjz/+KElq3769du/e7drqLvP888/r+PHj9seMGTMq3X/evHlasGCBFi9erB07dig6Olp9+vTRmTPVW8enrqLHCABQVzgdjFq3bq309HRJUocOHfTaa6/p6NGjevXVV2Wz2Vxe4KVCQ0MVHR1tf4SEhFS4r2EYWrRokaZPn66hQ4eqXbt2Wrp0qXJzc/Xuu++6tc7axp+r0gAAdUS1eoyOHz8uSZo5c6bWrl2ruLg4vfTSS5ozZ47LC7zU3Llz1ahRI3Xo0EGzZ88uc0XcpTIyMpSVlaW+ffvat1mtViUmJmrr1q0VHpeXl6ecnJxSj7ruYvM1PUYAgNrN6avS7r33XvvfHTt21OHDh/Xf//5XcXFxioiIcGlxl5o4caI6deqkBg0aaPv27Zo2bZoyMjL017/+tdz9s7KyJElRUVGltkdFRem7776r8HOSk5NZk+ky9BgBAOoKp0eMLhccHKxOnTpVKxQlJSWVaai+/LFz505J0uOPP67ExERde+21euihh/Tqq6/qzTff1MmTJyv9DIvFUuq5YRhltl1q2rRpys7Otj8yMzOd/l61TcmIUX4BwQgAULs5NGI0efJkh99wwYIFDu87YcIEDR8+vNJ9Krr/Wrdu3SRJ33zzjf22JJeKjo6WdGHk6NLepxMnTpQZRbqU1WqV1cod5C9V0nzNiBEAoLZzKBilpaU59GaVjcSUJyIiotrTbyU1VdTw3axZM0VHR2v9+vXq2LGjJCk/P1+bN2/W3Llzq/WZddXF5mt6jAAAtZtDwWjjxo3urqNSqamp2rZtm3r37q3w8HDt2LFDjz/+uAYNGqS4uIs3Rm3Tpo2Sk5M1ZMgQWSwWTZo0SXPmzFHLli3VsmVLzZkzR8HBwRoxYoSJ36bmoccIAFBXON18nZ2drcLCQjVs2LDU9p9//ll+fn4KCwtzWXElrFarVqxYoVmzZikvL0/x8fEaO3aspkyZUmq/9PR0ZWdn259PmTJF586d0/jx43Xq1Cl17dpVKSkpCg0NdXmNtRk9RgCAusJiGIZT8yP9+/fXwIEDNX78+FLbX331VX300Uf65JNPXFqg2XJycjnaGtkAACAASURBVBQeHq7s7Gy3hL6aIO3IKQ15ZauaNgjSf56+2exyAACoUnX//Xb6qrTPP/9cvXv3LrO9V69e+vzzz519O9QA3EQWAFBXOB2M8vLyVFBQUGb7+fPnde7cOZcUBe8SQPM1AKCOcDoYXX/99Xr99dfLbH/11VfVuXNnlxQF72IfMaLHCABQyzndfD179mzdcsst+vLLL/Xb3/5WkvTZZ59px44dSklJcXmBMB83kQUA1BVOjxj17NlTqampio2N1Xvvvaf/9//+n1q0aKE9e/boxhtvdEeNMBmX6wMA6gqnR4wkqUOHDlq2bJmra4GXKplKKzKkwiJDvj7OLeQJAEBNccX3SkPtV7LytcSoEQCgdiMYoUolPUYSfUYAgNqNYIQq+ftcMmLElWkAgFqMYIQq+fhY5FfcV8RaRgCA2szpYPTggw/qzJkzZbb/8ssvevDBB11SFLwPq18DAOoCp4PR0qVLy13h+ty5c3rnnXdcUhS8D2sZAQDqAocv18/JyZFhGDIMQ2fOnFFgYKD9tcLCQn3yySeKjIx0S5Ew38XbghCMAAC1l8PBqH79+rJYLLJYLGrVqlWZ1y0Wi2bNmuXS4uA9Lt4WhB4jAEDt5XAw2rhxowzD0M0336yVK1eqYcOG9tcCAgIUHx+vmJgYtxQJ85UEI6bSAAC1mcPBKDExUZKUkZGhuLg4WSysflyXlPQYMZUGAKjNnG6+3r9/v7Zs2WJ//vLLL6tDhw4aMWKETp065dLi4D24Kg0AUBc4HYyeeuop5eTkSJL27t2ryZMn67bbbtOhQ4c0efJklxcI70DzNQCgLnD6JrIZGRlq27atJGnlypUaOHCg5syZo927d+u2225zeYHwDvYeI5qvAQC1mNMjRgEBAcrNzZUk/etf/1Lfvn0lSQ0bNrSPJKH2occIAFAXOD1idMMNN2jy5Mnq2bOntm/frhUrVkiSDhw4oKZNm7q8QHgHeowAAHWB0yNGixcvlp+fn/75z3/qL3/5i5o0aSJJ+vTTT9WvXz+XFwjvEEAwAgDUAU6PGMXFxenjjz8us33hwoUuKQje6eI6RvQYAQBqL6dHjCTp22+/1YwZM3TPPffoxIkTkqS1a9dq3759Li0O3sN+VVoBI0YAgNrL6WC0efNmtW/fXp9//rlWrVqls2fPSpL27NmjmTNnurxAeAd6jAAAdYHTwWjq1Kl64YUXtH79egUEBNi39+7dW6mpqS4tDt4jwI+r0gAAtZ/TwWjv3r0aMmRIme2NGzfWyZMnXVIUvA89RgCAusDpYFS/fn0dP368zPa0tDT7FWqofZhKAwDUBU4HoxEjRujpp59WVlaWLBaLioqKtGXLFj355JO6//773VEjvIA9GNF8DQCoxZwORrNnz1ZcXJyaNGmis2fPqm3btrrpppvUo0cPzZgxwx01wgsEsPI1AKAOcHodI39/fy1btkzPP/+80tLSVFRUpI4dO6ply5buqA9egh4jAEBd4HQwKtG8eXNdddVVkiSLxeKyguCd/P3oMQIA1H7VWuDxzTffVLt27RQYGKjAwEC1a9dOf/3rX11dG7wIzdcAgLrA6RGjZ599VgsXLtSjjz6q7t27S5JSU1P1+OOP6/Dhw3rhhRdcXiTMR48RAKAucHrE6C9/+YveeOMNJScna9CgQRo0aJCSk5P1+uuv69VXX3VHjZKkhIQEWSyWUo+pU6dWeszo0aPLHNOtWze31Vib2XuMCugxAgDUXk6PGBUWFqpLly5ltnfu3FkFBQUuKaoizz//vMaOHWt/HhISUuUx/fr105IlS+zPL12tG45jKg0AUBc4HYzuu+8+/eUvf9GCBQtKbX/99dd17733uqyw8oSGhio6OtqpY6xWq1PH5OXlKS8vz/48JyfHqc+rrWi+BgDUBQ4Fo8mTJ9v/tlgs+utf/6qUlBT7tNS2bduUmZnp9gUe586dq//5n/9RbGys7r77bj311FNVjgBt2rRJkZGRql+/vhITEzV79mxFRkZWuH9ycrJmzZrl6tJrPHqMAAB1gcUwjCqbRnr37u3Ym1ks2rBhwxUXVZ6FCxeqU6dOatCggbZv365p06bpjjvuqPRquBUrVigkJETx8fHKyMjQs88+q4KCAu3atUtWq7XcY8obMYqNjVV2drbCwsJc/r1qis/2/6AxS3fqutj6+vCRnmaXAwBApXJychQeHu70v98OBSN3SUpKqnJ0ZseOHeX2NK1cuVJ33XWXfvrpJzVq1Mihzzt+/Lji4+O1fPlyDR061KFjqntia5v/O/Cj7n9ru9rawvTJxBvNLgcAgEpV99/vai/w6AoTJkzQ8OHDK90nISGh3O0l03jffPONw8HIZrMpPj5eBw8edKpO0HwNAKgbTA1GERERioiIqNaxaWlpki6EHUedPHlSmZmZTh2DCwL86DECANR+1Vr52tNSU1O1cOFCffHFF8rIyNB7772nP/zhDxo0aJDi4uLs+7Vp00arV6+WJJ09e1ZPPvmkUlNTdfjwYW3atEkDBw5URESEhgwZYtZXqbEujhixjhEAoPYydcTIUVarVStWrNCsWbOUl5en+Ph4jR07VlOmTCm1X3p6urKzsyVJvr6+2rt3r9555x2dPn1aNptNvXv31ooVKxQaGmrG16jRLt5ElhEjAEDtVSOCUadOnbRt27Yq97u0jzwoKEjr1q1zZ1l1Cj1GAIC6oEZMpcF8ASXBqIBgBACovQhGcIi/vfmaHiMAQO1FMIJDLu0xMnHpKwAA3IpgBIeUBCNJKigiGAEAaieCERwScEkwogEbAFBbEYzgEP/im8hK0vkCRowAALUTwQgO8fWxyFKcjVjLCABQWxGM4BCLxcJaRgCAWo9gBIcFEIwAALUcwQgOK+kzIhgBAGorghEcZl/LiOZrAEAtRTCCw7iRLACgtiMYwWEBfvQYAQBqN4IRHGbvMeJGsgCAWopgBIcxlQYAqO38zC4ANUdJMNr67Unl/Frgls8I9vfVja0iZPXzdcv7AwBQGYIRHBbkfyGsvP5/h9z6OVP7t9G4xOZu/QwAAMpDMILDxvVqLj9fiwqL3HO5fuapXGX+fE6ZP+e65f0BAKgKwQgOS2zVWImtGrvt/V/b/K2SP/2vzuUXuu0zAACoDM3X8BrBARem6nIJRgAAkxCM4DWCAi4MYJ47TzACAJiDYASvUTJixFQaAMAsBCN4jZKr3nLPu2cpAAAAqkIwgtcIoscIAGAyghG8BlNpAACzEYzgNezBiOZrAIBJCEbwGiVXpTGVBgAwC8EIXqOk+Tq/oMhtq2sDAFAZghG8RslUmiTl5nNlGgDA8whG8BpWPx9ZLBf+pgEbAGAGghG8hsViUbA/DdgAAPMQjOBVaMAGAJiJYASvEhRw4SdJMAIAmKFGBaM1a9aoa9euCgoKUkREhIYOHVrp/oZhKCkpSTExMQoKClKvXr20b98+D1WL6gj2L76RLMEIAGCCGhOMVq5cqZEjR+qBBx7Ql19+qS1btmjEiBGVHjNv3jwtWLBAixcv1o4dOxQdHa0+ffrozJkzHqoazrp4WxCuSgMAeJ6f2QU4oqCgQBMnTtSLL76oMWPG2Le3bt26wmMMw9CiRYs0ffp0+8jS0qVLFRUVpXfffVd/+MMf3F43nMfq1wAAM9WIEaPdu3fr6NGj8vHxUceOHWWz2dS/f/9Kp8UyMjKUlZWlvn372rdZrVYlJiZq69atFR6Xl5ennJycUg94DvdLAwCYqUYEo0OHDkmSkpKSNGPGDH388cdq0KCBEhMT9fPPP5d7TFZWliQpKiqq1PaoqCj7a+VJTk5WeHi4/REbG+uibwFHBPqXTKURjAAAnmdqMEpKSpLFYqn0sXPnThUVFUmSpk+frjvvvFOdO3fWkiVLZLFY9P7771f6GZaSFQOLGYZRZtulpk2bpuzsbPsjMzPzyr8oHMZUGgDATKb2GE2YMEHDhw+vdJ+EhAR7s3Tbtm3t261Wq6666iodOXKk3OOio6MlXRg5stls9u0nTpwoM4p0KavVKqvV6vB3gGsFB3BVGgDAPKYGo4iICEVERFS5X+fOnWW1WpWenq4bbrhBknT+/HkdPnxY8fHx5R7TrFkzRUdHa/369erYsaMkKT8/X5s3b9bcuXNd9yXgUhevSiMYAQA8r0b0GIWFhWncuHGaOXOmUlJSlJ6erocffliSdPfdd9v3a9OmjVavXi3pwhTapEmTNGfOHK1evVpfffWVRo8ereDg4Cov84d5Lt4ShMv1AQCeVyMu15ekF198UX5+fho5cqTOnTunrl27asOGDWrQoIF9n/T0dGVnZ9ufT5kyRefOndP48eN16tQpde3aVSkpKQoNDTXjK8ABjBgBAMxkMQzDMLsIb5aTk6Pw8HBlZ2crLCzM7HJqvWWff6fpq79Sn7ZReuP+LmaXAwCooar773eNmEpD3VFyVdqvXJUGADABwQheJaj4XmlMpQEAzEAwglcJpscIAGAighG8SpD9liBclQYA8DyCEbxKELcEAQCYiGAEr8ItQQAAZiIYwatwSxAAgJkIRvAqJVNpBUWG8guKTK4GAFDXEIzgVUqaryVGjQAAnkcwglcJ8PORn49FkpTL/dIAAB5GMILXuXjJPiNGAADPIhjB67DIIwDALAQjeJ2SBmwu2QcAeBrBCF4nKID7pQEAzEEwgtcJ5rYgAACT+JldAHC5kmB06KdfdOCHMyZXg0tZJCVE1JO/L/+fCkDtRDCC1ynpMZq3Nl3z1qabXA0u17NFIy17qJvZZQCAWxCM4HXu6NBEe77PVn4hK197kyLD0Onc89p5+JQMw5DFYjG7JABwOYIRvM7t19p0+7U2s8vAZX49X6g2z65VXkGRcn4tUHiQv9klAYDL0SgAwCGB/r4KDbzw/6V+PPOrydUAgHsQjAA4LDLUKkk6kZNnciUA4B4EIwAOiwwNlCSdOEMwAlA7EYwAOCwyrHjEiKk0ALUUwQiAw5hKA1DbEYwAOIypNAC1HcEIgMOYSgNQ2xGMADiscclUGiNGAGopghEAh5VMpf1IjxGAWopgBMBhJVNpZ/IKdC6/0ORqAMD1CEYAHBZq9VOg/4X/2aDPCEBtRDAC4DCLxaKoMK5MA1B7EYwAOIW1jADUZgQjAE65uJYRU2kAah+CEQCncMk+gNrMz+wCnLFmzRo9//zz2rNnj+rVq6ebbrpJq1atqnD/0aNHa+nSpaW2de3aVdu2bXN3qUCtVXJl2ncnf9H3p3JNrgZAbRBq9Vd4sL/ZZUiqQcFo5cqVGjt2rObMmaObb75ZhmFo7969VR7Xr18/LVmyxP48ICDAnWUCtV7JVNone7P0yd4sk6sBUBuM79VcU/q1MbsMSTUkGBUUFGjixIl68cUXNWbMGPv21q1bV3ms1WpVdHS0w5+Vl5envLyLUwQ5OTnOFQvUcj1bNFJswyCarwG4jJ+PxewS7GpEMNq9e7eOHj0qHx8fdezYUVlZWerQoYP+9Kc/6Zprrqn02E2bNikyMlL169dXYmKiZs+ercjIyAr3T05O1qxZs1z9FYBawxYepH9PudnsMgDALSyGYRhmF1GV5cuX65577lFcXJwWLFighIQEzZ8/XykpKTpw4IAaNmxY7nErVqxQSEiI4uPjlZGRoWeffVYFBQXatWuXrFZruceUN2IUGxur7OxshYWFueX7AQAA18rJyVF4eLjT/36belVaUlKSLBZLpY+dO3eqqKhIkjR9+nTdeeed6ty5s5YsWSKLxaL333+/wvcfNmyYbr/9drVr104DBw7Up59+qgMHDmjNmjUVHmO1WhUWFlbqAQAA6gZTp9ImTJig4cOHV7pPQkKCzpw5I0lq27atfbvVatVVV12lI0eOOPx5NptN8fHxOnjwYPUKBgAAtZqpwSgiIkIRERFV7te5c2dZrValp6frhhtukCSdP39ehw8fVnx8vMOfd/LkSWVmZspms1W7ZgAAUHvViAUew8LCNG7cOM2cOVMpKSlKT0/Xww8/LEm6++677fu1adNGq1evliSdPXtWTz75pFJTU3X48GFt2rRJAwcOVEREhIYMGWLK9wAAAN6tRlyVJkkvvvii/Pz8NHLkSJ07d05du3bVhg0b1KBBA/s+6enpys7OliT5+vpq7969euedd3T69GnZbDb17t1bK1asUGhoqFlfAwAAeLEacVWamarb1Q4AAMxTI69KAwAA8CYEIwAAgGIEIwAAgGIEIwAAgGIEIwAAgGIEIwAAgGIEIwAAgGI1ZoFHs5Qs85STk2NyJQAAwFEl/247u1wjwagKJTewjY2NNbkSAADgrDNnzig8PNzh/Vn5ugpFRUU6duyYQkNDZbFYXPKeOTk5io2NVWZmJqtpewjn3PM4557HOfc8zrk5HDnvhmHozJkziomJkY+P451DjBhVwcfHR02bNnXLe4eFhfFfJA/jnHse59zzOOeexzk3R1Xn3ZmRohI0XwMAABQjGAEAABTzTUpKSjK7iLrI19dXvXr1kp8fs5mewjn3PM6553HOPY9zbg53nXearwEAAIoxlQYAAFCMYAQAAFCMYAQAAFCMYAQAAFCMYORhr7zyipo1a6bAwEB17txZ//73v80uqdZISkqSxWIp9YiOjra/bhiGkpKSFBMTo6CgIPXq1Uv79u0zseKa5//+7/80cOBAxcTEyGKx6IMPPij1uiPnOC8vT48++qgiIiJUr149DRo0SN9//70nv0aNUtU5Hz16dJnffbdu3Urtwzl3TnJysq6//nqFhoYqMjJSgwcPVnp6eql9+K27liPn3FO/dYKRB61YsUKTJk3S9OnTlZaWphtvvFH9+/fXkSNHzC6t1rjmmmt0/Phx+2Pv3r321+bNm6cFCxZo8eLF2rFjh6Kjo9WnTx/7/fBQtV9++UXXXXedFi9eXO7rjpzjSZMmafXq1Vq+fLn+85//6OzZsxowYIAKCws99TVqlKrOuST169ev1O/+k08+KfU659w5mzdv1iOPPKJt27Zp/fr1KigoUN++ffXLL7/Y9+G37lqOnHPJQ791Ax7zm9/8xhg3blypbW3atDGmTp1qUkW1y8yZM43rrruu3NeKioqM6Oho449//KN926+//mqEh4cbr776qqdKrFUkGatXr7Y/d+Qcnz592vD39zeWL19u3+fo0aOGj4+PsXbtWs8VX0Ndfs4NwzBGjRpl3HHHHRUewzm/cidOnDAkGZs3bzYMg9+6J1x+zg3Dc791Row8JD8/X7t27VLfvn1Lbe/bt6+2bt1qUlW1z8GDBxUTE6NmzZpp+PDhOnTokCQpIyNDWVlZpc6/1WpVYmIi599FHDnHu3bt0vnz50vtExMTo3bt2vGfwxXYtGmTIiMj1apVK40dO1YnTpywv8Y5v3LZ2dmSpIYNG0rit+4Jl5/zEp74rROMPOSnn35SYWGhoqKiSm2PiopSVlaWSVXVLl27dtU777yjdevW6Y033lBWVpZ69OihkydP2s8x5999HDnHWVlZCggIUIMGDSrcB87p37+/li1bpg0bNmj+/PnasWOHbr75ZuXl5UninF8pwzA0efJk3XDDDWrXrp0kfuvuVt45lzz3W2f9cg+zWCylnhuGUWYbqqd///72v9u3b6/u3burefPmWrp0qb1Bj/PvftU5x/znUH3Dhg2z/92uXTt16dJF8fHxWrNmjYYOHVrhcZxzx0yYMEF79uzRf/7znzKv8Vt3j4rOuad+64wYeUhERIR8fX3LpNYTJ06U+X8dcI169eqpffv2OnjwoP3qNM6/+zhyjqOjo5Wfn69Tp05VuA+ujM1mU3x8vA4ePCiJc34lHn30UX300UfauHGjmjZtat/Ob919Kjrn5XHXb51g5CEBAQHq3Lmz1q9fX2r7+vXr1aNHD5Oqqt3y8vK0f/9+2Ww2NWvWTNHR0aXOf35+vjZv3sz5dxFHznHnzp3l7+9fap/jx4/rq6++4j8HFzl58qQyMzNls9kkcc6rwzAMTZgwQatWrdKGDRvUrFmzUq/zW3e9qs55edz2W3e8RxxXavny5Ya/v7/x5ptvGl9//bUxadIko169esbhw4fNLq1WeOKJJ4xNmzYZhw4dMrZt22YMGDDACA0NtZ/fP/7xj0Z4eLixatUqY+/evcY999xj2Gw2Iycnx+TKa44zZ84YaWlpRlpamiHJWLBggZGWlmZ89913hmE4do7HjRtnNG3a1PjXv/5l7N6927j55puN6667zigoKDDra3m1ys75mTNnjCeeeMLYunWrkZGRYWzcuNHo3r270aRJE875FXj44YeN8PBwY9OmTcbx48ftj9zcXPs+/NZdq6pz7snfOsHIw15++WUjPj7eCAgIMDp16lTqUkRcmWHDhhk2m83w9/c3YmJijKFDhxr79u2zv15UVGTMnDnTiI6ONqxWq3HTTTcZe/fuNbHimmfjxo2GpDKPUaNGGYbh2Dk+d+6cMWHCBKNhw4ZGUFCQMWDAAOPIkSMmfJuaobJznpuba/Tt29do3Lix4e/vb8TFxRmjRo0qcz45584p73xLMpYsWWLfh9+6a1V1zj35W7cUFwQAAFDn0WMEAABQjGAEAABQjGAEAABQjGAEAABQjGAEAABQjGAEAABQjGAEAABQjGAEAABQjGAEwO0SEhK0aNGiK3qPpKQkdejQwUUVle/w4cOyWCz64osv3Po57lQbvgNgJla+BuAyb7/9tiZNmqTTp0+X2v7jjz+qXr16Cg4OrvZ7nz17Vnl5eWrUqNGVlilJGj16tE6fPq0PPvjAvq2wsFA//vijIiIi5Ofn55LP8bTDhw+rWbNmSktLc3uQBGqjmvnffAA1SuPGja/4PUJCQhQSEuKCairm6+ur6Ohot34GAO/GVBoASVJeXp4ee+wxRUZGKjAwUDfccIN27Nhhf33Tpk2yWCxas2aNrrvuOgUGBqpr167au3ev/fUHHnhA2dnZslgsslgsSkpKklR2Ks1isei1117TgAEDFBwcrKuvvlqpqan65ptv1KtXL9WrV0/du3fXt99+az/m8qm0ks+49JGQkCDpwsjPmDFj1KxZMwUFBal169b63//931LvtXTpUn344Yf2Yzdt2lTuNNTmzZv1m9/8RlarVTabTVOnTlVBQYH99V69eumxxx7TlClT1LBhQ0VHR9u/d2XeeustXXPNNfb3nTBhgiTpwQcf1IABA0rtW1BQoOjoaL311luSpKKiIs2dO1ctWrSQ1WpVXFycZs+eXeFnff3117rtttsUEhKiqKgojRw5Uj/99FOVNQJ1kivuigug5nvssceMmJgY45NPPjH27dtnjBo1ymjQoIFx8uRJwzAu3uX96quvNlJSUow9e/YYAwYMMBISEoz8/HwjLy/PWLRokREWFmYcP37cOH78uHHmzBnDMAwjPj7eWLhwof2zJBlNmjQxVqxYYaSnpxuDBw82EhISjJtvvtlYu3at8fXXXxvdunUz+vXrZz9m5syZxnXXXWd/XvIZx48fN7755hujRYsWxsiRIw3DMIz8/HzjueeeM7Zv324cOnTI+Pvf/24EBwcbK1asMAzDMM6cOWP87ne/M/r162d/j7y8PCMjI8OQZKSlpRmGYRjff/+9ERwcbIwfP97Yv3+/sXr1aiMiIsKYOXOmvY7ExEQjLCzMSEpKMg4cOGAsXbrUsFgsRkpKSoXn+pVXXjECAwONRYsWGenp6cb27dvt52fLli2Gr6+vcezYMfv+H374oVGvXj37+ZwyZYrRoEED4+233za++eYb49///rfxxhtvGIZhlPkOx44dMyIiIoxp06YZ+/fvN3bv3m306dPH6N27tzM/D6DOIBgBMM6ePWv4+/sby5Yts2/Lz883YmJijHnz5hmGcTEYLV++3L7PyZMnjaCgIHvgWLJkiREeHl7m/csLRjNmzLA/T01NNSQZb775pn3bP/7xDyMwMND+/PJgVKKoqMgYMmSI0blzZyM3N7fC7zh+/HjjzjvvtD8fNWqUcccdd5Ta5/JQ8cwzzxitW7c2ioqK7Pu8/PLLRkhIiFFYWGgYxoVgdMMNN5R6n+uvv954+umnK6wlJibGmD59eoWvt23b1pg7d679+eDBg43Ro0cbhmEYOTk5htVqtQehy13+HZ599lmjb9++pfbJzMw0JBnp6ekV1gDUVUylAdC3336r8+fPq2fPnvZt/v7++s1vfqP9+/eX2rd79+72vxs2bKjWrVuX2ccR1157rf3vqKgoSVL79u1Lbfv111+Vk5NT6fs888wzSk1N1QcffKCgoCD79ldffVVdunRR48aNFRISojfeeENHjhxxqsb9+/ere/fuslgs9m09e/bU2bNn9f3335f7XSTJZrPpxIkT5b7niRMndOzYMf32t7+t8HMfeughLVmyxL7/mjVr9OCDD9prysvLq/T4S+3atUsbN26092iFhISoTZs2klRqqhLABTRfA5BRfHHqpQGgZPvl28rjyD6X8/f3L3N8eduKiooqfI+///3vWrhwoTZt2qSmTZvat7/33nt6/PHHNX/+fHXv3l2hoaF68cUX9fnnnztVY3nfv7xzdWndJa9VVPel4a0i999/v6ZOnarU1FSlpqYqISFBN954o8PHX6qoqEgDBw7U3Llzy7xms9mcei+gLmDECIBatGihgIAA/ec//7FvO3/+vHbu3Kmrr7661L7btm2z/33q1CkdOHDAPgIREBCgwsJCj9Scmpqqhx56SK+99pq6detW6rV///vf6tGjh8aPH6+OHTuqRYsWZUZHHKm1bdu22rp1qz0MSdLWrVsVGhqqJk2aVKvu0NBQJSQk6LPPPqtwn0aNGmnw4MFasmSJlixZogceeMD+WsuWLRUUFFTp8Zfq1KmT9u3bp4SEBLVo0aLUo169etX6DkBtRjACoHr16unhhx/WU089pbVr1+rrr7/W2LFjlZubqzFjxpTa9/nnzYVH4QAAAp5JREFUn9dnn32mr776SqNHj1ZERIQGDx4s6cLVZ2fPntVnn32mn376Sbm5uW6pNysrS0OGDNHw4cN16623KisrS1lZWfrxxx8lXQh6O3fu1Lp163TgwAE9++yzpa6wK6l1z549Sk9P108//aTz58+X+Zzx48crMzNTjz76qP773//qww8/1MyZMzV58mT5+FT/fz6TkpI0f/58vfTSSzp48KB2796tP//5z6X2eeihh7R06VLt379fo0aNsm8PDAzU008/rSlTpuidd97Rt99+q23btunNN98s97MeeeQR/fzzz7rnnnu0fft2HTp0SCkpKXrwwQc9FmKBmoRgBECS9Mc//lF33nmnRo4cqU6dOumbb77RunXr1KBBgzL7TZw4UZ07d9bx48f10UcfKSAgQJLUo0cPjRs3TsOGDVPjxo01b948t9T63//+Vz/88IOWLl0qm81mf1x//fWSpHHjxmno0KEaNmyYunbtqpMnT2r8+PGl3mPs2LFq3bq1vQ9py5YtZT6nSZMm+uSTT7R9+3Zdd911GjdunMaMGaMZM2ZcUf2jRo3SokWL9Morr+iaa67RgAEDdPDgwVL73HLLLbLZbLr11lsVExNT6rVnn31WTzzxhJ577jldffXVGjZsWIU9TTExMdqyZYsKCwt16623ql27dpo4caLCw8OvKNwBtRUrXwNwyKZNm9S7d2+dOnVK9evXN7ucWi83N1cxMTF66623NHToULPLAeoMmq8BwIsUFRUpKytL8+fPV3h4uAYNGmR2SUCdQjACAC9y5MgRNWvWTE2bNtXbb79dY+/ZBtRUTKUBAAAUo/MOAACgGMEIAACgGMEIAACgGMEIAACgGMEIAACgGMEIAACgGMEIAACgGMEIAACg2P8H8wN8orUO5gsAAAAASUVORK5CYII=\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -362,24 +200,17 @@
     }
    ],
    "source": [
-    "# visualize the optimization process\n",
-    "cycles = np.arange(1, metrics['count'])\n",
-    "optim_classical = metrics['global_energies']\n",
+    "import matplotlib.pyplot as plt\n",
     "\n",
-    "# print information\n",
-    "info = 'Optimization on graph with n={} vertices, m={} edges, optimized with {} and {} shots per call; seed={}.'\n",
-    "print(info.format(n, m, OPT_METHOD, SHOTS, seed))\n",
+    "%matplotlib inline\n",
     "\n",
-    "plt.plot(cycles, optim_classical)\n",
-    "plt.xlabel('optimization cycle')\n",
-    "plt.ylabel('best classical minimum')\n",
-    "plt.show()"
+    "plt.plot(losses)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "4aaa6ad7",
+   "id": "2afbc2c6",
    "metadata": {},
    "outputs": [],
    "source": []
@@ -387,9 +218,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "conda_braket",
+   "display_name": "Python 3.9.5 64-bit ('braket')",
    "language": "python",
-   "name": "conda_braket"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -401,7 +232,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.13"
+   "version": "3.9.5"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "5904cb9a2089448a2e1aeb5d493d227c9de33e591d7c07e4016fb81e71061a5d"
+   }
   }
  },
  "nbformat": 4,
diff --git a/examples/Quantum_Phase_Estimation_Algorithm.ipynb b/examples/Quantum_Phase_Estimation_Algorithm.ipynb
index 5def1235..5343893a 100644
--- a/examples/Quantum_Phase_Estimation_Algorithm.ipynb
+++ b/examples/Quantum_Phase_Estimation_Algorithm.ipynb
@@ -36,13 +36,13 @@
    "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt\n",
-    "\n",
+    "from braket.aws import AwsDevice\n",
     "from braket.circuits import Circuit, circuit\n",
     "from braket.devices import LocalSimulator\n",
-    "from braket.aws import AwsDevice\n",
-    "from quantum_phase_estimation import (\n",
-    "    run_quantum_phase_estimation,\n",
+    "\n",
+    "from braket.experimental.algorithms.quantum_phase_estimation import (\n",
     "    get_quantum_phase_estimation_results,\n",
+    "    run_quantum_phase_estimation,\n",
     ")\n",
     "\n",
     "# magic word for producing visualizations in notebook\n",
@@ -67,18 +67,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Create your own controlled unitary gate on which you want to estimate eigenvalues.\n",
+    "# Define a callback function to apply your controlled unitary to a given circuit.\n",
+    "# This is used by the Quantum Phase Estimation algorithm to apply your controlled unitary.\n",
     "# To run on a QPU this controlled unitary needs to be decomposed into gates available for a given QPU.\n",
-    "# This circuit accepts a control qubit, and a list of target qubits to host the unitary\n",
-    "@circuit.subroutine(register=True)\n",
-    "def qpe_controlled_cnot_unitary(control_qubit, target_qubits):\n",
-    "    return Circuit().cnot(control=control_qubit, target=target_qubits)\n",
-    "\n",
-    "\n",
-    "# Define a callback function to apply your controlled unitary to a given circuit.# This is used by the Quantum Phase Estimation algorithm to apply your controlled unitary\n",
     "def unitary_apply_cnot_func(quantum_phase_estimation_circuit, control_qubit, query_qubits):\n",
-    "    # apply the user defined controlled unitary gate\n",
-    "    quantum_phase_estimation_circuit.qpe_controlled_cnot_unitary(control_qubit, query_qubits)"
+    "    quantum_phase_estimation_circuit.cnot(control_qubit, query_qubits)"
    ]
   },
   {
@@ -114,20 +107,21 @@
      "output_type": "stream",
      "text": [
       "Quantum Phase Estimation Circuit:\n",
-      "T  : |0|1|2| 3  |4|     5      |6|Result Types|\n",
-      "                                               \n",
-      "q0 : -H---C-SWAP---PHASE(-1.57)-H-Probability--\n",
-      "          | |      |              |            \n",
-      "q1 : -H-C-|-SWAP-H-C--------------Probability--\n",
-      "        | |                       |            \n",
-      "q2 : -H-X-X-----------------------Probability--\n",
-      "                                               \n",
-      "T  : |0|1|2| 3  |4|     5      |6|Result Types|\n"
+      "T  : |0|1| 2  |3|     4      |5|\n",
+      "                                \n",
+      "q0 : -H---SWAP---PHASE(-1.57)-H-\n",
+      "          |      |              \n",
+      "q1 : -H-C-SWAP-H-C--------------\n",
+      "        |                       \n",
+      "q2 : -H-X-----------------------\n",
+      "\n",
+      "T  : |0|1| 2  |3|     4      |5|\n"
      ]
     }
    ],
    "source": [
-    "# Now that you have prepped the unitary, precision qubits, and query qubits, create the quantum phase estimation circuit with all three as input.\n",
+    "# Now that you have prepped the unitary, precision qubits, and query qubits,\n",
+    "# create the quantum phase estimation circuit with all three as input.\n",
     "quantum_phase_estimation_circuit.quantum_phase_estimation(\n",
     "    precision_qubits, query_qubits, unitary_apply_cnot_func\n",
     ")\n",
@@ -152,12 +146,13 @@
      "output_type": "stream",
      "text": [
       "Quantum Phase Estimation Running\n",
-      "Quuantum Phase Estimation Run Complete\n",
+      "Quantum Phase Estimation Run Complete\n",
       "Quantum Phase Estimation Results:\n",
       "Measurement counts: Counter({'001': 545, '000': 455})\n",
       "Results in precision register: {'00': 1000}\n",
       "Quantum Phase Estimation phase estimates: [0.0]\n",
-      "Quantum Phase Estimation eigenvalue estimates: [1.+0.j]"
+      "Quantum phase estimation eigenvalue estimates: [1.+0.j]\n",
+      "Measurement Counts Graph:\n"
      ]
     },
     {
@@ -177,13 +172,21 @@
     "# define device and run quantum phase estimation\n",
     "device = LocalSimulator()\n",
     "print(\"Quantum Phase Estimation Running\")\n",
-    "results = run_quantum_phase_estimation(\n",
+    "result = run_quantum_phase_estimation(\n",
     "    quantum_phase_estimation_circuit, precision_qubits, query_qubits, device\n",
     ")\n",
     "print(\"Quantum Phase Estimation Run Complete\")\n",
     "# pretty print results. Comment out these lines if you don't want results printed\n",
     "print(\"Quantum Phase Estimation Results:\")\n",
-    "get_quantum_phase_estimation_results(results)"
+    "agg_result = get_quantum_phase_estimation_results(\n",
+    "    result, precision_qubits, query_qubits, verbose=True\n",
+    ")\n",
+    "# plot probabalities\n",
+    "plt.bar(agg_result[\"bitstring_keys\"], agg_result[\"probs_values\"])\n",
+    "plt.xlabel(\"bitstrings\")\n",
+    "plt.ylabel(\"probability\")\n",
+    "plt.xticks(rotation=90)\n",
+    "print(\"Measurement Counts Graph:\")"
    ]
   },
   {
@@ -248,7 +251,13 @@
     "print('Quantum Phase Estimation Run Complete')\n",
     "# pretty print results\n",
     "print('Quantum Phase Estimation Results:')\n",
-    "get_quantum_phase_estimation_results(results)\n",
+    "agg_result = get_quantum_phase_estimation_results(result, precision_qubits, query_qubits, verbose=True)\n",
+    "# plot probabalities\n",
+    "plt.bar(agg_result[\"bitstring_keys\"], agg_result[\"probs_values\"])\n",
+    "plt.xlabel(\"bitstrings\")\n",
+    "plt.ylabel(\"probability\")\n",
+    "plt.xticks(rotation=90)\n",
+    "print(\"Measurement Counts Graph:\")\n",
     "\"\"\""
    ]
   },
diff --git a/examples/Template.ipynb b/examples/Template.ipynb
new file mode 100644
index 00000000..1e1b3b2a
--- /dev/null
+++ b/examples/Template.ipynb
@@ -0,0 +1,119 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Algorithm Name\n",
+    "[Brief description of algorithm]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# References \n",
+    "[1] references here with hyperlinkns"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# [Optional] Print the circuits"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Run on a local simulator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Code here\n",
+    "local_simulator = LocalSimulator()\n",
+    "task = local_simulator.run(circuit, shots=100)\n",
+    "result = task.result()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# [Optional] Run on a QPU\n",
+    "\n",
+    "[Include estimated price for running in USD.]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Code here\n",
+    "qpu = AwsDevice(\"quantum_arn\")\n",
+    "task = qpu.run(circuit, shots=100)\n",
+    "result = task.result()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[Print the final costs]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\n",
+    "    f\"Estimated cost to run this example: {tracker.qpu_tasks_cost() + tracker.simulator_tasks_cost():.2f} USD\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.9.5 64-bit ('braket')",
+   "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.5"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "5904cb9a2089448a2e1aeb5d493d227c9de33e591d7c07e4016fb81e71061a5d"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/setup.py b/setup.py
index f86040e8..7f91a1cf 100644
--- a/setup.py
+++ b/setup.py
@@ -13,7 +13,7 @@
 
 from setuptools import find_namespace_packages, setup
 
-with open("README.md", "r") as fh:
+with open("README.md") as fh:
     long_description = fh.read()
 
 with open("src/braket/_algos/_version.py") as f:
diff --git a/src/braket/experimental/algorithms/qaoa/__init__.py b/src/braket/experimental/algorithms/qaoa/__init__.py
index e69de29b..7307120b 100644
--- a/src/braket/experimental/algorithms/qaoa/__init__.py
+++ b/src/braket/experimental/algorithms/qaoa/__init__.py
@@ -0,0 +1,18 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+from braket.experimental.algorithms.qaoa.qaoa import (  # noqa: F401
+    evaluate_circuit,
+    evaluate_loss,
+    qaoa,
+)
diff --git a/src/braket/experimental/algorithms/qaoa/qaoa.py b/src/braket/experimental/algorithms/qaoa/qaoa.py
index 39060727..87d86f46 100644
--- a/src/braket/experimental/algorithms/qaoa/qaoa.py
+++ b/src/braket/experimental/algorithms/qaoa/qaoa.py
@@ -11,258 +11,128 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 
-from typing import Any, Dict, List, Tuple, Union
 
 import numpy as np
-from braket.aws import AwsDevice
-from braket.circuits import Circuit, circuit
-from braket.devices import LocalSimulator
-from scipy.optimize import minimize
+from braket.circuits import Circuit, FreeParameter, Observable, circuit
+from braket.devices import Device
+from braket.tasks import QuantumTask
 
 
-def _zzgate(q1: int, q2: int, gamma: float) -> Circuit:
-    """function that returns a circuit implementing exp(-i gamma Z_i Z_j)
-    using CNOT gates if ZZ not supported
+def evaluate_circuit(device: Device, circ: Circuit, values: np.ndarray, shots: int) -> QuantumTask:
+    """Evaluate a QAOA circuit with parameters=values.
 
     Args:
-        q1 (int): Index value for the controlling qubit for CNOT gate
-        q2 (int): Index value for the target qubit for CNOT gate
-        gamma (float): Rotation angle to apply parameterized rotation around z
+        device (Device): Braket device to run on.
+        circ (Circuit): QAAO circuit to run.
+        values (np.ndarray): Values for the parameters.
+        shots (int): Number of shots.
 
     Returns:
-        Circuit: Circuit object that implements ZZ gate using CNOT gates
+        QuantumTask: The Braket task to run.
     """
-
-    # get a circuit
-    circ_zz = Circuit()
-
-    # construct decomposition of ZZ
-    circ_zz.cnot(q1, q2).rz(q2, gamma).cnot(q1, q2)
-
-    return circ_zz
+    fixed_circuit = circ.make_bound_circuit(
+        dict(zip(np.array(list(circ.parameters), dtype=str), values))
+    )
+    task = device.run(fixed_circuit, shots=shots)
+    return task
 
 
-def _driver(beta: float, n_qubits: int) -> Circuit:
-    """Returns circuit for driver Hamiltonian U(Hb, beta)
+def evaluate_loss(task: QuantumTask, coeffs: np.ndarray) -> float:
+    """Evaluate the loss function from a QAOA task.
 
     Args:
-        beta (float): Rotation angle to apply parameterized rotation around x
-        n_qubits (int): number of qubits to apply rx gate
+        task (QuantumTask): QAOA task.
+        coeffs (np.ndarray): The coefficients of the cost Hamiltonian.
 
     Returns:
-        Circuit: Circuit object that implements evolution with driver Hamiltonian
+        float: Loss function value.
     """
-    return Circuit().rx(range(n_qubits), 2 * beta)
+    exp_vals = task.result().result_types
+    loss = sum(c * s.value for c, s in zip(coeffs, exp_vals))
+    return loss
 
 
-def _cost_circuit(
-    gamma: float, ising: np.ndarray, device: Union[AwsDevice, LocalSimulator]
-) -> Circuit:
-    """Returns circuit for evolution with cost Hamiltonian
+def qaoa(n_qubits: int, n_layers: int, ising: np.ndarray) -> Circuit:
+    """QAOA template.
 
     Args:
-        gamma (float): Rotation angle to apply parameterized rotation around z
-        ising (np.ndarray): Ising matrix
-        device (Union[AwsDevice, LocalSimulator]): AwsDevice or LocalSimulator to run the circuit on
+        n_qubits (int): Number of qubits
+        n_layers (int): Number of layers. Defaults to 1.
+        ising (ndarray): Ising interaction matrix.
 
     Returns:
-        Circuit: Circuit for evolution with cost Hamiltonian
+        Circuit: The parameteric QAOA Circuit
     """
-    # instantiate circuit object
+
+    gammas = [FreeParameter(f"gamma_{p}") for p in range(n_layers)]
+    betas = [FreeParameter(f"beta_{p}") for p in range(n_layers)]
+
     circ = Circuit()
+    circ.h(range(n_qubits))  # prepare |+> state
+    for gamma, beta in zip(gammas, betas):
+        circ.cost_layer(gamma, ising)
+        circ.driver_layer(beta, n_qubits)
 
-    # get all non-zero entries (edges) from Ising matrix
+    # add Result types
     idx = ising.nonzero()
-    edges = list(zip(idx[0], idx[1]))
-
-    # apply ZZ gate for every edge (with corresponding interaction strength)
-    for qubit_pair in edges:
+    for qubit_pair in zip(idx[0], idx[1]):
         # get interaction strength from Ising matrix
-        int_strength = ising[qubit_pair[0], qubit_pair[1]]
-        # for Rigetti we decompose ZZ using CNOT gates
-        if isinstance(device, AwsDevice) and device.provider_name == "Rigetti":
-            gate = _zzgate(qubit_pair[0], qubit_pair[1], gamma * int_strength)
-            circ.add(gate)
-        # classical simulators and IonQ support ZZ gate
-        else:
-            gate = Circuit().zz(qubit_pair[0], qubit_pair[1], angle=2 * gamma * int_strength)
-            circ.add(gate)
-
+        circ.expectation(observable=Observable.Z() @ Observable.Z(), target=qubit_pair)
     return circ
 
 
 @circuit.subroutine(register=True)
-def qaoa(
-    params: List[float], device: Union[AwsDevice, LocalSimulator], n_qubits: int, ising: np.ndarray
-) -> Circuit:
-    """function to return full QAOA circuit;
-    depends on device as ZZ implementation depends on gate set of backend
+def driver_layer(beta: float, n_qubits: int) -> Circuit:
+    """Returns circuit for driver Hamiltonian U(Hb, beta).
 
     Args:
-        params (List[float]): Parameters for the rotation gates
-        device (Union[AwsDevice, LocalSimulator]): AwsDevice or LocalSimulator to run the circuit on
-        n_qubits (int): number of qubits
-        ising (np.ndarray): Ising matrix
+        beta (float): Rotation angle to apply parameterized rotation around x
+        n_qubits (int): number of qubits to apply rx gate
 
     Returns:
-        Circuit: QAOA circuit
+        Circuit: Circuit object that implements evolution with driver Hamiltonian
     """
-
-    # initialize qaoa circuit with first Hadamard layer: for minimization start in |->
-    circ = Circuit()
-    circ.x(range(0, n_qubits))
-    circ.h(range(0, n_qubits))
-
-    # setup two parameter families
-    circuit_length = len(params) // 2
-    gammas = params[:circuit_length]
-    betas = params[circuit_length:]
-
-    # add QAOA circuit layer blocks
-    for gamma, beta in zip(gammas, betas):
-        circ.add(_cost_circuit(gamma, ising, device))
-        circ.add(_driver(beta, n_qubits))
-
-    return circ
+    return Circuit().rx(range(n_qubits), 2 * beta)
 
 
-def _objective_function(
-    params: List[float],
-    device: Union[AwsDevice, LocalSimulator],
+@circuit.subroutine(register=True)
+def cost_layer(
+    gamma: float,
     ising: np.ndarray,
-    n_qubits: int,
-    n_shots: int,
-    tracker: Dict[str, Any],
-    verbose: bool = False,
-) -> float:
-    """objective function takes a list of variational parameters as input,
-    and returns the cost associated with those parameters
+) -> Circuit:
+    """Returns circuit for evolution with cost Hamiltonian.
 
     Args:
-        params (List[float]): Parameters for the rotation gates
-        device (Union[AwsDevice, LocalSimulator]): AwsDevice or LocalSimulator to run the circuit on
+        gamma (float): Rotation angle to apply parameterized rotation around z
         ising (np.ndarray): Ising matrix
-        n_qubits (int): number of qubits
-        n_shots (int): Number of shots
-        tracker (Dict[str, Any]): Tracker to keep track of results
-        verbose (bool): Enable or disable verbose logging
 
     Returns:
-        float: Final average energy cost
+        Circuit: Circuit for evolution with cost Hamiltonian
     """
-
-    # get a quantum circuit instance from the parameters
-    qaoa_circuit = qaoa(params, device, n_qubits, ising)
-
-    # classically simulate the circuit
-    # execute the correct device.run call depending on whether the backend is local or cloud based
-    if isinstance(device, LocalSimulator):
-        task = device.run(qaoa_circuit, shots=n_shots)
-    else:
-        task = device.run(qaoa_circuit, shots=n_shots, poll_timeout_seconds=3 * 24 * 60 * 60)
-
-    # get result for this task
-    result = task.result()
-
-    # convert results (0 and 1) to ising (-1 and 1)
-    meas_ising = result.measurements
-    meas_ising[meas_ising == 0] = -1
-
-    # get all energies (for every shot): (n_shots, 1) vector
-    all_energies = np.diag(np.dot(meas_ising, np.dot(ising, np.transpose(meas_ising))))
-
-    # find minimum and corresponding classical string
-    energy_min = np.min(all_energies)
-    tracker["opt_energies"].append(energy_min)
-    optimal_string = meas_ising[np.argmin(all_energies)]
-    tracker["opt_bitstrings"].append(optimal_string)
-
-    # store optimal (classical) result/bitstring
-    if energy_min < tracker["optimal_energy"]:
-        tracker["optimal_energy"] = energy_min
-        tracker["optimal_bitstring"] = optimal_string
-
-    # store global minimum
-    tracker["global_energies"].append(tracker["optimal_energy"])
-
-    # energy expectation value
-    energy_expect = np.sum(all_energies) / n_shots
-
-    # update tracker
-    tracker.update({"count": tracker["count"] + 1, "res": result})
-    tracker["costs"].append(energy_expect)
-    tracker["params"].append(params)
-
-    return energy_expect
+    circ = Circuit()
+    # get all non-zero entries (edges) from Ising matrix
+    idx = ising.nonzero()
+    edges = list(zip(idx[0], idx[1]))
+    # apply ZZ gate for every edge (with corresponding interaction strength)
+    for qubit_pair in edges:
+        # get interaction strength from Ising matrix
+        interaction_strength = ising[qubit_pair[0], qubit_pair[1]]
+        circ.decomposed_zz_gate(qubit_pair[0], qubit_pair[1], gamma * interaction_strength)
+    return circ
 
 
-def run_qaoa(
-    device: Union[AwsDevice, LocalSimulator],
-    options: Dict[str, Any],
-    p: int,
-    ising: np.ndarray,
-    n_qubits: int,
-    n_shots: int,
-    opt_method: str,
-    tracker: Dict[str, Any],
-    verbose: bool = True,
-) -> Tuple[Dict[str, Any], Dict[str, Any]]:
-    """function to run QAOA algorithm for given, fixed circuit depth p
+@circuit.subroutine(register=True)
+def decomposed_zz_gate(qubit0: int, qubit1: int, gamma: float) -> Circuit:
+    """Return a circuit implementing exp(-i gamma Z_i Z_j) using CNOT gates if ZZ not supported.
 
     Args:
-        device (Union[AwsDevice, LocalSimulator]): AwsDevice or LocalSimulator to run the circuit on
-        options (Dict[str, Any]): options for classical optimization
-        p (int): circuit depth for QAOA
-        ising (np.ndarray): Ising matrix
-        n_qubits (int): Number of qubits
-        n_shots (int): Number of shots
-        opt_method (str): Optimization technique
-        tracker (Dict[str, Any]): Tracker to keep track of results
-        verbose (bool): Enable or disable logging
+        qubit0 (int): Index value for the controlling qubit for CNOT gate
+        qubit1 (int): Index value for the target qubit for CNOT gate
+        gamma (float): Rotation angle to apply parameterized rotation around z
 
     Returns:
-        Tuple[Dict[str, Any], Dict[str, Any]]: Results and tracker output
-
-    """
-    print("Training in progress...")
-
-    # randomly initialize variational parameters within appropriate bounds
-    gamma_initial = np.random.uniform(0, 2 * np.pi, p).tolist()
-    beta_initial = np.random.uniform(0, np.pi, p).tolist()
-    params0 = np.array(gamma_initial + beta_initial)
-
-    # set bounds for search space
-    bnds_gamma = [(0, 2 * np.pi) for _ in range(int(len(params0) / 2))]
-    bnds_beta = [(0, np.pi) for _ in range(int(len(params0) / 2))]
-    bnds = bnds_gamma + bnds_beta
-
-    tracker["params"].append(params0)
-
-    # run classical optimization (example: method='Nelder-Mead')
-    result = minimize(
-        _objective_function,
-        params0,
-        args=(device, ising, n_qubits, n_shots, tracker),
-        options=options,
-        method=opt_method,
-        bounds=bnds,
-    )
-
-    return result, tracker
-
-
-def get_qaoa_results(result: Dict[str, Any], tracker: Dict[str, Any]) -> None:
-    """Function to postprocess dictionary returned by run_qaoa and pretty print results
-
-    Args:
-        result (Dict[str, Any]): Results associated with QAOA optimization
-        tracker (Dict[str, Any]): Results tracked by tracker
-
+        Circuit: Circuit object that implements ZZ gate using CNOT gates
     """
-
-    print("Optimal energy:", tracker["optimal_energy"])
-    print("Optimal classical bitstring:", tracker["optimal_bitstring"])
-    result_energy = result.fun
-    print("Final average energy (cost):", result_energy)
-    result_angle = result.x
-    print("Final angles:", result_angle)
+    circ_zz = Circuit()
+    circ_zz.cnot(qubit0, qubit1).rz(qubit1, gamma).cnot(qubit0, qubit1)
+    return circ_zz
diff --git a/src/braket/experimental/algorithms/quantum_phase_estimation/__init__.py b/src/braket/experimental/algorithms/quantum_phase_estimation/__init__.py
index c6e7e329..8d729e1b 100644
--- a/src/braket/experimental/algorithms/quantum_phase_estimation/__init__.py
+++ b/src/braket/experimental/algorithms/quantum_phase_estimation/__init__.py
@@ -10,3 +10,8 @@
 # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
+
+from braket.experimental.algorithms.quantum_phase_estimation.quantum_phase_estimation import (  # noqa: F401,E501
+    get_quantum_phase_estimation_results,
+    run_quantum_phase_estimation,
+)
diff --git a/src/braket/experimental/algorithms/quantum_phase_estimation/quantum_phase_estimation.py b/src/braket/experimental/algorithms/quantum_phase_estimation/quantum_phase_estimation.py
index 777c8e0f..d255c16c 100644
--- a/src/braket/experimental/algorithms/quantum_phase_estimation/quantum_phase_estimation.py
+++ b/src/braket/experimental/algorithms/quantum_phase_estimation/quantum_phase_estimation.py
@@ -17,13 +17,15 @@
 
 import numpy as np
 from braket.circuits import Circuit, circuit
+from braket.circuits.qubit_set import QubitSetInput
 from braket.devices import Device
+from braket.tasks import GateModelQuantumTaskResult
 
 
 @circuit.subroutine(register=True)
 def quantum_phase_estimation(
-    precision_qubits: List[int],
-    query_qubits: List[int],
+    precision_qubits: QubitSetInput,
+    query_qubits: QubitSetInput,
     unitary_apply_func: Callable,
 ) -> Circuit:
     """
@@ -36,9 +38,23 @@ def quantum_phase_estimation(
          repeatedly apply this function for the target qubits. This is a necessary input because the
          controlled unitary needs to be defined in terms of available gates for a given QPU.
 
+    Example:
+        >>> def cnot_apply_func(circ, control_qubit, query_qubits):
+        ...    circ.qpe_cnot_unitary(control_qubit, query_qubits)
+        >>> circ = Circuit().h([2])
+        >>> circ.quantum_phase_estimation([0, 1], [2], cnot_apply_func)
+        >>> print(circ)
+        T  : |0|1| 2  |3|     4      |5|
+        q0 : -H---SWAP---PHASE(-1.57)-H-
+                  |      |
+        q1 : -H-C-SWAP-H-C--------------
+                |
+        q2 : -H-X-----------------------
+        T  : |0|1| 2  |3|     4      |5|
+
     Args:
-        precision_qubits (List[int]): Qubits defining the precision register
-        query_qubits (List[int]) : Qubits defining the query register
+        precision_qubits (QubitSetInput): Qubits defining the precision register
+        query_qubits (QubitSetInput) : Qubits defining the query register
         unitary_apply_func (Callable): Function that applies the desired controlled unitary to a
             provided circuit using provided control and target qubits
 
@@ -62,65 +78,82 @@ def quantum_phase_estimation(
 
 def run_quantum_phase_estimation(
     circuit: Circuit,
-    precision_qubits: List[int],
-    query_qubits: List[int],
+    precision_qubits: QubitSetInput,
+    query_qubits: QubitSetInput,
     device: Device,
-    items_to_keep: int = None,
     shots: int = 1000,
-) -> Dict[str, Any]:
+) -> GateModelQuantumTaskResult:
     """
     Function to run Quantum Phase Estimation algorithm and return measurement counts.
 
     Args:
         circuit (Circuit): Quantum Phase Estimation circuit
-        precision_qubits (List[int]): Qubits defining the precision register
-        query_qubits (List[int]) : Qubits defining the query register
+        precision_qubits (QubitSetInput): Qubits defining the precision register
+        query_qubits (QubitSetInput) : Qubits defining the query register
         device (Device): Braket device backend
-        items_to_keep (int) : Number of items to return, topmost measurement counts for precision
-            register (default to None which means all)
         shots (int) : Number of measurement shots (default is 1000).
             0 shots results in no measurement.
 
     Returns:
-        Dict[str, Any]: measurements and results from running Quantum Phase Estimation
+        GateModelQuantumTaskResult: measurements and results from running Quantum Phase Estimation
     """
 
     # Add desired results_types
     circuit.probability()
 
-    num_qubits = len(precision_qubits) + len(query_qubits)
-
     task = device.run(circuit, shots=shots)
 
     result = task.result()
 
-    metadata = result.task_metadata
+    return result
 
-    # get output probabilities (see result_types above)
-    probs_values = result.values[0]
 
-    # get measurement results
+def get_quantum_phase_estimation_results(
+    result: GateModelQuantumTaskResult,
+    precision_qubits: QubitSetInput,
+    query_qubits: QubitSetInput,
+    verbose: bool = False,
+) -> Dict[str, Any]:
+    """
+    Function to postprocess results returned by run_quantum_phase_estimation
+        and pretty print results
+
+    Args:
+        result (GateModelQuantumTaskResult): Results associated with quantum phase estimation run
+            as produced by run_quantum_phase_estimation
+        precision_qubits (QubitSetInput): Qubits defining the precision register
+        query_qubits (QubitSetInput) : Qubits defining the query register
+        verbose (bool) : If True, prints aggregate results (default is False)
+
+    Returns:
+        Dict[str, Any]: aggregate measurement results
+    """
+
+    metadata = result.task_metadata
+    probs_values = result.values[0]
     measurements = result.measurements
     measured_qubits = result.measured_qubits
     measurement_counts = result.measurement_counts
     measurement_probabilities = result.measurement_probabilities
 
+    num_qubits = len(precision_qubits) + len(query_qubits)
     format_bitstring = "{0:0" + str(num_qubits) + "b}"
     bitstring_keys = [format_bitstring.format(ii) for ii in range(2**num_qubits)]
 
     # quantum phase estimation postprocessing
     phases_decimal, precision_results_dict = _get_quantum_phase_estimation_phases(
-        measurement_counts, precision_qubits, items_to_keep
+        measurement_counts, precision_qubits
     )
 
     if not phases_decimal and not precision_results_dict:
         eigenvalues = None
+        eigenvalue_estimates = None
     else:
         eigenvalues = [np.exp(2 * np.pi * 1j * phase) for phase in phases_decimal]
+        eigenvalue_estimates = np.round(eigenvalues, 5)
 
     # aggregate results
-    out = {
-        "circuit": circuit,
+    aggregate_results = {
         "task_metadata": metadata,
         "measurements": measurements,
         "measured_qubits": measured_qubits,
@@ -131,9 +164,16 @@ def run_quantum_phase_estimation(
         "precision_results_dict": precision_results_dict,
         "phases_decimal": phases_decimal,
         "eigenvalues": eigenvalues,
+        "eigenvalue_estimates": eigenvalue_estimates,
     }
 
-    return out
+    if verbose:
+        print(f"Measurement counts: {measurement_counts}")
+        print(f"Results in precision register: {precision_results_dict}")
+        print(f"Quantum phase estimation phase estimates: {phases_decimal}")
+        print(f"Quantum phase estimation eigenvalue estimates: {eigenvalue_estimates}")
+
+    return aggregate_results
 
 
 def _binary_to_decimal(binary: str) -> float:
@@ -161,7 +201,7 @@ def _binary_to_decimal(binary: str) -> float:
 
 
 def _get_quantum_phase_estimation_phases(
-    measurement_counts: Counter, precision_qubits: List[int], items_to_keep: int = 1
+    measurement_counts: Counter, precision_qubits: QubitSetInput
 ) -> Tuple[List[float], Dict[str, int]]:
     """
     Get Quantum Phase Estimates phase estimate from measurement_counts for given number
@@ -169,10 +209,7 @@ def _get_quantum_phase_estimation_phases(
 
     Args:
         measurement_counts (Counter) : measurement results from a device run
-        precision_qubits (List[int]) : List of qubits corresponding to precision_qubits. Currently
-            assumed to be a list of integers corresponding to the indices of the qubits.
-        items_to_keep (int) : number of items to return (topmost measurement counts for
-            precision register)
+        precision_qubits (QubitSetInput): Qubits defining the precision register
 
     Returns:
         Tuple[List[float], Dict[str, int]]: decimal phase estimates, precision results
@@ -205,57 +242,23 @@ def _get_quantum_phase_estimation_phases(
 
     # Get topmost values only
     c = Counter(precision_results_dict)
-    topmost = c.most_common(items_to_keep)
+    topmost = c.most_common(None)
     # get decimal phases from bitstrings for topmost bitstrings
     phases_decimal = [_binary_to_decimal(item[0]) for item in topmost]
 
     return phases_decimal, precision_results_dict
 
 
-def get_quantum_phase_estimation_results(results: Dict[str, Any]) -> None:
-    """
-    Function to postprocess dictionary returned by run_quantum_phase_estimation
-        and pretty print results
-
-    Args:
-        results (Dict[str, Any]): Results associated with quantum phase estimation run as produced
-            by run_quantum_phase_estimation
-    """
-
-    # unpack results
-    circuit = results["circuit"]
-    measurement_counts = results["measurement_counts"]
-    precision_results_dict = results["precision_results_dict"]
-    phases_decimal = results["phases_decimal"]
-    eigenvalues = results["eigenvalues"]
-
-    # print the circuit
-    print(f"Printing circuit: {circuit}")
-
-    # print measurement results
-    print(f"Measurement counts: {measurement_counts}")
-
-    if not eigenvalues:
-        eigenvalue_estimates = None
-    else:
-        eigenvalue_estimates = np.round(eigenvalues, 5)
-
-    # print results
-    print(f"Results in precision register: {precision_results_dict}")
-    print(f"Quantum phase estimation phase estimates: {phases_decimal}")
-    print(f"Quantum phase estimation eigenvalue estimates: {eigenvalue_estimates}")
-
-
 # TODO: Add to qft module once available
 # inverse QFT
 @circuit.subroutine(register=True)
-def inverse_qft(qubits: List[int]) -> Circuit:
+def inverse_qft(qubits: QubitSetInput) -> Circuit:
     """
     Construct a circuit object corresponding to the inverse Quantum Fourier Transform (QFT)
     algorithm, applied to the argument qubits.  Does not use recursion to generate the circuit.
 
     Args:
-        qubits (List[int]): Qubits on which to apply the inverse Quantum Fourier Transform
+        qubits (QubitSetInput): Qubits on which to apply the inverse Quantum Fourier Transform
 
     Returns:
         Circuit: Circuit object that implements the inverse Quantum Fourier Transform algorithm


Test patch:
diff --git a/test/unit_tests/braket/experimental/algorithms/qaoa/test_qaoa.py b/test/unit_tests/braket/experimental/algorithms/qaoa/test_qaoa.py
index 13a718be..2a8d5316 100644
--- a/test/unit_tests/braket/experimental/algorithms/qaoa/test_qaoa.py
+++ b/test/unit_tests/braket/experimental/algorithms/qaoa/test_qaoa.py
@@ -12,59 +12,34 @@
 # language governing permissions and limitations under the License.
 
 import numpy as np
-from braket.circuits import circuit
+from braket.circuits import Circuit, FreeParameter, Observable
 from braket.devices import LocalSimulator
 
-from braket.experimental.algorithms.qaoa import qaoa
-
-gammas = [0.1, 0.2]
-betas = [0.3, 0.4]
-params = gammas + betas
-J_sub = np.array([[0, 1], [0, 0]])
-N = J_sub.shape[0]
-bitstring_init = -1 * np.ones([N])
-energy_init = np.dot(bitstring_init, np.dot(J_sub, bitstring_init))
-
-
-@circuit.subroutine(register=True)
-def qaoa_circuit():
-
-    circ = qaoa.qaoa(params, LocalSimulator(), N, J_sub)
-    return circ
+from braket.experimental.algorithms.qaoa import evaluate_circuit, evaluate_loss, qaoa
 
 
 def test_qaoa():
-    circ = qaoa_circuit()
-
-    assert circ.depth == 6
+    n_qubits = 2
+    n_layers = 1
+    coupling_matrix = np.diag(np.ones(n_qubits - 1), 1)
+    circ = qaoa(n_qubits, n_layers, coupling_matrix)
     assert circ.qubit_count == 2
 
 
-def test_qaoa_optimization():
-    tracker = {
-        "count": 1,  # Elapsed optimization steps
-        "optimal_energy": energy_init,  # Global optimal energy
-        "opt_energies": [],  # Optimal energy at each step
-        "global_energies": [],  # Global optimal energy at each step
-        "optimal_bitstring": bitstring_init,  # Global optimal bitstring
-        "opt_bitstrings": [],  # Optimal bitstring at each step
-        "costs": [],  # Cost (average energy) at each step
-        "res": None,  # Quantum result object
-        "params": [],  # Track parameters
-    }
-    options = {"disp": True, "maxiter": 500}
+def test_qaoa_evaluate_circuit():
+    param = FreeParameter("theta")
+    circ = Circuit().rx(0, param).probability()
+    device = LocalSimulator()
+    shots = 0
+    values = [0]
+    task = evaluate_circuit(device, circ, values, shots)
+    result = task.result().values[0]
+    assert np.isclose(result[0], 1)
 
-    result, tracker = qaoa.run_qaoa(
-        device=LocalSimulator(),
-        options=options,
-        p=3,
-        ising=J_sub,
-        n_qubits=N,
-        n_shots=10,
-        opt_method="Powell",
-        tracker=tracker,
-    )
 
-    assert result.fun > 0.00 or result.fun < 0.00
-    assert len(result.x) > 0
-    assert tracker["optimal_energy"] > 0.00 or tracker["optimal_energy"] < 0.00
+def test_qaoa_evaluate_loss():
+    circ = Circuit().i(0)
+    circ.expectation(observable=Observable.Z(), target=0)
+    task = LocalSimulator().run(circ, shots=0)
+    js = [1]
+    assert np.isclose(evaluate_loss(task, js), 1)
diff --git a/test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py b/test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py
index 838976f1..f40d7f36 100644
--- a/test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py
+++ b/test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py
@@ -11,21 +11,15 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 
-from braket.circuits import Circuit, circuit
+from braket.circuits import Circuit
 from braket.devices import LocalSimulator
 
 from braket.experimental.algorithms.quantum_phase_estimation import quantum_phase_estimation as qpe
 
 
-# controlled unitary gate definition
-@circuit.subroutine(register=True)
-def qpe_cnot_unitary(control_qubit, target_qubits):
-    return Circuit().cnot(control=control_qubit, target=target_qubits)
-
-
 # controlled unitary apply function
 def controlled_unitary_apply_cnot_func(qpe_circ, control_qubit, query_qubits):
-    qpe_circ.qpe_cnot_unitary(control_qubit, query_qubits)
+    qpe_circ.cnot(control_qubit, query_qubits)
 
 
 # CNOT controlled unitary with 2 precision qubits, and H gate query prep
@@ -51,16 +45,16 @@ def test_cnot_qpe_run_2_precision_qubits():
         qpe_circ, precision_qubits, query_qubits, LocalSimulator()
     )
 
-    print(
-        f"test_cnot_qpe_run_2_precision_qubits Results: \
-      {qpe.get_quantum_phase_estimation_results(result)}"
+    agg_result = qpe.get_quantum_phase_estimation_results(
+        result, precision_qubits, query_qubits, verbose=True
     )
 
     # validate excepted QPE output
-    assert result["measurement_counts"]["001"] > 300
-    assert result["measurement_counts"]["000"] > 300
-    assert len(result["measurement_counts"]) == 2
-    assert result["phases_decimal"] == [0.0]
+    assert agg_result["measurement_counts"]["001"] > 300
+    assert agg_result["measurement_counts"]["000"] > 300
+    assert len(agg_result["measurement_counts"]) == 2
+    assert agg_result["phases_decimal"] == [0.0]
+    assert set(agg_result["eigenvalue_estimates"]) == {1.0 + 0.0j}
 
 
 # 0 shots should result in no measurement
@@ -77,6 +71,7 @@ def test_0_shots():
         precision_qubits, query_qubits, controlled_unitary_apply_cnot_func
     )
 
+    print("Circuit: ", qpe_circ)
     assert len(qpe_circ.instructions) == 8
     assert qpe_circ.depth == 6
     assert qpe_circ.instructions[3].ascii_symbols == ("C", "X")
@@ -86,14 +81,13 @@ def test_0_shots():
         qpe_circ, precision_qubits, query_qubits, LocalSimulator(), shots=0
     )
 
-    print(
-        f"test_0_shots Results: \
-       {qpe.get_quantum_phase_estimation_results(result)}"
+    agg_result = qpe.get_quantum_phase_estimation_results(
+        result, precision_qubits, query_qubits, verbose=True
     )
 
     # validate excepted QPE output
-    assert not result["measurement_counts"]
-    assert not result["phases_decimal"]
+    assert not agg_result["measurement_counts"]
+    assert not agg_result["phases_decimal"]
 
 
 # CNOT controlled unitary with 3 precision qubits, and H gate query prep
@@ -110,21 +104,22 @@ def test_cnot_qpe_run_3_precision_qubits():
         precision_qubits, query_qubits, controlled_unitary_apply_cnot_func
     )
 
+    print("Circuit: ", qpe_circ)
     # run QPE
     result = qpe.run_quantum_phase_estimation(
         qpe_circ, precision_qubits, query_qubits, LocalSimulator()
     )
 
-    print(
-        f"test_cnot_qpe_run_3_precision_qubits Results: \
-       {qpe.get_quantum_phase_estimation_results(result)}"
+    agg_result = qpe.get_quantum_phase_estimation_results(
+        result, precision_qubits, query_qubits, verbose=True
     )
 
     # validate excepted QPE output
-    assert result["measurement_counts"]["0001"] > 300
-    assert result["measurement_counts"]["0000"] > 300
-    assert len(result["measurement_counts"]) == 2
-    assert result["phases_decimal"] == [0.0]
+    assert agg_result["measurement_counts"]["0001"] > 300
+    assert agg_result["measurement_counts"]["0000"] > 300
+    assert len(agg_result["measurement_counts"]) == 2
+    assert agg_result["phases_decimal"] == [0.0]
+    assert set(agg_result["eigenvalue_estimates"]) == {1.0 + 0.0j}
 
 
 # CNOT controlled unitary with 2 precision qubits, and HX gate query prep
@@ -141,21 +136,22 @@ def test_cnot_qpe_run_HX_eigenstate():
         precision_qubits, query_qubits, controlled_unitary_apply_cnot_func
     )
 
+    print("Circuit: ", qpe_circ)
     # run QPE
     result = qpe.run_quantum_phase_estimation(
         qpe_circ, precision_qubits, query_qubits, LocalSimulator()
     )
 
-    print(
-        f"test_cnot_qpe_run_HX_eigenstate Results: \
-       {qpe.get_quantum_phase_estimation_results(result)}"
+    agg_result = qpe.get_quantum_phase_estimation_results(
+        result, precision_qubits, query_qubits, verbose=True
     )
 
     # validate excepted QPE output
-    assert result["measurement_counts"]["101"] > 300
-    assert result["measurement_counts"]["100"] > 300
-    assert len(result["measurement_counts"]) == 2
-    assert result["phases_decimal"] == [0.5]
+    assert agg_result["measurement_counts"]["101"] > 300
+    assert agg_result["measurement_counts"]["100"] > 300
+    assert len(agg_result["measurement_counts"]) == 2
+    assert agg_result["phases_decimal"] == [0.5]
+    assert set(agg_result["eigenvalue_estimates"]) == {-1.0 + 0.0j}
 
 
 # CNOT controlled unitary with 2 precision qubits, and X gate query prep
@@ -172,23 +168,24 @@ def test_cnot_qpe_run_X_eigenstate():
         precision_qubits, query_qubits, controlled_unitary_apply_cnot_func
     )
 
+    print("Circuit: ", qpe_circ)
     # run QPE
     result = qpe.run_quantum_phase_estimation(
         qpe_circ, precision_qubits, query_qubits, LocalSimulator()
     )
 
-    print(
-        f"test_cnot_qpe_run_HX_eigenstate Results: \
-       {qpe.get_quantum_phase_estimation_results(result)}"
+    agg_result = qpe.get_quantum_phase_estimation_results(
+        result, precision_qubits, query_qubits, verbose=True
     )
 
     # validate excepted QPE output
-    assert result["measurement_counts"]["000"] > 100
-    assert result["measurement_counts"]["100"] > 100
-    assert result["measurement_counts"]["101"] > 100
-    assert result["measurement_counts"]["001"] > 100
-    assert len(result["measurement_counts"]) == 4
-    assert set(result["phases_decimal"]) == {0.0, 0.5}
+    assert agg_result["measurement_counts"]["000"] > 100
+    assert agg_result["measurement_counts"]["100"] > 100
+    assert agg_result["measurement_counts"]["101"] > 100
+    assert agg_result["measurement_counts"]["001"] > 100
+    assert len(agg_result["measurement_counts"]) == 4
+    assert set(agg_result["phases_decimal"]) == {0.0, 0.5}
+    assert set(agg_result["eigenvalue_estimates"]) == {1.0 + 0.0j, -1.0 + 0.0j}
 
 
 # inverse QFT circuit validation with 2 input qubits