Tree-Cycles.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('./codes/')\n",
    "from config import args\n",
    "\n",
    "args.dataset='syn3'\n",
    "args.elr = 0.003\n",
    "args.eepochs = 20\n",
    "args.coff_size = 0.0001\n",
    "args.budget = -1\n",
    "args.coff_ent = 0.01\n",
    "\n",
    "\n",
    "import tensorflow as tf\n",
    "from utils import *\n",
    "from models import GCN\n",
    "from metrics import *\n",
    "import numpy as np\n",
    "from Extractor import Extractor\n",
    "from Explainer import Explainer\n",
    "from scipy.sparse import coo_matrix,csr_matrix\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import roc_auc_score\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "explainer\n"
     ]
    }
   ],
   "source": [
    "with open('./dataset/' + args.dataset + '.pkl', 'rb') as fin:\n",
    "    adj, features, y_train, y_val, y_test, train_mask, val_mask, test_mask, edge_label_matrix  = pkl.load(fin)\n",
    "\n",
    "adj = csr_matrix(adj)\n",
    "support = preprocess_adj(adj)\n",
    "\n",
    "features_tensor = tf.convert_to_tensor(features,dtype=tf.float32)\n",
    "support_tensor = tf.SparseTensor(*support)\n",
    "support_tensor = tf.cast(support_tensor,tf.float32)\n",
    "\n",
    "model = GCN(input_dim=features.shape[1], output_dim=y_train.shape[1])\n",
    "model.load_weights(args.save_path+ args.dataset)\n",
    "\n",
    "explainer = Explainer(model=model)\n",
    "embeds = model.embedding((features_tensor,support_tensor)).numpy()\n",
    "\n",
    "all_label = np.logical_or(y_train,np.logical_or(y_val,y_test))\n",
    "single_label = np.argmax(all_label,axis=-1)\n",
    "hops = len(args.hiddens.split('-'))\n",
    "extractor = Extractor(adj,features,edge_label_matrix,embeds,all_label,hops)\n",
    "if args.setting==1:\n",
    "    if args.dataset=='syn3':\n",
    "        allnodes = [i for i in range(511,871,6)]\n",
    "    elif args.dataset=='syn4':\n",
    "        allnodes = [i for i in range(511,800,1)]\n",
    "    else:\n",
    "        allnodes = [i for i in range(400,700,5)] # setting from their original paper\n",
    "elif args.setting==2:\n",
    "    allnodes = [i for i in range(single_label.shape[0]) if single_label[i] ==1]\n",
    "elif args.setting==3:\n",
    "    if args.dataset == 'syn2':\n",
    "        allnodes = [i for i in range(single_label.shape[0]) if single_label[i] != 0 and single_label[i] != 4]\n",
    "    else:\n",
    "        allnodes = [i for i in range(single_label.shape[0]) if single_label[i] != 0]\n",
    "\n",
    "optimizer = tf.keras.optimizers.Adam(learning_rate=args.elr)\n",
    "clip_value_min = -2.0\n",
    "clip_value_max = 2.0\n",
    "\n",
    "sub_support_tensors = []\n",
    "sub_label_tensors = []\n",
    "sub_features = []\n",
    "sub_embeds = []\n",
    "sub_adjs = []\n",
    "sub_edge_labels = []\n",
    "sub_labels = []\n",
    "remap = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "for node in allnodes:\n",
    "    sub_adj,sub_feature, sub_embed, sub_label,sub_edge_label_matrix = extractor.subgraph(node)\n",
    "    remap[node]=len(sub_adjs)\n",
    "    sub_support = preprocess_adj(sub_adj)\n",
    "    sub_support_tensor = tf.cast(tf.SparseTensor(*sub_support),tf.float32)\n",
    "    sub_label_tensor = tf.convert_to_tensor(sub_label,dtype=tf.float32)\n",
    "\n",
    "    sub_adjs.append(sub_adj)\n",
    "    sub_features.append(tf.cast(sub_feature,tf.float32))\n",
    "    sub_embeds.append(sub_embed)\n",
    "    sub_labels.append(sub_label)\n",
    "    sub_edge_labels.append(sub_edge_label_matrix)\n",
    "    sub_label_tensors.append(sub_label_tensor)\n",
    "    sub_support_tensors.append(sub_support_tensor)\n",
    "best_auc = 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def plot(node,label):\n",
    "    after_adj_dense = explainer.masked_adj.numpy()\n",
    "    after_adj = coo_matrix(after_adj_dense)\n",
    "\n",
    "    rcd = np.concatenate([np.expand_dims(after_adj.row,-1),np.expand_dims(after_adj.col,-1),np.expand_dims(after_adj.data,-1)],-1)\n",
    "    pos_edges = []\n",
    "    filter_edges = []\n",
    "    edge_weights = after_adj.data\n",
    "    sorted_edge_weights = np.sort(edge_weights)\n",
    "    thres_index = max(int(edge_weights.shape[0]-12),0)\n",
    "    thres = sorted_edge_weights[thres_index]\n",
    "    filter_thres_index = min(thres_index,max(int(edge_weights.shape[0]-edge_weights.shape[0]/2),edge_weights.shape[0]-100))\n",
    "    # filter_thres_index = min(thres_index,max(int(edge_weights.shape[0]-edge_weights.shape[0]/4),edge_weights.shape[0]-100))\n",
    "    filter_thres = sorted_edge_weights[filter_thres_index]\n",
    "    filter_nodes =set()\n",
    "\n",
    "    # print(sorted_edge_weights)\n",
    "#     print('thres',thres)\n",
    "    for r,c,d in rcd:\n",
    "        r = int(r)\n",
    "        c = int(c)\n",
    "        if d>=thres:\n",
    "            pos_edges.append((r,c))\n",
    "        if d>filter_thres:\n",
    "            filter_edges.append((r,c))\n",
    "            filter_nodes.add(r)\n",
    "            filter_nodes.add(c)\n",
    "\n",
    "    num_nodes = sub_adj.shape[0]\n",
    "    G = nx.Graph()\n",
    "    G.add_nodes_from(range(num_nodes))\n",
    "    G.add_edges_from(filter_edges)\n",
    "\n",
    "    for cc in nx.connected_components(G):\n",
    "        if 0 in cc:\n",
    "            G = G.subgraph(cc).copy()\n",
    "            break\n",
    "\n",
    "    pos_edges = [(u, v) for (u, v) in pos_edges if u in G.nodes() and v in G.nodes()]\n",
    "    pos = nx.kamada_kawai_layout(G)\n",
    "\n",
    "    colors = ['orange', 'red', 'green', 'blue', 'maroon', 'brown', 'darkslategray', 'paleturquoise', 'darksalmon',\n",
    "              'slategray', 'mediumseagreen', 'mediumblue', 'orchid', ]\n",
    "    if args.dataset=='syn3':\n",
    "        colors = ['orange', 'blue']\n",
    "\n",
    "\n",
    "    if args.dataset=='syn4':\n",
    "        colors = ['orange', 'black','black','black','blue']\n",
    "\n",
    "\n",
    "    # nodes\n",
    "    labels = label#.numpy()\n",
    "    max_label = np.max(labels)+1\n",
    "#     print(max_label)\n",
    "\n",
    "    nmb_nodes = after_adj_dense.shape[0]\n",
    "    label2nodes= []\n",
    "    for i in range(max_label):\n",
    "    \tlabel2nodes.append([])\n",
    "    for i in range(nmb_nodes):\n",
    "    \tlabel2nodes[labels[i]].append(i)\n",
    "\n",
    "    for i in range(max_label):\n",
    "        node_filter = []\n",
    "        for j in range(len(label2nodes[i])):\n",
    "            if label2nodes[i][j] in G.nodes():\n",
    "                node_filter.append(label2nodes[i][j])\n",
    "        nx.draw_networkx_nodes(G, pos,\n",
    "                               nodelist=node_filter,\n",
    "                               node_color=colors[i % len(colors)],\n",
    "                               node_size=500)\n",
    "\n",
    "    nx.draw_networkx_nodes(G, pos,\n",
    "                           nodelist=[0],\n",
    "                           node_color=colors[labels[0]],\n",
    "                           node_size=1000)\n",
    "\n",
    "    nx.draw_networkx_edges(G, pos, width=7, alpha=0.5, edge_color='grey')\n",
    "\n",
    "    nx.draw_networkx_edges(G, pos,\n",
    "                           edgelist=pos_edges,\n",
    "                           width=7, alpha=0.5)\n",
    "\n",
    "\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "#     plt.savefig('./vis/'+args.dataset+'/P'+str(node)+'.png')\n",
    "    plt.clf()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train():\n",
    "    print('extract sub graphs done')\n",
    "    t0 = args.coff_t0\n",
    "    t1 = args.coff_te\n",
    "    epochs = args.eepochs\n",
    "    for epoch in range(epochs):\n",
    "        train_accs = []\n",
    "        loss = 0\n",
    "        pred_loss = 0\n",
    "        lap_loss = 0\n",
    "        tmp = float(t0*np.power(t1/t0,epoch/epochs))\n",
    "        tmp = 5.0\n",
    "        with tf.GradientTape() as tape:\n",
    "            for i in range(len(allnodes)):\n",
    "                output = model.call((sub_features[i],sub_support_tensors[i]),training=False)\n",
    "                train_acc = accuracy(output, sub_label_tensors[i])\n",
    "                train_accs.append(float(train_acc))\n",
    "                pred_label = tf.argmax(output, 1)\n",
    "\n",
    "                x = sub_features[i]\n",
    "                adj = sub_adjs[i]\n",
    "                nodeid = 0\n",
    "                embed = sub_embeds[i]\n",
    "                pred = explainer((x,adj,nodeid,embed,tmp),training=True)\n",
    "                l,pl,ll = explainer.loss(pred, pred_label, sub_label_tensor, 0)\n",
    "                loss += l\n",
    "                pred_loss += pl\n",
    "                lap_loss += ll\n",
    "            train_variables = []\n",
    "            for para in explainer.trainable_variables:\n",
    "                if para.name.startswith('explainer'):\n",
    "                    train_variables.append(para)\n",
    "        grads = tape.gradient(loss, train_variables)\n",
    "        cliped_grads = [tf.clip_by_value(t, clip_value_min, clip_value_max) for t in grads]\n",
    "        optimizer.apply_gradients(zip(cliped_grads, train_variables))\n",
    "\n",
    "        print('pred_loss_mean',np.mean(pred_loss.numpy()))\n",
    "\n",
    "        explainer.save_weights(args.save_path + 'expaliner_'+args.dataset)\n",
    "\n",
    "\n",
    "reals = []\n",
    "preds = []\n",
    "def acc(sub_adj,sub_edge_label):\n",
    "    real = []\n",
    "    pred = []\n",
    "    sub_edge_label = sub_edge_label.todense()\n",
    "    mask = explainer.masked_adj.numpy()\n",
    "    for r,c in list(zip(sub_adj.row,sub_adj.col)):\n",
    "        d = sub_edge_label[r,c] + sub_edge_label[c,r]\n",
    "        if d==0:\n",
    "            real.append(0)\n",
    "        else:\n",
    "            real.append(1)\n",
    "        pred.append(mask[r][c]+mask[c][r])\n",
    "    reals.extend(real)\n",
    "    preds.extend(pred)\n",
    "\n",
    "    if len(np.unique(real))==1 or len(np.unique(pred))==1:\n",
    "        return -1\n",
    "    return roc_auc_score(real,pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def explain_test(node,needplot=True):\n",
    "    newid = remap[node]\n",
    "    sub_adj, sub_feature, sub_embed, sub_label, sub_edge_label =  sub_adjs[newid],sub_features[newid],sub_embeds[newid],sub_labels[newid],sub_edge_labels[newid]\n",
    "\n",
    "    nodeid = 0\n",
    "    explainer((sub_feature,sub_adj,nodeid,sub_embed,1.0),training=False)\n",
    "    label = np.argmax(sub_label,-1)\n",
    "    if needplot:\n",
    "        plot(node,label)\n",
    "    acc(sub_adj,sub_edge_label)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "extract sub graphs done\n",
      "pred_loss_mean 0.45032197\n",
      "pred_loss_mean 0.43228906\n",
      "pred_loss_mean 0.30744252\n",
      "pred_loss_mean 0.29131055\n",
      "pred_loss_mean 0.51852596\n",
      "pred_loss_mean 0.23597619\n",
      "pred_loss_mean 0.18589483\n",
      "pred_loss_mean 0.16831325\n",
      "pred_loss_mean 0.03771505\n",
      "pred_loss_mean 0.04262153\n",
      "pred_loss_mean 0.08178485\n",
      "pred_loss_mean 0.07881756\n",
      "pred_loss_mean 0.04426924\n",
      "pred_loss_mean 0.07843521\n",
      "pred_loss_mean 0.02366048\n",
      "pred_loss_mean 0.030991154\n",
      "pred_loss_mean 0.043784387\n",
      "pred_loss_mean 0.0314185\n",
      "pred_loss_mean 0.053820506\n",
      "pred_loss_mean 0.018783744\n"
     ]
    }
   ],
   "source": [
    "train()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f2de5381908>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "explainer.load_weights(args.save_path + 'expaliner_'+args.dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "node  511 auc 1.0\n",
      "node  517 auc 1.0\n",
      "node  523 auc 1.0\n",
      "node  529 auc 1.0\n",
      "node  535 auc 1.0\n",
      "node  541 auc 1.0\n",
      "node  547 auc 1.0\n",
      "node  553 auc 1.0\n",
      "node  559 auc 1.0\n",
      "node  565 auc 1.0\n",
      "node  571 auc 0.9997578692493946\n",
      "node  577 auc 0.9997975708502024\n",
      "node  583 auc 0.9998311381290105\n",
      "node  589 auc 0.9998575498575498\n",
      "node  595 auc 0.999875249500998\n",
      "node  601 auc 0.9998910675381264\n",
      "node  607 auc 0.9999004380724811\n",
      "node  613 auc 0.9999086257309941\n",
      "node  619 auc 0.9998768472906404\n",
      "node  625 auc 0.9996683372641509\n",
      "node  631 auc 0.9996668443496801\n",
      "node  637 auc 0.9996907854050711\n",
      "node  643 auc 0.9997109993641986\n",
      "node  649 auc 0.999624060150376\n",
      "node  655 auc 0.9996483825597751\n",
      "node  661 auc 0.9996691245982228\n",
      "node  667 auc 0.9996880570409982\n",
      "node  673 auc 0.9997064743374706\n",
      "node  679 auc 0.9997232982844493\n",
      "node  685 auc 0.9997432134996332\n",
      "node  691 auc 0.9997561994984675\n",
      "node  697 auc 0.9997682119205299\n",
      "node  703 auc 0.9996985849355923\n",
      "node  709 auc 0.9991285272109866\n",
      "node  715 auc 0.9990909090909091\n",
      "node  721 auc 0.9990567869725636\n",
      "node  727 auc 0.9989686905013752\n",
      "node  733 auc 0.9990098758536646\n",
      "node  739 auc 0.9989845852703695\n",
      "node  745 auc 0.9985644257703081\n",
      "node  751 auc 0.9985577789796286\n",
      "node  757 auc 0.9985196795541624\n",
      "node  763 auc 0.9984786486202918\n",
      "node  769 auc 0.9984776519303373\n",
      "node  775 auc 0.9984455455163704\n",
      "node  781 auc 0.9983671171171171\n",
      "node  787 auc 0.9981450283174421\n",
      "node  793 auc 0.9982056794147222\n",
      "node  799 auc 0.9980168027848441\n",
      "node  805 auc 0.998079447658871\n",
      "node  811 auc 0.998095088161209\n",
      "node  817 auc 0.9980057543881015\n",
      "node  823 auc 0.9980240371806638\n",
      "node  829 auc 0.9980204149210326\n",
      "node  835 auc 0.9980014534883721\n",
      "node  841 auc 0.997950458092976\n",
      "node  847 auc 0.9979523259477056\n",
      "node  853 auc 0.9979729384080213\n",
      "node  859 auc 0.9979758839259185\n",
      "node  865 auc 0.9979691161449258\n",
      "mean acc 0.9979691161449258\n"
     ]
    }
   ],
   "source": [
    "\n",
    "reals= []\n",
    "preds = []\n",
    "for node in allnodes:\n",
    "    explain_test(node,needplot=False)\n",
    "    auc = roc_auc_score(reals, preds)\n",
    "    print('node ',node, 'auc',auc)\n",
    "\n",
    "print('mean acc',auc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3dfZgkVX0v8O851e9V3T27Ayy4KzuLO91diEbjJgTjVdS9N+g1MeSKMZgYMJBEDZGX5WVRGJaAaJBFJTE3UQRvEniC3Ih5TGISzDVGQjCby428VHfPALOwCwI7u9PdVf1e59w/uobsLlu181J9unvm93meffaRX033z92d75w+deocJqUEIYQQNfigGyCEkLWEQpcQQhSi0CWEEIUodAkhRCEKXUIIUYhClxASiDGMM4YrGcMTjKHFGGqMoeL93vb++5WMYf2gex0FjJaMEUKOhTHEAEwBuByAAJAKuLyO3iBuN4BdUqLd/w5HE4UuIeRVGMOpAB4EsBHBYXu0OoD9ALZLiWf70duoo9AlhBzBC9w9ANYD0JbxEi6AgwC2UfC+GoUuIeQV3pTC4wBOw/ICd4EL4GkAr5cSnTB6Wy3oRhoh5HBT6E0prCRw4X39awBcv+KOVhka6ZKRwBgiACYAJAA0AcxKie5Am1plGMM4gH3o/RmHpQlgo5Q4GOJrjjQa6ZKhdfhSJQAOgEcBPOT9XqelSqH7KHqrFMIkvNclHhrpkqFDS5X6Y2JigiWTyfVSytcIIcallCdIKdcJIdZJKbPPPvvwbwtxcj9+gD0hJc7ow+uOJApdMlRoqZI/LzSzADYIIU6UUo4LIdZ7wZmVUmaEEGNCCF1KaQghkkKIlJQyLoRISClj8Pl0K2UEhw49txmI9aP1NgCdpoN6IoNugJAFK1yqlELvjvsexoZ3qVKhUEgxxjYIIU6SUo5LKdcLIdYLIcaklBkpZVYIYXi/UlLKlBeYcSFEvFarrfQG1zEJsSUCdCUQY314+Q568/EzfXjtkUOhS4aCN6XwIJa/NhTe160H8CBj/VmqlMvlIpqmneyNNE+UUq73gnPM+5ieFkKkpZS6EEIXQiSllEkhREIIEceQfs9JmWDhT+e+wkW4N+dG2lD+AyBrUj+WKl13dHFiYoIlEokT0fuIfvi85vjCR3QvOHXvY3rKC8yklDLufURfdRhryj7eV9fQW8VAQHO6ZAj0Z6lSW2zYcOY/MvbjiPcxPSmEiEspo6BVO69Cc7rq0D8+Mgz6sFTJZZXKeW9pt9tbut3uBtd1M1LKOOjf/DEx1gXnz/brybFpCtz/RNMLZBhcgKWtVFiEJGu3P2ikUrdVw33dkdfhnLc55w3GWINzXvd+2e32w6+z7c3bgGg0xPerA7grxNcbeTS9QAbKe9LMQV8+17axbt1r9zK2qgZZLue8xRhrcs4bXnjWOec257zGGKsxxqqc8znO+TxjbI4xdoBz/rKU8sfFYrHl98LeQyb7QU+k9RWNdMmgTaA359eH0O1KIbZENG16mFLXZYy1OectznnTC8w659xhjNmc8ypjrMI5n+ecH/JCc45z/jKAFxuNhj07O9uXkZKUOMgYdgO4FOF88qgD2E2BeyQKXTJoCfRtrZLwlkKFizHW8kabjcOC0+Gc215wHloIzoXQ1DTtAHqhebBfoRmSXQDOw4p3GRMC4PsB3BhOW6sHhS4ZtCb6dnOLe0uhjsQYa3ujzebR85qMsar38bzihefCaPNlzvnLruu+XC6Xh2nkHCop0WYM27Gi/XS7YKwm4vFn3tdo/CRt63gUCl0yaLPo0zolIC7Gx+s7NW385cXOaxJASjzLGLZhWY9j1yXnL7np9C/9eGzs4CeA2U/2qc2RRTfSyMB5u4id3oeXpo1WVsB7SvB6AFfguBsPNSTAkEh8tZpM3jTPWAcAuieccMKHSqXSHhX9jgpas0iGwd3o3XQJEy1VWiEp0ZYSn0ZvtDsF4An0bno6AKq937uC85lOIrF7fmzsDftSqamFwAWASLVa/dzExEQ/9nMYWTTSJQNHS5VGx9GbyW/c+JsvttsP/LPrumN+XzM2NvaFp5566guqehx2NNIlA+cF426EN9qtA/g8BW74pERXSsxIicelxMy+fX9Sy2aznw36mmq1enGhUDhJVY/Djka6ZCj05g/bJYBPrPD+Lh2IOACbNm16oNFovMmvnkqlHnruuec+rLKnYUUjXTIUpER7w4b3/l/GKgLLf0x/4ejv7RS4aqXT6csYY76rQur1+lm5XO4clT0NKwpdMhRM0zy903n0TZnMf32e833d3t3wJXHQG+EO7Qbmq5llWc+k0+l7Ay7hlUplVy6XW/PLVCl0yVCwbfs6AJqm7XWz2bP2x+NfqwJNuYjwraN30+x29KYUKHAHJBqN3hSNRl/wq3e73Q2dTmeXyp6GEc3pkoHL5/NvPHDgwDdx1NNPQqznzeaFRqfz4bjrnhoBWAe9KQQNQBTANHrLwu6im2bDIZfLnT03N/c1+AzoGGPtE0888ectyyopbm1oUOiSgdu0adP9jUZjm199/fr1O2Zmph/AYUuVAMzSHq3D6dRTT73LcZx3+tUTicST+/fvf6/KnoYJTS+Qgcrn82c2Go2f9KvHYrGnp6en7z96qRIF7vDSdX0H59z2qzebzdO3bt16ocqehgmFLhkox3F2IuDfYTqd3q2wHRICy7LmstnsHUHXVKvVy0zTTKvqaZhQ6JKByefzb2s0Gm/0q8fj8elyufxtlT2RcHS73T+Jx+O+87au62bq9frnVfY0LCh0ycDYtn0tAv4NGoZxq8J2SIhmZ2dlJpPZAfivl7Zte3s+n3+bwraGAoUuGYhcLvfuZrPpu7NYPB63yuXy36vsiYSrWCw+lk6nHwi4RKtUKrestQ1xKHTJQNi2fVVAWRiGcYuyZkjfJBKJT0cikQN+9U6n81rO+U6VPQ0ahS5RLpfLvbfVauX96olE4vFyufx9lT2R/igWi61sNvt7QddUq9WPmKa5WVVPg0ahS5Sr1WpXBJSFYRg3K2uG9F25XP5WKpV6xK8upUzUarXbVPY0SBS6RKnJyclz2+326/zqyWTy0VKp5PsNSkaTYRhXMMYafvVGo7FtcnLyAyp7GhQKXaLMxMQEs2370oBLXF3Xb1LWEFHGsqx9mUwm8CSPSqVybaFQiKvqaVAodIky0Wj0l9vttu/cXSqV2lMqlR5V2RNRRwhxaywW2+tXd113fbPZXPU3UCl0iRITExOsVqtdEnAJjXJXOW/t7jXobVp0TLVa7Rfy+bzvAzOrAYUuUSIajX6k0+ls9KunUql/LRaLj6nsiahXKpUeNgzj7wIuidRqtd2ree0uhS7pO2+U+7GAS7qGYdyorCEyUKlU6mpN0+b96q1Wa6umaR9X2ZNKFLqk7yKRyEWdTudkv7qu6/+8lvdXXWssy6pls9nAfReq1erHTdMcV9WTShS6pK+8Ue7FAZd0dF2/QVU/ZDhMT0//WSKR8J1OEkLojuPcrrInVSh0SV9pmnZJt9v1PX7bMIx/tCzL9442Wb0ymcxljLG2X91xnLflcrn/prInFSh0Sd/kcrlIrVa7wK/OGGunUqnAR0TJ6mVZ1kw6nf6LgEt4tVq9cbUdZkmhS/qm2+1e6rruer+6ruv/YFnWPpU9keESjUZ3RaPRH/vVO53OyZ1OZ0plT/1GoUv6olAoxG3b/lW/OmOslUwm1/zJsGtduVzuZjKZ6wEIv2tqtdovm6a5VWFbfUWhS/qi3W5f4brumF/dMIy/KRaLL6nsiQyncrn897qu/8CvLqWMVavVVXNTjUKXhK5QKKRqtdqv+NUZY41kMklPn5FX6Lp+Gefc8as3m803TE5O+n5yGiUUuiR0rVbrKiGE76GDhmF827KsOZU9keFmWdZcJpP5ctA1lUplx2o4zJJCl4TKNM20bdvn+dU5504ymaSnz8iruK775Xg8PhNQH6vX659T2VM/UOiSUDWbzWuEELpf3TCMv7Qsq6ayJzIaZmdnZTqdvhxA1+8a27Z/Lp/Pn6WwrdBR6JLQmKY5Ztv2uX51zrkdj8dX/dZ9ZPlKpdKP0un0XwVcolWr1c+O8oY4FLokNI1G49NCiJRf3TCM+4rFYl1lT2T0JBKJnZFIxHfOv91ub+acX6mypzBR6JJQmKY5btv2+/zqmqZV4/H4yM/Hkf4rFoutTCYTuLqlWq1eaJrmJlU9hYlCl4Si0WhcL6VM+NUNw7inWCy2VPZERtf09PQ3k8nkHr+6lDJp2/ZIHmZJoUtWzDTNU2zbPsevrmnaoUgkEriVHyFHS6fTVzDGmn71er1+Zi6Xe7/KnsJAoUtWrF6vXyel9D1QMJ1O/2m5XPa9I03IsViWtTeTyfyvoGsqlcp1o3aYJYUuWRHTNDc5jrPdrx6JROY0TfuSyp7I6iGEuCUajT7nV+92uyc0m82bVfa0UhS6ZEXq9fqUlDLmV0+n03fSKJcs1+zsrMxmszsRfJjl+wuFwhsUtrUiFLpk2UzT3GLb9tl+9Ugk8mK32/0jhS2RVahUKv3AMIwHAy6JVqvVz4/K2l0KXbJsjuNMAYj61dPp9FdmZ2elwpbIKpVKpXZomlb1q7darXwkEvlNlT0tF4UuWRbTNPOO4/wXv3o0Gn2h2+3eqbInsnpZllXLZDKB2ztWKpVLRuEwSwpdsiy2bU8B0Pzq6XT6D2mUS8I0MzNzVyKReNKvLoQwHMcZ+qWJFLpkyQqFwhvq9fqZfvVoNPpcp9P5c5U9kbVhEYdZviOXy71bZU9LRaFLlsy27esQPMq9g0a5pB8syyql0+lvBFzCq9XqTcN8mCWFLlmSfD6/rdFovMWvHovFnpmenr5PZU9kbYlGo1ORSORFv3qn0zml0+l8WmVPS0GhS5bEcZxPIXiU+wWF7ZA1qFwud7PZ7BSCD7P8FdM0tyhsa9EodMmi5fP5sxqNxk/41ePx+Ey5XP6Wyp7I2lQul7+TSqUe9qtLKeO1Wm0oD7Ok0CWLZtv2tQj4N2MYxtDfOSarx/EOs2w0Gm+anJz8sMqeFoNClyxKLpc7u9ls+j5qGY/Hi+Vy+TsqeyJrW7FYfCmTyXwl6JpKpXJloVDw3Vh/ECh0yaLYtn11UN0wjM+q6oWQBa7rfjEWiz0VUB9rNBq/r7Kn46HQJceVy+XOabVapl89kUg8Vi6Xv6ewJUIA9DbEyWQyVyP4MMv35PN533XlqlHokuOybXtHQFkYhvEZZc0QcpRSqbQnnU7/dcAlQ3WYJYUuCZTL5d7XarW2+tWTyeR/lEol37vIhKiQSCR2app2yK/ebre3aJp2mcqe/FDokkC1Wu2KgLKr6/pIbSBNVqdisVjPZrO3BF1TrVYvMk3zFFU9+aHQJb4mJyc/2G63fReYJ5PJfy+VSr6HBxKi0vT09H3JZPJRv7oQIjUMh1lS6JJjmpiYYLVa7ZKAS1zDMH5PWUOELEI6nb6cMeZ76nS9Xn9rLpd7n8qejkahS44pGo1+uNPpvNavnkqlHikWi4+p7ImQ47Es65l0On28wyyvH+RhlhS65FW8Ue4nAi7pGoaxS1lDhCyBlPIz0Wh0v1+92+2e1Gw2B/bvl0KXvEokEvmNTqfje8NB1/V/sSyrpLInQhbLW7sbeJilbdu/ZJrm6QrbegWFLjmCN8q9OOCSjq7rU8oaImQZyuXy93Vd/55fXUoZq1QqA7mpRqFLjhCJRD7W7XY3+NUNw/ieZVnPqOyJkOXQdf0KznnNr95qtcytW7depLIngEKXHCaXy0Vqtdpv+NUZY+1UKkVzuWQkWJY1n81mvxR0TaVS+aRpmmOqegIodMlhXNf9nW6363uaqq7rD1qWtU9lT4SsxMzMzFfi8bjlVxdCpOv1+q0qe6LQJQBeGeX+ul+dMdZKpVK0LpeMnGw2ewWAjl/dtu135XK5t6vqh0KXAAC63e4O13XX+dUNw/iOZVkvqOyJkDBYlvVkOp3+3wGXaNVq9TOqNsSh0CUoFApx27bP96szxprJZPJGlT0REqZEIjEViURe8qt3Op1NjLFrGUOEMWxlDGd4v4d+qjCFLkGr1bradd2MX90wjG9bljWnsidCwlQsFlvZbPaYAwchxnm9viPz7LPfvR6QdQCPAnjI+73OGJ5gDFcyhvVh9MKklGG8DhlRhUIhNTc390MhhHGsOue8fsIJJ7zVsqx51b0RErbXvva199br9bMAQMoY6vVPj7Vav5EBJIBk0PRCHb1B6m4Au6REe7k90Eh3jWu1Wjv9AhcADMP4JgUuWS0Mw7icc1533c1apfLwxlbroxkgwY4TuACQApAAcCmAxxnDqcvtgUJ3DTNNM23b9i/51TnnTjwep/1yyaphWdYLsdjZ91erD75GiE2RRYTt0VIATgOwZ7nBG/okMRkdjUbjU0II3a9uGMY3isViXWVPhPQTY4gB930IEAzQlvsyGoD1AB5kDK+X0n852rHQSHeNMk1z3Lbt9/vVOee1eDw+VKeoEhKCKYBtBLSVLg/TALwGwPVL/UIK3TWq0Wh8SkqZ9Kun0+l7aZRLVhPGMA7gcvSmCMKgA9ix1FUNFLprUKFQOMm27f/uV9c0bT4Wiw38WBNCQvZRACLk1xTe6y4aLRlbhRjDGICzAGwD8A4AGwHEALQB7Nf1b6QZ+6uJSORfWpzPv+ofYTab/YOnn37680qbJqTPGMMTAPqxh+4TUuKMRfdBobt6MIZtAK4A8IsAWuh9jIq++soOgKYAoiwafbCeSPxBNRr9tzYAaJp2cGxs7KfL5XJXXeeE9Jf3ZJmD3uAjbG0AupRY1PcMrV5YBRjDJgB/BuCnAMTRm+RP+H9FFECUA0Cn8x6903l3KhJ5rKXrv3lgbKx2NwUuWYUm0AvHfoRux3v9mcVcTKE7whgDA3ABgDvQ+8d0jFHt8WgAkqzbfXO8Unn4NZVKosYYmJSgj0BkNUkg/PncBS4CBzlHohtpI8oL3N3oBa6OZQXu4aIMSHKA3QFgt/f6hKwWTfQv7zTv9ReF5nRH0GGBezF6gRs2B8BXpMRlfXhtQpQbpjldGumOpgvQv8CF97oXM4YL+/T6hCjlBeKi5lyXYXqxgQtQ6I4c76bZwpRCP+kAvsQYNvb5fQhR5W70dgsLUx3AXUv5AppeGDGM4XsA3ooVz+EuSgfAQ1LinQrei5C+8p4c248l3PRahCaAjVLi4GK/QN3qhXtYBL1lFQn0Gp3F+ZKWJi0BY/gp9JaFqQhceO/z04xhm5TYo+g9CekLKXGQMexGb3vGMB4FrgPYvZTABfo90r2HjaP3iNwFALaiN+Es0JvWiAOYRm/IfyfOl0tqfC1iDPcCOA8r2B5pGVwA90kJ3+N8CBkVvV3G8DggTgP4Sr6PXABPA0vfZaw/oXsPiwGYQm9zCYHgnypH7MiO8+Wyd2RfzbxHe19AuB+NFqsJ4BQpQZuZk5HHGE5lrDItpR5b5od9F8BBANukxLNL/eLwb6Tdw04F8Dh6Q/gEjj+MP2JHdu/ryVEikc7PAgP7gdQC8DMDem9CQpXL5U/NZN75Euf7ukBjqaNOB70R7rICFwh7TrcXmHvQ2+B3qUP3V3Zkxz1sG86Xy/o/NIx27drF0PuzTgT8igfV8/n/8a4nnjjdwGCeWUiht3nOdwbx5oSEybbtqzTtgJvNnrV/GWek3Q7gxqVOKRwuvOmF3pTC4+gFZyhzJThfLvv/WJi80IxhBaGJFX6quOOOT3xkbu6ELSt5jRX6rpTYPsD3J2TF8vn8mQcOHLgXh30/CrGeN5sXGu32Bw0hJjQg0kAvhzT0biZPo7cs7K6l3jQ7ljBHulPobSG40ps8h+/Ift1KmwKAXbt2cRw/GI9XG+hjsY1GMj3I90fv74SQkeY4zpU4agDE+UGRSt1WTaVuq65bt+XXn3pqz8KysiaA2aU8+LAY4YRub5XC5QjvJo8OYAfuYbfjfHlw165dCx/Njzea9Kv349E/paRkKlcsHEt8wO9PyIrk8/k3NhqNN/vVE4nEkzMze/6p332ENdINfUd2V3L+ZO30r//lrl2PgHZDA2PSHXALrQG/PyErUq/Xr0HAJ3Fd15WclhLW6oULEN65QwAAjYnYltQzZ4ICFwCQTDZqA27h+QG/PyHLZppmvl6vn+lXj8fjpXK5/F0Vvaw8dHtPmm1deSuvltLq6zXWpf0hAJx88o9nAdGv/UCPpwPgewN6b0JWzHGcTyFglGsYxhdV9RLGKHICfdqRXYCJTYl9Y3sbE6vhaTUXvYn5hV+to/730b+OqD/55OmPAPwnAWTVt446QI8Bk9FkmuYWx3He6lePxWJPl8vlv1HVTxih278d2SUTMdYelumFDlYQmgC6U1NTy16fd8MNeBiDu5kVB/CvA3pvQlakXq9fi4CsMwzjywrbCSV0+7cjO5O8LWNhLdc4OgSXFJpTU1MDvZElJeYZwwMYzN4L36RHgMkoMk1zk+M47/Crx2KxZ6enp+9X2VMYoTuLPi3J4pB8X3PTPHqPiyxmNOlXa01NTQ1qPjRMtwH4BYR80/I4Wt77EjJy6vX6tVJK33wyDOOPVfYDhBG658su7mEz6M958tOujNwMoL2Sj+arhZTYwxh+COBnoW4/3R9KiX9X8F6EhKpQKJzkOI7vU5TRaPSFTqdzj8qegPCWY90N4AaEOwKrcya/OjU1RetDj/RrAIpQE7otAL+q4H0ICV2z2dx5nFHunTMzM8oHc2HNxd4Z4mst4FjiMRhrgZTYB+AS9HY76icHwO9Kif19fh9CQmea5pht2+/xq0cikRe73e6dKntaEE5Q9jYg343wzh+qA/g8bWzu624AX0HfgrfponcaMP3QIyOp0WhcI6X03ZYgnU5/fXZ2diBTlmGOTnehd/7QSu/yu97r3LjijlYpKSHR2+uiD8Fbl7HYvc5pp+V+FO7rEqKGaZppx3F+3q8eiUTmut3uH6ns6XDhhW7vxIft6O2ovtzgXdiRffuwbOs4rA4L3ksA2MDy9/fs6UjAkanU9QcNY8ehavXQFaZpjq+8U0LUajabVwkhfE/LNgzjzwc1ygXCnoftbTy+Db39cJc61fDKjuyraQPzfpIS0psCMAE8hN6f+RJ/4LkAGjISebSVzb51fyJxlw0AQgjDtu07Qm6ZkL4qFAop27bP9atrmjavadqXVPZ0tPAfaugF5hno7bDexPHDt+5ddzt6G5dT4C6RlNjnHZP+DgD3offnWYH/6LfTq4tWNPq3djp97o8zmfe8qGn7jgjser3+1snJyQ/0tXlCQtRqtS4TQhh+dcMw7iuXywM9hbzfpwGvx3+eBjyJ3jf7MXdkp5tm4fEOsfwZ9D51nI3eBuRx9JaAPY/e5jV7APzr5s0Tn6rVauf5vZamafPj4+P/xbKsQe9yRkigQqEQP3jw4L+5rps5Vp1zXhsfH99WLBYHugy1v6F7uN5uZBM4bEd2nC8H+hOHALlcLlKtVn/Q6XRO9rvGMIx/2Lt378Uq+yJkqU477bSrKpXKx/3qmUzm7meeeeYGhS0dk7rQJUMrl8u9fW5u7i747+kgxsfHf7tcLv+9yr4IWaxcLheZn5//N9d11x2rzjl3xsfHf6pYLIa1rHXZaK9agnK5/H3DMIJO+uWVSuWmQqFAR/aQoeS67sf9AhcAdF3/q2EIXIBCl3iSyeSVkUhkzq/e7XZPajabn1XZEyGLMTExwWzb/ohfnTHWSCaTn1PZUxAKXQIAKBaL9Ww2O4WAvZFrtdov5PP5sxS2RchxRSKRi7rd7gl+dcMw/tqyrKHZmpRCl7yiXC5/W9f17wdcolUqlVtzudywbCxP1riJiQlWq9Uu8qszxlrJZPIWlT0dD4UuOYKu65dqmlb1q3c6nU2dTmdKZU+E+IlGox/pdrsb/Oq6rv+DZVm+02aDQKFLjmBZ1nw2mw2c/6pWqx8qFApvUNUTIcfijXJ9lzIyxtqpVOpmlT0tBoUueZXp6ek/TyaTPwy4JFqpVL4wMTHBlDVFyFGi0eh5nU5nk19d1/X/Y1nWCyp7WgwKXXJM6XT6k5xz3x3M2u326zjnV6vsiZDD2bb9sYByJ5VKfUZZM0tAoUuOybKsF7LZbODGINVq9ULTNLeq6omQBblc7v3tdnuLX13X9R9YlrVXZU+LRaFLfM3MzPxxIpF43K8upYxXq9WB7thE1ibbti8JKHd1XR+6udwFFLokUCaTuYQx1vSrN5vN07du3er7vDshYcvlcue0Wi3fT1ipVOoRy7JmVPa0FBS6JJBlWc9kMpmvBV1TqVQ+YZrmKap6ImubbdufDCi7uq4P9ZOTFLrkuIQQt8ZisacC6nqtVqMNz0nf5XK5t7daLdOvnkql9hSLxcdU9rRUFLrkuGZnZ2U2m72UMdb2u6bRaGybnJz8sMq+yNrjOM6VAWWRSqWGepQLUOiSRSoWi4+l0+l7g66pVCpXm6Y5pqonsrbk8/kzm83m6/3qyWTyP0ql0qMqe1oOCl2yaFLKG6LR6HN+ddd1M47j0GoG0heO41wF/8wSuq7/vsp+lotClyyaN82wAwGHXzqO87ZcLvd+hW2RNSCfz7+50Wi8ya+eSCSeLJVKD6vsabkodMmSlEqlR9Lp9LcCLuHz8/NThUIhpawpsurV6/Vr4H+yCXRd/7zCdlaEQpcsWSKR2BmJRF70q7uuu77RaIzMNwEZbqZpnl6v17f51ePxeLFcLn9PYUsrQqFLlqxYLLay2ey1CJhmsG3753K53NnquiKrleM4OxEwyjUM4wsK21kxCl2yLOVy+buGYTwYcIlWqVQ+Rxuek5UwTXOr4zi+p5XEYrGnyuVy0Pl+Q4dClyxbKpXaoWnaIb96t9vd0G63h2rXfjJavFGu7w9uwzD+QGE7oaDQJctmWVYtm83eGHRNrVY7N5/P+87HEeLHNM3NjuO83a8ei8X2Tk9Pf1NlT2Gg0CUrMj09/c1UKvVQwCWRarW6mzY8J0tVr9d3Aoj61Q3D+COF7YSGQpesmGEYv8s5r/nV2+32qYwxOleNLJppmqc4jvMuv3o0Gt3f6XT+QmVPYaHQJStmWdbc2NhY4BKxWq12vmmap6vqiYy2Rloc8OsAAAtQSURBVKNxjZQy5lc3DOOrs7OzUmVPYaHQJaGYnp7+ejKZ9H3uXUoZq1QqX6RpBnI8pmmO27b9c371SCTyYrfbvVthS6Gi0CWhSafTl3DO6371Vqs1qWnaZSp7IqOn0WjslFIm/OrpdPprozrKBSh0SYgsy9qXyWT+MOiaSqVysWmam1X1REaLaZppx3He61ePRCJz3W73T1T2FDYKXRIq13W/HI/HLb+6lDJZrVZpw3NyTM1m8xohhO++HYZh/Okoj3IBCl0SMm8nsksYYy2/a5rN5hu3bt16scq+yPArFAop27Z/0a+uadohTdNG7mGIo1HoktBZljWTyWS+HnRNpVK5tFAonKSqJzL8Wq3WDiGE7lc3DOMvyuVyV2VP/UChS/pCCHFLLBZ7JqCuO47zRZU9keFVKBTijuN8wK+uaVo1FovdrrKnfqHQJX0xOzsrM5nM5QA6ftfU6/WzJicnP6iwLTKk2u32Za7rZvzquq7fXywWfaesRgmFLumbUqn0aDqdvj/omkqlcq1pmmlVPZHhk8vlIrZtf8ivzjl34vH4qtmfmUKX9FUsFrsuGo2+4Fd3XXfMcZyR2g+VhMt13d9xXdf3QFPDMB4oFou+679HDYUu6atyudzNZrNXIvhctXfmcrlzFLZFhsTExASzbfvX/Oqc83oikRj6Y9WXgkKX9F2pVPqBYRh/G3AJr1QqNxUKhbiypshQiEQiH+t2u+N+dV3X/9qyLN/NlEYRhS5RIplMXhGJRA741bvd7gmNRuM2lT2RwZqYmGC1Wu3X/eqMsWYymVxVo1yAQpco4p2r9mkAwu8a27bfk8/n36awLTJAkUjkgm63u8GvbhjG31mWNaeyJxUodIky5XL5O7qu/1PAJVqlUrmVzlVb/by53Iv86oyxdiKRuFllT6pQ6BKldF2/TNO0eb96p9M5pd1u/57Knoh60Wj0lzudzka/uq7r/1gsFl9S2ZMqFLpEKcuy5rPZ7GeCrqnVah/I5/NvVNUTUc+27Y8HlDupVOomZc0oRqFLlJuenr4vlUo9HHBJtFqt0obnq9Tk5OS57Xb7VL+6ruvftyxrn8qeVKLQJQOh6/onOeeOX73dbm/hnO9U2RNRw7bt3wkod3VdX7WjXIBClwxIsVh8KZvNBm5gUq1WLzBNM6+qJ9J/uVzunHa7/Tq/uq7rD1uW5btR0mpAoUsGZmZm5quJROJHfnU6V231sW370oCyq+v6LcqaGRAKXTJQmUzmEsZY06/earUKmqYF3XQhIyKXy53darUKfvVUKvVDy7KeVNnTIFDokoGyLGtvNpsNPPOqWq1+wjTNTap6Iv3hOM6OgLKbSqVW/SgXoNAlQ8B13dvj8fi0X10IkarVarTh+QjL5/NnNZvN0/3qyWTy/5VKJd+pptWEQpcMnHeu2icZY22/axqNxlsmJyd9n9Mnw81xnKvgnzdC1/XfV9nPIFHokqFgWdaT6XT6nqBr5ufnd5im6bsjFRlO+Xz+zY1G4yf86olE4olSqfSIyp4GiUKXDA0p5a5YLPasX10IkbZt+0sqeyIr5zjOTgRkja7rtypsZ+AodMnQOOxcNd8TX+v1+s9OTk6eq7AtsgKFQuENjUbjLX71eDxulcvl76vsadAodMlQKZVKe9Lp9ANB11QqlevpXLXhxRgijGErYzjj0KHTbpIyovldaxjGqjjhdymYlHLQPRByhFwuF6lUKg8db6/VvXv3/pbKvog/xjAO4KMALgCwFUC7t3VyUweijPO9nVjsG3Yi8TWb84MCAOLx+Mzzzz+/fXBdDwaNdMnQ8c5VuxoB56rZtr09l8u9W2Fb5BgYQ4wx3AxgH4AbAJwOIAbAALgBpBgQhRBbo83mpWPz849tcpwbx6SMwTCMOwbZ+6DQSJcMrc2bN/9P27Z9D6yMRCIvrlu37u3FYrGlsi/SwxhOBfAggI0AUov/yobk/GBTiI0FKeF743S1opEuGVrJZPJyTdMO+tW73e6GZrO5Jp5iGjZe4O4BcBqWFLgAkGRCnBIHsMd7nTWFQpcMrWKxWB8bG9uFgHPVarXa+/P5/JkK21rzGEMMvRHuegC+N8mCce59/YOMIRpacyOAQpcMtXK5/C1d138QcIlWqVRum5iYYIffNfd+p7PW+mMKvSmFZQbuKzQArwFw/Yo7GiE0p0uGnmmaYwcOHPhnIcSrlokJMc6bzQuNdvuirhAnZgG00RsZcwBxANMA7gZwp5Twnaogi+OtUtgHIBHiyzYBbFwrfz800iVDz7Ks+bGxsc8d/t+kjMFxbhybn//Rpmbz0jEhTjwRr9w1R8b7PYre3fQbAOxnDDd7H43J8n0UkL7TPcskeq+7NtBIl4yMTZs23d9oNLa57matVvvLk4XYoAHJpWxwXgewH8D2tXjXHOgdfZ5MJg0AG4QQ41LKcSnleiFEVggxJqUck1LqUsq0ECIlhNCllCkhRFxKmZybezgvxOv68YPrCSlxRh9ed+hQ6JKRYZrmKS++aPzT/PzfvU7KDMfypmxdAAcBbBvF4C0UCnHG2MlCiBOllOsXfgkhMkKIrJQyLaU0hBCGF5ZJIURKShn3gjOGZc7FShnBoUPPbUZ/Piy0AehS+j8CvlrQjQYyMopFa47zSlZKfbmBC/QCZ+Gu+eulRCe8DoPlcrmIpmkneoF5opRynZRynReWWSllxgtLQwihCyGSh40y40KIOAb4PSvElgjQlUCsH8cndQBMAJjpw2sPFQpdMkqmhMgaIbzO4XfNr1vMF3gfy9cD2OC67gkA1gkh1nuhmZFSZryP5LoXnEkvNJMLI0xvlDmypEywgNV7K+Ui3JtzQ4tCl4wE76755QjvG1MHuldv2vSuSCTybMT7WK4LIQzv43hSCJHwgjMmpYzWarU1feOZsabs4713Db1VDKsehS4ZFR9F6MOsTmRu7pzfSqVuq4b7uqsT5890gUi/TmaOApjt02sPlTX9k5uMlAuw5MdNjyfJ2u0PhjFdsSYw1gXnz/ZrDnx6LdxEA2ikS0aA92TZ1n68thCnRqWMgLE18f2+wGWMtTnnLc55kzHW4Jw3GGN1zrnNGLMZYzXOeYVzfogxVmGMHWSMHaxWk+cKIS8FWJg/AOsA7grx9YYahS4ZBRPoLSnqw42orhRiS0TTpkcldQVjrMM5b3lh2fLC0uGc1xljNcZY1QvNec75QmDOcc7nALzYaDTs2dnZZa0VZQxPoze3HiYOCl1ChkoCfbttLry78mowxtreKHNhhNnknDuMMccbZdYYY7YXmIcYY/NeYL4M4ECj0Ti43MAMg5Q4yBh2A7gU4Uz31AHsXiuPAAMUumQ0NNG3+w/cuyu/KB3OeZsx1uKcL3wkb3hhWeecVw8fZTLG5hhjhzjnc4yxA67rvlwul0dlRB1kF4Dz0NvWcSWb3rjoPSF4YxhNjQoKXTIKZtGnx6CAmEynX36Qc8P2PopXvN8XRpkvc85fllK+TJul90iJNmPYjt5+usvd3nHhycDtKh9QGQb0GDAZCYzhCfQ2rwnbmnnmP2zLPzkCDoDnsUb3wKAlY2RU3I3e/F+Y1tRd87B5gXkGgNvRmwI63t9P3bvudgCvX4uBC9BIl4wIxrAevfk/2sd1CHl/PwunAU+it5eCi97UQxS9fY3vAnDXWv/zptAlI8M7dTbsu+aL2nuBLJ63rnoCvR+QTQCza+XBh8Wg0CUjw9uA/HGEc9f8aUDtLmOEADSnS0aIlGgD2I7eXW93mS+zZu+ak+FAoUtGinfzZRt6I9Wl3lhzvK8byQ3MyepAoUtGDt01J6OM5nTJSKO75mTUUOgSQohCNL1ACCEKUegSQohCFLqEEKIQhS4hhChEoUsIIQr9fwI5oSNQ5TO4AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "explain_test(allnodes[1],needplot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf2",
   "language": "python",
   "name": "tf2"
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}