final.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#########\n",
    "# IMPORTS\n",
    "#########\n",
    "import random as rand\n",
    "import tensorflow as tf\n",
    "import networkx as nx\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import time\n",
    "import pickle\n",
    "from tsp_solver.greedy import solve_tsp as solve\n",
    "from graph_nets import utils_tf\n",
    "from graph_nets import utils_np\n",
    "from graph_nets.demos import models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#########\n",
    "# UTILS\n",
    "#########\n",
    "\n",
    "def create_random_graph(node_range=(5, 9), prob=0.25, weight_range=(1, 10)):\n",
    "    '''\n",
    "    This function generates a Hamiltonian graph by generating a complete graph\n",
    "    with random initial weights.\n",
    "    '''\n",
    "    n_nodes = rand.randint(*node_range)\n",
    "\n",
    "    G = nx.complete_graph(n_nodes)\n",
    "    H = G.copy()\n",
    "    for u, v, w in G.edges(data=True):\n",
    "        H[u][v][\"weight\"] = rand.randint(*weight_range)\n",
    "\n",
    "    return H\n",
    "\n",
    "def solve_tsp(graph):\n",
    "    '''\n",
    "    This function solves the TSP problem in a graph with a TSP solver from third-party library\n",
    "    '''\n",
    "    adj_matrix = nx.adjacency_matrix(graph)\n",
    "    hamil_path = solve(adj_matrix.todense().tolist())\n",
    "\n",
    "    path_edges = [(hamil_path[i], hamil_path[i + 1])\n",
    "                  for i in range(len(hamil_path) - 1)]\n",
    "    path_edges.append((hamil_path[-1], hamil_path[0]))\n",
    "\n",
    "    for u, v in graph.edges():\n",
    "        graph[u][v][\"solution\"] = int(\n",
    "            any({u, v}.issubset({src, targ}) for src, targ in path_edges))\n",
    "\n",
    "    solution_dict = {v: False for v in graph.nodes()}\n",
    "    for u, v in path_edges:\n",
    "        solution_dict[u] = True\n",
    "        solution_dict[v] = True\n",
    "\n",
    "    nx.set_node_attributes(graph, solution_dict, \"solution\")\n",
    "\n",
    "    return graph\n",
    "\n",
    "def to_one_hot(indices, max_value, axis=-1):\n",
    "    '''\n",
    "    pad a one hot vector\n",
    "    '''\n",
    "    one_hot = np.eye(max_value)[indices]\n",
    "    if axis not in (-1, one_hot.ndim):\n",
    "        one_hot = np.moveaxis(one_hot, -1, axis)\n",
    "\n",
    "    return one_hot\n",
    "\n",
    "def graph_to_input_target(graph):\n",
    "    '''\n",
    "    from a Hamiltonian graph that contains all information,\n",
    "    this function generates an input graph and a target graph\n",
    "    with the necessary information encoded in each graph.\n",
    "    '''\n",
    "    def create_feature(attr, fields):\n",
    "        return np.hstack([np.array(attr[field], dtype=float) for field in fields])\n",
    "\n",
    "    # feature fields\n",
    "    input_node_fields = (\"solution\",)\n",
    "    input_edge_fields = (\"weight\",)\n",
    "    target_node_fields = (\"solution\",)\n",
    "    target_edge_fields = (\"solution\",)\n",
    "\n",
    "    input_graph = graph.copy()\n",
    "    target_graph = graph.copy()\n",
    "\n",
    "    # Generate Node Features\n",
    "    solution_length = 0\n",
    "    for node_index, node_feature in graph.nodes(data=True):\n",
    "        input_graph.add_node(\n",
    "            node_index, features=create_feature(node_feature, input_node_fields))\n",
    "        target_node = to_one_hot(\n",
    "            create_feature(node_feature, target_node_fields).astype(int), 2)[0]\n",
    "        target_graph.add_node(node_index, features=target_node)\n",
    "\n",
    "    # Generate Edge Features\n",
    "    for receiver, sender, features in graph.edges(data=True):\n",
    "        input_graph.add_edge(\n",
    "            sender, receiver, features=create_feature(features, input_edge_fields))\n",
    "        target_edge = to_one_hot(\n",
    "            create_feature(features, target_edge_fields).astype(int), 2)[0]\n",
    "        target_graph.add_edge(sender, receiver, features=target_edge)\n",
    "        solution_length += features[\"weight\"] * features[\"solution\"]\n",
    "\n",
    "    input_graph.graph[\"features\"] = np.array([0.0])\n",
    "    target_graph.graph[\"features\"] = np.array([solution_length], dtype=float)\n",
    "\n",
    "    return input_graph, target_graph\n",
    "\n",
    "def generate_networkx_graphs(num_graphs, node_range=(5, 9), prob=0.25, weight_range=(1, 10)):\n",
    "    '''\n",
    "    generate_nx_graphs wraps up the previous functions\n",
    "    and serves as a helper function to conveniently\n",
    "    generates graphs for training/testing\n",
    "    '''\n",
    "    input_graphs = []\n",
    "    target_graphs = []\n",
    "    graphs = []\n",
    "\n",
    "    for i in range(num_graphs):\n",
    "        graph = create_random_graph(node_range, prob, weight_range)\n",
    "        graph = solve_tsp(graph)\n",
    "        input_graph, target_graph = graph_to_input_target(graph)\n",
    "        input_graphs.append(input_graph)\n",
    "        target_graphs.append(target_graph)\n",
    "        graphs.append(graph)\n",
    "\n",
    "    return input_graphs, target_graphs, graphs\n",
    "\n",
    "\n",
    "#########\n",
    "# EXPORTS\n",
    "#########\n",
    "\n",
    "def create_placeholders(num_graphs):\n",
    "    '''\n",
    "    Create a placeholder for feeding graphs to the NN uses API\n",
    "    provided by deepming GNN library to do that\n",
    "    '''\n",
    "    input_graphs, target_graphs, _ = generate_networkx_graphs(num_graphs)\n",
    "    input_ph = utils_tf.placeholders_from_networkxs(input_graphs)\n",
    "    target_ph = utils_tf.placeholders_from_networkxs(target_graphs)\n",
    "    return input_ph, target_ph\n",
    "\n",
    "def make_all_runnable_in_session(*args):\n",
    "    '''\n",
    "    Lets an iterable of TF graphs be output from a session as NP graphs.\n",
    "    '''\n",
    "    return [utils_tf.make_runnable_in_session(a) for a in args]\n",
    "\n",
    "def create_feed_dict(num_graphs, input_ph, target_ph):\n",
    "    '''\n",
    "    Creates placeholders for the model training and evaluation.\n",
    "    '''\n",
    "\n",
    "    inputs, targets, raw_graphs = generate_networkx_graphs(num_graphs)\n",
    "    input_graphs = utils_np.networkxs_to_graphs_tuple(inputs)\n",
    "    target_graphs = utils_np.networkxs_to_graphs_tuple(targets)\n",
    "    feed_dict = {input_ph: input_graphs, target_ph: target_graphs}\n",
    "\n",
    "    return feed_dict, inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#########\n",
    "# TRAINING_HELPER (THAT CAN BE TUNED)\n",
    "#########\n",
    "\n",
    "def create_loss_ops(target_op, output_ops):\n",
    "    '''\n",
    "    use edge information for computing losses\n",
    "    '''\n",
    "    return [\n",
    "        tf.losses.softmax_cross_entropy(target_op.edges, output_op.edges)\n",
    "        for output_op in output_ops\n",
    "    ]\n",
    "\n",
    "def compute_accuracy(target, output, use_nodes=True, use_edges=False):\n",
    "    '''\n",
    "    Compute classification accuracy\n",
    "    '''\n",
    "    if not use_nodes and not use_edges:\n",
    "        raise ValueError(\"Nodes or edges (or both) must be used\")\n",
    "\n",
    "    tdds = utils_np.graphs_tuple_to_data_dicts(target)\n",
    "    odds = utils_np.graphs_tuple_to_data_dicts(output)\n",
    "\n",
    "    cs, ss = [], []\n",
    "    for td, od in zip(tdds, odds):\n",
    "\n",
    "        xe = np.argmax(td[\"edges\"], axis=-1)\n",
    "        ye = np.argmax(od[\"edges\"], axis=-1)\n",
    "\n",
    "        c = [xe == ye] if use_edges else []\n",
    "        c = np.concatenate(c, axis=0)\n",
    "\n",
    "        s = np.all(c)\n",
    "        cs.append(c)\n",
    "        ss.append(s)\n",
    "\n",
    "    correct = np.mean(np.concatenate(cs, axis=0))\n",
    "    solved = np.mean(np.stack(ss))\n",
    "\n",
    "    return correct, solved"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/roger/Library/Python/3.7/lib/python/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From /Users/roger/Library/Python/3.7/lib/python/site-packages/tensorflow/python/ops/losses/losses_impl.py:209: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "WARNING:tensorflow:From /Users/roger/Library/Python/3.7/lib/python/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/roger/Library/Python/3.7/lib/python/site-packages/tensorflow/python/ops/gradients_impl.py:110: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.\n",
      "  \"Converting sparse IndexedSlices to a dense Tensor of unknown shape. \"\n"
     ]
    }
   ],
   "source": [
    "#########\n",
    "# MODEL AND HYPERPARAMETERS SETUP\n",
    "#########\n",
    "tf.reset_default_graph()\n",
    "\n",
    "seed = 2\n",
    "rand = np.random.RandomState(seed=seed)\n",
    "\n",
    "# Model parameters; no. of message-passing steps\n",
    "num_processing_steps_tr = 10\n",
    "num_processing_steps_ge = 10\n",
    "\n",
    "# Data / training parameters\n",
    "num_training_iterations = 2000\n",
    "batch_size_tr = 200\n",
    "batch_size_ge = 1000\n",
    "\n",
    "# Input and target placeholders\n",
    "input_ph, target_ph = create_placeholders(batch_size_tr)\n",
    "\n",
    "# Connect the data to the model and instantiate\n",
    "model = models.EncodeProcessDecode(edge_output_size=2, node_output_size=2)\n",
    "# A list of outputs, one per processing step\n",
    "output_ops_tr = model(input_ph, num_processing_steps_tr)\n",
    "output_ops_ge = model(input_ph, num_processing_steps_ge)\n",
    "\n",
    "# Training loss\n",
    "loss_ops_tr = create_loss_ops(target_ph, output_ops_tr)\n",
    "# Loss across processing steps\n",
    "loss_op_tr = sum(loss_ops_tr) / num_processing_steps_tr\n",
    "# Test/generalization loss\n",
    "loss_ops_ge = create_loss_ops(target_ph, output_ops_ge)\n",
    "loss_op_ge = loss_ops_ge[-1]  # Loss from final processing step\n",
    "\n",
    "# Optimizer\n",
    "learning_rate = 1.3e-3\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate)\n",
    "step_op = optimizer.minimize(loss_op_tr)\n",
    "\n",
    "# Lets an iterable of TF graphs be output from a session as NP graphs\n",
    "input_ph, target_ph = make_all_runnable_in_session(input_ph, target_ph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#########\n",
    "# RESET SESSION\n",
    "#########\n",
    "try:\n",
    "    sess.close()\n",
    "except NameError:\n",
    "    pass\n",
    "\n",
    "sess = tf.Session()\n",
    "sess.run(tf.global_variables_initializer())\n",
    "\n",
    "last_iteration = 0\n",
    "logged_iterations = []\n",
    "losses_tr = []\n",
    "corrects_tr = []\n",
    "solveds_tr = []\n",
    "losses_ge = []\n",
    "corrects_ge = []\n",
    "solveds_ge = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/roger/Library/Python/3.7/lib/python/site-packages/tensorflow/python/training/saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from data/pickles/model.ckpt\n",
      "USING MODEL FOUND ON LOCAL STORAGE\n"
     ]
    }
   ],
   "source": [
    "#########\n",
    "# TRY TO RESTORE THE MODEL\n",
    "#########\n",
    "restored_model_flag = False\n",
    "try:\n",
    "    saver = tf.train.Saver()\n",
    "    saver.restore(sess, \"data/pickles/model.ckpt\")\n",
    "    restored_model_flag = True\n",
    "    print(\"USING MODEL FOUND ON LOCAL STORAGE\")\n",
    "except ValueError:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# (iteration number), T (elapsed seconds), Ltr (training loss), Lge (test/generalization loss), Ctr (training fraction nodes/edges labeled correctly), Str (training fraction examples solved correctly), Cge (test/generalization fraction nodes/edges labeled correctly), Sge (test/generalization fraction examples solved correctly)\n",
      "# 00031, T 22.8, Ltr 0.3386, Lge 0.3058, Ctr 0.8754, Str 0.1900, Cge 0.8704, Sge 0.1280\n",
      "Breaking...\n"
     ]
    }
   ],
   "source": [
    "#########\n",
    "# TRAINING\n",
    "#########\n",
    "# How much time between logging and printing the current results.\n",
    "log_every_seconds = 20\n",
    "\n",
    "print(\"# (iteration number), T (elapsed seconds), \"\n",
    "      \"Ltr (training loss), Lge (test/generalization loss), \"\n",
    "      \"Ctr (training fraction nodes/edges labeled correctly), \"\n",
    "      \"Str (training fraction examples solved correctly), \"\n",
    "      \"Cge (test/generalization fraction nodes/edges labeled correctly), \"\n",
    "      \"Sge (test/generalization fraction examples solved correctly)\")\n",
    "\n",
    "start_time = time.time()\n",
    "last_log_time = start_time\n",
    "for iteration in range(last_iteration, num_training_iterations):\n",
    "    last_iteration = iteration\n",
    "\n",
    "    feed_dict, _ = create_feed_dict(batch_size_tr, input_ph, target_ph)\n",
    "    train_values = sess.run({\n",
    "        \"step\": step_op,\n",
    "        \"target\": target_ph,\n",
    "        \"loss\": loss_op_tr,\n",
    "        \"outputs\": output_ops_tr\n",
    "    }, feed_dict=feed_dict)\n",
    "\n",
    "    the_time = time.time()\n",
    "    elapsed_since_last_log = the_time - last_log_time\n",
    "\n",
    "    if elapsed_since_last_log > log_every_seconds:\n",
    "        last_log_time = the_time\n",
    "\n",
    "        feed_dict, raw_graphs = create_feed_dict(\n",
    "            batch_size_ge, input_ph, target_ph)\n",
    "        test_values = sess.run({\n",
    "            \"target\": target_ph,\n",
    "            \"loss\": loss_op_ge,\n",
    "            \"outputs\": output_ops_ge\n",
    "        }, feed_dict=feed_dict)\n",
    "\n",
    "        correct_tr, solved_tr = compute_accuracy(\n",
    "            train_values[\"target\"], train_values[\"outputs\"][-1], use_edges=True)\n",
    "        correct_ge, solved_ge = compute_accuracy(\n",
    "            test_values[\"target\"], test_values[\"outputs\"][-1], use_edges=True)\n",
    "\n",
    "        elapsed = time.time() - start_time\n",
    "\n",
    "        losses_tr.append(train_values[\"loss\"])\n",
    "        corrects_tr.append(correct_tr)\n",
    "        solveds_tr.append(solved_tr)\n",
    "        losses_ge.append(test_values[\"loss\"])\n",
    "        corrects_ge.append(correct_ge)\n",
    "        solveds_ge.append(solved_ge)\n",
    "        logged_iterations.append(iteration)\n",
    "\n",
    "        print(\"# {:05d}, T {:.1f}, Ltr {:.4f}, Lge {:.4f}, Ctr {:.4f}, Str\"\n",
    "              \" {:.4f}, Cge {:.4f}, Sge {:.4f}\".format(\n",
    "                  iteration, elapsed, train_values[\"loss\"], test_values[\"loss\"],\n",
    "                  correct_tr, solved_tr, correct_ge, solved_ge))\n",
    "        if restored_model_flag and True: # change True to False to continue Training from last time\n",
    "            print(\"Breaking...\")\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#########\n",
    "# POST-TRAINING TESTING\n",
    "#########\n",
    "test_batch_size = 1000\n",
    "num_processing_steps_test = 10\n",
    "\n",
    "test_input_ph, test_target_ph = create_placeholders(test_batch_size)\n",
    "test_output_ops = model(test_input_ph, num_processing_steps_test)\n",
    "\n",
    "test_loss_ops = create_loss_ops(test_target_ph, test_output_ops)\n",
    "test_loss_op = test_loss_ops[-1]\n",
    "\n",
    "test_input_ph, test_target_ph = make_all_runnable_in_session(\n",
    "    test_input_ph, test_target_ph)\n",
    "\n",
    "test_feed_dict, test_input_graphs = create_feed_dict(\n",
    "    test_batch_size, test_input_ph, test_target_ph)\n",
    "test_values = sess.run({\n",
    "    \"target\": test_target_ph,\n",
    "    \"loss\": test_loss_op,\n",
    "    \"outputs\": test_output_ops\n",
    "}, feed_dict=test_feed_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#########\n",
    "# MODEL & RESULTS STORAGE\n",
    "#########\n",
    "\n",
    "output_graphs = utils_np.graphs_tuple_to_networkxs(test_values[\"outputs\"][-1])\n",
    "target_graphs = utils_np.graphs_tuple_to_networkxs(test_values[\"target\"])\n",
    "input_graphs = test_input_graphs\n",
    "\n",
    "training_stats = pd.DataFrame(np.array([logged_iterations, losses_tr, losses_ge,\n",
    "                                         corrects_tr, solveds_tr, corrects_ge, solveds_ge]).T,\n",
    "                               columns=[\"iteration\", \"loss_tr\", \"loss_ge\", \"correct_tr\", \"solved_tr\",\n",
    "                                        \"correct_ge\", \"solved_ge\"])\n",
    "\n",
    "if not restored_model_flag: # we dont want to mess with saved file if they are loaded\n",
    "    # Store the model\n",
    "    saver = tf.train.Saver()\n",
    "    saver.save(sess, \"data/pickles/model.ckpt\")\n",
    "\n",
    "    # Store the training statistics\n",
    "    training_stats.to_pickle(\"data/pickles/train_stats.pkl\")\n",
    "\n",
    "    # Store the test results\n",
    "    pickle.dump({\n",
    "        \"outputs\": output_graphs,\n",
    "        \"targets\": target_graphs,\n",
    "        \"inputs\": input_graphs,\n",
    "    }, open(\"data/pickles/test_results.pkl\", \"wb\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#########\n",
    "# EVAL HELPERS\n",
    "#########\n",
    "def is_solution_edge(feature_vector):\n",
    "    '''\n",
    "    Given a feature vector of an edge, determines if it's classified as solution\n",
    "    '''\n",
    "    # if it's solution, one hot vector is (0, 1)\n",
    "    if feature_vector[1] > feature_vector[0]: return True\n",
    "    return False\n",
    "\n",
    "def get_neighbor_dict(my_graph):\n",
    "    '''\n",
    "    return a dictionary with vertices as key each item contains its neighbor\n",
    "    vertices connected by the labelled edges\n",
    "    '''\n",
    "    ret_dict = {}\n",
    "    edge_list = [i for i in my_graph.edges(data = True)]\n",
    "    output_label_cnt = 0\n",
    "    for i in edge_list:\n",
    "        if is_solution_edge(i[2][\"features\"]):\n",
    "            try:\n",
    "                ret_dict[i[0]].append(i[1])\n",
    "            except KeyError:\n",
    "                ret_dict[i[0]] = [i[1]]\n",
    "            try:\n",
    "                ret_dict[i[1]].append(i[0])\n",
    "            except KeyError:\n",
    "                ret_dict[i[1]] = [i[0]]\n",
    "            output_label_cnt += 1\n",
    "    return ret_dict, output_label_cnt\n",
    "\n",
    "def hamiltonian_path_check(my_graph):\n",
    "    '''\n",
    "    Check if a the solution to a graph is Hamiltonian\n",
    "    '''\n",
    "    neighbor_dict, my_count = get_neighbor_dict(my_graph)\n",
    "    my_vertices = [i for i in my_graph.nodes()]\n",
    "    visited_dict = [False] * len(my_vertices)\n",
    "    # since hamiltonian path is closed; choose a random vertex to start\n",
    "    # actually nvm, maybe just use the first vertex...\n",
    "    start_vertex = my_vertices[0]\n",
    "    # test 1: every vertex is in the neighbor_dict\n",
    "    for v in my_vertices:\n",
    "        try:\n",
    "            neighbor_dict[v]\n",
    "        except KeyError:\n",
    "            return False, neighbor_dict, my_count\n",
    "    # test 2: every vertex connects to two and only two other vertices\n",
    "    for k, i in neighbor_dict.items():\n",
    "        if len(i) != 2: return False, neighbor_dict, my_count\n",
    "    # test 3: start from a node and perform the walk, we will end up at the same node\n",
    "    current_vertex = start_vertex\n",
    "    next_vertex = neighbor_dict[start_vertex][0]\n",
    "    while True:\n",
    "        visited_dict[current_vertex] = True\n",
    "        if next_vertex == start_vertex: break\n",
    "        if neighbor_dict[next_vertex][0] == current_vertex:\n",
    "            current_vertex = next_vertex\n",
    "            next_vertex = neighbor_dict[next_vertex][1]\n",
    "        else:\n",
    "            current_vertex = next_vertex\n",
    "            next_vertex = neighbor_dict[next_vertex][0]\n",
    "    for mark in visited_dict:\n",
    "        if mark == False: return False, neighbor_dict, my_count\n",
    "    return True, neighbor_dict, my_count\n",
    "\n",
    "def get_ori_weight(input_graph, u, v):\n",
    "    '''\n",
    "    Given the original graph and vertices u, v, return its original weights\n",
    "    '''\n",
    "    return input_graph.get_edge_data(u, v)[\"weight\"]\n",
    "\n",
    "def evaluate(input_graphs, output_graphs, target_graphs):\n",
    "    '''\n",
    "    Main Evaluate function that does all the job\n",
    "    '''\n",
    "    assert len(output_graphs) == len(target_graphs)\n",
    "    assert len(input_graphs) == len(output_graphs)\n",
    "    assert isinstance(output_graphs, list)\n",
    "    assert isinstance(target_graphs, list)\n",
    "\n",
    "    n_num = len(output_graphs)\n",
    "\n",
    "    # sort graph by correctly labelled edges\n",
    "    # seperate output into bad/average/good sets\n",
    "\n",
    "    is_hamiltonian_path_count = 0\n",
    "    recall_correct_count = 0\n",
    "    recall_total_count = 0\n",
    "    precision_total_count = 0\n",
    "\n",
    "    output_solution_len_list = []\n",
    "    target_solution_len_list = []\n",
    "\n",
    "    non_output_soln_len_list = []\n",
    "    non_target_soln_len_list = []\n",
    "\n",
    "    for i in range(len(output_graphs)):\n",
    "        ret, my_dict, my_count = hamiltonian_path_check(output_graphs[i])\n",
    "        precision_total_count += my_count\n",
    "        if ret:\n",
    "            is_hamiltonian_path_count += 1\n",
    "        # get output solution length\n",
    "        output_soln_len = 0\n",
    "        for u in my_dict.keys():\n",
    "            for v in my_dict[u]:\n",
    "                if u > v: continue\n",
    "                output_soln_len += get_ori_weight(input_graphs[i], u, v)\n",
    "        # get target solution length\n",
    "        tar_soln_len = 0\n",
    "        for e in input_graphs[i].edges(data = True):\n",
    "            if e[2][\"solution\"] == 1:\n",
    "                tar_soln_len += e[2][\"weight\"]\n",
    "                recall_total_count += 1\n",
    "                try:\n",
    "                    for neighboring_vertex in my_dict[e[0]]:\n",
    "                        if neighboring_vertex == e[1]:\n",
    "                            recall_correct_count += 1\n",
    "                            break\n",
    "                except KeyError:\n",
    "                    pass\n",
    "            output_solution_len_list.append(output_soln_len)\n",
    "            target_solution_len_list.append(tar_soln_len)\n",
    "            non_output_soln_len_list.append(output_soln_len)\n",
    "            non_target_soln_len_list.append(tar_soln_len)\n",
    "    # calculate difference between output and target graphs\n",
    "    print(\"{0} out of {1} solutions are Hamiltonian.\".format(is_hamiltonian_path_count, n_num))\n",
    "    output_solution_len_list = np.array(output_solution_len_list)\n",
    "    target_solution_len_list = np.array(target_solution_len_list)\n",
    "    diff_ = output_solution_len_list - target_solution_len_list\n",
    "    print(\"Among Hamiltonian cycles found by the GNN, the average difference in solution graph with ground truth is {0:.4f}\".format(np.mean(diff_)))\n",
    "    output_vec = np.array(non_output_soln_len_list)\n",
    "    target_vec = np.array(non_target_soln_len_list)\n",
    "    diff_ = output_vec - target_vec\n",
    "    print(\"Among those that were incorrectly labelled, the average error in solution length is {0:.4f}\".format(np.mean(diff_)))\n",
    "    total_weight = 0\n",
    "    for g in input_graphs:\n",
    "        for e in g.edges(data = True):\n",
    "            total_weight += e[2][\"weight\"]\n",
    "    average_weight = total_weight / n_num\n",
    "    print(\"On average, the total weight of each graph we used is {0:.4f}. So the average relative error is {1:.4f}\".format(average_weight, np.mean(diff_) / average_weight))\n",
    "    print(\"Recall: {0:.4f}\".format(recall_correct_count / recall_total_count))\n",
    "    print(\"Precision: {0:.4f}\".format(recall_correct_count / precision_total_count))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "132 out of 1000 solutions are Hamiltonian.\n",
      "Among Hamiltonian cycles found by the GNN, the average difference in solution graph with ground truth is 4.2062\n",
      "Among those that were incorrectly labelled, the average error in solution length is 4.2062\n",
      "On average, the total weight of each graph we used is 92.3800. So the average relative error is 0.0455\n",
      "Recall: 0.7407\n",
      "Precision: 0.8405\n"
     ]
    }
   ],
   "source": [
    "evaluate(input_graphs, output_graphs, target_graphs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApkAAAFNCAYAAABL6HT2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3XeYVdXVx/HvGroICGLFAkZjQ2OLGn1VjA2NmmLDrq+GGFs0iTW+GmvUqFhiooLGFls0GozYRWNXFLE3sKEgIKA0abPeP9Y5nnPv3Jm5c6fB8Ps8z33OOfu0fWdQFnvvtbe5OyIiIiIiTamqtSsgIiIiIm2PgkwRERERaXIKMkVERESkySnIFBEREZEmpyBTRERERJqcgkwRERERaXIKMkVksWJmT5rZkcn+gWb2SDO843QzG9bUz20JZvaWmQ2o4L5m+VmKyJJLQaaIYGaDzOxFM5tlZpOS/aPNzFq7bnVx93+4+86NeYaZDTCz8UXPvcDdj2xc7Uq+q6OZXWpm481sppl9bGaX585/bGY7NuB5N5rZefkyd1/f3Z+s576+ZuZm1j53X6N/liIieQoyRZZwZvY74Argz8CKwArAUcDWQMcWrkv7+q9arJ0GbAZsDnQDBgCvtmaFRESai4JMkSWYmfUAzgGOdve73X2Gh9HufqC7z02u62Rml5jZp2b2pZldY2ZdknMDkpa53yWtoBPM7PDcO8q59xQzmwj83cx6mtl/zGyymU1L9leppf6Hmdkzyf7JSetg+plvZjcm5w43s3fMbIaZjTOzXyXlXYEHgZVz961sZn80s1tz79kz6YaennTXr5s797GZ/d7MXjezr83sTjPrXMuP/IfAve7+RfJz/tjdb06ecwuwGnB/Uo+Tk/J/mtnE5Nn/NbP1k/LBwIFA+r3vz9Vnx2R/czMbZWbfJD/7y5J6/DfZTk/u/VH+Z5ncu76ZPWpmU5N7T6/nmSIiBRRkiizZfgR0Av5dz3UXAt8HNgLWBPoAZ+bOrwj0SMqPAK42s54NuLcXsDowmPj/0t+T49WAOcBf6vsi7n6xuy/t7ksD6wKTgTuT05OA3YHuwOHAEDPbxN1nAbsCX6T3uvsX+eea2feB24ETgOWAEUQgmG/l3RcYCPQDNgQOq6WaLwC/TYYibJAfjuDuBwOfAnsk9bg4OfUgsBawPNHq+Y/k+uuS/fR771HifVcAV7h7d+B7wF1J+bbJdpnk3ueLvnM34DHgIWBl4vf2eD3PFBEpoCBTZMnWG5ji7gvSAjN7Lmmxm2Nm2yaB0GDgRHef6u4zgAuAQbnnzAfOcff57j4CmAmsXea91cBZ7j7X3ee4+1fufo+7z06uPx/YrtwvlLSS3kcEQg8CuPsD7j42aT18CngE2KbMR+4HPODuj7r7fOASoAuwVe6aK5PWyanA/URAXcqfgIuIFshRwOdmdmhdL3f3G5IW5rnAH4EfJC3Q5ZgPrGlmvd19pru/UOZ9uwMT3f1Sd/82ef+LjXymiCxhFGSKLNm+AnoXJYBs5e7LJOeqiNa7pYBXkuBzOtHCtVz+OflAFZgNLF3mvZPd/dv0wMyWMrNrzewTM/uG6Npdxszalfmdrgfec/eLcs/c1cxeSLp+pwO7EQF2OVYGPkkP3L0a+IxokU1NzO2n370Gd1/o7le7+9bAMkQAfUO++z3PzNqZ2YVmNjb5WXycnCq37kcQrcjvmtnLZrZ7mfetCoxt4meKyBJGQabIku15YC7w0zqumUJ0Wa/v7ssknx5Jt3R9yrnXi+75HbA2sEXSJZt27dab6W5mpxIB0BG5sk7APUQL5ApJAD0i97zi9xf7gui6T59nRBD2eX31qUvSans1MA1Yr5a6HED8bnYkhiP0TatRy/XF7/jA3fcnutovAu5OxqHW950/A9Zo4DNFRAooyBRZgrn7dOBs4K9mtreZdTOzKjPbCOiaXFMNDCXGMS4PYGZ9zGyXMp5fyb3diMB0upn1As4q57uY2a7A8cDP3X1O7lRHYtzpZGBBcl1+qp4vgWXr6IK+C/iJme1gZh2IIHgu8Fw59Sqq4wkWyU5dzKx90lXeDRidq0s+uOuWvOsrokX4gqJHFl9f/L6DzGy55PcwPSmuJn4W1XXc+x9gpaS+nZI/F1vU80wRkQIKMkWWcEmCyW+Bk4mg5UvgWuAUskDqFOBD4IWk2/YxorWxHA2993JizOMUIlHmoTLfsx/RDf+OZZni1yTjOo8ngsVpROvg8PQmd3+XSOwZl3Tpr5x/qLu/BxwEXJXUaQ8iOWdemfXKmw1cSnSvTwGOAfZy93HJ+T8BZyT1+D1wM9FV/znwNvHzyLseWC+5/r4S7xsIvGVmM4mEnUFJC+psoqv+2eTeLYu+8wxgp+S7TgQ+ALav65kV/CxEpI0z9/p6TUREREREGkYtmSIiIiLS5BRkioiIiEiTU5ApIiIiIk1OQaaIiIiINDkFmSIiIiLS5NrXf8nioaqqyrt06dLa1RARERGp1+zZs93d23RjX5sJMrt06cKsWbNauxoiIiIi9TKzNj+/bJuOoEVERESkdSjIFBEREZEmpyBTRERERJqcgkwRERERaXIKMkVERESkySnIFBEREZEmpyBTRERERJqcgkwRERERaXIKMkVERESkySnILJM73HILPPdca9dERERECsyaBU891dq1kCIKMstkBr/5TQSaIiIibcrFF8dfdHNaeKXD116Dhx6q/7oTT4Qjj6z9/P77w4ABMHlyVvbOOzB7dqOrKJVTkNkAffvCJ5+0di1EREQaaM4c+NWvYMIEOPts2Hhj2H13+PLLOH/BBbGdNq356zJiBHz6aexvvDHsumt2btYsuPDCLDj8+msYNgwuvxyuv772Z95/f2wnTszuW289OPTQwuvuvRe22QY++yzeO2VK03wnKUlBZgOsvrqCTBERWQzdey9cdx2svDL88Y/RgvjAA3DQQXF+3rzYfv11/c/6n/+Bv/8dJk2CjTaCv/0Nvv0W3nuv7vsWLID99oOf/CT+Qp0/Pzu3cGFsjzgCTjsN/v3vCDhPPBF++cvSz/v00yxYTX35ZTxr4MA4vvvuwvO/+AU88wzcfnu0oJbTiioVU5DZAKuvDh9/HOMzRUREapg2DWbObPrnvvACPP987M+YAY89VvOaGTOyYLFcb7wRAVfaTX7jjfDww7VfP3s2PPtsBGdvvgljxsDRR8O558I668A998D778N//wuXXJLdd+65sO66cNddWdkee2T7kyZFK+udd8bxAQfA0kvHX7qlTJkSfymvvjrsvXdW/umnEUi+8EJWNndutt+uXWz/+9/Y5q+TJqcgswH69o3/vr76qrVrIiIii6RevSKYKseCBaWDqIkTozs370c/gq22iv1hw2CnnWD8+MJruncv7HrOy49N7NUr2//yywjoUhdfHK2ApVpTFi7Mxjy+807hX4YffRTbvfeGtdeG7baDk06C6uooP/NM+PDD7PpttikMZm+8sXTSQ/FfuKedBv/6F+yyS1Z2zz3Z/pVXwvDhsb/00rE966zs+7RvH9s0Sag4yHzttQiSFxFmNtDM3jOzD83s1BLnVzOzkWY22sxeN7PdkvIDzey13KfazDZKzj2ZPDM9t3xz1V9BZgOsvnps1WUuIrKEqK3ravRo6NevsLUuVRz81WbnneMZxYHOSivBaqvBW29FN/Rf/lJ4fuzY2B55ZHSB/+Mf8M03UfbEE3DrrTXflR97uO229dft9dejdfGSSyJwffbZCND69o3z779fmGRTW+vtNdfEtmfPwvJ//rPw+PTT4ZRTStcj78ILYa+94NVXC8v79In6jRmTlf3737G96KIIHhcsiE++vmPGZAH444/HGNG1145W2lZmZu2Aq4FdgfWA/c1svaLLzgDucveNgUHAXwHc/R/uvpG7bwQcDHzk7q/l7jswPe/uk5rrOyjIbIA0yKyt9V5ERNqIefNg002hqgp++9soe/VVePDB2H/uufjL4JpropsasgCmNum4w9TIkbG97DJ4990Yq5gPvvr3h3POgeOOK7wvbel4+OFI5jnooMIu44MPjncdeGBkXR96KHzxRXb+Jz+p9+vzxz/CCitEa+RDD8U4zLy5c+GYY7LjN94o/ZxjjomfT/fucMghEbS7x7NvuQWuuqrw+uWWq/mM5ZcvbG0tpUsX6N27sOyHP8z2//a36CLP/w6qquJ39uSTcXz66dm5nXfOWmFbz+bAh+4+zt3nAXcAPy26xoHuyX4P4Atq2j+5t+W5e5v4LLXUUt7cvvoq/uu49NJmf5WIyJLn4Yfdt9rKfc6c1q6J+yefpOFQfNwL908/PfY7dMjKzzij8Jq8l1+O8s02cx861H3BgsLnpx+zwuMuXQqPv/3WfYMN6r/vt78tPN5ww2x/5szS767ts+KK5V235Zbu229fs/yDD9yXWcb9uONK/6yHDs2u3WSTmvdfcEH82Sj1zhtvjO1aa7nff39Wfvrphb+z9FNV5f6LX8T+Lru49+uXlee/60EHNf2fqSLALK8jrgH2Bobljg8G/lJ0zUrAG8B4YBqwaYnnjAX6546fTO55Dfg/wOqqR2M+aslsgJ49Y4iHustFRCrkHt2io0fXPLfLLtFC+PnnTfe+2bOzFqmZM2uO8bv//pga58UXo8XQk+7xb7/Nrqmqgpdeyo4XLMhaBvMZ0uedl+2bRQtZ+u50+p1RoyJbura/SNL3p4rnrezcufS9xfdddlnh8euvRzf8669D166l313s9ttjuqEvvoANN6z/+j59CpN5UhMnRnd+9+41z0F0+w8YEPurrgq33VY4DGH55bM6F7dWpsdVVYXjNM8/P7b53w/E9zjsMOjYMVprjzgiytPf04knwvHH1/z5NY/2ZjYq9xlcwTP2B25091WA3YBbzOy72M7MtgBmu3u+//9Ad98A2Cb5HNyI71AnBZkNYAZrrbVIDNUQEVk8TZmSJZfk5YOkXXap2Y0K0W1tBiecEMdz5hRmDi9cGEFjt27R/bxwYQQnRx0V5/v3rxmk7LlnBDkDB8bYx48+imlvrr46u6a6GrbYIjueMKGw+xlgmWVq1veSS+Kdxx8PjzxSeO5736t5fRqEbbJJbPNjK3/+82w/HX/ZUDvsABtsEPsrrFA4h+Q770QAm/c//xPjMc0iOK5Nt26xXXZZGDSo5vlx4+Jn2KNH7c9Ik5H69o0u/t/9Lt4LEWT27x8B4n33RZDdrRvsu2+8EyLI7NCh5nPTRJ/UD34QgfCcObDllnGc178/XHFF6W77prfA3TfLfa4rOv85sGrueJWkLO8I4C4Ad38e6Azk/5APAm7P3+DunyfbGcBtRLd8s1CQ2UADBsT455ZeFEFEZLHy3HPZdDQQf3n/8IdZ1nR+qp2FC2P+xNTYsYXj41JDhsT2iitiDGDv3hH8zZoVwc2uu0bQOHNmZHjfe29cP3RoBDlpC+CkSTXnT5w+PbbPPw/77BNZyrX57LOara1Tp8LgooaoBx6I4O2qqyLQqsuwYVkr4NlnR2vpgQfCiitGWXHG+uGHl37Os8/GmMxUPljKB8oTJ0ZG9xtvRKb1OuvUDDJXXjnbzwdwCxfC009nx6usEtvevaO19PHH43i33WKbZmvXFWSmiTjrr5+VpdMNLbdc3DtmDGy9dSRFffNN/Pnq0iWuqUrCmXHjarb0HnNM/Hn685+zFsr0+uIW2lVXZRHyMrCWmfUzs45EwDi86JpPgR0AzGxdIsicnBxXAfuSG49pZu3NrHey3wHYHWi+prPm6odv6U9LjMl0d//3v2O4xnPPtcjrRERaxsiR7kcdVdm96Ri/oUMLj8H9hRfcp07Nju+7L7YrrJDd/+67pcfb3Xef+8UXu7//vvv06aWvAff27UuXb7FFtp8fr5eOo5w0yX311Wt/bm2fX/4ytlttFdvll4/vsXCh+5/+VHht9+7uhx8e36P4Offc4z5rlvvXX8f9X3zhftpp7vPmZT+bgw6Ka6+4ovDel15ynz+/5jMnT4770uPqavf99ov9N96o+/e48sqFzyq22mqF5RMmuE+c6L7nnlH+2mtRXl3tfvXV7lOmxFjRffaJ87ffXvu70zGjTz+dlXXqFGVjx9Z+37x58f1Gj677u9XlxRfdhw93/8EPWnQ8MPWMyYxL2A14nxhX+Yek7Bxgz2R/PeBZYAwxxnLn3L0DgBeKntcVeAV4HXgLuAJoV189Kv20SkDYHJ+WCjJfeil+asOHt8jrRGRJsXBhJHU0pWnT4i/8cqSBxezZDXvH7Nnuxx8f9/br5/7ggzUDn802y/YvuyzbHzYsnnHvvTXvaYnPr39deLzttjWvGTCg8Lhbt2w7eXIk2Hz2WfbzeO+9wuu32KLmzxjcDzmk/J/vo49GotBFF2X3f/ll4TMff9z96KOz3/fIke6XXx771dURpNdnzTXjWTfckAWreVOnun/8cc3yiRPdn3229DNXWy1LphkxovZ3n3deXPPVV1lZGsR/8039dV8MlRNkLu6fVq9AU31aKsgcOzZ+ajfe2CKvE5ElxeDB/l3LU1P4+ON43pVXlnd9Gqz89rcR8Jby9dfR+peXtlKB+zrr1MxqLv6krV75FrkLLqj7nvynXbts/+KL3X/4w9LX9exZ/jNPPDG+28KF7r/7XeG54kzuYcNi27Vr6Z9RcdZ4Pks5LZs8ubC1siEGDSr8c5I+s7bfWUOkrYkPP9z4Z6WOPTar48sv137dwoU1g8kpU9wfeqjp6rKIWRKCTI3JbKB0bLJW/RGRWrnHmL/ieRHrcl0y5r+2taNffx3efjuSWIpXgynlxRdj++ijsX3nnfjMmxdj3IYMiUm83eN8x46xveyy0ksW3nlnjIvLj+tzz1ZOgRjTl0/EKWV40ZCyESOiXuW6775s/6STal8CcaWVYlsqwaZYjx6RdFNVFavDnHVWdm7PPWN7xRUxxnPQoEhIyWeS56XjCFNrrVXzmt69SyeplOPmm2PpyjQpJlXVBH+dL7VUbIvHZjZGmnS14opZQlMpVVVZAlFq2WULM8ZlsaMgs4HS/w9NndraNRGR78yfH9PP5Jeta0333hvJI3/+c+3XXHEFvPxydpwGefms5UceiWX05s+PLNj114drr43EhyefhFNPzSYAv/TSCHCqq+PnkAaiq60W2112gfXWi1VQpkyJTO2DDoqs4S23LEzE+c9/CuvqHhnSENnX6Yoz48ZFEk3+ug8+yOpTn3XXjSC13CDzf/4nyyZO9exZczWZ5ZbLEmY23rj0c9ZeOzvOT63TrVtMbZM688xY2eb44+FnP4ts9YULswz3Ut54I4Lpiy6KzPXUu+/CM8/U+RXr1aFD6Uz2ppBOE5Sfvqmx1l8/Vi56+eWmCYRl8dLaTalN9Wmp7nJ39969Kx8fLyLN4D//ie64vfZqnudXV8fk3OW69dbC+lRXu7/9dnTLzpzpPndu1oWY6tUrjocOja7uQw4p7Hat7fPYY3F/mvxywAGx3Xrr2B5/fHRFptfvumvh/b/5Tc1nbr554fe55BL/rls57TL+5z+zLv58F3mPHu4HHxz31VbnM86I80ceWf/3O+yw2J5zTvZzLP7ZffVVDAuASN6YOtX90EPj+Kij3Dt3jv0//cn9iSey5I6jjoryq66q+TssfseiqinrmY6nnTixaZ4ndWIJ6C5vX28UKjX06qWWTJFFStoS1lxz2511Fpx7brQQPvJILHH30EPRNXzIITWvT1sX77kn9q+6KluacJVVYPfda96z9NLxP5Zf/rJhdXv//ehCbt8+3nXbbVH+7LOxvfLKbHoeyJZFTBV3X0N0zc+aFfMQPvpoNqH1r34V80fmW+cg5r1cZplo9fv662h9LeXII+GOO7KJt+vryt5pJ/j73+OTKtWK16tX/EyPPz5aa3v2jAm3b7opus3/+98IxTYvmg4wbbmbNavueizKXnml6f5CGjgwGz4h0gSate3azAaa2Xtm9qGZnVrLNfua2dtm9paZ3ZYrP9TMPkg+hzZnPRtq2WU1JlNkkTJmTGy7dInAryFjIfMeeSTmC5wzJ54xZkwEiueeG+cHDoSjj44u60GDYjLr/OoMzz4bAWj+fxDXXls4EXd1ddbdDFm39tJLV1bnCy+MScTr6uK8+ebC49/+Nuu2/eijmtd/+23UZ8SICDD79Yu5B9deu7BbHWLMYbt2sNdecdy5c805HSdOjOEB114b61jvsEOU77xzbAcOjJ9JflWdu+6Krv1iaZCZDgNIrbpqDDlIu9MHDIjn/f73MT9ncYAJsOaasU0H2+cVTxa/qNpkE9hxx9auhUhpzdVECrQj5nVaA+hIzOG0XtE1awGjgZ7J8fLJthcwLtn2TPZ71vW+luwu/8lP3DfeuMVeJyJ5Tz0VGbx5P/5xYdfqz39eeH7ffd1vuqmwbMKEmKdw8uTIYr3rrmwd4912q7sLN5/RnHa1jhxZ+tqf/MR9992z46OPdh8ypPCaG25wX3fdut/ZlJ/0O6fH+QzqV1/N5kNMP488kv3c8uXXXOM+fnx27s9/jjkHU4895n7CCXX/PufPLzwup/t32DD3ceNqlt93X6yTXa6FC91vu63mn6f0XKlykSbCEtBd3nwPhh8BD+eOTwNOK7rmYuDIEvfuD1ybO74W2L+u97VkkHnIITF/r4i0sKeeiv9tHXNMBC+jRkV5//5RPnBgzSClujore+MN97/9zf3mm7OA8rDD3A88sOGBWvfu7n36xJQys2a5H3FEzWvSMYulPj16ZPsbbui+yioRjI4YUfr6dKxl/tOnj/uZZ9acy3HIkAgWa3u3ewRQZnGczlG46aZx7ttvC6/Pz434j3+ULm8qi8tYSJFGWhKCzObsLu8D5OfZGJ+U5X0f+L6ZPWtmL5jZwAbc22p69VJ3uUizc49pfWbMyMrGj4/t1VfD5ZfD+efHcZrhPHp0zefk13neYAP49a9jHGXaTTxxYqxF3VDrrRfPu+OOGNt3/fU1r+nbt/b7L70066Z9/fX4bmusEUsjptMOpcyiHCJbOh0Huv76sQRh8bv33LNmVvX++8eSiemYzHbtouu5Q4esazj+UQ+dOmVLAULhUnsHHBDTBu2xR7acYFN65JHSv0cRWey09nwC7Yku8wFE6+VQMyt7bgYzG2xmo8xs1IJ0oH0L6NUrllktHpokIkSwdMstDU8gqK6OMX9XXx3jAEeNikST/HrQxXMDPvporEucBplffhnb/ByEU6bU/d5p0wqn4Sk2cGAklTzxRAR66ZjA9darOQfiZpsVHqfT6JTyve/F+tdXXJGVpesw77hjTPnywAORwDJyZPbdBw6MeRYhWwt6jTXgvffi+995ZxznPfJIrN+95ZaFYw179446b7xxjF287bbs3FprRcLQW2/VnHpm550jYah4TsimsNNOsNFGTf9cEWlxzZld/jmQX2l+laQsbzzworvPBz4ys/eJoPNzIvDM3/tk8Qvc/TrgOoCuXbs28G+0yqXjyqdOrfvvEJFm8eab0YJVHHAtCtyzVq8NN4y5Hcs1ZUq0nh17bARFaSvgSy9FBm337jB7dnb9DjvA44/DX/9a81n5LPPJk2t/5yabRKvZvHmRNFL8L8cjjojgLP1Zb799JItMnx6/g3Ruy9Tmm0dwnEonBAf4+c9j/sxU376RJJMPCN99N9tPA9bddovtvHnxP53Bg+Ff/4qyfKb1978f2333rfk9N9wwy6TOu+SS+FdzVVXpOT179MgCWRGRBmrOlsyXgbXMrJ+ZdQQGAcVzZdxHEkyaWW+i+3wc8DCws5n1NLOewM5J2SIh7eHSNEbS4p58Mrpo09VhmtvMmdHaVu4UL/nJ0PPdrXmffFI4CXnq89y/QYcPj6l3ICb83myzCKJeeSW7Jl2JpZR05RKo2ZL57LPwm99E0LXRRllgefTRNZ/Tu3fNYD7NDN9mm/jkA738iibPPFP4r9C7744s8FTa1bzjjpGpDjHZd206dowJ5zt1iq7vhx8uXJmmLsWTlaf23DMmJhcRaQbNFmS6+wLgWCI4fAe4y93fMrNzzCz92+Fh4CszexsYCZzk7l+5+1TgXCJQfRk4JylbJKQtmRqXKS0uHUeYzoFYbMGCulvu8t5/vzB4nDAhWiJfeCFbdWbgwAiGll669LRAr78e17rHXIb331/4/Lxf/jKmkunbN1r8Jk2KLvIXXojznxd3dJTwt79l+9tvX7j83QMPZPszZsSqLXvvnY3jTG21FVxwQQSs+RbPlVeO6Y/SaXWgdJd/Oj3PJptES+20adm5/LQ6W2+dBZnt2kVr4THHxHKEW2wR81pCfIfbb4/f3WGH1fcTyOy8M/SpZ6j6ppvGtrjFVUSkJbR25lFTfVoyu3zUqEh+vO++FnulSLjttvjDV9vKNmmG89y5dT9n/vy4btdd4/iLL/y7TGuIZa3cCzOMO3d279ChMKM4Lc9nMvfp477yyrHiirv7p59m2cv5zxVXuF98ceyPHJlle5f7+fpr9+99L/YvvTTede+9ke1d2z1mhT+Hs8/Ozp16apTlV8T56KOaP7uJE93ffLOwLL3+zTfdL7/c/eGHo3zBAvd27dz/8pe6fx/NZfp09/ffb513i0idWAKyy7XiTwXSnrg5c1q3HrKE+de/YuUSKBybmHfLLbGdMaPmGs+pceOyFsA00zgdC3jjjbEtlSyTTvZ9//0xbvKqq7Ly/ETgP/lJtGI++GAkjey7L7z9ds3nffBBts719ttn5QcdBLfeWvP6/fePFr9U9+4xdmXs2CwR5mc/g9deq3nvrrtGV3PxikAzZ2b7aXd5muTyr3+Vzg5fYYX4lNKnT3TFp9q1y1b/aQ0aUykirai1s8sXS2nPk7LLpUXttRdcc03s1xZkpl3a+Wl78p5+OrKa02X/OnWK7ccf17x27twI5Ir99reRBX788VlZPqFlo41i/OSkSdC/f7bkY2r06Ohqfv/9yIjOW3bZmqvF7LJLbH/1q6zszDNjm441zNezW7eadf7znyPQLM7+Trusr78+S1hqTMa0AjoRke8oyKxA+veygkxpEu7w4ot1T/lTHFTmW+C++SbGO06ZkgWZM2ZEFvqLL8bxI4/E8oVpS2UPA8wcAAAgAElEQVS6zODcuRHsffJJzXduvHE8Ox9MQkwvVDzeMp+ZvMoqhS2A7XMdJvPmRRDauXPU6eOP4Uc/ys6PGFGzHnffHa2T220Hjz0WyU9nnx3nfvjD2OYzp/NBZho4FgeuqdNOg3POgYMPzsrS/8Ab4sc/ju2imPEvItJK1F1egbQlc+7c1q2HNNDEiZHA0pA1oqurYciQyP7t2jWCo3yySSXSYDINSO65B/bZJwLA996DAw+M6XEguqE33LAwaxmim3nhwmh1+/e/Ydiwwm7ZadNiip+FCyNJaJddIvj7+uua9Vl77ViDu2vXwkSgtAWya1c4/PBI7ClHnz6FSTzz52f76fyVu+0Gzz0X+8ceG5OEQ3R7Dx4c32uPPeLepZfOpkJK17xOnXVWtE7m127OZ1KPHh0ZesXzPKa6dYP/+7/Csssvj4zxdOqgcjzySOXrpYuItFWtPSi0qT4tmfgzbVqM8b/sshZ7pTQFcF9//Ybd8/zzcd8ee8R2s82yc8884z51qvuXX8b5SZOyc998U/p5n3+eLSe4667u77zjfuGF/l2yDbgfdFB2/bvvlk5gAfcxY+KaNBmoZ8/ar81/Dj+8dHnx0oTp54Yb4j1ffln7vfnPl19G4tE22xSW339/9r0WLHCvqoryNJMOIlGlsfJJSCIiiyiWgMQfdZdXQN3li6G0Ne2tt2qemzs3Vl3Jt7ilnnkmtuk0NelE25Mnw7bbwoknRhLI/fdnk4KfdlqMEUzveemlrHv3zTez1sQHH4QLL8xaNtNkm3Qi1vx787p0iVbQPfaIbu6JE0tfu/feNe9dbbWYYLyU/v2j6zjVs2ck1Rx6aBwvvzyce27Wylqb3r2juf/CC7OyBx6IVXNS7dpFEk/37rDOOll5qTGgDZVOSi4iIq1KQWYF1F2+GErnfYSa0wJcdBGccEJkZs+eHVnFBx0UgeTIkXFNOj8lRJD43/9GV/pNN2XlaftZGlylSxz+9KcxZ+OGG0bSTN5NN2VJOKnp0yO4ffPN0ssdrrVWLP/36acx9rH4makbbyycOxIi87t//9JjB9Ou43Qd7E03jdVo8l3NffpEvdyzORrz3c3XXptdnw8e+/ev+b59942fZX48ZVOMaSy1so2IiLQ4BZkVSOdVVkvmIubbb0uPOYRIekl9+CGMGQMnnQR/+EM2fU9VVSz9t9de8I9/xJQ2Tz8d5/JjDJdZJstuzps2rTBbOk3OScfqvfFG6ZbUYjffHCvJbLBBYdb3AQfEdtVVY4zokCHZuW7dsiSXVNeuMa5w1qxYZxsi8OvRI8ZvnnFG4fX/+7+x3WefmPT8jjvqrufWW8f2mGOysvw64/kW2eK6Fdtuu6adMHzIkPLHkIqILKLMbKCZvWdmH5rZqSXOr2ZmI81stJm9bma7JeV9zWyOmb2WfK7J3bOpmb2RPPNKs2bMWGzt/vqm+rTkmEx39y5d3E86qUVfKfX50Y9qH4f3j39k4/Seeiom5c5P0A3ut95aOIYwHSP5hz94jXGHpT577uk+dGh2/MQT7tXV7ksvXfr6zTZznzKlvGeD+113xfbZZ7PvdcopUbbiiu6dOhVen7fddlH2wANZ2YIF8f5KzZzp/vTTsX/cce4DB9a85qOPsmvqUl3tvnBh5XUREVnMUM+YTKAdMBZYA+gIjAHWK7rmOuDXyf56wMfJfl/gzVqe+xKwJWDAg8CuddWjMR+1ZFaoY0d1ly9y0gxlLzEV0IQJ2f706YXXpPvF63OnYyRryzIuzlgeMwbuuis7njEjurTz0w0Vq23C9FL22iv+0G21VVa2xRaxnTgxa60sJW1JXH31rKxdu4a9v1jXrtm611demU3snte3b3lrY5vVngEuIrJk2hz40N3Hufs84A7gp0XXOJAOZu8BfEEdzGwloLu7v5AEujcDP2vaamf0f/UKdeyo7vJW9cortXeHzpgR27lzs38J5LvRSyXTABx1VOnyFVYoPVYwnVZn1VXhhhsiCefRR2OsIcQ4zlIrxqTSZx50UM2VaCC68n/0I9hvvxgfWlVVs0t54MBs/4EHYl7ME08snBwd4C9/ibGm9SXtiIjIoqIPkBvrxfikLO+PwEFmNh4YARyXO9cv6UZ/ysy2yT1zfD3PbDKaJ7NCnTopyGxV6cothx9e89zkyZGl3K9fBJxLL104t2V+XGSPHlkAWqoFFCKr+plnIghdaaWYExFiTOLo0XF/vrVzwIBo0Xzyyayse/dsFZ78PkTC0SOPZCvbpH7zGzjvvNp+AqFLF3joofiOK60Un803r3ldjx4x3lRERBYV7c1sVO74One/roHP2B+40d0vNbMfAbeYWX9gArCau39lZpsC95lZi7cyqCWzQmrJbAaffRYtlA1Ral3oyZNjO2FCdFVPnBgJNCuvHOXp6jTvvBPd2Wk2dW2WXjq6qF9/HR5+OCvfdtvYfvNN4VrW6cTpaXY5ZEkyd9+dTUKeX+lmp53guuvgT3/Kvlep1s1Sdtkle76IiCwuFrj7ZrlPcYD5OZDPmlwlKcs7ArgLwN2fBzoDvd19rrt/lZS/Qozt/H5y/yr1PLPJKMiskMZkNoN+/WquLV2fF16IMZb51Vbycz3m5bOd998/Mq27d8+yqlOnngqnnJId15Z4lx8bmbfBBrEdNy62Tz0Ft94a2dp77RVd1i+/XLgUo1ksDXnqqdGi2pj1s0VEpC14GVjLzPqZWUdgEDC86JpPgR0AzGxdIsicbGbLmVm7pHwNYC1gnLtPAL4xsy2TrPJDgH831xcwr62LcDHTtWtXn1WcuNGMNtoohtvdd1+LvbLtS4O5cv5MFgd+779fOAn31KmFQSVEUJi2Ik6YACuuWPp58+fHlEV9+5b+10R6bXV1jJNs1y5aHs88E4YPj3W2l146SyT69tvK1sMWEZE2y8xmu3udE/smUxJdTmSa3+Du55vZOcAodx9uZusBQ4GliSSgk939ETPbCzgHmA9UA2e5+/3JMzcDbgS6ENnlx3kzBYMak1khdZc3o/nzY43r6dMjoOvRIzs3Z04ksRQbNKjweNddSz83lQ8wi7VvH1nYzzxTOuP5iSdiknSz+FdGGtyec07WitqtWwSZ3bopwBQRkYq4+wgioSdfdmZu/22gxngpd78HuKeWZ44CSqyQ0fQUZFZI3eXN6OuvY2nCnj0jsWX27Ozc5ZfD6afXvOfVV2N73nkxyfiLL9a8ZurUWGGnrqAv/y+H2sY5br99tv/T4tkkEt27x1jQfIAsIiKyBNGYzAopu7wZTZ+e7eeXgDziiNIBZr6bvK45GadOhUMOiSmBatOhQ/n1rEs6zjNNNhIREVnCKMiskLrLm9H06YWZ19XV8OyzMRclRCB4xBHZ+XRCcoj1tmtTVwA5YUJkmjeVk0+OqYXqy1wXERFpoxRkVmix7y5fsAAOPLB0t3Le889HMkuxV1/NMrrHjYus8C++iGmIqqvrf//QobDzzrH/8MMwKjdV2PjxkTWeGju2sIXy5JMLx2XmM9KXXhrefLPm+847Dx57rPb6rLhi/etrN4RZTC3Uv0WGvYiIiCxyFGRWaLFvyRw9Gm67DQYPrvu6rbaKcYcHHwx33hllY8ZEi+HZZ8fxkCExv+Wll8Jqq8Fhh5V+1qxZ0RrpHu999NGYS3LgQPjhD7PriicNz3eHA6yySkyu/uab8NVX8U7IJlxff3246CL45z+ze04/PZtaSERERJqdgswKLfZjMtMWzN694d134cgjs+UYIZJthg7Njm+9NTK4Z8yIzGqI6YD+85+Y7geytatvuSVaM/MJO48+Gq2MRxwR2dmpp5+uvY5pMk+x3r1ju/76MU3RgAHx3Jtvzq45+WTYe+/suLa5LkVERKRZKMisUIcOi1GQOX16zCOZN3p0bJ94AtZdN8YOPv54dv6440q3cj7xBJx0Uuw//jjssUe2TvY772TXDR0KXbvGdEDvvVe4xvaOO2b7+RV08u6/HzbeOAJgiFV00vcWr4SzzDIwbBjss0/pZ4mIiEiL0xRGFerQofSKhq1i4UIYORJ22KF0i93WW8Pbb2eTnF93XZZEk/fWWzHlziWXwIgRNc8D/Oxn5dXpqKOyum2xRe3jNJ96qnT5gAGxXXtteOMNWHPN+G5bbw3bbVdeHQBOOy0LqEVERKTFaMWfCh19dAz5S5fJblWnnhpjEB98MD7HHFM4jjENPAcPjqDtd78rvL937+jK7tmz4QHZz38OffpEHf75z5jE/Be/iHN77BFZ4VOnlv+8ffaJ6X/yLZ8iIiJtTDkr/izu1JJZofbtW6glc8aM6Jdfdtnar7nuutimq9y0bx9JOPvsU7hiTXpdsc6dYdttC8c0nnYa/OlP9ddvn31iHXCAE06ITPDUscdGC+SQIbDllnDuuTBlSiTgLLUU/OQn0cXevn2MrxwzBtZbTwGmiIhIG9CsYzLNbKCZvWdmH5rZqSXOH2Zmk83steRzZO7cwlx5iTl0WleLdZdvs020NNbV4jxtWuHxa6/F9u674a67ar8vDVwnTYopftLWzyuugPPPr3l9OuVQ3lprFR7nl2vcfPNsWqDOnWMs5qBBEVD265cFp1OmRAvqPfdEcCsiIiKLvWYLMs2sHXA1sCuwHrB/spB7sTvdfaPkMyxXPidXvmdz1bNS7dsXLoXd5F57LZYlHDMmjvNJNXn5aXog5mZ84YXy+vEPOCC28+ZFMPjee9G1feyx0cWeZnGnbrklsrbzioPMrl1hzz0jEWeZZbLphUpF5H/4A3zzTYwDNYtudq3zLSIi0iY0Z0vm5sCH7j7O3ecBdwC1LPS8+Gn27vKNN4aVVoJu3eL4l7+E118vvGbWLNh338KyCy+Eb7+Nrum6PP00XHZZLLOYZodDjMtMu9g/+SQmWgc4/HBYfvl4fl6ptbn//e9sRZ40E7zUD6uqKvt+IiIi0qY055jMPsBnuePxwBYlrtvLzLYF3gdOdPf0ns5mNgpYAFzo7vc1Y10brEOHSJx2b4YpGPNd4+nclc89Bz/4QUyI/vzzEWAefHDNezfaKLqpr7oqO067z/PSFXRuuqn2eiy1VHRrv/12JAxB4ZedMKH+77Je0nh9/PH1XysiIiJtRmsn/twP3O7uc83sV8BNwI+Tc6u7++dmtgbwhJm94e5j8zeb2WBgMEDHjh1bst60T35yCxbUvSR2g337LcyZU1h2+unw8ssxofl++2XlaStjse23z5ZlHDIkgsRjjoHvfQ9+//ua3eD1WXfd0uX58Ze1qW88qYiIiLRJzRlkfg7kF4NeJSn7jrt/lTscBlycO/d5sh1nZk8CGwNji+6/DrgOYgqjJqx7vdLAsqIg8803YxzkJptES+XIkdFCePvtMcbyyCMLr19uuQgWi9fBTidPP/DACETTyPeEE6KV8a23ovVzwIBoUdxooxgnKSIiItLMmjPIfBlYy8z6EcHlIOCA/AVmtpK7p32uewLvJOU9gdlJC2dvYGtyAeiiIN+S2WDpGtruEVAWZ4Bfc03hca9eMRVQKausEks+5i2/PPz974Vl6eTmIiIiIi2g2RJ/3H0BcCzwMBE83uXub5nZOWaWZosfb2ZvmdkY4HjgsKR8XWBUUj6SGJP5dnPVtRJpkNnoDPOXXio8XmONbH/33WPbuXNkXZ92Ghx2GPz4x9k1hxzSyAqIiIiIND2t+FOhv/41hjl++WU0HJZt6tRsfsrq6miJ/OKL7PxZZ8HZZ8f+uHExtnKffbKoFiLru2/fqMTgwdCuXWO/TsP07Rt1aCN/dkRERFqaVvyRWjW4JXPYsJjM/Mkns7IHHijM0L7hhpi7crXVYv3wPn2yCcvzVl89AtQmT2sv0/vv174WuYiIiAhqyazYDTfEVJAffxwxX50++CBW0+nSJVouP/ig5jX/+79w/fXNUVURERFZxCwJLZnNuqxkW5bPLq/T229nyzXOmRMB5hZF04XOmaMAU0RERAqUsTz3amY20sxGm9nrZrZbUr6Tmb1iZm8k2x/n7nkyeWa6dHdDBv01iILMCtXbXT5pUgSP999f81yauLPiijB7diT2iIiIiCTKXJ77DCKxemNiFp+/JuVTgD3cfQPgUOCWovsOzC3dPam5voOCzAoVtGSOGBHjI999N7tghRVg/fXhwQdr3jxoENx8c1zfpUuL1FdEREQWK+Usz+1A92S/B/AFgLuPdvc0q/gtoIuZdWqBOhdQ4k+FCubJvOOOOHj+eVhnHZg7N44/+ig+qTfeiOUhN9gANtywResrIiIii5Vyluf+I/CImR0HdAV2LPGcvYBX3X1uruzvZrYQuAc4z5spQUctmRUq6C4vzvIeP77w+PnnY+qi/v1jyqHWygoXERGRRUV7MxuV+wyu4Bn7Aze6+yrAbsAtZvZdbGdm6wMXAb/K3XNg0o2+TfI5uPKvUDe1ZFaooLs8DRqvvDKyx//85ziuqoIdd4Qtt2yVOoqIiMgia4G7b1bH+XqX5waOAAYCuPvzZtYZ6A1MMrNVgHuBQ9z9u2W5c8t2zzCz24hu+Zsb+2VKUZBZoZItma+9FnNhpt57r3AFHxEREZHy1Ls8N/ApsANwo5mtC3QGJpvZMsADwKnu/mx6sZm1B5Zx9ylm1gHYHXisub6AussrVNba5autFq2ZIiIiIg1Q5vLcvwN+mSzDfTtwWDK+8lhgTeDMoqmKOgEPm9nrwGtE8Dq0ub6DWjIrVLK7PG+bbaBjxxatk4iIiLQd7j4CGFFUdmZu/21g6xL3nQecV8tjN23KOtZFQWaFCrrL583LTsyYAWPHwpprtkq9RERERBYFCjIrVNCSOXNmdqJrV/jBD1qlTiIiIiKLCg0YrFDBmMx8kKnpiUREREQUZFaqoLt8xoxWrYuIiIjIokZBZoUKusunTGnVuoiIiIgsahRkVihtyVzhlREwbhwcemjNlX5EREREllBK/KlQGmT2+GRM7Fx1FXTr1noVEhEREVmEqCWzQml3eYcZ06BTJwWYIiIiIjkKMiv0XZA5cxr06tW6lRERERFZxCjIrFCnTrHtMHMq9OzZupURERERWcQoyKxQGmR2nDVNQaaIiIhIEQWZFWrfHtq1g06zFWSKiIiIFFOQ2QidO0PnORqTKSIiIlJMQWYjdO4MXeZoTKaIiIhIMQWZjdCpE3RcMBu6dm3tqoiIiIgsUpo1yDSzgWb2npl9aGanljh/mJlNNrPXks+RuXOHmtkHyefQ5qxnpTp3ctr5wmxmdhEREREBmnHFHzNrB1wN7ASMB142s+Hu/nbRpXe6+7FF9/YCzgI2Axx4Jbl3WnPVtxJdOy2InXTSTBEREREBmrclc3PgQ3cf5+7zgDuAn5Z57y7Ao+4+NQksHwUGNlM9K/ZdkKmWTBEREZECzRlk9gE+yx2PT8qK7WVmr5vZ3Wa2agPvbVVLdZgfO2rJFBERESnQ2ok/9wN93X1DorXypobcbGaDzWyUmY1asGBBs1SwLuouFxERESmtOYPMz4FVc8erJGXfcfev3H1ucjgM2LTce5P7r3P3zdx9s/at0GX9XUumustFRERECjRnkPkysJaZ9TOzjsAgYHj+AjNbKXe4J/BOsv8wsLOZ9TSznsDOSdkipWtHdZeLiIiIlNJsQaa7LwCOJYLDd4C73P0tMzvHzPZMLjvezN4yszHA8cBhyb1TgXOJQPVl4JykbJGyVEcl/oiIiEjzKGMqyNXMbKSZjU7yW3bLnTstue89M9ul3Gc2pWaNjtx9BDCiqOzM3P5pwGm13HsDcENz1q+xurRXS6aIiIg0vTKngjyDaMT7m5mtR8RcfZP9QcD6wMrAY2b2/eSecqaXbBKtnfizWOvSQYk/IiIi0izKmQrSge7Jfg/gi2T/p8Ad7j7X3T8CPkye15jpJRtMQWYjfNeSqe5yERERaVrlTOf4R+AgMxtPtGIeV8+9LTpFpILMRlB3uYiIiFSofToNY/IZXMEz9gdudPdVgN2AW8xskYnt1ATXCJ3aKfFHREREKrLA3Ter43w50zkeQbIiors/b2adgd713FvvFJFNZZGJdhdHHS1aMqvbqSVTREREmlS9U0ECnwI7AJjZukBnYHJy3SAz62Rm/YC1gJfKfGaTURNcI3SwaMlcWNVB0bqIiIg0GXdfYGbpVJDtgBvSqSCBUe4+HPgdMNTMTiSSgA5zdwfeMrO7gLeBBcAx7r4QoNQzm+s7KMhshLQlcwHtUVumiIiINKUypoJ8G9i6lnvPB84v55m1MbPjgFvdfVoDqv0dNcA1wndBpinEFBERkTZnBWIuzbuSSdytITcryGyEDlXRXb7A1CAsIiIibYu7n0GM57yeWJXxAzO7wMy+V879CjIboYOn3eVqyRQREZG2JxnjOTH5LAB6Aneb2cX13asmuEZIE3/mK8gUERGRNsbMfgMcAkwBhgEnufv8ZC7OD4CT67pfQWYjdCBL/BERERFpY3oBv3D3T/KF7l5tZrvXd7O6yxshDTLVkikiIiJt0IPA1PTAzLqb2RYA7v5OfTcryGyE9iTd5a6WTBEREWlz/gbMzB3PTMrKoiCzEdSSKSIiIm2YJYk/QHST04ChlgoyG+G7lkwFmSIiItL2jDOz482sQ/L5DTCu3JsVZDZCu2QKI3WXi4iISBt0FLAV8DkwHtgCGFzuzYqOGiGdJ3OeqyVTRERE2hZ3nwQMqvT+soLMZGb38e4+18wGABsCN7v79Epf3Ba08+gun1etWF1ERETaFjPrDBwBrA90Tsvd/X/Lub/c7vJ7gIVmtiZwHbAqcFvDqtr2qLtcRERE2rBbgBWBXYCngFWAGeXeXG6QWe3uC4CfA1e5+0nASg2saJvTvno+82nP/AUNWi9eREREZHGwprv/HzDL3W8CfkKMyyxLuUHmfDPbHzgU+E9StsQPROzw7Qxm0I3581u7JiIiIiJNLo1wpptZf6AHsHy5N5cbZB4O/Ag4390/MrN+RBPqEq397G/4hu4sWNDaNRERERFpcteZWU/gDGA48DZwUbk3lzWY0N3fBo4HSF7Wzd3LfklblQaZaskUERGRtsTMqoBv3H0a8F9gjYY+o6yWTDN7MlmvshfwKjDUzC5r6MvamnazFGSKiIhI25Os7nNyY55Rbnd5D3f/BvgFMXXRFsCOjXlxW9Bu1jd8TQ8FmSIiItIWPWZmvzezVc2sV/op9+Zyg8z2ZrYSsC9Z4k+9zGygmb1nZh+a2al1XLeXmbmZbZYc9zWzOWb2WvK5ptx3tqSqmV9rTKaIiIi0VfsBxxDd5a8kn1Hl3lzuBI/nAA8Dz7r7y2a2BvBBXTeYWTvgamAnYimil81seDK+M39dN+A3wItFjxjr7huVWb9WUTVT3eUiIiLSNrl7v8bcX27izz+Bf+aOxwF71XPb5sCHybWY2R3AT4nMpLxziUylk8qs8yLDZkSQWaUgU0RERJqYmQ0ErgDaAcPc/cKi80OA7ZPDpYDl3X0ZM9seGJK7dB1gkLvfZ2Y3AtsBXyfnDnP312p5/yGlyt395nLqX+6ykqsAVwFbJ0VPA79x9/F13NYH+Cx3nC6snn/uJsCq7v6AmRUHmf3MbDTwDXCGuz9dTl1bzPz52Jw5fEN3llZ3uYiIiDShcnqE3f3E3PXHARsn5SOBjZLyXsCHwCO5x5/k7neXUY0f5vY7AzsQCeBNF2QCfyeWkdwnOT4oKdupzPtrSFLjLwMOK3F6ArCau39lZpsC95nZ+knyUf4Zg4HBAB07dqy0KpWZOROAGXSjk1oyRUREpGmV2yOc2h84q0T53sCD7j67oRVw9+Pyx2a2DHBHufeXm/iznLv/3d0XJJ8bgeXquedzYo3z1CpJWaob0B940sw+BrYEhpvZZu4+192/AnD3V4CxwPeLX+Du17n7Zu6+Wfv2Lbx+eDIQcz4dNCZTREREmlqpHuE+pS40s9WBfsATJU4PAm4vKjvfzF43syFm1qkBdZqVvKcs5QaZX5nZQWbWLvkcBHxVzz0vA2uZWT8z60h8yeHpSXf/2t17u3tfd+8LvADs6e6jzGy5pJmYJMloLWBcuV+qRVRXA2BVVcouFxERkYZqb2ajcp/BjXjWIOBud1+YL0xmBtqASN5OnUaM0fwh0As4pbaHmtn9ZjY8+fwHeA+4t9xKldv897/EmMwhgAPPUbqb+zvuvsDMjiW+WDvgBnd/y8zOAUa5+/A6bt8WOMfM5gPVwFHuPrXMuraMJMis6tCOOXNauS4iIiKyuFng7pvVcb6+HuG8QcRUQ8X2Be519+/6XN19QrI718z+Dvy+jjpckq8v8Ek9+TgFys0u/wTYM19mZicAl9dz3whgRFHZmbVcOyC3fw9wTzl1azVJkNmhUxUzZrZyXURERKSt+a5HmAguBwEHFF9kZusAPYHnSzxjf6LlMn/9Su4+wcwM+BnwZh11+BSY4O7fJvd2MbO+7v5xOV+g3O7yUn7biHsXf0mQ2bFzFTNmtHJdREREpE1x9wVA2iP8DnBX2iNsZvmGv0HAHe7u+fvNrC/REvpU0aP/YWZvAG8AvYHz6qjGP4ke5dRCclNa1qcx2TLWiHsXf7kgc6ZaMkVERKSJldMj7O5/rOXejymRKOTuP25AFdq7+7zcvfOSPJuyNKYl0+u/pA1TkCkiIiJt2+R8q6mZ/RSYUu7NdbZkmtkMSgeTBnQp9yVtUhJkduqi7nIRERFpk44iutf/khyPB0quAlRKnUGmu3drRMXatnxL5vRWrouIiIhIE3P3scCWZrZ0ctygvtvGdJcv2XItmeouFxERkbbGzC4ws2Xcfaa7zzSznmZWV6JQAQWZlVoY852qu1xERETaqF3d/bv+WnefBuxW7s0KMitV1JLpS3YalIiIiLQ97fLLTppZF6DsZShbeMHvNiQNMpdqR3U1zJkDSy3VynUSERERaTr/AB5PVgYyYrXHm8q9WUFmpZIgs0vXaAz++iI6kBoAACAASURBVGsFmSIiItJ2uPtFZjYG2JGYbehhYPVy71d3eaWSIHOZXvEjnDChrotFREREFktfEgHmPsCPidWHyqKWzEolQWav3hFkfv45bLJJa1ZIREREpPHM7PvEuuf7E5Ov3wmYu2/fkOcoyKxUEmQuu1wWZIqIiIi0Ae8CTwO7u/uHAGZ2YkMfou7ySiVBZs9lq6iqUpApIiIibcYvgAnASDMbamY7EIk/DaIgs1JJkNmuQxUrrqggU0RERNoGd7/P3QcB6wAjgROA5c3sb2a2c7nPUZBZqSTIpKqK3r3hq69atzoiIiIiTcndZ7n7be6+B7AKMBo4pdz7FWRWKlnxh6oqevaEadNatzoiIiIizcXdp7n7de6+Q7n3KMisVNqS2a6dgkwRERGRIgoyK5XrLleQKSIiIlJIQWalioLMzz+HI49s3SqJiIiILCoUZFaqKMgEuP761quOiIiIyKJEQWalckFmugtZPpCIiIjIkkxBZqVyQeaMGVnxF1+0TnVEREREFiUKMiuVCzJPPhnWXjsOV1sNzjtP82aKiIhI45jZQDN7z8w+NLNTS5wfYmavJZ/3zWx67tzC3LnhufJ+ZvZi8sw7zaxjc9VfQWalckHmcsvBa6/B738P7drB//0f7LwzuLduFUVERGTxZGbtgKuBXYH1gP3NbL38Ne5+ortv5O4bAVcB/8qdnpOec/c9c+UXAUPcfU1gGnBEc30HBZmVyk3GDtC5M/z5z/Dii7DssvDqqzBpUivWT0RERBZnmwMfuvs4d58H3AH8tI7r9wdur+uBZmbAj4G7k6KbgJ81QV1LatYgs75m3tx1e5mZm9lmubLTkvveM7NdmrOeFcm1ZOZtuilcfXXsn3EGmMGbb7Zw3URERGRx1wf4LHc8PimrwcxWB/oBT+SKO5vZKDN7wczSQHJZYLq7L6jvmU2hfXM9ONfMuxPxJV42s+Hu/nbRdd2A3wAv5srWAwYB6wMrA4+Z2ffdfdHJ3c6t+FOsd+/YDhsW20cfhf79W6heIiIisjhob2ajcsfXuft1FT5rEHB3UZy0urt/bmZrAE+Y2RvA15VWthLN2ZJZbjPvucT4gG9zZT8F7nD3ue7+EfBh8rxFRy0tmQDLLdfCdREREZHFzQJ33yz3KQ4wPwdWzR2vkpSVMoiirnJ3/zzZjgOeBDYGvgKWMbO0kbGuZzZacwaZ9TbzmtkmwKru/kBD7211DQgyP2+2X5+IiIi0US8DayXZ4B2JQHJ48UVmtg7QE3g+V9bTzDol+72BrYG33d2BkcDeyaWHAv9uri/QbN3l9TGzKuAy4LBGPGMwMBigY8dmy8AvrY4gc9lls/3vfQ/uuQfWWANWWgnWXRfWWaeF6igiIiKLJXdfYGbHAg8D7YAb3P0tMzsHGOXuacA5iOj9zc9psy5wrZlVEw2KF+aGK54C3GFm5wGjgWZbr7A5g8z6mnm7Af2BJyPZiRWB4Wa2Zxn3ApA0LV8H0LVr15adMKiOIDMf7668Mjz9NBxzTOGtzzwD774Lv/xlM9dTREREFkvuPgIYUVR2ZtHxH0vc9xywQS3PHEcLDUFszu7yOpt53f1rd+/t7n3dvS/wArCnu49KrhtkZp3MrB+wFvBSM9a14eoIMgGuvBJGjoyWy2J//Stsuy0MHkzBakEiIiIibUWzBZlJenzazPsOcFfazJu0VtZ171vAXcDbwEPAMYtUZjnUG2QedxwMGAA77lhYvswyMGRIdvzoo81TPREREZHWZN5GlqXp2rWrz5o1q+VeOHRoNEWOHw99as9Jmj8fzj8/Vv+57z446CA4+eTs/BZbwAsvwOzZcMop8Mc/Rvz66KNwwAHN/zVERESk5ZnZbHfv2tr1aE6tlviz2Cta8ac2HTpE4Ahw9tmxIlBq0CC44w6YOBGGD4e//CXGcz7+OIwZA7vsUphEJCIiIrK40LKSlaqnu7w2a6yR7e+7b2x32SVbJWj+/AgwAaZPR0RERGSxpJbMStWx4k9d0tWAAHbeObavv56VzZ+f7SvIFBERkcWVWjIrVWFLZszWFLp2hfZFYf4992T7Y8fC3nvDpElZ2ddfQzr0dO7cBr1aREREpMUoyKxUhUEmwBFHZF3l11wT267J0N/Jk7PrTjopgs7rcgtNLbMMbL115Bt17gzXN9sUqiIiIiKVU5BZqUYEmcOGwZ13xv4RR8Sjpk+HE06IskGDYvvpp7Ht1Cm2nyULbY4ZA+ecE/v/brbFoEREREQqpyCzUo0IMouZRbf5pZfCG2/A3/5WeH7SpGwKpNTQoY1+rYiIiEizUeJPpZowyExVVUH//hFQ5r3/funXrLMOjBvXZK8XERERaTJqyaxUMwSZqXxy0HbbxRyaqbPOyvZ32QXeeQeee67w/vHjY8Whu+5q8qqJiIiIlEVBZqWaMcgEOO00+Oc/Yb/9Csv794cNN4R+/WDVVaMaW28NH32UXXPDDTGx+377xaJEZvDQQ3HupptgxIhmqXKt3n0XFixo2Xe2tq++0rr0IiKyZFOQWakyV/yp1AUXxPRFv/51Ycb52mvDqFERuK2wQlY+dmw2r+a772bl6djNww6Dww+Ho4+GSy5pWF3Gjs2+LsC338JLL8G//lX/vR99BOuuC2ec0bB3Lu5694bvfa+1ayEiItJ6FGRWqsLJ2CvRu3eWeb7mmrFUZceOhUHmTjtBz57RYnn77TUDnC+/hBtvjDXS0yx1gBVXhIsuKrwu/WoPPBDTJ625ZiyJmVpnnVhzfa+9CoPP1OjRMZ8nxJKZAE88UdFXL0t1dSRFFY9lbW35fxyIiIgsaRRkViqNxPIDKJvRJZfA1KnQpUtWlg8yU7vuGtttt639WZ99Bo8+ClOmRFB56qlR/vrrEXSm0yPtvjv86lexn3a3A3zySbZfnOVeXQ2bbBJd+gDffBPbKVPgySfr/IoVu/Za+PnP4ZZbmuf5IiIi0nAKMitVXf3/7Z13mBRV1sbfw8wg4yDCMChJMqiYAJGgIqgowRUQUcGwfCziIgiIgoBhxcC6uq4gwYwgi4osJlTCuogYQCSIJAnjgAqSo8IMMHC+P05d61Z19YSmuyed3/PUc6tu3aq6PTUN75x7QsyWyoNISBBLpY1fZD72GFCjBnDTTbLcHo4jR6Sk5T33uH3z5wMXXST7U6Z4y1sC4lO5aBGwfr23/+67gd9/d4/37pX255/FJ3H3bjnetAm48kpg9Wp37J49wP/+F36eeeXXX6XdvPnk76UoiqIoSnRQkRkpcRaZQdh10AGxSP70k0SVV67s9l96qbTduwPPP+/2L10qbZkywAsvuP3Hj4sfps2xY3Kfc84JnYdJo/T995Jo3nDuuaEpli68EBgzRpbob7xRlvkXLpSl7hkzIiuVmZTkzlFRFEVRlMKB5smMlEIgMhMSZBl9yBDZL13ae75XLylXaSoHDRggwu+hh8T6aIRkcrLXorh9O9C1q/dee/aEPv/MM2W5feNGEY+NGnnPb90qVlEbZmDwYG9fp06Squm99ySqPicrbBDmcx89mr/rFEVRFEWJHWrJjJRCIDIB4P77RSxu2xZ67vXXgXHjgIoV5fiCC2TJfe9e71L7vn0SmX7DDUCfPkDbtpJ/0ybo/g0aSNutmwjXINLT3f2WLUPPd+4sAtZEqn/3HTBvXvC9wpHo/KmkIlNRFEVRCg8Fr5KKKoVEZAJAnTpApUrhz99wg/hfnnaaHCclScS4nylTJJr8o4+A667LPe1Qu3ZAixay77c+fvml+zxA/ESN2O3d2+3v0sV73Zw5InInTpTjo0eBO++U+YaLUM/MlDaSpfZYExR9ryiKoiglgcKhkooihUhk5sb114tF06ZKFe/xd98BZcvKfqlSwMcfA088AaSmesfdd59ElK9cKUvbixYB/fuHPvOyy4DFi4EFC0QETp/uBuR37OiOq1gxODn8ww9L4NDUqSI4f/xRBCmRNwUTABw6JK2d/Pyss0IT2RcEZm6KoiiKUtIoGiqpMHL8eJERmUFccom0vXsDq1aF+lMa7Hybxgf0zjtl6d18fBN4Y4s6IvH/vOIKCSwCgKFDpTWBSICI2HbtvM8cMkR8PXv2dK2ejRq5ItJOpwS4Qm7fPrdvy5aCK6tpxDTgjbxXFEVRlPxARO2JaD0RpRPR8IDzo4lohbNtIKL9Tn8jIlpERGuIaCUR3WJdM5mINlnXhVEAJ48G/kRKEbJkBjF4sCRMv+OO4IhxQ4sWQPnyEpxzzTXBaUHvuEMixocNE2FnR5jbtGkTmjC9QoXQH2OnTmJZff99OX7oIQlOWrFCjv3+oYcPS2uLTMORI7KVKxf+M0Ybu4TmwIESNa8oiqIo+YGIEgBMAHANgC0AlhDRTGZea8Yw82Br/AAAjZ3DwwD+zMwbiagqgGVENJeZndqAGMrMMf/fSUVmpJw4EZdqP7EiKQkYNSr3cWPGSJuTnm7SxBWPthUvL/iX4wHxL23Z0g0A6t9f0hwZVq2Sc23bihuAsWSaCjtZWe7Y6tXFkupfYo8ldiqld9+N33MVRVGUYkUzAOnMnAEARDQNQGcAa8OM7wHgUQBg5g2mk5l/JaKdACoB2B/m2phQdE1xBU0Rt2TmlVKlYvsxTYL52rXdvjPOcAOKEhLk2F62nzFDBCYgPqJGZO7YIa0paQlIMvgtW2Iz93DYIrNatfg+W1EURSk2VANgm0i2OH0hEFFNALUBhITIElEzAKUB2BmwRznL6KOJ6JToTdlL8VdJsaKEiMxYc4rzq21XEipf3hWZlSuL0PTXYjccO+aKzIMHxYq5P65/p4ViL5fn17KrKIqilBgSiWiptd11EvfqDmAGM3tymhBRFQD/BtCLmc3/SCMAnAPgEgCpAIadxHNzRFVSpKjIPCn++U9v3sykJNffs1QpiTqvX9+1BJp0SLVrAw8+6L2XKV0JiDXztttCn+f3BY0lxpKZnKyBP4qiKEpYspm5qbW94ju/FcBZ1nF1py+I7gDetjuIqByATwA8xMzfmH5m3sbCEQCTIMvyMUF9MiNFReZJMWSIbDabNkm1IcPzz3vdXtPTZXk9NdWbl3PVKhF0mZnA2rXAsmWhz8vMBE49NbqfIRxGZKamSl115uCAKUVRFEXJgSUA6hNRbYi47A7gVv8gIjoHQAUAi6y+0gDeBzDFH+BDRFWYeRsREYAuAFbH6gPEVCXlIfS+LxGtckLovyKihk5/LSLKtMLrX4rlPCNCRWbUqVkTaN7cPe7QAbj2Wve4bl03UOgUnwfJzTdLa5fHtHn11eDSmLHAiMwKFURgaq5MRVEUJb8wczaAewDMBfADgOnMvIaIHieiTtbQ7gCmMXvW7G4GcAWA/wtIVfQmEa0CsApAGoAnY/UZiGO0juiE3m+AFXoPoIcdek9E5Zj5oLPfCUA/Zm5PRLUAfMzM5+f1eSkpKXwonv+b9+wpmcY3b47fM5U/yMgQy+a+fUD37sDSpUDTpq5FM4iHHgKeDPNVuvVWSY00f/7Jz239ekkL1aqVVD7atk18SxVFURTFQESHmTmloOcRS2Jpivsj9J6ZjwIwofd/YASmQwqAOHrOnSRFPIVRUadOHbFy3nKLWA6bNJH+zExJNL9gQeg1P/0kkekXXyxL8zZvvw18/nl05mZbMgFvtLuiKIqilBRiKTLzFHpPRP2J6EcAzwAYaJ2qTUTfEdECImoVw3lGRhGv+FOcSEz0+jxOnCiVhvxs3Qr85S/A8uXhBeXOne7+r7/KNfnF9skEck52f7IQSV14RVEURSlsFLhKYuYJzFwXEkL/sNO9DUANZm4M4D4AbzlRUh6I6C4T+p9t542JB8ePqyWzkHHjjdKe7zhZzJ4NPPKIe37rVllOB7wpk2zOPBM4elQCkKpV89ZZD+Kdd6SOu435VTSWzFijFYUURVGUwkgsRWZ+Qu8BWU7vAgDMfISZ9zj7yyAJRBv4L2DmV0zof2JinAPlVWQWOt5+W1IGGatm+/ZAt27u+S1bgL17ZX/DhtDrDXPmAJ856WyNgFy0SO539Kh3bPfuwEUXefuMJdM2dPuvC8e770qd9rzk19QcnIqiKEphJpYi84/QeyeUvjuAmfYAIqpvHV4HYKPTX8kJHAIR1QFQH0BGDOeaf1RkFjqSkoCUlNA+w+HDrpVx0SKpj84stc1t7rkH+Phj95hZ6rPPnSsW0Jdeklyd4YznRmTaS/Z5jWy/4w7g++9FDL/5JjBpUvixRSEH53//C/zjHwU9C0VRFKUgiJnIzGPo/T1EtIaIVkCWxXs6/VcAWOn0zwDQl5n3xmquEaGBP0UCE9Vtp0a64AJZDm/SRKLKW7f2XvPLL2IVNRw44IrVTz8F7r4beOop1ypq2L0b+OEHb+DPf/7jnssLJjXTjh0izgYNEkEcRLiAokceEWtsYaBdO2DEiIKehaIoilIQxHSNmZlnAZjl6/ubtT8ozHXvAng3lnM7aTTwp0hgclXOmgVcd530de0qCdwBYNo0d+wVVwBffy2v1mbbNldk3n+/279xo3dc69aSDP799+U4KQmoVEn2586V9EljxgClS0tFI0NGhojLatXkHCBCd906sZZeemlwxaKDVm4GO+G7SdMUzypHuaGGf0VRlJKHqqRI0f81ixRnnOHuX3+9iD17KR0Aevd2RR4gNdQBEZ7GOmmzeLG7P2WKCEwAuPdeaRMTgbQ02R86FJg+HahaVdIv2dStC1SvDixc6Foyv/jCuxz/ir/YGLyWzMOHpQ0nLHftkoT0xo/zrbekxvvBg8D48eGX/qOFpnFSFEUpeajIjBQVmUUKY1EERNQNGgSUc/IVTJ0KdO4slk5bTP75z9L26SNWRUCshcZSaVs1e/Z093/6SVrbkmlz8CDw2msivGxReNllrsj1Vy76619FFPrvY1ixQnxLt21z+4zwBMS6eddd4mu6bp3Ud//LX8S/dMAA4IUXQucZTfyuBYqiKErxR0VmpKhPZpHCFnvGQnn66dK2bg188IEsYdsWPWORNMydK76SnTohkB49gMaN3WMjMoNSGfXpEywcjchdsiT0mgoVXIvg3r3ea598UiLdq1mZaG1Lq0m+8NZbruBbvtxNWv/mm8GfKVrs2xfb+yuKoiiFDxWZkaI+mUWKU08N7Zs5U4JkbGH26aci1rKygNq13f70dKkwVKmSvPbbbgu9X7VqIlYNJkl8zZpun/ELBSTH5oMPeu/x8885f44hQ6SSacWKwKOPSt+114ootZ8NSGS34bffpH3/fQlOAsTiOsvxmP72W/EDBcS6Om+ea5HNiTVrJC/p999LJPx997nnli939+NtyRw+XIKzFEVRlIJDVVKk6HJ5kaNWLVkyNpx3HvD4495qQW3bSmS58Y28917JW1m3rvdekyZJhPqyZRJIBIj/ZY0awFlneceaij/LlnlTIwGyXO1n4EB55uWXh5577TXXwmpyfbZpE5wi6fvvJTfoZ5+JPyYg+Tr9S/GGZcvEkvvCC/Jz6N07eJzNJ5+I0GzUSJbfR48Wkfr221K+0xBkyVy2LHa+mk8/HSrgFUVRlPiiIjNSVGQWOTZtAl5+OX/XjB4t+TT9JCVJdaAmTdxAHrPU/jcnf4IJ+hk3ToKHTH11Q716EjA0ciRw6JDbX7++WAG//BKYPDn02R9+6O43bAhceWXw3BcvFsF79dXefn+FIsP27ZKe6Z575HjpUvfczz+7Pp4vvyypibZudcW4TWamBC7Z+C2ZJ04ATZtKIBSzpHrq2VNKgkaTTz+N7v3CsWyZ970oiqIoKjIjR0Wm4tCjh7TXXy/tnXeKiDK1y9PSJA2R4YcfRHRu3CjJ1x991Luc37Gja101ZS3tykU2rVpJDtCOHb0itmbN8EvUJgrehkhE5muvuX0HDoi19MQJuZ/xRX3xRVmKf+WVUJ9SQPr8/f4a8Lt2SXv4sNSIv/lmEdx33hk85/xgB29de+3J3y8vNG0KdOmSt7FZWcE/N0VRlOJGnGsxFiM08EdxaNIkNHWQvQTvxyyf+5kxQyyAdoqjSpWA1avF6hlUo/yGG+RZH30kllRjWaxdO9SnMjlZBE5QmqO0NBGZfs4+2w0gmjdPnmGW6UePdn09q1eXpXlAlsb9y+OrVslXxrgx21Hw5jrDkSPyOb74Qu7fsaP8TZfXyrF5ra4EyP2fe06W1v0prSIhKwsoUybnMW3byh8ZhSmPqaIoSixQS2akaOCPEmVuvBF4/vnQ/vPOC16W7tABuOYa2S9Vypvj0w5aWrMGGDVKRJudBN7Qv79URrKFH+AGRP3zn27fZZfJcvgpp7gCExArpGHfPm+Fo3r1RASPGCEC8skn3ZRQQGhFI+On2bo18Kc/uQLw118l3VJuFYSMldRgp3Ly89hj4q7w1ls53zOvmOCpnPj66+g8S1EUpbCjKilSdLlciTPbt7uC74YbJDI83N85RmQSid/mgw/Kkq5Zwr/kEmnT0iQZe+XKoaUoMzKktS2o334r7bPPese2bOlG0e/bJ4LQYHxTn3kGGDtWIvpNZDwADB7svdfKlZLeyWBqn1erJnMNVwudWdJTjRzp7Q+y0BpM3Xp7+XrbNqBfP7FK5pfcsgPYZGbm//6KoihFCRWZkaIiU4kzZ57p5vgMSslkc/bZ0t58s7c/OVnali2lNVa+Cy+UyHMb2zJ6661utSBA8nzalCnjRq3v2SP5RA2TJoklsnRp4L33pM8I2CBGjgyucGQIt2y+f79YQc0zjCD3W2ht7CwCZs6DB4vfaXJyaACTn6wsGVu2rBznJe2TQXOHKopS3FGRGSkqMpUCwCR7v/HG4PPNm0t73XWSusifZP3dd2WZ3VQzMta0du2kPe+84Ps+/LBYRTMygB9/FHHmX4Y2Sed79fIK0nPOEbF27BjwzTfSl50tS+92jlJDTpbHQYPk2n/9S47vuMNNVeRfJje+r3PnyvL8TTeFWidt/8lRo6Q11k1zbU4884xYPX//XY5tcZ0bKjIVRSnuqMiMFDuKQVHixMUXi8XuhhuCz8+aJQE6KSmS2sj/d1DdujKmSROxLI4eLf1t2gAPPSTnPvjA9Zk0PpzGMlq7thuYZKyiBmNlDaJFC2+EPSCJ23/5RSyoAwa4/T/+KK0/3yjgCtkhQ+S6qVMl6fr69cDOnd6xLVsCF1wgS/R33y3L/l995R1jW0WDgrWCrKbr17uJ7v1C0S90c0JFpqIoxR1VSZGilkylgDDlMINITQWuuir3exCJxW7QIDlOSpKAnBo1pI67EZXLlkmgSri/p+bPF9EFyNfho4/cc//+tzcn56hRXiFXq5YcJyVJwNPw4d57f/mltCbvKOAVsp995u6vWhUq8MqXF6vqgQPA559Ln98P0m+N9SeHnzbNG+AEiAW2XTv5+fndFvxC12bUKG+KqMJQz71xYzcFl6IoSrRRkRkpKjKVEkDNmqEWSJs2bYAGDdzjevXc/bZtxZJoaN3au4xul9skCq3QU7Om5NccOVKW1R991CsyzZI/IGU/bYGXmChfz1q1vPfs3FnGGmyROXas3N+uiLRhg9fKCrgpkr75Rv4ZsAmyZO7aJUv8Dz/s9WWNhyWT2S0SEMSKFSKkFUUpnBBReyJaT0TpRDQ84PxoIlrhbBuIaL91ricRbXS2nlb/xUS0yrnnWKKcku6dHCoyI0VFpqKEYAvHypVzHmsi3Q1ly7qlNMeOlbZqVRGgW7aI2LStuLagGzHCGwVvhJVfZDJLZH16uviI2pWWDMa/0rB8uWutBYBzz5V20aLcl8u3bwfOOCM47VI8LJm9ekUn/6eiKPGHiBIATADQAUBDAD2IqKE9hpkHM3MjZm4EYByA95xrUwE8CqA5gGYAHiUix+EILwLoA6C+s7WP1WdQkRkpmoxdUUIwfpo33RR+zLPPuknkbYhkiZw51Hpo8FsOu3YVf08guCa7X2QC4tNav76kdDKCMqdo/VWrJIjILLWbOWzeHCoU/SLTLI9PnRp6X5Pu6PBhsXDmFPDkZ+FC+Rkb/9VwvPGGtLYFWVGUIkMzAOnMnMHMRwFMA9A5h/E9ALzt7LcD8Ckz72XmfQA+BdCeiKoAKMfM3zAzA5gCII/1yvKPisxI0WTsihLIsWM5L8Hef7+bZii/2EnmAeDvf/fWJ/cns69QwZsOqVs3SQUFiL/o4sUSBJWXcpZbt4rgNMJy0yavyCxbVqLLs7MlMGjBAmD2bDkXJCBNGqfp00WMVqki97Qxllf/z2vmTLHcjhkTPNfjx73C8uDB0DH2ea0+pCiFkmoA7BIPW5y+EIioJoDaAIy3erhrqzn7ud4zGqhKihRdLleUQBITY/f3V5MmYr3r3VuO69Vzc1QCUiHIjxkLAP/5jySUf+cdOf7lF4nEz8nyapg4UfKJmmpGfktmzZoisJOSJDCoTRs3eX0QRmTagUWtWokIN9bSAweApUuB226TY5Pk3gQo2cv1S5a41tYGDYCLLnLP+QOaAK8/qtZSV5QCIZGIllrbXSdxr+4AZjDz8VxHxhEVmZGiIlNRCoQ6dYCXXhKBZb6CS5YAH38c7AdaqpSkalq4UI5r1JAk9SY3aEaG+ILOn+9G5vfrF3qfF1909xMSRGTay9XlyoVeYwfd+JfuV68GHn8cGDjQ7du6VWqp9+0rgtlURsrKkv5q1STFlBGFBw6IFfKTT4BmzSTP6b33ymdavdq976uvhlorbX/U/KReijVDh+acjF9RihHZzNzU2vy/+VsB2Mncqjt9QXSHu1Se07Vbnf283PPkYeZisZ166qkcV8qXZx4wIL7PVBQlV0RO5T5u27bQsS1ayPFHH7nngrZrr3X3+/SRdsqUnK+ZNYv56quZK1Zk7t8/57E5bbfdxty+veyffjrzNdfk/dotW5gzM+Wzpqd7z3Xrxnz4sPdn9NVXzPfdx3zggLd//37mzz5jXrny5N5VEHl9f4pS1AFwiHPQYTFMrQAAGh9JREFUNQASAWRAlsFLA/gewHkB484BsBkAWX2pADYBqOBsmwCkOue+BdACAAGYDaBjTvM4mU0tmZGigT+KUih56CGx9uVG5cqSBsm2mplgpHr1pJpPOO64w92/7TaxWN5+O9CxY+jYadPEAnnVVRKctHu3jDWYKk15ZckSiWwHxJJp+6TmRuvWEpy1bl1oFP2MGcCUKbKfkSHpni6/XCyozz3nHfvUU/J5LrxQkv/bnDihPp6KEg2YORvAPQDmAvgBwHRmXkNEjxNRJ2todwDTHOFqrt0L4AkAS5ztcacPAPoBeA1AOoAfIUIzZh+iWGxxt2SmpMif+IqiFBs2bmQeOZL5xAk5zs4Wy9/DDzOnpblWtsOHmS++mLlSJbHq2dxwgzuuTp3g5/z2m9diZ1tVq1bNn2Wzc2fm9evzd83AgWKl9PcnJDAvWsTcvHnoM2yaNnXP3X4785EjzAcPyjyqVmV+4AEZ98knzH375u8dmPuecw7z8uV5u2b9eubZs719ixczT5uWv2crSjxBLpbM4rCpJTNS1CdTUYod9eqJH6SxaCYkSH3zJ56QyHGTeD45WQJyduwIrcDUqJG0EyaElrE0lC0r9ddNLXfbl3TiRODpp/M+51atvAnxFy+WGvU58c47oRHv5crJP2stW8o97MTxa9dKe+yYWDWXLnXP/fQTcO21cv0VV0hw0tuOZ9h114n/rO2buns38Je/yM/4s8+8VaFs1q0DBg/O+XMYmjQBOnTwWmebNwe6d4/cqrp7N7BxY2TXKooiqMiMFBWZilKiKFUK+O47bzR4UJ2MBx+UJeR+/SQtUTjuuy94qTwtLX8J1KtW9R7XqSP5Q4cOdfuaNXPrsI8bJ+K4Wzc5vvhiGe/PpTl4sKRUevhhCXBasEDq3d9/v3fcjh1yzuyXLi115W1q1xYXgcxM2Z80Sfqvvlqi4ImAN98EHnvMe926dbl//qNH3SCmTz4J/RxbtoRekxfq1fOK9/xy/LiUHlWUkoyKzEhRn0xFKXGceqo3ZVIQiYl5qx8fjrS0/FnfKjg1PExEfMWK0p5/vrS1agFz50p+0AoVZNyQIe7106eL5fPYMbePSMRqrVqSp/PECVeU+tmxw3vcr5/02VbFLVtERA4fHuoLarj9dqnqFO7e+/aJdXX3bu/PZ8MGd797d4nMt1mzRkRyhw7iw+q/PhxBaZ/yQ9euYgVXlJJMTEVmHmpu9nXqZ64goq/scklENMK5bj0RtYvlPCNCk7ErihIDKlYUwdWihQiooNRIgKRhAiSoCBALZVaWa109+2xp27aVmuznny9pm0qVAv75T0lbNGGCm+DeXtI+4wzglFNk31RU2r0b6NJFco3+978SNNWwYagYa9lSWn8tesAtF5ofDh6UeaemStL6yZPlM5jE+36R++qr0p52mrTr1gF//SswZ44s41eqJO4ImzfLvXJbEp8zR3Kpmpr1eWXmTGlN7tJYMXYsMGxY9O5n/7FR0Jw44c3nqhRBYuXsCSABErVUB27ofUPfmHLWficAc5z9hs74UyCh+z8CSMjpeXEN/Dl+XDzTR46M3zMVRSnWdOwo/6yYoCNDlSrSP30684svyv6tt0pA0rx5Od9z2jQ3MCkz001fFIQ/CMimeXPm6tUlBZLNq696rylVivn335kvuSR80NHf/+49TklhPu208ONHjPAeN2ggbb16Moc33/SeP+MM6T/9dDkOSheVnMx81lneZwwe7H6uEyfcc+3aSTt8OPMPP8j5WbOYt2/P+Wdvrl+1KudxJ0s0Uz6ZNFybNkXnfobMTOajR/N/3ZAhMp8jR6I7n8ICNPDnpMi15iYz28XOUgCYRYzOkHD8I8y8CRJm3yyGc80fphyHLpcrihIlZsyQZWW/n6exMF52GXDXXcCoUWK9KlMm92X5W25xA5PKlMnb8m1yMvDAA96+RYuk1no1X/E5v+tA375i9fP7Vtpccom7//33EoB06aXhx/tLaprl8Xr1pN25U9qrr5a2enX5J9pYWCdMCL1nZqZUezIVop56ShL2Hz4swUjz57tjjSX5H/8Azj1XLJodO+bdJSIvfqWFhddflzbaAU/lykk6rPwybpy0J+u6oBQcsRSZeaq5SUT9iehHAM8AGJifawsMFZmKokSZ5ORQEQe4VX8qVpRl4gcfdP0uo8ldTkG7338PjW4nCg5y6tJF6qfv3y9R5mYJ+5prwj+nUiVpU1Ikz2bZskDduuHHr18f3G+qFO3cKX6wH34oy/dHjoSWyWzYMPR6ILT2+9SpIlaNYAXEPcCmSxdpTcR9OMxy/U03Ac8+G37ctGny8164MLjGfGamBJLt3QtccIEEnwHy+QcNcscdOQKsWhX8jIwMoH17bxnUIMzSftC7jpTjx2UJPqcSq+EwS/da9rToUuBOhcw8gZnrAhgG4OH8XEtEd5man9m2Q1GsMeGLKjIVRYkx/fvLgqjxkYwVL7wgUdr5cTUvU0aEzumnS7lOE8GemAgsWwbMmgX87W8iMD74QPwb09JkDFvBN0FR9snJ7r6dgB6QevQmanzHDvEhTUkRf9A1a9xnGHr0cPfXrgV69RL/zDp1vOPsEp82p5/uRsTbaan80ePp6eID27ixNwvB0KEyz/nzgTfekBRSmze7cxs+XCzVXbuGPnvQILnnG29IqdB77pH+Rx7x+ri2bSuiPcgH9JZbJPjr669Dz338saSZAlz/x3CWwzVrgNlO2u6KFUVA58ZPP7n7/sh/m6VLpbCB7RNqxsfakrlnT85zUyInMYb3zk/NTUCW00114Dxdy1Ln8xUASElJiV+NCWPJ1MAfRVGKCQkJEj0fLZo0kbZDB29/Vpa0bdq4fc0CnKEuvlgE3f/9H9C0qfR9+imwbZsItB07RBysWuWmcTKR9mY/LU2Wfm+/3c3dee657rKwH1s0li/vWtCysyXQqVcv7/iFC2X5/rffJLVTr15eEXr//SIOd++WfKb+ZejLLxehbn4m/upJgJtHdNs295kvvhgqcM1z9+8Xgf7553LtwIFuXlNbgP7yi1iRr79ejvv2dUVmOMuhyVjALFbRGTPcn0+zZiKmbUEPAD/84O5v3QqcdRYC6ddP/pgYMMANNjNES2RmZ8tmu43s2SO/J8OGibW3WbPofg9KOrFUSUsA1Cei2kRUGlL2aKY9gIjqW4fXATBfwZkAuhPRKURUG0B9SK3NwoEulyuKokREmTKy5PvOO27f2WdLEnqbc88Vf8bXXnP72raVkp5du8qSbs2aIkyM+CtfXtoLLxTx8L//Ae+/L6mYVq8Ov5wMuMvbxrppL7FnZXltCv36ibV23DgRZ0OHitD1J9/PznattEF+jl995QpMw7x5YlXu1UuW0UuXlv41a7zPN76ofn77TXKwXnmlWEHt++/e7e7XqAGcd573WiMyn3tOfFDDYedB3b0bWL5c3unChe75u+4SK+YXX7hjMzLC37N6dWmXLw89Z0TvggXeLAj5pXPnUAG51TFfPf20/MzCWbOVyIiZJZOZs4nI1NxMAPA6OzU3ASxl5pkA7iGitgCOAdgHoKdz7Roimg5gLYBsAP2Z+Xis5ppvVGQqiqJEjKmKZCCSKkC9e7t9lSu7aZj8nHeeCKHJk2Up2PiTGgtVnz5yzxo1ZDPPCPI1HD9elt5bthQfzZdeEiE7YoRr5Tvu+99n3DgRgx9+6Pb5KygBEliUliZJ4vNK27be4yuukNYI5MGDJUhp1qzg6/0/M1tY2yITcK2jgCwXG0G6dq18/iFDXBcIm02b3P2qVYEnn5R9k05q8mRJJfXrrzK2alXZt5/nx4h843Nqc+CABIm1aSOWTn8qrFdekT880tLkXWVnS2sE5dSpEnxkfmZZWe7vin9OQe9ROQkKOrw9WltcUxjt2CF5FcaPj98zFUVRijlnnumm5Pn88/xff/Ag84cfhqaBioQNG7xpj5iZu3ZlTk2V/datveeTkrzH9hzuu897zr898ojM2xwvXcpcu3bw2J07mcuUkf0aNZhHj8753vY2YIDMx2Ths7e9eyUFld23ZIn3Z2L6Z8zwjuvQQdrq1ZlPPTX03oMHSztsWPh3c/31MqZLFzk+etS9/rnnJG2USXk1eTLz6tUybvNm6W/Vinn+/NB3Zs/bbOvWuedef917rmXLSH5bIgOawkgJxHgIq0+moihK1HjlFbE4pacDrVvn//rTTgM6dYpOdLRZpgbEFxSQykgmKbupN9+8uQTPzJ/vrfduzyFcUInxNa1Y0ZtZ4OKLxZcziNRU1zp7553hUynVt5zRqlaVa3bvBr78MtiimJoaOs+PPnKXp2dazm7+6k+mrOiWLcHJ04019umnpfJTEObnum+fWInHj3fPHTjgWjgPHRI/3fPPF79Q46/57bfB6aqC2LRJgq2eeUYs6DaLFkVWNEAJQ0Gr3GhtcbVkbtkif/K8/HL8nqkoiqLEjexs5t69mVesCD4/cKD8N9Cnj7cfEEujzfbtzL16Mf/2G/O//y3Wt//9j/mJJ2T8lCnMv/7qtcDt2uUeT57sPWesnLNnuwtr9lanjlghzfH27ZJQv0IFOTZzz2lr3Fja004Ty2pu4889N/y59HR3v29f78/m0CHmc85xz194Yej1duJ8v9XRtl6WL+89f+IE88KF7rEpeJCbZRlgXrPmpH+FcgVqyVQCMcnG1CdTURSlWJKQIEFHF10UfN5YMi+80Nv/yy+SuN7mzDMlor1sWYl0r1lTcnEa39SKFSUNk01amgTN/P67mzTeYAKdmjaV69av9+ahXLPGvV9iojz/7LPFSgi4lscgRo4US/JTT8nxb7+5FldArKwGk7S/bl3g1luD71e6tAReGZKSpD16VNIhjR3rTVhv5mjzi5U1u3Fjd3/RIvFRNfij4seP9yb6v+UWea/PPecdZ8/P0LmzN8BJiZCCVrnR2uJmybT/LJo0KT7PVBRFUQoVEyfKfwMLFkR+j6NHmceNY87KkuMaNaTEpR+7zCWz+FTu2eMd8/vv3jFHjzLXrcv8zjty7C+/aTa/D+Xcue49Z89mXrbMPTdiBPOiRe7xF1+IP+aGDcz/+U/w/b/9Vu71wgtyXK4cc79+UhY0N2siwJyW5j2eOlUsmBs3Bo83FljA6yf70EPyc6xUKfSaw4e9xzfdxPzJJ5G/17yCEmDJLPAJRGuLm8isVs39TZwyJT7PVBRFUQoVu3aJcImkJnck2AIyCL8Q9ZOZyfzAA8x33OEVVN26eY8XLw691gQlrVjheosBzD//7I7ZupVDxBvA/OOP7hizXB20vfSSiE9/f4sW/Mcy+4YN7r2CgpcAcXEI6v/iC7nOuAwYl4MKFaQ/K8t9/sSJeXsnJ0tJEJm6XJ4ffv3VTaoFaIkARVGUEkpamqTuMcu/sWb8eLeWdxC5BTuVKSOBN/78l82bA998434OU+veplMnCbi56CLXTQDwBitVrRrsQZaa6u5feaX3nH2vv/7VTapvk5IibZs23mCmUqW8z3v/fVk6NzXtbVq1cosDmCT2pgCACfA65RQp4dq3b2hCeSVyVGTmB1M2waAJtRRFUZQ40L+/W1IyHI8+Gj5/pqFqVcmBaWjVSoSmEXPlygVfZ3JOJiRIpPnmzaEJVo4dE7uhXSPdvt+QId7k8KNHi/j917/k2Jx7+WVX/JkKQVWqhM7Jtvl06SK+ln6hW7my+Laaz2f8LDt2lPZhq5j1GWdINSW7pKlycpBYbIs+KSkpfOjQodg+5JFH3KyzQHBWWEVRFEUp5GRlSZCNEW/vvSeVi9ati451tmlTqV8fJDHGjAGef14SxScnu8Lw4EGp/DRwoKRDysiQQJ9p08TSGWSt7dMHWLzYLb85d66UhzRUrOhNQj9woFiEjx6V/iDxGi+I6DAzpxTcDGKPisz80KEDMGeOe7xggZsATFEURVEUABIVf+CAd0k9XmzYIMv7TZrI8r8ddX78uOTyNBWGCpKSIDJ1uTyvMHuXy8eMUYGpKIqiKAGULVswAhMAGjRwUzgdO+Y9l5BQOARmXiGi9kS0nojSiWh4mDE3E9FaIlpDRG85fVcS0QpryyKiLs65yUS0yTrXKOi+0SBmtcuLHSdOiOPIypXS2snCFEVRFEUpNBiR+ec/F+w8TgYiSgAwAcA1ALYAWEJEM5l5rTWmPoARAC5j5n1EdAYAMPN8AI2cMakA0gH817r9UGaeEevPoCIzryQkuL+tw4YBlSoV7HwURVEURQkkKUlKVYYLZCoiNAOQzswZAEBE0wB0BrDWGtMHwARm3gcAzLwz4D7dAMxm5oCin7FFl8sjQQWmoiiKohRqUlOl4lERphoAq94Rtjh9Ng0ANCCir4noGyJqj1C6A3jb1zeKiFYS0WgiOiV6U/aiIlNRFEVRFCX+JBLRUmu7K5J7AKgPoA2AHgBeJaLy5iQRVQFwAYC51jUjAJwD4BIAqQCGRTj/PE1OURRFURRFiS/ZzNw0h/NbAZxlHVd3+my2AFjMzMcAbCKiDRDRucQ5fzOA953zAABm3ubsHiGiSQCGnMRnyBG1ZCqKoiiKohQ+lgCoT0S1iag0ZNl7pm/MBxArJogoDbJ8nmGd7wHfUrlj3QQREYAuAFbHYvKAWjIVRVEURVEKHcycTUT3QJa6EwC8zsxriOhxAEuZeaZz7loiWgvgOCRqfA8AEFEtiCV0ge/WbxJRJQAEYAWAvrH6DJqMXVEURVEUJc5oMnZFURRFURRFiQAVmYqiKIqiKErUUZGpKIqiKIqiRB0VmYqiKIqiKErUUZGpKIqiKIqiRJ1iE11ORCcAZMbhUYkAsuPwHCW66Hsruui7K5roeyua6HuLH8nMXKyNfcVGZMYLIlqaS4Z+pRCi763oou+uaKLvrWii702JJsVaQSuKoiiKoigFg4pMRVEURVEUJeqoyMw/rxT0BJSI0PdWdNF3VzTR91Y00femRA31yVQURVEURVGijloyFUVRFEVRlKijIjOPEFF7IlpPROlENLyg56N4IaKziGg+Ea0lojVENMjpTyWiT4loo9NWcPqJiMY673MlETUp2E9QsiGiBCL6jog+do5rE9Fi5/28Q0Slnf5TnON053ytgpx3SYaIyhPRDCJaR0Q/EFFL/b4VDYhosPPv5GoiepuIyuh3TokFKjLzABElAJgAoAOAhgB6EFHDgp2V4iMbwP3M3BBACwD9nXc0HMA8Zq4PYJ5zDMi7rO9sdwF4Mf5TViwGAfjBOn4awGhmrgdgH4DeTn9vAPuc/tHOOKVgeB7AHGY+B8BFkPen37dCDhFVAzAQQFNmPh9AAoDu0O+cEgNUZOaNZgDSmTmDmY8CmAagcwHPSbFg5m3MvNzZ/w3yH141yHt6wxn2BoAuzn5nAFNY+AZAeSKqEudpKwCIqDqA6wC85hwTgKsAzHCG+N+beZ8zAFztjFfiCBGdDuAKABMBgJmPMvN+6PetqJAIIJmIEgGcCmAb9DunxAAVmXmjGoBfrOMtTp9SCHGWcxoDWAzgTGbe5pzaDuBMZ1/faeFhDIAHAJxwjisC2M/MpuqI/W7+eG/O+QPOeCW+1AawC8Akx83hNSJKgX7fCj3MvBXAswB+hojLAwCWQb9zSgxQkakUK4ioLIB3AdzLzAftcyypFDSdQiGCiP4EYCczLyvouSj5IhFAEwAvMnNjAIfgLo0D0O9bYcXxk+0M+UOhKoAUAO0LdFJKsUVFZt7YCuAs67i606cUIogoCSIw32Tm95zuHWZZzml3Ov36TgsHlwHoRESbIW4oV0F8/co7S3mA99388d6c86cD2BPPCSsAxNK1hZkXO8czIKJTv2+Fn7YANjHzLmY+BuA9yPdQv3NK1FGRmTeWAKjvRN+VhjhJzyzgOSkWjo/QRAA/MPNz1qmZAHo6+z0BfGj1/9mJem0B4IC1zKfECWYewczVmbkW5Hv1GTPfBmA+gG7OMP97M++zmzNerWVxhpm3A/iFiM52uq4GsBb6fSsK/AygBRGd6vy7ad6dfueUqKPJ2PMIEXWE+I4lAHidmUcV8JQUCyK6HMCXAFbB9e17EOKXOR1ADQA/AbiZmfc6/7iOhywTHQbQi5mXxn3iyh8QURsAQ5j5T0RUB2LZTAXwHYDbmfkIEZUB8G+Iz+1eAN2ZOaOg5lySIaJGkGCt0gAyAPSCGC70+1bIIaLHANwCycrxHYA7Ib6X+p1TooqKTEVRFEVRFCXq6HK5oiiKoiiKEnVUZCqKoiiKoihRR0WmoiiKoiiKEnVUZCqKoiiKoihRR0WmoiiKoiiKEnVUZCqKUiIgouNEtMLahud+VZ7vXYuIVkfrfoqiKMWBxNyHKIqiFAsymblRQU9CURSlpKCWTEVRSjREtJmIniGiVUT0LRHVc/prEdFnRLSSiOYRUQ2n/0wiep+Ivne2S51bJRDRq0S0hoj+S0TJBfahFEVRCgEqMhVFKSkk+5bLb7HOHWDmCyBVacY4feMAvMHMFwJ4E8BYp38sgAXMfBGkXvcap78+gAnMfB6A/QBujPHnURRFKdRoxR9FUUoERPQ7M5cN6N8M4CpmziCiJADbmbkiEe0GUIWZjzn925g5jYh2AajOzEese9QC8Ckz13eOhwFIYuYnY//JFEVRCidqyVQURQE4zH5+OGLtH4f6vCuKUsJRkakoigLcYrWLnP2FALo7+7cB+NLZnwfgbgAgogQiOj1ek1QURSlK6F/aiqKUFJKJaIV1PIeZTRqjCkS0EmKN7OH0DQAwiYiGAtgFoJfTPwjAK0TUG2KxvBvAtpjPXlEUpYihPpmKopRoHJ/Mpsy8u6DnoiiKUpzQ5XJFURRFURQl6qglU1EURVEURYk6aslUFEVRFEVRoo6KTEVRFEVRFCXqqMhUFEVRFEVRoo6KTEVRFEVRFCXqqMhUFEVRFEVRoo6KTEVRFEVRFCXq/D+E3fJUzYZF5wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 720x360 with 0 Axes>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 720x360 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#########\n",
    "# MAKE TRAINING STATS\n",
    "#########\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['figure.figsize'] = [10, 5]\n",
    "\n",
    "training_stats = pickle.load(open(\"data/pickles/train_stats.pkl\", 'rb'))\n",
    "\n",
    "# Make Training Plots\n",
    "loss_tr = np.array(training_stats['loss_tr'])\n",
    "correct_tr = np.array(training_stats['correct_tr'])\n",
    "\n",
    "epoch = np.arange(loss_tr.shape[0])\n",
    "ax = plt.subplot(1, 1, 1)\n",
    "ax.plot(epoch, loss_tr, label = \"Training Loss\", color = \"blue\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Loss\")\n",
    "# Accuracy (right)\n",
    "ax2 = ax.twinx()\n",
    "ax2.plot(epoch, correct_tr, label = \"Training Accuracy\", color = \"red\")\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title(\"Training Statistics\")\n",
    "# for generating plots to be included in the report\n",
    "# plt.savefig(\"training_stats.png\")\n",
    "plt.show()\n",
    "plt.figure()\n",
    "\n",
    "# Make Testing Plots\n",
    "# Make Training Plots\n",
    "loss_ge = np.array(training_stats['loss_ge'])\n",
    "correct_ge = np.array(training_stats['correct_ge'])\n",
    "epoch = np.arange(loss_ge.shape[0])\n",
    "ax = plt.subplot(1, 1, 1)\n",
    "ax.plot(epoch, loss_ge, color = \"blue\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Loss\")\n",
    "# Accuracy (right)\n",
    "ax2 = ax.twinx()\n",
    "ax2.plot(epoch, correct_ge, color = \"red\")\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title(\"Generalization Statistics\")\n",
    "# for generating plots to be included in the report\n",
    "# plt.savefig(\"generalization_stats.png\")\n",
    "plt.show()\n",
    "plt.figure()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}