e_NFA_to_DFA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "e-NFA_to_DFA.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "iI14AskJFHw-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5925bb64-89cb-4c5c-954c-8393bee33564"
      },
      "source": [
        "# for finite automata visualization\n",
        "!sudo apt-get install python3-dev graphviz libgraphviz-dev pkg-config\n",
        "!pip install pygraphviz"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "pkg-config is already the newest version (0.29.1-0ubuntu2).\n",
            "graphviz is already the newest version (2.40.1-2).\n",
            "python3-dev is already the newest version (3.6.7-1~18.04).\n",
            "python3-dev set to manually installed.\n",
            "The following package was automatically installed and is no longer required:\n",
            "  libnvidia-common-460\n",
            "Use 'sudo apt autoremove' to remove it.\n",
            "The following additional packages will be installed:\n",
            "  libgail-common libgail18 libgtk2.0-0 libgtk2.0-bin libgtk2.0-common\n",
            "  libgvc6-plugins-gtk libxdot4\n",
            "Suggested packages:\n",
            "  gvfs\n",
            "The following NEW packages will be installed:\n",
            "  libgail-common libgail18 libgraphviz-dev libgtk2.0-0 libgtk2.0-bin\n",
            "  libgtk2.0-common libgvc6-plugins-gtk libxdot4\n",
            "0 upgraded, 8 newly installed, 0 to remove and 49 not upgraded.\n",
            "Need to get 2,120 kB of archives.\n",
            "After this operation, 7,128 kB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu bionic/main amd64 libgtk2.0-common all 2.24.32-1ubuntu1 [125 kB]\n",
            "Get:2 http://archive.ubuntu.com/ubuntu bionic/main amd64 libgtk2.0-0 amd64 2.24.32-1ubuntu1 [1,769 kB]\n",
            "Get:3 http://archive.ubuntu.com/ubuntu bionic/main amd64 libgail18 amd64 2.24.32-1ubuntu1 [14.2 kB]\n",
            "Get:4 http://archive.ubuntu.com/ubuntu bionic/main amd64 libgail-common amd64 2.24.32-1ubuntu1 [112 kB]\n",
            "Get:5 http://archive.ubuntu.com/ubuntu bionic/universe amd64 libxdot4 amd64 2.40.1-2 [15.7 kB]\n",
            "Get:6 http://archive.ubuntu.com/ubuntu bionic/universe amd64 libgvc6-plugins-gtk amd64 2.40.1-2 [18.2 kB]\n",
            "Get:7 http://archive.ubuntu.com/ubuntu bionic/universe amd64 libgraphviz-dev amd64 2.40.1-2 [57.3 kB]\n",
            "Get:8 http://archive.ubuntu.com/ubuntu bionic/main amd64 libgtk2.0-bin amd64 2.24.32-1ubuntu1 [7,536 B]\n",
            "Fetched 2,120 kB in 0s (5,564 kB/s)\n",
            "debconf: unable to initialize frontend: Dialog\n",
            "debconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 76, <> line 8.)\n",
            "debconf: falling back to frontend: Readline\n",
            "debconf: unable to initialize frontend: Readline\n",
            "debconf: (This frontend requires a controlling tty.)\n",
            "debconf: falling back to frontend: Teletype\n",
            "dpkg-preconfigure: unable to re-open stdin: \n",
            "Selecting previously unselected package libgtk2.0-common.\n",
            "(Reading database ... 155653 files and directories currently installed.)\n",
            "Preparing to unpack .../0-libgtk2.0-common_2.24.32-1ubuntu1_all.deb ...\n",
            "Unpacking libgtk2.0-common (2.24.32-1ubuntu1) ...\n",
            "Selecting previously unselected package libgtk2.0-0:amd64.\n",
            "Preparing to unpack .../1-libgtk2.0-0_2.24.32-1ubuntu1_amd64.deb ...\n",
            "Unpacking libgtk2.0-0:amd64 (2.24.32-1ubuntu1) ...\n",
            "Selecting previously unselected package libgail18:amd64.\n",
            "Preparing to unpack .../2-libgail18_2.24.32-1ubuntu1_amd64.deb ...\n",
            "Unpacking libgail18:amd64 (2.24.32-1ubuntu1) ...\n",
            "Selecting previously unselected package libgail-common:amd64.\n",
            "Preparing to unpack .../3-libgail-common_2.24.32-1ubuntu1_amd64.deb ...\n",
            "Unpacking libgail-common:amd64 (2.24.32-1ubuntu1) ...\n",
            "Selecting previously unselected package libxdot4.\n",
            "Preparing to unpack .../4-libxdot4_2.40.1-2_amd64.deb ...\n",
            "Unpacking libxdot4 (2.40.1-2) ...\n",
            "Selecting previously unselected package libgvc6-plugins-gtk.\n",
            "Preparing to unpack .../5-libgvc6-plugins-gtk_2.40.1-2_amd64.deb ...\n",
            "Unpacking libgvc6-plugins-gtk (2.40.1-2) ...\n",
            "Selecting previously unselected package libgraphviz-dev.\n",
            "Preparing to unpack .../6-libgraphviz-dev_2.40.1-2_amd64.deb ...\n",
            "Unpacking libgraphviz-dev (2.40.1-2) ...\n",
            "Selecting previously unselected package libgtk2.0-bin.\n",
            "Preparing to unpack .../7-libgtk2.0-bin_2.24.32-1ubuntu1_amd64.deb ...\n",
            "Unpacking libgtk2.0-bin (2.24.32-1ubuntu1) ...\n",
            "Setting up libgtk2.0-common (2.24.32-1ubuntu1) ...\n",
            "Setting up libxdot4 (2.40.1-2) ...\n",
            "Setting up libgtk2.0-0:amd64 (2.24.32-1ubuntu1) ...\n",
            "Setting up libgail18:amd64 (2.24.32-1ubuntu1) ...\n",
            "Setting up libgail-common:amd64 (2.24.32-1ubuntu1) ...\n",
            "Setting up libgvc6-plugins-gtk (2.40.1-2) ...\n",
            "Setting up libgraphviz-dev (2.40.1-2) ...\n",
            "Setting up libgtk2.0-bin (2.24.32-1ubuntu1) ...\n",
            "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n",
            "Processing triggers for libc-bin (2.27-3ubuntu1.3) ...\n",
            "/sbin/ldconfig.real: /usr/local/lib/python3.7/dist-packages/ideep4py/lib/libmkldnn.so.0 is not a symbolic link\n",
            "\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting pygraphviz\n",
            "  Downloading pygraphviz-1.7.zip (118 kB)\n",
            "\u001b[K     |████████████████████████████████| 118 kB 5.0 MB/s \n",
            "\u001b[?25hBuilding wheels for collected packages: pygraphviz\n",
            "  Building wheel for pygraphviz (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for pygraphviz: filename=pygraphviz-1.7-cp37-cp37m-linux_x86_64.whl size=165754 sha256=266d8ce7456ff830f0a8ada66fd477702e9d55ac64fbdc4949113cc4cba9d6dd\n",
            "  Stored in directory: /root/.cache/pip/wheels/8c/bc/0c/ac35392b72556e75107ff610cb31b313e8471918a6d280e34c\n",
            "Successfully built pygraphviz\n",
            "Installing collected packages: pygraphviz\n",
            "Successfully installed pygraphviz-1.7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BA_ZKLMwL1yi"
      },
      "source": [
        "# function to graph given finite automata\n",
        "def graph(delta,F,Q,q0,connectionstyle='arc3, rad = 0',label_pos=0.7):\n",
        "  import matplotlib.pyplot as plt\n",
        "  import networkx as nx\n",
        "  import numpy as np\n",
        "  import pydot\n",
        "  from networkx.drawing.nx_agraph import graphviz_layout\n",
        "  \n",
        "  # convert list of characters into strings\n",
        "  table=[]\n",
        "  for i in delta:\n",
        "    if i[1]=='e': table.append([''.join(i[0]),''.join(i[2]),-1])\n",
        "    else: table.append([''.join(i[0]),''.join(i[2]),int(i[1])])  \n",
        "  adfa=[]\n",
        "  for i in F: adfa.append(''.join(i))\n",
        "  s=[]\n",
        "  for i in Q: s.append(''.join(i))\n",
        "\n",
        "  # initialize graph and add all the edges\n",
        "  G=nx.MultiDiGraph()\n",
        "  for i in table: G.add_edge(i[0], i[1], weight=i[2] if i[2]!=-1 else 'Ɛ')\n",
        "\n",
        "  # assign color values to respective nodes\n",
        "  # by default nodes are yellow\n",
        "  # green node implies initial node\n",
        "  # purple node implies initial and final node\n",
        "  # red nodes imply final nodes\n",
        "  values=[]\n",
        "  for i in s:\n",
        "    if i == ''.join(q0): \n",
        "      if i in adfa: values.append('purple')\n",
        "      else: values.append('green')\n",
        "    elif i in adfa: values.append('red')\n",
        "    else: values.append('yellow')\n",
        "\n",
        "  # get edge and node labels\n",
        "  edge_labels=dict([((u,v,),d['weight']) for u,v,d in G.edges(data=True)])\n",
        "  node_labels = {node:node for node in G.nodes()}\n",
        "\n",
        "  # define graph layout style\n",
        "  pos=graphviz_layout(G,prog='sfdp')\n",
        "  # define size of graph image\n",
        "  plt.figure(figsize=(8,8))\n",
        "  # define nodes of graph\n",
        "  nodes = nx.draw_networkx_nodes(G, pos, node_color = values, node_size=1500)\n",
        "  # define edges of graph\n",
        "  nodes.set_edgecolor('black')\n",
        "  nx.draw_networkx_edges(G,pos,arrowstyle = '-|>',arrowsize=20,edge_color='black',edge_cmap=plt.cm.Reds,connectionstyle=connectionstyle, node_size=1500)\n",
        "  nx.draw_networkx_labels(G, pos, labels=node_labels)\n",
        "  nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels,label_pos=label_pos)\n",
        "  # plot graph\n",
        "  plt.show()  \n",
        "  \n",
        "  # the i/p value is closer to the base of the arrow (i.e. closer to start of the edge)"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "STdB7JcY2Dcu",
        "outputId": "854157b1-d830-46c0-bc30-67e29ed27671"
      },
      "source": [
        "# print a list with given seperator and end string\n",
        "def print_list(l,s='',e=''):\n",
        "  #if type(l) in (list(),tuple(),set()): \n",
        "  list(l).sort()\n",
        "  print(*l,sep=s,end=e)\n",
        "\n",
        "# find and return e-closure of given state\n",
        "def closure(state):\n",
        "    s=state\n",
        "    for i in enfa_delta:\n",
        "        for j in state:\n",
        "            if i[0]==j and i[1]=='e': s+=[i[2]]\n",
        "    s=list(set(s))\n",
        "    s.sort()\n",
        "    return s\n",
        "\n",
        "# find and return next states given state and symbol \n",
        "def delta(state,symbol):\n",
        "    s = []\n",
        "    for i in enfa_delta:\n",
        "        if i[0]==state and i[1]==symbol: s+=[i[2]]\n",
        "    s=list(set(s))\n",
        "    s.sort()\n",
        "    return s\n",
        "\n",
        "# function to find set of acceptance states in DFA using acceptance states of enfa and all states of dfa \n",
        "def statesAcceptanceDFA(states,F):\n",
        "    dfa_F = []\n",
        "    for f in F:\n",
        "      for s in states:\n",
        "        if (f in s) and ((len(dfa_F)==0) or (s not in dfa_F)):\n",
        "          dfa_F.append(s)\n",
        "    return dfa_F\n",
        "\n",
        "# variable to decide if to take input values or use default, pre-filled values\n",
        "custom = False\n",
        "\n",
        "# prefilled values to run program without inputting values\n",
        "nQ=6\n",
        "enfa_Q = ['A','B','C','D','E','F']\n",
        "enfa_q0 = 'A'\n",
        "enfa_F=['F']\n",
        "nsig=2\n",
        "dfa_sigma = ['0','1']\n",
        "ndel=11\n",
        "enfa_delta=[['A','0','F'],['A','0','C'],['A','e','B'],['A','e','F'],['B','1','C'],['C','e','D'],['D','0','E'],['D','1','A'],['E','0','A'],['E','e','B'],['E','e','F']]\n",
        "\n",
        "# block of code to input various values\n",
        "if custom:\n",
        "  nQ = int(input(\"Enter the number of states :\"))\n",
        "\n",
        "  enfa_Q = []\n",
        "  for i in range (nQ):\n",
        "      enfa_Q += input (\"Enter state \" + str (i + 1) + \" :\")\n",
        "\n",
        "  enfa_q0 = input (\"Enter the input states :\")\n",
        "\n",
        "  enfa_F = input(\"Enter the acceptance states :\").split(\" \")\n",
        "\n",
        "  nsig = int(input(\"Enter the number of symbols (excluding epsilon):\"))\n",
        "\n",
        "  dfa_sigma = []\n",
        "  for i in range (nsig):\n",
        "      dfa_sigma += [input (\"Enter the symbol #\" + str (i + 1) + \" :\")]\n",
        "\n",
        "  ndel = int(input(\"Enter the number of transitions:\"))\n",
        "  \n",
        "  print (\" Enter the transitions in the following format: Input_State Symbol Output_State \\n -> In the case of epsilon, write e in the symbol\")\n",
        "  i = 0\n",
        "  enfa_delta = []\n",
        "  tran = []\n",
        "  while (i<ndel):\n",
        "      tran = input (\"Enter the transition #\" + str (i + 1) + \":\")\n",
        "      tran = tran.split(\" \")\n",
        "      enfa_delta.append(tran)\n",
        "      i += 1\n",
        "\n",
        "print(\"================================================================== \")\n",
        "# print parameters of epsilon-nfa\n",
        "print(\"eNFA\")\n",
        "\n",
        "enfa_sigma = dfa_sigma.copy()\n",
        "enfa_sigma += 'e'\n",
        "\n",
        "print()\n",
        "print(\"set of states (Q): {\",end='')\n",
        "print_list(enfa_Q,s=',',e='}\\n')\n",
        " \n",
        "print(\"set of input symbols (∑): {\",end='')\n",
        "print_list(enfa_sigma,s=',',e='}\\n')\n",
        "\n",
        "print(\"initial state (q0): {\",end='')\n",
        "print_list(enfa_q0,s=',',e='}\\n')\n",
        "\n",
        "print(\"final states (F): {\",end='')\n",
        "print_list(enfa_F,s=',',e='}\\n')\n",
        "\n",
        "print(\"Transition function (δ):\\n\\n\\t\",end='')\n",
        "\n",
        "print_list(enfa_sigma,s='\\t',e='\\n\\n')\n",
        "for i in enfa_Q:\n",
        "  print(i,end=\"\\t\")\n",
        "  for j in enfa_sigma: \n",
        "    d=delta(i,j)\n",
        "    if d: print_list(d);\n",
        "    else: print_list('-');\n",
        "    print(\"\\t\",end='');\n",
        "  print()\n",
        "\n",
        "print(\"================================================================== \")"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "================================================================== \n",
            "eNFA\n",
            "\n",
            "set of states (Q): {A,B,C,D,E,F}\n",
            "set of input symbols (∑): {0,1,e}\n",
            "initial state (q0): {A}\n",
            "final states (F): {F}\n",
            "Transition function (δ):\n",
            "\n",
            "\t0\t1\te\n",
            "\n",
            "A\tCF\t-\tBF\t\n",
            "B\t-\tC\t-\t\n",
            "C\t-\t-\tD\t\n",
            "D\tE\tA\t-\t\n",
            "E\tA\t-\tBF\t\n",
            "F\t-\t-\t-\t\n",
            "================================================================== \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# plot enfa\n",
        "graph(enfa_delta,enfa_F,enfa_Q,enfa_q0,connectionstyle='arc3, rad = 0')\n",
        "\n",
        "# the i/p value is closer to the base of the arrow (i.e. closer to start of the edge)\n",
        "\n",
        "# by default nodes are yellow\n",
        "# green node implies initial node\n",
        "# purple node implies initial and final node\n",
        "# red nodes imply final nodes"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 466
        },
        "id": "8pqjMgIlO_uV",
        "outputId": "077eac9d-480a-4020-ed45-242351fc7e9a"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Epsilon Closures of all states:\\n\")\n",
        "\n",
        "# find epsilon-closure of all the states in enfa\n",
        "for i in enfa_Q:\n",
        "  print('Ɛ-closure({}) = {{'.format(i),end='')\n",
        "  print_list(closure([i]),s=',',e='}\\n\\n')\n",
        "\n",
        "print(\"================================================================== \")\n",
        "# calculate and print parameters of dfa\n",
        "print(\"DFA\")\n",
        "\n",
        "dfa_q0 = closure([enfa_q0])\n",
        "dfa_Q = [dfa_q0]\n",
        "c = 0\n",
        "k = 0\n",
        "dfa_delta = []\n",
        "\n",
        "while(True):\n",
        "    # for every symbol in dfa\n",
        "    for i in dfa_sigma:\n",
        "        q1 = []\n",
        "        # find delta of each enfa state in a particular dfa state\n",
        "        for j in dfa_Q[k]:\n",
        "            q1 += delta(j,i)\n",
        "            q1 = list(set(q1))\n",
        "        # add closure of all deltas as next state\n",
        "        q1 = closure(q1)\n",
        "        dfa_delta += [[dfa_Q[k],i,q1]]\n",
        "        # if the new state is not in dfa_Q the add it\n",
        "        flag = True\n",
        "        for j in dfa_Q:\n",
        "            if j==q1: flag=False;\n",
        "        if flag:\n",
        "            dfa_Q += [q1]\n",
        "            c += 1\n",
        "    k += 1\n",
        "    # exit loop if all states are explored\n",
        "    if k>c: break;\n",
        "\n",
        "# find set of acceptance states in DFA using acceptance states of enfa and all states of dfa \n",
        "dfa_F = statesAcceptanceDFA(dfa_Q,enfa_F) \n",
        "\n",
        "print(\"set of states (Q): {\",end='')\n",
        "for i in range(len(dfa_Q)-1): print_list(dfa_Q[i],e=',');\n",
        "print_list(dfa_Q[len(dfa_Q)-1],e='}\\n')\n",
        " \n",
        "print(\"set of input symbols (∑): {\",end='')\n",
        "print_list(dfa_sigma,s=',',e='}\\n')\n",
        "\n",
        "print(\"initial state (q0): {\",end='')\n",
        "print_list(dfa_q0,e='}\\n')\n",
        "\n",
        "print(\"final states (F): {\",end='')\n",
        "for i in range(len(dfa_F)-1): print_list(dfa_F[i],e=',');\n",
        "print_list(dfa_F[len(dfa_F)-1],e='}\\n')\n",
        "\n",
        "print(\"Transition function (δ):\\n\\n\\t\",end='')\n",
        "\n",
        "qi=0\n",
        "i=0\n",
        "\n",
        "print_list(dfa_sigma,s='\\t',e='\\n\\n')\n",
        "while(i<(len(dfa_Q)*len(dfa_sigma))):\n",
        "    print_list(dfa_Q[qi], e = \"\\t\")\n",
        "\n",
        "    while (i<(len(dfa_sigma)*(qi+1))):\n",
        "        print_list(dfa_delta[i][2],e=\"\\t\")\n",
        "        i += 1\n",
        "    print()\n",
        "    qi += 1\n",
        "print(\"================================================================== \")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zzF1lF-NRsRx",
        "outputId": "bcb50c89-b681-4b74-a523-00a904c01f97"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epsilon Closures of all states:\n",
            "\n",
            "Ɛ-closure(A) = {A,B,F}\n",
            "\n",
            "Ɛ-closure(B) = {B}\n",
            "\n",
            "Ɛ-closure(C) = {C,D}\n",
            "\n",
            "Ɛ-closure(D) = {D}\n",
            "\n",
            "Ɛ-closure(E) = {B,E,F}\n",
            "\n",
            "Ɛ-closure(F) = {F}\n",
            "\n",
            "================================================================== \n",
            "DFA\n",
            "set of states (Q): {ABF,CDF,CD,BEF}\n",
            "set of input symbols (∑): {0,1}\n",
            "initial state (q0): {ABF}\n",
            "final states (F): {ABF,CDF,BEF}\n",
            "Transition function (δ):\n",
            "\n",
            "\t0\t1\n",
            "\n",
            "ABF\tCDF\tCD\t\n",
            "CDF\tBEF\tABF\t\n",
            "CD\tBEF\tABF\t\n",
            "BEF\tABF\tCD\t\n",
            "================================================================== \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# plot dfa\n",
        "graph(dfa_delta,dfa_F,dfa_Q,dfa_q0,connectionstyle='arc3, rad = 0.2')\n",
        "\n",
        "# the i/p value is closer to the base of the arrow (i.e. closer to start of the edge)\n",
        "\n",
        "# by default nodes are yellow\n",
        "# green node implies initial node\n",
        "# purple node implies initial and final node\n",
        "# red nodes imply final nodes"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 466
        },
        "id": "MruRwEw6JAMU",
        "outputId": "c36cec40-a18d-4ad1-b634-5fd6ca3c1333"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcwAAAHBCAYAAADkRYtYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd1QUVx/G8e/SiwUjEjXGXiMacdFYsTfEGBU09liixhZjjRpr7C1WjL33gthLigh2sfcSuwQ7orRddt4/iL4WVNDdnQV+n3P25Bx2du4DRh5n5s4djaIoCCGEEOLdrNQOIIQQQqQEUphCCCFEEkhhCiGEEEkghSmEEEIkgRSmEEIIkQRSmEIIIUQS2LzrTVdXVyV37txmiiKEEEKoLzQ09L6iKFle//o7CzN37twcOXLEdKmEEEIIC6PRaK4n9nU5JSuEEEIkgRSmEEIIkQRSmEIIIUQSSGEKIYQQSSCFKYQQQiSBFKYQQgiRBFKYQgghRBJIYQohhBBJIIUphBBCJIEUphBCCJEEUphCCCFEEkhhCiGEEEkghSmEEEIkgRSmEEIIkQRSmEIIIUQSvPN5mEII89PpdFy7do2oqCj0ej329vZkyZKFTz/9VO1oQqRpUphCqCwqKor169ez76+/CN23j9P//MOn9vaks7LCBogFwmJjcXBwQPvll2grVcLn66/x9PRUO7oQaYpGUZS3vunp6akcOXLEjHGESDsuXrzIzMmTWbxoEWWsrKj+9CmeQAkg/WvbKsB14Ahw2NqaVfb2uOXMSed+/WjSpAmOjo7mji9EqqXRaEIVRXnjX6RSmEKY2aNHj+j5ww9s3biRtno9HXU6cidzH/HAdsA/XTpCrayYOmcOjRs3Nn5YIdKgtxWmTPoRwoy2bNlCsXz5cN6wgSvR0Yz+gLIEsAbqAluePmXDkycMadsWv7p1uXfvnnEDCyFekMIUwgwMBgM//fAD3Ro3ZsmjR0yPjSWdkfZdBjj67Bl5/viD4gUKcPDgQSPtWQjxMilMIUwsPj6eNt9+y5HFizkaFUUVE4zhCIyLi2NuRAT1qlXj77//NsEoQqRtUphCmJCiKHRu25abW7awIyoKFxOPVxdY9ewZjX185EhTCCOTwhTChGZOn87htWsJjIrCyUxjVgEWREXRoHZtHjx4YKZRhUj9pDCFMJGrV68y+OefWR4V9cZtIqbmAzSOiqJ7+/ZmHlmI1EsKUwgTMBgMtG3ShH6xsRRWKcOouDgO7dzJhg0bVEogROoihSmECaxcuZJnZ8/SMz5etQxOJJya7dquHXFxcarlECK1kMIUwgSmjx7NwGfPsFY5RwWgoE4nR5lCGIEUphBGduzYMW798w911Q7yn86RkfiPHat2DCFSPClMIYxs5qRJdIyNtZgnG9QHLp07x5kzZ9SOIkSKJoUphJFt27qVxu+5dpmbhMUG0gGZSLh/8uZ/730H2P333vPXl/+9dw3QvOW9t7EFGhgMbN++PVnfhxDiVVKYQhjR3bt3efrsGfmTsO0m4CkQBnwKdHvpvb7/vff8deK1zz5+x3uJ8YyNJTQoKAlbCiHeRgpTCCMKDQ2lpL09mmR8xgHwBc6aKBOAFgiVJw8J8VGkMIUwouPHjlEyKipZn4kCVpGwiLqpFAFu3b/P06dPTTiKEKmbFKYQRvTg339x0+uTtO03gAuQEdgF9HnpvQn/vff81fq1z7q+9N6EJIxlA7jY2vL48eMkZRNCvMlSJvIJkSrERkfjkMRtNwDVSXgYdCBQif+flu0NjHjHZ++T/L+8DlZWxMTEJPNTQojn5AhTCCOytbdHl8zPWAMN//tviPEjvaBTFGxtbU04ghCpmxSmEEbknDEjT5L5GYWEI8xHJFxrNAUFiNTrcXZ2NtEIQqR+UphCGNEX7u6cSp+0Z5PUI+E+ygzAQGARUPS/98bx6r2Wrh+Z6xZgZ2dH5syZP3JPQqRdcg1TCCPSarX0Nxjeu921d7y38L9XYnKTcLSYXKGAtlgxNJrk3PAihHiZHGEKYUT58+fnUXw899UO8ppQKyu0lSqpHUOIFE0KUwgjsrKyopxWyw61g7xmh7MzFaQwhfgoUphCGFn7n37C34Im1xwB7trbU716dbWjCJGiyTVMIYzEYDCwefNmxo8fz9mYGE7w/oXRzWGmoyPeDRvi7+9PpkyZMBgMxMfHv/FSFIWmTZuSJUsWtSMLYZGkMIX4SDqdjlWrVjFmzBjs7Ozo378/Z0+dYvL48SxQeaGAf4H1ikL92Fi6d++OjY0NdnZ2aDQaFEV55RUbG0vlypWlMIV4CylMIT5QdHQ08+fPZ8KECeTOnZtJkyZRo0YNNBoNj2vUoNiMGfwdE0MVlfIpwA9OTnTu3JkR48Zx9epV9u7dS9Rb1rqtWLEixYsXN29IIVIQuYYpRDLFxMQwdepU8uXLx86dO1mxYgV///03NWvWfHHbhouLC78vXkw7JyfUWu58BXDJzY3BI0ag0WgIDAx869Gjk5MTY8aMMW9AIVIYKUwhkig2NhZ/f3/y58/Pn3/+yZYtWwgMDKRMmcSfM1K3bl28fHzoaW//QfdOfoxbwE+OjixcswZ7e3sgocS3bt2Ko6PjG9s7OzuTN29eM6cUImWRwhTiPeLi4pg9ezYFChRgy5YtbNiwgcDAQDw8PN772cmzZrE/e3ZG2Zjv6sc9oIaTE/2GDsXT0/OV9zw8PPjtt99wcnJ68TUnJycqVapE0aJF+eWXX4iIiDBbViFSEilMId5Cp9Mxf/58ChUqxLp161i9ejVbtmx5o4TexcXFhZ1797Lo008ZYWNj8iPNMKCqkxONunShZ9++iW7ToUMH6tWrh4NDwnNV8uXLx+rVqzl27Bi3b9+mQIECTJo0SZ5sIsRrpDCFeI1er2fx4sUUKVKE5cuXs3TpUnbs2PHWU6/vky1bNvYcOcLqnDlp5+CQ7MXZkyoEKO/kRNO+ffl17Ni3bqfRaJg/fz6fffYZNjY2jB07Fo1GQ86cOVmwYAF///03QUFBFCpUiAULFhAfH2+ixEKkMK9PLX/5pdVqFSHSCr1eryxbtkwpWLCg4uXlpezevduo+4+IiFC+b9lSyenkpOwARTHS6xkoPezslGwZMyoBAQFJznPx4kWlY8eOisFgSPT9kJAQpUKFCsoXX3yhbNiw4a3bCZHaAEeURDpRClOkeQaDQVm7dq1SpEgRpVy5csoff/xh0nLYsWOHktPVVWnq6KgcAMXwgUUZCcosUPI5OSnNvvlGuX//vtGzGgwGZdOmTYq7u7tSrlw5Zc+ePUYfQwhL87bClFOyIk07ePAgFStWZPjw4UyaNImQkBCqVatm0qd61KxZk627dxNdowZ+n3xCcTs75pDwBJP3XeOMAQ4AP9rZkcvBga3VqjFr40aWBQSY5NFdGo0GHx8fjh8/TseOHWnZsiU+Pj6cOXPG6GMJYek0CWWaOE9PT+XIkSNmjCOEeVy/fp3+/fuzZ88efv31V1q1aoW1tbVZxv7777/x9vbG3t6eBg0aYGNjw6ObN9l/8CAx0dFo7e1xj44mnU6HLRBjZcW/Dg6E2thwMSqKQjlz4t2oER27diVnzpxmyfxcbGwsM2fOZOTIkTRr1oxhw4bh4uJi1gxCmJpGowlVFOWN2X1SmCJNiYiIYPTo0cyZM4fu3bvTu3dvnM20ULper2fgwIFMnTqVmJgYcufOzePHjzlz5gzZs2cHICwsjNDQUM6dO0dUVBS62FgcnZ3JnDkzWq2WYsWKvZjdqqZ79+7xyy+/EBgYyIgRI2jbti1WVnLCSqQOUpgiTdPpdMyZM4fhw4fj7e3NiBEjXpSUOVy7do369etz+fLlF0vT5ciRgyJFirBz506z5TC20NBQunXrhk6nY9q0aR88k1gIS/K2wpR/EopUTVEUNm/eTPHixVm/fj3bt29n/vz5Zi3L1atXU6xYMU6fPv3KOq4RERG0aNHCbDlMQavVsnfvXn788UcaNWrEd999x7///qt2LCFMQgpTpFrHjx+nevXq9O3bl4kTJ7Jr1y5KlChhtvGjo6Np2bIlbdq04enTpxgMhlfej4qKomHDhmbLYyoajYYWLVpw/vx53NzccHd3Z+LEicTFxakdTQijksIUqc7du3dp27YttWvXxs/Pj5MnT+Lt7W3Sma+JOXDgAMuXLyc2NjbR9zNmzEi6dOnMmsmU0qdPz7hx49i7dy9//PEHxYsXT9Gnm4V4nRSmSDUMBgO///477u7ufPLJJ1y8eJFOnTphY8Z1XF9WpUoVLl68yDfffJPogudubm4qpDK9QoUKsXXrVsaPH0/nzp355ptvuHr1qtqxhPhoUpgiVTh27Bhly5Zl6dKl/Pnnn0yYMIEMGTKoHYt8+fKxdu1aZsyYgaOj4yvF6erqqmIy09JoNNSrV4/Tp09TunRpSpUqxYQJE9Dr9WpHE+KDSWGKFC0iIoIff/yR2rVr07FjR/bs2UOxYsXUjvWK+Ph4pkyZwuLFiwkJCSFXrlxoNBpsbW3VjmZyDg4ODBgwgIMHD7Jt2zbKli3LiRMn1I4lxAeRwhQpkqIorFq1ii+++IKoqCjOnj1rsfcCLliwgAwZMtCoUSM8PDywsbFh7ty5DBo0SO1oZpMvXz7++OMPfvjhB2rUqMHAgQPlaSgixZH7MEWKc+nSJbp06UJ4eDgzZ86kXLlyakd6qydPnlCoUCE2b96MVqvl2LFj+Pn5cenSJbNPQrIUYWFhdOvWjdOnTzNnzhwqVqyodiQhXiH3YYoULyYmhiFDhlC2bFlq165NaGioRZclwOjRo6lVqxZarRaAtWvX4uvrm2bLEhIed7Z27VpGjx7Nt99+S+fOnXnyxFQPPRPCeKQwRYqwc+dO3N3dOXPmDMePH6dnz56qzX5NqqtXrzJ79mxGjRoFJJxGXrNmDY0aNVI5mWVo0KABZ86cQafT4e7uzubNm9WOJMQ7SWEKi/b48WPatm1Lx44dmTZtGmvXriVHjhxqx0qSfv360aNHjxerCp0+fZrY2Fg8Pd8405Nmubi4MGfOHBYuXEiPHj1o2rQpd+/eVTuWEImSwhQWa/v27RQvXhxHR0dOnTpFnTp11I6UZMHBwRw4cIBevXq9+Nq6devS/OnYt6latSonT57k888/p1ixYqxYsULtSEK8QQpTWJyIiAjat29Pp06dWLBgATNmzEhRK+IYDAZ++uknxowZg5OT04uvP79+KRLn5OTEuHHj2LJlC8OHD6d58+Y8fvxY7VhCvCCFKSzKrl27KF68ONbW1pw8eZJq1aqpHSnZlixZgq2tLU2bNn3xtfPnz/Po0SO++uorFZOlDJ6enoSGhuLi4kKJEiUICgpSO5IQAFj2rAmRZkRGRtKnTx+2bdvGnDlzqFmzptqRPsjTp08ZOHAga9eufeXU67p162jUqJFF3idqiZycnJgxYwZ169aladOmtG7dmmHDhmFnZ6d2NJGGyd9eobo///yTYsWKodfrOXnyZIotS4CxY8dSqVKlN54LKadjP4y3tzfHjx/nzJkzlC1blvPnz6sdSaRhUphCNU+fPqVLly589913zJw5k7lz55IxY0a1Y32wCxcuMHPmTMaOHfvK1y9fvkxYWBjly5dXKVnK5ubmRmBgIB07dqRixYr4+/vzrgVXhDAVKUyhij179lC8eHGioqJS3AzYxCiKQqdOnRg0aNAbt72sW7eOBg0aYG1trVK6lE+j0dChQwf27t3LggUL8PHxITw8XO1YIo2RwhRmpdfrGTp0KE2aNGHKlCksWLAAFxcXtWN9tCVLlvDkyRO6du36xnvPbycRH69gwYLs27cPDw8PSpQowaZNm9SOJNIQWUtWmM2tW7do3rw5tra2LFmyhGzZsqkdySgePHhA0aJF2bx58xuLEly/fh1PT0/CwsIsfmWilCYkJISWLVtSq1Ytfvvtt0SfOSrEh5C1ZIWqNm7ciFarpXbt2uzYsSPVlCVA3759adKkSaIr+Kxbt4769etLWZpAhQoVOHHiBI8fP6Z8+fL8888/akcSqZz8LRYmFRMTQ9++fdm4cSMBAQEWv1h6cu3Zs4edO3dy5syZRN9ft25dmnqMl7llyJCBFStWMH36dMqUKcO8efOoV6+e2rFEKiVHmMJkLly4QNmyZblz5w7Hjh1LdWUZFxdHp06dmDx5MhkyZHjj/du3b3P+/HmqVq2qQrq0Q6PR0K1bNwIDA+nSpQv9+/dHr9erHUukQlKYwiQWL15MhQoV6NixI2vWrCFTpkxqRzK68ePHky9fPho2bJjo++vXr8fHx0dutjeTsmXLEhoaypEjR6hZs6bMohVGJ4UpjCoyMpKWLVsyZswY/vrrLzp16pQqFxu/fPkyv/32G9OnT3/r9yeLFZhflixZ2L59OxUqVECr1RISEqJ2JJGKSGEKozl69CharRYHBwcOHz5MsWLF1I5kEoqi0LlzZ/r160euXLkS3SY8PJyTJ09So0YNM6cT1tbWDB8+nDlz5tCoUSMmTZokCx0Io5DCFEaxYMECatWq9eIXlbOzs9qRTGblypWEh4fTo0ePt24TEBCAt7c3Dg4OZkwmXlanTh0OHTrEihUr8PPz48mTJ2pHEimcFKb4KDqdjq5duzJmzBj27NnDt99+q3Ykk3r48CE9e/Zk1qxZ2NravnW7LVu2yGxNC5ArVy5CQkJwc3PD09OTU6dOqR1JpGBSmOKDhYeHU61aNa5fv86hQ4coUqSI2cY2GAxmG+tl3bp1w8/P743F1V8WGxtLUFCQnI61EPb29vj7+zN48GCqVq3Khg0b1I4kUigpTPFBDh8+TKlSpahcuTKBgYFmWzT9woULhIeHY2VlRXx8vFnGfG7t2rUcPnyYMWPGvHO7kJAQihYtSubMmc2UTCRFixYt2LZtG926dWPs2LFyXVMkmxSmSLaFCxfi7e3NlClTGD58uNme8bh79260Wi3e3t6Eh4djbW1tttIMDw+na9euLFq0CCcnp3duu337dmrXrm2WXCJ5PD09OXDgAKtXr6ZNmzbExsaqHUmkIFKYIsl0Oh3dunVj1KhRBAUF0aBBA7ONbTAYWL58ORMmTMDX15fGjRvz+PFjs5Smoih06NCBNm3aULZs2fduL4Vp2T777DP27NlDZGQk1atX5/79+2pHEimELI0nkiQ8PBw/Pz8yZMjAoUOHzP6EESsrK6ZOnUpkZCSZMmXi7t27+Pr6EhgYaPIZuYsXL+bq1ausXr36vdvevHmTsLCwRNeVFZbD2dmZNWvWMGjQIL766is2bdrEF198oXYsYeHkCFO81/PrlZUqVWLjxo2qPY7LwcGBLFmyYGNjw5gxY8ifPz9+fn4AXLt2jdOnTxt9zJs3b9K7d28WL16Mvb39e7ffsWMHNWvWlGdfpgBWVlaMHDmSoUOHUrlyZbZv3652JGHhpDDFOy1ZsgRvb28mT57Mr7/+arbrle9jb2/PxIkTKViwIF988QVeXl5GnzmrKApt27blxx9/pESJEkn6jJyOTXlatmzJ+vXradOmDdOnT1c7jrBglvHbT1gcRVEYNmwYgwcPZvfu3W9dL1VNzs7OFCtWjLCwMJYsWULx4sWNuv+ZM2cSERHBzz//nKTtdTodf/75JzVr1jRqDmF6FSpUYN++ffz+++906dIFnU6ndiRhgaQwxRvi4uJo27YtmzZtYv/+/RQtWlTtSImKjIxk9erV7Nixg0qVKhl135cvX2bw4MEsXrw4yc+yPHjwIHny5CFr1qxGzSLMI0+ePOzbt4+rV6/i7e3N48eP1Y4kLIwUpnhFREQEdevW5f79+wQFBVn0L//06dOzceNGSpcubdT9xsfH89133/HLL79QuHDhJH9OTsemfBkyZGDjxo0UKVIELy8v7ty5o3YkYUGkMMULt27domLFihQoUICAgIAUsR5sUibiJNekSZOwsbGhe/fuyfrctm3bqFOnjtHzCPOysbFhypQpNG3alAoVKnDp0iW1IwkLIbeVCABOnDiBj48P3bt3p3fv3qnykVxJcfz4ccaNG8ehQ4eSNcEpPDycK1euvHPJPJFyaDQa+vfvj6urK5UqVWLLli14eHioHUuoTApTsHPnTlq0aMH06dNp3Lix2nFUExkZSePGjZkyZQp58uRJ1md37txJtWrV3rkgu0h5vv/+ezJnzkytWrVYvXo1lStXVjuSUJGckk3j5s+fT6tWrVi/fn2aLktFUejUqRNeXl40a9Ys2Z+X65epV8OGDVm1ahWNGzcmICBA7ThCRXKEmUYpisKQIUNYtmwZQUFBFCpUSO1Iqpo/fz4nTpzg0KFDyf5sfHw8O3fuZPTo0SZIJixBlSpV2L59O3Xr1uXBgwe0b99e7UhCBVKYaZBOp6N9+/ZcuHCB/fv34+bmpnYkVZ0+fZqff/6ZoKCg9y6snpjQ0FDc3NzImTOnCdIJS1GyZEmCgoKoVasW9+/fp1+/fmn2Wn9aJYWZxsTExNC4cWMMBgN//fXXBxVEavLs2TOaNGnC+PHjP3gt0e3bt8vs2DSiYMGC7N27l1q1anHv3j3Gjx9vMatfCdOTP+k05NmzZ/j4+ODo6EhAQECaL0tIeCC0VquldevWH7wPuX6ZtmTPnp09e/Zw4MAB2rRpI6sCpSFSmGlEREQEtWrVImfOnCxfvlxmc5KwTu6+ffvw9/f/4FNrDx8+5PTp01SoUMHI6YQly5QpE7t27eL+/fv4+fkRFxendiRhBlKYacD9+/epWrUqJUuWZO7cufIkDeDChQv07NmT1atXky5dug/eT3BwMGXLlsXBwcGI6URK4OTkREBAABqNRkozjZDCTOXCwsKoVKkStWrVYsqUKXK9BYiOjqZx48aMGDHioxdsDw4OpmLFikZKJlIaOzs7Vq1ahZWVlZRmGiC/PVOx69ev4+XlRfPmzRk1apTM6PtPz549KVKkCB06dPjofUlhiuelaW1tja+vr5RmKiaFmUpdvHgRLy8vunXrxoABA9SOYzFWrFjBrl27mD179kf/A+LZs2ecPn3a6Iu/i5THzs6OlStXYmNjg6+vL7GxsWpHEiYghZkKnTp1iipVqjBkyJBkLyCemh09epTu3buzbt06MmTI8NH7O3jwIF9++SWOjo5GSCdSuudHmjY2Nvj5+UlppkJSmKnMkSNHqFGjBhMnTqRt27Zqx7EYd+/epUGDBsycOZMvv/zSKPuU07Hidba2ti9KU440Ux8pzFTk0KFDeHt7M3v2bL799lu141iMuLg4fH19adWqFb6+vkbbb0hIiNxOIt7wvDRtbW1p1KiRlGYqIoWZShw/fpx69eoxb948vv76a7XjWJQePXrg4uLCsGHDjLZPvV7PwYMHKV++vNH2KVKP56Vpb28vpZmKSGGmAmfOnKFOnTrMmDGDevXqqR3HosyaNYvdu3ezdOlSo95Sc+zYMXLlysUnn3xitH2K1MXW1paVK1dKaaYiUpgp3KVLl6hZsyYTJkww6unG1CA4OJjBgwcTGBholEk+LwsJCZHrl+K9Xi7NZs2aER8fr3Yk8RGkMFOwa9euUb16dYYPH07z5s3VjmNRbty4QZMmTVi8eDEFChQw+v6Dg4Pl+qVIEltbW5YvX05ERASdOnVCURS1I4kPJIWZQt26dYtq1arRt29f2rVrp3YcixIVFUWDBg3o2bMntWrVMvr+FUWRI0yRLPb29gQEBHD8+HEGDhyodhzxgeTxXinQv//+S7Vq1fjhhx/o0qWL2nEsiqIofP/99xQpUoRevXqZZIyLFy/i5OTE559/bpL9i9Qpffr0bNu2jQoVKpAlSxZ++ukntSOJZJLCTGHu379P9erVad68Ob1791Y7jsWZMGECFy5cIDg42GRLAcrpWPGhXF1d2blzJxUqVCBz5sy0atVK7UgiGaQwU5BHjx5Rs2ZN6tWrx6BBg9SOY3ECAwOZPHkyBw4cMOnqO3I6VnyMnDlzsmPHDqpUqUKmTJlkZnsKItcwU4jIyEjq1KmDl5eXLKSeiP3799O+fXsCAwNNfqpUVvgRH6tIkSJs3LiRtm3bEhwcrHYckURSmClAXFwc33zzDV9++SW//fablOVrLl68SMOGDVm8eDGenp4mHevOnTs8fvyYwoULm3QckfqVLl2a5cuX4+vry4kTJ9SOI5JACtPCGQwG2rRpQ8aMGfH395eyfE14eDh16tRhxIgR1KlTx+TjPV8OT54rKoyhRo0aTJ8+HW9vb65cuaJ2HPEecg3Twg0YMIBr167xxx9/YG1trXYci/L06VN8fHxo2bKl2W6tkdOxwtj8/Px48OABNWvWJCQkhGzZsqkdSbyFFKYFmzFjBgEBAezbt08eIfUavV5PkyZNKF68OEOGDDHbuMHBwbJIhDC6Tp06ce/ePerWrUtwcDDOzs5qRxKJkPNKFiogIIBRo0axfft2MmfOrHYci6IoCj/88AMGg4Hff//dbKepo6KiuHjxIiVLljTLeCJt+eWXX/jyyy9p0aIFBoNB7TgiEVKYFmjfvn106NCBjRs3kidPHrXjWJwRI0Zw9OhR1qxZg62trdnGPXnyJEWKFMHOzs5sY4q0Q6PRMGvWLB4+fMiAAQPUjiMSIadkLcyFCxdezPjUarVqx7E4CxcuZMGCBezbt4906dKZdexjx47h4eFh1jFF2mJnZ8e6desoU6YMhQsX5rvvvlM7kniJFKYF+ffff6lTpw6jR482y4zPlGbHjh38/PPPBAUFkTVrVrOPL4UpzMHV1ZXNmzfj5eVF3rx58fLyUjuS+I+ckrUQz2d8fvfdd7Rp00btOBbn8OHDtGzZkvXr11OoUCFVMkhhCnMpXLgwy5Yto3Hjxly+fFntOOI/UpgWQKfT4efnh4eHhyx5l4gTJ07g4+PDvHnzKFeunCoZdDodZ86coXjx4qqML9KeGjVqMHToUHx8fHj06JHacQRSmKpTFIUuXbpgZWXFzJkzZWGC15w9e5batWszY8YMVdfcPHfuHLly5TL7dVORtnXq1InatWvTuHFjdDqd2nHSPClMlfn7+7N//35WrVqFjY1cUn7ZpUuXqFmzJuPHj8fX11fVLHI6Vqhl4sSJ2Nra0r17d3n4tMqkMFW0e67vh+IAACAASURBVPdufv31VwIDA+XI5TXXrl2jevXqDB06lBYtWqgdRwpTqMba2pqVK1cSHBzMtGnT1I6TpklhquTatWt8++23LFu2jLx586odx6LcunWLatWq0adPH9q3b692HEAKU6grQ4YMbN68mTFjxrBt2za146RZUpgqePbsGfXr16d///5Uq1ZN7TgW5d9//6VatWp06tSJrl27qh0HSFgA//jx41KYQlW5c+dmzZo1tG7dmn/++UftOGmSFKaZKYpCmzZtKFmyJN27d1c7jkW5f/8+1atXp3nz5vTp00ftOC9cvXqVjBkzyhKFQnXly5fnl19+wdfXl5iYGLXjpDlSmGY2evRobty4ITNiX/Po0SNq1qxJvXr1LO7WGjkdKyxJt27dKFiwIN26dVM7SpojhWlGmzZtwt/fn/Xr1+Pg4KB2HIsRGRlJnTp1qFixIqNGjbK4f0gcPXpUFlwXFkOj0TB37lz27t3L/Pnz1Y6Tpkhhmsm5c+do164da9euJXv27GrHsRhPnjzB29ubL7/8ksmTJ1tcWYIcYQrLky5dOtatW0e/fv04duyY2nHSDClMM3j8+DH169dn7NixlClTRu04FuPhw4dUr14dd3d3iz5FLYUpLFGRIkWYPn06vr6+shKQmUhhmlh8fDxNmzalTp06skbsS8LDw6lcuTKVKlXC398fKyvL/F8xLCwMvV5Pjhw51I4ixBuaNGlCvXr1aN26tTxD0wws87dUKjJkyBBiY2OZMGGC2lEsxs2bN6lYsSK+vr6MGzfOYo8s4f9Hl+bKqNfrX7xkVReRFOPGjePBgweMHTtW7SipnqzFZkK7du1i4cKFHD161KwPOrZkly9fpkaNGnTt2pVevXqpHee9zHU6Nj4+nuPHj7Njxw5u376NoihkzZoVHx8fmXAk3snOzo7Vq1dTqlQpSpcuLfd2m5AcYZpIWFgYrVu3ZsmSJbi5uakdxyKcPXuWypUr069fvxRRlmC+whw9ejQdO3bE1taWSpUqUblyZdKnT0/79u0ZMmSIHG2Kd/rss89YunQpLVq04NatW2rHSbU07/qL6OnpqRw5csSMcVKH+Ph4atSogZeXF0OHDlU7jkU4evQo3t7ejB8/npYtW6odJ8kKFSpEQEAAX3zxhUnHyZ07N9euXUv0vfz583Pu3Dk5SyHea8yYMQQGBrJnzx75/+UjaDSaUEVRPF//uhxhmsDIkSNRFMXibsBXy759+6hduzb+/v4pqix1Oh3Xr18nX758Jh8rc+bMHD58mOjoaOLi4tDpdOj1eq5evYqNjY3FTooSlqVv37588skn8g91E5FrmEa2e/duZs6cSWhoKNbW1mrHUd2ff/7Jt99+y5IlS6hdu7bacZLl2rVrZM+eHXt7e5OPNX36dFq3bk2OHDnIkSMHGo2G27dvc/nyZaZNmyb/L4kksbKyYv78+ZQoUYJatWrh5eWldqRURQrTiO7evUuLFi1YtGiRLE5AwspGbdu2Ze3atVSqVEntOMl26dIlChYsaJaxypYty9mzZzl9+jS3bt16MelH7v8UyfXpp58yd+5cWrVqxfHjx3FxcVE7UqohhWkkBoOBVq1a0apVK2rWrKl2HNXNnj2bwYMHs3nzZr766iu143yQixcvUqBAAbOO6e7ujru7u1nHFKlP3bp12bp1K126dGHZsmVqx0k15MKIkYwbN46nT58yfPhwtaOoSlEUBg4cyLhx4wgODk6xZQnmPcIUwtjGjx/P0aNHpTCNSI4wjWDv3r389ttvHDlyBBubtPsjjY2NpW3btvzzzz/s37+fLFmyqB3po1y8eJF69eqpHUOID+Lk5MTy5cupVasW5cuXJ3fu3GpHSvHkCPMjPXjwgGbNmjFv3jw+//xzteOo5tGjR9SqVYuYmBj++uuvFF+WkFCYcoQpUjIPDw/69OlDq1atiI+PVztOiieF+REURaFt27b4+fnh4+OjdhzVXLt2jfLly1OyZElWr16No6Oj2pE+WnR0NHfv3iVXrlxqRxHio/Tq1QtbW1tZOs8IpDA/wqJFi7h+/TqjRo1SO4pqjhw5Qvny5enUqROTJk1KNbc/XLlyhdy5c6ea70ekXVZWVixatIgpU6Zw+PBhteOkaFKYH+jGjRv06dOHxYsXY2dnp3YcVWzevJk6deowY8YMunfvrnYco5LTsSI1yZEjB9OnT6d58+Y8ffpU7TgplhTmBzAYDLRp04aePXtSvHhxteOoYubMmXz//fds3ryZb775Ru04Rnfp0iWz31IihCn5+flRvnx5fvrpJ7WjpFhSmB9g5syZREVF0adPH6Pt89q1a+zYsYP79++j0+mMtl9jMxgM9OvXj8mTJxMSEpKibxt5FznCFKnR1KlT+euvv9i8ebPaUVIkKcxkunTpEkOGDGHRokVGu4Vk3759VKxYkXnz5tG8eXMmTZrElStXjLJvY4qIiKBBgwbs37+fffv2mWWNVbXIEaZIjdKnT8/cuXPp3LkzT548UTtOiiOFmQzx8fG0bt2awYMHG/XoY8uWLYwaNYrVq1fTs2dPYmJimDp1Kjdu3DDaGB/r/PnzfPXVV+TIkYM//viDzJkzqx3JpOQIU1iSuLg44uLijLKvKlWqULt2bfr162eU/aUlUpjJMHHiRBwcHOjatatR9/vw4cMXs9dq1aqFj48PGTNmZNmyZUb7S/IxNm7ciJeXF3379mXGjBmpfpLTkydPePr0qawHLFQXExPDtm3bqFevHs2aNWPt2rVG2e+4cePYtGkTQUFBRtlfWiGFmUSnTp1i/PjxLFiwwOiPWhowYAC3bt1i1apVAGi1WsqUKcOxY8dULUyDwcCwYcPo0qXLi4XU04JLly6RP39+NBqN2lFEGvbw4UPmzJnDzJkzadmyJb169WLQoEFcuHDho/ft4uKCv78/7du3Jzo62ghp0wYpzCSIi4ujdevWjB071iQ3smfPnh0/Pz927drFhg0bAPD29ubJkyeo9QDvJ0+e0KBBA3bt2sXhw4dT7eSexMjpWKG22NhYli9fzqlTp/j5559p0aIFZcuWJWvWrDx+/NgoY3z99ddotVp5dmYypN2FT5Nh5MiRZM+enTZt2phk/9bW1jRo0ACdTsfcuXO5cOECRYoU4cqVK2TLls0kY77L+fPn+eabb6hatSpr1qxJ9adgX6fGU0qEeFlISAhbtmxh4MCBlCtXjvj4eNavX0+uXLnQarVGG2fq1KkUK1YMPz8/PD09jbbf1EqOMN/j8OHD/P7778yZM8ekp+gcHBxo3rw5v/76KydOnCAgIAB/f38KFSpksjET8/x6ZZ8+ffD3909zZQnylBKhrvj4eObMmYOvry8VKlRAr9cTHBzMwYMHKVmypFEvCbm5uTFhwgTatWtn0bezWQopzHfQ6XS0bduWyZMnm+VIz9raGg8PD5YuXcrcuXOpUaOGycd87uXrlRs3bqRdu3ZmG9vSXLlyJVXfMiMsm0ajwcHB4cWyjCtXrmTLli04OjrStm1bo8+haNGiBdmzZ2fcuHFG3W9qJKdk32HSpEl8/vnnfPvtt2Yd19h/Id7n0aNHfPfddzx48IDDhw+TNWtWs45vaW7fvk2OHDnUjiHSKCsrK3r06EGLFi1YtGgROXLkoEKFCjRr1ox06dIZfTyNRsPvv/+OVqulYcOGFClSxOhjpBYaRVHe+qanp6ei1qQTtV29epVSpUpx+PBh8uTJo3Yck9m7dy/Nmzenfv36jB8/Pk2egn2ZwWDAwcGByMhI7O3t1Y4j0rC7d+/y77//UqxYMQCTz9qeMWMGy5YtIzg4OM0/dECj0YQqivLGRV05JZsIRVHo0qULvXv3TrVlGR8fz6hRo2jYsCFTp05lypQpab4sAe7fv0+GDBmkLIXq3NzcKF68OBqNxiy3OP3www9YWVnh7+9v8rFSKjklm4i1a9dy8+ZNevXqpXYUkwgLC6NFixbo9XpCQ0Pl9ONL7ty5w2effaZ2DCHMzsrKinnz5lG+fHkaNWokC3ckQo4wXxMREUGPHj2YNWsWtra2ascxum3btlGyZEm8vLz466+/pCxfc+fOHflFIdKsQoUK0aFDB/r27at2FIskR5ivGThwID4+PpQrV07tKEYVFxfHwIEDWblyJStXrqRSpUpqR7JIUpgirRswYABFihQhODiYihUrqh3HokhhvuTQoUOsW7eOs2fPqh3FqK5cuULTpk359NNPOXbsGK6urmpHslhSmCKtS5cuHRMmTKBr166EhoYa7alMqYGckv2PXq+nQ4cOTJgwgUyZMqkdx2hWrFhBmTJlaNGiBRs3bpSyfA8pTCGgcePGfPLJJ8yaNUvtKBZF/unwnylTppAlSxaaNWumdhSjePr0KT/++CPBwcHs2LGDkiVLqh0pRbhz5w516tRRO4YQqtJoNEybNo2qVavSuHFjsmTJonYkiyBHmMD169cZPXo0M2fOTBVPqNi9ezfFixfHYDAQGhoqZZkMcoQpRAJ3d3eaNWvGwIED1Y5iMdL8EaaiKHTr1o0ePXqQP39+teN8lGfPntG/f3/WrVvHrFmz8PHxUTtSiiOFKcT/DR06lCJFinD48GFKlSqldhzVpfkjzK1bt3Lx4kX69OmjdpSPEhwczJdffsmjR484deqUlOUH0Ov13Lt3j08//VTtKEJYBBcXF0aPHk3Xrl0xGAxqx1Fdmi5MnU5Hr169mDRpUopd2SUqKoqffvqJJk2aMHHiRJYsWcInn3yidqwUKTw8HFdXV5kVKMRLWrVqhZWVFQsXLlQ7iurSdGHOnDmTXLlypdhJHvv27aNEiRLcvXuXU6dOUb9+fbUjpWiyyo8Qb7KysmL69OkMGDDAaA+vTqnSbGE+fPiQESNGMGnSpBQ30Sc6OprevXvTqFEjxowZw7Jly8icObPasVI8uX4pROK0Wi3169dnyJAhakdRVZotzGHDhuHr60vRokXVjpIsBw4cwMPDg5s3b3Ly5EkaNmyodqRUQwpTiLcbOXIkK1asSHULuyRHmrxYc/78eZYvX56i/uCfPXvGsGHDWLx4MdOmTcPPz0/tSKmOFKYQb+fq6kq/fv3o378/gYGBasdRRZo8wuzduzc///xzirkZd+PGjRQtWpRbt25x8uRJKUsTkcIU4t26dOnC8ePHCQkJUTuKKtLcEebOnTu5cOEC69evVzvKe12/fp3u3btz/vx55s2bR7Vq1dSOlKpJYQrxbg4ODvz666/069ePkJCQFDf/42OlqSNMvV5Pz549GT9+vEU/LDkuLo6xY8ei1WopVaoUJ0+elLI0g7CwMLJmzap2DCEsWvPmzYmMjGTjxo1qRzG7VFuYERER3L59+5WvzZkzBzc3N4u+/SIoKAgPDw+CgoI4dOgQv/zyS4q9RzSlefz4capaeF8IU7C2tmbs2LH8/PPP6PV6teOYVaotzLlz55IzZ07atWvHnTt3ePz4McOGDbPY20ju3r1L69atadGiBcOHD2fLli3kzZtX7VhpypMnT8iYMaPaMYSweLVr1yZr1qxpbjGDVFuYsbGxKIrCkiVLyJ8/P1WqVKFatWqUKFFC7WivMBgMzJo1C3d3d1xdXTl79iyNGjWyyFJPzRRF4cmTJ6RPn17tKEJYPI1Gw9ixYxk6dChRUVFqxzGbVFuYer0eRVHQ6XRER0dz/PhxAgIC6Nevn8WsVnHs2DHKlSvHokWL+OOPP5g4caL8wlbJs2fPsLe3x9bWVu0oQqQIpUuXpmzZskyZMkXtKGaTqgvzddHR0UydOpUcOXKwatUqFVIluHPnDu3ataN27dp8//33hISEULx4cdXyiITTsRkyZFA7hhApyqhRo5g4cSIPHjxQO4pZpNrCjIuLS/Trer0eW1tbVdYMfb74QLFixcicOTMXLlygXbt2WFml2j+GFCMiIkKuXwqRTAUKFKBx48aMGjVK7ShmkWp/U+t0uje+5uTkRJkyZTh//jwVKlQwW5b4+HgWLFhAoUKFOHfuHEeOHGHcuHG4uLiYLYN4N5nwI8SHGTx4MAsXLuT69etqRzG5NFOYjo6ODBo0iKCgILM+7/DPP/9Eq9Uyd+5c1q5dy8qVK8mTJ4/ZxhdJExERIadkhfgAWbNmpWvXrgwaNEjtKCaXYlb6URSFa9eucevWLaKjo9FoNDg6OpInTx6yZ8/+xqzS56dkbW1tcXV1JTAw0KxPDD937hx9+vTh3LlzjB07Vma+Wjg5JSvEh+vduzf58+fnzJkzKe6BFslh0YV57NgxVq9ezpEjQRw9ehZHR4XcuW1xdARFgagouHQpFhsbe7TaYpQqVYVmzVpSoEABrl69CoCPjw8LFy4029HD3bt3GTp0KGvWrKF///6sW7dOFh5IAWTSjxAfLn369PTs2ZPhw4erOqHS1CyuMGNiYlizZg3+/mO5ffsqrVrF0KOHAa0WElu1TFHg5s0YQkNDCA4+SPny4/Hw8CBjxhwMGDCAkSNHmiV3dHQ0U6ZMYcKECbRo0YLz58/LMypTEDnCFOLjdOnShXz58nH69Gnc3d3VjmMSFnUNc9euXRQunJMlSzrz889n+OefKEaMMFC3buJlCaDRQM6c0KABTJqk48aNGFq23M+NG9vYtGklR48eNWnmmJgYpk2bRv78+Tl8+DD79+9n8uTJUpYpjBxhCvFx0qVLR+/evRk2bJjaUUzGIo4wnzx5Qp8+3di2bS1z5kRRq9aH78vBAVq0gObNn7Js2VNq165Ax47dGDToV6MuuB4bG8v8+fMZNWoUJUqUYOPGjWi1WqPtX5hXREQEn3/+udoxhEjROnfuzMSJEzl58uQr95YbDAYuXrxIaGgoYWFhxMTEYGVlhaOjI/nz50er1aaIJwWpXpiXL1+mVq2KVK36mFOnYjDWWTGNJqE4q1WLplOn6ZQvv4mtW4M++hmYOp2OhQsXMmLECIoWLcq6desoXbq0cUIL1chtJUJ8PGdnZ/r06cPw4cOZO3cuixYuZN3ChRw/fx5XGxu0Gg05Y2JwiI9H0WgIt7Fhu4MDoXFx2Nrb85VWS6suXfj666+xsVG9nt6kKMpbX1qtVjGls2fPKtmzZ1JmzbJ6V4yPfhkMKAMH2iqFC+dU7ty580FZdTqdMn/+fCVPnjxKjRo1lH379n3oty0sUKNGjZTVq1erHUOIFO/gwYOKi4ODktHeXmnq5KRsA+VBwnSTt74MoFwDZREoFdKnVz7LlEkZNmiQcvfuXVW+B+CIkkiZqHYN89q1a9SsWYHRox/ToYPBpGNpNDBihI5mze5Qs2Z5Hj58mOTPxsfHs2TJEooUKcLixYtZtGgRO3fupGzZsiZMLMxNJv0I8XFiYmLo36sXX1euTG+djguxsSyPiqI28Ml7PqsBcgGtgODISLY+esStceNwz5ePlStWkNBh6lOlMHU6Hb6+dejZ8zGtWpnvB/HLL3qqVr1N27bfvvcPID4+nhUrVlC0aFFmz57N7Nmz+fvvv6lYsaKZ0gpzkkk/Qny4Q4cOoS1cmIu//86J6GgGxsfzMcvDFAdmx8ayKTKS4e3b4+vtTXh4uLHifjBVCnPcuFFkznyTHj1Me2T5Oo0Gxo2L4/LlfaxYsTzRbfR6PcuWLaN48eJMnTqVadOmsWfPHqpUqWLWrMK85AhTiA+zetUqfCpXZtD166yNivqoonxdaeBoVBT5//qL0u7uXLhwwYh7/wCJnad9/jLFNcxTp04prq6OyvXrprtm+b7X4cMobm7plbCwsBe5oqOjFX9/fyVPnjyKl5eXsm3bNsVgMBj9+xeWKVu2bMqtW7fUjiFEirJk0SIlu6OjcuI91yiN8Zqv0SjZXFyUs2fPmvz7wlKuYfbo0Z5ff40hZ05zj/x/np7Qpk0Mgwb1JiIigjFjxpAnTx62bt3K0qVLCQoKonbt2rKUXRoip2SFSJ5NmzbRu1MndkVHY46HE7ZRFMZGRFCrYkVu3LhhhhHfpFHecS3P09NTOXLkiNEGO3fuHFWqaLlxIxoj3hL5Qe7ehfz5bbGxSYe3tzf9+vWjWLFi6oYSqrGzsyMyMlKWMRQiCcLCwviyYEE2Pn1KGTOPPdramp0lS/LngQMmezSiRqMJVRTF8/Wvm/UI8/ffp9C+vU71sgRwcwNvb2u6dPmBpUuXSlmmcfHx8VhbW6sdQwiLpygKHVu2pGNsrNnLEqBvfDwxZ88yc/p0s49ttsKMiopi6dIldOigN9eQ79W1awyrVy+0mCnLQh2KomAwGKQwhUiCpUuWcO3AAQYl8sxhc7AGFjx7xpD+/fnnn3/MOrbZCvPw4cMULGiT7GuXy5cnXHNMlw6yZYM6dSAkBIYOBVtbSJ8+4VWwIHTtCmFhSd93+fLw+PFDbt68mbxQIlUxGAxoNBq5Zi3Ee+j1egb89BNznj1DzROFhYEfY2MZ1q+fWcc1W2GGhoai1cYm6zOTJkGPHjBgAISHw40b0LkzBAYmvN+kCURGwsOHEBAA//4LWm3SS1OjAU9PO0JDQ5P53YjURE7HCpE0mzZtIpdOx1dqBwF+iI8ncNMmHjx4YLYxzViYQXh6Jr0wIyJg8GCYMQMaNgRn54Qjynr1YPz4V7e1tYWiRWHVKsiSBSZOTHourfYpoaEHk/4BkepIYQqRNP5jx9I5MlLtGAC4Al9bWbFg3jyzjWm2wjx+/CgeHknffv9+iIlJeGxXUllbQ/36EByc9M94eBg4fnxv0j8gUh0pTCHe7+rVq5w8eZJGagd5yQ/R0cyePNls45mtMB8/foqra9K3f/AAXF0huQvWZ8+ecIo2qVxd4fHjR8kbRKQqUphCvF9ISAiVra15341XywFPIB2QDagDhABDAVsg/X+vgkBX4OUraLtJKKV0L73qvWOsMsDdBw+4d+9eMr+bD2O2woyNTd7tJJkzw/37oE/mpNrbt+GT9630+xJ7e4iNjUveICJVkcIU4v1C9+9H+/TpO7eZBPQABgDhwA2gM/DftBOaAJHAQyAA+BfQ8mppZgeevvTa9I7xNEBJBwezzUMxW2Ha2lqTnFnIZcsmlNmGDUn/jMEAmzZBctZHj4sDOzvbpH9ApDpSmEK8X2hICG/cyf+SCGAwMANoCDiTcERZD3ht2gm2QFFgFZAFSMa0kzd4RkVx5NChj9hD0pmtMNOndyIiIunbZ8wIw4dDly4JpRkVBTodbNsGffu+uq1eD+fOQdOmCTNle/ZM+jgREZAuXfqkf0CkOlKYQrzfmStXeNfyLvuBGCAZ006wBuoDyZh28obiej1nUlthuru7c+JE8j7Tq1fCrSUjRiTMfv38c5g+Hb75JuH9VasS7s/MmBG+/jrhNG5oaMJ1zKQ6cUKDu3vp5AUTqYper7fMp7sLYUGexsbyrtWWH5AwczW5f5Oyk3CK9rk7gMtLr9Xv+XwG4JmZZu6a7beEp2dlQkOD+Pbb5K0O0bx5wut15colLF7wsUJD0+HrKw+DTsvkCFOId1MUBV18PO+6eJUZuA/oSV6x3ObVB0xnB24l4/O2QFyceeahmO0IU6v1JDTUyVzDJVloqAGtVqt2DKEiKUwh3k2j0WBvY8O77qQvC9gDyZh2goGEST3JmHbyhhjAwcHhI/aQdGYrzNKlS3PsWGyybvkwtTNnIC7Olvz586sdRahIClOI9/vE2Zl33byRERgOdCGhNKMAHbANeG3aCXrgHNCUhJmyyZh28oZ7QKYsWT5iD0lntsLMlCkT9erVZcECsz+C861mzrTn++9/MNkjYkTKIIUpxPuVcHfn6Hu26UXCrSUjSJj9+jkwHfhv2gmrSLi3MiPwNQmncUNJOA37oY46OOBRocJH7CHpzDrT4YcfetGy5XZ++ukZandUZCQsX66hTZtYRo8ejYODA/Hx8a+89Ho9er2eTz75hF69eqkbWJiMFKYQ7+dZqRKh+/fzjcHwzu2a//d6XTkSFi94l8ok7/olQKidHS3NdFnNrIVZpkwZ0qfPRmDg5WQteWcKc+daUbmyF2vXruXGjRtYW1uj0WhQFOXF456ey58/vxRmKiaFKcT7aUuX5vd06eDJE7WjvBAHnImKokSJEmYZz6zHeRqNhokTZ9G9uxOPH5tz5FddvQojR9ozatQUDh8+jIuLy4sjyvj4+FfKMl26dIwcOVK9sMLkpDCFeD8vLy8OxMVxX+0gL9kIeLq74+zsbJbxzH5itGrVqtSr14SePc0zq+l1BgO0a+dMv36DKFy4MG5ubmzevBlHR8dEt8+UKRO+vr5mTinMSQpTiPdzcXHhq9Klmaf29bSX+KdPT2czPhNTle987Ngp/P13hmQte2csU6daERWVh549/z9vq3z58gwbNgwnpzdveylVqhRRUVHmjCjMzNbWFp1KT48XwtLp9XpWrlyJh4cHl2/fZqadHfFqhyJhlu1ZjYaGDRuabUxVCjN9+vSsWrWJDh2c2bPHfOOuWgXjx2dk2bINbxxR9O7dm8qVK2Nv//+1+F1dXbGxsaFAgQLMmDHDbDfHCvNydHQkJiZG7RhCWJSYmBhmzZpF4cKFmT59OiNHjuTSpUt8mjcvy9UOB4xydKRD587YJeepHh/r+SSXxF5arVYxpT/++EPJksVJ2bXrnTGM8lq8WKN8+mkG5eTJk2/NExERoXz22WcKoDg7OyuzZs1SFEVRQkNDlZo1ayp58+ZVli9frsTHxxv7RyFUdP36dSVHjhxqxxDCIkRGRipjx45VsmXLptStW1cJDg5+5f3Dhw8rbo6OShgoikqvTaDkzZpViYyMNMnPADiiJFIkqhamoihKUFCQkiVLOmXCBGtFrzd+UUZHo/Tta6fkyJFZOXPmzHvznDx5UnFwcFAyZ86sxMbGvvLen3/+qZQqVUrx8PBQtm/frhgMBmP8CITK7t69q7i6uqodQwhVPX36VBk3bpzi5uamNGnSRDlx4sRbtx3Qu7dS38lJMahQlg9B+czJJPq6gAAAIABJREFUSfn7779N9rOw2MJUFEW5fPmy4uWlVcqVc1bOnzdeWR44gFKkiLPSqFEdJTw8PMl5AgIClICAgETfMxgMytq1a5WCBQsqVapUUQ4ePPhh37SwGE+ePFGcnZ3VjiGEKp49e6ZMnDhRyZo1q+Ln56ecPn36vZ+JiYlRiubOrfhbWZm1LPWgNHR0VLq0b2/Sn4lFF6aiKEp8fLwydepvSubMTsqPP9p9VHEeOYLy3XcOyqefZlBWrlxpkiNBnU6nzJ49W/nss8+URo0aKefOnTP6GMI8dDqdYm1trXYMIcwqOjpamTx5spItWzalQYMG7zyiTMylS5eU7JkyKcvNVJbxoLS3t1eqlimjREdHm+inksDiC/O5GzduKAMG9FHc3NIr1aqlU5YuRbl8GcVgeHtUvR7l7FmU2bNRSpdOr2TLlkHJlSuHcu/ePZPnffbsmTJmzBjF1dVVad++vRIWFmbyMYXxWVtbK3FxcWrHEMLkYmJilOnTpyufffaZ8vXXXytHjx794H2dPHlSyebioszVaExaljpQWjo4KBU8PJQnT54Y8aeRuLcVpuXcUPOfzz//nJEjx3Hjxj3atZvNmjVVqVw5E5kz21O9eka+/96Jbt3s6drVnnbtnKhYMQMuLrb4+Ljx5591GTRoOdeu3cPJKT1HjhwxeV4nJyf69evHxYsXcXFxwd3dnYkTJ8qM2hTGwcFBZsqKVC0uLo7ff/+d/Pnzs3XrVjZs2EBgYCAeHh4fvM9ixYqx++BBRrq50d7BgQgj5n3uHFDB2ZlHZcuyIySE9OnTm2CUpNEklGniPD09FXOUTlKEh4cTGhrKrVu3iI6OxsrKCgcHB/LmzUvJkiXJlCnTK9uvXLmS3377jQMHDqDRaMyW88KFC/z4449cv36dKVOmULNmTbONLT5clixZOHPmDG5ubmpHEcKodDodCxcuZOTIkRQuXJhhw4bx1VdfGXWMyMhI+nTrxtY1a5gTFUUtI+xTD0yytma8vT3Dx42j4w/me1CGRqMJVRTF8403EjvsfP5S45Sssej1euWLL75Qtm7davaxDQaDsnHjRiVv3rzKN998o1y5csXsGUTy5MiRQ7l+/braMYQwGoPBoKxatUrJmzevUr16dWXv3r0mH3PXrl1Kbjc3pXK6dMoaUOI+4PTrA1AmajRKfmdnpepXXylXr141ee7XkVJOyRqLtbU1Q4YMYciQIQkXa81Io9FQr149zpw5Q6lSpShdujSDBw+WFYMsmCxeIFKTffv2Ua5cOcaMGcOcOXPYtWsX5cqVM/m45cuXJ/cXX+Dx/fdM8/Agt6MjvW1sWAP8AyT2m1gHHAfmAa0dHcnn4MCxBg1YvGsXf+zfT+7cuU2eO6lSbWEC+Pr6Eh0dzdatW1UZ38HBgQEDBnDs2DEuXbpE4cKFWb16tdkLXLyfg4MD0dHRascQ4qNcuXKFxo0b06RJEzp16sSRI0eoWrWqWcY+ffo0BQsWZPfu3RQoUICgo0fZcegQGX/5hWVVquCVKROZ7f/X3p3H1Zz9fwB/3RaVtCB7Y99L+2JLUUhKlki2KCRrKrKMrYlC2UZjtAyRosVuUEOGQZJI0siWZQjJkvbl8/tjRr+vPXXvPXd5P+fhj7nd+zkv66vzWc5RgJ6qKnqqqcFETQ3aqqpQl5fHOE1N/DlyJIzXrUP2w4fYHR+PXr16CfVyWk0IdXsvYZORkcGKFSuwfPlyDBkyhNlG0T/88AOio6Nx9uxZzJkzB9u2bcOWLVvQo0cPJnnIp2iGScTZq1ev4Ofnh507d2L+/PnYuXPnZ9fGFgSO4xAcHAwfHx8UFRWhXr16aNy4MQBAW1sb2tra1e/Nzc1Fbm4uiouLISsrW30fSoMGDYSSta4keoYJACNHjgSPx0NsbCzrKOjXrx+uXLmC0aNHw9LSEnPnzsVrlvuckWo0wyTiqKysDJs3b0aXLl3w7t07ZGZm4scffxRaWebn52PIkCFYtGhR9SUnBQUFyMl9fi7WvHlz6OnpoVevXjAxMYGOjo7YlCUgBYUpIyODtWvXYunSpSLxqIecnBxmzpyJmzdvorS0FNra2jhw4ADrWFKPHish4oTjOOzfvx9aWlo4efIkTp8+je3bt6N58+ZCy3D27Fl07twZSUlJKCwsrH6dx+N9sTDFncQXJgBYWlqiY8eOCAkJYR2lmoaGBrZv347o6GgsWrQIDg4OyM3NZR1LaikpKdEMk4iFlJQU9OvXDytXrsQvv/yC33///YPTnsLg7+8Pa2trvHz58rMTEUndX1YqChMAAgIC4Ofnh4KCAtZRPmBmZob09HR06dIFOjo6CA8Pp5uCGKAZJhF1z58/x+TJkzFixAhMmTIFV69excCBA5lkef9v1Oe21qIZpgTQ09PDwIEDERgYyDrKJxQVFbF69WokJiZi27ZtsLKywt27d1nHkio0wySiqqqqCr/++iu0tbWhoaGBv//+Gy4uLkxncUuWLMH9+/cxZcqUz5YmFaYE+Omnn7B161aRPfWpq6uL5ORkDBkyBKampggMDERFRQXrWFKBZphEFKWlpaFXr16IjIzEqVOnEBgYyHRpuP/VrFkzbNmyBS1btsSAAQOgqKgIWVlZVFVVUWFKgrZt28LZ2Rm+vr6so3yRnJwcvL29cenSJRw/fhw9e/bEtWvXWMeSeDTDJKLkzZs3mDt3LmxsbDBjxgycPXtWJB9DCw4ORrdu3XDq1ClkZGRg2LBhePfuHZSUlFhHEwipKkzg31MJMTExyM7OZh3lqzp06IA//vgDM2fOxKBBg7BkyRKaAQmQmpoa3rwRxNLRhNQcx3GIjo5G9+7dUVJSgszMTEyZMoXZM+Rfk5eXhzVr1iAoKAgA0LFjR+zfvx+PHz+GsbEx43SCIXq/CwKmoaEBLy8vLF26lHWUb+LxeHBxcUF6ejqys7Ohq6uLS5cusY4lkTQ0NJCXl8c6BpFit27dwsCBA7F27VrExcUhJCSkegEAUbRixQo4OTmhW7duH7zesmVLkVuhh1+krjABYN68ebh48aLYlE+LFi0QFxcHPz8/DBs2DL6+vnRtk8+oMAkrxcXFWLZsGfr06QNbW1ukpqaiV69erGN9VWZmJmJjY7FixQrWUYRKKguzfv36WLlyJXx8fMTqEY7Ro0cjLS0N586dQ79+/ehOWj6iwiQsJCQkQEtLC9nZ2UhPT4eHh4fI3zDDcRw8PT3x448/ivQMWBCksjABYPLkyXj27BmOHz/OOsp3adWqFU6ePInRo0ejZ8+e2LFjh1iVvqhq3LgxFSYRmrdv32L69OmYNm0atm3bhn379qFVq1asY9XI8ePH8eDBA7i7u7OOInRSW5hycnJYu3YtvL29UV5ezjrOd5GRkcH8+fNx+vRpbNy4EaNHj8bLly9ZxxJrNMMkwpKYmFh9x2tGRgYGD+bHdsvCUV5eDk9PTwQFBUFeXp51HKGT2sIEADs7O/zwww/YunUr6yi10qNHD6SkpKB169bQ1dVFYmIi60hiq3Hjxnj58iXN1onAFBQUYMaMGXB1dUVISAhCQkKgqqrKOtZ32bZtG9q0aQMbGxvWUZiQ6sLk8XjYsmULVq9eLbKLGXyLoqIiNmzYgJ07d8LFxQXz58+nx09qQUlJCfLy8nj37h3rKEQCnTp1Cjo6OqioqBC7WeV7+fn58PPzw4YNGyT2LthvkerCBIAuXbrA1dUVPj4+rKPUiZWVFdLT06ufgbp+/TrrSGKHTssSfnv37h1mzpyJyZMn45dffkFYWBjU1NRYx6qVVatWYfTo0dDS0mIdhRmpL0wA+PHHH3Hq1ClcuHCBdZQ6adSoEWJiYuDt7Q1LS0ts2bKFTjF+BypMwk9JSUnQ0dFBSUkJMjIyMGTIENaRai0zMxNRUVFYtWoV6yhMUWECUFFRwbp16zB79mxUVlayjlMnPB4Pzs7OuHTpEnbu3ImxY8eK3A4toooKk/DDu3fvMHv2bEycOBFbt27Fb7/9BnV1ddaxaq2qqgpubm7w9fWFhoYG6zhMUWH+x8nJCQ0aNEBoaCjrKHzRvn17XLhwAWpqajA2NkZmZibrSCKPCpPUVXJyMnR1dfHu3TtkZGRIxM0x4eHhqKiogJubG+sozFFh/ofH42Hr1q1Yvny5xDyioaioiJCQECxevBgWFhaIiopiHUmkUWGS2qqqqsLatWthb2+PwMBA7Ny5Ew0bNmQdq86ePXuGpUuXIiQkRCTXsxU2+hX4Hzo6OnB0dBSLdWa/h7OzM06dOoUVK1Zg1qxZKC0tZR1JJFFhktrIzc2FtbU1jh49isuXL2PEiBGsI/GNp6cnpkyZAh0dHdZRRAIV5kd8fX1x8OBBpKWlsY7CVzo6OkhNTcXTp0/Rr18/PHjwgHUkkUOFSb7XyZMnYWBggF69eiEpKQmtW7dmHYlvEhIScOHCBSxfvpx1FJFBhfmRhg0bYvXq1Zg9ezaqqqpYx+ErNTU1xMfHY8yYMTA1NcWJEydYRxIpVJikpsrKyrBw4UJMnTq1+u5RUV8D9nsUFxdj5syZCA4OhrKyMus4IoMK8zOmTJmCiooK7N69m3UUvuPxePDy8kJsbCymTp2KFStWiP2dwfxChUlq4t69ezAzM0NWVhauXr0KCwsL1pH4bvXq1TAwMJCIm5b4iQrzM2RkZBAcHIxFixYhPz+fWQ5BrjpjZmaG1NRUnD17FjY2NlQUoMIk37Z371707NkT48aNw+HDhyXyMYvMzExs374dmzZtYh1F5FBhfoGxsTEcHBzg5eXFZPzHjx9j5MiROHr0qMDGaN68ORITE6GnpwdTU1PcvHlTYGOJAypM8iWFhYVwdXXF8uXLceLECcybN08il4erqqrCjBkzsHLlSrRs2ZJ1HJFDhfkVa9asQVJSEhISEoQ+dsOGDTFq1CiMGTMGt2/fFtg473dtWblyJSwsLKT6umbjxo2Rn58vcdeuSd1kZmbCyMgIFRUVuHLlCgwMDFhHEpjffvsNZWVlmDFjBusoIokK8ytUVFSwfft2uLm5CX1R7sLCQpw9exajR49Gp06dBD7exIkTceDAAUyZMgU///yzVC6pJy8vDzU1Nbx48YJ1FCIi4uPjYWFhgUWLFiEiIgIqKiqsIwnM8+fPsWTJEmzfvh2ysrKs44gkKsxvGDx4MMzNzYX6bOaLFy/g5uYGeXl5REREAIBQbszp06cPLl68iO3bt2PWrFlit08oP7Rp04YeuSGorKzEkiVL4OnpiRMnTsDZ2VloY7M6wzFv3jxMmjQJenp6TMYXB1SYNbBhwwbExsYKdHH2V69eAQDy8vIwffp0qKqqYufOnQD+/csrrO/42rZtiwsXLiAnJwc2NjbVuaRF27ZtkZOTwzoGYejVq1ewtbXFxYsXkZqaCkNDQ6GMe+vWLeTm5kJGRkbod67HxsYiLS0Nvr6+Qh1X3FBh1kCjRo2wZcsWuLq6CmSvyZKSEowZMwYbNmyAl5cXVFRUPphZCvv0iKqqKg4fPgxtbW306tVLoNdQRQ3NMKXbjRs3YGxsjK5duyIxMRFNmjQRyrhnzpyBoaEhrK2t8fTpU8jKygqtNHNzczF79mxERESgfv36QhlTXFFh1tCoUaPQrVs3+Pn58f3YioqKCAoKwvr163Hp0iXs2rULAJuyfE9OTg4bN27E/PnzYWZmhjNnzjDJIWxt27alwpRSsbGx6N+/P1auXImNGzcKbSGCqqoq7Nu3D4GBgXBycoKjoyNevXollNLkOA7Tpk3D1KlT0bNnT4GOJRE4jvviD0NDQ478vydPnnBNmjThrl69KpDjZ2RkcJ06deIuX74skOPX1h9//ME1bdqUCw0NZR1F4A4ePMgNHTqUdQwiRBUVFdyiRYu4Nm3acFeuXGGSobi4mHv+/DlXXl7OeXh4cJaWlty7d+8EPu5vv/3G6erqcqWlpQIfS5wASOU+04k0w/wOLVq0QEBAAFxdXVFRUcH342tra+PMmTMidyeepaUlzp49i3Xr1sHLy0uiH7ugGaZ0yc/Px9ChQ3Hp0iVcvnyZ2SMjioqKaNKkCeTk5BAQEIDOnTvDwcEBAPDgwQNkZGTwfcwHDx5g4cKF2LVrF+rVq8f340siKszvNGXKFDRq1AgbNmwQyPFbtmyJLl26COTYddGlSxckJyfj8uXLGD9+PMrKylhHEog2bdogJydHKh+rkTYZGRkwNjZG9+7dkZCQILTrld+ioKCA9evXo2vXrtDS0oKZmRnfv0mtqqrClClT4OnpSTuRfAcqzO/E4/EQEhKCdevWITs7m3UcoWrUqBFOnjyJoqIi2NnZCf3ZVGFQV1eHjIyM1N0dLG2OHDmCAQMGwNfXFxs2bBC5hdOVlZXRo0cPPHnyBLt27YKuri5fj79161YUFxdjwYIFfD2upKPCrIV27dph2bJl1Yu0SxMlJSXEx8ejVatWsLKykpjNtv8XPVoi2YKDg+Hm5oZjx45h/PjxrON8VkFBAfbt24fjx4/zfXH3W7duwdfXF7t27RK5bxREHRVmLc2ZMwdKSkrw9/dnHUXo5OTkEB4eDgsLC5iZmeHRo0esI/EVPVoimaqqquDt7Y2ff/4Zf/31F0xMTFhH+iIVFRUcPnyY73euVlRUwNnZGStXrhTKCmKShr69qCUZGRlERETAwMAAAwcOlLpbsnk8HgICAtCkSRP07dsXJ0+eRNeuXVnH4guaYUqe4uJiTJo0Cc+ePcOFCxfQqFEj1pG+SUFBge/HXLduHZSVlTFz5ky+H1sa0AyzDlq1aoVffvkFEyZMQEFBAes4THh5ecHX1xcWFhZISUlhHYcvaIYpWfLy8mBlZQU5OTkkJCSIRVkKQnp6OjZu3IgdO3ZARob+6a8N+lWro1GjRsHc3Bzz5s1jHYUZZ2dnhIaGwtbWFomJiazj1BnNMCXHnTt30Lt3b/Tr1w979uyBoqIi60hMFBYWwsnJCUFBQWjdujXrOGKLCpMPNm/ejHPnziEuLo51FGbs7Oywf/9+TJgwATExMazj1AnNMCXDxYsXYWZmBm9vb/j7+0v1rGrWrFkwNjbGpEmTWEcRa3QNkw8aNGiAyMhIDBs2DD179oSmpibrSEz07dsXiYmJsLGxQV5entheJ6EZpviLj4+Hu7s7IiIiMGTIENZxmIqIiKhemIHUjfR+y8VnpqammDNnDpydnSV6JZxv0dHRwblz57Bx40asX7+edZxaady4McrKyvDmzRvWUch34jgOGzduxLx583Dy5EmpL8ubN2/C29sbMTExaNCgAes4Yo8Kk48WL16M0tJSga0CJC7atWuHM2fOVC/wIG54PB6dlhVDHMfB29sb4eHhuHDhAvT19VlHYqqoqAiOjo7w9/dHjx49WMeRCHRKlo9kZWURGRkJExMTWFlZSfVGrK1atcKZM2fQv39/AMDChQsZJ/o+79eUpWXDxENlZSVmzJiBGzdu4Ny5c2jYsCHrSMzNmzcPOjo6cHV1ZR1FYlBh8lnbtm2xYcMGjBs3DqmpqVK9v1yrVq2QlJSE/v37g+M4+Pj4sI5UYzTDFB/l5eVwdnZGbm4uEhMT6dQjgKioKJw9exapqang8Xis40gMOiUrAOPHj4eenh68vb1ZR2HufWn+9ttvCAgIYB2nxjp06CBVG2eLq5KSEjg4OODt27c4duwYlSWA7OxszJs3DzExMSK385G4o8IUAB6Ph23btiEhIQFRUVGs4zAnjqXZvXt3ZGZmso5BvqKwsBB2dnZQVFTE/v37oaSkxDoScyUlJRgzZgx++uknvi/YTuiUrMCoqakhPj4eVlZW0NXVhZaWFutITLVs2bL6mibHcVi8eDHrSF+lpaWFmzdvso5BvuDNmzcYOnQoOnfujNDQUMjKyrKOJBI8PT3RuXNnuLm5sY4ikWiGKUC6uroIDAzEyJEj8fbtW9ZxmGvZsiWSkpKwc+dOkV+0vnXr1igoKKBtvkRQXl4eBgwYAAMDA4SFhVFZ/icmJgYJCQkIDQ2l65YCQoUpYM7OzrCwsICrqyttSoz/L82IiAisWbOGdZwv4vF4dFpWBD158gTm5uawtrbG5s2bpXr1nv918+ZNzJ49G/v27YOamhrrOBKL/rQJwebNm3H//n1s2rSJdRSR8L40d+3aJdKlqaWlRYUpQnJyctCvXz9MmDABq1evplnUf/Lz82Fvb4/AwEAYGhqyjiPR6BqmECgqKiIuLg6mpqYwMjKCmZkZ60jMtWjRAklJSejXrx9UVVUxe/Zs1pE+QYUpOrKzs2FlZYWFCxeK5J8VVioqKjB27FjY2dnROrFCQDNMIWnbti127twJJycn5Obmso4jElq0aIGEhAQEBAQgOjqadZxPUGGKhrt378LS0hIrVqygsvzIokWLwHGcWK6oJY6oMIVoyJAhcHV1xdixY1FRUcE6jkho164dTpw4AQ8PD5w4cYJ1nA9QYbL38OFDWFpaYunSpbRizUd2796NgwcPYt++fZCTo5OFwkCFKWTLly+HgoICli5dyjqKyNDW1saBAwcwceJEXLx4kXWcapqamiguLsbLly9ZR5FKT548gaWlJTw8PDBjxgzWcURKSkoKvLy8cOjQIandEJsFKkwhk5WVxZ49e7Bv3z4cOHCAdRyR0bt3b0RERGD48OEiM6ujO2XZef78OSwtLeHq6goPDw/WcUTK06dPMWrUKISGhkr9893CRoXJgIaGBmJjY+Hm5oZbt26xjiMybGxssGHDBlhbW4vMfpR0Wlb4Xr58CSsrKzg6OmLRokWs44iU0tJSjBw5EtOnT4e9vT3rOFKHCpMRY2NjBAQEwNbWlk75/Y/x48djwYIFGDRoEJ4/f846DhWmkL1+/RqDBg3CkCFDsGLFCtZxRArHcXB3d0erVq3okg4jVJgMubi4YMSIERg1ahTKyspYxxEZc+fOxdixYzFkyBDmKyRRYQpPQUEBhgwZgr59+yIgIICes/zI1q1bkZqaip07d9KCDYzQrzpj/v7+UFdXh7u7O60E9D9WrVoFExMT2Nvbo6SkhFkOKkzhKCoqgq2tLXR0dLBp0yYqy4+cOnUKq1evxqFDh2hHFoaoMBl7v+l0WloaAgMDWccRGTweD1u3bkXTpk3h5OTE7DGcli1boqysDC9evGAyvjQoKSmBvb092rZti23btlFZfiQjIwNOTk7Yu3cv2rVrxzqOVKPCFAENGjTAkSNHsHnzZhw8eJB1HJEhKyuLXbt2oaCgAF5eXkwy8Hg8mmUKUHl5OUaPHo3GjRsjPDycTjV+5PHjxxg6dCg2b94MCwsL1nGkHv3pFBGampo4ePAgpk2bhqtXr7KOIzIUFBQQFxeHhIQE/PLLL0wyUGEKBsdxmDZtGjiOw+7du+nh+4+8fv0aQ4YMwZw5c+Dk5MQ6DgEVpkgxMjLCtm3bMGzYMDx58oR1HJGhrq6Oo0ePwtfXFwkJCUIfv3v37rQ3pgAsX74cWVlZ2LdvH+Tl5VnHESmlpaUYMWIE+vfvD29vb9ZxyH+oMEWMg4MD3N3dMWzYMBQVFbGOIzI6dOiA2NhYTJgwQejlRTNM/tu+fTuio6Nx5MgRKCsrs44jUqqqqjB58mQ0atQIGzdupGu6IoQKUwQtXrwYWlpamDRpEqqqqljHERlmZmZYv3497OzshHoTTo8ePXD9+nW6i5lPjhw5gpUrV+LEiRNo2rQp6zgix8fHB48ePUJkZCRtji1iqDBFEI/HQ0hICJ49e4Zly5axjiNSnJ2d4ejoiJEjR6K0tFQoYzZv3hwNGjTAnTt3hDKeJEtJSYGLiwsOHjyIjh07so4jcrZs2YKjR4/i8OHDUFJSYh2HfIQKU0QpKCjgwIED2LdvH7Zv3846jkjx8/ND06ZNMX36dKHN+kxNTZGSkiKUsSTVnTt3YG9vjx07dsDU1JR1HJETHx+PdevW4fjx47SguoiiwhRhGhoaOHnyJHx9fREXF8c6jsiQkZHBrl27kJmZiYCAAKGMaWJigkuXLgllLEn0/PlzWFtbY9WqVbC1tWUdR+ScO3cO7u7uOHr0KNq2bcs6DvkCuo9bxHXo0AG///47Bg0aBHV1dVhZWbGOJBKUlZVx+PBhmJqaonPnzhg1apRAxzM1NUV8fLxAx5BUhYWFsLW1hZOTE6ZPn846jsjJysqCg4MDIiMjoaenxzoO+QqaYYoBXV1dxMXFYdy4cXRa8H+0bNkShw4dwowZM5CamirQsQwMDJCRkSG066aSoqKiAo6OjtDS0oKvry/rOCInJycH1tbWWLduHQYNGsQ6DvkGKkwxYWZmhvDwcAwbNgxZWVms44gMAwMDhIaGYvjw4QJ9drVBgwbo2LEjrl+/LrAxJA3HcZg5cyYqKioQEhJCj0d85PHjx7C0tMSCBQvg7OzMOg6pASpMMWJnZ4d169bB2toaDx8+ZB1HZAwfPhxubm5wdHREeXm5wMYxMTGhGf532LBhAy5fvozY2FhamOAjubm5sLS0hLu7O2bPns06DqkhKkwxM2nSJMybNw+DBw9GXl4e6zgiY+nSpVBVVRXohsOmpqZ0408NnTx5EkFBQTh06BBUVFRYxxEpeXl5sLKywoQJE2gVHzFDhSmGPD09MWLECNjY2KCgoIB1HJEgIyOD3bt348CBAwK7o5hmmDWTnZ2NiRMnIiYmBq1bt2YdR6S8evUKAwcOhL29PX788UfWcch3osIUU6tXr4aenh5GjBhBN6L8p1GjRoiNjYW7uztu3brF9+NraWnhn3/+watXr/h+bEnx9u1b2Nvbw8/PD3379mUdR6S8ffsW1tbW6N+/P/z8/OiarhiiwhRTPB4P27Ztg5qaGiZMmIDKykrWkUSCoaEh/P39MXLkSLx7946vx5aVlYWBgYHA78gVV1VVVRg/fjz69+9Pj498pLCwEEOHDoWhoSGCgoKoLMUUFaYYk5WVRVRUFF69eoVp06a7ft09AAAgAElEQVTRurP/cXV1hampqUBWAqLrmF+2fPlyvH37Fps2bWIdRaQUFxdj2LBh6NSpE7Zu3UplKcaoMMWcgoICDh06hLt372Lq1KlUmvh39h0cHIybN28iODiYr8em65ifFxMTg8jISMTFxaFevXqs44iM0tJSjBw5Es2bN0doaChtkC3m6HdPAigrK+P333/HvXv3qDT/o6SkhPj4ePj6+uLixYt8O+77GSbtXPL/rl27hlmzZuHgwYNo0qQJ6zgio7y8HI6Ojqhfvz4iIiJo5xEJQIUpIZSVlXHs2DEqzf/RoUMHhIWFwdHRkW/bgWlqakJGRoaeg/3PixcvMHz4cAQHB9Oybv+jpKQEo0ePRmVlJaKjoyEnR6uQSgIqTAnyvjTv378PV1dXuhEIwLBhwzBhwgQ4OTnx5deDx+PRdcz/lJeXw8HBAePHj8eYMWNYxxEZhYWFsLOzQ7169RAfH0+nqCUIFaaEUVZWxtGjR5GTk4OpU6dSaQLw9fUFx3FYuXIlX45H1zH/5eHhATU1Nfz000+so4iMN2/eYPDgwdDU1ERUVBSVpYShwpRA70vzwYMHNNMEICcnh6ioKISFheHcuXN1Ph7NMIGoqCgkJiYiMjKSbmT5T15eHgYMGAB9fX2Eh4fTaVgJRH/SJZSysjKOHDmChw8fwsXFRepLs1mzZggNDcXEiRPx+vXrOh3LyMgIV69eRUVFBZ/SiZfs7GzMmzcPMTExUFVVZR1HJDx9+hTm5uYYNGgQtmzZQt9ESCj6XZVg72eajx49otIEYGtrCxsbG8yaNatOx1FTU0ObNm2kcueSkpISjBkzBr6+vnSTz38ePHgAMzMzjB8/Hv7+/vScpQSjwpRw9evXry7NKVOmSH1pBgYGIi0tDXv27KnTcSwsLJCUlMSnVOLD09MTnTt3xowZM1hHEQnZ2dno168f5s6diyVLlrCOQwSMClMKvC/Np0+fwtHRUarXnq1fvz6ioqLg4eGBnJycWh9nwIABOH36NP+CiYGYmBgkJCQgNDSUZlEArl+/DgsLC6xYsQJz585lHYcIARWmlHhfmjweT+p3OdHX18fChQsxceLEWs+4LSws8Ndffwl0/01RcvfuXcyePRv79u2Dmpoa6zjMpaSkYODAgdi4cSNcXFxYxyFCQoUpRRQUFLB371506tQJ/fv3x/Pnz1lHYsbLywvy8vIICAio1ecbN26M9u3bS8VC7KWlpXB0dMSyZctgaGjIOg5zp06dgq2tLcLDw+Ho6Mg6DhEiKkwpIysri23btsHGxgZ9+/at02lJcSYjI4OIiAhs2bKl1s9USstp2YULF6J169aYPXs26yjMRUREYNy4cYiJiYGtrS3rOETIqDClEI/Hg6+vL+bMmQMzMzPcuHGDdSQmfvjhB2zduhXjx4+v1VZg0lCYBw4cwOHDhxEeHi7V1y05jsOqVauwcuVKnDlzBhYWFqwjEQZ4X1tE2sjIiJOGU07SLDo6Gh4eHjhw4AB69+7NOg4TU6ZMgZycHEJDQ7/rc2/fvkWrVq3w4sULKCoqCigdOzk5OTAxMcGRI0dgamrKOg4zZWVlcHNzw40bN3DkyBE0b96cdSQiYDwe7wrHcUYfv04zTCnn5OSEiIgIDB8+HL///jvrOExs2bIFp0+fxv79+7/rc6qqqtDW1ubrbiiioqysDI6Ojli0aJFUl+WbN29gY2ODly9f4syZM1SWUo4Kk8Da2hqHDx+Gi4sLIiMjWccROhUVFURGRmLWrFnIy8v7rs9K6mlZX19fNGnSBPPnz2cdhZlHjx6hb9++6Nq1Kw4cOABlZWXWkQhjVJgEANCzZ0+cPn0aS5YswaZNm1jHqbHaXHv8nF69esHJyem7C0ISC/PSpUsICwtDWFiY1F63vHr1Knr16oXJkyfj559/pr0syb84jvviD0NDQ45IlwcPHnBdu3blPD09uYqKCtZxvurRo0fcwIEDuSNHjvDleO/evePatWvHHTt2rMafKSoq4pSVlbmCggK+ZGCtqKiI69KlCxcTE8M6CjO///47p6GhwcXGxrKOQhgBkMp9phNphkk+0Lp1a5w/fx5Xr17F8OHDRXqBg4YNG2LUqFEYM2YMbt++XefjKSsrIzQ0FDNmzMDbt29r9BklJSUYGxvjr7/+qvP4omDx4sXQ19fH6NGj+XbMBw8e4OTJk3jx4oXIL/QQEhKCKVOm4NChQ3BwcGAdh4gYKkzyiUaNGuHkyZNo0aIF+vTpgwcPHrCO9FmFhYU4e/YsRo8ejU6dOvHlmJaWlhg0aBAWL15c489IymnZpKQkxMXFITg4mG/HvHjxIvr27Yvw8HCMHz8eQUFBuHv3Lt+Ozy+VlZXw8fHB+vXrce7cOam9Y5x8HRUm+Sx5eXls374dLi4u6NWrl8jdCfrixQu4ublBXl4eERERAMC3heUDAwNx8ODBGu+d2b9/f7EvzLdv38LFxQUhISFo1KgR3477+++/w8/PDzExMfD29kZpaSk2b96Mhw8f8m2MusrPz8fQoUORkpKCixcv8u2bLyJ5qDDJF/F4PHh4eCA0NBT29vZ13uGjrl69egXg3416p0+fDlVVVezcuRPAv2XJrxsz1NXVERwcDFdXVxQXF3/z/SYmJsjOzq7OJ448PT0xcOBA2NjY8PW4+fn5uHz5MgBg0KBBsLOzg7q6OiIjI0ViE4CMjAyYmJige/fuSExMhIaGButIRIRRYZJvGjp0KE6fPo0ff/wRy5YtQ1VVldAzvN+HccOGDfDy8oKKisoHM0t+38U4fPhw6OvrY9WqVd98b7169dC7d2/8+eeffM0gLMeOHcOpU6cQFBTE92MvXrwYT548wd69ewEABgYG6NmzJ65du8b8emZsbCwGDBiAVatWYcOGDZCTk2Oah4iBz90JxNFdsuQznj17xvXu3ZtzcHDgCgsLhT5+eno617x5c65Lly7VrwnyTt7c3FyuadOmXGpq6jffu3btWm7OnDkCyyIoeXl5XMuWLbkzZ84I5PiVlZVcVFQU5+rqysXHx1e/PnjwYO706dMCGfNbKioqOB8fH65NmzZcWloakwxEtIHukiV11bRpU5w6dQoKCgowNzfHkydPhDq+jo4OEhMTUVVVVb1LiCCfj2vWrBkCAwPh6ur6zdmQuN74M2vWLDg6OsLc3Fwgx5eRkcGIESNgbm6OHTt2ICAgAMeOHcPdu3fRokULgYz5Nfn5+bCxscHly5eRmpoKfX19oWcg4osKk3wXRUVF7N69GyNGjICpqSnS0tKEOr62tjbOnDkDFRUVoYw3YcIEtGjRAuvXr//q+/T19fHPP//g2bNnQsnFD/v27UN6ejpWr14t0HEUFRUxbtw4/PTTT0hPT0dsbCyCg4PRtWtXgY77sevXr8PY2Bja2to4efIkXa8k3+9z006OTsmSGoiLi+M0NDS4iIgI1lEEKicnh2vcuDGXlZX11ffZ29tze/bsEVKqunl/ujklJUWo41ZUVDBZEGPfvn2choaG2Pz+ELZAp2QJv40aNQpJSUlYvXo13NzcUFJSwjqSQLRp0wbLli3DnDlzwH1ld5+hQ4fi6NGjQkxWe/Pnz8fkyZNhbGws1HFlZWWFuszc++crFy1ahMTERIwbN05oYxPJQ4VJ6kRbWxuXL19Gfn4++vTpg/v377OOJBCzZs1Cbm7uV3c0sbW1xYkTJ5jf/fktCQkJSE5OxooVK1hHEagnT55g4MCBuHLlCi5fvgw9PT3WkYiYo8IkdaaqqoqYmBhMnDgRPXv2xLFjx1hH4js5OTls3boVnp6eKCoq+ux7WrRogY4dO4r0MnnFxcVwd3dHcHAw6tevzzqOwBw7dgwGBgbo378/Tp48icaNG7OORCQAFSbhi/eLHOzfvx8zZszA0qVL+bbyjqgwNzdHnz594O/v/8X32NnZ4fDhw0JM9X38/PxgZGSEIUOGsI4iEKWlpZg/fz5mzpyJuLg4LFu2jHYaIXzD+9o1GSMjI+797fuE1NTz58/h5OQEAIiKikKzZs0YJ+Kff/75B7q6ukhOTkbHjh0/+fq1a9fg4OCA27dvi9zWWJmZmbCwsMD169eZPNIhaLdv38bYsWPRunVrhIeH83WJPyJdeDzeFY7jjD5+nWaYhO+aNm2KhIQE9OrVC4aGhiJ9ivJ7tWrVCgsWLPjivpm6urooKytDVlaWkJN9XVVVFdzc3ODr6yuRZbl792707t0brq6u2L9/P5UlEQgqTCIQsrKy8PPzw/bt2zFq1Chs3Ljxq3eYihMPDw9kZ2d/9lotj8eDnZ0djhw5wiDZl4WHh6OiogJubm6so/BVQUEBJk2ahDVr1uCPP/7AzJkzRW5mTyQHFSYRqKFDhyI5ORmRkZFwcHBAfn4+60h1pqCggC1btmDevHmffZRm2LBhInUd89mzZ1i6dClCQkIgIyM5f+XT0tJgaGiIevXqITU1Fbq6uqwjEQknOX97iMhq164dzp8/D01NTejq6uLUqVOsI9XZ4MGDoa2tjQ0bNnzyNQsLC9y4cQMvXrxgkOxTXl5emDx5MnR0dFhH4QuO47B582ZYW1vD19cXYWFhUFZWZh2LSAEqTCIUioqK2Lx5M8LCwjBp0qTqvRHF2caNGxEUFPTJ3o4KCgoYOHCgSDxek5iYiPPnz0vMM5dPnjyBra0t9uzZg+TkZIwdO5Z1JCJFqDCJUA0ePBjp6em4d+8ejI2NcePGDdaRaq1du3aYM2cOvL29P/maKFzH/N9nLsV9BsZxHHbt2gU9PT0YGRnhr7/+Qvv27VnHIlKGCpMInYaGBuLj4+Hh4YH+/ftj8+bNTPbY5AcfHx9cvnz5k9PMNjY2+OOPP5guF7hmzRoYGBjwfVNoYXv69Cns7e0RGBiIEydOYNWqVahXrx7rWEQKUWESJng8HlxcXJCcnIy9e/fC2tpa6NuF8YOSkhKCgoIwf/78DxZqaNKkCXr06IEzZ84wyZWTk4Nffvnls9dYxQXHcYiMjISuri50dXWRmpoKAwMD1rGIFKPCJEx16NAB586dQ58+faCvr//VtVpF1YgRI6CiooI9e/Z88DrLu2V9fHwwb948aGpqMhm/rnJzczFixAgEBATg+PHj+Omnn2hWSZijwiTMycnJYcWKFTh06BAWLlwIV1dXFBQUsI5VYzweD2vXrsWyZcs+OAX7/jqmsJ8/PX/+PC5evPjZa6uijuM4REdHQ1dXF1paWrhy5QoMDQ1ZxyIEABUmESE9e/bEtWvXwOPxoKenh7Nnz7KOVGN9+/aFnp4egoODq1/r2rUrFBUVce3aNaHlqKqqgoeHB/z9/cVucfVnz55h1KhR8PPzw9GjR7F69WooKCiwjkVINSpMIlIaNGiAsLAwbNy4EePGjcOMGTPw5s0b1rFqxN/fH2vXrsXr168BsFn1JzIyErKystVr+YoDjuOwb98+6OjooEuXLrhy5YrQ9+kkpCaoMIlIGjZsGG7cuAGO46CtrS1SK+d8Sffu3TFs2DCsXbu2+jVhXscsLCzEkiVLsGnTJrFZ0ScnJwf29vZYuXIlDh8+DH9/fygqKrKORchnicffKiKV1NXVsX37dkRGRsLb2xuOjo549uwZ61hftXLlSoSEhODx48cAgD59+uDevXv4559/BD72unXrYG5ujp49ewp8rLoqKytDQEAAjIyMYGpqimvXrsHU1JR1LEK+igqTiDxzc3Okp6ejffv20NHRwc6dO0V2IXdNTU1Mnz4dK1euBADIy8tjyJAhAj8t+/DhQ2zduvWre3WKiqSkJOjq6uLcuXNISUnB0qVL6VolEQtUmEQsKCkpwd/fHydOnMDPP/+MwYMH4/79+6xjfZaPjw8OHz6MmzdvAgBGjhyJ+Ph4AP9er7tw4cIHNwfxw+LFizFr1iy0bt2ar8flp2fPnmHixImYPHky/P39cfToUVqth4gVKkwiVvT19XHp0iVYWVnB2NgYGzdu/GDBAFGgrq4OHx8fLF68GABgbW2N5ORkuLu7o2nTprCyssLChQtrffwxY8YgOjq6enWkixcv4s8//6zTMQWpsrISv/zyC7S1tdGyZUtkZmZi+PDhtA0XETu8r53aMjIy4lJTU4UYh5Cau337NqZPn47CwkKEh4ejR48erCNVKykpQfv27TF48GD88ccfePr0KTiOqy65Dh064M6dO7U6toyMDOrXr49mzZohKCgI/v7+mDVrFiZNmsTPnwJfpKamwt3dHUpKStWlSYio4/F4VziOM/r4dZphErHVqVMnnD59GtOnT8eAAQPg6ekpMo+gRERE4OnTp4iIiMDjx49RWVn5wXq5tT0VWVVVBY7jUFhYiHv37mHs2LG4fv06mjdvLlLXdV+/fo1Zs2bB1tYWs2fPxp9//kllScQeFSYRazweD1OnTkVmZibevn2Lbt26YefOncwXc3d0dISWltYXv/61r31NZWXlB4+MlJaWoqSkBCNHjoSxsTHOnz9fq+PyS2VlJXbs2IHu3bujsrISN2/ehLOzM51+JRKBCpNIhKZNmyIsLAyHDh3Cr7/+it69e+Py5cvM8qirq+PChQto27btJ2WhpKSEzp071+q4FRUVn33GsrCwEGlpaRg8eDCzfUZPnToFQ0NDhIWF4eDBg/j111/RqFEjJlkIEQQqTCJRjI2NceHCBbi7u8Pe3h6urq7Mnt1UVVVFeno6lJSUIC8vX/16vXr10K5du1ods6Ki4rOzNSUlJXTs2BFXrlwR+iMaN2/ehK2tLaZPn44ff/wRf/31F0xMTISagRBhoMIkEkdGRgbOzs7IyspCw4YNoa2tjU2bNqG8vFzoWVRUVLB7927IyclVr2BTUVHB18KsX78+Jk2ahIyMDHTp0qXOmWvq2bNncHd3h4WFBSwtLXHz5k04ODjQ6VcisagwicRSU1NDYGAgzp07h+PHj0NPT++TjZ6FYcSIEdDW1kbbtm0hKyuLoqIitGnTplbHqqysrC4kOTk5qKqqYu/evfj111+FNrMsLi7GmjVroKWlBUVFRfz999+YP38+LT5AJJ4c6wCECFrXrl1x4sQJHD58GNOmTYO+vj6CgoLQtm1boYzP4/Hg6+sLDw8PaGlpISsrC/Ly8sjKysKVK1eQcjEF1y5fw7t371BeUQ6Fegpo2LAhjPsaw8TUBIaGhtDU1ASPx0NFRQXKy8shJycHQ0ND7N+/Hy1bthTKz6OqqgpRUVFYsmQJTExMkJycjI4dOwplbEJEARUmkQo8Hg/29vYYNGgQgoKCYGRkhKlTp8LHxwcNGzYU+PiDBw9Gw4YN4eDggAt/XUDThk0hz8mjJVqi8bvGaI3WUIACZCGLSlSiEIW4eOEijjQ4gkflj9C4cWPM9Z4LKysrVFVVwdvbG2vWrIGsrKzAswPAn3/+CS8vL8jKyiIqKgp9+/YVyriEiBJauIBIpcePH2PVqlU4ePAgFixYgDlz5kBJSUlg4924cQOuE11xPeM6DGUNoV+mDw1o1OizHDg8xENcq38Nt6tuw87ODpu2bkLTpk0Flve99PR0LF++HOnp6fD394ejo6PY7IRCSG3RwgWE/A9NTU2Ehobi3LlzuHTpEjp37oywsDBUVFR89XPfuzhAeXk5flr1E/qa9IVGugY8Kz0xsGxgjcsSAHjgoQ3awL7IHm4lbnh06BG6d+qO2NjY78ryPW7cuAEHBwdYW1vDwsICf//9N5ycnKgsiVSjP/1EqnXt2hXx8fGIi4vDnj17oK2tjfj4+M8WY1JSEtq2bYu8vLwaHTs7OxsGPQwQvS4aLsUuMOFMUA/16pRXBSqwKrPC8LfDMW/yPAwfOpyvqxtlZWVh7NixsLKyQs+ePXHnzh3Mnz+f9qgkBFSYhAAATE1Ncfr0aWzatAl+fn7o2bMnkpKSPniPl5cXHj9+jOHDh39zwfe0tDT0NumNNtltMKZoDNSgxte8P+AHuBS5IPePXPQ16Yvnz5/X6Xi3bt3C+PHjYW5uDn19fdy5cwfe3t5QVlbmU2JCxB8VJiH/4fF4sLa2xpUrV+Dh4YGpU6fC2toaV69exdmzZ3Hr1i1UVVXh6tWrWLZs2RePc/36dVhZWMHqjRWMOWPwIJjnEuUhD+sya2jc10C/nv2Qn5//3ce4ffs2Jk2ahL59+6J79+64c+cOfHx80KBBAwEkJkS8UWES8hEZGRk4OTkhKysLdnZ2sLGxwahRo1BUVAQAKCoqwqZNm3DixIlPPvvPP//8W5YFVuiGbgLPygMP5uXmaPpPU1gPsK7x4gz37t3DlClT0KtXL3Ts2BF37tzB0qVLoaqqKuDEhIgvKkxCvqBevXqYNWsWoqOjP7lOWFxcDEdHRzx8+LD6NY7j4DLBBT0KekALtVtcvTZ44GFA2QAU3C5AwJqAr743JycH06ZNg7GxMVq3bo07d+5g+fLlUFPj7yljQiQRFSYh3+Dr6/vZmdu7d+8wdOhQlJWVAQAidkYg63IWelf0FnZE8MCDdZE1gtYGISMj45OvZ2ZmYtKkSTAwMEDTpk1x+/ZtrFq1Curq6kLPSoi4osIk5CuuXbuG5OTkz36tqqoKWVlZmDBhAnJzc+E51xM2hTaQY7QeiDrUYV5ijvFjxldvb5acnAx7e3tYWlqia9euuHfvHlavXk27iBBSC7TSDyFf8euvv6K8vBwNGjSoftSE47jqH2VlZYiNjYWykjK6lHdBC7Rgmlef08e1x9fg7++PxMRE5OTkYMGCBYiOjkb9+vWZZiNE3NFKP4R8xdu3b/HkyRPIysp+8QcAdOvYDQ6vHdAMzRgnBq7gCi6oXMCmXzbB0dHxg63FCCHf9qWVfmiGSchXqKqqfvPO0bi4OKhXqotEWQJAD/TAmfIzMDMzo7IkhI/oGiYhdRS+LRzaBdqsY1Srh3rQ4rQQHR3NOgohEoVmmITU0ZW0KxiHcTV67w7swDM8gze8q28OOoADyEAGZCELHnhojMYYjMFoi7YAgKu4isM4/MHNRHrQw1AM/eI4LUtb4nzSeWBR7X9ehJAPUWESUgdPnz5FSXEJ1PHtxzNe4RUe4iEUoIBbuPXBs5p90AeWsAQHDmlIwz7swwIsgMx/J4E0oQlXuNY4V0u0xP60/d//EyKEfBGdkiWkDq5cuYIfFH6o0fJ36UiHJjShBz1cw7XPvocHHnqgB4pRjHd4V+tcjdAIr96+wsuXL2t9DELIh6gwCamD+/fvQ62sZqvkpCMdPdADOtDBXdz9bCFWoQrpSIc61NEAtV/PVQYyaKbYDPfv36/1MQghH6JTsoTUQXFxMWQrZL/5vgd4gDd4Ay1oQRnKaIiGyEAGeqEXAOACLiAFKahEJThwsId99elYAHiMx/CHf/X/T8AE/IAfvjqmHE8OJSUltfyZEUI+RoVJSB3UdEPpdKSjAzpAGf9ul9UDPXAN16oLszd6V1/DfI7n2I3dUIISOqETgO+/hgn8e3r3/Yo/hJC6o8IkpA6UlJRQJVsFVHz5PeUoRyYyUYUqrMd6AEAlKlGCEuQi94P38sBDMzRDa7RGNrKrC7M2KlABJSWlWn+eEPIhKkxC6kBTUxMFCgVA6Zff8zf+Bg88zMIsyOL/T9/GIhbpSP/k/S/wAg/xEOYwr3UuDhzySvKgqalZ62MQQj5EhUlIHRgaGuJx+eOvvucarkEf+p88emICExzHcbRHe5zHeSTj30XelaAEPejBEIa1zvUar6GopIgWLdiubUuIJKHCJKQOWrdujSqZKrzFW6ji80voTcTEz76u/d9/ADAKo744hv5//32PJ3gCfd3v+wwh5OvosRJC6oDH40FfRx+P8fVZprA9lXuKXua9WMcgRKJQYRJSR5OmTUJmg0zWMapVoAKZ8plwHOvIOgohEoUKk5A6cnR0xGPuMV7hFesoAP69yai7Vnd069aNdRRCJAoVJiF1VL9+fUyeMhlp8mmsowAArqtch4ePB+sYhEgcKkxC+GDu/LlIl0tHPvKZ5vgbf6NUpRT29vZMcxAiiagwCeGD9u3bY+nypTiufBxVYLO6ThGKcFLpJHbv3U0bRxMiAFSYhPCJ1wIvqLRXQZoMm1Ozfyj9gXHO42BmZsZkfEIkHRUmIXwiKyuLPTF78JfSX8hBjlDHTpFNwWuN11gXtE6o4xIiTagwCeGjrl27Iu5QHA7UP4BHeCSUMdNk0pCmnobT506jfv36QhmTEGlEhUkIn1laWmJv/F7E1Y9DNrIFNk4VqnBe9jxSG6fi7MWzaNOmjcDGIoRQYRIiENbW1jiWcAxJGkk4rngcJeDvvpSv8ArRytHI65aH5CvJ6NSp9ruaEEJqhgqTEAHp06cPsu5koZtDN4TVD8Mt3KrzHbTlKEeKTAp2KO2A61JXXL52GT/88PWNpAkh/EGLrxMiQGpqatixewcSJiZgnvs8nHl+BrqFutDldKGEmu9V+QqvcFX+KtJl02FgaIBLYZfQtWtXASYnhHyMCpMQIRg0aBBu3rmJCxcuYHPgZmw9vhU/KPwAjSINNK9ojmZoBgUoQAYyqEQlilCEp3iK5wrP8VzhOV5WvsTkKZMRNjeMTr8SwgiP47gvftHIyIhLTU0VYhxCpEN+fj5SUlKQejkVF/+8iMzMTBSVFKG8ohwK8gpQVVGFvqE+epv3hqGhIQwNDaGkVPMZKSGk9ng83hWO44w+eZ0KkxBCCPl/XypMuumHEEIIqQEqTEIIIaQGqDAJIYSQGqDCJIQQQmqACpMQQgipASpMQgghpAaoMAkhhJAaoMIkhBBCaoAKkxBCCKkBKkxCCCGkBqgwCSGEkBqgwiSEEEJqgAqTEEIIqQEqTEIIIaQGqDAJIYSQGqDCJIQQQmqACpMQQgipAR7HcV/+Io/3AsAD4cUhhBBCmGvDcVyTj1/8amESQggh5F90SpYQQgipASpMQgghpAaoMAkhhJAaoMIkhBBCaoAKkxBCCKmB/wNYQF4ZBokAAAACSURBVGd65pfY+AAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}