Trimer_Schrieffer_Wolff_Transformation.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Schrieffer Wolff Transformation for a triple quantum dot\n",
        "\n",
        "\n",
        "We carry out the second order BW perturbation theory for a quantum dot with 3 spinful orbitals."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "Bibn2U0yMqlK"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from MesoPack.MesoPack import InitHam, Operators, SuperBlockDiagonalization, SuperBlockOperator\n",
        "import itertools as it\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "11CkqVlxIPTo"
      },
      "outputs": [],
      "source": [
        "def bin_decomp(x):\n",
        "    #x += 4\n",
        "    x1 = x//2\n",
        "    x2 = int(2*(x/2-x//2))\n",
        "    return (x1,x2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {},
      "outputs": [],
      "source": [
        "def fermi_parent(T):\n",
        "    def fermi(x):\n",
        "        return 1./(1+np.exp(x/T))\n",
        "    return fermi"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "7GvRVYu3IPTr",
        "outputId": "0601a2b8-8667-46cb-a6b1-a5dc56b2375a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "overlap:  0.0\n",
            "overlap:  0.0\n"
          ]
        }
      ],
      "source": [
        "# pauli matrices\n",
        "PMx = np.array([[0.,1.],[1.,0.]])\n",
        "PMy = np.array([[0.,-1.j],[1.j,0.]])\n",
        "PMz = np.array([[1.,0.],[0.,-1.]])\n",
        "delta = np.array([[1.,0.],[0.,1.]])\n",
        "pli = [PMx,PMy,PMz,delta]\n",
        "\n",
        "# pauli tensor\n",
        "pauli_tensor = np.zeros((2,2,2,2),dtype=complex)\n",
        "delta_tensor  = np.zeros((2,2,2,2),dtype=complex)\n",
        "for n in range(3):\n",
        "    for (a,b,c,d) in it.product([0,1], repeat=4):\n",
        "        pauli_tensor[a,b,c,d] += pli[n][a,b]*pli[n][c,d]\n",
        "        if n == 0: delta_tensor[a,b,c,d] += delta[a,b]*delta[c,d]\n",
        "\n",
        "# test overlap\n",
        "trace = 0.\n",
        "n1 = 0\n",
        "n2 = 2\n",
        "for (a,b,c,d) in it.product([0,1], repeat=4):\n",
        "    trace += pli[n1][a,b]*pli[n1][c,d]*pli[n2][a,b]*pli[n2][c,d]\n",
        "print(\"overlap: \",trace)\n",
        "trace = 0.\n",
        "n2 = 2\n",
        "for (a,b,c,d) in it.product([0,1], repeat=4):\n",
        "    trace += delta[a,b]*delta[c,d]*pli[n2][a,b]*pli[n2][c,d]\n",
        "print(\"overlap: \",trace)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U2NCDJe1IPTr"
      },
      "source": [
        "## Hamiltonian\n",
        "\n",
        "Here we consider the TQD model $\\hat{H}=\\hat{H}_{\\rm leads}+\\hat{H}_{\\rm TQD}+\\hat{H}_{\\rm hyb}$, with\n",
        "$$\n",
        "\\hat{H}_{\\rm TQD} = \\sum_{j=1,2,3} \\left ( \\epsilon_j \\hat{n}_j + U_j \\hat{n}_{j\\uparrow}\\hat{n}_{j\\downarrow} \\right )  + %\\\\ \n",
        "\\sum_{i\\ne j} \\left (U_{ij}'\\hat{n}_i\\hat{n}_j   + \\sum_{\\sigma} t_{ij}^{\\phantom{\\dagger}} \\hat{d}^{\\dagger}_{i\\sigma}\\hat{d}^{\\phantom{\\dagger}}_{j\\sigma} \\right) \\;,\n",
        "$$\n",
        "where $\\hat{n}_j=\\sum_{\\sigma}\\hat{n}_{j\\sigma}$, and the inter-dot tunnelling matrix elements satisfy $t_{ij}=t_{ji}^*$. We take for simplicity equivalent dots with $\\epsilon_j\\equiv \\epsilon$, $U_j\\equiv U$, $U'_{ij}\\equiv U'$, and consider the mirror symmetric case $t_{12}=t_{13}\\equiv t$ but $t_{23}\\equiv t'$. We consider the following TQD-lead hybridization,\n",
        "$$\n",
        "\t\t\\hat{H}_{\\rm hyb} = \\sum_{\\sigma} \\left (V_s^{\\phantom{\\dagger}} \\hat{d}^{\\dagger}_{2\\sigma}\\hat{c}_{s\\sigma}^{\\phantom{\\dagger}}+V_d^{\\phantom{\\dagger}} \\hat{d}^{\\dagger}_{3\\sigma}\\hat{c}_{d\\sigma}^{\\phantom{\\dagger}} + h.c.\\right ) \\;.\n",
        "$$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The Hilbert space of dimension  64  is initialized\n"
          ]
        }
      ],
      "source": [
        "U = .5\n",
        "V = 0.05\n",
        "t = -U/(2*np.pi)\n",
        "N = 3\n",
        "DOF = [4 for _ in range(N)]\n",
        "bDOF = [35 for _ in range(1)]\n",
        "\n",
        "p = {}\n",
        "# [(\"hubbard-U\",1),(\"extended-hubbard-U\",1),(\"epsilon\",1),(\"hopping\",1),(\"magfield\",1),(\"spin-spin\",2)]\n",
        "# the epsilon and U are to follow the order of the DOF\n",
        "p[\"hubbard-U\"] = np.array([U for _ in range(N)])\n",
        "p[\"extended-hubbard-U\"] = np.array([0.*U for _ in range(N)]) \n",
        "p[\"epsilon\"] = np.array([ 0. for _ in range(N)]) \n",
        "# the J and hopping are to follow the order of the bonds\n",
        "p[\"spin-spin\"] = np.array([[0.,0.] for _ in range(N)])\n",
        "p[\"hopping\"] = np.array([t,t,t])\n",
        "# creating the Hamiltonain class\n",
        "H = InitHam(DOF,bonds = [[1,0],[0,2],[1,2]])#,boundary_condition=bc_set)#,boson_DOF = bDOF)\n",
        "ham = H.getH(p)\n",
        "# for adjusting the \n",
        "# get the neutral hamiltonian matrix\n",
        "ham_neutral = H.getH(p)\n",
        "q = {}\n",
        "# get the chemical potential matrix\n",
        "q[\"epsilon\"] = np.array([1. for i in range(N)]) #-.15\n",
        "n_all = H.getH(q)\n",
        "q = {}\n",
        "# get the magnetization matrix\n",
        "q[\"spin-spin\"] = np.array([[1.,0.] for _ in range(N)])\n",
        "sz_all = H.getH(q)\n",
        "#print(ham.GetMat(0,False))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We diagonalize the Hamiltonian in a broad gate voltage range to determien how the filling numbers in a certain voltage range."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n",
            "Operators were summed\n"
          ]
        }
      ],
      "source": [
        "eps_set = np.linspace(-1,0,100)\n",
        "temp_set = np.logspace(-10,0,2)\n",
        "occupation = np.zeros((100,2))\n",
        "magnetization = np.zeros((100,2))\n",
        "degeneracy = np.zeros(100)\n",
        "for i,eps in enumerate(eps_set):\n",
        "    eps_ham = n_all.copy()\n",
        "    eps_ham.ScalarDot(eps)\n",
        "    eps_ham.OperatorSum(ham)\n",
        "    # diagonalize \n",
        "    a, b = eps_ham.Diagonalize(False,verbosity=0)\n",
        "    # count degeneracy\n",
        "    # initial bad guess for GS eneergy\n",
        "    GS_temp_en = 10.\n",
        "    # collect degenerate ground state qunatum numbers\n",
        "    GS_QNset = []\n",
        "    # tollerance to ground state energy fro GS set\n",
        "    GS_tollerance = 1e-2\n",
        "    for j,en in enumerate(a):\n",
        "        # creating a set containing the ground state quantum numbers\n",
        "        if en[1][0] < GS_temp_en-GS_tollerance:\n",
        "            GS_temp_en = en[1][0]\n",
        "            GS_QNset = [en[0]]\n",
        "        elif en[1][0]  < GS_temp_en+GS_tollerance and en[1][0]  > GS_temp_en-GS_tollerance:\n",
        "            GS_QNset += [en[0]]\n",
        "    # print(\"GS quantum numbers: \",GS_QNset,\"\\n\")\n",
        "    degeneracy[i] = len(GS_QNset)\n",
        "    # loop over tempearture\n",
        "    for tind,temp in enumerate(temp_set):\n",
        "        # setting the fermi function\n",
        "        fd = fermi_parent(temp)\n",
        "        # impurity partition function\n",
        "        Z0 = sum([np.sum(np.exp(-x[1]/temp)) for x in a])\n",
        "        # compute occupation\n",
        "        occupation[i,tind] = sum([np.sum(np.diag(n_all.BraKetDot(x,x)[1])*np.exp(-y[1]/temp)/Z0) for x,y in zip(b,a)])\n",
        "        magnetization[i,tind] = sum([np.sum(np.diag(sz_all.BraKetDot(x,x)[1])*np.exp(-y[1]/temp)/Z0) for x,y in zip(b,a)])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'occupation')"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(eps_set,occupation[:,0])\n",
        "plt.xlabel(\"gate voltage\")\n",
        "plt.ylabel(\"occupation\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BhL1DxRmIPTt"
      },
      "source": [
        "### Parity and cration-/anihilation operators"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "Euvvr56tMqlQ",
        "outputId": "b8e710e9-68ab-4bac-cd3c-bcedff5dee65"
      },
      "outputs": [],
      "source": [
        "# #####################\n",
        "# # initializing operators\n",
        "# #####################\n",
        "# # initializing the observables\n",
        "SysObs = Operators(H)\n",
        "# # constructing the observables\n",
        "# # for the source lead\n",
        "cd_0_up = SysObs.creation(0,\"up\")\n",
        "c_0_up = SysObs.anihilation(0,\"up\")\n",
        "cd_0_do = SysObs.creation(0,\"down\")\n",
        "c_0_do = SysObs.anihilation(0,\"down\")\n",
        "# for the source lead\n",
        "cd_2_up = SysObs.creation(N-1,\"up\")\n",
        "c_2_up = SysObs.anihilation(N-1,\"up\")\n",
        "cd_2_do = SysObs.creation(N-1,\"down\")\n",
        "c_2_do = SysObs.anihilation(N-1,\"down\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "mJkb9OGXIPTu"
      },
      "outputs": [],
      "source": [
        "#####\n",
        "# total SU(2) spin symmetry\n",
        "#####\n",
        "Stot = SysObs.Stot()\n",
        "#####\n",
        "# parity symmetry\n",
        "#####\n",
        "# parity dictionary: \n",
        "# 0 <-> 1 can be flipped\n",
        "par_dict = {1:2}\n",
        "#parity operator\n",
        "parity = SysObs.Parity(par_dict)\n",
        "test_par = []\n",
        "for i,j in enumerate(H.qnind):\n",
        "    test_par += [parity.GetMat(i,False)]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Test commutation\n",
        "\n",
        "We test if the parity symmetry and the Hamiltonian commute"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "all commutes\n"
          ]
        }
      ],
      "source": [
        "test_ham = []\n",
        "for j,i in enumerate(H.qnind):\n",
        "    test_ham += [ham.GetMat(j,False)]\n",
        "\n",
        "noerror = True\n",
        "for j,i in enumerate(H.qnind):\n",
        "    A = np.dot(test_ham[j],test_par[j])\n",
        "    B = np.dot(test_par[j],test_ham[j])\n",
        "    if abs(np.max(abs((A-B).flatten()))) > 0.:\n",
        "        print(i,\" does not commute\")\n",
        "        noerror = False\n",
        "if noerror:\n",
        "    print(\"all commutes\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EQc8MsJLIPTu"
      },
      "source": [
        "## Diagonalization\n",
        "\n",
        "Check the degeneracy in the selected voltage range to determine the appropriate Schrieffer Wolff Transformation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "LC2fgTZEIPTu",
        "outputId": "21027500-f737-424a-84ce-b84268f9f802"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "-0.4\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "-0.30000000000000004\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "-0.2\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n"
          ]
        }
      ],
      "source": [
        "n_points = 3\n",
        "eps_set = np.linspace(-0.4,-0.2,n_points)#np.linspace(-43,-36,n_points)\n",
        "degeneracy = np.zeros(n_points)\n",
        "list_GS_QNset = []\n",
        "for i,eps in enumerate(eps_set):\n",
        "    print(eps)\n",
        "    eps_ham = n_all.copy()\n",
        "    eps_ham.ScalarDot(eps)\n",
        "    eps_ham.OperatorSum(ham)\n",
        "    # diagonalize\n",
        "    _,_,_,GS_QNset = SuperBlockDiagonalization([parity,Stot],eps_ham,BlockOperator=False)\n",
        "    #par_ham_val,par_ham_vec,new_ham_qn_dict,GS_QNset = BlockDiagonalization(Pval,Pvec,eps_ham)\n",
        "    # collect degenerate ground state qunatum\n",
        "    degeneracy[i] = len(GS_QNset)\n",
        "    list_GS_QNset += [GS_QNset]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "n4DXlOrQIPTu",
        "outputId": "96daf158-442b-470f-e1be-6e644ace7ebd"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'ground state degeneracy')"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGtCAYAAAAbNg6bAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAArwklEQVR4nO3dz24bV4Lv8R+dnivMBSKW6F2jhY5L0eZuZpp/HmAiMlmnQ0ov0CLb2x5HDGdxBzOLYajkAUJmXsBi2b2eUcm9b0rVzmY2NssBDGRnskQvBsJFh3chsEa0SIlFk6J49P0ABMiqYtU5Lpf586lz6sT6/X5fAAAABrm36AIAAADMGgEHAAAYh4ADAACMQ8ABAADGIeAAAADjEHAAAIBxCDgAAMA4BBwAAGCcXyy6AIvw888/66efftKHH36oWCy26OIAAIAJ9Pt9vX37Vr/85S91797VbTR3MuD89NNPWl9fX3QxAADAFF6/fq1f/epXV25zJwPOhx9+KOn8D2h1dXXBpQEAAJPo9XpaX18Pf8evcicDzuC21OrqKgEHAIAlM0n3EjoZAwAA4xBwAACAcQg4AADAOAQcAABgHAIOAAAwDgEHAAAYh4ADAACMQ8ABAADGIeAAAADjLPxJxuVyWZVKRZZljVzveZ5c15UktVotff/99+G2vu/LcRzZti3f91UsFsfuBwAA3B0LbcHxPE/7+/tXbuO6rvb29rS3t6dMJqOtra1wXaFQ0N7envL5vPL5vHZ3d+ddZAAAsAQWGnB835dt22PXe56narUafs7n8/I8T77vy/f9oW1t2w5begAAwN22sIDjOI7y+fyV2ySTSX3//ffh5yAIJEmJREKu6yqRSAxtn0gk5Hnepf2cnZ2p1+sNvQAAgLkWEnCCIJi4r8zFEPT48WNls1lZlhWGnXd1Op1Ly6rVquLxePhaX1+fptgAAGBJLCTgHBwcKJvNRvpOEARyHEfNZvPa7d5VqVR0enoavl6/fh3p2AAAYLnc+Cgq13W1vb0d+XvlclmHh4dhy49lWZdaazqdzsiWoZWVFa2srExTXAAAsIQWMkz84OAgfO/7vqrVqnZ2dpRMJkduv7+/r3K5LNu2wxaabDarer1+adt0Oj2XMgMAgOVx4wHn3VtTpVJJpVIpHE3leZ4sywo/O46jZDIZhpuDg4ORz7vxfV/pdJrn4AAAgMWNogqCIHwGTq1WC0c/VatVOY4j6Ty0FAoF5XI5xWIxra2tqVwuh/toNpsql8tyHEf1ev3a/jkAAOBuiPX7/f6iC3HTer2e4vG4Tk9Ptbq6uujiAACACUT5/WYuKgAAYBwCDgAAMA4BBwAAGIeAAwAAjEPAAQAAxiHgAAAA4xBwAACAcQg4AADAOAQcAABgHAIOAAAwDgEHAAAYh4ADAACMQ8ABAADGIeAAAADjEHAAAIBxCDgAAMA4BBwAAGAcAg4AADAOAQcAABiHgAMAAIxDwAEAAMYh4AAAAOMQcAAAgHEIOAAAwDgEHAAAYBwCDgAAMA4BBwAAGIeAAwAAjEPAAQAAxiHgAAAA4xBwAACAcRYecMrlsoIguHIbz/OUSqVGLvc8T5Lk+374HgAA3G0LDTie52l/f//KbRzHCbd9V71eVyqVUiwWU6lUkm3bcyknAABYLr9Y5MF93782lOTz+bHrUqmUut2uJMmyrFkWDQAALLGFteA4jnNleJmUZVnXhpuzszP1er2hFwAAMNdCAk4QBDNpcQmCQI7jyHEclctl+b4/crtqtap4PB6+1tfX3/vYAADg9or1+/3+TR+00WioWCxKkjY2NnRycnJt4InFYnq3qBeDkud5KhQKarfbl757dnams7Oz8HOv19P6+rpOT0+1urr6fpUBAAA3otfrKR6PT/T7feMtOK7rant7eyb7uthiY9u2fN8f2YqzsrKi1dXVoRcAADDXQjoZHxwchO9931e1WtXOzo6SyeTE+/A8T1tbW2En44FEIjGzcgIAgOV04wEnm80OfS6VSkNDvD3Pk2VZI0dXXbwlZdu2arVauM51XeXzeUZTAQCAxY2iCoIgfAZOrVYLn3NTrVbDZ99I58GlXC5fWmdZltLptPb399VoNNRqtdRsNm+4FgAA4DZaSCfjRYvSSQkAANwOt7qTMQAAwLwRcAAAgHEIOAAAwDgEHAAAYBwCDgAAMA4BBwAAGIeAAwAAjEPAAQAAxiHgAAAA4xBwAACAcQg4AADAOAQcAABgHAIOAAAwDgEHAAAYh4ADAACMQ8ABAADGIeAAAADjEHAAAIBxCDgAAMA4BBwAAGAcAg4AADAOAQcAABiHgAMAAIxDwAEAAMYh4AAAAOMQcAAAgHEIOAAAwDgEHAAAYBwCDgAAMA4BBwAAGIeAAwAAjLPwgFMulxUEwZXbeJ6nVCp1abnv+9rf35fjONrf3792PwAA4G6I9fv9/qIOPggu3W5XlmWN3MZxHNm2rVQqpXeLmkqldHJyIuk87JTLZTWbzWuP2+v1FI/HdXp6qtXV1feuBwAAmL8ov9+/uKEyjeT7vmzbvnKbfD4/9rsX2bYt13VnVjYAALC8FnaLynGcseFlEq7rKpFIDC1LJBLyPO/StmdnZ+r1ekMvAABgroUEnCAIxt6SirKPUTqdzqVl1WpV8Xg8fK2vr7/XsQEAwO22kIBzcHCgbDY7l32PCj6VSkWnp6fh6/Xr13M5NgAAuB1uvA+O67ra3t5+7/1YlnWptabT6YxsGVpZWdHKysp7HxMAACyHhXQyPjg4CN/7vq9qtaqdnR0lk8mJ95HNZlWv1y8tT6fTMykjAABYXjcecN69NVUqlVQqlcLRVJ7nybKskaOrLvbdeXe97/tKp9Pv3bcHAAAsv4WNogqCQPv7+5KkWq0Wjn6qVqtyHCfcznVdlcvlkeuazabK5bIcx1G9Xp/oGTgAAMB8C33Q36LwoD8AAJZPlN/vhU/VAAAAMGsEHAAAYBwCDgAAMA4BBwAAGIeAAwAAjEPAAQAAxiHgAAAA4xBwAACAcSIHnEQioYcPH+r58+dzKA4AAMD7ixxwXr16pWQyqd/97nfa3NxUpVLRjz/+OIeiAQAATCdywInH49rd3dXx8bGOj49l27YKhYIymYy+/fZb9Xq9eZQTAABgYlPPJv78+XPV63UdHh4qmUyqVCopCALl83l99tln+sd//MdZlhMAAGBikSfb/Oabb1Sv1xWLxVQqlbS7u6t4PD60TTqd1vHx8UwLOktMtgkAwPKJ8vsduQWn3W6r2WzqN7/5zdhtSqVS1N0CAADMTOQ+OLlcTrFYbGjZkydP9PTp0/Dz7u7u+5cMAABgSpFvUW1uburk5GSoaej09FTpdFovXryYeQHngVtUAAAsnyi/35FbcN68eXNpp/F4XG/evIm6KwAAgLmIHHDS6bT++Mc/Di179uyZbNueWaEAAADeR+RbVL7vK51O6/79+8pms2q32zo5OdHJyYk++uijORVztrhFBQDA8pnrKCrbttXpdOQ4jl69eqVsNqsvvvhi6sICAADM2tQP+svn87MsBwAAwMxMFXCePXsmz/OGOhbfv39fjx49mlnBAAAAphW5k/FXX32lfD6vly9fqtlsqtvt6vDwUK1Wax7lAwAAiCxyC86TJ0/U6XQkSb///e+1v7+v1dVV7ezszLxwAAAA04jcgnNx0NXGxoaOjo4kSa7rzq5UAAAA7yFywMnn8+G0DMViUV9++aUymYwePHgw88IBAABMI/JzcN716tUr+b6vra2tWZVp7ngODgAAy2euUzV8++23Q58fPHiwVOEGAACYL3LA+fOf/3xpqgYAAIDbJPIoqkqlou3t7fC2lGVZ4bplmaoBAACYLXIfnHQ6rSAILu8oFtOLFy9mVa65og8OAADLZ65zUR0fH09dsFHK5bIqlcpQS9BFvu/LcRzZti3f91UsFsNtPc+TJCWTSfm+ryAIlEwmZ1o+AACwfCL3wZHOp2p4+PCh/umf/kmSdHR0pGfPnkXej+d52t/fv3KbQqGgvb095fN55fN57e7uhuvq9bpSqZRisZhKpZJs245cBgAAYJ7IAadSqaher6tYLOrw8FCSlEqlVC6XIx/c9/0rQ4nv+0OfbdseeqBgKpVSt9sNp4sY1woEAADulsgBx3EcPX78WL/5zW/CpxpbljWyX851+7luRnLXdZVIJIaWJRKJ8NbU4NjXBZuzszP1er2hFwAAMFfkgBOPx/XDDz9IOu9YLEl/+ctfFI/HJ95HEAQTtbaMC02DubCCIJDjOHIcR+Vy+VKLz0C1WlU8Hg9f6+vrE5cVAAAsn8idjA8ODpROp5XJZNTtdvXw4UO5rqtmsxlpH8ViMeqhQ4Pgc7HDsW3byuVyarfbl7avVCr6wx/+EH7u9XqEHAAADBY54Ni2rU6noydPnsj3fVmWpa+//nriFhzXdbW9vT3RtpZlha01A51OJww1vu+Ho6YGo6xG9etZWVnRysrKRMcEAADLL3LAGfjiiy+mPujBwUH43vd9VatV7ezsXBrinc1mVa/XL30/nU7L8zxtbW2p2+0OrXu3zw4AALh7Igecp0+fam9vT69evQqX9ft9xWIx/fWvf732+9lsduhzqVQaGuLteZ4sy5Jt25daYnzfVzqdDtfXarVwneu6yufzjKQCAADRA87u7q4ajcaloBJVEARqNBqSpFqtplKppGQyqWq1qkwmo729PUlSs9lUuVxWJpNRq9UK+/pYlqV0Oq39/X1ZlqV2ux2pHxAAADBX5KkaPv30U/3nf/7nvMpzI5iqAQCA5TPXqRoKhYJ2dna0s7Mj27aZbBMAANw6kVtwPv7440sjm6TzZ+K8efNmZgWbJ1pwAABYPnNtwXn58uXUBQMAALgJUw0Tf/bsmZrNptbW1vRv//ZvOjo6UiwW0yeffDLr8gEAAES20Mk2AQAA5iFyC47jOHrx4oUkvddkmwAAAPOykMk2AQAA5mkhk20CAADM041PtgkAADBvkQNOpVJRtVodOdnm06dPJUm//e1v379kAAAAU4occE5OTvT27Vu1223Zth0+aKdSqejw8FCJREK+7+vRo0czLywAAMAkprpF9dFHHymVSunVq1fa39/X559/rkajoVevXml1dVWbm5sEHAAAsDBTteD4vh/2udnc3NTnn3+ubrcbtuZcnJ8KAADgpkUeJt7tdnXv3vnXer3eyDDT7Xbfu2AAAADTityC89133+nXv/617t+/r36/L8uy9Omnn8q2bT18+FCSlM/nZ15QAACASUUOONlsVp1OR6enp5eGhn/zzTeSpC+//HI2pQMAAJjCTCfbJNgAAIDbgMk2AQCAcZhsEwAAGIfJNgEAgHGYbBMAABiHyTYBAIBxphpFJWnkZJsAAAC3wUR9cO7du6cPPvjgytfm5ua8ywoAADCRiVpwfv755/D9V199pUwmo2w2K+l8JFWj0QinbwAAAFi0WH8w1ntCmUxGrVZr4uW3Ua/XUzwe1+npaThBKAAAuN2i/H5PNdnmn/70p6Flz58/V7vdjrorAACAuZhqss2trS3lcjnZtq12u62joyOGiQMAgFtjqsk2u92uDg4OFASBksmkms0mw8QBAMCtMdUw8Xg8rt3d3VmXBQAAYCYY+gQAAIwz9YP+ZqVcLqtSqciyrJHrfd+X4ziybVu+76tYLIbbXrUOAADcXZGHic+S53lKpVLqdrtjg0kqldLJyYmk80BTLpfDDs1XrbsKw8QBAFg+UX6/F9qC4/u+bNu+cv1Ftm3Ldd1r1y1Kv9/Xf/+/vy60DAAA3BZ/+zcfKBaLLeTYUwWcZ8+e6eDgQGtra6pWqzo6OlIsFtMnn3wy8T4cx1E+n1e5XB67jeu6SiQSQ8sSiYQ8z9Px8fHYdclkcmj52dmZzs7Ows+9Xm/ickbx3//vr/o///c/5rJvAACWzX/962f63/9rMW0pkTsZVyoV1et1lUqlsMUknU5fGVTeFQTBRH1lgiAYubzT6Vy57l3ValXxeDx8ra+vT1xWAACwfCLHKsdx9OLFC0nnt2Sk82Hj4wLHKAcHByoWi1EPHbrqWKPWVSoV/eEPfwg/93q9uYScv/2bD/Rf//rZzPcLAMAy+tu/+WBhx44ccOLxuH744Qf93d/9XXhf7S9/+cvED/pzXVfb29sTbWtZ1qUWmU6nI8uyrlz3rpWVFa2srEx0zPcRi8UW1hQHAAD+R+Rf44ODA6XTaWUyGXW7XT18+FCu60aaquHg4CB87/u+qtWqdnZ2LvWdyWazqtfrl76fTqdl2/bYdQAA4G6LHHBs21an09GTJ0/k+74sy9LXX389cQtONpsd+lwqlVQqlcLRVJ7nybIs2bZ9aYSV7/tKp9NhC864dQAA4G6LHHCePXumTz75RF988UW47PT0VE+fPtVvf/vbifcTBIEajYYkqVarqVQqKZlMqlqtKpPJaG9vT5LUbDZVLpeVyWTUarWGWoquWgcAAO6uyA/6G4SJSZffRjzoDwCA5TOXB/39+7//u6TzW0GD9wMvX74MnygMAACwaBMHnJcvX0o6Hxp+fHw8tM6yLAIOAAC4NSYOOF9//bWk874z33333dwKBAAA8L4iP8mYcAMAAG67qeei8jxPb968CZfdv39fjx49mlnBAAAAphW5Beerr75SPp/Xy5cv1Ww21e12dXh4uDQjqAAAgPkit+A8efIknCLh97//vfb397W6uqqdnZ2ZFw4AAGAakVtwLj42Z2NjQ0dHR5IUziwOAACwaJEDTj6f19OnTyVJxWJRX375pTKZjB48eDDzwgEAAEwj8pOM3/Xq1Sv5vq+tra1ZlWnueJIxAADLJ8rvd+QWnGfPng19fvDggdLpdNiqAwAAsGiRA065XL60LB6Pq1qtzqRAAAAA74u5qAAAgHGYiwoAABiHuagAAIBxIvfB+fjjj/Xjjz9KOu9wvLm5qc3NTf3pT3+addkAAACmEnmY+Obmpl68eCHpfP6pWq2mTz75RJ999lm4/LZjmDgAAMsnyu935KkaBnno6OhI3W5Xv/vd7yRpaOJNAACARYoccGzbVqVSUbPZVLFYlHT+sD/btmdeOAAAgGlE7oPTbDZl27bK5XLY2TgIAlUqlZkXDgAAYBrvPVXDMqIPDgAAy2euUzUAAADcdgQcAABgHAIOAAAwDgEHAAAYZ6KAc+/ePX3wwQdXvjY3N+ddVgAAgIlM9Bycn3/+OXz/1VdfKZPJKJvNSjp/8F+j0dC9ezQGAQCA2yHyMPFMJqNWqzXx8tuIYeIAACyfuQ4T73a7lybWfP78udrtdtRdAQAAzEXkqRq+++47bW1tKZfLybZttdttHR0dqdlszqN8AAAAkUUOONlsVp1OR81mU0EQKJlMqtlsKh6Pz6N8AAAAkUUOOJJkWZZ2d3enPqjrupLO57BqtVra2dlRMpkcua3v+6rX69rY2FC73ValUpFlWZIkz/MkSclkUr7vh4ELAADcbZH74Dx9+lQff/zx0BDxwTDySRUKBSUSCeXzeW1sbKhQKIzdNpfLqVKpqFgsamdnR+VyOVxXr9eVSqUUi8VUKpWY0RwAAEiaogVnd3dXjUYjHCY+jWazOdTSMmiRedegpWewPplMqtFoqF6vS5JSqZS63e6V+wAAAHdP5ICTSqX0xRdfvNdBL4ajZrOpUqk0crsgCEYu9zwvDEiTBJuzszOdnZ2Fn3u93uSFBQAASydywCkUCtrZ2dHOzo5s2x4KGB999NHE+/E8T48fP1Yul1OxWBy5zaBvzcXvSFKn05F0HoAcx5EktVqtsbepqtWq/uVf/mXisgEAgOUW+UF/H3/8cRgwhnYUi+nNmzeRDh4EgcrlsnK5nPL5/Mht9vf3ZVmWtre35bquCoWCTk5OlEwmFQTBUIfjQqEw8nk8o1pw1tfXedAfAABLJMqD/iIHnFlzXVe5XE7dbnfs7abBCCnbtrW2thZue/FWVRAEWltbU7vdvrazMU8yBgBg+cz1Scbvy3Vdra2thZ8HYeTiraiLfN+Xbdvh7apkMhmGm62trUvbJxKJ+RQcAAAsjcgBZ9zM4pPOJp5IJIY6GXueJ8uywpYYz/OGwk4qlQo7G9frddVqNUnnwWjwXjoPTvl8ntFUAAAgeifjwbDsgaiziSeTSe3s7KjRaEiSDg8PdXJyEq6vVqvKZDLa29uTJNVqNbmuq06no0KhEIYjy7KUTqfDPjrtdpvpIgAAgKQZ9sH57LPP9B//8R+z2NXc0QcHAIDlE+X3O3ILzo8//nhpme/7Y/vQAAAA3LTIASeZTCoWi+liw8/9+/fHPssGAADgpkUOOKOegQMAAHCbTDWbuCQ9e/ZMvu9rY2ND//AP/zDLMgEAALyXyAHn9PRUqVRKa2trevDggXzf1+npqQ4PDyNN1QAAADAvkQPO9va26vX60EP2HMdRqVRamlFUAADAbFPNRfXy5ctLy+/fvx95LqpFYZg4AADLZ65TNdi2rR9++GFo2fPnz/XgwYOouwIAAJiLyLeovvvuO6XTaeVyOdm2rXa7raOjIx0dHc2jfAAAAJFN1YLT6XSUzWbV7/eVy+Xk+77+/u//fg7FAwAAiC5yC863336rR48eaXd3dx7lAQAAeG+RW3D+/Oc/649//OM8ygIAADATkVtwKpWKtre35fu+tra2ZFlWuI7n4AAAgNsg8jDxdDqtIAgu7ygW04sXL2ZVrrlimDgAAMtnrrOJHx8fT10wAACAmxC5D06lUhm77unTp3r69Ol7FQgAAOB9RW7BOTk50du3b9Vut2XbdthEVKlUdHh4qEQiId/39ejRo5kXFgAAYBKRA45t2/roo4+USqX06tUr7e/v6/PPP1ej0dCrV6+0urqqzc1NAg4AAFiYqVpwfN9XPB6XJG1uburzzz9Xt9sNW3MujqwCAAC4aZH74HS7Xd27d/61Xq83Msx0u933LhgAAMC0ppqL6te//rXu37+vfr8vy7L06aefyrZtPXz4UJKUz+dnXlAAAIBJRQ442WxWnU5Hp6en4W2qgW+++UaS9OWXX86mdAAAAFOI/KA/E/CgPwAAlk+U3+/IfXAAAABuOwIOAAAwDgEHAAAYh4ADAACMQ8ABAADGIeAAAADjEHAAAIBxCDgAAMA4kZ9kPAuu60qSgiBQq9XSzs6OksnkyG1931e9XtfGxoba7bYqlUo4/5Xv+3IcR7Zty/d9FYtFJvoEAACLCTiFQkFHR0fhtA+FQkHtdnvktrlcTicnJ7IsS57nqVwuq16vh/s5OTmRdB52dnd31Ww2b6weAADgdlrILapmsznUYjOu1WXQ0jNYn0wm1Wg0JJ0Hmots2w63BwAAd9tCWnCy2Wz4vtlsqlQqjdwuCIKRyz3P0/HxsRKJxNDyRCIhz/Mu3e46OzvT2dlZ+LnX601ZcgAAsAwW1sl4cLspl8upWCyO3CaZTA611HieJ0nqdDpjw0+n07m0rFqtKh6Ph6/19fX3rwAAALi1FhZwksmkKpWK2u22HMcZuY1t26rVamo0GgqCIAw777bcXDQq+FQqFZ2enoav169fz6QOAADgdlrILaoBy7JUKBSUy+XU7XZH9sXZ29uT7/vyfT+8tWXbtizLutRa0+l0Ru5jZWVFKysr86gCAAC4hW68Bcd1Xa2trYWfbduWdLnT8IDv+7JtO7xdlUwmZVnWUD+ei9Lp9OwLDQAAlsqNB5xEIjEUTjzPk2VZYcdgz/OGwk4qlQpvO9XrddVqNUn/E4wGfN9XOp3mOTgAAECxfr/fv+mDOo4T3l46PDxUrVYLA0uhUFAmk9He3p4kqdFoKJFIqNPpyLbtoXA0eAhgJpNRq9UaegjgVXq9nuLxuE5PT7W6ujr7CgIAgJmL8vu9kICzaAQcAACWT5Tfb+aiAgAAxiHgAAAA4xBwAACAcQg4AADAOAQcAABgHAIOAAAwDgEHAAAYh4ADAACMQ8ABAADGIeAAAADjEHAAAIBxCDgAAMA4BBwAAGAcAg4AADAOAQcAABiHgAMAAIxDwAEAAMYh4AAAAOMQcAAAgHEIOAAAwDgEHAAAYBwCDgAAMA4BBwAAGIeAAwAAjEPAAQAAxiHgAAAA4xBwAACAcQg4AADAOAQcAABgHAIOAAAwDgEHAAAY5xeLOKjrupKkIAjUarW0s7OjZDI5clvf9+W6rhKJhHzfVz6fl23bkiTP8yRJyWRSvu8rCIKx+wEAAHfHQlpwCoWCEomE8vm8NjY2VCgUxm7rOI6KxaLy+bz29vZUq9XCdfV6XalUSrFYTKVSKQw+AADgbltIwGk2m0MtLZZljd328ePHY9elUil1u111u10dHh5euR8AAHB3LOQWVTabDd83m02VSqWx2yYSCaVSKTWbTfm+r1wuN7R+klBzdnams7Oz8HOv14teaAAAsDQW1snY8zyVy2XlcjkVi8Wx2zWbTUnSxsaGms2m8vl8uC4IAjmOI8dxVC6X5fv+yH1Uq1XF4/Hwtb6+PtvKAACAWyXW7/f7izp4EARhyLkYXC5yHEeWZcn3fZVKJRWLRdXr9fD7gxYcz/NUKBTUbrcv7WNUC876+rpOT0+1uro6+4oBAICZ6/V6isfjE/1+L3SYuGVZKhQKKhQKCoLg0nrf99VqtZTNZlUsFtVut3VwcBC21FxssbFtW77vj2zFWVlZ0erq6tALAACY68YDjuu6WltbCz8PRj6NCiae5ymTyQxtW6lUFASBPM/T1tbWpe8kEok5lBoAACyTGw84iURiqJOx53myLCscVeV5Xhh2ksmkWq3W0PffvHmjZDIp27aHhoy7rqt8Ps9IKgAAsJg+OI7jqNPpSJIODw9Vq9XClpxCoaBMJqO9vT1J58FlEIKk8xFYFx/057quLMtSu90eCjxXiXIPDwAA3A5Rfr8X2sl4UQg4AAAsn6XpZAwAADAPBBwAAGAcAg4AADAOAQcAABiHgAMAAIxDwAEAAMYh4AAAAOMQcAAAgHEIOAAAwDgEHAAAYBwCDgAAMA4BBwAAGIeAAwAAjEPAAQAAxiHgAAAA4xBwAACAcQg4AADAOAQcAABgHAIOAAAwDgEHAAAYh4ADAACMQ8ABAADGIeAAAADjEHAAAIBxCDgAAMA4BBwAAGAcAg4AADAOAQcAABiHgAMAAIxDwAEAAMYh4AAAAOP8YhEHdV1XkhQEgVqtlnZ2dpRMJkdu6/u+XNdVIpGQ7/vK5/OybTtc5ziObNuW7/sqFouyLOumqgEAAG6phQScQqGgo6MjZbNZdTodFQoFtdvtkds6jqO9vb3wc6lUUr1eD/dzcnIi6Tzs7O7uqtlszr8CAADgVlvILapmsznUYnNVq8vjx49HLvd9f+izbdthyxAAALjbFhJwstls+L7ZbKpUKo3dNpFIKJVKhbeqcrmcJIW3rd7d1vO8S/s4OztTr9cbegEAAHMtrJOx53kql8vK5XIqFotjtxvcctrY2FCz2VQ+n5d03n9nlE6nc2lZtVpVPB4PX+vr6+9fAQAAcGstLOAkk0lVKhW12205jjN2O9d1VavVVK/X1Wg0rmztkUYHn0qlotPT0/D1+vXr9y0+AAC4xRbSyXjAsiwVCgXlcjl1u91LfXF831er1VKtVpN0fmsrlUqpXC7LsqxLrTWdTmdkf56VlRWtrKzMqxoAAOCWufEWHNd1tba2Fn6+OOT7XZ7nKZPJDG1bqVQUBMFQP56L0un0jEsMAACWzY0HnEQiMRROPM+TZVnhqCrP88Kwk0wm1Wq1hr7/5s0bJZPJMBgN+L6vdDrNc3AAAIBi/X6/f9MHdRwnvL10eHioWq0WBpZCoaBMJhM++8Z13TAESee3qS62+tTrdWUyGbVaLVUqlYkCTq/XUzwe1+npqVZXV2dfQQAAMHNRfr8XEnAWjYADAMDyifL7zVxUAADAOAQcAABgHAIOAAAwDgEHAAAYh4ADAACMQ8ABAADGIeAAAADjEHAAAIBxCDgAAMA4C51NfFEGD2/u9XoLLgkAAJjU4Hd7kkkY7mTAefv2rSRpfX19wSUBAABRvX37VvF4/Mpt7uRcVD///LN++uknffjhh4rFYjPdd6/X0/r6ul6/fm3kPFfUb/mZXkfT6yeZX0fqt/zmVcd+v6+3b9/ql7/8pe7du7qXzZ1swbl3755+9atfzfUYq6urxv7FlaifCUyvo+n1k8yvI/VbfvOo43UtNwN0MgYAAMYh4AAAAOMQcGZsZWVF//zP/6yVlZVFF2UuqN/yM72OptdPMr+O1G/53YY63slOxgAAwGy04AAAAOMQcAAAgHEIOAAAwDh38jk40/J9X47jyLZt+b6vYrEoy7Ku/V65XFalUgm3vWo/0x5jFqIc23VdSVIQBGq1WtrZ2VEymZQkOY6jbDYrSZe+73meJCmZTMr3fQVBEH5v3mZVv6vqsMjzF/X419VxsL7Vaun7778P92PCOTThGrzqHN3Wa1CaXR1v63U4y/ot+zV4VR1u5BrsY2LJZDJ83263+/l8/trvnJyc9CX1u93uRPuZ5hizEuXYlmX1T05O+v1+v1+v1/u2bYfrJF161Wq1fr/f7xeLxXBZNpsd+nOZt1nV76o6LPL8RT3+VXUcnK/B+4v7NeEcmnANXnWObus12O/Pro639TqcVf1MuAavqsNNXIMEnAm12+2hP/R+//wf0Os0m82+bdvhX8Cr9jPtMWYh6rEPDw/D9/V6Pfxut9vtN5vNoW0v/iWv1+v9brd74/+ozqp+g8+j6rDI8zfN8cfV8eTkZOh77Xa7L6nfbrfDbZf5HJpwDV51jm7rNdjvz66O/f7tvA5nVT8TrsGr6nBT1yB9cCbkuq4SicTQskQiETYVjuI4jvL5/MT7meYYsxL12IPmb0lqNpsqlUrh54t1HvVnYFnWjd62kWZbP2l0HRZ5/qY5/rg6JpNJff/99+G6IAjCfQ0s8zk04Rq87hzdxmtQmm0dpdt3Hc6qfiZcg1fV4aauQfrgTGhwct7V6XTGbj/qL99V+4l6jFma5tie5+nx48fK5XIqFouShu/3B0GgTqcj27aHljmOI+n8nmypVBpaPy+zqt9gX6PqsMjzNyhX1OOPq+PFH8THjx8rm82G53bZz6Ep1+BV5+jiPm/LNTg49ijT1PE2XoezrJ8J1+C4OtzUNUjAeU/jTsbBwcHQD8a0+7lu3bxddexkMinbtlUul0f+L7FcLqtWqw0tu9hZzLZt5XI5tdvtWRd7YtPUL2odFnn+rjv+dedw8A/pyclJuMyEcxh1P7f1Ghysf/ccDSzDNShNV8dlug7f5xwu+zU4WD+ufpPuZ5rzd+cDTqPRuPIvRi6XC1Pnuwmy0+mMbKVxXVfb29sj93fVfqIcY1LzqN9FlmWpUCgol8up2+0O/Q/Ddd1L3/d9P+ztP+gh7/v+1P/7WET9xtVhHudPWtw5lM5/IA8PD4eWmXAOTboGR50j6eauQWkxdbzJ63BR53DcumW7Bt+tw41dg1P13LmDxnV8GtXJ6/DwsF+v18OXpP7e3l7/5OTkyv1EOcasRa2fNaLz2GDEymCbd/f3bqezbrd7aYTZvMyqflfVYZHnb1DOWZ7DWq0WdmocdGg04RyacA0OjDpHA7ftGuz3Z1fH23odzvocLvM1ODCqDjd1DdLJeELvJmPf95VOp8NU6XmefN+XdN65sVgshi9JKpVKYXP5uP1cd4x5ilK/RCIx1IHT8zxZljX0HAbP8y51FLNte6i53HVd5fP5parfVXVY5PmTZnsOHccJ6xsEgQ4ODsI6mnAOx+1nWa5Bafw5Grht1+Dg+BdNW8fbeh3O8hwu+zV4XR3G7WeW54/JNiPwfV/1el2ZTEatVmvo4X2FQkGZTEZ7e3vh9kEQqNFoqFwuq1gshiHnqv1cte421c9xnLAZ8fDwULVabegv5v7+vtrttur1+tAxBr3kLctSu92+1D9gnmZVv6vqsMjzN6s6+r6vjY2Nof1alqVutyvJjHO47NfgdedIup3XoDS7Ot7W63AW9TPhGryuDjdxDRJwAACAcbhFBQAAjEPAAQAAxiHgAAAA4xBwAACAcQg4AADAOAQcAABgHAIOgDtnbW1t6IFkAMxDwAGwcOVyWY1G484dG8D8EHAAAIBxCDgAZsZ1XW1sbCiVSqlUKimXy6lcLks6bynZ2NjQxsZGuEw6n6dtMKVJKpWS67qSzh/XnkqlLm1/UaFQGGp9CYJAa2tr4fdzuZw2NjaUy+UUBMGl74879riyXlfHScoM4IZEnp4TAMYYzPrb7XYvzQDcbDaHtjs8PAw/F4vFfr1ev7Svwezm+Xx+aPuBd2fMrtfr/Xw+f+n7h4eHfdu2h/Y9mOF41LGvKutVdZykzABuBi04AGYiCAIlEglZliXLspROp4c68ubz+fD99va2PM8buy/HcZROp8PZzSuViprN5qXtstmsfN8PW2eazWbYKpPNZsPvZ7NZWZYVttBcZ1xZr6rjpGUGcDN+segCADDDYLbfIAhkWZZ83x+aYT4IAjUaDbXb7XAm5HF83w9v9wxks9mR22azWR0cHGh7e1vHx8fKZrMql8tDx5YUzpQ+iXFlvaqOUcoMYP4IOABmxrIsbW1tKQgC1Wq1MBAM+sPUajUVi8Vr+6dYlqVsNqt6vX7tMUulkmq1mhKJRBgoNjY2dHh4OLTdu4FrnOvKOq6OUcoMYP64RQVgZhKJhE5OTtRut4du8/i+L8uylM/nZVmWjo+Ph75nWZba7bak89aR7e1tua47dGto3O2lbDar4+NjPX78WKVSSZIufd9xHAVBMLJF5d1jX1fWcXWMUmYA80fAATAzvu8rFospFotpbW0tbP0YBIu1tTUVCgXZtq379++H39vZ2dH+/n44ksmyLDWbTe3u7mpjY0NbW1tXHncQLgbHsSxLR0dH2t3d1dramur1+qUWnXHHvq6s4+oYtcwA5ivW7/f7iy4EgOW3v7+vdrsd3qIJgkBbW1uqVCpDLR3L7C7UETAFLTgA5sKyLCUSiUUXY67uQh2BZUXAATATe3t7siwrfAje4AF7JrVs3IU6AqbgFhUAADAOLTgAAMA4BBwAAGAcAg4AADAOAQcAABiHgAMAAIxDwAEAAMYh4AAAAOMQcAAAgHEIOAAAwDj/H5iDGpo7Cz7ZAAAAAElFTkSuQmCC",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(eps_set,degeneracy)\n",
        "plt.xlabel(\"gate voltage\")\n",
        "plt.ylabel(\"ground state degeneracy\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JlprhPtzIPTu"
      },
      "source": [
        "## Schrieffer Wolff transformation\n",
        "\n",
        "As a first step of the Schrieffer Wolff transformation we must decompose the creation and annihilation operators of frontier orbitals into quantum number blocks."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "cYaaY2kEIPTu",
        "outputId": "9ab8e258-c6bb-4b6e-eb34-f4852e302b43"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "all commutes\n",
            "GS quantum numbers:  ['Q-1S0S1.00S0.00']\n"
          ]
        }
      ],
      "source": [
        "##################\n",
        "# choose defining symmetries\n",
        "##################\n",
        "symmetry_set = [parity,Stot]\n",
        "##############\n",
        "# checking the commutaiton\n",
        "##############\n",
        "noerror = True\n",
        "for A in symmetry_set+[ham]:\n",
        "    for B in symmetry_set+[ham]:\n",
        "        for i,j in enumerate(H.qnind):\n",
        "            tmpA = A.GetMat(i,False)\n",
        "            tmpB = B.GetMat(i,False)\n",
        "            L = np.dot(tmpA,tmpB)\n",
        "            R = np.dot(tmpB,tmpA)\n",
        "            if abs(np.max(abs((L-R).flatten()))) > 1e-12:\n",
        "                print(np.max(abs((L-R).flatten())))\n",
        "                print(i,\" does not commute\")\n",
        "                noerror = False\n",
        "                break\n",
        "##############\n",
        "# decompose operators into symmetry blocks\n",
        "##############\n",
        "if noerror:\n",
        "    print(\"all commutes\")\n",
        "    ###############\n",
        "    # get all ingredients for the SuperBlockOperator\n",
        "    ###############\n",
        "    _,_,_,Tot_QN_set,basistrafos,basis_dict_set,_ = SuperBlockDiagonalization(symmetry_set,ham)\n",
        "    # creation\n",
        "    cd_0_up_set,cd_0_up_dict,cd_0_up_out =  SuperBlockOperator(basistrafos,basis_dict_set,cd_0_up)\n",
        "    cd_0_do_set,cd_0_do_dict,cd_0_do_out =  SuperBlockOperator(basistrafos,basis_dict_set,cd_0_do)\n",
        "    cd_2_up_set,cd_2_up_dict,cd_2_up_out =  SuperBlockOperator(basistrafos,basis_dict_set,cd_2_up)\n",
        "    cd_2_do_set,cd_2_do_dict,cd_2_do_out =  SuperBlockOperator(basistrafos,basis_dict_set,cd_2_do)\n",
        "    all_cd_sets = [cd_0_up_set,cd_0_do_set,cd_2_up_set,cd_2_do_set]\n",
        "    all_cd_dict = [cd_0_up_dict,cd_0_do_dict,cd_2_up_dict,cd_2_do_dict]\n",
        "    all_cd_out = [cd_0_up_out,cd_0_do_out,cd_2_up_out,cd_2_do_out]\n",
        "    # anihilation\n",
        "    c_0_up_set,c_0_up_dict,c_0_up_out = SuperBlockOperator(basistrafos,basis_dict_set,c_0_up)\n",
        "    c_0_do_set,c_0_do_dict,c_0_do_out = SuperBlockOperator(basistrafos,basis_dict_set,c_0_do)\n",
        "    c_2_up_set,c_2_up_dict,c_2_up_out = SuperBlockOperator(basistrafos,basis_dict_set,c_2_up)\n",
        "    c_2_do_set,c_2_do_dict,c_2_do_out = SuperBlockOperator(basistrafos,basis_dict_set,c_2_do)\n",
        "    all_c_sets = [c_0_up_set,c_0_do_set,c_2_up_set,c_2_do_set]\n",
        "    all_c_dict = [c_0_up_dict,c_0_do_dict,c_2_up_dict,c_2_do_dict]\n",
        "    all_c_out = [c_0_up_out,c_0_do_out,c_2_up_out,c_2_do_out]\n",
        "    # QN set\n",
        "    all_cd_index = [[0,1],[0,0],[1,1],[1,0]]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "In the following for simplicity of the discussion, we assume that all states can be labelled by a unique combination of quantum numbers and thus, we omit the multiplet index henceforth. The occupation $N = \\bra{\\mathbf{Q},\\mathbf{q}}\\hat{N}_{\\rm mol} \\ket{\\mathbf{Q},\\mathbf{q}}$ (or charge $Q = eN$) is a conserved quantity and defining an abelian quantum number. Because of its importance we state it before the non-abelian \\qn{}s\n",
        "$$\n",
        "\t\\ket{n} \\mapsto \\ket{N,\\mathbf{Q},\\mathbf{q}}\\;, %\\\\\n",
        "\t%\\textrm{with}~\\mathbf{Q} \\equiv (Q_1,Q_2,\\dots),~\\mathbf{q} \\equiv (q_1,q_2,\\dots)\n",
        "$$\n",
        "We demand that the molecule is tuned to a \\gs{} manifold with integer occupation $N$\n",
        "$$\n",
        "\\ket{GS} = \\ket{N,\\mathbf{Q}_{GS},\\mathbf{q}}\\;,\\\\\n",
        "\\textrm{with}~(q_1,q_2,\\dots)\\in \\mathbb{q}_{GS} \\equiv \\lbrace (q'_1,q'_2,\\dots),(q''_1,q''_2,\\dots),\\dots \\rbrace \\;,\n",
        "$$\n",
        "where we have assumed that the GS manifold is defined by a fixed set of non-abelian QNs $\\mathbf{Q}_{GS}$ and a number of different abelian \\qn{} sets $\\mathbb{q}_{GS}$. The goal of the BWPT is to derive an effective model that is defined only on the GS manifold of the molecule (but including the entire Fock space of the leads), the GS manifold thus defines the model space\n",
        "$$\n",
        "\t\\hat{M} = \\sum_{\\mathbf{q}\\in \\mathbb{q}_{GS}} \\ket{N,\\mathbf{Q}_{GS},\\mathbf{q}}\\bra{N,\\mathbf{Q}_{GS},\\mathbf{q}} \\bigotimes_\\alpha\\left(\\sum_k\\ket{k}_\\alpha ~_\\alpha\\bra{k}\\right)  \\;,\n",
        "$$\n",
        "with its defining property\n",
        "$$\n",
        "\t(\\hat{H}_{\\rm mol} + \\hat{H}_{\\rm gate})\\hat{M} = E_{G} \\hat{M} \\; ,\n",
        "$$\n",
        "where $E_{G}$ is the \\gs{} energy of $\\hat{H}_0$. Using this the generalized SWT effective exchange Hamiltonian is to second order in $\\hat{H}_{\\rm hyb}$\n",
        "$$\n",
        "\t\\hat{H}_{\\rm eff} = \\sum_\\alpha\\hat{H}^\\alpha_{\\rm bath} + \\hat{H}_{\\rm ex} \\\\  \\hat{H}_{\\rm ex} = \\sum_{\\alpha\\alpha'}\\hat{M} \\left[\\hat{H}^{\\alpha}_{\\rm hyb} \\hat{O} \\frac{1}{E_{G} - (\\hat{H}_{\\rm mol}+\\hat{H}_{\\rm gate})} \\hat{O} \\hat{H}^{\\alpha'}_{\\rm hyb}  \\right] \\hat{M} \\; ,\n",
        "$$\n",
        "where the conjugate space is $\\hat{O} = \\hat{\\mathbb{1}} - \\hat{M}$. To simplify the notation we combine all orbitals of the impurity, which hybridize with lead $\\alpha$, in to a frontier orbital\n",
        "$$\n",
        "\t\\bar{\\hat{d}}^\\dagger_{\\alpha\\sigma} = \\frac{1}{V_\\alpha}\\sum_i V_{\\alpha i}\\hat{d}^\\dagger_{i\\sigma} \\; ,\n",
        "$$\n",
        "with $V^2_\\alpha = \\sum_i |V_{\\alpha i }|^2$, while $\\hat{c}_{\\alpha\\sigma 0}$ remain the frontier orbitals of the leads.\n",
        "When inserting the equations the exchange Hamiltonian can be expressed as\n",
        "$$\n",
        "\t\\hat{H}_{\\rm ex} = \\sum_{\\substack{\\alpha\\alpha' \\\\ \\sigma\\sigma'}}V_{\\alpha}V_{\\alpha'}\\hat{c}^\\dagger_{\\alpha 0 \\sigma}\\hat{c}_{\\alpha' 0 \\sigma'}\\sum_{\\mathbf{q},\\mathbf{q}' \\in \\mathbb{q}_{GS}} A^{\\alpha\\alpha'\\sigma\\sigma'}_{q_1 q_2 \\dots q_1'q_2'\\dots} \\ket{N,\\mathbf{Q}_{GS},\\mathbf{q}}\\bra{N,\\mathbf{Q}_{GS},\\mathbf{q}'} \\; ,\n",
        "$$\n",
        "where we have introduced the cotunnelling amplitude $A^{\\alpha\\alpha'\\sigma\\sigma'}_{q_1 q_2 \\dots q_1'q_2'\\dots}$. \n",
        "The hybridization term either adds (by means of $\\bar{\\hat{d}}^\\dagger_\\alpha$) or removes (by means of $\\bar{\\hat{d}}_\\alpha$) an electron from the molecule. The full cotunnelling amplitude can be decomposed in to the contribution from creating an electron (partiitcle $p$) and destroying an electron (hole $h$) \n",
        "$$\n",
        "\tA^{\\alpha\\alpha'\\sigma\\sigma'}_{q_1 q_2 \\dots q_1'q_2'\\dots} = h^{\\alpha\\alpha'\\sigma\\sigma'}_{q_1 q_2 \\dots q_1'q_2'\\dots} + p^{\\alpha\\alpha'\\sigma\\sigma'}_{q_1 q_2 \\dots q_1'q_2'\\dots} \\;.\n",
        "$$\n",
        "The particle and hole contributions are respectively given gy\n",
        "$$\n",
        "\th^{\\alpha\\alpha'\\sigma\\sigma'}_{q_1 q_2 \\dots q_1'q_2'\\dots} = \\sum_{\\tilde{\\mathbf{q}},\\tilde{\\mathbf{Q}}} \n",
        "\t\\frac{\\bra{N,\\mathbf{Q}_{GS},\\mathbf{q}}\\bar{\\hat{d}}^\\dagger_{\\alpha'\\sigma'}\\ket{N-1,\\tilde{\\mathbf{Q}},\\tilde{\\mathbf{q}}}\\bra{N-1,\\tilde{\\mathbf{Q}},\\tilde{\\mathbf{q}}}\\bar{\\hat{d}}_{\\alpha\\sigma}\\ket{N,\\mathbf{Q}_{GS},\\mathbf{q}'}}{E_{N-1,\\tilde{\\mathbf{Q}},\\tilde{\\mathbf{q}}}-E_{G}} \\; , \\\\\n",
        "\tp^{\\alpha\\alpha'\\sigma\\sigma'}_{q_1 q_2 \\dots q_1'q_2'\\dots} = \\sum_{\\tilde{\\mathbf{q}},\\tilde{\\mathbf{Q}}} \n",
        "\t\\frac{\\bra{N,\\mathbf{Q}_{GS},\\mathbf{q}}\\bar{\\hat{d}}_{\\alpha\\sigma}\\ket{N+1,\\tilde{\\mathbf{Q}},\\tilde{\\mathbf{q}}}\\bra{N+1,\\tilde{\\mathbf{Q}},\\tilde{\\mathbf{q}}}\\bar{\\hat{d}}^\\dagger_{\\alpha'\\sigma'}\\ket{N,\\mathbf{Q}_{GS},\\mathbf{q}'}}{E_{G}-E_{N+1,\\tilde{\\mathbf{Q}},\\tilde{\\mathbf{q}}}} \\; .\n",
        "$$\n",
        "The particle- and hole-cotunnelling amplitudes can be interpreted as follows: the numerator gives the likelihood for an electron to tunnel from the state $\\ket{N,\\mathbf{Q}_{GS},\\mathbf{q}}$ to the excited state $\\ket{N\\pm1,\\tilde{\\mathbf{Q}},\\tilde{\\mathbf{q}}}$ and back to $\\ket{N,\\mathbf{Q}_{GS},\\mathbf{q}'}$, akin to Fermi's golden rule. The denominator $1/(E_{G}-E_{N+1,\\tilde{\\mathbf{Q}},\\tilde{\\mathbf{q}}})$ corresponds to the lifetime of the excited state. Combining both terms gives the transition amplitude from one state of the \\gs{} manifold to another.\n",
        "\\end{sloppypar}\n",
        "\n",
        "As with the SWT for the anderson impurity model, computing concludes the calculation of the effective exchange Hamiltonian. However, more physical insight can be gained when further analysing the symmetries of $A^{\\alpha\\alpha'\\sigma\\sigma'}_{q_1 q_2 \\dots q_1'q_2'\\dots}$. The effective model must have same symmetries as the bare model thus allowing to greatly simplify the cotunnelling amplitude. Depending on these symmetries the cotunnelling amplitude might be factorized in many different ways. The precise decomposition depends on the details of the system and its symmetries. However, one very important example is when the model is $\\textrm{S} = SU(2)$ spin-symmetric and the ground state hosts a degenerate doublet \\gs{} manifold ($S = 1/2$). This is the identical situation found in the anderson impurity model, meaning that the same decomposition of the cotunnelling amplitude can be performed using the Pauli matrices (being of course the generators of $SU(2)$)\n",
        "$$\n",
        "A^{\\alpha\\alpha'\\sigma\\sigma'}_{m m'} = \\tfrac{1}{4}[\\mathbb{J}]_{\\alpha\\alpha'}\\sum^3_{i=1}\\sigma^i_{\\sigma\\sigma'}\\times\\sigma^i_{m m'}\n",
        "+ \t[\\mathbb{W}]_{\\alpha\\alpha'}\\delta_{\\sigma\\sigma'}\\delta_{\\alpha\\alpha'}\\;,\n",
        "$$\n",
        "where $m$ is the magnetic spin quantum number. The first term of $A^{\\alpha\\alpha'\\sigma\\sigma'}_{m m'}$ contributes a spin-scattering term and second term constitutes a potential scattering, just as we found with the SWT for the anderson impurity model. The difference is that the exchange couplings have now the form of matrices. The diagonal components correspond to scattering in and out of the same lead and off-diagonal components to scattering out of one lead and in to an other. If one the components of $\\mathbb{J}$ vanishes, it means that some of the virtual processes interfere destructively in a manifestation of many-body interference."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.4\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.3959183673469388\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.3918367346938776\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.38775510204081637\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.38367346938775515\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.3795918367346939\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.37551020408163266\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.37142857142857144\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.3673469387755102\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.363265306122449\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.3591836734693878\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.35510204081632657\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.3510204081632653\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.3469387755102041\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.34285714285714286\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.33877551020408164\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.3346938775510204\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.3306122448979592\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.326530612244898\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.3224489795918367\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.31836734693877555\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.3142857142857143\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.31020408163265306\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.30612244897959184\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.3020408163265306\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.2979591836734694\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.2938775510204082\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.28979591836734697\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.2857142857142857\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.28163265306122454\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.27755102040816326\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.27346938775510204\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.2693877551020408\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.2653061224489796\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.2612244897959184\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.2571428571428571\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.25306122448979596\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.2489795918367347\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.24489795918367346\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.24081632653061225\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.23673469387755103\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.2326530612244898\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.2285714285714286\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.22448979591836735\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.22040816326530613\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.2163265306122449\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.21224489795918366\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.20816326530612245\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.20408163265306123\n",
            "Operators were summed\n",
            "GS quantum numbers:  ['Q0S-1S-1.00S0.75', 'Q0S-1S1.00S0.75', 'Q0S1S-1.00S0.75', 'Q0S1S1.00S0.75']\n",
            "Done Vg = -0.2\n"
          ]
        }
      ],
      "source": [
        "num_points = 50\n",
        "thevalVg = 0.\n",
        "thetens = 0.\n",
        "Jvec = np.zeros((num_points,2,4))\n",
        "Wvec = np.zeros((num_points,2,4))\n",
        "Vgset = np.linspace(-0.4,-0.2,num_points)\n",
        "#####################\n",
        "# second order BW-peturbation-theory routine\n",
        "#####################\n",
        "for enu,Vg in enumerate(Vgset):\n",
        "    eps_ham = n_all.copy()\n",
        "    eps_ham.ScalarDot(Vg)\n",
        "    eps_ham.OperatorSum(ham)\n",
        "    par_ham_val,par_ham_vec,new_ham_qn_dict,GS_QNset = SuperBlockDiagonalization(symmetry_set,eps_ham,\\\n",
        "                                                                                 BlockOperator=False,SuperTrafo=basistrafos)\n",
        "\n",
        "    # particle amplitude\n",
        "    particle_amplitude = np.zeros((2,2,2,2,2,2,2)) # channel_in,channle_out,cran_in,cran_out,spin_in,spin_out\n",
        "    # get ground state\n",
        "    for h1,QN_string_in in enumerate(GS_QNset):\n",
        "        # print(\"\\n GS QN: \",QN_string_in)\n",
        "        #par_ham_val = []\n",
        "        QNint = [float(x) for x in QN_string_in[1::].split(\"S\")]\n",
        "        # getting the cotunnelling quantum number indeces\n",
        "        par_in =int(0.5*(1+QNint[2]))\n",
        "        spin_in=int(0.5*(1+QNint[1]))\n",
        "        # print(\"gs spin: \",spin_in)\n",
        "        ham_qn_ind = new_ham_qn_dict[QN_string_in]\n",
        "        gs_vec_in = par_ham_vec[ham_qn_ind][:,0]\n",
        "        gs_val = par_ham_val[ham_qn_ind][0]\n",
        "        # print(\"Groundstate energy: \",par_ham_val[ham_qn_ind][0])\n",
        "        # loop over all creation operators\n",
        "        for f,ad_in in enumerate(all_cd_sets):\n",
        "            if not QN_string_in in all_cd_dict[f]: continue\n",
        "            cran_ind = all_cd_dict[f][QN_string_in]\n",
        "            # collecting the virtual states\n",
        "            virtual_state = []\n",
        "            operated_GS = []\n",
        "            # c^\\dagger |0>\n",
        "            # operato on ground state\n",
        "            for i in cran_ind:\n",
        "                operated_GS += [np.dot(ad_in[i],gs_vec_in)]\n",
        "                virtual_state += [all_cd_out[f][i]]\n",
        "            # < N+1;i|c^dagger|0>\n",
        "            # multiply virtual state\n",
        "            for i,qn in enumerate(virtual_state):\n",
        "                virtual_qn = \"Q%.iS%.i\"%(qn[0],qn[1])\n",
        "                for addon in qn[2::]:\n",
        "                    virtual_qn += \"S%.2f\"%(addon)\n",
        "                # print(\"virtual_qn \",virtual_qn)\n",
        "                ham_qn_ind = new_ham_qn_dict[virtual_qn]\n",
        "                virtual_vec = par_ham_vec[ham_qn_ind]\n",
        "                virtual_energies = par_ham_val[ham_qn_ind]\n",
        "                inter_cott_right = np.dot(virtual_vec.T,operated_GS[i])\n",
        "                # multiply <0|c|N+1>\n",
        "                for j,a_out in enumerate(all_c_sets):\n",
        "                    if not virtual_qn in all_c_dict[j]: continue\n",
        "                    cran_par_ind = all_c_dict[j][virtual_qn]\n",
        "                    for par_ind in cran_par_ind:\n",
        "                        return_qn = all_c_out[j][par_ind]\n",
        "                        # run over second ground state to close the loop\n",
        "                        for h2,QN_string_out in enumerate(GS_QNset):\n",
        "                            # print(\"\\n GS QN: \",QN_string)\n",
        "                            #par_ham_val = []\n",
        "                            QNint_out = [float(x) for x in QN_string_out[1::].split(\"S\")]\n",
        "                            par_out =int(0.5*(1+QNint_out[2]))\n",
        "                            spin_out=int(0.5*(1+QNint_out[1]))\n",
        "                            ham_qn_ind_out = new_ham_qn_dict[QN_string_out]\n",
        "                            gs_vec_out = par_ham_vec[ham_qn_ind_out][:,0]\n",
        "                            # check for which creation anihilation operator the loop closes\n",
        "                            if return_qn == QNint_out:\n",
        "                                operated_virtual_vec = np.dot(a_out[par_ind],virtual_vec)\n",
        "                                inter_cott_left = np.dot(gs_vec_out.T,operated_virtual_vec)\n",
        "                                #print(inter_cott_right,inter_cott_left)\n",
        "                                # compute cottunnelling amplitude:\n",
        "                                inter_cott = sum(inter_cott_right*inter_cott_left/(gs_val-virtual_energies))\n",
        "                                #######\n",
        "                                # the creation/anihilation operators contribute a channel and a spin index to the tensor\n",
        "                                # here we accumulate the corresponding indeces\n",
        "                                in_index = all_cd_index[f]\n",
        "                                out_index = all_cd_index[j]\n",
        "                                ######\n",
        "                                # enforce that the incoming and outcoming parity are identical\n",
        "                                if par_in != par_out: continue\n",
        "                                ######\n",
        "                                particle_amplitude[par_in,\\\n",
        "                                                   in_index[0],out_index[0],\\\n",
        "                                                   in_index[1],out_index[1],\\\n",
        "                                                   spin_in,spin_out] += inter_cott * V**2\n",
        "\n",
        "    # hole amplitude\n",
        "    hole_amplitude = np.zeros((2,2,2,2,2,2,2)) # channel_in,channle_out,cran_in,cran_out,spin_in,spin_out\n",
        "    # get ground state\n",
        "    for h1,QN_string_in in enumerate(GS_QNset):\n",
        "        #print(\"\\n GS QN: \",QN_string_in)\n",
        "        #par_ham_val = []\n",
        "        QNint = [float(x) for x in QN_string_in[1::].split(\"S\")]\n",
        "        # getting the cotunnelling quantum number indeces\n",
        "        spin_in=int(0.5*(1+QNint[1]))\n",
        "        par_in =int(0.5*(1+QNint[2]))\n",
        "        # print(\"gs spin: \",spin_in)\n",
        "        ham_qn_ind = new_ham_qn_dict[QN_string_in]\n",
        "        gs_vec_in = par_ham_vec[ham_qn_ind][:,0]\n",
        "        gs_val = par_ham_val[ham_qn_ind][0]\n",
        "        # print(\"Groundstate energy: \",par_ham_val[ham_qn_ind][0])\n",
        "        # loop over all creation operators\n",
        "        for f,a_in in enumerate(all_c_sets):\n",
        "            if not QN_string_in in all_c_dict[f]: continue\n",
        "            cran_ind = all_c_dict[f][QN_string_in]\n",
        "            # collecting the virtual states\n",
        "            virtual_state = []\n",
        "            operated_GS = []\n",
        "            # c^\\dagger |0>\n",
        "            # operato on ground state\n",
        "            for i in cran_ind:\n",
        "                operated_GS += [np.dot(a_in[i],gs_vec_in)]\n",
        "                virtual_state += [all_c_out[f][i]]\n",
        "                # print(virtual_state)\n",
        "            # < N+1;i|c^dagger|0>\n",
        "            # multiply virtual state\n",
        "            for i,qn in enumerate(virtual_state):\n",
        "                virtual_qn = \"Q%.iS%.i\"%(qn[0],qn[1])\n",
        "                for addon in qn[2::]:\n",
        "                    virtual_qn += \"S%.2f\"%(addon)\n",
        "                ham_qn_ind = new_ham_qn_dict[virtual_qn]\n",
        "                virtual_vec = par_ham_vec[ham_qn_ind]\n",
        "                virtual_energies = par_ham_val[ham_qn_ind]\n",
        "                inter_cott_right = np.dot(virtual_vec.T,operated_GS[i])\n",
        "                # multiply <0|c|N+1>\n",
        "                for j,ad_out in enumerate(all_cd_sets):\n",
        "                    if not virtual_qn in all_cd_dict[j]: continue\n",
        "                    cran_par_ind = all_cd_dict[j][virtual_qn]\n",
        "                    for par_ind in cran_par_ind:\n",
        "                        return_qn = all_cd_out[j][par_ind]\n",
        "                        # run over second ground state to close the loop\n",
        "                        for h2,QN_string_out in enumerate(GS_QNset):\n",
        "                            # print(\"\\n GS QN: \",QN_string)\n",
        "                            #par_ham_val = []\n",
        "                            QNint_out = [float(x) for x in QN_string_out[1::].split(\"S\")]\n",
        "                            # getting the cotunnelling quantum number indeces\n",
        "                            par_out =int(0.5*(1+QNint_out[2]))\n",
        "                            spin_out=int(0.5*(1+QNint_out[1]))\n",
        "                            ham_qn_ind_out = new_ham_qn_dict[QN_string_out]\n",
        "                            gs_vec_out = par_ham_vec[ham_qn_ind_out][:,0]\n",
        "                            # check for which creation anihilation operator the loop closes\n",
        "                            if return_qn == QNint_out:\n",
        "                                operated_virtual_vec = np.dot(ad_out[par_ind],virtual_vec)\n",
        "                                inter_cott_left = np.dot(gs_vec_out.T,operated_virtual_vec)\n",
        "                                # compute cottunnelling amplitude:\n",
        "                                inter_cott = sum(inter_cott_right*inter_cott_left/(virtual_energies-gs_val))\n",
        "                                #######\n",
        "                                # the creation/anihilation operators contribute a channel and a spin index to the tensor\n",
        "                                # here we accumulate the corresponding indeces\n",
        "                                in_index = all_cd_index[f]\n",
        "                                out_index = all_cd_index[j]\n",
        "                                ######\n",
        "                                # enforce that the incoming and outcoming parity are identical\n",
        "                                if par_in != par_out: continue\n",
        "                                ######\n",
        "                                hole_amplitude[par_in,\n",
        "                                               out_index[0],in_index[0],\\\n",
        "                                               out_index[1],in_index[1],\\\n",
        "                                               spin_in,spin_out] += inter_cott* V**2\n",
        "\n",
        "    # channel_in,channle_out,cran_in,cran_out,spin_in,spin_out\n",
        "    cottunelling_amplitude = hole_amplitude+particle_amplitude\n",
        "    #print(cottunelling_amplitude)\n",
        "\n",
        "    ######################\n",
        "    # decompose the con tunnelling tensor\n",
        "    ######################\n",
        "    new_tensor = np.zeros((2,4,2,2),dtype=complex)\n",
        "    for px in range(2):\n",
        "        for n in range(4):\n",
        "            for (i,j) in it.product([0,1], repeat=2):\n",
        "                for (a,b,c,d) in it.product([0,1], repeat=4):\n",
        "                    new_tensor[px,n,i,j] += cottunelling_amplitude[px,i,j,a,b,c,d]*pli[n][a,b]*pli[n][c,d]\n",
        "    # we account for the SU(2) symme\n",
        "    assert new_tensor.all() == np.real(new_tensor).all()\n",
        "    Jvec[enu] = np.real(new_tensor[:,0,:,:]).reshape(2,4)/3.\n",
        "    # the potential scattering is not accounted for by SU(2)\n",
        "    Wvec[enu] = np.real(new_tensor[:,-1,:,:]).reshape(2,4)\n",
        "    print(\"Done Vg =\",Vg)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Final coupling parameters for the effective Hamiltonian"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {},
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n",
        "import matplotlib.colors as colors\n",
        "\n",
        "from matplotlib import rc\n",
        "#rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})\n",
        "rc('text', usetex=True)\n",
        "plt.rcParams['figure.facecolor'] = 'white'\n",
        "\n",
        "tickfont = 16\n",
        "labelfont = 18\n",
        "ucdblue = '#008ac9ff'\n",
        "ucdred = '#b40000fe'\n",
        "ucdgreen = '#4cb72fff'\n",
        "\n",
        "np_load_old = np.load\n",
        "np.load = lambda *a,**k: np_load_old(*a, allow_pickle=True, **k)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 0 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABDYAAAJTCAYAAADzOpafAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAABcSAAAXEgFnn9JSAADzuElEQVR4nOzdeVwc9f0/8NdyJZCDBXKfsCQeiVGzkHgfTRbvoyoE69VaDWittlbNiq1W2/6Mi/ZrW9sqxKNWW0vAox71YON9B9aYmESTsLnvAAsJCff+/ng7zC7swgKzO7vL6/l4fB47Mzs782FD2Nn3vD/vj8HtdrtBRERERERERBSBYvTuABERERERERHRQDGwQUREREREREQRi4ENIiIiIiIiIopYDGwQERERERERUcRiYIOIiIiIiIiIIhYDG0REREREREQUsRjYICIiIiIiIqKIxcAGEREREREREUUsBjaIiIiIiIiIKGIxsEFEREREREREEYuBDSIiIiIiIiKKWAxsEBEREREREVHEYmCDiIiIiIiIiCJWnN4dICKKFBUVFXA6naitrYXT6URRURHMZrPe3SIiIqIg4zUAUXgzuN1ut96dICIKd8XFxbBYLF0XMQ6HA3l5eaipqdG5Z0RERBRMvAYgCn8cikJE1Ae73Q6z2ex1Z6aurg5Go1G/ThEREVHQ8RqAKDIwsEFE1IfKykpYLBavbVarFUVFRTr1iIiIiEKB1wBEkYGBDSKiPqSlpcHpdCIvLw9ZWVlISUlBUVERcnNz9e4aERERBRGvAYgiA2tsEBH1wuFwoK6uDtnZ2Vi+fDlSU1PhdDqxcuVKlJeX6909IiIiChJeAxBFDgY2iIh6UVpaioKCgh7bDQYD6uvrOcaWiIgoSvEagChycCgKEQ1JTqcTOTk5yMnJQUpKCgwGA1JSUpCTkwOHw9G1n8vl8vl6o9GIqqqqEPWWiIiISktLu4aDKJ/bWVlZcDqdXfvY7fYen+1ZWVmw2+1ex3I6ncjMzITBYIDBYEBmZiYqKiq89uE1AFHkYMYGEQ15hYWFKC0tRUlJSY87M8XFxViyZInXNpfLhZSUFN6tISIi0kFKSgpcLhdqampgMpl87pOTkwO73Y7y8vJe62FkZmaisLCwx2c9wGsAokjCjA0iGvKUuy6LFi3y2u5yuVBbW9tj/9LSUlgsFl7QEBER6SA1NbXPffwFPDy5XC5YLBafQQ1eAxBFlji9O0BEpDeHwwGTydTjIsVut3ultyrbSkpKUF1dHcIeEhERkUL5vPY3VARQb1rU1dX53Wfp0qWw2Ww+n+M1AFFkYWCDiIY0Zcxt9znqARl/u2zZMhQXFwMAampqkJmZiZqampD2kYiIiFQmk6lrxhJfSktLu/bxF/xwOBzIzMz0m3nBawCiyMLABhENacp0bXl5eT6fNxqNPlNUiYiISB/KUBR/QYuamhrk5OSgoqLCbyCipKQEJSUlvZ6H1wBEkYM1NohoSFMyNrKzs3XuCREREQVCybLoPlQEkIKfRUVFXcEPX1kdFRUVKCwsDGofiSi0GNggoiHL5XLB6XTCbDb3SEVVthMREVF4SUtLA4AexT2dTieMRiOMRmNX8VBfWR0rV67s9TOe1wBEkYeBDSIasnqrr+FwOJjFQUREFIb8FQ/1nLZd2ad7xoaS0dEbXgMQRR7W2CCiIauyshKAzHXfXW9z3hMREZF+lGwMz6BFRUUF8vPzu9Z91eHwzOjoDa8BiCIPMzaIaMjqLWODiIiIwpOvoEX34SW+MjY8MzqIKLowsEFEQ5JnfQ0iIiKKHN2DFr0NL1GCH3a73WeGJhFFBwY2iCjqKZkZnpYvXw4gtNkaFRUVyMzMDNn5iIiIopGSseF0OnsdXuJZQLSyslK3DE1+/hMFHwMbRBTVsrKyuuay91ReXg4AIZ3ubenSpcwQISIiGiTP4qG9DS9R9rNarX0WDA0mfv4TBR+LhxJRVHM4HDCbzV53aZxOJ+x2O3Jzc7vu5gSby+WCw+HAsmXLQnI+IiKioaC34SVKZkdmZmafBUODhZ//RKHBwAYRRbXc3Nyu7AxALjBycnJgsVi8tgfb8uXLYbFYeMeGiIhIAyaTqceNi+6MRiNMJhOWLFkSwp554+c/UWgwsEFEUW3ZsmWwWq1d6w6HAzabrc+p3EpLS1FTUwNAMjxsNpvf7I5A9i0pKeHdGiIiIo2YTCbYbLY+9+nvkFN+/hNFJgY2iCiqGY3GPi98usvJyYHZbO56XUVFBXJyclBTUwOXy4Xly5d3jecNZN9FixYhNTWVd2uIiIg0UllZ2ec+/PwnGjoMbrfbrXcniIjCRXFxMUpKSrruwCgMBgOqq6tRVVWFRYsWwWg09mtfl8ul2/heIiIi6h0//4kiG2dFISLyYLVafaatGo1GVFVVoaamxqvKeqD78qKGiIgofPHznyiyMWODiOh7TqcTmZmZqK6u7pE2qsw/X11dDaPR2K99iYiIKHzx858o8rHGBhHR91wuFwD4LBJmNBphsVi6LlT6sy8RERGFL37+E0U+DkUhIvqe2WyGyWRCVVWV13ar1dp1IQPInZ3+7EtEREThi5//RJGPQ1GIiDw4nU5YrVaYTCakpaUBAAoKClBXV4fCwkLk5OSgoKCgKx010H2JiIgofPHznyiyMbBBRERERERERBGLQ1GIiIiIiIiIKGIxsEFEREREREREEYuBDSIiIiIiIiKKWAxsEBEREREREVHEitO7AxRcEyZMQFNTE6ZNm6Z3V4iIiAAA27Ztw4gRI7Bnzx69uxIV+FlPREThJtSf9czYiHJNTU1oa2vTuxtERERd2tra0NTUpHc3ogY/64mIKNyE+rOeGRtRTrl7s3btWp17QkREJGbPnq13F6IKP+uJiCjchPqznhkbRERERERERBSxGNggIiIiIiIioojFwAYRERERERERRSwGNoiIiIiIiIgoYjGwQUREREREREQRi4ENIiIiIiIiIopYnO6ViIiIiIgoArjdbrjdbr27QUOIwWCAwWDQuxt9YmCDiIiIiIgoDLndbhw8eBCNjY04fPgwOjo69O4SDUGxsbFISkrC6NGjMWrUqLAMdDCwQUREREREFGY6OzuxZ88eNDQ06N0VGuI6Ojpw8OBBHDx4EEajEePHj0dMTHhVtWBgg4iIiIiIKMw0NDR0BTVSU1MxatQoDBs2LCzvllP0crvdaGlpwcGDB1FXVweXy4Xhw4cjJSVF7655YWCDiIiIiIgozNTX1wMAxo0bh7S0NJ17Q0NZUlISkpKSEBcXh3379qG+vj7sAhvhlT9CREREREQ0xCl3yQFg9OjROveGSCi/iy0tLWFXxJaBDSIiIiIiojDi+aUxNjZWx54QqTx/FxnYICIiIiIiIiLSCAMbRERERERERBSxGNggIiIiIiIioojFwAYREREReWtv17sHRES6KS0tRWZmJioqKvTuCgWIgQ0KTEUF8MMfAmYz8Otf690bIiIi0trLLwOzZwNJScCECXr3hohINy6XC06nU+9uBI3D4UBmZiZcLpfeXdFMnN4doAjhdAL//a8sT5umb1+IiIhIe9u2AevWyfKRI0BrK5CQoG+fiIh0sGTJEixZsqTH9oqKChiNRlgsFh16NTgulwuLFy9Gamoqqqqqoi5ww4wNCoxnMGPbNv36QURERMHxox95r7/xhj79ICIKU0uXLkV5ebne3fBit9tRWlra535GoxHl5eUoKSlBfn5+CHoWWgxsUGAY2CAiIopu48YBiYnq+iuv6NYVIiIKjMvliqohJQPFwAYFxjOwUVsLNDXp1xciIiIKjvR0dfnzz3XrBhFRdw6HA1lZWXA4HCguLkZWVhYMBgNycnJ6DKtwuVwoLi5GZmYmDAYDMjMzUVxc7LWP3W5HSkoKnE4n7HY7srKykJOTA0CGnBgMBjgcDgBAYWFh13ppaSkMBgMMBgOsViusVisMBoPPoR3Kc56BB6XPpC3W2KDATJwIxMYCHR2yvn07cMwx+vaJiIiItHXqqcD69bK8dau+fSGi3rndQEOD3r3on+RkwGAY0Evr6uq6ghu5ubkoLCxEZWUlKioqkJWVhc2bN8NoNAKQoMXSpUtRVFQEs9kMh8MBq9WK2tpa2Gy2rmO6XC5UVFTAarXCbDYjLy/P57ltNhsKCwuxcOFCZGdndx3DZDIBAIqLi1FSUuJ1bEBmV8nNze3qFwBYLBaYzeYBvQfkHwMbFJjYWGDKFPUiZ9s2BjaIiIiizeWXA089JcstLcCOHfL5T0Thp6EBSEnRuxf9U18PeHzJHwibzdZV2LOgoADFxcWwWq0oLS3t2m6xWFBfX9/1GovFgpUrV6K4uLhH8MFqtaKkpAQFBQV+z2k0GmE2m5GamgqTydQjMJGbm4vS0lKvY9vtdrhcLhQWFnrtW1lZObAfnHrFoSgUOM/hKNu369cPIiIiCo5zzvFef+EFffpBRORH96DCkiVLYDQaUVZW1rXN6CN4ogz/UIaXKCwWS69BjUAUFhZ2ZX8oSkpKYDKZInIGlUjEjA0KHAuIEhERRbe4OCAtTeppAUBlJXDXXfr2iYioD9nZ2aiqqup1n9TUVAAypMWTv+En/WGxWGAymVBSUoLc3FwAUqeje3bIYBQWFsJut/fYrvw8JSUlPZ4zm81hN4tLsDCwQYGbOlVdZmCDiIgoOs2eDXz4oSyvXq1vX4jIv+RkGdoRSZKTg3LYurq6rsCFwm63o7y8HHa73WdhT4VSJ2OwrFZrV+aGEoAYbCaIJ1+BC0ACKE6ns2sYzlDFwAYFjhkbRERE0W/BAjWwsW8f0NkJxHD0MlHYMRgGXa8iEvma2tTpdCI7O7trXam5UVBQgPLycphMJtjtdp/ZGd0DIn3pnvGhKCgoQGFhIZYvX47KykpYLBafQ2IoOPgpRYFjYIOIiCj6XXWVuux2Ax9/rF9fiIi66Z59YbVaexTpLC4uRlFREWw2G8xmM4xGo9+ARH/5CqwolECK3W6H1WrV5HwUGGZsUOC6Fw/lHRwiIqLoM3MmEB8PtLXJenk5cOaZ+vaJiOh7SsDAZDKhrKwMFRUVMJvNXbUtlOeWLl0KAF7TvQ6W2WxGRUUFiouLUVtbC6fT6VXDwmq1IjMzE0aj0W/R0JycHJjNZk3rb/RX7fd1lOrq6qImq4TfSilwnoGNlhZg/379+kJERETB4znF60cf6dcPIqJuSkpKUFNTA6vVCrvdjoKCAlRXV3vtU15ejtTUVFitVuTl5aGmpgYlJSVdU7YOVFFREYxGI5YuXQqHw4H8/Hyv55WpYHurrWG323vMzBIqeXl5yMvLQ2lpqc/1SMaMDQpccjIwejTQ2Cjr27YB48fr2yciIiLSXnY2sHmzLG/apG9fiIg8mEymPotyms1m1NTU9Nju+TqLxQK32+3z9bm5uT6fM5vNqO+jYKvD4eh1JhJ/5wyFaJ4hhRkb1D+ss0FERBT9LrlEXW5qUm9qEBGRX6WlpV1Tv4aK0WiMmuEkg8GMDeqfadOAb76RZQY2iIiIotPllwPXXquuL18O3Hijfv0hIgpTLpcLVVVVXUNfQp0V4a+Wx1DDwAaksq7NZuuKdDmdThQVFcFsNgf9WKWlpV1jwurq6uB0OlFYWKjpnMea6l5AlIiIiKJPUhIwahRw8KCs/+9/DGwQEflQV1eHvLw8uFwuLFmyhIEGnQz5wIbD4UBeXh4qKyu7UoZcLheysrJgs9m8qutqfSyr1Yr8/HyvIIbD4UBWVhbKy8tRWVmpwU+oMQ5FISIiGhqOOgpQCvJ1K8xHRBRqvdXE0JPJZOqz7gYF35CvsZGXl4fCwkKvcVBGoxE2mw2LFy/udZ7iwRzL6XSiuLgYJSUlXscwm82wWCyw2+2w2+0D/rmChoENIiKiocFzitddu/TrBxERUR+GdGDDbrfD6XT6TBfKzc2Fy+UKeOqb/h5LCXJUVVX12N9zGEvYYWCDiIhoaPCcxrC9Xa2xRUREFGaGdGBDGerhr2qt0WhEWVlZUI6lTEG0YsWKHvsqAY3s7OyAzh1SU6eqy3v3As3N+vWFiIiIgmfePCDG41LxhRf06wsREVEvhnRgQxnq4W96HJPJBIfDEbRjmUymHvs7nU44HA5YLJYBFS8NusmTAYNBXd+xQ7++EBERUfDExADjx6vr77+vW1eIiIh6M6QDG06nU7M5f7U6VmFhIcxmc8inCQpYfDwwaZK6zuEoRERE0evEE9Xl9et16wYREVFvhnRgI9DCoIHsN5hjFRcXIy8vD5mZmTCbzaiuru53kGT27Nk+W01NTb+OExDW2SAiIhoazj9fXa6vB1pb9esLERGRH0M6sBGourq6oB5ryZIlXdO7Op1OZGVlhWfhUAUDG0REREODZwFRAHjjDX36QURE1Is4vTugJ62GoWh1LJPJhPLycmRlZSEzMxM1NTV+i5F2t3btWp/bZ8+ePeh+9cDABhER0dAwbhyQmAgcOSLrr7wCXHaZrl0iIiLqbkhnbKSmpmq2n5bHKiwsBADk5eUFdMyQY2CDiIho6MjIUJc//1y/fhAREfkxpAMbRqOx19oYynOBZGP091hOpxMVFRU+91WmeQ10RpaQ8wxsbN+uXz+IiIgo+E45RV3eulW/fhARhUhpaSkyMzP9fl+j8DOkAxtKAMFfQMLpdAY85Wp/j5WTk4O8vLw+/7MEWpQ0pLpnbLjd+vWFiIiIguvyy9XllhZO9U5EUc/lcoV3zcNBcjgcyMzMDM/vmgM0pAMbypAPX7+0yj9yfveiWRoey2g0+gycKMcwmUya1gHRjGdg4/BhQMPiqkRERBRmzjkHMBjU9Rde0K8vREQhsGTJErjdbuTm5nptr6iogN1u16lXg+NyuZCXl4fCwkIsXrw46gI3QzqwYTabYTKZUFZW1uO55cuXw2g0oqCgwGu7y+Xy+cvc32Pl5uaivLzcZ3FQ5RhWq7XfP1NIpKQAI0ao66yzQUREFL3i4gDPGmGVlfr1hYhIR0uXLkV5ebne3RgQo9GI8vJylJSUBHzzPpIM6cAGAJSXl6O0tNQrYuVyuWCz2bBixYoeGRN5eXnIyclBaWnpoI5ls9lQUlLSYyhKRUUFKioqUFBQ0COoEjYMBhYQJSIiGko8Z1lbvVq/fhAREfkw5AMbZrMZ1dXVsFqtsFqtKC4uxuLFi1FSUuJzmEhOTg6MRmNXTY3BHEuJ9uXl5XUFTEpKSlBZWYmSkhLtf1gtMbBBREQ0dCxYoC7v2wd0durXFyIakhwOB7KysuBwOFBcXIysrCwYDAbk5OT0GFbhcrlQXFyMzMxMGAwGZGZmori42Gsfu92OlJQUOJ1O2O12ZGVlIScnB4DcbDYYDF2TORQWFnatl5aWwmAwwGAwdH3vMxgMPod2KM951rJQ+kzaitO7A+HAZDIFnFK0ZMkSLFmyRJNjATIkpfvYrYgwdaq6zMAGERFRdLvqKuD++2XZ7QY+/hg480xdu0Q01LndQEOD3r3on+Rk75I9/VFXV9cV3MjNzUVhYSEqKytRUVGBrKwsbN68uStD3m63Y+nSpSgqKoLZbIbD4YDVakVtbS1sNlvXMV0uFyoqKmC1WmE2m5GXl+fz3DabDYWFhVi4cCGys7O7jqGUFSguLkZJSYnXsQGZXSU3N9crc99isQQ8QQUFjoENGhhmbBAREQ0dM2cC8fFAW5usl5czsEGks4YGKX0XSerrgcHOjWCz2bpuNBcUFKC4uBhWqxWlpaVd2y0WC+rr67teY7FYsHLlShQXF/cIPlitVpSUlPRaBkCZ9CE1NRUmk6lHYCI3NxelpaVex7bb7XC5XF2TTCgqWacoKIb8UBQaIAY2iIiIhpYpU9Tljz7Srx9ENKR1DyosWbIERqPRaxIHXzNLKsM/lOElCovFMujahoWFhV3ZH4qSkhKYTCZYLJZBHZsCw4wNGhgGNoiIiIaW7Gxg82ZZ3rBB374QEXnIzs5GVVVVr/ukfj+7U11dndd2f8NP+sNiscBkMqGkpKSrzEBFRUWP7JDBcLlcWLhwoVe9jr6Ul5cPmWEvDGzQwHgGNnbvltTU+Hj9+kNERETBdc01MgQFAI4cAV5/HbjoIn37RDSEJSfL0I5IkpwcnOPW1dV1BS4Udrsd5eXlsNvtPgt7KpQ6GYNltVq7MjfsdjsAaDrLpdFoRHV1tWbHizYMbNDAeKajut3Azp1Aerpu3SEiIqIgu+QSIDFRghoA8P/+HwMbRDoyGAZfryIS+cpYcDqdXrNWKjU3CgoKUF5eDpPJBLvd7jM7o3tApC/dMz4UBQUFKCwsxPLly1FZWQmLxeJzSAwFBwMbNDDDhgETJgB79sj6tm0MbBAREUW7c88FXnlFlr/8EmhtBRISdO0SEQ0t3bMvrFZrjyKdSpFQz9ks/QUk+qu3oSBKIKWqqqpfM2XS4DGwQQM3bZp3YIOIiIii2x/+oAY2OjuBP/0J8PjiQEQUbFarFYAMISkrK0NFRQXMZnNXbQvluaVLlwKA13Svg2U2m1FRUYHi4mLU1tbC6XR6BTCsVisyMzNhNBr9Fg3NycmB2WzWtP5Gf9XW1gKQYE+0ZJVwVhQaOBYQJSIiGlpmzwbGjVPXn3hCv74Q0ZBUUlKCmpoaWK1W2O12FBQU9Kg9UV5ejtTUVFitVuTl5aGmpgYlJSVdU7YOVFFREYxGI5YuXQqHw4H8/Hyv55WpYHurrWG323vMzBIqeXl5yMvLQ2lpqc/1SMaMDRo4BjaIiIiGnmuuAf7v/2R582Zg1y5g0iR9+0REQ4bJZOqzKKfZbEZNTU2P7Z6vs1gscLvdPl+fm5vr8zmz2Yz6Piq2OhyOXoeh+DtnKETz8BhmbNDAMbBBREQ09Nx7r1QtVNx3n359ISIKI6WlpV1Tv1JoMbBBA8fABhER0dBjNALHHquuv/iibl0hItKbMr2rUsdDi1oe1H8MbNDATZ2qLm/dKtO+EhERUfT7xS/UZZcL+OQT3bpCRKSnuro65OXlISsrCwUFBX6LhlJwscYGDZxnxsahQ0BDw9CcTJuIiKKO0+mEzWbrqhbvdDpRVFQEs9k84GPa7XZYrVaUl5dHfpryjTcCP/850NYm6/ffD1RW6tolIopuvdXE0JPJZOqz7gYFHwMbNHBjxwLDhgEtLbK+fTsDG0REFPEcDgfy8vJQWVnZFYBwuVzIysqCzWbzmlKwL1arFQ6HAyaTCU6nU7dK+JqLiQHOPBNYsULWP/hApn+NYTIwERGFHj99aOAMBtbZICKiqJOXl4fCwkKvrAqj0QibzYbFixfD5XIFfCybzYbKysquaQajygMPqMttbcDTT+vXFyIiGtIY2KDBYWCDiCjqvf66fIc9ckTvngSf3W6H0+n0OUY6NzcXLpcLpaWlOvQsDJ12mnem5qOP6tYVIiIa2hjYoMFhYIOIKKodOQLcdpuUUJg1C/joI717FFyV39eJ8FcDw2g0oqysLJRdCm9XXKEur18PNDbq1xeiKGLwmFK5s7NTx54QqTx/Fz1/R8MBAxs0OAxsEBFFtUceATZvluUdO4AxY/TtT7DZ7XYA6Coa2p3JZIqeOhla+N3v1GW323t4ChENmMFgQFyclENsbm7WuTdEQvldjIuLY2CDogwDG0REUWvrVuDBB9X1224Djj1Wv/6EgtPp9BvUIB8mTQIyMtT1f/1Lv74QRZlRo0YBAOrr68NyNhAaWtxud9fsL8rvZjjhrCg0OAxsEBFFrTvuAJQbhePHA7/9rb79CQWXyxVQYCPQ/bQ0e/Zsn9tramqQmZkZ0r54KSgAiopkee9eYO1awE9fiShwycnJqK+vx6FDh7Bjxw6kpKRg+PDhiOHsQxRCnZ2daG5u7vpdBOR3M9wwsEGD4xnY2LkTaG8H4vhrRUQU6ex24MUX1fXiYmD0aP36E27q6uqY2aH41a+AX/9apnsFgHvvBV56Sd8+EUWBxMRETJ48GTt37sShQ4e6vlQS6Wny5MlITEzUuxs98BsoDc7UqepyRwewe7f3NiIiijitrcCtt6rrp54KXHONfv0JpXAOVqxdu9bndn+ZHCGTkADMmwd88YWsv/WWvv0hiiKjR49GfHw8GhoacPDgQbS3t+vdJRqC4uLiMGrUKCQnJ4dlUANgYIMGKzERGDsW2L9f1rdtY2CDiCjCPfYY8O23smwwyPpQyXxOTU1FXV1dQPuRh3vuAS69VJaPHJF0H88ZU4howBITE5GYmIgJEybA7Xaz3gaFlMFgCLtCob4wsEGDN3WqGtjYvl3fvhAR0aDs3u09sUVhIWA269efUDMajXA6nX6fd7lcXfuRh0suAZKSgMOHZf13v2NggygIIuVLJlGoDZH7LxRULCBKRBQ17r4bOHhQllNTgT/8Qd/+hFp2djYANYDRndPphHkoRXr648IL1eXVq4F339WvL0RENKQwsEGDx8AGEVFU+PRT4J//VNf/8AcgLU2//uihsLAQAHxmbSjBjvz8/FB2KXI88QQQG6uuX3edfn0hIqIhhYENGjwGNoiIIl5HB/Dzn6vrJ54os3gONWazGSaTCWVlZT2eW758OYxGIwq6vTEulwt2uz1UXQxfqanA4sXq+s6dwOOP69cfIiIaMhjYoMFjYIOIKOItWwZ89ZW6/te/et98H0rKy8tRWlrqlbXhcrlgs9mwYsWKHvU18vLykJOTg9LS0l6PqxzP3zCXqPDYY1JrQ3HXXeo0sEREREHC4qE0eAxsEBFFtNpa4Ne/VtevvRY47TT9+qM3s9mM6upqWK1WmEwmpKWlYeXKlSgpKfFZXyMnJwdVVVVd9Tk8lZaWory8HHV1dXA4HACAhQsXdu1bUlICk8kU3B8olOLigIceAm67TdabmoBf/hL4y1907RYREUU3g5vzBUU1ZW77tWvXBu8ku3cDkyap642NwKhRwTsfERFp6qabgJISWR41CvjuO2DixOCdLySfTUNIWL6fkybJ9QEgqT8HDgCcSYaIaMgI9WcTh6LQ4I0fD8THq+uc8pWIKGK89ZYa1ACA3/42uEENGiKefVZd7ugArrpKv74QEVHUY2CDBi8mBpg6VV3ncBQiooiwbx/wk5+o63PmALfeqlt3KJrk5EgFWsWbbwLr1+vWHSIiim4MbJA2WGeDiCiiuN3ADTcAe/fK+rBhwL//DSQk6NsviiIVFYDBoK4vWqRfX4iIKKoxsEHa8AxsbN2qXz+IiCggTzwBvP66uv7ww8Bxx+nXH4pCmZnAxRer69984/1LR0REpBEGNkgbM2aoy6tX69cPIiLq0/r1wK9+pa5fcAHw85/r1x+KYs89JzOlKG64Qb++EBFR1GJgg7SRlaUuV1fr1w8iIupVS4vUcWxulvWxY4Gnn/YeMUCkmdGjZbpXxb59kh5ERESkIQY2SBuegY3du9Up3oiIKKz85jfAqlXq+jPPyORWREFjs0mAQ3HffUBrq379ISKiqMPABmlj/Hhg8mR1nVkbRERhx24HHnlEXb/lFuDCC/XrDw0RMTHAn/6krjc3A/n5unWHiIiiDwMbpJ3sbHW5qkq/fhARUQ+1tcCPf6yuH3ssRwRQCF1/PTB9urr+yivA3/+uW3eIiCi6MLBB2mGdDSKisOR2A4sXA7t2yXpCgkztmpiob79oiHnjDcneUNx6K+Bw6NcfIiKKGgxskHYY2CAiCkulpcDLL6vrS5cCJ56oW3doqJo9GygpUdc7O4GzzwYOHdKtS0REFB0Y2CDtdC8gqtwaJCIi3XzwgdwYV+TkeE9SQRRSN94o0/IoDh4ETj1Vv/4QEVFUYGCDtMMCokREYWXjRuDyy4G2NlkfNw74xz+8RwMQhdxzzwEzZ6rra9YAN92kX3+IiCji8dKGtOVZQJSBDSIi3dTXAxddBNTVyfqwYcCrrwKTJunbLyLExACffw4kJanbSkqAF17Qr09ERBTRGNggbbHOBhGR7tragNxcYMMGdduzzwInnaRfn4i8pKYC77wDGAzqtuuuA2pq9OsTERFFLAY2SFsMbBAR6crtBn72M+Ddd9Vtv/sdkJ+vX5+IfDrtNODBB9X19naJvrW26tcnIiKKSAxsUMCqq4EVK/rYiQVEiYh09eijwJNPqutXXQX85jf69YeoV3ffDZx7rrpeWwssXKhff4iIKCIxsEEB2bpVxmqfd56kM/vFAqJERLp59VXgzjvV9VNPBZ56yjvbnyjs/O9/wMSJ6vrHHwN5efr1h4iIIg4DG9Qnt1uuL/bskSzRn/wEuP9+2e4TC4gSEYXcqlWSnaH8bU5PB15+GRg+XM9eEQUgJgb48ksgIUHdVlEhd1OIiIgCwMAG9clgAP76V5kmUPHAAxLg8DkMlnU2iIhCatcu4OKLgaYmWR81Cnj9de+/20RhbcoU4M03gdhYddvbb0sdjs5O/fpFREQRgYENCsj8+TIz2zHHqNv++U+5meJyddvZM7BRVRWK7hERDVl79khJgh07ZD0mBli+HJg9W99+EfXbggXARx8B8fHqtk8/BcxmSRklIiLyg4ENClhGhlxfnHWWuu299+RmytatHjt6Bjb27GEBUSKiINm7V74Lfvutuu3Pf2YGP0WwU06RmyLDhqnbvv4amDWLs6UQEZFfDGxQv6SkSGbo1Ver29atA04+2SM5gwVEiYiCTglqrF+vbvvd74Cf/1y/PhFp4vjjgTVrgKQkddvGjcCMGcDhw/r1i4iIwhYDG9Rvw4YBzz3nPX3gnj2SyfH6699vYAFRIqKg2bdPhp+sW6due+AB4N579esTkaZmzgS++w4YPVrdtn27pI/2GANLRERDHQMbNCAGA/D738s0gnFxsu3wYeDSS4GHHgI657LOBhFRMOzfL0GNtWvVbb/9LXDfffr1iSgopkwBamqAtDR12759MuXP6tW6dYuIiMIPAxs0KD/9KfDGG1KBH5DC5UVFwGVvFsCFZNnIjA0iIk0cOCBBjW++Ubfde68ENoii0pgxgNMJTJyobmtoAE48Ue6kEBERgYEN0sA55wCffCI3UBSvfjEeWajGKpzAAqJERBpQghpr1qjbfv1rGYJiMOjXL6KgGz1aghsmk7rN7ZY7KaeeyrobRETEwAZpY84cScy44AJ1mxOZOAWf4Wlcz6wNIqJB2LcPsFi8s+/vuUeGBDKoQUPC8OFSQPTKK723f/YZMGGC3GEhIqIhi4EN0kxqKvDaa8Af/qBeaDcjETfgadxw32QcOaJv/4iIItG338rMU19/rW67+27vv7VEQ0JMDPDCC0BZGZCQoG4/eBA44wzJ4CAioiGJgQ3SVEyMpEa/8w4wdkRT1/anV5lx6qlSA4yIiALzwQfAKacAmzer25YsAR58kEENGsIWLQK2bgUyM9VtbrfU3Dj+eM6aQkQ0BDGwQUFhsQCOv3+BU/Bp17ZVqwCzWaaKdbv16xsRUSR4/nkgJ0f9jmYwAI88It/dGNSgIW/CBGDTJqCw0Hv7mjXA+PEsLEpENMQwsEFBM+Xc2XgfZ+MX+FPXtsZG4LrrgNxcmbKQiIi8ud3A734HXHst0NYm24YPB8rLgTvuYFCDyMsTTwD/+5/8J1G0tsqwlEmTgI8/1q9vREQUMgxsUPCMH4+EKePxJ9yOMizC6KS2rqdeekkKjr72mo79IyIKM62twPXXe0/fOnYs8N57wBVX6NcvorB2/vnA7t3ACSd4b9+9W2pvnH02UFenS9eIiCg0GNgA4HQ6UVhYCKvVCqvViry8PDgcjpAcy263Iy8vDzk5OcjMzEROTs6Azx2WsrIAAItQjjWLH8OCBepTe/cCl1wC3HijZHIQEQ1lLhdw3nnAs8+q244+Gvj8cykeSkS9MBplzOtzzwEjR3o/98EHwLhxUqCms1OP3hERUZAN+cCGw+FATk4OrFYrbDYbbDYbli1bhry8PFRUVAT1WMXFxXA4HCgvL0dlZSVqampgMpmQlZUFq9Wq1Y+or+8DGwAwbdO7qKwE/vxn74zRp56SmywffKBD/4iIwsC6dVIk9L331G1nnQV8+ilgMunXL6KIc801QH291N6I8bjM7egAHn5YUqDKyvTrHxERBcWQD2zk5eWhsLAQJo8rR6PRCJvNhsWLF8PVj8ra/TmW0+lEbW0tlixZ4nWMkpISmM1mFBcXw263D/jnChsegQ1UVyMmBrjtNsDhALKz1ae2bAF+8APg9tuBQ4dC3ksiIt384x/AvHkyravimmuAt9+WabSJqJ/i4qT2xtat3hcbgAxJufJKKTBaWqpP/4iIwtTatUBVld69GJghHdiw2+1wOp2wWCw9nsvNzYXL5UJpgB96/T1WSUkJ5s2b5/NYRd/Pw15SUhLQucOaZ2Bjzx5g1y4AwLHHyp3I++8HYmPlabcb+NOf5LmXX+bMKUQU3ZqagJ/8RGpqHD6sbr/vPuCf/wSGDdOta0TRYcoUYOVK4I03gLQ07+f27ZOsjtRU4P/+j0NUiGhIa2sD/vAHmcHy6quBI0f07lH/DenARmVlJQB4ZVh4MhqNKAswXbG/x3I4HMjLy/MZODGbzV37RLzx4+XCQuERAoyPlwJ5n38OHHOMusuOHcDll0v9jS1bQtdVIqJQWbtWsjQ862mkpgKvvw488ABnPiHS1AUXSCDjnnuAxETv5+rrZbqh5GT5z8cABxENMV99BcyfD9x7rxQx37BBbj5HmiEd2FCGehiNRp/Pm0ymgIML/T1WTk4OjEYjsrunSAL9Gv4SEboNR+kuO1uGpvzmNxLsULz+OjBrlkxF39oagn4SEQWZ2w0884wENdavV7efeqrUPbzwQt26RhTdYmKA//f/ZLzrAw8Ao0Z5P3/okFzJjxwpaVT79unSTSKiUGluBn79a7kmWbVK3T5litT5ijRDOrDhdDr9BiKCfawlS5agvr6+KzvDU9X3WQ2+notIfQQ2ALmB8vvfA6tXS60NxZEjMhX93LnAhx8GuZ9EREF06BDw4x8DP/2pd4qn1Qq8/z4wdapuXSMaOmJiZLyXywU8+iiQkuL9/JEjUvhm/Hjg+OOBF1/Uo5dEREH1+ecy7OTBB6W2sqKgAPjmG0l0izRDOrARaGZEIPtpeazy8nIAaq2NQMyePdtnq6mpCfgYQdM9sNFL8YxjjgFWrACef15mZlOsWyeRw2uvBbZtC2JfiYiC4KOP5ALiuefUbWlpMvT/oYe8s9WIKARiYoBf/lKKiS5b5n3RoVizBsjNleyOG28EDhwIeTeJiLR0+DDwq19Jpqhn5mhGhnwHKymRkXmRaEgHNgJVV1cXsmPZ7XbY7XYsWbIkOjM2PAqI+mMwSNGab78FbrrJe6z5888DRx0lWRwNDUHqLxGRRg4eBG65BTjzTGDjRnX76adL2mck3hEhijo33gjs3QuUlwOzZ/d8/tAhmZt+7FjJ4igpAdrbQ99PIqIBcruB116TP2GPPqreZzYYgF/8QuK4Cxbo28fBGtKBDa2GoWh1LJfLhby8POTm5sJms/XrtWvXrvXZMjMzB92vQeulgGhvUlKAxx8HPvtMhqIoWlrkDueMGcBjj0kVXyKicPPWW/Id6e9/V7fFxEhg9r33vP8sElEYyM2VHOzdu4HrrgOSknrus2aN3HUZPlyKhD3zDAuOElFYcziAhQtlYgbPZP6jjwY+/lhmpRwxQrfuaWZIBzZSU1M120+LYy1evBgWi6VrKEpUmT9fXX7nnX699KSTZLa2J58EJk5Utx84ANx2m3xxeOklTg9LROGhrk5qaZx/PrB9u7r9uOMkUPvgg0BcnH79I6I+TJggUxY1NUmqqOfUbYqODhle+9OfytzMJ58MvPACgxxEFDa2b5cYbVaW3FBRxMYCd98tmaOnnqpb9zQ3pAMbRqOx15oXynOBZGMM9lhWqxUAojOoAXiX+n/11X5HIWJjgRtukFTuBx7wjipu3AhccQVwxhkyjp2ISC8VFcCxxwL//Ke6TZnaurraO8ZLRBHg6qtlIPrOnfINoXuxUUCGpXzxBXDVVRLkOPFEmYEl2ma5I6KI0Ngos50cdZR3bS8AOOccyeBYulQSz6LJkA5sKFOt+gtIOJ3OgOtcDOZYpaWlcDqdPYIaTqczoHNHhIsuUotl7NghEyYPwIgRUsx80yap2hvj8Rv8yScyjn3BAuCDDzToMxFRgDZsAC6+GMjL854lct48CWjcfz+QkKBb94hosCZNkiyOujoZjpKX57vCXns78PXXMod9Sopkf1x9taRrEREFUUuLDOOfOVOyQ5ub1eeOO06GyL79ttTZiEZDOrBRWFgIwHcAQQlQ5OfnB/VYdrsdlZWVPjM1+ltnI6yNGweccoq6/uqrgzrchAlSu2v1au9kEEBSrc4+W6aNff/9QZ2GiKhX9fXA7bfLkLjXX1e3Dx8OPPKIfJeZM0e//hFREBx3HLB8uWRkrFwJXHYZMHKk73337gX+/W/J91bqctx3H6d4IyLNNDVJnYzMTOBnP/O+wTJhggznX7UKOPfcAA7W2gps3hykngbXkA5smM1mmEwmlJWV9Xhu+fLlMBqNKCgo8Nrucrlgt9s1OZaSpRG1w0+6u+QSdXmQgQ2F8mXi3XdllgFP778vwY2zz5ZgB2twEJFW2tqAv/5Vihj/6U/eEyScfbbc0L3jDhlGR0RRLDtbCn0dPAh8+aVkZ0yY4HvflhZJ4fr974Hp0yUNdf58GWO7Y0do+01EEc/lklFv6elyk2XnTvW5pCQZBrtxowzn7/N6pKNDxtEec4x8Z4vAekFDOrABSE0LZSiIwuVywWazYcWKFT1qYuTl5SEnJwelpaWDOpbL5UJWVhaqqqqQlZXVo6WkpGg6a0tYuPRSdfmrrzS9W/GDHwAffijzL595pvdzH3wgw1POOgt4442I/H9KRGHkrbeAE04Abr1VstIV06fLTdx335WABxENMfPmSbHR3btlTvqlS6XeRny87/0PH5aMj/vvB6ZOlayPrCz5hvLFF7xgISKf9u8H7rlHrjt+8xuZUEGRkAAUFkpA4/77/SeTdenslIuX446TyuebN8vsUD5u1oe7IV+X3Ww2o7q6GlarFSaTCWlpaVi5ciVKSkp81sTIyclBVVVVV02NgR4rLy8PLpcLDofDb9/mzZs3+B8wnBx9tAz62rhR1l97DbjlFs0ObzBIAGPBAsnWuP9+71obH30k7dhj5Zrh2mujr2gOEQXP11/LVK1vvum9feRIKdL1y1/ybwoRfW/0aJl24O67Zb2yEigtBT79VAIfvtJIm5qkqp/DIalgMTGS/TF3LnDBBcCVVwIBzsJHRNHnu++Av/1NhpYcOeL9XFKSzER9xx1SEqhPbrd8F7v3Xhnb7ykuznte2AhhcLuZoB/NZs+eDQBYu3atzj353p13An/8oyyfc45UsAmiDz6QDE/PKY4UY8dKXOXmm6UECBGRL6tWAb/7HfDyy97bDQaZ6fEPf/CfeU6+hd1nU4Tj+xlh2tuBV16R2huffw7s2RP4eNnhw4HJkyVt7Ac/AC6/PMBvMUQUidrbZdj93/4G+KiGAKNRMkhvuw0YMyaAA7rdEmj9zW8kY8xTTAxwzTVSBygzc9B9D/VnEwMbUS7sLnY++kgdKxIfL7lUvqqKB+G0jzwigcnuv/HDhskMbrffLtkcRESA/4AGIHU0Hn1Ussyp/8LusynC8f2McO3twIsvSjp4dbUMlPcs3NOX+HiJrs6aBZx8MpCTIwXbY4b8iHOiiLV/v2RmPPGE79H748YBv/qV3KAdPTqAA3Z2SsqpzSZfjLpbtEjS3TX8MsTABmkq7C522tvlw7e2VtbLyuQ/Uohs2CDZnf/4R88ULkBufhQWSoFzTs1INDT1FtA4/nh57pJL1Bmsqf/C7rMpwvH9jELffAO88IKknK5fL1UC+2vECMnumDVLAh0Wi0RjGfAgCktut4xWKymRr0itrT33Oe44yTi/7joZftKnpiYpCvrnP8tYlu4uvlgubIJwp4aBDdJUWF7s/PjH8h8MkOrhzz8f8i7U1koE9K9/lQzQ7saNA66/HigoAEymkHePiELM7ZapWR9+WDLEuzvhBKkufuml/E6ghbD8bIpgfD+HgOZmqYD+9ttAVRXgdEqB0oFISpILHZNJorWnnCIFygLKYycirW3ZIl+N/vlP36Ut4uJk1NkttwBnnBHgjZWdO+WLTkmJzE3fXU6OzNB00kmD7b5fDGyQpsLyYuell4ArrpBlo1EmW/ZXMTzIWlrkhsijj/asm6M45xzJ4rj4Yt26SURB0tYGVFRIJteXX/Z8/oQTJDPzkksY0NBSWH42RTC+n0NUe7sUE3vjDYnM1tTIVE0dHQM7XmwsMGqUBD3S0yXTY+5c+SaVkaFp14mGuoMH5frj2We9JzvwNHGi3GQtKOhHQdCqKrmoWb6855A2g0Hu0PzqV/L/OsgY2CBNheXFzqFDQFqaml/17rsyBkRHyt1aJfWrpaXnPuPHS4LJtdfKlx2moRNFrtpaYNkyuZnhOe+7ggGN4ArLz6YIxveTvOzYIfNSf/SR3LXZulWyOwYzfazBIIVLU1JkSHF6usx2d+KJcsd3+nStek8UtVpbpQDov/8t93l9DYtXZnksKJCh8QHdVK2tBf71L+Dpp2UKt+5GjpRq57fdpklR0EAxsEGaCtuLnQsuUOdM/OUvJWUiTNTVSSpYSQnw7be+95kzRwIcV1/NYuREkWT9ehlm+s9/+r6gOOssKSR88cUMaART2H42RSi+nxSQzZuBFSuAL74A1q6VgEdtre+7OQMxbJhkfIwZI7eap0+X4MdxxwFmMy+YaEhqaZFJSMrLgf/+1/8IsqOOktH611wDTJsWwIE7OiRK8vTTMobWV0GOadMkmHHDDZIlH2IRH9hITU3FPffcgzvvvLPX/V566SWUlZXBZDKhsLAQ6enpWnaDvhe2FzslJTLZMiDpjTU1YZcC4XYDH34oXa2okJT17mJigIULJchx2WUSECWi8NLUJBmZTz0FfPJJz+fj44Ef/UhirHPnhrx7Q1LYfjZFKL6fNCitrVKx8PPP5W7vxo3Arl0yLr+5WdtzxcdLUdPkZGDsWCluOm0aMHMmMGMGMHs2MGUKI8sU0Zqb1WDGq6/6D2akpABXXikBjfnzA/wqVFMj41f+8Q9g+3bf+5x2mgQ0Lr9cCnToJKIDG5s3b4bdbseiRYuQ3MsUng8//DDuvvtuXHHFFUhNTcWKFStQXV2N0QHNVUP9EbYXOzt3ygeXYs0aieiHqdpaGaLy3HPyue9LYiJw/vlAbi5w0UVy04KI9OF2y03Jp54C/vMfGQHX3ZgxMk3az34mmdUUOmH72RSh+H5S0HR2ygwtn3wi12qbNsmXqf37pUiAr7vEWoiNlaEvI0fKneYxY6T2x+TJwNSpMhRmxgy5zc27ShQGDhyQZPTXX5eRYI2NvvcbPlwS13/0I8kOHTYsgINv3SpRkrIyqaHhy/jxEiG5/nrgmGMG/HNoKaIDGwBw8803w2azYenSpXA4HMjKysLdd9/tFbRITU1FYWEhli5dCgCoqKjAli1b+szyoP4L64udefPU/5z/7/8B99yjb38CtGGDTOTy3HNSxdiXYcOA886TIMfFF8uNCSIKvv375f/mU08B69b53uf444Ff/AK46iq5wKDQC+vPpgjE95N009kpf2xXrpTHmhoJfOzdK1PUHj488GKmgTIY5K70sGEy48vIkXIrPDVVgiETJ0pAZNIkGR6TkSGBEmaF0CC43TKi67XXJJjx2WeyzZfERODCC4G8PAlqBBSL27FDghnLl/u/qxobKwe+4Qa5uxpmsxxEfGDjxRdfRF5ente2lJQUVFdXIz09HZs3b0ZmZiacTqfX8JObb74Zjz/+uJZdIYT5xc4f/gDce68sn3SS//+0YaqzU25gPPec/N3xN8V8QoLMqHTZZfLHbOLEkHaTKOrV1wMvvyw3Mlas8H0NPXq0BDJuuAHIygq7kW9DTlh/NkUgvp8U1lpbJeixdi3w3XcyVe3OncCePVLY7NAhyd0fTHHTgYiJUQMiiYkyRGbkSLkbpWSJjB0rd8LHj5cLuAkTJGOEWeZDUmMj8P77wDvvSDBj61b/+yYlSQZ3bq5c/48YEcAJamokUvLii8DHH/vf79hjgZ/8BLjuurBOOQ31Z5Pmg27KyspQUlKCxYsXd20rLS2F1WpFWVkZnE4nDAZDj5oavQ1doSh1ySVqYOOLL4DduyPqW39MjMyUdMYZMrPCihVSi+Pll72ni25tlZnY3nhD1rOz5Q/dhRdKLS3eMCDqv8ZGKcJVViYXGL5q4ABSDPSGG2SG6aSk0PaRiIggd3hOPFFab9rb5YvdunUy5GXzZgmA7N4tAZDGRskAaW7WJguks1Mu0lpbZVhNfymZIvHxEhxRMkaUrJFRo9QgSUqKtLQ0aePHS9Bk4kTZlxeDYam9XZLLKyvlWuPzz3vOoOpp0iS5xr/oIqnB1+d1R0eHfAd67TUpxuEv1RSQYVf5+cCiRWE9fF9Pmgc2UlNTvYIaAFBQUACHw9Hr6wy8fTb0zJkjKYFKuPP114FuvzuRIiFBMsDOPx944gngvfcki+Pll6U+h6eqKmn33y9B1gsvlD+ACxbwBgBRb2prZdxqRYWMY/VXyH/SJBlm+tOfyhBsIiKKAHFxMovK0UcHtv+BA5IBsmmTXEvu3i1DYPbvlztMjY2SDXLkiES/tR4S43bLcdvaJOAyWDExMrRACZYkJKgBk8REGTs5YoQaOFGCJ0oAZdQoCaIoLTVVHZKjYwHJSOJ2y5Dz996TCUdWrPCfka3IzpZh5xddJAXI+/xK29goB371VbnruX+//31NJjWYccIJTDftg+a/5f4CFPXf38J29fXbQUOHwSBZG489JuuvvhqxgQ1P8fHAOedIe/xx4IMPZK7qN97ombK2Z4/UAnjqKfksO+kkGbZischymA2VIwopt1umXFbGr37yif9M5XHjJN0zPx84/XTe/CIiinpjxkg77bTAX3PokBRI27JFskGUITG1tRIMcbkke6OpSYIVLS0SuOjs9F9AQSudndLa2nzPR66FmBi1KUEUpcXH9wyoeLbhw9WmDN1JTJSWlKRuUwIvSUkSbPEc5pOUFFZBFrdbYmPvv6+2vXt7f01KimRjnHuu3JzsM9m8o0PuaL7zjqR+fPZZ72kfs2ZJpCQ3l2Nn+0nz3yy3242ioiIUFhYiNTUVdXV1KCkpQWpqKgCgrq4OAHDw4EGM8pg2oqamRuuuUCS49FI1sGG3ywdJQIPQIkNcnPzxW7hQhqusXStf0N54Q2ZW8/yS1tEh2z79FHjgAfn7f/bZEuSwWOTvHP+2UbRraZFhpUowo7ePhtRUGWKSny9DTsLoWomIiMLRyJGSxj+QVP7OTgmC7Nolbc8eYN8+uePucsmcng0NamCkqUmGzSjBESVAEupaIt1/Bj3P70m5qDUYpCkBF8/l2Fjv5e4tLs77sXuwxvP5uDh0xCZgzaF0fFI/Gx/uPxYf7DsGe4/0Xg4hLqYDp07fiXOO2oqcY3cgK70WsfExQGcc8L/vj20wePejtlZmEVq1SqZQ9jU1myI2VlI9zjxTxrdPm6b+zGvWqHdqlPcrkDs3noE45d/b87H7857blOXjjpPAYQTRvHhoQ0MDsrKysHnz5q5tGRkZsFgsyMzMxNKlS7Fo0SIYDIauYqH5+fkoLCzEggULtOwKIQIKirW1yRhDZYLnl18GfvhDXbsUKkpa/euvA2+/7V2Xw5e0NLWmxxlnyN9AfpGjSNfZKZ/5Ssrnhx/2fqNKGb6VmysBQ2Y1Raaw/2yKMHw/iSJMa6sERZRskQMH1IwRZRiNEiQ5fFjakSMSKGluVmuDKENsOjrCK2gRJg5iJD7HyfgEp+FTnIrPcTIOou9x38fja5yN95GDSpyFDzAKvQQmotUDDwD33TeoQ0R88dDk5GRs2rQJpaWlXdO9KjU3vvrqKxQUFCA5ORmFhYVIS0sDAFgsFgY1hqr4eClM8Z//yPqrrw6ZwEZaGnD11dI6OiSoW1kpX/A+/rhn/YDaWuCVV6QBkthy6qkS5Dj9dJk9l1O5U7hzuyULY8UK+V1/772edWi6mztXHb+alcVhJkREFOESEoApU6QFQ3OzFFytq5NgiRIoUeqOHDyoZpYcOaIWZfVsLS1q8KS1VYZPKIGU9nbvYIpyt19pOuiEARtwFL7ASfgCJ+EznILVOB6diO3ztSdgFc7CBzgb7+NMfIg01IWgx2FOp3/HwdA8Y6M/VqxYgdTUVMydO1evLkS9iLiL85//AD/6kSyPHSvFn2L7/iMUzY4ckeCG3S7BjlWr+v77EhMjw1VOOkna/PnA7NnM6iB9tbYCX30l9TE+/VQe9+zp/TXDh0s2hlJZPFjXfaSfiPhsiiB8P4ko7LS2SsDk0CF1aI6SeaJsVwIozc2yvaVFDag0N6tBFc/gyvfre5tG4suGo/FFwzH44uAsrGyahYbOUX12KxbtmBu7BqfFfYGzYz/CGTGfIM1Q1zM4ozTP7UMpI+b++4Hf/nZQhwj1Z5MugY0tW7b0mO6VgiMiLnZcLgloKIV03nlHKmhSF5dLvhB+9JGk6ldV+Z/e0lNSklRrzs6Wu95z50qxcQY7KFj27JHfTyWI8eWXcm3Sm9hYyThauFDqyZxyitQpo+gVEZ9NEYTvJxFFs337gOpqtVVVATt2BPba5GTJcD7tNGnz5vVRzm/vXrl4US5kVq7s+0IGkOlYzzpLCuSddRYwebL/fT0zXTyHEPla9/fYV/qq8rxSr8PXNl/rGqbFRvxQlEAUFhbi7bff1uPUFI6MRuC886TYBAD85S8MbHRjNEpdgQsvlPXDh+VvrhLo+PJLyS7s7vBhef7DD9Vtw4fLTLtKoOPEE2U9imq2Uojs2eN9kVFdLfXUAjFrlgQxFi6Uz//k3mt3ERERUZRzu+U6YtUqwOFQrzECDWIYDJKtPH++ZC+feqpcb/j9rn7okJzoyy/V1n0KQ3+OPlqCGGefLYU/J00K7HWA5gEELbS1AV9VyXeLqirg+ecjL4E+KIGNxsZG2O32rhlQPLlcLlRVVQXjtBTJbr1VDWy88QawcSMwc6a+fQpjSUnq31JAArfffit/j7/4Qtrq1b6nbG9uluDzypXe29PT5cNAabNmAccey4AHSVbod98B33wjbc0auQ4INIiRkCB3SE47TS4yTj1VkrSIiIhoaGpvl2uLVau824EDgR9j0iTvIdjZ2TLDrE9HjsjFcXW1XMSsXCkXNYEMLxk2TA6upH2cckrEX8gcPizfFz76SNpnn8loIcXddwMnnKBf/wZC88DGihUrkNPH3XYD56yk7nJy5Fv0+vUSrn3sMcncoIAo9TVmzQJ+8hPZdviw1Db44gt5/OorCX74CnYA6rTub7yhbjMYJOBx9NGSYTdzpvo4bVrkRXKpd4cPA5s2ARs2yH/FNWvkM3/DBv+/N75MnCgXGMrnf1YWh5YQERENVfv2SUxh9Wq5tli9Gli3LrARHorx4yW2kJWlNr+jPZqa1CCGEshYuzbwi5mJE4GTT1bvyJjNEX0h43ZL1otyA/Sjj+Rt6W1Y+0cfMbABm80Gm80Gi8UCo9HY4/n6+nrk5+drfVqKdAYDcNttwM03y/ozzwC//z3z0wchKUn9Yqk4ckS+qK5aJYEOZXrtw4d9H8PtBjZvlvbWW97PJSQAmZkS5MjIkJaeLi0jAxjd92xapINDhyTL0umUxKgNG6Rt3Bh4qqeniRN7XmhMnKh9v4mIiCi8HTwoAYtvvpE4ghLE2Levf8eZMkW+VHteW0yaJF8XvLjdMunA11+rKR9ffy0XNoGWkRw5UtJK589Xx7D0Vh8jAjQ2ynCSL75Qgxm7d/f9uvh4eSvOOEOSUiKN5oENs9mMu+66y+/zGRkZnAWFfLv2WuCee2T+7kOHJLjxy1/q3auokpgof7DmzVO3dXZKpsbatd5t/freI+mtrbLP+vW+n09JkSDH9OnyATV5sjTPZQ5z0VZHB7B/vwwR2bFDAhhbt6rZOFu39i/F01N8PHDMMcBxx0k7/ngGMYiIiIaipibJAl67Vg1irF0beHkKRWysXFuceKJa9+2EE4AxY3zsfOSIRE3WrFHbqlVy4ROoxETviMn8+dKBCE5BdrnUzGyHQ9q33wYW1xk5UhJSzjhD2vz58hZFKs0DG4EMM1m+fLnWp6VoMGIEsHgxUFws6489JrU3IviPTSSIiQFMJmkXX6xu7+iQTI116+RuvnJ3P9A7+/X10r76yv8+yckSgR8/Hhg3Tprn8rhxMoQxJUUKqA7F2Vza22Ua+v37JSihPO7bJ9H3XbvUxz17+jdkxJeEBGDGDBlypAQx5syRzJz4eG1+JiIiIgp/dXVyA2vdOvVm1rp1wLZt/T/WuHFyU2TOHPVx1iwfX6Q7OoANNWrKh9I2buzfdKsjRkikRAlimM0SxIjQi0m3G9i5UzJglOKqX30lGbiBmj5dElJOPlkCGSeeGLFvh0+a/ygmk6nP6VxvvvlmPP7441qfmqLBLbcAf/yj/FFzOqXgwyWX6N2rISk2Vr7gzpjR8zmlFsPGjfKoZAQoLdAxkw0N0vxlfXQ3ejSQmiqBDuUxOVkKRflrSUkyE4zSEhPV5fh4H2mNg+B2y6+uMt16c7O8V8rU7d0fGxvl53e5vB+V5dpaCQ5pPSl3fLzUSPGsmXLUUdKmTmUskYiIaKjo6JBMi2+/lfbdd+pyf4eQABJPUArRKxmec+bIjaseJ968uWfK8LffStXy/pg8WTIxTjxRbZmZYTfzSKAOHZK3QqlLotQmqa8P/BjJyd6ja+bP9/FvEGU0D2wsXrwYL730Eux2OywWC1JTU3vsY7fbtT4tRYtp04DLLgMqKmT9T39iYCMMJSXJB9Xxx/d8zu2WKcA9hz/s3Onddu8eWGZBY6O0LVsG+QN8z2CQL/lxcdJiY9VlZd3t9t86OyWAoQQy2tq0D0IMxKhRMkRk+nS17onn8oQJDF4QERENJXV1knn73XdqfS1lub9xBEBuFClDVJUgxuzZcinvFU9obZW7YB93S/347jsZXtIfw4ZJmocSLTnhBGkROkPJ4cPyVqxdK2+NEtvZsqV/15NGoySkzJ0rj2az3KyK0LjOgGke2EhLSwMg07oSDcgvfqEGNt57T8KUvr5BU1gyGOSL84QJkurmS0eHBD+UIMe+fdL27vVe3rtXPoj7k3nYH263fN62tgbn+FpKSJDP7bFjZezpmDESvJg0ybtNnNjLVGdEFDCn0wmbzdZVCN3pdKKoqAhms1nXYxER+dPUpGbUKk0JXgy0xlZyssQSjj1WmrI8fXq3L84ul5zsg2/VlI/166VD/b2bZTDIGGnPlI85cySNOALHTtTXy1vh+bYMJIABSK26OXPUAMbcuXLTipOOBiGw4Xa7YbFYYDKZuoIcng4cOIAnn3xS69NSNDntNPmf6nDI+l/+AvB3JqrExqpfxPvS2SlVtuvq5IPB87GuTjI4Dh6UduiQuqy0I0dkSEhzc+/TWgVTUpKkZiYleS+PGiUXDEaj96PS0tLUQMbIkfzQIgoVh8OBvLw8VFZWwmQyAZAbNllZWbDZbMjNzdXlWERER44ANTUSL1CmaFeCGDt3Dvy406dLBsbRR8uj0iZM8Lj+aG+Xb+PrNwCvfKeOW/nuOyn0NRAZGerYFaUdc4xcKEUQ5a1RMmG+/XZwQ3qSktR4jpIlPWeODMUm34JSY6Ov4qBf9VZNkMhgkNlQrrtO1p9/Hli6NGLTzGhwYmLUL/oZGYM7Vnu7pFsqgY7mZtnWvXV0qMsGg/8WEyOZFEqLj/d+HDZMUjUZkCCKLHl5eSgsLOwKRACA0WiEzWbD4sWL/U5pH+xjEdHQcOiQBC+UAIZS02zTpoFNza4YPVqGKBx9tFpb65hjpNZW10x1ypjiDRuAN7qNWampGdhdIqVwW/e0j6OPljs3EcLtlmLtSkDJc0iP0zmwt2b4cPUtUeI6s2ZJwspQG0oyWJoHNpYtW9bnPjabTevTUrRZtAi46y75w9rSApSWAr/+td69ogin1M7gNLNE5I/dbofT6YTFYunxXG5uLvLy8lBaWoolS5aE9FhEFD3cbikQ7hm88Hzcu3fgxx42TOpmzpwpTQliHH20zEzSdbOlrk4iJms2AC9t9E79OHhwYCcfNapnysexx0pQIyFh4D9UCHV2yjBpz4CSZ2Dp8OGBHXf0aHkrlKwYJYCRkREGdc/cbhlK5DnV3iWXSCpxBNE8sDF37tw+91mxYkVA+9EQNmwYcPPNwP33y/rf/w4sWcL5JomIKKgqKysBwCvDwpPRaERZWVlAwQgtj0VEkaW9Hdi+XQ1e1NTIXX3lsbFx4MeOj5c7+koAQ5nhbObMbrOb1derwYr3PIpvbNokgY2BMBhk3IoSMfEMYkycGBFpqm1tMmWtr6CS09n/mqYKg0HqXcycqcZ0lLdm/Hgd3hq3W34HlGBF90fP5e4VZL/4QqZSiSAhr77S2NiIsrIy3HnnnaE+NUWam24CHnxQKjvu2iUFRX/0I717RUREUUyZuc3f8BCTyQSHUgMqhMciovDT0OAdrPBc3rp1YDPAKZTMCyV4MWOG2qZN+z54oaR+KOkEn2xSlzduHHjwApBCX0rKh2faR2amjLMNcy5Xz38TZXnbtsH924wb550No7TMTBlaEnTKv7tnoMLf8kCmvAHk9RFmUIGNc845B++++y42bdqE9PR0AEBMTAwMERCpowgwfjxw5ZXAP/8p63/+MwMbREQUVE6nU7OaF1oeKxTWrgWUWqbKlNaAPCqV+z2Xlamvuy8rPNe1mApbubz0vMz0t81ze/d9YmK8tynj2JVlX/WUfK3HxPRc9rctNrbnutI8t8XFeT/vue45LXlsrDpduedyfLy67tmU55Tmqy6U0oYPj8iJJ4KirU2yLjZvVr8Ye7bBxA0AGZ6QmSnBiu6PkyZ9/7upjI1Q0gre75Zm0NAw8A6MGuWd8uGZ+hHmVSpbWyVA4flv47lcXz+4448dq74VM2Z4L48erc3P0ENnJ7B/f88gRff1PXuCM6VfQoJk3UycKJG1CDOoP1s1NTXo7Oz0mtrVZDLBbDZj3rx5Pl/DWVGoX37xCzWw8cUXwOef+59DlIiIaJBcLldAwYhA9tPyWAAwe/Zsn9tramqQmZnZ5+v7smePVPAn8qV7gKi3AFD3QI+vAI9ncEcJ2HQP1CgBGc/ATPegzLBh0pTl4cPVR6UlJcljYqLaRoyQxyNHpCDnli09vyQP9s4+AEyeLMEKZeiIZ0tN/f79bG+Xk23aBKyvAV73CF7U1Ax8bAQgxTl9fTufObNb0Y3wosRzNm/23XbsUIOvA2EwyLAd5d9CCSopTdPgRXu7TI3SV3bF3r2D/4XzJSFBImUTJ/b+2PULGZkGHdjYvHkzMjymKjAajZwVhbRjNgNnnAF89JGs//nPDGwQEZHu6urqNMvG0PJYgxHB17MUAp7ZOaQyGNRAixJEGTlSWnKyGlRxt7Vj55pG1K2swzeHa5HUuBcjGnYhqXY7RtVtwahOF0biEEajEaNwEMlowGg0YjgCuDM/enTP8SozZ8o3dF2KO/TN7QYOHFADFUpgSXncunXgoygUSUlqQMlk8l5OT9cgKaGtTYIRvoIUno/79gXnP87w4d7BCX8Bi5SUsPwd0NqgE80yus2/uGLFij5fU1JSMtjT0lDyi1+ogY3ycuDee6WMMBERkca0DDBoHaxYu3atz+3+Mjn6a/p04KSTeg638Dckw18DfA8R8RzyEQjP7wHKndm+hsEoy57N13ZlSE339e5DbTy3K/3wte7rGP7O5+v53rYH8nN1f78YfAgdt1tGBbS2yjSt/sUBSP2+zejPGQAABrgRAzdiDG7ExrgRGwfExhkQnxCD+GEGxO8zYFgDMOwbNWtFyUzxDLaMGiUBl1GjZNKLlBQpp5GWJsMvkpIG+k705HJ5Byu6BzCamgZ3fIMBmDJFDVpkZHgvDzim0z1g0b3QpvK4f39w/rONGNEzYNE9cDFxovwDDoGARaA0H0GXnJzc5z7FxcV4/PHHtT41RatLL5Xwak2NpGfddhtQWcn/yEREpLnU1FTUBTBwPjWA8edaHisUMjNlxCdFp85OyYhXvoQrra2t52NLizx2X/bcTzmW8pxna22VSzbP/drbpbW1qcueraPDe1lZ7+jwPreyT2enPBf9QRy53nXDgA4AHW6grQNAB4AWAIMMDvijDBnyHAbkOcRHyURRAp7Kv9PhwzLjS23t4AMXADBmjAQpfLVp0/qZddHRoQ4J8dWCnWExerTv7Iru66NGaX/uIUCXWVGqqqpCfVqKZHFxwP/9nwQ4AGDFCuCVV4DLLtO1W0REFH2MRiOcTqff55W6YoFkY2h5LKLBiolRC4SGG2Vq1O7FOZWaF7W1gzt+XJx8CU5Plzv8kyYBEyZIhkJqqnxpb2mRL+WHmzpxZLcLzTtqcWR3PQ7vaUTLgYNorj2MloZmNLfHoAXD0YJhaEECWjAcrUhAK+LRimFoRQLaEN/V2hGHNsShA3FoRxw6DHHoNMSiEzHodMegEwaP79Dhc9Ous1MNhjU3B+88BoMEJ0aMkO/9Y8bId/v0dJl1ZOZM+TebPr2XbBK3W9JDdu6UwITy2H15z57g1LAwGnsOAfE1LETLdBjqYcCBDc5+QiF18cXAuecCb78t67/6FXDeeREx3RQREUWO7OxsOBwOvwU9nU4nzGZzyI9FFOkaG72n3vR83LZNvkAPxrhx6lCE7o9TpnSb6aWjQ6pPbtyoTo+qtJqawX2TT0ryXZFyxgypVtnLlDOdnTKcpbFRJjtpbFTXPR8PHZIgjPKotCNHpLW0yI/QPTMnHLNd3G7pa3OzBLA2b+51b8Qa3IiP6UBCTBtG4DBG4iCS22uR5t6PMTiA8diLydiJKdiBGdiEGdiE0eh1jJB/SsDCV9Bi8mR1md9HwsKAAxt9zX7iD2dFoQExGIA//QmYM0f+Im/ZAjzyiNTbICIi0khhYSFKS0t9Bh2UDIv8/PyQH4so3Lnd6qyknk0JXhw4MLjjDx/uu5aCUghy5MhuL+jslDSQDRuANzd5BzFqagY3XWZqqu95WjMzJRVkgDd/Y2Ika2H0aAnGDJbbLaUilMwXz1lFnE6J7WiRwKAMR/GcFjo4DOhwG9DREYPmjng0IgnAGAAZfbzOjTi0YxiaMQKHMcpwCKkJTRg3sglTUg5j+oQWmEzA0bNjcUzWCAzPmMSARQQacGAjkNlP/OGsKDQgxxwjhUT/+EdZX7oUuO46yU0jIiLSgNlshslkQllZWY9gxPLly2E0GlFQUOC13eVyoaqqChaLZdDHIgpnnrOS1tR4Pzqdg5uVFJCb4J4BC8/Mi4kTfcQL3G4ZXlC9QQIYGzdK27BBOjaYaTUmTPAOXCgtM1MqboaJpqae09R6Lg/23yQ2Vh3Go9S2UJbT0+XfRSkM3OX7oSGHNuzC7jUHsPu7Ruzbchj7drTiwL5O1NYbUH8wHvXtI9AA4/fzwIzCYYxA8/fDfNoQjw7Ewg0DBj9Ex4B2xKMd8WjCKOxzj0dNC6RGSS2ATQA+9tjbIEO2Ro6Uf+qxY+V3MyMDOOooYPZs4IQTOLIk3Bjc7oElIXWf5jVUr6X+USql+6ukHnEaG+Uvyt69sp6XBwwwwEZERPoI988mh8OBhQsXorq6GiaTCYAEL7KyslBeXt4jSJGTkwO73Y6SkpIegYr+Hmsgwv39pMjS1iZfiDdt6jlSY8uWwQ0ZSUz0Dlx4TsOZkSFZGT41NKgBi+++k0el9T4VSe8mTVKnRu0evAiTAo5K7KZ7BowSvFAuiQfKYJC3wTNw4Rm86DGMB5D3fNs2yYjxbDt2qMtaVA4F0AlgFyZhe/Lx2G6cg90jMrEnYRr2GiZgf0cq6tpGob4lCQeb49F0JAbNzYau4rXBFhMjv9NGowyFmjpVfn1mzZIZpmbN8hH0GUJC/dk04IyNwQQmGNSgARs9GnjoIeD662W9vBx47z3gBz/Qt19ERBQ1zGYzqqurYbVaYTKZkJaWhpUrV6KkpMRnICInJwdVVVXIzs4e9LGIQqG9Hdi6VU1y2LBBDWRs3Tq4L4VjxqijMrq3XkdpdHQANVskcPHdd8C336rLe/YMvEOTJkngQgleKI+ZmVKxMgy0tXlnwnhmw2iRCZOS4p394rk8fXq3mUXa22VM0datwKfb1ADGNo/l+vrBdchTXJykQ0yeLFGUKVO81mMmT8aUiRMxZdgwnNLPQ9fVqcG5bdsk7rJ7t8zSeuCA1Bs9dEjqewwkYNfZKfGbpiapUeprUMKwYTK97oQJ8n4feyyQlQWceaYEQ0g7A87Y6MuWLVtgs9m6ZkDJyclBQUEB0tPTg3E68iMq7+J0dgKnnAJ8+aWsH3ec/CXppRgTERGFj6j8bNIR30/yxe2WiSA8kxyUkRpOp3yZHijlznT38hKZmXIPqldNTdKh9esleKE8btw48LoXY8dKRq8SwFCWZ8wIm+BFa2vvmTCDCSbFx3sHLLoP5UlO9tj5yBH5lr91q5xYWd66Vf32r1W6w7BharBiyhT5xfEMXkydKv92YZLWsGePGk+rqZF/L2X21/p6+dVtadGu6GpsrDoD7MyZwNy5wOmnSwvH2Yv6K9SfTUEJbDz55JMoLCxE90MbDAZUVFTgMk7TGTJRe7Hz5ZeS46V47DHg5z/Xrz9ERBSwqP1s0gnfz6Ht0CE1sUEJYCiPAx0NEBMjd/KVBIfMTDVO0OuQEU/19cC6dcDatfKoBDG2bRtYp5KSJGBx9NHyqCzPnCljAcKAUt9eyYJRgkmbNkncYDBFNdPS1KE7nkN4MjPli3Fs7Pc7HjkiJ9u8WTqzZYsaxNiyZfBjVxRxcWqwQmnd18eMGXAh1XDmcgEOB7B6tfxaO52SsXHggIya12J63OHDJcvj6KOB+fNlcshTTgmbGFBAIj6w8dVXXyErKwsFBQUoLCzsGk/qdDrx4IMP4qWXXoLT6cR0FnwMiai+2LnhBuDpp2XZaJRPjjFjdO0SERH1Lao/m3TA9zP6ud3yxenbb73bd9/JDfaBMBikKKSS4KAEMWbOlPoKXsMTelNXB3zzjQQvPAMZAxk+onTqmGPkG51nmzw5LL4kKzUvPANJSnM6B16DxGCQuED3GWKV4EVX1kV7u/yje1YIVYIYmzcPbtiOpzFj5N+ie5s6VR7Hj/eIplB3W7cCn34qSeXr1sn63r1SLmYwE/KMHCm/J1lZwIUXAhdf7GNGoDAR8YGNc889FwUFBbjiiit8Pl9RUYHy8nKUlZVpeVryI6ovdvbulU/ixkZZLygASkr07RMREfUpqj+bdMD3M3p0dMh31fXrpa1bpy4PtEbm+PFqYoOS6KBkYQSUeaFoapIOffONd9u1q/+dGj5cOnXssdKOOUbazJlhM8Vmc7PcM/MMIimBDOXSs79iYiRo5KteaXq6x79HY6N3tVDPtnXr4Cq4AhKQmDJF0nKUNm2a+jhtGqf8CKLWVkk+/+gjoLpafqd27ZKgx0D+aUeMkEyqefMk2HHhhf38vx0kEVM81J/k5GS/QQ0AyM3Nhd1u1/q0NBSNHw/cfz/wq1/J+rJlQGEhwGJsREREFMY6OuQ769q13m3DhoHNUJqYqI7MUEZqDHiURmen3PlfvRr4+mt5XL1avlT3935ocrJMDTFrlhrEOPZY+eIcJnf76+vVUTKeZT82bx7Y0BEl6cSz5IdnJkxCAuR9rK2VyElNDfCfbvPn7t8/uB8qNlYyK5TpTdLTJWihLE+ezNp0OkpIUGtpdFdXB9jtwPvvS7aH0ym/Kr2VPWlqUuOMzzwj21JTpWbHxRcD114r69FO89/otLS0PvdJCaO5nynC/fznEtBYv14+JG66Cfj44+iouENEREQRze2WG+xr1khTAhjffjuwAMbEiWpyg9KOPlq+ww5o7P3hwxK0WLVKghhffy0d7W96iNEoxdyVIMasWcDs2dLhMBg+AsgXRs+RMsq/xUBHbowd6x1I8pkJ43KphTb+vVGt3rpxozw3GJMmec/P2uccrRQJUlOBRYukedqxA/jf/4APP5SAx5Yt8t/Xn7o6YMUKab/8pRQpnT0buOAC4Kc/lV+faKP5b3wgI1t87VNUVISlS5dq3R2KdvHxwJ//DJxzjqyvXAksWQL86U+6douIiIiGlvp6NYDh2Q4e7N9xDAb5buqZ5DBrlgQxvGa3GEgHv/pKbQ6HjK3oT1pCYqJ8OzruOLXNmRNWAYxDhyRg8c038v5/883AAxjx8RKs8FXyo+s+bWur3Fb/7jvgDY/qrd99N7jMi+HDfVcLNZkkgBEmQ3YoNKZMkVH3BQXqtsZG4NVXgTfflCEt27b5nxq4sRH47DNp994rv79nnCHJ7uedF1lFSf3RvMZGQ0MDCgoK/NbQKCoqQmFhYY9pX+fNm4eVK1dq2RXCEBp3u3gx8OST6np5OZCbq19/iIjIryHz2RQifD9Dq7NTvscqCQ5KskN/J/swGOT76uzZaps1S740D/o7qzJtQ1WV3PSpqpJbvP1hMgEnnAAcf7w8zpkjEZcwGULS0SGJD0qSiRLEcDr7f6zRo73LfSjLGRkeiQ+Njd5jVZTmdA58etTkZLXIhmfF0MxMCRZFw7dNCqm6OuC55yTgsWqVrPclLk5+33NzJRleq2ErEV88NC0tDa4BplZ1aDVnMnUZMhc7R47IHEhffy3ro0ZJ6HLmTH37RUREPQyZz6YQ4fsZPK2tcrff4ZC2apWM3OjvSI1p0yQuoCQ5zJ4tX6A1uel++LB07ssvJYBRVSXf+AOVmCiBixNPVAMZc+bItVSYaGhQS34o7Ztv/N+d9sdo9A4iKY9eCSeeY1aUcSvr1w+sSCogU1Z0L7ahtCidDpXCx+HDQFkZ8OKL8qdh376+S+WMGwfccgtw332DO3fEFw91u91YuHBh1zSvgaitrcW7776rdVdoKElMlCyN7GyJqB88KGHHzz9nqh4RERH16cgR+fKsBDEcDskCaGsL/BhGo8QEPNtxxw1yCIknt1uCFp9/DnzxhTx+/XXgGQNKRUHPdtRRYZOFAcjoDc9/A4ej/1kYI0ZI0EL5N1CCGRMmeMQRDh2S6MgbHuNVBjpmJTZWMlx8VXD1OilRaCUlAddfLw2Q2X6eeQZ4/nkZkeYrOLhvnyQmRRrNAxsmkwnvvPNOv193jlIjgWigZs6U/6nKrDyrVwO33uo9RIWIiIiGvLY2+Q67cqXavvmmf1MtzpghCQ6eyQ5Tp2r8HfbwYcnE+Phj4NNPJZgRSG45IEGM7Gy1ZWUFoYODs3evvPfV1WoQY8eOwF8fEyPxAyXJRGnp6R6jODo6ZLaRj1dLpGr1948DGbMycqQ6VsXzMTOThespIgwfDtx8szRAsjgeewyorAR271b3u+UWffo3GJoHNmw224BeZ7VaNe4JDUmXXy6lf5XioU89JZVxfvxjPXtFREREOnG7ZepOJclh5Uq5U9ncHNjr4+Ply7LZLAkOJ54YxJEaBw4An3wigYyPPpJv/IFEW0aMAObNk5adLY/p6WEVxGhokB9HCSR9+SWwfXvgrx89Wg0kKW32bLkj3aWpSYIW76ySf+RVq2S9v2NWkpN7Fj855hip4BhG7ynRYGVnA88+K8uNjUBJiUw3e9pp+vZrIDSvsRGILVu29CgeSsExJMfdtrYCZ50lVzCADEX54gu5CiEiIt0Nyc+mIOL76e3QIfni/PnnMgPA558HPjlFYqIELsxmNZAxe3YQb8bv2we8/z7w3nvyGGj+96xZwEknASefLG327LAaTtLRIRkxyiwMn38uk4QEatw4STDx/HfoEafxLJCqBDE2bOjfLC8jRngXPlHapEkMYBANUsTX2AhEXl4eZ0Ch4ElIAJYvl0/B2lqJ0uflyVVOGBXCIiIiosHbvl0SHD7+WJId1qwJ7LttfLwMYVASHebNk5EFccG8Oq6vBz74AHj3XQlmfPNN368ZOVIKpJ92GnDqqdJRozGIney/ujo1kPTZZ5KNEeg0txMnyo/kGcjoMXtsYyPwgUMtjlpdLcNLAhUTI2OHlDErymNGBmceIYoSmv/pfrKPegbV1dVwDmRMG1F/TJ0qVXEuuEByUL/7TqaEfeEFRuCJiIgiVGenTFKhBDI++ijwaVaPOkqSG+bPly/Sxx8v482DqrVVamO8/TbwzjuSWdBXsvSECcDpp6vthBOCHG3pv+3b5b3/8EN5XLcusNcZjZL6rvwbzJsHTJ7cbae2NsCxWrJtldafdI+kJLXwyYknqmk3XmNWiCjaaP5XcsmSJWhoaICvES4GgwFutxsGfrGkUDjvPODXvwb+8AdZLyuTT9A77tC3X0RERBSQzk7JwFBGa3z4oSQ99GX0aHWkximnyBfptLSgd1c4nRLIeOstyczoa27YyZOBH/xA2llnyewaYXSt7HbLCA8liPHhh8DWrX2/LjZW4gunnCL/DiedJEkTPX60HTvUwqhffCHZGIEWQElJkUiJZwGUGTPCalgOEYWG5oGN1NRULFu2DGaz2Wu7y+XCypUr4XA4UFxcrPVpiXy7/375sFSmE77zTikIdeONunaLiIiIelIyMt57T9oHHwQ2CYjJpCY4nHqqDCkJ2QiDtjb5tv/f/0owY+PG3vcfN04NZCxY4Ofbvr62bQNWrJDLp3ffBXbt6vs1Y8dKEENp2dlSwsJLR4cMv1EKpH7ySeApN8nJ6uwuykwvYVYglYj0E5TpXq9QptvsZu7cuWhoaEBpaSnuvPNOrU9N1FNsLPDvf8ttAuX2QkGB5J5ec42+fSMiIiLs3ClTDb7zjlTj76vQZ0yMZAKcfrpMfHbaaVLrMaQOHpQgxn//C7zxhhSy9Gf4cODss4FzzwVycqTwZ5h9Gd+/Xw1irFgB1NT0/RqTSd5/pc2c6ePHammRLIwPP5RAxmefSb2MvsTHS/aFkuoxf35YBoCIKHxoHth45513en0+OTnZ5zAVoqAZP14+pc88U245uN0y/evw4UBurt69IyIiGlIOH5bvue+8I62vgvkxMXKT/uyzJcnhtNNkqEnI7dkDvPoq8Morcl3R2up/32OPlUDGeefJ9UdiYsi6GYj2dok3vPmmxGeqq/t+zXHHyY+iBDJ61MYA5D358kt1lpdPPw1sWEl6ujrDy0knSVAj6AVQiCia6FKJqC6QnEIiLWVmqsGN/fsl1/VHP5ILjQsv1Lt3REREUW3TJklseP11CWr0FhMwGKRcghLIOOMMGYWgi7o64MUXpfj4++/7L/w5bBhgsQAXXyzBjOnTQ9rNQOzcKaU/3nxTMmQaGnrff+ZMYOFCGS1z9tky1KSHjg6ZpcRul2DGp5/KbHS9iY2VwMXpp0uUSpeUGyKKNpoHNhr7SC+rqqqCw+HQ+rSD4nQ6YbPZYPx+6iyn04mioqIedUKCeSy73Q6r1Yry8nKYTKZ+n5cCcMwx8sF79tlSeay9HbjiCrnKslj07h0REVHUaGuT77ivvSYfs31NapGeLgkO55wjwYyUlJB007emJsnM+Pe/JRLQ1uZ7v5QU4KKLgEsvlc6PHBnafvbB7ZZJWF55RX6cr7/uff/Jk9VAxoIFMsGcT1u2qGOHVqzou5prYqIUPjnzTAlinHRS2L1XRBT5NA9sGI3GPmc9qays1Pq0A+ZwOJCXl4fKysqugILL5UJWVhZsNhty+zFUob/HslqtcDgcMJlMcDqdYRfwiUrHHy8fxAsXyhjPlha5IHnrLbklRERERAPS0CBZGa+9Jh+rvZWdGDVKvjyfc460zEydyye0t0sQ4/nnJQpw+LDv/aZNAy67TK4dTj9dakGEkdZWKbj63//Kj7F9u/99ExLk0uf88yXJxG/pj6YmCWAoY4f6Ko46fLgEMn7wA7mZNG+eZLQQEQVRUIqHms1mmEwmpHWbV8toNMJisSAjI0Pr0w5YXl4eCgsLvbIkjEYjbDYbFi9eDIvF0pV9ofWxbDZb17LVaoXdbh/0z0MByM4G/vc/uZI6fFjahRdKNsf8+Xr3joiIKGLU1soX6BdflJv4vQ0xOe44+bi98EIppRAWMYGtW4GnngKeflrGavgyfjywaJEMYT355LArYHn4sFzWvPSSPPY2xCQjQwIZ558vMQe/iRPbtkmqzeuvS0XRlhb/B42Lk2lQLBY56EknMZBBRCEXlIyN5cuXa33YoLDb7XA6nbD4GIaQm5uLvLw8lJaWYsmSJSE9FoXAaafJLaULLpAP64MHJY30rbfkA5mIiIh82rtXhjdUVEhZhY4O3/slJEhWxkUXSTAjPT2UvexFW5tcAyxbJlkavupmJCfLcNUf/Ui+rMfpUpbOr5YWSZ74z38kO6Opyfd+BoMkT1x6KXDJJcBRR/mJy3R0ACtXqmOHVq/uvQNHHy0zvJxzjrw/o0YN9kciIhoUzf9KL1u2TOtDBo0yJMZfTQuj0YiysrKAghFaHotCZMEC4OWX5dO+rU1yZs8+G/jHP4D8fJ07R0REFD5cLsnK+Ne/eq+hmZamfoleuDDMSils3gyUlgLPPCPRme7i4qTj114rKQ1hlnXQ1ibJE2Vlkp3hLzNj+HCJOVx6qQSVxo/3c8D2dvnHrKiQ66F9+/yfPDlZDqpMWRuGxVGJaGjTPLAxd+7cruUnn3wS1dXVqKurw/z587F48WKM1mV+Lt+UoR/+hpqYTKaA615oeSwKofPPlyuE/Hy5YmhuBq68Uqqc3Xtv2KWbEhERhUpLiwxt+Ne/5Ca+v9EIEyYAl18uCQ5nnhl2yQ0ya8fDD8sX+M7Ons/PmAEsXixTwfuNAuhDKQD6zDOSnXHggO/9Ro2SQMbll0sSxYgRfg7Y2irRkYoKSbuprfV/8pkzZZaXiy4Ky3oiRESegvLRs2rVKuTm5sLpdHZtKy8vx4MPPoiKigr84Ac/CMZp+83pdAZcPyOUx6IQu+wyyee84gqZ1g0Afvtb4NtvZcwt51EnIqIhorMT+PhjqaFZXu6/AOjUqfKxecUVUl4hNjak3eyb2y3DTIqLZbxMdwkJ0vnFiyVbM8xuZNTWSkDp6af9z2aSmChxh/x8uU+TmOjnYG1tcp1TXi7jVvz9o8bGSjXRiy6SAx91lBY/ChFRSGge2GhoaEBubi5yc3ORk5PTNTTD6XRi+fLlyM3NxebNm8Mic8PlcgUUjAhkPy2PNRCzZ8/2ub2mpgaZmZmany/qnH028Pnn8mG+YYNse+EFmdLs5ZfD7g4OERGR1l57Dfj5z6VupC9jxkhS49VXSzmqMIsFiLY2SW14+GFgzZqez8+YAfzsZzLcZMyY0PevFx0dEn94+mkpyOqrEGtCggQx8vMl9uB3qI/bLZkqzz0n78f+/b73S0iQ4SW5uXJAXefZJSIaOM0DGw899BBKSkqwcOFCr+0ZGRlYuHAh8vLyYLVa8fjjj2t96qCpq6vTLBih5bFIYzNnSnAjN1fSNAHgs89kppTXXwfmzNG3f0REREE0blzPoEZioiQ2Xn21lFYI29EIra1SP8NmA3bs6Pn8SScBS5bIeI0wSy/ZvRsoKQGefNL/xCynnAJcfz2Qlwf0ehm5dauk2zz3nAyr9WX4cImO5ObKDZ0wuNlIRDRYmgc23G53j6CGJ4vFgtLSUq1POyBaBhj0DlasXbvW53Z/mRzkR0qKzIzy85/LBRIgV3mnnip3PC68UN/+ERERBcn8+UBmptTYzMkBrrkG+OEPw6wAaHdutwyxuOceoKam5/MXXSQBjdNPD7sUky+/BP7yF2D5ckk06W7CBOC66ySgccwxvRyoqUkO8o9/AB9+6HufYcPkvVi0SGaEC+t/VCKi/tM8sGEI4EMjLS1N69MOSGpqKuqUmgp97BfKY5HO4uOBJ56Qq4g77pCLpkOHJEVzyRLggQfCrlI6ERHRYBkMcrM/PV2+VIe999+Xz+WVK723x8dLVObOO4FZs3Tpmj+trVK38y9/Ab74oufzcXFyufHTnwLnnddHIdZvvpFUj+ee8z9FyhlnyLCbPlM9iIgim+aBjfr6+j73CSQAEApGo9GrwGl3ru+LKwWSjaHlsSgMGAzA7bfL8JQf/UgCG263pLi+9ZZc+R13nN69JCIi0tTJJ+vdgwCsWQPcfbdM2eIpNha48UaZ1WzyZH365seBA8Df/w48/jiwZ0/P56dMkdIfN9wgQ4L8am6WyMgTTwCffOJ7n6OOkmDG1VcDGRma9J+IKNzFaH3ArKws3HzzzX6fv/nmmzFv3jytTzsg2dnZANSgQ3dOpxNmsznkx6IwctFFcuHgWRn866+B7Gzg0Ud9TxtHRERE2tu1S1IZTjihZ1DjssuAtWvlC38YBTX27JHEkenTZcK17kGNM86QUSROJ1BU1EtQY9MmySKdPFmCFt2DGqNGATfdJGkg334L/OY3DGoQ0ZCieWBj8eLF2LRpE9LS0nDllVeiqKgIRUVFyM/PR1paGqqqqnDnnXdqfdoBKSwsBACfmRZKgCI/Pz/kx6Iwc/zxMon8Lbeo21pagF/9SgYhb9+uX9+IiIiindsNPPOMDCt55hlZV5x2mnzJf+kl4Oij9etjN9u3A7feKsN6/vhH4PBh9blhw6RuhsMhJTHy8nopyvrZZzIt7VFHAf/3f+q09AqzWWqC7dol6SDz54ddLREiolDQfCgKAFRWVsJqteLhhx/22p6bm4vly5cH45QDYjabYTKZUFZW1iObYvny5TAajSgoKPDa7nK5UFVVBYvFMuhjUQRJSgL++lfJ4Lj+evWWy7vvymwpf/+7DFnhxQQREZF2tm8HCgpkGKinY44BHnoIuOSSsPrs3bxZuvXMMz0Lgo4ZA/zyl/LjjB3by0E6O2W+10ce8T3cJClJrjluukkySImISPuMDYXNZkNnZycqKytRWVmJ+vr6sApqKMrLy1FaWuqVaeFyuWCz2bBixYoeNTHy8vKQk5Pjc2aX/h7Lk/Iaf0NZKEycd56M7b3iCnVbQ4OMY120yPcUc0RERNQ/bjewbBkwe7Z3UGP0aLmZsGaNTN0aJkGNrVvlvsfMmZJA4RnUmDBBsja2bAF+/eteghpHjkgx0GOOkaE13YMaRx8tN1l27ZK5YRnUICLqEpSMDQBobGzE6NGjvaZ+fffdd7FgwYJgnXJAzGYzqqurYbVaYTKZkJaWhpUrV6KkpMRnTYycnBxUVVV11dQYzLFKS0tRXl6Ouro6OBwOAMDChQu7jl1SUgKTyaTxT0yDNmaMTC33/PMyLWxjo2yvqJAxv/fcI+Nghw/Xt59ERESRaMsWYPFiwG733n7++RI1mDJFl2750tgILF0qZbdaWryfmzoVsFqlIGivlwRNTcBjj8lQk/37ez5/xhnAXXfJlPMxQbsnSUQU0Qxut+dARW0sWrQIL774IjIzM7Fhw4au7V999RUeeughlJWVaX1K8mP27NkAgLVr1+rckyi1datMMt993viMDLlACaO7SURE4YKfTdqKmvezs1OKf1qtMhuZwmgE/vQn+bwNk8/U9nZJmrjvvp6xiIwMKQT64x8DCQm9HKS5WX7epUuBffu8n4uJAS6/XCqPnnSS5v0nIgq2UH82aR72VYqFLliwoEd2xty5c1FaWopHHnlE69MS6WP6dOC99+TqxjO3dPNmSSM991xg/Xr9+kdERBQJDh0CcnOlULdnUOOSS2S2kx//OCyCGm438OabMjHLzTd7BzUmTQKeegr47jtJOPEb1GhtlSEnM2bI1PKeQY3ERHkPNmyQ7FAGNYiIAqJ5YKO+vh5z585FZWUlnnjiiR7PJycna31KIn3FxEie6YYNcoES5zHCq7JSZlW5/XaA9VOIiIh62r5dhlu8/LK6LTUV+Ne/gFdekYhBGFizRu5XXHABsG6duj0pCbj/frkM+OlPe5nhpL0dePZZqaFx003Azp3qc4mJkqmybZvU0cjMDOaPQkQUdTQPbBgCiKbX1NRofVoi/RmNMvzk669lGlhFe7uk0GZkAA88wAAHERGR4osvgHnzgFWr1G3nny+Rg6uuCossjSNHgCVLgBNPlPsVCoNBCoZu3Aj89rfAiBF+DuB2yywnxx0H/OQnktWpSEgAfvELwOmU6VTGjAniT0JEFL00D2zU1NRg69atfe5DFLVmzQLeflvuMmVkqNtdLrmlk54uj/X1unSPiIgoLPz738BZZwF796rb7rgDeO01YPx4/frl4aOPZNjJww9LCRDFggWAwwE8/XQfCSUbNkiKx6WXyhgVRVyczPu6aZPc/JgwIVg/AhHRkKB5YGPJkiUwm8142TOd8HuNjY0499xzcc4552h9WqLwYjDIRcy6dcD/+38yPZ2ioUEyN9LTpepYXZ1u3SQiIgq5zk7g3ntlqnRlKpH4eKlX9cgjQGysvv0DcPCgTHx25pmSkaHIzJTkC7tdMjj8OnQIuPtuydLwnK42JkaKoH77rdTZmDo1WD8CEdGQonlgw2KxwGq14oorrkBaWhrmzZuHc889FzNnzkRKSgqcTifuvPNOrU9LFJ6GD5fpX7dskTxVzxozjY3A738vAY7f/Mb3FG9ERETRpKkJWLQI+MMf1G1paTLG44Yb9OuXh8pKYM4c4G9/U7fFxEgyyerVwMUX9zJCxu2WTJSjjwZsNqCtTX1u4UI5wLPPsoYGEZHGgjIZ9pIlS1BVVYX09HRUV1ejsrISNTU1uOKKK7DRM+xNNFSkpMjwky1b5NFoVJ87eFCyOqZOlbG31dW6dJGIiCio9uyRIqEvvqhumzUL+PJLGZKis/p6Kf55zjkym7ti9mzgs88kmSQpqZcDrF4NnH22ZKLs2qVunzYNqKiQiMn30x8SEZG2ghLYAACz2Yzq6mp0dnaipqYGnZ2dWL58ebBORxQZjEbJ3NiyBfjd7yTgoWhpkbs42dnAaacB//mP950eIiKiSNXQAJx3HvDVV+q2888HPv0UMJn069f3Pv5YRo0884y6LS5ORoxWVwPz5/fy4pYWoKgImDsX+PBDdfuwYTLkZv164IorwqIQKhFRtApaYMNThmcBRSKSISn33isBjj/8oWfRsE8/BX70I2D6dAmA7NmjSzeJiIgGraUFuPxymTVM8YtfSLEKzyGaOnC7gUcflUQLzyQLsxmoqpKSWMOG9XKA1asl6vHQQ97VRS+5ROps/e53faR5EBGRFkIS2CAiP0aPBn79a8l5/de/gJNP9n5+927J8Jg2TS4K//tfoLVVn74SERH1V2enFMt891112113yUwgcXG6dQuQkaD5+cCvfgV0dMi2+Hhg6VKZhfaEE3p5cUeHBDOysyW4ocjMBP73P/m8DoNMFCKioYKBDaJwkJAAXHWVDOJduVIuAhMS1Ofb2oCXXwZ++ENg8mTgttskN9bt1q3LREREvXK7gV/+EvAcinzttRIQ0Nm6dZJoUV6ubpsyRaZ3vfvuPmIumzbJdClFRd5DRm+5RbJSzj8/aP0mIiLfGNggCjfZ2VJrY/t2mTVl0iTv5w8cAB57TPabMwcoLvbOnyUiIgoHNpt8XinOPRd46imZYkRH//mPBDW+/VbdZrEADgdw0km9vNDtBh5/XFI5Pv1U3T55MvDOO8Bf/wqMGBG0fhMRkX8MbBCFq3HjZBrYrVuBN96QfNnuA33XrgWsVrnNdMYZMlDYs5Q7ERGRHv7xD8loUGRny8wg8fG6dam1VUp7/OhHMuus4je/Ad56Cxg7tpcX79snmRg/+xlw+LC6/ZprgDVrgJycoPWbiIj6xsAGUbiLiwMuuEBuMe3ZA5SWyqwpntxuKen+q18B6enAvHkySHjDBl26TEREQ9gbbwA33qiuz5gh20aO1K1L9fXAwoXAX/6ibjMagddfl+TI2NheXlxdLYGZt99Wt6WlSaDmuee8ZzgjIiJdMLBBFEmMRmDxYglibNwo89Clp/fcr6oKuOce4OijZf66e++V+h1KdTQiIqJg+PxzIC9P/bwZP14CAuPG6dalPXuAs86Sj07F3LkSr7jwwj5e/K9/AaefLsNDFRdfDHzzjUzhSkREYYGBDaJINWOGzEPndEogo6gIOOqonvutXStTyp56quTZXnml1PDYuzf0fSYioui1eTNw0UXAkSOyPmoU8Oabus4OsmWLjNRcs0bd9pOfAJ980ke32tuBO+6QoSbNzbItNlaGfP73vz2naSciIl0FLbDR2NiId999F08++WTXtnc9p/oiIm0YDEBWFvDgg1IJ7ZtvJOBx/PE9962vB8rK5KpuwgR53a9/DXzwAdDSEvKuExFRlHC7gcJCoLZW1uPjZTavuXN169L69ZJssWmTuq2oCHj6aSAxsZcX1tZKPY3/+z91W2qqZJ788pfyuUtERGElKIGNRx55BCkpKbBYLCgsLOzanpKSgvz8/GCckogAudiaPVuGqHz9tQxXKS4Gzj7b99x1DocERM4+W4a5LFggg40/+oiBDiIiCty//w1UVqrrpaVS1EIn1dWSqbFzp7rNZpOPvF7jEmvWSJ0qu13ddvzxkhmp489DRES90zyw8eKLL+KJJ57AE088gZqaGtx1111dz82dOxelpaV45JFHtD4tEfkyYwZw113Ae+/JHaiXXwYKCoCpU3vu29ws+913H3DmmVIMzWKRYSwffOBdBZ6IiEhRVwfcfru6ft55wI9/rFt3PvwQ+MEP1OQRgwEoKQGWLOnjhRUVwCmnyJAaxaJFMrVrRkbQ+ktERIPn4xbu4CxfvhybPHL+xowZ4/V8cnKy1qckokCMHg388IfS3G7J0X3zTZnj7pNP1DHRiiNHgBUrpAEytviEE6RWxymnSEtPZ0ouEdFQd9ddwP79spyUBPz977p9NrzxBpCbq5bFiIuTiUuuvLKPF/7tb8DPf66uGwyS3mG18nOOiCgCaB7YyAggol1TU6P1aYmoPwwGYNYsaXfcAbS2Al9+Cbz/vmRtfPqpelWo6OiQoSsOB/DXv8q28eMl0DFvntTryMqSKfCIiGhoeP99KVqheOAB3bIbysqk1md7u6wPHw68+KLMmN6rRx6R4IwiORl44QWps0FERBFB88BGQ0OD17rb7e6xT62SG0hE4SEhQSqsnX468JvfSH2NL7+UIMcHH8jyoUM9X7d3rwxveflldVt6uhrkYLCDiCh6NTdLwVDFiSdKcU0d2O3eQY1Ro4DXX5eRlX653TLc8r771G3TpgHvvCPTpRMRUcTQPLCRnJyMn/3sZ/j73/8OADB0S9/Lz8/H/PnztT4tEWlp2DCpunbGGbLe0SGzrXz6KfDZZ9I8y8x72rJF2osvqtsmT5bia57t6KOlaj4REUWmpUuBDRtkOSZGCob6KlQdZN98A1xxhRrUSEuTCUyysnp5kdsts4ItXapuM5mAd98Fpk8Pan+JiEh7mn/6PPTQQ8jKykJaWhosFgucTidqa2vhdDpRUVEBk8mEsrIyrU9LRMGk1Nc44QTg5ptl2/79wOefS6uulnbggO/X79wp7c031W3x8TIUZs4c4NhjZfnYY4HMTF0ujImIqB/Wr/cOCtx6qwxLDLHdu4ELLwQaG2U9KSnAoMbttwN//rO67ZhjJO1j8uSg9peIiIIjKN8eqqurUVhYiGXLlnWtA0Bubm7XNiKKcGPHAhdfLA2QC8Xt2yXAUVXVd7CjrU2mpP36a+/t8fHAUUdJkENpM2dKY/FhIiL9dXbKEJS2NlmfMkWmCg+xpib5CNq2TdYNBimN0WtQo7MT+NnPZJoUxZw5MlXt+PFB7S8REQVP0G6LlpSUoLi4GE6nE3V1dcjOzuaMKETRzGCQscnTpgGXXSbb3G7J1FizBli9Wm3ffqvmDHfX1gasXSutu3Hj1CDHUUfJ44wZUqiOf1+IiELj6aeBjz5S1//2NylqEUIdHcBVV0n8XPGnPwGXXNLHi264AXj2WXVbVpakeLAWFBFRRNM8sJGamop77rkHd955J5KTkzF37lyf+7300ksoKyuDyWRCYWEh0tPTte4KEenNYJA7eVOmeFeXb2mR4MbXX0sAY/16aU6n3E3zZ98+aZ980vO51FQZH52RIY/Kcno6MHWqlMcnIqLB2bvXewaRyy/vI5oQHHfcAbz6qrp+663Abbf18oKODqku+p//qNtOOUWGSDIwTkQU8TQNbGzevBk2mw2LFi3qdb+HH34Yd999N6644grU19cjJycH1dXVGD16tJbdIaJwNWyYWrPDU3OzFKJTAh3r1sn6xo3A4cO9H7OuTlpVle/nx4+XgnDTp0tWibKsBF7GjJHid0RE5N/ttwMulyyPGgX85S8h78Jjj3mXx7j4YuDRR/t4kdXqHdQ4+2zgtdeAkSOD0UUiIgoxTQMbGRkZcDgcyM/PR1FRERwOB7KysnD33Xd7BS2WLl2KJUuWYOn3RacqKipQWlqKO++8U8vuEFGkGT5cnTXFk9sN7NolAQ6lKQEPp1MCIn3Zu1fal1/6fj4hAZg0SQ10TJ4sjxMnSps0SR5HjBj8z0lEFIm++EKKWCgeeijkxTZfe817RlmzGfj3v6XGtV8lJcAf/6iu5+QAr7wilUaJiCgqaD4UxWKxwGg0dq1XVlaipKQE1dXVSE9Px+bNm+FyuVDoMe95bm4ublZmWiAi6s5gkIvnyZPlLpsntxvYswfYvFmCHE6n9/KuXb0Pb1G0tqpT1fZm1Cg12DFxomSCKG3cOO/1YcMG+AMTEYWh0lJ1ed484KabQnr66mrgyivVP+lTpwKvv95H0kVlJXDLLer6iScCL73EoAYRUZTRPLBRVlaGkpISLF68uGtbaWkprFYrysrK4HQ6YTAYetTUYGFRIhoQg0ENMpx6as/n29qkgOm2bcDWreqjsrxjB3DoUODnO3hQ2oYNfe87erTMHjN2rAx16b48ZowUrFOa0djHbUciIp00NnoP5bj99pAO3zt4ELjiCnVU4qhRwBtvyJ9+v9atA3Jzpb4GIJl3HH5CRBSVglI81DOoAQAFBQVwOBy9vs5gMGjdFSIimT42PV2aP42NEuDYsUOCIJ7Lu3dL27s3sMyP7sdtbARqagLb32CQ4IYS6EhNBVJSvJvnNqNRit4ZjXKVzxohRBQsZWVqVCElRZ39KkTuuEPi0YDEfysqZJZWv/btAy68UP4GA5Kh8dprMsSQiIiijuaBDX8Bivr6egCASyk4RUQULkaPBmbNkuZPR4dcKCuBDs+Ax759ag2PvXvVwnr95XYD9fXSNm3q32sNBglueAY7Ro/uvY0aJXcuuz9yCA0Rdbdsmbp87bUhnWnqzTe9T3/vvcA55/TyguZm4Ic/VIcWGgxSiMNsDmIviYhIT5oHNtxuN4qKilBYWIjU1FTU1dWhpKQEqampAIC6ujoAwMGDBzHKY87zmkDvaBIR6SE2Vh3y0peWFnVq2gMHgP371ea5Xlsrra5OTZUeKLdbzRAZrPh4CXCMGCHN33JSkv+WmChffBITe7bhwyV4wkw9osjw9dfAypXq+g03hOzU9fXAjTeq62YzcM89vbzA7Qauvx747DN128MPA5deGrQ+EhGR/jQPbNhsNmRlZaG4uLhrW0ZGBiwWCx5++GEsXboUixcvxpIlS/D4448DAPLz83FTiAtQEREFzbBhUtVu6tTA9u/slICEZ6BDeVQyOJTmua2hAWhq0r7/bW3qOYJp2DAJcng2ZduwYTJTjedj920JCRKEUZaVdc8WF9dzOS7Ou8XG9lyPjZWhPcpy920xMT2bwaA+BpPbrbbOTmmeyx0dPZc9H9vbfT92dMi/fXu72rqvt7cD110X3J+Pws9TT6nL8+f3nLkqiH7xC6kBDch/8Weflf/Gft1/v3ctkIIC4Fe/CmYXiYgoDGge2EhOTsamTZtQWlraNd2rUnPjq6++QkFBAZKTk1FYWIi0tDQAMpPKggULtO4KEVFkiImRoSNGI5CZ2b/XtrVJUMTlkkBHQ4O6rGRw+GuHDkk7eFAdOx9KLS3SGhpCf+5QMBjUIIey7LnNcz9PStDCc7n7up6uvZbZNkPJkSPAc8+p657pE0H2yivep/7d74DjjuvlBc8/LzspLBbgr3/l7ysR0RBgcLv1u0JasWIFUlNTMXfuXL26EPVmz54NAFi7dq3OPSGisNbRIdkfSqDj0CF1vanJe/nQIQmE+GtNTTLG/cgRtTU36/0Tklba2iSzZRD42aStoL6f//43cPXVsjxihNQW8hhKHCwHDgCzZ8uIPgA4+WTg4497mThq/XoZp6L8rTn2WODTTyVgTEREIRfqz3rNMzYCsWXLFqSnp2PhwoV6nJ6IiLqLjVWLigaD2y3ZGZ6BjpYWeVSa53pLC9DaqmZ1eC63tMiX67Y22d7a6r3c2uo9jMLzUVlWhmB4NmUohjJsI1rFxHgPufFc9jdkx3M9mt8b6unJJ9Xl/PyQBDUA4Gc/U4MaiYkyBMVvUEMZIqUENcaMAV5/nUENIqIhRJfARmFhId5++209Tk1ERHowGNQ6Gikpevemb8qQD6X2hGfzrGfhq/kbPuJrGImv9e5DVrqvx8aq9Ty61/bwVQek+zLT8ilQmzYB772nrodoGEpZGVBerq4vXQocdVQvL1i6FKiqUteffhowmYLWPyIiCj9BCWw0NjbCbrd3zYDiyeVyocrzw4eIiCjcKIGEmJg+KhUSRbGnn1aXZ82S8SBBtmePZGsozjoLuPXWXl7w1VfedTWuvx64+OKg9Y+IiMKT5oGNFStWICcnp9d9DLxbRERERGHK6XTCZrPB+P1QBqfTiaKiIpjN5gEf0263w2q1ory8HKZIyCZobweeeUZdv/HGoGf7uN0yiYlyX2zECOlCTIyfF7S0yBCU9nZZnzYNePTRoPaRiIjCU1Cme7XZbLBYLF0XBJ7q6+uRn5+v9WmJiIgoSDo7gXfflZFEp5+ud2+Cy+FwIC8vD5WVlV0BCJfLhaysLNhsNuTm5gZ8LKvVCofDAZPJBKfTCYfDEaxua+9//5P0CUDmWb322qCf8rnngNdeU9f/+EcgI6OXF9x3H/DNN+r6M88AyclB6x8REYUvzQMbZrMZd911l9/nMzIyOAsKERFRBKirA/7xD+CJJ4CNG2VYwPvv692r4MrLy0NhYaFXVoXRaITNZsPixYv93rjxxWazdS1brVbY7Xatuxs8y5apy5ddJgU5g+jIEeDuu9X1c86R7A2/Pv0UePhhdf3WW4EFC4LWPyIiCm/+kvsGLJBhJsuXL9f6tERERKQBtxv44gvgJz8BJk8G7rhDghoA8MEHwLp1unYvqOx2O5xOJywWS4/ncnNz4XK5UFpaqkPPQmznTsnYUISgaGhJicwkCwDDhklcxe8lZVOTDEFRiu/OnAk89FDQ+0hEROFL88CGyWTCli1bet3n5ptv1vq0RERENAhNTfJlMitLakQ++6w6eyYgXzIvuEAtZxCNKisrAcBvDQyj0YiysrJQdkkf//iHOq1venrQMyGammRiE8VNN0m5DL+sVqCmRpZjYuSXNSkpqH0kIqLwpvlQlMWLF+Oll16C3W6HxWJBampqj30iKhWTiIgoSrW3y2yeyvSajY099xk7FrjhBhkW0Gu9gyigXJ/4G2piMpkiq07GQHR2Ak89pa7fcEMv1Tu18be/Afv2yXJioveQlB7sdnmBYskS4JRTgto/IiIKf5oHNtLS0gBIoS0iIiIKLx0dwMcfSzCjogLYv9/3fmecAdx8M3D55TI0YChwOp0B18+IWu+9B2zeLMsxMTImKYgOHgSKi9X1n/8cmDDBz84ul0znqpgzB7j//iD2joiIIoXmgQ232w2LxQKTydQV5PB04MABPPnkk1qfloiIiPzo7JS6GUpmxq5dvvcbNUpKF9x0E3DccaHtYzhwuVwBBTYC3S8ieV6jnX8+MGVKUE/3l78AtbWyPGIE0Ev9eSn4smOHLMfHA//859CJuhERUa80D2yYTKY+i4N+9dVXWp+WiIiIPNTVAe+8IzUg33rLf2ZGfDxw3nnAlVcCl1wCjBwZ2n5Gorq6Ol0CG7Nnz/a5vaamBpmZmYM/QW0t8NJL6nqQi4a6XMAjj6jrv/iFDH3y6euvZTpXxW9/C5x4YhB7R0REkUTzwMYyz+nBulm1ahVMJpPX9GdEREQ0eG63fPf73/+kffaZWv+xu9hYwGKRYMYPfwhEa/JBf0VtFkag/v1voLVVlsePBy68MKine/RRCW4AwOjRkpDh169/rc6CMmuWFBAlIiL6nuaBjblz5/p9rqamBitXrkRDQ0Ov+xEREVHv3G7g229lCtb335fHPXv87x8bC5x5JpCfL3Uz/N4Zj0A5OTkDLkxeX1/fFdBITU1FXV1dn6/xVRg9FNauXetzu79Mjn5bvBhIS5PhKCedJOk8QVJbK4ENxe23A37f1o8+At54Q11/8EEgTvNLWCIiimAh/VS44oor0NDQAIvFgjvvvDOUpyYiIoponZ3A2rUSwPjgA+DDD9WZJPwZP17KJJx/PpCTA6SkhKavoaZM0zpYRqMRTqfT7/NKYfSozewYPhy46ipp/tJ9NPLHP0rhUEB+L2+/3c+ObjdQVKSun3yyjJkiIiLyEJTAxpNPPgmbzeb34sBisQTjtERERFHjwAEp+Km0L79U0/b9MRjkRvsFF0ibOzfoM3VGlezsbDgcDr/FQZ1OJ8xmc+g7pocg/uLs3y9FQxV33gkkJ/vZ+X//Az75RF1/6CH5RSciIvKgeWDjq6++QkFBASwWCxYuXIiqqipkZ2cDkAsCk8mEJ554QuvTEhERRayDB4HVq4GqKjWQ0UviQBeDQWa8PPts4KyzZKjJmDFB727UKiwsRGlpqc8AhpKtkZ+fr0PPoovNBjQ1yfKYMcCtt/rZsbPTO1vjvPPkF52IiKgbzQMbDz30EKqrq7tqaCxbtgw5OTlIT08HAGzevBlPPvkkbgxypW0iIqJw43YDO3cCq1ZJoc9Vq6Rt2hTY62NiZCKIs86SdsYZvdQloH4zm80wmUwoKyvrEdhYvnw5jEYjCgoKvLa7XC5UVVUxGzVAu3cDf/ubur5kiUwz7NMLLwBr1qjrDz4Y1L4REVHk0jywkZGR4VUY1GQywel0dgU2MjIy4FaqWhMREUWp/fulJsa6derjmjVSNDFQ48fL0JL58+Vx3rxeUvZJE+Xl5Vi4cCEKCwthMpkASPDCZrNhxYoVPYao5OXlwW63o6SkpEfQw5MyPNfV13iiKPfQQ0BzsyyPHw/ccoufHVtbgfvuU9fz82VsFRERkQ+aBzYM3cY9Lly4EPn5+ViwYEHXtoaGBq1PS0REFHLt7cDWrcCGDdK++04NZBw40L9jjRol2Rjz56uBjGnTWE4g1MxmM6qrq2G1WmEymZCWloaVK1eipKTEZ32NnJwcr2G3nkpLS1FeXo66ujo4HA4Acl2k7FtSUtIVPBkKduwAPEcjFxUBSUl+dn7ySXU8Vmws8PvfB71/REQUuTQPbLjdbmzZsgU2mw1WqxXp6emoqanByy+/jMsuuwyAVC/nrChERBQJ2tqA7dvlO1ZNDbBxoxrIcDrl+f6aOlWCGJ4tPZ2FPsOFyWRCeXl5QPsuWbIES5Ys8flcQUFBr1kcQ82jj0oiBgBMmgQUFvrZsakJ+N3v1PUbbwRmzgx6/4iIKHJpHtgoLCyExWLB5s2bkZmZiTvvvBN33303rrjiCmRlZcHlcnEcKhERhY3OTmDvXsm82LoV2LxZAhZK27YN6OgY2LHT0oDZs6XNmiXthBNkO9FQ0t4OPP+8um61yuyyPv3lL/KfEpCdPIekEBER+RCUGhvV1dWoqqrCwoULAQC5ubl46KGHcPfdd8NsNsNms2l9WiIiIp+amiQFfvt2edy2TQ1ibN0q68pd5IEwGIDp0+WG8lFHAcceqwYyxo3T7ucgimTvvAPs2yfLCQnANdf42bGuTqZNUdx2m6R3EBER9ULzwAYAJCcndwU1FL2lahIREfVXZ6cU6Ny1y7vt3KkGMXbsALSo1WgwAJMnAxkZagBDaZmZvdx5JiIAwHPPqcsXXdTLbD42G6DUYktOltQOIiKiPgQlsNGXLVu2dM2SQkRE5Km5WbLQ9+yRqSH37PFuu3dLAGPPHklv14rRKJkX06dLsCIzEzCZpE2fzuAF0UA1NACvvKKuX3ednx137pRhKAqrlfMZExFRQHQJbBQWFuLtt9/W49RERBRinZ2SNbFvn2RY7N8vgYu9e2Wb5+PevUBjo/Z9iIuTbPapU4EpU9QAxvTpMvPI9OnA6NHan5eIgBdfVKd4TUsDzj/fz44PPqjuOGGCDEMhIiIKQFACG42NjbDb7airq+vxnMvlQlVVVTBOO2BOpxM2m61rbnqn04mioiKf07ppfSwtz01EFAqtrUBtrUxnun+/PCpNWd+/3zuQMdDim4EYMUKGiUyapDYlgKE8jhsnM0YSUej985/q8pVXSo2NHg4eBJ59Vl2/9175z01ERBQAzQMbK1asQE5OTq/7GAwGrU87YA6HA3l5eaisrOyaS97lciErKws2mw25ublBO5aW5yYi6i+3Wwpr1tVJoEJpyvqBAz0fDxyQ7x+hkJoKTJwoN267N89AxqhRoekPEfXf1q3ABx+o636HobzwgvxBAmRc2PXXB7trREQURTQPbNhsNthsNlgslq4sBE/19fXIz8/X+rQDlpeXh8LCwq7AAgAYjUbYbDYsXrzY78+hxbG0PDcRDV1uN3DkiAQklKBEIMu1tYObDaS/4uKAsWOljRsHjB+vPnoujxsnbdiw0PWNiILDc4rXo44C5s3zs2Npqbp87bVAYmJQ+0VERNFF88CG2WzGXXfd5ff5jIwMzJ07V+vTDojdbofT6YTFYunxXG5uLvLy8lBaWhrQbC79PZaW5yai6OB2SzaEEnzoT2tpCX1/k5KAMWMkUDFmjHdTgheej0ajzC5CAWpvBw4fltbUJO3IEXlsbpbtymNLizzX3Ky2lhZpynJbmzy2tkpra/Nu7e3qY0eHNGW5s1MelSgaUQDcbu9hKNdd5+dvgMMBVFer64sXB71vREQUXTQPbAQyzGT58uVan3ZAKisrAcArY8KT0WhEWVlZQMGF/h5Ly3MTUXjp7JQCmJ4ZEt0zJvy1YNai6M3o0TL0Iy1NbWPG9P6YlKRPX/uls1O+xB865B0gaG5WHz2DBEeOeAcJlOCAZ/MMDHgGCDwDA0rzFRzo7OzZ3G61hbv2dkm/IerDypXAhg3q+tVX+9lx2TJ1+eSTgTlzgtovIiKKPppfmZhMpj6nc7355pvx+OOPa33qfrPb7QDgd7iHyWSCw+EIyrG0PDcRBc/hw971J7o3z4CFZ+Cis1Of/o4YIQEKJUjh+ehrWVmPj+/HSZRgwYFDkmKiBAuamiSAcOSIvHFKdoFnJkH3gIESJPBsnlkEHR3eWQSe2QS9BQciIUAQqQ4f5hQyFBDPbI2zzgJ8Xho2NQH/+pe6XlAQ7G4REVEU0jywsXjxYjzyyCMwGo2wWCxI9TH/uPKlXm9Op1OzGhb9PZaW5yaiwLS1qTN2dJ/No3tTimXqlXU/erR3ECLV2IHUka1ITWxG6rAmpMQfQlpcA1JjG5Aa40Iq6pDSWYthbYfki4ISWGhuBrY3A5s8hiV0DyB4Zhj4Chy43eojhReDwbvFxHi32FjvFhcnLT5eXU5IkPX4eFlOSJACJ55t+HD10eeUFkTeWluB//xHXfdbNLSsTK1IPHo0sGhR0PtGRETRZ8CBjdgomDfP5XIFFFwIZL/+HkvLcwPA7NmzfW6vqalBZmZmn68nikQdHRKA2Lev96YEM1yu0PbPgE4YEw4jLa4RqXHfByAMLqQZapHqrkOKuw5p7gNI7fRuxo5axDW1AQc7gc0MJoREb8GB3gIEnoECJVigBAfi4yUYoDwqAYPhw70DBcOHS6FEz+XERBnrk5goaTiJicDIkbItIUH6RBTG3nxT/j4D8mvtd6I3z2EoV1/NKV6JiGhABhzYSE5OhsVigclkQlpaWsCvO3DgAJ588smBnlYXdXV1mmVX9PdYWp6bKBK43UBDA7B7N7BrF7BnD7B3r/ejsrx/f+iGfIzAIYzBAaShtkdLRZ3Px2Q0ILa1EwjhzCNhQwkQdA8UxMbKY1xczwCBv+CAEhBQtiUkqIEAJTigBAOUdSUY4Bkc8Nw2ciSDA0RB5DkM5Yc/9DN6ac0a4PPP1XUOQyEiogEacGDDZDINuAjoV199NdDTakrLgEF/j6V1sGLt2rU+t/vL5CDSQ3MzsHMnsGOH+rhrlzQlkLF7d/CHfyTiMMZiP8bgQNejr+YZvBgWrtEJz0wDJWjgb9iBZ6Cg+3CD7pkDSgBACQwowQAlc2DECHkcORIYNUoeOUSBiCB1hl5/XV2/9lo/O3pma2RnAyeeGMxuERFRFBtwYGOZ54dRP9lstgG/Vkupqamoq6sLaD+tj6XluYnCQXu7BCa2bZO2taYN2745iO3OVuzYE4cdtYmoPRKcFONhaMZ47MU47PNqY7G/61FpY3AAI3A4KP3oMWxBCSp4ZhooWQZKhoFnAEHJKlCCBqNHS9Bg1ChZHj0aSE6WeVOTkphxQERhaflyqbEByHTP55zjY6fDh4HnnlPXma1BRESDMODAxty5c3t9vrGxEaO75R2+++67WLBgQZ+vDRWj0Qin0+n3edf3A/IDya7o77G0PDdRKHTWubD7EyecX+6Hc+0RbN4SA+feEdjcmIptzeOws308Orz+pMQDGHhgLh6tmIjdmIA9mIA9GI+9PR6V5ZE4hL4nmoaa1RA3XM1gUDIWugcYlEyE5GRpSlAhNRVISfGo6pkaIfOeEhGFhme84uqr/cwOXFGhFj4aMQK48spQdI2IiKJUUCaiX7RoEV588UVkZmZig8cE5ikpKcjPz0dZWVkwTttv2dnZcDgcfgt0Op1OmM3moBxLy3MTDVhnJ7B5M7B6NfDdd+jYtBnbNrZg445EbKgbg42HJ2FjWzqc7gxsQTpaMPjfSQM6MQF7MAU7MBk7MRk7MQm7MBG7vR5TUYcYuNVghJL5MHy4R/BhDJCcKUEHo1ECDmPGSBs7Fhg/Xtq4cfI6IiIKqk2bgE8/VdcDGoZy1VUSSCYiIhogzQMbRUVFKCoqQn19fY/ZOObOnYvS0lI88sgjuPPOO7U+db8VFhaitLTUZxBByZjIz88PyrG0PDeRX3v2AJ99JoGLjRuBrVuB3btxqLYF6w5OxbqOo7AOs7ABR2EDLkENMtGKYYM65Vjsw3RsxTRswzRsw1Rsx1TDTkyJ24Mpw/ZjQlIj4kcNl+yHlBRpY8cC46YD4+cDkyYBkycD06ZJgILDLYiIIoZntsZxx/kpm7FuHfDxx+o6h6EQEdEgaR7YqK+vx9y5c1FZWenz+eTkZK1POWBmsxkmkwllZWU9ggvLly+H0WhEQbcPW5fLhaqqKlgslkEdayDnJurh8GHgk0+AL76QC8WaGil0UV8PHD6Mw+7h+AbH4Rsch3U4EetwFdZiNrZh+oBPORb7YDJsRkbsdpiG70LGyP2YnnYI0ye2YmpGHBKnjZWghMkEzDhNsiUYnCAiinput3dg49prJemuB8/Z8U48EcjKCnbXiIgoymke2DD4/ATzVlNTo/VpB6y8vBwLFy5EYWEhTCYTAAle2Gw2rFixoscwkby8PNjtdpSUlPQIPPT3WP3dn4aozk6guhr48EPA4QC++w7Yvl2CF21tXbsdQBpW4UR8hSuxCidiFU7EtzgGnYjt9ymnxO3BUaN2YebYBsxMb8OMWQkwzR+DjLOmYeSkcQDGAThJu5+RiIgi3iefyOhGQAIaV1/tY6fmZuDZZ9X1ggI/0Q8iIqLAaR7YqKmpwdatWzF9uv87wuEU2DCbzaiurobVaoXJZEJaWhpWrlyJkpISnzUucnJyUFVVhezs7EEfq7/766mzkzfdQ2LtWuCtt2SA8rp1Mh/qoUM9djuIkViJ0/E5TsYXOAnVyMJOTOnXqf5/e/ce50Zd7g/8k93t9t6mu6UtBYokQFuKXJIt9shN2oSLogImZ4+giEo3CupBjybWyw9FZcniQT0okgWPeAFss4BHuSelclOgu1EuBVvJlGtpaXd3em+3253fHw+TmWySbXY3ySSbz/v1mtfObSffnU4zyTPP9/lOGteHhUftwqL312L+4qk4fn4Njj8eOPZYYNKkOQDmFOiPIiKiavDAA8b8smXSqzDDfffJeLCA1Eu69NKStI2IiMa2ggc2gsEgXC4Xbr/9dlx88cVp23bs2AG/349zs477ZR2Hw4FoNJrXvsFgEMFgsCDHGsn+VrnmGuDmmyW4oY9gqddw1Eei1Gs3NjYadRvnzDFKJsyZw+BIysAAsGYN8H//J0GMZBLYvl3yeAfvChtexgl4Fh/AM1iCZ7AE67AIGvI7mRMnali0yIZFi4BFi4ATTpCf8+bVo6aGwwkTEVFhPPGEMX/BBTl2am835pubpd4SERHRKBU8sOHxeBAKhfCJT3wCM2bMgMPhQENDAxRFgaIocDgcZVE4lIZn2zb5OTAgY9P39QG7dwPd3cM7js0mwY1x44zgiD7K5tSpxuia5gEuDjtMpjlzZDr8cBkco2IMDEjw4r77JE93wwYZ4i5LEAOQQMZLOBFrcA7W4Bw8gbPQm+ewqTNnAqeeKl2W9Z/HHWfLPtQeERFRgezZA6xdayyfdVaWnTZsAP7yF2OZtcSIiKhAivJ1JxgMwuPxYPny5ejq6kqt9/l8WLVqVTFekopMzxodLU0DDh6Uad8+YOfOkR9r8Cig48cbgZLJk4EpUzKzSRoa5Mt/Y6MxCujs2QUeCXRgALj/fuAPf5CAxptvyrocNAAv44RUIONxnI1uzDzky0yfDpx2GrBkifw89VTJjmFXZSIiKrVnnjHKPk2dmmM0lDvuMOZPPBH4AGs1ERFRYRTtOa5ePwIANm7ciGOOOaZYL0Ul0N4uI4Zu2iQjiG7ZItkaPT1Sw3LnTikFsXcvsH+/ZHQcPDjk9/lR0zSgv1+mvXtHfzw9UKJ3tamvl4CH3uVGD5ZMmzYoWGLvR+O/nsWsvz+Kw9Y/hVnb1mEmtqIOuf/4vZiA1ViG+2s+jvttF+Ltg4cP2baaGuD975cgxpIl8llw/nx27SEiovJg7oZy+unInil4//3G/Gc/y0g8EREVTMEDG4899hiWLl2atm5wUGPFihVobW0t9EtTEc2bJ9NI7NolSQvmoMi2bTL19kppie3bJTiyZ096cOTAAQmQ5Oi1UVDmQMm+fcP5zToAp783pY4GAKjBAGpxEHXoRy36AVsN+m3jsH+gHhpsyBX7sNlktNTTTgPOOUf6Kh85vNqgREREJWMObGTthvL228CLLxrLF15Y9DYREVH1KHhgIxAI4F//+teQ+3R0dDCwUUWmTAEWLpRpNPbsAd55R4Ij774LbN1qZI10dxvBkZ07pf7H7t0SoNi3zwiS9PdLFknxAyXyFGoAtRhALQ7gvaIgGvSYx5A0TeqJJpPA3XebjmpLL+CqZ5XodUqyZZQ0Nhpdb2bPlholc+bkeJpGREQ0TH19wN/+ZixnDWw88ogxf8wxwHHHFb1dRERUPQr+1aa7uxtr1qzBOeeck3X7F77wBSiKUuiXpSowaRLgdMpUCLt2SfbIu+/KtG2bBEh6e6W2p6oCOzZ2Y9c/38Su7QPYg4nYi4nYiwnow3j0oR797+ViDKD2vaMWN63WXKNk//7RH6+mxqhTMrhGiV7M1VzIdeZMqUty+OEyHXGEBFOIiKh6rV1rZDpOmAA0NWXZ6eGHjfkLLmA3FCIiKqiCBzZUVYXP58Pq1atxiqly1I4dO7Bs2TJ0dXXBxpsZlYEpU2TKCJQkk8B3vws8cP/Q1U1tNumf8+EPY+8Xv4b/W3csfvMbIB6XzJBsJk+W7IkpUySgsG+fdL3Rs0r6+uR3S9X9ZmBApgMHJCNmpGw2I4tED5CYa5LY7UbhVr1g6xFHSLHTo4+WoBUREVUmczeUJUvkPpCmvx+IxYzl888vSbuIiKh6FDyw0dLSglAohEgkAkVRcMkll+Cxxx6Dz+dDY2Mjurq6sHz58kK/LNHo7NgB/OhHwO9+J/1dchk/Xkq9f+pTwJVXYv3rE/DznwO/OT13DOT444HLLgP8fmDBguE9pOrrk2wSc/ebbduMoq2qanTB2bVLut/ogRK9TkkpAiWaJsGR0QRI9GGA6+vThwCeNi196N85cyQocuSREhSZO5dFVImIrGQObJx9dpYdnn1WbliAvNHnyOolIiIaqYIHNm699VYAwA033IDbbrsN5513HuLxOD7xiU+khnrt7Ows9MsSjcy6dcBVVwFPPpn7m399vXxS+853gLPOwsAA8OijwM8uTs+sNZszB/iP/5CAhts98ozb+nr5Al+owqG7dkncZssWCZZs3SpTb68ES8yBkt27JUixZ09mNkkxDAxIMGb//uEPA6xnjIwfL0ERfahfvcbI7Nnyb3LUURIMOeYYmWedESKi0envB55+2ljOWl/DfLM880z2YSQiooIr2sf6HTt2IBKJIJFIwOVy4fbbby/WSxEN3yOPANdcA/zzn9m322ySmfG1rwGXXgrU1GDnTuA3PwduvhnYsCHzV6ZOBS65RIIZS5dKV5NyM2WK1Gsbbc22/n7JIHn7bRntRq9Vohd01QMkO3ZIMEUf7aZYI92YM0Z27ZJ25MNmM7rP6HVF7HbJDtELrR59NPC+90nmzdFHMzuEiMjs+eeNYHRdnXRFyWAObLAbChERFUHBAxvHHXccwuEwrrzySjQ0NKCrqwsOhwPBYBBf+MIXcMopp2QdEpao6AYGgEgEuO46SVfI5uijgc99DggGpVAEJMPhxhuBX/1KvqgPtmgR8JWvSEBj8uQitr+M1NVJF5C5c0d+jIEB+Wd4803grbeMTBJzFomqGt1s9GGA9cBIIWiakY2yc2fuy8JM7zIzcaIRCNG7yBx5pARBjj0WmD9flhkIIaKx7PHHjfnFi7PUTHr3XcCcqXvBBSVpFxERVZeCBzaSyST8fn9a1xNAuqjceOONCAaDWL16NQ4WK5+daLCBASkG+j//I9+QB6upAZYtA375y7RKoqoKtLUBP/2pfKk2s9mAj35UAhpLl7K4+0jU1BjBkQ98YPi/v2cP8PrrwBtvSHBk0yajFok5a8QcFOnvH32miLnLjKrKaw+lttYopmoOghx1FOBwSN2V979f1hERVRpzfY2s3VDMRUOPOEKeBhARERVYwQMbdrsdK1aswDe+8Y2Mbd/4xjegaRpWr15d6Jclyu6++4DPf14e/w9WXy/dTH72M6lQ+Z49e4Cf/xy44YbMX5s2TQ539dWFG3aWRmbSJGDhQpmGo79fAiKKIj/fesvoTqMXZtWzRPTRakYTDDl4UOqV7N4tQZds3Zh0eibItGlSG0TvCnPccfJ3nnLK6LJkiIgKaWBASlTpshYOHdwNhU8CiIioCAoe2HA4HFmDGrpgMIj29vZCvyxRuo0bgYsuAl54IXPb9OlSX+M730mrHnngAPDrXwPf/7580TWbNQv41rckqMGaZ5Wtrk6CUsMJTOnBkA0b5NJ6/XWpL6IHQ3p7pZuSXkdkYGBkbdPrhOzYIQGX55/Pvl99vQR2GhqkFsjRR0v3lxNOkODH/PnsAkNExffyyxIMBuQ954MfHLTDwIDUtNKxvgYRERVJwQMbzc3Nh9zH5/MV+mWJRF8f8NnPAnffnfmYvbER+O//Bj7zmbTVmgZ0dADf/jbwr3+l/8rUqVJu45prGNCoZsMNhvT3y7W0YQPw6quSHfL229JVRu8ms3u3dGcZSRBErwuiqnLsv/0te5unTJHLfu5cGQlmwQIJfCxeLAVSiYhGw9wN5ZRT5LlBmr//3ajmXFsLeDylahoREVWZggc29GyNHTt2oLOzE4qi4MorrwSAVNHQG264odAvSwTccgvw9a9nFsSoqwNWrAC+972Mx9ibNgEtLcADD6T/yvjxwJe+BHzzm/wCSMNXV5d/N5m+Phmc55VXgPXrJSPkrbeMbJAdO6RLzHDLEvX3S+BDVYFkMj1dHJBs8EmTZEjcuXMlaHPCCTI88b/9m9QDISIairlwaNb6Gg89ZMwvWcI3FiIiKpqiDPf64x//GKFQCJqmwWazpQIbM2bMQHNzM1auXFmMl6VqtXkzcMYZ8u1tsPPOA1atSquhAUiWxm9/K5kYqmqsr6mRhI9rr5XijkTFVl8PnHSSTEPp75cAyPPPSwAkmZTCqZs3Syr4rl0SJMmXphm1P956C3juufTtNTWS8XHYYdLVZcECwOWS/2rHHceuLkTVTtPyKBxqrq/B0VCIiKiICh7YuOeee3Drrbfi1ltvhcfjQSQSSW079dRT0d7ejh//+Mf4+te/XuiXpmr04IPAxRdnfqM75hjpX+JyZfzKpk1AIADcf3/6+nPPlTqiCxYUsb1EI1RXB5x4oky5DAzIKC2JhJSX2bABeO01ueZ7eiSIkW/mx8CAZIvs2CFBlMceS98+caIEPd73Phnk4AMfAD70IQmCENHY9+qr6UNkn3nmoB16e9P7ybG+BhERFVHBAxurVq3Cq6++mlqeOSiPf3pGB0yiEfrqV2UsVrOJE4Gf/EQiF4NoGvD738sQreYsjWnTgJtuAj73ORZrp8pWUyOBhaOPlnhfNvv2SdbH2rXASy9JLZA335Ru8Lt2SWZIPvbulYyRN96Qp7a//KWst9mkNs2cOcDxxwNNTcA550hRwbqi5AgSkRXM2RqLFmXptrl6tVFE6LDDgFNPLVnbiIio+hT8Y+YxxxxzyH2S2boMEOVrzx7Jh//739PXL1kCrFkDTJiQ8SvvvCOxjj//OX39uecCt9/ObidUPSZMkOyKD3wg+/Z9+6Rbytq1EgDZsEG6qvT0ZJavyUbTjEyPDRskM+p73zNee9YsqefR1AQsWyZBj/r6gv15RFQiw+qGct557L9GRERFVfDAxvbt29OWtcEjUwDo7u4u9MtStejsBJYuBXbuTF+/YgVw/fVZf+WJJ4BLLpHRKHRTp0qWxuc/zywNIrMJE+RLSrYvKgMDkuHx5JNAVxewbp10ddm2Lb+gx759RpbHmjXAjTfK+okTpYDpwoUSn7zgAhlhgd+DiMrXkIVDNS09sMFuKEREVGQFD2xMnz4dV111FW655RYAgG3Qt8bm5macdtpphX5ZqgY33SSjnpiDZRMmyCPhZcuy/srvfy9dTA4cMNZ5vZKlMW9ekdtLNMbU1ADz58v0Xk3olIEBqevx+OOS7fHKKxLA6O09dF2PvXuljkcyKf+dv/MdCTjOmAEce6xkl1xwgfzfZXcWIuu9/rpMuoz6GuvWyRjXgPxnPvfckrWNiIiqU8E/It5www1wu91obGyEx+OBoijo7u6Goijo6OiAw+HgqCg0fJdcAtx3X/o6pxN45pms47FqGnDddUYKPCBDuP7P/wDLlzNLg6jQamoky+KUUzK3vfsuEIsBTz8twQ9FkSwPc8BxME2T7i/PPSfTzTfL+qlTpWDpaacBH/2oBDzYlYWotMzDRzudwBFHDNrBnK3R1CQ1NoiIiIqoKM++urq6EAgEcNttt6WWAcDn86XWEeXN788Manz608Add2TNVd+/X4IXv/udsW7mTOBPfwL+7d+K21QiyjRrFnDZZTKZbdsm33/+8hfgH/+Qbi29vUa9wWx27gRefFGmX/1K1k2fLkPQnnmmxEA/+EF2YyEqJnN9jbPPzrLDQw8Z8+yGQkREJWDTshXBKJDt27dDURT09PSgqamJI6JYYNGiRQCAdevWWdySEWppAczBsNpa4H//F7j88qy79/TIFxtz39/582VUWIejyG0looJ45RXg//5PngqvWyfFfweP6DwUmw2YPVtGe77wQuCTnwTs9qI1l0ag4u9NZabU53PBAmD9epm/4w7gM58xbdy1C2hoMFKynn5aoo1ERFRVSn1vKmpv5enTp+NUDu9FIxUKZQY1nnwyZ9pFMgl8+MMyEoPuQx8C7r1X+uoTUWVYuFCmb37TWPfuu5J1tXo1kEhI/Y59+7L/vqYBmzdLQPPBB4GrrpIuLPPnAx6PxEUXLizN30I01mzZYgQ1gCyFQ9esMYIadrv0GyMiIioyJutSebrhBqCtzVi22YAHHsgZ1PjrX2U0BXNQ4/LLgUceYVCDaCyYNUsKlt59t3yp2rtXvmD94hfAxz8uxYCHKiy6c6cMqnTDDcAJJ0jd4ZNOAoJBGemFiPJj7oZy5JFS8yaNub4GK/4SEVGJMLBB5eeXv5ThW3U2G7BqFXDeeVl3f+45eQq7bZux7rrrJD2WRQWJxq5ZsyQb449/lBEaDhyQ4Ob3vieZ70P1fty/X+p03HgjcPzxMuSsywV8+9uSDUJE2ZkDG2edNagYt6al19e44IKStYuIiKobAxtUXu6+W76pmLW3Az5f1t0VRfrQ790ry/X1MsTrd7/LkU+IqtFxxwHXXivd+lUV2L1byvJcdJGM3JCrqOi+fcDf/w5cfz1w9NESFDn3XODOO4H+/lL+BUTlbcjCoa++CmzcaCzneCBBRERUaAxsUPl48MHMYRPa2iT/PIvubnkYtHWrLNfVAfffn3kIIqpekyYBn/2sDKz01luS1fHww8CllwJHHZU7ALpjhwxR+6lPScDU6QSuvjq9tgBRtenpkUwnXUZ9jVjMmD/pJGDu3JK0i4iIiIENKg9PPw187GOSxqr71reAb3wj6+5798ru5poav/qVdOclIsqlpkYeIt95p3Q56e+XEVj8fsnoyBbo0DTJDrvlFhkNYupUKVT8yCOlbz+RlZ57zrhNH3aYFORN09VlzGcdB5aIiKg4GNgg6+3ZIxGJgweNdVddBfzoR1l3HxiQwqB//aux7gc/yDkCLBFRTjU1EiRdtUoyOvr6pD7P0qUSwMhm1y4pI3D++VKE9IwzgN/+Vt6biMYyc8bSKadkCQQ+/3z6DkRERCXCwAZZ7+MfN4pkAJIj/otf5Nz9G98AOjqM5SuvlIJ/RESjVVcHfOYzMqzsjh2SqfHVr0rtjmz1Ofbvl4Szz3xGuqycdBJw882sy0Fjk3kEoeOOG7Sxvx946SVjmYENIiIqIQY2yFr33w/E48byggWSI57D//wPcNNNxvL550t6OAuFElExHHOMvOds2CD1Oe66S+oKTJiQue/Bg1J/4Ctfke1LlgD33FP6NhMVy6uvGvMZgY316yXSBwC1tTKuMhERUYkwsEHW6esDPvlJY7mmZshO63/8I3DNNcbyqadK+vi4cUVrIRFRSk2NvGU9/rgkma1eLd1Ypk3L3PfgQeDZZ2VAp4kTJQj7t7+Vvs1EhWTO2Dj22EEb//EPY37hwuzRPyIioiJhYIOs88lPSmd13be+Bcybl3XXZ56R3fWiZfPmSbJHrj7wRETFtnSpFB7dvl0yNS6/HGhoyNxv3z6J2X7wgzKM7Oc+B2zbVvr2Eo1GXx/w2mvGckbGhrm+xsknl6JJREREKQxskDWeeAK4915j+eijpQJoFqoKXHKJfDkA5IvBgw9yFDkiKh8nngj85jcyDPXzzwMXXwxMnpy5344dwK9/LSNKnHQSu6pQ5di40SiQW1Mj3bTSmDM2WF+DiIhKjIENKr2BAfnUr7PZZIiBHIJB4J13ZH7cOOC++4BFi4rcRiKiETrpJInb7toFPPoo8KEPZe8y9+KL0lVl6lRg+XKgp6fkTSXKm7kbyvveJ8VyUzSNgQ0iIrIUAxtUep//fPon+Kuvlv64WTz+OHDbbcbyddcB55xT5PYRERWI1wusWSMZZ7/5Tfag7K5dwO23AzNnSgb/6tWlbyfRoQw5IsrmzcDWrcYyu6IQEVGJMbBBpZVIAHfcYSzPng387GdZd923D2hpMZZPPhn4r/8qbvOIiIqhpkZqcLz0kmSgXX55ZlcVTQNeeAHweIAjjpBgB1G5MI+IMmTh0Llzpa8VERFRCTGwQaUzMAB85CPp6+6/Xz7xZ/GjH8kQi4DsctttHAGFiCrfnDmSvbFrF/D732dPWNu0SbqnTJ8OfPe7QH9/6dtJZDZkxgYLhxIRkcUY2KDS+a//knRV3ac/DTQ1Zd31pZeAG24wlr/yFWDx4iK3j4ioxC67DHj5ZeDtt4FLLx1UtwBSbPSHP5TsjiuukGUiKwwZ2GB9DSIishgDG1Qa69endzmx29O7pJgMDMiTSv0J5RADphARjQlz5wJ33gns3i0jXw8eyrqvT7I8ZswA/P70kbKJim3/fuCNN4xlZmwQEVG5YWCDSuOSS6QDue6ee3J2QfnlL4FnnklfnjKlyO0jIioDdXXSDW/HDiASAQ4/PH37wADQ0SEBjpYWCXgQFZuiGEO91tbKqCgpe/YY/UYBZmwQEZElGNig4tu4UXKtdR/7GLB0adZd33oLWLHCWP7kJ4ELLihy+4iIylBLi9TaePhhYMGC9G39/VJ3aNo0ec/Uv3QSFYO5cOj73jeo3tVLLxkX4MSJWSqLEhERFR8DG1R811xjzNtskk+dhabJyK87d8ryjBnAT35S/OYREZWz884DXnkF6OoCTjghfdv+/VKPaNo04KabrGkfjX1519c46SRJ6SAiIioxBjaouPr7gQcfNJY/8AGpr5HFPfcAf/qTsfzf/y2jwRIREeByAevWAfG41B4y271b6jPPnJn+lktUCCwcSkRE5Y6BDSquG25IH6fwxz/OultvL/DlLxvLS5fKCABERJRu2TLgtdeAaBSYNSt9W3e3jKp9xhlAT48lzaMxiEO9EhFRuWNgg4rr5puN+TlzgNNPz7rbt79tjAQ7YYIUzbPZStA+IqIK5fMBW7YAt9wCTJ+evu3ppyXj7fvft6ZtNLbkDGwMDKQHNpixQUREFmFgg4rniSeAd981lv/zP7Pu9s47wO23G8vXXsvaY0RE+friFyU745vfTC9v0N8PfO97wBFHAGvXWtY8qnD79gFvvmksp92fFUX6QQHyNOL97y9p24iIiHQMbFDxfP3rxvy4cenLJrfcAhw4IPNHHin9xImIKH81NUBrq4wstXhx+rZNm4DTTgM+/nH5kko0HIpijNZeVzdoqFdzfY1jj+XY7EREZBkGNqg4enqAzk5j+cIL5RPRIHv3Arfeaix/6UuDhpEjIqK8zZkDPPcccO+9MlKK2Z/+BDQ0pBdpJjoUczeUY44ZdCtnfQ0iIioTDGxQcQSDxiMeIOe4rXfdBWzbJvOTJgHLl5egbUREY9zFF0sh0SuuSK9XtHevZG5cdpmURyA6FI6IQkRElYCBDSq8gQHg7ruN5YULM8cmhMQ9zPGOz3xGniYSEdHo1dUBv/41sH49cPzx6dvuugs46iggmbSmbVQ58g5sMGODiIgsxMAGFd6vfw3s2WMs/+AHWXdbvRpYt85Y/spXitwuIqIqdNxxEty49tr07I1Nm4D589MHryKhKAoCgQBCoRBCoRD8fj8SicSIjhWPx+H3++H1euF0OuH1ekd8LCu8+qoxnxbY6O6Woi46ZmwQEZGFMoseEI3W9dcb89OmAZ/4RNbdfvpTY/6CC4AFC4rbLCKiava97wEXXQQsWyZlkADg4EEJKkejwKOPynDb1S6RSMDv9yMWi8HhcAAAVFWF2+1GOByGz+fL+1htbW0AgGg0mloXCATgdrsRDAYRDocL2/giMGdspI2IYq6v0dgow+8QERFZhBkbVFivvCIl1HVXXJF1tw0bgAceMJavuaaorSIiIshD9S1bJJhs9uSTwKxZwFNPWdKssuL3+xEIBFJBDQCw2+0Ih8NYvnw5VFXN6ziKoqC7uxvBYDBtfSQSgcvlQltbG+LxeCGbXnB796YP9ZqWsTG4cKg5HYiIiKjEGNigwvrqV435mhrgRz/KutvPfmbMn3AC4PUWuV1ERARAam88+CBwxx3pI1zs3AmcdZYMwV2t4vE4FEWBx+PJ2Obz+aCqKtrb2/M6ViQSweLBY+++Z8WKFal9ypm5Bsu4ccC8eaaNLBxKRERlhIENKpy+PsD89OnMM7OOad/bKx+odddcwwc9RESl9pnPAK+/DpgSE6BpwNVXV2/No1gsBgBp2RpmdrsdK1euzOtYepeWbIEQl8uV2qecmbuhOBwc6pWIiMoXAxs0PEOND/i970mHbd1NN2Xd7fbbjdqijY3Apz5VuOYREVH+5s6Vp/KDh9q++WbgvPOqb0hYvWuI3W7Put3hcOQdjPB6vbDb7WhqasrYlm93FqvlLBza1we8/LKxzIwNIiKyGAMblB9NA+68EzjpJKPq3GDmlNojjwTeeyJl1t+fXoH/C18AJk4scFuJiGhY2tuBX/wiPXvu0UdltG7zIFdjnaIoOYMawxUMBtHb25vKzjDr7OwEgKzbyknOwqGvvAIcOCDz48ax+jcREVmOgQ06NE0DLr1UUivWrQP+8z8z93nkkfSAx9e/nvVQ995rFCKrqwOuuqoI7SUiomG76ip5Kx83zli3YQNw1FHAG29Y165SyjeTYrQZF/ooKXqtjXJlDmykZWyY62ssWgTU15eqSURERFkxsEGHZrOlZ1/8/vfAH/+Yvs/3v2/Mjx8PfPnLWQ9lHuK1uVnSoImIqDx4vcCLLwJTpxrrenqA448H/vY369pVbnpyZS7mIR6PIx6PIxgMDjtjY9GiRVmnpLnKZwHlFdhgNxQiIioDVR/YUBQFgUAAoVAIoVAIfr9/xMW8RnqseDwOt9sNxTxMarn52teAJUuM5UAA2LbNWH7xRWPe65URUQZ59tn0D8bmAVSIiKg8zJ8vGRpHHWWs278fOOMM6ZE4lhWqG0ouqqrC7/fD5/MhHA4X9bVGa88e4O23jeUhh3olIiKyWN2hdxm79IrlsVgsVQFdVVW43W6Ew2H4fL6iHSsUCiGRSMDhcEBRlLKvjI7aWhnK5JRTgH37gHfflayMu++WAMeuXca+zc1ZD2HO1jjjDMDtLmaDiYhopOx2QFFkcKtnnpF1AwPSI/G114Bvf9vK1mXyer2pwp/D1dvbmwpoNDQ05JWN0dDQMKLXWr58OTweT6orynCtW7cu6/pFixaN6HhDMRcOra83Bbo0jRkbRERUdqo6Y8Pv9yMQCKQN62a32xEOh7F8+fJh9aEd7rHC4TBisRgikUjZFw9LmT8fuP56Y/kPfwA6OoDf/CZ9vywBobfeAsyf4665pjhNJCKiwqirkyy7T3/aWGezlecD+lgsBk3TRjSZszTsdvuQ935920gyO0KhEACMOKhRaubAhsMhzzcAyA29t9fYWI4XBBERVZ2qDWzE43EoigKPx5OxzefzQVXVrGPPF/tYZe8rX5F0C90XvygVQXWNjcCECRm/dsstxkiwRx8NfPzjRW4nEREVxG9/C/zwhxLU+PGPgQsvtLpFxaMPzZoruKEoyogeRrS3t0NRlIygRjl3Qc2rvsa8ecCMGaVqEhERUU5VG9iIxWIAkJZhYWa327Fy5cqSH6vs1dYCv/61MUbrtm3A2rXG9hwf+O65x5j/0pfkSSAREVWGb38b2LRJyi2NZYFAAED2gIMe7GjO0d0yl3g8jlgsljVTo5zrbOQMbLC+BhERlaGqDWzofXFzpZM6HI68614U8lgV4dhjAfOHMX0sewD42McydlcUGTJQ5/cXsW1ERFQUc+ZY3YLic7lccDgcWR9GrFq1Cna7HS0tLWnrVVXNWd9Dz9KolO4nZhwRhYiIKknVBjYURSlY9fNCHqtiXH01cPbZmes/9amMVY88YswvXChdUYiIiMpRNBpNdR3RqaqKcDiM1atXZ9zv/X4/vF5vRpdTvYB4Z2cn3G53xjRjxoyy/uyQV2CDGRtERFQmqrZDgKqqeX2gyGe/Qh5rpHJVRE8mk3A6nYV/wZoa4H//Fzj+eKN4Rl0dMH16xq4PP2zMn39+4ZtCRERUKC6XC11dXQiFQnA4HGhsbMTatWtzFvv2er3o7OxM1efQ+f1+qKo6ZMbm4sWLC97+Qti9G3jnHWP52GPfm9m5E0gmjQ3M2CAiojJRtYGNfPX09BQsGFHIY5UFh0NqbehDvfb3A3fdBVx2WWqXvj5g9WrjVxjYICKicudwOPLuPhIMBhEMBjPW6/W3KpF5RJTx401Dvb74orFh6lTgmGNK2i4iIqJcqjawUcgAQzkEK0o5tn1Kf78R1NB9+cuA2w0sWAAAePppefIDSAzkrLOK1xwqM5omka3du4G9e7NP+/bJ1NcH7N+f/lOfP3BArrWDB+Xn4OngQXktTQMGBox5fQIkw8hmM36a5+vqgHHj5Kd50teNH597mjABmDRJpokTjXl9GjdOXoOIqIKYu6E4nfJ2CUCKZukWLDBtICIislbFBTa8Xm/OIl2H0tvbmwpCNDQ0oKen55C/09DQkNc+hTpWRfnjHzPX9fYCp54KXH898JWv4OGHa1ObPvShrCPBUjnRNAk4qGr6tGOHpCDv2GFM5uXduyXItXt3+rzeTala1dXJU81c0/TpgN1uTDNmpM83NABTpjA4QkQllbO+xltvGfOpNA4iIiLrVVxgo1CpnXa7fcjx4/Vh3fLJxijksSqKuWp8fb08YQfkCfzXvgbcey8e3hYHMB4Au6GUlKZJ4GHbNmDrVqC7G+jpMabBy729RhDDPMoNjU5/v5zb3t6RH2PcOGDmTJkaG9N/zpoFzJ4tw1XMni2T3c5ACBGNSl6BjSOPLFl7iIiIDqXiAhuF0tTUhEQikbOgp6IoWYuEFftYFeXZZ435E08EvvMd4AtfAN59FwCw6akkXngvqAEwsDEqmiZZEFu2yPnVJ31561aZtm0zJj3QVC5qaqS7xoQJ8lOfJkyQbh319dl/ZusqUltr/KytzexmYl4e3E3F3F3l4MHMLi561xd9fv/+zEnvJqN3qdmzx5gGBgp73g4ckCp+5kp+Q6mvN4Idc+cCRxxhTEceacxPnVrYdhLRmGGusZEqHAowsEFERGWragMbgUAgNZzb4KCDnmHR3Nxc8mNVjIEB4O23jeVzzwUuvhg480zgS18CVq7EIzgvtfmYCZtwXO0+AI7St7Wc7d8PbN4sX1o3b849bdkimTClNGGCPP2fPl2madPky/C0aenzU6dKd4nJk42fg+cnTqyOehN6XZE9e4xuOTt35p62b0/v8mPOnNm5c2Rt6OsD3nxTpqFMmyZjLx99NPC+92XOH3bY2P/3IqKsmLFBRESVpmoDGy6XCw6HAytXrswIRqxatQp2ux0tLS1p61VVRWdnJzwez6iPVfFWr05/Mn3FFfJz5kzgD38AfD48fFkd8F7SwPn7/gjbyUHg2muBT35y7H8g2rdPghWbNhmT/tRdX//OO9INpJhsNqnT0NAg3RcaG9OXGxqMWg7mWg92OwuijITNZhQWnTFjdMfq7ze6DW3blvlz2zYJeG3ZIsGvd9+V38nXjh0ywoF5lAOzSZPkUa0+OZ3G/JFHsmgg0Ri1c6e8pegY2CAiokpQtYENAIhGo1i2bBkCgQAcDskkUFUV4XAYq1evzuhW4vf7EY/HEYlEMgIVwz2WmV6fQ8/uqAh33WXMjx8PzJ+ftrn/Ih9ikwaMwAYelqfXwaBMp5wCfPSjwMc+BrhclfMlyRywyPVz06bR1VQYis0mwaPZs436CrNmydP1ww6TbfrPmTMlYFFbe+jjUvmpq5N/21mz8tt/YEACIXqw4513JKtq8LRpU35FXffsAV54QabBxo+XAMeCBcDChcY0f74ERIioYpm7oUyYID3XAEg22JYtxkYGNoiIqIxUdWDD5XKhq6sLoVAIDocDjY2NWLt2LSKRSNaaGF6vF52dnWhqahr1sdrb2xGNRtHT04NEIgEAWLZsWerYkUgkFSApS08+acw7nRmb164FelUJVoyrPYhzpr8AmJMT/vEPmX7wA+Dww4ELL5RAx+LF8kWulIGO/fvlKfjWreldPwbPv/NO8QIWjY1yHvTaCIMnvTBkYyMDFZRdTY0R0BpqmOeDByW74803gddfN6bXXjN+HqobzP79wLp1MpnZbNKNZeFCacPJJwMnnSQBkPr60f6FRFQC5m4oxx5ruh1v2pS+49y5JWsTERHRodg0TdOsbgQVz6L3vuCsG/wFZLTGjTPS3q+6CvjFL9I2X3stcN11Mr90KbD6ri3Aj38sQ8SaHwflOvaRR8pQcubpyCPl8ZFeMHLwZLNlDjdq/rljR/aU/l27CntuzGbNkg9/hx8uk3leX54zh1/6qHxomtT42LhR/q8OnvItYmo2bpwEO046SaaTT5ZhoQ87rODNp8pQtHtTlSrk+bz+euDb35b5iy4C7rvvvQ1PPSV1tAC5t5mzN4iIiAYp9b2+qjM2aITWrk3vy3/55Rm7PPywMX/++ZBsgxtvBNragPXrgT/9Cfjzn4G//jVzFIkDB+RL1caNxWl/IRx2mBGkMP/UJz37ggELqjQ2m9QHmTFDuokNtmsXkEzK/+NXXjGm9eslkyObAweyd2s5+migqUkytZqaALdb6rsQkWVyFg41FwxnNxQiIiozDGzQ8P32t8Z8XR3wgQ+kbd62TWIfurRhXm02SUtfsEBqbWzbBjz0kAQ6Vq8uXlePfEyalNn9Y/D83LkMWFB1mzJFMi5OPjl9/cGD0o3llVeAl1+WoqQvvCDLBw5kP5beDeaee4x1xx0nQY5/+zfg9NMlw6OOtyqiUuGIKEREVIn4aZGGb80aY37evIzNsZhkswMSBzjxxCGONXMm8OlPywRIdxF9qMrB06ZN8gXp4MHsk6ZlDjVq/jl1qtSomDkz+8+JEwt3joiqTW2t1NtxOqVmjq6vD/jnPyXI8fzz8vMf/5A6H9n8618y3X23LE+ZAixZIkGO00+X+alTi/7nEFUrBjaIiKgSMbBBw2eukXHGGRmbB3dDsdmGcexp06To4FDFD4moctTXG7U1PvUpWadp8iWps1PSuzo7ZcqWsbVrFxCPywRIJcOTTwbOOQdYtkz6/DPQQVQQO3akxxwZ2CAiokrBwAYNz7/+ld6P/tJL0zYPDACPPGIsp3VDISICJNqpFwW++GJZp2mAokiA49lngaefBhKJ9Ho+gLzJ/P3vMt10k3RTOe00CXIsXSpdWMaPL/3fRDQGmLM1Jk6UclEpDGwQEVEZY2CDhufXvzbma2oArzdt8/PPG4XSa2oAj6eEbSOiymWzGV1Zmptl3Z49ktHx9NMy/fWvMmKLWX+/rP/rX2X46IkTJYvjggukS8yxx5b8TyGqVPX1gN8vAY6JEweNvM7ABhERlTEGNmh4Hn3UmD/88EGfetK7oSxZIgMrEBGNyKRJwNlnywRItsbLLwOPPy7FhtesyQx07N0r71OPPgp89avA8cdLgOMjH5Gucyz8S5TT+98PrFqVZUN/f/pQzwxsEBFRmWFgg4bnn/805pcsydicMcwrlR1N06Dp1V2JSsRms8E2rII7WdTUSDXiE08Err5aigb/4x8S5Fi9GnjySQlsmG3YIF1WbrpJanGcd54EOj72MUZeifK1ZYv8f9MdcYR1bSEiIsqCgQ3K3+bNwO7dxrLfn7Z5+3bJBtcxsFE+Dh48iO7ubuzcuRN9fX1WN4eqVH19PaZOnYrGxkbU1taO/oC1tYDbLVMwKPV/nnlGIqz33w+89FL6/jt3Ah0dMo0bJ13p/H7g4x9nkINoKOZuKDNmSDYVERFRGak59C5E77njjvRlvejfex57zKjzN3OmfNcg6x08eBBvvPEGuru7GdQgS/X19aG7uxtvvPEGDpqf/hbK+PHSbaW1FXjxReC114Bf/AL48IczC4oeOAA8+CDw2c8Cs2fLPnfckX1kFqJqx/oaRERU5pixQfl74AFj/rDDMvqqm7uhnHtuRvkNskh3dzf27duH2tpazJ49G5MnT0YN/3GoxAYGBrB7925s2bIF+/btQ3d3N2bNmlXcFz36aOCqq2Tas0eir3/+M3DffcDWrcZ+Bw4ADz0k07hx8gZ2xRXARz/KEVaIAAY2iIio7DGwQfl78UVjflA6hqaxvka52rlzJwBg9uzZmD59usWtoWpVU1OTuv42bdqEnTt3Fj+wYTZpktTWuPBCyeJ44gkgGgXuvRd4911jvwMHJIj7wANAQ4MMaX3FFYDLJSO3EFUjBjaIiKjM8bEt5WfHDimioRvUDeWf/wTeeMNYPvfcErWLhqRpWqr7yeTJky1uDZFxHfb19VlXxLauDli6FPjlL4FNmyST44tfBAYHWnp6gJ//HGhqAk4+GfjJT9KDIETVgoENIiIqcwxsUH7uvDN9+dJL0xbN2Roul3RZJ+uZvziy+wmVA/N1WBaj89TWAuecA9xyiwQ54nHgU58CJk5M3+/FF4GvfU1Gg7jkEuAvf5FUNaJqwMAGERGVOX7Tofz88Y/GvN0OTJmStrmz05hftqwkLSIiKqzaWnkD+93vZBSo224DTj89fZ/+fqnRcc45ksVx221Sv4NoLGNgg4iIyhwDG5Sf+nr50A8AJ52UsfmVV4z5LJuJiCrLtGnAlVcCTz0FrF8PfOtbkq1h9uKLQEuLfNELhYDXX7emrUTFNDAAvP22sczABhERlSEGNig/f/6zPKl86ingZz9L2zQwIDU2dAsXlrhtRETFdPzxwI9+JIGLP/85s4hQby/Q1gY4HNJN5emnrWknUTFs3SpFdXUMbBARURliYIOG5/TTgVNOSVv1+uvA3r3G8oIFpW0SUTlqb2+H0+lER0eH1U2hQqmtlVFVHnlE0tSuvhowF+UdGJBuKmecIcVJ16xhHQ6qfOZuKFOnSjYTERFRmWFgg0bN3A1l3rz0z/lE1UpVVSiKYnUziiaRSMDpdEJVVaubYo0FC2TElLffltFSnM707WvWSHDjzDOBRx9lgIMqF+trEBFRBWBgg0bt5ZeN+RNOsK4dROUkGAxC0zT4fL609R0dHYjH4xa1anRUVYXf70cgEMDy5cvHdOAmb9OnA9dcA2zYIN1UzjwzffvTTwPnnQcsWQLcfz8DHFR5GNggIqIKwMAGjZo5Y4P1NYiG1traimg0anUz0sTjcbS3tx9yP7vdjmg0ikgkgubm5hK0rILU1Eg3lSeekKFgly5N3/7cc8BHPwq43cCDDzLAQZWDgQ0iIqoADGzQqDGwQVTZVFWt3i4lxXD22cDq1ZKtcf756dv+/nfgIx+RLI4XXrCmfUTDwcAGERFVAAY2aFQ0jYENqhyJRAJutxuJRAJtbW1wu92w2Wzwer0Z3SpUVUVbWxucTidsNhucTifa2trS9onH45gxYwYURUE8Hofb7YbX6wUgXU5sNhsSiQQAIBAIpJbb29ths9lgs9kQCoUQCoVgs9mydu3Qt5kDD3qbqcx98IPAQw8Bzz4r2RpmsRhw6qnA8uXA5s3WtI8oHwxsEBFRBaizugFU2TZvBswPehnYqDCaBmzfbnUrhm/6dMBmG/av9fT0pIIbPp8PgUAAsVgMHR0dcLvd2LhxI+x2OwAJWrS2tmLFihVwuVxIJBIIhULo7u5GOBxOHVNVVXR0dCAUCsHlcsHv92d97XA4jEAggGXLlqGpqSl1DIfDAQBoa2tDJBJJOzYgo6v4fL5UuwDA4/HA5XIN++8ni5x2GvCnP0m2xje+IdkcgIyicvvtwN13A9/8JvC1rwGTJlnbVqLBGNggIqIKwMAGjYo5W2PWLKCx0bq20Ahs3w7MmGF1K4avtxcwfdEfrnA4jGAwCABoaWlBW1sbQqEQ2tvbU+s9Hg96e3tTv+PxeLB27Vq0tbVlBB9CoRAikQhaWlpyvqbdbofL5UJDQwMcDkdGYMLn86G9vT3t2PF4HKqqIhAIpO0bi8VG9oeTtU49VTI1HnwQ+PrXgX/+U9bv3g1897tAJAJcfz1w2WVSs4PIaprGwAYREVUEfnKiUWE3FKpEg4MKwWAQdrsdK1euTK2zZwmc6N0/9O4lOo/HM2RQIx+BQCCV/aGLRCJwOBzweDyjOjaVEZtNamy88ALwi18AM2ca2956C7j8cuCcc2SUFSKr9fQA+/YZywxsEBFRmWLGBo2KObDBoV6pkjU1NaGzs3PIfRoaGgBIlxazXN1PhsPj8cDhcCASiaSGiO3o6MjIDhmNQCCQdahZ/e+JRCIZ21wuV9mN4jImjBsHXHUVcOmlkqXxs58BfX2y7YkngJNPBr7/femeUsdbNVnk7beN+YkTKzPDj4iIqgI/LdGovPyyMc+MjQo0fbp066g006cX/JA9PT2pwIUuHo8jGo0iHo9nLeyp0+tkjFYoFEplbugBiNFmgphlC1wAEkBRFCXVDYdKyG4H2tqAL35Ruqfce6+s37cPCIWAlSuBX/0KOOUUK1tJ1WpwN5QR1DYiIiIqBQY2aFTYFaXC2WyjqlVRqbINbaooCpqamlLLes2NlpYWRKNROBwOxOPxrNkZgwMihzI440PX0tKCQCCAVatWIRaLwePxZO0SQ2PQMccA99wD3HefZHLoI6UkEkBTkwQ5vvtdYMIEa9tJ1YX1NYiIqEKwxgaNmKqmj1LIwAZVisHZF6FQKKNIZ1tbG1asWIFwOAyXywW73Z4zIDFc2QIrOj2QEo/HEQqFCvJ6VEEuvlhS4T7/eWPdwYPSXeWUU4CnnrKsaVSFGNggIqIKwYwNGjFztsa0acDcuda1hWg49ICBw+HAypUr0dHRAZfLlaptoW9rbW0FgLThXkfL5XKho6MDbW1t6O7uhqIoaTUsQqEQnE4n7HZ7zqKhXq8XLperoPU3hqu7uxuAZJ8wq6TAZsyQYWD/4z+AlhZg40ZZv349cNZZMjTsddex9gYVHwMbRERUIZixQSM2uL4Gu95SpYhEIkgmkwiFQojH42hpaUFXV1faPtFoFA0NDQiFQvD7/Ugmk4hEIqkhW0dqxYoVsNvtaG1tRSKRQHNzc9p2fSjYoWprxOPxjJFZSsXv98Pv96O9vT3rMhWQxwO8+CJwzTXGG6ymAa2twLJlwKZNljaPqgADG0REVCH4uIdGjPU1qFI5HI5DFuV0uVxIJpMZ682/5/F4oGla1t/3+XxZt7lcLvQeomBrIpEYciSSXK9ZChwhpcQmTwZ+8hOguRm44grJ2gBk5JRTTgHuvBN4bxhiooJjYIOIiCoEMzZoxBjYICq89vb21NCvpWK329mdpNwtWQJ0dgKXXWas27oVOO884P/9P6nDQVRoDGwQEVGFYMYGjZg5sHHCCda1g6jSqaqKzs7OVNeXUmdF5KrlQWVmyhTgd78Dzj4b+PKXgf37pWvKD34gRUXvuguYM8fqVtJYsWMHsHOnsczABhERlTFmbNCI7NkDvPaascyMDaKR6+npgd/vh9vtRktLCwMNlJvNBixfDjz7LHDcccb6NWuka8pjj1nWNBpjzNka9fXAzJnWtYWIiOgQmLFBI7J+vTwoBIDx44H3vc/S5hDlZaiaGFZyOByHrLtBlObkk6VrSksLsHKlrNuyRept3HwzcNVV1raPKp85sDF3LlDDZ2FERFS+eJeiETF3Q1mwAKitta4tRERVado04O67gVtukSfqADAwAFx9tQwJOzBgbfuosrG+BhERVRAGNmhEWDiUiKgM2GzAF78I/O1v6V8+w2Hg8suBvj7r2kaVjYENIiKqIAxs0Ii8/LIxz8AGEZHFXC7gmWeA97/fWHfnncCHPwxs325du6hyMbBBREQVhIENGhFmbBARlZkjjgCefBJYutRYt3o1cNZZwNtvW9cuqkwMbBARUQVhYIOG7cAB4F//MpY51CsRUZmYPh146CHg0kuNdS+8ACxZAqxbZ127qPIwsEFERBWEgQ0atmQS6O+X+dra9BEHiYjIYvX1wO9+JwVEdW+9BZx+OvD449a1iyoLAxtERFRBGNigYTPX13A6jWL8RERUJmpqgNZW4Oc/lwKjgNTaOPdcIBaztm1U/nbvBsxDUDOwQUREZY6BDRo21tcgIqoQV18N3HsvMGGCLPf1ARddBDz1lKXNojJnrslSWwvMmWNdW4iIiPLAwAYNmzmwwfoaRERl7qKLJEtj8mRZ3rMH+MhHgK4uS5tFZczcDeXwwyW4QUREVMYY2KBhY8YG0aG1t7fD6XSio6PD6qYQAWecAfzpT8D48bK8Y4d0S3npJWvbReWJ9TWIiKjCMLBBwzIwwMAGUT5UVYWiKFY3o2gSiQScTidUVbW6KZSvpUuBe+4B6upkuacH8HrTh7kiAhjYICKiisPABg3LG28Ae/caywsWWNcWonIWDAahaRp8Pl/a+o6ODsTjcYtaNTqqqsLv9yMQCGD58uVjOnAzZn3kI8Bdd0lxUQDYvBlYtkze3Il0DGwQEVGFYWCDhsWcrTFvHjBlinVtIapEra2tiEajVjdjROx2O6LRKCKRCJqbm61uDo2U3w/86lfG8ptvSnDjnXesaxOVFwY2iIiowjCwQcNiHuqV3VCIiCrUFVfIULC6V1+Vbind3ZY1icoIAxtERFRhGNigYWF9DapkiUQCbrcbiUQCbW1tcLvdsNls8Hq9Gd0qVFVFW1sbnE4nbDYbnE4n2tra0vaJx+OYMWMGFEVBPB6H2+2G1+sFIF1ObDYbEokEACAQCKSW29vbYbPZYLPZEAqFEAqFYLPZsnbt0LeZa1nobSYalauvBm64wVhetw44/3wZNYWqGwMbRERUYeqsbgBVFg71OrZoGrB9u9WtGL7p0wGbbfi/19PTkwpu+Hw+BAIBxGIxdHR0wO12Y+PGjbDb7QAkaNHa2ooVK1bA5XIhkUggFAqhu7sb4XA4dUxVVdHR0YFQKASXywW/35/1tcPhMAKBAJYtW4ampqbUMRwOBwCgra0NkUgk7diAjK7i8/lS7QIAj8cDl8s1/BNANFgoBOzaBfzwh7Lc2Ql84QvAb34zsv9kVPn27we2bjWWGdggIqIKwMAG5U3TmLEx1mzfDsyYYXUrhq+3FzB9zx+2cDiMYDAIAGhpaUFbWxtCoRDa29tT6z0eD3p7e1O/4/F4sHbtWrS1tWUEH0KhECKRCFpaWnK+pt1uh8vlQkNDAxwOR0Zgwufzob29Pe3Y8XgcqqoiEAik7RuLxUb2hxNlc911MkLKLbfI8u9+B5x2GvClL1nbLrLGpk3GvM0GHH64dW0hIiLKE7uiUN62bJEvlDoGNqhSDQ4qBINB2O12rFy5MrXOniVyonf/0LuX6Dwez5BBjXwEAoFU9ocuEonA4XDA4/GM6thEQ7LZgJ/+FDjrLGPdV78KPPmkZU0iC5m7ocyeDdTXW9cWIiKiPDFjg/JmztY47DCgsdG6thAVWlNTEzo7O4fcp6GhAYB0aTHL1f1kODweDxwOByKRSGqI2I6OjozskNFQVRXLli1Lq9dxKNFolN1eqsG4ccCqVYDLJU/s+/tl9JREApg71+rWUSmxvgYREVUgBjYob6yvMfZMn56ehVMppk8v/DF7enpSgQtdPB5HNBpFPB7PWthTp9fJGK1QKJTK3IjH4wAw6kwQM7vdjq6uroIdj8aY2bOBe+6RzI0DByRNz+cD/vIXPrWvJgxsEBFRBWJgg/LG+hpjj802uloVlSpbxoKiKGhqakot6zU3WlpaEI1G4XA4EI/Hs2ZnDA6IHMrgjA9dS0sLAoEAVq1ahVgsBo/Hk7VLDFHRLFkiw8DqdV3+9jfgP/8T+OUvrW0XlQ4DG0REVIEY2KC8vfyyMc/ABlWywdkXoVAoo0inXiRULyYK5A5IDNdQXUH0QEpnZyei0WhBXo9oWJYvB557DvjVr2T51luBxYuBz33O2nZRaTCwQUREFYiBDcobu6LQWBEKhQBIF5KVK1eio6MDLpcrVdtC39ba2goAacO9jpbL5UJHRwfa2trQ3d0NRVHSAhihUAhOpxN2uz1n0VCv1wuXy1XQ+hvD1d3dDUCCPcwqGWNsNsnaeOEFYO1aWXfVVcBJJwGmrCYaoxjYICKiCsRRUSgv27cD77xjLDNjgypZJBJBMplEKBRCPB5HS0tLRu2JaDSKhoYGhEIh+P1+JJNJRCKR1JCtI7VixQrY7Xa0trYikUigubk5bbs+FOxQtTXi8XjGyCyl4vf74ff70d7ennWZxogJE6TexmGHyfL+/cAllwBbt1rbLio+BjaIiKgCMWOD8mLO1pg6lUXyqbI5HI5DFuV0uVxIJpMZ682/5/F4oGla1t/3+XxZt7lcLvQeomJrIpEYshtKrtcsBXaPqSJHHSUjpXg8wMGDwJtvAv/xH8AjjwB1/PgwJh04kP4Ug4ENIiKqEMzYoLwMrq9hs1nXFqKxrL29PTX0K5HlPvQh4MYbjeXHHjNqb9DYs3kzYA6cHnGEdW0hIiIahqp/5KIoCsLhcKqPuKIoWLFiBVwuV9GPFY/HEYlEoKoqFEWBw+FAOBwe0WsXG+trEBWPqqro7OxMdX1hVgSVlWuukWKif/gD8M1vAldeaXWLqFjM3VBmzpQuSURERBWgqgMbiUQCfr8fsVgs9XRUVVW43W6Ew+G0QoKFPlZbWxuA9LTuQCAAt9uNYDBoaVHAbL76VeCccyTAsWiR1a0hGlt6enrg9/uhqiqCwWDOoqFElrDZgNtvBz79aeDDH7a6NVRMCxcCDz0kAY6+PqtbQ0RElDebZmVnbYs5nU4EAoG04RwBoKOjA8uXL8fGjRvzrvY/nGMpioJIJJI1eOF2u5FIJBCLxQry5WbRe1GIdevWjfpYVHkGBgawfv16AMD8+fNRU8PeZ2QtXpME8N5UaDyfRERUbkp9b6raT5TxeByKomQNHvh8PqiqmneV/+EeKxKJYPHixVmPtWLFitQ+RERERERERDS0qg1sxGIxAMhZoM9ut2PlypVFOZbebSVb4ESvr2HVUI5ERERERERElaRqAxvxeBwAcnY1cTgceQcXhnssr9cLu92OpqamjH1VVc3rNYmIiIiIiIioiouHKoqSd/2MQh8rGAxm1OLQdXZ2AkBZjoxClcdmGpd3YGCA9QzIcgMDA6l5G8eNpjJVyBHT2tvb0dXVBUAKBSuKgkAggJaWlkI2mYiIqKpVbWBDVdW8ghH57FfIY+mjpOi1NvK1KMdQJclkEk6nc1jHorHDZrOhvr4efX192L17N6ZPn251k6jK7d69GwBQX1/PwAaVpUKOmBYKhdDc3JwWxEgkEnC73YhGo6murERERDQ6VRvYyFdPT0/BMjsOdax4PI54PI5gMMiMDSqYqVOnoru7G1u2bAEATJ48mZkbVHIDAwPYvXt36jqcOnWqxS0iys7v9yMQCKTVzbLb7QiHw1i+fDk8Hk9enwsURUFbWxtUVU0rCO5yueDxeFL3fA7vTERENHpVG9goVLCiUMdSVRV+vx8+ny/rMLCHkmsYnVyZHFQ9GhsbsXv3buzbtw+bNm2yujlEmDBhAhobG61uBlGGQ41yphf+ztWd1EyvmaV3MTUzd3EhIiKi0au4x7Zerxc2m21Ek7kwZ0NDQ16vl89+hTiW/hRI74pCVCi1tbWYN28eGhsbUV9fb3VzqIrV19ejsbER8+bNQ21trdXNIcpQyBHTXC4XkskkVq9enbFND2hkKyJOREREw1dxGRuF6o9qt9uHfFKiB0HyycYY7bFCoRAAMKhBRVNbW4tZs2Zh1qxZ0DQNmqZZ3SSqMnqAmaicFXLENH3/wRRFQSKRgMfjYbdTIiKiAqm4wEahNDU1IZFI5CzoqShK3h84RnOs9vZ2KIqSEdRQFCXnEyOi0eAXTCKi7Ao5YlougUAALpeLDzOIiIgKqOK6ohRKIBAAkL1/q55h0dzcXNRjxeNxxGKxrB9uRlJng4iIiEbO3GW1EPvp2tra4Pf74XQ64XK50NXVNaIAyqJFi7JOyWRy2MciIiIaS6o2sOFyueBwOLL2lV21ahXsdnvGGPOqqqbSVEd7LD1Lg09siIiIKktPT8+w9g8Gg6nhXRVFgdvtZuFQIiKiAqrariiA1LRYtmxZ2rBuqqoiHA5j9erVGU9T/H4/4vE4IpFIRqBiOMdSVRVutxsOhwNutzujXYqiZByfiIiIiqvY3VAcDgei0SjcbjecTieSyeSwup1yBDQiIqLsqjqwoaeDhkIhOBwONDY2Yu3atYhEIllrYni9XnR2dmatYj6cY/n9fqiqOmQBssWLF4/+DyQiIqoCXq83a0ZlPnp7e1MBjYaGhryyMfIdDS2XQCCAQCAAv9+Prq6uUR2LiIiIAJvG4RHGNP0pTq6nPERERKVWrvcmt9uNRCKRc+Qop9MJRVHyGllKH/3E5/NlbEskEqmMzUJ8DCvX80lERNWr1Pemqq2xQURERGSmZ2TmKg46nBHTvF4v/H4/Ojo6htxvuIVIiYiIKBMDG0REREQo7IhpgNTsyBYI0Y/vcDiKXteDiIioGlR1jY1q8MYbb+DAgQMsLEZERGUjmUxi3LhxVjcjg3mUs8EBiaFGTOvs7ITH40lb7/P54PV6sxYH1UdRC4VCBWk37/VERFRuSn2vZ8bGGDd58uSCXVDJZBLJZLIgx6Lh4/m3Fs+/tXj+rVXo8z9u3DhMnjy5YMcrpGg0ivb29rSsjUONmOb1etHe3p62PhwOIxKJZHRF6ejoQEdHB1paWgo2Ahrv9WML/w2sxfNvLZ5/axXy/Jf6Xs+MjTFu8+bNBTsWi5NZi+ffWjz/1uL5t1Y1nf9CjpgWjUbR0dEBv98PwOjOEovFMjI8RoP3+rGF/wbW4vm3Fs+/tSr5/DOwQURERGTicDgQjUbz2jcYDCIYDObc7vP5so6MQkRERIXDrihEREREREREVLEY2CAiIiIiIiKiisXABhERERERERFVLAY2iIiIiIiIiKhi2TRN06xuBBERERERERHRSDBjg4iIiIiIiIgqFgMbRERERERERFSxGNggIiIiIiIioorFwAYRERERERERVSwGNoiIiIiIiIioYjGwQUREREREREQVi4ENIiIiIiIiIqpYdVY3gKynKArC4TDsdntqecWKFXC5XKM+tqqqcLvdSCaTJX/tSlHIc9De3o6uri4AQE9PDxRFQSAQQEtLS8a+bW1tWLt2LZqbm+FyueBwOKAoCiKRCBKJBGKx2Kj+rkph1fkv9GtXqkKeg3g8jkgkAlVVoSgKHA4HwuFw1mPx+hdWnf9CvzYdGu/11uK93lq811uL93prVc29XqOq1tXVpTkcDi2ZTKbW9fb2ag6HQ4tGo6M+fktLi5brMiv2a1eCQp6DYDCodXV1ZRwfgObxeDL2D4fDGoCMyeFwaL29vSP6eyqNleef139hz0E4HNbC4XDaOv39JxgMZt2f179155/Xf2nxXm8t3uutxXu9tXivt1Y13esZ2KhyDocj4wLVNE2LRqOa3W4f1X/6rq4uzW635/ywU8zXrhSFOgfJZFIDoLW0tGRs83g8GgAtFoulrQ+Hw5rP59NcLpfmcDg0n8+nRSKREf0dlcrK88/rv7DnP9sNVdM0zeVy8frPwcrzz+u/tHivtxbv9dbivd5avNdbq5ru9QxsVLFYLKYByIg86wBkvRjz1dLSovl8vqwfdor92pWgkOdAf1rgcrkytun/BoPfyMPhcFoEtdpYef55/Rf2HASDwZyR/2g0qgHQfD5f2npe/9adf17/pcV7vbV4r7cW7/XW4r3eWtV2r2fx0Cqm9ytzOBxZt9vtdqxcuXJEx25ra0MoFLLktStFIc+By+VCMpnE6tWrM7YpigIAaGpqGmFLxyYrzz+v/8Keg0QiAb/fj/b29oxteh/ORCIxwpaOTVaef17/pcV7vbV4r7cW7/XW4r3eWtV2r2dgo4rF43EASBVzGczhcIzoDUJRFNjt9pwXcjFfu5IU+hw4HI6MYymKgkQiAY/HU1VFqvJh5fnn9V/Yc+D1emG327N+oFdVdaRNHNOsPP+8/kuL93pr8V5vLd7rrcV7vbWq7V7PUVGqmP6hpNDC4TAikYglr11JSnEOAoEAXC4XotFo1u2qqqKtrQ3d3d2pZa/XC5/PV9R2lQMrzz+v/8Keg2AwiGAwmHVbZ2cnAGT9sM/r316QYw33/PP6Ly3e663Fe721eK+3Fu/11qq2ez0DG1VMVdW8Lrh89wNkCKxAIGDJa1eaYp0DfWirRCIBn8+HcDicc99QKIRoNJp2fKfTCUVRcr55jRVWnn9e/6U7B/oHzRUrVmRs4/VvL9h+uWQ7/7z+S4v3emvxXm8t3uutxXu9tartXs+uKHRIPT09ee2nKApUVS1oGmS+rz2WDfccBINBRKNRxGIxKIoCt9ud6vtp5vP5EIvFMt5MQqEQQqHQmE+PzFexzn8xXnssGs05iMfjiMfjCAaDGe9LvP7zU6zzX+zXpuHjvd5avNdbi/d6a/Feb62xcq9nYKOKFTo6HA6H8458jtXI9HAU+xw4HI5UBFWPTA/eno3H4wEAtLa2FrV9VrPy/PP6L/45UFUVfr8/55M0Xv/2oh5/qPPP67+0eK+3Fu/11uK93lq811ur2u71DGxUIK/XC5vNNqLJXNyloaEhr9fLZ7+Ojo680lKL8dqlVo7nfyj6v4vf7x/W65VrFHssnH9e/8U/B8uXL4fH48nZ5/xQr8frf3j7DTbU+a/k67+UyvHfmvf68vu/puO9vvzOP69/3utHaiycfyuufwY2KlAsFoOmaSOazNEzu90+ZBVhfduhIm6qqmLt2rXDSj8q1GtbodzOPyCpwR0dHVm36dWLzW/ebW1tmDFjxpBpk+WaGjkWzj+v/+KeA334yVwfdHj9W3v+K/n6L6Vy+7fmvd76/2u811fW+ef1z3v9SI2F82/F9c/ARhXT34RzXXSKouT1AUYf5srr9WZM+g1g8HKhXruSFfIceL1e+P3+nDdcnf5asVgMqqpmfW39TT7bcE5jiZXnn9d/8c5Be3s7FEXJWp1ex+vf2vPP67+0eK+3Fu/11uK93lq811ur2u71DGxUMT1tLlskU78Im5ubD3kcl8uFWCyWddIvWH1ZH1qpUK9dyQp9Dux2e9Y3CP345rHXXS4Xurq6su6vjzvt9Xrzfu1KZOX55/VfnHMQj8cRi8WyPj0w9/3k9W/t+ef1X1q811uL93pr8V5vLd7rrVV193qNqprD4dCCwWDG+kgkotntdq23tzdtfW9vrxaLxfI+vsvl0nJdZsN97bGoUOc/GAzm/Hfx+XwaAC0SiaTWJZPJrK+raZrm8Xg0h8MxjL+icll1/kfy2mNRId9/ksmk1tLSkvO1zNt4/Qurzv9IXptGh/d6a/Feby3e663Fe721qulez8BGlevq6tLsdruWTCZT63p7ezWHw6F1dXVl7O/xeLK+cedit9s1AFkv3OG+9lhUyPPv8/m0aDSati4ajWoAsr4JhcNhLRwOp60LBoOa3W7n+S/B+ef1X7jz39vbq9ntds3lcmWd7HZ7xo2V17+155/Xf2nxXm8t3uutxXu9tXivt1Y13evrCpv/QZVGT9MKhUJwOBxobGzE2rVrEYlEsqZueb1edHZ2DtknTX1v6J+enp5UqpHb7YbD4UA4HE4dd7ivPRYV8vxHo1F0dHSkKnKb+9jqw1qZBYNBxONxBAKB1L+Vw+HAxo0by7KQVTFYef55/Rfu/Pv9fqiqOmR188WLF6ct8/q39vzz+i8t3uutxXu9tXivtxbv9daqpnu9TdM0reBHJSIiIiIiIiIqARYPJSIiIiIiIqKKxcAGEREREREREVUsBjaIiIiIiIiIqGIxsEFEREREREREFYuBDSIiIiIiIiKqWAxsEBEREREREVHFYmCDiIiIiIiIiCoWAxtEREREREREVLEY2CAiIiIiIiKiisXABhERERERERFVLAY2iIiIiIiIiKhiMbBBRERERERERBWLgQ0iGlPa2trgdrsxY8aM1OT1eqEoSsa+iqLA6XTCZrNhxowZcDqdiMfjFrSaiIiI8sV7PRENZtM0TbO6EUREheZ0OqEoCmKxGDwez5D72my2vPYjIiKi8sF7PRHpmLFBRGOSy+UCAKiqOuR+HR0diEQi/KBDRERUYXivJyJdndUNICIqBofDAQBZ01J1qqpi5cqViEajpWoWERERFQjv9USkY8YGEY1JTqcTAJBMJnPuEwqFEA6HS9UkIiIiKiDe64lIx8AGEY1Jh3qKE4/H4XQ6U/sRERFRZeG9noh07IpCRGPSoT7sRCIRpqUSERFVMN7riUjHUVGIaMyy2WwAgMFvc6FQCM3NzamiY0RERFSZeK8nIoBdUYhoDLPb7QDSq6UrigJVVflBh4iIaAzgvZ6IAAY2iGgMy5aiGgqFEIlEivaa7e3tSCQSRTs+ERERGXivJyKAgQ0iGsMGf9hpb29Hc3NzUV8zFosV9fhERERk4L2eiAAGNohoDNM/7KxduxaqqiIWi8Hn8+X9++a01nzE43F0dHQM63eIiIho5HivJyKAo6IQ0Ri2ePFiAPIUZ/ny5bjtttty7hsIBNL66TqdTnR3d0NVVUQiEaiqitbWVjidTiSTSaiqinA4nPqdeDyeqrze2tqKhoYGuN1utLS0pF6jra0N3d3daGxsRDKZRCAQYP9fIiKiUeC9nogAjopCRGNYIpGA2+0GIEO+mT94mAUCgdQ+gPTNVRQlbYi4trY2rFy5El1dXVmXdTabDV1dXRkfYvx+PxoaGlKvoaoqjjnmGGzcuDH1gYmIiIiGh/d6IgLYFYWIxjA9PdXlcuX8oAPIUx7zBw6n05lWhAwAfD4fVqxYkbacSCTySmFVFAUdHR2pD1WAVHFvamrCqlWr8vxriIiIaDDe64kIYFcUIhrD7HY7HA5H2tOYbEKhEAKBAAKBQOpJi/mDDSAfnBKJBEKhEBobG9Hd3Z13O/TK6fF4HJ2dnan1fr8fHo9nGH8RERERmfFeT0QAu6IQEaGjowN2uz315Mbj8aSeAOm8Xi/sdnvqg5OiKHA6nejt7QWA1FMgc3pqKBRCOBxO7ZstbZWIiIiKj/d6orGNXVGIqOr19PQgkUjg3//939HS0pLxQQeQJzDm4eP0JzM9PT1obW1Nrbfb7ejp6QFgVFp3OBxoaWlJ2w+QIeni8Xih/xwiIiIahPd6orGNGRtEVPVUVcWMGTPS1jkcDoRCoVR/3fb2dsRiMSxevDiV9ppIJBCLxRAIBFJDy3V0dKC1tRVNTU0Z6aft7e3o6upKPfFZvHjxsIakIyIiopHhvZ5obGNgg4iqmqIo8Pv9uO2221Kpo6qqptZHIhH2jSUiIqpgvNcTjX3sikJEVU1PITX3h7Xb7XC5XFnTVImIiKiy8F5PNPYxY4OIql48Hkc0GoXT6UytSyaTrGROREQ0RvBeTzS2MbBBRERERERERBWLXVGIiIiIiIiIqGIxsEFEREREREREFYuBDSIiIiIiIiKqWAxsEBEREREREVHFYmCDiIiIiIiIiCoWAxtEREREREREVLEY2CAiIiIiIiKiisXABhERERERERFVLAY2iIiIiIiIiKhiMbBBRERERERERBWLgQ0iIiIiIiIiqlgMbBARERERERFRxWJgg4iIiIiIiIgqFgMbRERERERERFSx/j+37vrQ7YcTjAAAAABJRU5ErkJggg==",
            "text/plain": [
              "<Figure size 1200x600 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "tickfont = 12\n",
        "labelfont = 11\n",
        "\n",
        "fig = plt.figure()\n",
        "fig, bx = plt.subplots(1,2, figsize=(8,4),dpi=150)\n",
        "\n",
        "ax = bx[0]\n",
        "ax.set_title(\"$J^\\\\beta_{\\\\alpha\\\\alpha'}$\",size=tickfont)\n",
        "\n",
        "ax.plot(Vgset,Jvec[:,0,0],color='r',label=\"parity: $+1$\")\n",
        "for i in range(1,4): ax.plot(Vgset,Jvec[:,0,i],color='r')\n",
        "ax.plot(Vgset,Jvec[:,1,0],color='b',label=\"parity: $-1$\")\n",
        "for i in range(1,4): ax.plot(Vgset,Jvec[:,1,i],color='b')\n",
        "ax.legend(loc='best')\n",
        "ax.tick_params(axis='both', which='major', labelsize=tickfont)\n",
        "ax.tick_params(axis='both', which='minor', labelsize=tickfont)\n",
        "ax.set_ylabel(\"$\\\\rm exchange~coupling$\",fontsize=labelfont)\n",
        "ax.set_xlabel(\"$V_{\\\\rm gate}$\",fontsize=labelfont)\n",
        "ax.tick_params(axis='y', which='major', labelsize=tickfont)\n",
        "ax.tick_params(axis='y', which='minor', labelsize=tickfont)\n",
        "ax.tick_params(axis='x', which='major', labelsize=tickfont)\n",
        "ax.tick_params(axis='x', which='minor', labelsize=tickfont)\n",
        "\n",
        "# Next panel\n",
        "ax = bx[1]\n",
        "ax.set_title(\"$W^\\\\beta_{\\\\alpha\\\\alpha'}$\",size=tickfont)\n",
        "ax.plot(Vgset,Wvec[:,0,0],color='r',label=\"parity: $+1$\")\n",
        "for i in range(1,4): ax.plot(Vgset,Wvec[:,0,i],color='r')\n",
        "ax.plot(Vgset,Wvec[:,1,0],color='b',label=\"parity: $-1$\")\n",
        "for i in range(1,4): ax.plot(Vgset,Wvec[:,1,i],color='b')\n",
        "ax.legend(loc='best')\n",
        "ax.tick_params(axis='both', which='major', labelsize=tickfont)\n",
        "ax.tick_params(axis='both', which='minor', labelsize=tickfont)\n",
        "ax.set_xlabel(\"$V_{\\\\rm gate}$\",fontsize=labelfont)\n",
        "ax.tick_params(axis='y', which='major', labelsize=tickfont)\n",
        "ax.tick_params(axis='y', which='minor', labelsize=tickfont)\n",
        "ax.tick_params(axis='x', which='major', labelsize=tickfont)\n",
        "ax.tick_params(axis='x', which='minor', labelsize=tickfont)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "interpreter": {
      "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.4"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}