{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 682,
   "id": "806f6f69-1e0b-4d34-aac9-695c8531cdb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain, combinations, permutations, product, pairwise\n",
    "from math import prod, log\n",
    "from copy import deepcopy\n",
    "import networkx as nx\n",
    "from fractions import Fraction\n",
    "import json\n",
    "from operator import add\n",
    "\n",
    "def hs_array_to_fr(hs_array):\n",
    "    return prod([pow(dims[d], hs_array[d]) for d in range(len(dims))])\n",
    "\n",
    "def hs_array_to_cents(hs_array):\n",
    "    return (1200 * log(hs_array_to_fr(hs_array), 2))\n",
    "\n",
    "def expand_pitch(hs_array):\n",
    "    expanded_pitch = list(hs_array)\n",
    "    frequency_ratio = hs_array_to_fr(hs_array)\n",
    "    if frequency_ratio < 1:\n",
    "        while frequency_ratio < 1:\n",
    "            frequency_ratio *= 2\n",
    "            expanded_pitch[0] += 1\n",
    "    elif frequency_ratio >= 2:\n",
    "        while frequency_ratio >= 2:\n",
    "            frequency_ratio *= 1/2\n",
    "            expanded_pitch[0] += -1\n",
    "    return tuple(expanded_pitch)\n",
    "\n",
    "def expand_chord(chord):\n",
    "    return tuple(expand_pitch(p) for p in chord)\n",
    "\n",
    "def collapse_pitch(hs_array):\n",
    "    collapsed_pitch = list(hs_array)\n",
    "    collapsed_pitch[0] = 0\n",
    "    return tuple(collapsed_pitch)\n",
    "\n",
    "def collapse_chord(chord):\n",
    "    return tuple(collapse_pitch(p) for p in chord)\n",
    "\n",
    "def transpose_pitch(pitch, trans):\n",
    "    return tuple(map(add, pitch, trans))\n",
    "\n",
    "def transpose_chord(chord, trans):\n",
    "    return tuple(transpose_pitch(p, trans) for p in chord)\n",
    "\n",
    "def cent_difference(hs_array1, hs_array2):\n",
    "    return hs_array_to_cents(hs_array2) - hs_array_to_cents(hs_array1)\n",
    "\n",
    "def pitch_difference(hs_array1, hs_array2):\n",
    "    return transpose_pitch(hs_array1, [p * -1 for p in hs_array2])\n",
    "\n",
    "# this is modified for different chord sizes like original version\n",
    "def grow_chords(chord, root, min_chord_size, max_chord_size):\n",
    "    #this could use the tranpose_pitch function\n",
    "    branches = [branch for alt in [-1, 1] for d in range(1, len(root)) if (branch:=(*(r:=root)[:d], r[d] + alt, *r[(d + 1):])) not in chord]\n",
    "    subsets = chain.from_iterable(combinations(branches, r) for r in range(1, max_chord_size - len(chord) + 1))\n",
    "    for subset in subsets:\n",
    "        extended_chord = chord + subset\n",
    "        if(len(extended_chord) < max_chord_size):\n",
    "            for branch in subset:\n",
    "                yield from grow_chords(extended_chord, branch, min_chord_size, max_chord_size)\n",
    "        if(len(extended_chord) >= min_chord_size):\n",
    "            yield tuple(sorted(extended_chord, key=hs_array_to_fr))\n",
    "\n",
    "def chords(chord, root, min_chord_size, max_chord_size):\n",
    "    # this will filter out the 4x dups of paths that are loops, there might be a faster way to test this\n",
    "    return set(grow_chords(chord, root, min_chord_size, max_chord_size))\n",
    "\n",
    "# this is very slow, I have an idea in mind that my be faster by simply growing the chords to max_chord_size + max_sim_diff\n",
    "# technically at that point you have generated both chords and can get the second chord from the first\n",
    "def edges(chords, min_symdiff, max_symdiff, max_chord_size):  \n",
    "\n",
    "    def reverse_movements(movements):\n",
    "        return {value['destination']:{'destination':key, 'cent_difference':value['cent_difference'] * -1} for key, value in movements.items()}\n",
    "\n",
    "    def is_directly_tunable(intersection, diff):\n",
    "        # this only works for now when intersection if one element - need to fix that\n",
    "        return max([sum(abs(p) for p in collapse_pitch(pitch_difference(d, list(intersection)[0]))) for d in diff]) == 1\n",
    "\n",
    "    for combination in combinations(chords, 2):\n",
    "        [expanded_base, expanded_comp] = [expand_chord(chord) for chord in combination]\n",
    "        edges = []\n",
    "        transpositions = set(pitch_difference(pair[0], pair[1]) for pair in set(product(expanded_base, expanded_comp)))\n",
    "        for trans in transpositions:\n",
    "            expanded_comp_transposed = transpose_chord(expanded_comp, trans)\n",
    "            intersection = set(expanded_base) & set(expanded_comp_transposed)\n",
    "            symdiff_len = sum([len(chord) - len(intersection) for chord in [expanded_base, expanded_comp_transposed]])\n",
    "            if (min_symdiff <= symdiff_len <= max_symdiff):\n",
    "                rev_trans = tuple(t * -1 for t in trans)\n",
    "                [diff1, diff2] = [list(set(chord) - intersection) for chord in [expanded_base, expanded_comp_transposed]]\n",
    "                base_map = {val: {'destination':transpose_pitch(val, rev_trans), 'cent_difference': 0} for val in intersection}\n",
    "                base_map_rev = reverse_movements(base_map)\n",
    "                maps = []\n",
    "                diff1 += [None] * (max_chord_size - len(diff1) - len(intersection))\n",
    "                perms = [list(perm) + [None] * (max_chord_size - len(perm) - len(intersection)) for perm in set(permutations(diff2))]\n",
    "                for p in perms:\n",
    "                    appended_map = {\n",
    "                        diff1[index]:\n",
    "                        {\n",
    "                            'destination': transpose_pitch(val, rev_trans) if val != None else None, \n",
    "                            'cent_difference': cent_difference(diff1[index], val) if None not in [diff1[index], val] else None\n",
    "                        } for index, val in enumerate(p)}\n",
    "                    yield (tuple(expanded_base), tuple(expanded_comp), {\n",
    "                        'transposition': trans,\n",
    "                        'symmetric_difference': symdiff_len, \n",
    "                        'is_directly_tunable': is_directly_tunable(intersection, diff2),\n",
    "                        'movements': base_map | appended_map\n",
    "                    },)\n",
    "                    yield (tuple(expanded_comp), tuple(expanded_base), {\n",
    "                        'transposition': rev_trans,\n",
    "                        'symmetric_difference': symdiff_len, \n",
    "                        'is_directly_tunable': is_directly_tunable(intersection, diff1),\n",
    "                        'movements': base_map_rev | reverse_movements(appended_map)\n",
    "                    },)\n",
    "\n",
    "def graph_from_edges(edges):\n",
    "    g = nx.MultiDiGraph()\n",
    "    g.add_edges_from(edges)\n",
    "    return g\n",
    "\n",
    "def generate_graph(chord_set, min_symdiff, max_symdiff, max_chord_size):\n",
    "    #chord_set = chords(pitch_set, min_chord_size, max_chord_size)\n",
    "    edge_set = edges(chord_set, min_symdiff, max_symdiff, max_chord_size)\n",
    "    res_graph = graph_from_edges(edge_set)\n",
    "    return res_graph\n",
    "\n",
    "def display_graph(graph):\n",
    "    show_graph = nx.Graph(graph)\n",
    "    pos = nx.draw_spring(show_graph, node_size=5, width=0.1)\n",
    "    plt.figure(1, figsize=(12,12)) \n",
    "    nx.draw(show_graph, pos, node_size=5, width=0.1)\n",
    "    plt.show()\n",
    "    #plt.savefig('compact_sets.png', dpi=150)\n",
    "\n",
    "def path_to_chords(path, start_root):\n",
    "    current_root = start_root\n",
    "    start_chord = tuple(sorted(path[0][0], key=hs_array_to_fr))\n",
    "    chords = ((start_chord, start_chord,),)\n",
    "    for edge in path:\n",
    "        trans = edge[2]['transposition']\n",
    "        movements = edge[2]['movements']\n",
    "        current_root = transpose_pitch(current_root, trans)\n",
    "        current_ref_chord = chords[-1][0]\n",
    "        next_ref_chord = tuple(movements[pitch]['destination'] for pitch in current_ref_chord)\n",
    "        next_transposed_chord = tuple(transpose_pitch(pitch, current_root) for pitch in next_ref_chord)\n",
    "        chords += ((next_ref_chord, next_transposed_chord,),)\n",
    "    return tuple(chord[1] for chord in chords)\n",
    "\n",
    "def write_chord_sequence(path):\n",
    "    file = open(\"seq.txt\", \"w+\")\n",
    "    content = json.dumps(path)\n",
    "    content = content.replace(\"[[[\", \"[\\n\\t[[\")\n",
    "    content = content.replace(\", [[\", \",\\n\\t[[\")\n",
    "    content = content.replace(\"]]]\", \"]]\\n]\")\n",
    "    file.write(content)\n",
    "    file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 683,
   "id": "aea5215c-8551-4685-b761-11c2dc74cf22",
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import choice, choices\n",
    "\n",
    "# This is for the static version\n",
    "def stochastic_hamiltonian(graph):\n",
    "        \n",
    "    def movement_size_weights(edges):\n",
    "        \n",
    "        def max_cent_diff(edge):\n",
    "            res = max([abs(v) for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None])\n",
    "            return res\n",
    "            \n",
    "        def min_cent_diff(edge):\n",
    "            res = [abs(v) for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None]\n",
    "            res.remove(0)\n",
    "            return min(res)\n",
    "            \n",
    "        for e in edges:\n",
    "            yield 1000 if ((max_cent_diff(e) < 200) and (min_cent_diff(e)) > 50) else 1\n",
    "\n",
    "    def hamiltonian_weights(edges):\n",
    "        for e in edges:\n",
    "            yield 10 if e[1] not in [path_edge[0] for path_edge in path] else 1 / graph.nodes[e[1]]['count']\n",
    "    \n",
    "    def contrary_motion_weights(edges):\n",
    "\n",
    "        def is_contrary(edge):\n",
    "            cent_diffs = [v for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None]\n",
    "            cent_diffs.sort()\n",
    "            return (cent_diffs[0] < 0) and (cent_diffs[1] == 0) and (cent_diffs[2] > 0)\n",
    "\n",
    "        for e in edges:\n",
    "            yield 10 if is_contrary(e) else 1\n",
    "    \n",
    "    def is_directly_tunable_weights(edges):\n",
    "        for e in edges:\n",
    "            yield 10 if e[2]['is_directly_tunable'] else 0\n",
    "\n",
    "    def voice_crossing_weights(edges):\n",
    "        \n",
    "        def has_voice_crossing(edge):\n",
    "            source = list(edge[0])\n",
    "            ordered_source = sorted(source, key=hs_array_to_fr)    \n",
    "            source_order = [ordered_source.index(p) for p in source]\n",
    "            destination = [transpose_pitch(edge[2]['movements'][p]['destination'], edge[2]['transposition']) for p in source]\n",
    "            ordered_destination = sorted(destination, key=hs_array_to_fr)\n",
    "            destination_order = [ordered_destination.index(p) for p in destination]\n",
    "            return source_order != destination_order\n",
    "\n",
    "        for e in edges:\n",
    "            yield 10 if not has_voice_crossing(e) else 0\n",
    "\n",
    "    def is_bass_rooted(chord):\n",
    "        return max([sum(abs(p) for p in collapse_pitch(pitch_difference(chord[0], p))) for p in chord[1:]]) == 1\n",
    "        \n",
    "    check_graph = graph.copy()\n",
    "    next_node = choice([node for node in graph.nodes() if is_bass_rooted(node)])\n",
    "    check_graph.remove_node(next_node)\n",
    "    for node in graph.nodes(data=True):\n",
    "        node[1]['count'] = 1\n",
    "    path = []\n",
    "    while (nx.number_of_nodes(check_graph) > 0) and (len(path) < 5000):\n",
    "        out_edges = list(graph.out_edges(next_node, data=True))\n",
    "        #print([l for l in zip(movement_size_weights(out_edges), hamiltonian_weights(out_edges))])\n",
    "        factors = [\n",
    "            movement_size_weights(out_edges), \n",
    "            hamiltonian_weights(out_edges), \n",
    "            contrary_motion_weights(out_edges), \n",
    "            is_directly_tunable_weights(out_edges),\n",
    "            voice_crossing_weights(out_edges)\n",
    "        ]\n",
    "        weights = [prod(a) for a in zip(*factors)]\n",
    "        edge = choices(out_edges, weights=weights)[0]\n",
    "        #edge = random.choice(out_edges)\n",
    "        next_node = edge[1]\n",
    "        node[1]['count'] += 1\n",
    "        path.append(edge)\n",
    "        if next_node in check_graph.nodes:\n",
    "            check_graph.remove_node(next_node)\n",
    "    return path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 684,
   "id": "4e3ef738-7f64-47c3-9129-0450fd031375",
   "metadata": {},
   "outputs": [],
   "source": [
    "dims = (2, 3, 5, 7, 11)\n",
    "root = (0, 0, 0, 0, 0)\n",
    "chord = (root,)\n",
    "chord_set = chords(chord, root, 3, 3)\n",
    "graph = generate_graph(chord_set, 4, 4, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 685,
   "id": "6e0de0e5-7973-4a15-ae90-5bbb4a1ef49d",
   "metadata": {},
   "outputs": [],
   "source": [
    "path = stochastic_hamiltonian(graph)\n",
    "#for edge in path:\n",
    "#    print(edge)\n",
    "write_chord_sequence(path_to_chords(path, root))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7f2d356f-6377-46cf-bbb1-32111be90f4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The line_profiler extension is already loaded. To reload it, use:\n",
      "  %reload_ext line_profiler\n"
     ]
    }
   ],
   "source": [
    "%load_ext line_profiler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "7f141bf5-fdcb-4c01-a10b-3e86d3d1a7b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "chord_set = chords(chord, root, 3, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "88850b8c-a743-44d0-b863-7cd9066690d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timer unit: 1e-09 s\n",
       "\n",
       "Total time: 0.112228 s\n",
       "File: /tmp/ipykernel_515812/2679284550.py\n",
       "Function: edge_data at line 74\n",
       "\n",
       "Line #      Hits         Time  Per Hit   % Time  Line Contents\n",
       "==============================================================\n",
       "    74                                           def edge_data(chords, min_symdiff, max_symdiff, max_chord_size):\n",
       "    75       990   29603044.0  29902.1     26.4      [expanded_base, expanded_comp] = [expand_chord(chord) for chord in chords]\n",
       "    76       990     229527.0    231.8      0.2      edges = []\n",
       "    77       990   23648371.0  23887.2     21.1      transpositions = set(pitch_difference(pair[0], pair[1]) for pair in set(product(expanded_base, expanded_comp)))\n",
       "    78      9193    2315267.0    251.9      2.1      for trans in transpositions:\n",
       "    79      8203   33386775.0   4070.1     29.7          expanded_comp_transposed = transpose_chord(expanded_comp, trans)\n",
       "    80      8203    8393773.0   1023.3      7.5          intersection = set(expanded_base) & set(expanded_comp_transposed)\n",
       "    81      8203   11812057.0   1440.0     10.5          symdiff_len = sum([len(chord) - len(intersection) for chord in [expanded_base, expanded_comp_transposed]])\n",
       "    82      8203    2530596.0    308.5      2.3          if (min_symdiff <= symdiff_len <= max_symdiff):\n",
       "    83                                                       rev_trans = tuple(t * -1 for t in trans)\n",
       "    84                                                       [diff1, diff2] = [list(set(chord) - intersection) for chord in [expanded_base, expanded_comp_transposed]]\n",
       "    85                                                       base_map = {val: {'destination':transpose_pitch(val, rev_trans), 'cent_difference': 0} for val in intersection}\n",
       "    86                                                       base_map_rev = reverse_movements(base_map)\n",
       "    87                                                       tunability = is_directly_tunable(intersection, diff2)\n",
       "    88                                                       maps = []\n",
       "    89                                                       diff1 += [None] * (max_chord_size - len(diff1) - len(intersection))\n",
       "    90                                                       perms = [list(perm) + [None] * (max_chord_size - len(perm) - len(intersection)) for perm in set(permutations(diff2))]\n",
       "    91                                                       for p in perms:\n",
       "    92                                                           appended_map = {\n",
       "    93                                                               diff1[index]:\n",
       "    94                                                               {\n",
       "    95                                                                   'destination': transpose_pitch(val, rev_trans) if val != None else None, \n",
       "    96                                                                   'cent_difference': cent_difference(diff1[index], val) if None not in [diff1[index], val] else None\n",
       "    97                                                               } for index, val in enumerate(p)}\n",
       "    98                                                           edges.append((tuple(expanded_base), tuple(expanded_comp), {\n",
       "    99                                                               'transposition': trans,\n",
       "   100                                                               'symmetric_difference': symdiff_len, \n",
       "   101                                                               'is_directly_tunable': tunability,\n",
       "   102                                                               'movements': base_map | appended_map\n",
       "   103                                                           }))\n",
       "   104                                                           edges.append((tuple(expanded_comp), tuple(expanded_base), {\n",
       "   105                                                               'transposition': rev_trans,\n",
       "   106                                                               'symmetric_difference': symdiff_len, \n",
       "   107                                                               'is_directly_tunable': tunability,\n",
       "   108                                                               'movements': base_map_rev | reverse_movements(appended_map)\n",
       "   109                                                           }))\n",
       "   110       990     308812.0    311.9      0.3      return edges if edges != [] else None"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lprun -f edge_data edges(chord_set, 3, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 688,
   "id": "6e4ecb10-344b-4721-b2f4-68de91d712db",
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import choice, choices\n",
    "\n",
    "# This is for the rising version / yitgadal\n",
    "def stochastic_hamiltonian(graph):\n",
    "        \n",
    "    def movement_size_weights(edges):\n",
    "        \n",
    "        def max_cent_diff(edge):\n",
    "            res = max([v for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None])\n",
    "            return res\n",
    "            \n",
    "        def min_cent_diff(edge):\n",
    "            res = [v for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None]\n",
    "            res.remove(0)\n",
    "            return min(res)\n",
    "            \n",
    "        for e in edges:\n",
    "            yield 1000 if ((max_cent_diff(e) < 175) and (min_cent_diff(e)) >= 0) else 1\n",
    "\n",
    "    def hamiltonian_weights(edges):\n",
    "        for e in edges:\n",
    "            yield 10 if e[1] not in [path_edge[0] for path_edge in path] else 1 / graph.nodes[e[1]]['count']\n",
    "    \n",
    "    def contrary_motion_weights(edges):\n",
    "\n",
    "        def is_contrary(edge):\n",
    "            cent_diffs = [v for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None]\n",
    "            cent_diffs.sort()\n",
    "            return (cent_diffs[0] < 0) and (cent_diffs[1] == 0) and (cent_diffs[2] > 0)\n",
    "\n",
    "        for e in edges:\n",
    "            yield 2 if is_contrary(e) else 1\n",
    "    \n",
    "    def is_directly_tunable_weights(edges):\n",
    "        for e in edges:\n",
    "            yield 10 if e[2]['is_directly_tunable'] else 0\n",
    "\n",
    "    def transposition_weight(edges):\n",
    "        for e in edges:\n",
    "            yield 1000 if 0 <= hs_array_to_cents(e[2]['transposition']) < 100 else 0\n",
    "\n",
    "    def is_sustained_voice(edges, voice):\n",
    "        \n",
    "        def is_sustained(edge):\n",
    "            source = list(edge[0])\n",
    "            ordered_source = sorted(source, key=hs_array_to_fr)    \n",
    "            destination = [transpose_pitch(edge[2]['movements'][p]['destination'], edge[2]['transposition']) for p in source]\n",
    "            ordered_destination = sorted(destination, key=hs_array_to_fr)\n",
    "            return ordered_source[voice] == ordered_destination[voice]\n",
    "\n",
    "        for e in edges:\n",
    "            yield 10 if is_sustained(e) else 0\n",
    "\n",
    "    def voice_crossing_weights(edges):\n",
    "        \n",
    "        def has_voice_crossing(edge):\n",
    "            source = list(edge[0])\n",
    "            ordered_source = sorted(source, key=hs_array_to_fr)    \n",
    "            source_order = [ordered_source.index(p) for p in source]\n",
    "            destination = [transpose_pitch(edge[2]['movements'][p]['destination'], edge[2]['transposition']) for p in source]\n",
    "            ordered_destination = sorted(destination, key=hs_array_to_fr)\n",
    "            destination_order = [ordered_destination.index(p) for p in destination]\n",
    "            return source_order != destination_order\n",
    "\n",
    "        for e in edges:\n",
    "            yield 10 if not has_voice_crossing(e) else 0\n",
    "\n",
    "    def is_bass_rooted(chord):\n",
    "        return max([sum(abs(p) for p in collapse_pitch(pitch_difference(chord[0], p))) for p in chord[1:]]) == 1\n",
    "        \n",
    "    check_graph = graph.copy()\n",
    "    #next_node = choice([node for node in graph.nodes() if is_bass_rooted(node)])\n",
    "    next_node = choice(list(graph.nodes()))\n",
    "    print(next_node)\n",
    "    check_graph.remove_node(next_node)\n",
    "    for node in graph.nodes(data=True):\n",
    "        node[1]['count'] = 1\n",
    "    path = []\n",
    "    while (nx.number_of_nodes(check_graph) > 0) and (len(path) < 500):\n",
    "        out_edges = list(graph.out_edges(next_node, data=True))\n",
    "        #print([l for l in zip(movement_size_weights(out_edges), hamiltonian_weights(out_edges))])\n",
    "        factors = [\n",
    "            movement_size_weights(out_edges), \n",
    "            hamiltonian_weights(out_edges), \n",
    "            #contrary_motion_weights(out_edges), \n",
    "            #is_directly_tunable_weights(out_edges),\n",
    "            voice_crossing_weights(out_edges),\n",
    "            #transposition_weight(out_edges)\n",
    "            #is_sustained_voice(out_edges, 0)\n",
    "        ]\n",
    "        weights = [prod(a) for a in zip(*factors)]\n",
    "        #print(weights)\n",
    "        edge = choices(out_edges, weights=weights)[0]\n",
    "        #print(edge)\n",
    "        #edge = random.choice(out_edges)\n",
    "        next_node = edge[1]\n",
    "        node[1]['count'] += 1\n",
    "        path.append(edge)\n",
    "        if next_node in check_graph.nodes:\n",
    "            check_graph.remove_node(next_node)\n",
    "    print(len(check_graph.nodes()))\n",
    "    return path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 689,
   "id": "a76dc0f3-02e2-4739-9014-b53d3a590e3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "dims = (2, 3, 5, 7, 11)\n",
    "root = (0, 0, 0, 0, 0)\n",
    "chord = (root,)\n",
    "chord_set = chords(chord, root, 3, 3)\n",
    "graph = generate_graph(chord_set, 2, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 690,
   "id": "7b76d848-fe53-4b60-b414-46cfe570f78b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((3, 0, 0, -1, 0), (0, 0, 0, 0, 0), (-2, 0, 0, 1, 0))\n",
      "0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "163"
      ]
     },
     "execution_count": 690,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path = stochastic_hamiltonian(graph)\n",
    "#for edge in path:\n",
    "#    print(edge)\n",
    "write_chord_sequence(path_to_chords(path, root))\n",
    "len(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91fd1700-6f41-4a4c-98cb-8355075d44d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#ffmpeg -i video.mkv -acodec pcm_s16le -ar 16000 -ac 2 bereshit_chant.wav\n",
    "#sox bereshit_chant.wav bereshit_chant_snippet.wav trim 4 60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "51be5ff2-2b7f-4350-878f-09e79d4bff1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import crepe\n",
    "from scipy.io import wavfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9b8e1e21-c5f5-4d77-8d1c-094b073b8322",
   "metadata": {},
   "outputs": [],
   "source": [
    "sr, audio = wavfile.read('/home/mwinter/Downloads/bereshit_chant_snippet.wav')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "01f8f969-fc3c-46a2-acfd-b1f956e438bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m76/76\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m54s\u001b[0m 714ms/step\n"
     ]
    }
   ],
   "source": [
    "time, frequency, confidence, activation = crepe.predict(audio, sr, step_size = 25)\n",
    "#time, frequency, confidence = [list(time), list(frequency), list(confidence)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 786,
   "id": "a89c32ee-6413-400a-b3c9-a875f2768954",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOx9d5wlRbX/t/ummdm8ywbCknNOiigKPFFUxBxBEVSe+sDE+71nRH2KoL4nZsX4TOAzKwqigIKKIElyzizL5jS7M3Pv7e76/dFdVaeqTnW4M7OzuPd8PrB37u1Q3V1ddep7vud7AiGEQN/61re+9a1vfevbFFk41Q3oW9/61re+9a1vW7f1nZG+9a1vfetb3/o2pdZ3RvrWt771rW9969uUWt8Z6Vvf+ta3vvWtb1NqfWekb33rW9/61re+Tan1nZG+9a1vfetb3/o2pdZ3RvrWt771rW9969uUWt8Z6Vvf+ta3vvWtb1Nq9aluQBlLkgRLly7FjBkzEATBVDenb33rW9/61re+lTAhBIaHh7HddtshDP34x1PCGVm6dCkWL1481c3oW9/61re+9a1vPdjjjz+OHXbYwfv7U8IZmTFjBoD0YmbOnDnFrelb3/rWt771rW9lbMOGDVi8eLGax332lHBGZGhm5syZfWekb33rW9/61renmBVRLPoE1r71rW9961vf+jal1ndG+ta3vvWtb33r25Ra3xnpW9/61re+9a1vU2p9Z6Rvfetb3/rWt75NqfWdkb71rW9961vf+jal1ndG+ta3vvWtb33r25Ra3xnpW9/61re+9a1vU2p9Z6Rvfetb3/rWt75NqfWdkb71rW9961vf+jal1ndG+ta3vvWtb33r25Ra3xnpW9/61re+9a1vU2p9Z6Rvfetb3/rWt75NqfWdkb71rciuuQb4wheAJJnqlvStb33r2z+lPSWq9vatb1NmSQIcdVT6+eCDgaOPntLm9K1vfevbP6P1kZF/Botj4B//SP/t28Ta2Jj+vHz51LVjc5gQwOmnAx/5yFS3pG9969tWZn1n5J/B/uu/gEMPBT7zmaluyT+fjY7qz7Xa1LVjc9hddwHf+hbwiU88NUJSQkx1C/rWt75NkPWdkX8G+8Qn0n8/+MGpbcc/o1Fn5KkwQY/Hul39eXh46tpRxrrd1AF/9aunuiV961vfJsD6nJG+9S3PaJiGTtb/jBZF+vP69cCsWVPXliK74QbgllvS/4QAgmCqW9S3vvVtHNZHRmxbtaoP//ZNG0VG/tmdkU2b9OcNG6auHWWs0dCf2+2pa0ff+ta3CbG+M0Lt6quB+fOBN71pqlvSty3F6ETX6eRvKwTwl78ATz45uW2aLBsZ0Z+3dMer1dKfN26cunb0bcuy4eE06+2d75zqlvStolV2Rv785z/jxBNPxHbbbYcgCPCrX/2qcJ+rrroKhx56KFqtFnbffXd897vf7aGpm8HOOSf99wc/mNp29G3LMRq6KJqgb7wReM5zgB12mNw2TZZVudapNopeUkSnb1u3feUrwK23Al/+8lS3pG8VrbIzsmnTJhx00EH4yle+Umr7hx9+GCeccAKOPfZY3HLLLXjPe96Dt771rfj9739fubGTbv/sBMXJsm99C/jGN6a6FZNjNF26aIK+5Zb03yR5avYl2uYt3RmhjhNFdPq2ddvKlVPdgr71aJWdkRe+8IU455xz8PKXv7zU9hdccAF22WUXfPazn8U+++yDM888E6961avwuc99rnJjJ92eihPIVNuGDak2xdvelpIe/9mMTnpFYZpp0/j9ylq7DTzzmen9rGoPPADstVe6MvTZqlXAF78ILFvG//5UckZo+/rv7VPDkgR44xuBj3988s7xz55+/09sk84Zufbaa3HccccZ3x1//PG49tprvfu0221s2LDB+G+z2JZKXL3xRuCSS6a6FbytXas/bymx+04HeOyxiTkWdSqqiMr14oz87nfAtdemSFNV++Y3gfvuA84807/N5z4HvPvdwAtewP/+VHJGen0ufZs6u/JK4Ic/BD760ck7B3VGtrTx/KqrgJNPBh5/fKpbskXapDsjy5Ytw8KFC43vFi5ciA0bNmCUZioQO++88zBr1iz13+LFiye7maltaZ1X2tOeBrz4xcCDD051S1xbvVp/rhK7P/XUdFKcjFXtCScAO+0E3HTT+I9FJ7oiB4P2n16cEXovx8bS451xBvCpTxXv63mXDJNcrVtv5X9/qjojWxIycvvtwPHHA9dfP9Ut2TLswx9OEwKEAB55RH8/WWMtdUa2pD4sBHDsscBFFwE/+tFUt2aLtC0ym+YDH/gA1q9fr/57fHN5kuMd1MpMCFXszjuBn/1M//3EE+M/5ve/nyq2TpRRNKQsMpIkwPe+B/z+96mM/UTbFVek/37ve+M/1uZERppN/Xn9+vTefPWrwAc+MDETbhG34qnkjND2bUnIyPHHA3/4A/Dc5051S7YM++Qn0zHntts2D0GaOiNbUso37aMPPTR17diCbdKdkUWLFmG5VdNj+fLlmDlzJgYHB9l9Wq0WZs6cafy3WayIE5BnF1wADA0Bv/jFxLVn//1NhcmBgfEdT4h0lfKxjwF33DG+Y0mjL3xZZ4Q6bRMdgqMrrtmzx3+8KshIlW2L9h8eBtat038X8XHKrDSL2jRRzsj735+KkOWFjMZrWyoyItO6t5SQJTB1iC/tQ92u6SiMd+HW6QCf/rSL8oVkSqOChVNtW2p/3YJs0p2RI488EldeeaXx3eWXX44jjzxysk9d3cbTed/xjvTfV71qYtrCrfZ8KpNl1SepxPdErUyoA1f2mHQgmuhMCHrsiVDlrIKM0G3l5zvvTGu+lDF6/0ZHzQmNhnA4oxOO/HzVVea5i9o/Uc7Ipz+d/lsy464no/f6wgu33BDrVNs3v5kSq6+6qvq+cQxcd13vCAMdT8PQ/1sv9o1vpE7vwQeb33Pv4JZg9N3bkhCbLcgqOyMbN27ELbfcgluyNMaHH34Yt9xyCx7LCIMf+MAHcMopp6jt3/72t+Ohhx7Cf/7nf+Kee+7BV7/6VfzkJz/Be9/73om5gom08SAjE22UGCptvO1btUp/pgqW4zH6YpWdwOhANNEDBnW4JgK+p8eo6ox0Oim6td9+5fg0dP+xMfPeVllJdrspmfXYY9NzSytakT1VwzRf+EJfG8hn//qvad859tjq+557LnDkkb0LiNH3PAhcZ3s8dued/Pf0HFuSM0LbMh5n5Ec/Ap73PGDFivG15/rrgXe9a4vKgKzsjNx444045JBDcMghhwAAzjrrLBxyyCH4SFZ2/Mknn1SOCQDssssuuOSSS3D55ZfjoIMOwmc/+1l861vfwvHHHz9BlzCBNpke6xVXAIsXA5deWm57DjEo44zkTTiT8aKOFxmZ6AGDhn0mAiqvstKy7y8NszzwQPG57MGa3ttrrineX1qnozVPqNmrU9ueSs6I/Sx82WZJApx0ki4m+VSyFSumdrLIxnR885u97W/XdaL9ebwLK0+If4t1RuhCZjyo0EknpXPJF74wvvYccQTwpS+lfLQtxCoXyjvmmGMgciBRTl31mGOOwT8mg6g40TaZyMiLX5w6OyecUA5S5lbSPmeJHq/bNaWyqU3GZDNeZGSiJz3ani98Afj858d3vLLIiBDAX/+q/44iE6VZtgw46KD8c9nOCP37He9ICa5vfnNxmzsd0+GTheSKnJEqAm9TbfZE4+MeXXGFzl44++yJOfcTTwDbblt8P8djjz4K7LknsOOOwP33T955JtPoe97pmOPreFFL31ho81S2FLNRz/HaRC2cb755Yo4zAbZFZtNMmRU94I0b0/TIovg9Z1UdHc4ZKXOMvNUAdUaKVg0jI+lkXpRO3AsyMpmrl4kegMoiI1/7GvB//2duSydIGiIrca540yb3WvJUbik/pt02BzzZr4sEoSbCWbX3m6zVqX0e6ZA/8ECaRSWvhWagTQSv5LLLUrn/k08e/7Hy7E9/St+tBx6YmD49FWJgNhJC/x5vv/CNhU8FZOSaa9JEh83Jc3rkkXTusu/JFuSw9Z0RatQZ4TrKmWcCp50GvPSl/mP4OpgPVvRZlTANnYjKOiNFnfCcc4D3vMfkHHBmOyPLlhVzEyZzBV7leKtXF6dLl0VG/uM/zL+jyHQoyziwpO0X/uUB93nnZVPRfpckZp+QjsnmCNPYba5YN2Z4rItN7RKTiN3P5WT7hjekGjYf/nD6Nw2VTcSKVJJzqeOZZ5s2AUuW6L87HeA3vykOv0xk5glgpo33YtdeW71P0P40mciIbzzZkpwR2paNG4FXvnJ8mZdV79+++6Zzl72gmUx0r6JtOS3ZEox08FXrGWfghz9M/60Sv5+AtijbnMjIX/7ib4fvfFdckcLXNB2Zs4l0Rn79a+Db39bHJMcT06fjj/csxxPrPIP5058O7LJLPp+DtHV4o38yE7azGUXmtZVwRjqj+l7f+OBKdMese583oZBn++SaTfi/ax/Wv8nJrEidkhxjdFNvE/ey1cPmFxWckU6U4OCPX45DPnE54iR/1Tg2at0bOaj+/e/pv7KAJ3VGitqyZEnKk8hDsSosKjaMdbHxwENSrph0SD7+ceAlLynOuqPPZyIyzlqt9F6cfHKq71PVnvlMPzL3kY8Az3626zTRa+h0jPfhjkdKIIV55kNkJyKb5kMfAs47r/p+QgCnnMLzMDjnoSp1oYx0wL338uOZfDZ/+pP5/UQlMkyA9Z0RAMvXjeB/z/6a0cG/9Pu7jW2SRCAZjxdZBMklCfCiF6W1GwAIbhXHOQZCGMd+YkXOiot05k7RKrHsoEtfCikyVuTxj1ePQ9qSJcDLXga89a3AH/+YfkcGpmDjRrzjm9fgeedf7e6bJKn4ULcLXHyx/xxkgv7drUuweiPvnI02GWeEXluJMM3Dy9apz404xrp11uSZ57iRdv737+7CfY9Zaq6AuQri7js5xlcuvxsbxqo7ip/5raVfU8EZWbVmGK+++XeYsX4NNoySc195ZTp5ZzV1xroxzv31bca+f39kDf5wJ6m5U6vh/uXDuPQ6MjAXtWWvvVKi6/z5fpXMCs7Ihy+6HtMfyvgechL46lfTf6Uwn8/ou95rVWL6ntXrqfjYRRf5ywHYtu225t8+0uQnPpHypX76U/N7uvhJEqM937+GEf5asqS8BoePqzZezsg996RZRB/8YPX9H3wwzer61KfcbEjufRsaqnb8ImRpzRpg772BPfbwIyd2/92Cavls9c5IO4px0YtPx2nn/JvxfTMwnYevX/0gwpKd81t/YV60opfsvvvS2iQ//CGwcSOuup0JH3DIiNXJr77rSe8p/nqvTgf7wmV3e7cDAEyfrj/T1WXB+UvZRCkxUmXeLNXtiZWmM/bpy76IkU6MO56wnDR63rxKn+S51ZIY7/nB9fjGK9+FVTeZk2FioRai2zXPUULc7bFH9fOpJTE2DJsr4tXrNmGsyw8yo8RxeHDZBjRjJo2SOiOcY0uutRHHuHtpdUG6VbYDxRDafTb4mU/hU7//Mr7984/jiruJUOJxxwE//7kSUXti3Sjq1vu0vp3g339KBLBqNXz+ivuxchV57kUIA/39pJM8jSzvjPz9JuIIyf3KTrZ0sdArMmKFGOO79Dv/5Jos02zp0tQ5+c1v3P1p4UcAm1auwV1LN6TIyqJFrhNvv8s5zsimEav//fSnKYL07/9eeFkA/MjIeMM0RB31G7+7LWdDxugzu/FG8zfGOfjtDY/gT/eUS9G98ZE1WLGKvI+cs0HPOTzs/g4giSJcdhuZW/rOyJZjG8civPNvbvx3Rt28NUs//7XSxzznkrvRjszOkhQhIzSG/MQT+OV1jENTwhnptv2hnP/+nRbAun/JWnz/2kfcSVraAQfoz4wzcufS9Tj/8vswNtZDBhJ9kd7znt5z5qkTkQ0E199nHutld6WoyIu/9Ff87nbiqJXNAiLPrSYSHHbh1/Cvv/gSpj3nKGOz0cB8qf94x1Lz2ZSI+489odvXSCKssEIejy9fh0/97h5230tu1QNMtxOhFZHnMjaGJBHY0LFi+JZtHNXf1ZMIg03PQHX//V4RrQFY/fzcc/19zLJpP0q1Qg5+8j78x89uw91PbsAjq4hzk8HPtSBAPTH7fRIEGB4j34Uh6rUArYg8214RBmrUGbH6zSoLNZveIc+8Kumd9s9enRHqDLTbuHu57k/JqtVYs6mD615+aupcvOQl7v6WaGB3rI0XffEvqfOyfHnKnaPttCF/OubFsfHe14XllL3rXem/ZbPf6PtEnsPKNSSdvxdnhIQ4vnOZX6X6vuXDOO93d+NjF9+JRIYUqZTAo4+aOzBtWfrEKpz23RsKm3TJbU/iVRdcixd+hqBpzPE2rV6nPnfW6M+0H9y1bCPe873r9G99zsiWY3EisGzGPOf7RA5i2YP8xMXnG78XDbBRbA7KSaw7xC2Pr3N3oLDe+vVoxMyLxDkj1oDYEAmEEIhidwUW0ok1ifGRX9+JF3/pr7jy7uU44twr8LcH01DC8FgXdzxKwgqMl33CF/+KL155P357M18d98n1OZOv7dXvsot/2zwjg7QYGcFYN8aylf7V/NeuJplBZcl0BjKS4Pj70mrTgyPmPVk+at7vP9z2hPlsSkwos8b0YFZPYjy2zOxjzTjCb29byu4bk+fdCAVaMbm+NWtw3UOrMdbJF1668G+aZ1JPYox0Yty+hOnnr3pVKqLFhLcGA7ffvfHbf2fbbFs0bYbx92s/cxkuOfE0/UX2nGphgHpSQOATAotmDRhO2eU3VCw0yYUyKYnYIqGu3mi+n9Pb5JlLJdyyJR3WrNGfJ8IZ6XTw0L0aSRQbhvG5y+/DM66/3Lt72xrD2HtO74E9seUgI86xymSbZSaEwKOPk4UIec9uI1yUjs25KmOkwOFQd4zlm412Ypz4pb/i61c/hO/+7RHc+Gg2dlNnxF7AMWPMUDeHgyYEhBBYP9LFGRel6bd0Tli5cp2zz8YV2uEdXsmEaQHcvXIUg11yX/rIyJZjnTgB4MqGiyhKV9577gm8/OW4dscDjN+N+LRle6x8FDGZ+Ec6EUBWAi/7CkOA7ZgrWQNmzyzhBkfLQ64lMc76ya047JwrsHaTOTgGpE0NMhh84Be3Y2TlGrzji6nn/eFf3YFr7yKTngfyA4CVHnLos8/5g3cf58UcGck9h88eXa4Hwq//4S7sffZluH+pq1zbyl4+Y+VM73ceSdcK0zQ5JxFANzQle5auGsYaSoL2TChxIhQPhU6c9STG8LC5kq/HMWohL3FPHc0GgCZBBB5547/iqvtWokae+YNL3JX6CuJANuIIJ3/r7zjxy3/FTY+uMTe8LYOvrTIPANCC6Yxct3h/rB3xI09CCNz4yBqsH+kiGtJhgVa3jQ9f+U2ccR3hIWT9JgwD41pkew2LY3Q7MQ5Yple6F/6xIDRp2cgSJuRJ+66FdnUi89oNZESSFQmycsMj1n2lRivcToQzEkWYO6Lfl+9dfgfWj/qfy0MrN2LZGlM0kMV26aRrtzMHGVm+1tq2Aopx59INGFtHFh3EGaH94Ib7zZpopYxcw2B3DB+72FV6fXTNJrSjRF1fTc6iZAy74tp7sW4kP5XZ54zc9OgaHPKJy7H32ZfhoI/rcbRB0MAlS92+0yZoyKY1xEkk/TQOQwxGerxr20TwKbS+MxIlxkOWlnSjlMT24IPAr36FW7bdS/129/ydnRezU9ecgZNv+Z2G7gCc+r83IMzLDnj4YYP02dm0CQ3WGWE6jtXJv3PV/fjlP57A+tEufn7zEuO3kEwUFOZOhofxh2/9G/70zbcBK1bg17csNV7qi//ChwYAOJOCtEUbc2BpbuBZssT9rsD+RkIyG9enA2fEhI12WZs6VonN7peWQ+ZNqDMiEuO504yPTt2EqGtJjKvv0A6d2MRPKG//4U047JwrcNuSdWiRZ15PItSs+9SMu6h7YFX6bAcCYRxr52UP4xt/fshwQN/yzb+5xyD3J4BQ13fh33n0SzCrvaYFv7frTWcbaZfftRy7fOBSvOqCa3HQx/+Ae1brQXPe6Ho881EzZi+ya08S4aysm1HXSW/e9ZKfYvc1ul8ZK8IS9psrbnG+ExTtspzY4XYXCVnYGMiILOhGkJFXf819Buo8ZFJcv7pHFVaLnzKbIG833bUEG9f5UcQHV25CzdpfMIs2Axmxw2AWMkJDusbz+0POwoWxDaNdTOu4JSViq198+6oSqse2kXHhwh9/GH+7U4c/5Zi+bP0YPvvbz+LmL52M/ZanaJsQAj+7Wju7TzzyJF7xVf18k6g8MnLmRf/AupFu6vAQowvUVsfd96+krcPDxBEmzkggBAa6+hrvfDiHL7eZre+MxAkGmQcroshQMp3R1i9aPYmd5JgumYxmtjcZE9XND6xASKcxe+d99zXK3Z/3i1swnxnDE44PYoVp6Mtor6Jr1ipf2tNXPYRtN67G3NENuOtnv8OsRoAjHtfx0t9d61eAbAjeGaErc8eYSayzovpLMbelu+9AhirYXAIA2G5DeuxHV48o9WAjWymHzxGTQaSWxKiR6/3JjSnsfccT65FY8fV6kmAGAUueWOYiNnEicPld6ertJV++xhhs6nHsrPYHo7Y3TdlAvWomyrJk5nzVfrUNg/BQhyYkTsXyDbxi7q02YgIXfh+IOhho8MPMB7/6B1z99bfivX+5UG0rbe7IBgxag3W8KM3uEMI9TzPuokba3IkTHPnzbzvb+EwIgdWDZnXwdctch5qmLkeWg7lxzLynBjKyYQPufWIdlpBLmtbx97ulJNz4SEZsLkp3dsxyJigyMtQZA9auM7cnfSiKE6NPAYBgCk+OriR9wHZGLGRkI0kXp/0LFUuDPLRiGDtsINyw7Do7UWK8/4WhPMYo+jx7bCMOfzh1Is+48Gbs+sFLcfGtSzHyyGN45Z1/wtzRDTj6oZvQiQT+8fg63HK3dgZmjm3CQ4TvdOtj7rsyxMw7QPqcFwyvxgFP6nF3wfBqfOZSnc3U7LiO9WPkfJs2kr5FHKzX3n45PnbF1/Vx4q6xcJ5K2+qdkW47wsyOu2pNotiAVLcZWac+15IYwsZGiOMShTUjTGOjBA4SY63MV65Yx6Ig0ajbeUcsPYhajjMSesI0c1ZpOPqiX1+PU666CPusfER9Ny0ntln3EHObcRddhrcCAJ22Oyl8+eJbvOfwGR3c6tnkWmccne2GdRxZDhBf+J2GX9et8a8QDWdEJAYh8otXpoPFi7/0VwchqiUxGkI/57GRMfzlftPh+tH1JuJAHbh6EjuDqW9lL4QwBvcmhDHxLpuxTXZM3Z4GM1CbnCJ9vJkDBPUhK/a7H3Mn6xseMAnEraiNoSZfdeLsP34LO61bhnf/7UeAEMb1bbNpHeaNms8lypyRRAjnfrfiruoDALB6uI3d1pgZaa0cB3m06zp/tVF3XOiQrKXzf2MiN8OOM2Lu/9Lzr8Qass3Mtp9Q++DSderzQGcUZ//qDjz9k1c4JNk8W7PBdHbmkTFsqDuGgQ3rzB3IODTajU2HAUASuNPFu7/1F/2HXQuK9KH/u+4R43j1JMbGdlQ9YwVA6zKzvtd//jgNgXXixLvgKmtdK2yx3/IHsX6ki0sy8vu7fvQPBHfosWPXNU+gGydYNdzGYUt0goD9bLtMFpzPGV2xYQwX/vjD+M3334sT7k7v78eu+DoOW6oR6gbjyND7u4loIv3pDvM9eM4jWt+kGXXxfzc8ji3BtnpnJBrmJyLRjYyX6QUZcRFIX6RVwyZKQeHZDa1pxqJkwJpEmlFXE0yZybwVdSEYHsNtDKR28U3mhEYnsNBayQSCf1EbG/Vqb8Hwavz7Xy809stbwfmyd5pxFyMdfjC45RF3EnvgQX9Kss9GSXqgDMU0swm3e8KLsekZzwIAnPOHr2LbDB1pZFD/Fbdq+H7tKj8MTomhtSQxXvgn1+sXvmE5QfUkxo0PrDT+fuO3r8ebvnO9Suf7vcU7alirOjtUZyMF0h5dPQKaif7EmhFj4t1m07rsmDR1152Y6Uo49DiZa1dqhGe74VWGQyWEcJycgW4Hgw2eJHfAMr3yO+6B6w1nZN6I+0wk1B0z52nGXQwQZGeEiYU3466XWL1iQ1v1HWnt9S6PKST37fp7TDLxxnZkoAc2DN+KuobDmeeM0L4QD2/ED657FKs3dfC9vz3i3ce2y+8036kWcbaGumOYH5nnHyOkx5FObCBNABz0DzD7pLCdEdKH/vHIaqwgPJFaEuOCqx7E93/tZpP84LpHne+ozVplXtetj67G/cuHsXJ4zGgz53AXmb3g22XNUpz87euM78RS/dwPWXoPvvzHB3DWj2/By++6Sn2/aNhagAbu+yS5G/cuG8YDK/S923vlI9hjdeogvOyuq9CKOnjRfWZIL2DQXDo2yXBikgh88mJ/VlAz7jqLoqmyrd4ZSTypqUkUe0lVtSTBj280vcmoa77of3twFV7w+T/jpkfXuINSTOKBzDlacYeF0ZcsW+dAtZGFoHz1V+fhmz//BGpJjHoeMkImT+psLF7vkr7sFTnVuqj5wjRxNyXuMvb3+91U3mmdkcpwYUJCBsfffx2mt0fU6jgYHISYM0f9/oZ/pKspOZ4aIREPXAoAXfJcayLmoubqN/vvmDhq8nlefd9KnPbdG/D7O5dh3x9egNP/rrlCdKJqJJEzmDYyB8W+T4mFjIQiMcI007qjCERiDdTms9nYjpxjSKMI15nf+LP6vNvqJfjAL25Xf8eJi1gMRB0MeVKEd1mrJ5XDn7gLA4RYN3tsGHctMLOs4uxZCAYZaUZdBOT+bb/BddxbcRfv+hGvennupXc779wjj7n9lCrT2qHITZ3ImLBpbB5IQ2c0yymPwzIt1M/4xjtIFkyFV8TXV4F0jNpttcnT+o/v6gVXO3LDNBIZoQuv4x7Q2Sdr1/qRkZpIkESR8fdgs4YZDCp99q/uYLMBpQ3PmGv8XUsSPO9zf8Zx5//ZaLPqI2vXAhdeWIoIvHGD6aBtO7wSdzxhLlhry3S/3WH9ctzw8CoseNJ0oHawxtFO1x0L5SL1+M//GcedfzXuWZaeh5Ku91z1KHZdw/DpWGeEPK+sb96zbDg3XNWMu7jryep6QpNhW70zAh90m0TelE97IBdCICAPfKg7hh+e/3/41GdOx3kf/o4z6LSijnJGvnGFy/Af6HbY+LZod3D2r00vd9F0EwJftHENnvfA37H/sgeYMA2PjEzr6o5NvXtpNg+DsvBtkpu0ZtTFpjZ//2YwqP30zii62bE2tiNcfOtSb5hHmfV8Fmxco9oaNptY9bFz1W9HPpbCwRf+/TG8+//+YdzfMIfA+tMb9KqhnlgDdA6SUE9itIiDYveZj33lMnzgqu/iQ1d9Jx24hDBg/Vrihg2AdAIbtSDfRAhrEE4c/ok9INlIzmgnNq7BdEb09+tWaGRk/iaTBxMxxNKBqI2FM8uls9L3ZEZ7E+Js8vvTrocBAJatTSeKxMMZoddE+SfSWlEH9yzjs7YeeHKdctau2elAAMBQt21kyDy5fhSPLtcDd8t6R5NEGCRP6lzJ7ZtkQs7jsEwnzkh3vT5nkqXtj3pQR2q+ECoADHVGsWCpOYE++PAypborhHCQEXlpXZIOeuI9OkzjlC9IqHMrEJDnU0titOohy5sIROIdOwAgsVBjY1yzQkEAgP/+77Rm0Ste4T0mAKwb6WDdetMZ2Y5xapsrNKLZiiMs2LgG+y8308bt/tdlFmb2IvU/f3YbHls9gj1W6TFnp3XLcNqNTAp95Dqyxljc7eKmR9fiRV/8S6Ez0qxtGW7AltGKKbTAg35cdeeThidPrZbEOHJXrU0SJQKhAYFH+MBV/4uDn7wPP/vhf7DOyK1L1kEIgS//3nVGfMhII+niIiuzocvwLwBg7uiGXGeETo55YRh5PdQxoAO0Ly6bh4zUmSTBoc4Y2lGCux94Es/48MV414/+gT0+9LvcdgUWQ71Tbyg0IWw2IHbdFceenpK1Dl16L/Ze8TAuuPpBJ1sozxlZS2L0YZIgAD9hy8+dWsqvqCWxEWqznycdhGeNbcSssY2YQZ5Dyhlx718z7joppIkw2xIIYYRp6knkcGnsME03TthBfec1TyAk3Ak6gBqwsBB4fM2IGvhEPfU4B6IOZgzwnBHbTGdkRDlnG1qpGvDqLFXazppIrydi7xe1Ztz1pkY/a8dZ6vP67HzTOqOqDwshcPuS9cY5WtaEI4RJ8rTf+4Fu23BAGnGkCNXUfnHzEoMLRvcRAF74hb/gsHMux5pNHTy+xr/aD+F35oe6bTTao9Z3o1i+3kMyBUFGAh7p+ts9y3De78h4Rp3bJDZS3WsiQZQIduwZ6HYw7BnXgHRRRs3gyXGfP/e59N+Cmjxv/d6NjoO43fAqzN+4Bp++9AvYK+PRtR8zkYoDlz2AL/7mv43vWrGZ3cVxRoas/lEPA1x9/0rstcp0El94rysF0YgjJ+WehuHR7eI7f011g3KdkaiLneZVlKWfJOs7Ix7OQy1J0Pa8EHWLwNqJTAi8GUc46Mn71N92rL8Zd3Ha/96A7/3tEdbpaEU8MsJtaxOupA1022haKrILp2siooGM5IQpgNRxoSJv1DGxZbmltWI/MsIhTtM7o/jenx/ETvvugjv+55VKGyTPAut+hEmiSYyNBmpBgIfnbIf1rVS/4l8e1PFpwxlhmOnqHIYCa2yILdAwitxubDA91zYj6w0Wuz1RNhP9fOeOrMfsMXPFXvdomjTiKNPG0ZYIYWRr1URshAMaSYy6FUaykZqulT0RCIFDnrgHV33zbTjrS/9PfU/7Si1JsOPcdCB72VeuwfM+92c98M1MM1MGog6fBWJlgQ1028Y1zGhvUtkoGwbSe7pu4xjuWroBiXCdEY7wa1sryuExPahh9fUDqTMy2G1jU7b9mRf9A//6g5sMp64Zdw1nQsAkedrOyMz2JgNNSUne7r056ye3GmRc2leve2g17l+xESOdGId+4nI8+zN/wt0emL2WE9IZiNpojJmOwLTOGNYQbSIb7ZPOSeRJL2/EEb5+NVGOtpCREaLwW0tiRHHCprcOdcewMadys7DEH2uWIy6tnglAJuSZPbDCr2d046NrnTF2IOrgc7/9LF57++X4/XfOxKzRYYcP8prb+NRk6qyOMHQAm0v4ogO2xbRmTSEjMhw2g3HYakmMV37tWvM7ujjqRgrlyiPytnISDTa3bfXOiC9ME4oEHQ+fxIYvbWeknkTG36+zOqtctf6v1xnpshMR56Bs9FRX5WBqkIGvbjgjxcjIimH94tABNMxJ7Y08jkrExE+ndUbxg9/9Q60W3nONp1AZMRvVMiakRgO1WgAEAb57WCp1TSFXet/rbb8zZoa2TGSEThgKGdlrbwDA4nXLjedlP096/vN/e74zKNc9K/16ErvISOKST43MnDgy2iqvhVqKjJihnrfc+GsAwAH33qS+N5ARCMxu1fDwqk24NVNqVW3Oahs1o65BApY2Ymlc2GTOGe0R1S+lc1BLEnzpj/dDCHeAbSQR+y59/5jX46KD0tRRDlWS9sQK3Z7jj9pHXeumbFKU2RTUqWtFHawiqqspMqKPaS9Cttm0zpigmrH/HaGOLkWx/vHYOmfbH3uyIQI7zALgLzsdnLWt7WRktKIOosxxFMJFRrhMNbPN1v23SinY79JPblzCLoQGoza6UY4nZTkj3jBNHOFlX7nGqCl23Pl/Rp5JZ3Fs733Vd0c9qmsenXntj7FgY4pIPLHjHgCA5xHeTHLhRc6xALPUgrRmYr6X51xyNz72/WtU9t+nj3mT+u2yPY809rUXgUkiHM7IhixzK89Jb8VdDOeI321O2+qdkYCSzH76UyTb7wAgfYBrh/lJ2h70rn1otROmoS/F0Q/fbGwvV60BmBcY2aolO8eDTz8aq/c/BEA6odmQ2oq1PCN/hqV1AgAJ6ZSygx7w5P144X2u+NIHjz/DuB6aUlgGGWnGkZdsFzOy9kPdMcMpOHDZfc42jlnnriWxvp8ZMgIAq6alEDzN0KADRSMPGaHHF4mFlJgrPwCYPS89V8ph8Gse0N/mj6xzYueNJGYHfy8yYjkjFBmpi8Q5vz3RdCKXBDtAJtM/3pMiB7bjmsQxHlppytgDQJBVJA0h2HDn/1x8u/H3s8iADwBzRjcox3RDhmyFIsFgo4Y4cbNpfGGttYcegRXTU8JjHkdDTvhRWMPchen2g90xp6wDfSatqGvovgiYnBE7rr/bmiVmv4sjFhlJr4dyS/LDT3ZKsbSIEdqSad4D3TbGrGyhVtRR77aAcJ2RrE2+LBVn0iPvZyDMtNu6SPDYmhFMYwisNmJgW2CharXEfQ/T72PcTeThy5h8L1d95wf4886HOL8fuOwB5Yw8trf5+9nPezvCk16PJEzDWDsQqtQmz4Rv95HdV6WO5fJZ83HhwS/Ck9PnYbg5iE8e+xZsaOqxXz6LsW6MNZs66FqZfkHUVQrc9nP5zxe8y/h77fpNWJ+jkry5rO+MZKv0FbMXAK96FYKBVC8kTBKs3cA7IzVL9OxrVz1YKaVMIiNBEPDckDhSg+Nup7waD7/hdPX9ghktY1v7xZT2vqu/5w50sbuC+M3336uv44hXYaTRwvcPOQEXHfxC/PnkM7PridDu6n2jxHzhOcsb+Fcz6ZWD3TEMEqfgWY/eVpg6YIdp6oJM4I2GKpXxxMwFAIAX3vc3tVo0VqjdNt76PTfF0NbvqCVmNg19dspJybRpGnFk3IOaSBAmFOLX+96y7Z7OJO+Tnm8kEcMZEcYqOLT0UOzrTbcx762NjASWg/Pm796YXp4Nq3e7Rj01NTGQiq9ctetr7jHTMxduNOPfFMVaNzBDHXvmYMPUGdlpJwCpM8G9d6sXbK9UYO17QE0+y6jeUJpBzTiCgDCKXtKBvRV10CZcACFgIGcyTCPDhLusMVOB87R4qNMjHey5I+txyBP3OO9Fs87zYASzUFg1bXbatqjtcBZaVtjIRs9kf2TrZnHf5yAjZ1/5TQC8htFgt+3qOBELnb5M+z69bzGOfch8rzm0iJp8Z5tDg3hg3mLn9wOW3Y+6SJAgwJP7mc7IXQt2BQCITGV3FvT94JARAKngphCYNZo6hntmfJF75i7GxtYQjn/LV3Dsv34Dj89ehJNefy7GXvM6dW0QAs/5zJ9w6Ccux5K1o6Yz0o2Uo0z77Pte8E785KDnY//3/ERfc9TFCINWb27b6p2Rv2Q1WDq1jGSXEe9qIkbcSTvmlbs9zdinLhLjRZszrWk4I0MFYQ/Z4X3ISCOO9PfNJtBsqe9tByPwQKdxEOIjVuaNMWElCV5iZc5ExxyLfc/6OT7y/Hekpx4aUOelcHKXcWq4a/QNJ1yYZrDbdkIVnNYEtdCpy5MYyIgU27pxBw25nnLzJQCA2aN6VTgQdXDFXctZYqidpUJh1XktPQmoSagl71nXGZwbBjJlhnhsfkHDs9Kvx5wzAtiZMLYzaIftbCcy5YyYz9V+tsNjXWfySBx9lazNtPw8g4TVPeHRe7fZEYBOzY2mTcexB+6grqseBmY2zVveAiDNDrJDUQCwZpvtFKk4z0GWE21Uq6fvXHYtQgAjbf65TeuOGX1cAIbei3ymM3dLHaZFw+YqvRFHDvKi2pOYCAoAfPtnH8cvf/j/8IL7/oYDnrwfX//FOdh2w0ovusLJ9a8aSpG7gaijEIh2Nva1oo5KqRVW30+vPUaYuPojqp12f7UQC5r+3oq72GXNE2w2jZ2FZFvYdd97eh5pzbiLr//yXGPbbTbljynyXoetJh6ct4Pzu3TgVk2bjceecYzxm3RGkswZqZHF1cYxvu8Ndcfw3r9ehFu/+Hoc/dBNirx6X/YebBiYjlXTUomCOxbtjs7nPq/2XTCtrsLnV9270grTRAoZl+/6LdvugR9nIcuRhl7UcnPQVFjfGbkzdUbGRHYrsrS1epKoSXO04aYm0lXus3c18965dDAA2LAo7dxqhRaAHUDT+Hd2/GYTB+66TfZ91wm9cKsfALhh8X4OWY+GkupJjHN+/1Xj98F5s42/o0zi3naCzDCNnzPis5DZZ6g75jgjufVtACdMY3NGprfSQXZDxjkAgBPvTmPG80bNQYlbNTspsyI2hbEi06EAAAzKVbXL+6HOCf080O0Y6dXptfAciEYSO6tpLkzDybIbx7He/I6FjIQiMfoLALzluze6k0fXDMep8xL14pBxRuy6O9LuWLhb+rskS86chUVzp2Xfpcc2kJHsPKGlOittj53moy2dkZw+efYf05X69NGNQEP3ewAq5dy4PqSKpsZ8bSFpclINtt8egNufyyIjz82I14c8eS8A4JiHbsJvvv9eHH//dfivK76On93E13XinJF1meT9YLetkZsMeWpFXXQlZwRuKM9WIJZ2xSe+6rQZAK5/UI+DYZI4Id2BqM3y1bhyG0Y7bMfa4qLQ49s2e5Qn+wLAzFaoFgxz5840kJG/7Xigoa+yfPpcJHPm4qf7HwcA+PKRr8FoM50nREs6I7qdMRMyA9I+8O6/pfy4r/3qXIWM3LfNTs62573iAMycrt+rgDhlkZUNdwPRcpJ9Ng5q+NYph+Oy9zwbSVhDlJGtm1G3kn7NZNlW74zIB9WVyEjmjIQiUSJLA3NnOfuF5MWLrRfUlrEGUnRlYJ89AeiJLwwCD1E1QkOujBoNNIcGs/2YwcuXzcJMroE12UQ1M+WyM6Bjkqc+c2fEWeyzkcTGCu7C63R6sT1g6WvosmmLABAwbR6IXGTEBwcDKWFreNRd7dNsGmovfeNnAQAHL70XQ51Ro04HkK7UbGjYyVKxkBE6GKiJPLuHTStMA1hy7NQZidrOJJ/yXzjOCKM/I4STcuyKj1lphPZzEzbcbZMXI1z/yBpn8hCR5YyQMFnSSBGGoMs4Ix6U4qG55mo0mjETB+2UptHLiSZJiAYGKTzHiYhtP2cQ//aC/QC4uiDUjn1Ik3QlMtJIYjy8ahPOu1TLcFNnZO7IBqPPpMiIG6ZB5owsHLadkcjvjFirVYq20oydvVc87L0mYS1c/vewE9WKeIAgkYML09pFrbhjiI05fQR8cbeF81Jn315hX3CV1t7gnNtpnVF1vJhcU1FWlB328/Vbrj9sG/lVb9u0ds5Ay3BGHpmzHVZM1yKKy6fPRSMM8MEXnIHXvv48fO6ok9VvIgvzUTFFX3iIjv9D3TYOeyLta7duu4ez7eufvqNC7gETFY8S0xFOjEy+dLsorGH3BdOx96LUIZXFPfMQw81pW70zIgf3rhWmqSexckbCadPwvhe8Ex//l9PVfjXy4nVy0tCk3bFwNwQtvWoG8sI0BOJvNvXgGEcGXwNAjjPidjCbdb7GKgzWISXcP/aS/TB3zgzVHhqmkZkFgH/gyIvPczyToY47IefpRjy82q0qWqcTuOWM3LrdXljfmoa6SLDdhpWuM8KsDuyMgkYcGQN0EDHOCEFGnDCNh9A6yDpirhy8vZ80O5wUCncVavcHG4I3riH7TDUzJLLyApvszPB20g91JNkz4HhNnRE+g+mBbcw4fTxzFsJGPWtTWjU5EQTly3FGEgSohcB2C2cDSFeALz14O/a8hilkpIt3/ugf+OU/dG0Ps75PBDsWaUyG0gHcLj2nXQOLfZ/Vsc3nTNNJW8SxzHPYJWq6afos7Py+3+K/jnsbRqUzEnWUgzpj+4XZcQmB1dMuriRBfVCHcwHggRUbcdkdT5pkUpE4KsU0Y+qc407HrYvSCTiVTvBbzerLZphGf6ahWGmNnMw5Y8waGMDX3vsC9efawRl4csZ89ffjsxehXgvRrTXw9x0PUAs3AJo3RhwCbgEGuGjdQNTBsulzWWQkPage10Ly7DuRSRC2S0sAQFSrqRIhF731CCBbLBQRpDeX9Z0R4jUCQECQESk3PjjYwp0vejWue9Hr1H414pV2O7xnecVuT8Mf9ngG/rbjgfj6Ea9UA6ecGMIg4MM0sRmmkYS6RhI5Msm+QaMZd3HIjrON7+zUzSWzFhq/dwemGX/vv4sssBYbg+Zbj9Iy3XkEVt+AYq+QAD5Mk7dCGmrWDDRAtqWe8MgIACybka6wFw2vNsqpAzCyT6SlYRr/Npd9423AihQOVSuflh6YbWeiYfFEpNXjWKU4jg5JsiYJOV11FXDwweq49n1NEptoW4yMcM8gsFAg0xlp45An7jGKDgJA0jUnjhpxBpOM61SzspWeWDfqJXnfPd+SgJ81S6GVChmh6qAkHGRnJpz66o+lg6987+IOZg26/cIJdUrOSPYOzmhvwsysv1Anr2ZNmimBVZuNjNiWoofkWhOBK7Iqzva4sOM6rfr5yjv/pD6HOdO2kAJ0QYD3HJeloR66s2qbat/cNMycIq/Z8TwLAfsdvXv/I9DMSP/y3Tvu/Kvx9h/ebPSnQLjZOZQn1mkNIs4Y50XIiOOMECeHhmxoX5WOTtD1I7aSQ5OEIdBo4Om7zsMFR7wSj81aiO8e9hIsnbmN2vahudujUfMQh7P+VifOMef8Azxa99jsRQBTBwiAehcAICT3IUrMMKtRvZ2EaeRhn7n7NhgaTPu5dPKn2spJI/4Tm4oLZ3FlRWBNEi3OVavh4jOOSjtxpv9khGk8TOQnZi3AR5/3DvV3MCidkSy1NwAGGJ0Og8DaaBjIiON7ZC/fuj33RXfJUszPKnMORG3sMMdMA7YL5TUS80XoDA4BWKu3p4gMcYIGSa0RH5mtFXfxpSvvx+E7zcGMAXMCCJjBZiBqO6uuIl0DGxkx0mEZZ2T59HnYa9VjWLhxDaa3zVUqxyeIEzNLhdNuEe97H7DwVdppkavEJMrljBh6JUmEoYwzMjZtBgZHhlEXRA5+7lwSOnD7WmxxRgKOM2KFSuyVms0RCK2V7EDUweGkKqnazlIRVU50vQ7hQUb+dM8KFvWJghBPzFqA4eagEnpKZs3WzojQzkhTtjW7L+k1ms7IusEZCIKAZMd0kTCTQtzuqIFw+Io/Ycbq1MFsJhECkeCqr5+OOaPD2Offf244CbUkMZwJAVNCXbVnOx6NaWTZOtIuuv4xnP2rOwAhnBDJ4vXL7N0B+MOkACAyx0KEId793D3w4gO3w64PpqT2oe4Y44yQMA153x9ZsBN2XvFotl+6z1i9iVe84X+w53MOw3taaVg6L328ZqX2AqkzIt/D9tB0dMMMlfYo06pjWe/qnBEdFqeT/vbr0+f45PR5GGvIJIAuokSwjoR8v7vNFlrZrP2pY07Dp445DYBOiwaA+7fZEXvUPWv5jLw9NKpDQl5khHkPKALjWBhChCGCJEnDNNkw142FtcBhkJGwZvo41ns11bZVIyNJIpQ335Uwm1qFxcoZEbUawjBArRYikQRXKnjl8eT3OnhP84uBjPtB64Ywk6AhhkPCNGxsL+vk8cAgnvbOH+KEU78AIM1EsQuq2dkSTYtE+LS9FlkN0eelBNbEQFh8YZoubn5sHT7+m3QCE0Lgrd+7Ee/98S1qVT520huAyy4DkA6OMywHoUje211pjZlOnGVSb2L+prVK3VO1N+44YRo7S4XTPxCrV5ttGcw4I1HX5YwYtTnMVHC5QhybNkNta1xLdj2cg2anlNaT2Fkx26gO5xDacDftH62ogwWbdPqtfA/sWDhFRkTWf0LLERJCsOGF4dY0xGFNiZwBQEKQkVCkk79RfqFWU06PjYw8MG9xOrlmzkgr6rrOPIC/3EYK0R12GEFGIsxoj2De6AaEENhj1WPGhGsrMdsopSI7z5ihlHmN3+OuirJGcZI6IuAdzp1IUUFqvtpQgCawiiBEEATYfcF0hNPTdswaG9Z9ZF6KGLbiDv5w13JsbEfGpH7GO7+CJLsnkrvSCeu4a+Gu6LYGFNG9GUeYRosiktsRMlo3g1Fbid2NDU1XoY5Czog1bu1IHDV6P2QiwZqhWehkjk4z7nozmCR6GDV16I9WD/hjllX55PR5uGGH/VD3KNEm26TOxCxau8mXgcS8B08SBIbfKXPyyX2KbGeEQUaiWt2s5G4hjlNtW7UzIqBXcjaBtSYS5c0K0ulEth11QAIPCW3mLovx4RP2UX+HA3pQBFKdEW7CTTUTOGeEmZzlAJi18ZHZ2wJI5cibm8yYqT3Z2MjI8/ZdiG+ecjj+8p/H6nNDhmkIOYrJnvj7IccAgGZoZxPx3x9OJ7BT//cGXHH3cvzyH09oT3z2bBV+GOq2HRXOepJ4a29wCpEz2puMbBrbpHjWzPZGh4jZjFwCq00M5Qh9D6xM2ywH9mBAIyP2QEPTNQ1INY4UX2ZUOiNJbPKGJI8hccXk7Gwa6gTJTBIb1SnDGaH9Y6DbxoKN6eB6zrFvRpw5XbXYDFWofkuQkdByuBPB9+U5mST+yGxd90lQZEQ63jFJE63VVD+VK/2RQ5+GA97zY4w0B9OJJ3smTabiMQD84aaUBJogQDgwYNxr2k8OfvI+c5AXZtaHdzXfamFk5mzna4rU3PCInriowxlPT/vDjkw1bSCtQWXzn5TJMA2dUTMxOkNinIRp/vbgapx50c0GOVKEIUTddPi6hPy+y7azs3ZHRu0fA2mzRLkAYIAsQLrTpqtQedkwTZyFAQ0nn54z65lrBmeq9jYZ0UDVHoKMqOOR67lm54Px2tefh9eddB7isOYP02yTOhOzNxHExnNOboG5enAWPvWKA7DfdjOZPXTdpxpBHFOROj5Mo5CRIGSdkTCTzZ9q27qdESGI8qKlM5LESlRLEAaz/ByWQEa6CxYZg1VAYtdA6nX7OCNqsG5oESYb1gVIvDvrZJtaQ1iZCRvNW27KRNuaGdIp+t6hJ+CMd1+AIAjwvH0XYnFWb4SmONLVhLBWPABw83Nfht3/36/wyX9JdR9kKErCvlffp9P8lEpnrW7oUdhVYOtJlFujwhbumtEe1RM454xknJiZY5tUEbYkO78dvwdcZISzh9aMZm3JHNdBOfEx2TRk0KTiTHWRKKRGIiM1YfFfSMjMtpTAahJtpfkEv7g+ayNnlPQ6QJCRFdPnKkejEZmIkkJG6lqvo2al9nK1ZaR965TDUdtWI3TCQkaAND6uHOt6XT1rFXaYOQPDmePZTWxkxH2eMkTXrjdRC0PjXs9ONNoyc2yjsXioJ1as3bfCbDYxMnOO83WDqBTTopIUGUlmpZl8i9fxYRrArLlETSI1gmSqUI4NkKXvZ++AnIyvunelcmSAlEMhn7d0mmkmXq2lFy30fjgE1uz+PDo/JSkPddvqPTz8oF0MZyTvrZNocpI5VvR+cVkr66bPUmTqRuLPYOKckcDibvx9xwPw6Jw07GbX/lL7ZP2tFnWxYkMWevaMI5wzsm5wOg7cYTZ++86jHN4fADVH2e+wrxCqSu31hWkKnL/NZVu1MwLoB9XhkBHZaRlkxHiAnkFobMEiY/ALBmWKruaM+IqhcWEaNq0zcdu4amg2AGBw2FwxOZyR7ByX7nUUHtx5HzhGwjS+FWCdwOVRra4EpmQoqsusRBXEXg+NwXGhpcPQiCPUPVVWbY4DwCMjb36WJkTKCWreyHpNoMwg1VbkEm4ThnTntiNtn3T0aMaUK3rGZN+QtgMaGWnEEVoMMsIhabnISMaYt5GRUAizyJvleAUiMdo/SJCRldPmoj6crvqee/c1AJj+0GhAZIO6rZgpBN+XzzrhvThu34UYmaNhajF7joGMCAh0Y8LNoGGaLNRFFw/dKLE4I85pCW+sng7WxAmfTUI/rchUeU2VmMkBfYN6q4XRGbOdr5sknXyMKBxTRy2ZmTojO1rOyAMkBZqGtagpnZHARUakdVuDBnIkjXIcRBCqeyLDiZLfAcBAkqiZ6eb6XYqyPj7UHVOckVOOPwD77JgiYoXISNbOJEPnTLTKfV9PfO5BOO7gHdM25qRTyzBs1xOmsa3lcUbClg7zPf3cKwFYTtKxxyLaN00359KP1w/MQC0MHEdIWYZS2YKXNilemgrT9DkjW7bJFyh2OCOJetiiRpGR7PcSyMjGHXcxB7+WFaaBJ5smsRVYs85tSYoDBO0gzsjGrIbBwIgZ9rBXKvIcXTuWKK1JVzz5nJE4G5w6lrPGvfiy8we1OlCrIc4yUBYOr2G385n9+/TOiJNN84EX7Y2fvC0tMiXDNNsOE1G6LF7O6aJwkL7PtM6IloO3B2ejUrB1rllZtsZYlk1jrJgIZ6RhT4Bws2maBjIidSVcoSj78uxsK9qGF9/zF+y2JhXXWjF9jorbn3HVD4xj1EmYRiEjXTtMI9S9uWanA/Gakz6Fo//1G/jF/s8FAMMZwZw5zqAZJ0T0rFbTyIh0HOoaFYsSQRy5mH2mss1RWEthedLvZ0SaVN2K2g4xkB4t8PWXVgujHmRE7jJGZOXlOUQYQmQFB6ny7cqh2XjZKefjmp0OTK/bV8tFpulSZMR2RgYGtbNGw2nkvX36bttAZE6tyn7J3vMA8KJ2toiefH5jmRbP3JH1KvTZmjcX22Z6JXa5DdvqWd+Ls2up57xXAID58/XCKuqyRfiEEBoZIeqk7LiY2UBD82Nee/hifP2NhwEAgqbub+o4mXO39qhjgD/+EdEeaXbPLCurD0jJwdIJYs+eOdv2+GLU/qHIiJDOCM8ZkVysqbat2hkR0J1Eie5ICEzoMA1qBBnJnBaaGskxpS/d85mIWgMmLMysQDgeQtMO05CMAUe50grTAMCmZobAjJodnbYzJbBm8HStYcRGlVlKlOqUBiyfZThkHdsmoa1jCjCFZFULQPEPFlj1Sbg0VmmCqKOuy1aG09sjOptDtr0W4um7pDFx6YxstyFN+RtpDgBDJlplX2cRMpIEFjKSIT3NuOtoe+St4CQyIsM0xgRjac1c+5CJIKVhGv035XpIZMQhsIrECVmEoJwik2RKK09LIrA0NkzTaEA0ec5IioxIRLKB6xfvj0fnbKdi5JQzkuywAxk0tYNr9KHM+ZArW0FCdN2YOCNxxIZp6MoxDAKj388izshA1DHeVwcZ8Y3ozSZGCzgjbSLxL9EXUW8gmWaiHq856VN41jv+FxtbQxjNHE1O+wMgiwZKtGw0DE2MqDVgIEf6WnR73n/CfgR9cjkjFLUzi/ZZzkhiOiMyLBsFYeokeSZZ22SYRgzKMI076RtGnJFGUpEzkuOM0In9Ay/aG8fvl4YXA3IuZfazyO4554xQUTvWaMZnZgECIwxvlJ6IZf/mOSN9AusWYipdUHYSIgcv2coJRUZqrjPCISNnvfgsJIkwV2JKZ4So47Fhmq72bMlEJH+jJuSgYSAj2QQ7ZpI/TUJZbCEjTjOMCdBAoy2JdEDfPxn3zYtDKs5IJmaVZGiCFIVaq+Sp3QwXavIlkk7GjM5ors7IcCtzerJBcKQ1TaklcroodviDMxmmkfdWpm83I01Cln2GPjs7ti0HJRmmMcIqRjZNhM9fcb/TzoA4EtLJ7IY1NfHYzlZNJPjr/aZmiC2c5lNmHG6aq2uTwEo5IxnB0M6mgeZqqZR6aH+6PUMT95KddzHDNCJFO2okPCj7qSr8Rp59FCcGqsQlUtQNZwTGxDVIMrzscveObHlemGaWi4w0SQprbIQ+s37TqENMM+/1ymlzlHKmLFPhRUaIzoiyIDAmW4qM0D5CFy7TBptA9q5KZERy7ALDeYsNh8xG2uSYIJ0RGfbbNDAtffjZcdLt/O+d5oyk771d58mx7bc3HC5fmEaKyZmcEW8zDKMhlbDpLuLU+y4djabpjERBiD/uejgenrMtbli8X77uR8NFXoLAXOBwqb2x7N/SLC7WVNtW7YzQOLlCRggkvGLdiPEdoDNrDAck69xj02bgLa88G6e+6qMYawwgESaKoMWXZDYNP2mnglkeZ8RBRrITkJehnQ1WNnHQZFtrZKRTa/DxSZrBQb425L+lw5ZNenFQzIg3JhJouFWaFCc75/KvQXT4gZZm04w0tJOXm01jxdZHW4PGIMVlqfjEimxTyEh2Lc0kUvdXZKtbk29gISOKwJpOxMYEQ9CxJrNqFJbTJPtOHNYU0dBGaUIh8K4f/UMfwyoZH1qcEWlLZs4HggAPfvsiAMCDVmVTg8AqUxCt2HYi9KqxS1bp8hIePvJf8PishWkJdxKmke3bMNo1kRGbwErCNHtvO9PgXCVJet2f+p0r8Z7G1E1kZLCts06mWwqqts4I6+kAKTLCOCPUyadvn1zJJvUGYCEjq7NCd4CW8/apsFKdEWodwomIBgZ5ZCS2FmkqtTfjjFBkRKZwWzorgeWYyN9GszRnSYjeJMUWFTKSzxlRYawMhaT8CIlcbaAO8w47GPy3KBZOqFMIiowQzoiHNHLiQaZ2DN0slHLwBq/QfBaSWybF9NYPTMebX/VR/MvpX0e73lT9YlqLkQJTKuF2WIw4IxaCB2T9G31kZIs1+QATK0xTS2Jn0gT41F75WYQhrtz9CFyV5aMnQpiwsBWbTWPn7ovXpOXQGw0gCHQ6ly3rLbcjA44kkT6xfB0eWDFMtjUnm6ZCRjxhmjLIiArTpO2TKop5HVyhCNk1yTCNNBoGuOcXf4DP5HFkxojhxOUgI9JGB4Z0hlPUdRZjNqmTM7nqVJoNhJArhcxEpu2QxxlRbZJhmkiqQdbSZ5sdV3I/6GBqZ/3ISSWiyIgVpgkTJkxjcYo4x+e4t34tPf/8BWl7ojZfKK/RADJ+VWBNljRMExEipDxOZ/osPOdt38Qpr/1E1hg9aH73b4/gvN/dYxBY5apd3jPRaOCy9zwb//Pqg3DcPgv0SlIkuPXxtbj41qW44OoHdZtlxV7pGJGqvQNjFBkx08Frwsr68K0wWy2s21Y7bf997KnpaQihlq4FFKJWb0CQEg2dWkOhgIAmkXrDGszYAADdFnFGvARWE/FUqb0WZyRtgH7XfPyNUOjQ2ogK06zL/p5mHKeIMyL5eiLLApLXT9HG6zI+DQBg8WJjLHv7D2/C8z/3Z7St4nXy3aLICMcZ+dLrD8EXX3ew8R3dLmDC24GNYGftUYhoo5WO89k8JDl6n3jp/thjwXT8z6sP0icjJUuMNviQEUGcEdoV+gTWLccENBEusZERAisKwxnJBliGM5LQ+gRIJ23DA7dSe4XgkZEhmy9Azmt3HHV46oyQAkjHnf9n9b2piKizaTq1Rm6YxvbAOQKrHLTk5GfXoaAmHRUpvZ9Y6YZ09fetW1bCZ3KwG5POSNItpTMibaw1pCFqplCercAqbWS6bp9c/WnRM30tLTVopqtbE07m74/kjKg2yOtQTlPmpFhUBY7AGgeheh62wmxYQGANCXImbcnMBRjLUChBQo70vtUpMiIHTQsZSVEYCR0TPlb2bxBo0mUQgB00jYWCzBhSYZo69l40E686bAcD6QCAaIwp2pcdSzlGDS3iRcM0riifyRnxlWZAs4nHD3oGvn34S/H+48/E815yVHoawmGhK1Z5D0W9rhxZAFg7Y47htWjtDD6cJjgCK2xkxMMZSax9s7FgmhWmSS9E31+Dv2Er+mbHvGeTOdiMDJrISFE2TT1rp5AE1mx72n9/eUBKhn509iJTwTiO8MS6Udy/YqMTppSiZ50CZ6RZDx0k2YiEEQK0MtsZkZyRdkZcr+tzAnpc33mbabj8rKPxqsN09pR22syxyaszEmtnpE9g3YJNMfRDExkJRWyuvjITzMqfIiPUEiFwyjN3xtxpTZxy5E4OZyQR/ItnOBzKGZGITIKPXXwnXvqVa9CJEs16p2GaGq8tYRCc4kidp1Or54Zpmpa+iUFglchSdo80ZyQPGbE4IxYysuvbT1Wf8wYmDhnJ54yYzsjowBDL45GWcjFc2zBvgfosQ2JqIGi1nO2lM9IsgYzYzkgi01QlMhK5yAhgPVuSHaKREbueh4uMGFolSeSouD5J5LAHs1LmtThGm0tLbTQALg0eJuJEyXpCTcykTUHAxrZpmEYSZVWYptGEYXTlnrgTd12FtcyJt57ERpjGQUZsPQzfCrPZRFCv4RPPPR3/d/ALMG9eGoqjBFYDGZFObKOhVv8AsG76bOOwSj7d944o0UazF0ekj0YDxCGPKDJiOSNW+jRHYE3bTu+vibTJsUIS7KXZyEiRzogMVct7c/RDN2F6e8QYc/6+y8F4/evOxatO/kx6c5XDpd9Bmk4N8ARWbpHGkVqNSZ4UWlS/W+KUGDA5I6MNc9yYydRQkibHTTd7yXx/pRVxRvphmi3EAjUoZk+JEFiVkBWDjBicEeWMmMjIQTvMxjbTW7jhQ8fh4y/d3ymUJ4j40z+23Qtfeu6pbgPli16TTlCM7/7tEdz6+DpccfdylsAqkRF7AqKTDeUkdGt1njVOU/bI6HDR3x9TnxUyIsM0gVvsyp446znISDQ4hIPPPAUPz9k2O7dn1UfQAFl3ohnnIyNRra5KqANAu5AzwpO7Oq1B/HbvZ6fHyBwh5QzU64jr5rklCbEoBTFBgLYlG57IY9nOCD0+TG6LRDTiHAJrIITDAzKl713nbPkMneXSaGpI/d9/eqv63kjtlSs4mzOSaP5AwvQ7Y5UJsIMmXShIWFwVcWtYcXZa6TRyJ+5d56R9QE2wst0iwbS2P0xjE1i5rLpOWAfC0IzV0/IOLKFWiy0KwhlZS0rY0/Z6OSMq085GRsj7VoSMhKYzwqb21mpqOyOd1dCt0ZwkxxkZzK6xJDIi77MMsdZFgm//7L9MHaVaiGt3OhArZciXKalBwzQC+t3adbF2uqmT8YL9FmGneUM4ag9Xrt3oxooATQimPmTEckY++KK9ce7LD8D2s817ZJgM2VvoqpHaa6jS5iMjeSj25rSt2hkRgqzsrTANhRU5zsjGTWP4v+sfw6Z2pByTpGbezl3nZ3nz0h21Xvo40c7ITdvvjcuPe43byKzjUWREWjdOlLZBwHBG5HkeXJl2+JrHGekUcEZCCG+mgBo4KmTTKJ2R7NoSEhePskwKie7klUiXg127phGcPGcEMNGRscEh0xlxtuazaZJGA3cu3BUAyQwiqXuxfW4pnc6t7Iltag4grpkTqXJGsoFXQsl2s0IfMpL1XRvKrzES0LRNdpVfAFhOuDzy2dWtgUyJntXrmudkIyNgUuqZawL8YRquNo26N5YzSPuCzbkCgGlheuLWQIao0OJ7JIOGI7Aa3gRzAdJhCBkYn+qMGARWubhpNAyF4tUz54EaDdOwct7yvgc2MqLDNN2h6ZozYiAjFtqrCKxZxknIO3ymGqrJLZPXtdFyRjZJLpcK6+Wn9qpFIkF4jlhyp9E/6AKStp++By4ykl7bvPmz9bnIrfvaGw7Fn/79GENfRG/nIiM0LKscVUVgTe+5rB4uwzSvOXwxTjpiR+f4hnHZNODRUbpdZC2W1VyXJFg/yi/6Nqdt1c4IoL1JO5umnpAS7rRjZw7HqvWjeP8vbsfHLr5TKbXayIhjTphGc1ZmzxrC+W94urF5VG/ogYSR7hUCGhpmsmkkAvPcz14NwFr5ksnGUeaTRgdxZqWcHjO7fx6dEdVOuo91XxOSTRNltThoLQnOUr5PhozUtVx+HoEV0JokANAemGYQWLkBPWBclKTWUP1FDoAhWfnEdTNMIOHkmrFqZLgozUEV7lLnkmEaUhIAgBE2czgjBBlJPMhIEWeEq1BscG4YrYP0b0pg5WWrE5JZkRicERmyIGRA8GEak8Bqh2msZx8E6jysQGEG+yvHj+xP35MiZIRz2OXCgL5gwlCEzQnT1BvATB22c5wREqbZMOa+J8JGNzIbIfyE9vSZhDdFUnvtbBorTCOztGS7pQN40NL78IabL0EgEiPMF4pEOZA2MrJJvpMEkZL3lZskJcoQEqdK7ifN0eogxQ/VtdsEVtnnB/hsmiAIjL/po2edEYJOOOKULXOMkMjIUJPJnrHNw8XyLXbkdrGNjBAk6sQv/xUPrXQ1TzanbfXOiD+bhoRpKOM/NAfGy+5c5uWMOGal9gqS4viSw3bC7tubYlJqIoJGRgypaCFcYhRcZEQahZHli9eupQ4PyxkxxNZ4z1muhOWkF5UhsFpcHBqm6c5IyaEKgs4RQNJhGr3qKUJGVk7TUHe7EBkBm9rbrdWVMyIH2NCDjCSBrnVSp2EGBtLf1BgwBKkAd4JUglhWs6jT1FTISEjCNG5qbx5nhHNGNpJspKDOI2BGmMaz0k0EXQS4qb1GmygyYtw/4tBK0TPZ5qb77LVYodne5RvG8L2rU92WxMqmAYAWSS23BQodzghDYOWQkZA4lkUE1njnndX3K61qrjRMs2ojU1HaSieVtpE4I2OGMxLphyDHPovAKsM0raF0LJPlFmSF5q/9+lM45/Kv4aV3Xe3o1sj3fqOlU2MTWKUzdv4f7sVB//UH/Pa2pcb26rgDTf572m5pjBBZhwjNCSHQkplqZDxiEWPGjK0I1079bjuGliMlnRFfvRvDpHSDNcb6qvbWjTAN2WFG6ujOyBC/X9z8RPG5J9H6zohH9Iy+PHet0B6jsAdGwZC9fGaJC8VCr+6DRj1dwRGImXIPRIbI0LLRcSK0BLWBjHiKo5GXVa4iO7UcT9yItZsTyiFP3IM9Vj5KsmlsZMRPijK0KADEM3R2SjRDIiMFGgpCDz5tsm0egRUAVmVFBAGgPTCkFVMjlzNiIw5qv6CmV9pCAELoVWAQICaTWVRvAEy4ggv/jDVaiGtmu21nRGks2M6IQU7OkJHAH6axlSqF1SYu3c+A11WYJjEaYziDhogVPZnOUirFGWHvH3Fopey8/M4O04DoO1iCV1+/+iFd0kCiUrWacjZbTLhKWl3YyAjDGcmep5H6OUBqPjHHpam9ya67q++HZ5qLFZXaG3exiSkoyY0NALCJ1MnpzNDOSNqmLE3WmjwDC306Yq9FuPUjz8dBi7NjWTyd/Zc9YIZpDGfEJrCahTmlsu0X//gAAOAjv77T2F5JA9jICOkfkb0wzKt8nplCwQih/rOvPgjNWoiPnrivs71JtHbPZWQhWovGYMAkrI7WW7jy34/2ts2wEqm99F5onRFLDn5OujCTvBU7m3BzWwlM6J/XhLFCs0XPYvUQh7vE47bCJQIktdeOU9pm5fOn1UvNyTNpNJR8tkGEZAbkdEIuj4zQzqqdkUyYimtvGCKp1RDGseGMzNu0Dr/84f9L2yjz4sMQQOwgBoDL0bORkXiehp+7c9PVX4cMtD5TtS4aNExjOjq2ySKCANAZnMbGkqmxTkNQU0haTSRmKCcMEZNsjqjRQE0RzvQ94VKGBQI3TNOwnBHV70iftNrJ6owwYZo83glnxoqW3N9QJEik2B29/x7OSEK4WrsummlcB2CiBAigV5pJtnIPArMP2UgIh4yolHwXsWsoZ0RfU1yroxZ1WHXTBEEq8JWYNZs4FM0gesrtmrq/Ll03ikdXbzI2kPdQNOrA/Pm4Y+FumDOyASNHHY2XT5+BhTMHcMHVDxL0kNflkH3MRkY2zNJOTWe66YzstHYp7p+/EyHl8wRW0Whg9hBZLFkOoP1e0D6wqWWFaSwCa5HomRIYtCZ02n+dPLicqtfSuDDN4TvPxV0fPx71mrvQpLc8YDkjJEwjuX1yOyvrLh4YxG7zTYE7rzX4MI0taml/jsLQdJoyZ2Tm2CYALLC3Wa2PjAjeGQlJmfLYILC6ZDoHgvOZIbAlkCSWLgOAhExkiYGMuATWWAg3FomcMA2FTbNXSQ5ovn4o20DDNItIdV2VGq1Ez7JJqYTOiArTzNGDY3v+wvQa6vw1SEsnYMkZkZVp2xqh8IVpSEZCZ3CaQY7kVgbsBBPqlXMgEnMSt5yRuN5QZE9jtcI4I7Ukdoh3KlRnEQQja+Qw0vqIAqtErDgCq21FstA01h+QidsY+EQZZ0RzRoYG9aDcYAb8AKZOiNzP6EN29hKLjLhlHNQxGWckytrOhatkWLBuK7BymVcSGaH4eEvWC+riQ7+8A0f/91UYIchGnSAjYRji5W/8Hxz31q9hbGg6Pvfag/H+F+4NwAzTcDV3lDNiIbYbSdG+9sxZxsR4+XfOSPe10d6WqTNCQ1nc36H1XtAw4aaGzRkxwzShSPzjUaJJ5UHLdkY0yu2EnSs4I8LSPeIckVwrI3pmtX3MSu0tc3w6xgaBnfquf3vxPX9R7THuS8bV85HiN7f1nZHsCQgHGdGwImX8g8kW0ZyRcshITSRKMEkeR+aO0yJfZpjGPa8hV55DYNXX6h8sfSb5D7TYWcdm0oNyRnQKsmq7L2tDapMQZ6SzTarhUURgpceRzohRO8QXphmynBE6YdphGvDOSFRraOVVYUnGM86IWskUhGlCIQyeEABVLdUmxR34sT/gD3cuM/aVZiIjMtzgd0zzvqNGFWwDAstzkDAlsAZRhG/95SG1TSKIU0Cc6DnZStsqpcIqfHJy8MqYZ68WCnnICC0gl/VxDhmRhOmaSHT6LMCHaRjHKBwgZOTsnj+5QfddxQtqNBEgDVmONgecCZqGabhVrZ3BIW0TcUY2Ldje+R0AIeWbYRppwtJycZARwrlLr0m/x1FYU+8sQHRGSPhhw6Y2DnniHgxa9YBikiIcDJhhmpA4X87tUJwR/+JGIyM5abVljMksCi1nJByHM8ItboIgsDgjbl+0pR60qrN0RqbWG9mqnREBoUhAscUZoS+TkX5oMfuFEESBtRxnBNBS0LqwWPqyJOSlp591ZgJhjCdCDWYUlWl7kRG3g3bzwjTQgwxFRrhVta9qL2c6tp+hQXN1mKa9IEVG9EDr44zoFZKcHIwhyEtgna0+d4eIM+JZjXEOXFwzwzQ2MkLRrW6jxTuw2XG//vRXGN9RQidAkBGGgPevP7gJAIwKxgBRYA1DJNl9tOXgXSVfYVTt5UwiI0PNmjE50WMZYbK6hqvPueRufS5Sw0TUanh2pttw+rN3dc4ZAKzCJ1coT+3DOSNMgUvVfi5Mo0ixnDNCzke5VByBNZQEVsIZaer+qu4d2VXxghpmjJ9OFt9442GGw86n9srJ2Xy779v/6bh3mx3x9x32w8YF27r7AZrAatVSUT83befEdKJDkRiVpGlIIQprquIwAGyUYRqy4PrTf5yHX/7w/+HCH3/IGJtigoyEQ6bToLKQuHG4DGdETspD43RGVOZOTjaN5Ui1qyAjiujrD9Nw0gpX73qY+UWOdtFU2FbNGQEYvQMiKKOU66gzYhE0BSogI+SFHog6GYHVREaMMA2tFswgDlSUi8JvKkzDZFDYlktghR6Ua2TQ5UInUlOC0xlxOCNWam97j73wwNwdMHtsGGue9kyjXXmwqpyQ2lYqbboj74w8MVOrp3YHpwH1tmoTG3dnjhHVG0aYxnDyHM6IrnhKYVW9iqNprCkfIq43lPOXWMiI737Q+LwK01ACawmUzCfEJp28FdPn4v0v3Bsv2n9bUJ/JDD9RAitPtDOIwWGIb73pcCxZO8rGzFM5dxoSisy00bLICHletsnJn5ZzkGEaHhnRz9eou8O9X1Khl3YkwnVoRl2MNs1xQ2fTNIwOSI/+/P0W4Y9ZRks9iT3ICJ9NEw8O4fg3fwUA8H4uW8RYYGVts4XkbMTHCdOYpRQoIpGEoYEYrZ2RIaNkYfC6W38PADh06b3GcRN63P32xZpFizF32eMACJ8lCN33thJnZJzOCJcqbaFUoU1gbZjOSa55iOGG6Bn5baTRwlC3jfWWAnWRqvPmtq0bGSFEOjUpUGREOiq0smhdIiOUnFSSM1KrYSSrCzG9PWIosMqiYkaYhkVGrGwahYww2TR2cbQewjRcgT7uhY4rZdOYYZqg1cQJp30Rz37btxHNmw+AZNN4UnsFgAA5zoiHwPrI3O1w7Y4H4M4Fu2LFjruB6so45/Bk08R1M0xjTOJ2Nk2jSWBVGtNN96GOrjxXRPYXFmfErhNk7wsQUb0wVJOJnZbKIQScM0Il4NcMzsTbj94NO84bUqm9aZv0vVN9o16HTw4+jfvLd6aGVr3mJe8phc/sfjfi2LiPVOlVmr1qB3Q2mp3aKyCUkxiTPhPVLO0SYm0PMsKRYyUyQsEJCtGrzBmyj/qu0TAJh9bjiUpyRuxsmiAI0u+CgHW2W3FXlZmQ9z2wwzLN/DBNEgSWg0zGrSDUdYQADGeVqmnIlNP3AVKulEJGBgbx9S/9Uv0mn1VS84dpfO+PEJrkPW5kRHExyPhrISN2iGm0WcEZ8QgOsuUShFAhWmecVM7IlsEZ6SMjclLISe3lOSMyTKMHOLtQHmfDQzMx1BnD7LFhDBMFVvmyG8gI+Sys8wJSZ0R2cn1ujYyYLx7HCWgzMW1qMlREnREWGZGckaC8Aqu610HgvChFRcAAkDCNtW9YQ4NVcUudpde//jwAwCsGBoGudhQ4AiuLJjVaOkxjxcZZZCQnNTUxnJGsLzaaADKGu80Z8dxXQ4GVVKGNa3yf5K6LQw2WzpyP957476ngGUVxghBxEGZhKppSSEJwDd4xFXAdUuN307cDkDoK9W4XjaRrhpg4ZKTpQt6yf9qpvYApCiVNIiPMtOZ1Rjh4gnu/aqS9tDSE3R5Rt8I0VluUM5J00eVmEg+BlS39QKwVdQA50VkKrMrsvxu2MxKyfVL+RsciNW6ShYGPv5QkAo3st1q9hmhgEFEQoi4SvcLnJBZKISOZgzRBzshgt607sx2maY0DGfHo93A6I/VE11j74qnPMI+zhYVptm5kBP5sGoMzErqcEYWoQABy8CjBuh7O4qOzxjZCwM2mocgIDdNwyIgBWYIiI57U3hwdBJ8l2cD70NJ16GYDuV1aXgSBQoVKKbAy6cjS5DjZKaEz4gvTdAtCT6odYWCE5fjxj3NGmqpPhMJUmuSckYDAz2ozRmdDZW+R+LGNjHjDNAyBldamsc3hjIB3ULq1Oq5fvD/uWbCLdUJNVq77wjQecaaEkBCL3hm5dpdZXfU4Nvtxrabk1dU+9kQJwn1gnDkVjq25yAhnhvNLnRs2DNpwfgrDEB1SaRow/RgDGaHXYB3e5Iy47dSoqeWMGKqi6b9/evlb1HetqIvQo8Cq2uIQrc2/kyA0kRF5nWEIBAHr5FHBSZ+7FBNUrVavIYAOhUlkRIT+ME2+zki1MM2imR4HYkiXf7B1W7zOSBVkRC1MSEYneM4ITek/cj9S+RcgBFatCD6VtlU7IwBBOJhsGqXpT24Tx90IVZimGBnZiHSbRjaASNgwaGqdEWn0M5dNEyekA9ZczginLWGb0hnxvP2SQDm8YRM+9MvbAQDbNM2NqdMkJ6gQgl1pp9fgIiO2lUNGtCNJM3xkXZsiu3/FRsLg9xFYmQm60VRORMBk01BEK2o21cBtTNoyJk9WcfI4NMzjZNOUCCc1CTJio3WyLdyzqRLGCwLteNZ8YRqPA0UdycJ3Jusa0hlpJJGDjAgHGWGcEUZSPj18oO4p1XiJchDD4dY0/dwMZMR9NtyKNwh1SEjeGzoRUM6ISWA1jyMzfupxzE8kagK0wzTupr8/+V2qiGQrajtpwUHLDtNY6JN1z+OQR0akRMFHj3s7AOACQuCmCwMfMkJD07LQpnzfVbghrPmzaXzOSBTpLKbBcs7IXotm4DOvPBDfe7NZxgOkvIVsk87+4pGmnpCRxEZGaB9Kz2dk0NgVxbewMM1W74x4dUaE1hmhan7CWuUKAVJUqtgZkdkSKelM6Aq2SvTMSguV52UGUwGSTUMmNX/VXj/BztcRpUPUSCL85MYlaRts2J3cH7oSVxOONTTYqb3c4NgpyKYBhIFcUTSES6f80usPwcwBc/V26+PrDAa/TeAS5BzUanGkRJVqIilI7W2y0uly4EiCAFH27G7bdo90H0NrhtcZsY3eQqoz4hTea1hqpcS4a6X39Y3P2Mk4H63PE4gEJ951NXZcv1y316MzkmoiWLC1x+Q8GhP+SWg5I6U4Izk6IxwyYldeprahNaTCX0FBmEbKfNNfwiBAN0NGmipMQ9qj6ivVvYsEQIdp6knEC1YxYwNgisrJz0GgJ/VW1NWZONJBc1J787VdBAKrcJspovbz/f8FLzjtS/jsc96odyILAx9nhKb2IhPx4pARx5hsNKO9o6QIYklnBABe87TFOHrP+eaXjQa6WX+T3BgtwTCRyEiMcy/7Ms768w8AmDxG+VkuSLv1hvuuZU5Tq09gnXoTQrihGLKKlb+dcMhivY81qAnyuTC1F3QAibMVYk6YhkKhDDISgOSWU50ROajEXWOUY6XNC1AEOXmZaWrmcSgyQvk1Pt6I7YwYaY/Zx3I6I3KwDYxJs82s5k88aDvc+tHnuwch0DAPdWftIU7WPvffopyuUDCcEUpgbbYQ1F1UQ/e7Gl502hfxrcNfig8df4baR5qqTMoU31LbWE6T0hkJQhcZkZWYPTonttF7SSWxgyAwQnKvuv0KfOk3/613rNdJZd+0bcNjeuKVg2WRAy+zxITiEyRmv6rVFKqo9mE5I5rjY5tcYRqckZxQ33BrmrqvNz+0Ev/+k1uxYazLok0yhdXwVwONvMiQZ8JN3M4Ebz4f2ScbSYxzL7kb/3bhTcaEwmm5AIyOS2YyvDsQdxDI0LPcwCasFnBG4tDkhWhkpIZGLSXP3rNgF0VUB2CMcXnICHVkgyBQ6N1gtsJPcsI0XkXnUV0E0SaX9mLyucs2yb4R1CbAGcneq91WP46Tbr0M77r2x0Ac8ciIckaYcT5zupQTV74Fk2JbtTMC0GwaV4FVTh5H7EY831po7AeKjBCYt+UpeETj7Gk2jS0HT1bVTZc74Nb5yP4NXWQEMCdzPrW3XJiGhkvsVbUBb5MBXcHN1mndMI173jK1aYwwDRnU/KEF5kQEGuZMnuOcl7xbfffjl/6rEaaxs2mMME1dE1hfc/sV+MO3/g1zR9Ybqb33zd8Z5zz3dKwZmgVAmMiI7Yx4s2lIvJg4Ora8vHJG7ElZeJwR0haqRBnATOM+9sEbzR0ZBdYDPvYHfP6K+4w2gpXZ1u2QTywhyEjNcv5cAmv5MI2A4DkjBWEaiYxcecdS/PzmJfj07+5RhemojTL6EWEQqDCNREbMMI1UYLV1RszjqIVNHOHe5cO49PZl+Mfj6/QGnppZ/KseKL2eVrfj8E0c7ZYS6dRm5VipAVLzhwM8laDpa5vEpA5U1raOnfmUQ2A1igFSy5yRsXrTPxhWMCliJtukOCM+ZKSHMA2VzW8NbzALSWZopUTHuw2/MyK5Mn+8Z0X5NkyCbdXOCGX1u7Vp9IqXpjEKwviWxqX2TmvxK6uYZJskgpCQGGQkooWgpBy8tTLm0vfoZEydCG7l1vGkwEqTEyuFNwM7TEMmPCNMk53vor8/ZmyfF6aRsLEisHoUE+lxkiA09FLYVF/G3v/CvQ0kzDYhNLzarTWw83/+Bnuf9TM8tPO+asVIRc8k7S4iBLio2TTUSvdc/RhedO81RpjGNuqEJk3TGfHV7eCebcQ5I1JRt2SYxoechUFg1eexjBTKo/f281fcjyAozxmRt0deRyOJ3JR7a6DlCaxuNppEETjOSF6YZrg1pFOms33vWTbMPoMxFaYhiAUJ0zQUMqL3UU58o2m8G/YUSlFWae0uITWq9Gnz6XAcLYAoN8cdTcqXWUgFSAinwGrUjpMOVshSV1MrwRmJ6PiXISDy3ZcoQMKRokn72Yy0EeKMTICNWs6IRnP42jRjrephGrpQa23c4NyzWpKoe9LhRNUsZ2TJ2lF3m81oW7UzAugXlnNG1MBFJhNVI4Zk03CiZ4MNfpDtkjivgNDxYaY2DZ2UuDLqgBY2oshI2+OMcBB1cTaNGx6wV9AirKmBh2YeyZf+47+9y9jeTu3lEIsi0TOa/ZEEFmek4Jqk7TxvyOKMuNvI2LXIdBnGshWMdCpDInomHYvukNbMiElqr7Shziir7ivPaJCY5aClVB3d+yEEv9rlsmlEDmeEmwB8g3MQUGQkMRCxtKEkTGNnXxFUy67F45wHMkzjIiN2ETdlLDJiIZrEVFXTkpyR4dY0A6kB0hCU7aQDwAiz4g0DUyMEAG54eA2AtAilfGeLkJE41A6a3oagSj7OiBGmIZwRUu1bE1jLhmlcBVauXlLu86apvR6XJbGcEYAh7OcgI7Qtho2NqWOxCGpFk+/NviseSr+wQ2ZWn91ESi0UGiPI1xgbcdDdWhLrME0OMjIYtd3ONQXWkzPyla98BTvvvDMGBgZwxBFH4Prrr8/d/vOf/zz22msvDA4OYvHixXjve9+LsbGx3H02h1HRM8X3UGEaPegFJFODiz0HJA1ueoaIPMcmNWVGRcFSZISkQsJERswwjXSSLGRETpY0LhwEaFurBYBfPRehCDI8RNN5beEouqIUQUg0OPhVvCN6Rn+swBnRGSmB4YDkaacsmKHvaRgEBjScpzNiIxjy71AI9QzkdXeGtNJh1Gwq1r80ykfiNBFomEbIFZMqjpWwAweHakQMgVVyUMoiI2PcICbbSdABpx8ZCqyMA5CT3k2N6ozIY+l3Vq7arefd8iMjBgE8u41SkMvMpjHv29qBGerzcGvIEffb1I7Z58JzRoJUfwZ6sXD/io04bMlduOnLb8DJt1yW7mOl9toWWegMYCIsvto03Fy7fqRLCk52tHqrh8DqKLBav6dhAvNveTwvUZKUvDAXPLrBcWSF6AI9VihkhEPbqDPChTqlQ1oiCaGMyZDXnNENaVNtwrY9nlQ5b0OGpfQcGkSxs0isiUTp2OQ5IwBTt2YKrLIz8uMf/xhnnXUWPvrRj+Lmm2/GQQcdhOOPPx4rVvDxposuugjvf//78dGPfhR33303vv3tb+PHP/4xPvjBD4678RNhdEJLv6DISCZIRvkfNjJiZdP85p1H4T+O3wsfPmEf9nwRmaiF0LVxOGSEwv2aOEuLI+l22N68hNcpMlJEUOSM46rYK+jEmvBiD4qj22E6I5wVpfbSEMrpR+9uEOHykJEvn3So+lwroTOiETBzhaqdET1wylVkNKhXOVGj5cTb60nshgeJxQSyTeQgatRncQdT7tlSBVZ1vOzYdl2LlATL9Y/0/CccaNYwCQLd9pDLfiDICOeUKievBOkboGGWmKTSV0BGmDCNNFWfivTj9bH5Pq0iNY1SZIQR92OOzRVAC8NAE1hJ/z7j2p+Yba7b2TTmPZZCiYagGEVGFE/B9j5cb2TVxjbJpumoyVk5y/Y9tVN9bWckSdjFD5t2K42ETL0EVpq9FIYIoMnrSryLC9PUauqdVcgT/T1ySczjsX9st1d6rswZUATWkv091yQyQuomBXHkLCbqSaxUuKMiZ4SpTr25rfKdOf/883H66afjtNNOw7777osLLrgAQ0ND+M53vsNu/7e//Q3PetazcNJJJ2HnnXfG85//fLz+9a8vRFM2lyltB7s2DVmBBWSVJDu6EXdU8dUQu2wzDWccu7uXM6JVE1OdEaOwGGxkhHSg7PfRUbPT+KBYld5rICM5BFa2tTwSZE8uNvSqVo0eUmiZMA1X48Y9Tvrbiw9djO3mz1Tf5yEjO8zRL2AYBgQadnVGaPjDvr/ybyoHL5GRLkFGxqbPdMI09ThSz8LljIhcZCTd3631UpozkqlLclwczhmRyMjhO80xvg8QGM95wJZNJzojXIxeOdUlFVgTEvKxkRGnUB7jjMhYvZkanxpNhZa2tms+l40ERuc4I+kBGWfEgzxKx4fWDIqtiSqVg/eHac55zSFOGwy9kTJhGvIdrfbt8OAKqvbaSIkjBij3KxGmqYnYOx7d/MgacpLsfQstZ4QL0wSBErJjwzRShZfbtwdTKtixdEbKpbKXMoWM6HcujCIXGUligowwnJGGrrG1JVTurXRnOp0ObrrpJhx33HH6AGGI4447Dtdeey27zzOf+UzcdNNNyvl46KGHcOmll+JFL3qR9zztdhsbNmww/psUo2EahzOiV2ABwxmR+0WJwC2PrE6PURD/BsxJlhbKU2EaIy2UEli51F7Sya3VwMZmOnjObG9S3+WJWvm6oM5C8CMj9gDDCcNRCxM/MqKyJwg5km0XzBQ/QQhheenKDXKfakaYJp8YajsNChUgnBGRbRJRZ2RohuOMhCQV10Yu6lZqsGiNAxkJXGckydA2bkBmCZgZ3OysrQkyUktiVaRMN7KhECHu3mreR0nOCAmL2MiI43wwqZlcmEa1JWvffWv04G4XkKQx/Q0km0Y6xGn1bn82jT3IdxlieGJPhE5qr2n777xN1gbSB+lGKhRmiZ7Rz4H8TmfTDERtrNmQkhm9zkgBhyRFRhhnJAxLZtPwG5372zv1H1JnxArT+PpUN4+HpkoCMGnBPZit9ZSnOl3ZFGdEv3Nxp8MgI5TAyoyJQaCQO+nIdZhyCZvLKt2ZVatWIY5jLFy40Ph+4cKFWLZsGbvPSSedhI9//OM46qij0Gg0sNtuu+GYY47JDdOcd955mDVrlvpv8eLF3m3Ha15nhCIjhDNCU3+dY5ToaJL42MgIk3UrTEMnMppNYztB0jg5eEDDyttsWke2ZWD4gto0Ct4m583jjABAHGq4lTMHGWG2iQny4DMa7qGkT070TFqTOCOJECRMk7CrgkLOCIlvK2RkUD/D0RmzHGekEZPVvXXcbaa3CpERR9EU/LONwprrKGYTtc3FEb7UXl+aNPRKvpYkGOKQkZxMpZqHz+Ccx8qmSQmsVi2oCqm9XDaNzFCKiDNglxQYtZERJpOF6z+SS2Ojf5IgS5+lzVewJdad4xt9Irsnhq4QwyfzmI2MrMycEXjDNNZKu2EjIy6HAShARqgcvOe9N44pkZGsjypkhNMKgE7XZh1xef8mCBlp1/S9TBslF076+j/znFMAAB//l9OrOUAMMvLnu5500vVDoQmsbJgGOnV/IGqzv29Om/RsmquuugrnnnsuvvrVr+Lmm2/GL37xC1xyySX4xCc+4d3nAx/4ANavX6/+e/zxxyelbWkmjEwT9DsjoKm9obtilwNcVxR3qa6FcNStME08U4cbEiObxg2XpEJLPPy3cloKq1NnhEMZJDJy6I5znN8AfhC3BxmbM8LG04nVciB6OWgnhI/gMwMZIS9bHg+mUbdgb4KMOGEakKrI1mRihmkyx0KmJc/Qz3Dj3AXOdTbjrpMOLO34/Rcaz119JkqtnNYIzxlx5eCTaWmmDzcg8wTWDBlhKr9SAuUgh4zkOCPla9Nk7SaTf83e15oI82rT5CnP0jCJ7YzQdlLRM/O98IdpatYEyXFGhNUX7HTZyEZeaOgu6xNv+d6NuH/5cPqlT2fEG6bJdEbiDuSRvbVpbGE5O7VX8CqqZZyRuvBn0xjfZyiGTWD1ISMyRN5kQpQimuAwjfV8tYS9Pv7Xj3gljj396/jO015a7eCWmCCQcamse1ZPqM4IE6aBfuZcderNbZXu/DbbbINarYbly5cb3y9fvhyLFi1i9zn77LPxxje+EW9961txwAEH4OUvfznOPfdcnHfeeUg8E02r1cLMmTON/ybLnOqpRM9AmhmmcSdaeYyxEs6IXUjODtNE0/W1RmT1wZ33K396kMgM88jI/E1rnXZS22unbXD2i/fF247elW8wKQjnO46o1Qx4w840cA5ZgsCaMOc1zinM44iSyAgN08SJMNIJeQKriXqofUn7NK8k/TS8/U64Zds9sWz6XKzccVcHGUmdEXcC/OW/PRN7L5ppZlGRPqD5RrbwnWDj81xtmmR6mhXCOyMVUntJ22sixlDHckbqdZVNk0dgRVGYRjqnhGjsKB5bq/TAQhQAsKJn8mo1iV23pRtapGNyb0YaA8rhVpogAEtglciIXSlXOyP6OczojBjb2A5AO0q8v1OH74yLbgZQjacQINAKrFEHzcDa13bwBq1QGEtg5cI0xZyRMDEzcQzniUVGTM6I73rLcEaSLPQzXjPIwCBaVGQcicMaHp67ffWDMwJzqTKx2T8KU3uhOWEKVZrCDN9Kzkiz2cRhhx2GK6+8Un2XJAmuvPJKHHnkkew+IyMjCO2qkVmnm2otfCO11yKwGmJhdDJhwhYqM6IE2Gan46mJRYZpZugUQlP0zD0vwKSMZbZmMHVq5owO6+tg7vc282biLUftgladHyQ4ZMTmFqQ6IyT9rggZyRE9kybDFz7OCABD7pqiCXmckTpZocY0TJPE4OLUAWQ2Dd8+qqeg+lAY4jUnfRpHvf07iAaGgOnTjX2bkWa+08Fpj4Xps6dhGsp/UH3HDrF4nL44DNWzUO2eloaQOAJrns6I/YxSzojuGw7MS5RR2TCNhzPjtCn7V/bDRhy7fBNSmGys3kTArG7z5OA5x9DmjDy+YEfSqKB0No1E6RxkhMkWG7AyGmxkJM8ZoRPsupFsNc6IMQIw3lWfzkgjsEI8Fg9HWA6gHVJKuVQ8MnLELnOd7wGY2TQeZMQuvRAEuo6VLpTHT2tdqzihYZEuLjkRZiMjKuuxxs8RlbRNGKHKeuLJpikK09RNzshUWr78JmNnnXUW3vSmN+Hwww/H05/+dHz+85/Hpk2bcNpppwEATjnlFGy//fY477zzAAAnnngizj//fBxyyCE44ogj8MADD+Dss8/GiSeeqJySqTRnIMraRFnuIQ3TMJLFVdIUbWcktDgj8fRZatvuNI2ScOdNf+CdEU1MIoxrLuOCqeNhHJ4h/tltcEiSjMNGzdYZoabE04ISyAiRhY5JGnQeMkJf+iQxOSPcOeQKzYa6E+gwDZcZY7Rh9mxj30bSzU3tTcgqNCHpd5ziJgBWbAuQ2TRWCG0aj4wYSBOxkSZfNCytTUMJrG17g/wwTU4fMIS7FGeEiJ7ZyAhxRkYaAxhixnXdj922cM/PDtP85OjXIBkexp92PRwAz4vinbn0/XKcESYt166bYqfLtrtW27P6QOk90b8ph9sWLtO7sZ9poTyZW6Ymdqt4nO2M2Kt1qqVj7BfW8KWTDsHHLr4Tl95u8QzJwqAUZyQIstRek5/hCwVFNReNUjbBnBF/Ns0EzHksMuLe71CUCNMw88RUWWVn5LWvfS1WrlyJj3zkI1i2bBkOPvhgXHbZZYrU+thjjxlIyIc//GEEQYAPf/jDeOKJJzB//nyceOKJ+OQnPzlxVzEOc0q5c2EaMjCJnLBFGeEau+y6jWzEZBU9MncbvaOa4Ivl4AEYAka6ne4LnuSIWqUndB0LVw6+GmfEkYNnEKWkBIGVOjUxIf4WaadIs5GRPJ0Rh8BK+kHoGfQB4PG1o8A+s43vmlGXnQBVu4iDGM3Wq8guSQs3zaPJwIZp0v7FDchcqEdmZfmOD6R9w8mmAdgCgdJUPy4ksGZhGhkWEUQwjkFGRustcC3mCaxp3wsV+uV3RuLBQfzXcW8jxzMzxoQAm9orQx+2M8IRWJ37ZK2AOzYygjRFuJbERuiuVtOCfOkHGxlxzXAuRUwyxHhnBC3rb4fAypQIQBpuWzBjAF89+TDs/P5LzB/JWOPDCSg/S6rTOjojHociUsgIo100wam9NoFVIyMTl01jfJW4hOF6iTANRcOm2io7IwBw5pln4swzz2R/u+qqq8wT1Ov46Ec/io9+9KO9nGpSTYCZbBQczHNGYMWKAZLe1wMyYmcVjO64E9q1OjY2hzC8HYGGmSwekPbb5x5jiElc6mbMeNnUBEOctT1wN5uG0WAglouMyJVwgYqrUak2DA0nLg8ZMdppcEZcnRGAZCTkKLDa21D05Y/3rADeeKixbyOJ9QRIBj+5V3eaDtUlBFWRegpO5V4fMhLUnHuswjQlCazDOTLVcuBuxBEP8+ZyRsoRWKVROXinlgxxRjqOUFi2vwetS4UDXV5Q13Jow0YDgJ7EbJ0Rn2icFxmpu6KEDlpVxBlBplfSbRuk5rocC7yiZ9oC8q8hYmcrsNrOSInaNCwyklcLq4ToGXXiQ6SX5hBYPX1KcUZyFFjjTEhtvOYjsE4IIcXjjMi+3a7V0Yoj/M+ln8cdC3cDkIovcqaQke5T1Bn5Z7LAHohkmMbgjJAwDUOE04S68joj9SQ2iYfZcbtzt8FzT/86hptDeAdHYPWELeyYo9Q3aBUgI3ERMsKEaWyHyCal2XU7zI3dqpvc+ylXab5ByWhTrYaEICNla9PsNn86UE/vT00kbNVVozYNsSSgyIjZh5zLqdVw9/ydsc/KR9Q+eWGaTYu2U5/jOfPUZ9l37MGU07cAUqcw8CAj3IDM3etNWZiGTb/Ojj3dJl7K4+WJnqm003KwtSqUF+cjIwIBO5lwiKaU/1fvLw2zhebQWKvb6B8T3uNEBT3IiFylv+36XyAKa/jvo9/k3idrwo+Z5yzF06iDKs/FkSZtmzmodYYShYwkWlVa3hPLGQns9FlLkr/m4YwkeQuFAv4WwCQcQD+rVmlkZPLDNG0nTJMhIxMoekaNG2v3X/4gdlnzBACgywkBgg/nT5VNemrvlmxC0LoiJjJCYeyQ1l5REy3hUFTQGaEkRDtNTdqSWQuxfnCGOaR6C+XJgTlIC78BmDFQJ2Eaiowwg1kRZyQne0iayxmRKah6n4HuGF576++x7fAq55rY8xYQWA1djDBETFfHBc7Ib995FC54w2HYf3tTA0SwQmB8Ng11RgICHfuM6rnQlR+dAOXHJw8+Amc/7+145cmfQUhWeR2fToKXMxK6nBGVTWPxE8A7q7lhmuwezGjnOyN8cTqJjJR0RuSkznFGCLlSBAGPjHjen5AiI57U3m5YQ71uPn8b/fOp4Mrtdppr3seY9NEzrvspAAYZKaioDQBx3XVQNUlbvh9uWra0Ew7YNmu/SJE0ZO+6/XwYITmjrdaihi0RABftMUyF4szaNLT1DgoJGqZpm222LI8zolJ7J8JZgBv+8IXMejIPMiKtRa5vWhY+9SMjW042zVaPjDgwvJVNEwUh7xQwhM4yXjVNezUGxtCzqlYn4Qmd8oUPwhouOv0Z+PlNS7D/DrPwvTtTRVwzTNODM8KJnnGpvcQ4Aut7/3oR3nb9L/DEDFJAkCWwpnegiMBqHL9WU+EHANjoIV1K23/7WakjYreh6w9d2BoQZqE8+Z0f6aEZPqFR7M3tM0EY4geHvjj7Q3/vVCeV23uzaWoGqgcAIrtPrThyRh5WoVc6URy3JXvOs8Y2sucPclaiOsTGEVjdYwk1UTHZNCUGeK4fC5FOzNxqmzojcVhDwzoHx4vyIVQAcMSu8/CxE/fFbgtSZIrLbnCqGxeEUAHt1BjcE8kZkaGWHPSpTkUAKTJiiykW3WMrm6Ym7GJ32TlKICOAP8TrhNQCTWCdlqWXJ/UGO5DalZINLqysTRPUJiSSQgmsv79zmbdooTp/lYN7CKx5NkoqiVNrN7acbJqtGxkBcUZgIiO0XoVRH4KROg8rICNdQkQ1XtYc/kR6Ek/MmzhT280exDufuwfmTWs6Mr8A2JVKYZiGcYLsQdcmsMY1c9UIAP/y4A0AgO2HV5Jj+wdJmTbqdUYsRy4mL9vGHspxpyflkJH0Xz9nJJ/AKm3DgG5fjUsH9hgtId+Rqy2bgOdZzqQ6IzYyotthD2B5ZGHO5CpyNkkfpxbkcEYUMlJypUhDf0XvG/cUpConDTEuWZuqjHIqu5LrAaT3kYrlpe1x+7iccCJPu0591i549h6pM25XBQYY/ZiCitqAzpKQBdEAoKZCnMWcEWmJEETePwFszkiRWeOIL0xThjMCmPd1xbDLe+Myn2T4V9TrbJRH64zIQnlko3iykJEu3vaDmyY2m4ZDRnKqmwM5zkjWzqec6Nk/p/FhGjnpx2FoopwcMmKv1HJMriZbUcdMM1T8CX7g8MLMiURGigmsvXBG7PN++Y/3q3iyNF9qLx34WSIkozMiP6swjWfV36EoRq2G2EBGenRGIrcAnc9p0M4SQ2BlTvNfzz1dN5cw340wDdz96Wc5cNC08/TE/KooDmvYfbvZxndSgRVwEQsuzMC1Q5qE9WeP+ZyRjDMiEsdh0qhWWWdET/7akeHfN/Ydkn0S+hqPO//qtL4T3Gc8SmDtOAgNsTwAyslT2TTQzv69O+yFM17yPrz0jZ/1Xk9kORr1OGIIrJYKLDPDdpouAVGFaSo6fIaQXwkH2zA7myYZJzJi3YvhMZmVYr43AVxNGN+Y1s50myTHyWjehBfKMxH2Cc2mYZARx5G1bITIRFDrc0a2IHNWtXZmSBCayEj2wtD6LE4MO8dWDc0GAOy98hG2zgI1g4jnTZeVUKw5qY1xKVvc4OAhNqldrPP+zx/uQ2RP2jUT2owZPYyAW3TnISNqYORX6//2PVL1OQzRJWnQawdnMHt4jHJGogh3P7kh1R/JTBNYzd0Eg4yoAZIZwJfMXoS3vTytx0SREW7wM50zgozIME1sh2n4e3TEHgvwyiN2NttNnRESFhCCzwbJM9nfaTFGw8ig6a2pFLqrPK4VgjojOdlrzTjikRGPM4+AoDRkz1ELGal7wjRSZVgI/RxEEOCSfZ6NW7My8pxF1qQ8GLVdMbsSWWFRw03hVwRWkm1WZEJoZ6yexIagIGd2F3eyaQRPQhXNYs4IYE2uQkighhUL7Fp9SNTrrPe8ck4qP/HhP30HF/7fBw10VSgF1gkSPZNhGpnaa5H2basUGmKQkbzq5gAwMo0fE1UJAMkZ8ZZMnXzbqp0RKmolRaycVEi7dDyDjFTRGblph30AADuuW2bC5EVwqCdMEzJQbBDolR3Vf2CRkUICq5s1YA/ojs4Io4nChlsUMkIdqewYBZyRtRuJJx+GaO+0i/rzkTkVJJbJ4PDp396BF37hL/jcFffp9qgaMjaBVcP+eZoh1KhiqUZTOCeUN1rIzDDPPTpmv23RbFkpmITo27TCPXb/WD5da5xwlybJ2D4Cax4HQKGJ9ZLICNEsyctee2LmfE9qr78/yeumEP0YQUZGGwOGci+gnRGJbq7a2MbGsfxsDmr26r0VddzVrZ0+y8wT3aa7spVN1c6RpTPC3J9ECPU8Q0HCNCVRlaDpKrCOjzNCEghEotrsICOBm4adeMI0G8mE/KxHb8P8u25Vf9/x2BoAE6gzokKqJoF1srJp2HRlYqPTZrHf9zkjW5DpyTz7wnIKHHlgRla6CjKyYlo6wDeS2CT+MQRWOmgoRMZxRniPe20mBz+tO6a8c44zknhY1voEjOhZUTYNq8Xid0Y4UzojnonW5tsks2bh5W/4H7zo1C+W1hmRJp/x3Y+nA9KX/vgAABjaEbajESvYnxTKyyGwpufRolJyJUMHP7lfYDmW0mxVR90YT3iFVM5V1mqh7SmlLq9j6YK0SvZ7Xvz/1G8HL57tHD5R2TQeZCQHdi8KtTjnkn2KVDymehL/9tL3484Fu+KDx5/JIlM+ZCQAT2AdIe/Fo3MWOc80IUJbr73191i8bhkeXLYhPVeJCc1GRsIkYQisxfkF3WYaeqAOaoAAcSLwyMo0fFbGoaDISFpXJj9MY9/jCdEZ8SAjVATNzm5LFVitxZCHaxPZTgs538U3Pw5gIsM0EsVMieJcobyerSCbhrPR6Twy0pHI2hbAGdmqs2kE3EwI+0E7DoZCCuiqX8LGJXRGanVEQYi6SDCtM0qOW7AvIz6WnpQX09nQmoZuWEMjiTF3ZD1WbBgbl+gZ5X/YDoIIazhkx9n42U1LABBkxAhlWTyTQCsocsMdJYhyZrQhEyr6x/Z7516Lz6KwZogGUfNl09AwjU6kzEdGzMHej6Z4nRmlKWGtgnzhlXrDqaYqmk10aw204siVlc+O88l3fQ63Pr4OS2YvwkGLZ+MjL94X+23nrqykEze9BDJiZrGYgnW2cZcjC+XVDQKrfmcu3fsoXLr3UXw7ALasAZDea+5ZrBnS17tk5kLGGUmPd/r1v8SszBn7t5e+Pz1XCcg9tsaZhqWiCpQL03Q9JeCvuneFV2iL1WEBLXyY6BBG2bCFXShPJGxoNveaggBxELrob5Io54dTRLY5I6LBh2lia7vHVuvFoAy3xRMUpmkTh6gVdwmZeAKO30M2TWeA59HZiQ5PmUJ5/4zmsLMtp6DVMr1sboVVRWcE4EMoeQJgtF01keBpj9+BV96eFivkUiSDIP3f6mxAnTeyDk+sG2XZ7Y54kXNeN0xjw69JrYbXPW1HnPvyA3DFWc8hOiP+0I43iyRrDlWD5MyYVMZZ40hL9LvnUo6GJ5uGrgC9omfWeSiEXWYVLU1p1NiEVZ8WS61uqAe3a/U0FTJ0i7QJ6HvabTSxZHZahXvbmQM4bKc57PE1MpI6I9fsdCAenb0IH3/RO9MNSoRpShNYpcZKElXOxAH48KrdFvqMN7Q0Ifqx2W5FcukIzSKoUNkMKcAlsHIEQju1l5sndJiGZM0FwFiXIBOOzghzIAGSTUMUUMm2P93/OADAucec5vZxjsAK914nBdopNsoKWGOPJUJIFVj1OXhkxN7upruX6uMKosA6gam9gKzSnd3PyUJGsgUKp3U03Bz0OpVc1uVU2VaNjIAIZ9mpvcqsvzkF1io6I0DaAWZ0Rs2y6wVvgDpvEuOnF6UrsPu22VGPUMzAvM2mdQCAk2+5DIl4I2q9uL0MMsJpndTCACcdsSMA4EZGgdWeBBLbebIsKSCwctU7ezVOpE21zZtNI9MnBUmvljvxjYlJiI9maznn9HzWgnl2oTz+HgWNmjFwdWsNQyTKDtPUGXJgnsm2N7Pwwt3zd8HJrzsX01t1fAQAgkChgIYeB9H2KB2mkZwRrmpvGfNU7Q3AaFdkbf+fZ78Br7ntcvxy/2NxiK0zU3OHTl/pAM7a1v7cZFAKGVFhGnP/kCA+ZWrTJEIYtYZUkT1aZ+z578BPDjwON22/D061D8AgI9wy2xZHsy0Oa2jADEPSMA2rCWMTWD3hrYc3mP2d3jOnevs4jaI1zUg7I76qvZUsBxmJw9BIrkjbwuuuAECnn02z5ZgD0Xr4D8oYPkTVgVWm3U7rpmGayKhPQvkCNJvGRSh2XLeMJ7Bmx5CTSyOOkAieM1L0apQRPauPmUXSBsbSlfJZf72Q7GOFabwaEWmLKnFGwrDwOvJMIRY2MVf4J5g8OXjvedQ1xaxegjKvM+P2PcCfkitqdSU8BujVWodzRsj9LCLiSrP5VCONdGKke3NtFkKQbA1G9IzjNhFkJMzhaD137wVsW7lFBCDDNHxm05ef+To85+3fxtKZC5wXhVvBq8y2EhPaaGA5I0zM3iaFciazaVoWMpI6fOXbI+CpTUP2bTdauGHx/jxR31Zg9RJYC5AR5pmmYRp5XEko1yFeh8DqcXhsZETq9fzl/pW55Rl6siDQxfLiDjtOWzuUPzarUZMhI0GAf3vp+/H3HfYrdai2VVB1CqM0fWdEpVx5nBHbweBiz1XDNLKTSg2QUt54dmxKVEuCgKx+XNLjN572cgDA+oFpiBPBhmkKLUdxVlp9bNT4e/87rgMAzB3dQNrqpkyr9jIvYpECq0KjEFTMi3Mt9oU/AAQeZ0T+XWdEz7xhGpJNw63EFIGVnp/80WXK1gOAyCGwBmQVJQdjFhmhaY4lB2S73442XclwuzCkNI6EKo2rTpsQKXy9LycUyN99wfCYpFVBNFR7mHNXOc4YzP17R0Z4mD0MyOKjFIFV8AqsZVNRrZTdlEvFISP518RxNkzyvEVgDVzOiM/hsbeTDtyF1z2mU+0nSPQMIPVpSJVuu1ZUT8bWppHjSQ2X7n0UXnvyp9VvAXIy9FShvD4yMqUmUIyM2IOlqDOckQrZNICeDGSWS5nBSw68M9um9HbegCO1RupJjMTjjBSdWhNYKRJkHqfeNpGRNpMubK84eDUIbZTAmnAF7GxkYRz+SF6VYemsOtk05HrKhuliEg7KQ1P8BNZMHdgulOdxMkW9bvTnVDMH6IbZIJkQODymzsj4kBFq8t5+5Mpv4Pn3pSUKgiDIRUbGuowz0tCOmA7TVOCMUHImMV82DbVGzXWXOXSgjBKvtJHQdkZKcEbY1N4BZ/8AKTncV9GbTX2GdpbT2kn5zohjNmfEo1tTVG+Hu6+0f3P32EY8fE5cZIVzlBBZoN/hOKxNSNVegKb3dhV/ZrKyaSgyYlsghNdJH2N0aqbKtmpnBCArX9kBrQfthF5ywhZlBXPkIC4JhNQbNwSv6E41mbmgUYhGEpG6JC4yomoxJGmYhhscfJ1UWeiGh5wwTdtERr581uf18bNt7X3oCohTYE1IjP/lX73GbZalDTGeAUSGyexVMyV1urVp9DNzRc8851FicBFbKVYrsPIHiHyrew96FNTNMI1sM4uMkGOUdartyZsrUCjb/LwHrsc3fvnJ9FRC5CIjo13XKdTISFc5xvz75nHMcsI0XIaGsQ0C5z3J54wU378R2GEadzIos4qmWUZqvyD1IaoUZxPCUmBN8h0ru4/ajhPV0jG3K+CMsIiTS56nAoMOgdWDvmwYmGb8bS4oJ1aBFTCFz8KJREZYAqusOsw4Izl5fmM1O5umL3o2JSYIj6IqZ8RMW622UpMeuoxZlgrTZOelKyC6wqYetxwo9OSVIBGChU2LTDApxY4kfWSu1B/eVccr5SDrOCMl+RWBELh1yXrnd7nSqJKN4rNu4F6jsuyW2eehg7S9KvE5E2M1Xa8iT4HVNH0sX8jDV7VX1OsICHyetjlgnZHACNO4ji1nNjLC1WSxr28gyyDT2QXuwNrOc0aS3gisXgVW0hbfs+A4LGyISDojJcaBlQOm7oOjHeNpiW30HTfaQpARJ7WX02EBjNo0Va4FAAILjQiE4AmsBaEnO5wL2M6Ii2J1QgtB8qAvty/c3fi7RpGRCSawAkCHFF2d0Kq9jYaqcSZNzkdc+0MhvO9xu09g3XLMgcuLOCPMoDZeZMTgDZDtjA6knBHCAE8SwEp1486TIiPj44wYAwL0RLqhOYS/vu88YxeqXaJrM1jpwAVFzsoSWIvQiDKmBnSGM6KdBvN7OnHp7Ba3EXsu1PLrSkE17pAUxfJhmtjqN2p7zz3C0BAw6FYw5gisNCOnV84IF++3Y/CHDqX3ShGamX323W6me666iypVCdPIm2r3wzSbprpjyyEjGmUtthUDM3H3/J3V35wzUqZPS1TPKXpI+GSl7hPJpqHISGnOiBOm4UXPigisPDIitJwSownjIiM8+mJzmjjtpInkjIwr7JVnQeDU39ILIub4IgcZyZ7bQLcztSIj2MqdEUHUM32pvfaLzMlKy0msLLwtY/+SM1Ime0F6+4aeAI3LMmEPicDU47hnZ4TNpsle4nOPOQ0Hv/tHWLfLnsY+Sa2uJmtJErOditjjgKljFDgjrhJj75Z4BnSASf3OjA5adRsZIZt+6pUHqs+0kmeYuINfWQLrybdchn1WPEQa40FGhqax8tOKs0QnQOKIlV0d2kiIo1bMfDdj4zoAxJlnUh1POXJnfPiEfXDZe56tm0cWAXkEVp/5wjQgWSe+95AVYcsJJ5SZ/DuxwMtOOR9PTp8HoBwywnJGPCHG1MnyiZ4xx4b1Hqj7VO7NcsI0glO8KIGMsFwcjjOi73Fkj9k55/jN3rpPbTtdb6fex2BidEYAM+zFIdjjMbsyOU3ttS0PER/LeF4hBJoFlX8n27ZqZwRgsiWcMA1ThAm8CFhpAqslOuUb/I13QmXTaDjNKNNtcA9SU/LjSYw48XFGChqr9E3462UJZwgUCiCv0ZGQLzjxs/fSKZrcyl+hURNANvNB3YKEttzUXn3djRyIdOYAER3LnJGaSHSIjmm/79aMkJXdZy/5HL8RtSEXFaEEVkqE9YVp8vxXGwmJGYjd3qY5mqZ9K00Tpv806yHe+uxdsfcijZDIyScUiRp4qxQ1ywvTlK0tRI11RjxkZ846cYJ2vYm1Q+k1OpWYS1qXrL6lBUE+gZUzhzMiw5Ola9O4YRpWDr4gm4ZN7c3ljOj+rM6Rg76886Xvw+/3eAYAYEZDh1WrZkSWMaq4nKc4DFRHdjc2zXdbopz03ZXI2+/2epafwFrTKNJA1J7S1N6tW/QMxc6I8zIynJGqapoOgdUQW/LslJ23FVsFpBiVRZ7A2htnhE3tLRFf7dQaGOq21aSbq8BqEFjTPz544v5AJuTJTSA1i2BXSMTNsdhHDIVHEAvmCkTHa+Xgpo22q00InoMZd4IL0fk4J+sJz2DfFQ/r/XyckUFz9dSKOuigRGpvxZLz0jhkxOZhxFFstrdezqGgzoRyRBmHwOc8aUTTRRDK9Gf7ieRxRsrMLO2uyRlqlQjTcJfmQ0ZS0bNsP/u6mOYlQiAiqecoCtPYXzBhGhYZKai3w4X6cp0RsvCRljSbQI46uuynARNqjyZCrl22g9EimpBCeQCGLWREovP0fTvlNZ/A8fdfi1/uewyO9xynm6HYNZE4wnmb27ZqZKQMgdUedLgVVlBhBQK4sf8yxai4wc8QFuLgeEJ4NGBbeo4CZEEwqIEtEmU3P839N5GR0BpKi2KzAblett2M3kCvpgvYcatmngRIX3qJjAimLSH5gxbwU2gKdx88GVXrB91iV4+vGfESWCUy8uedDwEA/O/hL0lFoiSXiHJGaDZNyZvppGszfdRBT+LYRLpKohs0NbcXOXguKwwwM6Z8zgjnBORyRkosSjqxTiUFmErMJU1yRqZ1de2pABk6AtNhV+3katMIsDojpbVXrO0MrRJiuVV74ddvkc+AU0S2UYJNO+ycfw4l7pZ5LAEI2jY+AUVqFGmSvWjinBEzM0hn0+jjr5w+Bz885EXY1BryLnIFtATEVKf3btXOCMBwAoLAeKBlUnvtVXqRycmA44z4nIOAGfxqSaKWgiYyILNp7LS/HpARqatCVpRcLQ+jrYF2Qr70688AgKNuSsMcpuqsPAlNnc0hlk7Ay+3jjKQTlcy0cD0uufZTdSGY+0HLgoggdGTAq4QG7EF3WnsEKze22UF/tN5SDuq7XvIfePvLPoBvZiJ4XeUoEmQkrk5gLROmsdESGxkpmxFDOR9VFY/T/f0ZU0WcEc7i0H0fqxBh44wwbKOkK6fNxlef8Soc95avlmtH1p+Ofvhm/PyH/wEgS+0NXIc9z8xsGp2l53X47NfB+sKvMzLebBoTyQ6CNFxHqyyPbrtd7jmUk8BkCE5kai/lvWnOCN9nqzpAfgKrZ0z2nIE6I4PdsX6hvKkyAQYZgblatT11GY/kXpCyFR9l+KSlwjSeDkonMs+KgRs05H5azCsyVoC+c7DGiLwVpUICwOyxVJxt9zVLsPuqx5xzF770ZNLmBjWnYFb+0XLNq98B3T84x0uLmGXxWkYnJLT2a9dMpr9B5C0I89ABFwDmb1qbDh6MKNxoo6XasW5wJi7b61mq36kwDRU9o8+nZGqvg4yw2TQWByuKDQG9soQ+hYxQAmslZ8Stl6Ta0ENaJ7eCl7eqmlMjkZF0VbqxOYjPHH0qHthmx1LaOfT+Hrr0XvU5DKmYm4WMMId1FFgLwjScPfetX8O7Tvx/6Tkon42eh+GM0D7OZtNwmYvWs6LPtTNnm9x2KkQ32ycAXdxMXJiGpkpPNIF11BoL9IK4GidFCF2eZKqRka2eM8LxPZIwVDFHxwlgtB4CDxzqs8hCRkrtx3TikNQ44cR0VJgmjtOQFOP1Fp6Zkb8PLcKmfQx7ED1k6b1uNo1H6E19R66XC584lXLH4Y3kVe3NU0pNv4sJgbWYjNquN4HOiPqbT+3lL2bUUjid1hkFIHTYrFZDLYNrR+stcMNqEAQsYVdOPlUmZAcZkX+T5tsOSxLFFj+lbJhGLwKqKh4DWgjLVq8Fcej92TTldEaK64+4JkOEmszuvx9cO7jJM0CKjFSVuTdq06hrKX+PH5y3WPGiKBpAjXNG6HWxnBGC6LqckdQol44TBaMm77F0coIgqFzstIwpQUZC5p2oMI0tMCj7tW+Rl9cDthQV1q0bGRGCxEb195Sl78CUdT/EV/bFlZNBq4oCq6dmQ242TY2GaVx2exlIktdVqZY9RPeRVpRBZHBG8pyEicimkcQ9KxyUOnBW6jcxhYzEVo6/hzMCwCXbsYqJ/OcRSydhWncsBUWy+xORY7frDb8SLCeexijCFpmLjLjP1A6jBRCAMXFU5IwQAivnEPhQ5qSp06ptq1UIr+j2+FNQqxxHoqKSv1M1TGBP3rIvVi6UJ6jeTqLRtoKCluQL41yhhzBfGKbxOHnSYbGRbHYhU9CFlZNgJCFoAuh4yPDU5L0wxukJckbs90pyRnxhaz8yIojkQKenSP5E2VbtjAAaLUjIrcjjjPBVbGWYpqwzYqf2lkFGqoRpJGdETzopWdduR3FOvcjNpvHszHztysG7WSSGGQTWvHRMeZzeB5BEhVs4CD/9lw3TWFwTLmTkOiM5YRr5r+dS1gzNNv4e6mQxXpkJQI69qemm9UpT/YKRg69CCvUiI8y5pKWCWoSfUpEzkhJY48ptlUJYNjIi4BKynXNzx2OzaSqSPlG+NITP7LDGYNRWqb2+ytDcYQWEwZ2qUmfHaI9STvaEaRjUgk7+vqq96rNaHORkPpV0RhQyAip6NhlhGn0/J8oZccJUmTPlkzezxyFpfQLrFmSyk3z1DYep7+gL7pWDZySKyw6O3Zo5APkUWI23yhtLlSxtt7OZCqxwiI42f4E1RRwkYakSnBFqnOZAERxK4cy8MI3IWSGVNZ/OCD0P53jZxNciAivgwqtVFFjbtQZu2XYP9fdQdyxF97LJvUuUJ5+cOZ8dlgIQZ4QiQapkfBW+Q3XOSC1JjBVp2cFZrYRFb5wRiYxweh69EFgTBtEpJH0yZnNG8iZDzimytx/odtJsGtoeqydMH3AdAltnRJ2NGVcAfx/VBS55kcVkaMj5rjBMY4ieuam9APCFZ74OAPDZo04u5NrEVpgGAOqMCOF4jVYen1A5eLh9tZ642TTU8rq2gYxMoW3VzghFCw7dZZ763gzT8JwR1lsvHZu1s2lKwKjMisLo5FyYJtSkPQGhVvkXPP0VWDk0G29+9UeLG8uEaZQXrvga+Ssvmo4pjSNu2seI1CqLIbD2MIH4rIzOCE9gNcMdCXM/7GtzskuKuDPWd698w//ghu33BZByRgSgMqq6zQH8+IDn4cnp8/DlI1/jHsxqg5ax740z4tamcfuo7bAGQiAgirGVCaxGNk11ZIRTOu0lvJIw16oQstJH0c+f0xwq07Nt4TdZY4SKntlow5uO3BnP2n0ePv5SXUPKzKYh6FVJh0/2U0GOIVOLqcVD05zvzOvxZynRz/b7+LmjTsZL3/hZfP2IV/UWpiGF8iYmSKPvu5FZ5Omzr3v6jtWObfXVvEJ5qfniNCYywtVh2ly21RNY1aqbanqQDuPqjITmfqAcinIvri3H7U/HIp8ZZMTI5WcmtYiEH4TQL/Jv9nkOPnXMaUAQ4LiivscQWKumwdWS2HEoCnVGguyFyxwZIcwy2A6BtVRLeFP1PRwERuTWkJHXr9QPmWPbC0t7wuY5I/6ricMals9IHechmYpHUsvf96J30wO5xw5cJ+p3tz+JR59cj2NRcUIuxRlxwzRy4I8qTf7aKVZkwwpy8EkzzRiwnRGRiMKwoxCuUyiYVPt6D+EjyVdq2rwjTztsc5GRNoIgba9ssj1xT2vVceFbn2F8l5BsmlDE6HZdRU9qvh6q0BXwqb3x0HTnu8JsGkNnxMMZCQLcut1enlaZpnVGJIGVhJ4nVIE1bZxvnKb2rn/Znf3ef2zzOCq1tyJnJLE5I1NoWzUyYrzdNJ2XOiN2bRoapsn2H68Ca1KAEtDzUgsTnsCqz6OVNmkaswhCtX3MpIUaxoq85aMS9jXUCLQuzRuaotuQ1bDdTHdQGg9nxIOMkP5Br1V+a3NN5POnsLMdq+1az5GbfEwSs3tdMsV3qDuWIl49Vo2uiRh3PLEe77jwZvzfdY9k11Cd7yCtDGckJUdqSLxM+iqgn1FYgIz4SqCrMI2NjBghgnL37zunHg7BhGlUGfoKrrEK02Tt4kJdZfaX9twHbwCQOSNViLmChhVE4eTpM/qecMRzDhmhzyxiCK68zkgeZ6QoTJPuu354VJ27fBXt8kazk4qQkXrFlF977M2r2gsUZNP0OSNbgPmcEZJeZ6+AAkP/Isn+NQmMRZbnjHiNS+2Fp1Be1vW6JJtGULIraWaxM+IiQfYqgrvsHx34fPW5Tsq+q/MWISMIDJ5AYk0yvWRA+EzX8LEGT5qCymXTKM6IKThkdCsnTGMjI8WOqG2SnDqtM5p6Rh7RPd9EL6+3Ecd4aNWmtJ2eDKm8JrnISDFnJBSCZO7USnN9qGOqFVgr6IzIME1kElhN5dlyfelf9l6oxMaoqXAdue+ffPn+uceSz0KuShMG4ZTGOVo2OvT+q78LIMiQ0PKhTAF9/bUSk6dt8gz0HnKE8ISpl0StY2WMAXyYJu+aJGfGZ/IeiyjCV696MCWwTkJqr1rkiOLaNJWPbYdpcnhrQD6BVXIH+8jIFJqg1U49jG5hOQEUoagpZ6RamEbrjLiqecaqmPYfjwJrXpgmtlbuOi2OOF5Fkns1TuRNriL46w0A/Ndx/6r+rtvaDta+7HsSkBg244zYK5nxhGl8nBGR8MiIPfA2LClmGne1xzZ7wua1SfKvpquqMUdGNkgZxyxAoFK+a0mMd/3oH+n3FTUpgHLIiMsZSdSKOQnK4iIk/t5j1V6FjCQWMkKeOb32xXPzJ01ODt7OqgKAVxyyQ+5x7NIQVVfmeUhKkcw9NSF0Nk0IUejs+/ooPZedKp8enEMC9bE6zZbzeygE3vjt63HL4+tcAiv7/uTzdui48qU/3q8+A+n9nKDM3ikisFYjHAuhdUZaUaevwDpl5kNGyCDnpvbq7eSgqln0JZERpcAqGfQlHgMnbiQS9dZxL2WXyMEnhN1O+1th52N1RopXJ2ONAfzkgOMAWAXZMivMpgn0NqEQTju9seMeTCEcdhG1JH/VHKvVujkQ5CEjXWsS4yYfgytE/lDhIZKxkKb28o6E755EqtKrWXQxPYblPOS4Cw4ywjin9uo4FMIgC5Y1U1q7hzRkTzYN5TJRROP7bz4i93hRjjNCwzRFTbQFEKuGaWxkZM3gTH3uysiI3k6lT48jfFBnwjRFTek0eGfk1sfX4WVfuUanK+el9hZm0xAnQfI65LObBM5IWKAzst92M53vio9tIyP5nKO8O9JHRrYES3zICEnttbJYgjqDjBRI8dqmatMo4iPPnzBeKg+BNW9gtvUkuFoVhY4wm8rsHoeaQmYsgic1U2ckf5UVJokTTqqqLplnXjl4cs2COY1DYM3+TgxnhD+XPm71V1ATDZMUhalYG0kTWMkzZcoiFB/HckaYPmo/+1RqnBQlK3k6QZ6RVmCtEqaRBFazPVSanvbnXbbJz/rgnBG7ejMA1Ir4CxZnxHynim+OjUb9Yr9j1T2tgnalqb36WNqJLEdglYshzqEx98tvS3GYxrwm7mhhkH/nEhKWDYMgVWCtgCKVNRr2UgJwzDh98OLZlY998b5HG3/XC8JMXi4iNIG1zxmZQhOUx+AhsNpwLB+m6W0yqCR6xhDmAiH0MpzNptF6EjSGTPkPRWcWZOKTVktMZMR3jNhyuqgVVUgNYCIPvjCNzqbp3SnxycHTGL1fDt5N6aRtdZCRMtk0BZdCUYJUP6a8vkUQaBItnSy8Rd5y2uKm9nLIiMvRCGKKjJR7bvLaAqFDCByPymdeAispEJiXSWG3Mo8zQt+vWgFamid6ZlsZnRFTk6NCmIaIngGkb1QmsHIOTXnjwzTlF0JA+TBNKBL1rskF5UQqsOrxa+I5Iw/P3R6Hn/kDnP28t6tzANUWE0AWpiHZNFMYpdm6nZHAg4yYqb3WoENefhWmUavKkqm92YQ0EOWHaUzOCJ/yxsrBZ59V1d44TietnKJvXmML5eWrFcqjy+tqMNoOxjUzzQmCQLUzFMLJpnFjx/mXkWc+ZMSoLsucwC6UpzgjZEKwd7PRA+7Zl4WZAyHSc3mQuSInkaqRKh5HFe0O63xcf2gwYRqpYVEFGaFpkqo2Ug+iZ1TBFYCBflUZyHPDNMy76DMbXTMJzcXtsENdNaGDRHrxUWxJYl6/em49ip6l5zed+4fnbFvoe/LICOdg5b335dAohYyQc0xkai9Vo+X0oMZrq6bNKSWiCBQQWLMMphYzTm9O26qdEWHg6QQNMbJpeAVWgEFGynJGcqB6L9GILYhFCzC5O8qJr5lEEIQhX8kZIcJp6quSXriqu8EQWItqygSwCKyWN9JLpVWfKYTDJtwVZNO4BNaMM0K2Kcqm4Y5b9HgEmZgFtNNU9rl2GefLlzKZd0QHGWGccZujkToj+WmInNHMBK3A6u7vm3gTok77nr9ehAOeTImLRbwgb3uYxQHHGSkyGyXN5YwwF2e3g+d2lbuumEFGymYsySs2HJrMwbr5hNfh9oW74W0v/1DhcYqQEYcrxrWlKExD+UdBehDN+5q4KXEya9NIs8dgb6E8zw3pRImu2tttT2jbqtpW7Yz4yqYnBP61OSO0M8kXX3FGSnY0p6y6jwFN/2Dlp/WUTici+ckY2BKti1IJymuU4Iw4xMn0b42MMM4ITUVmkRHtzOQpsE4kZ8TRRfDojEjT3Ivyqb1dct0JAvbiDd5QDlcllARmnyPhuTcaGSl2MPNW9vbAza0qp5MKxYDJGamidpmQZ6TJleU1G0VTryDfee2P8Zvvvzf7YeKQEcUZqeSMpPdMycFXnAxduf1Yc0ay70oRWIUw+k8RMuIzM9ST3tsHn34MTjz1C7hv/s6Fd4YnsHIKrOVDaraZYRqNvtLfJsKoou1Eh2mk2Wh8qbnEMoqM+HR6Nodt1c6IoJOPwRnRAw034EWqM8fZv8VxTGr5GRWebsMW5tIvJ1Vo1ZwRfZ6g29VqolX4FQ0Nb0t4vDQyksMZKVPqWiEAOTLtE5JN4yuURwu65Siw5ouemfvQScwWQJPmT8Mz+1mYZATWio4ZF5by1VWphIwwq2ibFBcI0ykuG583dEZk/+Oq9nrGUp/jEhagXz7jrrXBEFgLjxOYjqGhM2Jty3NGzOuqiUSF+aqghwJmyFD1De976rnGIFDOmErtrTAB377GL9cPuERrPrW3SpgmvZYiIcdejNb6mejUXml2e3urTZMhI1EfGZkyM1bcXgKrOegEgUlMAsp569TK6DPIc0ljFVgL4D+6Cg+ibmkngpqMtQMaSi7SGVmzyVzlFWXTUNME1oC8zAJn/uhm3LZkndquKgSdZ3JCcArylQzT2Dn+lLSYV5uGq+ViGzfo05oXQpAwjeX5+CDsiKR8q+97QJpsJIRzMP/zhe8y/qY8p2rS8yRMUxGJTE8csohFQIiLVTzaiUNGih26PGtbYQ0+9FYGGbHTcrN3tqzoGTmFeg8YLlORozDWcIt3ViawFrSVjt+yPRMpoigt2SzISFlnxH9XFDLCFJHcnLZVOyP+1F5CYG248sSJVfVxvM5IqQHIU82SJbBmryMdMEUUq0J5lWCEliaUSYSjVsBRuPq+len5ZTiAIUYVycEHgX7RQpHgmgdW4yVfvkb/7sSOe1/R2LLu9jnoeajZBFbpsIQ50DbNpvFXaM2/FkrmFEKvgMv2Pw4JkkXN3FCP/ziGY0Umc7rLtTsdhMPO/CEu3uc5aZuThBTlK//UqN5FPYfP4GtvgIB/z5LeVsRldUYKj+OEbHOyaRjYZ6xlVsGtZRkigqCmeZoc6tgwwzQq7ds3eeZcou2kV5llRutMmIaO0yUQ0aJHqWXa0ycVBHSBNfHOiDFOs6Jv4z+H/tsTpsk5h+KM9LNpps58YRo6yHFKiy4yUo2Jba+IYw9/gg7VAcMZAfhqkPIYRgXQbm/ICBp1tdKTnrOKr8p0S8+uiuDJKrAW36vEh1hgYlcyEYFtqQlS1TZPDt4msOZpS9Bsmm4JRIwzytIXABDzziE/UAeGGJ60Xqog02eYl5K6etpso82GM1LydPTdUrouzP3LC3lzzl/QyzsBIA7dRQqnM1J8HAslrYAiAEDHQhIM7Rj1TIvbIe+b5jnIME31mVLreJjhS6AYtRjjnBEmm8ZXMTz9rmT7iOjZpIdpcnRGxkPTKO2M5Nx5jYz0dUamzsogI054JDDgN8Afb/eZvRryTUrUhE2kzc6rxHRo+wlaIo8dRF2A4YwUvXtBEDhVhsuGSKI8zkhYPOgaRE3LJnIl45OD9xGclZ6IjYzI9o4TGaF7G6E6+S9h6aer5WphD7tqL0AzwspzRmj7/ShPajS0pJWAyzsj9Dk3Mkn3SmEa8FWFpeZJVac2YhYH8n523e5auk15Th37nljfhZTAWoHLJvuWw4MqWQWWTnYUuUt/dBdKPhsrJLCaTgP3qgUI8IZn7AQAePYe2zi/mwqs6XdcSGm8prN24s0WpvHL9/uPQZGRqbSt2xmhHimdbMjAynE1VPaFQkaqrYjyOCPGEegfTLiIEqMC0sk7kX55JQoTRBG7+i3jlbezXHbpjJRVK5QTUO9y8NmAw8hKTyiB1ZPaKwfzlE+Qs5/NGclpDCUv2wJo6rxFBDwC/9LUXieryeNKcKm9OiTVIzJS1BeyoSaEJrBW44zobZVycYXaNCnXy9y+HkfK4Sx6d+1nYhNHAd0P2hWcEQcZyXHquDCNEALnH3WybgOTeVIumyb913Gwe5g8dZgme+8rvJxSgItaAIqMlAjPBsBZz9sTF771CHz9jYd521dLUs5IgGr3qqyVrdo7kWEar2ZVzjH6yMiWYD5khAxyCVPSmupfABQZKTc42sJXZTgjQRiqLB5ptNQ3HTTahjOSwZlRZKxIy1oQAJ266Yxo0bNQbUPtyF3npeeWmQKFcvDMeREYq2nn9wkksHqREcqN4TQePIJV9VpOmMZARooHDm6gok6a8PQBnwXgkREtsW5zRvzXUgkZoaRGgzNSri/Sa6vH+at2n9nv2WDUVveuKsLG8aV6CtPYk0mFkIa0Lz7r9fjPF6RE4ZQHEUCQEG6Z911Yk7wMPfYUplHOiEQDXD6bzzgCKw2fqr4uM4Z4XwT1Wohn7b4Nhpr5YXbZhaTDMzm1afQ7OtFhGrsf+sjTpTkjU0ga2aqdEUFXvsTywjRBAKO2AVBd88JeEedVvzX2s9T2AugwDZ00dps/HftsOxMARUa6rLBVcZMDpfInBayUWqen47/skO3S3yUyYldKRVlkxHT6qE1ObRo7myb/HLHVDzR0nBemIZyRCjoZAFm9Epg5zabxtNPTDFUmgCmUZz+X3DAN2bbIoVaOKwnTJEFQesY1OCMyTFMBGUnbYG4/0G0TwbiKzggzakvnrlFBpr4SMpJzHI1oJOqeqmdaYoK1wzRFcvD2Y2OzaXrgdbEEVnKva9Y1sQuZssiiqk1D3uEJnBINbsqkpfbanBH++HljUh8Z2RIs4aE5M0zDeNaG6JQoHbZQ+zvZNOVIaza3JBA8gbUWBrjknUelx5YDdhRpnZEK83cQQDsjsUlg9Q1yWo7ezxlpE8fKt7rJ54xMHOHMzxkpcEYsgq7SRcnhjNAsDK8TWoGAJwD45OC9beAK5fl4Tzltof24qO9raf8EIAqsZZ8evVe5BNacY9gKsUPdMS1NX7EfceeRzsgRu8/HSw/eDj94y9MLj5OXWVelSXbomFqZVGNhLVR0Jkw1hw9g+gLN9CvijLDOCMMZAY/KAsU6bVRxOaT9EhOzuJEm++zm1BnxtT83TCOr9sZdM1qwma3a0uyfzLQUtAV1UWSEIY4mZPVA45llYWPbqSiCuKXZ6YRGJ7dWY5JEKQfgMNIOQZXQRgDXGbGdLxt6lZyJPJ2RNhMbti3JdUYmMEyjBidbgTX/HIkV7pDQ8VDT/zzps+aq3AL+jCp1XplCLAQiQ4HV4oxwTl7gVnNOj1X9ftYa1LEq4IwwaY7VyhIwnJEKE2UanjLb2Iy6PUnTAzy0LvvBQKuOL7zukFLHcdWY/e3gzqnI1MSJkHe1Cg9i4cwBrB3pOjwof22anPCddQ1VnjMXpqEp9k6ImNOOKXC+5D0Pk4Tcq8kI0xBuyuaSg/emYvvvCeXpiPYYgMGJaFpl27qREQX5+ZERWw6eDmoG/IYKqb2WU2Gshui56IoC7ioqEGB1RrhzhR2trld1FdixRHGK4uzyNijZ8QJnhB1QgsARTzJ+n0BkRCJT09sjmD26Qf/gSZlVP8uBOzbl4J+9x3wcv99CvOu5ezj7UEfUF9ooHkxJmAaEM1KWQJ31CUrY9aFdeW35zXuPLnU+gMbPEyubpiRnBEJxphQyUiEcArj3O5Wm50O1RWZXkQb4VNYis89bVfRMNkOFGnMyT/LsqycfiqN230ZtW1X0zGiTfb4aP77x+7rno9fk6At5HO48o5y/NFIYTOjiRp1HzROxTu2dQOQFcO/XvBkD+MiL98WBO8wyvs9FRuhYPDY2kc2rZFu3MyLhbQcZIWEaBhmh4QM6UZaeDILekJEOg4zIlzPwvEQqtbejeRvVCKyBOq8MRxSVq5bQZy4yUnOJwcZ5YfIMnHM4egO5h8s1ef+f+dhtuOWLJ2Hm2Mb0h9JhGnN1XQsDfP2Nh+Os5+3p7EMJrN6JhyIjzKkF6X9CQPfjEmm5AQLV/+pER0VKd1dZxc6fPa30thQZMQms5UwI3R9UWKzixM3VcUFS7rrLtLPegzZHHjJi3x2RE4SiPIggCDLRMzOkkWe7zp+OH771CJN7AvRIYLXbPb57y9emkc4Ih4wUtI9wvSRnZDLCNOxiarLDNGGINx+1C/ZeNMP4Pu+yolpdOfrB2OiEtq+KbdXOiPAQ/2LqgDBQugm/UWekLDJSLpvG7j+2WFrg0RmhJge7gJCTqrxwRpgmKscZUc6I5IwwBNY20RPwrW6onoZzDkwkMmLe/71XPpK2oYCLYadBlmkLrUdT9rnbRgtwCZAMg4oKrFxqb2Kjb3mNYRz1dB8mtEQcKC16VhGNUNlZfp0RX6EvGp6SVk/inkXPuLMoh67ChONyRnobkjkV4V6urVcCq3kMq19T5JlzrgvaZIZpTO0Uth0Fl0v5NZoz0htClmes6OMkE1h9Y0AegRUg6Mjo1NWn2aqdER+8HZF6D7YCaxAEYAsgoXy80VVgpQRWT1uZwTSA0KsGD2StXrwuQUaqOCOBdkakKE5oMc/tw2lnpDoyQucSZ2Ck5yjI6Kli9gst75lQaYS82chIGWfAREZ6o2wpiFqIdPL11aYpCN3RME3Nc4xc83BeOIeAZljQ965sVxTkGK0edEYABhkRCRCXFwYz2iME3nXi/zO+02hChTCNI3pWMUyT/Usn2N/cuhS3LllHkJHyz9SVci93LfQ5ulldNNxc/X3NCz1xzSs6B83SCwIYyMhkKLBSBHJzICOcFV2V5I30kZEpMrsKqrSIkKg4nRG2ABIqhGmsDmOHbaTZh7NTQUNPNg23T62jkZGqE/jK6XMAAAs3rs7Oa5LIbJPz2XgIrJQzEjDuwIQWynMUcbP7XKBgaSNDZbKUojKcEYsr5JzXQoxUzaESzzUIwIZpfPWVco/oQUY4UytZK7W3tM6IYIiRlTkj5vY0TFMZGRHAxfsegwPf/X+4d5sdARBCcAWHzkYRyixMOLOdiI/8+k6S2lvdGdGZd57JLeeQZSdIdayCNtEx1tYX4vlm+cejixwbGZlIzohcrBmLqQl2RhydkR6eF6DH4z5nZKrMU/CNIiOCkX2OCVnMCCGUzYrJq02T82rak1coEhKm8UyY8qWNekRGEODR2dsCAHZa+yQAnXXiO47M5FFhmgxWp05Qm3HyfG3nCKx2qGg8hfJsU5N8QUFAR5+mxEBGHcpewzS2zgg8YQ/fcWSY0ID0Yd7PUkaQibAAbDcyo3qQg+faVo0zEkBYw109SUhqb1VkJP13w8B0I1UUqPZ+lV2Y0HPyx3FTe3tDRmzyafUpwumHBbpGRWEaozaNVdLCJwuQZxTZTvefHAKrIgOLyURG+DCN3VcKqyXLxeFTDRn5yle+gp133hkDAwM44ogjcP311+duv27dOpxxxhnYdttt0Wq1sOeee+LSSy/tqcETaonZsaVFlM/gCI2ZBNbACNOUe+lthMMnfmWneNqDXFE1SJC2gqyCq6wCgwB4bPYiAMDi9cuNXq6Kn1n7OARWWbODXCfVE/A1Rw8aHDIycZyRVdNmG39L54k6q9yA6TgjJQZ9s7hcidRe5pB0MAVIuLFibaQQAmH2bHy1OcreXi79mhpVo/Q5T3kmIFxkpOLAPnd0vfF3SEJGlZ0R0iMcp7lCu8qInj1/34UAgFOftbP3OE54BZprMX2gOI1en99qu2+lbfV1+rd9jPGSQgPDwTLDKVxWU9HEa8rBZ8f1aE6Nx+yCgemJJjlM04PzCABveN05eMY7vovuYU+biGb1ZJWD1j/+8Y9x1lln4YILLsARRxyBz3/+8zj++ONx7733YsGCBc72nU4Hz3ve87BgwQL87Gc/w/bbb49HH30Us2fPnoj2j888gkdRk6Q6NfwE1j1WPYZbttUZE6UJhNZ2ZbkmblaJdkYCTydUyEhBBdo8WzuYqrk+87HbsGh4tXNs26RPZq9kx+rNVFgH5YoD6tW0yxmZSDn42xfubvwtw0paD6NsmKYaMuKt2lvwfASd2AE1uTu1aTyrRjrh1ZMEnbDWU2ovNa5+EDUDzSHk47I9UQjmfldUsN1p3TLj7/o4wzTSFDegh9Ret06Vu+8XX38Ibnl8HQ7faY63IZHloAIa7Xrl03Ys3R5npd1Laq/9VA05eNfs78464b14482XYrg1hOc88g8PZyRtF9ftCsM0FBmRmj3oDSHLM85BnHBnxMITijIcfbZ0ZjZ3N8s7rhNtle/M+eefj9NPPx2nnXYa9t13X1xwwQUYGhrCd77zHXb773znO1izZg1+9atf4VnPehZ23nlnHH300TjooIPG3fhxm+AHcYqMJK0BZzfZmT941f9itzVL9A8VdR7U3wSatdEQag4CQTkjnmFddU7qjOSkD9oWBMDGphbBOfXm3+hj+zgjMkxjvdhrhmaqz9IpyWtDmTDNRKTi2fyVRtw1iKG+F9yO95eZ0OjkUwYZ4Z6rPK+6L9In6UF0T67aQsFPpOWRkfJhGiP8VeHxjQcZ4a4j5YzkO5w+S8jlOtocFVanbqEzt08MNGp4xq7zUM85ruwTXCXmaYPlJxhnMh5HoTxpVe/tL/Z/Ll5+ymexbEZa44r2LVtnhEVGSrZPSRQkOhGgUpiy8DxZv5hEAqs9/vXC8dlSrNKd6XQ6uOmmm3DcccfpA4QhjjvuOFx77bXsPhdffDGOPPJInHHGGVi4cCH2339/nHvuuYhjd7Urrd1uY8OGDcZ/k2FC8JMN5YxgwHRGgsDU8N93+UPpPkFYehXZqwKrbWk2Tz40rPLxCYm0ihw8YE6gIw19P3xhCemF24OSlB0GOJTHNQXtcwRWTGAtCev5t+Iu4kQ7I/606XKrEmqUL1S1No19ngAmt8Uehn0VTWl/k2mHBjJS/GgcM1bkbGovDdNUX4UKIVznr8f7J60mEhWmGg88TxWZU6vCGbFSez0LkyKz6yQBZBKvMAHa98EX8shJmHHRnZLlLty2ZKguo8CquBEl2mZbbC1y5kxrOvWlJsKUtP6kckZ4Z8S+L1UQyKmySndm1apViOMYCxcuNL5fuHAhli1bxu7z0EMP4Wc/+xniOMall16Ks88+G5/97GdxzjnneM9z3nnnYdasWeq/xYsXV2lmaVMrNIczQrJpBlxkZKirc7Gf8djt6XZBmCtKRC0Ja8ZE7s+q4D+r7wTpZMwG+28/kxBYe5WDD/Dw3O3V3+sHpqvPvqq9KpuGiR1//lmvx9W7HIo/73KoPoePM0KEnGxzSomPcwy5bvH++thJgliI4mwaZwVY3Ihumdo0BcewESPNGSmJzDHIiK+oWdn7SieMvNReSrqu4hSzYZpxDuy1JFbtrq4v4XJG6j2kRzuiZz1eE1dfqRcJcqev98BBmCjhMNpnpNnvPdfXCgvlEbJvEADzpjU14jKBOR2sNMFkF8rz1gub0NNOik3snWEsSRIsWLAA3/jGN3DYYYfhta99LT70oQ/hggsu8O7zgQ98AOvXr1f/Pf7445PTOA8nIKZxM8YZGezq9KcX3fe37BjVnnYZuN42G02gBDyuk28/e1BP6AZnpLwFQZoxcPvC3QBo4TMASoTKNh8yEoc1fP6ok/Gm13zcCVVxljAZAqpdE0hgBYA3vebjWN9KFUVrIkmRkZIKrKq9pXRG9D3r+FJjC5xQA2UAVLixrCMhgtCpQWIM8j3cUopehcxknFDHUqIRKI8mAozDwGS6VTHKGan6/tIwDZUXB8YretabzggtUSGtCDXlzB6LqoZYgHyHpsptVoUnE/ea5Dm4lXyVME2AlIws79vE1qaR4TvijEywV+BLo7bPMpHZhpNlle78Nttsg1qthuXLlxvfL1++HIsWLWL32XbbbbHnnnuiRtIA99lnHyxbtgydDl+yuNVqYebMmcZ/k2Ei9kFz+m9hcUYCBBjsuip1VYlPkaHEWe5ltXM6aNVejsAqBAnTJDSbpnqsXab3tmKq5Mrv43NGfI6D75LtUuTGOXooT55n7XoTty/aXR07TkRhaq9LYK3GGRlu8XLqpQt92SnIYYBDdpydu688tuxzcqDU6EoNR+wy19ijjNEJg9tD3qtQCJVOW8UBoKJn6juuaq/H0w4AtJlyCqVDRlZT6YrcJf2OgzNipMFWd9RqBmdk/GGa0qJnTFu4X6tMibrqbR5nhGlLITLiIq4aGZy4SZuVg59gZ8Qe/7xhmpKnLYvuT4ZVGsmbzSYOO+wwXHnlleq7JElw5ZVX4sgjj2T3edaznoUHHngACXkg9913H7bddls0p5C5C8CrwNqkzsaQW8FwqOsKw1T1qCl3oAwyEoBBRkB1RvJJoIh6887V5JU5TxQZ0am95vF8YZqqDptOoZ7c1F5pNPwRJ8JbLgAADt1xNoOMVHNGNvicEYqMsO204GuC8C2eM1TYhrQdmRieldqbBAHOOHZ3734+q8IZ6SUTSojykLTPvvaMVxt/15NYZZmNRw7edZKqcEaKCaxljGofSesFGZk70xrvfFy0nDkrr1BeFdNKw26YRihnpDqB1UGyiEczsdk0Jql4IqXm9TmC3L+lVXFsp8oq352zzjoL3/zmN/G9730Pd999N97xjndg06ZNOO200wAAp5xyCj7wgQ+o7d/xjndgzZo1ePe734377rsPl1xyCc4991ycccYZE3cVPZruhOaDWrHjbupzwDhMNBNEWtWOVkaJs8gCoV/OwDNoqElAVpbtEa6Tk1czpmEa6YVbTpInm6bqgP/03bZJj8dwRvTkOYExXgJ1x0n+pPnTtz8TJxyyg/FdmXgzDU95nZGCY9jwtUQaEBSLiKnkKllR2Q7ThDUMkHT28tk0+cjIDnOnZ9vFRGismuiZS4ysRmD9wrNej2e847u4crdUS6GWxCrE1avoGcDVYuk9LGIosFZoD4eMFFX05mywZYkR+pwRG6Ul53AL5dHtSjdF93NWZ6R3AqshwBcEhuzBxC5u5HvaWyiwyjmk9SoHvyVYZTr6a1/7WqxcuRIf+chHsGzZMhx88MG47LLLFKn1scceQ0huyOLFi/H73/8e733ve3HggQdi++23x7vf/W68733vm7ir6NWUl21+vWS3/fGG13wCD8/dHh8t2YGqrmgMzghl0FNIs+DcRjl2ZlsKbcsXruoLITeXGUCGI+Y5lpcz4pW954+z/bx0AuPCNMEkxHgpYTYhyqbcddbCAC1r4C5VKM8I05RDMXztlKhY1UJ5tB1uam9vw5YBpRfyXKpD4gLCJQxXIFdGiYAIQiybuQ0he/ZetI9OgmXTK9l2jZczIsz9jIlbtrLCO+KEvnp4v+z3vFeiccIgo6UIrIW1abK+qFLjE/Lb5HFGJvLY+hx8mMa20mGaKcym6Sk37swzz8SZZ57J/nbVVVc53x155JG47rrrejnV5BqRpaYWhAH+usshAFyxmLzMjyoPslNCFtw8MfOVKCF6Jqv29ghHy63lip6TdrdNiZ6VhBC9VvMTWB1Z6GpHZi0hA7oAzabhj+4M3KXCNPq5ezkj5Dh5FXBVLLoH9VSNjNipvXYxxnJmOoxMmxnOSFXRM4dcWQH+H+no1a8i7xJnnnvGrzl8B/zkxiU49Zk7Y8OYiYbSSdBBRceRTVMVYa3XMsc/pxJzJYfCbnuVwomZ5fNOqvNgeAXW9LeEIY0UpvYSBeL0IJMTplGpvROQPu4/B+8IT6VT0atNejbNFm0eVIH+VSv5MlaNX1OhLaM2TQ5fwJ6Ujaq9bDl1ioxklU5tx6skrC+LxzWzFGH6YrmckSxMUzJt0dsERlVS/TQZVTZJLJnWfPGudK1sjlLICHFCNzVdPhJQEWaGmdpbNAgp55KgAwDNBKnWP6SZxEtmA6p62SP5uIzomY+ARy/LSIPNQUY++fID8PN3HIkPn7BPbruc517hulw1Zt2nyswnQ810+8gWwkNvBFbHwfOqLPvHzLyqvVXMyRoD44z0MOnSMGcATFqYxs5YmyiyPTVXMTcfrd6Sre+MAM7LYjgEzDN8x0vf73wXB2Gld47WZrFJbD6rW9yJUGjXwsfglwiGL0xT1oPu2sgIeQnsCUA6cGWzacz2kGMpZER/95U/PYCPXXznpFTZ1GGaGEKQSd63g+1slWjLpuYglsycj9F6C7ct2oPdJvB81ueRg7R0RtLv7cm5TNFFnU3Dp7mXNepk8W0mzgghy/YigqWsQkiDniZSKEKissy4vtmohThsp7mo19wUZEqctNGkagTW8YVpBhv1rA0a7ZEvdS8EVntb2h9adf15gCmTIS1f9Kx8UwRZHKhDlVFgLUJGVF+M022Fi5pNhNmckclARhz0uZSqs9+mElDZqp0RocI0ptGBh0NGfrf3Udj5P3+DJ6fPU99VnRTHCDJiV/FV7bBObYjnIB1sagUDTkImWKAXTkCQtdGswJsnWKVJkmU5I54DMaqS//37e/Hdvz0y4TojAIG6ZZimCBmpVUdG4rCGF775y3jGv30Xo01XwwaoADOr2jTVlT9jC9b3yWGXDaR0SB9mOSNcmKZCexMhXBG9XjNPCNlTOUYVkU06B5YlEbJt6cGhpaaQEXIc7aSOnzNCw7+vOiwlbO+zbb7UgkvkDphPxWYXhARASOXpkV584HbOfqU5IzLETeCViUQv7No0k0NgtZ3HLR8B8dlW7Yx4wzTkTy+8FQTo1DWBMQ6rcUbGGsVhGuN0CEzxHFgprx7OiNIZYcIreeezf5cOU0M5I5T17wnTjPdFyeOMTLDOCMARWCWPwsMZsZyRsm0Zbk3D+sEZOVvk3yc7y0ChGiVCLEEQ4D9fsJdKO5TH8FXtLWsmMuKeWBf3owqs5bNphGD6UwUCK32P5ftWF7EzuZU1M5vGP/kW2XiRkdOfvSsAc1KSz7QnZMQO05A+dfaL98VnXnkgvvdmt7IrvX1uai9FRio4oBLVZQissp8umjWAO/7reJz6zJ3ZtrDHtUNakxSmkfdhMgmsDtL9FM6m2aqdETWI55Ix/b/RWitV4b3REmEae1DnkBG9MddOvZpUYZqK3VJu3ZU6IzHv1Bjt9IRpfPfIO0DlOiOTjIwIAapsyrH23TDNxL/y3CHjwFwxBhUdiQCBU5/DW7W34JI+ffSbAADve+G7c/cRqs0lECePjYfASk1O+KkarERpqmbT+FfTVZCRvEJ5bJ+z7IAdZuGkI3ZkJf574YzkhWkGGjW85mmLsWAGj+hJc1brPSIjRp+RzWPe++mtemFonZpCXLKq55QgO6HZeRb6uDlSe70Oz1MAMdmqnRFlOWQse1FMN6XISDIOzoiBjOS8rr/Y/1+Mvw2kxKPAqmrTeOKWrzk8v+6PdBTkylcWCczz8icsm4aRuFY/WUS2iXjXbAKrr3aRspp/0B2PFa/sMpTBzqZxQizMsZFOpMpJtVbRVR2Erz3j1dj3vT/FFXsckXtegzPSAxohIJisld6Gr5jwZYpUdr3tyUNGKsnBl3PY82z2YMPYr5akvJHeUnutPtSDwzdRnBGtwOxWIs4ffwqQRTKopxwm4lhOIIagwjRiElN7rSl8vMhIGQd4smx8ZS+f4iY8VGy6Us/LpqHpuVXDNO0G5YyUK5T3+aNOwj+22xuD3TF86Tf/bYqB+dJPVTaNi4ycdMSOWDQrf5Wj25g5IzJMk7OtvH9uNk3FgS0bCLkKv5PBGaFhGiGgw3glwzQT1ZbA+Owe09Zf6IV8aod6/JyRYhvxZAVRS0LqjIw/tbdKlWy5vzSWM1IVpTHSQS2ovMpxJqiCN92vRkJhAKp5APZkVhZtI+dws4vox+q8Jvr++977oAL6QnkxIQBQQciJDNNkLan3qPFUxvxVe21Rugk/9YTb1o2MeAis1PJinJ0a5YxUG0RGPchIXhi8W2vgij2OwLqMb0ARA68Ca/aIpQIrfSGaJWLuKkwjdSnUcYpXJr1k05gHMmFO46eCIna9mEtgLZjkJ8sZKTiOndpLxftMtUv/cewwjb9qb/Vr4vbRnBHRuwNA+rgPTi+zIKDS6UG2aq0Kz7cjIpQ1DjTB5YxUH5KDwGx/LYlNPtl4Unt7aI/zvvSMjHBhmmIEr5AHZ90r2R8nMkQD6PFgcjkjNjLCX/w/XaG8fzorQWC1kRH6UA2tkHFl0+gBoFWnIRvepMddpjS1loN3vfMyA4MisDqpvTmcEQ+BtTIEXXNVJdVPkwB9xoTYlghozojvSUxAhVPOih6LrtlhKrAiNLktbJgmyDgjVqaCjwQ7a9CSB+/RBEGdyiwCnP1hOu1JUOt5tac1VmLNGal4sA51RmyovBJCZb8j1ZGRAAFEECrCZz1JTDRxHJyRXmaIMnow1Hy3nq3aizLPq8iZJ2OsED33gSKzxdU2R2pvrxlmav8pzO3tOyMA7M5LHY48yQATGanojDQogZU4I43imB9XzZZDRgTZViuw6u3KdDx5L5QcfAnOiC+1t/JkzcC06hzZd3rgG/+LTifolMCaj75MWpimgIynVoxSDp4QQk1khD8+lVaXq04dpkmv6bOvPgjP3XsB/vU5u1ZuP/cqSCcnRGKElXrNpqmKjFDYmqZcViX/SuvEftJjVflzWiKAHqvsxGC/b6HoHRmx0T4f4ppnbgglHxnxXadaSIHRGckRbyzkXFHOSBKr1PiJFiUbT8p3r+fwF8qb8FNPuG3dzgj4yaZUai+Ads0ksFax1UOz1GdaMI2KCdEBj5qwIPa0oRyBVSgIWXNGqpke6EyRrLzjyEJ59n2dSGRkUsI0isAap9cn4dUwxLP3mO9tn73/eK28ToIksJJ7YVAF3OPIY9NrBWhqb/r7Kw/bAd8+9WmY1qpOK2NTe4k2ChU9q+JEmshI7/faqONSclVs/2wgIzkciTJmcGHGsbLVTlZiZIiMrzZN9fbkhQ4qcUYkOd3gjBSH+HxnOHjxbADAKw/fSX1XIyJ8E11V1x6bJiXbrmRY7Sngi/QJrAAcAS/6pxOmIX9GpCNUhVeXE8G0DQPT1Weqckjj0tRke8uFabIXepxxS1vauMxgMN6qvWV0RiZHgTVFRgLi7H36lQfisjuXse2TtrkQTiflUYVYQq8cum30WgEowmNlknFJo0iMJiFWeXZmNk0Z0rfPdMolUWCtOFzThYJzHRX7ZNioAxJx7GH1vHhOWnAxCmtoxV2EIukdGRknygO4731AnZEKt1n3cxcZyVuE+HhOP3zrEbh9yXpsN0MvIsNJDNOULWI3vnPYBNY+MvKUtMAXpimJjNAVTadeza+7c6GGvyn3hJJKqTNistU10ZL7nZrNGenVRe5FTbBsbRqvheaEafw06TojUN5FEoSYNaQHsAUz0hBbr6JnRVY2tTcQCX5w3aPQVUfL3QshzGsFXGRkPMYegjzLnlJ7hUnu9K1ivWEaJpumnsROeKqsveKQ7dVnV6a+Wj+g54564Iy84IBFaNZC9roqt2cCCKx2bNsQSKxEYGU4I55FSOD5TG16q44jd5uHkFxjmMTKIZ1oZ2Hci7ESZrdZ9SXrPegTWLdwEx4v20zt9e9PB45uWI7ot+PcdBXz6Jzt8JZXno1XnvwZ77k7HmTEgemBYmREiZVVe+ROmIYTPbORpcA8t2pLie5mvEM5YZpelTPzjGaYpGEas3jc/572NBy3z0J89MT90h3CyR9sOKNy1jc9uhaPrRxW7SzkGcjn6eGMVCXAfefUw32nMEyqpdLU3qoKrJR4mIRhT5k+AJXTT6yQUXk76/l7Kln08XJGhMEZqe6MzBxo4NxXHKCvK0lgsIc2c9Ve+/oN0vw4wzRlFiHF2TSBQsJCoVHjyQ7TTAYyYucZes+x5fsiW7czoln9NuGKfM7hk5jISDln5LunaSnlK3c/AjftsK9325hBBAA9qdMVQ8AMGuni3kRGqnNG0v3li9pIXL0SnxfuViTtERlhZlhbFnoi/AAtehanBbisbJpj91qAb73pcMz3ICMTxhkpS2DN7sHwSArxiwpaN3Z6cK9VkBfNdDVGODSRhpYKxeQYExClkJEyZhQJ7BFha9VreN6+C7O22ftWOxblVIwnvVTum8rcT2Fqr13fpsfQn5PCDr/OiHG+gvsfBAFx6GMlBz/xqb2Tv1gprcBa0vrZNFNsTtE38nctpwPRuHXHU+zOtiqpkt3Y0zNKckZSoSiTwNprZ1WwfgXuybgVWKdKDj5J8MlL7sbvblsKIGe1MUmckaLB1BUsqy56lgSmQ9vLMbzGNF85jUiIA1BhkiShpar7yv2lUdGzcDxcKpnRZb97tap9kjojvU3cQgitn5IkJUpFeFripPb20B4HGclvSlFqL0V5fDojVbJpAFNQTRVunOxsmknhjPhRKGpFqrRbgm3VBFZfrN1M7c3jjOiOQAuFTZRRlUfaCp4zkh+mUaJnPdamkQN4M3HF05x9ZJjGCWNUfBkrEFglWjEeozVf/nL/KsxeuREAvEJCTjbNBK2szIHVPbdxHym5JSgmsHJpoOm/2SDfY72XIpP3kE6UVRRYAZMkHodhtTon9Dgkm0aUFGBjQ0/Zv+MnKurWjQfxMZysCUJGegqF5cnBc+f0pva6CPBELEICEKQuiREkwbiPydnm4IzE1h2Vz8++pVu+K7LVOyP8W2AQWG2iPHmsFBkp64xUebkjT2ovpzNSWg6+4gvh438Yx7EOWQ/5ME0ZZ8Q4VOgORmo7a1CaOTB+cS66skzbwofxpE1WmKbI6KBGMyeqPFs71FPrMUzDrnS585HUXvRAlk1Fz0oQWEvgU1T0LB7H5CaHj/ESWKn1iozQfWvCEj2rcm32tVSojCzNccZ6JLBqzoh+/2seAqtxuiLOSGDywwJZvLcH8nCeOSnOkxKmmfxzbC7bqp0RL4GVfC6bTTMZyEjkqZ1jK7DGOeJReQqsZUzxP/LImlYz501v4fVPX+zEAMvEZDkCKyd65pMvH4/ZiFNhzRe7rshkcEaY3+kAFApBoOtiAqs8nu3Q9lLfxnsOljMiY/S6bkrVMI0peta7AqtEsOpJjKRHaXpAOz5l0yu9RrYfj84Ih4zEQYhKR5yIbBrbgTGQRffeFIZpWJ0R/z0uCknQqtWBEAhjvi7TeM0JU09C2nxZYbXSRPHNJlDg2lbtjAQ+Z4RyRnLY5AZnpNaYcPIPdUZom2QHbBQIkKUKrFnn9FTtLTIF61eEHM97xYFqv5pFBC1tpar2TtxKgIZp0n8LVs2TViivHGcEkM5I1gPCsPRQYuuMyJTteAKcau6VEUYGi0ScKiKF4xAHozL5MgsuFIkK1Y4HGXGr9o7foehpXwMZ6TFV23ZGenHSHDg54D7q7QvCNGZtGt6RDQrOYTdH8650SYCJzqbZLKm91lgh74tdffepAJhs1QRWb9Ve+Du2kU1jpPaWDNOUbx66BQqs0vJWdWrSYar2VrFc/kfOIekLWJmtnpfaK48/gdHQxAoLqUGwpDOy2XRGaP8kSEOlbJrQvLeKmDwBnBG20jDJjKIqmmWfnoAw+mAc1np+8lRNOPz/7b19nB1VfT/+nrn37m42D7tJNtnNc0JCEpKQBBISAgkPEgjUIhTFiCARFUESBOMDYC2o/dZQqxRt+ZEKVdtvFdD2ixaqWBol1hpNCaCgLQWEAkISUMhzdvfemd8fd2fmnDOP5+nO3L3n/Xrlld27M2fOPTNzzud8Pu/P+yOhr+JzRhIW3zhM6a5nIfWNYapmE+fybm6iPCPcHp9Q0T/+Z5olwVKGAkc7URIGWcQOU7NpQKZ3Qzi9OwkXnTilIaJnIDKDAODAoLfxYw5rAtZISxsjHhI9I4nZNDSBVbX1WY3JpmGzf5ImUp8zwiFWRiJw67OPSrZ2yPNECaxWlDGiQYG1yizQVowb3oO22jTkzxFNsmEa2sOXRmCl+Tze5O4r62pSYIW/sLhiGjEuresTV902W9Veki/gSYELyJ7HcUYyfK9vfGAl3rl8Kr555Uru68aB/F5ePRdZz4iIAqtLKVPHGybBZ9HtsMUc6z/L64zAIgwdpyadaRiF2965FP9w5cnUZ7p0iEgj539eOxR5TOYwjUntzQkxOiMUET0jZ0RHmGZu32j/Z9KyjSItRbs/iYJogpwRViQr6EM8Z4QE6Q0R3aVFEVh11KYJQhf1sfJd3XETckmeM/Lp88M6M6mekRCB1fFPzK4z4k3GtGekxukZiSSwRoZpAjKiH6bhHC+p1F7iZ1JPJmuYJvI7Idq9n0U4bmbPSHz+HUtwzIRRqcdmBRmmUeYZEVmgyWJ/VrpnJL64YRRnJNoYSWal0LBgUSEg3yBVzBlpa6O95Vo8I6DnwCBMo+VSWtHinJFgEifhkDHKBM7I4UrgYs2eTZN+zIPXrsZ/PPs6LjlpWuTf2dCEY1mxJLWAwBqhnJoBbGE1tt001CjPiNguLVr0TL1nhJVID64bF6bR74aNLDpHekbgglcjhCyg6H3XinbPCHm9YEHJTqwLc0ZEFVgD0TPSMErh6URN7kOfhc4VCG3Ioj4+QZjG95bxKqiynhGR70IZIzS5nueWRUkYxOmMUMjAGan5nrqadN2uOOjynAJDvBfv+bNtX4rVN0aUXalxMJ4RRIQ9iJ/Zd7kWwzOZvP81Zd1aNKULV50+G+WYiSBsGNixMcGQZ0QwdhjOpsnKGZH3jDRK9IwNXaSqPXJMNv/nwkU4duIojO7IYrQmfyfyOhZBYHUzEFi9M2vMRO97RjhrLEVeI2IcKM4IwdPIGssmvXyAQAosMTCkgJ8tkU0T9IX1jPC2peYZJhdvf9HmbZuZc8Q8I2R1ZdaDwR+msXjDNFk4Ix6J2XH8VHOZtOpIyOosZYSbYcOX1XDP04hpaWPEr9rLehqIbRCbTUMaI/s7Rvo/Tzz0ho4uRiPBeGIRrtrL6RmJCdNkhQrOiFfmnuqXhjBNSJUUKR4HDmPkspNn4OHNp2NSV0fsMR54wzTg9IzU2/Am+vq5ZaUE1ggQC4u/oHDJwTOeEUs8tTfQGXFgudnei+gwTR2hmkvcHYtL4edbGkj9FOEwJrsgCxXKI8+hTQMumlBEam+sR5TT+0KlmgvOjVmvEfe7DMiWosI0SccXFS1tjPhgH5IEzgiZ4fLAcaf5P48cOKylaz6IbkSxtOOe83DVXgtjhyrQerU1slxWVE2V5oykvxJelgGAjGEahZ6RmDBN3CSirTYN+XMGAmtQ5M4KpfSF2rboNjyPiGeAORmzwoK+ZtvpkjH6V9+ovys8xlOUzkjkcRna8nbFJbfmh2lEjG1vrNl3Q4T0qQKkMR149cQ2AB6ial6lggrTiL+fXLVpSI23lHYtywrIsQ5ZLFHtfQupoypsn/R0kM/b3L568cZmTO1tac5IHIGV9IywN5HU/hgsVfCDY0/Gumd+hq8tu6BhgxkSuok5rl7ptH4sWVPmkY+fiRd/dxjHT+1KvRabfRHXh/i+kgtI/Mv4wKbVeOPwAKYNVTUGEIRpohRYU9RRRcBqbyAl7m4xC7e6QnkZgt5DsF2yQquVaTEmaxaVmGwaXgJrSvcCENej5OA5OCOkAcIvBx+MjF9QzqkRehwixkj9/9C7wNuWipXCJbPBauKeQyJMU+NIvaa6UiLDNHaqzkgcolN7079X2vtTD9MMfU/H8bNpmlFnBKCf3cUzx9U/Y47hCYfmhRb3jKQ/2KxnhE23vebCm7D6qrvxb8dmS9GrKCC3RQndRH2D3jEdQQ0Gompv14hKJkMEIDkGYl4AmsAaf87xU7tw2twJ9IeJnhHBnV8CWMJcGlmOJfdpSe2NOYZSkCQ4I1G4h0kxJM/3s2m8cAWnZyQKkTojxC43LWU6CvVCcBKcEQLeok3vivnvnfdUhkXPxJ/JP1w8Sfhc0jMiTPBO4HtkbyJ+A8JDOg44XOlhGnKGSPeMBO+05RDeMcUerZBnRJPHjGpXUoE1T7S2MTL0kCfdJ/ZvVWaXXrNLeLm7L/MlR7aXceN589Ezqi3zOQD9MGWthvvJP5hP5dMD4q7CkCs648OtJLU3gjOihcDK6IzYMZ4zHwJhmiwbjyxfidw1WlSYJnwsWUTQMxTYiqiVoWwrbZ6RoUq2VkgXJTtqFGeE71miqvYSomcqXPShhVFi0SFDp+NG8s0RVVLMDclevThYJdoYEclYcqkwjZ3JuI5sJ8IYiTNknRi16iiQcvD1WklepqFqz0i2eVoEZEvU3OxtGpswnaa1wzSELDWJpBcwToiMB1efPhttJRufffDXQudnLcA0flQ71i2eAmwjjRG+a8URWN2MdmwWpncsEqr26hA9Y70FVprnTEHqnujTFBgjLlVXJmt7ZKEw8n8VcvBRo+BaAWlUxKvlIoIzIji5kzojUp4RL0yjkDNiWxb+bfPpGKw5GM1Z/JEUCRP2jJQYQ0JkiEmDJuQZyd5MogJrwvyTHuYM2rYcR0lGVRR6xoygftelM0Km43vGJ0t+FqH+NBqtbYwIxB87Kpp0GDgQpcAa9wJaDO8i6SWOPN/TGUkqlJcAagERTu2ND9OopIk7jCfGXzQzip6pKrRFhTlivh+5a6RSezMSWAM5bDZMIy96FvWhF9IiF0ouz4jLeEbsEgarEeUSYgW0AlDVmTMu2pF6L94unf2bRGqvZQFzJvILoblwaZl74Wwaic3DECzGG0rpjHC8sA6zOQDiOSNUmCYD5cpPNScUWFVzRkaPpDPnVOuMeKCM31jPZkbOiHiXpGHCNEgxRpjfTz5mnJJL8z6XlFsOrGGQsEso0VkTogqsopVJa4zLlgslYtFgoEP0LKwz4l03+ruqyKbJuJaH4O/siFRZHsuMzabxU3vLelJ7yVRiMsTG8ziynpGD/VWh/pGpvQcPD/h94YVfKI81PjiNEUeBtgtAP7/i2TRBX1zBiiZkPZtwQbvs7SQXymPmI55sGrJfrhts1FRzOkKhbZVhmqAtyjOiyfvSCDRvz1UgZhInd5chorxlYeHkMZo7loyobJq4x9yvliooBx8XplGdTROJxDANXz+ygNUZSbuGxRojGaZudueRLlIW3WaN8oykyNZHgAzzAES2lQLhpyRviQ03iPtzTD/kzh8Qz/QAgvtcdms4cGSA+kwEoQWA8zlXtUjRnpFodek0WIxnRKhrNh2moQqPcjQTFaaJC8+SYYnUbBqL4Iw4QUkA1Z6RhomekUR6L0zDTCyGwFpwuL5nhO88FTdWpgmeqr1eZ0sirnHqGvEVapNalJKDT1BgtaDBM8LqjCB5kWdrkKhL7U0/xo3YBSNj1V6Sf8EWytPHGQkMPYt477KnHIY9I1xRHmJcqkTo0jM8har2utEaJbykUV8DCHxhDBYk50mY4M1wRkRmKpYEK4qk1N5kBdaU/oEMAblEoTzFKzZrjKj0vBBddSjjr/6zaIauKZSXE/xJkXl8qcJOPOmHDYq4heXr43cwA0yX+GvT1BGWgw/aSfrWWdQBY5EYptGvMxLFVSFhlfVMNlmeOYrAShBtsz6DbG2agMCqwjOSlTPCN14ytWlonZF6OxWn6t9jkbROX4E1FMLka8uuDnJfO9QXN7inZUpnhJMjRoSMRBfn7lFB9pbDGo3SYZroZ4cK02ThjBBZhj6JWbUcPFvnR6XoGdluhtTe/ih+VcHQ2gRWD9wLtPwC2NnOqXSZsKgn7upCiwtvmKZ+fDibJitnhBFA4oEnIR6xwOpI7WUXaD/uHucZEcim4RUVimsyioORNUwzfVwnnmNCUpWh9EaXW4E122duRH+5RM9c+j7EGQ9ZjDFq7DwPm8C+LBA9Y8M0fIvawb4pGLHvjXqfJB7nKpGxlFpXKQ4J5NM0fO/Da7DvyCDa79xFtMHIwYsQWAnPSMkP0yR5RtKvUSPmFl0E1nCYRk+shDKiYrJpjgyI8asaiZb2jARhmsYH1M6aP1H43CidkbRsmrhz0+AdnUs2TQYCq8p7F1coL/YausI0GY4hXdg2QbRNs3UsC3jbksnEgswUytOkM+IS2Tsiqb2O64Y8I6IIyL9u5kU76c+yOiPbbr4d22ediIvffSvXeSz8MKNTC0KMgu8cEDYk0rBg8hismj0+rMBKQCy1l+CDxITGeK5hwSLEIAOdHt3GiC5yKfW8WdFhmoP9Ya2mmNbUdEoAre0ZUezq53l1xxOuTF6w/U1ckBUxusME1mycEfI4fmnqJAKregXWmkUbP3ZKNg0YfoUqw4hOhYwGKVpGlouPNkYYzQHbCnmBygpd1ZHvwdCOrUwU9uM1jNmqvaKckcjqtinPUdS4ervPkJeG85k8MHUWbnznZwEAV3CdSYMU7RNP7SXCr6LPMxnCZSpJ8xFYw56ROEOWx+NoWaSCMRmmaaJsmhjOCOut9XDcpNHKrq0LLe0Z8WcY5hkRfWR0ckaoGGGEZyQOXGTXqOsONR0K02TkjNQyuNZjkUBg1VEoLxSm8T6PlYOnX3zlO6sEkBN1sPCkX98zFGoW/V1VekaiXiByrMquV5qArzZNNZRNI3bvyWqwJQWiZyHNC4mSD+JzDy1kJ5r67jJhVVkF1rBnhCNME/H+x3lEeXRG6v3yOCOOPgKrZVFtasumoTgj4e/wlfcswymze7RcWyWMMSKAvNOkwmltCcYIa51zXitO9CyrN0nqZUyoTWPFLAQyCBNYA5n1pP55UFebJgOBFWECK2w7xiAOt8d+Vy+bJm5nxYNozkjwqUgGS73oY/D8VDk9IySi9Tj4wzTeSLN1m3hTe1U9woFnRKJQHrnLhphxxIZpeDRASESFabJl06TfSz9MSdQn0rGZIDcIvFlWSYjVGRl69shZ4JyF2cuVmGyavOB7RnK2LjgR0qpIeInCNWXUeEbIySBrmEa8Nk1jRM9YBVYr5fmwQoXy0vvCbQzGXJsmsCbXpom6KqngahGVf3lTe6O6F60zEowNWUE6KxZMHuOn5AJDYZrMZ9MjQHJG/OdIIDwVW7VXU0G0NESn9spwRsTk4KkSEBJy8NPG15VoLeKhjtUZ4cmmgRUQWInaTqx8gQqQBojKuYr8jmwtICBfo0IULW2MxKX2pp6nozNp1yRjhDwCZIIF7lhwXZMAXShPkDMSQWAVqfyaBrZKaBZeClmwrZFE6CDUQCiwWum1aXzjkjD0KoTOhRqdkfA4UJ4RIsSWNdRyzRmzKXltbs8IMTtTIS6p5yiGvyBhjIg+QmXbihE942vHlXlfPTC8E0qQLKJDcZfZevlJAOjNSJxnxKGK6SWD9IyQYRrVVXsBxjOiaX6g9I5UhFlzQksbI1nk4IsILmn2ENdD8JZbFqUwSr1kCaeRLmzRbJokzohKnRFWZMmvfJrIyQn+JuLmTc1+ifk8rlBe9M1ICtPUfE8FADjasmmCsbEFeBodlRLesXKm/3tsam8W0Tdi7PzFTeA5ivWMcHsf5Z/h85dMpgxMUc8I6e2re59EOCPEO896nKKejZh7ZlfqhnEUgTVpHrPTQm6IDtPo4HQk8WdkQH7DWjkoqBhcr/lcIy1tjAQMbEUM1gYha9VeAHCYOCW3F4g4nK4zk5UzoitMo96QZEWW0iS1LdDj2UgFVprAmsJtiZiYfHIgXJ9QWm9DgWckasEhxsYnsEqEEI6WxbPR/LGD61ezFrl3QW0aljMi80yKndtRKeGUeb0AWJVbvvZIvocoL8dl5gmeEAqFiEKZccR1HgKrRRBLbadGPAPqJ35dnhHSgO3vHBn8gVOB9e/ftwLz+4JMmzxNmJY2RkhZar4T87VW2P4mTaSsy5hfZyR6sc3OGSGJVuoIrMIx8QSwxeOC2jTZrpFpsmG+SiTnIsO1KK0M/8Q4Amu4bc8TUHIcyjOiRGck6hsQH/lFGzmyaQDAaQ8MkKPltshj4r59FGcEkC+TwLYH8IdpVM0mLklgjQkhpULFTj6hOGYknShuAAheh39slkJ5GTwjvhfTdQMCq44wjUyh0IwY6Bjh/8xbdPG0uRPw0PWnYdzI6PepkWhpYyRP0TNexBkFQIo1G3KTqvGMZHVrS3FGkmrTROyQrjljNgDgohOm8F2H6Z834VkpC5VlWZRhKLO7jv173OeRnpFstWmA4L7YrhNU7IWFQe6lMSMHgHgOyXRanqvViEm3P8YYyQLyPpUyuuijs2liFvwGpniTcAmRQFHJfTCeESEQ73yVMW4jSwXEPbMRnlEVxPUQZ0RjmMbRFKYhUW0LuFTuUGiLP2syf7S26JmP4hNYSYQVWBM8IxyaJFEgj2Y1CLKAEqpSqMAa5bX46DnzcM7CPuGqyqRoFEB4ZBLHTI4zktJkLKI4I5maHjrPIQTePE9F1S7h6KCmGhbEpOxlK3GLnpHGSKkSeUyWFsl3oizhog/CNMzmgNO7RF5aZl9EGyOBEB5fZ+jFUyxME88Z4WouwjMaH57lW37JzDnL0SQHD41hGuLnahtRC6gc/V5kRZ5ZOK1tjCj2jDTqRoZ4HwndD+uMiH9X6mXNmk1DvYwaCKyky922sHRaN981CJDERvoa2Yw9kQVN9NEjjRHKM5LxfNIzUvEmY7ukRLgv0k1OLIqBzgjf80B6RuLe2VhPEqnACtIYqdfskKouyziY2RIMjYI7lAlVcmviHgTGM1IRIrASBjprjERF8LKGaVyXyH6KT+1Ng2VZhAKrq5fAmpDmrAqD7YRnZMgY4a2BVQS0dJgmkIOnoaIQnmpQLyzr7Ui4jSFjRILp7wiEXBxbIpsmSYHVy3RReK+C1N4hzsjQ53HflSWwisSERecMsrYMb6G8+vmeMUN6RrKHeZIQNVpx3gguzkhHMOn+rrNLtHvUolOpiRNYrz97LnpGtePs4ycFbcPiD4VyXzkanvKrDIEVJfIdF1seyPegbuAG4Jpb7eD71M8l07PjOSNZQFXt9Z4BLZwRcn5QuK4QTZGeEVHRwiIwFYxnBJDiUWT5XAdqlh2Q7xJcseHMG77rkIfHEViT4Mh4DhIJrBrk4AU8I1HnJyHLnElO2OQOx7KCR5b04gTibHbqjigwsIJ4fJnwjKhA5DAQYyicll2u4B+Wnoeuowfx6NQFOFuwf05kyIh/IZrSPQL/+cdn4c3tPw3alnweZc72PSNOTZzgzRQj7BDpELEgsoRoruFh3n8yXCvrxfDClJYTvD9awjQyVcszgjRGvM2j6J5CZ0mTNBhjpEnhUj8nGCOMtT/IaY3QBFZSKtoijolvsybjpiQJbK5LdUa4RHoCHKZQXpoCK0Abd1rY+MTPFdvGQI12Kduu4+8YXduGk5XAShD4SM4ILzJnA1GeEUFD0gI+tW4j3zlDII00J8ZLIwLLsoCy3IKjQmcECN51sgAgt+gZqcBqi3FGwHhGhOdZIv0chCYMEEXi5+SMeGR1x9HMGZHznMaBvC1kmMa/VhMubSZMA3732XtPmZnUXEOQWb9DsjYNdc0YnZGk3bgUm5yYGNlQjZ7U3iFvw9Dkl5YeaVlMmEaRwz3ucZw4hiCqRXFGMlzfazsoQub6xoFw9kQCZo7vBDAkysWkTtfHNfuYSXkNiJ/pbJqsnpGEqzPvhUw/ZQwTZ8gzUpbwjJB8F9HFmZczEguiLxZcP3wKRJD4OSc2b+PQWUKgM6I5tTfO4F0+cyx3u+RzQmbTiD8++cdpjDECgL0RaTf0bUsm6+kPB2iLO77DYRl3cc5ILasBRIA8R5QzAoRDNXHVO2VQo66XrQw79bcsYRpOi5U8/O4Ny7FkWjcuXjY12NmB2DGWrMzGZhCmqVGeERUGNamA+S8fXoN/+fBqvGX+RN+LRGp7VEocxoii8aU9I0Ff3rl8aua+UP0qyXpGhC4bBkX4ViR6JrJIlehsmjTOyNyJMeXtyXCa41BhmlCtLM4Hd/SIemp4d0cJVq0xBFbWS73942fgS+9aiguWiEkReHizb1r4uoJtmWyavCDoGYmbFBvJGSFfnOTFktVAkNh52fEvVhxqGfsZCWJSK7kOqsSfstSN4QXZFp2lEkdglb/hy2Zk3xXN7xuD7248Ff/8i1f8vpadGiMHH55NukaENTnIyrWVoYwSHZyRke1lLJzcFfQPDiEHb2P6uM7s7SrpHe1B8gyx5cf04H1/dLxQexbFC+Dvparv5Un5k54R7tAA48kUS+0lQ7PxnpF/3nQq/mnXy/jI2XOjG6I8oy6lN8J6MRxO18j0CXUDyHb0pvYmkf5njB+JGeNHsqdkAtnU84tX4gtrLsMzPdOxWqi1YkBo9O+44w7MnDkTHR0dWLlyJXbu3JnpvHvvvReWZeHCCy8Uuax6+JwAtc3pQEelhLPmT0Rb2cZTn1lHPY2JEyCz85ThWMTVo0nasboynhFiMrKYME1Q5FAdKPe96/haJonGnuQ1l0zrxreuWoWf3vgWrvMG7TBZMU5sa8Lodtzx7hPxtfeeROiMBJkKUpwRjmO9Z8+Tg180tYsrLCGlwcHohXvpvR5nZMaEUSiXBBejUvyCwwupUJQdFJYUJXhblGdEQTZNKd7btnhqNz5zwSJ0d8YI2JFhGteh9HTYTUiNN5um5BFYg3Z1h2l0KbBatoW/PuVd+MHcU4JrcS5GTZlNc99992Hz5s3YunUrVq5cidtvvx3r1q3D008/jYkTJ8ae98ILL+BjH/sY1qxZI9VhpRCs2psX/va9J/k/HyLDNAn9Z8tiq9IZyfpi1WQ4I4yblvqTqNx1AiiJe6K0eKLOiIJnZ8WscdTvZItxxDzPi1GpVQPDLEFn5K2LJ1G/DxD8Ai9UUbPU6IzELamubwANxf55ZdMVvqaOZdV32540fUrj15wxG/+062W8e+X0cL9Kkt4EVV9sSAq87Ip7RlivhkjPXKbYHgmu9pgwLekZkQ3TeFlDluP4nBEdnhFaRK4B60wRrApBcI/+bbfdhiuvvBJXXHEFFixYgK1bt6KzsxNf/epXY8+p1Wq49NJL8ZnPfAbHHHOMVIe1oAlvYGZlP8naNNS5AoXypLJpmDANCR2pvWRfKRXLpLAcb0w+wzFZvAVVQi2WzJzIOicPDhkjbbVq4BlRVH48rvue4SYqepYlLMbLmfGLBKY8m9PGdeLXn12HT79tYfiPkpwREjKPs09KdpzIcgmZQBgSVcEwDUWCtctMejpHg1QKdsAZidJy4Q3TBGNVC2rTNGk2TdzPIsiTM8I1OgMDA9i1axfWrl0bNGDbWLt2LXbs2BF73mc/+1lMnDgR73//+zNdp7+/H/v376f+aUHMYtMMpknWmijsd5MhfMYRWJNaFNEm8UG5aVkCq2BMPAFkWzaCbJpcaxfFTA6eMVJ2ar6XiMfTMDgkp95WG/RDFeoIrNGfe/dftDidVJiG/d0LGdWyVxCODeMUhDOCiGwa7qJ95HexS0K9I68Z0hnhaYjJpvOyaaJS6GucxogX0rJqDmyOZ4AXDvEddFXtjQLve1yENY9r9F9//XXUajX09vZSn/f29mL37t2R5/zkJz/B3/7t3+Kuu+7KfJ0tW7agq6vL/zdtWpgtrAQx2TTNANozknBcSIG1sZ6RqowCa4JnRHjnFwGvCSqbhvKMNDbprEzwfEoxK7vn/i6TYRorvWqvB88zUqkN+sJfNUuRZyQ2TON5RoYm/5xk0wHCMzJE3pXqi6TOiCr4CqxEJhjv++FWAv6GMGeEqU3D0HWyg9mMJH0n3tReb6xspwa4Gqv2ktw+Tc87Z0JfYaH1zTlw4ADe85734K677kJPT0/m82666Sbs27fP//fSSy/p6WATVe1l4WR1/4XEgSSMESvayk8aPm/Rq5/P+bhZFiVbTkJ0sk0C2ZZNckYSxsznPyjEmI4KPnjaMXj/6lkYP6o98phBzxghiH08RdEGbM8YqfreATHRs+zXJDOAhk7Wdi0WLKHPW3j81F6JhcJijHRuLTdFi4mXuUJVcuZ959qCQms14Wya4KSwzohEmMbfgISfU95+uhRnRGeYRg+BNe3rinK/mkaBtaenB6VSCXv27KE+37NnD/r6+kLHP/fcc3jhhRdw/vnn+585Qze+XC7j6aefxuzZs0Pntbe3o709ehJWCt8Y0X8p1aBikRwKrKo4I1kNCyljBPX4sA3XnzA8WArJxxbqbnwq5dMNyqklLfLezlo1PvkHxyX+nfSMBIZa9toyA0MFtSq1KiEHr2ayjOWMsJ4RXmOEbU9i3nRA9wUSac20zkh+k4lbDsI0WdSDI9sgPCM1QQIrLDbUIwhmc+AbDRHPKW9xYpfkjGitTSMhbZAA2oAlNoZDd4w7TFOANZBr9Nva2rBs2TJs27bN/8xxHGzbtg2rVq0KHT9//nw8+eSTeOKJJ/x/b3vb23DmmWfiiSee0Bd+yYpm1MwdAmWMJNWmUVm1V+DFGiBKvYtM1EF1Wf2ckbonpt6eReqMJFzDK7SWFaoeucGIOiQ8cvA+gdWp+mGaKuNSF0WaMVL2x5VvocrSt6zj6/fFDxmJvxfSomeKwsRkam+aenAs2sj3VfDdogiscsYIWV3X94xEjFdcODMOZGqv7cS3KwtXYAPXquBO7d28eTM2bNiA5cuXY8WKFbj99ttx6NAhXHHFFQCAyy+/HFOmTMGWLVvQ0dGBRYsWUed3d3cDQOjzXNDEnJGscvAqPSNxqq9JTfYTxojIxOSng5JhGqqUuNp759gW7BqdTRP3eFhWkGLcaHj8jooTlIvn2R7OmVpPJyY9I1VbjQZiKWaHGVIDljAAAMmQhif6BnmjVrRSahRkDBM3UvRM3DNiu45QaCyJwMoLx7JQcunQU5QHg7ufVDaNWs8gicxZj9yIbkv2Ek2lwLp+/Xq89tpruPnmm7F7924sXboUDz30kE9qffHFF2HnSEzjgXCZ7UKADNPEI1y1V002TdZ2yDCNyLVJpVAPSaXERWBZlv8W1uPRNdhwtKi8qsJgySvqVyPCSelVez187YOrgT+uG3nt1UEA4oRFD8tmjMWrbx7BDefOi/x7OLOrcePKDkvouVHEGQH4DQpV049bUsAZqQSbBzJUyQVGZ8SSWODq/a/VSbkJ3I4S5yA6PmeECGnZJfx/l54o3tkIkB43XYTtqG/ejE5/oa3Qpk2bsGnTpsi/PfLII4nnfv3rXxe5pBa4gnHVIiArgVVtNg2/O5oM04gQxKKMkaTqnbLwJg/bdWmZ9QioqrYqAl/0zKlmEmdjUeoIOFkjBvsBiMX3yRH44GnH4JwFvbHjEnr2eHftCmfY0HMj8RxZZbndvxX7Cx+iPCPc2TRtgWfEcl3pqr2OXYLM6NRsG6jRomdRnhHeMI33rtiE6Nm6JVOw9vhJSadxg3wnB52EAxXB35hwemxVhQplULwtXwPRzJ4RlwrTJHBGQr+rCdOQs1TSgzwoyRkJSI+kMeKE/i6DiaPJarhhSe2iGasWCNEzIpzEZRwRi86IwaMAhjJ0JNZ7K6UPoXslGabhwarZ4xP7IsUZ0VDtWASkZ0TEQAVow4pVPebtBzAkBy/UylBbQ/eJ4oxEfCfuV3TIe2PVHF/0zNVwH8k2Xz+qLvOO+r7Fmp6E0dLGiOv/T9/Ngq09kXBiDAMWbDxbxpNQizGAklN7S8TPlfgD467puVOJXTHpGVFhjHz1vSfhpJljce8HTyY8I0Q2TcI1DlU6Yv8WBRWpcy4Y0TPCqM7sPCDc8Z1Dxogqzkgc2GdPR5gm7usvmtKFB69djV2fWjvUF4VhGmIBZ8X5Mp2vOEwj4xkhUX8HxDcQgHzxRYfwjHpjqzJMYzs13zMi8wzEgTRyVfLb4lryLtGMYZqWNkaUF8pT00y2a5FiOokKrOwCIH5N0o2ffSEJLkjyRzJf01ftJHYVZJhGwc07btIYfPvqU3DyMeN9zwgpsx4X67UAXHHxp/HcuKm4dP3/ke4HD/zUXqea2s9IWJZ/P3xjRJJsmKoKyfxddnLmnXAXTenydVtChpHMQsRmmUl8LakR8YonumoE+0TDNC6TTSMTXiM9o14adtR8N3/SGL52Pc+I4/iKaTo4Hbp0RkhEGYy8I16EDbjerVDR0WSF8khk9Qiw7mcZz4hjMZNulusTPw8IeEb86rIN5oyQio9J33XntEU468qt2dtXldprB5oS3ii7Nl+hu2qpgkqt6nNGBiU9I2lPROg9y1WBVSGZVlJnRFW83imToTvPQOUl0wbHs0KDWUF6Y6V0RoDo1N6IMb581Qwc7q9izdwJ2fo41K8jR/sx2kvvVpgV5YHm2Sn0jMRl+DXhWubBGCOAMrOwkY9B5tRelVVtSWa4wJgNCHhGAgIrGaYJJkn1qb2k8VNcTlGgIErqjFhcu9DBcgUjBo74xkjNzi4n74FnaMJhmvzGNfTOxNWdyQCawJrjs0JmWCngwwmfSYytbGqvS4RpvPc+KgW3UrJx7VnHZm93qF/7D/aj7VDdMyjzDMSCDNMofDZIo0Mlf6RpCuUNN6gmsDb0PhJ9Hkzqf0hnRMYzIhKmCSByjh8zJgmsxEirdn3Sk19aNg1/+yoeNQuBF4MUPbOopOd0VIdUWDt9AqukZyTlu4V26bzl7RW+YCr5KzSBVaCTFP1LgmBeCsI0Koo8isrBk4v6QLkt4cB0kMUVAx6MvAfDF4ij9Es0EFgzbhrVX5jv8CJst1raGInbRTaDq4v0CFQTiCBnLqRT1WTm8xqlJtiYMfJLfZM6IxSBVdP1NGXTqFpQ/dTeWi2ogsuhMwIAVZ8zcqT+u+RknGqMNEJnJOP3V0pgJZqy3fyCvh7ngcyw4l0Ayb47ti0oehY8R/LGSOAZLSmsIePaYY+LTHp37HU0iZ5R+QsI/5xnjRlRtLQxIsJ8Lwqypvb2jR1J/S5jnccpsOoEW3YeoIvTqS5u5RKTnyfWpNLwWnNstph2GgYJAquHetXe7PA9IwP1ME21VNbqpg1zRvjGVeUEGzKEFPFXRHgWqrzsLlUiwEvtlfOMCIEYy8G2NrkaQrbHGSE8GAreR4dIjfeNeR2ckZwqOp8wfazQeU1TKG+4wVUcpmkkyEcmcYepUvQsxspP2j09PmW+8PWAaNGzEsUZUfuCk5yR9Gwa/rH81FuPwz07XxTvIOr3PvCMEIX6Snz98TwjI/zUXlnxruTrh0IjOmL0GREisMp4Roif2RpKjYQ3niWqkrNEWNa2hYyjWlug2yOjvgoE96nuGVFX0M4bK7IAnw7OiC4Caxy8ufgja+eia0QF5yzo5TovT7S0MSJa2bIIcLOGTBQaI7WY1N6kFl/u6sVbPrAVb44YLXRN0lPhgZKFVk1gjdA1UBlRHdleBqE+LwzPcGhjPCM8GxvPMzKi2k+1yQPKANEcplEZPlUbpiEMcyGdEUXfqxxwRkqCnhHy8JfH9Aq9XrVRwbve0X9YardN1qby5gA1YZoghT8Ic2rwjFBVy/XojEQ1O6KthI1nzlF2vUagpcM0zewZIR/sRO+Awqq9dJgm+6Pzm/FT8fvOLqFrehMPqQbpTR6qQzQAcKhafybsDCTAvB4bC6RnZJD4A994VBmdEVkCaxrCFaQ5z1foQlapM0JKkYsUl0tbWLKCXEzLQx4zEc/h+95+M/5x0VnYuvLtYh0hvsTBTj79Dxbk5iAI0yj0jDgSdXwyXUeO9B+Hty2dAgCY30dv8mSnpKYqlDecELfzbQbbJCtnBCEFVokwDSnuREzAOserFkFgTapRIQvSE1NKCdPkhYWTx+Dfh/pZrhFicIKckQmH3qz/Lindza8zoiF7IetxknVy4pBnmMYh3vW2IWNEZKP1wzkr8MM5KwCIe6OuuvCTWLjnOTw+dxlmynBGMsrBc7frklk6GjkjhGdENgxKYvPZc7F0WhdOPmY87v7355W1myda2hjx0IyeEZoz0qAwDckZaVDOQI2QPfeQJAstC58wS2YkFKT2iIdjJoyiCuV5ENEZIVGVTJlM8wiEhcaKpDOi5h6XRAisVKRLYkyIhc97X2RDYaK36AfzTsEP5p2C+ZL3mPKMOPE6I7z42Yv78AfwlF09zogOY4So06NwU9NWtnHuonBRvyZcynwUa8vXaAyTbJpa0iLC6oxITHa0HHxjnnovdEASNT0imw5jJFB8JIuNRX9X3kqhKkGKnvngnOxqjAhdVUCULi7FMArh4nR56ow0IM24wSB39l6WVR4Gn8pL+nLwpOiZgnt1cDAIxwqVU8gIyhhRoI8SBaXjra4pbjT/GyiF5iWwOlkLMCncjZLXIV9cnbosg37xL8IYUZC2GAdy8is5yZNUJVc5c88YIT0jfGEa1nxQ6UaOQrhOUnGyaVRlUohM5qoL5QF1/RlAfozznhmD1F5X6XtfI7LmdHpGXCpMo/95f3bvQe3X0IXWNkYctQTWRjpayDBJWv8proei1F7ZapxZ4RVzayM8I4G7Vn0fqr7+QC01TFPiTKVVCW93WCE5I+Co2gugRBgyQN0LJVPULO3RckIKrMKXikXW7ofCNAoXCpmvJUVgpTgjdWIzL68qdH3Je2RZfKrALEjRsyQ5eF4ExPiar+is3TPSgDlzoCpWT6gI+/HWNkZiCuUV4L6kgkdmmDJGFIVpdJBHo1D1C8KFPSM6wjSe8VNxarCQrMBaLkCYpkSFaSyujBNSYr/epl6dEfbN4t21a5WDV/Q8ixj7qjyLlmURRqqYMRJqU6BvOlKwbSq1V35RJ5Wd7RQPqNR1CGNEl+fRIV6MPEPHsmhtY0RxmKaR1iU56aVlyGTOvEkBeS65cOn83l5xPTJrRGc2zeBQZeFKrZoaphE1RlQMV0BgDcbFtWxOz0iN+n1Qg5uaRFj0TP31sj6LofdAUTw/7wrgXijA94xo4inwQMaI9HVGCKKpimwaz6AhFVghwJlKA5lNo8szUiP2FLKaNTKeUVm0tjGieNwbeR/JhTjt5ZStj/DO5VMxc3wnZkwMNANqmjUpPHieEVLcy1ZYo4LFgE+YHSTCNNHXyZXAyuyAAXDzHko12hip6i6UJ8lfyvJ6ZX0HWa+MlWPIjYcEnAbP+PDCmtxhGvb3nDfangfQggvbHVJgVSIHH3hGPKNci2eEMEBks9Vir0EKQgoOTd73GWjx1F7VVXsbiThp9ii4FNmV/4X7/DuWwHVd7HzXN/3PahSBVR8812aZ5Iwo1BtgQXJU0sSQ8pRQDgispM4IH2fEdlhjRDZMkwx2YSwUgVVRX37fOSY/MTzL8t9LUc6IakiLcFmk0aCOMxJV9gFlvQRWlam9JByHNEaaby3z0OKeES9Mw3zeBDeUdPmleQhUTPqWZdHpxA0isHphGiq1VyGRjUXAGalqTfmThffdPZ0RkZTtEsMZ0Z1NExYX1JANldHdqbI2DQD89ebb8auJx2DjBTdKtSO7egceMzHPSKg9h9/dy95WGeVc+NyB8AAAM7lJREFUUvenlLI54AGp7Gz7m9Lm5IzUFHhGrjptNj5x7jxM6hqhqFf8aGnPSByBVRSNtGFEwzRSVXtJAqtmfoEHL3Qw+cBr+OiP/y/uWbpOqd4AC5Iz4k9SRTRGGJl8x7L4ZchdxcZIWjZNyADgDNMojIM6zD7MkrzHvzphNb5QEasFosoosxBsEoQ5I0xXqgLGiEp485VFFMobUBAi9u4/mTKsMqPKv04DOCPkayH6LF128gxFvRFH8WbZBsJVTGBtLGckezVIcjF1ZVIHiXZIQ0CnEeZ5Kq7Y9QCu3XEf7v6nPw2IpTo4IyWSM1JkzwgdvvImbZ4F+77zP0D9PihJ4EvLomiEzkjWTI5QaLOA91gEvsdMlWekJj+pycyLpAKr951kn1OALjPhZ9OU1e/N3VJ2D7YoSO9VEzj1YzE83kBB+OWtmTvYXi7+sPBxRgjPiMQtJ1+sRkmksxPPgr3P6/WM2GHOSBEyElj43ABGaZNn3t+1eDWeGT/N/71ql/i9KxyHh3RGJAnAUd81e5hGbWqvjKS7Rf0sNybeO6GKMzJtnJzbXnZx9J5r23X9Z12WaF1vkBA31Fq1V7/OiJNjBoxKFH/V1Qi/ai/z+eWrZmDJ1C584tx5je9URtS4wjSkQJr4NfPgjESFDlQS2VjUIkTPZBdNHfAJrBLVWS1YeKp3tv97zS5pFT2T1hnh604iQiEjybCjThXizH2wgvfFz6bhNKTJ73H5qhlCbn+VI+E91yXX8Z91FZ6RKurjQodp1N9DXYXyqGsQ72wz2yUtzRmJy6YZ3VHBdzetzqNLmUFzRnjCNDKeEeKalCGgUw4+/IjqzKbxs3cIXQPV4QTLsqRnDW8HXPZJffXPeZsdKAXF8gbtMioJx6Yh7SkIh2nknhuZs1lDVpq3IXE65VWR7IbDekYUydznBW+emf27l3HdT+8BoEYPx3v2yGw0HZ4RtxGeEYL61cS2SGt7RoJsmvx3NbyoUZwRDp0RiVmTfFlrDSKwDka4ZElZ6BvOna/0ekHNilpgrBZwQmcnNseyYVn8mQuksVfVLXoWCtPkN64UqRuW9BxQhBmE9IwEnBHxe6rqO8l42zyjwTNEgOg5gRdBoUmiJILmqr26atOQ2TTN7Bop3izbSCjOpmkkeLJpeLwoSciTwOphwC4HCqyWjaXTupVeL/CM1JqCM+LBS+3lmossenxlJ/k074I0gTXDd8tem4ZWMJb1jJDn8zalVj6dVWDlFD1T0BUdnh4SgyUZ/10drj9ORKFJLcaI/mwaKkyj5QqNQWsbIxLZNA9dvwZbLjqe+kyW7MUDcoFMNTBUFcoj2jnS3incDg9Yslq1VAo4IxrCNGSWis7qwLJgv7sIgRUADlc6gjYFJkueRTjUtzyrHoM0Rmxpc0DVEyLTjgUrwjMiPsaqUo7lsmnCfRhUsKg7DQrTkDwUbZwRZ3hwRlrbGJHIoZ/fNwaXrJhOfbb57LmyPcoMLs6Ioto0IF6mN0aOFW+HA6xnpGqVlFbvDF1vyPgpuQ53mOaLFy9R3p84sMXC6guqhYWTx8ScEY1DbYEBLTvJp3JGWAXWHInBbDaaNGVEEWdEFg6TZdWorDddiDKmVBBYSQVWD7JaM2nQVpuGjNI0sW+kpQmsKjkjl508HaM75N2HWeFwkFKpbBqJvZddDVyaBztHAv31n3UuKXsZo6daKlPEUtVOiyCWXONWfHz7sqlqO5OAsLR6fSD+4h1L8Fc/fAbvXjk96rQQDhLGiJKUyQTI16Zxmd/V9EUFEboovjN29807xkX5Hh6i3r3DbfIe6Kh7rpsbpktnxGTTDANYaN7aNGShOp5sGpnV2yKm/2qpgkZEKF/q7qN+r9qlQA7espW79qpUam+66JmCxBghsBObM7S7nzC6HZ+9YFGmNiwAR8vt/u9HK21SfUp7tFjuDS9nZMb4kbxdSugL7S2U94wQ4Srec2Pa4e9DeJGVCdP87tCAaE+In+QGNmpuO9AmHyKOnDO1eC4aIIfQxAYIidYO08TVppFoqlEQJbBWFVnnr/c35gu/PrKb+n3QLvsy5lo5I4TOSJ4F3eIQ5xmRaedIpUOSJ5B8biibhvNaJx8zPvUYYQKr5CQgNWoK90KsZ0SmuvYDv3hFtjvSiHr3DmnyjPBWvc6CWltg4Ouv/dTcdknxZtlc0HzDwO7skkCLlan5rgerpAQx/2z6gdWzMh23Z9Q46veabQfZNBpivF6Z76yeERGoWHvYcuSioQby2ekXyFLg+S4kf0HUkDz5mHHpB2XpCyUEqOD+KjIoZA0Tdlx5d+N6iheKI+odV2KMsEabZWtJC6wS3kZdYRoSzRymab5VWCX8nW/O/RBAjYczQnlRJKzzmJw9keG78bxs+iCDpQq1SI47sh/LX/4vAPWXW/WtqxGiZ5nCNIqvnxVRqb3c4QGLmSCl01uT/85jQMdB1WTLkrrlNc/0eZR4wBofeWjkKCXkRsxtB9tVeEbY3+W9Y5HXIUOfDaADNDOB1RgjQFOKnrkcu0zShS8jvKNymHh2YG+OGO3/PGrgCN79i4cA6Mmm8canRIVpipeREKqtInhzfkXIwcsiNZtGAZFa1VRLvjMqdqzU8Oc4nch6RlRDllMV9Vyr8IywGzgdas4AMNihX+6BMkCa1xZpbQIrYuTghZqSboEPNcEwjcxLl5c4nM2UuvegYwLxPSNuLajmWcDaNCHPiOAz/GzPdFzyrs9h9+h0PoYsSNd43qRxmjOSbzYNXWRPph0rrMzLabDn/aSfu7APD/1qNxZP7QIQbSgqUWC1WG6NreXLv7LgBPzHjMX43+5J6huPQBPbIsYYAZpUgZWsoJtmjKiqj5DTAmLFbK10Vu2lOCMJyowq6syIIOwZ4U9z9tzSO2YsFu4HHblrgFGcMtRZ7wRVIkGJAqvU6crAGql5e0YAvtDB5y9ejDVze3DuwnoWHRsifWV0D34zbop8n5j7pSPkCwAolXDpuz6no+VIyEjv5w1jjADFmUk4UKMm0+xhGh2hDZHh4znFjnnB6vVY1N676Gya4j0fLDNfSsxOEdJ6QFeaFg3TqJlsw9k0cpBpQdWdsxDBGeEmsKrpBwnPy5EFYzoquHTlDP939t278D1fVCLkFvYsNi9jYZiUpmltY8RX2My5HyJwOSZ2uqaMROGsmMtkncBKtoWagOptbJhGI2ekXKvB9p6MIhJYo3RGCu7hU1EjSdVk6zBeGpUKrFKGSc7ZNKphAThz3kR8+ZITcFzf6NTjWbBGgqrvE8UZ0ZFJ1OiNbjOuZR5a2hgJPCPNZxWTuwOeqr0yBNYj3fp5BVGI84zo1BlpI6p5aqlZIYmQzkgBDJHU2jQc3jzdYD0jspCTg1dz7ywroppzjvV/PFiWhbctmSx0btgYUfN9wkabnnEqNSKDxnhGhgEU3rhGPwRcLm+bnHjFX7pnz3wrXvvew9g5daHQ+aLxTCvGM9JfllMMjYIX/mirDvqfqV44VcxP4UJ5/H1UPU+meQSoEgaC11D1mlGZPUN1feSgMtgijpDHjDdMUwCjlgQ7t6kKp0R6RpS0TKPRmdXNnNrb4saIOgXWRoPHM0KJTUns8t1SCX+8blPoc5EJjGchfHb8dJzw6tOhz49U2jXUphkyRmqBMeIkzCh5UTVCst8KtDJEQN77dM+IFfkzD9IM2qwGL+lJUiMHL3Gu3KUpsJ7PPDwjpKfnFy/vk2qLNRpUqZiGiL4a6lwBgN3gTLxm9ozk78MrAIpIUEwDX5hGL4E1K2zBcb72gk/ggflrQp+TdVVUgS3BDuQfUoiEZcFhFtSiQ4UCqyooD9OQP/NmNSm6dRaskKiho6DCbZ5g742y54Ztt4nDNMMFBZxlG4cXf3cQALDvSDXlyOLhwGAQukgP06gVeAoh4/sm+l6+3NWLay+4IfT5kYp6Y8QbH9IzggLqjABsqC7/ME0aSL0WxxYLjaja+IUIrJLtKTMoZAmsIc8IpyehYI96SLZdFYHVZbWabOHNUhJKDZg7yNBMM6f2trQx8uqbRwAAvzs8mHJk8bB/kHgAuWrT5EfGpCqbKnjxj2jwjAwO7SRJz0jShJ5njL1o3hA+OXg71/g2OXZVu5SrHLxKQ6YIOiMqn0p2blPlwWBLIajIqIq+jsmmyYqWNka8x6QZwzTsi5QEV5FnRHaYVG8SjlTatdWmaXNIz0gxXxPSJd8MOgkqwjTKNn5U6FJ+wZZ5Nw4P1IJ2JPvBpu4XIZtGBuHq1Kq+jxUKX+swHEoNXlpGdzRvWK65n1RJxCl7iqGxNimPZoOreOJlkfV9Ux0/PaohTONVw23XmU2jwIT60Bmzw8JdORjVPPoaoeJ0uYZpgmvXVXflxs6K+TkLXvz94aBfkl9QNkxTtH0ZaWQPKp273FCYU0dEpRFhGhJXna6u1lSj0drGCIqrsJmGKseumCqqJ1MoT3LCVh2T1RGm6S/XKwR3DPYHHxZwd7l6Tg+XdywKqsPLqWEajkrTsVDUaXK8lIRpJBpwCAvEkfh+FqJSe4v37PJAVV2tKJDt1ZSkd4fRiGwa8pEZ01GJP7DgaO4nVRLW0E0sgmAULxwO8qKqMI00NIRpVMPL0PFEz1LHK6dHx4J8qqzMwicC15J/Dskey3SfzESq2qVcZ4CaQ/4sd0/Y1NdaDtk0KvccDhNKUQmKw2Rr8ow04UY3L7S2MeJ7RuTbarjoGalmmXIsvQjokIPPNoDKPSMadEY8z4iHNA2K3KYaiw65uQL7OtmQQKhLHJ6RvMm3lCpxQiHErJD5OjWHyIyTuCmWFfaE8HoTirZ0UvdJYu6KAmXoaJKDb7TOSDPDGCNoTs8IuUsYTNn9kCmVeeqMqI6fvtTVq7Q9IKzqqkuZUQVktTJ++fKbCnuThTNC9lcPgTXrpoDcgNSsknzVXkr8ja+tGtHpmuSuhl2wHQWGVp6geB2K565GZNM0RA5e+xUag5Y2RppZro6NeSdBVWpv3GuV9XVT/Vq+3CBjpIioC1zJTaZHB6Nl9vn6kR08Qn1xUFe1lzbm89QZURemscLZJ03PGaHDaSrBvj/NqjMyXNC8eUAK4Kf2FnbvG48qh8S7WyKNkfwmJ9nd51nvvxPn//ePMWXfa/jm0nO1UP/7S3SYpqop5U8FVKuIyqIRYZq0/UOWZke2lUI6I7LLnMzoj6gQRpqsZyTEGeHNppF/jlQ+ijoJrGxqrw67odEE1maG0N294447MHPmTHR0dGDlypXYuXNn7LF33XUX1qxZg7Fjx2Ls2LFYu3Zt4vF5QAVnpNGgU95SwjQKiINA/jojz/VMw+2rL8XH33o9Hp8y3+uVXKMMQlVPU8YrLxugLtpEcEaKYIyk/J0lDIpARZjmW1ev0pBNI37uFatn+j/XJJ1V4aq9wydMo5J8zyqw6qpNYwis2cF9d++77z5s3rwZt9xyCx577DEsWbIE69atw969eyOPf+SRR3DJJZfgRz/6EXbs2IFp06bhnHPOwW9/+1vpzsvC0xlpRs8I9ZKmTTjU7kKDzkjG4WsGlyXrOdKSaaGgQQtsqmz+9VbTnoOaAs4Iz/XisHByF/V71S4rTe3lbYtMx5QJ01hWBGekoGHGrCDnts7Bo0rbZo1jLQTWvF/KJgL3k3rbbbfhyiuvxBVXXIEFCxZg69at6OzsxFe/+tXI47/xjW/gmmuuwdKlSzF//nzcfffdcBwH27Ztk+68LDwCqwqTOM9smjQxIJLAylb15EHRdEZ0wLVsmthW4Jh70cI0afjt/gH/Z12pvVk5JbRnRIFhJN1CHdJhGiIs48ACeEXPpK7utaHuWSSNka7+Q8raZTOPapo4IyabJju43sKBgQHs2rULa9euDRqwbaxduxY7duzI1Mbhw4cxODiIcePGxR7T39+P/fv3U/90oKl1RjhIqS4Hv6TZoGMNJhenqlVKnKHz8kdYlkUbTXlx0a3YX0Kg0tGFOSOqCKykgV6Wv4+KHgMpzwjokK1qwmceqJX10BpdlzXm9WTNNSZMMzxII1wz2Ouvv45arYbeXjqLobe3F7t3787Uxg033IDJkydTBg2LLVu2oKury/83bdo0nm5mhkqdkUaDNCrSUnvZHYAo4nZtWSfyAjsZKNQ4FGvzdEi4zOKeN9GWh8Caq/geWDGtZIMzC1QZpSoJrEX26mWFToNquFTtHS5o6NN666234t5778X999+Pjo6O2ONuuukm7Nu3z//30ksvaemPSs5IoyuQ0pyRFAXWUvbFNQl7D/SnH5SAZgjTAHTcvWaXcq3MG4eoqqNFB6l6mnd/SUNusCTPC6Jr9IhDWoG1JOcZKdorqtOTS0seNG82zXABlw+sp6cHpVIJe/bsoT7fs2cP+vr6Es/9whe+gFtvvRX/9m//hsWLFyce297ejvZ29VLfLPzU3qK9gRlAc0bSRM9IfQfxl/u1GGMk6/A1SwoaOaHnvYOPgwV6d+9a+S8kaZevNSC1N3M7lBy8fChA1dDLEVgtij+Wm8Gn8DmsapSzDxnzTZpN0yzzahq4nta2tjYsW7aMIp96ZNRVq1bFnvf5z38ef/qnf4qHHnoIy5cvF++taviekeYD+YinhWnsWlCifEDi5R6oyuUd6qiFouNVZzOV8l7k48BTn0gXeJRH3QIRg1mdEWkFVkXPyKSuEVLnV1nOSEGf3axwFBiKsW2HdEZ0EFiVNzlswX2nN2/ejA0bNmD58uVYsWIFbr/9dhw6dAhXXHEFAODyyy/HlClTsGXLFgDAn//5n+Pmm2/GN7/5TcycOdPnlowaNQqjRo1S+FX40cxVe0cOHPF/PtA+MvHY0mCQxSAza8qGomTqbjQSVJgmTWdEd2firmuxCpLFf4ZrTH9FuqxOgZUxRiTbkw3l/f37VuDp3Qdw6pzxEn2gs2lEvHqqQ5KdbXJhFhV1g6Jw3vF9tOiZLs5IE7yXRQG3MbJ+/Xq89tpruPnmm7F7924sXboUDz30kE9qffHFF2ET5uCdd96JgYEBvOMd76DaueWWW/DpT39arveSsJrYvzWq/7D/c1pctVQdVHLNuOHK+rp1d7bhlX1qtQJ0oGaznBG1UObSpwis+dfQSRc9Iyf/kpB7WVVtGp5yCllAcUYEbsRpcyfgtLkTpPtBhmzzUlsmv/7GM+dItaUrTPOhM+bgDbLQpC7RM8MZyQyhO71p0yZs2rQp8m+PPPII9fsLL7wgcomGohlTe/97wszMx+6edzzmb/+e9DVjHRsZh693TDs+dMYJGDOikn5wjqgy2TTF3NxYTOG5/DuZmk2jILVXFdiaJ9KiZ5L9UYVBiu+Uf2qv7LiSG4MXuidJ9iZApWSFqvY2K4G1ebfUNExtGiB/5p8AnpkwA+sv2YJXR/ekHvv4hZfjF0+9iJ3TFkpdM07jYVZPcpjIQ9Vxcf6SyVJ9YKHDtUp5RlIm9LzSadlsmmYwqGsUuVI0TKMGlDFSUqEzkv/4WxbNGanZ/N4y1V9DdlwHKkEiw6Xv+jPZ7vhgC03WvUgaOCMFeC6aBS1ujDQvgRUAfj79+EzHueUy/nLNpdLXY8ub/+hjZ2D/kcHMpLtqTQOBVbPoWX1CL+aEEspOUVHkjPd4KqU1+Wx2JyqCOIP47SdOxT899jKuW3tspnbINGNWQl0ERXlCBhWl8auCrGPgzVGBdP/rI7vlGmPAip7pcGI0JpumWVcwGq1tjAzdxLGj5NOIm4SbKQXyO77n5BmZPSIeqo58yXoW2j0jKXyC3AisYEXP8l94+MI08nLwJL5w8WJ84tx56B0Tr19Egryv1ZLaQnltmkiXWfpAeUZyCtPI1Olh8XzvLDwwfw3eGDEG/eU2yZ4FYAtN6pODV97ksEVLGyMnzxoHPANcfspM6baKbJyqesVIC3z6uE7u86saLDY9nhF6kiqqpzWUncJ5/nmL+vD9p7IpJ6tA2C0ugDgStWVlNkQAUAub6mya7s78OFGDHOrBjYC0V9G2ce0FN6jpDAM2tdcQWPNF/k9rjujqqNtiE8fI5fYDjVdgzQOkIJPI99USptHgmyB3TEWt72FZFmQL5XV3qttpZgEVVhK8b2cv7E0/KAP6y4HBULXL0hY76fXLi6BtwaIF+wrw7KqshqwSdc8iaYyUTGpvzmhpY8R3Z6h4YIa/LSJfN0ODZ0TH5q/KqFgmPh45zTV1BVZZAqva+5H2GpF9dAQXys1nzxU6j0V/ifaMyIIUBOyo5DetFsGrR15SWkxOrivx7VoWZRyryKiKgsmmyQ5jjABKjBEd6qKqoOolIykfYhoRGowRLZwRjvLyAl9JRZdtywqJnuW98KRBhRx8e7mE3jF1jtfa4yYKtQFEhWnkBo98DPLMoKB1RuRq03zi3HlCfVBVp4dtSzXIStcqnoEoGM9IdrQ0Z0SlMVJcU0QdZA2uZpGDpyuflhKvktd9tyx6cRchhDbafmY5LqLY/vEz8btDA5jSLR5ePcoaI5IPEmlo52aMWGEF1idf3ifc3OIp3YLdUEdg1RmmcZiyDzq8rIYzkh3GMwIo8oxIN6ENRSlvLluRNAqqJ6v6Ip9dUlvHd8qCuhw8zRnhvc9Rt1Pm2/DUppEpQNhRKUkZIkDYMyILcizzXH8Gmdo0hwZqCUfrgUrPyLN7D0q2EA/y/Rm0y5qyaRqR2qv9Eg1BaxsjCjFccr2TQK67It9WxxCpftctsAqsybvmvMJzbJimCKJnaT2Q9eSoBEVgLZWlR498N3ITwkN60cz0NhRo1RBNNGIxFgErGqgioyoKJkyTHa1tjLRImEYZZ6SIYRrtCqzJKpZ52aC2ZUmHPaIyonQa1SpEz1SB9IwMKqjaW5RsuoFSYGSVXDldH9EhocI0Uj3QBwsWZRCrqNwchUZkVxfjyZOHMUYANcZIS3hGZI0RRR0hoNwzYlmoWtkJrKwqbaPAVu0VKfSlIkzDM4EXqcownU0jT50ryutPGSMaRAazgLq1BfYMUET1UklPbZoCf/+iwRgjgBrOSD7vfSaoeh1ks2l08CtUv+wW6EqhjlXUMA1NwFOlhyLzddJuBVtlOE8crQTGyOFKR5HXTC6Qz0HJ5eeLqMr08tuTb04PLKYkgF3W4hkxYZrsMMYIoChMU5CtkUact6jP/1nk+zaD96guqU2KniW/Inl9JVb0TJXaps6vo0SBVRFIz8iRtnYFnJGCPNvEM1EEz0iRPQMOE6Zp1qq9wwXGGAEUhWmkmyg8rj5jttT5WsI0il92CxalwOpoKJSnor0wZ4S/Qmvk7ZB4kFML5SnQGVGFgVIZB9rqGTnPj50s/RwV8f0vOXKZNKIj0ogozdbLTpQ634rwLGrRGWlINk0BHz4BGJ0RYPin9ip6Hyolws0u8H2bR2dEffiDxHtWzcBXfvwbnDFvgnAbFhAi4KmAXs8ImYrMbzwphWVh5ca/R8l1cLTSgYqkp6aInlERAquKe6IytTcO5y6aJHW+hXBqr5baNAX2DBUNxhgBFK3WxZuMigYdxohyNzCjM5IqBy+Aj6+bh9OOnYATZ3QLtxHpGVFAYOW9RzyXZPub9xtzuC3QKimXjGdEFVRW7dWJKqNWqyOkUoBahU2D1h6qnD0jS6Z2AQAWD/2vC3npHrBoimwasJwR9Z6RSsnG6mN70NkmvhdgRc9EOBiqd/Npj5mjSPRMB8qyYRpF/VAJIc+IgrmCDtMUY+5hYVkWlXk0WDI6I3mjWDNCo5Fzau9dG5bjY+fMxd0blktfv6i4fNUM/2ctJD8N7zqPzkheYGPeJM9FBlLZNCl/D9XSEb+UcpRLkmGaArpGCuEZyaUH2TBQItVq9SiwGjn47DDGCJCb6NnE0R3Y9JZjMXF0h/T1i4rPXrDI/9lphtReK6zAWkSwCqw1EaJtZJhGsmMJIL03g6VKobwJsp6RImaNSGfTCIueET8XcFyAeh9Jz0jNtrVk0xT1+xcRrW2MKESRCaxFgZ4wjYZsGpsOJ/zm9UNKr6ECLGdEJOwRdTt4d/g8R5PGk6xsuWpUJD0jRdwBl0V0RhRcl3wnCzgsAOqbDvIZHLTLxXbjtABa2xhpEQVWHca5yPdtmmwai/aM/Pszr2u4ihxYBda8PDjUc8DBGdFVC0QUsgTWIhojdgF0RorsGCA9I3WdkQJ3NgEFXnq4YIwRwOiMCKAoqb06wjQUZ6SgdHg2NbFm2dyWWZRBKccZSe4ARRhUIMGuErKpvUUkKpLZQiJQUjSvUCZnAAsW5RlpZmNkuKCYM22jYBRYGwotoSzN2TRF5YxYlkWnIAtl00R9pi9MQ1bKtQr2vpRkPSOS56vE36y4CABw07pN3Ocql4MvzrBQsCygv6S2cnNeGC5rT7G2J41Gi3hGdOxORL7uuM629IM4oWOyY7NpigjLAlziy4ukII9sD7/+OmvTHC23+z/LVpRVDVnPhiwBViW2nHEF/mbl2/H7Tr2SAXGgwzTFGRcWlGfEMp6RvFHMmbZRUKozUmBrJGfcc+XJOHF6N7763pPy7komkAqshfWMACECK2+20uaz52LptG7cetHx/mc6n2IylTIvPkMcZKNxpSKF8ywrN0Nk6PLBz7n1Ih0UZ6RUQkH3HS2D1h5+IwffEKyaPR7/75pTsWDyGOVtq/5qNhP+KKpnhE3trdolVDkfwp5R7fjOxlPxrhXT/c+4s2l4DieLuBXMMyK7K64UyDMiAzWiZ8UP0wD19HIPVVtfmObkY8Zpanl4oZgzbaOgUg6+wMbIG4cHlLdZFEeQDjdwtRkIrEw2zUC5gmpNfoHnva1kvJrnTjw7fhrnlfRC9im6fNVMTOkegfevnqWkP0WA6KtlU56RYlojlsWKntnawjSyaeNpKMpcLAvDGQGGPYH1UH817y5og/LpI5RNU9QwjRUq9MXrGYmEFGck/W5c9s4/xdR9e/C9eafiYvFLKYfsQtTVWcFPbjiz0ByJRoEcgqI6jCxYTGqvHgVWoNi8mSKhtY2RsWOBCROA9vb0Y1MwuVsujU4nDh4dvsZIW1ntrsMCrTNSVSSzrhqWTXttBkoVJZOebpP6J7NO0HwFMahYL8yi46H4YRrbqnsTPQyW9FTtbQSuOn02fvrc73Duwr68uyKF1jZGvvc96Sa++YGVuOc/X8LNf7hAQYf04GC/+hoVeXuCOio2Hrx2tRYXaLUUGCBHK/KGqg7UdUboMI2KjA5uInZxHYJcMIZEGKIjQg9lMcfVZgrl1Wz11bk96B6B0+dOwM4/Pgs9I4s5V2VFaxsjCnDKnB6cMqcn724k4mD/oLK21i+fhgd/+QrevXJ6+sEaMa9vDOZMHK28XcuyKM7IkYIaIyyBddAuK1EBlbFFirnsGDQaTaMzUqZF+HTxWxoxBsOhvlkx2XkGqTht7oTMxx5UyBn583csxi9uOSf3h1/n+01WwD1SzmaMNFoO3LLoTJ/BUlmJZ0TG41XUhcegsSAfg6Jqd1iWhf5SoHtUV2DVc605E0bpaXiYwXhGmhRfe+9JmP8n38dgLX3xOKQ4TCNbbr3IYKv2ZvWMNJqoV7IZAmuprOS+cHtGhkmYxiAM0dBVs+iMkKJnNY1y8B85ey5qros/XDxJS/vDBcN3VRnmKNkWzprfm+nYy06eobk3wwcW6Ayao5V2XHPG7PTzGrwDbC+XUCUm0/5SBUunyQtd6axNY6AXRbELmyFMA9D1kQZtfQTWke1l3HL+QiybYfRGkmA8I02Mz110PCaOacc7lydrNlxxykx89SfP47dvHmlQz5obpALrkXI7VmfgBOVRKI00mjauW6CFQ2PQPJAt9qcDRTZGSHJ6zS4ZEnPOMMZIE2PcyDZ89oJFqcfZtoUTpncbYyQD6gTW4LU4UmnPNEnloacwSBgjC2aMV9ImtwKr4ZgUBp3txUhDb5baNL/tmoh7Fp+Do5V2Ks3XIB8Uz5Q20IIiFfLiwZfetbSh17MAHCJKr9eNkfTz7BzGlzSaSh1qCMXcCqwS6TR58k0+ce68/C6uCZ1tao0RUTuCNECKPuvcdN6H8Zm1V+XdDQMYY6RlkMdiqQIXLJ2C7314TUOvebQSsOyzZtPMmdh4xrxDEFbtDjUpyDqr9hYJ15wxB9evPTbvbijFyLZiOLrtJvGMGBQLxhhpETSrZyQO2gSKLOClrkDJsL/clrhAf+ldSzGqvYyrTjtGT4cS4FrqjJFjJowEAJy7iE/FsWdUcN3OSvLO/J8+tAqXrAj4TXmvU90jhpdrfsJo+hk4pmck7rny5Ib3gyQyD7Npx0AjimFKG2hHo3UwmhcWDrZ3Ys1Vd9dTfC0rkUdxwdIpOH/x5Fw8T+Qly5IlDb511Sr8+H9ewx8cz5d+2Fa28YtbzoFtpad8L5sxDstmjMM9O1+S6aoyFCX7RBU6GGPwhx87Q6o9FQqsshlWFyydjO8+8YpUGwbNAeMZaRGsG6pbMH5kW8qRrQ1vIn2puw+vjskmLJdXCKzkBlV6S51ytZF6RrXjohOnhha0LOgaUcHojubzMgxHjRTVtZpEQL4Nst6v2965VK4Bg6aB8Yy0CM6YNxH3X3MKZvWMzLsrTYeirlkj+4PsqJKCYo+thqLeVxkUwf+pksBqPLqtA2OMtBBOmD427y4IYeq48K5f1xQV1S538bgGobP/kP+zlf+GmBvLcxaB4k1jbgbkzcMJ9aEA/TFoDjThFGbQahjTUcG/f+LMhlwrajIv6pr1rwtOAwA8MWluUxGUt3/8DPzl+iV4x7KpeXfFQAOoZ7Gg745B8WA8IwZNgWnjOnO7dlHn0yPTZuKEa7+B/R2j8FxB0jqzYMb4kZgxPv9wYVGNzKJA1MtChlZqZpANMqJ5ZjADgwYgiv1fVHe+67p4o1O+Hk2rQkY9tqgoQn2gMiFLX3PUjfHZC3rx3GsHsenMOcraNCgOjDFi0JTQVTl4RISKZUFtkWG4lDYWRb2vMigCZ4T0jKgc45njO3HX5cvVNWhQKBjOiEHT4C/esdj/uVJq3Kxb1B30x86pS5qTQmIG2VHMu1okiL1jJGdEpWdksGbu2HCG8YwYNA0uXj4NH//HXwKgXcG6UdQd9NuXTcUpc8ajb4yaujSthqLe16JAtMSBrYkzsv/ooLK2DIoHY4wYNCUqmsI0USjyojWpS07srJVRVI+XDFT4C3/56XNwdLCGLgVy+Y5Cz8jvDw0oa8ugeDBhGoOmRGPDNAbDEcNRjVhFYboxHRVMHK3G26bCFvnA6lkAgM1nz5VvLAZ3Gy5K7jCeEYOmhC7PCLkbHDeyDb8/NIATp3druZZBvrjoxKl47H/fxClzxufdFWUY3VHGwf5q3t3woSJM86k/XICPnjMvklyuAh89ey7WLujV0rZBdhhjxKApUdbkGfnL9Utx/X1P4JozZuP0uRNwZKCGscNwB21QN2j/nCBFDwfcdflyfPRbv8AN583LuysA1IVpdBkigBrvjYE8hLaXd9xxB2bOnImOjg6sXLkSO3fuTDz+29/+NubPn4+Ojg4cf/zx+N73vifUWQMDD22aPCOzekbiuxtPxbqFfeiolIwhYtBUWDSlCz/4yGl4y/xi7PRVZtPownDkDjUjuGf0++67D5s3b8Ytt9yCxx57DEuWLMG6deuwd+/eyON/+tOf4pJLLsH73/9+PP7447jwwgtx4YUX4qmnnpLuvEHrYvWxPXl3wcDAIAXtleLTEotMUG8lWC6nvOTKlStx0kkn4a//+q8BAI7jYNq0abj22mtx4403ho5fv349Dh06hAcffND/7OSTT8bSpUuxdevWTNfcv38/urq6sG/fPowZM4anuwbDDK+8eQS/emU/1h43UQlZz8DAQD22bn8Oj77we9x52bKGZr7xYOaN/wIA2HrZMpy7qC/n3gxfZF2/uTgjAwMD2LVrF2666Sb/M9u2sXbtWuzYsSPynB07dmDz5s3UZ+vWrcN3vvMdnksbGAAAJnePwORuk85qYFBkXH36bOD02Xl3IxHfv24Nnnx5H9YtLEZIq9XBZYy8/vrrqNVq6O2lb15vby/++7//O/Kc3bt3Rx6/e/fu2Ov09/ejv7/f/33//v083TQwMDAwMEjEcZPG4LhJxtNeFBTSf7ZlyxZ0dXX5/6ZNM3LXBgYGBgYGwxVcxkhPTw9KpRL27NlDfb5nzx709UXH3Pr6+riOB4CbbroJ+/bt8/+99NJLPN00MDAwMDAwaCJwGSNtbW1YtmwZtm3b5n/mOA62bduGVatWRZ6zatUq6ngAePjhh2OPB4D29naMGTOG+mdgYGBgYGAwPMEterZ582Zs2LABy5cvx4oVK3D77bfj0KFDuOKKKwAAl19+OaZMmYItW7YAAK677jqcfvrp+OIXv4i3vvWtuPfee/Hoo4/iK1/5itpvYmBgYGBgYNCU4DZG1q9fj9deew0333wzdu/ejaVLl+Khhx7ySaovvvgibKKi6imnnIJvfvOb+NSnPoVPfvKTOPbYY/Gd73wHixYtUvctDAwMDAwMDJoW3DojecDojBgYGBgYGDQfsq7fhcymMTAwMDAwMGgdGGPEwMDAwMDAIFcYY8TAwMDAwMAgVxhjxMDAwMDAwCBXGGPEwMDAwMDAIFcYY8TAwMDAwMAgVxhjxMDAwMDAwCBXcIue5QFPCsVU7zUwMDAwMGgeeOt2mqRZUxgjBw4cAABTvdfAwMDAwKAJceDAAXR1dcX+vSkUWB3HwSuvvILRo0fDsqxM5+zfvx/Tpk3DSy+9ZFRbM8CMFz/MmPHDjBk/zJjxwYwXP3SOmeu6OHDgACZPnkyVimHRFJ4R27YxdepUoXNN1V8+mPHihxkzfpgx44cZMz6Y8eKHrjFL8oh4MARWAwMDAwMDg1xhjBEDAwMDAwODXDFsjZH29nbccsstaG9vz7srTQEzXvwwY8YPM2b8MGPGBzNe/CjCmDUFgdXAwMDAwMBg+GLYekYMDAwMDAwMmgPGGDEwMDAwMDDIFcYYMTAwMDAwMMgVxhgxMDAwMDAwyBXD0hi54447MHPmTHR0dGDlypXYuXNn3l0qDH784x/j/PPPx+TJk2FZFr7zne9Qf3ddFzfffDMmTZqEESNGYO3atXjmmWfy6WwBsGXLFpx00kkYPXo0Jk6ciAsvvBBPP/00dczRo0exceNGjB8/HqNGjcLb3/527NmzJ6ce548777wTixcv9gWUVq1ahe9///v+3814pePWW2+FZVm4/vrr/c/MuNH49Kc/DcuyqH/z58/3/27GK4zf/va3uOyyyzB+/HiMGDECxx9/PB599FH/73nO/8POGLnvvvuwefNm3HLLLXjsscewZMkSrFu3Dnv37s27a4XAoUOHsGTJEtxxxx2Rf//85z+PL3/5y9i6dSt+/vOfY+TIkVi3bh2OHj3a4J4WA9u3b8fGjRvxs5/9DA8//DAGBwdxzjnn4NChQ/4xH/nIR/DAAw/g29/+NrZv345XXnkFF110UY69zhdTp07Frbfeil27duHRRx/FW97yFlxwwQX41a9+BcCMVxr+8z//E3/zN3+DxYsXU5+bcQtj4cKFePXVV/1/P/nJT/y/mfGi8cYbb+DUU09FpVLB97//ffz617/GF7/4RYwdO9Y/Jtf53x1mWLFihbtx40b/91qt5k6ePNndsmVLjr0qJgC4999/v/+74zhuX1+f+xd/8Rf+Z2+++abb3t7u3nPPPTn0sHjYu3evC8Ddvn2767r18alUKu63v/1t/5j/+q//cgG4O3bsyKubhcPYsWPdu+++24xXCg4cOOAee+yx7sMPP+yefvrp7nXXXee6rnnOonDLLbe4S5YsifybGa8wbrjhBnf16tWxf897/h9WnpGBgQHs2rULa9eu9T+zbRtr167Fjh07cuxZc+D555/H7t27qfHr6urCypUrzfgNYd++fQCAcePGAQB27dqFwcFBaszmz5+P6dOnmzEDUKvVcO+99+LQoUNYtWqVGa8UbNy4EW9961up8QHMcxaHZ555BpMnT8YxxxyDSy+9FC+++CIAM15R+Od//mcsX74cF198MSZOnIgTTjgBd911l//3vOf/YWWMvP7666jVaujt7aU+7+3txe7du3PqVfPAGyMzftFwHAfXX389Tj31VCxatAhAfcza2trQ3d1NHdvqY/bkk09i1KhRaG9vx9VXX437778fCxYsMOOVgHvvvRePPfYYtmzZEvqbGbcwVq5cia9//et46KGHcOedd+L555/HmjVrcODAATNeEfjNb36DO++8E8ceeyx+8IMf4EMf+hA+/OEP4+/+7u8A5D//N0XVXgODImDjxo146qmnqLi0QTTmzZuHJ554Avv27cM//uM/YsOGDdi+fXve3SosXnrpJVx33XV4+OGH0dHRkXd3mgLnnXee//PixYuxcuVKzJgxA9/61rcwYsSIHHtWTDiOg+XLl+Nzn/scAOCEE07AU089ha1bt2LDhg05926YeUZ6enpQKpVCjOk9e/agr68vp141D7wxMuMXxqZNm/Dggw/iRz/6EaZOnep/3tfXh4GBAbz55pvU8a0+Zm1tbZgzZw6WLVuGLVu2YMmSJfjSl75kxisGu3btwt69e3HiiSeiXC6jXC5j+/bt+PKXv4xyuYze3l4zbino7u7G3Llz8eyzz5rnLAKTJk3CggULqM+OO+44P7SV9/w/rIyRtrY2LFu2DNu2bfM/cxwH27Ztw6pVq3LsWXNg1qxZ6Ovro8Zv//79+PnPf96y4+e6LjZt2oT7778fP/zhDzFr1izq78uWLUOlUqHG7Omnn8aLL77YsmMWBcdx0N/fb8YrBmeddRaefPJJPPHEE/6/5cuX49JLL/V/NuOWjIMHD+K5557DpEmTzHMWgVNPPTUkS/A///M/mDFjBoACzP/aKbINxr333uu2t7e7X//6191f//rX7gc/+EG3u7vb3b17d95dKwQOHDjgPv744+7jjz/uAnBvu+029/HHH3f/93//13Vd17311lvd7u5u97vf/a77y1/+0r3gggvcWbNmuUeOHMm55/ngQx/6kNvV1eU+8sgj7quvvur/O3z4sH/M1Vdf7U6fPt394Q9/6D766KPuqlWr3FWrVuXY63xx4403utu3b3eff/5595e//KV74403upZluf/6r//quq4Zr6wgs2lc14wbi49+9KPuI4884j7//PPuf/zHf7hr1651e3p63L1797qua8aLxc6dO91yuez+2Z/9mfvMM8+43/jGN9zOzk73H/7hH/xj8pz/h50x4rqu+1d/9Vfu9OnT3ba2NnfFihXuz372s7y7VBj86Ec/cgGE/m3YsMF13Xp615/8yZ+4vb29bnt7u3vWWWe5Tz/9dL6dzhFRYwXA/drXvuYfc+TIEfeaa65xx44d63Z2drp/9Ed/5L766qv5dTpnvO9973NnzJjhtrW1uRMmTHDPOuss3xBxXTNeWcEaI2bcaKxfv96dNGmS29bW5k6ZMsVdv369++yzz/p/N+MVxgMPPOAuWrTIbW9vd+fPn+9+5Stfof6e5/xvua7r6ve/GBgYGBgYGBhEY1hxRgwMDAwMDAyaD8YYMTAwMDAwMMgVxhgxMDAwMDAwyBXGGDEwMDAwMDDIFcYYMTAwMDAwMMgVxhgxMDAwMDAwyBXGGDEwMDAwMDDIFcYYMTAwMDAwMMgVxhgxMDAwMDAwyBXGGDEwMDAwMDDIFcYYMTAwMDAwMMgVxhgxMDAwMDAwyBX/PzoSwSkF1XiVAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[(1.05, 51.0, 0.0),\n",
       " (0.3, 53.0, 200.0),\n",
       " (0.5, 51.0, -200.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.4, 49.0, -200.0),\n",
       " (0.5, 48.0, -100.0),\n",
       " (0.5, 48.0, 0.0),\n",
       " (0.5, 49.0, 100.0),\n",
       " (0.5, 49.0, 0.0),\n",
       " (0.5, 51.0, 200.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.025, 49.0, -200.0),\n",
       " (0.5, 48.0, -100.0),\n",
       " (0.5, 48.0, 0.0),\n",
       " (0.5, 51.0, 300.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.475, 53.0, 200.0),\n",
       " (0.5, 51.0, -200.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.5, 48.0, -300.0),\n",
       " (0.5, 48.0, 0.0),\n",
       " (0.5, 53.0, 500.0),\n",
       " (0.5, 53.0, 0.0),\n",
       " (0.5, 49.0, -400.0),\n",
       " (0.5, 49.0, 0.0),\n",
       " (0.125, 52.0, 300.0),\n",
       " (0.1, 53.0, 100.0),\n",
       " (0.425, 52.0, -100.0),\n",
       " (0.475, 51.0, -100.0),\n",
       " (0.1, 52.0, 100.0),\n",
       " (0.175, 51.0, -100.0),\n",
       " (0.5, 49.0, -200.0),\n",
       " (0.5, 49.0, 0.0),\n",
       " (0.5, 46.0, -300.0),\n",
       " (0.5, 46.0, 0.0),\n",
       " (0.5, 51.0, 500.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.05, 56.0, 500.0),\n",
       " (0.5, 57.0, 100.0),\n",
       " (0.5, 57.0, 0.0),\n",
       " (0.5, 53.0, -400.0),\n",
       " (0.5, 53.0, 0.0),\n",
       " (0.075, 54.0, 100.0),\n",
       " (0.375, 53.0, -100.0),\n",
       " (0.025, 56.0, 300.0),\n",
       " (0.5, 57.0, 100.0),\n",
       " (0.5, 57.0, 0.0),\n",
       " (0.5, 51.0, -600.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.5, 52.0, 100.0),\n",
       " (0.5, 52.0, 0.0),\n",
       " (0.5, 53.0, 100.0),\n",
       " (0.5, 53.0, 0.0),\n",
       " (0.5, 51.0, -200.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.5, 48.0, -300.0),\n",
       " (0.5, 48.0, 0.0),\n",
       " (0.5, 51.0, 300.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.45, 53.0, 200.0),\n",
       " (0.125, 52.0, -100.0),\n",
       " (0.45, 51.0, -100.0),\n",
       " (0.025, 56.0, 500.0),\n",
       " (0.2, 57.0, 100.0),\n",
       " (0.5, 56.0, -100.0),\n",
       " (0.5, 56.0, 0.0),\n",
       " (0.5, 57.0, 100.0),\n",
       " (0.5, 57.0, 0.0),\n",
       " (0.3, 53.0, -400.0),\n",
       " (0.5, 51.0, -200.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.125, 52.0, 100.0),\n",
       " (0.5, 51.0, -100.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.425, 52.0, 100.0),\n",
       " (0.5, 51.0, -100.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.5, 48.0, -300.0),\n",
       " (0.5, 48.0, 0.0),\n",
       " (0.5, 53.0, 500.0),\n",
       " (0.5, 53.0, 0.0),\n",
       " (0.5, 49.0, -400.0),\n",
       " (0.5, 49.0, 0.0),\n",
       " (0.5, 51.0, 200.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.5, 48.0, -300.0),\n",
       " (0.5, 48.0, 0.0),\n",
       " (0.075, 51.0, 300.0),\n",
       " (0.15, 52.0, 100.0),\n",
       " (0.5, 51.0, -100.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.2, 53.0, 200.0),\n",
       " (0.5, 52.0, -100.0),\n",
       " (0.5, 52.0, 0.0),\n",
       " (0.05, 50.0, -200.0),\n",
       " (0.5, 49.0, -100.0),\n",
       " (0.5, 49.0, 0.0),\n",
       " (0.5, 52.0, 300.0),\n",
       " (0.5, 52.0, 0.0),\n",
       " (0.5, 51.0, -100.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.45, 53.0, 200.0),\n",
       " (0.5, 49.0, -400.0),\n",
       " (0.5, 49.0, 0.0),\n",
       " (0.5, 56.0, 700.0),\n",
       " (0.5, 56.0, 0.0),\n",
       " (0.075, 55.0, -100.0),\n",
       " (0.3, 54.0, -100.0),\n",
       " (0.2, 53.0, -100.0),\n",
       " (0.35, 51.0, -200.0),\n",
       " (0.25, 53.0, 200.0),\n",
       " (0.5, 51.0, -200.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.45, 49.0, -200.0),\n",
       " (0.3, 48.0, -100.0),\n",
       " (0.2, 49.0, 100.0),\n",
       " (0.5, 51.0, 200.0),\n",
       " (0.5, 51.0, 0.0),\n",
       " (0.3, 53.0, 200.0),\n",
       " (0.05, 52.0, -100.0)]"
      ]
     },
     "execution_count": 786,
     "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": [
    "import librosa \n",
    "import numpy as np\n",
    "from scipy.signal import savgol_filter\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def filter_data(time, frequency, confidence):\n",
    "    data = tuple(data for data in zip(list(time), list(frequency), list(confidence)) if data[2] > 0.1)\n",
    "    dev = 0\n",
    "    dur = 0\n",
    "    for (p1, p2) in pairwise(data):\n",
    "        t_diff = (p2[0] - p1[0])\n",
    "        dur = round(dur + (p2[0] - p1[0]), 2)\n",
    "        if(True):\n",
    "            freq1, conf1 = p1[1:3]\n",
    "            midi1 = librosa.hz_to_midi(freq1)\n",
    "            r_midi1 = np.around(midi1)\n",
    "            freq2, conf2 = p2[1:3]\n",
    "            midi2 = librosa.hz_to_midi(freq2)\n",
    "            r_midi2 = np.around(midi2)\n",
    "            #if(r_midi2 != r_midi1):\n",
    "            if(True):\n",
    "                yield(dur, freq1, conf1, midi1, r_midi1, dev * 100)\n",
    "                dev = r_midi2 - r_midi1\n",
    "                dur = 0\n",
    "                \n",
    "def filter_data(time, frequency, confidence):\n",
    "    data = tuple(data for data in zip(list(time), list(frequency), list(confidence)) if data[2] > 0.9)\n",
    "    #durs = tuple(round(y[0]-x[0], 2) for (x, y) in pairwise(data)) + ((1,))\n",
    "    #data = tuple((d,) + data[i][1:] for i, d in enumerate(durs) if d > 0.01)\n",
    "    #print(data)\n",
    "    m, rm = [librosa.hz_to_midi(data[0][1]), np.around(librosa.hz_to_midi(data[0][1]))]\n",
    "    yield(data[0] + (m, rm, 0,))\n",
    "    for i, [t, f, c] in enumerate(data):\n",
    "        nm, nrm = [librosa.hz_to_midi(f), np.around(librosa.hz_to_midi(f))]\n",
    "        if((0 < i < len(data) - 1) and (nrm != rm)):\n",
    "            m, rm, d = [nm, nrm, nrm - rm]\n",
    "            yield(t, f, c, m, rm, d * 100)\n",
    "            \n",
    "t_min = 50\n",
    "t_max = 600\n",
    "f_time, f_frequency, f_confidence = [time[t_min:], frequency[t_min:], confidence[t_min:]]\n",
    "s_confidence = savgol_filter(f_confidence, 30, 4)\n",
    "plt.plot(f_time, f_confidence)\n",
    "plt.plot(f_time, s_confidence, color='red')\n",
    "plt.show()\n",
    "\n",
    "def filter_midi(f_time, f_frequency, s_confidence):\n",
    "    last_confident_value = 51\n",
    "    for t, f, c in zip(f_time, f_frequency, s_confidence):\n",
    "        if c > 0.9:\n",
    "            last_confident_value = librosa.hz_to_midi(f)\n",
    "        yield last_confident_value\n",
    "            \n",
    "#m_time, midi = zip(*[[t, librosa.hz_to_midi(f)] for t, f, c in zip(f_time, f_frequency, s_confidence) if c > 0.0])\n",
    "#nr_midi = np.interp(f_time, m_time, midi)\n",
    "#r_midi = np.interp(f_time, m_time, np.around(midi))\n",
    "#midi\n",
    "\n",
    "midi = list(filter_midi(f_time, f_frequency, s_confidence))\n",
    "\n",
    "def snap_midi(midi):\n",
    "    r_midi = np.around(midi)\n",
    "    s_midi = np.around(savgol_filter(midi, 30, 5))\n",
    "    last_val = s_midi[0]\n",
    "    for i, (r1, r2) in enumerate(pairwise(r_midi)):\n",
    "        if r1 != r2:\n",
    "            last_val = s_midi[i+5]\n",
    "        yield last_val\n",
    "    yield last_val\n",
    "\n",
    "def filter_midi(midi):\n",
    "    last_val = midi[0]\n",
    "    dur = 1\n",
    "    dev = 0.0\n",
    "    first_flag = True\n",
    "    for i, (m1, m2) in enumerate(pairwise(midi)):\n",
    "        if m1 != m2:\n",
    "            #yield (dur / 40, last_val, dev * 100)\n",
    "            if first_flag or dur < 20:\n",
    "                yield (dur / 40, last_val, dev * 100)\n",
    "                first_flag = False\n",
    "            else:\n",
    "                size = int(dur / 20)\n",
    "                yield (20 / 40.0, last_val, dev * 100)\n",
    "                yield (20 / 40.0, last_val, 0.0)\n",
    "            last_val = m2\n",
    "            dur = 1\n",
    "            dev = m2 - m1\n",
    "        else:\n",
    "            dur += 1\n",
    "            \n",
    "    \n",
    "\n",
    "plt.plot(f_time, midi)\n",
    "plt.plot(f_time, savgol_filter(midi, 30, 5), color='yellow')\n",
    "plt.plot(f_time, np.around(savgol_filter(midi, 30, 5)), color='red')\n",
    "plt.plot(f_time, np.around(midi), color='green')\n",
    "plt.plot(f_time, list(snap_midi(midi)), color='blue')\n",
    "#plt.show()\n",
    "\n",
    "target_melody_data = list(filter_midi(list(snap_midi(midi))))\n",
    "target_melody_data\n",
    "\n",
    "#target_melody_data = list(filter_data(time, frequency, confidence))\n",
    "#target_melody_data\n",
    "#durs = tuple(round(y[0]-x[0], 2) for (x, y) in pairwise(target_melody_data)) + ((1,))\n",
    "#print(durs)\n",
    "#target_melody_data = tuple((d,) + target_melody_data[i][1:] for i, d in enumerate(durs) if d > 0.1)\n",
    "#list(target_melody_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 750,
   "id": "aa9c7525-4d17-4b87-9d92-60096867cd49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40.0"
      ]
     },
     "execution_count": 750,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1/0.025"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 822,
   "id": "b0d17cc2-a181-4212-aba5-72b90cab2a84",
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import choice, choices\n",
    "\n",
    "# This is for the beginning / breysheet\n",
    "def stochastic_hamiltonian(graph):\n",
    "\n",
    "    #try making this omit the moving voice\n",
    "    def movement_size_weights(edges):\n",
    "        \n",
    "        def max_cent_diff(edge):\n",
    "            res = max([abs(v) for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None])\n",
    "            return res\n",
    "            \n",
    "        def min_cent_diff(edge):\n",
    "            res = [abs(v) for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None]\n",
    "            res.remove(0)\n",
    "            return min(res)\n",
    "            \n",
    "        for e in edges:\n",
    "            yield 200 if ((max_cent_diff(e) < 100) and (min_cent_diff(e)) >= 0) else 1\n",
    "\n",
    "    def hamiltonian_weights(edges):\n",
    "        for e in edges:\n",
    "            yield 10 if e[1] not in [path_edge[0] for path_edge in path] else 1 / graph.nodes[e[1]]['count']\n",
    "    \n",
    "    def contrary_motion_weights(edges):\n",
    "\n",
    "        def is_contrary(edge):\n",
    "            cent_diffs = [v for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None]\n",
    "            cent_diffs.sort()\n",
    "            return (cent_diffs[0] < 0) and (cent_diffs[1] == 0) and (cent_diffs[2] > 0)\n",
    "\n",
    "        for e in edges:\n",
    "            yield 2 if is_contrary(e) else 1\n",
    "    \n",
    "    def is_directly_tunable_weights(edges):\n",
    "        for e in edges:\n",
    "            yield 10 if e[2]['is_directly_tunable'] else 1\n",
    "\n",
    "    def symdiff_weights(edges):\n",
    "        for e in edges:\n",
    "            yield 1000 if e[2]['symmetric_difference'] == 2 else 1\n",
    "\n",
    "    def transposition_weight(edges):\n",
    "        for e in edges:\n",
    "            yield 100 if 0 <= hs_array_to_cents(e[2]['transposition']) < 100 else 1\n",
    "\n",
    "    def is_sustained_voice(edges, voice):\n",
    "        \n",
    "        def is_sustained(edge):\n",
    "            source = list(edge[0])\n",
    "            ordered_source = sorted(source, key=hs_array_to_fr)    \n",
    "            destination = [transpose_pitch(edge[2]['movements'][p]['destination'], edge[2]['transposition']) for p in source]\n",
    "            ordered_destination = sorted(destination, key=hs_array_to_fr)\n",
    "            return ordered_source[voice] == ordered_destination[voice]\n",
    "\n",
    "        for e in edges:\n",
    "            yield 10 if is_sustained(e) else 1\n",
    "\n",
    "    def voice_crossing_weights(edges):\n",
    "        \n",
    "        def has_voice_crossing(edge):\n",
    "            source = list(edge[0])\n",
    "            ordered_source = sorted(source, key=hs_array_to_fr)    \n",
    "            source_order = [ordered_source.index(p) for p in source]\n",
    "            destination = [transpose_pitch(edge[2]['movements'][p]['destination'], edge[2]['transposition']) for p in source]\n",
    "            ordered_destination = sorted(destination, key=hs_array_to_fr)\n",
    "            destination_order = [ordered_destination.index(p) for p in destination]\n",
    "            return source_order != destination_order\n",
    "\n",
    "        for e in edges:\n",
    "            yield 10 if not has_voice_crossing(e) else 0\n",
    "\n",
    "    def is_bass_rooted(chord):\n",
    "        return max([sum(abs(p) for p in collapse_pitch(pitch_difference(chord[0], p))) for p in chord[1:]]) == 1\n",
    "\n",
    "    def target_melody_weights(edges, target, c_devs, voice):\n",
    "\n",
    "        def target_weight(edge, target, c_devs, voice):\n",
    "            candidate_diffs = []\n",
    "            for idx, dev in enumerate(c_devs):\n",
    "                if(idx == 2):\n",
    "                    source = list(edge[0])\n",
    "                    ordered_source = sorted(source, key=hs_array_to_fr)    \n",
    "                    candidate_diff = edge[2]['movements'][ordered_source[idx]]['cent_difference']\n",
    "                    candidate_diffs += [abs(dev + candidate_diff - target)]\n",
    "            #return 1/pow(1.1, min(candidate_diffs))\n",
    "            return 1 if min(candidate_diffs) < 40 else 1/pow(1.1, min(candidate_diffs))\n",
    "            \n",
    "        for e in edges:\n",
    "            yield target_weight(e, target, c_devs, voice)\n",
    "        \n",
    "    check_graph = graph.copy()\n",
    "    next_node = choice(list(graph.nodes()))\n",
    "    check_graph.remove_node(next_node)\n",
    "    for node in graph.nodes(data=True):\n",
    "        node[1]['count'] = 1\n",
    "    path = []\n",
    "    s_next_node = sorted(next_node, key=hs_array_to_fr)\n",
    "    c_devs = (cent_difference(s_next_node[2], s_next_node[0]), cent_difference(s_next_node[2], s_next_node[1]), 0,)\n",
    "    #c_devs = (0, cent_difference(s_next_node[0], s_next_node[1]), cent_difference(s_next_node[0], s_next_node[2]),)\n",
    "    print(c_devs)\n",
    "    while (nx.number_of_nodes(check_graph) > 0) and (len(path) < len(target_melody_data)-1):\n",
    "        out_edges = list(graph.out_edges(next_node, data=True))\n",
    "        factors = [\n",
    "            movement_size_weights(out_edges), \n",
    "            hamiltonian_weights(out_edges), \n",
    "            contrary_motion_weights(out_edges), \n",
    "            is_directly_tunable_weights(out_edges),\n",
    "            voice_crossing_weights(out_edges),\n",
    "            #transposition_weight(out_edges),\n",
    "            #is_sustained_voice(out_edges, 0),\n",
    "            target_melody_weights(out_edges, target_melody_data[len(path)+1][-1], c_devs, 2),\n",
    "            symdiff_weights(out_edges)\n",
    "        ]\n",
    "        weights = [prod(a) for a in zip(*factors)]\n",
    "        edge = choices(out_edges, weights=weights)[0]\n",
    "        next_node = edge[1]\n",
    "        node[1]['count'] += 1\n",
    "        path.append(edge)\n",
    "        s_chord = tuple(sorted(edge[0], key=hs_array_to_fr))\n",
    "        c_devs = tuple(c_devs[pdx] + edge[2]['movements'][pitch]['cent_difference'] - target_melody_data[len(path)][-1] for pdx, pitch in enumerate(s_chord))\n",
    "        print(c_devs)\n",
    "        if next_node in check_graph.nodes:\n",
    "            check_graph.remove_node(next_node)\n",
    "    return path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 824,
   "id": "a8592bc9-7e9e-4b6a-9eaa-4c4e3b69ce91",
   "metadata": {},
   "outputs": [],
   "source": [
    "dims = (2, 3, 5, 7, 11, 13)\n",
    "root = (0, 0, 0, 0, 0, 0)\n",
    "chord = (root,)\n",
    "chord_set = chords(chord, root, 3, 3)\n",
    "graph = generate_graph(chord_set, 4, 4, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 825,
   "id": "be01e4ae-e629-42ff-9d95-f77d510c13bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-359.4723382306895, -231.17409353087487, 0)\n",
      "(-929.2190926654878, -431.17409353087487, -44.86037966604022)\n",
      "(-729.2190926654878, -177.9011503007306, -27.26409180010012)\n",
      "(-826.5832079359744, -177.9011503007306, -12.896921800808741)\n",
      "(-626.5832079359744, -240.26949407113915, -9.09540054026445)\n",
      "(-526.5832079359744, -206.43935910209234, 24.734734428782644)\n",
      "(-526.5832079359744, -167.11086970528447, -28.538208801361634)\n",
      "(-1107.6385314745955, -267.1108697052845, -35.936776174409715)\n",
      "(-1004.7626826435351, -587.2547185391661, -35.936776174409715)\n",
      "(-1018.4288120700417, -787.2547185391661, 26.431567595998786)\n",
      "(-942.3943388731266, -814.0960941733115, 26.431567595998786)\n",
      "(-742.3943388731266, -511.22024534225113, -13.175246207638565)\n",
      "(-642.3943388731266, -353.1846194685721, 6.287718762117265)\n",
      "(-712.6569576992622, -353.1846194685721, 33.12909439626287)\n",
      "(-1151.2296186031854, -653.1846194685721, -4.5025618333286275)\n",
      "(-1107.138446562843, -555.8205041980855, -4.5025618333286275)\n",
      "(-986.9945977289614, -755.8205041980855, -18.168691259835214)\n",
      "(-1053.8655033326986, -555.8205041980855, -4.5025618333284)\n",
      "(-973.3284683024546, -613.8561300717643, -4.5025618333284)\n",
      "(-673.3284683024546, -122.01052593769703, -24.64641066720992)\n",
      "(-575.9643530319679, -189.65063916713234, -24.64641066720992)\n",
      "(-920.8247326980081, -689.6506391671323, 12.304361698255548)\n",
      "(-828.2233000710562, -636.3776959369881, 12.304361698255548)\n",
      "(-885.0597535722322, -236.37769593698806, -5.203602406112964)\n",
      "(-974.029508875239, -160.34322274007286, -5.203602406112964)\n",
      "(-819.8155609707633, -460.34322274007286, 37.701776394539706)\n",
      "(-946.6569366049085, -560.3432227400729, -9.025280375316015)\n",
      "(-846.6569366049085, -392.4429887004319, -6.129274835597016)\n",
      "(-651.915326931122, -292.4429887004319, -3.233269295877676)\n",
      "(-778.7567025652673, -392.4429887004319, -32.97065046974228)\n",
      "(-678.7567025652673, -30.07464493002334, 23.19829830012077)\n",
      "(-478.75670256526735, -247.58260903439174, 19.28829656934579)\n",
      "(-532.0296457954114, -340.18404166134366, 19.28829656934579)\n",
      "(-538.2290407959566, -40.184041661343656, 13.088901568800509)\n",
      "(-373.2248122960349, -218.08519196207467, 13.088901568800509)\n",
      "(-873.2248122960349, -59.53852616086908, -32.6971505267237)\n",
      "(-846.3834366618896, -263.8712440575988, -32.6971505267237)\n",
      "(-1123.3435822882886, -763.8712440575988, 49.815042077566545)\n",
      "(-1095.045337588474, -863.8712440575988, -23.343582288288076)\n",
      "(-672.0256399235316, -409.65729615312296, -23.343582288288076)\n",
      "(-369.12963438381234, -9.657296153122957, 17.184079481022536)\n",
      "(-823.3435822882882, -213.99001404985268, 17.184079481022536)\n",
      "(-923.3435822882882, -372.02563992353157, 14.288073941303537)\n",
      "(-823.3435822882882, -174.66152465304492, 17.184079481022536)\n",
      "(-972.7065237876574, -474.6615246530449, 23.383474481567873)\n",
      "(-1125.9794670178014, -574.6615246530449, -23.343582288287962)\n",
      "(-1072.7065237876573, -521.3885814229009, -23.343582288287962)\n",
      "(-472.70652378765726, -205.83561818392036, 25.338475346955192)\n",
      "(-525.9794670178013, -166.50712878711244, 25.338475346955192)\n",
      "(-625.9794670178013, -239.6657531529671, 22.702590617441842)\n",
      "(-599.1380913836559, -239.6657531529671, -8.491659622091902)\n",
      "(-725.9794670178012, -339.6657531529671, -24.024466152413993)\n",
      "(-672.706523787657, -255.19855968328955, -24.024466152413993)\n",
      "(-472.70652378765703, -334.13386288373465, 25.33847534695508)\n",
      "(-525.9794670178011, -360.97523851788, 25.33847534695508)\n",
      "(-874.6615246530446, -60.97523851787997, -34.13386288373431)\n",
      "(-1002.9597693528591, -393.60620111442415, -34.13386288373431)\n",
      "(-1053.0785393451129, -693.6062011144242, 8.348799750963735)\n",
      "(-960.4771067181607, -640.3332578842799, 8.348799750963735)\n",
      "(-1160.4771067181607, -346.79082058299616, 12.681517647693681)\n",
      "(-798.1087629477522, -246.79082058299616, -15.616727052120837)\n",
      "(-698.1087629477522, -200.06376381314044, 3.8462379176348804)\n",
      "(-1086.3774776779744, -700.0637638131404, 1.8912370522474475)\n",
      "(-1186.3774776779744, -826.9051394472858, -13.218853312119904)\n",
      "(-993.7760450510223, -726.9051394472858, -24.950138581897704)\n",
      "(-904.8062897480155, -673.6321962171418, -24.950138581897704)\n",
      "(-1004.8062897480155, -849.666669414057, -35.980383278891054)\n",
      "(-626.626815040455, -395.4527215095811, -35.980383278891054)\n",
      "(-354.9250597402696, 4.547278490418876, 31.388654124564994)\n",
      "(-470.5663467408225, -319.92928824019305, 231.388654124565)\n",
      "(-470.5663467408225, -239.39225320994865, 27.478652393790014)\n",
      "(-570.5663467408225, -378.72074260675635, -19.248404376065707)\n",
      "(-470.5663467408225, -239.39225320994865, 27.478652393790014)\n",
      "(-523.8392899709665, -292.6651964400927, 27.478652393790014)\n",
      "(-708.3064834406446, -392.6651964400927, -6.351482575257307)\n",
      "(-608.3064834406446, -377.1323899097706, 9.181323955064897)\n",
      "(-639.5007336801782, -350.2910142756253, 9.181323955064897)\n",
      "(-339.5007336801782, -108.3266401493043, 19.971604550511017)\n",
      "(-366.34210931432364, -135.16801578344962, 19.971604550511017)\n",
      "(-866.3421093143236, -164.38710844893717, -25.814447545013195)\n",
      "(-839.5007336801783, -256.98854107588943, -25.814447545013195)\n",
      "(-439.5007336801783, -208.3266401493047, 22.847453381571427)\n",
      "(-817.6802083877388, -528.4704889831863, 22.847453381571427)\n",
      "(-1087.9428272138744, -728.4704889831863, -26.5154881177981)\n",
      "(-1034.6698839837302, -675.197545753042, -26.5154881177981)\n",
      "(-606.3716392839157, -375.19754575304205, 11.116168111793286)\n",
      "(-690.8388327535935, -348.3561701188967, 11.116168111793286)\n",
      "(-990.8388327535935, -439.520890388838, -22.012926284469245)\n",
      "(-1188.2029480240801, -539.520890388838, -41.47589125422485)\n",
      "(-1088.2029480240801, -386.24794715869393, -26.775608928003635)\n",
      "(-995.601515397128, -413.0893227928393, -26.775608928003635)\n",
      "(-999.4030366576725, -613.0893227928393, 35.59273484240509)\n",
      "(-872.5616610235271, -513.0893227928393, 38.22861957191844)\n",
      "(-775.4576665632463, -544.283573032373, 38.22861957191844)\n",
      "(-575.4576665632463, -189.14395269841322, -24.13972419849017)\n",
      "(-475.45766656324633, -115.98532833255854, 22.58733257136555)\n",
      "(-363.7263812934686, -336.885005659325, 22.58733257136555)\n",
      "(-663.7263812934686, -432.55228776259537, -15.044323658225892)\n",
      "(-716.9993245236128, -513.0893227928398, -15.044323658225892)\n",
      "(-616.9993245236128, -466.36226602298404, 31.682733111630057)\n",
      "(-670.2722677537569, -439.0981742228837, 31.682733111630057)\n",
      "(-870.2722677537569, -372.22726861914623, -29.744605984446764)\n",
      "(-470.27226775375686, -239.0981742228837, -7.924080692007408)\n",
      "(-559.2420230567636, -199.7696848260759, -7.924080692007408)\n",
      "(-926.6110604602196, -899.769684826076, -86.08339869090946)\n",
      "(-926.6110604602196, -224.6560595948339, 6.5180339360422295)\n",
      "(-826.6110604602196, -217.2574922217857, 13.916601309090538)\n",
      "(-668.5754345865408, -117.2574922217857, 33.379566278846255)\n",
      "(-665.9395498570275, -17.257492221785697, 36.015451008359605)\n",
      "(-465.9395498570275, -79.62583599219425, 32.105449277584626)\n",
      "(-665.9395498570275, -306.4672116263396, 36.015451008359605)\n",
      "(-465.9395498570275, -234.7654563261541, 32.105449277584626)\n",
      "(-519.2124930871717, -199.06864425329172, 32.105449277584626)\n",
      "(-812.7549303884553, 0.9313557467082774, 27.772731380854907)\n",
      "(-712.7549303884553, -161.43698802370034, -64.07287275321232)\n",
      "(-812.7549303884553, -453.28259215776757, 27.772731380854907)\n",
      "(-1012.7549303884553, -199.06864425329172, 32.10544927758451)\n",
      "(-936.7204571915402, -288.0383995562985, 32.10544927758451)\n",
      "(-874.3521134211317, -488.0383995562985, 10.006599578315445)\n",
      "(-774.3521134211317, -346.9795411508029, 39.33417271403346)\n"
     ]
    }
   ],
   "source": [
    "path = stochastic_hamiltonian(graph)\n",
    "#durs = tuple(round(y[0]-x[0], 2) for (x, y) in pairwise(target_melody_data)) + ((1,))\n",
    "durs = tuple(d[0] for d in target_melody_data)\n",
    "path_to_chords(path, root)\n",
    "write_chord_sequence(list(zip(durs, path_to_chords(path, root))))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (compact sets)",
   "language": "python",
   "name": "compact_sets"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}