diff --git a/.gitignore b/.gitignore
index b97d95b..008eb2f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,8 +1,11 @@
 Trotter/*
+notebooks/Trotter/*
 QSP/*
+notebooks/QSP/*
 .ipynb*
 *.sh
 GSE/*
+notebooks/GSE/*
 *.zip
 qasm_circuits/*
 
diff --git a/RuClExample.ipynb b/RuClExample.ipynb
deleted file mode 100644
index 4a85b24..0000000
--- a/RuClExample.ipynb
+++ /dev/null
@@ -1,1069 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "e5f96d16-ff66-4a0c-b801-5b9eda3a4efc",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "# RuCl Full Scale Example\n",
-    "We can now implement a full scale example, with details described here https://www.nature.com/articles/s41535-019-0203-y"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "38469f7e-7a4f-4efb-8dc4-e4d36186ab3d",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "import networkx as nx\n",
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "import random\n",
-    "import time\n",
-    "import sys\n",
-    "import os\n",
-    "import openfermion\n",
-    "from openfermion.circuits import trotter\n",
-    "import re\n",
-    "import pandas as pd\n",
-    "\n",
-    "import cirq\n",
-    "from cirq.contrib.svg import SVGCircuit\n",
-    "from cirq.contrib     import qasm_import\n",
-    "\n",
-    "import pyLIQTR.QSP.gen_qsp                 as qspFuncs\n",
-    "import pyLIQTR.QSP.QSP                     as pQSP\n",
-    "\n",
-    "from pyLIQTR.QSP.Hamiltonian             import Hamiltonian as pyH\n",
-    "from pyLIQTR.QSP.qsp_helpers             import qsp_decompose_once, print_to_openqasm, prettyprint_qsp_to_qasm # these should move to a utils.\n",
-    "from pyLIQTR.gate_decomp.cirq_transforms import clifford_plus_t_direct_transform\n",
-    "from pyLIQTR.utils.utils                 import count_T_gates, open_fermion_to_qasm"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "5d41c521-fa39-4ffd-9704-b60d4932e4da",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "##defining helper functions\n",
-    "t_init = time.perf_counter()\n",
-    "def get_T_depth_wire(cpt_circuit):\n",
-    "    #maximum number of T-gates on a wire.  This may be more optimistic than\n",
-    "    #number of layers with T-gates.  Perhaps good to treat as lower bound\n",
-    "    #for an implementation\n",
-    "    count_dict = dict()\n",
-    "    for moment in cpt_circuit:\n",
-    "        for operator in moment:\n",
-    "            opstr = str(operator)\n",
-    "            if opstr[0] == 'T':\n",
-    "                reg_label = opstr[opstr.find(\"(\")+1:opstr.find(\")\")]\n",
-    "                if not reg_label in count_dict:\n",
-    "                    count_dict[reg_label] = 1\n",
-    "                else:\n",
-    "                    count_dict[reg_label] += 1\n",
-    "    max_depth=0\n",
-    "    for register in count_dict:\n",
-    "        if count_dict[register] > max_depth:\n",
-    "            max_depth = count_dict[register]\n",
-    "    return max_depth\n",
-    "\n",
-    "def get_T_depth(cpt_circuit):\n",
-    "    t_depth = 0\n",
-    "    for moment in cpt_circuit:\n",
-    "        for operator in moment:\n",
-    "            opstr = str(operator)\n",
-    "            if opstr[0] == 'T':\n",
-    "                t_depth += 1\n",
-    "                break\n",
-    "    return t_depth\n",
-    "\n",
-    "def plot_T_step_histogram(cpt_circuit, lowest_ind=0, **kwargs):\n",
-    "    t_widths = [0] * (len(cpt_circuit))\n",
-    "    for (i, moment) in enumerate(cpt_circuit):\n",
-    "        width = 0\n",
-    "        for operator in moment:\n",
-    "            opstr = str(operator)\n",
-    "            if opstr[0] == 'T':\n",
-    "                width += 1\n",
-    "        t_widths[i] = width\n",
-    "    bins = range(max(t_widths))\n",
-    "    fig = plt.hist(t_widths, bins[lowest_ind:-1], **kwargs)\n",
-    "    return fig\n",
-    "    \n",
-    "def count_gates(cpt_circuit):\n",
-    "    count = 0\n",
-    "    for moment in cpt_circuit:\n",
-    "        for operator in moment:\n",
-    "            count += 1\n",
-    "    return count\n",
-    "\n",
-    "def pyliqtr_hamiltonian_to_openfermion_qubit_operator(H):\n",
-    "    open_fermion_operator = openfermion.QubitOperator()\n",
-    "    for term in H.terms:\n",
-    "        open_fermion_term = \"\"\n",
-    "        for (i,pauli) in enumerate(term[0]):\n",
-    "            if not pauli == 'I':\n",
-    "                open_fermion_term = open_fermion_term + pauli + str(i) + \" \"\n",
-    "        open_fermion_term_op = openfermion.QubitOperator(open_fermion_term)\n",
-    "        if not open_fermion_term == \"\":\n",
-    "            open_fermion_operator += term[1] * open_fermion_term_op\n",
-    "    return open_fermion_operator\n",
-    "\n",
-    "def flatten_nx_graph(g):\n",
-    "    new_ids = {}\n",
-    "    count = 0\n",
-    "    for node in g.nodes:\n",
-    "        if node in new_ids:\n",
-    "            pass\n",
-    "        else:\n",
-    "            new_ids[node] = count\n",
-    "            count = count + 1\n",
-    "    new_g = nx.relabel_nodes(g, new_ids)\n",
-    "    return new_g\n",
-    "\n",
-    "def estimate_qsp(pyliqtr_hamiltonian, timesteps, energy_precision, outdir, hamiltonian_name=\"hamiltonian\", write_circuits=False):\n",
-    "    timestep_of_interest=1 #for magnus like argument\n",
-    "    \n",
-    "    t0 = time.perf_counter()\n",
-    "    angles, tolerances = qspFuncs.compute_hamiltonian_angles(pyliqtr_hamiltonian, simtime=timestep_of_interest, req_prec=energy_precision)\n",
-    "    qsp_generator = pQSP.QSP(phis=angles, hamiltonian=pyliqtr_hamiltonian, target_size=pyliqtr_hamiltonian.problem_size)\n",
-    "    qsp_circuit = qsp_generator.circuit()\n",
-    "    t1 = time.perf_counter()\n",
-    "    elapsed = t1 - t0\n",
-    "    print(\"  Time to generate high level QSP circuit: \" + str(elapsed) + \" seconds\")\n",
-    "    \n",
-    "    if not os.path.exists(outdir):\n",
-    "        os.makedirs(outdir)\n",
-    "    \n",
-    "    subcircuit_counts = dict()\n",
-    "    t_counts = dict()\n",
-    "    t_depths = dict()\n",
-    "    t_depth_wires = dict()\n",
-    "    clifford_counts = dict()\n",
-    "    gate_counts = dict()\n",
-    "    subcircuit_depths = dict()\n",
-    "    \n",
-    "    outfile_qasm_high_level = outdir + hamiltonian_name + \"_high_level.qasm\"\n",
-    "    outfile_data = outdir + hamiltonian_name + \"_high_level.dat\"\n",
-    "    \n",
-    "    for moment in qsp_circuit:\n",
-    "        for operation in moment:\n",
-    "            gate_type = type(operation.gate)\n",
-    "            if gate_type in subcircuit_counts:\n",
-    "                subcircuit_counts[gate_type] += 1\n",
-    "            \n",
-    "            else:\n",
-    "                outfile_qasm_decomposed = outdir+str(gate_type)[8:-2]+\".decomposed.qasm\"\n",
-    "                outfile_qasm_cpt = outdir+str(gate_type)[8:-2]+\".cpt.qasm\"\n",
-    "                \n",
-    "                t0 = time.perf_counter()\n",
-    "                decomposed_circuit = qsp_decompose_once(qsp_decompose_once(cirq.Circuit(operation)))\n",
-    "                t1 = time.perf_counter()\n",
-    "                elapsed = t1 - t0\n",
-    "                print(\"    Time to decompose high level \" + str(gate_type)[8:-2] +\" circuit: \" + str(elapsed) + \" seconds\")\n",
-    "                \n",
-    "                t0 = time.perf_counter()\n",
-    "                cpt_circuit = clifford_plus_t_direct_transform(decomposed_circuit)\n",
-    "                t1 = time.perf_counter()\n",
-    "                elapsed = t1 - t0\n",
-    "                print(\"    Time to transform decomposed \" + str(gate_type)[8:-2] + \" circuit to Clifford+T: \" + str(elapsed) + \" seconds\")\n",
-    "                \n",
-    "                if write_circuits:\n",
-    "                    with open(outfile_qasm_decomposed, 'w') as f:\n",
-    "                        print_to_openqasm(f, decomposed_circuit, qubits=decomposed_circuit.all_qubits())\n",
-    "                    \n",
-    "                    with open(outfile_qasm_cpt, 'w') as f:\n",
-    "                        print_to_openqasm(f, cpt_circuit, qubits=cpt_circuit.all_qubits())\n",
-    "                \n",
-    "                subcircuit_counts[gate_type] = 1\n",
-    "                subcircuit_depths[gate_type] = len(cpt_circuit)\n",
-    "                t_counts[gate_type] = count_T_gates(cpt_circuit)\n",
-    "                gate_counts[gate_type] = count_gates(cpt_circuit)\n",
-    "                t_depths[gate_type] = get_T_depth(cpt_circuit)\n",
-    "                t_depth_wires[gate_type] = get_T_depth_wire(cpt_circuit)\n",
-    "                clifford_counts[gate_type] = gate_counts[gate_type] - t_counts[gate_type]\n",
-    "                \n",
-    "    total_gate_count = 0\n",
-    "    total_gate_depth = 0\n",
-    "    total_T_depth = 0\n",
-    "    total_T_depth_wire = 0\n",
-    "    total_T_count = 0\n",
-    "    total_clifford_count = 0\n",
-    "    for gate in subcircuit_counts:\n",
-    "        total_gate_count += subcircuit_counts[gate] * gate_counts[gate] * timesteps / timestep_of_interest\n",
-    "        total_gate_depth += subcircuit_counts[gate] * subcircuit_depths[gate] * timesteps / timestep_of_interest\n",
-    "        total_T_depth += subcircuit_counts[gate] * t_depths[gate] * timesteps / timestep_of_interest\n",
-    "        total_T_depth_wire += subcircuit_counts[gate] * t_depth_wires[gate] * timesteps / timestep_of_interest\n",
-    "        total_T_count += subcircuit_counts[gate] * t_counts[gate] * timesteps / timestep_of_interest\n",
-    "        total_clifford_count += subcircuit_counts[gate] * clifford_counts[gate] * timesteps / timestep_of_interest\n",
-    "    with open(outfile_data, 'w') as f:\n",
-    "        total_gate_count \n",
-    "        f.write(str(\"Logical Qubit Count:\"+str(len(qsp_circuit.all_qubits()))+\"\\n\"))\n",
-    "        f.write(str(\"Total Gate Count:\"+str(total_gate_count)+\"\\n\"))\n",
-    "        f.write(str(\"Total Gate Depth:\"+str(total_gate_depth)+\"\\n\"))\n",
-    "        f.write(str(\"Total T Count:\"+str(total_T_count)+\"\\n\"))\n",
-    "        f.write(str(\"Total T Depth:\"+str(total_T_depth)+\"\\n\"))\n",
-    "        f.write(str(\"Maximum T Count on Single Wire:\"+str(total_T_depth_wire)+\"\\n\"))\n",
-    "        f.write(str(\"Total Clifford Count:\"+str(total_clifford_count)+\"\\n\"))\n",
-    "        f.write(\"Subcircuit Info:\\n\")\n",
-    "        for gate in subcircuit_counts:\n",
-    "            f.write(str(str(gate)+\"\\n\"))\n",
-    "            f.write(str(\"Subcircuit Occurrences:\"+str(subcircuit_counts[gate]*timesteps)+\"\\n\"))\n",
-    "            f.write(str(\"Gate Count:\"+str(gate_counts[gate])+\"\\n\"))\n",
-    "            f.write(str(\"Gate Depth:\"+str(subcircuit_depths[gate])+\"\\n\"))\n",
-    "            f.write(str(\"T Count:\"+str(t_counts[gate])+\"\\n\"))\n",
-    "            f.write(str(\"T Depth:\"+str(t_depths[gate])+\"\\n\"))\n",
-    "            f.write(str(\"Maximum T Count on a Single Wire:\"+str(t_depth_wires[gate])+\"\\n\"))\n",
-    "            f.write(str(\"Clifford Count:\"+str(clifford_counts[gate])+\"\\n\"))\n",
-    "    return qsp_circuit\n",
-    "\n",
-    "def find_hamiltonian_ordering(of_hamiltonian):\n",
-    "    \"\"\"\n",
-    "    Function to generate a near optimal term ordering for trotterization of transverse field Ising Models.\n",
-    "    This would need to be modified if there were multi-qubit interactions that were not just ZZ\n",
-    "    \"\"\"\n",
-    "    #ordering hamiltonian terms by performing edge coloring to make optimal trotter ordering\n",
-    "    #assuming that any 2 body interactions are ZZ\n",
-    "    sorted_terms = sorted(list(of_hamiltonian.terms.keys()))\n",
-    "    sorted_terms.sort(key=lambda x: len(x) * 100 + ord(x[0][1])) #Z and X get translated to 90 and 88 respectively, multiplying by 100 ensures interacting term weight is considered\n",
-    "    one_body_terms_ordered = list(filter(lambda x: len(x) == 1, sorted_terms))\n",
-    "    two_body_terms = list(filter(lambda x: len(x) == 2, sorted_terms))\n",
-    "    \n",
-    "    #assigning edge colorings to order two body terms\n",
-    "    g = nx.Graph()\n",
-    "    for term in two_body_terms:\n",
-    "        edge = (term[0][0], term[1][0])\n",
-    "        g.add_edge(*edge)\n",
-    "    edge_coloring = nx.greedy_color(nx.line_graph(g))\n",
-    "    nx.set_edge_attributes(g, edge_coloring, \"color\")\n",
-    "    colors = list()\n",
-    "    for (i,term) in enumerate(two_body_terms):\n",
-    "        n1,n2 = (term[0][0], term[1][0])\n",
-    "        color = g.edges[n1,n2]['color']\n",
-    "        term = (*term, color)\n",
-    "        two_body_terms[i] = term\n",
-    "    \n",
-    "    two_body_terms.sort(key=lambda x: x[2])\n",
-    "    two_body_terms_ordered = list()\n",
-    "    for (i,term) in enumerate(two_body_terms):\n",
-    "        new_item = (term[0],term[1])\n",
-    "        two_body_terms_ordered.append((term[0], term[1]))\n",
-    "    return one_body_terms_ordered + two_body_terms_ordered\n",
-    "\n",
-    "def estimate_trotter(openfermion_hamiltonian,timesteps, energy_precision, outdir, hamiltonian_name=\"hamiltonian\", write_circuits=False):\n",
-    "    t0 = time.perf_counter()\n",
-    "    nsteps = openfermion.circuits.trotter_steps_required(trotter_error_bound = openfermion.circuits.error_bound(list(openfermion_hamiltonian.get_operators()),tight=False),\n",
-    "                                                time = timesteps, \n",
-    "                                                energy_precision = energy_precision)\n",
-    "    t1 = time.perf_counter()\n",
-    "    elapsed = t1 - t0\n",
-    "    print(\"  Time to estimate Number of steps required: \" + str(elapsed) + \" seconds\")\n",
-    "    \n",
-    "    t0 = time.perf_counter()\n",
-    "    term_ordering = find_hamiltonian_ordering(openfermion_hamiltonian)\n",
-    "    t1 = time.perf_counter()\n",
-    "    elapsed = t1 - t0\n",
-    "    print(\"  Time to find term ordering: \" + str(elapsed) + \" seconds\")\n",
-    "    \n",
-    "    t0 = time.perf_counter()\n",
-    "    trotter_circuit_of = openfermion.circuits.trotter_exp_to_qgates.trotterize_exp_qubop_to_qasm(openfermion_hamiltonian, trotter_order=2, evolution_time=timesteps/nsteps, term_ordering=term_ordering)\n",
-    "    t1 = time.perf_counter()\n",
-    "    elapsed = t1 - t0\n",
-    "    print(\"  Time to generate trotter circuit from openfermion: \" + str(elapsed) + \" seconds\")\n",
-    "    \n",
-    "    qasm_str_trotter = open_fermion_to_qasm(openfermion.count_qubits(openfermion_hamiltonian), trotter_circuit_of)\n",
-    "    trotter_circuit_qasm = qasm_import.circuit_from_qasm(qasm_str_trotter)\n",
-    "    \n",
-    "    t0 = time.perf_counter()\n",
-    "    cpt_trotter = clifford_plus_t_direct_transform(trotter_circuit_qasm)\n",
-    "    t1 = time.perf_counter()\n",
-    "    elapsed = t1 - t0\n",
-    "    print(\"  Time to decompose trotter to Clifford + T: \" + str(elapsed) + \" seconds\")\n",
-    "    \n",
-    "    #writing the the higher level trotter circuit to a file as well as the clifford + T circuit\n",
-    "    if not os.path.exists(outdir):\n",
-    "        os.makedirs(outdir)\n",
-    "    \n",
-    "    if write_circuits:\n",
-    "        outfile_qasm_decomposed = outdir + \"trotter_circuit_\" + hamiltonian_name + \".qasm\" \n",
-    "        outfile_qasm_cpt = outdir + \"trotter_cpt_\" + hamiltonian_name + \".qasm\"\n",
-    "        with open(outfile_qasm_decomposed, 'w') as f:\n",
-    "            print_to_openqasm(f, trotter_circuit, qubits=trotter_circuit.all_qubits())\n",
-    "        with open(outfile_qasm_cpt, 'w') as f:\n",
-    "            print_to_openqasm(f, cpt_trotter, qubits=cpt_trotter.all_qubits())\n",
-    "    \n",
-    "    t0 = time.perf_counter()\n",
-    "    outfile_data = outdir + \"trotter_\" + hamiltonian_name + \".dat\"\n",
-    "    gate_count = count_gates(cpt_trotter)\n",
-    "    t_count = count_T_gates(cpt_trotter)\n",
-    "    t_depth = get_T_depth(cpt_trotter)\n",
-    "    t_depth_wire = get_T_depth_wire(cpt_trotter)\n",
-    "    with open(outfile_data, 'w') as f:\n",
-    "        f.write(\"Logical Qubit Count:\"+str(len(cpt_trotter.all_qubits()))+\"\\n\")\n",
-    "        f.write(\"Number of Trotter Steps Required (Loose Upper Bound):\"+ str(nsteps) +\"\\n\")\n",
-    "        f.write(\"Total T Depth:\"+str(t_depth * nsteps)+\"\\n\")\n",
-    "        f.write(\"Maximum T Count on a Single Wire:\"+str(t_depth_wire * nsteps)+\"\\n\")\n",
-    "        f.write(\"Single Step Gate Count:\"+str(gate_count)+\"\\n\")\n",
-    "        f.write(\"Single Step Gate Depth:\"+str(len(cpt_trotter))+\"\\n\")\n",
-    "        f.write(\"Single Step T Count:\"+str(t_count)+\"\\n\")\n",
-    "        f.write(\"Single Step T Depth:\"+str(t_depth)+\"\\n\")\n",
-    "        f.write(\"Single Step Maximum T Count on a Single Wire:\"+str(t_depth_wire)+\"\\n\")\n",
-    "        f.write(\"Single Step Clifford Count:\"+str(gate_count - t_count)+\"\\n\")\n",
-    "    \n",
-    "    t1 = time.perf_counter()\n",
-    "    elapsed = t1 - t0\n",
-    "    print(\"  Time to enumerate resource estimates: \" + str(elapsed) + \" seconds\")\n",
-    "    \n",
-    "    return cpt_trotter"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "0275aeb7-e4fc-4348-8256-e7aa5c0bef71",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def assign_hexagon_labels_rucl(g):\n",
-    "    for n1, n2 in g.edges:\n",
-    "        #start by making sure that the edges are ordered correctly\n",
-    "        r1,c1 = n1\n",
-    "        r2,c2 = n2\n",
-    "        if r2 - r1 < 0 or c2 - c1 < 0:\n",
-    "            swap_r2 = r1\n",
-    "            swap_c2 = c1\n",
-    "            r1 = r2\n",
-    "            c1 = c2\n",
-    "            r2 = swap_r2\n",
-    "            c2 = swap_c2\n",
-    "        \n",
-    "        #now that they are ordered correctly, we can assign labels\n",
-    "        label = ''\n",
-    "        if c1 == c2:\n",
-    "            label = 'Z1'\n",
-    "        elif (((r1 % 2) + (c1 % 2)) % 2 == 0):#apparently you can differentiate X and Y labels based off nx's node label parity.  Huh.\n",
-    "            label = 'Y1'\n",
-    "        else:\n",
-    "            label = 'X1'\n",
-    "        \n",
-    "        g[n1][n2]['label'] = label\n",
-    "       \n",
-    "    #Adding next nearest and next-next nearest neighbor edges and labels\n",
-    "    for n in g.nodes:\n",
-    "        r,c = n\n",
-    "        \n",
-    "        #next nearest neighbors\n",
-    "        if (r, c+2) in g:\n",
-    "            g.add_edge(n, (r, c+2), label = 'Z2')\n",
-    "        if (r+1, c+1) in g:\n",
-    "            g.add_edge(n, (r+1, c+1), label = \"Y2\")\n",
-    "        if (r-1, c+1) in g:\n",
-    "            g.add_edge(n, (r-1, c+1), label = \"X2\")\n",
-    "       \n",
-    "        #next-next nearest neighbors\n",
-    "        if (r+1, c) in g and not ((n, (r+1, c)) in g.edges):\n",
-    "            g.add_edge(n, (r+1,c), label = \"Z3\")\n",
-    "        if (r+1, c+2) in g and (r + c)%2 == 0:\n",
-    "            g.add_edge(n, (r+1, c+2), label=\"X3\")\n",
-    "        if (r-1, c+2) in g and (r + c)%2 == 1:\n",
-    "            g.add_edge(n, (r-1, c+2), label=\"Y3\")\n",
-    "\n",
-    "g_rucl = nx.generators.lattice.hexagonal_lattice_graph(3,3)\n",
-    "pos = nx.get_node_attributes(g_rucl, 'pos')\n",
-    "assign_hexagon_labels_rucl(g_rucl)\n",
-    "edge_labels = dict([((n1, n2), d['label']) for n1, n2, d in g_rucl.edges(data=True)]);\n",
-    "nx.draw(g_rucl, pos, with_labels=True)\n",
-    "nx.draw_networkx_edge_labels(g_rucl, pos,edge_labels = edge_labels);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "705727b5-1cc4-4da7-aa0f-06d08bf772d0",
-   "metadata": {
-    "tags": []
-   },
-   "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>reference</th>\n",
-       "      <th>method</th>\n",
-       "      <th>J1</th>\n",
-       "      <th>K1</th>\n",
-       "      <th>Gam1</th>\n",
-       "      <th>Gam_prime1</th>\n",
-       "      <th>J2</th>\n",
-       "      <th>K2</th>\n",
-       "      <th>J3</th>\n",
-       "      <th>K3</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>Winter et al. PRB</td>\n",
-       "      <td>Ab initio (DFT + exact diag.)</td>\n",
-       "      <td>-1.70</td>\n",
-       "      <td>-6.70</td>\n",
-       "      <td>6.60</td>\n",
-       "      <td>-0.90</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>2.7000</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>Winter et al. NC</td>\n",
-       "      <td>Ab initio-inspired (INS fit)</td>\n",
-       "      <td>-0.50</td>\n",
-       "      <td>-5.00</td>\n",
-       "      <td>2.50</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.5000</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>Wu et al.</td>\n",
-       "      <td>THz spectroscopy fit</td>\n",
-       "      <td>-0.35</td>\n",
-       "      <td>-2.80</td>\n",
-       "      <td>2.40</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.3400</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>Cookmeyer and Moore</td>\n",
-       "      <td>Magnon thermal Hall (sign)</td>\n",
-       "      <td>-0.50</td>\n",
-       "      <td>-5.00</td>\n",
-       "      <td>2.50</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.1125</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>Kim and Kee</td>\n",
-       "      <td>DFT + t=U expansion</td>\n",
-       "      <td>-1.53</td>\n",
-       "      <td>-6.55</td>\n",
-       "      <td>5.25</td>\n",
-       "      <td>-0.95</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>5</th>\n",
-       "      <td>Suzuki and Suga</td>\n",
-       "      <td>Magnetic specific heat</td>\n",
-       "      <td>-1.53</td>\n",
-       "      <td>-24.40</td>\n",
-       "      <td>5.25</td>\n",
-       "      <td>-0.95</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>6</th>\n",
-       "      <td>Yadav et al.</td>\n",
-       "      <td>Quantum chemistry (MRCI)</td>\n",
-       "      <td>1.20</td>\n",
-       "      <td>-5.60</td>\n",
-       "      <td>1.20</td>\n",
-       "      <td>-0.70</td>\n",
-       "      <td>0.25</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.2500</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>7</th>\n",
-       "      <td>Ran et al.</td>\n",
-       "      <td>Spin wave fit to INS gap</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>-6.80</td>\n",
-       "      <td>9.50</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>8</th>\n",
-       "      <td>Hou et al.</td>\n",
-       "      <td>Constrained DFT + U</td>\n",
-       "      <td>-1.87</td>\n",
-       "      <td>-10.70</td>\n",
-       "      <td>3.80</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>1.2700</td>\n",
-       "      <td>0.63</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>9</th>\n",
-       "      <td>Wang et al.</td>\n",
-       "      <td>DFT + t=U expansion</td>\n",
-       "      <td>-0.30</td>\n",
-       "      <td>-10.90</td>\n",
-       "      <td>6.10</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.0300</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>10</th>\n",
-       "      <td>Eichstaedt et al.</td>\n",
-       "      <td>Fully ab initio (DFT + cRPA + t=U)</td>\n",
-       "      <td>-1.40</td>\n",
-       "      <td>-14.30</td>\n",
-       "      <td>9.80</td>\n",
-       "      <td>-2.23</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>-0.63</td>\n",
-       "      <td>1.0000</td>\n",
-       "      <td>0.03</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>11</th>\n",
-       "      <td>Eichstaedt et al.</td>\n",
-       "      <td>Neglecting non-local Coulomb</td>\n",
-       "      <td>-0.20</td>\n",
-       "      <td>-4.50</td>\n",
-       "      <td>3.00</td>\n",
-       "      <td>-0.73</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>-0.33</td>\n",
-       "      <td>0.7000</td>\n",
-       "      <td>0.10</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>12</th>\n",
-       "      <td>Eichstaedt et al.</td>\n",
-       "      <td>Neglecting non-local SOC</td>\n",
-       "      <td>-1.30</td>\n",
-       "      <td>-13.30</td>\n",
-       "      <td>9.40</td>\n",
-       "      <td>-2.30</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>-0.67</td>\n",
-       "      <td>1.0000</td>\n",
-       "      <td>0.10</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>13</th>\n",
-       "      <td>Banerjee et al.</td>\n",
-       "      <td>Spin wave fit</td>\n",
-       "      <td>-4.60</td>\n",
-       "      <td>7.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>14</th>\n",
-       "      <td>Kim et al.</td>\n",
-       "      <td>DFT + t=U expansion</td>\n",
-       "      <td>-12.00</td>\n",
-       "      <td>17.00</td>\n",
-       "      <td>12.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>15</th>\n",
-       "      <td>Kim and Kee</td>\n",
-       "      <td>DFT + t=U expansion</td>\n",
-       "      <td>-3.50</td>\n",
-       "      <td>4.60</td>\n",
-       "      <td>6.42</td>\n",
-       "      <td>-0.04</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>16</th>\n",
-       "      <td>Winter et al.</td>\n",
-       "      <td>Ab initio (DFT + exact diag.)</td>\n",
-       "      <td>-5.50</td>\n",
-       "      <td>7.60</td>\n",
-       "      <td>8.40</td>\n",
-       "      <td>0.20</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>2.3000</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>17</th>\n",
-       "      <td>Ozel et al.</td>\n",
-       "      <td>Spin wave fit/THz spectroscopy</td>\n",
-       "      <td>-0.95</td>\n",
-       "      <td>1.15</td>\n",
-       "      <td>3.80</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>18</th>\n",
-       "      <td>Ozel et al.</td>\n",
-       "      <td>Spin wave fit/THz spectroscopy</td>\n",
-       "      <td>0.46</td>\n",
-       "      <td>-3.50</td>\n",
-       "      <td>2.35</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.00</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.00</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "              reference                              method     J1     K1  \\\n",
-       "0     Winter et al. PRB       Ab initio (DFT + exact diag.)  -1.70  -6.70   \n",
-       "1      Winter et al. NC        Ab initio-inspired (INS fit)  -0.50  -5.00   \n",
-       "2             Wu et al.                THz spectroscopy fit  -0.35  -2.80   \n",
-       "3   Cookmeyer and Moore          Magnon thermal Hall (sign)  -0.50  -5.00   \n",
-       "4           Kim and Kee                 DFT + t=U expansion  -1.53  -6.55   \n",
-       "5       Suzuki and Suga              Magnetic specific heat  -1.53 -24.40   \n",
-       "6          Yadav et al.            Quantum chemistry (MRCI)   1.20  -5.60   \n",
-       "7            Ran et al.            Spin wave fit to INS gap   0.00  -6.80   \n",
-       "8            Hou et al.                 Constrained DFT + U  -1.87 -10.70   \n",
-       "9           Wang et al.                 DFT + t=U expansion  -0.30 -10.90   \n",
-       "10    Eichstaedt et al.  Fully ab initio (DFT + cRPA + t=U)  -1.40 -14.30   \n",
-       "11    Eichstaedt et al.        Neglecting non-local Coulomb  -0.20  -4.50   \n",
-       "12    Eichstaedt et al.            Neglecting non-local SOC  -1.30 -13.30   \n",
-       "13      Banerjee et al.                       Spin wave fit  -4.60   7.00   \n",
-       "14           Kim et al.                 DFT + t=U expansion -12.00  17.00   \n",
-       "15          Kim and Kee                 DFT + t=U expansion  -3.50   4.60   \n",
-       "16        Winter et al.       Ab initio (DFT + exact diag.)  -5.50   7.60   \n",
-       "17          Ozel et al.      Spin wave fit/THz spectroscopy  -0.95   1.15   \n",
-       "18          Ozel et al.      Spin wave fit/THz spectroscopy   0.46  -3.50   \n",
-       "\n",
-       "     Gam1  Gam_prime1    J2    K2      J3    K3  \n",
-       "0    6.60       -0.90  0.00  0.00  2.7000  0.00  \n",
-       "1    2.50        0.00  0.00  0.00  0.5000  0.00  \n",
-       "2    2.40        0.00  0.00  0.00  0.3400  0.00  \n",
-       "3    2.50        0.00  0.00  0.00  0.1125  0.00  \n",
-       "4    5.25       -0.95  0.00  0.00  0.0000  0.00  \n",
-       "5    5.25       -0.95  0.00  0.00  0.0000  0.00  \n",
-       "6    1.20       -0.70  0.25  0.00  0.2500  0.00  \n",
-       "7    9.50        0.00  0.00  0.00  0.0000  0.00  \n",
-       "8    3.80        0.00  0.00  0.00  1.2700  0.63  \n",
-       "9    6.10        0.00  0.00  0.00  0.0300  0.00  \n",
-       "10   9.80       -2.23  0.00 -0.63  1.0000  0.03  \n",
-       "11   3.00       -0.73  0.00 -0.33  0.7000  0.10  \n",
-       "12   9.40       -2.30  0.00 -0.67  1.0000  0.10  \n",
-       "13   0.00        0.00  0.00  0.00  0.0000  0.00  \n",
-       "14  12.00        0.00  0.00  0.00  0.0000  0.00  \n",
-       "15   6.42       -0.04  0.00  0.00  0.0000  0.00  \n",
-       "16   8.40        0.20  0.00  0.00  2.3000  0.00  \n",
-       "17   3.80        0.00  0.00  0.00  0.0000  0.00  \n",
-       "18   2.35        0.00  0.00  0.00  0.0000  0.00  "
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "rucl_references = [\"Winter et al. PRB\", \"Winter et al. NC\", \"Wu et al.\", \"Cookmeyer and Moore\", \"Kim and Kee\", \"Suzuki and Suga\", \n",
-    "              \"Yadav et al.\", \"Ran et al.\", \"Hou et al.\", \"Wang et al.\", \"Eichstaedt et al.\", \"Eichstaedt et al.\", \n",
-    "              \"Eichstaedt et al.\", \"Banerjee et al.\", \"Kim et al.\", \"Kim and Kee\", \"Winter et al.\", \"Ozel et al.\", \"Ozel et al.\"]\n",
-    "\n",
-    "rucl_methods = [\"Ab initio (DFT + exact diag.)\", \"Ab initio-inspired (INS fit)\", \"THz spectroscopy fit\",\n",
-    "                \"Magnon thermal Hall (sign)\", \"DFT + t=U expansion\", \"Magnetic specific heat\", \"Quantum chemistry (MRCI)\",\n",
-    "                \"Spin wave fit to INS gap\", \"Constrained DFT + U\", \"DFT + t=U expansion\", \"Fully ab initio (DFT + cRPA + t=U)\",\n",
-    "                \"Neglecting non-local Coulomb\", \"Neglecting non-local SOC\", \"Spin wave fit\", \"DFT + t=U expansion\",\n",
-    "                \"DFT + t=U expansion\", \"Ab initio (DFT + exact diag.)\", \"Spin wave fit/THz spectroscopy\", \"Spin wave fit/THz spectroscopy\"]\n",
-    "\n",
-    "rucl_J1 = [-1.7, -0.5, -0.35, -0.5, -1.53, -1.53, 1.2, 0, -1.87, -0.3, -1.4, -0.2, -1.3, -4.6, -12, -3.5, -5.5, -0.95, 0.46]\n",
-    "rucl_K1 = [-6.7, -5.0, -2.8, -5.0, -6.55, -24.4, -5.6, -6.8, -10.7, -10.9, -14.3, -4.5, -13.3, 7.0, 17., 4.6, 7.6, 1.15, -3.5]\n",
-    "rucl_Gam1 = [6.6, 2.5, 2.4, 2.5, 5.25, 5.25, 1.2, 9.5, 3.8, 6.1, 9.8, 3.0, 9.4, 0, 12., 6.42, 8.4, 3.8, 2.35]\n",
-    "rucl_Gam_prime1 = [-0.9, 0, 0, 0, -0.95, -0.95, -0.7, 0, 0, 0, -2.23, -0.73, -2.3, 0, 0, -0.04, 0.2, 0, 0]\n",
-    "rucl_J2 = [0, 0, 0, 0, 0, 0, 0.25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
-    "rucl_K2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.63, -0.33, -0.67, 0, 0, 0, 0, 0, 0]\n",
-    "rucl_J3 = [2.7, 0.5, 0.34, 0.1125, 0, 0, 0.25, 0, 1.27, 0.03, 1.0, 0.7, 1.0, 0, 0, 0, 2.3, 0, 0]\n",
-    "rucl_K3 = [0, 0, 0, 0, 0, 0, 0, 0, 0.63, 0, 0.03, 0.1, 0.1, 0, 0, 0, 0, 0, 0]\n",
-    "\n",
-    "d_rucl = {'reference': rucl_references, 'method': rucl_methods, 'J1': rucl_J1, 'K1': rucl_K1,\n",
-    "          'Gam1': rucl_Gam1, 'Gam_prime1': rucl_Gam_prime1,\n",
-    "          'J2': rucl_J2, 'K2': rucl_K2, 'J3': rucl_J3, 'K3': rucl_K3}\n",
-    "df_rucl = pd.DataFrame(d_rucl)\n",
-    "df_rucl"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "c2c67168-10fb-4925-bbb4-a02013ec28f4",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "def nx_rucl_terms(g, data_series):\n",
-    "    H = []\n",
-    "    n = len(g.nodes)\n",
-    "    for (n1,n2,d) in g.edges(data=True):\n",
-    "        label = d['label'][0]\n",
-    "        distance = int(d['label'][1])\n",
-    "        \n",
-    "        #Heisenberg and Kitaev terms\n",
-    "        if distance == 1:\n",
-    "            weight_J = data_series.J1\n",
-    "        elif distance == 2:\n",
-    "            weight_J = data_series.J2\n",
-    "        else:\n",
-    "            weight_J = data_series.J3\n",
-    "        \n",
-    "        if distance == 1:\n",
-    "            weight_K = data_series.K1\n",
-    "        elif distance == 2:\n",
-    "            weight_K = data_series.K2\n",
-    "        else:\n",
-    "            weight_K = data_series.K3\n",
-    "        \n",
-    "        if not (weight_J == 0 and weight_K == 0):\n",
-    "            string_x = n*'I' \n",
-    "            string_y = n*'I' \n",
-    "            string_z = n*'I'\n",
-    "            \n",
-    "            weight_x = weight_J\n",
-    "            weight_y = weight_J\n",
-    "            weight_z = weight_J\n",
-    "            for i in [n1,n2]:\n",
-    "                string_x = string_x[:i] + 'X' + string_x[i+1:]\n",
-    "                string_y = string_y[:i] + 'Y' + string_y[i+1:]\n",
-    "                string_z = string_z[:i] + 'Z' + string_z[i+1:]\n",
-    "            if label == 'X':\n",
-    "                weight_x += weight_K\n",
-    "            elif label == 'Y':\n",
-    "                weight_y += weight_K\n",
-    "            else:\n",
-    "                weight_z += weight_K\n",
-    "            if weight_x != 0:\n",
-    "                H.append((string_x, weight_x))\n",
-    "            if weight_y != 0:\n",
-    "                H.append((string_y, weight_y))\n",
-    "            if weight_z != 0:\n",
-    "                H.append((string_z, weight_z))\n",
-    "            \n",
-    "        #Gamma Terms\n",
-    "        if distance == 1 and data_series.Gam1 != 0:\n",
-    "            string_gam1_1 = n*'I'\n",
-    "            string_gam1_2 = n*'I'\n",
-    "            #unwrapping loop since there is no ordering guarantee\n",
-    "            labels=['X', 'Y', 'Z']\n",
-    "            labels.remove(label)\n",
-    "            l1,l2 = labels\n",
-    "            string_gam1_1 = string_gam1_1[:n1] + l1 + string_gam1_1[n1+1:]\n",
-    "            string_gam1_1 = string_gam1_1[:n2] + l2 + string_gam1_1[n2+1:]\n",
-    "            \n",
-    "            string_gam1_2 = string_gam1_2[:n1] + l2 + string_gam1_2[n1+1:]\n",
-    "            string_gam1_2 = string_gam1_2[:n2] + l1 + string_gam1_2[n2+1:]\n",
-    "            \n",
-    "            H.append((string_gam1_1, data_series.Gam1))\n",
-    "            H.append((string_gam1_2, data_series.Gam1))\n",
-    "            \n",
-    "        #Gamma' Terms\n",
-    "        if distance == 1 and data_series.Gam_prime1 != 0:\n",
-    "            #unwrapping inner loop since there is no ordering guarantee\n",
-    "            labels=['X', 'Y', 'Z']\n",
-    "            labels.remove(label)\n",
-    "            for label_offset in labels:\n",
-    "                string_gam1_1 = n*'I'\n",
-    "                string_gam1_2 = n*'I'\n",
-    "                l1 = label\n",
-    "                l2 = label_offset\n",
-    "                \n",
-    "                string_gam1_1 = string_gam1_1[:n1] + l1 + string_gam1_1[n1+1:]\n",
-    "                string_gam1_1 = string_gam1_1[:n2] + l2 + string_gam1_1[n2+1:]\n",
-    "                string_gam1_2 = string_gam1_2[:n1] + l2 + string_gam1_2[n1+1:]\n",
-    "                string_gam1_2 = string_gam1_2[:n2] + l1 + string_gam1_2[n2+1:]\n",
-    "                H.append((string_gam1_1, data_series.Gam_prime1))\n",
-    "                H.append((string_gam1_2, data_series.Gam_prime1))\n",
-    "    return H\n",
-    "\n",
-    "def generate_time_varying_terms(g, s, x = lambda s: 0, y = lambda s: 0, z = lambda s: 0):\n",
-    "    assert callable(x)\n",
-    "    assert callable(y)\n",
-    "    assert callable(z)\n",
-    "    \n",
-    "    weight_x, weight_y, weight_z = x(s), y(s), z(s)\n",
-    "    n = len(g)\n",
-    "    H = []\n",
-    "    if not (weight_x == 0):\n",
-    "        for node in g.nodes:\n",
-    "            string_x = n*'I'\n",
-    "            string_x = string_x[:node] + 'X' + string_x[node+1:]\n",
-    "            H.append((string_x, weight_x))\n",
-    "    if not (weight_y == 0):\n",
-    "        for node in g.nodes:\n",
-    "            string_y = n*'I'\n",
-    "            string_y = string_y[:node] + 'y' + string_y[node+1:]\n",
-    "            H.append((string_y, weight_y))\n",
-    "    if not (weight_z == 0):\n",
-    "        for node in g.nodes:\n",
-    "            string_z = n*'I'\n",
-    "            string_z = string_z[:node] + 'z' + string_z[node+1:]\n",
-    "            H.append((string_z, weight_z))\n",
-    "    return H\n",
-    "\n",
-    "#using normalized time s = t_current / t_total to allow for more variation of total time\n",
-    "def generate_rucl_hamiltonian(lattice_size, data_series, s=0, field_x=lambda s: 0, field_y=lambda s: 0, field_z=lambda s: 0):\n",
-    "    g = nx.generators.lattice.hexagonal_lattice_graph(lattice_size,lattice_size)\n",
-    "    assign_hexagon_labels_rucl(g)\n",
-    "    g = flatten_nx_graph(g)\n",
-    "    H_constant = nx_rucl_terms(g, data_series)\n",
-    "    H_time_varied = generate_time_varying_terms(g, s, x=field_x, y = field_y, z = field_z)\n",
-    "    H = H_constant + H_time_varied\n",
-    "    return H"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "58ea9762-5b90-477b-9d20-fff664f8cf87",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Estimating RuCl row 13 using Trotterization\n",
-      "  Time to estimate Number of steps required: 58.982447494999995 seconds\n",
-      "  Time to find term ordering: 0.16902502400000685 seconds\n",
-      "  Time to generate trotter circuit from openfermion: 5.884000003675283e-06 seconds\n",
-      "  Time to decompose trotter to Clifford + T: 621.37379112 seconds\n",
-      "  Time to enumerate resource estimates: 41.273443928999995 seconds\n",
-      "Total time to estimate RuCl row 13: 754.742733289 seconds\n",
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "#Commenting out range, to avoid long runtimes.  This still takes ~20-30 minutes as written\n",
-    "for i in [13]:\n",
-    "#for i in range(19):\n",
-    "    #defining precision required for the trotterized circuit\n",
-    "    energy_precision = 1e-3\n",
-    "    figdir=\"Trotter/Figures/\"\n",
-    "    if not os.path.exists(figdir):\n",
-    "        os.makedirs(figdir)\n",
-    "    timesteps=1000\n",
-    "    H_rucl = generate_rucl_hamiltonian(32, df_rucl.iloc[i])\n",
-    "    H_rucl_pyliqtr = pyH(H_rucl)\n",
-    "    openfermion_hamiltonian_rucl = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_rucl_pyliqtr)\n",
-    "    \n",
-    "    print(\"Estimating RuCl row \" + str(i) + \" using Trotterization\")\n",
-    "    t0 = time.perf_counter()\n",
-    "    cpt_trotter_rucl = estimate_trotter(openfermion_hamiltonian_rucl, timesteps, energy_precision, \"Trotter/RuCl_circuits/\", hamiltonian_name=\"rucl_\" + str(i))\n",
-    "    t1 = time.perf_counter()\n",
-    "    elapsed = t1 - t0\n",
-    "    print(\"Total time to estimate RuCl row \" + str(i) + \": \" + str(elapsed) + \" seconds\\n\")\n",
-    "    \n",
-    "    plot_T_step_histogram(cpt_trotter_rucl)\n",
-    "    plt.title(\"trotter RuCl, row \" + str(i))\n",
-    "    plt.xlabel(\"T Width\")\n",
-    "    plt.ylabel(\"count\")\n",
-    "    plt.savefig(figdir + \"trotter_cpt_t_width_histogram_rucl_\" + str(i) + \".pdf\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "e2ccb7bf-252d-489f-b292-619549ba1e15",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Estimating RuCl row 13 using QSP\n",
-      "  Time to generate high level QSP circuit: 257.6114212550001 seconds\n",
-      "    Time to decompose high level cirq.ops.common_channels.ResetChannel circuit: 0.0004568480001125863 seconds\n",
-      "    Time to transform decomposed cirq.ops.common_channels.ResetChannel circuit to Clifford+T: 0.0003812750001088716 seconds\n",
-      "    Time to decompose high level cirq.ops.pauli_gates._PauliX circuit: 0.0002850809999017656 seconds\n",
-      "    Time to transform decomposed cirq.ops.pauli_gates._PauliX circuit to Clifford+T: 0.00010283599999638682 seconds\n",
-      "    Time to decompose high level cirq.ops.common_gates.Rx circuit: 0.00035275799996270507 seconds\n",
-      "    Time to transform decomposed cirq.ops.common_gates.Rx circuit to Clifford+T: 0.054105950999883135 seconds\n",
-      "    Time to decompose high level pyLIQTR.QSP.qsp_cirq_gates.SelectV circuit: 300.36175675699997 seconds\n",
-      "    Time to transform decomposed pyLIQTR.QSP.qsp_cirq_gates.SelectV circuit to Clifford+T: 1927.61035602 seconds\n",
-      "    Time to decompose high level pyLIQTR.QSP.qsp_cirq_gates.Reflect circuit: 0.8477977160000592 seconds\n",
-      "    Time to transform decomposed pyLIQTR.QSP.qsp_cirq_gates.Reflect circuit to Clifford+T: 7.592521574999864 seconds\n",
-      "Time to estimate RuCl row 13: 2670.952123478 seconds\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "#Commenting out range, to avoid long runtimes.  This still takes ~20-30 minutes as written\n",
-    "for i in [13]:\n",
-    "#for i in range(19):\n",
-    "    #defining precision required for the trotterized circuit\n",
-    "    energy_precision = 1e-3\n",
-    "    figdir=\"QSP/Figures/\"\n",
-    "    if not os.path.exists(figdir):\n",
-    "        os.makedirs(figdir)\n",
-    "    timesteps=1000\n",
-    "    H_rucl = generate_rucl_hamiltonian(32, df_rucl.iloc[i])\n",
-    "    H_rucl_pyliqtr = pyH(H_rucl)\n",
-    "    \n",
-    "    print(\"Estimating RuCl row \" + str(i) + \" using QSP\")\n",
-    "    t0 = time.perf_counter()\n",
-    "    #change to Clifford+T dictionary in future revision\n",
-    "    qsp_high_level_rucl = estimate_qsp(H_rucl_pyliqtr, timesteps, energy_precision, \"QSP/RuCl_circuits/\", hamiltonian_name=\"rucl_\" + str(i))\n",
-    "    t1 = time.perf_counter()\n",
-    "    elapsed = t1 - t0\n",
-    "    print(\"Time to estimate RuCl row \" + str(i) + \": \" + str(elapsed) + \" seconds\\n\")\n",
-    "    print()\n",
-    "    \n",
-    "    #plot_T_step_histogram(cpt_trotter_rucl)\n",
-    "    #plt.title(\"QSP RuCl, row \" + str(i))\n",
-    "    #plt.xlabel(\"T Width\")\n",
-    "    #plt.ylabel(\"count\")\n",
-    "    #plt.savefig(figdir + \"qsp_cpt_t_width_histogram_rucl_\" + str(i) + \".pdf\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "c39ea21d-6ed9-47a8-bbcb-42665a577b73",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Total time to run notebook (only using the fastest row): 3442.918268621\n"
-     ]
-    }
-   ],
-   "source": [
-    "t_end = time.perf_counter()\n",
-    "print(\"Total time to run notebook (only using the fastest row): \" + str(t_end - t_init))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2f256c6e-4063-458f-839d-29cb8f4d03d6",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.8"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/notebooks/MagneticLattices.ipynb b/notebooks/MagneticLattices.ipynb
index dcc8f5b..df31e76 100644
--- a/notebooks/MagneticLattices.ipynb
+++ b/notebooks/MagneticLattices.ipynb
@@ -45,9 +45,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/zain/anaconda3/lib/python3.11/site-packages/attr/_make.py:918: RuntimeWarning: Running interpreter doesn't sufficiently support code object introspection.  Some features like bare super() or accessing __class__ will not work with slotted classes.\n",
+      "  set_closure_cell(cell, cls)\n"
+     ]
+    }
+   ],
    "source": [
     "import os\n",
     "import random\n",
@@ -69,7 +78,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -86,7 +95,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -98,12 +107,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABwoUlEQVR4nO3deUCU9b4/8DcDgoI7iGmKpAgIgruoiIgKiIIKqeCYHavTbe/oybpmpzSzxbLtZtlps80RXAYVlFURd8QdkFVF3BIFF2Qf5vn90Y+5eW65zQzfmXner//uIZ/nfc8JefOZ5/t5rCRJkkBERERE9IAUogMQERERkXljoSQiIiIivbBQEhEREZFeWCiJiIiISC8slERERESkFxZKIiIiItILCyURERER6YWFkoiIiIj0wkJJRERERHphoSQiIiIivbBQEhEREZFeWCiJiIiISC8slERERESkFxZKIiIiItILCyURERER6YWFkoiIiIj0wkJJRERERHphoSQiIiIivbBQEhEREZFeWCiJiIiISC8slERERESkFxZKIiIiItILCyURERER6YWFkoiIiIj0wkJJRERERHphoSQiIiIivbBQEhEREZFeWCiJiIiISC8slERERESkFxZKIiIiItILCyURERER6YWFkoiIiIj0wkJJRERERHphoSQiIiIivbBQEhEREZFeWCiJiIiISC8slERERESkFxvRAYgsWXW9BqUV1WjQaGFro4CrowMc7PhtR0REloU/2YgMrPhyFdZklSGjsBxllTWQ/vA1KwAune0R5OGM2X4u6Nu1naiYREREBmMlSZJ093+MiO7mXGUNFsXnYHfJVVgrrNCk/etvreavB7g54b1IH/TsbN+CSYmIiAyLhZLIAGKzy7B4Sx40WumORfI/WSusYKOwwttTvBEzzMWICYmIiIyHhZJITyszirEitUjv6ywIcceLQX0NkIiIiKhl8ZQ3kR5is8sMUiYBYEVqEeKyywxyLSIiopbEQkn0gM5V1mDxljyDXvOtLXk4V1lj0GsSEREZGwsl0QNaFJ8DzX08L3kvNFoJi+JzDHpNIiIiY2OhJHoAxZersLvk6n0dwLkXTVoJu0uuoqS8yqDXJSIiMiYWSqIHsCarDNYKK6Nc21phhV8P8FlKIiIyHyyURA8go7Dc4NPJZk1aCRlF5Ua5NhERkTGwUBLdp1v1GpQZ+eBMWUUNqus1Rr0HERGRobBQEt2nsxXVMPbyVglAaUW1ke9CRERkGCyURPepQaO1qPsQERHpi4WS6D7Z2rTMt01L3YeIiEhf/IlFdJ9cHR1gnPPdfyTh1qUz4JtRiYjIHLBQEt0nBzsbuHS2N+o9mq7/hhFDB6FXr154/vnnsW3bNtTW1hr1nkRERA+KhZLoAQR5OBt1D+XckOFISUnBtGnTkJSUhMmTJ8PJyQlTp07Ft99+i4sXLxrl3kRERA/CSuJnakT3rfhyFYI/22W066fPHwM353YAAEmSkJ+fj8TERCQmJmLv3r3QarUYPHgwwsPDER4ejiFDhkCh4O+HREQkBgsl0QOa830W9p2uMOiCc2uFFUb1dsQvT/n95T9TWVmJ5ORkJCYmIikpCdevX0fXrl0xefJkhIeHY8KECWjXrp3BMhEREd0NCyXRAzpXWYMJn2ai3oDrfexsFEifH4ie9/iMpkajwb59+3TTy/z8fNja2mLs2LG66eUjjzxisHxERER/hoWSSA+x2WVYqM4x2PWWR/kgepjLA//5U6dOYevWrUhMTMTOnTvR2NgILy8vXbkcOXIkbGxsDJaXiIgIYKEk0tvKjGKsSC3C7++3efCDOq+GeOCFIDeD5aqqqkJaWhoSExOxdetWlJeXo3PnzggLC0N4eDhCQ0PRqVMng92PiIjki4WSyAD+nZaD91JLoLC2gWR174djrBVWsFFYYekUb70mk3ej1WqRnZ2t+2j82LFjsLa2xujRo3XTSw8PD1hZGX/DJhERWR4WSiIDmD17NtL2HcG4//4WB87egLXC6o6HdZq/HuDmhPcife75mUlDOX/+vO6j8fT0dNTV1aFPnz66cjlmzBjY2tq2aCYiIjJfLJREetqxYwfGjx+P1atXY+7cuSi+XIU1WWXIKCpHWUUN/vgNZgXAxdEeQe7OeGyEi241kEg1NTXIyMjQTS/Pnz+Pdu3aISQkBOHh4Zg0aRKcnZ1FxyQiIhPGQkmkh4aGBvj6+qJLly7IzMz8P7sgq+s1KK2oRoNGC1sbBVwdHeBgZ7qHYiRJwokTJ3TlMisrCwAwfPhw3fRywIAB/GiciIhuw0JJpIf3338fb775Jo4ePQofHx/RcQyuvLwcSUlJSExMREpKCqqqqtCjRw/dzstx48bB3r5lP64nIiLTw0JJ9IDOnj2Lfv364fnnn8eKFStExzG6hoYG7N69G4mJiUhISMCpU6fQunVrjB8/HuHh4Zg8eTJ69uwpOiYREQnAQkn0gKZNm4ZDhw4hPz9fdm+mkSQJhYWFuo/G9+zZg6amJgwYMAAREREIDw/HsGHD+DpIIiKZYKEkegAJCQmYMmUK1q9fj+nTp4uOI9y1a9eQkpKiex1kZWUlunTpovtoPDg4GO3btxcdk4iIjISFkug+1dTUwNvbGx4eHkhKSuIBlf+g0Whw4MAB3fQyLy8PrVq1QmBgoO5gT58+fUTHJCIiA2KhJLpP//rXv7BixQrk5ubCzc1wb7axVGfOnNHtvMzIyEBDQwM8PT115XLUqFFo1aqV6JhERKQHFkqi+1BYWAgfHx8sWrQIS5YsER3H7Ny6dQvp6em66eXly5fRsWNHTJw4EeHh4Zg4cSIcHR1FxyQiovvEQkl0jyRJQnBwMEpLS5GTk4M2bdqIjmTWtFotjhw5oiuXhw8fhkKhwKhRo3TTSy8vLz5SQERkBlgoie5RbGwsZs2ahW3btiEsLEx0HItz8eJFbNu2DQkJCUhPT0dNTQ1cXV115XLs2LGws7MTHZOIiP4ECyXRPbhx4wY8PT3h7++PDRs2iI5j8Wpra7Fz507d9LKsrAwODg63vQ7yoYceEh2TiIj+PxZKonswb948fPfdd8jPz+fy7hYmSRJyc3N15XL//v2QJAnDhg3TTS8HDRrEj8aJiARioSS6i2PHjmHIkCFYvnw5FixYIDqO7F29elX3Osjk5GTcvHkT3bt31+28HD9+PBwcHETHJCKSFRZKojvQarXw9/dHVVUVjh49yvU2JqaxsRF79uzRTS+LiopgZ2eHcePG6V4H2atXL9ExiYgsHgsl0R189913ePrpp7Fr1y4EBASIjkN3UVRUpNt5uWvXLmg0Gvj4+Og+Gvfz84O1tbXomEREFoeFkugvXL16FR4eHoiIiMCPP/4oOg7dpxs3biA1NRWJiYnYtm0brl69CicnJ0yaNAnh4eEICQlBhw4dRMckIrIILJREf+Hvf/87Nm7ciMLCQjg7O4uOQ3poamrCwYMHdR+NnzhxAjY2NhgzZoxuetm3b1/RMYmIzBYLJdGf2LdvH/z9/bFq1So8++yzouOQgZ09e1b30fiOHTtQX18Pd3d3XbkcPXo0n5clIroPLJRE/0Gj0WDIkCGws7PD/v37+cydhauursb27dt108tLly6hffv2utdBhoWFwcnJSXRMIiKTxkJJ9B8+++wz/POf/0R2djaGDBkiOg61IEmScPToUV25zM7OhpWVFUaOHKmbXvbv3587L4mI/gMLJdEfXLhwAZ6envjb3/6GlStXio5Dgv3222/Ytm0bEhMTkZqaiurqari4uOjKZVBQEFq3bi06JhGRcCyURH8QExODjIwMFBYWomPHjqLjkAmpr69HZmYmEhMTkZCQgNLSUtjb22PChAm6nZfdu3cXHZOISAgWSqL/Ly0tDSEhIfjll1/w2GOPiY5DJkySJOTn5+vK5b59+6DVajF48GCEh4cjIiICgwcPhkKhEB2ViKhFsFAS4ffpk4+PD7p3746MjAw+I0f3paKiAsnJybrXQV6/fh0PPfSQ7nWQEyZMQNu2bUXHJCIyGhZKIgDLli3D22+/jePHj8PLy0t0HDJjjY2N2Ldvn+5gT0FBAWxtbREUFKR79tLV1VV0TCIig2KhJNk7ffo0vL298Y9//AMffPCB6DhkYUpKSnQ7LzMzM9HY2Ahvb29duRwxYgRsbGxExyQi0gsLJcmaJEkIDw9HTk4O8vPz4eDgIDoSWbCbN28iLS0NiYmJ2Lp1K65cuYLOnTsjLCwM4eHhCA0NRadOnUTHJCK6byyUJGubNm1CZGQk4uPjMW3aNNFxSEa0Wi2ys7N1H40fO3YM1tbWGD16tG566eHhwed5icgssFCSbFVXV6Nfv37w9fVFQkICf3CTUOfOndPtvExPT0ddXR369OmjOzUeEBAAW1tb0TGJiP4UCyXJ1sKFC/H5558jLy8PvXv3Fh2HSKempgY7duzQTS8vXLiAdu3aITQ0VPc6SGdnZ9ExiYh0WChJlk6ePIkBAwZg8eLF+Ne//iU6DtFfkiQJx48f15XLgwcPAgD8/Px0H437+vqa1IS9ul6D0opqNGi0sLVRwNXRAQ52PHhEZMlYKEl2JElCUFAQLl68iJycHNjZ2YmORHTPLl++jKSkJCQmJiIlJQW3bt1Cjx49dOVy3LhxaNOmTYvnKr5chTVZZcgoLEdZZQ3++IPFCoBLZ3sEeThjtp8L+nZt1+L5iMi4WChJdn799VfMmTMHqampCA4OFh2H6IE1NDRg165dujf2nD59Gm3atMH48eN1r4Ps0aOHUTOcq6zBovgc7C65CmuFFZq0f/0jpfnrAW5OeC/SBz072xs1GxG1HBZKkpXr16/Dw8MDY8eORVxcnOg4RAYjSRIKCwt1H43v2bMHTU1NGDhwoG56OWzYMIO+DjI2uwyLt+RBo5XuWCT/k7XCCjYKK7w9xRsxw1wMloeIxGGhJFl58cUX8dNPP6GgoAAPP/yw6DhERnPt2jWkpKQgMTER27Ztw7Vr1+Ds7IxJkyYhIiICwcHBaNfuwT96XplRjBWpRXrnXBDijheD+up9HSISi4WSZOPw4cMYNmwYPv74Y8yfP190HKIWo9FocODAAd30Mi8vD61atcLYsWN1H4336dPnnq8Xm12Gheocg+VbHuWDaE4qicwaCyXJQlNTE0aOHIn6+nocPnyYr7ojWTtz5oyuXO7cuRMNDQ3o16+f7qPxUaNG/eX3yLnKGkz4NBP1Gq3B8tjZKJA+P5DPVBKZMRZKkoWvv/4azz33HPbs2QN/f3/RcYhMRlVVFdLT03Wvg7x8+TI6duyoex3kxIkT0blzZ90/P+f7LOw7XXFfz0zejbXCCqN6O+KXp/wMdk0ialkslGTxysvL4eHhgaioKHz//fei4xCZLK1Wi8OHD+uml0eOHIFCoYC/v//v+y5Hh+DZhAtGu3/6/DFwc+ZKISJzxEJJFm/u3LlISEhAYWEhnJycRMchMhsXLlzQvQ4yLS0Nrf3noP3gyYDC2uD3slZYYY5fLyyZ4m3waxOR8bFQkkXbtWsXAgMD8c033+Dpp58WHYfIbNXW1iLgwx24Wme8e/RytEfmgiDj3YCIjMZwC8mITExjYyOef/55+Pn54amnnhIdh8isNSlaocKIZRIAyipqUF2vMe5NiMgoeNSVLNbnn3+O/Px8HDp0yKDLnInk6GxFNYz9cZYEoLSiGt7dOxj5TkRkaPwpSxbp3LlzWLJkCV588UUMGjRIdBwis9dgwDVBpnAfIjIsFkqySPPnz0e7du2wdOlS0VGILIKtTcv8uGip+xCRYfEjb7I4SUlJ2LhxI1QqFTp04EdnRIbg6ugAK8CoH3tb/f/7EJH54a+CZFFqa2vx4osvYty4cYiJiREdh8hiONjZwMXIb7Jpi1qcPaX/+8GJqOWxUJJFWb58Oc6dO4cvv/wSVlZWouMQWZQgD2dYK4z0fSVpcfXELnh7e8PHxwfvvvsuSkpKjHMvIjI4FkqyGMXFxfjggw/w6quvwtPTU3QcIosz28/FoK9cvI2VAtv/vQRbtmyBr68v3n//ffTt2xdDhw7FRx99hLNnzxrnvkRkEFxsThZBkiSEhYWhoKAAJ0+ehL29cT+aI5KrlnqXd01NDbZt24a4uDgkJiairq4OI0eORExMDGbMmIFu3boZ7P5EpD8WSrIIGzZswIwZM7BlyxZERESIjkNksc5V1mDCp5moN+B6HzsbBdLnB6LnXzyjWVVVhYSEBMTGxiI5ORkajQaBgYGIjo7Go48+ii5duhgsCxE9GBZKMntVVVXo168fhgwZgs2bN4uOQ2TxYrPLsFCdY7DrLY/yQfQwl3v6Z69du4ZNmzYhLi4O6enpAIDx48cjJiYG06ZNQ6dOnQyWi4juHQslmb0FCxbgq6++wsmTJ+Hq6io6DpEsrMwoxopU/U9kvxrigReC3B7oz165cgVqtRqxsbHIzMyEjY0NQkNDERMTgylTpqBdu3Z65yOie8NCSWYtJycHgwYNwjvvvIPXX39ddBwiWYnNLsNbm3NR36iBlcL6nv+ctcIKNgorLJ3ifc+Tybu5ePEiNmzYgLi4OOzbtw+tW7fG5MmTER0djcmTJ/O5aiIjY6EksyVJEsaMGYOrV6/i+PHjsLW1FR2JSHamzHoCx229YNXdC9YKqzse1mn+eoCbE96L9PnLZyb1VVZWhnXr1iE2NhaHDx+Gg4MDpkyZgpiYGISGhsLOzs4o9yWSMxZKMls//fQT5s6di+3bt2PcuHGi4xDJzr59++Dv74+ffvoJI0MjsSarDBlF5SirqLntjTpWAFwc7RHk7ozHRrjAzbnlPoouKSnRlcucnBx06NABkZGRiI6Oxvjx49GqVasWy0JkyVgoySxVVlbC09MTwcHBWLNmjeg4RLIjSRJGjRqFuro6HD58GArF/641rq7XoLSiGg0aLWxtFHB1dICDnfg3/Z48eRJxcXGIjY1FUVERHB0d8eijjyImJgZjxoyBtfW9f2xPRLdjoSSz9Nxzz0GlUqGgoID76IgEWL9+PWbOnGmWnxBIkoTjx4/rymVpaSkeeughzJgxA9HR0Rg5cuRtBZmI7o6FkszOwYMHMWLECHz++ed46aWXRMchkp36+np4eXmhX79+SExMFB1HL5IkITs7G7GxsVi3bh0uXLiAnj17YubMmYiJicGQIUP4Gleie8BCSWalqakJw4cPhyRJOHjwIGxsxH+MRiQ3n376KRYsWICcnBx4eXmJjmMwWq0We/fuRVxcHNavX4/y8nL07t0b0dHRiImJgY+PD8sl0V9goSSz8uWXX+Kll17C/v374efnd/c/QEQGVVlZCTc3N8ycORNff/216DhGo9FokJmZidjYWGzcuBHXrl2Dp6cnYmJiEB0dDU9PT9ERiUwKCyWZjd9++w2enp6Ijo7Gv//9b9FxiGTplVdewTfffIPi4mI89NBDouO0iIaGBqSnpyMuLg7x8fGoqqrCgAEDEB0djejoaPTu3Vt0RCLhWCjJbMyZMwfJyckoKCiAo6Oj6DhEsnP69Gl4enrirbfewr/+9S/RcYSoq6tDcnIyYmNjkZCQgJqaGgwbNgwxMTGYOXMmevToIToikRAslGQWdu7ciaCgIPzwww944oknRMchkqXo6Gjs2bMHxcXFfPMMgOrqaiQmJiIuLg7btm1DfX09Ro8ejejoaEyfPl02E1wigIWSzEBDQwMGDhyIzp07Y9euXVznQSTA/v37MWrUKKxevRpz584VHcfk3Lx5E5s3b0ZsbCxSU1Oh1WoxduxYxMTEICoqip+qkMVjoSSTt3z5crzxxhs4cuQIfH19Rcchkh1JkjB69GhUV1fj8OHDXAB+F5WVlVCr1YiLi8OOHTugUCgQHByM6OhoTJs2DR06dBAdkcjgWCjJpJ09exZeXl549tln8fHHH4uOQyRLGzduxPTp05GWloYJEyaIjmNWLl++jI0bNyI2NhZ79uxBq1atEBYWhpiYGERERMDBwUF0RCKDYKEkkxYZGYmDBw+ioKAA7dq13Pt/ieh3DQ0N8PLygru7O7Zt2yY6jlk7f/481q9fj7i4OGRlZaFNmzaIiIhAdHQ0wsLC0KZNG9ERiR4YCyWZrMTERERERGDdunWYMWOG6DhEsvT555/jn//8J44fP47+/fuLjmMxzpw5g3Xr1iEuLg5Hjx5F27ZtMW3aNERHRyMkJAS2traiIxLdFxZKMkk1NTXw9vaGu7s7kpOT+XYKIgGuXbsGNzc3PProo/jmm29Ex7FYRUVFuveKnzx5Ep06dUJkZCRiYmIQFBTEN4KRWWChJJP05ptv4sMPP0Rubi769u0rOg6RLL366qtYtWoViouL0a1bN9FxZCE3NxexsbGIi4tDSUkJunTpgunTpyM6OhoBAQHcckEmi4WSTE5hYSF8fX2xcOFCvP3226LjEMnSmTNn4OnpiTfeeANvvfWW6DiyI0kSjhw5gri4OMTFxaGsrAzdu3fHjBkzEBMTAz8/P35yQyaFhZJMiiRJCAkJwenTp5Gbm8uH1IkEmTVrFjIzM1FcXMyTyIJptVpkZWUhNjYW69evx6VLl9CrVy/dqx8HDRrEcknCsVCSSYmLi0NMTAy2bduGsLAw0XGIZCkrKwsjRozA999/jyeffFJ0HPqDpqYm7N69G3FxcdiwYQOuXr2Kvn37Ijo6GjExMfD29hYdkWSKhZJMxs2bN+Hp6YmRI0di48aNouMQyZIkSRgzZgxu3LiBo0ePcom5CdNoNNixYwdiY2MRHx+P69evw9vbGzExMYiOjubz59SiWCjJZMyfPx/ffvst8vPz0bNnT9FxiGQpPj4eUVFRSElJQUhIiOg4dI/q6+uRmpqKuLg4bN68Gbdu3cLgwYMRHR2NmTNnwtXVVXREsnAslGQSjh07hiFDhuCDDz7Aq6++KjoOkSw1NDTA29sbffr0QXJysug49IBqa2uxbds2xMXFITExEbW1tRgxYgRiYmIwY8YMdO/eXXREskAslCScVqvF6NGjcePGDRw7dgytWrUSHYlIlr744gvMmzcPx44dg4+Pj+g4ZAC3bt1CQkICYmNjkZycjMbGRowZMwbR0dF49NFH4ezsLDoiWQgWShLu+++/x9///ndkZmZizJgxouMQydL169fh5uaGadOm4bvvvhMdh4zg+vXr2LRpE+Li4pCWlgYAGDduHKKjoxEVFYVOnToJTkjmjIWShLp69So8PDwQHh6On376SXQcItn67//+b6xcuRLFxcX8SFQGrl69CrVajdjYWOzcuRM2NjYICQlBTEwMpkyZgvbt24uOSGaGhZKEevrpp7FhwwYUFBSga9euouMQyVJpaSk8PT2xcOFCLFmyRHQcamGXLl3Chg0bEBcXh71798LOzg6TJ09GdHQ0wsPDYW9vLzoimQEWShJm//79GDVqFL766is899xzouMQydbs2bOxY8cOFBcXo23btqLjkEBlZWVYv349YmNjcejQITg4OCAiIgIxMTGYOHEi7OzsREckE8VCSUJoNBoMHToUrVq1woEDB7jrjkiQ7OxsDB8+HN9++y3+/ve/i45DJuTUqVO6Vz+eOHEC7du3R2RkJKKjozFhwgQeoKTbsFCSEJ9//jnmz5+PgwcPYujQoaLjEMmSJEkYO3YsKisrcezYMf5iR38pPz8fcXFxiI2NRWFhITp37oxHH30UMTExCAwM5L87xEJJLe/ixYvw9PTEnDlz8OWXX4qOQyRbmzdvxrRp05CUlISJEyeKjkNmQJIknDhxQlcuz5w5g65du2LGjBmIjo7GqFGjoFAoRMckAVgoqcXNmjULO3bsQEFBAddUEAnS2NiI/v37o1evXkhJSYGVlZXoSGRmJEnCoUOHEBsbi3Xr1uH8+fPo0aMHZs6ciZiYGAwdOpT/XskICyW1qPT0dAQHB+Pnn3/GnDlzRMchkq0vv/wSL730Eo4ePYoBAwaIjkNmTqvVYt++fYiLi8O6detQXl6O3r17Izo6GtHR0fD19WW5tHAslNRi6uvr4evri4ceegg7d+7kXy5Egty4cQNubm6IiIjADz/8IDoOWZimpiZkZmYiNjYWGzduRGVlJTw9PXXlsl+/fqIjkhGwUFKLeffdd7FkyRIcO3YM3t7eouMQydbrr7+Ozz//HMXFxXj44YdFxyEL1tjYiPT0dMTFxSE+Ph43b96Er6+vrlz26dNHdEQyEBZKahFnzpyBl5cXXn75ZSxfvlx0HCLZKisrg7u7O1577TUsXbpUdBySkbq6OqSkpCA2NhZbtmxBTU0Nhg4dipiYGMycORM9e/YUHZH0wEJJRidJEiIiInDixAmcPHmSi5OJBJozZw7S0tJQXFyMdu3aiY5DMlVdXY2tW7ciLi4OW7duRX19Pfz9/REdHY0ZM2bgoYceEh2R7hMLJRld82oStVqNyMhI0XGIZOvw4cMYOnQo/v3vf+O//uu/RMchAgDcvHkTW7ZsQWxsLFJTU9HU1ITAwEDExMQgKioKTk5OoiPSPWChJKOqrq6Gl5cX+vfvj8TERB7EIRJEkiSMGzcO5eXlOH78OGxsbERHIvo/KisrER8fj7i4OGzfvh1WVlYIDg5GdHQ0pk2bho4dO4qOSH+BhZKM6vXXX8dnn32GvLw89O7dW3QcItlKSEjAlClTsHXrVkyaNEl0HKK7Ki8vx8aNGxEbG4vdu3ejVatWmDhxImJiYhAREcHHp0wMCyUZzcmTJzFgwAC89dZbePPNN0XHIZKtxsZG+Pj4oEePHkhLS+MnBWR2Lly4gPXr1yMuLg4HDhxAmzZtEB4ejujoaEyaNAlt2rRp8UzV9RqUVlSjQaOFrY0Cro4OcLCT7+SfhZKMovnjtQsXLuDEiRNo3bq16EhEsrVq1Sq88MILOHLkCAYOHCg6DpFeSktLsW7dOsTGxuLo0aNo27Ytpk6dipiYGISEhMDW1tZo9y6+XIU1WWXIKCxHWWUN/ligrAC4dLZHkIczZvu5oG9XeR16Y6Eko1izZg0ee+wxpKSkICQkRHQcItm6efMm3NzcMGnSJPz444+i4xAZVFFREeLi4hAXF4e8vDx07NgRUVFRiI6Oxrhx4wz2rPC5yhosis/B7pKrsFZYoUn719Wp+esBbk54L9IHPTvbGySDqWOhJIO7fv06PD09ERgYiLi4ONFxiGTtjTfewCeffILi4mL06NFDdBwio8nNzdWVy+LiYjg5OWH69OmIjo5GQEAArK2tH+i6sdllWLwlDxqtdMci+Z+sFVawUVjh7SneiBnm8kD3NicslGRwL730En788UcUFBTwLRxEAp07dw7u7u545ZVXsGzZMtFxiFqEJEk4evSorlyePXsW3bp1w4wZMxATE4MRI0bc83PEKzOKsSK1SO9MC0Lc8WJQX72vY8pYKMmgDh8+jOHDh2PFihWYP3++6DhEsva3v/0NycnJKCkp4RJzkiVJkpCVlYXY2FisW7cOly5dgouLi+7Vj4MHD/7LchmbXYaF6hyDZVke5YNoC55UslCSwTQ1NWHkyJGor6/H4cOHueeOSKAjR45g6NCh+Oqrr/Dss8+KjkMkXFNTE/bs2YO4uDisX78eV69ehZubG6KjoxETE4P+/fvr/tlzlTWY8Gkm6jVag93fzkaB9PmBFvtMJQslGcy///1vPPvss9izZw/8/f1FxyGSLUmSMH78eFy6dAk5OTn85Y7oP2g0GmRkZCA2NhZqtRrXr1+Hl5cXYmJiEB0djXd2X8O+0xX39czk3VgrrDCqtyN+ecrPYNc0JSyUZBDl5eXw9PREZGQkvv/+e9FxiGRt69atCA8PR0JCAsLDw0XHITJpDQ0NSE1NRVxcHDZt2oR6u07o/vQqo90vff4YuDlb3iMoLJRkEE888QS2bNmCwsJCvneVSCCNRgNfX1889NBDulfXEdG9qa2txdNfp2LPZQVgpTD49a0VVpjj1wtLpngb/NqiGf6/LZKd3bt348cff8QHH3zAMkkk2Pfff4/8/HysWLGCZZLoPrVp0wbnNO2NUiYBoEkrIaOo3CjXFo0TStJLY2MjBg8eDAcHB+zbtw8KBX9HIRKlqqoKbm5uCA0Nxc8//yw6DpHZuVWvgc+SFBizGFkByF0SanGvabSs/2+oxX3xxRc4efIkDh06xDJJJNiHH36Imzdvcuck0QM6W1Ft1DIJABKA0opqeHfvYOQ7tSw2AHpg58+fx+LFi/Hiiy9i0KBBouMQydr58+fx8ccfY/78+XBxsdxdd0TG1GDANUGmcJ+WxEJJD+yf//wn2rZti6VLl4qOQiR7b775Jtq2bYuFCxeKjkJktmxtWqYWtdR9WhI/8qYHkpKSgvXr10OlUqFDB8sa2xOZm2PHjuGnn37CypUr0b59e9FxiMyWq6MDrACjP0Pp6uhgxDuIwUM59H9U12tQWlGNBo0WtjYKuDo63PbwcF1dHXx8fODi4oL09HSeJCUSSJIkBAcH4/z588jJyUGrVq1ERyIya4EfZeBsZY3Rrt/L0R6ZC4KMdn1ROKEkAEDx5SqsySpDRmE5yiprbvvtzAqAS2d7BHk4Y7afC9b++1OcPXsWCQkJLJNEgiUnJ2P79u3YvHkzyySRAQR5OOOXrLMGfUtOM2uFFYLcnQ1+XVPACaXMnauswaL4HOwuuQprhdUdv4Gav15/9hhmujbh8/feasGkRPSfNBoNBgwYgC5duiAjI4O/4BEZQPHlKgR/tsto17fUN+VwQiljsdllWLwlD5r/XyLv9ttY89ftevog2boVYrPLEDOMp0mJRFm9ejVOnjyJ7OxslkkiA+nbtR0C3JyM9i5vSyyTACeUsrUyoxgrUov0vs6CEHe8GNTXAImI6H7cunULbm5umDBhAn799VfRcYgsyrnKGkz4NBP1BlzvY2ejQPr8QPTsbG+wa5oSyzu3TncVm11mkDIJACtSixCXXWaQaxHRvfvoo49w/fp1vPvuu6KjEFmcnp3t8baB37e9dIq3xZZJgIVSds5V1mDxljyDXvOtLXk4Z8QTcUR0uwsXLuCjjz7CvHnz0KtXL9FxiCxSzDAXLAhxN8i1Xg3xQLSFPyLGQikzi+JzdM9MGopGK2FRfI5Br0lEf+2tt96Cvb09Xn/9ddFRiCzai0F98UGUD+xsFIB0fx9/WyusYGejwPIoH7wQ5GakhKaDhVJGii9XYXfJVYOvQmjSSthdchUl5VUGvS4R/V8nTpzA6tWrsWTJEr5UgKgFxAxzwXuj7VFbegzA70XxTpq/Pqq3I9LnB1r8ZLIZD+XIyJIteUbdrTXHrxeWGPiZEyK6XWhoKM6cOYO8vDzunSRqIePHj0dFRQXikjOx9uB5ZBSVo6ziT3Y2O9ojyN0Zj41wsdjT3H+Fa4NkJKOw3ChlEvh9SplRVI4lYKEkMpaUlBSkpqYiPj6eZZKohezatQs7duyAWq2Gx0MdsGRKByyB913fKic3nFDKxK16DXyWpBj9/aS5S0Jl/Q1FZCxNTU0YOHAgOnXqhMzMTO6dJGoh48ePR2VlJY4cOcLvuzvgT36ZOFtRbdQyCQASgNKKanh353NdRIb2448/Ijc3F1lZWfyhRtRCmqeT8fHx/L67Cx7KkYkGAy5nNYX7EMnJrVu38Oabb2LWrFkYPny46DhEsvH2229j4MCBmDp1qugoJo8TSpmwtWmZ3x1a6j5EcvLxxx+joqIC7733nugoRLLB6eT94U9/mXB1dICxvx2s/v99iMhwLl26hA8//BD/+Mc/4OrqKjoOkWwsWbKE08n7wAmlTDjY2cClsz3OGvGNNh2sG1FZfgkOPXsa7R5EcvPWW2+hdevWWLRokegoRLKRmZmJjIwMbNq0idPJe8QJpYwEeTjfdSHrA5O0OJ+dAhcXF/j5+WH58uUoLi42zr2IZCInJwc//PADFi9ejI4dO4qOQyQbzc9OTpkyRXQUs8G1QTJSfLkKwZ/tMtr11U8NQn5WBtRqNZKSklBbW4v+/fsjKioKUVFR8PX15W96RPchLCwMJSUlyMvLg62treg4RLKQmZmJsWPHYtOmTfy4+z6wUMrMnO+zsO90hUEXnFsrrDCqtyN+ecpP95/V1NQgJSUFarUaCQkJuHHjBnr37q0rl35+flAoOCAn+iupqakIDQ3Fxo0bERUVJToOkWwEBQXh+vXr3Dt5n1goZeZcZQ0mfJqJegOu97GzUSB9fiB6drb/0683NDQgI+P3yeWmTZtQXl6Obt26ITIyElFRURgzZgzf+kH0B01NTRg8eDDatWuH3bt384caUQvZuXMngoKCOJ18ACyUMhSbXYaF6hyDXW95lA+ih7nc0z/b1NSEffv2Qa1WQ61Wo6ysDJ07d0ZERASioqIQHByMNm3aGCwbkTlavXo1nnzySRw4cAB+fn53/wNEZBBBQUG4ceMGDh8+zF/k7hMLpUytzCjGitQiva/zaogHXghye6A/K0kSjh49qiuX+fn5cHBwwKRJkxAVFYVJkyahffv2emckMifV1dVwd3dHQEAAYmNjRcchko3m6eTmzZt5GOcBsFDKWGx2GRZvyUN9owawuvfnGa0VVrBRWGHpFO97nkzei/z8fMTHx0OtVuPw4cOwtbVFcHAwoqKiMGXKFDg5ORnsXkSm6p133sGyZctQUFCARx55RHQcItngdFI/LJQytzUzC0+uSkWbRwbDWmF1x8M6zV8PcHPCe5E+f/nMpCGUlpZi06ZNUKvV2LNnD6ysrBAYGIioqChMmzYNPXr0MNq9iUT57bff4ObmhmeffRYrVqwQHYdINjid1B8LpcxNmTIFhYWF2LzzIGKzzyOjqBxlFTX4478UVgBcHO0R5O6Mx0a4wM25XYtmvHz5MjZv3gy1Wo3t27dDo9HAz89Pd2Lcze3BPnInMjXPPPMM1q9fj1OnTqFTp06i4xDJxtixY1FVVYVDhw5xOvmAWChl7OjRoxg8eDB+/vlnzJkzR/efV9drUFpRjQaNFrY2Crg6OsDBzjReqnTt2jVs3boVarUaycnJqK2thY+Pj65c+vj48C8DMkt5eXnw9fXFxx9/jHnz5omOQyQbzdPJLVu2ICIiQnQcs8VCKWORkZHIzc1Ffn4+bGxMozDej+rq6tt2Xd68eRN9+vTRlcvhw4dz1yWZjcmTJ6OwsBAnT57kEnOiFsTppGGwUMrU8ePHMXDgQKxevRpz584VHUdvDQ0N2LFjh27X5ZUrV9C9e/fbdl2aY2kmeUhPT0dwcDDWr1+P6dOni45DJBucThoOC6VMPfroozh27BgKCwstrmg1NTVh7969UKvViI+P1+26nDp1KqKiojBhwgS0bt1adEwiAL//+zpkyBDY29tj7969nJAQtRBJkjB27FjcunWL00kDYKGUoRMnTmDAgAH4/vvv8eSTT4qOY1SSJOHIkSNQq9XYuHEjCgsL0bZt29t2XbZr17KHjIj+6KeffsLcuXOxb98+jBw5UnQcItnIyMjAuHHjOJ00EBZKGZo5cyYOHTqEwsJC2b3yMD8/X7dI/ciRI7Czs7tt16Wjo6PoiCQjNTU1cHd3x6hRo7Bu3TrRcYhko3k6WV1djezsbE4nDYCFUmby8vLg4+ODb775Bn//+99FxxGqtLRUt0h97969UCgUt+26fPjhh0VHJAv37rvv4u2330Z+fj769OkjOg6RbDRPJxMSEhAeHi46jkVgoZSZmJgY7N+/H8XFxTxJ+ge//fabbtfljh07oNFoMGLECN2Jcf6wJ0O7fPky3Nzc8PTTT+OTTz4RHYdINjidNA4WShk5efIk+vfvj1WrVuGZZ54RHcdkXbt2DYmJibpdl3V1dfD19dWVy/79+/MvINLbc889h9jYWJw6dQqdO3cWHYdINnbs2IHx48dzOmlgLJQyMnv2bOzevRslJSWcTt6j6upqJCcnQ61WIzExETdv3oSbm5uuXA4bNoy7Lum+nTx5Er6+vvjwww/xz3/+U3QcItmQJAmBgYGoqanhdNLAWChlorCwEF5eXli5ciWee+450XHMUn19/W27Lq9evYqHH35Yt+syICDA4lYwkXFEREQgLy8P+fn5sLOzEx2HSDY4nTQeFkqZmDNnDjIyMnDq1Cn+ADOApqYm7NmzR3di/Pz583B0dLxt1yX/e6Y/03wYIC4uDjNnzhQdh0g2mqeTtbW1OHjwIKeTBsZCKQNFRUXo168fPv/8c7z44oui41gcSZJw6NAhXbksKipCu3btMHnyZERFRSEsLAxt27YVHZNMgFarxbBhw9CqVSvs37+fP9CIWlDzdDIxMRGTJ08WHcfisFDKwN/+9jekp6fj1KlTfEOMkUmSdNuuy6NHj8LOzg6hoaGIjIxEREQEd13K2K+//oo5c+Zgz5498Pf3Fx2HSDYkScKYMWNQV1fH6aSRsFBauJKSEnh6euKTTz7Byy+/LDqO7Jw5c0a363Lfvn1QKBQYO3asbtdl9+7dRUekFlJbWwsPDw8MHz4cGzZsEB2HSFa2b9+OCRMmcDppRCyUFu7JJ59EUlISTp8+jTZt2oiOI2uXLl26bddlU1MTRo4cqTsx3rt3b9ERyYg++OADvPnmm8jPz4ebm5voOESy0TydrK+vR1ZWFqeTRsJCacFOnz4Nd3d3fPTRR5g/f77oOPQHlZWVul2XKSkpqKurw4ABA3Tl0tvbm3/pWZArV66gT58+ePLJJ/HZZ5+JjkMkK83Tya1bt2LSpEmi41gsFkoL9ve//x2JiYk4ffo07O3tRcehv3Dr1q3bdl1WVVWhb9++t+26ZLk0by+++CJ+/fVXnDp1is/QErUgTidbDgulhSotLUXfvn3xwQcf4JVXXhEdh+5RfX09tm/fDrVajc2bN+Pq1avo0aOHbtfl6NGjuevSzBQWFsLb2xsffPABFixYIDoOkaxwOtlyWCgt1DPPPIP4+HicOXMGDg4OouPQA9BoNLfturxw4QKcnJx0uy7Hjx/PXZdmYNq0aTh+/Djy8/O5ZYGoBUmShICAADQ0NHA62QJYKC1QWVkZ3NzcsGzZMrz22mui45ABaLVa3a7LjRs3oqSkBO3atUN4eDiioqIwceJE7ro0QZmZmRg7dizWrl2LmJgY0XGIZCU9PR3BwcGcTrYQFkoL9Nxzz2HDhg04c+YMS4YFkiQJeXl5usnl8ePH0bp1a4SGhiIqKgrh4eHo3Lmz6Jiyp9Vq4efnB4VCgQMHDnA6QtSCmqeTjY2N/P5rISyUFubcuXPo06cPli5dioULF4qOQy3g9OnTiI+Px8aNG7F//37Y2NggKCgIkZGRmDZtGrp16yY6oiypVCrMnj0bu3btQkBAgOg4RLLSPJ3ctm0bwsLCRMeRBRZKC/Piiy9i7dq1KC0tRbt27UTHoRZ28eJF3a7LjIwMaLXa23ZdPvLII6IjykJdXR08PDwwZMgQqNVq0XGIZIXTSTFYKC3IhQsX0Lt3b7z11lt44403RMchwSoqKm7bdVlfX4+BAwfqyqWXlxf/ojWSDz/8EG+88Qby8vLg7u4uOg6RrKSlpSEkJITTyRbGQmlBXn75Zfz6668oLS1F+/btRcchE1JVVXXbrstbt27B3d1dVy6HDh3KcmkgV69eRZ8+ffC3v/0N//M//yM6DpGsSJKE0aNHo6mpCfv37+ffay2IhdJCXLx4Eb1798Ybb7yBN998U3QcMmF1dXW37bqsqKhAz549b9t1aW1tLTqm2Xr55Zfx008/4dSpU3BychIdh0hWmqeTSUlJmDhxoug4ssJCaSHmz5+PH3/8EaWlpejQoYPoOGQmNBoNdu/eDbVajfj4eFy4cAFdunTR7bocN24cd13eh6KiInh7e+Pdd9/lyi6iFsbppFgslBbgt99+wyOPPIKFCxdi8eLFouOQmdJqtcjOztatIyopKUH79u1v23XJJfl3FhUVhcOHD6OwsJBLzIlaGKeTYrFQWoBXXnkF3333HUpLS9GpUyfRccgCSJKE3NxcXbk8ceIEWrdujYkTJ+p2XfLftdvt3r0bY8aMwZo1a6BUKkXHIZIVSZLg7+8PrVbL6aQgLJRm7vLly3jkkUewYMECLF26VHQcslAlJSWIj4+HWq3GgQMHYGNjg3HjxiEqKgpTp07FQw89JDqiUFqtFiNGjIAkScjKyoJCoRAdiUhWUlNTERoayumkQCyUZu7VV1/Fv//9b5SWlvLtKNQiLly4gE2bNkGtViMzMxNarRb+/v6IiopCZGQkXF1dRUdscbGxsZg1axZ27tyJwMBA0XGIZIXTSdPAQmnGrly5AldXV8yfPx/Lli0THYdk6OrVq0hISEB8fDxSU1NRX1+PwYMH69YR9evXT3REo6urq4OnpycGDhyITZs2iY5DJDvN08nk5GSEhoaKjiNbLJRmbOHChfjyyy9RWloKR0dH0XFI5qqqqpCUlAS1Wo2tW7fi1q1b8PDw0JXLIUOGWOTkYMWKFVi4cCHy8vLg4eEhOg6RrDRPJyVJwr59+yzy7xhzwUJppq5evQpXV1e89NJLeP/990XHIbpNXV0d0tPTdbsuKysr4eLiott16e/vbxG7LisqKtCnTx889thjWLlypeg4RLKTkpKCiRMncjppAlgozdSiRYvwP//zPygtLeXyZDJpGo0Gu3bt0u26vHjxIrp06YJp06bpdl3a2tqKjvlA5s2bhx9++AGnTp1Cly5dRMchkhVJkjBq1CgA4HTSBLBQmqHKykr06tULzz//PJYvXy46DtE902q1OHjwINRqNTZu3IjTp0+jQ4cOul2XoaGhZrPrsri4GF5eXnjnnXewcOFC0XGIZIfTSdPCQmmG3nzzTXzyySc4c+YMnJ2dRccheiCSJCEnJ0e36zInJwdt2rS5bddlx44dheWrrtegtKIaDRotbG0UcHV0gIOdje7r06dPx8GDB1FYWIg2bdoIy0kkR83TSSsrK+zdu5fTSRPAQmlmrl27BldXVzz99NNYsWKF6DhEBlNcXKzbdZmVlQUbGxuMHz9et+uya9euxs9wuQprssqQUViOssoa/PEvRysALp3tEeThjH62FYgJC8Qvv/yCxx57zOi5iOh2zdPJlJQUhISEiI5DYKE0O4sXL8ZHH32EM2fOtMgPWCIRzp8/f9uuy+Z39DbvuuzVq5dB73eusgaL4nOwu+QqrBVWaNL+9V+LzV9vdbUE6e8/hV5ObQ2ahYjuTJIkjBw5EgqFgtNJE8JCaUauX78OV1dXPPnkk/jkk09ExyFqEc27LtVqNVJTU9HQ0IAhQ4bo1hF5enrqdf3Y7DIs3pIHjVa6Y5H8TworoJW1Am9P8UbMMBe9MhDRvUtOTkZYWBinkyaGhdKMLF26FO+//z5Onz6Nbt26iY5D1OJu3rx5267L6upq9OvXT1cuBw0adF/TipUZxViRWqR3rgUh7ngxqK/e1yGiO+N00nSxUJqJGzduwNXVFY8//jg+//xz0XGIhKutrb1t1+W1a9fQq1cv3a7LUaNG3XHXZWx2GRaqcwyWZ3mUD6I5qSQyqubpZGpqKoKDg0XHoT9goTQTy5Ytw7Jly3D69Gl0795ddBwik9LY2HjbrstLly7B2dlZt+syKCjotl2X5yprMOHTTNRrtAbLYGejQPr8QPTsbG+waxLR/2qeTlpbW2PPnj2cTpoYFkozcPPmTbi6umL27Nn44osvRMchMmlarRZZWVm6dUTNuy4jIiJ0uy6fWZuDfacr7uuZybuxVlhhVG9H/PKUn8GuSUT/KykpCZMmTeJ00kSxUJqB9957D2+//TZOnTqFHj16iI5DZDYkScKJEyd05TI3NxdtH+4LxzmfGu2e6fPHwM25ndGuTyRHkiRhxIgRsLGx4XTSRLFQmriqqiq4uroiJiYGX375peg4RGatqKgIr6w5gJy6joDC8O8St1ZYYY5fLyyZ4m3waxPJGaeTpk8hOgDd2VdffYWqqir893//t+goRGbP3d0dN9v2NEqZBIAmrYSMonKjXJtIriRJwpIlS+Dv748JEyaIjkN/webu/wiJcuvWLaxYsQJPPvkkXFx4epRIX7fqNSirrDHqPcoqalBdr7ntNY1E9OCSk5Nx8OBBpKWl8aNuE8YJpQlbtWoVbty4gddff110FCKLcLaiGsZ+xkcCUFpRbeS7EMmDJElYvHgx/P39MX78eNFx6A74K7SJqqmpwUcffYS5c+ca/DVzRHLVYMA1QaZwHyJLl5SUhOzsbE4nzQAnlCbq66+/xrVr1zidJDIgW5uW+Suvpe5DZMn++Owkp5OmjxNKE1RTU4MPP/wQjz/+OB555BHRcYgshqujA6wAI3/sLcHZnpMUIn01TyfT09M5nTQD/DXaBH3zzTe4evUq3njjDdFRiCyKg50NXIz8JpvGyktwfbgbpk+fDpVKhRs3bhj1fkSWqHk6OXr0aIwbN050HLoHLJQmpra2FsuXL8ecOXPQu3dv0XGILE6QhzOsFcaZdlgrrDDdvx/eeustnDt3DrNnz0aXLl0QFhaGb7/9FuXlXClEdC+ap5NLlizhdNJMcLG5ifniiy8wb948FBYWws3NTXQcIotTfLkKwZ/tMtr1//imnHPnzmHTpk1Qq9XYtev3e44ePRpRUVGIjIzkOjCiPyFJEoYPH47WrVtj165dLJRmgoXShNTV1aFPnz4YP348fv75Z9FxiCzWnO+zWvxd3leuXMGWLVugVquRnp6OhoYGDB06FFFRUYiKioKHh4fBshCZs61btyI8PBzp6ek8jGNGWChNyJdffomXX34Z+fn5cHd3Fx2HyGKdq6zBhE8zUW/A9T52Ngqkzw9Ez3t4RvPGjRvYtm0b4uPjsW3bNlRXV8PLy0tXLgcOHMipDMkSp5Pmi4XSRNTX18PNzQ2BgYH49ddfRcchsnix2WVYqM4x2PWWR/kgetj9f4RdW1uLtLQ0qNVqbNmyBdeuXUOvXr105XLkyJGwtjbOqyKJTE3zdHL79u08jGNmWChNxNdff43nn38eJ0+ehKenp+g4RLKwMqMYK1KL9L7OqyEeeCFI/2eeGxsbkZmZCbVajfj4ePz222/o2rUrpk2bhqioKIwdOxa2trZ634fIFDVPJ9u0aYPMzExOJ80MC6UJaGhoQN++fTFq1CisXbtWdBwiWYnNLsO/4k+gUdMEK+t7X81rrbCCjcIKS6d4P9Bk8m60Wi0OHDgAtVoNtVqNM2fOoGPHjoiIiEBUVBRCQkJgb2/cFUhELSkxMRERERGcTpopFkoT8M033+DZZ59Fbm4uvLy8RMchkpVbt26h76CRcJ78D9xo0w3WCqs7HtZp/nqAmxPei/S5p2cm9SVJEo4fP474+Hio1Wrk5ubC3t4eYWFhiIqKwuTJk9GhQwej5yAyFkmSMGzYMNjb23M6aaZYKAVraGiAu7s7/Pz8EBcXJzoOkewsWbIE77//PgoLC9HYxhFrssqQUVSOsoqa296oYwXAxdEeQe7OeGyEi241kAhFRUW6cnnw4EG0atUK48ePR1RUFKZOnQpnZ2dh2YgeBKeT5o+FUrDvvvsOTz/9NHJyctC/f3/RcYhk5dKlS3Bzc8MLL7yADz/88LavVddrUFpRjQaNFrY2Crg6OsDBzvTeVstdl2TumqeTDg4O2LlzJ6eTZoqFUqDGxkZ4eHhgyJAhWL9+veg4RLLzX//1X9i4cSNOnTqFjh07io6jtzvtuoyMjOSBPzJJzdPJHTt2ICgoSHQcekAslAKtXr0aTz75JI4fPw5fX1/RcYhkJS8vD76+vvj4448xb9480XEM7s92Xfbr10+3jmjQoEGcBJFwnE5aDhZKQTQaDTw9PeHr6wu1Wi06DpHshIeHIz8/H/n5+Ra/ioe7LslUJSQkYMqUKZxOWgAWSkF++uknzJ07F0ePHsXAgQNFxyGSlYyMDIwbNw5xcXGYOXOm6DgtirsuyVRIkoShQ4eibdu2nE5aABZKATQaDby8vODl5YVNmzaJjkMkK1qtFsOGDUOrVq2wf/9+Wf8Qu9Ouy8jISISGhnLXJRlN83QyIyMDY8eOFR2H9MRCKcCvv/6KOXPm4NChQxgyZIjoOESysmbNGjz22GPYvXs3Ro8eLTqOyfizXZdt2rS5bdelJRxcItPQPJ1s164ddu7cKToOGQALZQtramqCt7c3+vbti4SEBNFxiGSlrq4OHh4eGDx4MOLj40XHMWncdUnGtGXLFkydOpXTSQvCQtnCVCoVZs+ejezsbAwdOlR0HCJZ+fDDD/HGG28gLy8P7u7uouOYDe66JEOSJAlDhgxB+/btOZ20ICyULaipqQn9+/dH7969sXXrVtFxiGSloqICffr0wWOPPYaVK1eKjmO2uOuS9MXppGVioWxBcXFxiImJwYEDB+Dn5yc6DpGszJs3Dz/88ANOnTqFLl26iI5jEW7evIlt27ZBrVZz1yXdk+bpZIcOHZCRkSE6DhkQC2UL0Wq18PX1RY8ePZCcnCw6DpGsnDp1Cv369cOSJUuwaNEi0XEsEndd0r3gdNJysVC2kPXr12PmzJnYt28fRo4cKToOkaw0f+8VFRVxDU4L4K5L+jOcTlo2FsoWoNVqMWDAAHTr1g2pqami4xDJyoEDBzBy5EisXr0ac+fOFR1HdrRaLbKysqBWq7Fx40buupSxzZs3Y9q0aZxOWigWyhagVqvx6KOPYs+ePfD39xcdh0g2JElCQEAAqqqqcOTIEX7kKpgkSThx4oRukTp3XcqHJEkYPHgwOnbsyOmkhWKhNDKtVovBgwfD0dER27dvFx2HSFbi4+MRFRWFlJQUhISEiI5D/4G7LuWjeTq5c+dOBAYGio5DRsBCaWSbNm1CZGQkMjMzMWbMGNFxiGSjsbER3t7eeOSRR5CSkiI6Dt0Fd11arubpZKdOnbBjxw7RcchIWCiNiA8gE4mzcuVKvPzyyzh27Bh8fX1Fx6H7cOXKFSQkJECtViMtLY27Ls1c82CF00nLxkJpRFyPQCTGjRs34ObmhoiICPzwww+i45AeuOvSvHE6KR8slEYiSRKGDRsGe3t7ZGZm8i88oha0aNEifPbZZyguLsbDDz8sOg4ZCHddmh9OJ+WDhdJItm7divDwcKSnp2P8+PGi4xDJxrlz5+Du7o5XXnkFy5YtEx2HjIS7Lk0fp5PywkJpBJIkwc/PD7a2tti9ezenk0QtaO7cudi2bRtKSkrQvn170XGoBXDXpWnioVR5YaE0gqSkJEyaNAmpqakIDg4WHYdINo4fP45BgwZh5cqVeP7550XHIQG469I0cGWe/LBQGpgkSRg5ciQUCgX27t3L6SRRCwoJCcHZs2eRm5uLVq1aiY5DJoC7LsVo3gHL6aR8sFAaWGpqKkJDQ5GUlISJEyeKjkMkGykpKZg4cSLi4+Mxbdo00XHIBHHXZcvgdFKeWCgNSJIkjB49GhqNBgcOHOB0kqiFNDU1YdCgQejYsSO3KtA9+bNdl0OGDNGdGOeuywfXPJ3ctWsXAgICRMehFsJCaUDp6ekIDg7G1q1bMWnSJNFxiGTjhx9+wFNPPYWsrCwMHz5cdBwyM9x1aTjN00knJyekp6eLjkMtiIXSQCRJwpgxY1BXV4eDBw/yLx+iFlJdXQ13d3cEBAQgNjZWdBwyc9x1qR+1Wo1HH32U00kZYqE0kIyMDIwbNw5btmxBRESE6DhEsrFs2TIsXboUBQUF6N27t+g4ZEH+atfl1KlTERUVhaCgIO66/AOtVotBgwahS5cunE7KEAulgYwdOxZVVVU4dOgQp5NELeTy5ctwc3PD008/jU8++UR0HLJgf7brskOHDoiIiEBUVBR3XYLTSbljoTSAzMxMjB07Fps2bcLUqVNFxyGSjeeffx5r167FqVOn0LlzZ9FxSCa46/L/4nSSWCgNYNy4cbh27RqOHDnC6SRRCykoKED//v3xwQcfYMGCBaLjkIxx1+X/Tid3796N0aNHi45DArBQ6mn37t0YM2YM1Go1IiMjRcchko1p06bh2LFjKCgoQOvWrUXHIQLwf3ddSpKEgIAAREZGIjIyEr169RId0eCap5POzs5IS0sTHYcEYaHUU3BwMC5fvoxjx45BoVCIjkMkC82/yK1ZswZKpVJ0HKI/JZddlxs3bsT06dM5nZQ5Fko97Nu3D/7+/li/fj2mT58uOg6RLGi1WowYMQKSJCErK4u/yJFZsNRdl1qtFgMHDkTXrl05nZQ5Fko9hIaG4uLFizh+/Dh/qBG1kNjYWMyaNQs7d+5EYGCg6DhE982Sdl1yOknNWCgf0IEDBzBy5EjExcVh5syZouMQyUJ9fT08PT3h4+ODLVu2iI5DpLfGxkbs2rVLt+vy0qVLJrfrsrpeg9KKajRotLC1UcDV0QEOdjacTtJtWCgf0KRJk1BaWoqcnByz+U2SyNx98skneO2115CTk4N+/fqJjkNkUH/cdalWq3H69Glhuy6LL1dhTVYZMgrLUVZZgz8WBSsALp3t0dPmJta9+xIyNq+Fv79/i+Qi08VC+QAOHjwIPz8/qFQqzJo1S3QcIlm4du0a+vTpg5kzZ+Lrr78WHYfIqETtujxXWYNF8TnYXXIV1gorNGnvUBG0TYDCGgFuTngv0gc9O8t7sbvcsVA+gPDwcJw6dQq5ubmcThK1kAULFuDrr79GSUkJHnroIdFxiFpUS+y6jM0uw+ItedBopTsXyf9grbCCjcIKb0/xRswwF71zkHliobxPhw4dwrBhw/Drr79i9uzZouMQycKZM2fg6emJN954A2+99ZboOERCnT9/XrfrMjMz0yC7LldmFGNFapHe2RaEuOPFoL56X4fMDwvlfZo6dSoKCgpw8uRJTieJWohSqcTOnTtRXFwMBwcH0XGITIYhdl3GZpdhoTrHYJmWR/kgmpNK2WGhvA9Hjx7F4MGD8dNPP+Hxxx8XHYdIFpo/Ffjuu+/w1FNPiY5DZLIeZNflucoaTPg0E/UarcFy2NkokD4/kM9UygwL5X2IjIxEbm4u8vPzYWNjIzoOkcWTJAlBQUGoqKjAsWPH+KkA0T26112Xc77Pwr7TFff1zOTdWCusMKq3I355ys9g1yTTx0J5j44fP46BAwdi9erVmDt3rug4RLKwZcsWTJ06Fdu2bUNYWJjoOERm6a92XY6PnI29HccZ7b7p88fAzbmd0a5PpoWF8h49+uijOHbsGAoKCtCqVSvRcYgsnkajgY+PDx5++GGkpaWZ5WvpiEzNH3ddbjhjBW2f0bBSGH7yb62wwhy/Xlgyxdvg1ybTxM9t70FOTg7UajW+++47lkmiFvLdd9+hsLAQKpWKZZLIQBQKBUaOHImRI0ci66MMlFXWGOU+TVoJGUXlWAIWSrnghPIezJw5E9nZ2SgqKmKhJGoBVVVVcHNzQ2hoKH7++WfRcYgszq16DXyWpMCYBcAKQO6SUDjYcXYlBwrRAUxdXl4eNmzYgEWLFrFMErWQjz76CDdu3MCyZctERyGySGcrqo1aJgFAAlBaUW3ku5CpYKG8i3feeQc9e/bE3/72N9FRiGTh4sWL+PjjjzFv3jy4uHCXHZExNBhwTZAp3IfE4xz6DvLz87Fu3TqsWrUKtra2ouMQycJbb72FNm3a4PXXXxcdhchi2dq0zDyppe5D4rFQ3sGyZcvw8MMPc00QUQvJzc3F6tWr8dlnn6FDhw6i4xBZLFdHB1gBRn+G0tWRb7aSC9kXyup6DUorqtGg0cLWRgFXRwc42NmgsLAQsbGx+OKLL2BnZyc6JpEsvPbaa+jduzeeeeYZ0VGILJqDnQ1cOtvjrJFOeQOAi6M9D+TIiCz/ly6+XIU1WWXIKCxHWWXNbb+hWQFw6WyPxrPH0M1zMF/1RtRC0tPTkZSUhA0bNvARE6IWEOThjF+yzhr0LTnNrBVWCHJ3Nvh1yXTJam3QucoaLIrPwe6Sq7BWWN3xm0jSNsFKYY0ANye8F+nDd5ISGZFWq8WQIUNgb2+PPXv2cO8kUQsovlyF4M92Ge36fFOOvMjmadnY7DJM+DQT+05XAMBdfyNrfnPAvtMVmPBpJmKzy4yekUiufv31Vxw7dgwfffQRyyRRC+nbtR0C3JxgrTDs95y1wgoBbk4skzIjiwnlyoxirEgt0vs6C0Lc8WJQXwMkIqJmtbW18PDwwPDhw7FhwwbRcYhk5VxlDSZ8mol6A673sbNRIH1+ID/ZkxmLn1DGZpcZpEwCwIrUIsRxUklkUJ9//jkuXbqE999/X3QUItnp2dkebxv4fdtLp3izTMqQRRfKc5U1WLwlz6DXfGtLHs4Z8VQckZxcuXIF77//Pp577jn07cvpP5EIMcNcsCDE/ff/Q88PLV8N8UD0ML6QQI4sulAuis+BxsCn1zRaCYvicwx6TSK5eueddwD8vsyciMR5MagvAttcgKRpwP0+UmmtsIKdjQLLo3zwQpCbcQKSybPYQll8uQq7S64afB1Ck1bC7pKrKCmvMuh1ieSmuLgYq1atwqJFi+Dk5CQ6DpGsnTt3DhuWz0eYdBj+fX7/frzbYZ3mr4/q7Yj0+YGcTMqcxR7KWbIlz6j7teb49cISAz93QiQn06dPx8GDB1FYWIg2bdqIjkMkazNmzMDevXtRUFCA9u3b/+++5qJylFX8yb5mR3sEuTvjsREuPM1NACx4sXlGYblRyiTw+5Qyo6gcS8BCSfQg9u3bh40bN+Lnn39mmSQSLDU1FRs2bIBKpUL79u0B/L5SaMkUbyyB91++UY7ojyxyQnmrXgOfJSlGf0dp7pJQflMR3SdJkuDv74+6ujocOnQICoXFPnlDZPLq6+vh6+uL7t27Y8eOHdwDSw/MItvQ2Ypqo5ZJAJAAlFZUw7t7ByPficiybNy4Efv370d6ejrLJJFgn3zyCU6fPg21Ws0ySXqxyL/NGwy4oNUU7kNkKRoaGrBw4UKEhYVh/PjxouMQydrZs2fxzjvvYN68efD25iNcpB+LnFDa2rRMT26p+xBZiq+//hpnzpzBpk2bREchkr358+ejU6dOXNtFBmGRhdLV0QFWgNGfoXR1dDDiHYgsy/Xr17F06VI88cQT6N+/v+g4RLKWlJSE+Ph4xMXFoV07ntIm/VnkiM3BzgYuRn7tUyfbJkiNdUa9B5El+eCDD1BbW4ulS5eKjkIka3V1dXjppZcwfvx4zJgxQ3QcshAWWSgBIMjD+a5LWR+Ytgml+7bC2dkZs2bNQkJCAhoaGoxzLyILUFZWhs8++wwLFixA9+7dRcchkrUVK1agrKwMK1eu5EEcMhiLXBsE/P6mnODPdhnt+j/O6IP9KfFYs2YN8vLy0LlzZ8yYMQNKpRKjR4/m6VWiP3j88ceRmpqKkpIStG3bVnQcItkqLS1Fv3798I9//AMffPCB6DhkQSy2UALAnO+zsO90hUEXnFsrrDCqtyN+ecpP95/l5ORApVJBpVKhrKwMPXr0wKxZs6BUKjFgwAD+BkiyduTIEQwdOhSrVq3CM888IzoOkaxNmzYNhw8fRn5+Pn+5I4Oy6EJ5rrIGEz7NRL0B1/vY2SiQPj8QPf/kGU2tVot9+/ZBpVJh3bp1qKioQL9+/TB79mzMmjULvXv3NlgOInMgSRImTJiAS5cu4cSJE7CxschzgERmYevWrQgPD8f69esxffp00XHIwlh0oQSA2OwyLFTnGOx6y6N8ED3M5a7/XGNjI9LS0qBSqbBp0yZUV1djxIgRUCqVmDlzJrp27WqwTESmatu2bZg8eTK2bNmCiIgI0XGIZKu2thbe3t5wc3NDSkoKPzkjg7P4QgkAKzOKsSK1SO/rvBrigReC3O77z1VXV2PLli1QqVRITk6GVqvFhAkToFQqERkZqXt3KpEl0Wg0GDhwIJycnJCRkcEfYEQCvf3223j33XeRk5MDDw8P0XHIAsmiUAK/TyoXb8mDRivd1zOV1gor2CissHSK9z1NJu+moqICGzZsgEqlwq5du9C6dWtERERAqVQiLCwMdnZ2et+DyBR89913ePrpp5GdnY2hQ4eKjkMkW6dPn4aXlxdeeeUVvPvuu6LjkIWSTaEEfn+mclF8DnaXXIW1wuqOxbL56wFuTngv0udPn5nUV1lZGWJjY6FSqXD8+HF06NAB06dPh1KpRGBgIKytrQ1+T6KWUF1djb59+yIoKAhr1qwRHYdI1iIiInDixAmcPHkSDg58IQcZh6wKZbPiy1VYk1WGjKJylFXU3PZGHSsALo72CHJ3xmMjXODm3DJvEMjLy8PatWuhUqlw5swZdO/eHTExMVAqlRg8eDA/LiSzsnTpUrz77rsoLCyEq6ur6DhEspWQkIApU6ZArVYjMjJSdByyYLIslH9UXa9BaUU1GjRa2Noo4OroAAc7cSdRJUlCVlYWVCoV4uLiUF5eDnd3dyiVSiiVSvTt21dYNqJ78dtvv8HNzQ3PPfccPvroI9FxiGSrtrYWXl5e8PT0xLZt2ziYIKOSfaE0ZRqNBjt27IBKpYJarUZVVRWGDh0KpVKJmJgYdOvWTXREov/j2Wefxbp163Dq1Cl06tRJdBwi2XrrrbewfPly5ObmchhBRsdCaSZqa2uRmJgIlUqFbdu2obGxEePGjYNSqURUVBQ6duwoOiIRTp48CV9fX3z00UeYP3++6DhEslVSUgJvb2+89tpreOedd0THIRlgoTRD165dg1qthkqlQkZGBlq1aoXJkydDqVRi8uTJaNOmjeiIJFMRERHIy8tDfn4+NxYQCSJJEiZPnoyTJ0/i5MmTsLc3/KFSov/EQmnmLly4gLi4OKhUKhw+fBjt27dHVFQUlEolgoKC+GYSajE7d+5EUFAQYmNjER0dLToOkWxt2rQJkZGR2Lx5M6ZMmSI6DskEC6UFKSwsxNq1a7FmzRqUlJSga9euiI6OhlKpxPDhw/lANhmNVqvF8OHDYW1tjQMHDvDfNSJBampq0K9fP/j4+CAhIYHfi9RiWCgtkCRJOHz4MNasWYPY2Fj89ttv6N27t+6keL9+/URHJAujUqkwe/Zs7Nq1CwEBAaLjEMnWv/71L6xYsQJ5eXno06eP6DgkIyyUFq6pqQk7d+6ESqXCxo0bcePGDQwaNEh3UrxHjx6iI5KZq6urg6enJwYNGoT4+HjRcYhkq6ioCD4+Pnj99dexZMkS0XFIZlgoZaSurg5JSUlQqVRISEhAQ0MDxowZA6VSienTp6Nz586iI5IZWrFiBRYuXIi8vDy+I5hIEEmSMHHiRBQXFyMvL4+HM6nFsVDK1I0bN7Bp0yaoVCqkp6fD2toaEydOhFKpxJQpU3gqkO5JZWUl+vTpA6VSiS+//FJ0HCLZ2rhxI6ZPn46EhASEh4eLjkMyxEJJ+O2337Bu3TqoVCpkZWXBwcEBkZGRUCqVmDBhAlq1aiU6Ipmof/7zn/juu+9QUlICZ2dn0XGIZKm6ulr32MmWLVtExyGZYqGk25w6dUp3UrygoABOTk6YOXMmlEolRo4cCYVCIToimYjTp0/D09MTixcvxhtvvCE6DpFsvf766/jss89w8uRJPPLII6LjkEyxUNKfkiQJx44dg0qlwtq1a3HhwgX06tVLd1K8f//+oiOSYNHR0di7dy+Kior4iASRIAUFBfD19cWbb76JN998U3QckjEWSrorrVaL3bt3Q6VSYf369bh27Rp8fHygVCoxa9Ys9OrVS3REamFZWVkYMWIEfvjhBzzxxBOi4xDJkiRJCAkJwZkzZ5Cbm4vWrVuLjkQyxkJJ96WhoQEpKSlYs2YNtmzZgtraWvj7+0OpVGLmzJlwcnISHZGMTJIkjBkzBjdu3MDRo0dhbW0tOhKRLK1fvx4zZ87Etm3bEBYWJjoOyRwLJT2wqqoqbN68GSqVCqmpqbCyskJISAiUSiWmTp2Ktm3bio5IRtD8WreUlBSEhISIjkMkS1VVVejXrx+GDRvG/a9kElgoySCuXLmC9evXQ6VSYe/evWjTpg2mTp0KpVKJ0NBQ2Nraio5IBtDY2Ij+/fvD1dUVKSkpouMQydZrr72GlStX4uTJk3B1dRUdh4iFkgyvtLQUsbGxWLNmDXJzc9G5c2fMmDEDSqUSo0eP5klxM/bVV1/hxRdfxLFjx+Dr6ys6DpEsnTx5EgMGDMCSJUu4YYFMBgslGVVOTg5UKhVUKhXKysrQo0cPzJo1C0qlEgMGDICVlZXoiHSPbt68CTc3N0yePBmrV68WHYdIliRJwvjx43H+/Hnk5OTAzs5OdCQiACyU1EK0Wi32798PlUqFdevW4erVq+jXrx9mz56NWbNmoXfv3qIj0l3861//wieffIKioiK+A55IkNjYWMyaNQvJyckIDQ0VHYdIh4WSWlxjYyPS0tKgUqmwadMmVFdXY8SIEbqT4l27dhUdkf7D+fPn4e7ujvnz5+Pdd98VHYdIlqqqquDh4YFRo0Zhw4YNouMQ3YaFkoSqrq5GQkICVCoVkpKSoNVqMWHCBCiVSkRGRqJ9+/aiIxKAJ554Alu3bkVJSQn/NyESZMGCBVi1ahXy8/Ph4uIiOg7RbVgoyWRUVFRg48aNWLNmDXbt2oXWrVsjIiICSqUSYWFhfFZIkOPHj2PQoEH44osv8MILL4iOQyRLubm5GDhwIJYtW4aFCxeKjkP0f7BQkkk6d+4cYmNjoVKpcOzYMXTo0AHTp0+HUqlEYGAgl2m3oNDQUJSWliI3NxetWrUSHYdIdiRJwtixY3H58mWcOHGCa9jIJLFQksk7efIk1q5dC5VKhdOnT6Nbt26IiYnB7NmzMXjwYJ4UN6LU1FSEhoYiPj4e06ZNEx2HSJbWrFmDxx57DKmpqQgODhYdh+hPsVCS2ZAkCQcPHoRKpUJsbCzKy8vh7u6ue6e4u7u76IgWpampCYMHD0b79u2xa9cuFnciAW7cuAFPT08EBARg3bp1ouMQ/SUWSjJLGo0GO3bsgEqlglqtRlVVFYYOHQqlUono6Gh0795ddESz9+OPP+KJJ57AgQMH4OfnJzoOkSzNnz8f3377LQoKCriui0waCyWZvdraWmzduhUqlQpbt25FY2MjgoKCMHv2bERFRaFjx46iI5qdmpoauLu7w9/fH3FxcaLjEMnSiRMnMHjwYLz//vt49dVXRcchuiMWSrIo169fx8aNG6FSqZCRkYFWrVph8uTJUCqVmDx5Mtq0aSM6oll47733sGTJEhQUFHDpPJEAkiRhzJgxqKiowLFjx3gQh0weCyVZrIsXLyIuLg4qlQqHDh1Cu3btEBUVBaVSiXHjxsHGxkZ0RJNUXl4ONzc3PPXUU/j0009FxyGSpZ9//hl/+9vfsH37dowbN050HKK7YqEkWSgqKsLatWuxZs0aFBcXo2vXroiOjoZSqcTw4cN54OQPXnjhBaxZswanTp2Co6Oj6DhEsnP9+nV4eHhg3LhxWLt2reg4RPeEhZJkRZIkHD58WHdS/NKlS+jduzeUSiWUSiX69esnOqJQhYWF8Pb25jNbRAK9/PLLWL16NQoKCvDwww+LjkN0T1goSbaampqQmZkJlUqFDRs24MaNGxg4cCBmz56NmJgYWZ6ojIyMxNGjR1FQUIDWrVuLjkMkO8eOHcOQIUPw4Ycf4pVXXhEdh+iesVASAaivr0dSUhJUKhUSEhJQX1+PMWPGQKlUYvr06ejcubPoiEa3e/dujBkzBmvWrIFSqRQdh0h2tFotAgICcOPGDRw9epRvpiKzwkJJ9B9u3ryJ+Ph4qFQqpKenw9raGhMnToRSqcSUKVNgb28vOqLBSZKEkSNHQqPR4ODBg1AoFKIjEclO8+7XnTt3IjAwUHQcovvCQkl0B5cvX8a6deugUqlw4MABODg4IDIyEkqlEhMmTLCYCcK6desQHR2NjIwMjB07VnQcItm5du0aPDw8EBISgl9//VV0HKL7xkJJdI9OnTqlOyleUFAAJycnzJw5E0qlEiNHjjTbqV59fT28vLzg5eWFhIQE0XGIZOmFF17AL7/8gsLCQnTr1k10HKL7xkJJdJ8kScLx48ehUqmwdu1anD9/Hr169dKdFO/fv7/oiPfls88+wyuvvIKcnBx4eXmJjkMkO4cPH8awYcPwySefYN68eaLjED0QFkoiPWi1WuzZswcqlQrr169HZWUlfHx8oFQqMWvWLPTq1Ut0xDu6du0a3NzcMH36dPz73/8WHYdIdrRaLUaNGoWamhocOXKEL1wgs8VCSWQgDQ0NSElJgUqlwubNm1FbWwt/f38olUrMnDkTTk5OLZ6pul6D0opqNGi0sLVRwNXRAQ52//sD69VXX8WqVatQUlKChx56qMXzEcnd999/j7///e/YtWsXAgICRMchemAslERGcOvWLWzevBkqlQopKSmwsrJCSEgIlEolpk6dirZt2xrt3sWXq7AmqwwZheUoq6zBH7/BrQC4dLZHkIczxva0RuiIAVi0aBEWL15stDxE9OcqKyvh7u6OSZMm4eeffxYdh0gvLJRERnblyhWsX78eKpUKe/fuRZs2bTB16lQolUqEhobC1tbWIPc5V1mDRfE52F1yFdYKKzRp//pbu/nr2gt5SHvvSXj0aPnpKZHcPffcc1CpVCgqKkLXrl1FxyHSCwslUQsqLS1FbGwsVCoVcnJy0KlTJ8yYMQNKpRIBAQEPfFI8NrsMi7fkQaOV7lgk/5MVJNjaWOPtKd6IGebyQPcmovt36NAhDB8+HJ9//jleeukl0XGI9MZCSSRITk4O1q5dC5VKhbNnz6JHjx6YNWsWlEolBgwYACsrq3u6zsqMYqxILdI7z4IQd7wY1Ffv6xDRnTU1NWHkyJFoaGjAoUOHeBCHLAILJZFgkiRh//79WLNmDdatW4erV6+iX79+upPiffr0+cs/G5tdhoXqHINlWR7lg2hOKomM6ptvvsEzzzyDPXv2wN/fX3QcIoNgoSQyIY2NjUhPT4dKpUJ8fDyqq6vh5+eH2bNnY+bMmbc9Z3WusgYTPs1EvUZrsPvb2SiQPj8QPTtb3usliUzB1atX4eHhgSlTpmD16tWi4xAZDAslkYmqqalBQkICVCoVkpKS0NTUhAkTJkCpVCIyMhIvrM/HvtMV9/XM5N1YK6wwqrcjfnnKz2DXJKL/9V//9V9Yt24dioqK4OzsLDoOkcGwUBKZgYqKCmzcuBEqlQqZmZlw6O4Gp8c/M9r90uePgZtzO6Ndn0iOsrKyMHLkSHzxxRd44YUXRMchMigWSiIzc+7cObzww06cqOkAKKwNfn1rhRXm+PXCkineBr82kVw1NTXBz88PWq0W2dnZsLY2/PcukUgPtqOEiITp2bMnbtj3MEqZBIAmrYSMonKjXJtIrr799lscPnwYX331FcskWSQWSiIzc6teg7LKGqPeo6yiBtX1GqPeg0gurly5gkWLFuGpp57CiBEjRMchMgoWSiIzc7aiGsZ+TkUCUFpRbeS7EMnDwoULAQDvv/++4CRExsNtqkRmpsGAa4JM4T5Elmz//v344YcfsGrVKnTp0kV0HCKj4YSSyMzY2rTMt21L3YfIUjU1NeH555/HkCFD8PTTT4uOQ2RUnFASmRlXRwdYAUb+2FuCXcNNAB2MehciS/b111/j+PHjOHDgAA/ikMXjCILIzDjY2cDFyG+yaay8hL6PuGDAgAFYuHAhMjMz0djYaNR7ElmS8vJyvPHGG3j66acxfPhw0XGIjI57KInM0JItefgl66xB35LTzFphhekDumJgUxGSkpKQkpKC8vJytGvXDhMmTEBYWBgmTpyInj17GvzeRJbiiSeewJYtW1BUVARHR0fRcYiMjoWSyAwVX65C8Ge7jHb9P74pR6vV4ujRo0hKSkJycjL2798PrVYLb29vXbkcPXo07OzsjJaHyJzs3bsXo0ePxjfffMNnJ0k2WCiJzNSc77OEvMv72rVrSEtLQ3JyMpKTk3Hp0iU4ODhg/PjxmDhxIsLCwuDq6mqwTETmRKPRYMiQIWjdujX2798PhYJPlpE8sFASmalzlTWY8Gkm6g243sfORoH0+YHoeY/PaEqShOPHjyM5ORlJSUnYu3cvmpqa4OnpqSuXY8aMQevWrQ2WkciU/c///A/mzZuHgwcPYujQoaLjELUYFkoiMxabXYaF6hyDXW95lA+ih7k88J+/ceMGtm/fjqSkJCQlJeHChQuwt7dHUFCQrmD26dPHYHmJTMlvv/0GDw8PKJVKrFq1SnQcohbFQklk5lZmFGNFapHe13k1xAMvBLkZINHvJElCXl6erlzu2bMHjY2NcHNzQ1hYGMLCwhAYGAh7e+OeWCdqKY8//ji2bduGoqIidO7cWXQcohbFQklkAWKzy7B4Sx40Wum+nqm0VljBRmGFpVO89ZpM3ouqqirs2LFDVzDLysrQunVrBAYG6g73uLu7w8rKyqg5iIxh165dCAwMxHfffYennnpKdByiFsdCSWQhzlXWYFF8DnaXXIW1wuqOxbL56wFuTngv0ueen5k0FEmSUFBQoDs5npmZiYaGBjzyyCO6cjlu3Dg4ODi0aC6iB9HY2IjBgwejbdu22Lt3Lw/ikCyxUBJZmOLLVViTVYaMonKUVdTc9kYdKwAujvYIcnfGYyNcdKuBRKuurkZGRobucM/p06dha2uLMWPG6J697NevH6eXZJI+/fRTLFiwANnZ2Rg8eLDoOERCsFASWbDqeg1KK6rRoNHC1kYBV0cHONiZ9htXJUlCcXGxrlzu3LkTdXV1cHFx0U0vx48fj3btTKMMk7xdvHgRnp6eePzxx7Fy5UrRcYiEYaEkIpNWW1uLzMxM3bOXxcXFaNWqFUaPHq2bXvbv35/TSxJi9uzZSEtLQ2FhITp16iQ6DpEwLJREZFZOnTqlm17u2LEDtbW1ePjhh3XlcsKECejQoYPomCQDO3fuRFBQEFavXo25c+eKjkMkFAslEZmturo67N69W3e4Jz8/H9bW1hg1apTu4/GBAwdyekkG19jYiIEDB6Jjx47YvXs3D+KQ7LFQEpHFKC0t1b0Scvv27bh16xYeeugh3fQyODiYH0uSQXz88cd47bXXcPjwYQwcOFB0HCLhWCiJyCI1NDRgz549uullbm4uFAoFRowYoZteDh48mJMlum8XLlyAp6cnnnzySXz++eei4xCZBBZKIpKFc+fO6aaXaWlpqKqqgrOzM0JDQzFx4kSEhITAyclJdEwyAzExMdi5cycKCgrQsWNH0XGITAILJRHJTmNjI/bt26c73HP8+HFYWVlh+PDhuo/Hhw4dCmtra9FRycRs374dEyZMwM8//4w5c+aIjkNkMlgoiUj2Ll68iJSUFCQlJSEtLQ3Xr1+Ho6MjQkJCEBYWhtDQUDg7O4uOSYI1NDRgwIABcHJywq5du3jYi+gPWCiJiP5Ao9EgKytL9+zl4cOHAQBDhgxBWFgYwsLCMHz4cNjYmPaCeDK8Dz/8EIsWLcKRI0fg6+srOg6RSWGhJCK6g8uXL+uml6mpqaisrESnTp0QHBysm15269ZNdEwysnPnzqFfv354+umn8emnn4qOQ2RyWCiJiO5RU1MTsrOzddPL7OxsSJKEgQMH6k6Ojxw5Eq1atRIdlQxs5syZ2L17NwoKCrg4n+hPsFASET2gK1euIDU1FcnJyUhJScGVK1fQvn17BAcHY+LEiZg4cSJ69OghOibpKS0tDSEhIVizZg2USqXoOEQmiYWSiMgAtFotDh8+rDs5npWVBa1WCx8fH93JcX9/f9ja2oqOSvehvr4evr6+6NatGzIyMngQh+gvsFASERlBZWUl0tLSdB+PX758GW3btsX48eN1h3tcXFxEx6S7eP/99/Hmm2/i+PHj8Pb2Fh2HyGSxUBIRGZlWq8Xx48eRlJSEpKQk7N+/H01NTfDy8tJNLwMCAmBnZyc6Kv1BWVkZPD098fzzz2PFihWi4xCZNBZKIqIWdv36daSnp+umlxcvXoS9vT3GjRunm14+8sgjomPK3qOPPooDBw6goKAA7dq1Ex2HyKSxUBIRCSRJEnJycnTlcs+ePdBoNHB3d9eVyzFjxqBNmzaio8pKcnIywsLCsHbtWsTExIiOQ2TyWCiJiEzIzZs3sX37dt3hnnPnzqFNmzYYO3as7uPxvn37io5p0err69G/f3/07NkT27dv50EconvAQklEZKIkScLJkyd15XLXrl1obGxEnz59dHsvg4KCYG9vLzqqRXn33XexZMkSnDhxAv369RMdh8gssFASEZmJW7duISMjQ3e4p7S0FHZ2dggMDNRNLz08PDhR00NpaSm8vLzw0ksvYfny5aLjEJkNFkoiIjMkSRKKiop05TIzMxP19fVwdXXVlctx48ahbdu2oqOalWnTpuHQoUMoKCjgf3dE94GFkojIAtTU1GDnzp26gnnq1Cm0atUKAQEBusM9Xl5enF7ewdatWxEeHo5169ZhxowZouMQmRUWSiIiC1RSUqI7OZ6RkYHa2lr07NlTN70cP3482rdvLzqmyairq4O3tzd69+6N1NRUFm+i+8RCSURk4Wpra7Fr1y7d4Z7CwkLY2NjA399fd7jH19dX1iVq6dKlWLZsGU6cOAFPT0/RcYjMDgslEZHMnDlzRlcut2/fjpqaGnTv3h0TJ07ExIkTERwcjI4dO4qO2WJOnz4Nb29vzJs3D++//77oOERmiYWSiEjG6uvrsWfPHt2zlydPnoS1tTVGjhyp+3h84MCBUCgUoqMazZQpU3Ds2DHk5+fDwcFBdBwis8RCSUREOmfPnkVKSgqSkpKQnp6OW7duoWvXrggNDUVYWBhCQkLQuXNn0TENJiEhAVOmTMHGjRsRFRUlOg6R2WKhJCKiP9XQ0IB9+/bpppc5OTlQKBQYPny47uT4kCFDTHZ6WV2vQWlFNRo0WtjaKODq6AAHOxvd12tra+Ht7Q13d3ckJSXJ+hlSIn2xUBIR0T25cOGC7tnLtLQ03Lx5E05OTrdNL7t06SI0Y/HlKqzJKkNGYTnKKmvwxx9wVgBcOtsjyMMZs/1c8OtXK/DBBx8gNzeXr7Mk0hMLJRER3bfGxkYcOHBAt5ro6NGjsLKywtChQ3Unx4cPHw5ra+sWyXOusgaL4nOwu+QqrBVWaNL+9Y+25q/Xnz2G6Ee0+OzdN1skI5ElY6EkIiK9Xbp0CSkpKUhOTkZqaiquXbuGzp07IyQkBGFhYQgNDUXXrl2Ncu/Y7DIs3pIHjVa6Y5H8T5K2Ca1tW+HtKd6IGeZilGxEcsFCSUREBqXRaHDw4EHdx+OHDh0CAAwePFh3cnzEiBGwsbG5y5XubmVGMVakFul9nQUh7ngxiB97Ez0oFkoiIjKq8vJypKamIikpCSkpKaioqECHDh0QHBys+3i8e/fu933d2OwyLFTnGCzn8igfRHNSSfRAWCiJiKjFNDU14fDhw7qT4wcPHoQkSfD19dWdHB81ahRatWp1x+ucq6zBhE8zUa/RGiybnY0C6fMD0bOzvcGuSSQXLJRERCRMRUXFbdPL8vJytGvXDhMmTNBNL3v27Pl//tyc77Ow73TFfT0zeTfWCiuM6u2IX57yM9g1ieSChZKIiEyCVqvF0aNHdSfH9+/fD61WC29vb9300t/fH2XXGxD82S6j5UifPwZuzu2Mdn0iS8RCSUREJunatWtIS0tDcnIykpOTcenSJTg4OMBT+SYqHL0hwfCLyK0VVpjj1wtLpngb/NpEloyFkoiITJ4kSTh+/DiSk5Px3W89oGnTyWj36uVoj8wFQUa7PpElYqEkIiKzcateA58lKTDmDy4rALlLQm97TSMR3ZlpvoCViIjoT5ytqDZqmQQACUBpRbWR70JkWVgoiYjIbDQYcE2QKdyHyFKwUBIRkdmwtWmZH1stdR8iS8HvGCIiMhuujg5GONt9O6v/fx8iuncslEREZDYc7GzgYuQ32bg42vNADtF9YqEkIiKzEuThDGuFceaU1gorBLk7G+XaRJaMhZKIiMzKbD8Xg75y8Y+atBIeG+FilGsTWTIWSiIiMit9u7ZDgJuTwaeU1gorBLg58bWLRA+AhZKIiMzOe5E+sDFwobRRWOG9SB+DXpNILlgoiYjI7PTsbI+3Dfy+7aVTvNHTyAd+iCwVCyUREZmlmGEuWBDibpBrvRrigehhfHaS6EHxXd5ERGTWYrPLsHhLHjRa6b4O61grrGCjsMLSKd4sk0R6YqEkIiKzd66yBovic7C75CqsFVZ3LJbNXw9wc8J7kT78mJvIAFgoiYjIYhRfrsKarDJkFJWjrKIGf/wBZ4Xfl5YHuTvjsREuPM1NZEAslEREZJGq6zUorahGg0YLWxsFXB0d+AYcIiNhoSQiIiIivfCUNxERERHphYWSiIiIiPTCQklEREREemGhJCIiIiK9sFASERERkV5YKImIiIhILyyURERERKQXFkoiIiIi0gsLJRERERHphYWSiIiIiPTCQklEREREemGhJCIiIiK9sFASERERkV5YKImIiIhILyyURERERKQXFkoiIiIi0gsLJRERERHphYWSiIiIiPTCQklEREREemGhJCIiIiK9sFASERERkV5YKImIiIhILyyURERERKQXFkoiIiIi0gsLJRERERHphYWSiIiIiPTCQklEREREemGhJCIiIiK9sFASERERkV5YKImIiIhILyyURERERKQXFkoiIiIi0gsLJRERERHphYWSiIiIiPTCQklEREREemGhJCIiIiK9sFASERERkV7+Hz0KmN7pL9byAAAAAElFTkSuQmCC",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABxjklEQVR4nO3deVyU5cI+8GuGTcEtUMxUAkVQkVxR3FAUcANMg7TU6mTHFrM0l8w0rUxzqbQ091ZNa1AM3NgERVFcUQRkURBXUHBBUGCY5/dH+fzyvGUqM9wzz1zfz+f88UY+z/WeE80196qSJEkCEREREdFjUosOQERERESmjYWSiIiIiKqFhZKIiIiIqoWFkoiIiIiqhYWSiIiIiKqFhZKIiIiIqoWFkoiIiIiqhYWSiIiIiKqFhZKIiIiIqoWFkoiIiIiqhYWSiIiIiKqFhZKIiIiIqoWFkoiIiIiqhYWSiIiIiKqFhZKIiIiIqoWFkoiIiIiqhYWSiIiIiKqFhZKIiIiIqoWFkoiIiIiqhYWSiIiIiKqFhZKIiIiIqoWFkoiIiIiqhYWSiIiIiKqFhZKIiIiIqoWFkoiIiIiqhYWSiIiIiKqFhZKIiIiIqoWFkoiIiIiqhYWSiIiIiKqFhZKIiIiIqoWFkoiIiIiqhYWSiIiIiKqFhZKIiIiIqoWFkoiIiIiqhYWSiIiIiKqFhZKIiIiIqoWFkoiIiIiqxVJ0ACJzUlquRV5RKSq0OlhbquHsYAc7G/4aEhGRaeMnGZGBZReUYENyPuIzC5FfXAbpLz9TAXCyt4WvuyNGdXNCq8Z1RcUkIiJ6bCpJkqR//9uI6FGdLy7DjPBUJOZcg4VahSrdP/+q3ft5b9eGmDfME83tbWswKRERUfWwUBIZwKbD+ZgdkQatTnpgkfxfFmoVLNUqfBzsgZFeTgZMSEREpD8slER6tiw+G4ujs6r9nCkBbnjbt5UeEhERERkWd3kT6dGmw/l6KZMAsDg6C78eztfLs4iIiAyJhZJIT84Xl2F2RJpen/lRRBrOF5fp9ZlERET6xkJJpCczwlOhfYT1kg9Dq5MwIzxVr88kIiLSNxZKIj3ILihBYs61R9qA8zCqdBISc64hp7BEr88lIiLSJxZKIj3YkJwPC7XKIM+2UKuw/iDXUhIRkfFioSTSg/jMQr2PTt5TpZMQn1VokGcTERHpAwslUTXdLtci38AbZ/KLylBarjXoO4iIiB4XCyVRNZ0rKoWhD3OVAOQVlRr4LURERI+HhZKomiq0OkW9h4iI6FGxUBJVk7Vlzfwa1dR7iIiIHhU/oYiqydnBDobZ3/0XkoStP69BSkoKdDqOVBIRkXFhoSSqJjsbSzjZ2xr0HdYVNzHvk9no2LEjmjRpgtGjR+Onn37C5cuXDfpeIiKih8FCSaQHvu6OBj2H8sW+HVBcXIzdu3fj1VdfRUZGBl5++WU89dRT8PT0xOTJkxEVFYWyMl7TSERENU8lSZKhN6gSKV52QQn8l+w12PNjJ/nA1bHufX/t6tWriIuLQ3R0NKKjo3Hx4kXY2NigV69eCAgIQEBAAJ555hmo1fzeSEREhsVCSaQnY9YlI+lskV4POLdQq9CjhQN+HtvtgX+fJEnIyMhATEwMoqOjkZCQgLKyMjg6OsLf3x8BAQHw9/dHkyZN9JaNiIjoHhZKIj05X1wGv6/2oFyPx/vYWKoRO6kPmj/iGs3y8nIkJSXJo5fHjh0DALRr104evezduzdsbQ279pOIiMwDCyWRHm06nI/pW1L19rwFwz0xwsup2s/h9DgRERkSCyWRni2Lz8bi6Cz8cb/N42/UmRrgjvG+rnrLdc+/TY/f+89TTz2l93cTEZEysVASGcCqmFTMi86B2sISkurhR/0s1CpYqlX4JNhDLyOTD+Ov0+MxMTE4evQoAE6PExHRw2OhJDKAMWPGIGrfEfSbvgYH827CQq164Gadez/v7doQ84Z5PvKaSX3i9DgRET0qFkoiPUtMTISPjw/Wrl2LsWPHIrugBBuS8xGfVYj8ojL89RdOBcDJwRa+bo4Y7e30f44GEo3T40RE9DBYKIn0SKvVolOnTrC1tUVSUtL/GcUrLdcir6gUFVodrC3VcHawg52NpaC0j47T40RE9HdYKIn0aOnSpZg0aRIOHz6Mzp07i45jcH83PW5tbY3evXtzepyIyIywUBLpyZUrV+Du7o4XX3wRK1asEB2nxkmShNOnT8vlktPjRETmg4WSSE9efvllbN++HVlZWbC3txcdRzhOjxMRmQ8WSiI92LdvH3r37o01a9bgtddeEx3HKHF6nIhIuVgoiapJq9Wic+fOqFWrFg4cOMBC9BAeND3u5+cn3z3O6XEiItPAQklUTd988w3effddHDp0CF26dBEdxyTdmx6/dzwRp8eJiEwLCyVRNRQUFMDNzQ0vvPACVq5cKTqOYnB6nIjItLBQElXDK6+8gsjISGRlZcHBwUF0HEX6p+nxRo0awd/fn9PjRERGgIWS6DElJSWhZ8+eWLVqFcaNGyc6jtkoLy/HgQMH5IJ57NgxSJIkT4/7+/vDx8eH0+NERDWIhZLoMWi1Wnh5ecHKygoHDhyAhYWF6Ehmi9PjRETisVASPYZly5bhnXfeQXJyMry8vETHoT9xepyISAwWSqJHVFhYCDc3Nzz//PNYvXq16Dj0AA+aHr9XMDk9TkRUfSyURI/o1Vdfxe+//47MzEw0bNhQdBx6BPemx+8dT3ThwoX7psf9/f3Rvn17To8TET0iFkqiR3DgwAH06NEDK1euxOuvvy46DlUDp8eJiPSHhZLoIVVVVcHLywtqtRrJycnciKMwnB4nInp8LJRED+nbb7/F22+/jYMHD6Jr166i45CBcXqciOjhsVASPYSrV6/Czc0NISEhWLNmjeg4VMM4PU5E9GAslEQPYezYsQgPD0dWVhY34tA/To97eHjIZ19yepyIzAkLJdG/OHjwILp3745vv/0Wb775pug4ZISuXbt23+HqnB4nInPDQkn0AFVVVfJ6yUOHDnEjDv0rTo8TkTlioSR6gBUrVuCtt97CgQMH4O3tLToOmSBOjxOROWChJPoHV69ehbu7O4YNG4Z169aJjkMKwelxIlIiFkqif/Daa69h8+bNyMrKQqNGjUTHIQXi9DgRKQULJdHfSE5Ohre3N5YvX4633npLdBwyE5weJyJTxUJJ9D+qqqrQrVs36HQ6HD58mBtxSJgHTY/fG8E0henx0nIt8opKUaHVwdpSDWcHO9jZWIqORUR6xEJJ9D9WrVqFN954A0lJSejevbvoOEQA7p8ej4mJQXx8vFFPj2cXlGBDcj7iMwuRX1yGv37QqAA42dvC190Ro7o5oVXjuqJiEpGesFAS/cW1a9fg5uaGZ599Ft99953oOET/yFinx88Xl2FGeCoSc67BQq1Cle6fP2Lu/by3a0PMG+aJ5vacyicyVSyURH8xbtw4aDQaZGZmwtHRUXQcoodmDNPjmw7nY3ZEGrQ66YFF8n9ZqFWwVKvwcbAHRno5GSwfERkOCyXRnw4dOgRvb2988803GD9+vOg4RI9NxPT4svhsLI7OqvZzpgS44W3fVnpIREQ1iYWSCH9sxPH29oZWq8WRI0e4EYcUxdDT45sO52P6llS95V0w3BMjOFJJZFJYKIkArF69Gq+//jr279+PHj16iI5DZFD/ND3eq1cvuWA+7PT4+eIy+H21B+Vand7y2ViqETupD9dUEpkQFkoye0VFRXBzc0NQUBB++OEH0XGIalR1p8fHrEtG0tmiR1oz+W8s1Cr0aOGAn8d209sziciwWCjJ7L3++uv49ddfkZmZicaNG4uOQyTUo0yPZxeUwH/JXoNliZ3kA1dHHilEZApYKMmsHTlyBF27dsXSpUsxYcIE0XGIjM6Dpsdte72MtEoH6HFwUmahVmFMt6cxJ9hD/w8nIr1joSSzpdPp4O3tjfLychw9ehSWlry5g+hBJElCZmamXC5Tmg+DZYMnDfa+px1ssWeKr8GeT0T6w0JJZmvNmjUYN24cEhMT0atXL9FxiEzK7XItPOdEwZAfICoAp+YM4DWNRCbAuC+AJTKQ4uJifPDBB3jppZdYJokew7miUoOWSQCQAOQVlRr4LUSkDyyUZJY+/PBDVFZWYuHChaKjEJmkCj0eE2QM7yGi6uE8ApmdI0eOYNWqVViyZAl3dRM9JmvLmhmPqKn3EFH1cA0lmRWdTocePXrgzp073IhDVA2l5Vq04xpKIvoTf0vJrHz//fdITk7G3r17WSaJqsHOxhJO9rY4V1xmsHc8WccStta8BpXIFHAugcxGcXExpk+fjjFjxqB3796i4xCZPF93R1ioVQZ5tqSrQmbCFrRu3RoffvghUlJSwAk1IuPFQklmY+bMmaioqOBGHCI9GdXNSa9XLv6VSm2BRa8Ho2fPnlixYgU6duwINzc3fPDBB/LtPURkPLiGkszCsWPH0KVLF3z55ZeYOHGi6DhEilETd3lXVFQgPj4eGo0G4eHhKC4uRosWLRASEoLQ0FB07twZKpVhRkqJ6OGwUJLi6XQ69OzZE7dv38bx48e5dpJIj84Xl8Hvqz0o1+PxPjaWasRO6oPm9rb/52eVlZVISEiQy+W1a9fg7Owsl0svLy+WSyIBWChJ8b777juMHTsWe/bsgY+Pj+g4RIqz6XA+pm9J1dvzFgz3xAgvp3/9+7RaLfbs2QONRoMtW7bg6tWrcHJykstl165doVZzZRdRTWChJEW7fv063NzcMGDAAKxfv150HCLFWhafjcXRWfjjfpvHHyGcGuCO8b6uj/znqqqqsHfvXrlcFhQUoFmzZggJCUFISAi6d+/OcklkQCyUpGhvv/02fvrpJ2RmZqJJkyai4xAp2vd7MzEnMh0qC0tA9fDlzUKtgqVahU+CPR5qZPLfVFVVYd++fdBoNNi8eTOuXLmCpk2b4rnnnkNISAh69uzJckmkZyyUpFjHjx9Hly5dsHjxYkyaNEl0HCLF++CDD/DN9xsx6KOfcPh8CSzUqgdu1rn3896uDTFvmOffrpmsrqqqKiQlJSEsLAxhYWG4dOkSmjRpIpfLXr16wcKCZ10SVRcLJSmSTqdDr169cOvWLRw/fhxWVlaiIxEp2rlz5+Du7o5p06bhk08+QXZBCTYk5yM+qxD5RWX33aijAuDkYAtfN0eM9naCq2PdGsmo0+lw4MABuVxeuHABjRs3xvDhwxEaGgofHx+WS6LHxEJJivTDDz/gP//5DxISEtCnTx/RcYgUb/To0YiNjUV2djbq1r2/IJaWa5FXVIoKrQ7Wlmo4O9gJv05Rp9MhOTlZLpf5+flwdHTEsGHDEBoaij59+vBECKJHwEJJinP9+nW4u7vD398fGzZsEB2HSPEOHz6Mrl27YvXq1fjvf/8rOs4jkyQJhw8fhkajgUajwblz59CwYUO5XPbt25ezHET/goWSFGfChAn44YcfkJmZiaeeekp0HCJFkyQJffv2RVFREVJSUkx+VE+SJBw9elQul7m5uXBwcMCzzz6L0NBQ9OvXj+WS6G+wUJKipKSkoHPnzli4cCEmT54sOg6R4m3duhXDhg3Dzp07MXDgQNFx9EqSJBw/flwul2fOnMETTzwhl8v+/fvD2tpadEwio8BCSYqh0+nQu3dv3LhxAykpKRxFIDKwyspKeHh4wNnZGVFRUYq+oUaSJJw4cUIul9nZ2WjQoAGGDh2KkJAQ+Pv7w8bGRnRMImFYKEkxfvzxR7zyyiuIj49H3759RcchUrxvvvkG7777LlJSUvDMM8+IjlNjJElCamoqwsLCoNFocPr0adSvXx/BwcEICQlBQEAAatWqJTomUY1ioSRFuHHjBtzd3dGvXz9s3LhRdBwixbtx4wZcXV0xdOhQrFu3TnQcYSRJQlpamlwu09PTUbduXblcDhgwALVr1xYdk8jgWChJEd5991189913OH36NJo2bSo6DpHiTZs2DcuXL0d2djY3v/1Fenq6XC5PnTqFOnXqIDAwEKGhoRg0aBDLJSkWCyWZvBMnTqBTp05YsGABpkyZIjoOkeLl5eXB3d0dH3zwAebMmSM6jtE6ffq0XC5PnjwJOzs7DBkyBKGhoRg8eDBsbfV/MxCRKCyUZNIkSYKPjw+Kiopw4sQJbsQhqgEvvPAC9uzZg+zsbNjZ2YmOYxKysrLkcpmSkgJbW1sMHjwYoaGhGDJkCP97JJPHQkkm7eeff8ZLL72EuLg49OvXT3QcIsVLTk6Gt7c31q5di7Fjx4qOY5JycnLkcnns2DHUrl0bgwYNQmhoKAIDA1GnTh3REYkeGQslmaybN2/C3d0dffv2xaZNm0THIVI8SZLQu3dv3Lp1C8ePH+e913pw9uxZ+frHw4cPo1atWhg4cKBcLuvVqyc6ItFDYaEkkzVx4kSsXbsWp0+fRrNmzUTHIVK8LVu24LnnnkNUVBQCAgJEx1GcvLw8uVwmJyfDxsYGAwYMQGhoKIKCglC/fn3REYn+EQslmaSTJ0+iU6dOmDdvHqZNmyY6DpHiVVRUwMPDA66urti5c6foOIqXn5+PzZs3Q6PR4MCBA7C2tkZAQABCQ0MRHByMBg0aiI5IdB8WSjI59zbiXLt2DSdOnODVZ0Q1YOnSpXjvvfdw4sQJtGvXTnQcs3L+/Hls2bIFGo0G+/fvh5WVFfz9/RESEoKhQ4fC3t5edEQiFkoyPevXr8eYMWMQGxuL/v37i45DpHjXr1+Hq6srnnvuOaxevVp0HLN28eJFuVzu27cPFhYW8PPzQ0hICJ599lk4ODiIjkhmioWSTMrNmzfRunVr9O7dG7/99pvoOERmYcqUKVi5ciVycnLw5JNPio5Df7p8+bJcLvfu3Qu1Wo3+/fsjJCQEw4YNQ8OGDUVHJDPCQkkmZdKkSVizZg034hDVkLNnz6JNmzaYOXMmZs2aJToO/YMrV64gPDwcGo0Ge/bsgUqlgq+vr1wuHR0dRUckhWOhJJORmpqKjh074rPPPsP7778vOg6RWRgxYgT27duHrKwsHr5tIgoLCxEeHo6wsDDEx8dDkiT06dMHoaGhGD58OBo3biw6IikQCyWZBEmS0LdvXxQUFODkyZPciENUAw4cOIAePXrg+++/xyuvvCI6Dj2Gq1evYuvWrQgLC0NcXBx0Oh18fHzkctmkSRPREUkhWCjJJPzyyy8YNWoUoqOj4e/vLzoOkeJJkoSePXuirKwMR48e5SHmClBUVCSXy9jYWFRVVaFXr15yuWzatKnoiGTCWCjJ6N26dQvu7u7o1asXNBqN6DhEZkGj0eD555/naQoKVVxcjIiICGg0GsTExKCyshI9e/ZEaGgonnvuOa5Rp0fGQklGb/LkyVi5ciVOnz6N5s2bi45DpHjl5eVo27YtWrduje3bt4uOQwZ2/fp1REZGQqPRIDo6GhUVFejevbtcLp2cnERHJBPAQklG7dSpU+jQoQM+/fRTfPDBB6LjEJmFL7/8ElOnTkVqairatm0rOg7VoJs3b8rlMioqCuXl5ejWrRtCQkIQEhICZ2dn0RHJSLFQktGSJAm+vr64fPkyTp48CRsbG9GRiBSvuLgYLVu2xIgRI7By5UrRcUigW7duYdu2bdBoNNi5cyfKy8vh5eUll8sWLVqIjkhGhIWSjNbGjRvx4osvIioqCgEBAaLjEJmFSZMmYe3atcjJyeHxMiQrKSnB9u3bERYWhh07duDOnTvo1KkTQkNDERoaipYtW4qOSIKxUJJRKikpgbu7O7p3747NmzeLjkNkFnJyctC2bVvMnj0bH374oeg4ZKRu376NHTt2QKPRYPv27bhz5w46dOggl8tWrVqJjkgCsFCSUZoyZQq+/fZbnD59mgvCiWpISEgIkpOTkZmZCVtbW9FxyASUlpZi586dCAsLw7Zt21BaWopnnnlGLpfu7u6iI1INYaEko5Oeno727dvj448/xowZM0THITIL+/fvR69evfDjjz/ipZdeEh2HTFBZWRl27dqFsLAwREZG4vbt22jXrh1CQ0MREhLCDV4Kx0JJRkWSJPTv3x8XLlxAamoqN+IQ1QBJktC9e3dUVFTgyJEjUKvVoiORibtz5w6io6Oh0WgQERGBkpIStG3bVi6XHh4eUKlUomOSHrFQklHZtGkTXnjhBezcuRMDBw4UHYfILPz6668YOXIkdu/eDV9fX9FxSGHu3r2LmJgYaDQa/P7777h16xZat24tl0tPT0+WSwVgoSSjUVJSgtatW6Nbt27YsmWL6DhEZuHu3bto06YNPD09ERERIToOKVx5eTliY2Plcnnjxg24ubnJ5bJ9+/YslyaKhZKMxrRp07Bs2TJkZGTg6aefFh2HyCwsXrwY06dPx6lTp9C6dWvRcciMVFRUIC4uDhqNBlu3bsX169fh6uqKkJAQhIaGomPHjiyXJoSFkozCvY04s2fPxsyZM0XHITIL165dg6urK0aNGoXly5eLjkNmrLKyErt370ZYWBjCw8NRVFSEFi1ayOWyc+fOLJdGjoWShJMkCX5+fsjPz0dqaipq1aolOhKRWXj33Xfx/fffIycnB46OjqLjEAH4o1wmJCQgLCwMW7ZswbVr1+Ds7CyXSy8vL5ZLI8RCScL99ttvGDFiBHbs2IFBgwaJjkNkFrKysuDh4YFPP/0U06dPFx2H6G9ptVrs2bNHLpeFhYVwcnKSy2XXrl2FnUpQWq5FXlEpKrQ6WFuq4exgBzsbSyFZjAELJQl1+/ZttG7dGl26dMHWrVtFxyEyG8OHD8fRo0dx+vRp1K5dW3Qcon9VVVWFxMREaDQabN68GQUFBWjWrJlcLr29vQ1eLrMLSrAhOR/xmYXILy7DXwuUCoCTvS183R0xqpsTWjWua9AsxoaFkoR6//338fXXXyMjIwPOzs6i4xCZhb1796JPnz5Yv349Ro0aJToO0SOrqqrC/v375XJ5+fJlNG3aFM899xxCQkLQs2dPvZbL88VlmBGeisSca7BQq1Cl++fqdO/nvV0bYt4wTzS3N49bp1goSZjTp0/D09MTH330EWbNmiU6DpFZ0Ol08Pb2hiRJSE5O5iHmZPJ0Oh2SkpLkcnnx4kU0adJELpe9evWChYXFYz9/0+F8zI5Ig1YnPbBI/i8LtQqWahU+DvbASC/lXyHMQklCSJKEgIAA5Obm4tSpU9yIQ1RDfvnlF4waNQoJCQno06eP6DhEeqXT6XDw4EFoNBqEhYXhwoULePLJJzF8+HCEhITAx8fnkcrlsvhsLI7OqnauKQFueNu3VbWfY8xYKEkIjUaD559/Htu2bcOQIUNExyEyC3fv3oW7uzs6duzINcukeDqdDocOHUJYWBg0Gg3y8/Ph6Ogol8s+ffrA0vKfN9FsOpyP6VtS9ZZnwXBPjFDwSCULJdW427dvo02bNujUqRN+//130XGIzMaCBQswc+ZMpKWlwc3NTXQcohojSRIOHz4sl8u8vDw0bNgQw4YNQ2hoKHx9fe8rl+eLy+D31R6Ua3V6y2BjqUbspD6KXVPJQkk17oMPPsCSJUuQnp4OFxcX0XGIzMLVq1fh6uqKl19+GV9//bXoOETCSJKEo0ePyuXy7NmzcHBwwLPPPovQ0FD069cPr/50DElnix5pzeS/sVCr0KOFA34e201vzzQmLJRUozIzM+Hp6YmZM2fio48+Eh2HyGy8/fbbWL9+PXJyctCwYUPRcYiMgiRJSElJgUajgUajQU5ODhxcPFBnxAKDvTN2kg9cHZV3pBALJdUYSZIwYMAAnDlzBmlpadyIQ1RDMjMz4eHhgfnz52Pq1Kmi4xAZJUmScPLkSUz79TAyqxwB9ePvDP8nFmoVxnR7GnOCPfT+bNF4XgTVmC1btiAmJgZLly5lmSSqQdOmTUOzZs0wYcIE0VGIjJZKpUL79u1x94mWBimTAFClkxCfVWiQZ4tmvncEUY0qLS3FpEmTEBgYiMDAQNFxiMxGQkICIiIisHHjRn6RI/oXt8u1yC8uM+g78ovKUFquVdw1jRyhpBrx2WefobCwEEuXLhUdhchs6HQ6TJ48GV27dsWIESNExyEyeueKSmHodYASgLyiUgO/peYpqx6TUcrKysLixYsxY8YMtGjRQnQcIrPxyy+/4NixY0hMTIRKpRIdh8joVejxmCBjeE9N4gglGZQkSZgwYQKaNWuG999/X3QcIrNx584dzJgxA8OHD0evXr1ExyEyCdaWNVOLauo9NYkjlGRQ4eHhiI6ORkREBGrXri06DpHZWLJkCS5fvowFCwx3/AmR0jg72EEFGHTaW/Xne5RGeRWZjEZZWRkmTZqEIUOGICgoSHQcIrNRWFiI+fPnY/z48XB1dRUdh8hk2NlYwsnAN9k4OdgqbkMOwEJJBjRv3jwUFBRwIw5RDZszZw4sLCwwa9Ys0VGITI6vuyMs1IZZc2yhVsHXzdEgzxaNhZIMIjs7G4sWLcL777+Pli1bio5DZDYyMjKwevVqzJw5Ew4ODqLjEJmcUd2c9Hrl4l9V6SSM9nYyyLNF4005pHeSJGHw4ME4ffo00tPTuXaSqAYFBQUhLS0NGRkZsLGxER2HyCSNWZfMu7wfEUcoSe9+//137Nq1C0uWLGGZJKpBu3fvxrZt2/D555+zTBJVw7xhnrDU87S3pVqFecM89fpMY8IRStKrsrIytGnTBu3atcO2bdt49h1RDdHpdOjcuTNq1aqFpKQk/u4RVdOmw/mYviVVb89bMNwTI7yUOd0N8Ngg0rP58+fjypUriIuL4wcaUQ36+eefkZKSgv379/N3j0gPRno54drtciyOzqr2s6YGuCu6TAIcoSQ9ysnJgYeHB6ZNm4ZPP/1UdBwis1FWVgY3Nzf06NEDv/32m+g4RIqy6XA+ZkekobxSC6gefqWghVoFS7UKnwR7KL5MAiyUpCeSJGHIkCFIT09Heno6bG0Ne44XEf1/c+fOxSeffIKMjAyeqkBkAEknMjF8vga1XDrCQq164Gadez/v7doQ84Z5ormBz7U0FpzyJr2IiIjAzp07ER4ezjJJVIOuXLmCzz//HBMmTGCZJDKQH5Z/ASn+d0QsOIUtJwoRn1WI/KKy+27UUeGPQ8t93Rwx2tsJro51RcUVgiOUVG1lZWVo27Yt2rRpgx07dnD9FlENev3116HRaJCTkwN7e3vRcYgU59y5c3B1dcX8+fMxZcoU+a+XlmuRV1SKCq0O1pZqODvYKfIGnIdlvv+fk958/vnnuHz5MmJiYlgmiWpQWloa1q5diy+++IJlkshAPv/8czRo0ABvvPHGfX/dzsYSHk/VF5TK+HCEkh7o376BnTlzBh4eHpgyZQrmzp0rMCmR+Rk8eDCysrKQnp4Oa2tr0XGIFOf8+fNo2bIlPvnkE0yfPl10HKPGEUr6P7ILSrAhOR/xmYXIL/6bNSL2tvB1d8SLXZtj0jvvoHHjxpgxY4aouERmKSYmBjt37kRYWBjLJJGBLFy4EHXr1sX48eNFRzF6HKEk2fniMswIT0VizrWH3sV2J/cY5g71wH9fGF6DSYnMW1VVFTp16oS6desiMTGRS02IDODSpUto0aIFZs2ahQ8//FB0HKPHEUoC8P/P2dL+WSL/7f7Sez+v7dwBi9MtUfdwPkaawTlbRMbgp59+wsmTJ3Hw4EGWSSIDWbhwIWrXro23335bdBSTwBFKwrL4bL3cBDAlwA1v+7bSQyIi+ielpaVo1aoVfHx8sGnTJtFxiBTpypUrcHFxwfTp0zF79mzRcUzCwx/5Toq06XC+XsokACyOzsKvh/P18iwi+ntffPEFioqKMH/+fNFRiBRr8eLFsLa2xjvvvCM6islgoTRj54vLMDsiTa/P/CgiDeeLy/T6TCL6w+XLl7Fw4UK88847cHFxER2HSJEKCwuxYsUKvPvuu3jiiSdExzEZLJRmbEZ4qrxmUl+0OgkzwlP1+kwi+sNHH30EGxsbbhAgMqAvv/wSarUaEydOFB3FpLBQmqnsghIk5lz71803j6pKJyEx5xpyCkv0+lwic5eamorvvvsOs2fPRoMGDUTHIVKka9euYdmyZZgwYQIvC3hELJRmakNyPizUhtkdaqFWYf1BrqUk0qepU6eiZcuW/+e2DiLSn6+++goA8N577wlOYnpYKM1UfGah3kcn76nSSYjPKjTIs4nMUVRUFKKiorBgwQIeYk5kIMXFxfjmm2/w1ltvoWHDhqLjmBwWSjN0u1yLfANvnMkvKkNpudag7yAyB1VVVZgyZQp69+6NZ599VnQcIsVaunQptFotJk+eLDqKSeLB5mboXFEpDH34qAQgr6gUHk/VN/CbiJTt+++/x6lTp3Do0CEeYk5kIDdu3MDSpUvx5ptvonHjxqLjmCSOUJqhCq1OUe8hUqrbt29j1qxZePHFF+Hl5SU6DpFiffPNNygvL8eUKVNERzFZLJRmyNqyZv5nr6n3ECnVokWLcP36dcybN090FCLFunXrFr766iuMGzcOTZo0ER3HZPET3ww5O9ihJibOnra3rYG3ECnTxYsXsWjRIkycOBFPP/206DhEirVs2TKUlpZi2rRpoqOYNBZKM2RnYwknA5e9yuJLaOvWEuPHj8euXbtQXl5u0PcRKc2sWbNgZ2eHDz74QHQUIsUqKSnBF198gddeew1NmzYVHceksVCaKV93R4OeQzmwfXMMGzYMO3bswKBBg9CwYUM899xz+PHHH3H16lWDvJdIKU6cOIEffvgBc+bMQf363NhGZCgrVqxASUkJpk+fLjqKyVNJkmToDb9khLILSuC/ZK/Bnh87yQeujnUhSRLS0tIQERGByMhIJCcnAwB69OiBoKAgBAcHo3Xr1ty9SvQnSZIQEBCA8+fPIzU1FVZWVqIjESlSaWkpXFxcMHz4cKxcuVJ0HJPHQmnGxqxLRtLZIr0ecG6hVqFHCwf8PLbb3/68oKAA27dvR0REBGJiYlBWVgZXV1e5XPbs2ZMfoGTWdu7cicGDB+P3339HcHCw6DhEivXFF19g+vTpyM7OhrOzs+g4Jo+F0oydLy6D31d7UK7H431sLNWIndQHzR9ijeadO3ewe/duREZGIjIyEpcuXUKDBg0wePBgBAUFYeDAgbyzmMyKVqtF+/bt0ahRI8THx3PknshAysrK0KJFCwQGBmLt2rWi4ygCC6WZ23Q4H9O3pOrteQuGe2KEl9Mj/zlJknDs2DF5avz48eOwtLSEj48PgoODERQUhBYtWugtJ5ExWr16NV5//XUcOXIEnTt3Fh2HSLGWLl2KyZMnIysri58tesJCSVgWn43F0VnVfs7UAHeM93XVQyLg/Pnz2LZtGyIiIrB7925UVFTAw8NDnhrv2rUrLCws9PIuImNQUlICV1dXBAQE4OeffxYdh0ix7t69ixYtWmDAgAH4/vvvRcdRDBZKAvDHSOXsiDSUV1QC6ocvahZqFSzVKnwS7PFYI5MPo6SkBDExMYiIiMD27dtx7do1NGrUCIGBgQgODoa/vz/s7OwM8m6imjJr1iwsXrwYmZmZcHIyzO8SEQHLly/HO++8g9OnT6NVq1ai4ygGCyXJlqz5GfPj8lDbpRMs1KoHbta59/Perg0xb5jnQ62Z1IeqqiocPHgQkZGRiIiIQEZGBmxsbNC/f38EBQUhKCiIZ4mRyblw4QLc3NwwceJE3opDZEDl5eVwdXVF3759OROgZyyUBACorKxEmzZt0K5dOyxa9TM2JOcjPqsQ+UVl+Os/ICoATg628HVzxGhvJ7g61hUVGQCQk5Mjb+rZu3cvqqqq0KlTJwQHByM4OBgdOnTgxgYyeq+88gp27NiBnJwc1KtXT3QcIsVauXIl3nrrLaSnp6N169ai4ygKCyUBAL777juMHTsWx48fR4cOHeS/XlquRV5RKSq0OlhbquHsYAc7G0txQR/g+vXr2LVrFyIiIrBz507cvHkTzZo1k6fGfX19UatWLdExie5z/PhxdO7cGcuXL8ebb74pOg6RYlVUVKBVq1bo0aMHNm7cKDqO4rBQEioqKuDu7o7OnTsjLCxMdBy9qKysRGJiIiIiIhAREYHc3FzY2dkhICAAwcHBGDJkCBo1aiQ6Jpk5SZLQv39/XL58GampqbC0NM4va0RKsHbtWowbNw6pqanw8PAQHUdxWCgJa9aswbhx43Dy5El4enqKjqN3kiQhPT1dXnd58OBBAED37t3lXeNt2rTh1DjVuG3btiEoKAiRkZEIDAwUHYdIsSorK+Hu7o4uXbrgt99+Ex1HkVgozdy9KQBvb2/8+uuvouPUiMLCQmzfvh2RkZGIioqSD7i9d95l7969eVsPGZxWq4WnpyeeeuopxMbG8gsNkQH98MMP+M9//oMTJ07gmWeeER1HkVgozdy9BcqnTp1C27ZtRcepcXfv3kV8fLx8oPrFixdRv359+baeQYMG8bYeMogVK1Zg/PjxOHr0KDp27Cg6DpFiabVatG7dGs888wy2bNkiOo5isVCasbt376JVq1bo3bs3fvnlF9FxhJMkCcePH5fL5bFjx2BpaYnevXvLo5ctW7YUHZMU4NatW3B1dcXgwYPxww8/iI5DpGg///wzXnrpJRw7doxf3gyIhdKMLVu2DO+++y7S0tJ4fMLfuHDhwn239ZSXl6Nt27byustu3brxth56LDNmzMCSJUuQlZWFZs2aiY5DpFhVVVVo27Yt3N3dERERITqOorFQmqk7d+7A1dUV/fv3x08//SQ6jtG7ffs2YmJiEBkZiW3btuHq1ato2LAhAgMDERQUhICAANSpU0d0TDIB+fn5cHd3x5QpU/Dpp5+KjkOkaBs3bsSLL76Iw4cPo0uXLqLjKBoLpZlaunQpJk+ejIyMDF499Yiqqqpw6NAheWo8LS0N1tbW993Ww1En+idjxoxBTEwMsrOzUbeu2IsBiJRMp9OhXbt2cHFxwfbt20XHUTwWSjN0b1fzoEGD8P3334uOY/LOnDlz3209Wq0WHTt2lNdddurUiTt4CQBw9OhRdOnSBatWrcK4ceNExyFStN9++w0jRozAgQMH4O3tLTqO4rFQmqEvv/wS06ZNQ1ZWFlq0aCE6jqLcuHHjvtt6bty4gaZNm8q39fTr14+39ZgpSZLg6+uLq1ev4sSJEzzEnMiAdDod2rdvj6eeegpRUVGi45gFFkozU1paChcXFwQHB2Pt2rWi4yhaZWUl9u3bJx+ofubMGdja2iIgIABBQUEYMmQIGjduLDom1ZCIiAgMHToUO3bswKBBg0THIVK0LVu24LnnnsO+ffvQs2dP0XHMAgulmVm4cCE+/PBDZGdnw9nZWXQcsyFJEjIyMuSp8aSkJABAt27dEBwcjODgYLRt25ZT4wpVWVmJdu3awcnJCdHR0fzfmciAJElCx44d0bBhQ8TGxoqOYzZYKM1ISUkJXFxcEBISgpUrV4qOY9auXr2KHTt2ICIiAlFRUfeNHAcFBcHHx4e39SjI8uXLMWHCBBw/fhzt27cXHYdI0e7NBuzZswc+Pj6i45gNFkozMn/+fMyePRs5OTlwcnISHYf+dPfuXSQkJMi7xi9cuID69etj4MCBCA4OxqBBg/DEE0+IjkmP6ebNm3B1dUVQUBC+++470XGIFE2SJHTp0gV169ZFQkKC6DhmhYXSTNy6dQvOzs544YUXsHz5ctFx6B9IkoSUlBR53eXRo0dhYWGB3r17ywequ7q6io5Jj2D69On45ptvkJWVhaZNm4qOQ6Ro27dvR2BgIOLi4tCvXz/RccwKC6WZmDt3LubOnYucnByekWhCLl68KN/WExcXh/LycrRu3Vped+nt7c3beoxYXl4eWrdujffffx8ff/yx6DhEiiZJEry9vWFlZYXExESuVa5hLJRm4MaNG3BxccGYMWPw9ddfi45Dj6m0tPS+23oKCwvRsGFDDBkyRL6thwdlG5dRo0Zh9+7dyM7O5k1KRAYWFRWFgQMHIjo6Gv7+/qLjmB0WSjMwZ84cLFiwAGfOnMFTTz0lOg7pgU6nu++2nlOnTsHa2hq+vr7yxp7mzZuLjmnWDh06hG7dumHNmjV47bXXRMchUjRJktCzZ09IkoSkpCSOTgrAQqlw169fh7OzM8aOHYsvv/xSdBwykNzcXHnd5Z49e6DVatGhQwd53WWnTp2gVqtFxzQbkiShT58+uH79OlJSUrgsgcjA4uLi4Ofnx3NeBWKhVLhZs2bhiy++QG5uLg/RNhM3b96Ub+vZsWMHbty4gSZNmsj3jPfv3x+1a9cWHVPRwsPDMXz4cOzatQsDBgwQHYdI0e59gbtz5w4OHTrE0UlBWCgVrKioCM7OznjjjTewaNEi0XFIgMrKSuzfv18evczJyUHt2rXl23oCAwP5RUPPKioq4OHhgZYtW2LXrl2i4xApXkJCAnx9fREREYGgoCDRccwWC6WCzZgxA19//TVyc3PRqFEj0XFIMEmSkJmZKa+7TEpKgiRJ6Nq1q7zusl27dvx2X01ff/01Jk2ahJSUFHh6eoqOQ6R4/fr1w40bN3D06FH++0sgFkqFunr1KlxcXPD222/j888/Fx2HjNC1a9fuu63n9u3bcHZ2ltdd+vj4wNraWnRMk3Ljxg20bNkSw4cPx5o1a0THIVK8xMRE+Pj4IDw8HM8++6zoOGaNhVKhpk2bhhUrViA3NxcNGzYUHYeMXHl5ORISEuSp8fPnz6NevXoYOHAggoKCMHjwYNjb24uOafSmTp2KFStWIDs7G02aNBEdh0jxAgICUFBQgOPHj3PjoWAslApUUFCAFi1aYNKkSZg7d67oOGRiJEnCiRMn5HJ55MgRWFhYoFevXvLoZatWrUTHNDq5ublo3bo1PvzwQ3z00Uei4xAp3oEDB9CjRw9oNBqEhISIjmP2WCgVaPLkyVi7di1yc3M5qkTVdunSJWzbtg2RkZGIjY3F3bt34e7uLq+77N69OywtLUXHFG7kyJFITExEVlYW7OzsRMchUrxBgwYhPz8fqampHJ00AiyUCnP58mW0aNEC06ZN41VvpHdlZWWIjY1FREQEtm3bhoKCAjg4OGDw4MEIDg7GgAEDzPK2noMHD6J79+747rvv8J///Ed0HCLFu3dxwMaNGzFy5EjRcQgslIozceJE/PDDD8jLy0ODBg1ExyEF0+l0OHz4sDw1npqaCisrK/j6+spnXj799NOiYxqcJEno1asXbt++jWPHjvEQc6IaEBQUhJycHJw6dYq/c0aChVJBLl68iJYtW2LGjBlcw0U1Li8v777beiorK/HMM88gODgYwcHB6Ny5syKnpTZv3oyQkBDExMTAz89PdBwixTt27Bg6d+6M9evXY9SoUaLj0J9YKBXk7bffxi+//ILc3FzUr19fdBwyYzdv3kRUVBQiIyOxfft2XL9+HU8++eR9t/XY2tqKjlltFRUVaNu2Ldzc3LBjxw7RcYjMwrPPPov09HSkp6dz/bYRYaFUiPPnz8PV1RWzZ8/GjBkzRMchkmm1WiQlJSEiIgIRERHIzs5G7dq14efnh+DgYAQGBuLJJ58UHfOxLFmyBJMnT8bJkyfh4eEhOg6R4qWkpKBjx4744Ycf8PLLL4uOQ3/BQqkQb775JjQaDXJzc81yUwSZjszMTHlqfP/+/dDpdOjatat8JJGnp6fR3HZRWq5FXlEpKrQ6WFuq4exgBzubP0ZEiouL4erqitDQUKxatUpwUiLzEBISguPHjyMzM5Ojk0aGhVIBzp07h1atWuHTTz/F+++/LzoO0UMrKiq677aekpISODk5yesu+/TpU+O39WQXlGBDcj7iMwuRX1yGv/4LUgXAyd4Wvu6OuLhnEzatXoLs7GyTHWElMiWnTp2Cp6cn1q1bh1dffVV0HPofLJQKMG7cOGzduhVnz55FnTp1RMcheizl5eXYs2ePPHqZn5+PunXr3ndbj4ODg8Hef764DDPCU5GYcw0WahWqdP/8r0a1CtBJQFP1LWyaPBTN7U1/PSiRsRs5ciQOHjyI7OxsWFlZiY5D/4OF0sSdPXsW7u7umD9/PqZMmSI6DpFeSJKE1NRUREREIDIyEocOHYJarUbPnj3lA9Xd3d319r5Nh/MxOyINWp30wCL5vyzUgKVajY+DPTDSy0lveYjofhkZGfDw8MDKlSsxbtw40XHob7BQmrhXX30VO3bswNmzZxWxa5bo71y+fBnbt29HREQEYmNjcefOHbi5ucnlskePHo+9nmpZfDYWR2dVO+OUADe87csrKYkMYdSoUUhMTER2djZsbGxEx6G/wUJpwnJyctC6dWssXrwYEydOFB2HqEaUlZUhLi5Ovq3nypUrsLe3v++2nnr16j3UszYdzsf0Lal6y7ZguCdGcKSSSK8yMzPRtm1bfPPNN3jrrbdEx6F/wEJpwl5++WXExMTgzJkzqF27tug4RDVOp9PhyJEj8rrLkydPwsrKCn379pXPvHR2dv7bP3u+uAx+X+1BuVantzw2lmrETurDNZVEevTyyy8jNjYWZ86cQa1atUTHoX/AQmmi7n1jW7JkCSZMmCA6DpFROHfuHCIjIxEZGYn4+HhUVlbC09NTnhr38vKSb+sZsy4ZSWeLHmnN5L+xUKvQo4UDfh7bTW/PJDJn92bivvrqK37WGTkWShM1evRoJCQkICcnh9/YiP7GrVu3EB0djYiICGzfvh3FxcVo3LgxAgMD4eUXjPknDHf/b+wkH7g68jxYouoaO3asvE+AM3HGjYXSBN3b7bZs2TKuJyF6CFqtFgcOHJCnxgub90HdTkOgUuu/VFqoVRjT7WnMCebNOUTVkZubCzc3NyxcuBCTJk0SHYf+BQulCRo5ciSSkpK4243oMXWfF43LJZUGe/7TDrbYM8XXYM8nMgfjxo3D77//jtzcXJ5iYgJ4b5GJOXXqFH777TesXLmSZZLoMdwu1+KKAcskAOQXlaG0XCtf00hEj+bcuXP44Ycf8Nlnn7FMmgi16AD0aD7++GM4OTnhlVdeER2FyCSdKyqFoadlJAB5RaUGfguRci1YsAD169fHm2++KToKPSR+fTYhJ06cQFhYGNauXVvj9xsTKUWFHo8JMob3ECnNhQsXsG7dOnz88ce8TtiEcITShHz88cdo0aIFXnrpJdFRiEyWtWXN/Guvpt5DpDQLFixAnTp1MH78eNFR6BFwhNJEHDt2DOHh4fj+++9hZWUlOg6RyXJ2sIMKMOi0t+rP9xDRo7l06RLWrFmDmTNnom5dHr1lSvgV2kTMmTMHrq6uGD16tOgoRCbNzsYSTga+yaai+BIG+ffDokWLcPr0afAwDaKHs2jRItSuXZuHmJsgFkoTcO9qudmzZ8PSkoPKRNXl6+4IC7XKIM+2UAHdneuhQYMGmD17Ntq0aQM3Nze899578u09RPR/XblyBStXrsTEiRNRv3590XHoEfEcShMwZMgQnDlzBmlpabCwMNztHkTmIrugBP5L9hrs+fduyikrK8Pu3bsRGRmJbdu24dKlS2jQoAEGDhyI4OBgDBw4EE888YTBchCZkqlTp2L16tXIy8vj74UJYqE0cgcPHkT37t3xyy+/4IUXXhAdh0gxavoub51Oh+PHj8t3jR87dgwWFhbo3bs3goKCEBQUhFatWuktC5EpKSwshIuLC9577z18+umnouPQY2ChNHIDBw7E+fPncfLkSY5OEunR+eIy+H21B+V6PN7HxlKN2El90Pwh1mheuHAB27ZtQ2RkJOLi4lBeXg53d3e5XPbo0YNLXMhsTJ8+HcuXL0deXh4cHBxEx6HHwEJpxJKSktCzZ0/8+uuveP7550XHIVKcTYfzMX1Lqt6et2C4J0Z4OT3ynystLUVsbKw8NV5QUAB7e3sMGjQIQUFBGDhwINeUkWJdu3YNzs7OmDBhAubPny86Dj0mFkoj5u/vjytXruDEiRNQq7l/isgQlsVnY3F0VrWfMzXAHeN9Xav9HJ1OJ2/Ei4yMxIkTJ2BpaQkfHx8EBwcjKCgILVq0qPZ7iIzFzJkzsWTJEuTl5aFhw4ai49BjYqE0Unv37kWfPn2wefNmDB8+XHQcIkXbeCgfMzYfhwQVoH74pSUWahUs1Sp8EuzxWCOTDyM/P1+eGt+9ezcqKirQtm1beWrc29uby2HIZF2/fh1PP/003njjDSxcuFB0HKoGFkoj5evri+vXr+PYsWMcnSQysJ07dyL4hf+g3/S1yLypgoVa9cDNOvd+3tu1IeYN83yoNZP6UFJSgpiYGERGRmL79u24evUqGjZsiMGDByMoKAgBAQGoV69ejWQh0oc5c+Zg4cKFyM3NRePGjUXHoWpgoTRC8fHx6NevH7Zu3YqhQ4eKjkOkaFVVVejQoQPs7e2RkJCAnMLb2JCcj/isQuQXld13o44KgJODLXzdHDHa2wmujuJu8qiqqsKhQ4fkqfFTp07BysoKffv2lUcvnZ2dheUj+jc3btyAs7MzXn31VXz55Zei41A1sVAaGUmS0KdPH5SWluLIkSNQqQxz+DIR/WHdunV47bXXcOjQIXh5ed33s9JyLfKKSlGh1cHaUg1nBzvY2Rjnzuvc3Fx5ajwhIQGVlZVo166dXC67du3KqXEyKp9++ik+++wz5ObmokmTJqLjUDWxUBqZ2NhY+Pv7IzIyEoGBgaLjEClaaWkp3Nzc4OPjg40bN4qOoze3bt1CdHS0PDVeVFSERo0aITAwEEFBQfD390edOnVExyQzduvWLTg7O2P06NH4+uuvRcchPWChNCKSJKFXr16orKxEcnIyRyeJDGzu3Ln49NNPcfr0abi4uIiOYxBVVVU4cOCAPDWekZEBa2tr9OvXTx69bN68ueiYZGbmz5+POXPm4OzZs2jatKnoOKQHLJRGJCoqCgMHDsTOnTsxcOBA0XGIFK2goACurq4YN24cvvjiC9FxasyZM2fkcrl3715otVq0b99eLpddunThRkAyqNu3b8PZ2RkjRozA8uXLRcchPWGhNBKSJMHb2xtqtRpJSUkcnSQysLfeegsbN27EmTNnYG9vLzqOEDdu3EBUVBQiIyOxY8cOXL9+HU8++SSGDBmCoKAg+Pn5wc7OTnRMUpiFCxdi5syZyMnJgZOTYY7boprHQmkkduzYgSFDhiA6Ohr+/v6i4xAp2unTp9GuXTssWLAAkydPFh3HKGi1WiQlJcmjl5mZmahVqxb69++PoKAgBAYGcmqSqq20tBQuLi4YNmwYVq1aJToO6RELpRGQJAleXl6oXbs29u7dy9FJIgN79tlnceLECZw+fRo2Njai4xilrKwsuVzu27cPVVVV6NSpkzw13qlTJ/67ih7Zl19+iffffx/Z2dk81kphWCiNQEREBIYOHYq4uDj069dPdBwiRUtMTISPjw82bNiAF198UXQck1BcXIxdu3YhMjISO3fuxM2bN/HUU0/Ju8b79++P2rVri45JRu7OnTtwcXFBYGAg1q5dKzoO6RkLpWCSJKFTp06oX78+4uPj+Y2fyIDurVW+dyg4N588usrKSuzbt08evczJyUHt2rXh5+cnT43zTEH6O19//TXee+89ZGZmomXLlqLjkJ6xUAoWHh6O4cOHIyEhAX369BEdh0jRfv31V4wcORLx8fHo27ev6DgmT5IkZGZmIjIyEhEREUhKSoJOp0OXLl3kqfEOHTrwizLh7t27aNmyJfz9/fHDDz+IjkMGwEIpkE6nQ4cOHdCoUSPExcWJjkOkaOXl5WjTpg08PDwQGRkpOo4iFRUVYceOHYiMjMSuXbtQUlKC5s2by1Pjvr6+qFWrluiYJMDy5cvxzjvvICMjA25ubqLjkAGwUAoUFhaG0NBQJCYmolevXqLjECnaV199hSlTpiA1NRVt27YVHUfxKioqsHfvXnlqPDc3F3Z2dvD390dQUBCGDBmCxo0bi45JNaC8vByurq7o06cP1q9fLzoOGQgLpSBVVVV45pln0KxZM0RFRYmOQ6Ro169fR8uWLREaGsqjSgSQJAnp6elyuTxw4AAAoGvXrvLUuKenJ6fGFWrVqlV48803kZ6ejtatW4uOQwbCQinIpk2b8MILL+DAgQPw9vYWHYdI0aZOnYoVK1YgJycHTz75pOg4Zu/q1avYsWMHIiIiEB0djdu3b+Ppp5+Wp8b79u3L45wUoqKiAq1atUKPHj2wceNG0XHIgFgoBaiqqkK7du3g4uKCHTt2iI5DpGh5eXlwd3fHjBkzMHv2bNFx6H+Ul5cjISFBHr3Mz89HnTp1MGDAAAQFBWHw4MFo1KiR6Jj0mNatW4fXXnsNp06dgoeHh+g4ZEAslAJs2LABo0ePxqFDh+Dl5SU6DpGijRo1Crt370Z2djbq1KkjOg49gCRJSE1NlcvloUOHAADdu3eXp8bbtm3LqXETUVlZCXd3d3Tu3BkajUZ0HDIwFsoaptVq0bZtW7i7u3OnKZGBHTlyBF5eXli9ejX++9//io5Dj6igoADbt29HZGQkoqOjUVZWBhcXF7lc+vj4wNraWnRM+gc//PAD/vOf/yAlJQXt27cXHYcMjIWyhv300094+eWXcfToUXTq1El0HCLFkiQJ/fr1Q2FhIU6cOAFLS0vRkaga7t69i/j4eERERGDbtm24cOEC6tWrd9/UuIODg+iY9CetVos2bdqgXbt2CA8PFx2HagALZQ2qrKxEmzZt4OnpyV8wIgPbtm0bgoKCsG3bNgwZMkR0HNIjSZKQkpIiT40fOXIEarUaPXv2lEcv3d3dOTUu0Pr16zFmzBgcO3YMHTt2FB2HagALZQ367rvvMHbsWA7/ExmYVqvFM888gyeffBJxcXEsFgp36dIleWo8NjYWd+7cgaurq1wue/XqBSsrK9ExzUZVVRU8PDzg5uaGiIgI0XGohrBQ1pDKykq4ubmhc+fOCAsLEx2HSNFWr16N119/HUeOHEHnzp1Fx6EaVFZWht27dyMyMhLbtm3DpUuX0KBBAwwcOBBBQUEYNGgQnnjiCdExFW3jxo148cUXufHUzLBQ1pA1a9bg9ddfx8mTJ9GuXTvRcYgU6/bt23B1dYWfnx9v5TBzOp0Ox48fR0REBCIjI3H8+HFYWFigV69eCA4ORlBQEFq1aiU6pqLodDq0a9cOzs7OPBbPzLBQ1oB7B7t6e3vj119/FR2HSNHmzJmDzz//HJmZmXj66adFxyEjcuHCBWzbtg2RkZGIi4tDeXk53N3d5anxHj16cPNWNWk0Gjz//PO8tMMMsVDWgJUrV+Ktt97CqVOneIcwkQFdvnwZrq6uGD9+PBYuXCg6Dhmx0tJSxMbGylPjBQUFeOKJJzB48GAEBQVh4MCBqF+/vuiYJkWn06FDhw5o0qQJrxQ2QyyUBnb37l20atUKPj4+2LBhg+g4RIo2btw4bN68GWfOnEGDBg1ExyETodPpcOTIEXnX+L1jpnx8fOTRy5YtW4qOafTCw8MxfPhw7Nu3Dz179hQdh2oYC6WBLVu2DO+++y7S09Ph7u4uOg6RYqWlpeGZZ57BF198gYkTJ4qOQybs3Llz8tR4fHw8Kioq0KZNG7lcdu/eHRYWFqJjGhVJktCpUyfY29sjLi5OdBwSgIXSgO4dXdG/f3/89NNPouMQKVpgYCAyMjKQkZHB21NIb0pKShATE4PIyEhs374dV69ehYODA4YMGYKgoCAEBASgXr16omMKFxERgaFDhyIhIQF9+vQRHYcEYKE0oKVLl2Ly5MnIyMjgTkIiA4qPj0e/fv3w66+/4vnnnxcdhxSqqqoKhw4dkqfGT506BSsrK/Tt21cevXR2dhYds8ZJkgQvLy/Y2dlhz549ouOQICyUBlJWVoYWLVpg0KBB+P7770XHIVIsnU4HLy8vWFlZ4cCBAzzEnGpMbm6uPDWekJCAyspKtGvXTi6XXbt2NYup8R07dmDIkCGIi4tDv379RMchQVgoDeTLL7/EtGnTkJWVhRYtWoiOQ6RYGzZswOjRo5GYmIhevXqJjkNm6tatW4iKikJkZCR27NiBoqIiNGrU6L6p8Tp16oiOqXeSJKF79+6wtLREYmIiv9CZMRZKAygtLYWLiwuGDh2KNWvWiI5DpFh3796Fu7s7OnXqhPDwcNFxiAD8MTV+4MABeWr83rrefv36ISgoCIGBgXBychIdUy+io6MxYMAAREVFISAgQHQcEoiF0gAWLlyIDz/8ENnZ2Wa5noaopixatAgffPAB0tLSeIoCGa0zZ87I5XLv3r3QarVo3769PDXepUsXqNVq0TEfmSRJ6NWrl1ygOTpp3lgo9aykpAQuLi4ICQnBypUrRcchUqyioiK0bNkSo0aNwvLly0XHIXooN27cuG9q/Pr163jyySflqXE/Pz/Y2dmJjikrLdcir6gUFVodrC3VcHawg53NH7cJxcXFwc/PD9u3b8fgwYMFJyXRWCj1bP78+ZgzZw6ys7MVM6VBZIwmTZqEdevWIScnB46OjqLjED0yrVaL/fv3y6OXWVlZqFWr1n1T482aNavxXNkFJdiQnI/4zELkF5fhryVBBcDJ3ha+7o6I+nYWtEXncejQIY5OEgulPt26dQvOzs544YUXOGJCZEBnzpxBmzZtMHv2bHz44Yei4xDpRVZWllwu9+3bh6qqKnTs2FGeGu/UqZNBp8bPF5dhRngqEnOuwUKtQpXun+uBWgXoJKB1fQlrxvVDc3tbg+Ui08BCqUdz587F3LlzkZOTI+RbJZG5GDFiBPbt24fs7GzY2vKDjJSnuLgYu3btQmRkJHbu3ImbN2/iqaeeQmBgIIKCgtC/f3/Url1bb+/bdDgfsyPSoNVJDyyS/8tCrYKlWoWPgz0w0ouzcuaMhVJPbty4ARcXF7z00ktYunSp6DhEipWcnAxvb2+sW7cOr776qug4RAZXWVmJffv2ITIyEhEREThz5gxq164NPz8/eWq8SZMmj/38ZfHZWBydVe2cUwLc8LYvL/EwVyyUejJnzhwsWLAAZ8+erdYvNhH9M0mS0KdPH9y4cQPHjx83i0Ojif5KkiScPn1anhpPSkqCTqdDly5d5KnxDh06PPSaxk2H8zF9S6re8i0Y7okRHKk0SyyUenD9+nU4Oztj7Nix+PLLL0XHIVKs33//Hc8++yx27tyJgQMHio5DJNy1a9ewc+dOREZGYteuXSgpKUGzZs3kqfF+/fqhVq1af/tnzxeXwe+rPSjX6vSWx8ZSjdhJfbim0gyxUOrBrFmz8MUXXyA3NxeNGzcWHYdIkSorK+Hp6YnmzZsjOjqau0qJ/kdFRQX27t0rj17m5ubCzs4O/v7+CAoKwpAhQ+77jBqzLhlJZ4seac3kv7FQq9CjhQN+HttNb88k08BCWU1FRUVwdnbGG2+8gUWLFomOQ6RYK1aswPjx43Hs2DF06NBBdBwioyZJEtLT0+V1lwcPHgQAdO3aFUFBQWjvMxBv77hisPfHTvKBq2Ndgz2fjA8LZTXNmDEDX3/9NXJzc9GoUSPRcYgUqaSkBK6urhg4cCB+/PFH0XGITE5hYSF27NiByMhIREdHw8r7RdTtNAQqtf7XIVuoVRjT7WnMCfbQ+7PJeLFQVsPVq1fh4uKCCRMmYP78+aLjECnWrFmzsHjxYmRlZaF58+ai4xCZtPLycvT6PBZX7xruHU872GLPFF/DvYCMjuldHmpEFi9eDJVKhSlTpoiOQqRYFy9exBdffIGJEyeyTBLpQSUscM2AZRIA8ovKUFquNexLyKiwUD6mgoICLFu2DO+++y4cHBxExyFSrI8++gh2dnaYPn266ChEinCuqBSGnpqUAOQVlRr4LWRMLEUHMFULFy6EpaUl3nvvPdFRiBQrNTUV33//PZYuXYr69euLjkOkCBV6PCbIGN5DxoEjlI/h8uXL+PbbbzFx4kTY29uLjkOkWNOmTUPLli3x+uuvi45CpBjWljXz0V9T7yHjwBHKx7BgwQLY2Nhg0qRJoqMQKVZsbCx27dqFsLAwWFtbi45DpBjODnZQAQad9lb9+R4yH/z68IguXryIlStXYvLkyWjQoIHoOESKpNPpMHXqVPTo0QPDhw8XHYdIUexsLOFk4JtsnBxsYWfDMStzwkL5iD7//HPY2tri3XffFR2FSLHWr1+PlJQULFq0iDfiEBmAr7sjLNSG+d2yUKvg6+ZokGeT8WKhfATnz5/H6tWrMWXKFNSrV090HCJFunPnDmbOnInnnnsOPXr0EB2HSJFGdXPS65WLf1WlkzDa28kgzybjxUL5CObNm4e6detiwoQJoqMQKdbSpUtx+fJlXhZAZECtGtdFb9eGeh+ltFCr0Nu1Ia9dNEMslA/p3LlzWLduHaZOnYq6dfmLQmQIV69exfz58/Hmm2+iVatWouMQKdq8YZ6w1HOhtFSrMG+Yp16fSaaBhfIhffbZZ2jQoAHGjx8vOgqRYn366acA/jjMnIgMq7m9LT7W833bnwR7oLmBN/yQcWKhfAi5ubn4/vvv8f7776NOnTqi4xApUnZ2NlasWIEPPvgADRs2FB2HyCyM9HLClAC3P/+v6q2pnBrgjhFeXDtprlSSJBn6BiaTN3bsWGzfvh1nz56FrS2/eREZQkhICA4dOoTMzEzUrl1bdBwis/LT/hx8tDUVsLAEVA8/1mShVsFSrcInwR4sk2aOI5T/IicnBz/++COmT5/OMklkIElJSdi8eTPmzp3LMkkkwOnt3+Hqj++ic7M/ZuH+bbPOvZ/3aOGA2El9WCaJI5T/5uWXX0ZMTAzOnDnDDzoiA5AkCT179sSdO3dw9OhRqNX8nktUk9LT09G+fXvMmjULH330EbILSrAhOR/xWYXILyq7byJchT8OLfd1c8Robyfu5iYZC+UDZGVloU2bNliyZAmPCiIykM2bNyMkJAQxMTHw8/MTHYfIrEiSBF9fX1y6dAmpqamwsbG57+el5VrkFZWiQquDtaUazg52vAGH/hYL5QOMHj0aCQkJyMnJQa1atUTHIVKciooKeHh4wNXVFTt37hQdh8js/PTTT/JMHL/QUXWY/deMf/r2lZGRgV9++QXLly9nmSQykFWrVuHs2bPYsmWL6ChEZqe4uBiTJ0/GCy+8wDJJ1WaWI5Ty+pDMQuQX/836EHtblOcdw6U9vyL7aOL/mQIgouq7efMmWrZsiaFDh2LdunWi4xCZnddffx2bNm1CZmYmnnzySdFxyMSZVaE8X1yGGeGpSMy5Bgu16oH3mEq6KqjUFujt2hDzhnnyoFYiPfvggw+wdOlSZGdno2nTpqLjEJmVAwcOoEePHli2bBkv7CC9MJtCuelwPmZHpEGrkx5YJP/XvTO2Pg72wEgei0CkF+fPn4ebmxsmT56MuXPnio5DZFa0Wi26dOkCKysrHDx4EBYWFqIjkQKYxRrKZfHZWByd9Vh/turPAjp9Syqu3S7H2768X5ioumbOnIm6deti2rRpoqMQmZ1vvvkGJ0+exKFDh1gmSW8UXyg3Hc5/7DL5vxZHZ6FRHRse4EpUDSkpKfj555+xbNky1KtXT3QcIrNy4cIFfPTRRxg/fjy6dOkiOg4piKKnvM8Xl8Hvqz0o1+r09kwbSzViJ/XhmkqixyBJEgICApCfn49Tp07ByspKdCQisxISEoL9+/fj9OnTqF+/vug4pCCKvpJiRngqtI+wXvJhaHUSZoSn6vWZROYiKioKsbGxWLBgAcskUQ3bsWMHNm/ejK+++oplkvROsSOU2QUl8F+y12DPj53kwyuniB5BVVUVOnTogAYNGmDv3r1QqR58VzAR6U9ZWRnatWuHli1bIjo6mr9/pHeKXUO5ITn/X48GelwWahXWH8zHnGAPvT+bSKl+/PFHnDp1CgcPHuSHGVENmzdvHi5evIhdu3bx948MQrFT3vGZhQYpk8AfO7/jswoN8mwiJSorK8OsWbPw/PPPo1u3bqLjEJmVjIwMLFy4EB988AHc3NxExyGFUmShvF2uRX5xmUHfkV9UhtJyrUHfQaQUX331Fa5evYr58+eLjkJkViRJwltvvYWnn34a06dPFx2HFEyRU97nikph6IWhEoC8olJ4PMWFzUQPUlhYiAULFmD8+PFo0aKF6DhEZmX9+vVISEhAVFQUatWqJToOKZgiRygr9HhMkDG8h8iUffzxx1Cr1Zg5c6boKERm5fr165g8eTJGjBiBgIAA0XFI4RQ5QmltWTM9uabeQ2SqMjMzsWrVKsyfPx8ODg6i4xCZlRkzZuDu3bv48ssvRUchM6DIQunsYAcVYNBpb9Wf7yGifzZ9+nQ0a9YMEyZMEB2FyKwkJydj1apVWLp0KZ566inRccgMKPYcyj6L4nHOgBtzpFsFGGqRgtDQUPTs2RNqNUcrif4qMTERPj4+WL9+PUaNGiU6DpHZ0Gq18PLyglqt5n3dVGMU24J83R1hoTbMWVtqFdCi9l1s3rwZPj4+aNasGd5++23s2bMHVVVVBnknkSmRJAlTp05Fp06d8MILL4iOQ2RWli1bhhMnTmDlypUsk1RjFFsoR3VzMtg5lDoJWDNtDM6fP499+/ZhxIgR+P3339G3b180a9YM48ePR0JCAsslmS2NRoPk5GQsXryYo/dENejixYuYNWsW3nzzTXh5eYmOQ2ZEsVPeADBmXTKSzhbptVhaqFXo0cIBP4+9/3BmnU6H5ORkaDQahIWF4fz583B0dMTw4cMRGhoKHx8fWFoqcskq0X3Ky8vRtm1btGnTBtu2bRMdh8isPP/889i7dy9Onz6NBg0aiI5DZkTRhfJ8cRn8vtqDcj0e72NjqUbspD5obm/7j3+PTqfDoUOHEBYWBo1Gg/z8fDRq1Egul3369GG5JMVasmQJJk+ejNTUVLRt21Z0HCKzsWvXLgwaNAgbNmzAiy++KDoOmRlFF0oA2HQ4H9O3pOrteQuGe2KEl9ND//2SJOHw4cPyyGVeXh4aNmyIYcOGITQ0FL6+viyXpBg3btxAy5Yt8dxzz2H16tWi4xCZjTt37qBdu3ZwcXFBTEwM7+umGqf4QgkAy+KzsTg6q9rPmRrgjvG+ro/95yVJwtGjR6HRaKDRaJCbmwsHB4f7yqWVlVW1cxKJMm3aNHz77bfIzs5GkyZNRMchMhuzZs3CwoULcfLkSbi7u4uOQ2bILAol8MdI5eyINGh10iOtqbRQq2CpVuGTYI9HGpn8N5Ik4dixY3K5PHv2LOzt7fHss88iNDQU/fv3Z7kkk3Lu3Dm4u7tj+vTpmDNnjug4RGYjMzMTnp6emD59Oj755BPRcchMmU2hBP5YUzkjPBWJOddgoVY9sFje+3lv14aYN8zzgWsmq0uSJKSkpMjlMicnB0888cR95dLa2tpg7yfSh9GjRyMuLg7Z2dmoU6eO6DhEZkGSJPj5+SEvLw+nTp1C7dq1RUciM2VWhfKe7IISbEjOR3xWIfKLyu67UUcFwMnBFr5ujhjt7QRXx7o1mk2SJJw4cUIul9nZ2WjQoAGGDh2K0NBQ+Pv7s1yS0Tl69Ci6dOmCVatWYdy4caLjEJmNDRs2YPTo0di5cycGDhwoOg6ZMbMslH9VWq5FXlEpKrQ6WFuq4exgBzsb49gkI0kSUlNT5XKZmZmJ+vXrIzg4GKGhoQgICICNjY3omGTmJElC//79ceXKFZw8eZKbzIhqyPXr19G6dWv06dMHv/32m+g4ZObMvlCaCkmScOrUKfkoooyMDNSrV+++clmrVi3RMckMbd++HYGBgYiMjERgYKDoOERm46233sL69euRkZGBpk2bio5DZo6F0kSlpaXJI5fp6emoW7cugoODERISgoEDB7JcUo3QarVo3749HB0dsXv3bh5VQlRDDh06BG9vb3z11Vd49913RcchYqFUgvT0dHnk8tSpU6hTpw6CgoIQGhqKgQMHcpE2GcyaNWswbtw4HDlyBJ07dxYdh8gsaLVadO3aVT7nmMtMyBiwUCrM6dOn5ZHL1NRU2NnZITAwEKGhoRg0aBBsbQ23W53My+3bt9GqVSv069cPGzZsEB2HyGx8/fXXmDhxIg4cOIBu3br9+x8gqgEslAqWmZkpj1yeOHECdnZ2GDJkiFwu7ezsREckE/bxxx9j3rx5yMzMhLOzs+g4RGbh0qVLaN26NUaNGoUVK1aIjkMkY6E0E9nZ2fLIZUpKCmxtbTF48GCEhoZiyJAhLJf0SK5cuQJXV1e88cYbWLx4seg4RGZjxIgRSEhIwOnTp/HEE0+IjkMkY6E0Qzk5OfLI5bFjx1C7du37yiUPpaZ/8/rrr0Oj0eDMmTP8UCOqIdHR0RgwYAB+/vlnjB49WnQcovuwUJq5M2fOYPPmzdBoNDhy5Ahq1aqFQYMGITQ0FIGBgahbt2YPdifjl56eDk9PTyxatAjvvfee6DhEZuHOnTvw9PSEk5MT4uLieKICGR0WSpLl5ubKI5eHDx+GjY0NBg0ahJCQEAQFBaFevXqiI5IRCAoKQlpaGjIyMniwPlENmT17NubPn4+TJ0+idevWouMQ/R8slPS38vLy5JHL5ORk2NjYYMCAAQgNDUVQUBDq168vOiIJkJCQAF9fX2zcuBEjR44UHYfILGRlZcHT0xNTp07F3LlzRcch+lsslPSv8vPz5ZHLgwcPwtraGgEBAQgNDUVwcDAaNGggOiLVAJ1Oh65du0KtViM5OZlTbkQ1QJIk+Pv7Izc3F6dOneK5wmS0WCjpkZw/f14euUxKSoKVlZVcLocOHcpyqWC//PILRo0ahT179sDHx0d0HCKzsHHjRrz44ovYsWMHBg0aJDoO0T9ioaTHduHCBblc7t+/H1ZWVvDz85PLpb29veiIpCd3795F69at0b59e/z++++i4xCZhRs3bqBNmzbo2bMnwsLCRMcheiAWStKLixcvYsuWLdBoNNi3bx8sLCzuK5cODg6iI1I1LF68GNOnT8epU6e4IYCohrz99tv48ccfkZGRgWbNmomOQ/RALJSkd5cuXZLLZWJiIiwsLNCvXz+Ehobi2WefRcOGDUVHpEdQXFyMli1bYuTIkbyZg6iGHDlyBF27dsUXX3yBSZMmiY5D9K9YKMmgrly5IpfLvXv3QqVSoV+/fggJCcGwYcPQqFEj0RHpX7z33ntYs2YNcnJy0LhxY9FxiBSvqqoK3bp1g1arxZEjR2BpaSk6EtG/YqGkGlNQUIAtW7YgLCwMCQkJUKlU6Nu3L0JDQzFs2DA4OjqKjkj/4+zZs2jdujVmzZqFWbNmiY5DZBaWLVuGd955B0lJSfD29hYdh+ihsFCSEIWFhQgPD4dGo0F8fDwAoG/fvggJCcHw4cM5EmYkRo4cib179yI7O5v3vRPVgMuXL6N169YYOXIkVq1aJToO0UNjoSThrl69ivDwcISFhWH37t2QJAk+Pj4IDQ3F8OHD8eSTT4qOaJYOHTqEbt26Ye3atRg7dqzoOERm4YUXXkBcXBxOnz7NkzLIpLBQklG5du0atm7dCo1Gg7i4OOh0OvTu3RuhoaF47rnn0KRJE9ERzYIkSejbty+Ki4uRkpICCwsL0ZGIFC8mJgYBAQH48ccf8dJLL4mOQ/RIWCjJaBUVFeH333+HRqNBbGwsqqqq0KtXL7lcPvXUU6IjKlZERASGDh3Kw5SJasjdu3fh6emJpk2bIj4+njdRkclhoSSTUFxcfF+51Gq16NGjh1wueUab/mi1WvmDLSYmhh9sRDXg448/xmeffYYTJ06gTZs2ouMQPTIWSjI5169fR0REBDQaDaKjo1FZWXlfuWzevLnoiCZt5cqVeOutt3D06FF07NhRdBwixcvOzoanpyfee+89zJs3T3QcosfCQkkm7caNG4iIiEBYWBiioqJQUVEBb29vhIaGIiQkBE5OTqIjmpSSkhK4urpiwIAB+Omnn0THIVI8SZIwYMAAZGdnIy0tDba2tqIjET0WFkpSjJs3byIyMhIajQa7du1CRUUFunXrJo9cOjs7i45o9D766CMsXLgQWVlZLONENeDXX3/FyJEjsW3bNgwZMkR0HKLHxkJJinTr1i1ERkYiLCwMO3fuRHl5Oby8vOSRSxcXF9ERjc6lS5fQqlUrTJgwAZ9//rnoOESKd/PmTbRu3Ro9evTA5s2bRcchqhYWSlK8kpISbNu2DRqNBjt37sTdu3fRuXNnhIaGIjQ0FC1atBAd0Si89tpr2Lp1K86cOYP69euLjkOkeO+88w6+++47ZGRkcO03mTwWSjIrt2/fxvbt26HRaLBjxw7cuXMHnTp1kstly5YtRUcU4tSpU2jfvj2++uorvPPOO6LjECne0aNH0bVrVyxcuBCTJ08WHYeo2lgoyWzdvn0bO3bsgEajwfbt23Hnzh106NBBLpetWrUSHbHGDB48WN4UYG1tLToOkaJVVVXB29sbFRUVOHLkCKysrERHIqo2FkoiAKWlpdi5cyc0Gg22bduGsrIytG/fXl5z6e7uLjqiwcTFxcHPzw8ajQYhISGi4xAp3rfffovx48dj//796NGjh+g4RHrBQkn0P8rKyu4rl6WlpfD09JRHLlu3bi06ot7odDp06dIFtWrVwv79+3mIOZGBXblyBe7u7hgxYgRWr14tOg6R3rBQEj3AnTt3sGvXLmg0GkRGRuL27dto166dPHLZtm1b0RGr5eeff8ZLL72Effv2oWfPnqLjECneqFGjEB0djczMTNjb24uOQ6Q3LJRED+nOnTuIiopCWFgYIiIiUFJSgrZt28ojlx4eHqIjPpI7d+7A3d0dXbp0wZYtW0THIVK8e8tLvv/+e7zyyiui4xDpFQsl0WO4e/cuoqOjodFoEBERgVu3bqFNmzYICQlBaGgo2rVrJ3z6uLRci7yiUlRodbC2VMPZwQ52NpbyzxcsWICZM2ciLS0Nbm5uApMSKV95eTmeeeYZPPnkk0hISBD+7wcifWOhJKqm8vJyuVz+/vvvuHXrFtzd3eWRS09Pzxr78MguKMGG5HzEZxYiv7gMf/3lVgFwsreFr7sjBrvXhX9XT4wZMwbLli2rkWxE5uzTTz/FJ598gpSUFJObzSB6GCyURHpUXl6O2NhYuVzeuHEDbm5u8shl+/btDVIuzxeXYUZ4KhJzrsFCrUKV7p9/re/9vCL/JHZ8PAYdXJvpPQ8R/X85OTlo164dJk2ahPnz54uOQ2QQLJREBlJRUYHY2FiEhYVh69atuH79OlxdXeWRyw4dOuilXG46nI/ZEWnQ6qQHFsn/pYIEa0sLfBzsgZFevLebyBAkScKgQYNw+vRppKenw9bWVnQkIoNgoSSqARUVFdi9ezc0Gg22bt2K4uJitGzZUh657NSp02OVy2Xx2VgcnVXtfFMC3PC2r/kc5E5UUzQaDZ5//nlEREQgKChIdBwig2GhJKphlZWViI+Ph0ajQXh4OIqKitCiRQuEhIQgJCQEXbp0eahyuelwPqZvSdVbrgXDPTGCI5VEenPr1i20bt0a3bp1Q3h4uOg4RAbFQkkkUGVlJRISEuRyee3aNTg7O8sjl15eXn9bLs8Xl8Hvqz0o1+r0lsXGUo3YSX3Q3J5TckT6MHHiRKxZswYZGRlwcuKXNVI2FkoiI6HVarFnzx5oNBps2bIFV69ehZOTk1wuu3XrJpfLMeuSkXS26JHWTP4bC7UKPVo44Oex3fT2TCJzdezYMXh5eWHBggWYMmWK6DhEBsdCSWSEtFot9u7dK5fLwsJCNG/eHCEhIeg+cDimxt802LtjJ/nA1bGuwZ5PpHRVVVXo0aMHysrKcOzYMVhZWYmORGRwLJRERq6qqgqJiYnQaDTYvHkzKjyHom6nIVCpLfT+Lgu1CmO6PY05wTwnj+hxrVy5Em+++SavNCWzwkJJZEKqqqrQ/bMoFN4x3K/t0w622DPF12DPJ1KygoICuLu7IyQkBGvXrhUdh6jGqEUHIKKHd0cr4aoByyQA5BeVobRca9B3ECnVlClTYGlpiQULFoiOQlSjWCiJTMi5olIYekpBApBXVGrgtxApz+7du7F+/XosWrQIDg4OouMQ1SgWSiITUqHHY4KM4T1ESlFeXo633noLvXr1wssvvyw6DlGNsxQdgIgenrVlzXwHrKn3ECnF4sWLcebMGYSFhUGt5u8PmR/+U09kQpwd7FD9278fTPXne4jo4Zw9exZz587Fe++9h3bt2omOQyQEd3kTmZg+i+JxrrjMYM/X3byCHsUxGDBgAAICAtC0aVODvYvI1EmShMGDByM9PR3p6emws+OXMTJPHKEkMjG+7o6wUBtmnFKtAto0kHDmzBmMHTsWzZo1g6enJ6ZMmYLo6GjcvXvXIO8lMlWbN2/Grl278M0337BMklnjCCWRickuKIH/kr0Ge/69m3KuXbuG2NhYREVFITo6GpcuXUKtWrXQp08fDBgwAAMGDECbNm3+9q5xInNQUlKCNm3aoHPnzvj9999FxyESioWSyATV9F3ekiQhLS0NUVFRiIqKwt69e1FeXo5mzZohICAAAwYMgJ+fH+zt7fWWh8jYvffee1i1ahXS09Px9NNPi45DJBQLJZEJOl9cBr+v9qBcj8f72FiqETupD5rb2/7r31tWVobExES5YKanp0OtVsPLy0sumN26dYOlJQ+SIGVKSUlB586dMX/+fEybNk10HCLhWCiJTNSmw/mYviVVb89bMNwTI7ycHuvPnj9/HtHR0YiKikJsbCyuX7+O+vXro3///vLmHmdnZ71lJRJJp9OhR48euH37No4fPw4rKyvRkYiEY6EkMmHL4rOxODqr2s+ZGuCO8b6uekj0x33jR44ckUcvk5OTUVVVBTc3N3ntZd++fbmBgUzWqlWr8MYbb2Dv3r3o3bu36DhERoGFksjEbTqcj9kRadDqpEdaU2mhVsFSrcInwR6PPTL5MG7cuIHdu3fLBfPcuXOwsrJCr1695ILZvn17bu4hk1BYWAh3d3cMGzYM3333neg4REaDhZJIAc4Xl2FGeCoSc67BQq16YLG89/Perg0xb5jnQ62Z1BdJkpCVlSVPj8fHx6OsrAyNGzdGQECA/B9HR8cay0T0KF5++WVs27YNmZmZaNiwoeg4REaDhZJIQbILSrAhOR/xWYXILyrDX3+5VQCcHGzh6+aI0d5OcHWsKyqmrLy8HPv375ePJkpJSQEAdOzYUR697NGjB6ytrcUGJQKQkJAAX19frF27FmPHjhUdh8iosFASKVRpuRZ5RaWo0OpgbamGs4Md7GyMe9f1lStXEBMTIxfMq1evws7ODr6+vnLBdHV15fQ41biKigq0b98e9vb2SExM5H3dRP+DhZKIjJJOp8OJEyfktZf79+9HZWUlXFxc5KOJ+vXrh/r164uOSmZg3rx5+Oijj3D8+HF4enqKjkNkdFgoicgk3L59GwkJCXLBzM7OhoWFBbp37y4fTdS5c2dYWFiIjkoKk5ubi7Zt2+Ltt9/GokWLRMchMkoslERkknJzc+VyGRcXh5KSEjg4OMDPz08umE2bNhUdk0ycJEkIDAxEamoq0tPTUadOHdGRiIwSCyURmbzKykokJyfLBfPIkSOQJAkeHh7y2svevXujdu3aoqOSidmyZQuee+45hIeH49lnnxUdh8hosVASkeIUFRUhNjZWLpiXLl1CrVq10KdPH3n9Zdu2bbm5hx6opKQEbdu2RYcOHRAREcF/XogegIWSiBRNkiSkpaXJZ1/u3bsXd+/eRbNmzeRy2b9/fzg4OIiOSkZm8uTJWLFiBdLT03l1KNG/YKEkIrNy584d7N27Vz6aKC0tDSqVCl5eXvL0eLdu3WBpadxHLJFhnThxAp07d8bcuXMxffp00XGIjB4LJRGZtQsXLsijlzExMbh+/Trq1auH/v37ywWTo1PmRafToVevXrh58yaOHz/Og/WJHgILJRHRn6qqqnD06FF57eXBgwdRVVUFNzc3eed43759udNX4dasWYNx48Zhz5498PHxER2HyCSwUBIR/YMbN25g9+7d8ghmXl4erKys0KtXL3n08plnnuGtKQpy9epVuLu7Izg4GD/88IPoOEQmg4WSiOghSJKE7OxsefQyPj4eZWVlaNy4Mfz9/eURTEdHR9FRqRpeeeUVREREIDMzE40aNRIdh8hksFASET2G8vJyJCUlyQUzJSUFANCxY0d593jPnj25/s6E7NmzB3379sXq1avx3//+V3QcIpPCQklEpAcFBQWIiYmRd48XFhbCzs4Ovr6+8uhlq1ateJahkaqoqECHDh3QoEED7Nu3j8sYiB4RCyURkZ7pdDqcOHFCXnu5b98+VFZWwtnZWV572a9fP9SvX190VPrT559/jpkzZ+LYsWN45plnRMchMjkslEREBnb79m0kJCTIo5dZWVmwsLCAt7e3XDA7d+4MCwsL0VHNUl5eHtq2bYs333wTX3zxheg4RCaJhZKIqIbl5ubKo5dxcXG4desW7O3t4e/vL6+/bNq0qeiYZkGSJAQHByMlJQXp6emoW7eu6EhEJomFkohIoMrKShw6dEje3HP48GFIkgQPDw959LJ3796oXbu26KiKtHXrVgwbNgybN2/G8OHDRcchMlkslERERqSoqAixsbHyCObFixdRq1Yt+Pj4yAWzbdu23NyjB7dv30abNm3Qvn17REZG8r9TompgoSQiMlKSJCE9PV0evdy7dy/u3r2Lpk2bylPjfn5+cHBwEB3VJE2dOhXLly9HWloaXFxcRMchMmkslEREJuLOnTtITEyUC2ZaWhpUKhW8vLzko4m8vb1haWkpOqrRS01NRceOHfHJJ59gxowZouMQmTwWSiIiE3Xx4kV5ajwmJgbFxcWoV68e+vfvL0+POzs7i45pdHQ6HXr37o3r168jJSWFh88T6QELJRGRAlRVVeHo0aNywTxw4ACqqqrQqlUruVz27dsXderUER1VuHXr1uG1115DfHw8+vbtKzoOkSKwUBIRKdDNmzexe/dueXo8Ly8PVlZW6Nmzp1ww27dvb3Y3wly7dg3u7u4IDAzEjz/+KDoOkWKwUBIRKZwkScjJyZHLZXx8PEpLS+Ho6Chv7vH390fjxo1FRzW4V199FVu3bsXp06fh6OgoOg6RYrBQEhGZmYqKCiQlJckF8/jx4wCADh06yKOXPXv2VNzawsTERPj4+GDlypV4/fXXRcchUhQWSiIiM1dQUICYmBhER0cjOjoaBQUFsLOzg6+vrzyC2apVK6M+p7G0XIu8olJUaHWwtlTD2cEOdjb/f7d7ZWUlOnbsiLp162L//v1mN9VPZGgslEREJNPpdDh58qQ8erlv3z5UVlbC2dlZPpqof//+qF+/vuioyC4owYbkfMRnFiK/uAx//TBTAXCyt4WvuyNGdXNC+I8r8MEHH+Do0aPo0KGDoMREysVCSURE/6i0tBQJCQlywczKyoKFhQW8vb3l6fHOnTvDwsKixjKdLy7DjPBUJOZcg4VahSrdP3+M3ft5xbkTCHryNlZ9Oa/GchKZExZKIiJ6aHl5efLRRHFxcbh58ybs7e3h5+cnj2A2a9bMYO/fdDgfsyPSoNVJDyyS/0vSVaGWtRU+DvbASC8ng+UjMlcslERE9Fi0Wi2Sk5Plgnno0CFIkgQPDw957aWPjw9q166tl/cti8/G4uisaj9nSoAb3vZtpYdERHQPCyUREelFcXExYmNj5enxixcvolatWvDx8ZFHLz08PB5rc8+mw/mYviVVb1kXDPfECI5UEukNCyUREemdJEnIyMiQy+WePXtw9+5dNG3aVB699PPzg4ODw78+63xxGfy+2oNyrU5v+Wws1Yid1AfN7W319kwic8ZCSUREBnfnzh3s27dPLpinTp2CSqVCly5d5M093bp1g5WV1f/5s2PWJSPpbNEjrZn8NxZqFXq0cMDPY7vp7ZlE5oyFkoiIatzFixflcy9jYmJQVFSEevXqoX///vIIpouLC7ILSuC/ZK/BcsRO8oGrY12DPZ/IXLBQEhGRUFVVVTh27Jg8enngwAFUVVWhVatWaBo0EeesnaCD/g9Vt1CrMKbb05gT7KH3ZxOZGxZKIiIyKrdu3cLu3bsRFRWFnRbdgLqNDPaupx1ssWeKr8GeT2QuWCiJiMgo3S7XwnNOFAz5IaUCcGrOgPuuaSSiR8fLTImIyCidKyo1aJkEAAlAXlGpgd9CpHwslEREZJQq9HhMkDG8h0jJWCiJiMgoWVvWzEdUTb2HSMn4W0REREbJ2cHOAHu776f68z1EVD0slEREZJTsbCzhZOCbbJwcbLkhh0gPWCiJiMho+bo7wkJtmHFKC7UKvm6OBnk2kblhoSQiIqM1qpuTXq9c/KsqnYTR3k4GeTaRuWGhJCIio9WqcV30dm2o91FKC7UKvV0b8tpFIj1hoSQiIqM2b5gnLPVcKC3VKswb5qnXZxKZMxZKIiIyas3tbfGxnu/b/iTYA80NvOGHyJywUBIRkdEb6eWEKQFuennW1AB3jPDi2kkifeJd3kREZDI2Hc7H7Ig0aHXSI23WsVCrYKlW4ZNgD5ZJIgNgoSQiIpNyvrgMM8JTkZhzDRZq1QOL5b2f93ZtiHnDPDnNTWQgLJRERGSSsgtKsCE5H/FZhcgvKsNfP8xU+OPQcl83R4z2duJubiIDY6EkIiKTV1quRV5RKSq0OlhbquHsYMcbcIhqEAslEREREVULd3kTERERUbWwUBIRERFRtbBQEhEREVG1sFASERERUbWwUBIRERFRtbBQEhEREVG1sFASERERUbWwUBIRERFRtbBQEhEREVG1sFASERERUbWwUBIRERFRtbBQEhEREVG1sFASERERUbWwUBIRERFRtbBQEhEREVG1sFASERERUbWwUBIRERFRtbBQEhEREVG1sFASERERUbWwUBIRERFRtbBQEhEREVG1sFASERERUbWwUBIRERFRtbBQEhEREVG1sFASERERUbWwUBIRERFRtbBQEhEREVG1sFASERERUbWwUBIRERFRtbBQEhEREVG1sFASERERUbWwUBIRERFRtbBQEhEREVG1sFASERERUbWwUBIRERFRtbBQEhEREVG1sFASERERUbX8P35ARgUQYHKsAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -118,12 +127,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -138,12 +147,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -165,7 +174,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -252,7 +261,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -278,7 +287,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -313,7 +322,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -348,7 +357,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -365,7 +374,7 @@
    "source": [
     "hexagon_graph = hexagonal_lattice_graph(3,3)\n",
     "pos = nx.get_node_attributes(hexagon_graph, 'pos')\n",
-    "assign_hexagon_labels(hexagon_graph)\n",
+    "assign_hexagon_labels(hexagon_graph, 'X', 'Y', 'Z')\n",
     "edge_labels = dict([((n1, n2), d['label']) for n1, n2, d in hexagon_graph.edges(data=True)]);\n",
     "nx.draw(hexagon_graph, pos)\n",
     "nx.draw_networkx_edge_labels(hexagon_graph, pos,edge_labels = edge_labels);"
@@ -383,7 +392,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -404,7 +413,7 @@
     "\n",
     "def generate_kitaev_hamiltonian(lattice_size:int, weight_prob:float=1):\n",
     "    graph = hexagonal_lattice_graph(lattice_size,lattice_size)\n",
-    "    assign_hexagon_labels(graph)\n",
+    "    assign_hexagon_labels(graph, 'X', 'Y', 'Z')\n",
     "    graph = flatten_nx_graph(graph)\n",
     "    H = nx_kitaev_terms(graph, weight_prob)\n",
     "    return H\n"
@@ -412,7 +421,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -442,7 +451,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -459,7 +468,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
@@ -484,7 +493,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
@@ -523,7 +532,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -565,7 +574,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -625,7 +634,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -647,7 +656,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -658,7 +667,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
@@ -704,7 +713,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -718,7 +727,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
@@ -743,7 +752,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -768,7 +777,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
@@ -793,7 +802,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
@@ -818,7 +827,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
diff --git a/notebooks/RuClExample.ipynb b/notebooks/RuClExample.ipynb
new file mode 100644
index 0000000..e378ef0
--- /dev/null
+++ b/notebooks/RuClExample.ipynb
@@ -0,0 +1,989 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c375a2e9-f691-4aba-8f0f-ac466ce86f33",
+   "metadata": {},
+   "source": [
+    "# RuCl Full Scale Example\n",
+    "We can now implement a full scale example, with details described here https://www.nature.com/articles/s41535-019-0203-y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6770f6e2-191d-417c-b971-2fc509e2e0bf",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/zain/anaconda3/lib/python3.11/site-packages/attr/_make.py:918: RuntimeWarning: Running interpreter doesn't sufficiently support code object introspection.  Some features like bare super() or accessing __class__ will not work with slotted classes.\n",
+      "  set_closure_cell(cell, cls)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import time\n",
+    "import random\n",
+    "import pandas as pd\n",
+    "\n",
+    "from openfermion import count_qubits\n",
+    "from openfermion.circuits import trotter_steps_required, error_bound\n",
+    "from openfermion.circuits.trotter_exp_to_qgates import trotterize_exp_qubop_to_qasm\n",
+    "\n",
+    "import networkx as nx\n",
+    "from networkx.generators.lattice import hexagonal_lattice_graph\n",
+    "\n",
+    "import cirq\n",
+    "from cirq.contrib import qasm_import\n",
+    "\n",
+    "from pyLIQTR.circuits.qsp import generate_QSP_circuit\n",
+    "from pyLIQTR.utils.Hamiltonian import Hamiltonian as pyH\n",
+    "from pyLIQTR.utils.utils import open_fermion_to_qasm, count_T_gates\n",
+    "from pyLIQTR.utils.qsp_helpers import circuit_decompose_once, circuit_decompose_once, print_to_openqasm\n",
+    "from pyLIQTR.gate_decomp.cirq_transforms import clifford_plus_t_direct_transform\n",
+    "from pyLIQTR.phase_factors.fourier_response.fourier_response import Angler_fourier_response\n",
+    "\n",
+    "from qca.utils.utils import count_gates, get_T_depth_wire, get_T_depth, plot_histogram\n",
+    "from qca.utils.hamiltonian_utils import flatten_nx_graph, assign_hexagon_labels, pyliqtr_hamiltonian_to_openfermion_qubit_operator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "f09ad0d9-4f64-4951-aad4-85f22ac9ee84",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "t_init = time.perf_counter()\n",
+    "def estimate_qsp(pyliqtr_hamiltonian, timesteps, energy_precision, outdir, hamiltonian_name=\"hamiltonian\", write_circuits=False):\n",
+    "    timestep_of_interest=1 #for magnus like argument\n",
+    "    t0 = time.perf_counter()\n",
+    "    random.seed()\n",
+    "    angles_response = Angler_fourier_response(tau=timestep_of_interest*pyliqtr_hamiltonian.alpha, eps=energy_precision, random=True, silent=True)\n",
+    "    angles_response.generate()\n",
+    "    angles = angles_response.phases\n",
+    "\n",
+    "    qsp_circuit = generate_QSP_circuit(pyliqtr_hamiltonian, angles, pyliqtr_hamiltonian.problem_size)\n",
+    "    t1 = time.perf_counter()\n",
+    "    elapsed = t1 - t0\n",
+    "    print(\"  Time to generate high level QSP circuit: \" + str(elapsed) + \" seconds\")\n",
+    "    \n",
+    "    if not os.path.exists(outdir):\n",
+    "        os.makedirs(outdir)\n",
+    "    \n",
+    "    subcircuit_counts = dict()\n",
+    "    t_counts = dict()\n",
+    "    t_depths = dict()\n",
+    "    t_depth_wires = dict()\n",
+    "    clifford_counts = dict()\n",
+    "    gate_counts = dict()\n",
+    "    subcircuit_depths = dict()\n",
+    "    \n",
+    "    outfile_data = outdir + hamiltonian_name + \"_high_level.dat\"\n",
+    "    \n",
+    "    for moment in qsp_circuit:\n",
+    "        for operation in moment:\n",
+    "            gate_type = type(operation.gate)\n",
+    "            if gate_type in subcircuit_counts:\n",
+    "                subcircuit_counts[gate_type] += 1\n",
+    "            \n",
+    "            else:\n",
+    "                outfile_qasm_decomposed = f'{outdir}{str(gate_type)[8:-2]}.decomposed.qasm'\n",
+    "                outfile_qasm_cpt = f'{outdir}{str(gate_type)[8:-2]}.cpt.qasm'\n",
+    "                \n",
+    "                t0 = time.perf_counter()\n",
+    "                decomposed_circuit = circuit_decompose_once(circuit_decompose_once(cirq.Circuit(operation)))\n",
+    "                t1 = time.perf_counter()\n",
+    "                elapsed = t1 - t0\n",
+    "                print(\"    Time to decompose high level \" + str(gate_type)[8:-2] +\" circuit: \" + str(elapsed) + \" seconds\")\n",
+    "                \n",
+    "                t0 = time.perf_counter()\n",
+    "                cpt_circuit = clifford_plus_t_direct_transform(decomposed_circuit)\n",
+    "                t1 = time.perf_counter()\n",
+    "                elapsed = t1 - t0\n",
+    "                print(\"    Time to transform decomposed \" + str(gate_type)[8:-2] + \" circuit to Clifford+T: \" + str(elapsed) + \" seconds\")\n",
+    "                \n",
+    "                if write_circuits:\n",
+    "                    with open(outfile_qasm_decomposed, 'w') as f:\n",
+    "                        print_to_openqasm(f, decomposed_circuit, qubits=decomposed_circuit.all_qubits())\n",
+    "                    \n",
+    "                    with open(outfile_qasm_cpt, 'w') as f:\n",
+    "                        print_to_openqasm(f, cpt_circuit, qubits=cpt_circuit.all_qubits())\n",
+    "                \n",
+    "                subcircuit_counts[gate_type] = 1\n",
+    "                subcircuit_depths[gate_type] = len(cpt_circuit)\n",
+    "                t_counts[gate_type] = count_T_gates(cpt_circuit)\n",
+    "                gate_counts[gate_type] = count_gates(cpt_circuit)\n",
+    "                t_depths[gate_type] = get_T_depth(cpt_circuit)\n",
+    "                t_depth_wires[gate_type] = get_T_depth_wire(cpt_circuit)\n",
+    "                clifford_counts[gate_type] = gate_counts[gate_type] - t_counts[gate_type]\n",
+    "                \n",
+    "    total_gate_count = 0\n",
+    "    total_gate_depth = 0\n",
+    "    total_T_depth = 0\n",
+    "    total_T_depth_wire = 0\n",
+    "    total_T_count = 0\n",
+    "    total_clifford_count = 0\n",
+    "    for gate in subcircuit_counts:\n",
+    "        total_gate_count += subcircuit_counts[gate] * gate_counts[gate] * timesteps / timestep_of_interest\n",
+    "        total_gate_depth += subcircuit_counts[gate] * subcircuit_depths[gate] * timesteps / timestep_of_interest\n",
+    "        total_T_depth += subcircuit_counts[gate] * t_depths[gate] * timesteps / timestep_of_interest\n",
+    "        total_T_depth_wire += subcircuit_counts[gate] * t_depth_wires[gate] * timesteps / timestep_of_interest\n",
+    "        total_T_count += subcircuit_counts[gate] * t_counts[gate] * timesteps / timestep_of_interest\n",
+    "        total_clifford_count += subcircuit_counts[gate] * clifford_counts[gate] * timesteps / timestep_of_interest\n",
+    "    with open(outfile_data, 'w') as f:\n",
+    "        total_gate_count \n",
+    "        f.write(str(\"Logical Qubit Count:\"+str(len(qsp_circuit.all_qubits()))+\"\\n\"))\n",
+    "        f.write(str(\"Total Gate Count:\"+str(total_gate_count)+\"\\n\"))\n",
+    "        f.write(str(\"Total Gate Depth:\"+str(total_gate_depth)+\"\\n\"))\n",
+    "        f.write(str(\"Total T Count:\"+str(total_T_count)+\"\\n\"))\n",
+    "        f.write(str(\"Total T Depth:\"+str(total_T_depth)+\"\\n\"))\n",
+    "        f.write(str(\"Maximum T Count on Single Wire:\"+str(total_T_depth_wire)+\"\\n\"))\n",
+    "        f.write(str(\"Total Clifford Count:\"+str(total_clifford_count)+\"\\n\"))\n",
+    "        f.write(\"Subcircuit Info:\\n\")\n",
+    "        for gate in subcircuit_counts:\n",
+    "            f.write(str(str(gate)+\"\\n\"))\n",
+    "            f.write(str(\"Subcircuit Occurrences:\"+str(subcircuit_counts[gate]*timesteps)+\"\\n\"))\n",
+    "            f.write(str(\"Gate Count:\"+str(gate_counts[gate])+\"\\n\"))\n",
+    "            f.write(str(\"Gate Depth:\"+str(subcircuit_depths[gate])+\"\\n\"))\n",
+    "            f.write(str(\"T Count:\"+str(t_counts[gate])+\"\\n\"))\n",
+    "            f.write(str(\"T Depth:\"+str(t_depths[gate])+\"\\n\"))\n",
+    "            f.write(str(\"Maximum T Count on a Single Wire:\"+str(t_depth_wires[gate])+\"\\n\"))\n",
+    "            f.write(str(\"Clifford Count:\"+str(clifford_counts[gate])+\"\\n\"))\n",
+    "    return qsp_circuit\n",
+    "\n",
+    "\n",
+    "def find_hamiltonian_ordering(of_hamiltonian):\n",
+    "    \"\"\"\n",
+    "    Function to generate a near optimal term ordering for trotterization of transverse field Ising Models.\n",
+    "    This would need to be modified if there were multi-qubit interactions that were not just ZZ\n",
+    "    \"\"\"\n",
+    "    #ordering hamiltonian terms by performing edge coloring to make optimal trotter ordering\n",
+    "    #assuming that any 2 body interactions are ZZ\n",
+    "    sorted_terms = sorted(list(of_hamiltonian.terms.keys()))\n",
+    "    sorted_terms.sort(key=lambda x: len(x) * 100 + ord(x[0][1])) #Z and X get translated to 90 and 88 respectively, multiplying by 100 ensures interacting term weight is considered\n",
+    "    one_body_terms_ordered = list(filter(lambda x: len(x) == 1, sorted_terms))\n",
+    "    two_body_terms = list(filter(lambda x: len(x) == 2, sorted_terms))\n",
+    "    \n",
+    "    #assigning edge colorings to order two body terms\n",
+    "    g = nx.Graph()\n",
+    "    for term in two_body_terms:\n",
+    "        edge = (term[0][0], term[1][0])\n",
+    "        g.add_edge(*edge)\n",
+    "    edge_coloring = nx.greedy_color(nx.line_graph(g))\n",
+    "    nx.set_edge_attributes(g, edge_coloring, \"color\")\n",
+    "\n",
+    "    for (i,term) in enumerate(two_body_terms):\n",
+    "        n1,n2 = (term[0][0], term[1][0])\n",
+    "        color = g.edges[n1,n2]['color']\n",
+    "        term = (*term, color)\n",
+    "        two_body_terms[i] = term\n",
+    "    \n",
+    "    two_body_terms.sort(key=lambda x: x[2])\n",
+    "    two_body_terms_ordered = list()\n",
+    "    for (i,term) in enumerate(two_body_terms):\n",
+    "        new_item = (term[0],term[1])\n",
+    "        two_body_terms_ordered.append(new_item)\n",
+    "    return one_body_terms_ordered + two_body_terms_ordered\n",
+    "\n",
+    "def estimate_trotter(openfermion_hamiltonian,timesteps, energy_precision, outdir, hamiltonian_name=\"hamiltonian\", write_circuits=False):\n",
+    "    t0 = time.perf_counter()\n",
+    "    bounded_error = error_bound(list(openfermion_hamiltonian.get_operators()),tight=False)\n",
+    "    nsteps = trotter_steps_required(trotter_error_bound = bounded_error,\n",
+    "                                                time = timesteps, \n",
+    "                                                energy_precision = energy_precision)\n",
+    "    t1 = time.perf_counter()\n",
+    "    elapsed = t1 - t0\n",
+    "    print(\"  Time to estimate Number of steps required: \" + str(elapsed) + \" seconds\")\n",
+    "    \n",
+    "    t0 = time.perf_counter()\n",
+    "    term_ordering = find_hamiltonian_ordering(openfermion_hamiltonian)\n",
+    "    t1 = time.perf_counter()\n",
+    "    elapsed = t1 - t0\n",
+    "    print(\"  Time to find term ordering: \" + str(elapsed) + \" seconds\")\n",
+    "    \n",
+    "    t0 = time.perf_counter()\n",
+    "    trotter_circuit_of = trotterize_exp_qubop_to_qasm(openfermion_hamiltonian, trotter_order=2, evolution_time=timesteps/nsteps, term_ordering=term_ordering)\n",
+    "    t1 = time.perf_counter()\n",
+    "    elapsed = t1 - t0\n",
+    "    print(\"  Time to generate trotter circuit from openfermion: \" + str(elapsed) + \" seconds\")\n",
+    "    \n",
+    "    qasm_str_trotter = open_fermion_to_qasm(count_qubits(openfermion_hamiltonian), trotter_circuit_of)\n",
+    "    trotter_circuit_qasm = qasm_import.circuit_from_qasm(qasm_str_trotter)\n",
+    "    \n",
+    "    t0 = time.perf_counter()\n",
+    "    cpt_trotter = clifford_plus_t_direct_transform(trotter_circuit_qasm)\n",
+    "    t1 = time.perf_counter()\n",
+    "    elapsed = t1 - t0\n",
+    "    print(\"  Time to decompose trotter to Clifford + T: \" + str(elapsed) + \" seconds\")\n",
+    "    \n",
+    "    #writing the the higher level trotter circuit to a file as well as the clifford + T circuit\n",
+    "    if not os.path.exists(outdir):\n",
+    "        os.makedirs(outdir)\n",
+    "    \n",
+    "    if write_circuits:\n",
+    "        outfile_qasm_decomposed = outdir + \"trotter_circuit_\" + hamiltonian_name + \".qasm\" \n",
+    "        outfile_qasm_cpt = outdir + \"trotter_cpt_\" + hamiltonian_name + \".qasm\"\n",
+    "        with open(outfile_qasm_decomposed, 'w') as f:\n",
+    "            print_to_openqasm(f, trotter_circuit_qasm, qubits=trotter_circuit_qasm.all_qubits())\n",
+    "        with open(outfile_qasm_cpt, 'w') as f:\n",
+    "            print_to_openqasm(f, cpt_trotter, qubits=cpt_trotter.all_qubits())\n",
+    "    \n",
+    "    t0 = time.perf_counter()\n",
+    "    outfile_data = outdir + \"trotter_\" + hamiltonian_name + \".dat\"\n",
+    "    gate_count = count_gates(cpt_trotter)\n",
+    "    t_count = count_T_gates(cpt_trotter)\n",
+    "    t_depth = get_T_depth(cpt_trotter)\n",
+    "    t_depth_wire = get_T_depth_wire(cpt_trotter)\n",
+    "    with open(outfile_data, 'w') as f:\n",
+    "        f.write(\"Logical Qubit Count:\"+str(len(cpt_trotter.all_qubits()))+\"\\n\")\n",
+    "        f.write(\"Number of Trotter Steps Required (Loose Upper Bound):\"+ str(nsteps) +\"\\n\")\n",
+    "        f.write(\"Total T Depth:\"+str(t_depth * nsteps)+\"\\n\")\n",
+    "        f.write(\"Maximum T Count on a Single Wire:\"+str(t_depth_wire * nsteps)+\"\\n\")\n",
+    "        f.write(\"Single Step Gate Count:\"+str(gate_count)+\"\\n\")\n",
+    "        f.write(\"Single Step Gate Depth:\"+str(len(cpt_trotter))+\"\\n\")\n",
+    "        f.write(\"Single Step T Count:\"+str(t_count)+\"\\n\")\n",
+    "        f.write(\"Single Step T Depth:\"+str(t_depth)+\"\\n\")\n",
+    "        f.write(\"Single Step Maximum T Count on a Single Wire:\"+str(t_depth_wire)+\"\\n\")\n",
+    "        f.write(\"Single Step Clifford Count:\"+str(gate_count - t_count)+\"\\n\")\n",
+    "    \n",
+    "    t1 = time.perf_counter()\n",
+    "    elapsed = t1 - t0\n",
+    "    print(\"  Time to enumerate resource estimates: \" + str(elapsed) + \" seconds\")\n",
+    "    \n",
+    "    return cpt_trotter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "21cec969-e59e-4136-b417-20877db4eb09",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def assign_hexagon_labels_rucl(g):\n",
+    "    \n",
+    "    assign_hexagon_labels(g, 'X1', 'Y1', 'Z1')\n",
+    "       \n",
+    "    #Adding next nearest and next-next nearest neighbor edges and labels\n",
+    "    for n in g.nodes:\n",
+    "        r,c = n\n",
+    "        \n",
+    "        #next nearest neighbors\n",
+    "        if (r, c+2) in g:\n",
+    "            g.add_edge(n, (r, c+2), label = 'Z2')\n",
+    "        if (r+1, c+1) in g:\n",
+    "            g.add_edge(n, (r+1, c+1), label = \"Y2\")\n",
+    "        if (r-1, c+1) in g:\n",
+    "            g.add_edge(n, (r-1, c+1), label = \"X2\")\n",
+    "       \n",
+    "        #next-next nearest neighbors\n",
+    "        if (r+1, c) in g and not ((n, (r+1, c)) in g.edges):\n",
+    "            g.add_edge(n, (r+1,c), label = \"Z3\")\n",
+    "        if (r+1, c+2) in g and (r + c)%2 == 0:\n",
+    "            g.add_edge(n, (r+1, c+2), label=\"X3\")\n",
+    "        if (r-1, c+2) in g and (r + c)%2 == 1:\n",
+    "            g.add_edge(n, (r-1, c+2), label=\"Y3\")\n",
+    "\n",
+    "g_rucl = hexagonal_lattice_graph(3,3)\n",
+    "pos = nx.get_node_attributes(g_rucl, 'pos')\n",
+    "assign_hexagon_labels_rucl(g_rucl)\n",
+    "edge_labels = dict([((n1, n2), d['label']) for n1, n2, d in g_rucl.edges(data=True)]);\n",
+    "nx.draw(g_rucl, pos, with_labels=True)\n",
+    "nx.draw_networkx_edge_labels(g_rucl, pos,edge_labels = edge_labels);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2e8216d9-90b9-4174-8c0f-6b6d13aa2e25",
+   "metadata": {
+    "tags": []
+   },
+   "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>reference</th>\n",
+       "      <th>method</th>\n",
+       "      <th>J1</th>\n",
+       "      <th>K1</th>\n",
+       "      <th>Gam1</th>\n",
+       "      <th>Gam_prime1</th>\n",
+       "      <th>J2</th>\n",
+       "      <th>K2</th>\n",
+       "      <th>J3</th>\n",
+       "      <th>K3</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Winter et al. PRB</td>\n",
+       "      <td>Ab initio (DFT + exact diag.)</td>\n",
+       "      <td>-1.70</td>\n",
+       "      <td>-6.70</td>\n",
+       "      <td>6.60</td>\n",
+       "      <td>-0.90</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>2.7000</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Winter et al. NC</td>\n",
+       "      <td>Ab initio-inspired (INS fit)</td>\n",
+       "      <td>-0.50</td>\n",
+       "      <td>-5.00</td>\n",
+       "      <td>2.50</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.5000</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Wu et al.</td>\n",
+       "      <td>THz spectroscopy fit</td>\n",
+       "      <td>-0.35</td>\n",
+       "      <td>-2.80</td>\n",
+       "      <td>2.40</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.3400</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Cookmeyer and Moore</td>\n",
+       "      <td>Magnon thermal Hall (sign)</td>\n",
+       "      <td>-0.50</td>\n",
+       "      <td>-5.00</td>\n",
+       "      <td>2.50</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.1125</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Kim and Kee</td>\n",
+       "      <td>DFT + t=U expansion</td>\n",
+       "      <td>-1.53</td>\n",
+       "      <td>-6.55</td>\n",
+       "      <td>5.25</td>\n",
+       "      <td>-0.95</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Suzuki and Suga</td>\n",
+       "      <td>Magnetic specific heat</td>\n",
+       "      <td>-1.53</td>\n",
+       "      <td>-24.40</td>\n",
+       "      <td>5.25</td>\n",
+       "      <td>-0.95</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>Yadav et al.</td>\n",
+       "      <td>Quantum chemistry (MRCI)</td>\n",
+       "      <td>1.20</td>\n",
+       "      <td>-5.60</td>\n",
+       "      <td>1.20</td>\n",
+       "      <td>-0.70</td>\n",
+       "      <td>0.25</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.2500</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>Ran et al.</td>\n",
+       "      <td>Spin wave fit to INS gap</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>-6.80</td>\n",
+       "      <td>9.50</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>Hou et al.</td>\n",
+       "      <td>Constrained DFT + U</td>\n",
+       "      <td>-1.87</td>\n",
+       "      <td>-10.70</td>\n",
+       "      <td>3.80</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>1.2700</td>\n",
+       "      <td>0.63</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>Wang et al.</td>\n",
+       "      <td>DFT + t=U expansion</td>\n",
+       "      <td>-0.30</td>\n",
+       "      <td>-10.90</td>\n",
+       "      <td>6.10</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0300</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>Eichstaedt et al.</td>\n",
+       "      <td>Fully ab initio (DFT + cRPA + t=U)</td>\n",
+       "      <td>-1.40</td>\n",
+       "      <td>-14.30</td>\n",
+       "      <td>9.80</td>\n",
+       "      <td>-2.23</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>-0.63</td>\n",
+       "      <td>1.0000</td>\n",
+       "      <td>0.03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>Eichstaedt et al.</td>\n",
+       "      <td>Neglecting non-local Coulomb</td>\n",
+       "      <td>-0.20</td>\n",
+       "      <td>-4.50</td>\n",
+       "      <td>3.00</td>\n",
+       "      <td>-0.73</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>-0.33</td>\n",
+       "      <td>0.7000</td>\n",
+       "      <td>0.10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>Eichstaedt et al.</td>\n",
+       "      <td>Neglecting non-local SOC</td>\n",
+       "      <td>-1.30</td>\n",
+       "      <td>-13.30</td>\n",
+       "      <td>9.40</td>\n",
+       "      <td>-2.30</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>-0.67</td>\n",
+       "      <td>1.0000</td>\n",
+       "      <td>0.10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>Banerjee et al.</td>\n",
+       "      <td>Spin wave fit</td>\n",
+       "      <td>-4.60</td>\n",
+       "      <td>7.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>Kim et al.</td>\n",
+       "      <td>DFT + t=U expansion</td>\n",
+       "      <td>-12.00</td>\n",
+       "      <td>17.00</td>\n",
+       "      <td>12.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>Kim and Kee</td>\n",
+       "      <td>DFT + t=U expansion</td>\n",
+       "      <td>-3.50</td>\n",
+       "      <td>4.60</td>\n",
+       "      <td>6.42</td>\n",
+       "      <td>-0.04</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>Winter et al.</td>\n",
+       "      <td>Ab initio (DFT + exact diag.)</td>\n",
+       "      <td>-5.50</td>\n",
+       "      <td>7.60</td>\n",
+       "      <td>8.40</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>2.3000</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>Ozel et al.</td>\n",
+       "      <td>Spin wave fit/THz spectroscopy</td>\n",
+       "      <td>-0.95</td>\n",
+       "      <td>1.15</td>\n",
+       "      <td>3.80</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>Ozel et al.</td>\n",
+       "      <td>Spin wave fit/THz spectroscopy</td>\n",
+       "      <td>0.46</td>\n",
+       "      <td>-3.50</td>\n",
+       "      <td>2.35</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              reference                              method     J1     K1  \\\n",
+       "0     Winter et al. PRB       Ab initio (DFT + exact diag.)  -1.70  -6.70   \n",
+       "1      Winter et al. NC        Ab initio-inspired (INS fit)  -0.50  -5.00   \n",
+       "2             Wu et al.                THz spectroscopy fit  -0.35  -2.80   \n",
+       "3   Cookmeyer and Moore          Magnon thermal Hall (sign)  -0.50  -5.00   \n",
+       "4           Kim and Kee                 DFT + t=U expansion  -1.53  -6.55   \n",
+       "5       Suzuki and Suga              Magnetic specific heat  -1.53 -24.40   \n",
+       "6          Yadav et al.            Quantum chemistry (MRCI)   1.20  -5.60   \n",
+       "7            Ran et al.            Spin wave fit to INS gap   0.00  -6.80   \n",
+       "8            Hou et al.                 Constrained DFT + U  -1.87 -10.70   \n",
+       "9           Wang et al.                 DFT + t=U expansion  -0.30 -10.90   \n",
+       "10    Eichstaedt et al.  Fully ab initio (DFT + cRPA + t=U)  -1.40 -14.30   \n",
+       "11    Eichstaedt et al.        Neglecting non-local Coulomb  -0.20  -4.50   \n",
+       "12    Eichstaedt et al.            Neglecting non-local SOC  -1.30 -13.30   \n",
+       "13      Banerjee et al.                       Spin wave fit  -4.60   7.00   \n",
+       "14           Kim et al.                 DFT + t=U expansion -12.00  17.00   \n",
+       "15          Kim and Kee                 DFT + t=U expansion  -3.50   4.60   \n",
+       "16        Winter et al.       Ab initio (DFT + exact diag.)  -5.50   7.60   \n",
+       "17          Ozel et al.      Spin wave fit/THz spectroscopy  -0.95   1.15   \n",
+       "18          Ozel et al.      Spin wave fit/THz spectroscopy   0.46  -3.50   \n",
+       "\n",
+       "     Gam1  Gam_prime1    J2    K2      J3    K3  \n",
+       "0    6.60       -0.90  0.00  0.00  2.7000  0.00  \n",
+       "1    2.50        0.00  0.00  0.00  0.5000  0.00  \n",
+       "2    2.40        0.00  0.00  0.00  0.3400  0.00  \n",
+       "3    2.50        0.00  0.00  0.00  0.1125  0.00  \n",
+       "4    5.25       -0.95  0.00  0.00  0.0000  0.00  \n",
+       "5    5.25       -0.95  0.00  0.00  0.0000  0.00  \n",
+       "6    1.20       -0.70  0.25  0.00  0.2500  0.00  \n",
+       "7    9.50        0.00  0.00  0.00  0.0000  0.00  \n",
+       "8    3.80        0.00  0.00  0.00  1.2700  0.63  \n",
+       "9    6.10        0.00  0.00  0.00  0.0300  0.00  \n",
+       "10   9.80       -2.23  0.00 -0.63  1.0000  0.03  \n",
+       "11   3.00       -0.73  0.00 -0.33  0.7000  0.10  \n",
+       "12   9.40       -2.30  0.00 -0.67  1.0000  0.10  \n",
+       "13   0.00        0.00  0.00  0.00  0.0000  0.00  \n",
+       "14  12.00        0.00  0.00  0.00  0.0000  0.00  \n",
+       "15   6.42       -0.04  0.00  0.00  0.0000  0.00  \n",
+       "16   8.40        0.20  0.00  0.00  2.3000  0.00  \n",
+       "17   3.80        0.00  0.00  0.00  0.0000  0.00  \n",
+       "18   2.35        0.00  0.00  0.00  0.0000  0.00  "
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rucl_references = [\"Winter et al. PRB\", \"Winter et al. NC\", \"Wu et al.\", \"Cookmeyer and Moore\", \"Kim and Kee\", \"Suzuki and Suga\", \n",
+    "              \"Yadav et al.\", \"Ran et al.\", \"Hou et al.\", \"Wang et al.\", \"Eichstaedt et al.\", \"Eichstaedt et al.\", \n",
+    "              \"Eichstaedt et al.\", \"Banerjee et al.\", \"Kim et al.\", \"Kim and Kee\", \"Winter et al.\", \"Ozel et al.\", \"Ozel et al.\"]\n",
+    "\n",
+    "rucl_methods = [\"Ab initio (DFT + exact diag.)\", \"Ab initio-inspired (INS fit)\", \"THz spectroscopy fit\",\n",
+    "                \"Magnon thermal Hall (sign)\", \"DFT + t=U expansion\", \"Magnetic specific heat\", \"Quantum chemistry (MRCI)\",\n",
+    "                \"Spin wave fit to INS gap\", \"Constrained DFT + U\", \"DFT + t=U expansion\", \"Fully ab initio (DFT + cRPA + t=U)\",\n",
+    "                \"Neglecting non-local Coulomb\", \"Neglecting non-local SOC\", \"Spin wave fit\", \"DFT + t=U expansion\",\n",
+    "                \"DFT + t=U expansion\", \"Ab initio (DFT + exact diag.)\", \"Spin wave fit/THz spectroscopy\", \"Spin wave fit/THz spectroscopy\"]\n",
+    "\n",
+    "rucl_J1 = [-1.7, -0.5, -0.35, -0.5, -1.53, -1.53, 1.2, 0, -1.87, -0.3, -1.4, -0.2, -1.3, -4.6, -12, -3.5, -5.5, -0.95, 0.46]\n",
+    "rucl_K1 = [-6.7, -5.0, -2.8, -5.0, -6.55, -24.4, -5.6, -6.8, -10.7, -10.9, -14.3, -4.5, -13.3, 7.0, 17., 4.6, 7.6, 1.15, -3.5]\n",
+    "rucl_Gam1 = [6.6, 2.5, 2.4, 2.5, 5.25, 5.25, 1.2, 9.5, 3.8, 6.1, 9.8, 3.0, 9.4, 0, 12., 6.42, 8.4, 3.8, 2.35]\n",
+    "rucl_Gam_prime1 = [-0.9, 0, 0, 0, -0.95, -0.95, -0.7, 0, 0, 0, -2.23, -0.73, -2.3, 0, 0, -0.04, 0.2, 0, 0]\n",
+    "rucl_J2 = [0, 0, 0, 0, 0, 0, 0.25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
+    "rucl_K2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.63, -0.33, -0.67, 0, 0, 0, 0, 0, 0]\n",
+    "rucl_J3 = [2.7, 0.5, 0.34, 0.1125, 0, 0, 0.25, 0, 1.27, 0.03, 1.0, 0.7, 1.0, 0, 0, 0, 2.3, 0, 0]\n",
+    "rucl_K3 = [0, 0, 0, 0, 0, 0, 0, 0, 0.63, 0, 0.03, 0.1, 0.1, 0, 0, 0, 0, 0, 0]\n",
+    "\n",
+    "d_rucl = {'reference': rucl_references, 'method': rucl_methods, 'J1': rucl_J1, 'K1': rucl_K1,\n",
+    "          'Gam1': rucl_Gam1, 'Gam_prime1': rucl_Gam_prime1,\n",
+    "          'J2': rucl_J2, 'K2': rucl_K2, 'J3': rucl_J3, 'K3': rucl_K3}\n",
+    "df_rucl = pd.DataFrame(d_rucl)\n",
+    "df_rucl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "21f84759-41b2-4ba7-9e86-a87268967dee",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "def nx_rucl_terms(g, data_series):\n",
+    "    H = []\n",
+    "    n = len(g.nodes)\n",
+    "    for (n1,n2,d) in g.edges(data=True):\n",
+    "        label = d['label'][0]\n",
+    "        distance = int(d['label'][1])\n",
+    "        \n",
+    "        #Heisenberg and Kitaev terms\n",
+    "        if distance == 1:\n",
+    "            weight_J = data_series.J1\n",
+    "        elif distance == 2:\n",
+    "            weight_J = data_series.J2\n",
+    "        else:\n",
+    "            weight_J = data_series.J3\n",
+    "        \n",
+    "        if distance == 1:\n",
+    "            weight_K = data_series.K1\n",
+    "        elif distance == 2:\n",
+    "            weight_K = data_series.K2\n",
+    "        else:\n",
+    "            weight_K = data_series.K3\n",
+    "        \n",
+    "        if not (weight_J == 0 and weight_K == 0):\n",
+    "            string_x = n*'I' \n",
+    "            string_y = n*'I' \n",
+    "            string_z = n*'I'\n",
+    "            \n",
+    "            weight_x = weight_J\n",
+    "            weight_y = weight_J\n",
+    "            weight_z = weight_J\n",
+    "            for i in [n1,n2]:\n",
+    "                string_x = string_x[:i] + 'X' + string_x[i+1:]\n",
+    "                string_y = string_y[:i] + 'Y' + string_y[i+1:]\n",
+    "                string_z = string_z[:i] + 'Z' + string_z[i+1:]\n",
+    "            if label == 'X':\n",
+    "                weight_x += weight_K\n",
+    "            elif label == 'Y':\n",
+    "                weight_y += weight_K\n",
+    "            else:\n",
+    "                weight_z += weight_K\n",
+    "            if weight_x != 0:\n",
+    "                H.append((string_x, weight_x))\n",
+    "            if weight_y != 0:\n",
+    "                H.append((string_y, weight_y))\n",
+    "            if weight_z != 0:\n",
+    "                H.append((string_z, weight_z))\n",
+    "            \n",
+    "        #Gamma Terms\n",
+    "        if distance == 1 and data_series.Gam1 != 0:\n",
+    "            string_gam1_1 = n*'I'\n",
+    "            string_gam1_2 = n*'I'\n",
+    "            #unwrapping loop since there is no ordering guarantee\n",
+    "            labels=['X', 'Y', 'Z']\n",
+    "            labels.remove(label)\n",
+    "            l1,l2 = labels\n",
+    "            string_gam1_1 = string_gam1_1[:n1] + l1 + string_gam1_1[n1+1:]\n",
+    "            string_gam1_1 = string_gam1_1[:n2] + l2 + string_gam1_1[n2+1:]\n",
+    "            \n",
+    "            string_gam1_2 = string_gam1_2[:n1] + l2 + string_gam1_2[n1+1:]\n",
+    "            string_gam1_2 = string_gam1_2[:n2] + l1 + string_gam1_2[n2+1:]\n",
+    "            \n",
+    "            H.append((string_gam1_1, data_series.Gam1))\n",
+    "            H.append((string_gam1_2, data_series.Gam1))\n",
+    "            \n",
+    "        #Gamma' Terms\n",
+    "        if distance == 1 and data_series.Gam_prime1 != 0:\n",
+    "            #unwrapping inner loop since there is no ordering guarantee\n",
+    "            labels=['X', 'Y', 'Z']\n",
+    "            labels.remove(label)\n",
+    "            for label_offset in labels:\n",
+    "                string_gam1_1 = n*'I'\n",
+    "                string_gam1_2 = n*'I'\n",
+    "                l1 = label\n",
+    "                l2 = label_offset\n",
+    "                \n",
+    "                string_gam1_1 = string_gam1_1[:n1] + l1 + string_gam1_1[n1+1:]\n",
+    "                string_gam1_1 = string_gam1_1[:n2] + l2 + string_gam1_1[n2+1:]\n",
+    "                string_gam1_2 = string_gam1_2[:n1] + l2 + string_gam1_2[n1+1:]\n",
+    "                string_gam1_2 = string_gam1_2[:n2] + l1 + string_gam1_2[n2+1:]\n",
+    "                H.append((string_gam1_1, data_series.Gam_prime1))\n",
+    "                H.append((string_gam1_2, data_series.Gam_prime1))\n",
+    "    return H\n",
+    "\n",
+    "def generate_time_varying_terms(g, s, x = lambda s: 0, y = lambda s: 0, z = lambda s: 0):\n",
+    "    assert callable(x)\n",
+    "    assert callable(y)\n",
+    "    assert callable(z)\n",
+    "    \n",
+    "    weight_x, weight_y, weight_z = x(s), y(s), z(s)\n",
+    "    n = len(g)\n",
+    "    H = []\n",
+    "    if not (weight_x == 0):\n",
+    "        for node in g.nodes:\n",
+    "            string_x = n*'I'\n",
+    "            string_x = string_x[:node] + 'X' + string_x[node+1:]\n",
+    "            H.append((string_x, weight_x))\n",
+    "    if not (weight_y == 0):\n",
+    "        for node in g.nodes:\n",
+    "            string_y = n*'I'\n",
+    "            string_y = string_y[:node] + 'y' + string_y[node+1:]\n",
+    "            H.append((string_y, weight_y))\n",
+    "    if not (weight_z == 0):\n",
+    "        for node in g.nodes:\n",
+    "            string_z = n*'I'\n",
+    "            string_z = string_z[:node] + 'z' + string_z[node+1:]\n",
+    "            H.append((string_z, weight_z))\n",
+    "    return H\n",
+    "\n",
+    "#using normalized time s = t_current / t_total to allow for more variation of total time\n",
+    "def generate_rucl_hamiltonian(lattice_size, data_series, s=0, field_x=lambda s: 0, field_y=lambda s: 0, field_z=lambda s: 0):\n",
+    "    g = hexagonal_lattice_graph(lattice_size,lattice_size)\n",
+    "    assign_hexagon_labels_rucl(g)\n",
+    "    g = flatten_nx_graph(g)\n",
+    "    H_constant = nx_rucl_terms(g, data_series)\n",
+    "    H_time_varied = generate_time_varying_terms(g, s, x=field_x, y = field_y, z = field_z)\n",
+    "    H = H_constant + H_time_varied\n",
+    "    return H"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "6be24969-cd04-435b-a3ce-5bead1bd680d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Estimating RuCl row 13 using Trotterization\n",
+      "  Time to estimate Number of steps required: 14.89695408300031 seconds\n",
+      "  Time to find term ordering: 0.021428124979138374 seconds\n",
+      "  Time to generate trotter circuit from openfermion: 1.0419171303510666e-06 seconds\n",
+      "  Time to decompose trotter to Clifford + T: 87.22412741708104 seconds\n",
+      "  Time to enumerate resource estimates: 7.514046208932996 seconds\n",
+      "Total time to estimate RuCl row 13: 146.24839045794215 seconds\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#Commenting out range, to avoid long runtimes.  This still takes ~20-30 minutes as written\n",
+    "for i in [13]:\n",
+    "#for i in range(19):\n",
+    "    #defining precision required for the trotterized circuit\n",
+    "    energy_precision = 1e-3\n",
+    "\n",
+    "    figdir=\"Trotter/Figures/\"\n",
+    "    if not os.path.exists(figdir):\n",
+    "        os.makedirs(figdir)\n",
+    "    widthdir = \"Trotter/Widths/\"\n",
+    "    if not os.path.exists(widthdir):\n",
+    "        os.makedirs(widthdir)\n",
+    "\n",
+    "    timesteps=1000\n",
+    "    H_rucl = generate_rucl_hamiltonian(32, df_rucl.iloc[i])\n",
+    "    H_rucl_pyliqtr = pyH(H_rucl)\n",
+    "    openfermion_hamiltonian_rucl = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_rucl_pyliqtr)\n",
+    "    \n",
+    "    print(\"Estimating RuCl row \" + str(i) + \" using Trotterization\")\n",
+    "    t0 = time.perf_counter()\n",
+    "    cpt_trotter_rucl = estimate_trotter(openfermion_hamiltonian_rucl, timesteps, energy_precision, \"Trotter/RuCl_circuits/\", hamiltonian_name=\"rucl_\" + str(i), write_circuits=True)\n",
+    "    t1 = time.perf_counter()\n",
+    "    elapsed = t1 - t0\n",
+    "    print(\"Total time to estimate RuCl row \" + str(i) + \": \" + str(elapsed) + \" seconds\\n\")\n",
+    "    \n",
+    "    plot_histogram(cpt_trotter_rucl,\n",
+    "                   f'trotter RuCl, row{i}',\n",
+    "                   figdir,\n",
+    "                   widthdir,\n",
+    "                   0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "fc6129fc-d5d5-465b-b686-4085883228f6",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Estimating RuCl row 13 using QSP\n",
+      "  Time to generate high level QSP circuit: 96.58290741604287 seconds\n",
+      "    Time to decompose high level cirq.ops.pauli_gates._PauliX circuit: 0.00010220904368907213 seconds\n",
+      "    Time to transform decomposed cirq.ops.pauli_gates._PauliX circuit to Clifford+T: 2.1459069103002548e-05 seconds\n",
+      "    Time to decompose high level cirq.ops.common_gates.Rx circuit: 5.8333040215075016e-05 seconds\n",
+      "    Time to transform decomposed cirq.ops.common_gates.Rx circuit to Clifford+T: 0.006496042013168335 seconds\n",
+      "    Time to decompose high level pyLIQTR.circuits.operators.hamiltonian_encodings.UnitaryBlockEncode circuit: 0.4555914159864187 seconds\n",
+      "    Time to transform decomposed pyLIQTR.circuits.operators.hamiltonian_encodings.UnitaryBlockEncode circuit to Clifford+T: 114.45711995789316 seconds\n",
+      "    Time to decompose high level cirq.ops.common_gates.Ry circuit: 0.0047991249011829495 seconds\n",
+      "    Time to transform decomposed cirq.ops.common_gates.Ry circuit to Clifford+T: 0.4593636669451371 seconds\n",
+      "    Time to decompose high level cirq.ops.raw_types._InverseCompositeGate circuit: 11.808722625020891 seconds\n",
+      "    Time to transform decomposed cirq.ops.raw_types._InverseCompositeGate circuit to Clifford+T: 122.48608425003476 seconds\n",
+      "    Time to decompose high level pyLIQTR.circuits.operators.reflect.Reflect circuit: 0.016667624935507774 seconds\n",
+      "    Time to transform decomposed pyLIQTR.circuits.operators.reflect.Reflect circuit to Clifford+T: 0.5113535419804975 seconds\n",
+      "Time to estimate RuCl row 13: 384.14998012501746 seconds\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Commenting out range, to avoid long runtimes.  This still takes ~20-30 minutes as written\n",
+    "for i in [13]:\n",
+    "#for i in range(19):\n",
+    "    #defining precision required for the trotterized circuit\n",
+    "    energy_precision = 1e-3\n",
+    "    figdir=\"QSP/Figures/\"\n",
+    "    if not os.path.exists(figdir):\n",
+    "        os.makedirs(figdir)\n",
+    "    widthdir = \"QSP/Widths/\"\n",
+    "    if not os.path.exists(widthdir):\n",
+    "        os.makedirs(widthdir)\n",
+    "    timesteps=1000\n",
+    "    H_rucl = generate_rucl_hamiltonian(32, df_rucl.iloc[i])\n",
+    "    H_rucl_pyliqtr = pyH(H_rucl)\n",
+    "    \n",
+    "    print(\"Estimating RuCl row \" + str(i) + \" using QSP\")\n",
+    "    t0 = time.perf_counter()\n",
+    "    #change to Clifford+T dictionary in future revision\n",
+    "    qsp_high_level_rucl = estimate_qsp(H_rucl_pyliqtr, timesteps, energy_precision, \"QSP/RuCl_circuits/\", hamiltonian_name=\"rucl_\" + str(i))\n",
+    "    t1 = time.perf_counter()\n",
+    "    elapsed = t1 - t0\n",
+    "    print(\"Time to estimate RuCl row \" + str(i) + \": \" + str(elapsed) + \" seconds\\n\")\n",
+    "    print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "2ff5148f-2d2a-41c8-b71c-a787f82f8d32",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total time to run notebook (only using the fastest row): 533.9890611250885\n"
+     ]
+    }
+   ],
+   "source": [
+    "t_end = time.perf_counter()\n",
+    "print(\"Total time to run notebook (only using the fastest row): \" + str(t_end - t_init))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09c39464-1b86-4369-8f06-b12f4db46772",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/qca/utils/hamiltonian_utils.py b/src/qca/utils/hamiltonian_utils.py
index 904c909..2da67e8 100644
--- a/src/qca/utils/hamiltonian_utils.py
+++ b/src/qca/utils/hamiltonian_utils.py
@@ -188,7 +188,7 @@ def pyliqtr_hamiltonian_to_openfermion_qubit_operator(H:Hamiltonian) -> QubitOpe
             open_fermion_operator += term[1] * open_fermion_term_op
     return open_fermion_operator
 
-def assign_hexagon_labels(graph:Graph):
+def assign_hexagon_labels(graph:Graph, x:str='X', y:str='Y', z:str='Z'):
     for n1, n2 in graph.edges:
         # start by making sure that the edges are ordered correctly
         r1,c1 = n1
@@ -200,12 +200,12 @@ def assign_hexagon_labels(graph:Graph):
         # now that they are ordered correctly, we can assign labels
         label = ''
         if c1 == c2:
-            label = 'Z'
+            label = z
         # You can differentiate X and Y labels based off nx's node label parity
         elif (((r1 % 2) + (c1 % 2)) % 2 == 0):
-            label = 'Y'
+            label = y
         else:
-            label = 'X'
+            label = x
         
         graph[n1][n2]['label'] = label