estimate_model_medline_mesh.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling Hypergraphs of MeSH Terms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model\n",
    "\n",
    "* Let $G=(V,E)$ be a hypergraph, where $E$ is the collection of hyperedges.\n",
    "* Let $H$ be the collection of admissible combinations of nodes, (e.g., if we only consider hyperedges of size less than 10). \n",
    "* $G$ is modeled as a collection of random variables ${X_h: h\\in H}$.\n",
    "* $X_h\\sim Poisson(\\lambda_h)$.\n",
    "* The mean $\\lambda_h$ depends on the (latent) features of nodes in $h$: $$\\lambda_h=\\sum_k\\prod_{i\\in h}r_i\\theta_{ik},$$ where $\\theta_{ik}$ is the percentage of node $i$ in block $k$  ($\\sum_{k}\\theta_{ik}=1$), and $r_i$ corresponds to the popularity of node $i$.\n",
    "* Assume $X_h$'s are independent of each other given $\\theta=(\\theta_i)$ and $r=(r_i)$.\n",
    "* The distribution of $G$ is given by $$p(G|\\theta)=\\prod_{h\\in H} p(x_h|\\theta)$$.\n",
    "* Estimation: Use stochastic gradient descent to estimate $\\theta$ and $r$\n",
    "    * Let $\\theta_{ij}=\\theta_{ij}r_i$, so that we only need to deal with one set of variables $\\theta$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Workbench"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import pandas as pd\n",
    "import scipy.sparse as ssp\n",
    "import numpy as np\n",
    "from functools import partial\n",
    "from multiprocessing import Pool, cpu_count\n",
    "from scipy.stats import dirichlet\n",
    "from collections import Counter\n",
    "from datetime import datetime\n",
    "import random\n",
    "from collections import defaultdict\n",
    "from scipy.optimize import minimize\n",
    "from itertools import zip_longest\n",
    "from numba import guvectorize,vectorize\n",
    "from numba import int64,float64,int32\n",
    "from numba import cuda\n",
    "import math\n",
    "import pickle as pickle\n",
    "from scipy.stats import pearsonr\n",
    "from sklearn.metrics import precision_recall_curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import pylab as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Stopwatch:\n",
    "    start_time=None\n",
    "    def go(self,msg=''):\n",
    "        if msg:\n",
    "            print(msg, flush=True)\n",
    "        self.start_time=time.time()\n",
    "    def stop(self,msg=''):\n",
    "        if msg:\n",
    "            print(\"{}: {} seconds\".format(msg,time.time()-self.start_time), flush=True)\n",
    "        else:\n",
    "            print(\"Elapsed time: {} seconds\".format(time.time()-self.start_time), flush=True)\n",
    "    def check(self):\n",
    "        return time.time()-self.start_time\n",
    "\n",
    "tic=Stopwatch()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_date(filename):\n",
    "    tic=Stopwatch()\n",
    "    print(\"Loading paper dates %s from disk...\" % filename),\n",
    "    tic.go()\n",
    "    pkl_file = open(filename, 'rb')\n",
    "    A=pickle.load(pkl_file,encoding='latin1')\n",
    "    pkl_file.close()\n",
    "    tic.stop()\n",
    "    return A\n",
    "\n",
    "def load_hypergraph(filename):\n",
    "    tic=Stopwatch()\n",
    "    print(\"Loading file %s from disk...\" % filename),\n",
    "    tic.go()\n",
    "    pkl_file = open(filename, 'rb')\n",
    "    (row,col) = pickle.load(pkl_file,encoding='latin1')\n",
    "    pkl_file.close()\n",
    "    A=ssp.coo_matrix((np.ones(len(row),dtype=np.int8),(row,col)),shape=(19916562, max(col)+1),dtype=np.int8)\n",
    "    tic.stop()\n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading file ../../Data/chemical.pkl from disk...\n",
      "Elapsed time: 13.912632465362549 seconds\n",
      "Loading file ../../Data/disease.pkl from disk...\n",
      "Elapsed time: 8.555835247039795 seconds\n",
      "Loading file ../../Data/method.pkl from disk...\n",
      "Elapsed time: 11.13637089729309 seconds\n",
      "Loading paper dates ../../Data/paper_dates.pkl from disk...\n",
      "Elapsed time: 2.9732871055603027 seconds\n"
     ]
    }
   ],
   "source": [
    "tic=Stopwatch()\n",
    "G=[]\n",
    "for thing in ['chemical','disease','method']:\n",
    "    G.append(load_hypergraph('../../Data/'+thing+'.pkl'))\n",
    "G=ssp.hstack(G).tocsr()\n",
    "\n",
    "paper_dates=load_date('../../Data/paper_dates.pkl') # Load publicatioin dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({-1: 3011366,\n",
       "         1865: 3,\n",
       "         1866: 11,\n",
       "         1867: 36,\n",
       "         1868: 95,\n",
       "         1869: 58,\n",
       "         1870: 69,\n",
       "         1871: 62,\n",
       "         1872: 38,\n",
       "         1873: 96,\n",
       "         1874: 39,\n",
       "         1875: 73,\n",
       "         1876: 87,\n",
       "         1877: 46,\n",
       "         1878: 119,\n",
       "         1879: 143,\n",
       "         1880: 118,\n",
       "         1881: 98,\n",
       "         1882: 88,\n",
       "         1883: 108,\n",
       "         1884: 159,\n",
       "         1885: 209,\n",
       "         1886: 196,\n",
       "         1887: 234,\n",
       "         1888: 182,\n",
       "         1889: 195,\n",
       "         1890: 240,\n",
       "         1891: 207,\n",
       "         1892: 227,\n",
       "         1893: 309,\n",
       "         1894: 308,\n",
       "         1895: 296,\n",
       "         1896: 340,\n",
       "         1897: 314,\n",
       "         1898: 324,\n",
       "         1899: 335,\n",
       "         1900: 254,\n",
       "         1901: 329,\n",
       "         1902: 416,\n",
       "         1903: 642,\n",
       "         1904: 715,\n",
       "         1905: 861,\n",
       "         1906: 765,\n",
       "         1907: 689,\n",
       "         1908: 703,\n",
       "         1909: 748,\n",
       "         1910: 700,\n",
       "         1911: 806,\n",
       "         1912: 862,\n",
       "         1913: 936,\n",
       "         1914: 882,\n",
       "         1915: 1117,\n",
       "         1916: 1180,\n",
       "         1917: 1130,\n",
       "         1918: 1112,\n",
       "         1919: 1131,\n",
       "         1920: 1151,\n",
       "         1921: 1124,\n",
       "         1922: 1149,\n",
       "         1923: 1300,\n",
       "         1924: 1488,\n",
       "         1925: 1561,\n",
       "         1926: 1671,\n",
       "         1927: 1796,\n",
       "         1928: 1776,\n",
       "         1929: 1646,\n",
       "         1930: 1695,\n",
       "         1931: 1842,\n",
       "         1932: 1850,\n",
       "         1933: 1952,\n",
       "         1934: 1937,\n",
       "         1935: 2006,\n",
       "         1936: 1954,\n",
       "         1937: 1964,\n",
       "         1938: 2286,\n",
       "         1939: 2062,\n",
       "         1940: 1889,\n",
       "         1941: 1728,\n",
       "         1942: 1668,\n",
       "         1943: 1652,\n",
       "         1944: 1613,\n",
       "         1945: 1564,\n",
       "         1946: 1667,\n",
       "         1947: 14702,\n",
       "         1948: 64826,\n",
       "         1949: 56311,\n",
       "         1950: 72558,\n",
       "         1951: 90531,\n",
       "         1952: 95672,\n",
       "         1953: 96678,\n",
       "         1954: 92750,\n",
       "         1955: 94473,\n",
       "         1956: 92215,\n",
       "         1957: 96518,\n",
       "         1958: 96378,\n",
       "         1959: 96925,\n",
       "         1960: 98229,\n",
       "         1961: 105620,\n",
       "         1962: 111271,\n",
       "         1963: 125638,\n",
       "         1964: 141892,\n",
       "         1965: 154666,\n",
       "         1966: 156711,\n",
       "         1967: 168406,\n",
       "         1968: 184234,\n",
       "         1969: 192312,\n",
       "         1970: 195367,\n",
       "         1971: 199313,\n",
       "         1972: 204058,\n",
       "         1973: 207236,\n",
       "         1974: 210733,\n",
       "         1975: 221837,\n",
       "         1976: 226115,\n",
       "         1977: 232439,\n",
       "         1978: 242206,\n",
       "         1979: 251212,\n",
       "         1980: 249876,\n",
       "         1981: 251146,\n",
       "         1982: 260583,\n",
       "         1983: 272964,\n",
       "         1984: 279096,\n",
       "         1985: 287918,\n",
       "         1986: 300651,\n",
       "         1987: 317428,\n",
       "         1988: 334360,\n",
       "         1989: 348124,\n",
       "         1990: 354127,\n",
       "         1991: 355473,\n",
       "         1992: 358775,\n",
       "         1993: 364239,\n",
       "         1994: 374184,\n",
       "         1995: 383192,\n",
       "         1996: 389401,\n",
       "         1997: 398176,\n",
       "         1998: 412126,\n",
       "         1999: 423046,\n",
       "         2000: 450871,\n",
       "         2001: 479434,\n",
       "         2002: 500423,\n",
       "         2003: 524728,\n",
       "         2004: 557686,\n",
       "         2005: 583842,\n",
       "         2006: 612750,\n",
       "         2007: 627336,\n",
       "         2008: 650129,\n",
       "         2009: 445648,\n",
       "         2010: 1})"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(paper_dates)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "G=G[paper_dates>0,:]\n",
    "paper_dates=paper_dates[paper_dates>0]\n",
    "G=G[paper_dates<2010,:]\n",
    "paper_dates=paper_dates[paper_dates<2010]\n",
    "paper_dates[paper_dates<1947]=1947"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({1975: 221837,\n",
       "         1976: 226115,\n",
       "         1977: 232439,\n",
       "         1978: 242206,\n",
       "         1979: 251212,\n",
       "         1974: 210733,\n",
       "         1980: 249876,\n",
       "         1992: 358775,\n",
       "         1993: 364239,\n",
       "         1990: 354127,\n",
       "         1991: 355473,\n",
       "         1988: 334360,\n",
       "         1987: 317428,\n",
       "         1985: 287918,\n",
       "         1986: 300651,\n",
       "         1989: 348124,\n",
       "         1970: 195367,\n",
       "         1969: 192312,\n",
       "         1968: 184234,\n",
       "         1967: 168406,\n",
       "         1971: 199313,\n",
       "         1964: 141892,\n",
       "         1966: 156711,\n",
       "         1972: 204058,\n",
       "         1973: 207236,\n",
       "         1965: 154666,\n",
       "         1963: 125638,\n",
       "         1962: 111271,\n",
       "         1961: 105620,\n",
       "         1960: 98229,\n",
       "         1984: 279096,\n",
       "         1982: 260583,\n",
       "         1983: 272964,\n",
       "         1981: 251146,\n",
       "         1995: 383192,\n",
       "         1994: 374184,\n",
       "         1996: 389401,\n",
       "         1997: 398176,\n",
       "         1998: 412126,\n",
       "         1999: 423046,\n",
       "         2000: 450871,\n",
       "         2001: 479434,\n",
       "         2002: 500423,\n",
       "         2003: 524728,\n",
       "         1956: 92215,\n",
       "         1953: 96678,\n",
       "         1954: 92750,\n",
       "         1950: 72558,\n",
       "         1958: 96378,\n",
       "         1947: 82133,\n",
       "         1959: 96925,\n",
       "         1951: 90531,\n",
       "         1949: 56311,\n",
       "         1955: 94473,\n",
       "         1957: 96518,\n",
       "         1952: 95672,\n",
       "         2004: 557686,\n",
       "         2005: 583842,\n",
       "         2006: 612750,\n",
       "         2007: 627336,\n",
       "         1948: 64826,\n",
       "         2008: 650129,\n",
       "         2009: 445648})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(paper_dates)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_nodes(x,G):\n",
    "    return tuple(sorted(G[x,:].nonzero()[1]))\n",
    "    \n",
    "def get_hyperedges(G):\n",
    "    # G: a edge-by-node incidence matrix\n",
    "    with Pool(cpu_count()-1) as pool:\n",
    "        E=Counter(pool.map(partial(get_nodes,G=G), (G.sum(axis=1).A.flatten()>1).nonzero()[0]))\n",
    "    return E\n",
    "\n",
    "def get_random_combo(h, V, E):\n",
    "    while True:\n",
    "        e=tuple(sorted(random.sample(V,len(h))))\n",
    "        if e not in E:\n",
    "            return e\n",
    "\n",
    "def batch_generator(iterable, batchsize, shuffle=False):\n",
    "    if shuffle:\n",
    "        iterable=list(iterable)\n",
    "        random.shuffle(iterable)\n",
    "    sentinel=object()\n",
    "    return ([entry for entry in i if entry is not sentinel]\n",
    "            for i in zip_longest(*([iter(iterable)]*batchsize), fillvalue=sentinel))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def edges2CSR(H):\n",
    "    nodes=[]\n",
    "    nodes_in=[0]\n",
    "    for h in H:\n",
    "        nodes+=list(h)\n",
    "        nodes_in.append(len(nodes))\n",
    "    return nodes, nodes_in\n",
    "\n",
    "def CSR2CSC(nodes, nodes_in, N):\n",
    "    M=ssp.csr_matrix((np.ones_like(nodes,dtype=np.int8), nodes, nodes_in), shape=(len(nodes_in)-1,N))\n",
    "    M=M.tocsc()\n",
    "    return M.indices, M.indptr            \n",
    "\n",
    "@vectorize([float64(float64)], target='cuda')\n",
    "def copy(x):\n",
    "    return x\n",
    "\n",
    "@guvectorize([(int64,float64[:,:],int64[:],int32[:],int32[:],int32[:],int32[:],int32[:],int32[:],int32[:],int32[:],int32[:],int32[:],float64[:])],\n",
    "             '(),    (N0,K),      (N),     (M),     (N1),    (M),     (E1),    (E),     (M),     (N1),    (M),     (E1),    (D)  ->  (D)', target='cuda')\n",
    "def dtheta(x,theta,active,edges,edges_in,nodes,nodes_in,weights,rand_edges,rand_edges_in,rand_nodes,rand_nodes_in,dummy,res):\n",
    "    K=theta.shape[1]\n",
    "    i=int(x/K)\n",
    "    z=x-i*K\n",
    "    res[0]=0.0\n",
    "    for j in edges[edges_in[i]:edges_in[i+1]]:\n",
    "        dlam=1.0\n",
    "        for u in nodes[nodes_in[j]:nodes_in[j+1]]:\n",
    "            if u!=i:\n",
    "                dlam*=theta[active[u],z]\n",
    "        p=0.0\n",
    "        for k in range(K):\n",
    "            prod=1.0\n",
    "            for u in nodes[nodes_in[j]:nodes_in[j+1]]:\n",
    "                prod*=theta[active[u],k]\n",
    "            p+=prod\n",
    "        p=max(p,1e-8)\n",
    "        res[0]+=weights[j]*dlam/p-dlam \n",
    "            \n",
    "    for j in rand_edges[rand_edges_in[i]:rand_edges_in[i+1]]:\n",
    "        dlam=1.0\n",
    "        for u in rand_nodes[rand_nodes_in[j]:rand_nodes_in[j+1]]:\n",
    "            if u!=i:\n",
    "                dlam*=theta[active[u],z]\n",
    "        res[0]-=dlam\n",
    "\n",
    "@cuda.jit\n",
    "def preupdate(theta,theta0,r,s):\n",
    "    x, y = cuda.grid(2)\n",
    "    if x < theta.shape[0] and y < theta.shape[1]:\n",
    "        theta[x,y]-=1.0/(100+r)*(theta[x,y]-theta0[x,y])/s\n",
    "\n",
    "@cuda.jit\n",
    "def update(theta,active,D,r):\n",
    "    x, y = cuda.grid(2)\n",
    "    if x < D.shape[0] and y < D.shape[1]:\n",
    "        theta[active[x], y] += 1.0/(100+r)*D[x,y]\n",
    "        cuda.atomic.max(theta, (active[x], y), 0.001)\n",
    "\n",
    "@guvectorize([(int64,float64[:,:],int64[:],int32[:],int32[:],int32[:],int32[:],float64[:])], \n",
    "             '(),    (N,K),       (N0),    (M),     (E1),    (E),      (D)  ->  (D)', target='cuda')\n",
    "def p_pos(i,theta,active,nodes,nodes_in,weights,dummy,res):\n",
    "    p=0.0\n",
    "    K=theta.shape[1]\n",
    "    for k in range(K):\n",
    "        prod=1.0\n",
    "        for u in nodes[nodes_in[i]:nodes_in[i+1]]:\n",
    "            prod*=theta[active[u],k]\n",
    "        p+=prod\n",
    "    if p<1e-15:\n",
    "        res[0]=0\n",
    "    else:\n",
    "        res[0]=weights[i]*math.log(p) - p\n",
    "\n",
    "@guvectorize([(int64,float64[:,:],int64[:],int32[:],int32[:],int32[:],float64[:])], \n",
    "             '(),    (N,K),       (N0),    (M),     (E1),    (D)  ->  (D)', target='cuda')\n",
    "def p_neg(i,theta,active,rand_nodes,rand_nodes_in,dummy,res):\n",
    "    p=0.0\n",
    "    K=theta.shape[1]\n",
    "    for k in range(K):\n",
    "        prod=1.0\n",
    "        for u in rand_nodes[rand_nodes_in[i]:rand_nodes_in[i+1]]:\n",
    "            prod*=theta[active[u],k]\n",
    "        p+=prod\n",
    "    res[0]=-p\n",
    "\n",
    "@cuda.reduce\n",
    "def sum_reduce(a, b):\n",
    "    return a + b\n",
    "\n",
    "def logPG(theta,active,edges,edges_in,nodes,nodes_in,weights,rand_edges,rand_edges_in,rand_nodes,rand_nodes_in):\n",
    "    res1=p_pos(range(weights.shape[0]),theta,active,nodes,nodes_in,weights,[0])\n",
    "    sum1=sum_reduce(res1.ravel())\n",
    "    res2=p_neg(range(rand_nodes_in.shape[0]-1),theta,active,rand_nodes,rand_nodes_in,[0])\n",
    "    sum2=sum_reduce(res2.ravel())\n",
    "    return (sum1+sum2)\n",
    "\n",
    "def estimate(G, times, K=20, thetas=None, nepochs=5, subepochs=10, batchsize=1000, discontinue=1, outfile=None):\n",
    "    # G: an edge-by-node incidence matrix; scipy sparse CSR matrix.\n",
    "    # times: timestamp for each edge; 1D numpy array.\n",
    "    # K: dimension of latent space.\n",
    "    # thetas: intial values for the parameters; a list of node-by-K matrices with each matrix for a time point. If None, then the estimation starts from random matrices.\n",
    "    # nepochs: number of repetitions of the whole process\n",
    "    # subepochs: number of repetitions for each data point \n",
    "    # batchsize: batch size of training samples.\n",
    "    # discontinue: correlation of the parameters between time points; the larger the value, the more dissimilar between time points.\n",
    "    \n",
    "    tic.go('Estimating...')\n",
    "    candidate_times=np.unique(times)\n",
    "    if thetas is None:\n",
    "        theta=np.random.dirichlet([0.5]*K,size=G.shape[1])\n",
    "        thetas=[cuda.to_device(theta)]\n",
    "    else:\n",
    "        if K!=thetas[0].shape[1]:\n",
    "            raise(\"K and the dimension of initial condition don't match!\")\n",
    "        thetas=[thetas[0]]+thetas\n",
    "        thetas=[cuda.to_device(theta) for theta in thetas]\n",
    "    \n",
    "    # parameters for CUDA\n",
    "    threadsperblock = (32,min(32,K))\n",
    "    blockspergrid_x = math.ceil(thetas[0].shape[0] / threadsperblock[0])\n",
    "    blockspergrid_y = math.ceil(K / threadsperblock[1])\n",
    "    blockspergrid0 = (blockspergrid_x, blockspergrid_y)\n",
    "    \n",
    "    likelihoods=[]\n",
    "    for epoch in range(nepochs):\n",
    "        time_index=1\n",
    "        for t in candidate_times:\n",
    "            if len(thetas)==time_index:\n",
    "                thetas.append(copy(thetas[-1]))\n",
    "            G0=G[(times==t).nonzero()[0],:]\n",
    "            active_nodes=G0.sum(axis=0).A.ravel().nonzero()[0]\n",
    "            G0=G0[:,active_nodes] \n",
    "            E0=get_hyperedges(G0)\n",
    "            N=len(active_nodes)\n",
    "            V=range(N)\n",
    "            active_nodes=cuda.to_device(active_nodes)\n",
    "            \n",
    "            blockspergrid_x = math.ceil(N / threadsperblock[0])\n",
    "            blockspergrid = (blockspergrid_x, blockspergrid_y)\n",
    "                     \n",
    "            if outfile:\n",
    "                outfile.write(\"Epoch {} | Time: {} | Nodes: {} | Edges: {} | \".format(epoch,t,N,len(E0)))\n",
    "                outfile.flush()\n",
    "            \n",
    "            for subepoch in range(subepochs):\n",
    "                for batch in batch_generator(E0.items(),batchsize):\n",
    "                    samples,weights=zip(*batch)\n",
    "                    nodes,nodes_in=edges2CSR(samples)\n",
    "                    edges,edges_in=CSR2CSC(nodes, nodes_in, N)  \n",
    "                    nodes=cuda.to_device(np.array(nodes, dtype=np.int32))\n",
    "                    nodes_in=cuda.to_device(np.array(nodes_in, dtype=np.int32))\n",
    "                    weights=cuda.to_device(np.array(weights, dtype=np.int32))\n",
    "                    edges=cuda.to_device(np.array(edges, dtype=np.int32))\n",
    "                    edges_in=cuda.to_device(np.array(edges_in, dtype=np.int32))\n",
    "#                     f=partial(get_random_combo, V=V, E=E0) # This sampling method is slower unless batchsize is huge\n",
    "#                     with Pool(cpu_count()-1) as pool:\n",
    "#                         E_neg=pool.map(f,samples)\n",
    "                    E_neg=[]\n",
    "                    for h in samples:\n",
    "                        while True:\n",
    "                            e=tuple(sorted(random.sample(V,len(h))))\n",
    "                            if e not in E0:\n",
    "                                E_neg.append(e)\n",
    "                                break\n",
    "                    rand_nodes, rand_nodes_in = edges2CSR(E_neg)\n",
    "                    rand_edges, rand_edges_in = CSR2CSC(rand_nodes, rand_nodes_in, N)\n",
    "                    rand_nodes=cuda.to_device(np.array(rand_nodes, dtype=np.int32))\n",
    "                    rand_nodes_in=cuda.to_device(np.array(rand_nodes_in, dtype=np.int32))\n",
    "                    rand_edges=cuda.to_device(np.array(rand_edges, dtype=np.int32))\n",
    "                    rand_edges_in=cuda.to_device(np.array(rand_edges_in, dtype=np.int32))\n",
    "                    preupdate[blockspergrid0, threadsperblock](thetas[time_index],thetas[time_index-1],(epoch+1)*(subepoch+1),discontinue)\n",
    "                    D=dtheta(range(N*K),thetas[time_index],active_nodes,edges,edges_in,nodes,nodes_in,weights,rand_edges,rand_edges_in,rand_nodes,rand_nodes_in,[0])\n",
    "                    D=D.reshape(N,K)      \n",
    "                    update[blockspergrid, threadsperblock](thetas[time_index],active_nodes,D,(epoch+1)*(subepoch+1))        \n",
    "                    l=logPG(thetas[time_index],active_nodes,edges,edges_in,nodes,nodes_in,weights,rand_edges,rand_edges_in,rand_nodes,rand_nodes_in)\n",
    "                    likelihoods.append(l/len(samples))\n",
    "            if outfile:\n",
    "                outfile.write('log-lik: {:.2f} | Elapsed {:.2f} s\\n'.format(likelihoods[-1], tic.check()))\n",
    "                outfile.flush()\n",
    "            time_index+=1\n",
    "        thetas[0]=thetas[1]\n",
    "    tic.stop()\n",
    "    return (thetas[1:], likelihoods)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-03-19 21:29:11.723705, # nodes: 15919 | # edges: 16905195 | average degree: 4547.891324831961 | average edge size: 4.282581892725875\n"
     ]
    }
   ],
   "source": [
    "print(\"{}, # nodes: {} | # edges: {} | average degree: {} | average edge size: {}\".format(datetime.now(),G.shape[1],G.shape[0],G.sum(axis=0).mean(),G.sum(axis=1).mean()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "K = 20 # dimension of hidden space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimating...\n",
      "Elapsed time: 48363.13294005394 seconds\n"
     ]
    }
   ],
   "source": [
    "with open(\"output_medline_mesh.txt\", 'w') as logfile:\n",
    "    thetas,likelihoods=estimate(G,paper_dates,K,discontinue=1.0,nepochs=5,batchsize=1000,outfile=logfile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "thetas=[theta.copy_to_host() for theta in thetas]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('../Fitted_Model/block_model_medline_mesh.pkl','wb') as outfile2:\n",
    "    pickle.dump([thetas,likelihoods,np.unique(paper_dates)],outfile2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('../../Fitted_Model/block_model_medline_mesh.pkl','rb') as infile:\n",
    "    thetas,likelihoods,times=pickle.load(infile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from evaluate import evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating time 1948...\n",
      "Evaluating time 1949...\n",
      "Evaluating time 1950...\n",
      "Evaluating time 1951...\n",
      "Evaluating time 1952...\n",
      "Evaluating time 1953...\n",
      "Evaluating time 1954...\n",
      "Evaluating time 1955...\n",
      "Evaluating time 1956...\n",
      "Evaluating time 1957...\n",
      "Evaluating time 1958...\n",
      "Evaluating time 1959...\n",
      "Evaluating time 1960...\n",
      "Evaluating time 1961...\n",
      "Evaluating time 1962...\n",
      "Evaluating time 1963...\n",
      "Evaluating time 1964...\n",
      "Evaluating time 1965...\n",
      "Evaluating time 1966...\n",
      "Evaluating time 1967...\n",
      "Evaluating time 1968...\n",
      "Evaluating time 1969...\n",
      "Evaluating time 1970...\n",
      "Evaluating time 1971...\n",
      "Evaluating time 1972...\n",
      "Evaluating time 1973...\n",
      "Evaluating time 1974...\n",
      "Evaluating time 1975...\n",
      "Evaluating time 1976...\n",
      "Evaluating time 1977...\n",
      "Evaluating time 1978...\n",
      "Evaluating time 1979...\n",
      "Evaluating time 1980...\n",
      "Evaluating time 1981...\n",
      "Evaluating time 1982...\n",
      "Evaluating time 1983...\n",
      "Evaluating time 1984...\n",
      "Evaluating time 1985...\n",
      "Evaluating time 1986...\n",
      "Evaluating time 1987...\n",
      "Evaluating time 1988...\n",
      "Evaluating time 1989...\n",
      "Evaluating time 1990...\n",
      "Evaluating time 1991...\n",
      "Evaluating time 1992...\n",
      "Evaluating time 1993...\n",
      "Evaluating time 1994...\n",
      "Evaluating time 1995...\n",
      "Evaluating time 1996...\n",
      "Evaluating time 1997...\n",
      "Evaluating time 1998...\n",
      "Evaluating time 1999...\n",
      "Evaluating time 2000...\n",
      "Evaluating time 2001...\n",
      "Evaluating time 2002...\n",
      "Evaluating time 2003...\n",
      "Evaluating time 2004...\n",
      "Evaluating time 2005...\n",
      "Evaluating time 2006...\n",
      "Evaluating time 2007...\n",
      "Evaluating time 2008...\n",
      "Evaluating time 2009...\n"
     ]
    }
   ],
   "source": [
    "res = evaluate(G, paper_dates, thetas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "res.to_csv(\"../Results/MEDLINE_MeSH_evaluation.csv\", index=False)\n",
    "# res = pd.read_csv(\"../Results/MEDLINE_MeSH_evaluation.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>time</th>\n",
       "      <th>num_nodes</th>\n",
       "      <th>num_edges</th>\n",
       "      <th>mean_edge_size</th>\n",
       "      <th>max_edge_size</th>\n",
       "      <th>mean_degree</th>\n",
       "      <th>auc</th>\n",
       "      <th>auc_std</th>\n",
       "      <th>repeated_edges</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1948</td>\n",
       "      <td>2488</td>\n",
       "      <td>2569</td>\n",
       "      <td>2.185675</td>\n",
       "      <td>6</td>\n",
       "      <td>10.819534</td>\n",
       "      <td>0.8459</td>\n",
       "      <td>0.007829</td>\n",
       "      <td>143</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1949</td>\n",
       "      <td>2064</td>\n",
       "      <td>3636</td>\n",
       "      <td>2.245050</td>\n",
       "      <td>53</td>\n",
       "      <td>15.930717</td>\n",
       "      <td>0.9583</td>\n",
       "      <td>0.006589</td>\n",
       "      <td>478</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1950</td>\n",
       "      <td>2203</td>\n",
       "      <td>8987</td>\n",
       "      <td>2.370869</td>\n",
       "      <td>32</td>\n",
       "      <td>28.710395</td>\n",
       "      <td>0.9492</td>\n",
       "      <td>0.006274</td>\n",
       "      <td>1108</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1951</td>\n",
       "      <td>2534</td>\n",
       "      <td>10680</td>\n",
       "      <td>2.288577</td>\n",
       "      <td>8</td>\n",
       "      <td>29.824388</td>\n",
       "      <td>0.9594</td>\n",
       "      <td>0.004800</td>\n",
       "      <td>2377</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1952</td>\n",
       "      <td>2115</td>\n",
       "      <td>10845</td>\n",
       "      <td>2.312218</td>\n",
       "      <td>10</td>\n",
       "      <td>37.018913</td>\n",
       "      <td>0.9725</td>\n",
       "      <td>0.005162</td>\n",
       "      <td>2807</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   time  num_nodes  num_edges  mean_edge_size  max_edge_size  mean_degree  \\\n",
       "0  1948       2488       2569        2.185675              6    10.819534   \n",
       "1  1949       2064       3636        2.245050             53    15.930717   \n",
       "2  1950       2203       8987        2.370869             32    28.710395   \n",
       "3  1951       2534      10680        2.288577              8    29.824388   \n",
       "4  1952       2115      10845        2.312218             10    37.018913   \n",
       "\n",
       "      auc   auc_std  repeated_edges  \n",
       "0  0.8459  0.007829             143  \n",
       "1  0.9583  0.006589             478  \n",
       "2  0.9492  0.006274            1108  \n",
       "3  0.9594  0.004800            2377  \n",
       "4  0.9725  0.005162            2807  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "res['frac_repeated']=res[\"repeated_edges\"]/res[\"num_edges\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = res[res[\"time\"]>=1966]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(df[\"time\"], df[\"frac_repeated\"], label=\"Content\");\n",
    "plt.ylabel(\"Fraction of repeated edges\", fontsize=14);\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcQAAAD8CAYAAADpAdRrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAABUVElEQVR4nO3dd3hUVfrA8e+bXmkJvYYqTZCOrGIXdYW1d8HGupZVd113Lbv6s6yuurv2gojCropdcK2oKDYQpHdCaKGTBNLLzLy/P+4NDiFlEpLJJHk/zzMPM/feOXPmZph3zrnnnFdUFWOMMaapC6vvChhjjDGhwAKiMcYYgwVEY4wxBrCAaIwxxgAWEI0xxhjAAqIxxhgDBDEgisg0EdkjIisr2C8i8pSIpIrIchEZ4rdvoohscG8Tg1VnY4wxTUcwW4ivAuMq2X8G0Mu9TQaeBxCRVsC9wEhgBHCviLSs05oaY4xpcoIWEFV1HpBZySETgBnqmA+0EJH2wOnAHFXNVNUsYA6VB1ZjjDGm2iLquwJ+OgLb/B6nu9sq2n4YEZmM07oEGBoXF1cH1TTGmMYrPz9fVbVJji8JpYB4xFR1CjAFID4+XvPy8uq5RsYY07CISEF916G+hNKvgO1AZ7/HndxtFW03xhhjak0oBcTZwJXuaNNRwAFV3Ql8BpwmIi3dwTSnuduMMcaYWhO0LlMReQM4AUgWkXSckaORAKr6AvAxcCaQCuQDV7n7MkXkAWChW9T9qlrZ4BxjjDGm2qSxpn8q7xpiSUkJ6enpFBYW1lOtGo6YmBg6depEZGRkfVfFGBNEIpKvqvH1XY/60KgG1VQlPT2dxMREunXrhojUd3VClqqSkZFBeno6KSkp9V0dY4wJilC6hljnCgsLSUpKsmBYBREhKSnJWtLGmCalSQVEwIJhgOw8GWOamibVZRpKfKqUeHwUubfIcKFZbCRhFoiMMRXw+pR1u3L4eWsWPZLjObZncn1XqVGxgBgEPlVyCkrIK/ZS7PGRvmMnD93zZ1YuW0xi8+YkJbfmT/c9TK9evUlOiKJVfBThYVU33p944gkmT55MTVfk+frrr4mKiuLYY4+t0fONMXWrsMTLsm37WbQli582ZbJ4SxY5RZ6D+y8d2YV7zupLXJR9ldcGO4t1yOvzkZlXzL7cYkq8PsJEiAwXfn/NZVx06WW89sYbREeEsXbVCvZm7icqIoydBwrZnV1Eq/gokhOiiIoIP6xcnyrFHh//+vcTTDjvIrrGxBIWVv2W5ddff01CQoIFRGNCgM+nbM7IY3n6AZZu28+y9P2s2p5NsdcHQO+2CZw9uAMjurVicOcWvPHTVqZ8m8YPqfv490WDOaaL5Tw4Uk1q2sWaNWvo27dvnb92scfLvtxiMvOK8akSHx1B64RoEmMimDt3Lvfddx/z5s075Dmqyh133MHHH3+CV5VrbrqdcePPYdXPP/L04w/TolUSa1evot/AwTz05Iu89soU/vXgX+nWvSctWyXx7v8+4+cfvuYfDz1AUVERPXr04JVXXiEhIYFu3boxceJEPvzwQ0pKSnj77beJiYlh1KhRhIeH07p1a55++mmOO+64ejlfxjRFHq+P7zdm8NOmDJanH2DZtv1kFzqtv9jIcAZ0bMaQLi0Z3q0VQ7u2pGV81GFlzE/L4I9vLWNXdiE3ntiTm0/qSWT4kQ0NsWkXTdD/fbiK1Tuya6UsxQlovdsmMvn47mQXlABC87hIWidEEevXnbFy5UqGDh16WBnvvfceS5cuZfnyZezbt4/hw4dz6sljKSjxsnzZUt7/cj6dO3XkkvGnsWn1Yv5y+23MnPY8c774kvC45mzZvosHHniQF197j/bJLZj27BP885//5N577wUgOTmZxYsX89xzz/H4448zdepUrr/+ehISErj99ttr5TwYY6qWuieHtxel896S7ezNKSI8TOjTNpGzju7A4M7NObpTC3q1SSAigMA2qnsSn9x6HPfNXsVTX27gm3V7+NdFg+nROiEI76TxabIBsaZKvD58qqiCT0FRJyIC2YUl5BZ5SE6MJik+mqiIwH+pfffdd1xyySWEh4fTtm1bxo4dy9Z1K+naKpGRI0Zw8rC+iAgjhw0hZ+9OWsZFIUBCTCTJreJY8t0qNm9cz5XnnI7Pp5SUlHDMsBEUe7wAnHvuuQAMHTqU9957r7ZPizGmEgcKSvjf8h28vSidpdv2Ex4mnNinDRcM68TxvVoTG3X4pZFANYuJ5F8XDuaUvm256/0VnPXUt9x9Zl8uH9XVRotXU5MNiPee3T/gY1WVrPwSdh0oxOPzER0RTkS4EBkWRmS4EBHu/hsWRmxUOOGVXM/r378/77zzTsCvHRYmxMTEHPxgh4eH4/F4DjtOBE479VTeeOMNvD4fBwo87DxQwMa9eSgQHR1d6fONMbVHVdmWWcCPafuYt2EfX6zeTZHHR5+2idxzVl8mDO5I68ToWn3NMwe2Z1jXlvzpneV8sWYPl4/qWqvlNwVNNiAGqqDYw/b9heQXe4iLiqBbi7gjGtF10kkncddddzFlyhQmT3ZSNy5fvpwWLVrw5ptvMnHiRDIzM5k3bx6PPfYYa9eurbCsxMREcnJySE5OZtSoUdx4442kpqbSs2dPoinBm7kdadUJj1cpKPaW+/zs7NrpNjamqdt1oJAf0/bxQ2oGP2zMYPt+J4tSckI0Fw7rzAXDOjGwY/M6bbW1aRbDq1cNJ6/Ya63DGrCAWAGP18fu7CIy84oIDwujU8s4WsZFHvGHTER4//33ufXWW/nHP/5BTEwM3bp144knniA3N5dBgwYhIjz66KO0a9eu0oA4efJkxo0bR4cOHZg7dy6vvvoql1xyCUVFRQA8+OCDnNanDwBbMvNolXRoy/Dss8/m/PPPZ9asWeUOqjHGVC5tby6zlu7gf8t3sHGvM4ivRVwko7sn8dux3Tm2RxI9WicENTiJCAnR9tVeEzbKtAyne7SYXQeK8Pp8JCVE0yYxOqAL3KGq2OMlbV8eHq/SLSmOhJjAFuy2UabGHG5PTiEfLtvJrKXbWZ5+ABEY3T2Jk45qw+geSfRt16xG06BChY0yNQcVe3xszyokLiqcDi3ij+hid6iIiginR+sENu3LY1NGPl1bxdEs1rJYGBOo/fnFzFm9m1lLd/DDxn34FAZ0bMY9Z/Xl7EEdaNsspr6raGqBBcQyoiPD6dkmnpjI8EbVBx8ZHkb35Hg2Z+SxJSOfzq1iaRF3+LwmY4wjPSufOat38/mq3fy0OROvT+nSKo6bTuzJ+MEd6dnGpjY0Nk0uIKpqlYEutpEugxQRHkZKcjybM/LZmplPsddH64Tocs9HY+1KN6Yiqsq63Tl8vmo3n63axSp3nnLvtglcP7Y7p/Vrx9Gd6nZQjKlfjfObvwIxMTFkZGQ06RRQ4WFhpCTFk55VwK4DhRSV+OjYMvaQRcVL8yHGxFg3kGn89uYUMWvpdt75OZ21u3IQgaFdWnLXmUdxar92pCQ3yctpFRKRacCvgT2qOqDMvj8CjwOtVXWfOF+0TwJnAvnAJFVd7B47EbjHfeqDqjrd3T4UeBWIBT4GbtEg/UJvUoNqSkpKSE9Ptzx/ruyCErILPURHhJEUH3XIQICYmBg6depEZKRdazSNT7HHx1drd/POz+nMXbcXr08Z3LkF5w3pyOkD2tEmsen+GKxqUI2IHA/kAjP8A6KIdAamAkcBQ92AeCZwM05AHAk8qaojRaQVsAgYhrO0yc/uc7JE5Cfg98ACnID4lKp+Uhfvtawm1UKMjIy0DPBlzFq6nRvfWU775jFMmzTclnwyjZbH6+PnLVl8snIXs5ZuJyu/hDaJ0Vx3XHfOH9qRnm0S67uKDYKqzhORbuXs+jdwBzDLb9sEnMCpwHwRaSEi7YETgDmqmgkgInOAcSLyNdBMVee722cAvwEsIJq6N2FwRzq1jGXyjJ8559nvef7yoYyxHGumkcgt8jBv/V6+WL2br9btYX9+CVHhYZzavy0XDO3Er3omN+gpVXUkQkQW+T2eoqpTKnuCiEwAtqvqsjKXozoC2/wep7vbKtueXs72oLCAaBjatRUf3DiGa6YvZOK0n7h/wgAuHdmlvqtlTI1k5hXz0fIdzFmzh/kbMyj2+mgRF8lJfdpwSr+2HNcrmcQA5+I2UR5VHRbowSISB9wFnFZ3VQoOC4gGgM6t4nj3d8dy8xtLuOv9FazZmc1ff92vWguUG1Of1uzM5tXvN/PB0u0UeXykJMczaUw3Tj6qDUO7trSWYN3pAaQApa3DTsBiERkBbAc6+x3byd22Hafb1H/71+72TuUcHxQWEM1BiTGRTL1yGI99vo4Xv0ljzc5snrtsCG1s0rEJUV6fMmf1bl79YRPz0zKJiQzjvKGduHJ0V45q16y+q9ckqOoKoE3pYxHZDAxzB9XMBm4SkZk4g2oOqOpOEfkM+LuIlGY1Pg24U1UzRSRbREbhDKq5Eng6WO+lSY0yNYH73/Id/Ont5STGRPD85UMZ2tWycZvQkVvk4fUFW5j+wxa27y+gY4tYrhzdlYuGd7YFJ45QAKNM38Bp3SUDu4F7VfVlv/2b+SUgCvAMMA5n2sVVqrrIPe5qnK5WgIdU9RV3+zB+mXbxCXBzVdMuRCQMQFV97uN2OFND1qjq9wG/dwuIpiJrd2Xz2//8zI79Bdw3vj+XjujSZOdvmtCgqny2ajf3zV7FruxCRqa04qox3Tilb1vrEq0lDXEtUxH5BPhUVZ8UkQRgLRAPJADXqOqMgMqxgGgqcyC/hFveXMLX6/Zy0bDO/N+E/sRENvz1XU3Ds31/AffOWsUXa3bTt30zHjpnAEO6WM9FbWugAXEvcJKqrhCRK4G/AIOAy4A/qOrRgZQT1J9UIjJORNaJSKqI/KWc/V1F5EsRWS4iX4tIJ799/xCRle7tomDWuylrHhfJyxOHc9OJPXlz0TYumjKf9Kz8+q6WaUI8Xh9Tv03j1H99w/ep+7j7zL58eNMYC4bGXwKw371/GvC+qpYAX+EM+glI0AKiiIQDzwJnAP2AS0SkX5nDHseZxHk0cD/wsPvcs4AhwGCcC7O3i4hdMQ+S8DDh9tP78MLlQ9m4J5eznvqOOat313e1TBOwIv0Av3nuex78aA0jU1rx+W3Hc93x3a171JS1FRgjIvHA6cAcd3srnGuXAQnmp2oEkKqqaapaDMzEWcXAXz+ciA4w129/P2CeqnpUNQ9YjnOR1gTRuAHt+Oj3v6Jzq1ium7GI+z9cTbHHV9/VMo1QVl4xf5u1kgnPfsee7CKeu2wI0yYNp3OruPqumglN/wL+gzORfzswz91+PLAi0EKCGRArWpnA3zLgXPf+OUCiiCS528eJSJyIJAMncujcFhMkXZPiefd3xzLp2G5M+34TF7zwA9syrQvV1I4Sr49Xv9/ECY9/zX/nb+HyUV354o9jOXNgexvQZSqkqi8Co4CrgV+VjjYFNgJ/DbScUJuHeDvwjIhMwonw2wGvqn4uIsOBH4C9wI+At+yTRWQyMBkgKsqGXteV6Ihw7hvfn1HdW/Gnd5Zz5lPf8tj5RzNuQPv6rpppwL5Zv5cH/rea1D25jOmZxN9+3Z8+7Wx9URMYVf0ZZ5Fw/20fVaeMoI0yFZHRwH2qerr7+E4AVX24guMTgLWq2qmcfa8D/1XVjyt6PRtlGhzbMvO56fXFLEs/wMTRXbnzzL42CtVUS9reXB76aA1frt1D16Q47j6zL6f2a2stwnrSEEeZAojIMTi9h20o0/upqncEVEYQA2IEsB44GafltxC4VFVX+R2TDGSqqk9EHsJpHf7NHZDTQlUzRORo4HVgsKp6Kno9C4jBU+zx8eina5n63SZSkuN5+NyBjOqeVN/VMiGusMTLk19uYOq3aURHhHPzST2ZNKYb0RH2g6o+NcSAKCJ3AI8AW3AWC/APbKqqxwZUTjDnIbq5sZ4AwoFpqvqQiNwPLFLV2SJyPs7IUsXpMr1RVYtEJAZY7BaTDVyvqksrey0LiMH3feo+7nxvBVsz87l0ZBf+csZRNLNFlE055qdlcOd7K9i0L4/zh3bijnF9mnQOwlDSQAPiTpweyBePqBybmG9qU36xh399vp5p32+iTWIMD/5mAKf0a1vf1TIhIruwhEc+WcvrC7bSpVUcD5870NKNhZgGGhB3A2NUNfWIyrGAaOrC0m37+fM7y1m3O4dfH92e+8b3Jzkhur6rZerRF6t3c88HK9mTU8jVY1L4w2m9iYsKtXF9poEGxPuASFW9+4jKsYBo6kqxx8cL32zk6a82EBcVweDOLWjbLJo2iTG0bRZN68QY2jSLpl2zGNo3j6n2IAqP10d4mNjgixC3L7eI//twNR8u20Gfton84/yjGdy5RX1Xy1SggQZEAT4G2gErgRL//ap6dUDlWEA0dW3D7hye/HIDWzPz2Z1dyL7cYry+Qz933ZLiGD+oA+MHd6Bnm4qH2heWePlq7R5mL93BV+v20KdtIo+cN5D+HZrX9dsw1bQnp5Cp327iv/O3UOL1cfNJvbh+bA/LsRniGmhA/DvwZ5yxJmUH1aCqZwdUjgVEE2xen5KRV8Se7CL25BSyLbOAz1fv4seNGfgU+rZvxvhBHTh7UHs6tYyjxOvju9R9fLh0B5+v3k1ukYfkhGhO6duGL9bsJiu/hOvHdufmk3rV2ZSP/GIPry/YSlZ+Mbee0ptIWzqsQjsPFPDiN2m88dNWSrw+zh7Ugd+f3IserRPqu2omAA00IO4Hfquqbx5RORYQTajYk1PIR8t3MnvZDpZs3Q/AoE7N2ZZVQGZeMYkxEZwxoB3jB3VkVPdWRISHkZVXzIMfreHdxel0bx3PP847muHdWtVanfKLPfznxy1MmZdGRl4xAMf3bs1zlw0hIdquf/nblpnP899s5J1F6fhUOeeYjtxwYk9SkhvUd2uT10AD4k5grKquP6JyLCCaULQ1I58Plzstws4tYxk/qANj+7SucI7avPV7uev9FaRnFXDFqK7cMa4PiUcw5SOvyMOMH7fw0rdpZOYVc1yvZG49pRepe3K56/2V9GvfjGmThtM60QYKrd+dw5R5aXywZDthIlwwrBPXj+1h6442UA00IN4BdMOZqlfjoGYB0TQaeUUeHv98Ha/+sJl2zWL4zTEdCatgvE1EWBgJ0RHER0cQHx1OfJRzPyE6gm9T9/LSvDSy8ksY27s1vz+5F0O7/pJq6Ku1u7nhtcW0SYxh+tUjmmQLSFWZn5bJlHkbmbtuL7GR4Vw0vDO/Hdud9s1j67t65gg00ID4Ic5C3vuB1Rw+qGZ8QOVYQDSNzeKtWdz9/ko27M6p8BiPr/LP/Ql9WnPLyb04poKce0u2ZnHN9EUATJs0vMmMmvR4fXy6ahdT5qWxPP0ASfFRTDy2G1eM6krLeFs/uDFooAHxlcr2q+pVAZVjAdE0RV6fkl/sIa/IS26Rh7wiD3nu4w4tYgIatZq2N5eJr/zEvpxinrt8CCf2aROEmteftxdt46mvNrAts4BuSXFcd3x3zhvSydaubWQaWkB0lwWdDHygqjuOqCwLiMbU3J6cQq56ZSFrd+Xw8LkDuXBY48tK5vMpf/94DVO/28Sgzi343djunNqvHeEV9UebBq2hBUQAEckD+qnqliMpx8aOG3ME2iTG8OZvR3NsjyTueGc5j322Fl8V3bENSbHHx61vLmXqd5uYOLor7/3uWMYNaG/B0ISa+cDQIy3EWojG1IISr4+/frCSmQu3cebAdvzzgsHERjXsrsScwhKu/+/PfJ+awR3j+vC7sT1sVaAmoIG2EC8G/g48hZMT8ZAvf1VdXN7zDivHAqIxtUNVmfrtJv7+yRoGdmzO1CuH0aZZw8zgsCe7kImvLGTD7hz+cd7RnDf0sLSkppFqoAHRV8luVdWAfp1aQDSmls1ZvZtbZi6heWwkUycOa3DLym3cm8uVL/9EVn4xz18+lLG9W9d3lUwQNdCA2LWy/YFeW7SAaEwdWLXjANdOX8SBghKeuviYBpMC6+ctWVwzfSERYcK0ScM5ulOL+q6SCbKGGBBriw2qMaYO9O/QnFk3jqFnmwSu+88ipszbSKj/+Fy8NYvLpy6geWwk7/7uWAuGpkERkTNE5H8islpEOrvbrhWRkwMtwwKiMXWkTbMY3pw8mjMGtOPvH6/lkpfms3lfaPZabNidw9WvLqRNs2jevn40XZOaZAPBNFAichnwFrABSAFK120MB+4IuJxQ/9VaU9ZlakKFqvLmwm089PEaij0+/nBqb675VQoRIZIxIz0rn/Of/xGvKu9efyxdkmwN0qasIXaZisgy4GFVnSkiOcAgVU0TkUHA56oa0DWL0PgfaUwjJiJcPKILX/xhLGN7t+bhT9ZyznM/sGrHgfquGhm5RVz58k/kFXuYcfUIC4amoeoF/FjO9lygWaCFWEA0JkjaNovhxSuG8txlQ9h5oIDxz3zPY5+tpbDEe8hxXp+SXVjCzgMF7M0pqrP65BZ5uOrVhWzfX8DLE4fTt33A3xvGhJodQO9yth8PbAy0EOsyNaYe7M938ji+83M6rROjiYsKJ6/IQ26Rh8KSX6ZUicC/LxzMb47pWKuvX+TxcvWrC52MFVcM5eS+DWMUrKl7DbTL9A7gKuBa4FPg1zjpoB4H7lPVZwMqxwKiMfVn3vq9vLlwG5HhQpybfspJRRVOfHQE7y1OZ3n6Ad793bEM6Fg78xm9PuXmNxbz8Ypd/POCQTbp3hyiIQZEABF5CLgNKF0Nowh4XFX/GnAZFhCNCV37cosY//R3AMy++VckJxxZQmKfT7n7g5W88dNW7jmrL9ce1702qmkqsCe7kDOf+pbkhGjGD+7A2Ud3CPnEyQ01IAKISBzQD+dy4GpVza3O8+0aojEhLDkhmhevGEZGXjE3vraYEm9lK1RV7kBBCddMX8gbP23lhhN6WDAMgoc+XkN2oYfYqHAe/XQdxz06l3Of+55Xv99Up9eH65KITBORPSKy0m/bYyKyVkSWi8j7ItLCb9+dIpIqIutE5HS/7ePcbaki8he/7SkissDd/qaIVJlo061Toqrmq+oiVf1JVXNFJF5EpgX83qyFaEzoe39JOre9uYxJx3bjvvH9q/389btzmDxjEelZBdw7vj+Xj+xiC3XXsR9S93Hp1AXccnIvbju1N9sy8/lw+Q5mL93B2l05hAkc2yOZP57Wu8JE1PWhqhaiiByPM3pzhqoOcLedBnylqh4R+QeAqv5ZRPoBbwAjgA7AF/wy+GU9cCqQDiwELlHV1SLyFvCeO4XiBWCZqj5fRZ29QHtV3VNmezKwS1UjAnnvAR1kjKlf5xzTiVXbs5n63Sb6dWhWYd7FIo+XtxZu453F2xnapSVXjenGyu0H+OPby4iLiuCNyaMY3q1VkGvf9BR5vNwzayVdk+L43Qk9AOjcKo4bTujJDSf0ZMPuHGYv28Hbi9K5fOoCXrtuFIM7t6jfSgdIVeeJSLcy2z73ezgfON+9PwGYqapFwCYRScUJjgCpqpoGICIzgQkisgY4CbjUPWY6cB9QbkAUkVaAuLeWIuLx2x0OnAXsDvS9WUA0poH4yxlHsWZXNve8v5JebRIOaVUUlnh5a9E2npu7kV3ZhfRsk8D0HzYx7ftNAPRum8CMq0fSrnnDzL7R0Ez9dhNpe/N45arhxEQenmihV9tE/nhaHy4b2ZULX/yRK19ewMzJo+nXISSmvkSIyCK/x1NUdUo1nn818KZ7vyNOgCyV7m4D2FZm+0ggCdivqp5yji/PPkDd2+py9itwb6AVD+o1xIr6jP32dxWRL91+6K9FpJPfvkdFZJWIrBGRp8T6e0wTExEexjOXDKFNs2iu/+/P7MkppLDEy6vfb2LsY3P526xVdGoZy3+uGcE7149meIrTEowMF9bvzuXG1xfzyYqdeBtRAuNQtC0zn6e+3MAZA9pxYp82lR7brnkMr107kvjoCK54eQGpe3KCVMtKeVR1mN8t4GAoIncDHuC1uqveIU4ETsZpIZ6P07osvf0K6KKqDwVaWNBaiCISDjyLX5+xiMxWVf+o/jhOv/R0ETkJeBi4QkSOBcYAR7vHfQeMBb4OVv2NCQUt46OYcsUwznv+B66Y+hP7C4rZnV3EiG6t+NeFgzm2RxJp+/KY8Oz37NhfwN/PGciEwR14e9E2Xv5+E797bTGdW8Xy9CVDgtZFp6o1ul65J6eQ7VkFIXV9LRD/9+EqwsOEv/66X0DHd24Vx2vXjuTCF+dz6UsLjngt2W837EUVjg9y2i4RmYQz/+9k/WVwynbAv3+/k7uNCrZnAC1EJMJtJfoffxhV/cZ97RRgqx7hoJhgthBH4PYZq2oxMBOnf9lfP+Ar9/5cv/2KM7ckCojGWbg14H5hYxqTfh2a8dgFR7N+Tw5dk+J5/bqRvPnbUYzpmczCzVmc+9wP5BV5mDl5NJeO7EJ8dASTxqTw9e0n8sLlQ/B4lT+9veyIRqwGqsjjZdIrC7nwxR/Zn18c8PO2ZeZzzrM/cM5zP3D/h6sp9tR9XWvDnNW7+WLNHm49pRcdWsQG/LzurRN47dqRlHh9XPrSArbvL6hxHZ6bu5Envlhf4+fXhIiMw1lEe7yq5vvtmg1cLCLRbtDqBfyEM4imlzuiNAq4GJjtBrS5/HINciIwq6rXV9UtRxoMIbgBsSOH9xmX7RteBpzr3j8HSBSRJFX9Eeck7XRvn6nqmrIvICKTRWSRiCzyeDxldxvTaPz66A4s/dtpvPXb0RzbIxkR4cNlO7h86gKSEqJ4/4YxDO16aMsqPEwYN6A9908YwIY9ucz4MaCcqTXm8yl/ens536zfy5KtWVz04nz25BRW+bytGflc9OKP5BZ5OH9oJ6Z9v4kLXviBbZn5VT63PuUXe7hv9ip6t03gqjEp1X5+n3aJzLh6JNkFJVz20nz2ZFd9rsqzJSOPbnWYrURE3sBZN7SPiKSLyDXAM0AiMEdElrqjQ1HVVThZKFbjrCBzo6p63dbfTcBnwBrgLfdYgD8Df3AH4CQBL9fZmykj1OYh3g6MFZElOF2i2wGviPQE+uI0nzsCJ4nIcWWfrKpTSvu9IyJsvJBp3JrHOhluVJUXvtnIzW8sYXDnFrz3u2Mrnfx9St82jO3dmifmrK/TuXCPf76O2ct2cMe4PrwyaQRbM/O58IUfSc+qOLBtycjj4ik/kl/i5fXrRvL4BYN44fIhpO3L48ynvuXTlTvrrL5H6pmvUtm+v4AHfzOQyBpmMhnYqTmvXj2cPTlFXDZ1AZl5gbeqwRlctTO7sE7Td6nqJaraXlUjVbWTqr6sqj1VtbOqDnZv1/sd/5Cq9lDVPqr6id/2j1W1t7vvIb/taao6wi3zAneEalAEMyBW1pcMgKruUNVzVfUY4G53236c1uJ8Vc11Vx74BBgdlFobE8I8Xh9/nbWSRz5Zy9mDOjDjmhG0iKt8HrOIcO/Z/Sj0ePnHp2vrpF6vLdjCc19v5NKRXfjd2B78qlcy/712BBl5xVz4wo+k7T18AZHN+/K4eMp8Ckq8vH7tKPp3cJaqGzegPR///ji6J8dz/X8Xc++slYctiK6qbNidw39+3MyNry3m6lcXBqVLuFTqnhxe+jaN84Z0YkTKkU1rGdq1FVOvHMaWzHwe/3xdtZ6bnpWPKnRLDu3VcEJVMJtRB/uMcQLhxfwy1wQ4OIkyU1V9wJ1A6QoDW4HrRORhnNFEY4EnglRvY0JSfrGHm19fwpdr93D92B7ccXofwsICG7zSvXUC1/yqOy98s5FLRnQ5rHv1SMxdu4e/frCSE/u05v7x/Q8OqBnatRUzJ4/iypd/4sIXf2TG1SMPTjPYtC+PS6bMp9jr4/XrRh2WeaNzqzjevv5YHv10LVO/28SiLVncfWZfNuzJZcGmDBakZZLhtqZiIsMoLPGxL7eI9s0Dv45XU6rKPR+sJDYynDvPPKpWyjy2ZzJDurRg7c7saj1v8z6n9d0lxJeHC1VBC4juCgalfcbhwDRVXSUi9wOLVHU2cALwsIgoMA+40X36OzjDaFfgDLD5VFU/DFbdjQk163fn8Me3lrFqxwEe/M0ALh/Vtdpl3HxST95fks59s1fxwY1jCA8wmFZmRfoBbnx9Mf06NOOZS4cclgS5f4fmvHX9aC6fuoCLp/zIq1ePoEVsJJe8NJ8Sr/L6dSM5ql35c/GiIsK459f9GNU9iT++vYxLpy4AoGOLWMb2ac2olCRGdU9iybYsbpm5lNxCD9TOeuiV+nr9XuanZfLAhP5HvNasv5TkhGp3EW/OcFbnqstriKEk0GXZVPXqQI4L6oU2Vf0Y+LjMtr/53X8HJ/iVfZ4X+G2dV9CYEJeZV8wTX6zntQVbiYsK56Urh9U4dVN8dAR3ndmXW2Yu5c2F27h0ZJcjqtu2zHyunr6QlnFRTJs0nPjo8r9eerRO4O3rR3PZ1AVcPnUB8dER+HzKG9eNok+7xCpf55R+bfns1uNZtCWTQZ1aHHa9dKPbHZtbVPcD61SVJ7/YQMcWsVw0/MjOX1k9WseTlV9CVl4xLeOrXM4TgC0Z+TSLiaBFXGSt1iWElZ1bcjrwLVCjEVg28sSYBqDY4+M/87fw5BfrySv2ctnILtx6Sm9aBfhFWZHxgzrw2oKtPPbZWs4c2K7C649z1+7h4U/WkFPoISU5/uCte+t4UpITaBYTwVWvLqSoxMvr146kTWLlK+J0ahnH278dzRUv/0RGXhGvBxgMS7VrHsOvj+5Q7r7SQByMgPhd6j6WbtvPQ+cMICqidodkpCQ7rbxNGXmBB8TMfLolxzeZdWpV9Wz/xyKSA1xXuiRcdVlANCaEqSpfrd3DQx+tIW1fHsf3bs1fz+pLr7aBB4/KiAj/N74/v376O/75+Xoe+M2AQ/Zvzcjn/v+t4os1e+jeOp7R3ZPYlJHH/5bv5EBBySHHRoWHMeOaEQHXrU2zGD68+VcUebwkxtReiybBDYh5dRwQVZWnvtxA++YxnF8HOSUPBsS9eQwJcHGCLRl5DKylvJlNkQVEY0LUlow87vlgJd9u2EeP1vG8ctXwKpcCq4m+7ZtxxaiuzPhxMxeP6Ez/Ds0pLPHy3NcbeeGbjUSECXeecRRXjUk52ApSVbLyS9i0L5e0vXlszshjTM9kRnVPqtZrR0WE1XrLqjQg5hTWbUCcn5bJws1Z/N/4/kRHHL5e6ZHq3CqO8DAhbV9gKf1KvD7Sswo4u4KWs6maBURjQoyq8t7i7fxt1krCwoT7zu7HZaO61nhuWyBuO7U3Hy7bwb2zVjH5+O7c/7/VpGcVMH5QB+46s+9hi4KLCK3io2gV34qhXUMre0ZCTHBaiE99uYE2idFcNLz8zCNHKjI8jC6t4ti0L7A0dtuzCvD6lK5JNsK0piwgGhNCDhSUcM8HK/lw2Q5GdGvFvy8eTMdqLAFWU81jI7ljXB/+/O4KFv3nZ3q3TeCN60Yxukf1WnyhID7aaa3V5TXEhZsz+TEtg3vO6ltuNovakpIcT9rewALiFncln27JTWOEKYCIDCm7Cejvn6AYQFUXB1KeBURjQsTCzZncOnMpu7ILuf203vzuhJ61MhUiUBcM7cyanTl0aRXHFaPrtkVal6IjwokKDyO3yFv1wTX01JcbSE6I4rKR1Z/uUh3dk+P5YeM+fD6tco7pFnfKRRNrIS7CmYrnf3LKrn2qOFP9qmQB0Zh65vH6eOrLDTwzN5VOLeN45/rR9ZLhISxMuG98/6C/bl2Ijw4nt6ik6gNrYPHWLL7dsI87zziK2Ki6ax0CpLSOp7DEx67swioXC9+8L5+4qHBa1+JcyAag+ovGVsICojH1aFtmPr+fuYQlW/dz3pBO/N+E/gcHhZiaS4iJIK+OWohPf7mBlnGRNVoMoboOjjTdl1dlQNySkUeXVnFNZsoFOFkuarM8+59nTD35eMVO/vzuclB46pJjGD/IRgfWlvioiDoZZbo8fT9z1+3lT6f3qXDhgdrUPTkBgLS9uYzpmVzpsZsz8ujVpnam4zQUIpIARKtqht+2vsCfgATgPVWdGWh5FhCNCbLCEi8PfbSG/8zfwqDOLXjmkmMqzU5hqi8xJqJOukyf/iqVZjERXDm67luHAG2bRRMbGU5aFSNNvT5lW2YBp/Sr2apFDdjzwAGcVFKl62F/C/hwUgW+JiJhqvp6IIVZQDQmiNL25nLj60tYszOb645L4U+nH1Xr8/CMs1pNRm71UidVZdWOA8xZvZvbTuldqwsJVEZESEmOr3Lqxa7sQoq9viazhqmf0Ry6rOcVQDHQV1UPiMg/cIKlBURjQsn7S9K5+/2VREeEMW3SME46qsn9mg+ahOgItmRUfzlLr0+pKPH6M1+lkhgdwaQx3Y6wdtWT0jqeldsPVHrMFjdgdm16PQ3tgY1+j08E3lXV0hM2HQhoYW+wgGhMncsrcjKpv/1zOiO6teLJSwYHJS1RU5YQHVHteYipe3I466nvKPJUnEfx5pN6HkzMHCw9kuP5ZMVOij2+CnsTNrvBv2sTmoPoygf83/QI4E2/x4VAwL8SLCAaU0dUlVlLd/DwJ2vYk1PEzSf15JaTex2WEsnUvoToCCf9UzWk7smjyOPjytFdy526EBURFpSRpWWltI7Hp7A1M5+ebRLKPWZLRh5REWG0b1b5ouqN0DLgKuB2ETkBJ/vFV377ewA7Ai3MAqIxdWDl9gPcN3sVi7ZkcXSn5jx/+dCAF2g2Ry4+OoKCEi9enwa8uEF2oTMI57rjuofUIKcUv5GmFQfEfLq0igs4QXQj8gDwiYhciBMMX1VV/ySS5wDfBVqYBURjalFGbhGPf76OmQu3kRQfxaPnHc35Qzs1xS+qepUY80sKqEC7OEunaZQ+N1SkJP0yF7EimzPymuL1Q1T1GxEZCpwG7ALeLnPIUuCnQMsLrb+8MQ1UidfHf+dv4V9z1lNQ7OWaMSn8/pReNAvSaERzqHi/FFCBB0SnhRhqCyM0j4skKT6qwoCoqmzJyOfYHpXPU2ysVHUNsKaCfVOqU1Zo/eWNaYDS9uZy25tLWZZ+gON6JXPv2f3o2cQmSIeahBokCc4u8BAfFR6S13hTkuMrnIu4N6eIghIv3ZKbXgvRn4icgTPFIgU4XVW3ici1wCZV/TKQMkLvL29MA6GqvLZgC2c99R1bMvN59tIhzLh6hAXDEFCTgJhTWBK0+YXV1b11xXMRS7NcdG16cxAPEpHLgLeA9TgBsfQPGQ7cEWg5FhCNqYG9OUVcO30Rd7+/kmHdWvLZrcdz1tHtm9Q6kqGsNCdidUaa5hR6Qu76YamU5AT25hQd7Nb1t9kNlN2aVpaLsu4ArlPV2wD/P/p8YHCghYTmX9+YEPbF6t38+d3l5BR5uPfsfkwc3c0GzYSY+KjqJwnOLiyhWZDnGAbKf5Hvozu1OGTflox8wsOkysW/G7lewI/lbM8FmgVaSKUtRBEZICIfishhBYpIc3df30BfzJiGLK/Iw13vr+DaGYto0yyG/938K64ak2LBMASVtvRyqtVlGrotxO6tKx5pujkjj04tYxts/spasgPoXc724zl0JZtKVfXX/yOwXFWzy+5w14lbgrOqeMBL4xjT0OzJKWTGD1v474ItHCgo4bdju/OHU3sTHVG3ufBMzSVEV7+FmFNYErLZ5p20TpC29/CAuCUjv0lfP3RNAZ5yB9EAdBaR44BHgfsCLaSqgDgGuLiS/e/jXMg0ptFZtyuHqd+mMWvpDkp8Pk7t25brT+hhE+wbgNJpF9W5hphd6KFZiLYQYyLD6dgi9rAWoqqyOSOPY7q0qJ+KhQhVfVREmgNzgBhgLlAEPK6qzwZaTlV//S5ARiX7M4FOgb6YMaFOVfkudR8vfbuJeev3EhMZxkXDO3P1r1IOXscxoS8qIoyoiDByiwMLiKoa0qNMAbq3TjgsIO7PLyGn0EOXJjgpvyxVvVtEHgL64VwOXK2qudUpo6qAmIWzFlxFWYl7Afur84LGhJL8Yg8r0g+wZNt+lm7dz+KtWezJKaJ1YjS3n9aby0Z2pWV8VH1X09RAddYzLfL4KPFqyF5DBOieHM87W7JQ1YOjmTdnlI4wtR9rAKqaDyyq6fOr+ut/A9zKoYul+rsVmBfoi4nIOOBJnLkhU1X1kTL7uwLTcNakywQuV9V0ETkR+LffoUcBF6vqB4G+tjHgtAS+XreXr9buYfHWLNbuysHrc9L9dE2K49geSRzXqzW/HtTerhE2cAnREQFfQ8wucKYzhOooU3BGmuYWedibW0SbRGcR79IUV011Ur6IPBXIcar6+0COqyogPgLMF5H33ftr3e19gb8Ap+AkaKySiIQDzwKnAunAQhGZraqr/Q57HJihqtNF5CTgYeAKVZ2LO5dERFoBqcDngbyuMeAEwi/X7OGJL9ezcns2CdERDO7cghtO6MExXVowqFMLksrJcGAarvhqpIDKdluSoXoNEX6ZepG2N+9gQNyckYcIdGrZNAMizso0W4E0oKLh3uUnuCxHpX99VV0qIufjtNp+KLM7A7hQVZcE+FojgFRVTQMQkZnABMA/IPYD/uDenwt8UE455wOfuE1jYyqlqnyxZg9PuoGwS6s4Hj3/aM45pmNTH6be6CVWIyCWTngP5S5T/7mIo7onAbA1I58OzWOJiQxeb4aITAN+DexR1QHutlY4eQi7AZtxYkOWOH27TwJn4uQunKSqi93nTATucYt9UFWnu9uHAq8CscDHwC1aUdZmZzHv8cAm4GXgHVUtrOl7q/IbQVX/B3TFCUR/Ae4EzgO6qersarxWR2Cb3+N0d5u/ZcC57v1zgEQRSSpzzMXAG+W9gIhMFpFFIrLI46leLjTTuKgqc1bv5tdPf8d1MxaRXeDhsfOP5ss/juXCYZ0tGDYB8dHhNWghhm6XaYcWsURFhB0ysGZzRl59DKh5FRhXZttfgC9VtRfwpfsY4AycsSa9gMnA83AwgN4LjMRpLN0rIqXDt58HrvN7XtnXOkhVL8KJI+8DtwM7ReR5ERlWkzcW0M8hVS1wX7Cu3Q48IyKTcK5Nbge8pTtFpD0wEPisvCe7K5tPAYiPjw+4mWwahz3ZhczflMn8tAy+T93nzs+K47Hzj+Y31iJschJiIg9mkq/KLy3E0A2I4WFCSlL8IXMRt2Tkc1r/tkGth6rOE5FuZTZPAE5w708Hvgb+7G6f4bbw5otIC/d7/ARgjqpmAojIHGCciHwNNFPV+e72GcBvgE8qqU8m8BTOPMRhOPPiPxeRbcDo6vQmVhoQK7lgeQBYB7ytqkUBvtZ2oLPf407utoNUdQduC1FEEoDzVHW/3yEXAu+r6uEL+pkmJzOvmO9T9zE/LYP5aRlsdL8oEqIjGJHSiptP6sVvBncIyewFpu4lRIcfzHFYlVDNhVhWSnI8G/bkAE4Qz8grDpVJ+W39EvPuAkqjdEU9g5VtTy9ne6DW4uRAHImzck21+pKr+usPrGB7C5wRpveJyEmqujWA11oI9BKRFJxAeDFwqf8BIpIMZKqqD6drdlqZMi5xt5sm7EBBCc9/vZFXvt9EkcdHQnQEw7u15MJhnRnVPYn+HZpZEDTVGmVa2kIM5VGmACmt4/ly7W48Xt8vI0xrf1HvCBHxn7owpTp5BVVVRSSoPXQiMha4BqdBtRR4DnizVuchquqJlVSgGfAazujTSys6zq8sj4jchNPdGQ5MU9VVInI/sMi9HnkC8LB7MucBN/q9XjecFuY3Vb2WaZwKS7z858ctPDM3lQMFJfxmcAcmHtuNgR2bWwA0h4mPjqCgxIvH66vy85Fd4CFMID4qtKfapCTHU+JV0rMKDgbEOmghelS1utfgdotIe1Xd6XaJ7nG3V9QzuJ1fulhLt3/tbu9UzvHlEpG7gUlAAjADGKaqays6vio17h9Q1WwReQB4pxrP+Rhn1JD/tr/53X+novJUdTPVazqbRsLrU95fsp1/fb6OHQcKOb53a+44vQ8DOjav76qZEHZwPdNiL81jKw+IOYUlJERHhHz6ru5+I01LJ+WHyCo1s4GJOA2kicAsv+03ubMKRgIH3KD5GfB3v4E0pwF3qmqmiGSLyChgAXAl8HQlr/sAzrSLD3BGpd5Q3t+wtuYhVmUfTvepMXXiuw37ePCj1azdlcPAjs157IJBjOmZXN/VMg2Af5Lg5lV0heYUekK+uxT85iLuy2NLRh6tE6MPrtsaLCLyBk7rLllE0nFGiz4CvCUi1+CsbHahe/jHOFMuUnGmXVwFzkAYt0G10D3u/tIBNsAN/DLt4hMqGVCD05OoOIu1VKR25iEGYDTOhEhjat3WjHwmvfITHVvG8vQlx3DWwPaWaskErDpJgrNDfB3TUq3io2geG8mmfblszsivl6TAqnpJBbtOLudYxe/SV5l90zh8nAiquggYEGBdTgjkuEBVNcp0SAW7mgNDceaa3FubFTKm1DNzNxAeJrz929G0aRZT39UxDUy8XwuxKtkhnAvRn4iQkhzPpn15bM3I51e9rLekNlX1CViE09ws72f5Ppyl1p6r7UoZszUjn3cXb+fK0V0tGJoaSaxGQMwp9NCxgWSc754cz9fr95KZV0zX0Lh+2GhUFRBTKtierapZACJyCvBFrdbKNHnPzN1ARJjwu7E96rsqpoGKr0aS4OyCEvq2S6zrKtWKlOR43lviDLzsainJalVV0y7KTfskIh1F5EacFQG6Us3Jj8ZUxlqHpjYkVCNJsJMLMfS7TMGZi1iqPq4hNmYBT94SkXAROVdEPsJZvPUc4AWgZx3VzTRR1jo0tSEhwC5Tn0/JLWoYo0yBQxJVd23VdFuIIjJNRBLd+8eLyBH/oqkyIIpIHxF5DNiBc82wNLvFFar6qKpuOtJKGFOqtHV46cgu1jo0RyTQQTV5xR58GvrLtpUqDYgt4yJpHtcwgngduRwo/UUwF2h1pAVWNcr0W5zhr+/ipPP4xt3+5yN9YWPK8/RX1jo0tSMqIozoiLAqryH+so5pwwgucVERtG8eYz8YnZ7Km0Xkc5yBn6NFJKu8A1U1oET2Vf0kGo2T1HeKqq6qRkWNqbYtGXm8t2Q7E0d3s//splYkREeQE2BADOXUT2VdPSalysUGmoA/AVNx1rdWKs7IpAQ4zqWqgDgcuBb4TkQ246wVV24uQmOO1DNfpRIRJlw/tnt9V8U0EgkxVS/wnd0AkgOXdd3x9n9EVWcBs0SkBZAJ9OeXNVRrpNJriKq6RFVvBNoD/8LJTLzNfd5ZfuvQGXNESluHl420kaWm9sRHRVQ5yjSnAQZE8ws3ReCJwAZVzSjvFmhZAY0yVdVCVf2Pm/2iL/AYcBuwS0QqW2fOmIBY69DUhYSYiCoH1RzsMrUuyAbLHd8SLiJXi8jjIvKYiFwlItHVKafaOXNUNVVV/4KT0uNCoLi6ZRjjz1qHpq4kRFcdELMLrIXY0IlIP2A9Tk/mSGAU8G9gvYj0DbScGieRU1Wvqs5S1Qk1LcMYsNahqTuBJAnOboCDasxhnsRJDNxFVY9T1eOALsAy4IlAC7GfRKZefbZqF+8tsVVpTN2ID6CFmFPoISrcmaJhGqwxwHBVzS7d4ObsvRuYH2gh9gkw9ebLNbu56fXFDOzYnD+c2ru+q2MaocQAriFmu8u2hXpyYFOpQsrPzdvc3RcQC4imXny9bg+/++9i+rZvxvSrRzSYSdGmYYmPiqCwxIfH66vwmJwGkvrJVOpD4CURGeMuMxouIr8CXgRmB1qIBUQTdN9t2Mfk//xMzzYJzLh6hE0wNnWmNElwXpG3wmNyCktshGnDdwuwAfgWp0VYCHyDM9Dm1kALsZ9FJqh+3JjBtTMW0j05nv9eO5IWcVH1XSXTiCVEOwuU5BSVVLjuZ3ZBw8l0YcrnzkWcICI9caYGAqxR1dTqlGOfAhM0Czdncs30hXRuGcd/rx1Jq3gLhqZuJUQ7QbDyFqKHNok2oKsxcANgtYKgP+syNUHx85YsJk37iXbNY3jtupEkJ1RrvqwxNRLvthBzi0oqPCan0EOzWGsbGGshmjrm8fp4/aetPPrpOlonRvPGdaPs17gJmtKu0NxKWojOKFO7hmgsIJo69OPGDP7vw1Ws3ZXD6O5J/PPCQbS1uYYmiA7mRKxgPVOP10d+sdeuIRrAAqKpA+lZ+Tz88Vo+WrGTji1ief6yIYwb0M7meZmgS4guHWVafkAsnaNoq9Q0XCISAUwGPlDVHUdSlgVEU2sKS7y88M1Gnv96IyLwh1N7M/n47sREBpSKzJhaVxoQK8qJmF1QmhzYvgobKlX1iMhjwEdHWlZQPwUiMg5nzblwYKqqPlJmf1dgGtAaJ7/V5aqa7u7rgpMMsjNOwsczVXVz8GpvKrNs235ueG0x2/cXcNbR7bnrzL50bBFb39UyTVxVXaa/5EK0FmIDNx8YAmw5kkKCFhBFJBx4FjgVSAcWishsVV3td9jjwAxVnS4iJwEPA1e4+2YAD6nqHBFJACpeesIE1ScrdnLbW0tJTohm5uRRjOqeVN9VMgaASHeN0rzi8gPiL6mfrIXYwL0E/NNtVP0M5PnvVNXFgRQSzE/BCCBVVdMARGQmMAHwD4j9gD+49+cCH7jH9gMiVHUOgKrmBqnOphKqyvPfbOTRT9cxpEsLplw5zKZTmJCTGBNxMPCVVdpCtGuIDd7r7r//Kmef4vRKVimYAbEjsM3vcTpO3ip/y4BzcbpVzwESRSQJ6A3sF5H3gBTgC+AvqnrIWGoRmYxzcZWoKJv0XZeKPT7ufn8Fb/+cztmDOvDY+UfbtUITkipLAVUaKO0aYoOXUhuFhNqn4HbgGRGZBMwDtgNenHoeBxwDbAXeBCYBL/s/WVWnAFMA4uPjNViVbmr25xdz/X9/Zn5aJr8/uRe3ndLLRpCakFVZCqgcayE2Cqp6RNcOSwVzpZrtOANiSnVytx2kqjtU9VxVPQa42922H6c1uVRV01TVg9OVOiQYlTaH2rQvj3Of+4HFW/bz74sG8YdTe1swNCEtoZKAWDrKNMFaiA2eiJwhIv8TkdUi0tnddq2InBxoGcEMiAuBXiKSIiJRwMWUScshIskiUlqnO3FGnJY+t4WItHYfn8Sh1x5NEPywcR/nPPc9WfnFvHbdSM45plN9V8mYKiVER1Q4yjSnsITYyHAiw20Vy4ZMRC4D3sLJeJEClDb5w4E7Ai0naJ8Ct2V3E/AZsAZ4S1VXicj9IjLePewEYJ2IrAfaAg+5z/XidKd+KSIrAMEZVWSCQFV5+btNXPHyTyQnRPPBjWMY3q1VfVfLmIAkxERUOsrURpg2CncA16nqbYD/H3s+MDjQQoL6SVDVj4GPy2z7m9/9d4B3KnjuHODoOq2gOUxhiZe73l/Be4u3c1q/tvzzwkE2Z8s0KPGVtBBtHdNGoxfwYznbc4FmgRZi/QSmQjv2F3DBCz/y3uLt3HZKb164fKh9eZgGJ7HSQTUeG2FaAyJym4isEpGVIvKGiMS4l8MWiEiqiLzpXhpDRKLdx6nu/m5+5dzpbl8nIqcfQZV24MxGKOt4YGOghVhANOVakJbB2U9/x6Z9ebx05TBuOaUXYWE2eMY0PPHRERR5fJR4D1/LI6ewxEaYVpOIdAR+DwxT1QE41+kuBv4B/FtVewJZwDXuU64Bstzt/3aPK51ffjHQHxgHPOcu4FITU4CnRGSM+7iziEwEHgWeD7QQC4jmEKrKjB83c9nUBTSPjeSDG8dwar+29V0tY2qssgW+s62FWFMRQKy7sHYcsBNnsGPpJa/pwG/c+xPcx7j7TxZnaPoEYKaqFqnqJpzEviNqUhlVfRR4D5gDxOMs7PIC8IKqPhtoORYQzSFe/WEzf5u1irG9W/PBTWPo2SahvqtkzBE5uMB3OdcRc+waYnkiRGSR322y/05V3Y6zzOZWnEB4AGe5tP3u4Elwpsp1dO8fXJTF3X8ASKL8xVo6UkOqejeQjBNURwGtVfWv1SnDfhqZgzbuzeWRT9Zy0lFteOnKYdZFahqF0jmG5Y00zbZRpuXxqOqwinaKSEuc1l0KsB94G6fLMxQoUOjerzgrdAWshWgAJ1Hq7W8vIyYynEfOHWjB0DQaFWW8KCzxUuzx2TXE6jsF2KSqe1W1BKercgzOXPHSXxf+C68cXJTF3d8cyCCAxVoC5Q7ceQInS9IyYDmQKSJPikjAWcktIBoApnybxpKt+7l/Qn/aWFZ704iUdpmWHWlq65jW2FZglIjEudcCT8ZZKGUucL57zERglnt/tvsYd/9Xqqru9ovdYJaCM3XipxrW6Xm37Gvdcnq6988Bngu0EPskGNbuyuaJORs4c2A7xg/qUN/VMaZWVRwQbR3TmlDVBSLyDrAYZxL8EpxRnh8BM0XkQXdb6VrTLwP/EZFUnBbcxW45q0TkLZxg6gFuLJuwoRouAM4tzYjkShORPcC7wNWBFGIBsYkr8fr441vLSIyJ4IEJA2xdUtPoHLyGWCYgZlsLscZU9V7g3jKb0yhnlKiqFuIErPLKeQh3RbIjlEf53a3bgYJAC7Eu0ybuma9SWbUjm7+fO5Aky2VoGqGEqPJHmZa2EG2UaaPwNHCviMSWbnDv/9XdFxD7adSErUg/wLNzUznnmI6c3r9dfVfHmDoRH+3M9c4rOrQ3rjRA2ijThklEZpfZdAKwXUSWu48H4sS4+EDLtE9CE1Xk8fLHt5eSlBDFfWf3r+/qGFNnIsLDiIkMI7eo5JDt2QXWQmzgMso8frfM403VLdACYhP17zkbWL87l1euGk7zOPtCMI1bQnQkuRW0EO0aYsOkqlfVdpl2DbEJWrptP1PmbeTi4Z05sU+b+q6OMXUuITq83FGmIr9cYzTGPglN0IwfNpMQHcHdZ/Wt76oYExQJMRHljjJNiI6wRSgaAXf1nPuAE4E2lGnsqWpAv/wtIDYxRR4vc1bvZtyAdnbtxDQZCeXkRMy2TBeNyQycrBnTgd04S7hVmwXEJua7DfvIKfJw5sD29V0VY4ImITqCHfsLD9lmuRAblROAsaq6+EgKsWuITczHK3bRLCaCMT2T67sqxgRNQjlJgrMLrIXYiGykFuKZBcQmpNjjY87qXZzarx1REfanN01HfDkB0VqIjcotwMMiMugIkgxbQGxKvk/dR3ahh7OOtkn4pmlJiCknIBaV0CzWWoiNRCoQi7O+arGIeP1vgRZiP4+akI9W7CQxJoJf9Wxd31UxJqgSoiIo9vgo9vgO9o5kF1gLsRF5Ayet1O+xQTWmKsUeH5+v2sWp/dpad6lpcvwX+I6KiEJVyS2ygNiIDANGqOrKIynEvhmbiO83Ot2lZw6w0aWm6YkvkwIqv9iL16c2qKbxWA00O9JCLCA2EZ+s2ElidATH9bbRpabpSSwTELMt00Vjcw/wLxE5RUTaikgr/1ughVh/QRNQ4vXx+erdnNKvLdERNR6AZUyDVbaFaOuYNjofu/9+zqHXD8V9HNAXn30amoAfNmawP7/EJuObJqv0GuIvAdFpIdoo00bjxNooJKgBUUTGAU/iROupqvpImf1dgWlAayATuFxV0919XmCFe+hWVR0ftIo3cB8v30lCdATH9bLuUtM0JZS2EN2WYXaBtRAbE1X9pjbKCdqnwZ0s+SxwKpAOLBSR2aq62u+wx4EZqjpdRE4CHgaucPcVqOrgYNW3sSjx+vhs9S5O6duGmEjrLjVNU2lAzCtzDbGZBcRGQUSGVLY/0CXdgvlpGAGkqmoagIjMBCbgjA4q1Q/4g3t/LvBBEOvXKP1o3aXGVHgN0UaZNhqLcK4V+qcu8b+WGFBrIJijTDsC2/wep7vb/C0DznXvnwMkikiS+zhGRBaJyHwR+U15LyAik91jFnk8nvIOaXI+WbmT+Khwju9tk/FN05Vgo0wbuxSgu/tvCtAbuBjnMtuvAy0k1PoLbgeeEZFJwDxgO1C67E5XVd0uIt2Br0Rkhapu9H+yqk4BpgDEx8fXaKWCxsTj9fHZqt2c3LetdZeaJi08TIiNDD94DTGn0ENEmBATaTPPGgNV3VLO5lQROQDcC3wSSDnBDIjbgc5+jzu52w5S1R24LUQRSQDOU9X97r7t7r9pIvI1cAzOCuemAvPTMsnMK7buUmNwkwQX/zLKtFlsJCKWHLiR2wQMDvTgYP48Wgj0EpEUEYnCac7O9j9ARJJFpLROd+KMOEVEWopIdOkxwBgOvfZoyvHRCqe79IQ+1l1qTEJ0xMFrh7aOaeNSdiK+iCSJyACcgZnrAi0naJ8IVfWIyE3AZzgXOKep6ioRuR9YpKqzcZI8PiwiitNleqP79L7AiyLiwwnij5QZnWrKcLpLd3GSdZcaAzgBMc9vHqIFxEZlH4cv6C0441YuCrSQoH4iVPVjfllRoHTb3/zuvwO8U87zfgAG1nkFG5EFm5zu0rMGWqonYwDio8MPGWVqI0wblbIT833AXpyZDQGPsLSfSI1QelY+f5u1ksToCMb2blPf1TEmJCRER7J9fwHgjDJNSY6v5xqZ2tLgJuab4Fi9I5tJr/xEQYmXqROHERtl3aXGgLMqTW6RM90ip9BjUy4agUAX7lbVzECOs4DYiPywcR+/nfEz8dERvHP9sfRpl1jfVTImZMRHh5NX5MzicgKiff01AuVdOyxLCTDW2Seikfhw2Q7++NYyuibFMf3qEXRoEVvfVTImpCRER5Jb6MHrc5ID2zXERqGyRb3HAbcAdg2xKXn5u0088L/VjOjWipeuHEbzOPuPbkxZCdHhFHt9ZOYVA7awd2NQ3rVDETkGeAw4DngReCDQ8uwT0YD5fMojn65lyrw0zhjQjn9fNNimWBhTgdLl23YecAbWWAuxcRGRFOAh4ALgPaBf2dXMqmIBsQHakpHHJyt38eGyHazakc2Vo7ty79n9CQ+zVTeMqUjpAt879hcC0CzWvv4aA3e9678B1wPfA8eq6sKalGWfiAZi495cPlmxk49X7GL1zmwABnVqzsPnDuTi4Z1tCSpjqlDaRVraQrRRpjUnIi2AqcAAnEErV+OsCPMm0A3YDFyoqlnifDk9CZwJ5AOTStMxichE4B632AdVdXo163E38Cf39Sao6qdH8r4sIIa4D5ft4JmvUlm3OweAoV1bcs9ZfRk3oB2dWsbVc+2MaTjiD3aZOi1Eu4Z4RJ4EPlXV892lOOOAu4AvVfUREfkL8Bfgz8AZQC/3NhJ4HhjpTpm4FxiGE1R/dnPkZlWjHg8ABTjZk24QkRvKOyjQhPL2iQhhX67ZzS0zl9CnXTPuO7sfpw9oR/vmNnrUmJpIONhlatcQj4SINAeOByYBqGoxUCwiE3CW3wSYDnyNExAn4CR+V2C+iLQQkfbusXNK5wiKyByckaFvVKM6M6h62kXALCCGqOXp+7np9SX079CcmZNHHfx1a4ypmdKAuMtaiFWJEJFFfo+nuKn1SqXgLIv2iogMAn7Gmd7QVlV3usfsAtq69yvKhRtIjtxKqeqk6hxfFftEhKBtmflc/epCkhKieHnSMAuGxtSChJiyXabWQqyAR1WHVbI/AhgC3KyqC0TkSZzu0YNUVd0kDQ2KZccMMfvzi5n4yk+UeJVXrxpBm8SY+q6SMY1C6Q/LXdmFxESGERVhX381lA6kq+oC9/E7OAFyt9sVivvvHnd/Rblwq8yRG2z2iQghhSVerpuxiPSsAl66chg92yTUd5WMaTTio5yA6PWptQ6PgKruAraJSB9308k4+WlnAxPdbROBWe792cCV4hgFHHC7Vj8DTnPz3bYETnO31RvriwsRPp/yx7eXsXBzFs9cegwjUgJas9YYE6DwMCEuKpz8Yq9dPzxyNwOvuSNM04CrcBpYb4nINcAW4EL32I9xplyk4ky7uAqcBbdF5AGc5PEA9we6CHddsU9FiHjk07V8tHwnd515FL8+ukN9V8eYRikhOoL8Yq+NMD1CqroUZ7pEWSeXc6zyS7L3svumAdNqtXJHwLpMQ8DL321iyrw0Jo7uynXHda/v6hjTaJWONLUWoimPfSrqkary7znreeqrVMb1b8ffzu5vK84YU4dKR5paC9GUx1qI1VDk8fLYZ2t5f0k6Xt+RjSgu8fq4453lPPVVKhcN68wzlx5ja5EaU8dKB9bYOqamPPapCFBBsZff/vdn5q3fC8DTX6by+5N7cfagDtUOZHlFHm54bTHfrN/LLSf34tZTelnL0JggKG0h2ihTUx5rIQYgr8jDVa/+xLcb9vLIuQN54fIhREWEceubSzn1398wa+n2gFuMe3OKuHjKfL5L3ccj5w7ktlN7WzA0JkgOXkO0xS5MOexTUYXswhImTfuJZekHeOKiwUwY7KwsdFq/dny6ahdPfrGBW2Yu5akvN/D7k3txev92FeYkTNuby8RXfmJfTjEvXTmUk45qW+5xxpi6URoQm8VaC9EczgJiJbLyirly2k+s3ZXNM5ccwxkD2x/cFxYmnDmwPeP6t+OTlbt48sv13DJzKQDJCVF0aBFL++YxdGgRS4fmsSTERPDop2sREd6YPIrBnVvUz5sypgn7pcvUvvrM4exTUYG9OUVc8fIC0vbl8eIVFbfmwsKEs45uzxkD2vHV2j2s3pnNjv0F7DhQSNrePL7bsI+8Yi8AXZPimH7VCLolxwfzrRhjXL9Mu7AWojmcBcRy7DpQyKVT57NzfyGvTBrOmJ7JVT4nLEw4pV9bTul3aOBUVbILPew6UEiXVnHERpXfnWqMqXsHu0ythWjKYZ+KMnbsL+DiKfPJzCtm+tUjjngJNRGheWwkze2ahTH1Lt5aiKYSQR1lKiLjRGSdiKS6GZXL7u8qIl+KyHIR+VpEOpXZ30xE0kXkmbqqY/PYSHq1SeC/14609USNaWRO7NOa68f2oHdbWzjfHE6cZeaC8EIi4cB64FSc9CELgUtUdbXfMW8D/1PV6SJyEnCVql7ht/9JoDWQqao3VfZ68fHxmpeXVwfvxBhjGi8RyVfVJjnQIZgtxBFAqqqmqWoxMBOYUOaYfsBX7v25/vtFZChOBubPg1BXY4wxTUwwA2JHYJvf43R3m79lwLnu/XOARBFJEpEw4J/A7ZW9gIhMFpFFIrLI4/HUUrWNMcY0BaG2Us3twFgRWQKMxcme7AVuAD5W1fTKnqyqU1R1mKoOi4iw8ULGGGMCF8yosR3o7Pe4k7vtIFXdgdtCFJEE4DxV3S8io4HjROQGIAGIEpFcVT1sYI4xxhhTE8EMiAuBXiKSghMILwYu9T9ARJJxBsz4gDtxE0eq6mV+x0wChlkwNMYYU5uC1mWqqh7gJuAzYA3wlqquEpH7RWS8e9gJwDoRWY8zgOahYNXPGGNM0xa0aRfBZtMujDGm+mzahTHGGNPENdoWooj4gIL6rkc1RAA2V6R8dm4qZuemfHZeKlbVuYlV1SbZWGq0AbGhEZFFqjqsvusRiuzcVMzOTfnsvFTMzk3FmuSvAGOMMaYsC4jGGGMMFhBDyZT6rkAIs3NTMTs35bPzUjE7NxWwa4jGGGMM1kI0xhhjAAuIxhhjDGABsc6IyDQR2SMiK/22DRKRH0VkhYh8KCLN3O2XichSv5tPRAa7+4a6x6eKyFMiIvX0lmpNNc9NpIhMd7evEZE7/Z4zTkTWueemUaxtW81zEyUir7jbl4nICX7PaYyfm84iMldEVovIKhG5xd3eSkTmiMgG99+W7nZx33uqiCwXkSF+ZU10j98gIhPr6z3Vhhqcl6Pcz1ORiNxepqxG93+qWlTVbnVwA44HhgAr/bYtBMa6968GHijneQOBjX6PfwJGAQJ8ApxR3+8tmOcGZwH4me79OGAz0A0IBzYC3YEonFya/er7vQX53NwIvOLebwP8DIQ14s9Ne2CIez8RWI+TVPxR4C/u9r8A/3Dvn+m+d3HPxQJ3eysgzf23pXu/ZX2/vyCelzbAcJy1om/3K6dR/p+qzs1aiHVEVecBmWU29wbmuffnAOeV89RLgJkAItIeaKaq89X5xM4AflMnFQ6iap4bBeJFJAKIBYqBbGAEkKqqaapajHPOJtR13etaNc9NP+Ar93l7gP3AsEb8udmpqovd+zk4SQI64vzdp7uHTeeX9zoBmKGO+UAL99ycDsxR1UxVzcI5p+OC905qV3XPi6ruUdWFQEmZohrl/6nqsIAYXKv45QN2AYfmhyx1EfCGe78j4J8UOd3d1hhVdG7eAfKAncBW4HFVzcQ5D9v8nt8Uz80yYLyIRLhp1Ya6+xr950ZEugHHAAuAtqq60921CydTDlT8GWm0n50Az0tFGu15CZQFxOC6GrhBRH7G6doo9t8pIiOBfFVdWd6TG7mKzs0IwAt0AFKAP4pI9/qpYr2p6NxMw/nSWgQ8AfyAc64aNTd5+LvAraqa7b/PbRE3yblkdl6OXDATBDd5qroWOA1ARHoDZ5U55GJ+aR2Ck0i5k9/jTu62RqeSc3Mp8KmqlgB7ROR7YBjOL1n/FnaTOzfq5Bi9rfQ4EfkB5/pRFo30cyMikThf+q+p6nvu5t0i0l5Vd7pdonvc7dsp/zOyHSf3qv/2r+uy3nWtmuelIhWdrybDWohBJCJt3H/DgHuAF/z2hQEX4l4/BOfaAJAtIqPcUYJXArOCWukgqeTcbAVOcvfF4wyOWIsz0KSXiKSISBTOj4nZwa53MFR0bkQkzj0niMipgEdVVzfWz437Xl4G1qjqv/x2zQZKR4pO5Jf3Ohu40h1tOgo44J6bz4DTRKSlO/LyNHdbg1SD81KRJvN/qkL1Paqnsd5wWno7cS5cpwPXALfg/IJfDzyCu1KQe/wJwPxyyhkGrMQZ/fWM/3Ma6q065wZIAN7GuY62GviTXzlnusdvBO6u7/dVD+emG7AOZxDFF0DXRv65+RVOt99yYKl7OxNIAr4ENrjnoZV7vADPuudgBTDMr6yrgVT3dlV9v7cgn5d27mcrG2cgVjrOIKxG+X+qOjdbus0YY4zBukyNMcYYwAKiMcYYA1hANMYYYwALiMYYYwxgAdEYY4wBLCAaY4wxgAVEY4wxBoD/ByIYv2VorZ/gAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(df[\"time\"], df[\"auc\"], label=\"MeSH\");\n",
    "ax = plt.gca();\n",
    "ax2 = ax.twinx()\n",
    "ax2.plot(df[\"time\"], df[\"num_nodes\"], label=\"Content\")\n",
    "ax.set_ylabel(\"AUC\", fontsize=14);\n",
    "ax2.set_ylabel(\"Number of MeSH terms\", fontsize=14);\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "171px",
    "width": "252px"
   },
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "685px",
    "left": "0px",
    "right": "1272px",
    "top": "107px",
    "width": "165px"
   },
   "toc_section_display": "none",
   "toc_window_display": true
  },
  "toc_position": {
   "left": "653.983px",
   "right": "20px",
   "top": "120px",
   "width": "257.912px"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}