TAR - Text Segmentation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# TAR PROJECT - TEXT SEGMENTATION\n",
    "\n",
    "### Authors: Mirela Oštrek and Luka Dulčić"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import nltk\n",
    "from nltk.stem.porter import PorterStemmer\n",
    "import string\n",
    "import os\n",
    "from __future__ import division, print_function\n",
    "%pylab inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import ENGLISH_STOP_WORDS\n",
    "\n",
    "stemmer = PorterStemmer()\n",
    "# irrelevant characters specific for choi dataset\n",
    "choi_noise = ['--', '\\'\\'', '``', ';', '..', '...', 'afj']\n",
    "\n",
    "def is_digit(string):\n",
    "    \"\"\"\n",
    "    Checks whether string is digit.\n",
    "    :param string: String\n",
    "    :return boolean: True if string is digit otherwise False.\n",
    "    \"\"\"\n",
    "    return string.replace('.', '').replace('-', '').replace(',', '').isdigit()\n",
    "\n",
    "def stem_tokens(tokens, stemmer):\n",
    "    \"\"\"\n",
    "    Stemms tokens using Porter Stemmer.\n",
    "    :param tokens: List of tokens.\n",
    "    :param stemmer: Object which has method \"stem\" (in this poject it is nltk Porter Stemmer)\n",
    "    :return list: List of stemmed tokens.\n",
    "    \"\"\"\n",
    "    stemmed = []\n",
    "    for item in tokens:\n",
    "        stemmed.append(stemmer.stem(item))\n",
    "    return stemmed\n",
    "\n",
    "def tokenize(text):\n",
    "    \"\"\"\n",
    "    Tokenizes text.\n",
    "    \n",
    "    :param text: String.\n",
    "    :return list: List of stemmed tokens from text.\n",
    "    \"\"\"\n",
    "    tokens = nltk.word_tokenize(text)\n",
    "    tokens = list(map(lambda t: t.lower(), tokens))\n",
    "    tokens = filter(lambda t: t not in string.punctuation, tokens)\n",
    "    tokens = filter(lambda t: t not in ENGLISH_STOP_WORDS, tokens)\n",
    "    tokens = filter(lambda t: not is_digit(t), tokens)\n",
    "    tokens = filter(lambda t: t not in choi_noise, tokens)\n",
    "    tokens = filter(lambda t: t[0] != '\\'', tokens)#remove strings like \"'s\" \n",
    "    stems = stem_tokens(tokens, stemmer)\n",
    "    return stems\n",
    "\n",
    "def get_filepaths(directory):\n",
    "    \"\"\"\n",
    "    Recursively searches directory and returns all file paths.\n",
    "    \n",
    "    :param directory: Root directory.\n",
    "    :return list: List of all files in directory and all of its subdirectories.\n",
    "    \"\"\"\n",
    "    file_paths = []\n",
    "\n",
    "    for root, directories, files in os.walk(directory):\n",
    "        for filename in files:\n",
    "            # Join the two strings in order to form the full filepath.\n",
    "            filepath = os.path.join(root, filename)\n",
    "            file_paths.append(filepath)\n",
    "\n",
    "    return file_paths\n",
    "\n",
    "def doc_to_seg_string(n_sent, boundaries):\n",
    "    \"\"\"\n",
    "    Creates string which represents documents (eg. '0000100001000')\n",
    "    where 0 marks sentence and 1 marks boundary between segments.\n",
    "    This string is used for evaluating topic tiling algorithm with Pk\n",
    "    and WD measure.\n",
    "    \n",
    "    :param n_sent: Number of sentences in document.\n",
    "    :param boundaries: Indices of boundaries between segments.\n",
    "    :return string: String which represent document.\n",
    "    \"\"\"\n",
    "    seg_string = ''\n",
    "    for i in range(n_sent):\n",
    "        if i in boundaries:\n",
    "            seg_string += '1'\n",
    "        else:\n",
    "            seg_string += '0'\n",
    "    return seg_string\n",
    "\n",
    "def print_top_words(model, feature_names, n_top_words):\n",
    "    \"\"\"\n",
    "    Prints top words for each topic where \"model\" is LDA model.\n",
    "    \"\"\"\n",
    "    for topic_idx, topic in enumerate(model.components_):\n",
    "        print(\"Topic #%d:\" % topic_idx)\n",
    "        print(\" \".join([feature_names[i] for i in topic.argsort()[:-n_top_words - 1:-1]]))\n",
    "    print()\n",
    "    \n",
    "def max_left(sequence, ind_curr):\n",
    "    \"\"\"\n",
    "    Searches for maximum value in sequence starting from ind_curr to the left.\n",
    "    \n",
    "    :param sequence: List of integer values.\n",
    "    :param ind_curr: Index from which search starts.\n",
    "    :return integer: Maximum value from in sequence where index is less than ind_curr.\n",
    "    \"\"\"\n",
    "    max = sequence[ind_curr]\n",
    "    while (ind_curr != 0) and (max <= sequence[ind_curr-1]):\n",
    "        max = sequence[ind_curr-1]\n",
    "        ind_curr -= 1 \n",
    "    return max\n",
    "\n",
    "def max_right(sequence, ind_curr):\n",
    "    \"\"\"\n",
    "    Searches for maximum value in sequence starting from ind_curr to the right.\n",
    "    \n",
    "    :param sequence: List of integer values.\n",
    "    :param ind_curr: Index from which search starts.\n",
    "    :return integer: Maximum value from in sequence where index is greater than ind_curr.\n",
    "    \"\"\"\n",
    "    max = sequence[ind_curr]\n",
    "    while (ind_curr != (len(sequence)-1)) and (max <= sequence[ind_curr+1]):\n",
    "        max = sequence[ind_curr+1]\n",
    "        ind_curr += 1  \n",
    "    return max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Document class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Document:\n",
    "    \"\"\"\n",
    "    Document represents one document.\n",
    "    \n",
    "    :param path: Path to file which contains document.\n",
    "    :param sentences: list of document sentences\n",
    "    :param boundaries: list of positions where segments boundaries are \n",
    "                        (note: boundary 0 means segment boundary is behind sentence at index 0)\n",
    "    :param segment_divider: string which indicates boundary between two segments\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, path):\n",
    "        \"\"\"\n",
    "        :param path: Path to file where documents is.\n",
    "        \"\"\"\n",
    "        self.path = path\n",
    "        self.sentences = []\n",
    "        self.boundaries = []\n",
    "        self.segment_divider = \"==========\"\n",
    "        \n",
    "        self.load_document(path)\n",
    "        \n",
    "    def load_document(self, path):\n",
    "        \"\"\"\n",
    "        Loads document from file.\n",
    "        \n",
    "        :param path: Path to file where document is.\n",
    "        \"\"\"\n",
    "        sentences = self.get_valid_sentences(path)\n",
    "        for i, sentence in enumerate(sentences):\n",
    "            if sentence != self.segment_divider:\n",
    "                self.sentences.append(sentence)\n",
    "            else:\n",
    "                self.boundaries.append(i - len(self.boundaries) - 1)\n",
    "        #remove unecessary boundaries at beginning and the end\n",
    "        del self.boundaries[0]\n",
    "        del self.boundaries[-1]\n",
    "        \n",
    "    def get_valid_sentences(self, path):\n",
    "        \"\"\"\n",
    "        Reads all sentences from file and filters out invalid ones.\n",
    "        Invalid sentences are sentences which are empty or contain\n",
    "        only irrelevant tokens like stop words, punctuations, etc.\n",
    "        \n",
    "        :param path: Path to file where document is.\n",
    "        :return list: List of valid sentences.\n",
    "        \"\"\"\n",
    "        sentences = []\n",
    "        with open(path, 'r') as fd:\n",
    "            for line in fd:\n",
    "                line = line.rstrip('\\n')\n",
    "                if tokenize(line):\n",
    "                    # if line is valid\n",
    "                    sentences.append(line)\n",
    "        return sentences\n",
    "        \n",
    "    \n",
    "    def to_text(self):\n",
    "        \"\"\"\n",
    "        Returns this documents as appendend string of sentences.\n",
    "        \"\"\"\n",
    "        return '\\n'.join(self.sentences)\n",
    "    \n",
    "    def to_segments(self):\n",
    "        \"\"\"\n",
    "        Returns this document as list of segments based on boundaries.\n",
    "        \"\"\"\n",
    "        segments = []\n",
    "        for i, boundary in enumerate(self.boundaries):\n",
    "            if i == 0:\n",
    "                segments.append(' '.join(self.sentences[0:boundary]))\n",
    "            else:\n",
    "                last_b = self.boundaries[i - 1]\n",
    "                segments.append(' '.join(self.sentences[last_b:boundary]))\n",
    "        segments.append(' '.join(self.sentences[self.boundaries[-1]:]))\n",
    "        return segments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "files_paths = get_filepaths('choi_data')\n",
    "documents = [Document(path) for path in files_paths]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Topic Tiling class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from scipy import spatial\n",
    "from scipy.signal import argrelextrema\n",
    "\n",
    "class TopicTiling:\n",
    "    \"\"\"\n",
    "    Implementation of Topic Tiling algorithm (M. Riedl and C. Biemann. 2012, Text Segmentation with Topic Models)\n",
    "    \n",
    "    :param m: Multiplier of standard deviation in condition for segmentation (c = mean - m*stddev).\n",
    "    :param cosine_similarities: Cosine similarities between sentences.\n",
    "    :param boundaries: Caluclated segments boundaries.\n",
    "\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, m = 0.5):\n",
    "        self.m = m\n",
    "        self.cosine_similarities = None\n",
    "        self.boundaries = None\n",
    "        \n",
    "    def fit(self, sentence_vectors):\n",
    "        \"\"\"\n",
    "        Runs Topic Tiling algorithm on list of sentence vectors.\n",
    "        \n",
    "        :param sentence_vectors: List (iterable) of topic distributions for each sentence in document.\n",
    "                                 t-th element of sentence vector is weight for t-th topic for sentence, \n",
    "                                 higher weight means that sentence is \"more about\" t-th topic.\n",
    "                                 \n",
    "        :return: Calculated boundaries based on similatities between sentence vectors.\n",
    "                 Note: boundary '0' means that segment boundary is behind sentence which is at index 0\n",
    "                 in sentence_vectors.\n",
    "        \"\"\"\n",
    "        self.cosine_similarities = np.empty(0)\n",
    "        depth_scores = []\n",
    "\n",
    "        # calculating cosine similarities\n",
    "        for i in range(0, len(sentence_vectors) - 1):\n",
    "            sim = 1 - spatial.distance.cosine(sentence_vectors[i], sentence_vectors[i+1])\n",
    "            self.cosine_similarities = np.append(self.cosine_similarities, sim)\n",
    "\n",
    "        # get all local minima\n",
    "        split_candidates_indices = argrelextrema(self.cosine_similarities, np.less_equal)[0]\n",
    "\n",
    "        # calculating depth scores\n",
    "        for i in split_candidates_indices:\n",
    "            depth = 1/2 * (max_left(self.cosine_similarities, i) + max_right(self.cosine_similarities, i) - 2 * self.cosine_similarities[i])\n",
    "            depth_scores.append((depth, i))\n",
    "\n",
    "        tmp = np.array(list(map(lambda d: d[0], depth_scores)))\n",
    "        \n",
    "        # calculate segment threshold condition\n",
    "        condition = tmp.mean() - self.m*tmp.std()\n",
    "        \n",
    "        # determine segment boundaries\n",
    "        tmp = filter(lambda d: d[0] > condition, depth_scores)\n",
    "        self.boundaries = [d[1] for d in tmp]\n",
    "        \n",
    "        return self.boundaries\n",
    "    \n",
    "    def set_m(self, m):\n",
    "        \"\"\"\n",
    "        Setter for parameter m.\n",
    "        \"\"\"\n",
    "        if m:\n",
    "            self.m = m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Segmentation Engine class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from sklearn.base import BaseEstimator\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.decomposition import LatentDirichletAllocation\n",
    "from nltk.metrics.segmentation import pk\n",
    "from nltk.metrics.segmentation import windowdiff\n",
    "from time import time\n",
    "\n",
    "class SegmentationEngine(BaseEstimator):\n",
    "    \"\"\"\n",
    "    Implementation of segmentation engine used for segmenting documents.\n",
    "    Based on Latent Dirichlet Allocation model and Topic Tiling algorithm.\n",
    "    \n",
    "    :param vectorizer: CountVectorizer class used for transforming and cleaning input data.\n",
    "    :param lda: Latent Dirichlet Allocation model.\n",
    "    :param tt: Topic Tiling class.\n",
    "    :param n_topics: Number of topics parameter of LDA.\n",
    "    :param max_iter: Maximum number of iterations parameter of LDA.\n",
    "    :param a: Document topics prior parameter of LDA.\n",
    "    :param b: Topic document prior parameter of LDA.\n",
    "    :param m: Multiplier parameter of Topic Tiling\n",
    "    :param random_state: Random state.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, n_topics = 10, max_iter = None, a = None, b = None, m = None, random_state = None):\n",
    "        \"\"\"\n",
    "        Initializes estimator.\n",
    "        \"\"\"\n",
    "        self.n_topics = n_topics\n",
    "        self.max_iter = max_iter\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "        self.m = m\n",
    "        self.random_state = random_state\n",
    "        \n",
    "        self.vectorizer = CountVectorizer(max_df=0.95, min_df=2, tokenizer=tokenize, stop_words='english')\n",
    "        self.lda = LatentDirichletAllocation(n_topics=n_topics, max_iter=max_iter, doc_topic_prior=a, topic_word_prior=b, random_state=random_state)\n",
    "        self.tt = TopicTiling(m=m)\n",
    "        \n",
    "    def fit(self, documents, input_type='segment'):\n",
    "        \"\"\"\n",
    "        Trains segmentation engine.\n",
    "        \n",
    "        :param documents: List (iterable) of documents (class Document).\n",
    "        :input_type: Determines basic input unit.Possible values are 'segment', 'document', 'sentence'. \n",
    "                     By default we use 'segment'.\n",
    "        \"\"\"\n",
    "        t0 = time()\n",
    "        \n",
    "        train_data = self.parse_data(documents, input_type)\n",
    "        X = self.vectorizer.fit_transform(train_data)\n",
    "        self.lda.fit(X)\n",
    "        \n",
    "        print('Fitted in %0.2f seconds' % (time() - t0))\n",
    "        \n",
    "    def predict(self, documents):\n",
    "        \"\"\"\n",
    "        Calculates segment boundaries for documents.\n",
    "        \n",
    "        :param documents: List (iterable) of documents (class Document).\n",
    "        :return: List of boundaries for each document.\n",
    "        \"\"\"\n",
    "        # TODO check if fit has been called\n",
    "        estimated_boundaries = []\n",
    "        for document in documents:\n",
    "            sentence_vectors = [self.lda.transform(self.vectorizer.transform([sentence])) for sentence in document.sentences]\n",
    "            estimated_boundaries.append(self.tt.fit(sentence_vectors))\n",
    "        return estimated_boundaries\n",
    "    \n",
    "\n",
    "    def score(self, X, method = 'pk'):\n",
    "        \"\"\"\n",
    "        Calculates segmentation score with Pk or WindowDiff measure.\n",
    "        \n",
    "        :param X: List (iterable) of documents (class Document).\n",
    "        :param method: String which indicates which evaluation method should be used.\n",
    "                       Possible evaluation methods are Pk measure ('pk') or WindowDiff method ('wd').\n",
    "                       By default Pk measure is used.\n",
    "        :return float: Evaluation score (actually method returns 1 - pk or 1 - wd because standard \n",
    "                       scikit learn grid search treats higher values as better while the oposite is \n",
    "                       the case with pk and wd).\n",
    "        \"\"\"\n",
    "        if method == 'wd':\n",
    "            scorer = windowdiff\n",
    "        else:\n",
    "            scorer = pk\n",
    "            \n",
    "        scores = np.empty(0)\n",
    "        estimated_boundaries = self.predict(X)\n",
    "        for i, document in enumerate(X):            \n",
    "            ref_doc = doc_to_seg_string(len(document.sentences), document.boundaries)\n",
    "            estimated_doc = doc_to_seg_string(len(document.sentences), estimated_boundaries[i])\n",
    "            # calculate k\n",
    "            k = int(round(len(ref_doc) / (ref_doc.count('1') * 2.)))\n",
    "            scores = np.append(scores, scorer(ref_doc, estimated_doc, k))\n",
    "        return 1 - scores.mean()    \n",
    "                \n",
    "                \n",
    "    def set_params(self, **params):\n",
    "        \"\"\"\n",
    "        Sets value of parameters.\n",
    "        \n",
    "        :param params: Dictionary of parameters to be set.\n",
    "        \"\"\"\n",
    "        super(SegmentationEngine, self).set_params(**params)\n",
    "\n",
    "        # refresh parameters\n",
    "        self.lda.set_params(n_topics=self.n_topics, max_iter=self.max_iter, doc_topic_prior=self.a, topic_word_prior=self.b, random_state=self.random_state)\n",
    "        self.tt.set_m(self.m)\n",
    "        return self\n",
    "        \n",
    "    def parse_data(self, documents, input_type='segment'):\n",
    "        \"\"\"\n",
    "        Transforms list of documents into list of segments.\n",
    "        :param documents: List of documents (class Document)\n",
    "        :input_type: Determines basic input unit.Possible values are 'segment', 'document', 'sentence'. \n",
    "                     By default we use 'segment'.\n",
    "        :return list: List of segments.\n",
    "        \"\"\"\n",
    "        train_data = []\n",
    "        for document in documents:\n",
    "            if input_type == 'segment':\n",
    "                train_data.extend(document.to_segments())\n",
    "            elif input_type == 'sentence':\n",
    "                train_data.extend(document.sentences)\n",
    "            elif input_type == 'document':\n",
    "                train_data.append(document.to_text())\n",
    "            else:\n",
    "                raise ValueError('Invalid input_type parameter!')\n",
    "        return train_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Which input type is better?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SEGMENT\n",
      "Fitted in 91.38 seconds\n",
      "Pk = 0.175918\n",
      "WD = 0.223952\n",
      "DOCUMENT\n",
      "Fitted in 44.14 seconds\n",
      "Pk = 0.360908\n",
      "WD = 0.411459\n",
      "SENTENCE\n",
      "Fitted in 216.62 seconds\n",
      "Pk = 0.459176\n",
      "WD = 0.533597\n"
     ]
    }
   ],
   "source": [
    "from sklearn.cross_validation import ShuffleSplit\n",
    "\n",
    "engine = SegmentationEngine(n_topics=100, max_iter=70, a=0.1, b=0.01, m=0.5)\n",
    "splitter = ShuffleSplit(len(documents), n_iter=1, test_size=.05, random_state=273)\n",
    "\n",
    "X_train = []\n",
    "X_test = []\n",
    "for train_indices, test_indices in splitter:\n",
    "    X_train = [documents[i] for i in train_indices[:100]] # take 100 documents\n",
    "    X_test = [documents[i] for i in test_indices]\n",
    "    \n",
    "\n",
    "# Input: SEGMENT\n",
    "print('SEGMENT')\n",
    "engine.fit(X_train, input_type='segment')\n",
    "print('Pk = %f' % (1 - engine.score(X_test)))\n",
    "print('WD = %f' % (1 - engine.score(X_test, method='wd')))\n",
    "\n",
    "# Input: DOCUMENT\n",
    "print('DOCUMENT')\n",
    "engine.fit(X_train, input_type='document')\n",
    "print('Pk = %f' % (1 - engine.score(X_test)))\n",
    "print('WD = %f' % (1 - engine.score(X_test, method='wd')))\n",
    "\n",
    "# Input: SENTENCE\n",
    "print('SENTENCE')\n",
    "engine.fit(X_train, input_type='sentence')\n",
    "print('Pk = %f' % (1 - engine.score(X_test)))\n",
    "print('WD = %f' % (1 - engine.score(X_test, method='wd')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train-test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.cross_validation import train_test_split\n",
    "\n",
    "X_train, X_test = train_test_split(documents, test_size = 0.2, random_state = 273)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grid Search\n",
    "\n",
    "### Optimizing parameters $K$, $\\alpha$ and $x$\n",
    "\n",
    "### WARNING! Very slow block DO NOT RUN THIS!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.grid_search import GridSearchCV\n",
    "\n",
    "cv = ShuffleSplit(len(X_train), n_iter=1, test_size=.2)\n",
    "\n",
    "engine = SegmentationEngine(max_iter=60, a=0.1, b=0.01)\n",
    "params = {'n_topics': [60, 80, 100, 120, 130, 140, 150, 160], 'm': [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7], 'a':[0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]}\n",
    "clf = GridSearchCV(engine, params, cv=cv)\n",
    "\n",
    "t = time()\n",
    "clf.fit(X_train)\n",
    "print('Duration %f hours' % ((time() - t)/3600))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model with optimal parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted in 1587.52 seconds\n"
     ]
    }
   ],
   "source": [
    "engine = SegmentationEngine(n_topics=150, max_iter=100, a=0.1, b=0.01, m=0.2, random_state=273)\n",
    "engine.fit(X_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### score function is returning (1 - score) because scikit-learn grid search treats higher value as better (which is opposite for $Pk$ and $\\textit{WD}$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pk = 0.096507\n",
      "WD = 0.126073\n"
     ]
    }
   ],
   "source": [
    "print('Pk = %f' % (1 - engine.score(X_test, method='pk')))\n",
    "print('WD = %f' % (1 - engine.score(X_test, method='wd')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Choose which document to plot and generate plot indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "doc = X_test[174] # just change index for chosing different document\n",
    "plot_indices = engine.predict([doc])[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Graph\n",
    "\n",
    "#### true positive - green line\n",
    "#### false negative - dashed green line\n",
    "#### false positive - red line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4kAAAG2CAYAAADSncMEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsnXmYXUWZ/7/Ve9KdpJPOChgSAiGQAAFZApjkiKyKOzMq\nIPSgIKPDDIqj6IDixsgojoKAiEpERp1BZPyhgpCRwyaySAKBJEBCOiQhSYcknb3XW78/qk/u7dvn\nnnuqTp2t6v08z326z13Ora5+T533rXdjnHMQBEEQBEEQBEEQBADUpD0AgiAIgiAIgiAIIjuQkUgQ\nBEEQBEEQBEHsh4xEgiAIgiAIgiAIYj9kJBIEQRAEQRAEQRD7ISORIAiCIAiCIAiC2A8ZiQRBEARB\nEARBEMR+6tIegG4YY9TTgyAIgiAIgiAIq+GcM9XPGmckAkDF3o+OI366blJDyS3OIgcA4La7qY4j\nE/8zTWO47rrrcN111/l/RVbmOyfQfIUnzFwFyaZNkFzJkdR82SCfJHvJomu+bZBNAFX1IJLfbMKY\nsn0IgMJNCSIxOjo60h4CQfhCsklkGZJPIquQbBImQ0YiQRAEQRAEQRAEsR8yEgkiIdrb29MeAkH4\nQrJJZBmSTyKrkGwSJkNGIkEkhOPF9BNExiDZJLIMySeRVUg2CZMhI5EgEsKlgklERiHZJLIMySeR\nVUg2CZMxsropQRAEQRAEQRDxQ1VNzYQ8iQSREBSWQmQVkk0iy5B8ElmFZJMwGTISCYIgCIIgCIIg\niP2QkUgQCUG5C0RWIdkksgzJJ5FVSDYJkyEjkSAIgiAIgiAIgtgPGYkEkRCUu0BkFZJNIsuQfBJZ\nhWSTMBkyEgmCIAiCIAiCUMJZ5MBZ5KQ9DEIzZCQSREJQ7gKRVUg2iSxD8klkFZJNwmTISCQIgiAI\ngiAIgiD2Q0YiQSQE5S4QWYVkk8gyJJ9EViHZJEyGjESCIAiCIAiCIAhiP2QkEkRCUO4CkVVINoks\nQ/JJZBWSTcJk6tIeAEEQBEEQBEEQ+cRtd9MeAhED5EkkiISg3AUiq5BsElmG5JPIKiSbhMmQkUgQ\nBEEQBEEQBEHsh4xEgkgIyl0gsgrJJpFlSD6JrEKySZgMGYkEQRAEQRAEQRDEfshIJIiEoNwFIquQ\nbBJZhuSTyCokm4TJkJFIEARBEARBEIQSziIHziIn7WEQmiEjkSASgnIXiKxCsklkGZJPIquQbBIm\nQ0YiQRAEQRAEQRAEsZ9MGImMsZ8yxjYzxl4MeM9NjLHXGGNLGWNzkxwfQeiAcheIrEKySWQZkk8i\nq5BsEiaTCSMRwJ0Azqr0ImPsHAAzOOeHAfgUgB8lNTCCIAiCIAiCIAibyISRyDl/AsD2gLe8H8Bd\ng+99GsAYxtikJMZGELqg3AUiq5BsElmG5JPIKiSbhMnUpT2AkBwIYF3J8YbB5zanMxyCIAiCIAiC\nINx2N+0hEDGQFyORyCA/+AFw4onAySenPZJ8EDV34TvfAZ56SvzO+fBHKYwNfZQ/V43yz5c/CgXx\n4Hz473V1wNy5wCmnCPloaYn0ZyvxxBPA978P1NRUfnh/x8DA0J+lv9fWAvX1lR8jRgCtrcDYseKn\n9/COW1qAffuAXbuA3bvFz9LH7t3Anj1Ad7d4n99j9Gjg3e8Gzj5b/B4HlFeTDH19wJYt4tHVFfzo\n7w93zkrXekMDMGuWuBbnzgUOPjjcta+TFSuAX/0K6O0tPnp6hh4PDIjrZPRo8Rg1aujvo0YBnDu4\n/37xWb/HuHHAwoXAYYfF8ze+9hrw5JNAe7v+c+eFzk7g6afF4/XXxTpfVyfWQe/30uNq/4eLLhL/\nr7xTbe3s6wN27AB27hRr/s6dwx/79olroa/P/+ecOcDVVyd//ermK18RctTfX3wMDAz9vb5erAfN\nzcWfpb83NFReB3p6xPf8wz8Ahx+e7t9qCnkxEjcAeFvJ8UGDz/nS3t6OadOmAQBaW1sxd+7c/Rey\n29UFuG7xeDBUgI6HHnsEvf+HPwQGBly87W3AHXc4mDkzhvF0dYnjEOOJ7birC05ra6zf5xH0/t/8\nBnjve12MHQu8/e0OGAOef94FY8Dxx4vj554T7z/uOAecDz/+29+Kx4D4fPkx58Cxx4r3e8dz54rj\nJUvE8XHHOaipAZYudVFTUxzPkiUu+vqAQsHBbbcBH/2oi9ZW4KyzHJx6KsCYi0mT4p+v555zMGUK\ncNhhLgoF4JhjHBQKYnyFAnDUUeL45ZfF/Hl/z4svFv+emhrg2WddDAwAc+Y46OsT89HfDxx+uDhe\nssTFpk3AuHEOurqAV15xsXs3UFMjjt96y0VjIzBxooNRo4CeHhcjRwIzZojjrVtdNDUBs2c7GDcO\n6OhwMX68+H82NQErVrjo6gIeftjB5z8PTJzo4tRTgauucjB1arj56lrZhdZZleW3txd44w0Hn/xk\ndtaftI67Vor1xkP28/fd5+LFF4HaWgedncCyZS62bwd6ex1s3w7094vr4ZBDHIwdC+zd66KlBTj6\naAeTJon1dMoUYMECB/X1xev3+OPF+f2OvevRu76967enB/jf/3Vxxx1AZ6eD9euBSZNczJgBnHuu\ng7lzxfh27AAOPtjBtm3A00+72LkTaGlxsHUr0Nbm4mMfU5+v73/fxauvAu3tDhoagFdfdVFfL8bf\n0AC89JK43mbOdLBzJ/DMMy42bwYABxs2CPnfuxeYMsVBY6O4nhoagEMPFcfr14vj7dsd/OxnwOuv\nu5g9G/jIRxw4DvDmm+L6jiIfXV3Al77kDG72uDjqqHjlz1XUTzgHvv51FytXAuec42DOHGDLFrH+\nyJ7vpJMcLFkC/Nd/uVixAli7Vsz31KkujjwS+MQnxPr5/PNifZw1y0F/v1g/BwaA6dPF+VauFOeb\nNWvo8caN4n528sl65y/J+a50vGsXADh47DHg/vtdbNki5Hf0aHH9NzcL+R09Wqz/I0eK67++Hli9\n2sWoUeJ+W18v5L+uDnjwQQcjRwLHHJPufEXRnzkH/vM/XVx9tVif6urE+lNbC5xwgoPaWqFP9PeL\n9WDPHnH/3bEDaG52sHkzsHy5eH3GDCGPb74prv8jj3Qwfry4/vftA977XgennQaccYaLtrbs3F+S\nOF66dCm6BvXmjo4ORIXxchdESjDGpgG4n3N+lM9r7wbwGc75exhj8wB8n3M+r8J5eMW/aXAiUaZo\nEsPxmqIGhRBMnSp2WH/zG+C664CzzhI7RRMn6hyIGEeq/zNNYyi9GQ37ihDzfcwxwMMPa57fmOEc\nWLtW7ML/5S/isX07MH06MGaM8LZ5P0t/nz07eCew2nx961viXP/0T/r/prQoFIBnngH+3/8Tj/p6\n4H3vAz70ISEblag2Vx0dwMyZLnbscDBihO5R54sw12Ep69cDjz1WfBQKwIIFwNFHA5MmicfEieJn\na2u6noD+fuCVV4ClS8XjhReEl6Ktzf+xcydw553A//1f5XNWm69vflN41T/zmWhjD1o7S9m9W6wx\nrise69eLiIazzxaeq5oaue/t7gbe9S7hQTzmGHGOv/1NeDR0Iyt7paxcCVxxhfj7/u7vxPGyZcKT\nO2KE8ETNmQMcdRRwyCHif+t5tDs7i797xzt2AMceC5x0kniccIKQX1384Q/APfcAixbpO6csUea7\nlPvuc1EoCKPw0UfF3M6fL9aBhQuBGTOiX/fbtwPveAdw441CllMhoh7U0yPu6RrsllDfdfvtwPe+\nB1xwAfCFLwh9wEYYY+CcK0tgJjyJjLFfQjiL2hhjbwD4KoAGAJxz/mPO+R8ZY+9mjK0CsAfAP6Q3\nWsKjv1+4/i+4APjwh4FbbhE3k0svBT772XhupDbT3Q00NaU9CjkYA6ZNE48LLhDP7doFbNggQup2\n7Bj6c/VqcRO59VZg8WL17+3pARobNfwBGaKmBpg3Tzyuv17M1f33A6efLsK/Ro1SO29Pjwhrevxx\n4Mwz9Y7ZRB55BLjrLjFfzc1CGXzXu8RG2eTJaY+uMnV1YvNl9uzitRjE6tXAjyLWEe/pEfeIpGhp\nETLsyfGePcJovOUWsZ787Gfhx1MoCONw/nxxTwOEAfbFLwI//GEsw5dmzx5hiN9zD3DDDWLDqNwg\n2bYNePll4KWXhOz+9KfC4JswQTwmTxbGo3c8YYLYJIhzQ2PWLLFhkXceewz45CfFvC9YAHzucyKs\nWzdjxwL33Sc24v/4R+CII/R/R9zs24fENiEbG4F//mdx/d54o9jg+Zd/AT79afP0grjJhJHIOT8/\nxHsM8gmYAefFG0lTE3DVVSIW/PrrxU3ny18WF2ldJqQsfcLshAdhiuEzapRQEiqxalX03B9T5iqI\nGTOAK68Uu/F79kQzEgEHDz5IRmIYrr5aKBs33ihy4UylsbGY46OKrutQde1sbgbOOEMY8Z/9LHDu\nucC994a7Vq65Rtzjrr+++Ny11wrP2uLFYnMmLTgXRsMXviAM1xdeqLwpO26cMHTnz092jEFMmyY2\nA0t1iDzy4ovAlVc6uPba+L9r5kzgjjuEQfrEE8KQzxNpbHKPHg187WvAP/4j8I1vCG/6tdcC559P\nemlYJIMvCCKYceOA734X+POfRVTC7NnCK7R3b9ojyz9J78qnRZaU0zwQdb56eoDjjgP+9Cd9YzKZ\nnh4R8mWygQiItaa3N9o5enuzcR3W1IhCVqefDrzzncCmTcHv/8lPxP1r0aKhIaoNDcDPfy6Uzh07\n4hxxZV57DTjnHHFf/f3vgX//9/xF7dTWiuvnrbfSHkk01q8H3va26u/Txemni7Di886Lfm3qxlnk\n7A/h9WPfvvQioSZPFtEEDzwAPPhgMbpp/nwRVfGlLwG33SbCoJctE5uuhICMREKJaqms06YBd98t\nQiNeflmER1x3nch5sBVXMZa/lDzvuoaFjEQ5mpqiG4ktLaKAwBtv6BuXqdgiW7quQx0bW7rWzi98\nQYSdOY4wtvx4+GGx0fm73/mHxx19NHDJJcIzmTS33io2KC65RIwzKCIj6xx+eP5DTtetE8VnkuTT\nnwaOPFIYixkpKRKK7u7kwk0rceihwC9/KYz7FStE+PkllwgvbWcn8NvfipDhI48UGzAEGYmEIn19\n4W7+M2aIHZznnhPHxx8vihisXh3v+EzEBgMRICNRlqjz1d0truWzziJvYhhskS1Tr8OPfxy46SYh\n7888M/S1l14CLrtMGIgTJlQ+x7/+K7B8efKK5K9+JfKQ//7v838/MMVIDJKTuPj+94UOdfPNyX+3\nKlmrqTBihGjB8q53iTSpr35V5Os+/LAo1nXNNSI0dWAg7ZGmCxmJhBKyN/8JE4QnccUKEYL67ncX\ncylsIUpOYp52DKNiqnIaFzrCTadOdXD22WQkhsEW2cpSuGnUfO5yzjxTFHv56EdFtAsAbNwIfPCD\nIsS0Wo+1ujoRdvov/wJs3ap1aIH09KjnHmcNU4zE885zEv/e+nohvz/6UX7W7CQL10Tl0ENFwau1\na4Xn3uYIODISCSVUFaWRI0W4xPLlonz/JZfoH5uJ9PbakY8IFJvlRsEWRR4Qf2d3t/rne3rEDu87\n3gE89ZSIEiAqw7l8K4U8UlMTfXMqy3nUb3+78BpcdZUI43zf+4Q3YeHCcJ8//HBRQTHJNjsmrWt5\nNxILBbHujhyZzvd7FU8vv1y0PMk6WfMkVmPkSLERdN55oo3O00+nPaJ0sOBWR8RB1JtVbS3w/vfb\nlSAcJa/GU+RtQJdyaooyVQ0dOYmdnaLp9rHH2nszJPSj6zrUkZPox4wZorfd3XeL+9GFF8p9/oor\nhAfyf/4nluENw6R1Le9GYmen6IEal2yG4fDDgR//GPjAB0TRlSyHRqZZuEYVxoBPfUrkMV54odhM\nsimqCyAjkVCkuzv6zSqqB8QmdMx3noiab2OSMlUNHeGm9fXi9yyHnC5bBnz722mPwi5s2KyZOFGE\nll1zjfxna2qAO+8UvROrVUzVQR7mMyzjxomeuXmNXFi3LtnKppU44wwRdvrTn4ocu699TYwtadx2\nF267W/H1LBSuUeWEE0SUze9+B1x0kV3ODeoUQiih42alI+clT0TJq8lbqEbamKRMVUOHkThzpgNA\nFPM4/3zRUypr3H+/eFx9dXpjKBTyXzBEBsai9bLLak6iTqZPFyX0/+EfgEsvFX9zT4//42Mfi9YI\nPcvhuypMnw6sWSOqS+YNr/1FFmTTccRj40axaXHaaaLy7WWXiXYpWegJmHcdZvx4kb/89a+L8NOH\nHxYbTKZDnkRCCR3hjzYpW1HJ+wIrS20t0N+v/nnbjMQoHvlSL/WhhwJdXdlM1H/0UeDVV9Mdg025\nwUD0jTzTjJpKXHopcPLJQnH8619Fzv369cDOneL10aNF5dSHHor2Pablw+Y55DQrnsRSpkwBvvxl\nMadXXAHcdZcwwL/61WQ83UHkqXBNJWprhaf20kvFw4bQ0wzsLxB5RJcSbsNF5uG6rvKuo01GD1D0\njqnugNo0Xzo8ievWuQAcMCYqPz78sPAoZoX+fhFuOnYssG1beo3sbZIroChbqn+zzpzELHhsKsEY\n8JWvBL+nvz96QS7T8IzE97437ZHIs24dcNRR2ZTNmhqxjp95JrB5s+gHOG8e8G//BnziE+lsNJi0\n0f2Zz4gc0DvvNL/4okF7UkSS6FSWbDIUVTFpgQ2DDsPHFmVeR+GaUm/PWWcBDz4YfVw6WbJENDE/\n4ojKTdCTwCa5AqJ7EnWFm5qAjtY+ppFnT6IXbpp1Jk0S4dB/+YtY19/5znTm3CQdhjFheH/jG8Dr\nr6c9mnghI5FQQpeyVF8fLawwT1BOYnjISAyPjrk66ihn//E73wk88ojIv8sKjz4KLFggCjOQkZgc\nOmRLR7hp1jw1KkQNCx8YMCvUFMi3keiFm+ZFNg84ALj3XtHb85xzgOuvT7ZokAnhpqVMmQJ85zui\nkE2Wq8pGxbAlh0gKXdU2m5qowmkYSDmVw6b50j1Xo0YJY+yFF6KPTRePPSb615GRmCx0HeqD5nI4\nhxySX0/M+vXAgQemPQp5PvQh4PnnRaP4E04AnnlGz3mdRQ6cRU7F103c6D7vPCHD3/lO2iOJDzIS\nCSV03bBsCsGJ0k/JxAU2iKhyMTAgksxtQEfhmlWr3CHPZSnktFAA/vY34PjjyUhMmoaGaNehrkI/\nafai04WOsHDTZK+hQTQt7+pKeyRyDAwI2R4xIp+y2doK3H47cNNNQHs78NnPArt3x/udeeyTGIab\nbxbtR5YuTXsk8UBGIqGErubu5EkMBxmJRCV0KJ9en0SPs8/OjpG4bJmo0NfYKH6SkZgcjY3R2xRR\nFWsBeRL9yWPI6ebNwOTJaY8iOgsWCK9iYyPw/vfH+1157pMYxJgxwB13iLBTE3VZMhIJJciTKE+U\n3AVTFYRK2CQXUdGhfJ5wgjPkuaOPFv3LvBL+aeKFmgLAQQeJXKC0il3Z0tLBIyvXYV7yvoIgI9Gf\nPBqJ69aJtQjIv2w2NYm2GW+8Ee/3mLzR7Tiikuy//VvaI9EPGYmEErpuWORJDIfJC6wfURQq26rl\nxqF8MiYaMv/5z9HGpgOvaA0gCneMH59eH0dTFfVKRJUt267FIMhI9CevRmIeKpuGZcSI+PUw0wrX\nlPPNb4rWUY88kvZI9EJGIqEEeRLloZzE8ESRC9sanutQPl9+2R32vM6Q0/5+0XdRtgoc56I5+bx5\nxefSzEs0VVGvRJQWGDqrceYx76ucqLnDpspeHo3E0vYXJshmElXmTddhmpqAu+4CLrsM2LEj7dHo\ng4xEQgmqbpospioIlYhi+Ng4V1GVz/KcRAA44wyxM6rDG/Taa8CvfiW8gjK88gpw8MGiuIUHGYnJ\nEXWzxqa5qgYVrvEnj0aiaZ5EHbjtLtx2t+LrphauKWXuXOCTnwSuuCLtkejDSCMxaqI9UR3yJMpD\nfRLDQ0ZieKIqn93dwKmnOsOeb2sToZ2vvqp+bo8XXxQ5PHffLfe50lBTDzISkyMr12He874ACjet\nxMSJwFtv5avXnEk5iaXEGR5uauGacj7/eZHP/7vfpT0SPRhpJO7Zk/YIzEdndVNbjMQokJEYHlOV\nqUrEqXzqCjldtgy46irgoYfEjnJYSovWeJCRmBxRWmCQJ3EoZCT6wxgwdWr8hVN0UhpuagpRQsvD\nYIsOU1sLXH65uHeZABmJhBI6PYm2hJtGyV3QZZTnBTISw6ND+Xz+edf3tbPOAv70J/VzeyxbBpx0\nEnD66cDvfx/uM5wDTz4JnHLK0OfTbINho2ypKo46K8GakPdFRmJl8hZyun49cOCB4ncTZBMQXj6Z\nDTxZTC9cU8ro0dmoDK4DI43EuJuCEnqrm5InsTq6ckDzAuVChUdHTmIlZf7EE4EXXoiuPCxbBsyZ\nA1xwAfBf/xXuM2vWiHDX0aOHPj9lCrBxYzqVM01W1P2gzRp9kJFYmTwZif39IjTWtP9FU1O8RqIt\nnkRA3LN27Up7FHow0kgkT2L8kCdRHspJDA8pp+HRoXyedprj+1pdHXDqqcDjj6uff9cuEVI2apRo\nq7F0KbB1a/XP+YWaAuJckycLQzFpSLbCo3OzxoS8L6puWpk8GYmbNomNKg8TZBOI35Nokw4zahR5\nEjMNGYnxo7O6KXkSq0PhpuExWZnyQ0fhmqD5ihpy+tJLwosIiHyND38YuOee6p977LHhRWs80spL\ntE22ouQp6Qw3NQGqblqZPBmJplY2jdor0VnkwFnkVHy9t9e/iraJULhpxiEjMX7IkyhP1D6JpioI\nfpCRGJ6onsS+PuDJJ92Kr0c1El98ETjqqOJx2JDTxx8H3vEO/9fISEyGrFyHJuR91dVF60Vnsuwd\neiiwalXaowhHaWVTwAzZBOL3JAIiCsQGyEjMOJSTGD+6PFs2tcCIgk2hGkB2lNM8oOMaCrp5H3SQ\neH39erVzL1sGHH108fjYY4Ft24COjsqfWb9eKC1tbf6vk5GYDFkJNzWBqAqyybI3YoSIMsiD7mZi\nZVMgGSPRFignMePE6Uns64vv3HlCZ+EaWzyJlJMYHjISwxPVG89YddlcsEBUGlVh2bKhnkTGgPPP\nB375y8qfCQo1BchITIqshJuakvcVBdNlb+ZMPT1Z46Y83NQU2YzTSOzvF5sAttDYaI7BTUaiJAsX\nBu+AJ8Hy5cBvfpPuGHSGm5InsTqmKwjlkJEYnvp69c2rsBVC580D/vpXtfO/+qow6ko5/3wRclrp\n+6sZiWm1wbBNtug61Avn6lV5TZ/PvOQlmpyTGJdhY1tNBS9qII0K3LohI1GSjg5REj5N7r0X+O1v\n0x0DeRLliZqTaNMiS8ppeBhTD2Xr7xe5UtVkc9484Kmn5M+/YYOoBFhXN/T56dOBsWNFpVM/qhmJ\nEyYAW7YAhYL8mKJgm2xl5To0Je8ryoaO6bJ3+OHAypVpj6I669dTTqIsNvVI9BgxwgwHCBmJEhQK\nQGenqNaXJn/9q1CQ0kRXIRXyJIaDjMTwmK5M6STsdXzooWIHXfZ/Uh5qWsqFFwJ33z38+c5O0Yds\n8uTK52VMKGqqeZKq2CZblJOolygVTk2XvVmz8uFJ3LABOPDAtEehn6h9Et12F2676/uabfoLYE4b\nDCONxLiSn7duFcpLmkYi58Azz6RvJJInUZ4ouQumKwjlkJEoh2oYmzdX1WSTMVFwZskSufOXVzYt\n5e/+TkRFDAwMff7xx4O9iB5p5CXaJluUk6gXWtcqk4dw074+sc6WtnIwRTajtsAIYt8++4xEUyqc\nGmkkxuVJ3LxZ9PtK00h89VURqhWmGXWcUHXTZLFtJ46UKTlUw9hkrmOVvMTyyqaltLUBxxwDPPLI\n0Ocfe0zkfleDjMT4oetQLzSflTngAGDjxuRDyGV4800xThOJM9y0u9u+cFMyEjNMnEbi0UeL8u1p\nVTl96ilg/nyRS5RmUix5EuWJkrtguoJQDilTcqiGsXlzFUY2VfISg8JNAf+Q00cfJU9iVshKuKkp\neV+0rlWGMRHGuWFD2iOpjF/7C1NkM24j0aZNbsCcNhhkJEqwaRMwaVJ6lfUAoaSdfHL6uxSFgp6S\nxuRJDEehANQYebX6Q8qUHKrzJTNXJ54oQt3D0tcnwuKDcgvPPRdYvBjYu1ccb98u1rWpU6ufn4zE\n+MlKuKkp0LoWTNZDTk2tbApQ4RrdUE5ihonTkzh5crohp56R6FX3SwtdXkybPImm5C4kASlTcqjO\nl1e4Joxsjh4NtLSIkKswvPKKKEYRVHl1xAjgzDOB++8Xx08+KSIlwpDGZp1tspWV69CUtTNKT1Mb\nZC8PRmJpZVPAHNkkT6Je0nbk6MJIIzGuwjWbNwtPYlpG4s6dwn194IHpG4m6IE8i4UdWlNO8oKp8\nys7VvHnA00+He2+1UFOPCy8UPROB8KGmADBuHLBjx/DCN3Fim2xlJdzUFKi6aTBZNxL9wk1NIaqR\n6Cxy4CxyfF+ztXANhZtmlDg9iZMmAbNnp2MkPvOMCPkC0jUSCwX1vmzl2ORJVM1d8HrZ2UQUubBB\nmSonSrhpU1N42ZTJSwyqbFrKwoXCoHzrrfBFazymTgXWrg3//qjYJltRN2t0hZuakvdFm1/BZN1I\n9As3NUU2o7bACMLGwjUUbpph4s5JTMtI9EJNgXSNRJ07xORJrI6NoRqkTMkRtXBNWGQqnAZVNi2l\nthY47zzgzjtFdcMZM8KPJ+m8RNtkK2pOok1zFQZa14KZOVNUcM8qlJOoho06DIWbZhivCIJuvJzE\nsWOF0Md1QVUiK0aizptVlPCbvKGau2DjAkvKlBxRC9eElc0jjgBWrQpX3fnll8WGWhguuAD4xjeA\nU06Ri1IgIzFesnIdmpL3lZX5zCrNzSJSKWndKiwbNwJTpgx9zhTZjLtPom2eRDISM0xcfXa2bBHG\nGQAceSSwYkU83+NHoQAsXSoaWgPmGIlREvltwQbloBxSpuRIoropICrszpkjvIRBdHWJEOnm5nDn\nPeYYEToqE2oKJG8k9vbaVbGTchL1QutaddKoWhyG3l6x/pma+kGeRL1QTmLG0d1DsFAQD2+BSLp4\nzauvAtM67H19AAAgAElEQVSnFxUUk4xEWzyJqrkLNi6wtbXqmz22KFOlqG62eNVNZWQzTF7iSy+F\ny0f0YAy46y7g/PPDfwZIR6HUlY+dB7LSAsOUvC+qblqdrOYlbtggigaWY4pskpGoF8pJzDBxhDBu\n3Sqq6XnMmSPCqZKiNNQUMMdIrKnRb9Cbho0LbBRsUaZKSSonEQiXlxi2smkpxx0HjBkj95mseh1M\ngTZr9ELVTauTVSNx/frh7S9MIqqR6La7cNtd39co3DS/GGkkNjfrL17j5SN6JO1JzJKR6HkfdGGL\nkaiau+BVoCTCYYsyVUrU6qYysnnSSdXbYIStbBqVMWOEAhImR5JIFp3hpqbkfUUNN7XhPpBVI7FS\n0RpTZJM8iXqhcNMME5eROGlS8fiII4Dly/V+RxBZMhJtuVllBd1GeV5gTM2LQUZieFTmqq1N/G+C\n1p+wlU11MG0asGZN/N/T3y88a7ahuomnM9zUFKIYiQMD5ubDlZI3I9EU4jQSbeyTSOGmGaa5Gdi9\nW+85y43E5mahMCQhBDt2CKP3gAOKzzU2queKREW3El5bKxQw06GcRDlU86FsNRJVcp28uZKVzXnz\nKnsTOQdWr5ZrZRGFpEJObZQrDxVDUed8mZL3ZVMOvipTpwqDLGsRRuvW+YebmiKb1CdRL2QkZpg4\nPIlej8RSZs9OJi/xmWeAE08c/nwcf2cYdCtLNrXBUMFWIzFJ71jeUZ0rVS91UF7iG2+IAg9Jed3I\nSIyXhga1cF6qbjocMhKrU1MjIqU2b057JENZv95sT2JdnfBWx4GNOkx9fXzzmSRGGoktLfHnJALJ\n5SWWh5p6pBVyqltZsuXGGSUn0UZli4zE8EQtXCMrmyefXNlITDLUFCAjMW6iXIe6wk1NyftS9fhn\nzasWN1kMOTU9JxGIr3KzjYVrAPWUmSxhpJGYRE4iQEaiLpqaqFdiEDbuwgFkJMoQtXCNLF51Z7+d\nUpXKplEgIzFeKOxbH6qbOX19wjNhC1k0EjdtGu4oMBHVDQlnkQNnkeP7mq06TFrRfjox1kiMOycR\nSMZILBSAF14A5s4d/lpaRqLuQiq2eBIpJ1EOVbmwreE5EN2glpXNujqhyPkV70qqsqnHoYcCq1bF\n/z22Gj1Z2KwxJe8rC3OZB7JmJHZ3izXPL4TeFNkE4tPFbCxcA5jRBsNYIzGJnMQkFrJXXgEOOcRf\n6U3Tk6jzgidPYjC2KQgeqjcszkVei01ELVyjQqW8xKTDTVtaROGruDea6DqUw8bNmmqQkRiOWbOS\n7UNdjQ0bzO6R6BFXhVMbC9cAZrTBMFKVisNI3LJFGGWlNDSIPl1xGmqVQk0BMZ7Ozvi+uxKUk6iG\nau4CeRKJakRVPlVk0y8vsacH6OoCJk6UH0sUDjlEVFSNE9sUdY8sGDam5H1lYS7zwLHHirY2cV/T\nYQlqf2GKbALxGok26jAmVDg10kjUXbimUBAPv5wALzcnLqoZiZSTaD62LrBkJIZHNdcpSuj4SSeJ\n9amUlSuFFyBpkshLtE1R91DNSbTRo18NVY+/bb1y6+qAz38euOGGtEciWL/eDk9iXG0wbC1cQ+Gm\nGUW3J3HrVmDcOP/X4s5LtMFItMUYUM1dsFU5VZGLQiG+Cm1ZJumcREAUcejuFp5Dj6RDTT2SMBJt\nbemQhfXZlLwv8iSG56KLgP/7P9FSJ22CPImmyCZAnkTdULhpRtFduMavaI3H7NnxGYk7dgB79wJT\npvi/boqRSJ7EYGxdYFUUKhuVKSD56qYeJ50k+rh6JF3Z1IM8ifGRBSPRFKK2qrGJxkbgyiuB73wn\n7ZEEG4kmMWKEui7mtrtw213f12zVYciTmFF0exL9eiR6xOlJfPppoYRVgqqb5gvKSZSDjMTwRC1c\noyqb5XmJSVc29SAjMT5Uwk11e/RNyfsiT6Icn/wkcP/9onBgmgSFm5oim0B8nsRCwc7Qc8pJ1ARj\n7GzG2ErG2KuMsS/6vN7GGHuAMbaUMbaMMdYedD7dOYlBnsQZM0RydRzNboNCTQGzqpvaYCSqYquC\nQEZieNLyUMybNzQvcfly4Mgj1c+nircOx4mtsqVyHfb1UWVTP8hIlGPECOAznwFuvDHdcdjkSYzD\nSLQV8iRqgDFWA+CHAM4CMBvAxxhj5aUP/gnAUs75XADvBHAjY6yu0jl1exL92l941NaKcNANG/R9\nn0c1I3HkyHQu6DhyEm0IN6U+iXKoGok2KqeqyqcXFaAqm3Pnij6uhQKwbZuQ05EjlU4ViREjxE71\n3r3xfYetinoWrkNT8r7ISJTn8suB//kf4K230htDkKPAFNkE4jES43Cg5AXKSdTDiQBe45yv5Zz3\nAfg1gPeXvWcTgFGDv48CsJVz3l/phEnmJALxhJwWCiJ065hjgt+XhoEVR04ieRIrQ0ZieGxVptJS\nPhsagGnTRKhnWvmIHjNmAKtWxXd+W2WroYGuQ12k0c8074waJcJOf/CDdL5/3z4x9zaES8ZhJNpa\n8AugcFNdHAhgXcnx+sHnSrkDwGzG2JsAXgDwL0EnTDInEYinDcbKlULpqbYbm0bIKXkS1VDNXbBV\nQSAjMTxp5SQCxbzEtCqbesSdl2izbMnmJOqeK1PyvsiTqMYVVwB33TW0knJSVGt/YYpsAvEYibZu\ncgMUbpokXwLwAuf8AADHAriFMdZS6c1xGIlJexKrhZp6mGIkkiexMrYusmQkhidN5dPLS0zbk0hG\nYjyoyFZvr51h39UgI1GN1lbg4x8Hbrkl/GfWrtXTPsOWfEQgWp9EZ5EDZ5Ez7HlbeyQCZoSbVszr\nS5ANAKaWHB80+FwppwL4FgBwzlczxtYAmAXgOb8Tfu5z7Vi3bhquuw5obW3F3Llz9+/2uF1dgOsW\njwfjyYOOX3sNmDSp8uu7dgEvvRT+fGGOn3rKwXveU/39AwMuFi8GjjtO7/d7+L2+bh3Q2Kjv+9at\nAyZOrPD64NahEzCe2I+7uuC0tkY+X+ncysz3xo1AU1OCf29GjhsbgeXLXbhu+Pl66il3cOcu/fEn\neTx3roOeHv/Xu1Z2oXWWv/zu2+fiiSew/zmV7+cc+OtfHYwYASxY4P//SuL4sMOA225zMW+e+vm6\nVg51VZS+3tMDbNqU3t+X1vGbbwKTJ/u/Xmm+Jk1yhuS6Rh2P91wW5iPK8RNPuINKuP/rXSu74LrD\n9ZOeHr3zmcfjK68E5sxxcdxxwDnnBL+fcwcf/jDwnve4+MQngq93v/kuPX7oIeBtb6v8+tKlS3Hl\nlVemPj86jt9808XmzUDF+2cV/dlvPjdtslN/AYCVK12sXQskqY8sXboUXYN6c0dHByLDOU/1AaAW\nwCoABwNoALAUwBFl77kRwFcHf58EEZ46rsL5eKHA+ZQpfDgLF4qHJAceyHlvb+XXCwXOJ0/mfGBA\n+tQVOfJIzjdurP6+q67i/Be/0Pe9HgvvXMgX3rnQ97X3vIfz557T910//jHn115baSALlf5nWtE0\nhkceeaTyVwTM96mncr56deSvzx233sr5ddf5v1Zpvv78Z84/+tF4x5VF9u7lfPp0/9eCZGvyZPEz\nSDarUShwPnUq5xMn6l0DZVmxgvP586OdI2iuvvIVzm+/Pdr588gNN3D+ve/5v1ZpvpYs4fyss/SN\nIYp8Zg1f3YQHy17QWmgTV13F+Xe/G/yeO+7g/PDDOb/mGs4/+9nK7wua71K++U3Ob7qp8usmyeZN\nN4m/15cqelCl+Vy+nHPH0TG6/LF+PefHHZfuGISZp26j1UQ3M6PBOR+AqF76EICXAfyac76CMfYp\nxthlg2/7dwDHM8ZeAPAwgC9wzrdVOidj+ioqFQrAwABQX1/5PYyJ4g1r1uj5zq4uEWIYlAfpYUK4\naVMT5SQGobsvZV5QDXOjuZJHVTYBsf6dcIJYA2tSvKMccoi+NdgPW0P+snAdRpHPrKGim9gqe+Vc\ndRXwwx/6h0QODIjXf/5z4PHHxZqkI+2oWripSbIZV06izeGmec9JzEK4KTjnDwI4vOy520t+fwvA\ne+XPG72h77ZtQFtb9fd5eYkzZkT7PgB4+mngpJPCvXfChHgr+vlBOYnJQjmJ4bFVmaqpERtaMuhs\neD5vnsgbSpOGBqCuLr4cGFtlq7FRvmCIra1owsCYfHNxW2WvnClTgPe8B/jZz0T/RI9du4Dzzxe6\n2uLFYq50Vbm3KSeRCtfoRXd9lDRI3ZMYF7p6CAb1SCxFZ/GasEVrAPIk5gkvflwWWxdZMhLjpdTb\noyqbHpddBnz969HHFJWJE+NbD22VrYaG9K/DqPKZJRoa0q8Wm2e+8AXgP/+zOIdr1wLz5wPveAdw\n553FeWpp0aOgr18fbCSaJJtxGIk2F65R2bzNGpnwJMaBZ8FHbexcrbKpx5w5wE9+Eu271q0DbroJ\n+PWvxW5YGEwwEsmTGIytCgIZiXLIegV1ztXo0eKRNhMnAp2dwNSp1d8ri62ypdICw9aw7zB4fYFl\nNv5slT0/pk4FHEe0xJg9G7jgAuDGG4EPfnDo+3R5ErdsAcaPj36ePBDFSHTbXd/nbd3k9qirA/r7\nxc88ktNhV8dbICZMiHaeaj0SPaJ4EpcsEYvcU0+JEIqXXw6vcKVhJOrOkbPFk6iau5DnBSYKZCTK\nIRvGVjpXpuTVeEZiHNgqW6rXoc5wU1PkE6B1TQdf+hKwYIEwau69Fzj22OHv0eFJ3LNHfEfQmmqS\nbFK4qX68Nhhjx6Y9EjWMVT11xQKH9SROnCjyF/v6govceBQKwAMPCONw506RcH3nneE+W0pankSd\nFz15Egk/SJmSw5uvsKE9JhZEmjCBjETd0HWoF5rP6MyYAdxwA3DaacABB/i/R4cnsVqoqWlE6ZNY\nCZvDTYFi8Zq8GonG5iTqMhLD5iQyBsycWb2Zc6Egkq6PPhr40Y+Ar3wFePZZ4GMfkzcQAWDUqOSb\ndepulGyLJ9Gk3IUk8MKyZLBZmWpslLuOSufKFNkkT6J+spBDZ4p8AmQk6uLCCysbiIAeT+K6dcBB\nBwW/xyTZHDFCvy5muydx1Kh8Vzg11pOoK2l582YR/x4GL+T0yCP9X9+zB7joIlF19Z57gCOOiD4+\nxkQoYlgPpg4411vqnjyJlRkYSLetQJrIGj2AnCfNNGSNahMVz4kTgRdeiOfcJs5XGFRbYFB1U39U\n1zUbZS8KOrxiNlU2BahwTRzkvQ2GseqnznDTMDmJgEiirpSXuGEDsHCh8CDee68eA9Fj/Hjgrbf0\nnS9pbPEkquQu6A7tzRO04y6H7HyVypYpeTXkSdRPFq5DU+QTyMZ82oCO9j5hwk1Nkk3KSdSPl5OY\nV4w2EnVUtgqbkwhULl7z3HMiyfrznwe++lV9vck8ks5LVGkGHAR5Eitjs3JAypQcKkaiaXNFOYn6\nyUILDJOgMPrkiNqCIEy4qUlEMRKdRQ6cRc6w58lIJE9iJtHlSezsDF8h1c+T+JvfAB/5CPDLXwIf\n/Wj08fiRpJEYR/ijLZ5EldwFmxdYMhLloJxE8iTGQRZaYJginwCta0kyciSwd6/65zs7q0eSmSSb\nFG6qH8pJzCg6jMRCQRhFYXP9xo4VStq+fUKxv/56YSQ+8kg8fbs8kjQS4wh/JE9iZchIlPuMzcqU\n7HyZWt00rrXQVtlSvQ7zWs0vbmhdS46WFhFR1tKi9vldu4SSbwtxVDe1WYcB8h9uaqyR2NIS/R+z\nbRvQ1ib3mSOPFH0Pb7tN7B48/rj6AhWWpI1E3TcrW4xE1ZxEW5UDUqbkiFK4xpS8moYGUcSLc/1h\n/bbKVhauQ1PkE8jGfNpC1LSjMAamSbJZWxstPNcPz2liK6NHi7S1vELhpgHI5CN6zJkDvO99wJQp\nwG9/G7+BCOTfSKyrEx5bYjg278KRMiVHlMI1JhHXzq2tsqXSAkN3uKlJUHXT5Iha5T6KF5IQdHdT\nuGmew02NNhKjFq4J2yOxlL//e+Cmm4D/+A+xK5MEeTcSAf3FcLII5STKUV8vvEIy2KxMRSlcY1Je\nTVzFawYGxIaWbahu1uhsgWGSfNLmV3JE1QN37apuJJokm4CIwNCpj9mswwD5L1xj7C0vLU/iiSeK\nR5KYYCQS/tg83yrhgjbPV5TCNSbhFa859NC0R2IGZNTohaqbJkdUT2J/f3L9p7OCV0hQ1vvntru+\nz9teuCbvOYnGehKjLg6AXI/ENEnSSIyr2EXUUtV5QCV3wfZdOFlsVqZklc/Sa9mkvJqJE5NtCWQ6\nWQg3NUk+yehODl2t0IIwSTYB/RVObddh8u5JNNZI1OFJVAk3TYO8VzcF7CleI4vtCywgF/piszJF\nfRIFcbTBsCEcvhIqOeO6w01NQuVe19tL86lCFGeBqetjNchI1AvlJGYUHTtIKuGmadDaCnR1JfNd\ncS2cNhiJKrkLtt6oPOrqRMhPWGyeL8pJFMRhJPb12Rd2FgXd16FJ8qlyr+Ncf39iG4iiB4YtWmOS\nbAL6jUQKN6Vw00ySVk5iGtTUiPytJCqExqWEe3HwxFBs34Uj71h4qLqpII7CNTbLFSDvSbV9voJQ\nqW5KqBHFk2hrZVPyJOqFwk0zii4jMQ85iQAwbpzo6xg35ElUh3IS5SEjMTxRCteYlFcThyfRZrny\nkDEUdYdHmiSfNtzrskIUT+KuXSJUsBomySYg9A3yJOoj75tCxhqJOgrXdHaKXek8kFReInkSk4WM\nRDISwyJbuMbUuYqjcI2pcxWW+noK+9aF7HU6MJBcOy3TIE+iPCNGqOliziIHziJn2PO26zBelfa8\n5rUbayRGtd4LBbE45yUPJSkjMa7qpjbsrlJOojxkJIZHdq5Kr2WT8mrIk6iftK9Dk+Qz7bm0iZaW\naJ5EykmMTm9vfvTouFBpe5MVpPskMsamApgJoBVAF4BXOedv6B5YVFR6rJWybZsI4cwLSXoS49gV\nIk+iP93dQFtb2qNID1mFyuYCI6R8CsaNA7Zu1XtO26t1yrbB0N0CwyToOk2OKGlHu3eHCzc1Dd1G\nIhBdH887Xl5iHj2qoYxExtgBAC4DcCGA6QBK/+WcMbYWwN0Abuecb9A+SkUYEx5BlapgecpHBPIf\nbmqDJ5FyEuVRkQtbb0gqOYmebJmUV1NbK0J7VNd+P2xX1FUMG8pJ9IeMxOSI4kkMG25qkmwC8RiJ\ntuO1wZg4Me2RyFP1FsoYuwHAKwBOAXAjgOMBtAGoBzB+8Pg7AOYBWMkY+/fYRitJczOwd6/aZ/PS\nI9Ej70YieRL9sV1BsGHzQBekfBbRXcjL5LkKA8mWPqIUmCLkiFq4xtacRF1G4sAAtW4B8t0GI8y/\nbxyAOZzzMznnt3HOl3DOt3POBzjn2waPb+OcnwngKAjDMRNECTXIS/sLjzjKvvtBnkR1VHIXyJNo\nvlzoIkrhGtPyanQXr7FdUZe9DnWHm5okn2RwJ0fUwjVhwk1Nkk1Ar5HY3W13ZVOPPLfBqBpuyjm/\nNOzJOOcdAEK/P268XSQVYy+PRmJSnsSxY/WflzyJ/pCRGF6h6u+3uwpglMI1puEVrzniCD3ns11R\nl81JpIqclaEqxMkRxZO4ezcwdare8eQB1RYYbrs77Dnb9RcPL9w0jxjtCI7qSaScxOFQdVN1VHIX\nbFcQZOSC5kpd+TQtr0Z3hVOSrXTXZ5PkkzyJyRHFkxg23NQk2QTUW2D4YXuPRA/Tw00DYYz9K2Ps\nz4yxFYyx6xljmaktGMVIpJxEf6i6abLYvhNHRmJ4KNepiO7we5PnKgyyhk1ee4IlARmJyTFihHpd\nCqpuGh3b9RePPIeb6vAkruCcn8Y5PwLAYgDXajinFqLsIuUt3LStTX/Zdz8oJ1EdykmUh4zE8KiE\nsXmyZVpeDXkS9SITbhqHgWiSfJKRmBw1NeryGLa6qUmyCZCRGAe2G4mTGWPvZow1c87/DOAZDefU\ngk2Fa0rLvscJGYnJYruCQEZieEj5LEKFa/QiI1t9fXb3lKwGefyTR8VQpOqm0aFwU0GecxJD9Ums\nwtsAjAVwCWNsLADGGGsG8DbO+Xc1nF+ZKEnLnZ3562nS2gp0dYny73ERZwsMVYM+L1CfRHnISAwP\n5SQWIU+iXtK+Dk2ST9rMSZaRI4WxMnKk3OfChpuaJJsAeRLjwOqcRAD3A3iKc34e5/xdAC4D0ATg\nfRrOHQlVT2KhIKqz1WcmuzIcSeQlkicxWWxfZNNWTvOEiofCVI8PGYl6kbkOdbe/MI3GRrlKsbbL\nXlRaWtScBWHDTU1D1Uh0FjlwFjlDniNPosC6cFPGWB1jbAIAcM6fA/CS9xrnfBXn/OcAPqpniOqo\nGonbtsXrjYuLJIzEuKqb2lC4RiV3wXYFgYzE8KgUF/EaHZuWV0OFa/Qik5MYx+aDSfIpmydncqua\nJFDVA8OGm5okmwB5EuMgz+Gmqp7EawGsYIxNGzyeyxg7vvQNnPM3I4xLC6qFa/KWj+iRlCcxjoue\nPIn+2L7IkpEYHtnCNSYzZgywY4e+89kuW3QdpgfNZzRUPYl79ggD0zZU+yT6Ybv+4mFjuOlrAGZx\nzjsAgHPuAjha05i0oZqTmLceiR55Djc13ZP4pz8BI0c60p+zfZEl5TQ8dXVAf3/49zNW/N20vBrG\nxHz09ek5n+2ylXa4qWnyKeNJtF32oqKqBxYKoiBgNUyTTeqTqB/rwk0BTOWcv1X2nKa9B32ohhnk\nrUeiR56NRNM9iYsXA089Jf+53t785cbqRNZINDXHLgyMhVc++/uLoaamMmEC8Fb5XUoR2xX1tMNN\nTaOmRtQ9CIPtshcVlYgym/t8Uripfmw0El9hjP2cMXZAyXMTdAxIJ6pGIoWbVoY8iWrs2gW8+KKr\n9NlSj49tyIRQkjIVnvK5Mi2vBtBbvMZ22Urbo2+afNK6lhwqnkSZaqimySa1wNBPnnMSlVpgcM7v\nZYwdDGAVY+w1AHsA/I/WkWkgSk7i4YfrH0/c5NlINN2TmNcFIm3SVk7zCOfVNxZsmCudxWtsmK8g\nGhvDr2G2z1UYvHUtjCFC8xkNFT3Q1sqmgLqR6La7w57r7iYjERCpD2EjB7KGcp9Ezvn3GGO/BHAq\ngDc55wrBdPESxZO4cKH+8cQNVTfNLrt2AQcf7Eh9JoyybzoybR1ImRJhfmGamZfPlWl5NQB5EnXS\n0CCXk6g73NQ0+aTNr+RQ8SSGrWwKmCebOnWx7m5g7Fg958o7jIk817yleVQdLmPshEqvcc43cc7v\nLTUQg96fNKoJy5STWBnyJKqxc6e8LMahbOWNtAtm5I2w8xVXleIsMXGivvXQdkVdpref7XMVBjIS\nk0PVkzhqVDzjyTqyLVqCoHDTIqpOq7QJY9P+ljH2R8bYBxhjviorY6yBMfZBxtgDAO7VO0R1bMtJ\nHD9eX6GGSoTxUqhggydxzRpX6jOU9E3KlCwyRiLlJIbHdtlK+zo0TT7Tnk+bUHEWyISbmiabgD4j\nkXSYInltgxEm3HQmgM8BuAXAOMbYiwDeALALwCgAB0O0v3gLwK0APhTPUOVRNRI7O4WCkTe8ULO4\nwxTjOLfpnsRdu0Rcugy0wJIyJUvY8Fwb5mriRODJJ/Wcy4b5CoI8+nqhMPrkaGkB1q6V+4xMuKmJ\n1NToCY0kHaaIV+H0gAOqvzdLVBUBzvk+zvm3AEwF8AEAiwdfOggAB/AwgPcBOJhzfj3nPDOtMFTC\nDAoFUR4+r20HRo3K526F6Z7EnTuB+npH6jOkHJCRKEvYqonlucWm5dUAVLhGJ2m3wDBNPqm6aXK0\ntKh5EsOGm5omm4A+fYzCTYvktQ1GaN8G53wAwJ8GH7lA5sbmsW0b0NYWz3iSwMtLHD067ZHIYYMn\nUfZGRbtw8kbi+PHxjifrqIabmgiFm+qDNmv0QvOZHCoRZTZXNwWKFU7DtgEBAGeRA2BolVPSYYrk\ntQ1GzursxE9e8xE9dBZrKKe/H6itjefcJnsS+/vFortliyv1OVpgSZmSRbVwjYl5NToLedkuW2mH\nm5omn7SuJYeKJ1Em3NQ02QT09UokT2KRvOYkGm8k1tTI9SfJu5EYZ4XTuNpfACJfr78/nnOnza5d\nwniX9ZSSckDKlCyUk1ikuRnYu1fPuWyYryBkWmDEEW5qGrSuJYeqJ9HW6qaAPiORNrqL5DXc1Hgj\nUTYvcdMmYPLk+MYTN3EaiXGWzWdMX0WtrLFrl1ggGhocqc/RAkvKlCyq4aYm5tUAQtnRYSjaLltp\nt8AwTT5pXUsO1ZxEW/skAmQkxgGFm2YU2V0k8iRWhm5WauzcKRaI2lo5rzYtsKRMyaJauMZUdK2H\ntssWXYd6oeqmyaHSAsP26qYUbqofCjfNKLILBBmJlYn7ZmWqN9HzJNbUuFIbFqQckHIqC/VJHIqu\n4jW2y5ZsTqLucFPT5JOqmyaHSpV7mXBT02QTEPJJnkS95DXcVLJzWxHGWBuAbZxnW61X8SQuWBDf\neOImz0aiV43WtBui50kcMULcfMJWnqUFVuQUh11hSJmi6qbl6CrkxXn0nmF5RrYFhg2yFQXa/EqO\nkSOpuqksI0bIFxIsrWrqQZ7EInk1EqVue4yxWsbY1xhj2wFsBjB98PlvM8Y+FccAoyJrJFJOYmXi\nvlmZ2gbD8yROmeJIhRuQkSgHKVNyhWtKZcvEvBpAbxsMm0nbqDFNPtOeT5uorRX9r2WQCTc1TTYB\nvTmJJLsCW3ISvwjgYgD/DKB0X3EJgHZNY9KKbKgBhZtWJu4L3tQ2GJ4nUTaBnpQDOWi+yJNYzoQJ\nZCTqIO0WGKZBRmLyyMS8UXVTPUZioRBf27S8YUtO4sUALuec/wJAaQmOZQBmahuVRmRzEjs7xe5z\nXslrdVPAfE/i3r2ulCySJ1HAWLidYFKmwuc6UU5ieAoFIYM2k3YLDNPkU6ZwzcCAaBFFqCOTAwrI\nhZuaJpuAPiORKGJFuCmAqQBW+DzfDyCTkccy4aaFgujVV18f75jiRHYxlCFuJdxUT+KuXcWcRAo3\nlXQLBEEAACAASURBVIe8Y+EJO1e2hAHpMBJJruT62NJ8VcfUDdGsIussoOqm0Y3EbFcrSR5bwk07\nABzj8/zpAFZGHk0MyBiJ27YBbW3xjicJdPUGK4dyEtXwwk1nznSkPYmkbJGRKAP1SRyKjsI1JFfC\nkxrWmxpHuKlp8hnnZi4xHNm0o717RcGbMJgmm4AeI7GvT39EQZ6xJdz0VgA/YIydOXh8GGPs0wCu\nB/BDrSPThIyRmPeiNR5xhZySJ1ENL9xUJSeRPIlkJMogU7jGhrkiT6I+ZKoMk3IYTNg1jbwxepC9\n9wJ2h5irGInOIgfOImf/MVU2HYpKv84sIGUkcs5vBvBzAPcBaAbwAIDvAvgu5/xnqoNgjJ3NGFvJ\nGHuVMfbFCu9xGGNLGGMvMcYeCXtumR2ktWuBgw8Oe+bsklcj0XRPYmcn5SSqQEZieGRyEktly8S8\nGgAYP56MxKSJY75Mk8+wa1ocPSdtRDbtSMZANE02AT0b9qS/DEWmnVeWCJ0OzRirB7AWwBkAbgAw\nG8LIfJlzLtmFZsh5ayC8kO8C8CaAZxljv+Ocryx5zxgAtwA4k3O+gTE2Puz5m5uBNWvCvbejA5g2\nLfzYs0pcRiJVN1XD8ySq5CSSckpGogw0V0NpaBBhT5yrewZsmatqeHmJ1YqoUHXT6tB1miwynsQ9\ne+zORwT0hJuSJ3E4YdfQLBHak8g57xv8dYBzvo9z/hzn/JkoBuIgJwJ4jXO+dvA7fg3g/WXvOR/A\nvZzzDYNjeSvsyWV2kMhIDIaqm6rhFa457ji5nEQKNxWElQuqAqheuMbEvBqPMWOiFQwgRV0gY9jo\n9n6ZJp+q/UwJNWRC/WSL1pgmm4AeI5E8icMZNSp/eYmyOYk/geiRqJMDAawrOV4/+FwpMwGMY4w9\nwhh7ljH28bAnlzES16whIzEIyklUQ7VPIi2yAlM3D+KAchKHE7V4DXnGBGHbYNgkW6qQJzFZZNKO\nZNpfmAoZifGQxzYYskbiAQAuGMwf/C/G2I9LH3EMcJA6AMcBOAfA2QCuZYwdGuaDMotDRwcwfbri\nCDNEXo1EU40BL9z09dcpJ1EFU+UiDlSVTxPzajyiFq8hRV3Q2CgM5mpQTmJ1VPuZEmrIeBJ37xab\numExTTYBCjeNizy2wZANzpoB4PnB3w8oe001JXMDRP9Fj4MGnytlPYC3OOfdALoZY49BtOJY5XfC\n9vZ2TBt0Ce7e3Yo33pgLwAEAuF1dgOvuDxHwLnDHcbBhA/Dqqy5Wr4bv63k53rgR2LIl2vk8Sl/v\n6QE2bXLhuvGMv6kJWLrUxZQpJa93dYnXfcaT2HFXF5zWVuXPb90KNDc7GDFCGIp+8+dRPt8vveSi\nUMiWfCV93NUF9PQMfd3DO164MDvjTfN4+XIX69cD+9c710XXyi60zhoqvz094noLkj9Tjvv6gM7O\ncO/vWinWGw/XdbF0KdDYmJ2/J63jxkZxPHly8Hzt2AE0NOj9/tLzp/X36zyeOFGs737y57pF/eTx\nx93BdlbZGn/ejltaHOzZU32+veu9pSX8+ZcuXZr636f7uLnZwb59Pq8H6M9uuwvXdffPZ3c3sGOH\nC9dN/+/JynFPj4tHHwWOOiq+71u6dCm6BvXmjo4ORIZznuoDQC2EsXcwgAYASwEcUfaeWQAeHnzv\nSADLABxZ4Xy8lFde4Xz+/MGDhQvFw4edOzk/5BDfl3LH009zfu650c6x8M6FfOGdC4c89+Uvc/7T\nn0Y7bxDXXcf5bbeVD2Rhxf9ZYkQcw+TJ4ueLL3J+xhkVvsJnvs86i/OlS5W/1hguvpjzBx4Y+lz5\nfPX0cD51aqLDyiTPPjv82veTrVNO4Xz16uTGlSbXXsv57beHe6/fXD34oJBB21mwQNxPS/Gbr4MO\n4ry3N7lx5ZFVqzg/9dShz/nN5fPPc37OOcmNy1Ruvpnzb3xj6HN+880557//Peef+EQy48oqy5Zx\n/q53lT0pqQf94Q+cX3KJzlHln/b24bpM3AzaRMo2WuplHjjnA4yxfwLwEET460855ysYY58SL/Mf\nc85XMsb+BOBFAAMAfsw5Xx7m/GFzEteuNSMfEchvddOw+VR5YmAAqK0Vv1NOohphQigpLEtAuU7D\noXBTPTQ0hAs3zVv1vjSg6zRZWlqADeXxaRWQDTc1kaYmykmMAxtyEsEYeydjbDFjbOPg42HGmBNl\nEJzzBznnh3POD+Ocf3vwuds55z8uec93OeezOedHc9GvMRRhjURTKpsC+a1uGjZPI0+UVkp78UW5\nnERSEARkJIYn7EZL+YaPF7ZiIlEL15BsCWRyg3U3IjdNPqnAVLLEWd3UNNkERC4h9UnUj/HVTRlj\nHwOwGMBOAN8efOwGsJgx9hH9w4uOjUaityD29+s9LxWukccrWgOo9UmkRZaMRBmoIMZwyJOoBxPX\n57QgT2KyyFY3td2TSIVr4sEGT+I1AK7hnH+Ic/6DwccHAXwFwLX6hxed+vpwxtKaNWZUNgXELu4p\npwCLF+s9L7XAkMdrfwEAZ5zhSP19ZCQKyEgMj6ry6SW+m8iECWQk6iBMuClXLV9XBdPkkzZzkkUm\n1UO2BYZpsglQC4y4sMFIPBTAPT7P3zP4Wm4xyZMIABdfDPz853rPSZ5EeUo9ibIhWKQgCMIoVDRX\ngrDXUF+f2ECzAfIk6iGMbA0MUD5iGOrrxTVYDZI9Pcj0y5YNNzURlQ17Z5EDZ5Gz/7i7mzyJ5eSx\nBYaskbgFwNE+zx8z+FomqaurviCbZiS++93AE08AO3boOyd5EuXZtavoSXRdF3V14cOA4y4UlBfI\nkxge1bwxE/NqPMaNA7ZuVf88yZYg7HXY0KD/u02Tz7AbhiR7epD1JNreJ1FHTvG+feRJLGf0aMNz\nEgHcDeB2xtinGGNHDj4uB3AbgF/oH54ewuwivfkmMGVKMuNJgoYG4AMfAO7x8/sqkkR1U9M8iaXh\npoDczYpzoEa6tJR5kJEYHhMrBEfFqy5cKKh9nmRLQNehXsKE5tJ86kHGkygbbkr4Q+Gmw7Eh3PQa\nAIsA/ACiV+FLAP4TwM8g8hIzSbWk5Z07xSLiKROmoDvkNInqpqYpuKXhpo7jSLfBIEg5laGmprry\n6fe6iXk1pbS1Adu2qX2WZEsQJicxrrkyVT6rXaske3qQue/KhpuaKps1NSJ8XBUqXDMc441Eznk/\n5/xfAYwFMBcizHQc5/yLnHPNtTT1Ua38sUk9Ekt5+9uB7duB1av1nI9yEuVR9STGVQAij4TxjpEy\nVaRaqJBN+YgeUYrXkGwJwqzPvb3xhJuaSJjUA5I9Pci0wKDqpoKom/bkSRyO8S0wPDjn+zjnywYf\nEWsgxU+1UAPT8hE9GAMuugi46y4956OcRHlKPYmu62LUqHA3q/5++xT5SpAnUY4w3onym7eJeTWl\nRCleQ7IlSPM6NFE+qSBXctTVhfeKyYabmiibQPQKp2QkDsd4TyJj7B7G2NU+z1/NGPtvfcPSSzUj\n0aT2F+VceCHwy1+q5+OUQp5EeUoL1wDi5hNmJ4mK1hQhI1GOamFCNs4VGYnRSTPc1ERoXcsmVN1U\nIGskuu0u3HZ3/zGFmw7HeCMRwAIAf/R5/oHB1zJJtZxEUz2JAHDAAcAhh4hKp1EhT6I8peGmMjmJ\nced/5glSpuSoNl9+c2VqXo3HxInAFsX62yRbgrDhppSTGA5a15IlzCYHIB9uaqJsAuRJjIM8FpaT\nNRLHANjr8/xeiDzFTFItHt1kIxHQV8CGqpvKUxpuCoTPSaQFtggpU3JUC2Oz0UtNnsTopNkCw0Ro\nXUuWsHmJJMOCqEYieRKH49ULyFPNCVkjcTWAM3yePwPAmujDiQdbcxI9PvAB4KGHgL1+5r0E/f3x\nNko23ZMok5NooyJfCVKm5FDxJJqaV+NBhWuiQzmJegnjVaD7gD6qRZSVItMn0ETZBMiTGBdhcpGz\nhKyReCuAGxhjn2WMzRl8fA7AtwdfyyTVjETTeiSWM3IkcNZZwH33RTsPY3qarFbCFk9imJxECjct\nQkaiHCpGoumQJzE6YcL14go3NRFa15IlTBRPX1+8G+F5gozEeMhbXqJsC4xbIPoifgvAC4OPbwL4\nAef8Zv3D00OQkbhjh/D0mN60/OKL9VU5jQsTPYmlhWtkchJpgS1CypQc1TwUfhsQpubVeJCRGJ00\nw01NlE+qbpos1ZwFgHhdtmiNibIJULhpXOStDYa0acQ5/yqA8QDmDT4mcM6v1T0wnQSFGXR0mFvZ\ntJRTTwVefx3YsEHt80nEUIdNLM8TO3dSTmJUKBdKjmrKp42KJxWuiQ5t1uiF5jNZwtx7qbJpEdlN\ne2eRA2eRs/+YdBh/jPYkenDO93LOnx18hIzyTo+ghGXT8xE9amqACy4A7r5b7fNJNOBmLF8JvWEo\n7bkkk5NIykGRNKsq5pFq8+WX52RqXo3H6NEiakQFuhYFabbAMFE+yUhMljCeRNnKpoCZsgnoCTcl\nT+JwjDYSGWNnMMZOLTm+lDH2LGNsEWNM8tJKjqDFwRYjEQAuukiEnKoYYpRAr0ahMDSUWaZPIu3C\nCUiZkoNyEofDmMg1UolUsHG+/Ai7WUMe/XDQupYsYTyJpZu6thPVSOzpid+xkEdGjTLYSATwHxCh\npmCMzQRwC4DnABwP4Dt6h6YPMhIFhxwCtLUBf/ub/GeTLKRiijdxYGCogUg5iWqQMiVHmJxE2/ok\nAqLC6VtvyX+OZEuQ5nVoonyGqW5KsqePMC0wVMJNTZRNILqRCMRb6DCvjB5tdk7iDAAvDf7+QQCL\nOef/COBSAOfqHJhOquUk2mIkAuo9E5O6WdXXi1YbJuC3KxnWSCTloAgZiXKE8STauAGhmpdIsiVo\naKDrUCe0riVLmBYYKuGmpqLDSCSGY3S46SCen2chgIcGf98AoE3LiGKAchKLnHce8L//Kx92ldTN\nyqQ2GOXtL2T7JNqoyPtBypQcKoVrTM2rKUW1winJlqCxMb0WGCbKJ1U3TZYwnkSVcFMTZROIZiSW\nR1ERRUw3El8E8I+MsQUATkPRSHwbAMXacfETFG66aRMweXKy40mTMWOA+fOBP/xB7nNJ3axMaoNR\n2v7Cg3IS5amrq+5dJmWqiErhGhtQNRKTKNqVB6jKsF5o8ytZwngSqbppEVkj0W134ba7AOyNVgmD\n6S0wrgZwCYBHANzFOV8++Px7ATyrc2A6qWQkdnUJq962HQ+VkFPyJMqzc+dQI1EmJ5GUgyJh8hpo\nvoqoFK4xNa+mlAkT1HslUm4N5STqhozEZAnrSZQNNzVRNoFoG/bUI7EyRnsSOedPAJgIoI1zflnJ\nS3cA+IzOgemkkpFoW6ipx+mnAy+8IFfEISnvg2mexNJwUyBcyBZAnkRZSJkqolK4xgZUPYmEIEwL\nDGpFEx4yEpMlbE4ieRIFUcJNSX+pjNFGIgBwzgc4511lz63mnG/SNyy9kJE4lNpa4OyzgUceCf+Z\npMIHTPYkyuQu0CI7nKCqt6RMFVHxJJqaV1OKauEaQpBmuKmJ8hmmuim1FNFHXNVNTZRNIJqRSJ7E\nypjeAiOX1NaKfnXl2GokAkJh2r49/PspJ1EeP08iIHLs+vqCP0tGz1Dq64PnjOarSJjCNTZuQKh4\nEvv7xf2DIM+XbsJuiFKosx6ouqkc5EmMB9NbYOSack+EzUbimDHAjh3h3085ifKUF67xchfC5CXS\nIjsUahAfHspJ9EfFSCS5KpJmCwwT5TNMdVNCH2HuuyrhpibKJkBGYlwYH26aVxoagF4+tERdRwcw\nfXo640mbMWNE4Z6wkCdRnvJwU48wbTBokR0KGYnhoeqm/qgUriG5KlLNmw9QeKQMJm2I5oGgKvce\nVN20iKyR6Cxy4CxyAFC4aRDWGImMsTbG8hMI0dwM7BkYqnWTJzH8+8mTKI9fn0QgvCeRlNMiZCSG\nR6Vwjal5NaWMHAns3Sv3GWrpUISx6qGPcV2HJspntTWNQp31EtaTKBtuaqJsAuRJjAujW2AwxmoZ\nY19jjG0HsBnA9MHnv80Y+1QcA9RFSwuwe6C4tcG56JE4aVKKg0oRWSORqpvKU8mTGKZXoq15Y5Ug\nIzE8YXISbZ0rWUPR5rnyI6h4FEDzJQOtackSxpNI1U2LUOGaeAjT9zlLyHoSvwjgYgD/DKC0GPYS\nAO2axhQL5Z7Eri6gtdXepHAVTyJVN5Wj3JNIOYnqkEIVnjBzVS5bpubVlCNb4ZTkSo64wk1NlE9q\nVZMsYVq4qISbmiibQLQNe9JfgmHMv5hmFpE1Ei8GcDnn/BcABkqeXwZgprZRxUBzM7CnUNzasDnU\nFMhuuKlJnsTywjUeYXMSSUEoUs3w4RyosSbDOhgyqCsjm5do81z5UVsLDAxUfp3mKzx0nWYP8iQW\noXDT+Ajj1c4KsmrVVAArfJ7vB5Bp53K5J9F2I7G1NZtGokmexEp9EsN4EincdCgmyUXcVPNQ+G1A\nmJpXU45shVNS1IeSlmFjonxSWHjyVGs/1dcnCjTJYKJsAtHuuRRuGkye2mDUSb6/A8AxANaWPX86\ngJU6BhQXLS1kJJai4kkcNy6+8XiEaTCcFyr1SQyTk0g7cUMhIzE85KGoDHkSo+G1wRg50v/13l6a\nr7DQdZo8ngentXX4a9XybW1DNhXLbXf3/076SzBehdMDDkh7JNWRNRJvBfADxpinxh/GGDsbwPUA\nPqd1ZJppbh5auKajAzjllPTGkzayYZ1JhpuaYgyUexJlcxJJQSgSpFAVCvbmFvuh4qEwNa+mnLFj\ns9n6Jy80NgbndcVVDdZE+VTJHSai0dJS2Ujs7VWbbxNlMyrd3eRJDCJPbTCkwk055zcD+DmA+wA0\nA3gAwHcBfJdz/jP9w9OHyEksrgBr1tjtSfQIu3uWlNFikiexUjntMDmJpCAMJcjwod5sQyEPRWWy\nmoudF0i29EFzmTzNzZXvvdQjcTi1tWqVOPftI/0liDy1wZAu9cA5vw7AeAAnApgHYALn/Juax6Ud\nkZNIhWtKCePR8kjKaDHJkzgwMLTPlWyfRFpkiwQpVKRMDUXFQ2FqXk05ZCRGo5psxRVuaqJ8UnXT\n5PE8iX6oFq0xUTY9VIvXkP4STJ48ibLhpgAAzvk+AM9pHkuslBau4RzYvFkUMbAZT2EK0zw2ycI1\nJngSg0Igw+YkkoJQhIzE8JDyWZkxY+RuzjbPlR/V2gj09soX/rAV8iQmT9AGbaXIH5vx0pJk54UK\n1wSTJyNRypPIGLuHMXa1z/NXM8b+W9+w9FNauGb7dlGExfY8JpkKp5STKMeePcN3JWVyEgcGRCU2\nQkBGYniqKZ9+GxC25NWQJzEaYQpIxXFfNVE+qbpp8gS1HlANNzVRNj3IkxgPJoebLgDwR5/nHxh8\nLbOUFq6hUFOBjMJELTDkKC9aU0qYnERiKGQkhqea8lkoDA2DtgkyEqMRpl8pEY66Ouo5mTTVPImU\nkzgUGSPRWeTAWeQAICOxGsZ6EgGMAbDX5/m9AMZGH058lBau6egApk9PdzxZIItGomzV1azi1/5C\nJieRGEpQCCUpU0NR2WgxOa+mlNGjyUiMgtcCI2lskc9SSPb0E+RJVA03NVk2VT2JFG4ajMlG4moA\nZ/g8fwaANdGHEx+lhWvIkygYMyZ8Ofgkq5ua4EnctavyDadaTuLAAFAjXVLKbMiTGJ5qDaNthjyJ\n0QhqgVFeqIuoTpDnlWRPP0EbtFTddDgUbhoPeTISVfok3sAYawLw8OBzZwK4DsC/aRyXdkpzEtes\nAebPT3lAGUDWk5hUdVMTPIk7dw73JIbNSaT2F8NpbKxsWJMyNZSgnLBCwX8DwuS8mlJkc0F6eoZf\nxzaT1maNyfLJuf81S+uafoJaYKiGm5osm+RJjIc85SRKGYmc81sYYxMBfAuiPyIA9AC4cbCHYmYp\nz0n8+MfTHU8WyGK4qS2exCAjkXbhhkOeRD3E1ew8L9TUyOXNkWwNJeg6jKv9hcl41WL95o1kTz8t\nLcDWrf6vUXXT4ZAnMR7y5ElU6ZP4VYg+ifNQ7JN4re6B6aY8J5HCTbNpJJrkSSy/4Xi5Cw0NweGA\npBwMh4xEORjzN4YqzZXJeTXl1NcHt3EohWRrKEEtMOLcgDBVPoOKTJHs6SfIk6gabmqqbAJkJMZF\nnoxE1T6JewE8q3ksseL1SeQc2LIFmDAh7RGlTxZbYJjkSQwKUwvyZtACOxwyEuWorxcbEeVKO81V\ncXMszD2A5msodB3qpdp8jhmT7HhMp6UluHAN5SQORWbT3m139/9O4abB5CncVLZP4kjG2NcYY08y\nxlYxxl4vfcQ1SB14hWu29Y9GWxv1SATIkxgnfuGmpbkLQTvyZCQOh5RTOSpVg600Vybn1ZSTxXUv\nL6QVbmqqfNK6lizVchJVwk1NlU2APIlxMXo00NkJvPJK9ovMyXoSbwNwLoD/BvAmgNx0RRo5Ethb\naERH92QKNR1ERlmi6qZy7NwJTJpU+XWvV+K4ccNfS2qu8wQpU3JUmi8qikRGYhSCWmDYnu+qAq1r\nyRLkSaTqpsMhIzEeWlqA978f+OQngddfF/rgrFnA4YcP/emnHyaNrJF4LoCPcM4XxzGYOKmpATgY\nGYklyLTASKoBt8meRNd1h1U49VsESJEfDilTclTKdQrKSTR5R7wUMhLVCWqBEedcmSqf1P81WYKK\nxqmGm5oqm4C6kUjtcIJhDLi5pNTntm3Cq7hypfj5u9+Jnz/5CXDqqemNE5A3EnsBvBHHQJJiTfcU\nMhIHkVGWkgrPNcmTGBS6EtQrkXbhhkNGohyV5ou81GQkRqGxEdi+3f81mit5qHBNsjQ3B+ckUnXT\noYwYIddXllBj3Djg5JPFI2vIVje9BcCn4hhIEjTV9GLF3qlkJA4i21g6CWpqhNcy7/gVrindbQza\n0SRFfjhkJMoRFG5KOYlkJKpSLScxrnBTU+WT1rVkCbrvqoabmiqbgJonUabFEJF9ZD2JBwP4MGPs\nNAAvQHgW98M5v0zXwOKguaYbL++ZjsunpT2SbBAUOlRKoUCFfmSp5kn0chL9oHDT4VRTpqiS2lBk\nC9fYBBmJ6lRrgUFzJQcZiclSzZNIOYlDkTESnUUOAOCh813KTTYIWU/ioRDGYReEwXhYyeNQvUPT\nT0vtPry8dxqmT097JNmBseqeuzh3iE3Fz5NY2k+pmieRjMShkDIlh0pOoi2QkahOWtehqfJJ61qy\nBOWA7tkjjEhZTJVNQBiJsjUiSH8xCylPIuf8nXENJAmaa/eBc4a2trRHkh08j1ZQT7+kb1a1tUB/\nP1Cn1MUzG/gVrimlWk4iKQdDIWVKDqpuWpkxY4DVq8O9l2RrKGm1wDAVWteSJSgiioqtDKepST7c\nlHokmoWsJ3E/jLE2xvIVhNhc241pTZsodLKEMBVOk94ZMqF4jV+4adicRFLkh0PKlByyhWtMzqsp\nhzyJ6lQLN6WcRDmoumny1NQIg7AUztVTakyVTUAtJ5E8iWYhZSQyxmoZY19jjG0HsBnA9MHnv80Y\ny3xBm+YaYSQSRcIoTEnfrIIqvuWFgYFgT2hQTiItssMhI1EOykmsDBmJ6tB1qBeqbpo8fnmJ+/aJ\nXtrEUFSMRPIkmoWsJ/GLAC4G8M8YWrRmCYB2TWOKjZbafWQklpFFIzHvnsRK1b0oJ1EdUk7lkK1u\nanJeTTlkJKqTVripqfJJ61rytLQMNxJVK5sC5somQJ5EQt5IvBjA5ZzzXwAoddgvAzBTdRCMsbMZ\nYysZY68yxr4Y8L4TGGN9jLEPqXyPF25KFMmikdjUJJ8snSX27Kl+wwnKSSTlYDhBYW6UCzUc2cI1\nNkFGojrVjBoqcCZH0HxSbno8NDcP36Clyqb+yBiJbrsLt90lI9EwZI3EqQBW+DzfD0DJwcwYqwHw\nQwBnAZgN4GOMsVkV3vdtAH9S+R4A+PD4R3Fu21OqHzeSLBqJefckVipaI9MnkRbZodTUVPbQknI6\nHNnCNSbn1ZQjYyRWCxu3jbRaYJgqn+RJTB4/T+Lu3cGF5oIwVTYBCjcl5I3EDgDH+Dx/OoCVimM4\nEcBrnPO1nPM+AL8G8H6f910B4DcAOhW/B/Nbl2HWyDdUP24kra3ZMxLz7kms1iMRoJxEnZAyNRzZ\ncFObGDWqshefCIaMGr1Q4Zrk8fMkRgk3NRkKNyVkjcRbAfyAMXbm4PFhjLFPA7gewhuowoEA1pUc\nrx98bj+MsQMAfIBzfhsAqk2qkTC76lTdVA6/HolA+JxEUg7koPkaTiXls1IIm8l5NeXU1lbvDUv4\nUy0nMS6PvqnySUZ38lTyJFJO4nBUNuy7u8mTaBKyfRJvZoy1AbgPIrz0AQDdAK7nnP8shvF5fB+i\naI4HGYqaGDMG2Lgx+D3kSZQjjCexWp9E2okbjle6vLyXFSlTw2ls9N+EoLkS1NUBfX1AfX3l91QK\nb7aZtMJNTSWoummhQH374sBvgzZKuKnJBF3vldi3j/QXk5DOtuCcX8cYuwEif7AGwMuc8z1VPhbE\nBohcR4+DBp8r5XgAvx7syzgewDmMsT7O+f/zO2F7ezumTZsGAGhtbcXcuXP3x427XV2A6xaPB3eB\nbD1et87F8uUAMPR1D9d18be/AY2NyY1v+3agp2fweLCJo1Mynri/f9hxVxec1tbQ7//LX4DRo4e/\n7jjO/uMZMxzs3u0/32vXAk1NCf59OTlubAQeftgdcgNyXRedncnKZx6Om5ocbN0qjrtWdqF1lpDf\n1au9+cvWeJM+HjPGwc6dwLJlQ1/vWllsGtvbCxQKLlw3/fFm5fi551xs3Qp48lM6Xz09Qr5ovsIf\nr17tYtUqoHQ+XZf0kziPt24F9uwRx95879rloKVF/fweWfj7dB4/+qg7uIkx+HoI/XnpUtJf0jxe\nunQpugb15o6ODkSF8ZDbpYyxegBrAZzBOX858jcXz1sL4BX8//buPU6Ssrr/+Od093TP7MzuWuBf\nNwAAIABJREFU7IKAXAIsFy8hQRQ0JqAZJCpoApr8JJrfT12jBmOMmhg13qLGxOgrajTeEhRYLzFE\nTLwkUQOIE6PxGl1iEBBdQEDYBcKwy+7MzkzP8/ujunu7e6q6qvpSVV31fb9e+2L7Mt3PFqd76tTz\nnPPAOcCdwLeAZznn/BrkYGaXAf/snPungMdd4L+pcSDp+mAX2TXXwIc/DJ/4ROf9c9vnAJjfNs8/\n/AN8/evw7ncnM6aLLoKnPhXOP59s/D+LOYaPfxyuvRb+8i+Dn7OwAL/0SzQS9M7j/YxnwMteBmed\n1feIc+nhD4f//E/YsqXzeD360fDpT8Mxx6Q7viz5yEfg+uvhbW/rPFYvehGcey487Wnpji9tZ54J\nH/sYnHBC5/3tx2rPHjjjDPjhD5MfX1bt3Qunn37wmLQfrxe/GJ74RHj609Mb37j59KfhqqvgAx/o\nPJYARx4ZvspH4nvLW+DQQ+GTG+YA73i/973ebOJrXpPu2LKoFYch50HN+H3GPu9C/+tfn8ToJIyZ\n4Zzre/VlKeoTG01loHPri4E55+rAS4ArgeuAy51z15vZRWb2O34/Msz3Lzp1Nx2+oOWm7Vcd/Yrn\nm7Tc1J+asUQXt7tp9xXxvMvi9944qFbT2QIjr/EZ9DldWwNTUc1ITE+rJjGO5tL8qHT+ki9xl5t+\nGHgp8OJhDsI590XgoV33/W3Ac397mO9ddFk8WRr3msSgxjXtJiaCv3j1JetPSWJ0cRvXFE2U7z3t\nv7letRr8vaXPYXxBn9NRNgEqupkZuOMO4LCD9+3dCw9+cGpDyrRmh9Me5dsdlpa8rvmSD3GTxKOA\nZ5jZE4D/Ajquxzjn/Gb+JMOibIGh7qbx7NmzfhkbHFw33s659VeMdSLvT0lidEENMYKOlV9s5tmm\nTdm7ODYOes1ujTKpzmt86jsteX6reLRPYrBmkhhy3btlcVEJd57ETRJPBL7b+PtRXY9pGegYyuJM\nYq+9o8ZBlJlE8E7k/U6sgpYEFl1Q4qOr7uvp5LO3LH7vjYugkv9RLjfNq7gXc2RwfltgaJ/EYFNT\n8c7HtBIqXyLXJAI4587u8ecJoxqkjE6vZY9NaSw3jTqT+PnPw4UXelsjZMXeveE1iRC8V6K+ZP31\nmmFW/U6nuEli3utquilJHL5RHq+8xqcu5iQvaCZRNYn+Jie92cGoFhe1T2KexEoS25nZoY0tKWTM\nlUq9k6wszyRefz1cfTW87nWjHVMce/ZEm0kM2itRy039jfsy5CQFfYY0S+1Rkti/UslrrNJNxys+\nJYnJ85tJ1D6JwZrLTcPMb5tnftu8LnLnTKwk0czKZvZmM7sP2AVsbdz/NjO7aBQDlNHbuDF4Y3fI\n9kzi7t1em//5eW/riSwImknsrl0ImknUibw/JYnRxT35zHtdTTclif0Liq1RLvvOa3wqSUye30zi\nIMtN8xqbTVGTxCYlifkSdybx1cBz8TqcLrfd/z1g25DGJAkLO2HK8kzirl1w3HHeflNvehN885sj\nHVokQVtgdNu40T9JXF72lgFLJ78Tqnrdm9mQTkEXWjRL7VGS2L+gbTB0vOLrNeOvYzkaQTOJqkn0\nFzdJ1HLTfIl7evVc4EXOuY/RuV/i94GHDG1UkqiwDqdJXxmKM5O4axccfri34evll8Nv/Rbcfvto\nxxcmqHFN1JpEUI2dH78kUSdT/lST2JuSxP7Vat6FrG6qSYxPM4nJ8/u9O8hy07zGZpNmEostbpJ4\nLHC9z/2rgK4djKlxn0k84gjv72ecAW99Kzz96bB//+jGFyZouWm3oJpE8ecXFzqZ8qeTz96UJPYv\njeWmeaXupsmbnl4/k7h/v2a/gvSTJOpY5kfcJPEW4BE+9/8KcMPAo5FUzM7CwkLw41muSbz7bjis\nbVPc3/xNOPdceP7zg1u1j9rKiv9y0e7aBb/lpn77JopHM4nRxd2kO+91Nd2UJPYvjQsQeY3PXsdS\nszGj4Zf0DPJ7N6+x2dTPclPFbn7ETRI/ALzHzJ7UuH2ymb0YeCvwvqGOTBKTxZnEKEni2ppXk9ad\nkL35zd7Pv/WtoxlfL3F+2fgte9FeY8GUJEYX9BlyTjWcoCRxENWq/3JTzSTGVyr5X8xU7I2OWecx\nr9ehXE5vPFk3ORltZdfc9jnmts9puWnOxN0n8b3AR4BPA9PAF4B3AO9wzl06/OFJErKWJEb9Urrv\nPtiyZf39pRJ89KPwqU95DW2S1GvZSpSaRF1BDqYkMbqgurEgea+r6bZpk9dgqhfFlr80LkDkOT6V\nJCbPDNyadzV33z5vCWq/8hyboMY1RVeJ+wPOuTeZ2duBU/CSzOucc/tCfkwyLGtJYtSZxPZ6xG4z\nM/CZz8DZZ8OJJ8Kppw53jEGCmtb4mZmB227rvE9X4YIpSYwuaIZCPJVK771hQbEVRFvRjJ5ib7Q2\nbIC1lRrl2pI6m4ZQ45pi6+u6n3Nu0Tn3Hefct5Qgjr+wJDGN7qZRZhJ7JYngbY3x0Y/Cb/wG/PjH\nwxtfL722v4hSk6gv2GBKEuPpThJXV4OXVeW9rsZPuewdkyCKLX9BW2CMUp7j08wrnWin2ButmRmo\nL3nTXYN0NoV8xybETxK17DxfYiWJZrbBzN5sZl8zsx+Z2c72P6MapIxW2BYY4ziT2HTWWfCe98CT\nngT/8z/DGV8vcWcS/Zab6uTAn5LEwehYdQpbcqrj5c9vKfPamhpu9cuvUZtib7Smp6F+wEsS9+7V\nTGIvcZNENd/Ll7gziR8EXgJcC2wHLun6I2Moa8tNhzWT2PSUp8Bll8Gv/Rp8+9uDj6+XXttfRKlJ\n1ExiMCWJ8ZTLnUsqe9W75r2uxk/WvvfGhd/ncNSzB3mOT32vJW9mBuoHvC/DQZeb5jk2IX6SKPkS\ntybxV4HfdM5dPYrBSDqytgVGnJnEk06K9pqPfzxccQVceCFceimMaoVIr+Wm3fz2SVSSGEwnU/F0\nHy8dq05KEvujz+FwBR1PNf8Ynelp2D2k5aZ5FzVJnN82T70Ox75u9GOS5MSdSVwGfjKKgUh6snay\nNOyZxKYzzoB/+Rd4wQvgX/+1//H10mu5aZSaRJ1sBdPJaTzdx2tpKfhY5b2uxk/WvvfGhd8WGKM+\nVnmOT32vJW9mBurL3tXYQZeb5jk2wUsSo5yPgbqz51HcJPH9wEWjGIikJ8rJUpKFyFFnEnfvjpck\nAvzsz8KVV8IrXgGXX97f+HqJO5Oo5abR6WQqnlqt85e7jlUnJYn9SWO5aZ51f05BsTdqMzOw1jaT\nqJrEYJOT0Zeb6vwlf0KTRDO7uPkHOBb4bTP7npltb3+s8biMobAGDklvwF2p9O462BR3JrHphBPg\nmmvgrW+Fi4cctb1mElWTOBglifHEWW6a97oaP0oS+5PG5zDP8anvteS1N64ZdLlpnmMT4tUkao/E\n/IlSk3hy1+0djf8e13W/duUaUxMTvZOyrHaq2r0bDjusv5896igvUTzvPC9B/qM/Gs6Y9u71tt6I\nYnraP0nUyYE/nUzF0901Uceqk5LE/vhtgaFj1T91N03ezAzUdx/sbnrooSkPKMPiJIm6yJ0/oUmi\nc+7sJAYi6Wp2QgzaRy1rnBt8/fuDHgRf+hKccw6cfjqcPYRIj7NPot+G3lrTH0xJYjx+M4lBsZX3\nuho/s7PaAqMffltgLC+rJrFf+l5LnjeTeLC7adQLu37yHJvQliRGOC9ZWtJMYt4kuIhQsixoyWm9\nnuxS0ya/DYbb7dkTfT/CXjZtgvPPh+uuG/y1IN4+iU3tm57rSlwwnUzFE6dxTRFpJrE/QZ9D1ST2\nR99ryZuZgbq6m0YSdSZxbvscz/nkRTp/yZnYp/9mdraZXW1mdzb+XGVmcyMYmyQoaBuMtH5ZhTWv\n6bce0c8JJ8DNNw/ntXrNJPrVLnQvNdKJfDCdTMUTp3FN3utq/ChJ7I9qEodL32vJm54eXnfTPMcm\nxFtuurZSVZKYM7GSRDN7FnA1sAd4W+PPA8DVZvabwx+eJCXohCmtX1Z+dRrthpkkbt0KO3cO57Xi\nziR275Wo5abBdDIVj/ZJ7E1JYn/8tsAY9XLTPFN30+Spu2l0cZLE+kpVy01zJkrjmnavB17vnPuL\ntvveY2avBd4A/MPQRiaJCjphSmv5o98vznbDThKHNZO4d2/0mkRYv1fi0pL3/0LWU5IYT5zGNXmv\nq/GjJLE/aSw3zXN86nstecPsbprn2ITwxobtNJOYP3GXm54EXOFz/xWNx2RMFXkm8cEPhrvu6qwN\n7FecfRJh/TYYWm4aTCdT8cRpXFNEShL7o8/hcKm7afJmZg42rhl0uakc5DSTmDtxk8S7gVN97n9E\n4zEZU1lLEpOcSTSDLVvgvvsGf61eM4l+tQvdSaJO5IPp5DQe7ZPY26ZNShL7kcYWGHmOT32vJW96\nurNxjWoSw0W5iF5frun8JWfiLjf9OPC3ZnYY8B+N+x4PvAX40DAHJsnavDlbSWKUmcTTTx/e+zWX\nnB5yyGCvE7c2p7smUd1Ng+lkKp7WhZbGPqeape6kmcT+BG2Boe6m/Wl9r7UdP8XeaM3MQH1Z3U2j\nmpiAFVehasHrTue3zXPxMtxxR4IDk5HrpyaxDLwHmMA7/TgA/DXwJ8MdmiSpyN1N4WCSOEjiGXal\nLWpNok4O/AXtK6nj5a91oaVx0UE1iZ3Cam2U+PhL42JNnuOzdTzbEhV9r41W+0zi0tJgn/M8x2bT\n1BQsrtWolnoXJy4uap/EvIm13NQ5t+qceyWwBTgNb5npIc65VzvnIpa2ShZlbbnp5GRyy01hOM1r\n+tlIVstNB6OTqWDqbhquVFp/4aHJuXT2iM06zegPl7qbJm9mBtYOHPxFa5biYMZAM0kMo5VQ+RN3\nC4wrzOyPnXOLzrnvN/4smtkfm5k6m46xLHY3TWMmcRB79vTe/iJKTaK+ZOPRyVQw1SSG27ixc7m3\nhEtjC4w8x6eS7uRt2ODVz62tlpmYGOy18hybTVNTsFgPn27t50K5ZFvc66SPBz7vc/8XGo/JmBq3\nmcTFRe+LfliGsVdir6Y1QVSTGF/7sl6dTAXrnqHQLPV6YXWJsl4aW2DkmV/9/coKAycvEqxUAlyJ\n+oEpdTaNYGoKltbCP+CLi/odkzdxk8RZYL/P/fvxlqDKmMpakthrJnHfPq+mYJiGNZPYK0mMUpOo\npKe37lkMHa9g3Z+hXvWuRair8RP0vbe2piVoQVSTOFxBv+sUf6NXX9owcJKY59hsmpzUctOiipsk\n/hh4os/9TwSGtB25pCGL3U2DZhJ37YLDDx/u+23Z4v3719b6f429e3svN/Wj5abxdF91H/Uyt3HW\nfayUUK/X6+KYZsb8+W2Boc9h/8JKK2Q0StUDrOydVWfTCKLUJM5tn+OT135Oy01zJm6S+AHg7Wb2\nB2b2c40/fwi8rfGYjKlxmkkcdj1i01FHwZ139v/zYctNg2oStdw0OjVjiU41ieGy9r03Dvy2wBh1\nUp3n+Oz+nDoXbU86GUy5tsjy/YcMPJOY59hsitq4Zm25qvOXnIm1BYZz7v1mdjjw58A7GncfAN7p\nnHvvsAcnyQnaWDqrM4mjSBKbS06PPrq/nw9rXOPHr7upTk6DKUmMTscqnJLE+NRoZbi6a4dXV73t\nfmS0SrWloSSJRRC1cc3aipLEvInd4Ns590bgQcBjG38Oc869YdgDk2SVy/5LLbPY3XTUSWK/wmYS\no+6TqC/ZYH6Jj5YF+ovTuKYIdTV+lCTGp5rE4dLFnHSUa4ss7zlk4OWmeY7NpsgziSs1LTfNmb6u\nVznn9gPfHvJYJGWVyvquamkuN93v1yKJ7CaJYY1r/KgmMR6dUEWnmsRwShLjm5jw3wJDF2v6o89p\nOsq1JVbuP4SZ49MeSfZFTxI1k5g32ipYWjZt8hKddmkuNx3HmcR+9klsr0nUzFhv3UmilmYFi9Pd\ntAh1NX6UJMZX8jlrGPXxynN86sJXOlSTGF3ULTDWVqqaScwZJYnS4nfClOZMYlo1if3qd5/E9plE\n5/xPwsTjt9RNreL96eQznJLE/nQ3VtHx6p8+p+loJonqbhouykzi/LZ5Tt70CM0k5oxOR6XFbxuM\nIs0kHn/84MtNe80k+tUuTE97+z5KNL0uHkgnv5pE7ZPYSUnicIx6uWme41NJYjrKk8OZScxzbDZ5\n+ySGf8BVLpM/ShKlpegziVNTUK+vr7eJqp+ZxPaGQWp7Hq79hErHqzedfIZTktifUqmz0ZmOV//i\nXMyR4RnWctMi8Lqbhgfl4iJabpozShKlZXYWFhY67+tVxzRKvWYS+0nGojr2WPjJT/r72bDGNb1q\nF5wDVy93NA2S9TqSxHpZ9Yg9+DXECLrKW4S6Gj9KEvtTrXZeTFNNYv90MScdpdoS9aXpgc8l8hyb\nTVEb12gmMX+UJEpL0ExiWltg+M0kNpPWUdWhnXBC/0tOwxrXBJmagrXlmjqDRdCRJK5WdTLVQ5zG\nNUWlJLE/3bG1vKzj1S91N01HeXIRQDOJEUTubrrmrY6S/NB1eGnJ0nLToJnE3btHs9S0aZDmNWEz\niUG1Cxs3Qv3AFOB0chCi/eR0bXVCx6uHOJ1gi1BX40dJYn/8ZhJVk9ifpGdlxVOuelehVZMYzksS\nwz/gKgHJH80kSkuWksSgmcRR1SM2DZIk9juTODMD9aUp3KpmEsN0JIkrShJ78fsMqRNsp2rV2xu2\nm07Ue9MSyeHp/kzqWCajOZOo7qbhoswk/vJlc/zv4r0JjUiSoiRRWrKUJAbNJO7aBYcfPrr3HSRJ\nDDtWQbULXpK4QctNI9BMYnSVijd7GEUR6mqCdDdhAZ2oh0k6Scx7fLbPwCj2klGuDWcmMe+xCdH2\nSXT1MlbxueImY01JorRkaQsMv/3wILsziYMss5iZ8Zabrq2oxi6MahKja5+h0DKgYN17lYJO1MN0\nL5Ec9RYYRaLYS0a5pprEqCYnw7ubrq3UKE302RpeMktJorRkrbtpGstNjzkGbrst/s9FafDTsyZx\naYq11QnNJIbQctN4momiq1d6nsQXoa4mSJZWUIyL7ot4o25Ykff4LJe9mRhIr1lc0ZSGlCTmPTYh\n2nLTtZWqksQcUpIoLVnrbprGTGKl4v17u2cWwoQ1remlfSZRJwe9ablpfM6hWeoelCTG1/39rJnq\nwUxOet9noNhLSrm2iFWWte1UBFEa16wtayYxj5QkSkuWTpbSmkmE/pacRmlaE6UmUScHvSlJjGdi\nAtzqROisaxHqaoJk6XtvXFSrwfvYjkLe47NW81ZGgGIvKeXaUqt5zSDyHpugmcQiU5IoLVk6WUpr\nJhH6TxIHmklcmmJtRctNw3TUJCqpDtWcoVD9ZrAsfe+Ni1rtYE2ic+qaO6haTTOJSStP7mdiw960\nhzEWoiSJH3rKx/jFraclNCJJipJEadm40Ut22qX1C2tiorMxQlNWk8Qoy03D9knUctNwmkmMpzlD\nEXasilBXE2TTJiWJcXU2kJoYedOavMdnreY14gLFXlIqU4uc9rqXDPw6eY9NaCSJIY1rFhdVS5tH\nShKlpVxe3wp+eZlU1uwHXZm+7z7YsmW0733CCaNZbhrk4EyiksQwalwTT/PkU7PUwTSTGF/nxZqK\njtWAvIs5ShKTVt20EP4koVKBeki6sLSkJDGPlCRKB78ZvKwsJVpZ8b6sRj2eUc0k9q5JnMJpZixU\n9wyGjldvzZPPsHrXItTVBFGSGF/7FhhutTrymcS8x6dqEsdX3mMzqsVFb8ZR8kVJonTwO2FKU3vX\nvN274fDDR/+eo2pcE0TdTaPrnMFQnV2YZq2TluYGU5IYn5Z9D5e6m8o46NXFWDOJ+ZSJJNHMzjWz\nG8zsh2b2ap/Hf8vMrm38+aqZ/Xwa4yyC9hOmtBsSVKuw7A6udU2iHhG8RHT37nht3aM0rgndJ1FJ\nYigtN41nctI7TmGNa4pQVxNESWJ8SX8O8x6falwzvvIem01VW+k4H2t3zTXwxjfCaepbkzupJ4lm\nVgLeBzwZOAV4lpk9rOtpO4HHO+ceAfwZ8KFkR1kcHUlivUylkt5YJifhwFrySaIZHHoo3Htv9J/Z\ns2c4M4k6OehNMxjxtGYSlVAHUpIYX/sWGK4++sY1eVered2aQbEn2TRVWl7X4fTmm+HXfx1e8xqo\nXPC7fKI6l87gZGRSTxKBxwA3Oedudc6tAJcDF7Q/wTn3Dedc89f4N4CjEx5jYXQkiSkv56vVYKlt\nA9fdu5NJEsFbcrpzZ/TnR5lJDN0ncVUziWFUkxhPq3FNyLEqcl2NksT42rfASOICRN7jU41rxlfe\nY7NpqnyAxboXo/v2wetfD+ecA097Gnz967DpxOtTHqGMQhaSxKOB29pu307vJPAFwBdGOqICaz9h\nSnumxm8mMYmaRIhflxilcU0QLTeNrnOZm2ZewzRPPt2qupsGUZIYn2b0h0vLTSXrpkoH2L82ySc+\nAaeeCqurcO218JznQCkLmYSMRIqLCeMzs7OB5wFnpT2WvNq8uS1JTHmJWq0GSwcOziTu2gWPelQy\n7x03SYzSuCaodkHLTaNrnpxOoJPTKFr7JK5UqW0Ifl5R6mr8KEmMr1aDe+7x/q59Egc3OQlrDyhJ\nHEd5j82mqdIBfvV//oKH/AP827/BSSelPSJJQhaSxDuAY9tuH9O4r4OZnQpcDJzrnLuv1wtu27aN\n448/HoDNmzdz2mmntT7I8wsLMD9/8HZjqYBue7fvvXee73wHOMObgThwYJ75+XTGMzkJX919L3cs\nLzCHlyTedVcy49m6dY4vfrFxe2GBuc2bez5/7945Nm7s7/3W1qB+4BTWVif40Y/SO97jcPs735nn\n3nthBi9J3LlTx6vX7XvumWfv6h1MHnIKtVr648ni7eVluP9+7/bCDd6+aeXGiXoWxpfF29XqHMvL\n3vHae8tdraQmK+Mbt9u12hxuYcI7nnfOU6tla3x5vb1wwwLz8/OZGU+Wb/+/I67i7uXv8Zg/+F1O\nOsn/+Tqe6d/esWMHCwve77FbbrmFQZmL08JxBMysDNwInAPcCXwLeJZz7vq25xwLfAl4tnPuGyGv\n5wL/TY0DSePAynof/KBX+/fl4+bY99Nj2Xj1R7nmmnTG8qu/Cm+68yLO2HgjzM/zxCfCu94FP59A\nb9sdO+BVr4IrryRS3Jx1FnzkI3DiicGv2f7l2a225R62/Ny32f668zj33H5HnX979sAZZ8BRr53j\nR3/3Et71wv/DhRemParsetWr4J8X/pzVxWme85CX84Y3+D+vV2wWwZFHwp13wtz2OQDuecc88/Pw\noAelOqzM+vu/h29/G7576hz3XvsLPPr+t3PppaN7v7zH55vfDH+3810cdfbnWLt0nksugZNPTntU\n+db8rM9vmx/odfIemy0h50HDOp4yXGaGc67vfQpSn0l0ztXN7CXAlXg1kpc45643s4u8h93FwBuA\nQ4APmJkBK865x6Q36vyanYWbbvL+nnbjmrS6m0J/y037rUn0ONaWa1pmFEL7JMbTrEnU0txw7dcW\nteSvt44GUnXF1qCay8JBsSfjSclhPqWeJAI4574IPLTrvr9t+/sLgRcmPa4i6mhck4GaxPYk8d57\nva0pkjA763XwqtehHPLctTWvPqffmkSAcvUAq/tm1FwkRLXa1lVRiU+oVuOald6NawpxJbyHmRl4\n4IGDt3Wi3lu12rlPYrU62vfLe3yqu+n4yntsSrGV0h6AZEvWups2t8Co1737ymEZ2xAddRT89Kfh\nz/vSl+CRj2SgBK88ucjKA7NKEkNY26IJp73/Qk1ONvdJ1KxrL93Na1ZWYMJ/32ihawsMXawZmLqb\nikgWKUmUDllKEms1OOC8X5z33JN8fVDUJad/8zfwoheFP2++R01jqeYliTo5CNdMFNOOz3HQPPkM\nW5rbKzaLwK/DqfVdxZF/Se9Xmvf4nJz0jiMoSRw3eY9NKTYlidKhcwuMdPfta59JTLIesWnrVti5\ns/dzfvpTr8nNeecN9l6Vyf2s7NVMYhyqSQxXq3kzrkqoe/NLEiVY9z6Jo15umndabioiWaQkUTq0\nnyy5lJeoeTWJ6SaJYTOJl1wCz3tetGWwPWsSJxdZW55SkhhBuQyuXk69ZnYctNck9jpWRa+r6fje\nS7fh91hIujY47/HZvtzUOW1OPk7yHptSbJloXCPZMTPjdeo8ksYv/4E6dg4mCzOJX/968OOrq3DZ\nZfC1rw3+XuXaIqAryFE0T6iSWOY27rxjpe6mYTpmEtfKVPSbsaeO5aa6WDOwWu3gclORcaQtMPJJ\n16ukQ6l08Ep62jM17d1NsziT+IUvwKMe5e2xFkWv2oXypJckaiYxXLNdvBKfcO2Na3rFVtHramZn\nvT04QbWuUSS93DTv8dm+3FTGS95jU4pNSaKsU616J+Fpz9TUaunOJB53HNx6a/DjURvWRFGe3A9o\nJjGKVjMWdewMdbAmUceqlyxt/TMOOrbAUFI9sOaFL7dmapgkIpmhJFHWmZ2F1cXp1E8sJycPziTu\n3g2HH578+zvXuVdj0y23wI9+BE94QvTX61mTWFvEyqta5haBtzSrmvpFjHFwMKFWTWIvWerqPA7a\nt8BI4nOY9/j0ZvyruLqaAI2bvMemFJuSRFlndhZW90+n3t007ZlEgOOPh1uX1r/xhz4EL3zh8BoM\nlCcXscrKcF4s55pLs3QyH67VuEbHqqeOxjWadQ2l7qbDFfVijohIkpQkyjqbN0N9cSb1X1iTkwf3\nSUwrSdy6FW5e6iw6XF6Gj38ctm2L91o9axJri5QmluMPsIBUkxhd1MY1Ra+r0XLTeLRP4nBpq5rx\nlffYlGLT4jZZZ3YWfrJ/JvVfWO0ziXffDYcdlvwYtm6Fm7/RmSR+9rPwuMfBgx40vPcpTypJjKrV\nLl6t4kNNTjYS6pRXBWSdlpvG07EFhpLqgWkmUcaduprmk06xZJ1mTWLaS9S8msQqa85yin6MAAAV\n1klEQVSo12EihQ7hW7fCzsXOJLHfhjVh+ySWKkoSo2jfU0x6a7bWD2vyU/S6Gs0kxtPRBbuumsRB\nHVwWrqXO4ybvsSnFpiRR1mmvSczCTOJ9qxvZsiWdMXQvN73xRm9W88wzh/s+Wm4anbc0S0VQUWhP\nyWhUkxhfM0l0K6pJHJT2MxWRLFKSKOvMzkJ9cTr1X1jN7qa7lrekUo8I65PEiy+Giy6irzblYfsk\nKkmMRnuKRRe1yU/R62o2bdJy034lcbzyHp+Tk42aRM1ij528x6YUm2oSZR1vuelM6nVMzZnENJPE\no4+GO5a94sPFRbjiCvj+94f/PhMz91OZ3jv8F86hWg3qB6awcj3toWSeV5NY1clniKkp7/MNWm4a\nlZk3m5j2Vkl5oL1fRSSLNJMo62SqJtFNsGvlkNSSxHIZpktL7FndwKc+BU9+snd8+tGrdqF2yN2c\n+opX9vfCBVOrweriBs28RtCsScSVKJeDn1f0uprmygDnkunWmQfVqnes3Gpl5MtN8x6flQq4tbJm\nscdQ3mNTik1JoqyzeTPU90+nfkU9CzOJAFsn7+TmpSP7blgTlZXc6F48R2o1bzl0SftKhqpW1eQn\nqg0bYG15UjNjEbVmv5TYDMwMcKZ6WBlbc9vnmNs+l/YwZMiUJMo6XuOamdRPlrJQkwiwdepOPnfv\nL7G8DKef3v/rqHZhOGo1WF3aoCQxglIJcOEFtIrN9oZdSnqiaM4kJrFEsijxqdgbP0WJTSkmJYmy\nTnO5adpXiGs1bwuMXSvpzyT+5W3PHOksokTXnEm0CSWJUThnYJqlDpOV771x0eqcWx/9ctOiUOyJ\nSJYoSZR1mo1rXMpXNScnm8tN06tJBDhh8k4MxzOfOdjrqHZhOLwkcYP2lYxqrRQ666rYbHZ1nlFN\nYkRe59xkOnIWIT6tskJ9aUqxN2aKEJtSXEoSZZ3Z2WZNYvrdTQ+4CXavbE41SXz87LW87+T3MD2d\n3hjkIG+5qWoSo7KJFUzHKlRW9ocdF81617TLEvKiVFmhvjStYykimaEkUdaZmfG2GEh76Yu33HSC\n3ctbOOyw9MZxZO1/efYRVw38OqpdGI7mTKKWm0ZTqiyHdoJVbGq5aVytzrlrJSoj3kyrCPFZqqyw\nurhBsTdmihCbUlzaJ1HWabaDT/sKsRk4jANuItUZTckWbwuMaSa1r2QkpYkVbRcSwews1G9XkhhV\nsyZRhsMmVqgvTut3nYyl+W3zaQ9BRkAzieKrNLFMfX/6S18W6zU2lfelO4ghUe3CcNRqUF9STWJU\npcqKahIjaHZ1TrsWe1wkmSQWIT5LlWVWF9P/nSvxFCE2pbiUJIqv8tQ+VhdnRr6MKEy1tMIR1fvS\nHYRkSnMmsaTlppHYxLJqEiM4uNxUNXZRVKvgVqpe91wZWKmyQl3LTUUkQ5Qkiq/Khgew8mraw6BW\nWuGIiXwkiapdGI5WTaISn0hKlZXQhFqx2exuquWmUdVqUD8wSSmB3xNFiM/SxDKralwzdooQm1Jc\nShLFV2VqXybqmCZLy5pJlA7eclN1N42qVFnW0twImt1Ntdw0muaybzWQGg6vJlEziSKSHUoSxVd5\nal8mTsJrtsIR1f9NexhDodqF4WieRGXhIsY4iNK4RrF5cH9YzSRGU63CakK1wUWIT2+5qWYSx00R\nYlOKS91NxVdlal8mlvNNlpZzs9xUhqN5EpWF+BwHpYnlTFzwybpmTaKV6zpRj6C57LtUSb8sIQ/U\nuEbG2dz2OUBdTvNGM4niq7LhgUzM1NRytNxUtQvD0ZpJVOITiVVWQpcEKjYbNYn7p1nTctNIWstN\nE/gcFiE+SxMrShLHUBFiU4pLSaL4qmx4IBMn4apJlG4Hl5umH5/jIMoWGNKYSVyaxmm5aSTVamMr\nmgxcTMwDq6xQX1JNoohkh5abiq+s1CS+bevFPGLmx2kPYyhUuzAcB2cSdXIahbfcVDWJYTZsgLXl\nmmoSI6rVmjWJo/89UYT4LE0sgysp9sZMEWJTiktJoviqTO3DMnCF+NGbbkx7CJIxk5Pef1WTGI1V\nwhvXCFhju7+1Fe2TGMXB5aaqSRyGZrKt2BORrNByU/FV2bBPy/mGTLULw6HlpvGUJpZVkxhRaWJZ\nHSYjOti4ZvQXIIoQn80LOYq98VKE2JTi0kyi+KpM76FcXUp7GCLrqHFNPKpJjK4ytY+lew/XiXoE\n1arXDXZi5v60h5ILpplEGWPqappPShLF18bjb+Tk574TODPtoeSGaheGo7UFhpZQRrL5YTtCZ10V\nm57y1D5W983qRD0Cb7npVCLLTYsQn1puOp6KEJtSXEoSxZeVHLXN+djEXvKlVAIrr2p2LKLND7s2\n7SGMjcrUA4BO1KNo1iSqgdRwNC/kKPZEJCtUkyiSENUuDI9pCeVQKTY9lQ37oFSnXE57JNnXXG6a\nRG1wEeJTNYnjqQixKcWlJFFExk6psqzGNTJ03tY/mhmLorXctKzupsPQjDsliSKSFUoSRRKi2oXh\nKU2sYDqZHxrFpqcytY+StnSIpFYDXDmR7VWKEJ9WWQFbo6IioLFShNiU4lKSKCJjRx07ZRTKU/u0\n/2ZErQZSOl5DUZrwvtOa+3WKjJO57XPMbZ9LexgyZEoSRRKi2oXh8TaI18npsCg2PZWpfYnMjOVB\nter9N4mLNUWIz1JlRQn3GCpCbEpxKUkUkbFTmljWTKIMXWXDPsVVRNqvdLhsYlkXKEQkU5QkiiRE\ntQvD85DnvpPqlrvTHkZuKDY95akHlPREdHC/0tEfryLEZ6miC1/jqAixKcWlEmkRGTubTrw+7SFI\nDlWm9iWS9ORBkstNi6BZkygikhWaSRRJiGoXJKsUm57Khge05C+iJJebFiE+S5UVXaAYQ0WITSku\nzSSKiIgAG466lYf+9tuBj6c9lMxTd9Ph8uqsdYFCxtP8tvm0hyAjoJlEkYSodkGySrHpMYMND749\n7WGMhSRnEosQn7VDd/HQ57897WFITEWITSkuJYkiIiISS7MmUTOJw2EGMz+zM+1hiIi0KEkUSYhq\nFySrFJsSV7kMlOqqSZRCU2xKnilJFBERkdhKlWVKarYiIpJLShJFEqLaBckqxab0o1RZxcqqSZTi\nUmxKnilJFBERkdissqKZRBFhbvscc9vn0h6GDJmSRJGEqHZBskqxKf3wtm1QTaIUl2JT8kxJooiI\niMRW0kyiiEhuKUkUSYhqFySrFJvSj1JlRTWJUmiKTcmzTCSJZnaumd1gZj80s1cHPOevzewmM9th\nZqclPUYRERE56KEv+Auqm+9NexgiIjICqSeJZlYC3gc8GTgFeJaZPazrOecBJzrnTgYuAv4m8YGK\nDEi1C5JVik3px8bjb8Js9O+j+JSsUmxKnlXSHgDwGOAm59ytAGZ2OXABcEPbcy4APgrgnPummc2a\n2RHOuV2Jj1ZERERERACY3zaf9hBkBFKfSQSOBm5ru317475ez7nD5zkimabaBckqxaZkmeJTskqx\nKXmWhSRRREREREREMiILy03vAI5tu31M477u5/xMyHNatm3bxvHHHw/A5s2bOe2001pXe+YXFmB+\n/uDtxnpy3e683ZT6eBYWvNtpjmdhgbnNmwd+vfZjm9njPSa3m7IynizfXrhhgc0P6x2/zfuyMN40\nby/c4H3fNKU9nqzfTup4Ne9L+9+bxPGcn5/PzHjyfnsYx3vHjh28/OUvz8S/Z+S3df6c+ds7duxg\noXHefMsttzAoc84N/CIDDcCsDNwInAPcCXwLeJZz7vq25zwF+D3n3FPN7LHAu51zjw14PRf4b2oc\nSNp+8Yi/ue1zAOmvM8/C/7MhjaH9l9G6t8jK8R4TOl7RRTlWvWKzSBRX8SR1vIoQn4q9ZA3reBch\nNoFsnItJbGaGc67v9mKpzyQ65+pm9hLgSrzlr5c45643s4u8h93FzrnPm9lTzOxHwD7geWmOWaQf\nhfhFImNJsSlZpviUrFJsSp6lniQCOOe+CDy0676/7br9kkQHJSIiIiIiPWkmPJ9KaQ9ApCjmtUxD\nMkqxKVmm+JSsUmxKnilJFBERERERkRYliSIJUe2CZJViU7JM8SlZpdiUPFOSKCIiIiIiIi1KEkUS\notoFySrFpmSZ4lOySrEpeZaJ7qYiIiIiIjJ+1NU0nzSTKJIQ1S5IVik2JcsUn5JVik3JMyWJIiIi\nIiIi0qIkUSQhql2QrFJsSpYpPiWrFJuSZ0oSRUREREREpEVJokhCVLsgWaXYlCxTfEpWKTYlz5Qk\nioiIiIhIX+a2zzG3fS7tYciQKUkUSYhqFySrFJuSZYpPySrFpuSZkkQRERERERFpUZIokhDVLkhW\nKTYlyxSfklWKTckzJYkiIiIiIiLSoiRRJCGqXZCsUmxKlik+JasUm5JnlbQHICIiIiIi42l+23za\nQ5AR0EyiSEJUuyBZpdiULFN8SlYpNiXPlCSKiIiIiIhIi5JEkYSodkGySrEpWab4lKxSbEqeKUkU\nERERERGRFiWJIglR7YJklWJTskzxKVml2JQ8U5IoIiIiIiJ9mds+x9z2ubSHIUOmJFEkIapdkKxS\nbEqWKT4lqxSbkmdKEkUSsmPHjrSHIOJLsSlZpviUrFJsSp4pSRRJyMLCQtpDEPGl2JQsU3xKVik2\nJc+UJIqIiIiIiEiLkkSRhNxyyy1pD0HEl2JTskzxKVml2JQ8M+dc2mMYKjPL1z9IREREREQkJuec\n9fuzuUsSRUREREREpH9abioiIiIiIiItShJFRERERESkJTdJopmda2Y3mNkPzezVaY9HisvMjjGz\na8zsOjP7vpm9tHH/FjO70sxuNLN/M7PZtMcqxWRmJTP7rpl9rnFbsSmZYGazZnaFmV3f+A79BcWn\nZIGZvaYRk/9tZn9nZlXFpqTFzC4xs11m9t9t9wXGYyN+b2p8tz4pynvkIkk0sxLwPuDJwCnAs8zs\nYemOSgpsFfhD59wpwC8Cv9eIxz8GrnbOPRS4BnhNimOUYnsZ8IO224pNyYr3AJ93zj0ceARwA4pP\nSZmZHQe8EHikc+5UoAI8C8WmpOcyvLynnW88mtnPAhcCDwfOAz5gZqENbXKRJAKPAW5yzt3qnFsB\nLgcuSHlMUlDOubucczsaf38AuB44Bi8mP9J42keAp6UzQikyMzsGeArw4ba7FZuSOjPbBDzOOXcZ\ngHNu1Tl3P4pPSd8eYBmYNrMKMAXcgWJTUuKc+ypwX9fdQfF4PnB54zv1FuAmvNypp7wkiUcDt7Xd\nvr1xn0iqzOx44DTgG8ARzrld4CWSwOHpjUwK7K+AVwLtra0Vm5IFW4F7zOyyxnLoi81sA4pPSZlz\n7j7gncBP8JLD+51zV6PYlGw5PCAeu/OkO4iQJ+UlSRTJHDObAT4FvKwxo9i934z2n5FEmdlTgV2N\nme5eS00Um5KGCvAo4P3OuUcB+/CWT+m7U1JlZicAfwAcBxyFN6P4f1FsSrYNFI95SRLvAI5tu31M\n4z6RVDSWo3wK+Jhz7rONu3eZ2RGNxx8M7E5rfFJYZwLnm9lO4O+BJ5jZx4C7FJuSAbcDtznnvtO4\n/Y94SaO+OyVtZwBfc879r3OuDnwa+CUUm5ItQfF4B/Azbc+LlCflJUn8NnCSmR1nZlXgmcDnUh6T\nFNulwA+cc+9pu+9zwLbG358LfLb7h0RGyTn3Wufcsc65E/C+J69xzj0b+GcUm5KyxjKp28zsIY27\nzgGuQ9+dkr4bgcea2WSj4cc5eM2/FJuSJqNzVVBQPH4OeGajI+9W4CTgW6Ev7lw+ZsbN7Fy8rmgl\n4BLn3NtSHpIUlJmdCXwF+D7eVL8DXov3gfwk3tWcW4ELnXMLaY1Tis3Mfhl4hXPufDM7BMWmZICZ\nPQKvqdIEsBN4HlBG8SkpM7NX4p2A14HvAS8ANqLYlBSY2SeAOeBQYBfwRuAzwBX4xKOZvQZ4PrCC\nVwZ1Zeh75CVJFBERERERkcHlZbmpiIiIiIiIDIGSRBEREREREWlRkigiIiIiIiItShJFRERERESk\nRUmiiIiIiIiItChJFBERERERkRYliSIiIiIiItKiJFFERCSEmR1tZmtm9vi0xyIiIjJqShJFRETC\nGeDSHoSIiEgSlCSKiMjYM7OzzOyrZran8ed7ZvbExmOHm9l2M9vdeOw/zOxxbT/7y41Zwl8xs383\ns31mdp2Zndv2Fj9p/He+8dydbT//xMZ77zez283sUjM7pO3xy8zsKjN7oZndYmb3m9lnzeywrn/D\nr5jZVxrvv2BmXzazrW2PP7Px71o0s5vN7J1mtiHKMRAREYlDSaKIiIw1MysDnwW+DpwGPBJ4E7Df\nzCaBLwMbgCc3Hv88cKWZPbTrpf4S+DPgVOCbwOVmNtt47FF4s4lPBx4MPLrx3k8APgN8Avg54ALg\nOOCful770cAc8BTgScDPA+9o+zf8CvBF4NvAYxvP3w5UGo9vA97fGOPDgGcD5wAfDDsGoQdQRESk\nizmn1TMiIjK+zGwzcC9wtnPuK12PbQP+FDjeObfWdv+XgGudc39oZr+Ml0g+3Tn32cbjhwN3AU92\nzl1lZkcDtwFz7e9hZl8Gvu6ce23bfccCtwCnOef+28wuA84DjnHOrTae8yrgZc65oxu3vwLc55y7\nIODfeDPwF865i9vuexzw78AWvATW9xiIiIjEpZlEEREZa865BeASvNnBz5vZq83sIY2HzwCOBO43\ns73NP8BZwMntLwNc2/aau4E6cETI2z8aeHnXa1/XeL3217+hmSA2/LTrtU8HrvJ7AzN7EN7s5Lu6\n3ucLjfc5KeQYiIiIxFJJewAiIiKDcs79jpm9G28p55OAPzWz38e7GPoD4Gl4s23tupdiLvu8dNjF\n1BLwduBjPo/d1eO1nc94er0HwEuBeZ/HbwffY/AWM/s959yHIr6PiIgIoCRRRERywjn3A7yE8N1m\n9kHghcAHgOcAe51z9wzw8s0kr9x1/3eAU5xzOxnMf+Eldu/rfsA5t9vMbgMe5py7tNeL+ByD3wGU\nJIqISCxabioiImPNzE40s7eZ2ZlmdqyZ/SLwOLxln38H3Az8a6ML6XFm9hgz+2MzO7/9ZULe5h7g\nAeBJZnZEow4S4E+ACxqdRh9hZieY2blm9mEzq8X4Z7wFOM/M/srMft7MHmJmzzWz5pLV1wEvNbPX\nmtkpjcefZmZ/E+EYiIiIxKIkUURExt0+vPq/vwduBK4Avgr8vnNuGXg83ozfpY3H/xGvlvDWttfw\n6+LWus95Xd5eDFyI18Dmu43754En4HUr/QpeXeM7gT3AStR/gHPuKrzOp48BvoHXXfU5zddwzn28\n8d5PbTz2LbwE9fawYxB1DCIiIk3qbioiIiIiIiItmkkUERERERGRFiWJIiIiIiIi0qIkUURERERE\nRFqUJIqIiIiIiEiLkkQRERERERFpUZIoIiIiIiIiLUoSRUREREREpEVJooiIiIiIiLQoSRQRERER\nEZGW/w+vLAhZWs7NlAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f7b37f3c438>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t\t\t\t\t\t   Pk 0.094737\n",
      "\t\t\t\t\t\t   WD 0.147368\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "tp = list(filter(lambda b: b in doc.boundaries, plot_indices))\n",
    "fp = list(filter(lambda b: b not in doc.boundaries, plot_indices))\n",
    "fn = list(filter(lambda b: b not in plot_indices, doc.boundaries))\n",
    "\n",
    "plt.figure(figsize=(15, 7))\n",
    "plt.vlines(tp, -0.1, 1.1, 'g', linewidth=1.5)\n",
    "plt.vlines(fp, -0.1, 1.1, 'r', linewidth=1.5)\n",
    "plt.vlines(fn, -0.1, 1.1, 'g', linewidth=1.5, linestyles='dashed')\n",
    "plt.plot(range(0, len(engine.tt.cosine_similarities)), engine.tt.cosine_similarities, linewidth=0.9)\n",
    "plt.xlabel(\"sentences\", fontsize='x-large')\n",
    "plt.ylabel(\"coherence score ($c_p$)\", fontsize='x-large')\n",
    "plt.ylim(ymin = -0.1, ymax = 1.1)\n",
    "plt.grid()\n",
    "plt.show()\n",
    "\n",
    "ref_doc = doc_to_seg_string(len(doc.sentences), doc.boundaries)\n",
    "estimated_doc = doc_to_seg_string(len(doc.sentences), plot_indices)\n",
    "k = int(round(len(ref_doc) / (ref_doc.count('1') * 2.)))\n",
    "\n",
    "print('\\t\\t\\t\\t\\t\\t   Pk %f' % pk(ref_doc, estimated_doc))\n",
    "print('\\t\\t\\t\\t\\t\\t   WD %f' % windowdiff(ref_doc, estimated_doc, k))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}