diff --git a/challenges/PIQUE challenge/PIQUE_challenge.ipynb b/challenges/PIQUE challenge/PIQUE_challenge.ipynb
new file mode 100644
index 0000000..0269203
--- /dev/null
+++ b/challenges/PIQUE challenge/PIQUE_challenge.ipynb	
@@ -0,0 +1,185 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Challenge: PIQUE\n",
+        "### Team # 32\n",
+        "### Team Members\n",
+        "- Ayelen Perez | Argentina\n",
+        "- Jefferson Granizo | Ecuador\n",
+        "- Jesus Montemayor | Perú\n",
+        "- Rubén Guzman | México\n",
+        "- Andres Diaz | Puerto Rico\n",
+        "\n",
+        "\n",
+        "\n",
+        "# Quantum Investor: Exploring the Fusion of Blockchain and Quantum Computing\n",
+        "\n",
+        "**Introduction**:\n",
+        "\n",
+        "At the exciting intersection of blockchain investment and quantum computing emerges \"Quantum Investor,\" an educational game designed for high school students. This innovative game provides a unique opportunity to explore advanced concepts playfully and educationally, allowing young adventurers to delve into the intriguing world of quantum physics and blockchain investment strategies.\n",
+        "\n",
+        "**Game Description:**\n",
+        "\n",
+        "\"Quantum Investor\" invites you to take on the role of a savvy investor in the fascinating realm of quantum blockchains. Armed with financial knowledge and quantum cryptography strategies, you will face exciting challenges while optimizing your investment and safeguarding the integrity of a blockchain against quantum threats.\n",
+        "\n",
+        "**How It Works:**\n",
+        "\n",
+        "The game presents players with the ability to apply a quantum gate, in this case, the famous Hadamard gate, to strengthen the security and reliability of the blockchain. The application of this gate generates quantum properties such as superposition that enhance the blockchain's resistance to attacks. Participants also have the opportunity to simulate quantum attacks, providing a practical understanding of how threats can impact blockchain security and, ultimately, the investment.\n",
+        "\n",
+        "**Code Development:**\n",
+        "\n",
+        "The game was developed using IBM's Qiskit quantum programming language, a leading tool in quantum computing research and development.\n",
+        "The code is structured modularly to facilitate understanding and allow for future educational expansions. In addition, didactic explanations were incorporated into the game to help students understand why applying a quantum gate improves blockchain security and, consequently, investment performance.\n",
+        "\n",
+        "**Educational Objectives:**\n",
+        "\n",
+        "\"Quantum Investor\" aims to achieve the following educational objectives:\n",
+        "\n",
+        "* ***Basics of Quantum Physics:*** Participants will learn fundamental concepts of quantum physics, such as superposition and quantum entanglement.\n",
+        "\n",
+        "* ***Quantum Investment Strategies:*** They will experience the importance of investment strategies in the context of quantum blockchains, understanding how quantum techniques can impact investment profitability.\n",
+        "\n",
+        "* ***Quantum Programming:*** Players will become familiar with quantum programming using Qiskit, gaining practical insights into designing and executing quantum algorithms for game development.\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "**Conclusion:**\n",
+        "\n",
+        "\"Quantum Investor\" offers an educational experience to ignite students' interest in the exciting intersection of quantum physics and blockchain investment strategies. This game demonstrates that learning about emerging technologies and finance can be fun and accessible, preparing the next generation for the challenges and opportunities of the digital future.\n",
+        "Embark on this thrilling educational adventure and discover the fascinating intersection of finance and quantum computing.\n",
+        "\n",
+        "# Welcome to \"Quantum Investor\"!\n",
+        "\n",
+        "Supporting Tools: ChatGPT"
+      ],
+      "metadata": {
+        "id": "crT2z7MxQhov"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "a0s5Spg6cdCs"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install qiskit[all]\n",
+        "!pip install qiskit-aer"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "7SvM-F6Dcnoh"
+      },
+      "outputs": [],
+      "source": [
+        "import random\n",
+        "from qiskit import QuantumCircuit, Aer, execute\n",
+        "\n",
+        "# Configuración del juego\n",
+        "quantum_bits = 8\n",
+        "blockchain_security = 60\n",
+        "\n",
+        "# Crear qubits cuánticos y registro clásico\n",
+        "qc = QuantumCircuit(quantum_bits, quantum_bits)\n",
+        "\n",
+        "# Variables globales para seguimiento\n",
+        "investment = 1000\n",
+        "current_security_level = blockchain_security\n",
+        "\n",
+        "# Función para aplicar una puerta cuántica de seguridad\n",
+        "def apply_security_gate(qc, level):\n",
+        "    for i in range(quantum_bits):\n",
+        "        for _ in range(level):\n",
+        "            qc.h(i)\n",
+        "\n",
+        "# Función para simular un ataque cuántico\n",
+        "def simulate_quantum_attack(qc):\n",
+        "    for i in range(quantum_bits):\n",
+        "        if random.random() < 0.2:\n",
+        "            qc.measure(i, i)\n",
+        "\n",
+        "# Función para calcular el nivel de seguridad\n",
+        "def calculate_security_level(success_rate):\n",
+        "    return int(blockchain_security * (1 - success_rate))\n",
+        "\n",
+        "# Función para mostrar el estado actual\n",
+        "def show_game_state():\n",
+        "    print(f\"Inversión actual: {investment} créditos\")\n",
+        "    print(f\"Nivel de seguridad de la blockchain: {current_security_level}\")\n",
+        "    print(f\"Qubits cuánticos: {quantum_bits}\")\n",
+        "\n",
+        "# Función para ejecutar el juego\n",
+        "def run_game():\n",
+        "    global current_security_level, investment\n",
+        "\n",
+        "    while True:\n",
+        "        show_game_state()\n",
+        "\n",
+        "        # Opciones del jugador\n",
+        "        print(\"Opciones:\")\n",
+        "        print(\"1. Aplicar seguridad a la blockchain\")\n",
+        "        print(\"2. Simular ataque cuántico\")\n",
+        "        print(\"3. Salir del juego\")\n",
+        "\n",
+        "        choice = input(\"Elige una opción: \")\n",
+        "\n",
+        "        if choice == \"1\":\n",
+        "            # Explicación didáctica\n",
+        "            print(\"Al aplicar una puerta cuántica, como la compuerta Hadamard, a los qubits de la blockchain,\")\n",
+        "            print(\"se generan propiedades cuánticas que fortalecen su seguridad.\")\n",
+        "            print(\"La compuerta Hadamard se utiliza para crear superposiciones, lo que hace que sea más difícil para\")\n",
+        "            print(\"los atacantes predecir la información en los qubits, mejorando así la seguridad.\")\n",
+        "            apply_security_gate(qc, 1)\n",
+        "            current_security_level += 10\n",
+        "            investment -= 100\n",
+        "        elif choice == \"2\":\n",
+        "            if choice == \"2\":\n",
+        "                qc.measure(range(quantum_bits), range(quantum_bits))\n",
+        "                backend = Aer.get_backend('qasm_simulator')\n",
+        "                job = execute(qc, backend, shots=1024)\n",
+        "                result = job.result()\n",
+        "\n",
+        "                simulate_quantum_attack(qc)\n",
+        "                counts = result.get_counts()\n",
+        "                success_rate = counts.get('0', 0) / 1024\n",
+        "                new_security_level = calculate_security_level(success_rate)\n",
+        "\n",
+        "                # Determinar el resultado del ataque\n",
+        "                if current_security_level > 80:\n",
+        "                    print(\"¡La blockchain es segura!\")\n",
+        "                else:\n",
+        "                    print(\"¡La blockchain ha sido comprometida!\")\n",
+        "\n",
+        "                # Actualizar la inversión en función de los resultados del ataque\n",
+        "                investment += 100 if new_security_level > 80 else -100\n",
+        "        elif choice == \"3\":\n",
+        "            break\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    run_game()\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/challenges/QOSF challenge/TicTacToe (1).ipynb b/challenges/QOSF challenge/TicTacToe (1).ipynb
new file mode 100644
index 0000000..7bd3499
--- /dev/null
+++ b/challenges/QOSF challenge/TicTacToe (1).ipynb	
@@ -0,0 +1,310 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Challenge: QOSF\n",
+        "### Team # 32\n",
+        "### Team Members\n",
+        "- Ayelen Perez | Argentina\n",
+        "- Jefferson Granizo | Ecuador\n",
+        "- Jesus Montemayor | Perú\n",
+        "- Rubén Guzman | México\n",
+        "- Andres Diaz | Puerto Rico"
+      ],
+      "metadata": {
+        "id": "5SltFSOKWsqm"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "bRuwWMVmXXv_"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install qiskit[all]\n",
+        "!pip install qiskit-aer\n",
+        "!pip install qiskit-ignis"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from os import read\n",
+        "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer, transpile, assemble\n",
+        "from qiskit.primitives import Sampler\n",
+        "from qiskit.visualization import plot_histogram\n",
+        "import random\n",
+        "import math\n",
+        "\n",
+        "posicion_f_X = None\n",
+        "posicion_c_X = None\n",
+        "posicion_diagonal_X = None\n",
+        "posicion_diagonal_secundaria_X = None\n",
+        "\n",
+        "celdas = [0, 1, 2, 3, 4, 5, 6, 7, 8]\n",
+        "numeros_de_celda_X = []\n",
+        "numeros_de_celda_O = []\n",
+        "\n",
+        "\n",
+        "pi = math.pi\n",
+        "n=0\n",
+        "\n",
+        "qr = QuantumRegister(9,'q')\n",
+        "cr = ClassicalRegister(9,'c')\n",
+        "\n",
+        "qc = QuantumCircuit(qr,cr)\n",
+        "\n",
+        "matriz_1 = [\n",
+        "    ['X', 'O', 'O'],\n",
+        "    ['X', '-', '-'],\n",
+        "    ['O', '-', '-']\n",
+        "]\n",
+        "\n",
+        "# Matriz 2\n",
+        "matriz_2 = [\n",
+        "    ['X', 'O', 'O'],\n",
+        "    ['X', '-', '-'],\n",
+        "    ['-', '-', '-']\n",
+        "]\n",
+        "\n",
+        "while True:\n",
+        "    numeros_de_celda_X = []\n",
+        "    numeros_de_celda_O = []\n",
+        "    print(\"Elige una opción:\")\n",
+        "    print(\"1. Mostrar Matriz 1\")\n",
+        "    print(\"2. Mostrar Matriz 2\")\n",
+        "    print(\"3. Salir\")\n",
+        "\n",
+        "    opcion = input(\"Ingresa el número de la opción: \")\n",
+        "\n",
+        "    if opcion == '1':\n",
+        "        for fila in matriz_1:\n",
+        "            print(' '.join(fila))\n",
+        "            tablero = matriz_1\n",
+        "    elif opcion == '2':\n",
+        "        for fila in matriz_2:\n",
+        "            print(' '.join(fila))\n",
+        "            tablero = matriz_2\n",
+        "\n",
+        "        ps = input(\"Ingresa la posición que desea utilizar 'O' (4,5,6,7,8): \")\n",
+        "        ps = int(ps)\n",
+        "\n",
+        "    elif opcion == '3':\n",
+        "        break\n",
+        "    else:\n",
+        "        print(\"Opción no válida. Por favor, elige 1, 2 o 3.\")\n",
+        "\n",
+        "    fila = ps // len(tablero)\n",
+        "    columna = ps % len(tablero[0])\n",
+        "\n",
+        "    # Reemplazar el valor en la posición con 'X'\n",
+        "    tablero[fila][columna] = 'O'\n",
+        "\n",
+        "    for fila in tablero:\n",
+        "        print(fila)\n",
+        "\n",
+        "    for fila_idx, fila in enumerate(tablero):\n",
+        "        for columna_idx, valor in enumerate(fila):\n",
+        "            if valor == 'X':\n",
+        "                numero_de_celda = fila_idx * 3 + columna_idx\n",
+        "                numeros_de_celda_X.append(numero_de_celda)\n",
+        "\n",
+        "    for fila_ido, fila in enumerate(tablero):\n",
+        "        for columna_ido, valor in enumerate(fila):\n",
+        "            if valor == 'O':\n",
+        "                numero_de_celda = fila_ido * 3 + columna_ido\n",
+        "                numeros_de_celda_O.append(numero_de_celda)\n",
+        "\n",
+        "    for i in numeros_de_celda_X:\n",
+        "        qc.x(i)\n",
+        "\n",
+        "    qc.barrier()\n",
+        "\n",
+        "    index = list(set(numeros_de_celda_X + numeros_de_celda_O))\n",
+        "    index_set = set(index)\n",
+        "    celdas_set = set(celdas)\n",
+        "    resultado = list(index_set.symmetric_difference(celdas_set))\n",
+        "\n",
+        "    for i in resultado:\n",
+        "        qc.h(i)\n",
+        "        n = n+1\n",
+        "\n",
+        "    qc.barrier()\n",
+        "\n",
+        "    angle=pi/(1.5*n)\n",
+        "\n",
+        "    for ind in numeros_de_celda_X:\n",
+        "        fila = ind // 3\n",
+        "        columna = ind % 3\n",
+        "        elementos_fila = [fila * 3 + i for i in range(3)]\n",
+        "        elementos_columna = [i * 3 + columna for i in range(3)]\n",
+        "        if fila == columna:\n",
+        "            elementos_diagonal_principal = [i * 3 + i for i in range(3)]\n",
+        "        else:\n",
+        "            elementos_diagonal_principal = []\n",
+        "        if fila + columna == 2:\n",
+        "            elementos_diagonal_secundaria = [i * 3 + (2 - i) for i in range(3)]\n",
+        "        else:\n",
+        "            elementos_diagonal_secundaria = []\n",
+        "        todas_las_listas = elementos_fila + elementos_columna + elementos_diagonal_principal + elementos_diagonal_secundaria\n",
+        "\n",
+        "        for j in todas_las_listas:\n",
+        "            if ind != j:  # Asegurarse de que ind y j no sean iguales\n",
+        "                qc.crz(angle, ind, j)\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "    for columna in range(len(tablero[0])):\n",
+        "        elementos_columna = [tablero[fila][columna] for fila in range(len(tablero))]\n",
+        "        count_X = elementos_columna.count('X')\n",
+        "\n",
+        "        if count_X == 2:\n",
+        "            for fila, elemento in enumerate(elementos_columna):\n",
+        "                if elemento == '-':\n",
+        "                    posicion_c_X = fila * len(tablero[0]) + columna\n",
+        "                    break\n",
+        "    if posicion_c_X is not None:\n",
+        "        for i in numeros_de_celda_X:\n",
+        "            qc.crz(angle, i, posicion_c_X)\n",
+        "\n",
+        "\n",
+        "    for fila in range(len(tablero)):\n",
+        "\n",
+        "        count_X = tablero[fila].count('X')\n",
+        "\n",
+        "        if count_X == 2:\n",
+        "            for columna, elemento in enumerate(tablero[fila]):\n",
+        "                if elemento == '-':\n",
+        "                    posicion_f_X = fila * len(tablero[0]) + columna\n",
+        "                    break\n",
+        "\n",
+        "        if posicion_f_X is not None:\n",
+        "            for i in numeros_de_celda_X:\n",
+        "                qc.crz(angle, i, posicion_f_X)\n",
+        "\n",
+        "\n",
+        "\n",
+        "    qc.barrier()\n",
+        "    for i in resultado:\n",
+        "        qc.h(i)\n",
+        "\n",
+        "    qc.barrier()\n",
+        "\n",
+        "    for i in numeros_de_celda_X:\n",
+        "        qc.x(i)\n",
+        "\n",
+        "    qc.barrier()\n",
+        "\n",
+        "    qc.measure(qr,cr)\n",
+        "    break\n",
+        "display(qc.draw(output=\"mpl\"))\n",
+        "simulator = Aer.get_backend('qasm_simulator')\n",
+        "job = execute(qc, simulator, shots=8200)\n",
+        "result = job.result()\n",
+        "counts = result.get_counts()\n",
+        "\n",
+        "sorted_results = sorted(counts, key=counts.get, reverse=True)\n",
+        "\n",
+        "if sorted_results[0] == '0' * len(sorted_results[0]):\n",
+        "    if len(sorted_results) > 1:\n",
+        "        max_result = sorted_results[1]\n",
+        "else:\n",
+        "    max_result = sorted_results[0]\n",
+        "position = max_result.rfind('1')\n",
+        "position = position - 8\n",
+        "if position < 0:\n",
+        "  position = position * -1\n",
+        "print(\"El movimiento optimo será\",position)\n",
+        "\n",
+        "fila = position // len(tablero)\n",
+        "columna = position % len(tablero[0])\n",
+        "\n",
+        "# Reemplazar el valor en la posición con 'X'\n",
+        "tablero[fila][columna] = 'X'\n",
+        "\n",
+        "for fila in tablero:\n",
+        "    print(fila)\n",
+        "\n",
+        "plot_histogram(counts)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "9gd8NXn8XZAK",
+        "outputId": "8ee8dfa9-874e-4d8f-8b91-81fb463efb01"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Elige una opción:\n",
+            "1. Mostrar Matriz 1\n",
+            "2. Mostrar Matriz 2\n",
+            "3. Salir\n",
+            "Ingresa el número de la opción: 2\n",
+            "X O O\n",
+            "X - -\n",
+            "- - -\n",
+            "Ingresa la posición que desea utilizar 'O' (4,5,6,7,8): 5\n",
+            "['X', 'O', 'O']\n",
+            "['X', '-', 'O']\n",
+            "['-', '-', '-']\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 2210.55x1789.28 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "El movimiento optimo será 6\n",
+            "['X', 'O', 'O']\n",
+            "['X', '-', 'O']\n",
+            "['X', '-', '-']\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 700x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 34
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/challenges/QOSF challenge/challenge_openqaoa.ipynb b/challenges/QOSF challenge/challenge_openqaoa.ipynb
new file mode 100644
index 0000000..80e2562
--- /dev/null
+++ b/challenges/QOSF challenge/challenge_openqaoa.ipynb	
@@ -0,0 +1,3623 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "auLfxa4-RRQe"
+      },
+      "source": [
+        "# Challenge: OpenQAOA\n",
+        "### Team # 32\n",
+        "### Team Members\n",
+        "- Ayelen Perez | Argentina\n",
+        "- Jefferson Granizo | Ecuador\n",
+        "- Jesus Montemayor | Perú\n",
+        "- Rubén Guzman | México\n",
+        "- Andres Diaz | Puerto Rico"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "It1BO2eERRQl"
+      },
+      "source": [
+        "# Problem Definition - Tic-Tac-Toe\n",
+        "Introduction\n",
+        "Tic-tac-toe, also known as noughts and crosses or Xs and Os, is a classic paper-and-pencil game for two players. The game is typically played on a 3x3 grid, although variations with larger grids exist. The objective of the game is simple: one player tries to get three of their marks (either X or O) in a row, either horizontally, vertically, or diagonally, before their opponent does. Consider you want to play the classic version in a 3x3 grid, that you are the \"X\"s, and that you want to design a winning strategy. Consider also the following convention:\n",
+        "\n",
+        "the state of the X's is |1>\n",
+        "the state of the O's is |0>\n",
+        "the state of the empty cells in an unknown state.\n",
+        "Consider each bit of the tic-tac-toe board is represented by a qubit, in the form:\n",
+        "```\n",
+        "| q0 | q1 | q2 |\n",
+        "|----|----|----|\n",
+        "| q3 | q4 | q5 |\n",
+        "|----|----|----|\n",
+        "| q6 | q7 | q8 |\n",
+        "```\n",
+        "\n",
+        "We can convert this problem into a binary optimization problem, known as QUBO (Quadratic unconstrained binary optimization) in order to use known Quantum Approximate Optimization (QAOA) Algorithms. We first create a cost function, that can be of the form:\n",
+        "\n",
+        "$$𝐶(𝑞𝑖)=𝑀(𝑞_0+𝑞_1+𝑞_2+𝑞_3+𝑞_4+𝑞_5+𝑞_6+𝑞_7+𝑞_8−2)^2−(𝑞_0+𝑞_1+𝑞_2)^2−(𝑞_3+𝑞_4+𝑞_5)^2−(𝑞_6+𝑞_7+𝑞_8)^2−(𝑞_0+𝑞_3+𝑞_6)^2−(𝑞_1+𝑞_4+𝑞_7)^2−(𝑞_2+𝑞_5+𝑞_8)^2−(𝑞_0+𝑞_4+𝑞_8)^2−(𝑞_2+𝑞_4+𝑞_6)^2$$\n",
+        "\n",
+        "The idea is to minimize this function when you get three X's in a row (vertical, horizontal, or diagonal), represented by the terms that are being subtracted. We do have the challenge of considering each of the possibilities of our opponent, and the order of play. We chose this well-know problem in order to learn how to apply QAOA and its different options (different simulation methods, inclusion of noise, etc) to a case where the minimum-energy state can be readily verified.\n",
+        "\n",
+        "## Analysis of a toy problem - case # 1\n",
+        "\n",
+        "To better understand how we can design a winning strategy and determine the best possibilities to win, we are going to consider the situation in the figure below. Your turn is next and we need to develop a quantum algorithm to be able to find the best decisions with the higher probability.\n",
+        "\n",
+        "```\n",
+        "|  X |  O |  O |\n",
+        "|----|----|----|\n",
+        "|  X |    |    |\n",
+        "|----|----|----|\n",
+        "|  O |    |    |\n",
+        "```\n",
+        "\n",
+        "We can then define a quantum state $|q_0q_1q_2q_3>$ made up of four qubits, each one representing the state of the four missing spaces:\n",
+        "\n",
+        "```\n",
+        "|  X |  O |  O |\n",
+        "|----|----|----|\n",
+        "|  X | q0 | q1 |\n",
+        "|----|----|----|\n",
+        "|  O | q2 | q3 |\n",
+        "```\n",
+        "\n",
+        "Consider now all the possible ways to win (eight in total: 3 vertical, 3 horizontal, and 2 diagonal). Of this eight possibilities, only two of them (second row horizontal and diagonal from the top right), are possible with the current stay of play, simplifying the definiton of our cost function. Our cost function $C$ now becomes:\n",
+        "\n",
+        "$$C(q_i) = M(1+0+0+1+q_0+q_1+0+q_2+q_3-2)^2-(1+q_0+q_1)^2-(1+q_0+q_3)^2$$\n",
+        "$$C(q_i) = M(q_0+q_1+q_2+q_3)^2-(1+q_0+q_1)^2-(1+q_0+q_3)^2 $$\n",
+        "\n",
+        "We now proceed to consider constraints, determined by the dynamics of the game and that we don't want our opponent to win.\n",
+        "\n",
+        "**Equality Constraints**\n",
+        "\n",
+        "From the order of play, we are missing at most two X's and two O's. Since we are playing the X's and we have two more plays, we have the condition:\n",
+        "\n",
+        "$$q_0+q_1+q_2+q_3 = 2$$\n",
+        "\n",
+        "Note that by incorporating this condition into our Cost function, we can further simplify it to:\n",
+        "\n",
+        "$$C(q_i) = 4M -(1+q_0+q_1)^2-(1+q_0+q_3)^2 $$\n",
+        "\n",
+        "where we choose $M$ to our convenience. Note the equality constraint still needs to be enforced, to guarantee there are exactly two X's in the missing squares.\n",
+        "\n",
+        "**Inequality Constraints**\n",
+        "\n",
+        "We can also prevent our opponent from winning by not allowing him to place an 'O' in the center square. We can represent this by requiring:\n",
+        "\n",
+        "$$q_0 > 0$$\n",
+        "\n",
+        "We can try to run the program with or without this inequality constraint to see what happens.\n",
+        "\n",
+        "## Analysis of a toy problem - case # 2\n",
+        "A variation of case 1 is to consider starting one step earlier with your opponent not having chosen yet, as shown below. We can choose this option by calling the function `Problem` with input parameter '2'.\n",
+        "\n",
+        "```\n",
+        "|  X |  O |  O |\n",
+        "|----|----|----|\n",
+        "|  X |    |    |\n",
+        "|----|----|----|\n",
+        "|    |    |    |\n",
+        "```\n",
+        "\n",
+        "We can then define a quantum state $|x_0x_1x_2x_3x_4>$ made up of four qubits, each one representing the state of the four missing spaces:\n",
+        "\n",
+        "```\n",
+        "|  X |  O |  O |\n",
+        "|----|----|----|\n",
+        "|  X | q0 | q1 |\n",
+        "|----|----|----|\n",
+        "| q4 | q2 | q3 |\n",
+        "```\n",
+        "\n",
+        "## Process\n",
+        "The problem has been solved using the following workflow:\n",
+        "- Part 1: problem definition in function `Problem` using the QUBO implementation described above. The problem is then converted to an Ising Model and solved using QAOA.\n",
+        "- Part 2: improvement of the QAOA algorithm, considering other simulation methods: statevector_simulator, shot-based simulator, and annealing parameterization\n",
+        "- Part 3: implementation of the model using a Noise Model.\n",
+        "- Part 4: the different model are compared by plotting the cost function"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BYIwp4ttRRQp"
+      },
+      "source": [
+        "#  Part 1 Problem definition and solution using QAOA"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "K2ZzTO7mRRQr"
+      },
+      "outputs": [],
+      "source": [
+        "%matplotlib notebook\n",
+        "\n",
+        "# Import external libraries to present an manipulate the data\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import pandas as pd\n",
+        "\n",
+        "# Import docplex model to generate the problem to optimize\n",
+        "from docplex.mp.model import Model\n",
+        "\n",
+        "# Import the libraries needed to employ the QAOA quantum algorithm using OpenQAOA\n",
+        "from openqaoa import QAOA\n",
+        "\n",
+        "# method to covnert a docplex model to a qubo problem\n",
+        "from openqaoa.problems.converters import FromDocplex2IsingModel #check this method and properties\n",
+        "from openqaoa.backends import create_device\n",
+        "\n",
+        "# method to find the correct states for the QAOA object\n",
+        "from openqaoa.utilities import ground_state_hamiltonian"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "W8Y_TZrDRRQt"
+      },
+      "source": [
+        "Code your problem"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "B9vRaRMtRRQu"
+      },
+      "outputs": [],
+      "source": [
+        "# inputs\n",
+        "\n",
+        "def Problem(value): #(values,weights, max_weight):\n",
+        "\n",
+        "    # initialize a model\n",
+        "    mdl = Model(\"Basic Problem using minimize\")\n",
+        "\n",
+        "    if value == 1:\n",
+        "        #tic-tac-toe with only 4 cells left empty\n",
+        "        #|  X |  O |  O |\n",
+        "        #|  X | q0 | q1 |\n",
+        "        #|  O | q2 | q3 |\n",
+        "        # indicate the binary variables\n",
+        "        n_vars = 4 # Number of variables\n",
+        "        q = mdl.binary_var_list(n_vars, name=\"q\")\n",
+        "        # define the objective function\n",
+        "        obj_func = 40 - (1+q[0]+q[1])*(1+q[0]+q[1]) - (1+q[0]+q[3])*(1+q[0]+q[3])\n",
+        "        mdl.minimize(obj_func)\n",
+        "        # add the constraints\n",
+        "        mdl.add_constraint(q[0] + q[1] + q[2] + q[3] == 2)\n",
+        "        #mdl.add_constraint(q[0] >= 0)\n",
+        "    elif value == 2:\n",
+        "        #tic-tac-toe with 5 cells left empty\n",
+        "        #|  X |  O |  O |\n",
+        "        #|  X | q0 | q1 |\n",
+        "        #| q4 | q2 | q3 |\n",
+        "        # indicate the binary variables\n",
+        "        n_vars = 5 # Number of variables\n",
+        "        q = mdl.binary_var_list(n_vars, name=\"q\")\n",
+        "        # define the objective function\n",
+        "        obj_func = 40 - (2+q[4])*(2+q[4]) -(q[2]+q[3]+q[4])*(q[2]+q[3]+q[4]) - (1+q[0]+q[1])*(1+q[0]+q[1]) - (1+q[0]+q[3])*(1+q[0]+q[3])\n",
+        "        mdl.minimize(obj_func)\n",
+        "        # add the constraints\n",
+        "        mdl.add_constraint(q[0] + q[1] + q[2] + q[3] + q[4] == 2)\n",
+        "        #mdl.add_constraint(q[0] >= 0)\n",
+        "    # print a summary of the docplex model\n",
+        "    # print(mdl.prettyprint())\n",
+        "\n",
+        "    return mdl #return model, check FromDocplex2IsingModel\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "KTE07LS3RRQv",
+        "outputId": "f745ed9b-36f3-42be-b7e0-12a9157ec594"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Warning: Model name contains whitespaces: |Basic Problem using minimize|\n",
+            "// This file has been generated by DOcplex\n",
+            "// model name is: Basic Problem using minimize\n",
+            "// var contrainer section\n",
+            "dvar bool q[4];\n",
+            "\n",
+            "// single vars section\n",
+            "dvar bool q_0;\n",
+            "dvar bool q_1;\n",
+            "dvar bool q_2;\n",
+            "dvar bool q_3;\n",
+            "\n",
+            "minimize\n",
+            " - 72 q_0 - 70 q_1 - 68 q_2 - 70 q_3 [ 15 q_0^2 + 32 q_0*q_1 + 34 q_0*q_2\n",
+            " + 32 q_0*q_3 + 16 q_1^2 + 34 q_1*q_2 + 34 q_1*q_3 + 17 q_2^2 + 34 q_2*q_3\n",
+            " + 16 q_3^2 ] + 106;\n",
+            " \n",
+            "subject to {\n",
+            "\n",
+            "}\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Ising encoding of the QUBO problem\n",
+        "mdl = Problem(1)\n",
+        "qubo = FromDocplex2IsingModel(mdl)\n",
+        "ising_encoding = qubo.ising_model\n",
+        "# Docplex encoding of the QUBO problem\n",
+        "mdl_qubo_docplex = qubo.qubo_docplex\n",
+        "\n",
+        "mdl_qubo_docplex.prettyprint()\n",
+        "# Print in a df the ising encoding (we need to remove keys: 'problem_instance' and 'metadata'))\n",
+        "#ising_encoding_dict = ising_encoding.asdict(exclude_keys=['problem_instance', 'metadata'])\n",
+        "#pd.DataFrame(ising_encoding_dict)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "JEcISoRiRRQy",
+        "outputId": "399b08a1-7831-43ff-eedf-7629468a2d6b"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/javascript": [
+              "/* Put everything inside the global mpl namespace */\n",
+              "/* global mpl */\n",
+              "window.mpl = {};\n",
+              "\n",
+              "mpl.get_websocket_type = function () {\n",
+              "    if (typeof WebSocket !== 'undefined') {\n",
+              "        return WebSocket;\n",
+              "    } else if (typeof MozWebSocket !== 'undefined') {\n",
+              "        return MozWebSocket;\n",
+              "    } else {\n",
+              "        alert(\n",
+              "            'Your browser does not have WebSocket support. ' +\n",
+              "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+              "                'Firefox 4 and 5 are also supported but you ' +\n",
+              "                'have to enable WebSockets in about:config.'\n",
+              "        );\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
+              "    this.id = figure_id;\n",
+              "\n",
+              "    this.ws = websocket;\n",
+              "\n",
+              "    this.supports_binary = this.ws.binaryType !== undefined;\n",
+              "\n",
+              "    if (!this.supports_binary) {\n",
+              "        var warnings = document.getElementById('mpl-warnings');\n",
+              "        if (warnings) {\n",
+              "            warnings.style.display = 'block';\n",
+              "            warnings.textContent =\n",
+              "                'This browser does not support binary websocket messages. ' +\n",
+              "                'Performance may be slow.';\n",
+              "        }\n",
+              "    }\n",
+              "\n",
+              "    this.imageObj = new Image();\n",
+              "\n",
+              "    this.context = undefined;\n",
+              "    this.message = undefined;\n",
+              "    this.canvas = undefined;\n",
+              "    this.rubberband_canvas = undefined;\n",
+              "    this.rubberband_context = undefined;\n",
+              "    this.format_dropdown = undefined;\n",
+              "\n",
+              "    this.image_mode = 'full';\n",
+              "\n",
+              "    this.root = document.createElement('div');\n",
+              "    this.root.setAttribute('style', 'display: inline-block');\n",
+              "    this._root_extra_style(this.root);\n",
+              "\n",
+              "    parent_element.appendChild(this.root);\n",
+              "\n",
+              "    this._init_header(this);\n",
+              "    this._init_canvas(this);\n",
+              "    this._init_toolbar(this);\n",
+              "\n",
+              "    var fig = this;\n",
+              "\n",
+              "    this.waiting = false;\n",
+              "\n",
+              "    this.ws.onopen = function () {\n",
+              "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
+              "        fig.send_message('send_image_mode', {});\n",
+              "        if (fig.ratio !== 1) {\n",
+              "            fig.send_message('set_device_pixel_ratio', {\n",
+              "                device_pixel_ratio: fig.ratio,\n",
+              "            });\n",
+              "        }\n",
+              "        fig.send_message('refresh', {});\n",
+              "    };\n",
+              "\n",
+              "    this.imageObj.onload = function () {\n",
+              "        if (fig.image_mode === 'full') {\n",
+              "            // Full images could contain transparency (where diff images\n",
+              "            // almost always do), so we need to clear the canvas so that\n",
+              "            // there is no ghosting.\n",
+              "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+              "        }\n",
+              "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
+              "    };\n",
+              "\n",
+              "    this.imageObj.onunload = function () {\n",
+              "        fig.ws.close();\n",
+              "    };\n",
+              "\n",
+              "    this.ws.onmessage = this._make_on_message_function(this);\n",
+              "\n",
+              "    this.ondownload = ondownload;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_header = function () {\n",
+              "    var titlebar = document.createElement('div');\n",
+              "    titlebar.classList =\n",
+              "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
+              "    var titletext = document.createElement('div');\n",
+              "    titletext.classList = 'ui-dialog-title';\n",
+              "    titletext.setAttribute(\n",
+              "        'style',\n",
+              "        'width: 100%; text-align: center; padding: 3px;'\n",
+              "    );\n",
+              "    titlebar.appendChild(titletext);\n",
+              "    this.root.appendChild(titlebar);\n",
+              "    this.header = titletext;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
+              "\n",
+              "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
+              "\n",
+              "mpl.figure.prototype._init_canvas = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
+              "    canvas_div.setAttribute(\n",
+              "        'style',\n",
+              "        'border: 1px solid #ddd;' +\n",
+              "            'box-sizing: content-box;' +\n",
+              "            'clear: both;' +\n",
+              "            'min-height: 1px;' +\n",
+              "            'min-width: 1px;' +\n",
+              "            'outline: 0;' +\n",
+              "            'overflow: hidden;' +\n",
+              "            'position: relative;' +\n",
+              "            'resize: both;'\n",
+              "    );\n",
+              "\n",
+              "    function on_keyboard_event_closure(name) {\n",
+              "        return function (event) {\n",
+              "            return fig.key_event(event, name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    canvas_div.addEventListener(\n",
+              "        'keydown',\n",
+              "        on_keyboard_event_closure('key_press')\n",
+              "    );\n",
+              "    canvas_div.addEventListener(\n",
+              "        'keyup',\n",
+              "        on_keyboard_event_closure('key_release')\n",
+              "    );\n",
+              "\n",
+              "    this._canvas_extra_style(canvas_div);\n",
+              "    this.root.appendChild(canvas_div);\n",
+              "\n",
+              "    var canvas = (this.canvas = document.createElement('canvas'));\n",
+              "    canvas.classList.add('mpl-canvas');\n",
+              "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
+              "\n",
+              "    this.context = canvas.getContext('2d');\n",
+              "\n",
+              "    var backingStore =\n",
+              "        this.context.backingStorePixelRatio ||\n",
+              "        this.context.webkitBackingStorePixelRatio ||\n",
+              "        this.context.mozBackingStorePixelRatio ||\n",
+              "        this.context.msBackingStorePixelRatio ||\n",
+              "        this.context.oBackingStorePixelRatio ||\n",
+              "        this.context.backingStorePixelRatio ||\n",
+              "        1;\n",
+              "\n",
+              "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+              "\n",
+              "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
+              "        'canvas'\n",
+              "    ));\n",
+              "    rubberband_canvas.setAttribute(\n",
+              "        'style',\n",
+              "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
+              "    );\n",
+              "\n",
+              "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
+              "    if (this.ResizeObserver === undefined) {\n",
+              "        if (window.ResizeObserver !== undefined) {\n",
+              "            this.ResizeObserver = window.ResizeObserver;\n",
+              "        } else {\n",
+              "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
+              "            this.ResizeObserver = obs.ResizeObserver;\n",
+              "        }\n",
+              "    }\n",
+              "\n",
+              "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
+              "        var nentries = entries.length;\n",
+              "        for (var i = 0; i < nentries; i++) {\n",
+              "            var entry = entries[i];\n",
+              "            var width, height;\n",
+              "            if (entry.contentBoxSize) {\n",
+              "                if (entry.contentBoxSize instanceof Array) {\n",
+              "                    // Chrome 84 implements new version of spec.\n",
+              "                    width = entry.contentBoxSize[0].inlineSize;\n",
+              "                    height = entry.contentBoxSize[0].blockSize;\n",
+              "                } else {\n",
+              "                    // Firefox implements old version of spec.\n",
+              "                    width = entry.contentBoxSize.inlineSize;\n",
+              "                    height = entry.contentBoxSize.blockSize;\n",
+              "                }\n",
+              "            } else {\n",
+              "                // Chrome <84 implements even older version of spec.\n",
+              "                width = entry.contentRect.width;\n",
+              "                height = entry.contentRect.height;\n",
+              "            }\n",
+              "\n",
+              "            // Keep the size of the canvas and rubber band canvas in sync with\n",
+              "            // the canvas container.\n",
+              "            if (entry.devicePixelContentBoxSize) {\n",
+              "                // Chrome 84 implements new version of spec.\n",
+              "                canvas.setAttribute(\n",
+              "                    'width',\n",
+              "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
+              "                );\n",
+              "                canvas.setAttribute(\n",
+              "                    'height',\n",
+              "                    entry.devicePixelContentBoxSize[0].blockSize\n",
+              "                );\n",
+              "            } else {\n",
+              "                canvas.setAttribute('width', width * fig.ratio);\n",
+              "                canvas.setAttribute('height', height * fig.ratio);\n",
+              "            }\n",
+              "            canvas.setAttribute(\n",
+              "                'style',\n",
+              "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
+              "            );\n",
+              "\n",
+              "            rubberband_canvas.setAttribute('width', width);\n",
+              "            rubberband_canvas.setAttribute('height', height);\n",
+              "\n",
+              "            // And update the size in Python. We ignore the initial 0/0 size\n",
+              "            // that occurs as the element is placed into the DOM, which should\n",
+              "            // otherwise not happen due to the minimum size styling.\n",
+              "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
+              "                fig.request_resize(width, height);\n",
+              "            }\n",
+              "        }\n",
+              "    });\n",
+              "    this.resizeObserverInstance.observe(canvas_div);\n",
+              "\n",
+              "    function on_mouse_event_closure(name) {\n",
+              "        return function (event) {\n",
+              "            return fig.mouse_event(event, name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mousedown',\n",
+              "        on_mouse_event_closure('button_press')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseup',\n",
+              "        on_mouse_event_closure('button_release')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'dblclick',\n",
+              "        on_mouse_event_closure('dblclick')\n",
+              "    );\n",
+              "    // Throttle sequential mouse events to 1 every 20ms.\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mousemove',\n",
+              "        on_mouse_event_closure('motion_notify')\n",
+              "    );\n",
+              "\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseenter',\n",
+              "        on_mouse_event_closure('figure_enter')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseleave',\n",
+              "        on_mouse_event_closure('figure_leave')\n",
+              "    );\n",
+              "\n",
+              "    canvas_div.addEventListener('wheel', function (event) {\n",
+              "        if (event.deltaY < 0) {\n",
+              "            event.step = 1;\n",
+              "        } else {\n",
+              "            event.step = -1;\n",
+              "        }\n",
+              "        on_mouse_event_closure('scroll')(event);\n",
+              "    });\n",
+              "\n",
+              "    canvas_div.appendChild(canvas);\n",
+              "    canvas_div.appendChild(rubberband_canvas);\n",
+              "\n",
+              "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
+              "    this.rubberband_context.strokeStyle = '#000000';\n",
+              "\n",
+              "    this._resize_canvas = function (width, height, forward) {\n",
+              "        if (forward) {\n",
+              "            canvas_div.style.width = width + 'px';\n",
+              "            canvas_div.style.height = height + 'px';\n",
+              "        }\n",
+              "    };\n",
+              "\n",
+              "    // Disable right mouse context menu.\n",
+              "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
+              "        event.preventDefault();\n",
+              "        return false;\n",
+              "    });\n",
+              "\n",
+              "    function set_focus() {\n",
+              "        canvas.focus();\n",
+              "        canvas_div.focus();\n",
+              "    }\n",
+              "\n",
+              "    window.setTimeout(set_focus, 100);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_toolbar = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var toolbar = document.createElement('div');\n",
+              "    toolbar.classList = 'mpl-toolbar';\n",
+              "    this.root.appendChild(toolbar);\n",
+              "\n",
+              "    function on_click_closure(name) {\n",
+              "        return function (_event) {\n",
+              "            return fig.toolbar_button_onclick(name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    function on_mouseover_closure(tooltip) {\n",
+              "        return function (event) {\n",
+              "            if (!event.currentTarget.disabled) {\n",
+              "                return fig.toolbar_button_onmouseover(tooltip);\n",
+              "            }\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    fig.buttons = {};\n",
+              "    var buttonGroup = document.createElement('div');\n",
+              "    buttonGroup.classList = 'mpl-button-group';\n",
+              "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+              "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+              "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+              "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+              "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+              "\n",
+              "        if (!name) {\n",
+              "            /* Instead of a spacer, we start a new button group. */\n",
+              "            if (buttonGroup.hasChildNodes()) {\n",
+              "                toolbar.appendChild(buttonGroup);\n",
+              "            }\n",
+              "            buttonGroup = document.createElement('div');\n",
+              "            buttonGroup.classList = 'mpl-button-group';\n",
+              "            continue;\n",
+              "        }\n",
+              "\n",
+              "        var button = (fig.buttons[name] = document.createElement('button'));\n",
+              "        button.classList = 'mpl-widget';\n",
+              "        button.setAttribute('role', 'button');\n",
+              "        button.setAttribute('aria-disabled', 'false');\n",
+              "        button.addEventListener('click', on_click_closure(method_name));\n",
+              "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+              "\n",
+              "        var icon_img = document.createElement('img');\n",
+              "        icon_img.src = '_images/' + image + '.png';\n",
+              "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
+              "        icon_img.alt = tooltip;\n",
+              "        button.appendChild(icon_img);\n",
+              "\n",
+              "        buttonGroup.appendChild(button);\n",
+              "    }\n",
+              "\n",
+              "    if (buttonGroup.hasChildNodes()) {\n",
+              "        toolbar.appendChild(buttonGroup);\n",
+              "    }\n",
+              "\n",
+              "    var fmt_picker = document.createElement('select');\n",
+              "    fmt_picker.classList = 'mpl-widget';\n",
+              "    toolbar.appendChild(fmt_picker);\n",
+              "    this.format_dropdown = fmt_picker;\n",
+              "\n",
+              "    for (var ind in mpl.extensions) {\n",
+              "        var fmt = mpl.extensions[ind];\n",
+              "        var option = document.createElement('option');\n",
+              "        option.selected = fmt === mpl.default_extension;\n",
+              "        option.innerHTML = fmt;\n",
+              "        fmt_picker.appendChild(option);\n",
+              "    }\n",
+              "\n",
+              "    var status_bar = document.createElement('span');\n",
+              "    status_bar.classList = 'mpl-message';\n",
+              "    toolbar.appendChild(status_bar);\n",
+              "    this.message = status_bar;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
+              "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+              "    // which will in turn request a refresh of the image.\n",
+              "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.send_message = function (type, properties) {\n",
+              "    properties['type'] = type;\n",
+              "    properties['figure_id'] = this.id;\n",
+              "    this.ws.send(JSON.stringify(properties));\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.send_draw_message = function () {\n",
+              "    if (!this.waiting) {\n",
+              "        this.waiting = true;\n",
+              "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+              "    var format_dropdown = fig.format_dropdown;\n",
+              "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+              "    fig.ondownload(fig, format);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
+              "    var size = msg['size'];\n",
+              "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
+              "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
+              "        fig.send_message('refresh', {});\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
+              "    var x0 = msg['x0'] / fig.ratio;\n",
+              "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
+              "    var x1 = msg['x1'] / fig.ratio;\n",
+              "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
+              "    x0 = Math.floor(x0) + 0.5;\n",
+              "    y0 = Math.floor(y0) + 0.5;\n",
+              "    x1 = Math.floor(x1) + 0.5;\n",
+              "    y1 = Math.floor(y1) + 0.5;\n",
+              "    var min_x = Math.min(x0, x1);\n",
+              "    var min_y = Math.min(y0, y1);\n",
+              "    var width = Math.abs(x1 - x0);\n",
+              "    var height = Math.abs(y1 - y0);\n",
+              "\n",
+              "    fig.rubberband_context.clearRect(\n",
+              "        0,\n",
+              "        0,\n",
+              "        fig.canvas.width / fig.ratio,\n",
+              "        fig.canvas.height / fig.ratio\n",
+              "    );\n",
+              "\n",
+              "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
+              "    // Updates the figure title.\n",
+              "    fig.header.textContent = msg['label'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
+              "    fig.rubberband_canvas.style.cursor = msg['cursor'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
+              "    fig.message.textContent = msg['message'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
+              "    // Request the server to send over a new figure.\n",
+              "    fig.send_draw_message();\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
+              "    fig.image_mode = msg['mode'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
+              "    for (var key in msg) {\n",
+              "        if (!(key in fig.buttons)) {\n",
+              "            continue;\n",
+              "        }\n",
+              "        fig.buttons[key].disabled = !msg[key];\n",
+              "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
+              "    if (msg['mode'] === 'PAN') {\n",
+              "        fig.buttons['Pan'].classList.add('active');\n",
+              "        fig.buttons['Zoom'].classList.remove('active');\n",
+              "    } else if (msg['mode'] === 'ZOOM') {\n",
+              "        fig.buttons['Pan'].classList.remove('active');\n",
+              "        fig.buttons['Zoom'].classList.add('active');\n",
+              "    } else {\n",
+              "        fig.buttons['Pan'].classList.remove('active');\n",
+              "        fig.buttons['Zoom'].classList.remove('active');\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.updated_canvas_event = function () {\n",
+              "    // Called whenever the canvas gets updated.\n",
+              "    this.send_message('ack', {});\n",
+              "};\n",
+              "\n",
+              "// A function to construct a web socket function for onmessage handling.\n",
+              "// Called in the figure constructor.\n",
+              "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
+              "    return function socket_on_message(evt) {\n",
+              "        if (evt.data instanceof Blob) {\n",
+              "            var img = evt.data;\n",
+              "            if (img.type !== 'image/png') {\n",
+              "                /* FIXME: We get \"Resource interpreted as Image but\n",
+              "                 * transferred with MIME type text/plain:\" errors on\n",
+              "                 * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+              "                 * to be part of the websocket stream */\n",
+              "                img.type = 'image/png';\n",
+              "            }\n",
+              "\n",
+              "            /* Free the memory for the previous frames */\n",
+              "            if (fig.imageObj.src) {\n",
+              "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+              "                    fig.imageObj.src\n",
+              "                );\n",
+              "            }\n",
+              "\n",
+              "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+              "                img\n",
+              "            );\n",
+              "            fig.updated_canvas_event();\n",
+              "            fig.waiting = false;\n",
+              "            return;\n",
+              "        } else if (\n",
+              "            typeof evt.data === 'string' &&\n",
+              "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
+              "        ) {\n",
+              "            fig.imageObj.src = evt.data;\n",
+              "            fig.updated_canvas_event();\n",
+              "            fig.waiting = false;\n",
+              "            return;\n",
+              "        }\n",
+              "\n",
+              "        var msg = JSON.parse(evt.data);\n",
+              "        var msg_type = msg['type'];\n",
+              "\n",
+              "        // Call the  \"handle_{type}\" callback, which takes\n",
+              "        // the figure and JSON message as its only arguments.\n",
+              "        try {\n",
+              "            var callback = fig['handle_' + msg_type];\n",
+              "        } catch (e) {\n",
+              "            console.log(\n",
+              "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
+              "                msg\n",
+              "            );\n",
+              "            return;\n",
+              "        }\n",
+              "\n",
+              "        if (callback) {\n",
+              "            try {\n",
+              "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+              "                callback(fig, msg);\n",
+              "            } catch (e) {\n",
+              "                console.log(\n",
+              "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
+              "                    e,\n",
+              "                    e.stack,\n",
+              "                    msg\n",
+              "                );\n",
+              "            }\n",
+              "        }\n",
+              "    };\n",
+              "};\n",
+              "\n",
+              "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+              "mpl.findpos = function (e) {\n",
+              "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+              "    var targ;\n",
+              "    if (!e) {\n",
+              "        e = window.event;\n",
+              "    }\n",
+              "    if (e.target) {\n",
+              "        targ = e.target;\n",
+              "    } else if (e.srcElement) {\n",
+              "        targ = e.srcElement;\n",
+              "    }\n",
+              "    if (targ.nodeType === 3) {\n",
+              "        // defeat Safari bug\n",
+              "        targ = targ.parentNode;\n",
+              "    }\n",
+              "\n",
+              "    // pageX,Y are the mouse positions relative to the document\n",
+              "    var boundingRect = targ.getBoundingClientRect();\n",
+              "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
+              "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
+              "\n",
+              "    return { x: x, y: y };\n",
+              "};\n",
+              "\n",
+              "/*\n",
+              " * return a copy of an object with only non-object keys\n",
+              " * we need this to avoid circular references\n",
+              " * https://stackoverflow.com/a/24161582/3208463\n",
+              " */\n",
+              "function simpleKeys(original) {\n",
+              "    return Object.keys(original).reduce(function (obj, key) {\n",
+              "        if (typeof original[key] !== 'object') {\n",
+              "            obj[key] = original[key];\n",
+              "        }\n",
+              "        return obj;\n",
+              "    }, {});\n",
+              "}\n",
+              "\n",
+              "mpl.figure.prototype.mouse_event = function (event, name) {\n",
+              "    var canvas_pos = mpl.findpos(event);\n",
+              "\n",
+              "    if (name === 'button_press') {\n",
+              "        this.canvas.focus();\n",
+              "        this.canvas_div.focus();\n",
+              "    }\n",
+              "\n",
+              "    var x = canvas_pos.x * this.ratio;\n",
+              "    var y = canvas_pos.y * this.ratio;\n",
+              "\n",
+              "    this.send_message(name, {\n",
+              "        x: x,\n",
+              "        y: y,\n",
+              "        button: event.button,\n",
+              "        step: event.step,\n",
+              "        guiEvent: simpleKeys(event),\n",
+              "    });\n",
+              "\n",
+              "    /* This prevents the web browser from automatically changing to\n",
+              "     * the text insertion cursor when the button is pressed.  We want\n",
+              "     * to control all of the cursor setting manually through the\n",
+              "     * 'cursor' event from matplotlib */\n",
+              "    event.preventDefault();\n",
+              "    return false;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
+              "    // Handle any extra behaviour associated with a key event\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.key_event = function (event, name) {\n",
+              "    // Prevent repeat events\n",
+              "    if (name === 'key_press') {\n",
+              "        if (event.key === this._key) {\n",
+              "            return;\n",
+              "        } else {\n",
+              "            this._key = event.key;\n",
+              "        }\n",
+              "    }\n",
+              "    if (name === 'key_release') {\n",
+              "        this._key = null;\n",
+              "    }\n",
+              "\n",
+              "    var value = '';\n",
+              "    if (event.ctrlKey && event.key !== 'Control') {\n",
+              "        value += 'ctrl+';\n",
+              "    }\n",
+              "    else if (event.altKey && event.key !== 'Alt') {\n",
+              "        value += 'alt+';\n",
+              "    }\n",
+              "    else if (event.shiftKey && event.key !== 'Shift') {\n",
+              "        value += 'shift+';\n",
+              "    }\n",
+              "\n",
+              "    value += 'k' + event.key;\n",
+              "\n",
+              "    this._key_event_extra(event, name);\n",
+              "\n",
+              "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
+              "    return false;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
+              "    if (name === 'download') {\n",
+              "        this.handle_save(this, null);\n",
+              "    } else {\n",
+              "        this.send_message('toolbar_button', { name: name });\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
+              "    this.message.textContent = tooltip;\n",
+              "};\n",
+              "\n",
+              "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
+              "// prettier-ignore\n",
+              "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
+              "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+              "\n",
+              "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+              "\n",
+              "mpl.default_extension = \"png\";/* global mpl */\n",
+              "\n",
+              "var comm_websocket_adapter = function (comm) {\n",
+              "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+              "    // object with the appropriate methods. Currently this is a non binary\n",
+              "    // socket, so there is still some room for performance tuning.\n",
+              "    var ws = {};\n",
+              "\n",
+              "    ws.binaryType = comm.kernel.ws.binaryType;\n",
+              "    ws.readyState = comm.kernel.ws.readyState;\n",
+              "    function updateReadyState(_event) {\n",
+              "        if (comm.kernel.ws) {\n",
+              "            ws.readyState = comm.kernel.ws.readyState;\n",
+              "        } else {\n",
+              "            ws.readyState = 3; // Closed state.\n",
+              "        }\n",
+              "    }\n",
+              "    comm.kernel.ws.addEventListener('open', updateReadyState);\n",
+              "    comm.kernel.ws.addEventListener('close', updateReadyState);\n",
+              "    comm.kernel.ws.addEventListener('error', updateReadyState);\n",
+              "\n",
+              "    ws.close = function () {\n",
+              "        comm.close();\n",
+              "    };\n",
+              "    ws.send = function (m) {\n",
+              "        //console.log('sending', m);\n",
+              "        comm.send(m);\n",
+              "    };\n",
+              "    // Register the callback with on_msg.\n",
+              "    comm.on_msg(function (msg) {\n",
+              "        //console.log('receiving', msg['content']['data'], msg);\n",
+              "        var data = msg['content']['data'];\n",
+              "        if (data['blob'] !== undefined) {\n",
+              "            data = {\n",
+              "                data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
+              "            };\n",
+              "        }\n",
+              "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+              "        ws.onmessage(data);\n",
+              "    });\n",
+              "    return ws;\n",
+              "};\n",
+              "\n",
+              "mpl.mpl_figure_comm = function (comm, msg) {\n",
+              "    // This is the function which gets called when the mpl process\n",
+              "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+              "\n",
+              "    var id = msg.content.data.id;\n",
+              "    // Get hold of the div created by the display call when the Comm\n",
+              "    // socket was opened in Python.\n",
+              "    var element = document.getElementById(id);\n",
+              "    var ws_proxy = comm_websocket_adapter(comm);\n",
+              "\n",
+              "    function ondownload(figure, _format) {\n",
+              "        window.open(figure.canvas.toDataURL());\n",
+              "    }\n",
+              "\n",
+              "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
+              "\n",
+              "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+              "    // web socket which is closed, not our websocket->open comm proxy.\n",
+              "    ws_proxy.onopen();\n",
+              "\n",
+              "    fig.parent_element = element;\n",
+              "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+              "    if (!fig.cell_info) {\n",
+              "        console.error('Failed to find cell for figure', id, fig);\n",
+              "        return;\n",
+              "    }\n",
+              "    fig.cell_info[0].output_area.element.on(\n",
+              "        'cleared',\n",
+              "        { fig: fig },\n",
+              "        fig._remove_fig_handler\n",
+              "    );\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
+              "    var width = fig.canvas.width / fig.ratio;\n",
+              "    fig.cell_info[0].output_area.element.off(\n",
+              "        'cleared',\n",
+              "        fig._remove_fig_handler\n",
+              "    );\n",
+              "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
+              "\n",
+              "    // Update the output cell to use the data from the current canvas.\n",
+              "    fig.push_to_output();\n",
+              "    var dataURL = fig.canvas.toDataURL();\n",
+              "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+              "    // the notebook keyboard shortcuts fail.\n",
+              "    IPython.keyboard_manager.enable();\n",
+              "    fig.parent_element.innerHTML =\n",
+              "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+              "    fig.close_ws(fig, msg);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
+              "    fig.send_message('closing', msg);\n",
+              "    // fig.ws.close()\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
+              "    // Turn the data on the canvas into data in the output cell.\n",
+              "    var width = this.canvas.width / this.ratio;\n",
+              "    var dataURL = this.canvas.toDataURL();\n",
+              "    this.cell_info[1]['text/html'] =\n",
+              "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.updated_canvas_event = function () {\n",
+              "    // Tell IPython that the notebook contents must change.\n",
+              "    IPython.notebook.set_dirty(true);\n",
+              "    this.send_message('ack', {});\n",
+              "    var fig = this;\n",
+              "    // Wait a second, then push the new image to the DOM so\n",
+              "    // that it is saved nicely (might be nice to debounce this).\n",
+              "    setTimeout(function () {\n",
+              "        fig.push_to_output();\n",
+              "    }, 1000);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_toolbar = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var toolbar = document.createElement('div');\n",
+              "    toolbar.classList = 'btn-toolbar';\n",
+              "    this.root.appendChild(toolbar);\n",
+              "\n",
+              "    function on_click_closure(name) {\n",
+              "        return function (_event) {\n",
+              "            return fig.toolbar_button_onclick(name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    function on_mouseover_closure(tooltip) {\n",
+              "        return function (event) {\n",
+              "            if (!event.currentTarget.disabled) {\n",
+              "                return fig.toolbar_button_onmouseover(tooltip);\n",
+              "            }\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    fig.buttons = {};\n",
+              "    var buttonGroup = document.createElement('div');\n",
+              "    buttonGroup.classList = 'btn-group';\n",
+              "    var button;\n",
+              "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+              "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+              "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+              "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+              "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+              "\n",
+              "        if (!name) {\n",
+              "            /* Instead of a spacer, we start a new button group. */\n",
+              "            if (buttonGroup.hasChildNodes()) {\n",
+              "                toolbar.appendChild(buttonGroup);\n",
+              "            }\n",
+              "            buttonGroup = document.createElement('div');\n",
+              "            buttonGroup.classList = 'btn-group';\n",
+              "            continue;\n",
+              "        }\n",
+              "\n",
+              "        button = fig.buttons[name] = document.createElement('button');\n",
+              "        button.classList = 'btn btn-default';\n",
+              "        button.href = '#';\n",
+              "        button.title = name;\n",
+              "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
+              "        button.addEventListener('click', on_click_closure(method_name));\n",
+              "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+              "        buttonGroup.appendChild(button);\n",
+              "    }\n",
+              "\n",
+              "    if (buttonGroup.hasChildNodes()) {\n",
+              "        toolbar.appendChild(buttonGroup);\n",
+              "    }\n",
+              "\n",
+              "    // Add the status bar.\n",
+              "    var status_bar = document.createElement('span');\n",
+              "    status_bar.classList = 'mpl-message pull-right';\n",
+              "    toolbar.appendChild(status_bar);\n",
+              "    this.message = status_bar;\n",
+              "\n",
+              "    // Add the close button to the window.\n",
+              "    var buttongrp = document.createElement('div');\n",
+              "    buttongrp.classList = 'btn-group inline pull-right';\n",
+              "    button = document.createElement('button');\n",
+              "    button.classList = 'btn btn-mini btn-primary';\n",
+              "    button.href = '#';\n",
+              "    button.title = 'Stop Interaction';\n",
+              "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
+              "    button.addEventListener('click', function (_evt) {\n",
+              "        fig.handle_close(fig, {});\n",
+              "    });\n",
+              "    button.addEventListener(\n",
+              "        'mouseover',\n",
+              "        on_mouseover_closure('Stop Interaction')\n",
+              "    );\n",
+              "    buttongrp.appendChild(button);\n",
+              "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
+              "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
+              "    var fig = event.data.fig;\n",
+              "    if (event.target !== this) {\n",
+              "        // Ignore bubbled events from children.\n",
+              "        return;\n",
+              "    }\n",
+              "    fig.close_ws(fig, {});\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._root_extra_style = function (el) {\n",
+              "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
+              "    // this is important to make the div 'focusable\n",
+              "    el.setAttribute('tabindex', 0);\n",
+              "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+              "    // off when our div gets focus\n",
+              "\n",
+              "    // location in version 3\n",
+              "    if (IPython.notebook.keyboard_manager) {\n",
+              "        IPython.notebook.keyboard_manager.register_events(el);\n",
+              "    } else {\n",
+              "        // location in version 2\n",
+              "        IPython.keyboard_manager.register_events(el);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
+              "    // Check for shift+enter\n",
+              "    if (event.shiftKey && event.which === 13) {\n",
+              "        this.canvas_div.blur();\n",
+              "        // select the cell after this one\n",
+              "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
+              "        IPython.notebook.select(index + 1);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+              "    fig.ondownload(fig, null);\n",
+              "};\n",
+              "\n",
+              "mpl.find_output_cell = function (html_output) {\n",
+              "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+              "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+              "    // IPython event is triggered only after the cells have been serialised, which for\n",
+              "    // our purposes (turning an active figure into a static one), is too late.\n",
+              "    var cells = IPython.notebook.get_cells();\n",
+              "    var ncells = cells.length;\n",
+              "    for (var i = 0; i < ncells; i++) {\n",
+              "        var cell = cells[i];\n",
+              "        if (cell.cell_type === 'code') {\n",
+              "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
+              "                var data = cell.output_area.outputs[j];\n",
+              "                if (data.data) {\n",
+              "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+              "                    data = data.data;\n",
+              "                }\n",
+              "                if (data['text/html'] === html_output) {\n",
+              "                    return [cell, data, j];\n",
+              "                }\n",
+              "            }\n",
+              "        }\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "// Register the function which deals with the matplotlib target/channel.\n",
+              "// The kernel may be null if the page has been refreshed.\n",
+              "if (IPython.notebook.kernel !== null) {\n",
+              "    IPython.notebook.kernel.comm_manager.register_target(\n",
+              "        'matplotlib',\n",
+              "        mpl.mpl_figure_comm\n",
+              "    );\n",
+              "}\n"
+            ],
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/html": [
+              "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA+gAAAMgCAYAAACwGEg9AAAAAXNSR0IArs4c6QAAIABJREFUeF7s3Qm4VtPf//FPg1SaRKVUSooyZooMFcosYymPuaSQhMpcNJjHX1KUMlamEEJooCSZQkiaDYUKlebn+u7tNJ/OfZ9zD2vt/d7X5Xr+D3tY39f3Xv/r+Zy999qF1q1bt05sCCCAAAIIIIAAAggggAACCCCQVYFCBPSs+nNxBBBAAAEEEEAAAQQQQAABBAIBAjo/BAQQQAABBBBAAAEEEEAAAQQcECCgO9AEhoAAAggggAACCCCAAAIIIIAAAZ3fAAIIIIAAAggggAACCCCAAAIOCBDQHWgCQ0AAAQQQQAABBBBAAAEEEECAgM5vAAEEEEAAAQQQQAABBBBAAAEHBAjoDjSBISCAAAIIIIAAAggggAACCCBAQOc3gAACCCCAAAIIIIAAAggggIADAgR0B5rAEBBAAAEEEEAAAQQQQAABBBAgoPMbQAABBBBAAAEEEEAAAQQQQMABAQK6A01gCAgggAACCCCAAAIIIIAAAggQ0PkNIIAAAggggAACCCCAAAIIIOCAAAHdgSYwBAQQQAABBBBAAAEEEEAAAQQI6PwGEEAAAQQQQAABBBBAAAEEEHBAgIDuQBMYAgIIIIAAAggggAACCCCAAAIEdH4DCCCAAAIIIIAAAggggAACCDggQEB3oAkMAQEEEEAAAQQQQAABBBBAAAECOr8BBBBAAAEEEEAAAQQQQAABBBwQIKA70ASGgAACCCCAAAIIIIAAAggggAABnd8AAggggAACCCCAAAIIIIAAAg4IENAdaAJDQAABBBBAAAEEEEAAAQQQQICAzm8AAQQQQAABBBBAAAEEEEAAAQcECOgONIEhIIAAAggggAACCCCAAAIIIEBA5zeAAAIIIIAAAggggAACCCCAgAMCBHQHmsAQEEAAAQQQQAABBBBAAAEEECCg8xtAAAEEEEAAAQQQQAABBBBAwAEBAroDTWAICCCAAAIIIIAAAggggAACCBDQ+Q0ggAACCCCAAAIIIIAAAggg4IAAAd2BJjAEBBBAAAEEEEAAAQQQQAABBAjo/AYQQAABBBBAAAEEEEAAAQQQcECAgO5AExgCAggggAACCCCAAAIIIIAAAgR0fgMIIIAAAggggAACCCCAAAIIOCBAQHegCQwBAQQQQAABBBBAAAEEEEAAAQI6vwEEEEAAAQQQQAABBBBAAAEEHBAgoDvQBIaAAAIIIIAAAggggAACCCCAAAGd3wACCCCAAAIIIIAAAggggAACDggQ0B1oAkNAAAEEEEAAAQQQQAABBBBAgIDObwABBBBAAAEEEEAAAQQQQAABBwQI6A40gSEggAACCCCAAAIIIIAAAgggQEDnN4AAAggggAACCCCAAAIIIICAAwIEdAeawBAQQAABBBBAAAEEEEAAAQQQIKDzG0AAAQQQQAABBBBAAAEEEEDAAQECugNNYAgIIIAAAggggAACCCCAAAIIEND5DSCAAAIIIIAAAggggAACCCDggAAB3YEmMAQEEEAAAQQQQAABBBBAAAEECOj8BhBAAAEEEEAAAQQQQAABBBBwQICA7kATGAICCCCAAAIIIIAAAggggAACBHR+AwgggAACCCCAAAIIIIAAAgg4IEBAd6AJDAEBBBBAAAEEEEAAAQQQQAABAjq/AQQQQAABBBBAAAEEEEAAAQQcECCgO9AEhoAAAggggAACCCCAAAIIIIAAAZ3fAAIIIIAAAggggAACCCCAAAIOCBDQHWgCQ0AAAQQQQAABBBBAAAEEEECAgM5vAAEEEEAAAQQQQAABBBBAAAEHBAjoDjSBISCAAAIIIIAAAggggAACCCBAQOc3gAACCCCAAAIIIIAAAggggIADAgR0B5rAEBBAAAEEEEAAAQQQQAABBBAgoPMbQAABBBBAAAEEEEAAAQQQQMABAQK6A01gCAgggAACCCCAAAIIIIAAAggQ0PkNIIAAAggggAACCCCAAAIIIOCAAAHdgSYwBAQQQAABBBBAAAEEEEAAAQQI6PwGEEAAAQQQQAABBBBAAAEEEHBAgIDuQBMYAgIIIIAAAggggAACCCCAAAIEdH4DCCCAAAIIIIAAAggggAACCDggQEB3oAkMAQEEEEAAAQQQQAABBBBAAAECOr8BBBBAAAEEEEAAAQQQQAABBBwQIKA70ASGgAACCCCAAAIIIIAAAggggAABnd8AAggggAACCCCAAAIIIIAAAg4IENAdaAJDQAABBBBAAAEEEEAAAQQQQICAzm8AAQQQQAABBBBAAAEEEEAAAQcECOgONIEhIIAAAggggAACCCCAAAIIIEBA5zeAAAIIIIAAAggggAACCCCAgAMCBHQHmsAQEEAAAQQQQAABBBBAAAEEECCg8xtAAAEEEEAAAQQQQAABBBBAwAEBAroDTWAICCCAAAIIIIAAAggggAACCBDQ+Q0ggAACCCBQAIGvvvpKDzzwgMaMGaNffvlFRYsWVZ06dXTuueeqTZs2Kl++fAHOvvVDe/furXr16un000/P89yzZs1SzZo1dc899+i6667b5v7du3dXjx49tG7dujzPm7PDsmXLdPfdd6tx48bBP2wIIIAAAgggkH8BAnr+7TgSAQQQQCDmAo8//rg6dOigPffcM/ifFppXrVqlTz/9VPbf9t9/f73yyispVypVqpTOPvtsDR48OM9zJxPQ582bJ/vnsMMOy/O8OTv8/vvvqlChgm677TZZwGdDAAEEEEAAgfwLENDzb8eRCCCAAAIxFpg4caKOOuooNW3aVCNGjND222+/icbKlSs1atQonXbaaSlXSldAz89A0xXQly9fruLFi6tQoUL5GRbHIIAAAggg4KUAAd3LtjFoBBBAAIFsC5x66qlBAP/pp59UrVq1PIezdu1a3XvvvRo0aJBmzpypsmXL6oQTTpA9rl61atX1x3/++ee65ZZb9Mknn2jJkiXaaaedVL9+ffXv3z/Yb2uBtVGjRsEj9lvbNr6DXrhwYT3yyCNauHCh9t133+DR/I3vlm/tEff3339ft99+u6ZOnSp7nN3ulh9yyCF6+umntWDBguDx+c23Cy+8cP3d/Q8//DC4u271rFmzRgcccIBuuukmnXzyyesPsycBLr74Yr399tsaOnSoXn/9dVnwHzdunI4++mg999xzatWq1SaXeeqpp2TXsfPaeNgQQAABBBCIggABPQpdpAYEEEAAgYwKWNAsU6ZMEHI//vjjhK7drl07DRgwQFdeeaVOOeUUWXC2IG53iT/77DPtvPPOWrp0qXbbbbcg9Hbp0kWVKlXSr7/+qg8++EAdO3ZU3bp1g+sdc8wxatKkSXC8bTYWe7x+WwG9Ro0a2muvvXT55ZcHu9mx9jh7zh8L7N9tHtBtjHZNe1LgiiuuULly5TR//vzgDxMPP/ywSpQoEfxhwP7QcOmllwbv3NtmIb5WrVoaO3Zs8ITBfvvtF9RjTxk8+uijevfdd/X888+rZcuWwf45AX3XXXcNgvsZZ5wRWNg79ha+S5YsKQv6G2+HHnpo8L9aQGdDAAEEEEAgKgIE9Kh0kjoQQAABBDIm8Ntvv2mXXXYJFoKzoJnX9t133wVB195T79u37/rdLVw2aNBAN954o3r16qUpU6bo4IMPDh6Zb968ea6nzc8j7vbHBLs7X6RIkeC8kydPloVcG7/VsbWA/tJLLwXvun/xxRfB+/Rb27b1iPvhhx8ePGEwY8YM2Zhty7mLvnjxYs2ZMyd4IiAnoF9wwQUaMmTIJpfJ+W82drv7vvHYbV87hg0BBBBAAIGoCBDQo9JJ6kAAAQQQyJhAsgG9X79+QTjf2uPYdufb7oDbnXF7pN3unlesWFGdOnUKHu/e2p3x/AT0bt26qU+fPuuNVqxYEdy9v/POO9W1a9etBnQL1nZ9C8Y2fruTvvvuu2/inFtAtzvgpUuXVvv27Tf5o4QdbKu+2zWnTZsW3NXPCeGvvvrqFu/s2zirV68e/HtbeM82C+V2F3/u3LlbvPufsR8BF0IAAQQQQCANAgT0NKBySgQQQACBaAsk+4h7z549g0fKLVBu/L65KR133HGaPXu2pk+fHqDZu952N/2dd97RokWLVLlyZbVt21Y333yztttuu2Cf/AT0rX1mze5eb7z6+tbeQR8/fnwQqO0xewvdFtDtcfurr746GEtuAd0en7d38++4445g7BtvzzzzjM4///zgsfUjjjhifUDP7X3yW2+9Vffdd1/weL2tkm/n7dy5c/D+PhsCCCCAAAJREiCgR6mb1IIAAgggkDEBu6P71ltvBe9wbx66Nx9EXnfQbcE4WxV+482+RW7fWLe7yw8++GBw99vugmc6oOeMyf4oYZ+Ps0Xmnn322fWPxm/rDro9GWDvvG/8WL+dL+cOuj36b5+oy7mDbo/d2yP+m2/2fXl7N9/u9v/777+ywG6PztuddTYEEEAAAQSiJEBAj1I3qQUBBBBAIGMCG39mzR7NLlas2CbXtju99hi2rfb+/fffB49y253nhx56aP1+Oe+B26rmdpc9t23HHXcMFlsbPnx4sIut7G533ocNG5Znvdv6Dnoid9A3v4A9hm+LxV1//fVB0P7777+DR/RtEbi77rprk90bNmwY/AHDwrQtKGebrWZvj8zb0wGbv4OeW0C348477zxNmjRJ9vm6gw46KC3fl88Tkx0QQAABBBBIswABPc3AnB4BBBBAILoC9k60vZtt4dvetd57772DR7BtQTNbsX2fffZZHyRtFXfb3x4NP/HEE9ev4m4rm9v+FrpHjhwZrHJuq5fbo+R2F/3ll1/WY489FpzPHnW3rXHjxsH720888UTwCLy96213ore2FSSg23XtM2u2srrdrba71/aZuBdffDH4JFqzZs2CS9oK8fY+u63sXr58+WBFevt3Oau4H3jggbruuuuCP2JYffb4/tZWcd9WQM9ZUM+uN3r0aB177LHR/WFRGQIIIIBAbAUI6LFtPYUjgAACCKRC4Msvvwy+J27vaNsn0ew98Tp16gR3zu2TavbJMdtyvoM+cODATb6Dbo+u5zwib3fae/ToESwm9/PPPweB1oK3/RHAvvmds9k17bNnFuzt2+SJfgfdQvLGW1530G3hOrtLbp+Bs9rs3Xf7o8O1114b1Jezvffee8Ed9W+//Va2qNvWvoNud7/NwFaDtycG7FNzOVtej7jn7GcL6NmdeLsOGwIIIIAAAlEUIKBHsavUhAACCCCAQMQE7H18C/f2Prv9wYINAQQQQACBKAoQ0KPYVWpCAAEEEEAgIgL2qTdb5d6+FW/vrP/4448qWbJkRKqjDAQQQAABBDYVIKDzi0AAAQQQQAABZwUuuugiPf3006pbt6769+8ffJaNDQEEEEAAgagKENCj2lnqQgABBBBAAAEEEEAAAQQQ8EqAgO5VuxgsAggggAACCCCAAAIIIIBAVAUI6FHtLHUhgAACCCCAAAIIIIAAAgh4JUBA96pdDBYBBBBAAAEEEEAAAQQQQCCqAgT0qHY2l7rsG7T2bd3SpUvLvn/LhgACCCCAAAIIIIAAAvEUWLdunf7++29VqVJFhQsXjieCY1UT0B1rSLqHM2/ePFWrVi3dl+H8CCCAAAIIIIAAAggg4InA3LlzVbVqVU9GG+1hEtCj3d8tqluyZInKlSsnm4RlypSJWfWUiwACCCCAAAIIIIAAAjkCf/31V3DzbvHixSpbtiwwDggQ0B1oQiaHYJPQJp8FdQJ6JuW5FgIIIIAAAggggAACbgmQDdzqh42GgO5eT9I6IiZhWnk5OQIIIIAAAggggAAC3giQDdxrFQHdvZ6kdURMwrTycnIEEEAAAQQQQAABBLwRIBu41yoCuns9SeuImIRp5eXkCCCAAAIIIIAAAgh4I0A2cK9VBHT3epLWETEJ08rLyRFAAAEEEEAAgdgK2Od8V65cGdv6XSx8u+22U5EiRXIdGtnAva4R0N3rSVpHxCRMKy8nRwABBBBAAAEEYilgwXzmzJmykM7mloB9wWmXXXZRoUKFthgY2cCtXtloCOju9SStI2ISppWXkyOAAAIIIIAAArETWLdunebMmaNVq1apSpUqKly4cOwMXCzY+rJs2TItWLAg+Mxy5cqVCeguNmqzMRHQPWhSKodIQE+lJudCAAEEEEAAAQQQsGD+448/BuGcb2m793v4448/gpBep06dLR53Jxu41y8Cuns9SeuImIRp5eXkCCCAAAIIIIBA7AT+/fff4PH2GjVqqESJErGr3/WCly9frlmzZqlmzZoqXrz4JsMlG7jXPQK6Qz2x/09t9uzZW4yoQ4cO6tu3ry666CINGTJkk//eoEEDffzxxwlXwSRMmIodEUAAAQQQQAABBBIQyAnoWwuACRzOLmkW2FZ/yAZpxs/H6Qno+UBL1yELFy7UmjVr1p/+66+/VtOmTfXBBx+ocePGQUD/7bff9OSTT67fp1ixYipfvnzCQ2ISJkzFjggggAACCCCAAAIJCMQ1oOfclf788891wAEHJCAlDR48WJ06ddLixYsT2j+RnfIaBwE9EUV39iGgu9OLLUZik3fkyJGaPn16sOqiBXSbzCNGjMj3qAno+abjQAQQQAABBBBAAIGtCPge0OfOnavu3bvrrbfe0u+//x4spnb66afr1ltv1U477ZRrz+3Gmt1g23nnnVW0aNGEfhv2uPnff/+tihUrJrR/IjsR0BNR8mcfArqjvbJPVdhCG507d9aNN94YjNICuoVzu2tuKzE2atRIvXr12uYEX7FiheyfnM0CerVq1bRkyRKVKVPG0eoZFgIIIIAAAggggIAvAj4H9J9++kmHH354sIBaz549g/e0v/nmG11//fXBN93tVdKtPa1q/83+b3IXNgK6C11I3RgI6KmzTOmZhg8frtatWwefrLCgbtuwYcNUqlQp7bbbbsFCHLfccotWr16tKVOmaPvtt9/q9e2vgT169NjivxHQU9ouToYAAggggAACCMRWwOeAfuKJJ8peK/3hhx82WeDu119/Va1atXTBBReoX79+wQJ4bdq0CVarf+WVV4I77PZ/Y1ug3/gR99dee03XXnut5s2bp8MOOyy4wWb/LFq0KLjBtvkj7vZ/q9sNODvG/m9728/G9Pjjj6t06dLBb2rUqFHBHw9snEWKFAn+oPDQQw8F47ONgB6tqUdAd7Sfxx9/fPBXuddffz3XEf7yyy9BWB86dKjOPPPMre7HHXRHG8ywEEAAAQQQQACBiAj4GtD//PPP4PF0eyL1hhtu2KIbl112mV588UXZZ8osiFt4thBt4dw2e6x944BuQdnuxF999dVBmLfgft1112n+/PnbDOj33XefmjVrFgR+u0aLFi10ySWXBOOy7aWXXgped9133321dOnS4NF7u9YXX3wRfHOegB6RifRfGQR0B/tpK7nvvvvuevnll9W8efNtjrB27drB/wfQtWvXhCrhHfSEmNgJAQQQQAABBBBAIEGB3AL60qW5n6BIEWnjL35ta9/ChaWNv96W27477JDggP/bbdKkScFd7pw74psf/cADDwSvm9oizYceeqjq168f7JuzbR6Mu3XrpjfeeENTp05dv8/NN98cBO1t3UG/5557ZHfsc+6Yd+nSRePGjcv1S0323ru9w27X2WeffQjoybXd+b0J6A62yB516d+/v2zBim0tOGF/zdt11101YMCA4PGbRDYCeiJK7IMAAggggAACCCCQqEBuAb1QodzPcNJJ0htvbPjvFq6XLdv6/o0aSWPGbPhvFSpIv/++5b7r1iU64nC/vAL6/fffHzx6vmDBAh1yyCFq27atbrrpplwD+hlnnKEdd9xRgwYNWr+PPfJuN9y2FdBfeOGF4L33nM3+MPDII4/I3o+3bcaMGcGde3sf3haxW7t2bXAn3f4YcNJJJxHQk2u783sT0B1rkU04e1SmVatWuvPOO9eP7p9//glWlzzrrLOClSXtL3a2eJy9oz5t2rT1f3HLqxwCel5C/HcEEEAAAQQQQACBZAR8Deh2s6tChQrB+905izJvXPfmj7jbF5bsn5xt8zvo9ui7rfo+cODA9fu8+uqrwSPxeb2Dbo+r52wPPvig7B87v2316tULFnm2O+u2NpXlBbtznnPnn0fck/m1ur8vAd2xHr3zzjuy98+///774B2WnM0+yWCT295lsU+tWUhv0qSJ7rjjjmDCJroR0BOVYj8EEEAAAQQQQACBRAR8fcTdarP/u9vuXttnjUts9Bz91haJyyug2yPub775pr766qv1bHbn2/4AkN+Abn9EsPfk7ZH3o446Kjjvhx9+GPy/CeiJ/Dr924eA7l/PCjRiAnqB+DgYAQQQQAABBBBAYDMBXxeJszIsmDds2FB169bd4jNrtthyzmfWbBX3vAK6fWVpzz331DXXXKNLL700WMQtZ0V3u8FWtmzZXFdxz+0Out0tt/fNbWX32267LXh61v4QMHnyZAJ6RGciAT2ijc2tLAJ6zBpOuQgggAACCCCAQJoFfA7oRmMLNNurpPY5M7tjvcsuuwRPrlogtkfWbUskoNt+OZ9Zs7Wk7HNoLVu2VPv27WVPwxYvXjzpgG7nHD16tDp27Bi8k25/AHj44YfVuHFjAnqaf9fZOj0BPVvyWbouAT1L8FwWAQQQQAABBBCIqIDvAT2dbbEV3B977LFg8edsbdvqD9kgW13J/boEdPd6ktYRMQnTysvJEUAAAQQQQACB2AkQ0De0/NFHHw1WfLc77x999JGuuuoqXXnllcHj89naCOjZks/fdQno+XPz9igCuretY+AIIIAAAggggICTAgT0DW2x98+HDRumP//8U9WrV9f555+vG264YZufTk53Uwno6RZO7fkJ6Kn1dP5sPgX0tWulwoWdJ2WACCCAAAIIIIBArAUI6G63n4Dudn82Hx0B3a9+FXi0vgT0Bx6Qbr9dGjtW2m+/ApfNCRBAAAEEEEAAAQTSJEBATxNsik5LQE8RZIZOQ0DPELQrl/EloBcqFIrtu6+00ackXWFkHAgggAACCCCAAAL/CRDQ3f4pENDd7s/moyOg+9WvAo/Wl4B+xhnSiBHSuedKzz9f4LI5AQIIIIAAAggggECaBHICoH2KrESJEmm6CqfNr4B94m3WrFmqWbNm8Km3jTdfskF+a/fxOAK6j10rwJh9mYR9+0pXXilZUH/55QIUzKEIIIAAAggggAACaRVYtWqVfvzxR1WpUkVly5ZN67U4efIC9m33BQsWqE6dOipSpAgBPXnCjB5BQM8od/Yv5ktAf+01qXlz6aCDpE8/zb4bI0AAAQQQQAABBBDYusC6des0Z84cWVC3kF6YVX6d+KlYX5YtWxaE83Llyqly5cpbjMuXbOAEaIYGQUDPELQrl/FlEl53nXTffaHaunWu6DEOBBBAAAEEEEAAga0JrFy5UjNnztRa+wwPm1MCFs532WUXFcpZ5Gmj0fmSDZwCTfNgCOhpBnbt9L5Mwj32kGbMCPWWLZN4ncm1XxLjQQABBBBAAAEENhWwcG5Bnc0dge22226Lx9o3Hp0v2cAd0fSPhICefmOnruDLJKxfX/rii/Ad9GeekUqWdIqRwSCAAAIIIIAAAggg4L2AL9nAe+gkCiCgJ4EVhV19mYT27fOpU6XRo6Vjj42CPDUggAACCCCAAAIIIOCWgC/ZwC219I6GgJ5eX+fO7sskrFdPmjZNGjNGatTIOUYGhAACCCCAAAIIIICA9wK+ZAPvoZMogICeBFYUdvVlEtapI02fLvXqJZ16qrTvvlHQpwYEEEAAAQQQQAABBNwR8CUbuCOW/pEQ0NNv7NQVfJmEu+8uzZwZ0rVtKw0Y4BQjg0EAAQQQQAABBBBAwHsBX7KB99BJFEBATwIrCrv6MgmrV5fmzg3Fjz9eGjUqCvrUgAACCCCAAAIIIICAOwK+ZAN3xNI/EgJ6+o2duoIvk3DiROn116U+fSR7H/2bb5xiZDAIIIAAAggggAACCHgv4Es28B46iQII6ElgRWFXnybhDz9Ie+4plSol/fWXVKhQFDpADQgggAACCCCAAAIIuCHgUzZwQyz9oyCgp9/YqSv4NAmXL9/w/fM//5R23NEpSgaDAAIIIIAAAggggIDXAj5lA6+hkxg8AT0JrCjs6ssk7N9fWrdO6tRJWrFC+vJLyb6NzoYAAggggAACCCCAAAKpEfAlG6SmWj/OQkD3o08pG6Uvk7BECenff6WddpL++CN8H/2UU1LGwIkQQAABBBBAAAEEEIi9gC/ZIE6NIqDHqduyd7n/UtmyZbVkyRKVKVPG2eq3205avVq66y6pXLlwJffddnN2uAwMAQQQQAABBBBAAAHvBHzJBt7BFmDABPQC4Pl4qA+T0B5tL1w41P31V6lSJR+lGTMCCCCAAAIIIIAAAm4L+JAN3BZM/egI6Kk3dfqMPkzCNWukokVDRnu8vXx5p0kZHAIIIIAAAggggAACXgr4kA28hC3AoAnoBcDz8VAfJqEtCle8eKg7b57044/h++j2mDsbAggggAACCCCAAAIIpEbAh2yQmkr9OQsB3Z9epWSkPkzCpUvDb5/bNnq0dNxx4fvns2alhICTIIAAAggggAACCCCAgEfrU8WpWQT0OHXbk0m4ZEm4MJxtM2ZItWpJRYqEn1uz/8mGAAIIIIAAAggggAACBRfw4eZdwav06wwEdL/6VeDR+jAJV62S3n03XMX9pJPCx93tvXR73H3XXQtMwAkQQAABBBBAAAEEEEDAk5t3cWsUAT1mHfchoG/eEnu8fc4cacIE6fDDY9YwykUAAQQQQAABBBBAIE0CPmaDNFE4c1oCujOtyMxAfJyERx0lffihNGyY1KJFZpy4CgIIIIAAAggggAACURfwMRtEvScE9Kh3eLP6fJiEf/8tvfhi+Gh7q1ZS69bS889L99wjXXddzBpGuQgggAACCCCAAAIIpEnAh2yQptKdPS0B3dnWpGdFd51xAAAgAElEQVRgPkxC+6xa7dpSmTKSLRjXrZt0111Sx47SQw+lx4WzIoAAAggggAACCCAQNwEfskHcekJAj1nHfZiE330n1a0rlS8v/fGHNGmS9OWX0sEHSwceGLOGUS4CCCCAAAIIIIAAAmkS8CEbpKl0Z09LQHe2NekZmA+TcOpUab/9pIoVpd9+S48DZ0UAAQQQQAABBBBAIO4CPmSDuPWIgB6zjvswCT//PLxTXqWKNH9+zBpEuQgggAACCCCAAAIIZEjAh2yQIQpnLkNAd6YVmRmID5Nw8mTp0EMl+7zarFnS2rXS+PHhp9ZsFfftt8+MFVdBAAEEEEAAAQQQQCDKAj5kgyj7b602AnrMOu7DJJw4UWrYUKpVS7IF49atk0qVkpYtk374IVxAjg0BBBBAAAEEEEAAAQQKJuBDNihYhf4dTUD3r2cFGrEPk9Dulh99tLTnnpItGGebLRpn/+/33pOOOaZABByMAAIIIIAAAggggAACknzIBnFrFAE9Zh33YRIuXCiNGSOVLCmdfHLYoGbNpHfflZ58Urroopg1jXIRQAABBBBAAAEEEEiDgA/ZIA1lO31KArrT7Un94HydhG3aSAMHSj16SLfemnoXzogAAggggAACCCCAQNwEfM0GUe4TAT3K3d1Kbb5Owttvl267TbKg/vjjMWsa5SKAAAIIIIAAAgggkAYBX7NBGiicOSUB3ZlWZGYgPkzCefMkWyiuQgWpcePQxR5tv+SS8FH3t9/OjBVXQQABBBBAAAEEEEAgygI+ZIMo+2+tNgJ6zDruwyR8+WXprLOkI46QPvwwbJAtDnfcceFicd9+G7OmUS4CCCCAAAIIIIAAAmkQ8CEbpKFsp09JQHe6PakfnA+TcPhwqWVLqVGjcLE422zhuFdeCT+9duyxqXfhjAgggAACCCCAAAIIxE3Ah2wQt54Q0GPWcR8m4XPPSeedFwbx0aNj1iDKRQABBBBAAAEEEEAgQwI+ZIMMUThzGQK6M63IzEB8mIRPPSVdeKF0/PHSqFGZceEqCCCAAAIIIIAAAgjETcCHbBC3nhDQY9ZxHybhoEHSpZeG30AfOXJDg6ZMCd8/b9BAqlMnZo2jXAQQQAABBBBAAAEEUizgQzZIccnOn46A7nyLUjtAHybhgAFSu3bS6aeH753nbGecIY0YIfXtK3XokFoXzoYAAggggAACCCCAQNwEfMgGcesJAT1mHfdhEj76qHTFFdLZZ0svvLChQR07So88InXrJvXpE7PGUS4CCCCAAAIIIIAAAikW8CEbpLhk509HQHe+RakdoA+T8LvvpI8/lqpXl445ZkP9994rXX+91Lq19OyzqXXhbAgggAACCCCAAAIIxE3Ah2wQt54Q0GPWcZ8n4bBh0rnnSkcdJY0bF7PGUS4CCCCAAAIIIIAAAikW8DkbpJjCmdMR0J1pRWYG4vMknDhRathQ2m03adaszHhxFQQQQAABBBBAAAEEoirgczaIak8I6FHtbC51+TAJf/hBmj5dqlFD2nvvDYXMny9VrSoVLSr9+69UpEjMmke5CCCAAAIIIIAAAgikUMCHbJDCcr04FQHdizalbpA+TMIePaTu3aX27SVbMC5nW7NGKl5cWr1amjdP2nXX1LlwJgQQQAABBBBAAAEE4ibgQzaIW08I6DHruA+T8JZbpJ49pauukh5+eNMG2eJwO+0kHX20VLJkzJpHuQgggAACCCCAAAIIpFDAh2yQwnK9OBUB3Ys2pW6QPkzCG26Q7rxTuuYa6f77U1c7Z0IAAQQQQAABBBBAAIENAj5kg7j1i4Aes477MAntU2o5n1S7++6YNYhyEUAAAQQQQAABBBDIkIAP2SBDFM5choDuTCsyMxAfJmGnTtJDD0l2J713701dZsyQJkyQKlWSmjXLjBlXQQABBBBAAAEEEEAgigI+ZIMoum+rJgJ6zDruwyS88kqpb1/J3kW//fZNG2T/3v776adLr7wSs+ZRLgIIIIAAAggggAACKRTwIRuksFwvTkVA96JNqRukD5Pw8sul/v0lW8391ls3rf3116XTTpMOPFCaMiV1LpwJAQQQQAABBBBAAIG4CfiQDeLWEwJ6zDruwyQcO1b6+mvpkEOkQw/dtEFffikdcIBUoYK0YEHMmke5CCCAAAIIIIAAAgikUMCHbJDCcr04FQHdoTbVqFFDs2fP3mJEHTp0UN++fbVu3Tr16NFDAwYM0KJFi9SgQYPg3++9994JV+H7JPzzz/Aza7YtWyaVKJFw6eyIAAIIIIAAAggggAACGwn4ng2i2EwCukNdXbhwodasWbN+RF9//bWaNm2qDz74QI0bN9Zdd92lXr16afDgwapTp4569uypcePG6fvvv1fp0qUTqsT3SbhunWSlLl0q/fCDVLt2QmWzEwIIIIAAAggggAACCGwm4Hs2iGJDCegOd7VTp04aOXKkpk+fHoyySpUqsn/XtWvX4H9fsWKFKlWqFAT3du3aJVSJD5Nw6lTpjz+kOnWs5i3LqldPmjZNGj1aOvbYhMpmJwQQQAABBBBAAAEEECCgO/8bIKA72qKVK1cGgbxz58668cYb9dNPP6lWrVr67LPPVL9+/fWjbt68ucqVK6chQ4YkVIkPAf3ss6WXXgpXcu/QYcuyjj9eeucdadAg6eKLEyqbnRBAAAEEEEAAAQQQQICA7vxvgIDuaIuGDx+u1q1ba86cOUFQnzBhgo444gjNnz8/+N9ztssuuyx4b/3tt9/eaiV2l93+ydksoFerVk1LlixRmTJlnKzePqH26qvSgAFS27ZbDnHcuPD9c/s7hX0PnQ0BBBBAAAEEEEAAAQSSF/Dh5l3yVfl9BAHd0f4df/zxKlasmF6374pJ6wP6zz//rMqVK68fddu2bTV37lyNGjVqq5V07949WFhu883lgH7KKdIbb3CH3NGfJsNCAAEEEEAAAQQQiIgAAd29RhLQ3etJcEd8991318svvyx7hN22/D7i7uMd9BNOkOyBgKeeks4/38EGMSQEEEAAAQQQQAABBCIgQEB3r4kEdPd6Irvr3b9//+DOeNGiRYMR2ifW7NH2a665Rl26dAn+nb2nXrFixcgtEnfccdJ770nPPSe1arVlg774Qvr883ARuSOOcLCBDAkBBBBAAAEEEEAAAQ8ECOjuNYmA7lhP1q5dq5o1a6pVq1a68847Nxmdrdbep08fPfnkk6pdu7Z69+6tMWPGRO4za40aSfae+fDh0jnnbNmg7t0le2r/8sulfv0cayDDQQABBBBAAAEEEEDAEwECunuNIqA71pN33nlH9v65fdvcvnW+8WZ30e19cru7vmjRIjVo0EB9+/bVPvvsk3AVPkxCuys+YYL08svSGWdsWVrv3tJNN0mXXCINHJhw6eyIAAIIIIAAAggggAACGwn4kA3i1jACesw67sMktEfb580Lw3nt2ls26N57peuvD99Pt/fU2RBAAAEEEEAAAQQQQCB5AR+yQfJV+X0EAd3v/iU9+ihMwocflq6+WmrZUho6NGkCDkAAAQQQQAABBBBAAAFJUcgGUWskAT1qHc2jnihMwscek9q3D++w22PwbAgggAACCCCAAAIIIJC8QBSyQfJVu30EAd3t/qR8dD5MQlulfdUqaa+9pNKltyQYNEi69FLJvpf+32fiU+7ECRFAAAEEEEAAAQQQiLqAD9kg6j3YvD4Cesw67sMktLXxpk+Xxo+XjjxyywY9/bR0wQVSs2bh99LZEEAAAQQQQAABBBBAIHkBH7JB8lX5fQQB3e/+JT16Hybh7rtLM2dKEydKhx22ZYmzZ0uffCJVrrz1AJ80CgcggAACCCCAAAIIIBBDAR+yQdzaQkCPWcd9mITVq0tz50qTJ0sHHxyzBlEuAggggAACCCCAAAIZEvAhG2SIwpnLENCdaUVmBuLDJKxSRfrlF+nzz6UDDsiMC1dBAAEEEEAAAQQQQCBuAj5kg7j1hIAes477MAkrVpQWLpSmTpX22WfLBi1YII0ZI+2wg3TyyTFrIOUigAACCCCAAAIIIJAiAR+yQYpK9eY0BHRvWpWagfowCcuXlxYtkqZNC1dy33yzcN6kiVS3rvTtt6lx4SwIIIAAAggggAACCMRNwIdsELeeENBj1nEfJmGZMtLff4crue+xx5YNmjBBOuKI8L/ZPmwIIIAAAggggAACCCCQvIAP2SD5qvw+goDud/+SHr0Pk7BPH+nff6VOnaQdd9yyRFs87tBDJVtMzlZ0Z0MAAQQQQAABBBBAAIHkBXzIBslX5fcRBHS/+5f06KMwCb/8Mlw8bpddwsXk2BBAAAEEEEAAAQQQQCB5gShkg+SrdvsIArrb/Un56KIwCe3d9Hr1pJ12kn7/PeVEnBABBBBAAAEEEEAAgVgIRCEbRK1RBPSodTSPelyfhOvWhau3Fy0q7bmnVKTIlgXNmBG+f166tPTXXzFrIOUigAACCCCAAAIIIJAiAdezQYrK9Oo0BHSv2lXwwbo+CVeulLbfPqxz8WKpbNkta54zR9ptt3A/e1edDQEEEEAAAQQQQAABBJIXcD0bJF+R/0cQ0P3vYVIVuD4Jly6VSpUKS/rnn/Bb55tvy5ZJw4dLxYpJrVsnVT47I4AAAggggAACCCCAwH8CrmeDODaKgB6zrrs+CZcskcqVC5tid8dz7qbHrE2UiwACCCCAAAIIIIBA2gVczwZpB3DwAgR0B5uSziG5Pgn/+EPaeedQYM0aqXDhdGpwbgQQQAABBBBAAAEE4ivgejaIY2cI6DHruuuT8Lffws+nFSokrV279ebYv3/rLWnVKumkk8JH3dkQQAABBBBAAAEEEEAgOQHXs0Fy1URjbwJ6NPqYcBWuT8L586WqVaXttpNswbitbRbQc1Z3X7hwwx33hBHYEQEEEEAAAQQQQAABBOR6NohjiwjoMeu665Nw9mypRg2pRAnJFoPLbbMAv3q1ZIG+SpWYNZFyEUAAAQQQQAABBBBIgYDr2SAFJXp3CgK6dy0r2IBdn4R//indfXd4h7xXr9xrLVlSWr5cmjkzDPRsCCCAAAIIIIAAAgggkJyA69kguWqisTcBPRp9TLiKqExCW+ndVnz/4Qepdu2Ey2dHBBBAAAEEEEAAAQQQ+E8gKtkgSg0loEepmwnUEpVJWLGiZO+ff/21tPfeCRTOLggggAACCCCAAAIIILCJQFSyQZTaSkCPUjcTqMX1SWjfPrf3yosXl3bdNfeC7L/9/LP02WdS/foJFM4uCCCAAAIIIIAAAgggQEB3/DdAQHe8QakenusB/dNPpUMOkapVk+bMyb36mjWlWbOkjz+WGjRItRLnQwABBBBAAAEEEEAg+gKuZ4Pod2DLCgnoMeu665PQAvfhh0sWwH/6KffmPPNMuMp78+ZSpUoxayLlIoAAAggggAACCCCQAgHXs0EKSvTuFAR071pWsAG7Pgk//FA66qhw4TdbAI4NAQQQQAABBBBAAAEE0iPgejZIT9Vun5WA7nZ/Uj461yfhmDFSkyZS3brSt9+mvHxOiAACCCCAAAIIIIAAAv8JuJ4N4tgoAnrMuu76JBw9WmraVNpvP+nLL3NvzuefS7//Hu7HI+4x+xFTLgIIIIAAAggggEBKBFzPBikp0rOTENA9a1hBh+v6JBw1SjrxROnAA6UpU3Kv9uijpfHjpRdflM46q6AqHI8AAggggAACCCCAQPwEXM8G8euIRECPWdddn4QjR0qnniodeqg0aVLuzTn2WOn996XnnpNatYpZEykXAQQQQAABBBBAAIEUCLieDVJQonenIKB717KCDdj1STh1qjRggFS9unT99bnXanfZ7W774MHShRcWzISjEUAAAQQQQAABBBCIo4Dr2SCOPSGgx6zrUZmE9nm1114Lw3zbtjFrIuUigAACCCCAAAIIIJACgahkgxRQOHMKArozrcjMQKIyCc8+W3rpJel//5OuuCIzdlwFAQQQQAABBBBAAIEoCUQlG0SpJwT0KHUzgVpcn4TLlkl//SWVKCGVLZt7Qa1bS88/Lz3wgNSpUwKFswsCCCCAAAIIIIAAAghsIuB6NohjuwjoMeu665PwySelSy6RTj5ZsgXjctsuukgaMkS66y6pS5eYNZFyEUAAAQQQQAABBBBIgYDr2SAFJXp3CgK6dy0r2IBdn4SPPy5ddplk75iPGJF7rbZA3LRp0pFHSoccUjATjkYAAQQQQAABBBBAII4CrmeDOPaEgB6zrrs+Cfv1kzp0CL9tbt84Z0MAAQQQQAABBBBAAIH0CLieDdJTtdtnJaC73Z+Uj871Sfjww9LVV0stW0pDh6a8fE6IAAIIIIAAAggggAAC/wm4ng3i2CgCesy67vokvP9+6dprpfPOk555JvfmzJsnzZkjVaok1aoVsyZSLgIIIIAAAggggAACKRBwPRukoETvTkFA965lBRuw65Pw7rulrl0lWwTOFozLbbvlFqlnT+nKK6VHHimYCUcjgAACCCCAAAIIIBBHAdezQRx7QkCPWdddn4S9e0s33SS1aSPZgnG5bbffLt12W7igXP/+MWsi5SKAAAIIIIAAAgggkAIB17NBCkr07hQEdO9aVrABuz4J7dNqL78sHX10eBc9t+3OO6UbbpAuvlgaNKhgJhyNAAIIIIAAAggggEAcBVzPBnHsCQE9Zl2PyiRM9F31mLWXchFAAAEEEEAAAQQQSFggKtkg4YI92JGA7kGTUjnEqEzC//1Puuoq6ZxzpOHDUynEuRBAAAEEEEAAAQQQiIdAVLJBlLpFQI9SNxOoxfVJuHy5tHq1tP32UrFiuRc0YIDUrp10+unSK68kUDi7IIAAAggggAACCCCAwCYCrmeDOLaLgB6zrrs+Ca+5RnrwQalbN6lPn9ybM3hw+P75SSdJb7wRsyZSLgIIIIAAAggggAACKRBwPRukoETvTkFA965lBRuw65PQHlu3x9dvvlm6447ca/3qK+nVV6U6daSWLQtmwtEIIIAAAggggAACCMRRwPVsEMeeENBj1nXXJ2H79tJjj0ndu4efUWNDAAEEEEAAAQQQQACB9Ai4ng3SU7XbZyWgu92flI/O9UnYtq30xBNSz57h99DZEEAAAQQQQAABBBBAID0CrmeD9FTt9lkJ6G73J+Wjc30S2nvl9n65fee8a9fcy//nH+mnn6SiRaV69VLOxAkRQAABBBBAAAEEEIi8gOvZIPIN2EqBBPSYdd31SXj++dIzz0j33itde23uzRk9WmraVNp3X8neR2dDAAEEEEAAAQQQQACB5ARczwbJVRONvQno0ehjwlW4PglbtZKGDpUeekjq2DH3ssaNkxo1kvbaS5o2LeHy2REBBBBAAAEEEEAAAQT+E3A9G8SxUQT0mHXd9UlowXzChPATaieckHtzPv5YOvxwaffdpRkzYtZEykUAAQQQQAABBBBAIAUCrmeDFJTo3SkI6N61rGADjsoknDJFOvhgqWpVae7cgplwNAIIIIAAAggggAACcRSISjaIUu8I6FHqZgK1RGUSTp0q7befVLGi9NtvCRTOLggggAACCCCAAAIIILCJQFSyQZTaSkCPUjcTqMX1Sbh6tVSkiFSo0LaL+f778P3zHXeU/vwzgcLZBQEEEEAAAQQQQAABBAjojv8GCOiONyjVw3M9oB93nPTee9Kzz0qtW+devX1irVYtaYcdJPvkGhsCCCCAAAIIIIAAAggkJ+B6NkiummjsTUCPRh8TrsL1Sdi4sTR2rDRsmNSiRe5lLV4cfiu9RAnpttsSLp8dEUAAAQQQQAABBBBA4D8B17NBHBtFQI9Z112fhEceKX30kfTSS9KZZ8asOZSLAAIIIIAAAggggEAGBVzPBhmkcOZSBHRnWpGZgbg+CQ87TJo0SXrtNenUUzNjwlUQQAABBBBAAAEEEIijgOvZII49IaDHrOuuT0L7dJp9Qu3NN6UTT8y9OevWSfYe+qpVUu3a4cJybAgggAACCCCAAAIIIJC4gOvZIPFKorMnAT06vUyoEtcn4f77S199Jb3zjtS0ae4lWTAvViz874sWSeXKJVQ+OyGAAAIIIIAAAggggMB/Aq5ngzg2ioDuWNfnz5+vrl276q233tLy5ctVp04dDRw4UAcddFAw0osuukhDhgzZZNQNGjTQxx9/nFAlrk/CvfeWvv1Wev99qUmT3EuyO+iFC4f/3b6Dbt9DZ0MAAQQQQAABBBBAAIHEBVzPBolXEp09CegO9XLRokWqX7++mjRpovbt26tixYqaMWOGatSooVr2TbH/Avpvv/2mJ598cv3IixUrpvLlyydUieuT8IorpNmzpT59pH333XZJdgfd7qTPnStVrZpQ+eyEAAIIIIAAAggggAAC/wm4ng3i2CgCukNd79atmz766CONHz8+11HZHfTFixdrxIgR+Rp5lCZhqVLS0qXSjBnS7rvni4ODEEAAAQQQQAABBBCIrUCUskFUmkhAd6iT9erV0/HHH6958+Zp7Nix2nXXXdWhQwe1bdt2/SgtoFs4t7vm5cqVU6NGjdSrV6/gbnsiW5QmoT00YO+ff/edtOeeiVTPPggggAACCCCAAAIIIJAjEKVsEJWuEtAd6mTx4sWD0XTu3FnnnHOOPvnkE3Xq1En9+/fXBRdcEPy3YcOGqVSpUtptt900c+ZM3XLLLVq9erWmTJmi7bfffotqVqxYIftn40lYrVo1LVmyRGXKlHGo+uSHUqmStGBBuKhcXo/DJ392jkAAAQQQQAABBBBAINoCBHT3+ktAd6gndlf84IMP1oQJE9aPqmPHjpo8ebImTpy41ZH+8ssvQVgfOnSozjzzzC326d69u3r06LHFv3c1oNu75H/8IX36qWQLxm1rq1ZNmjcv3Pe/NfQc6iZDQQABBBBAAAEEEEDAbQECunv9IaA71BML2k2bNtUTTzyxflT9+vVTz549Zau757bVrl1bbdq0CVZ/33zz7Q76TjtJf/4ZruRet+62m9O9u/TXX1KnTlL16g41kqEggAACCCCAAAIIIOCBAAHdvSYR0B3qSevWrTV37txNFom75pprNGnSpE3uqm885D/++CN4V33AgAHrH4PfVkmuT8KyZcPQPX26tMceDjWHoSCAAAIIIIAAAgggEDEB17NBxLgTKoeAnhBTZnayR9kbNmwYPJLeokWL4B10WyDOwvd5552nf/75R/bI+llnnaXKlStr1qxZuvHGGzVnzhxNmzZNpUuXznOgrk/CHXaQli2TZs6UatTIsxx2QAABBBBAAAEEEEAAgXwKuJ4N8lmW14cR0B1r38iRI3XDDTdo+vTpqlmzZrBgXM4q7suXL9fpp5+uzz//PPjUmoV0+2b6HXfcIVv4LZHN9Ulo69ytXJnYt83tXXUL8/ZYfMmSiVTPPggggAACCCCAAAIIIJAj4Ho2iGOnCOgx67rrk7BIEWntWumXX6Rddtl2cxo2lGztPPskfPPmMWsk5SKAAAIIIIAAAgggUEAB17NBAcvz8nACupdty/+gXZ6EFswtoNu2cKG0887brrNRI2ncOGn4cOmcc/JvwpEIIIAAAggggAACCMRRwOVsEMd+WM0E9Jh13uVJuHq1dOKJkv3P116T8nqlvmlTafRo6ZlnpPPOi1kjKRcBBBBAAAEEEEAAgQIKuJwNCliat4cT0L1tXf4GHqVJePLJ0ptvSoMGSRdfnD8PjkIAAQQQQAABBBBAIK4CUcoGUekhAT0qnUywjihNwjPOCN8/f+wxqV27BAHYDQEEEEAAAQQQQAABBAKBKGWDqLSUgB6VTiZYR5QmYYsW0gsvSI88Il15ZYIA7IYAAggggAACCCCAAAIEdEd/AwR0RxuTrmG5HNBtYbg6daSiRaUFC6RChbat8H//Jz37rHTffVLnzukS47wIIIAAAggggAACCERTwOVsEE3xvKsioOdtFKk9XJ6E8+dLVauGAX3VqrzZBw6UPvlEOussqVmzvPdnDwQQQAABBBBAAAEEENgg4HI2iGufCOgx67zLk3D2bKlGDal4cWn58pg1hnIRQAABBBBAAAEEEMiwgMvZIMMUzlyOgO5MKzIzEJcn4YwZ0h57SKVKSX//nRkProIAAggggAACCCCAQFwFXM4Gce0JAT1mnXd5En7/vbTXXlK5ctKiRXk3ZsUKaelSqVixMNSzIYAAAggggAACCCCAQOICLmeDxKuI1p4E9Gj1M89qXJ6E33wj7bOPtPPOki0Yl9d2ww3SnXdKnTpJDzyQ1978dwQQQAABBBBAAAEEENhYwOVsENdOEdBj1nmXJ+GXX0oHHCDtsov0yy95N+a226Tbb5c6dJD69s17f/ZAAAEEEEAAAQQQQACBDQIuZ4O49omAHrPOuzwJ7RH3iy+WypeXRo7MuzG9ekk33yy1bSsNGJD3/uyBAAIIIIAAAggggAACBHSXfwMEdJe7k4axuRzQky33nnukLl2kCy+UBg9O9mj2RwABBBBAAAEEEEAg3gJRygZR6SQBPSqdTLCOKE3CBx+UrrlGatVKeu65BAHYDQEEEEAAAQQQQAABBAKBKGWDqLSUgB6VTiZYR5Qm4aOPSldcIZ11lvTiiwkCsBsCCCCAAAIIIIAAAggQ0B39DRDQHW1MuoblckAfP14699xwJfe3385b4IknwvfPTztNevXVvPdnDwQQQAABBBBAAAEEENgg4HI2iGufCOgx67zLk9BC+QknSPXrS599lndjxo4NF4c76CCpc+e892cPBBBAAAEEEEAAAQQQIKC7/BsgoLvcnTSMzeWAbiu3n3qqdMgh0iefpKF4TokAAggggAACCCCAAALrBVzOBnFtEwE9Zp13eRKOGCGdcYZ0+OHShAkxawzlIoAAAggggAACCCCQYQGXs0GGKZy5HAHdmVZkZiAuT0Jb6O2cc6Sjj5bs8fW8tnXrpFWrpDVrpBIl8tqb/44AAggggAACCCCAAAIbC7wRjNgAACAASURBVLicDeLaKQJ6zDrv8iQcOjT8ZNoxx0jvvZd3Y0aNkk48MfF31vM+I3sggAACCCCAAAIIIBAfAZezQXy6sGmlBPSYdd7lSfjMM9L550vNmiW2ivv770vHHhuu+j51aswaSbkIIIAAAggggAACCBRQwOVsUMDSvD2cgO5t6/I3cJcn4WuvSbfcIjVsKPXrl3d9H34oHXWUVKeO9P33ee8flT1stfuvvgrf1T/yyKhURR0IIIAAAggggAACmRZwORtk2sKV6xHQXelEhsYRpUk4aZJ02GFSjRrSzJkZAnTgMoUKbRiEvYfPhgACCCCAAAIIIIBAfgSilA3yU7+LxxDQXexKGscUpUn4+efSgQdKVapI8+enEc2xUxPQHWsIw0EAAQQQQAABBDwViFI28LQFWwybgB6VTiZYR5Qm4TffhO+fV6ggLViQIEAEdiOgR6CJlIAAAggggAACCDggEKVs4ABnSoZAQE8Joz8ncXkSDhok3XmndPrp0t135236ww/SnntKZctKixfnvX9U9iCgR6WT1IEAAggggAACCGRXwOVskF2Z7F2dgJ49+6xc2eVJeM89Upcu0gUXSEOG5M3z229Su3ZSqVKSrQAfl42AHpdOUycCCCCAAAIIIJBeAZezQXord/fsBHR3e5OWkbk8Cfv0kW68UbrkEmngwLSUH4mTEtAj0UaKQAABBBBAAAEEsi7gcjbIOk6WBkBAzxJ8ti7r8iS84w7p1lulyy6T+vfPlpD71yWgu98jRogAAggggAACCPgg4HI28MEvHWMkoKdD1eFzujwJb7tNuv12qUMHqW/fxBFzPjW2cXBN/Gj/9hw8OHy0/+yzpWef9W/8jBgBBBBAAAEEEEDADQGXs4EbQpkfBQE98+ZZvaLLk/Cmm6TevaWrr5YefDBvpuXLpTJlpNWrpb/+kkqXzvsY9kAAAQQQQAABBBBAAIFQwOVsENceEdBj1nmXJ2HXruHq7ddeK917b96NWbNGKlo03O+PP6Ty5fM+hj0QQAABBBBAAAEEEECAgO7qb4CA7mpn0jQulwO6fWLtiSekNm2kbt0SAyhcWLJH3H/5Rdpll8SO8X2vAQPCmlu2lMqV870axo8AAggggAACCCCQLQGXs0G2TLJ9XQJ6tjuQ4etHbRIWLy6tWCHNni1Vr55hzCxdjkXisgTPZRFAAAEEEEAAgYgJRC0bRKE9BPQodDGJGqI2Ce0d9L//ln78UapVKwkIj3fdOKCvXSvFZXE8j1vG0BFAAAEEEEAAAScFopYNnEROclAE9CTBfN89apNw553D98+//VaqW9f37uQ9fgvkRYps2M+eHihWLO/j2AMBBBBAAAEEEEAAgc0FopYNotBhAnoUuphEDS5PQvsG+uuvS506SRdemFhRlStLv/4qffGFtP/+iR3j8162cn3JkhsqWLIkXMmeDQEEEEAAAQQQQACBZAVczgbJ1hKV/QnoUelkgnW4PAkvuEB6+ulwBXdbyT2R7bzzpEWLpIcekmrXTuQIv/exWjderf6336SKFf2uidEjgAACCCCAAAIIZEfA5WyQHZHsX5WAnv0eZHQELk/C1q2l558Pv4Fu30Jn21LAVquvUmXDv58zR6pWDSkEEEAAAQQQQAABBJIXcDkbJF9NNI4goEejjwlX4fIkbNFCeuEF6X//k664IuGSYrXjzJnS7rtvKPmHH+Lx5ECsmkyxCCCAAAIIIIBAhgRczgYZInDuMgR051qS3gG5PAnPOEMaMUJ67DGpXbv0Ovh69mXLpHHjpNNOk5o0kfr3l2rU8LUaxo0AAggggAACCCCQTQGXs0E2XbJ5bQJ6NvWzcG2XJ+Gpp0ojR0pPPCFdemliOMceK338sTR8uHTyyYkdw14IIIAAAggggAACCCAguZwN4tofAnrMOu/yJDzxRGnUKGnw4MRXcT/iCGnCBOmll6Qzz4xZMykXAQQQQAABBBBAAIECCLicDQpQlteHEtC9bl/yg3d5ErZqJY0ZIz3yiHT22YnVZo952zG2uNy55yZ2jM97zZ8f/hGjUiXplFN8roSxI4AAAggggAACCGRbwOVskG2bbF2fgJ4t+SxdN2qT8PjjpXfekZ56Sjr//CyhZvCyFs7tSQPbSpeWhg6VTjopgwPgUggggAACCCCAAAKREYhaNohCYwjoUehiEjVEbRLm5731JLic29UW0bPF9HI2W/U+0acNnCuGASGAAAIIIIAAAghkVSBq2SCrmCm6OAE9RZC+nCZqk9DeO3/lFenRR6X27X3pQv7HaXfM7VWAnO3pp6X/+7/8n48jEUAAAQQQQAABBOIrELVsEIVOEtCj0MUkanB5El5yiWTf9b73XumwwxIryt47HzZMevBB6eqrEzvG572GDJEuumhDBY8/LrVp43NFjB0BBBBAAAEEEEAgWwIuZ4NsmWT7ugT0bHcgw9d3eRLWry998YX09ttSs2aJwdx+u/Tee9IVV0gtWiR2jM972XfPL798QwW2oN6VV/pcEWNHAAEEEEAAAQQQyJaAy9kgWybZvi4BPdsdyPD1XZ6E++4rff11GLiPOSbDMJ5c7qGHpE6dNgz2nnuk667zZPAMEwEEEEAAAQQQQMApAZezgVNQGRwMAT2D2C5cyuVJWLeu9N130tix0tFHu6Dl3hjuukvq1m3DuO64Q7r5ZvfGyYgQQAABBBBAAAEE3BdwORu4r5eeERLQ0+Pq7FldnoS1a0s//ih99JHUsKGzhFkdmL2j/9VX4Xv3P/8sXXqpZO/usyGAAAIIIIAAAgggkKyAy9kg2Vqisj8BPSqdTLAOlydhjRrS7NnSpEnSoYcmVlDPntLDD4fvZdv76GwIIIAAAggggAACCCCQmIDL2SCxCqK3FwE9ej3dZkUuT8KqVaX586UpU6QDD0ysMTfdJPXuLXXsKNn72WwIIIAAAggggAACCCCQmIDL2SCxCqK3FwE9ej31NqDvtVf42PaECdI++yTWmB49pO7dwzvo/foldozPe338cfiUwf77S+bFhgACCCCAAAIIIIBAfgUI6PmVS99xBPT02Tp55qhNwj59pBtvDN/FfuIJJ8lTOih73/zJJ6U99pCWLZNOOy0ef5hIKSInQwABBBBAAAEEEAgEopYNotBWAnoUuphEDVGbhPfeK11/vXT++dJTTyUB4emurVtLzz8fBnRbUO/ss6UXXvC0GIaNAAIIIIAAAgggkFWBqGWDrGKm6OIE9BRB+nKaqE1CWyDu6qulli2loUN96UL+x3nmmdIrr0gHHyx9+ql0yinS66/n/3wciQACCCCAAAIIIBBfgahlgyh0koAehS4mUYPLk/DEE6V166Snn5YqVEisqMcek9q3lyy4vvRSYsf4vNdJJ0lvvSUdd5w0enT4P9991+eKGDsCCCCAAAIIIIBAtgRczgbZMsn2dQno2e5Ahq/v8iQsUkRauzZcKK5y5cRg7G6yfWqtSRPJHneP+nbMMdIHH0hnnRX+QeLII6Xx46NeNfUhgAACCCCAAAIIpEPA5WyQjnp9OCcB3YcupXCMrk5CC+YW0G1bsCDxO+gppPHiVEccEa5yb4viDRwYPuo+ebIXQ2eQCCCAAAIIIIAAAo4JuJoNHGPK6HAI6Bnlzv7FXJ2Eq1ZJxYqFPn/+Ke24Y/atXBzBQQdJn30mde4s3X+/tO++0ldfuThSxoQAAggggAACCCDguoCr2cB1t3SOj4CeTt18nHv+/Pnq2rWr3nrrLS1fvlx16tTRwIEDdZAlM9k72uvUo0cPDRgwQIsWLVKDBg3Ut29f7b333gldzdVJuHy5VLJkWMJff0mlSydUTux2evPN8AmD8uWlW26RateWXnwxdgwUjAACCCCAAAIIIJACAVezQQpK8/YUBHSHWmeBu379+mrSpInat2+vihUrasaMGapRo4Zq1aoVjPSuu+5Sr169NHjw4CC89+zZU+PGjdP333+v0gmkWlcn4d9/S2XKhM2w73uXKJFYY8aMkezb4PXqSSNHJnYMeyGAAAIIIIAAAggggADfQXfxN0BAd6gr3bp100cffaTxuaz6ZXfPq1Spok6dOgV32W1bsWKFKlWqFAT3du3a5VmNqwF90aLwrrBtK1dK222XZynBDu+8Ix1/vLT//tIXXyR2DHshgAACCCCAAAIIIIAAAd3F3wAB3aGu1KtXT8cff7zmzZunsWPHatddd1WHDh3Utm3bYJQ//fRTcCf9s88+C+6052zNmzdXuXLlNGTIkC2qsQBv/+RsFtCrVaumJUuWqEzOLWsHDBYulKpWlexd9NWrpcKFExuU3UG3FdztDvo33yR2jM972TfPzaZxY2mHHXyuhLEjgAACCCCAAAIIZFvA1Zt32XbJ5vUJ6NnU3+zaxYsXD/5N586ddc455+iTTz4J7pb3799fF1xwgSZMmKAjjjhC9p663UnP2S677DLNnj1bb7/99hbVdO/ePXhnffPNtYCe3zZ89FH4qbE99pCmT8/vWfw5rlQpaelSaeJE6cILpTVrpB9/9Gf8jBQBBBBAAAEEEEDAHQECuju9yBkJAd2hnhQrVkwHH3xwEMRzto4dO2ry5MmaOHHi+oD+888/q/JGHwq3O+xz587VqFGjtqjGlzvo+W2DfWLs0EOl6tWl2bPzexZ/jitaNAzlX34ZPtZvm/3viT5x4E+ljBQBBBBAAAEEEEAg3QIE9HQLJ39+AnryZmk7YrfddlPTpk31xBNPrL9Gv379goXg7K55fh5x33ywUZuEFlQPOECyv1f8/HPaWuPEie3R/5x38+2PEbvtFg4rmUX1nCiEQSCAAAIIIIAAAgg4IRC1bOAEagEHQUAvIGAqD2/dunVwJ3zjReKuueYaTZo0Kbh7nrNInP27Ll26BJdeuXJlsNq774vEzZ8vtW8vlS0rPf104qrTpoXvn++0k/T774kf5+Oe//yz4fNzixdL5cqFVfDdeB+7yZgRQAABBBBAAIHsCxDQs9+DzUdAQHeoJ/Yoe8OGDYN3xlu0aBG8g26Pr9s3z88777xgpBbE+/TpoyeffFK1a9dW7969NWbMGO8/s/btt5J9yj3ZoG13km0V9x13DN/LjvJmf4CoUCGs0O6mFysmrV0bPjmw0RsPUSagNgQQQAABBBBAAIEUChDQU4iZolMR0FMEmarTjBw5UjfccIOmT5+umjVrBgvG5azibtewu+gW4G3hOPtueoMGDdS3b1/ts88+CQ3B1Un41VfhO9WVKkm//ppQKbHbad48qVq18DF3+xSdreJuj7f/9JNUs2bsOCgYAQQQQAABBBBAoIACrmaDApbl9eEEdK/bl/zgXZ2En30mHXRQ+Km1uXOTrysOR9hq7bVrh4+5//VX+LSBPd5uj/nvtVccBKgRAQQQQAABBBBAIJUCrmaDVNbo27kI6L51rIDjdXUSfvKJ1KCBVKOGNHNmAYuM6OH23vmLL0qFCkmXXio1bCgtWSK9/LK0554RLZqyEEAAAQQQQAABBNIm4Go2SFvBHpyYgO5Bk1I5RFcnoX1Z7ogjkv+euT3ibcHeHvm2Fd3/+5R8Ksk4FwIIIIAAAggggAACkRRwNRtEEjvBogjoCUJFZTdXJ+G4cVKjRuGj2vbIdqLbihUbQrndTS5TJtEj2Q8BBBBAAAEEEEAAgXgLuJoN4twVAnrMuu/qJHz/fenYYyVb627q1MSbYquYFykS7r9wobTzzokf69ueVp+9q2/vnh98sG+jZ7wIIIAAAggggAACrgm4mg1cc8rkeAjomdR24FquTsJ166Q1a8J/tt8+OaiiRcPj7FvqVaokd6xPe7/xhnTKKWE4nzxZuvhiadIk6aGHpKZNfaqEsSKAAAIIIIAAAgi4IOBqNnDBJltjIKBnSz5L143iJCxZUlq+PFxczhaZi+r20kvS2WdLRx4pjR8vHXOM9MEH0tChUsuWUa2auhBAAAEEEEAAAQTSJRDFbJAuq0ydl4CeKWlHrhPFSViuXLia+Q8/hJ8hi+r23HPSeedJxx0nvfuudNJJ0ltvSYMHSxdeGNWqqQsBBBBAAAEEEEAgXQJRzAbpssrUeQnomZJ25DquTsKcR7Xr1ZNuvjk5rAoVpN9/l77+Wtp77+SO9WnvQYPCz6udfLI0cqR05pnSK69Ijz0mtWvnUyWMFQEEEEAAAQQQQMAFAVezgQs22RoDAT1b8lm6rquTcNgw6dxzpcaNw8e2k9kOOUT6448wtFrAj+r26KPSFVdIZ50Vfg+9Vavw8fYHH5SuvjqqVVMXAggggAACCCCAQLoEXM0G6arXh/MS0H3oUgrH6OokfPZZ6f/+b8Pj2yksOTKnuv9+6dprw8fcn3kmXCTOHm+/806pa9fIlEkhCCCAAAIIIIAAAhkScDUbZKh8Jy9DQHeyLekblKuTcMgQ6aKLpBNOCN+rZttSoHdv6aabwsfcn3hCat8+fLy9e3fpttsQQwABBBBAAAEEEEAgOQFXs0FyVURrbwJ6tPqZZzWuTsKBA6U2baRTT5Veey3PMmK5g31a7aOPwsf4mzWTbr1Vsj9sXHWVdN11sSShaAQQQAABBBBAAIECCLiaDQpQkveHEtC9b2FyBbg6Cfv3ly6/XDrjDOnll5Orye68T50afg/cPkHGhgACCCCAAAIIIIAAAnkLuJoN8h55dPcgoEe3t1utzNVJ2LevdOWV0jnnSMOHJ9eUww6TbBX4V1+VTjstuWPZGwEEEEAAAQQQQACBuAq4mg3i2g+rm4Aes+67Ognt7nenTuHK5Pa972S2o4+Wxo+XXnhBOvvsZI70a9/vvgtXq69ZU6pSxa+xM1oEEEAAAQQQQAAB9wRczQbuSWVuRAT0zFk7cSVXJ+HKldLy5VKRIlKpUslRHXec9N57kq0E37p1csf6tPeFF0pPPSXdfbd0/fXhHyTuvVdq0iRcyZ0NAQQQQAABBBBAAIFkBFzNBsnUELV9CehR62ge9URxEp54ojRqVPjJMQuxUd3sO/H2vfiHHw4XhrMV3G0l9/y8tx9VI+pCAAEEEEAAAQQQSFwgitkg8erd3JOA7mZf0jaqKE7C5s3Dld8HDJDatk0bXdZPfPrp4Xv2tqDeZZeFf5Cwb6HbHyjefDPrw2MACCCAAAIIIIAAAp4JRDEbeNaCLYZLQPe9g0mO39VJOGKE9MYb0rHHSnanOJnNFpZ78UXpf/+TrrgimSP92te+Ef/22+Gn1S64QBo6NHxn3x5xf/99v2phtAgggAACCCCAAALZF3A1G2RfJnsjIKBnzz4rV3Z1Et58s9Srl9SxY/i5tGS2du0kC/g9e0b7DnrjxtLYseFj7i1ahDXb4+2HHy5NmJCMGPsigAACCCCAAAIIICC5mg3i3BsCesy67+ok7NZNuusuqXNn6b77YtaUBMvd/HNy9t69Pd5ev7702WcJnoTdEEAAAQQQQAABBBD4T8DVbBDnBhHQY9Z9VyfhtddK998vdekSBnW2LQUOOED68svwMfdmzaQxY8LH2+vWlb79FjEEEEAAAQQQQAABBJITcDUbJFdFtPYmoEern3lW4+okvPrqcHXyG28MH3Vn21Jg0CDp55+l884Lv4U+ebJk76XXqSNNnIgYAggggAACCCCAAALJCbiaDZKrIlp7E9Cj1c88q3F1Etribo8+Kt12m9S9e55lbLJDv37S88+HC6bZZ8fYEEAAAQQQQAABBBBAIG8BV7NB3iOP7h4E9Oj2dquVuToJbaE3+0zaHXdItmBcMlvXrtLdd/P+ejJm7IsAAggggAACCCCAgKvZIM6dIaDHrPuuTsJLL5XsEe4+fSRbMC6Z7ZZbwhXcr7xSeuSRZI70a98pU6SiRcN3zosV82vsjBYBBBBAAAEEEEDAPQFXs4F7UpkbEQE9c9ZOXMnVSbhkifTPP1Lp0lKZMslR2V33W2+V7C78Y48ld6xPe5coIf37rzR7tlS9urRokXT22dLKldK4cVKhQj5Vw1gRQAABBBBAAAEEsi3gajbItks2r09Az6Z+Fq4dxUloq77bXfeLLw7vwkdxW7dOKlw4rOzXX6VKlcKAXr58+O8spG+3XRQrpyYEEEAAAQQQQACBdAlEMRukyypT5yWgZ0raketEcRLa59nsM222uvkzzzgCneJhrFghFS8ennTxYqlsWWn5cqlkyfDf/f23VKpUii/K6RBAAAEEEEAAAQQiLRDFbOB7wwjovncwyfG7Ogkff1z6+mupZUupYcPkivrf/6SrrpLOOUcaPjy5Y33Z214BKFcuHK095r799tLatVKRIuG/W7hQ2nlnX6phnAgggAACCCCAAAIuCLiaDVywydYYCOjZks/SdV2dhKedJr3+umRBvU2b5HAGDpTsO+qnnx7dO+gLFoSPtdtmwTznfXNbLG7VKmnuXKlq1eTc2BsBBBBAAAEEEEAg3gKuZoM4d4WAHrPuuzoJTzpJeust6cknpYsuillTEih3zhxpt93CO+d2Bz1nswX17PH26dOlPfZI4ETsggACCCCAAAIIIIDAfwKuZoM4N4iAHrPuuzoJmzWT3n1Xevpp6f/+L2ZNSaDcH36Q9twzfPfc3kHP2SpWDB9vnzpV2mefBE7ELggggAACCCCAAAIIENCd/Q0Q0J1tTXoG5mpAP+YY6YMPpOefl849Nz21+3xWC+F9+4bfQb/55g2V2F1z+29jx0oHHOBzhYwdAQQQQAABBBBAINMCrmaDTDu4dD0CukvdyMBYXJ2ERx8tjR8vvfBC+G3vZLZJk6QePcJHvB9+OJkj2RcBBBBAAAEEEEAAgfgKuJoN4tsRiYAes+67Oglt5faJE6URI6TmzZNryptvSiefLB10kPTpp8kdy94IIIAAAggggAACCMRVwNVsENd+WN0E9Jh139VJeOih0uTJ0siRYdhOZhs9WmraVNpvP+nLL5M50p99//orXKndFoWrVs2fcTNSBBBAAAEEEEAAAXcFXM0G7oqlf2QE9PQbO3UFVyfh/PnSsmVS5cpSqVLJkY0bJzVqJO21lzRtWnLH+rK3fYLOPkVnf8iwR/pzthtukD77TLrpJsleE2BDAAEEEEAAAQQQQCBRAVezQaLjj+J+BPQodnUbNUVxEtqj8faI/O67SzNmRLOh9m5+ixZhCLcF4XI2e3LAniB49lmpdeto1k5VCCCAAAIIIIAAAukRiGI2SI9U5s5KQM+ctRNXiuIknDJFOvhgqWrV8DHwKG72+bkLLpDsc3Rvv72hwlNPDV8LGDhQuuSSKFZOTQgggAACCCCAAALpEohiNkiXVabOS0DPlLQj13F1Et59t7RkidSunVS9enJY9g1we/+8UiXp11+TO9aXvR9/XLrssvAx91df3TDqc86RXnwx/ARbhw6+VMM4EUAAAQQQQAABBFwQcDUbuGCTrTEQ0LMln6XrujoJa9aUZs0K36+296yT2b77TqpbN9oB/ZFHpI4dJQvkw4dv0Dn/fOmZZ6T77pM6d05GjX0RQAABBBBAAAEE4i7gajaIc18I6DHrvquT0FYmnzdPssfVDzwwuaasWxfuX6hQcsf5tPc990hdukgWyJ96asPI27QJH2/v1Uu68UafKmKsCCCAAAIIIIAAAtkWcDUbZNslm9cnoGdTPwvXdnUS2urt9ni6fSbNHldn21SgZ0/plluktm2lAQM2/Lcrrwwfb7f/dvvtqCGAAAIIIIAAAgggkLiAq9kg8QqitycBPXo93WZFrk7CChWk33+XvvlGqlcvZk1JoNx33w0Xh2vQIHzMPWe77jrp/vulbt2k3r0TOBG7IIAAAggggAACCCDwn4Cr2SDODSKgx6z7rk7CHXeUFi+Wvv9eqlMnuaYsXSpdeKG0alW4YNp22yV3vM97r10bPtof5cf7fe4PY0cAAQQQQAABBFwWcDUbuGyW7rER0NMt7Nj5XZ2EpUpJFrTtO+b2PfNkNjvOjrftn3+kHXZI5mj2/X/2zgTqxqp94xcyZq4IiYyllJSIkFDKTIMSSaUoRKL0GTOEJpWKRGUuyRTRhNRXCWVOZZZMmcfIf13v/s7/nc77nuec8zzn3eec617Lqpz97OG3n71W13Pf+75FQAREQAREQAREQAREID4J2KoN4nM3zKol0ONs9209hDlyAKdOAVu3Bl9mjZ7zbNnMRh44AOTPH3ubunu34VOwYOLHiNhbpVYkAiIgAiIgAiIgAiIQSQK2aoNIMrBtLAl0F3Zk4MCB6NGjB3LlypWstxMnTmDEiBHo27evC6O404Wth3DNGuDMGXP/3Ce2na6YWdwzZzatKWQLFXL6ZPS0u/9+YNKk1OXUFi4ERo8GqlQx99BlIiACIiACIiACIiACIuCUgK3awOn8Y7GdBLoLu5olSxbs2rULhVIow/379yf83dmzZ10YxZ0uYvUQUtTTk759O3DJJe6wsqkXJobj/XpmbO/UKXFmY8eazO5NmgCzZtk0Y81FBERABERABERABETAdgKxqg1s557e/CTQXdi9zJkzY/fu3biIqciT2FdffYV77rkHe/fudWEUd7qI1UMYzh12d8h620vjxsDcuabmefv2iWNNmAC0bQvceqvJ8i4TAREQAREQAREQAREQAacEYlUbOF2/je0k0MPYlQIFCiBTpkw4dOgQ8ubNm/DvPqPX/OjRo3jssccwim5PS8zGQ0jPN0uEnXcewLJh2bMHD4t3s3n/fP164PLLg3/e9ifq1we++AKYOBFo3Tpxth99BNx9N1CrFrB4se2r0PxEQAREQAREQAREQARsImCjNrCJT0bMRQI9DOrvv/8+zp07h/bt2+PVV19Fvnz5/r+3bNmyoWTJkrjxxhvDGMH9R208hMy8niePWSszsqe4yu8IQuHCwJ49wC+/AFdf7eiRqGpUsyawdKkJc2/ZMnHqc+aY8PYbbgB++CGqlqTJioAIiIAIiIAIiIAIZDABG7VBBiPJ8OEl0F3YgsWLS28w3gAAIABJREFUF6NGjRo4jy5gy83GQ8j656yDTjt9OrQ65idOGA88/8RiTXAmgfvpJxPm3rBh4kv2+ecmvJ0fJfhxQiYCIiACIiACIiACIiACTgnYqA2czj1W20mgu7CzK1asQNasWVGxYsWE3mbNmoXx48ejQoUK6N+/P+hNt8VsPIT79gG+6/vMp+fLyG4LMxvmQQG+erUJc69bN3FG33xjwtvLlQN+/dWGmWoOIiACIiACIiACIiAC0ULARm0QLey8mqcEugtkq1SpgmeeeQYtW7bEpk2bEoR5ixYtsGzZMjRs2DAh/N0Ws/EQ/vUXUKSIEeYWJby3ZcsS5jF4sMlQ3727EeM+W7bMhLdfeqmpIS8TAREQAREQAREQAREQAacEbNQGTuceq+0k0F3YWd49pxe9dOnSGDZsGJi9fcGCBfj222/RqlUrbKeyssRsPIQ7dgDFi5v656dOhQaqTx/gjz9MLfBYvIOeFhV+0OC1ACbWU+RBaO+OnhIBERABERABERCBeCVgozaI173wrVsC3YU3gBncly9fjrJly6J+/fpo1KgRunbtim3btqF8+fI4wQvSlpiNh3DLFuCyy0xyOCaJC8Wuvx5Yvhz49FPgjjtC6UHPiIAIiIAIiIAIiIAIiEB8EbBRG8TXDqRerQS6C2/ALbfcguLFi6NevXp46KGHsG7dOpQpUwZMHvfAAw9gCxWoJWbjIfztNxO2nTcvcOhQaKCqVwf++1/gk0+AZs1C68Pmp3btMl7y/PnlKbd5nzQ3ERABERABERABEYgmAjZqg2ji58VcJdBdoLpq1Sq0bt06wWPevXt39OvXL6HXzp07Y//+/Zg8ebILo7jThY2HkAEGq1YB584B1aqFts6bbzZ1wKdNM3XBY80ozhnKztsSl1ySuLojR4AnngBOngSmTJF4j7V913pEQAREQAREQAREwEsCNmoDL9cbDX1LoHu4SydPnkSWLFkSMrzbYrF6COvXNxnOJ04EWre2hbY78/j3XyBLFtMXa737Mt7zvw8fBvLlM7/xQ0eOHO6MqV5EQAREQAREQAREQARin0CsaoNo3jkJdBd3j/fQ169fj0yZMuGKK65A5cqVXezdna5i9RCyNvi8ecC4ccCDD7rDypZeKLx5P98nyPPkSZyZL0Ec/+bAARMCLxMBERABERABERABERABJwRiVRs4WbutbSTQXdiZPXv24J577km4c54/f36cO3cOhw4dQp06dTB16lRclNTl6cJ44XRh4yHk/epJk4ALLghdXDdvDsycCbz9NvDoo+EQsu9ZCu+CBc28KMiTBmTwWgC96/wny9UVLmzf/DUjERABERABERABERABOwnYqA3sJBW5WUmgu8Ca4vyPP/7AhAkTEjznNCaKY4I4JoubwsvBDqx///4YMGBAspaFCxfGX1ReANq1a4f3338/2e9Vq1bF999/76B308TGQ/jdd0CNGkDp0sDvvzteSrKG99wDfPgh8NprvPsfWh+2PsUPGEWLmvvlZ84AmTIln2nOnOYOOnMRlihh6yo0LxEQAREQAREQAREQAdsI2KgNbGMU6flIoLtAnHXQv/jiC1SpUiVZbz/++CNuvfVWHDx40NEoFOjTp09P6MtnvMPu88BToO/evRvjx4///9+zZcuGgj73qoNRbDyES5YAtWsD5csDGzY4WISfJryLzbvaDAVnPfVYss2bgVKl0i5DV6AAwFeM7MhQJgIiIAIiIAIiIAIiIAJOCNioDZzMO5bbSKC7sLt58uTBN998g0qVKiXrbeXKlahdu3aC19qJUaDPnDkTP//8s9/mFOgU+2wTqtl4CL/6CqhbF7jySmDNmlBXFrvPrV8PVKgAUIj//XfqdRYpYsLb+dpcc03sctDKREAEREAEREAEREAE3CVgozZwd4XR15sEugt71rRp0wThzFD2ooxFBrBz586E0msFChTAJyzO7cAo0EeMGAF65LNnzw6Grw8ZMgSl6D79X4g7xTm95rzrTvE/ePBgFCpUyEHvpomNh3DhQuC224y4TOPbhOP1xWLDHTuA/v1NhvY33ki9wssuM+HtP/wA3HBDLBLQmkRABERABERABERABLwgYKM28GKd0dSnBLoLu7V9+3ZQpK9ZswbFixdPyOLOmugVK1bErFmzcEnSwtXpjDd//nwcP34c5cqVSwhlHzRoEDZs2IC1a9figgsuwLRp05A7d26UKFECmzdvRp8+fXDmzBkwezwFvT87deoU+MdnPIScI5PY5c2b14XVh98Fs68zC/t11wE//RRafx99BFDoN2gAtGwZWh/R+hS96kwcd/75qoMerXuoeYuACIiACIiACIhARhCQQM8I6umPKYHu4p58/vnnCYKaWdwrVKiAevXqhdX7sWPHULp0afTs2RPdu3dP1deuXbsSxDozxbdo0cLvWP4Sz7GhTQJ99mygaVOgalUgiHx3ydbbowfw0ktAz57AsGFhYdfDIiACIiACIiACIiACIhAXBCTQ7dtmCfQw9uSrr77CE088kZBFPaU3mgK4evXqePvtt1GzZs2QR6lfv35CJvi33nrLbx9ly5bFww8/jF69evn9PRo86DNmGK83M7kvXRoaqmefBV54AXjySeCVV0Lrw9anWFqNtdCZrT3WEuDZylzzEgEREAEREAEREIF4ICCBbt8uS6CHsSdNmjRJqHXerVs3v7289tpr+Prrrx3fQU/ZCcU1PegdOnRA3759U42xf/9+FCtWDGPGjEHbtm0drcTGQ7h3L7B6NZAnD5AiEb6jNbFRv37AwIHA44/7v6ftuCMLGzInIOu833gjwJJ0Ke3VVw2/Rx4BqlWzcAGakgiIgAiIgAiIgAiIgJUEbNQGVoKK4KQk0MOAzfDyzz777P9rn6fsiuHuLLPG++hOrEePHmjcuDEuvfRS7NmzJ+EO+uLFi7F69eqEO+gMV2/ZsiWKFCmCLVu2oHfv3gl9r1+/Hswk78Ri9RAOHgz85z9GpI4Z44RE6jZ//gmwYh2TsdlkU6cC994L1KkDMON9SuO9+wULgPffBxx+p7FpeZqLCIiACIiACIiACIhABhGIVW2QQThdGVYCPQyMOXLkSEgMxxB0f/b7778nJIo7wfhkB9aqVSssWbIE+/btS6h9Xq1aNTz//PMJ99nZR7NmzcDSbcwYT5FO7z1/Z9I3pxarh3D4cIBR/g88ALz3nlMaie22bgVKlgRYKW/lyuCf9/IJrufBB4HbbweYUC+lNWsGzJoFjB4NdOjg5UzUtwiIgAiIgAiIgAiIQCwRiFVtEM17JIEexu4x/PzFF19Ec8Yf+7EZM2aAXvFNmzaFMYq7j9p4CNetAxYvBlhNjuXWQjGGefOmAT3NkycH3wOv+HfqZJ47dy745718gsL7scdMmDvv66e0Vq2AadOAkSOBLl28nIn6FgEREAEREAEREAERiCUCNmqDWOIbylok0EOh9r9nOnfujEWLFmHZsmWgNz2p0eN9ww03JHi5eRfdFrPxEDIk/dFHAXqCHZaMT4XzzTfN/fM77wRYci1Ymz4duOsugPn8liwJ9mlv21N4M/ldWh8f2rUz4e3MXs8s9jIREAEREAEREAEREAERcELARm3gZN6x3EYCPYzdZa3yypUrI0uWLAnZ3MuXL59QA513wkeNGoWzZ89ixYoVKFy4cBijuPuojYdw1CjgiSdCF9ckdOQIcPiwqQWeP3/wzN59F3j4YVOPfe7c4J/38gkK72eeASjEx49PPRK96/SyDxgA+Mkl6OXU1LcIiIAIiIAIiIAIiEAUE7BRG0QxTlemLoEeJsatW7eiY8eOWLBgQUL9cxpF+m233YY333wTJXmx2SKz8RD6PMQM1Z4yJWNgsTQbS83TSz1unF2J4ii8+/c3Ye7+qu3Ru06GvXsDTJYnEwEREAEREAEREAEREAEnBGzUBk7mHcttJNBd2t0DBw6ASeEo0lmbvECBAi717G43Nh7Cl14CevQA2rQBPvjA3fU67c0ngtmeCdko0m0xhux//DFQvz7w0EOpZ8XkeEySxw8MZCkTAREQAREQAREQAREQAScEbNQGTuYdy20k0GN5d/2szcZD6AvhDkcYsw44RTUT2lOoBmt8hl50WtWqwPffB9tDxrU/cAA4eRLIm9eE+MtEQAREQAREQAREQAREwAkBG7WBk3nHchsJ9Fje3SgR6G7UMJ89G2jaNHRxPWcOwLvwrCdOoXvwIK8qxNnLoeWKgAiIgAiIgAiIgAjEFQEJdPu2WwLdvj3xdEY2HkJfeHnHjgCzsYdin31m6oRfey2wYkUoPQCnThkP9NmzwM6dQNGiofXj9lOnTwNZspg/MhEQAREQAREQAREQARFwi4CN2sCttUVrPxLo0bpzIc7bxkO4cSPw66/ApZcC11wT2sK++gqoWxe46iqA4e6hWvnyAOfzxRemPxvsvvtM8jzWeu/aNfWMGI7P3ytUMOXqZCIgAiIgAiIgAiIgAiLghICN2sDJvGO5jQR6LO+un7XF6iH85hugVi2gXDkj9oO1TZuArFmNwJ0/H2Dp+s6dg+3Fm/YtWpj68MzgzkzuKY2l19q3t7NEnDdE1KsIiIAIiIAIiIAIiIAbBGJVG7jBJqP6kEDPKPIZNG6sHsIffgCqVQNY1W7z5uDhXnklsG6ducPOvsIJtw9+9PSfYG32efNMDXTWQk9p9J7Ty06PPz3/MhEQAREQAREQAREQARFwQiBWtYGTtdvaRgLd1p3xaF42HkIKYnq9r74aqFQptIWvXAlUrgwUKwbs2BF8H5dcYu6d9+kD/PijSThHkW6DUXgzhH/yZFOnPaXNmAG0bAnUqAEsXWrDjDUHERABERABERABERCBaCBgozaIBm5ezlEC3Uu6FvZt4yF84gmTQZ3ieODA0KCtXWvun190EbBnT/B9MHP7kSPm/nnZssE/7+UTFN7ffQdQiDdvnnoketfpZb/uOuCnn7ycifoWAREQAREQAREQARGIJQI2aoNY4hvKWiTQQ6EWxc/YeAh5r3r0aIDZ3Pv2DQ0uM7Bv2QJkz27C3IOxf/9NzJC+ezdQqFAwT3vflsKbmekpxJmpPqX5EuQxTH/NGu/noxFEQAREQAREQAREQARig4CN2iA2yIa+Cgn00NlF5ZM2HsKHHwbefRdgPfTevSOP9dAhIH9+M+6JE0COHMDff5ukcXnyRH4+KUf03Y+nEK9TJ/V86F2nl710aeD33zN+vpqBCIiACIiACIiACIhAdBCwURtEBznvZimB7h1bK3u28RAy8dn77wPDhgE9e0Ye2/btpsRbtmymFnqrVsC0acA77wD8eJDRxisAjA4gH4r1lEbvOr3sod6/z+j1aXwREAEREAEREAEREIGMIWCjNsgYEvaMKoFuz15EZCY2HsL77wcmTQJefhno1i00DMePA0OGAKdPAy+8AGTO7Lwf3/31Cy8E9u41c2DNcf6Tc7LdTp4E+JEhZ06Aye5kIiACIiACIiACIiACIuCEgI3awMm8Y7mNBHos766ftdl4CH0e63BqjycNU6dg5V10p8as76+8YjzoQ4cCY8aYeugNGpia6DIREAEREAEREAEREAERiEUCNmqDWOQczJok0IOhFQNtbTyEd94JfPwx8OaboZc2493xXLnMBh0+HN7dcZYqq1kTKFHChJZntJ07B2TKlNGz0PgiIAIiIAIiIAIiIAKxRsBGbRBrjINdjwR6sMSivL2Nh5BJzrZtM/eoQy1xduaMSepG278fKFgw9I3i8wx3px09Cpx/fuh9ufEkPfvnnQds2gRcfHHqHvlxYtAggJEDw4cnZqR3Y2z1IQIiIAIiIAIiIAIiELsEbNQGsUvb2cok0J1xiplWsXoI6WXOkgXgP3ft8i9k09rEAweMEKeo94lxllrjfXTWFeeHg4yypB8emFm+QIHUMzl2DMid254PChnFSuOKgAiIgAiIgAiIgAgERyBWtUFwFOxqLYFu1354PptYPoQsj8Ys7Fu3mqzsTu2ll4AePYDWrYGJE81TN98MLF4MTJgAMIldRhk/HPhKvVGI+8L4k84nqYjftw+44IKMmq3GFQEREAEREAEREAERiCYCsawNomkfks5VAj1ady7Eedt4CBctMnXHq1Y1pcJCtbx5gSNHgN9+A8qUcd5Lv37AwIHm/jvvwdNGjgQ2bgTatAGqVXPel9stKbgvusj0SiHOKAF/xvB+/r5zJ1C0qNuzUH8iIAIiIAIiIAIiIAKxSMBGbRCLnINZkwR6MLRioK2Nh7B2bWDJEuCjjwAmjAvV6Dmm0GfZtAoVnPfy5JNGkD/zjMnibpMxw3zx4uZ+PUvIpWX0stPb/scfQKlSNq1AcxEBERABERABERABEbCVgI3awFZWkZqXBHqkSFsyjo2HsEYNgIniPvkEaNYsdFCrVpls50w0x3B3p9a+PTB+vKmj/uyzTp+KTDsKbkYDUIAzO31axqR2TG4X7MeJyKxCo4iACIiACIiACIiACNhIwEZtYCOnSM5JAj2StC0Yy8ZDyND2H38E5swBGjWKPCRfmbc33gAefzxxfIbLb9gAVKqUmCE+0rOj4L7qKhPmvmdP2qNfcokJb1++HKhcOdKz1HgiIAIiIAIiIAIiIALRSMBGbRCNHN2cswS6mzSjoC8bDyEF5cqVwPz5QIMGkYdYvz7wxRfJE8IxGzwzph86lLFeaXrQ+dGAHnReAUjL6GVn22+/BapXjzxDjSgCIiACIiACIiACIhB9BGzUBtFH0d0ZS6C7y9P63mw8hFdfDaxeDXz+OVCvXugIx44F/vzTZF0P5h62z4M/axbQpEni+L6/D/dufOgrcv7k+vWmbcmSQM6czp9TSxEQAREQAREQAREQgfglYKM2iN/dMCuXQI+zN8DGQ8iEbhSYzObOhHGh2rXXAj//DCxYANx6q/Nehg0zmd+7dQOuvDLxuQcfBN57z2R479PHeX9qKQIiIAIiIAIiIAIiIALRQMBGbRAN3LycowS6l3Qt7NvGQ1iunBHIS5cCTBgXqrl9l334cKBXL+Dee4HJk0OdlZ4TAREQAREQAREQAREQATsJ2KgN7CQVuVlJoEeOtRUj2XgIP/4YOHAAaNwYKFw4dEw33WTuYLO/Fi1C78f3JJPWMeSdSeJ4Rz4jbOZMoG1boFYtYO7ctGcwZYpJaMcs+IwkkImACIiACIiACIiACIhAIAI2aoNAc4713yXQY32HU6wvlg/hLbcAX38NUKy2auVsY//919xbz5vXJGJjmTaf/f57Ysk21hjPksVZn262oue+dWugbl2TyC4tY/b7Tz8F3n0XYNk4mQiIgAiIgAiIgAiIgAgEIhDL2iDQ2m39XQLd1p3xaF6xfAiZAZ73zz/4AGjTxhlAeu4LFjRtT54EsmdPfO7sWeD884FTp0yG9GASzzkbPXCrceOAhx4CGjZM34PuKxX35ptAx46B+1ULERABERABERABERABEYhlbRCtuyuBHq07F+K8bTyECxcC9GQzRD137hAXBhMizzBwZnOnqHViW7eazOcU5hToKa1/fyBfPpMZnrXII20U3Cyz1rIlMH162qPTy05v+8svm2R3MhEQAREQAREQAREQAREIRMBGbRBozrH+uwR6rO9wivXZeAhZb/zgQXOHunz50DeEInbGDCAYLzLLu7HMG8X3nj2hj+3Vk6+8AnTvbsLcJ05MexR+kKC3fcgQ4NlnvZqN+hUBERABERABERABEYglAjZqg1jiG8paJNBDoRbFz9h4CHn3m3e8eee7dOnQ4bJU26FDJhS9UCFn/TBzfM2aQJkyJpO8bTZ0KNC7t7lXzvvlaRm97Pww0bcvMGCAbavQfERABERABERABERABGwkYKM2sJFTJOckgR5J2haMZeMhzJnThJdv2QKUKBFZSPPmmfvdlSsDy5enHvv0aVOj/a+/gNtui+zcOFq/fqYOe6dOwKhRaY//1FMmvL1nT4B13WUiIAIiIAIiIAIiIAIiEIiAjdog0Jxj/XcJ9Fjf4RTrs/EQZs0KnDkD7NgBFCsW2Q2ZOtXUOb/5ZpMBPqWtWQNUrGiyvDMMP2mW90jM9J13gPffN3fQ07tb/txzJry9a1fg1VcjMTONIQIiIAIiIAIiIAIiEO0EbNQG0c403PlLoIdLMMqet+0QnjsHZM5sINJLHU4d9EWLjBe8alWTcM6JjRkDPPoo0LQpwJrjKY0Z3HPlMknsdu4EihZ10mvk22zbBuzeDRQpAlxySeTH14giIAIiIAIiIAIiIALRR8A2bRB9BN2fsQS6+0yt7tG2Q8hSZuedZ5Dt2wdccEHo+J58Ehg50tzZHjzYWT/0mjP5WqVKQOfO/p8pV87cT2cdctYjl4mACIiACIiACIiACIhALBCwTRvEAtNw1yCBHi7BKHvetkNID3WOHAYiE7wxlDxUe/pp4MUXgR49gBEjQu0l9XPNmgGzZgGvvw488YR7/aonERABERABERABERABEchIArZpg4xkYcvYEui27ESE5mHbIeTdc4aZ85+PPQZkyxY6CN897C5djCfdLWPZshdeADp2NJnSI2ksnzZ/vrlf3q5d2iPzrjzbMcne3XdHcoYaSwREQAREQAREQAREIFoJ2KYNopWjm/OWQHeTZhT0FcuHkOXF+vcPTkgz8VuWLMD55yfehU+5jR98ADzwQNqJ5Lzcdt6Nnz0bGD0a6NAh7ZF8c2zQwAh1mQiIgAiIgAiIgAiIgAgEIhDL2iDQ2m39XQLd1p3xaF6xfAjpZaYXnV7nsWOdAWzRAvjkE+MZp4fcny1bBtxwg0lgx0R2kTSWdlu40GRyb9s27ZE//BC4556M+YgQSR4aSwREQAREQAREQAREwD0CsawN3KMU2Z4k0CPLO8NHs+0Q8g76f/9rEsU5zbyeFkTeP+c99DZtAHqUnVi9esCXXwKTJgH33ef/iaNHjQf7ssuA5s0jW2qN5d8WLwamTUs/dJ1ednrbq1UzPGUiIAIiIAIiIAIiIAIiEIiAbdog0Hzj4XcJ9HjY5SRrtO0QsvZ58eIAa6GfPh3eZrz2mqkD3qoVMGWKs77oGaeHfM4coFEjZ89EshUF9w8/mCR1TZqkPTK97PS2Mxv9ypWRnKHGEgEREAEREAEREAERiFYCtmmDaOXo5rwl0N2kGQV92XYIt2wxnumcOYHjx8MDyFrgLIfGWuAVKjjrq3x5YONG46WuVcvZM5FsRcH9yy/AggXArbemPTLnT2/75ZcD69dHcoYaSwREQAREQAREQAREIFoJ2KYNopWjm/OWQHeTZhT0Zdsh/P13oGxZIE8e4PDhyAOkmOe98p9/Bq65Ju3x//jDCOVSpYyXOlJGwf3rr4E/INDLTm97yZLA5s2Rmp3GEQEREAEREAEREAERiGYCtmmDaGbp1twl0N0iGSX92HYIN2wArrgCKFAA+PvvyEPMlQs4cQLYtMl48tOy7t2BV14BnnrK1FqPlPHOOwU379RffXXao/LjAT8cXHwxsGtXpGancURABERABERABERABKKZgG3aIJpZujV3CXS3SEZJP7YdQtbvrlgRKFQI2L07PIgUsryLfdFFALOzB7J//kmsu75vH3DBBWk/4bvf3rIlMH16oJ4j/zsT2f34I5A7t8k4LxMBERABERABERABERCBQARs0waB5hsPv0ugx8MuJ1mjbYeQoeXXXgsULQrs3BneZsyYAVBA16gBLF0auC96zh9/3ITWM6kcE9WlZUwixyRt110H/PRT4L7VQgREQAREQAREQAREQARsJ2CbNrCdVyTmJ4EeCcoWjWHbIfTVGL/0UmDr1vBAzZ0LNG4MVKlivMlu2urVJsS8YEFg/343e1ZfIiACIiACIiACIiACIpAxBGzTBhlDwa5RJdDt2g/PZ2PbIeR96YkTgfPPBzp1Cm/5XpYaO3IEyJvXzO/QocR/D2/G6T997py5F58tm6ltnl4IPsP1x44FTp4EOnc2deVlIiACIiACIiACIiACIpAeAdu0gXYLkECPs7cglg/hokVAnTqmxNratYE3lnXX+YcfBzJlCtz+wguN93zVKnNv3mvj3LJnN6McPAjky5f2iBTmLFUXyQ8IXq9f/YuACIiACIiACIiACHhLIJa1gbfkvOtdAt07tlb2HMuH8NtvgZtuAsqUMfXQA9mnnwKNGpmkaixTFsiuvx5YvhyYNcvcR/faeDfeJ8opwH1i3d+49LZnzmx+YbI9Jt2TiYAIiIAIiIAIiIAIiEB6BGJZG0TrzkugR+vOhThv2w4hPcMU06yDzprf4ZjvPnuJEsCWLYF7mjwZaN0auOUW4MsvA7efPRtgKDmT0LGcmde2Zw9QuLAZ5d9/A3v5c+QATp0yd/l5p18mAiIgAiIgAiIgAiIgAhLo0fUOSKBH136FPVvbBPr8+cAddwCVKxvvdDjmqwVepAjw55+Be3r7baBjR4C1xpkB3jbbtg3gxwZ6zulBD2T585v78b/+CpQrF6i1fhcBERABERABERABEYh3ArZpg3jfD65fAj3O3gLbDqGvfJnTMPP0vwACX39t7pTXqxd4Y4cPB3r1Ah54AHjvvcDtI91i40agfHkT5s5Ig0BGbzu97vxQwYzzMhEQAREQAREQAREQARFI//+fDyNfvnw4dOgQ8voyIgtZhhKQQM9Q/JEf3DaB/sknQIsWzmuXu0nsueeAIUNM1vPXXgvcM73TX30FHD0KtGkTuH24LXyl3Si8//orcG/0ttPrzvv0/OAhEwEREAEREAEREAEREAEJ9Oh6ByTQo2u/wp6tbQL9o4+Au+8GatcGmIU9kkZh/sYbwH/+Azz/fOCR160DrrwSYCj5gQOB24fbgpno77nHlFdbvDhwb/S20+vOtrVqBW6vFiIgAiIgAiIgAiIgAvFNwDZtEN+7YVYvgR5nb4Fth3DKFOC++4C6dYEvvghvM3hPe/p0UzrrYVU2AAAgAElEQVTtwQcDJ1Vr2xaYMAFgqPvTTwce+9gxIHdu044CnUI9kPXuDSxdajK/FygQqHV4v/MDB9fObPMFC4bXl54WAREQAREQAREQARGIfQK2aYPYJx54hRLogRnFVAvbDiEFMoXybbcBn30WHmrWKGetchqzrZ93Xvr9vf668dpTzLPcmhNj+bK9e4GVK4FKldJ/4uzZxDnwAwA/BMhEQAREQAREQAREQAREwBYCtmkDW7hk5Dwk0DOSfgaMbdshHD8eaN8eaNgQmDs3PCBHjgC+3BbHjwM5c4bXn7+nebeb5dx4d75Zs/T7ZzZ1X+k4lj3btAnIksX9OalHERABERABERABERABEQiFgG3aIJQ1xNozEuixtqMB1mPbIVyxwoR/ly0L3H9/eJvBGuCsBU5j1nNmP3fbeF+e9+ZfeQV48sn0e//wQ3OHnEYP/bhxwEUXOZ/RvHlAjx5A9erA2LGBn2Mtd34EqFkz/JrygUdTCxEQAREQAREQAREQgWgnYJs2iHaebsxfAt0NilHURywfwn//TfRQs9xYIDF84oQR9JkyOd/Anj2BESOALl2AkSPTf47J5wYPNiJ96lTnY/ha+sL/b70VWLAg8PNNmwKzZwNjxgCPPBK4vVqIgAiIgAiIgAiIgAjEN4FY1gbRurMS6BbtXP/+/TFgwIBkMypcuDD++l+NrXPnziX8PmbMGBw4cABVq1bFqFGjcCVTizu0WD+EvHfOu987dgDFiqUPheXLeG+ddcOdInzrLaBTJ6BJE+P5T8+GDTNe865dzTPB2jvvAB06OBuLffNDAL32LBnHDPUyERABERABERABERABEUiPQKxrg2jcfQl0i3aNAn369On4Ikk68yxZsuCi/7mChw0bhsGDB+O9995DuXLlMGjQICxZsgS//vor8uTJ42glth1CJlyjt5tZx4sUcbSEdBvlygXQM755M1CyZPr98Y46M79v2QKwhrgTYwg5w/KvuMK5qPf1u3UrsGoV0Lixk5EAJrGjp55h9dOmBX7mgQeADz4wHn6GxstEQAREQAREQAREQAREQAI9ut4BCXSL9osCfebMmfj5559TzYre86JFi+LJJ59Er169En4/deoU6GGncH/00UcdrcQ2gc7M5lxOu3YAE8aFa7x3fvgwwARt5cql3RvLkWXPbn7/+2/vS6BxS6+7Djj/fGDnTsDJ9xQKbYbUt2ljhHcgo7edXnfWdGd4vUwEREAEREAEREAEREAEJNCj6x2QQLdovyjQR4wYgXz58iF79uwJIexDhgxBqVKlsGnTJpQuXRorVqzAtdde+/+zbtq0KfLnz4/333/f0UpsE+i8o00x+fDDRlyGa6yDTuO9bV9Gd3997tuXeEf9zBn3s6vzA0DWrIn323k/vkIF8+Fg1ChnIe+DBgF9+pj75LxXHsjobafX/bnnAD4rEwEREAEREAEREAEREAEJ9Oh6ByTQLdqv+fPn4/jx4wnh67t3704IYd+wYQPWrl2bEMZeo0YN7Ny5M8GT7rMOHTpg69atWJBGFjF62fnHZxToxYsXx6FDh5A3PQUbIS68ct+/P/DYYwDvd0fK/vgDKFPGeLSPHg1uVKJevx5o0QJg+TR/9sYbRihzXbyLTvOFrDM8fu3awMnpfEnmeJ+c98oDmS+B3VNPAS++GKi1fhcBERABERABERABEYh3ArY57+J9P7h+CXSL34Jjx44leM179uyJatWqJQj0P//8E0WSXNZ+5JFHsH37dnz22Wd+V+Iv8Rwb2iLQ6SGmt/eJJ4yAjZStXAlUrmzuvf/5Z3CjVqsG/PAD8PHHRqT7M1+4eVJvNkPvmbiOHwSYZqBu3fTHpbDnR4uHHjKe9EDWt68Jb480y0Dz0u8iIAIiIAIiIAIiIAJ2EpBAt29fJNDt25NkM6pfvz7KlCmDp59+OqQQd9s96M8+C7zwgqkpztri4RqFL++U164NMEt7WrZ4MXDzzUD58sCGDcGN2qqVSdr20ktA9+7+n/WJeLZjkjefUTwzxL1ZM+CTT4IbN1BreuUZQs+a8hUrBmqt30VABERABERABERABOKdgAS6fW+ABLp9e/L/M6K4pgedYex9+vRJCG3v1q1bgkeddvr0aRQqVCiqk8Q9/bQJx2bWcSZFC9coTNesCeyhZtI2epvpQWc4ejDm+6iQVug5y7zx9sDx4yYU/vLLE3vnf/MueubMADPCO80eH8z81FYEREAEREAEREAEREAEnBCQQHdCKbJtJNAjyzvd0Xr06IHGjRvj0ksvxZ49exLuoC9evBirV69GiRIlEoT40KFDMX78eJQtWzYhgdyiRYuiusxat27Aq68CzzwDDB0a/mYwUzrLoM2fDzRoEH5//noYPdrcLW/UCJgzJ3WL334zGeRz5DDh7FmyJG9Tr54JkZ84EWja1Js5qlcREAEREAEREAEREAERCERAAj0Qocj/LoEeeeZpjtiqVauEuub79u1LqH3Oe+fPP/88KtDlCoCl1gYMGIDRo0fjwIEDCVneR40ahauuusrxKmw7hLNnA998A9SpA9xxh+NlpNnQF1o+axbQpEn4/fnrgUniKP6JffXq1C14N/3OO4HrrweWLUv9OxPUsbR9oBx9jCpYssR8vEjrrnvS3lnP/b//NX3zI4BMBERABERABERABERABNIjYJs20G4pSVzcvQOxfghr1TKC/6OPjEhOy3yl1TJlCv4V2LjR3F3PndvUXE/Zhy9ZW/v2wLvvBt+/74nGjYG5c4GxY02iuEA2aRJw//1GnH/+eaDW+l0EREAEREAEREAERCDeCcS6NojG/ZUHPRp3LYw5x/ohpDj98ktg8mTg3nvTBtW7NzB8OMA78MGG1p88CeTMafreuxe48MLk4zB0fcoUkxzugQfSnsO5cyYcn9nk/X0oqF/f3KVnf61bB950n+e+Zk3jeZeJgAiIgAiIgAiIgAiIQHoEYl0bROPuS6BH466FMWfbDuGePcCJE0DBgkCePGEs7H+P3n47wIpz772Xvjh+/HHgzTcBertZiz1YYwg9S6Zdcw2QNWuwTwP//gvUqAF8/725j37DDan78EUDTJ8OtGwZeIxPPzX34qtUAX78MXB7tRABERABERABERABEYhvArZpg/jeDbN6CfQ4ewtsO4Rt2hgPcXoly4LZIiZd4732MWOARx5J+0nfuMwg/9RTwYzgXtu77gIovgcO9F/nnKKdd9gZ5t6wYeBxGTnACAJmsl+1KnD7SLXgxwhmrZeJgAiIgAiIgAiIgAjYRcA2bWAXnYyZjQR6xnDPsFFtO4QMQ586FRg5EujSJXwsvHu9cydQvbrJpJ6WORXywc7o4EHg1Kn0a7D7+qQHn578W24xYfkp7eqrTRI6rslJ0rdvvwVuusnUQec9eRuMdd/5EYJl7S6+2IYZaQ4iIAIiIAIiIAIiIAI+ArZpA+2MPOhx9w7YdgiZyI13p0eNAjp1itx2MGv8okXAtGnmrniwtm4dsHAhcMklyZPRvfWWWUerVuYeenrGPq680txnP3AAyJ49eWt+YGDJNia9o/AOZMuXm8zxxYsD27YFah2Z3313692qcx+ZWWsUERABERABERABEYgPArZpg/ignv4q5UGPs7fAtkPYrBnA+9ysLd6hQ+Q2g4nZVq4MvV76O++Y+bI0HO9++4z10bkWJ3XdmSSucGGTaM6fCGeI+6ZN5kMA5xvI1qwx4e0ss8a7/TaYT6D/8gvAiACndvYs8PvvJgoilEz7TsdROxEQAREQAREQARGIZwK2aYN43gvf2iXQ4+wtsO0QMqkZBe64ccCDD4a/GfRKb94MlCljSqGlZfyd9cgZFs5w+GCN2dWZZZ0l6teuTXyafbEWeaAs8r4n6L1nSbhBg4Dnngt2FsnbHzpkPnYw2V7z5uH15dbTjAo4fdp49OnZd2pduwKvvRY4l4DT/tROBERABERABERABEQgNQHbtIH2SCHucfcO2HYIGzQAFiwAPvgAYOK2cI13nhkuHyg7Oz8GbN9uvN2lSwc/Kr27vOudKxdw9Kjx8jIZWr585r8p2ineAxnnyjnHYu1y3sXPkcMQ4N18snFqPq95oULA7t1On1I7ERABERABERABERCBYAjYpg2CmXustpUHPVZ3No112XYIndYtd7pN3boBr77qLMTcaZ/+2lF88u44w9QZTs6wcoajU+xnywYcOwacd17gEXjHnMni6I1nuHwsGUP3KbBpDz0EjB3rfHU+gV6pkrmKIBMBERABERABERABEXCfgG3awP0VRl+PEujRt2dhzdi2Q8gw5g0bgPbtTYKzcK1XL2D4cKB7d1O6zUtjgjhmjPfVMf/kE6BFC+Daa4EVK8IbmXewa9Y0Hmj268T7zGfmzTNZ5JmlPpT67OHNOvnTvELAqwQ+O3zYWa37EydMZALtr7+cZcR3c97qSwREQAREQAREQATihYBt2iBeuKe3Tgn0OHsLYv0Q9ulj7nMzbPz11/1vLr3etHCTjzGzOu+w+zLBDxgA9O8PPPAA8N574b1Yx48D559v+nAqbP/5x3jvaX//DRQoEN4cwn2akQX8ADN4sOmJnnB6xAOZL9kdP0owu324+xRoPP0uAiIgAiIgAiIgAvFKINa1QTTuqwR6NO5aGHOO9UM4cCDQrx/w6KPA22/7B8X741dcARQrBmzZEjrM++8HJk0Chg0DevY0tcxnzzaeb5aPc2onT5rEckykRnFPozAtWND8O5OsOfGG88MDw+p5F/7PP4EiRZzOwNt2N94IfP898OGHwF13BR6LZffIj1nsGZ0gEwEREAEREAEREAER8IZArGsDb6h526sEurd8revdtkO4f39icjWf9zccaCNGGLF8770mk7o/Y/j5ddcZgb5jR+ij0dPLcGwmi8ufP/R+Vq0CrrnGeMwpzCnGd+0CihYFMmcGzpxx7kVmH/S+8z78ZZeFPic3n2zbFpgwARgyBHj22cA9M0SfIp2e9yZNgKFDAz+jFiIgAiIgAiIgAiIgAsETsE0bBL+C2HtCAj329jTdFdl2CClMKVBZ65uJ0sI1erB5/5o1t1l72599/TVwyy2pS6SFO3aoz9PjzSRzDEunJ71aNVMqrlQpcxebCeec2gUXmH5Ybo5RAhlpnAc/wDBT/ciRJs/Au+86m5GvjN1VVwGrVzt7Rq1EQAREQAREQAREQASCI2CbNghu9rHZWgI9Nvc1zVXZdgivvNKIya++AurUCX8zWJLr/feBypVN6TJ/xlrhzZoZIUxB7IbR401RXbGis0RoKcdkcjkmg6O3+JlngPXrzQcEhrlT5Do1RgUwvJ1RAkxWl5H21ltAp06JM2Do/5IlzmbE0HbuT4kS4V1DcDaaWomACIiACIiACIhAfBKwTRvE5y4kX7UEepy9BbYdwvLlgY0bjXCjgIuEMdyaYde33mpqsIdqDG8fM8bcHWeYe8eOofdJD/OTTwK33QZ89plJqMaPDAxzZ6Z4p0avOz8UfPcdwLvfGWm8m8+PDfSC8zpA8eKGVSBjgj9GDTDRXrAfKAL1rd9FQAREQAREQAREQAQSCdimDbQ3gAR6nL0Fth1C1g3nfelICkqGXFMEMhHZRx+F/gIweRtroTNEnR7wGTOAp582Zd6CNYbjM8N57twmRJ3/zQgAJnqjN92p0evO9m5FJDgd11+7554z984fe8xwufTSwLXh9+0z4f4+4318cpaJgAiIgAiIgAiIgAi4T8A2beD+CqOvRwn06NuzsGZs2yFkCDO9qj/+CFSpEtbS/v9h1s7+5hsjdm+/PXWfFI0Ujw89BIwdG96YFJ3btxvhyWRuEycCrVsH3ydF/oUXmiRxzHhetWrwffAJZko/ehRo0MB43zPSOncG3ngDYOk7Ztd3YvxQU6OG2Tuug8Ys99mzO3labURABERABERABERABIIhYJs2CGbusdpWAj1WdzaNddl2CH13pp3WyHayXePHm4RkTATH0mcp7YMPTPh048ZAt25Oeky7Te3aye9VM+Ed76GHYrwXz/vxzETfo0coPdj1DEvGkXUw6/HtHbkuXmzWQ686k9/JREAEREAEREAEREAE3CVgmzZwd3XR2ZsEenTuW8iztu0QFi4M7NljMnXzrrIb5iujxvvLFHeZMrnRq/8+fCKUvzIcm3enndQs99cb5825MgN9lizezTlSPTdvDsycCYwebaIDWDqNnv02bdKeAcuwvfCCSS43bpzxnvNOfcmSkZq1xhEBERABERABERCB+CFgmzaIH/Jpr1QCPc7eAtsOYZcuwMGDJns5veluGEUdQ6TPnjXh55dc4kav/vvo1y8xfJsl437+2Z2xeIecQpVh/6wH7tR4d51Z3HkXndcHMtLq1jV34adMAX79FejfP/C1Al82eybNa9XK1IZnqTkvP7JkJCONLQIiIAIiIAIiIAIZScA2bZCRLGwZWwLdlp2I0Dzi5RAyzJyZw+fOBRo29A6uLySbIzAzPEu8uWHsp107c4d+3jznPfoELkucMTlbRhrnwBJ6Dz9s9uL++4FatRJD1/3NzVd2b/58422XiYAIiIAIiIAIiIAIeEcgXrSBdwTd71kC3X2mVvcYL4eQYnDSJGDQIJMQLqkxOzo93RTB4Yr3RYsS67ezZBtLt4Vj9Djz3jYzsTNxHu+lsz66U7vvPuOxfuUVU7bNFuNamPguvbJxTJRHb/mpUyaz/2WX2TJ7zUMEREAEREAEREAEYpNAvGiDaNo9CfRo2i0X5mrbITxyxGRAz5HD3TDmF180pb3uustkNk9qLGfGUHDWG2fd8XCM86eYpphMWh4s1D5ffhl46qnEpxnmTcHt1Jgcj159hsf36uX0Ke/bsXScL9Ebs7MzdN2f8bfffzeJ9pgBnh9SHn0UqFbN+zlqBBEQAREQAREQARGINwK2aYN44+9vvRLocfYW2HYIM2cGzp0DWBqNCePcss8/N97ssmWBjRuT91qqlEk8Fsna607X5Utw52vPMHcKbqfG5GoMLed9b96Pz0ij0M6Tx3y44D5ToPtqvDMRXiC74w6Aoe5cPznIREAEREAEREAEREAE3CVgmzZwd3XR2ZsEenTuW8iztukQMqTZl63c7VJahw4BX3wB0FteunRyXD6huHatSaZmkzGxHefH+dN4j5yC26mxbNyrrwLPPGMS72WU/fMPkC2bGd23twxxZ6g7s7nzrnwgu/tu4KOPgNdeA1hTXSYCIiACIiACIiACIuAuAZu0gbsri97eJNCjd+9CmrlNh/D0aSB7drMMZnLPly+kJQX1EL31FI5nznif4T2oiSVpzPrsTG5H4z1y3id3ar4yZcE+57R/p+2ShrTzTjmZMy/A1KnA668DHTum7olCnEnl2O6mm0zGd5ZaYxb73r2djqx2IiACIiACIiACIiACTgnYpA2czjnW20mgx/oOp1ifTYfw+PHEu8jp3Ut2c4tOnDCJyGiHD5sQbNvMd3+e8+I9ct4nd2oDBpjw9mA97077d9puyxZzL5+5BcicduCAKX+XVp14Ju/78svEkHZ+ZGC5tYyOBnC6ZrUTAREQAREQAREQgWgjYJM2iDZ2Xs1XAt0rspb2a9MhZBh3/vwGFGuX+7zpbqFj8jZmQOfddnpjabt3AxdfbBLS0YvOu9G22U8/mfrnjChgeDiT6Dm1H34A+Id3vG++2elT7rdbtQpgXfhChQxzJ1a8OLBjR2JugD59TBb+xx83CeNkIiACIiACIiACIiAC7hKwSRu4u7Lo7U0CPXr3LqSZ23QI9+8HLrzQLINi2XcfPaSF+XmI2c9ZduzGG43oo+3aBbRuDfCu9+LFbo3kbj9kQS4UrMw0X6yYu/1HorelS4GaNYEyZYDffgs84rFjxrtO43tRsCAwfLiJIHCzvnzgmaiFCIiACIiACIiACMQPAZu0QfxQT3+lEuhx9ibYdAiTerOZMM5towedSeBY0ovh7DZ6y9NaM0P+fYLVbS6R6G/ePFNjvnJlYPlyMyJzDjCSgdndGcruu2rA31hO7dprTYI8Rg3QmByPWembNwdmzIjErDWGCIiACIiACIiACMQXAZu0QXyRT3u1Euhx9ibYdAh5J5nJwijOU9Yqd2Nb6InmHXOGz7PUGkuuxbrxXj9rvPOfdetm3GqZDO7ee02Y/ddfJ86DnnHuO0PgWevcZ9z/e+4BqlcHvv3W/C0/qvBDBUP906qbnnEr1MgiIAIiIAIiIAIiEP0EbNIG0U/TnRVIoLvDMWp6ibdDyLvcvNPNcl133hk12xTyRH2e6GDufoc8WDoPspzaBx+YEncs/eazG24Ali0zHnF6xn32/PNA376m3nkwdd+9mLv6FAEREAEREAEREIF4IRBv2iAa9lUCPRp2ycU5xtshfPhh4N13geeeMwnHJk0CunYFWMosFoVg0msDDCkPJsGci69Zml0xJwBzA/B++dNPJzZjKDtD2lm7nVnbQzXWX+dVBrfzGYQ6Hz0nAiIgAiIgAiIgAjYTiDdtYPNe+OYmgR4Nu+TiHG06hKxJzvB2L8UUa2536QI0agTMmQOw1jYF+t13A9OmuQjWkq7IkzXHmQSPGdFtSzDXrx8wcCDwyCPAmDHJoTGknfP3ZfbfudMIea5nxAhngN9+21yb4IcAfoyRiYAIiIAIiIAIiIAIpE3AJm2gfTIEJNDj7E2w6RCuXQtcdVVwpbiC3a5vvgFq1QJKlQL++MN40Vm+i571d94JtrfoaE9R/uefJpT8+uszZs7MxE6xzfvjFNg+mzDBZGWvUwf46qv05+ZL8legAPD3387WwZrxzz4LPPggMG6cs2fUSgREQAREQAREQATilYBN2iBe9yDluiXQ4+xNsOkQMplZpUpAkSJGUHphJ06YBHFXXGGEYs+exhv71FPAiy96MWLG90lRzszps2ebUP6MsPbtzRWClCHr339vyt5dcgmwfXv6M2MEAEvNMUyf4fqsXR/IGB4/bBjw5JPAK68Eaq3fRUAEREAEREAERCC+CdikDeJ7JxJXL4EeZ2+CTYeQIpJikiJs27bIbMRjjwGjRwMDBpikZLFoFOVz55p1duiQMStkQr6PPwZGjTKl0nzGEmqFCwMlSwIbNgBZswJMKMccAaybnnRPDh1KDHfnh5YcOQKvhYnnZs407ejBdyLqA/eqFiIgAiIgAiIgAiIQmwRs0gaxSTj4VUmgB88sqp+w6RD+8ANQrRpw2WXApk2RwcrSXywBRu8qvayxaLzfPXZsxn6EuPVW4PPPAYa0339/ImXmHaA3PHv2xL/jXDnnBg2A+fMT/5736H1J7vbsAS66KPBuNW1qIgdoFPh58wZ+Ri1EQAREQAREQAREIF4J2KQN4nUPUq5bAj3O3gSbDiHrXd90k6lPzjB0r4wfApiQrEQJgP8+b565n8x7yrFoX3wBrFsH1KgBXHddxqyQH17IetYsoEmT9OfAbO68bsBkfiNHJm/L+ues6c78AcwjEMgo8hcsMK02bzaeepkIiIAIiIAIiIAIiIB/AjZpA+2RISCBHmdvgk2HcPFi4Oabzf1wCkqvjCHPDH3mfXeGUfPDwJAhwG23eTWi+q1QAWCSt6+/Nnucnvm83inD4fnMxRcDLB3H+u7XXBOYq+/DAFv+9FPGfaAIPFO1EAEREAEREAEREIGMJ2CTNsh4GnbMQALdjn2I2CxsOoT09NavD1SsCKxa5R0CelLpfWWSuCNHkmcV927U+O6ZSeBYJo15BipXTs5ixgzg5ZdN9ASzrl9+OfDrryYkvl695G3LlDHec2bjZ/tA1r17YnK4hQvN+yUTAREQAREQAREQARHwT8AmbaA9MgQk0OPsTbDpEK5YYZKCMQz5jTe82wjee2ZtbdbZZub4q6/2biwbej55EiDbgweBO+7ImBnlyQMcPQr89htAkZ3UPvgAeOAB4JZbTDh6zpzAmTMmUSATBia1LVtMIrlChcw/nRg99ozOmDIFaNXKyRNqIwIiIAIiIAIiIALxScAmbRCfO5B61RLocfYmxOshZC10emEpDtu0ie1Np9DlfXtGDFCsRzqTOT+IdO5sPojwTjnrmCe1774z9+Mpxr/8EihXzoh0CvrMmcPfm5YtAXrp/YXMh9+7ehABERABERABERCB2CEQr9rA5h2UQLd5dzyYW7weQgpGn5ee4e6sx+0kK7gHW+B5l0mzpLOs2QUXeD5kUAPs3Ws84jRec6CXu1gxc888HOOHAZZWY36BRYtMeTeKdZkIiIAIiIAIiIAIiIB/AvGqDWx+HyTQbd4dD+YWr4fQV8rLh5R30XPn9gCwJV1eeCGwfz+wejVw1VWWTOp/00h65WDtWoAJ5VjnnF70lPbRRwA97o0aAXXrpr+Ov/4CihQx1xm4dje88XaR02xEQAREQAREQAREwF0C8aoN3KXobm8S6O7ytL43mw7htGlAu3ZGeM2d6y26ZcuAG24wY1C48c5zpEO/vV1h8t6ZeG/NGiAjEqXRg++rQZ603nnSGV5/vUkgxwz7zOKelvlqug8aBDz3XPoEN2wwFQEo0A8ciCRtjSUCIiACIiACIiAC0UnAJm0QnQTdn7UEuvtMre7RpkM4YQLQti1w662Jtau9gkdBvnKlEenxIOCYvZzh4++/bxiHY/R4d+gA5MqVuk65v355feDGG03mfGZg92cMa+cHGtY/f+qptGfny8req5fJ+J6e+cZl0kFm7ue8Y/kjTDh7qmdFQAREQAREQAREgARs0gbaEUNAAj3O3gSbDuH48UD79ibT+Kefer8RP/4IVK0KXHopsHWr9+Nl5AgU5fwAQlFLcRuOMRu8L9EbE78xQ3t6Rq89a8yz7jw/ivizfv2A994zmdsbNADGjEmdwZ3Psd3AgeY+OZO+pWeffQbcfrtpwXv3LN+2dGk4K9ezIiACIiACIiACIhDbBGzSBrFN2vnqJNCds4qJljYdwnfeMcWizoMAACAASURBVJ7ZJk2AWbO8x8s62/TWe1133fuVBB6Bonz4cKBrV+DVVwO3T68FPdH0njMjPD3i9IynZ9OnA3fdBTBzPsud+TP2yaztefOaXxmSzsiGlDZiBNCzp8m8zwz86Rk98vTM8woDk8WVLQts3Bje2vW0CIiACIiACIiACMQyAZu0QSxzDmZtEujB0IqBtjYdwrfeMp7RFi2Ajz/2Hm7STO4UiLFs335raqFXqQJUqxb+Shl1sH27yX7PKIT0bNw44KGHTGK3OXPSbsk76LyLzozuu3f7b/f220DHjkCzZsAnn6Q/7ujRwGOPGWHO+uv0ojOLvUwEREAEREAEREAERMA/AZu0gfbIEJBAj7M3waZD+PrrQJcuwN13m/vIXtu6dUas8s4zQ6dlzgjQ003RyyzpFNwU3ukZPfbdugH33QdMmpR2y8mTgdatgZo1gSVL/Lfj8/ffbxIJ8k59ejZsGPDMMya8fsEC40n/5x9lc3e2y2olAiIgAiIgAiIQjwRs0gbxyN/fmiXQ4+xNsOkQvvIKwCRggYScm1t09iyQJYubPcZ+Xz6RzJXSO/7gg+mvmXfG+QGE3mxGSaRlvgRu1asD9Pj7s9mzTZZ3Jvf74Yf0x6XgZ1K8W24xQp3299+J9+djf6e0QhEQAREQAREQAREIjoBN2iC4mcduawn02N1bvyuz6RB++CHAEGZ6RwOV0IqzbQp7ufQcMykeQ8d5hSAce+MNgNcDaE6SzvXoAbz0krk7Tq92IIHOJHHz5/tvxaR0O3ea++msce7UWOP+2DHg99+B0qWdPqV2IiACIiACIiACIhBfBGzSBvFFPp3/Rz53LtZv42qrkxLQIYyP94Fh6b5s60eOABSsodrzzwN9+5qneT2ApdHSM3qy580zyf94fSEtY21zJrJjpvWrrw51dv6fK1HCZIin153ed5kIiIAIiIAIiIAIiEBqAtIG9r0V8qDbtyeezkiH0FO8VnXu8yIzkznvkIdqvlrkfP7rr4Gbbw61p9TPuXnlIGnd83vvBfbuNR8TWO5NJgIiIAIiIAIiIAIiIIEeDe+ABHo07JKLc5RAdxGm5V1RlDPEm6XOWPIsVOOdc9YsHzo08W53qH0F+xzD1OllZ0QAxbbv3rq/fmrUANauNQkHmShOJgIiIAIiIAIiIAIikD4BaQP73hAJdPv2xNMZ2XQIGTo9cqQpo8V/l7lLgKL8m2+AqVOBe+4JvW+WOGOdeuYLePTRwP3w3niOHEC2bIHbBmrB8HxfrfTjx4GcOdN+4oorgA0b3PfyB5qjfhcBERABERABERCBaCVgkzaIVoZuz1sC3W2ilvdn0yFkErERI5zda7Ycq5XToyhnIj6WPevaNfQp1q5tyqD95z/GM33TTen3VbEisGYN8PnnQL16oY/LJ//9NzHrPhPesWZ6WsYkciwFt3KlwtrDo66nRUAEREAEREAE4oWATdogXpgHWqcEeiBCMfa7TYfQd7e5Vy+THVzmLgGK8tdeA8Lly9DyuXNNqDw92PRkp2duJ2hzmpGdczt5Eti8GZgxAxg8GGjTxnygkImACIiACIiACIiACKQmYJM20P4YAhLocfYm2HQIu3QBXn/deGYV4u7+i8iPHs8+C7Rta+qDh2NJQ815H/z889PurUAB4OBBYP164PLLwxnVPOvEM05h7gt/P3DA1Gtnxvn77gNYx10mAiIgAiIgAiIgAiIggR4N74AEejTskotztEmgd+oEvPUW0L8/0K+fi4tUVwkEGOr93XfANdcEDksPhIwZ0nPlSvRQlyzp/wm2O+88E5rO+uVFiwbqOfDv5coBv/1mwuxr1vTfnuHvF19sksidOQNMmAC0a2dC8j/7LPAYaiECIiACIiACIiAC8UjAJm0Qj/z9rVkCPc7eBJsOYYcOwDvvAKyH/dxzcbYRUbJcCu1duwB6xekN3749/drizLruq7kebv11H6LrrgNWrAA+/RS44w7/4H791cwvXz7jvZ8zx9Rhr1IF+PHHKIGtaYqACIiACIiACIhAhAnYpA0ivHRrh5NAt3ZrvJmYTYewfXtg/Hhz/5z3pGX2EdizByhc2MyLnvhffjH30Rs29D9Xinl6zenJZo3z9MqiOV0t667z/nt62ehZTu7xx032eGacZ+QAy66VKgX88YfTkdROBERABERABERABOKLgE3aIL7Ip71aCXRL34ShQ4eid+/e6Nq1K179X5ardu3a4f0Ul4mrVq2K77//3vEqbDqEvHdOT2fnziaZl8xdAvR+U6hSNLNUWtaswffv80yz1NmNNwILFpiPKgwf92cpPdnBj5j6CfbJsPVLLwXy5HHWI8utsexa/vwA76TLREAEREAEREAEREAEUhOwSRtofwwBCXQL34Rly5bh7rvvRt68eVGnTp1kAn337t0YT4X0P8uWLRsKFizoeBU6hI5RRX1D3gfPnh345x9g61YjcIM1fvuhMGdmdtZV593uYcMAlsjzZxyH1xX4MSDJaxrssGG337s3sSQb18978TIREAEREAEREAEREIHkBKQN7HsjJNAt25OjR4+icuXKePPNNzFo0CBUqlQpmUA/ePAgZs6cGfKsdQhDRheVD1KUB7o3nt7C5s83974rVTLJ/NauBerWBapWtRsHPe433ADw29Unnzj3vNu9Ks1OBERABERABERABNwlIG3gLk83epNAd4Oii3088MADCR7xV155BTfffHMqgU5xTq95/vz5Ubt2bQwePBiFChVKcwanTp0C//iMh7B48eI4dOhQgodeFtsEKKSZJI3fdJo2DX6tkycDrVsDdeoAX30V/PNuPMH7519/DVx/PdCokf8eWaudyQaZ1+Dll90YVX2IgAiIgAiIgAiIQOwTkEC3b48l0C3ak6lTpyYIboa458iRI5VAnzZtGnLnzo0SJUpg8+bN6NOnD86cOYPly5cjO2OZ/Vj//v0xYMCAVL/YINAfeMAIL4qru++2aCNiaCq8e86kaSxn99hjwS9s1CjgiSeAFi2Ajz8O/Pzp0yYxXCj33dPqnZ57vsIdOwJvvum/Ve/ewNChQJcuwMiRgeepFiIgAiIgAiIgAiIgAoAEun1vgQS6JXuyfft2XH/99Vi4cCGuYbpsIJVATznVXbt2JYh1CvsWVFB+zGYP+u23mxrV770HUKzL3CdAUT56NNC3rxG5wRq90n36AA89BLz+uqlHfvKkCR/3Z2xDkXzffcCkScGO5r/9Sy8BPXoA999v7sD7s06dzEeIUNfpzkzViwiIgAiIgAiIgAhEFwEJdPv2SwLdkj1h6Hrz5s2RJUuW/5/R2bNnkSlTJmTOnDkhTD3pb75GZcuWxcMPP4xeDuuU2XQI69cHvvgCmDjRhFHL3CdAUU4PNGvOU6gHa7NnmzvctWubOuNMGMd77UwG5898gv7hh02NezdszBjg0UdNiH5a6Rf4QWDKFBPe3q2bGZXh7oweYBEEVQlwYyfUhwiIgAiIgAiIQKwRsEkbxBrbUNcjgR4qOZefO3LkCLamUD0PPvggLr/88gTxfdVVV6Uacf/+/ShWrBjGjBmDtm3bOpqRTYeQ95oXLUq/vrWjRalRmgR84rZxY4BiOxxjPfEyZYCcOYHjx/33xOzuI0YA3bsD9Hy7YRTeFOC33AJ8+aX/HpnIjgntxo0DHnzQtPEn2t2Yj/oQAREQAREQAREQgVghYJM2iBWm4a5DAj1cgh4+nzRJHLO78z55y5YtUaRIEWzZsiWhTvq2bduwfv165HFYINqmQ1izJrB0qbnbnEaEvod046Nr1gOnqK1QwSR6C8eOHAF8eQWPHgXOPz91b76Qenrt+/ULZ7TEZ+fOBfiBoUoVk/DOn1WvDvz3v8CMGUDz5qYF787zDj3LvtGzLxMBERABERABERABEUhOwCZtoL0xBCTQLX4Tkgr0EydOoFmzZli5ciVYao0inTXSn3/++YSs7E7NpkPIcGnW2WYYcpMmTlegdpEksG+f8ZjnymVG5b+zKMDmzUDJkqln4oXXmlEW/LjAEPv16/2vnh8g+Bszzfs+RPADwcCB6SeXiyRLjSUCIiACIiACIiACthGwSRvYxiaj5iOBnlHkM2hcmw4hPaI//QR8+qmptS2zjwDzFa5aZZL53XYbwG9BO3YYTzb3L6WxDBr3c+xYk1jODVu+3JRYK1bMjO3PmMPg99+B8eNNtACN2dyffNJUCJg2zY2ZqA8REAEREAEREAERiC0CNmmD2CIb+mok0ENnF5VP2nQI77kHWLsWePtt4KabohJnVEz622+BP/8EmDU/d+7gpsyEcNu3Az/8YDK3V64MrFwJMOy8YcPUfdWqBXzzDfDhh8BddwU3Vlqtjx0zHwny5weuuMJ5n0w+yORw9eoBn3/u/Dm1FAEREAEREAEREIF4IWCTNogX5oHWKYEeiFCM/a5DGGMb6mA5hQoBe/cCP/8M/K+Cn4OnTBOmNuB9840bgbJljRd94ULjqW7XLnU3rEdOMc1yZ2mVYnM8eJgN580zHxGuvRZYsSLMzvS4CIiACIiACIiACMQgAWkD+zZVAt2+PfF0RjqEnuK1snNfmDqznDdo4HyK//wDZMtm2lPgX3ihqW2+bZsRvldf7byvjGjJDxIstXbllWnXT8+IeWlMERABERABERABEbCFgLSBLTuROA8JdPv2xNMZ6RB6itfKzinKFyxIXoLMyUQpyul9p1Gsn3eek6e8acP75IcOmTvlvkzyvpF495x31Hk/fvVqb8ZXryIgAiIgAiIgAiIQiwSkDezbVQl0+/bE0xnpEHqK18rOWRf8vfeAwYMBhqA7NYa1ly9vwtwPH3b2FIV81qzO2gbTiqKcZd5++83UYk9qy5aZcHrel9+6NZhe1VYEREAEREAEREAE4puAtIF9+y+Bbt+eeDojHUJP8VrZOUX50KGmLvjrrzufIhPDVauWXPjyPvoffwDnzgGVKiXvi+XXcuQwpdj++iu1p9v5yKlbMoM7E93xLjnvlCc1JoC79VYTcv/LL+GMomdFQAREQAREQAREIL4ISBvYt98S6Pbtiacz0iH0FK+VnVOUd+kCtGwJTJ/ufIobNgDDhgH58gGvvmqemz0baNrUlFhjqbWkljQk/swZIEsW52MFaska6L/+CixeDDBTfFL76CNTSq1mTWDJkuS/0bPOEHhmsg8mA3yg+eh3ERABERABERABEYgFAtIG9u2iBLp9e+LpjHQIPcVrZecU5Sx5VqMGsHRpeFP8/nvgxhuBEiWALVuS90XPOsPPgwmJdzob3jFnPXR/5d3eeQfo0AFo3Nh8QEhqzDxPgc7Sbyrl55S22omACIiACIiACMQLAWkD+3ZaAt2+PfF0RjqEnuK1snMKaZYco1itXz+8KfpEeK5cAOuTJzXWR2eddIaj79gR3jgpn65TB1i0CJg6FbjnnuS/jhgB9Oxpap5/8EHy36pWNZ7+mTON518mAiIgAiIgAiIgAiKQSEDawL63QQLdvj3xdEY6hJ7ijanOed88UyaAYpz/pDFZHEPeaRTo/M1nDD+/+WYTSr5unbsomjQB5swB6C1/+OHkfT/3HDBkCNC5M/Daa8l/u+MOgOXlxo0DmCxPJgIiIAIiIAIiIAIiIIFu8zsggW7z7ngwNwl0D6DGaJdPPw28+CLAfw4fbhbJ5HBMAseEcPTMM9TdZxTQFNL0WjMU3k1r3RqYPBl4+WWgW7fkPfOO/YQJANt07Zr8N3rVJ04E6GXv0cPNGakvERABERABERABEYh+AtIG9u2hBLp9e+LpjHQIPcVrbecUzNu2AXXrAhdc4Gya9FS/+y4waBBAL7XPWG+cIewMHWeyOJ9NmgTcf78Jo1+40NkYTlutXQscPAiULg1cfLHTp4xgp1f9mWdMJnuZCIiACIiACIiACIhAIgFpA/veBgl0+/bE0xnpEHqK19rOWc+cdc2//tqEoTsxZn2fMQMYNQro1CnxCd4z533zTz8FGELuM5Y7GznSlEF7/nknI3jfZuBAoF8/k0Ru9Gjvx9MIIiACIiACIiACIhBNBKQN7NstCXT79sTTGekQeorX2s4pynlHnGHi997rbJq33GIEfcpnxowB/v7blG1j4jmbjaHvLBHHBHF9+9o8U81NBERABERABERABCJPQNog8swDjSiBHohQjP2uQxhjG+pwORTlzID+0ktA9+7OHqIn/OefTZK1Bg2cPeNVqzVrgC++MHfemzdPPgrLvu3aBUybZu6/y0RABERABERABERABJwRkDZwximSrSTQI0nbgrF0CC3YhAyYAkX5K6+YRGlMmObESpYEtm4F/vtfoFq1wE8wgZwv23vg1sG1SK/WOcu6/fmnqZPO8HuZCIiACIiACIiACIiAMwLSBs44RbKVBHokaVswlg6hBZuQAVPw1QpnpnNmNXdiLKfGsmobNgC8w+4z/t2mTUDWrMCVVyb+fdu2wMcfmw8ASe+sOxkrUBt6/xkFwFB9ht0ntdy5Tck31mgvVSpQT/pdBERABERABERABEQg8f/rDiNfvnw4dOgQ8ubNKzAWEJBAt2ATIjkFCfRI0rZnLIpylhzjvfIvvww8L3rDmcV9/35TQ7xgwcRnxo4FHnkEaNgQmDs38e+bNQNmzTLJ2JiUzU1jQrpGjYDrrweWLUvs+Z9/gGzZzH9zrknnyb+jZ71WLeDkSZN5XiYCIiACIiACIiACIpBIQNrAvrdBAt2+PfF0RjqEnuK1tnOK8nr1gCuuANatC2+aFOEU4yyxxlJrPvMllZsyBWjVKrwxUj69ZAlQu7bx5NOj77N9+4CLLjL/RbF+3nnJnzx0CMif3/zdiRNAjhzuzku9iYAIiIAIiIAIiEA0E5A2sG/3JNDt2xNPZ6RD6CleazvfvduUTOO98ttvD2+avJNevbrpa/PmxL7o3eY98JTl18IbzTzNsm68X160KLBzZ2KPv/9uMsnnyWPC8VMaIwEYin/2rPGg8766TAREQAREQAREQAREwBCQNrDvTZBAt29PPJ2RDqGneGOmc3qjT58GcuVKnfjNJ4rPPx84ejRxyeXKAb/9BnzzDXDTTe6iSEuI//ST8eQXLw5s2+Z/zEKFgL17gVWrgIoV3Z2XehMBERABERABERCBaCYgbWDf7kmg27cnns5Ih9BTvDHT+cKFwG23AdddB1AEJzV6qplAjsbkbBTxtIsvBuip/+UX4Oqr3UXBftk/s8TTG+7LFr9iBfDYYwBFeNL78ElHv/xy4NdfTXI5JpmTiYAIiIAIiIAIiIAIGALSBva9CRLo9u2JpzPSIfQUr9Wd8744Q9Jr1jSh4ukZa4rzHjnvfS9alLwlw8Z5l5se9i1bTG1yGoU673lzDIa/u2n06LMOOkPZGV6fObPz3mvUAL77zmSYb9HC+XNqKQIiIAIiIAIiIAKxTkDawL4dlkC3b088nZEOoad4re78xhuB7783d9GbN09/qm+/DXTsCDRtCsycmbrtJZeYu+DMqM675//+CzRubO6Bz5mTmJjNBiBNmpg5jRljss/LREAEREAEREAEREAEDAFpA/veBAl0+/bE0xnpEHqK1+rO6T3+5BNg1KjAdcqHDgV69wbatQPGj0+9rJdeAs6cAVhXnWLdZuvZ05SWe/pp97PL27xuzU0EREAEREAEREAEAhGQNghEKPK/S6BHnnmGjqhDmKH4M3TwTp2At94C/vMf4Pnn059Kr17A8OFAt27Ayy9n6LT/f/APPwR27QLuvhsoUsT89ZAhxjPOe+jPPGPHPDULERABERABERABEYgWAtIG9u2UBLp9e+LpjHQIPcVrdecU5X37Ag89BIwdm/5UO3QA3nkHGDgQ6NPHjmWxhjtroPNOPO/G0zp3Bt54w9lHBztWoVmIgAiIgAiIgAiIgD0EpA3s2QvfTCTQ7dsTT2ekQ+gpXqs7pyjnHew77jC1ytOzu+4Cpk8HXn8deOKJ1C0PHDAJ4nLnNnXIly41Wd8rVQK+/dYbDDfcYO688z55o0ZmjDZtgIkTgRdfBJ56yptx1asIiIAIiIAIiIAIxCoBaQP7dlYC3b498XRGOoSe4rW68/nzjThnCTSWQkvPKHgpuh9/HKhfP3VLhpY/9xzw4IPAuHHAvHlAw4b+y7K5BaVuXeCrr4DJk4F77zW9MjEdy6vx4wMjA/wZs78zBJ4eeIp7mQiIgAiIgAiIgAiIgCEgbWDfmyCBbt+eeDojHUJP8VrdOcPDKVLPPx84ciSxlngok2b4O8PgKcopkKdONaK5Th0jor2wZs2AWbOA0aPN2DSWjOOHBHr7W7ZMW6DzI8NVVwGrV3sxM/UpAiIgAiIgAiIgAtFJQNrAvn2TQLdvTzydkQ6hp3it7vzUKZNQrXRpoEGD4GqJp1wYhTIFM8POf/jB9Pvoo2mXZXMDjL9w9ooVgTVrTI10etj92cqVQOXKJrHcn3+6MRP1IQIiIAIiIAIiIAKxQUDawL59lEC3b088nZEOoad4Y6bz48eBnDnT9rJ/9x1QowZw2WXApk3AiBEAy5lRRH/wgTcYWJed9dn79QP69zdjFC8O7NiRWI/d38hbtwIlSwLZswMnToQXOeDNytSrCIiACIiACIiACGQMAWmDjOGe3qgS6Pbtiacz0iH0FG9MdH72LHDeeUDWrMDOncBFF6Ve1m+/AeXKmSRxDJdnpvdBg8yddWZV98L4AYAfApgMjnfkaQyp5xwXLDAfC/zZ0aNAnjzmF/47Q/xlIiACIiACIiACIiACuoNu4zsggW7jrng4Jwl0D+FGQdf0djMkvVgxoFYt/xNmhvaCBc1vDIvPli11u0OHgPz5zd/T284a5K+9Bjz7rKlN7oWtW2cyxzNrPP84tXPnjPf8n3+AbduM110mAiIgAiIgAiIgAiIggW7jOyCBbuOueDgnCXQP4UZB177s6+mFolPE8556rlzAsWP+F5VU9DKEnEnaZswwWd3TyqaekXh4//yvvwDeR2cpOJkIiIAIiIAIiIAIiIAEuo3vgAS6jbvi4Zwk0D2EGwVdT5sGtGoFVK+edr3y5cuB6683Xnbe707LBgwAcuQAHn4YuOACuxfPGu379wPMPn/ttXbPVbMTAREQAREQAREQgUgRkDaIFGnn40igO2cVEy11CGNiG0NexE8/AVWqAIULG4+yP2NGdBvLkvFjweefA3nzmpJqq1aZrPHlywOffRYyEj0oAiIgAiIgAiIgAnFLQNrAvq2XQLdvTzydkQ6hp3it7zzp/XImd2OSt5T20UfA3XebGuNLltizpPnzgTvuMCXT6OVnvXWWVrvySlNqTSYCIiACIiACIiACIhAcAWmD4HhForUEeiQoWzSGDqFFm5FBU2ECOAp1eqBZRzyl+WqaN2kCsN55WrZvH7B9u0kod+edpsY476FXrerNwpYuNR8NmCBu40YzFj3pLPfG37w0X3k2hvTLREAEREAEREAERCBWCEgb2LeTEuj27YmnM9Ih9BRvVHTOEHeGun/yCdCsWeopz5sHUKRTaDMre1r25JPAyJFAr17AhAlGoNOzTQ+3F/bzz+b++MUXA7t2AePGmYR0DRsCc+emPyIzzHOurVsDAwcGN7t//zWJ5Zitfu1akxFeJgIiIAIiIAIiIAKxQEDawL5dlEC3b088nZEOoad4o6JzJoljsjjWEmdN8VBt8GDgP/8B2rcHPvzQ1BhnffQyZULtMf3n/vjD9M065hzr5ZfN/Cm6J05M/9kXXjAfG9q1A8aPD25+zFifL5+p986PBNdcE9zzai0CIiACIiACIiACthKQNrBvZyTQ7dsTT2ekQ+gp3qjo/LvvgL//Np7uokVDnzIzonfoYO6F0+tO27MHuOii0PtM70n2zeR2tLNngf79geefBx5/HHjjjfTH9IXtN24MzJ4d/PxuvBH4/nvzIeKuu4J/Xk+IgAiIgAiIgAiIgI0EpA3s2xUJdPv2xNMZ6RB6ijcmOj99GsiaFciUKf3lzJwJNG8OXH45sGGDaXvypHch4LwHztrstMOHgeeeA15/3fxz0KD05/rxx+aefKj31Vnf/b33AJaW69s3JrZZixABERABERABERABSBvY9xJIoNu3J57OSIfQU7wx0TlLrC1eDEyalL63+NtvgZtuMmL+n3+AbNmAU6e8Q8BQc45F7/nOncDo0cCUKUC3bkDHjumP+/XXwC23mI8J69cHN0fflQA+de+9wOTJwT2v1iIgAiIgAiIgAiJgKwFpA/t2RgLdvj3xdEY6hJ7ijYrOz5wBpk8HeKebCd7OOy/5tK+/3iR7Y+I1JmBLy3jfvFy5xF8vvBDYu9dbBPSEM5M6xXbOnM7HYsZ63h0vVAjYvdv5c0nD6vkUk9StWOH8ebUUAREQAREQAREQAZsJSBvYtzsS6Pbtiacz0iH0FG9UdM6s5AwVp7ebIr1UqeTTLl0a2LQJoIe8evW0l3TwIFCggPmd99kpflmr3EbbsQMoXtx8jGAIf6Dwfd8aWGaOme4ZHcDnyI3J4jJntnGVmpMIiIAIiIAIiIAIBEdA2iA4XpFoLYEeCcoWjaFDaNFmZOBUrrjC3BtfuBBgSHtS89VJX7cOYLu0jCHn9MDTc/7EE4n3wzNwWWkOzfvrV15parYvWeJ8rlzf8OEA76AzUzxD+bduBS691MZVak4iIAIiIAIiIAIiEBwBaYPgeEWitQR6JChbNIYOoUWbkYFTadQI+PRT4K23gMceS5wIvev0MlN8s9Y4a47bZIsWGYFcqxZw//2mNvnUqUD58t7MsmZNYOlSU5qNHnj+YYRBlizejKdeRUAEREAEREAERCCSBKQNIknb2VgS6M44xUwrHcKY2cqwFtK1K/Daa0CPHsCIEYldJQ1bp9eZ971tsnr1gC+/NN5sJoZjuPnGjUDZsu7PkiHtrH/OzPSMNvDqI4D7M1ePIiACIiACIiACIuCMgLSBM06RbCWB3Q92bgAAIABJREFUHknaFoylQ2jBJlgwBYpzivQWLQAmXvPZ5s3mTjqFOQV6IGMStd69gXffBZ56CnjxxUBPhPc7y7qxvNuoUab+Oc2r2us//ghUrWrC4vftc35vPbwV6mkREAEREAEREAERiBwBaYPIsXY6kgS6U1Ix0k6HMEY2MsxlMLydYe7MbP7zz4mdbdsGdOlikqDNmBF4kNatE8uOMVSeIfNeWtu2wIQJ5qPAkCFmJCa7YxK3QEaPO+/c8yMChX4gmz0beOghoFo1YM4cE1pPzz0TzHF8mQiIgAiIgAiIgAhEOwFpA/t2UALdvj3xdEY6hJ7ijZrOWQu8QgUgd27g8OHQvcNPPgmMHGmW3bMnMGyYtwjoNX/zTaBNGyPUmVX92DFnY955p4kW+L/2zgTeymn//98KpVlUGggpUZQ03CTEJeOtZO6SEPdyRYbSgEIDmQllqIzFj3KlkowpEmUKGVKacCUpGkj/1+dZ/+ec3e7s2p3Os8969n5/X6/9Oqezn72e73p/13M6n7W+67vuuy9/9X1rn9RefKXRV6xoFq6o16hhtnTp1j7J+xCAAAQgAAEIQMB/AmgD/2KEQPcvJpF6xEMYKd7YNK5V55dfdgXPJNTTPXYsuYMDB5r16+d+evPNZn37Rovg2mvdJMCRR5qpYFzNmmZLlqR3z4suMnvoIbMbbzS77rr0PpN41cqVZpUru59or772p2MQgAAEIAABCEAgzgTQBv5FD4HuX0wi9YiHMFK8sW98wwaX3p6uYB8xwuzii123ta/9ssuiRRBOCGhiQWe4a3Jh7tz07tm7t9mQIW7v/V13bfkzqmYvBskcatVyq+czZ5q1aJHefbkKAhCAAAQgAAEI+EoAbeBfZBDo/sUkUo94CCPFG/vGdea3VsS12qxU8K2ZCraF+7lHjTLr0mVrn9i+98PidtWru7RzVW/Xfvp0TNXqlYav9PjHHtvyJ5591kzp+9rzPnhw/rVHH2322mtmmehrOn3iGghAAAIQgAAEILA9BNAG20Mvms8i0KPh6m2rPITehibjjs2aZTZ1qlmjRmYnn+xuH64yq1BcuLd8S45Nn2522GHuChWVS6f42vZ0dN48sw8+cKn5qrC+Lfboo67o2wknbF3U9+jhVtm15z1xoiLcA69U+0Thvi1+cC0EIAABCEAAAhDwhQDawJdI5PuBQPcvJpF6xEMYKd5YNS6BqWrkWiUePdq5rkrsw4eb3XCDWf/+W++OziAPzwd/+22z1q23/pniuiJc7Zewf/fdLXuha1QU7sknzc4+O//ae+91Ve47dDAbN664esJ9IQABCEAAAhCAQNEQQBsUDceibAWBXpQ0Y9AWD2EMgpQhF8eONTvzTCeqJa5lZ5xh9swzbvVYe7W3ZqtXu6JrVauaXX11+nvXt9ZuFO/PmWN26KFmWh0Pj2gr6D46/10F4P74w2z+fLO9986/6pVXzI49dtv2vkfRF9qEAAQgAAEIQAACRUEAbVAUFIu2DQR60fL0vjUeQu9DlDEH33/frHlzs913N1u2zN1W4lMiVCvqWln3zVQ9/fXXXcV4FXK75BKzbt3S81JHpv30k5tM2JJpsqJNG8dFBeESC8VpQkLnoe+7r1np0undl6sgAAEIQAACEICArwTQBv5FBoHuX0wi9YiHMFK8sWp8xQqzKlWcyxKe5co5wS7h/t//5u9L96lTH39s1rhxvkc6ck2F34rSwmJyp5zizk3HIAABCEAAAhCAQLYSQBv4F1kEun8xidQjHsJI8caucQl0CXUJ3wMPdFXRv/7abNq0/OJvPnXq22/N9tkn3yPtl1fF+W21d94x+/TTglffVehO+9Ul1JW2j0EAAhCAAAQgAIFsJYA28C+yCHT/YhKpRzyEkeKNXePhirkEafv27pi0BQvMHnnEpXH7Zskp6tpHf/rp2+ZlmNpfpozbY16jxqafv+kmV+Vd+/D/9rfN254wwVWs15FrnTtv2725GgIQgAAEIAABCPhEAG3gUzScLwh0/2ISqUc8hJHijV3jKhInkXv77WZXXum/++vWmUlYh/byy27f/LaY9qLraLgZM9xZ53feuS2fdkXxVOW+a1czHd2GQQACEIAABCAAgbgSQBv4FzkEun8xCTwaPHiw9enTxy6//HK7S0t5ZrZx40YbMGCAjRgxwlasWGEtW7a0YcOGWcOGDdPuBQ9h2qhy4sLPPjP780+3Wl62bDy6vNNOrsK6bOZMsxYttt3vsBp7qlX0LbWoKveqdt+qlRP5GAQgAAEIQAACEIgrAbSBf5FDoPsXE5s1a5adfvrpVrFiRWvbtm2eQL/lllts4MCBNmrUKKtfv77dfPPN9tZbb9m8efOsQoUKafWEhzAtTDl5kVaWZYlVy30EEe6bl29ffJF/Dvu2+JpqFV3775XyroJ5qSwsVLfLLmbLl/vPa1u4cC0EIAABCEAAArlFAG3gX7wR6J7FZPXq1da0aVO7//77AwHepEmTQKBr9bxmzZp2xRVXWK9evQKv161bZ9WrVzcJ94svvjitnvAQpoUpJy/SOeEtWzrB+8kn/iLYc0+zRYucf99/b1a9euF8LWgVvWlTVzBv4sTUqfM6J10CXiL/hx/MqlUr3P35FAQgAAEIQAACEChuAmiD4o7A5vdHoHsWky5duliVKlXszjvvtCOPPDJPoM+fP9/q1q1rs2fPtoMPPjjP6/bt21vlypVttA6uTsN4CNOAlEOXaE+3dlCoWNqppzpRuv/+Zkp999W0Z15p+e3ame22W+G9TF5FV3G4SpXc+eqLF5vVqpW6bVWSV0X5N980O/zwwvvAJyEAAQhAAAIQgEBxEkAbFCf9gu+NQPcoJmPGjAlS2JXiXqZMmU0E+owZM6x169a2ZMmSYCU9tIsuusgWLlxoL6taVgGmVXa9QtNDuMcee9jKlSuDFHostwlIjGrvuYbIbbe5Y8UOPdRs+vTc4KJV9AsvNBswwEwr86rMrq8LF265/yecYDZpkllhj3nLDbr0EgIQgAAEIAAB3wkg0P2LEALdk5gsWrTImjVrZlOmTLHGjRsHXiWuoIcCfenSpVYj4Vyobt26mT47efLkAnvSv3//oLBcsiHQPQm8B25oxVx7uc86y+zpp81OPNFMR4nlgmkVXQXnVHhu4ECzfv1cAbgxY7bce1W8V+aBqrnrhUEAAhCAAAQgAIE4EkCg+xc1BLonMRk/frx17NjRSpUqlefRhg0brESJElayZMmgENy+++67zSnurKB7EmCP3TjpJHfud716Zl99ZfbPf5o9/ri/Dj/8sFm3bkVfRV0TE9p7fvfdZt27b7n/K1aYlS4dn8r3/kYTzyAAAQhAAAIQKE4CCPTipF/wvRHonsRk1apVQap6onXt2tUaNGgQFIXTUWpKbe/Ro4f17NkzuGz9+vVWrVo1isR5EsO4unH55Wb33JPv/WWXbfpv3/pVubLZypXOq7Dy/Pb6GK6iq51Zs8yaNdveFvk8BCAAAQhAAAIQ8J8AAt2/GCHQ/YtJnkeJKe76oaq163z0kSNHWr169WzQoEH2xhtvcMyaxzGMg2sS5xLpoV1/vduT7auVL2/2229FK9CnTHFF52Tr15vtuKOvvccvCEAAAhCAAAQgUHQEEOhFx7KoWkKgFxXJCNpJFug6ak37yYcPH24rVqywli1b2rBhw6xRo0Zp352HMG1UOXOh0tuV5i474giXPt65s7/d33lns7Vri1agayVe++93393sqKPS67sSWWbONLv/frOGDdP7TLpXPfSQmQrRbamSfLptcR0EIAABCEAAAhBIRQBt4N/YQKD7F5NIPeIhjBRvLBtXgTgViqtQwaWOlyjhdzdUlO3GG81OP91MR64Vl7VubTZjhisop8JyRWWqoH/YYWY6ZEE1AThnvajI0g4EIAABCEAAAskE0Ab+jQkEun8xidQjHsJI8cayce2/1rnnOttbIt130xnoErEtWphpNb247IILzB591Kx//6Kr5K70+qZNzebONVP7KoingnS33OImJVRtHoMABCAAAQhAAAJFRQBtUFQki64dBHrRsYxFSzyEsQgTTsaAwNChZkpzP/NMlx5fFDZkiFnv3ma77eaOvqtSxezww83eftusfXuzZ55BpBcFZ9qAAAQgAAEIQMARQBv4NxIQ6P7FJFKPeAgjxRvrxmvXdmeCT5tmVr9+rLuSEedffNHsH/8wa9LEbM6c7b/l/PluL7v21z/2mNk557g2VcBO91m3zqxjR5fWTxG77edNCxCAAAQgAAEIINB9HAMIdB+jEqFPCPQI4ca46ZdfNjvuONeBRYvMJNaxLRPQ/nBNZCjNfvVqs5IlC09MRepUFG7yZFekburUTWsB6OdaQVcK/Kmnmj31FCK98LT5JAQgAAEIQAACIQG0gX9jAYHuX0wi9YiHMFK8sW28Tx+zwYOd+xKb5crFtisZc1x74cuWdVkHCxaY1alT+Fs//7xZp04uff3jj83222/ztiZOdCvoEukqkPfkk2Y77FD4e/JJCEAAAhCAAAQggDbwbwwg0P2LSaQe8RBGije2jYf7qdWBv/7yv5K7L6CVkq7K9+PGmTVvXnivNCmiYnOVK5v165e6nQkTzE45xU0K9Ohhdscdhb8nn4QABCAAAQhAAAJoA//GAALdv5hE6hEPYaR4Y9u49jm3a+fcV7o1lh4B7QsvXTq9a4vqqueeMxs0yOyuu8zatCmqVmkHAhCAAAQgAIFcJIA28C/qCHT/YhKpRzyEkeKNbeMS5bfd5oqUaS80lhkCP/xgVrXqtu9fV5bD9ux5z0zvuAsEIAABCEAAAr4TQBv4FyEEun8xidQjHsJI8dI4BNImoDT1Zs3Mypc3e/xxdw59YWzDBrNSpQrzST4DAQhAAAIQgECuE0Ab+DcCEOj+xSRSj3gII8VL4zlGQBXvu3Y1+/lns9mzt9z5NWvM5s41++gj93r3XbNZs9xZ5zrzXCvp22Jq79ZbzVRg7r33Mp9qvy2+ci0EIAABCEAAAn4SQBv4FxcEun8xidQjHsJI8dJ4jhH49VezSpVcp3X8maqq66UVba2O/+c/7j0J+b32cgX4Eq1ECXfm+T//ue3gVq1yx7x9/70T6tdcs+1t8AkIQAACEIAABHKbANrAv/gj0P2LSaQe8RBGipfGc5CAjkT78svNO64j0bS6LZMwl5AvU8asceP819/+5kR2YW30aLPzzjOrUMH5sPvuhW2Jz0EAAhCAAAQgkIsE0Ab+RR2B7l9MIvWIhzBSvDSegwS++sps6lQz7QXX2ej6qle9eu7c8tCWL3fp7Fo1LyqT8JfIV6r8+eebPfJIUbVMOxCAAAQgAAEI5AIBtIF/UUag+xeTSD3iIYwUL41DIOME3nnH7NBDnfDXXnSl1mMQgAAEIAABCEAgHQJog3QoZfYaBHpmeRf73XgIiz0EOACBIidwzjlmTzxh1rq12bRpRbtKX+TO0iAEIAABCEAAAt4QQBt4E4o8RxDo/sUkUo94CCPFS+MQKBYCS5a4vexKrVe6+4EHFosb3BQCEIAABCAAgZgRQBv4FzAEun8xidQjHsJI8dI4BIqNgArSHXyw2d57Oxd++83s22/da/5893XhQrOddjLr08cVqpP99JPZihVmNWu6YnbLlm366tLF7Z2X6T1df8ABnL1ebIHmxhCAAAQgAIEiJIA2KEKYRdQUAr2IQMalGR7CuEQKPyFQeAJDhpj17p3689Onu33rsnvvNevePfW1M2eatWjh3h861KxnT1c1XsXpWrVyL+1733VXUusLHzE+CQEIQAACECgeAmiD4uG+pbsi0P2LSaQe8RBGipfGIeAFgVGjzLp2Natc2Wyffdyqul46i12V5nXuugS17LbbzPr3dyvusnLl3Gq6XjVqmPXta9aokXvvhhvM7rjDbPXqzbsp0f7pp2Z77une0ySAUu91/4YNzXbe2Qs0OAEBCEAAAhCAQAIBtIF/wwGB7l9MIvWIhzBSvDQOAS8ISEBLiEugp2u//upWwCW0t2RqV0Jc1eNnzHAvpdDL1q41K13afa/U+Mcec9+XKmXWoIFLwQ9fKmindHsMAhCAAAQgAIHiI4A2KD72qe6MQPcvJpF6xEMYKV4ah0BOEvj9d7PFi12hutAGDjSbNMls3jy3bz3RNBGgCYHy5d1PJfB3392sbNmcxEenIQABCEAAAsVGAG1QbOhT3hiB7l9MIvWIhzBSvDQOAQgkEdi40WzpUrM5c8w+/NB9XbXKbMqU/AuPOMKd4d62rdlJJ5mdeKJZnTqghAAEIAABCEAgagJog6gJb3v7CPRtZxbrT/AQxjp8OA+BrCPwxx+uKvzXX2/aNe1b79DB7NRTzZo0ybpu0yEIQAACEICAFwTQBl6EYRMnEOj+xSRSj3gII8VL4xCAQCEIaJX9s8/MXnrJbMIEt69dZ7rLtJqun4Wma5Uij0EAAhCAAAQgsP0E0Abbz7CoW0CgFzVRz9vjIfQ8QLgHAQjYzz+bTZxoNm6c2SmnmHXu7KDoHHcdD6eVdb2UGk+hOQYMBCAAAQhAoPAE0AaFZxfVJxHoUZH1tF0eQk8Dg1sQgMBWCdx9t9kVV+RfVqmS2QknOLF+3HFmFStutQkugAAEIAABCEAggQDawL/hgED3LyaResRDGCleGocABCIksH692auvmj33nNmLL5r9+GP+zbSS/sorZocfHqEDNA0BCEAAAhDIMgJoA/8CikD3LyaResRDGCleGocABDJEQHvUZ840e+EFs/HjzRYscMe5hee4jxhh9u23boW9VSuzHXbIkGPcBgIQgAAEIBAjAmgD/4KFQPcvJpF6xEMYKV4ahwAEiomAzmGvXTv/5s2bm73/vvu3UuGPPdaJ9WOOMatVq5ic5LYQgAAEIAABzwigDTwLiJkh0P2LSaQe8RBGipfGIQABTwg8/bSrCj95stny5Zs61bq12dtve+IobkAAAhCAAASKkQDaoBjhp7g1At2/mETqEQ9hpHhpHAIQ8IyAUuFnzXJV4SdNMps9252tPnasc1THtmm1vUEDt39dVeJ1LnvJktvfkXXrzH75xaxq1aJpb/s9ogUIQAACEIDApgTQBv6NCAS6fzGJ1CMewkjx0jgEIOA5gZUrzfTac0/n6Lx5TpwnmqrB/+1vbu+6zmGXgE80Fav77bf8l1botd9d19Wv767U3viOHd0EgArY7b23Wd26Zvvs415KtW/UyF0rES8/NJnw55/u9ddfZqVLm5Uta1anjtluu7lr9fPQwmvDz+mrrtcLgwAEIAABCKRDAG2QDqXMXoNAzyzvYr8bD2GxhwAHIAABjwisXWs2fbrZm2+6ryo8J/EdWq9eZkOGuH+99ppZu3ZOQBdkOgaue3f3jlbtW7RI3dH77jO79FL3/oQJZiefnPraxHaVmt+mTeprb7vN7Kqr3Puff+7Oka9SJf+1665meknwaxKicWN3bSjyNSmAQQACEIBA7hBAG/gXawS6fzGJ1CMewkjx0jgEIBBzAhLfn35qNmOG2TvvmHXtanbUUa5TEvCHHZbfQVWGL1fOrHJlt0J+0UVmZ53l3tcq+4oVThgvWWL2zTdm8+fnvy6/3KXTy954w+y881yleb1KlXIp8UqRX7PGbNAgs3POcddOmeImCVLZLbeY9ezp3tWkw5FHpr72ppvM+vVz73/yidlBB5mVKWO2yy6bvzp1Mmvf3l27erXZ66+7fofX6nut3JcoEfMBgPsQgAAEcowA2sC/gCPQ/YtJpB7xEEaKl8YhAIEsJiDBrKPcJMr12nHHzHf2jz9cir4sUdAnCvvQK6XOf/ih2c8/u5dS8cOv6ocmBTp0cFdrkqBt29T9uflms7593fsff5y/8p74Cfmgivlawe/d272js+r1fSjm9TXx+732oqp+5kcRd4QABCCQTwBt4N9oQKD7F5NIPeIhjBQvjUMAAhCIJQHtbf/1V7fqX9BLBfSUEi/TavsFF+Rfp4kApciHlo6YD6+VmFdavmzRIrNmzTYX8xL9EvVHHOGOypMpQ+Hdd92596oZEH5Vij6r+LEcgjgNAQgUEwG0QTGB38JtEej+xSRSj3gII8VL4xCAAARyjoAK4Wnfvlb2JdaV1l+jhsOwbJnZyJHu5+FLEwD6Xl+1D79HD3dtqpX5EOjVV5sNHer+9d13rnhesimrQYK9WzezwYPdu/Ltkkvc6n758mY77+xS+fXS96raH2430ETFnDkuQ0LXhtkSKvS3LSYmmrRQVgEGAQhAwGcCaAP/ooNA9y8mkXrEQxgpXhqHAAQgAIFCElDBvi+/zBfvoeCXmNf3SsE/6STXuPb0q8L+qlVu5V/74hMtcWU+lZgPr5eYHzHC/Uv30r76ZJPQlpg/+2yzBx9076pegTIL9N7vvzsfEl+qR/D44+5aCfZ993X79MOMAGUFaDJBL+3/V9uhqSCheKgGQfhV3+ulbQGnn55/7VtvOd/C7QOaeJApk0D1DPReaPp8+J7eT3yp7kFRHC+4OT1+AgEI+EwAbeBfdBDo/sUkUo94CCPFS+MQgAAEIFAMBLTyLXEssa6XRG/t2s4R7bt/+GEn8rWaHoreUPged5xbYZf98INLs9d1ak97/hNNRQMffdT9RJMDuk8q0/7+cePcuxLwWo1PZSrAN368e1diXqn6yfcOP3v88WYTJ+a3JB/kS0GmSQ2J/dBUvV+1CAqypk3NPvgg/x1tafj+e3dMoPwJsw70VZMNDzyQf61OOhDnxOvC75VRodMEQlOGgrYo6P3kCQFNdiijITQVVlS8kicS5JMmHqpXT82UdyAAgfQIoA3S45TJqxDomaTtwb14CD0IAi5AAAIQgEAsCCSeeS9BrxXwmjWd63pPQllCOkyJV1p8+JJw1vcyrbarYF9iVoBW68MMAInSCy9016o9TRKEq/ZhSn74tUkTsyuvdNdqYkLCOtw2oMmJREsW6DpiT0K6IGvVyp1eEFqtWmZLlxZ8rVb8P/oo/7369c2++qrga/fZx2U8hCZ/JdILMm2NSLynth7oNIWCTMwTMyc6dnQnFyROJCR+/+qr+fUJ7rnHxUNCP3xpe0Q4EXDjjS77QPbcc2affeb+Hb7Cooz6t+oxhMcTapuGTm3QffWzcJIi/F5jJ2y34F7xUwhkngDaIPPMt3ZHBPrWCGXZ+zyEWRZQugMBCEAAAhD4/wS0710CX6vwMgnOMOVd/5ag1XsFvbSarTT50HTcoFb+dXpB+NIkhV6aeAiP3dP1KvSn7IPw/cSvWuVWBkNo2qYwd65rM/QzfE/XSjiHpm0Ms2a5iYjQZ32vyREVBtQ9Q9ORghLoBZkEsnwK7eSTzSZMSD1sNKESCukzzzQbOzb1tZp0CTMpNMnyyCOpr128OP/UAtVeGDZs00mCMFtBXzX5E9ZZGD3aZWOEEw7qT+K13bub7b67u+/775vNnr355EA4SaDJFbGThdtDwvYSJyH0PQUXU8cym95BG/gXTQS6fzGJ1CMewkjx0jgEIAABCEAAAhkgIMGeKCBVkFBiOXFyQJMA+rcEd6dO+U5pVVwr/hL6emlSQ1/DSYA778xPv9fkgiYJNPkRvtRe+P0TT+RPggwYYPbf/7p7hvdOnODQ6rq2Gcj+9S+z4cNTg1qwIF+gq0Di7benvlYTHuHWgBtuMFMGQCqbOdOsRQv3riZWrrkm9bWvv26miQ/ZqFFmffrkF1lURkf4ksC//nqz5s3dtbrHU09tOomQmK2gbRp167prFy50JzJoQiCsg6DvldGgCYn998/fyqDtDsoWSZygCDMfMjDksvYWaAP/QotA9y8mkXrEQxgpXhqHAAQgAAEIQAACWyWgyQRtcQgnCRK/StQrvT9MnZfg1ZaCcPJB74fX63sJ52rV3C0ljJ95Jn+SIDkD4oUXzBo2dNfeeqv7bOIxiYmOqwBhmzbuJ5q0CLdWFNS5yZPN2rVz72hSQ8UXU5kmSMK6BPK3c+fU1yp74Nxz3fvKelD2Q7KF2QHy8fzz3bsS/dp+oIkBiXi9Ercd6LqwLRWSVDZD+H6YnRD++5BDzA480LWrmKntxHYTt0loG0lYaDKsjVHQxI78CU+72OpgifgCtEHEgAvRPAK9ENDi/BEewjhHD98hAAEIQAACEIBA0RKQgJTgT8wS0Pc6cSA8YvCnn8yUoh+eJpB4woAmAVRsUXULZMo4UNFD/VzZCckTCj175q+2T51qNnCg28agV+hD+DlNImirg0xp/qedlnpCQRMDEuUyTRhopT6V3X23mbYGyKZNcycypLJBg8x693bvavuABHsq04SH+iNT7YJwMiT5ek3ATJ9etHEsbGtog8KSi+5zCPTo2HrZMg+hl2HBKQhAAAIQgAAEIACBNAhIxIeZAZpYCL+vWjW/joJOK1DWgYR++EqspSCBHK6Kf/212f33u0mKgtrV6Q2aGJCpNoOORExsN9wioc/36mXWt6+7dt48swYNNu1QWGBQRRm1hcAHQxv4EIVNfUCg+xeTSD3iIYwUL41DAAIQgAAEIAABCEAgyAiQaA+L7yUfK+gLIrSBL5HI9wOB7l9MIvWIhzBSvDQOAQhAAAIQgAAEIACB2BBAG/gXKgS6fzGJ1CMewkjx0jgEIAABCEAAAhCAAARiQwBt4F+oEOj+xSRSj3gII8VL4xCAAAQgAAEIQAACEIgNAbSBf6FCoPsXk0g94iGMFC+NQwACEIAABCAAAQhAIDYE0Ab+hQqB7l9MIvWIhzBSvDQOAQhAAAIQgAAEIACB2BBAG/gXKgS6fzGJ1CMewkjx0jgEIAABCEAAAhCAAARiQwBt4F+oEOj+xSRSj3gII8VL4xCAAAQgAAEIQAACEIgNAbSBf6FCoPsXk0g94iGMFC+NQwACEIAABCAAAQhAIDYE0Ab+hQqB7l9MIvWIhzBSvDQOAQhAAAIQgAAEIACB2BCqNALNAAAehUlEQVRAG/gXKgS6fzGJ1CMewkjx0jgEIAABCEAAAhCAAARiQwBt4F+oEOj+xSRSj3gII8VL4xCAAAQgAAEIQAACEIgNAbSBf6FCoPsXk0g94iGMFC+NQwACEIAABCAAAQhAIDYE0Ab+hQqB7l9MIvWIhzBSvDQOAQhAAAIQgAAEIACB2BBAG/gXKgS6fzGJ1CMewkjx0jgEIAABCEAAAhCAAARiQwBt4F+oEOj+xSRSj3gII8VL4xCAAAQgAAEIQAACEIgNAbSBf6FCoPsXk0g94iGMFC+NQwACEIAABCAAAQhAIDYE0Ab+hQqB7l9MIvWIhzBSvDQOAQhAAAIQgAAEIACB2BBAG/gXKgS6fzGJ1CMewkjx0jgEIAABCEAAAhCAAARiQwBt4F+oEOgexeSBBx4wvRYsWBB41bBhQ7v++uvt+OOPD/593nnn2ejRozfxuGXLlvbuu++m3QsewrRRcSEEIAABCEAAAhCAAASymgDawL/wItA9ismLL75opUqVsn333TfwSmJ86NChNmfOnECsS6D/8MMPNnLkyDyvd9ppJ6tSpUraveAhTBsVF0IAAhCAAAQgAAEIQCCrCaAN/AsvAt2/mGzikcS3RPoFF1wQCPRffvnFxo8fX2iveQgLjY4PQgACEIAABCAAAQhAIKsIoA38CycC3b+YBB5t2LDBnn32WevSpUuwgn7AAQcEAl3iXKvmlStXtiOOOMIGDhxo1apVS7sXPIRpo+JCCEAAAhCAAAQgAAEIZDUBtIF/4UWgexaTTz75xFq1amVr16618uXL21NPPWUnnHBC4OXYsWODn9WpU8e+/fZbu+666+zPP/+0Dz74wEqXLl1gT9atW2d6haaHcI899rCVK1daxYoVPes97kAAAhCAAAQgAAEIQAACmSKAQM8U6fTvg0BPn1VGrly/fr199913QSr7c889Zw8//LC9+eabwQp6si1btiwQ62PGjLFTTjmlQP/69+9vAwYM2Ow9BHpGwslNIAABCEAAAhCAAAQg4C0BBLp/oUGg+xeTTTz6+9//bnXr1rXhw4cX6Gm9evXswgsvtF69ehX4PivongcY9yAAAQhAAAIQgAAEIFBMBBDoxQR+C7dFoPsXk008Ovroo4OU9FGjRm3m6fLly61WrVo2YsQIO/fcc9PqiVbOtX990aJFpLinRYyLIAABCEAAAhCAAAQgkJ0Ewu2vyt6tVKlSdnYyZr1CoHsUsD59+gRnnkuQr1q1KkhdHzJkiE2ePDnYl6509U6dOlmNGjWCs9J1vdLhP//8c6tQoUJaPVm8eHHQPgYBCEAAAhCAAAQgAAEIQEAEtHhXu3ZtYHhAAIHuQRBCF3SU2quvvmraW64ZrIMOOihIXT/mmGNszZo11qFDh6Ciu2a4JNLbtm1rN9100zYJ7r/++suWLl0aCPoSJUpE3vtwVo4V+8hRZ9UNGDdZFc6Mdoaxk1HcWXMzxk3WhDKjHWHcZBR3Vt3Mp7GzcePGYGGwZs2aVrJkyaziHNfOINDjGrmY+M2+lpgEyjM3GTeeBSRG7jB2YhQsj1xl3HgUjBi5wriJUbA8c5Wx41lAPHMHge5ZQLLNHX4BZVtEM9Mfxk1mOGfjXRg72RjV6PvEuImecTbegXGTjVHNTJ8YO5nhHNe7INDjGrmY+M0voJgEyjM3GTeeBSRG7jB2YhQsj1xl3HgUjBi5wriJUbA8c5Wx41lAPHMHge5ZQLLNHR3zNnjwYOvdu7eVLl0627pHfyIiwLiJCGwONMvYyYEgR9BFxk0EUHOgScZNDgQ5oi4ydiICmyXNItCzJJB0AwIQgAAEIAABCEAAAhCAAATiTQCBHu/44T0EIAABCEAAAhCAAAQgAAEIZAkBBHqWBJJuQAACEIAABCAAAQhAAAIQgEC8CSDQ4x0/vIcABCAAAQhAAAIQgAAEIACBLCGAQM+SQNINCEAAAhCAAAQgAAEIQAACEIg3AQR6vOPnvff333+/DR061JYtW2YNGza0u+66y9q0aeO93ziYGQKq8P/888/bF198YTvvvLMdeuihdsstt9h+++2X58DGjRttwIABNmLECFuxYoW1bNnShg0bFownDAIioHHUp08fu/zyy4PfMTLGDWOjIAJLliyxXr162aRJk2zNmjVWv359e+SRR+yQQw5h3DBkUhL4888/rX///vbkk0/a999/bzVq1LDzzjvP+vXrZyVLlmTsMHYCAm+99VbwN+8HH3wQ/N07btw469Chwzb9PaPq7ldffbU9/fTTwe+oo48+2vS3dO3ataGcQwQQ6DkU7Ex3dezYsXbOOecEv1hat25tw4cPt4cfftg+++wz23PPPTPtDvfzkMBxxx1nZ555pjVv3tz0B1Dfvn3tk08+CcZIuXLlAo8l2AcOHGijRo0K/pi++eabg/8E582bZxUqVPCwV7iUSQKzZs2y008/3SpWrGht27bNE+iMm0xGIR730gTfwQcfHIyTf//731atWjX75ptvbK+99rK6devy+yYeYSwWL/V/0J133mmjR48OJofff/9969q1a/D/kSYG+b+qWMLi3U018Td9+nRr2rSpderUaTOBns7/S/rd9OKLLwZ/8+y666521VVX2c8//xyI/lKlSnnXZxyKhgACPRqutGoWrHTql9QDDzyQx2P//fcPZhO14oVBIJnA//73v+CP5jfffNMOP/zwYBW0Zs2adsUVVwSrXjLNLlevXj0Q7hdffDEQc5jA6tWrg98xmgTUH8pNmjQJBDrjJocHxRa6fu211wZ/PE+bNq3Aqxg3jJtUBE466aTg/x1lW4QmAVa2bFl7/PHH+Z3D0NmMQIkSJTYR6On8flm5cqVVrVo1GFNnnHFG0ObSpUttjz32sIkTJ1q7du0gnSMEEOg5EuhMd3P9+vXBf1zPPvusdezYMe/2mmn+8MMPAwGGQSCZwNdff2316tULVtEbNWpk8+fPD1a2Zs+eHax8hda+fXurXLlysJqB5S6BLl26WJUqVYKVrSOPPDJPoDNucndMbKnnBxxwQPAH7uLFi4P/g2rVqmWXXHKJdevWLfgY44Zxk4rAkCFD7MEHH7QpU6YEmVwfffSRHXvsscGE4FlnncXYYehsVaCn8/vltddeC1LatWK+yy675LXZuHHjYHFL2/2w3CCAQM+NOGe8l5rx0x8/Wq3QvuLQBg0aFIgqpSdjEEgkoNllCW+loYYrXDNmzAi2R2jfqFbSQ7vooots4cKF9vLLLwMxRwmMGTMm2PqgFPcyZcpsItAZNzk6KLbSbY0T2ZVXXmmnnXaavffee0F2jrZfnXvuuca4YdykIqD/n1TnQplbSjPesGFD8Pund+/ewUcYO4ydZALJK+jpjJGnnnoq2DqhTMFE02TQ3nvvHfyuwnKDAAI9N+Kc8V6GAl2/kFq1apV3f/2HptQdFQXDIJBI4NJLL7WXXnrJ3n777bxiKOF/aBpPKsoTmla8Fi1aZJMnTwZiDhJQ7Js1axasZmllQZa4gs64ycFBkUaXd9ppp2DcaHyE1r1792CS55133skTWfy+SQNmjl2iCcFrrrkmKACmPejKBNTkzh133GHK5OF3To4NiDS6m0qgb+n3SyqBfswxxwTZhMriwHKDAAI9N+Kc8V6S4p5x5LG+4WWXXWbjx48Pir9plji0dFLCYt1xnC8UAY0VbZ1JLJijFS39QaSKysrQ2XfffdkaUSi62fuhOnXqmP7QVbHS0FQjRfULlKXD75vsjf329kx7gFXDQBPJoWncPPHEE8GCA2Nnewln3+eTBXo6Y4QU9+wbB4XtEQK9sOT43FYJqEicjq5RAafQtAdQacwUidsqvpy4QGmDEuc6iuSNN94I9p8nWlhUpUePHtazZ8/gLU3+qJAcReJyYogU2MlVq1YFWxwSTWmBDRo0CIoJaoVLWyIYN7k7Rgrq+dlnnx1k3iQWidMYmTlzZrACyu8bxksqAqqmLUGuCtuh6e+YkSNH2pdffsnYYehsRiBVkbgt/b8UFonTxI9OJ5HpuDYdsUaRuNwaZAj03Ip3RnsbHrOmlByluesc64ceesjmzp1rWsnAIKACTUrpeuGFFzY5+7xSpUrBuegyCfHwDyEJeNUxkJjnmDXGTyKBxBR3xg1joyACSmVXTRQVWtIfv9qDru0y+r+pc+fO/L5h2KQkoDPPp06dGuwB1gTgnDlzTLVQzj///OD/KH7nMHhEQCeLqNitTIVttQVCxzqqmKmOF07n7xlNAk2YMCE4Zk2f05noy5cv55i1HBtiCPQcC3imu6vV81tvvTWYAVRVblVb1vFZGAREQDPMBZlWJfQHkUyrWvqDWn8YqYCcMjOGDRsWjCcMAiGBZIHOuGFsFERAf/iqsNdXX30VbKdRwbiwiju/bxgzqQgoa+e6664Lsr1+/PHHIENH1duvv/56U20Dxg5jRwS0eCBBnmyqUyDBnc7/S2vXrg3qHWjxYs2aNUFVd/0trW0WWO4QQKDnTqzpKQQgAAEIQAACEIAABCAAAQh4TACB7nFwcA0CEIAABCAAAQhAAAIQgAAEcocAAj13Yk1PIQABCEAAAhCAAAQgAAEIQMBjAgh0j4ODaxCAAAQgAAEIQAACEIAABCCQOwQQ6LkTa3oKAQhAAAIQgAAEIAABCEAAAh4TQKB7HBxcgwAEIAABCEAAAhCAAAQgAIHcIYBAz51Y01MIQAACEIAABCAAAQhAAAIQ8JgAAt3j4OAaBCAAAQhAAAIQgAAEIAABCOQOAQR67sSankIAAhDIagILFiywvffe2+bMmWNNmjTxoq9ffPGFnXfeefbhhx9agwYNgq/JtnHjRrv44ovt//7v/2zFihXF6r+PDAsbyDfeeMPatm0bMK1cuXJhm0nrc/3797fx48cXGN+0GuAiCEAAAhCAwP8ngEBnKEAAAhCAQJEQkBAdPXq0DR482K699tq8NiVcOnbsaBKiUZqP4vKMM86wn376yR599FErX7687brrrpshmDRpkrVv394kKPfZZx/bbbfdbIcddogSVdC24vXLL78EwjK0DRs22P/+97+M+RBlJ6MS6CVKlLBx48ZZhw4d8txfvXq1rVu3rsD4RtlH2oYABCAAgewjgEDPvpjSIwhAAALFQkCCb+zYsVamTBmbP3++7bLLLoEfcRfo69evt5122qlQTJs1a2YnnniiDRgwIOXn77vvPhs6dKgtXLiwUPco7IcKEuiFbcvHz2VSoPvYf3yCAAQgAIF4EkCgxzNueA0BCEDAOwISfMuXL7evv/7aTj75ZLv11lsLFOgFpQPfddddppdWwWWheGzRooXdfffdwepkjx49rG/fvta7d2975JFHrGzZsnbjjTfa+eefH3wmXEF/+umn7Z577rHZs2db3bp1bdiwYXbkkUfm8frss8/s6quvtrfeesvKlStnxx57rN15553BqrFM1zZq1CgQ5Y899pg1bNjQ3nzzzc14//XXX3bzzTfbiBEjglXn/fff34YMGWLHHXdccK1WWhPthhtuMPU90cKsg/BnderUCfqx11572RVXXBG8QlPavlZtwzbU/kMPPWQvvfSSvfzyy1arVi27/fbb7R//+EfeZ+bOnWs9e/a0adOmBRkMamPUqFH2+OOPbzZp8Prrrwf3Td4moL5fc8019tFHH1mVKlWsS5cuQb/DVX7xOuigg4KJmYcffjjg9q9//WuzviYDHDlyZDBGvv322+C+3bt3t0suuSS4rFWrVnbEEUcEPEMT45o1a9qUKVOC1PUnnngiGDPz5s0L4njUUUcF/65WrVrwkWSBns64mzVrlvXp0yfYZvDHH38EvDQ2mjZtGrQpPxMnUsJ4Jbe9tbERjtXnnnvO7r33Xps5c6bVq1fPHnzwwaDvMt3nP//5j7399tumSSLdWxM5J5xwgnfPPg5BAAIQgEDREUCgFx1LWoIABCCQ0wRCUS0Bd/bZZ9tXX31ltWvX3mwFPR2hpLaef/55O/fcc+2yyy6z6dOn2wUXXGDt2rWzww8/3E477bRgtV4C/ZtvvrE99tgjT6DrnhJqBxxwgN1xxx3BdRKBSi9ftmxZICa7desWtL1mzRrr1auX/fnnn/baa68F8ZPg/OCDD+zf//53cE8JW+0fTzYJN/Vl+PDhdvDBBwdp7PqZRLHE1vfff29///vfA8GuCQGluOuVaCtXrgwmEyTyJQ5LlSplVatWTVugq68Suc2bNw+EnnyQsJOQXrJkSdBX9UeTGhUrVgw4HnrooYGYV99+/fVXk1CW6TNLly7dRKCrjfr16wcTJoqD9tSL3aWXXponwNW+BO2VV14ZxP2dd94JrtekwTHHHFPgM6GJBU1YKHtA7PR5tat4afyEWQUSsuFEh34mwf7dd99ZyZIlg77WqFHD9ttvP/vxxx+DCRxlbUycOLHQAl1jQAwOOeSQoA1NeEyYMCEYyxUqVAgmYjQBIGaKaxiv5DG9tbERCnSNq9tuuy0YL5p80hjQBJcmP0466aRAmMsHTUBoYkkx1PjHIAABCEAgewkg0LM3tvQMAhCAQEYJJKZMaxVQAlkr3ckp7ukKdK2AKlVeYkwmMSNxpJVvmfZLV6pUKVi1PfPMM/MEukScRLdMwlsrwhKXWkm+/vrrg9VKicfQFi9eHAh8rcRKjEpwSjhLNG7JJHIlVLXiGppW/CWWtWovS171Lqi95OwBXZPuCnq/fv3spptuCpr97bffAhEpgSrxKL/GjBkT9GvHHXfc7NYFpbgn7+OXaNQq7+eff54nlO+///6ArxgpNuKlWGiVPpGDVrQTV8ATHdhzzz3tlltusbPOOivvx1qVl+8zZswIhLBWyyWY27RpE1yjiYXDDjssLzMjuUMSt+K/atWqYCKkMCvoyW2qXxL9Tz31VCCYZQXtQU8e01sbGyFnjV1NlMgkwJWtIdYa65pc6dSpUzCRgUEAAhCAQO4QQKDnTqzpKQQgAIFICSQKPoloCbSPP/7Yvvzyy02KxKUr0CXSlL4dmlKelXoeil/9XCnGV111VZAeHYoepWQnrjKqQJ2qeGvVU/vBX3nllc32lEvcShwef/zxgeDUiqZWeVOZVp41OSARKL9C0yquUsHD1fioBfozzzwTZBOEJp+0kq7sAKVCazVehfsKsnQE+imnnBL0M1xlVzvqn/qllXoJbfGSsEyMi4reKWNBq9zJFq5C77zzznmTL7pGkym61w8//BB8RP6rfaV9KwNCBfRUBb9x48bB+5pA0VjSz37++WdTWvnvv/8eZDBocqgwAl0r8ZrEUfzkhwS62tTqfZh+vzWBns7YCMfqe++9F0zoyFRtXlkM4fiVeFcWhyYdlIkhsS7RjkEAAhCAQHYTQKBnd3zpHQQgAIGMEUgWfBLDWrnVzxOruCstXauyEnqhaW+tBF7yHvTECuMSghKGWnEOLXGleUsCXaugEosS4Nq7rtXbZFO6tFKJC7pP8rWhCEueDNCe8U8++cReffXV4COFFegSo1r1l+APTSJYYjxxD3pyNXFNRIiPmEvQaSV5ewS64hayC/2QIFZaulLNlXlQEC/tlZcv2u+ebBK+u+++e7CHvGXLlpu8rZRxZTzInnzySbv88suDbQlK41dtgU8//TR4TxMqir3qB2i/uyYi5I+2QITH7CUL9HTGnSYFNIGgon6a/CldunSwJ1yZBGE9gHQF+pbGRkEnDqiivlirFkBYM2HRokXBJJX23SvVXunuGhcYBCAAAQhkLwEEevbGlp5BAAIQyCiBZIEuoSqBqhVuCfDwmLUHHnggEJnaox3uL+7cuXOwP7ooBLrEt9LZZVqVldhVsS39LEzZltBLdZRZOgJdbadKY9aKp1Zct0egS7hqZT4stKcJAYla9SFdgS6RKXGeKsX9oosuCsTviy++mDdO0k1x1zF6EpRhinvyxMmWBLpupr3zOvv9uuuuSzlGJcKrV68eCHPd75xzzsk7vk81AlQhP5wkUCMS/LomlUBPZ9xpi4BS+NWOTAJZq/jaUx4KdBXBk0+aAAkt3RT3cGykK9AT4aiOgMS6slIwCEAAAhDIXgII9OyNLT2DAAQgkFECBaVMK9X62WeftbVr1+YJdO2x1Wqwzks/9dRTbfLkyYFQUwGsohDoElRaRVZVdQkr7R9WirSqtKsAmMSkxK8qk+tnKsqlvdpKadcKbroCXffQ/mAVeFObSgNXkbOwSNz2CHSJMa0+K4Vdq6riM3Xq1GCyI12Bror6KqCmvqo9pY+/++67Qcq0fj5o0KCgwJ1WZ5WOrvdVFC6xintYJK5r167BJIfE/oUXXrhZkbhtFehK39a2BI0BZTWoSv/7778fpHmr2FxomrgRT4lSjQ3FVqZVbol8rbBrBV0TLoqntlOkEujpjDtlBmg1XicHaFJEbcovsQoFuuoUKOVcqfBaYVd8kgX61sZGOgJd9xMb3U9clO6urAEVPcQgAAEIQCB7CSDQsze29AwCEIBARgkUJNC1T1liUAIsXEGXU9pXLNGjvcNaidQ1ErpFIdAlyCWwJNR0zJpWs7UfPjRV5FaRM6USyy+lMquomsS1VvTTFeiJR2lp77L2PSces7Y9Al3iUFXNNXkh4axCcJpsSD5mbUsp7rq/hK1Epo7q0uRDeMyasgokciWAVXV99erVAY/CHrO2rQJdvilOyqxQcTRtLTjwwAMDEay0+tBUF0BbJVRTIPmoO61iqxCesgB0DJomIXTEXCqBns6402eVWaDsD00GaIyqAn/ikXfKONAkgsaqsij0dUvHrBU0NtIR6EplnzRpkqmIoSavNEY1BjSZgkEAAhCAQPYSQKBnb2zpGQQgAAEIQAACEIAABCAAAQjEiAACPUbBwlUIQAACEIAABCAAAQhAAAIQyF4CCPTsjS09gwAEIAABCEAAAhCAAAQgAIEYEUCgxyhYuAoBCEAAAhCAAAQgAAEIQAAC2UsAgZ69saVnEIAABCAAAQhAAAIQgAAEIBAjAgj0GAULVyEAAQhAAAIQgAAEIAABCEAgewkg0LM3tvQMAhCAAAQgAAEIQAACEIAABGJEAIEeo2DhKgQgAAEIQAACEIAABCAAAQhkLwEEevbGlp5BAAIQgAAEIAABCEAAAhCAQIwIINBjFCxchQAEIAABCEAAAhCAAAQgAIHsJYBAz97Y0jMIQAACEIAABCAAAQhAAAIQiBEBBHqMgoWrEIAABCAAAQhAAAIQgAAEIJC9BBDo2RtbegYBCEAAAhCAAAQgAAEIQAACMSKAQI9RsHAVAhCAAAQgAAEIQAACEIAABLKXAAI9e2NLzyAAAQhAAAIQgAAEIAABCEAgRgQQ6DEKFq5CAAIQgAAEIAABCEAAAhCAQPYSQKBnb2zpGQQgAAEIQAACEIAABCAAAQjEiAACPUbBwlUIQAACEIAABCAAAQhAAAIQyF4CCPTsjS09gwAEIAABCEAAAhCAAAQgAIEYEUCgxyhYuAoBCEAAAhCAAAQgAAEIQAAC2UsAgZ69saVnEIAABCAAAQhAAAIQgAAEIBAjAgj0GAULVyEAAQhAAAIQgAAEIAABCEAgewkg0LM3tvQMAhCAAAQgAAEIQAACEIAABGJEAIEeo2DhKgQgAAEIQAACEIAABCAAAQhkLwEEevbGlp5BAAIQgAAEIAABCEAAAhCAQIwIINBjFCxchQAEIAABCEAAAhCAAAQgAIHsJYBAz97Y0jMIQAACEIAABCAAAQhAAAIQiBEBBHqMgoWrEIAABCAAAQhAAAIQgAAEIJC9BBDo2RtbegYBCEAAAhCAAAQgAAEIQAACMSKAQI9RsHAVAhCAAAQgAAEIQAACEIAABLKXAAI9e2NLzyAAAQhAAAIQgAAEIAABCEAgRgQQ6DEKFq5CAAIQgAAEIAABCEAAAhCAQPYSQKBnb2zpGQQgAAEIQAACEIAABCAAAQjEiAACPUbBwlUIQAACEIAABCAAAQhAAAIQyF4CCPTsjS09gwAEIAABCEAAAhCAAAQgAIEYEUCgxyhYuAoBCEAAAhCAAAQgAAEIQAAC2UsAgZ69saVnEIAABCAAAQhAAAIQgAAEIBAjAgj0GAULVyEAAQhAAAIQgAAEIAABCEAgewkg0LM3tvQMAhCAAAQgAAEIQAACEIAABGJEAIEeo2DhKgQgAAEIQAACEIAABCAAAQhkLwEEevbGlp5BAAIQgAAEIAABCEAAAhCAQIwIINBjFCxchQAEIAABCEAAAhCAAAQgAIHsJYBAz97Y0jMIQAACEIAABCAAAQhAAAIQiBEBBHqMgoWrEIAABCAAAQhAAAIQgAAEIJC9BBDo2RtbegYBCEAAAhCAAAQgAAEIQAACMSKAQI9RsHAVAhCAAAQgAAEIQAACEIAABLKXAAI9e2NLzyAAAQhAAAIQgAAEIAABCEAgRgQQ6DEKFq5CAAIQgAAEIAABCEAAAhCAQPYS+H+avjTXKkLTMgAAAABJRU5ErkJggg==\" width=\"1000\">"
+            ],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>solutions_bitstrings</th>\n",
+              "      <th>bitstrings_energies</th>\n",
+              "      <th>probabilities</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>1100</td>\n",
+              "      <td>27.0</td>\n",
+              "      <td>0.119885</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>1001</td>\n",
+              "      <td>27.0</td>\n",
+              "      <td>0.119885</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>1010</td>\n",
+              "      <td>32.0</td>\n",
+              "      <td>0.113245</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>0101</td>\n",
+              "      <td>32.0</td>\n",
+              "      <td>0.112614</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>0110</td>\n",
+              "      <td>35.0</td>\n",
+              "      <td>0.111264</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "  solutions_bitstrings  bitstrings_energies  probabilities\n",
+              "0                 1100                 27.0       0.119885\n",
+              "1                 1001                 27.0       0.119885\n",
+              "2                 1010                 32.0       0.113245\n",
+              "3                 0101                 32.0       0.112614\n",
+              "4                 0110                 35.0       0.111264"
+            ]
+          },
+          "execution_count": 193,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Initialize the QAOA object\n",
+        "qaoa = QAOA()\n",
+        "\n",
+        "# Set the parameters to use the QAOA algorithm\n",
+        "qaoa.set_backend_properties(n_shots=1024, seed_simulator=1)\n",
+        "# p=1, a custom type and range from 0 to pi\n",
+        "qaoa.set_circuit_properties(p=2, init_type=\"custom\", variational_params_dict={\"betas\":2*[0.01*np.pi],\"gammas\":2*[0.01*np.pi]})\n",
+        "#Indicate the ising e ncoding model from docplex\n",
+        "qaoa.compile(ising_encoding)\n",
+        "# Run the QAOA algorithm\n",
+        "qaoa.optimize()\n",
+        "\n",
+        "results_qaoa = qaoa.result\n",
+        "results_qaoa.plot_cost(label='Original')\n",
+        "pd.DataFrame(qaoa.result.lowest_cost_bitstrings(5))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "wURSjn_fRRQ0",
+        "outputId": "fcba395d-17f0-4791-8a70-2fc6c6187372"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "(27.0, ['1100', '1001'])"
+            ]
+          },
+          "execution_count": 194,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# To find the correct answer using ground_state_hamiltonian\n",
+        "# and the parameter is a cost_hamiltonian\n",
+        "correct_solution = ground_state_hamiltonian(qaoa.cost_hamil)\n",
+        "correct_solution"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "OcTebnHiRRQ0"
+      },
+      "source": [
+        "Validate your answer using docplex, you can see how to check the classical solution using the following tutorial [here](https://github.com/entropicalabs/openqaoa/blob/main/examples/community_tutorials/02_docplex_example.ipynb)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "a9rEXiPfRRQ1",
+        "outputId": "60896c68-54bf-4646-c08f-bf110e63b0f6"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "objective: 27.000\n",
+            "status: OPTIMAL_SOLUTION(2)\n",
+            "  q_0=1\n",
+            "  q_1=1\n",
+            "  q_2=0\n",
+            "  q_3=0\n"
+          ]
+        }
+      ],
+      "source": [
+        "## docplex solution\n",
+        "sol = mdl_qubo_docplex.solve()\n",
+        "mdl_qubo_docplex.print_solution(print_zeros=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "OZwGgvpARRQ1"
+      },
+      "source": [
+        "# Part 2: Improve the QAOA circuit\n",
+        "\n",
+        "Perform the same process as above now with the variant of using different backends, p values, and different optimizers until you find the one that can provide the correct answers with the least number of iterations, quantum circuit depth."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "eNlmpecRRRQ2",
+        "outputId": "f229cf8e-e563-460e-be25-26be76bec60f"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Optimized cost with AnnealingParams: 36.69610068004\n"
+          ]
+        },
+        {
+          "data": {
+            "application/javascript": [
+              "/* Put everything inside the global mpl namespace */\n",
+              "/* global mpl */\n",
+              "window.mpl = {};\n",
+              "\n",
+              "mpl.get_websocket_type = function () {\n",
+              "    if (typeof WebSocket !== 'undefined') {\n",
+              "        return WebSocket;\n",
+              "    } else if (typeof MozWebSocket !== 'undefined') {\n",
+              "        return MozWebSocket;\n",
+              "    } else {\n",
+              "        alert(\n",
+              "            'Your browser does not have WebSocket support. ' +\n",
+              "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+              "                'Firefox 4 and 5 are also supported but you ' +\n",
+              "                'have to enable WebSockets in about:config.'\n",
+              "        );\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
+              "    this.id = figure_id;\n",
+              "\n",
+              "    this.ws = websocket;\n",
+              "\n",
+              "    this.supports_binary = this.ws.binaryType !== undefined;\n",
+              "\n",
+              "    if (!this.supports_binary) {\n",
+              "        var warnings = document.getElementById('mpl-warnings');\n",
+              "        if (warnings) {\n",
+              "            warnings.style.display = 'block';\n",
+              "            warnings.textContent =\n",
+              "                'This browser does not support binary websocket messages. ' +\n",
+              "                'Performance may be slow.';\n",
+              "        }\n",
+              "    }\n",
+              "\n",
+              "    this.imageObj = new Image();\n",
+              "\n",
+              "    this.context = undefined;\n",
+              "    this.message = undefined;\n",
+              "    this.canvas = undefined;\n",
+              "    this.rubberband_canvas = undefined;\n",
+              "    this.rubberband_context = undefined;\n",
+              "    this.format_dropdown = undefined;\n",
+              "\n",
+              "    this.image_mode = 'full';\n",
+              "\n",
+              "    this.root = document.createElement('div');\n",
+              "    this.root.setAttribute('style', 'display: inline-block');\n",
+              "    this._root_extra_style(this.root);\n",
+              "\n",
+              "    parent_element.appendChild(this.root);\n",
+              "\n",
+              "    this._init_header(this);\n",
+              "    this._init_canvas(this);\n",
+              "    this._init_toolbar(this);\n",
+              "\n",
+              "    var fig = this;\n",
+              "\n",
+              "    this.waiting = false;\n",
+              "\n",
+              "    this.ws.onopen = function () {\n",
+              "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
+              "        fig.send_message('send_image_mode', {});\n",
+              "        if (fig.ratio !== 1) {\n",
+              "            fig.send_message('set_device_pixel_ratio', {\n",
+              "                device_pixel_ratio: fig.ratio,\n",
+              "            });\n",
+              "        }\n",
+              "        fig.send_message('refresh', {});\n",
+              "    };\n",
+              "\n",
+              "    this.imageObj.onload = function () {\n",
+              "        if (fig.image_mode === 'full') {\n",
+              "            // Full images could contain transparency (where diff images\n",
+              "            // almost always do), so we need to clear the canvas so that\n",
+              "            // there is no ghosting.\n",
+              "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+              "        }\n",
+              "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
+              "    };\n",
+              "\n",
+              "    this.imageObj.onunload = function () {\n",
+              "        fig.ws.close();\n",
+              "    };\n",
+              "\n",
+              "    this.ws.onmessage = this._make_on_message_function(this);\n",
+              "\n",
+              "    this.ondownload = ondownload;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_header = function () {\n",
+              "    var titlebar = document.createElement('div');\n",
+              "    titlebar.classList =\n",
+              "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
+              "    var titletext = document.createElement('div');\n",
+              "    titletext.classList = 'ui-dialog-title';\n",
+              "    titletext.setAttribute(\n",
+              "        'style',\n",
+              "        'width: 100%; text-align: center; padding: 3px;'\n",
+              "    );\n",
+              "    titlebar.appendChild(titletext);\n",
+              "    this.root.appendChild(titlebar);\n",
+              "    this.header = titletext;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
+              "\n",
+              "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
+              "\n",
+              "mpl.figure.prototype._init_canvas = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
+              "    canvas_div.setAttribute(\n",
+              "        'style',\n",
+              "        'border: 1px solid #ddd;' +\n",
+              "            'box-sizing: content-box;' +\n",
+              "            'clear: both;' +\n",
+              "            'min-height: 1px;' +\n",
+              "            'min-width: 1px;' +\n",
+              "            'outline: 0;' +\n",
+              "            'overflow: hidden;' +\n",
+              "            'position: relative;' +\n",
+              "            'resize: both;'\n",
+              "    );\n",
+              "\n",
+              "    function on_keyboard_event_closure(name) {\n",
+              "        return function (event) {\n",
+              "            return fig.key_event(event, name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    canvas_div.addEventListener(\n",
+              "        'keydown',\n",
+              "        on_keyboard_event_closure('key_press')\n",
+              "    );\n",
+              "    canvas_div.addEventListener(\n",
+              "        'keyup',\n",
+              "        on_keyboard_event_closure('key_release')\n",
+              "    );\n",
+              "\n",
+              "    this._canvas_extra_style(canvas_div);\n",
+              "    this.root.appendChild(canvas_div);\n",
+              "\n",
+              "    var canvas = (this.canvas = document.createElement('canvas'));\n",
+              "    canvas.classList.add('mpl-canvas');\n",
+              "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
+              "\n",
+              "    this.context = canvas.getContext('2d');\n",
+              "\n",
+              "    var backingStore =\n",
+              "        this.context.backingStorePixelRatio ||\n",
+              "        this.context.webkitBackingStorePixelRatio ||\n",
+              "        this.context.mozBackingStorePixelRatio ||\n",
+              "        this.context.msBackingStorePixelRatio ||\n",
+              "        this.context.oBackingStorePixelRatio ||\n",
+              "        this.context.backingStorePixelRatio ||\n",
+              "        1;\n",
+              "\n",
+              "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+              "\n",
+              "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
+              "        'canvas'\n",
+              "    ));\n",
+              "    rubberband_canvas.setAttribute(\n",
+              "        'style',\n",
+              "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
+              "    );\n",
+              "\n",
+              "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
+              "    if (this.ResizeObserver === undefined) {\n",
+              "        if (window.ResizeObserver !== undefined) {\n",
+              "            this.ResizeObserver = window.ResizeObserver;\n",
+              "        } else {\n",
+              "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
+              "            this.ResizeObserver = obs.ResizeObserver;\n",
+              "        }\n",
+              "    }\n",
+              "\n",
+              "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
+              "        var nentries = entries.length;\n",
+              "        for (var i = 0; i < nentries; i++) {\n",
+              "            var entry = entries[i];\n",
+              "            var width, height;\n",
+              "            if (entry.contentBoxSize) {\n",
+              "                if (entry.contentBoxSize instanceof Array) {\n",
+              "                    // Chrome 84 implements new version of spec.\n",
+              "                    width = entry.contentBoxSize[0].inlineSize;\n",
+              "                    height = entry.contentBoxSize[0].blockSize;\n",
+              "                } else {\n",
+              "                    // Firefox implements old version of spec.\n",
+              "                    width = entry.contentBoxSize.inlineSize;\n",
+              "                    height = entry.contentBoxSize.blockSize;\n",
+              "                }\n",
+              "            } else {\n",
+              "                // Chrome <84 implements even older version of spec.\n",
+              "                width = entry.contentRect.width;\n",
+              "                height = entry.contentRect.height;\n",
+              "            }\n",
+              "\n",
+              "            // Keep the size of the canvas and rubber band canvas in sync with\n",
+              "            // the canvas container.\n",
+              "            if (entry.devicePixelContentBoxSize) {\n",
+              "                // Chrome 84 implements new version of spec.\n",
+              "                canvas.setAttribute(\n",
+              "                    'width',\n",
+              "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
+              "                );\n",
+              "                canvas.setAttribute(\n",
+              "                    'height',\n",
+              "                    entry.devicePixelContentBoxSize[0].blockSize\n",
+              "                );\n",
+              "            } else {\n",
+              "                canvas.setAttribute('width', width * fig.ratio);\n",
+              "                canvas.setAttribute('height', height * fig.ratio);\n",
+              "            }\n",
+              "            canvas.setAttribute(\n",
+              "                'style',\n",
+              "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
+              "            );\n",
+              "\n",
+              "            rubberband_canvas.setAttribute('width', width);\n",
+              "            rubberband_canvas.setAttribute('height', height);\n",
+              "\n",
+              "            // And update the size in Python. We ignore the initial 0/0 size\n",
+              "            // that occurs as the element is placed into the DOM, which should\n",
+              "            // otherwise not happen due to the minimum size styling.\n",
+              "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
+              "                fig.request_resize(width, height);\n",
+              "            }\n",
+              "        }\n",
+              "    });\n",
+              "    this.resizeObserverInstance.observe(canvas_div);\n",
+              "\n",
+              "    function on_mouse_event_closure(name) {\n",
+              "        return function (event) {\n",
+              "            return fig.mouse_event(event, name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mousedown',\n",
+              "        on_mouse_event_closure('button_press')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseup',\n",
+              "        on_mouse_event_closure('button_release')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'dblclick',\n",
+              "        on_mouse_event_closure('dblclick')\n",
+              "    );\n",
+              "    // Throttle sequential mouse events to 1 every 20ms.\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mousemove',\n",
+              "        on_mouse_event_closure('motion_notify')\n",
+              "    );\n",
+              "\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseenter',\n",
+              "        on_mouse_event_closure('figure_enter')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseleave',\n",
+              "        on_mouse_event_closure('figure_leave')\n",
+              "    );\n",
+              "\n",
+              "    canvas_div.addEventListener('wheel', function (event) {\n",
+              "        if (event.deltaY < 0) {\n",
+              "            event.step = 1;\n",
+              "        } else {\n",
+              "            event.step = -1;\n",
+              "        }\n",
+              "        on_mouse_event_closure('scroll')(event);\n",
+              "    });\n",
+              "\n",
+              "    canvas_div.appendChild(canvas);\n",
+              "    canvas_div.appendChild(rubberband_canvas);\n",
+              "\n",
+              "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
+              "    this.rubberband_context.strokeStyle = '#000000';\n",
+              "\n",
+              "    this._resize_canvas = function (width, height, forward) {\n",
+              "        if (forward) {\n",
+              "            canvas_div.style.width = width + 'px';\n",
+              "            canvas_div.style.height = height + 'px';\n",
+              "        }\n",
+              "    };\n",
+              "\n",
+              "    // Disable right mouse context menu.\n",
+              "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
+              "        event.preventDefault();\n",
+              "        return false;\n",
+              "    });\n",
+              "\n",
+              "    function set_focus() {\n",
+              "        canvas.focus();\n",
+              "        canvas_div.focus();\n",
+              "    }\n",
+              "\n",
+              "    window.setTimeout(set_focus, 100);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_toolbar = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var toolbar = document.createElement('div');\n",
+              "    toolbar.classList = 'mpl-toolbar';\n",
+              "    this.root.appendChild(toolbar);\n",
+              "\n",
+              "    function on_click_closure(name) {\n",
+              "        return function (_event) {\n",
+              "            return fig.toolbar_button_onclick(name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    function on_mouseover_closure(tooltip) {\n",
+              "        return function (event) {\n",
+              "            if (!event.currentTarget.disabled) {\n",
+              "                return fig.toolbar_button_onmouseover(tooltip);\n",
+              "            }\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    fig.buttons = {};\n",
+              "    var buttonGroup = document.createElement('div');\n",
+              "    buttonGroup.classList = 'mpl-button-group';\n",
+              "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+              "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+              "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+              "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+              "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+              "\n",
+              "        if (!name) {\n",
+              "            /* Instead of a spacer, we start a new button group. */\n",
+              "            if (buttonGroup.hasChildNodes()) {\n",
+              "                toolbar.appendChild(buttonGroup);\n",
+              "            }\n",
+              "            buttonGroup = document.createElement('div');\n",
+              "            buttonGroup.classList = 'mpl-button-group';\n",
+              "            continue;\n",
+              "        }\n",
+              "\n",
+              "        var button = (fig.buttons[name] = document.createElement('button'));\n",
+              "        button.classList = 'mpl-widget';\n",
+              "        button.setAttribute('role', 'button');\n",
+              "        button.setAttribute('aria-disabled', 'false');\n",
+              "        button.addEventListener('click', on_click_closure(method_name));\n",
+              "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+              "\n",
+              "        var icon_img = document.createElement('img');\n",
+              "        icon_img.src = '_images/' + image + '.png';\n",
+              "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
+              "        icon_img.alt = tooltip;\n",
+              "        button.appendChild(icon_img);\n",
+              "\n",
+              "        buttonGroup.appendChild(button);\n",
+              "    }\n",
+              "\n",
+              "    if (buttonGroup.hasChildNodes()) {\n",
+              "        toolbar.appendChild(buttonGroup);\n",
+              "    }\n",
+              "\n",
+              "    var fmt_picker = document.createElement('select');\n",
+              "    fmt_picker.classList = 'mpl-widget';\n",
+              "    toolbar.appendChild(fmt_picker);\n",
+              "    this.format_dropdown = fmt_picker;\n",
+              "\n",
+              "    for (var ind in mpl.extensions) {\n",
+              "        var fmt = mpl.extensions[ind];\n",
+              "        var option = document.createElement('option');\n",
+              "        option.selected = fmt === mpl.default_extension;\n",
+              "        option.innerHTML = fmt;\n",
+              "        fmt_picker.appendChild(option);\n",
+              "    }\n",
+              "\n",
+              "    var status_bar = document.createElement('span');\n",
+              "    status_bar.classList = 'mpl-message';\n",
+              "    toolbar.appendChild(status_bar);\n",
+              "    this.message = status_bar;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
+              "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+              "    // which will in turn request a refresh of the image.\n",
+              "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.send_message = function (type, properties) {\n",
+              "    properties['type'] = type;\n",
+              "    properties['figure_id'] = this.id;\n",
+              "    this.ws.send(JSON.stringify(properties));\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.send_draw_message = function () {\n",
+              "    if (!this.waiting) {\n",
+              "        this.waiting = true;\n",
+              "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+              "    var format_dropdown = fig.format_dropdown;\n",
+              "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+              "    fig.ondownload(fig, format);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
+              "    var size = msg['size'];\n",
+              "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
+              "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
+              "        fig.send_message('refresh', {});\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
+              "    var x0 = msg['x0'] / fig.ratio;\n",
+              "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
+              "    var x1 = msg['x1'] / fig.ratio;\n",
+              "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
+              "    x0 = Math.floor(x0) + 0.5;\n",
+              "    y0 = Math.floor(y0) + 0.5;\n",
+              "    x1 = Math.floor(x1) + 0.5;\n",
+              "    y1 = Math.floor(y1) + 0.5;\n",
+              "    var min_x = Math.min(x0, x1);\n",
+              "    var min_y = Math.min(y0, y1);\n",
+              "    var width = Math.abs(x1 - x0);\n",
+              "    var height = Math.abs(y1 - y0);\n",
+              "\n",
+              "    fig.rubberband_context.clearRect(\n",
+              "        0,\n",
+              "        0,\n",
+              "        fig.canvas.width / fig.ratio,\n",
+              "        fig.canvas.height / fig.ratio\n",
+              "    );\n",
+              "\n",
+              "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
+              "    // Updates the figure title.\n",
+              "    fig.header.textContent = msg['label'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
+              "    fig.rubberband_canvas.style.cursor = msg['cursor'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
+              "    fig.message.textContent = msg['message'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
+              "    // Request the server to send over a new figure.\n",
+              "    fig.send_draw_message();\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
+              "    fig.image_mode = msg['mode'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
+              "    for (var key in msg) {\n",
+              "        if (!(key in fig.buttons)) {\n",
+              "            continue;\n",
+              "        }\n",
+              "        fig.buttons[key].disabled = !msg[key];\n",
+              "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
+              "    if (msg['mode'] === 'PAN') {\n",
+              "        fig.buttons['Pan'].classList.add('active');\n",
+              "        fig.buttons['Zoom'].classList.remove('active');\n",
+              "    } else if (msg['mode'] === 'ZOOM') {\n",
+              "        fig.buttons['Pan'].classList.remove('active');\n",
+              "        fig.buttons['Zoom'].classList.add('active');\n",
+              "    } else {\n",
+              "        fig.buttons['Pan'].classList.remove('active');\n",
+              "        fig.buttons['Zoom'].classList.remove('active');\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.updated_canvas_event = function () {\n",
+              "    // Called whenever the canvas gets updated.\n",
+              "    this.send_message('ack', {});\n",
+              "};\n",
+              "\n",
+              "// A function to construct a web socket function for onmessage handling.\n",
+              "// Called in the figure constructor.\n",
+              "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
+              "    return function socket_on_message(evt) {\n",
+              "        if (evt.data instanceof Blob) {\n",
+              "            var img = evt.data;\n",
+              "            if (img.type !== 'image/png') {\n",
+              "                /* FIXME: We get \"Resource interpreted as Image but\n",
+              "                 * transferred with MIME type text/plain:\" errors on\n",
+              "                 * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+              "                 * to be part of the websocket stream */\n",
+              "                img.type = 'image/png';\n",
+              "            }\n",
+              "\n",
+              "            /* Free the memory for the previous frames */\n",
+              "            if (fig.imageObj.src) {\n",
+              "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+              "                    fig.imageObj.src\n",
+              "                );\n",
+              "            }\n",
+              "\n",
+              "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+              "                img\n",
+              "            );\n",
+              "            fig.updated_canvas_event();\n",
+              "            fig.waiting = false;\n",
+              "            return;\n",
+              "        } else if (\n",
+              "            typeof evt.data === 'string' &&\n",
+              "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
+              "        ) {\n",
+              "            fig.imageObj.src = evt.data;\n",
+              "            fig.updated_canvas_event();\n",
+              "            fig.waiting = false;\n",
+              "            return;\n",
+              "        }\n",
+              "\n",
+              "        var msg = JSON.parse(evt.data);\n",
+              "        var msg_type = msg['type'];\n",
+              "\n",
+              "        // Call the  \"handle_{type}\" callback, which takes\n",
+              "        // the figure and JSON message as its only arguments.\n",
+              "        try {\n",
+              "            var callback = fig['handle_' + msg_type];\n",
+              "        } catch (e) {\n",
+              "            console.log(\n",
+              "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
+              "                msg\n",
+              "            );\n",
+              "            return;\n",
+              "        }\n",
+              "\n",
+              "        if (callback) {\n",
+              "            try {\n",
+              "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+              "                callback(fig, msg);\n",
+              "            } catch (e) {\n",
+              "                console.log(\n",
+              "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
+              "                    e,\n",
+              "                    e.stack,\n",
+              "                    msg\n",
+              "                );\n",
+              "            }\n",
+              "        }\n",
+              "    };\n",
+              "};\n",
+              "\n",
+              "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+              "mpl.findpos = function (e) {\n",
+              "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+              "    var targ;\n",
+              "    if (!e) {\n",
+              "        e = window.event;\n",
+              "    }\n",
+              "    if (e.target) {\n",
+              "        targ = e.target;\n",
+              "    } else if (e.srcElement) {\n",
+              "        targ = e.srcElement;\n",
+              "    }\n",
+              "    if (targ.nodeType === 3) {\n",
+              "        // defeat Safari bug\n",
+              "        targ = targ.parentNode;\n",
+              "    }\n",
+              "\n",
+              "    // pageX,Y are the mouse positions relative to the document\n",
+              "    var boundingRect = targ.getBoundingClientRect();\n",
+              "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
+              "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
+              "\n",
+              "    return { x: x, y: y };\n",
+              "};\n",
+              "\n",
+              "/*\n",
+              " * return a copy of an object with only non-object keys\n",
+              " * we need this to avoid circular references\n",
+              " * https://stackoverflow.com/a/24161582/3208463\n",
+              " */\n",
+              "function simpleKeys(original) {\n",
+              "    return Object.keys(original).reduce(function (obj, key) {\n",
+              "        if (typeof original[key] !== 'object') {\n",
+              "            obj[key] = original[key];\n",
+              "        }\n",
+              "        return obj;\n",
+              "    }, {});\n",
+              "}\n",
+              "\n",
+              "mpl.figure.prototype.mouse_event = function (event, name) {\n",
+              "    var canvas_pos = mpl.findpos(event);\n",
+              "\n",
+              "    if (name === 'button_press') {\n",
+              "        this.canvas.focus();\n",
+              "        this.canvas_div.focus();\n",
+              "    }\n",
+              "\n",
+              "    var x = canvas_pos.x * this.ratio;\n",
+              "    var y = canvas_pos.y * this.ratio;\n",
+              "\n",
+              "    this.send_message(name, {\n",
+              "        x: x,\n",
+              "        y: y,\n",
+              "        button: event.button,\n",
+              "        step: event.step,\n",
+              "        guiEvent: simpleKeys(event),\n",
+              "    });\n",
+              "\n",
+              "    /* This prevents the web browser from automatically changing to\n",
+              "     * the text insertion cursor when the button is pressed.  We want\n",
+              "     * to control all of the cursor setting manually through the\n",
+              "     * 'cursor' event from matplotlib */\n",
+              "    event.preventDefault();\n",
+              "    return false;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
+              "    // Handle any extra behaviour associated with a key event\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.key_event = function (event, name) {\n",
+              "    // Prevent repeat events\n",
+              "    if (name === 'key_press') {\n",
+              "        if (event.key === this._key) {\n",
+              "            return;\n",
+              "        } else {\n",
+              "            this._key = event.key;\n",
+              "        }\n",
+              "    }\n",
+              "    if (name === 'key_release') {\n",
+              "        this._key = null;\n",
+              "    }\n",
+              "\n",
+              "    var value = '';\n",
+              "    if (event.ctrlKey && event.key !== 'Control') {\n",
+              "        value += 'ctrl+';\n",
+              "    }\n",
+              "    else if (event.altKey && event.key !== 'Alt') {\n",
+              "        value += 'alt+';\n",
+              "    }\n",
+              "    else if (event.shiftKey && event.key !== 'Shift') {\n",
+              "        value += 'shift+';\n",
+              "    }\n",
+              "\n",
+              "    value += 'k' + event.key;\n",
+              "\n",
+              "    this._key_event_extra(event, name);\n",
+              "\n",
+              "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
+              "    return false;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
+              "    if (name === 'download') {\n",
+              "        this.handle_save(this, null);\n",
+              "    } else {\n",
+              "        this.send_message('toolbar_button', { name: name });\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
+              "    this.message.textContent = tooltip;\n",
+              "};\n",
+              "\n",
+              "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
+              "// prettier-ignore\n",
+              "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
+              "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+              "\n",
+              "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+              "\n",
+              "mpl.default_extension = \"png\";/* global mpl */\n",
+              "\n",
+              "var comm_websocket_adapter = function (comm) {\n",
+              "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+              "    // object with the appropriate methods. Currently this is a non binary\n",
+              "    // socket, so there is still some room for performance tuning.\n",
+              "    var ws = {};\n",
+              "\n",
+              "    ws.binaryType = comm.kernel.ws.binaryType;\n",
+              "    ws.readyState = comm.kernel.ws.readyState;\n",
+              "    function updateReadyState(_event) {\n",
+              "        if (comm.kernel.ws) {\n",
+              "            ws.readyState = comm.kernel.ws.readyState;\n",
+              "        } else {\n",
+              "            ws.readyState = 3; // Closed state.\n",
+              "        }\n",
+              "    }\n",
+              "    comm.kernel.ws.addEventListener('open', updateReadyState);\n",
+              "    comm.kernel.ws.addEventListener('close', updateReadyState);\n",
+              "    comm.kernel.ws.addEventListener('error', updateReadyState);\n",
+              "\n",
+              "    ws.close = function () {\n",
+              "        comm.close();\n",
+              "    };\n",
+              "    ws.send = function (m) {\n",
+              "        //console.log('sending', m);\n",
+              "        comm.send(m);\n",
+              "    };\n",
+              "    // Register the callback with on_msg.\n",
+              "    comm.on_msg(function (msg) {\n",
+              "        //console.log('receiving', msg['content']['data'], msg);\n",
+              "        var data = msg['content']['data'];\n",
+              "        if (data['blob'] !== undefined) {\n",
+              "            data = {\n",
+              "                data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
+              "            };\n",
+              "        }\n",
+              "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+              "        ws.onmessage(data);\n",
+              "    });\n",
+              "    return ws;\n",
+              "};\n",
+              "\n",
+              "mpl.mpl_figure_comm = function (comm, msg) {\n",
+              "    // This is the function which gets called when the mpl process\n",
+              "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+              "\n",
+              "    var id = msg.content.data.id;\n",
+              "    // Get hold of the div created by the display call when the Comm\n",
+              "    // socket was opened in Python.\n",
+              "    var element = document.getElementById(id);\n",
+              "    var ws_proxy = comm_websocket_adapter(comm);\n",
+              "\n",
+              "    function ondownload(figure, _format) {\n",
+              "        window.open(figure.canvas.toDataURL());\n",
+              "    }\n",
+              "\n",
+              "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
+              "\n",
+              "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+              "    // web socket which is closed, not our websocket->open comm proxy.\n",
+              "    ws_proxy.onopen();\n",
+              "\n",
+              "    fig.parent_element = element;\n",
+              "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+              "    if (!fig.cell_info) {\n",
+              "        console.error('Failed to find cell for figure', id, fig);\n",
+              "        return;\n",
+              "    }\n",
+              "    fig.cell_info[0].output_area.element.on(\n",
+              "        'cleared',\n",
+              "        { fig: fig },\n",
+              "        fig._remove_fig_handler\n",
+              "    );\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
+              "    var width = fig.canvas.width / fig.ratio;\n",
+              "    fig.cell_info[0].output_area.element.off(\n",
+              "        'cleared',\n",
+              "        fig._remove_fig_handler\n",
+              "    );\n",
+              "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
+              "\n",
+              "    // Update the output cell to use the data from the current canvas.\n",
+              "    fig.push_to_output();\n",
+              "    var dataURL = fig.canvas.toDataURL();\n",
+              "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+              "    // the notebook keyboard shortcuts fail.\n",
+              "    IPython.keyboard_manager.enable();\n",
+              "    fig.parent_element.innerHTML =\n",
+              "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+              "    fig.close_ws(fig, msg);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
+              "    fig.send_message('closing', msg);\n",
+              "    // fig.ws.close()\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
+              "    // Turn the data on the canvas into data in the output cell.\n",
+              "    var width = this.canvas.width / this.ratio;\n",
+              "    var dataURL = this.canvas.toDataURL();\n",
+              "    this.cell_info[1]['text/html'] =\n",
+              "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.updated_canvas_event = function () {\n",
+              "    // Tell IPython that the notebook contents must change.\n",
+              "    IPython.notebook.set_dirty(true);\n",
+              "    this.send_message('ack', {});\n",
+              "    var fig = this;\n",
+              "    // Wait a second, then push the new image to the DOM so\n",
+              "    // that it is saved nicely (might be nice to debounce this).\n",
+              "    setTimeout(function () {\n",
+              "        fig.push_to_output();\n",
+              "    }, 1000);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_toolbar = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var toolbar = document.createElement('div');\n",
+              "    toolbar.classList = 'btn-toolbar';\n",
+              "    this.root.appendChild(toolbar);\n",
+              "\n",
+              "    function on_click_closure(name) {\n",
+              "        return function (_event) {\n",
+              "            return fig.toolbar_button_onclick(name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    function on_mouseover_closure(tooltip) {\n",
+              "        return function (event) {\n",
+              "            if (!event.currentTarget.disabled) {\n",
+              "                return fig.toolbar_button_onmouseover(tooltip);\n",
+              "            }\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    fig.buttons = {};\n",
+              "    var buttonGroup = document.createElement('div');\n",
+              "    buttonGroup.classList = 'btn-group';\n",
+              "    var button;\n",
+              "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+              "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+              "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+              "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+              "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+              "\n",
+              "        if (!name) {\n",
+              "            /* Instead of a spacer, we start a new button group. */\n",
+              "            if (buttonGroup.hasChildNodes()) {\n",
+              "                toolbar.appendChild(buttonGroup);\n",
+              "            }\n",
+              "            buttonGroup = document.createElement('div');\n",
+              "            buttonGroup.classList = 'btn-group';\n",
+              "            continue;\n",
+              "        }\n",
+              "\n",
+              "        button = fig.buttons[name] = document.createElement('button');\n",
+              "        button.classList = 'btn btn-default';\n",
+              "        button.href = '#';\n",
+              "        button.title = name;\n",
+              "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
+              "        button.addEventListener('click', on_click_closure(method_name));\n",
+              "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+              "        buttonGroup.appendChild(button);\n",
+              "    }\n",
+              "\n",
+              "    if (buttonGroup.hasChildNodes()) {\n",
+              "        toolbar.appendChild(buttonGroup);\n",
+              "    }\n",
+              "\n",
+              "    // Add the status bar.\n",
+              "    var status_bar = document.createElement('span');\n",
+              "    status_bar.classList = 'mpl-message pull-right';\n",
+              "    toolbar.appendChild(status_bar);\n",
+              "    this.message = status_bar;\n",
+              "\n",
+              "    // Add the close button to the window.\n",
+              "    var buttongrp = document.createElement('div');\n",
+              "    buttongrp.classList = 'btn-group inline pull-right';\n",
+              "    button = document.createElement('button');\n",
+              "    button.classList = 'btn btn-mini btn-primary';\n",
+              "    button.href = '#';\n",
+              "    button.title = 'Stop Interaction';\n",
+              "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
+              "    button.addEventListener('click', function (_evt) {\n",
+              "        fig.handle_close(fig, {});\n",
+              "    });\n",
+              "    button.addEventListener(\n",
+              "        'mouseover',\n",
+              "        on_mouseover_closure('Stop Interaction')\n",
+              "    );\n",
+              "    buttongrp.appendChild(button);\n",
+              "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
+              "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
+              "    var fig = event.data.fig;\n",
+              "    if (event.target !== this) {\n",
+              "        // Ignore bubbled events from children.\n",
+              "        return;\n",
+              "    }\n",
+              "    fig.close_ws(fig, {});\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._root_extra_style = function (el) {\n",
+              "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
+              "    // this is important to make the div 'focusable\n",
+              "    el.setAttribute('tabindex', 0);\n",
+              "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+              "    // off when our div gets focus\n",
+              "\n",
+              "    // location in version 3\n",
+              "    if (IPython.notebook.keyboard_manager) {\n",
+              "        IPython.notebook.keyboard_manager.register_events(el);\n",
+              "    } else {\n",
+              "        // location in version 2\n",
+              "        IPython.keyboard_manager.register_events(el);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
+              "    // Check for shift+enter\n",
+              "    if (event.shiftKey && event.which === 13) {\n",
+              "        this.canvas_div.blur();\n",
+              "        // select the cell after this one\n",
+              "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
+              "        IPython.notebook.select(index + 1);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+              "    fig.ondownload(fig, null);\n",
+              "};\n",
+              "\n",
+              "mpl.find_output_cell = function (html_output) {\n",
+              "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+              "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+              "    // IPython event is triggered only after the cells have been serialised, which for\n",
+              "    // our purposes (turning an active figure into a static one), is too late.\n",
+              "    var cells = IPython.notebook.get_cells();\n",
+              "    var ncells = cells.length;\n",
+              "    for (var i = 0; i < ncells; i++) {\n",
+              "        var cell = cells[i];\n",
+              "        if (cell.cell_type === 'code') {\n",
+              "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
+              "                var data = cell.output_area.outputs[j];\n",
+              "                if (data.data) {\n",
+              "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+              "                    data = data.data;\n",
+              "                }\n",
+              "                if (data['text/html'] === html_output) {\n",
+              "                    return [cell, data, j];\n",
+              "                }\n",
+              "            }\n",
+              "        }\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "// Register the function which deals with the matplotlib target/channel.\n",
+              "// The kernel may be null if the page has been refreshed.\n",
+              "if (IPython.notebook.kernel !== null) {\n",
+              "    IPython.notebook.kernel.comm_manager.register_target(\n",
+              "        'matplotlib',\n",
+              "        mpl.mpl_figure_comm\n",
+              "    );\n",
+              "}\n"
+            ],
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/html": [
+              "<img src=\"data:image/png;base64,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\" width=\"800\">"
+            ],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "## Implementation\n",
+        "\n",
+        "# Modeling with statevector_simulator\n",
+        "q_sv = QAOA()\n",
+        "qiskit_sv = create_device(location='local', name='qiskit.statevector_simulator')\n",
+        "q_sv.set_device(qiskit_sv)\n",
+        "q_sv.set_circuit_properties(p=2, param_type='standard', init_type='rand', mixer_hamiltonian='x')\n",
+        "q_sv.set_classical_optimizer(method='COBYLA', maxiter=400, tol=0.001, cost_progress=True, parameter_log=True)\n",
+        "\n",
+        "q_sv.compile(ising_encoding)\n",
+        "q_sv.optimize()\n",
+        "results_sv = q_sv.result\n",
+        "#pd.DataFrame(q_sv.result.lowest_cost_bitstrings(5))\n",
+        "\n",
+        "# Modeling with shot-based simulator\n",
+        "q_shot = QAOA()\n",
+        "qiskit_shot = create_device(location='local', name='qiskit.qasm_simulator')\n",
+        "q_shot.set_device(qiskit_shot)\n",
+        "q_shot.set_circuit_properties(p=2, param_type='standard', init_type='rand', mixer_hamiltonian='x')\n",
+        "q_shot.set_backend_properties(n_shots = 400)\n",
+        "q_shot.set_classical_optimizer(method='COBYLA', maxiter=400, tol=0.001, cost_progress=True, parameter_log=True)\n",
+        "\n",
+        "q_shot.compile(ising_encoding)\n",
+        "q_shot.optimize()\n",
+        "results_shot = q_shot.result\n",
+        "pd.DataFrame(q_shot.result.lowest_cost_bitstrings(5))\n",
+        "\n",
+        "# Modeling with annealing parameterization\n",
+        "q_annealing = QAOA()\n",
+        "p=6\n",
+        "q_annealing.set_circuit_properties(p=p, param_type='annealing', init_type='ramp')\n",
+        "q_annealing.set_classical_optimizer(maxiter=100)\n",
+        "q_annealing.compile(ising_encoding)\n",
+        "q_annealing.optimize()\n",
+        "results_annealing = q_annealing.result\n",
+        "print(\"Optimized cost with AnnealingParams:\", q_annealing.result.optimized['cost'])\n",
+        "# annealing optimized schedule\n",
+        "opt_schedule = q_annealing.result.optimized['angles']\n",
+        "p_i = range(1,p+1)\n",
+        "fig = plt.figure(figsize=(8,5))\n",
+        "plt.plot(p_i,opt_schedule,lw=0.3,ls='--',marker='o')\n",
+        "plt.xlabel('p')\n",
+        "plt.title(f'Optimized annealing (discrete) schedule for p={p}');\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "PWpQZ1F4RRQ2"
+      },
+      "source": [
+        "# Part 3: Noise Model\n",
+        "\n",
+        "The optimal combination that you found with the best optimizer, the lowest number of $p$'s and the correct answer, can give the same answer with noise, use the circuit with a noise model and identify if it gives the same answer."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ErC1FJCzRRQ3",
+        "outputId": "9f9960e8-2979-40b6-9811-2c8e4c1045b7"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>solutions_bitstrings</th>\n",
+              "      <th>bitstrings_energies</th>\n",
+              "      <th>probabilities</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>1100</td>\n",
+              "      <td>27.0</td>\n",
+              "      <td>0.005</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>1001</td>\n",
+              "      <td>27.0</td>\n",
+              "      <td>0.010</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>0101</td>\n",
+              "      <td>32.0</td>\n",
+              "      <td>0.140</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>1010</td>\n",
+              "      <td>32.0</td>\n",
+              "      <td>0.095</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>0110</td>\n",
+              "      <td>35.0</td>\n",
+              "      <td>0.140</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "  solutions_bitstrings  bitstrings_energies  probabilities\n",
+              "0                 1100                 27.0          0.005\n",
+              "1                 1001                 27.0          0.010\n",
+              "2                 0101                 32.0          0.140\n",
+              "3                 1010                 32.0          0.095\n",
+              "4                 0110                 35.0          0.140"
+            ]
+          },
+          "execution_count": 204,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# implementation using a noise model using qiskit\n",
+        "from qiskit.providers.fake_provider import FakeManila\n",
+        "from qiskit.providers.aer.noise import NoiseModel\n",
+        "from qiskit.providers.aer import QasmSimulator\n",
+        "\n",
+        "# Modeling with noisy shot-based simulator\n",
+        "device_backend = FakeManila()\n",
+        "device = QasmSimulator.from_backend(device_backend)\n",
+        "noise_model = NoiseModel.from_backend(device)\n",
+        "\n",
+        "q_noisy_shot = QAOA()\n",
+        "qiskit_noisy_shot = create_device(location='local', name='qiskit.qasm_simulator')\n",
+        "q_noisy_shot.set_device(qiskit_noisy_shot)\n",
+        "q_noisy_shot.set_circuit_properties(p=2, param_type='standard', init_type='rand', mixer_hamiltonian='x')\n",
+        "q_noisy_shot.set_backend_properties(n_shots = 200, noise_model = noise_model)\n",
+        "q_noisy_shot.set_classical_optimizer(method='COBYLA', maxiter=400, tol=0.001, cost_progress=True, parameter_log=True)\n",
+        "\n",
+        "q_noisy_shot.compile(ising_encoding)\n",
+        "q_noisy_shot.optimize()\n",
+        "results_noisy_shot = q_noisy_shot.result\n",
+        "pd.DataFrame(q_noisy_shot.result.lowest_cost_bitstrings(5))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Azlj93FaRRQ3"
+      },
+      "source": [
+        "# Part 4: Model comparison"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "nqoBITCgRRQ3",
+        "outputId": "cd649b98-d563-425d-8c79-bfeca8bd89ce"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/javascript": [
+              "/* Put everything inside the global mpl namespace */\n",
+              "/* global mpl */\n",
+              "window.mpl = {};\n",
+              "\n",
+              "mpl.get_websocket_type = function () {\n",
+              "    if (typeof WebSocket !== 'undefined') {\n",
+              "        return WebSocket;\n",
+              "    } else if (typeof MozWebSocket !== 'undefined') {\n",
+              "        return MozWebSocket;\n",
+              "    } else {\n",
+              "        alert(\n",
+              "            'Your browser does not have WebSocket support. ' +\n",
+              "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+              "                'Firefox 4 and 5 are also supported but you ' +\n",
+              "                'have to enable WebSockets in about:config.'\n",
+              "        );\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
+              "    this.id = figure_id;\n",
+              "\n",
+              "    this.ws = websocket;\n",
+              "\n",
+              "    this.supports_binary = this.ws.binaryType !== undefined;\n",
+              "\n",
+              "    if (!this.supports_binary) {\n",
+              "        var warnings = document.getElementById('mpl-warnings');\n",
+              "        if (warnings) {\n",
+              "            warnings.style.display = 'block';\n",
+              "            warnings.textContent =\n",
+              "                'This browser does not support binary websocket messages. ' +\n",
+              "                'Performance may be slow.';\n",
+              "        }\n",
+              "    }\n",
+              "\n",
+              "    this.imageObj = new Image();\n",
+              "\n",
+              "    this.context = undefined;\n",
+              "    this.message = undefined;\n",
+              "    this.canvas = undefined;\n",
+              "    this.rubberband_canvas = undefined;\n",
+              "    this.rubberband_context = undefined;\n",
+              "    this.format_dropdown = undefined;\n",
+              "\n",
+              "    this.image_mode = 'full';\n",
+              "\n",
+              "    this.root = document.createElement('div');\n",
+              "    this.root.setAttribute('style', 'display: inline-block');\n",
+              "    this._root_extra_style(this.root);\n",
+              "\n",
+              "    parent_element.appendChild(this.root);\n",
+              "\n",
+              "    this._init_header(this);\n",
+              "    this._init_canvas(this);\n",
+              "    this._init_toolbar(this);\n",
+              "\n",
+              "    var fig = this;\n",
+              "\n",
+              "    this.waiting = false;\n",
+              "\n",
+              "    this.ws.onopen = function () {\n",
+              "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
+              "        fig.send_message('send_image_mode', {});\n",
+              "        if (fig.ratio !== 1) {\n",
+              "            fig.send_message('set_device_pixel_ratio', {\n",
+              "                device_pixel_ratio: fig.ratio,\n",
+              "            });\n",
+              "        }\n",
+              "        fig.send_message('refresh', {});\n",
+              "    };\n",
+              "\n",
+              "    this.imageObj.onload = function () {\n",
+              "        if (fig.image_mode === 'full') {\n",
+              "            // Full images could contain transparency (where diff images\n",
+              "            // almost always do), so we need to clear the canvas so that\n",
+              "            // there is no ghosting.\n",
+              "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+              "        }\n",
+              "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
+              "    };\n",
+              "\n",
+              "    this.imageObj.onunload = function () {\n",
+              "        fig.ws.close();\n",
+              "    };\n",
+              "\n",
+              "    this.ws.onmessage = this._make_on_message_function(this);\n",
+              "\n",
+              "    this.ondownload = ondownload;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_header = function () {\n",
+              "    var titlebar = document.createElement('div');\n",
+              "    titlebar.classList =\n",
+              "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
+              "    var titletext = document.createElement('div');\n",
+              "    titletext.classList = 'ui-dialog-title';\n",
+              "    titletext.setAttribute(\n",
+              "        'style',\n",
+              "        'width: 100%; text-align: center; padding: 3px;'\n",
+              "    );\n",
+              "    titlebar.appendChild(titletext);\n",
+              "    this.root.appendChild(titlebar);\n",
+              "    this.header = titletext;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
+              "\n",
+              "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
+              "\n",
+              "mpl.figure.prototype._init_canvas = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
+              "    canvas_div.setAttribute(\n",
+              "        'style',\n",
+              "        'border: 1px solid #ddd;' +\n",
+              "            'box-sizing: content-box;' +\n",
+              "            'clear: both;' +\n",
+              "            'min-height: 1px;' +\n",
+              "            'min-width: 1px;' +\n",
+              "            'outline: 0;' +\n",
+              "            'overflow: hidden;' +\n",
+              "            'position: relative;' +\n",
+              "            'resize: both;'\n",
+              "    );\n",
+              "\n",
+              "    function on_keyboard_event_closure(name) {\n",
+              "        return function (event) {\n",
+              "            return fig.key_event(event, name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    canvas_div.addEventListener(\n",
+              "        'keydown',\n",
+              "        on_keyboard_event_closure('key_press')\n",
+              "    );\n",
+              "    canvas_div.addEventListener(\n",
+              "        'keyup',\n",
+              "        on_keyboard_event_closure('key_release')\n",
+              "    );\n",
+              "\n",
+              "    this._canvas_extra_style(canvas_div);\n",
+              "    this.root.appendChild(canvas_div);\n",
+              "\n",
+              "    var canvas = (this.canvas = document.createElement('canvas'));\n",
+              "    canvas.classList.add('mpl-canvas');\n",
+              "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
+              "\n",
+              "    this.context = canvas.getContext('2d');\n",
+              "\n",
+              "    var backingStore =\n",
+              "        this.context.backingStorePixelRatio ||\n",
+              "        this.context.webkitBackingStorePixelRatio ||\n",
+              "        this.context.mozBackingStorePixelRatio ||\n",
+              "        this.context.msBackingStorePixelRatio ||\n",
+              "        this.context.oBackingStorePixelRatio ||\n",
+              "        this.context.backingStorePixelRatio ||\n",
+              "        1;\n",
+              "\n",
+              "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+              "\n",
+              "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
+              "        'canvas'\n",
+              "    ));\n",
+              "    rubberband_canvas.setAttribute(\n",
+              "        'style',\n",
+              "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
+              "    );\n",
+              "\n",
+              "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
+              "    if (this.ResizeObserver === undefined) {\n",
+              "        if (window.ResizeObserver !== undefined) {\n",
+              "            this.ResizeObserver = window.ResizeObserver;\n",
+              "        } else {\n",
+              "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
+              "            this.ResizeObserver = obs.ResizeObserver;\n",
+              "        }\n",
+              "    }\n",
+              "\n",
+              "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
+              "        var nentries = entries.length;\n",
+              "        for (var i = 0; i < nentries; i++) {\n",
+              "            var entry = entries[i];\n",
+              "            var width, height;\n",
+              "            if (entry.contentBoxSize) {\n",
+              "                if (entry.contentBoxSize instanceof Array) {\n",
+              "                    // Chrome 84 implements new version of spec.\n",
+              "                    width = entry.contentBoxSize[0].inlineSize;\n",
+              "                    height = entry.contentBoxSize[0].blockSize;\n",
+              "                } else {\n",
+              "                    // Firefox implements old version of spec.\n",
+              "                    width = entry.contentBoxSize.inlineSize;\n",
+              "                    height = entry.contentBoxSize.blockSize;\n",
+              "                }\n",
+              "            } else {\n",
+              "                // Chrome <84 implements even older version of spec.\n",
+              "                width = entry.contentRect.width;\n",
+              "                height = entry.contentRect.height;\n",
+              "            }\n",
+              "\n",
+              "            // Keep the size of the canvas and rubber band canvas in sync with\n",
+              "            // the canvas container.\n",
+              "            if (entry.devicePixelContentBoxSize) {\n",
+              "                // Chrome 84 implements new version of spec.\n",
+              "                canvas.setAttribute(\n",
+              "                    'width',\n",
+              "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
+              "                );\n",
+              "                canvas.setAttribute(\n",
+              "                    'height',\n",
+              "                    entry.devicePixelContentBoxSize[0].blockSize\n",
+              "                );\n",
+              "            } else {\n",
+              "                canvas.setAttribute('width', width * fig.ratio);\n",
+              "                canvas.setAttribute('height', height * fig.ratio);\n",
+              "            }\n",
+              "            canvas.setAttribute(\n",
+              "                'style',\n",
+              "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
+              "            );\n",
+              "\n",
+              "            rubberband_canvas.setAttribute('width', width);\n",
+              "            rubberband_canvas.setAttribute('height', height);\n",
+              "\n",
+              "            // And update the size in Python. We ignore the initial 0/0 size\n",
+              "            // that occurs as the element is placed into the DOM, which should\n",
+              "            // otherwise not happen due to the minimum size styling.\n",
+              "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
+              "                fig.request_resize(width, height);\n",
+              "            }\n",
+              "        }\n",
+              "    });\n",
+              "    this.resizeObserverInstance.observe(canvas_div);\n",
+              "\n",
+              "    function on_mouse_event_closure(name) {\n",
+              "        return function (event) {\n",
+              "            return fig.mouse_event(event, name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mousedown',\n",
+              "        on_mouse_event_closure('button_press')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseup',\n",
+              "        on_mouse_event_closure('button_release')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'dblclick',\n",
+              "        on_mouse_event_closure('dblclick')\n",
+              "    );\n",
+              "    // Throttle sequential mouse events to 1 every 20ms.\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mousemove',\n",
+              "        on_mouse_event_closure('motion_notify')\n",
+              "    );\n",
+              "\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseenter',\n",
+              "        on_mouse_event_closure('figure_enter')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseleave',\n",
+              "        on_mouse_event_closure('figure_leave')\n",
+              "    );\n",
+              "\n",
+              "    canvas_div.addEventListener('wheel', function (event) {\n",
+              "        if (event.deltaY < 0) {\n",
+              "            event.step = 1;\n",
+              "        } else {\n",
+              "            event.step = -1;\n",
+              "        }\n",
+              "        on_mouse_event_closure('scroll')(event);\n",
+              "    });\n",
+              "\n",
+              "    canvas_div.appendChild(canvas);\n",
+              "    canvas_div.appendChild(rubberband_canvas);\n",
+              "\n",
+              "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
+              "    this.rubberband_context.strokeStyle = '#000000';\n",
+              "\n",
+              "    this._resize_canvas = function (width, height, forward) {\n",
+              "        if (forward) {\n",
+              "            canvas_div.style.width = width + 'px';\n",
+              "            canvas_div.style.height = height + 'px';\n",
+              "        }\n",
+              "    };\n",
+              "\n",
+              "    // Disable right mouse context menu.\n",
+              "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
+              "        event.preventDefault();\n",
+              "        return false;\n",
+              "    });\n",
+              "\n",
+              "    function set_focus() {\n",
+              "        canvas.focus();\n",
+              "        canvas_div.focus();\n",
+              "    }\n",
+              "\n",
+              "    window.setTimeout(set_focus, 100);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_toolbar = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var toolbar = document.createElement('div');\n",
+              "    toolbar.classList = 'mpl-toolbar';\n",
+              "    this.root.appendChild(toolbar);\n",
+              "\n",
+              "    function on_click_closure(name) {\n",
+              "        return function (_event) {\n",
+              "            return fig.toolbar_button_onclick(name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    function on_mouseover_closure(tooltip) {\n",
+              "        return function (event) {\n",
+              "            if (!event.currentTarget.disabled) {\n",
+              "                return fig.toolbar_button_onmouseover(tooltip);\n",
+              "            }\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    fig.buttons = {};\n",
+              "    var buttonGroup = document.createElement('div');\n",
+              "    buttonGroup.classList = 'mpl-button-group';\n",
+              "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+              "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+              "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+              "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+              "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+              "\n",
+              "        if (!name) {\n",
+              "            /* Instead of a spacer, we start a new button group. */\n",
+              "            if (buttonGroup.hasChildNodes()) {\n",
+              "                toolbar.appendChild(buttonGroup);\n",
+              "            }\n",
+              "            buttonGroup = document.createElement('div');\n",
+              "            buttonGroup.classList = 'mpl-button-group';\n",
+              "            continue;\n",
+              "        }\n",
+              "\n",
+              "        var button = (fig.buttons[name] = document.createElement('button'));\n",
+              "        button.classList = 'mpl-widget';\n",
+              "        button.setAttribute('role', 'button');\n",
+              "        button.setAttribute('aria-disabled', 'false');\n",
+              "        button.addEventListener('click', on_click_closure(method_name));\n",
+              "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+              "\n",
+              "        var icon_img = document.createElement('img');\n",
+              "        icon_img.src = '_images/' + image + '.png';\n",
+              "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
+              "        icon_img.alt = tooltip;\n",
+              "        button.appendChild(icon_img);\n",
+              "\n",
+              "        buttonGroup.appendChild(button);\n",
+              "    }\n",
+              "\n",
+              "    if (buttonGroup.hasChildNodes()) {\n",
+              "        toolbar.appendChild(buttonGroup);\n",
+              "    }\n",
+              "\n",
+              "    var fmt_picker = document.createElement('select');\n",
+              "    fmt_picker.classList = 'mpl-widget';\n",
+              "    toolbar.appendChild(fmt_picker);\n",
+              "    this.format_dropdown = fmt_picker;\n",
+              "\n",
+              "    for (var ind in mpl.extensions) {\n",
+              "        var fmt = mpl.extensions[ind];\n",
+              "        var option = document.createElement('option');\n",
+              "        option.selected = fmt === mpl.default_extension;\n",
+              "        option.innerHTML = fmt;\n",
+              "        fmt_picker.appendChild(option);\n",
+              "    }\n",
+              "\n",
+              "    var status_bar = document.createElement('span');\n",
+              "    status_bar.classList = 'mpl-message';\n",
+              "    toolbar.appendChild(status_bar);\n",
+              "    this.message = status_bar;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
+              "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+              "    // which will in turn request a refresh of the image.\n",
+              "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.send_message = function (type, properties) {\n",
+              "    properties['type'] = type;\n",
+              "    properties['figure_id'] = this.id;\n",
+              "    this.ws.send(JSON.stringify(properties));\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.send_draw_message = function () {\n",
+              "    if (!this.waiting) {\n",
+              "        this.waiting = true;\n",
+              "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+              "    var format_dropdown = fig.format_dropdown;\n",
+              "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+              "    fig.ondownload(fig, format);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
+              "    var size = msg['size'];\n",
+              "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
+              "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
+              "        fig.send_message('refresh', {});\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
+              "    var x0 = msg['x0'] / fig.ratio;\n",
+              "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
+              "    var x1 = msg['x1'] / fig.ratio;\n",
+              "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
+              "    x0 = Math.floor(x0) + 0.5;\n",
+              "    y0 = Math.floor(y0) + 0.5;\n",
+              "    x1 = Math.floor(x1) + 0.5;\n",
+              "    y1 = Math.floor(y1) + 0.5;\n",
+              "    var min_x = Math.min(x0, x1);\n",
+              "    var min_y = Math.min(y0, y1);\n",
+              "    var width = Math.abs(x1 - x0);\n",
+              "    var height = Math.abs(y1 - y0);\n",
+              "\n",
+              "    fig.rubberband_context.clearRect(\n",
+              "        0,\n",
+              "        0,\n",
+              "        fig.canvas.width / fig.ratio,\n",
+              "        fig.canvas.height / fig.ratio\n",
+              "    );\n",
+              "\n",
+              "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
+              "    // Updates the figure title.\n",
+              "    fig.header.textContent = msg['label'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
+              "    fig.rubberband_canvas.style.cursor = msg['cursor'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
+              "    fig.message.textContent = msg['message'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
+              "    // Request the server to send over a new figure.\n",
+              "    fig.send_draw_message();\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
+              "    fig.image_mode = msg['mode'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
+              "    for (var key in msg) {\n",
+              "        if (!(key in fig.buttons)) {\n",
+              "            continue;\n",
+              "        }\n",
+              "        fig.buttons[key].disabled = !msg[key];\n",
+              "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
+              "    if (msg['mode'] === 'PAN') {\n",
+              "        fig.buttons['Pan'].classList.add('active');\n",
+              "        fig.buttons['Zoom'].classList.remove('active');\n",
+              "    } else if (msg['mode'] === 'ZOOM') {\n",
+              "        fig.buttons['Pan'].classList.remove('active');\n",
+              "        fig.buttons['Zoom'].classList.add('active');\n",
+              "    } else {\n",
+              "        fig.buttons['Pan'].classList.remove('active');\n",
+              "        fig.buttons['Zoom'].classList.remove('active');\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.updated_canvas_event = function () {\n",
+              "    // Called whenever the canvas gets updated.\n",
+              "    this.send_message('ack', {});\n",
+              "};\n",
+              "\n",
+              "// A function to construct a web socket function for onmessage handling.\n",
+              "// Called in the figure constructor.\n",
+              "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
+              "    return function socket_on_message(evt) {\n",
+              "        if (evt.data instanceof Blob) {\n",
+              "            var img = evt.data;\n",
+              "            if (img.type !== 'image/png') {\n",
+              "                /* FIXME: We get \"Resource interpreted as Image but\n",
+              "                 * transferred with MIME type text/plain:\" errors on\n",
+              "                 * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+              "                 * to be part of the websocket stream */\n",
+              "                img.type = 'image/png';\n",
+              "            }\n",
+              "\n",
+              "            /* Free the memory for the previous frames */\n",
+              "            if (fig.imageObj.src) {\n",
+              "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+              "                    fig.imageObj.src\n",
+              "                );\n",
+              "            }\n",
+              "\n",
+              "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+              "                img\n",
+              "            );\n",
+              "            fig.updated_canvas_event();\n",
+              "            fig.waiting = false;\n",
+              "            return;\n",
+              "        } else if (\n",
+              "            typeof evt.data === 'string' &&\n",
+              "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
+              "        ) {\n",
+              "            fig.imageObj.src = evt.data;\n",
+              "            fig.updated_canvas_event();\n",
+              "            fig.waiting = false;\n",
+              "            return;\n",
+              "        }\n",
+              "\n",
+              "        var msg = JSON.parse(evt.data);\n",
+              "        var msg_type = msg['type'];\n",
+              "\n",
+              "        // Call the  \"handle_{type}\" callback, which takes\n",
+              "        // the figure and JSON message as its only arguments.\n",
+              "        try {\n",
+              "            var callback = fig['handle_' + msg_type];\n",
+              "        } catch (e) {\n",
+              "            console.log(\n",
+              "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
+              "                msg\n",
+              "            );\n",
+              "            return;\n",
+              "        }\n",
+              "\n",
+              "        if (callback) {\n",
+              "            try {\n",
+              "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+              "                callback(fig, msg);\n",
+              "            } catch (e) {\n",
+              "                console.log(\n",
+              "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
+              "                    e,\n",
+              "                    e.stack,\n",
+              "                    msg\n",
+              "                );\n",
+              "            }\n",
+              "        }\n",
+              "    };\n",
+              "};\n",
+              "\n",
+              "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+              "mpl.findpos = function (e) {\n",
+              "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+              "    var targ;\n",
+              "    if (!e) {\n",
+              "        e = window.event;\n",
+              "    }\n",
+              "    if (e.target) {\n",
+              "        targ = e.target;\n",
+              "    } else if (e.srcElement) {\n",
+              "        targ = e.srcElement;\n",
+              "    }\n",
+              "    if (targ.nodeType === 3) {\n",
+              "        // defeat Safari bug\n",
+              "        targ = targ.parentNode;\n",
+              "    }\n",
+              "\n",
+              "    // pageX,Y are the mouse positions relative to the document\n",
+              "    var boundingRect = targ.getBoundingClientRect();\n",
+              "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
+              "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
+              "\n",
+              "    return { x: x, y: y };\n",
+              "};\n",
+              "\n",
+              "/*\n",
+              " * return a copy of an object with only non-object keys\n",
+              " * we need this to avoid circular references\n",
+              " * https://stackoverflow.com/a/24161582/3208463\n",
+              " */\n",
+              "function simpleKeys(original) {\n",
+              "    return Object.keys(original).reduce(function (obj, key) {\n",
+              "        if (typeof original[key] !== 'object') {\n",
+              "            obj[key] = original[key];\n",
+              "        }\n",
+              "        return obj;\n",
+              "    }, {});\n",
+              "}\n",
+              "\n",
+              "mpl.figure.prototype.mouse_event = function (event, name) {\n",
+              "    var canvas_pos = mpl.findpos(event);\n",
+              "\n",
+              "    if (name === 'button_press') {\n",
+              "        this.canvas.focus();\n",
+              "        this.canvas_div.focus();\n",
+              "    }\n",
+              "\n",
+              "    var x = canvas_pos.x * this.ratio;\n",
+              "    var y = canvas_pos.y * this.ratio;\n",
+              "\n",
+              "    this.send_message(name, {\n",
+              "        x: x,\n",
+              "        y: y,\n",
+              "        button: event.button,\n",
+              "        step: event.step,\n",
+              "        guiEvent: simpleKeys(event),\n",
+              "    });\n",
+              "\n",
+              "    /* This prevents the web browser from automatically changing to\n",
+              "     * the text insertion cursor when the button is pressed.  We want\n",
+              "     * to control all of the cursor setting manually through the\n",
+              "     * 'cursor' event from matplotlib */\n",
+              "    event.preventDefault();\n",
+              "    return false;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
+              "    // Handle any extra behaviour associated with a key event\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.key_event = function (event, name) {\n",
+              "    // Prevent repeat events\n",
+              "    if (name === 'key_press') {\n",
+              "        if (event.key === this._key) {\n",
+              "            return;\n",
+              "        } else {\n",
+              "            this._key = event.key;\n",
+              "        }\n",
+              "    }\n",
+              "    if (name === 'key_release') {\n",
+              "        this._key = null;\n",
+              "    }\n",
+              "\n",
+              "    var value = '';\n",
+              "    if (event.ctrlKey && event.key !== 'Control') {\n",
+              "        value += 'ctrl+';\n",
+              "    }\n",
+              "    else if (event.altKey && event.key !== 'Alt') {\n",
+              "        value += 'alt+';\n",
+              "    }\n",
+              "    else if (event.shiftKey && event.key !== 'Shift') {\n",
+              "        value += 'shift+';\n",
+              "    }\n",
+              "\n",
+              "    value += 'k' + event.key;\n",
+              "\n",
+              "    this._key_event_extra(event, name);\n",
+              "\n",
+              "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
+              "    return false;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
+              "    if (name === 'download') {\n",
+              "        this.handle_save(this, null);\n",
+              "    } else {\n",
+              "        this.send_message('toolbar_button', { name: name });\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
+              "    this.message.textContent = tooltip;\n",
+              "};\n",
+              "\n",
+              "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
+              "// prettier-ignore\n",
+              "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
+              "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+              "\n",
+              "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+              "\n",
+              "mpl.default_extension = \"png\";/* global mpl */\n",
+              "\n",
+              "var comm_websocket_adapter = function (comm) {\n",
+              "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+              "    // object with the appropriate methods. Currently this is a non binary\n",
+              "    // socket, so there is still some room for performance tuning.\n",
+              "    var ws = {};\n",
+              "\n",
+              "    ws.binaryType = comm.kernel.ws.binaryType;\n",
+              "    ws.readyState = comm.kernel.ws.readyState;\n",
+              "    function updateReadyState(_event) {\n",
+              "        if (comm.kernel.ws) {\n",
+              "            ws.readyState = comm.kernel.ws.readyState;\n",
+              "        } else {\n",
+              "            ws.readyState = 3; // Closed state.\n",
+              "        }\n",
+              "    }\n",
+              "    comm.kernel.ws.addEventListener('open', updateReadyState);\n",
+              "    comm.kernel.ws.addEventListener('close', updateReadyState);\n",
+              "    comm.kernel.ws.addEventListener('error', updateReadyState);\n",
+              "\n",
+              "    ws.close = function () {\n",
+              "        comm.close();\n",
+              "    };\n",
+              "    ws.send = function (m) {\n",
+              "        //console.log('sending', m);\n",
+              "        comm.send(m);\n",
+              "    };\n",
+              "    // Register the callback with on_msg.\n",
+              "    comm.on_msg(function (msg) {\n",
+              "        //console.log('receiving', msg['content']['data'], msg);\n",
+              "        var data = msg['content']['data'];\n",
+              "        if (data['blob'] !== undefined) {\n",
+              "            data = {\n",
+              "                data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
+              "            };\n",
+              "        }\n",
+              "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+              "        ws.onmessage(data);\n",
+              "    });\n",
+              "    return ws;\n",
+              "};\n",
+              "\n",
+              "mpl.mpl_figure_comm = function (comm, msg) {\n",
+              "    // This is the function which gets called when the mpl process\n",
+              "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+              "\n",
+              "    var id = msg.content.data.id;\n",
+              "    // Get hold of the div created by the display call when the Comm\n",
+              "    // socket was opened in Python.\n",
+              "    var element = document.getElementById(id);\n",
+              "    var ws_proxy = comm_websocket_adapter(comm);\n",
+              "\n",
+              "    function ondownload(figure, _format) {\n",
+              "        window.open(figure.canvas.toDataURL());\n",
+              "    }\n",
+              "\n",
+              "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
+              "\n",
+              "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+              "    // web socket which is closed, not our websocket->open comm proxy.\n",
+              "    ws_proxy.onopen();\n",
+              "\n",
+              "    fig.parent_element = element;\n",
+              "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+              "    if (!fig.cell_info) {\n",
+              "        console.error('Failed to find cell for figure', id, fig);\n",
+              "        return;\n",
+              "    }\n",
+              "    fig.cell_info[0].output_area.element.on(\n",
+              "        'cleared',\n",
+              "        { fig: fig },\n",
+              "        fig._remove_fig_handler\n",
+              "    );\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
+              "    var width = fig.canvas.width / fig.ratio;\n",
+              "    fig.cell_info[0].output_area.element.off(\n",
+              "        'cleared',\n",
+              "        fig._remove_fig_handler\n",
+              "    );\n",
+              "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
+              "\n",
+              "    // Update the output cell to use the data from the current canvas.\n",
+              "    fig.push_to_output();\n",
+              "    var dataURL = fig.canvas.toDataURL();\n",
+              "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+              "    // the notebook keyboard shortcuts fail.\n",
+              "    IPython.keyboard_manager.enable();\n",
+              "    fig.parent_element.innerHTML =\n",
+              "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+              "    fig.close_ws(fig, msg);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
+              "    fig.send_message('closing', msg);\n",
+              "    // fig.ws.close()\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
+              "    // Turn the data on the canvas into data in the output cell.\n",
+              "    var width = this.canvas.width / this.ratio;\n",
+              "    var dataURL = this.canvas.toDataURL();\n",
+              "    this.cell_info[1]['text/html'] =\n",
+              "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.updated_canvas_event = function () {\n",
+              "    // Tell IPython that the notebook contents must change.\n",
+              "    IPython.notebook.set_dirty(true);\n",
+              "    this.send_message('ack', {});\n",
+              "    var fig = this;\n",
+              "    // Wait a second, then push the new image to the DOM so\n",
+              "    // that it is saved nicely (might be nice to debounce this).\n",
+              "    setTimeout(function () {\n",
+              "        fig.push_to_output();\n",
+              "    }, 1000);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_toolbar = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var toolbar = document.createElement('div');\n",
+              "    toolbar.classList = 'btn-toolbar';\n",
+              "    this.root.appendChild(toolbar);\n",
+              "\n",
+              "    function on_click_closure(name) {\n",
+              "        return function (_event) {\n",
+              "            return fig.toolbar_button_onclick(name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    function on_mouseover_closure(tooltip) {\n",
+              "        return function (event) {\n",
+              "            if (!event.currentTarget.disabled) {\n",
+              "                return fig.toolbar_button_onmouseover(tooltip);\n",
+              "            }\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    fig.buttons = {};\n",
+              "    var buttonGroup = document.createElement('div');\n",
+              "    buttonGroup.classList = 'btn-group';\n",
+              "    var button;\n",
+              "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+              "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+              "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+              "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+              "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+              "\n",
+              "        if (!name) {\n",
+              "            /* Instead of a spacer, we start a new button group. */\n",
+              "            if (buttonGroup.hasChildNodes()) {\n",
+              "                toolbar.appendChild(buttonGroup);\n",
+              "            }\n",
+              "            buttonGroup = document.createElement('div');\n",
+              "            buttonGroup.classList = 'btn-group';\n",
+              "            continue;\n",
+              "        }\n",
+              "\n",
+              "        button = fig.buttons[name] = document.createElement('button');\n",
+              "        button.classList = 'btn btn-default';\n",
+              "        button.href = '#';\n",
+              "        button.title = name;\n",
+              "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
+              "        button.addEventListener('click', on_click_closure(method_name));\n",
+              "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+              "        buttonGroup.appendChild(button);\n",
+              "    }\n",
+              "\n",
+              "    if (buttonGroup.hasChildNodes()) {\n",
+              "        toolbar.appendChild(buttonGroup);\n",
+              "    }\n",
+              "\n",
+              "    // Add the status bar.\n",
+              "    var status_bar = document.createElement('span');\n",
+              "    status_bar.classList = 'mpl-message pull-right';\n",
+              "    toolbar.appendChild(status_bar);\n",
+              "    this.message = status_bar;\n",
+              "\n",
+              "    // Add the close button to the window.\n",
+              "    var buttongrp = document.createElement('div');\n",
+              "    buttongrp.classList = 'btn-group inline pull-right';\n",
+              "    button = document.createElement('button');\n",
+              "    button.classList = 'btn btn-mini btn-primary';\n",
+              "    button.href = '#';\n",
+              "    button.title = 'Stop Interaction';\n",
+              "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
+              "    button.addEventListener('click', function (_evt) {\n",
+              "        fig.handle_close(fig, {});\n",
+              "    });\n",
+              "    button.addEventListener(\n",
+              "        'mouseover',\n",
+              "        on_mouseover_closure('Stop Interaction')\n",
+              "    );\n",
+              "    buttongrp.appendChild(button);\n",
+              "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
+              "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
+              "    var fig = event.data.fig;\n",
+              "    if (event.target !== this) {\n",
+              "        // Ignore bubbled events from children.\n",
+              "        return;\n",
+              "    }\n",
+              "    fig.close_ws(fig, {});\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._root_extra_style = function (el) {\n",
+              "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
+              "    // this is important to make the div 'focusable\n",
+              "    el.setAttribute('tabindex', 0);\n",
+              "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+              "    // off when our div gets focus\n",
+              "\n",
+              "    // location in version 3\n",
+              "    if (IPython.notebook.keyboard_manager) {\n",
+              "        IPython.notebook.keyboard_manager.register_events(el);\n",
+              "    } else {\n",
+              "        // location in version 2\n",
+              "        IPython.keyboard_manager.register_events(el);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
+              "    // Check for shift+enter\n",
+              "    if (event.shiftKey && event.which === 13) {\n",
+              "        this.canvas_div.blur();\n",
+              "        // select the cell after this one\n",
+              "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
+              "        IPython.notebook.select(index + 1);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+              "    fig.ondownload(fig, null);\n",
+              "};\n",
+              "\n",
+              "mpl.find_output_cell = function (html_output) {\n",
+              "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+              "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+              "    // IPython event is triggered only after the cells have been serialised, which for\n",
+              "    // our purposes (turning an active figure into a static one), is too late.\n",
+              "    var cells = IPython.notebook.get_cells();\n",
+              "    var ncells = cells.length;\n",
+              "    for (var i = 0; i < ncells; i++) {\n",
+              "        var cell = cells[i];\n",
+              "        if (cell.cell_type === 'code') {\n",
+              "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
+              "                var data = cell.output_area.outputs[j];\n",
+              "                if (data.data) {\n",
+              "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+              "                    data = data.data;\n",
+              "                }\n",
+              "                if (data['text/html'] === html_output) {\n",
+              "                    return [cell, data, j];\n",
+              "                }\n",
+              "            }\n",
+              "        }\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "// Register the function which deals with the matplotlib target/channel.\n",
+              "// The kernel may be null if the page has been refreshed.\n",
+              "if (IPython.notebook.kernel !== null) {\n",
+              "    IPython.notebook.kernel.comm_manager.register_target(\n",
+              "        'matplotlib',\n",
+              "        mpl.mpl_figure_comm\n",
+              "    );\n",
+              "}\n"
+            ],
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/html": [
+              "<img src=\"data:image/png;base64,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\" width=\"1200\">"
+            ],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# Print figure comparing results\n",
+        "fig, ax = plt.subplots(1,1,figsize=(12,8))\n",
+        "results_qaoa.plot_cost(ax=ax,label='Original')\n",
+        "results_sv.plot_cost(ax=ax,color='green',label='Statevector Simulator')\n",
+        "results_shot.plot_cost(ax=ax,color='red',label='Shot Simulator')\n",
+        "results_noisy_shot.plot_cost(ax=ax,color='orange',label='Noisy Shot Simulator')\n",
+        "results_annealing.plot_cost(ax=ax,color='black',label='Annealing Simulator')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xcOyfF4URRQ4"
+      },
+      "source": [
+        "# Acknowledgments\n",
+        "\n",
+        "🎉🎉🎉\n",
+        "\n",
+        "Special thanks to Entropica Labs for helping us create this challenge and being able to use their SDK, OpenQAOA. If you want to know more about OpenQAOA or ask them questions directly, check out their [discord channel](discord.gg/ana76wkKBd).\n",
+        "\n",
+        "🎉🎉🎉"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "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.8.13"
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/challenges/openqaoa challenge/challenge_openqaoa.ipynb b/challenges/openqaoa challenge/challenge_openqaoa.ipynb
new file mode 100644
index 0000000..80e2562
--- /dev/null
+++ b/challenges/openqaoa challenge/challenge_openqaoa.ipynb	
@@ -0,0 +1,3623 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "auLfxa4-RRQe"
+      },
+      "source": [
+        "# Challenge: OpenQAOA\n",
+        "### Team # 32\n",
+        "### Team Members\n",
+        "- Ayelen Perez | Argentina\n",
+        "- Jefferson Granizo | Ecuador\n",
+        "- Jesus Montemayor | Perú\n",
+        "- Rubén Guzman | México\n",
+        "- Andres Diaz | Puerto Rico"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "It1BO2eERRQl"
+      },
+      "source": [
+        "# Problem Definition - Tic-Tac-Toe\n",
+        "Introduction\n",
+        "Tic-tac-toe, also known as noughts and crosses or Xs and Os, is a classic paper-and-pencil game for two players. The game is typically played on a 3x3 grid, although variations with larger grids exist. The objective of the game is simple: one player tries to get three of their marks (either X or O) in a row, either horizontally, vertically, or diagonally, before their opponent does. Consider you want to play the classic version in a 3x3 grid, that you are the \"X\"s, and that you want to design a winning strategy. Consider also the following convention:\n",
+        "\n",
+        "the state of the X's is |1>\n",
+        "the state of the O's is |0>\n",
+        "the state of the empty cells in an unknown state.\n",
+        "Consider each bit of the tic-tac-toe board is represented by a qubit, in the form:\n",
+        "```\n",
+        "| q0 | q1 | q2 |\n",
+        "|----|----|----|\n",
+        "| q3 | q4 | q5 |\n",
+        "|----|----|----|\n",
+        "| q6 | q7 | q8 |\n",
+        "```\n",
+        "\n",
+        "We can convert this problem into a binary optimization problem, known as QUBO (Quadratic unconstrained binary optimization) in order to use known Quantum Approximate Optimization (QAOA) Algorithms. We first create a cost function, that can be of the form:\n",
+        "\n",
+        "$$𝐶(𝑞𝑖)=𝑀(𝑞_0+𝑞_1+𝑞_2+𝑞_3+𝑞_4+𝑞_5+𝑞_6+𝑞_7+𝑞_8−2)^2−(𝑞_0+𝑞_1+𝑞_2)^2−(𝑞_3+𝑞_4+𝑞_5)^2−(𝑞_6+𝑞_7+𝑞_8)^2−(𝑞_0+𝑞_3+𝑞_6)^2−(𝑞_1+𝑞_4+𝑞_7)^2−(𝑞_2+𝑞_5+𝑞_8)^2−(𝑞_0+𝑞_4+𝑞_8)^2−(𝑞_2+𝑞_4+𝑞_6)^2$$\n",
+        "\n",
+        "The idea is to minimize this function when you get three X's in a row (vertical, horizontal, or diagonal), represented by the terms that are being subtracted. We do have the challenge of considering each of the possibilities of our opponent, and the order of play. We chose this well-know problem in order to learn how to apply QAOA and its different options (different simulation methods, inclusion of noise, etc) to a case where the minimum-energy state can be readily verified.\n",
+        "\n",
+        "## Analysis of a toy problem - case # 1\n",
+        "\n",
+        "To better understand how we can design a winning strategy and determine the best possibilities to win, we are going to consider the situation in the figure below. Your turn is next and we need to develop a quantum algorithm to be able to find the best decisions with the higher probability.\n",
+        "\n",
+        "```\n",
+        "|  X |  O |  O |\n",
+        "|----|----|----|\n",
+        "|  X |    |    |\n",
+        "|----|----|----|\n",
+        "|  O |    |    |\n",
+        "```\n",
+        "\n",
+        "We can then define a quantum state $|q_0q_1q_2q_3>$ made up of four qubits, each one representing the state of the four missing spaces:\n",
+        "\n",
+        "```\n",
+        "|  X |  O |  O |\n",
+        "|----|----|----|\n",
+        "|  X | q0 | q1 |\n",
+        "|----|----|----|\n",
+        "|  O | q2 | q3 |\n",
+        "```\n",
+        "\n",
+        "Consider now all the possible ways to win (eight in total: 3 vertical, 3 horizontal, and 2 diagonal). Of this eight possibilities, only two of them (second row horizontal and diagonal from the top right), are possible with the current stay of play, simplifying the definiton of our cost function. Our cost function $C$ now becomes:\n",
+        "\n",
+        "$$C(q_i) = M(1+0+0+1+q_0+q_1+0+q_2+q_3-2)^2-(1+q_0+q_1)^2-(1+q_0+q_3)^2$$\n",
+        "$$C(q_i) = M(q_0+q_1+q_2+q_3)^2-(1+q_0+q_1)^2-(1+q_0+q_3)^2 $$\n",
+        "\n",
+        "We now proceed to consider constraints, determined by the dynamics of the game and that we don't want our opponent to win.\n",
+        "\n",
+        "**Equality Constraints**\n",
+        "\n",
+        "From the order of play, we are missing at most two X's and two O's. Since we are playing the X's and we have two more plays, we have the condition:\n",
+        "\n",
+        "$$q_0+q_1+q_2+q_3 = 2$$\n",
+        "\n",
+        "Note that by incorporating this condition into our Cost function, we can further simplify it to:\n",
+        "\n",
+        "$$C(q_i) = 4M -(1+q_0+q_1)^2-(1+q_0+q_3)^2 $$\n",
+        "\n",
+        "where we choose $M$ to our convenience. Note the equality constraint still needs to be enforced, to guarantee there are exactly two X's in the missing squares.\n",
+        "\n",
+        "**Inequality Constraints**\n",
+        "\n",
+        "We can also prevent our opponent from winning by not allowing him to place an 'O' in the center square. We can represent this by requiring:\n",
+        "\n",
+        "$$q_0 > 0$$\n",
+        "\n",
+        "We can try to run the program with or without this inequality constraint to see what happens.\n",
+        "\n",
+        "## Analysis of a toy problem - case # 2\n",
+        "A variation of case 1 is to consider starting one step earlier with your opponent not having chosen yet, as shown below. We can choose this option by calling the function `Problem` with input parameter '2'.\n",
+        "\n",
+        "```\n",
+        "|  X |  O |  O |\n",
+        "|----|----|----|\n",
+        "|  X |    |    |\n",
+        "|----|----|----|\n",
+        "|    |    |    |\n",
+        "```\n",
+        "\n",
+        "We can then define a quantum state $|x_0x_1x_2x_3x_4>$ made up of four qubits, each one representing the state of the four missing spaces:\n",
+        "\n",
+        "```\n",
+        "|  X |  O |  O |\n",
+        "|----|----|----|\n",
+        "|  X | q0 | q1 |\n",
+        "|----|----|----|\n",
+        "| q4 | q2 | q3 |\n",
+        "```\n",
+        "\n",
+        "## Process\n",
+        "The problem has been solved using the following workflow:\n",
+        "- Part 1: problem definition in function `Problem` using the QUBO implementation described above. The problem is then converted to an Ising Model and solved using QAOA.\n",
+        "- Part 2: improvement of the QAOA algorithm, considering other simulation methods: statevector_simulator, shot-based simulator, and annealing parameterization\n",
+        "- Part 3: implementation of the model using a Noise Model.\n",
+        "- Part 4: the different model are compared by plotting the cost function"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BYIwp4ttRRQp"
+      },
+      "source": [
+        "#  Part 1 Problem definition and solution using QAOA"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "K2ZzTO7mRRQr"
+      },
+      "outputs": [],
+      "source": [
+        "%matplotlib notebook\n",
+        "\n",
+        "# Import external libraries to present an manipulate the data\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import pandas as pd\n",
+        "\n",
+        "# Import docplex model to generate the problem to optimize\n",
+        "from docplex.mp.model import Model\n",
+        "\n",
+        "# Import the libraries needed to employ the QAOA quantum algorithm using OpenQAOA\n",
+        "from openqaoa import QAOA\n",
+        "\n",
+        "# method to covnert a docplex model to a qubo problem\n",
+        "from openqaoa.problems.converters import FromDocplex2IsingModel #check this method and properties\n",
+        "from openqaoa.backends import create_device\n",
+        "\n",
+        "# method to find the correct states for the QAOA object\n",
+        "from openqaoa.utilities import ground_state_hamiltonian"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "W8Y_TZrDRRQt"
+      },
+      "source": [
+        "Code your problem"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "B9vRaRMtRRQu"
+      },
+      "outputs": [],
+      "source": [
+        "# inputs\n",
+        "\n",
+        "def Problem(value): #(values,weights, max_weight):\n",
+        "\n",
+        "    # initialize a model\n",
+        "    mdl = Model(\"Basic Problem using minimize\")\n",
+        "\n",
+        "    if value == 1:\n",
+        "        #tic-tac-toe with only 4 cells left empty\n",
+        "        #|  X |  O |  O |\n",
+        "        #|  X | q0 | q1 |\n",
+        "        #|  O | q2 | q3 |\n",
+        "        # indicate the binary variables\n",
+        "        n_vars = 4 # Number of variables\n",
+        "        q = mdl.binary_var_list(n_vars, name=\"q\")\n",
+        "        # define the objective function\n",
+        "        obj_func = 40 - (1+q[0]+q[1])*(1+q[0]+q[1]) - (1+q[0]+q[3])*(1+q[0]+q[3])\n",
+        "        mdl.minimize(obj_func)\n",
+        "        # add the constraints\n",
+        "        mdl.add_constraint(q[0] + q[1] + q[2] + q[3] == 2)\n",
+        "        #mdl.add_constraint(q[0] >= 0)\n",
+        "    elif value == 2:\n",
+        "        #tic-tac-toe with 5 cells left empty\n",
+        "        #|  X |  O |  O |\n",
+        "        #|  X | q0 | q1 |\n",
+        "        #| q4 | q2 | q3 |\n",
+        "        # indicate the binary variables\n",
+        "        n_vars = 5 # Number of variables\n",
+        "        q = mdl.binary_var_list(n_vars, name=\"q\")\n",
+        "        # define the objective function\n",
+        "        obj_func = 40 - (2+q[4])*(2+q[4]) -(q[2]+q[3]+q[4])*(q[2]+q[3]+q[4]) - (1+q[0]+q[1])*(1+q[0]+q[1]) - (1+q[0]+q[3])*(1+q[0]+q[3])\n",
+        "        mdl.minimize(obj_func)\n",
+        "        # add the constraints\n",
+        "        mdl.add_constraint(q[0] + q[1] + q[2] + q[3] + q[4] == 2)\n",
+        "        #mdl.add_constraint(q[0] >= 0)\n",
+        "    # print a summary of the docplex model\n",
+        "    # print(mdl.prettyprint())\n",
+        "\n",
+        "    return mdl #return model, check FromDocplex2IsingModel\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "KTE07LS3RRQv",
+        "outputId": "f745ed9b-36f3-42be-b7e0-12a9157ec594"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Warning: Model name contains whitespaces: |Basic Problem using minimize|\n",
+            "// This file has been generated by DOcplex\n",
+            "// model name is: Basic Problem using minimize\n",
+            "// var contrainer section\n",
+            "dvar bool q[4];\n",
+            "\n",
+            "// single vars section\n",
+            "dvar bool q_0;\n",
+            "dvar bool q_1;\n",
+            "dvar bool q_2;\n",
+            "dvar bool q_3;\n",
+            "\n",
+            "minimize\n",
+            " - 72 q_0 - 70 q_1 - 68 q_2 - 70 q_3 [ 15 q_0^2 + 32 q_0*q_1 + 34 q_0*q_2\n",
+            " + 32 q_0*q_3 + 16 q_1^2 + 34 q_1*q_2 + 34 q_1*q_3 + 17 q_2^2 + 34 q_2*q_3\n",
+            " + 16 q_3^2 ] + 106;\n",
+            " \n",
+            "subject to {\n",
+            "\n",
+            "}\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Ising encoding of the QUBO problem\n",
+        "mdl = Problem(1)\n",
+        "qubo = FromDocplex2IsingModel(mdl)\n",
+        "ising_encoding = qubo.ising_model\n",
+        "# Docplex encoding of the QUBO problem\n",
+        "mdl_qubo_docplex = qubo.qubo_docplex\n",
+        "\n",
+        "mdl_qubo_docplex.prettyprint()\n",
+        "# Print in a df the ising encoding (we need to remove keys: 'problem_instance' and 'metadata'))\n",
+        "#ising_encoding_dict = ising_encoding.asdict(exclude_keys=['problem_instance', 'metadata'])\n",
+        "#pd.DataFrame(ising_encoding_dict)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "JEcISoRiRRQy",
+        "outputId": "399b08a1-7831-43ff-eedf-7629468a2d6b"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/javascript": [
+              "/* Put everything inside the global mpl namespace */\n",
+              "/* global mpl */\n",
+              "window.mpl = {};\n",
+              "\n",
+              "mpl.get_websocket_type = function () {\n",
+              "    if (typeof WebSocket !== 'undefined') {\n",
+              "        return WebSocket;\n",
+              "    } else if (typeof MozWebSocket !== 'undefined') {\n",
+              "        return MozWebSocket;\n",
+              "    } else {\n",
+              "        alert(\n",
+              "            'Your browser does not have WebSocket support. ' +\n",
+              "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+              "                'Firefox 4 and 5 are also supported but you ' +\n",
+              "                'have to enable WebSockets in about:config.'\n",
+              "        );\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
+              "    this.id = figure_id;\n",
+              "\n",
+              "    this.ws = websocket;\n",
+              "\n",
+              "    this.supports_binary = this.ws.binaryType !== undefined;\n",
+              "\n",
+              "    if (!this.supports_binary) {\n",
+              "        var warnings = document.getElementById('mpl-warnings');\n",
+              "        if (warnings) {\n",
+              "            warnings.style.display = 'block';\n",
+              "            warnings.textContent =\n",
+              "                'This browser does not support binary websocket messages. ' +\n",
+              "                'Performance may be slow.';\n",
+              "        }\n",
+              "    }\n",
+              "\n",
+              "    this.imageObj = new Image();\n",
+              "\n",
+              "    this.context = undefined;\n",
+              "    this.message = undefined;\n",
+              "    this.canvas = undefined;\n",
+              "    this.rubberband_canvas = undefined;\n",
+              "    this.rubberband_context = undefined;\n",
+              "    this.format_dropdown = undefined;\n",
+              "\n",
+              "    this.image_mode = 'full';\n",
+              "\n",
+              "    this.root = document.createElement('div');\n",
+              "    this.root.setAttribute('style', 'display: inline-block');\n",
+              "    this._root_extra_style(this.root);\n",
+              "\n",
+              "    parent_element.appendChild(this.root);\n",
+              "\n",
+              "    this._init_header(this);\n",
+              "    this._init_canvas(this);\n",
+              "    this._init_toolbar(this);\n",
+              "\n",
+              "    var fig = this;\n",
+              "\n",
+              "    this.waiting = false;\n",
+              "\n",
+              "    this.ws.onopen = function () {\n",
+              "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
+              "        fig.send_message('send_image_mode', {});\n",
+              "        if (fig.ratio !== 1) {\n",
+              "            fig.send_message('set_device_pixel_ratio', {\n",
+              "                device_pixel_ratio: fig.ratio,\n",
+              "            });\n",
+              "        }\n",
+              "        fig.send_message('refresh', {});\n",
+              "    };\n",
+              "\n",
+              "    this.imageObj.onload = function () {\n",
+              "        if (fig.image_mode === 'full') {\n",
+              "            // Full images could contain transparency (where diff images\n",
+              "            // almost always do), so we need to clear the canvas so that\n",
+              "            // there is no ghosting.\n",
+              "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+              "        }\n",
+              "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
+              "    };\n",
+              "\n",
+              "    this.imageObj.onunload = function () {\n",
+              "        fig.ws.close();\n",
+              "    };\n",
+              "\n",
+              "    this.ws.onmessage = this._make_on_message_function(this);\n",
+              "\n",
+              "    this.ondownload = ondownload;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_header = function () {\n",
+              "    var titlebar = document.createElement('div');\n",
+              "    titlebar.classList =\n",
+              "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
+              "    var titletext = document.createElement('div');\n",
+              "    titletext.classList = 'ui-dialog-title';\n",
+              "    titletext.setAttribute(\n",
+              "        'style',\n",
+              "        'width: 100%; text-align: center; padding: 3px;'\n",
+              "    );\n",
+              "    titlebar.appendChild(titletext);\n",
+              "    this.root.appendChild(titlebar);\n",
+              "    this.header = titletext;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
+              "\n",
+              "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
+              "\n",
+              "mpl.figure.prototype._init_canvas = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
+              "    canvas_div.setAttribute(\n",
+              "        'style',\n",
+              "        'border: 1px solid #ddd;' +\n",
+              "            'box-sizing: content-box;' +\n",
+              "            'clear: both;' +\n",
+              "            'min-height: 1px;' +\n",
+              "            'min-width: 1px;' +\n",
+              "            'outline: 0;' +\n",
+              "            'overflow: hidden;' +\n",
+              "            'position: relative;' +\n",
+              "            'resize: both;'\n",
+              "    );\n",
+              "\n",
+              "    function on_keyboard_event_closure(name) {\n",
+              "        return function (event) {\n",
+              "            return fig.key_event(event, name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    canvas_div.addEventListener(\n",
+              "        'keydown',\n",
+              "        on_keyboard_event_closure('key_press')\n",
+              "    );\n",
+              "    canvas_div.addEventListener(\n",
+              "        'keyup',\n",
+              "        on_keyboard_event_closure('key_release')\n",
+              "    );\n",
+              "\n",
+              "    this._canvas_extra_style(canvas_div);\n",
+              "    this.root.appendChild(canvas_div);\n",
+              "\n",
+              "    var canvas = (this.canvas = document.createElement('canvas'));\n",
+              "    canvas.classList.add('mpl-canvas');\n",
+              "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
+              "\n",
+              "    this.context = canvas.getContext('2d');\n",
+              "\n",
+              "    var backingStore =\n",
+              "        this.context.backingStorePixelRatio ||\n",
+              "        this.context.webkitBackingStorePixelRatio ||\n",
+              "        this.context.mozBackingStorePixelRatio ||\n",
+              "        this.context.msBackingStorePixelRatio ||\n",
+              "        this.context.oBackingStorePixelRatio ||\n",
+              "        this.context.backingStorePixelRatio ||\n",
+              "        1;\n",
+              "\n",
+              "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+              "\n",
+              "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
+              "        'canvas'\n",
+              "    ));\n",
+              "    rubberband_canvas.setAttribute(\n",
+              "        'style',\n",
+              "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
+              "    );\n",
+              "\n",
+              "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
+              "    if (this.ResizeObserver === undefined) {\n",
+              "        if (window.ResizeObserver !== undefined) {\n",
+              "            this.ResizeObserver = window.ResizeObserver;\n",
+              "        } else {\n",
+              "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
+              "            this.ResizeObserver = obs.ResizeObserver;\n",
+              "        }\n",
+              "    }\n",
+              "\n",
+              "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
+              "        var nentries = entries.length;\n",
+              "        for (var i = 0; i < nentries; i++) {\n",
+              "            var entry = entries[i];\n",
+              "            var width, height;\n",
+              "            if (entry.contentBoxSize) {\n",
+              "                if (entry.contentBoxSize instanceof Array) {\n",
+              "                    // Chrome 84 implements new version of spec.\n",
+              "                    width = entry.contentBoxSize[0].inlineSize;\n",
+              "                    height = entry.contentBoxSize[0].blockSize;\n",
+              "                } else {\n",
+              "                    // Firefox implements old version of spec.\n",
+              "                    width = entry.contentBoxSize.inlineSize;\n",
+              "                    height = entry.contentBoxSize.blockSize;\n",
+              "                }\n",
+              "            } else {\n",
+              "                // Chrome <84 implements even older version of spec.\n",
+              "                width = entry.contentRect.width;\n",
+              "                height = entry.contentRect.height;\n",
+              "            }\n",
+              "\n",
+              "            // Keep the size of the canvas and rubber band canvas in sync with\n",
+              "            // the canvas container.\n",
+              "            if (entry.devicePixelContentBoxSize) {\n",
+              "                // Chrome 84 implements new version of spec.\n",
+              "                canvas.setAttribute(\n",
+              "                    'width',\n",
+              "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
+              "                );\n",
+              "                canvas.setAttribute(\n",
+              "                    'height',\n",
+              "                    entry.devicePixelContentBoxSize[0].blockSize\n",
+              "                );\n",
+              "            } else {\n",
+              "                canvas.setAttribute('width', width * fig.ratio);\n",
+              "                canvas.setAttribute('height', height * fig.ratio);\n",
+              "            }\n",
+              "            canvas.setAttribute(\n",
+              "                'style',\n",
+              "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
+              "            );\n",
+              "\n",
+              "            rubberband_canvas.setAttribute('width', width);\n",
+              "            rubberband_canvas.setAttribute('height', height);\n",
+              "\n",
+              "            // And update the size in Python. We ignore the initial 0/0 size\n",
+              "            // that occurs as the element is placed into the DOM, which should\n",
+              "            // otherwise not happen due to the minimum size styling.\n",
+              "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
+              "                fig.request_resize(width, height);\n",
+              "            }\n",
+              "        }\n",
+              "    });\n",
+              "    this.resizeObserverInstance.observe(canvas_div);\n",
+              "\n",
+              "    function on_mouse_event_closure(name) {\n",
+              "        return function (event) {\n",
+              "            return fig.mouse_event(event, name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mousedown',\n",
+              "        on_mouse_event_closure('button_press')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseup',\n",
+              "        on_mouse_event_closure('button_release')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'dblclick',\n",
+              "        on_mouse_event_closure('dblclick')\n",
+              "    );\n",
+              "    // Throttle sequential mouse events to 1 every 20ms.\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mousemove',\n",
+              "        on_mouse_event_closure('motion_notify')\n",
+              "    );\n",
+              "\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseenter',\n",
+              "        on_mouse_event_closure('figure_enter')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseleave',\n",
+              "        on_mouse_event_closure('figure_leave')\n",
+              "    );\n",
+              "\n",
+              "    canvas_div.addEventListener('wheel', function (event) {\n",
+              "        if (event.deltaY < 0) {\n",
+              "            event.step = 1;\n",
+              "        } else {\n",
+              "            event.step = -1;\n",
+              "        }\n",
+              "        on_mouse_event_closure('scroll')(event);\n",
+              "    });\n",
+              "\n",
+              "    canvas_div.appendChild(canvas);\n",
+              "    canvas_div.appendChild(rubberband_canvas);\n",
+              "\n",
+              "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
+              "    this.rubberband_context.strokeStyle = '#000000';\n",
+              "\n",
+              "    this._resize_canvas = function (width, height, forward) {\n",
+              "        if (forward) {\n",
+              "            canvas_div.style.width = width + 'px';\n",
+              "            canvas_div.style.height = height + 'px';\n",
+              "        }\n",
+              "    };\n",
+              "\n",
+              "    // Disable right mouse context menu.\n",
+              "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
+              "        event.preventDefault();\n",
+              "        return false;\n",
+              "    });\n",
+              "\n",
+              "    function set_focus() {\n",
+              "        canvas.focus();\n",
+              "        canvas_div.focus();\n",
+              "    }\n",
+              "\n",
+              "    window.setTimeout(set_focus, 100);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_toolbar = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var toolbar = document.createElement('div');\n",
+              "    toolbar.classList = 'mpl-toolbar';\n",
+              "    this.root.appendChild(toolbar);\n",
+              "\n",
+              "    function on_click_closure(name) {\n",
+              "        return function (_event) {\n",
+              "            return fig.toolbar_button_onclick(name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    function on_mouseover_closure(tooltip) {\n",
+              "        return function (event) {\n",
+              "            if (!event.currentTarget.disabled) {\n",
+              "                return fig.toolbar_button_onmouseover(tooltip);\n",
+              "            }\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    fig.buttons = {};\n",
+              "    var buttonGroup = document.createElement('div');\n",
+              "    buttonGroup.classList = 'mpl-button-group';\n",
+              "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+              "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+              "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+              "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+              "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+              "\n",
+              "        if (!name) {\n",
+              "            /* Instead of a spacer, we start a new button group. */\n",
+              "            if (buttonGroup.hasChildNodes()) {\n",
+              "                toolbar.appendChild(buttonGroup);\n",
+              "            }\n",
+              "            buttonGroup = document.createElement('div');\n",
+              "            buttonGroup.classList = 'mpl-button-group';\n",
+              "            continue;\n",
+              "        }\n",
+              "\n",
+              "        var button = (fig.buttons[name] = document.createElement('button'));\n",
+              "        button.classList = 'mpl-widget';\n",
+              "        button.setAttribute('role', 'button');\n",
+              "        button.setAttribute('aria-disabled', 'false');\n",
+              "        button.addEventListener('click', on_click_closure(method_name));\n",
+              "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+              "\n",
+              "        var icon_img = document.createElement('img');\n",
+              "        icon_img.src = '_images/' + image + '.png';\n",
+              "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
+              "        icon_img.alt = tooltip;\n",
+              "        button.appendChild(icon_img);\n",
+              "\n",
+              "        buttonGroup.appendChild(button);\n",
+              "    }\n",
+              "\n",
+              "    if (buttonGroup.hasChildNodes()) {\n",
+              "        toolbar.appendChild(buttonGroup);\n",
+              "    }\n",
+              "\n",
+              "    var fmt_picker = document.createElement('select');\n",
+              "    fmt_picker.classList = 'mpl-widget';\n",
+              "    toolbar.appendChild(fmt_picker);\n",
+              "    this.format_dropdown = fmt_picker;\n",
+              "\n",
+              "    for (var ind in mpl.extensions) {\n",
+              "        var fmt = mpl.extensions[ind];\n",
+              "        var option = document.createElement('option');\n",
+              "        option.selected = fmt === mpl.default_extension;\n",
+              "        option.innerHTML = fmt;\n",
+              "        fmt_picker.appendChild(option);\n",
+              "    }\n",
+              "\n",
+              "    var status_bar = document.createElement('span');\n",
+              "    status_bar.classList = 'mpl-message';\n",
+              "    toolbar.appendChild(status_bar);\n",
+              "    this.message = status_bar;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
+              "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+              "    // which will in turn request a refresh of the image.\n",
+              "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.send_message = function (type, properties) {\n",
+              "    properties['type'] = type;\n",
+              "    properties['figure_id'] = this.id;\n",
+              "    this.ws.send(JSON.stringify(properties));\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.send_draw_message = function () {\n",
+              "    if (!this.waiting) {\n",
+              "        this.waiting = true;\n",
+              "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+              "    var format_dropdown = fig.format_dropdown;\n",
+              "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+              "    fig.ondownload(fig, format);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
+              "    var size = msg['size'];\n",
+              "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
+              "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
+              "        fig.send_message('refresh', {});\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
+              "    var x0 = msg['x0'] / fig.ratio;\n",
+              "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
+              "    var x1 = msg['x1'] / fig.ratio;\n",
+              "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
+              "    x0 = Math.floor(x0) + 0.5;\n",
+              "    y0 = Math.floor(y0) + 0.5;\n",
+              "    x1 = Math.floor(x1) + 0.5;\n",
+              "    y1 = Math.floor(y1) + 0.5;\n",
+              "    var min_x = Math.min(x0, x1);\n",
+              "    var min_y = Math.min(y0, y1);\n",
+              "    var width = Math.abs(x1 - x0);\n",
+              "    var height = Math.abs(y1 - y0);\n",
+              "\n",
+              "    fig.rubberband_context.clearRect(\n",
+              "        0,\n",
+              "        0,\n",
+              "        fig.canvas.width / fig.ratio,\n",
+              "        fig.canvas.height / fig.ratio\n",
+              "    );\n",
+              "\n",
+              "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
+              "    // Updates the figure title.\n",
+              "    fig.header.textContent = msg['label'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
+              "    fig.rubberband_canvas.style.cursor = msg['cursor'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
+              "    fig.message.textContent = msg['message'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
+              "    // Request the server to send over a new figure.\n",
+              "    fig.send_draw_message();\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
+              "    fig.image_mode = msg['mode'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
+              "    for (var key in msg) {\n",
+              "        if (!(key in fig.buttons)) {\n",
+              "            continue;\n",
+              "        }\n",
+              "        fig.buttons[key].disabled = !msg[key];\n",
+              "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
+              "    if (msg['mode'] === 'PAN') {\n",
+              "        fig.buttons['Pan'].classList.add('active');\n",
+              "        fig.buttons['Zoom'].classList.remove('active');\n",
+              "    } else if (msg['mode'] === 'ZOOM') {\n",
+              "        fig.buttons['Pan'].classList.remove('active');\n",
+              "        fig.buttons['Zoom'].classList.add('active');\n",
+              "    } else {\n",
+              "        fig.buttons['Pan'].classList.remove('active');\n",
+              "        fig.buttons['Zoom'].classList.remove('active');\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.updated_canvas_event = function () {\n",
+              "    // Called whenever the canvas gets updated.\n",
+              "    this.send_message('ack', {});\n",
+              "};\n",
+              "\n",
+              "// A function to construct a web socket function for onmessage handling.\n",
+              "// Called in the figure constructor.\n",
+              "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
+              "    return function socket_on_message(evt) {\n",
+              "        if (evt.data instanceof Blob) {\n",
+              "            var img = evt.data;\n",
+              "            if (img.type !== 'image/png') {\n",
+              "                /* FIXME: We get \"Resource interpreted as Image but\n",
+              "                 * transferred with MIME type text/plain:\" errors on\n",
+              "                 * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+              "                 * to be part of the websocket stream */\n",
+              "                img.type = 'image/png';\n",
+              "            }\n",
+              "\n",
+              "            /* Free the memory for the previous frames */\n",
+              "            if (fig.imageObj.src) {\n",
+              "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+              "                    fig.imageObj.src\n",
+              "                );\n",
+              "            }\n",
+              "\n",
+              "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+              "                img\n",
+              "            );\n",
+              "            fig.updated_canvas_event();\n",
+              "            fig.waiting = false;\n",
+              "            return;\n",
+              "        } else if (\n",
+              "            typeof evt.data === 'string' &&\n",
+              "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
+              "        ) {\n",
+              "            fig.imageObj.src = evt.data;\n",
+              "            fig.updated_canvas_event();\n",
+              "            fig.waiting = false;\n",
+              "            return;\n",
+              "        }\n",
+              "\n",
+              "        var msg = JSON.parse(evt.data);\n",
+              "        var msg_type = msg['type'];\n",
+              "\n",
+              "        // Call the  \"handle_{type}\" callback, which takes\n",
+              "        // the figure and JSON message as its only arguments.\n",
+              "        try {\n",
+              "            var callback = fig['handle_' + msg_type];\n",
+              "        } catch (e) {\n",
+              "            console.log(\n",
+              "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
+              "                msg\n",
+              "            );\n",
+              "            return;\n",
+              "        }\n",
+              "\n",
+              "        if (callback) {\n",
+              "            try {\n",
+              "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+              "                callback(fig, msg);\n",
+              "            } catch (e) {\n",
+              "                console.log(\n",
+              "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
+              "                    e,\n",
+              "                    e.stack,\n",
+              "                    msg\n",
+              "                );\n",
+              "            }\n",
+              "        }\n",
+              "    };\n",
+              "};\n",
+              "\n",
+              "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+              "mpl.findpos = function (e) {\n",
+              "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+              "    var targ;\n",
+              "    if (!e) {\n",
+              "        e = window.event;\n",
+              "    }\n",
+              "    if (e.target) {\n",
+              "        targ = e.target;\n",
+              "    } else if (e.srcElement) {\n",
+              "        targ = e.srcElement;\n",
+              "    }\n",
+              "    if (targ.nodeType === 3) {\n",
+              "        // defeat Safari bug\n",
+              "        targ = targ.parentNode;\n",
+              "    }\n",
+              "\n",
+              "    // pageX,Y are the mouse positions relative to the document\n",
+              "    var boundingRect = targ.getBoundingClientRect();\n",
+              "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
+              "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
+              "\n",
+              "    return { x: x, y: y };\n",
+              "};\n",
+              "\n",
+              "/*\n",
+              " * return a copy of an object with only non-object keys\n",
+              " * we need this to avoid circular references\n",
+              " * https://stackoverflow.com/a/24161582/3208463\n",
+              " */\n",
+              "function simpleKeys(original) {\n",
+              "    return Object.keys(original).reduce(function (obj, key) {\n",
+              "        if (typeof original[key] !== 'object') {\n",
+              "            obj[key] = original[key];\n",
+              "        }\n",
+              "        return obj;\n",
+              "    }, {});\n",
+              "}\n",
+              "\n",
+              "mpl.figure.prototype.mouse_event = function (event, name) {\n",
+              "    var canvas_pos = mpl.findpos(event);\n",
+              "\n",
+              "    if (name === 'button_press') {\n",
+              "        this.canvas.focus();\n",
+              "        this.canvas_div.focus();\n",
+              "    }\n",
+              "\n",
+              "    var x = canvas_pos.x * this.ratio;\n",
+              "    var y = canvas_pos.y * this.ratio;\n",
+              "\n",
+              "    this.send_message(name, {\n",
+              "        x: x,\n",
+              "        y: y,\n",
+              "        button: event.button,\n",
+              "        step: event.step,\n",
+              "        guiEvent: simpleKeys(event),\n",
+              "    });\n",
+              "\n",
+              "    /* This prevents the web browser from automatically changing to\n",
+              "     * the text insertion cursor when the button is pressed.  We want\n",
+              "     * to control all of the cursor setting manually through the\n",
+              "     * 'cursor' event from matplotlib */\n",
+              "    event.preventDefault();\n",
+              "    return false;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
+              "    // Handle any extra behaviour associated with a key event\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.key_event = function (event, name) {\n",
+              "    // Prevent repeat events\n",
+              "    if (name === 'key_press') {\n",
+              "        if (event.key === this._key) {\n",
+              "            return;\n",
+              "        } else {\n",
+              "            this._key = event.key;\n",
+              "        }\n",
+              "    }\n",
+              "    if (name === 'key_release') {\n",
+              "        this._key = null;\n",
+              "    }\n",
+              "\n",
+              "    var value = '';\n",
+              "    if (event.ctrlKey && event.key !== 'Control') {\n",
+              "        value += 'ctrl+';\n",
+              "    }\n",
+              "    else if (event.altKey && event.key !== 'Alt') {\n",
+              "        value += 'alt+';\n",
+              "    }\n",
+              "    else if (event.shiftKey && event.key !== 'Shift') {\n",
+              "        value += 'shift+';\n",
+              "    }\n",
+              "\n",
+              "    value += 'k' + event.key;\n",
+              "\n",
+              "    this._key_event_extra(event, name);\n",
+              "\n",
+              "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
+              "    return false;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
+              "    if (name === 'download') {\n",
+              "        this.handle_save(this, null);\n",
+              "    } else {\n",
+              "        this.send_message('toolbar_button', { name: name });\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
+              "    this.message.textContent = tooltip;\n",
+              "};\n",
+              "\n",
+              "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
+              "// prettier-ignore\n",
+              "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
+              "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+              "\n",
+              "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+              "\n",
+              "mpl.default_extension = \"png\";/* global mpl */\n",
+              "\n",
+              "var comm_websocket_adapter = function (comm) {\n",
+              "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+              "    // object with the appropriate methods. Currently this is a non binary\n",
+              "    // socket, so there is still some room for performance tuning.\n",
+              "    var ws = {};\n",
+              "\n",
+              "    ws.binaryType = comm.kernel.ws.binaryType;\n",
+              "    ws.readyState = comm.kernel.ws.readyState;\n",
+              "    function updateReadyState(_event) {\n",
+              "        if (comm.kernel.ws) {\n",
+              "            ws.readyState = comm.kernel.ws.readyState;\n",
+              "        } else {\n",
+              "            ws.readyState = 3; // Closed state.\n",
+              "        }\n",
+              "    }\n",
+              "    comm.kernel.ws.addEventListener('open', updateReadyState);\n",
+              "    comm.kernel.ws.addEventListener('close', updateReadyState);\n",
+              "    comm.kernel.ws.addEventListener('error', updateReadyState);\n",
+              "\n",
+              "    ws.close = function () {\n",
+              "        comm.close();\n",
+              "    };\n",
+              "    ws.send = function (m) {\n",
+              "        //console.log('sending', m);\n",
+              "        comm.send(m);\n",
+              "    };\n",
+              "    // Register the callback with on_msg.\n",
+              "    comm.on_msg(function (msg) {\n",
+              "        //console.log('receiving', msg['content']['data'], msg);\n",
+              "        var data = msg['content']['data'];\n",
+              "        if (data['blob'] !== undefined) {\n",
+              "            data = {\n",
+              "                data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
+              "            };\n",
+              "        }\n",
+              "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+              "        ws.onmessage(data);\n",
+              "    });\n",
+              "    return ws;\n",
+              "};\n",
+              "\n",
+              "mpl.mpl_figure_comm = function (comm, msg) {\n",
+              "    // This is the function which gets called when the mpl process\n",
+              "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+              "\n",
+              "    var id = msg.content.data.id;\n",
+              "    // Get hold of the div created by the display call when the Comm\n",
+              "    // socket was opened in Python.\n",
+              "    var element = document.getElementById(id);\n",
+              "    var ws_proxy = comm_websocket_adapter(comm);\n",
+              "\n",
+              "    function ondownload(figure, _format) {\n",
+              "        window.open(figure.canvas.toDataURL());\n",
+              "    }\n",
+              "\n",
+              "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
+              "\n",
+              "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+              "    // web socket which is closed, not our websocket->open comm proxy.\n",
+              "    ws_proxy.onopen();\n",
+              "\n",
+              "    fig.parent_element = element;\n",
+              "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+              "    if (!fig.cell_info) {\n",
+              "        console.error('Failed to find cell for figure', id, fig);\n",
+              "        return;\n",
+              "    }\n",
+              "    fig.cell_info[0].output_area.element.on(\n",
+              "        'cleared',\n",
+              "        { fig: fig },\n",
+              "        fig._remove_fig_handler\n",
+              "    );\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
+              "    var width = fig.canvas.width / fig.ratio;\n",
+              "    fig.cell_info[0].output_area.element.off(\n",
+              "        'cleared',\n",
+              "        fig._remove_fig_handler\n",
+              "    );\n",
+              "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
+              "\n",
+              "    // Update the output cell to use the data from the current canvas.\n",
+              "    fig.push_to_output();\n",
+              "    var dataURL = fig.canvas.toDataURL();\n",
+              "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+              "    // the notebook keyboard shortcuts fail.\n",
+              "    IPython.keyboard_manager.enable();\n",
+              "    fig.parent_element.innerHTML =\n",
+              "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+              "    fig.close_ws(fig, msg);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
+              "    fig.send_message('closing', msg);\n",
+              "    // fig.ws.close()\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
+              "    // Turn the data on the canvas into data in the output cell.\n",
+              "    var width = this.canvas.width / this.ratio;\n",
+              "    var dataURL = this.canvas.toDataURL();\n",
+              "    this.cell_info[1]['text/html'] =\n",
+              "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.updated_canvas_event = function () {\n",
+              "    // Tell IPython that the notebook contents must change.\n",
+              "    IPython.notebook.set_dirty(true);\n",
+              "    this.send_message('ack', {});\n",
+              "    var fig = this;\n",
+              "    // Wait a second, then push the new image to the DOM so\n",
+              "    // that it is saved nicely (might be nice to debounce this).\n",
+              "    setTimeout(function () {\n",
+              "        fig.push_to_output();\n",
+              "    }, 1000);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_toolbar = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var toolbar = document.createElement('div');\n",
+              "    toolbar.classList = 'btn-toolbar';\n",
+              "    this.root.appendChild(toolbar);\n",
+              "\n",
+              "    function on_click_closure(name) {\n",
+              "        return function (_event) {\n",
+              "            return fig.toolbar_button_onclick(name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    function on_mouseover_closure(tooltip) {\n",
+              "        return function (event) {\n",
+              "            if (!event.currentTarget.disabled) {\n",
+              "                return fig.toolbar_button_onmouseover(tooltip);\n",
+              "            }\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    fig.buttons = {};\n",
+              "    var buttonGroup = document.createElement('div');\n",
+              "    buttonGroup.classList = 'btn-group';\n",
+              "    var button;\n",
+              "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+              "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+              "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+              "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+              "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+              "\n",
+              "        if (!name) {\n",
+              "            /* Instead of a spacer, we start a new button group. */\n",
+              "            if (buttonGroup.hasChildNodes()) {\n",
+              "                toolbar.appendChild(buttonGroup);\n",
+              "            }\n",
+              "            buttonGroup = document.createElement('div');\n",
+              "            buttonGroup.classList = 'btn-group';\n",
+              "            continue;\n",
+              "        }\n",
+              "\n",
+              "        button = fig.buttons[name] = document.createElement('button');\n",
+              "        button.classList = 'btn btn-default';\n",
+              "        button.href = '#';\n",
+              "        button.title = name;\n",
+              "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
+              "        button.addEventListener('click', on_click_closure(method_name));\n",
+              "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+              "        buttonGroup.appendChild(button);\n",
+              "    }\n",
+              "\n",
+              "    if (buttonGroup.hasChildNodes()) {\n",
+              "        toolbar.appendChild(buttonGroup);\n",
+              "    }\n",
+              "\n",
+              "    // Add the status bar.\n",
+              "    var status_bar = document.createElement('span');\n",
+              "    status_bar.classList = 'mpl-message pull-right';\n",
+              "    toolbar.appendChild(status_bar);\n",
+              "    this.message = status_bar;\n",
+              "\n",
+              "    // Add the close button to the window.\n",
+              "    var buttongrp = document.createElement('div');\n",
+              "    buttongrp.classList = 'btn-group inline pull-right';\n",
+              "    button = document.createElement('button');\n",
+              "    button.classList = 'btn btn-mini btn-primary';\n",
+              "    button.href = '#';\n",
+              "    button.title = 'Stop Interaction';\n",
+              "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
+              "    button.addEventListener('click', function (_evt) {\n",
+              "        fig.handle_close(fig, {});\n",
+              "    });\n",
+              "    button.addEventListener(\n",
+              "        'mouseover',\n",
+              "        on_mouseover_closure('Stop Interaction')\n",
+              "    );\n",
+              "    buttongrp.appendChild(button);\n",
+              "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
+              "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
+              "    var fig = event.data.fig;\n",
+              "    if (event.target !== this) {\n",
+              "        // Ignore bubbled events from children.\n",
+              "        return;\n",
+              "    }\n",
+              "    fig.close_ws(fig, {});\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._root_extra_style = function (el) {\n",
+              "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
+              "    // this is important to make the div 'focusable\n",
+              "    el.setAttribute('tabindex', 0);\n",
+              "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+              "    // off when our div gets focus\n",
+              "\n",
+              "    // location in version 3\n",
+              "    if (IPython.notebook.keyboard_manager) {\n",
+              "        IPython.notebook.keyboard_manager.register_events(el);\n",
+              "    } else {\n",
+              "        // location in version 2\n",
+              "        IPython.keyboard_manager.register_events(el);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
+              "    // Check for shift+enter\n",
+              "    if (event.shiftKey && event.which === 13) {\n",
+              "        this.canvas_div.blur();\n",
+              "        // select the cell after this one\n",
+              "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
+              "        IPython.notebook.select(index + 1);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+              "    fig.ondownload(fig, null);\n",
+              "};\n",
+              "\n",
+              "mpl.find_output_cell = function (html_output) {\n",
+              "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+              "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+              "    // IPython event is triggered only after the cells have been serialised, which for\n",
+              "    // our purposes (turning an active figure into a static one), is too late.\n",
+              "    var cells = IPython.notebook.get_cells();\n",
+              "    var ncells = cells.length;\n",
+              "    for (var i = 0; i < ncells; i++) {\n",
+              "        var cell = cells[i];\n",
+              "        if (cell.cell_type === 'code') {\n",
+              "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
+              "                var data = cell.output_area.outputs[j];\n",
+              "                if (data.data) {\n",
+              "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+              "                    data = data.data;\n",
+              "                }\n",
+              "                if (data['text/html'] === html_output) {\n",
+              "                    return [cell, data, j];\n",
+              "                }\n",
+              "            }\n",
+              "        }\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "// Register the function which deals with the matplotlib target/channel.\n",
+              "// The kernel may be null if the page has been refreshed.\n",
+              "if (IPython.notebook.kernel !== null) {\n",
+              "    IPython.notebook.kernel.comm_manager.register_target(\n",
+              "        'matplotlib',\n",
+              "        mpl.mpl_figure_comm\n",
+              "    );\n",
+              "}\n"
+            ],
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/html": [
+              "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA+gAAAMgCAYAAACwGEg9AAAAAXNSR0IArs4c6QAAIABJREFUeF7s3Qm4VtPf//FPg1SaRKVUSooyZooMFcosYymPuaSQhMpcNJjHX1KUMlamEEJooCSZQkiaDYUKlebn+u7tNJ/OfZ9zD2vt/d7X5Xr+D3tY39f3Xv/r+Zy999qF1q1bt05sCCCAAAIIIIAAAggggAACCCCQVYFCBPSs+nNxBBBAAAEEEEAAAQQQQAABBAIBAjo/BAQQQAABBBBAAAEEEEAAAQQcECCgO9AEhoAAAggggAACCCCAAAIIIIAAAZ3fAAIIIIAAAggggAACCCCAAAIOCBDQHWgCQ0AAAQQQQAABBBBAAAEEEECAgM5vAAEEEEAAAQQQQAABBBBAAAEHBAjoDjSBISCAAAIIIIAAAggggAACCCBAQOc3gAACCCCAAAIIIIAAAggggIADAgR0B5rAEBBAAAEEEEAAAQQQQAABBBAgoPMbQAABBBBAAAEEEEAAAQQQQMABAQK6A01gCAgggAACCCCAAAIIIIAAAggQ0PkNIIAAAggggAACCCCAAAIIIOCAAAHdgSYwBAQQQAABBBBAAAEEEEAAAQQI6PwGEEAAAQQQQAABBBBAAAEEEHBAgIDuQBMYAgIIIIAAAggggAACCCCAAAIEdH4DCCCAAAIIIIAAAggggAACCDggQEB3oAkMAQEEEEAAAQQQQAABBBBAAAECOr8BBBBAAAEEEEAAAQQQQAABBBwQIKA70ASGgAACCCCAAAIIIIAAAggggAABnd8AAggggAACCCCAAAIIIIAAAg4IENAdaAJDQAABBBBAAAEEEEAAAQQQQICAzm8AAQQQQAABBBBAAAEEEEAAAQcECOgONIEhIIAAAggggAACCCCAAAIIIEBA5zeAAAIIIIAAAggggAACCCCAgAMCBHQHmsAQEEAAAQQQQAABBBBAAAEEECCg8xtAAAEEEEAAAQQQQAABBBBAwAEBAroDTWAICCCAAAIIIIAAAggggAACCBDQ+Q0ggAACCCCAAAIIIIAAAggg4IAAAd2BJjAEBBBAAAEEEEAAAQQQQAABBAjo/AYQQAABBBBAAAEEEEAAAQQQcECAgO5AExgCAggggAACCCCAAAIIIIAAAgR0fgMIIIAAAggggAACCCCAAAIIOCBAQHegCQwBAQQQQAABBBBAAAEEEEAAAQI6vwEEEEAAAQQQQAABBBBAAAEEHBAgoDvQBIaAAAIIIIAAAggggAACCCCAAAGd3wACCCCAAAIIIIAAAggggAACDggQ0B1oAkNAAAEEEEAAAQQQQAABBBBAgIDObwABBBBAAAEEEEAAAQQQQAABBwQI6A40gSEggAACCCCAAAIIIIAAAgggQEDnN4AAAggggAACCCCAAAIIIICAAwIEdAeawBAQQAABBBBAAAEEEEAAAQQQIKDzG0AAAQQQQAABBBBAAAEEEEDAAQECugNNYAgIIIAAAggggAACCCCAAAIIEND5DSCAAAIIIIAAAggggAACCCDggAAB3YEmMAQEEEAAAQQQQAABBBBAAAEECOj8BhBAAAEEEEAAAQQQQAABBBBwQICA7kATGAICCCCAAAIIIIAAAggggAACBHR+AwgggAACCCCAAAIIIIAAAgg4IEBAd6AJDAEBBBBAAAEEEEAAAQQQQAABAjq/AQQQQAABBBBAAAEEEEAAAQQcECCgO9AEhoAAAggggAACCCCAAAIIIIAAAZ3fAAIIIIAAAggggAACCCCAAAIOCBDQHWgCQ0AAAQQQQAABBBBAAAEEEECAgM5vAAEEEEAAAQQQQAABBBBAAAEHBAjoDjSBISCAAAIIIIAAAggggAACCCBAQOc3gAACCCCAAAIIIIAAAggggIADAgR0B5rAEBBAAAEEEEAAAQQQQAABBBAgoPMbQAABBBBAAAEEEEAAAQQQQMABAQK6A01gCAgggAACCCCAAAIIIIAAAggQ0PkNIIAAAggggAACCCCAAAIIIOCAAAHdgSYwBAQQQAABBBBAAAEEEEAAAQQI6PwGEEAAAQQQQAABBBBAAAEEEHBAgIDuQBMYAgIIIIAAAggggAACCCCAAAIEdH4DCCCAAAIIIIAAAggggAACCDggQEB3oAkMAQEEEEAAAQQQQAABBBBAAAECOr8BBBBAAAEEEEAAAQQQQAABBBwQIKA70ASGgAACCCCAAAIIIIAAAggggAABnd8AAggggAACCCCAAAIIIIAAAg4IENAdaAJDQAABBBBAAAEEEEAAAQQQQICAzm8AAQQQQAABBBBAAAEEEEAAAQcECOgONIEhIIAAAggggAACCCCAAAIIIEBA5zeAAAIIIIAAAggggAACCCCAgAMCBHQHmsAQEEAAAQQQQAABBBBAAAEEECCg8xtAAAEEEEAAAQQQQAABBBBAwAEBAroDTWAICCCAAAIIIIAAAggggAACCBDQ+Q0ggAACCCBQAIGvvvpKDzzwgMaMGaNffvlFRYsWVZ06dXTuueeqTZs2Kl++fAHOvvVDe/furXr16un000/P89yzZs1SzZo1dc899+i6667b5v7du3dXjx49tG7dujzPm7PDsmXLdPfdd6tx48bBP2wIIIAAAgggkH8BAnr+7TgSAQQQQCDmAo8//rg6dOigPffcM/ifFppXrVqlTz/9VPbf9t9/f73yyispVypVqpTOPvtsDR48OM9zJxPQ582bJ/vnsMMOy/O8OTv8/vvvqlChgm677TZZwGdDAAEEEEAAgfwLENDzb8eRCCCAAAIxFpg4caKOOuooNW3aVCNGjND222+/icbKlSs1atQonXbaaSlXSldAz89A0xXQly9fruLFi6tQoUL5GRbHIIAAAggg4KUAAd3LtjFoBBBAAIFsC5x66qlBAP/pp59UrVq1PIezdu1a3XvvvRo0aJBmzpypsmXL6oQTTpA9rl61atX1x3/++ee65ZZb9Mknn2jJkiXaaaedVL9+ffXv3z/Yb2uBtVGjRsEj9lvbNr6DXrhwYT3yyCNauHCh9t133+DR/I3vlm/tEff3339ft99+u6ZOnSp7nN3ulh9yyCF6+umntWDBguDx+c23Cy+8cP3d/Q8//DC4u271rFmzRgcccIBuuukmnXzyyesPsycBLr74Yr399tsaOnSoXn/9dVnwHzdunI4++mg999xzatWq1SaXeeqpp2TXsfPaeNgQQAABBBCIggABPQpdpAYEEEAAgYwKWNAsU6ZMEHI//vjjhK7drl07DRgwQFdeeaVOOeUUWXC2IG53iT/77DPtvPPOWrp0qXbbbbcg9Hbp0kWVKlXSr7/+qg8++EAdO3ZU3bp1g+sdc8wxatKkSXC8bTYWe7x+WwG9Ro0a2muvvXT55ZcHu9mx9jh7zh8L7N9tHtBtjHZNe1LgiiuuULly5TR//vzgDxMPP/ywSpQoEfxhwP7QcOmllwbv3NtmIb5WrVoaO3Zs8ITBfvvtF9RjTxk8+uijevfdd/X888+rZcuWwf45AX3XXXcNgvsZZ5wRWNg79ha+S5YsKQv6G2+HHnpo8L9aQGdDAAEEEEAgKgIE9Kh0kjoQQAABBDIm8Ntvv2mXXXYJFoKzoJnX9t133wVB195T79u37/rdLVw2aNBAN954o3r16qUpU6bo4IMPDh6Zb968ea6nzc8j7vbHBLs7X6RIkeC8kydPloVcG7/VsbWA/tJLLwXvun/xxRfB+/Rb27b1iPvhhx8ePGEwY8YM2Zhty7mLvnjxYs2ZMyd4IiAnoF9wwQUaMmTIJpfJ+W82drv7vvHYbV87hg0BBBBAAIGoCBDQo9JJ6kAAAQQQyJhAsgG9X79+QTjf2uPYdufb7oDbnXF7pN3unlesWFGdOnUKHu/e2p3x/AT0bt26qU+fPuuNVqxYEdy9v/POO9W1a9etBnQL1nZ9C8Y2fruTvvvuu2/inFtAtzvgpUuXVvv27Tf5o4QdbKu+2zWnTZsW3NXPCeGvvvrqFu/s2zirV68e/HtbeM82C+V2F3/u3LlbvPufsR8BF0IAAQQQQCANAgT0NKBySgQQQACBaAsk+4h7z549g0fKLVBu/L65KR133HGaPXu2pk+fHqDZu952N/2dd97RokWLVLlyZbVt21Y333yztttuu2Cf/AT0rX1mze5eb7z6+tbeQR8/fnwQqO0xewvdFtDtcfurr746GEtuAd0en7d38++4445g7BtvzzzzjM4///zgsfUjjjhifUDP7X3yW2+9Vffdd1/weL2tkm/n7dy5c/D+PhsCCCCAAAJREiCgR6mb1IIAAgggkDEBu6P71ltvBe9wbx66Nx9EXnfQbcE4WxV+482+RW7fWLe7yw8++GBw99vugmc6oOeMyf4oYZ+Ps0Xmnn322fWPxm/rDro9GWDvvG/8WL+dL+cOuj36b5+oy7mDbo/d2yP+m2/2fXl7N9/u9v/777+ywG6PztuddTYEEEAAAQSiJEBAj1I3qQUBBBBAIGMCG39mzR7NLlas2CbXtju99hi2rfb+/fffB49y253nhx56aP1+Oe+B26rmdpc9t23HHXcMFlsbPnx4sIut7G533ocNG5Znvdv6Dnoid9A3v4A9hm+LxV1//fVB0P7777+DR/RtEbi77rprk90bNmwY/AHDwrQtKGebrWZvj8zb0wGbv4OeW0C348477zxNmjRJ9vm6gw46KC3fl88Tkx0QQAABBBBIswABPc3AnB4BBBBAILoC9k60vZtt4dvetd57772DR7BtQTNbsX2fffZZHyRtFXfb3x4NP/HEE9ev4m4rm9v+FrpHjhwZrHJuq5fbo+R2F/3ll1/WY489FpzPHnW3rXHjxsH720888UTwCLy96213ore2FSSg23XtM2u2srrdrba71/aZuBdffDH4JFqzZs2CS9oK8fY+u63sXr58+WBFevt3Oau4H3jggbruuuuCP2JYffb4/tZWcd9WQM9ZUM+uN3r0aB177LHR/WFRGQIIIIBAbAUI6LFtPYUjgAACCKRC4Msvvwy+J27vaNsn0ew98Tp16gR3zu2TavbJMdtyvoM+cODATb6Dbo+u5zwib3fae/ToESwm9/PPPweB1oK3/RHAvvmds9k17bNnFuzt2+SJfgfdQvLGW1530G3hOrtLbp+Bs9rs3Xf7o8O1114b1Jezvffee8Ed9W+//Va2qNvWvoNud7/NwFaDtycG7FNzOVtej7jn7GcL6NmdeLsOGwIIIIAAAlEUIKBHsavUhAACCCCAQMQE7H18C/f2Prv9wYINAQQQQACBKAoQ0KPYVWpCAAEEEEAgIgL2qTdb5d6+FW/vrP/4448qWbJkRKqjDAQQQAABBDYVIKDzi0AAAQQQQAABZwUuuugiPf3006pbt6769+8ffJaNDQEEEEAAgagKENCj2lnqQgABBBBAAAEEEEAAAQQQ8EqAgO5VuxgsAggggAACCCCAAAIIIIBAVAUI6FHtLHUhgAACCCCAAAIIIIAAAgh4JUBA96pdDBYBBBBAAAEEEEAAAQQQQCCqAgT0qHY2l7rsG7T2bd3SpUvLvn/LhgACCCCAAAIIIIAAAvEUWLdunf7++29VqVJFhQsXjieCY1UT0B1rSLqHM2/ePFWrVi3dl+H8CCCAAAIIIIAAAggg4InA3LlzVbVqVU9GG+1hEtCj3d8tqluyZInKlSsnm4RlypSJWfWUiwACCCCAAAIIIIAAAjkCf/31V3DzbvHixSpbtiwwDggQ0B1oQiaHYJPQJp8FdQJ6JuW5FgIIIIAAAggggAACbgmQDdzqh42GgO5eT9I6IiZhWnk5OQIIIIAAAggggAAC3giQDdxrFQHdvZ6kdURMwrTycnIEEEAAAQQQQAABBLwRIBu41yoCuns9SeuImIRp5eXkCCCAAAIIIIAAAgh4I0A2cK9VBHT3epLWETEJ08rLyRFAAAEEEEAAgdgK2Od8V65cGdv6XSx8u+22U5EiRXIdGtnAva4R0N3rSVpHxCRMKy8nRwABBBBAAAEEYilgwXzmzJmykM7mloB9wWmXXXZRoUKFthgY2cCtXtloCOju9SStI2ISppWXkyOAAAIIIIAAArETWLdunebMmaNVq1apSpUqKly4cOwMXCzY+rJs2TItWLAg+Mxy5cqVCeguNmqzMRHQPWhSKodIQE+lJudCAAEEEEAAAQQQsGD+448/BuGcb2m793v4448/gpBep06dLR53Jxu41y8Cuns9SeuImIRp5eXkCCCAAAIIIIBA7AT+/fff4PH2GjVqqESJErGr3/WCly9frlmzZqlmzZoqXrz4JsMlG7jXPQK6Qz2x/09t9uzZW4yoQ4cO6tu3ry666CINGTJkk//eoEEDffzxxwlXwSRMmIodEUAAAQQQQAABBBIQyAnoWwuACRzOLmkW2FZ/yAZpxs/H6Qno+UBL1yELFy7UmjVr1p/+66+/VtOmTfXBBx+ocePGQUD/7bff9OSTT67fp1ixYipfvnzCQ2ISJkzFjggggAACCCCAAAIJCMQ1oOfclf788891wAEHJCAlDR48WJ06ddLixYsT2j+RnfIaBwE9EUV39iGgu9OLLUZik3fkyJGaPn16sOqiBXSbzCNGjMj3qAno+abjQAQQQAABBBBAAIGtCPge0OfOnavu3bvrrbfe0u+//x4spnb66afr1ltv1U477ZRrz+3Gmt1g23nnnVW0aNGEfhv2uPnff/+tihUrJrR/IjsR0BNR8mcfArqjvbJPVdhCG507d9aNN94YjNICuoVzu2tuKzE2atRIvXr12uYEX7FiheyfnM0CerVq1bRkyRKVKVPG0eoZFgIIIIAAAggggIAvAj4H9J9++kmHH354sIBaz549g/e0v/nmG11//fXBN93tVdKtPa1q/83+b3IXNgK6C11I3RgI6KmzTOmZhg8frtatWwefrLCgbtuwYcNUqlQp7bbbbsFCHLfccotWr16tKVOmaPvtt9/q9e2vgT169NjivxHQU9ouToYAAggggAACCMRWwOeAfuKJJ8peK/3hhx82WeDu119/Va1atXTBBReoX79+wQJ4bdq0CVarf+WVV4I77PZ/Y1ug3/gR99dee03XXnut5s2bp8MOOyy4wWb/LFq0KLjBtvkj7vZ/q9sNODvG/m9728/G9Pjjj6t06dLBb2rUqFHBHw9snEWKFAn+oPDQQw8F47ONgB6tqUdAd7Sfxx9/fPBXuddffz3XEf7yyy9BWB86dKjOPPPMre7HHXRHG8ywEEAAAQQQQACBiAj4GtD//PPP4PF0eyL1hhtu2KIbl112mV588UXZZ8osiFt4thBt4dw2e6x944BuQdnuxF999dVBmLfgft1112n+/PnbDOj33XefmjVrFgR+u0aLFi10ySWXBOOy7aWXXgped9133321dOnS4NF7u9YXX3wRfHOegB6RifRfGQR0B/tpK7nvvvvuevnll9W8efNtjrB27drB/wfQtWvXhCrhHfSEmNgJAQQQQAABBBBAIEGB3AL60qW5n6BIEWnjL35ta9/ChaWNv96W27477JDggP/bbdKkScFd7pw74psf/cADDwSvm9oizYceeqjq168f7JuzbR6Mu3XrpjfeeENTp05dv8/NN98cBO1t3UG/5557ZHfsc+6Yd+nSRePGjcv1S0323ru9w27X2WeffQjoybXd+b0J6A62yB516d+/v2zBim0tOGF/zdt11101YMCA4PGbRDYCeiJK7IMAAggggAACCCCQqEBuAb1QodzPcNJJ0htvbPjvFq6XLdv6/o0aSWPGbPhvFSpIv/++5b7r1iU64nC/vAL6/fffHzx6vmDBAh1yyCFq27atbrrpplwD+hlnnKEdd9xRgwYNWr+PPfJuN9y2FdBfeOGF4L33nM3+MPDII4/I3o+3bcaMGcGde3sf3haxW7t2bXAn3f4YcNJJJxHQk2u783sT0B1rkU04e1SmVatWuvPOO9eP7p9//glWlzzrrLOClSXtL3a2eJy9oz5t2rT1f3HLqxwCel5C/HcEEEAAAQQQQACBZAR8Deh2s6tChQrB+905izJvXPfmj7jbF5bsn5xt8zvo9ui7rfo+cODA9fu8+uqrwSPxeb2Dbo+r52wPPvig7B87v2316tULFnm2O+u2NpXlBbtznnPnn0fck/m1ur8vAd2xHr3zzjuy98+///774B2WnM0+yWCT295lsU+tWUhv0qSJ7rjjjmDCJroR0BOVYj8EEEAAAQQQQACBRAR8fcTdarP/u9vuXttnjUts9Bz91haJyyug2yPub775pr766qv1bHbn2/4AkN+Abn9EsPfk7ZH3o446Kjjvhx9+GPy/CeiJ/Dr924eA7l/PCjRiAnqB+DgYAQQQQAABBBBAYDMBXxeJszIsmDds2FB169bd4jNrtthyzmfWbBX3vAK6fWVpzz331DXXXKNLL700WMQtZ0V3u8FWtmzZXFdxz+0Out0tt/fNbWX32267LXh61v4QMHnyZAJ6RGciAT2ijc2tLAJ6zBpOuQgggAACCCCAQJoFfA7oRmMLNNurpPY5M7tjvcsuuwRPrlogtkfWbUskoNt+OZ9Zs7Wk7HNoLVu2VPv27WVPwxYvXjzpgG7nHD16tDp27Bi8k25/AHj44YfVuHFjAnqaf9fZOj0BPVvyWbouAT1L8FwWAQQQQAABBBCIqIDvAT2dbbEV3B977LFg8edsbdvqD9kgW13J/boEdPd6ktYRMQnTysvJEUAAAQQQQACB2AkQ0De0/NFHHw1WfLc77x999JGuuuoqXXnllcHj89naCOjZks/fdQno+XPz9igCuretY+AIIIAAAggggICTAgT0DW2x98+HDRumP//8U9WrV9f555+vG264YZufTk53Uwno6RZO7fkJ6Kn1dP5sPgX0tWulwoWdJ2WACCCAAAIIIIBArAUI6G63n4Dudn82Hx0B3a9+FXi0vgT0Bx6Qbr9dGjtW2m+/ApfNCRBAAAEEEEAAAQTSJEBATxNsik5LQE8RZIZOQ0DPELQrl/EloBcqFIrtu6+00ackXWFkHAgggAACCCCAAAL/CRDQ3f4pENDd7s/moyOg+9WvAo/Wl4B+xhnSiBHSuedKzz9f4LI5AQIIIIAAAggggECaBHICoH2KrESJEmm6CqfNr4B94m3WrFmqWbNm8Km3jTdfskF+a/fxOAK6j10rwJh9mYR9+0pXXilZUH/55QIUzKEIIIAAAggggAACaRVYtWqVfvzxR1WpUkVly5ZN67U4efIC9m33BQsWqE6dOipSpAgBPXnCjB5BQM8od/Yv5ktAf+01qXlz6aCDpE8/zb4bI0AAAQQQQAABBBDYusC6des0Z84cWVC3kF6YVX6d+KlYX5YtWxaE83Llyqly5cpbjMuXbOAEaIYGQUDPELQrl/FlEl53nXTffaHaunWu6DEOBBBAAAEEEEAAga0JrFy5UjNnztRa+wwPm1MCFs532WUXFcpZ5Gmj0fmSDZwCTfNgCOhpBnbt9L5Mwj32kGbMCPWWLZN4ncm1XxLjQQABBBBAAAEENhWwcG5Bnc0dge22226Lx9o3Hp0v2cAd0fSPhICefmOnruDLJKxfX/rii/Ad9GeekUqWdIqRwSCAAAIIIIAAAggg4L2AL9nAe+gkCiCgJ4EVhV19mYT27fOpU6XRo6Vjj42CPDUggAACCCCAAAIIIOCWgC/ZwC219I6GgJ5eX+fO7sskrFdPmjZNGjNGatTIOUYGhAACCCCAAAIIIICA9wK+ZAPvoZMogICeBFYUdvVlEtapI02fLvXqJZ16qrTvvlHQpwYEEEAAAQQQQAABBNwR8CUbuCOW/pEQ0NNv7NQVfJmEu+8uzZwZ0rVtKw0Y4BQjg0EAAQQQQAABBBBAwHsBX7KB99BJFEBATwIrCrv6MgmrV5fmzg3Fjz9eGjUqCvrUgAACCCCAAAIIIICAOwK+ZAN3xNI/EgJ6+o2duoIvk3DiROn116U+fSR7H/2bb5xiZDAIIIAAAggggAACCHgv4Es28B46iQII6ElgRWFXnybhDz9Ie+4plSol/fWXVKhQFDpADQgggAACCCCAAAIIuCHgUzZwQyz9oyCgp9/YqSv4NAmXL9/w/fM//5R23NEpSgaDAAIIIIAAAggggIDXAj5lA6+hkxg8AT0JrCjs6ssk7N9fWrdO6tRJWrFC+vJLyb6NzoYAAggggAACCCCAAAKpEfAlG6SmWj/OQkD3o08pG6Uvk7BECenff6WddpL++CN8H/2UU1LGwIkQQAABBBBAAAEEEIi9gC/ZIE6NIqDHqduyd7n/UtmyZbVkyRKVKVPG2eq3205avVq66y6pXLlwJffddnN2uAwMAQQQQAABBBBAAAHvBHzJBt7BFmDABPQC4Pl4qA+T0B5tL1w41P31V6lSJR+lGTMCCCCAAAIIIIAAAm4L+JAN3BZM/egI6Kk3dfqMPkzCNWukokVDRnu8vXx5p0kZHAIIIIAAAggggAACXgr4kA28hC3AoAnoBcDz8VAfJqEtCle8eKg7b57044/h++j2mDsbAggggAACCCCAAAIIpEbAh2yQmkr9OQsB3Z9epWSkPkzCpUvDb5/bNnq0dNxx4fvns2alhICTIIAAAggggAACCCCAgEfrU8WpWQT0OHXbk0m4ZEm4MJxtM2ZItWpJRYqEn1uz/8mGAAIIIIAAAggggAACBRfw4eZdwav06wwEdL/6VeDR+jAJV62S3n03XMX9pJPCx93tvXR73H3XXQtMwAkQQAABBBBAAAEEEEDAk5t3cWsUAT1mHfchoG/eEnu8fc4cacIE6fDDY9YwykUAAQQQQAABBBBAIE0CPmaDNFE4c1oCujOtyMxAfJyERx0lffihNGyY1KJFZpy4CgIIIIAAAggggAACURfwMRtEvScE9Kh3eLP6fJiEf/8tvfhi+Gh7q1ZS69bS889L99wjXXddzBpGuQgggAACCCCAAAIIpEnAh2yQptKdPS0B3dnWpGdFd51xAAAgAElEQVRgPkxC+6xa7dpSmTKSLRjXrZt0111Sx47SQw+lx4WzIoAAAggggAACCCAQNwEfskHcekJAj1nHfZiE330n1a0rlS8v/fGHNGmS9OWX0sEHSwceGLOGUS4CCCCAAAIIIIAAAmkS8CEbpKl0Z09LQHe2NekZmA+TcOpUab/9pIoVpd9+S48DZ0UAAQQQQAABBBBAIO4CPmSDuPWIgB6zjvswCT//PLxTXqWKNH9+zBpEuQgggAACCCCAAAIIZEjAh2yQIQpnLkNAd6YVmRmID5Nw8mTp0EMl+7zarFnS2rXS+PHhp9ZsFfftt8+MFVdBAAEEEEAAAQQQQCDKAj5kgyj7b602AnrMOu7DJJw4UWrYUKpVS7IF49atk0qVkpYtk374IVxAjg0BBBBAAAEEEEAAAQQKJuBDNihYhf4dTUD3r2cFGrEPk9Dulh99tLTnnpItGGebLRpn/+/33pOOOaZABByMAAIIIIAAAggggAACknzIBnFrFAE9Zh33YRIuXCiNGSOVLCmdfHLYoGbNpHfflZ58Urroopg1jXIRQAABBBBAAAEEEEiDgA/ZIA1lO31KArrT7Un94HydhG3aSAMHSj16SLfemnoXzogAAggggAACCCCAQNwEfM0GUe4TAT3K3d1Kbb5Owttvl267TbKg/vjjMWsa5SKAAAIIIIAAAgggkAYBX7NBGiicOSUB3ZlWZGYgPkzCefMkWyiuQgWpcePQxR5tv+SS8FH3t9/OjBVXQQABBBBAAAEEEEAgygI+ZIMo+2+tNgJ6zDruwyR8+WXprLOkI46QPvwwbJAtDnfcceFicd9+G7OmUS4CCCCAAAIIIIAAAmkQ8CEbpKFsp09JQHe6PakfnA+TcPhwqWVLqVGjcLE422zhuFdeCT+9duyxqXfhjAgggAACCCCAAAIIxE3Ah2wQt54Q0GPWcR8m4XPPSeedFwbx0aNj1iDKRQABBBBAAAEEEEAgQwI+ZIMMUThzGQK6M63IzEB8mIRPPSVdeKF0/PHSqFGZceEqCCCAAAIIIIAAAgjETcCHbBC3nhDQY9ZxHybhoEHSpZeG30AfOXJDg6ZMCd8/b9BAqlMnZo2jXAQQQAABBBBAAAEEUizgQzZIccnOn46A7nyLUjtAHybhgAFSu3bS6aeH753nbGecIY0YIfXtK3XokFoXzoYAAggggAACCCCAQNwEfMgGcesJAT1mHfdhEj76qHTFFdLZZ0svvLChQR07So88InXrJvXpE7PGUS4CCCCAAAIIIIAAAikW8CEbpLhk509HQHe+RakdoA+T8LvvpI8/lqpXl445ZkP9994rXX+91Lq19OyzqXXhbAgggAACCCCAAAIIxE3Ah2wQt54Q0GPWcZ8n4bBh0rnnSkcdJY0bF7PGUS4CCCCAAAIIIIAAAikW8DkbpJjCmdMR0J1pRWYG4vMknDhRathQ2m03adaszHhxFQQQQAABBBBAAAEEoirgczaIak8I6FHtbC51+TAJf/hBmj5dqlFD2nvvDYXMny9VrSoVLSr9+69UpEjMmke5CCCAAAIIIIAAAgikUMCHbJDCcr04FQHdizalbpA+TMIePaTu3aX27SVbMC5nW7NGKl5cWr1amjdP2nXX1LlwJgQQQAABBBBAAAEE4ibgQzaIW08I6DHruA+T8JZbpJ49pauukh5+eNMG2eJwO+0kHX20VLJkzJpHuQgggAACCCCAAAIIpFDAh2yQwnK9OBUB3Ys2pW6QPkzCG26Q7rxTuuYa6f77U1c7Z0IAAQQQQAABBBBAAIENAj5kg7j1i4Aes477MAntU2o5n1S7++6YNYhyEUAAAQQQQAABBBDIkIAP2SBDFM5choDuTCsyMxAfJmGnTtJDD0l2J713701dZsyQJkyQKlWSmjXLjBlXQQABBBBAAAEEEEAgigI+ZIMoum+rJgJ6zDruwyS88kqpb1/J3kW//fZNG2T/3v776adLr7wSs+ZRLgIIIIAAAggggAACKRTwIRuksFwvTkVA96JNqRukD5Pw8sul/v0lW8391ls3rf3116XTTpMOPFCaMiV1LpwJAQQQQAABBBBAAIG4CfiQDeLWEwJ6zDruwyQcO1b6+mvpkEOkQw/dtEFffikdcIBUoYK0YEHMmke5CCCAAAIIIIAAAgikUMCHbJDCcr04FQHdoTbVqFFDs2fP3mJEHTp0UN++fbVu3Tr16NFDAwYM0KJFi9SgQYPg3++9994JV+H7JPzzz/Aza7YtWyaVKJFw6eyIAAIIIIAAAggggAACGwn4ng2i2EwCukNdXbhwodasWbN+RF9//bWaNm2qDz74QI0bN9Zdd92lXr16afDgwapTp4569uypcePG6fvvv1fp0qUTqsT3SbhunWSlLl0q/fCDVLt2QmWzEwIIIIAAAggggAACCGwm4Hs2iGJDCegOd7VTp04aOXKkpk+fHoyySpUqsn/XtWvX4H9fsWKFKlWqFAT3du3aJVSJD5Nw6lTpjz+kOnWs5i3LqldPmjZNGj1aOvbYhMpmJwQQQAABBBBAAAEEECCgO/8bIKA72qKVK1cGgbxz58668cYb9dNPP6lWrVr67LPPVL9+/fWjbt68ucqVK6chQ4YkVIkPAf3ss6WXXgpXcu/QYcuyjj9eeucdadAg6eKLEyqbnRBAAAEEEEAAAQQQQICA7vxvgIDuaIuGDx+u1q1ba86cOUFQnzBhgo444gjNnz8/+N9ztssuuyx4b/3tt9/eaiV2l93+ydksoFerVk1LlixRmTJlnKzePqH26qvSgAFS27ZbDnHcuPD9c/s7hX0PnQ0BBBBAAAEEEEAAAQSSF/Dh5l3yVfl9BAHd0f4df/zxKlasmF6374pJ6wP6zz//rMqVK68fddu2bTV37lyNGjVqq5V07949WFhu883lgH7KKdIbb3CH3NGfJsNCAAEEEEAAAQQQiIgAAd29RhLQ3etJcEd8991318svvyx7hN22/D7i7uMd9BNOkOyBgKeeks4/38EGMSQEEEAAAQQQQAABBCIgQEB3r4kEdPd6Irvr3b9//+DOeNGiRYMR2ifW7NH2a665Rl26dAn+nb2nXrFixcgtEnfccdJ770nPPSe1arVlg774Qvr883ARuSOOcLCBDAkBBBBAAAEEEEAAAQ8ECOjuNYmA7lhP1q5dq5o1a6pVq1a68847Nxmdrdbep08fPfnkk6pdu7Z69+6tMWPGRO4za40aSfae+fDh0jnnbNmg7t0le2r/8sulfv0cayDDQQABBBBAAAEEEEDAEwECunuNIqA71pN33nlH9v65fdvcvnW+8WZ30e19cru7vmjRIjVo0EB9+/bVPvvsk3AVPkxCuys+YYL08svSGWdsWVrv3tJNN0mXXCINHJhw6eyIAAIIIIAAAggggAACGwn4kA3i1jACesw67sMktEfb580Lw3nt2ls26N57peuvD99Pt/fU2RBAAAEEEEAAAQQQQCB5AR+yQfJV+X0EAd3v/iU9+ihMwocflq6+WmrZUho6NGkCDkAAAQQQQAABBBBAAAFJUcgGUWskAT1qHc2jnihMwscek9q3D++w22PwbAgggAACCCCAAAIIIJC8QBSyQfJVu30EAd3t/qR8dD5MQlulfdUqaa+9pNKltyQYNEi69FLJvpf+32fiU+7ECRFAAAEEEEAAAQQQiLqAD9kg6j3YvD4Cesw67sMktLXxpk+Xxo+XjjxyywY9/bR0wQVSs2bh99LZEEAAAQQQQAABBBBAIHkBH7JB8lX5fQQB3e/+JT16Hybh7rtLM2dKEydKhx22ZYmzZ0uffCJVrrz1AJ80CgcggAACCCCAAAIIIBBDAR+yQdzaQkCPWcd9mITVq0tz50qTJ0sHHxyzBlEuAggggAACCCCAAAIZEvAhG2SIwpnLENCdaUVmBuLDJKxSRfrlF+nzz6UDDsiMC1dBAAEEEEAAAQQQQCBuAj5kg7j1hIAes477MAkrVpQWLpSmTpX22WfLBi1YII0ZI+2wg3TyyTFrIOUigAACCCCAAAIIIJAiAR+yQYpK9eY0BHRvWpWagfowCcuXlxYtkqZNC1dy33yzcN6kiVS3rvTtt6lx4SwIIIAAAggggAACCMRNwIdsELeeENBj1nEfJmGZMtLff4crue+xx5YNmjBBOuKI8L/ZPmwIIIAAAggggAACCCCQvIAP2SD5qvw+goDud/+SHr0Pk7BPH+nff6VOnaQdd9yyRFs87tBDJVtMzlZ0Z0MAAQQQQAABBBBAAIHkBXzIBslX5fcRBHS/+5f06KMwCb/8Mlw8bpddwsXk2BBAAAEEEEAAAQQQQCB5gShkg+SrdvsIArrb/Un56KIwCe3d9Hr1pJ12kn7/PeVEnBABBBBAAAEEEEAAgVgIRCEbRK1RBPSodTSPelyfhOvWhau3Fy0q7bmnVKTIlgXNmBG+f166tPTXXzFrIOUigAACCCCAAAIIIJAiAdezQYrK9Oo0BHSv2lXwwbo+CVeulLbfPqxz8WKpbNkta54zR9ptt3A/e1edDQEEEEAAAQQQQAABBJIXcD0bJF+R/0cQ0P3vYVIVuD4Jly6VSpUKS/rnn/Bb55tvy5ZJw4dLxYpJrVsnVT47I4AAAggggAACCCCAwH8CrmeDODaKgB6zrrs+CZcskcqVC5tid8dz7qbHrE2UiwACCCCAAAIIIIBA2gVczwZpB3DwAgR0B5uSziG5Pgn/+EPaeedQYM0aqXDhdGpwbgQQQAABBBBAAAEE4ivgejaIY2cI6DHruuuT8Lffws+nFSokrV279ebYv3/rLWnVKumkk8JH3dkQQAABBBBAAAEEEEAgOQHXs0Fy1URjbwJ6NPqYcBWuT8L586WqVaXttpNswbitbRbQc1Z3X7hwwx33hBHYEQEEEEAAAQQQQAABBOR6NohjiwjoMeu665Nw9mypRg2pRAnJFoPLbbMAv3q1ZIG+SpWYNZFyEUAAAQQQQAABBBBIgYDr2SAFJXp3CgK6dy0r2IBdn4R//indfXd4h7xXr9xrLVlSWr5cmjkzDPRsCCCAAAIIIIAAAgggkJyA69kguWqisTcBPRp9TLiKqExCW+ndVnz/4Qepdu2Ey2dHBBBAAAEEEEAAAQQQ+E8gKtkgSg0loEepmwnUEpVJWLGiZO+ff/21tPfeCRTOLggggAACCCCAAAIIILCJQFSyQZTaSkCPUjcTqMX1SWjfPrf3yosXl3bdNfeC7L/9/LP02WdS/foJFM4uCCCAAAIIIIAAAgggQEB3/DdAQHe8QakenusB/dNPpUMOkapVk+bMyb36mjWlWbOkjz+WGjRItRLnQwABBBBAAAEEEEAg+gKuZ4Pod2DLCgnoMeu665PQAvfhh0sWwH/6KffmPPNMuMp78+ZSpUoxayLlIoAAAggggAACCCCQAgHXs0EKSvTuFAR071pWsAG7Pgk//FA66qhw4TdbAI4NAQQQQAABBBBAAAEE0iPgejZIT9Vun5WA7nZ/Uj461yfhmDFSkyZS3brSt9+mvHxOiAACCCCAAAIIIIAAAv8JuJ4N4tgoAnrMuu76JBw9WmraVNpvP+nLL3NvzuefS7//Hu7HI+4x+xFTLgIIIIAAAggggEBKBFzPBikp0rOTENA9a1hBh+v6JBw1SjrxROnAA6UpU3Kv9uijpfHjpRdflM46q6AqHI8AAggggAACCCCAQPwEXM8G8euIRECPWdddn4QjR0qnniodeqg0aVLuzTn2WOn996XnnpNatYpZEykXAQQQQAABBBBAAIEUCLieDVJQonenIKB717KCDdj1STh1qjRggFS9unT99bnXanfZ7W774MHShRcWzISjEUAAAQQQQAABBBCIo4Dr2SCOPSGgx6zrUZmE9nm1114Lw3zbtjFrIuUigAACCCCAAAIIIJACgahkgxRQOHMKArozrcjMQKIyCc8+W3rpJel//5OuuCIzdlwFAQQQQAABBBBAAIEoCUQlG0SpJwT0KHUzgVpcn4TLlkl//SWVKCGVLZt7Qa1bS88/Lz3wgNSpUwKFswsCCCCAAAIIIIAAAghsIuB6NohjuwjoMeu665PwySelSy6RTj5ZsgXjctsuukgaMkS66y6pS5eYNZFyEUAAAQQQQAABBBBIgYDr2SAFJXp3CgK6dy0r2IBdn4SPPy5ddplk75iPGJF7rbZA3LRp0pFHSoccUjATjkYAAQQQQAABBBBAII4CrmeDOPaEgB6zrrs+Cfv1kzp0CL9tbt84Z0MAAQQQQAABBBBAAIH0CLieDdJTtdtnJaC73Z+Uj871Sfjww9LVV0stW0pDh6a8fE6IAAIIIIAAAggggAAC/wm4ng3i2CgCesy67vokvP9+6dprpfPOk555JvfmzJsnzZkjVaok1aoVsyZSLgIIIIAAAggggAACKRBwPRukoETvTkFA965lBRuw65Pw7rulrl0lWwTOFozLbbvlFqlnT+nKK6VHHimYCUcjgAACCCCAAAIIIBBHAdezQRx7QkCPWdddn4S9e0s33SS1aSPZgnG5bbffLt12W7igXP/+MWsi5SKAAAIIIIAAAgggkAIB17NBCkr07hQEdO9aVrABuz4J7dNqL78sHX10eBc9t+3OO6UbbpAuvlgaNKhgJhyNAAIIIIAAAggggEAcBVzPBnHsCQE9Zl2PyiRM9F31mLWXchFAAAEEEEAAAQQQSFggKtkg4YI92JGA7kGTUjnEqEzC//1Puuoq6ZxzpOHDUynEuRBAAAEEEEAAAQQQiIdAVLJBlLpFQI9SNxOoxfVJuHy5tHq1tP32UrFiuRc0YIDUrp10+unSK68kUDi7IIAAAggggAACCCCAwCYCrmeDOLaLgB6zrrs+Ca+5RnrwQalbN6lPn9ybM3hw+P75SSdJb7wRsyZSLgIIIIAAAggggAACKRBwPRukoETvTkFA965lBRuw65PQHlu3x9dvvlm6447ca/3qK+nVV6U6daSWLQtmwtEIIIAAAggggAACCMRRwPVsEMeeENBj1nXXJ2H79tJjj0ndu4efUWNDAAEEEEAAAQQQQACB9Ai4ng3SU7XbZyWgu92flI/O9UnYtq30xBNSz57h99DZEEAAAQQQQAABBBBAID0CrmeD9FTt9lkJ6G73J+Wjc30S2nvl9n65fee8a9fcy//nH+mnn6SiRaV69VLOxAkRQAABBBBAAAEEEIi8gOvZIPIN2EqBBPSYdd31SXj++dIzz0j33itde23uzRk9WmraVNp3X8neR2dDAAEEEEAAAQQQQACB5ARczwbJVRONvQno0ehjwlW4PglbtZKGDpUeekjq2DH3ssaNkxo1kvbaS5o2LeHy2REBBBBAAAEEEEAAAQT+E3A9G8SxUQT0mHXd9UlowXzChPATaieckHtzPv5YOvxwaffdpRkzYtZEykUAAQQQQAABBBBAIAUCrmeDFJTo3SkI6N61rGADjsoknDJFOvhgqWpVae7cgplwNAIIIIAAAggggAACcRSISjaIUu8I6FHqZgK1RGUSTp0q7befVLGi9NtvCRTOLggggAACCCCAAAIIILCJQFSyQZTaSkCPUjcTqMX1Sbh6tVSkiFSo0LaL+f778P3zHXeU/vwzgcLZBQEEEEAAAQQQQAABBAjojv8GCOiONyjVw3M9oB93nPTee9Kzz0qtW+devX1irVYtaYcdJPvkGhsCCCCAAAIIIIAAAggkJ+B6NkiummjsTUCPRh8TrsL1Sdi4sTR2rDRsmNSiRe5lLV4cfiu9RAnpttsSLp8dEUAAAQQQQAABBBBA4D8B17NBHBtFQI9Z112fhEceKX30kfTSS9KZZ8asOZSLAAIIIIAAAggggEAGBVzPBhmkcOZSBHRnWpGZgbg+CQ87TJo0SXrtNenUUzNjwlUQQAABBBBAAAEEEIijgOvZII49IaDHrOuuT0L7dJp9Qu3NN6UTT8y9OevWSfYe+qpVUu3a4cJybAgggAACCCCAAAIIIJC4gOvZIPFKorMnAT06vUyoEtcn4f77S199Jb3zjtS0ae4lWTAvViz874sWSeXKJVQ+OyGAAAIIIIAAAggggMB/Aq5ngzg2ioDuWNfnz5+vrl276q233tLy5ctVp04dDRw4UAcddFAw0osuukhDhgzZZNQNGjTQxx9/nFAlrk/CvfeWvv1Wev99qUmT3EuyO+iFC4f/3b6Dbt9DZ0MAAQQQQAABBBBAAIHEBVzPBolXEp09CegO9XLRokWqX7++mjRpovbt26tixYqaMWOGatSooVr2TbH/Avpvv/2mJ598cv3IixUrpvLlyydUieuT8IorpNmzpT59pH333XZJdgfd7qTPnStVrZpQ+eyEAAIIIIAAAggggAAC/wm4ng3i2CgCukNd79atmz766CONHz8+11HZHfTFixdrxIgR+Rp5lCZhqVLS0qXSjBnS7rvni4ODEEAAAQQQQAABBBCIrUCUskFUmkhAd6iT9erV0/HHH6958+Zp7Nix2nXXXdWhQwe1bdt2/SgtoFs4t7vm5cqVU6NGjdSrV6/gbnsiW5QmoT00YO+ff/edtOeeiVTPPggggAACCCCAAAIIIJAjEKVsEJWuEtAd6mTx4sWD0XTu3FnnnHOOPvnkE3Xq1En9+/fXBRdcEPy3YcOGqVSpUtptt900c+ZM3XLLLVq9erWmTJmi7bfffotqVqxYIftn40lYrVo1LVmyRGXKlHGo+uSHUqmStGBBuKhcXo/DJ392jkAAAQQQQAABBBBAINoCBHT3+ktAd6gndlf84IMP1oQJE9aPqmPHjpo8ebImTpy41ZH+8ssvQVgfOnSozjzzzC326d69u3r06LHFv3c1oNu75H/8IX36qWQLxm1rq1ZNmjcv3Pe/NfQc6iZDQQABBBBAAAEEEEDAbQECunv9IaA71BML2k2bNtUTTzyxflT9+vVTz549Zau757bVrl1bbdq0CVZ/33zz7Q76TjtJf/4ZruRet+62m9O9u/TXX1KnTlL16g41kqEggAACCCCAAAIIIOCBAAHdvSYR0B3qSevWrTV37txNFom75pprNGnSpE3uqm885D/++CN4V33AgAHrH4PfVkmuT8KyZcPQPX26tMceDjWHoSCAAAIIIIAAAgggEDEB17NBxLgTKoeAnhBTZnayR9kbNmwYPJLeokWL4B10WyDOwvd5552nf/75R/bI+llnnaXKlStr1qxZuvHGGzVnzhxNmzZNpUuXznOgrk/CHXaQli2TZs6UatTIsxx2QAABBBBAAAEEEEAAgXwKuJ4N8lmW14cR0B1r38iRI3XDDTdo+vTpqlmzZrBgXM4q7suXL9fpp5+uzz//PPjUmoV0+2b6HXfcIVv4LZHN9Ulo69ytXJnYt83tXXUL8/ZYfMmSiVTPPggggAACCCCAAAIIIJAj4Ho2iGOnCOgx67rrk7BIEWntWumXX6Rddtl2cxo2lGztPPskfPPmMWsk5SKAAAIIIIAAAgggUEAB17NBAcvz8nACupdty/+gXZ6EFswtoNu2cKG0887brrNRI2ncOGn4cOmcc/JvwpEIIIAAAggggAACCMRRwOVsEMd+WM0E9Jh13uVJuHq1dOKJkv3P116T8nqlvmlTafRo6ZlnpPPOi1kjKRcBBBBAAAEEEEAAgQIKuJwNCliat4cT0L1tXf4GHqVJePLJ0ptvSoMGSRdfnD8PjkIAAQQQQAABBBBAIK4CUcoGUekhAT0qnUywjihNwjPOCN8/f+wxqV27BAHYDQEEEEAAAQQQQAABBAKBKGWDqLSUgB6VTiZYR5QmYYsW0gsvSI88Il15ZYIA7IYAAggggAACCCCAAAIEdEd/AwR0RxuTrmG5HNBtYbg6daSiRaUFC6RChbat8H//Jz37rHTffVLnzukS47wIIIAAAggggAACCERTwOVsEE3xvKsioOdtFKk9XJ6E8+dLVauGAX3VqrzZBw6UPvlEOussqVmzvPdnDwQQQAABBBBAAAEEENgg4HI2iGufCOgx67zLk3D2bKlGDal4cWn58pg1hnIRQAABBBBAAAEEEMiwgMvZIMMUzlyOgO5MKzIzEJcn4YwZ0h57SKVKSX//nRkProIAAggggAACCCCAQFwFXM4Gce0JAT1mnXd5En7/vbTXXlK5ctKiRXk3ZsUKaelSqVixMNSzIYAAAggggAACCCCAQOICLmeDxKuI1p4E9Gj1M89qXJ6E33wj7bOPtPPOki0Yl9d2ww3SnXdKnTpJDzyQ1978dwQQQAABBBBAAAEEENhYwOVsENdOEdBj1nmXJ+GXX0oHHCDtsov0yy95N+a226Tbb5c6dJD69s17f/ZAAAEEEEAAAQQQQACBDQIuZ4O49omAHrPOuzwJ7RH3iy+WypeXRo7MuzG9ekk33yy1bSsNGJD3/uyBAAIIIIAAAggggAACBHSXfwMEdJe7k4axuRzQky33nnukLl2kCy+UBg9O9mj2RwABBBBAAAEEEEAg3gJRygZR6SQBPSqdTLCOKE3CBx+UrrlGatVKeu65BAHYDQEEEEAAAQQQQAABBAKBKGWDqLSUgB6VTiZYR5Qm4aOPSldcIZ11lvTiiwkCsBsCCCCAAAIIIIAAAggQ0B39DRDQHW1MuoblckAfP14699xwJfe3385b4IknwvfPTztNevXVvPdnDwQQQAABBBBAAAEEENgg4HI2iGufCOgx67zLk9BC+QknSPXrS599lndjxo4NF4c76CCpc+e892cPBBBAAAEEEEAAAQQQIKC7/BsgoLvcnTSMzeWAbiu3n3qqdMgh0iefpKF4TokAAggggAACCCCAAALrBVzOBnFtEwE9Zp13eRKOGCGdcYZ0+OHShAkxawzlIoAAAggggAACCCCQYQGXs0GGKZy5HAHdmVZkZiAuT0Jb6O2cc6Sjj5bs8fW8tnXrpFWrpDVrpBIl8tqb/44AAggggAACCCCAAAIbC7wRjNgAACAASURBVLicDeLaKQJ6zDrv8iQcOjT8ZNoxx0jvvZd3Y0aNkk48MfF31vM+I3sggAACCCCAAAIIIBAfAZezQXy6sGmlBPSYdd7lSfjMM9L550vNmiW2ivv770vHHhuu+j51aswaSbkIIIAAAggggAACCBRQwOVsUMDSvD2cgO5t6/I3cJcn4WuvSbfcIjVsKPXrl3d9H34oHXWUVKeO9P33ee8flT1stfuvvgrf1T/yyKhURR0IIIAAAggggAACmRZwORtk2sKV6xHQXelEhsYRpUk4aZJ02GFSjRrSzJkZAnTgMoUKbRiEvYfPhgACCCCAAAIIIIBAfgSilA3yU7+LxxDQXexKGscUpUn4+efSgQdKVapI8+enEc2xUxPQHWsIw0EAAQQQQAABBDwViFI28LQFWwybgB6VTiZYR5Qm4TffhO+fV6ggLViQIEAEdiOgR6CJlIAAAggggAACCDggEKVs4ABnSoZAQE8Joz8ncXkSDhok3XmndPrp0t135236ww/SnntKZctKixfnvX9U9iCgR6WT1IEAAggggAACCGRXwOVskF2Z7F2dgJ49+6xc2eVJeM89Upcu0gUXSEOG5M3z229Su3ZSqVKSrQAfl42AHpdOUycCCCCAAAIIIJBeAZezQXord/fsBHR3e5OWkbk8Cfv0kW68UbrkEmngwLSUH4mTEtAj0UaKQAABBBBAAAEEsi7gcjbIOk6WBkBAzxJ8ti7r8iS84w7p1lulyy6T+vfPlpD71yWgu98jRogAAggggAACCPgg4HI28MEvHWMkoKdD1eFzujwJb7tNuv12qUMHqW/fxBFzPjW2cXBN/Gj/9hw8OHy0/+yzpWef9W/8jBgBBBBAAAEEEEDADQGXs4EbQpkfBQE98+ZZvaLLk/Cmm6TevaWrr5YefDBvpuXLpTJlpNWrpb/+kkqXzvsY9kAAAQQQQAABBBBAAIFQwOVsENceEdBj1nmXJ2HXruHq7ddeK917b96NWbNGKlo03O+PP6Ty5fM+hj0QQAABBBBAAAEEEECAgO7qb4CA7mpn0jQulwO6fWLtiSekNm2kbt0SAyhcWLJH3H/5Rdpll8SO8X2vAQPCmlu2lMqV870axo8AAggggAACCCCQLQGXs0G2TLJ9XQJ6tjuQ4etHbRIWLy6tWCHNni1Vr55hzCxdjkXisgTPZRFAAAEEEEAAgYgJRC0bRKE9BPQodDGJGqI2Ce0d9L//ln78UapVKwkIj3fdOKCvXSvFZXE8j1vG0BFAAAEEEEAAAScFopYNnEROclAE9CTBfN89apNw553D98+//VaqW9f37uQ9fgvkRYps2M+eHihWLO/j2AMBBBBAAAEEEEAAgc0FopYNotBhAnoUuphEDS5PQvsG+uuvS506SRdemFhRlStLv/4qffGFtP/+iR3j8162cn3JkhsqWLIkXMmeDQEEEEAAAQQQQACBZAVczgbJ1hKV/QnoUelkgnW4PAkvuEB6+ulwBXdbyT2R7bzzpEWLpIcekmrXTuQIv/exWjderf6336SKFf2uidEjgAACCCCAAAIIZEfA5WyQHZHsX5WAnv0eZHQELk/C1q2l558Pv4Fu30Jn21LAVquvUmXDv58zR6pWDSkEEEAAAQQQQAABBJIXcDkbJF9NNI4goEejjwlX4fIkbNFCeuEF6X//k664IuGSYrXjzJnS7rtvKPmHH+Lx5ECsmkyxCCCAAAIIIIBAhgRczgYZInDuMgR051qS3gG5PAnPOEMaMUJ67DGpXbv0Ovh69mXLpHHjpNNOk5o0kfr3l2rU8LUaxo0AAggggAACCCCQTQGXs0E2XbJ5bQJ6NvWzcG2XJ+Gpp0ojR0pPPCFdemliOMceK338sTR8uHTyyYkdw14IIIAAAggggAACCCAguZwN4tofAnrMOu/yJDzxRGnUKGnw4MRXcT/iCGnCBOmll6Qzz4xZMykXAQQQQAABBBBAAIECCLicDQpQlteHEtC9bl/yg3d5ErZqJY0ZIz3yiHT22YnVZo952zG2uNy55yZ2jM97zZ8f/hGjUiXplFN8roSxI4AAAggggAACCGRbwOVskG2bbF2fgJ4t+SxdN2qT8PjjpXfekZ56Sjr//CyhZvCyFs7tSQPbSpeWhg6VTjopgwPgUggggAACCCCAAAKREYhaNohCYwjoUehiEjVEbRLm5731JLic29UW0bPF9HI2W/U+0acNnCuGASGAAAIIIIAAAghkVSBq2SCrmCm6OAE9RZC+nCZqk9DeO3/lFenRR6X27X3pQv7HaXfM7VWAnO3pp6X/+7/8n48jEUAAAQQQQAABBOIrELVsEIVOEtCj0MUkanB5El5yiWTf9b73XumwwxIryt47HzZMevBB6eqrEzvG572GDJEuumhDBY8/LrVp43NFjB0BBBBAAAEEEEAgWwIuZ4NsmWT7ugT0bHcgw9d3eRLWry998YX09ttSs2aJwdx+u/Tee9IVV0gtWiR2jM972XfPL798QwW2oN6VV/pcEWNHAAEEEEAAAQQQyJaAy9kgWybZvi4BPdsdyPD1XZ6E++4rff11GLiPOSbDMJ5c7qGHpE6dNgz2nnuk667zZPAMEwEEEEAAAQQQQMApAZezgVNQGRwMAT2D2C5cyuVJWLeu9N130tix0tFHu6Dl3hjuukvq1m3DuO64Q7r5ZvfGyYgQQAABBBBAAAEE3BdwORu4r5eeERLQ0+Pq7FldnoS1a0s//ih99JHUsKGzhFkdmL2j/9VX4Xv3P/8sXXqpZO/usyGAAAIIIIAAAgggkKyAy9kg2Vqisj8BPSqdTLAOlydhjRrS7NnSpEnSoYcmVlDPntLDD4fvZdv76GwIIIAAAggggAACCCCQmIDL2SCxCqK3FwE9ej3dZkUuT8KqVaX586UpU6QDD0ysMTfdJPXuLXXsKNn72WwIIIAAAggggAACCCCQmIDL2SCxCqK3FwE9ej31NqDvtVf42PaECdI++yTWmB49pO7dwzvo/foldozPe338cfiUwf77S+bFhgACCCCAAAIIIIBAfgUI6PmVS99xBPT02Tp55qhNwj59pBtvDN/FfuIJJ8lTOih73/zJJ6U99pCWLZNOOy0ef5hIKSInQwABBBBAAAEEEAgEopYNotBWAnoUuphEDVGbhPfeK11/vXT++dJTTyUB4emurVtLzz8fBnRbUO/ss6UXXvC0GIaNAAIIIIAAAgggkFWBqGWDrGKm6OIE9BRB+nKaqE1CWyDu6qulli2loUN96UL+x3nmmdIrr0gHHyx9+ql0yinS66/n/3wciQACCCCAAAIIIBBfgahlgyh0koAehS4mUYPLk/DEE6V166Snn5YqVEisqMcek9q3lyy4vvRSYsf4vNdJJ0lvvSUdd5w0enT4P9991+eKGDsCCCCAAAIIIIBAtgRczgbZMsn2dQno2e5Ahq/v8iQsUkRauzZcKK5y5cRg7G6yfWqtSRPJHneP+nbMMdIHH0hnnRX+QeLII6Xx46NeNfUhgAACCCCAAAIIpEPA5WyQjnp9OCcB3YcupXCMrk5CC+YW0G1bsCDxO+gppPHiVEccEa5yb4viDRwYPuo+ebIXQ2eQCCCAAAIIIIAAAo4JuJoNHGPK6HAI6Bnlzv7FXJ2Eq1ZJxYqFPn/+Ke24Y/atXBzBQQdJn30mde4s3X+/tO++0ldfuThSxoQAAggggAACCCDguoCr2cB1t3SOj4CeTt18nHv+/Pnq2rWr3nrrLS1fvlx16tTRwIEDdZAlM9k72uvUo0cPDRgwQIsWLVKDBg3Ut29f7b333gldzdVJuHy5VLJkWMJff0mlSydUTux2evPN8AmD8uWlW26RateWXnwxdgwUjAACCCCAAAIIIJACAVezQQpK8/YUBHSHWmeBu379+mrSpInat2+vihUrasaMGapRo4Zq1aoVjPSuu+5Sr169NHjw4CC89+zZU+PGjdP333+v0gmkWlcn4d9/S2XKhM2w73uXKJFYY8aMkezb4PXqSSNHJnYMeyGAAAIIIIAAAggggADfQXfxN0BAd6gr3bp100cffaTxuaz6ZXfPq1Spok6dOgV32W1bsWKFKlWqFAT3du3a5VmNqwF90aLwrrBtK1dK222XZynBDu+8Ix1/vLT//tIXXyR2DHshgAACCCCAAAIIIIAAAd3F3wAB3aGu1KtXT8cff7zmzZunsWPHatddd1WHDh3Utm3bYJQ//fRTcCf9s88+C+6052zNmzdXuXLlNGTIkC2qsQBv/+RsFtCrVaumJUuWqEzOLWsHDBYulKpWlexd9NWrpcKFExuU3UG3FdztDvo33yR2jM972TfPzaZxY2mHHXyuhLEjgAACCCCAAAIIZFvA1Zt32XbJ5vUJ6NnU3+zaxYsXD/5N586ddc455+iTTz4J7pb3799fF1xwgSZMmKAjjjhC9p663UnP2S677DLNnj1bb7/99hbVdO/ePXhnffPNtYCe3zZ89FH4qbE99pCmT8/vWfw5rlQpaelSaeJE6cILpTVrpB9/9Gf8jBQBBBBAAAEEEEDAHQECuju9yBkJAd2hnhQrVkwHH3xwEMRzto4dO2ry5MmaOHHi+oD+888/q/JGHwq3O+xz587VqFGjtqjGlzvo+W2DfWLs0EOl6tWl2bPzexZ/jitaNAzlX34ZPtZvm/3viT5x4E+ljBQBBBBAAAEEEEAg3QIE9HQLJ39+AnryZmk7YrfddlPTpk31xBNPrL9Gv379goXg7K55fh5x33ywUZuEFlQPOECyv1f8/HPaWuPEie3R/5x38+2PEbvtFg4rmUX1nCiEQSCAAAIIIIAAAgg4IRC1bOAEagEHQUAvIGAqD2/dunVwJ3zjReKuueYaTZo0Kbh7nrNInP27Ll26BJdeuXJlsNq774vEzZ8vtW8vlS0rPf104qrTpoXvn++0k/T774kf5+Oe//yz4fNzixdL5cqFVfDdeB+7yZgRQAABBBBAAIHsCxDQs9+DzUdAQHeoJ/Yoe8OGDYN3xlu0aBG8g26Pr9s3z88777xgpBbE+/TpoyeffFK1a9dW7969NWbMGO8/s/btt5J9yj3ZoG13km0V9x13DN/LjvJmf4CoUCGs0O6mFysmrV0bPjmw0RsPUSagNgQQQAABBBBAAIEUChDQU4iZolMR0FMEmarTjBw5UjfccIOmT5+umjVrBgvG5azibtewu+gW4G3hOPtueoMGDdS3b1/ts88+CQ3B1Un41VfhO9WVKkm//ppQKbHbad48qVq18DF3+xSdreJuj7f/9JNUs2bsOCgYAQQQQAABBBBAoIACrmaDApbl9eEEdK/bl/zgXZ2En30mHXRQ+Km1uXOTrysOR9hq7bVrh4+5//VX+LSBPd5uj/nvtVccBKgRAQQQQAABBBBAIJUCrmaDVNbo27kI6L51rIDjdXUSfvKJ1KCBVKOGNHNmAYuM6OH23vmLL0qFCkmXXio1bCgtWSK9/LK0554RLZqyEEAAAQQQQAABBNIm4Go2SFvBHpyYgO5Bk1I5RFcnoX1Z7ogjkv+euT3ibcHeHvm2Fd3/+5R8Ksk4FwIIIIAAAggggAACkRRwNRtEEjvBogjoCUJFZTdXJ+G4cVKjRuGj2vbIdqLbihUbQrndTS5TJtEj2Q8BBBBAAAEEEEAAgXgLuJoN4twVAnrMuu/qJHz/fenYYyVb627q1MSbYquYFykS7r9wobTzzokf69ueVp+9q2/vnh98sG+jZ7wIIIAAAggggAACrgm4mg1cc8rkeAjomdR24FquTsJ166Q1a8J/tt8+OaiiRcPj7FvqVaokd6xPe7/xhnTKKWE4nzxZuvhiadIk6aGHpKZNfaqEsSKAAAIIIIAAAgi4IOBqNnDBJltjIKBnSz5L143iJCxZUlq+PFxczhaZi+r20kvS2WdLRx4pjR8vHXOM9MEH0tChUsuWUa2auhBAAAEEEEAAAQTSJRDFbJAuq0ydl4CeKWlHrhPFSViuXLia+Q8/hJ8hi+r23HPSeedJxx0nvfuudNJJ0ltvSYMHSxdeGNWqqQsBBBBAAAEEEEAgXQJRzAbpssrUeQnomZJ25DquTsKcR7Xr1ZNuvjk5rAoVpN9/l77+Wtp77+SO9WnvQYPCz6udfLI0cqR05pnSK69Ijz0mtWvnUyWMFQEEEEAAAQQQQMAFAVezgQs22RoDAT1b8lm6rquTcNgw6dxzpcaNw8e2k9kOOUT6448wtFrAj+r26KPSFVdIZ50Vfg+9Vavw8fYHH5SuvjqqVVMXAggggAACCCCAQLoEXM0G6arXh/MS0H3oUgrH6OokfPZZ6f/+b8Pj2yksOTKnuv9+6dprw8fcn3kmXCTOHm+/806pa9fIlEkhCCCAAAIIIIAAAhkScDUbZKh8Jy9DQHeyLekblKuTcMgQ6aKLpBNOCN+rZttSoHdv6aabwsfcn3hCat8+fLy9e3fpttsQQwABBBBAAAEEEEAgOQFXs0FyVURrbwJ6tPqZZzWuTsKBA6U2baRTT5Veey3PMmK5g31a7aOPwsf4mzWTbr1Vsj9sXHWVdN11sSShaAQQQAABBBBAAIECCLiaDQpQkveHEtC9b2FyBbg6Cfv3ly6/XDrjDOnll5Orye68T50afg/cPkHGhgACCCCAAAIIIIAAAnkLuJoN8h55dPcgoEe3t1utzNVJ2LevdOWV0jnnSMOHJ9eUww6TbBX4V1+VTjstuWPZGwEEEEAAAQQQQACBuAq4mg3i2g+rm4Aes+67Ognt7nenTuHK5Pa972S2o4+Wxo+XXnhBOvvsZI70a9/vvgtXq69ZU6pSxa+xM1oEEEAAAQQQQAAB9wRczQbuSWVuRAT0zFk7cSVXJ+HKldLy5VKRIlKpUslRHXec9N57kq0E37p1csf6tPeFF0pPPSXdfbd0/fXhHyTuvVdq0iRcyZ0NAQQQQAABBBBAAIFkBFzNBsnUELV9CehR62ge9URxEp54ojRqVPjJMQuxUd3sO/H2vfiHHw4XhrMV3G0l9/y8tx9VI+pCAAEEEEAAAQQQSFwgitkg8erd3JOA7mZf0jaqKE7C5s3Dld8HDJDatk0bXdZPfPrp4Xv2tqDeZZeFf5Cwb6HbHyjefDPrw2MACCCAAAIIIIAAAp4JRDEbeNaCLYZLQPe9g0mO39VJOGKE9MYb0rHHSnanOJnNFpZ78UXpf/+TrrgimSP92te+Ef/22+Gn1S64QBo6NHxn3x5xf/99v2phtAgggAACCCCAAALZF3A1G2RfJnsjIKBnzz4rV3Z1Et58s9Srl9SxY/i5tGS2du0kC/g9e0b7DnrjxtLYseFj7i1ahDXb4+2HHy5NmJCMGPsigAACCCCAAAIIICC5mg3i3BsCesy67+ok7NZNuusuqXNn6b77YtaUBMvd/HNy9t69Pd5ev7702WcJnoTdEEAAAQQQQAABBBD4T8DVbBDnBhHQY9Z9VyfhtddK998vdekSBnW2LQUOOED68svwMfdmzaQxY8LH2+vWlb79FjEEEEAAAQQQQAABBJITcDUbJFdFtPYmoEern3lW4+okvPrqcHXyG28MH3Vn21Jg0CDp55+l884Lv4U+ebJk76XXqSNNnIgYAggggAACCCCAAALJCbiaDZKrIlp7E9Cj1c88q3F1Etribo8+Kt12m9S9e55lbLJDv37S88+HC6bZZ8fYEEAAAQQQQAABBBBAIG8BV7NB3iOP7h4E9Oj2dquVuToJbaE3+0zaHXdItmBcMlvXrtLdd/P+ejJm7IsAAggggAACCCCAgKvZIM6dIaDHrPuuTsJLL5XsEe4+fSRbMC6Z7ZZbwhXcr7xSeuSRZI70a98pU6SiRcN3zosV82vsjBYBBBBAAAEEEEDAPQFXs4F7UpkbEQE9c9ZOXMnVSbhkifTPP1Lp0lKZMslR2V33W2+V7C78Y48ld6xPe5coIf37rzR7tlS9urRokXT22dLKldK4cVKhQj5Vw1gRQAABBBBAAAEEsi3gajbItks2r09Az6Z+Fq4dxUloq77bXfeLLw7vwkdxW7dOKlw4rOzXX6VKlcKAXr58+O8spG+3XRQrpyYEEEAAAQQQQACBdAlEMRukyypT5yWgZ0raketEcRLa59nsM222uvkzzzgCneJhrFghFS8ennTxYqlsWWn5cqlkyfDf/f23VKpUii/K6RBAAAEEEEAAAQQiLRDFbOB7wwjovncwyfG7Ogkff1z6+mupZUupYcPkivrf/6SrrpLOOUcaPjy5Y33Z214BKFcuHK095r799tLatVKRIuG/W7hQ2nlnX6phnAgggAACCCCAAAIuCLiaDVywydYYCOjZks/SdV2dhKedJr3+umRBvU2b5HAGDpTsO+qnnx7dO+gLFoSPtdtmwTznfXNbLG7VKmnuXKlq1eTc2BsBBBBAAAEEEEAg3gKuZoM4d4WAHrPuuzoJTzpJeust6cknpYsuillTEih3zhxpt93CO+d2Bz1nswX17PH26dOlPfZI4ETsggACCCCAAAIIIIDAfwKuZoM4N4iAHrPuuzoJmzWT3n1Xevpp6f/+L2ZNSaDcH36Q9twzfPfc3kHP2SpWDB9vnzpV2mefBE7ELggggAACCCCAAAIIENCd/Q0Q0J1tTXoG5mpAP+YY6YMPpOefl849Nz21+3xWC+F9+4bfQb/55g2V2F1z+29jx0oHHOBzhYwdAQQQQAABBBBAINMCrmaDTDu4dD0CukvdyMBYXJ2ERx8tjR8vvfBC+G3vZLZJk6QePcJHvB9+OJkj2RcBBBBAAAEEEEAAgfgKuJoN4tsRiYAes+67Oglt5faJE6URI6TmzZNryptvSiefLB10kPTpp8kdy94IIIAAAggggAACCMRVwNVsENd+WN0E9Jh139VJeOih0uTJ0siRYdhOZhs9WmraVNpvP+nLL5M50p99//orXKndFoWrVs2fcTNSBBBAAAEEEEAAAXcFXM0G7oqlf2QE9PQbO3UFVyfh/PnSsmVS5cpSqVLJkY0bJzVqJO21lzRtWnLH+rK3fYLOPkVnf8iwR/pzthtukD77TLrpJsleE2BDAAEEEEAAAQQQQCBRAVezQaLjj+J+BPQodnUbNUVxEtqj8faI/O67SzNmRLOh9m5+ixZhCLcF4XI2e3LAniB49lmpdeto1k5VCCCAAAIIIIAAAukRiGI2SI9U5s5KQM+ctRNXiuIknDJFOvhgqWrV8DHwKG72+bkLLpDsc3Rvv72hwlNPDV8LGDhQuuSSKFZOTQgggAACCCCAAALpEohiNkiXVabOS0DPlLQj13F1Et59t7RkidSunVS9enJY9g1we/+8UiXp11+TO9aXvR9/XLrssvAx91df3TDqc86RXnwx/ARbhw6+VMM4EUAAAQQQQAABBFwQcDUbuGCTrTEQ0LMln6XrujoJa9aUZs0K36+296yT2b77TqpbN9oB/ZFHpI4dJQvkw4dv0Dn/fOmZZ6T77pM6d05GjX0RQAABBBBAAAEE4i7gajaIc18I6DHrvquT0FYmnzdPssfVDzwwuaasWxfuX6hQcsf5tPc990hdukgWyJ96asPI27QJH2/v1Uu68UafKmKsCCCAAAIIIIAAAtkWcDUbZNslm9cnoGdTPwvXdnUS2urt9ni6fSbNHldn21SgZ0/plluktm2lAQM2/Lcrrwwfb7f/dvvtqCGAAAIIIIAAAgggkLiAq9kg8QqitycBPXo93WZFrk7CChWk33+XvvlGqlcvZk1JoNx33w0Xh2vQIHzMPWe77jrp/vulbt2k3r0TOBG7IIAAAggggAACCCDwn4Cr2SDODSKgx6z7rk7CHXeUFi+Wvv9eqlMnuaYsXSpdeKG0alW4YNp22yV3vM97r10bPtof5cf7fe4PY0cAAQQQQAABBFwWcDUbuGyW7rER0NMt7Nj5XZ2EpUpJFrTtO+b2PfNkNjvOjrftn3+kHXZI5mj2/X/2zgTqxqp94xcyZq4IiYyllJSIkFDKTIMSSaUoRKL0GTOEJpWKRGUuyRTRhNRXCWVOZZZMmcfIf13v/s7/nc77nuec8zzn3eec617Lqpz97OG3n71W13Pf+75FQAREQAREQAREQAREID4J2KoN4nM3zKol0ONs9209hDlyAKdOAVu3Bl9mjZ7zbNnMRh44AOTPH3ubunu34VOwYOLHiNhbpVYkAiIgAiIgAiIgAiIQSQK2aoNIMrBtLAl0F3Zk4MCB6NGjB3LlypWstxMnTmDEiBHo27evC6O404Wth3DNGuDMGXP/3Ce2na6YWdwzZzatKWQLFXL6ZPS0u/9+YNKk1OXUFi4ERo8GqlQx99BlIiACIiACIiACIiACIuCUgK3awOn8Y7GdBLoLu5olSxbs2rULhVIow/379yf83dmzZ10YxZ0uYvUQUtTTk759O3DJJe6wsqkXJobj/XpmbO/UKXFmY8eazO5NmgCzZtk0Y81FBERABERABERABETAdgKxqg1s557e/CTQXdi9zJkzY/fu3biIqciT2FdffYV77rkHe/fudWEUd7qI1UMYzh12d8h620vjxsDcuabmefv2iWNNmAC0bQvceqvJ8i4TAREQAREQAREQAREQAacEYlUbOF2/je0k0MPYlQIFCiBTpkw4dOgQ8ubNm/DvPqPX/OjRo3jssccwim5PS8zGQ0jPN0uEnXcewLJh2bMHD4t3s3n/fP164PLLg3/e9ifq1we++AKYOBFo3Tpxth99BNx9N1CrFrB4se2r0PxEQAREQAREQAREQARsImCjNrCJT0bMRQI9DOrvv/8+zp07h/bt2+PVV19Fvnz5/r+3bNmyoWTJkrjxxhvDGMH9R208hMy8niePWSszsqe4yu8IQuHCwJ49wC+/AFdf7eiRqGpUsyawdKkJc2/ZMnHqc+aY8PYbbgB++CGqlqTJioAIiIAIiIAIiIAIZDABG7VBBiPJ8OEl0F3YgsWLS28w3gAAIABJREFUF6NGjRo4jy5gy83GQ8j656yDTjt9OrQ65idOGA88/8RiTXAmgfvpJxPm3rBh4kv2+ecmvJ0fJfhxQiYCIiACIiACIiACIiACTgnYqA2czj1W20mgu7CzK1asQNasWVGxYsWE3mbNmoXx48ejQoUK6N+/P+hNt8VsPIT79gG+6/vMp+fLyG4LMxvmQQG+erUJc69bN3FG33xjwtvLlQN+/dWGmWoOIiACIiACIiACIiAC0ULARm0QLey8mqcEugtkq1SpgmeeeQYtW7bEpk2bEoR5ixYtsGzZMjRs2DAh/N0Ws/EQ/vUXUKSIEeYWJby3ZcsS5jF4sMlQ3727EeM+W7bMhLdfeqmpIS8TAREQAREQAREQAREQAacEbNQGTuceq+0k0F3YWd49pxe9dOnSGDZsGJi9fcGCBfj222/RqlUrbKeyssRsPIQ7dgDFi5v656dOhQaqTx/gjz9MLfBYvIOeFhV+0OC1ACbWU+RBaO+OnhIBERABERABERCBeCVgozaI173wrVsC3YU3gBncly9fjrJly6J+/fpo1KgRunbtim3btqF8+fI4wQvSlpiNh3DLFuCyy0xyOCaJC8Wuvx5Yvhz49FPgjjtC6UHPiIAIiIAIiIAIiIAIiEB8EbBRG8TXDqRerQS6C2/ALbfcguLFi6NevXp46KGHsG7dOpQpUwZMHvfAAw9gCxWoJWbjIfztNxO2nTcvcOhQaKCqVwf++1/gk0+AZs1C68Pmp3btMl7y/PnlKbd5nzQ3ERABERABERABEYgmAjZqg2ji58VcJdBdoLpq1Sq0bt06wWPevXt39OvXL6HXzp07Y//+/Zg8ebILo7jThY2HkAEGq1YB584B1aqFts6bbzZ1wKdNM3XBY80ozhnKztsSl1ySuLojR4AnngBOngSmTJF4j7V913pEQAREQAREQAREwEsCNmoDL9cbDX1LoHu4SydPnkSWLFkSMrzbYrF6COvXNxnOJ04EWre2hbY78/j3XyBLFtMXa737Mt7zvw8fBvLlM7/xQ0eOHO6MqV5EQAREQAREQAREQARin0CsaoNo3jkJdBd3j/fQ169fj0yZMuGKK65A5cqVXezdna5i9RCyNvi8ecC4ccCDD7rDypZeKLx5P98nyPPkSZyZL0Ec/+bAARMCLxMBERABERABERABERABJwRiVRs4WbutbSTQXdiZPXv24J577km4c54/f36cO3cOhw4dQp06dTB16lRclNTl6cJ44XRh4yHk/epJk4ALLghdXDdvDsycCbz9NvDoo+EQsu9ZCu+CBc28KMiTBmTwWgC96/wny9UVLmzf/DUjERABERABERABERABOwnYqA3sJBW5WUmgu8Ca4vyPP/7AhAkTEjznNCaKY4I4JoubwsvBDqx///4YMGBAspaFCxfGX1ReANq1a4f3338/2e9Vq1bF999/76B308TGQ/jdd0CNGkDp0sDvvzteSrKG99wDfPgh8NprvPsfWh+2PsUPGEWLmvvlZ84AmTIln2nOnOYOOnMRlihh6yo0LxEQAREQAREQAREQAdsI2KgNbGMU6flIoLtAnHXQv/jiC1SpUiVZbz/++CNuvfVWHDx40NEoFOjTp09P6MtnvMPu88BToO/evRvjx4///9+zZcuGgj73qoNRbDyES5YAtWsD5csDGzY4WISfJryLzbvaDAVnPfVYss2bgVKl0i5DV6AAwFeM7MhQJgIiIAIiIAIiIAIiIAJOCNioDZzMO5bbSKC7sLt58uTBN998g0qVKiXrbeXKlahdu3aC19qJUaDPnDkTP//8s9/mFOgU+2wTqtl4CL/6CqhbF7jySmDNmlBXFrvPrV8PVKgAUIj//XfqdRYpYsLb+dpcc03sctDKREAEREAEREAEREAE3CVgozZwd4XR15sEugt71rRp0wThzFD2ooxFBrBz586E0msFChTAJyzO7cAo0EeMGAF65LNnzw6Grw8ZMgSl6D79X4g7xTm95rzrTvE/ePBgFCpUyEHvpomNh3DhQuC224y4TOPbhOP1xWLDHTuA/v1NhvY33ki9wssuM+HtP/wA3HBDLBLQmkRABERABERABERABLwgYKM28GKd0dSnBLoLu7V9+3ZQpK9ZswbFixdPyOLOmugVK1bErFmzcEnSwtXpjDd//nwcP34c5cqVSwhlHzRoEDZs2IC1a9figgsuwLRp05A7d26UKFECmzdvRp8+fXDmzBkwezwFvT87deoU+MdnPIScI5PY5c2b14XVh98Fs68zC/t11wE//RRafx99BFDoN2gAtGwZWh/R+hS96kwcd/75qoMerXuoeYuACIiACIiACIhARhCQQM8I6umPKYHu4p58/vnnCYKaWdwrVKiAevXqhdX7sWPHULp0afTs2RPdu3dP1deuXbsSxDozxbdo0cLvWP4Sz7GhTQJ99mygaVOgalUgiHx3ydbbowfw0ktAz57AsGFhYdfDIiACIiACIiACIiACIhAXBCTQ7dtmCfQw9uSrr77CE088kZBFPaU3mgK4evXqePvtt1GzZs2QR6lfv35CJvi33nrLbx9ly5bFww8/jF69evn9PRo86DNmGK83M7kvXRoaqmefBV54AXjySeCVV0Lrw9anWFqNtdCZrT3WEuDZylzzEgEREAEREAEREIF4ICCBbt8uS6CHsSdNmjRJqHXerVs3v7289tpr+Prrrx3fQU/ZCcU1PegdOnRA3759U42xf/9+FCtWDGPGjEHbtm0drcTGQ7h3L7B6NZAnD5AiEb6jNbFRv37AwIHA44/7v6ftuCMLGzInIOu833gjwJJ0Ke3VVw2/Rx4BqlWzcAGakgiIgAiIgAiIgAiIgJUEbNQGVoKK4KQk0MOAzfDyzz777P9rn6fsiuHuLLPG++hOrEePHmjcuDEuvfRS7NmzJ+EO+uLFi7F69eqEO+gMV2/ZsiWKFCmCLVu2oHfv3gl9r1+/Hswk78Ri9RAOHgz85z9GpI4Z44RE6jZ//gmwYh2TsdlkU6cC994L1KkDMON9SuO9+wULgPffBxx+p7FpeZqLCIiACIiACIiACIhABhGIVW2QQThdGVYCPQyMOXLkSEgMxxB0f/b7778nJIo7wfhkB9aqVSssWbIE+/btS6h9Xq1aNTz//PMJ99nZR7NmzcDSbcwYT5FO7z1/Z9I3pxarh3D4cIBR/g88ALz3nlMaie22bgVKlgRYKW/lyuCf9/IJrufBB4HbbweYUC+lNWsGzJoFjB4NdOjg5UzUtwiIgAiIgAiIgAiIQCwRiFVtEM17JIEexu4x/PzFF19Ec8Yf+7EZM2aAXvFNmzaFMYq7j9p4CNetAxYvBlhNjuXWQjGGefOmAT3NkycH3wOv+HfqZJ47dy745718gsL7scdMmDvv66e0Vq2AadOAkSOBLl28nIn6FgEREAEREAEREAERiCUCNmqDWOIbylok0EOh9r9nOnfujEWLFmHZsmWgNz2p0eN9ww03JHi5eRfdFrPxEDIk/dFHAXqCHZaMT4XzzTfN/fM77wRYci1Ymz4duOsugPn8liwJ9mlv21N4M/ldWh8f2rUz4e3MXs8s9jIREAEREAEREAEREAERcELARm3gZN6x3EYCPYzdZa3yypUrI0uWLAnZ3MuXL59QA513wkeNGoWzZ89ixYoVKFy4cBijuPuojYdw1CjgiSdCF9ckdOQIcPiwqQWeP3/wzN59F3j4YVOPfe7c4J/38gkK72eeASjEx49PPRK96/SyDxgA+Mkl6OXU1LcIiIAIiIAIiIAIiEAUE7BRG0QxTlemLoEeJsatW7eiY8eOWLBgQUL9cxpF+m233YY333wTJXmx2SKz8RD6PMQM1Z4yJWNgsTQbS83TSz1unF2J4ii8+/c3Ye7+qu3Ru06GvXsDTJYnEwEREAEREAEREAEREAEnBGzUBk7mHcttJNBd2t0DBw6ASeEo0lmbvECBAi717G43Nh7Cl14CevQA2rQBPvjA3fU67c0ngtmeCdko0m0xhux//DFQvz7w0EOpZ8XkeEySxw8MZCkTAREQAREQAREQAREQAScEbNQGTuYdy20k0GN5d/2szcZD6AvhDkcYsw44RTUT2lOoBmt8hl50WtWqwPffB9tDxrU/cAA4eRLIm9eE+MtEQAREQAREQAREQAREwAkBG7WBk3nHchsJ9Fje3SgR6G7UMJ89G2jaNHRxPWcOwLvwrCdOoXvwIK8qxNnLoeWKgAiIgAiIgAiIgAjEFQEJdPu2WwLdvj3xdEY2HkJfeHnHjgCzsYdin31m6oRfey2wYkUoPQCnThkP9NmzwM6dQNGiofXj9lOnTwNZspg/MhEQAREQAREQAREQARFwi4CN2sCttUVrPxLo0bpzIc7bxkO4cSPw66/ApZcC11wT2sK++gqoWxe46iqA4e6hWvnyAOfzxRemPxvsvvtM8jzWeu/aNfWMGI7P3ytUMOXqZCIgAiIgAiIgAiIgAiLghICN2sDJvGO5jQR6LO+un7XF6iH85hugVi2gXDkj9oO1TZuArFmNwJ0/H2Dp+s6dg+3Fm/YtWpj68MzgzkzuKY2l19q3t7NEnDdE1KsIiIAIiIAIiIAIiIAbBGJVG7jBJqP6kEDPKPIZNG6sHsIffgCqVQNY1W7z5uDhXnklsG6ducPOvsIJtw9+9PSfYG32efNMDXTWQk9p9J7Ty06PPz3/MhEQAREQAREQAREQARFwQiBWtYGTtdvaRgLd1p3xaF42HkIKYnq9r74aqFQptIWvXAlUrgwUKwbs2BF8H5dcYu6d9+kD/PijSThHkW6DUXgzhH/yZFOnPaXNmAG0bAnUqAEsXWrDjDUHERABERABERABERCBaCBgozaIBm5ezlEC3Uu6FvZt4yF84gmTQZ3ieODA0KCtXWvun190EbBnT/B9MHP7kSPm/nnZssE/7+UTFN7ffQdQiDdvnnoketfpZb/uOuCnn7ycifoWAREQAREQAREQARGIJQI2aoNY4hvKWiTQQ6EWxc/YeAh5r3r0aIDZ3Pv2DQ0uM7Bv2QJkz27C3IOxf/9NzJC+ezdQqFAwT3vflsKbmekpxJmpPqX5EuQxTH/NGu/noxFEQAREQAREQAREQARig4CN2iA2yIa+Cgn00NlF5ZM2HsKHHwbefRdgPfTevSOP9dAhIH9+M+6JE0COHMDff5ukcXnyRH4+KUf03Y+nEK9TJ/V86F2nl710aeD33zN+vpqBCIiACIiACIiACIhAdBCwURtEBznvZimB7h1bK3u28RAy8dn77wPDhgE9e0Ye2/btpsRbtmymFnqrVsC0acA77wD8eJDRxisAjA4gH4r1lEbvOr3sod6/z+j1aXwREAEREAEREAEREIGMIWCjNsgYEvaMKoFuz15EZCY2HsL77wcmTQJefhno1i00DMePA0OGAKdPAy+8AGTO7Lwf3/31Cy8E9u41c2DNcf6Tc7LdTp4E+JEhZ06Aye5kIiACIiACIiACIiACIuCEgI3awMm8Y7mNBHos766ftdl4CH0e63BqjycNU6dg5V10p8as76+8YjzoQ4cCY8aYeugNGpia6DIREAEREAEREAEREAERiEUCNmqDWOQczJok0IOhFQNtbTyEd94JfPwx8OaboZc2493xXLnMBh0+HN7dcZYqq1kTKFHChJZntJ07B2TKlNGz0PgiIAIiIAIiIAIiIAKxRsBGbRBrjINdjwR6sMSivL2Nh5BJzrZtM/eoQy1xduaMSepG278fKFgw9I3i8wx3px09Cpx/fuh9ufEkPfvnnQds2gRcfHHqHvlxYtAggJEDw4cnZqR3Y2z1IQIiIAIiIAIiIAIiELsEbNQGsUvb2cok0J1xiplWsXoI6WXOkgXgP3ft8i9k09rEAweMEKeo94lxllrjfXTWFeeHg4yypB8emFm+QIHUMzl2DMid254PChnFSuOKgAiIgAiIgAiIgAgERyBWtUFwFOxqLYFu1354PptYPoQsj8Ys7Fu3mqzsTu2ll4AePYDWrYGJE81TN98MLF4MTJgAMIldRhk/HPhKvVGI+8L4k84nqYjftw+44IKMmq3GFQEREAEREAEREAERiCYCsawNomkfks5VAj1ady7Eedt4CBctMnXHq1Y1pcJCtbx5gSNHgN9+A8qUcd5Lv37AwIHm/jvvwdNGjgQ2bgTatAGqVXPel9stKbgvusj0SiHOKAF/xvB+/r5zJ1C0qNuzUH8iIAIiIAIiIAIiIAKxSMBGbRCLnINZkwR6MLRioK2Nh7B2bWDJEuCjjwAmjAvV6Dmm0GfZtAoVnPfy5JNGkD/zjMnibpMxw3zx4uZ+PUvIpWX0stPb/scfQKlSNq1AcxEBERABERABERABEbCVgI3awFZWkZqXBHqkSFsyjo2HsEYNgIniPvkEaNYsdFCrVpls50w0x3B3p9a+PTB+vKmj/uyzTp+KTDsKbkYDUIAzO31axqR2TG4X7MeJyKxCo4iACIiACIiACIiACNhIwEZtYCOnSM5JAj2StC0Yy8ZDyND2H38E5swBGjWKPCRfmbc33gAefzxxfIbLb9gAVKqUmCE+0rOj4L7qKhPmvmdP2qNfcokJb1++HKhcOdKz1HgiIAIiIAIiIAIiIALRSMBGbRCNHN2cswS6mzSjoC8bDyEF5cqVwPz5QIMGkYdYvz7wxRfJE8IxGzwzph86lLFeaXrQ+dGAHnReAUjL6GVn22+/BapXjzxDjSgCIiACIiACIiACIhB9BGzUBtFH0d0ZS6C7y9P63mw8hFdfDaxeDXz+OVCvXugIx44F/vzTZF0P5h62z4M/axbQpEni+L6/D/dufOgrcv7k+vWmbcmSQM6czp9TSxEQAREQAREQAREQgfglYKM2iN/dMCuXQI+zN8DGQ8iEbhSYzObOhHGh2rXXAj//DCxYANx6q/Nehg0zmd+7dQOuvDLxuQcfBN57z2R479PHeX9qKQIiIAIiIAIiIAIiIALRQMBGbRAN3LycowS6l3Qt7NvGQ1iunBHIS5cCTBgXqrl9l334cKBXL+Dee4HJk0OdlZ4TAREQAREQAREQAREQATsJ2KgN7CQVuVlJoEeOtRUj2XgIP/4YOHAAaNwYKFw4dEw33WTuYLO/Fi1C78f3JJPWMeSdSeJ4Rz4jbOZMoG1boFYtYO7ctGcwZYpJaMcs+IwkkImACIiACIiACIiACIhAIAI2aoNAc4713yXQY32HU6wvlg/hLbcAX38NUKy2auVsY//919xbz5vXJGJjmTaf/f57Ysk21hjPksVZn262oue+dWugbl2TyC4tY/b7Tz8F3n0XYNk4mQiIgAiIgAiIgAiIgAgEIhDL2iDQ2m39XQLd1p3xaF6xfAiZAZ73zz/4AGjTxhlAeu4LFjRtT54EsmdPfO7sWeD884FTp0yG9GASzzkbPXCrceOAhx4CGjZM34PuKxX35ptAx46B+1ULERABERABERABERABEYhlbRCtuyuBHq07F+K8bTyECxcC9GQzRD137hAXBhMizzBwZnOnqHViW7eazOcU5hToKa1/fyBfPpMZnrXII20U3Cyz1rIlMH162qPTy05v+8svm2R3MhEQAREQAREQAREQAREIRMBGbRBozrH+uwR6rO9wivXZeAhZb/zgQXOHunz50DeEInbGDCAYLzLLu7HMG8X3nj2hj+3Vk6+8AnTvbsLcJ05MexR+kKC3fcgQ4NlnvZqN+hUBERABERABERABEYglAjZqg1jiG8paJNBDoRbFz9h4CHn3m3e8eee7dOnQ4bJU26FDJhS9UCFn/TBzfM2aQJkyJpO8bTZ0KNC7t7lXzvvlaRm97Pww0bcvMGCAbavQfERABERABERABERABGwkYKM2sJFTJOckgR5J2haMZeMhzJnThJdv2QKUKBFZSPPmmfvdlSsDy5enHvv0aVOj/a+/gNtui+zcOFq/fqYOe6dOwKhRaY//1FMmvL1nT4B13WUiIAIiIAIiIAIiIAIiEIiAjdog0Jxj/XcJ9Fjf4RTrs/EQZs0KnDkD7NgBFCsW2Q2ZOtXUOb/5ZpMBPqWtWQNUrGiyvDMMP2mW90jM9J13gPffN3fQ07tb/txzJry9a1fg1VcjMTONIQIiIAIiIAIiIAIiEO0EbNQG0c403PlLoIdLMMqet+0QnjsHZM5sINJLHU4d9EWLjBe8alWTcM6JjRkDPPoo0LQpwJrjKY0Z3HPlMknsdu4EihZ10mvk22zbBuzeDRQpAlxySeTH14giIAIiIAIiIAIiIALRR8A2bRB9BN2fsQS6+0yt7tG2Q8hSZuedZ5Dt2wdccEHo+J58Ehg50tzZHjzYWT/0mjP5WqVKQOfO/p8pV87cT2cdctYjl4mACIiACIiACIiACIhALBCwTRvEAtNw1yCBHi7BKHvetkNID3WOHAYiE7wxlDxUe/pp4MUXgR49gBEjQu0l9XPNmgGzZgGvvw488YR7/aonERABERABERABERABEchIArZpg4xkYcvYEui27ESE5mHbIeTdc4aZ85+PPQZkyxY6CN897C5djCfdLWPZshdeADp2NJnSI2ksnzZ/vrlf3q5d2iPzrjzbMcne3XdHcoYaSwREQAREQAREQAREIFoJ2KYNopWjm/OWQHeTZhT0FcuHkOXF+vcPTkgz8VuWLMD55yfehU+5jR98ADzwQNqJ5Lzcdt6Nnz0bGD0a6NAh7ZF8c2zQwAh1mQiIgAiIgAiIgAiIgAgEIhDL2iDQ2m39XQLd1p3xaF6xfAjpZaYXnV7nsWOdAWzRAvjkE+MZp4fcny1bBtxwg0lgx0R2kTSWdlu40GRyb9s27ZE//BC4556M+YgQSR4aSwREQAREQAREQAREwD0CsawN3KMU2Z4k0CPLO8NHs+0Q8g76f/9rEsU5zbyeFkTeP+c99DZtAHqUnVi9esCXXwKTJgH33ef/iaNHjQf7ssuA5s0jW2qN5d8WLwamTUs/dJ1ednrbq1UzPGUiIAIiIAIiIAIiIAIiEIiAbdog0Hzj4XcJ9HjY5SRrtO0QsvZ58eIAa6GfPh3eZrz2mqkD3qoVMGWKs77oGaeHfM4coFEjZ89EshUF9w8/mCR1TZqkPTK97PS2Mxv9ypWRnKHGEgEREAEREAEREAERiFYCtmmDaOXo5rwl0N2kGQV92XYIt2wxnumcOYHjx8MDyFrgLIfGWuAVKjjrq3x5YONG46WuVcvZM5FsRcH9yy/AggXArbemPTLnT2/75ZcD69dHcoYaSwREQAREQAREQAREIFoJ2KYNopWjm/OWQHeTZhT0Zdsh/P13oGxZIE8e4PDhyAOkmOe98p9/Bq65Ju3x//jDCOVSpYyXOlJGwf3rr4E/INDLTm97yZLA5s2Rmp3GEQEREAEREAEREAERiGYCtmmDaGbp1twl0N0iGSX92HYIN2wArrgCKFAA+PvvyEPMlQs4cQLYtMl48tOy7t2BV14BnnrK1FqPlPHOOwU379RffXXao/LjAT8cXHwxsGtXpGancURABERABERABERABKKZgG3aIJpZujV3CXS3SEZJP7YdQtbvrlgRKFQI2L07PIgUsryLfdFFALOzB7J//kmsu75vH3DBBWk/4bvf3rIlMH16oJ4j/zsT2f34I5A7t8k4LxMBERABERABERABERCBQARs0waB5hsPv0ugx8MuJ1mjbYeQoeXXXgsULQrs3BneZsyYAVBA16gBLF0auC96zh9/3ITWM6kcE9WlZUwixyRt110H/PRT4L7VQgREQAREQAREQAREQARsJ2CbNrCdVyTmJ4EeCcoWjWHbIfTVGL/0UmDr1vBAzZ0LNG4MVKlivMlu2urVJsS8YEFg/343e1ZfIiACIiACIiACIiACIpAxBGzTBhlDwa5RJdDt2g/PZ2PbIeR96YkTgfPPBzp1Cm/5XpYaO3IEyJvXzO/QocR/D2/G6T997py5F58tm6ltnl4IPsP1x44FTp4EOnc2deVlIiACIiACIiACIiACIpAeAdu0gXYLkECPs7cglg/hokVAnTqmxNratYE3lnXX+YcfBzJlCtz+wguN93zVKnNv3mvj3LJnN6McPAjky5f2iBTmLFUXyQ8IXq9f/YuACIiACIiACIiACHhLIJa1gbfkvOtdAt07tlb2HMuH8NtvgZtuAsqUMfXQA9mnnwKNGpmkaixTFsiuvx5YvhyYNcvcR/faeDfeJ8opwH1i3d+49LZnzmx+YbI9Jt2TiYAIiIAIiIAIiIAIiEB6BGJZG0TrzkugR+vOhThv2w4hPcMU06yDzprf4ZjvPnuJEsCWLYF7mjwZaN0auOUW4MsvA7efPRtgKDmT0LGcmde2Zw9QuLAZ5d9/A3v5c+QATp0yd/l5p18mAiIgAiIgAiIgAiIgAhLo0fUOSKBH136FPVvbBPr8+cAddwCVKxvvdDjmqwVepAjw55+Be3r7baBjR4C1xpkB3jbbtg3gxwZ6zulBD2T585v78b/+CpQrF6i1fhcBERABERABERABEYh3ArZpg3jfD65fAj3O3gLbDqGvfJnTMPP0vwACX39t7pTXqxd4Y4cPB3r1Ah54AHjvvcDtI91i40agfHkT5s5Ig0BGbzu97vxQwYzzMhEQAREQAREQAREQARFI//+fDyNfvnw4dOgQ8voyIgtZhhKQQM9Q/JEf3DaB/sknQIsWzmuXu0nsueeAIUNM1vPXXgvcM73TX30FHD0KtGkTuH24LXyl3Si8//orcG/0ttPrzvv0/OAhEwEREAEREAEREAEREAEJ9Oh6ByTQo2u/wp6tbQL9o4+Au+8GatcGmIU9kkZh/sYbwH/+Azz/fOCR160DrrwSYCj5gQOB24fbgpno77nHlFdbvDhwb/S20+vOtrVqBW6vFiIgAiIgAiIgAiIgAvFNwDZtEN+7YVYvgR5nb4Fth3DKFOC++4C6dYEvvghvM3hPe/p0UzrrYVU2AAAgAElEQVTtwQcDJ1Vr2xaYMAFgqPvTTwce+9gxIHdu044CnUI9kPXuDSxdajK/FygQqHV4v/MDB9fObPMFC4bXl54WAREQAREQAREQARGIfQK2aYPYJx54hRLogRnFVAvbDiEFMoXybbcBn30WHmrWKGetchqzrZ93Xvr9vf668dpTzLPcmhNj+bK9e4GVK4FKldJ/4uzZxDnwAwA/BMhEQAREQAREQAREQAREwBYCtmkDW7hk5Dwk0DOSfgaMbdshHD8eaN8eaNgQmDs3PCBHjgC+3BbHjwM5c4bXn7+nebeb5dx4d75Zs/T7ZzZ1X+k4lj3btAnIksX9OalHERABERABERABERABEQiFgG3aIJQ1xNozEuixtqMB1mPbIVyxwoR/ly0L3H9/eJvBGuCsBU5j1nNmP3fbeF+e9+ZfeQV48sn0e//wQ3OHnEYP/bhxwEUXOZ/RvHlAjx5A9erA2LGBn2Mtd34EqFkz/JrygUdTCxEQAREQAREQAREQgWgnYJs2iHaebsxfAt0NilHURywfwn//TfRQs9xYIDF84oQR9JkyOd/Anj2BESOALl2AkSPTf47J5wYPNiJ96lTnY/ha+sL/b70VWLAg8PNNmwKzZwNjxgCPPBK4vVqIgAiIgAiIgAiIgAjEN4FY1gbRurMS6BbtXP/+/TFgwIBkMypcuDD++l+NrXPnziX8PmbMGBw4cABVq1bFqFGjcCVTizu0WD+EvHfOu987dgDFiqUPheXLeG+ddcOdInzrLaBTJ6BJE+P5T8+GDTNe865dzTPB2jvvAB06OBuLffNDAL32LBnHDPUyERABERABERABERABEUiPQKxrg2jcfQl0i3aNAn369On4Ikk68yxZsuCi/7mChw0bhsGDB+O9995DuXLlMGjQICxZsgS//vor8uTJ42glth1CJlyjt5tZx4sUcbSEdBvlygXQM755M1CyZPr98Y46M79v2QKwhrgTYwg5w/KvuMK5qPf1u3UrsGoV0Lixk5EAJrGjp55h9dOmBX7mgQeADz4wHn6GxstEQAREQAREQAREQAREQAI9ut4BCXSL9osCfebMmfj5559TzYre86JFi+LJJ59Er169En4/deoU6GGncH/00UcdrcQ2gc7M5lxOu3YAE8aFa7x3fvgwwARt5cql3RvLkWXPbn7/+2/vS6BxS6+7Djj/fGDnTsDJ9xQKbYbUt2ljhHcgo7edXnfWdGd4vUwEREAEREAEREAEREAEJNCj6x2QQLdovyjQR4wYgXz58iF79uwJIexDhgxBqVKlsGnTJpQuXRorVqzAtdde+/+zbtq0KfLnz4/333/f0UpsE+i8o00x+fDDRlyGa6yDTuO9bV9Gd3997tuXeEf9zBn3s6vzA0DWrIn323k/vkIF8+Fg1ChnIe+DBgF9+pj75LxXHsjobafX/bnnAD4rEwEREAEREAEREAEREAEJ9Oh6ByTQLdqv+fPn4/jx4wnh67t3704IYd+wYQPWrl2bEMZeo0YN7Ny5M8GT7rMOHTpg69atWJBGFjF62fnHZxToxYsXx6FDh5A3PQUbIS68ct+/P/DYYwDvd0fK/vgDKFPGeLSPHg1uVKJevx5o0QJg+TR/9sYbRihzXbyLTvOFrDM8fu3awMnpfEnmeJ+c98oDmS+B3VNPAS++GKi1fhcBERABERABERABEYh3ArY57+J9P7h+CXSL34Jjx44leM179uyJatWqJQj0P//8E0WSXNZ+5JFHsH37dnz22Wd+V+Iv8Rwb2iLQ6SGmt/eJJ4yAjZStXAlUrmzuvf/5Z3CjVqsG/PAD8PHHRqT7M1+4eVJvNkPvmbiOHwSYZqBu3fTHpbDnR4uHHjKe9EDWt68Jb480y0Dz0u8iIAIiIAIiIAIiIAJ2EpBAt29fJNDt25NkM6pfvz7KlCmDp59+OqQQd9s96M8+C7zwgqkpztri4RqFL++U164NMEt7WrZ4MXDzzUD58sCGDcGN2qqVSdr20ktA9+7+n/WJeLZjkjefUTwzxL1ZM+CTT4IbN1BreuUZQs+a8hUrBmqt30VABERABERABERABOKdgAS6fW+ABLp9e/L/M6K4pgedYex9+vRJCG3v1q1bgkeddvr0aRQqVCiqk8Q9/bQJx2bWcSZFC9coTNesCeyhZtI2epvpQWc4ejDm+6iQVug5y7zx9sDx4yYU/vLLE3vnf/MueubMADPCO80eH8z81FYEREAEREAEREAEREAEnBCQQHdCKbJtJNAjyzvd0Xr06IHGjRvj0ksvxZ49exLuoC9evBirV69GiRIlEoT40KFDMX78eJQtWzYhgdyiRYuiusxat27Aq68CzzwDDB0a/mYwUzrLoM2fDzRoEH5//noYPdrcLW/UCJgzJ3WL334zGeRz5DDh7FmyJG9Tr54JkZ84EWja1Js5qlcREAEREAEREAEREAERCERAAj0Qocj/LoEeeeZpjtiqVauEuub79u1LqH3Oe+fPP/88KtDlCoCl1gYMGIDRo0fjwIEDCVneR40ahauuusrxKmw7hLNnA998A9SpA9xxh+NlpNnQF1o+axbQpEn4/fnrgUniKP6JffXq1C14N/3OO4HrrweWLUv9OxPUsbR9oBx9jCpYssR8vEjrrnvS3lnP/b//NX3zI4BMBERABERABERABERABNIjYJs20G4pSVzcvQOxfghr1TKC/6OPjEhOy3yl1TJlCv4V2LjR3F3PndvUXE/Zhy9ZW/v2wLvvBt+/74nGjYG5c4GxY02iuEA2aRJw//1GnH/+eaDW+l0EREAEREAEREAERCDeCcS6NojG/ZUHPRp3LYw5x/ohpDj98ktg8mTg3nvTBtW7NzB8OMA78MGG1p88CeTMafreuxe48MLk4zB0fcoUkxzugQfSnsO5cyYcn9nk/X0oqF/f3KVnf61bB950n+e+Zk3jeZeJgAiIgAiIgAiIgAiIQHoEYl0bROPuS6BH466FMWfbDuGePcCJE0DBgkCePGEs7H+P3n47wIpz772Xvjh+/HHgzTcBertZiz1YYwg9S6Zdcw2QNWuwTwP//gvUqAF8/725j37DDan78EUDTJ8OtGwZeIxPPzX34qtUAX78MXB7tRABERABERABERABEYhvArZpg/jeDbN6CfQ4ewtsO4Rt2hgPcXoly4LZIiZd4732MWOARx5J+0nfuMwg/9RTwYzgXtu77gIovgcO9F/nnKKdd9gZ5t6wYeBxGTnACAJmsl+1KnD7SLXgxwhmrZeJgAiIgAiIgAiIgAjYRcA2bWAXnYyZjQR6xnDPsFFtO4QMQ586FRg5EujSJXwsvHu9cydQvbrJpJ6WORXywc7o4EHg1Kn0a7D7+qQHn578W24xYfkp7eqrTRI6rslJ0rdvvwVuusnUQec9eRuMdd/5EYJl7S6+2IYZaQ4iIAIiIAIiIAIiIAI+ArZpA+2MPOhx9w7YdgiZyI13p0eNAjp1itx2MGv8okXAtGnmrniwtm4dsHAhcMklyZPRvfWWWUerVuYeenrGPq680txnP3AAyJ49eWt+YGDJNia9o/AOZMuXm8zxxYsD27YFah2Z3313692qcx+ZWWsUERABERABERABEYgPArZpg/ignv4q5UGPs7fAtkPYrBnA+9ysLd6hQ+Q2g4nZVq4MvV76O++Y+bI0HO9++4z10bkWJ3XdmSSucGGTaM6fCGeI+6ZN5kMA5xvI1qwx4e0ss8a7/TaYT6D/8gvAiACndvYs8PvvJgoilEz7TsdROxEQAREQAREQARGIZwK2aYN43gvf2iXQ4+wtsO0QMqkZBe64ccCDD4a/GfRKb94MlCljSqGlZfyd9cgZFs5w+GCN2dWZZZ0l6teuTXyafbEWeaAs8r4n6L1nSbhBg4Dnngt2FsnbHzpkPnYw2V7z5uH15dbTjAo4fdp49OnZd2pduwKvvRY4l4DT/tROBERABERABERABEQgNQHbtIH2SCHucfcO2HYIGzQAFiwAPvgAYOK2cI13nhkuHyg7Oz8GbN9uvN2lSwc/Kr27vOudKxdw9Kjx8jIZWr585r8p2ineAxnnyjnHYu1y3sXPkcMQ4N18snFqPq95oULA7t1On1I7ERABERABERABERCBYAjYpg2CmXustpUHPVZ3No112XYIndYtd7pN3boBr77qLMTcaZ/+2lF88u44w9QZTs6wcoajU+xnywYcOwacd17gEXjHnMni6I1nuHwsGUP3KbBpDz0EjB3rfHU+gV6pkrmKIBMBERABERABERABEXCfgG3awP0VRl+PEujRt2dhzdi2Q8gw5g0bgPbtTYKzcK1XL2D4cKB7d1O6zUtjgjhmjPfVMf/kE6BFC+Daa4EVK8IbmXewa9Y0Hmj268T7zGfmzTNZ5JmlPpT67OHNOvnTvELAqwQ+O3zYWa37EydMZALtr7+cZcR3c97qSwREQAREQAREQATihYBt2iBeuKe3Tgn0OHsLYv0Q9ulj7nMzbPz11/1vLr3etHCTjzGzOu+w+zLBDxgA9O8PPPAA8N574b1Yx48D559v+nAqbP/5x3jvaX//DRQoEN4cwn2akQX8ADN4sOmJnnB6xAOZL9kdP0owu324+xRoPP0uAiIgAiIgAiIgAvFKINa1QTTuqwR6NO5aGHOO9UM4cCDQrx/w6KPA22/7B8X741dcARQrBmzZEjrM++8HJk0Chg0DevY0tcxnzzaeb5aPc2onT5rEckykRnFPozAtWND8O5OsOfGG88MDw+p5F/7PP4EiRZzOwNt2N94IfP898OGHwF13BR6LZffIj1nsGZ0gEwEREAEREAEREAER8IZArGsDb6h526sEurd8revdtkO4f39icjWf9zccaCNGGLF8770mk7o/Y/j5ddcZgb5jR+ij0dPLcGwmi8ufP/R+Vq0CrrnGeMwpzCnGd+0CihYFMmcGzpxx7kVmH/S+8z78ZZeFPic3n2zbFpgwARgyBHj22cA9M0SfIp2e9yZNgKFDAz+jFiIgAiIgAiIgAiIgAsETsE0bBL+C2HtCAj329jTdFdl2CClMKVBZ65uJ0sI1erB5/5o1t1l72599/TVwyy2pS6SFO3aoz9PjzSRzDEunJ71aNVMqrlQpcxebCeec2gUXmH5Ybo5RAhlpnAc/wDBT/ciRJs/Au+86m5GvjN1VVwGrVzt7Rq1EQAREQAREQAREQASCI2CbNghu9rHZWgI9Nvc1zVXZdgivvNKIya++AurUCX8zWJLr/feBypVN6TJ/xlrhzZoZIUxB7IbR401RXbGis0RoKcdkcjkmg6O3+JlngPXrzQcEhrlT5Do1RgUwvJ1RAkxWl5H21ltAp06JM2Do/5IlzmbE0HbuT4kS4V1DcDaaWomACIiACIiACIhAfBKwTRvE5y4kX7UEepy9BbYdwvLlgY0bjXCjgIuEMdyaYde33mpqsIdqDG8fM8bcHWeYe8eOofdJD/OTTwK33QZ89plJqMaPDAxzZ6Z4p0avOz8UfPcdwLvfGWm8m8+PDfSC8zpA8eKGVSBjgj9GDTDRXrAfKAL1rd9FQAREQAREQAREQAQSCdimDbQ3gAR6nL0Fth1C1g3nfelICkqGXFMEMhHZRx+F/gIweRtroTNEnR7wGTOAp582Zd6CNYbjM8N57twmRJ3/zQgAJnqjN92p0evO9m5FJDgd11+7554z984fe8xwufTSwLXh9+0z4f4+4318cpaJgAiIgAiIgAiIgAi4T8A2beD+CqOvRwn06NuzsGZs2yFkCDO9qj/+CFSpEtbS/v9h1s7+5hsjdm+/PXWfFI0Ujw89BIwdG96YFJ3btxvhyWRuEycCrVsH3ydF/oUXmiRxzHhetWrwffAJZko/ehRo0MB43zPSOncG3ngDYOk7Ztd3YvxQU6OG2Tuug8Ys99mzO3labURABERABERABERABIIhYJs2CGbusdpWAj1WdzaNddl2CH13pp3WyHayXePHm4RkTATH0mcp7YMPTPh048ZAt25Oeky7Te3aye9VM+Ed76GHYrwXz/vxzETfo0coPdj1DEvGkXUw6/HtHbkuXmzWQ686k9/JREAEREAEREAEREAE3CVgmzZwd3XR2ZsEenTuW8iztu0QFi4M7NljMnXzrrIb5iujxvvLFHeZMrnRq/8+fCKUvzIcm3enndQs99cb5825MgN9lizezTlSPTdvDsycCYwebaIDWDqNnv02bdKeAcuwvfCCSS43bpzxnvNOfcmSkZq1xhEBERABERABERCB+CFgmzaIH/Jpr1QCPc7eAtsOYZcuwMGDJns5veluGEUdQ6TPnjXh55dc4kav/vvo1y8xfJsl437+2Z2xeIecQpVh/6wH7tR4d51Z3HkXndcHMtLq1jV34adMAX79FejfP/C1Al82eybNa9XK1IZnqTkvP7JkJCONLQIiIAIiIAIiIAIZScA2bZCRLGwZWwLdlp2I0Dzi5RAyzJyZw+fOBRo29A6uLySbIzAzPEu8uWHsp107c4d+3jznPfoELkucMTlbRhrnwBJ6Dz9s9uL++4FatRJD1/3NzVd2b/58422XiYAIiIAIiIAIiIAIeEcgXrSBdwTd71kC3X2mVvcYL4eQYnDSJGDQIJMQLqkxOzo93RTB4Yr3RYsS67ezZBtLt4Vj9Djz3jYzsTNxHu+lsz66U7vvPuOxfuUVU7bNFuNamPguvbJxTJRHb/mpUyaz/2WX2TJ7zUMEREAEREAEREAEYpNAvGiDaNo9CfRo2i0X5mrbITxyxGRAz5HD3TDmF180pb3uustkNk9qLGfGUHDWG2fd8XCM86eYpphMWh4s1D5ffhl46qnEpxnmTcHt1Jgcj159hsf36uX0Ke/bsXScL9Ebs7MzdN2f8bfffzeJ9pgBnh9SHn0UqFbN+zlqBBEQAREQAREQARGINwK2aYN44+9vvRLocfYW2HYIM2cGzp0DWBqNCePcss8/N97ssmWBjRuT91qqlEk8Fsna607X5Utw52vPMHcKbqfG5GoMLed9b96Pz0ij0M6Tx3y44D5ToPtqvDMRXiC74w6Aoe5cPznIREAEREAEREAEREAE3CVgmzZwd3XR2ZsEenTuW8iztukQMqTZl63c7VJahw4BX3wB0FteunRyXD6huHatSaZmkzGxHefH+dN4j5yC26mxbNyrrwLPPGMS72WU/fMPkC2bGd23twxxZ6g7s7nzrnwgu/tu4KOPgNdeA1hTXSYCIiACIiACIiACIuAuAZu0gbsri97eJNCjd+9CmrlNh/D0aSB7drMMZnLPly+kJQX1EL31FI5nznif4T2oiSVpzPrsTG5H4z1y3id3ar4yZcE+57R/p+2ShrTzTjmZMy/A1KnA668DHTum7olCnEnl2O6mm0zGd5ZaYxb73r2djqx2IiACIiACIiACIiACTgnYpA2czjnW20mgx/oOp1ifTYfw+PHEu8jp3Ut2c4tOnDCJyGiHD5sQbNvMd3+e8+I9ct4nd2oDBpjw9mA97077d9puyxZzL5+5BcicduCAKX+XVp14Ju/78svEkHZ+ZGC5tYyOBnC6ZrUTAREQAREQAREQgWgjYJM2iDZ2Xs1XAt0rspb2a9MhZBh3/vwGFGuX+7zpbqFj8jZmQOfddnpjabt3AxdfbBLS0YvOu9G22U8/mfrnjChgeDiT6Dm1H34A+Id3vG++2elT7rdbtQpgXfhChQxzJ1a8OLBjR2JugD59TBb+xx83CeNkIiACIiACIiACIiAC7hKwSRu4u7Lo7U0CPXr3LqSZ23QI9+8HLrzQLINi2XcfPaSF+XmI2c9ZduzGG43oo+3aBbRuDfCu9+LFbo3kbj9kQS4UrMw0X6yYu/1HorelS4GaNYEyZYDffgs84rFjxrtO43tRsCAwfLiJIHCzvnzgmaiFCIiACIiACIiACMQPAZu0QfxQT3+lEuhx9ibYdAiTerOZMM5towedSeBY0ovh7DZ6y9NaM0P+fYLVbS6R6G/ePFNjvnJlYPlyMyJzDjCSgdndGcruu2rA31hO7dprTYI8Rg3QmByPWembNwdmzIjErDWGCIiACIiACIiACMQXAZu0QXyRT3u1Euhx9ibYdAh5J5nJwijOU9Yqd2Nb6InmHXOGz7PUGkuuxbrxXj9rvPOfdetm3GqZDO7ee02Y/ddfJ86DnnHuO0PgWevcZ9z/e+4BqlcHvv3W/C0/qvBDBUP906qbnnEr1MgiIAIiIAIiIAIiEP0EbNIG0U/TnRVIoLvDMWp6ibdDyLvcvNPNcl133hk12xTyRH2e6GDufoc8WDoPspzaBx+YEncs/eazG24Ali0zHnF6xn32/PNA376m3nkwdd+9mLv6FAEREAEREAEREIF4IRBv2iAa9lUCPRp2ycU5xtshfPhh4N13geeeMwnHJk0CunYFWMosFoVg0msDDCkPJsGci69Zml0xJwBzA/B++dNPJzZjKDtD2lm7nVnbQzXWX+dVBrfzGYQ6Hz0nAiIgAiIgAiIgAjYTiDdtYPNe+OYmgR4Nu+TiHG06hKxJzvB2L8UUa2536QI0agTMmQOw1jYF+t13A9OmuQjWkq7IkzXHmQSPGdFtSzDXrx8wcCDwyCPAmDHJoTGknfP3ZfbfudMIea5nxAhngN9+21yb4IcAfoyRiYAIiIAIiIAIiIAIpE3AJm2gfTIEJNDj7E2w6RCuXQtcdVVwpbiC3a5vvgFq1QJKlQL++MN40Vm+i571d94JtrfoaE9R/uefJpT8+uszZs7MxE6xzfvjFNg+mzDBZGWvUwf46qv05+ZL8legAPD3387WwZrxzz4LPPggMG6cs2fUSgREQAREQAREQATilYBN2iBe9yDluiXQ4+xNsOkQMplZpUpAkSJGUHphJ06YBHFXXGGEYs+exhv71FPAiy96MWLG90lRzszps2ebUP6MsPbtzRWClCHr339vyt5dcgmwfXv6M2MEAEvNMUyf4fqsXR/IGB4/bBjw5JPAK68Eaq3fRUAEREAEREAERCC+CdikDeJ7JxJXL4EeZ2+CTYeQIpJikiJs27bIbMRjjwGjRwMDBpikZLFoFOVz55p1duiQMStkQr6PPwZGjTKl0nzGEmqFCwMlSwIbNgBZswJMKMccAaybnnRPDh1KDHfnh5YcOQKvhYnnZs407ejBdyLqA/eqFiIgAiIgAiIgAiIQmwRs0gaxSTj4VUmgB88sqp+w6RD+8ANQrRpw2WXApk2RwcrSXywBRu8qvayxaLzfPXZsxn6EuPVW4PPPAYa0339/ImXmHaA3PHv2xL/jXDnnBg2A+fMT/5736H1J7vbsAS66KPBuNW1qIgdoFPh58wZ+Ri1EQAREQAREQAREIF4J2KQN4nUPUq5bAj3O3gSbDiHrXd90k6lPzjB0r4wfApiQrEQJgP8+b565n8x7yrFoX3wBrFsH1KgBXHddxqyQH17IetYsoEmT9OfAbO68bsBkfiNHJm/L+ues6c78AcwjEMgo8hcsMK02bzaeepkIiIAIiIAIiIAIiIB/AjZpA+2RISCBHmdvgk2HcPFi4Oabzf1wCkqvjCHPDH3mfXeGUfPDwJAhwG23eTWi+q1QAWCSt6+/Nnucnvm83inD4fnMxRcDLB3H+u7XXBOYq+/DAFv+9FPGfaAIPFO1EAEREAEREAEREIGMJ2CTNsh4GnbMQALdjn2I2CxsOoT09NavD1SsCKxa5R0CelLpfWWSuCNHkmcV927U+O6ZSeBYJo15BipXTs5ixgzg5ZdN9ASzrl9+OfDrryYkvl695G3LlDHec2bjZ/tA1r17YnK4hQvN+yUTAREQAREQAREQARHwT8AmbaA9MgQk0OPsTbDpEK5YYZKCMQz5jTe82wjee2ZtbdbZZub4q6/2biwbej55EiDbgweBO+7ImBnlyQMcPQr89htAkZ3UPvgAeOAB4JZbTDh6zpzAmTMmUSATBia1LVtMIrlChcw/nRg99ozOmDIFaNXKyRNqIwIiIAIiIAIiIALxScAmbRCfO5B61RLocfYmxOshZC10emEpDtu0ie1Np9DlfXtGDFCsRzqTOT+IdO5sPojwTjnrmCe1774z9+Mpxr/8EihXzoh0CvrMmcPfm5YtAXrp/YXMh9+7ehABERABERABERCB2CEQr9rA5h2UQLd5dzyYW7weQgpGn5ee4e6sx+0kK7gHW+B5l0mzpLOs2QUXeD5kUAPs3Ws84jRec6CXu1gxc888HOOHAZZWY36BRYtMeTeKdZkIiIAIiIAIiIAIiIB/AvGqDWx+HyTQbd4dD+YWr4fQV8rLh5R30XPn9gCwJV1eeCGwfz+wejVw1VWWTOp/00h65WDtWoAJ5VjnnF70lPbRRwA97o0aAXXrpr+Ov/4CihQx1xm4dje88XaR02xEQAREQAREQAREwF0C8aoN3KXobm8S6O7ytL43mw7htGlAu3ZGeM2d6y26ZcuAG24wY1C48c5zpEO/vV1h8t6ZeG/NGiAjEqXRg++rQZ603nnSGV5/vUkgxwz7zOKelvlqug8aBDz3XPoEN2wwFQEo0A8ciCRtjSUCIiACIiACIiAC0UnAJm0QnQTdn7UEuvtMre7RpkM4YQLQti1w662Jtau9gkdBvnKlEenxIOCYvZzh4++/bxiHY/R4d+gA5MqVuk65v355feDGG03mfGZg92cMa+cHGtY/f+qptGfny8req5fJ+J6e+cZl0kFm7ue8Y/kjTDh7qmdFQAREQAREQAREgARs0gbaEUNAAj3O3gSbDuH48UD79ibT+Kefer8RP/4IVK0KXHopsHWr9+Nl5AgU5fwAQlFLcRuOMRu8L9EbE78xQ3t6Rq89a8yz7jw/ivizfv2A994zmdsbNADGjEmdwZ3Psd3AgeY+OZO+pWeffQbcfrtpwXv3LN+2dGk4K9ezIiACIiACIiACIhDbBGzSBrFN2vnqJNCds4qJljYdwnfeMcWizoMAACAASURBVJ7ZJk2AWbO8x8s62/TWe1133fuVBB6Bonz4cKBrV+DVVwO3T68FPdH0njMjPD3i9IynZ9OnA3fdBTBzPsud+TP2yaztefOaXxmSzsiGlDZiBNCzp8m8zwz86Rk98vTM8woDk8WVLQts3Bje2vW0CIiACIiACIiACMQyAZu0QSxzDmZtEujB0IqBtjYdwrfeMp7RFi2Ajz/2Hm7STO4UiLFs335raqFXqQJUqxb+Shl1sH27yX7PKIT0bNw44KGHTGK3OXPSbsk76LyLzozuu3f7b/f220DHjkCzZsAnn6Q/7ujRwGOPGWHO+uv0ojOLvUwEREAEREAEREAERMA/AZu0gfbIEJBAj7M3waZD+PrrQJcuwN13m/vIXtu6dUas8s4zQ6dlzgjQ003RyyzpFNwU3ukZPfbdugH33QdMmpR2y8mTgdatgZo1gSVL/Lfj8/ffbxIJ8k59ejZsGPDMMya8fsEC40n/5x9lc3e2y2olAiIgAiIgAiIQjwRs0gbxyN/fmiXQ4+xNsOkQvvIKwCRggYScm1t09iyQJYubPcZ+Xz6RzJXSO/7gg+mvmXfG+QGE3mxGSaRlvgRu1asD9Pj7s9mzTZZ3Jvf74Yf0x6XgZ1K8W24xQp3299+J9+djf6e0QhEQAREQAREQAREIjoBN2iC4mcduawn02N1bvyuz6RB++CHAEGZ6RwOV0IqzbQp7ufQcMykeQ8d5hSAce+MNgNcDaE6SzvXoAbz0krk7Tq92IIHOJHHz5/tvxaR0O3ea++msce7UWOP+2DHg99+B0qWdPqV2IiACIiACIiACIhBfBGzSBvFFPp3/Rz53LtZv42qrkxLQIYyP94Fh6b5s60eOABSsodrzzwN9+5qneT2ApdHSM3qy580zyf94fSEtY21zJrJjpvWrrw51dv6fK1HCZIin153ed5kIiIAIiIAIiIAIiEBqAtIG9r0V8qDbtyeezkiH0FO8VnXu8yIzkznvkIdqvlrkfP7rr4Gbbw61p9TPuXnlIGnd83vvBfbuNR8TWO5NJgIiIAIiIAIiIAIiIIEeDe+ABHo07JKLc5RAdxGm5V1RlDPEm6XOWPIsVOOdc9YsHzo08W53qH0F+xzD1OllZ0QAxbbv3rq/fmrUANauNQkHmShOJgIiIAIiIAIiIAIikD4BaQP73hAJdPv2xNMZ2XQIGTo9cqQpo8V/l7lLgKL8m2+AqVOBe+4JvW+WOGOdeuYLePTRwP3w3niOHEC2bIHbBmrB8HxfrfTjx4GcOdN+4oorgA0b3PfyB5qjfhcBERABERABERCBaCVgkzaIVoZuz1sC3W2ilvdn0yFkErERI5zda7Ycq5XToyhnIj6WPevaNfQp1q5tyqD95z/GM33TTen3VbEisGYN8PnnQL16oY/LJ//9NzHrPhPesWZ6WsYkciwFt3KlwtrDo66nRUAEREAEREAE4oWATdogXpgHWqcEeiBCMfa7TYfQd7e5Vy+THVzmLgGK8tdeA8Lly9DyuXNNqDw92PRkp2duJ2hzmpGdczt5Eti8GZgxAxg8GGjTxnygkImACIiACIiACIiACKQmYJM20P4YAhLocfYm2HQIu3QBXn/deGYV4u7+i8iPHs8+C7Rta+qDh2NJQ815H/z889PurUAB4OBBYP164PLLwxnVPOvEM05h7gt/P3DA1Gtnxvn77gNYx10mAiIgAiIgAiIgAiIggR4N74AEejTskotztEmgd+oEvPUW0L8/0K+fi4tUVwkEGOr93XfANdcEDksPhIwZ0nPlSvRQlyzp/wm2O+88E5rO+uVFiwbqOfDv5coBv/1mwuxr1vTfnuHvF19sksidOQNMmAC0a2dC8j/7LPAYaiECIiACIiACIiAC8UjAJm0Qj/z9rVkCPc7eBJsOYYcOwDvvAKyH/dxzcbYRUbJcCu1duwB6xekN3749/drizLruq7kebv11H6LrrgNWrAA+/RS44w7/4H791cwvXz7jvZ8zx9Rhr1IF+PHHKIGtaYqACIiACIiACIhAhAnYpA0ivHRrh5NAt3ZrvJmYTYewfXtg/Hhz/5z3pGX2EdizByhc2MyLnvhffjH30Rs29D9Xinl6zenJZo3z9MqiOV0t667z/nt62ehZTu7xx032eGacZ+QAy66VKgX88YfTkdROBERABERABERABOKLgE3aIL7Ip71aCXRL34ShQ4eid+/e6Nq1K179X5ardu3a4f0Ul4mrVq2K77//3vEqbDqEvHdOT2fnziaZl8xdAvR+U6hSNLNUWtaswffv80yz1NmNNwILFpiPKgwf92cpPdnBj5j6CfbJsPVLLwXy5HHWI8utsexa/vwA76TLREAEREAEREAEREAEUhOwSRtofwwBCXQL34Rly5bh7rvvRt68eVGnTp1kAn337t0YT4X0P8uWLRsKFizoeBU6hI5RRX1D3gfPnh345x9g61YjcIM1fvuhMGdmdtZV593uYcMAlsjzZxyH1xX4MSDJaxrssGG337s3sSQb18978TIREAEREAEREAEREIHkBKQN7HsjJNAt25OjR4+icuXKePPNNzFo0CBUqlQpmUA/ePAgZs6cGfKsdQhDRheVD1KUB7o3nt7C5s83974rVTLJ/NauBerWBapWtRsHPe433ADw29Unnzj3vNu9Ks1OBERABERABERABNwlIG3gLk83epNAd4Oii3088MADCR7xV155BTfffHMqgU5xTq95/vz5Ubt2bQwePBiFChVKcwanTp0C//iMh7B48eI4dOhQgodeFtsEKKSZJI3fdJo2DX6tkycDrVsDdeoAX30V/PNuPMH7519/DVx/PdCokf8eWaudyQaZ1+Dll90YVX2IgAiIgAiIgAiIQOwTkEC3b48l0C3ak6lTpyYIboa458iRI5VAnzZtGnLnzo0SJUpg8+bN6NOnD86cOYPly5cjO2OZ/Vj//v0xYMCAVL/YINAfeMAIL4qru++2aCNiaCq8e86kaSxn99hjwS9s1CjgiSeAFi2Ajz8O/Pzp0yYxXCj33dPqnZ57vsIdOwJvvum/Ve/ewNChQJcuwMiRgeepFiIgAiIgAiIgAiIgAoAEun1vgQS6JXuyfft2XH/99Vi4cCGuYbpsIJVATznVXbt2JYh1CvsWVFB+zGYP+u23mxrV770HUKzL3CdAUT56NNC3rxG5wRq90n36AA89BLz+uqlHfvKkCR/3Z2xDkXzffcCkScGO5r/9Sy8BPXoA999v7sD7s06dzEeIUNfpzkzViwiIgAiIgAiIgAhEFwEJdPv2SwLdkj1h6Hrz5s2RJUuW/5/R2bNnkSlTJmTOnDkhTD3pb75GZcuWxcMPP4xeDuuU2XQI69cHvvgCmDjRhFHL3CdAUU4PNGvOU6gHa7NnmzvctWubOuNMGMd77UwG5898gv7hh02NezdszBjg0UdNiH5a6Rf4QWDKFBPe3q2bGZXh7oweYBEEVQlwYyfUhwiIgAiIgAiIQKwRsEkbxBrbUNcjgR4qOZefO3LkCLamUD0PPvggLr/88gTxfdVVV6Uacf/+/ShWrBjGjBmDtm3bOpqRTYeQ95oXLUq/vrWjRalRmgR84rZxY4BiOxxjPfEyZYCcOYHjx/33xOzuI0YA3bsD9Hy7YRTeFOC33AJ8+aX/HpnIjgntxo0DHnzQtPEn2t2Yj/oQAREQAREQAREQgVghYJM2iBWm4a5DAj1cgh4+nzRJHLO78z55y5YtUaRIEWzZsiWhTvq2bduwfv165HFYINqmQ1izJrB0qbnbnEaEvod046Nr1gOnqK1QwSR6C8eOHAF8eQWPHgXOPz91b76Qenrt+/ULZ7TEZ+fOBfiBoUoVk/DOn1WvDvz3v8CMGUDz5qYF787zDj3LvtGzLxMBERABERABERABEUhOwCZtoL0xBCTQLX4Tkgr0EydOoFmzZli5ciVYao0inTXSn3/++YSs7E7NpkPIcGnW2WYYcpMmTlegdpEksG+f8ZjnymVG5b+zKMDmzUDJkqln4oXXmlEW/LjAEPv16/2vnh8g+Bszzfs+RPADwcCB6SeXiyRLjSUCIiACIiACIiACthGwSRvYxiaj5iOBnlHkM2hcmw4hPaI//QR8+qmptS2zjwDzFa5aZZL53XYbwG9BO3YYTzb3L6WxDBr3c+xYk1jODVu+3JRYK1bMjO3PmMPg99+B8eNNtACN2dyffNJUCJg2zY2ZqA8REAEREAEREAERiC0CNmmD2CIb+mok0ENnF5VP2nQI77kHWLsWePtt4KabohJnVEz622+BP/8EmDU/d+7gpsyEcNu3Az/8YDK3V64MrFwJMOy8YcPUfdWqBXzzDfDhh8BddwU3Vlqtjx0zHwny5weuuMJ5n0w+yORw9eoBn3/u/Dm1FAEREAEREAEREIF4IWCTNogX5oHWKYEeiFCM/a5DGGMb6mA5hQoBe/cCP/8M/K+Cn4OnTBOmNuB9840bgbJljRd94ULjqW7XLnU3rEdOMc1yZ2mVYnM8eJgN580zHxGuvRZYsSLMzvS4CIiACIiACIiACMQgAWkD+zZVAt2+PfF0RjqEnuK1snNfmDqznDdo4HyK//wDZMtm2lPgX3ihqW2+bZsRvldf7byvjGjJDxIstXbllWnXT8+IeWlMERABERABERABEbCFgLSBLTuROA8JdPv2xNMZ6RB6itfKzinKFyxIXoLMyUQpyul9p1Gsn3eek6e8acP75IcOmTvlvkzyvpF495x31Hk/fvVqb8ZXryIgAiIgAiIgAiIQiwSkDezbVQl0+/bE0xnpEHqK18rOWRf8vfeAwYMBhqA7NYa1ly9vwtwPH3b2FIV81qzO2gbTiqKcZd5++83UYk9qy5aZcHrel9+6NZhe1VYEREAEREAEREAE4puAtIF9+y+Bbt+eeDojHUJP8VrZOUX50KGmLvjrrzufIhPDVauWXPjyPvoffwDnzgGVKiXvi+XXcuQwpdj++iu1p9v5yKlbMoM7E93xLjnvlCc1JoC79VYTcv/LL+GMomdFQAREQAREQAREIL4ISBvYt98S6Pbtiacz0iH0FK+VnVOUd+kCtGwJTJ/ufIobNgDDhgH58gGvvmqemz0baNrUlFhjqbWkljQk/swZIEsW52MFaska6L/+CixeDDBTfFL76CNTSq1mTWDJkuS/0bPOEHhmsg8mA3yg+eh3ERABERABERABEYgFAtIG9u2iBLp9e+LpjHQIPcVrZecU5Sx5VqMGsHRpeFP8/nvgxhuBEiWALVuS90XPOsPPgwmJdzob3jFnPXR/5d3eeQfo0AFo3Nh8QEhqzDxPgc7Sbyrl55S22omACIiACIiACMQLAWkD+3ZaAt2+PfF0RjqEnuK1snMKaZYco1itXz+8KfpEeK5cAOuTJzXWR2eddIaj79gR3jgpn65TB1i0CJg6FbjnnuS/jhgB9Oxpap5/8EHy36pWNZ7+mTON518mAiIgAiIgAiIgAiKQSEDawL63QQLdvj3xdEY6hJ7ijanOed88UyaAYpz/pDFZHEPeaRTo/M1nDD+/+WYTSr5unbsomjQB5swB6C1/+OHkfT/3HDBkCNC5M/Daa8l/u+MOgOXlxo0DmCxPJgIiIAIiIAIiIAIiIIFu8zsggW7z7ngwNwl0D6DGaJdPPw28+CLAfw4fbhbJ5HBMAseEcPTMM9TdZxTQFNL0WjMU3k1r3RqYPBl4+WWgW7fkPfOO/YQJANt07Zr8N3rVJ04E6GXv0cPNGakvERABERABERABEYh+AtIG9u2hBLp9e+LpjHQIPcVrbecUzNu2AXXrAhdc4Gya9FS/+y4waBBAL7XPWG+cIewMHWeyOJ9NmgTcf78Jo1+40NkYTlutXQscPAiULg1cfLHTp4xgp1f9mWdMJnuZCIiACIiACIiACIhAIgFpA/veBgl0+/bE0xnpEHqK19rOWc+cdc2//tqEoTsxZn2fMQMYNQro1CnxCd4z533zTz8FGELuM5Y7GznSlEF7/nknI3jfZuBAoF8/k0Ru9Gjvx9MIIiACIiACIiACIhBNBKQN7NstCXT79sTTGekQeorX2s4pynlHnGHi997rbJq33GIEfcpnxowB/v7blG1j4jmbjaHvLBHHBHF9+9o8U81NBERABERABERABCJPQNog8swDjSiBHohQjP2uQxhjG+pwORTlzID+0ktA9+7OHqIn/OefTZK1Bg2cPeNVqzVrgC++MHfemzdPPgrLvu3aBUybZu6/y0RABERABERABERABJwRkDZwximSrSTQI0nbgrF0CC3YhAyYAkX5K6+YRGlMmObESpYEtm4F/vtfoFq1wE8wgZwv23vg1sG1SK/WOcu6/fmnqZPO8HuZCIiACIiACIiACIiAMwLSBs44RbKVBHokaVswlg6hBZuQAVPw1QpnpnNmNXdiLKfGsmobNgC8w+4z/t2mTUDWrMCVVyb+fdu2wMcfmw8ASe+sOxkrUBt6/xkFwFB9ht0ntdy5Tck31mgvVSpQT/pdBERABERABERABEQg8f/rDiNfvnw4dOgQ8ubNKzAWEJBAt2ATIjkFCfRI0rZnLIpylhzjvfIvvww8L3rDmcV9/35TQ7xgwcRnxo4FHnkEaNgQmDs38e+bNQNmzTLJ2JiUzU1jQrpGjYDrrweWLUvs+Z9/gGzZzH9zrknnyb+jZ71WLeDkSZN5XiYCIiACIiACIiACIpBIQNrAvrdBAt2+PfF0RjqEnuK1tnOK8nr1gCuuANatC2+aFOEU4yyxxlJrPvMllZsyBWjVKrwxUj69ZAlQu7bx5NOj77N9+4CLLjL/RbF+3nnJnzx0CMif3/zdiRNAjhzuzku9iYAIiIAIiIAIiEA0E5A2sG/3JNDt2xNPZ6RD6CleazvfvduUTOO98ttvD2+avJNevbrpa/PmxL7o3eY98JTl18IbzTzNsm68X160KLBzZ2KPv/9uMsnnyWPC8VMaIwEYin/2rPGg8766TAREQAREQAREQAREwBCQNrDvTZBAt29PPJ2RDqGneGOmc3qjT58GcuVKnfjNJ4rPPx84ejRxyeXKAb/9BnzzDXDTTe6iSEuI//ST8eQXLw5s2+Z/zEKFgL17gVWrgIoV3Z2XehMBERABERABERCBaCYgbWDf7kmg27cnns5Ih9BTvDHT+cKFwG23AdddB1AEJzV6qplAjsbkbBTxtIsvBuip/+UX4Oqr3UXBftk/s8TTG+7LFr9iBfDYYwBFeNL78ElHv/xy4NdfTXI5JpmTiYAIiIAIiIAIiIAIGALSBva9CRLo9u2JpzPSIfQUr9Wd8744Q9Jr1jSh4ukZa4rzHjnvfS9alLwlw8Z5l5se9i1bTG1yGoU673lzDIa/u2n06LMOOkPZGV6fObPz3mvUAL77zmSYb9HC+XNqKQIiIAIiIAIiIAKxTkDawL4dlkC3b088nZEOoad4re78xhuB7783d9GbN09/qm+/DXTsCDRtCsycmbrtJZeYu+DMqM675//+CzRubO6Bz5mTmJjNBiBNmpg5jRljss/LREAEREAEREAEREAEDAFpA/veBAl0+/bE0xnpEHqK1+rO6T3+5BNg1KjAdcqHDgV69wbatQPGj0+9rJdeAs6cAVhXnWLdZuvZ05SWe/pp97PL27xuzU0EREAEREAEREAEAhGQNghEKPK/S6BHnnmGjqhDmKH4M3TwTp2At94C/vMf4Pnn059Kr17A8OFAt27Ayy9n6LT/f/APPwR27QLuvhsoUsT89ZAhxjPOe+jPPGPHPDULERABERABERABEYgWAtIG9u2UBLp9e+LpjHQIPcVrdecU5X37Ag89BIwdm/5UO3QA3nkHGDgQ6NPHjmWxhjtroPNOPO/G0zp3Bt54w9lHBztWoVmIgAiIgAiIgAiIgD0EpA3s2QvfTCTQ7dsTT2ekQ+gpXqs7pyjnHew77jC1ytOzu+4Cpk8HXn8deOKJ1C0PHDAJ4nLnNnXIly41Wd8rVQK+/dYbDDfcYO688z55o0ZmjDZtgIkTgRdfBJ56yptx1asIiIAIiIAIiIAIxCoBaQP7dlYC3b498XRGOoSe4rW68/nzjThnCTSWQkvPKHgpuh9/HKhfP3VLhpY/9xzw4IPAuHHAvHlAw4b+y7K5BaVuXeCrr4DJk4F77zW9MjEdy6vx4wMjA/wZs78zBJ4eeIp7mQiIgAiIgAiIgAiIgCEgbWDfmyCBbt+eeDojHUJP8VrdOcPDKVLPPx84ciSxlngok2b4O8PgKcopkKdONaK5Th0jor2wZs2AWbOA0aPN2DSWjOOHBHr7W7ZMW6DzI8NVVwGrV3sxM/UpAiIgAiIgAiIgAtFJQNrAvn2TQLdvTzydkQ6hp3it7vzUKZNQrXRpoEGD4GqJp1wYhTIFM8POf/jB9Pvoo2mXZXMDjL9w9ooVgTVrTI10etj92cqVQOXKJrHcn3+6MRP1IQIiIAIiIAIiIAKxQUDawL59lEC3b088nZEOoad4Y6bz48eBnDnT9rJ/9x1QowZw2WXApk3AiBEAy5lRRH/wgTcYWJed9dn79QP69zdjFC8O7NiRWI/d38hbtwIlSwLZswMnToQXOeDNytSrCIiACIiACIiACGQMAWmDjOGe3qgS6Pbtiacz0iH0FG9MdH72LHDeeUDWrMDOncBFF6Ve1m+/AeXKmSRxDJdnpvdBg8yddWZV98L4AYAfApgMjnfkaQyp5xwXLDAfC/zZ0aNAnjzmF/47Q/xlIiACIiACIiACIiACuoNu4zsggW7jrng4Jwl0D+FGQdf0djMkvVgxoFYt/xNmhvaCBc1vDIvPli11u0OHgPz5zd/T284a5K+9Bjz7rKlN7oWtW2cyxzNrPP84tXPnjPf8n3+AbduM110mAiIgAiIgAiIgAiIggW7jOyCBbuOueDgnCXQP4UZB177s6+mFolPE8556rlzAsWP+F5VU9DKEnEnaZswwWd3TyqaekXh4//yvvwDeR2cpOJkIiIAIiIAIiIAIiIAEuo3vgAS6jbvi4Zwk0D2EGwVdT5sGtGoFVK+edr3y5cuB6683Xnbe707LBgwAcuQAHn4YuOACuxfPGu379wPMPn/ttXbPVbMTAREQAREQAREQgUgRkDaIFGnn40igO2cVEy11CGNiG0NexE8/AVWqAIULG4+yP2NGdBvLkvFjweefA3nzmpJqq1aZrPHlywOffRYyEj0oAiIgAiIgAiIgAnFLQNrAvq2XQLdvTzydkQ6hp3it7zzp/XImd2OSt5T20UfA3XebGuNLltizpPnzgTvuMCXT6OVnvXWWVrvySlNqTSYCIiACIiACIiACIhAcAWmD4HhForUEeiQoWzSGDqFFm5FBU2ECOAp1eqBZRzyl+WqaN2kCsN55WrZvH7B9u0kod+edpsY476FXrerNwpYuNR8NmCBu40YzFj3pLPfG37w0X3k2hvTLREAEREAEREAERCBWCEgb2LeTEuj27YmnM9Ih9BRvVHTOEHeGun/yCdCsWeopz5sHUKRTaDMre1r25JPAyJFAr17AhAlGoNOzTQ+3F/bzz+b++MUXA7t2AePGmYR0DRsCc+emPyIzzHOurVsDAwcGN7t//zWJ5Zitfu1akxFeJgIiIAIiIAIiIAKxQEDawL5dlEC3b088nZEOoad4o6JzJoljsjjWEmdN8VBt8GDgP/8B2rcHPvzQ1BhnffQyZULtMf3n/vjD9M065hzr5ZfN/Cm6J05M/9kXXjAfG9q1A8aPD25+zFifL5+p986PBNdcE9zzai0CIiACIiACIiACthKQNrBvZyTQ7dsTT2ekQ+gp3qjo/LvvgL//Np7uokVDnzIzonfoYO6F0+tO27MHuOii0PtM70n2zeR2tLNngf79geefBx5/HHjjjfTH9IXtN24MzJ4d/PxuvBH4/nvzIeKuu4J/Xk+IgAiIgAiIgAiIgI0EpA3s2xUJdPv2xNMZ6RB6ijcmOj99GsiaFciUKf3lzJwJNG8OXH45sGGDaXvypHch4LwHztrstMOHgeeeA15/3fxz0KD05/rxx+aefKj31Vnf/b33AJaW69s3JrZZixABERABERABERABSBvY9xJIoNu3J57OSIfQU7wx0TlLrC1eDEyalL63+NtvgZtuMmL+n3+AbNmAU6e8Q8BQc45F7/nOncDo0cCUKUC3bkDHjumP+/XXwC23mI8J69cHN0fflQA+de+9wOTJwT2v1iIgAiIgAiIgAiJgKwFpA/t2RgLdvj3xdEY6hJ7ijYrOz5wBpk8HeKebCd7OOy/5tK+/3iR7Y+I1JmBLy3jfvFy5xF8vvBDYu9dbBPSEM5M6xXbOnM7HYsZ63h0vVAjYvdv5c0nD6vkUk9StWOH8ebUUAREQAREQAREQAZsJSBvYtzsS6Pbtiacz0iH0FG9UdM6s5AwVp7ebIr1UqeTTLl0a2LQJoIe8evW0l3TwIFCggPmd99kpflmr3EbbsQMoXtx8jGAIf6Dwfd8aWGaOme4ZHcDnyI3J4jJntnGVmpMIiIAIiIAIiIAIBEdA2iA4XpFoLYEeCcoWjaFDaNFmZOBUrrjC3BtfuBBgSHtS89VJX7cOYLu0jCHn9MDTc/7EE4n3wzNwWWkOzfvrV15parYvWeJ8rlzf8OEA76AzUzxD+bduBS691MZVak4iIAIiIAIiIAIiEBwBaYPgeEWitQR6JChbNIYOoUWbkYFTadQI+PRT4K23gMceS5wIvev0MlN8s9Y4a47bZIsWGYFcqxZw//2mNvnUqUD58t7MsmZNYOlSU5qNHnj+YYRBlizejKdeRUAEREAEREAERCCSBKQNIknb2VgS6M44xUwrHcKY2cqwFtK1K/Daa0CPHsCIEYldJQ1bp9eZ971tsnr1gC+/NN5sJoZjuPnGjUDZsu7PkiHtrH/OzPSMNvDqI4D7M1ePIiACIiACIiACIuCMgLSBM06RbCWB3Q92bgAAIABJREFUHknaFoylQ2jBJlgwBYpzivQWLQAmXvPZ5s3mTjqFOQV6IGMStd69gXffBZ56CnjxxUBPhPc7y7qxvNuoUab+Oc2r2us//ghUrWrC4vftc35vPbwV6mkREAEREAEREAERiBwBaYPIsXY6kgS6U1Ix0k6HMEY2MsxlMLydYe7MbP7zz4mdbdsGdOlikqDNmBF4kNatE8uOMVSeIfNeWtu2wIQJ5qPAkCFmJCa7YxK3QEaPO+/c8yMChX4gmz0beOghoFo1YM4cE1pPzz0TzHF8mQiIgAiIgAiIgAhEOwFpA/t2UALdvj3xdEY6hJ7ijZrOWQu8QgUgd27g8OHQvcNPPgmMHGmW3bMnMGyYtwjoNX/zTaBNGyPUmVX92DFnY955p4kW+L/2zgTeymn//98KpVlUGggpUZQ03CTEJeOtZO6SEPdyRYbSgEIDmQllqIzFj3KlkowpEmUKGVKacCUpGkj/1+dZ/+ec3e7s2p3Os8969n5/X6/9Oqezn72e73p/13M6n7W+67vuuy9/9X1rn9RefKXRV6xoFq6o16hhtnTp1j7J+xCAAAQgAAEIQMB/AmgD/2KEQPcvJpF6xEMYKd7YNK5V55dfdgXPJNTTPXYsuYMDB5r16+d+evPNZn37Rovg2mvdJMCRR5qpYFzNmmZLlqR3z4suMnvoIbMbbzS77rr0PpN41cqVZpUru59or772p2MQgAAEIAABCEAgzgTQBv5FD4HuX0wi9YiHMFK8sW98wwaX3p6uYB8xwuzii123ta/9ssuiRRBOCGhiQWe4a3Jh7tz07tm7t9mQIW7v/V13bfkzqmYvBskcatVyq+czZ5q1aJHefbkKAhCAAAQgAAEI+EoAbeBfZBDo/sUkUo94CCPFG/vGdea3VsS12qxU8K2ZCraF+7lHjTLr0mVrn9i+98PidtWru7RzVW/Xfvp0TNXqlYav9PjHHtvyJ5591kzp+9rzPnhw/rVHH2322mtmmehrOn3iGghAAAIQgAAEILA9BNAG20Mvms8i0KPh6m2rPITehibjjs2aZTZ1qlmjRmYnn+xuH64yq1BcuLd8S45Nn2522GHuChWVS6f42vZ0dN48sw8+cKn5qrC+Lfboo67o2wknbF3U9+jhVtm15z1xoiLcA69U+0Thvi1+cC0EIAABCEAAAhDwhQDawJdI5PuBQPcvJpF6xEMYKd5YNS6BqWrkWiUePdq5rkrsw4eb3XCDWf/+W++OziAPzwd/+22z1q23/pniuiJc7Zewf/fdLXuha1QU7sknzc4+O//ae+91Ve47dDAbN664esJ9IQABCEAAAhCAQNEQQBsUDceibAWBXpQ0Y9AWD2EMgpQhF8eONTvzTCeqJa5lZ5xh9swzbvVYe7W3ZqtXu6JrVauaXX11+nvXt9ZuFO/PmWN26KFmWh0Pj2gr6D46/10F4P74w2z+fLO9986/6pVXzI49dtv2vkfRF9qEAAQgAAEIQAACRUEAbVAUFIu2DQR60fL0vjUeQu9DlDEH33/frHlzs913N1u2zN1W4lMiVCvqWln3zVQ9/fXXXcV4FXK75BKzbt3S81JHpv30k5tM2JJpsqJNG8dFBeESC8VpQkLnoe+7r1np0undl6sgAAEIQAACEICArwTQBv5FBoHuX0wi9YiHMFK8sWp8xQqzKlWcyxKe5co5wS7h/t//5u9L96lTH39s1rhxvkc6ck2F34rSwmJyp5zizk3HIAABCEAAAhCAQLYSQBv4F1kEun8xidQjHsJI8caucQl0CXUJ3wMPdFXRv/7abNq0/OJvPnXq22/N9tkn3yPtl1fF+W21d94x+/TTglffVehO+9Ul1JW2j0EAAhCAAAQgAIFsJYA28C+yCHT/YhKpRzyEkeKNXePhirkEafv27pi0BQvMHnnEpXH7Zskp6tpHf/rp2+ZlmNpfpozbY16jxqafv+kmV+Vd+/D/9rfN254wwVWs15FrnTtv2725GgIQgAAEIAABCPhEAG3gUzScLwh0/2ISqUc8hJHijV3jKhInkXv77WZXXum/++vWmUlYh/byy27f/LaY9qLraLgZM9xZ53feuS2fdkXxVOW+a1czHd2GQQACEIAABCAAgbgSQBv4FzkEun8xCTwaPHiw9enTxy6//HK7S0t5ZrZx40YbMGCAjRgxwlasWGEtW7a0YcOGWcOGDdPuBQ9h2qhy4sLPPjP780+3Wl62bDy6vNNOrsK6bOZMsxYttt3vsBp7qlX0LbWoKveqdt+qlRP5GAQgAAEIQAACEIgrAbSBf5FDoPsXE5s1a5adfvrpVrFiRWvbtm2eQL/lllts4MCBNmrUKKtfv77dfPPN9tZbb9m8efOsQoUKafWEhzAtTDl5kVaWZYlVy30EEe6bl29ffJF/Dvu2+JpqFV3775XyroJ5qSwsVLfLLmbLl/vPa1u4cC0EIAABCEAAArlFAG3gX7wR6J7FZPXq1da0aVO7//77AwHepEmTQKBr9bxmzZp2xRVXWK9evQKv161bZ9WrVzcJ94svvjitnvAQpoUpJy/SOeEtWzrB+8kn/iLYc0+zRYucf99/b1a9euF8LWgVvWlTVzBv4sTUqfM6J10CXiL/hx/MqlUr3P35FAQgAAEIQAACEChuAmiD4o7A5vdHoHsWky5duliVKlXszjvvtCOPPDJPoM+fP9/q1q1rs2fPtoMPPjjP6/bt21vlypVttA6uTsN4CNOAlEOXaE+3dlCoWNqppzpRuv/+Zkp999W0Z15p+e3ame22W+G9TF5FV3G4SpXc+eqLF5vVqpW6bVWSV0X5N980O/zwwvvAJyEAAQhAAAIQgEBxEkAbFCf9gu+NQPcoJmPGjAlS2JXiXqZMmU0E+owZM6x169a2ZMmSYCU9tIsuusgWLlxoL6taVgGmVXa9QtNDuMcee9jKlSuDFHostwlIjGrvuYbIbbe5Y8UOPdRs+vTc4KJV9AsvNBswwEwr86rMrq8LF265/yecYDZpkllhj3nLDbr0EgIQgAAEIAAB3wkg0P2LEALdk5gsWrTImjVrZlOmTLHGjRsHXiWuoIcCfenSpVYj4Vyobt26mT47efLkAnvSv3//oLBcsiHQPQm8B25oxVx7uc86y+zpp81OPNFMR4nlgmkVXQXnVHhu4ECzfv1cAbgxY7bce1W8V+aBqrnrhUEAAhCAAAQgAIE4EkCg+xc1BLonMRk/frx17NjRSpUqlefRhg0brESJElayZMmgENy+++67zSnurKB7EmCP3TjpJHfud716Zl99ZfbPf5o9/ri/Dj/8sFm3bkVfRV0TE9p7fvfdZt27b7n/K1aYlS4dn8r3/kYTzyAAAQhAAAIQKE4CCPTipF/wvRHonsRk1apVQap6onXt2tUaNGgQFIXTUWpKbe/Ro4f17NkzuGz9+vVWrVo1isR5EsO4unH55Wb33JPv/WWXbfpv3/pVubLZypXOq7Dy/Pb6GK6iq51Zs8yaNdveFvk8BCAAAQhAAAIQ8J8AAt2/GCHQ/YtJnkeJKe76oaq163z0kSNHWr169WzQoEH2xhtvcMyaxzGMg2sS5xLpoV1/vduT7auVL2/2229FK9CnTHFF52Tr15vtuKOvvccvCEAAAhCAAAQgUHQEEOhFx7KoWkKgFxXJCNpJFug6ak37yYcPH24rVqywli1b2rBhw6xRo0Zp352HMG1UOXOh0tuV5i474giXPt65s7/d33lns7Vri1agayVe++93393sqKPS67sSWWbONLv/frOGDdP7TLpXPfSQmQrRbamSfLptcR0EIAABCEAAAhBIRQBt4N/YQKD7F5NIPeIhjBRvLBtXgTgViqtQwaWOlyjhdzdUlO3GG81OP91MR64Vl7VubTZjhisop8JyRWWqoH/YYWY6ZEE1AThnvajI0g4EIAABCEAAAskE0Ab+jQkEun8xidQjHsJI8cayce2/1rnnOttbIt130xnoErEtWphpNb247IILzB591Kx//6Kr5K70+qZNzebONVP7KoingnS33OImJVRtHoMABCAAAQhAAAJFRQBtUFQki64dBHrRsYxFSzyEsQgTTsaAwNChZkpzP/NMlx5fFDZkiFnv3ma77eaOvqtSxezww83eftusfXuzZ55BpBcFZ9qAAAQgAAEIQMARQBv4NxIQ6P7FJFKPeAgjxRvrxmvXdmeCT5tmVr9+rLuSEedffNHsH/8wa9LEbM6c7b/l/PluL7v21z/2mNk557g2VcBO91m3zqxjR5fWTxG77edNCxCAAAQgAAEIINB9HAMIdB+jEqFPCPQI4ca46ZdfNjvuONeBRYvMJNaxLRPQ/nBNZCjNfvVqs5IlC09MRepUFG7yZFekburUTWsB6OdaQVcK/Kmnmj31FCK98LT5JAQgAAEIQAACIQG0gX9jAYHuX0wi9YiHMFK8sW28Tx+zwYOd+xKb5crFtisZc1x74cuWdVkHCxaY1alT+Fs//7xZp04uff3jj83222/ztiZOdCvoEukqkPfkk2Y77FD4e/JJCEAAAhCAAAQggDbwbwwg0P2LSaQe8RBGije2jYf7qdWBv/7yv5K7L6CVkq7K9+PGmTVvXnivNCmiYnOVK5v165e6nQkTzE45xU0K9Ohhdscdhb8nn4QABCAAAQhAAAJoA//GAALdv5hE6hEPYaR4Y9u49jm3a+fcV7o1lh4B7QsvXTq9a4vqqueeMxs0yOyuu8zatCmqVmkHAhCAAAQgAIFcJIA28C/qCHT/YhKpRzyEkeKNbeMS5bfd5oqUaS80lhkCP/xgVrXqtu9fV5bD9ux5z0zvuAsEIAABCEAAAr4TQBv4FyEEun8xidQjHsJI8dI4BNImoDT1Zs3Mypc3e/xxdw59YWzDBrNSpQrzST4DAQhAAAIQgECuE0Ab+DcCEOj+xSRSj3gII8VL4zlGQBXvu3Y1+/lns9mzt9z5NWvM5s41++gj93r3XbNZs9xZ5zrzXCvp22Jq79ZbzVRg7r33Mp9qvy2+ci0EIAABCEAAAn4SQBv4FxcEun8xidQjHsJI8dJ4jhH49VezSpVcp3X8maqq66UVba2O/+c/7j0J+b32cgX4Eq1ECXfm+T//ue3gVq1yx7x9/70T6tdcs+1t8AkIQAACEIAABHKbANrAv/gj0P2LSaQe8RBGipfGc5CAjkT78svNO64j0bS6LZMwl5AvU8asceP819/+5kR2YW30aLPzzjOrUMH5sPvuhW2Jz0EAAhCAAAQgkIsE0Ab+RR2B7l9MIvWIhzBSvDSegwS++sps6lQz7QXX2ej6qle9eu7c8tCWL3fp7Fo1LyqT8JfIV6r8+eebPfJIUbVMOxCAAAQgAAEI5AIBtIF/UUag+xeTSD3iIYwUL41DIOME3nnH7NBDnfDXXnSl1mMQgAAEIAABCEAgHQJog3QoZfYaBHpmeRf73XgIiz0EOACBIidwzjlmTzxh1rq12bRpRbtKX+TO0iAEIAABCEAAAt4QQBt4E4o8RxDo/sUkUo94CCPFS+MQKBYCS5a4vexKrVe6+4EHFosb3BQCEIAABCAAgZgRQBv4FzAEun8xidQjHsJI8dI4BIqNgArSHXyw2d57Oxd++83s22/da/5893XhQrOddjLr08cVqpP99JPZihVmNWu6YnbLlm366tLF7Z2X6T1df8ABnL1ebIHmxhCAAAQgAIEiJIA2KEKYRdQUAr2IQMalGR7CuEQKPyFQeAJDhpj17p3689Onu33rsnvvNevePfW1M2eatWjh3h861KxnT1c1XsXpWrVyL+1733VXUusLHzE+CQEIQAACECgeAmiD4uG+pbsi0P2LSaQe8RBGipfGIeAFgVGjzLp2Natc2Wyffdyqul46i12V5nXuugS17LbbzPr3dyvusnLl3Gq6XjVqmPXta9aokXvvhhvM7rjDbPXqzbsp0f7pp2Z77une0ySAUu91/4YNzXbe2Qs0OAEBCEAAAhCAQAIBtIF/wwGB7l9MIvWIhzBSvDQOAS8ISEBLiEugp2u//upWwCW0t2RqV0Jc1eNnzHAvpdDL1q41K13afa/U+Mcec9+XKmXWoIFLwQ9fKmindHsMAhCAAAQgAIHiI4A2KD72qe6MQPcvJpF6xEMYKV4ah0BOEvj9d7PFi12hutAGDjSbNMls3jy3bz3RNBGgCYHy5d1PJfB3392sbNmcxEenIQABCEAAAsVGAG1QbOhT3hiB7l9MIvWIhzBSvDQOAQgkEdi40WzpUrM5c8w+/NB9XbXKbMqU/AuPOMKd4d62rdlJJ5mdeKJZnTqghAAEIAABCEAgagJog6gJb3v7CPRtZxbrT/AQxjp8OA+BrCPwxx+uKvzXX2/aNe1b79DB7NRTzZo0ybpu0yEIQAACEICAFwTQBl6EYRMnEOj+xSRSj3gII8VL4xCAQCEIaJX9s8/MXnrJbMIEt69dZ7rLtJqun4Wma5Uij0EAAhCAAAQgsP0E0Abbz7CoW0CgFzVRz9vjIfQ8QLgHAQjYzz+bTZxoNm6c2SmnmHXu7KDoHHcdD6eVdb2UGk+hOQYMBCAAAQhAoPAE0AaFZxfVJxHoUZH1tF0eQk8Dg1sQgMBWCdx9t9kVV+RfVqmS2QknOLF+3HFmFStutQkugAAEIAABCEAggQDawL/hgED3LyaResRDGCleGocABCIksH692auvmj33nNmLL5r9+GP+zbSS/sorZocfHqEDNA0BCEAAAhDIMgJoA/8CikD3LyaResRDGCleGocABDJEQHvUZ840e+EFs/HjzRYscMe5hee4jxhh9u23boW9VSuzHXbIkGPcBgIQgAAEIBAjAmgD/4KFQPcvJpF6xEMYKV4ahwAEiomAzmGvXTv/5s2bm73/vvu3UuGPPdaJ9WOOMatVq5ic5LYQgAAEIAABzwigDTwLiJkh0P2LSaQe8RBGipfGIQABTwg8/bSrCj95stny5Zs61bq12dtve+IobkAAAhCAAASKkQDaoBjhp7g1At2/mETqEQ9hpHhpHAIQ8IyAUuFnzXJV4SdNMps9252tPnasc1THtmm1vUEDt39dVeJ1LnvJktvfkXXrzH75xaxq1aJpb/s9ogUIQAACEIDApgTQBv6NCAS6fzGJ1CMewkjx0jgEIOA5gZUrzfTac0/n6Lx5TpwnmqrB/+1vbu+6zmGXgE80Fav77bf8l1botd9d19Wv767U3viOHd0EgArY7b23Wd26Zvvs415KtW/UyF0rES8/NJnw55/u9ddfZqVLm5Uta1anjtluu7lr9fPQwmvDz+mrrtcLgwAEIAABCKRDAG2QDqXMXoNAzyzvYr8bD2GxhwAHIAABjwisXWs2fbrZm2+6ryo8J/EdWq9eZkOGuH+99ppZu3ZOQBdkOgaue3f3jlbtW7RI3dH77jO79FL3/oQJZiefnPraxHaVmt+mTeprb7vN7Kqr3Puff+7Oka9SJf+1665meknwaxKicWN3bSjyNSmAQQACEIBA7hBAG/gXawS6fzGJ1CMewkjx0jgEIBBzAhLfn35qNmOG2TvvmHXtanbUUa5TEvCHHZbfQVWGL1fOrHJlt0J+0UVmZ53l3tcq+4oVThgvWWL2zTdm8+fnvy6/3KXTy954w+y881yleb1KlXIp8UqRX7PGbNAgs3POcddOmeImCVLZLbeY9ezp3tWkw5FHpr72ppvM+vVz73/yidlBB5mVKWO2yy6bvzp1Mmvf3l27erXZ66+7fofX6nut3JcoEfMBgPsQgAAEcowA2sC/gCPQ/YtJpB7xEEaKl8YhAIEsJiDBrKPcJMr12nHHzHf2jz9cir4sUdAnCvvQK6XOf/ih2c8/u5dS8cOv6ocmBTp0cFdrkqBt29T9uflms7593fsff5y/8p74Cfmgivlawe/d272js+r1fSjm9TXx+732oqp+5kcRd4QABCCQTwBt4N9oQKD7F5NIPeIhjBQvjUMAAhCIJQHtbf/1V7fqX9BLBfSUEi/TavsFF+Rfp4kApciHlo6YD6+VmFdavmzRIrNmzTYX8xL9EvVHHOGOypMpQ+Hdd92596oZEH5Vij6r+LEcgjgNAQgUEwG0QTGB38JtEej+xSRSj3gII8VL4xCAAARyjoAK4Wnfvlb2JdaV1l+jhsOwbJnZyJHu5+FLEwD6Xl+1D79HD3dtqpX5EOjVV5sNHer+9d13rnhesimrQYK9WzezwYPdu/Ltkkvc6n758mY77+xS+fXS96raH2430ETFnDkuQ0LXhtkSKvS3LSYmmrRQVgEGAQhAwGcCaAP/ooNA9y8mkXrEQxgpXhqHAAQgAIFCElDBvi+/zBfvoeCXmNf3SsE/6STXuPb0q8L+qlVu5V/74hMtcWU+lZgPr5eYHzHC/Uv30r76ZJPQlpg/+2yzBx9076pegTIL9N7vvzsfEl+qR/D44+5aCfZ993X79MOMAGUFaDJBL+3/V9uhqSCheKgGQfhV3+ulbQGnn55/7VtvOd/C7QOaeJApk0D1DPReaPp8+J7eT3yp7kFRHC+4OT1+AgEI+EwAbeBfdBDo/sUkUo94CCPFS+MQgAAEIFAMBLTyLXEssa6XRG/t2s4R7bt/+GEn8rWaHoreUPged5xbYZf98INLs9d1ak97/hNNRQMffdT9RJMDuk8q0/7+cePcuxLwWo1PZSrAN368e1diXqn6yfcOP3v88WYTJ+a3JB/kS0GmSQ2J/dBUvV+1CAqypk3NPvgg/x1tafj+e3dMoPwJsw70VZMNDzyQf61OOhDnxOvC75VRodMEQlOGgrYo6P3kCQFNdiijITQVVlS8kicS5JMmHqpXT82UdyAAgfQIoA3S45TJqxDomaTtwb14CD0IAi5AAAIQgEAsCCSeeS9BrxXwmjWd63pPQllCOkyJV1p8+JJw1vcyrbarYF9iVoBW68MMAInSCy9016o9TRKEq/ZhSn74tUkTsyuvdNdqYkLCOtw2oMmJREsW6DpiT0K6IGvVyp1eEFqtWmZLlxZ8rVb8P/oo/7369c2++qrga/fZx2U8hCZ/JdILMm2NSLynth7oNIWCTMwTMyc6dnQnFyROJCR+/+qr+fUJ7rnHxUNCP3xpe0Q4EXDjjS77QPbcc2affeb+Hb7Cooz6t+oxhMcTapuGTm3QffWzcJIi/F5jJ2y34F7xUwhkngDaIPPMt3ZHBPrWCGXZ+zyEWRZQugMBCEAAAhD4/wS0710CX6vwMgnOMOVd/5ag1XsFvbSarTT50HTcoFb+dXpB+NIkhV6aeAiP3dP1KvSn7IPw/cSvWuVWBkNo2qYwd65rM/QzfE/XSjiHpm0Ms2a5iYjQZ32vyREVBtQ9Q9ORghLoBZkEsnwK7eSTzSZMSD1sNKESCukzzzQbOzb1tZp0CTMpNMnyyCOpr128OP/UAtVeGDZs00mCMFtBXzX5E9ZZGD3aZWOEEw7qT+K13bub7b67u+/775vNnr355EA4SaDJFbGThdtDwvYSJyH0PQUXU8cym95BG/gXTQS6fzGJ1CMewkjx0jgEIAABCEAAAhkgIMGeKCBVkFBiOXFyQJMA+rcEd6dO+U5pVVwr/hL6emlSQ1/DSYA778xPv9fkgiYJNPkRvtRe+P0TT+RPggwYYPbf/7p7hvdOnODQ6rq2Gcj+9S+z4cNTg1qwIF+gq0Di7benvlYTHuHWgBtuMFMGQCqbOdOsRQv3riZWrrkm9bWvv26miQ/ZqFFmffrkF1lURkf4ksC//nqz5s3dtbrHU09tOomQmK2gbRp167prFy50JzJoQiCsg6DvldGgCYn998/fyqDtDsoWSZygCDMfMjDksvYWaAP/QotA9y8mkXrEQxgpXhqHAAQgAAEIQAACWyWgyQRtcQgnCRK/StQrvT9MnZfg1ZaCcPJB74fX63sJ52rV3C0ljJ95Jn+SIDkD4oUXzBo2dNfeeqv7bOIxiYmOqwBhmzbuJ5q0CLdWFNS5yZPN2rVz72hSQ8UXU5kmSMK6BPK3c+fU1yp74Nxz3fvKelD2Q7KF2QHy8fzz3bsS/dp+oIkBiXi9Ercd6LqwLRWSVDZD+H6YnRD++5BDzA480LWrmKntxHYTt0loG0lYaDKsjVHQxI78CU+72OpgifgCtEHEgAvRPAK9ENDi/BEewjhHD98hAAEIQAACEIBA0RKQgJTgT8wS0Pc6cSA8YvCnn8yUoh+eJpB4woAmAVRsUXULZMo4UNFD/VzZCckTCj175q+2T51qNnCg28agV+hD+DlNImirg0xp/qedlnpCQRMDEuUyTRhopT6V3X23mbYGyKZNcycypLJBg8x693bvavuABHsq04SH+iNT7YJwMiT5ek3ATJ9etHEsbGtog8KSi+5zCPTo2HrZMg+hl2HBKQhAAAIQgAAEIACBNAhIxIeZAZpYCL+vWjW/joJOK1DWgYR++EqspSCBHK6Kf/212f33u0mKgtrV6Q2aGJCpNoOORExsN9wioc/36mXWt6+7dt48swYNNu1QWGBQRRm1hcAHQxv4EIVNfUCg+xeTSD3iIYwUL41DAAIQgAAEIAABCEAgyAiQaA+L7yUfK+gLIrSBL5HI9wOB7l9MIvWIhzBSvDQOAQhAAAIQgAAEIACB2BBAG/gXKgS6fzGJ1CMewkjx0jgEIAABCEAAAhCAAARiQwBt4F+oEOj+xSRSj3gII8VL4xCAAAQgAAEIQAACEIgNAbSBf6FCoPsXk0g94iGMFC+NQwACEIAABCAAAQhAIDYE0Ab+hQqB7l9MIvWIhzBSvDQOAQhAAAIQgAAEIACB2BBAG/gXKgS6fzGJ1CMewkjx0jgEIAABCEAAAhCAAARiQwBt4F+oEOj+xSRSj3gII8VL4xCAAAQgAAEIQAACEIgNAbSBf6FCoPsXk0g94iGMFC+NQwACEIAABCAAAQhAIDYE0Ab+hQqB7l9MIvWIhzBSvDQOAQhAAAIQgAAEIACB2BCqNALNAAAehUlEQVRAG/gXKgS6fzGJ1CMewkjx0jgEIAABCEAAAhCAAARiQwBt4F+oEOj+xSRSj3gII8VL4xCAAAQgAAEIQAACEIgNAbSBf6FCoPsXk0g94iGMFC+NQwACEIAABCAAAQhAIDYE0Ab+hQqB7l9MIvWIhzBSvDQOAQhAAAIQgAAEIACB2BBAG/gXKgS6fzGJ1CMewkjx0jgEIAABCEAAAhCAAARiQwBt4F+oEOj+xSRSj3gII8VL4xCAAAQgAAEIQAACEIgNAbSBf6FCoPsXk0g94iGMFC+NQwACEIAABCAAAQhAIDYE0Ab+hQqB7l9MIvWIhzBSvDQOAQhAAAIQgAAEIACB2BBAG/gXKgS6fzGJ1CMewkjx0jgEIAABCEAAAhCAAARiQwBt4F+oEOgexeSBBx4wvRYsWBB41bBhQ7v++uvt+OOPD/593nnn2ejRozfxuGXLlvbuu++m3QsewrRRcSEEIAABCEAAAhCAAASymgDawL/wItA9ismLL75opUqVsn333TfwSmJ86NChNmfOnECsS6D/8MMPNnLkyDyvd9ppJ6tSpUraveAhTBsVF0IAAhCAAAQgAAEIQCCrCaAN/AsvAt2/mGzikcS3RPoFF1wQCPRffvnFxo8fX2iveQgLjY4PQgACEIAABCAAAQhAIKsIoA38CycC3b+YBB5t2LDBnn32WevSpUuwgn7AAQcEAl3iXKvmlStXtiOOOMIGDhxo1apVS7sXPIRpo+JCCEAAAhCAAAQgAAEIZDUBtIF/4UWgexaTTz75xFq1amVr16618uXL21NPPWUnnHBC4OXYsWODn9WpU8e+/fZbu+666+zPP/+0Dz74wEqXLl1gT9atW2d6haaHcI899rCVK1daxYoVPes97kAAAhCAAAQgAAEIQAACmSKAQM8U6fTvg0BPn1VGrly/fr199913QSr7c889Zw8//LC9+eabwQp6si1btiwQ62PGjLFTTjmlQP/69+9vAwYM2Ow9BHpGwslNIAABCEAAAhCAAAQg4C0BBLp/oUGg+xeTTTz6+9//bnXr1rXhw4cX6Gm9evXswgsvtF69ehX4PivongcY9yAAAQhAAAIQgAAEIFBMBBDoxQR+C7dFoPsXk008Ovroo4OU9FGjRm3m6fLly61WrVo2YsQIO/fcc9PqiVbOtX990aJFpLinRYyLIAABCEAAAhCAAAQgkJ0Ewu2vyt6tVKlSdnYyZr1CoHsUsD59+gRnnkuQr1q1KkhdHzJkiE2ePDnYl6509U6dOlmNGjWCs9J1vdLhP//8c6tQoUJaPVm8eHHQPgYBCEAAAhCAAAQgAAEIQEAEtHhXu3ZtYHhAAIHuQRBCF3SU2quvvmraW64ZrIMOOihIXT/mmGNszZo11qFDh6Ciu2a4JNLbtm1rN9100zYJ7r/++suWLl0aCPoSJUpE3vtwVo4V+8hRZ9UNGDdZFc6Mdoaxk1HcWXMzxk3WhDKjHWHcZBR3Vt3Mp7GzcePGYGGwZs2aVrJkyaziHNfOINDjGrmY+M2+lpgEyjM3GTeeBSRG7jB2YhQsj1xl3HgUjBi5wriJUbA8c5Wx41lAPHMHge5ZQLLNHX4BZVtEM9Mfxk1mOGfjXRg72RjV6PvEuImecTbegXGTjVHNTJ8YO5nhHNe7INDjGrmY+M0voJgEyjM3GTeeBSRG7jB2YhQsj1xl3HgUjBi5wriJUbA8c5Wx41lAPHMHge5ZQLLNHR3zNnjwYOvdu7eVLl0627pHfyIiwLiJCGwONMvYyYEgR9BFxk0EUHOgScZNDgQ5oi4ydiICmyXNItCzJJB0AwIQgAAEIAABCEAAAhCAAATiTQCBHu/44T0EIAABCEAAAhCAAAQgAAEIZAkBBHqWBJJuQAACEIAABCAAAQhAAAIQgEC8CSDQ4x0/vIcABCAAAQhAAAIQgAAEIACBLCGAQM+SQNINCEAAAhCAAAQgAAEIQAACEIg3AQR6vOPnvff333+/DR061JYtW2YNGza0u+66y9q0aeO93ziYGQKq8P/888/bF198YTvvvLMdeuihdsstt9h+++2X58DGjRttwIABNmLECFuxYoW1bNnShg0bFownDAIioHHUp08fu/zyy4PfMTLGDWOjIAJLliyxXr162aRJk2zNmjVWv359e+SRR+yQQw5h3DBkUhL4888/rX///vbkk0/a999/bzVq1LDzzjvP+vXrZyVLlmTsMHYCAm+99VbwN+8HH3wQ/N07btw469Chwzb9PaPq7ldffbU9/fTTwe+oo48+2vS3dO3ataGcQwQQ6DkU7Ex3dezYsXbOOecEv1hat25tw4cPt4cfftg+++wz23PPPTPtDvfzkMBxxx1nZ555pjVv3tz0B1Dfvn3tk08+CcZIuXLlAo8l2AcOHGijRo0K/pi++eabg/8E582bZxUqVPCwV7iUSQKzZs2y008/3SpWrGht27bNE+iMm0xGIR730gTfwQcfHIyTf//731atWjX75ptvbK+99rK6devy+yYeYSwWL/V/0J133mmjR48OJofff/9969q1a/D/kSYG+b+qWMLi3U018Td9+nRr2rSpderUaTOBns7/S/rd9OKLLwZ/8+y666521VVX2c8//xyI/lKlSnnXZxyKhgACPRqutGoWrHTql9QDDzyQx2P//fcPZhO14oVBIJnA//73v+CP5jfffNMOP/zwYBW0Zs2adsUVVwSrXjLNLlevXj0Q7hdffDEQc5jA6tWrg98xmgTUH8pNmjQJBDrjJocHxRa6fu211wZ/PE+bNq3Aqxg3jJtUBE466aTg/x1lW4QmAVa2bFl7/PHH+Z3D0NmMQIkSJTYR6On8flm5cqVVrVo1GFNnnHFG0ObSpUttjz32sIkTJ1q7du0gnSMEEOg5EuhMd3P9+vXBf1zPPvusdezYMe/2mmn+8MMPAwGGQSCZwNdff2316tULVtEbNWpk8+fPD1a2Zs+eHax8hda+fXurXLlysJqB5S6BLl26WJUqVYKVrSOPPDJPoDNucndMbKnnBxxwQPAH7uLFi4P/g2rVqmWXXHKJdevWLfgY44Zxk4rAkCFD7MEHH7QpU6YEmVwfffSRHXvsscGE4FlnncXYYehsVaCn8/vltddeC1LatWK+yy675LXZuHHjYHFL2/2w3CCAQM+NOGe8l5rx0x8/Wq3QvuLQBg0aFIgqpSdjEEgkoNllCW+loYYrXDNmzAi2R2jfqFbSQ7vooots4cKF9vLLLwMxRwmMGTMm2PqgFPcyZcpsItAZNzk6KLbSbY0T2ZVXXmmnnXaavffee0F2jrZfnXvuuca4YdykIqD/n1TnQplbSjPesGFD8Pund+/ewUcYO4ydZALJK+jpjJGnnnoq2DqhTMFE02TQ3nvvHfyuwnKDAAI9N+Kc8V6GAl2/kFq1apV3f/2HptQdFQXDIJBI4NJLL7WXXnrJ3n777bxiKOF/aBpPKsoTmla8Fi1aZJMnTwZiDhJQ7Js1axasZmllQZa4gs64ycFBkUaXd9ppp2DcaHyE1r1792CS55133skTWfy+SQNmjl2iCcFrrrkmKACmPejKBNTkzh133GHK5OF3To4NiDS6m0qgb+n3SyqBfswxxwTZhMriwHKDAAI9N+Kc8V6S4p5x5LG+4WWXXWbjx48Pir9plji0dFLCYt1xnC8UAY0VbZ1JLJijFS39QaSKysrQ2XfffdkaUSi62fuhOnXqmP7QVbHS0FQjRfULlKXD75vsjf329kx7gFXDQBPJoWncPPHEE8GCA2Nnewln3+eTBXo6Y4QU9+wbB4XtEQK9sOT43FYJqEicjq5RAafQtAdQacwUidsqvpy4QGmDEuc6iuSNN94I9p8nWlhUpUePHtazZ8/gLU3+qJAcReJyYogU2MlVq1YFWxwSTWmBDRo0CIoJaoVLWyIYN7k7Rgrq+dlnnx1k3iQWidMYmTlzZrACyu8bxksqAqqmLUGuCtuh6e+YkSNH2pdffsnYYehsRiBVkbgt/b8UFonTxI9OJ5HpuDYdsUaRuNwaZAj03Ip3RnsbHrOmlByluesc64ceesjmzp1rWsnAIKACTUrpeuGFFzY5+7xSpUrBuegyCfHwDyEJeNUxkJjnmDXGTyKBxBR3xg1joyACSmVXTRQVWtIfv9qDru0y+r+pc+fO/L5h2KQkoDPPp06dGuwB1gTgnDlzTLVQzj///OD/KH7nMHhEQCeLqNitTIVttQVCxzqqmKmOF07n7xlNAk2YMCE4Zk2f05noy5cv55i1HBtiCPQcC3imu6vV81tvvTWYAVRVblVb1vFZGAREQDPMBZlWJfQHkUyrWvqDWn8YqYCcMjOGDRsWjCcMAiGBZIHOuGFsFERAf/iqsNdXX30VbKdRwbiwiju/bxgzqQgoa+e6664Lsr1+/PHHIENH1duvv/56U20Dxg5jRwS0eCBBnmyqUyDBnc7/S2vXrg3qHWjxYs2aNUFVd/0trW0WWO4QQKDnTqzpKQQgAAEIQAACEIAABCAAAQh4TACB7nFwcA0CEIAABCAAAQhAAAIQgAAEcocAAj13Yk1PIQABCEAAAhCAAAQgAAEIQMBjAgh0j4ODaxCAAAQgAAEIQAACEIAABCCQOwQQ6LkTa3oKAQhAAAIQgAAEIAABCEAAAh4TQKB7HBxcgwAEIAABCEAAAhCAAAQgAIHcIYBAz51Y01MIQAACEIAABCAAAQhAAAIQ8JgAAt3j4OAaBCAAAQhAAAIQgAAEIAABCOQOAQR67sSankIAAhDIagILFiywvffe2+bMmWNNmjTxoq9ffPGFnXfeefbhhx9agwYNgq/JtnHjRrv44ovt//7v/2zFihXF6r+PDAsbyDfeeMPatm0bMK1cuXJhm0nrc/3797fx48cXGN+0GuAiCEAAAhCAwP8ngEBnKEAAAhCAQJEQkBAdPXq0DR482K699tq8NiVcOnbsaBKiUZqP4vKMM86wn376yR599FErX7687brrrpshmDRpkrVv394kKPfZZx/bbbfdbIcddogSVdC24vXLL78EwjK0DRs22P/+97+M+RBlJ6MS6CVKlLBx48ZZhw4d8txfvXq1rVu3rsD4RtlH2oYABCAAgewjgEDPvpjSIwhAAALFQkCCb+zYsVamTBmbP3++7bLLLoEfcRfo69evt5122qlQTJs1a2YnnniiDRgwIOXn77vvPhs6dKgtXLiwUPco7IcKEuiFbcvHz2VSoPvYf3yCAAQgAIF4EkCgxzNueA0BCEDAOwISfMuXL7evv/7aTj75ZLv11lsLFOgFpQPfddddppdWwWWheGzRooXdfffdwepkjx49rG/fvta7d2975JFHrGzZsnbjjTfa+eefH3wmXEF/+umn7Z577rHZs2db3bp1bdiwYXbkkUfm8frss8/s6quvtrfeesvKlStnxx57rN15553BqrFM1zZq1CgQ5Y899pg1bNjQ3nzzzc14//XXX3bzzTfbiBEjglXn/fff34YMGWLHHXdccK1WWhPthhtuMPU90cKsg/BnderUCfqx11572RVXXBG8QlPavlZtwzbU/kMPPWQvvfSSvfzyy1arVi27/fbb7R//+EfeZ+bOnWs9e/a0adOmBRkMamPUqFH2+OOPbzZp8Prrrwf3Td4moL5fc8019tFHH1mVKlWsS5cuQb/DVX7xOuigg4KJmYcffjjg9q9//WuzviYDHDlyZDBGvv322+C+3bt3t0suuSS4rFWrVnbEEUcEPEMT45o1a9qUKVOC1PUnnngiGDPz5s0L4njUUUcF/65WrVrwkWSBns64mzVrlvXp0yfYZvDHH38EvDQ2mjZtGrQpPxMnUsJ4Jbe9tbERjtXnnnvO7r33Xps5c6bVq1fPHnzwwaDvMt3nP//5j7399tumSSLdWxM5J5xwgnfPPg5BAAIQgEDREUCgFx1LWoIABCCQ0wRCUS0Bd/bZZ9tXX31ltWvX3mwFPR2hpLaef/55O/fcc+2yyy6z6dOn2wUXXGDt2rWzww8/3E477bRgtV4C/ZtvvrE99tgjT6DrnhJqBxxwgN1xxx3BdRKBSi9ftmxZICa7desWtL1mzRrr1auX/fnnn/baa68F8ZPg/OCDD+zf//53cE8JW+0fTzYJN/Vl+PDhdvDBBwdp7PqZRLHE1vfff29///vfA8GuCQGluOuVaCtXrgwmEyTyJQ5LlSplVatWTVugq68Suc2bNw+EnnyQsJOQXrJkSdBX9UeTGhUrVgw4HnrooYGYV99+/fVXk1CW6TNLly7dRKCrjfr16wcTJoqD9tSL3aWXXponwNW+BO2VV14ZxP2dd94JrtekwTHHHFPgM6GJBU1YKHtA7PR5tat4afyEWQUSsuFEh34mwf7dd99ZyZIlg77WqFHD9ttvP/vxxx+DCRxlbUycOLHQAl1jQAwOOeSQoA1NeEyYMCEYyxUqVAgmYjQBIGaKaxiv5DG9tbERCnSNq9tuuy0YL5p80hjQBJcmP0466aRAmMsHTUBoYkkx1PjHIAABCEAgewkg0LM3tvQMAhCAQEYJJKZMaxVQAlkr3ckp7ukKdK2AKlVeYkwmMSNxpJVvmfZLV6pUKVi1PfPMM/MEukScRLdMwlsrwhKXWkm+/vrrg9VKicfQFi9eHAh8rcRKjEpwSjhLNG7JJHIlVLXiGppW/CWWtWovS171Lqi95OwBXZPuCnq/fv3spptuCpr97bffAhEpgSrxKL/GjBkT9GvHHXfc7NYFpbgn7+OXaNQq7+eff54nlO+///6ArxgpNuKlWGiVPpGDVrQTV8ATHdhzzz3tlltusbPOOivvx1qVl+8zZswIhLBWyyWY27RpE1yjiYXDDjssLzMjuUMSt+K/atWqYCKkMCvoyW2qXxL9Tz31VCCYZQXtQU8e01sbGyFnjV1NlMgkwJWtIdYa65pc6dSpUzCRgUEAAhCAQO4QQKDnTqzpKQQgAIFICSQKPoloCbSPP/7Yvvzyy02KxKUr0CXSlL4dmlKelXoeil/9XCnGV111VZAeHYoepWQnrjKqQJ2qeGvVU/vBX3nllc32lEvcShwef/zxgeDUiqZWeVOZVp41OSARKL9C0yquUsHD1fioBfozzzwTZBOEJp+0kq7sAKVCazVehfsKsnQE+imnnBL0M1xlVzvqn/qllXoJbfGSsEyMi4reKWNBq9zJFq5C77zzznmTL7pGkym61w8//BB8RP6rfaV9KwNCBfRUBb9x48bB+5pA0VjSz37++WdTWvnvv/8eZDBocqgwAl0r8ZrEUfzkhwS62tTqfZh+vzWBns7YCMfqe++9F0zoyFRtXlkM4fiVeFcWhyYdlIkhsS7RjkEAAhCAQHYTQKBnd3zpHQQgAIGMEUgWfBLDWrnVzxOruCstXauyEnqhaW+tBF7yHvTECuMSghKGWnEOLXGleUsCXaugEosS4Nq7rtXbZFO6tFKJC7pP8rWhCEueDNCe8U8++cReffXV4COFFegSo1r1l+APTSJYYjxxD3pyNXFNRIiPmEvQaSV5ewS64hayC/2QIFZaulLNlXlQEC/tlZcv2u+ebBK+u+++e7CHvGXLlpu8rZRxZTzInnzySbv88suDbQlK41dtgU8//TR4TxMqir3qB2i/uyYi5I+2QITH7CUL9HTGnSYFNIGgon6a/CldunSwJ1yZBGE9gHQF+pbGRkEnDqiivlirFkBYM2HRokXBJJX23SvVXunuGhcYBCAAAQhkLwEEevbGlp5BAAIQyCiBZIEuoSqBqhVuCfDwmLUHHnggEJnaox3uL+7cuXOwP7ooBLrEt9LZZVqVldhVsS39LEzZltBLdZRZOgJdbadKY9aKp1Zct0egS7hqZT4stKcJAYla9SFdgS6RKXGeKsX9oosuCsTviy++mDdO0k1x1zF6EpRhinvyxMmWBLpupr3zOvv9uuuuSzlGJcKrV68eCHPd75xzzsk7vk81AlQhP5wkUCMS/LomlUBPZ9xpi4BS+NWOTAJZq/jaUx4KdBXBk0+aAAkt3RT3cGykK9AT4aiOgMS6slIwCEAAAhDIXgII9OyNLT2DAAQgkFECBaVMK9X62WeftbVr1+YJdO2x1Wqwzks/9dRTbfLkyYFQUwGsohDoElRaRVZVdQkr7R9WirSqtKsAmMSkxK8qk+tnKsqlvdpKadcKbroCXffQ/mAVeFObSgNXkbOwSNz2CHSJMa0+K4Vdq6riM3Xq1GCyI12Bror6KqCmvqo9pY+/++67Qcq0fj5o0KCgwJ1WZ5WOrvdVFC6xintYJK5r167BJIfE/oUXXrhZkbhtFehK39a2BI0BZTWoSv/7778fpHmr2FxomrgRT4lSjQ3FVqZVbol8rbBrBV0TLoqntlOkEujpjDtlBmg1XicHaFJEbcovsQoFuuoUKOVcqfBaYVd8kgX61sZGOgJd9xMb3U9clO6urAEVPcQgAAEIQCB7CSDQsze29AwCEIBARgkUJNC1T1liUAIsXEGXU9pXLNGjvcNaidQ1ErpFIdAlyCWwJNR0zJpWs7UfPjRV5FaRM6USyy+lMquomsS1VvTTFeiJR2lp77L2PSces7Y9Al3iUFXNNXkh4axCcJpsSD5mbUsp7rq/hK1Epo7q0uRDeMyasgokciWAVXV99erVAY/CHrO2rQJdvilOyqxQcTRtLTjwwAMDEay0+tBUF0BbJVRTIPmoO61iqxCesgB0DJomIXTEXCqBns6402eVWaDsD00GaIyqAn/ikXfKONAkgsaqsij0dUvHrBU0NtIR6EplnzRpkqmIoSavNEY1BjSZgkEAAhCAQPYSQKBnb2zpGQQgAAEIQAACEIAABCAAAQjEiAACPUbBwlUIQAACEIAABCAAAQhAAAIQyF4CCPTsjS09gwAEIAABCEAAAhCAAAQgAIEYEUCgxyhYuAoBCEAAAhCAAAQgAAEIQAAC2UsAgZ69saVnEIAABCAAAQhAAAIQgAAEIBAjAgj0GAULVyEAAQhAAAIQgAAEIAABCEAgewkg0LM3tvQMAhCAAAQgAAEIQAACEIAABGJEAIEeo2DhKgQgAAEIQAACEIAABCAAAQhkLwEEevbGlp5BAAIQgAAEIAABCEAAAhCAQIwIINBjFCxchQAEIAABCEAAAhCAAAQgAIHsJYBAz97Y0jMIQAACEIAABCAAAQhAAAIQiBEBBHqMgoWrEIAABCAAAQhAAAIQgAAEIJC9BBDo2RtbegYBCEAAAhCAAAQgAAEIQAACMSKAQI9RsHAVAhCAAAQgAAEIQAACEIAABLKXAAI9e2NLzyAAAQhAAAIQgAAEIAABCEAgRgQQ6DEKFq5CAAIQgAAEIAABCEAAAhCAQPYSQKBnb2zpGQQgAAEIQAACEIAABCAAAQjEiAACPUbBwlUIQAACEIAABCAAAQhAAAIQyF4CCPTsjS09gwAEIAABCEAAAhCAAAQgAIEYEUCgxyhYuAoBCEAAAhCAAAQgAAEIQAAC2UsAgZ69saVnEIAABCAAAQhAAAIQgAAEIBAjAgj0GAULVyEAAQhAAAIQgAAEIAABCEAgewkg0LM3tvQMAhCAAAQgAAEIQAACEIAABGJEAIEeo2DhKgQgAAEIQAACEIAABCAAAQhkLwEEevbGlp5BAAIQgAAEIAABCEAAAhCAQIwIINBjFCxchQAEIAABCEAAAhCAAAQgAIHsJYBAz97Y0jMIQAACEIAABCAAAQhAAAIQiBEBBHqMgoWrEIAABCAAAQhAAAIQgAAEIJC9BBDo2RtbegYBCEAAAhCAAAQgAAEIQAACMSKAQI9RsHAVAhCAAAQgAAEIQAACEIAABLKXAAI9e2NLzyAAAQhAAAIQgAAEIAABCEAgRgQQ6DEKFq5CAAIQgAAEIAABCEAAAhCAQPYSQKBnb2zpGQQgAAEIQAACEIAABCAAAQjEiAACPUbBwlUIQAACEIAABCAAAQhAAAIQyF4CCPTsjS09gwAEIAABCEAAAhCAAAQgAIEYEUCgxyhYuAoBCEAAAhCAAAQgAAEIQAAC2UsAgZ69saVnEIAABCAAAQhAAAIQgAAEIBAjAgj0GAULVyEAAQhAAAIQgAAEIAABCEAgewkg0LM3tvQMAhCAAAQgAAEIQAACEIAABGJEAIEeo2DhKgQgAAEIQAACEIAABCAAAQhkLwEEevbGlp5BAAIQgAAEIAABCEAAAhCAQIwIINBjFCxchQAEIAABCEAAAhCAAAQgAIHsJYBAz97Y0jMIQAACEIAABCAAAQhAAAIQiBEBBHqMgoWrEIAABCAAAQhAAAIQgAAEIJC9BBDo2RtbegYBCEAAAhCAAAQgAAEIQAACMSKAQI9RsHAVAhCAAAQgAAEIQAACEIAABLKXAAI9e2NLzyAAAQhAAAIQgAAEIAABCEAgRgQQ6DEKFq5CAAIQgAAEIAABCEAAAhCAQPYS+H+avjTXKkLTMgAAAABJRU5ErkJggg==\" width=\"1000\">"
+            ],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>solutions_bitstrings</th>\n",
+              "      <th>bitstrings_energies</th>\n",
+              "      <th>probabilities</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>1100</td>\n",
+              "      <td>27.0</td>\n",
+              "      <td>0.119885</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>1001</td>\n",
+              "      <td>27.0</td>\n",
+              "      <td>0.119885</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>1010</td>\n",
+              "      <td>32.0</td>\n",
+              "      <td>0.113245</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>0101</td>\n",
+              "      <td>32.0</td>\n",
+              "      <td>0.112614</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>0110</td>\n",
+              "      <td>35.0</td>\n",
+              "      <td>0.111264</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "  solutions_bitstrings  bitstrings_energies  probabilities\n",
+              "0                 1100                 27.0       0.119885\n",
+              "1                 1001                 27.0       0.119885\n",
+              "2                 1010                 32.0       0.113245\n",
+              "3                 0101                 32.0       0.112614\n",
+              "4                 0110                 35.0       0.111264"
+            ]
+          },
+          "execution_count": 193,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Initialize the QAOA object\n",
+        "qaoa = QAOA()\n",
+        "\n",
+        "# Set the parameters to use the QAOA algorithm\n",
+        "qaoa.set_backend_properties(n_shots=1024, seed_simulator=1)\n",
+        "# p=1, a custom type and range from 0 to pi\n",
+        "qaoa.set_circuit_properties(p=2, init_type=\"custom\", variational_params_dict={\"betas\":2*[0.01*np.pi],\"gammas\":2*[0.01*np.pi]})\n",
+        "#Indicate the ising e ncoding model from docplex\n",
+        "qaoa.compile(ising_encoding)\n",
+        "# Run the QAOA algorithm\n",
+        "qaoa.optimize()\n",
+        "\n",
+        "results_qaoa = qaoa.result\n",
+        "results_qaoa.plot_cost(label='Original')\n",
+        "pd.DataFrame(qaoa.result.lowest_cost_bitstrings(5))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "wURSjn_fRRQ0",
+        "outputId": "fcba395d-17f0-4791-8a70-2fc6c6187372"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "(27.0, ['1100', '1001'])"
+            ]
+          },
+          "execution_count": 194,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# To find the correct answer using ground_state_hamiltonian\n",
+        "# and the parameter is a cost_hamiltonian\n",
+        "correct_solution = ground_state_hamiltonian(qaoa.cost_hamil)\n",
+        "correct_solution"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "OcTebnHiRRQ0"
+      },
+      "source": [
+        "Validate your answer using docplex, you can see how to check the classical solution using the following tutorial [here](https://github.com/entropicalabs/openqaoa/blob/main/examples/community_tutorials/02_docplex_example.ipynb)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "a9rEXiPfRRQ1",
+        "outputId": "60896c68-54bf-4646-c08f-bf110e63b0f6"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "objective: 27.000\n",
+            "status: OPTIMAL_SOLUTION(2)\n",
+            "  q_0=1\n",
+            "  q_1=1\n",
+            "  q_2=0\n",
+            "  q_3=0\n"
+          ]
+        }
+      ],
+      "source": [
+        "## docplex solution\n",
+        "sol = mdl_qubo_docplex.solve()\n",
+        "mdl_qubo_docplex.print_solution(print_zeros=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "OZwGgvpARRQ1"
+      },
+      "source": [
+        "# Part 2: Improve the QAOA circuit\n",
+        "\n",
+        "Perform the same process as above now with the variant of using different backends, p values, and different optimizers until you find the one that can provide the correct answers with the least number of iterations, quantum circuit depth."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "eNlmpecRRRQ2",
+        "outputId": "f229cf8e-e563-460e-be25-26be76bec60f"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Optimized cost with AnnealingParams: 36.69610068004\n"
+          ]
+        },
+        {
+          "data": {
+            "application/javascript": [
+              "/* Put everything inside the global mpl namespace */\n",
+              "/* global mpl */\n",
+              "window.mpl = {};\n",
+              "\n",
+              "mpl.get_websocket_type = function () {\n",
+              "    if (typeof WebSocket !== 'undefined') {\n",
+              "        return WebSocket;\n",
+              "    } else if (typeof MozWebSocket !== 'undefined') {\n",
+              "        return MozWebSocket;\n",
+              "    } else {\n",
+              "        alert(\n",
+              "            'Your browser does not have WebSocket support. ' +\n",
+              "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+              "                'Firefox 4 and 5 are also supported but you ' +\n",
+              "                'have to enable WebSockets in about:config.'\n",
+              "        );\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
+              "    this.id = figure_id;\n",
+              "\n",
+              "    this.ws = websocket;\n",
+              "\n",
+              "    this.supports_binary = this.ws.binaryType !== undefined;\n",
+              "\n",
+              "    if (!this.supports_binary) {\n",
+              "        var warnings = document.getElementById('mpl-warnings');\n",
+              "        if (warnings) {\n",
+              "            warnings.style.display = 'block';\n",
+              "            warnings.textContent =\n",
+              "                'This browser does not support binary websocket messages. ' +\n",
+              "                'Performance may be slow.';\n",
+              "        }\n",
+              "    }\n",
+              "\n",
+              "    this.imageObj = new Image();\n",
+              "\n",
+              "    this.context = undefined;\n",
+              "    this.message = undefined;\n",
+              "    this.canvas = undefined;\n",
+              "    this.rubberband_canvas = undefined;\n",
+              "    this.rubberband_context = undefined;\n",
+              "    this.format_dropdown = undefined;\n",
+              "\n",
+              "    this.image_mode = 'full';\n",
+              "\n",
+              "    this.root = document.createElement('div');\n",
+              "    this.root.setAttribute('style', 'display: inline-block');\n",
+              "    this._root_extra_style(this.root);\n",
+              "\n",
+              "    parent_element.appendChild(this.root);\n",
+              "\n",
+              "    this._init_header(this);\n",
+              "    this._init_canvas(this);\n",
+              "    this._init_toolbar(this);\n",
+              "\n",
+              "    var fig = this;\n",
+              "\n",
+              "    this.waiting = false;\n",
+              "\n",
+              "    this.ws.onopen = function () {\n",
+              "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
+              "        fig.send_message('send_image_mode', {});\n",
+              "        if (fig.ratio !== 1) {\n",
+              "            fig.send_message('set_device_pixel_ratio', {\n",
+              "                device_pixel_ratio: fig.ratio,\n",
+              "            });\n",
+              "        }\n",
+              "        fig.send_message('refresh', {});\n",
+              "    };\n",
+              "\n",
+              "    this.imageObj.onload = function () {\n",
+              "        if (fig.image_mode === 'full') {\n",
+              "            // Full images could contain transparency (where diff images\n",
+              "            // almost always do), so we need to clear the canvas so that\n",
+              "            // there is no ghosting.\n",
+              "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+              "        }\n",
+              "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
+              "    };\n",
+              "\n",
+              "    this.imageObj.onunload = function () {\n",
+              "        fig.ws.close();\n",
+              "    };\n",
+              "\n",
+              "    this.ws.onmessage = this._make_on_message_function(this);\n",
+              "\n",
+              "    this.ondownload = ondownload;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_header = function () {\n",
+              "    var titlebar = document.createElement('div');\n",
+              "    titlebar.classList =\n",
+              "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
+              "    var titletext = document.createElement('div');\n",
+              "    titletext.classList = 'ui-dialog-title';\n",
+              "    titletext.setAttribute(\n",
+              "        'style',\n",
+              "        'width: 100%; text-align: center; padding: 3px;'\n",
+              "    );\n",
+              "    titlebar.appendChild(titletext);\n",
+              "    this.root.appendChild(titlebar);\n",
+              "    this.header = titletext;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
+              "\n",
+              "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
+              "\n",
+              "mpl.figure.prototype._init_canvas = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
+              "    canvas_div.setAttribute(\n",
+              "        'style',\n",
+              "        'border: 1px solid #ddd;' +\n",
+              "            'box-sizing: content-box;' +\n",
+              "            'clear: both;' +\n",
+              "            'min-height: 1px;' +\n",
+              "            'min-width: 1px;' +\n",
+              "            'outline: 0;' +\n",
+              "            'overflow: hidden;' +\n",
+              "            'position: relative;' +\n",
+              "            'resize: both;'\n",
+              "    );\n",
+              "\n",
+              "    function on_keyboard_event_closure(name) {\n",
+              "        return function (event) {\n",
+              "            return fig.key_event(event, name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    canvas_div.addEventListener(\n",
+              "        'keydown',\n",
+              "        on_keyboard_event_closure('key_press')\n",
+              "    );\n",
+              "    canvas_div.addEventListener(\n",
+              "        'keyup',\n",
+              "        on_keyboard_event_closure('key_release')\n",
+              "    );\n",
+              "\n",
+              "    this._canvas_extra_style(canvas_div);\n",
+              "    this.root.appendChild(canvas_div);\n",
+              "\n",
+              "    var canvas = (this.canvas = document.createElement('canvas'));\n",
+              "    canvas.classList.add('mpl-canvas');\n",
+              "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
+              "\n",
+              "    this.context = canvas.getContext('2d');\n",
+              "\n",
+              "    var backingStore =\n",
+              "        this.context.backingStorePixelRatio ||\n",
+              "        this.context.webkitBackingStorePixelRatio ||\n",
+              "        this.context.mozBackingStorePixelRatio ||\n",
+              "        this.context.msBackingStorePixelRatio ||\n",
+              "        this.context.oBackingStorePixelRatio ||\n",
+              "        this.context.backingStorePixelRatio ||\n",
+              "        1;\n",
+              "\n",
+              "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+              "\n",
+              "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
+              "        'canvas'\n",
+              "    ));\n",
+              "    rubberband_canvas.setAttribute(\n",
+              "        'style',\n",
+              "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
+              "    );\n",
+              "\n",
+              "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
+              "    if (this.ResizeObserver === undefined) {\n",
+              "        if (window.ResizeObserver !== undefined) {\n",
+              "            this.ResizeObserver = window.ResizeObserver;\n",
+              "        } else {\n",
+              "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
+              "            this.ResizeObserver = obs.ResizeObserver;\n",
+              "        }\n",
+              "    }\n",
+              "\n",
+              "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
+              "        var nentries = entries.length;\n",
+              "        for (var i = 0; i < nentries; i++) {\n",
+              "            var entry = entries[i];\n",
+              "            var width, height;\n",
+              "            if (entry.contentBoxSize) {\n",
+              "                if (entry.contentBoxSize instanceof Array) {\n",
+              "                    // Chrome 84 implements new version of spec.\n",
+              "                    width = entry.contentBoxSize[0].inlineSize;\n",
+              "                    height = entry.contentBoxSize[0].blockSize;\n",
+              "                } else {\n",
+              "                    // Firefox implements old version of spec.\n",
+              "                    width = entry.contentBoxSize.inlineSize;\n",
+              "                    height = entry.contentBoxSize.blockSize;\n",
+              "                }\n",
+              "            } else {\n",
+              "                // Chrome <84 implements even older version of spec.\n",
+              "                width = entry.contentRect.width;\n",
+              "                height = entry.contentRect.height;\n",
+              "            }\n",
+              "\n",
+              "            // Keep the size of the canvas and rubber band canvas in sync with\n",
+              "            // the canvas container.\n",
+              "            if (entry.devicePixelContentBoxSize) {\n",
+              "                // Chrome 84 implements new version of spec.\n",
+              "                canvas.setAttribute(\n",
+              "                    'width',\n",
+              "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
+              "                );\n",
+              "                canvas.setAttribute(\n",
+              "                    'height',\n",
+              "                    entry.devicePixelContentBoxSize[0].blockSize\n",
+              "                );\n",
+              "            } else {\n",
+              "                canvas.setAttribute('width', width * fig.ratio);\n",
+              "                canvas.setAttribute('height', height * fig.ratio);\n",
+              "            }\n",
+              "            canvas.setAttribute(\n",
+              "                'style',\n",
+              "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
+              "            );\n",
+              "\n",
+              "            rubberband_canvas.setAttribute('width', width);\n",
+              "            rubberband_canvas.setAttribute('height', height);\n",
+              "\n",
+              "            // And update the size in Python. We ignore the initial 0/0 size\n",
+              "            // that occurs as the element is placed into the DOM, which should\n",
+              "            // otherwise not happen due to the minimum size styling.\n",
+              "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
+              "                fig.request_resize(width, height);\n",
+              "            }\n",
+              "        }\n",
+              "    });\n",
+              "    this.resizeObserverInstance.observe(canvas_div);\n",
+              "\n",
+              "    function on_mouse_event_closure(name) {\n",
+              "        return function (event) {\n",
+              "            return fig.mouse_event(event, name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mousedown',\n",
+              "        on_mouse_event_closure('button_press')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseup',\n",
+              "        on_mouse_event_closure('button_release')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'dblclick',\n",
+              "        on_mouse_event_closure('dblclick')\n",
+              "    );\n",
+              "    // Throttle sequential mouse events to 1 every 20ms.\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mousemove',\n",
+              "        on_mouse_event_closure('motion_notify')\n",
+              "    );\n",
+              "\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseenter',\n",
+              "        on_mouse_event_closure('figure_enter')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseleave',\n",
+              "        on_mouse_event_closure('figure_leave')\n",
+              "    );\n",
+              "\n",
+              "    canvas_div.addEventListener('wheel', function (event) {\n",
+              "        if (event.deltaY < 0) {\n",
+              "            event.step = 1;\n",
+              "        } else {\n",
+              "            event.step = -1;\n",
+              "        }\n",
+              "        on_mouse_event_closure('scroll')(event);\n",
+              "    });\n",
+              "\n",
+              "    canvas_div.appendChild(canvas);\n",
+              "    canvas_div.appendChild(rubberband_canvas);\n",
+              "\n",
+              "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
+              "    this.rubberband_context.strokeStyle = '#000000';\n",
+              "\n",
+              "    this._resize_canvas = function (width, height, forward) {\n",
+              "        if (forward) {\n",
+              "            canvas_div.style.width = width + 'px';\n",
+              "            canvas_div.style.height = height + 'px';\n",
+              "        }\n",
+              "    };\n",
+              "\n",
+              "    // Disable right mouse context menu.\n",
+              "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
+              "        event.preventDefault();\n",
+              "        return false;\n",
+              "    });\n",
+              "\n",
+              "    function set_focus() {\n",
+              "        canvas.focus();\n",
+              "        canvas_div.focus();\n",
+              "    }\n",
+              "\n",
+              "    window.setTimeout(set_focus, 100);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_toolbar = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var toolbar = document.createElement('div');\n",
+              "    toolbar.classList = 'mpl-toolbar';\n",
+              "    this.root.appendChild(toolbar);\n",
+              "\n",
+              "    function on_click_closure(name) {\n",
+              "        return function (_event) {\n",
+              "            return fig.toolbar_button_onclick(name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    function on_mouseover_closure(tooltip) {\n",
+              "        return function (event) {\n",
+              "            if (!event.currentTarget.disabled) {\n",
+              "                return fig.toolbar_button_onmouseover(tooltip);\n",
+              "            }\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    fig.buttons = {};\n",
+              "    var buttonGroup = document.createElement('div');\n",
+              "    buttonGroup.classList = 'mpl-button-group';\n",
+              "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+              "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+              "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+              "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+              "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+              "\n",
+              "        if (!name) {\n",
+              "            /* Instead of a spacer, we start a new button group. */\n",
+              "            if (buttonGroup.hasChildNodes()) {\n",
+              "                toolbar.appendChild(buttonGroup);\n",
+              "            }\n",
+              "            buttonGroup = document.createElement('div');\n",
+              "            buttonGroup.classList = 'mpl-button-group';\n",
+              "            continue;\n",
+              "        }\n",
+              "\n",
+              "        var button = (fig.buttons[name] = document.createElement('button'));\n",
+              "        button.classList = 'mpl-widget';\n",
+              "        button.setAttribute('role', 'button');\n",
+              "        button.setAttribute('aria-disabled', 'false');\n",
+              "        button.addEventListener('click', on_click_closure(method_name));\n",
+              "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+              "\n",
+              "        var icon_img = document.createElement('img');\n",
+              "        icon_img.src = '_images/' + image + '.png';\n",
+              "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
+              "        icon_img.alt = tooltip;\n",
+              "        button.appendChild(icon_img);\n",
+              "\n",
+              "        buttonGroup.appendChild(button);\n",
+              "    }\n",
+              "\n",
+              "    if (buttonGroup.hasChildNodes()) {\n",
+              "        toolbar.appendChild(buttonGroup);\n",
+              "    }\n",
+              "\n",
+              "    var fmt_picker = document.createElement('select');\n",
+              "    fmt_picker.classList = 'mpl-widget';\n",
+              "    toolbar.appendChild(fmt_picker);\n",
+              "    this.format_dropdown = fmt_picker;\n",
+              "\n",
+              "    for (var ind in mpl.extensions) {\n",
+              "        var fmt = mpl.extensions[ind];\n",
+              "        var option = document.createElement('option');\n",
+              "        option.selected = fmt === mpl.default_extension;\n",
+              "        option.innerHTML = fmt;\n",
+              "        fmt_picker.appendChild(option);\n",
+              "    }\n",
+              "\n",
+              "    var status_bar = document.createElement('span');\n",
+              "    status_bar.classList = 'mpl-message';\n",
+              "    toolbar.appendChild(status_bar);\n",
+              "    this.message = status_bar;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
+              "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+              "    // which will in turn request a refresh of the image.\n",
+              "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.send_message = function (type, properties) {\n",
+              "    properties['type'] = type;\n",
+              "    properties['figure_id'] = this.id;\n",
+              "    this.ws.send(JSON.stringify(properties));\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.send_draw_message = function () {\n",
+              "    if (!this.waiting) {\n",
+              "        this.waiting = true;\n",
+              "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+              "    var format_dropdown = fig.format_dropdown;\n",
+              "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+              "    fig.ondownload(fig, format);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
+              "    var size = msg['size'];\n",
+              "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
+              "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
+              "        fig.send_message('refresh', {});\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
+              "    var x0 = msg['x0'] / fig.ratio;\n",
+              "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
+              "    var x1 = msg['x1'] / fig.ratio;\n",
+              "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
+              "    x0 = Math.floor(x0) + 0.5;\n",
+              "    y0 = Math.floor(y0) + 0.5;\n",
+              "    x1 = Math.floor(x1) + 0.5;\n",
+              "    y1 = Math.floor(y1) + 0.5;\n",
+              "    var min_x = Math.min(x0, x1);\n",
+              "    var min_y = Math.min(y0, y1);\n",
+              "    var width = Math.abs(x1 - x0);\n",
+              "    var height = Math.abs(y1 - y0);\n",
+              "\n",
+              "    fig.rubberband_context.clearRect(\n",
+              "        0,\n",
+              "        0,\n",
+              "        fig.canvas.width / fig.ratio,\n",
+              "        fig.canvas.height / fig.ratio\n",
+              "    );\n",
+              "\n",
+              "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
+              "    // Updates the figure title.\n",
+              "    fig.header.textContent = msg['label'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
+              "    fig.rubberband_canvas.style.cursor = msg['cursor'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
+              "    fig.message.textContent = msg['message'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
+              "    // Request the server to send over a new figure.\n",
+              "    fig.send_draw_message();\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
+              "    fig.image_mode = msg['mode'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
+              "    for (var key in msg) {\n",
+              "        if (!(key in fig.buttons)) {\n",
+              "            continue;\n",
+              "        }\n",
+              "        fig.buttons[key].disabled = !msg[key];\n",
+              "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
+              "    if (msg['mode'] === 'PAN') {\n",
+              "        fig.buttons['Pan'].classList.add('active');\n",
+              "        fig.buttons['Zoom'].classList.remove('active');\n",
+              "    } else if (msg['mode'] === 'ZOOM') {\n",
+              "        fig.buttons['Pan'].classList.remove('active');\n",
+              "        fig.buttons['Zoom'].classList.add('active');\n",
+              "    } else {\n",
+              "        fig.buttons['Pan'].classList.remove('active');\n",
+              "        fig.buttons['Zoom'].classList.remove('active');\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.updated_canvas_event = function () {\n",
+              "    // Called whenever the canvas gets updated.\n",
+              "    this.send_message('ack', {});\n",
+              "};\n",
+              "\n",
+              "// A function to construct a web socket function for onmessage handling.\n",
+              "// Called in the figure constructor.\n",
+              "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
+              "    return function socket_on_message(evt) {\n",
+              "        if (evt.data instanceof Blob) {\n",
+              "            var img = evt.data;\n",
+              "            if (img.type !== 'image/png') {\n",
+              "                /* FIXME: We get \"Resource interpreted as Image but\n",
+              "                 * transferred with MIME type text/plain:\" errors on\n",
+              "                 * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+              "                 * to be part of the websocket stream */\n",
+              "                img.type = 'image/png';\n",
+              "            }\n",
+              "\n",
+              "            /* Free the memory for the previous frames */\n",
+              "            if (fig.imageObj.src) {\n",
+              "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+              "                    fig.imageObj.src\n",
+              "                );\n",
+              "            }\n",
+              "\n",
+              "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+              "                img\n",
+              "            );\n",
+              "            fig.updated_canvas_event();\n",
+              "            fig.waiting = false;\n",
+              "            return;\n",
+              "        } else if (\n",
+              "            typeof evt.data === 'string' &&\n",
+              "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
+              "        ) {\n",
+              "            fig.imageObj.src = evt.data;\n",
+              "            fig.updated_canvas_event();\n",
+              "            fig.waiting = false;\n",
+              "            return;\n",
+              "        }\n",
+              "\n",
+              "        var msg = JSON.parse(evt.data);\n",
+              "        var msg_type = msg['type'];\n",
+              "\n",
+              "        // Call the  \"handle_{type}\" callback, which takes\n",
+              "        // the figure and JSON message as its only arguments.\n",
+              "        try {\n",
+              "            var callback = fig['handle_' + msg_type];\n",
+              "        } catch (e) {\n",
+              "            console.log(\n",
+              "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
+              "                msg\n",
+              "            );\n",
+              "            return;\n",
+              "        }\n",
+              "\n",
+              "        if (callback) {\n",
+              "            try {\n",
+              "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+              "                callback(fig, msg);\n",
+              "            } catch (e) {\n",
+              "                console.log(\n",
+              "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
+              "                    e,\n",
+              "                    e.stack,\n",
+              "                    msg\n",
+              "                );\n",
+              "            }\n",
+              "        }\n",
+              "    };\n",
+              "};\n",
+              "\n",
+              "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+              "mpl.findpos = function (e) {\n",
+              "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+              "    var targ;\n",
+              "    if (!e) {\n",
+              "        e = window.event;\n",
+              "    }\n",
+              "    if (e.target) {\n",
+              "        targ = e.target;\n",
+              "    } else if (e.srcElement) {\n",
+              "        targ = e.srcElement;\n",
+              "    }\n",
+              "    if (targ.nodeType === 3) {\n",
+              "        // defeat Safari bug\n",
+              "        targ = targ.parentNode;\n",
+              "    }\n",
+              "\n",
+              "    // pageX,Y are the mouse positions relative to the document\n",
+              "    var boundingRect = targ.getBoundingClientRect();\n",
+              "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
+              "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
+              "\n",
+              "    return { x: x, y: y };\n",
+              "};\n",
+              "\n",
+              "/*\n",
+              " * return a copy of an object with only non-object keys\n",
+              " * we need this to avoid circular references\n",
+              " * https://stackoverflow.com/a/24161582/3208463\n",
+              " */\n",
+              "function simpleKeys(original) {\n",
+              "    return Object.keys(original).reduce(function (obj, key) {\n",
+              "        if (typeof original[key] !== 'object') {\n",
+              "            obj[key] = original[key];\n",
+              "        }\n",
+              "        return obj;\n",
+              "    }, {});\n",
+              "}\n",
+              "\n",
+              "mpl.figure.prototype.mouse_event = function (event, name) {\n",
+              "    var canvas_pos = mpl.findpos(event);\n",
+              "\n",
+              "    if (name === 'button_press') {\n",
+              "        this.canvas.focus();\n",
+              "        this.canvas_div.focus();\n",
+              "    }\n",
+              "\n",
+              "    var x = canvas_pos.x * this.ratio;\n",
+              "    var y = canvas_pos.y * this.ratio;\n",
+              "\n",
+              "    this.send_message(name, {\n",
+              "        x: x,\n",
+              "        y: y,\n",
+              "        button: event.button,\n",
+              "        step: event.step,\n",
+              "        guiEvent: simpleKeys(event),\n",
+              "    });\n",
+              "\n",
+              "    /* This prevents the web browser from automatically changing to\n",
+              "     * the text insertion cursor when the button is pressed.  We want\n",
+              "     * to control all of the cursor setting manually through the\n",
+              "     * 'cursor' event from matplotlib */\n",
+              "    event.preventDefault();\n",
+              "    return false;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
+              "    // Handle any extra behaviour associated with a key event\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.key_event = function (event, name) {\n",
+              "    // Prevent repeat events\n",
+              "    if (name === 'key_press') {\n",
+              "        if (event.key === this._key) {\n",
+              "            return;\n",
+              "        } else {\n",
+              "            this._key = event.key;\n",
+              "        }\n",
+              "    }\n",
+              "    if (name === 'key_release') {\n",
+              "        this._key = null;\n",
+              "    }\n",
+              "\n",
+              "    var value = '';\n",
+              "    if (event.ctrlKey && event.key !== 'Control') {\n",
+              "        value += 'ctrl+';\n",
+              "    }\n",
+              "    else if (event.altKey && event.key !== 'Alt') {\n",
+              "        value += 'alt+';\n",
+              "    }\n",
+              "    else if (event.shiftKey && event.key !== 'Shift') {\n",
+              "        value += 'shift+';\n",
+              "    }\n",
+              "\n",
+              "    value += 'k' + event.key;\n",
+              "\n",
+              "    this._key_event_extra(event, name);\n",
+              "\n",
+              "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
+              "    return false;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
+              "    if (name === 'download') {\n",
+              "        this.handle_save(this, null);\n",
+              "    } else {\n",
+              "        this.send_message('toolbar_button', { name: name });\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
+              "    this.message.textContent = tooltip;\n",
+              "};\n",
+              "\n",
+              "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
+              "// prettier-ignore\n",
+              "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
+              "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+              "\n",
+              "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+              "\n",
+              "mpl.default_extension = \"png\";/* global mpl */\n",
+              "\n",
+              "var comm_websocket_adapter = function (comm) {\n",
+              "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+              "    // object with the appropriate methods. Currently this is a non binary\n",
+              "    // socket, so there is still some room for performance tuning.\n",
+              "    var ws = {};\n",
+              "\n",
+              "    ws.binaryType = comm.kernel.ws.binaryType;\n",
+              "    ws.readyState = comm.kernel.ws.readyState;\n",
+              "    function updateReadyState(_event) {\n",
+              "        if (comm.kernel.ws) {\n",
+              "            ws.readyState = comm.kernel.ws.readyState;\n",
+              "        } else {\n",
+              "            ws.readyState = 3; // Closed state.\n",
+              "        }\n",
+              "    }\n",
+              "    comm.kernel.ws.addEventListener('open', updateReadyState);\n",
+              "    comm.kernel.ws.addEventListener('close', updateReadyState);\n",
+              "    comm.kernel.ws.addEventListener('error', updateReadyState);\n",
+              "\n",
+              "    ws.close = function () {\n",
+              "        comm.close();\n",
+              "    };\n",
+              "    ws.send = function (m) {\n",
+              "        //console.log('sending', m);\n",
+              "        comm.send(m);\n",
+              "    };\n",
+              "    // Register the callback with on_msg.\n",
+              "    comm.on_msg(function (msg) {\n",
+              "        //console.log('receiving', msg['content']['data'], msg);\n",
+              "        var data = msg['content']['data'];\n",
+              "        if (data['blob'] !== undefined) {\n",
+              "            data = {\n",
+              "                data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
+              "            };\n",
+              "        }\n",
+              "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+              "        ws.onmessage(data);\n",
+              "    });\n",
+              "    return ws;\n",
+              "};\n",
+              "\n",
+              "mpl.mpl_figure_comm = function (comm, msg) {\n",
+              "    // This is the function which gets called when the mpl process\n",
+              "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+              "\n",
+              "    var id = msg.content.data.id;\n",
+              "    // Get hold of the div created by the display call when the Comm\n",
+              "    // socket was opened in Python.\n",
+              "    var element = document.getElementById(id);\n",
+              "    var ws_proxy = comm_websocket_adapter(comm);\n",
+              "\n",
+              "    function ondownload(figure, _format) {\n",
+              "        window.open(figure.canvas.toDataURL());\n",
+              "    }\n",
+              "\n",
+              "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
+              "\n",
+              "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+              "    // web socket which is closed, not our websocket->open comm proxy.\n",
+              "    ws_proxy.onopen();\n",
+              "\n",
+              "    fig.parent_element = element;\n",
+              "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+              "    if (!fig.cell_info) {\n",
+              "        console.error('Failed to find cell for figure', id, fig);\n",
+              "        return;\n",
+              "    }\n",
+              "    fig.cell_info[0].output_area.element.on(\n",
+              "        'cleared',\n",
+              "        { fig: fig },\n",
+              "        fig._remove_fig_handler\n",
+              "    );\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
+              "    var width = fig.canvas.width / fig.ratio;\n",
+              "    fig.cell_info[0].output_area.element.off(\n",
+              "        'cleared',\n",
+              "        fig._remove_fig_handler\n",
+              "    );\n",
+              "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
+              "\n",
+              "    // Update the output cell to use the data from the current canvas.\n",
+              "    fig.push_to_output();\n",
+              "    var dataURL = fig.canvas.toDataURL();\n",
+              "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+              "    // the notebook keyboard shortcuts fail.\n",
+              "    IPython.keyboard_manager.enable();\n",
+              "    fig.parent_element.innerHTML =\n",
+              "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+              "    fig.close_ws(fig, msg);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
+              "    fig.send_message('closing', msg);\n",
+              "    // fig.ws.close()\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
+              "    // Turn the data on the canvas into data in the output cell.\n",
+              "    var width = this.canvas.width / this.ratio;\n",
+              "    var dataURL = this.canvas.toDataURL();\n",
+              "    this.cell_info[1]['text/html'] =\n",
+              "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.updated_canvas_event = function () {\n",
+              "    // Tell IPython that the notebook contents must change.\n",
+              "    IPython.notebook.set_dirty(true);\n",
+              "    this.send_message('ack', {});\n",
+              "    var fig = this;\n",
+              "    // Wait a second, then push the new image to the DOM so\n",
+              "    // that it is saved nicely (might be nice to debounce this).\n",
+              "    setTimeout(function () {\n",
+              "        fig.push_to_output();\n",
+              "    }, 1000);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_toolbar = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var toolbar = document.createElement('div');\n",
+              "    toolbar.classList = 'btn-toolbar';\n",
+              "    this.root.appendChild(toolbar);\n",
+              "\n",
+              "    function on_click_closure(name) {\n",
+              "        return function (_event) {\n",
+              "            return fig.toolbar_button_onclick(name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    function on_mouseover_closure(tooltip) {\n",
+              "        return function (event) {\n",
+              "            if (!event.currentTarget.disabled) {\n",
+              "                return fig.toolbar_button_onmouseover(tooltip);\n",
+              "            }\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    fig.buttons = {};\n",
+              "    var buttonGroup = document.createElement('div');\n",
+              "    buttonGroup.classList = 'btn-group';\n",
+              "    var button;\n",
+              "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+              "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+              "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+              "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+              "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+              "\n",
+              "        if (!name) {\n",
+              "            /* Instead of a spacer, we start a new button group. */\n",
+              "            if (buttonGroup.hasChildNodes()) {\n",
+              "                toolbar.appendChild(buttonGroup);\n",
+              "            }\n",
+              "            buttonGroup = document.createElement('div');\n",
+              "            buttonGroup.classList = 'btn-group';\n",
+              "            continue;\n",
+              "        }\n",
+              "\n",
+              "        button = fig.buttons[name] = document.createElement('button');\n",
+              "        button.classList = 'btn btn-default';\n",
+              "        button.href = '#';\n",
+              "        button.title = name;\n",
+              "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
+              "        button.addEventListener('click', on_click_closure(method_name));\n",
+              "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+              "        buttonGroup.appendChild(button);\n",
+              "    }\n",
+              "\n",
+              "    if (buttonGroup.hasChildNodes()) {\n",
+              "        toolbar.appendChild(buttonGroup);\n",
+              "    }\n",
+              "\n",
+              "    // Add the status bar.\n",
+              "    var status_bar = document.createElement('span');\n",
+              "    status_bar.classList = 'mpl-message pull-right';\n",
+              "    toolbar.appendChild(status_bar);\n",
+              "    this.message = status_bar;\n",
+              "\n",
+              "    // Add the close button to the window.\n",
+              "    var buttongrp = document.createElement('div');\n",
+              "    buttongrp.classList = 'btn-group inline pull-right';\n",
+              "    button = document.createElement('button');\n",
+              "    button.classList = 'btn btn-mini btn-primary';\n",
+              "    button.href = '#';\n",
+              "    button.title = 'Stop Interaction';\n",
+              "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
+              "    button.addEventListener('click', function (_evt) {\n",
+              "        fig.handle_close(fig, {});\n",
+              "    });\n",
+              "    button.addEventListener(\n",
+              "        'mouseover',\n",
+              "        on_mouseover_closure('Stop Interaction')\n",
+              "    );\n",
+              "    buttongrp.appendChild(button);\n",
+              "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
+              "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
+              "    var fig = event.data.fig;\n",
+              "    if (event.target !== this) {\n",
+              "        // Ignore bubbled events from children.\n",
+              "        return;\n",
+              "    }\n",
+              "    fig.close_ws(fig, {});\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._root_extra_style = function (el) {\n",
+              "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
+              "    // this is important to make the div 'focusable\n",
+              "    el.setAttribute('tabindex', 0);\n",
+              "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+              "    // off when our div gets focus\n",
+              "\n",
+              "    // location in version 3\n",
+              "    if (IPython.notebook.keyboard_manager) {\n",
+              "        IPython.notebook.keyboard_manager.register_events(el);\n",
+              "    } else {\n",
+              "        // location in version 2\n",
+              "        IPython.keyboard_manager.register_events(el);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
+              "    // Check for shift+enter\n",
+              "    if (event.shiftKey && event.which === 13) {\n",
+              "        this.canvas_div.blur();\n",
+              "        // select the cell after this one\n",
+              "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
+              "        IPython.notebook.select(index + 1);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+              "    fig.ondownload(fig, null);\n",
+              "};\n",
+              "\n",
+              "mpl.find_output_cell = function (html_output) {\n",
+              "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+              "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+              "    // IPython event is triggered only after the cells have been serialised, which for\n",
+              "    // our purposes (turning an active figure into a static one), is too late.\n",
+              "    var cells = IPython.notebook.get_cells();\n",
+              "    var ncells = cells.length;\n",
+              "    for (var i = 0; i < ncells; i++) {\n",
+              "        var cell = cells[i];\n",
+              "        if (cell.cell_type === 'code') {\n",
+              "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
+              "                var data = cell.output_area.outputs[j];\n",
+              "                if (data.data) {\n",
+              "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+              "                    data = data.data;\n",
+              "                }\n",
+              "                if (data['text/html'] === html_output) {\n",
+              "                    return [cell, data, j];\n",
+              "                }\n",
+              "            }\n",
+              "        }\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "// Register the function which deals with the matplotlib target/channel.\n",
+              "// The kernel may be null if the page has been refreshed.\n",
+              "if (IPython.notebook.kernel !== null) {\n",
+              "    IPython.notebook.kernel.comm_manager.register_target(\n",
+              "        'matplotlib',\n",
+              "        mpl.mpl_figure_comm\n",
+              "    );\n",
+              "}\n"
+            ],
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/html": [
+              "<img src=\"data:image/png;base64,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\" width=\"800\">"
+            ],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "## Implementation\n",
+        "\n",
+        "# Modeling with statevector_simulator\n",
+        "q_sv = QAOA()\n",
+        "qiskit_sv = create_device(location='local', name='qiskit.statevector_simulator')\n",
+        "q_sv.set_device(qiskit_sv)\n",
+        "q_sv.set_circuit_properties(p=2, param_type='standard', init_type='rand', mixer_hamiltonian='x')\n",
+        "q_sv.set_classical_optimizer(method='COBYLA', maxiter=400, tol=0.001, cost_progress=True, parameter_log=True)\n",
+        "\n",
+        "q_sv.compile(ising_encoding)\n",
+        "q_sv.optimize()\n",
+        "results_sv = q_sv.result\n",
+        "#pd.DataFrame(q_sv.result.lowest_cost_bitstrings(5))\n",
+        "\n",
+        "# Modeling with shot-based simulator\n",
+        "q_shot = QAOA()\n",
+        "qiskit_shot = create_device(location='local', name='qiskit.qasm_simulator')\n",
+        "q_shot.set_device(qiskit_shot)\n",
+        "q_shot.set_circuit_properties(p=2, param_type='standard', init_type='rand', mixer_hamiltonian='x')\n",
+        "q_shot.set_backend_properties(n_shots = 400)\n",
+        "q_shot.set_classical_optimizer(method='COBYLA', maxiter=400, tol=0.001, cost_progress=True, parameter_log=True)\n",
+        "\n",
+        "q_shot.compile(ising_encoding)\n",
+        "q_shot.optimize()\n",
+        "results_shot = q_shot.result\n",
+        "pd.DataFrame(q_shot.result.lowest_cost_bitstrings(5))\n",
+        "\n",
+        "# Modeling with annealing parameterization\n",
+        "q_annealing = QAOA()\n",
+        "p=6\n",
+        "q_annealing.set_circuit_properties(p=p, param_type='annealing', init_type='ramp')\n",
+        "q_annealing.set_classical_optimizer(maxiter=100)\n",
+        "q_annealing.compile(ising_encoding)\n",
+        "q_annealing.optimize()\n",
+        "results_annealing = q_annealing.result\n",
+        "print(\"Optimized cost with AnnealingParams:\", q_annealing.result.optimized['cost'])\n",
+        "# annealing optimized schedule\n",
+        "opt_schedule = q_annealing.result.optimized['angles']\n",
+        "p_i = range(1,p+1)\n",
+        "fig = plt.figure(figsize=(8,5))\n",
+        "plt.plot(p_i,opt_schedule,lw=0.3,ls='--',marker='o')\n",
+        "plt.xlabel('p')\n",
+        "plt.title(f'Optimized annealing (discrete) schedule for p={p}');\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "PWpQZ1F4RRQ2"
+      },
+      "source": [
+        "# Part 3: Noise Model\n",
+        "\n",
+        "The optimal combination that you found with the best optimizer, the lowest number of $p$'s and the correct answer, can give the same answer with noise, use the circuit with a noise model and identify if it gives the same answer."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ErC1FJCzRRQ3",
+        "outputId": "9f9960e8-2979-40b6-9811-2c8e4c1045b7"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>solutions_bitstrings</th>\n",
+              "      <th>bitstrings_energies</th>\n",
+              "      <th>probabilities</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>1100</td>\n",
+              "      <td>27.0</td>\n",
+              "      <td>0.005</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>1001</td>\n",
+              "      <td>27.0</td>\n",
+              "      <td>0.010</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>0101</td>\n",
+              "      <td>32.0</td>\n",
+              "      <td>0.140</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>1010</td>\n",
+              "      <td>32.0</td>\n",
+              "      <td>0.095</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>0110</td>\n",
+              "      <td>35.0</td>\n",
+              "      <td>0.140</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "  solutions_bitstrings  bitstrings_energies  probabilities\n",
+              "0                 1100                 27.0          0.005\n",
+              "1                 1001                 27.0          0.010\n",
+              "2                 0101                 32.0          0.140\n",
+              "3                 1010                 32.0          0.095\n",
+              "4                 0110                 35.0          0.140"
+            ]
+          },
+          "execution_count": 204,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# implementation using a noise model using qiskit\n",
+        "from qiskit.providers.fake_provider import FakeManila\n",
+        "from qiskit.providers.aer.noise import NoiseModel\n",
+        "from qiskit.providers.aer import QasmSimulator\n",
+        "\n",
+        "# Modeling with noisy shot-based simulator\n",
+        "device_backend = FakeManila()\n",
+        "device = QasmSimulator.from_backend(device_backend)\n",
+        "noise_model = NoiseModel.from_backend(device)\n",
+        "\n",
+        "q_noisy_shot = QAOA()\n",
+        "qiskit_noisy_shot = create_device(location='local', name='qiskit.qasm_simulator')\n",
+        "q_noisy_shot.set_device(qiskit_noisy_shot)\n",
+        "q_noisy_shot.set_circuit_properties(p=2, param_type='standard', init_type='rand', mixer_hamiltonian='x')\n",
+        "q_noisy_shot.set_backend_properties(n_shots = 200, noise_model = noise_model)\n",
+        "q_noisy_shot.set_classical_optimizer(method='COBYLA', maxiter=400, tol=0.001, cost_progress=True, parameter_log=True)\n",
+        "\n",
+        "q_noisy_shot.compile(ising_encoding)\n",
+        "q_noisy_shot.optimize()\n",
+        "results_noisy_shot = q_noisy_shot.result\n",
+        "pd.DataFrame(q_noisy_shot.result.lowest_cost_bitstrings(5))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Azlj93FaRRQ3"
+      },
+      "source": [
+        "# Part 4: Model comparison"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "nqoBITCgRRQ3",
+        "outputId": "cd649b98-d563-425d-8c79-bfeca8bd89ce"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/javascript": [
+              "/* Put everything inside the global mpl namespace */\n",
+              "/* global mpl */\n",
+              "window.mpl = {};\n",
+              "\n",
+              "mpl.get_websocket_type = function () {\n",
+              "    if (typeof WebSocket !== 'undefined') {\n",
+              "        return WebSocket;\n",
+              "    } else if (typeof MozWebSocket !== 'undefined') {\n",
+              "        return MozWebSocket;\n",
+              "    } else {\n",
+              "        alert(\n",
+              "            'Your browser does not have WebSocket support. ' +\n",
+              "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+              "                'Firefox 4 and 5 are also supported but you ' +\n",
+              "                'have to enable WebSockets in about:config.'\n",
+              "        );\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
+              "    this.id = figure_id;\n",
+              "\n",
+              "    this.ws = websocket;\n",
+              "\n",
+              "    this.supports_binary = this.ws.binaryType !== undefined;\n",
+              "\n",
+              "    if (!this.supports_binary) {\n",
+              "        var warnings = document.getElementById('mpl-warnings');\n",
+              "        if (warnings) {\n",
+              "            warnings.style.display = 'block';\n",
+              "            warnings.textContent =\n",
+              "                'This browser does not support binary websocket messages. ' +\n",
+              "                'Performance may be slow.';\n",
+              "        }\n",
+              "    }\n",
+              "\n",
+              "    this.imageObj = new Image();\n",
+              "\n",
+              "    this.context = undefined;\n",
+              "    this.message = undefined;\n",
+              "    this.canvas = undefined;\n",
+              "    this.rubberband_canvas = undefined;\n",
+              "    this.rubberband_context = undefined;\n",
+              "    this.format_dropdown = undefined;\n",
+              "\n",
+              "    this.image_mode = 'full';\n",
+              "\n",
+              "    this.root = document.createElement('div');\n",
+              "    this.root.setAttribute('style', 'display: inline-block');\n",
+              "    this._root_extra_style(this.root);\n",
+              "\n",
+              "    parent_element.appendChild(this.root);\n",
+              "\n",
+              "    this._init_header(this);\n",
+              "    this._init_canvas(this);\n",
+              "    this._init_toolbar(this);\n",
+              "\n",
+              "    var fig = this;\n",
+              "\n",
+              "    this.waiting = false;\n",
+              "\n",
+              "    this.ws.onopen = function () {\n",
+              "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
+              "        fig.send_message('send_image_mode', {});\n",
+              "        if (fig.ratio !== 1) {\n",
+              "            fig.send_message('set_device_pixel_ratio', {\n",
+              "                device_pixel_ratio: fig.ratio,\n",
+              "            });\n",
+              "        }\n",
+              "        fig.send_message('refresh', {});\n",
+              "    };\n",
+              "\n",
+              "    this.imageObj.onload = function () {\n",
+              "        if (fig.image_mode === 'full') {\n",
+              "            // Full images could contain transparency (where diff images\n",
+              "            // almost always do), so we need to clear the canvas so that\n",
+              "            // there is no ghosting.\n",
+              "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+              "        }\n",
+              "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
+              "    };\n",
+              "\n",
+              "    this.imageObj.onunload = function () {\n",
+              "        fig.ws.close();\n",
+              "    };\n",
+              "\n",
+              "    this.ws.onmessage = this._make_on_message_function(this);\n",
+              "\n",
+              "    this.ondownload = ondownload;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_header = function () {\n",
+              "    var titlebar = document.createElement('div');\n",
+              "    titlebar.classList =\n",
+              "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
+              "    var titletext = document.createElement('div');\n",
+              "    titletext.classList = 'ui-dialog-title';\n",
+              "    titletext.setAttribute(\n",
+              "        'style',\n",
+              "        'width: 100%; text-align: center; padding: 3px;'\n",
+              "    );\n",
+              "    titlebar.appendChild(titletext);\n",
+              "    this.root.appendChild(titlebar);\n",
+              "    this.header = titletext;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
+              "\n",
+              "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
+              "\n",
+              "mpl.figure.prototype._init_canvas = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
+              "    canvas_div.setAttribute(\n",
+              "        'style',\n",
+              "        'border: 1px solid #ddd;' +\n",
+              "            'box-sizing: content-box;' +\n",
+              "            'clear: both;' +\n",
+              "            'min-height: 1px;' +\n",
+              "            'min-width: 1px;' +\n",
+              "            'outline: 0;' +\n",
+              "            'overflow: hidden;' +\n",
+              "            'position: relative;' +\n",
+              "            'resize: both;'\n",
+              "    );\n",
+              "\n",
+              "    function on_keyboard_event_closure(name) {\n",
+              "        return function (event) {\n",
+              "            return fig.key_event(event, name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    canvas_div.addEventListener(\n",
+              "        'keydown',\n",
+              "        on_keyboard_event_closure('key_press')\n",
+              "    );\n",
+              "    canvas_div.addEventListener(\n",
+              "        'keyup',\n",
+              "        on_keyboard_event_closure('key_release')\n",
+              "    );\n",
+              "\n",
+              "    this._canvas_extra_style(canvas_div);\n",
+              "    this.root.appendChild(canvas_div);\n",
+              "\n",
+              "    var canvas = (this.canvas = document.createElement('canvas'));\n",
+              "    canvas.classList.add('mpl-canvas');\n",
+              "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
+              "\n",
+              "    this.context = canvas.getContext('2d');\n",
+              "\n",
+              "    var backingStore =\n",
+              "        this.context.backingStorePixelRatio ||\n",
+              "        this.context.webkitBackingStorePixelRatio ||\n",
+              "        this.context.mozBackingStorePixelRatio ||\n",
+              "        this.context.msBackingStorePixelRatio ||\n",
+              "        this.context.oBackingStorePixelRatio ||\n",
+              "        this.context.backingStorePixelRatio ||\n",
+              "        1;\n",
+              "\n",
+              "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+              "\n",
+              "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
+              "        'canvas'\n",
+              "    ));\n",
+              "    rubberband_canvas.setAttribute(\n",
+              "        'style',\n",
+              "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
+              "    );\n",
+              "\n",
+              "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
+              "    if (this.ResizeObserver === undefined) {\n",
+              "        if (window.ResizeObserver !== undefined) {\n",
+              "            this.ResizeObserver = window.ResizeObserver;\n",
+              "        } else {\n",
+              "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
+              "            this.ResizeObserver = obs.ResizeObserver;\n",
+              "        }\n",
+              "    }\n",
+              "\n",
+              "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
+              "        var nentries = entries.length;\n",
+              "        for (var i = 0; i < nentries; i++) {\n",
+              "            var entry = entries[i];\n",
+              "            var width, height;\n",
+              "            if (entry.contentBoxSize) {\n",
+              "                if (entry.contentBoxSize instanceof Array) {\n",
+              "                    // Chrome 84 implements new version of spec.\n",
+              "                    width = entry.contentBoxSize[0].inlineSize;\n",
+              "                    height = entry.contentBoxSize[0].blockSize;\n",
+              "                } else {\n",
+              "                    // Firefox implements old version of spec.\n",
+              "                    width = entry.contentBoxSize.inlineSize;\n",
+              "                    height = entry.contentBoxSize.blockSize;\n",
+              "                }\n",
+              "            } else {\n",
+              "                // Chrome <84 implements even older version of spec.\n",
+              "                width = entry.contentRect.width;\n",
+              "                height = entry.contentRect.height;\n",
+              "            }\n",
+              "\n",
+              "            // Keep the size of the canvas and rubber band canvas in sync with\n",
+              "            // the canvas container.\n",
+              "            if (entry.devicePixelContentBoxSize) {\n",
+              "                // Chrome 84 implements new version of spec.\n",
+              "                canvas.setAttribute(\n",
+              "                    'width',\n",
+              "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
+              "                );\n",
+              "                canvas.setAttribute(\n",
+              "                    'height',\n",
+              "                    entry.devicePixelContentBoxSize[0].blockSize\n",
+              "                );\n",
+              "            } else {\n",
+              "                canvas.setAttribute('width', width * fig.ratio);\n",
+              "                canvas.setAttribute('height', height * fig.ratio);\n",
+              "            }\n",
+              "            canvas.setAttribute(\n",
+              "                'style',\n",
+              "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
+              "            );\n",
+              "\n",
+              "            rubberband_canvas.setAttribute('width', width);\n",
+              "            rubberband_canvas.setAttribute('height', height);\n",
+              "\n",
+              "            // And update the size in Python. We ignore the initial 0/0 size\n",
+              "            // that occurs as the element is placed into the DOM, which should\n",
+              "            // otherwise not happen due to the minimum size styling.\n",
+              "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
+              "                fig.request_resize(width, height);\n",
+              "            }\n",
+              "        }\n",
+              "    });\n",
+              "    this.resizeObserverInstance.observe(canvas_div);\n",
+              "\n",
+              "    function on_mouse_event_closure(name) {\n",
+              "        return function (event) {\n",
+              "            return fig.mouse_event(event, name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mousedown',\n",
+              "        on_mouse_event_closure('button_press')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseup',\n",
+              "        on_mouse_event_closure('button_release')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'dblclick',\n",
+              "        on_mouse_event_closure('dblclick')\n",
+              "    );\n",
+              "    // Throttle sequential mouse events to 1 every 20ms.\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mousemove',\n",
+              "        on_mouse_event_closure('motion_notify')\n",
+              "    );\n",
+              "\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseenter',\n",
+              "        on_mouse_event_closure('figure_enter')\n",
+              "    );\n",
+              "    rubberband_canvas.addEventListener(\n",
+              "        'mouseleave',\n",
+              "        on_mouse_event_closure('figure_leave')\n",
+              "    );\n",
+              "\n",
+              "    canvas_div.addEventListener('wheel', function (event) {\n",
+              "        if (event.deltaY < 0) {\n",
+              "            event.step = 1;\n",
+              "        } else {\n",
+              "            event.step = -1;\n",
+              "        }\n",
+              "        on_mouse_event_closure('scroll')(event);\n",
+              "    });\n",
+              "\n",
+              "    canvas_div.appendChild(canvas);\n",
+              "    canvas_div.appendChild(rubberband_canvas);\n",
+              "\n",
+              "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
+              "    this.rubberband_context.strokeStyle = '#000000';\n",
+              "\n",
+              "    this._resize_canvas = function (width, height, forward) {\n",
+              "        if (forward) {\n",
+              "            canvas_div.style.width = width + 'px';\n",
+              "            canvas_div.style.height = height + 'px';\n",
+              "        }\n",
+              "    };\n",
+              "\n",
+              "    // Disable right mouse context menu.\n",
+              "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
+              "        event.preventDefault();\n",
+              "        return false;\n",
+              "    });\n",
+              "\n",
+              "    function set_focus() {\n",
+              "        canvas.focus();\n",
+              "        canvas_div.focus();\n",
+              "    }\n",
+              "\n",
+              "    window.setTimeout(set_focus, 100);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_toolbar = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var toolbar = document.createElement('div');\n",
+              "    toolbar.classList = 'mpl-toolbar';\n",
+              "    this.root.appendChild(toolbar);\n",
+              "\n",
+              "    function on_click_closure(name) {\n",
+              "        return function (_event) {\n",
+              "            return fig.toolbar_button_onclick(name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    function on_mouseover_closure(tooltip) {\n",
+              "        return function (event) {\n",
+              "            if (!event.currentTarget.disabled) {\n",
+              "                return fig.toolbar_button_onmouseover(tooltip);\n",
+              "            }\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    fig.buttons = {};\n",
+              "    var buttonGroup = document.createElement('div');\n",
+              "    buttonGroup.classList = 'mpl-button-group';\n",
+              "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+              "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+              "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+              "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+              "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+              "\n",
+              "        if (!name) {\n",
+              "            /* Instead of a spacer, we start a new button group. */\n",
+              "            if (buttonGroup.hasChildNodes()) {\n",
+              "                toolbar.appendChild(buttonGroup);\n",
+              "            }\n",
+              "            buttonGroup = document.createElement('div');\n",
+              "            buttonGroup.classList = 'mpl-button-group';\n",
+              "            continue;\n",
+              "        }\n",
+              "\n",
+              "        var button = (fig.buttons[name] = document.createElement('button'));\n",
+              "        button.classList = 'mpl-widget';\n",
+              "        button.setAttribute('role', 'button');\n",
+              "        button.setAttribute('aria-disabled', 'false');\n",
+              "        button.addEventListener('click', on_click_closure(method_name));\n",
+              "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+              "\n",
+              "        var icon_img = document.createElement('img');\n",
+              "        icon_img.src = '_images/' + image + '.png';\n",
+              "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
+              "        icon_img.alt = tooltip;\n",
+              "        button.appendChild(icon_img);\n",
+              "\n",
+              "        buttonGroup.appendChild(button);\n",
+              "    }\n",
+              "\n",
+              "    if (buttonGroup.hasChildNodes()) {\n",
+              "        toolbar.appendChild(buttonGroup);\n",
+              "    }\n",
+              "\n",
+              "    var fmt_picker = document.createElement('select');\n",
+              "    fmt_picker.classList = 'mpl-widget';\n",
+              "    toolbar.appendChild(fmt_picker);\n",
+              "    this.format_dropdown = fmt_picker;\n",
+              "\n",
+              "    for (var ind in mpl.extensions) {\n",
+              "        var fmt = mpl.extensions[ind];\n",
+              "        var option = document.createElement('option');\n",
+              "        option.selected = fmt === mpl.default_extension;\n",
+              "        option.innerHTML = fmt;\n",
+              "        fmt_picker.appendChild(option);\n",
+              "    }\n",
+              "\n",
+              "    var status_bar = document.createElement('span');\n",
+              "    status_bar.classList = 'mpl-message';\n",
+              "    toolbar.appendChild(status_bar);\n",
+              "    this.message = status_bar;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
+              "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+              "    // which will in turn request a refresh of the image.\n",
+              "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.send_message = function (type, properties) {\n",
+              "    properties['type'] = type;\n",
+              "    properties['figure_id'] = this.id;\n",
+              "    this.ws.send(JSON.stringify(properties));\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.send_draw_message = function () {\n",
+              "    if (!this.waiting) {\n",
+              "        this.waiting = true;\n",
+              "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+              "    var format_dropdown = fig.format_dropdown;\n",
+              "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+              "    fig.ondownload(fig, format);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
+              "    var size = msg['size'];\n",
+              "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
+              "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
+              "        fig.send_message('refresh', {});\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
+              "    var x0 = msg['x0'] / fig.ratio;\n",
+              "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
+              "    var x1 = msg['x1'] / fig.ratio;\n",
+              "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
+              "    x0 = Math.floor(x0) + 0.5;\n",
+              "    y0 = Math.floor(y0) + 0.5;\n",
+              "    x1 = Math.floor(x1) + 0.5;\n",
+              "    y1 = Math.floor(y1) + 0.5;\n",
+              "    var min_x = Math.min(x0, x1);\n",
+              "    var min_y = Math.min(y0, y1);\n",
+              "    var width = Math.abs(x1 - x0);\n",
+              "    var height = Math.abs(y1 - y0);\n",
+              "\n",
+              "    fig.rubberband_context.clearRect(\n",
+              "        0,\n",
+              "        0,\n",
+              "        fig.canvas.width / fig.ratio,\n",
+              "        fig.canvas.height / fig.ratio\n",
+              "    );\n",
+              "\n",
+              "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
+              "    // Updates the figure title.\n",
+              "    fig.header.textContent = msg['label'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
+              "    fig.rubberband_canvas.style.cursor = msg['cursor'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
+              "    fig.message.textContent = msg['message'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
+              "    // Request the server to send over a new figure.\n",
+              "    fig.send_draw_message();\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
+              "    fig.image_mode = msg['mode'];\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
+              "    for (var key in msg) {\n",
+              "        if (!(key in fig.buttons)) {\n",
+              "            continue;\n",
+              "        }\n",
+              "        fig.buttons[key].disabled = !msg[key];\n",
+              "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
+              "    if (msg['mode'] === 'PAN') {\n",
+              "        fig.buttons['Pan'].classList.add('active');\n",
+              "        fig.buttons['Zoom'].classList.remove('active');\n",
+              "    } else if (msg['mode'] === 'ZOOM') {\n",
+              "        fig.buttons['Pan'].classList.remove('active');\n",
+              "        fig.buttons['Zoom'].classList.add('active');\n",
+              "    } else {\n",
+              "        fig.buttons['Pan'].classList.remove('active');\n",
+              "        fig.buttons['Zoom'].classList.remove('active');\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.updated_canvas_event = function () {\n",
+              "    // Called whenever the canvas gets updated.\n",
+              "    this.send_message('ack', {});\n",
+              "};\n",
+              "\n",
+              "// A function to construct a web socket function for onmessage handling.\n",
+              "// Called in the figure constructor.\n",
+              "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
+              "    return function socket_on_message(evt) {\n",
+              "        if (evt.data instanceof Blob) {\n",
+              "            var img = evt.data;\n",
+              "            if (img.type !== 'image/png') {\n",
+              "                /* FIXME: We get \"Resource interpreted as Image but\n",
+              "                 * transferred with MIME type text/plain:\" errors on\n",
+              "                 * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+              "                 * to be part of the websocket stream */\n",
+              "                img.type = 'image/png';\n",
+              "            }\n",
+              "\n",
+              "            /* Free the memory for the previous frames */\n",
+              "            if (fig.imageObj.src) {\n",
+              "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+              "                    fig.imageObj.src\n",
+              "                );\n",
+              "            }\n",
+              "\n",
+              "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+              "                img\n",
+              "            );\n",
+              "            fig.updated_canvas_event();\n",
+              "            fig.waiting = false;\n",
+              "            return;\n",
+              "        } else if (\n",
+              "            typeof evt.data === 'string' &&\n",
+              "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
+              "        ) {\n",
+              "            fig.imageObj.src = evt.data;\n",
+              "            fig.updated_canvas_event();\n",
+              "            fig.waiting = false;\n",
+              "            return;\n",
+              "        }\n",
+              "\n",
+              "        var msg = JSON.parse(evt.data);\n",
+              "        var msg_type = msg['type'];\n",
+              "\n",
+              "        // Call the  \"handle_{type}\" callback, which takes\n",
+              "        // the figure and JSON message as its only arguments.\n",
+              "        try {\n",
+              "            var callback = fig['handle_' + msg_type];\n",
+              "        } catch (e) {\n",
+              "            console.log(\n",
+              "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
+              "                msg\n",
+              "            );\n",
+              "            return;\n",
+              "        }\n",
+              "\n",
+              "        if (callback) {\n",
+              "            try {\n",
+              "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+              "                callback(fig, msg);\n",
+              "            } catch (e) {\n",
+              "                console.log(\n",
+              "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
+              "                    e,\n",
+              "                    e.stack,\n",
+              "                    msg\n",
+              "                );\n",
+              "            }\n",
+              "        }\n",
+              "    };\n",
+              "};\n",
+              "\n",
+              "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+              "mpl.findpos = function (e) {\n",
+              "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+              "    var targ;\n",
+              "    if (!e) {\n",
+              "        e = window.event;\n",
+              "    }\n",
+              "    if (e.target) {\n",
+              "        targ = e.target;\n",
+              "    } else if (e.srcElement) {\n",
+              "        targ = e.srcElement;\n",
+              "    }\n",
+              "    if (targ.nodeType === 3) {\n",
+              "        // defeat Safari bug\n",
+              "        targ = targ.parentNode;\n",
+              "    }\n",
+              "\n",
+              "    // pageX,Y are the mouse positions relative to the document\n",
+              "    var boundingRect = targ.getBoundingClientRect();\n",
+              "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
+              "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
+              "\n",
+              "    return { x: x, y: y };\n",
+              "};\n",
+              "\n",
+              "/*\n",
+              " * return a copy of an object with only non-object keys\n",
+              " * we need this to avoid circular references\n",
+              " * https://stackoverflow.com/a/24161582/3208463\n",
+              " */\n",
+              "function simpleKeys(original) {\n",
+              "    return Object.keys(original).reduce(function (obj, key) {\n",
+              "        if (typeof original[key] !== 'object') {\n",
+              "            obj[key] = original[key];\n",
+              "        }\n",
+              "        return obj;\n",
+              "    }, {});\n",
+              "}\n",
+              "\n",
+              "mpl.figure.prototype.mouse_event = function (event, name) {\n",
+              "    var canvas_pos = mpl.findpos(event);\n",
+              "\n",
+              "    if (name === 'button_press') {\n",
+              "        this.canvas.focus();\n",
+              "        this.canvas_div.focus();\n",
+              "    }\n",
+              "\n",
+              "    var x = canvas_pos.x * this.ratio;\n",
+              "    var y = canvas_pos.y * this.ratio;\n",
+              "\n",
+              "    this.send_message(name, {\n",
+              "        x: x,\n",
+              "        y: y,\n",
+              "        button: event.button,\n",
+              "        step: event.step,\n",
+              "        guiEvent: simpleKeys(event),\n",
+              "    });\n",
+              "\n",
+              "    /* This prevents the web browser from automatically changing to\n",
+              "     * the text insertion cursor when the button is pressed.  We want\n",
+              "     * to control all of the cursor setting manually through the\n",
+              "     * 'cursor' event from matplotlib */\n",
+              "    event.preventDefault();\n",
+              "    return false;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
+              "    // Handle any extra behaviour associated with a key event\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.key_event = function (event, name) {\n",
+              "    // Prevent repeat events\n",
+              "    if (name === 'key_press') {\n",
+              "        if (event.key === this._key) {\n",
+              "            return;\n",
+              "        } else {\n",
+              "            this._key = event.key;\n",
+              "        }\n",
+              "    }\n",
+              "    if (name === 'key_release') {\n",
+              "        this._key = null;\n",
+              "    }\n",
+              "\n",
+              "    var value = '';\n",
+              "    if (event.ctrlKey && event.key !== 'Control') {\n",
+              "        value += 'ctrl+';\n",
+              "    }\n",
+              "    else if (event.altKey && event.key !== 'Alt') {\n",
+              "        value += 'alt+';\n",
+              "    }\n",
+              "    else if (event.shiftKey && event.key !== 'Shift') {\n",
+              "        value += 'shift+';\n",
+              "    }\n",
+              "\n",
+              "    value += 'k' + event.key;\n",
+              "\n",
+              "    this._key_event_extra(event, name);\n",
+              "\n",
+              "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
+              "    return false;\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
+              "    if (name === 'download') {\n",
+              "        this.handle_save(this, null);\n",
+              "    } else {\n",
+              "        this.send_message('toolbar_button', { name: name });\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
+              "    this.message.textContent = tooltip;\n",
+              "};\n",
+              "\n",
+              "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
+              "// prettier-ignore\n",
+              "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
+              "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+              "\n",
+              "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+              "\n",
+              "mpl.default_extension = \"png\";/* global mpl */\n",
+              "\n",
+              "var comm_websocket_adapter = function (comm) {\n",
+              "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+              "    // object with the appropriate methods. Currently this is a non binary\n",
+              "    // socket, so there is still some room for performance tuning.\n",
+              "    var ws = {};\n",
+              "\n",
+              "    ws.binaryType = comm.kernel.ws.binaryType;\n",
+              "    ws.readyState = comm.kernel.ws.readyState;\n",
+              "    function updateReadyState(_event) {\n",
+              "        if (comm.kernel.ws) {\n",
+              "            ws.readyState = comm.kernel.ws.readyState;\n",
+              "        } else {\n",
+              "            ws.readyState = 3; // Closed state.\n",
+              "        }\n",
+              "    }\n",
+              "    comm.kernel.ws.addEventListener('open', updateReadyState);\n",
+              "    comm.kernel.ws.addEventListener('close', updateReadyState);\n",
+              "    comm.kernel.ws.addEventListener('error', updateReadyState);\n",
+              "\n",
+              "    ws.close = function () {\n",
+              "        comm.close();\n",
+              "    };\n",
+              "    ws.send = function (m) {\n",
+              "        //console.log('sending', m);\n",
+              "        comm.send(m);\n",
+              "    };\n",
+              "    // Register the callback with on_msg.\n",
+              "    comm.on_msg(function (msg) {\n",
+              "        //console.log('receiving', msg['content']['data'], msg);\n",
+              "        var data = msg['content']['data'];\n",
+              "        if (data['blob'] !== undefined) {\n",
+              "            data = {\n",
+              "                data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
+              "            };\n",
+              "        }\n",
+              "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+              "        ws.onmessage(data);\n",
+              "    });\n",
+              "    return ws;\n",
+              "};\n",
+              "\n",
+              "mpl.mpl_figure_comm = function (comm, msg) {\n",
+              "    // This is the function which gets called when the mpl process\n",
+              "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+              "\n",
+              "    var id = msg.content.data.id;\n",
+              "    // Get hold of the div created by the display call when the Comm\n",
+              "    // socket was opened in Python.\n",
+              "    var element = document.getElementById(id);\n",
+              "    var ws_proxy = comm_websocket_adapter(comm);\n",
+              "\n",
+              "    function ondownload(figure, _format) {\n",
+              "        window.open(figure.canvas.toDataURL());\n",
+              "    }\n",
+              "\n",
+              "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
+              "\n",
+              "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+              "    // web socket which is closed, not our websocket->open comm proxy.\n",
+              "    ws_proxy.onopen();\n",
+              "\n",
+              "    fig.parent_element = element;\n",
+              "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+              "    if (!fig.cell_info) {\n",
+              "        console.error('Failed to find cell for figure', id, fig);\n",
+              "        return;\n",
+              "    }\n",
+              "    fig.cell_info[0].output_area.element.on(\n",
+              "        'cleared',\n",
+              "        { fig: fig },\n",
+              "        fig._remove_fig_handler\n",
+              "    );\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
+              "    var width = fig.canvas.width / fig.ratio;\n",
+              "    fig.cell_info[0].output_area.element.off(\n",
+              "        'cleared',\n",
+              "        fig._remove_fig_handler\n",
+              "    );\n",
+              "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
+              "\n",
+              "    // Update the output cell to use the data from the current canvas.\n",
+              "    fig.push_to_output();\n",
+              "    var dataURL = fig.canvas.toDataURL();\n",
+              "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+              "    // the notebook keyboard shortcuts fail.\n",
+              "    IPython.keyboard_manager.enable();\n",
+              "    fig.parent_element.innerHTML =\n",
+              "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+              "    fig.close_ws(fig, msg);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
+              "    fig.send_message('closing', msg);\n",
+              "    // fig.ws.close()\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
+              "    // Turn the data on the canvas into data in the output cell.\n",
+              "    var width = this.canvas.width / this.ratio;\n",
+              "    var dataURL = this.canvas.toDataURL();\n",
+              "    this.cell_info[1]['text/html'] =\n",
+              "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.updated_canvas_event = function () {\n",
+              "    // Tell IPython that the notebook contents must change.\n",
+              "    IPython.notebook.set_dirty(true);\n",
+              "    this.send_message('ack', {});\n",
+              "    var fig = this;\n",
+              "    // Wait a second, then push the new image to the DOM so\n",
+              "    // that it is saved nicely (might be nice to debounce this).\n",
+              "    setTimeout(function () {\n",
+              "        fig.push_to_output();\n",
+              "    }, 1000);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._init_toolbar = function () {\n",
+              "    var fig = this;\n",
+              "\n",
+              "    var toolbar = document.createElement('div');\n",
+              "    toolbar.classList = 'btn-toolbar';\n",
+              "    this.root.appendChild(toolbar);\n",
+              "\n",
+              "    function on_click_closure(name) {\n",
+              "        return function (_event) {\n",
+              "            return fig.toolbar_button_onclick(name);\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    function on_mouseover_closure(tooltip) {\n",
+              "        return function (event) {\n",
+              "            if (!event.currentTarget.disabled) {\n",
+              "                return fig.toolbar_button_onmouseover(tooltip);\n",
+              "            }\n",
+              "        };\n",
+              "    }\n",
+              "\n",
+              "    fig.buttons = {};\n",
+              "    var buttonGroup = document.createElement('div');\n",
+              "    buttonGroup.classList = 'btn-group';\n",
+              "    var button;\n",
+              "    for (var toolbar_ind in mpl.toolbar_items) {\n",
+              "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+              "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+              "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+              "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+              "\n",
+              "        if (!name) {\n",
+              "            /* Instead of a spacer, we start a new button group. */\n",
+              "            if (buttonGroup.hasChildNodes()) {\n",
+              "                toolbar.appendChild(buttonGroup);\n",
+              "            }\n",
+              "            buttonGroup = document.createElement('div');\n",
+              "            buttonGroup.classList = 'btn-group';\n",
+              "            continue;\n",
+              "        }\n",
+              "\n",
+              "        button = fig.buttons[name] = document.createElement('button');\n",
+              "        button.classList = 'btn btn-default';\n",
+              "        button.href = '#';\n",
+              "        button.title = name;\n",
+              "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
+              "        button.addEventListener('click', on_click_closure(method_name));\n",
+              "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
+              "        buttonGroup.appendChild(button);\n",
+              "    }\n",
+              "\n",
+              "    if (buttonGroup.hasChildNodes()) {\n",
+              "        toolbar.appendChild(buttonGroup);\n",
+              "    }\n",
+              "\n",
+              "    // Add the status bar.\n",
+              "    var status_bar = document.createElement('span');\n",
+              "    status_bar.classList = 'mpl-message pull-right';\n",
+              "    toolbar.appendChild(status_bar);\n",
+              "    this.message = status_bar;\n",
+              "\n",
+              "    // Add the close button to the window.\n",
+              "    var buttongrp = document.createElement('div');\n",
+              "    buttongrp.classList = 'btn-group inline pull-right';\n",
+              "    button = document.createElement('button');\n",
+              "    button.classList = 'btn btn-mini btn-primary';\n",
+              "    button.href = '#';\n",
+              "    button.title = 'Stop Interaction';\n",
+              "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
+              "    button.addEventListener('click', function (_evt) {\n",
+              "        fig.handle_close(fig, {});\n",
+              "    });\n",
+              "    button.addEventListener(\n",
+              "        'mouseover',\n",
+              "        on_mouseover_closure('Stop Interaction')\n",
+              "    );\n",
+              "    buttongrp.appendChild(button);\n",
+              "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
+              "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
+              "    var fig = event.data.fig;\n",
+              "    if (event.target !== this) {\n",
+              "        // Ignore bubbled events from children.\n",
+              "        return;\n",
+              "    }\n",
+              "    fig.close_ws(fig, {});\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._root_extra_style = function (el) {\n",
+              "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
+              "    // this is important to make the div 'focusable\n",
+              "    el.setAttribute('tabindex', 0);\n",
+              "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+              "    // off when our div gets focus\n",
+              "\n",
+              "    // location in version 3\n",
+              "    if (IPython.notebook.keyboard_manager) {\n",
+              "        IPython.notebook.keyboard_manager.register_events(el);\n",
+              "    } else {\n",
+              "        // location in version 2\n",
+              "        IPython.keyboard_manager.register_events(el);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
+              "    // Check for shift+enter\n",
+              "    if (event.shiftKey && event.which === 13) {\n",
+              "        this.canvas_div.blur();\n",
+              "        // select the cell after this one\n",
+              "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
+              "        IPython.notebook.select(index + 1);\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
+              "    fig.ondownload(fig, null);\n",
+              "};\n",
+              "\n",
+              "mpl.find_output_cell = function (html_output) {\n",
+              "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+              "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+              "    // IPython event is triggered only after the cells have been serialised, which for\n",
+              "    // our purposes (turning an active figure into a static one), is too late.\n",
+              "    var cells = IPython.notebook.get_cells();\n",
+              "    var ncells = cells.length;\n",
+              "    for (var i = 0; i < ncells; i++) {\n",
+              "        var cell = cells[i];\n",
+              "        if (cell.cell_type === 'code') {\n",
+              "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
+              "                var data = cell.output_area.outputs[j];\n",
+              "                if (data.data) {\n",
+              "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+              "                    data = data.data;\n",
+              "                }\n",
+              "                if (data['text/html'] === html_output) {\n",
+              "                    return [cell, data, j];\n",
+              "                }\n",
+              "            }\n",
+              "        }\n",
+              "    }\n",
+              "};\n",
+              "\n",
+              "// Register the function which deals with the matplotlib target/channel.\n",
+              "// The kernel may be null if the page has been refreshed.\n",
+              "if (IPython.notebook.kernel !== null) {\n",
+              "    IPython.notebook.kernel.comm_manager.register_target(\n",
+              "        'matplotlib',\n",
+              "        mpl.mpl_figure_comm\n",
+              "    );\n",
+              "}\n"
+            ],
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/html": [
+              "<img src=\"data:image/png;base64,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\" width=\"1200\">"
+            ],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# Print figure comparing results\n",
+        "fig, ax = plt.subplots(1,1,figsize=(12,8))\n",
+        "results_qaoa.plot_cost(ax=ax,label='Original')\n",
+        "results_sv.plot_cost(ax=ax,color='green',label='Statevector Simulator')\n",
+        "results_shot.plot_cost(ax=ax,color='red',label='Shot Simulator')\n",
+        "results_noisy_shot.plot_cost(ax=ax,color='orange',label='Noisy Shot Simulator')\n",
+        "results_annealing.plot_cost(ax=ax,color='black',label='Annealing Simulator')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xcOyfF4URRQ4"
+      },
+      "source": [
+        "# Acknowledgments\n",
+        "\n",
+        "🎉🎉🎉\n",
+        "\n",
+        "Special thanks to Entropica Labs for helping us create this challenge and being able to use their SDK, OpenQAOA. If you want to know more about OpenQAOA or ask them questions directly, check out their [discord channel](discord.gg/ana76wkKBd).\n",
+        "\n",
+        "🎉🎉🎉"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "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.8.13"
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/hackathon/IBM_challenge.ipynb b/hackathon/IBM_challenge.ipynb
new file mode 100644
index 0000000..dee7d9f
--- /dev/null
+++ b/hackathon/IBM_challenge.ipynb
@@ -0,0 +1,185 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Challenge: IBM\n",
+        "### Team # 32\n",
+        "### Team Members\n",
+        "- Ayelen Perez | Argentina\n",
+        "- Jefferson Granizo | Ecuador\n",
+        "- Jesus Montemayor | Perú\n",
+        "- Rubén Guzman | México\n",
+        "- Andres Diaz | Puerto Rico\n",
+        "\n",
+        "\n",
+        "\n",
+        "# Quantum Investor: Exploring the Fusion of Blockchain and Quantum Computing\n",
+        "\n",
+        "**Introduction**:\n",
+        "\n",
+        "At the exciting intersection of blockchain investment and quantum computing emerges \"Quantum Investor,\" an educational game designed for high school students. This innovative game provides a unique opportunity to explore advanced concepts playfully and educationally, allowing young adventurers to delve into the intriguing world of quantum physics and blockchain investment strategies.\n",
+        "\n",
+        "**Game Description:**\n",
+        "\n",
+        "\"Quantum Investor\" invites you to take on the role of a savvy investor in the fascinating realm of quantum blockchains. Armed with financial knowledge and quantum cryptography strategies, you will face exciting challenges while optimizing your investment and safeguarding the integrity of a blockchain against quantum threats.\n",
+        "\n",
+        "**How It Works:**\n",
+        "\n",
+        "The game presents players with the ability to apply a quantum gate, in this case, the famous Hadamard gate, to strengthen the security and reliability of the blockchain. The application of this gate generates quantum properties such as superposition that enhance the blockchain's resistance to attacks. Participants also have the opportunity to simulate quantum attacks, providing a practical understanding of how threats can impact blockchain security and, ultimately, the investment.\n",
+        "\n",
+        "**Code Development:**\n",
+        "\n",
+        "The game was developed using IBM's Qiskit quantum programming language, a leading tool in quantum computing research and development.\n",
+        "The code is structured modularly to facilitate understanding and allow for future educational expansions. In addition, didactic explanations were incorporated into the game to help students understand why applying a quantum gate improves blockchain security and, consequently, investment performance.\n",
+        "\n",
+        "**Educational Objectives:**\n",
+        "\n",
+        "\"Quantum Investor\" aims to achieve the following educational objectives:\n",
+        "\n",
+        "* ***Basics of Quantum Physics:*** Participants will learn fundamental concepts of quantum physics, such as superposition and quantum entanglement.\n",
+        "\n",
+        "* ***Quantum Investment Strategies:*** They will experience the importance of investment strategies in the context of quantum blockchains, understanding how quantum techniques can impact investment profitability.\n",
+        "\n",
+        "* ***Quantum Programming:*** Players will become familiar with quantum programming using Qiskit, gaining practical insights into designing and executing quantum algorithms for game development.\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "**Conclusion:**\n",
+        "\n",
+        "\"Quantum Investor\" offers an educational experience to ignite students' interest in the exciting intersection of quantum physics and blockchain investment strategies. This game demonstrates that learning about emerging technologies and finance can be fun and accessible, preparing the next generation for the challenges and opportunities of the digital future.\n",
+        "Embark on this thrilling educational adventure and discover the fascinating intersection of finance and quantum computing.\n",
+        "\n",
+        "# Welcome to \"Quantum Investor\"!\n",
+        "\n",
+        "Supporting Tools: ChatGPT"
+      ],
+      "metadata": {
+        "id": "crT2z7MxQhov"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "a0s5Spg6cdCs"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install qiskit[all]\n",
+        "!pip install qiskit-aer"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "7SvM-F6Dcnoh"
+      },
+      "outputs": [],
+      "source": [
+        "import random\n",
+        "from qiskit import QuantumCircuit, Aer, execute\n",
+        "\n",
+        "# Configuración del juego\n",
+        "quantum_bits = 8\n",
+        "blockchain_security = 60\n",
+        "\n",
+        "# Crear qubits cuánticos y registro clásico\n",
+        "qc = QuantumCircuit(quantum_bits, quantum_bits)\n",
+        "\n",
+        "# Variables globales para seguimiento\n",
+        "investment = 1000\n",
+        "current_security_level = blockchain_security\n",
+        "\n",
+        "# Función para aplicar una puerta cuántica de seguridad\n",
+        "def apply_security_gate(qc, level):\n",
+        "    for i in range(quantum_bits):\n",
+        "        for _ in range(level):\n",
+        "            qc.h(i)\n",
+        "\n",
+        "# Función para simular un ataque cuántico\n",
+        "def simulate_quantum_attack(qc):\n",
+        "    for i in range(quantum_bits):\n",
+        "        if random.random() < 0.2:\n",
+        "            qc.measure(i, i)\n",
+        "\n",
+        "# Función para calcular el nivel de seguridad\n",
+        "def calculate_security_level(success_rate):\n",
+        "    return int(blockchain_security * (1 - success_rate))\n",
+        "\n",
+        "# Función para mostrar el estado actual\n",
+        "def show_game_state():\n",
+        "    print(f\"Inversión actual: {investment} créditos\")\n",
+        "    print(f\"Nivel de seguridad de la blockchain: {current_security_level}\")\n",
+        "    print(f\"Qubits cuánticos: {quantum_bits}\")\n",
+        "\n",
+        "# Función para ejecutar el juego\n",
+        "def run_game():\n",
+        "    global current_security_level, investment\n",
+        "\n",
+        "    while True:\n",
+        "        show_game_state()\n",
+        "\n",
+        "        # Opciones del jugador\n",
+        "        print(\"Opciones:\")\n",
+        "        print(\"1. Aplicar seguridad a la blockchain\")\n",
+        "        print(\"2. Simular ataque cuántico\")\n",
+        "        print(\"3. Salir del juego\")\n",
+        "\n",
+        "        choice = input(\"Elige una opción: \")\n",
+        "\n",
+        "        if choice == \"1\":\n",
+        "            # Explicación didáctica\n",
+        "            print(\"Al aplicar una puerta cuántica, como la compuerta Hadamard, a los qubits de la blockchain,\")\n",
+        "            print(\"se generan propiedades cuánticas que fortalecen su seguridad.\")\n",
+        "            print(\"La compuerta Hadamard se utiliza para crear superposiciones, lo que hace que sea más difícil para\")\n",
+        "            print(\"los atacantes predecir la información en los qubits, mejorando así la seguridad.\")\n",
+        "            apply_security_gate(qc, 1)\n",
+        "            current_security_level += 10\n",
+        "            investment -= 100\n",
+        "        elif choice == \"2\":\n",
+        "            if choice == \"2\":\n",
+        "                qc.measure(range(quantum_bits), range(quantum_bits))\n",
+        "                backend = Aer.get_backend('qasm_simulator')\n",
+        "                job = execute(qc, backend, shots=1024)\n",
+        "                result = job.result()\n",
+        "\n",
+        "                simulate_quantum_attack(qc)\n",
+        "                counts = result.get_counts()\n",
+        "                success_rate = counts.get('0', 0) / 1024\n",
+        "                new_security_level = calculate_security_level(success_rate)\n",
+        "\n",
+        "                # Determinar el resultado del ataque\n",
+        "                if current_security_level > 80:\n",
+        "                    print(\"¡La blockchain es segura!\")\n",
+        "                else:\n",
+        "                    print(\"¡La blockchain ha sido comprometida!\")\n",
+        "\n",
+        "                # Actualizar la inversión en función de los resultados del ataque\n",
+        "                investment += 100 if new_security_level > 80 else -100\n",
+        "        elif choice == \"3\":\n",
+        "            break\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    run_game()\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file