MaxCutQAOA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Max-Cut QAOA on QCS\n",
    "\n",
    "In this notebook, we will walk through how to run the **Max-Cut QAOA** algorithm on the QPU and QVM. With **Parametric Compilation** and **Active Reset** enabled in QCS, we are able to achieve a **speedup of more than an order of magnitude** over web API offerings. The example below runs in less than a minute, as compared to more than 25 minutes using a web API. \n",
    "\n",
    "**NOTE**: This notebook depends on `pyquil >= 2.3.0`, `matplotlib`, and `tqdm`, which come preinstalled on all new QMIs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List, Tuple\n",
    "\n",
    "import networkx as nx\n",
    "import numpy as np\n",
    "from pyquil import get_qc, Program"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate Random Weighted Graph\n",
    "\n",
    "Given a list of edges, we generate a graph with random edge weights in the range \\[-1,1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_ising_graph(edges: List[Tuple[int, int]], seed: int) -> nx.Graph:\n",
    "    np.random.seed(seed)\n",
    "    graph = nx.from_edgelist(edges)\n",
    "    weights:  np.ndarray = 2.0 * np.random.rand(graph.number_of_edges()) - 1.0\n",
    "    weights /= np.linalg.norm(weights)\n",
    "    nx.set_edge_attributes(graph, {e: {'w': w} for e, w in zip(graph.edges, weights)})\n",
    "    return graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute Bitstring Cut Weight\n",
    "\n",
    "Given a graph and a bitstring, compute the [cut weight](https://en.wikipedia.org/wiki/Maximum_cut), which determines the cost of the particular bitstring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bitstring_cut_weight(b: List[List[int]], graph: nx.Graph) -> dict:\n",
    "    cost = 0\n",
    "    inverse_map = {qubit: idx for idx, qubit in enumerate(list(graph.nodes))}\n",
    "    for q0, q1 in graph.edges():\n",
    "        cost += graph.get_edge_data(q0, q1)['w'] * (-1) ** int(b[inverse_map[q0]] == b[inverse_map[q1]])\n",
    "    return cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create QAOA Max-Cut Program\n",
    "\n",
    "For our problem graph, we generate the [QAOA](https://arxiv.org/abs/1411.4028) cost and driver unitaries:\n",
    "\n",
    "$$H_c = \\sum_{i,j} w_{i,j} \\sigma_i^z \\sigma_j^z \\qquad H_d = \\sum_i \\sigma_i^x$$\n",
    "\n",
    "From these, we create our Quil program, using the [`exponential_map`](http://docs.rigetti.com/en/stable/advanced_usage.html#pauli-operator-algebra) function in pyQuil. As in the previous notebooks, we use the `RESET` instruction to enable **Active Reset** in our program, and declare our \"beta\" (β) and \"gamma\" (𝛾) values as parameters to leverage the **Parametric Compilation** feature. At the end of the program, we measure all qubits into the readout registers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyquil.gates import H, MEASURE, RESET\n",
    "from pyquil.paulis import exponential_map, PauliSum, sX, sZ\n",
    "\n",
    "def maxcut_qaoa_program(graph: nx.Graph) -> Program:\n",
    "    cost_ham = PauliSum([sZ(i) * sZ(j) * graph.get_edge_data(i, j)['w'] for i, j in graph.edges])\n",
    "    driver_ham = PauliSum([sX(i) for i in graph.nodes])\n",
    "\n",
    "    p = Program(RESET())\n",
    "    beta = p.declare('beta', 'REAL')\n",
    "    gamma = p.declare('gamma', 'REAL')\n",
    "    ro = p.declare('ro', 'BIT', len(graph.nodes))\n",
    "\n",
    "    p.inst(H(qubit) for qubit in list(graph.nodes))\n",
    "    p.inst(exponential_map(term)(gamma) for term in cost_ham)\n",
    "    p.inst(exponential_map(term)(beta) for term in driver_ham)\n",
    "\n",
    "    p.inst(MEASURE(qubit, ro[idx]) for idx, qubit in enumerate(list(graph.nodes)))\n",
    "    return p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run the Landscape\n",
    "\n",
    "Given a list of edges and a QPU- or QVM-backed `QuantumComputer` object, generate the Max-Cut QAOA program, compile it to a parametric binary, and rapidly iterate through the landscape of (β, 𝛾). For each job, we compute the average cost, which will become the $z$-axis of the landscape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "from tqdm import tqdm\n",
    "from pyquil.api import QPU, QuantumComputer\n",
    "\n",
    "def run_maxcut_qaoa_landscape(qc: QuantumComputer, edges: List[Tuple[int, int]], width: int,\n",
    "                              shots: int = 1000, seed: int = 19120623) -> np.ndarray:\n",
    "    qc.reset()\n",
    "    graph = generate_ising_graph(edges, seed)\n",
    "    p = maxcut_qaoa_program(graph)\n",
    "    p.wrap_in_numshots_loop(shots)\n",
    "    binary = qc.compile(p) if isinstance(qc.qam, QPU) else p\n",
    "\n",
    "    costs = []\n",
    "    angle_range = np.linspace(0, np.pi, width)\n",
    "    landscape = list(itertools.product(angle_range, angle_range))\n",
    "    for beta, gamma in tqdm(landscape):\n",
    "        bitstrings = qc.run(binary, memory_map={'beta': [beta], 'gamma': [gamma]})\n",
    "        costs.append(np.mean([bitstring_cut_weight(list(b), graph) for b in bitstrings]))\n",
    "\n",
    "    return np.array(costs).reshape(width, width)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot the Landscape\n",
    "\n",
    "Given results from running QAOA, plot the landscape and the max cost value (shown as a red dot)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot_landscape(landscape: np.ndarray, *, device: str, edges: List[Tuple[int, int]],\n",
    "                   width: int, shots: int):\n",
    "    max_x, max_y = (np.argmax(landscape) % width, np.argmax(landscape) // width)\n",
    "    plt.imshow(landscape, extent=[0, np.pi, np.pi, 0])\n",
    "    plt.plot((max_x + 0.5) * np.pi / width, (max_y + 0.5) * np.pi / width, 'ro')\n",
    "    plt.colorbar()\n",
    "    plt.xlabel('gamma (radians)')\n",
    "    plt.ylabel('beta (radians)')\n",
    "    plt.title(f'Max-Cut QAOA Landscape\\n{device}\\n{edges}\\nwidth = {width} shots = {shots}')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Device Information\n",
    "\n",
    "As in the **Parametric Compilation** and **Active Qubit Reset** notebooks, we must start by setting up the device or devices that we want to run on. In this notebook, we want to execute our algorithm on both the QPU and the QVM, and compare our results. We will use the `Aspen-1-8Q-B` lattice for the [QPU](https://www.rigetti.com/qpu) and a generic `8q-qvm` for our simulator. The `qvm` is our Quantum Virtual Machine, and is also available as part of the downloadable [Forest SDK](https://www.rigetti.com/forest). \n",
    "\n",
    "**NOTE**: When running this notebook, you may need to edit the entries to `get_qc` in the following cell and the `edges` entry in the cell after, depending on what QPU lattice you have booked. And remember that this code will only work from within the QMI!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "qpu = get_qc('Aspen-1-8Q-B')  # edit as necessary\n",
    "qvm = get_qc('8q-qvm')  # edit as necessary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Landscape Information\n",
    "\n",
    "In addition to providing the device that we want to run on, we need to provide some more information to build our QAOA landscape. The `width` parameter sets the resolution of the landscape—the width squared is the number of jobs we will run. The `shots` parameter specifies how many repetitions to perform for each (β, 𝛾) angle pair. The `seed` parameter is used when randomly generating the edge weights of our graph, and we can reproduce the same graph by keeping the seed constant. Finally, the `edges` specify the qubits and the topology of the graph that we will run QAOA on. For this example, we use a line graph, but you can create more interesting topologies by changing the edge list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "width = 25\n",
    "shots = 1000\n",
    "seed = 19120623\n",
    "edges = [(13, 14), (14, 15)]  # edit as necessary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run and Plot on QPU and QVM\n",
    "\n",
    "We run the QAOA algorithm on the QPU and the QVM, comparing the max value of each landscape, which should be nearly the same. Small differences can be attributed to gate infidelity and decoherence, and larger ones can come from the presence of more than one \"peak\" in the landscape (as seen by the presence of multiple yellow blobs). We can also see that for this 3Q instance that the QVM outperforms the QPU in terms of total execution time. However, for larger numbers of qubits, the QPU quickly becomes much more efficient at completing the grid search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 625/625 [01:09<00:00,  9.03it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU4AAAFDCAYAAABVzee3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJztnXm4XVV5/z/fO2ROSEgYQgiDSikgEBQRqyIiVrAKVNBClcHCj2JFa4sDSqVItUXbSkuxIhYEBEGKiJGCCEJAVJCAyCiDjJEwJCEh480d3t8fa52wc3LuXuvknnPvOTfv53n2c8/Za+213r3PPe9Zw7u+S2aG4ziOk0/HSBvgOI7TbrjjdBzHqRN3nI7jOHXijtNxHKdO3HE6juPUiTtOx3GcOnHH6TiApKckHTjSdjjtgTvOOohfrrWSZlSdv1eSSdqhSfXuI+k6SUslLZH0a0kfzbz2IklfTuSRpM9IekzSaknPSPpnSWNq5D0j3us+NdK2lXSZpMWSVkY73zdIfU9IeijDfndoTsvhjrN+ngSOqryRtDswvlmVSXoLcDNwK/A6YDrwMeDgBlZzDnAicAwwOZZ9IHBFlS0CjgaWAMdWpW0O3A6sBXYDZgBnA9+TdERVffsBWwKvkfSmBt6H4wwPZuZH5gE8BfwDcFfh3L8BpwEG7BDP/RnwG+AV4FngjEL+vwCeAKbE9wcDzwNbDFLn7cA3Smw6Dri96pwRnOyJQC/Bma0Aflzj+p2AfmCfqvOzgR7gHYVz+wGrgY8Ai4ExhbR/Ah4AOqrK+RzwNKDCuQuBy4CrgXMznvmBNc5PA64FXgJejq+3LaTPizb9AlgO/BSYUUg/Otq1OH5+6+oB9gHmx8/vBeDrheveBvwSWBo/2+MyPvMd4mdyIvAcsBA4pZDeAZwK/D7acyWw+Uj/v/tR8n850ga001H5cgGPALsAnfFLsn2V49wf2D1+IfaIX77DCuVcBlxEaD0+B7xvkPomRKf2zhKbjmMQxxlfXwR8ueT6k4CnB0m7FfhK4f0F8UvdHb/gHyik3QF8qUYZO0Z7di7c0yvAe4HDgUUUHPBgz7zG+enx+gmEVvL/AtcU0udFR/RHhB7BPOCsmLYr4YdkP2As8HWgr+A4fwUcHV9PAvaNr7cjOOGj4jOYDsxJfea86jgvBybGfC8V6vtUfH7bRnu+BVw+0v/vfgx+eFd94/guoVv7buB3wB+KiWY2z8zuN7MBM7uP8IV5RyHLx4EDCF/mH5vZtYPUM43wRVzYWPPXY0ZJ+QuBLQAkTQA+CHzPzHqBq1i/uz5YOQsL6QAfILRkf0poJXYRWmt1YWaLzewHZrbKzJYDX2H9ZwzwHTN71MxWExz+nHj+COBaM7vNzHqALwIDhet6gddJmmFmK8zsjnj+w8BNZna5mfVGG+6N9qQ+cwg/LCvN7H7gO7w65PPXwGlmtiDacwZwhKSuep+LMzy449w4vgv8JaG1d0l1oqQ3S7pF0kuSlhFadesmlMxsKaGF9Hrg3wvXfUHSinicR+iCDgAzm3gvi0rKn0loGQH8OaFVdl18fxlwsKQtEuXMLKRDcLZXmllfdBJXUzVemoOkCZK+JelpSa8AtwFTJXUWsj1feL2K0HoE2IbQUwDAzFYSWtAVjie0VH8n6a7CBNdsQiu2lj2ln3nk2cLrp6MdEHosP4yTf0uBhwk9ja1KHoEzgrjj3AjM7GnCJNF7CV/8ar4HzAVmm9lmwHmAKomS5gB/RWiVnFMo95/NbFI8TjKzVYRu4+El5qwkdFcrZW9dbW7idm4GZlfPkkuaDexL6K5DcG6TgGckPU9w/N282mq6CThcUvX/1IcIDuNRSdsSWtofkfR8LOcI4L3VkQoZnALsDLzZzKYQut1QeM4lLCQ4wXBBaE1Pr7w3s8fM7CjCBNZXgaskTYz38dpByiz9zCOzC6+3IwzTEMs92MymFo5xZvYHnJbEHefGczxwQGytVDMZWGJma6JD+stKgqRxwKXAF4CPArMk/U1JPZ8FjovhQtNjGXtKqsx4/xbYTdKcWPYZVde/ALxmsMLN7FHCl/wySftK6pS0G/ADwiTITZJmAe8C3kfo7s4B9iQ4lUpr8WxgCnCBpK0ljZN0FGHi5TNmZoQJmUcJDq9Szh8BCyhEKtSgO5ZXOboIz3g1sDTO6P9jyfXVXAW8T9LbYsjVmRS+C5I+ImkLMxsgTAJBaAFeBhwo6UOSuiRNjz+CUPKZF/hibCnvRvjsvx/Pnwd8RdL2sf4tJB1ax/04w81ID7K208HgExVdrD85dAShK7acMI53LnBpTDsb+Enh2j0J4T07ldS7D3A9sCzmvRM4ppB+GqEr/Cxhxrs4ObQTcC/BAVwzSPkdhNnvxwnjj0ZoUW4W008F7q5x3TaE8cDXx/fbEVrRSwgt4buAQwv5fwd8okY5nwXmlzxzqzq+HOueR5jkeZQwTmhAV7xuHnBCoZzjKEyiERz+M9SeVb8UeDGW/SDrT+y9PT7/yuz5sRmf+Q6sP6v+PPDZquf/94RJx+WE4YB/Hun/dz8GPxQ/OMdZh6QzgcOA/SyMxzpDIC6MeBLoNrO+kbXGaQQ+a+dsgJmdLulFwhjnT0baHsdpNbzF6ThNxlucow93nI7jOHXis+qO4zh14o7TcRynTtxxthCS5kl6WdLYkbaliKQxkq6KEm8maf+Maz4k6WFJyyU9JOmwqvRdJc2VtCzmuVnSvoky50laE1dWLZN0W1SncpxhxR1nixAnEN5OiPc7ZESNqc3thBjR51MZY8D8pYTYxCnAZwjyclvG9NcSVIvuJ4iAbANcA9xYS+ezipPNbBJhpc88wvJXxxlW3HG2DscQFHIuorB2W9J7Y4ttuaQ/SPp0PL+/pAVxffui2Br8cOG6sZL+TUGU+AVJ50kaX3XtKZJelLRQJcLIZrbWzP7DzG4nrKBJsS2w1Myut8D/EQLiK8sVzwB+ZWanmdkSM1tuZucQnO1Xcx5WnJ2+gqB0NCiSjo7r2RdLOi0+pwMlbaMg2rx5Ie9e8Vl2SzpO0i8knR3XkD8h6U/i+Wfjc6t7jb0zOnDH2TocQ1jSdxnwHkkVgYcLgL82s8kEUZCbC9dsTRCSmEVwtudL2jmmfZWwnHEOQZtzFnB61bWbxfPHA9+QNK1B9zIfeFjSIXEJ52GEFUn3xfR3E1YmVXMl8Pa4dLSUuFTyw4Qfm8Hy7Ap8k7DUcxtCK3VbADN7jg11AP4SuMqC+hPAm6PN0wlr0a8A3kR4nh8BzpU0CWfTY6SXLvmxThy3lyi0S1ia+Hfx9TOE5YRTqq7Zn6BWNLFw7kqCRJqILbxC2luAJwvXriYuT4znXiTqTiZsXQDsn5HveMKSxT6CMtGfFdL6gINqXPPHhKGKbQYpc14saylBnHkZ8K4SG04Hrii8nxivqyytPAG4Ob4WYQnlfvH9ccBjhWt3j7ZtVTi3mKjH6cemdXiLszU4FvipmVWk177Hq931wwkqTE9LulVhK40KL9v6IiMVqbItCIpJd+tVqbKfxPMVFtv6wdirgEmSttOr0nYrUobXyq+wR9DXCA56DEGX8n8KghhlEnQGLIpDC5Vyv1DI80kzmwqMI4iOXCVpj1jvisKxHWn5uKuAt0jahqCuZMDPC+kvFF6vjmVUn/MW5yaIL7kcYeK444eATgWZNQgq4FMl7WlmdwGHSuoGTia0KivyZNMkTSw4z+0I21csInypd7M6pcnM7BnqcAaD5J8D3GZm8+P7uyTdSVDPv5cgQfdBgphvkQ8Bd5jZWoKe5Ukl9Q4AP5f0OPCnwH0WJo3WIWkhQam/8r5aPm6ppJ/GenchqK77ihAnibc4R57DCBMuu/Kq1NouhJbPcZI+LGkzC+Nur7Dh5MyXYrjQ2wktsP+NTuXbwNmFmexZkt6zsUbGyabK2OMYBXm3wbQv7yKMVc6J1+5FiBiojHF+CfgTSV+RtLmkyZI+QZBay5aHi63vXQkKRrUolY+LfI8wvnx4fO04SdxxjjzHErZ4eMbMnq8cBFmyYwnO5CkFlfOTCJMSFZ4nqMQ/R5hUOsnMfhfTKjJxd8RrbyLoYG4sjxBasbOAG+Lr7WtlNLNbCTPnV0laTtD2/Gcz+2lMf4wwrrsnQc5tKWFjtT83sxsTdpxbGBb4LvAPZnb9IHY8SNim5HsE8eKXCWO0ReYSpPdeMLPfJup2HMDXqrctCkHol5rZtiNty1BRUIa/A/hHM7ugyXU9RdDpvKmZ9TijG29xOiOOmS0gbJM808N7nHbAJ4eclsDCzo/3j7QdjpODd9Udx3HqxLvqjuM4deKOs0VQUB1aKekrVed/EcN5WhZJn5R0Vp3XjFVYg1+9nXFLIelqSQcV3o+Ns/q9kr48krY5I4c7ztZiTzM7rfJG0vuB5Wb2m/j+9ZJuiEIUG4yxSLo0Cna8IulRSSfkVizpnZJuUZBre6ok3zuiky86jfMJe6VvmVsfYcfH22Lo1VDrL0XSyZLmS+qRdFFV2g6xvOKqoy8WspwFrPsxM7OeGGh/WW79zujDHWdrcxLry6b1ElYOHT9I/n8hbFE8hSBN92VJb8ysayVwIUECriZx9dJ/ErbHXYeZrSFsX3xMZl0Q1t8X722j68/gOcKWwheW5JlqZpPi8U+Vk2b2a2CKpL3rrNMZxbjjbFHiSpcDgFsr58zskRjnWHOljJk9aGY9lbfxeG2tvDWu/bWZfRd4oiTbKcBPCSIk1cwD/iynrriO/LUUHGAD6h8UM7vazK5h/XXq9TCPzHtzNg3ccbYuOwEDMcYxG0n/LWkVwbksBK5rhDGStgf+irBssRYPE1YC5bA78ITVseNjRv1D5WkFjdLvSJpRlVbPvTmbAO44W5epwPJ6LzKzvwEmE9aGX03QwWwE5wBfNLPBFJOWE/Q9c9iYe0vVv7EsImhsbg+8kfDsqscvlxNsdhzAHWcr8zLhS1w3ZtZvQa19W+BjQzUkTlJNNrPvl2SbTNDHzKGue8usf6MwsxVmNt/M+qJk3MnAn0qaUsg2mbCe3nEAXznUyjwGSNKseqXhCnSROcaZ4F3A3gXZu82Afkm7m9mh8dwuQK5Ixn3AayR1ZXbXc+pvFJVohaLyUz335mwCeIuzRYkycjcRRICB4EWjtNuY+H6c4o6YkraUdKSkSQrbVbwHOIrCVhsq2aFSUkcsuztWNS5OUEFQla9swzGHoCj0bYJyU4V3EGbWK+VdVB36U7i3BYQfhn0K+Te6foU9lAZdAiepK5bdSdA9HSepK6a9WdLOsf7phCGBeWZWbD2vd2+O446ztfkWYb+cCtsT5Nwqs+qrCXJvEFpKHyPIpr0M/BvwKTP7EaxTIFrB4OvB94vlXUcQRF5NmMHGwmZqRcm71cBKM1sSyx5HUKm/uFDebMJOlrn3ttH1x7p+VVLXP8RrTiXI8q2O5wBeQ1DHX04Qge4h/OAQ7+1Nsa5fl5TvbGL4WvUWQdIawpf2HDP7YuH87cAnKkHwQyj/IwRF+M8PzdKaZX8CmG1mn43vxxC6tnvYqxufVV8zFvgNYc+ghUOs/38IAs43DKWcQcr+AXCBmV0X348lbKnRDXzNzL7U6Dqd1scdp+M4Tp14V91xHKdO3HE6juPUiTtOx3GcOnHHOQxExZ3XDJJ2XJwAGuza/SXVteyyVZF0hqRLR9oOxxkq7jiHgai4UyZesY4Ya/m6ZttUVedYSRdIelrSckm/kXRwIT0lvTYcNl5Uj5Rcg+r8kKRfSlolaV6N9DmS7o7pdytuhxzTJOmrkhbH42vSq9spl13rtD7uOB0IK4yeJQR6b0YIOL9S0g5V+WpKr41ilgD/QdDkXI8YcvUj4FJgGiGG9UeFoP0TgcMI4iB7EPa8/+vMa50Wxx3nRiLpo5J+XHj/uKQrC++frbQiiq1ISdMlzVUQG/41hSWRkm6LL38bW3V/UUg7RdKLCkLFxRU7Q8bMVprZGWb2lJkNmNm1wJME0Yu6kfQ5SX+IrddHJL2rkDxG0iUx7UEVdC4l7SJpnqSlMe2QeP5E4MPAZ+Nz+XFGPUPGzG4ysysJep7V7E/4wfmPKG58DmGZ5gEx/Vjg381sQVwy++/AcZnXOi2OO86N51bg7XGp3kxCQPRbAeJ45iTCmuxqvgGsAWYSZNL+qpJgZvvFl3vGVl1F1GJrQktwFkHE+BuSptUySkFWbukgRy17apWxFWGJY7Xu59MaXHqtcu3OBKGMN5nZZOA9wFOFLIcAVxDUhuYC58bruoEfE1YLbQl8ArhM0s5mdj5Bsehr8bm8P6Oeok2nljyTjRXv2A24z9YPhL4vnq+kF9e3/7Yqrexap8Vxx7mRxDHL5YS10+8AbgD+IOmP4/ufm9lA8RpJncDhwOmxlfcA6y9THIxe4Ewz640rWFYAOw9i19+Y2dRBjj1SFUUHdhlwsZlVBINzpNcq9ANjgV0ldcdW7O8L6beb2XVm1k9QgK/oXO5L+LE5y8zWmtnNwLUUlj/WWU/xmZxV8kw2Vi5uEhuqQS3jVdWn6vRlwKQ4zpm61mlx3HEOjVsJ3a794ut5BKf5DgrK7QW24NXxxApPZ9SzuEpFaBXhy9dQJHUQnNlaQmsOyJZeq+R9HPgUcAbwoqQrJG1TyPJ84fUqoCK4sQ3wbNWPzdOEVvYGZNTTbFYA1fc/hVd1RqvTpwArYiszda3T4rjjHBoVx/n2+PpWyh3nS0AfQZSiwnaNNEjSeVWz38Wj5pYb8ToBFwBbAYcPtsY8Ukt67dVEs++Z2dsILVQDvpph+nPA7Oi8K2wHVCT1NlgbnFuPpC+UPJONFUZ+ENijOFNOmAR6sJBeVI3fsyqt7FqnxXHHOTRuBd4JjI9SaT8HDgKmEwQs1iN2T68GzpA0QdKuhEmEIi8QFHs2CjM7qTDzXX2UjaF9k6A7+X4zW11MUJ70WiXvzpIOUBDDWENQIurPMP1OwoZtn5XUrSB/937CeChUPZd66jGzfy55JoO23BXk+cYRegkdCnJ03TF5XqzvkwrhXJUWekXG7xLg7yXNii3hU4CLMq91Wh0z82MIB2Ffn+8U3s8Hrq/KY8Dr4ustCGN3rwC/Bv6JMO5XyXtSLHMp8CFCi3ZBVXlPAQc28B4qLbY1hG5k5fhwTD+KMMu+Mtp2CbD1IGXtEe9rOSGc51pgm5h2BnBpIe8Osd6u+H43wo/RMuAh4M8LeXcC7o3P5Zqyehr4XI7j1U3vKsdFhfS9gLsJTvseYK9CmoCvRduWxNfKudaP1j9cHclxHKdOvKvuOI5TJ011nJIOioHJj0s6tUb6WEnfj+l3asOVKo7jOC1H0xxnjFn8BnAwsCtwVJwMKXI88LKZvQ44m7zZV8dxnBGlmS3OfYDHzewJM1tLmB2t3pHwUF4NAL8KeFdViIbjOE7L0cztgWexfqD3AuDNg+Uxsz5JywihPIuKmeJa5RMBNGbMG7u32rK85pTrHUiktxqN+CnJmQNs1E9WspwMYyxtjBKfY0YRjSNRV8pWyPuI6Bz6s8uxpecPCxaZ2RY5JtXiPe+caIuX5EShwd339dxgZgdtbF0jQTMdZ61Pr/pTz8mDhbXK5wOM3W62bfPpT5VWbF3l/1wdPY35RuV8MdWfyNSR/iJYZ44xiWp608b2j834UmbYm+rHWEYZHT3pzlDnmvJ76h+TUU9f+rnkfM7WXV5X18p0IQMZn3PflLQzSj27ztVpW37/+VNyVrQNyuIl/fz6hry1HZ0zH6upe9DKNNNxLmD9FTLbsqHKTCXPgrjsbjNCzJvjOG2MAQNt17XLp5ljnHcBO0naUUFn8EiCGk6Ruby6cuYI4GbzwFLHaXsMo9f6s452pGktzjhmeTJBNagTuNDMHpR0JjDfzOYS1kZ/V9LjhJbmkc2yx3Gc4WU0tzib2VXHggTadVXnTi+8XgN8sJk2OI4z/BhG/yjuPDbVcTqOs+kykBcn0Ja443Qcp+EY0O+O03Ecpz68xdlCaCAdh9a9vDxYYEzGLjPdK9Mf+piV6cHvgcQTHrM8PavYs1k6wE+JYnonJIugb2I6yKJvfEY5ibr6xjcmdjUVd5qK5wXoT8RfAigj1jPlI/oz9q/sn5Qxw5zhi7TVmtL04ZiyMaDXxzgdx3HyMcy76o7jOHVh0D96/aY7TsdxGk9YOTR6ccfpOE4TEP0NU41pPdxxOo7TcMLkkDtOx3GcbEIcpztOx3GcuhjwFmd70bWqPH3iC+l4ufGL1ibzdP8hHRCqNYly+vqSZUyYPDGZh+7yj3L1dpsli1i1RfrfQWlzGehKCOlmxILmTMgOjC2fflBvhqZnhjZlSmsTYCCh/WkZOmQan/6/HDMh/X85ZWJ5HOeMCSuTZTyZzFGOtzgdx3HqxBD9o3gTXXecjuM0Be+qO47j1IEh1mbt+dKejN62tOM4I0YIgO/IOnKQdJCkRyQ9LunUGulnS7o3Ho9KWlpI6y+kVe9CsVF4i9NxnKbQqMkhSZ3AN4B3E/Ypu0vSXDN7qJLHzP6ukP8TwF6FIlab2ZyGGBPxFqfjOA3HTPRbR9aRwT7A42b2hJmtBa4ADi3JfxRweQNuY1DccTqO0xQGUNYBzJA0v3CcWFXULODZwvsF8dwGSNoe2BG4uXB6XCz3DkmHNeLevKvuOE7DCZND2e5lkZntXZJeq88/WODskcBVZuttn7mdmT0n6TXAzZLuN7Pf5xpXi7ZznKa0yG2q9a8M2Zbu55enMy1OB8D3rygPNrbedEBzZ+/myTwaU66U27nVpGQZ3avSHZCBrnSe1AKE2t+D9emZkf6QOleW/yPkCBmnAtchT1Q5JXY8MDFDpHgg/Vw6O9PPZeKY8v+pqWNWp20ZIpXJoQaxAJhdeL8t8NwgeY8EPr6eLWbPxb9PSJpHGP8ckuP0rrrjOE2h35R1ZHAXsJOkHSWNITjHDWbHJe0MTAN+VTg3TdLY+HoG8Fbgoepr66XtWpyO47Q+jVw5ZGZ9kk4GbgA6gQvN7EFJZwLzzaziRI8CrjBbb8+OXYBvSRogNBTPKs7GbyzuOB3HaQoDeTPmWZjZdcB1VedOr3p/Ro3rfgns3jBDIu44HcdpOEHkY/SOBLrjdByn4Rii15dcbhwZy6SOk/RSYTnUCc20x3Gc4cGMRgbAtxxNa3HmLJOKfN/MTm6WHY7jjATrgttHJc3sqq9bJgUgqbJMasgzWo7jtDYGbduazKGZjrPWMqk318h3uKT9gEeBvzOzZ6szxCVYJwJ0TptGKvSrI6FS3jcu/UvYu/XkZJ7uZA7onDghI1eqovTH1LfFlNL0/rHp8aachQE5i0H6x5Wn905OB5139KY/o/5E8HrXyozPeUr6pnNsSQXS56jR20D6ufT3p8tZuqpcYn/ymJ5kGY1gNE8ONfPOcpZJ/RjYwcz2AG4CLq5VkJmdb2Z7m9nenRMztpFwHGdEMcSA5R3tSDNbnMllUma2uPD228BXm2iP4zjDRNgeePQG7TSzxZlcJiVpZuHtIcDDTbTHcZxhQ/RnHu1I034SMpdJfVLSIUAfsAQ4rln2OI4zfBiNXTnUajS1LZ1aJmVmnwc+30wbHMcZGdq1NZnD6B2EcBxnxDCTtzgdx3HqIUwOjd4ll+44HcdpAvIA+JZCaWXv3knlYysda3PGXsYmc3RsWa66noN1pm3JCUxP0TshXc+a6ek8DWlEZDz+nPC+1HPJCrTP+F/IiarpXFnuJAbGpm3J+Tb2vJxYXQD0Tigv6KlhiJ0Mk0M+xuk4jlMXo3nlkDtOx3EaTmXl0GjFHafjOE2hgZu1tRzuOB3HaThm0DvgjtNxHCeb0FUfvY5z9N6Z4zgjSiPXqg9lNwlJx0p6LB7HNuLevMXpOE7DaWQ40lB2k5C0OfCPwN7RrLvjtS8Pxab2c5zGhqqeVayZUR7g1zM9o5qstnhO3GO5sR1rG2NLZ0+5Lf3jcmIa0/X0T0oHlaZiGjsydHT7pmYIDCfuOSdGszNH0zfj+598vhlhnKn/FQD1ZAgi95THF69emI4FHToN7aoPZTeJ9wA3mtmSeO2NwEHA5UMxyLvqjuM0hYG471DqAGZIml84TqwqqtZuErNqVHm4pPskXSWpogWce21dtF+L03GclifMqmcvM1tkZnuXpOfuJnG5mfVIOomwm8QBmdfWjbc4HcdpOA3eOiNrNwkzqwy8fBt4Y+61G4M7TsdxmkIdXfUUQ9lN4gbgTyVNkzQN+NN4bkh4V91xnIbTyFn1oewmYWZLJP0TwfkCnFmZKBoK7jgdx2kKjQyAH8puEmZ2IXBhw4zBHafjOE3ATPSN4pVD7jgdx2kKro7UYqQEbPsnlmcYO311so4tN1uRzjNheTJPilV9aTHknv70x9SVeCgretP1vLB4s2QeZQRy9E0ob2l0LulOlpETDN7RV15PTtB/zpe7P0OEuGvV0J1EZ086fKdzTbqerlXl6R19uRZtPC5k7DiOsxG443Qcx6kDFzJ2HMfZCDJjNNsSd5yO4zQcM+gbxULGTbszSRdKelHSA4OkS9I5UV/vPklvaJYtjuMMPw1cctlyNPMn4SKCfNNgHAzsFI8TgW820RbHcYaRBq9Vbzma5jjN7DbC0qfBOBS4xAJ3AFOr1ps6jtPGmCnraEdGcoxzMJ28hSNjjuM4jcQnh5pDtk5eFDY9EaBz2rSkInrXZuVS5jvMSK/xf/P0p5J5dhmXVqfavLM8kH5Kx5pkGSstHbz++7VblaYvXDs1WcZtXa9L5nl+2eRknp6O8gD3/s3SXyitSgeD900uD/pX7/AFt6ds6V6W7tzlKNZ39Caz0L2i/J7GLRmyHGUSM4/jbBbZOnlmdj5wPsDY2bOb/6k7jjNERL/PqjeFucAxcXZ9X2CZmXk33XFGCT7GuRFIuhzYn7CfyALCTnPdAGZ2HkEi6r3A48Aq4KPNssVxnOHF16pvJGZ2VCLdgI83q37HcUYQC+OcoxVfOeQ4TlPYpGfVJY0D3ge8HdgGWA08APyfmT3YXPMcx2lHbJRPDpU6TklnAO8H5gF3Ai8C44A/As6KTvUUM7uvuWY6jtNubMpd9bvM7IxB0r4uaUtgu8aalKADLBF7N2VyuZLrjHErk9XsNeHpZJ7dxzwHoPAMAAAfnElEQVSfzLN5R/mvbrfSv8prLB3r2Z8Ibh2jtHrtzAlbJvNMz3h29y6YVZo+0JX+Rqk/3c2zhKpyZ0b8Zf/4tC05gsgdPeV19adDcenoyciTIUKcEvruXpnI0CAaOWMu6SDgPwmbtf2PmZ1Vlf73wAmEzdpeAv7KzJ6Oaf3A/THrM2Z2yFDtKXWcZvZ/NW6gA5hkZq+Y2YuEVqjjOM46zBrnOCV1At8A3k2I/75L0lwze6iQ7TfA3ma2StLHgK8BfxHTVpvZnIYYE8kahJD0PUlTJE0EHgIekfSZRhriOM7oooEiH/sAj5vZE2a2FriCoHWxDjO7xcwqXc07CAtqmkbu6O2uZvYKcBgh/nI74OimWeU4TttjlncQYr3nF44Tq4oaTNdiMI4Hri+8HxfLvUPSYY24t9xwpG5J3QTHea6Z9Uo523Y5jrMpYoiB/Fn1RWa2d0l6PboWHwH2Bt5ROL2dmT0n6TXAzZLuN7Pf5xpXi9w7+xbwFDARuE3S9sArQ6nYcZzRjWUeGWTpWkg6EDgNOMTM1k21mdlz8e8ThAihveq8lQ3Icpxmdo6ZzTKz90b9zKeBdw61csdxRinW0LXqdwE7SdpR0hjgSILWxTok7UVo4B0SJ60r56dJGhtfzwDeSpinGRJZXfVY8eHADlXXnDlUAxzHGaU0aDDPzPoknQzcQAhHutDMHpR0JjDfzOYC/wpMAv5XErwadrQL8C1JA4SG4llVs/EbRe4Y54+AZcDdQEa0meM4mzqNjOM0s+sIE9PFc6cXXh84yHW/BHZvmCGRXMe5rZmV7R80fAxAx5ryD6Snt1xId01/+rbnr9wxmWetpcV2t+5aVpo+NUPI+Lm+zZN5nu/brDR9/vL0/YzNiK7+/bLpyTypSQEbyPhCdaebK5YIpB/IECnOEQ+2zoymU6IY9aeLyBk4G0j/yyUD4PvHNX8NuQEDOZ9zm5I7OfRLSQ332o7jjFIMMOUdbUhui/NtwHGSniR01UVQhtujaZY5jtPWbMpr1Ssc3FQrHMcZfWzqjrOwWH5LgjqS4zhOCe27LUYOuWvVD5H0GPAkcCshGP760oscx9m0aWAEfKuROzn0T8C+wKNmtiPwLuAXTbPKcZz2xkL0RM7RjuQ6zl4zWwx0SOows1uAhso0OY4z2lDm0X7kTg4tlTQJuA24TNKLBMFQx3Gc2rRpNzyHXMd5KLAG+Dvgw8BmjOByy9SY88ql40vTH1Fa6fz5lVOSeR6dlC5nTX95MP7M8eUB8gAPv7x1Ms+2k5aWpj+REbi+aOmkZJ4c+lcn/q160h2dnKDzzhWJQPuMYPGcPpca0J1MBaUDDOQE2o9J27JmekKNvjvnwTSATd1xmllxv4SLm2SL4zijhUoA/CgltVnb7Wb2NknLWf/3oxIAn26WOY6zSbLJBsCb2dvi38nDY47jOKOGNp0xzyHV4ixVlzCzJY01x3Gc0cJo3iMiNcZ5N6GLLsI+Qy/H11OBZ4BBJXckXQi8D3jRzF5fI31/glzdk/HU1Wbm+p6OMxpo4+D2HFJd9R0BJJ0HzI2aeEg6GKipf1fgIuBc4JKSPD83s/dlW+s4TpvQvspHOeQGwL+p4jQBzOx61t8MaQPM7DbAu/KOs6niSy5ZJOkfJO0gaXtJpwGLG1D/WyT9VtL1knYbLJOkEytbh/avXDlYNsdxWomBzKMNyQ2APwr4R+CH8f1t8dxQuAfY3sxWSHovcA2wU62MZnY+cD7A2NmzLTXo3LG0/LZWrkoHCaxam460WpgRSK++8u7KA2PSP7ldq9Jdnmc3n1FuR2/6N1IZaugdifsB0ITEtyHjy9L9Stre3mkpqfN0PTmB6f0Zn5F6y5+LjU3X09mTfrZ9E9MGp5TxO6Znb9u78WzKcZwV4uz53zayYjN7pfD6Okn/LWmGmS1qZD2O44wMo3lWPVdWbgtJ/yrpOkk3V46hVCxpa8Xt6CTtE21pRPffcZxWoIFjnJIOkvSIpMclnVojfayk78f0OyXtUEj7fDz/iKT3DPGugPyu+mXA9wnhRScBxwIvlV0g6XJgf2CGpAWErn43gJmdBxwBfExSH7AaONJsNK81cBxnY5DUCXwDeDewALhL0tyqbX6PB142s9dJOhL4KvAXknYl7MO+G7ANcJOkPzKznO3zBiXXcU43swsk/a2Z3QrcKunWsgvMrHQM1MzOJYQrOY4zCmlgV30f4HEzewJA0hUE4aGi4zwUOCO+vgo4N/ZoDwWuMLMe4ElJj8fyfjUUg3IdZ2/8u1DSnwHPAdsOpWLHcUYxRj1LLmdIml94f36cEK4wC3i28H4B8OaqMtblMbM+ScuA6fH8HVXXzso1bDByHeeXJW0GnAL8FzCFIDHnOI5Tm/wW5yIz27skvZYHri59sDw519ZN0nHG8YWdzOxaYBnwzqFW6jjO6KeBXfUFwOzC+20Jvd5aeRZI6iJoBi/JvLZuko7TzPolHQKcPdTKGoJgIGH1+OfLgwXGvFKaHPOkP/Xu1RkxdYm4ha5V6TIGMsRr+8aWi9OunZIhgLt5RhxnbzIL1lVuS+/E9LO1cv3nYMuacntTMbQA/amYU6BrZTr4pH9c4p4yvEjfpLQtmpTeeKGjq7yciRN6kmU0hMY5zruAnSTtCPyBMNnzl1V55hImrX9FmHi+2cxM0lzge5K+Tpgc2gn49VANyu2q/1LSuYSZ9XVLd8zsnqEa4DjOKKVBjjOOWZ4M3AB0Ahea2YOSzgTmm9lc4ALgu3HyZwnBuRLzXUmYSOoDPj7UGXXId5x/Ev8W1YsMOGCoBjiOM/qQNTYAPmplXFd17vTC6zXABwe59ivAVxpnTf7KIR/XdBynPkaxkHHp4I2kj0gaNI+k10p6W+PNchyn3am0OlNHO5JqcU4HfiPpboKo8UvAOOB1BFm5RcAGy58cx3HaVTIuh5SQ8X/GSaEDgLcCexCWRz4MHG1mzzTfRMdx2o42bk3mkBWOBNwYD8dxnDw2ZcfpOI6zMeRonbYro9Jxdq0uT5/wYjqMa8LCdJBw98uJigCtWlOabuPTCrdama5nYFq5OPOarSYky+halY467x+XzELPtPLZ1CzB3s50c2WguzyPMiZ11Z9hS0Zgetfy8iD53qkZwe0ZtqSC2wG23rx8hcfE7rXJMh5I5ti0GZWO03GcFsC76hBVkXYjzKoD4Nv5Oo5Tk019cgjWbQ88gSDw8T+EtaBDXu/pOM4oZhQ7ztxdm/7EzI4hKCx/CXgL6yuOOI7jrM8o3h44t6temZ1YJWkbwt5AOzbHJMdx2h3hs+oA10qaCvwrYVtfI3TZHcdxNsTHOAH4Wtyz4weSriVMEJXH2TiOs2kzih1n7hjnuo2NzKzHzJYxxM2OHMcZ5WyqY5yStiZsbDRe0l68un/HFMIs+4iQ6gJ0JESyu1emB186V2ZInb+4JJllYNWq0nR1pxv9NrhA1To6OstV17snpIPbx3elA7BXbpW2V4n1BZ0ZfZW1U9PfqM415c+lf2y6jJzuZOeqDAX48Ylg/AyJNRufXpiRI9TW3VlezmunLEqWcVNGPSk25a76e4DjCPt0fL1w/hXgC02yyXGc0cCm6jjN7GLgYkmHm9kPhskmx3HaHRvds+q5Y5y/kHSBpOsBJO0q6fgm2uU4Trszisc4cx3ndwgbJW0T3z8KfKopFjmOMyoYDgV4SZtLulHSY/HvtBp55kj6laQHJd0n6S8KaRdJelLSvfGYk1NvruOcYWZXAgMQdp0DSkegJc2WdIukh6PBf1sjjySdI+nxeENvyLTHcZxWZ3hanKcCPzOznYCfUXtHilXAMWa2G3AQ8B8xLr3CZ8xsTjzuzak013GulDSdeJuS9gWWJa7pA04xs12AfYGPS9q1Ks/BhH2OdwJOBL6ZaY/jOK1MrtMcuuM8FLg4vr4YOGwDU8weNbPH4uvngBeBLYZSaa7j/HvChu+vlfQL4BLgE2UXmNnCyr7rZracsN3GrKpshwKXWOAOYKqkmfXcgOM4rYcYts3atjKzhRB8DrBlqV3SPsAY4PeF01+JPd6zJaUFcsnfHvgeSe8AdiY8k0fMLCPQcZ2xOwB7AXdWJc0Cni28XxDPLay6/kRCi5TOaRsMYTiO04LU4RRnSJpfeH++mZ2/rhzpJmDrGtedVpc9oVH2XeBYM6vM+X8eeJ7gTM8HPgck5TJzZeXGAX8DvI3QuP65pPPiJvCpaycBPwA+ZWbV0tS14nk3eNzxIZ4PMHa72ZZq3vclVMr7JmQENE9MB4x3zJiazKP+KeXpGerujB2TzDIwIUOaPUHf+PRzsQZsld03KZ0nJ2C8f2J5vEvH6oyg85xvQEZYjSXU6HNs6R+ToUbfU77QAWBNX/lNPbdqs2QZDSHfcS4ys70HLcbswMHSJL0gaaaZLYyO8cVB8k0B/g/4h9i7rZRdaaT1SPoO8Okcg3O76pcQRIz/CzgX2JXguUuR1E1wmpeZ2dU1sixgfXm6bYHnMm1yHKeVGZ4xzrnAsfH1scCPqjNIGgP8kDAs+L9VaTPjXxHGR7N2DckV+djZzPYsvL9F0m/LLoiGXAA8bGZfHyTbXOBkSVcAbwaWFX4BHMdpV4ZPHeks4MoYV/4M8EEASXsDJ5nZCcCHgP2A6ZKOi9cdF2fQL5O0BaH3ey9wUk6luY7zN5L2rTRxJb0Z+EXimrcCRwP3S6pM8X8B2A7AzM4DrgPeCzxOCBn4aKY9juO0OsPgOM1sMfCuGufnAyfE15cClw5y/QEbU29K5ON+wu13A8dIeia+3x54qOxaM7udhCaBmRnw8XoMdhynPRjNSy5TLc73DYsVjuOMOjZZdSQze3q4DHEcZxTRxuvQc/B91R3HaQ7uOFsLSwRRDSRCMJe+Nh0Lt3rz8ck8Y5anYyc71ybi+/rS/139YzPiThOhnj1TMmI0M/4beiem86Sef/+YDIHhhBg1AH3lcY8596PejMDUnNjVhAZxTlwqObak/vmB5xeWLxJZuXk6LnioVFYOjVba0nE6jtP6aGD0ek53nI7jNB4f43Qcx6kf76o7juPUiztOx3Gc+vAWp+M4Tr2443Qcx6mDUb7LpTtOx3EajsdxtiFrthj6T13P9Azh2XE5gdzl5ShDGbh/Qsb9JIrpWjp0YWCAjrVDVzIeyPivy6lHyaDzdD05eQZyAvb7y+3tH59RUYY6bteSnKj+8uTVL6UFuBuCjV7POSodp+M4I4+3OB3HcerBA+Adx3HqxyeHHMdx6sQdp+M4Tj0YPjnkOI5TL6N5cih3e2DHcZz6GIbtgSVtLulGSY/FvzXFSCX1S7o3HnML53eUdGe8/vtxK+Ek7jgdx2k4lQD4nGOInAr8zMx2An4W39ditZnNicchhfNfBc6O178MHJ9Taft11Qegc015hG/fFr2l6eMm9ySrmTxhTTLPDpstSeZZ018uh77TpBeTZTywdJtkHiX+A3v60x/1S8snJfOsWZ3+Qe5fnVDY7834ve7LUaxPqOuvGnoZAB0ZyuypAPfUQgiAzpVpezvXJrPQtaq8rq5V6TKGjNlwCRkfCuwfX18MzAM+l3OhJAEHAH9ZuP4M4Jupa73F6ThOc8jvqs+QNL9wnFhHLVuZ2UKA+HfLQfKNi2XfIemweG46sNTMKhu1LABm5VTafi1Ox3Hagjq64YvMbO9By5FuAraukXRaHeZsZ2bPSXoNcLOk+4FXauTLstodp+M4jceABnXVzezAwdIkvSBpppktlDQTqDn2ZWbPxb9PSJoH7AX8AJgqqSu2OrcFnsuxqWlddUmzJd0i6WFJD0r62xp59pe0rDDbdXqz7HEcZ5gZhll1YC5wbHx9LPCj6gySpkkaG1/PAN4KPGRmBtwCHFF2fS2a2eLsA04xs3skTQbulnSjmT1Ule/nZva+JtrhOM4IMExxnGcBV0o6HngG+CCApL2Bk8zsBGAX4FuSBgiNxbMKfuhzwBWSvgz8Brggp9KmOc44UFsZtF0u6WHCwGu143QcZxQyHLPqZrYYeFeN8/OBE+LrXwK7D3L9E8A+9dY7LLPqknYgjCncWSP5LZJ+K+l6SbsNcv2JlRm3gZUrm2ip4zgNIbeb3qari5o+OSRpEmEQ9lNmVj2LdQ+wvZmtkPRe4Bpgp+oyzOx84HyAsdvNtlTMXPeE8mC37aen4y/fNuP3yTx7TXgqmWdqx9CD5j44Lf3fde+a7UrTf7d6ZrKMFydMTuZ5Ytn0ZJ4lHRNL03uXjU2WMdCd8Y1KiEBbRhk59XQm4iIhL04zRVciPhmgIx2CzNgl5fc07uXmq2+EAPg29YoZNLXFKamb4DQvM7Orq9PN7BUzWxFfXwd0x8Fbx3HanYHMow1pWoszRuVfADxsZl8fJM/WwAtmZpL2ITjyxc2yyXGc4WM0tzib2VV/K3A0cL+ke+O5LwDbAZjZeYQwgI9J6gNWA0fGEAHHcdqZNh6/zKGZs+q3k9g2yszOBc5tlg2O44wUw7ZWfUTwlUOO4zSHUdx5dMfpOE7jMd86w3Ecp368xek4jlMno9dvtp/j1AB0JQRfx4zpL01/3eRFyXp2GZcWSdmic3kyz05d5aLK0zonJMt4sndFMs8fj11Ymr5qIB10vqgnLWTc2ZHuf1kiML1jUvkzARhYlf7X7HylXDDZEnrKAOrPESlOewCV/8vR2ZMhZLw6mSVLyDi1Rrx71fD0oTUwevvqLmTcSlz9CnrTU2ibx9GbnoKra8kFOk4bYHgAvDMMXP0K+vRLaHVsLizog0+/FHo77/ffN6e9EDaqA+D9G9ki6F+WvOo0K+dWG/qX9Lp6x2lJzPKONsRbnK3CH/rqO+84rU6bOsUcvMXZKswa5DdssPOO08qM8jFOd5wtgn1+c2z8+jOvNl7Y5zcfIYscZ2hoYCDraEe8OdMqfGBKmAj6lyWhez6rKzjND0yBjHAkx2kt2nf8Mgd3nK3EB6ZgH5gy0lY4ztAx3HG2EgZYYoChZ013afrK/jHJeh5es00dVg3OGF4qTb9nbTpKu9+mJfM8sGZ2afozPeku/yu945J51vYN/V9moDdjhCgjML1ceysjHejIUF3PIaU2PzAm7UR60+sP6FycoRKfWF+wdlLGyoBG0J698Cx8jNNxnKYgs6xjSHVIm0u6UdJj8e8GrQxJ7yxsQX6vpDWSDotpF0l6spA2J6ded5yO4zSH4YnjPBX4mZntBPwsvq8yw24xszlmNgc4AFgF/LSQ5TOVdDO7t/r6WrjjdByn8ZhB/0DeMTQOBS6Ory8GDkvkPwK43syGtIuiO07HcZpDfotzRmX773icWEctW5nZwlCdLQS2TOQ/Eri86txXJN0n6WxJaTUc2nByyHGcNiG/G77IzPYeLFHSTcDWNZJOq8ccSTOB3YEbCqc/DzwPjCFsQf454MxUWe44HcdpPAY0aM8hMztwsDRJL0iaaWYLo2N8saSoDwE/NLN1cQeV1irQI+k7wKdzbPKuuuM4TcDABvKOoTEXODa+Phb4UUneo6jqpkdnW9nO/DDggZxK3XE6jtN4jOGaHDoLeLekx4B3x/dI2lvS/1QySdoBmA3cWnX9ZZLuB+4HZgBfzqm0/brqHTAwNhFsnFAPv+f5bZPVPNhda0hlfe7bbFYyz9r+clsmdfcky1jSk1aJX7E2a0y7lBeXZURgZzAwkAjS7kv/XneuyvhNT9Rj3ekv5UA65j+p7h7ylNsy0JXutlr5ug0A1myRLqd/bLktOWr0DWEYVg6Z2WLgXTXOzwdOKLx/CtjgC2tmB2xMve3nOB3HaQ98yaXjOE49uMiH4zhOfRjQppJxOTRtckjSOEm/lvRbSQ9K+lKNPGMlfV/S45LujAO4juOMBkbx1hnNnFXvAQ4wsz2BOcBBkvatynM88LKZvQ44G/hqE+1xHGfYGLYllyNC0xynBSoKvN3xqP55Ka4zvQp4V4ynchynnTEwG8g62pGmxnFK6pR0LyGa/0Yzu7MqyyzgWQAz6wOWAdNrlHNiZR1r/4qVzTTZcZxGMWB5RxvS1MkhM+sH5kiaCvxQ0uvNrBiZX6t1ucGTNLPzCetIGTt7tnWsLW+U6uXygLhVS6YmLIcVGXF3SwY28PEb2pIS5M1oX/ePS/8qd60o/w1Mxb4C9I9P16O+tMHdyxO2ZMQr9mfY25XUt0m3C5TR4Ml5dqbyPMn/A8By/hcmZNiS0CnumzBMrbw2Hb/MYVhWDpnZUmAecFBV0gJCND+SuoDNAN9I3HHaHbMwq55ztCHNnFXfIrY0kTQeOBD4XVW24jrTI4CbzUbxz5TjbEqM4ln1ZnbVZwIXS+okOOgrzexaSWcC881sLnAB8F1JjxNamkc20R7HcYYNw/oz1qq2KU1znGZ2H7BXjfOnF16vAT7YLBscxxkhGigr14r4yiHHcZpDm4Ya5eCO03GchmOAeYvTcRynDsy8xek4jlMvo3lySO0W/SNpOfDISNsRmQEsGmkjaB07wG2pRavYAfm2bG9mW2xsJZJ+EuvKYZGZVcd4tzTt6Djnl+2IN5y0ii2tYge4La1sB7SWLe2M7znkOI5TJ+44Hcdx6qQdHef5I21AgVaxpVXsALelFq1iB7SWLW1L241xOo7jjDTt2OJ0HMcZUdxxOo7j1EnLOk5JB0l6JG7kdmqN9GHZ6C3DjuMkvSTp3nic0Aw7Yl0XSnpR0gODpEvSOdHW+yS9YYTs2F/SssIzOb1WvgbYMVvSLZIejhsC/m2NPMP1THJsGa7n4hslNhsza7kD6AR+D7wGGAP8Fti1Ks/fAOfF10cC3x8hO44Dzh2m57If8AbggUHS3wtcT9CV3xe4c4Ts2B+4dhiex0zgDfH1ZODRGp/PcD2THFuG67kImBRfdwN3AvtW5Wn692c0H63a4twHeNzMnjCztcAVhI3digzHRm85dgwbZnYb5Qr5hwKXWOAOYKqkmSNgx7BgZgvN7J74ejnwMGEfqyLD9UxybBkW4r36RolNpFUd57pN3CIL2PCfMGujt2GwA+Dw2A28StLsBttQD7n2DgdviV3F6yXt1uzKYldzL0LrqsiwP5MSW2CYnkujNkp0atOqjjNnE7esjd6GwY4fAzuY2R7ATbz6Kz4SDMczyeEewlrnPYH/Aq5pZmWSJgE/AD5lZq9UJ9e4pGnPJGHLsD0XM+s3sznAtsA+kl5fbWqty5plz2ijVR3nuk3cItsCzw2Wp4kbvSXtMLPFZtYT334beGODbaiHnOfWdMzslUpX0cyuA7ol5Qo+1IWkboKjuszMrq6RZdieScqW4XwuhTp9o8Qm0KqO8y5gJ0k7ShpDGLyeW5VnODZ6S9pRNV52CGFsa6SYCxwTZ5L3BZaZ2cLhNkLS1pXxMkn7EP7PFjehHhH2rXrYzL4+SLZheSY5tgzjc/GNEptMS+pxmlmfpJOBGwgz2xea2YMa5o3eMu34pKRDgL5ox3GNtqOCpMsJM7MzJC0A/pEw8I+ZnQdcR5hFfhxYBXx0hOw4AviYpD5gNXBkk76UbwWOBu6P43kAXwC2K9gyLM8k05bhei6+UWKT8SWXjuM4ddKqXXXHcZyWxR2n4zhOnbjjdBzHqRN3nI7jOHXijtNxHKdO3HE6TUXSeEm3xtCYjS3jOEnnxtcnSTqmcRaCpJskTWtkmc7oxh2n02z+CrjazNbbZHtjHamZnWdmlzTEslf5LkEtyHGycMfZxkj6oqTfSbpR0uWSPh3P/z9Jd0UxiR9ImhDPXyTpm1E38glJ71DQ1nxY0kWFcldI+qqku2NrbB9J8+I1h8Q8O0j6uaR74vEng5j5YeBH8Zr9Y93fA+6P566J9Two6cSCDR+V9KikWwnB5ZXzZ2Te5zmSfhltPiKenynpNgUtzAckvT0WOxc4asgfiLPpMNK6dn5s3AHsDdwLjCfoPz4GfDqmTS/k+zLwifj6IoI0ngiyYq8AuxN+QO8G5sR8BhwcX/8Q+ClhZdCewL3x/ARgXHy9E2FFSrWNY4DnC+/3B1YCOxbObR7/jgceICj0zASeAbaIZfyCqHkKnJF5n/8b72tXgjQgwCnAafF1JzC5cP1jxfL88KPsaMkll04WbwN+ZGarAST9uJD2eklfBqYCkwhLRiv82MxM0v3AC2ZWafk9COxAcMZrgZ/E/PcDPWbWG6/ZIZ7vBs6VNAfoB/6oho0zgKVV535tZk8W3n9S0p/H17MJTnhrYJ6ZvRRt+/4g5Zfd5zVmNgA8JGmreO4u4EIFMY5rzOzeQv4XgW1owtpxZ/ThXfX2pUx09iLgZDPbHfgSMK6QVlFyGii8rryv/JD2mplV54uOqJLn74AXCK3QvQktw2pWV9UNocUZbkDanyBA8RYLUmu/KeTPWQt8Een7hPisLAgw7wf8gbBOuzjJNC7a6zhJ3HG2L7cD71fYX2YS8GeFtMnAwtiy+nCT6t8MWBid6dGEru96mNnLQKekaudZLONlM1sl6Y8JW1tAEADeX9L0eA8fHOT6uu5T0vbAi2b2bYLIxRvieRFauU+lynAcaFF1JCeNmd0laS5hH6SngfkEFW+ALxKcz9OErvbkJpjw38APJH0QuIVCS7KKnxKGFW6qkfYT4CRJ9wGPAHdA2IZC0hnAr4CFBAHgWrPw9d7n/sBnJPUCK4BKi/ONwB0WlNAdJ4mrI7UxkiaZ2Yo4m3wbcKLFfW9aBUl7AX9vZkePtC2DIek/gblm9rORtsVpD7zF2d6cL2lXwvjcxa3mNAHM7DcxBKnTqmI5W4gH3Gk69eAtTsdxnDrxySHHcZw6ccfpOI5TJ+44Hcdx6sQdp+M4Tp2443Qcx6mT/w+s6/AktuHucAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "landscape_qpu = run_maxcut_qaoa_landscape(qpu, edges, width, shots, seed)\n",
    "landscape_qvm = run_maxcut_qaoa_landscape(qvm, edges, width, shots, seed)\n",
    "plot_landscape(landscape_qpu, device=qpu.name, edges=edges, width=width, shots=shots)\n",
    "plot_landscape(landscape_qvm, device=qvm.name, edges=edges, width=width, shots=shots)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}