community/terra/qis_adv/Multi-Qubit_W_States_with_Tomography.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../../../images/qiskit-heading.gif\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" width=\"500 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deterministic Creation of Multi-Qubit W State Systems\n",
    "\n",
    "## _*Benchmarking Competing Algorithms by Quantum Tomography*_ \n",
    "\n",
    "\n",
    "***\n",
    "### Contributors\n",
    "Pierre Decoodt\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction\n",
    "\n",
    "A generalized $n$-qubit W state system can be written as$^{[1]}$:\n",
    "$$ |W_{n}\\rangle \\; = \\; \\sqrt{\\frac{1}{n}} \\: (\\:|10...0\\rangle \\: +  |01...0\\rangle \\: +...+ |00...1\\rangle \\:) $$\n",
    "\n",
    "A specific compact algorithm allows the deterministic creation of W states of any size $n$., as described here:\n",
    "\n",
    "https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/community/teach_me_qiskit_2018/w_state/W%20State%201%20-%20Multi-Qubit%20Systems.ipynb\n",
    "\n",
    "This algorithm is inspired by Diker's theoretical proposition$^{[2]}$, but is characterized by a linear rather than quadratic progression of the number of gates needed when  $ n $ increases.\n",
    "\n",
    "In many cases, the QISKit compiler is so smart that it allows safely the programming of circuits without taking into account the architecture of the different final real target devices. This is the approach that is presented here with realization of a compact multi-qubit W state generation program.\n",
    "\n",
    "For the creation of such states, an other approach is to use a general algorithm of arbitrary initialization, as described _at the end_ of the following tutorial:\n",
    "\n",
    "https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/qiskit/terra/summary_of_quantum_operations.ipynb\n",
    "\n",
    "Therefore, why worry about using a specific algorithm, sophisticated on the theoretical level, while a ready-made alternative, valid for any entangled state, is at our disposal?\n",
    "\n",
    "For this reason, it seemed interesting to compare the two approaches by using quantum fidelity as a benchmark, with the help of the methodology proposed by Smolin, Gambetta and Smith$^{[3]}$, described here:\n",
    "\n",
    "https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/qiskit/ignis/state_tomography.ipynb \n",
    "\n",
    "(the code to calculate the quantum fidelity used here comes mostly from this last tutorial).\n",
    "\n",
    "In the present tutorial, we start by testing the algorithms in noise free simulation, using the high performance Qiskit Aer qasm simulator:\n",
    "\n",
    "https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/qiskit/aer/aer_provider.ipynb\n",
    "\n",
    "Then, we use device noise simulation (DNS). Details can be obtained here:\n",
    "\n",
    "https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/qiskit/aer/device_noise_simulation.ipynb\n",
    "\n",
    "Finally we run the algorithms on superconducting quantum computing device (SQC).\n",
    "\n",
    "As you will see at the end of the notebook in the \"results\" section, one of the algorithms in competition clearly outperforms the other..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\decpi\\Anaconda3\\envs\\q7env\\lib\\site-packages\\marshmallow\\schema.py:364: ChangedInMarshmallow3Warning: strict=False is not recommended. In marshmallow 3.0, schemas will always be strict. See https://marshmallow.readthedocs.io/en/latest/upgrading.html#schemas-are-always-strict\n",
      "  ChangedInMarshmallow3Warning\n"
     ]
    }
   ],
   "source": [
    "#Import packages\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import time\n",
    "\n",
    "# import from qiskit\n",
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, compile\n",
    "from qiskit.converters import qobj_to_circuits\n",
    "from qiskit import Aer, IBMQ\n",
    "from qiskit.providers.aer import noise\n",
    "\n",
    "# import tomography library\n",
    "import qiskit.tools.qcvv.tomography as tomo\n",
    "\n",
    "# useful additional packages \n",
    "from qiskit.tools.visualization import plot_state, plot_histogram        \n",
    "from qiskit.tools.qi.qi import state_fidelity, outer\n",
    "from qiskit.tools.qi.qi import outer\n",
    "from qiskit.quantum_info import state_fidelity\n",
    "from qiskit.tools.monitor import job_monitor, backend_overview\n",
    "from qiskit.providers.ibmq import least_busy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<QasmSimulator('qasm_simulator') from AerProvider()>,\n",
       " <StatevectorSimulator('statevector_simulator') from AerProvider()>,\n",
       " <UnitarySimulator('unitary_simulator') from AerProvider()>]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Aer.backends() # No need for credentials for running the next cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choose the number of qubits involved and select an algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type number of qubits + enter: 3\n",
      "Do you want to use the specific method?\n",
      "    Answer by (y/n) + enter\n",
      "y\n"
     ]
    }
   ],
   "source": [
    "# Determine the job\n",
    "n = int(input(\"type number of qubits + enter: \"))\n",
    "\n",
    "# create a n-qubit quantum register\n",
    "qr = QuantumRegister(n)\n",
    "cr = ClassicalRegister(n)\n",
    "my_state = QuantumCircuit(qr, cr, name='my_state')\n",
    "\n",
    "# desired vector for a n-qubit W state\n",
    "desired_vector = []\n",
    "qr_vector = []\n",
    "n_vector = 2**n\n",
    "for i in range(n_vector):\n",
    "        desired_vector.append(0)\n",
    "for j in range(n) :           \n",
    "        desired_vector[2**j] = 1/np.sqrt(n)\n",
    "\n",
    "        \n",
    "# choice of the circuit building method (arbitrary or specific)        \n",
    "print(\"Do you want to use the specific method?\")\n",
    "W_state_circuit = input(\"    Answer by (y/n) + enter\\n\").upper()\n",
    "\n",
    "if (W_state_circuit == \"N\") :\n",
    "    method = \"arbitrary\"\n",
    "# Initialize a n-qubit W quantum state using the arbitrary method   \n",
    "    for j in range(n) :                   \n",
    "        qr_vector.append(qr[j])\n",
    "    my_state.initialize(desired_vector, qr_vector)\n",
    "    \n",
    "else:\n",
    "# Quantum circuit to make a n-qubit W state using the specific method\n",
    "    method = \"specific\"\n",
    "    my_state.x(qr[n-1]) #start is |10...0>\n",
    "    for i in range(1,n) :\n",
    "        theta = np.arccos(np.sqrt(1/(n-i+1)))\n",
    "        my_state.ry(-theta,qr[n-i-1])       \n",
    "        my_state.cz(qr[n-i],qr[n-i-1])\n",
    "        my_state.ry(theta,qr[n-i-1])\n",
    "    for i in range(1,n) :\n",
    "        my_state.cx(qr[n-i-1],qr[n-i])\n",
    "\n",
    "# Measurement circuit\n",
    "measuring = QuantumCircuit(qr, cr, name='measuring')\n",
    "for i in range(n) :\n",
    "    measuring.measure(qr[i] , cr[i])\n",
    "test = my_state+measuring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test the algorithm using a noise free simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e75c8b003dcc4cc392f22273d8a5d472",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HTML(value=\"<p style='font-size:16px;'>Job Status: job is actively running </p>\")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Date (DMY): 08/01/2019 08:35:45\n",
      "{'100': 325, '001': 345, '010': 354}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test circuit \"my_state\" : Noise free model on simulator\n",
    "backend_sim = Aer.get_backend('qasm_simulator')\n",
    "shots = 1024\n",
    "job_noisefree = execute(test, backend_sim, shots=shots, max_credits=5)\n",
    "job_monitor(job_noisefree)\n",
    "\n",
    "noisefree_count = job_noisefree.result().get_counts(test)\n",
    "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n",
    "print(\"Date (DMY):\", time_exp)\n",
    "print(noisefree_count)\n",
    "plot_histogram(noisefree_count, color=['purple'], \n",
    "               title=str(n) + '- qubit W state, noise free simulation, ' +  method + \" method\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OPENQASM 2.0;\n",
      "include \"qelib1.inc\";\n",
      "qreg q0[3];\n",
      "creg c0[3];\n",
      "x q0[2];\n",
      "ry(-0.955316618124509) q0[1];\n",
      "cz q0[2],q0[1];\n",
      "ry(0.955316618124509) q0[1];\n",
      "ry(-0.785398163397448) q0[0];\n",
      "cz q0[1],q0[0];\n",
      "ry(0.785398163397448) q0[0];\n",
      "cx q0[1],q0[2];\n",
      "cx q0[0],q0[1];\n",
      "measure q0[0] -> c0[0];\n",
      "measure q0[1] -> c0[1];\n",
      "measure q0[2] -> c0[2];\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# QASM from test\n",
    "QASM_source = test.qasm()\n",
    "print(QASM_source)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 782.6x379.26 with 1 Axes>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Draw the circuit \n",
    "test.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### State tomography and quantum fidelity in noise free device simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "344f68575fd54da1aec764c942034874",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HTML(value=\"<p style='font-size:16px;'>Job Status: job is actively running </p>\")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Date (DMY): 07/01/2019 07:51:45\n",
      "Tomography 3-qubit W state on qasm_simulator , shots: 1024 , method: specific , mode: noise free simulation\n",
      "Fidelity with theoretical ideal state\n",
      "F = 0.9858785193549825\n"
     ]
    }
   ],
   "source": [
    "# Execute state tomography using noise free quantum device simulation\n",
    "\n",
    "# obtain the final state vector\n",
    "backend_stvct = Aer.get_backend('statevector_simulator')\n",
    "job = execute(my_state, backend_stvct)\n",
    "my_state_psi = job.result().get_statevector(my_state)\n",
    "\n",
    "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n",
    "qubit_set = []\n",
    "for i in range(0,n) :\n",
    "    qubit_set.append(i)\n",
    "\n",
    "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.\n",
    "\n",
    "# add the state tomography measurement circuits to the Quantum Program\n",
    "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n",
    "\n",
    "backend_tomo = Aer.get_backend('qasm_simulator') # for simulation\n",
    "\n",
    "# take 1024 shots for each measurement basis\n",
    "# note: reduce this number for larger number of qubits\n",
    "shots = 1024\n",
    "mode = \"noise free simulation\"\n",
    "my_state_job = execute(my_state_tomo_circuits, backend_tomo, shots=shots)\n",
    "job_monitor(my_state_job)\n",
    "my_state_tomo_result = my_state_job.result()    \n",
    "        \n",
    "# extract tomography data from results\n",
    "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n",
    "\n",
    "# Quantum fidelity\n",
    "\n",
    "# reconstruct experimentally measured density matrix \n",
    "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n",
    "\n",
    "# calculate fidelity of fitted state:\n",
    "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n",
    "print(\"Date (DMY):\", time_exp)\n",
    "print('Tomography',str(n)+'-qubit W state on', backend_tomo,\n",
    "      \", shots:\", shots, \", method:\", method, \", mode:\", mode)\n",
    "F_fit = state_fidelity(rho_fit, my_state_psi)\n",
    "print('Fidelity with theoretical ideal state')\n",
    "print('F =', F_fit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From here, you need credentials:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "IBMQ.load_accounts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ibmq_16_melbourne           ibmqx4\n",
      "-----------------           ------\n",
      "Num. Qubits:  14            Num. Qubits:  5\n",
      "Pending Jobs: 9             Pending Jobs: 92\n",
      "Least busy:   True          Least busy:   False\n",
      "Operational:  True          Operational:  True\n",
      "Avg. T1:      55.0          Avg. T1:      49.0\n",
      "Avg. T2:      74.1          Avg. T2:      25.4\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "backend_overview() # you may skip running this cell if you want"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ibmq_16_melbourne\n"
     ]
    }
   ],
   "source": [
    "backend_real = least_busy(IBMQ.backends(operational=True, simulator=False))\n",
    "print(backend_real)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare noise simulation corresponding to a given quantum device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "device:  ibmq_16_melbourne\n",
      "noise model prepared for ibmq_16_melbourne\n"
     ]
    }
   ],
   "source": [
    "# Prepare device noise simulation (DNS)\n",
    "\n",
    "device = backend_real\n",
    "print(\"device: \", device)\n",
    "properties = device.properties()\n",
    "coupling_map = device.configuration().coupling_map\n",
    "prepared = False\n",
    "if device.name() == 'ibmq_16_melbourne' :\n",
    "    gate_times = [\n",
    "        ('u1', None, 0), ('u2', None, 100), ('u3', None, 200),\n",
    "        ('cx', [1, 0], 678), ('cx', [1, 2], 547), ('cx', [2, 3], 721),\n",
    "        ('cx', [4, 3], 733), ('cx', [4, 10], 721), ('cx', [5, 4], 800),\n",
    "        ('cx', [5, 6], 800), ('cx', [5, 9], 895), ('cx', [6, 8], 895),\n",
    "        ('cx', [7, 8], 640), ('cx', [9, 8], 895), ('cx', [9, 10], 800),\n",
    "        ('cx', [11, 10], 721), ('cx', [11, 3], 634), ('cx', [12, 2], 773),\n",
    "        ('cx', [13, 1], 2286), ('cx', [13, 12], 1504), ('cx', [], 800)\n",
    "    ]\n",
    "    prepared = True\n",
    "    \n",
    "elif device.name() == 'ibmqx4' :\n",
    "    gate_times = [\n",
    "        ('u1', None, 0), ('u2', None, 60), ('u3', None, 120),\n",
    "        ('cx', [1, 0], 340), ('cx', [2, 0], 424), ('cx', [2, 1], 520),\n",
    "        ('cx', [3, 2], 620), ('cx', [3, 4], 420), ('cx', [4, 2], 920)    \n",
    "    ]\n",
    "    prepared = True\n",
    "\n",
    "else :\n",
    "    print(\"No gate times yet defined in this notebook for: \", device)\n",
    "        \n",
    "if prepared :\n",
    "    # Construct the noise model from backend properties and custom gate times\n",
    "    noise_model = noise.device.basic_device_noise_model(properties, gate_times=gate_times)\n",
    "\n",
    "    # Get the basis gates for the noise model\n",
    "    basis_gates = noise_model.basis_gates\n",
    "    \n",
    "    print(\"noise model prepared for\", device)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run the algorithm using device noise simulation (DNS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e068a86300d84b77a43063bbac94badf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HTML(value=\"<p style='font-size:16px;'>Job Status: job is actively running </p>\")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<bound method AerJob.status of <qiskit.providers.aer.aerjob.AerJob object at 0x0000025F1FB74B00>>\n",
      "Date (DMY): 08/01/2019 08:37:23\n",
      "{'011': 33, '110': 26, '100': 268, '001': 303, '010': 310, '000': 39, '111': 17, '101': 28}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Execute test using device noise simulation (DNS)\n",
    "\n",
    "backend_noise = Aer.get_backend('qasm_simulator') # for simulation (DNS)\n",
    "\n",
    "shots = 1024\n",
    "mode = \"DNS\"\n",
    "job_noise = execute(test, backend_noise, \n",
    "                       noise_model=noise_model,\n",
    "                       coupling_map=coupling_map,\n",
    "                       basis_gates=basis_gates)\n",
    "job_monitor(job_noise)\n",
    "\n",
    "print(job_noise.status)\n",
    "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n",
    "print(\"Date (DMY):\", time_exp)\n",
    "noisy_count = job_noise.result().get_counts(test) \n",
    "print(noisy_count)\n",
    "plot_histogram(noisy_count, color=['cyan'],\n",
    "               title= str(n) + '- qubit W state, ' + mode + ': {}, '.format(device.name()) + method + \" method\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### State tomography and quantum fidelity in device noise simulation (DNS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "94ac876bc665474caf2dc9404348e887",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HTML(value=\"<p style='font-size:16px;'>Job Status: job is actively running </p>\")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Date (DMY): 07/01/2019 15:17:10\n",
      "Tomography 3-qubit W state on qasm_simulator , shots: 1024 , method: specific , mode: DNS of ibmq_16_melbourne\n",
      "Fidelity with theoretical ideal state\n",
      "F = 0.796346002046457\n"
     ]
    }
   ],
   "source": [
    "# Execute state tomography using device noise simulation (DNS)\n",
    "\n",
    "# obtain the final state vector\n",
    "backend_stvct = Aer.get_backend('statevector_simulator')\n",
    "job = execute(my_state, backend_stvct)\n",
    "my_state_psi = job.result().get_statevector(my_state)\n",
    "\n",
    "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n",
    "qubit_set = []\n",
    "for i in range(0,n) :\n",
    "    qubit_set.append(i)\n",
    "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.    \n",
    "\n",
    "# add the state tomography measurement circuits to the Quantum Program\n",
    "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n",
    "\n",
    "backend_tomo = Aer.get_backend('qasm_simulator') # for simulation\n",
    "\n",
    "# take 1024 shots for each measurement basis\n",
    "# note: reduce this number for larger number of qubits\n",
    "shots = 1024\n",
    "mode = \"DNS\"\n",
    "my_state_job = execute(my_state_tomo_circuits, backend_tomo, \n",
    "                               noise_model=noise_model,\n",
    "                               coupling_map=coupling_map,\n",
    "                               basis_gates=basis_gates)\n",
    "job_monitor(my_state_job)\n",
    "my_state_tomo_result = my_state_job.result()    \n",
    "\n",
    "# extract tomography data from results\n",
    "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n",
    "\n",
    "# Quantum fidelity\n",
    "\n",
    "# reconstruct experimentally measured density matrix \n",
    "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n",
    "\n",
    "# calculate fidelity of fitted state:\n",
    "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n",
    "print(\"Date (DMY):\", time_exp)\n",
    "print('Tomography',str(n)+'-qubit W state on', backend_tomo,\n",
    "      \", shots:\", shots, \", method:\", method, \", mode:\", mode, \"of\", device)\n",
    "F_fit = state_fidelity(rho_fit, my_state_psi)\n",
    "print('Fidelity with theoretical ideal state')\n",
    "print('F =', F_fit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results using device noise simulation (DNS)###\n",
    "\n",
    "The following results were obtained by device noise simulation on the qasm simulator, with the ibmqx4 as model, using 1024 shots for each tomographic circuit. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.xlabel('Number of Entangled Qubits')\n",
    "plt.ylabel('Quantum Fidelity')\n",
    "plt.axis([1.4, 6, 0, 1])\n",
    "plt.grid()\n",
    "plt.plot([2,3,4,5], [0.788,0.734,0.628,0.542], 'mo-', label=\"Specific Algorithm - DNS\")\n",
    "plt.plot([2,3,4,5], [0.773,0.682,0.386,0.148], 'cs-', label=\"Arbitrary Initialization - DNS\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run the algorithm on superconducting quantum computing device (SQC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b15f9a04b95b427a8acb7aba0d3b953a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HTML(value=\"<p style='font-size:16px;'>Job Status: job is being initialized </p>\")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<bound method IBMQJob.status of <qiskit.providers.ibmq.ibmqjob.IBMQJob object at 0x0000025F1FD42128>>\n",
      "{'011': 35, '110': 39, '100': 200, '001': 318, '010': 264, '000': 124, '111': 21, '101': 23}\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdAAAAFTCAYAAACJeV12AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xl8FeXZ//HPBQEEBSGYSgIiIBYCCAZwh4gLClqXB6m4V1tqtdblsf6wUluxVdr6iEUtLtW21lpbUbC2Ki1SFKqi1oDIJpWGRUiwbAJlC8Tr98c9iSfhZDvJyUnI9/16nVcyM/fMuWY5c83cM3OPuTsiIiJSM81SHYCIiEhjpAQqIiKSACVQERGRBCiBioiIJEAJVEREJAFKoCIiIglQAm2EzOwNMxtbwbCuZvZfM2te33HJ/sxsiZkNi/6fYGbPpDikBs3MupmZm1la1F3hti4VM7MZZva1mO57zGyjma1vqPuIuvx9mNnVZvZmXUyrMkqgCTKzZ8ys0My2mdm/GsqP3N3XuPsh7l4MVe+AzOxvZjYuprtztAOL169TTWKJxulZg/J1urM0swvM7INoHW00s7+bWbeY4X3M7M9mttXMtpvZbDM7sdw0WkY/7I/NbIeZrTKzX8dOpzLu3tfd36ireaotM+sXrfONZhb3IXAzu8TMlkXz+28zG1rfcUrtuPtId/8tgJkdAXwX6OPuncrvI1LBzIaZ2dpUfX9dUQJN3E+Abu7eDjgfuMfMBqU4pkTMBU6N6c4FPorT72N3X1+fgdVGlLifJuw4DgW6A48An0fDjwLeAhZFw7KAPwGvmdnxMZN6gbB+L4umMwDIA86olxmpe3uBqcA34g00s+HAz4BrgLaEdZ9fb9GlSMkZ7wHqSGCTu/8n1YEccNxdn1p+gF5AIXBxDcYZTkhUW4FfAHOAsdGwCcAzMWW7AQ6kRd1vEBL4e9H4LwHp5csC9wLFwG7gv8Av4sQxFPgMaBZ1PwJ8C/i0XL8nK5iPnlHsW4GNwHNR/7lRHDui7x4DdABeBjYAW6L/u0Tl48YK9AZeAzYDy6u7jIHRwAeVDP8d8Gqc/o8Cr0f/nwnsAo6oxbaxCjgzZr2+ADwHbAfmAwPKlf1/wIfRcvsVcDgwIyo/C+gQU/5KYDWwCfh+7HdVI66e4ee/X/+3gW/UcB6HAWuBccB/CL+FC4FzgH9F6258TPlmwPeAf0exT423/Va1rUfDzweWRNvwG0B2zDAHesZ0PwXcUy7m24H10fZQ0u+7MfNxTcz4rYD7gTWE38djQOtqLqNzgKXRelwH3FYujvGE388q4PLqfidwAfABsC1aniNilttYvtiGPyf8rp6Ks4zTgd8ABYTf5Z8qmIerCQedP4+Wdz5wctT/k2iZfa2q2IGDy8X0X8IB7IRoW3g6Wk5LgMEx08uO5uuzaNj5McM6An+OlsN7wI+BNxP93VZ720/2FxzIH0Ji2RltjPOBQ6o53mHRih4NtAD+F9hHzRLoOqBftDFOKylfQdmxlcTSKtqYc6LuxUCP6IcS2++qCsb/A2Hn3Qw4CBgSM6z8DqwjcBHQhnB283zsj7V8rNG8fUI4G0oDBhJ2Mn2rsYx7EJLxz4HTyq8bwk7zmjjjnRati4OAnwJzqvie7wEvVzJ8FWUT6N6Y9X4bsBJoEVP2HULS7EzYIc0HcqL1NBu4Kyrbh7DjyY2GPRDFnXACBZoDRdE8rSDs2H9BFUmCkAT2AT+M5uubhIOkZ6P13DdaFz2i8rdE89kliv1x4A8JbOtfJhxoDI++d1wUd8sKtr+nKJtA9xHOtlsRduwl/X4UTe8cwu+7QzTOZMJOOj2ar78AP6nm8i4Ehkb/dwAGlovjgSiOU6N56lXVdwLHEw4qhhN+f52B3uV/S9F3rK1kf/IK4aCuQzTfp1YwD1dHsV5D2FbuISTHKVHsZxES3yHViL1MTDG/j93Rcm9OOHB6JxrWIlq344GWwOnRd5Uspz8Sku/BhG1lHUqgDf8TreghwJ1EO8JqjHNVyYYRdRthZ1WTBPrTmOF9CDu+5hWUrTCBxpS5OdrQ10b9fhrT73PgyArGfRr4JdGZZLlhZXZgcYYfC2wpF0dsAh0D/KPcOI8TJZFqLOcTox/VhuiH+VTMj3sf0dF6uXF6R3FnAU8Af6zl9rGKsgk0dr03o+yOdRVlzz6mAY/GdN9IdMBBSFZ/jBl2cLQN1CaBZkXz/j6QSTjQewu4t4ppDSMchDWPuttG0zkhpkwecGH0/zLgjJhhmYQDi7Qabus/AKaWW57rgGHxtj/2T6BFwEFx5iMtpt9/ou3ICIntqJhhJwErq7m81xBqdtrFWXb7gINj+k2N5q3S7yT8Fn5ewfe9QTUSaLTsPyemZqOSebiacCmnpPuYaDqHx/TbRPhdVxV7mZhifh+zyq3rXdH/QwkHvc1ihv8hGqd5tP30jhk2kXpIoLoGWkvuXuzubxKOpq+H0jvg/ht9Lo8zWhbhzKpkGh7bXU2x5VcTjtAOq+E0SswlnMkMBUruXHszpt8n7r66gnHHEX4s70V3nH69oi8xszZm9riZrTazbdH3tq/kbsAjgRPM7LOSD3A5UK2bmdz9HXe/2N0zovnIJZwtQziTzYwzWiZhp7CRsDOIV6Y2Ytf754QDp6yY4Z/G/L8rTvch0f/lt6EdUby1sSv6+7C7F7r7RsKZ0TnVGHeTf3FTSsl0Kor9SODFmHW6jFB9f3gF065oW8+KuoHS5fkJ4UysOja4++4487EvpntnFHcGoeYkLybuv0b9q+MiwnJcbWZzzOykmGFbovVXYjVh3qr6ziMI1ba1cQSw2d23VLN8+XWKu8dbz4kur9j7LHYCB0XXp7MI+6HPY4avJqzrDMLBQPntJOmUQOtOGnAUlN4Bd0j0+X2csoWEDRcAM7PYbsKRW5uY7ngJI7Z8V8IR2MY45bwasc/liwTzj6jfW8ApUb+5FY3o7uvd/ZvunkU4wn6kkjtvv0u4XnyCh5uvcqP+VkGsnxCqUNvHfA5x9+urMU/l4/wnMJ1QvQPheuJX4xS9mHCWWBSVOd7MutT0+yoRu96bEQ68ChKYTvltqA2hijxh0U50LdXbZmrjE2BkufV6kLuvq6B8Rdt6ASEZA2V+RyXT2Unlv6OazOdGQnLoGxPzoe5+SFUjQtj+3P0C4EuEm9WmxgzuYGYHx3R3JcxbVd/5CdE+pxY+AdLNrH0tp1NeVbHXdBsrAI6IfjMluhLW9QbCWXz57STplEATYGZfim71P8TMmpvZ2cClhGtU1fEK0NfMRkVHVzdR9sf9AZAbPa91KHBHnGlcET2G0YZwzeYFj39b+qeE64GVeRtoD1xBlECjnemGqF+FCdTMvhqTYLYQfhglcZT/7raEH9VnZpYO3FVFrC8DXzazK82sRfQ5zsyyo+++2sxWVRDXEDP7ppl9KeruTbjh5J2oyN3AyWZ2r5mlm1lbM7uRcH3nrmgZzCLcwPSimQ0ys7So3HWVnWlXYVDMer8F2BMTU028AHwlms+WhG2gyt+zBQcRriNhZgeZWauYIr8Bboy28Q5RjC8nEF9lHgPuNbMjoxgyzOyCSspXtK1PBc41szPMrAXhAG0PYXuG8Du6LPqNjqDsneU1Ep35PAH8PGab6hz99om63aJnfmNFj0JdbmaHuvtewv0P5X+rd0flhgJfAZ6vxnf+Crgmmv9m0bDeNZyvQsJNao+YWYfoN5Zb1XjVmG5VsX8KdIz2b9XxLuHEYlwU4zDgPMJljGLCwfGEqJarD/C12s5DdSiBJsYJ1bVrCUnjfuAWd3+pWiOHqrGvEq4zbgKOJpzxlQx/jXBR/0PCtaN4O7DfEa7prCfc8HJTBV/3IDDazLaY2UMVxLMz+p5WhBuGSvyDcMRcYQIFjgPeNbP/Em4YuNndV0bDJgC/japwLibcVNCacHT6DqFKp8JY3X074caESwhHoOv54qYPCEecbxHfZ4SEuSiK7a/Ai8B90Tx/TLh2PYBw7fEzwp17/xMt/xKjgVcJ62NrtHwGE85OMbPxZjajkuVT3kuEa7tbCHfRjop2qjXi7kuAGwg36hRG06vOc3VHEg5ilkTduwh3N5f4MfBPwt2zy4AFhDuk69KDhG1lppltJ2wLJ1RSPu627u7LCQd4DxO2qfOA86LaAwjX8M8jrNvLCWd+tXE74UaWd6JLELMINSpEB5H/JTwWFc+VwKpovOuiuEusJ6y/AuD3wHXu/lFV3+nu7xEO+H5O2DbnEHNGXgNXEs7qPyJc870lgWnEU1nsHxGuYeZH+4esiicD0To9HxhJWNePEG5sLFlO3yFUHa8nbCu/qaN5qJRFF1wlxczsDcKNQ0+mOpbGwsxmEhL2sjqYVhfCjvwud/9VrYNLgehsfGx05iz1yMyuIFRXxqstqmy8YYTffV1eJpB6ciA/PCwHOHc/qw6ntdbMRgIXmNkh7v7fupq2HPjcXU00NkGqwhWJuPsid7+nsSdPK3sXeOxnfC2mOb6Cadak+lrkgKIqXBERkQToDFRERCQBSqAiIiIJaNI3EXXs2NG7dq2X521FRKSR+OCDDzZGLZhVqkkn0K5duzJ7dnXbPhARkaYgPT29Wk0BqgpXREQkAUqgIiIiCVACFRERSYASqIiISAKUQEVERBKgBCoiIpIAJVAREZEEKIGKiIgkQAlUREQkAUqgIiIiCVACFRERSYASqIiISAKUQEVERBKgBCoiIpIAJVAREZEEKIGKiIgkQAlUREQkAUqgIiIiCVACFRERSYASqIiISAKUQEVERBKgBCoiIpIAJdAmbtasWRx//PEMGjSIyZMn7zf8N7/5Daeccgq5ubmMHDmSjz76CIDNmzdz/vnnc8QRRzBu3Lgy49xzzz3069ePI444ol7mQUQkFZRAm7Di4mLGjRvH1KlTmTdvHtOmTStNkCUuuugi3nrrLebOnctNN93EnXfeCUCrVq0YP348P/rRj/ab7tlnn82sWbPqZR5ERFJFCbQJy8vLo3v37nTr1o2WLVsyatQoZsyYUaZMu3btSv/fuXMnZgbAwQcfzIknnkirVq32m+5xxx1Hp06dkhu8iEiKpaU6AEmdwsJCOnfuXNqdlZVFXl7efuWefPJJHnnkEYqKinjppZfqM0QRkQZLZ6BNmLvv16/kDDPW2LFjmT9/PhMmTGDSpEn1EZqISIOnBNqEZWVlsW7dutLugoKCSqteR40axSuvvFIfoYmINHhKoE3YwIEDyc/PZ/Xq1RQVFTF9+nRGjBhRpsy///3v0v9nzpzJUUcdVd9hiog0SLoG2oSlpaVx3333MXr0aIqLi7n88svJzs5m4sSJ5OTkMHLkSJ544gnmzJlDixYtaN++PVOmTCkdf8CAAWzfvp29e/fyyiuvMG3aNHr37s1dd93FCy+8wM6dO+nbty9XXnkl3/ve91I4pyIidc/iXQdrKnJycnz27NmpDkNERBqQ9PT0PHcfXFU5VeGKiIgkoN4TqJl928xWmtluM8szs6GVlD3VzN42s01mtsvMPjKz28qV+aaZ/cPMNpvZZ2b2upkNSf6ciIhIU1avCdTMxgAPAhOBHOBtYIaZda1glP8CDwG5QB/gHuBuM/t2TJlhwHPAGcAJwHLgb2Z2dDLmQUREBOr5GqiZvQt86O7fjOn3MfCCu99RzWlMB/a4+6UVDDegELjX3R+ubFq6BioiIuU1uGugZtYSGATMLDdoJnByNaeRE5WdU0mxlsBBwJYEwhQREamW+qzCPQxoDnxarv+nQKUNp5rZWjPbA7wPPOLuj1VS/B5C1e+faxGriIhIpVLxHGj5OmOL06+8ocAhwInAz8xspbv/rnwhM7sZ+BZwprtvizchM7sWuBYgMzOT+fPnA6FVnjZt2rBixQoADj30UHr06MGCBQsAaN68OQMGDGD58uXs2LEDgOzsbDZv3synn4Zjgi5dutCyZUvy8/MB6NChA127dmXhwoUAtGjRgmOOOYZly5axa9cuAPr06cOGDRvYsGEDAEceeSRmxqpVqwDo2LEjmZmZLF68GAhvQenbty9Llixhz549APTr14/CwkI2bdoEQLdu3XB3Vq9eDUBGRgYZGRksXboUgNatW5Odnc2iRYvYu3cvEJ7pXLNmDVu2hBP3Hj16UFRUxNq1awE4/PDDSU9PZ9myZUBoTL5Xr14sXLiQ4uJiAHJycsjPz2fr1q0A9OzZk507d1JQUEDJ8m7Xrh3Lly8HoG3bthx99NEsWLAAd8fMyMnJ4eOPP2b79u0A9OrVi23btlFYWKj1pPWk9aT1VC/rqbrq7RpoVIW7E7jU3Z+P6T8F6Ofup1ZzOncC17j7UeX630w4+xzp7m9WZ1q6BioiIuU1uGug7l4E5AHDyw0aTrgbt7qaAWXeoWVmtwL3AudWN3mKiIjURn1X4T4A/M7M3gPeAq4DsoDHAMzsaQB3vyrqvhFYSXg0BcLjLLcBj5RM0Mz+HyF5XgH8y8xKrqfucvetyZ4hERFpmuo1gbr7c2bWEbgTyAQWA+e4++qoSPnnQZsDPwO6AfuAfwPfI0q4kRuAFoRnQWP9Fri6DsMXEREppbZwdQ1URERiVPcaqN7G0sR1mJGe1OlvGbk5qdMXEUkVNSYvIiKSACVQERGRBCiBioiIJEAJVEREJAFKoCIiIglQAhUREUmAEqiIiEgClEBFREQSoAQqIiKSACVQERGRBCiBioiIJEAJVEREJAFKoCIiIglQAhUREUmAEqiIiEgClEBFREQSoAQqIiKSACVQERGRBCiBioiIJEAJVBqtWbNmcfzxxzNo0CAmT5683/ApU6Zw4oknMmTIEC688EI++eST0mGHHXYYubm55Obmctlll5X2nzNnDsOGDSM3N5eRI0eSn59fL/MiIo2PEqg0SsXFxYwbN46pU6cyb948pk2bxkcffVSmTP/+/Zk9ezZvvvkm559/PnfddVfpsNatWzN37lzmzp3Ls88+W9r/tttu4/HHH2fu3LmMHj2aSZMm1ds8iUjjogQqjVJeXh7du3enW7dutGzZklGjRjFjxowyZYYOHUqbNm0AGDx4MAUFBVVO18zYvn07ANu2baNTp051H7yIHBDSUh2ASCIKCwvp3LlzaXdWVhZ5eXkVln/mmWc488wzS7t3797N6aefTvPmzbnllls499xzAXjwwQcZM2YMBx10EG3btmXmzJnJmwkRadSUQKVRcvf9+plZ3LJTp05lwYIFvPzyy6X9PvzwQzIzM1m1ahUXXHABffr0oXv37jz66KM899xzDB48mIceeog777yThx56KGnzISKNl6pwpVHKyspi3bp1pd0FBQVxq1vfeOMNJk2axLPPPkurVq1K+2dmZgLQrVs3hgwZwocffsjGjRtZvHgxgwcPBmDUqFG89957SZ4TEWmslEClURo4cCD5+fmsXr2aoqIipk+fzogRI8qU+fDDD7n11lt59tlnycjIKO3/2WefsWfPHgA2bdrEu+++S69evWjfvj3btm1jxYoVALz++ut8+ctfrr+ZEpFGRVW40iilpaVx3333MXr0aIqLi7n88svJzs5m4sSJ5OTkMHLkSO666y527NjBNddcA0CXLl149tlnWb58ObfeeivNmjXj888/5+abb6Z3794ATJ48ma997Ws0a9aM9u3b8/DDD6dyNkWkAbN415KaipycHJ89e3aqw0ipDjPSkzr9LSM3J3X6IiJ1LT09Pc/dB1dVTlW4IiIiCVACFRERSYASqIiISAKUQEVERBKgBCoiIpIAJVAREZEEKIGKiIgkQAlUREQkAUqgIiIiCVACFRERSYDawpVGLZlNEaoZQhGpjM5ARUREEqAEKiIikgAlUBERkQQogYqIiCRACVRERCQBSqAiIiIJUAIVERFJQL0nUDP7tpmtNLPdZpZnZkMrKTvKzGaa2QYz225m75rZ+ZWUv9TM3MxeTk70IiIiQb0mUDMbAzwITARygLeBGWbWtYJRTgVmA+dG5V8FXoyXdM2sB/B/wD+SELqIiEgZ9X0GeivwlLs/4e7L3P1GoBC4Pl5hd7/Z3X/q7u+5+wp3vxvIAy6MLWdmLYA/AN8H8pM7CyIiIvWYQM2sJTAImFlu0Ezg5BpMqi2wpVy/e4FV7v7bxCMUERGpvholUDO72MzOiun+oZmtNbO/mVlmFaMfBjQHPi3X/1OgUzW//wagC/C7mH5nAWOA66ozDRERkbpQ08bkJwC3AJjZQGA88ENgBDAJuKwa0/By3Ran337M7CLCNc5L3H111O8w4CngMncvf1Za0XSuBa4FyMzMZP78+QBkZWXRpk0bVqxYAcChhx5Kjx49WLBgAQDNmzdnwIABLF++nB07dgCQnZ3N5s2b+fTTcEzQpUsXWrZsSX5+qEXu0KEDXbt2ZeHChQC0aNGCY445hmXLlrFr1y4A+vTpw4YNG9iwYQMARx55JGbGqlWrAOjYsSOZmZksXrwYgFatWtG3b1+WLFnCnj17AOjXrx+FhYVs2rQJgG7duuHurF69GoCMjAwyMjJYunQpAK1btyY7O5tFixaRW52FVgvr16+noKAACMu7Xbt2LF++HIC2bdty9NFHs2DBAtwdMyMnJ4ePP/6Y7du3A9CrVy+2bdtGYWEhsP96OiOJsTek9bR3714ABgwYwJo1a9iyJWzuPXr0oKioiLVr1wJw+OGHk56ezrJlywA4+OCD6dWrFwsXLqS4uBiAnJwc8vPz2bp1KwA9e/Zk586dSV1PTeX3pPV0YKyn6jL3KnPXF4XNdgB93H21mf0YONrdLzGzY4G/ufvhlYzbEtgJXOruz8f0nwL0c/dTKxn3IsJZ51Xu/kJM/2HA60BxTPGSs+rPgb7uvryi6ebk5Pjs2bMrnuEmIJlvM4Hkv9FEb2MRkbqWnp6e5+6DqypX02uguwnXICEc/M+K/t8a0z8udy8i3AA0vNyg4YS7ceMys4uBZ4CrY5Nn5J/AMcCxMZ8/E+7EPRZYWfnsiIiIJKamVbj/ACaZ2ZvAYGB01P/LwCfVGP8B4Hdm9h7wFuG6ZRbwGICZPQ3g7ldF3ZcQzjxvA+aaWcm10iJ33+zuO4DFsV9gZp8Bae5epr+IiEhdqukZ6HeAIkLivM7dC6L+I4G/VTWyuz9HuIZ6J/ABMAQ4p+SaJtA1+pS4jpDkJxMedyn5TK9h3CIiInWqRmeg7r4WOC9O/1tqMI1HgEcqGDassu5qTv/qmo4jIiJSUzV+DtTMDjKz0WZ2u5m1j/odZWbJvRtFRESkAanRGaiZ9STcOHQI0B54HviM0JJQe2BsXQcoIiLSENX0DHQyoeWgw4FdMf3/DJxWV0GJiIg0dDW9C/dk4ER3Lzaz2P5rCHfTioiINAmJtIXbIk6/roRnQUVERJqEmibQmYQ3qpRwM2sH3A28UmdRiYiINHA1rcK9FXjdzJYDBwHPAT0JDcJfXMexiYiINFg1fQ60IGr39lJgIOEM9pfA7919V6Uji4iIHEBqegZKlCh/HX1ERESapCqvgZrZKDNrEfN/hZ/khysiqTZr1iyOP/54Bg0axOTJk/cb/vbbbzNs2DAyMjJ46aWXygybMGECJ598MieffDLTp3/RIucNN9zAscceS25uLrm5uSxatCjp8yFSW9U5A32B8MLr/0T/V8QJL8wWkQNUcXEx48aNY/r06WRlZXHGGWcwYsQIevfuXVqmS5cuTJkyhV/84hdlxp05cyYLFy5k7ty57Nmzh/POO48zzzyTdu3aAXD33XdzwQUX1Ov8iNRGlWeg7t7M3f8T839FHyVPkQNcXl4e3bt3p1u3brRs2ZJRo0YxY8aMMmW6du1K3759adas7O7lo48+4pRTTiEtLY2DDz6Yvn378ve//70+wxepUzV6jMXMcs1sv7NWM2tuZrl1F5aINESFhYV07ty5tDsrK4vCwsJqjduvXz9mzZrFzp072bRpE2+++Sbr1q0rHX7vvfcyZMgQxo8fz549e+o8dpG6VtPnQF8H4jUa3z4aJiIHMHffr1+5VskqdPrppzN8+HBGjBjB2LFjOe6440hLC8fjP/jBD3j33Xf5+9//zmeffcaDDz5Yp3GLJENNE6gRrnWW1xHYUftwRKQhy8rKKnPWWFBQQKdOnSoZo6zvfve7zJ07lxdffBF356ijjgKgU6dOmBmtWrXisssuY/78+XUeu0hdq9ZjLGb25+hfB54xs9j6leZAP+DtOo5NRBqYgQMHkp+fz+rVq8nMzGT69On88pe/rNa4xcXFbN26lfT0dJYsWcKSJUs47bTwDor169fTqVMn3J1XXnmF7OzsZM6GSJ2o7nOgm6K/Bmyh7JtYioA3gSfqMC4RaYDS0tK47777GD16NMXFxVx++eVkZ2czceJEcnJyGDlyJPPnz+fKK69k69at/PWvf+WnP/0p8+bNY+/evZxzzjkAtG3blscff7y0Cvdb3/oWGzduxN055phjmDRpUipnU6RaLN41jQoLm90F3O/uB0R1bU5Ojs+ePTvVYaRUhxnJfQ/6lpGbkzr9ZMaf7NhFpGFKT0/Pc/fBVZWraVN+dycekoiIyIGjygRqZh8Cp7r7FjNbRPybiABw9/51GZyIiEhDVZ0z0GlAyU1DlbVEJCIi0mRUmUBjq21VhSsiIhLU9DlQERERoXrXQCu97hlL10BFRKSpqO7bWERERCRGja6BioiISKBroCIiIgnQc6AiUmONvQUrkbqg50BFREQSoOdARUREElCjtnBLmNlRQMn7hpa5+7/rLiQREZGGr0YJ1Mw6Ar8Czgc+/6K3vQx83d03VTiyiIjIAaSmd+E+CfQEhgIHRZ9coDt6H6iIiDQhNa3CPRs4w93nxfR7y8y+Bcyqu7BEREQatpqegW4A4r1Meyeg6lsREWkyappAfwRMNrPOJT2i/ydFw0RERJqERBqT7w6sMrN1UXdnYDfwJcI1UhERkQOeGpMXERFJgBqTFxERSYAakxcREUlAjRKombU0s7vN7F9mttvMimM/yQpSRESkoanpGeiPga8R7rr9HPh/wBTCIyzfrtvQREREGq6aJtCLgevc/XGgGHjJ3W8C7gKG13VwIiIiDVVNE+jhwNLo//8C7aP//wqcVVd8S2RBAAAgAElEQVRBiYiINHQ1TaBrgKzo/xWEpv0ATgJ21VVQIiIiDV1NE+iLwBnR/w8Cd5vZSuAp1IiCiIg0ITVqTN7d74j5/wUzWwucDPzL3V+u6+BEREQaqoReqF3C3d8B3qmjWERERBqNGjekYGYDzexpM3s/+vzOzAbWYPxvm9nK6DnSPDMbWknZTDN71sw+ip41faqCcu3M7CEzKzCzPWa2wswurum8iYiIVFdNG1K4HPgnkAm8Gn0OB94zsyuqMf4YwrXTiUAO8DYww8y6VjBKK2Aj8FPg3Qqm2QKYCRxNeMymF3A1sLK68yUiIlJTNa3CvRf4gbtPjO1pZncA9wDPVDH+rcBT7v5E1H2jmY0ArgfuKF/Y3VcBN0XfMbqCaV5DeBNMrrsXRf1WVTknIiIitVDTKtwMYGqc/s8TkliFzKwlMIhwthhrJuFGpERdCLwFPGxm681sqZlNiM5MRUREkqKmZ6CvA8MIz4DGGgbMqWLcw4DmwKfl+n8KnFnDOGL1AE4HngXOBboRmhc8BLitfGEzuxa4FiAzM5P58+cDkJWVRZs2bVixIszaoYceSo8ePViwYAEAzZs3Z8CAASxfvpwdO3YAkJ2dzebNm/n00zBLXbp0oWXLluTn5wPQoUMHunbtysKFCwFo0aIFxxxzDMuWLWPXrvDYbJ8+fdiwYQMbNmwA4Mgjj8TMWLVqFQAdO3YkMzOTxYsXA9CqVSv69u3LkiVL2LNnDwD9+vWjsLCQTZs2AdCtWzfcndWrVwOQkZFBRkYGS5eGNjBat25NdnY2ixYtIrcWC7461q9fT0FBARCWd7t27Vi+fDkAbdu25eijj2bBggW4O2ZGTk4OH3/8Mdu3bwegV69ebNu2jcLCQmD/9XRGnO+sKw1pPe3duxeAAQMGsGbNGrZs2QJAjx49KCoqYu3atQAcfvjhpKens2zZMgAOPvhgevXqxcKFCykuDs1V5+TkkJ+fz9atWwHo2bMnO3furNF6Or3Ol3ZZ8+fPb5S/p4a2nmr6e2oq+72q1lN1mbtXXsBsVExnJjABmMYXd9+eCIwCJrj7I5VMJwtYR6hq/UdM/7uAS929dxVxvAxsdPery/X/F3AQ0N3di6N+1wI/Bw7xSmYwJyfHZ8+eXdnXHvA6zEhP6vS3jNyc1OknM/5kx96YNfbtRqQy6enpee4+uKpyib5Qu/QsLsbDQIUJlHAzUDHQqVz/L7H/WWlNFAJ7S5JnZBnQhnDWu6EW0xYREYmrymug7t6smp/mVUynCMhj/0bnhxPuxk3UW0BPM4udly8DOwlJW0REpM7V9wu1HwCuNrOxZpZtZg8S2tZ9DCB6vvTp2BHM7FgzOxZoB6RH3X1iijwKpAMPmlkvMzsbuBt4pLLqWxERkdqocUtEZnYucDvQB3DC21l+5u6vVjWuuz9nZh2BOwnXUxcD57j76qhIvOdBF5TrPg9YTbhZCHf/xMzOIiTnD4D1wK8Jj9WIiIgkRY0SqJmNJVzn/D3w26j3UOBFM7ve3X9d1TSiG43iXit192Fx+lk1pvkOtXsURkREpEZqegZ6O3Cru/8ipt+vzCwP+B7hzE9EROSAV9NroF0JL88ubwZwZO3DERERaRwSeaF2+btoAc4iXJcUERFpEmpahXs/ocm8gYRHTxwYAlwJ3FjHsYmIiDRYNX2h9uNm9h/gu4TWhyA0WnCxu79U18GJiIg0VNVOoGaWRqiqnevuLyYvJBERkYav2tdA3X0fMB1om7xwREREGoea3kS0EOiZjEAaq1mzZnH88cczaNAgJk+evN/wt99+m2HDhpGRkcFLL31Ry71o0SLOOussTjrpJIYMGcL06dNLhz3xxBMMGjSI9PT00jcNiIhIw1LTBDoBmGRmF5rZEWaWHvtJQnwNWnFxMePGjWPq1KnMmzePadOm8dFHH5Up06VLF6ZMmcLo0WXfB966dWseffRR5s2bx/PPP8/3v//90tcWnXDCCbz44oscccQR9TYvIiJSMzW9C/eV6O90wh24JSzqrrRB+QNNXl4e3bt3p1u3bgCMGjWKGTNm0Lv3F29m69o1tE7YrFnZY5WePb84kc/MzOSwww5j48aNHHroofTv3z/5wYuISK3UNIGelpQoGqnCwkI6d+5c2p2VlUVeXl6Np5OXl0dRURHdu3evy/BERCSJqpVAzawN8H/AhUALYBZwk7s36deFxXvZi1mVTfeWsX79eq6//nqmTJmy31mqiIg0XNXdY98NXE2owv0DoTWiR5MUU6ORlZXFunXrSrsLCgro1Kn8+8Irtm3bNi655BLGjx/Pcccdl4wQRUQkSaqbQEcB33D3a939ZuBc4EIza1LXPMsbOHAg+fn5rF69mqKiIqZPn86IESOqNW5RURFXXXUVY8aM4cILL0xypCIiUteqm0CPAP5R0uHu7wH7CC/DbrLS0tK47777GD16NCeeeCIXXngh2dnZTJw4kRkzZgAwf/58+vbty0svvcStt97KSSedBMCf/vQn3n77bf7whz+Qm5tLbm4uixYtAuDxxx+nb9++FBQUMHToUG666aaUzaOIiMRn8a7j7VfIrBjo5O4bYvptB/q7+8okxpdUOTk5Pnv27FSHkVIdZiT36aMtIzcndfrJjD/ZsTdmjX27EalMenp6nrsPrqpcde/CNeAZM9sT0+8g4Akz21nSw93Pr1mYIiIijVN1E+hv4/R7pi4DERERaUyqlUDd/ZpkByIiItKY6MFDERGRBCiBioiIJEAJVEREJAE1bQtX4tAt/SIiTY/OQEVERBKgBCoiIpIAJVAREZEEKIGKiIgkQAlUREQkAUqgIiIiCVACFRERSYASqIiISAKUQEVERBKgBCoiIpIAJVAREZEEKIGKiIgkQAlUREQkAUqgIiIiCVACFRERSYASqIiISAKUQEVERBKgBCoiIpIAJVAREZEEKIGKiIgkQAlUREQkAUqgIiIiCVACFRERSYASqIiISALqPYGa2bfNbKWZ7TazPDMbWkX5U6Nyu80s38yuKze8uZn9OGaaK83sHjNLS+6ciIhIU1avCdTMxgAPAhOBHOBtYIaZda2gfHfg1ahcDvAT4GEzuyim2O3ADcBNQG/g5qj7jiTNhoiICPV9lnYr8JS7PxF132hmI4DriZ/wrgMK3P3GqHuZmZ0A3AZMi/qdDPzF3f8Sda8ysz8DJyRlDkRERKjHM1AzawkMAmaWGzSTkATjOSlO+b8Bg82sRdT9JnCamfWOvqcPcDrhzFVERCQp6rMK9zCgOfBpuf6fAp0qGKdTBeXToukB/Az4HbDUzPYCS4DfuvsjdRG0iIhIPKm40cbLdVucflWVj+0/BrgKuIyQPI8FHjSzle7+q/ITM7NrgWsBMjMzmT9/PgBZWVm0adOGFStWAHDooYfSo0cPFixYAEDz5s0ZMGAAy5cvZ8eOHQBkZ2ezefNmOlQ9z7VSVFTE4sWLAWjVqhV9+/ZlyZIl7NmzB4B+/fpRWFjIpk2bAOjWrRvuzurVqwHIyMggIyODpUuXAtC6dWuys7NZtGgRuUmOff369RQUFABhebdr147ly5cD0LZtW44++mgWLFiAu2Nm5OTk8PHHH7N9+3YAevXqxbZt2ygsLAT2X09nJDH2ZcuWsWvXLgD69OnDhg0b2LBhAwBHHnkkZsaqVasA6NixI5mZmUlbT3v37gVgwIABrFmzhi1btgDQo0cPioqKWLt2LQCHH3446enpLFu2DICDDz6YXr16sXDhQoqLiwHIyckhPz+frVu3AtCzZ0927txZo/V0ep0v7bLmz59Ply5daNmyJfn5+QB06NCBrl27snDhQgBatGjBMccco/VUh7+nmuz3Pv00nNsciOupusy9stxVd6Iq3J3Ape7+fEz/KUA/dz81zjhzgUXufkNMv68CzwJt3H2vmX0C3O/uD8aUuRO42t17VhZTTk6Oz549u7azRocZ6bWeRmW2jNyctGk35tghufEnO/bGrLFvNyKVSU9Pz3P3wVWVq7cqXHcvAvKA4eUGDSfcZRvPPODMOOXfd/e9UXcboLhcmWL0jKuIiCRRfVfhPgD8zszeA94i3GWbBTwGYGZPA7j7VVH5x4DvmNlk4HHgFOBq4NKYaf4F+J6ZrSRU4eYQ7vZ9OtkzIyIiTVe9JlB3f87MOgJ3ApnAYuAcd18dFelarvxKMzsH+DnhUZcC4CZ3nxZT7Ebgx8AjwJeAQuAJ4EfJnBcREWna6v0mouju2Lh3yLr7sDj95gADK5neduCW6CMiIlIvdJ1QREQkAUqgIiIiCVACFRERSYASqIiISAKUQEVERBKgBCoiIpIAJVAREZEEKIGKiIgkQAlUREQkAUqgIiIiCVACFRERSYASqIiISAKUQEVERBKgBCoi0kjMmjWL448/nkGDBjF58uT9hu/Zs4evf/3rDBo0iDPPPJM1a9YAkJeXR25uLrm5uQwdOpSXX365dJxHHnmEk046iZNPPpmxY8eye/fuepufxk4JVESkESguLmbcuHFMnTqVefPmMW3aND766KMyZZ555hnat29PXl4e119/PRMmTAAgOzub2bNnM3fuXJ5//nluvfVW9u3bR0FBAb/85S+ZPXs2b7/9NsXFxUyfPj0Fc9c4KYGKiDQCeXl5dO/enW7dutGyZUtGjRrFjBkzypR59dVXueSSSwC44IILmDt3Lu5OmzZtSEsLr3/es2cPZlY6zr59+9i9ezf79u1j165ddOrUqf5mqpFTAhVJgWRUxUE4Szn11FNLd6Jy4CgsLKRz586l3VlZWRQWFlZYJi0tjXbt2rF582YA3n//fU466SSGDBnCpEmTSEtLIysri+985zv079+f7Oxs2rVrx+mnn15/M9XIKYGK1LNkVMWVeOyxx/jyl79cn7Mj9cTd9+sXeyZZVZnBgwczb948Zs2axeTJk9m9ezefffYZM2bMYMGCBSxdupSdO3cyderU5MzAAUgJVKSeJasqbt26dbz22mtceeWV9TczUm+ysrJYt25daXdBQcF+1a2xZfbt28e2bdvo0KFDmTK9evWiTZs2LFu2jDfeeIOuXbty2GGH0aJFC77yla/w3nvvJX9mDhBKoCL1LBlVcQDjx49nwoQJNGumn/WBaODAgeTn57N69WqKioqYPn06I0aMKFNm5MiR/PGPfwTgpZdeYujQoZgZq1evLq2p+OSTT1ixYgVdu3alS5cuvP/+++zcuRN3Z+7cuarBqIG0VAcg0tTUVVXc8uXLueGGGzjzzDOZM2cOGRkZHHvssbz55pvJCVxSKi0tjfvuu4/Ro0dTXFzM5ZdfTnZ2NhMnTiQnJ4eRI0dyxRVXcN111zFo0CA6dOjAk08+CcA777zD5MmTadGiBc2aNeP//u//6NixIx07duT888/ntNNOo3nz5vTv35+vfe1rKZ7TxkMJVKSe1aQqrnPnztWqinv33XeZMWMGr732Gnv27GH79u1861vf4vHHH6+XeZL6MXz4cIYPH16m3/jx40v/P+igg3jqqaf2G2/MmDGMGTMm7jTvuOMO7rjjjjqNs6lQXY9IPUtGVdwPf/hDlixZwsKFC3nyyScZOnSokqdIkukMVKSeJaMqTkTqn8W71tJU5OTk+OzZs2s9nQ4z0usgmoptGbk5adNuzLFDcuNPduyNWWPfbhozLfvkS09Pz3P3wVWVUxWuiDQpiTZi8frrr3PaaadxyimncNpppzF37lwAdu7cyZgxYzjhhBM46aSTuPvuu+t1fiR1lEBFpMmoTSMWHTt25Nlnn+Wtt95iypQpXH/99aXjfOc73+Hdd99lzpw5vPvuu7z22mv1OVuNRl0fvADcc8899OvXjyOOOKLe5qOEroGKpIiq4upfbCMWQGkjFr179y4t8+qrr3L77bcDoRGL22+/HXenf//+pWWys7PZvXs3e/bsoU2bNgwdOhSAli1b0r9/fwoKCupvphqJkoOX6dOnk5WVxRlnnMGIESPKLPvYg5dp06YxYcIEfv3rX5cevGRmZrJ06VK++tWvsmTJEgDOPvtsxo4dy3HHHVfv86QzUBFpMmrbiEWJP//5z/Tv359WrVqV6b9161b+9re/ceqppyZpDhqv2rTA1b9/fzIzM4GyBy8Axx13XMoawFcCFZEmo7aNWAAsW7aMu+++mwceeKBMmX379jF27Fiuvfba0jNc+UKyD15SQVW4ItJk1LYRi3Xr1nHVVVfxyCOP0L179zLj3XLLLRx11FFlro3KF+ry4GXatGl1H2ACdAYqIk1GbRqx2Lp1K5dccgk/+MEPOPHEE8uMc++997Jt2zYmTpxYb/PS2NS2MfzKDl5SRQlURJqM2EYsTjzxRC688MLSRixKrsddccUVbN68mUGDBvHoo49y1113AfDEE0+wcuVK7r///tJ3sm7YsIF169YxadIkli9fzrBhw8jNzeXpp59O5Ww2SMk6eEklNaSghhSSNm1QQwqVaczLvjHH3tg15mX/2muvMX78+NIWuL773e+WaYFr9+7dXHfddSxatKi0Ba5u3bpx//33M3nyZHr06FE6rWnTppGRkcFdd93FCy+8wPr16+nUqRNXXnkl3/ve92oVZ3UbUlACVQJN2rShcSehxhw7aLs5UGnZJ59aIhIREUki3YUrIk1OY665kIZDCVREROrFgVb9rCpcERGRBCiBioiIJEAJVEREJAFKoCIiIglQAhUREUmAEqiIiEgClEBFREQSoAQqIiKSACVQERGRBNR7AjWzb5vZSjPbbWZ5Zja0ivKnRuV2m1m+mV1X22mKiIjUVr0mUDMbAzwITARygLeBGWbWtYLy3YFXo3I5wE+Ah83sokSnKSIiUhfq+wz0VuApd3/C3Ze5+41AIXB9BeWvAwrc/cao/BPAb4HbajFNERGRWqu3BGpmLYFBwMxyg2YCJ1cw2klxyv8NGGxmLRKcpoiISK3V5xnoYUBz4NNy/T8FOlUwTqcKyqdF00tkmiIiIrWWiteZeblui9OvqvIl/a2SMnGnaWbXAtdGnf9NT09fXmm0yXEYsLH6xZP7CqAaUuyp05jjb8yxQ43ib8yxQwOLP1WxH1mdQvWZQDcCxex/Zvgl9j+DLLG+gvL7gE2ERFmjabr7L4FfVjvqJDCz9919cCpjSJRiT53GHH9jjh0ad/yKPXnqrQrX3YuAPGB4uUHDCXfOxjMPODNO+ffdfW+C0xQREam1+q7CfQD4nZm9B7xFuMs2C3gMwMyeBnD3q6LyjwHfMbPJwOPAKcDVwKXVnaaIiEgy1GsCdffnzKwjcCeQCSwGznH31VGRruXKrzSzc4CfEx5LKQBucvdpNZhmQ5TSKuRaUuyp05jjb8yxQ+OOX7EniblXdv+OiIiIxKO2cEVERBKgBCoiIpIAJdAUMDOrupSIiDRkSqAp4LrwnBI6cBGRuqSbiOqJmbUC+gP/A2wFlgArgDXuvtPMTIm1fmhZ1z8za+bun6c6jqYodtlr269bSqD1xMweAkYR3hTTAehGeCznReAhd/936qKrHjNrTjiBblQ7QjM7BMgFLgG2AB8D/wIWuXthKmOrLjNLAz5vbMteGgYza+vu21Mdx4FGCbQemFkf4B1gNJDn7pvMLAP4BvAtQlOENwNPNMSjQzMb5O555fo1J+zQG1y85ZnZbwkJ9GPCwcsRwGfAfOBJd5+dwvAqZWZD3P3Ncv0aTTI1syOArwPHAf8GlhOe1V7k7lsa6hlRbFyNaXnHMrNswusec4hqu4APgH+4+ydRmQa5/BsLJdB6YGbjgRHunht1p7n7vpjhEwlnp6e7e0GKwozLzI4m7PSWEl4T9zt3XxAz3AgNcuQAH0TNKzYY0cHLu4TmHf/p7sVmdihwMfBNwuvwfgTcQwM7IDCz3oTlvgN4BXjY3d+KGW5AC+Bs4D13r6hN6ZQws+7ANKA18E+gH6Gd6s3AXODnDbXmJTrAzXb3uTH9jPD2p+KGtJ3EY2ZHAa8S2gR/C+hNOFBvRUimT7p7+ddANghmdjjh9/qqu2+upFwLd99bf5HtTzcR1Y9lQKaZ9QRw931mlmZmB0XDnwB2Al9NVYCVuJRw5vAacCLwspm9Y2bjzOyIaEfyJcIZ9pdSGGdFzgI+dPd3ouTZ0t23Ri9gPx64ARgLHNUAd4qjgIXARKAzMMfM1pvZ/WZWEm974CWgZQrjrMjtwDrgNHe/yt0HEt7T+yxwHvCOmV2QygArMQF4I1reU8ysjwf73N3NrJmZdTWzr0a1MQ3NbYTLFOe6+x3u/j/AhcDDhET6opl9I5UBVuJO4GlghZk9b2bnRPeQlDKzrsDN5fvXNyXQ+jGX8AaZl83sYjNrFf0Qd0NospBwZLs7lUFWoBfhSPZnhDO28YQquCuAeWb2F0I7xcvcfW3KoqzYQqCrmZ0B4aUG0cFL62j488Bqyrav3FB0Jpw9PA5cAJwO/Bo4F/jYzD4E/khY9p+kLMqK9QXmuvt6M2sR1byscfefuvuRwCzguigZNbQ7pI8jtKf9KDAEWGxmK8xsvJmlR9W5XwN+5u7FqQy0AkcC8919u5k1N7Pm7v6pu/8mqgl7DPimmbVJcZzxDCbsb75LuOTyIrDSzB42s4FRmW8C17n7nhTFGLi7PvXwITRw/xxfVIX+mLBD/DLwILABODjVcZaLOQ24DLijXP904CTgO8BU4HPgG6mOt4J5OIhw9lxIeNFA6zhlPgBuSHWs5WJqDpwDfLtc/5aENqO/Qqi5+By4JtXxVjAPE6Jl2zamX4uSdUBITP8GTkx1rOXiPhL4G+HFFc0IBzJnA1MI1xE/JxzYbAb+N9XxVjAPN0ex9i637bSM/u8DrCTUDqQ83pgYswgHtddG3WmE6ufbo22pGFhEuKxxc6rj1TXQehQ1en8uoVqxB+HsrgMwB3jc3f+YwvCqFO+ag5mNAl4ADnH3namJrHLR2ea9hJu4dhGqm18C/gtcQ9iR92qo8UP8x0DM7GxgBg102ZvZIOAvhPf6TnD3P5cb3otQQ5DekOI3s3aEx81WufucmP6tCTv4QcC3CdtNW3fflZJAKxFdf55OqOL/sbv/utzwfoSb6No3sGV/MOHE4j/u/m65YW0I19FvI1zeSPmyVwJNMjPrAvSMOncQzkB3ERLoIYRrnxu9kovlqVLRs3vRXYnF7u5mdj8w2N2H1XuA1RBVXRVHj7IMAYYCJxCqiZoRqhGfdPdXUxjmfqIqTYu3/GPKTABOcvez6y2waiq5uzO67n8f4fr5RuBNQtLvA1xESFIXpy7SypXcOOQxN/1F/X8PdG6o2z2ER1eAnwCXE878ZxK2936E38IH/sWrIxukeHcJm9lThHsWhqYmqphYlECTx8yuJ9zCP4CQKPOBT4A3gBe8YV63KhWT/I1QbbXc3dfHDDfCtbl17v7P1ERZM2bWEsggHMQcBGx19x2pjSoxZjYM2ODuS1IdS2Wim+XOjD4nEK6NbgJ+RbiruyG/ehAoewcu4a7iucBPPObVig1FFGuz6MDxIOAYwmNcpwMDCVW3zwDTY3/PDYGZNSM8ax43MUW1AC8Bj7r7i/UaXLx4lECTI6quXQFMItyIkEHYgZxGOPpeR3i36dKG+CxWueS/gzAva4F5wEvuvjyF4VXJzFrHVu9U9cNsSMrH3thEy/oCwjbfmnCdc667b4t26E6oftuYwjDjKhd7G8LvdI67/yemTCvgTHd/JTVR1pzFPLdtZoe6+9ZUx5QIM2tBqPGal+pYQAk0aczsRuAKdz8hzrAhhKqVzsDxDW1HUkXy703YqdwSJf/m3sDuQjSzDoRra68QjrTfLkmcsYnUwoPma70BtdBSReyxD/dnA4Xu/lnKgo0jqjb8FWFb+ZywrRjhIGwW8Ht3/zgq26Ca94sT+1pCst9FuE/hGXf/KHURVi5KLt2B1R7n7tSGeKBeoqrYGyo9xpI8RUDb6GI9ZtYqqj7EQ8sylxMeWzkrdSFW6DLgX+5+j7tvcveP3P0X7n4RoeWk1oRHcg5raMkzcgVwOOFmj7mE58l+ZGa93L3kKPwIwvOIGakMNI7KYi9JniWxp6cuzArdRLg57hx3P5ywLU0iPPp0HvCAhUYKaEjJM1I+9suByYR2q88G7iuJvYG6AVgAPGZm55lZp9hnVKPtvp2ZjYwSVkNSaewQbu4ys3NL9qMNgc5AkyQ6i5tDuOPzf0vOcqxsw85vA39y9/tSF+n+zOxbhNvgL3b3xVGVlXvUypCFh5j/Ctzj7s+mMNS4zOwJwrWqHxIeGr+UcAduD0KLOL8GOgLfd/dDUhVnPI05dgAz+wfwors/UK5/c+AUwhnev919RCriq0xjjh3AzOYRDsrTCA1WrCE8Qzmd0HTiVjO7Drja3U9MXaT7a6yx6ww0CaKL+JsJLWoMBwrM7FfRbf1YaMHkCsLF/ampi7RCLxCqsG6x0Aj1Hg8NEDQDcPc1hLZku6QyyHiiZL8U+MTd/+PuH7r7HYS7bs+Ohk0gPNbys5QFGkdjjh1K785eDFxUcqZmXzzEX+yhWbzrgC5m9v/bO38QO6ooDn8noglBZG2MEhMkarWJySpCUAQLwUIUBTEEjApxy4CmMClUbBRMKssU4p8mRSws0oisRSyUIEGwUQQbRYJoCK7BlSjH4ndnHV/mJfHx1nvP43wwsLx5xbe7M3Nm7pw/O2u6jhLZHVZbD15E/bQfQLWsb6N64VPAJ2Z2CHgBtbZshsju1QtnZ3lDNVh3oRPvI1R3+Bt6v/gdqo2r7jnibGV7HHXoWUYH8z3ohmsrWmZcBm6r7Tvmd1gP3Fx+vgZlJPb3P4huEG6t7TpL7sVvN0oaehPYNLB/SzkHNtd2nTH3W4AXgYcH9i2gJhC/lGOnKf/I7rmEO2XM7CZgH2pD9TNKQDgPfIrunq4FbkcB9Vtv9B9gZnMoWN6HisrvL7vOokD6vru/VsduPL36w23ABe81WO/te6PuWyEAAAMaSURBVBUtBW2rZ3opkd1hNUFrHWpO8QZajvsAdeD6Ht1MPoqatN9by3OIyO4dpcTD3X2lrIJB+aDsfx29312o5TiOqO4ZQKeMqch3HnVgOYcSPXagln0/AS/7SIeNVoge/Hv+B9Hf+k/Uwu8Eqnm7UE7OReBHdz9ZTXaEyO5DlBuw51AS0S60YvEHcBrVTzZ5DkB498FMW1MXnzPAO+7e3PI/xHTPADpFygVuGd0pnep9thUtD+1HySBPufuZaqJjiBz8Yaz/Aiq9+QE46u2OcHqXoO6w2v5uuX8BLE91G1DHre3oqbq54yeyOwz7D3xnA7AHOO4NjRyM7A4ZQKeKmc2j6RiL7v75wP71qAn1x67kkGaYgeA/zn8L6n6ziJIT9rbmH9m9w8yOoSe006iW79eB79zoDQ7RjuwOV+0/543VDENsdyCTiKa5ofrIJdSt505GEkDKdw6gHpTVfUe85tGUg8HJGCi55Qu0hFXddwL/61r1j+xe/PaiBI/zKDnuGGr2fQf/TF65HvgQ2FHbd1bcL+P/BHrV0vl37e+21/adFfduyyfQKWNmu9Gsvd/RAbEEnHO9w9qIBsWuuPvTFTUvobzEP4nalz2D6t1Gp38cQGPLdlVQvCyR/SO7w79qV4+g4PMsugh+g2bJLqEGBW+5ezNF8BDbHWL7R3bvyAC6Bpi6D70CPIZamH2G5n0+hBJDnnf3r+oZDhM1+HdE9o/qXuonXwJucPfDvc/n0dLzk+hd4hzwnrvvryI6QGR3iO0f2b1PBtA1pGRWPoJqKldQofYJb7ufZsjg3xHZP6q7qX/vJnf/2tRm7aL3Lixmtgc4Dtzt7l/W8hwisjvE9o/s3pEB9H/CGmucfSUiBv8+kf0ju3eULFZzjdRaRMtwG2t7XQ2R3SG2fzT3DKDJFYkW/EeJ7B/ZvcPMDqKh1Edru/xXIrtDbP8I7hlAkyRZU0yTP/6KeCMQ2R1i+0dwzwCaJEmSJBOQ01iSJEmSZAIygCZJkiTJBGQATZIkSZIJyACaJEmSJBOQATRJkiRJJiADaJIkSZJMwN/X0GPVliVBAAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Execute test using superconducting quantum computing device (SQC)\n",
    "\n",
    "#Choose the backend\n",
    "#backend_noise = Aer.get_backend('qasm_simulator') # for optional test before final experiment \n",
    "backend_noise = device # for least busy SQC device\n",
    "\n",
    "# Execute on SQC and get counts\n",
    "shots = 1024\n",
    "if backend_noise.name() == \"qasm_simulator\" : # optional test before final experiment \n",
    "    mode = \"DNS\"\n",
    "    job_noise = execute(test, backend_noise, \n",
    "                           noise_model=noise_model,\n",
    "                           coupling_map=coupling_map,\n",
    "                           basis_gates=basis_gates)\n",
    "else: # final experiment on real device\n",
    "    mode = \"SQC\"\n",
    "    job_noise = execute(test, backend_noise)\n",
    "    job_monitor(job_noise)\n",
    "\n",
    "print(job_noise.status)\n",
    "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n",
    "noisy_count = job_noise.result().get_counts(test) \n",
    "print(noisy_count)\n",
    "plot_histogram(noisy_count, color=['orange'], \n",
    "               title= str(n) + '- qubit W state, ' + mode + ': {}, '.format(device.name()) + method + \" method\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### State tomography and quantum fidelity on superconducting quantum computing device (SQC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b9073c034ea8437f89a942fb176b061b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HTML(value=\"<p style='font-size:16px;'>Job Status: job is being initialized </p>\")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Date (DMY): 08/01/2019 10:58:17\n",
      "Tomography 3-qubit W state on ibmq_16_melbourne , shots: 1024 , method: specific , mode: SQC ibmq_16_melbourne\n",
      "Fidelity with theoretical ideal state\n",
      "F = 0.6806596009461401\n"
     ]
    }
   ],
   "source": [
    "# Execute state tomography on superconducting quantum computing device (SQC)\n",
    "\n",
    "# obtain the final state vector\n",
    "backend_stvct = Aer.get_backend('statevector_simulator')\n",
    "job = execute(my_state, backend_stvct)\n",
    "my_state_psi = job.result().get_statevector(my_state)\n",
    "\n",
    "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n",
    "qubit_set = []\n",
    "for i in range(0,n) :\n",
    "    qubit_set.append(i)\n",
    "\n",
    "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.\n",
    "\n",
    "# add the state tomography measurement circuits to the Quantum Program\n",
    "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n",
    "\n",
    "#Choose the backend\n",
    "#backend_tomo = Aer.get_backend('qasm_simulator') # optional test before final experiment\n",
    "backend_tomo = device # for least busy SQC device\n",
    "\n",
    "# take 1024 shots for each measurement basis\n",
    "# note: reduce this number for larger number of qubits\n",
    "shots = 1024\n",
    "\n",
    "# loop: 27 circuits maximum per job to avoid exceeding the allowed limit for the real device.  \n",
    "n_circ = 3**n\n",
    "i_max = min(27,n_circ)\n",
    "my_jobs = []\n",
    "index_job = -1\n",
    "for i in range(0,n_circ,i_max) :\n",
    "    circs =[]\n",
    "    for j in range(i, i+i_max):\n",
    "        circs.append(my_state_tomo_circuits[j])\n",
    "    if backend_tomo.name() == \"qasm_simulator\" : # optional test before final experiment\n",
    "        mode = \"DNS\"\n",
    "        my_state_job = execute(circs, backend_tomo, \n",
    "                               noise_model=noise_model,\n",
    "                               coupling_map=coupling_map,\n",
    "                               basis_gates=basis_gates)\n",
    "    else: # final experiment on real device\n",
    "        mode = \"SQC\" \n",
    "        my_state_job = execute(circs, backend_tomo, shots=shots)\n",
    "    my_jobs.append(my_state_job)\n",
    "    index_job = index_job + 1 \n",
    "    job_monitor(my_jobs[index_job], monitor_async = True)\n",
    "    \n",
    "    my_state_new_result = my_state_job.result()\n",
    "    if i == 0:\n",
    "        my_state_tomo_result = my_state_new_result\n",
    "    else:\n",
    "        my_state_tomo_result = my_state_tomo_result +  my_state_new_result\n",
    "\n",
    "# extract tomography data from results\n",
    "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n",
    "\n",
    "# Quantum fidelity\n",
    "\n",
    "# reconstruct experimentally measured density matrix \n",
    "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n",
    "\n",
    "# calculate fidelity of fitted state:\n",
    "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n",
    "print(\"Date (DMY):\", time_exp)\n",
    "print('Tomography',str(n)+'-qubit W state on', backend_tomo,\n",
    "      \", shots:\", shots, \", method:\", method, \", mode:\", mode, device)\n",
    "F_fit = state_fidelity(rho_fit, my_state_psi)\n",
    "print('Fidelity with theoretical ideal state')\n",
    "print('F =', F_fit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results for superconducting quantum computing device (SQC)###\n",
    "\n",
    "The following results were obtained on the ibmqx4 superconductive quantum computing system using 1024 shots for each tomographic circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.xlabel('Number of Entangled Qubits')\n",
    "plt.ylabel('Quantum Fidelity')\n",
    "plt.axis([1.4, 6, 0, 1])\n",
    "plt.grid()\n",
    "plt.plot([2,3,4,5], [0.812,0.735,0.592,0.457], 'ro-', label=\"Specific Algorithm\")\n",
    "plt.plot([2,3,4,5], [0.838,0.539,0.144,0.060], 'bs-', label=\"Arbitrary Initialization\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing DNS to SQC\n",
    "The results mentioned above for the DNS and SQC experiments are illustrated together in the next graphs:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Herafter a comparison of the histograms of estimated outcome probabilities obtained during noise-free simulation, DNS and SQC experiments of deterministic generation of W states by the specific algorithm on ibmqx4 using Qiskit 0.7 (Note that the results were less convincing using the ibmq_16_melbourne as shown above)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# DSN vs SQC, count histograms\n",
    "# Shots = 1024\n",
    "count_noisefree = {'010': 344, '001': 335, '100': 345}\n",
    "count_DNS = {'110': 42, '010': 258, '111': 9, '011': 38, '000': 76, '001': 281, '100': 286, '101': 34}\n",
    "count_real = {'001': 274, '000': 129, '010': 224, '011': 20, '100': 282, '111': 14, '101': 46, '110': 35} \n",
    "plot_histogram([count_noisefree, count_DNS, count_real], \n",
    "               title= 'Determistic W state generation, specific algorithm, device: ibmqx4', \n",
    "               color=['purple','cyan', 'orange'], bar_labels=False,\n",
    "               legend = ['Noise free simulation', 'Device noise simulation','Real quantum device']) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hereafter a comparison of the quantum fidelity estimated by state tomography for device noise simulation (DSN) and real device (SQC), using either the specific algorithm or arbitrary  initialization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEKCAYAAAD9xUlFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsnXlYVdX6xz/7HGZkFMSZwUSRGVFUTEHLyoFyKpXrkAMOWWnltV+Wml2btKvZoFmmZmrOXutWmoF6BVMIcUAlBVFwQEAUEAGB9ftjwxZkFIGDtj/Ps59zzt5rr/XuzeG8e631ru8rCSFQUVFRUVEB0OjaABUVFRWVxoPqFFRUVFRUFFSnoKKioqKioDoFFRUVFRUF1SmoqKioqCioTkFFRUVFRaHenIIkSd9KknRNkqSTlRyXJElaJknSOUmSjkuS5FNftqioqKio1Iz67CmsAZ6u4vgzQPviLQRYXo+2qKioqKjUgHpzCkKIA8D1Koo8C3wnZP4ALCVJalFf9qioqKioVI+eDttuBSSV+pxcvO/KvQUlSQpB7k1gbGzcuU2bNg1iYF1QVFSERqNO3VSFeo+qRr0/1aPeo+r566+/0oQQttWV06VTkCrYV6HmhhBiJbASwNfXV0RFRdWnXXXKvn37CAgI0LUZjRr1HlWNen+qR71H1SNJ0oWalNOla00GSj/ytwYu68gWFRUVFRV06xR2AWOKo5C6ATeFEOWGjlRUVFRUGo56Gz6SJGkjEADYSJKUDMwD9AGEECuAn4H+wDkgB3ixvmxRUVFRUakZ9eYUhBAjqzkugJfqq30Vlfvlzp07JCcnk5ubq2tTymBhYcHp06d1bUajRr1HdzEyMqJ169bo6+vX6nxdTjSrqDQqkpOTMTMzw8HBAUmqKA5CN2RlZWFmZqZrMxo16j2SEUKQnp5OcnIyjo6OtapDjeFSUSkmNzeXpk2bNiqHoKJyP0iSRNOmTR+ot6s6BRWVUqgOQeVh50G/w6pTUFFRUVFRUJ2CikojYuHChbi6uuLh4YGXlxeHDx+u0/r79+/PjRs3AFi2bBkuLi4EBweza9cuPvzww/uq6+jRo0iSxO7du8vsb9KkSZ3ZO3fuXPbu3QvA0qVLycnJqZd2qkKSJF5//XXl8+LFi5k/fz4A8+fPZ/HixQD88ccf+Pn54eXlhYuLi1IGYOfOnXh4eNCxY0fc3NzYunVrg9heK4QQD9XWuXNn8TARFhamaxMaPY3lHp06der+Tvj+eyHs7YWQJPn1++8fqP2IiAjRrVs3kZubK4QQIjU1VVy6dElkZmY+UL2V0aFDB5GQkFDr82fNmiV69uwpxo4dW2a/qanpA1omU1BQUOazvb29SE1NrbCd+rpHQghhaGgoHBwclLYXLVok5s2bJ4QQYt68eWLRokVCCCGcnZ1FTEyMYntsbKwQQoiYmBjRrl075V4nJCQIJycnERUVVW82V/RdBqJEDX5j1Z6CikptWL8eQkLgwgUQQn4NCZH315IrV65gY2ODoaEhADY2NrRs2RIABwcHZs+eTdeuXenatSvnzp0DIDU1laFDh9KlSxe6dOlCeHg4ANnZ2bz44ou4u7vj4eHBtm3blHrS0tKYMmUKCQkJBAUFsWTJEtasWcP06dMBSElJYfDgwXh6euLp6UlEREQ5W4UQbN26lTVr1rBnz54KJzaLioqYNm0arq6uDBw4kP79+ytPyL///jve3t64u7szfvx48vLyFPsWLFhAz5492bJlC+PGjWPr1q0sW7aMy5cvExgYSGBgoNLGnDlz8PT0pE+fPqSkpAAwbtw4pk6dSmBgIE5OTuzfv5/x48fj4uLCuHHj7vvvoqenR0hICEuWLKmy3LVr12jRQtb01Gq1dOrUCZB7Fm+99ZYSDeTo6Mhbb73FJ598ct+2NASqU1BRqYgZMyAgoPJtwgQoNZQByJ8nTKj8nBkzqmyyX79+JCUl4ezszLRp09i/f3+Z4+bm5hw5coTp06czo7iuV199lZkzZxIZGcm2bduYOHEiAO+99x4WFhacOHGC48eP06dPnzJ1rVixgpYtWxIWFsbMmTPLHHvllVfo3bs3x44dIzo6GldX13K2hoeH4+joSLt27QgICODnn38uV2b79u0kJiZy4sQJvvnmGw4dOgTIUV7jxo1j06ZNnDhxgoKCApYvv6ucb2RkxMGDBxkxYkQZm0rsDQsLA+DWrVt069aNY8eO4e/vz9dff62Uz8jIIDQ0lCVLljBo0CBmzpxJbGwsJ06cICYmpsq/Q0W89NJLrF+/nps3b1ZaZubMmXTo0IHBgwfz1VdfKY4yNjaWzp07lynr6+vLqVOn7tuOhkB1CioqtaH4ybbG+2tAkyZN+PPPP1m5ciW2tra88MILrFmzRjk+cuRI5bXkB3bv3r1Mnz4dLy8vgoKCyMzMJCsri7179/LSS3fXhlpZWdXYjtDQUKZOnQrIT7wWFhblymzcuFH50R4xYgQbN24sV+bgwYMMHz4cjUZD8+bNlSf8uLg4HB0dcXZ2BmDs2LEcOHBAOe+FF16okZ0GBgYMHDgQAC8vLxITE5VjgwYNQpIk3N3dsbOzw93dHY1Gg6ura5lyNcXc3JwxY8awbNmySsvMnTuXqKgo+vXrx4YNG3j6aTmdjBCiXESQPJrTOFEXr6moVMTSpVUfd3CQh4zuxd4e9u2rdbNarZaAgAACAgJwd3dn7dq1DB06FCgbaljyvqioiEOHDmFsbFymnop+iOqKwsJCtm3bxq5du1i4cKGyYOreBWSV/fBV94NoampaIzv09fWVa9RqtRQUFCjHSobgNBqN8r7kc+lyAIcPH2by5MkALFiwgKCgoArbmzFjBj4+Prz4YuWKPO3atWPq1KlMmjQJW1tb0tPTcXV1JSoqCg8PD6VcdHQ0vr6+NbrOhkbtKaio1IaFC8HEpOw+ExN5fy2Ji4vj7NmzyueYmBjs7e2Vz5s2bVJeu3fvDshDTp9//nmZcyran5GRUWM7+vbtqwznFBYWkpmZWeb43r178fT0JCkpicTERC5cuMDQoUPZuXNnmXI9e/Zk27ZtFBUVkZKSwr5iZ9mxY0cSExOVeZF169bRu3fvau0yMzMjKyurxtdRU/z8/IiJiSEmJqZShwBgbW3N888/z6pVqyo8/t///ldxeGfPnkWr1WJpackbb7zBBx98oPRQEhMTWbp0KbNmzarza6kLVKegolIbgoNh5Uq5ZyBJ8uvKlfL+WpKdnc3YsWPp1KkTHh4enDp1qkxYY15eHn5+fnz66afKpOeyZcuUp9BOnTqxYsUKAN5++20yMjJwc3PD09NTGYevCZ9++ilhYWG4u7vTuXNnYmNjyxzfuHEjgwcPLrNv6NChbNiwody+1q1b4+bmxuTJk/Hz88PCwgIjIyNWr17N8OHDlWGdKVOmVGtXSEgIzzzzTJmJ5obm9ddfJy0trcJj69ato0OHDnh5eTF69GjWr1+PVqvFy8uLjz76iEGDBuHs7IyzszPLly+nQ4cODWx9DalJiFJj2tSQ1EePxnKP7jsktYHIzMwsF475sJCVlSWEECItLU04OTmJK1eu1Es79RmSWtfMnj1bBAQEiLy8vHpr40FCUtU5BRUVlXpj4MCB3Lhxg/z8fN555x2aN2+ua5N0zv0uEmxoVKegovIQUJuImcbAvgeYdFfRDeqcgoqKioqKguoUVFRUVFQUVKegoqKioqKgOgUVFRUVFQXVKaioNDJ27NiBJEmcOXOm0jKJiYm4ublVeGzixImKrs77779fLzZWRIl4XVWUlujeuXNnGf2f0jLZNWmj9HXeD2vWrOHy5cvK59rWcz+MGzeOVq1aKcJ/aWlpODg4AGX/ljk5OQQHB+Pu7o6bmxs9e/YkOzsbkNPFPvvss7Rv3x4nJyemT5+u1FeXqE5BRaUWNG8ur1m7d6uLiMuNGzfSs2dPfvjhhwqPFxYWVnn+N998oyh0VuYUhBAUFRXVyJ7q2rsfgoKCePPNN4HyTmHBggU88cQTNa6r9HXeD/c6hdrWc79otVq+/fbbKst8+umn2NnZceLECU6ePMmqVavQ19dHCMGQIUN47rnnOHv2LGfPnuX27dv885//rHM7VaegolILilWaa7y/pmRnZxMeHs6qVavKOIV9+/YRGBjIqFGjcHd3B6CgoICxY8fi4eHBsGHDlAQ0AQEBREVF8eabb3L79m28vLwIDg4mMTERFxcXpk2bho+PD0lJSUydOhVfX19cXV2ZN2+e0l5pCesPP/wQHx8f5djZs2fLqX7ei4ODA/PmzcPHxwd3d3el11Mi0R0REcGuXbuYNWsWXl5exMfHl+kFLFiwgC5duuDm5kZISEiFekkl17lr1y78/f3x8vKiQ4cOikR1RXVs3bqVqKgogoOD8fLy4vbt20o9IDvkkqf02bNnK201adJEkenu1q2bItN9P8yYMYMlS5aU014qzZUrV2jVqpXyuUOHDhgaGhIaGoqRkZGiu6TValmyZAnfffed0pOoK1SnoKJSAdUpZ1dFLZWzAfnp+emnn8bZ2Rlra2uio6OVY0eOHGHhwoXK03VcXBwhISEcP34cc3NzvvzyyzJ1ffjhhxgbGxMTE8P64jwPcXFxjBkzhqNHj2Jvb8/ChQuJiori+PHj7N+/n+PHjyvnl0hYz5kzBwsLC0VXafXq1TXKS2BjY0N0dDRTp05VspOV0KNHD4KCgli0aBExMTG0a9euzPHp06cTGRnJyZMnuX37Nj/99FOl7QQFBREeHk5MTAyenp688cYbldYxbNgwfH19Wb9+PTExMWWEBC9fvszs2bMJDQ0lJiaGyMhIRc+ptEx3r169ysh015S2bdvSs2dP1q1bV2mZ8ePH89FHH9G9e3fefvttRQurIvltc3NzHBwcFA2pukJ1CioqjYiqJKm7du2qPAUDtGnTBn9/fwD+8Y9/cPDgwWrrt7e3p1u3bsrnzZs34+Pjg7e3N7GxsWWGc0pLWE+cOJHVq1dTWFjIpk2bGDVqVLVtDRkyBIDOnTvf9+K7sLAw/Pz8cHd3JzQ0tJz+UkV8/PHHGBsbK5Lh91tHZGQkAQEB2NraoqenR3BwsCLpXVqmuzbXU8Jbb73FokWLKh268/LyIiEhgVmzZnH9+nW6dOnC6dOnK1W9ragH9aCoK5pVVCqgOuXsqlSpa7uINz09ndDQUE6ePIkkSRQWFiJJEu+88w5QXlL63h+Jmkhll67j/PnzLF68mMjISKysrBg3blyZDGqlyw4dOpR3332XPn360LlzZ5o2bVptWyWS1ffKWldHbm4u06ZNIyoqijZt2jB//vwKM7uVZt++fWzZskX5Ea9NHVX9wFYl013CU089RUpKCr6+vnzzzTcV1vPYY4/h5eXF5s2bK22rSZMmDBkyhCFDhqDRaPj555/x9PRUsueVkJmZSUpKSp0L66k9BRWVRsLWrVsZM2YMFy5cIDExkaSkJBwdHZWEOvdy8eJF5VjJ5PS96Ovrc+fOnQrPz8zMxNTUFAsLC1JSUvjll18qtc3IyIinnnqKqVOnVplP4H6oTAq75MfbxsaG7OzsaiOaLly4wGuvvcbmzZuV4aCq6qisXT8/P/bv309aWhqFhYVs3LixRpLeJezevZuYmJhKHUIJc+bMKTecVkJ4eLgic56fn8+pU6ewt7enb9++5OTk8N133wHy5P/rr7/O9OnTy+XSeFBUp6CiUgvs7O5vf02oTJJ6y5YtFZZ3cXFh7dq1eHh4cP36dSVbWmlCQkLw8PAguAJJb09PT7y9vXF1dWX8+PHKUFRlBAcHI0kS/fr1u4+rqpwRI0awaNEivL29iY+PV/ZbWloyadIk3N3dee655+jSpUuV9axZs4br168zePBgvLy86N+/f5V1jBs3jilTpigTzSW0aNGCDz74gMDAQDw9PfHx8eHZZ5+tk2stjaura5mJ+9LEx8fTu3dv3N3d8fb2xtfXl6FDhyJJEjt27GDr1q20b9+epk2botFomDNnTp3bJ9XHmFR94uvrK0oiBRorzZtXHIViZwdXrza8PY2dffv2EVDd7G0DcPr0aVxcXHRtRjnuzWimKxYvXszNmzd57733dG1KORrLPWooIiIiGDlyJNu3b68wEqyi77IkSX8KIapN96bOKdQD9RWuqKKiKwYPHkx8fDyhoaG6NkUFOXrrQkXpYOsA1SmoqKhUy44dO3RtgkoDoc4pqKioqKgoqE5BRUVFRUVBdQoNzOHDurZARUVFpXJUp1AP2FncrnC/ViqiTx/4738b2CAVFRWVGqI6hXrgqqULAqncdrlVFzp1gmefhWrWt6j8TVm4cCGurq54eHjg5eXF4TruWvbv358bN24AsGzZMlxcXAgODi4jaV1Tjh49iiRJ7N69u8z+Jk2a1Jm9peW0ly5dqoj+1XU7VaHVavHy8sLV1RVPT0/+/e9/KzIV+/btQ5IkfvzxR6X8wIEDldzUP/30E97e3nh6etKpUye++uqrBrH5gRBC1NsGPA3EAeeANys43hYIA44Cx4H+1dXZuXNn0eiRJCGgwi3rg8/E090zBAjx7rtCFBXp2ljdExYWpmsThBBCnDp16r7KX/3+qoiwjxBhUpiIsI8QV7+/+kDtR0REiG7duonc3FwhhBCpqani0qVLIjMz84HqrYwOHTqIhISEWp8/a9Ys0bNnTzF27Ngy+01NTR/QMpmCgoIyn+3t7UVqamqF7dTXPbq3nZSUFNG3b18xd+5cIYT83W3durXw8/NTygwYMECEhYWJ/Px80aJFC5GUlCSEECI3N1ecOXOm3uwsTUXfZSBK1OB3u956CpIkaYEvgGeATsBISZLuFS1/G9gshPAGRgBf8ijQtm3F+7Vamvzfy+w6ZMtY7TrmzYMpPkco+PEXKF7arvJwkLI+hbiQOPIu5IGAvAt5xIXEkbK+9otRrly5go2NjaIZZGNjQ8uWLQFZinr27Nl07dqVrl27KsqYqampDB06lC5dutClSxfCw8MBWYL7xRdfxN3dHQ8PD0U3x8HBgbS0NKZMmUJCQgJBQUEsWbJEkbQGSElJYfDgwXh6euLp6UlEREQ5W0WxDPWaNWvYs2dPhbpCRUVFTJs2DVdXVwYOHEj//v0VuYnff/8db29v3N3dGT9+vJIsprRk95YtWxQ57WXLlnH58mUCAwMJDAxU2iiRs+7Tp48iZz1u3DimTp1KYGAgTk5O7N+/n/Hjx+Pi4lIjddeqaNasGStXruTzzz9XtJI8PT2xsLDgt99+K1M2KyuLgoICRSfK0NCwznWK6oP6HD7qCpwTQiQIIfKBH4B714wLwLz4vQVwmUeBhQtJ0X+GQ2xkH79ziI2k6D8Da9fCpUvob97A6pf+5K3m37IypitDg/LJsW4Frq4QEiKXO3dO7luo6ISzM85yNOBopduZCWcoyimrdFmUU8SZCWcqPefsjLNVttmvXz+SkpJwdnZm2rRp7N+/v8xxc3Nzjhw5wvTp05lRrMP96quvMnPmTCIjI9m2bRsTJ04E4L333sPCwoITJ05w/Phx+vTpU6auFStW0LJlS8LCwpg5c2aZY6+88gq9e/fm2LFjREdH4+rqWs7W8PBwHB0dadeuHQEBAfz888/lymzfvp3ExEROnDjBN998o+g05ebmMm7cODZt2sSJEycoKChg+fLlynklkt0larElNpXYGxYWBpSVs/b39y8jZ52RkUFoaChLlixh0KBBzJw5k9jYWE6cOKFIgNcWJycnioqKuHbtmrLv7bff5l//+leZctbW1gQFBWFvb8/IkSNZv359jRMb6ZL6XLzWCkgq9TkZ8LunzHxgjyRJLwOmQIVplyRJCgFCAOzs7JTxukbL6VYgXge0AOTRnNPidU6f1kKrv8DWFgY/x5ODIWdLLJ8uD+Jx2+P8YDgVxw0b0Cv+cudbWXHTzY2bbm5kurmR1b49Ql9fhxdWP2RnZzeKv6mFhYUilHYn/06VGcdEXsUOW+SJSs+7k3+nQiG20uzbt4+IiAgOHDjA888/z7vvvsuIESMQQjBo0CCysrIYOHAgM2bMICsri99++42TJ08q59+8eZPLly+zZ88evv32W6U9PT09srKyEEKQnZ2NoaFhmfe5ubnk5+eTlZXF77//zhdffKGcq9Foytm9du1annvuObKysnj22WdZt24dTz75pHI8KyuL0NBQBg0axK1btzA1NeXxxx/n9u3bREdH07ZtW1q0aEFWVhbDhw/n66+/ZsKECQghGDBgwN2/w5073L59u5ztIMtZ9+7dm6ysLDw8PNi/fz9ZWVncuXOHJ554guzsbBwdHbG1tcXBwYFbt27h7OzM6dOny+VvqI57r7/ElpycHAoKCvDy8qKwsJDdu3dTUFBATk4OWVlZLFmyhIkTJxIWFsbHH3/Mzz//zIoVK+6r7dqQm5tb6/+p+nQKFen43vufNBJYI4T4RJKk7sA6SZLchBBl3KkQYiWwEmTto8agk1MVh8YdIq/gntypBVoMvzek+7+6l9kdEAC9noCRIx9jkNVv/Hq8CIecUxAejkF4OLbh4dj+739yYUND6NIF/P3lrUcPqIGEcWOnMWkflejndPqy6vSMhxwOyUNH92Bob4jv/6qVl6mS/v37079/f3x9fVm7dq0iRGdmZoaZmRl37txBo9FgZmaGEILDhw+XU8osXf7e/U2aNMHMzKzMeyMjIwwMDJT9ZmZmyo/vvRQWFvLjjz/y66+/8sknnyCEID09HUBpz8zMDH19fYyMjJR9enp6GBsbY2JiglarVfabmJigp6entG1nZ6cc09fXx9jYuJy9JcfMzc2V9yV26+vrY2lpiZmZGebm5sr5IA/h6Ovrl7kvhw8fZvLkyYCcrS0oKKjcNZcun5CQgFarxcnJiaSkJMX2uXPn8u9//xs9PT1MTEyUc7p160a3bt2YNGkSjo6OSsKj+sTIyAhvb+9anVufw0fJQJtSn1tTfnhoArAZQAhxCDACbOrRpgYh72LFybTzLuQR/894rqy+QubhTAoyZU32wYNh7164dg26+2uIKXCDyZPhu+8gPh4uX4atW2HaNMjPh08+gaAgsLEBFxeYOBFWr4a//lKHnBoIp4VOaEzK/vtoTDQ4LXSqdZ1xcXFKpi2AmJgY7O3tlc+bNm1SXrt3lx8u+vXrx+eff17mnIr2Z9zHnFXfvn2V4ZzCwkIyMzPLHN+7dy+enp4kJSWRmJjIhQsXGDp0qJKlrISePXuybds2ioqKSElJUZ5cO3bsSGJiojIvsm7duhpJVFcmef2g+Pn5ERMTQ0xMTIUOoTSpqalMmTKF6dOnl8tf0a9fPzIyMjh27BhQvgd879+zsVKfPYVIoL0kSY7AJeSJ5HvTNV0E+gJrJElyQXYKqfVoU4MwdAdctyi/3+o67BiZjMi/+8Nt0NIA006m2LmYsGe6Cf+3wpRBPU1Ys1Ofvk8Uf+latIChQ+UN4PZtiIyE8HB5274dVq2Sj9nayj2IHj3k3oSvr9zDUKlT7IJljeyEOQnkXczDsK0hTgudlP21ITs7m5dffpkbN26gp6fHY489xsqVK5XjeXl5+Pn5UVRUpGRkW7ZsGS+99BIeHh4UFBTQq1cvVqxYwdtvv81LL72Em5sbWq2WefPmKZnQquPTTz8lJCSEVatWodVqWb58ueKEoHKJ7+XLlzN69Ogy+37//Xfc3NxwdnbGz88PCwsLjIyMWL16NcOHD6egoIAuXbowZcqUau0KCQnhmWeeoUWLFsq8QkNQkuf6zp076OnpMXr0aF577bUKy86ZM0eR2xZC8PHHHzN58mSMjY0xNTVlzZo1DWZ3balX6WxJkvoDS5EH178VQiyUJGkBcmjUruJopK+BJshDS/8UQuypqs6HQTpbqmIsr7BnL3LP55JzKodbp2+RczpH2Qqz745FZ6KHobMJDr1NMXExwcTFBNNOphi2MSyfYauoCM6cueskwsPliWoAAwPZMZQecrK1rYerrj2NafiosUpnu7u7ExUVhY3Nw9WRzs7OpkmTJqSnp9O1a1fCw8Np3rx5nbfzd5POro5GK50thPgZ+PmefXNLvT8FVJ3Z4xFDo6fBpL0JJu1NsHn27j+4EIK85DxyTueQ9uct/vwsB72/ctAkp6Kfczf1n8ZUg0lH2UEozsLFFCPnjmg6dYJJk+SCKSlw6NBdJ7F0KSxaJB9zdr7rIPz9oWPHqvNLqqjUkoEDB3Ljxg3y8/N555136sUhqNQtqnR2A+MfHU0/a2uetLKiq5kZehp5XFqSJIzaGGHUxgjrftZMfw3GjIEZm+GfIfnMHplDblwOt07JvYsbYTdIWXc3Jl4ykDBub4ypS7Gz6GSCqcsTGD81CK2xFnJzISrqrpPYtUuehwCwtr7rIEqGnOo4xZ/Kg1HbRPG6pjFElancH6pTaGDuCMG7iYnMT0zEXKulj5UV/ays6GdtTbtSP8SGhrBxI7RsCR8vNSDxhgHffWdJy1LTAwWZBeSckYeebp2+Rc6pHLJjskndngol8VsSGDkZFTuLFpi4jMF0zlRMOhqjdyVedhAREfLrTz/J5+jrQ+fOZR3Fg+SZVFFReWhQnUIDc6RzZ9Lv3CE0I4M9GRnsuX6dnWlpADgaGdHPyoonra3pY2mJlb4+S5ZA69bwxhtydNKOHWBpKdelZ66HeVdzzLual2mjMLeQ23/dLuMsck7ncH3P9QomuX0xcemFyasmmLYswOTmcfRPHkSKCIcvvoB//1su3K7dXQfh7y9HPWlU6SwVlUcN1SnUA3b6+qTcuVPhfoCm+voMb9aM4c2aIYTg7O3b/FbsINZfu8ZXV66gAbqam/OklRX9JlixtoU5E8dp6NULfvkFWrWqvH2tkZYmHk1o4lFWMKyooKj8JPepHK6uvlpqktsMPetBmLi8gGmwESam6ZjknMI0KRzDn39B+u47uZilZdkop65dwcSkDu6eioqKLqnX6KP64GGIPirN/UbW3Ckq4nBmJnsyMvgtI4MjmZkUAWZaLW4FlkR/ZY1VghV7Vxvj6lo3k8PKJPc9EVG3Tt2iIP2eSW5HLabmGZjkn8Pk6mFMk8Mx4hIaPQ14e5ftTbRoUaP21eijqlEja6o5KNlwAAAgAElEQVRHvUdleZDoI7X/38jQ12joaWnJAkdHDvn4kObvz1ZXV0Y1a8ZV41vkTTnL1Y+P4B77B4P2x7Hl2jWuV9AruR9KJrmtn7KmzYw2dPiqA94HvOmZ1pMe13rgtd+L9svb02JCC/RbNOHGxaacj/IiNnkyR/iO/+nt5YjldmLPj+H8Z9mkDP+S7JaPU+jgDKNHw/LlcPw43CP/kDJtO4f0tkJgEYf0tpIybfsDXcejwo4dO5AkiTNnzlRaJjExETc3twqPTZw4kVOnTgHw/vvv14uNFVEiXlcVpSW6d+7cqdgJZWWya9JG6eu8H9asWcPly3fX0da2nvth3LhxODo64unpibOzM2PGjOHSpUvKcQcHB4aWrEMCtm7dqoj3paSkMHDgQEV+u3///vVqqzp81Mix0tdnqK0tQ4vXFsTfvs3Gs9f5KCaDn0yv8dOpK0iAr5mZMmHdzdwcgzoa7zewNcDA1gDLXpZl9peZ5C6OiMo+3YzU66V+qC4IjJJTMP0+ARO+xMQoBVNPS0z6tif9ZBPidjlThBEAeYU2xC3PBbZj92XNFlnpkubh4ZUOEV71f7Ao640bN9KzZ09++OEH5s+fX+54VZpMAN+UStbx/vvv89Zbb5Uro8gk1+B7UlhYiFarrd7wGhAUFKSsGt65cycDBw6kUydZUmTBggX3Vdc3tUxKsmbNGtzc3BQF2trWc78sWrSIYcOGIYRg6dKlBAYGcvLkSQwMDACIiooiNja2nADh3LlzefLJJ3n11VcBOH78eL3aqfYUHjLaGRvztkcrzv/DDb/3/eFlb5655oC+JPHhxYv0jonB+uBBBp04wbLkZM7cukV9DBGWTHI3H9ucdh+1w32XO35n/Xj81uP4HvOl0w+dsJ/ngNkQd3Kde5Os9wJxua8SfXgsB9/vweldropDKKEIIxJWNn4VSaBCh1DV/pqSnZ1NeHg4q1at4ocfflD279u3j8DAQEaNGoW7uzsABQUFjB07Fg8PD4YNG6YkoAkICCAqKoo333xTWY0bHBxMYmIiLi4uTJs2DR8fH5KSkpg6dSq+vr64uroyb948pb3SEtYffvghPj4+yrGzZ8/SuXPnKq/DwcGBefPm4ePjg7u7u9LrKZHojoiIYNeuXcyaNQsvLy/i4+PL9AIWLFhAly5dcHNzIyQkpMLvcMl17tq1C39/f7y8vOjQoQOOjo6V1rF161aioqIIDg7Gy8uL27dvK/WA7JDd3d1xc3Nj9uzZSltNmjRRZLq7deumyHTXBkmSmDlzJs2bN+eXX35R9r/xxhsV9uyuXLlC69atlc8eHh61brsmqE7hIcXGBkJ/0xDkZMHPLzgQsM2HNP+e7HB1ZUzz5pzJyeHVc+dwiYyk7R9/MOHMGTZdu0Zafn692lUyyd3shWY4znfEdbMrXeL8efx2b7rGdcVtpxuOc5tT2Vcvr7ApBdkFFR5rSGacPUvA0aOVblVR2TkzSukaVcbOnTt5+umncXZ2xtramujoaOXYkSNHWLhwoTLUERcXR0hICMePH8fc3JwvvyybjuTDDz/E2NiYmJgYRYQtLi6OMWPGcPToUezt7Vm4cCFRUVEcP36c/fv3l3kKLZGwnjNnDhYWFoqu0urVq2uUl8DGxobo6GimTp3K4sWLyxzr0aMHQUFBLFq0iJiYmHKqpdOnTycyMpKTJ09y+/ZtfioJl66AoKAgwsPDiYmJwdPTkzfeeKPSOoYNG4avry/r168nJiamjJDg5cuXmT17NqGhocTExBAZGanoOZWW6e7Vq1cZme7a4uPjU2aI8Pnnnyc6OlrRhCrhpZdeYsKECQQGBrJw4cIyQ1/1geoUHmJMTGDbNjkFw/vvw4xJegywtOVLZ2fO+vkR7+fHCmdn/MzM2J6WxohTp2gWEYFvVBT/l5BAWEYGeQ2k767R02DiLK/itn+3I4ba9EpKSoRb7OOE3+9c+eYy+Wn168QaGxs3blTyCIwYMULROALo2rWr8hQM0KZNG/yLh6r+8Y9/cPDgwWrrt7e3p1u3bsrnzZs34+Pjg7e3N7GxsWXG1l944QXl/cSJE1m9ejWFhYVs2rSJUaPulTErT4nWUufOne978V1YWBh+fn64u7sTGhpKbGxsted8/PHHGBsb89JLL9WqjsjISAICArC1tUVPT4/g4GAOHDgAyDLdAwcOrPX1VMS9vR+tVsusWbP44IMPyux/6qmnSEhIYNKkSZw5cwZvb29SU+tPIk6dU3jI0dODFSvktQxz58LVq7KgapMm4GRszGRjYya3bElBURF/Zmez5/p19mRksDgpiQ8vXsREo6G3paWyPqKTiUl5baV6wClEQ9zy3DJDSBpyad3hGEVJ6aQe8SH9iBZC4rDwN8N2WHNsBttg1NaoilrrjqXt21d5vCp9q321lCxOT08nNDSUkydPIkkShYWFSJLEO++8A4CpqWlZG+75O9Xk71a6jvPnz7N48WIiIyOxsrJi3LhxZTKolS47dOhQ3n33Xfr06UPnzp2VbGJVUSK9rdVqKSioee8vNzeXadOmERUVRZs2bZg/f36Fmd1Ks2/fPrZs2aL8iNemjqqGWUukuau6nqeeeoqUlBR8fX1rNE9x9OhR+vbtW2bf6NGj+eCDD8rNK1hbWzNq1ChGjRrFwIEDOXDgQJmJ6bpE7Sk8AkgSvPMOfP21LMEdECBLH5VGT6PBz9ycdxwc+J+3N+n+/vzHzY3xLVoQf/s2M+PjcYuMpPWhQ7x45gwbUlK4Vo9DTXZfDqHD1BwMtWlAEYbaNDpMzcHpzGwey/gX3b4vorP7Z9iLddyJiOXcjHP8Yf8HUb5RXFh4gVun6meuRJds3bqVMWPGcOHCBRITE0lKSsLR0VHJWHYvFy9eVI6VTE7fi76+PncqmefIzMzE1NQUCwsLUlJSyoxv34uRkRFPPfUUU6dO5cUXX6zF1ZWnMinskh9vGxsbsrOzq41ounDhAq+99hqbN29WhoOqqqOydv38/Ni/fz9paWkUFhaycePGGkl6l7B7925iYmKqdQhCCJYtW8aVK1d4+umnyxzT19dn5syZLF26VNkXGhqqzBdlZWURHx9P28pS/tYBqlN4hJg4EXbuhFOn5GUC9wxNlsFcT48gGxs+a9+eOD8/Ert142tnZ/wtLNiVlkbw6dPYRUTgExXF7Ph4fs/IILeaqJf7xe7LIXQvGAZhGroXDLsbdWRggBQ8CrPj23A8MpWuwb/TVf9FnPgKzbk4zr99nkjXSI50PEL8m/FkHs5EFDWsg7CrJANeZftrQmWS1Fu2bKmwvIuLC2vXrsXDw4Pr168zderUcmVCQkLw8PAgODi43DFPT0+8vb1xdXVl/PjxylBUZZQk++nXr999XFXljBgxgkWLFuHt7U18fLyy39LSkkmTJuHu7s5zzz1Hly5dqqxnzZo1XL9+ncGDB+Pl5UX//v2rrGPcuHFMmTJFmWguoUWLFnzwwQcEBgbi6emJj4+PIoNdF8yaNUsJSY2MjCQsLEyJPCrNhAkTyvRE/vzzT3x9ffHw8KB79+5MnDix2nvyIKiL1+oZXSzMOnwYBgyQVSh++klebHw/FApBdFaWvIDu+nUiMjO5IwTGGg29LCx40tqaflZWuJma1slQU43uUUoKrFwJy5eTdyWfNJvnSLMO4kaCOaJAluywec4Gm8E2WPa2RKN//8876uK1qlm8eDE3b97kvffe07Up5Wgs96ix0Gils1V0g5+frHH39NMQGCjPMTzzTM3P10oSXczN6WJuzhx7e7ILCth/86YyH/FG8VNdcwMDWYbDyoonrKxoXp/JfOzs5DGyN9/EcPt2Wi1bRquIVdwxaUZ675mkaXpzdc1VLn95GT0rPZoObIrNYBusn7JGa1I3MfZ/ZwYPHkx8fDyhoaG6NkWlnlGdwiOKs7PsGAYMgEGD5PmG2g4FN9HTY0DTpgwonlxMys3lt2IZjp/T01lXPIHhYWqqyII/bmGBcR0teCqDvj688IK8RUej/9lnNN84n+Z5eRQGPk1G91dITbIn/ad0UtaloDHWYP2UNTZDbGg6sCn6VrUf3vk7s2PHDl2boNJAqE7hEaZ5c9i3T87iOX48XLoEc+Y8eD6dNkZGjG/RgvEtWlAkBEezs/mtuBexLDmZxUlJGEoSvSwt5Z6EtTXupqZo6jqqycdHzgnx8cfw9ddov/wSm7D+2Dg6UvTmS9x0Hk7q3lzSdqaRtjMNSU/CMsASm8E22Dxrg2Gr8j0bIUSDRF+pqNQXDzoloM4p1DONQewtPx8mTIDvv4epU+Gzz6A+HuIBbhUWcuDGDWU+IrY4aqKZvr7iIJ6wssInKqruZSLu3JFn2j/7DP73P3khx+jRiJemk3W7LWk70kjdkcrtOHly0czPDNvBttgMtsHE2YTz589jZmZG06ZNG5VjUMfLq0e9RzJCCNLT08nKyiqzpgVqPqdQrVOQJCkKWA1sEEJkPIjBdYHqFGqHEPB//wcffQTPPQcbNjRMcrVLeXnsLZYF/y0jg9QayECIurhfMTGyc9iwQc4616cPvPwyDBrErb9ySduRRtqONLKi5NBEk04mWL9gjRgkKDDS/Yrq0uTm5mJk1DDrMx5W1Ht0FyMjI1q3bo3+PZFwdekUHgNeBF4AShzEHqGjLobqFB6Mzz6DV1+F7t3hxx/lTJwNRZEQHM/OZk9GBrMTEiotVydOoYS0NPjmG/jyS0hKAgcHmDZN7jpZW5N7sXh4aUcaNw7cgCIwbGuoRDJZ9LSQZcF1SGP7DjVG1HtUPXUmnS2EOCeEmAM4AxuAb4GLkiS9K0lSA/6kqNQFL78MmzfL6Zr9/eHChYZrWyNJeJmZ8c96XHhTDhsbePNNSEiQNUHs7eGf/5SXgIeEYHTzLK1faY1XmBc9UnrQ4dsONPFswuWvLnMs8BiHWhzizIQzpP2URmFu3a7TUFFpjNToEUiSJA/gE2ARsA0YBmQCanzaQ8iwYbBnD1y5IvcYjh3TtUUNgJ4eDBkiz7wfOwbBwfIki4eHvAR8+3YMLDW0eLEF7rvc8U/zp9OWTlj1syJ1ayonB50kwjaC2OdjSdmYQsHNxjXEpKJSV1TrFCRJ+hNYAkQCHkKIV4QQh4UQnwCVjwGoNGp694aDB+UJ5169oDGFn5+6dat+G/DwkGN0k5PlyKXERDlEy8kJPvwQ0tLQa6JHs2HN6LS+E/6p/nj86kGz4GbcOHCD06NOE24bzvFnjnN55WXyU/5eon0qjzY16SkMF0L0FUJsEELkAUiS5AgghGj82VBUKsXNTV7L0KaNvNCtlHx/vVOZHIQG8D96lAM3btS/EdbWMGsWxMfDjh3Qvr08G9+mjTznUCwVrTGQ1zp0WNGBHpd64H3Qm1avtCLnrxz+mvwXES0iiO4ZTdInSdxOuF1NoyoqjZuaOIWK1KiqVqhSeWho00aO3uzeHUaOhH//u2HavervjwgIQAQEEAbK+3g/P3ml9LFjbL52rWGM0WrlkKzff4cTJ2DsWNlDenvL3agtW+RwV0DSSlj4W/DY4sfwO+eH7zFfHOY5UJhdSPwb8Rxud5hIr0gS300k+3j2Iyfap/LoU6lTkCSpoyRJQwELSZKGlNrGAWrs1yOElRXs3i2PoLz+urw1UJqFcjgYGxPu7U1Xc3NeOHWKJUlJDWuAm5usRZ6cDIsXy6/PPw+OjnLSilI69pIk0cSjCQ7zHOgS0wW/eD/afdIOPTM9Et9NJMozisOPHebcG+e4GX6zwUX7VFRqQ1U9hQ7AQMASGFRq8wEm1b9pKg2JkRFs2gTTp8u9hX/8A/LydGOLtb4+v3l4MNTGhtfi45l57hxFDf3EbWUle8ezZ+E//wEXF3k5eJs2sl5IqYxoJRg7GdPmtTZ4/8+bHld64LzSGZMOJlxadomjPY8S0TKCuMlxpP+aTlH+w5F2VOXvR6UyF0KI/wD/kSSpuxCiYkF3lUcKrRaWLZOjNd98UxYm3b4dLCwa3hYjrZbNrq68du4cS5OTSc7LY13HjhjV11LsytBqIShI3k6dgs8/h+++gzVroEcPeOUVOarpnjkSAzsDWk5qSctJLSnILCD953TSdqRxbcM1rqy8gtZcS9MBxaJ9z1ij10RVnFFpHFQ1fPTP4rejJEladu/WQPapNDCSBLNny797Bw7IQ+r1nBK2UjSSxNL27fl3u3ZsTU3lyePHuV6DFdH1RqdO8iK45GRYskT2miNGyAvi3nuvfGajYvTM9bAbYYfrJld6pPbA7Uc3bIfZkvFbBqeeP0W4TTgnBp3gyrdXyqQfTVmfwiGHQ9AHDjkcImV97ZPFq6jUlKoeT04Xvz48y4dV6ozRo2W16qFD5UnoX3+VR1B0wcw2bWhlaMjo06fxP3qUX9zdcWgIjY7KsLSEGTPkXsIvv8jLxOfOhX/9S1ZvffllqCQJitZIi81AG2wG2lBUUERmeCapO1JJ25FG+k/poAHLXpYYtDEgbWsaRbflYaa8C3nEhcQBYBds12CXqvL3o9KeghDix+LXtRVtDWeiiq7o1w/275elg3r2lMNXdcXzzZrxm6cnV/Pz6X70KEcrSKfY4Gg0sjb5r7/CmTMQEiKHtnbtKnvSDRtkNcLKTtfTYNnbkvZL29MtsRud/+yM/Vv25Kfmc23dNcUhlFCUU0TCHHVpkEr9UtXw0Y+SJO2qbGtII1V0h48PHDoETZtC377ynKuu6GVpyUFvb/QliV4xMey5fl13xtxLhw5yj+HSJfj0U0hPl1dN29vDu+/C1atVni5JEmY+Zji+50jXk12hEpHWvAt5JH2SRFZ0FqJQjWZSqXuqij5ajCxtUdmm8jfByQnCw+WFwEOGwFdf6c4WV1NT/vDxoZ2REQNOnGDNlSu6M6YizM3lYaUzZ+ShJW9vmD8f2raVQ7oOH65RNYZtK85iJ+lJxL8Rz5+d/yTcNpyTQ06S/Hkyt2JvqWsiVOqEqqKP9pe8lyTJGGgrhIhrEKtUGh22trIUxgsvwJQp8lzrggUPnrCnNrQ0NOSAtzdDY2N5MS6O5Lw85tjbN6ocCGg08jLxp5+Gv/6CL76QEwKtXy/PN7zyCgwfDpWkMHVa6ERcSBxFOXeHkDQmGjqs7IBloCU3wm6QEZrBjbAbpO1IA0DfTh+rQCss+1hiGWiJcTvjxnVPVB4KaqJ9NAiIAX4t/uxV0+EjSZKeliQpTpKkc5IkvVlJmeclSTolSVKsJEkb7sd4lYbF1FTOYTN+vDynOnGistC3wTHX0+O/7u6MtrPjncREJv/1FwW6WnFXHc7O8pDSpUtySGtmpjyT37YtzJtXYXiXXbAdHVZ2wNDeECQwtDekw8oO2AXbYdjSELtgOzqu6ki3hG74JfjRYVUHrJ6w4sb+G/wV8hdH2h/hD/s/OD3uNFe/u0puUq4OLlzloUQIUeUG/AlYAEdL7Tteg/O0QDzgBBgAx4BO95RpDxwFrIo/N6uu3s6dO4uHibCwMF2bUOcUFQkxd64QIET//kJkZz9YfQ9yj4qKisRb8fGCsDAx4NgxkV1Q8GDGNASFhULs3i3EgAFCSJIQenpCjBghRHi4fHPv4X7uT1FRkbh15pZI/jJZnBx2Uhy0OSjCCBNhhIk/HvtDnAk5I1J+SBF5V/Pq8IJ0z6P4f1bXAFGimt9XIUSNtI8KhBA3a+FvugLnhBAJQoh84Afg2XvKTAK+EMUZ3YQQDSR2o/IgSJI8d/rVV3LgTWBgGfWHBrZFYqGTE8vbt+eX69cJiInhWhURP40CjUYO7frpJ3nF9Msvw88/ywkuunSBtWvlkK/168HBgd59+shrIdavr7ZqSZIw6WBCq6mtcN3iSo+UHvge86XdknaYuJhw7YdrnBpxiojmERxxO8LZV86SujOVOxk6XP+h0qioSea1VcDvwJvAUOAVQF8IMaWa84YBTwshJhZ/Hg34CSGmlyqzE/gL8EfuWcwXQvxaQV0hQAiAnZ1d5x8aUs7zAcnOzqZJkya6NqPeCA9vyoIFnbC1zeOjj47TqtX9D1PU1T2KABYATYGPgNYPXGPDob19G7s9e2i1YwemFy5QYGyMJj8fTeHdxD6FhobEvfEG1554ovYNFQJnkfvn0cAJIA852ukxZBEbb8AdMKl9Mw3No/5/VhcEBgbWWTpOE2AO0A/5q7MbeE8IUeV/vyRJw4Gn7nEKXYUQL5cq8xNwB3ge+X/4f4CbEKJS3WQ1HWfj49AhGDhQzmPz3/+Cb7Vfu7LU5T06nJnJwBMnEELwk7s73XSh0fEgCCGrtQYFwe0KZLjt7eX8D3VEUX4RmUcyuREqT1xnHspE5AskPQmzLmZY9rHEqo8V5t3N0Ro3sMTIffB3+D97UOoyHWeOEGKOEKKLEMK3+H1NHgeTgTalPrcG7p1RSwb+I4S4I4Q4D8QhzzOoPER07y6HrBoby0nMdu/WnS1+5uYc8vbGUk+PPseO8Z+0NN0ZUxskCZ54Qh4+qogLF+S803WExkCDZU9LHOY64L3Pm54ZPfHc60mbf7YBARc/vMixvsc4aHWQmMAYEt9L5Gb4TVXQ7xGm0pBUSZJ+BCrtRgghgqqpOxJoX5yQ5xIwAhh1T5mdwEhgjSRJNsh5oNUlmw8hHTvKK57795d7DatWwZgxurHlMRMTInx8GHTiBENOnuTz9u2Z2qqVboypLW3bVp5Au1UrOafqlCnyUvM6DDvVmmix6muFVV8rAAoyC7j5v5tkhGVwI/QGifMSSZybiMZUg+XjcuirZR9LzLzNkLRq+OujQFXaR4uLX4cAzYHviz+PBBKrq1gIUSBJ0nTk4SYt8K0QIlaSpAXIs+C7io/1kyTpFPJo5ywhRHqtrkRF57RsKYvoDRki56m5dElWW9VFqHwzAwNCvbwYceoU086e5WJeHgsdHdE8LHH7CxfKshk5OXf3mZjIGkvJybJi4YYNsiDV5MmyB7ayqnMz9Mz1aDqgKU0HNAXgTvodbuy/oayTSJgtP8NpLbRYBlgq6yRMXU2RNA/JvVYpS3XhScCBmuxrqE0NSW385OUJMWqUHLL60ktCVBclWp/36E5hoZh85owgLEwEx8aKvMLCemurzvn+eyHs7UWRJAlhby9/LiE7W4hVq4To2lW+0UZGQowdK0RERIVhrfVF7pVccXXDVXFm0hlxqN0hJfz1oO1BcfL5kyJ5ebK4FXdLFNWzTX/H/7P7hRqGpNZExN1WkiQnIUQCKPmZbevNS6k89BgYwLp1cs9h8WK4cgW+/16ec2ho9DQaljs709bIiDnnz3M1P59tbm5Y6D0E+QuCgyE4mP0VTaKamsqrCMePl3NJf/WVfJPXrgV3d7n38I9/1HsyDMPmhtiNtMNupKzcmnshVxlqygjNIHWzHKts0MoAqz5yL8Iq0AojezV5Y2OlJusUZgL7JEnaJ0nSPiAMmFGvVqk89Gg0sGiRnHZg+3Y5LD8jQze2SJLEW/b2rO3Ykf03b9Lr6FEu6SqtXH3g5QXLl8sro7/6Sk74M3267JUnToTISDmqqQEwsjeixbgWuHznQvek7nT9qyvOK5yx8Lfg+q/XiXsxjj8c/uCPdn8QNymOlI0p5F19hP4WjwDVPi4JIX6VJKk90LF41xkhhPpXVKkRM2ZAixbykHfPnrJGXNu2urFlTPPmtDAwYGhsLN2io/nF3R23Rym23cxMnocICYGoKDnX9MaN8qy/t7c8MT1ypFyuAZAkCZP2Jpi0N6Hl5JYIIbgVe+tuL2JrKle+kQUNTVxMlPBXy96W6DfVr6Z2lfqiKunsPsWvQ4ABQLvibUDxPhWVGvHCC/LK5+RkOYPliRO6s+VJa2sOeHlRKAQ9jx5ln666L/WNry98843ce/jiCygokIeUWraUncPRow1ukiRJNHFrQutXWuO+0x3/NH86R3XG6WMnjOyNuLrmKrFDYwm3DSfKO4pzr58j/b/pFGQWNLitf2eqGj7qXfw6qIJtYD3bpfKIERgI//ufPIrx+OOwb5/ubPEyM+MPHx9aGhry1PHj/FBJGs1HAgsLmDYNjh2TY4aHDpXnHXx8wM8Pvv0Wbt3SiWmSVsKssxltZ7XF4xcPemb0xDvcG4cFDuhZ6XHpi0ucGHiCg9YH+bPbnyS8lcD1vdcpzLm7yltNWVr3VLuiubGhrmh+uLl4UVaTPn264uN2dtXmo6kzMu7c4bmTJzlw8yaLnJx4vU2bRik1XeffoYwMORJgxQr5D2FuLqu2Tp4sT1I3EgpzC8k8dHe1ddaRLESBQDKQMO9mjr6NPun/TUfk3f0NK5EXV1OWlueBVzRLkrSm1PuxdWSXyt+ctm3h4MHKjzfkQ7uVvj67PTx43taWWQkJzDh3jsKH7CGpVlhZyfkcYmPlhSWDBsHXX8tZlPz95TUQFUlsNDBaIy1WgVY4vueIT7gP/hn+uP/iTutXW1N4q5C07WllHAKoKUvrgqqGjzxLvX+1vg1R+ftgba1rC+5ipNWysVMnXmvdmmWXLvF8bCy3S4nQPdJIkjyW9/338krDxYtlCY2xY+VV0zNnyhnkGgl6TfRo+nRT2n3cDt8o38pTll5U42AehKqcwt/gkUlFBTSSxCePPcaSdu3YkZbGk8eOka6r7EG6wsYGXn9ddgKhoXIM8RdfyCume/eWV083sjDeylKWVrZfpWZU5RRaS5K0TJKkz0q9V7aGMlBFpaGY0aYNmzp1IiorC//oaM43giGUBkeS5KiAH36Qw8U+/FB+DQ6G1q1h1iw5B0QjwGmhExqTsj9hGhMNTguddGTRo0FVTmEWcta1qFLvS28qKo8cw5s14zdPT67duUP36Gj+zMrStUm6o1kzmD1bdgJ79kCvXvJqRGdn6NsXtmwBHSY0qiplqUrtqXTxmhBibUMaovL3ws6u4kllfX15jlMXkhglPG5pSbi3N88cP07vo0fZ6urK002b6s4gXaPRwJNPymxL5UAAACAASURBVNuVK3IY69dfw/PPy45j/HiYNAmcGv4J3S7YDrtgO/bt20f3gO4N3v6jSE1kLlRU6pyrV+U1C0JAWNg+hJDlMAoKYNw4KNKxXL+LqSmHfHxob2LCwBMn+PbKFd0a1Fho0QLmzIH4eDmjUrdu8PHH8Nhjcqzxjh3wd5uPecRQnYJKo2HwYHkIe/NmmD9f19ZAC0NDDnh50dfKiglxcbybmMjDtq6n3tBq5eQZ//mPnPdh3jw5xHXIEDk73Ny58qIUlYcO1SmoNCpmzZJHI957T46U1DVmenr85O7OWDs75icmMikujju67sY0Nlq3lp3C+fOyk/D2hn/9Cxwd5YxLP/4If5cw30eAagXxiqWyXwYcSpcX1WdeU1G5byRJFvw8fx4mTAAHB1lIT5foazSs7tiRtkZGvHfhApfz89ncqRNNHgb57YZET0/OLR0UJOeR/uYbWYwvKAjatJEVWydMkNdAqDRaatJT2Imcae0z4JNSm4pKvWBgAFu3yg5h8GBIaAQLVCVJYoGjI185O7P7+nUCYmJI0WHkTaPHwUHuLVy8CNu2yesd5s2Th5aee06Wy1V7D42SmjiFXCHEMiFEmBBif8lW75ap/K2xtoaffpInnAcMgBs3dG2RTEjLlvzHzY3TOTl0j44mrnS6TJXy6OvL8wy7d8O5c/DGG3eTeT/2GLz/fsOJXanUiJo4hU8lSZonSVJ3SZJ8SrZ6t0zlb0/79nJEUnw8DB/eeIJaBtrYsM/Li+zCQvyjo4m4eVPXJj0ctGt3dzHcpk3ynMOcOfLQ0vDhsHev7sPOVGrkFNyBScCH3B06WlyfRqmolNC7N6xcKf9evPxygyUQq5Yu5uYc8vHBSl+fvseOsSM1VdcmPTwYGMhrHEJDIS4OXn0VwsLkdRDOznKIq3o/dUZNnMJgwEkI0VsIEVi89alvw1RUShg3Dt58U840uXSprq25SztjYyK8vfE0NWVobCxfXLqka5MePpydZSG+5GQ53KxlS3kVdatWcpa4ffsaz5PA34SaOIVjgGV9G6KiUhULF8r5YV5/XY5wbCzYGhgQ6uXFoKZNmX72LLPj4ylSf8TuHyMjWV/pwAF5vcO0aXK6vsBAeZJ6yRK4fl3XVv4tqIlTsAPOSJK0W5KkXSVbfRumolIajUaW+e/cWX6AjInRtUV3MdFq2e7mxtSWLfk4KYnRp0+Tp46N155OneQu4eXLsGaNHHXw2mtyL2L0aDkhR4njXb8eHBzo3aePHPG0fr0uLX8kqEmg9bx6t0JFpQaYmMCuXdC1q5wX5sgRWXWhMaCVJL5o3562hob83/nzXMnPZ7urK5b6agL6WmNsLOd2GDsWjh+Xxw+//17eXF3llKJbt8Lt23JqhQsXICREPjc4WJeWP9RU21MoHYaqhqSq6JoWLeTho4wMeU1UY4oIlSSJN+3tWdexIwdv3uTxmBiScnN1bdajgYeHnN/h8mV5UZyJiZxS9F5585wcOaJJpdZU6xQkScqSJCmzeMuVJKlQkqTMhjBORaUivP6/vTsPj6LMFj/+PQkhLAlrJAECyC5byIpXEQ0DenFGccNRBBTHZa4bXBeuCl63Gb0q+LvuOi6DOu4biIrbVaLjwpAFMKyCAcIWZVOMCwic3x9vJTQhSxPSqU7nfJ6nnnRXV1efroY69dZbdd5UePFFyM93ZxPC7UzN+KQk3k1JofjXXzmmoIDC0lK/Q4ocLVu6u6IXLHC3v1fGai4dlmBaCvGq2sqbmgFnAQ+FPjRjqnbqqe6ilTfeCM8DwxFt2/LPtDQUOG7hQj7escPvkCJP166HNt8E5ZAL4qnqbMAuSTW+u/pqdwr5rrtg5ky/ozlYSlwc89PT6RIby6ivvuKFygaQMLV3xx3uNFKgFi3cfFNrwRTEOzPgaRSQiY3fbMKACDz0kKuN9Oc/uzFeTjjB76gO1KVZMz5LS+P0JUsYt3w5G3btYkqXLkhVpz5M8Mo6k6dNQ4uLka5dXUKwTubDEkxL4dSA6d+BH4HTQhmUMcGKiXGjQvbs6UrshMnwwQdoExPD+4MHc26HDlxfVMRVq1ax1+5lqBvjxsHatXzy8ceuMqslhMMWzCWpT6rq54EzRGQo8F1oQjLm0LRp44rnHX20K9//5Zfu0vZwEhsVxfP9+pEcG8uM9evZuHs3L/TrR/PoaL9DM+YAwbQUHgxynjG+6dkTZs92B4tjxvg6nnyVokSY3rMn9/fqxZtbtzJi8WK2hmOgplGrsqUgIscAxwJHiMg1AS+1AuzwxoSd445zY7pMmOCqJDzxRNVXLfppUnIynWNjGbdsGUMXLuTdlBR6NG/ud1jGANW3FJoCcbjEER8w7QTGhD40Yw7d+PFw000uOcwI41q+Zx1xBB+lprL1t984pqCAvJ12648JD1W2FLy7lj8RkadVdV09xmTMYbntNvj6a1dss3dvN9BXOBraujWfp6VxcmEh2YsW8cqAAfy+fXu/wzKNXDB9CrEi8riIfCAiH5dNwaxcREaJyEoRWS0iN1Sz3BgRURHJDDpyY6oQFeXqqA0Z4i5GKSjwO6KqHdWyJV+mpdG3RQtGFxby1ObNfodkGrlgksKrwELgJmBKwFQtEYkGHgZOBvoDY0WkfyXLxQOTgH8FH7Yx1WveHN58ExIS3N3P4TzUQVJsLDmpqYxs25aLV67kljVrULtk1fgkmKSwR1UfVdUFqppfNgXxviHAalUtUtXdwEtUfn/DX4B7AKscZupUYqK7VPXHH11iCOcSRPFNmvDWoEFcmJTE7evWcdHKlfwWbkWdTKMQzH0Kb4nI5cAsYFfZTFWtacSLzsD6gOcbgKMDFxCRNKCLqr4tItdVtSIRuRS4FCAxMZGcnJwgwg4PpaWlDSpeP4R6G02b1o6pUwcxatQ2brttCeF8a8AEYB8ws6SEmYED2nvbpy3whg9xhTv7f1Z3gkkKF3h/A08ZKdCjhvdVdjFgeZtYRKKA/wUm1hSAqj4OPA6QmZmp2dnZNb0lbOTk5NCQ4vVDqLdRdrYriTNpUgLvvZfN9Okh+6g6MRx4pood3A6wf0+VsP9ndafGpKCq3Wu57g1Al4DnycCmgOfxwEAgx6sDkwTMEZHRqppXy880plJXXeXGiJ8xA/r2hYsv9jsiY8JTMC0FRGQgrrO4Wdk8VX22hrflAr1FpDuwETgXOC/g/T8ACQGfkQNcZwnBhMp998Hq1XDZZdC9O4wY4XdExoSfYAbZuQVX1uJBXMv2HmB0Te9T1T3AlcD7wHLgFVVdKiK3i0iN7zemrjVpAi+/DH36uFIYK1b4HVHtrKk42pgxdSiYq4/GACOAElW9EBgMxAazclWdq6p9VLWnqt7hzbtZVedUsmy2tRJMqLVu7a5IiolxxfO2bvU7okM3OC+P50pK7LJVExLBJIVfVHUfsEdEWuGqo9bUyWxM2Ore3d3DsGGDK7e9a1fN76lviTExlc5PiIkhNS6OCStWMG75cr7/7bd6jsxEumD6FPJEpA3wBJAPlAILQhqVMSF2zDFutLbzznMD9MycGV7F80qGDi1/XPHKmr2q3FVczC1r1vD5Dz/wj379OL5NGx+iNJEomDGaL1fV71X1MeBE4ALvNJIxDdrYsXDrrfDMM25Iz4YiWoRp3brxRXo6MSJkL1rEtKIiu9nN1IlgOpqPL5uArkAb77ExDd7NN7vWwtSp8NprfkdzaIa0asWizEwuTErizuJihi5cyKqff/Y7LNPABXP6KPCmtWa48hX5wO9CEpEx9UjEldleu9aNw9CtG2Rl+R1V8OKaNOGpo47i5HbtuPTrr0nLy+P+3r35U1KSjQNtaiWY00enBkwn4m44+zb0oRlTP5o1g1mzICkJRo+G4mK/Izp0Yzp04KvMTIa0asXFK1cyZulStlkntKmFYK4+qmgDLjEYEzE6dIB33oGff3bF83780e+IDl1ys2b83+DB3NOjB29t20ZKbi4f7djhd1imgQmmT+FBEXnAmx4C/gksDn1oxtSv/v3h1Vdh6VLXCb13r98RHbooEaZ07cr89HTio6M5cfFi/uubb9hlndAmSMG0FPJwfQj5wJfA9ao6PqRRGeOTk06CBx90rYbrqqzbG/7S4+MpyMzkz506MX39eo4pKGD5Tz/5HZZpAA5lkJ2FwGuq+nloQzLGX5ddBpMnu1pJjz3mdzS11yI6mkf79OHNgQNZv2sXGfn5PLZxo90JbapVZVIQkRgRuQ83JsJM4BmgqGxYTW8sBGMi0r33wh/+AFdeCR984Hc0h2d0QgJfZWYyrHVrLlu1itOWLGHL7t1+h2XCVHUthXuBOOBIVc1Q1TSgH9BDRB7FxvowESw6Gl58EQYMgLPPhmXL/I7o8HSMjeXdlBTu69WL97dvZ1BuLu9t2+Z3WCYMVZcUfg9coqrl12Go6k7gMlwZ7LEhjs0YX8XHw1tvufGeTzkFtmzxO6LDEyXC5ORkcjMySIiJ4eTCQv5z1Sp+bYg96iZkqksK+7SSk4+quhfYoqrzQxeWMeGha1eYMwc2b4bTT4dfI2Ak8ZS4OHIzMpjUuTP3b9xIVkEBheE8gLWpV9UlhWUicn7FmSIyHjc+gjGNwpAh8Oyz8MUXcNFFEAn9tM2jo7m/d2/mDhrElt27ycrP54ENG6wT2lSbFK4ArhCRHBG5V0RmiMgnwCTg8voJz5jwcPbZ8Ne/wgsvwF/+4nc0defk9u35KiuLE9u1Y/Lq1fy+sJCScKwlbupNlUlBVTeq6tHA7cBaoBi4XVWHqOrGeorPmLAxdSqcfz7ccgu89JLf0dSdDk2bMmfgQB7p3Zuc779nUF4ebzXE0YdMnQim9tHHqvqgqj6gqh/VR1DGhCMRePxxGDYMJk6E+RHUqyYiXNa5MwUZGSTHxjJ6yRIu//prfrZO6EanNrWPjGm0YmPhjTcgORlOO81VV40k/Vq2ZH56Otd16cKjmzaRkZ/PwoZYCMrUmiUFYw5RQoIb53n3blc8b+dOvyOqW7FRUUzv2ZMPU1LYuWcPRxcUMKO4mH3WCd0oWFIwphaOOsoNyrNiBZxzDuzZ43dEdW9ku3Z8lZXFKe3bM6WoiJMWL2ajdUJHPEsKxtTSiBHwyCPw3ntw9dV+RxMa7WNieH3AAJ7s25cvd+4kJTeXNxr6XXymWpYUjDkMl1wC114LDz3kpkgkIlzUsSMLMzPp0bw5Zy1dysUrVlAaic0jY0nBmMN1991uxLbJk+Hdd/2OJnT6tGjBF2lpTO3alb+XlJCen09upHWoGEsKxhyu6Gh4/nlISXH9C0uW+B1R6MRERXFHjx7MS03l1337OHbhQu5ct4691gkdMSwpGFMH4uJc8bz4eFc879sIH8X8hDZtWJyZyVkJCUxbs4bhixaxLhIKQxlLCsbUleRkVzxvyxZ3D8Mvv/gdUWi1jYnhxf79efaoo1hUWsrg3FxeivRs2AhYUjCmDmVkwHPPwYIFcOGFEOlDI4sIE5KSWJSZSf+WLRm7fDnnL1/OTuuEbrAsKRhTx844A+66C15+GW691e9o6keP5s35NDWVW7p14/lvvyU1L48vfvjB77BMLVhSMCYEpkyBP/3JVVR97jm/o6kfTaKiuLV7d/6ZloYCwxYu5NY1a9gT6c2lCGNJwZgQEIFHH4Xhw90YDJ995ndE9efY1q1ZnJnJuMREblu3juMXLaIo0jtYIoglBWNCpGlTVwqjWzd3SqmoyO+I6k+rJk14tl8/XujXj2U//URqXh7PlpTYID4NgCUFY0KoXTt45x3Yu9ddqvr9935HVL/GJiayOCuLtLg4LlixgrHLlrHjt9/8DstUw5KCMSHWu7crt716Nfzxj9DY9ondmjXj49RU7uzende3bmVwXh6fNLbs2ICENCmIyCgRWSkiq0Xkhkpev0ZElonIVyLykYh0C2U8xvglOxv+9jf48EOYNCkyxnk+FNEi3NitG1+kpdEsKorhixYxraiI36wTOuyELCmISDTwMHAy0B8YKyL9Kyy2EMhU1RTgNeCeUMVjjN8uvBCuvx4eewzuv9/vaPyR1aoVBRkZXNSxI3cWF3PswoWs+vlnv8MyAULZUhgCrFbVIlXdDbwEnBa4gKrOU9WyfxHzgeQQxmOM7+68E848E665xg3U0xjFNWnCE3378vqAART98gupeXk8tXmzdUKHCQnVDyEiY4BRqnqx93wCcLSqXlnF8g8BJar610peuxS4FCAxMTHjpQY0anppaSlxcXF+hxHWGts2+vXXKCZPTqO4uAUPPlhAr14/Vbt8JG+fLcBdQAEwDLgWaF2L9UTyNqorw4cPz1fVzBoXVNWQTMDZwJMBzycAD1ax7HhcSyG2pvVmZGRoQzJv3jy/Qwh7jXEbbdyompzspk2bql820rfP3n37dEZxscbk5Ginzz/X/9u+/ZDXEenbqC4AeRrEvjuUp482AF0CnicDmyouJCIjgWnAaFW1sf5Mo9Cpk6uqumOHG4uhMZ9WjxLh2i5d+Fd6Oq2aNGHk4sVM+eYbdlkntC9CmRRygd4i0l1EmgLnAnMCFxCRNOBvuITwXQhjMSbspKbCiy9Cfj6cf37kF8+rSVp8PPkZGVzWqRMz1q/n3woKWP5T9afWTN0LWVJQ1T3AlcD7wHLgFVVdKiK3i8hob7HpQBzwqogsEpE5VazOmIh06qkwYwa8/jrcdJPf0fivRXQ0j/Tpw5yBA9mwaxfp+fk8unGjdULXoyahXLmqzgXmVph3c8DjkaH8fGMagquvhpUr4X/+B/r0gYkT/Y7If6cmJFAYH8/EFSu4fNUq5m7fzlN9+9KhaVO/Q4t4dkezMT4TgYcegpEj4dJL4ZNP/I4oPCTFxjI3JYX7e/Xiw+3bScnN5b1t2/wOK+JZUjAmDMTEwKuvQs+e7j6GVav8jig8RIkwKTmZ3IwMjmjalJMLC5m8ahW/7t3rd2gRy5KCMWGiTRt3Q5uIK563fbvfEYWPQXFx5KanM7lzZx7YuJGsggIKS0v9DisihbRPwRhzaHr2hNmzYdgwaN++bG52+euJiVBS4kdk/msWHc19vXszql07Jq5YQUpe3oEL5OQAkBgTQ8nQofUfYISwloIxYea446p+7dtv6y+OcDWqfXsKs7KqfP3bxlaGto5ZUjDGNDhH2FVIIWNJwZgG5rPPYPduv6Mwkcr6FIxpYIYNg+bN4dhj3RjQ2dmQleWG/zTmcFlSMKaBmTXL9anm5Oy/C7p5cxg6dH+SyMy0JGFqx5KCMWEoMbHyTuXERDj9dDcBbNsGn366P0lMm+bmt2jhkkR2tksUmZnuXohIkhgTU2mncmKkfdF6ZknBmDAUeNlpTk4O2dnZlS7Xvj2ccYabALZurTxJtGx5YJLIyGj4SSLwstPqtpE5NJYUjIkgCQnujugzz3TPt251ZTPKksTUqW5+y5bu0teyJJGe3vCThKkblhSMiWAJCXDWWW4C2LLlwCRx441uflzc/iSRne1aEk1s79Ao2c9uTCNyxBEwZoybAL777sAkccMNbn5cnLvKqSxJpKdbkmgs7Gc2phHr0AHOPttN4Dq3A5PE9de7+fHxByaJtDRLEpHKflZjTLnERPjjH90ErsM7MEnM9UZHadXq4CQRHe1PzKZuWVIwxlQpKQnOOcdN4JJEWYLIyYF33nHzW7WC44/fnyRSUy1JNFSWFIwxQUtKgnPPdRPA5s0HJom333bzW7c+MEkMHmxJoqGwpGCMqbWOHWHsWDcBbNp0YJJ46y03v02bA5NESooliXBlScEYU2c6dYLzznMTwMaNByaJOXPc/LZtD04SUVaeMyxYUjDGhEznzjBunJsANmw4MEm8+aab37YtnHDC/iQxaJAlCb9YUjDG1JvkZBg/3k0A69cfmCRmz3bz27VzLYmyAn8DB1qSqC+WFIwxvunSBSZMcBNAcXHVSeKEE/YniQED3Kmq/UUDs8vX2ZiHLK0LlhSMMWGja1c4/3w3Aaxbd2CSmDXLzW/f3lWIrYwNWXp4rEFmjAlb3brBBRfAzJmwZo2bZs6EU07xO7LIZUnBGNNgHHkkTJwITz/tcyARzJKCMcaYcpYUjDHGlLOkYIxpkBITD22+CY4lBWNMg1RSAqpumjcvp/yxXY56eCwpGGOMKWdJwRhjTDlLCsYYY8pZUjDGGFPOkoIxxphyIU0KIjJKRFaKyGoRuaGS12NF5GXv9X+JyJGhjMcYY0z1QpYURCQaeBg4GegPjBWR/hUWuwjYoaq9gP8F7g5VPMYYY2oWypbCEGC1qhap6m7gJeC0CsucBjzjPX4NGCEiEsKYjDHGVCOUpbM7A+sDnm8Ajq5qGVXdIyI/AO2BrYELicilwKXe01IRWRmSiEMjgQrfxxzEtlH1bPvUzLZRzfoGs1Aok0JlR/xai2VQ1ceBx+siqPomInmqmul3HOHMtlH1bPvUzLZRzUQkL5jlQnn6aAPQJeB5MrCpqmVEpAnQGtgewpiMMcZUI5RJIRfoLSLdRaQpcC4wp8Iyc4ALvMdjgI9V9aCWgjHGmPoRstNHXh/BlcD7QDTwd1VdKiK3A3mqOgd4CviHiKzGtRDODVU8PmqQp73qmW2j6tn2qZlto5oFtY3EDsyNMcaUsTuajTHGlLOkYIwxppwlhRAQkS4iMk9ElovIUhGZ7HdM4UZEmonIAhFZ7G2j2/yOKVyJSLSILBSRt/2OJRyJyFoRKRSRRcFedtmYiEgbEXlNRFZ4+6Rjqls+lPcpNGZ7gGtVtUBE4oF8EflQVZf5HVgY2QX8TlVLRSQG+ExE3lXV+X4HFoYmA8uBVn4HEsaGq6rdvFa5+4H3VHWMdyVoi+oWtpZCCKjqZlUt8B7/iPsP3dnfqMKLOqXe0xhvsqseKhCRZOAPwJN+x2IaHhFpBRyPu9ITVd2tqt9X9x5LCiHmVX5NA/7lbyThxzstsgj4DvhQVW0bHew+4L+AfX4HEsYU+EBE8r2SOGa/HsAWYKZ3CvJJEWlZ3RssKYSQiMQBrwP/qao7/Y4n3KjqXlVNxd3tPkREBvodUzgRkVOA71Q13+9YwtxQVU3HVWS+QkSO9zugMNIESAceVdU04CfgoGEMAllSCBHvPPnrwPOq+obf8YQzrzmbA4zyOZRwMxQYLSJrcVWGfyciz/kbUvhR1U3e3++AWbgKzcbZAGwIaIW/hksSVbKkEAJe+e+ngOWq+v/8jiccicgRItLGe9wcGAms8Deq8KKqN6pqsqoeibvb/2NVHe9zWGFFRFp6F3PgnRY5CVjib1ThQ1VLgPUiUlYhdQRQ7QUvdvVRaAwFJgCF3jlzgKmqOtfHmMJNR+AZbzCmKOAVVbVLLs2hSgRmecOwNAFeUNX3/A0p7FwFPO9deVQEXFjdwlbmwhhjTDk7fWSMMaacJQVjjDHlLCkYY4wpZ0nBGGNMOUsKxhhjyllSMIdMRFRE7g14fp2I3FpH635aRMbUxbpq+JyzvYqR8yrMP1JEfvEqbpZN59ewrtNFpH+I4swRkaAHpBeR7KqqqYrIcV5l2hUislJErjjM9c31KnC2EZHLg43RhDdLCqY2dgFnikiC34EE8u55CNZFwOWqOryS175R1dSA6dka1nU6EJKkUFdEJAl4AfgPVT0Kdy/Nn0TkjNquU1V/792N3gawpBAhLCmY2tiDG+/16oovVDzSF5FS72+2iHwiIq+IyNcicpeIjPOOXAtFpGfAakaKyD+95U7x3h8tItNFJFdEvhKRPwesd56IvAAUVhLPWG/9S0Tkbm/ezcBxwGMiMj3YLy0ipSJyhzcGxHwRSRSRY4HRwHSvVdFTRC7x4lwsIq+LSIuAbfOAiHwhIkVl20lEokTkEXHjSrztHYEf1FoSkZNE5EsRKRCRV73aWojIKO/o/zPgzCrCvwJ4OqB671Zcob0pAbEd9Lt5WonILBFZJiKPiUiUt8xa78DgLqCn9/2ni0hHEfnUe75ERIYFu42N/ywpmNp6GBgnIq0P4T2DcWMDDMLd8d1HVYfgykJfFbDckcAJuJLRj4lIM9yR/Q+qmgVkAZeISHdv+SHANFU94GhdRDoBdwO/A1KBLBE5XVVvB/KAcao6pZI4y3ZwZVPZTq0lMF9VBwOfApeo6hfAHGCK16r4BnhDVbO85ZZ7sZfpiEtIp+B2puB25Ed62+Vi4KBBULyd703ASK/4Wx5wjbdtngBOBYYBSZV8H4ABQMXCenkE18IZAlzrxdeTgxPPDexvXU0BzgPe94odDgYWYRoMK3NhakVVd4rIs8Ak4Jcg35arqpsBROQb4ANvfiEQeBrnFVXdB6wSkSLgKFxNm5SAo9nWQG9gN7BAVddU8nlZQI6qbvE+83lcbfnZNcT5jbdDq2g3UHZ+PR84sYr3DxSRv+JOq8QB7we8Ntv7bstEJNGbdxzwqje/pGI/h+ffcDvwz8WVdGgKfInbNmtUdZX3HZ8DKisfLdR+vIoFqlrkrf9FL97Xqlk+F/i7uKKQs1XVkkIDYi0Fczjuwx0FB9Zn34P370rc3qtpwGu7Ah7vC3i+jwMPUCruvBS3U7sq4Dx/d1UtSyo/VRGfBPtFgvSb7q8Ls5eqD6qeBq5U1UHAbUCzgNcCt4FU+FsdwY05Ufb9+6tqWQskmJ39UqBih3UGrrUA1f9ulf0eVVLVT3HJdyPwj5o66k14saRgak1VtwOvcODpkbW4nQ3AabgR1Q7V2d559p64QUJW4o62L/OOPhGRPlLDYCG4gY1OEJEErxN6LPBJLeKpyY9AfMDzeGCzF+u4IN7/GXCW950TgexKlpkPDBWRXgAi0kJE+uAqy3YP6JMZW8VnPAxMFJFU7/3tgTuAv3ivr6Xq322IiHT3+hLO8eINdMD3F5FuuHEgnsBVC662VLMJL3b6yByue4ErA54/AbwpIguAj6j6KL46K3E770Tc1TK/isiTuPPuBd6R7BbcVT9VUtXNInIjSgRBkgAAAO9JREFUMA93pD1XVd8M4vN7yv7qtgB/V9UHqln+JeAJEZkEjAH+G5eQ1uFOjcVX815w426MwJV8/tp77w8VvssWEZkIvCgisd7sm1T1a3Gjjb0jIltxO+yDBivytsV44HGvH+hIYKKqliXJ6n63L3H9H4NwfSmzKqx7m4h8LiJLgHe97zFFRH4DSgFrKTQgViXVmDAgInGqWuodwS/AjSZWEsLPuwL4D+B4Vd0Rqs8xDY8lBWPCgIjk4DqmmwL3qOrTvgZkGi1LCsYYY8pZR7MxxphylhSMMcaUs6RgjDGmnCUFY4wx5SwpGGOMKff/AZcWzKCa/SV0AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.xlabel('Number of Entangled Qubits')\n",
    "plt.ylabel('Quantum Fidelity')\n",
    "plt.axis([1.4, 6, 0, 1])\n",
    "plt.grid()\n",
    "plt.plot([2,3,4,5], [0.812,0.735,0.592,0.457], 'ro-', label=\"Specific Algorithm - SQC\")\n",
    "plt.plot([2,3,4,5], [0.838,0.539,0.144,0.060], 'bs-', label=\"Arbitrary Initialization - SQC\")\n",
    "plt.plot([2,3,4,5], [0.788,0.734,0.628,0.542], 'mo-', label=\"Specific Algorithm - DNS\")\n",
    "plt.plot([2,3,4,5], [0.773,0.682,0.386,0.148], 'cs-', label=\"Arbitrary Initialization - DNS\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concluding remarks:\n",
    "\n",
    "The efficiency of the more compact specific algorithm as a deterministic $ |W_{n}\\rangle$ production tool, when estimated from the quantum fidelity, is clearly related to the linear progression of the number of required gates when n increases. On the other hand, the arbitrary initialization requires a number of gate increasing geometrically.\n",
    "This can be appreciated by looking at the qasm source and the circuit drawings of the respective circuits.\n",
    "\n",
    "The comparison between DNS and SQC shows a good fit of the simulator noise model with the real results of the ibmqx4 device.\n",
    "\n",
    "Beyond the comparison of two algorithms for deterministic production of multi-qubit W states, the approach presented here can be generalized to the study of a variety of other quantum states, for example GHZ.\n",
    " \n",
    "This type of approach can also be considered for the validation of device noise simulation models."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References:\n",
    "\n",
    "[1] Dür, W., Vidal, G., & Cirac, J. I. (2000). Three qubits can be entangled in two inequivalent ways. Physical Review A, 62(6), 062314. \n",
    "\n",
    "[2] Diker, F. (2016). Deterministic construction of arbitrary W states with quadratically increasing number of two-qubit gates. arXiv preprint arXiv:1606.09290. https://arxiv.org/abs/1606.09290v2\n",
    "\n",
    "[3] Smolin, J. A., Gambetta, J. M. & Smith, G. (2012). Efficient method for computing the maximum-likelihood quantum state from measurements with additive gaussian noise. Phys. Rev. Lett 108(7). https://link.aps.org/doi/10.1103/PhysRevLett.108.070502"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}