QAOA MaxCut for weighted graph.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# I. Importing libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import qiskit\n",
    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute, IBMQ\n",
    "from qiskit.visualization import *\n",
    "\n",
    "from qiskit.aqua.components import optimizers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# II. Background\n",
    "MaxCut is a problem whose goal is to find a bipartition $\\mathbf{x}$ of vertices in a weighted graph that maximizes $$C(\\mathbf{x}) = \\sum_{e \\in \\text{edges}} C_e(\\mathbf{x}),$$ where $C$ is the total weight of edges cut given partition $\\mathbf{x}$ as a bitstring. Here we only consider non-directional graphs. Let $A$ and $B$ be the two sets for the partition. The set $A$ contains $i$-th vertex if $\\mathbf{x}_i = 0$ and $\\mathbf{x}_i = 1$ for $B$. Given $e$ the edge between two vertices $v_i$ and $v_j$ with corresponding weight $w_{ij}$, $C_e(\\mathbf{x}) = w_{ij}$ if $v_i$ and $v_j$ belongs to different sets $A$ and $B$; $C_e(\\mathbf{x}) = 0$ otherwise.\n",
    "\n",
    "Quantum Approximate Optimization Algorithm (QAOA) can be viewed as a form of Quantum Annealing that attempts to encode the optimal state (which gives optimal cuts) as the ground state of a Hamiltonian. Finding the maximal cut is equivalent to finding the ground state of $\\displaystyle{H_C = -\\frac{1}{2} \\sum_{(v_i,v_j) \\in \\text{edges}} w_{ij}(1-\\sigma_i^z\\sigma_j^z)}$ in the transverse field induced by $\\displaystyle{H_B = \\sum_{v_i \\in \\text{vertices}} \\sigma_i^x}$, where $\\sigma$ are Pauli operators.\n",
    "\n",
    "Starting from the uniform superposition $|+\\rangle^{\\otimes n}$, we evolve the system with $\\displaystyle{U_{C_k} = e^{-i\\gamma_k H_C}}$ and $\\displaystyle{U_{B_k} = e^{-i\\beta_k H_B}} $ for $k=1,2,\\dots,p$ for some chosen depth $p$. The final state of the system is given by \n",
    "$$U_{B_p}U_{C_p}\\dots U_{B_2}U_{C_2}U_{B_1}U_{C_1}|+\\rangle^{\\otimes n}$$\n",
    "\n",
    "The technique is called trotterization, in which the ansatz state is prepared from $2p$ angles $\\{\\beta_k, \\gamma_k\\}$. While $U_{C_k}$ evolves the system simulating the desired Hamiltonian, $U_{B_k}$ is a driver keeping the system away from higher eigenstates. Measurement outcomes of all qubits in the $Z$ basis suffices to compute the cost function, which is the weighted sum of cut edges, that will be passed to a classical optimizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 3\n",
    "V = np.arange(0,n,1)\n",
    "E = [(0,1,10.0),(0,2,10.0),(1,2,3.0)]\n",
    "G = nx.Graph()\n",
    "G.add_nodes_from(V)\n",
    "G.add_weighted_edges_from(E)\n",
    "\n",
    "# Plot the Graph\n",
    "colors       = ['r' for node in G.nodes()]\n",
    "default_axes = plt.axes(frameon=True)\n",
    "pos          = nx.spring_layout(G)\n",
    "nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=nx.get_edge_attributes(G, 'weight'))\n",
    "\n",
    "nx.draw_networkx(G, node_color=colors, node_size=600, ax=default_axes, pos=pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cut_weight(G,partitions):\n",
    "    \"\"\"\n",
    "    Return list of cut weights corresponding to input partitions\n",
    "    \n",
    "    Args:\n",
    "        G : Graph\n",
    "        A weighted graph\n",
    "        \n",
    "        partitions : list(str)\n",
    "        List of bitstring   \n",
    "    \"\"\"\n",
    "    \n",
    "    vertices = list(G.nodes().keys())\n",
    "    edges = G.edges()\n",
    "    cut_vals = []\n",
    "    \n",
    "    for partition in partitions:\n",
    "        cut = 0\n",
    "        \n",
    "        idx_A = [idx for idx,char in enumerate(partition) if char=='0']\n",
    "        idx_B = [idx for idx,char in enumerate(partition) if char=='1']\n",
    "        \n",
    "        half_A = [vertices[i] for i in idx_A]\n",
    "        half_B = [vertices[i] for i in idx_B]\n",
    "        \n",
    "        for v1 in half_A:\n",
    "            for v2 in half_B:\n",
    "                if (v1,v2) in edges:\n",
    "                    cut += G[v1][v2]['weight']\n",
    "        cut_vals.append(cut)\n",
    "    \n",
    "    return cut_vals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classical_maxcut(G):\n",
    "    \"\"\"\n",
    "    Return the maximum cut value and all cuts that produce the maximum value.\n",
    "    \n",
    "    Args:\n",
    "        G : nx.Graph\n",
    "        A weighted graph\n",
    "    \"\"\"\n",
    "    n = len(G.nodes())\n",
    "    partitions = []\n",
    "    \n",
    "    # Generate all bitstrings of length n\n",
    "    for i in range(2**n):\n",
    "        partitions.append(bin(i)[2:].zfill(n))\n",
    "        \n",
    "    cut_vals = compute_cut_weight(G,partitions)\n",
    "    max_cut_val = max(cut_vals)\n",
    "    \n",
    "    max_cuts = [p for idx,p in enumerate(partitions) if cut_vals[idx] == max_cut_val]\n",
    "    \n",
    "    return max_cut_val, max_cuts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20.0, ['011', '100'])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classical_maxcut(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# III. Implementation details\n",
    "Because the terms $\\sigma^z_i \\sigma^z_j$ commute with each other (and similar for $\\sigma^x_i$), we can write \n",
    "$$\\begin{matrix}\n",
    "U_{C_k} = & e^{-i\\gamma_k H_C} = & \\displaystyle{\\prod_{(v_i,v_j) \\in \\text{edges}} e^{-i\\gamma_k w_{ij}(1-\\sigma_i^z\\sigma_j^z)/2}}\\\\ \n",
    "U_{B_k} = & e^{-i\\beta_k H_B} = & \\displaystyle{\\prod_{v_i \\in \\text{vertices}} e^{-i\\beta_k \\sigma_i^x}}\n",
    "\\end{matrix}$$\n",
    "\n",
    "In Qiskit notion, $R_A(\\theta) = e^{-i\\frac{\\theta}{2}A}$, where $A \\in \\{X,Y,Z\\}$. The ansatz components can be decomposed into\n",
    "$$\\begin{matrix}\n",
    "U_{C_k} = & \\displaystyle{\\prod_{(v_i,v_j) \\in \\text{edges}} CX_{ij}\\cdot R_Z(-\\gamma_k w_{ij}) } \\cdot CX_{ij}\n",
    " \\\\\n",
    "U_{B_k} = & \\displaystyle{\\prod_{v_i \\in \\text{vertices}}  R_{X_i}(-2\\beta_k) }\n",
    "\\end{matrix}\n",
    "$$\n",
    "\n",
    "We also provide an option for non-uniform transverse field. The non-uniformity proves helpful for performance in complex/tricky cases. The field is induced by $H_C = \\sum_{v_i \\in \\text{vertices}} i\\sigma_i^x$ with corresponding operators\n",
    "$$U_{B_k} = \\displaystyle{\\prod_{v_i \\in \\text{vertices}}  R_{X_i}(-2i\\beta_k) }$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QAOA_Solver():\n",
    "    \"\"\"\n",
    "    Create a quantum circuit that performs QAOA for an input graph\n",
    "    \n",
    "    Args:\n",
    "        G : nx.Graph\n",
    "        A weighted graph\n",
    "            \n",
    "    \"\"\"\n",
    "    def __init__(self,G):\n",
    "        \"\"\"\n",
    "        Initialize (self) quantum circuit.\n",
    "        \"\"\"\n",
    "        self.G = G\n",
    "        self.V = G.nodes()\n",
    "        self.E = G.edges()\n",
    "        self.n = len(self.V)\n",
    "\n",
    "        self._qreg = QuantumRegister(self.n, name='qreg')\n",
    "        self._creg = ClassicalRegister(self.n, name='creg')\n",
    "        self._circuit = QuantumCircuit(self._qreg, self._creg)\n",
    "    \n",
    "    def trotterize(self,depth,params=None,transverse='uniform'):  \n",
    "        \"\"\"\n",
    "        Implement trotterization on the circuit.\n",
    "        \n",
    "        Args:\n",
    "            depth : int\n",
    "            Number of trotterization layers\n",
    "            \n",
    "            params : list((float,float)), optional\n",
    "            Trotterization parameters, ideally of length = depth, with each pair is (beta_k,gamma_k) for layer k.\n",
    "            If None, trotterization layers left parameterized.\n",
    "            \n",
    "            transverse : str, optional\n",
    "            Type of transverse field.\n",
    "            If uniform, the field Hamiltonian is uniform Pauli X's\n",
    "            Otherwise, Hamiltonian is non-uniform.\n",
    "        \"\"\"\n",
    "        \n",
    "        betas = qiskit.circuit.ParameterVector('β', depth)\n",
    "        gammas = qiskit.circuit.ParameterVector('γ', depth)       \n",
    "        if params is not None:\n",
    "            beta_values,gamma_values = list(zip(*params))\n",
    "            assert len(betas) == depth, 'Obtain {} trotterization parameters but {} are expected'.format(len(params),depth)\n",
    "        \n",
    "        self._circuit.h(self._qreg)\n",
    "        self._circuit.barrier()\n",
    "        \n",
    "        \n",
    "        for d in range(depth):\n",
    "            #self._circuit.rx(2*betas[d],self._qreg)\n",
    "            ## Prepare U_C\n",
    "            for edge in self.E:\n",
    "                v1, v2 = edge\n",
    "                w = G[v1][v2]['weight']\n",
    "                self._circuit.cx(v1,v2)\n",
    "                self._circuit.rz(-gammas[d]*w,v2)\n",
    "                self._circuit.cx(v1,v2)\n",
    "                \n",
    "            self._circuit.barrier()\n",
    "            \n",
    "            ## Prepare U_B\n",
    "            if transverse == 'uniform':\n",
    "                self._circuit.rx(2*betas[d],self._qreg)      \n",
    "            else:\n",
    "                for idx,qubit in enumerate(self._qreg):\n",
    "                    self._circuit.rx((idx+1)*2*betas[d],qubit)\n",
    "\n",
    "            self._circuit.barrier()\n",
    "                   \n",
    "        if params is not None:\n",
    "            self._circuit.assign_parameters({betas:list(beta_values), gammas:list(gamma_values)}, inplace=True)\n",
    "            \n",
    "        self._circuit.measure(self._qreg,self._creg)\n",
    "\n",
    "    def get_circuit(self):\n",
    "        \"\"\"\n",
    "        Return the quantum circuit.\n",
    "        \"\"\"\n",
    "        return self._circuit\n",
    "    \n",
    "    def draw(self):\n",
    "        \"\"\"\n",
    "        Draw the quantum circuit.\n",
    "        \"\"\"\n",
    "        print(self._circuit.draw())\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        ┌───┐ ░                                                              »\n",
      "qreg_0: ┤ H ├─░───■──────────────────────■────■──────────────────────■───────»\n",
      "        ├───┤ ░ ┌─┴─┐┌────────────────┐┌─┴─┐  │                      │       »\n",
      "qreg_1: ┤ H ├─░─┤ X ├┤ RZ(-10.0*γ[0]) ├┤ X ├──┼──────────────────────┼────■──»\n",
      "        ├───┤ ░ └───┘└────────────────┘└───┘┌─┴─┐┌────────────────┐┌─┴─┐┌─┴─┐»\n",
      "qreg_2: ┤ H ├─░─────────────────────────────┤ X ├┤ RZ(-10.0*γ[0]) ├┤ X ├┤ X ├»\n",
      "        └───┘ ░                             └───┘└────────────────┘└───┘└───┘»\n",
      "creg: 3/═════════════════════════════════════════════════════════════════════»\n",
      "                                                                             »\n",
      "«                               ░ ┌────────────┐ ░                             »\n",
      "«qreg_0: ───────────────────────░─┤ RX(2*β[0]) ├─░───■──────────────────────■──»\n",
      "«                               ░ ├────────────┤ ░ ┌─┴─┐┌────────────────┐┌─┴─┐»\n",
      "«qreg_1: ───────────────────■───░─┤ RX(2*β[0]) ├─░─┤ X ├┤ RZ(-10.0*γ[1]) ├┤ X ├»\n",
      "«        ┌───────────────┐┌─┴─┐ ░ ├────────────┤ ░ └───┘└────────────────┘└───┘»\n",
      "«qreg_2: ┤ RZ(-3.0*γ[0]) ├┤ X ├─░─┤ RX(2*β[0]) ├─░─────────────────────────────»\n",
      "«        └───────────────┘└───┘ ░ └────────────┘ ░                             »\n",
      "«creg: 3/══════════════════════════════════════════════════════════════════════»\n",
      "«                                                                              »\n",
      "«                                                                ░ »\n",
      "«qreg_0: ──■──────────────────────■──────────────────────────────░─»\n",
      "«          │                      │                              ░ »\n",
      "«qreg_1: ──┼──────────────────────┼────■─────────────────────■───░─»\n",
      "«        ┌─┴─┐┌────────────────┐┌─┴─┐┌─┴─┐┌───────────────┐┌─┴─┐ ░ »\n",
      "«qreg_2: ┤ X ├┤ RZ(-10.0*γ[1]) ├┤ X ├┤ X ├┤ RZ(-3.0*γ[1]) ├┤ X ├─░─»\n",
      "«        └───┘└────────────────┘└───┘└───┘└───────────────┘└───┘ ░ »\n",
      "«creg: 3/══════════════════════════════════════════════════════════»\n",
      "«                                                                  »\n",
      "«        ┌────────────┐ ░                                                    »\n",
      "«qreg_0: ┤ RX(2*β[1]) ├─░───■──────────────────────■────■────────────────────»\n",
      "«        ├────────────┤ ░ ┌─┴─┐┌────────────────┐┌─┴─┐  │                    »\n",
      "«qreg_1: ┤ RX(2*β[1]) ├─░─┤ X ├┤ RZ(-10.0*γ[2]) ├┤ X ├──┼────────────────────»\n",
      "«        ├────────────┤ ░ └───┘└────────────────┘└───┘┌─┴─┐┌────────────────┐»\n",
      "«qreg_2: ┤ RX(2*β[1]) ├─░─────────────────────────────┤ X ├┤ RZ(-10.0*γ[2]) ├»\n",
      "«        └────────────┘ ░                             └───┘└────────────────┘»\n",
      "«creg: 3/════════════════════════════════════════════════════════════════════»\n",
      "«                                                                            »\n",
      "«                                         ░ ┌────────────┐ ░ ┌─┐      \n",
      "«qreg_0: ──■──────────────────────────────░─┤ RX(2*β[2]) ├─░─┤M├──────\n",
      "«          │                              ░ ├────────────┤ ░ └╥┘┌─┐   \n",
      "«qreg_1: ──┼────■─────────────────────■───░─┤ RX(2*β[2]) ├─░──╫─┤M├───\n",
      "«        ┌─┴─┐┌─┴─┐┌───────────────┐┌─┴─┐ ░ ├────────────┤ ░  ║ └╥┘┌─┐\n",
      "«qreg_2: ┤ X ├┤ X ├┤ RZ(-3.0*γ[2]) ├┤ X ├─░─┤ RX(2*β[2]) ├─░──╫──╫─┤M├\n",
      "«        └───┘└───┘└───────────────┘└───┘ ░ └────────────┘ ░  ║  ║ └╥┘\n",
      "«creg: 3/═════════════════════════════════════════════════════╩══╩══╩═\n",
      "«                                                             0  1  2 \n"
     ]
    }
   ],
   "source": [
    "QAOA = QAOA_Solver(G)\n",
    "QAOA.trotterize(3,transverse='uniform')\n",
    "QAOA.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss_function(params,G,transverse='uniform',return_counts=False,backend=qiskit.Aer.get_backend(\"qasm_simulator\"),shots= 10000):\n",
    "    \"\"\"\n",
    "    Return the total loss given a graph and trotterization parameters.\n",
    "    Total loss = - sum of weights of cut edges, averaged over measurement outcomes.\n",
    "    \n",
    "    Args:\n",
    "        params : list(int)\n",
    "        Ideally contain p beta values, followed by p gamma values.\n",
    "        \n",
    "        G : nx.Graph\n",
    "        A weighted graph.\n",
    "        \n",
    "        transverse : str, optional\n",
    "        Type of transverse field, either 'uniform' or else.\n",
    "        More information can be found in QAOA_Solver class       \n",
    "        \n",
    "        return_counts : bool, optional\n",
    "        If True, return statistics of experiment in addition.\n",
    "        \n",
    "        backend : `Qiskit backend`, optional\n",
    "        Use local simulator by default.\n",
    "        \n",
    "        shots : int, optional\n",
    "        The number experiment trials.\n",
    "    \"\"\"\n",
    "    E = G.edges()\n",
    "    V = G.nodes()\n",
    "        \n",
    "    \n",
    "    # Convert params as a list to [(beta0,gamma0),(beta1,gamma1),...]\n",
    "    depth = int(len(params) / 2)\n",
    "    betas = params[:depth]\n",
    "    gammas = params[depth:]\n",
    "    params = list(zip(betas,gammas))\n",
    "    \n",
    "    QAOA = QAOA_Solver(G)\n",
    "    QAOA.trotterize(depth, params, transverse)\n",
    "    QAOA_circ = QAOA.get_circuit()\n",
    "    job = execute(QAOA_circ, backend=backend, shots=shots)\n",
    "    counts = job.result().get_counts()\n",
    "    \n",
    "    total_loss = 0\n",
    "    \n",
    "    for partition,count in counts.items():\n",
    "        loss = 0\n",
    "        for edge in E:\n",
    "            v1,v2 = edge[0], edge[1]\n",
    "            z1,z2 = -2*int(partition[v1])+1, -2*int(partition[v2])+1 # Map '0' to +1, '1' to -1\n",
    "            w = G[v1][v2]['weight']\n",
    "            loss += w*(1-z1*z2)\n",
    "        loss = loss/2\n",
    "        #print(partition, loss)\n",
    "        total_loss += loss*(count/shots)\n",
    "    \n",
    "    if return_counts == False:\n",
    "        return -total_loss\n",
    "    else:\n",
    "        return -total_loss,counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(G,depth=1,transverse='uniform'):\n",
    "    \"\"\"\n",
    "    Return optimal parameters and loss value after training a QAOA circuit\n",
    "    \n",
    "    Args:\n",
    "        G : nx.Graph\n",
    "        A weighted graph.\n",
    "        \n",
    "        depth : int\n",
    "        The number of trotterization layers.\n",
    "        \n",
    "        transverse : str, optional\n",
    "        Type of transverse field, either 'uniform' or else.\n",
    "        More information can be found in QAOA_Solver class.\n",
    "    \"\"\"\n",
    "    optimizer = optimizers.COBYLA()\n",
    "    np.random.seed(20)\n",
    "    init_params = np.random.rand(2*depth,)\n",
    "    #print(init_params)\n",
    "\n",
    "    opt_params,opt_loss,_ = optimizer.optimize(2*depth, optimizers.COBYLA.wrap_function(loss_function,args=(G,transverse)), initial_point=init_params)\n",
    "\n",
    "    print('Optimal parameters = {}, optimal loss = {}'.format(opt_params,-opt_loss))\n",
    "    \n",
    "    return opt_params, -opt_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_max_cut(G,counts,k=2):\n",
    "    \"\"\"\n",
    "    Return k most probable cuts and their corresponding cut values\n",
    "    \n",
    "    Args: \n",
    "        G : nx.Graph\n",
    "        A weighted graph.\n",
    "        \n",
    "        counts : dict(str: float)\n",
    "        Statistics obtained from executing quantum circuit.\n",
    "        \n",
    "        k : int\n",
    "        Number of selected probababilities.\n",
    "        Note that the number of cuts can be > k if two cuts have the same probability.\n",
    "    \"\"\"\n",
    "    sort_counts = sorted(set(counts.values()), reverse=True)\n",
    "\n",
    "    #Get partitions with k highest probability\n",
    "    partitions = []\n",
    "    for i in range(k):\n",
    "        partitions += [key for key,val in counts.items() if val==sort_counts[i]]\n",
    "    cut_vals = compute_cut_weight(G,partitions)\n",
    "\n",
    "    pairs = list(zip(partitions, cut_vals))\n",
    "    return pairs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# IV. Experiments\n",
    "We evaluate 4 graph configurations as follows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Uniformly butterfly graph\n",
    "QAOA with uniform transverse field and a single trotterization layer is capable of peaking out 18 max cuts, better than the outcome obtained from the non-uniform one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum cut value = 4.0\n",
      "Obtained by partitions ['00100', '00101', '00110', '01001', '01010', '01011', '01100', '01101', '01110', '10001', '10010', '10011', '10100', '10101', '10110', '11001', '11010', '11011']\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 5\n",
    "V = np.arange(0,n,1)\n",
    "E = [(0,1,1.0),(0,2,1.0),(1,2,1.0),(2,3,1.0),(2,4,1.0),(3,4,1.0)]\n",
    "G = nx.Graph()\n",
    "G.add_nodes_from(V)\n",
    "G.add_weighted_edges_from(E)\n",
    "\n",
    "# Generate plot of the Graph\n",
    "colors       = ['r' for node in G.nodes()]\n",
    "default_axes = plt.axes(frameon=True)\n",
    "pos          = nx.spring_layout(G)\n",
    "nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=nx.get_edge_attributes(G, 'weight'))\n",
    "\n",
    "nx.draw_networkx(G, node_color=colors, node_size=600, ax=default_axes, pos=pos)\n",
    "\n",
    "# Compute max cuts classically\n",
    "max_cut_val, max_cuts = classical_maxcut(G)\n",
    "print(\"Maximum cut value = {}\\nObtained by partitions {}\".format(max_cut_val, max_cuts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.5881308  0.89771373]\n",
      "Optimal parameters = [1.87833965 0.61367107], optimal loss = 3.9284000000000003\n",
      "Max Cut(s): [('11001', 4.0), ('01010', 4.0)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt_params, opt_loss = train(G,depth=1, transverse='uniform')\n",
    "loss, counts = loss_function(opt_params,G,return_counts=True, transverse='uniform')\n",
    "pairs = evaluate_max_cut(G,counts)   \n",
    "print(\"Max Cut(s): {}\".format(pairs))\n",
    "plot_histogram(counts,figsize = (8,6),bar_labels = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal parameters = [1.06188104 1.41653876], optimal loss = 3.7532\n",
      "Max Cut(s): [('01001', 4.0), ('10110', 4.0)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt_params, opt_loss = train(G,depth=1, transverse='nonuniform')\n",
    "loss, counts = loss_function(opt_params,G,return_counts=True, transverse='nonuniform')\n",
    "pairs = evaluate_max_cut(G,counts)   \n",
    "print(\"Max Cut(s): {}\".format(pairs))\n",
    "plot_histogram(counts,figsize = (8,6),bar_labels = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.  Weighted square\n",
    "Both types of transverse field work well given a sufficient number of layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum cut value = 10.0\n",
      "Obtained by partitions ['0101', '1010']\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 4\n",
    "V = np.arange(0,n,1)\n",
    "E = [(0,1,1.),(1,2,2.),(2,3,3.),(3,0,4.)]\n",
    "\n",
    "G = nx.Graph()\n",
    "G.add_nodes_from(V)\n",
    "G.add_weighted_edges_from(E)\n",
    "\n",
    "# Generate plot of the Graph\n",
    "colors       = ['r' for node in G.nodes()]\n",
    "default_axes = plt.axes(frameon=True)\n",
    "pos          = nx.spring_layout(G)\n",
    "nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=nx.get_edge_attributes(G, 'weight'))\n",
    "\n",
    "nx.draw_networkx(G, node_color=colors, node_size=600, ax=default_axes, pos=pos)\n",
    "\n",
    "# Compute max cuts classically\n",
    "max_cut_val, max_cuts = classical_maxcut(G)\n",
    "print(\"Maximum cut value = {}\\nObtained by partitions {}\".format(max_cut_val, max_cuts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal parameters = [ 0.7084594   1.02663722  0.44346084  1.26467133  0.39560086  0.61250296\n",
      "  1.10706563  0.52375304  1.76964109 -0.11119655  0.18740231  0.68343664\n",
      "  0.77256179  0.89416569  0.86144721  0.07137408], optimal loss = 9.989399999999998\n",
      "Max Cut(s): [('1010', 10.0), ('0101', 10.0)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt_params, opt_loss = train(G,depth=8,transverse='uniform')\n",
    "loss, counts=loss_function(opt_params,G,return_counts=True,transverse='uniform')\n",
    "pairs = evaluate_max_cut(G,counts)   \n",
    "print(\"Max Cut(s): {}\".format(pairs))\n",
    "plot_histogram(counts,figsize = (8,6),bar_labels = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal parameters = [ 1.49422632e+00  9.36902359e-01  8.96384367e-01  8.31067277e-01\n",
      "  5.72839035e-04  6.68306677e-01  1.03506284e-01  5.74001813e-01\n",
      "  6.56090435e-01  2.13130731e-01  1.21930274e+00  5.97022678e-01\n",
      "  7.81064392e-01  8.67659051e-01  7.35593700e-01 -1.60627095e-01], optimal loss = 9.816299999999998\n",
      "Max Cut(s): [('0101', 10.0), ('1010', 10.0)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt_params, opt_loss = train(G,depth=8,transverse='nonuniform')\n",
    "loss, counts=loss_function(opt_params,G,return_counts=True,transverse='nonuniform')\n",
    "pairs = evaluate_max_cut(G,counts)   \n",
    "print(\"Max Cut(s): {}\".format(pairs))\n",
    "plot_histogram(counts,figsize = (8,6),bar_labels = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Weighted 3-regular graph\n",
    "The uniform transverse field produces suboptimal outcomes. The non-uniform field typically results in better partitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum cut value = 52\n",
      "Obtained by partitions ['01011101', '10100010']\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create 3-regular graph with sorted vertices\n",
    "n = 8\n",
    "temp_G = nx.random_regular_graph(3, n, seed=20)\n",
    "V = np.arange(0,n,1)\n",
    "E = list(temp_G.edges())\n",
    "\n",
    "G = nx.Graph()\n",
    "G.add_nodes_from(V)\n",
    "G.add_edges_from(E)\n",
    "\n",
    "np.random.seed(20)\n",
    "weights = np.random.randint(1,10,(len(E),))\n",
    "for idx,(v1,v2) in enumerate(G.edges()):\n",
    "     G[v1][v2]['weight'] = weights[idx]\n",
    "\n",
    "# Generate plot of the Graph\n",
    "colors       = ['r' for node in G.nodes()]\n",
    "default_axes = plt.axes(frameon=True)\n",
    "pos          = nx.spring_layout(G)\n",
    "nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=nx.get_edge_attributes(G, 'weight'))\n",
    "\n",
    "nx.draw_networkx(G, node_color=colors, node_size=600, ax=default_axes, pos=pos)\n",
    "\n",
    "# Compute max cuts classically\n",
    "max_cut_val, max_cuts = classical_maxcut(G)\n",
    "print(\"Maximum cut value = {}\\nObtained by partitions {}\".format(max_cut_val, max_cuts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal parameters = [1.60960902 0.9033521  1.90102428 0.79345654 1.03016224 0.65957486\n",
      " 0.4083585  0.48580782 0.65186971 1.17825772 0.31368603 0.73325893\n",
      " 1.83148464 1.84863199 1.77745153 0.02081137 0.11829601 0.77569414\n",
      " 0.21873184 0.28318258 0.93069493 0.93927467 0.53923121 0.13008067\n",
      " 0.78977216 0.49729807 0.59704104 1.83762842 0.46251084 0.48158634\n",
      " 0.67135314 0.62116106 0.27341279 0.05776765 0.76204189 0.49999636\n",
      " 0.33711092 0.50077325 0.27849123 0.31421659 0.64417659 0.59058625\n",
      " 0.33271085 0.40038125 0.31501795 0.53847511 0.1554617  0.70141244\n",
      " 0.73656883 0.16598905 0.71473371 0.40879856 0.79005427 0.80029364\n",
      " 0.77776378 0.58515079 0.7134745  0.6350996  0.43188674 0.52265383\n",
      " 0.52874168 0.00647863 0.70176167 0.64031847], optimal loss = 36.5523\n",
      "Max Cut(s): [('11100010', 48), ('00011101', 48)]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKsAAAGjCAYAAADjFZZCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAB4vklEQVR4nO3debycVX348c9JAgEElEVAdlBANkGIYpRFrbTWrdXWWrXuStW6ULVVf+4LLlURa0UUrVj3vdYdXAJEQiAg+xIEAiSQsIQlgew5vz++Z7iTYe69M/fO8tyZz/v1uq/kO/M885zvc55z5pnzbCnnjCRJkiRJklQF0/pdAEmSJEmSJKnGwSpJkiRJkiRVhoNVkiRJkiRJqgwHqyRJkiRJklQZDlZJkiRJkiSpMhyskiRJkiRJUmXM6HcBqm7HHXfMe++9d7+LIUmSJEmSNDAuuuiiO3POj2z2noNV49h7771ZsGBBv4shSZIkSZI0MFJKN432npcBSpIkSZIkqTIcrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXhYJUkSZIkSZIqw8EqSZIkSZIkVYaDVZIkSZIkSaoMB6skSZIkSZJUGQ5WSZIkSZIkqTIcrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXhYJUkSZIkSZIqw8EqSZIkSZIkVYaDVZIkSZIkSaoMB6skSZIkSZJUGQ5WSZIkSZIkqTIcrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXhYJUkSZIkSZIqw8EqSZIkSZIkVYaDVZIkSZIkSaoMB6skSZIkSZJUGQ5WSZIkSZIkqTIcrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXhYJUkSZIkSZIqw8EqSZIkSZIkVYaDVZIkSZIkSaoMB6skSZIkSZJUGQ5WSZIkSZIkqTIcrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXR88GqlNIbU0o3ppRWp5QuSikdM870h6aUzk4prUopLUkpvT+llOrePy6ldF5K6a4yzTUppXc0fMbrUkrnppSWp5TuSSn9IaV0dLdylCRJkiRJ0sTM6OXCUkovAj4HvBGYW/79VUrpoJzzzU2m3xY4CzgHeAJwAHAGcD/wmTLZSuA/gcuBB4CnAF9KKT2Qcz61TPNU4HvAH8s0/wr8JqV0eM75us5nKkmSJEmSpIlIOefeLSyl+cBlOefX1b12HfDDnPO7m0z/BuCTwM4551XltfcCbwB2z6MUPqX0Y2BNzvnFo7yfgNuAk3LOnx+rzLNmzcoLFixoKT9JkiRJkiSNL6V0Uc55VrP3enYZYEppc+BI4MyGt84EnjzKbLOBc2sDVcVvgF2BvUdZzuPL5509RnE2B7YA7h634JIkSZIkSeqZXl4GuCMwHVjW8Poy4BmjzLMLsLjJ9LX3bqy9mFJaDDySyOlDOefTxijLR4nLB/+v2ZsppROAEwB23XVX5syZA8C+++7LNttsw6WXXgrADjvswMEHH8w555wDwIwZMzj66KO5+OKLue+++wCYNWsWy5Yt45ZbbgFgv/32Y+bMmVxxxRUA7LTTTuy///7MnTsXgJkzZzJ79mwWLFjAypUrATjqqKNYvHgxS5YsAeCAAw5g+vTpXHXVVbEidtmFffbZh3nz5gGw5ZZbctRRRzF//nxWrYpxvtmzZ3PjjTeydOlSAA466CA2bNjAtddeC8Buu+3G7rvvzvz58wHYeuutmTVrFvPmzWPNmjUAHH300SxcuJDbb78dgEMOOYQ1a9Zw3XVxJeUee+zBzjvvTO1MtG233ZYjjjiCuXPnsn79egCOPfZYrrzySu666y4ADjvsMFasWMENN9wAwN57783222/PxRdfDMB2223HYYcdxtlnn03OmZQSxx13HJdeeil33x1jjUcccQTLly9n0aJF1pP1ZD1ZT9aT9WQ9WU/Wk/VkPVlP1pP1ZD1NgXoaS88uA0wp7QosAY7NOZ9b9/oHgBfnnB/bZJ4zgVtyzq+pe20vYBEwO+d8ft3r+wBbA08iLh18a875G00+863AR4Bn5JwvGK/cXgYoSZIkSZLUWWNdBtjLM6vuBDYQZ0TV24mHnm1Vs3SU6WmcJ+dcO8vq8pTSzsAHgU0Gq8pA1UeBv25loEqSJEmSJEm91bN7VuWc1wIXAcc3vHU8cN4os80DjkkpbdEw/a3E2VWjmQbMrH8hpfQ24CTg2Tnnua2XXJIkSZIkSb3Ss8Gq4mTglSml16aUDkwpfY64WfppACmlj6eUflc3/beBB4AzUkqHpJReALwLOLn2JMCU0ptTSs9JKe1X/l4DvAP4Zu1DUkr/BnwCeDWwMKW0S/l7eA9yliRJkiRJUot6eRkgOefvpZR2AN4LPAq4AnhWzvmmMsmjgEfXTX9vSul44AvAAuLpfZ8hBr1qphP3qNobWA9cTwxo1d9g/V+AzYDvNRTp68ArO5CaJEmSJEmSOqBnN1ifqrzBuiRJkiRJUmeNdYP1Xl8GKEmSJEmSJI3KwSpJkiRJkiRVhoNVkiRJkiRJqgwHqyRJkiRJklQZDlZJkiRJkiSpMhyskiRJkiRpSLzulPiTqszBKkmSJEmSJFWGg1WSJEmSJEmqDAerJEmSJEmSVBkOVkmSJEmSJKkyHKySKs4bIEqSJEmShomDVZIkSZIkSaoMB6skSZIkSZJUGQ5WSZIkSZIkqTIcrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXhYJUkSZIkSZIqw8EqSZIkSZIkVYaDVZIkSZIkSaoMB6skSZIkSZJUGQ5WSZIkSZIkqTIcrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXhYJUkSZIkSZIqw8EqSZIkSZIkVYaDVZIkSZIkSaoMB6skSZIkSZJUGQ5WSZIkSZIkqTIcrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXhYJUkSZIkSZIqw8EqSZIkSZIkVYaDVZIkSZIkSaoMB6skSZIkSZJUGQ5WSZIkSZIkqTIcrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXhYJUkSZIkSZIqw8EqSZIkSZIkVYaDVZIkSZIkSaoMB6skSZIkSZJUGQ5WSZIkSZIkqTIcrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXhYJUkSZIkSZIqw8EqSZIkSZIkVYaDVZIkSZIkSaoMB6skSZIkSZJUGQ5WSZIkSZIkqTIcrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXhYJUkSZIkSZIqw8EqSZIkSZIkVYaDVZIkSZIkSaqMng9WpZTemFK6MaW0OqV0UUrpmHGmPzSldHZKaVVKaUlK6f0ppVT3/gtSSmemlO5IKa1IKc1PKT1vjM97cUopp5R+3sm8JEmSJEmSNHk9HaxKKb0I+BzwMeDxwHnAr1JKe44y/bbAWcAy4AnAW4B/A95WN9lxwO+BZ5fP/CXwk2aDYCmlfYFPAed2KCVJkiRJkiR1UK/PrHobcEbO+fSc89U55zcDtwFvGGX6lwJbAa/IOV+Rc/4R8EngbbWzq3LOb805fyLnfEHO+c855w8BFwF/W/9BKaXNgO8A7wFu6EZykiRJkiRJmpyeDVallDYHjgTObHjrTODJo8w2Gzg357yq7rXfALsCe4+xuG2AuxteOwlYlHP+eqtlliRJkiRJUm/N6OGydgSmE5f01VsGPGOUeXYBFjeZvvbejY0zpJT+Bdgd+Ebda38JvAg4vJWCppROAE4A2HXXXZkzZw4A++67L9tssw2XXnopADvssAMHH3ww55xzDgAzZszg6KOP5uKLL+a+++4DYNasWSxbtoxbbrkFgP3224+ZM2dyxRVXALDTTjux//77M3fuXABmzpzJ7NmzWbBgAStXrgTgqKOOYvHixSxZsgSAAw44gOnTp3PVVVfFithlF/bZZx/mzZsHwJZbbslRRx3F/PnzWbUqxvlmz57NjTfeyNKlSwE46KCD2LBhA9deey0Au+22G7vvvjvz588HYOutt2bWrFnMmzePNWvWAHD00UezcOFCbr/9dgAOOeQQ1qxZw3XXXQfAHnvswc4778yCBQsA2HbbbTniiCOYO3cu69evB+DYY4/lyiuv5K677gLgsMMOY8WKFdxwQ5zstvfee7P99ttz8cUXA7Dddttx2GGHcfbZZ5NzJqXEcccdx6WXXsrdd8d45BFHHMHy5ctZtGjRQNYT7ATAnDlzrKcK15PtyXqynqwn68l6sp6sJ+vJepoK9QRPBfB3bsXraRja01hSznnMCTolpbQrsAQ4Nud8bt3rHwBenHN+bJN5zgRuyTm/pu61vYBFwOyc8/kN0/8dMUj1jznn/yuv7QhcBrwk5zynvHYGsGPO+TnjlXvWrFm5tlFK/fC6U+Lf00/sZykkSZIkDQJ/X6gqUkoX5ZxnNXuvl2dW3QlsIM6IqrcTDz3bqmbpKNPTOE/dQNXLawNVxSHAo4Df1j1EcFqZZz1wcM752tbTkCRJkiRJUrf07J5VOee1xI3Pj29463jiqYDNzAOOSSlt0TD9rcTZVQCklP4B+CbwypzzDxs+40LgUOISwNrf/xFPBDycJpcSSpIkSZIkqT96eWYVwMnAN1JKFwB/BF5P3Cz9NICU0seBJ+ac/6JM/23gA8AZKaWPAvsD7wI+lMv1iymlfyTOqHoHcE5KqXYm1tqc8/Kc8/3AFfWFSCndA8zIOW/yuiRJkiRJkvqrp4NVOefvpZR2AN5LXJp3BfCsnPNNZZJHAY+um/7elNLxwBeABcQT/j5DDHrVvJ7I45TyV3M2tTvHSZIkSZIkaUro9ZlV5JxPBU4d5b1XNnntcuDYMT7vqRMow0OWI0mSJEmSpP7r2T2rJEmSJEmSpPE4WCVJkiRJkqTKcLBKkiRJkiRJldHWYFVKaVpKaVpdvEtK6bUppad0vmiSJEmSJEkaNu2eWfUL4M0AKaWtiSf0fQqYk1J6eYfLJkmSJEmSpCHT7mDVkcDvy/9fANwH7AS8DnhHB8slSZIkSZKkIdTuYNU2wD3l/38J/CTnvI4YwHp0B8slSZIkSZKkIdTuYNXNwFNSSg8D/go4q7y+PfBAJwsmSZIkSZKk4TOjzelPBr4BrARuAs4prx8LXN7BckmSJEmSJGkItTVYlXP+UkrpImAP4Kyc88by1vXA+zpdOEmSJEmSJA2Xds+sIue8gHgKYP1rv+hYiSRJkiRJkjS02r1nFSmlN6aUrkwpPZBS2re89s6U0j90vniSJEmSJEkaJm0NVqWUTgTeC3wZSHVv3Qq8qXPFkiRJkiRJ0jBq98yq1wOvyzl/Dlhf9/rFwMEdK5UkSQLgdafEnyRJkjQs2h2s2gu4osnr64AtJ18cSaomBwwkSZIkqTfaHay6ATiiyevPAq6afHEkSZIkSZI0zNp9GuCngf9KKW1F3LNqdkrpZcC/A6/udOEkSZIkSZI0XNoarMo5fy2lNAP4GLAV8A1gCfCWnPP3ulA+SZIkSZIkDZF2z6wi53w6cHpKaUdgWs759s4XS5IkSZIkScOo7cGqmpzznZ0siCRJkiRJkjTuYFVK6TLguJzz3Smly4E82rQ558d1snCSJEmSOqv2dNvTT+xnKTSM3PYktaqVM6t+BKyp+/+og1WSJEmSJEnSZIw7WJVz/lDd/z/Y1dJIkiRJkiRpqE1rZ+KU0u9TSo9o8vq2KaXfd6xUkiRJkiRJGkptDVYBTwU2b/L6FsAxky6NJEmSJEmShlpLTwNMKR1RFz4upbS8Lp4O/BWwpJMFkyRJkiRJ0vBpabAKWEDcWD0DZzZ5fxXw5k4VSpIkSZIkScOp1cGqfYAE3AA8Ebij7r21wO055w0dLpskSZIkSZKGTEuDVTnnm8p/273HlSRJkiRJktSycQerUkovAH6Wc15X/j+qnPOPO1YySZIkSZIkDZ1Wzqz6IbALcHv5/2gycbN1SZIkSZIkaULGHazKOU9r9n9JkiRJkiSp0xx8kiRJkiRJUmW0es+qlnjPKkmSJEmSJE1Gq/esaoX3rJIkSZIkSdKktHXPKkmSJEmSJKmbHIiSJEmSJElSZbR6z6qf5ZzXjXf/Ku9ZJUmSJEmSpMlo9Z5VuwC3M/b9q7xnlSRJkiRJkialrXtWef8qSZIkSZIkdZODT5IkSZIkSaqMtgerUkpHpJT+J6W0oPx9I6V0RDcKJ0mSJEmSpOHS1mBVSumlwIXAo4Bflr+dgQtSSv/U+eJJkiRJkiRpmLRyg/V6JwHvyzl/rP7FlNK7gY8C3+xUwSRJkiRJkjR82r0M8JHA95u8/gNgp8kXR5IkSZIkScOs3cGqPwBPbfL6U4GzJ1sYSZIkSZIkDbdxLwNMKb2gLvwV8PGU0izg/PLak4AXAB/seOkkSZIkSZI0VFq5Z9UPm7x2Qvmr93ng1EmXSJIkSZIkSUNr3MGqnHO7lwpKkiRJkiRJE+JAlCRJkiRJkiqjlcsAN5FS2h54JrAnsHn9eznnD3eoXJIkSZIkSRpCbQ1WpZSeBPwCWAM8ElgCPKrEiwAHqyRJkiRJkjRh7V4G+CngW8BuwGrg6cQZVguAT3a2aJIkSZIkSRo27Q5WPQ74r5xzBjYAM3POy4B3Ah/scNkkSZIkidedEn+SpOHQ7mDV2rr/LwP2Kv9fCezakRJJkiRJkiRpaLV7g/WLgScAC4E5wEdTSjsD/wRc1tmiSZIkSZIkadi0e2bVe4Bby//fC9wBfB7YDjihg+WSJEmSJEnSEGrrzKqc84K6/98B/HXHSyRJU1DtPhqnn9jPUkiSJEnS1NfuZYAApJQeDRxYwqtyzjd0rkiSJEmSJEkaVm0NVqWUdgC+CjwP2Djycvo58Oqc810dLp8kSZIkSZKGSLv3rPoK8BjgGGCL8ncssA9weisfkFJ6Y0rpxpTS6pTSRSmlY8aZ/tCU0tkppVUppSUppfenlFLd+49KKX07pXRNSmlDSumMUT5n25TSf6aUbk0prUkp/Tml9A+tpS1JkiRJkqReaPcywL8C/iLnPK/utT+mlP4Z+O14M6eUXgR8DngjMLf8+6uU0kE555ubTL8tcBZwDvEUwgOAM4D7gc+UyWYCdwKfYJSbvKeUNgPOBO4G/gFYDOwOrBmvzJIkSZIkSeqddger7iAGiho9ALRyCeDbgDNyzrWzsN6cUnom8Abg3U2mfymwFfCKnPMq4IqU0oHA21JKJ+ewCHgLQErp70dZ7quAnYBjc85ry2uLWiivJEmSJEmSeqjdywA/DJySUtqt9kL5/2fKe6NKKW0OHEmc4VTvTODJo8w2Gzi3DFTV/AbYFdi7jXL/LfBH4PMppaUppatSSh8sZ1xJkiRJkibpdaeMPCFZkiZj3DOrUkqXA7nupX2ARSmlJSXeDVhNnLn0lTE+akdgOrCs4fVlwDNGmWcX4pK9xulr7904ZuFH7As8Hfg28GxioOsLwNbAOxonTimdQLmkcNddd2XOnDnxIfvuyzbbbMOll14KwA477MDBBx/MOeecA8CMGTM4+uijufjii7nvvvsAmDVrFsuWLeOWW24BYL/99mPmzJlcccUVAOy0007sv//+zJ07F4CZM2cye/ZsFixYwMqVKwE46qijWLx4MUuWxCo/4IADmD59OldddVWsiF12YZ999mHevLg6c8stt+Soo45i/vz5rFoV43yzZ8/mxhtvZOnSpQAcdNBBbNiwgWuvvRaA3Xbbjd1335358+cDsPXWWzNr1izmzZvHmjVxteTRRx/NwoULuf322wE45JBDWLNmDddddx0Ae+yxBzvvvDMLFiwAYNttt+WII45g7ty5rF+/HoBjjz2WK6+8krvuihPxDjvsMFasWMENN8QDJffee2+23357Lr74YgC22247DjvsMM4++2xyzqSUOO6447j00ku5++67ATjiiCNYvnw5ixYtGsh6iqYFc+bMsZ76WE81c+bMsZ4qXE+D2O/BUwGsp4rXk+3JeppK9QRbArBgwYIpU0+1vtD98qldT43vW0/VrCfbUzXqaRi+n8aSYkd4jAlS+sCYE9TJOX9ojM/ZFVhCXIp3bsPnvzjn/Ngm85wJ3JJzfk3da3sRl/DNzjmf3zD9z4E7c86vbHh9IXEz+H1yzhvKaycAnwW2zmOshFmzZuXaRin1Q+3o1Okn9rMUGq8erCd1i9uWpE6biv3KVCzzMHJ/aWqwHlQVKaWLcs6zmr037plVYw1AtelOYANxRlS9nXjo2VY1S0eZnjHmaeY2YF1toKq4mrgf1o7EvbgkSZIkSZLUZ+3eswqAlNLTU0pvSin9S0rpqa3MU25sfhFwfMNbxwPnjTLbPOCYlNIWDdPfSns3SP8j8JiUUn2++xM3hr+zjc+RJEmSJElSF7U1WJVS2i2ldAFwFvBO4F3A71JK88tlfuM5GXhlSum1KaUDU0qfI26Wflr5/I+nlH5XN/23iQGlM1JKh6SUXlCWeXL9pXsppcNTSocD2wLbl/igus/5IrA98LmU0gEppb8CPgScOtYlgJIkSZIkSeqtcS8DbPCfxKV8j8k53wiQUtoX+GZ57+/Hmjnn/L2U0g7Ae4FHAVcAz8o531QmeRTw6Lrp700pHU/cDH0BcDfx5MGTGz76Tw3xc4GbKE8MzDnfklL6yzLfJcTlhf8NfLTFvCVJkiRJktQD7Q5WHQ88tTZQBZBzviGl9Bbgd6PPNiLnfCpw6ijvvbLJa5cDx47zmamF5Z4PPLmVMkqSBlP947S9qagkSZJUTRO6Z1UTGzv0OZIkSZIkSRpi7Q5W/Q74z5TSHrUXUkp7Ap+jxTOrJEmSJEmSpNG0O1j1FmAr4IaU0k0ppUXA9eW1t3S4bJIkSZIkSRoy7d6z6i7gicDTgMcCCbgq5/zbThdMkiRJkiRJw6flwaqU0nTgXuCwnPNZwFldK5UkSZIkSZKGUsuXAeacNwA3AZt3rziSJEmSJEkaZu3es+ojwCdSSjt2ozCSJEmSJEkabu3es+odwD7AkpTSYuD++jdzzo/rVMEkSZIkScPjdafEv6ef2M9SSKqCdgerfghk4sbqkiRJkiRJUke1NFiVUtoK+BTwt8BmwO+AN+ec7+xe0SRJkiRJkjRsWr1n1YeAVwK/AL4DPAP4YpfKJEmSJEmV8rpTRi5TkyR1V6uXAb4AeE3O+bsAKaVvAX9MKU0vTwmUJEmSJEmSJq3VM6v2AM6tBTnnC4D1wK7dKJQk9ZpHSyVJkiSpGlodrJoOrG14bT3t36BdkiRJkiRJGlWrg00J+GZKaU3da1sAp6eUHqi9kHN+XicLJ0mSJEmSpOHS6mDV15u89s1OFkSSJEmSJElqabAq5/yqbhdEkiRJkiRJavWeVZIkSZIkSVLXOVglSZIkSZKkynCwSpIkSZIkSZXhYJUkSZIkSZIqw8EqSZIkSZIkVYaDVZIkSZIkSaoMB6skSZIkSZJUGQ5WSZIkSZIkqTIcrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXhYJUkSZIkSZIqw8EqSZIkSZIkVYaDVZIkSZIkSaoMB6skSZIkSZJUGQ5WSZIkSZIkqTIcrJIkSZIkSVJlzOh3ASRJkiSF150y8v/TT+xXKSRJ6i/PrJIkSZIkSVJlOFglSZIkSZKkynCwSpIkSZIkSZXhPaskSZIkSZXjPdwGV61urVeNxjOrJEmSJEmSVBkOVkmSJEmSJKkyHKyS2vS6UzY9JVlS62w/kiRJksbjYJUkSUPOQURJkiRViYNVkiRJkiRJqgwHqyRJqhDPcpIkSdKwc7BKkiRJkiRJleFglSRJkiRJkirDwSpJkiRJkiRVhoNVkoaS9wWSJEmSpGpysEqSJEkaYh7AkSRVjYNVkiRJkiRJqgwHqyRJkiRJklQZDlZJkiRJkiSpMhyskiR1jPc9kSRJkjRZDlZJkiRJkiSpMhyskiRJkiRJUmU4WCVJkiRpoHmZuiRNLQ5WSZLUQ/5gkiRJksbmYJUkSZIkSZIqw8EqSZIkSZIkVUbPB6tSSm9MKd2YUlqdUroopXTMONMfmlI6O6W0KqW0JKX0/pRSapjmuPJZq1NKN6SUXt/kc96aUrqmfM7ilNIXUkpbdzo/SZIkSZIkTVxPB6tSSi8CPgd8DHg8cB7wq5TSnqNMvy1wFrAMeALwFuDfgLfVTbMP8MvyWY8HPg58PqX0d3XTvAT4D+Ak4EDg5cCzSlk0xLx3jCRJkiRJ1TKjx8t7G3BGzvn0Er85pfRM4A3Au5tM/1JgK+AVOedVwBUppQOBt6WUTs45Z+D1wK055zeXea5OKR0FvAP4UXntycD5OedvlHhRSul/gAcHtKRBVT8Yd/qJ/SqFJEmSJE1M7TeNv2eGR8/OrEopbQ4cCZzZ8NaZxGBSM7OBc8tAVc1vgF2BveumafzM3wCzUkqblXgucHhK6UmlLHsCzyPOyJIkSZIkSVJF9PLMqh2B6cQlffWWAc8YZZ5dgMVNpq+9d2P597dNpplRlnlbzvm7KaUdgHPK/a5mAN8A3tlsoSmlE4ATAHbddVfmzJkDwL777ss222zDpZdeCsAOO+zAwQcfzDnnnAPAjBkzOProo7n44ou57777AJg1axbLli3jlltuAWC//fZj5syZXHHFFQDstNNO7L///sydOxeAmTNnMnv2bBYsWMDKlSsBOOqoo1i8eDFLliwB4IADDmD69OlcddVVsSJ22YV99tmHefPmAbDlllty1FFHMX/+fFatinG+2bNnc+ONN7J06VIADjroIDZs2MC1114LwG677cbuu+/O/PnzAdh6662ZNWsW8+bNY82aNQAcffTRLFy4kNtvvx2AQw45hDVr1nDdddcBsMcee7DzzjuzYMECALbddluOOOII5s6dy/r16wE49thjufLKK7nrrrsAOOyww1ixYgU33HADAHvvvTfbb789F198MQDbbbcdhx12GGeffTY5Z1JKHHfccVx66aXcfffdABxxxBEsX76cRYsWtV1PcAQAK1eubKOenvrgttKLeoKdAJgzZ86E6qm+vHPmzJmS9dSN9gT7AXDbbbcxffr0B9fzNddc07Se6tdhN+ppENpT1FNsb9dff/0o9RTvr1+/vi/9Xq2eAK677rq+1FNtHdS+WxrrqfZ+rZ5qcXfbUyzjzjvv9PupUu3J/YhhrKfa9xPA7bff3pV6gi2B2I+ZNWvWg8ubM2dOZeupse/s/PdTK/UUn3Hdddc1bU/fuiTe/683rBna9jRePTW+P349PZWa2jz2e52vp9q2+9LDI+5NvxfLHK09PbSeRraFYamnqn0/daM9jSXFjnD3pZR2BZYAx+acz617/QPAi3POj20yz5nALTnn19S9thewCJidcz4/pbQQ+EbO+SN10xwHzAEelXNeWuLvAe8F5gOPIe5XdUbO+f1jlXvWrFm5tlFq8EzkdNJen4I62eV5GWBzjet1vPU82feHRdXXUxXaQ7vrqBfrrN/1ImlEL/qpfvQzk9Wp/aHJ5Fj177gq6PT+VBW+twdRFfqAdpdp+xpMKaWLcs6zmr3XyzOr7gQ2EGdC1duJh55tVbN0lOmpm2e0adYDtcPYHwW+k3P+SokvTyk9DPhKSunDOef1LWchaUryC06SJEmSpoae3bMq57wWuAg4vuGt44kn+TUzDzgmpbRFw/S3EmdX1aZpvIzweGBBznldibciBsrqbQBSq+WXJEmDy6fDSpIkVUfPBquKk4FXppRem1I6MKX0OeJm6acBpJQ+nlL6Xd303wYeAM5IKR2SUnoB8C6g9iRAyry7p5ROKZ/5WuCVwKfrPudnwAkppX9MKe2TUjoe+Ajwc8+qkiRJkkbnYK4kqdd6eRkgOefvlRudvxd4FHAF8Kyc801lkkcBj66b/t4ysPQFYAFwN/AZYtCrNs2NKaVnAZ8F3kCcdfWWnPOP6hb9USATA1S7E5ck/gx4TzfylCRJkiRJ0sT0dLAKIOd8KnDqKO+9sslrlwPHjvOZZ1N7rFvz99cDHyp/kqQmBvG+XoOYkyTJ/l3Dze1fw6DXlwFKGoen2kuSJEnNua8sDQcHqzSl+OUkSdLg8ntekiSBg1WSJEmSJDXlILrUHw5WSZKmDHcYJUmS1AnuV1abg1WSes4vBkmSJEnSaByskiRJkiRJUmU4WCVJkiRJQ8iz3SVVlYNVktrmjo0kSaqp4n5BFcskSWqdg1WSJEmSJEmqDAerJEmSJEmSVBkOVkmSNIV4aYskSZIGnYNVkiRJkiplGAfmhzFnSRqNg1WSVFHutPaG61mSJEmqFgerJEkT1u+Bnn4vX5IkSVLnOVglSZIkSZKkynCwaoh5RoLUPbYvSZIkSZoYB6skTUkOBqmq3DYlScNivO88vxM1SNyee8vBKvWVDV7SoLOfkyRJktrjYJUkSZIkSV3gQStpYhyskiRJktQyf3xLkrrNwSpJkiRpgDm4JEmaahyskiRJkiRJUmU4WCVJA8Ij55IkSZIGwYx+F0CSNLxqg2unn9jPUkiStKn6gz9+R0lS73lmlQaKZ5a4DiRJkqRh5u8BDQIHqyRJ0pTjjrg0WGzTkqR6DlZJGkju9EqSpH5yX0TSZAx7H+I9qyRJkiR1jPd7ktRv3hd16vPMKqnDhn0EfFhYz5IkSZLUHQ5WSVOcgyZSd9nGJEmSpN5ysEqSpDoOTkmSNHX4vS0NJgerJEmSOsAfTJKkifD7Q3ooB6s00Oz4Jal67JvVS25v1WS9SJLG4mCVJEmSJE1xDgAOL+teg8jBKkmSJHWEP5gkSVInOFglSZIkSZKmLA+WDB4HqyRJkiRJA8lBDGlqcrBKkiRJlTQIPzIHIYepwPUsSYPFwSpJD+EOnyRJkiSpXxyskqaYqTiQNBXLrP6YitvKVCyzNFGT3d77Pf9UWaZ6z3qWOss2pclysEoTZgckSZIkaZj4G0jqDQerJGlIubMlSZL6yX0RDRO39/Y4WCV1mZ2SJFWPfXM1DGI9dCOndj9zENerNEw63YbtEzQVOVglSZLUA1Pxx8JULHOvuY6k4WYfMLys++6a0e8CSJIkDaPaDu7pJ/azFJIGVf2PaPsZSVONg1XqKXfMNazcYVSV2BdLkiSpyrwMUJKa8LReqXVTob1MtowTmX8qrJdhZL30h+u9fa4zTSVur+o0B6vUMXZQU5c3cVRVVfGmwlXcvqtYpk4bhhw1nNy2+8P1rqnE7XVqst4mx8EqSZqi/ALUVDGsg4i95jqQess2J0nd42CVJEkakz/INBq3DUlqn33nYLJeO8vBKk1pdggT43obTtb78Op13Q/CtjYIOag73DYkSZ3g98nYHKySNK5ud6R21IPLupUkaXD4vS6pVxyskqQpwh1EVYXboiT1nn2vpGHiYJVa5mO7JUmS+s/9K02U2874XEdSNThYJUmSNAX5g0qa2mzDkjQ6B6uGyHhfiH5hSv1lG1RVVGFbrEIZpjrPiJbUrmHoA4YhRw2mYdt2Z/S7ANJYao3x9BP7WQr1W32n7LbQO7Y/qbfGa3NTsU1a5t58/lRcz5IkjcUzq6Q+G7YRckmSusnvVUmSpj4HqyQNBH+cSJImwu8PabDYpnvD9axuc7BKQ8VOVVLV2C9JkqQq68S+Sqf3d9r9vFamd5+sWno+WJVSemNK6caU0uqU0kUppWPGmf7QlNLZKaVVKaUlKaX3p5RSwzTHlc9anVK6IaX0+iaf83cppatSSmvKv8/vdG6a+uygNEjcnqWpzTYsSZKGVU8Hq1JKLwI+B3wMeDxwHvCrlNKeo0y/LXAWsAx4AvAW4N+At9VNsw/wy/JZjwc+Dnw+pfR3ddPMBr4HfAs4vPz7g5TSUZ3NUJM1DDvmw5CjJLXLvrH3XOdSb/X7zBL1hvXSGa5H9fppgG8Dzsg5n17iN6eUngm8AXh3k+lfCmwFvCLnvAq4IqV0IPC2lNLJOecMvB64Nef85jLP1WUQ6h3Aj8prJwJ/yDmfVOKTUkpPK6+/uKMZauj4BJ7Oc51Wk09lnDpsQ93nOtYgc/uWpN6z791Uz86sSiltDhwJnNnw1pnAk0eZbTZwbhmoqvkNsCuwd900jZ/5G2BWSmmzcaYZbbnC0WwYWQfDvh7G4zqaGNeb1D22r4caxHUyiDlJVTIMbWwYcmxXP9ZJFeuhimUaJilOTurBglLaFVgCHJdzPqfu9fcDL805H9BknjOBxTnnV9e9tidwE/DknPO8lNJC4Js55w/XTXMscDawa875tpTSWuC1Oef/qZvm5cDpOeeZTZZ7AnBCCQ8Arp1M7hWzI3BnD+N+LNMczGGqxFUogzlUowzmUI0ymEM1ymAO1SiDOQxmTlUogzlUowzmUI0ydCKHqWyvnPMjm76Tc+7JH3E2VAaOaXj9A8A1o8xzJvDVhtf2Kp/zpBIvBN7XMM1xZZpdSrwWeFnDNK8AVvcq/6r8AQt6GfdjmeZgDlMlrkIZzKEaZTCHapTBHKpRBnOoRhnMYTBzqkIZzKEaZTCHapShEzkM6l8vb7B+J7AB2KXh9Z2IG6g3s3SU6ambZ7Rp1gN3jTPNaMuVJEmSJElSH/RssCrnvBa4CDi+4a3jiSf5NTMPOCaltEXD9LcCi+qmeUaTz1yQc15XN007y5UkSZIkSVIf9PLMKoCTgVemlF6bUjowpfQ54vLA0wBSSh9PKf2ubvpvAw8AZ6SUDkkpvQB4F1B7EiBl3t1TSqeUz3wt8Erg03Wf8zng6Smld6eUHptSejfwNOCU7qVaWV/ucdyPZZqDOUyVuAplMIdqlMEcqlEGc6hGGcyhGmUwh8HMqQplMIdqlMEcqlGGTuQwkHp2g/UHF5jSG4F/Bx4FXAH8ay43XE8pnQE8Nee8d930hwJfAJ4I3E0MTn24brCKlNJxwGeBg4mzrj6Zcz6tYbl/D3wU2Be4HnhPzvnH3clSkiRJkiRJE9HzwSpJkiRJkiRpNL2+DFCSJEmSJEkalYNVkiRJkiRJqgwHq7SJlFKa7DRVf78by+hHmfu9HqtYD71+vwplMIdqlKGVMrY7fb/LPAz1Mqg5tLs9SpIkVY33rFJTKaVpQM6jbCBlRziNNk2/3+9FDo3L6EVOvV5mj+qp0mU0h6nxfhXK0Ph+SimN1ZbLPPa15tCVHMaap8Vtc8xpqv5+FcpgDhP7jH6X2XqZGu9XoQzmUJ0ydPrz+p1TuzlPdJ6qc7BKpJT2AQ4DDgVuAX6Sc763vFc7Ort3s2mq/n6Xc7iYeLpkV3LKOecmddPVZXb7/VFyqlQZzaEaZRyEHGo7DH3upwahrzWHFt4Hth9rntr2WFNen1IDwO2+X4UymENb01TmYFxjeSaSU7/fH4QcbB9T4/1+lCGl8Qd7WijzlGof4+XcymdONQ5WDbmU0ouBtwCHAxcBuwK7AxcAH8s5/7LJNHsBOwNzgM8Cj6jY+73IYT/gkUAGrgG27WROOedfNSlzV5fZ7fdHyalSZTSHapRxQHJYBGwErss5b7SvNYcu57AnsBLYEriwyTy/A44lvkceA8wHfpRz3lDb+U0pbT7WNMBmVX7fHKrx/gRzWADcBTy6ajnBgz/+Kr3eBz2HIW8flXq/CjnUD8IMS/tozLmVehiEwSpyzv4N8R9wK/D/gJ2IHfYjgeuB24E7gS8DSxumuRy4AfgzsARYUbH3jwQWEzs+3crhDuAPwNnAjcBtwJXA1R3K6UNN6uZu4FfAb7q0zG6/3yynPwMLzcEcBjCHxcCZwHuAvyL6oFOJ/qlX/dQg9LXm0FoOK8r7NwAfKfPUfz9cWPJaSAxcLQdWA/8LzCr7A6c2mWYV8C1gVtXfN4dqvD/BHB4gDsTdRwwc9zunpUT7+MkUrpdByMH2UcH3K5LD04iDNNMmWJ6p2D42ybmVMtdNN60T4wZ9GavodwH862PlwxHEoMvOda89AVhDDMTcQZwZsJb4wfUU4Knl/XsYGdDKwDcq8v7DSw4bibOPupHDseVzLwHeCZxW3l9ADPRNNqelwIbS2Tyn5HQEsA54G3H5R6eX2e33m+VUq6fLzcEcBjSHm4GbiEGE1cSgyMfpTT/V7ffNoRrv138/fAR4f5l+HfBLoj3cVeb5KfH99eLyefeXz7wWeHeZ7mhgBvB35f1LymfcTAwk1N7/m/IZN5S/fr9vDlM3hxcB9wK/AM4l+suVxG0P+pHz3sBriD77duKS2s8RPwKrut4HMQfbhzmM9v5N5f3vAG8H3kxs2/+PuOpkENtHY87HAs8nDlQ9Y5R6uBZ4XsNv/82BFwAP6/c4RMvjFf0ugH99rHx4LPHj7uV1r70V+DWwI7Ad8Cdix30ZcbTrj6UBbCRGdz9I7BTfX5H3TyPOZshEZ9SNHL5LdG4biU7xrcSR66+W5U02pzeUsm4or58GfKnkdEJdPXVymd1+v1lOjfXU7zKagzl06v3vEztB9xKXaV1IDCDUBph70U8NQl9rDq3l0Pj9cAGxY1v7Hv89Mbh7T3nvCuJM3UzspN9dcr4ceDxxKeH3iTb26/JZq4H1wDvKNF8q864jdrL7/b45TN0c/ovYRu8BjiJ+mK0jzhLoR871ZZ5LDJytL/O8rqLrfRBzsH2Yw1jvbwSuKvEy4mz7B4DZLXzeVG0f9TlfROwbrC85N6uHu0tu9XkfQfS1Dlb5V/0/YDox2LEQeAVx34snA/8O7Fim+RxxNsAi4MfETu5G4My6z7iidBBVeP/88v7VXczhfGInf2VZb88ljgb+rhM51ZV5KXEU/dry/s11ddXRZXb7/TFyqq8nczCHQclhNtE+5xFnupxD9Bm97KcGoa81h9ZzqP9++CnRLmo5vYw4YnwhsT3eWeb5BTFI91FiMGt9meZTZZqbyvx7l8/cSByoORe4rqyjuRV53xyq8f5EcvgFsT0vKNP8mmiDL+xTTo1lfgJxFska4gdgFdf7IOZg+zCH0d6/ltiWbyMOwFxNDNKsbvHzpmL7aMz5bKLf3DhGPXyUOPPqtrq8zwHm9nsMop2/aWho5bip3HuJI8kfB/6beJLQdcCeKaVXEKcUfoi4YduTiA1+NTA3pXQk8E/EE4guqcj7Kxi5D0e3clhBdNQ3Ap8GTiKevnReJ3KqK/P7iCOL2xKd8B+IIwcdX2a336/L6f0NOc0DDq9CGc3BHDr4/gHEUzs/S+wsPIc4fftietdPDUJfaw6t5/Ad4jvpFOIeaecz0h52ALYmBrouJi7hWAWcnnNeRHyf3F2WtSNxacH2wI8AyjRvJ36cLCd2iDcjzvT6j4q8bw7VeL/dHG4H9iGO+JNSeg5xdsCWwPo+5HQ70X4eLDMxOLyGOMthcUXX+6DlYPswh6bvl+V+gDhh4LPEYM56YBrxHThw7WOUnLcBtiCushmtHk4izqL6LDGg9RfEZYb/wVTS79Ey/6rxBzwPOIuRm7ReR2zg7y7vTwOeRezo5sZpiEdkPo/YgW72fl/n72IOtxKnaK7pUs4J+HB5v1Y33V5mt+dPxA/4+pzMwRwGNYdE3Htg43jT29eaQwfmX0mcYdXYHr5MDMDdSlxauJHYYX828BniTMVjiEGu5cRlHq9rmOauus84jziq2/j++eO83835zWFq5vBHYsD16vL6tcQl1P3K+Y/l/ecCf12X03EVX++DlsNo21Yth9q29c/mMHQ5nAIsK9/V04mDTCvbWF6tffwNm7aPY9r4jF6v92Y538v4fe3Sut/6zwfu7feYQ9tjFP0ugH99rPx4tPUTG157LDG6ezwxojuduGnb9PL+PsBLiS/AvyAud3li3fxPJs7Wen75jL17PP9exP2cupnDk4mznurnf3IHc66VefO6nN5QOqRuLbPb8+9J3fZWl5M5mMOg5pDYtM94d4/7qUHoa82htRxeRuy41uewZd08e5ZpNyNuKnspsWN/FXFT+bOJgbFpZZo/EWcC3t1kms2B1xIDYOuavL8Z8Koyb7P3uz2/OUztHO4rfyuqlnNpQ1Vf7wOfA7FtbU4M1I+2bZnDcOQwrfz9jLjv3aSWV/c9WfX1Xp9zK33tJvP0e/yh3b9UKkZDJKV0KHGztaOJRrMdsZGvI3Z8a6/9HvhyzvnnKaWtiRHbjTnn9U0+YwdiVHc6cRpjr+fvRQ6HEvfzenIXcz4b+GLO+ed1ddXtZXZt/pLD44gfg1XZVszBHHo1v32tOXQzh/OAU3PO/wswSpvZBjgY2JBzvrDEBxGXBT6MOAtrCXEEd3rOeW1K6UnEju69wBOJSxC2A1bUfcYLibN7V5TPuI246XvOOW9IKc0uZdm5R/ObwxTMoWyjTybO9NupfMatxDber5yfRLTJnYgbGN9LDCJvqPB6H8Qc6udvlsPTiaeh3sdIX2YOg5/D0rK8e3LOf4IH+5A7gBvGW16Z/unEgZ1HEPfIq/VbqaLrvVnOTyIuF7x5lL72euDWnPMKijLN7TnnG5hCHKwaQiml+YzcQG4h0WA/RVz/eifwBeJo7F7AbsQ1wH8mNvyziNMNf0Zc1zunfMYXiSO5jyQa3L3EznCv5u9FDhuByxi58d2pHc75f4lTUncjdtb+DfhXNr3ZX6eX2e357yLuJbSIke3tNOI6a3Mwh0HPob7PsK81h07n8H7iwSi3Ae8kHmW9tm6eZwLvIo6o7kIcfV1PHHl9BLF9/gY4uW4nfgfKk5HKDvPLymdMr/uMdcRR4UcQlyD+H/BfZSe81/Obw9TNIRE3V/98znleBXKeRgzu3JHjnq5MgfU+iDk0zp+Is0ffaQ7m0DB/u9NDnHW0C/FdOZHP6HfOrfS1iRjj2cgAcLBqyKSUHkOcsrl/zvnWhtdeXP4eCxxO3CtjS2I0+FHE44SXEzu6xxGPLf0ScePvS4inE8wlbtL+POKGddO6PX/O+fSSwzXAfxKNudM5bE+Mbr8R+B/iB0Inc35MXZmvIXY2phNHKV5EdEydXma3519MDCy8BXhnzvnTdfX0TuKsgHeZgzkMaA6b9Bk55wd60E8NQl9rDq3lsC/lyCkwk/i+eETJayWxIzy7zPuTsqwvEpcYzgQWEPfOeDnxkIILicGvdxFn+J5T5v0VcDoxULxd+Yx7ie+jy8pr04hBtnOJweNf92h+c5i6OWxFPNhni/IZfyS2y1/1KeffEvc//HAp81yi7f2yzHdhBdf7IObQOP+CMt2cuhy2Jw7c3lPmMYfhzKGxDxlv+vuBvyTOUN6M+L7/BvAmou+p4npvlsPTiBMZtqF5X7ugTDcj57y6NnBF3FpmdUop5ak2+JMrcC2if737I3Z4rwAObvYasB+wjNgJfhrw+vLeBuI0xPnEUd01xGjwT4lHfd9UptkP+CBxOuXpPZr/zcQ9PzJxo7xu5DCPGM1eAnyzCzk3lvl95fPWEh1qN5bZ7fkvJp6skYnLWzapp7LtmYM5DGoOjX1GL/qpQehrzaG1HL5c4n8ivi9Wl7/LyzxLKZcUlHnOIgbINpRlnEvcu2oDI/cKuofYZi8htt+rGRkQ2xn4JLEzfBNxhP3mMv08YpCstrxezW8OUzeHjzLyqPnr+lDmxvnvKNNuIAZ55pVyrQOeQQwGV229D2IOjfN/l5Eb8O9cvuu/SDzNdF/iagRzGM4c2upDGsrc2G9Vdb03y+HzZZprad7Xfhf4SMM8exEHfB/Z73GIifxNQ8PmovLvF1NKB5UR1wdfI0abLyBGdv+Ucz6NeJrAIqJR3EmM9M4gBlIeQTw+ezeiA9iMaIQ3AHv0aP6XEDfJXU08JakbORxPjIRvB+zRhZz/3FDmjwD/RexkbN+lZXZ7/jXEZS3riTMHXlNfTymlg8zBHAY4h8Y+oxf91CD0tebQWg7/WF7/efm+OKtM/9Myzzrivj+3lXkfCxwIXFaW8Xlgf2Ig9VXEZQjbEGdiZEbO1Nqd2IZPAg4gLj9cm3P+BnFp7grga8B/E+1zA3HEuxfzm8PUzeF5xEGI24lB2l6XuXH+m4izLO8o791MPA5+GnHmwpcquN4HMYfG+fcnvvM3A05KKb0COIK4L98NOeefmsPQ5tBWH9JQ5sZ+68SKrvdmOTyX+O5/Oc372v2BExrmeQewLud8B1OQg1VDJue8kjgSO4N4DOY7gMcDbyuvfQl4AnAmsHVKaTpxic0G4v4wLyROMd5IXJqzjjgKnIkd5FOIneJtgfnl+vk/1s3/9y3Mf2Dd/K0s/yqiQX9plBw6UYadic5gWZdy/jhwCPD9nPM9KaX9iMeOfpEYHa/Cem53+R8lLmP8BHFmwEai8/we0RH3ogyTXQet5GA9WA/Nlt/YZ4zXT1Vxvfejr+32OhiUetiSuCTwnnJZ477AaTnn95ZlnlLyu4L4fj+FGLy6I6W0N3FpwUpgq5zzfOKJmsvL9L8hBlrvLvMsJXay9yOO0N6UUjq4TLea2Nn+YlmXK4ijwd2e3xymbg4HEYMoRxJ9eq/LvMn8Oef/IA4u3Ffm24q4gfTDid9JMyu43gcuh1HmX19ymUacHXYi0V9vmVL6tDkMbQ4T6UPeWF9m4Eo27bequN4b539Tmf+PY/S164l7YZ5Tpn0j8C/AZ5mq+n1ql3+9+2PkHmXTiJvJfpc48nIpcX3sn4lLEVYR19H+mjitcDGxM7J1mf9IYsf5meUzbiN2vC8kGtZ64gvzzIb5tyKum63N/+yG+S8aZ/7xln8WcSpoLYdaXp0sw1/1OmfgqRVbz+Muv2H+bYjt7Tdl/suJMxm6WoYOr4NtiMtlazlcRlxqYz1YD+Otg2fx0H7KvrYH2/84yx+Ueqif/mGMfM/X5rkC+D7wsRJfXeKvEDvJh5fpX1rWxd4l3hF4DzFodjnwY+KsrQ3lM74HnFE+Y0/iiPsrymds02T+nzTM//0252+2/HZz6EYZJrsOhrUefk5s97v3ab03zv+PtTITg9nvK+U7gegbqrje282hitt/K/PXcrii5LGBGKC4sqL1MF4OlzfkYD1MbB2004fUlreeuN/TZcQlc2uB5xNXsFR1vTcufz3wuHH62vXE/sAj6uN+j0NM9M8brA+ZlNIWOefVdfFewN8BjyaO8i4hdsCPIUZx7yTODPhmzvm+ctT4BcArcs7PLfE/E6O2c4gR3lVE49qTkZsjfzfnfF9Z5ouBl+Scn1viNxH30DibkcsX1hBfuGMuv8z/RmLkeA5xSuWtxJHtvyBGsTtRhiW1+buU8yriR83uJb4V+E7d/H1dzxNc/t8Dr8o5P7sufiPx1MMDelSGCa+DMv0LgZfXzf/CUoafMbJtWQ/WQ+Py72qSw+uJew3Nwb62l9t/4/IHtR4avy9eALyakUuzjiAOVN1ellP7/42l7u4kdqY/lHNeVz7nK8SlH58BXktcvkjJb5/yGcuISxZrn/G/Oef3lDJ8mbhx/cmlDE8mBtmWjFGG/805v2cSy/8J8IEcT0TqVxkmuw6GqR4uqdB6/1/gfTnnjWX5jyPuY/fcKbTeG+d/HNE/P7fXZejgOngc8aTTvy3l2JHYbh4+xerhacS9nT5FnPlyKXFGrfUwuXVwSZvLu4y4R/N0Rg7grKvweh8v5wf72vq6yjk/sVk8FTlYNSRSStsTN5N9DnHJwcXEju404myhA4nR8juIe2nsRzTou4gGtQ+xQ/9L4sfJcqKhry9f7NMb4mkAuTw2s8TbEUeGn9NkeftPZvllGd0oQ7dzbqyHx1Z5Pbe4fIjR/Prtrddl6Ng6yDnf0WSZ1oP1MNryG5dnX1uNbW8Q66Fpuy/l2Srn/ABFSmkW8WNpe2JH+e6ynK1LfBFxP6v7y/SbEz+qzs05/7DE/83I5Yi3lTLtRvQzt1GeCleWP4O4kfwfyvwziCcvrSvLW0LcTPaRZT0tKevjnDL/eMu/lbix7K5l+bcCfwLm1a2PbpehE+vAeujPem/M+cH1XqY/uZTnh3X1UKX13rj8TdZ7Wd5nSnm+XVcPVdv+x1r+JvVQFy8i+sLtKlgPzZb/YD3UxUuIQYvte1SGYaiH8ZZ3BnFSwM2MtPn1xNUr209wmb3MeQbwdeLAWK3vbdbXfqZhngdjpigHq4ZESul04Gji0o1rgKcQI7Qby2s/J27WtjNxSuIFxFHmnYmjxvOJmwTvRTTIzxPXxi4jnjpyHzFqvIx4LPequvi3xGmKX24ow2jLa2n5OedPpZROIHaUfpVzXlHiTpZhty7nPKNJPbygSuu53eXnnHOT7a2nZejAOtgcOIr4IvpszvnjZdu6i7j0ZlUPymA9TM16OBX72r5v/02WP+j1UFvm44gbsB9NHPG+gpGzdh9OnM11GXGPq6OJyw0uJ3507EVcOvAH4qzFecQZX9NyzmvhwZ3h+rjZgNnjgBePUYb6eFLLr0IZJrh866EaOf+BuIzpscR3zTZ9KEPH1kEVytDp5dcNIE6ZeqjFwKGM3R9bD5NbB60sr7GvnVLrvXH5Yyxzk35goOQKXIvoX3f/iBHfB+8n0PDal4gd4R+X+JnEzVyXEqO3z6+LNxL3+FhE3JRuI7EDPgf4NDFCvZTY6W6MP0M0uE8RR5hryz+N+HHXbHnjLf8PZRlX1ZWhNk2zMk2kDN3Mubbe19TVw4/KZyys0HpuZ/kfA/6SOHLw/LptbR3wujGWWaVtrb4e7iifdU2Zpn5bsx6shzGXV7fe1xP3N7Cv7c32P8z1sJA46vol4qbqDxBH8JcTO7+XlXgVcdlT/TTLiEG8ZaUslxIPZPkYcfnHFsSOdS3evCGeTlzW8qfy9/GGz7+DuLfWaHEry59B3AvsY8DTG+JelWGy68B66M96b8y5sR5+TJwxUuX13rj8+vX+VOIHcNW3//GW/9Oy3Frf9g8NOTYuswr10Lj8xnr4mPXQ9Xpotrz/YOy+torrvXH59ev9GTTva1Pd7/tN4kH463sB/OtBJcc10tcDu5R4OnHN8fXEY26fRewIL6ub5iOloZxQ4s+U+JvEzvYtpWEtJp5cdAOxI56Jo1SN8XXEjnsmnnjwL8Q1uhuJHZ3G5Y23/MtLvJrY4fhOWUYmHt/brEztlqHbOT+nrPeldfVwP3Fq579VZD23u/wLiR9WmTjl9gDgZSX+u1GWWbVt7TkN9fDL8v5a4tp268F6GG0dNC7vQGJHJxP3BrSv7c32P6z1cAsjO71fJAbKLi7L/AVxb4z/K5/11br4AuKpwF8hnkS0seSwuC6HBcSDDf6vvL+UOLuxMf4VMaD3GWKH+t+JnfavE4/nXlnKW1teYzze8v8f8J/ltYvLa2c2xN0uw2TXgfXQvAy9zrlZPfyo4uu9cXnN6uEPxI/gbUpfUrXtf7zl19dD7UDVFSWuaj00q5cvEwdGavXw0RLPHmWZ1sPk18Emy6tb73cQ+8LN+tqqrffG5a8sn1u/3hv72v9H3Jvu03V571YfT+W/vhfAvx5UctxLYCHw1tFeKw3oXuDEuvfvAS4o8UnEjvZ3iMGuM4hLcRYRlyvcQexE3z9KvJA4IrymxH8q/18+yvLGW/5sYsf8/tJ4LyCOHK8FftChMnQ154b1XquHBSWv7Suynttd/lWMnBGwqNTLVcQZPaNtW5Xa1hrqYbtShqvLNKNtW9aD9dBsefXr3b62d9v/sNbDPcRgVa0MdxL3RLqJeNLQx4kd35+U+GO1uCxzM2IA7H5i8OwbjNw8/irikoR7yjx5lPjOuvh1pWznEX3RZsTAwErikoxm8XjLX8DIgNx3iScq3V/iS3pUhsmuA+uhP+u9cXnN6uEB4sfniRVd743La1YP95X4hz0qQ6fXwcfr6uFtjAzU38PItlW1emhWL/XL36UsP9e1ceuh8+ugcXm7Efd8zIze11ZtvTcuf3FZ/q2M3tcuYOQAdW17exWwsd9jEJ34q11Tq8F2G7HD+9GU0ldTSn9FbOi11/6buL72WuAjKaWvEk8vuBs4vMRXEY3pthxPHHgfseP8y/L/rxGnQ/7XKPE3iR1uyudeXt5/2CjLG2/5C4gzw84hHsv5c+Iyi58Ab+hQGbqac0rpWcT1yVfV1UOt47qnIuu53eV/F9iJ6Jh3KmV5LHA+o29bPV3v4y2/1Mtq4sflvYw87eMcRt+2rAfrodnyrinr/Y/Y1/Zy+x/WevglsCVxqeP7iKOvjyDub7WO+PGxjDgCexDx2PFlwNNTSocT98pYRLS3y8tyriL2F1aU96eXZSxsEm9Rpn0YMUD2z8AhxEDb10oZTgJmEmd4bhK3sPwtiCPVWxADh48hdvC3LPPd0IMydGIdWA/9We+NOTfWwxeJAe0HiLOVqrbemy2vsR72Ku+vIw7yVHH7H3X5JT61lH9Vzvlk4EXEvsDNxLZVtXpotvza3wZi4PPHwJHAqpTS4dZD19pD4/J+AMwiBpwe0tdWbb03Wf6bgLeXetjA6H3tFsTA3MKyzB+X+vskg6Dfo2X+9eaP+KH3FmJH90JiZ/Zk4hTPO4gjvj8Dfk9cm7ycaHDnNcSnEx3vD4kOa6/y2QcQDWmfceIPEDe7u4QYZa59/l0NyxstPh14a/3yS3771ZZX4kQ8balWhvr4g2U9XNZQhn7lfHr57Fo9/F+pm7c2LHOsnCabY6dz3od4PPwFxEh//bY14bruwzpotq31dXtvcx3sS7T7Wj38nPHb+FRp81VuD405f4WHtvHx2kMVtv9Nci7r/cHltdAe+r39N66DrzDY33lHEu18KbED/MqG+MXEj43fEU8eOq2shz+U+CRix3gNsG/53GeVeDZx+4AflDyeMEr8P2WZt5f3ftlQhteUco8Wj7f8r5TlvaYhfgGxs96LMkx2HVgP/VnvjctrVg9rgRfX7TtXbb03Lm+0evgtcaC6itv/eMt/cVneC8vyD6zFjGxbVauH0erlHKIv/1OJf89IG7ceOr8OGpdXu0Tvt4ze11ZtvTcuv7beT2D0vrb2WuP2t2e/xx868TcDDYUcTwj4z5TSb4DnEU89OZzY8b6MuDZ2V2JUd3PiS25Zmb0+fjRxv40riQ7r5pxzTik9k7hkYdE48YeJHwsfJ0aIVxMjysuIhso48SbLzznfVKZ5FnBjzvnGkm9OKf11/Wt18QdTSt8hbry3bylDP3N+dKmHK4jLnHYudfM3jXmOkdNkc+x0zotyzp9PKe1aPmstsW1Nuq77tQ5yzjellFKOR8r2dXtvYx3cQLT7nevWwVaTWQ9UpM2P08b73R4ac96Xh7bxCeXdz5zLNA8ur4X20O/tv3Ed1OphUL/zjiaOtv6QeMDCS4gBryXEDvHDiEG4m4ibwL6MOIvk7rKs2jR3ASemlNYDxwC/zznPSylNJ76bDso5X5hSuniUeCHxI+E4Ylu/r5Th1cDWxGDhWHFt+euIG8jWlp/K51+dc/5qqevDSvzjEt/aUIanNpShluMd48TdXgfLie1jW+J+aveX15a2sR5qy1wwStztdVBfD7W4Vg9LJ7gt9DrnxvZwP/CclNJs4jLeKm7/jTk/pD0QA9Vv7WLd92IdHJNSelLdOvhByfFWqrH9j7cOribORnobMfCzipG+tlvbQjfWwWj1sJRqtodmOd9MPIVvtO+8Km7/jTl/uaz30b7zrs45XwhcWDdNbb9tSks5Ru00gEpDfhQx+rqOuBTiauJJAi8gvpznEdfXHlemuadMd0yTeA0jDe4JxCUKC8t0TyZ28P/YJF5SlrEzsLDsVG8B7E10GrcQR6KnlfKOFkOMIt9S/j+N2EffmFLavHzen/PIozy3IB79/efyOS8kntpwLrGD8vQSX9ennCFOH92D+IFRy6k+zwdzrM8p53xdB3PsZM63E9dK35BzXl9XLzcydt2OVde9XAdnl+W9gPjCmF/Wx1FtrodOb+8trYOc83Wl3e9JXK9+W8lxBTFIfdsoeVexzUO0j90YGSipcntolvPmxJk2a9m0jVd1+2/M+U/ED7bakcWFxBHCvyR+4LW6Hnqy/Y+yDq4mTpl/VamHQf7O25w4kvrnlNIs4oDHkSX/PYjLCNcSfdsjGblJ657AjqNM89/ELQOWEoNovycuPfx0C/FxxOWQdxHb4p6M3Ih+6xbilpefc/5U6fsap5lNnEm+vPw15jhe3O118MgyfSYGT3eczHoYJe7ZOhijHtrdFnqdc7P2MGW2/zHqoerbf8vrIOd82yjbVmW2/zHiC4n94+U0b+NVaw+jroNJ1EOv20Njzq1851V2+29c/hh97SbTMAAcrBpgKaV/IZ5AtDkxUrwTsSMOsdO9ObEzvZ7YgV5LNN5W4vuJHfTx4h2IH2n/SzwZYx1xs7icc16XUtq3nbjk9Rjg+lw23jLNTcSN5HKTuHE99Dvn2mUqN9Tl1CzvsXLqVo6TyXkxcUT/yznna9ut2wqsgx0YvX30ZXtvdx2UbelNwBv7vC1MZh2M1j6q3B4ac144Sg5V3v6btYflxABJq+2hr9v/EH/nzSQG155GDGxdR5xB+SRigHoxMYh2KDHQuBy4qGGapYwMzC8hdq6nl3luJAaMtweeSAzmLWqIryN28teVedeVQbVHls/dPOd8Z0ppBrEzveUo8XTi3o1b18Ub4cGzx7YvdbmuMS71+xTg2aUs15Ycn1rKe1spS2POPV0HpQ4fVnJcVuKW1kPdNrAjcW/L9fVxKW8318H1xDb2OOAIYjtcRPzIekx5v/bX7rbQq5zHag+V3P4b1wGwYZTt/5klh5sZ6Qc6Vfc9WQclz62Ip5jV4qps/62ug9WlPBtLv7498R0xY4y6r0ofUN8+jicOvFxOfLdVtT005nwFcaDqyeXvLkb/zqvU9t+Yc8nzwbwbvwPL+9sD99VtC5vEU16uwLWI/nXnj2jAbwT2L/GeRAe6nGg4/0ocNf4F8ZSB1eXvly3Gq1qMbyduFre6vHYl8USGQ0oZryNuetdKPL2U+aryGQc3iWvzfLIu/kD5fypl+UMfc27M4dCGuDHv0XLqVo4TyfmD5bW1REf9iVKmydR1r9fBhxi7ffRje293HaRS5rcQgyWJOKtqonXfjzY/Xvuoanuoz/lENt3+x2vjVdj+x2oPtZxaaQ/93P4b18GelCfwMdjfed8mdo4vLMveSAygLS7xBkaeWDTaNKPFtxCXKIwXrycur3w3cVbbQcQO+PRSFw/GZX9kvPjA2ry1/fG6ek2jTPPtUvYL2syxV+tgGjHIM71uP63d9XBg3eelJnG318F64hKalcRN/0ebZjLbQrdzbqc9VGX7b8y5WXuo+vY/Xs7N2kfVtv9W1sG1tXXQYl33uz200z6q2h4ac57Md15V+oAH2/gY7SHVr4eGMYBN4qn81/cC+Nelio3R5UXAjBJPr3+tNKZlxOhxbZqvl8Z2eIfi/ymN+YelA7mfkUdtXkzsXK8vncqfW4iXEDv9mbgh5gVlmkzsuDf7zDuJHwxriGvHn1vWwUrgr/qQ80RyGC/udY6N8f8jtqX7iJsB31LKtp64WfBEcur1OqjlsISJt49Ob+8TaR9XlGW+uJTpuaVMf92luu/0OuhE++h3m7+XGLRdTZz+3Yk23uucJ9Ie+r39N66D2nfeRuI+W4P6nbecGBBbC7y8/N1MHDS4n+iPv8rIjvtiYnDvZuKJQfeWz7x9nHjZGHFtx702YHdXiecC/048rXBjKe9E4j2Je43UPvOdxP146pdxInFU+xXEWXWvKLn/to0cu7kO9mohh8mup26vg5uJG/feQ2xLt/DQbanb28Jkc55oe+jn9t9Ke/j3ksMxLa6HXm//4+XUifZxIv3tA24mniiZGRnUPaXNHPrdB7TaPqrUHhpznga8nzhQO5nvvH72Aa20hz2JSwUPZeRgyINxv8chOjqm0e8C+NelioWjiUtRjq177TjiiO2xxOURlxI7us8o7z+nNLLvdij+LPED4r9L4zmL+DFxN3G65W2lkW9sMb64dAi5vPe70kFtJHbsm81zLfHjZSPRCZ9dlr+6TzlPJIfx4l7n2BjvVJZ7LfEErOOIjvreSeTU63WwE3FEZDkTbx+d3t4n0j5uZOQpJD8hrnPf2EYO/W7znWgf/W7z/0rsIK2ZRA797gMm0h76vf03roOfEPer2NhGDv3e/ifSHu4uOdXyXkwMjj1APLr+h2W6LzbGpczblfluIQb4JhIvJn7cfIUYXFtPDJbNIS4feYBoExsnGC8uOeaybi8rdZ0bllE7or4V8RSmn5eydCLHya6DVnOYzHrq9jpoZVvq9rYw2Zy70R56nfNY29LLW1wPvd7+O9XG+7n9t9I+lgHnEwcy7illubvNHPrZB3SiffS7D5hOPIVx4yRy6Hcf0Ep7WEycNbaBuGQW4v6i6/s9BtHxMY1+F8C/LlVsXO86l9ixfX5pUI2vfbs04Fo8szT4+zoU/wNxzfDppUx/z8gTEv6VuNFtJu7t0Ur8w9KQryeerlGLryIGSJrN86MS318afC2+t085TySH8eJe59gY174YLmfk9NVzJplTr9fBdOBbbNoe2m0fnd7eJ9o+7iJ+MJ9X4tvayKHfbb4T7aOvbb7kfd4kc+h3HzCR9tDv7b9xHdTWe/32P4jfeZeXeX7aENfKcCzRH1xL7APUxw8r05xGDKr9bbsxcfP2i4hBtZeWct1S3l9KHGm+l5Gd8YnE84kd/zXEPZJ+RQwS3kPcjPZW4qj5+jLPjaVMK4EfTzbHDq2DVnKY7Hrq9joYc1tqcT1MNsfJ5tzR9tCnnBu3pV8QAyJriEHsKm7/nWjj/d7+x4ufUcrzVeLG2G8mzni9vo0c+t0HTKp9UI0+4IyyzOUTyaEifUAr7eH8kmN93hcAP+j3GETHxzT6XQD/uli5ceO37xA3fvs18B7iZpI/IEb/15aN+8zSiK8mdvQv6HB8AvHI0LeWDuPJxKUlRxE73k+cQJzK52wEnljyHWueX5fyzCvx+Yw8HfH+0jF0Mj6BeNpifc7Tm+QwuyGHxmnaiX9TylDLcX6X67VZPW9N/GC6E3hyC/XS6Xiy9Xwi8H3iC6a+fXS67rsZP4No94sYOSrT7TbejTbfbhuvYpvvdBvvdR9wIu1/X3Sjv59Mvb+ZybfpbvT/7cajbUsvJdr5POISoMZ4JrEjvLKsm6c3xMcAs8o8500g/kvikoT7y+vb1MVvBD5M/IDeOMH4vYwcJf9WQ/w54gbA7yWOMGfiqPbpdXGtzE/oYjzeOmglh06spwsa1kEtnki9NovH25a6vS00y7ndem+lPXSy7ruRc+O29IcS31/y70bdd7MP6ET76HcfcAxxA/IHgJNK/1yLO9XGe9EHTPb7ogp9QK09dKqN97oPaPU77w8N89TiI/s9/tDx8Yx+F8C/LlQqTKv7/87Aa4DvEjvUy4hTBm8jLomYz8i1tvcRI9SdjmvLvIa4F0oiflz8E/EDYty45PLyUeLpY8zzshLvBry+dCxrGbl53n3EqHWn46V1Ob+7rj7+CVjaGLPpDfRe1jDNqDFxjXLtM3YGXkv8SFnbg3odq57fPVq9dDrucD3X6m0p0T7O62Ddt1yvk43LtnA6cSSmF2180m1+Im28y9vCZOr9/3Wqjfe5D5jI98Wk+/t243HqvRNtul99QCvfF/9EnE35O+KedRcQO8nnEzvANzFyxPcC4sjsCmKnt36auycZ30Fc+vhE4BvAwlK+GcQDOG6dbMzIzXQ/XIsbprmDuDfL5cTZZyuJtnBdXZm7GdfWwRMa1sH0Jjl8qCGHB6eZZHwHI9tCbR10up7H25a6vi1Mst7vAF5C9Gd31+XQ1brvdMxDt6Un0d2673ofwPhtvNPbQrf6gCOJe1YupPNtvNt9QCe+L/rdB9xL59t4z/sAWv++SPXxoP3NQAMnx6My9yYa6/qc81dTSt8E/oLYwNcRpxFC/LjZnmhkDyNOW+xkvAbYhZGbzV0K7E408unEk5vGjVNKdxM/CD4BbFce+3xfiR9eltU4z32lHO/IOS9JKX2lfMahxCj1emKnfnPiNM5uxLfnnK+tq567gX9rjHOtt4lHmN5Zm2a8uNR1Lef1OeevpJQgOu0FXazX+vhe4maAM4gfzouIL7im9dLpuAP1vIZoE9Pr4nuI68EPGqNuW677duu13bi4E/hkSmm7svwfE2e8zO9gXXetzU+kjTf5jH63+dq2c3VdvUyqjfepD6i16Xa/LzrS37cbN9Y7cFpK6U7iSTrn0Lk23bM+oBjz+6K4izgD7nzgb4AXENv844ij5MvKfF8u8dVEuzqaeLJQbZo7GuZpN679WJlJXPb45lK+DcSZZd+fSJxzXp9SejLw/bo29CTifmTTgA1103yLuGfIcxi5d9xhpUxLSzm7Gd/VsA7+peSwoZTve3U5zC451GwseX9vInHdMr4JnEpsC7Wj+5Op12b1PN621JVtoTGeRL3fRRzMmUkMKN9DnLV4yBjzTKjuG+tpsvE429J8YqC+W3XflT6glTbexmdUsg9oVpedjjvYB3Ti+6LffcAqOt/Ge9IHtPJ9UT9NiXN9PGjSpvs8mupSSkcTR9afQ1ySdTkx4vsI4PDy2o1l8t2IHetux9cTo767TzC+lDhivyPRGT6sxXnOJ36ozCU6zvV1P+ymdzkm57yh1MkmcbPXJhg/BXg1I3Xd63pttm1Ntq4nsm10pJ7r1mvX6r5bMfElXN/ue70tTLbNT6SNV7bNt1N3FesDOvF9UZk+oG49dbvuu9YHjDUNcdP4bYgfI2uI+3PsQtwvZT0xaJWBxxADi/cTA3bb1U2zkdixf/gE40xc6rI98cNyHXEE+L4SzyCO0v+MuL9Gu/GdwJuIhwYsKXX+IuD3JZ5W6vwlxH1ZlqWUtiB+HF3ByJl+y4FdS/l6ES/MOa8q9bUZ8M/EvUSWNcZlmi2ItvyjuhzaifcgzqL/SVkvWxJPmLqkrMPJ1nMr21K3t4XGuN16X0sMXuxcFy8q62rfLtX9ZOu1MW62Lb2daB83E/1Ap+u+231AK22809tCp+Om21bOeSVFF7aFTvcBnfi+6HcfsBlxf8fLGLl9wSI638a72Qe08n2xGfC6hnkejBkwDlYNmJTSVcQpif9DNJ7nEZ0VxA3gTiFuDDeD6FT+RPwomdaDeCPxdKMj2oyvJy4Hgrg2+T/rchhtnv0ZOdPn98QO/FllvSwjOrr5xEj80i7GXwZuKz9iziJ+TJ2ac76jxOcCXyKOSvyyzPNV4gtivPgK4ofit8oyf0D8WNnYo3r9M3HZCjx025poXbcbT6qec87rUkq/rdVDznlpieeU9XxnG3XdtO4nUK9txWXbuqbUxxnE0Z0fET+ge93GJ9rmJ9LGK9Xm67alc4inznSijfe6DxirTfeqv59sH/COsn7OA77c4Tbdkz6gxe+L1xM7pwcSO8jLiIGr7YgfrJcQPxr2Js6Sq02zdZlmbYfjNSX3bYh7tazuQHxx+Xdf4jHda0eZ5jzifh1/JAYN18KDZ6tN62E84YHHScavJ37sHNyler6E9ralbmwLHav3ftR9Fwexu1333e4DWmnjXdsWOh33ou671AdcQme/L/raB/Sj7nt5oKp+mqGQK3Aton+d+SOeeHA75YlsDa/9LXHU/AZiZ306MZB1PTEavltF4/oyt5NDJjq2jUSnVh9fwcjRgF7E5wMfL2W4o7x2ZUPc7mdeSRyp+D5xTXitnr9PHGWrar10Op5MPXejXvqxbX2y5P6k0uafUYt7WA9V2Jb62eb7sS11ug+oSpueTB/wACP3j7q1R/XQj23pKuKI8tXEEwhrl3qsKa9/j3hC2HriaP+XgXeVaZaXz/l9F+NlHYi/W5fDCmLQ9F0N0/yWGJxfRpxJ8HXiTLvXEj+aji3xicTZmr2MtyQGUJ9C1PE/E5eH1OLXlWmObviMduOnldz/kzgr9Z1lHd3dgXq8g8lvS53YFhrjdut9RkM9bFkXv3YCddtK3U+2XhvjZtvSU4nB8P8gLm/qdN13uw9opY13elvodDzettWNbaHTfUC3vy960QecVFc3r29SD/3o/zvRxhu/L6YRZ5bvSJyBWB9P78fYQ0/GN/pdAP86WJlxKuRVwIEl3pI4Sn4VcfT10aVh31o3zb8RI+LvqWh8EDz46M9Wc/g80al9hHh0+LXEjv564oaBNxBHDTJxT5dux39g5MfzXOJGeX8u8boJlulK4lTTDPycGLC4kfghs01F66XT8WTruRv10o9t64ESzyHuS/eBEh9ZkTbci22p322+H9tSp/uAKrTpyfYBPy/5byQuKZmqbXq8bWlZWQ+1uv8dcY+6jcQTCG8nBvJOJ3bca/GXiTPvXl+WcU2F41ZyqA3w3cbIfW1yidcTP2I2ls/uR/zrUqf1Zbqjw2W8lRjg/DXxw/nbwE+JJ4O+sUf10Otto91670U99GNburPkMaP0h52u+yq08U5vC1OxjXe7D6hiG2+33teU9bChj/XQi23p18R+0K8ZafdPqY8H8a/vBfCvg5UZ1wxfBZzc5LXPlvi7xGj7Z4mj5Q8nbjx3eRXjxjK3mMP/I36s/neJP0Rcs3weMTpf28m/vEfx/USHdBcxoFCLlxA/LCb6mZlNj2Bk4gumqvXS6Xiy9dyNeunXtrWauF9FLV7Rw3qowrbU7zbfj22po31ARdr0ZPuAbYmzjW7rYT30Y1ta1zBPLf5Fqbd/Jm6S/xtgC+I+JvcCZwJblGnOI87Me3xF41ZyWMjImeOvIc4K2EgM4J9bpq/9gO1H/MdSLxuJwcQPEH31xlLWTixjWfm8DcRlpD8jBjcv72E99HrbaLfee1EP/diWVpbX7utS3VehjXd6W5iKbbzbfUAV23i79X55qYc1fayHXmxLfyQGrWp1fRhx0O6yfo9BdHV8o98F8K/DFQqvKg36z8SO/D51r91M7Oh/o26a/yR+jDxQ4XgJ8WSLVnM4lejE/qGskycSP15eRFzr/NzS+J/do/gvS/ymJvG0SX7m/cSR+f+ui3tZL18gOtxavfxPiXtRhsnWczfqpV/b1meJAarakZqvMthtvGptvh/bUjf6gH636cn2AY8DbiEui5vqbXqsbendxE7txxviT5T1sFVZL/cSlwnW4nuAfyzTPI/Y4f1QReMxcyBuZvs14rKQpxM33P92mf5LxD1YNpR1d0Yf4guJH06Z+KFVH/+AuMymE8uoDXbOaYj/oxf10Ottg/brvRf10O14tBxqP2K/RXfqvq9tvAvbQq/qpZfbVif6gEq18QnU+3Tg8cR+wTl9qofJxq1sS/Xt/oyG+Ln9Hn/o6thGvwvgXxcqNR7T/iVipHkpcerkH4kfs/eV124kdurXEiO3VY8nksM1xJGCRcDPyrqZBjyfuBFfz+Py2t8SI+Npsp9JjKqfSvxYzWUd3NywTroZX8PIEY97iQGCfpRhk3ou6+lvGtZ7W3EnPqOXMdHuf122g2Fp45Vr851u433oA6rQprvSB/S7jXYoTsQljxtL/Z9PfN/X4gXEAOMKYhB7PXG23Srgi3XTfLOsv6rGreTwXWBlWS87Ek//WkFcCvNI4FPENtyv+MMl3rsh3qODyziJaAPryjr5FfEDphbX1utE41o9nFxeq9XDqR1cRrtxu/Xei3rox7Z0DyPto77uq9KGO9HGx/uMfvcBVdi2JtsHVLGNt9sHvLrk0M966MW2VGv3m8T9Hnfo9t8MNFDK4yuvAP6F+PH6eOAA4FHEDu0NxP1I9iWOQlxDNIbdKhzfTTydot0cdidG4L8B/KI8RWFjee3TPY4/VZ4ckUs5PwVMTynlyXwm8XjW9xBfVAcQo/X7EmcdLC3TdTvenRjlv6n8f98+leEbwP8xYveyjiYad+IzehLXtftfENftz2M42niV2nw32ni/+oAqtOlu9AHNXptScc45p5R2Ju5Rdi7wCmJwdDVxSehjiO/+9cRZWTcTO7UrgBcSZ8/VpllH3PemqnErOaxPKV1Zpp1JHIlfn1JaDuwH/LaP8eNKvAggpVSLbylxJ5ZxMNHvf424b+lzyqZyK3Hfufr1OtF4PfBXxIGBHYmB7H/o8DLaLlOzegfuSCk9uI5KPGY9jDJP1eJmOfwu5/yv5UmhrwCeVfIZtDY+7mf0sQ/oRRvvRR9QxTY+kT6gaT1QjTY8kTbemEOt3dfP8zsGnINVAyCltD1xKcEriIZ8EzEyvmV5/U7imuanENcmLynxA8SXWxXjm4izLLYkjiK3m8Ni4jTWdcTlE88t8VZEx76YeCx7N+NPEB3/VsBs4lTtWhkOJX5stVumTxD3aPkdcHOOwwp3p5TeDmyZc36AIqWUyvtdiXuxjFbKMIYvEtffTzTuxGd0LS7t/n5Gtq1lxBf2gcRTcPrdhrvdxqvQ5rvRxltZZlf6gInM0+94HFOqTbcY117bPud8Z0ppDnA4cCSwE/FUoQuIbWZ/4iy875T4EGLwqzbNI4iB1arGreSwPTHIPZP4sXZrSikR/crdwOl9jj+XUtqGGMSuj1d2chnEU6WuLuvjPGL/fgfiLIREHK2fbLwFcT+cLUod7NOFZUykTF8j7mFDSmnrunUybjyReaoUp5QelnP+ZUrpwrIe/lTSqkobHi/uRD/V7z6gF228V31AFdv4pPqAZq9NtbjVaQZVan2fT1WVUvox8FjgIuIGszsRP1hnEEfd7yR+AD6Mkcd+7lnxeHWHctiqxLf3IV5d6mUz4pLM24lHlU7mM7ciToVdDPyovH4RcEvOeWNK6fnEGTbXdyMGSCn9AzA/53xTiV9I7DD0pAyjxJfnnP9cyvN84NKc8w3N4vLa3wMX5JxvHiUe8zP6HZfXfkKcSVNr98fUbStVaMO9auP9bPPdaOM97QOgsm263RxeWHKYym16vH7pQODtxODU9Yxc9rAjMYB5EzF4+gTi6Y61afYk9guunQJxuzlcQ/wo3Jf4EXN1XfxI4qmZvY5vJtrqLOLsjz+XaR4DbNehMt5MnEU5H7ihNoCbUpoJrB20A1PNyjSalNLMnPOaVuOJzNPPuPQD7yAuAa9vHzsT7aHfbbjTbXy8uB99QC/aeM/6gFamqVo8lqnexieaw8DKFbgW0b+J/xE/9u4HHlf32pHEj6hfEdcdf69McyJxnW/t2ua3VzReBfywwzms6nH8QEMOD5TX63OYyDIycS36UkZuorgK+G2ZbmN5/bwuxC8hdi42lrx+S+ww1cfdLoM5RA5HEdvB80qbP7jEH6MabbgfbbzXbb5bbbyXfcCgtIdhyOFE4Dri6PGXiCc1rSrv3wDMJc6qWE1cDvidumlWEj/oFlQ8nkwOK4gfiBf1Of4jcHFdDt+ty6FTy7iA2BYuBb5PXK7zMuKHeiIGLV5OnG3Sdly+Ux5F3Adm+7r4VZ1aRgfjXUr5di7r4FElrk3zauJMk9Hi+nmqFjcr86OJPuAc4gELw9TGq9IH9KKNd7UPmGJtfLwcXlWXwyC08U3iut/2tSczpmbxIP/1vQD+TbIC43KZ84EZJZ5R/xrxhKH7iKP+tWm+QPwAml3R+Ln1ZTaHB+MzSvwB4ukQtR+qlxBPAVlDXLudifrvdLyC+HLOpWw/ZORpFRf2qAzmEDmsKvFLiO3r/SXepyLbv228O8s8g872AYPSHoYhh7VE3WfiaXinEfes2kgcWb+f+BF1Sfn3fuAPxI3n30D8uF1HnJFW1dgcWo83Ej/W7yC2pY3EWZY/IO7btpEYQP/RBOJnETddrv/Mszq8jG7Hg5rD74CrgB3Kd8IXiW3iR0R/0O/tvyrtYxhymEwfMKjtYxBzeBZxxt47gJml3e9ZHw/6X98L4N8kKzBOQb0NeHXda0fVXgM2J47c3g+cUN5/ErEjfFZF482JG0Tfbw6bxJ8kTvv9YolPA+4i7t2zjrjB9IqyjG7EN5fX1pW/G4jToFcSX9i9KIM5RA63EV9m60sOV5f3hrl9DEMOne4DBqU9DEMOq4inANXmeYC4+e3lxKO7TybuX3FS2TYa4+nEUxQXE5eSVjE2h9biW4k2/8/EWXeZeAz674mBy41Ev/HABOM15fNWAx+sW8bG8v9OLKPb8aDmsLH8fZ7Y//8lcDZxGVoVtv8qtI9hyGGyfcCgto9BzGENsb9wD3BE2cY+Avy532MQPRvr6HcB/OtAJcLpxI7uB4Btmrx2GfEj6sFpiB84qyocX9JQ5mHP4YPA8cS1/m8mbkb5lBKfSNzM+atEB/faLsSHAB8q8ekN8ZeIH+rdLoM5RJk/WOJziC+wP5T4bIa3fQxDDh+ks33AoLSHYcjhEOJS0wy8tzEu3/kHEdvK7cR91OrjQ8s0HyMGuF9d0dgcxomJJ1/+mrjH3/HEY83PJQYx/0z88FlRpl88wfh6Yvu7u8RXl/cvJfq8Tiyj2/Eg5nA5cYblAyWfDcSgxUbgExXZ/m3jXS4DnekDBrF9DGoOCxm5T2mtH7gfeGu/xx96Ns7R7wL416GKhH8nRtnXEqOx/8LI/VQyMdr+k9IgNpYN/f8qHp9oDqN+5utLPS8kjrTMAI4t0zys23HZ5p7WEPe0DObAw4jTgG9nZNv6MXHqcG1b+WnF4xOJ05zr24c5tLbME9i0D0hsum20FZftvzGe1Gf2Oh7wHF5EbF+LiB8sjfEhxPf/JcRR+Pc1xK8mHk2+sW6eqsXmMH78emL/bh3R7h9WF+9AbDvnEj94tp9A/ETi8pQNxA/h+vjYsszJLqPb8aDm8P3y/iXEtvAR4Bds2g/0e/vvd/sYhhwm2wcMavsYxBzq2/32DfGW/R576NXfDDQQcs7/kVL6HvDXxPWt7yd+PP0v8dSNA4AnEz90riyzHVXx+N3mMOZnngV8GFiVc84ppScSOy4PdDsu5TiyxKvLUzrW97IM5sADOedPp5R2InZk7gFml23jPOIL74kVj99J7OT9nLj06THm0NYyzwI+mHN+IKWUiL7iFznn+8eLAWrbUi0uy6mPaeczex0PWQ57EEfTFwGfJR7XvYxyWSgxkL2YuP/Fqxk5A/Nm4lHv9dM0zlO12BxGjz9XF7+SOFPvKcSNqpcTl41eT7h7AvFFxNH/83LOZ5XtdWWJzynxZJfR7XhQc1hFXHr+LOLm6m8CtibqfRFwKvFk2sVTIP460T4+QAy23Uw81bhKZaxqDqfUxa8kBs+OBr6Tc74rpXQuZVvKOS9vEl9I3bYFkFKqxeeUeLzP6Hc8LDlcSPxemZdzXg5ckFKqxasYEg5WTWEppYOI008fTtngiUuD7iSOxNdG4XcgnpjxTeLLbmbdPFWLryQ6/Vpe5vDQ+AHih+t0YD9gt5TSnWU5c4F/7EJ8PvHkkQeAV5fO8j7iUpRXAg/0oAzmEDn8BvhRznHKBfAN4t5Ft+acV6eUtiN2zKdPoXhFyXPzCpVpKuSwIue8HqAMZJ5JnMk5blycRRzJaxq3+5m9jocsh7OIdn9jSukLxI+kI4kDIFcRR/QfQZxlfQNx2UgmBr72b5jmoIrH5tBa/P6yjNOA/y3byebEZUKnTDYmbEE8cevklNL0nPOGTi6j2/EA5nAKsQ/zDuIpdF8lvnsOIM6yvY7YTzy44vG/E/vFnyH2Z2eZw4Ti9xH9wWnEGd0AWxLbzsmjxFvUxymlxvdb+Yx+x8OSQyvTDLza4w81xaSU3gW8lBisuJW4XnoX4rTBrYlLAjcjBkg2J47Abqx4fKs5VDJeUnJ6WMlpcXmvSmUclhxmEEdc/4c4ErsHcFfOeSVASmmviseJeIrJXTnnlY1xRco48DlUoQzm0HIO04C/AR5JfK/cRPRhW5Z4EXH5yePrprmDuKfZlnXzPLIssoqxOUwsvpW4NGRjXbw1sV+4bALxEuJ75Z+IM3W3ApYSg2SLO7SMbseDmsNtwL05519TpJRmAE8Azi8DXA8nDmhsnCpxzvnelNL0KpVpKuaQc763brvYDJiVc543kbgTn9HvuApl6EUOw8LBqikopbQDsWP0bznn01JKewBPJ27Ouog4JfhLxKmjc4nBku2IGwGeU9F4W+KMkbebQ8vxjBIf2MV4W+DMktONJacv1+XUizKYw8i29VbiqOo9xBH7TxA7tT8ibu79W+Lsve+W3KoU/4I4Q/Ba4lKGb5cyn90QV6nMUy2H7xPbzFjxz+pyOB/4Vl0O9XE7n9nreFhyuJi41PsZxD0qlgB7ETfeX0MMXqwFdiN+0K4ifpDvRfz4XVPinSsc32wOE4pvqYvXljLsMol4Ufl3j7ocbqnLoRPL6HY8qDncRBy0uheYQ/T7a4Gbcs5ryg/YfSocJ2I/Zh9G+qwZFSvjwOcADw52VKZM5jD6NKqTK3DjLP/a+yNurndhs9eAw4jLC1YBl5X3DiN2ejcA+1Y0frDM5lCpeBByGqQc7mHkvkUbiR8tFzHyaNs1xOnoaysY317KupGRx/GuLPGV5mAO5vCQHFYS969ZRtwH7RRiwGoFcAXxJNCfEpf+X0UMgJ1G/Jj6EbCAuExscYVjc5h8fCFxL5TJxL+vy+FK4sEu9Tl0Yhndjgc1h1OIfuMa4hKwa4j7mH4NeC5xKdj9xEG5v61gvAsj91o9o5T5ow1xv8s4SDmcBTy/SVyfw9cbcqjF431Gv+NhyWEX4lLvZxO3loA4aP1gPEx/fS+AfxOoNHghcYbIsSWeTjwZ6EbiCQJbEF9od9ZN89LSEE6uaLxVfZnNoTLxIOQ0KDksJZ4kMg3Ykbjf1grix+11xA75A8T9UaoY/4r4ws5l/X+SOOq90RzMwRya5rCcaOe1aW4mzqy4h+jLatO8vSF+G7FfcCwxyH1NhWNzqEZsDtWIm+VwNzEgei4jB6pWEY+330DsKywn+pMqxjcSfdb9jBxsW0cMyJuDOZjDQ3O4kTgT+0rg4eV3wOuJS377Pg7R83GPfhfAvwlUWvxwnUMcfTm02WulAdxYF29FnEJ8dRXjkkNjmc3BnMwh4s2Iy4V+SezU1sf7E5cELiV2Yj9bwfijxE73RqKfOqkuNgdzMIeH5nASsUObiSfC1ccfK/3aXxH3q/wTcS+j40t8SYlnEGf53A88tWqxOVQjNodqxKPk8ILy/rvL+48j+pJ1jJyFuZy4TDhXML6MOFtsY4kvIvrAtWx6JmmVymwO1SjzsOZwGXHbj7V107yTGNT+XL/HIPoy7tHvAvjXZoWN3GfsKcSlQuuI04T/Bvh74sfthrKRf4K4VGAdcDlxVPfaCscrgTeYQ+XiQchpUHL4a+IJYG8hjrYeXvqD6cDhJbfdKxofUuKDS5kPKvGh5mAO5tA0h5cQO6unEvcnelFDvAfRTywizsx6fEO8M/A8Ygf4CxWNzaEasTlUI27M4XjijIuXlH7hUcCHiDOr/pK4FPD+8hlVjL9A/FjfSFz6VB+/pNRRv8toDuZQpRy+QAxY189Ti3fr9zhEX8Y++l0A/yZYcXHt6iOBZxI3Yr2HkRsxLiHuaVB7bSlxKcEDUyQ2h2rGg5DTVM9hdcnhOuJm648mdnATcV38rVWMS5/1PuIypscAO9XF5mAO5vDQHKYBHyB2Uu8gBqcXEH3BcmLweiExoP1e4kzMNWXakxumWVrx2ByqEZtDNeJmOfw1cABxG5BvAQtKP5KIQa1LKhyfRJzdtkV5rTGuQhnNoRplNIeRaf5U95t/k3jY/magKSOltBPwMuL6++XED9c7iS+42v+nET9wH03clDUTlxRtSdwPo2rxekaedPPEkos59D8ehJwGMYd7iKcCbSB+yL6aONqyObBnyenXFYt/nlK6i7hX2FbADwjbE089/LE5mIM5bJLDWuJR9QuJo63zgVcSZ4duSdyrbgNxwGpr4F+JweybiT7uTUR/Vz9N4zxVi82hGrE5VCNuzOGnjDyk4QLgXwhbEldWfK3C8d+VeE1Kaav6uEJlNIdqlNEcNp2GhmmGUu2SMk0BKaUzgIOJa9yXEzu3ryaOwi4hdnKPJx7Tu75Mk4gvv6rGc4izw8yhWvEg5DTIOexdprmLuO/FDhWO5wNPJc4eWUL8eH+KOZiDOYyaw8XEDutjiYHqLxCX+29B/JA9hHB+XZyBs+umeSJxAOuyisbmUI3YHKoRt5rDHTnn+QAppW2Jge0XAd8p01UmzjmvTSk9EnjWGLE5mIM5lBggpbRFwzybxAyhaf0ugFqTUkrEPanennP+cM75v4CPED9sP0E8xvgFxGnC/0wcSboZ2K+8X9X4GcQPcXOoVjwIOQ1yDq8D3lim2Ze4gXNV4ycRP8w/XnI43hzMwRzGzOFZxD1rvkLsp51BnEn5aGB1zvn3xFnWLyb6hwXAy4FX1aYhHn/9hKrG5lCN2ByqEbeRwxNTSoeWH+afAl5LDG5vUcEY4D+IAfsDSpkb436X0RzMoUo5QFwO+PW6ganGePj0+zpE/1r7I86ouhx4UrPXiMsMrgBur00DHEacRvz1isablNkcKhMPQk7mUI3YHKoRm0M14lZy+CfijIrVxGDW70u8hniC6ZeAz5fXVpRp/lDilYw88noj8XCGxRWMzaEasTlUIx6EHJrl9LmGnGp92VTJyRyqEQ9LDl8izqA6Cziy7A9sSVwCfMhExg4G5a/vBfCvxYqKDfZ3wDzi7ItpTV57e2kEtXgr4kaN91c0nkbcf6u+zObQ/3gQcjKHasTmUI3YHKoRt5LD6cBc4CrgHcTlwBuIe+39ltjJ3UDs5H4BOK18fiYek/1b4ibsG4id5SrG5lCN2ByqEQ9CDoOYkzlUIx6WHG4gLhvcSNxQ/enEfSrX9nsMot9/09CUkHNeBbyHGKD6H+L04B2JSwG3BL4J/CNx6vDDyjT/RFwTv7ai8WuBvyB20s2hOvEg5GQO1YjNoRqxOVQjbiWHHYFdgEuBU4ijsTcTlwU+lngSMOVz/4a4PcAWxM3YzyrTTCfuf3dVRWNzqEZsDtWIByGHQczJHKoRD0sO2xIHtK4CXgF8nzjj8hsMu36PlvnX3h9x08XvEUdZ7yRutv5jYoR2I/F46znECO1G4hTECysezzGHSsaDkJM5VCM2h2rE5lCNuJUc5hD3qrqFGLg6lLhs8EVlmr8t+wQvaYg3Z+QpoYdXNDaHasTmUI14EHIYxJzMoRrxsORQm+bw8tom8TD/zUBTSs75CuBFKaWdgGcDf0vs2H6CuCTwgPLahcSo7L3EvTFuqHhsDtWMByEnc6hGbA7ViM2hGnErOWwJfBn4IbAw57yh3IR1NXGgCuKMrNXA/6WUpud4etD08trlZZ6qxeZQjdgcqhEPQg6DmJM5VCMelhxq01xeptmWePjCJQw5B6umqJzz7cDXgK+llKblnDeWt85r8hpTLDaHasaDkJM5VCM2h2rE5lCNuKUcim2AD+ScNzTEG1uYpuqxOVQjNodqxIOQwyDmZA7ViIciB0TKcaqZJEmSKiyltBmwobaT2xi3Mk3V4yqUwRzMoSpxFcpgTuZQ1bgKZehFDsPMwSpJkiRJkiRVxrR+F0CSJEmSJEmqcbBKkiRJkiRJleFglSRJkiRJkirDwSpJkiRJkiRVhoNVkiRJkiRJqgwHqyRJkiRJklQZ/x8w85Euv1WSKgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1440x432 with 1 Axes>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt_params, opt_loss = train(G,depth=32,transverse='uniform')\n",
    "loss, counts = loss_function(opt_params,G,return_counts=True,transverse='uniform')\n",
    "pairs = evaluate_max_cut(G,counts)   \n",
    "print(\"Max Cut(s): {}\".format(pairs))\n",
    "plot_histogram(counts,figsize = (20,6),bar_labels = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max Cut(s): [('01011101', 52), ('10100010', 52)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x432 with 1 Axes>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt_params, opt_loss = train(G,depth=32,transverse='nonuniform')\n",
    "loss, counts = loss_function(opt_params,G,return_counts=True,transverse='nonuniform')\n",
    "pairs = evaluate_max_cut(G,counts)   \n",
    "print(\"Max Cut(s): {}\".format(pairs))\n",
    "plot_histogram(counts,figsize = (20,6),bar_labels = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Isosceles triangle\n",
    "It turns out that the uniform transverse field performs poorly on a isosceles triangular graph regardless of trotterization depth. Probably the uniform field cannot push the state from some special uniform superposition. The non-uniform field works perfectly for this case even with fewer layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 3\n",
    "V = np.arange(0,n,1)\n",
    "E = [(0,1,10.),(0,2,10.),(1,2,1.)]\n",
    "\n",
    "G = nx.Graph()\n",
    "G.add_nodes_from(V)\n",
    "G.add_weighted_edges_from(E)\n",
    "\n",
    "# Generate plot of the Graph\n",
    "colors       = ['r' for node in G.nodes()]\n",
    "default_axes = plt.axes(frameon=True)\n",
    "pos          = nx.spring_layout(G)\n",
    "nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=nx.get_edge_attributes(G, 'weight'))\n",
    "\n",
    "nx.draw_networkx(G, node_color=colors, node_size=600, ax=default_axes, pos=pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal parameters = [1.58930594 1.89948025 0.88985173 0.82862606 1.28734364 1.44247903\n",
      " 0.38024053 0.51945377 0.65600073 0.19499105 0.02444793 0.71902883\n",
      " 0.78105748 0.88738923 0.77564172 0.03712809 0.11715924 0.75174777\n",
      " 0.23969551 0.25525701 0.85808195 0.95021234 0.56213966 0.17923034], optimal loss = 15.4319\n",
      "Max Cut(s): [('010', 11.0), ('100', 20.0)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt_params, opt_loss = train(G,depth=12,transverse='uniform')\n",
    "loss, counts = loss_function(opt_params,G,return_counts=True,transverse='uniform')\n",
    "pairs = evaluate_max_cut(G,counts)   \n",
    "print(\"Max Cut(s): {}\".format(pairs))\n",
    "plot_histogram(counts,figsize = (8,6),bar_labels = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal parameters = [ 0.5891035   0.91995814  1.930137    0.47110253 -0.02629345  0.72578021\n",
      "  0.40984399  0.52026338  0.75269843  0.13024709  1.26333661  0.67769352], optimal loss = 19.9342\n",
      "Max Cut(s): [('011', 20.0), ('100', 20.0)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt_params, opt_loss = train(G,depth=6,transverse='nonuniform')\n",
    "loss, counts = loss_function(opt_params,G,return_counts=True,transverse='nonuniform')\n",
    "pairs = evaluate_max_cut(G,counts)   \n",
    "print(\"Max Cut(s): {}\".format(pairs))\n",
    "plot_histogram(counts,figsize = (8,6),bar_labels = False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "QML",
   "language": "python",
   "name": "qml"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}