From 3f08650ae4edffffd07be0783c1996c0f7e4f162 Mon Sep 17 00:00:00 2001 From: Gopal M <46003265+gopalm-ai@users.noreply.github.com> Date: Tue, 26 Jul 2022 14:35:46 -0400 Subject: [PATCH 01/85] Created using Colaboratory --- Risk_Analysis_Hackathon.ipynb | 1158 +++++++++++++++++++++++++++++++++ 1 file changed, 1158 insertions(+) create mode 100644 Risk_Analysis_Hackathon.ipynb diff --git a/Risk_Analysis_Hackathon.ipynb b/Risk_Analysis_Hackathon.ipynb new file mode 100644 index 0000000..f0502a5 --- /dev/null +++ b/Risk_Analysis_Hackathon.ipynb @@ -0,0 +1,1158 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1meodHDHu2qx" + }, + "outputs": [], + "source": [ + "# Sensitivity Risk Analysis - Hackathon Project" + ] + }, + { + "cell_type": "code", + "source": [ + "!pip3 install qiskit\n", + "!pip3 install dimod\n", + "!pip3 install greedy\n", + "!pip3 install numpy\n", + "!pip3 install pylatexenc\n", + "#!pip3 install qiskit_textbook" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JnHjmawi5_dp", + "outputId": "b5716fe5-843e-46d7-dbd1-c501b170f879" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting qiskit\n", + " Downloading qiskit-0.37.0.tar.gz (13 kB)\n", + "Collecting qiskit-terra==0.21.0\n", + " Downloading qiskit_terra-0.21.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (6.7 MB)\n", + "\u001b[K |████████████████████████████████| 6.7 MB 4.1 MB/s \n", + "\u001b[?25hCollecting qiskit-aer==0.10.4\n", + " Downloading qiskit_aer-0.10.4-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (18.0 MB)\n", + "\u001b[K |████████████████████████████████| 18.0 MB 250 kB/s \n", + "\u001b[?25hCollecting qiskit-ibmq-provider==0.19.2\n", + " Downloading qiskit_ibmq_provider-0.19.2-py3-none-any.whl (240 kB)\n", + "\u001b[K |████████████████████████████████| 240 kB 49.1 MB/s \n", + "\u001b[?25hRequirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aer==0.10.4->qiskit) (1.7.3)\n", + "Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-aer==0.10.4->qiskit) (1.21.6)\n", + "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (2.8.2)\n", + "Collecting requests-ntlm>=1.1.0\n", + " Downloading requests_ntlm-1.1.0-py2.py3-none-any.whl (5.7 kB)\n", + "Collecting websockets>=10.0\n", + " Downloading websockets-10.3-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (112 kB)\n", + "\u001b[K |████████████████████████████████| 112 kB 49.6 MB/s \n", + "\u001b[?25hCollecting websocket-client>=1.0.1\n", + " Downloading websocket_client-1.3.3-py3-none-any.whl (54 kB)\n", + "\u001b[K |████████████████████████████████| 54 kB 2.5 MB/s \n", + "\u001b[?25hRequirement already satisfied: urllib3>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (1.24.3)\n", + "Requirement already satisfied: requests>=2.19 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (2.23.0)\n", + "Collecting ply>=3.10\n", + " Downloading ply-3.11-py2.py3-none-any.whl (49 kB)\n", + "\u001b[K |████████████████████████████████| 49 kB 5.6 MB/s \n", + "\u001b[?25hRequirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (1.7.1)\n", + "Collecting retworkx>=0.11.0\n", + " Downloading retworkx-0.11.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.6 MB)\n", + "\u001b[K |████████████████████████████████| 1.6 MB 49.9 MB/s \n", + "\u001b[?25hCollecting shared-memory38\n", + " Downloading shared_memory38-0.1.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl (25 kB)\n", + "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (0.3.5.1)\n", + "Collecting symengine>=0.9\n", + " Downloading symengine-0.9.2-cp37-cp37m-manylinux2010_x86_64.whl (37.5 MB)\n", + "\u001b[K |████████████████████████████████| 37.5 MB 1.2 MB/s \n", + "\u001b[?25hRequirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (4.1.1)\n", + "Collecting tweedledum<2.0,>=1.1\n", + " Downloading tweedledum-1.1.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (943 kB)\n", + "\u001b[K |████████████████████████████████| 943 kB 53.5 MB/s \n", + "\u001b[?25hRequirement already satisfied: psutil>=5 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (5.4.8)\n", + "Collecting stevedore>=3.0.0\n", + " Downloading stevedore-3.5.0-py3-none-any.whl (49 kB)\n", + "\u001b[K |████████████████████████████████| 49 kB 5.7 MB/s \n", + "\u001b[?25hRequirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.8.0->qiskit-ibmq-provider==0.19.2->qiskit) (1.15.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.19.2->qiskit) (2022.6.15)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.19.2->qiskit) (2.10)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.19.2->qiskit) (3.0.4)\n", + "Collecting cryptography>=1.3\n", + " Downloading cryptography-37.0.4-cp36-abi3-manylinux_2_24_x86_64.whl (4.1 MB)\n", + "\u001b[K |████████████████████████████████| 4.1 MB 35.8 MB/s \n", + "\u001b[?25hCollecting ntlm-auth>=1.0.2\n", + " Downloading ntlm_auth-1.5.0-py2.py3-none-any.whl (29 kB)\n", + "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.7/dist-packages (from cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.19.2->qiskit) (1.15.1)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.12->cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.19.2->qiskit) (2.21)\n", + "Requirement already satisfied: importlib-metadata>=1.7.0 in /usr/local/lib/python3.7/dist-packages (from stevedore>=3.0.0->qiskit-terra==0.21.0->qiskit) (4.12.0)\n", + "Collecting pbr!=2.1.0,>=2.0.0\n", + " Downloading pbr-5.9.0-py2.py3-none-any.whl (112 kB)\n", + "\u001b[K |████████████████████████████████| 112 kB 60.8 MB/s \n", + "\u001b[?25hRequirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=1.7.0->stevedore>=3.0.0->qiskit-terra==0.21.0->qiskit) (3.8.1)\n", + "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.7/dist-packages (from sympy>=1.3->qiskit-terra==0.21.0->qiskit) (1.2.1)\n", + "Building wheels for collected packages: qiskit\n", + " Building wheel for qiskit (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for qiskit: filename=qiskit-0.37.0-py3-none-any.whl size=12028 sha256=85d0c7367b42fcd77cb3d2298956de90f45bbe23388cc5f86a1c290e0e773eb7\n", + " Stored in directory: /root/.cache/pip/wheels/ed/f9/fa/3ed81abb79590bf4c0432e7816bcdf3f0dbd1ba5aeb3eeddf7\n", + "Successfully built qiskit\n", + "Installing collected packages: pbr, tweedledum, symengine, stevedore, shared-memory38, retworkx, ply, ntlm-auth, cryptography, websockets, websocket-client, requests-ntlm, qiskit-terra, qiskit-ibmq-provider, qiskit-aer, qiskit\n", + "Successfully installed cryptography-37.0.4 ntlm-auth-1.5.0 pbr-5.9.0 ply-3.11 qiskit-0.37.0 qiskit-aer-0.10.4 qiskit-ibmq-provider-0.19.2 qiskit-terra-0.21.0 requests-ntlm-1.1.0 retworkx-0.11.0 shared-memory38-0.1.2 stevedore-3.5.0 symengine-0.9.2 tweedledum-1.1.1 websocket-client-1.3.3 websockets-10.3\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting dimod\n", + " Downloading dimod-0.11.4-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (11.8 MB)\n", + "\u001b[K |████████████████████████████████| 11.8 MB 5.2 MB/s \n", + "\u001b[?25hRequirement already satisfied: numpy<2.0.0,>=1.17.3 in /usr/local/lib/python3.7/dist-packages (from dimod) (1.21.6)\n", + "Installing collected packages: dimod\n", + "Successfully installed dimod-0.11.4\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting greedy\n", + " Downloading greedy-0.1.1-py3-none-any.whl (19 kB)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.7/dist-packages (from greedy) (2.6.3)\n", + "Collecting geopandas\n", + " Downloading geopandas-0.10.2-py2.py3-none-any.whl (1.0 MB)\n", + "\u001b[K |████████████████████████████████| 1.0 MB 5.3 MB/s \n", + "\u001b[?25hCollecting libpysal\n", + " Downloading libpysal-4.6.2-py3-none-any.whl (2.4 MB)\n", + "\u001b[K |████████████████████████████████| 2.4 MB 40.9 MB/s \n", + "\u001b[?25hCollecting fiona>=1.8\n", + " Downloading Fiona-1.8.21-cp37-cp37m-manylinux2014_x86_64.whl (16.7 MB)\n", + "\u001b[K |████████████████████████████████| 16.7 MB 457 kB/s \n", + "\u001b[?25hCollecting pyproj>=2.2.0\n", + " Downloading pyproj-3.2.1-cp37-cp37m-manylinux2010_x86_64.whl (6.3 MB)\n", + "\u001b[K |████████████████████████████████| 6.3 MB 40.9 MB/s \n", + "\u001b[?25hRequirement already satisfied: pandas>=0.25.0 in /usr/local/lib/python3.7/dist-packages (from geopandas->greedy) (1.3.5)\n", + "Requirement already satisfied: shapely>=1.6 in /usr/local/lib/python3.7/dist-packages (from geopandas->greedy) (1.8.2)\n", + "Requirement already satisfied: six>=1.7 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (1.15.0)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (57.4.0)\n", + "Requirement already satisfied: attrs>=17 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (21.4.0)\n", + "Collecting click-plugins>=1.0\n", + " Downloading click_plugins-1.1.1-py2.py3-none-any.whl (7.5 kB)\n", + "Requirement already satisfied: click>=4.0 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (7.1.2)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (2022.6.15)\n", + "Collecting cligj>=0.5\n", + " Downloading cligj-0.7.2-py3-none-any.whl (7.1 kB)\n", + "Collecting munch\n", + " Downloading munch-2.5.0-py2.py3-none-any.whl (10 kB)\n", + "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas->greedy) (2.8.2)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas->greedy) (2022.1)\n", + "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas->greedy) (1.21.6)\n", + "Requirement already satisfied: appdirs in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (1.4.4)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (2.11.3)\n", + "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (4.6.3)\n", + "Requirement already satisfied: scipy>=0.11 in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (1.7.3)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (2.23.0)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (21.3)\n", + "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->libpysal->greedy) (2.0.1)\n", + "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging->libpysal->greedy) (3.0.9)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->libpysal->greedy) (1.24.3)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->libpysal->greedy) (3.0.4)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->libpysal->greedy) (2.10)\n", + "Installing collected packages: munch, cligj, click-plugins, pyproj, fiona, libpysal, geopandas, greedy\n", + "Successfully installed click-plugins-1.1.1 cligj-0.7.2 fiona-1.8.21 geopandas-0.10.2 greedy-0.1.1 libpysal-4.6.2 munch-2.5.0 pyproj-3.2.1\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (1.21.6)\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting pylatexenc\n", + " Downloading pylatexenc-2.10.tar.gz (162 kB)\n", + "\u001b[K |████████████████████████████████| 162 kB 5.1 MB/s \n", + "\u001b[?25hBuilding wheels for collected packages: pylatexenc\n", + " Building wheel for pylatexenc (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for pylatexenc: filename=pylatexenc-2.10-py3-none-any.whl size=136835 sha256=456654fdc157d7cd7abfe321f77450c462f8264b5ef3015358659c43e7359aad\n", + " Stored in directory: /root/.cache/pip/wheels/f1/8a/f5/33ee79d4473eb201b519fa40f989b842e373237395a3421f52\n", + "Successfully built pylatexenc\n", + "Installing collected packages: pylatexenc\n", + "Successfully installed pylatexenc-2.10\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!git clone https://github.com/JoSQUANTUM/pygrnd.git\n", + "#!pip3 install pygrnd" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RnBz315r3-mE", + "outputId": "7a06157f-6753-4306-f1fd-286b5788549f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Cloning into 'pygrnd'...\n", + "remote: Enumerating objects: 199, done.\u001b[K\n", + "remote: Counting objects: 100% (199/199), done.\u001b[K\n", + "remote: Compressing objects: 100% (148/148), done.\u001b[K\n", + "remote: Total 199 (delta 101), reused 129 (delta 50), pack-reused 0\u001b[K\n", + "Receiving objects: 100% (199/199), 553.72 KiB | 1.22 MiB/s, done.\n", + "Resolving deltas: 100% (101/101), done.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "#cd pygrnd\n", + "!pip3 install pygrnd/" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cFq0lMnM6Wzv", + "outputId": "ec78bc83-e365-4ba7-db30-fc7fc116f3be" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Processing ./pygrnd\n", + "\u001b[33m DEPRECATION: A future pip version will change local packages to be built in-place without first copying to a temporary directory. We recommend you use --use-feature=in-tree-build to test your packages with this new behavior before it becomes the default.\n", + " pip 21.3 will remove support for this functionality. You can find discussion regarding this at https://github.com/pypa/pip/issues/7555.\u001b[0m\n", + "Building wheels for collected packages: pygrnd\n", + " Building wheel for pygrnd (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for pygrnd: filename=pygrnd-0.1.0-py3-none-any.whl size=37571 sha256=d6ac8e98b015045b0cbe504195eae5fba3a3e5f21761bd5c387837c6bcc784ae\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-kwk9oygi/wheels/c6/b7/c0/b186dda1ea5b65ef883a645b27ad64a14b7eb0f729a6d523e8\n", + "Successfully built pygrnd\n", + "Installing collected packages: pygrnd\n", + "Successfully installed pygrnd-0.1.0\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from pygrnd.qc.helper import *\n", + "from pygrnd.qc.brm import *\n", + "from pygrnd.qc.brm_oracle import *\n", + "from pygrnd.qc.QAE import *\n", + "\n", + "from qiskit import execute\n", + "from qiskit import Aer\n", + "\n", + "from math import pi\n", + "import math\n", + "import cmath\n", + "import random\n", + "from qiskit.visualization import plot_histogram\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import norm\n", + "import networkx as nx\n", + "from IPython.display import Image" + ], + "metadata": { + "id": "4HSrlI8d8sNa" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Small Example" + ], + "metadata": { + "id": "sVQ25bzqN-mk" + } + }, + { + "cell_type": "code", + "source": [ + "## small example\n", + "\n", + "nodes=['0','1'] # risk items defition\n", + "edges=[('0','1')] # correlations\n", + "\n", + "probsNodes={'0':0.1,'1':0.1} # intrinsic probs\n", + "probsEdges={('0','1'):0.2} # transition probs\n", + "\n", + "print(\"Number of risk items = \",len(nodes))\n", + "print(\"Number of correlations = \",len(edges))" + ], + "metadata": { + "id": "zyjXGl6f67vR", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "34afa17b-6500-46ee-c874-95547b265b25" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Number of risk items = 2\n", + "Number of correlations = 1\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", + "rm.draw(output='mpl')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 140 + }, + "id": "MCO78g5z97YO", + "outputId": "7b9fea13-c884-440a-84ef-cd2dcf0d483c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 16 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# execute function to build a qiskit gate with the risk model\n", + "#rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", + "\n", + "rm.measure_all()\n", + "display(rm.draw(output='mpl'))\n", + "print(\"-------------------------------\")\n", + "\n", + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(rm, backend,shots=100000)\n", + "result=job.result()\n", + "counts=job.result().get_counts()\n", + "plot_histogram(counts,figsize=(16,8))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 680 + }, + "id": "E6rrMZzV9-iK", + "outputId": "bd9a07af-13f0-4ac5-8986-ff2bc307afa9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "-------------------------------\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 17 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## evaluate classically\n", + "modelProbabilities(nodes,edges,probsNodes,probsEdges)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xX6Xw84P9-lM", + "outputId": "ee81da7e-0e86-4285-b5f6-77a6d1b4fcf0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "([0.81, 0.08999999999999998, 0.072, 0.027999999999999987], 1.0)" + ] + }, + "metadata": {}, + "execution_count": 18 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## building the graph from adjacency matrix for visual representation\n", + "G = nx.Graph()\n", + "G = nx.from_numpy_array(mat)\n", + "nx.draw(G, with_labels=True, alpha=0.8, node_size=500)" + ], + "metadata": { + "id": "crnI_6km9-oB", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 319 + }, + "outputId": "66316016-d470-4bbb-8f04-237c880ef4ba" + }, + "execution_count": 19, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "## use Oracle to build QAE and evaluate probabaility for state 'STATELIST'\n", + "name=\"test\"\n", + "STATELIST=[\"11\"] # we search for the joint probability where both parameters are triggered\n", + "Nshots=1000 # number of shots\n", + "QAEqubits=4 # QAE bit precision --> 8 bit strings at the end of the measurement to differentiate 2^8 = 265 bins\n", + "\n", + "\n", + "#rm = BRMlist(RIlist,TPlist,model2gate=True)\n", + "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=True) \n", + "ora = brmoracle(\"ora\",rm,len(nodes),0,STATELIST)\n", + "QAE=qae(QAEqubits,len(nodes),len(nodes),rm,ora)\n" + ], + "metadata": { + "id": "nIUFoxxp9-qm" + }, + "execution_count": 20, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## execution with local quantum simulator (qasm simulator)" + ], + "metadata": { + "id": "a_YVRnVN9-td" + }, + "execution_count": 21, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(QAE, backend,shots=Nshots)\n", + "result=job.result()\n", + "counts=job.result().get_counts()\n", + "plot_histogram(counts,figsize=(16,8))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 511 + }, + "id": "9S0RLSI2_PEM", + "outputId": "7b59a152-9a65-4978-f7ce-6bbc45482925" + }, + "execution_count": 22, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 22 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Larger Example" + ], + "metadata": { + "id": "SzuW3MS6N6sm" + } + }, + { + "cell_type": "code", + "source": [ + "## large example\n", + "\n", + "nodes=['0','1','2','3','4','5'] # risk items defition\n", + "edges=[('0','1'),('0','2'),('1','2'),('1','3'),('1','4'),('2','3'),('2','4'),('2','5'),('3','4'),('3','5'),('4','5')] # risk items correlations\n", + "\n", + "probsNodes={'0':0.1,'1':0.2,'2':0.2,'3':0.3,'4':0.1,'5':0.1} # intrinsic probs\n", + "probsEdges={('0','1'):0.2, ('0','2'):0.3, ('1','2'):0.2, ('1','3'):0.3, ('1','4'):0.2, ('2','3'):0.3, ('2','4'):0.2, ('2','5'):0.3, ('3','4'):0.2, ('3','5'):0.5} # transition probs\n", + "\n", + "print(\"Number of risk items = \", len(nodes))\n", + "print(\"Number of correlations = \", len(edges))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7VnztBVp_PHR", + "outputId": "a40abddc-ed2a-4ab6-c3bf-5011dbc385af" + }, + "execution_count": 24, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Number of risk items = 6\n", + "Number of correlations = 11\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", + "rm.draw(output='mpl')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 997 + }, + "id": "RaIqTyBd_PKg", + "outputId": "e1388e08-8ba3-467c-d7f5-16a8bef87170" + }, + "execution_count": 25, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "NOTE: Item 2 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 3 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 4 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 5 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 25 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# execute function to build a qiskit gate with the risk model\n", + "#rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", + "\n", + "rm.measure_all()\n", + "display(rm.draw(output='mpl'))\n", + "print(\"-------------------------------\")\n", + "\n", + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(rm, backend,shots=100000)\n", + "result=job.result()\n", + "counts=job.result().get_counts()\n", + "plot_histogram(counts,figsize=(16,8))" + ], + "metadata": { + "id": "v_6D2LoE991Y", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "1fa7b6cf-e8a3-4d0a-e5e5-7e5ade5f68e6" + }, + "execution_count": 26, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "-------------------------------\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 26 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## building the graph from adjacency matrix for visual representation\n", + "G = nx.Graph()\n", + "G = nx.from_numpy_array(mat)\n", + "nx.draw(G, with_labels=True, alpha=0.8, node_size=500)" + ], + "metadata": { + "id": "rERzrEyX996k", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 319 + }, + "outputId": "0b2299c3-aff4-4d58-e8b9-692a271319d4" + }, + "execution_count": 28, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "## use Oracle to build QAE and evaluate probabaility for state 'STATELIST'\n", + "name = \"test\"\n", + "STATELIST = [\"111111\"] # we search for the joint probability where all 6 parameters are triggered\n", + "Nshots = 100000 # number of shots\n", + "QAEqubits = 8 # QAE bit precision --> 8 bit strings at the end of the measurement to differentiate 2^8 = 265 bins\n", + "\n", + "\n", + "#rm = BRMlist(RIlist,TPlist,model2gate=True)\n", + "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=True) \n", + "ora = brmoracle(\"ora\",rm,len(nodes),0,STATELIST)\n", + "QAE=qae(QAEqubits,len(nodes),len(nodes),rm,ora)" + ], + "metadata": { + "id": "I6snOMVZ999e", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "f78e6245-484d-4b82-f2eb-643b32e3b5d8" + }, + "execution_count": 29, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "NOTE: Item 2 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 3 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 4 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 5 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "## execution with local quantum simulator (qasm simulator)" + ], + "metadata": { + "id": "LV9AZICL9-Am" + }, + "execution_count": 30, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(QAE, backend,shots=Nshots)\n", + "result=job.result()\n", + "counts=job.result().get_counts()\n", + "plot_histogram(counts,figsize=(16,8))" + ], + "metadata": { + "id": "tHtZ9Jct7Fk1", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 544 + }, + "outputId": "322ec32e-4ba9-45b3-85ff-57bb6cdc7d34" + }, + "execution_count": 31, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 31 + } + ] + }, + { + "cell_type": "code", + "source": [ + "plot_histogram(counts,figsize=(50,30))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 832 + }, + "id": "vLim1948JiGW", + "outputId": "c226de2d-152e-4899-f149-1b20e690115c" + }, + "execution_count": 32, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 32 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# post processing: we see two different peaks from the QAE\n", + "\n", + "showQAEoutput(counts,STATELIST,QAEqubits)" + ], + "metadata": { + "id": "AEcQ0X_h7FoN", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "eeb1aa82-bcc0-4ba3-dcd0-8330eac98097" + }, + "execution_count": 33, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Bin with the highest probability: 00000010\n", + "Number of Bin with the highest probability: 2\n", + "The probability of the tail event ['111111'] is: 0.0006022718974138037\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.0006022718974138037" + ] + }, + "metadata": {}, + "execution_count": 33 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Even Larger Example" + ], + "metadata": { + "id": "8dR2Kh4xQJr_" + } + }, + { + "cell_type": "code", + "source": [ + "## large example\n", + "\n", + "nodes=['0','1','2','3','4','5','6','7'] # risk items defition\n", + "edges=[('0','1'),('0','2'),('1','2'),('1','3'),('1','4'),('2','3'),('2','4'),('2','5'),('3','4'),('3','5'),('4','5'),('5','6'),('5','7'),('6','7')] # risk items correlations\n", + "\n", + "probsNodes={'0':0.1, '1':0.2, '2':0.1, '3':0.2, '4':0.1, '5':0.1, '6':0.1, '7':0.1} # intrinsic probs\n", + "probsEdges={('0','1'):0.2, ('0','2'):0.3, ('1','2'):0.2, ('1','3'):0.3, ('1','4'):0.2, ('2','3'):0.3, ('2','4'):0.2, \n", + " ('2','5'):0.3, ('3','4'):0.2, ('3','5'):0.5, ('5','6'):0.3, ('5','7'):0.2} # transition probs\n", + "\n", + "print(\"Number of risk items = \", len(nodes))\n", + "print(\"Number of correlations = \", len(edges))" + ], + "metadata": { + "id": "f98E7QstC0Qc", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "67621486-971d-46a5-fdfd-5846d25ccd69" + }, + "execution_count": 34, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Number of risk items = 8\n", + "Number of correlations = 14\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", + "rm.draw(output='mpl')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "UrAnYtuvRIeT", + "outputId": "e0c72593-3144-49de-bde8-493fdedab387" + }, + "execution_count": 35, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "NOTE: Item 2 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 3 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 4 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 5 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "source": [ + "rm.measure_all()\n", + "display(rm.draw(output='mpl'))\n", + "print(\"-------------------------------\")\n", + "\n", + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(rm, backend,shots=100000)\n", + "result=job.result()\n", + "counts=job.result().get_counts()\n", + "plot_histogram(counts,figsize=(16,8))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "eJiTuNg5RNu5", + "outputId": "371519e7-c648-4812-b241-330be702b69a" + }, + "execution_count": 36, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "-------------------------------\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 36 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## building the graph from adjacency matrix for visual representation\n", + "G = nx.Graph()\n", + "G = nx.from_numpy_array(mat)\n", + "nx.draw(G, with_labels=True, alpha=0.8, node_size=500)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 222 + }, + "id": "KsSdy8ijRgLL", + "outputId": "c73e679b-b6ef-4aa9-9872-39031721baa7" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m## building the graph from adjacency matrix for visual representation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mG\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mG\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_numpy_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwith_labels\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.8\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m500\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'nx' is not defined" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "## use Oracle to build QAE and evaluate probabaility for state 'STATELIST'\n", + "name = \"test\"\n", + "STATELIST = [\"11111111\"] # we search for the joint probability where all 8 parameters are triggered\n", + "Nshots = 100000 # number of shots\n", + "QAEqubits = 12 # QAE bit precision --> 8 bit strings at the end of the measurement to differentiate 2^8 = 265 bins\n", + "\n", + "\n", + "#rm = BRMlist(RIlist,TPlist,model2gate=True)\n", + "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=True) \n", + "ora = brmoracle(\"ora\",rm,len(nodes),0,STATELIST)\n", + "QAE=qae(QAEqubits,len(nodes),len(nodes),rm,ora)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "URNLmbppRtF3", + "outputId": "5190c224-5913-49ac-cb36-9c4762b79701" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "NOTE: Item 2 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 3 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 4 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 5 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "## execution with local quantum simulator (qasm simulator)\n", + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(QAE, backend,shots=Nshots)\n", + "result=job.result()\n", + "counts=job.result().get_counts()\n", + "plot_histogram(counts,figsize=(70,30))" + ], + "metadata": { + "id": "98ixVKlqR66o" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# post processing: we see two different peaks from the QAE\n", + "\n", + "showQAEoutput(counts,STATELIST,QAEqubits)" + ], + "metadata": { + "id": "H5cYNrUKUwS8" + }, + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + }, + "colab": { + "name": "Risk_Analysis_Hackathon.ipynb", + "provenance": [], + "include_colab_link": true + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From b93b53443161871dfa02c866430f89da5dbdc6bb Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 14:59:04 -0400 Subject: [PATCH 02/85] Create Business_Application.md --- Business_Application.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 Business_Application.md diff --git a/Business_Application.md b/Business_Application.md new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/Business_Application.md @@ -0,0 +1 @@ + From 0a5afb2f5268879f8ac6b34dee3bd3a42c9872bf Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 15:05:50 -0400 Subject: [PATCH 03/85] Update Business_Application.md --- Business_Application.md | 56 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/Business_Application.md b/Business_Application.md index 8b13789..c5086a2 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -1 +1,57 @@ +# Business Application of Quantum Algorithm for the Sensitivity Analysis of Business Risks + +# Technical problem + +- Graphs + +Full stack approach: + +- Problem definition + +- Quantum algorithm + +- Compilation (Processor design / gate implementation) + +- Performance analysis + +- Hubbard model: + +$H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ + +i and j denote the sites which are adjacent to each other. + +total density operator $\hat{n}_i = ...$ + +Tight binding model + + +# Real-world problems + +- Correlation clustering problem (undirected graph): Multiple-person pose estimation [Pishchulin et al., 2016] + + + +Solid material structures such as graphene, ferromagnetic lattices, Silicium square and cubic lattices. + +# Potential customers + +Potential customers of a simulation tool to predict the band structures of solid materials are photovoltaics companies.. + +Solid material structures such as graphene, ferromagnetic lattices, Silicium square and cubic lattices can also be simulated with the Hubbard model. Such materials can be found in a wide range of applications such as aviation composites, semi-conductors and specialized coatings. + + +# Video for customer value proposition + + +# References + +[1] + +[2] + +[3] + +[4] + +[5] From 5e483b38efb7edc4d95ce7629bf2385dba5121eb Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 15:07:57 -0400 Subject: [PATCH 04/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index c5086a2..9cac0df 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -46,7 +46,7 @@ Solid material structures such as graphene, ferromagnetic lattices, Silicium squ # References -[1] +[1] M.C. Braun et al., A Quantum Algorithm for the Sensitivity Analysis of Business Risks (2021), https://arxiv.org/abs/2103.05475 [2] From 35c22eafb0233b42977587ba71d66f8d80b3e57c Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 15:55:35 -0400 Subject: [PATCH 05/85] Update Business_Application.md --- Business_Application.md | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 9cac0df..e7aeb72 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -1,11 +1,7 @@ # Business Application of Quantum Algorithm for the Sensitivity Analysis of Business Risks -# Technical problem - -- Graphs - -Full stack approach: +# Quantum algorithm - Problem definition @@ -36,9 +32,10 @@ Solid material structures such as graphene, ferromagnetic lattices, Silicium squ # Potential customers -Potential customers of a simulation tool to predict the band structures of solid materials are photovoltaics companies.. +Potential customers for the Sensitivity Analysis of Business Risks includes banks, and any financial institute dealing with risk analysis +and any company dealing with portfolio.. -Solid material structures such as graphene, ferromagnetic lattices, Silicium square and cubic lattices can also be simulated with the Hubbard model. Such materials can be found in a wide range of applications such as aviation composites, semi-conductors and specialized coatings. +Such analyses can be found in a wide range of applications such as .. # Video for customer value proposition From b0659498908f1093dd85598685d5a23d82b4ca6e Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 15:59:56 -0400 Subject: [PATCH 06/85] Update Business_Application.md --- Business_Application.md | 4 ---- 1 file changed, 4 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index e7aeb72..75848d9 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -5,13 +5,10 @@ - Problem definition -- Quantum algorithm - - Compilation (Processor design / gate implementation) - Performance analysis -- Hubbard model: $H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ @@ -27,7 +24,6 @@ Tight binding model - Correlation clustering problem (undirected graph): Multiple-person pose estimation [Pishchulin et al., 2016] - Solid material structures such as graphene, ferromagnetic lattices, Silicium square and cubic lattices. # Potential customers From b647d35c4e02892281f845ea5814ecda500d92da Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 16:02:15 -0400 Subject: [PATCH 07/85] Update Business_Application.md --- Business_Application.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 75848d9..f4cdf7d 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -16,8 +16,6 @@ i and j denote the sites which are adjacent to each other. total density operator $\hat{n}_i = ...$ -Tight binding model - # Real-world problems From f89994487e9b84260d1b482c6dd86bf933f8d3f6 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 16:06:45 -0400 Subject: [PATCH 08/85] Update Business_Application.md --- Business_Application.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index f4cdf7d..b90dcff 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -7,8 +7,8 @@ - Compilation (Processor design / gate implementation) -- Performance analysis - +- Performance analysis: +- Following the methology by Deutsche Borse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. $H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ From 6467503ce4ab896c711f32c0ae6186da239e70dc Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 16:07:00 -0400 Subject: [PATCH 09/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index b90dcff..d1bbc4d 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -8,7 +8,7 @@ - Compilation (Processor design / gate implementation) - Performance analysis: -- Following the methology by Deutsche Borse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. + Following the methology by Deutsche Borse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. $H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ From 441d9b63525efb10ef4582b58aec181c97abe3b5 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 16:10:40 -0400 Subject: [PATCH 10/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index d1bbc4d..58e5664 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -8,7 +8,7 @@ - Compilation (Processor design / gate implementation) - Performance analysis: - Following the methology by Deutsche Borse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. + Following the methology by Deutsche Borse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. We implement and analysis the risk modeling and its representation on quantum circuits. $H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ From eef7e18c3987433973efa4864e4e10e4ed80728b Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 17:18:55 -0400 Subject: [PATCH 11/85] Update Business_Application.md --- Business_Application.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 58e5664..5460844 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -3,7 +3,9 @@ # Quantum algorithm -- Problem definition +- Problem definition: +Quantum algorithms are known for super-polynomial speedup over known classical ones. +They can be applied to various real-world problems such as cryptography, search and optimisation, simulations and solving large systems of linear equations. - Compilation (Processor design / gate implementation) From 01fcdc9f50a957a09bf26d800015093ff5c9a016 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 17:25:14 -0400 Subject: [PATCH 12/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 5460844..2b76784 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -5,7 +5,7 @@ - Problem definition: Quantum algorithms are known for super-polynomial speedup over known classical ones. -They can be applied to various real-world problems such as cryptography, search and optimisation, simulations and solving large systems of linear equations. +They can be applied to various real-world problems such as cryptography, optimisation, and simulations. - Compilation (Processor design / gate implementation) From 6f9d2cc36ffccc094d0a7f394105cd2f982113ee Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 17:28:34 -0400 Subject: [PATCH 13/85] Update Business_Application.md --- Business_Application.md | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 2b76784..aebf1b7 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -4,7 +4,7 @@ # Quantum algorithm - Problem definition: -Quantum algorithms are known for super-polynomial speedup over known classical ones. +Quantum algorithms are known for super-polynomial speedup over their classical counterparts. They can be applied to various real-world problems such as cryptography, optimisation, and simulations. - Compilation (Processor design / gate implementation) @@ -34,9 +34,6 @@ and any company dealing with portfolio.. Such analyses can be found in a wide range of applications such as .. -# Video for customer value proposition - - # References [1] M.C. Braun et al., A Quantum Algorithm for the Sensitivity Analysis of Business Risks (2021), https://arxiv.org/abs/2103.05475 From 6c69382ffb9b28862d904f5e422c424273a43054 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 17:38:10 -0400 Subject: [PATCH 14/85] Update Business_Application.md --- Business_Application.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index aebf1b7..a605738 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -10,7 +10,8 @@ They can be applied to various real-world problems such as cryptography, optimis - Compilation (Processor design / gate implementation) - Performance analysis: - Following the methology by Deutsche Borse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. We implement and analysis the risk modeling and its representation on quantum circuits. + Following the methology by Deutsche Borse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. We implement and analysis the risk modeling and its representation on quantum circuits. +The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, which is measured by the number of elementary operations used by an algorithm. This can be done using the quantum circuit model. $H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ From 3916345968ca79d4a6c1fe783e8e6e75ea8a48fb Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 17:40:00 -0400 Subject: [PATCH 15/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index a605738..9a34f36 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -11,7 +11,7 @@ They can be applied to various real-world problems such as cryptography, optimis - Performance analysis: Following the methology by Deutsche Borse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. We implement and analysis the risk modeling and its representation on quantum circuits. -The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, which is measured by the number of elementary operations used by an algorithm. This can be done using the quantum circuit model. +The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. $H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ From d9558408749b5a9dc794d113ecd40727ab36a2ef Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 17:50:56 -0400 Subject: [PATCH 16/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 9a34f36..e951197 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -39,7 +39,7 @@ Such analyses can be found in a wide range of applications such as .. [1] M.C. Braun et al., A Quantum Algorithm for the Sensitivity Analysis of Business Risks (2021), https://arxiv.org/abs/2103.05475 -[2] +[2] A. Montanaro, Quantum algorithms: an overview, npj Quantum Information (2016) 2, 15023. [3] From f0572803e7e785dfcbf77dcacff986916487d9fc Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:02:29 -0400 Subject: [PATCH 17/85] Update Business_Application.md --- Business_Application.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index e951197..4f5cb56 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -10,7 +10,9 @@ They can be applied to various real-world problems such as cryptography, optimis - Compilation (Processor design / gate implementation) - Performance analysis: - Following the methology by Deutsche Borse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. We implement and analysis the risk modeling and its representation on quantum circuits. + Following the methology by Deutsche Borse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. +Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. +Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm. The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. $H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ From ee9f21f92b507f7d8563ef2e49267651ae414aa9 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:04:46 -0400 Subject: [PATCH 18/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 4f5cb56..a2a27d0 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -10,7 +10,7 @@ They can be applied to various real-world problems such as cryptography, optimis - Compilation (Processor design / gate implementation) - Performance analysis: - Following the methology by Deutsche Borse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. + Following the methology by Deutsche B\"{o}rse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm. The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. From 4fc98fd3ddd9899f0e7a02a75b54236d369a99d1 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:05:07 -0400 Subject: [PATCH 19/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index a2a27d0..a63b4b2 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -10,7 +10,7 @@ They can be applied to various real-world problems such as cryptography, optimis - Compilation (Processor design / gate implementation) - Performance analysis: - Following the methology by Deutsche B\"{o}rse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. + Following the methology by Deutsche B$\"{o}$rse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm. The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. From c17b83f7dfea74b0c26a40450e49bf51fa4ddeb8 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:06:43 -0400 Subject: [PATCH 20/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index a63b4b2..1e2e8db 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -10,7 +10,7 @@ They can be applied to various real-world problems such as cryptography, optimis - Compilation (Processor design / gate implementation) - Performance analysis: - Following the methology by Deutsche B$\"{o}$rse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. + Following the methology by Deutsche Börse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm. The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. From 8dad7649aac6eab28dbdb627e16024cefc12dca8 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:07:29 -0400 Subject: [PATCH 21/85] Update Business_Application.md --- Business_Application.md | 7 ------- 1 file changed, 7 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 1e2e8db..c0f9bfc 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -22,13 +22,6 @@ i and j denote the sites which are adjacent to each other. total density operator $\hat{n}_i = ...$ -# Real-world problems - -- Correlation clustering problem (undirected graph): Multiple-person pose estimation [Pishchulin et al., 2016] - - -Solid material structures such as graphene, ferromagnetic lattices, Silicium square and cubic lattices. - # Potential customers Potential customers for the Sensitivity Analysis of Business Risks includes banks, and any financial institute dealing with risk analysis From 1f4b1f67ed2ca0024e7115d0648fe0d0e66119a0 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:23:19 -0400 Subject: [PATCH 22/85] Update Business_Application.md --- Business_Application.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Business_Application.md b/Business_Application.md index c0f9bfc..ce41e4e 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -15,6 +15,8 @@ Grover's algorithm (1996) is known for its ability to address unstructured searc Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm. The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. +fast (as compared to thecalssical ones), requires low number of qubits (~200), ... + $H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ i and j denote the sites which are adjacent to each other. From 252c52448478812f89a877ee52bb97312fec0817 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:23:43 -0400 Subject: [PATCH 23/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index ce41e4e..9757402 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -15,7 +15,7 @@ Grover's algorithm (1996) is known for its ability to address unstructured searc Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm. The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. -fast (as compared to thecalssical ones), requires low number of qubits (~200), ... +fast (as compared to classical ones), requires low number of qubits (~200), ... $H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ From a23d3eb7c36cd30e9e34a9f44065cb78788ec768 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:26:45 -0400 Subject: [PATCH 24/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 9757402..837dfbe 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -15,7 +15,7 @@ Grover's algorithm (1996) is known for its ability to address unstructured searc Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm. The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. -fast (as compared to classical ones), requires low number of qubits (~200), ... +The quantum program employed here is fast (as compared to classical ones), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. $H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ From b15e6cfa5fdac5f97ed8c971c8e461cb4bdb1e6c Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:27:12 -0400 Subject: [PATCH 25/85] Update Business_Application.md --- Business_Application.md | 1 - 1 file changed, 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 837dfbe..a7e194c 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -14,7 +14,6 @@ They can be applied to various real-world problems such as cryptography, optimis Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm. The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. - The quantum program employed here is fast (as compared to classical ones), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. $H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ From 3f2cb463c1e3cdc39561819452bc4d2510d3ceab Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:28:52 -0400 Subject: [PATCH 26/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index a7e194c..17e9d6e 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -12,7 +12,7 @@ They can be applied to various real-world problems such as cryptography, optimis - Performance analysis: Following the methology by Deutsche Börse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. -Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm. +Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm and the Quantum Amplitude Estimation (QAE). The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. The quantum program employed here is fast (as compared to classical ones), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. From f0e447e65c393357fc9a171f8f044c2ca57564bf Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:31:42 -0400 Subject: [PATCH 27/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 17e9d6e..9009782 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -14,7 +14,7 @@ They can be applied to various real-world problems such as cryptography, optimis Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm and the Quantum Amplitude Estimation (QAE). The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. -The quantum program employed here is fast (as compared to classical ones), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. +The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. $H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ From 4c6ba291a52c963f5149f9c10a9a3b3e5ff3135f Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:34:41 -0400 Subject: [PATCH 28/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 9009782..2a242ac 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -10,7 +10,7 @@ They can be applied to various real-world problems such as cryptography, optimis - Compilation (Processor design / gate implementation) - Performance analysis: - Following the methology by Deutsche Börse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a risk model..., which found to be computationally too expensive to perform by classical algorithms. + Following the methology by Deutsche Börse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a business risk model, which found to be computationally too expensive to perform by classical algorithms. Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm and the Quantum Amplitude Estimation (QAE). The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. From 58b2107dd299f5cd82eb06a5e3b797aaf9334562 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:40:44 -0400 Subject: [PATCH 29/85] Update Business_Application.md --- Business_Application.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Business_Application.md b/Business_Application.md index 2a242ac..b8eaa22 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -22,6 +22,11 @@ i and j denote the sites which are adjacent to each other. total density operator $\hat{n}_i = ...$ +In this work (to-be rephrased): +we show that the oracles we consider lower the success probability by a constant factor compared to standard oracles. +we achieve a success probability of at least 81% (rather than nearly 100% in conventional Grover), which is inherited from the QAE. +The number of optimal search steps + # Potential customers From 41dd8755b68d85439940e389a2a0fe17db0c1b36 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:47:05 -0400 Subject: [PATCH 30/85] Update Business_Application.md --- Business_Application.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index b8eaa22..97a1bb4 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -16,16 +16,12 @@ Here, we implement and analysis the risk modeling and its representation on quan The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. -$H = - \sum_{\langle i,j \rangle, \sigma} t_{xy}^{ij}(\hat{c]_{i \sigma}^{\dagger} \hat{c}_{j \sigma} + h.c.) +...$ +The implementation of the quantum program and simulations are done using Qiskit. -i and j denote the sites which are adjacent to each other. - -total density operator $\hat{n}_i = ...$ In this work (to-be rephrased): we show that the oracles we consider lower the success probability by a constant factor compared to standard oracles. we achieve a success probability of at least 81% (rather than nearly 100% in conventional Grover), which is inherited from the QAE. -The number of optimal search steps # Potential customers From 40001bec1ce6848c8a1b7dc2803c01baf9c54384 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:47:30 -0400 Subject: [PATCH 31/85] Update Business_Application.md --- Business_Application.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 97a1bb4..e96b4e6 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -7,8 +7,6 @@ Quantum algorithms are known for super-polynomial speedup over their classical counterparts. They can be applied to various real-world problems such as cryptography, optimisation, and simulations. -- Compilation (Processor design / gate implementation) - - Performance analysis: Following the methology by Deutsche Börse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a business risk model, which found to be computationally too expensive to perform by classical algorithms. Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. @@ -16,6 +14,7 @@ Here, we implement and analysis the risk modeling and its representation on quan The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. +- Compilation (Processor design / gate implementation) The implementation of the quantum program and simulations are done using Qiskit. From d2f2d078a1729a0f6981653e82e1bf25ef41845e Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 18:48:01 -0400 Subject: [PATCH 32/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index e96b4e6..09a771c 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -14,7 +14,7 @@ Here, we implement and analysis the risk modeling and its representation on quan The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. -- Compilation (Processor design / gate implementation) +- Compilation (Processor design / gate implementation): The implementation of the quantum program and simulations are done using Qiskit. From 4df4137091dd7f41fda1ab29861d2dd8ae2d2888 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:12:48 -0400 Subject: [PATCH 33/85] Update Business_Application.md --- Business_Application.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Business_Application.md b/Business_Application.md index 09a771c..124b6a4 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -17,6 +17,8 @@ The quantum program employed here is fast (as compared to classical ones, e.g. q - Compilation (Processor design / gate implementation): The implementation of the quantum program and simulations are done using Qiskit. +The impact of external adverse developments on future revenues in any business can be addressed within a risk model. + In this work (to-be rephrased): we show that the oracles we consider lower the success probability by a constant factor compared to standard oracles. From d1271f5c0c752aad6860238c4877505e701b3c38 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:15:30 -0400 Subject: [PATCH 34/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 124b6a4..100378e 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -18,7 +18,7 @@ The quantum program employed here is fast (as compared to classical ones, e.g. q The implementation of the quantum program and simulations are done using Qiskit. The impact of external adverse developments on future revenues in any business can be addressed within a risk model. - +A risk model estimates the overall likelihood of impacts that would threaten the business. In this work (to-be rephrased): we show that the oracles we consider lower the success probability by a constant factor compared to standard oracles. From 3ad1b4701202567db985a8eb93042e67a41f2cd1 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:20:25 -0400 Subject: [PATCH 35/85] Update Business_Application.md --- Business_Application.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Business_Application.md b/Business_Application.md index 100378e..251bd22 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -19,6 +19,9 @@ The implementation of the quantum program and simulations are done using Qiskit. The impact of external adverse developments on future revenues in any business can be addressed within a risk model. A risk model estimates the overall likelihood of impacts that would threaten the business. +Thus we are dealing with a probablity problem. +To define the problem, a threshold $A$ for the financial impact is defined. +The probability $P(A)$ that this threshold is breached. In this work (to-be rephrased): we show that the oracles we consider lower the success probability by a constant factor compared to standard oracles. From 755ce957aaccd410fa8fc01f96f5ba11953cdf59 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:23:10 -0400 Subject: [PATCH 36/85] Update Business_Application.md --- Business_Application.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 251bd22..bc373aa 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -20,8 +20,8 @@ The implementation of the quantum program and simulations are done using Qiskit. The impact of external adverse developments on future revenues in any business can be addressed within a risk model. A risk model estimates the overall likelihood of impacts that would threaten the business. Thus we are dealing with a probablity problem. -To define the problem, a threshold $A$ for the financial impact is defined. -The probability $P(A)$ that this threshold is breached. +To define the problem, a threshold $A$ for a financial impact is defined. +The probability $P(A)$ shows probability that the financial impact bigger than $A$. In this work (to-be rephrased): we show that the oracles we consider lower the success probability by a constant factor compared to standard oracles. From 57701c78f68523258b7b3b28b91dcb0338cad1c8 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:24:58 -0400 Subject: [PATCH 37/85] Update Business_Application.md --- Business_Application.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index bc373aa..fa46c90 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -21,7 +21,8 @@ The impact of external adverse developments on future revenues in any business c A risk model estimates the overall likelihood of impacts that would threaten the business. Thus we are dealing with a probablity problem. To define the problem, a threshold $A$ for a financial impact is defined. -The probability $P(A)$ shows probability that the financial impact bigger than $A$. +The probability $P(A)$ shows probability that the financial impact bigger than $A$, and $P_{max}$ is the maximal acceptable value of $P(A)$. + In this work (to-be rephrased): we show that the oracles we consider lower the success probability by a constant factor compared to standard oracles. From 893c52e852f4678d748eaa49feb7857034d5e473 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:27:23 -0400 Subject: [PATCH 38/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index fa46c90..44ee7aa 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -22,7 +22,7 @@ A risk model estimates the overall likelihood of impacts that would threaten the Thus we are dealing with a probablity problem. To define the problem, a threshold $A$ for a financial impact is defined. The probability $P(A)$ shows probability that the financial impact bigger than $A$, and $P_{max}$ is the maximal acceptable value of $P(A)$. - +In the business risk model, to avoide loss, an action needs to taken when $P(A)$ reaches it maximum value $P_max$. In this work (to-be rephrased): we show that the oracles we consider lower the success probability by a constant factor compared to standard oracles. From 0bdfc748e2d4bfce5570ec077972763ed8024c8f Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:27:46 -0400 Subject: [PATCH 39/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 44ee7aa..299eecc 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -22,7 +22,7 @@ A risk model estimates the overall likelihood of impacts that would threaten the Thus we are dealing with a probablity problem. To define the problem, a threshold $A$ for a financial impact is defined. The probability $P(A)$ shows probability that the financial impact bigger than $A$, and $P_{max}$ is the maximal acceptable value of $P(A)$. -In the business risk model, to avoide loss, an action needs to taken when $P(A)$ reaches it maximum value $P_max$. +In the business risk model, to avoide loss, an action needs to taken when $P(A)$ reaches it maximum value $P_{max}$. In this work (to-be rephrased): we show that the oracles we consider lower the success probability by a constant factor compared to standard oracles. From f9930ee8af2a12a3b10f028a91d20550dc960d92 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:33:49 -0400 Subject: [PATCH 40/85] Update Business_Application.md --- Business_Application.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Business_Application.md b/Business_Application.md index 299eecc..ac367bd 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -24,6 +24,10 @@ To define the problem, a threshold $A$ for a financial impact is defined. The probability $P(A)$ shows probability that the financial impact bigger than $A$, and $P_{max}$ is the maximal acceptable value of $P(A)$. In the business risk model, to avoide loss, an action needs to taken when $P(A)$ reaches it maximum value $P_{max}$. +The estimated $P(A)$ is based on some estimated parameters (inputs) and we are interested in finding the parameter(s) that when changed +slightly, influence the output of the model such that $P(A)>P_{max}$. + + In this work (to-be rephrased): we show that the oracles we consider lower the success probability by a constant factor compared to standard oracles. we achieve a success probability of at least 81% (rather than nearly 100% in conventional Grover), which is inherited from the QAE. From ed70d271a38a75503a1b5e15a2192964636febfe Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:38:20 -0400 Subject: [PATCH 41/85] Update Business_Application.md --- Business_Application.md | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index ac367bd..21e6a71 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -14,9 +14,6 @@ Here, we implement and analysis the risk modeling and its representation on quan The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. -- Compilation (Processor design / gate implementation): -The implementation of the quantum program and simulations are done using Qiskit. - The impact of external adverse developments on future revenues in any business can be addressed within a risk model. A risk model estimates the overall likelihood of impacts that would threaten the business. Thus we are dealing with a probablity problem. @@ -27,6 +24,8 @@ In the business risk model, to avoide loss, an action needs to taken when $P(A)$ The estimated $P(A)$ is based on some estimated parameters (inputs) and we are interested in finding the parameter(s) that when changed slightly, influence the output of the model such that $P(A)>P_{max}$. +- Compilation (Processor design / gate implementation): +The implementation of the quantum program and simulations are done using Qiskit. In this work (to-be rephrased): we show that the oracles we consider lower the success probability by a constant factor compared to standard oracles. From 2e5094eecda925d122ae6eab69e9477814101e28 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:39:18 -0400 Subject: [PATCH 42/85] Update Business_Application.md --- Business_Application.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Business_Application.md b/Business_Application.md index 21e6a71..9116d5b 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -14,6 +14,8 @@ Here, we implement and analysis the risk modeling and its representation on quan The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. + +- The risk model: The impact of external adverse developments on future revenues in any business can be addressed within a risk model. A risk model estimates the overall likelihood of impacts that would threaten the business. Thus we are dealing with a probablity problem. From 92cbb3fe8378ef597b152d39e9993c6b848a5917 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:40:00 -0400 Subject: [PATCH 43/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 9116d5b..70534d0 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -15,7 +15,7 @@ The fact that quantum algorithms are faster than a classical ones can be tested The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. -- The risk model: +# The risk model: The impact of external adverse developments on future revenues in any business can be addressed within a risk model. A risk model estimates the overall likelihood of impacts that would threaten the business. Thus we are dealing with a probablity problem. From 101cf3a03f7916640be204524eb8426e42e345b2 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:41:34 -0400 Subject: [PATCH 44/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 70534d0..6c8ddfc 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -15,7 +15,7 @@ The fact that quantum algorithms are faster than a classical ones can be tested The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. -# The risk model: +# The Business risk model and analysis: The impact of external adverse developments on future revenues in any business can be addressed within a risk model. A risk model estimates the overall likelihood of impacts that would threaten the business. Thus we are dealing with a probablity problem. From dda1f3326910069bf41cde65d9772bc01a7f3869 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 19:41:56 -0400 Subject: [PATCH 45/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 6c8ddfc..92b4382 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -15,7 +15,7 @@ The fact that quantum algorithms are faster than a classical ones can be tested The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. -# The Business risk model and analysis: +# The business risk model and analysis: The impact of external adverse developments on future revenues in any business can be addressed within a risk model. A risk model estimates the overall likelihood of impacts that would threaten the business. Thus we are dealing with a probablity problem. From 32fc63ca8cd562cf2f28e4098f03f40f59e59da8 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 20:03:10 -0400 Subject: [PATCH 46/85] Update Business_Application.md --- Business_Application.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 92b4382..9945b87 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -15,7 +15,7 @@ The fact that quantum algorithms are faster than a classical ones can be tested The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. -# The business risk model and analysis: +# Business risk model and analysis: The impact of external adverse developments on future revenues in any business can be addressed within a risk model. A risk model estimates the overall likelihood of impacts that would threaten the business. Thus we are dealing with a probablity problem. @@ -34,6 +34,8 @@ we show that the oracles we consider lower the success probability by a constant we achieve a success probability of at least 81% (rather than nearly 100% in conventional Grover), which is inherited from the QAE. +# Quantum implementation + # Potential customers Potential customers for the Sensitivity Analysis of Business Risks includes banks, and any financial institute dealing with risk analysis From b1962dfa989186f867c21fd84d4c841cbd761642 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 22:38:53 -0400 Subject: [PATCH 47/85] Update Business_Application.md --- Business_Application.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Business_Application.md b/Business_Application.md index 9945b87..ad9ccef 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -35,6 +35,12 @@ we achieve a success probability of at least 81% (rather than nearly 100% in con # Quantum implementation +The sensitivity analysis of the risk model is considered as a quantum program that analyzes the impact of varying each input parameter separately. +The quantum algorithm consists of three steps: +1. Implement the risk model as a quantum algorithm, +2. Implement QAE on the outputs of the risk model, +3. Search sensitive parameters with Grover's algorithm. + # Potential customers From c6cfe74bdf352f2379f4f7474342d7f472d69d03 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 22:40:28 -0400 Subject: [PATCH 48/85] Update Business_Application.md --- Business_Application.md | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index ad9ccef..75e7149 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -35,10 +35,9 @@ we achieve a success probability of at least 81% (rather than nearly 100% in con # Quantum implementation -The sensitivity analysis of the risk model is considered as a quantum program that analyzes the impact of varying each input parameter separately. -The quantum algorithm consists of three steps: -1. Implement the risk model as a quantum algorithm, -2. Implement QAE on the outputs of the risk model, +The sensitivity analysis of the risk model is considered as a quantum program that analyzes the impact of varying each input parameter in three steps: +1. Implementing the risk model as a quantum algorithm, +2. Implementing QAE on the outputs of the risk model, 3. Search sensitive parameters with Grover's algorithm. From 95ce28bcaa918253a208c9007354b5a5b3a3d213 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 22:45:52 -0400 Subject: [PATCH 49/85] Update Business_Application.md --- Business_Application.md | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 75e7149..ef34cc0 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -1,7 +1,7 @@ # Business Application of Quantum Algorithm for the Sensitivity Analysis of Business Risks -# Quantum algorithm +# Quantum algorithms - Problem definition: Quantum algorithms are known for super-polynomial speedup over their classical counterparts. @@ -22,10 +22,13 @@ Thus we are dealing with a probablity problem. To define the problem, a threshold $A$ for a financial impact is defined. The probability $P(A)$ shows probability that the financial impact bigger than $A$, and $P_{max}$ is the maximal acceptable value of $P(A)$. In the business risk model, to avoide loss, an action needs to taken when $P(A)$ reaches it maximum value $P_{max}$. - The estimated $P(A)$ is based on some estimated parameters (inputs) and we are interested in finding the parameter(s) that when changed slightly, influence the output of the model such that $P(A)>P_{max}$. +The business risks is implemented as follows: +An intrinsic probability $P_i$ is defined for each relevant event (risk item). + + - Compilation (Processor design / gate implementation): The implementation of the quantum program and simulations are done using Qiskit. From 5d4fd7ec0861d42428c50f2ef91940fdf8d3683e Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 23:08:58 -0400 Subject: [PATCH 50/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index ef34cc0..2564221 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -26,7 +26,7 @@ The estimated $P(A)$ is based on some estimated parameters (inputs) and we are i slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: -An intrinsic probability $P_i$ is defined for each relevant event (risk item). +An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). - Compilation (Processor design / gate implementation): From b11beeb4766d7fcf0989b7ed1684c22d0238926e Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 23:12:25 -0400 Subject: [PATCH 51/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 2564221..cfd2eaa 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -26,7 +26,7 @@ The estimated $P(A)$ is based on some estimated parameters (inputs) and we are i slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: -An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). +An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). An item ($i$th) is also assigned a probability to trigger another item ($j$th) with with the transition probability $P_{ij}$. - Compilation (Processor design / gate implementation): From c974d8fae0cc29270c0ab9b775dafe30de092579 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 23:17:43 -0400 Subject: [PATCH 52/85] Update Business_Application.md --- Business_Application.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Business_Application.md b/Business_Application.md index cfd2eaa..2dfa85f 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -27,6 +27,8 @@ slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). An item ($i$th) is also assigned a probability to trigger another item ($j$th) with with the transition probability $P_{ij}$. +Each triggered risk item (e.g. by other items) generates a specific loss. +The sum of the losses of the triggered items gives the total loss for a specific scenario. - Compilation (Processor design / gate implementation): From 7b963e3aeb52723ca9cf06a8bd5d92a1316c824a Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 23:27:25 -0400 Subject: [PATCH 53/85] Update Business_Application.md --- Business_Application.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 2dfa85f..2ac93ed 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -12,7 +12,7 @@ They can be applied to various real-world problems such as cryptography, optimis Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm and the Quantum Amplitude Estimation (QAE). The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. -The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. +The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model (cf. ref [1] for the details). # Business risk model and analysis: @@ -28,7 +28,8 @@ slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). An item ($i$th) is also assigned a probability to trigger another item ($j$th) with with the transition probability $P_{ij}$. Each triggered risk item (e.g. by other items) generates a specific loss. -The sum of the losses of the triggered items gives the total loss for a specific scenario. +The sum of the losses of the triggered items gives the total loss for a specific scenario. T +Finally, the model is evaluated by brute force. - Compilation (Processor design / gate implementation): From a27f96439a427b2d8ec7995f34a76df18e78e26b Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 23:28:08 -0400 Subject: [PATCH 54/85] Update Business_Application.md --- Business_Application.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 2ac93ed..4498167 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -12,7 +12,7 @@ They can be applied to various real-world problems such as cryptography, optimis Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm and the Quantum Amplitude Estimation (QAE). The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. -The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model (cf. ref [1] for the details). +The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. # Business risk model and analysis: @@ -29,7 +29,7 @@ The business risks is implemented as follows: An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). An item ($i$th) is also assigned a probability to trigger another item ($j$th) with with the transition probability $P_{ij}$. Each triggered risk item (e.g. by other items) generates a specific loss. The sum of the losses of the triggered items gives the total loss for a specific scenario. T -Finally, the model is evaluated by brute force. +Finally, the model is evaluated by brute force (cf. ref [1] for the details). - Compilation (Processor design / gate implementation): From 6ddd7f4b89bdaf150e4614d0ab4131b2629a6a21 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 23:30:41 -0400 Subject: [PATCH 55/85] Update Business_Application.md --- Business_Application.md | 1 + 1 file changed, 1 insertion(+) diff --git a/Business_Application.md b/Business_Application.md index 4498167..a55be29 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -46,6 +46,7 @@ The sensitivity analysis of the risk model is considered as a quantum program th 2. Implementing QAE on the outputs of the risk model, 3. Search sensitive parameters with Grover's algorithm. +For the first step, the structure of the model is translated into a quantum circuit. # Potential customers From 99b33372381287cffac8427ca13c64e8074e7e1f Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 23:51:23 -0400 Subject: [PATCH 56/85] Update Business_Application.md --- Business_Application.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Business_Application.md b/Business_Application.md index a55be29..f9c114a 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -47,6 +47,8 @@ The sensitivity analysis of the risk model is considered as a quantum program th 3. Search sensitive parameters with Grover's algorithm. For the first step, the structure of the model is translated into a quantum circuit. +In the quantum formalism the risk items are represented by qubits. + # Potential customers From 39a9927c7001f8a6ec01fc70bbc728d3380e953b Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 23:54:46 -0400 Subject: [PATCH 57/85] Update Business_Application.md --- Business_Application.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index f9c114a..806b35f 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -28,7 +28,7 @@ slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). An item ($i$th) is also assigned a probability to trigger another item ($j$th) with with the transition probability $P_{ij}$. Each triggered risk item (e.g. by other items) generates a specific loss. -The sum of the losses of the triggered items gives the total loss for a specific scenario. T +The sum of the losses of the triggered items gives the total loss for a specific scenario. Finally, the model is evaluated by brute force (cf. ref [1] for the details). @@ -48,7 +48,8 @@ The sensitivity analysis of the risk model is considered as a quantum program th For the first step, the structure of the model is translated into a quantum circuit. In the quantum formalism the risk items are represented by qubits. - +A risk item can be put into a superposition of being triggered with probability $P$ and not being triggered with probability $1-P$ +by appying a rotation operator on a qubit. # Potential customers From deeb1302b830375dc13b471118e2fd012dc8fe45 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 23:56:40 -0400 Subject: [PATCH 58/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 806b35f..209d4e7 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -49,7 +49,7 @@ The sensitivity analysis of the risk model is considered as a quantum program th For the first step, the structure of the model is translated into a quantum circuit. In the quantum formalism the risk items are represented by qubits. A risk item can be put into a superposition of being triggered with probability $P$ and not being triggered with probability $1-P$ -by appying a rotation operator on a qubit. +by appying a rotation operator ($U3(\thea,\phi,\lambda)$) on a qubit. # Potential customers From d1a46f1a543eb7b88ce806b5ad55ced66cd6d947 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 23:57:19 -0400 Subject: [PATCH 59/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 209d4e7..962e4b7 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -49,7 +49,7 @@ The sensitivity analysis of the risk model is considered as a quantum program th For the first step, the structure of the model is translated into a quantum circuit. In the quantum formalism the risk items are represented by qubits. A risk item can be put into a superposition of being triggered with probability $P$ and not being triggered with probability $1-P$ -by appying a rotation operator ($U3(\thea,\phi,\lambda)$) on a qubit. +by appying a rotation operator ($$U3(\theta,\phi,\lambda)$$) on a qubit. # Potential customers From 5d9aa57363fab4fb2b715a1cd3a2aaf6d60a4834 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Tue, 26 Jul 2022 23:59:31 -0400 Subject: [PATCH 60/85] Update Business_Application.md --- Business_Application.md | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 962e4b7..edc872b 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -49,7 +49,14 @@ The sensitivity analysis of the risk model is considered as a quantum program th For the first step, the structure of the model is translated into a quantum circuit. In the quantum formalism the risk items are represented by qubits. A risk item can be put into a superposition of being triggered with probability $P$ and not being triggered with probability $1-P$ -by appying a rotation operator ($$U3(\theta,\phi,\lambda)$$) on a qubit. +by appying a rotation operator +$$U3(\theta,\phi,\lambda)= +\begin{pmatrix} +1 & 2\\ +a & b +\end{pmatrix} +$$ +on a qubit. # Potential customers From b814021aef79e9c6697c1bc333397665a3e9c4af Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 00:00:09 -0400 Subject: [PATCH 61/85] Update Business_Application.md --- Business_Application.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index edc872b..5b6c61f 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -50,12 +50,13 @@ For the first step, the structure of the model is translated into a quantum circ In the quantum formalism the risk items are represented by qubits. A risk item can be put into a superposition of being triggered with probability $P$ and not being triggered with probability $1-P$ by appying a rotation operator -$$U3(\theta,\phi,\lambda)= +$$U3(\theta,\phi,\lambda)=$$ + \begin{pmatrix} 1 & 2\\ a & b \end{pmatrix} -$$ + on a qubit. # Potential customers From 6e78b8da5f4288a3bdb84bdd75b13fca7fd7ed92 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 00:00:48 -0400 Subject: [PATCH 62/85] Update Business_Application.md --- Business_Application.md | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 5b6c61f..f996a43 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -50,13 +50,7 @@ For the first step, the structure of the model is translated into a quantum circ In the quantum formalism the risk items are represented by qubits. A risk item can be put into a superposition of being triggered with probability $P$ and not being triggered with probability $1-P$ by appying a rotation operator -$$U3(\theta,\phi,\lambda)=$$ - -\begin{pmatrix} -1 & 2\\ -a & b -\end{pmatrix} - +$U_3(\theta,\phi,\lambda)$ on a qubit. # Potential customers From 439228cf317d0ac2b0daa7f116598993c35f4109 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 00:02:17 -0400 Subject: [PATCH 63/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index f996a43..ba729b8 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -51,7 +51,7 @@ In the quantum formalism the risk items are represented by qubits. A risk item can be put into a superposition of being triggered with probability $P$ and not being triggered with probability $1-P$ by appying a rotation operator $U_3(\theta,\phi,\lambda)$ -on a qubit. +on a qubit, with a $theta$ that fullfill the relation $\sin(\theta/2)=P$. # Potential customers From d7e2308ae1c0faaf68cc45263e7968be07ef42f9 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 00:02:46 -0400 Subject: [PATCH 64/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index ba729b8..4ea2359 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -51,7 +51,7 @@ In the quantum formalism the risk items are represented by qubits. A risk item can be put into a superposition of being triggered with probability $P$ and not being triggered with probability $1-P$ by appying a rotation operator $U_3(\theta,\phi,\lambda)$ -on a qubit, with a $theta$ that fullfill the relation $\sin(\theta/2)=P$. +on a qubit, with a $\theta$ that fullfill the relation $\sin(\theta/2)=P$. # Potential customers From 9d55bf8483b1e70a4605725aa1a575d72e6a2207 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 00:04:05 -0400 Subject: [PATCH 65/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 4ea2359..7c8b111 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -51,7 +51,7 @@ In the quantum formalism the risk items are represented by qubits. A risk item can be put into a superposition of being triggered with probability $P$ and not being triggered with probability $1-P$ by appying a rotation operator $U_3(\theta,\phi,\lambda)$ -on a qubit, with a $\theta$ that fullfill the relation $\sin(\theta/2)=P$. +on a qubit, with a $\theta$ that fulfil the relation $\sin(\theta/2)=P$. # Potential customers From 67f69f8e7800f53e354038523d9440d27005b479 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 00:05:42 -0400 Subject: [PATCH 66/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 7c8b111..81f2c6b 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -51,7 +51,7 @@ In the quantum formalism the risk items are represented by qubits. A risk item can be put into a superposition of being triggered with probability $P$ and not being triggered with probability $1-P$ by appying a rotation operator $U_3(\theta,\phi,\lambda)$ -on a qubit, with a $\theta$ that fulfil the relation $\sin(\theta/2)=P$. +on a qubit, with a $\theta$ that fulfil the relation $\sin(\theta/2)=P$, and the phases $\phi$ and $\lambda$ can be set to zero. # Potential customers From d73525f4a8b6d03862a068c5f7f6701addb375a2 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 00:13:15 -0400 Subject: [PATCH 67/85] Update Business_Application.md --- Business_Application.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Business_Application.md b/Business_Application.md index 81f2c6b..4276f99 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -52,6 +52,8 @@ A risk item can be put into a superposition of being triggered with probability by appying a rotation operator $U_3(\theta,\phi,\lambda)$ on a qubit, with a $\theta$ that fulfil the relation $\sin(\theta/2)=P$, and the phases $\phi$ and $\lambda$ can be set to zero. +Such quantum implementation of the model seems remarkably efficient as compared to the implementation on a classical computer. + # Potential customers From 4629f74c1df4fbe57fd5c54ed01e86fd5e15d83f Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 00:13:45 -0400 Subject: [PATCH 68/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 4276f99..cff5196 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -52,7 +52,7 @@ A risk item can be put into a superposition of being triggered with probability by appying a rotation operator $U_3(\theta,\phi,\lambda)$ on a qubit, with a $\theta$ that fulfil the relation $\sin(\theta/2)=P$, and the phases $\phi$ and $\lambda$ can be set to zero. -Such quantum implementation of the model seems remarkably efficient as compared to the implementation on a classical computer. +Such quantum implementation of the model turns out to be remarkably efficient as compared to the implementation on a classical computer. # Potential customers From aa78724002823eed3040b277e3e1fa68d5914bb0 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 00:34:08 -0400 Subject: [PATCH 69/85] Update Business_Application.md --- Business_Application.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index cff5196..b2244e8 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -67,9 +67,9 @@ Such analyses can be found in a wide range of applications such as .. [1] M.C. Braun et al., A Quantum Algorithm for the Sensitivity Analysis of Business Risks (2021), https://arxiv.org/abs/2103.05475 -[2] A. Montanaro, Quantum algorithms: an overview, npj Quantum Information (2016) 2, 15023. +[2] A. Montanaro, Quantum algorithms: an overview, npj Quantum Inf 2, 15023 (2016). -[3] +[3] S. Woerner and D.J. Egger1, Quantum risk analysis, npj Quantum Inf 5, 15 (2019). [4] From 66f272bdee757f0b9cf35b76c33930622931a34f Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 00:34:35 -0400 Subject: [PATCH 70/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index b2244e8..1f1d691 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -69,7 +69,7 @@ Such analyses can be found in a wide range of applications such as .. [2] A. Montanaro, Quantum algorithms: an overview, npj Quantum Inf 2, 15023 (2016). -[3] S. Woerner and D.J. Egger1, Quantum risk analysis, npj Quantum Inf 5, 15 (2019). +[3] S. Woerner and D.J. Egger, Quantum risk analysis, npj Quantum Inf 5, 15 (2019). [4] From 4d186dfef7ece3caa4d63c436370d52e65ec95b0 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 01:06:47 -0400 Subject: [PATCH 71/85] Update Business_Application.md --- Business_Application.md | 4 ---- 1 file changed, 4 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 1f1d691..d6fdc37 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -70,7 +70,3 @@ Such analyses can be found in a wide range of applications such as .. [2] A. Montanaro, Quantum algorithms: an overview, npj Quantum Inf 2, 15023 (2016). [3] S. Woerner and D.J. Egger, Quantum risk analysis, npj Quantum Inf 5, 15 (2019). - -[4] - -[5] From c1803e88c24fdf8d173fa9d74a2fd7f3e0faa88d Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 01:17:40 -0400 Subject: [PATCH 72/85] Update Business_Application.md --- Business_Application.md | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index d6fdc37..e28de21 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -11,7 +11,7 @@ They can be applied to various real-world problems such as cryptography, optimis Following the methology by Deutsche Börse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a business risk model, which found to be computationally too expensive to perform by classical algorithms. Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm and the Quantum Amplitude Estimation (QAE). -The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. +The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. @@ -32,12 +32,10 @@ The sum of the losses of the triggered items gives the total loss for a specific Finally, the model is evaluated by brute force (cf. ref [1] for the details). -- Compilation (Processor design / gate implementation): -The implementation of the quantum program and simulations are done using Qiskit. - -In this work (to-be rephrased): -we show that the oracles we consider lower the success probability by a constant factor compared to standard oracles. -we achieve a success probability of at least 81% (rather than nearly 100% in conventional Grover), which is inherited from the QAE. +- Compilation (circuit representation): +The implementation of the quantum program and simulations are done using Qiskit, as illustrated in the Risk_Analysis_Hackathon.ipynb file. +As shown the oracles we consider lower the success probability by a constant factor compared to standard oracles. +A success probability of at least 81% (rather than nearly 100% in conventional Grover) is achieved, which is inherited from the QAE. # Quantum implementation From 36e32268f4bc277d062dc083f4910a24af03e786 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 01:18:53 -0400 Subject: [PATCH 73/85] Update Business_Application.md --- Business_Application.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index e28de21..d270826 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -5,10 +5,10 @@ - Problem definition: Quantum algorithms are known for super-polynomial speedup over their classical counterparts. -They can be applied to various real-world problems such as cryptography, optimisation, and simulations. +They can be applied to various real-world problems such as cryptography, optimization, and simulations. - Performance analysis: - Following the methology by Deutsche Börse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a business risk model, which found to be computationally too expensive to perform by classical algorithms. + Following the methodology by Deutsche Börse Group we present a quantum algorithm (namely Grover's algorithm) to address the sensitivity analysis for a business risk model, which found to be computationally too expensive to perform by classical algorithms. Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm and the Quantum Amplitude Estimation (QAE). The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. From 019f580eab8bc2a3bff02fbcc0e11fbafc217441 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 01:21:27 -0400 Subject: [PATCH 74/85] Update Business_Application.md --- Business_Application.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index d270826..9be7602 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -18,15 +18,15 @@ The quantum program employed here is fast (as compared to classical ones, e.g. q # Business risk model and analysis: The impact of external adverse developments on future revenues in any business can be addressed within a risk model. A risk model estimates the overall likelihood of impacts that would threaten the business. -Thus we are dealing with a probablity problem. +Thus we are dealing with a probability problem. To define the problem, a threshold $A$ for a financial impact is defined. The probability $P(A)$ shows probability that the financial impact bigger than $A$, and $P_{max}$ is the maximal acceptable value of $P(A)$. -In the business risk model, to avoide loss, an action needs to taken when $P(A)$ reaches it maximum value $P_{max}$. +In the business risk model, to avoid loss, an action needs to be taken when $P(A)$ reaches it maximum value $P_{max}$. The estimated $P(A)$ is based on some estimated parameters (inputs) and we are interested in finding the parameter(s) that when changed slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: -An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). An item ($i$th) is also assigned a probability to trigger another item ($j$th) with with the transition probability $P_{ij}$. +An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). An item ($i$th) is also assigned a probability to trigger another item ($j$th) with the transition probability $P_{ij}$. Each triggered risk item (e.g. by other items) generates a specific loss. The sum of the losses of the triggered items gives the total loss for a specific scenario. Finally, the model is evaluated by brute force (cf. ref [1] for the details). From fcb51caa5c66014478155715bd3a224999f13e88 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 01:24:09 -0400 Subject: [PATCH 75/85] Update Business_Application.md --- Business_Application.md | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 9be7602..ba1b4c2 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -55,10 +55,8 @@ Such quantum implementation of the model turns out to be remarkably efficient as # Potential customers -Potential customers for the Sensitivity Analysis of Business Risks includes banks, and any financial institute dealing with risk analysis -and any company dealing with portfolio.. - -Such analyses can be found in a wide range of applications such as .. +Potential customers for the Sensitivity Analysis of Business Risks includes banks, trading companies, and any financial institute dealing with risk analysis +and any company dealing with portfolio. # References From f9e04225d43764e33e0ab53746d32dda0032a8ca Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 09:21:19 -0400 Subject: [PATCH 76/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index ba1b4c2..a2a8b3f 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -12,7 +12,7 @@ They can be applied to various real-world problems such as cryptography, optimiz Grover's algorithm (1996) is known for its ability to address unstructured search problems, which are basic problems in computer science. Here, we implement and analysis the risk modeling and its representation on quantum circuits using this algorithm and the Quantum Amplitude Estimation (QAE). The fact that quantum algorithms are faster than a classical ones can be tested by the code execution runtime, measured by the number of elementary operations used by an algorithm, and can be done using the quantum circuit model. -The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (~200), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. +The quantum program employed here is fast (as compared to classical ones, e.g. quasi-Monte Carlo methods), requires low number of qubits (< 200, achievable), and has an interesting nested structure: Grover's algorithm\QAE\Quantum risk model. # Business risk model and analysis: From 65a6b1b5a21dff433bc79a964415712bf84128c2 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 09:21:51 -0400 Subject: [PATCH 77/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index a2a8b3f..2c3422f 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -1,4 +1,4 @@ -# Business Application of Quantum Algorithm for the Sensitivity Analysis of Business Risks +# Quantum Algorithms for the Sensitivity Analysis of Business Risks # Quantum algorithms From e5857720ba1ea94c8c6a2edb4fe86957c4cbcb77 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 09:33:53 -0400 Subject: [PATCH 78/85] Update Business_Application.md --- Business_Application.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 2c3422f..f399f1f 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -26,7 +26,8 @@ The estimated $P(A)$ is based on some estimated parameters (inputs) and we are i slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: -An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). An item ($i$th) is also assigned a probability to trigger another item ($j$th) with the transition probability $P_{ij}$. +An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). +An item ($i$th) is also assigned a probability to trigger another item ($j$th) with the transition probability $P_{ij}$. Each triggered risk item (e.g. by other items) generates a specific loss. The sum of the losses of the triggered items gives the total loss for a specific scenario. Finally, the model is evaluated by brute force (cf. ref [1] for the details). From 0b446121abf0e7d9404ebdf1911a6bcf134da92a Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 09:34:09 -0400 Subject: [PATCH 79/85] Update Business_Application.md --- Business_Application.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index f399f1f..e4526ef 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -27,7 +27,8 @@ slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). -An item ($i$th) is also assigned a probability to trigger another item ($j$th) with the transition probability $P_{ij}$. +An item ($i$th) +is also assigned a probability to trigger another item ($j$th) with the transition probability $P_{ij}$. Each triggered risk item (e.g. by other items) generates a specific loss. The sum of the losses of the triggered items gives the total loss for a specific scenario. Finally, the model is evaluated by brute force (cf. ref [1] for the details). From f4ee6a009eef7ca9d52f1056d396bc2ca00aadd2 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 09:34:51 -0400 Subject: [PATCH 80/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index e4526ef..466bad9 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -27,7 +27,7 @@ slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). -An item ($i$th) +An item ($\italic{i}$th) is also assigned a probability to trigger another item ($j$th) with the transition probability $P_{ij}$. Each triggered risk item (e.g. by other items) generates a specific loss. The sum of the losses of the triggered items gives the total loss for a specific scenario. From 2a26c664b2b6c745f1978755490ed2d16be001ee Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 09:35:18 -0400 Subject: [PATCH 81/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 466bad9..544c6d8 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -27,7 +27,7 @@ slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). -An item ($\italic{i}$th) +An item ($$i$$th) is also assigned a probability to trigger another item ($j$th) with the transition probability $P_{ij}$. Each triggered risk item (e.g. by other items) generates a specific loss. The sum of the losses of the triggered items gives the total loss for a specific scenario. From c1ec68715f46adb660efae4b8b2546a42f406843 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 09:35:42 -0400 Subject: [PATCH 82/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index 544c6d8..e4526ef 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -27,7 +27,7 @@ slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). -An item ($$i$$th) +An item ($i$th) is also assigned a probability to trigger another item ($j$th) with the transition probability $P_{ij}$. Each triggered risk item (e.g. by other items) generates a specific loss. The sum of the losses of the triggered items gives the total loss for a specific scenario. From 8c0fd832416ce42cc7e1c756d59a7ce290e2aa86 Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 09:36:01 -0400 Subject: [PATCH 83/85] Update Business_Application.md --- Business_Application.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Business_Application.md b/Business_Application.md index e4526ef..93e289b 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -27,7 +27,7 @@ slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). -An item ($i$th) +An item ($i$ th) is also assigned a probability to trigger another item ($j$th) with the transition probability $P_{ij}$. Each triggered risk item (e.g. by other items) generates a specific loss. The sum of the losses of the triggered items gives the total loss for a specific scenario. From f56cbd3e6eea681d49a7a1aeb5324ff216d1517d Mon Sep 17 00:00:00 2001 From: Ehsan Barati <38752076+ebarati@users.noreply.github.com> Date: Wed, 27 Jul 2022 09:36:26 -0400 Subject: [PATCH 84/85] Update Business_Application.md --- Business_Application.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Business_Application.md b/Business_Application.md index 93e289b..6723813 100644 --- a/Business_Application.md +++ b/Business_Application.md @@ -27,8 +27,7 @@ slightly, influence the output of the model such that $P(A)>P_{max}$. The business risks is implemented as follows: An intrinsic probability $P_i$ is defined for each relevant event (risk item, e.g. a change in stock market). -An item ($i$ th) -is also assigned a probability to trigger another item ($j$th) with the transition probability $P_{ij}$. +An item ($i$ th) is also assigned a probability to trigger another item ($j$ th) with the transition probability $P_{ij}$. Each triggered risk item (e.g. by other items) generates a specific loss. The sum of the losses of the triggered items gives the total loss for a specific scenario. Finally, the model is evaluated by brute force (cf. ref [1] for the details). From 4642a279c2591f1d67bc63d79a06e3f660d5495a Mon Sep 17 00:00:00 2001 From: Gopal M <46003265+gopalm-ai@users.noreply.github.com> Date: Wed, 27 Jul 2022 09:53:03 -0400 Subject: [PATCH 85/85] Created using Colaboratory --- Risk_Analysis_Hackathon.ipynb | 931 +++++++++++++++++----------------- 1 file changed, 455 insertions(+), 476 deletions(-) diff --git a/Risk_Analysis_Hackathon.ipynb b/Risk_Analysis_Hackathon.ipynb index f0502a5..6d2acaa 100644 --- a/Risk_Analysis_Hackathon.ipynb +++ b/Risk_Analysis_Hackathon.ipynb @@ -23,210 +23,138 @@ }, { "cell_type": "code", - "source": [ - "!pip3 install qiskit\n", - "!pip3 install dimod\n", - "!pip3 install greedy\n", - "!pip3 install numpy\n", - "!pip3 install pylatexenc\n", - "#!pip3 install qiskit_textbook" - ], + "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "JnHjmawi5_dp", - "outputId": "b5716fe5-843e-46d7-dbd1-c501b170f879" + "outputId": "66025db2-05e0-4bbd-8280-46d64228e366" }, - "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting qiskit\n", - " Downloading qiskit-0.37.0.tar.gz (13 kB)\n", - "Collecting qiskit-terra==0.21.0\n", - " Downloading qiskit_terra-0.21.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (6.7 MB)\n", - "\u001b[K |████████████████████████████████| 6.7 MB 4.1 MB/s \n", - "\u001b[?25hCollecting qiskit-aer==0.10.4\n", - " Downloading qiskit_aer-0.10.4-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (18.0 MB)\n", - "\u001b[K |████████████████████████████████| 18.0 MB 250 kB/s \n", - "\u001b[?25hCollecting qiskit-ibmq-provider==0.19.2\n", - " Downloading qiskit_ibmq_provider-0.19.2-py3-none-any.whl (240 kB)\n", - "\u001b[K |████████████████████████████████| 240 kB 49.1 MB/s \n", - "\u001b[?25hRequirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aer==0.10.4->qiskit) (1.7.3)\n", + "Requirement already satisfied: qiskit in /usr/local/lib/python3.7/dist-packages (0.37.0)\n", + "Requirement already satisfied: qiskit-terra==0.21.0 in /usr/local/lib/python3.7/dist-packages (from qiskit) (0.21.0)\n", + "Requirement already satisfied: qiskit-aer==0.10.4 in /usr/local/lib/python3.7/dist-packages (from qiskit) (0.10.4)\n", + "Requirement already satisfied: qiskit-ibmq-provider==0.19.2 in /usr/local/lib/python3.7/dist-packages (from qiskit) (0.19.2)\n", "Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-aer==0.10.4->qiskit) (1.21.6)\n", + "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aer==0.10.4->qiskit) (1.7.3)\n", + "Requirement already satisfied: websockets>=10.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (10.3)\n", "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (2.8.2)\n", - "Collecting requests-ntlm>=1.1.0\n", - " Downloading requests_ntlm-1.1.0-py2.py3-none-any.whl (5.7 kB)\n", - "Collecting websockets>=10.0\n", - " Downloading websockets-10.3-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (112 kB)\n", - "\u001b[K |████████████████████████████████| 112 kB 49.6 MB/s \n", - "\u001b[?25hCollecting websocket-client>=1.0.1\n", - " Downloading websocket_client-1.3.3-py3-none-any.whl (54 kB)\n", - "\u001b[K |████████████████████████████████| 54 kB 2.5 MB/s \n", - "\u001b[?25hRequirement already satisfied: urllib3>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (1.24.3)\n", "Requirement already satisfied: requests>=2.19 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (2.23.0)\n", - "Collecting ply>=3.10\n", - " Downloading ply-3.11-py2.py3-none-any.whl (49 kB)\n", - "\u001b[K |████████████████████████████████| 49 kB 5.6 MB/s \n", - "\u001b[?25hRequirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (1.7.1)\n", - "Collecting retworkx>=0.11.0\n", - " Downloading retworkx-0.11.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.6 MB)\n", - "\u001b[K |████████████████████████████████| 1.6 MB 49.9 MB/s \n", - "\u001b[?25hCollecting shared-memory38\n", - " Downloading shared_memory38-0.1.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl (25 kB)\n", + "Requirement already satisfied: urllib3>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (1.24.3)\n", + "Requirement already satisfied: requests-ntlm>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (1.1.0)\n", + "Requirement already satisfied: websocket-client>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (1.3.3)\n", + "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (5.4.8)\n", + "Requirement already satisfied: symengine>=0.9 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (0.9.2)\n", + "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (3.5.0)\n", + "Requirement already satisfied: shared-memory38 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (0.1.2)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (4.1.1)\n", + "Requirement already satisfied: ply>=3.10 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (3.11)\n", "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (0.3.5.1)\n", - "Collecting symengine>=0.9\n", - " Downloading symengine-0.9.2-cp37-cp37m-manylinux2010_x86_64.whl (37.5 MB)\n", - "\u001b[K |████████████████████████████████| 37.5 MB 1.2 MB/s \n", - "\u001b[?25hRequirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (4.1.1)\n", - "Collecting tweedledum<2.0,>=1.1\n", - " Downloading tweedledum-1.1.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (943 kB)\n", - "\u001b[K |████████████████████████████████| 943 kB 53.5 MB/s \n", - "\u001b[?25hRequirement already satisfied: psutil>=5 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (5.4.8)\n", - "Collecting stevedore>=3.0.0\n", - " Downloading stevedore-3.5.0-py3-none-any.whl (49 kB)\n", - "\u001b[K |████████████████████████████████| 49 kB 5.7 MB/s \n", - "\u001b[?25hRequirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.8.0->qiskit-ibmq-provider==0.19.2->qiskit) (1.15.0)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.19.2->qiskit) (2022.6.15)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.19.2->qiskit) (2.10)\n", + "Requirement already satisfied: tweedledum<2.0,>=1.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (1.1.1)\n", + "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (1.7.1)\n", + "Requirement already satisfied: retworkx>=0.11.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.21.0->qiskit) (0.11.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.8.0->qiskit-ibmq-provider==0.19.2->qiskit) (1.15.0)\n", "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.19.2->qiskit) (3.0.4)\n", - "Collecting cryptography>=1.3\n", - " Downloading cryptography-37.0.4-cp36-abi3-manylinux_2_24_x86_64.whl (4.1 MB)\n", - "\u001b[K |████████████████████████████████| 4.1 MB 35.8 MB/s \n", - "\u001b[?25hCollecting ntlm-auth>=1.0.2\n", - " Downloading ntlm_auth-1.5.0-py2.py3-none-any.whl (29 kB)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.19.2->qiskit) (2.10)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.19.2->qiskit) (2022.6.15)\n", + "Requirement already satisfied: ntlm-auth>=1.0.2 in /usr/local/lib/python3.7/dist-packages (from requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.19.2->qiskit) (1.5.0)\n", + "Requirement already satisfied: cryptography>=1.3 in /usr/local/lib/python3.7/dist-packages (from requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.19.2->qiskit) (37.0.4)\n", "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.7/dist-packages (from cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.19.2->qiskit) (1.15.1)\n", "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.12->cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.19.2->qiskit) (2.21)\n", "Requirement already satisfied: importlib-metadata>=1.7.0 in /usr/local/lib/python3.7/dist-packages (from stevedore>=3.0.0->qiskit-terra==0.21.0->qiskit) (4.12.0)\n", - "Collecting pbr!=2.1.0,>=2.0.0\n", - " Downloading pbr-5.9.0-py2.py3-none-any.whl (112 kB)\n", - "\u001b[K |████████████████████████████████| 112 kB 60.8 MB/s \n", - "\u001b[?25hRequirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=1.7.0->stevedore>=3.0.0->qiskit-terra==0.21.0->qiskit) (3.8.1)\n", + "Requirement already satisfied: pbr!=2.1.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from stevedore>=3.0.0->qiskit-terra==0.21.0->qiskit) (5.9.0)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=1.7.0->stevedore>=3.0.0->qiskit-terra==0.21.0->qiskit) (3.8.1)\n", "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.7/dist-packages (from sympy>=1.3->qiskit-terra==0.21.0->qiskit) (1.2.1)\n", - "Building wheels for collected packages: qiskit\n", - " Building wheel for qiskit (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for qiskit: filename=qiskit-0.37.0-py3-none-any.whl size=12028 sha256=85d0c7367b42fcd77cb3d2298956de90f45bbe23388cc5f86a1c290e0e773eb7\n", - " Stored in directory: /root/.cache/pip/wheels/ed/f9/fa/3ed81abb79590bf4c0432e7816bcdf3f0dbd1ba5aeb3eeddf7\n", - "Successfully built qiskit\n", - "Installing collected packages: pbr, tweedledum, symengine, stevedore, shared-memory38, retworkx, ply, ntlm-auth, cryptography, websockets, websocket-client, requests-ntlm, qiskit-terra, qiskit-ibmq-provider, qiskit-aer, qiskit\n", - "Successfully installed cryptography-37.0.4 ntlm-auth-1.5.0 pbr-5.9.0 ply-3.11 qiskit-0.37.0 qiskit-aer-0.10.4 qiskit-ibmq-provider-0.19.2 qiskit-terra-0.21.0 requests-ntlm-1.1.0 retworkx-0.11.0 shared-memory38-0.1.2 stevedore-3.5.0 symengine-0.9.2 tweedledum-1.1.1 websocket-client-1.3.3 websockets-10.3\n", "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting dimod\n", - " Downloading dimod-0.11.4-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (11.8 MB)\n", - "\u001b[K |████████████████████████████████| 11.8 MB 5.2 MB/s \n", - "\u001b[?25hRequirement already satisfied: numpy<2.0.0,>=1.17.3 in /usr/local/lib/python3.7/dist-packages (from dimod) (1.21.6)\n", - "Installing collected packages: dimod\n", - "Successfully installed dimod-0.11.4\n", + "Requirement already satisfied: dimod in /usr/local/lib/python3.7/dist-packages (0.11.4)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.17.3 in /usr/local/lib/python3.7/dist-packages (from dimod) (1.21.6)\n", "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting greedy\n", - " Downloading greedy-0.1.1-py3-none-any.whl (19 kB)\n", + "Requirement already satisfied: greedy in /usr/local/lib/python3.7/dist-packages (0.1.1)\n", + "Requirement already satisfied: geopandas in /usr/local/lib/python3.7/dist-packages (from greedy) (0.10.2)\n", + "Requirement already satisfied: libpysal in /usr/local/lib/python3.7/dist-packages (from greedy) (4.6.2)\n", "Requirement already satisfied: networkx in /usr/local/lib/python3.7/dist-packages (from greedy) (2.6.3)\n", - "Collecting geopandas\n", - " Downloading geopandas-0.10.2-py2.py3-none-any.whl (1.0 MB)\n", - "\u001b[K |████████████████████████████████| 1.0 MB 5.3 MB/s \n", - "\u001b[?25hCollecting libpysal\n", - " Downloading libpysal-4.6.2-py3-none-any.whl (2.4 MB)\n", - "\u001b[K |████████████████████████████████| 2.4 MB 40.9 MB/s \n", - "\u001b[?25hCollecting fiona>=1.8\n", - " Downloading Fiona-1.8.21-cp37-cp37m-manylinux2014_x86_64.whl (16.7 MB)\n", - "\u001b[K |████████████████████████████████| 16.7 MB 457 kB/s \n", - "\u001b[?25hCollecting pyproj>=2.2.0\n", - " Downloading pyproj-3.2.1-cp37-cp37m-manylinux2010_x86_64.whl (6.3 MB)\n", - "\u001b[K |████████████████████████████████| 6.3 MB 40.9 MB/s \n", - "\u001b[?25hRequirement already satisfied: pandas>=0.25.0 in /usr/local/lib/python3.7/dist-packages (from geopandas->greedy) (1.3.5)\n", + "Requirement already satisfied: pandas>=0.25.0 in /usr/local/lib/python3.7/dist-packages (from geopandas->greedy) (1.3.5)\n", + "Requirement already satisfied: fiona>=1.8 in /usr/local/lib/python3.7/dist-packages (from geopandas->greedy) (1.8.21)\n", "Requirement already satisfied: shapely>=1.6 in /usr/local/lib/python3.7/dist-packages (from geopandas->greedy) (1.8.2)\n", - "Requirement already satisfied: six>=1.7 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (1.15.0)\n", - "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (57.4.0)\n", + "Requirement already satisfied: pyproj>=2.2.0 in /usr/local/lib/python3.7/dist-packages (from geopandas->greedy) (3.2.1)\n", "Requirement already satisfied: attrs>=17 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (21.4.0)\n", - "Collecting click-plugins>=1.0\n", - " Downloading click_plugins-1.1.1-py2.py3-none-any.whl (7.5 kB)\n", "Requirement already satisfied: click>=4.0 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (7.1.2)\n", + "Requirement already satisfied: click-plugins>=1.0 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (1.1.1)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (57.4.0)\n", + "Requirement already satisfied: cligj>=0.5 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (0.7.2)\n", + "Requirement already satisfied: six>=1.7 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (1.15.0)\n", + "Requirement already satisfied: munch in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (2.5.0)\n", "Requirement already satisfied: certifi in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas->greedy) (2022.6.15)\n", - "Collecting cligj>=0.5\n", - " Downloading cligj-0.7.2-py3-none-any.whl (7.1 kB)\n", - "Collecting munch\n", - " Downloading munch-2.5.0-py2.py3-none-any.whl (10 kB)\n", "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas->greedy) (2.8.2)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas->greedy) (2022.1)\n", "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas->greedy) (1.21.6)\n", - "Requirement already satisfied: appdirs in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (1.4.4)\n", - "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (2.11.3)\n", - "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (4.6.3)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (21.3)\n", "Requirement already satisfied: scipy>=0.11 in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (1.7.3)\n", "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (2.23.0)\n", - "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (21.3)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (2.11.3)\n", + "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (4.6.3)\n", + "Requirement already satisfied: appdirs in /usr/local/lib/python3.7/dist-packages (from libpysal->greedy) (1.4.4)\n", "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->libpysal->greedy) (2.0.1)\n", "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging->libpysal->greedy) (3.0.9)\n", - "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->libpysal->greedy) (1.24.3)\n", - "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->libpysal->greedy) (3.0.4)\n", "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->libpysal->greedy) (2.10)\n", - "Installing collected packages: munch, cligj, click-plugins, pyproj, fiona, libpysal, geopandas, greedy\n", - "Successfully installed click-plugins-1.1.1 cligj-0.7.2 fiona-1.8.21 geopandas-0.10.2 greedy-0.1.1 libpysal-4.6.2 munch-2.5.0 pyproj-3.2.1\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->libpysal->greedy) (3.0.4)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->libpysal->greedy) (1.24.3)\n", "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (1.21.6)\n", "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting pylatexenc\n", - " Downloading pylatexenc-2.10.tar.gz (162 kB)\n", - "\u001b[K |████████████████████████████████| 162 kB 5.1 MB/s \n", - "\u001b[?25hBuilding wheels for collected packages: pylatexenc\n", - " Building wheel for pylatexenc (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for pylatexenc: filename=pylatexenc-2.10-py3-none-any.whl size=136835 sha256=456654fdc157d7cd7abfe321f77450c462f8264b5ef3015358659c43e7359aad\n", - " Stored in directory: /root/.cache/pip/wheels/f1/8a/f5/33ee79d4473eb201b519fa40f989b842e373237395a3421f52\n", - "Successfully built pylatexenc\n", - "Installing collected packages: pylatexenc\n", - "Successfully installed pylatexenc-2.10\n" + "Requirement already satisfied: pylatexenc in /usr/local/lib/python3.7/dist-packages (2.10)\n" ] } + ], + "source": [ + "!pip3 install qiskit\n", + "!pip3 install dimod\n", + "!pip3 install greedy\n", + "!pip3 install numpy\n", + "!pip3 install pylatexenc\n", + "#!pip3 install qiskit_textbook" ] }, { "cell_type": "code", - "source": [ - "!git clone https://github.com/JoSQUANTUM/pygrnd.git\n", - "#!pip3 install pygrnd" - ], + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "RnBz315r3-mE", - "outputId": "7a06157f-6753-4306-f1fd-286b5788549f" + "outputId": "818dd07a-7a81-4af3-9842-43c01d6c3812" }, - "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "Cloning into 'pygrnd'...\n", - "remote: Enumerating objects: 199, done.\u001b[K\n", - "remote: Counting objects: 100% (199/199), done.\u001b[K\n", - "remote: Compressing objects: 100% (148/148), done.\u001b[K\n", - "remote: Total 199 (delta 101), reused 129 (delta 50), pack-reused 0\u001b[K\n", - "Receiving objects: 100% (199/199), 553.72 KiB | 1.22 MiB/s, done.\n", - "Resolving deltas: 100% (101/101), done.\n" + "fatal: destination path 'pygrnd' already exists and is not an empty directory.\n" ] } + ], + "source": [ + "!git clone https://github.com/JoSQUANTUM/pygrnd.git\n", + "#!pip3 install pygrnd" ] }, { "cell_type": "code", - "source": [ - "#cd pygrnd\n", - "!pip3 install pygrnd/" - ], + "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "cFq0lMnM6Wzv", - "outputId": "ec78bc83-e365-4ba7-db30-fc7fc116f3be" + "outputId": "601c3054-0352-45e8-ed7b-8bff0816dd4b" }, - "execution_count": null, "outputs": [ { "output_type": "stream", @@ -238,17 +166,29 @@ " pip 21.3 will remove support for this functionality. You can find discussion regarding this at https://github.com/pypa/pip/issues/7555.\u001b[0m\n", "Building wheels for collected packages: pygrnd\n", " Building wheel for pygrnd (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for pygrnd: filename=pygrnd-0.1.0-py3-none-any.whl size=37571 sha256=d6ac8e98b015045b0cbe504195eae5fba3a3e5f21761bd5c387837c6bcc784ae\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-kwk9oygi/wheels/c6/b7/c0/b186dda1ea5b65ef883a645b27ad64a14b7eb0f729a6d523e8\n", + " Created wheel for pygrnd: filename=pygrnd-0.1.0-py3-none-any.whl size=37571 sha256=c37310586bd901155b741dd33c1019f0310b8f505152d343a72ff45f8e855c17\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-rqaaabwp/wheels/c6/b7/c0/b186dda1ea5b65ef883a645b27ad64a14b7eb0f729a6d523e8\n", "Successfully built pygrnd\n", "Installing collected packages: pygrnd\n", + " Attempting uninstall: pygrnd\n", + " Found existing installation: pygrnd 0.1.0\n", + " Uninstalling pygrnd-0.1.0:\n", + " Successfully uninstalled pygrnd-0.1.0\n", "Successfully installed pygrnd-0.1.0\n" ] } + ], + "source": [ + "!pip3 install pygrnd/" ] }, { "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "4HSrlI8d8sNa" + }, + "outputs": [], "source": [ "from pygrnd.qc.helper import *\n", "from pygrnd.qc.brm import *\n", @@ -267,199 +207,199 @@ "from scipy.stats import norm\n", "import networkx as nx\n", "from IPython.display import Image" - ], - "metadata": { - "id": "4HSrlI8d8sNa" - }, - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "markdown", - "source": [ - "## Small Example" - ], "metadata": { "id": "sVQ25bzqN-mk" - } + }, + "source": [ + "## Small Example" + ] }, { "cell_type": "code", - "source": [ - "## small example\n", - "\n", - "nodes=['0','1'] # risk items defition\n", - "edges=[('0','1')] # correlations\n", - "\n", - "probsNodes={'0':0.1,'1':0.1} # intrinsic probs\n", - "probsEdges={('0','1'):0.2} # transition probs\n", - "\n", - "print(\"Number of risk items = \",len(nodes))\n", - "print(\"Number of correlations = \",len(edges))" - ], + "execution_count": null, "metadata": { - "id": "zyjXGl6f67vR", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "34afa17b-6500-46ee-c874-95547b265b25" + "id": "zyjXGl6f67vR", + "outputId": "76fd2c8c-f3ed-4b5a-aa66-a1f449227f9a" }, - "execution_count": null, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Number of risk items = 2\n", - "Number of correlations = 1\n" + "Number of correlations = 2\n" ] } + ], + "source": [ + "## small example\n", + "\n", + "nodes=['0','1'] # risk items defition\n", + "edges=[('0','1'),('1','0')] # correlations\n", + "\n", + "probsNodes={'0':0.4,'1':0.6} # intrinsic probs\n", + "probsEdges={('0','1'):0.3, ('1','0'):0.7} # transition probs\n", + "\n", + "print(\"Number of risk items = \",len(nodes))\n", + "print(\"Number of correlations = \",len(edges))" ] }, { "cell_type": "code", - "source": [ - "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", - "rm.draw(output='mpl')" - ], + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 140 }, "id": "MCO78g5z97YO", - "outputId": "7b9fea13-c884-440a-84ef-cd2dcf0d483c" + "outputId": "8651bded-173f-4b60-8c5c-9876a81e1d05" }, - "execution_count": null, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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\n", "text/plain": [ - "
" - ], - "image/png": "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\n" + "
" + ] }, + "execution_count": 14, "metadata": {}, - "execution_count": 16 + "output_type": "execute_result" } + ], + "source": [ + "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", + "rm.draw(output='mpl')" ] }, { "cell_type": "code", - "source": [ - "# execute function to build a qiskit gate with the risk model\n", - "#rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", - "\n", - "rm.measure_all()\n", - "display(rm.draw(output='mpl'))\n", - "print(\"-------------------------------\")\n", - "\n", - "backend = Aer.get_backend('qasm_simulator')\n", - "job = execute(rm, backend,shots=100000)\n", - "result=job.result()\n", - "counts=job.result().get_counts()\n", - "plot_histogram(counts,figsize=(16,8))" - ], + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 680 }, "id": "E6rrMZzV9-iK", - "outputId": "bd9a07af-13f0-4ac5-8986-ff2bc307afa9" + "outputId": "2b87c8a2-7131-4c75-c31b-9ceab56036ee" }, - "execution_count": null, "outputs": [ { - "output_type": "display_data", "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAACoCAYAAAAb366wAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3daUBUZd/H8e8wMICyqKEi7oSaoIiIWZoC4q63lrlm9rhi7kuPWZmKebukhluGeptm+aQirpmWO+Vym+S+ZZQLuCAuqCjrwPNiEh0ZYFSYA4f/5xVcc51zfqPy83C20WRmZmYihBBCVayUDiCEECL/SbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKSbkLIYQKWSsdQAjx7M6dO5fnnC+//JJhw4blOueVV17Jr0iikJE9dyFUauHChUpHEAqSchdCCBWSchdCCBWSchdCpSIiIpSOIBQk5S6EECok5S6ESnXp0kXpCEJBcimkhfyxG+7fUDpF7hzLQa3mSqcQRd2oUaM4duyYxbfr4+PD3LlzLb7dwkrK3ULu34CEWKVTCFHwjh07RmRkpNIxij05LCOESg0dOlTpCEJBUu5CqFRed6cKdZNyF0KlmjVrpnQEoSApdyFUKj4+XukIQkFS7kIIoUJS7kXIu9OqsfP3lWaPi+LN09NT6QhCQXIppBAqtW7dOqUjmK1kyZJ4eXnh7OxMWloa0dHRxMbmfO1wo0aNcHR0ZOfOnRZMWbTInrsQKjVx4kSlI+SqdOnSjB49muPHj3Pv3j0OHTrE9u3b2bNnDzExMcTFxfGf//yH+vXrGy3XqFEjfv75ZzZv3oyPj49C6Qs/KXdhEQ9uwd8H4c9IiDkKaclKJ8qbPg2unjJk/msf3L0KmZlKpzLf2rVrlY6Qo4EDB3Lx4kVCQ0Px9vZGr9dz7NgxduzYwa+//srt27cpV64cAwYM4MiRI4SHh+Pi4pJV7M7OzmzevJmTJ08q/VYKrWJ5WCYjI4PQ0FAWL15MTEwMtWrVYv78+QQHB+Pv78+SJUuUjqga6Slwaivc/MvwvZUWMvSGwqz+GlRrBBqNshlNuXYazu0CferjsQv/BSdX8O4Idk7KZSvK7O3tWbVqFZ06dQJg165dLFiwgJ9++omUlBSjubVr12bgwIEMHDiQrl27EhQUhE6nw8HBgTVr1tCrVy/0er0Sb6NIKJbl3r9/f9avX8+ECRNo0KABBw4coGfPnsTHxzNmzBil4+VIq7UhPSMt23i6Pg1rrY0CiXKXkQHH1sPda+DeBCp5g66k4VEMFw4a9oY1GkPBFyZxf8DpbaZfuxcHUWugUW+wsbNsrqLOxsaGjRs30qpVK27fvs3gwYMJDw/Pcf7Zs2cZM2YM8+bNIyIiAj8/PwB27NghxW6GYlfuq1at4ptvvmHv3r34+/sDEBgYyJEjR1i/fj2+vr4KJ8yZa+lqXL0ZbTSWlJLInfvXqfCSu0KpcnYzGhKugGcbcKvzeNyxHNTtCCc2Gw7VVPIBa1vlcj4pM9PwW0XOEyD5Llw5Xvj+U3paYXu+y6RJk2jVqhVxcXEEBASY9TmwAK6urtSoUSPrew8PD+zs7Hjw4EFBRVWFYnfMfdq0abRp0yar2B/x8PDAxsYGb29vAC5evIi/vz81a9akbt26/Prrr0rENdLKrw9bDy3h5N+/os/Qc//hHb7aNJJqrnXxcKuf9wos7MpJsHOECiauyNNooHojyEiH6+b9jFvEnRhIvpf3vCtF4FDv6dOnlY6QxcfHh3HjxpGRkcHbb79tdrE/eYw9PDycI0eOUL16daZPn17AiYu+YrXnHhsby6lTpxg9enS21y5fvoyXlxe2toZdyEGDBtG9e3eGDBnCgQMH6Nq1KxcuXECn0+W5HY2Jg8iz399DvZcDXih/kG8vUtIesmDDUOISLmGvc8Db3Z8p/X5Aq33xv8rIyL007Bn4wut5ZOn/nsKviReaHHYhHMsDZDJh3FS++XlCvm33RbRo0JtxPb7Nc97dm8loNPYWSGSaqX/DT5szZ06e8+bMmZNfkXI1duxYrK2tmT9/Pvv37zdrmSeL/dExdi8vL44ePUpwcDCTJ0/m1q1bWfMjIyNN/uypTaaZZ/WLXbmD4de8JyUlJREZGUnbtm0BuHnzJvv27WPz5s0ANG7cGDc3N/bs2UPr1q0tG/op7RoNpF2jgYpmMNf9pDs8TMggp18QU+4DaHiQfNeSsXL10JzdduBh8v0CTqIeLi4udOnSBb1ez6xZs8xaxlSx6/V6Tpw4wdatW+nQoQN9+/Zl9uzZBZy+6CpW5e7i4gLA+fPnadeuXdb4zJkzuXbtGg0aNAAMe/Hly5fP2osHqF69OpcuXTJrO6b+Z41aXfif5+7vH0BmWP5d63f5CJzfDQlXoZRb9tdj//k8hxUbZxFeyrwf+oKmT4VfwgyXQeambrOyZu9BFQRzDmvMmTOH4ODgXOeEhobmV6QsAQEBRsf7mzZtik6nY+fOnbnemPRITsX+yLfffkuHDh0ICgoyKnd/f3/27t2br++lKCtW5e7u7o63tzfTpk2jTJkyVKxYkYiICLZu3QqQVe4if7h5wcVDcHIz1O0AzhUNx9oz9IYTkhcPQ/lXwL6U0kkf0+qgip/hah6TNGBlBZUL3ymObCZPnqx0BODxz9WhQ4fynJtXsT+5Hvl5zV2xOqFqZWXF2rVr8fLyYvDgwfTt2xcXFxeGDh2KVqvNOplapUoV4uLijK67vXDhAlWrVlUqepFkbQu+/3yMZ9Rq+O83cHQd7Fts+NjBMlXBs5WiEU1yfx3c6v7zzVOHcK20UO8tKFHa4rGeWbdu3ZSOAEDFihUB+Ouvv3KdZ06xg+E367S0NMqWLYu1dbHaP30mxe5PpmbNmuzZs8dorHfv3nh6emJvbzhB5uLiQpMmTfj666+zTqheuXKFwMD8O9lYXDiUhdf7wfUzcG6n4U7VcjXAzRteqlY4b2DSWEHtVoaCv3IMrp0xjHs0NVzSqSupbD5z1a5dm7Nnzyodg0GDBjFq1CiSk3O/LdnFxQV7e3uzblBydXUlOTmZ9PT0/I6rGsWu3E2JioritddeMxpbtGgRffr0Ye7cueh0OlatWmXWlTJ5uXn3KhOWd+BS3Bl++HditqtcFm4ayV9Xj5GWlsygf4VSp3oTpq7swe3710lLTyElLYnFY0x/+PCF66eYt+59MjMzGdk5DHc3b5PzjkbvZvm28ehs7BjX4zvKlqr0wu8rN9Y6w7Xs5/55xpN3pwLdXL7QaAznCUq5PS73wn5de2GVmppKampqnvN+/PFH3njjDY4cOZLnDUq3b9/Or3iqVezLPTExkfPnzzNkyBCjcXd3d3755Zd8355TiTLMDN5FyIq3TL4+qMNsrLU2xN25xPz1Q5ja/0fGv7sagH0nN/Dnld9zXPeKnybwSa9VWGmsmL9+CJ/13WRy3v/tnMKMgdu5dOMMq3ZPZ0TnhS/+xoTIB4cPH1Y6gmoU+3J3cHCw6G3MOhs7dLnct/7oMQJJKYm4u9Uzem3/qQ10bjoqx2XvJ92hXKnKACQmJ5ick5z6EJ2NPSXsHKldpRFLfxz3rG9BFBEBAQFKRxAKKvblXhiFfPMW52J+Y1zP77LG0vVpXLh+khqVcn48QmZmxpPfmJyTmJRASdvHT73KyJTnc6hVWFiY0hGEgorV1TJFRUifDSwYfohl2z7JGjv+196873B94uykJofbQkvaO/Mg5fGNOlYa7QtlFYXX4MGDlY4gFCTlXsikphsuv7S3dcDuicsy9p/aQJM6j4/T33t4m5S0JKNlnezLEJ8Qy827VynxzzNp7yTeIP2JO3LsdSVJTUsiKSWRc5d/o2p5+Sg2tZIbeoo3OSxjYen6ND5Z2pa/rx3no6Wt6dd2GuVLVWXb4a/pFTSeqSu7k5iUQEamnv5tDQ9HyszM5Mylgwx788us9az7JZSGtdpSp3qTrLH3Wk3m3yu7AzD8LcNJ0sWbxzCg/ee4OFfMmvdO8/GMW9ISnY0dH3ZfYYm3LYSwMCl3C7PW2jBzUPbPfewVNB6AyX02ZntNo9GwaPRRo7EHyXfxrPq60Zi7mzfzhhk/lKmEnZNRsQP41myBb80Wz5VfCFE0SLkXUcPeXGDWvBGdvyrgJKKwKgw3MAnlSLlbiGM5pRPkrShkFOYLDw9X5BEEz/Oh1X9fvgaAe5UKRl8X9HbVTMrdQmo1VzqBKG4mTZqkSLnPnTv3mZf56HPD5xbPGBds9LV4fnK1jBBCqJCUuxBCqJCUuxAq9dVXcjK9OJNyF0KlvLy8lI4gFCTlLoRK+fv7Kx1BKEjKXQghVEjKXQiVatiwodIRhIKk3IVQKfngi+JNyl0IIVRIyl0IIVRIyl0IlYqIiFA6glCQlLsQQqiQlLsQKtWlSxelIwgFyVMhRY7+2A33b+T/eqNW59+6HMtlf+JmUc0tlDNq1CiOHTumyLZ9fHye60maeZFyFzm6fwMSYvN/vQWxzicV1dxCOceOHSMyMlLpGPlKDssIoVJDhw5VOoJQkJS7ECo1bNgwpSMIBUm5C6FSzZo1UzqCUJCUuxAqFR8fr3QEoSApd1Eg3p1WjZ2/rzR7vDAoipmFyImUuxAq5enpqXQEoSApdyFUat26dUpHEE9xdna22Lak3IVQqYkTJyodQbVeffVVJkyYwKZNmzh69CjHjx9n9+7dfPHFF3Tu3BkbG5tsy7Rp04aLFy/SsmVLi2SUm5iEIu7cjyNkxVtYa3WkpiXRt+00fGsEKR0rV0Ut89q1a/nss8+UjqEqHTt2ZNKkSfj6+pp8PTAwkDFjxnD9+nUWLFjA7NmzSU1NpU2bNmzcuBFbW1tatWrFjh07CjxrsS33jIwMQkNDWbx4MTExMdSqVYv58+cTHByMv78/S5YsUTpikabV2pCekZZtPF2fhrXWBqeSLoQO+RWtlZZrt/7m3yu74ztS2Q+XKIqZhWU4OTkRFhbGO++8A8DNmzf5/vvvOXjwIOfPnyc9PZ2KFSvi5+dH165dqVu3LlOnTqVHjx6EhYUxZ84cbG1tWbBgAWPHjrVI5mJb7v3792f9+vVMmDCBBg0acODAAXr27El8fDxjxoxROl6R51q6GldvRhuNJaUkcuf+dSq85I7WSps1npiUgHsFb0tHzKYoZhYFr1SpUuzYsQM/Pz8ePHjA+PHjWbRoESkpKUbzTpw4wbZt25gyZQpBQUGEhYVRt25dFi5ciEajYcGCBYwYMcJiuYtlua9atYpvvvmGvXv3Zn1CfGBgIEeOHGH9+vU5/solzNfKrw9hm0fRsFYbPKs15mHyPZZs+V+qudbFw60+ANduX+DzVb2Jjf+D/+22XOHERTNzbtT2rBQlaDQa1q9fj5+fH9HR0bRt25bo6Og8l9u1axdjx45l3bp1aLVakpOTmT17tgUSP1Ysy33atGm0adMmq9gf8fDwwMbGBm9vwx7ZxIkTWb16NdHR0YSHh8sjVJ9BkG8vUtIesmDDUOISLmGvc8Db3Z8p/X5AqzX8s6tQpjpzh+7j2q2/Gbu4Oa95dpDM+ej06dOUK1dO6RhF2vDhwwkMDOT69esEBgYSG2ve0+PatGnDmjVr0Gq1XLhwgerVq7N06VJatWpVwIkfK3blHhsby6lTpxg9enS21y5fvoyXlxe2traA4S+oT58+9OvX75m2odFo8iWr0ma/v4d6Lwc89/LtGg2kXaOBJl9LTU9BZ234cy5h54S9zuG5thEZuZeGPQONxl4ktyUyg+ncz8LUv9+nzZkzJ895c+bMee4M+WncjMWA4Wfnya+V5OzszNSpUwEIDg5+pmJ/dPJ0wYIFTJkyhdOnT9OyZUvefPNNNm7caDQ/MjLymd5rZmamWfOKZbkDuLq6Go0nJSURGRlJ27Zts8YaN25s0WzFyfmYwyzb9glWVlrS9WkM7jRP6Uh5KoqZxfN77733cHBwYPfu3fzwww9mLfN0sT86xj516lTmzp3LkCFDspV7QSl25e7i4gLA+fPnadeuXdb4zJkzuXbtGg0aNHjhbZj7P2thF7W64J5hXqf6G4QO+eWF1+PvH0BmmPGfd0Hlzq/MYDr3szh37lyec+bMmUNwcHCuc0JDQ587Q3766HPD1WmZmZlGX1tKQEBAtnMUPXv2BOCrr74yax05FTvAihUrmD59Oi1btsTFxYWbN29mvebv78/evXtf/E08pdiVu7u7O97e3kybNo0yZcpQsWJFIiIi2Lp1K0C+lLsQhcHkyZOVjlBkabVafHx8AMPJ0bzkVuwACQkJREVF0bRpUxo0aMDPP/9cILmfVOzuULWysmLt2rV4eXkxePBg+vbti4uLC0OHDkWr1WadTBWiqOvWrZvSEYosd3d37O3tuXTpEgkJCbnOzavYH3n0MX5eXl75nteUYrfnDlCzZk327NljNNa7d288PT2xt7dXKJUQ+at27dqcPXtW6RhF0t27dwkJCcmz2EuXLs2aNWvyLHaALVu2cOfOHQ4dOpTfcU0qluVuSlRUFK+99prR2IQJE1i+fDnx8fGcPHmSUaNGERkZycsvv6xQSuXcvHuVCcs7cCnuDD/8OzHr0sBHpq7swe3710lLTyElLYnFY47x1aZR/HXVsLfy97XjbPjsTo7r/nzVu6SmJ/M/rT7Dt2YLk/MuXD/FvHXvk5mZycjOYbi75f5b1tnLh1i0eTQajRW1KjdkcEfjK0NMbXf17hn89sc2UlIf0rP5J7xR960XynI0ejfLt41HZ2PHuB7fUbZUpVwzi8Lhxo0bZh3WunPnDr169SIwMJAPPvgg17nbt29n+/bt+RUxT1LuQGJiIufPn2fIkCFG41OmTGHKlCkKpSpcnEqUYWbwLkJWmC678e+uBmDfyQ38eeV3AIZ0Mnyie/SVo0REfpHjutfsmcH/tJ7Cy271+HRZhxzLfcVPE/ik1yqsNFbMXz+Ez/puyjVz+VJVmTVoNzobO6Z/34sL105SvULdXLfbxf8DejT/iKSURD5c0iLHcjc3y//tnMKMgdu5dOMMq3ZPZ0TnhblmFkXPli1b2LJli9Ixsil2x9xNcXBwQK/XM3z4cKWjFFo6GzscS5TOc97+Uxt4o05no7F9pzbQpG7nHJaAC9dP4lWtMfa2DpSwdeRB8j2T8+4n3aFcqcq4OFckMTn3X5cByji5orOxA0BrZYPVE48PyGm71lrD0/xS0pKo5lonx3WbkyU59SE6G3tK2DlSu0ojLsWdzjNzfgoICLDo9kThIuUu8k26Po0L109So5Lx4xui/viJhrXa5LhcRoY+6yaOknbOPEgyXZaZmRlPfmN2rr+vnuDug3iqljf+8Iqctjt//RAGhXpT36N5jus0J0tiUgIlbZ0eby9Tb3bm/BAWFmbR7YnCRcpd5Jvjf+3NdmdobPyfuDhVxE5XIsflNJrH/wwfpNyjpH2pnCaaXCY39x7e5suNw/ig69dmb3dE569YNvYc3++amvOKzchS0t6ZBymPfwux0mhNzisogwcPtuj2ROEi5S7yzf5TG2hS561cxx4m38922MW9gjdnLh4kKfUBD5PvUdLOiXsPb5OSlmQ0z8m+DPEJsdy8e5USdk7kRa9PZ8aqdwnuMJsyTq7ZXje13dR0w5P+dDb2lPhnr9vcLHcSb5Cuf/zIYHtdSVLTkkhKSeTc5d+y/eZQ0ArixhhRdMgJVWGWdH0anyxty9/XjvPR0tb0azuN8qWqsu3w1/QKGk9mZiZnLh1k2JtfGi136OwWJvd5fLJx7/E12NrYE+TbK2usW8CHzFz9HilpSbzXynCFwrpfQmlYqy11qjfJmvdeq8n8e2V3AIa/lfeJycgTazkfc5j//PghAP3bTsez2ut8uXE4w95cYHK7X20aScyNc6TrU+kaMPaZsizePIYB7T/Hxbli1rx3mo9n3JKW6Gzs+LD7ijwzC5FfpNyFWay1NswctDPbeK+g8YDhIU+LRh/N9vrTt+tfu/UXPZp/bDRWtlQlZr2/22jsQfJdPKu+bjTm7ubNvGH7zc7cvH5PmtfvmW182JsLctzuqLcXZZtvbpYSdk5GxQ7gW7NFjlf/CFGQpNyFRfVvN92seY8KuDAwN8uIzuY9g8RS5Aam4k2OuQuhUuHh4UpHEAqSPXeRI8ci8DkPpjIW1dz5bdKkSfJ8GTM9ekjYs/r78jUA3KtUMPraEtvOi5S7yFGtnC/zLtSKam6hnLlz5z7Xco8eTzxjXLDR14WBHJYRQggVknIXQqXM/ZAJoU5S7kKolKWeGy4KJyl3IVTK399f6QhCQVLuQgihQlLuQgihQnIppBBF0CuvvJLnnEmTJpk1T6iT7LkLoVIhISFKRxAKknIXQggVknIXQggVknIXQggVknIXQggVknIXQggVknIXQggVknIXQggVknK3sJiYGIKCgqhduzZeXl58/PHHeS8khMjV3r178fLywsPDgwEDBqDX65WOlKeRI0dSqVIlrK0L5l5SKXcLs7a25vPPP+fs2bMcPXqUffv2sWnTJqVjCVFkZWRkMGDAANauXUt0dDT37t1j5cqVSsfKU9euXYmKiiqw9Uu5W1iFChXw8/MDQKfTUb9+fS5fvqxwKiGKrsOHD+Pm5oanpycA/fv3Z926dQqnytsbb7yBq6trga1fni2joNu3b7Nx40a2b9+udBQhLCotPZ1v120n8WGS0fi85etMft0usBE1qlUyua7Y2FgqV66c9X2VKlWIiYnJ58QGvx0/x8Ejp7ONm8pdoVwZurYLQKPRFEiWvMieu0JSU1Pp0qULI0eOlIc7iWLHxtqa1xt4ce3GLa7duJU1/vTX127copRTSTyqVsxxXZmZmQWa9Un1vTzIyMjIM/eNW3do9mo9xYodpNwVodfreeedd/Dx8eGDDz5QOo4QivD0qIqfd61c55S0t6Nzm2a5lmTlypWN9tQvX75MpUqm9/JflI21Nd3/1RytVe7V2appQ1zLlimQDOaScldAcHAwjo6OfPHFF0pHEUJR/2r+OmWcHXN8vXObZjiWLJHrOvz8/IiNjeXMmTMAfP3113Tu3Dlfcz7JrdxLtGzql+Pr1StXoGnDugW2fXNJuVvY/v37WbZsGVFRUdSvXx8fHx/mz58PWPbXSyEKA1tbHd06BGJqv7xB3Zp41ayW5zq0Wi1Lly6lS5cuvPzyyzg4ONC7d+98z/qkZq96U61S9pOhtjoburYPwCqPPXuAQYMGUalSJfR6PZUqVWLo0KH5mlGTKY1SaGz4+Ve0Wis6tmiidBQhLOqnyN/Y+99jWd+XdnZkZN+3sbPVKZgqd7cT7jF3+TpSU9Oyxrq088evbu6HmixF9twLiVsJ9zh84hyY3IcRQt1avNGACuVeAgw/AV3bBxTqYgcoU8qJfwW9nvW9Z41qNKhTU8FExgpNuYeEhKDRaDh16hTt27fHwcGBChUqMGvWLAC2bduGr68vJUqUoH79+uzbt89o+QMHDtC6dWucnZ2xt7enadOm2eZERUXRrVs3qlSpgr29PR4eHgwfPpy7d+8azYuOjqZLly64urpia2tLxYoV6dixI7du3aKg7Dl4FCuNFQGN6hXYNoQorKy1Wrp3CESrtaLpq964V66gdCSz+NWtRW2PqjiUsKdzm6aKXh3ztEJzWCYkJITJkyfzyiuvMGDAAOrVq8e3337Ld999x7hx49iyZQuffvopjo6OjB8/npiYGC5evIijoyPbt2+nQ4cONG/enODgYGxtbVm4cCG7du1i3759NGzYEICIiAjOnj1LvXr1cHZ2Jjo6munTp1O+fHn279+flaVWrVo4OTnx4YcfUr58ea5fv86OHTuYNGmSWWfhP/p8SYH9OQkhircZ44LNmlfoyj0sLIz3338fgJSUFMqXL8/Dhw85f/481apVA2D37t0EBQURERHB22+/Tc2aNXFxcWHfvn1ZJzLS09OpU6cO7u7ubN261eQ209PTOXjwIM2aNePo0aP4+Phw8+ZNypYty8aNG+nUqdNzvRcpdyFEQTG33AvdHart2rXL+trW1hZ3d3f0en1WscPjT36PiYkhOjqaP//8k1GjRpGRkUFGRkbWvBYtWrB8+fKs7xMTE5kxYwZr1qwhJiaGlJSUrNf++OMPfHx8eOmll3B3d+ejjz4iLi6OZs2aPfNNRub+4YPhWPsX/1nDa/W96Nii8TNtRwghclLoyr1MGeML/3U6HXZ2dtnGAJKTk4mLiwNg6NChOV5KlJSUhL29Pf369WPbtm2EhITg6+uLo6MjMTExdO7cmaQkw23QGo2GnTt38tlnn/Hpp58SHx+fdZnSuHHjzDqm9jx77gd+P8WB308983JCiOKlyO65P6uXXjKcYQ8JCaF9+/Ym59ja2pKcnMyGDRuYOHGi0V2hT59MBahevTrLly8nMzOT06dPs2zZMj7++GNcXFwYMGBAwbwRIYTIR0W+3GvVqoW7uzsnT55k0qRJOc5LSUkhPT0dGxsbo/Fly5bluIxGo6FOnTqEhoayaNEiTp48aVYmc/9njdgWybHT0Xw4qAdOjiXNWkYIIcxR5Mtdo9GwaNEi2rdvT6dOnXj33XcpV64c8fHxHDlyhLS0NGbNmoWzszONGzdm9uzZlC9fHjc3N8LDwzl06JDR+k6cOMGIESPo1q0bNWrUAGDt2rUkJSXRunXrfMt9K+EeR06d57X6XlLsQoh8V+TLHaBly5YcOHCAqVOnMnjwYO7fv0+5cuXw9fVl4MCBWfO+//57hg0bxqhRo9BqtXTo0IE1a9ZkPV8dwNXVlWrVqjFv3jxiY2OxsbGhdu3ahIeHG53sfVG379zDyaGkXNcuhCgQheZSyOIoIyPDrGdQCCHEs5JyF0IIFZLdRiGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUNVavCEAAAA9SURBVCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUCEpdyGEUKH/Bwto8HKsi5r6AAAAAElFTkSuQmCC\n", "text/plain": [ - "
" - ], - "image/png": "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\n" + "
" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "-------------------------------\n" ] }, { - "output_type": "execute_result", "data": { + "image/png": "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\n", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, + "execution_count": 15, "metadata": {}, - "execution_count": 17 + "output_type": "execute_result" } + ], + "source": [ + "# execute function to build a qiskit gate with the risk model\n", + "#rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", + "\n", + "rm.measure_all()\n", + "display(rm.draw(output='mpl'))\n", + "print(\"-------------------------------\")\n", + "\n", + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(rm, backend,shots=100000)\n", + "result=job.result()\n", + "counts=job.result().get_counts()\n", + "plot_histogram(counts,figsize=(16,8))" ] }, { "cell_type": "code", - "source": [ - "## evaluate classically\n", - "modelProbabilities(nodes,edges,probsNodes,probsEdges)" - ], + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "xX6Xw84P9-lM", - "outputId": "ee81da7e-0e86-4285-b5f6-77a6d1b4fcf0" + "outputId": "3980a420-6068-4271-ef19-7656402bdd4e" }, - "execution_count": null, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ - "([0.81, 0.08999999999999998, 0.072, 0.027999999999999987], 1.0)" + "([1, 1, 1, 1], 4)" ] }, + "execution_count": 16, "metadata": {}, - "execution_count": 18 + "output_type": "execute_result" } + ], + "source": [ + "## evaluate classically\n", + "modelProbabilities(nodes,edges,probsNodes,probsEdges)" ] }, { "cell_type": "code", - "source": [ - "## building the graph from adjacency matrix for visual representation\n", - "G = nx.Graph()\n", - "G = nx.from_numpy_array(mat)\n", - "nx.draw(G, with_labels=True, alpha=0.8, node_size=500)" - ], + "execution_count": null, "metadata": { - "id": "crnI_6km9-oB", "colab": { "base_uri": "https://localhost:8080/", "height": 319 }, - "outputId": "66316016-d470-4bbb-8f04-237c880ef4ba" + "id": "crnI_6km9-oB", + "outputId": "8a807df0-6664-4bb8-ea29-d947ede2aad4" }, - "execution_count": 19, "outputs": [ { - "output_type": "display_data", "data": { + "image/png": "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\n", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" } + ], + "source": [ + "## building the graph from adjacency matrix for visual representation\n", + "G = nx.Graph()\n", + "G = nx.from_numpy_array(mat)\n", + "nx.draw(G, with_labels=True, alpha=0.8, node_size=500)" ] }, { "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "nIUFoxxp9-qm" + }, + "outputs": [], "source": [ "## use Oracle to build QAE and evaluate probabaility for state 'STATELIST'\n", "name=\"test\"\n", @@ -472,117 +412,109 @@ "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=True) \n", "ora = brmoracle(\"ora\",rm,len(nodes),0,STATELIST)\n", "QAE=qae(QAEqubits,len(nodes),len(nodes),rm,ora)\n" - ], - "metadata": { - "id": "nIUFoxxp9-qm" - }, - "execution_count": 20, - "outputs": [] + ] }, { "cell_type": "code", - "source": [ - "## execution with local quantum simulator (qasm simulator)" - ], + "execution_count": null, "metadata": { "id": "a_YVRnVN9-td" }, - "execution_count": 21, - "outputs": [] + "outputs": [], + "source": [ + "## execution with local quantum simulator (qasm simulator)" + ] }, { "cell_type": "code", - "source": [ - "backend = Aer.get_backend('qasm_simulator')\n", - "job = execute(QAE, backend,shots=Nshots)\n", - "result=job.result()\n", - "counts=job.result().get_counts()\n", - "plot_histogram(counts,figsize=(16,8))" - ], + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 511 }, "id": "9S0RLSI2_PEM", - "outputId": "7b59a152-9a65-4978-f7ce-6bbc45482925" + "outputId": "142535fb-ea75-4e7f-a852-fcf2b6ebca26" }, - "execution_count": 22, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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\n", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, + "execution_count": 20, "metadata": {}, - "execution_count": 22 + "output_type": "execute_result" } + ], + "source": [ + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(QAE, backend,shots=Nshots)\n", + "result=job.result()\n", + "counts=job.result().get_counts()\n", + "plot_histogram(counts,figsize=(16,8))" ] }, { "cell_type": "markdown", - "source": [ - "## Larger Example" - ], "metadata": { "id": "SzuW3MS6N6sm" - } + }, + "source": [ + "## Larger Example" + ] }, { "cell_type": "code", - "source": [ - "## large example\n", - "\n", - "nodes=['0','1','2','3','4','5'] # risk items defition\n", - "edges=[('0','1'),('0','2'),('1','2'),('1','3'),('1','4'),('2','3'),('2','4'),('2','5'),('3','4'),('3','5'),('4','5')] # risk items correlations\n", - "\n", - "probsNodes={'0':0.1,'1':0.2,'2':0.2,'3':0.3,'4':0.1,'5':0.1} # intrinsic probs\n", - "probsEdges={('0','1'):0.2, ('0','2'):0.3, ('1','2'):0.2, ('1','3'):0.3, ('1','4'):0.2, ('2','3'):0.3, ('2','4'):0.2, ('2','5'):0.3, ('3','4'):0.2, ('3','5'):0.5} # transition probs\n", - "\n", - "print(\"Number of risk items = \", len(nodes))\n", - "print(\"Number of correlations = \", len(edges))" - ], + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "7VnztBVp_PHR", - "outputId": "a40abddc-ed2a-4ab6-c3bf-5011dbc385af" + "outputId": "176a4eab-ce69-4aa1-bfd9-1cd786644476" }, - "execution_count": 24, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Number of risk items = 6\n", - "Number of correlations = 11\n" + "Number of correlations = 12\n" ] } + ], + "source": [ + "## large example\n", + "\n", + "nodes=['0','1','2','3','4','5'] # risk items defition\n", + "edges=[('0','1'),('0','2'),('1','2'),('1','3'),('1','4'),('2','3'),('2','4'),('2','5'),('3','4'),('3','5'),('4','5'),('5','1')] # risk items correlations\n", + "\n", + "probsNodes={'0':0.1,'1':0.2,'2':0.2,'3':0.3,'4':0.1,'5':0.1} # intrinsic probs\n", + "probsEdges={('0','1'):0.2, ('0','2'):0.3, ('1','2'):0.2, ('1','3'):0.3, ('1','4'):0.2, ('2','3'):0.3, \n", + " ('2','4'):0.2, ('2','5'):0.3, ('3','4'):0.2, ('3','5'):0.5, ('4','5'):0.4, ('5','1'):0.4} # transition probs\n", + "\n", + "print(\"Number of risk items = \", len(nodes))\n", + "print(\"Number of correlations = \", len(edges))" ] }, { "cell_type": "code", - "source": [ - "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", - "rm.draw(output='mpl')" - ], + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 997 + "height": 1000 }, "id": "RaIqTyBd_PKg", - "outputId": "e1388e08-8ba3-467c-d7f5-16a8bef87170" + "outputId": "026ab563-af32-4df4-edd6-8ead15b78a5a" }, - "execution_count": 25, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "NOTE: Item 2 is triggered by more than one other RI!\n", "ITEM:\n", @@ -603,135 +535,130 @@ "NOTE: Item 5 is triggered by more than one other RI!\n", "ITEM:\n", "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", "ITEM:\n" ] }, { - "output_type": "execute_result", "data": { + "image/png": "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\n", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, + "execution_count": 26, "metadata": {}, - "execution_count": 25 + "output_type": "execute_result" } + ], + "source": [ + "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", + "rm.draw(output='mpl')" ] }, { "cell_type": "code", - "source": [ - "# execute function to build a qiskit gate with the risk model\n", - "#rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", - "\n", - "rm.measure_all()\n", - "display(rm.draw(output='mpl'))\n", - "print(\"-------------------------------\")\n", - "\n", - "backend = Aer.get_backend('qasm_simulator')\n", - "job = execute(rm, backend,shots=100000)\n", - "result=job.result()\n", - "counts=job.result().get_counts()\n", - "plot_histogram(counts,figsize=(16,8))" - ], + "execution_count": null, "metadata": { - "id": "v_6D2LoE991Y", "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, - "outputId": "1fa7b6cf-e8a3-4d0a-e5e5-7e5ade5f68e6" + "id": "v_6D2LoE991Y", + "outputId": "5927c35c-19ac-4665-9f2a-d0fdd1cbd997" }, - "execution_count": 26, "outputs": [ { - "output_type": "display_data", "data": { + "image/png": "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\n", "text/plain": [ - "
" - ], - "image/png": "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\n" + "
" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "-------------------------------\n" ] }, { - "output_type": "execute_result", "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJkAAAJrCAYAAABDQEIDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdf5TV9X3v+9dH5kq0SAMYUWYwiPyooEImw0FSIi5XvdzaFVaaGLWrp8lp09g0Nj1Jmpp7Vhqv6U17TJpam1qv51rbGNrG3tiTYE+OVK8tUlIKGbihKq2QgBFoxQRs1GAgTD73D0YOEByY8xkGRx+PtWZl7++P2e+dD6zFevrd311qrQEAAACAFqec7AEAAAAAGPlEJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQrONkD3CinHnmmXXKlCknewwAAACAV4x169Z9u9b6uqPte8VGpilTpqS3t/dkjwEAAADwilFK+eZL7fNxOQAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoNmwR6ZSyvtKKVtLKd8rpawrpbz5OM9bWErZX0p59ETPCAAAAMDgDGtkKqVck+T3k/x2kjck+fsk95dSzj3GeeOSfC7JQyd8SAAAAAAGbbivZPpQks/WWu+stf5TrfX9Sf41yS8f47y7ktydZPWJHhAAAACAwRu2yFRKOTXJG5M8cMSuB5K8aYDz3pdkYpJPnLjpAAAAAGjRMYyvdWaSUUl2HrF9Z5KfONoJpZSLkvwfSS6ptfaVUgZ8gVLKdUmuS5JJkyZlxYoVSZKpU6fmjDPOyIYNG5IkEyZMyOzZs7Ny5cokSUdHRxYuXJj169fn2WefTZL09PRk586d2bZtW5Jk+vTpGT16dB599MAtoc4666zMmDEjq1atSpKMHj06CxYsSG9vb55//vkkyfz587N9+/bs2LEjSTJz5syMGjUqGzduTJKcffbZOe+887J69YELtE477bTMnz8/a9asyQsvvJAkWbBgQbZu3ZqnnnoqSTJr1qz09fXl8ccfT5J0dnamq6sra9asSZKMGTMmPT09Wb16dfbu3ZskWbhwYTZt2pSnn346SXLhhRdm79692bx5c5Jk8uTJmThxYnp7e5MkY8eOTXd3d1atWpX9+/cnSS699NI89thj2bVrV5Jkzpw5ee6557Jly5YkyZQpUzJ+/PisX78+STJu3LjMmTMnDz/8cGqtKaVk0aJF2bBhQ5555pkkSXd3d3bv3p0nnnjCOlkn62SdrJN1sk7WyTpZJ+tknayTdbJOI2CdBlJqrQMeMFRKKZOS7EiyqNa68pDtNyb52VrrzCOOH53k/0vyn2utS/u33ZTkqlrrhcd6vZ6envriHyYAAAAA2pVS1tVae462bzivZPp2kr4c+OjboSYmeeoox5+T5IIkf1JK+ZP+backKaWU/UmurLUe+dE7AAAAAE6CYbsnU611X5J1Sa44YtcVOfAtc0fakeSiJHMP+bkjydf7Hx/tHAAAAABOguG8kilJbkmytJSyNslXkrw3yaQciEcppXwuSWqt76y1fj/Jo4eeXEp5OsneWuth2wEAAAA4uYY1MtVa/6KUMiHJb+TAx+EezYGPvX2z/5Bzh3MeAAAAAIbGsN34e7i58TcAAADA0Broxt/Ddk8mAAAAAF65RCYAAAAAmolMAAAAADQTmQAAAABoJjIBAAAA0ExkAgAAAKCZyAQAAABAM5EJAAAAgGYiEwAAAADNRCYAgGG2fPnyzJw5M9OmTcvNN9/8Q/vvuOOOXHTRRZk7d24WLlyYjRs3Htz3j//4j1mwYEFmz56diy66KN/73veSJB/96EczefLkjBkzZtjeBwDAoUqt9WTPcEL09PTU3t7ekz0GAMBh+vr6MmPGjDz44IPp6urKvHnz8vnPfz6zZs06eMyzzz6bsWPHJknuu+++3H777Vm+fHn279+f7u7uLF26NHPmzMmuXbvy2te+NqNGjco//MM/5PWvf32mT5+e559//mS9PQDgFa6Usq7W2nO0fa5kAgAYRmvXrs20adMyderUnHrqqbn22muzbNmyw455MTAlyXe/+92UUpIkDzzwQC6++OLMmTMnSTJhwoSMGjUqSXLJJZfknHPOGaZ3AQDww0QmAIBhtGPHjkyePPng866uruzYseOHjvvDP/zDnH/++bnhhhvymc98JkmyadOmlFKyePHidHd351Of+tSwzQ0AcCwiEwDAy9D111+fb3zjG/nkJz+ZT3ziE0mS/fv3Z9WqVfmzP/uzrFq1Kl/84hfz0EMPneRJAQAOEJkAAIZRZ2dntm3bdvD59u3b09nZ+ZLHX3vttfnSl76U5MBVT5deemnOPPPMnH766bnyyiuzfv36Ez4zAMDxEJkAAIbRvHnzsnnz5mzdujX79u3LPffckyVLlhx2zObNmw8+/vKXv5zp06cnSRYvXpxHHnkke/bsyf79+/Pwww8fdsNwAICTSWQCABhGHR0due2227J48eJccMEFufrqqzN79uzceOONue+++5Ikt912W2bPnp25c+fmlltuyd13350kGTduXD70oQ9l3rx5mTt3brq7u/NTP/VTSZIbbrghXV1d2bNnT7q6unLTTTedrLcIALxKlVrryZ7hhOjp6am9vb0newwAAACAV4xSyrpaa8/R9rmSCQAAAIBmIhMAAAAAzUQmAAAAAJqJTAAAAAA0E5kAAAAAaCYyAQAAANBMZAIAAACgmcgEAAAAQDORCQAAAIBmIhMAAAAAzUQmAAAAAJqJTAAAAAA0E5kAAAAAaCYyAQAAANBMZAIAAACgmcgEAAAAQDORCQAAAIBmIhMAAAAAzUQmAAAAAJqJTAAAAAA0E5kAAAAAaCYyAQAAANBMZAIAAACgWcfJHgAAgMO959aB99/5geGZAwBgMFzJBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoNmwR6ZSyvtKKVtLKd8rpawrpbx5gGMXlVL+vpSyq5TyQinln0spHx7OeQEAAAA4to7hfLFSyjVJfj/J+5Ks6v/f+0sps2qtTx7llOeTfCbJI0n2JPnxJP+llLKn1nr7MI0NAAAAwDEM95VMH0ry2VrrnbXWf6q1vj/Jvyb55aMdXGtdV2u9p9b6WK11a631T5P8dZKXvPoJAAAAgOE3bJGplHJqkjcmeeCIXQ8kedNx/o439B/78NBOBwAAAECL4fy43JlJRiXZecT2nUl+YqATSynbk7wuB+b9eK31jpc47rok1yXJpEmTsmLFiiTJ1KlTc8YZZ2TDhg1JkgkTJmT27NlZuXJlkqSjoyMLFy7M+vXr8+yzzyZJenp6snPnzmzbti1JMn369IwePTqPPvpokuSss87KjBkzsmrVqiTJ6NGjs2DBgvT29ub5559PksyfPz/bt2/Pjh07kiQzZ87MqFGjsnHjxiTJ2WefnfPOOy+rV69Okpx22mmZP39+1qxZkxdeeCFJsmDBgmzdujVPPfVUkmTWrFnp6+vL448/niTp7OxMV1dX1qxZkyQZM2ZMenp6snr16uzduzdJsnDhwmzatClPP/10kuTCCy/M3r17s3nz5iTJ5MmTM3HixPT29iZJxo4dm+7u7qxatSr79+9Pklx66aV57LHHsmvXriTJnDlz8txzz2XLli1JkilTpmT8+PFZv359kmTcuHGZM2dOHn744dRaU0rJokWLsmHDhjzzzDNJku7u7uzevTtPPPGEdbJO1sk6WSfrZJ0OW6fLMpAVK1ZYp5fFOvn7ZJ2sk3WyTtbp1bdOAym11gEPGCqllElJdiRZVGtdecj2G5P8bK115gDnnpdkTJJLknwyyX+stS4d6PV6enrqi3+YAABGkvfcOvD+Oz8wPHMAAByplLKu1tpztH3DeSXTt5P0JZl4xPaJSZ4a6MRa69b+h4+UUiYmuSnJgJEJAAAAgOEzbPdkqrXuS7IuyRVH7Loiyd8P4ledkmT0UM0FAAAAQLvhvJIpSW5JsrSUsjbJV5K8N8mkJHckSSnlc0lSa31n//P3J9ma5PH+8y9N8uEktw/v2AAAAAAMZFgjU631L0opE5L8RpJzkjya5Mpa6zf7Dzn3iFNG5cA9mKYk2Z/kG0n+9/RHKQAAAABeHob7SqbUWm/PS1yJVGu97IjntyY5xq0vAQAAADjZhu2eTAAAAAC8colMAAAAADQTmQAAAABoJjIBAAAA0ExkAgAAAKCZyAQAAABAM5EJAAAAgGYiEwAAAADNRCYAAAAAmolMAAAAADQTmQAAAABoJjIBAAAA0ExkAgAAAKCZyAQAAABAM5EJAAAAgGYiEwAAAADNRCYAAAAAmolMAAAAADQTmQAAAABoJjIBAAAA0ExkAgAAAKCZyAQAAABAM5EJAAAAgGYiEwAAAADNRCYAAAAAmolMAAAAADQTmQAAAABoJjIBAAAA0ExkAgAAAKCZyAQAAABAM5EJAAAAgGYiEwAAAADNRCYAAAAAmolMAAAAADQTmQAAAABoJjIBAAAA0ExkAgAAAKCZyAQAAABAM5EJAAAAgGYiEwAAAADNRCYAAAAAmolMAAAAADQTmQAAAABoJjIBAAAA0ExkAgAAAKCZyAQAAABAM5EJAAAAgGYiEwAAAADNRCYAAAAAmolMAAAAADQTmQAAAABoJjIBAAAA0ExkAgAAAKCZyAQAAABAM5EJAAAAgGYiEwAAAADNRCYAAAAAmolMAAAAADQbVGQqpZxSSjnlkOdnl1J+sZTy40M/GgAAAAAjxWCvZPpykvcnSSllTJLeJL+TZEUp5Z1DPBsAAAAAI8RgI1NPkr/pf/y2JM8mOSvJe5J8eAjnAgAAAGAEGWxkGpPk3/of/69Jvlhr/X4OhKfzh3IwAAAAAEaOwUamJ5P8eCnlR5IsTvJg//bxSfYM5WAAAAAAjBwdgzz+liRLkzyf5JtJVvZvvzTJI0M4FwAAAAAjyKAiU631v5RS1iWZnOTBWusP+nd9I8nHhno4AAAAAEaGwV7JlFprbw58q9yh2748ZBMBAAAAMOIM9p5MKaW8r5TyWCllTyllav+2j5RSrh768QAAAAAYCQYVmUopH0jyG0n+7yTlkF3/kuRXhnAuAAAAAEaQwV7J9N4k76m1/n6S/YdsX59k9pBNBQAAAMCIMtjI9Pokjx5l+/eTnNY+DgAAAAAj0WAj05Yk3UfZfmWSje3jAAAAADASDfbb5T6d5LZSyuk5cE+mBaWUn0tyQ5JfGOrhAAAAABgZBhWZaq1/UkrpSPLbSU5PsjQHbvr9q7XWvzgB8wEAAAAwAgz2SqbUWu9Mcmcp5cwkp9Ranx76sQAAAAAYSQYdmV5Ua/32UA4CAAAAwMh1zMhUSvnHJItqrc+UUh5JUl/q2FrrxUM5HAAAAAAjw/FcyfSXSfYe8vglIxMAAAAAr07HjEy11o8f8vimEzoNAAAAACPSKYM5uJTyN6WU1x5l+9hSyt8M3VgAAAAAjCSDikxJLkty6lG2vybJm5unAQAAAGBEOq5vlyuldB/y9OJSyu5Dno9KsjjJjqEcDAAAAICR47giU5LeHLjhd03ywFH2v5Dk/UM1FAAAAAAjy/FGpvOSlCRbkvy7JN86ZN++JE/XWvuGeDYAAAAARojjiky11m/2PxzsPZwAAAAAeBU4ZmQqpbwtyV/VWr/f//gl1Vr/65BNBgAAAMCIcTxXMt2b5OwkT/c/fik1B24CDgAAAMCrzDEjU631lKM9BgAAAIAXiUYAAAAANDveezIdF/dkAgAAAHh1Ot57Mh0P92QCAAAAeJUa1D2ZAAAAAOBoBCQAAAAAmh3vPZn+qtb6/WPdn8k9mQAAAABenY73nkxnJ3k6A9+fyT2ZAAAAAF6lBnVPJvdnAgAAAOBoRCMAAAAAmg06MpVSukspnyul9Pb/LC2ldJ+I4QAAAAAYGQYVmUopP5vkq0nOSfLf+38mJllbSvn3Qz8eAAAAACPB8dz4+1C/leRjtdbfPnRjKeU/JflEkj8dqsEAAAAAGDkG+3G51yX5f46y/QtJzmofBwAAAICRaLCR6W+TXHaU7Zclebh1GAAAAABGpmN+XK6U8rZDnt6f5D+XUnqS/EP/tkuSvC3JTUM+HQAAAAAjwvHck+neo2y7rv/nUH+Q5PbmiQAAAAAYcY4ZmWqtg/1IHQAAAACvMgISAAAAAM2O5+NyhymljEvyk0nOTXLqoftqrb85RHMBAAAAMIIMKjKVUi5J8uUke5O8LsmOJOf0P38iicgEAAAA8Co02I/L/U6SP0vSmeR7SS7PgSuaepN8cmhHAwAAAGCkGGxkujjJbbXWmqQvyeha684kH0ly0xDPBgAAAMAIMdjItO+QxzuTvL7/8fNJJg3JRAAAAACMOIO98ff6JPOSbEqyIsknSikTk/z7JP84tKMBAAAAMFIM9kqmjyb5l/7Hv5HkW0n+IMm4JNcN4VwAAAAAjCCDupKp1tp7yONvJfnJIZ8IAAAAgBFnsB+XS5KUUs5PckH/04211i1DNxIAAAAAI82gIlMpZUKSu5IsSfKD/7G5/Lckv1Br3TXE8wEAAAAwAgz2nkx/lGRakjcneU3/z6VJzkty5/H8glLK+0opW0sp3yulrCulvHmAY99WSnmglPKtUspzpZQ1pZQlg5wZAAAAgBNssJFpcZL31Fq/Umvd3//zlSS/1L9vQKWUa5L8fpLfTvKGJH+f5P5SyrkvccqiJH+T5Kf6j//vSb44UJgCAAAAYPgN9p5M30ry3aNs35PkeD4q96Ekn621vnjV0/tLKf9bkl9O8p+OPLjW+h+P2PTxUspPJXlrkr877qkBAAAAOKEGG5l+M8mtpZSfq7XuSJJSSmeS3+3f95JKKacmeWOSTx+x64EkbxrEDGckeeYlXuO6JNclyaRJk7JixYokydSpU3PGGWdkw4YNSZIJEyZk9uzZWblyZZKko6MjCxcuzPr16/Pss88mSXp6erJz585s27YtSTJ9+vSMHj06jz76aJLkrLPOyowZM7Jq1aokyejRo7NgwYL09vbm+eefT5LMnz8/27dvz44dO5IkM2fOzKhRo7Jx48Ykydlnn53zzjsvq1evTpKcdtppmT9/ftasWZMXXnghSbJgwYJs3bo1Tz31VJJk1qxZ6evry+OPP54k6ezsTFdXV9asWZMkGTNmTHp6erJ69ers3bs3SbJw4cJs2rQpTz/9dJLkwgsvzN69e7N58+YkyeTJkzNx4sT09h748sCxY8emu7s7q1atyv79+5Mkl156aR577LHs2nWgJc6ZMyfPPfdctmw5cM/3KVOmZPz48Vm/fn2SZNy4cZkzZ04efvjh1FpTSsmiRYuyYcOGPPPMgeXr7u7O7t2788QTT1gn62SdrJN1sk7W6bB1uiwDWbFihXV6WayTv0/WyTpZJ+tknV596zSQUmsd+IBSHkly6EHn5cC9mHb0P+9M8r0kW2utFw/weyb1n7Oo1rrykO03JvnZWuvMAQc5cOz1SW5OcmGt9ZsDHdvT01Nf/MMEADCSvOfWgfff+YHhmQMA4EillHW11p6j7TueK5nuHeJ5/qeUUt6e5HeSXHOswAQAAADA8DpmZKq1fnyIXuvbSfqSTDxi+8QkTw10YinlqiSfS/LOWutfDdE8AAAAAAyRwd6TKUlSSrk8yawc+BjdY7XWFcc6p9a6r5SyLskVSb5wyK4rkvzlAK91dZK7k7yr1vqyuKoKAAAAgMMNKjL13+T7izlwA+9/6d88qZTSm+Sna63/8pInH3BLkqWllLVJvpLkvUkmJbmj//d/Lklqre/sf35tkqVJPpxkZSnl7P7fs6/WunswswMAAABw4pwyyOM/kwMfeZtWa51ca52cZHr/ts8c6+Ra618k+UCS30jytSQLk1x5yD2Wzu3/edF7cyCE3ZrkXw/5+a+DnBsAAACAE2iwH5e7IslltdatL26otW4ppfxqkoeO5xfUWm9PcvtL7LtsoOcAAAAAvDwN9kqm5MB9mI5nGwAAAACvEoONTA8l+YNSyuQXN5RSzs2Bj7Md15VMAAAAALzyDDYy/WqSH0mypZTyzVLKN5N8o3/brw71cAAAAACMDIO9J9OuJP8uyWVJfqx/2z/VWv/foRwKAAAAgJHluCNTKWVUku8kmVNrfTDJgydsKgAAAABGlOP+uFyttS/JN5OceuLGAQAAAGAkGuw9mf7PJDeXUs48EcMAAAAAMDIN9p5MH05yXpIdpZTtSb576M5a68VDNRgAAAAAI8dgI9O9SWqScgJmAQAAAGCEOq7IVEo5PcnvJHlrkv8lyUNJ3l9r/fYJnA0AAACAEeJ478n08ST/IcmXk3w+yU8k+b9O0EwAAAAAjDDH+3G5tyV5d631niQppfxZkq+UUkb1f+scAAAAAK9ix3sl0+Qkf/fik1rr2iT7k0w6EUMBAAAAMLIcb2QalWTfEdv2Z/A3DgcAAADgFeh4I1FJ8qellL2HbHtNkjtLKXte3FBrXTKUwwEAAAAwMhxvZLr7KNv+dCgHAQAAAGDkOq7IVGv9+RM9CAAAAAAj1/HekwkAAAAAXpLIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAAAAANBOZAAAAAGgmMgEAAADQTGQCAAAAoJnIBAAAAEAzkQkAAACAZiITAAAAAM1EJgAAAACaiUwAADCMli9fnpkzZ2batGm5+eabf2j/ypUr093dnY6Ojtx7772H7bv77rszffr0TJ8+PXfffffB7fv27ct1112XGTNm5Md+7Mfyl3/5lyf8fQDAkTpO9gAAAPBq0dfXl+uvvz4PPvhgurq6Mm/evCxZsiSzZs06eMy5556bz372s/n0pz992Lm7d+/Oxz/+8fT29qaUkje+8Y1ZsmRJxo0bl9/6rd/KWWedlU2bNuUHP/hBdu/ePdxvDQBEJgAAGC5r167NtGnTMnXq1CTJtddem2XLlh0WmaZMmZIkOeWUwz908Nd//de54oorMn78+CTJFVdckeXLl+dnfuZn8sd//Mf553/+54PnnXnmmcPwbgDgcD4uBwAAw2THjh2ZPHnyweddXV3ZsWNH07n/9m//liT52Mc+lu7u7rzjHe/Izp07h3ZwADgOIhMAAIxg+/fvz/bt2/OmN70p69evz4IFC/LhD3/4ZI8FwKuQyAQAAMOks7Mz27ZtO/h8+/bt6ezsbDp3woQJOf300/O2t70tSfKOd7wj69evH9rBAeA4iEwAADBM5s2bl82bN2fr1q3Zt29f7rnnnixZsuS4zl28eHEeeOCBPPPMM3nmmWfywAMPZPHixSml5C1veUtWrFiRJHnooYcOu8cTAAwXkQkAAIZJR0dHbrvttixevDgXXHBBrr766syePTs33nhj7rvvviTJV7/61XR1deULX/hCfumXfimzZ89OkowfPz4f+9jHMm/evMybNy833njjwZuAf/KTn8xNN92Uiy++OEuXLs3v/u7vnrT3CMCrV6m1nuwZToienp7a29t7sscAABi099w68P47PzA8cwAAHKmUsq7W2nO0fa5kAu3VZ6AAACAASURBVAAAAKCZyAQAAABAM5EJAAAAgGYiEwAAAADNRCYAAAAAmolMAAAAADQTmQAAAABo1nGyBwAAAP6H99w68P47PzA8cwDAYLmSCQAAAIBmIhMAAAAAzUQmAAAAAJoNe2QqpbyvlLK1lPK9Usq6UsqbBzj2nFLKn5dS/rmU0ldK+ewwjgoAAADAcRrWyFRKuSbJ7yf57SRvSPL3Se4vpZz7EqeMTvLtJDcnWTMsQwIAcEItX748M2fOzLRp03LzzTf/0P69e/fmmmuuybRp0zJ//vw88cQTSZJ9+/bl53/+53PRRRdlzpw5WbFixcFzPvrRj2by5MkZM2bMML0LAOBIw30l04eSfLbWemet9Z9qre9P8q9JfvloB9dan6i1/mqt9bNJdg/jnAAAnAB9fX25/vrrc//992fjxo35/Oc/n40bNx52zF133ZVx48bl61//ej74wQ/mIx/5SJLkzjvvTJI88sgjefDBB/Nrv/Zr+cEPfpAkectb3pK1a9cO75sBAA4zbJGplHJqkjcmeeCIXQ8kedNwzQEAwMmzdu3aTJs2LVOnTs2pp56aa6+9NsuWLTvsmGXLluVd73pXkuSqq67KQw89lFprNm7cmMsvvzxJctZZZ+W1r31tent7kySXXHJJzjnnnOF9MwDAYTqG8bXOTDIqyc4jtu9M8hND8QKllOuSXJckkyZNOngJ9dSpU3PGGWdkw4YNSZIJEyZk9uzZWblyZZKko6MjCxcuzPr16/Pss88mSXp6erJz585s27YtSTJ9+vSMHj06jz76aJID/7CZMWNGVq1alSQZPXp0FixYkN7e3jz//PNJkvnz52f79u3ZsWNHkmTmzJkZNWrUwf9ad/bZZ+e8887L6tWrkySnnXZa5s+fnzVr1uSFF15IkixYsCBbt27NU089lSSZNWtW+vr68vjjjydJOjs709XVlTVrDnyacMyYMenp6cnq1auzd+/eJMnChQuzadOmPP3000mSCy+8MHv37s3mzZuTJJMnT87EiRMP/iNt7Nix6e7uzqpVq7J///4kyaWXXprHHnssu3btSpLMmTMnzz33XLZs2ZIkmTJlSsaPH5/169cnScaNG5c5c+bk4YcfTq01pZQsWrQoGzZsyDPPPJMk6e7uzu7duw9eAm+drJN1sk7WyTpZpxfX6bIMZMWKFSN2nR5++OGcddZZefLJJ7Nly5Y899xz2b59e5599tmD6/SNb3wjkydPPrhOo0ePzq5duzJ+/PjcddddmTRpUl73utflq1/9au6///7s2bPn4Dr19fVlxYoVI/rv07HWv7e319+nl8E6vRz+Plkn62SdrNPJWKeBlFrrgAcMlVLKpCQ7kiyqta48ZPuNSX621jrzGOf/tyTfrrX+h+N5vZ6envriHyYAgJHkPbcOvP/ODwzPHCfCvffem+XLl+eP/uiPkiRLly7NmjVrcttttx085sILL8zy5cvT1dWVJDn//POzZs2avPa1r82v//qv52//9m/z+te/Pt///vdz3XXX5a1vfevBc8eMGXPwH9gj1St5/QEY+Uop62qtPUfbN5xXMn07SV+SiUdsn5jkqR8+HACAV5rOzs6D/2U2SbZv357Ozs6jHtPV1ZX9+/fnO9/5TiZMmJBSSn7v937v4HFvetObMmPGjGGbHQAY2LDdk6nWui/JuiRXHLHrihz4ljkAAF7h5s2bl82bN2fr1q3Zt29f7rnnnixZsuSwY5YsWZK77747yYErny6//PKUUrJnz55897vfTZI8+OCD6ejoyKxZs4b9PQAARzecVzIlyS1JlpZS1ib5SpL3JpmU5I4kKaV8Lklqre988YRSytz+h2OT/KD/+b5a6+FfQwIAwMteR0dHbrvttixevDh9fX35hV/4hcyePTs33nhjenp6smTJkrz73e/Oz/3cz2XatGkZP3587rnnniTJ008/ncWLF+eUU05JZ2dnli5devD33nDDDfnzP//z7NmzJ11dXfnFX/zF3HTTTSfpXQLAq9Ow3ZPp4AuW8r4kNyQ5J8mjST744j2aSikrkqTWetkhxx9twG/WWqcM9DruyQQAjFTuyfPqZv0BeDl7udyTKUlSa709ye0vse+yo2wrJ3omAAAAANoM2z2ZAAAAAHjlEpkAAAAAaCYyAQAAANBMZAIAAACgmcgEAAAAQLNh/3Y5AAAYyHtuHXj/nR8YnjkAgMFxJRMAAAAAzUQmAAAAAJqJTAAAAAA0E5kAAAAAaCYyAQAAANBMZAIAAACgmcgEAAAAQDORCQAAAIBmIhMAAAAAzUQmAAAAAJqJTAAAAAA0E5kAAAAAaCYyAQAAANBMZAIAAACgmcgEAAAAQDORCQAAAIBmIhMAAAAAzUQmAAAAAJqJTAAAAAA0E5kAAAAAaCYyAQAAANBMZAIAAACgmcgEAAAAQDORCQAAAIBmIhMAAAAAzUQmAAAAAJqJTAAAAAA0E5kAAAAAaCYyAQAAANBMZAIAAACgmcgEAAAAQDORCQAAAIBmIhMAAAAAzUQmAAAAAJqJTAAAAAA0E5ngJFq+fHlmzpyZadOm5eabb/6h/Xv37s0111yTadOmZf78+XniiSeSJE888UROO+20zJ07N3Pnzs173/veg+d89KMfzeTJkzNmzJjhehsAAAAgMsHJ0tfXl+uvvz73339/Nm7cmM9//vPZuHHjYcfcddddGTduXL7+9a/ngx/8YD7ykY8c3Hf++efna1/7Wr72ta/ljjvuOLj9LW95S9auXTts7wMAAAASkQlOmrVr12batGmZOnVqTj311Fx77bVZtmzZYccsW7Ys73rXu5IkV111VR566KHUWgf8vZdccknOOeecEzY3AAAAHI3IBCfJjh07Mnny5IPPu7q6smPHjpc8pqOjIz/6oz+aXbt2JUm2bt2aN7zhDVm0aFH+7u/+bvgGBwAAgKPoONkDAIN3zjnn5Mknn8yECROybt26vPWtb81jjz2WsWPHnuzRAAAAeJVyJROcJJ2dndm2bdvB59u3b09nZ+dLHrN///585zvfyYQJEzJ69OhMmDAhSfLGN74x559/fjZt2jR8wwMAAMARRCY4SebNm5fNmzdn69at2bdvX+65554sWbLksGOWLFmSu+++O0ly77335vLLL08pJd/61rfS19eXJNmyZUs2b96cqVOnDnqG/9lvt3vRk08+mTFjxuTTn/50kuTxxx8/+I13c+fOzdixY3PrrbcOei4AAABGHpEJTpKOjo7cdtttWbx4cS644IJcffXVmT17dm688cbcd999SZJ3v/vd2bVrV6ZNm5ZbbrnlYAhauXJlLr744sydOzdXXXVV7rjjjowfPz5JcsMNN6Srqyt79uxJV1dXbrrppqO+fuu32yXJhz70ofzkT/7kweczZ848+I1369aty+mnn56f/umfHqr/ywAAAHgZc08mOImuvPLKXHnllYdt+83f/M2Dj1/zmtfkC1/4wg+d9/a3vz1vf/vbj/o7P/WpT+VTn/rUMV/70G+3S3Lw2+1mzZp18Jhly5YdjFRXXXVVfuVXfiW11pRS8qUvfSnnnXdefuRHfuSov/+hhx7K+eefn/+fvTMPj6rIHvZ7s0DYdxASIIQwEAIYWUREURABoxM/EEF0UIcwrqjozxFmZFxwXMYFN3DGBUUZISiOBhyJIOKgskQUEIjIIigJiICA7JBwvz/O7aa7c7uzdHe6O33e5+kHcm+dW3Wq7lJ16tSptm3bllkWRVEURVEURVEUJfJRTyZFiVL82d3u8OHD/OMf/+DBBx/0ev2cnBxGjRoVnMIriqIofhHo5dIAycnJdO3alYyMDHr27BlsFRRFURRFCUPUyKQoSoV56KGHuPvuu6lbt67t+ZMnTzJv3jyuvvrqKi6ZoiiKUhbBWC7tYMmSJaxZs4ZVq1YFVQdFURRFUcITXS6nKFFKRXa3S0pKctvdbuXKlcydO5f77ruPAwcOEBMTQ0JCAuPGjQNgwYIFdO/enRYtWlSpToqiKErZBHu5tKIoiqIo0Yt6MilKlOLP7naff/4527dvZ/v27YwfP56//vWvTgMTwOzZs3WpnKIoSpgSrOXShmEwaNAgevTowSuvvBJcJRRFURRFCUvUk0lRwpw/Pef7/KvjK3dd193tSkpKGDNmjHN3u549e5KVlUV2djajR48mNTWVxo0bk5OTU+Z1jxw5wqJFi3j55ZcrVzBFURQlbPG1XPqLL74gMTGRX375hUsvvZROnTrRr1+/EJRSURRFUZRQoUYmRYliKru7nSuO5RQO6tSpw759+wJWRkVRFCWwBGu5tOMazZs3Z+jQoeTn56uRSVEURVGiDF0upyiKoiiKEkUEY7n0kSNHOHToECAerQsXLqRLly5VrpuiKIqiKKFFPZkURVEURVGiiGAsl969ezdDhw4FoLi4mGuvvZYhQ4ZUhTqKoiiKooQRamRSFEVRFEWJMgK9XDolJYW1a9cGtIyKoiiKokQeamRSFMUnwQo8riiKoiiKEm3k5eVx1113UVJSwtixY5k4caLb+RMnTnD99dfz9ddf06RJE+bMmUNycjL5+fncdNNNAJimyUMPPeT0Hnz22Wd57bXXMAyDrl278sYbb5CQkFDluimKooDGZFIURVEURVEURQk6JSUl3H777SxYsICCggJmz55NQUGBW5rp06fTqFEjtmzZwt13382ECRMA6NKlC6tWrWLNmjXk5eVx8803U1xcTFFRES+88AKrVq1i/fr1lJSUlGs3YEVRlGChRiZFURRFURRFUZQgk5+fT2pqKikpKdSoUYNrrrmG3NxctzS5ubnccMMNAAwfPpzFixdjmia1a9cmLk4WoRw/fhzDMJwyxcXFHDt2jOLiYo4ePUqrVq2qTilFURQPdLmcoiiKoiiK4oYulVaUwFNUVETr1q2dfyclJbFy5UqvaeLi4mjQoAH79u2jadOmrFy5kjFjxvDjjz8yc+ZM4uLiSExM5N5776VNmzbUqlWLQYMGMWjQoCrVS1EUxRX1ZFIURVEURVEURQlzevfuzYYNG/jqq694/PHHOX78OPv37yc3N5dt27axc+dOjhw5wr///e9QF1VRlChGjUyKoiiKoiiKoihBJjExkR07djj/LiwsJDEx0Wua4uJiDh48SJMmTdzSpKWlUbduXdavX88nn3xCu3btaNasGfHx8QwbNoxly5YFXxlFURQvqJFJURRFURRFURQlyPTq1YvNmzezbds2Tp48SU5ODllZWW5psrKyePPNNwGYO3cuAwYMwDAMtm3bRnFxMQA//vgjGzduJDk5mTZt2rBixQqOHj2KaZosXryYtLS0KtdNURTFgcZkUhRFURRFURRFCTJxcXFMnTqVwYMHU1JSwpgxY0hPT+eBBx6gZ8+eZGVlkZ2dzejRo0lNTaVx48bOneK++OILnnjiCeLj44mJieGll16iadOmNG3alOHDh9O9e3fi4uI455xzuOmmm0KsqaIo0YwamRRFURRFURRFUaqAzMxMMjMz3Y5NnjzZ+f+EhATefffdUnKjR49m9OjRttd8+OGHefjhhwNbUEVRlEqiy+UURVEURVEURVEURVEUv1Ejk6IoiqIoiqIoiqIoiuI3amRSFEVRFEVRFEVRFEVR/EZjMimKoiiKoiiKooQJf3rO9/lXx1dNORRFUSqDejIpiqIoiqIoiqIoiqIofqNGJkVRFEVRFEVRFEVRFMVv1MikKIqiKIqiKEqVkJeXR8eOHUlNTeWJJ54odf7EiROMHDmS1NRUevfuzfbt2wFYtGgRPXr0oGvXrvTo0YNPP/0UgEOHDpGRkeH8NW3alPHjdT2ZoihKqNCYTIqiKIqiKIqiBJ2SkhJuv/12Fi1aRFJSEr169SIrK4vOnTs700yfPp1GjRqxZcsWcnJymDBhAnPmzKFp06bMnz+fVq1asX79egYPHkxRURH16tVjzZo1TvkePXowbNiwUKinKIqioJ5MiqIoiqIoiqJUAfn5+aSmppKSkkKNGjW45ppryM3NdUuTm5vLDTfcAMDw4cNZvHgxpmlyzjnn0KpVKwDS09M5duwYJ06ccJPdtGkTv/zyCxdeeGHVKKQoiqKUQo1MiqIoiqIoiqIEnaKiIlq3bu38OykpiaKiIq9p4uLiaNCgAfv27XNL895779G9e3dq1qzpdjwnJ4eRI0diGEaQNFAURVHKQpfLKYqiKIqiKIoSEWzYsIEJEyawcOHCUudycnKYOXNmCEqlKIqiOFBPJkVRFEVRFEVRgk5iYiI7duxw/l1YWEhiYqLXNMXFxRw8eJAmTZo40w8dOpS33nqL9u3bu8mtXbuW4uJievToEWQtFEVRFF+okUlRFEVRFEVRlKDTq1cvNm/ezLZt2zh58iQ5OTlkZWW5pcnKyuLNN98EYO7cuQwYMADDMDhw4ACXX345TzzxBH379i117dmzZzNq1Kgq0UNRFEXxjhqZFEVRFEVRFEUJOnFxcUydOpXBgweTlpbGiBEjSE9P54EHHmDevHkAZGdns2/fPlJTU5kyZQpPPPEEAFOnTmXLli1MnjyZjIwMMjIy+OWXX5zXfuedd9TIpCiKEgZoTCZFURRFUZQIIy8vj7vuuouSkhLGjh3LxIkT3c6fOHGC66+/nq+//pomTZowZ84ckpOTWbRoERMnTuTkyZPUqFGDp556igEDBgDw9ddfc+ONN3Ls2DFqtsqkz9DnNYCyEnAyMzPJzMx0OzZ58mTn/xMSEnj33XdLyU2aNIlJkyZ5ve4PP/wQuEIqiqIolUY9mRRFURRFUSKI06dLuP3221mwYAEFBQXMnj2bgoICtzTTp0+nUaNGbNmyhbvvvpsJEyYA0LRpU+bPn8+6det48803GT16tFPm1ltv5dVXX2Xz5s38tmczhRvzqlQvRVEURVEiHzUyKYqiKIqiRBB7fsonNTWVlJQUatSowTXXXENubq5bmtzcXG644QYAhg8fzuLFizFNk3POOYdWrVoBkJ6ezrFjxzhx4gS7du3it99+47zzzsMwDDr0up4f131Q5bopiqIoihLZqJFJURRFUaKQvLw8OnbsSGpqqjPmiSsnTpxg5MiRpKam0rt3b7Zv3w7Avn376N+/P3Xr1mXcuHFuMrNnz6Zr165069aNIUOGsHfv3qpQJeo4eqCI1q1bO/9OSkqiqKjILU1R0Zk0cXFxNGjQgH379rmlee+99+jevTs1a9akqKiIpKQk57k6DZI4ctD9mopSVfzpOd8/RVEUJXxRI5OiKIqiRBklJZVfbpWQkMAjjzzC008/7Za+uLiYu+66iyVLlvDtt9/SrVs3pk6dWmU6KRVjw4YNTJgwgZdffjnURVEURVEUpRqhRiZFURRFiTLy8yu/3KpOnTpccMEFJCQkuKU3TRPTNDly5AimafLbb785l2UpgaV2w0R27Njh/LuwsJDExES3NImJZ9IUFxdz8OBBmjRp4kw/dOhQ3nrrLdq3b+9MX1hY6JQ/crCQOg3cr6koiqIoilIWamRSFEVRlCjDdSkVVH65lSvx8fH885//pGvXrrRq1YqCggKys7ODo0CU06x1LzZv3sy2bds4efIkOTk5ZGVluaXJysrizTffBGDu3LkMGDAAwzA4cOAAl19+OU888QR9+/Z1pm/ZsiX169dnxYoVmKbJ5q/eom2XK6tUL0VRFEVRIh81MimKoiiK4jenTp3in//8J6tXr2bnzp1069aNxx9/PNTFqpbExMYxdepUBg8eTFpaGiNGjCA9PZ0HHniAefPmAZCdnc2+fftITU1lypQpzrhbU6dOZcuWLUyePJmMjAwyMjL45ZdfAHjppZcYO3Ysqamp1G/anqS0y0KmY1kEI6bYxRdfTMeOHUvVi6IoiqIo5Scu1AVQFEVRFKVqcV1KBb6XWyUlJZVabmXHmjVrAJzLr0aMGGE7+FcCQ2ZmJpmZmW7HJk+e7Px/QkIC7777bim5SZMmMWnSJNtr9uzZk/Xr1wPhHVz59GmJKbZo0SKSkpLo1asXWVlZdO7c2ZnGNaZYTk4OEyZMYM6cOc6YYuvXr3fq6srbb79Nz549q1IdRVEURalWqCeToiiKokQZvXpVfrmVNxITEykoKGDPnj0ALFq0iLS0tOApoUQte34KfEwxRVEURVECg3oyKYqiKEqUERd3ZrlVSUkJY8aMcS636tmzJ1lZWWRnZzN69GhSU1Np3LgxOTk5Tvnk5GR+++03Tp48yQcffMDChQvp3LkzDz74IP369SM+Pp62bdsyY8aM0CkZ5ZTlifTq+KopRzA4eqCIZI+YYitXrnRL4y2mWNOmTX1e+49//COxsbFcddVVTJo0yadhVVEURVGU0qgnk6IoISPQMTWOHj3K5ZdfTqdOnUhPT2fixIlVpYqiRByZmZls2rSJrVu3cv/99wOy3Mrh0eRYbrVlyxby8/NJSUlxym7fvp1ff/2Vw4cPU1hY6FymdMstt/Ddd9/x7bffMn/+fJ/L6xQl3Hj77bdZt24dn3/+OZ9//jkzZ84MdZEUJeBo3yu0aP0r0YAamRRFCQklJRJTY8GCBRQUFDB79mwKCgrc0rjG1Lj77ruZMGECgDOmxtNPP13quvfeey8bN25k9erVfPnllyxYsKBK9FEURVGqhtoNyx9TDLCNKbZu3Trefvttt4Ge4xr16tXj6quv5pFHHqlQ4PD777+f1q1bU7du3YDrrCiBQPteoUXrX4kW1MikKEpIyM8PfEyN2rVr079/fwBq1KhB9+7dKSwsrBqFFKWa8afnfP8UJVQ0a+1fTLGSkhJmzpzJFVdc4Rzoffvtt+zduxeQnRJfeuklWrZsWaGB3u9//3vy8/ODqbqi+IX2vUKL1r8SLaiRSVGUkOAaLwMkpkZRUZHXNK4xNcrDgQMHmD9/PpdcckngCq0oiqKEnJjYMzHF0tLSGDFihDOm2Lx58wDIzs5m3759pKamMmXKFLdlKUlJSezfv5/333+flJQUBgwYwPvvv8/gwYPp1q0bGRkZ/Prrrzz22GNA+QOHn3feebRs2bJqKkFRKoH2vUKL1r8SLWjgb0VRqh3FxcWMGjWKO++80y2OjKIoilI9yMzMJDMz0+3Y5MmTnf93xBSz48UXXyQvL4/XXnsNgJkzZ7Jy5Uq+/vprZ5ouXbqQnJwMVCxwuKJEK9r3Ci1a/0o4oZ5MiqKEBNd4GVC5mBreuOmmm+jQoQPjx/vePqmywRcBHn/8cVJTU+nYsSMff/yx8/izzz5Leno6Xbp0YdSoURw/frzM8oaKaNdfURRFUaKJcOh7RTNa/0q0oEYmRVFCQq9e/sXU8MakSZM4ePAgzz3nO2iMP8EXCwoKyMnJYcOGDeTl5XHbbbdRUlJCUVERL7zwAqtWrWL9+vWUlJS4bfseTkS7/oqiVG98xRN764vgDfQUJZwJdd8r2tH6V6IFNTIpilJpdnxXeU+Yp556imPHjtGxY0eSk5OdMTXuu+8+zj//fDp16sQLL7zApk2bbGNqJCcnc8899zBjxgySkpIoKCigsLCQRx99lIKCArp3705GRoZzOYQn/gRfzM3N5ZprrqFmzZq0a9eO1NRUZ7DX4uJijh07RnFxMUePHqVVq1b+VnNQiHb9FUWJXvwNHK4okUpcnH/xzPzte0Hgvai///57MjIynL/69euHrbElHOpfUaoCjcmkKBGMGHnuoqSkhLFjxzJx4kS38ydOnOD666/n66+/pkmTJsyZM8cZY+Lxxx9n+vTpxMbG8sILLzB48GBAggaOHTuW9evXYxgGHQa/TovkPqXyPn26hGXv3c6a/EUkJSXRq1cvsrKy6Ny5szONqydMTk4OEyZMYM6cOU5PmO3bt7Nz504GDhzoLPvu3bsZM2YMY8eO5eTJkxw9epSGDRuWyt+10+GKaZrlqju74IsrV670msY1JkdRURHnnXeem2xRURF9+vTh3nvvpU2bNtSqVYtBgwYxaNCgcpWnqol2/cOBvLw87roruM/v66+/Tp8+pZ9fRfGXYN+/P+836DfK/vvjL66Bw0tKShgzZoxzoNezZ0+ysrLIzs5m9OjRpKam0rhxYzevzOTkZH777TdOnjzJBx98wMKFC+ncuTP33Xcfs2bN4ujRoyQlJTF27FgeeuihgJdfUfzBn3hm/va9HF7UixZVvu+4YcMGZ99x06ZNdOzYkTVr1jivn5iYyNChQ8tVnlAQyvpXlKpCPZminGDEZDlw4ADDhw+nU6dOpKWlsXz58qpQJepwGHkCudwJ4K677mLIkCFs3LiRtWvX0rBFmm3+e37Kp37TwHrCHDx4kKVLl5KdnQ3IVqx2BiYH/ty///nPf3jnnXdK3b/Jycl07dqVjIwMtm7d6jVvO/bv309ubi7btm1j586dHDlyhH//+98VukYkE+36V4RgLFeE0s9vWpr986so/nD6dPDv32F/9v79CQSZmZls2rSJrVu3cv/99wMy0HN4NDkGelu2bCE/P98tkO727duZNWsWiYmJJCQkOD0QnnzySQoLCzl9+jRbt27lu+++q1D/yfX788EzPYOmOwSn/+da/p49g1t+JTIJlhe1g8WLF9O+fXvatm1bZTopilIa9WSKYoIxmxAbG+vsJM6dO9fpiaIEHlcjD+D8ULu2X25urnMWdfjw4YwbN87nh7pz584sXbqUGTNmAGLkqVmrhm3+Rw8UUadhYD1hatWqRbNmzfjjH//I2rVr6dGjB8Udnie+Zp1S+Z8+XcK7j1Xekyo/P5/evXvzyiuvMHDgQMaMGeOMybFkyRKaNm3K4MGD2bFjB0lJSW4xObwFbvzkk09o164dzZo1A2DYsGEsW7aMP/zhD74bMwRUJPhkddQ/1Lh2tCF4z2+NGvbPr6L4w56fgn//xsbVIDYuPO/fYPWf4Mz3509BXO1TFeUPZ4LhhZecnEy9evWIjY0lLi6OVatWVbVa/o03PgAAIABJREFUAaWs++/VSsaWDoYXtSs5OTmMGjWqcoULI4JV/4pSVagnUxQTjNmEinqiKJXHzsjj+bH19aH2/MgXFRWxbds2p5HnnHPOYezYsZw6caRqFELi+XzzzTfceuutrF69mjp16rB2cekZVvDfk+rGG290eiqlpKQwY8aMcsfkyMrKIicnh/nz55OSksKnn37KkiVLaNOmDStWrODo0aOYpsnChQtZsWKF15ngVq1aUaNGDVq1auU2k1xSUsI555zDZZddVqGZ5OPHj3Puuedy9tlnk56ezoMPPui1rv0JPunQ/8SJE2zbto3Nmzdz7rnnltJ/8eLFPj1pAj2TXhH9Q423Z9Bbmso+v0eOVN3zq0QPRw8E//5dmlO13x9PfAUOH/p/wfXGKA/+vD/HjRvHrl27uOyyy1iyZAnXXHMN7733ntv785lnnglq+UNFsLxIQQxsa9asiXgDU6Ry8uRJ5s2bx9VXXx3qoihK1KNGpihGBzmKJxUx8tRumMiRA5XbncebJ0xSUhJJSUn07t0bkI7tvsJvbPP318iWnJzsjMmxcuVKevbsSXp6OgcOHKB379706NEDwDb4Ynp6OsOHD2fYsGGYpsl7773HnDlzqFevHsOHD6d79+507dqVTZs20aNHD9uO6uzZs0lISGDRokUkJCS4dXSff/550tLS2LFjR4U6ujVr1uTTTz9l7dq1rFmzhry8PFasWGFbf/4En0xPT2fEiBF07tyZIUOGMG3aNGJjY+ndu7eb/qdPn+amm26yzT8YHf2K6A/Vz8hl9/za6RUoIr3+Ir381Q3P+ze+hvfvT6gJhpENwDAMBg0aRI8ePdi47BWv+fu7XPGjjz5i5MiRzvdnq1at+Pnnn93en7t27WLPnj2VLv8rr3gvfyCo7PObn59PbGwsgwYNomvXrnTv3p3c3Fy35/e+++7j5MmTQPUysIUDFfGihvL1HR0sWLCA7t2706JFiyBrofiDfnujAzUyRTiBjklz+PBh+vfvT+fOnUlPT2ffvn0VKk+kD3J27Njhpv/zzz8ftLL7S6iNPM1a9+K3PYH1hDnrrLNo3bo133//PSBr6xue1blU3oHCEZPj6quv5qqrrgJgw4YNbN26lQULFvDKK69wxx132MbkGDhwIAMGDGDbtm1kZWU5Z7IffvhhNm7cyPr162nUqBFjxowBSndU+/btS4cOHbjooovo0KED559/Prm5uRQWFvLf//6XsWPHsnv37grNJBuGQd26dQE4deoUp06d8rkbkj8xSe6//362bt3K999/z2WXXeY87qr/zJkzqVmzpm3ewfCkrIj+oTZyBaOjbff8fvON/fPrL8GIyVNRI6E/hLr9I53aDYN//7Y72/v3p7ryxRdf8M0338h9+eU0dm1dapvOdbliZd6fffv2JTY21vn+3Lp1a6n3p2maFd5Nz7X806ZNY+lS+/L7iz/vnxUrVrB3717n8/vf//6XwsJCt+e3bdu2rF69mhUrVtga2Bx9z+XLlzN16lTA3cA2bdq0oPY9/dnZN9T5L168mE8//ZSUlBQ+/PBDcnJy6NWrl1v+9erVq1Df0cHs2bPLtVQumscOEFr9w+HbG+3tX1WokSmC8fdBdcSkcTyoP/30E61ateKZZ56hoKCAFStW8Ntvvzk7CXadRMeDOnv2bBYvXlyqk5iVlcX06dMrFDhyzJgxNG/enC5dugRV/5ycHJ599llOnTrFFVdcwWOPPUZcXJyb/i+++CKXXXZZUMrvL6E28sTExnH+VYH1hAF48cUXue666+jWrRtr1qwhY+BfbfMPhpHNIQPQvHlzhg4d6nWW0l9PwPj4eOe5pKQk4uLiKCoqYvz48Tz55JPExMRw/PjxCs+El5SUkJGRQfPmzbn00kudz2Ko8fyoB8KT0q6j76p///79mTJlSrmXi+Tm5ro9v2UZuZYsWcKQIUPYtWsX48aNKzVIO3HiBJMmTSp3RzsrK8st/0A8v64xVgKJv4Ncf+vP3/dvIIycoSx/qGnWOvDLbT3v36LNwZ1k8IdgGNkcMiDfn7Zdh7LnJ/vvj7+eVB06dHCWISkpia1bt5KYmOj2/jzrrLOcsZUC/f30F3/eP1999RXt27d3TlK0aNGC3bt3uz2/pml6naQ4ffq0s+85bNgwvvzySwoKCtwMbI899hjHjx8v9yDZs+85bdo09v9cUCpvyT/wm75UZf7vvvsuc+fOxTRNhg4dyvDhw0lPT3f2DVasWMGaNWvYtm1bhfqOR44cYdGiRQwbNszLXSMEw8hhV3+e1wwXQq1/dZxgjKT2r0rUyBRhuA7Uxo0b59eDaheT5rrrrqN79+4A1KtXj/bt2zNr1iygdCdx9uzZ3Hbbbbzyyiu0aNGCZcuW8euvv7p1EqdMmULz5s0rtK79xhtvJC8vr8y68PdFNWLECMaPH88nn3zCxRdfzBtvvMH+/fvd9K9duzaxsbEBKX9ZlvOKEmojD0DrzoH3hMnIyGDVqlV8++23fPDBB9Ss3cg272AY2Y4cOcKhQ4cA6bAsXLiQTzZ3sY3J8a8P4fP15W+v8rB9+3aaN2/uXKpXGWJjY1mzZg2FhYXk5+ezfr0UsrL3n6+4JOUNTGv3UXcdpFQGbx19V/3nz5+PaZrlXi5SVFTk9vz6GqQlJiY68x8xYoRTN9dBWvPmzUlNTa1QR7ukpIS//OUvQGCe37/+VZ7fQL9//B3k+lt//r5//TVyVnX5w42Y2MAvtwX3+/fXIt/fn1ASDCOb5/en6PuFNDorOMbGlJQUZ/lLSkr48ssvycrKcnt/xsfH8+yzz1a6/AsXLnQaS8Pp/XPy5ElOnDjhTFezZk2nx63j+d20aRMZGRn07t27lIFt+fLlzr6nY6IiNzfXzcBWq1YtZ97lGSS3bNnSre+ZlpbGkYPu+jgIxs6+VZ3/lVdeybZt2xgwYAADBw6kZcuWvPrqq2RlZVGvXj3S09O59957K9R3rFOnDvv27aNBgwZuZfG894Jh5LCrP8f9GOh7v6KEm/7BCNUC3idYw03/aEJ3l4sgPHcD6dChA7169XKer8wODY5O4s8//8zll1/u7CT27NmTbt26sX//flJSUkhNTaVx48bk5OQA0kns06cPM2fO5KabbuKll15izZo15ObmOjuJJ0+e5Oeff2bmzJlA+XaX6dOnD/369XOb8XXguRtIamqqXztUNGnSxPmiadOmDc2bN3fbHWf79u1s3ryZKVOm+F3+8uzkUhlad84k75VMt2OTJ092/t9h5LHj/vvvdxqGXHEYeRwEc4cbf3A1spWUlDBmzBi3+zcrK4vs7GxGjx5te/86BjlxcXHOQc7u3bsZOnQoIDO31157LdvrDLHNvyKeVHa7s/30009OQ0thYSEpKSkcPnyYefPm8dFHH3H8+HGOHj1KdnY2H3/8cYXiEgA0bNiQ/v37k5eXR1paWlDuv/Jit5Papk2b/NrdzltH36FTw4YNOX36NM2bNwdKP792y0UAr+8fT7Zu3erMPzY2lr59+5Kbm8tf/vIX1qxZw4EDB0hJSeH666+3zd/R0b7yyisZPHgwAwcOBODNN99k+/btTJ8+PSDPLwTv/eMPgag/f96/N954Y8SUP1zJzMwkMzN4359w/faAu5EtWN+f1p2vpXWa9+/Pju8q//7cuXOns/yFhYWMHj26VPlHjhzJvHnz/Pp+DhkyJOzeP82bN2fp0qVs27aNxMREfvjhB6677jrgzCTNU089xbPPPsv69etZv369m4EtMzPTuVR+8+bNXHvttSxbtoxDhw5Rr149jhw5ws6dO52D3IrujrZ9+3ZWr15N/z72XsjB2Nk3HPP/99e9eWeDbRGA8u2uZnfv1axZM6i72znK37t375Df++Gov7/fXm84nt0DBw4wdOhQ1q9fb9v3DbX+oe57VSVqZIogPAdqffv2ZfPmzX5d09FJzM7Ods4ITJ48mcOHD3PRRRfx/PPPe3U9vfTSSykpKeG1114DYO/evaxcudKtk9ilSxfS09OBij+orgTjRbV//363F03jxo2dZTh8+DBXXXUVzZo1o1OnTn6XvzzblVdXgrkNa6CNbCkpKaxdu9btmLfyu3pSJSYmkpOT4/T6c+CYye7Tp0+pmeBRo0Zx6NAhli5dyqZNm/j555+ZNWuW83n57LPPGDduHO3atQNKzyRfe+213HPPPezcudM5k7xnzx7i4+Np2LAhx44dY9GiRUyYMCHk95/d7NOOHTucM+mVqT+7jv7SpUs5cOCAU/9du3bRs2dPwH65iGPNvmO5iOcSJV+DtHXr1jl1KiwspHfv3m7vgIYNGxIfH8/GjRtt86/I+8NfgtH+/g5yq7L+gmHkjKT2DxXVfQvuQBvZPL8/vuqvWeteLJlX+fen4/vx8ccfc8kll/DSSy+xZ88e7rnnHuf787PPPuPRRx/liiuuqFT5HYTb+6d169ZkZmY6DYRNmjThvPPOczOw3XHHHcyYMYOLL76YlJQUNwPb+eefz3vvvceyZcuYNm0ae/fu5dixY1xwwQWAGNjq1atH//79K6yXo+/53HPPseCn+pWun8pS3fK3u/e++uorateu7fe17XAtf/369d0mwxz5V2XfKxz19/fbW5EJ1kOHDoWd/tEy9gNdLhdReA7UUlNT2b17t/PvQMUEOHXqFFdddRXXXXcdw4YN87pMJhjLhbxh595YkRcVlNZ/7969brKNGsmyLFf969cPzEe2PO6hwSIQy52U0vi7XHHkyJEcP36cgQMHcvz4cVv51q1bV2i5ya5du+jfvz/dunWjV69eXHrppVxxxRUhvf+8ERMT49dyG0dH36F/TEwMR44ccdO/bt26Tg8hT7wtF3HF13KXL7/8kpKSEqeRq3379hw7dowDBw4AcOzYMQ4fPkxqaqpf9RSIZzcY7e/vcqGqqj+w198wjIgpv6J4Eozlip7fj6N1LyV3yxXV8v2zevVq1q1bxyeffEJJSQnnnnsud9xxB/369QMkJlPjxo2ZMWNGqeVad955J3369HEu1yosLCQtLY21a9eydu1aNmzYQEZGht99b28EKx5lpORfEezuvZMnTwYlnppd+UPd9wpH/f399tot1d2zZ4/bt3fRokV06tQpLPUPdd+7KlFPpggmJSWFgwcP+j2T5eoJYZom2dnZpKWlcc899/jM39/lQmU95K4EwxNi+vTptGvXzvmi6tevH61atXLT/+OPPw5I+ZXQEUmeVJ7yF198sde87eS7devG6tWry1P0KsXb8+KPJ8Cdd97Jr7/+6gya/Pjjj3P22Wc7Z5wBBg8eXKnlIo53ja/lLkOGDGHmzJnO2ew1a9ZQt25d+vfvT0lJCadPn6Zly5Z07NgRqNg2zJGAv8uFQl1/rkbOSCy/Ev4E25Mr0J5Unt+PcJ6ECsZyxV27dnHDDTc4n9+arUeQu+UKcj3q4XRJL5av8t+LrLJ9b3+9qCM9f39p3rw533zzTcSW319Crb+/397yPLsjRozgiiuuYO7cuWGnfzShRqYIwrNjumvXLoYOHRrQB/WLL75g5syZdO3alYyMDADOOvcxWnfOLFWeYHxoKoK/L6rrr7+eRx55hEsuuYTnnnuOv/3tb9x7773cf//9Tv337t3LI488wkcffeRX+XVQoYSSUN9/vXr1KtMgHIxrVnS5CMggbfv27Tz//PM+B2nTpk1j0aJF5OXlkZiYyMSJE5k1a5bb1rXTpk0L2vuvIgSr/f0Z5FZl/QXDyBlJ7a8ooSQc3z/+GNmCEQ+yIn3vaM+/Itjde61btw64kcOu/I899ljI+17hqn+wn91w1z9aMEzTrNoMDeM24M9AS2ADMN40zc99pL8ImAKkAzuBJ03T/FdZ+fTs2dP0DH4a6RQXF/O73/2OxYsXk5iYSK9evdxiuAQLX7NZOwo+4ofPxjsf1Pvvv9/tQT1+/DijR49m9erVzgfV4Xb86KOP8vrrrxMXF8dzzz3njAk1atQoPvvsM/bu3UuLFi14+OGH6dy5Mw899JCb1wLg3IWpsnz00UeMHx/88t9www2Vbjt/Z0NVPrrlwb93R6Bm4+2etfIQ6vdPygUP0/G87LDMv7x1X9n2D7YnRri/f8vSf+jvglv+GnVa0GNI5ds/1O8elY9ueQfh+v4pC80/8vMP1bgpEPlHu/6af2RgGMbXpmn2tDtXpZ5MhmGMBJ4HbgO+sP5dYBhGZ9M0f7JJ3w74CHgd+ANwAfCSYRh7TNN8r+pKHh7Exdm7B4eSYCwXmj17dqljxcXFlfaE8P2izmTTpuCXHwi7tlOih3B4d9jNXPlLVbx/fL0/Qp1/eQlV+5fdSQ787mRV+f4Nxu5qruUP5+VKilJewvf9U73zV0Lf94nk/ANx/0Zy/oEg1PmHmqpeLncPMMM0zVetv+8wDGMIcCtg55JyC7DTNM07rL+/MwyjN3AvEHVGJqjcQK06fOhC+aAGqv6CMchWlPKi919oCJf3byS2fyDrLhT6h0vbK0qoicT3T6QT6vdPqPN3UNl7r7r0/TX/6G7/UFJlRibDMGoAPYCnPU4tBM73ItbHOu/Kx8ANhmHEm6Z5KrClDE/C5UVdWaL9QY309lMim1Dff9GefyiJZt1B9VeUUKLPnxJKQn3/RXv+0Y7WfxXGZDIMoxVQBFxkmuZSl+MPANeZptnRRmYT8G/TNCe7HOsH/A9oZZrmLo/0NwE3WX92BL4PuCLhQVNgr8qrvMqrvMpHlXwkl13lVV7lVV7lVV7lVV7lqw9tTdNsZnvGNM0q+QGtABPo53H8AeB7LzKbgAc8jvWzrtOyqsoebj9glcqrvMqrvMpHl3wkl13lVV7lVV7lVV7lVV7lo+MXQ9WxFygBWngcbwH87EXmZy/pi6me1kBFURRFURRFURRFUZSIpMqMTKZpngS+Bi71OHUpsMyL2HIv6VeZURKPSVEURVEURVEURVEUJRKoSk8mgCnAjYZhjDUMI80wjOeRZXT/AjAM4y3DMN5ySf8vINEwjOes9GOBGykdPDzaeEXlVV7lVV7lo04+ksuu8iqv8iqv8iqv8iqv8lFAlQX+dmZoGLcB9wEtgfXA3aYVCNwwjM8ATNO82CX9RcCzQDqwE/iHaZr/qtJCK4qiKIqiKIqiKIqiKD6pciOToiiKoiiKoiiKoiiKUv2o6uVyiqIoiqIoiqIoiqIoSjVEjUyKoiiKoiiKoiiKoiiK36iRSVEChGEYRqjLECpCrXsY5B/V79IwqP9Q5x/S9lf9ozt/RVEURVGUcEI7RooSIEwrwJlhGDGhHvRVNaHWPQzyP13R/KvTPRIG9R/q/EPa/qp/aPJ3GJcc+VfkuoE2TIX6fRKt+RtCqI2cIav7UOsfqvwddR5q/V3LEqq8tf1V/yjOP+rGexVBA39HOIZhNAaaAHUAE9hkmuaxKsy/DbJTYEvgEPCVaZq/RVH+6UAKkIrsfrjINM1fqyjvqNU91PkbhhEH9Aa6AWnAJuAd0zR/qcS1DDhjKKiAnLZ/dLd/1OofBvnXAS4G+gJdgW+A903TXON63fJc01f+5b2Gh0yMq9GrqrE6/GZ5da+ofoHKPxB5e14jUnQPVP6h1j8M8o83TfNUZa4bjOc0Cus/1PmHtP1V/5DnX6sqx9uRiBqZIhjDMEYBNwP9gL3ARmAb8DmwwDTNIl8Pkr8PmWEYNwM3AecAPwJ7gKPAUqTDv97XA28YRnPgoGmaJyI0//uAG4F2QAEQD9RF6v9V0zS/8Ja/YRidgV+B3R4fifK+ICNWd0veX/1Dnf8jwEjEuLsOaG+V5XPgGdM0PyxDvh+wD9hommZJJfLX9o/u9o92/UOd/3NAJmLcLQB6Ica+74AngX/7uo5hGMOAX4B80zRPuhwv9yDBSt8XaIBMNP0ILPfsdAcLwzBqAIOBs6zft0BeZd8pkZS/IZN7/w+551oBXwA5lRlwGEaljJyhrvtQ6x/q/JOBEUAXK/+FiJF5cyXy9/rM++g/avtHd/tHu/6hzv9s4FrgAqA+8CnwIfL9PVzOfGNd+x7VFtM09ReBP6AhMrB8DugADAQeBT5BOt1vAc19yNcHlgMTgHYe5wyX/7cBErzkfwD4q/X/XsAtwHRgGbAASC8j/2+BF4D+QGPXfF3SdQMahGn+h4E/IQO83yGDjr8hL7wVwKU+8t4K5AB/RGbC69uku8iuDSNZ9wDqH+r8jyEf+VighXWN0cB/kEFndhn577ba6WHgcqC1Tbr/ByRp+4dl/qFu/2jXP9T5HwcuBAygNmLkuRB4DSgE/g7E+Mj/N+RZnQHcis3zarVNey/XqA38E9iPGJfXAquAPGA80MpK560MsUjnPNZbPfn6IQbN2ch7aDti3Psemeh6GuhkpSv1XrGOxwM9gUY252xlApV/APKuhwwo9iCDuw+BXcAJYA5wbhnyNYErgWSbc7btFWZ1H2r9Q51/fWQyZxvwNvBvqx2Kgf8Bl5QhnwDcDpyt7a/tr/pHZP6rgTXAY8ik0hqgBOlXjyjrGp55esu3PM9juP9CXgD9VbLh4E5kFtTzeC1gFLDFehBKDR6sdOOA0y4P5+dIp7axS5pExGjV1kb+NmCVzfEawCDEgFWE1dm1SXe79VCut8qxAXgQ6A7UtdK0RDrOvwvD/P8ErLY5Hgf0AN5FZrk72aS51Tr3OXAE+AF4GRiGzMgnILNTW4Cu1Un3AOkf6vyvt+ouzuO4ASQjH50TQG8v+f8J8WLIQQbEG6wy/x/ildgYaI50Inpq+4dd/qFu/2jXP9T5j0SW59W1OVcfeT6PA4O95P9HxOtoCmIU+gpYDExFvt2tgabAKaCvl2v82Sr7IOvvCxHj0mzga8TYFW8na6W/2WrfycC52BsZ6wJ9sDFEAfdZbXCO9XcXYKhV918C84CzfOR/i9UGryAz0r8DanukaQD83k4Pf/IPQN4TEKNeW+vvVohH6ThkRnuZo1xe8r8Nef7esa41AA9jLmK0HAPUCMO6D7X+4ZD/KqCh9Xdt5H3xe2TAvwm40kf+tyPP9iLgX8j7zHOit4WVj90Er7Z/6PMPZfur/qF//vLxeDaQia7XkGfrbh/510aMU/1szsVSDQxLbjqFugD6q2TDSSfzK6wZWGRgEOdyPg3YDGR6kX8TeAnp0A4BZiEzI4eRDvcgxJB13It8NvKhS7f+jsXFGgs0Qqy713qRfw2YhsyqdASeQQbGpxBr9E3AQ8DhMM0/y6pfb4OAeGQQd7vNuZeAf7mU09FpOIrE9piMDDj2VzfdA6R/qPM/H5lFudzH8zkf+JuXc88hz5+BDOTGWOk3Ix/PV5AZqV+0/cMy/1C3f7TrH+r806z8r/OR/0zgWS/nnkQ6+LWQ73YW4lX4GfJNn4cYnYp8XH8lcKfN8YaIG/+vwGwf8l8hxrWtyCTTcuAuS7cEK80fgU+8yC8FJtocr4N4VW+2dLA1dCEDoRVWfR9FvK+fAi5D+iQxVv7fBDr/AOSdBzzq5bnrhrxDvwHqeZFfYpXtPWRAtNq6H29DvFJrWflvD9O6D7X+oc7/fWCazXEDMc6/bV23hRf5j5FnfApiFPjK0ukpZKDcyMr/N23/sMw/1O0f7fqHOv+3gJkuf8dxJvRQPGJA+hFI8SLvcPBYZZXlr3hM5iEOHk/jYfyNxF/IC6C/SjYctEVmoB/2OO5qaFoB/J+NbAKytGKSyzHDurFvRCy8h60H4REv+TdFrOmv4bKkAPeldl8C99vI1kBmU+7Dw2qLLN+ZhXSST3vqF0b510cGBf9FBj01bdIstWsf4Cpk1jnW41w6MgDaZuX9UHXSPYD6hzr/WsBcxGPgOmyWnSAf8sdtZA1kGdJNNjLtkdmTJdXx3tf2D1j7R7v+oc4/HjHUFQGTgAyglkeaT4AnvcinA3/Aw0Ue+f5eD7xeRv41ESPW+0Ad65jbDCjilbYa6GAj3xzpG1xl/d3HynM/4tk2z6rXdcBLNvKxwLPIUo3GXsp4AfKOyrA519SSHeFS709Y953Dw24iMlh+IZD5+5u3JTMR8SJr6eV8Z8TIf4HNuSbIs5tt/Z0E3I0MdrYgBoAXkCWXU8Kt7kOtf5jknw3swMP7weM5Xg0MsTnXCHk3jHd5FkchS92/RIzHc5Fv8FPa/mGZf8jaX/UPi/yvRLycz/Y4HmP9Wx8x8l3tRX4+4nE8HjFYLbfSz0W8rM9CjFyn7eQj7RfyAuivkg0nsw13It4HW4B7gSbWuSaIJ9IRvMd0aAx09HIuDolTcRpo46MMwxHXwF8Qb4hzrLzbI264h3zkX5czXlgxlB7wnlOO/K+2HvbK5F/PcW0/8j8fWYN7BBmcDwXORpYf3Ip4hpXKHzHyNbX+H4uLJdw61g6ZXW5b3XQPoP4XIoOgyubfws/82wO5Vht8inwwshCvwL8hHylvMxmxnBkcxlB6gNgeea61/bX9VX/7a/wOMYbsRYxCFc2/vg/9y5N/A2SwV4AMzJ5GvsfXIl6Cu/HSCXbobf1rUNrYlAqcxD5mhmPG9DKko32Xoy490rVD4j7ZxZRqAzyAhycYYjwbhsSqOoG8A2zrADgPGYhOQbwhPQ12ba17s9Q7BGhm3aOlvKyR3fre4oyhO6D5ByjvTsgg7j3gUuS96+pJmozEDLNrv7qIkbdUzDTEWPk48lx7ff+GQd2HWv9Q55+IGGpWIYPC3+HiNYQ8v8ewef6Rd82FwMU25zogXg4LtP21/VX/sM2/IWIoKkLiIJ+Py7I6xBv4ODb9D0s2D8vLGulHDEAmq/5j6bTMKn+pSbJI/IW8APrzswHlgXoF+BkZGGxG3P9+wou7vs014ij9oXoQ+KkcsnWAvyCu96cRC3gB0gF+0A+9HgR2lSNdLWRQ8X1l8/ehf5n5W2mvQwYaJUgAvi3IzNC4Cuocgww6HgT2RJPuldHfkrkemYGoVP64f5wrk/+lyGB3n/Xsbbd9SARfAAAgAElEQVTaYFQl9HcMIB8EftX21/ZX/cuUGQh8EML8z0O8mr62fj9Z7WEbj6kC+R8sI20d4BHEGLUZuB/p3J6FeGq9AHzrQ74JZwxtdobmJ/GyXMZF5k+IkW+3VQeXIQGFrwLeKEO+LmeW5cVSOr7Wg9jEHXM5H4t4ZO5DDO3lzh8xstepbN5Wmkxk9nmPdf/dYuV7EzIjvcKHbLwjT6se7d6/a4Khe3XQ30rzeyv/vYixuyL51yzHvVdW/hlWPpsQz//HkZhuf0GWIn3mS97jOfI0Mj8IrNX21/ZX/b3K9bDy34J4JpU7f6SP47j/vOlfVv4tkeV1+cj3fhbyzX0GGX8v8CHbCZtQB4jx7P8hKxR8TvJG0i/kBdBfJRtOlr10cPk7EZnJfQD4B/LBKRW0zSV9PPaW1ljr92e8uPtZ6WJcH07EDbEL4sp4G2L88hqpv4xzBjIj7C2eVLyl77kex7siAU1v95W/Jd8Km+B4lu4xvvJ3SecZ+K0+4lGQiRdX1rJ0t873w8bSXh10D4D+tZAPzKW4dE6s/EcgHni+6r4WEuD6Ykp3bmKte89r/i7pPD9McdY1u2KzI5vNs+M1uB/iSdFL21/bX/Uvda4h0hEbjstMu5X/QMSby2v+lvyV1jXa4uIF5KK/1/x96B9r5d0UH99d13x8nE/Ax+6QHmlTgBcRA3MJYmDcjXiXeW1Dm7ZzNTbWRmI1/bUcsvHAPYhX42lLbg8yK+tzlyMf90YdJBSAbUwtj/Q1EC/udZXJH3cPtgrlbcmMQpam/ozENduNDBLK1X42utdGDKUPBFv3SNffkhmJLP/ZHaL8M5GlqyuRweWPyIDX1ouyrLZA3s8/4mWpsra/tr/q7yYzENmhNR/xAvIn/5hK5H8+4s30LvLNXY98D332gT10tjOybaho+cP1F/IC6K+CDSad+BnIbO1yxIvg0fK+VDzkl1nyT1E6dkFNbDrC2ETbr2D57aL1224z7EW+L7KDwFbgO6RzPRPoU8787eTfBs73SGe7tTP2u/C4BV72kbedrJ3u3gwEEat7gPS/HHGT3c6ZLVsXAsPLmb+d/MfA0HLKN7M5VsPbvVpO+XLVnba/tr/qzx+QWAs/IjO4JUjskT9ThmHHi3wx0jEdTzkCbAKJ5dHf7p72IV/h3WQQg2JPoIfHdTKAsUjHv1YZ8t0pHVPCQDra9ZGOstdvPWKY8jS0NUNm2LuV1R6+2h3pe1yFTawx63wSMqF2scfxszizbNQ2f0v2Cjxmkl1095m3D90bIAOO5nh5f5b3nsfHBKE/uke6/lb5uiKTmENxj0fYEDGOe83fRf5W6z5t6/rcc8bIXNYErZ3+dZBlOz4N6K75+DjfDO/9X23/KG1/1Z+ayNKyRy0d+nHGI68OEovK67Vd5P+OeOFejCwtrOF6X9rlj7sx1k5/ZwiIyv6suk9AxuV/9uda4fQLeQH0V8EGE9f4eYhb4N+QXYDykSUzz+Nl2/Iy5FcAGy355mXI/x2ZBW6Hx4fIekji8NFh9yXvkqa243o2535CgrSNRZbq/BUxth1ABtDdyii/p/xfrId6P7LOtnMZ8m8ggfLOx9pC00P/WLzv6uBV1iVNveqoe4D034V46V1pXeMPiKv2cWS55iXeZH3Iv2/Jr6OMmX9kQP8C0glr6XHOEVumoY/ye5V3qUNf8tr+0d3+0a7/XuuePR8ZLF0A/BOJIfIL4oHntZNbhvzPwDVlyBcgz9kdeMyUuujfxEf5fckb1s+rvHX8ZqsdCxBj4Q6rTjvZ1Wc55ad6yuN9kNvIy3NfXkNzo3KW09tAyRFvawMSd86xG26pILflkD2E7CJ4fjnLbnfP18RjwFFeecc1yiPrr+7VRP8XrfKvAw4iS0W/AEZXUv4EEs+tXEtrKb3Nua3+Pp5dT/lSXgy+rqHtH/XtH+36z0K+8/nWvyXId+xv+DCK+pAvRjxw/4JHv9VL/mle9PdpVPW8HmUb2RqX95mKhF/IC6C/CjSWdKK34uIRgKyv7okEDtuKxGfyNgvmr/wIxC33V+tBfRCxBp/leNAQS+yb2AQVr6C8Xaf5GmQ5QC2XY/HIgOE664X7H88XRgDlh1vl32iV/2VkF4BunFnjXANZE3xOoGQjXfcAyV9tld/zg1YTGTS+h2zdWspbIkDyw6zyf26Vfx7wMHAJZwwjccgadbv11v7Ka/tHd/tHu/7/DzGKlOrQIffwVKTz3NZL+QMhfxIxyjlc899Clos0ttLEIFuCDwy0vHV+lNWGExFvhKuR7ZLXIcsknsf3UkE7+UeRjvbPSCDzuj7kByBxMMYimwPU9jgfg3y/SwUiL6e8gbwDvMlfh/RRxiBbbfdCYpH8Dxkw5PpoPzvZm11k38faiMSL/BBkOcjfrf97GtljkaUWpbw1yynvmMX2Jl9p3auJ/qOR+CtXIh4YLazrvIsYyb8Buvsof1nyq7DZjc1F3rGj1L+BG/DYHt3Sv46nXhWQdyxV8iav7R/d7R/t+l9vlf9CzngvpSObbBxEJktKBTOvgPxPWN9d7A1MVyP9ly+QnZlb2+hfF+jqowyeRirHBI1dfhXybg7nX8gLoL8KNJZ0Dv/r7Qa0HuTdeFmPHQD515H1vhciM8A/I14QeUhU/nOAG4ETQZJ3fBRtPaUQg9VO4LIgyf8L8cbojVjPlyOeYUuQQKlDkZg4xwMpG+m6B0j+GiSwrq1LqnXv/ADcECT5F5EP5DlI3LFZiAfgcs5sR3ofcCxI8tr+0d3+0a5/JjID7xqH0Bk0Fomj9C1wX5DkpwA5SMd0CGKc+RDp3H+JGGgeBo4GQ966xhLgHx7HaiLLFP6MPE9e4yiVQ35LGfKLEEPZd4ixcAoSE8S5wxUSI+OzIMkvBJ62OV4f8Y77Bngu0LJWuo+Q/spS6759F5gA9MHy+kKCL28Lkry/5Y90/ee7lg93z4Du1r09y0f5/ZXPRSZI3kfeoyuQgNtXYHlRIMvYSoIkr+0f3e0f7fq/A7zk8rdrPMpGyOTFQrx7wPorP9cq86tIP6HQuqev58zKm0yg2It8WUaqGCwjFdXIwGSaphqZIumH7GRzDHk5l/I4QCyjn+Olo+iPPDLL/DjwpMfxy60XyG9IrIuDwMxAy1tpOyEuwtOA1nYPIxJj5O+Blkcszn8FpngcvxCZBf8WCfp2DJgRKNlI1z2A+rdCXFznWy/iUm62yNKhUh0pf+WRD8CdwAsexzOQZykXWXZ2GpgeaHltf21/1Z/6nNk59SLsPZLmAFMDLY98F8cA//Q4noJ4Bz+PPDungVcDLe/yDOXgYSTySPM3pAPvLfaTP/J1kHhWf0D6Ec9Yf3+PTBI9iAwSFwPvBEE+BvF+tH0/WGluQQyJdssaKiVrnatt3TdjkWfnbsTrMx8ZNLyB7Or0mZey+yvvb/kjXX8DWeb7kc097TBODkO8IEst/QqAfG3EGH47EuZhOGIgXYRsJb8E2enxc+DdIMhr+0d3+0e1/tY1JiLBxeNdjtXgjIGqn1X+IYGWRzz0PkV2r2uGfL/uQAyljt18ZyD3s7fy+2WkiuRfyAugvwo2mGxVvB3xBOqNdJ4dD0pbJD6L1zXWlZVHPlRpQE/r7xoe52shs6GnsXHb9FfeJd0o5GP4DmdmQR1xLLohRipf+ldaHnEx7WD93zMwXE0kmNxpXAKyBkI20nUPoP4XIB+KPGRwegmQbJ3r7+3eDYQ8srSsufV/zyVH8ZyZqegZDHltf21/q/z5iEGisvpXSh7pkDnK79l+5dHfL3krXSoy27gc8Yy7AehinRuJeMX60t9fecd30m5XvkFW+X3tSuev/M3I0pZsbDzSgDaIIdE2tpo/8ta5l3CJ/2GV+/fIsr/vkPgYp4HegZa30l9lnZ+M/c64TZAlGaVi0/kpexbwNDDG5VgMYiR/BHmeVntrP3/l/S1/NdG/v3X+DWyW9SBGzL3YLLX2Vx6JkTIZuMXlmIHspjwWGTgux8v7y195bX9tf9WfDMQRIQ+40OZ8TSQMS8DlkZAy/wfc5HE8EdnldxJiKPM29vPbSBXJv5AXQH/lbKgzke/jEYvwVuAU8nKeiswGfwd8GAx5j2sZWJ4QiIeSwxp+A3AomPLIx+kqzsx8b0SsxF8jyz1mB1Pe5nrOoKdI5/1woGVd0sQhca2+tMr+fXnK7q+8j/LHlaf8gZB33DPIsq5ZiNfbt8jsx07r738FS97HveS4j28BjgRDXttf298l/cXIsrOfkFg8X5RV/kDJl9F+ZZa/svIeOnRDPGK/QOJIbERiSmzHt5eOv/K2cRNc2m8MsD9Y8i719bRV5pcRL+AOiJt9TaQTuzMY8ta905Yz8aM8J4nqIztV/hAMeZd0dyI7Cr6LdNQvApoiA4FHgB1Bkq3NmVgenkbi2ojRcnuw5F3K/y3yzq5Q+f2VRwahjvJ7GonLo79f8la6YYg3wKeIJ9wo655KRPqw24Is71jWZTdJ8HQ56t9feW3/6G7/YYghYokf+vsjH+/6rx/6V1a+N/AJ0m/5D/K96gr0QHZZ3hRkece32nOSyAAewvu30y8jVaT/HJWmRACGYSSYpnnc5e9+yAxsT84E1H3PNM2fq0LeOhZjmuZpwzBiEGs1pmlOCrS8dd40XW5YwzCSkYCG6cgguQCYb5rmoSDIxwKnTS8PjGEYBuKJVcc0zQcDJeuSpoFpmgdd/m6DBPPriljDvZY9GPL+lr8i8nb1ZxhGK2SQlIwE/fsB+NQ0zeKqkLdJczMSzHByoOWt89r+0d3+LUzT3O3yd3Or/KlllT+Q8oZhJCAu3cUe58tV/srIe2m/pkjA8mbAPqSDl+8lb3/l45BYEb7a7xrEU+uFQMtb5x3fyQaIi/04pO3WILFOeiOGsn+ZpvlaoOVdrmM49LCe21iHboZhrAa+NE1zXBDlE5DYHdmIZ/RuxEsuDem/vGSa5qxAy3q5nrNPYRjGOuB/vspeWXlHnRmGURtZUpGNeAH8ggzQOvkqv7/yntdx/B/3titTf3/kXdJfiMSXOxsxXLZBtm1fDEwzTfODQMu7ltvjeIxpmqet/y8H8k3TvCtY8tr+0dn+LunjkPf0tUjg9hhk04oy9Q+EvKdOuLdfmeX3R97l+9UFieN0LhL2oTMyQTIPWY6+KNDyVlnxbEOP+3khsME0zbt96WzpGmuaZonH9R9EjFCtvMlHKmpkigAMwzgLWcfanTMdojmmaS5zSVPKgBMk+Y7IbMBc0zSXu6QxgAZI4NKTgZT3uFYMMiNb4vqglpcAyDtmn097O+9tMFEZWcMwUpEZh/5AO2Rt+zzgfdM0jzh08nHNQMonI26t84ElpsugtZzlr7C8x/lY5MNU7K28vgiAfAxAZWQrK6/t73Y+Gts/AzEKZAItEc/ThcAHpmkWVLH8WYj3zyKkU7q6rHeov/Ie1wqH9jcq893wV94wjHhk57f9Lse6IZ6JDZFJov8hHd1SugVIvo5pmge8lK8esgR/kmma24Mgb2co/B2y5LMW4om3yjTNHwMp65D31WaGGK+eRuKZ2ZbdT/n6SN3tcjmWgsyC10WMg77KHxB5xChXG+mjnXY5X67y+yFv135tkP5kDLLMZ4Npmvu8lN9f+TjTi/HdOl8Tifky3TTNwiDIa/tHd/u3QrxhDiHevgcNw2iGGIoSrPKvN03zVy/XD4R8XcTjNwb42XR3VihP+f2RL1V/VvlTkNU4J4Gtpmke81L+gMt7nI9Hwj2859mntc4HxEgVqaiRKQIwDOO/yKzjd8jShr6c8b55CnjDNM1ib4PFIMifj8yEbAGeQAJ1++pE+St/OxJLZqXri8B6uDFN85Q32SDLl/KOCqSsle5/yAfiC2TGeQASW+UAsmPTP8pou2DJ70MC1j5jmmZJEOUfRXY+WWi6eNlUoO2CJV+md0qA5LX9o7v9v0Y6h/ORTvrl1g/gTWCiaZpHfNRfsORLkDgCkyz5eLu6DID8G8ikxDumu4GkBvL+POXaWatC+Tik/Xwaq/yVt9IOAf6IzL7XRIxB75mmOb8s2SDIxyPLTT5AdoE7Emx5j2vFIQOVU7467YGWtdKEwsh8LVJ33QEDmSSYj0wSFFWxvIncyx8Bi03T/D7Y8h7X8rf9/JWPRd4ZlW3/Cstr+7tdKxrb/zbE8ywdiae3BulLfWia5hdVLH8S6cssR5Z3/c80zRPBlPe4lmN5vVcnhCDLxwL4Gqt6y9f0w0gV8ZhhsGZPf95/yKBsD5Bk/Z2AePycjwRM+wG4pxrLX4CsVV2KxBK5EzjbI01N4AGgZYjlWwVK1jrX36q7Rh7HWyHulUVIMFVv225Guryj/lYjsXOeBi7ySFMLeAFoUw3lQ13/oZYPdf2HWv5iq/4SbM5lIx4YC7DZKbSayDvqbxMSQ+pd4Eqb+nsd+2DVES3vco3vEe+z25Ad4FYiRrrvgFF2clUkvx64OsjyXZF3xEBKxzKp4XksULLlkI8F31tNB0C+H+Jl8hay894N1vNyApmsuzOE8juA213S2u1W6a98T+BDxAveM45LedovmPJx5Wg/f+W1/aO7/S9G+kj/QFagXIaMmTYhE3ZP+NIhyPJFwKMOeS/t5698XySG3lhKx/Cr4ahDJK6YXczDYMo7DJYOeds+rIdMbHnSVbdfyAugvzIaSAKKferlXH1kt7jDeNmRrRrIP4sE6Z6MvLC/QqzgLyPLMJKRdcankeUAYSMfgLzvRWZ+all/OwOFW3//AdkRbICXuot0+Set+roFCUz4GTIT8zHwF8Qb7lyr/koNVKuBfKjrP9Tyoa7/UMvfYqVvYf1dE5fODhK4dTcw1Ev9Rbr83626utK6lz5EBi2bgGnILi29fNRfRMtb15gLvGpzvBPwCtJZv95OtprIvwkcQ76dnyD9ie4eafog31QjULJhIv8O8IrN8drWtfYBf/NRd5Eu/ybi/bAJ2ajmNUob6c8HcrAZvFUD+VDXf6jlQ13/oZafBbxsczwe+bb+giwx81Z/kS7/JjIZsQvxwsoDrvBI09c6XspYFgbyATVSReov5AXQXxkNJDOBe4AhXs7HIbOEd1dT+ZnAC9b/awBDkJ0RPkU6bx8iy+4WhZt8APLubNXddR7HDZf/5wIPV1P517E+QtYLuSeyK8pbiMttvnX9j6qpfKjrP9Tyoa7/UMsnITO+93gcd3pBIB35KdVU/llkSZ1jtrMdsuX9Y4h36HYkpsJ/q6O8JfMp8IjL36478iUgW1J/gwQNr47y31j1dRvyPH2JeAbmIrvktkFiORUEUjZM5D9AgtE6/q6Ji0cEMnm1AUiupvLLEY/Xy4GHEYP9DmSHtL8j8T2nIfFkqqN8qOs/1PKhrv9Qy89AvF8TrL8TcDFmIN7AG4H0air/P2QyrquVNg8x2v8GTEeWX78IfBum8n4ZqarLL+QF0F8ZDSTu9G8hxoiJyHaLdVzONwQKgWHVVL4LcJnN8eZIQOEZyExwZrjJByDvWMQotQ+Z9c0EmricPwv5aA2vpvJnARfbHG+ALMWaXEb9Rbq8o/5+9bP+I1U+1PUfMnnOGGEmIJ6enyDb3LdySZNi1V+pJUeRLm+drwucZ3O8FmLAHFtG/Ue0vJX2TmRpw++81G9r5NvqzRM4YuWBDkhHf4z1dz1kd6gJiHEyHwkkf5rSyxArLRsO8pbMdci383yP47HWv42BbUCf6iaPeHl/CNxq/Z2ADMpHILH8vkLeHaeBrOomH+r6D7V8qOs/1PKWzGAkKPcIj+OOSYs6yDLsi6qbPBJS4TXgZsc9AzRCPH8nWvV3wqq/34ebvCXjl5GquvxCXgD9laORpCP2EuJ2uRJZejHJuoHnAd9Xc3nnul1cZkKtY78HDoarfADyrokstVhqvdjet15QU5CZ0W+qs7zHtRy7M7nW3+HqLI+4lv8fEqzx60rUf0TKU3rpi+P5KVf9Rbq8h+xQZNnRN5xZejMTiWmztLrL+6jTLOB4dZYHmiG78W1FYlj0w2VpHTAMOFSN5VPxMFBZx1sgMT4+AA4EWjbU8sgyirrAbGA/svTkKqChdT4GmaiyrbtIl3eppxSb4/WQAdrLZdR/xMp71N8BP+s/4uRDXf+hlrfqLwHpJ51CvKJuwZqkQ5ZYjQF+q47yVpomQGub43HId2VyGfUfMnkCYKSqLj/dXS6CMGTL4T8g63jjkJt2GbLcYF11l/e4loG8yOYC9U3THBgp8pWRNQyjE3AFkIHUW0tksPZP0zS3VXd5m+vFIIbLxqZpjqju8oZsuft7JI5LU6QDU5H6j2h5j2s5np9K1X8kyhuG0Zozu4ImWb88ZGfOX6q7vM31DGQJQgvTNG+uzvKGYaQiS64uQtzuC4GjyExwJ2SnoPuqq7zLdRzLLItdjn2AbMt9XbBkQylvGEY94EZkyU0LZFByEBm0tAByTNN8qLrKe1zLbQcwq/5OmKY5srrKG4ZRB9md7UrEA76YitV/RMu7XMfb81Ou+o9kecMwrgCuBc5BjBu7kXqsCbxmmubT1Vnex3U/AEpM07wqHOUNw2gC1DZNc4fHccfY9w4k+H7DyuQfKaiRKUwxDKMm0A1rpg9Zx7vKNM2frfMdkZgOJ02bRqxG8kORj9IGxK1+h+my5bb1wDYwTXNfuMj7m7fLdRyBkk95HG9mmuYeO5lqKG+aXrZ8tc7XM03zQHWSNwyjLjLjPwqZBfwe8QJaZcqW6z7rr5rJ/wpsRrwg15mmucslXXnqL+LkXc7HAZge298ahlHTLMfWv9VE/rSP5ycGWXp9qDrK26TvjBhqOyNLTWohcZ+WmKZ5tLrLe1wrBumo5yOBw7+sCtlQyVv9pT5AO8RAm8D/b+/Mg+0oqjj89cv6YkgCGghF2EECBNkEsUBkR8AFqQKUkmIrVkUWKSh2UCmkcAEpNpHNgkpBAEHcoESWgARDILKHYCiQTQiELawmxz9OX5jMm/fywn1hevr+flVd777p/rq77u2Z6TnTfY6vCJ9u/QjJ3XS+or4xwA3AcWY2LVe+da0MIYzD7ynr4jsDhtGP7y8Dfqny9TGeP6Po3/fXWL5olAwhLI9fN1fCz6HhuJ+3WWY2P0e+L8U51nnAuWY2o2l8rKMtI1dTJCNTogoh/Bo30LyIT8hWwX0b3AScZWbPdBi/Mh529UbgHDObnSo/AG1vbGbTS8eG4gaLD3vBcucH4Q9si7xgZcBfiU/IZuHjZzy+j3sGcL6Z3dmB/NzI/8bMbs+c38LM7i4dW+j8CSEMLhtvMucXMtiEaKjPkY/5K+LbCTbF/ZY8CvzDzP4VryXdZvZ2B/Cb4FvtZsY6HjKzua0HmBDCyHI97bB186UHsx5G2n6Mm9z4voy0I6xknGw6H4+vDRyNr/yYjZ8/9+BbiytfSGTMP4X77ZkBTLHCqpAQQreZvZsbX6prodVvi6um84uou18vq1LkwwAYqRojS2DPntLCCbf4vgnswMd7WMfiezmfxp2HHQw9w952EH8QEKrqqJMfgLbXxJeUP4LvZ96wlB/wSHWbUgqL2UH8kIz5dfCVf5vxsYPM0cCBuD+z+Xj4348idHUgf2rkuzLkJ8Tx8xYe2njzUn4X/hb4G/hWq07jW9ePLPlYZlXcf9XjeISaB4DncUPFxfQSjSlz/jl8NfQFwOrl73Qg2ET4sfQMc946Z1r+HQO9hLzOlA/09GfXurb25/trEr86bpS8CzgT92E4FQ+Ffj2w3SLOnRz5e/Hz6Fpgh0WcP03nlwP2xrfRl8+h1qKQQcCwXr6/LPmKcq2Idf36/j4tfnFSb99Bbqn2DihV/ChwAgWHqJTCG+JhcZ+gEKlHfBr8ALR9Cr4C4le4v6rn8Zv0sUQndMAK+IPMePHZ8UcCdxf+H1rKPwSPStLDoaz4LPgT8DDnxwNTcN8FLwE/Jz6g4r4tFlDtlFJ8g/mYfxFwMzCucGwlPDLZM3jEnsqIZB3Cv9Ib3w6bCH9+HBsvxc/rlPIHxfp2p8JQ0wF8V4HvEfY7A/7COH6KzvGXw/1a3YX7Mjugj/GTOz8vc/68OH5eAybjEXmHlcqshAfT6WGkEF87/6kZqZqSau+AUsWP4r58ZgFrFI4NLgzM1tuyH4pPix+Atq/GQ5yOw/ev74NHKXgIfyN6Mx4a9VHxWfJb40aIbUvjpzt+/iweqe1U8Vny5+O+KpaJaUvcMP04Pvl5CPh7H+NHfIP5WMcU4Jj4eQg9X1RMAv5CKVql+Gb3Peb/E1/xdCq++mMBvuXmBOKDC3AyMLuXsSO+2fyfgdPj50GUDHHAL/CXViPEZ8nfi6+A2g8PjPI+7mrjPGCjWOYnwFPik+TbMlLlmGrvgFLFj+IPIo/jK172qBqM+A3sYPFp8W2yg/EoDMeXji+DO838Ab7kdgEVb0PEN5uPZYfjIb9fxFe9dFeUmQF8X3xePD4p3Rk4rHR8KD4x+TpwSRw/+4nPiy+UPy2OkeLb8CF8bKjcAvf1s5n4dNoegL6vDNyCr3rowle87ogbLp+N4+Ye/AHmKPF58bGOI2LZCaXrx9D4eR3c7cLW4vPi8bD3k4GD4v+D8e3Xx+HXlPnAw/hqqCPEp8VHpi0jVY6p9g4o9fLD+IC/BngMuBX4KbAN8Hl8pcQreGQa8Ynx7bZdqGdIxbHd8MlK5ZsQ8c3n8ahLv8QnKzNx3x674X6+JuErZcRnyhfqqfLZtONijD/xDeSBjfGJ6QPANyvyJwDv9VZHJ/MN7/sofOXrV0vHu3FfL3sAd+BbMKuM1+IbzMeyq+LbbZ8G9q/Inwh80Mf4E99QHvgM7qvvSxV5I3A/ntf2Mf7E18u3baTKMdXeAaU+fhxfFbMPcBXu3+VVfIJ6O/Ad8enyn4Sl4qEkHv/IaSTu2+MO8fnxMb/lEHQk8DXgDOA2PDrZm3jY253E58fjDmIrx1ChzGnALeLz41t1xL9rxLHyAj4xvQCfAEx4nFoAAAgKSURBVB8HTAOuFZ9O2wPBV4ylKp89V9PH/UN883lgKXzL7Vzg7TiWDovj6CHgd+Lz5YtjqOLYFXiUOvGJ8bRppMo1tW6KUiIKIYzHJyngFs/H8Ihkq+EPLu8Ac8zsNfFp8QPYdsANUjPN7KVCfgC+BTxvZtPE58VXKYZ+H4uPo+HAG2Y2rz+s+ObzFfVtBbxiZo+Kz5sPIQwHtgO2xyeo6+JbbS4BrjKzZ8Sn1/ZA8IV6Ar4Ncz6+IuYu4Ewzu158Xnws22Vm8+P4WQ/36bYNsBG+OuYq4IbivEJ8NnwXYNbLQ3kIoRu4CbjQzH4vPi2+onwo1xVCuAIPAPKVRfG5SEamhBRCOBTYH1gfN0jMxp0F3w5cZ2b/EZ8mP8Btz8OdRT6HOwm80cxmis+a7zazdwv/93nDE583v7gS32w+1tGFG6HH4g+k/8bfmr4RH1oM9/UzR3w6bS8BfgQelfROM3u5UGYYHgL+T+Lz4ntTCGEQsMDMLIQw2sze6C8rvvl8qa4hwBfN7F7x6fEDbaTKRpbAciolA99eNRc4KX6egDsKvg5fEfM3YjhUqFzGJ74mfgm3/SjuTLLFV4X9Fd9sfmncf8+FwObFMUIhChGwNgWHsuI7gi9+XhsYIz4vPuYthS+lfwX4L+7T50HcUfDpwJrFMSU+jbaXED8duB+PQnkGBSfC/Rw74pvFD8H9dVZGm6Jizii+c/hFJfH18ovZzpeXZBsppto7oBR/CDgcuK+XvC3w0Lizgc+JT4tvct/FJ8O/j4c/no+/Bf8xsFahzIr4g8tq4sWLz4eP+SfiUUc3if9PAL6HG66mAzcDY6vYTueb3Pd+8NOAP4jPmj8SX/18Oe7TZRyll1G4U/GdqA4mIr4z+F2IUerEJ8V/KkaqpqbaO6AUfwg4GF/1MjH+P6w4oPEQyI8Be4lPi29y38UnwV8CXAQsC3wBD4E6C39gnQocBBwPvC1evPi8+FjHFODoiuODcL8es4C/ik+rbfHiB4C/F3erMAW/ZjyNRyfdAhgdyxwCTBUvXnxyfFtGqtxT7R1Qij+Eb7N5BPgthS0VFJZX41HKjhWfFt/kvouvfewMA44CTiwdH407jr0Mj1K0ADhZvHjx+fCx7GB81cM9xBUP+ANq8fqxLX6NWV98Gm2LFz8A/FjcGfhe8f/x+Lb7J/FrxnQ8KuETwLnixYtPh49MW0aq3FPtHVAygBDTrsAzwFvApcDGuE+PlfDlt28Bq4hPh29y38XXz8c6hgHj4ueFJqjx2Fb4DW+8ePHi8+Jjmc3wbXZnActV5K+Ih8NeQXw6bYsX3+bYXR43Uu9YkbchcD7wKn79EC9efFp820aq3FPtHVAq/BgwBl9ufwjuLPjtmJ7Cb2KniU+Tb3LfxdfH87FT6NUoTVALeacAs8WLF58XH/O78BURB+LOg+fiqyK3B9YCdgeuBKaJT6dt8eLb5WMd3cDw1jWjlQr5ZwAPihcvPi2eNo1UnZBakyCpJoUQlgX2Bn4EzAHeBV7HI1NMxZ2KrYHv6X5SfDp8k/suPin+aOBl4H/Ai8Bk4AYzmxdCCPgE9gUz+6N48eLz4KsUQhgD7AvsBWyAr4B8D3cgfKaZ3Sc+vbbFi29z7AareBgLIYzAoxVebmZniRcvPi0+hNANmJm9F+/3EA/E/DOAnc1sw97az1kyMtWsEMIVwLp4BJLXgGWA9XBv9S8DJy3i5iS+Jr7JfRefLL8hHp3mOeBsM7tVvHjx+fGxjlHAW8UJbgihCxgOjAQmAvP6uAd1LN/kvosXX8VXlBkO7AlMMrMPxIsXnwZfKteWkStrWQLLqTo1AQHfUrNl6djKwB7Arfh2m43Ep8U3ue/ik+ZXxJfY3wrMFC9efH58gbkYOAA3To/qpczSrfrFp9G2ePGfEj+m6rh48eJr50dVndelMsOBfejAqHIffQd1d6CTE/4W9GFgs17yhwH340ttxSfEN7nv4hvBDxUvXnyefCzzXdxXw+vAbHzSuxu+xbY7lhkJ3AisJz6NtsWLX0L8t4HVC3w3cBMwUbx48enwMb8tI1WnpNo70MkpDuLb8BCIa1KKShPLHA7MEJ8W3+S+ixcvXrz4+viYfwlwEe40/BjcaPUO8CDubHQb4FDgA/HptC1evHjx4juab9tI1Smp9g50esLDn87AJ6v74svtR8a8EcB1wFXi0+Ob3Hfx4sWLF1/bvWMwcALws9LxdYFzcJ9Oc3Bn4peKT6Nt8eLFixffuXws25aRqpNS7R1QMnAHgdfg0anm4I5ELwOeBe6jYrmt+DT4JvddvHjx4sXXdu9YGpgQPw+lp8+hPfG3pRuIT6dt8eLFixffmTwDYKTqpKTocgkpeEjkXYBd8dCnjwCTzewJ8WnzTe67ePHixYuvjy/U04VPeOeHEA4EzjWzEeLTblu8ePHixXcGH0JYGljOzJ4IIQwFPrSCMSWEsCcwCQ/8MaO/fchRMjIlqhBCl5ktEN88vsl9Fy9evHjx9fGFeo4GBpnZ2eKb07Z48eLFi+8svl0jV66SkUmSJEmSJCkhhRCGAPPbeNnRsXyT+y5evHjx4hvNt2XkykkyMkmSJEmSJEmSJEmSJH1CtWukykkyMkmSJEmSJEmSJEmSJEltq6vuDkiSJEmSJEmSJEmSJEnNl4xMkiRJkiRJkiRJkiRJUtuSkUmSJEmSJEmSJEmSJElqWzIySZIkSZIkSZIkSZIkSW1LRiZJkiRJkiRJkiRJkiSpbf0fKEaOO6i2jY4AAAAASUVORK5CYII=\n", "text/plain": [ - "
" - ], - "image/png": "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\n" + "
" + ] }, + "execution_count": 27, "metadata": {}, - "execution_count": 26 + "output_type": "execute_result" } + ], + "source": [ + "# execute function to build a qiskit gate with the risk model\n", + "#rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", + "\n", + "rm.measure_all()\n", + "display(rm.draw(output='mpl'))\n", + "print(\"-------------------------------\")\n", + "\n", + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(rm, backend,shots=100000)\n", + "result=job.result()\n", + "counts=job.result().get_counts()\n", + "plot_histogram(counts,figsize=(20,10))" ] }, { "cell_type": "code", - "source": [ - "## building the graph from adjacency matrix for visual representation\n", - "G = nx.Graph()\n", - "G = nx.from_numpy_array(mat)\n", - "nx.draw(G, with_labels=True, alpha=0.8, node_size=500)" - ], + "execution_count": null, "metadata": { - "id": "rERzrEyX996k", "colab": { "base_uri": "https://localhost:8080/", "height": 319 }, - "outputId": "0b2299c3-aff4-4d58-e8b9-692a271319d4" + "id": "rERzrEyX996k", + "outputId": "fe29c0d8-d0a5-48b4-8f7a-f6aff421eaf9" }, - "execution_count": 28, "outputs": [ { - "output_type": "display_data", "data": { + "image/png": "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\n", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" } + ], + "source": [ + "## building the graph from adjacency matrix for visual representation\n", + "G = nx.Graph()\n", + "G = nx.from_numpy_array(mat)\n", + "nx.draw(G, with_labels=True, alpha=0.8, node_size=500)" ] }, { "cell_type": "code", - "source": [ - "## use Oracle to build QAE and evaluate probabaility for state 'STATELIST'\n", - "name = \"test\"\n", - "STATELIST = [\"111111\"] # we search for the joint probability where all 6 parameters are triggered\n", - "Nshots = 100000 # number of shots\n", - "QAEqubits = 8 # QAE bit precision --> 8 bit strings at the end of the measurement to differentiate 2^8 = 265 bins\n", - "\n", - "\n", - "#rm = BRMlist(RIlist,TPlist,model2gate=True)\n", - "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=True) \n", - "ora = brmoracle(\"ora\",rm,len(nodes),0,STATELIST)\n", - "QAE=qae(QAEqubits,len(nodes),len(nodes),rm,ora)" - ], + "execution_count": null, "metadata": { - "id": "I6snOMVZ999e", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "f78e6245-484d-4b82-f2eb-643b32e3b5d8" + "id": "I6snOMVZ999e", + "outputId": "73f4cfbc-f501-4a2c-c956-7a42fb23331a" }, - "execution_count": 29, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "NOTE: Item 2 is triggered by more than one other RI!\n", "ITEM:\n", @@ -752,151 +679,155 @@ "NOTE: Item 5 is triggered by more than one other RI!\n", "ITEM:\n", "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", "ITEM:\n" ] } + ], + "source": [ + "## use Oracle to build QAE and evaluate probabaility for state 'STATELIST'\n", + "name = \"test\"\n", + "STATELIST = [\"111111\"] # we search for the joint probability where all 6 parameters are triggered\n", + "Nshots = 100000 # number of shots\n", + "QAEqubits = 8 # QAE bit precision --> 8 bit strings at the end of the measurement to differentiate 2^8 = 265 bins\n", + "\n", + "\n", + "#rm = BRMlist(RIlist,TPlist,model2gate=True)\n", + "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=True) \n", + "ora = brmoracle(\"ora\",rm,len(nodes),0,STATELIST)\n", + "QAE=qae(QAEqubits,len(nodes),len(nodes),rm,ora)" ] }, { "cell_type": "code", - "source": [ - "## execution with local quantum simulator (qasm simulator)" - ], + "execution_count": null, "metadata": { "id": "LV9AZICL9-Am" }, - "execution_count": 30, - "outputs": [] + "outputs": [], + "source": [ + "## execution with local quantum simulator (qasm simulator)" + ] }, { "cell_type": "code", - "source": [ - "backend = Aer.get_backend('qasm_simulator')\n", - "job = execute(QAE, backend,shots=Nshots)\n", - "result=job.result()\n", - "counts=job.result().get_counts()\n", - "plot_histogram(counts,figsize=(16,8))" - ], + "execution_count": null, "metadata": { - "id": "tHtZ9Jct7Fk1", "colab": { "base_uri": "https://localhost:8080/", "height": 544 }, - "outputId": "322ec32e-4ba9-45b3-85ff-57bb6cdc7d34" + "id": "tHtZ9Jct7Fk1", + "outputId": "be5dac1c-67e2-4e2f-9d18-409a1fa0d85c" }, - "execution_count": 31, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8MAAAIPCAYAAABXKAxNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzde3gX5Z3//+ctKVGMWA4FJUEhBKIEC4TQSIugVsuutrS6KmjX1tXKVvFAu1baVWnxUOm3Lku76s/WtRWrNfXQLtoKorhIsQgNCBXSCkpwSaxgOQmCSRPv3x+fEBIMkEgOhHk+riuXM/fcM5/3cM8fvuYYYoxIkiRJkpQkR7R1AZIkSZIktTbDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJSpy0ti6gLXXv3j326dOnrcuQJEmSJLWApUuX/i3G+ImGliU6DPfp04fi4uK2LkOSJEmS1AJCCG/ua5m3SUuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJElSwsyZM4fc3FxycnKYNm3ah5bfd999nHLKKQwZMoSRI0dSUlICwHPPPcewYcM45ZRTGDZsGC+88MKH1h07diyDBg1q8X04WIbhQ0hzH5A7d+7k3HPP5aSTTiIvL49vf/vbrbo/kiRJkg491dXVTJw4kdmzZ1NSUsKjjz5amy12u+SSS3j11VdZvnw5N954I9/85jcB6N69O08//TSvvvoqM2fO5NJLL6233q9//WsyMjJabV8OhmH4ENFSB+QNN9zAX/7yF1555RVeeuklZs+e3ar7JUmSJOnQsmTJEnJycsjOzqZjx46MHz+eWbNm1evTuXPn2un33nuPEAIAQ4cOpVevXgDk5eWxa9cuKioqANixYwfTp0/n5ptvbqU9OThpbV2AUuoekEDtATlw4MDaPvs7IHere0B26tSJM844A4COHTuSn59PWVlZa+yOJEmSpENUeXk5vXv3rp3Pyspi8eLFH+p3zz33MH36dCorKxu8HfrJJ58kPz+f9PR0AG655Rb+7d/+jU6dOrVc8c3IK8OHiIYOyPLy8g/1u+eee+jXrx833ngjP/7xjz+0fO8DcretW7fy9NNP89nPfrb5i5ckSZJ02Jk4cSJvvPEGP/jBD7j99tvrLVu1ahWTJ0/mJz/5CQDLly/njTfe4LzzzmuLUj8Sw3A705QDcreqqiouvvhirrvuutorz5IkSZKSKTMzk/Xr19fOl5WVkZmZuc/+48eP53/+53/q9T/vvPN46KGH6NevHwCLFi2iuLiYPn36MHLkSFavXs3pp5/eYvvQHAzDh4iWOCB3mzBhAv3792fSpEnNX7gkSZKkdmX48OGsWbOG0tJSKisrKSoqYuzYsfX6rFmzpnb6d7/7Hf379wdSd5yee+65TJs2jc985jO1fa666ireeust1q1bx8KFCxkwYADz589vlf35qAzDh4iWOCABbr75ZrZt28aMGTNafickSZIkHfLS0tK4++67GTNmDCeffDIXXXQReXl5TJkyhaeeegqAu+++m7y8PIYMGcL06dOZOXNmbfvrr7/OrbfeypAhQxgyZAgbN25sy935yEKMsa1raDMFBQWxuLi4rcuo9cwzzzBp0iSqq6u5/PLLuemmm5gyZQoFBQWMHTuW66+/nueff56PfexjdOnSpfYAvf3227nzzjtrwzHA3LlzqayspHfv3px00km1zxBfc801fO1rX2urXZQkSZKkVhNCWBpjLGhwmWH40AnDkiRJkqTms78w7G3SkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEafUwHEK4OoRQGkJ4P4SwNIRw2n76jg4h/CGEsCmEsCuE8JcQwg179bkyhPD7EMKWEMLWEML/hhBGtvyeSJIkSVIyXDkj9Xc4adUwHEIYB/wI+D4wFPgDMDuEcMI+VtkB/BgYBQwEbgemhhCurtPndOBXwJlAIfAa8GwIoX9L7MOh5HA8ICVJkiSpNaS18u99E3gwxnh/zfy1IYR/AK4CvrN35xjjUmBpnabSEML5wGnAvTV9vlx3nRDCVcCXgH8A1jT7HkiSJEmS2r1WuzIcQugIDAPm7rVoLvDpRm5jaE3fF/fTrSNwJLDlI5QpSZIkSUqA1rwy3B3oAGzYq30DcNb+VgwhlAGfIFXv1Bjjffvpfjup26uf2se2JgATAHr16sX8+fMByM7O5phjjmHFihUAdOvWjby8PBYsWABAWloaI0eOZNmyZbz77rsAFBQUsGHDBtavXw9A//79SU9PZ+XKlQD06NGDAQMGsHDhQgDS09MZMWIExcXF7NixA4DCwkLKysooLy8HIDc3lw4dOlBSUgLAcccdR9++fVm0aBEARx11FIWFhSxevJjUXeFQUVFBaWkpb7/9NgADBw6kurqa1157DYDMzEyysrJq1oGMjAwKCgpYtGgRFRUVAIwcOZLVq1ezceNGAAYNGkRFRQVr1qQurvfu3ZuePXtSXFwMQOfOncnPz2fhwoVUVVUBMGrUKFatWsWmTZsAGDx4MNu3b2ft2rUA9OnTh65du7Js2TIAunTpwuDBg3nxxReJMRJCYPTo0axYsYItW1LnMvLz89m8eTPr1q1rt+O0a9cuAEaMGOE4OU6Ok+PkODlOjpPj5Dg5Tu1ynFJPp9Lu8tP+hBjjATs1hxBCL6AcGB1jXFCnfQrw5Rhj7n7W7QtkAKcCPwCujzH+ooF+1wO3AWfFGJccqKaCgoK4+yBqj3Y/L3z/pLatQ5IkSdLhrb1mjxDC0hhjQUPLWvPK8N+AaqDnXu09gbf3t2KMsbRm8tUQQk/ge0C9MBxCmEQqCP9jY4KwJEmSJCm5Wu2Z4RhjJamXYZ2916KzSb1VurGOANLrNoQQvkkqCJ8bY1x4MHVKkiRJkg5/rf026enAL0IIS4CXgK8DvYD7AEIIDwHEGL9SM38tUErqc0mQ+sTSDdS8Sbqmz7eAO4B/BlaHEI6rWbQrxritpXdIkiRJktT+tGoYjjH+KoTQDbgZOB5YCZwTY3yzpsve3xvuQOoZ4T5AFfAG8G1qwnONicDHSH1ruK6ZwGXNWL4kSZIk6TDR2leGiTHeS50ru3stO32v+RnAjANsr09z1SZJkiRJSoZWe2ZYkiRJkqRDhWFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuIYhiVJkiRJiWMYliRJkiQljmFYkiRJkpQ4hmFJkiRJUuK0ehgOIVwdQigNIbwfQlgaQjhtP33PDyHMDSG8E0LYHkJYHEIYu5/+F4cQYgjhty1TvSRJkiTpcNCqYTiEMA74EfB9YCjwB2B2COGEfawyGngBOLem/zPAbxoK0CGEbOCHwO9boHRJkiRJ0mGkta8MfxN4MMZ4f4zxzzHGa4G/Alc11DnGeH2McVqMcUmM8fUY41RgKfCluv1CCB8DHgVuAta27C5IkiRJktq7tNb6oRBCR2AYcNdei+YCn27Cpo4BtuzVdgewLsY4M4RwxgHqmABMAOjVqxfz588HIDs7m2OOOYYVK1YA0K1bN/Ly8liwYAEAaWlpjBw5kmXLlvHuu+8CUFBQwIYNG1i/fj0A/fv3Jz09nZUrVwLQo0cPBgwYwMKFCwFIT09nxIgRFBcXs2PHDgAKCwspKyujvLwcgNzcXDp06EBJSQkAxx13HH379mXRokUAHHXUURQWFrJ48WKgEICKigpKS0t5++23ARg4cCDV1dW89tprAGRmZpKVlVWzDmRkZFBQUMCiRYuoqKgAYOTIkaxevZqNGzcCMGjQICoqKlizZg0AvXv3pmfPnhQXFwPQuXNn8vPzWbhwIVVVVQCMGjWKVatWsWnTJgAGDx7M9u3bWbs2dX6iT58+dO3alWXLlgHQpUsXBg8ezIsvvkiMkRACo0ePZsWKFWzZkhri/Px8Nm/ezLp169rtOO3atQuAESNGOE6Ok+PkODlOjpPj5Dg5To5TuxwnOB2g3eWn/QkxxgN2ag4hhF5AOTA6xrigTvsU4MsxxtxGbGMiMA0YFGN8s6btc8BPgSExxq0hhAeB7jHGzx9oewUFBXH3QdQeXTkj9d/7J7VtHZIkSZIOb+01e4QQlsYYCxpa1mpXhg9WCOGfSD0TPK5OEP4E8CBwcYxxaxuWJ0mSJElqR1ozDP8NqAZ67tXeE3h7fyuGEC4AHgK+EmN8us6iPOB4YF4IYXfbETXrVAF5McbXDr50SZIkSdLhpNVeoBVjrCT18quz91p0Nqm3SjcohHAR8AvgshjjE3st/iNwCjCkzt9TpN4oPQQobZbiJUmSJEmHlda+TXo68IsQwhLgJeDrQC/gPoAQwkMAMcav1MyPJxWEbwAWhBCOq9lOZYxxc4zxPWBl3R8IIWwF0mKM9dolSZIkSdqtVcNwjPFXIYRuwM2kbm9eCZyz+xlgYO/vDX+dVI0zav52e5HdrzOTJEmSJKmJWv0FWjHGe4F797Hs9P3NN3L7l32UuiRJkiRJydFqzwxLkiRJknSoMAxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEaVIYDiEcEUI4os78cSGEr4UQPtP8pUmSJEmS1DKaemX4d8C1ACGEDKAY+CEwP4TwlWauTZIkSZKkFtHUMFwAvFAzfT7wLtADuBK4oRnrkiRJkiSpxTQ1DGcAW2umPwf8Jsb4d1IBuV9zFiZJkiRJUktpahj+P+AzIYSjgTHAczXtXYGdzVmYJEmSJEktJa2J/acDvwB2AG8CC2raRwGvNmNdkiRJkiS1mCaF4RjjT0IIS4HewHMxxg9qFr0B3NLcxUmSJEmS1BKaemWYGGMxqbdI1237XbNVJEmSJElSC2vqM8OEEK4OIawKIewMIWTXtE0OIVzU/OVJkiRJktT8mhSGQwiTgJuBnwKhzqK3gGuasS5JkiRJklpMU68Mfx24Msb4I6CqTvsyIK/ZqpIkSZIkqQU1NQyfCKxsoP3vwFEHX44kSZIkSS2vqWF4LZDfQPs5QMnBlyNJkiRJUstr6tuk7wLuDiF0IvXM8IgQwqXAjcDlzV2cJEmSJEktoanfGf55CCEN+D7QCfgFqZdnXRdj/FUL1CdJkiRJUrP7KN8Zvh+4P4TQHTgixrix+cuSJEmSJKnlNDkM7xZj/FtzFiJJkiRJUms5YBgOIfwJGB1j3BJCeBWI++obY/xkcxYnSZIkSVJLaMyV4SeBijrT+wzDkiRJkiS1BwcMwzHGqXWmv9ei1UiSJEmS1Aqa9J3hEMILIYSPN9DeOYTwQvOVJUmSJElSy2lSGAZOBzo20H4kcNpBVyNJkiRJUito1NukQwj5dWY/GULYXGe+AzAGKG/OwiRJkiRJaimN/bRSMakXZ0VgbgPLdwHXNldRkiRJkiS1pMaG4b5AANYCnwLeqbOsEtgYY6xu5tokSZIkSWoRjQrDMcY3ayab+oyxJEmSJEmHnAOG4RDC+cDTMca/10zvU4zx181WmSRJkiRJLaQxV4afAI4DNtZM70sk9TItSZIkSZIOaQcMwzHGIxqaliRJkiSpvTLcSpIkSZISp7HPDDeKzwxLkiRJktqDxj4z3Bg+MyxJkiRJahea9MywJEmSJEmHA4OuJEmSJClx/M6wJEmSJClx/M6wJEmSJClx/M6wJEmSJClxDLeSJEmSpMRpchgOIeSHEB4KIRTX/P0ihJDfEsVJkiRJktQSmhSGQwhfBv4IHA88U/PXE1gSQvjn5i9PkiRJkqTm15gXaNV1B3BLjPH7dRtDCN8Bbgcebq7CJEmSJElqKU29TfoTwGMNtD8O9Dj4ciRJkiRJanlNDcP/C5zeQPvpwIsHW4wkSZIkSa3hgLdJhxDOrzM7G7gzhFAAvFzTdipwPvC9Zq9OkiRJkqQW0Jhnhp9ooG1CzV9d/wXce9AVSZIkSZLUwg4YhmOMfotYkiRJknRYMehKkiRJkhKnqZ9WIoTQBfhH4ASgY91lMcZbm6kuSZIkSZJaTJPCcAjhVOB3QAWpzyyVA8fXzK8DDMOSJEmSpENeU2+T/iHwCJAJvA+cSeoKcTHwg+YtTZIkSZKkltHUMPxJ4O4YYwSqgfQY4wZgMn5aSZIkSZLUTjQ1DFfWmd4AnFgzvQPo1SwVSZIkSZLUwpr6Aq1lwHBgNTAfuD2E0BP4Z+BPzVuaJEmSJEkto6lXhm8C3qqZvhl4B/gvoAswoRnrkiRJkiSpxTTpynCMsbjO9DukPrEkSZIkSVK70uTvDAOEEPoBJ9fMlsQY1zZfSZIkSZIktaymfme4G/AAMBb4YE9z+C1weYxxUzPXJ0mSJElSs2vqM8P/DeQApwFH1vyNAvoC9zdvaZIkSZIktYym3iY9BvhsjHFRnbaXQgj/CjzffGVJkiRJktRymnpl+B3gvQbadwLeIi1JkiRJaheaGoZvBWaEEDJ3N9RM/0fNMkmSJEmSDnkHvE06hPAqEOs09QXWhRDKa+YzgfeBHqSeKZYkSZIk6ZDWmGeGn2jxKiRJkiRJakUHDMMxxqmtUYgkSZIkSa2lqW+TBiCEcCYwkNTt06tijPObsyhJkiRJklpSk8JwzcuyfgMMA96qae4VQigGzosxvrXPlSVJkiRJOkQ09W3SPwaqgZwYY+8YY2+gf03bj5u7OEmSJEmSWkJTb5M+Gzg9xli6uyHGuDaEcB0wr1krkyRJkiSphTT1yjDU/8zS/tokSZIkSTokNTUMzwP+K4TQe3dDCOEEYAZeGZYkSZIktRNNDcPXAUcDa0MIb4YQ3gTeqGm7rrmLkyRJkiSpJTT1meFNwKeA04GTatr+HGN8vjmLkiRJkiSpJTU6DIcQOgDbgMExxueA51qsKkmSJEmSWlCjb5OOMVYDbwIdD+YHQwhXhxBKQwjvhxCWhhBO20/f40MIvwwh/CWEUB1CeHAf/TqHEH4cQngrhFARQng9hHDRwdQpSZIkSTp8NfWZ4duAaSGE7h/lx0II44AfAd8HhgJ/AGbXvISrIenA34BpwOJ9bPNjpK5S9wcuAnKBy4DShvpLkiRJktTUZ4ZvAPoC5SGEMuC9ugtjjJ88wPrfBB6MMd5fM39tCOEfgKuA7+zdOca4jpoXc4UQLtjHNv8F+ARwWoyxsqZt3QH3RJIkSZKUWE0Nw0+Q+qZwaOoPhRA6AsOAu/ZaNBf4dFO3V8eXgJdIffLpi8Bm4DHgjhjj3w9iu5IkSZKkw1SjwnAIoRPwQ1LB82Okvil8bYzxb034re5AB2DDXu0bgLOasJ29ZQNnAr8EzgX6APcAGaSuZNcTQpgATADo1asX8+fPT20kO5tjjjmGFStWANCtWzfy8vJYsGABAGlpaYwcOZJly5bx7rvvAlBQUMCGDRtYv349AP379yc9PZ2VK1cC0KNHDwYMGMDChQsBSE9PZ8SIERQXF7Njxw4ACgsLKSsro7y8HIDc3Fw6dOhASUkJAMcddxx9+/Zl0aJFABx11FEUFhayePFioBCAiooKSktLefvttwEYOHAg1dXVvPbaawBkZmaSlZVVsw5kZGRQUFDAokWLqKioAGDkyJGsXr2ajRs3AjBo0CAqKipYs2YNAL1796Znz54UFxcD0LlzZ/Lz81m4cCFVVVUAjBo1ilWrVrFp0yYABg8ezPbt21m7di0Affr0oWvXrixbtgyALl26MHjwYF588UVijIQQGD16NCtWrGDLli0A5Ofns3nzZtatW9dux2nXrl0AjBgxwnFynBwnx8lxcpwcJ8fJcXKc2uU4pT4oRLvLT/sTYowH7hTCD4GrgUeAXcAlwPwY44UHXHnPNnoB5cDoGOOCOu1TgC/HGHMPsP5vgb/FGC/bq301cCTQt+YlX7sD738CGXE/O1hQUBB3H0Tt0ZUzUv+9f1Lb1iFJkiTp8NZes0cIYWmMsaChZY29Tfp84IoYY1HNBh8BXgohdNgdQBvhb0A10HOv9p7A243cRkP+Cvx9rzr+DHQidTX6nYPYtiRJkiTpMNTYt0n3Bn6/eybGuASoAno19odqXm61FDh7r0Vnk3qr9Ef1EpATQqi7LwOAnaQCuCRJkiRJ9TQ2DHcAKvdqq6LpL+CaDlwWQvhaCOHkEMKPSAXq+wBCCA+FEB6qu0IIYUgIYQjQGehaMz+wTpf/D+gK/CiEkBtCGANMBe7d3y3SkiRJkqTkamyYDcDDIYSKOm1HAveHEHbubogxjt3fRmKMvwohdANuBo4HVgLnxBjfrOnS0PeGX9lr/gvAm6RelEWMcX0I4XOkgvZyUrdc/wy4vXG7JkmSJElKmsaG4ZkNtD38UX4wxngvcO8+lp3eQNsBP+MUY3yZg/s8kyRJkiQpQRoVhmOM/9LShUiSJEmS1Foa+8ywJEmSJEmHDcOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSpMQxDEuSJEmSEscwLEmSJElKHMOwJEmSJClxDMOSJEmSlABz5swhNzeXnJwcpk2b9qHlCxYsID8/n7S0NJ544ol6y1Yvmcljd/Snf//+zJw5E4CdO3dy7rnnctJJJ5GXl8e3v/3tVtmP5mIYliRJkqTDXHV1NRMnTmT27NmUlJTw6KOPUlJSUq/PCSecwIMPPsgll1xSr33z5s288uxUxk5azJIlS5g6dSpbtmwB4IYbbuAvf/kLr7zyCi+99BKzZ89utX06WIbhQ9iBztz89Y0F/Oauhs/czJw5k/7965+5Abjpppvo3bs3GRkZLV6/JEmSpEPDkiVLyMnJITs7m44dOzJ+/HhmzZpVr0+fPn345Cc/yRFH1I+Jzz77LJm5Z3Pk0V3p0qULZ599NnPmzKFTp06cccYZAHTs2JH8/HzKyspabZ8OlmH4ENWYMzcZXU5g1CUNn7mZOnUqixd/+MzNF77wBZYsWdJq+yFJkiSp7ZWXl9O7d+/a+aysLMrLyxu97tEf3/+6W7du5emnn+azn/1s8xTcCgzDh6jGnLk5pmsfuvVq+MzN2WefTdeu9c/cAJx66qkcf/zxrbYfkiRJkg5vVVVVXHzxxVx33XVkZ2e3dTmNZhg+RB3smZuPuq4kSZKkw09mZibr16+vnS8rKyMzM7PR6763dd/rTpgwgf79+zNp0qTmK7gVGIYlSZIk6TA3fPhw1qxZQ2lpKZWVlRQVFTF27NhGrTtmzBjKXptLxc4tbNmyhblz5zJmzBgAbr75ZrZt28aMGTNasvwWYRg+RB3smZuPuq4kSZKkw09aWhp33303Y8aM4eSTT+aiiy4iLy+PKVOm8NRTTwHwxz/+kaysLB5//HH+9V//lby8PAC6du3K0M/dwqz/HM7w4cOZMmUKXbt2paysjDvuuIOSkhLy8/MZMmQI//3f/92Wu9kkIcbY1jW0mXTxW+MAACAASURBVIKCglhcXNzWZTSoqqqKAQMGMG/ePDIzMxk+fDi//OUvaw9IgCtrTr78ffllfP7zn+eCCy4AUi/QGjZsGMuWLQMgPz+fpUuX0rVr19p1MzIy2LFjR+vtkCRJkqR2a3f2uL993QlNCGFpjLGgoWVeGT5ENebMzTv/90d++b2Gz9zccsstDB9e/8wNwI033khWVhY7d+4kKyuL733ve221i5IkSZLUZrwyfIheGW6M9np2RpIkSVL70l6zh1eGJUmSJEmqwzAsSZIkSUocw7AkSZIkKXEMw5IkSZKkxDEMS5IkSZI+ZPdLsw5XhmFJkiRJUuIYhg8TV844/M/cSJIkSVJzMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJSpxWD8MhhKtDCKUhhPdDCEtDCKcdoP/omn7vhxDWhhC+vtfyDiGE2+psszSEcHsIIa1l90SSJEmS1F61ahgOIYwDfgR8HxgK/AGYHUI4YR/9+wLP1PQbCtwJ/FcI4Z/qdJsMTASuA04Crq+Z/04L7YYkSZIkqZ1r7aun3wQejDHeXzN/bQjhH4CraDi8fh14K8Z4bc38n0MIhcANwJM1bZ8Gno4xPl0zvy6E8BRQ2CJ7IEmSJElq91rtynAIoSMwDJi716K5pAJtQ0Y00P9ZoCCE8LGa+YXAGSGEk2p+ZyBwJqkrypIkSZIkfUhrXhnuDnQANuzVvgE4ax/rHAc830D/tJrt/RX4AXAMUBJCqK5ZdkeM8d6GNhhCmABMAOjVqxfz588HIDs7m2OOOYYVK1YA0K1bN/Ly8liwYAEAaWlpjBw5kmXLlvHuu+8CUFBQwIYNG1i/fj0A/fv3Jz09nZUrVwLQo0cPBgwYwMKFCwFIT09nxIgRFBcXs2PHDgAKCwspKyujvLwcgNzcXDp06EBJSUnqH+C44+jbty+LFi0C4KijjqKwsJDFixez++J3RUUFkA7A/PnzGThwINXV1bz22msAZGZmkpWVVbMOZGRkUFBQwKJFi2rWhZEjR7J69Wo2btwIwKBBg6ioqGDNmjUA9O7dm549e1JcXAxA586dyc/PZ+HChVRVVQEwatQoVq1axaZNmwAYPHgw27dvZ+3atQD06dOHrl27smzZMgC6dOnC4MGDefHFF4kxEkJg9OjRrFixgi1btgCQn5/P5s2bWbduXbsdp127dgEwYsQISktLefvttwEcJ8fJcXKcHCfHyXFynBwnx+mQHiegNi/B6fXm28s47U+IMR6wU3MIIfQCyoHRMcYFddqnAF+OMeY2sM5q4OEY46112kYBLwK9Yox/DSGMB34IfAtYBQwh9Vzyt2KMD+yvpoKCgrj7IGqPrpyR+u/9k+pPS5IkSdLBunLGnnzRXvNGCGFpjLGgoWWteWX4b0A10HOv9p7A2/tY5+199K+q2R6kgvBdMcaimvlXQwgnknoGeb9hWJIkSZKUTK32zHCMsRJYCpy916KzSb0tuiGL9tG/OMb495r5TqRCdl3V+A1lSZIkSdI+tPbbpKcDvwghLAFeIvW26F7AfQAhhIcAYoxfqel/H3BNCGEG8BPgM8BlwMV1tvk08O0QQimp26SHknpr9UMtvTOSJEmSpPapVcNwjPFXIYRuwM3A8cBK4JwY45s1XU7Yq39pCOEc4D9JfX7pLeC6GOOTdbpdC9wG3Av0IPVSrfuBW5EkSZIkqQGtfWWYmrc8N/im5xjj6Q20vQjk72d724FJNX+SJEmSJB2Qz9VKkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDsCRJkiQpcQzDkiRJkqTEMQxLkiRJkhLHMCxJkiRJShzDcBubM2cOubm55OTkMG3atA8tr6ioYNy4ceTk5FBYWMi6desAeO655/jNfwzjyf93CsOGDeOtNS/UrlNZWcmECRMYMGAAJ510Ek8++WRr7Y4kSZKkduhAuaS6qoJ5MxvOJcOGDeOUU1K55IUX2k8uSWvrApKsurqaiRMn8txzz5GVlcXw4cMZO3YsAwcOrO3zwAMP0KVLF15//XWKioqYPHkyv/rVr+jevTuf+9rTHH1sL64/ayWFI8dwyffKAbjjjjvo0aMHq1ev5oMPPmDz5s1ttYuSJEmSDnH7yiWwJ5e89vIDpB/VhT+/8uFc8vTTT9OrVy9WrlzJmDFjKC9vH7nEK8NtaMmSJeTk5JCdnU3Hjh0ZP348s2bNqtdn1qxZfPWrXwXgggsuYN68ecQYGTp0KEcf2wuAvLw8qv++i+qqCgB+9rOf8Z3vfAeAI444gu7du7fiXkmSJElqTxqTS95cOYv+n2o4l/TqtSeX7Nq1i4qK9pFLDMNtqLy8nN69e9fOZ2Vl1Z5FaahPWloaxx57LJs2barX58knn6RbZj4d0tLZunUrALfccgv5+flceOGFbNiwoYX3RJIkSVJ71ZhcsnNbORkfP3Auyc/PJz29feQSw3A7t+Wvq5g8eTIjL/oJAFVVVZSVlfHpT3+aZcuWMWLECG644YY2rlKSJEnS4WzVqlQu+clP2k8uMQy3oczMTNavX187X1ZWRmZm5j77VFVVsW3bNrp16wbAe1vLeO7n5/HQQw/RuXs/ALp160anTp04//zzAbjwwgtZtmxZa+yOJEmSpHaoMbmk07GZ7NjacC4pKyvjvPNSuaRfv/aTSwzDbWj48OGsWbOG0tJSKisrKSoqqnlQfY+xY8cyc+ZMAJ544gnOPPNMQghs3bqVZ+8/l+Gfn8ZnPvOZ2v4hBL7whS8wf/58AObNm1fvhVySJEmSVFdjcsmJg8ayZknDueTcc89l2rT2l0tCjLGta2gzBQUFsbi4uE1reOaZZ5g0aRLV1dVcfvnl3HTTTUyZMoWCggLGjh3L+++/z6WXXsorr7xC165dKSoqIjs7m9tvv52pt91J5+796f0JWP8O/OPX5/LwLT148803ufTSS9m6dSuf+MQn+PnPf84JJ5zQpvspSZIk6dDVUC7JHzOF701M5ZJ/+eH7vPjIpRyx48O55M4776R///6125o7dy49ehwauSSEsDTGWNDgMsNw24bhg3HljNR/759Uf1qSJEmSDtaVM/bki/aaN/YXhr1NWpIkSZKUOIZhSZIkSVLiGIbbkStn7Lk9QZIkSZL2Z86cOeTm5pKTk8O0adM+tLyiooJx48aRk5NDYWEh69atA2DTpk2cccYZPDg5g2uuuaa2f+X72xkyZAhDhgyhW+YQunfvzqRJ7ey+6ToMw+3EnDlzePz7uTx2R8MHcnVVBfNm7vtAzsiofyBv377nQB4ypP0fyJIkSZL2qK6uZuLEicyePZuSkhIeffRRSkpK6vV54IEH6NKlC6+//jrf+MY3mDx5MgBHHnkkt912G4Vj76rXv+ORx7B8+XKWL1/O+d9azoknnlj76aT2yDDcyj7K2Znq6mquuuoqOnbqwnvb/spdd91V70A+/fTTeXTqCby1eh4ZGRlcfvnlHzqQ77qr/oF8zDF7DuTly9v/gSxJkiRpjyVLlpCTk0N2djYdO3Zk/PjxzJo1q16fWbNm8dWvfhWACy64gHnz5hFj5Oijj2bkyJF0+NiR+9z+to2r2bhxI6eddlqL7kdLMgy3oo96dmbJkiX069ePwrF3ceoX/4P+/ft/6EA+pls2n7vyaZYvX84VV1zxoQP5yCP3fSCvXt3+D2RJkiRJe5SXl9O7d+/a+aysLMrLy/fZJy0tjWOPPZZNmzY1avtvvFLEuHHjCCE0X9GtzDDcij7q2ZmysjL69OnDcdmpszMZGRkfOpDf37GRjI9/tAO5qKj9H8iSJEmSWs/aV4q4+OKL27qMg2IYbkUf9ezM9u3bD7jt97aVM/u+z3HbbbfR1G9HFxW1/wNZkiRJ0h6ZmZmsX7++dr6srIzMzMx99qmqqmLbtm1069btgNtesWIFH3xQxbBhw5q36FZmGG4Hjj/++HoH8o4dO+odyI888gjH9xvNiPN+zO9//3sefPDBJh3IVVXt/0CWJEmStMfw4cNZs2YNpaWlVFZWUlRUxNixY+v1GTt2LDNnzgTgiSee4Mwzz2zU3aKPPvoo/Ya2/4tphuFW9FHPzpx11lmsWbOG7ZtK+aC6ijVr1tQ7kDMzMzlx0FhKVzzBJZdcQlFRUZMOZK8KS5IkSYeXtLQ07r77bsaMGcPJJ5/MRRddRF5eHlOmTOGpp54C4IorrmDTpk3k5OQwffr0ei/47dOnD4tnfZMHH3yQrKwstry9511Hjz32GP3y23+GCE29pfZwUlBQEIuLi1vt96qqqhgwYADz5s0jMzOT4cOH88tf/pK8vLzaPvfccw+vvvoq9913H0VFRfz617/mscce45lnnuHiyyZRuWsrg/Oyefnll8kfM4VumUN59P+dxrd+nsH8h7/MO288S/fu3XnhhRfIzs4GUgfyu+++S2VlJR//+MeZO3cuAwcOBCA7O5tnnnmGk046qdX+HSRJkiQd+q6cAfdP2jMN9efvbwdfZg0hLI0xFjS0LK21i0myumdnqqurufzyy2vPzhQUFDB27FiuuOIKLr30UnJycujatStFRUUAnHPOOXxQdTXxgypWrlxJVlYWp/7zXDK6nMiYMaMo/evfiR9Uc8UVVzB9+nQ6dOhQ+7u7vznckLVr17b0bkuSJEnSIccw3MrOOecczjnnnHptt956a+30kUceyeOPP97guuOnrAM+fHZm6dKltdM/agdnZyRJkiQdeva++nu485nhw9SVM/YczJIkSZKk+gzDh7h9hdo5c+bw+PdzeeyOnHoPuu9WXVXBvJnjyMnJobCwsN6t0nfeeSc5OTnk5uby7LPPAvDaa68xZMiQ2r/OnTszY4ZpWpIkSWpP5syZQ25uLjk5DeeEiooKxo1rOCcsf/5OHruj4Zzw6x+m/g6nnGAYboeqq6uZOHEiYybM5p8ml/Doo4/We7sbwGsvP0D6UV14/fXX+cY3vsHkyZMBKCkpoaioiFWrVjFnzhyuvvpqqquryc3NZfny5SxfvpylS5fSqVMnzjvvvLbYPUmSJEkfwe6cMHv2bEpKUjmhpKR+TnjggQfo0qXhnLD2lSL+afKenPDBB3tywvnfWs6X/u3wygmG4XZoyZIl5OTk0Ll7Nh3SOjJ+/HjeXDmrXp83V86i/6e+CsAFF1zAvHnziDEya9Ysxo8fT3p6On379iUnJ4clS5bUW3fevHn069ePE088sdX2SZIkSdLB2Z0TsrOz6dgxlRNmzaqfE2bNmsVXv9pwTsgeOp4OaXtywjv/Vz8nvLX68MoJhuF2qLy8nN69e9fOZ2VlsXNbeb0+O7eVk/HxVJ+0tDSOPfZYNm3a1OC65eX11y0qKvLbw5IkSVI705j/16/bZ++ccPTH98oYW+uvu/aVwysnGIYPA3/60594fekj+3x+uKKigg0bNjB8+HAef/xx3nnnndplK1as4Jprrql9LqCyspKnnnqKCy+8kOrqaoYOHcrnP//51twdSZIkSU2w+znha665hhUrVnxoed3nhNeuXcv69etrl23dupXhw4fz8MMPs+WtPwHw/vvv89RTT7H4qX8jLy+P7373u1RXVfLmqlROOFz4aaV2KDMzk/Xr13PCIPjgg2p+9rOfkXvq1yg45w4e/cVwunTpwvZNpcyacSrTjryGo48+mqqqKtauXcvFF1/MAw88wMsvv8yiRYsoLy/nkUceobCwkLPOOosRI0awc+dORo0axejRozn55JPZsmULn/rUp6ioqKCqqooLLriAqVOntvU/gyRJkpRIc+bM4frrr6e6uprLL7+cBx54gOeee46ysjLOPfdcli9fzp133snzzz9Pp06d6NmzZ+1zwscffzxnnnkmJ5xwApMmTWLbtm28/PLLnHnmmbw6/z94c9VvyWMCgwcPptOg23jyhwWMHDmS2ONoumfm07Nnz7be/WZjGG6Hhg8fzpo1a+jyqVJ2bFlPZWUlA4ZfRoe0jlx00UX8+7//O58880be21rGT3/6U8rKykhLS+MHP/gB3/nOdxg6dCgjRoxg3Lhx3HvvvXzrW98iPT2djRs38pvf/IYZM2YwaNAgRo8eTY8ePdi2bRsPP/wwX/rSl1i7di1DhgzhoYceolOnTkyYMIHrr7++rf9JJEmSpMNK3cB72mmn8Yc//KFe+P3tb3/LLbfcwne/+13S09O57rrr+POf/8yuXbv44he/yJYtW6ioqKBv375MnTqVnj178r//+/+zd95hVlVX//+cafQ6gCC9qRQVFcWGXSyxRGNiyasxxhiNacYYE2OM2H4aW4xRY4vy2kWNGkUUu4IIqIgI0nsvM8D0tn9/fNdmH27uDMMww4Dv2c8zz9x711l77VX23mutXc57rFmzhsrKSkpKSrj88svJycnhmWee4a677uK88y9i2Ol3cM89l1NRUcGIkw+ivLyU8vJyVs0eR7/9z2tssdRrSbZJ74IlKyuLf/zjH7zx4Am8M+r77LnnnrTrMojP3riOadOm0aJFC/Y59mpKi/NYtGgRVVVVjBkzhmeeeYaJEyfinOOxxx7j3nvv5eCDD2bNmjXMmTOHDh06UFxczNixYznuuOOoqqriJz/5CQcddBCXXXYZHTt2ZM8996SwsJATTjiBsrIyrrrqKnr27ElWVhZNmjTh1ltv3eI69x//+Mc1Xu2elKQkJSlJSUpSkpKUpCRFxfvRffv25Qc/+AFlZWVUVVXxxBNPcP7555ORkcFf/vIXCgoKOOqooxg3bhyDBg2iadOmzJw5k3nz5nHYYYexePFiWrVqxbnnnsu0adOoqqriwgsvZOXKlVx77bU0a9aMZcuWkZWVxYUXXsiTTz7JoEGDaNNxDz565iLWrFnDJZdcwst3HkCnTp048sgjWbf0c3rtc2Zji6heS7IyvIuWk08+mR9cczILpr5Ar6yxABxw0g00nfdLWrZsSVZ2U/Y++kpaVs1i+fLl9OvXb/OqcVZWFhMnTuSEE05gyZIl5Obmsm7dOpo2bUpmZibFxcXss88+rF69mpdeeomePXuSl5dHVVUV2dnZNG3alEceeYSZM2dyxRVXMHbsWO655x7uu+8+nn76ae6//37ef/99unTpQtu2bXn11Vc5+uijOfBAbeG+6667/ivDdfHFFzNkyJC02a8ElsC2Bmts+gksgSWwBLYz0E9gCSyB7dqw+HbnxYsXc8wxxzB69GiaNWvG8ccfzx133MHnn3/OH//4R0aPHs1+++3H3XffzZlnnklhYSHl5eU45+jYsSMAEydO5Mknn6Rnz54sXLiQs88+myeeeALnHF26dKF///7MmDGDnJwcBgwYwLJly8jtOoQ9h/2EJZNu5de//jWLW/2Z2y/M54wzzuA7v/iAnGZtGjMEqv/inPs/+3fAAQe4nb1cfLf+Uj/776f+eoIbMWLEZti5557rhg4d6i6+27ljfzTaHXnkka579+5uwoQJ7s9//rPr3r27y8zMdIsXL3YjRoxwLVq0cD169HBr1qxx3bt3d1lZWe773/++a9GihcvJyXFRFLmcnByXlZXlzjvvPJeXl+e6dOnimjZt6l588UXXqVMn16dPH3fVVVe5QYMGuUsvvdT179/fOefchAkTXP/+/d0tt9zinHPupptucu3bt3fz5s1zRUVFLicnx40dO9aVlpa6vffe23Xv3j2BJbBthjU2/QSWwBJYAkvGogSWwBJYfcD69u3rDj300M1+c+vWrd0tt9ziRo8e7bp06eLatGnjnHPue9/7nsvOznadOnVyS5Ysccccc4zLyMjY7NMffPDBLooi9+WXX7rLL7/cHXHEES4nJ8eNGTPGDRgwwF1++eWuXbt2rlu3bm7IkCHutNNOc927d3cbNmxwu/c/1rXuuId78cUXN8cbzjk3cuRId9Bpt/9XLLIrFGCKqyYeTLZJ7+KlY3edH960bgGVFWVMmjSJnJyczfDCwkKi1kO46MpRm1d3O3TowNKlSznqqKMoLi5m48aNbNy4kYKCAqqqqrj22mu58MIL2WOPPcjNzWWvvfaiRYsW5Obm0rZtW3r06AHA7373Oy644AK6d+/OypUrAW3hzsrShoNly5ax++67b77OvbS0lBYtWtCnTx+mTp1Kz549+fzzz8nJyeGwww6jadOmCSyBbTOsseknsASWwBJYMhYlsASWwOoDdtBBB1FWVgbA+vXrad68+WY/OooiMjJC6JaRkUFFRQUA7dq1wzlHRUUFZWVlzJkzh8zMzM24zjmiKOLll1+mefPmTJkyBecc99xzD02aNOG118dy++23s3LlSlYtnMBeh/yU4cOHk5+fD0BxcTHjxo2jbae9GiymaaySBMO7eMnIDOeHX7h1ABdccAErVqxgwou/ZMOa2XzzzTfsd8L1lBat4/HHHycvL4/LLruMUaNG0a1bN5o0aUJJSQknnXQSN954I1VVVTRv3nzzOYLs7GzKy8spLy+nXbt2FBcXs2jRIsrKyhg+fDjDhg2rdVvz8vJo2bIl8N+Bck1BdAJLYDXBGpt+AktgCSyB+bKzti2BJbAEtmvAcnNzKSwsBKB9+/aUlpYCepNMYWHhZrzs7GwqKytp0qQJ8+fPZ9KkSbRt25aVK1cyfPhwhgwZQhRFXHvttWzcuJHZs2dz8MEHs379eqZPn86kSZO45JJLGDx4MNOmTWP3/sdwzTXXcOCBB9J1zxHsc/TvWLFiBUcffTQv/nUfDjzwQI4//nh6DPr2vW41CYa/BUXnh2dz9rXzuO666/jHP/7B0llv8s3ER3TGt3k7Wnfcg5YtWzJkyBCuvvpq1q1bx29+8xtycnI444wzmDVrFrm5ubRs2ZIjjzyS0aNH06ZNG8rKyrjooosoKiriwQcfZOjQoZSVlZGRkcGll15K165dWb58OZ07dwagoqJic5bKw7p27QrAunXraNGiRaPJKSlJSUpSkpKUpCQlKUnZWUu7du0oKCgA4IgjjmDTpk00a9aMfffdl02bNpGdnU1ZWRlTpkyhXbt2bNy4kVNPPZW99tqL3r1707p1a+6++25OOOEEmjVrRq9evXj77bdZvXo19913H7fddhvZ2dkMGzaMF154gQMPPJARI0Zw4s/eYNSoUWzcuJFN6+bz0u1DuOCCC7j55pv53u+nMX36dK677rpGlk7DlCQY/hYWHxyf8+f5PPnkk7zx4AnM/+JZLrvsMlasWMEBx19FXstz6NatG++++y7l5eX069ePu+66i9/97neceuqpLFy4kIMOOoiSkhIeeughcnNzN19+tX79eioqKrjooou45JJLWLBgAYMHD6aqqorx48dTXFzMggUL2HfffVm0aBH7778/ZWVbbuFODZRrCqITWAKrCdbY9BNYAktgCcyXnbVtCSyBJbBdA5aTk0NBQQELFizggAMOAOCZZ55h8ODBtG7dmtWrV9OxY0eGDh3Khg0bOOWUUxg4cCAffPABJSUlHHLIIfz2t79l9OjRXHzxxUydOpVWrVpx/vnnc9ppp3HUUUdRUFCgY5RRxMaNG/nyyy956fYh/OIXv+D111/ne7+fxplXTWXq1KmcfPLJfOtLdYeJG+oP+DmwACgBPgOGb+X5I+25EmA+cOn21un/vg0XaG0r7PXXX3etO/Z3rXL7uJtuusldfLdz+434s3vllVecc84VFxe7s846y/Xt29cdeOCBbt68eZvxcnNzXVZWlsvNzXUjR450/fv3d3369HE9e/Z0mZmZDnCtW7d2v/rVrzbDzj///M2fR44c6Xr37u3mz5/vCgsL/+sygW7duiWwBLbNsMamn8ASWAJLYMlYlMASWAKrD9g+++zj7r///rR+9E033eRef/31amF1jS/89+2F7cyFGi7QigTfMSWKorOBJy14/dj+/xgY6JxbnOb53sB04F/A/cDh9v8c59yLdakzXoYOHeqmTJlSP8w1UPnp3/T/4d9s+XlHwBqijBkzht/85jdUVlZy2GGHMXHixM1Xye+3334JLIHVCdbY9BNYAktgCWxnoJ/AElgC2/Vhf/rTn+rF507n41fn79cHbGcuURR95pwbmha2g4PhT4Fpzrmfxn6bA7zgnPtjmudvA850zvWP/fYIMMg5d0hd6oyXJBiuP1hSkpKUpCQlKUlJSlKSkpSGLQ0d1CbBcMM1IgcoAs51zo2O/X4fMNg5d2QanA+Br5xzl8d++z7wNNAciOpQ5yXAJfZ1T2BWPbDX0KUDsDbN5wSWwBJY9bDGpp/AElgCS2A7A/0ElsASWALbkTR2xtLTOdcxLaS6/dP1/QfsDjjgiJTfrwNmVYMzG7gu5bcjrJ4udalzV/wjts+dlD3vCSyBJbD0sMamn8ASWAJLYDsD/QSWwBJYAtuRNHa1v+Q26aQkJSlJSUpSkpKUpCQlKUlJyv+5krX1R+qtrAUqgd1SDFKOZAAAIABJREFUft8NWFkNzspqnq+w+qI61JmUpCQlKUlJSlKSkpSkJCUpSfk/XnbYyrBzrgy99uj4FNDxwIRq0D6p5vkpzrnyOta5K5aHqvmcwBJYAqse1tj0E1gCS2AJbGegn8ASWAJLYDuSxi5VGuPVSk+g1x+NBy4FfoJuh14URdH/AjjnLrDn/auVHgYeBA5Dr1Y61235aqVq69xhzCUlKUlJSlKSkpSkJCUpSUlKUnaZsiO3SeOcey6KolzgWnQB1nTg5FjQ2iPl+QVRFJ0M3A1cBiwHfuUD4VrWmZSkJCUpSUlKUpKSlKQkJSlJScoWZYeuDCclKUlJSlKSkpSkJCUpSUlKUpKyM5TkNumkJCUpSUlKUpKSlKQkJSlJScr/uZIEw0lJSlKSkpSkJIUoiqLGbkNSkpKUpCQlKTuyJMHwLlq80xJZqQb2X/rdCiyjAfC2CktXGoHeduFVA6vWsdzR/G0P7nbw2Cj06oBXpwCgJh2ma1c9y6HWvP4f0MN287Aj2rw1O6llHQ0arDo7NxVFUUYSGCfl21QSe971yrddZzuav+31deoTtrOV5MzwLlyiKMpwzlXFP0dRFDnnXBRF2c658tTn7HtNsGbOueIoijIBnHOV9YBXE6wVUAK0Bjb6+huJXl3x0sKiKMoC2gKtgBxggb0OrFH4S8HNTgPzuG2B9dXUuwWsFjzuaHrbjLcVWEugE9ANvd/8C+dccYxetnOuPI3+MuvJJuvF7oDMb5EeqoDPUvRQHzysATbVRp41tHk10I7q7aXadsaeqdbm6mqrW4F1BHoBewH5wHvOuYLUdqVp5xY2Xx+wuhRzuKL6rDMdDZ8oqC+8rcBSx5Ptlllteahrm+urLVuxnTrhpT6H8j6bEz+7mu3UBN8WfurLPusJr0YYMZ3Vtnwb+GsEenXGqwtsZylJMLwLliiK2gIjgAOAvsA7wBin11N1BU5B71ruArwPvIXex9ymBtjuwPeAM5Ez+AnwLjARKDK847YRLzLYGWlgLYAfAucAmcAUYJI9sxQ4agfSWw+cWAe8EuC71cAi4FzgPGAj8BWwEPgYmAYMrYMe6srfFOQIp6t3EtAU+J80uJ8CBYaTDlZpNNPxOAcYvgPpLQVOqAPeOtNhOlgxcDZwOrASWGzt+wj4ANgzjQ4/Bwqcc86c9D3qqLNiw9leu5sLZAMdUBD50S6uhxWmh0JCXzp0O3koQkFwB6AcmAx8WI08a2rzUqA9eivCanvO28tXNbRzonNuo9nLscDlMV6XWds+RH3quFrKKI63FI3f6WCeh2OAWYBDdvEe8KhzbkKa4KGJPVcONE0J9pvYs2UWZJebDLOszdXhtbHnIpRMWB/DiycwuqAkQFvjeVEt68xxzq2qJSyVxpwY73XFqwnWHyU3uqFxZnItZV3btmQC82spz1q1ObVsh1xq4r1OeCntOgDojPykb4C3XVhAiNtqE6AiJpc4P6kyqwlWo8yqk1Mt8NLCtyK/CMjYXl03hI62AqtJZ3WS/S7E346mV1e8tLAoinKAI4D+QD80v73o0iR9d7aSBMO7YImi6GlkcPOQ03AU0BI56C2AjsgINyGHugPwJZpU2xAcxe/GYE2BMmAs6oQ/RU7+IuQsNq0DXpU9PxY58BfHYFloxeoZe+6PVleRtTNCAUMhcuI6IMe3SQPQyzE5vpGCtxg5EtXhtUAO6lPW5j8YrJgQ+PzDnrvZ2lCBBp8K9F7suI6mG38l9czfi8gRb4kCtmEoOO5vPHrc55CznmPtiWI8PhODdUSljfH4AHC1yaAJ0BwNlGuB/wCHxOgticm0Pul1RYHf4yhYyDGaxHSRDq8nCkruBK4xWDP762Wyvsn0WGl6a2t4pSig6Al0RxPKdGvHw8A4FFS0rqXOfmvPFrOlbW2P3f3d5FZs9WwCetNwem9oPVxpMmhrfAxA4+Aj28HD360dxUbPOyKbYs+l68ddYm1uajwXozGrjbUrD8hFq67zgIdiculsfBYb7vPA2yh4vs/ach/qLxEKsj8DbjF6t1pbnLXlDZNRa+D+GF4vlDD9Uwos02AvIvtqBTxtv2cbj//POfckQKRdDccDvwKGoFXkD5GdTwIGARcCh5uMI5QcWG+8t0LJvnUpeIcCPwMOQn2kyuSXZ7L41J4/ALgU2BslAfKszvZorHnf5PdpSp3r7bdP0ZjbC42r6WD7otc4ehpzgdkogdQauKAOeN2Bi6qBDQZ+jOx/rvG0FnjT5HSqyXNjDTKrqS1rkI20AjagxMl4k+v+KfKsbZu/QOOHMwf47Fq2ZVt4b4qSVduK9y4wE/WJm4EfoX47G40LpcCr9v24NLKdiJK4l6Th50Pk4F9cDSzVPuNtfgcl3NPJqQNwUg14Z6MEWSq8NfIDe6BEVhEKaN5EAcgyv8oXRdGlNeihtvaZSqO2OkrF62R46WD9UfI4nc6WA6fVQfa7Cn+bgLN2IL3I6G0rXhs0LqWDdUOJ1Y3I1xuE7PRl4C7n3BR21uKcS/52oT/gSDTwD0Bnvo9GhvglyvpXAdfbswfb928IWflRKbBZqBM6tBIACl6q0AqCD07fQYNDHK+wFnhvGV4cVmKwsSmwIhRwOOBr5OTE6RU1IL3pRi+OV1oLvGkpeDXB1th/Z58HpuiouIH4K0OObe8YbAlyIuYa7rPItqpMr+VoNaEKOTUjYrAKFESlwlYbvSX2fxFKnFQh52mD4TUUvYUxeh5v0TbiediyGOx0gy20tvtnNqEJqgo5iGsJK1Ub7PliFED8Lka/Jp3Fdf0FtbetdLAjrE39kZPnTCbzUP/a1fQQt6V8k0+5ff5hHXk4yWSUC/wTBYrO4OXVyDrej1cR+vEa5Hh9QVjNq0Irs5VoDL4o1hbPu0N9tNz+X2Jt8Tx5m/KB8xlo3K+pLdXhHcWWthyHeTuYam3zNnUnGjsOR7azDiVQJtv3SjR+rUD2/P+Q/ecZbCWy92Jr48IUvDXAYyjIzjOZrDS9bLDPC+3zjWg14roYjZXIUU5X52XGz0STxwLkSKfCFqfQOBPNCW8bn3NMf4+hgMbjLa0FXoHBTo/BvjBYobXjSDQWj0VJ7ZlG723g2jSyro6/eFvOMRnOBGaY7AuqkeefjJc5JqOCGOyaGGyh4f8J2A8FlEusLX+ItWV5LeRSHe9+LvxrTGbvoJ0QNeHNQLZ5A/AT+3wWCvovNP6nojGlGCUGfoz62jrCnLXW+Dna2rDS/uK2kwqrSZ5fA6Nicorbz2o0Jr1eDd7/Wv2p9jPb8N5AwcnPja+vkK/0BgpOjkbB/UqUKDsZ9Z3a6HpRTNapNBbHdJSKtwSNHdXhlQBXpIEtQT7X/6Bk3PkpOisB/m083RaT/QrUV7bVlncm/pajsf+BNPSWNyC9G9LgLd8KXjnw6zSwlQb7H5SA62VtvtHgnwNHmW+b0dix1H/FVo3dgORvGxWm1YA3Y9/vQc7a/dYxysyQ/4ky/pPQyoezTlOBJo830KR0j8FKY7AxyFH0KzTeKZqBJp3PgL/VAq84hvc+MAGtQPi2eNi7aAXNBxYF9ky+tfFz4K4GpFcUozcJTVJX1wKvOIY30Wj+yGAlMdgEwz3FYOsJzuYMNOk91ID8LY+15VNrq8dbYPTK0NbN95EjUYUCCkdwwD6M1TknBptp9E412HT7vRIN6FORg9xQ9KbG6C1GNnNFLfCmxPAWmVwuNNgnMdhCk/XpMbwy+7wOOWR+lXaF6cIHZAXI4XHI+apOZx+kwIpNTrPS6LO2dvcBSpINtd8moglvDHKsdzU9eFu6mWBLZSbjWXXk4QuT/1EGuwM5m4sI24+r68ebCP34XcO5zGDeYb3WePWB8VrUP0YSklJVMbkUxGhOM5qnEcaNcvubZ7r18i2IteWLFLw803W58f4FISiPw2YZzAfhfjeRt/NlptMqtILsx5aVJp9y5FQ9i8azA9EOiUUGu8Z498mi6UY/Hd4DhIRNubWxCnjE5r3RVvdJKDB0JoPUOp8g9JmSGL+3pcBKTb4eNspgnq98gz2Xgle2Fby8GF4cVhHDew4FST5QrULOfSkar/3uEO8U18RfvC1ensPs82eEhFiqPH3bNtj/KtSfmqSB+bGrHI1tH6FVpKWxtsT5SyeXmnjfkIb3fGTfNeHlE+bQSuSk34Js+nF7zid/K6ztp6MdGT4B5/vin00uXr5+x0JcZjXB4jKrjOmvSYrOKlHfKkmRUxxvRYoe8gnjQVGKLFYRxjbvu5WiMe4sNJ4+Qe11HYelozEbJeDidbptwBtVA+zRGnT2Qkz2nl5dbHln5e/5HUzv2TriPVUD7GQ0372FbPUjNEbsHotfclCirEVjx1bJNuldrERRdBLwIHCqc+7LKIpGAwudc1cZ7FlkkPmErWaFht4DDcD5aFtdKRpMVqNsVAUamDuhzlCMHI3esXp6oW10lch56lcN3gqrsxB16B7I8CtQ9qk3WtlejbbONSN0wF7I8apCq1ot0ZaOT+17fdL72vDWWz19TW6gztunGrxpaHuJl3UvdNYtQs5vZ6tnJdo60tFgkwxvDsqe9TO8TDRR7VnP/E0Grrc2+TONnr930AT8lNWVQwg8pqDVzDHWztYGj5Cj/wuDtUcDdNMY7DcoONiEts3mWNvGAbc3AL2LUNIgisEz0SD8qxrwzkEBT3u0VbdZDO9Mk1l/+625/X/T5PkyCvgGW3uzrc4yk383ZL/tUR/baPVXp7N0+nSEs6x1sbt2yH4d6k9j0damCrTisKvpoZnJOcNgdxgPkbWzrA48RGhbtDPYJPs91+ral/T9+D3TS0vkQFSirasZKKj9j+mwEK1UfGRy72y8ZyNbmoC2xe1rdbe1+ucg++lrsngHjQdZyMFoi7ZeZ5ssmtuzK6xNHm+cya27tTMT2CdGvwwFSyuR47y/yWqs8QvaYuuQrUWEFYdXre3D7PemyNYXoKTFBnR+fJnpwFn789C49z5KiLREY9wCFIDnG956+9zf4P2MxmKT5Wsm98tQcncYSnqcGKtzHQrc90ArSlmmzzI0tz1hejrGZNPeYKtQANUFOXVZpp9Ka9OLBhtmsqwOD/vsA7nnkN0Mt9962P+1aDt/K2tLC6szE9nQ28h2+hm96vjzfa/M5DnZ6j6BsDPnEKTrPjF5ViEnuzvaxl9uOltndY1G9nem/dYFjWmZVodDtv8C6juDUD+vTi7lNfAOGuMio/GawfYlHBeoTmbtTFcrkJ6bEsbYN5Ftn2Zy2NPaUYkScB2Q8++Mr4lo/noK7cQ7Ddldc5MZyH76IeefauR5srWtjbW5HPWdLmjXUJnJ2icXHo7hNSUcAygFXrJ2nkI4coXBnzIaxxDm+VJkJ/44ShkKymuj61MIx018wP6c1Xs2sqGO9nsRGlPboMRiZjV4Z5ls2trvBWhVvBm6L6EJsm0/Z3qdfQeNUb0JybGPrZ4hSMfbass7E38nof65O2GH0IdG4wBk0/VJb4TR8PdklKLkeRbaht60GrxjCHNqOWGHRSZhrmxGSAQ2Rf2rDUpKd0Vj54P2fQDyFbs653yc0jilsaPx5G/b/tAg9w7K9F2KHMlzDNYcGVolcoJGoQCyCnWafxtsLHA36jRVaCD3K5OTgXvRYF2FMr6vGN7raKVjVC3wTkfn+Jy14XrgXwY7lbC6MxdtRXkwRs87Oa+i7PedBjutAeidjiZphxzTX6MAsQoNltXhnWrfHQrg/4i2IXm8KwkrhTejrUleD28Yfy+jwfoa+94Q8jwVTSAb0QTyJkqY+HZGMdwlyG48XhTjcSGyrSrgFLM3z+NqZCO+ziaEldIp1pbKWJ31TS+LsFNhnsmlEiWMtob3J4OtBJ6MtTMLnSusQIO67ztnoSDhbfv+DtJ7ieH1IKyS3E1YXRu/FZ3dmQL7K9tvd9eZfP2q8D0m13N3UT3kx+R+FnK6HzC8pXXkYRVhxWwGOpv3k5icquvHp8XavAIF+343iQ96lqEV7ng755qMvL3kIkdvodG+JVbHXUa/Eo0TN8bo/R5tbS5BY0PcVlPxfhOD3YHOvZYY7IfIESpCjv2v7PufkbOyFs0xXdEKgSMcu5ltsrgIjZn5yBlbQ1h5/AFhC94ylGz4NVotPgXZ7yYU8MXxfo6CvCvs2d9aW/JRQJBHWDH50mS3FAVrvs4iq3etPXce2qKab7DiGL1zra359ntRDPZ9wpbjQqu7vJZ4xxteEWFV1M8DPgnhV3Q97Azjf6nJeRNhJ8oFW+Ev3ha/UlqFEgZPA7+0eq+OyfN1q8+3+y+oX+Qjm1gTa9tTyEZWorlqYYxGfqyd52xFLjXxfqzR9zbh6/xeDXjnI9/k1/b7N4RV7CdQ4t7X80805q1A4+4q478KjZF59veByd/L92777O8X8ccuqtB20+rkeSbalVKJ5l+/sl+Fxu7VRrcgRU5nor5diZJpcT383ni419q4Lgb7KRp/8tBOwqkxHb29Dbr+HbKVTab3FTHYdYa33tqwJCbfK2vA83VuQLsZ58fwLiccK3gsRWe3m95Xo3F9UUxn19cg+12Fv+uMv3VoF93sGH+/bQB6V8bwbkMJeE/v5zXgxeu8D/l3Hu8iNJcWG94K1Ee8TV6L5pYVyJ5vRwH/x40dVznnkmB4V/xDGc1nzEjHooH4EuTYPGMGPpFwc2wJmsDess42GTnn75qR/xplvVbaM1+g7WblaLCebDCP9w4aoLeG588xvYMcFr999maDzUaZ5DmEs2//IpzniNNzDUhvlv3F8Vwt8aaioHY+YbueH0A+RRPvSjQ4OzRYL7c6dyR/HyAn/x3Cud1RaXD9lupxaXhcSVhBS+XRO6dTjcdl9nlH0htfR7xxyNHfmAb2Ggp6fDvnGZ08tEo7GQVRznTkV0BnoYDsu2gC2Bad+TZPrUGf22p3fkVi7bdMD+uRg1kfPGwgOKOrtyLP1DavjcFmxT7H2zm2hrb4rPwZpuc/EVaHXayOF9LQG5Mio3R4TyCncUEa2Ci0zX5SDPYlcmT+F626RCiwd4SLrb4CNtictDthW3Ocx5dQoOJhT6NkQKHh5aKVBd+e1TG8y9EqfiGwm8ncoR00fyLsHhqNHMFNaer81J737eyBkp6OcGmSh8VpTEN91sMGWl3evl6sJV5fNJY75Ci+EoN1R/O1M529hWy/PVo5nmv8/S+yvw214C/elqnI8fTyvBI5z5vSyPPPKNm6IaXN8QTxBrTi+3OrIxOtbk6zZ99E/a46ubxbS973RzsvHHK2n6wl3qEoyM+3tj1g8luBHPe7rd2noyDeB7j/g8btDSmyfd34foWwG8vbzstG618Gq0meXdDChQ9gNtsPWn3z7axMg/cTQiCy2X7Q7oAbCSvbI9FxuA3IVq9Dr4fDaPik6LboOi7rmSk0hsZ0NAH11atqgbcvSix72F8M7tv9aDU6OxmNN96WL0Z2uDXZ7yr8HW9tj9O7tAHpHYX6axzvqlrgHU7Ywu1ht8RgDyGbXI7G87fQ+H0SIaExDCVsP7d6TmvsmMq5ZJv0LlvsZs8TkKMx0H7uipyUO5FjdYrBmyKDHIOyXNko63g+2npREoOBLt65HG05WosG4Eft+5ko49sGGX1t8CpQZ78cDVz5aDJ51OoYgibq7shZewU5OF2N3netTtfA9HIM7yKjXbgVvDdQpi4fbT27mrDF+xU0aBSi7WhXoS0hX6PV3rfRQH0mGug7IKezwfhzzq2IoqgnWh3ak7D182U0qZciR7U3CvC6pPB4r/Gw2Oi+gpzzjWgAHoiCvd1iPLZGA+0+yPFuKHpvoWCgBAV6Q1Bmd2t4HwPPO+fyoigaibZ9LkZO0WvGQx6aePe3drYlbKkdaLrd2+rvYTr8BwooHjP9/aouOkN9ta521xutIAxAzt8qZOPdd0U9OOfWRVH0izR6mIyc4brwsAFl4vuj1aSBpm+/Zbamfhxvcx/TwxCUYHgPrSbsa+0cjwJeZ3UMMznshoKnx5FzcRUae64w+r9CF2J9ioKbMc65oiiKeptN7IMSZK+xZWDg8T43eYw2vFZoZXFfq+9d5IT5ywLPQSvW41AgMtPpPdpZaLveIcbPsaajUmTvzZADuQqNYwNRAO1v5G6CVhP8dsYVaJt0M5PZPDRnHWb/C9DclGn8LTW5jEdbQ48zuA8wsuyZj6qpM0LBbxNk+1+jselgVD5CfaNbjMZphjcV9cPmJs+OhufrrA3e2yhhcLLJ4IsYbLThXWztm211+jPeuSZPv1uqOv6q4yED2a8/mjAPjf3p5LkJ9ZF4m48xmgWmi+bAg865OwCiKHoZjT/r6yCX6ngvQcmjvtsosxIUKDyCAs5myMYvRHNeEerza0y2Xe2ZbsiWP06RbX/URzeioCFuO32RLWwy2Nbk+SBajDg/jZz6G42u1eB9hnZ4pMqiNRr3+6Bt9EUooVQC/N0590/ru35b/5I66NrL+ntpaHgdebxCNNdsDe9pk+UZJsM47AFrX6rOVqI5d4+Y7IvQHLI9trwz8fc6GtN3FL1RaD7zeP6Sw63h3WP0LjB9+J0oK1H8kYN8pn1RMqcYzUO3OefGAERRdAbwuHPOH9tr1JIEw7tQiaJoDxQA+4G8BJ0T8md3PgMWOOc22bshI3Se5QjkJK7HXomAboIstzreB74xpy6yurqii0z2RwP4khieP2v8YRq8XqgjH4o6hz+nticanPKxS6qccytjvO1mdR+Rhp6/HOTjeqTXDd1GeXwavA3225Q0eH1QkuFEq7/AQD0NbyNyzt9wzi2I4bVFzuIxafgrNB4/qUf+OiDnZ38UcG9CGeLdUUC1Eg1OH6bgtSfcRHyWyb0dcsgWI9tLx18rNGAPS0NvHnJ+Z9UzvXZo4kvFW4Qmgs+qweuMJhR/wVAngoNeiDKzTwOznXMVhufPqw5CwUKefe9u/K213z5E/eM4k0Mp0ndROp0hmzneni2yej5Po89a2x3Sra+zxPTQ0eS/HK0m70p6WBDjZ6O15as0Mqo1D6arM+05v42zzOTpbzH+Mk27+6KVpBMIFxJ+jDL3q4BKZ2efrM97GvG2LDQ+WiL72WD1TMJW+51z662OXsh5PsnqiNC43SGG9yn/ba8D0MrCsfZMG2QzzYzX5ig4vx859+VoPMr0NFyKc2AJWFCQcCzaivm21ZWDkmzvI2fuOcL7zdva5xzjeZ7h9EZ96A7Ub/ZEDt+bhtMJ6b4Zso/7UBDQAp3Vv53wVoN1SPd909T5HArumxtvo0xnu6FEx2coqMBoTDXajxFejVZquplqeA+hftRuK3hVyN4+Nh38057LRXb3FJrLm6DVkvGor+YjR3w5SjqMtOdza5BZcxQoxdvyv6ajTlbvOsIZ+erkudy32TlXEUXRIShhtAT16ScJq9ZNkfP7IOq3tyM/o0OKXHqgxN+bhPP91fFejPrCZ8j5v8Vod6pBZrsZvU/sew7aEj4GBao5aDeBr3uqc25tFEUD0dh1ismv3GT7AfKBDkZJva8Iu2o+tmePQauzC02u1cnTy2y1c259FEVdCfbT3uR4vz3XPwXvJfQu3YVRFOUS7KcD4WjDfGvrbSghNAPZTqH5Ek1REnYsmhtqq+vFJuvZyF56xGjM8zpyenXTQSjJttHg6fCWoTHyU5Ov92P+gOaJb8w+lpguU3U2zzm3wMb5w9Bulmw0H9bFlncm/qYBi51z02Dze3wvt+dW1DO9UmSz853eI5+N4oRLUb+cUw1eJbLzmc65t20OH4zm702ov0412hmGe6F9/hBYHotNQInmFs45f09Ao5YkGN5FShRFNyKnqBRl+FoiJ2cDmpCaoAH7OTTo+a16f0MDfT6aMNoh49xo/6sIt+W+gzrB9uD9C60eLEcDU180cWwk3NhZjgabqWgQ24SyuTuS3uOGt4xw4Uxt8F5EA8cc5Fj5lZJC5GwuJWT05qPs2jR0zmWH8eecc1EUjYrxuLfxWU64+GCV8TEVrWQWosE2zuPByCGpJNxW653PuZ4/51xxjN5yNEg2NL2XDG8uCsJri/eWPfsVukiimekgi3BDbJXp8gnThc94noL6XD/D8ytqfhVnAnLy96qlzjohR2YZCg7L0umTbbO75sjxXrqD9N7QeihHTs8i48UHdvNQ4qAuPLQxOfrt7LXtx6/E2rzJ+O2CHBHvXPmExLM1yMWv0vkzoYvZMhnwJLK7R43n6fbs2dbOSvu+kHBRUBzvKeP3M8IZ0bbGU77x1BoF4yvRhV/PIgcqi5Dxn4+covnIyS5GJQOtDGSg82B+1X0xWqFcYW38hcHWocReFuE1gJ8hR64zcuD6ERI7ndGcthz1l4/RvJaNgpwBpqcu6ep0zm2wdhJF0e7G69VGoxAlPRwKtpfG6l/rkwCWUMyNtS2ONx/12erw+qKtqp2RbexOuKwyj3B3wxrnXKnhtTZde/7iMvva9JAqs74ms+WxtrSPtTnP5FSdPOPtHoG2kXY2PWea3Crs+0a0++BZNK55GqVoDHPI1lfE6u8Tk0M5svXqeB9Qjcz8mc/q8A5FRwBaEi7zehklJRYTbmfvgc6Me1vNt9/a2fdlaDxJtZ/haLdYP2tLWUyea1H/2VH2swbZhddDqiy6EOzCn3n9GAVLS+qo6ziNo9FW+3R4RabfdHhnol1KLQmXeYFsMwuN8y+jcXZ1TGcD0Q6YdLJfYbLYXltuTP4ORUF2OnoFyGbqk953UGCbDi+T0HdS8X5kcsm0tmYTbtlvh8b619BcPMXglSg5nDbIjKLoYJQgmp8OvqNLEgzvAiWKoj3RBHg54Ya5yWhiHGrf5yPj3du+T0eO26/RxRpzCWdwXkNnBnZDk+XXaPDsggb30SjwPo9wucl7aAvHUchpqw7vR6jDldnfBygLehwKkIpQBq+NfS9AzuN30Pbr1oQLdv6DVoRyG4CeX2XraHX/B2W3TyZsCUmHdyrKSvY2vNfQGZWyZB+hAAAgAElEQVQz7Pcy5DRXIGe8DAVIw9AlJrnIiX/KaJ6ABpP65O9Z09dD6AKNCWh73UWGdwBaMS4lBOdxvIfRmbXDUAbyu2glaCDhFsvVaIIuQ6su76PVi++g3QpXoazgmSgw3LcB6N2AVgFPRRPDaehylh4m13R476Fs/lAUWPzeaJ+N7PoCNMivIdzs+CVy8H+GtuUdg/rGb+35/oQVjXJkw7c65/5oK3RTtqKzh9BqxCw0ua9FgdKebLvdVaLbIF9AztQU0/uurIcuaLz7AXJ2ZxLOLLbYDh5etjr7mD6uNb0eQPp+PB45LyeicXYB6lf+ApG2bGkvl6H+8H3UF05Ddzvkoj7yrvF3tulkFgpshhu9r5F9/Ajt0vkCrQxdiGzPt2uW6TMV74coyP8cjW0jkE2MQLY6GzmFw5Gj/TWaNw4mbMlvT8jyf4hWVb6y37qYDDPQ/NMP2V+F1e3HmMXGbyahj/ggZ67paoHV2wP1E0e44X8l6lN5hMsAa6pzBhrzHrP29EJ9aAVKqJxhbfRtLTMdrrB234kC5G6ExMYiZEu1wetuup1ieBcRktYZhNtbS1GAe5vJvRlaCcyw34+qpcy6oLEiQva0B0oGbU2efoeZ39b4prX5C+TwXmi8liAfYB7hhvFc1A8X1iDPtWgnzQdWZy7qi63smTjvrdAK9rbKrA3q969a+0432nsZbDVadZ1lOJHpqjfheNlqQqBebnxNQAlzbwMrtlGeS1Nw43ZXZXpdTrjVPI7n7Wey4f3EZNEc2cgyo19pdcRl+Jq1ZzYaA8rStG1bdF0Vo7EJ7aSYQtghURu8QpSkfBWNRe3RWFtubdmE+mzvFJ3NQdtxVxh/3Wop+12Fv7loPJ+M5oxOMXqlhIRvfdGbj+ZHv8OlXS3xFqBjB367fisULOejJFiBtb894XbonzvnZttuogjIds75ROrOWRrzwHLyV7s/5PS+F/t+nf+OLu0pRBPPTMLWuU2EMwNvos50C5qYfOdaT3jdQhUh+7UeDThf2e+3Gl6XreCtS8G7HmXtPN4ya+uXqMOXo8HaX5qyyP7/0+j1bSB6K1Po3WN4fbeCtyIF7za0Lauf4c1BA/R4wrscKwjvQfTtfZbwSpWG4O8bwgCejr/bkDNZGOOpytrp8e4lXNrh+ft/hNWhhfZbFXLQKoz+S/bbFzH+/roD6E1D2zO9vW4N71X77WuUqKhCfekLwntr/XlE348qUJBTZTo52Np/B2Fr7VrjrxRl6H9TC50VIcfrc9ONo+52V05wSF9ESbRdWQ/fEBzIT9FlITNRBtrVkYc5sbb8BzlQk2Ptrq4fL2HLfvy06fYX9t2302fU4/YyEwWmfrV0Dgrq7kW2VIQc2YIYvaWE3T8ObcWejpIxXmYFKLkQx1ts//1FZKNMjqfGdLTeeF9kMvPb4/II48YD9kxVjD9nz/0GOUdvmdxGE+z7y1g955mu3kRb4l8g9JGNhPegnmHz2d9RguVKwjsvN6DxcqW18xexOr+PdtKk1umQ8/hXwmp9X5PVWJS8eRg5m45wS7Sn97Tx/g4KND81ekchG5xfA94ryCHsiY5CvIWSUKNQH3eE83e+jnfQnPeJ0ZiJgsMfIDv2NpdOZnea7DcQ3v97BQq4vDyvIszrXp5+DMhH9vEZSmDcYPJ9ByVq/MV0m9DW0aVG31/k8wZKTHyURi7lpq9M00WV0SthS97fszbtg/rpOHR2dywaC6qT2Tsm48GEeXIOCo78kbA8ZJcLTA4Tke7HG59l9txqlPDxF+otN5l8hGznx/b8+6S3z7g8fbL7YzT23G9yOorwnnPf1lS8V6xtNxq9sch+/MWelYRdGF4vY61dU1BA58fAtcbXSuqm6ziNhaabU5Cd3x/DW1sD3gJkzycb3r3ItofH6K1DfWxhTGdLkT390nT2oPH4e8KK5fba8s7A38+MvweM3jmEMaU+6S0x3EuM3j8M7wiCzafDW5yC9zc0pg0g+O6rrJ2fEhKtI1Dg3NPq64gC4wygqV/Eb+z4yv8lK8O7QImi6Mdo8D3e6RKkH6MtCycjx7gcrViMRisxuSgbVoq2K+Tbb+vQSspHKLP8EloFeQ2tPPRGhpuBHJ+1Vg9W1wR7riY8H9z5M0PlaGAaZO0biCb9nvbbnmi7RgWawDqiidOvsOyJnI/6pufPP7QnvDd5Bsr8vlgDnp/MWxteFcrwdbR2dkEDXClyfgejLJvnr12M37mE1ZX65m8BYUtWRoy/5miFvzXKnmeiieQAwhZU7PnsWDsz0CTb2drsz6DuRziP5qx9Xr4L7P8bDUTPyyPH8Jchh+mFWrSzCm0nqjS9bEArSXtZfXsg56MPcoRy7fdSgh34wHaCwfZDGdfTCTfwNqtBZ4vQmbcsw1+FApzuKDiri929g84JZiFd7+p6aG84fmtzJ8IKWTs0lm0rD5vQRF1CeH+s12dz1B+r68eVSOc5ppeNhHejv06wl/ZoVavcaIDG0zVohWiC4fqzXR1RYLYcjeF72W8ZJksIl0/lG29jCDY5KwUvImwzj6ytRfbng+dc5PyfTng3tpdbOeHd5n6lorXxUmJ/ba3NUwivhRuMbhXNQU7RMuP5JdPR2Sb/1tamDvZ7AUr2jUABIcjp9Sufy1DyqcTwl5tOm6Mz2RtjdXY2OZUhZ243FAxMQ/PeHVb/2SZLv8rdjnD8yO9I2GD62Qc5gVVGL68GvM6ES5UGo0RXvuGtNlkORGNDK9PPamtnEXI++6EbXCO0Ir2hBpmdi2xhCPIJMo33h+w3n5C50mQQl2cp4f3cbUyOPvE0z9r9WxScDWTLZIw/e/iBtfu7aK7ycmlmbfVtGY4Cvb1QYsTFeO8Uq683Ou612upcVYPMOprc/c6EB62uEwj9zm/pLDO8HMN9y9p9GRqLmyCbHWD0Cu23Fsh+MtD4XpN9enkuRuN3qdH4OkUPtyOf7WCrP4430D4XpdHDzda+7yIb9wm4uYRL1kpNZm+i/nuUPVsXXR8bo1Eaa6tD/tlck+Uva8ArMno+ATKBEDD9AiVCDkTj0ukxnZUSEnE5KJibhOaCy6gfW25M/ooIPl4OSozMQzZwaQPQ20SYk3JMfpuQbf6sBjzvd5QY3iQ07k4wvLGEeOI4tFPOJyZmG72eQG/nXKVd4voBcKBzbg07Scm8/vrrG7sNSdlKGTly5Gp0O+gRI0eOnIMc618hp2MuGvh6I0f4KzRwd0ZZ6K6EW1HfRsY+CBn+p2iy/tA+z0eO+HvIeDuibPajaED1WyAmVYM3Dk3ou6GA8m/IkRyAjH8c6jTjUYZvJprAXkFO5G4oO3YzujCmv7Wlvum9aPLphjKxvzf+9iK8biMd3gvICemFnI9r0KrbQGvja8iZe8/qmIGcqFEouOqCMuk/R85A7wbi7wXkLO6PnLZ7TZ97IUf/deRcHYYc2Q+M/gMoe3+AtfVjgnPwAQq6lqDM6YeEbOS9aDv+CYRLaXxA+UoD0fslmgB7okl/o+F9WAu8vaxtE9FEOgBNCG8gx/dsq/N1tJr2IDoXeTYKIB6y9vZA9vMJmqAGo9UAZ3W+iYLddDr7yOrdz9oyDfXbI9AZovFsu929i86MHmA8/gc5xruyHl5GDuww+/0mNEEPJ6zubCsPr6EEgV/N+iEKGgZRcz9+GDlKgwjvSaxARzlutWe9vZxreu9nelhrbfkYJUTWolXNtUbvOJPRK0bvUJS5z7e2jUc26JMDXyFn/mQ07r+cgjfP9PIl2llUZrKZg5yY0w3/f03WJ6EdORGyq98af8ejQPmvhOM33U0HGcgp2xsFHhloHP8bCmoGoDmkm+nrQKPX0ngdhMa1AUb3YKN9uD07F+0c2AetdK43nNbWpsMN5xEUIH1oz8423fVDfbEp4ex+luENRfcxZJs89kO29yIhiGlFuBE5y/R5sOk3pwa81kazq9V/ILLfB5Cj/oW1czoaP/ZG43Q7e343gs0fhlaoWlcjs0PQPLKb/faOfa603wfF2v1NTJ43oMDSJzz82cEsNJbtE2v3V6hvD0arwV+icSobBZ4HIru7FwWPfoX3CcMvQ3bR3/4PsToejfHe1mTmE0D7WZ1/J+w0SiezNjG8yOofSrjYarHxh/HbwvjZDR0nOQwlkv5tdf4FjR/r0Xjrzz42tTr2JL19pspzN/vcDgURe8T0MAvN1/9ACZIZqL96vKWon5ej/hDXw+eoX55HuCm+P0o6rDd55CHb62k83YQSJ9uq67sNvsRoNDGcbDRX7YV8jENRkqA6vGaGk4181cH2dwjyZd81uT6GAl2vM4f6YDNC0uEgozcdjavbY8uNzV8VwX6nG38HEt4C8FYD0PP9bAYaQ/czelPQmFlTO5sh2+1CGFc+JdyT8iRhN0xPNBZ2Rra/Bth75MiR7ZDN93HO3crOVBp7aTr5q/mPcK57XzSAzkDBxi3IEGehjlSEJoGOKFucb5/9Fr41yODHELY/rELZz8ORo/QPlAVrjc4M+20Tk5Gz5beleLwjUvDaEjK+mwx3nH0vJpyDONP+nkEdrqV9j9N7voHpnUjYbrUOOdoOTVwe7yzDe9bwWhOy4msM92P77rcpFqAthL9Fg9lso3dCCn9PNTB/w61dj1jdfnuZX1nxGc8fxvkzW4vzWByjX2o4q9AW4M38Gd7wmEzzG5BeK8MbZs+ujeEVpOD9MYbn6R1IuLCsPKaHSsNfiRzQycgJ8/wdG9PhzBje1yiIWo+SKv8kXLaxNZ29QDiX73W0vXb3rsn/26KHz61u31f9ltzt4eFtwvnsQhRoeNv18ryCLftx65Q2lyGn3qFAx9uLl8v+Mbn4rbtxuWxENlNlbb0DOf++nhZo3K8yHuP0NtnvhdXgDTb4JJOn35rpt8MVIuflVePtY8O7yOD+XonbrZ5ehDPyRcgRupWwxfRdlMSrsnoGodW2KpON18X3rY5zTQ590TxWZfVfQrDZe9DN3aXIGRtkcvBb6QsI/SVe509jn3ui7a2+zsdiny9HSQF/Zvt7sc9tUIJijT17F2Gr5NbwDiZsM3yUcMbzZnv2Anv2aLQlshQFTUcRtrZfFfucyl9cZn9AvsBn9r0/soMqk+XJMR7i8uyCEiC+3cfF2nyD/e6PZTxsuilFycAuhHeE3kDYgpsqly6E4xM3oxXRd5E9HpnCe1/kyzhkywtiMvP8l6L+Hcfb3Xh3RusDq78z0v359uyJBNs/Cfk8/vsdMdl2S5H1pQR7uYLq7TNVnocTfK3paAff2hjeoYRXk52RguePjsxGiRdvP4+gOwiOtGeHx2QxAG2ZdWg++icKFitRgF0XXXdGPqWnsX9MRzegRNnsWNvieAemtM3ryCcKv7LvT5lsSgkBvNfZIYS3bvwU+Ub+e33YcmPzt3fsuRvQeDC9Aen1I7xD+0F0BGNyNXi9Ynj9Cf7xC2hX6if2/d9oHikxfm5FvnsR6kt/RjZ4J/KD/Lj188aOrf4r1mrsBiR/26AsZV+uQis8X6DJsgINzkuQI1mGHKDLUIb1DpSpORetaK0yYyxBg+xC5IgWoInqPKN1I3IQv4cmdH82oBitOvpzaQUoo3QeyszeiCakQ6yDLyWcs/vG/krRBPpv4DtG709Wj6fnz9k2JL13UWbs5hjeWjQgziGcL34ZTUIRunDgPTQJX4yCojL7/zFawVmDBqfHgMON3pXIAff8rdgR/Nnn/VAiZWNM13n22eOdas9moAHsXePxJZPJOqO92HC34C/G4zij9zayxx1Bry3hLOI6ZNdLUb/4Cm1TPNLkmYn60Dj7/k97fiYaqKejLP0YlJEdFKN3GeHs43gUkPizvQWEIO5dNFHXWmcpOqoXu/u26YHQV32Qtd08WJsvjcnza5Tpnmi4vt2HWzt/ZzLNQE7XpybX6uxlrNF4mnATbKpcxqLgc2YKv5m+DqvvROSEeHovIhv5JoY32NrpaWegbP9Yo/8wWrm913AeRrbVzfB+ZDQmorlipv3tjezufeRk+2MArxpPZdauJchmR6I5aiWyt0LCuft8wu3HI1GSdgHh7ouFBJutMNjlaCX3a5Pf1ur8BNlihsnuaWuLx/GJqRKUkJhk9X+OnLtMw3sczX1FhFf8ldWA55PXj5qO1xEuv/LnyP2FM+OQ/h+JtfNJ48X319rKbB5KdP3L6pxHeFXbPDRW+TPlC9DupC3andLmApPzJsLW02Voh8A4ZBOzayGXL1Ff9nUusXrivHtZP0K47brc9FNMGFdTZRbZ34PIZubZs5tM39ORvfzN6n8mJttFxoMft0vRvO9td7P9sKXtVGefqfLMRIm8KWhnWK3th5CIvYXa2c/DRu9eq+fxGL2126Hr2+LyNhk+HNNRoT1XQLhfIxXvYcP7Z0xH5Whs8YlBh/yhuM7uMbxRaNxqCFveGfh7LIXe8gam9yiy/bmEyyRrwvN95yHkE7+N+vAqwhhaTriRfxWaj/wOrkeASVZHW+SXVqBXKjV6TBX/S84M7+TF3qmWS3hReD7apjYIbSEpRA60v6GxCTLI1cjgf4jeXfuh1fVzZNSzUQf051fboM7VCjmS37XnPjT6PySsLPkBPR9l5SqN5hSUuV3snPssiqImKKs7Fw1KKwm3Y/ZAnWo3q+MY1Eknoy1CpxNujqxPev3QVqoR9twn1oYRaMBdhjqxd1gHmkyWoRWigegK/2/sXcCHoUE63235ztPOzrmVURT1sDYPJdxI2d7a7QiXM9ULf8650iiKBqHtoO2snmUoizwXTb57G0/+bHhGjL+8GE+z/Gfjt7PnMeXzIJPpYaazr1GWdSGatOuNXhRFWWglch8UoBQhW94X2esUFBB0IziUbQ32HJpY9yScT9sTKHV6f2FrZONYe/3n7qaXPdBEuwBlTivR5NUdrcZvQAHXV85ezVGDznoZH/48udfRAtPRNtud6WF/wnncZbu4Hgaica4b4R2nuxnNLMJryWrFg/0+zNrb3doyF/Udz8MKwlnYucZD11i728faGaGsebHpfpPp1stlqPG3wPibg5y2LMK7GDuYTeCcc8Z7JVolPAythvjkXBe0TXBTTJ7Tjf/eyD6/QEmAJUbHrwq2t+8+GeLp+TPCOHMGzGZbo9uvjzWava2uZ5EjNgutAE9EWf+1yLHbZO2ci1YIRqGVjMfQGNeFcLFSW3tuNNo+nWM0/4QcwW9MHx3QuD0TBd/Po622D6JSU50LrZ3jULJgFkogbEK25Ff52qBx61XgebPxlibLRwz2ktHoSFi1bU3YsjnadNncnn0U2eV7pq8cwruesw3vHeA/zrl8e5f5E8jONqIdQjlb4a8pGuu9zD6PyagZSqpeaXKaYXrqaPqcYe1+Htnvy9bmV9H8e7e1dyLyFbqifvMNcor/g3yFZ5Et1ySXfNOtr3N8Cu9tjPZz9vvr1uZM1C+bEV4xNQ4ljzYg/+UJo/Gq4RURbv4dj5JjVchuX0fj8FlogaAl4X2tbUwuXr6PI5t/ByWQplJ7+9xo8nzEOfe8jc1bs5/nTM//NlmMJtyWXaP9oHHmCeA559xoe4vBc6aX9tuh65kxGn6nw3PWxvNQwF5seHloLN2dLW2kxNr2PEowHI761BqU6F9D2Oof1xkoMfA6Wgk9Bx0PbEL92XJj8peFdkG8bu09By1+VDQQvSYmh9edcy9EUXQMSqDkES4h642OPiy2ut5HNvugtfPfaG57CM0x7xK25bclXDr3KbK9O4HxzrnnAaIoegTYxzl3EDtZSYLhnbhEUXQuOqB+BOr4/oxMJ8IWsdZoYF0Zg/ltnAvQ2bY3nXNLrM4MAOdclf8e+/wztA1oP9QZQIFwCzTA5KCJPo9wiL8l6kQ+g/YRth3COVcWRVEn5LCXGY3N3xuB3u/R1fW9TT67E14dst5kmWOfse8ZqNMXI8fD03sbTaADTd6rzLkc5L8bbzuMP/se53E94eKn9SiQ88FQnN88owUa/Dbzl4angbHPEF6htKPo+W1PLdCk4M8vrre6WyKn27fFw6oIFy6NRZPKLKvzCMK7dw+3z7MIWw29DtcjR6Q5cu6KjKcWpjOf1d2azmrSEdTN7q5Gq3rfFj1cibYrbq2vbgsP8TZPR1vP2lXTzjgPCwlnQOPtTmcvNcnFGb0PUZD0CuE9x8Nj9dyJtrduQk7edwhnD/OQ852NxpBsZI8l1s7m1s6ZyFEZjQKk7yAbnWTt+K59nwyUmawOQw5NW2tHU5NzL8KrjYpQUuIT5Fyd5Zx73ALHc1BgdCwKzFuYXtYSXveViQIHf07uC5Ts83NQM+BI59zYKIraOefyoijKQcdM+pgcMFntbbrwdbYgXBSTjc7hv2FwX+fm+o1eO+dcXvyzJY2/i7bu7mdyWoOC+reQc9if8F7wDWjs/hitPlZa26aZbvdG79ausERDmfGQY5+zjb8uVm8hms97I0e2NjL7juloALKPKYSLazwPvp1fGN3+qE/5c+x7xNqZHePBX8jVzuTSz+otMT30Qf2iPKXON0z3xOocaHV63nui7ZqDre1rrd6OxjuEbZsbsFUl08O/kbO/G+rjFYa3OiWxM8J01RklBSPC+90zCBfizUB9o6/JehoKRA+N2ct/2ae1MdV+vofGFz8OrEFBxAqTWXcUMKTTQ18U9EM19mP91dtSO7TVejBbXjDYCwU5ddE1MRpdYjrqE9NLl5jOygiv/Mww2XY2Pfnk0zqbDzO8zmLfXUxnuSiA7Y0Sod6Wuxv9ErbflhuTv97ouIhPFk+O0etH2OFZX/SGoMTP4YSkH0Z7NxQ/+EtPvzIZ9TT676G5bjJQHPNhstBuFk8PFE9WUk0xnDuBj5xzL1T3XGOVJBjeSUsURX4V5SngPjSJPE3YNtMdTYzF9nl3NIEWownhKzSQtkMD5APIGXkQdabxaCXnFfv+JXJk/oqMvyvKZM5AHcVfRLMcTa4DkMNVYp/9VqhOaCB6FTkGf0WZt2nIgXoGOa1z0FaK29BE2hZl5GaggGPPBqB3KzpX+QVydN9A2167ohW0V1H29yTkvH2CMq6HIedwrj27r8GeR5cZfWqw91EmcxKa9C5GZ80mo8n2SeOvFZrw6pO/adaOT4zmKPvtEaM9FK0yfYLsZ3iM3xMNtgzZT1/C9q2ZyO4mWVvPtjrmIqf+eXSWahWyn4eNv32Nr/qm9yIa2CvRpPd7NEkcioKpd0xnJ1t7xqJdDceaTorQhONX+r5CfWOKwY5DwcNqNBHcZn9rUFb1bWSrfuLaVp15HV1hbfBbVVN1tC12923TQ7HhXYfOoRaisehNa+MgNG5tCw8r0K6YCwln9D8wmsPQOU/fzv9BdvBOrC3zkROxu9GbiVanLrV2eHv5GwoKW5kOfm9tGmL6rA3vp5hsq1DgOQElB76Ptpk/h8aZS+25sUb/fKt/Ghr3DzK5fISc5W+M7/fRODjNaLyL7PVU5HjNNV22J2xRbY3mk5WEYzlvWl3TnG4JbWk8n0R4L2p7wuum/CUsBcim/C3iYwirFwXIXudYYNESjWEn1qLOSvteZTqOjN/XfP1WZ7ankYZeK9Rnh5kc+hBuTF9FSJisI1wg5uXSEs2Vr6K++YJzbmEURc2t/X5cORH43GCt0CrL9sisItbmWchRPtra4tvZNg0Pa9G41sHobG53mna2Rb7IQVuRy7bU2Qb5Gt1RHz3K6skg3B7v68wy+WZa/T4pOQHN5/9yzn1p8rwQjVHzY7L128z3Nrx09tI2Jmu/Q2xr9hm3pXxrY3X2U4bG+XQym43mkBYpMluBxp+vnHNzU2xpsT1fG3vdFr3EaeTFdDTB9HA6si2vF59ojetsteG2QgHXZj2ZXi4EPkyjswVozG5IW25M/hY2Ar330Rg1Btn+JcjO11ndOUY/D9lvjskyn3Ap3Qxk439DscIfgDecdpzmAFWWeMhECaXNC267THE7wV7t5O+//9B2kEmp35ERP44c8C+Q4+2/T0UBl0OOaAXhcgt/VsIRVikWEs4l+MtYrkCd51rknPUivJt0GcoY3UuYMP5ldfkzDuvsewXhWvw1sf/+8hlnbb4ddbRbjF4PNMgVNTC9G0x+3dAkuRENvIPQVpU8+/4g4WxQkf1eZbIsI0ykVYSM3mz7Xoa2sq1AW94+Q4OgX1Wsb/5W2V+cvy4m1/tjPD0Q+zwIvQfR81hudVUhG1qfwlOc33w0gF9k/79BTvRck1tD0FuPkgxrCEHiXBRwrrE6/hb7PAwN3IWms/Wxev0FSqWEd1T680SeXh66YbQITc6dCNtF66Kz1cgeRqBAZ0Y1OtoWu/s26qEUOTQFqA9NMzn5YyF14aEcbS9bge5S+Nravcbk4tv521i774u1eQEaT71e8wlb3KuM3kZ05rDQnu9idd27DbyXoy1pBaa/uWgc9hdulaCVxAtNJyVWv18dm0y4C8IHVWXo2IcjvAPY01sTa9tfTN6rY7jeHp8hJFynmxw3oqTmQei89nTCjdZzTOdPoTG2CAXy8609H6CkxiLCNs+HjY8nUBLK62k4mufmokTQSyl1LiK8auivaM4qN9yVRu8ZtAJ0nfH1OAroU+lNQ6s2o1D/PAsFVQuN9wcIZ3J/iS6pnGvym2l1V6J59GrUDwpQ0vlzw3sDJZEeNpyj7PtcNPeO3QaZPWV1DEXbeG9BY9XNhOTLL+3P83C/PVOJklwvowRHJWHVNd5Ov1V8X/s+AyXInk6Ry7bWORWtAL6A5quhaOvoLMJ87ROOl6KEjb9kaD5hrJ2BtkGPQnr/wGS0DCXh/mB6WITG7jxk89cje4nLeq7J+v00sk61z+sJthS314vRpYFfI/v51OjNsOfieng39t0nTLz9eJm9gsaVcQRb8jL8BiXdrjF6qXrZVl3fG6MxDY2fQ42nv5jOLjaZxfXyTUxnXxEuD3uDcPHVVJScqzCZTEQ+q9fZYnv2VNPZrdb2v5rc68OWG/QRWDwAACAASURBVJu/hSjA/wOyn6loB+jqBqC3CPWTg43eNSiOOIYwRl6JkkST7PsdKNh29sx4wgVki5ENV5nMF6Dx/2F06ecdhN1Jd6Dgeqd5l3BNf8nK8E5aoii6Ck3cZzrnlkRR9EfCDbTnoC2RLdDFIvuiAb8FmqTXIefkX+gmzW4o47QBDci5aBtQIeEdptlowMg02BSUYXwabYWdi7JENyBjv9K+rzCaQ9EEcSHKJDVHTlQ+yuT5883+6nqftY+s3bNRx3kZ+AnqZPVJDzSwYM9+bfy9hs6GLDX+/VmIO+37BjQoDUAT0pnoyv02MXgzlM0vNPn514z4Cy/aoEGkGVpZPN2+1zd/09BWrIwU/s42Hj1Pn6AVOs/vIKtngLU/Aw2O2cgp8DxlognC87ue8G7XyNr2ntX9owagt9b++0FrE9oWdTjaJvgUmlC+RDdBrjb+c9FKWXsUzFag1brsGB1nMl5DuIHTH0soJ7xT9lO0MnhNHXXmefBlbTU62ha7+7bpoZnRL7TnF9jzU0z2/kKVbeEhMj2Wmx5mW50fo9XWdbF2vhPjoRIFde2R4zHMaPntun6FaTfC+1L9ClCR4eyFxtHa8N7UYMVoNfYblCD8Gq3ebkQO/mTjf4x9b2JyqjD9dEVjQSs0rvrLiDoStoWWo7G3zD43R2NIP+OllfHQBSUmLkMJPb9F1m+D9nIuQg78ROSc34qC9fPRis3uhNfa9Ca8gznD/vs7L/ylLK2MzmSj+zPkeK1Er3LLiNXZwdr5JeorE1AfLDf+YctkSb7h72Zy8fSKrL5P0A22f0dz3y8N1h3ZSqnRXof61JtoqyaE862VqJ/6+wTKDL+QcBuyv7jpKzQG3Gj6vN5waiuzdSaj/mguG4/s4W8G8+30q1I+iOxjbV5n8vPtziBcYuW36M9HAesP0G2+36DgYWkd6yxC48qnaNfDKPv8F+Rw90X9drHV748TPGt8trDfmtv/VbF6C1ACyV9OtAfqxy/abz7x6O3lo22Qdap9elvqZLr1R0m8HuaaHp63drRiS/v5OeGyu/fRmOlXpf24tQ7NIS2t/jLUx/1c0BzZ0Uf1oJdStrTXdVb3ADQ+zDI93Yd8Ja+Xx2I6W0PYajsd+ag51o5KQvIyF/W/uM5WojFsD8N9HyVE/CWL22vLjc3fWuNxD5T8+BrZyUOoj9UnvZ7IzpcbvQlobB+LEpyzkT0ejXzRfdG8448fdDH5H43mJu/XettsZ/x0MJrNUYK6CLjBOZcBEEVRV7TQdp1zroidsCTvGd5Jy8iRI5ch5yPr+uuvf3/kyJFL7Hs2yvz8FHWG+Why8N9XIKfRnxubRnjfcA4y3hy08tCMsA1jMWHLyVvIYdgbbXl8GA3c/rKXf6GthB1QJ5uCBqLFBGdod9RZclEHeQp13I5Gw69eNUFZ4TXI0R1m9Lo2AL1ORu8Nk9N+RvMZwrmsDWgQOglNuMut/j0N59/Iwe2EBp/WJtN/okGns9H3q7It0CT/DcrODUHZ3PrmbwYa2JujCWMRcsIPQPYS52lhjN+NyPn3W32Xm3zaIgcvztPcGL8PoEF8H2RPXr77IMe/Ieh9hWzSO/7tUDA0xvQyGN3gvB7Z04FownvFfvOXSb1qND5AE0t709UXhNfI3Icci2Gmw0mmg4Fo0nq4Djp7Ajkoe5k8Flo70umotnb3bdTDh8iu2yPn9T2U3BuAMvt14cEn91qihJR3KAYZzrpYO1+I8bCK8H7X5SZPv116A3IKeiF7ec/qbGN6aGa6fgs5brXh/QNkb52QzY1HDtEA5KDNJrzi613j9WTkkLyH9L4YOd+zkFO/HDlAg9GqyDijsQeaB5obP/ejZMBQZC8PxHjsggLEI9B808Fgy5HTVGHPDbL2+XN8h6AgbY7Jvw1yRh8ymlejlWRHOF+50GTjV8l72zPlqP8NR3qfF9Ppl8ZHK9SPD0Wrdd0JF6p1szoz0ZjZ1to9L0avFPXjQ+zzPvb5beNjiLV1EtK7M10fhMbkHsjuPjd6ZciJ9GN1JXKwOyGHscpku689uw9atXkB9a3ayGyNyaC/PZtB2Po/F9mhb3OJ8ZBhbXkUzUX/D41Dm0wufoeMb2cFIcHi6zgS9ccv6lhnmfGzN3Kw9zXdjkb94EQUXH6C+k0h8ncOQONMVzQGjLd6Nhr/lSa3EjQmdkI20MJkMgLNl0XIXj6w/3Wxz4hgS6tRn+hD2Oo6DNnPfNTfrkT91e+6cyghtzcK3q5HY/7XyH4yCQk3n4D0/K01nrujvpFj/G2PXoqtHd5eCwgrfRXG6yGmpymE5M40NLedaHVEaP7pjIKuAcjXid/7kIvG3aYxnoqQvXr+mqHjJccZvRZsny03Nn8FxkOu8dfU6B2P/I0e9UxvE7JFT68JspHj0Lw0CNns7P/f3pmH2VlUafz3dXe2zk42IhB22UUQUAQElMFBXEFxGAQckREGZ0ZFBBWE8KigsuogoGyiIqDsAdmJELaQDZJAyL52ls7W3ek13V3zx3sq9eXa6XTfe7tv33TV89ynq/q93/2q6pyqOufUqVP2zrPsmTK0Ro1CvDQO8f1IxGcN1rcL0frfbLRqQOvop4G548ePbxw/fnyFteNa59zl9NRU6K3p+Gn7gxj8f9AkNx/tzl5m5YVoAfCuzleiicChQf8AGlB72+cbVj4SnRdoRcw9KlXeE7lXOTRobkj95gY0MXgX6zuQYN9q2HP2+0egSf1CNKA+hAZBK7JQDcooX5J63/XoTGZH3vd86n0fSr3vUCT4+98fnFE+136zDk0svya4T3vXjwZkNXsETSgNSLCpRa4rx6PrVTaiieRINBHsiSa5w1Pl/85o3zVd3L7DLP8eQYjw7ctsU7q9zyLBsRp5HfzA2uet775N+2W0twztEvg+fSXjfY+2874/pN53Wcb7jky976MZ7zue4F461d5XgxTFiWh8VBOuqvLYM5b/Btp9WU/YmTvYntvL+nszElRKCfd0r0UCeK40S9iaD9ujUUf5bkejwx7oLGx6rF5H22O1o23Yk3AH8TqkSP7GfrOteqbbsMjo8J/oPO/VVu99+Wd++RTBZXp6ql/etrr6tv/cvrMPEi4OJSh+hxN2pF9BY7MVCT8r7XuVSAl7m3BNVwXB9fMspKCvJkSabrJ6lljdffk8q+d4tr5reDwKmOTdBT+BXIy/Ye24zvLVyBj7GuFYwKxU/kSkUCyyut+APJZqkTB7IfKmqLc+q7FnT0MGFn+8541UPvM3/yuV/wLhfHgt8uLw+a/b7/h3ZL7vUcQHDs3RPn8WEiLftTpcQnDNPA+N6bOtDRcgQ1m9/ebDVrdWZHjx+X9FvNto73g6lT+hE332TKqeVyEDhy9/P1XPr2W04Waraz0yMpxu3/HzRrqetxPuivYGKIe8WbL9TX90wCF5ps7ylyIvk6n23Z8TXPp/hOaGc+wdZxht6tHYu5Fwl+ntqd8/C63Bvpzml870dZpfvs7WvPQQITr569amNB1mIvo3onHl++w8pCQ3ZvRZPXJ1/0uq/Wn+uYVwD+4kZMjKlS5fZGt+vSfVZzehIxS+/LNUvS7LoNlt1qZ6NMcdZzRoQHKlp9GJGTS7mRBp+3vIRdiXLyZ3Xi50+35JOKb4S8RrG7rwfT8jXIt6Lzq+4su3E9buW5CR6B9W/jPSKxqQXLQ/4qkGtAY8kXrfNDRXtiKZ90kCr05B60I9cE2h9ap2da5CVyB+tkMgMf7vCGfVFhPc91oJ9905y6execjFbKkNEG95XEpwzbsyVb4KWa39WZdWe+dqwvmzKsKEW5WBLUeT0zLgSqv/lcDKVHu2lH0enTV7n3Amck3G+xrZun1tvi/VhpUZ7VuZgZ2FhEz/vlXWJq/Y1Kfel8ZWIsPEIhv0if1+JeHeTV9O53/Sne2zvj2LcM6jvTZlYr59395OmzKxcxAfOSQQpH9zdep9mVj6faVtvMPnM7F/QcqA7ye/e7HS2ldjn0xssfXpmYQAglcC69P5TAzx6NpUvfNBs47SqDN8t6PR4RwkVLYSzi3n2oaTkdXb16e9eqaxeel6b4dfTkJGqbb6paNt/xjara1I1XOl1WMO4YqleRnYVMJZr0+nfrMq431Vlv8p4Xq3echQ0GjlFYTzaQuRQHW/1f/zSEh7x/q3BAmefs1Yiua7dfb/2YQ7c+cYvY5CSuS9SKgaYvWZbjTsiwSvZjTOFhHOXT9NEIarrP0eew4pbXPs9/9kv1+KdjT8O4YiZcu/r8y+W4d4ZSkhYvR0wtWCNYSz3h6bhpSTC5Fi9Ib1ST9kWJhh7bna8iXICNTR9mX22R9Tbfpzqs6PImG4cRv1TLdhhdH1yxn1zqxn+h1rEU83IUVlBtpd979ZYb/5FTQWH7bfHGD9PiPV17cifphLuEaxEvFhBeJvH8ynNoUtJpwffwEZrzwPXomMRGVIQfR9eyvBoJLJLx3t60x+SfNSqdF5gX03k38WEOaBbdHh9Dbo0JdwljXNSyVobVlo78sXXcqRodKXb0vR6Dl7V/026JKm2Tq0vn2/DTpdZTTKpFkJMn56PnsM7QJ7XvZHFIq5fbfb785HRvTp9r51hKOMaw3371uH+NS/78donp5obbjaft+Pq/Gp8vWI/72nkfeKWGm/vQmtHyvsHX5s+D79tf3GW0jBTax9sy1/ABZTILW2+HgcXzSsFRhXaH2qvU88M9xDk0Vo2905N8/KeyDXgzFoR3AOEqAPRm5WGwjnvt5FDH2wfXcSsh57y/E0NFF4QX0GmnwvRpPJw8j14Yf2e7MIbilHGfaevbcfIVLtUchF4xn7HdBuzUbn3FMWgv3f0CCbhnYVpqIJaDSyhpWgQekXo2MI54CaCHdrLk5hs9CuywgkPL+NJqaRVp6JFrsz0aTyDBrE3yBccfC29dmnrC0LkDWsibBD593/pjnnVlp7jkUh5iemyt4t+1Q0wb5q7ftPJOz5XZ18tu8pa1+15RMre1e8dJs2Z7TXBxk6ON0+2HIV17FGl5dT+TeRBfZ4xG+Vlp+LBAbvRtls9V5l/X4qwZ0nQW4+y9Gi1x/tQh5rfbPK8rOQxRK0O5VY+RMEFyl/LuYgyy+zvjgWTfDL0S7eemCJC/cAl6Cds50QL/q8d0k+Ci0Myyzfz2iSDc08351pdfQ82RaNOsR3OyAdxiLB4CBkQHrH2ncEmvu8oaAzbXgXuRB/As2Br1gbTkCeLC9l1DPdBi+A1KbasMQ5V5XBO/Ps93ax+jRYfoW9cw+CC9tw+/+r1mcfsXavRALOWKPdNKvnvmi3+Hk0dzahsbrS6rWP5Tfa73nMXynn3YL3ds7NbqPcH+3O16NzXV+yOlQQovv2QULTICuvIsQmuBqtMf2MXncjXr6acK3UMCSYrSC4Lg5Gyt8Qo8kvEI/NtN/4GRJkZyJlpBGtV2Xb+c1MrJ/9/rVop8L/5j1IyGvrffcgReZWggLv3cFXIK+qemtffQY2BCm4N6J1sj/iwbsJARzvQgK6x+613xnfgfa112cL0K7nxxC/9Wunnuk2rLLyE2iHbOE26nm3Yb+331mPXDdb0NjL9jffMRpvRPOhd3tea3WutPeVZ2BDkfL0e+uX/mhtvdv6Zo71bRXayfXzUl+2zS/Z8Oc9/DMvnUPb/FOFxtX26NAe/7TFS2d1AV3S75hq7zidEPl4W3RJ02wzWks9nVamaDR+GzS729p+EVpT1xnNfBvqdoD2TUIeJWdY+0qREdERrvJLv89jmwnxfO5A87T/zavRmJ+DePLaFPYcMmB+mxAgcSFaq8Yib1GvfI9NYf7Yzl3IS2EDWqceQd5B/VLl3/i8c+5XAEmSXAmc4Zw7iB6cojLcw1KSJIcgpfQowl20ZUgI2YQmAK8wtmwDW44YvR+arGsQc/tAOJtTWKWV30ABHmY65xqsLkOAGmdMkiRJ/xS2Je/LQKNzznksSZKEsBvmsU8gN9wDkFA3gnDvYjNhwViHJqBcsVo0mP+BFqZ3CG4wQ5xzG1Ph4AelsEHOueoMrMbaMMSwBAnhaexYpNR3V/tq0GI90bcvVW8fXKS9NmViiW9jqk1DTfj37T0FGUp2tXcPQ4JqA4EXffCRjmD1SPDYFjbQ2ncbMMk5V2nGImffq/L5DmAlzrnWJElGoXv5WpMkGZWBHWPt80GZ8kGzPtaGW4B3U3zXERpti+92NDqcmmpPP6TI59oG//4t9e5kPdPYtvjla2jO3sk+gwjBugak6uzn6qY2MIyGM9DO5BOEHdnRzrkVqbqMJkQnbwtbheb/DxhW6sseS83pw5Ay7ZxzU23c74+UY68ITyUYA0qRcDYc8eCbaMcgQYrJeYjH+1v+fnR8Y7k992GkZL5n3/+YL5vi3h8ZOSYgge8opNz/yZ49GAl5J6Nxs9J+xxuBZyFX9gH2zhGWfwcZ83ZFxocD0XGiQyx/vdHEv/8Ja/upxjv7EtxoP2j5dfbbByEltAnNGQuAtc7u3DSjyeFWh+ZUfrTlxyLD2SGWfwoZvtPt8214P9W+d5CS5uv8eKoNX0HGubkZ9Uy3YYHRZFCqDWudrsnydZ5p3z0Ojf+ZhOCAzxltPc+NQDw+197zUTRu5iEe/yDinycIni8fQYbCZsu/b7+3yOq8s+UdmhN2QUJ6Ot+S4udSNAYHIqNbYv05xtqzE5KpvELk+aUjfb2QwDvXWz19+Qar4+eRm2hDii4T0ZjyO8EHZNBhPlJeB7ZFB5tjjmBr/vF0OQsZzXyQsFzoMgGN649Y3Z+0PjkQ7V76oEnHEK6DStMlTbOF9n1/HncLnVI02uic22zlEfa9o9Fc8zLiy+PsHeVWxwVIuTuyyNq3s73nBGQY8Z4Lx6A1YCCabxai+XBXdKxqLZoHSwkeQPtZm5daffZEBlsfe+JgtD7MtDo32XMthDuLG+23IaxLGwl6gb+9op9hG7B1w9ozFKh2zjUD2N3a1U7XK+2ElPgWUoqyV457aorKcA9LSZLMQ4LC64hJL0YDshkxpXdXHUCIZti0DazesMHIEuSxISmsyd43Eg3sKiTMvIx2Mt8yfCFyFZ1m5XO2g72JFhOPTbHyM2iynpp6V6PVsQwN+P5o8uiLBtWAdrD+SNGYa/mxGVgDmhRGoF3gamRRexxZHaeiRWYKssTOtPJ/bAebYmWPvUOwCj9rfbGxG9r3Pppwyq2N1UhwfBwt9p1pUybm25TZ3vcIbo23IF7dGQkfZWiBGY0mXi8oH7YNDLS4lxGC8ZQgT4TEMIcEulGIX58xGr6Gzty9b9//ptV5MtpF2x42x+pwnmFvGfYm4tEZyOVnsfXt6BxotplwX2suNNqR6XAdUnTetj5/Es1pe+TQhmbCkQ9/LvdZq/f/dLKeHsvkl5lIOJ6KlL8HkcBxLBIaFlhdBiHBoBqdtUpj5ZZfg5SiQfaOe5Br/PtI8fkrEuoWWvmbWWJ/RS7u45EgXY54s7/13TAkOG5Ec+gANM+sTGFVBDf1R9F5tHVIyPKutQMJZ/6GEiLvbimbgDXc6d7WxPAfoV3qlYRz1dVoXHkj0gqk4HcEK7MPhu2SgTnEbzcjAXI1IaLvaGuXD0qzTcx7bpgCMxZY7fMZ2BU5tM+3YbTV+ymr9+KO1jMDG9VOPX+DFK4VSKnoi3blEsJNFKsIc2MmthLxd1+k5Hi+eA0d/3oDCfK+LuMIhv7dtoMttnd5z4slbfTtOHt3Z/kls68z+SXNS6PsN9rin1FoPP0THUxx+ABt8A8wZlu8BNBFdEljw6zs6fRmJ+iSxnZL0WVPT7NUeUkbfDYOzX/ba0Mxte8+dHRmMeLVkak2jLS6NBAU7O1hKxFvec+P1gxsIJrP30W7uc+hdaoZ8cv71oZmpFwv2Ab2QcLVhPujtbrEylgeX04ZpZJUfouiTE9OHfWnjp+u/6AD6gvQjqUvL0Rujw8iQe5PyJruy4+jyJPZYA+ihaQRCYwzU+X5iMGr0WT9d8I5PS/cdAR7OgOrQtbWB5CivwhZzN6z9z6GBudvCMEPbrN8Z7HfEgLYvGMfR4hK6QjnJnzAgUWEQB7ZYLXozM+b6L7IRWgSWdYF7TvP+s1Ze1YRggzNRoJ6PtqUiVUiy+wstEgMQEL+/xGsuj+3/D+QIPHjLLEfEs6EepfTBsLZSIf4tsnySwjXlWSDzUVW0FOtzV4xWIjGUjY0u9nesYng6pQPGu1odGhAZ7mW2d9FyIhUiRb8zrbhp4Sz09ORYODp4HebcuWXOfb7n0a8shIJYHNRwLxqe+6SVH53NHbTmD+rOCNVtzp7TyvaBfCCTgtSxH0wqWywCjQvNls/3WTtaDU61FkfLiZcBbTa+s5jiwjn+FYQzm1fhAwWp6AxcwFyzXvE8kdvA/uWYf+B1sHzkdvfcrR++d2bRsNbEF88hAxCbWF/6yBWa+9psX74NQrydLr12bVWl2mWP62D2DUp7BrDzrd6/Kf1vW/fjE62rxqN93cIRxR+jcZAZ+uZxnw9v2X0/DLydlpk9X2aYEifYX8b0bz3ZAewZoKHWrP9/1xkRK9EwvutiK/+gtbTjmJ3IZ69ABmcrjBsbgf6MxteakbGu2VorKb5x9PhZ2jH+Gupvj7N+nUKCqSUppmnw09R8ET/XJouC9CRs+/kkS5NaIx5Gk22j/dkeZJwVVdn6XIrMpK1hd1tbfgKMgRehPjj9Szb0NPad4+17yRkcDkHzcuPobl0M3Kfvp1wpvyVDmLXtoF5L7N5SNn3soM/btJq/78BjRNffqIT2G5Ibh9kNCux/KG0ca9wW//raZ+CVyB+UsTQgvMkYcd+S9nyU5BAclRG+f+yxB5HuyTr0SLgB1gT4dybt/z7yWQBQWDKBttsg7XVJoqpSCjYjCaxlUhQ+laq/OsssSeRol6JdtBW2bubCIEC1ltdaq39XnjMFqsjBDF7Bikq3+mi9p1CCAT0HTSxbyAE6slXm9LYeuu/+dbGBcjtvQEtzu8iYeS3qfy5OWC/MTouR8rjCoJgXo2E8wqr27pUPltsrbXFB/+ZjwSV+hxodhuBD9/PE412RDrUIqGyBZ2nXYbOiDZl2YbnUnW+M9X3PphQPvhlNSHQVIvR9JeIXz5DCHZ1JxLI56BouWnsZbRr+z4hMqgPFFZr71ts7/NBsypTdeks5hUpz0u+r1+zenu3zSsIbpwb0O53JuZdCdcRhK4qtMYsYWvFp8XeX90B7Al0xnM98hg4CQl6M6xvfpvK30RwMc8Gm2p1qCCsTVVo7l5pfeeVoga0jjTlgK1GxpvvWp9dh+aJxZ1og6/zcqQobSAEZ9xIfupZgY4V+HreZPVchHh2GfKw2JI3uaU9bCJhnNfYO2sIPLYBjQmHeNEbeDuDVRCikD9n/ftVw/LBL2nsdELQo1fZmn9qCPczLyZEq19g/19p/dqYQbPW7TxXgebgCjRv5IMuaSxNI+/Bt5kQUCpburSHrUzRzCulnzcsmzb0tPatSrXvIcQ7nzdaL0ByeCnysPHlR7PEHkfz8XJkKPNeoF7mbSQcs6m3evqNoo5i6+yvNyDuhta0ZutvrxwfQhEows65LVvcMfWMNBFd//GDJEkGp8tI0TkITZ6fMcyX+2eJDUcT+2xkMbsZWatqCPfttSKGd2jCGEcYGJ3FmgkRQlchq+dhhEP3+9h3T0HCgi8PzwF7D1lZlyElZYK9u499ZyASQqsJ9x42ZIlVI7eVEWgh2wOdD7oO7QDmu32fQW5ma5DLzKPIyjrV+j4fbcrEVhkN90ILyu7IYv00Ela9W8+IVP7EHLD5aJKfYu9+CAntc5CgUI9cgzdanXe29meLvY14Yzc08e+JrO6PZUmzzxDOSE4j3FWbK412NDpUoHlhV+srHwPhSjR2smnDkFSdNyBX8r9bW7yRLld+8VekfQAZUoahnd4XrX9AY9O7Uo5CZ9rS2EDECzPsPbcjIX46Ejpq0fw5EY33amt3RZbYe4YNN2wqcvs8GkUMnoLWhC9afaYgxfAE+7/HvAHjIWt7nfVPf+Si6OfEgdb2SkIArvawkWjdu9766FDkmbASGQq8t5Q/hvMviG+ywfa2dtxvba0yWvRFtNwJjT3vkryacO47W6wcufNfhdbEjyMDyeQOtuEEq9/99o6J1k/r7R1981TPgal6NqFAfpcifnjdaHYEMl6sAY6wmBnbwj6FxuV91u4NiJe8O305QbBuQfPMAMRXHcWaCHfF1qDdq39B3gcLt9GfufDSQmvHRnSkxSshfe2zyf6OQXzu+7oWzU+J5ctSfe+281wJMkT1QeM7V7qksSPRHPFntN5MsHeuJhyjyIYu26NZ/xTNDkbeg5dY33e2DT2tff5MsG/fh9H1b5eiebURyYpenmtCcsf6LLC9EE/cb/h9SPZdinir3OpZxtZ3Ln+Q4JrdEczPETsj/pxj75qWJEm5kzv/J4DpzrTjnp6iMtyDknPuDSR4X4h2FxyKdnchciF5CAm9Hzbsd1beKUvMWyIPQYPpXuTSUYp2a+9Bg/vLSIC7w7Bzs8Q+hXaDy9AkcAGyAvozPY8hV8cPIwHoVit/IEusBU14H0fC553ITWQo2nW4ES0oX0e75r9CY+KMLLFT7R0lSIC+GrlWlVqb892+AwmBhl5B5xpfRG7Z38tTmzKxw5BynyBBZpJ9bzfkzvUAEvB3RwvQaKtztlg5ErQ/iVxnX7I6XI546zKUvmD/Awk+2WL/iowzIB59xvI7kx3NDrX6z0GL4Y3kh0Y7Gh3OQOMFJDBMRGMVpLS1Vc/RSBjYFuaDOp2EBNjb0FnZXVAU73RdPpaqyxc7gX0RXXUBEr6mWH5f5ML2JhKy9kQC11A036axvsh48lngTefcXUhp39/ac6H95g8Rf55v5a9kiZ1vfQTazfppqrwSKWVHWxt2Q7T25Tmp/CGo7ychAfM5RMN6gkGj1dpYRwioMrkd7GWkXJSjtasVosDqYgAAIABJREFU0e+TaO14FvHNHmhn3ed3zxI7ABmyJiPaPIvGVSMapxVWt0GIvljdHssSux8ZaAZZ29dafx6PBPSOtmFuqs5PoXXnz/aeDXmq51xCjJG1SEk5Hhldn0bz3jikEB5m+V3awXYnnF0cYt+7w/r6XjSP1ds75yNZZTDaResoNgOth8PQ/PEuiqFwLBr7ufJLJnYAUqiGIEX4QcQ/TWisrCJsSqxO9fUiNAb6EbyGfN/Pbue5uWh+LEN0LskDXdLYbkgBnWVtetFo9Edrkz/C0Vm6tIdNNnoNs/6biYxUxyL5qbNt6Gnte83+DjMazUBGjo+j4yG7Il4aY/XcBfHZsiywcYhHZqN18zVkXL0TyfuTrV5Dkcfb80ix7ot0gI5gP0QGnwrEf48gz6ihKD7K7CRJ7kFGtEcollToren40QddzwMSdi9CC+ZmtDvwD8I5AG+99q40a/OAVSF36seQEDMBCZLnoom31Or2H1bOBfu61eU1q0sFshJvIpyTW0twsa7MA1aNJtWpaJL8i9XrPPuO7/tvAptyxM63/n2VYE1raaeea/OAZbbv/lTdzm+n3p3GjIbnGw3vs3p497xmgou9P8NSlSdsJeKVJUip8UcJLgRqLX8B4ulsMd/2izJo6N2nc6XZ0nzRaAelw4XWnj9ZX3nX41zbsA4pbFvqnVEXP0/9Vxv1bA8rsc9/2buuIbitr0N8410gmwl3qG4LW4kE6AZkTPsF4Qq4DZbPLHcaS81ZDfa+25FXkD8ffQchcu2d6KqlN62ciX0TGWlWIsXgcuvnfsgD6a+I3w9N5dvD+iIhdYrV5xGj2Wa0Pn3f6rLZsHfzgP0QKZIrkDB3LRI2y5CSf4fRY3QqnwtWjvixyeri1/rHM+r5qNWzuQ3sCaRYrkGGujGpeu+cel8fpBz6cmewcmQMbETGqcX27lcRz0w3bJLRrqPYs2h8j0OKwyLrlz7oPOIypAT6fGexF6xv/wb8L8GlvL3+zAXzdBiJFBJPh6H2v9us79J9PcTyS2w8pvt+e8/dZu97I890SWPT7R17WZs8nXKhS3vYY/bul9B8MsVo+Gqqnl6x8/XMBfPt2zujfQNS9eqTUc9csD8Rgrk+gniykRAhugkpsS8iGbw+R2wpWmsORdGz/2jfK0VKagUheFy63BFsKIr384SV/fdWIe+Jy42OrcBHCq1bdfTjI+LFVODkFHHOX1d0C3BLkiQnIUHkCHT3r3fDOxAJf/2QJWp2HrAj0WC5BS0i/ZH1/2anEP8D0MRxcw5YgnZArgd+gixcdyHr06Nochphz68j7O7MzQIrIbjYjECuHn9Hi9qTFrV0hNUlsfJOwA1ZYtcnSTIUWeN+4Zy7MkmSg+x7u9q7l6KFbT8kBA9Hk8yiLLE5Rs9Bhr2IJvknjJ98fXzdRgDXZ4sRIncORzuWV6JdwkPRJF+FFvUGJMBuRBPn7nnEFlo7S5Ik8YrqL40ODikQWWGptjejwEw3IwXtJDRO8kGzRbnSaAekwy+SJBlj+Wucc1fb2LkE7ahOIAiCexl9BiJBYEMHsJ2sDY8hN/hXLYqrI4zjMUiJvb4TWBnhvOsv0K5oJRI+XkLCzmjrO298HGD/81i1PeOxMVauINwzXGc0LiUYB8ZniV1p0Wo3oTm4Hu1w74uUwc3IYFmK5uWvIiW6Du1QbQtbgLxTFrP1Oe99gKecc28nSbIPmgfbwzYTrst6CSlkY61/TkTn7DYh3vwCwfCRD2w94u3JyBOgxTm3LkmSjwITnHNrfD5HrM6utHoBrZe7WR+egI4O1Vo9P299sa4N7FTDViDlcn+r96XOuVX2vicJxiBfl85gzcjL5Sm0jh6FjNqHoV0tf4zjGML93x3FWo1XXkAeMv5amqOBh52uZjwayT2dxQYhBXUgUlyHIz5vrz9zxVYQPH4mIwNLNUrHGO3TfV3tecIi76b7fnvPHYNktL+iGAn5pEsaW4MUydFGp+/mSJf2sNFofq609++P5ixfr9VofTvayo15wCqRYjzaaPdd51y91esRxP/Ysw9ni9k79zaazTJ67Ydk1L2MBivQLu8+1vdJHrD1Rr9+hNtTWq39DxAiQqfL28Wcc1VoLfy0YSWG/cU591ySJM+j+Xs/59xUiiTFq5V6QEqSZGfkUnw4sq7PQoN1OHLxqUGT+fAUNhJZ13PFhhLu3h1l769Bi/MoJDzWIIHyUEKwiM5gByJ3ugeRAteEhOpWpIj7skODqMWFuw7LCJFRs8FasVD31teJL6fzOWL7oMjfJyDh/T3rv5FoEtyIJoyBSAj0fbtXlti4jHfshQT/UmTkmIEm4LFICcgHNglZAl9Cgn0pmvQTn7e+Ke0CrAS2GIy25K3v84XtjQSLE5FikG+a7Rnp0CZ2GHA2Ovc0lnA35Aes3/wZ1P7IuNVZrJ/RoQmNmxFISBhgn9lZYm8igfsFNNclOfY1aE5pSfVZkprP8oZhwU2ccxvs/32QgHYKmq8XIeX2cMKZ0oFoPs3E/Pkxjz1NOAfqdyuvst+4Fu0arGgHW4YU4FuRsl6JdlUm2/ca0Zrld8/XoTWrPI/YFOfcEqNPH+T2egMyUFxnn2VZYuut376Pdvg2ISPKHOOBFoLnx2rE1wch/svE5iJFZjASfl+wtvRHOze/tb4ebu/7A5ozOoLNRWtoug23IeF6vdV1AKK/D9q1F+HKoY5is81wUIZ45jJ0zGqV5e8kxEfYHvaA/e7XDatGcsklaA6Yt53+7CzWZFgNmrt2Ru6jzxsdEjR334Q872qsr39rfX0tMmI2pGj2B6PLtp5bggxvaT7rCrqksTVoTFel+rozdGkPm2B95WlWhdbi7yCj8SI0JseiMdoHyXt9CMbOzmLrjU57Wb/7qP4DkGHjbCSrrkbzw3lIWV6RBfaQ/fZ3U20fg4yUjyKjeRVat1qtPonRoT5PWD3B+8R7lD2E5kBffhTNtR3B1iC+8OX1Pu+cWw2QJMmzaGx/lyJJURnuASlJkieRZec9tOh8DS1wtWii9EExfICm/oTrLgbmEdtkmH9fFUHYzAXzbhZ7IDfCyWiCfAtNgjMJbngXWHlqF2CTkcv2bMMa0c7f7ByxvxMUldVo4RqKJqFGgmucD0rQL0fsVbST39Y7atGE3x8pYk15wvyZJX/+9VYk+DainagpaFH4geWfRbx7dZ6xOsLVE88bNi0P2ItGw1fR2c0ReaZZvmi0o9HhRSTsPYEW2ZvRLq93d26wskOLc1kOWBMSCBoNayGc5+8sttlo24gEoduQ0taIhNbX0S7BLwmGwFoUr2F72ENox/8Nw2qA31s5F2w9cDKayw61+s9HvDYKGSbrCcEFO4oNMayvYe+j9WUM4b77jmAvIMFrovVjif2/1OdtR6msC7DuMLididamwwl3hw4gHKHoZ/3Sp4NYIxL4ByBFrCyFbSa4fXYWexXtBr+AhOh893WpumWLQcil+ixb7KxU3yZIUexsf3YGcxnvSPchhPOimX3dYr/TVt9v77k3upguaawkT3RpD7sIeZYchObtVWhtG27924zmmCYkQ+YT8/P2YIKBo5kwrvxzuWANaJ17HR11nOSc22RtL0NHoZrS+TxipaizvSF0SzlXDOmN3oD7T8mMq1spx0WRXA/w1e7NHxQYpBLY1cqfRoLuF5DLTAuyIH4cKV0tyLW4WLDH0STkdw1mWnkBOo/UiiaMt5Ew2Irc7eYXEeZd+H6Cdvgr0Y7+NOuHO5Gr9N1Wvg8ZA7LBriLcu3pQCsvnOzKxOwnh9FdZfqO1/y/WFzMIYffno4XmsSLBnrD2jCVYRcdaux/sgv6MdAhYPdoV/jUKolWJFK+phOvJBiPF0ZdvLDB2jbWplnCvegMSjl+09s0jXDVUgYyCbxQQ8+UV9rkaKcr19swGa8tGe2YDEiYdWo86iq3PEltn+Rar7zPoeEIZ2v281cpHpPJdhR2KDBon2fd+mwfsBKS43ouMQ5VGhyZktGiytlcZrTqLbczAqrLENtrvbkZzzCy0pvVBbp9PWvmYVL4PCjKXDebdx7+MZIcJWWAnpfr2FDQ+63Lsz/awdQTDXuZ3/bGJjW30dSWSger4577f3nNPImOhp8vMLqZLGsuWLu1hJ1u7f4E8NC5D8+l664M6JGstJrhvdxW2PgOryhO2Aa3Nc42Gq1Fg2k/ZM99EcsbxqfJpXYB9MU9YX4K3xBgrlyLvxNJC61I562KFrkBv/yDl5sW2ymhSX4AmzMMzyncVCfYAcu1pQpFCVyPBscUmjFokvDnC3XxzCMJmMWB1SHh36BzPdBRWvtX6oQoZPS5BSkEV2kmanwX2ScLVFP+KdqGz+Z3OYL9Cbmb1aGKvJdyxutHKC639NfZ/V0TYOmvbm9auWSn6Xd4F/RnpEDB/3tQh4et9xNet9p1KFDfh29YXlal+KRR2DfJq2YiEhQ0EoXgj2iFYk2rv+lS+kJi/pskhg96LaIe6FQlztcA56LzeQitfmsp3JTaXsNvm6+hdTmegNeNdwzbb88uLCJuNDG1HI37/neXvNMx7Yfj8FYTIwt2JzSDwSiNhvVtgNNqMdja98ubdhOcVGJuDAtndj9bg3yEDdVUX9NlV1jdvZWBXGI2nWv9dncfnGtCaP6/I6NJRmv0FBbk6jrAe34mUaB8B+a5UvqdjrxPWt2Y0F/tyq+X92fkV1k8+2GZPxd5E89k1yFhZhowoTyMPCa8oF6VyHN2kC5wS3YH2CHC2c+7pdBkpk4+gyeNPaBL15VeR21VPxxyaGPZD1lR/Lm0cclepQQPJISuTQxanMiTU9XSsheCS411vPogE5IXo/OlSZBF9ALnLLEW7NGdkgfnydKQ8XN4Glus7MrHdrL0jjW5L0RlYZ1gf+yQEN98qtOAXA1aLjim0oMXMuzlPQsaGfPdnpENwQfRnUdcioelgJChNJgTEewkFrHrdypPRPFIoDOR2N8j6fxHBUj4O7Wz3RXNCK5o3FltbC4VtJByNWYgMe0da+WnDhhst/hV5RAwjnDkb1MXYs4hXhqPd976IR9YgV+xqw3dCO2OD0bzbWiSYd92vJnigbELC/3wU0bY/Wj9GWP5U5DHRndj9hPtL+9r/B6P1bDAam61Guwp7ti8S+AuFDURj088tS5FX1jokR83Lc5+dipSBUcj4fxOaf/1ziwiGswrEC7k+N8nafSlSkAcVAV3aw8rRWPDjfK59dzEKzLfQnj8N7RofYO18z/qsp2PVyAj2YaQcf5dwr3Qd4s1d2dotHfu7rIdiXjbyyZ9T39059yEAC+52BfBZ144rdU9MpVdddVWh69Cr0/jx4yuRZfxb48ePLyeE0j8fCTB9kQV5HVIyxyKXq0VIuOzp2DS00/Y5tKP5ZzSJnIwE/Ho0gZyHrNIDkDL5B7Qo93Ts12jR2gUJzy8jwXh3ZN1dju7LayYEJfk0miyXZoE1IwHxFBRowk+8+XxHJuYNG18jnEn8Erqf9G9IGTscuTytQm6H5yGX2GLAHkLGmt3RTl+t0XMBElQz++W4dvqsK7EdjQ7jkWFpX+Q98hwh4rzf9TgGCRuV1h+fRXPi/AJiz6A572vAz9Acd6blf2N1Pw4ZUmZb/jy081Eo7HtIGTsECSv/h+apQxAvzUdCdx90zKU2o3xcF2KzED88iFwpV6KjC/sioXg0EqB9MK9GpDTPtL89HXsL8dAoK69FAcuOAL6Fxvy/W188gowDfZCRYkU3YjPQPPgMWsuXoGi4+1sbvFDsz3r3QYroRHSutVBYJeKRvoivxqCxeiS6HePEPPfZU2huOh15ssxIYY+hs8s3orn58dTvZPvcNLQ27YLWql3st3o6XdrDVqHxkKbZkWhM/ALJh+WGzUbzWTmSIT/bw7FBaNf7eSRD3Y/S82i+bUUGglK0bu+C5MlSZCDridgfEb+VojV6jZX3A4aMHz9+r/Hjxy9Bnj6HOOduodhSobem48eBrEs+guOb6Kzgm2iS30i4F3ipfeqLDNtgnyvQZd5PoMWgBE38VZYvQ+cUqooMO93a+jJanN5AystyQtTuVfbxroq5YhsRj3TlOzKxtSiy6KvANOPdEmTo8Hfhfj6VLybsdMIdiwvQjtUqtFu5jnC2a1OqXwqFbUUHAk9+jnAP8RdS+Z6O1aOFeBqaA1uQIF5vH9/uOnuup2AbkJAwC3jZeClBvNWQ4rOGHoJ9zfp2AVLcf5oq30iIjfAzo9FMK3cHdiZS2GuQMeQiy49BQXaeQ/Otz28sMuxLaF51aJ3wboj3GV3etPKDhOM3hcDOQ7uPNUh5+V/LD0ZK5X3WpnS+0NjHEC/59lxGOIbRFX12HzImbbb3p7/7IFpD6gzP13O3E9arYqFLe9iR6BYTZ+38OVImHQrS+C7Bq/BSdKSjmLBpaE2rMZrti6KFV6NNlJusH8oyyj0V2w15fU4gzGm/RDx4GZJ7G9F8/rlC61TZfKKbdA9KSZJ8CE2CH0eMuTMhmEUZsgD6AApDixBrQpbx15AwPxtNGEPQZd1JqnxyEWLfRgLffyNr4WrCNQXDCTteq9FkkivWF7mzdeU7MrFhyMJ5q3NukUVJ/S3aDfk3n3fOnVGk2CVo0t8N7f7tjfi3EllJV1l5eIGxIZ4OyJskaat9yOWsGLCLkRX9+1ZehpTQNWg+OQDx31pkve4p2Ei0c/RHp/tkE7TjPQZFsR8PjHHOfauHYPuindfj7f+tSOEfi1wy65Ewl6BdnUa0G9AdWJnR/X206zAB3dfq51t/xvhhq/M5RYY9an2+Dilw/qiAdxWtte+VWx81FxBbiQzaY4D7nXNXGT89AjQ6576aJMmjqXyhsSfQVTLr0S7x7sjY1oJ2uhoQr/dFfLYJ8WAumA86N7qN7/az/mzJ43PrkfJc6umCrmbyfNeIdpoftt/89yLAhiMj0WGEe+KbEE86wrVTZWjto8iwZrQ+NyPa3uGcu854ucU5dzpAutxTsSRJRiBjxqY0htb14Uju/R/n3DCKMEVluEApSZJ+KOLwaWjwvIsG1PHIOjgAKZIrDBuBXBJqigwbQhBwxiHlba21dT/CWZkG5DpWZV20Ww/H1iMBeQZSWBK0yHmBbxx2/YFzbnOSJKPsmRKkUK7PBnPOVVqI+5x+JwvMEe5adW7rqxMS5BpU4/POuY1FgI1BEWDPRGOuDAlU/kxlCeLRTWgh29mwBcj1qxBYNRpXXll/z8qHISW5LxIEFxtOD8Qq0JwwE80Z1UajMrbmQZxzzTZXttjzpT5fYKwVjfMWoDU1HsrQWPHnzh1Q7pyrKSRm5RJgoOUPRLvGh6A5eiQStPsg5X9XQuDD4d2M9UU7xy+h+XY4Ord9LuL3yUjBfL1Isc3IO2qC9f0uaByUoDn2bZQOKDDWF+1kTnW6rmUYUmAuRedwHwYudc691QOwR1CU7mXIvfhKNL9stvb1QUbdXdEucoJ2K7PFpqE5eWck/6S/uxuSdwah9SRfzw1BrsX90DnUV5CSNQS5WV+CPGseQ0bFqT0c8/RbQXCPfpUQZKwExZD4gPVTOTKUFhu2B1KU70K8OgAdp7nZOTcjSZJBvmw0LzoMtlaiKcIUleECpSRJfo0U4ZVo4OxJiOLog1ZsRgLO4B0EazVsgJWbDBtShFgrWpgqkMX/ebRD5IAPOeemJknS15cJV0plhZli+pFcfycPWKm1/XBkCGgFDi9S7B4UNXqefW8YWogb0YJWmuKDgT0M82cSByGBaZ19rxiwzUjQ3mC0eQ25ATrgo865SUmSDECC3keRElECHNEDsX7Wno+j4xEOONowrywXDHO6H3I3dD3GEcgoUYEE73HIMDnaaPWOYXsiwa47sbFo530sUhLeQTuT+yAFbTVaJ3dCiuaCIsGmIg+o2cYn1WgsD0QulK1mtEhsji9DqbWAmOebMv7Z0NPPOVebzhcQ+xBwITKwLUHzyW7GX5XI2FmOjjGsS2GrEC92Fptn9Gvru4vtf1353ErEY4PRulyJdlNHGDbWsHftHT0Rm4vmoBnAZOfcfCwlSTLAOVdv+cSllJN0uViw9lKSJP2cc41tlYsRSyvKXjkuuuR6gK92b/sAB6JJ7mQ0QRyIdqvuJFzfczuKGujPGU3awbDbihhbYfmVyDq7ysorkPWvFQk/9yGDhy8/kSWWLi9ASly+35ENNiuFzSoy7Aw05o5B7ro1aDz+nHCW6ZVU/g8o2E1PxF5O5e/p4djblvfW/3mp8lNGoxr77gWp8lsR6zT2MjoDOh3tmD2A+L8JKWZLkJHPn2H0hopG5JFQKGx9CmtAc14xYmsNfwetC2ciQ4r3+jjB8h9AHmElyNjVE7CEEPTreOQ1M6YHYfuiXdSX0Y7is9b3m4wOdUjGWo3W58YcsTnojGhb71iLaF7bTc+tQrJHIxrn8+17PR2ba5+30E73Y0a7EUbrs5GHSv9UeRQyBhQzNjKF7ZSB7YSMkj0S8zq//d1SzsQs36/QulVOelmhK9AbP8CPsIArVr6cEIDlR8giPgctTJenytdErEdgvyJcrP4Wmvib0WK1yvKrkZDvAyD5YBjZYjVI4HJd+I7ehNUY3X6KlIe3kNW9FRk/5iMF4mdIEFmGAkpcHLGcsOvt70Yk7LXYpwEJTp5uzv6/mXBnY8Q6j7US7iU9Fhn3/kE4K9yIrv24FI2JJqQ010QsL5hDc1CT5TegCMf3GQ3WIKOEzz+N7lyNWPvYUhSh+ADgK4ivn0VnzNejuf4yFKG5wsr3pvKdxV5G42oWMjilv/siIajend3wXL7a1N2Y30SoRR42PojcJmQUbSXc3T4hVa6MWMGws4H/QMdpvo8MZuN8PqXD/JNyXGyf6CZdgJQkyZdQJLZTnHPzU+UvoHOBNxAmyEXo/FQtEnA+FbGCY/XITekjhCtCRqBJogwJPE3IWggSkBLkGrc2C6w/EqzKkIXcK3P5fEdvw7z7cSOa4P3ZsiEoku2f0IIwGe0Yr0fu8C9GLCesFu2UHYx2u/dGLnQfRLtU1eis/hjE61vOwUYsK6zBygPR2cR6JKA2oXlqIDKufQF4Abmzr0IujhHLDZuEzgpDuLJkM1KAdibsDu6J5qh6o19pxDqMrbe/U9Fxi2akEL9t/z+JcL91CRonQ7LATkJrfh80V/3NaJvYc28i2h9j5cFd+Fy+2tTdWGKfEcjQcYLRq54QUM8HYS1Fa0UlOnPbGrGCYCWEQHRNwJeRUfUM59w+AEmSjEOedr9xKZfqYkslha5AL00vo0lgQpIkZxCu4vHR9RqRkLi/YfVW7hOxHoFVoZ0vh878/B/aGViOdhj9maDrkTV7GVrwXssS+ytyLxqEDCUPdME7ehN2HfATJEiVI5etanQmdApyK30XCSHlyBtgf3QuMGK5YXVIyOuPBKI7CMampwzbFV3BNt6eHYBc6iLWOexm6/fh9v/PG132QTtpz6M5ZT90r6xX7Pa370Use+yLyNjwN2Rsm4Oi/9ajtQW0fuyBFIQKJI/VRqxDGEhg97EIPoV2Iy9G9yTvjsbE0Vbe08pzs8SOROvJzuhYTfodC9Au6MvIIDW3i5/LV5u6ExuHeP9Jo+fv0U7+RLQWDERGolKklCVIAdudEGsiYt2LrSaMPX+kYgIaZxVJkhyO0vnABcWsCAPRTbpQHySUP4CElWfRfV4vIXfC5Ug5Xoqsy9ORVWZBxHoMtgRNEp9DQv7NaGIZSjirOsRovaWcB6wcCVNd+Y7egv0bEq6WEVy41lp5EVq8K5GivDliecVq0RnKk9naaPFpo9FAo9GWcsSywi5CfD0dKcPp8neRy2krsvh/JFX+QcRyws5GkaPPRrvz56fyRyFX6bfR+nKb0aMZKUER2z72HYIb+o8J91I7dNTsPctfgJSx91LfzQa7gDCuFhut089NJ8gLB3Txc/lqU3djt6A5vwmdo/1cqnwpMs41I0X6e6lyxAqDHWj5KVY+AXlCtqBx2IIMsbXA/xZap8pZJyt0BXrzB7mLnItcCF9DO1WtaAdrHuEcWBWa6CPWs7D3CZGlJwJnGl2vQ+fySqx8PTAxWwxZ5TKxvL6jl2EJsnxej1x1P4N2/jcQzv2tsXwt2tV5J2J5xWYQ7tt8GDgF8flVaDchyShHrPNYYvmXrY8rkLW/Aq031YQAPevQme11yIARsfxga9Ac80PkNfQgUGbz0Z/R/F6Wzkesw9gDyIi5wfp8meUbkKBejTxRNqO1e1UeMH9Wua3vNiKlobuey1ebuhtbAvwXumP+HXSeOEEBF18hBGzaUo5YQbCByGAxAXgl43vlyKj3IOLdAYXWp3L9lBFTt6YkSXZFbmogwfA1NOF9AEVwq0O7J6WIyYYh94R+EetR2Fo0WbSgndpqoG+SJKehs5F/Bg5NkmQoWqCfyhK7D92FuxHtoJ2WJElrnt/R27AxSCl4BbkuTkGTex1SigcbTdcjF646o3V9xPKO9QeqXLgyZSLwV6eV16XKrRHrNLYlj7xZTkJumfugM9v1KEBPf+Tm2weNkeFGo4jlB/swiib7ezSHtyRJUo7cqa9B52H3Q5F1I9YxrD86snQJMlifhHa1HHLVnWc0+RBSlDehWBG5YkOBg7bx3Vrk1lzTTc/lq03djQ0FrkDeQrehO6L7Ixn4BiBJksSXb4xYYTCnK82eB/4buCHRFYMeqwMmJ0lSB7zu7EqsYk4xgFY3piRJLgS+gZQbHyZ/MOE+3lakcDUSzjNGrGdiDYYN3Aa2oZ3nOorVWnloF76jt2EL0YL8BnL5mQU4UxzKgXrLe/pHrGuw9J2SW/KZ5Yh1HrNyCQriNArx/kJ0VGCg/R1B2L1ZhsbKCLSzHLH8YaVI0akyvALNTeVISa5CRtd9kEtixLaPPYcCXB7qnHsSxP/AJ51zT5oRdBPQanPNcGCj5fOFtffd7n6uWLGhzrkqo18fdHf765nliBUGszWktJ3BaHfnAAAKG0lEQVTnfMyKW51zj1DkKSrD3ZSSJBmBzgNfD9yK7sl7EQkp/dDZiklowTwYHWZfaI9HrGdjDkXE9dhBKMhHLlgL2lU4FO3q9O2Cd/RGbBxyX2xFO8SPocvi30eBtJ60vz/B3IPs+UkR6xbsVfsbseywV5Bb9A1ot6wZKWC7o2BDTfa/cjQ+1iNluRwZK1oiFrEejFWgHdR6xOv/QLFWWtH6vMQ512iC+56E65k6jbX33e5+LmIR6y6MDqZM5bjok+sBvtq94YNcDd5sq4zcE6qRAD8yo3xbxHoldioynjS0gRW6bsWMtVqftiJhqxkJX5WW98E+HDrn5AWyiEWsWLANiJ8XImPQjYSzlavQ7sy1yCi7Gu1mPmHfiVjXYatS2HKk1EWs49hSNFe/hiLP+8BT9yEX9Dp0DOYq4ErkWfUndEdxNli6/CyKeu+/65+7B10rc28XP5evNvVUbLzhESs8tic65jESyaF9kTfRqUDfQutSXfUpI6buSk3A4CRJDnbOzULC+OAkSQ5GAWV8GPOTkRLky2UR65XYULRgXoFc6yOP5I4NQWeEP4J23QciD40+aOehCZ1Jc0jQGohSv4hFrEgwb+QZgISZ+5C77gzgeKRQlCJ301OBj6Px0QfFQegbsS7FSg1bZ3SLWMexasTT+6P1sQXx+meRW3oDCoY4DO0iV6IIuLtkiZ1l5Tp0D3B5xncbkPfFOSit6OLn8tGmiEVse9h/o/E0B43FTwBfAs514VjCEOA44DnnXBM7QCopdAV6UfobElS+kyTJYCSUt6IrAp5GzDkIBYW4P1VeE7Feie2NLOMt6AqPyCO5YR9E54Nno5201SiYzQzgLsNaUFqBFoXhyHIfsYgVCzYDCTADEX+/h4KefAbdh/4a4v3d0RGM11Pl9yMWsR6K7YXm8puQq/RX7a+Pu1KPAjR5A1GCFOZdUNyIbLB1SDEdghTT2ozv1qOxliClvKufy0ebIhax7WEDEV8ejDYL3gV+Biyzc98A/w5csaMowkB0k+6OD2K8BPgi8tGvQS4wF1t5ExJoWi1/P3JZaEUTYsR6JzYRWeyWE3kkH9iDyP2uBjgR+Lbl90JRFE+z7+6Tyo+LWMSKCBuHri1x6OqSMRnlU9C9pU1I2fhYqvy1iEWsB2O/Qrunm4DD0D3ZZyEFcjJSjFvR/fGTUuVssQfQGtIWdhvwOOFqxcld/Fy+2hSxiLWHfYVwLr8VyUx1aP1oBaaiqO1zgJsLrVvlVU8rdAV60wdZ8z+ELiN/Bk3qdWgHqw5ZaBos32rliPVurInII/nGmpA79RIkYPlAgjeiIBJb8hGLWDFhhHuGK+2zAQkwG5FHxCZ0DrMZRex9EXlLNEcsYkWAzUO7x/shRfiP6P7mAcjQOR1tPKTL2WIJutZpho2xzOf6ox2ztn4n38/lq00Ri1h72FhkZPoLMN340PPqYcAtBEPOLoXWqfL5iWeGuzglSTIaOBvtAq9FgvlA5Lq2FjHiTkhY2WDlUSjibVnEeh22AiluQ9CEU0HkkXz3b3/khrcGnSX+TJIkY5H7Wt8kSeqR4lwNzIpYxIoAqzX8UaQEXwC8gO4V/l+05tQgpaIfsvSXAcfa3xr7X8Qi1pOxkejYy2tonXwLefh4z7u7nXMuSZIt5RywAeh6srtRSn+3PtHVcadn/k4XPZevNkUsYu1hK5Mk+QNaP+5K86pzbjpwUZIkG4HPOOdWsAOleLVSF6ckSe5BV7o8gSzz5yFBvAlNfo1IKB+GFCCQoBOx3oltRJPTKCKPdCW2FinL5dbfDSjYjd9RjljEiglbh65cGoACDC1HVvzHkfFnZ3TlWB3wjpX3tN9bHrGIFRm2BzIAvYcU5X7oHPEEJGf1A85Fwn5JJzFfrt3Wc865piRJ+m/jd/L5XL7aFLGIbQ/7S4o/v4p2hzOxcrTO3O2c+wU7UIoBtLowmfXly8DFzrmrkXCyL/At4H+Qtb4J+AHwPULQhBsj1muxpYhHriXySFdiF6OoieVoh+1XhtVFLGJFiC1FQbIWA3egtf0edJXJ3sDlSLkoRTttlyKFoiViEStCbE/L34RuWzgceAT4ear8UeSV11nMl7+JBP9fZT6XJMkhyGB9eBu/k8/n8tWmiEVse1h/01n6O+f+4BQcK50HeSteg2SpHSrFneEuTEmSHIQC+pzvnHsjXUbWzAfQBP8ouu/LlycBR0es12GPWv414K/AL4k8ErGIRWz788ZsdH6yER2tWIyCxDWhs5ejkCKdADOBI9EZzL5olyBiEYuYxtM7SFFoQcamney7ZfZsHdpd64+uLeuq5wrdFxHrPdjf0fGDV9C1X5civrwf+LHTdbAkSTLMObeRHTBFZbgLU5IkA5BbQjm6U24FcpcuRwrxzSiSbT1whGF7Ibe3ioj1OsyXpwO7ogUy8kjEIhax7c0brwIHIEH6LuBH6OqMJiSAD0ZCeBlSmPsgd+uxyDAbsYhFTC7Ym5AXRoLiT/ix0weNwxI05oYiBbarnit0X0Ss92A16DiZQ3w4Aekr3wCG2ln3AWQoxztSKil0BXbk5JyrB36MznHdC5yBlJuBwO9RSPOdgNGG3YrujhwZsV6JjUJXS6xFQmzkkYhFLGIdmTdGIsH6HeQ6ejNynV6MLP5laL1/F80tzfb9zRGLWMS2YPVotzYxLD12VtuzdUhx2NzFzxW6LyLWe7BSw7G/p6DjnDXA5UmSfBL4OnDKjqgIA/Fqpe74oMurH0AT31p0f+xCtr4CphlZC6tQwIiI9W7sLSKPRCxiEescNhGdFV4GvA0cgpTn79p3jkAKtC+fGLGIRWyr8jcs/2G2HjsnouB0X7XycV38XKH7ImK9A/so8iR6lMCHnlf/jNaXtWjNubPQ+lRXfcqIqcuTkyXlq3bN0qkojPlb6ELrKnSxvEPMNxQx3qKI9XpsIZFHIhaxiHUOGwD8DvgbMNc515IkySbkqjndyrVAg3PupSRJ9olYxCJGg3NuSpIkhxk2M2PsvGzlT9h3X0mS5IAufK7QfRGx3oFNAeaineKT0U7xkfa9swCSJPkqii79G3bQFJXhbkzOuTUolPndSZKUOOdaPZYuRyxiPe39EYtYxIoPS6XBwJXOuRYrD0KRpiMWsYi1j7X33e5+LmIR6wpsQyIjzJVOVygNBq5KkqTU8CFIOZ7BDppiAK2YYooppphi2oFTkiR9gJaUAr2lHLGIRaxjWHvf7e7nIhaxbsS+B5Q6537FDpqiMhxTTDHFFFNMMcUUU0wxxRTTVilTOd4RU1SGY4oppphiiimmmGKKKaaYYup1KV6tFFNMMcUUU0wxxRRTTDHFFFOvS1EZjimmmGKKKaaYYooppphiiqnXpagMxxRTTDHFFFNMMcUUU0wxxdTrUlSGY4oppphiiimmmGKKKaaYYup1KSrDMcUUU0wxxRRTTDHFFFNMMfW69P+XM/asBS5zKQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, + "execution_count": 31, "metadata": {}, - "execution_count": 31 + "output_type": "execute_result" } + ], + "source": [ + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(QAE, backend,shots=Nshots)\n", + "result=job.result()\n", + "counts=job.result().get_counts()\n", + "plot_histogram(counts,figsize=(16,8))" ] }, { "cell_type": "code", - "source": [ - "plot_histogram(counts,figsize=(50,30))" - ], + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 832 }, "id": "vLim1948JiGW", - "outputId": "c226de2d-152e-4899-f149-1b20e690115c" + "outputId": "3ab61c9d-a777-4791-c7b6-c3fbe2d0c2c9" }, - "execution_count": 32, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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\n", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, + "execution_count": 32, "metadata": {}, - "execution_count": 32 + "output_type": "execute_result" } + ], + "source": [ + "plot_histogram(counts,figsize=(50,30))" ] }, { "cell_type": "code", - "source": [ - "# post processing: we see two different peaks from the QAE\n", - "\n", - "showQAEoutput(counts,STATELIST,QAEqubits)" - ], + "execution_count": null, "metadata": { - "id": "AEcQ0X_h7FoN", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "eeb1aa82-bcc0-4ba3-dcd0-8330eac98097" + "id": "AEcQ0X_h7FoN", + "outputId": "24d07541-20dd-4979-b39c-e01c580ffb9b" }, - "execution_count": 33, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "Bin with the highest probability: 00000010\n", - "Number of Bin with the highest probability: 2\n", - "The probability of the tail event ['111111'] is: 0.0006022718974138037\n" + "Bin with the highest probability: 11111110\n", + "Number of Bin with the highest probability: 254\n", + "The probability of the tail event ['111111'] is: 0.0006022718974138055\n" ] }, { - "output_type": "execute_result", "data": { "text/plain": [ - "0.0006022718974138037" + "0.0006022718974138055" ] }, + "execution_count": 33, "metadata": {}, - "execution_count": 33 + "output_type": "execute_result" } + ], + "source": [ + "# post processing: we see two different peaks from the QAE\n", + "\n", + "showQAEoutput(counts,STATELIST,QAEqubits)" ] }, { "cell_type": "markdown", - "source": [ - "## Even Larger Example" - ], "metadata": { "id": "8dR2Kh4xQJr_" - } + }, + "source": [ + "## Even Larger Example" + ] }, { "cell_type": "code", - "source": [ - "## large example\n", - "\n", - "nodes=['0','1','2','3','4','5','6','7'] # risk items defition\n", - "edges=[('0','1'),('0','2'),('1','2'),('1','3'),('1','4'),('2','3'),('2','4'),('2','5'),('3','4'),('3','5'),('4','5'),('5','6'),('5','7'),('6','7')] # risk items correlations\n", - "\n", - "probsNodes={'0':0.1, '1':0.2, '2':0.1, '3':0.2, '4':0.1, '5':0.1, '6':0.1, '7':0.1} # intrinsic probs\n", - "probsEdges={('0','1'):0.2, ('0','2'):0.3, ('1','2'):0.2, ('1','3'):0.3, ('1','4'):0.2, ('2','3'):0.3, ('2','4'):0.2, \n", - " ('2','5'):0.3, ('3','4'):0.2, ('3','5'):0.5, ('5','6'):0.3, ('5','7'):0.2} # transition probs\n", - "\n", - "print(\"Number of risk items = \", len(nodes))\n", - "print(\"Number of correlations = \", len(edges))" - ], + "execution_count": 8, "metadata": { - "id": "f98E7QstC0Qc", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "67621486-971d-46a5-fdfd-5846d25ccd69" + "id": "f98E7QstC0Qc", + "outputId": "236ed17f-5246-46a9-b878-a16d001bf636" }, - "execution_count": 34, "outputs": [ { "output_type": "stream", @@ -906,23 +837,32 @@ "Number of correlations = 14\n" ] } + ], + "source": [ + "## larger example\n", + "\n", + "nodes=['0','1','2','3','4','5','6','7'] # risk items defition\n", + "edges=[('0','1'),('0','2'),('1','2'),('1','3'),('1','4'),('2','3'),('2','4'),('2','5'),('3','4'),('3','5'),('4','5'),('5','6'),('5','7'),('6','7')] # risk items correlations\n", + "\n", + "probsNodes={'0':0.1, '1':0.2, '2':0.1, '3':0.2, '4':0.1, '5':0.1, '6':0.1, '7':0.1} # intrinsic probs\n", + "probsEdges={('0','1'):0.2, ('0','2'):0.3, ('1','2'):0.2, ('1','3'):0.3, ('1','4'):0.2, ('2','3'):0.3, ('2','4'):0.2, \n", + " ('2','5'):0.3, ('3','4'):0.2, ('3','5'):0.5, ('4','5'):0.4, ('5','6'):0.3, ('5','7'):0.2, ('6','7'):0.4} # transition probs\n", + "\n", + "print(\"Number of risk items = \", len(nodes))\n", + "print(\"Number of correlations = \", len(edges))" ] }, { "cell_type": "code", - "source": [ - "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", - "rm.draw(output='mpl')" - ], + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "UrAnYtuvRIeT", - "outputId": "e0c72593-3144-49de-bde8-493fdedab387" + "outputId": "8df43d84-0da5-4bec-c6ee-35cecf6739e3" }, - "execution_count": 35, "outputs": [ { "output_type": "stream", @@ -947,6 +887,14 @@ "NOTE: Item 5 is triggered by more than one other RI!\n", "ITEM:\n", "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 7 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", "ITEM:\n" ] }, @@ -954,37 +902,30 @@ "output_type": "execute_result", "data": { "text/plain": [ - "
" + "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, - "execution_count": 35 + "execution_count": 9 } + ], + "source": [ + "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=False) \n", + "rm.draw(output='mpl')" ] }, { "cell_type": "code", - "source": [ - "rm.measure_all()\n", - "display(rm.draw(output='mpl'))\n", - "print(\"-------------------------------\")\n", - "\n", - "backend = Aer.get_backend('qasm_simulator')\n", - "job = execute(rm, backend,shots=100000)\n", - "result=job.result()\n", - "counts=job.result().get_counts()\n", - "plot_histogram(counts,figsize=(16,8))" - ], + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "eJiTuNg5RNu5", - "outputId": "371519e7-c648-4812-b241-330be702b69a" + "outputId": "ed83f3a8-941e-4715-d1cb-0a611d26e730" }, - "execution_count": 36, "outputs": [ { "output_type": "display_data", @@ -992,7 +933,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} }, @@ -1009,67 +950,64 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, - "execution_count": 36 + "execution_count": 10 } + ], + "source": [ + "rm.measure_all()\n", + "display(rm.draw(output='mpl'))\n", + "print(\"-------------------------------\")\n", + "\n", + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(rm, backend,shots=100000)\n", + "result=job.result()\n", + "counts=job.result().get_counts()\n", + "plot_histogram(counts,figsize=(16,8))" ] }, { "cell_type": "code", - "source": [ - "## building the graph from adjacency matrix for visual representation\n", - "G = nx.Graph()\n", - "G = nx.from_numpy_array(mat)\n", - "nx.draw(G, with_labels=True, alpha=0.8, node_size=500)" - ], + "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 222 + "height": 319 }, "id": "KsSdy8ijRgLL", - "outputId": "c73e679b-b6ef-4aa9-9872-39031721baa7" + "outputId": "5746b997-2785-4acc-c415-6271a14c98f2" }, - "execution_count": 1, "outputs": [ { - "output_type": "error", - "ename": "NameError", - "evalue": "ignored", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m## building the graph from adjacency matrix for visual representation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mG\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGraph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mG\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_numpy_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwith_labels\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.8\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m500\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'nx' is not defined" - ] + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} } + ], + "source": [ + "## building the graph from adjacency matrix for visual representation\n", + "G = nx.Graph()\n", + "G = nx.from_numpy_array(mat)\n", + "nx.draw(G, with_labels=True, alpha=0.8, node_size=500)" ] }, { "cell_type": "code", - "source": [ - "## use Oracle to build QAE and evaluate probabaility for state 'STATELIST'\n", - "name = \"test\"\n", - "STATELIST = [\"11111111\"] # we search for the joint probability where all 8 parameters are triggered\n", - "Nshots = 100000 # number of shots\n", - "QAEqubits = 12 # QAE bit precision --> 8 bit strings at the end of the measurement to differentiate 2^8 = 265 bins\n", - "\n", - "\n", - "#rm = BRMlist(RIlist,TPlist,model2gate=True)\n", - "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=True) \n", - "ora = brmoracle(\"ora\",rm,len(nodes),0,STATELIST)\n", - "QAE=qae(QAEqubits,len(nodes),len(nodes),rm,ora)" - ], + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "URNLmbppRtF3", - "outputId": "5190c224-5913-49ac-cb36-9c4762b79701" + "outputId": "137da7f0-865b-469b-ad39-c47f1d5a5edc" }, - "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1094,13 +1032,55 @@ "NOTE: Item 5 is triggered by more than one other RI!\n", "ITEM:\n", "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "ITEM:\n", + "NOTE: Item 7 is triggered by more than one other RI!\n", + "ITEM:\n", + "ITEM:\n", "ITEM:\n" ] } + ], + "source": [ + "## use Oracle to build QAE and evaluate probabaility for state 'STATELIST'\n", + "name = \"test\"\n", + "STATELIST = [\"11111111\"] # we search for the joint probability where all 8 parameters are triggered\n", + "Nshots = 100000 # number of shots\n", + "QAEqubits = 12 # QAE bit precision --> 8 bit strings at the end of the measurement to differentiate 2^8 = 265 bins\n", + "\n", + "\n", + "#rm = BRMlist(RIlist,TPlist,model2gate=True)\n", + "rm, mat = brm(nodes, edges, probsNodes, probsEdges, model2gate=True) \n", + "ora = brmoracle(\"ora\",rm,len(nodes),0,STATELIST)\n", + "QAE=qae(QAEqubits,len(nodes),len(nodes),rm,ora)" ] }, { "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "background_save": true + }, + "id": "98ixVKlqR66o", + "outputId": "4310dd51-3ebb-4ef0-ff51-dc2974780500" + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "ignored", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m## execution with local quantum simulator (qasm simulator)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mbackend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mAer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_backend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'qasm_simulator'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mjob\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexecute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mQAE\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mshots\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mNshots\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mcounts\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_counts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'Aer' is not defined" + ] + } + ], "source": [ "## execution with local quantum simulator (qasm simulator)\n", "backend = Aer.get_backend('qasm_simulator')\n", @@ -1108,28 +1088,32 @@ "result=job.result()\n", "counts=job.result().get_counts()\n", "plot_histogram(counts,figsize=(70,30))" - ], - "metadata": { - "id": "98ixVKlqR66o" - }, - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "H5cYNrUKUwS8" + }, + "outputs": [], "source": [ "# post processing: we see two different peaks from the QAE\n", "\n", "showQAEoutput(counts,STATELIST,QAEqubits)" - ], - "metadata": { - "id": "H5cYNrUKUwS8" - }, - "execution_count": null, - "outputs": [] + ] } ], "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "machine_shape": "hm", + "name": "Risk_Analysis_Hackathon.ipynb", + "provenance": [], + "include_colab_link": true + }, + "gpuClass": "standard", "kernelspec": { "display_name": "Python 3", "language": "python", @@ -1146,11 +1130,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.4" - }, - "colab": { - "name": "Risk_Analysis_Hackathon.ipynb", - "provenance": [], - "include_colab_link": true } }, "nbformat": 4,