ProLigNET.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import MDAnalysis as md # distances in Angstroem\n",
    "from MDAnalysis.lib.pkdtree import PeriodicKDTree\n",
    "from MDAnalysis.lib.distances import distance_array\n",
    "from MDAnalysis.analysis.dihedrals import Ramachandran\n",
    "from MDAnalysis.analysis.hbonds.hbond_analysis import HydrogenBondAnalysis as HBA\n",
    "from sklearn.cluster import KMeans\n",
    "import mdtraj # necessary for dssp\n",
    "import networkx as nx\n",
    "import numpy as np\n",
    "import h5py as h5\n",
    "import warnings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransitionNetworks:\n",
    "    topology = None\n",
    "    trajectory = None\n",
    "    state = []\n",
    "    nLigandChains = 0  \n",
    "    nProteinChains = 0\n",
    "\n",
    "    \n",
    "    \n",
    "    \"\"\"The descriptors and corresponding cutoffs to use for constructing the transition matrix.\"\"\"\n",
    "    descriptors = {}\n",
    "    \n",
    "    def __init__(self, top=topology, traj=trajectory, nLigandChains=nLigandChains,\\\n",
    "                 nProteinChains=nProteinChains,desc=descriptors, state=state,\\\n",
    "                 h5File='transitionNetwork.hdf5'):\n",
    "        \n",
    "        self.top = top\n",
    "        self.traj = traj\n",
    "        self.universe = md.Universe(top, traj)\n",
    "        \n",
    "        self.nLigandChains = nLigandChains\n",
    "        self.nAtomsPerLigandChain = int(len(self.universe.select_atoms(\"resname LIG\"))/nLigandChains)\n",
    "        self.nResiduesPerLigandChain = int(len(self.universe.select_atoms(\"resname LIG\").residues)/nLigandChains)\n",
    "\n",
    "        self.nProteinChains = nProteinChains\n",
    "        self.nAtomsPerProteinChain = int(len(self.universe.select_atoms(\"protein\"))/nProteinChains)\n",
    "        self.nResiduesProteinPerChain = int(len(self.universe.select_atoms(\"protein\").residues)/nProteinChains)\n",
    "\n",
    "        self.nFrames = self.universe.trajectory.n_frames\n",
    "        self.state = state\n",
    "        self.h5File = h5File\n",
    "        \n",
    "        \"\"\"Sort the descriptors dictionary by cutoffs in decreasing order.\"\"\"\n",
    "        self.descriptors = {k: v for k, v in sorted(desc.items(), key=lambda item: -item[1])}\n",
    "\n",
    "        \"\"\"Generate array with cutoff values in decreasing order.\"\"\"\n",
    "        self.cutoffs = np.unique(list(self.descriptors.values()))[::-1]\n",
    "        \n",
    "        \"\"\"Generate array to connect atom indices with residue names.\"\"\"\n",
    "        self.resnames = self.universe.atoms.resnames\n",
    "        \n",
    "        \"\"\"Generate array to connect atom indices with residue indices.\"\"\"\n",
    "        self.resindices = self.universe.atoms.resindices    \n",
    "    \n",
    "    def _intermolecularContactPairs(self):\n",
    "        \"\"\"The largest cutoff value 'cutoff0' defines the search distance for the k-d tree.\"\"\"\n",
    "        cutoff0 = self.cutoffs[0]\n",
    "        \n",
    "        \"\"\"All other cutoffs are stored in the array cutoffs1\"\"\"\n",
    "        cutoffs1 = self.cutoffs[1:]\n",
    "\n",
    "        with h5.File(self.h5File, 'a') as f:\n",
    "            \"\"\"Create/Check if group 'contactPairs' is present in the file. Structure\n",
    "            of this group is: (nFrames, nCutoffs, contactPairs[cutoff]).\"\"\"\n",
    "            group = f.require_group(name='contactPairs')\n",
    "            \n",
    "            for frameIdx, frame in enumerate(self.universe.trajectory):\n",
    "                frameIdx = str(frameIdx)\n",
    "                \n",
    "                \"\"\"Extract the unit cell information 'box' and the concatenated positions\n",
    "                'pos Concatenated' for every frame.\"\"\"\n",
    "                box = frame.dimensions\n",
    "                posConcatenated = frame.positions\n",
    "                \n",
    "                \"\"\"Initialize the periodic k-d tree 'tree' with the unit cell information.\n",
    "                From MD analysis online documentation:\n",
    "                Number of entries in leafs of the KDTree. If you suffer poor performance \n",
    "                you can play around with this number. Increasing the leafsize will speed\n",
    "                up the construction of the KDTree but slow down the search.\"\"\"\n",
    "                tree = PeriodicKDTree(box=box, leafsize=5)\n",
    "                \n",
    "                \"\"\"Reshape the positions array from shape (nAtomsPerChain*nChains, 3) to\n",
    "                (nChains, nAtomsPerChain, 3) 'pos' seperately for protein and ligand.\"\"\"\n",
    "                \n",
    "                posProtein = np.split(posConcatenated[:self.nProteinChains*self.nAtomsPerProteinChain], self.nProteinChains)\n",
    "                posLigand = np.split(posConcatenated[self.nProteinChains*self.nAtomsPerProteinChain:-1], self.nLigandChains)\n",
    "\n",
    "                \"\"\"Build the k-d tree using the coordinates of one chain and then search\n",
    "                all intermolecular contacts using the coordinates of the remaining chains.\"\"\"\n",
    "                contactPairs = list([] for d in self.cutoffs)\n",
    "\n",
    "                for excludeChain in range(self.nProteinChains):\n",
    "                    \n",
    "                    \"\"\"Extract the coordinates of one protein chain.\"\"\"\n",
    "                    excludePos = posProtein[excludeChain]\n",
    "\n",
    "                    \"\"\"Build the k-d tree using these coordinates. From MD analysis online\n",
    "                    documentation: 'cutoff': Specified cutoff distance to create duplicate images.\n",
    "                    Typically equivalent to the desired search radius or the maximum of the \n",
    "                    desired cutoff radius.\"\"\"\n",
    "                    tree.set_coords(excludePos, cutoff=cutoff0)\n",
    "\n",
    "                    \"\"\"Extract all intermolecular contact pairs within the cutoff0 and correct atom\n",
    "                    indicies.\"\"\"\n",
    "                    for ligandChainIdx, includePos in enumerate(posLigand):\n",
    "                        for pair in tree.search_tree(includePos, cutoff0):                                        \n",
    "                                                        \n",
    "                            atomIdxLigand = pair[0]                            \n",
    "                            atomIdxProtein = pair[1]\n",
    "    \n",
    "                            \"\"\"Compute the exact distance of this intermolecular distance pair using pbc.\"\"\"\n",
    "                            distance = distance_array(posLigand[ligandChainIdx][atomIdxLigand],\n",
    "                                                      posProtein[excludeChain][atomIdxProtein],\n",
    "                                                      box=box)[0][0]\n",
    "\n",
    "                            \"\"\"Compare the calculated distance with the given cutoffs, stop if cutoff is\n",
    "                            greater than the given value. 'depth' allows to return the 'stop cutoff' value\n",
    "                            by self.cutoffs[depth].\"\"\"\n",
    "                            depth = 0\n",
    "                            for cValue in cutoffs1:\n",
    "                                if (distance < cValue):\n",
    "                                    depth += 1\n",
    "                                else:\n",
    "                                    break\n",
    "                                    \n",
    "                            globalAtomIdxLigand = pair[0] + self.nAtomsPerLigandChain*ligandChainIdx + self.nAtomsPerProteinChain*self.nProteinChains\n",
    "                            globalAtomIdxProtein = pair[1] + self.nAtomsPerProteinChain*excludeChain\n",
    "                                                       \n",
    "                            \"\"\"Append the contact pair to the last undercut cutoff value array.\"\"\"\n",
    "                            contactPairs[depth].append(sorted([globalAtomIdxProtein, globalAtomIdxLigand]))\n",
    "                            \n",
    "\n",
    "                    \"\"\"Store the intermolecular contact pairs array in the hdf5 file.\"\"\"\n",
    "                    subGroup = group.require_group(name=frameIdx)\n",
    "                    for depth, data in enumerate(contactPairs):\n",
    "                        subGroup.create_dataset(name=str(self.cutoffs[depth]), data=data)\n",
    "    \n",
    "    \n",
    "    def _residuesWithAttribute(self, descriptorName=None, attribute=None):\n",
    "        \"\"\"The user can define an attribute group by augmentation or modification of\n",
    "        the 'attributes' dictionary.\"\"\"\n",
    "        attributes = {'hydrophobic': ['GLY', 'ALA', 'VAL', 'LEU', 'ILE', 'PRO', 'PHE', 'MET', 'TRP'],\n",
    "                      'polar': ['SER', 'THR', 'CYS', 'ASN', 'GLN', 'TYR'],\n",
    "                      'charged':['ARG','HIS', 'LYS','ASP', 'GLU']}\n",
    "        residuesWithAttribute = attributes[attribute]\n",
    "    \n",
    "    \n",
    "        \"\"\"Get the cutoff value for the descriptor function.\"\"\"\n",
    "        cutoff = self.descriptors[descriptorName]\n",
    "        \n",
    "        \"\"\"Open the hdf5 file and create the group 'descriptorName' to store all information\n",
    "        for this descriptor function. The structure of this group is (nFrames, nChains, any).\"\"\"\n",
    "        with h5.File(self.h5File, 'a') as f:\n",
    "            group = f.require_group(name=descriptorName+str(cutoff))\n",
    "\n",
    "            \"\"\"Extract the contact pairs for every frame for the descriptor.\"\"\"\n",
    "            for frameIdx in f['contactPairs']:\n",
    "                frameIdx = str(frameIdx)\n",
    "                contactPairs = list(f['contactPairs'][frameIdx][str(cutoff)])\n",
    "                \n",
    "\n",
    "                \"\"\"Array to be filled with information to identify which residues are in contact \n",
    "                within the cutoff value distance. Set is chosen because it has the helpful add\n",
    "                feature, means that if the chain index is already included it is not appended\n",
    "                multiple times, which would be the case when appending to a list.\"\"\"\n",
    "                residuesInContact = []\n",
    "\n",
    "                \"\"\"Get the residue names of the atom indices and see if they belong to the\n",
    "                chosen attribute.\"\"\"\n",
    "                for atomIdxChainA, atomIdxChainB in contactPairs:\n",
    "                    residueNameA = self.resnames[atomIdxChainA]\n",
    "                    residueNameB = self.resnames[atomIdxChainB]\n",
    "\n",
    "                    if (residueNameA in residuesWithAttribute):\n",
    "                        if (residueNameB in residuesWithAttribute):\n",
    "                            \"\"\"Build the 'residuePair' and check if contact between both residues\n",
    "                            has already been recognized. If not, add it to the array 'residuesInContact'\n",
    "                            and increase the counter 'resiudesInContactCounter'.\"\"\"\n",
    "                            residueIdxA=self.resindices[atomIdxChainA]\n",
    "                            residueIdxB=self.resindices[atomIdxChainB]\n",
    "                            residuePair = [residueIdxA, residueIdxB]\n",
    "                            if residuePair not in residuesInContact:\n",
    "                                residuesInContact.append(residuePair)\n",
    "                      \n",
    "                \"\"\"Export the data in the hdf5 file.\"\"\"\n",
    "                group.create_dataset(name=frameIdx, data=np.array([len(residuesInContact)]))\n",
    "                \n",
    "    \n",
    "    def _hydrophobicContacts(self):\n",
    "        self._residuesWithAttribute(descriptorName='hydrophobicContacts', attribute='hydrophobic')\n",
    "    \n",
    "    def _polarContacts(self):\n",
    "        self._residuesWithAttribute(descriptorName='polarContacts', attribute='polar')\n",
    "    \n",
    "    def _chargedContacts(self):\n",
    "        self._residuesWithAttribute(descriptorName='chargedContacts', attribute='charged')\n",
    "                        \n",
    "    def _hbondContacts(self):        \n",
    "        \n",
    "        hbonds = HBA(universe=self.universe)\n",
    "        hbonds.run()\n",
    "        \n",
    "        names = [atom.name for atom in self.universe.atoms]\n",
    "        protein = [[], []]\n",
    "        ligand = [[], []]\n",
    "\n",
    "        for idx, name in enumerate(names):\n",
    "            if name in hbonds.donors:\n",
    "                if idx < self.nProteinChains*self.nAtomsPerProteinChain:\n",
    "                    protein[0].append(idx)\n",
    "                else:\n",
    "                    ligand[0].append(idx)\n",
    "\n",
    "            elif name in hbonds.acceptors:\n",
    "                if idx < self.nProteinChains*self.nAtomsPerProteinChain:\n",
    "                    protein[1].append(idx)\n",
    "                else:\n",
    "                    ligand[1].append(idx)\n",
    "\n",
    "        hbondAcceptorsProtein = np.array(protein[1])\n",
    "        hbondDonorsProtein = np.array(protein[0])\n",
    "        hbondAcceptorsLigand = np.array(ligand[1])\n",
    "        hbondDonorsLigand = np.array(ligand[0])\n",
    "\n",
    "        possibleIntermolecularHbondPairs = []\n",
    "        for proteinDonor in hbondDonorsProtein:\n",
    "            for ligandAcceptor in hbondAcceptorsLigand:\n",
    "                possibleIntermolecularHbondPairs.append([proteinDonor, ligandAcceptor])\n",
    "        \n",
    "        for proteinAcceptor in hbondAcceptorsProtein:\n",
    "            for ligandDonor in hbondDonorsLigand:\n",
    "                possibleIntermolecularHbondPairs.append([ligandDonor, proteinAcceptor])\n",
    "\n",
    "        nDifferentHbondPairs = len(possibleIntermolecularHbondPairs)        \n",
    "        \n",
    "        descriptorName='hbondContacts'\n",
    "        \n",
    "        \"\"\"Get the cutoff value for the descriptor function HbondContacts.\"\"\"\n",
    "        cutoff = self.descriptors[descriptorName]\n",
    "\n",
    "        \"\"\"Open the hdf5 file and create the group 'desc' to store all information\n",
    "        for this descriptor function. The structure of this group is (nFrames, nChains).\"\"\"\n",
    "        with h5.File(self.h5File, 'a') as f:\n",
    "            group = f.require_group(name=descriptorName+str(cutoff))\n",
    "\n",
    "            \"\"\"Extract the contact pairs for every frame for the descriptor.\"\"\"\n",
    "            for frameIdx in range(self.nFrames):\n",
    "                hbondContacts = 0\n",
    "                frameIdx = str(frameIdx)\n",
    "                contactPairs = list(f['contactPairs'][frameIdx][str(cutoff)])\n",
    "        \n",
    "                for contactPair in contactPairs:\n",
    "                    for pair in possibleIntermolecularHbondPairs:\n",
    "                        if np.allclose(pair, np.sort(list(contactPair))):\n",
    "                            hbondContacts += 1\n",
    "                            #print(frameIdx+1, pair)\n",
    "\n",
    "                \"\"\"Export the data in the hdf5 file.\"\"\"\n",
    "                group.create_dataset(name=frameIdx, data=np.array([hbondContacts]))\n",
    "                \n",
    "    def _aromaticStacking(self):\n",
    "        aromatics = {'TYR': ['CG', 'CD1', 'CD2', 'CE1', 'CE2', 'CZ'],\n",
    "             'PHE': ['CG', 'CD1', 'CD2', 'CE1', 'CE2', 'CZ'],\n",
    "             'TRP': ['CG', 'CD1', 'CD2', 'CE1', 'CE2', 'CE3', 'CZ2', 'CZ3', 'NE1']\n",
    "            }\n",
    "        \n",
    "        weights_dict = {'TYR': np.array([12.011, 12.011, 12.011, 12.011, 12.011, 12.011]),\n",
    "                   'PHE': np.array([12.011, 12.011, 12.011, 12.011, 12.011, 12.011]),\n",
    "                   'TRP': np.array([12.011, 12.011, 12.011, 12.011, 12.011, 12.011, \n",
    "                                    12.011, 12.011, 14.007])}\n",
    "\n",
    "        ligand_weights = np.array([12.011, 12.011, 12.011, 12.011,\n",
    "                                   12.011, 12.011, 12.011, 12.011,\n",
    "                                   14.007, 12.011]) \n",
    "\n",
    "        \n",
    "        proteinAromaticCindex = []\n",
    "        ring = []\n",
    "        ks = []\n",
    "\n",
    "        count = 0\n",
    "        for residueName in aromatics.keys():\n",
    "            atomNames = aromatics[residueName]\n",
    "            for atom in self.universe.atoms: \n",
    "                if atom.resname == residueName:\n",
    "                    if atom.name in atomNames:\n",
    "                        if count < len(atomNames)-1:\n",
    "                            ring.append(atom.index)\n",
    "                            count +=1\n",
    "                        else:\n",
    "                            ring.append(atom.index)\n",
    "                            proteinAromaticCindex.append(ring)\n",
    "                            ks.append(atom.resname)\n",
    "                            \n",
    "                            ring = []\n",
    "                            count = 0\n",
    "                            \n",
    "        descriptorName='aromaticStacking'\n",
    "        \n",
    "        \"\"\"Get the cutoff value for the descriptor function aromaticStacking.\"\"\"\n",
    "        cutoff = self.descriptors[descriptorName]\n",
    "\n",
    "        \"\"\"Open the hdf5 file and create the group 'desc' to store all information\n",
    "        for this descriptor function. The structure of this group is (nFrames, nChains).\"\"\"\n",
    "        with h5.File(self.h5File, 'a') as f:\n",
    "            group = f.require_group(name=descriptorName+str(cutoff))\n",
    "\n",
    "            \"\"\"Extract the contact pairs for every frame for the descriptor.\"\"\"\n",
    "            for frameIdx, frame in enumerate(self.universe.trajectory):\n",
    "                frameIdx = str(frameIdx)\n",
    "\n",
    "                \"\"\"Extract the unit cell information 'box' and the concatenated positions\n",
    "                'pos Concatenated' for every frame.\"\"\"\n",
    "                box = frame.dimensions\n",
    "                posConcatenated = frame.positions\n",
    "                \n",
    "                \"\"\"Enter the index of aromatic ring of the ligand\"\"\"\n",
    "                ligandAromaticC = posConcatenated[304:314]\n",
    "                ligandAromaticCOM = np.average(ligandAromaticC, weights=ligand_weights, axis=0)\n",
    "\n",
    "\n",
    "                numberOfContacts = 0\n",
    "                for key, aromaticCarbons in zip(ks, proteinAromaticCindex):\n",
    "                    ligandAromaticCOM = np.average(ligandAromaticC, weights=ligand_weights, axis=0)\n",
    "                    proteinRing = posConcatenated[min(aromaticCarbons):max(aromaticCarbons)+1]\n",
    "                    proteinAromaticCOM = np.average(proteinRing, weights=weights_dict[key], axis=0)\n",
    "                    distance = distance_array(ligandAromaticCOM, proteinAromaticCOM,\n",
    "                                              box=box)[0][0]\n",
    "\n",
    "                    if distance <= cutoff:\n",
    "                        numberOfContacts += 1\n",
    "\n",
    "                \"\"\"Export the data in the hdf5 file.\"\"\"\n",
    "                group.create_dataset(name=frameIdx, data=np.array([numberOfContacts]))\n",
    "\n",
    "    def _generateTransitionMatrix(self):\n",
    "        \"\"\"Generate the key names for the state defining functions, which may either be composed\n",
    "        of the descriptors name or of the descriptors name and the associated cutoff value.\"\"\"\n",
    "        descriptorKeys = []\n",
    "        for descriptorName in self.state:\n",
    "            try:\n",
    "                descriptorKeys.append(descriptorName + str(self.descriptors[descriptorName]))\n",
    "            except KeyError:\n",
    "                descriptorKeys.append(descriptorName)\n",
    "        \n",
    "        differentStatesList = []\n",
    "        populationOfStatesDict = {}\n",
    "        transitionMatrixDict = {}\n",
    "        countIdx = 0\n",
    "        states = []\n",
    "        with h5.File(self.h5File, 'r') as f:\n",
    "            stateInFrame = []\n",
    "            for frame in range(self.nFrames):\n",
    "                \"\"\"Extract the states in every frame.\"\"\"\n",
    "                stateInFrame = []\n",
    "                for key in descriptorKeys:\n",
    "                    for value in f[key][str(frame)]:\n",
    "                        stateInFrame.append(int(value))\n",
    "                \n",
    "                \"\"\"If a state did not occur yet, append it to the list 'differenStatesList',\n",
    "                update its population and generate an entry in the dictionary \n",
    "                'transitionMatrixDict' to later relate the entries in the 'transitionMatrix' with\n",
    "                transitions between states, in other words to relate indices <-> states.\"\"\"\n",
    "                if (stateInFrame not in differentStatesList):\n",
    "                    differentStatesList.append(stateInFrame)\n",
    "                    populationOfStatesDict.update({tuple(stateInFrame): 1})\n",
    "                    transitionMatrixDict.update({tuple(stateInFrame): countIdx})\n",
    "                    countIdx += 1\n",
    "    \n",
    "                else:\n",
    "                    \"\"\"If a state is already known, increase its population by one\n",
    "                    update its population.\"\"\"\n",
    "                    population = populationOfStatesDict[tuple(stateInFrame)]\n",
    "                    population += 1\n",
    "                    populationOfStatesDict.update({tuple(stateInFrame): population})\n",
    "                \n",
    "                \"\"\"Append the states observed in this frame to the overall array 'states'.\"\"\"\n",
    "                states.append(tuple(stateInFrame))\n",
    "                                \n",
    "            \"\"\"Get the number of different states which have been observed along the\n",
    "            trajectory.\"\"\"\n",
    "            differentStates = len(differentStatesList)\n",
    "            states = np.array(states)\n",
    "            \n",
    "            \"\"\"Initialize the transition matrix.\"\"\"\n",
    "            transitionMatrix = np.zeros((differentStates, differentStates), dtype=int)\n",
    "            \n",
    "            \"\"\"Fill the transition matrix with transition values by counting all observed\n",
    "            transitions between two states.\"\"\"\n",
    "            \n",
    "            stateHistory = states\n",
    "            for state1, state2 in zip(stateHistory[:-1], stateHistory[1:]):\n",
    "                    idx1 = transitionMatrixDict[tuple(state1)]\n",
    "                    idx2 = transitionMatrixDict[tuple(state2)]\n",
    "                    transitionMatrix[idx1][idx2] += 1\n",
    "        return (transitionMatrix, transitionMatrixDict)\n",
    "    \n",
    "    def _generateNetwork(self, minPopulation=0.0, minTransition=0.0, gexfName=\"network.gexf\"):\n",
    "        \"\"\"This function generates a .gexf file which can be visualized using the\n",
    "        program 'Gephi'. This files contains the following information:\n",
    "            - population of a state can be visualized by a node's size\n",
    "            - the name of a node is the state\n",
    "            - the amount of transition between two states is encoded in the\n",
    "              line thickness\n",
    "            - the direction of the transition is read to be clockwise.\n",
    "            \n",
    "        Futhermore the user is asked to give 'minPopulation' as input, which is a threshold\n",
    "        for only considering nodes possesing with at least 'minPopulation'*100 percent population\n",
    "        of the maximum observed population\"\"\"\n",
    "        \n",
    "        \n",
    "        transitionMatrix, transitionMatrixDict = self._generateTransitionMatrix()\n",
    "        transitionMatrixNonDiagonal = transitionMatrix.copy()\n",
    "        for idx,_ in enumerate(transitionMatrixNonDiagonal):\n",
    "            transitionMatrixNonDiagonal[idx][idx] = 0\n",
    "                \n",
    "        \"\"\"Get the maximum values for a node pouplation and a transition.\"\"\"\n",
    "        maxPopulation = max(np.diag(transitionMatrix))\n",
    "        maxTransition = np.max(transitionMatrixNonDiagonal)\n",
    "        \n",
    "        \"\"\"Generate a dictionary with nodes and normalized population, which are at least greater than\n",
    "        'minPopulation'.\"\"\"\n",
    "        nodesDict = {}\n",
    "        for state, size in zip(transitionMatrixDict.keys(), np.diagonal(transitionMatrix)):\n",
    "            fraction = size/maxPopulation\n",
    "            if (fraction >= minPopulation):\n",
    "                nodesDict.update({state: size})\n",
    "\n",
    "        \"\"\"Only consider normalized transitions with a value of at least 'minTransition'.\"\"\"\n",
    "        edgesDict = {}\n",
    "        for state1, (idx1, row) in zip(transitionMatrixDict.keys(), enumerate(transitionMatrix)):\n",
    "            for state2, (idx2, transition) in zip(transitionMatrixDict.keys(), enumerate(row)):\n",
    "                if (idx1 != idx2 and transition != 0):\n",
    "                    if (state1 in nodesDict.keys() and state2 in nodesDict.keys()):\n",
    "                        fraction = transition/maxTransition\n",
    "                        if (fraction >= minTransition):\n",
    "                            edgesDict.update({(state1, state2): transition})\n",
    "\n",
    "        G = nx.DiGraph()\n",
    "        for k, v in nodesDict.items():\n",
    "            G.add_node(k, size=float(v))\n",
    "        for k, v in edgesDict.items():\n",
    "            G.add_edge(k[0], k[1], weight=float(v))\n",
    "        nx.draw(G)\n",
    "        nx.write_gexf(G, gexfName)\n",
    "        \n",
    "    \n",
    "    def _OSError(self, function):\n",
    "        try:\n",
    "            function()\n",
    "        except OSError:\n",
    "            pass\n",
    "        except ValueError:\n",
    "            pass\n",
    "        except RuntimeError:\n",
    "            pass\n",
    "        \n",
    "    def generateNetwork(self, minPopulation=0.0, minTransition=0.0, gexfName=\"network.gexf\"):\n",
    "        for state in self.state:\n",
    "\n",
    "            if (state == 'hydrophobicContacts'):\n",
    "                self._OSError(self._intermolecularContactPairs)\n",
    "                self._OSError(self._hydrophobicContacts)\n",
    "            \n",
    "            elif (state == 'hbondContacts'):\n",
    "                self._OSError(self._intermolecularContactPairs)\n",
    "                self._OSError(self._hbondContacts)\n",
    "                \n",
    "            elif (state == 'chargedContacts'):\n",
    "                self._OSError(self._intermolecularContactPairs)\n",
    "                self._OSError(self._chargedContacts)\n",
    "            \n",
    "            elif (state == 'aromaticStacking'):\n",
    "                self._OSError(self._aromaticStacking)\n",
    "            \n",
    "            elif (state == 'polarContacts'):\n",
    "                self._OSError(self._intermolecularContactPairs)\n",
    "                self._OSError(self._polarContacts)\n",
    "                \n",
    "        self._generateNetwork(minPopulation=minPopulation, minTransition=minTransition, gexfName=gexfName)\n",
    "    \n",
    "    \n",
    "    def correlationCoefficients(self):\n",
    "        descriptorKeys = []\n",
    "        for descriptorName in self.state:\n",
    "            try:\n",
    "                descriptorKeys.append(descriptorName + str(self.descriptors[descriptorName]))\n",
    "            except KeyError:\n",
    "                descriptorKeys.append(descriptorName)\n",
    "        \n",
    "        with h5.File(self.h5File, 'r') as f:\n",
    "            correlations = {}\n",
    "            for idxA, keyA in enumerate(descriptorKeys,1):\n",
    "                for keyB in descriptorKeys[idxA:]:\n",
    "                    valuesA = np.zeros((self.nFrames, 1))\n",
    "                    valuesB = valuesA.copy()\n",
    "                    \n",
    "                    for frame in range(self.nFrames):\n",
    "                        valA = list(f[keyA][str(frame)])\n",
    "                        valB = list(f[keyB][str(frame)])\n",
    "                        for a, b in zip(valA, valB):\n",
    "                            valuesA[frame] = a\n",
    "                            valuesB[frame] = b\n",
    "                    \n",
    "                    correlationCoefficients = 0\n",
    "                    for valsA, valsB in zip(valuesA.T, valuesB.T):\n",
    "                        correlationCoefficients = np.corrcoef(valsA, valsB)[0][1]\n",
    "                    correlations.update({keyA + '+' + keyB: np.mean(correlationCoefficients)})\n",
    "        return (correlations)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a cutoff is given with one decimal place, all others must also be given with one decimal place!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdd1xV9f8H8NddcNkoGwFFUHChIg5AEzX3SFEy03JPxBxomWVSaqmpKYiWltu0yL0iWS4QBcQFKopsZO+77/n94Y/7jXAwrt4L9/18PHikd3zu+97kvO75nM9gMQzDgBBCCNEQbFUXQAghhLxLFHyEEEI0CgUfIYQQjULBRwghRKNQ8BFCCNEoFHyEEEI0CgUfIYQQjULBRwghRKNQ8BFCCNEoFHyEEEI0CgUfIYQQjULBRwghRKNQ8BFCCNEoFHyEEEI0CgUfIYQQjULBRwghRKNQ8BFCCNEoFHyEEEI0CgUfIYQQjULBRwghRKNQ8BFCCNEoFHyEEEI0ClfVBRBCGq6gQoSQuEwk55ahTCiFIZ8LZ0tD+PSwgYm+tqrLI0QtsRiGYVRdBCGkfhIzSrAjMgVRj/IBACKpXHEfn8sGA8DLyQwL+juiq62xiqokRD1R8BHSxByKeYZ155MhlMrwut9eFgvgczlYNcIZU/q0eWf1EaLuqKuTkCbkReglQSCRv/GxDAMIJDKsO58EABR+hPw/GtxCSBORmFGCdeeT6xR6/yaQyLHufDLuZJa8pcoIaVoo+AhpInZEpkAolTXouUKpDMGRKUquiJCmiYKPkCagoEKEqEf5r72m9zoMA0Q8zEdhhUi5hRHSBFHwEdIEhMRlNroNFoCQ+Ma3Q0hTR8FHSBOQnFtWY8pCQwilciTnlCupIkKaLgo+QpqAMqFUSe1IlNIOIU0ZBR8hTYAhXzkzjwz5PKW0Q0hTRsFHSBPgbGkIbW7jfl35XDacrQyUVBEhTRcFHyFNwIQeNo1ugwEwwbXx7RDS1FHwEdIEmOpro397M7BYDXs+iwUMcDKjhasJAQUfIU2Gr5cj+FxOg57L53KwwMtRyRUR0jRR8BHSRHS1NcaqEc7Q4dXv11aHx8aqEc5wsaFdGggBaJFqQpqU6oWmaXcGQhqOtiUipAm6k1mC4MgURDzMBwsvJqcryCTQ1tbGACczLPBypDM9Qv6Dgo+QJqywQoSQ+Ewk55S/mJwursKfe7Zj5/JPMXnCB6oujxC1RMFHSDNy+PBhTJkyBdra2rh//z4cHBxUXRIhaocGtxDSjFy8eBEAIBKJMGjQIJSVlam4IkLUDwUfIc1IeHi44s+ZmZnw9fVVYTWEqCca1UlIM1FVVYXs7Gxoa2tDJBIhICAA48aNU3VZhKgdOuMjpJnQ1dVFTk4OBAIBOBwOevXqhY4dO6q6LELUDgUfIc2IpaUlWCwWrK2t8ccff6i6HELUEgUfIc1Qz549cfXqVVWXQYhaouAjpBkaN24cUlNTVV0GIWqJ5vER0gxVVVVBT08PqampaNOmjarLIUSt0BkfIc2Qrq4ujI2NceDAAVWXQojaoeAjpJnq1KkT/vnnH1WXQYjaoeAjpJkaPHgw7t27p+oyCFE7dI2PkGYqNTUVbdu2hUAgAJ/PV3U5hKgNOuMjpJmyt7eHtrY2/vrrL1WXQohaoeAjpBmzt7fHiRMnVF0GIWqFgo+QZszT0xM3b95UdRmEqBUKPkKasYkTJyIrK0vVZRCiVmhwCyHNmFwuB5fLRXR0NHr37q3qcghRC3TGR0gzxmazYWFhgSNHjqi6FELUBgUfIc1c9+7dERUVpeoyCFEbFHyENHOjRo3C48ePVV0GIWqDrvER0syVlJSgRYsWeP78OczNzVVdDiEqR2d8hDRzxsbG0NfXx+HDh1VdCiFqgYKPEA3g5OSE8+fPq7oMQtQCBR8hGmDgwIFITExUdRmEqAW6xkeIBrhz5w66desGsVgMLper6nIIUSk64yNEA7i4uIDD4VB3JyGg4CNEY9jZ2SEkJETVZRCichR8hGiI3r17Izo6WtVlEKJyFHyEaAhvb2+kpaWpugxCVI4GtxCiIcRiMbS1tfHgwQN06NBB1eUQojJ0xkeIhtDS0oKJiQkOHTqk6lIIUSkKPkI0iIuLCy5duqTqMghRKQo+QjTIsGHDkJycrOoyCFEpusZHiAbJzs5Gq1atUFZWBgMDA1WXQ4hK0BkfIRrE2toaOjo6OHr0qKpLIURlKPgI0TAODg44c+aMqssgRGUo+AjRMO+99x7i4uJUXQYhKkPBR4iGmTRpEnJzcyGXy1VdCiEqQcFHiIbx8PAAAFy+fFnFlRCiGhR8hGgYNpsNKysrGuBCNBYFHyEaqGfPnrhy5YqqyyBEJSj4CNFAY8aMwdOnT1VdBiEqQRPYCdFAVVVV0NPTQ3p6OmxtbVVdDiHvFJ3xEaKBdHV1YWRkRAtWE41EwUeIhurYsSMuXryo6jIIeeco+AjRUO+//z7u3bun6jIIeefoGh8hGurx48do3749hEIhtLW1VV0OIe8MnfERoqHatWsHLS0tnDx5UtWlEPJOUfARosFat26N48ePq7oMQt4pCj5CNJinpydiY2NVXQYh7xQFHyEazMfHBxkZGaoug5B3iga3EKLB5HI5uFwubt68iR49eqi6HELeCTrjI0SDsdlsmJmZ4ciRI6ouhZB3hoKPEA3XrVs3REREqLoMQt4ZCj5CNNyoUaPw6NEjVZdByDtD1/gI0XAFBQUwMzNDQUEBTExMVF0OIW8dnfERouFMTU2hp6dH1/mIxqDgI4Sgffv2OHfunKrLIOSdoOAjhGDAgAG4ffu2qssg5J2ga3yEEMTHx8PNzQ0SiQQcDkfV5RDyVtEZHyEErq6u4HA4CA0NVXUphLx1FHyEEABAq1at8Oeff6q6DELeOgo+QggAoFevXrh27ZqqyyDkreOqugBCiHoYP348Tp06Vev2ggoRQuIykZxbhjKhFIZ8LpwtDeHTwwYm+rSBLWl6aHALIQQAIBQKoaOjg8ePH8PR0RGJGSXYEZmCqEf5AACRVK54LJ/LBgPAy8kMC/o7oqutsYqqJqT+KPgIIQomJibw9fVF+xEzsO58MoRSGV53hGCxAD6Xg1UjnDGlT5t3VichjUFdnYQQhc6dO+PU/UKIkQSBRP7GxzMMIJDIsO58EgBQ+JEmgQa3EEIUXAePQ4n9oDqF3r8JJHKsO5+MO5klb6kyQpSHgo8QolBg7gpweA16rlAqQ3BkipIrIkT5KPgIIQBejN6MzagEi92wwwLDABEP81FYIVJyZYQoFwUfIQQAEBKX2eg2WABC4hvfDiFvEwUfIQQAkJxbVmPKQkMIpXIk55QrqSJC3g4KPkIIAKBMKFVSOxKltEPI20LBRwgBABjylTO7yZDfsMExhLwrFHyEEACAs6UhtLmNOyTwuWw4WxkoqSJC3g4KPkIIAGBCD5tGt8EAmODa+HYIeZso+AghAABTfW30b28GFqthz2exgAFOZrRwNVF7FHyEEAVfL0fwuQ3bgZ3P5WCBl6OSKyJE+WiRakJIDYdinmHd+bqt1VlNh8fGqhEdaK1ODdKUt6ui4COE1HIo5hm+Op4AsLkA69UdQ7Q7g+ZpDttVUfARQl5q7sr1OJcqhl673mDhxeT0atUHuAFOZljg5QgXG/U8wBHletEb0PS3q6LgI4S8VFJSEjp27Iic4gqcupOLnUdOIbugBCypEAFL5sCnh63ad2kR5WlOXeA0uIUQ8lIdOnQAj8fDtbCLmPueA6RXf0P+X98h79QmlMeeoNDTIIkZJVh3PrnZbFdFwUcIeaXWrVvj+PHjkMlkSEn535ZDX3/9NZKSklRYGXmXdkSmQCiVNei56rhdFe3AThqlKY/sIm/m7u6Oa9eu4cyZM5BI/rcGp0gkwvjx45GYmAgej5Yoa84KKkSIepT/2mt6r/Pv7arU5ZhA1/hIgzSHkV3kzU6fPo3x48fDzc0NMTExNe5js9m4ceMG3NzcVFQdeRd2RT3B1kuPGrVzB5/LxpLB7TH3PQclVtZwdMZH6u1NI7uqR/+FPniOy48K1HZkF3mzESNGQCaT4dNPP0VOTg7S0tJgYmICW1tbxMbG0tmeBmiO21XRNT5SL/8b2fX64czAiy4OgUSGdeeTcCjm2TupjygXl8uFqakpnj17BltbW/B4PDg7O6OqqopCr5lZv349+vfvjx9++AExMTGKru3muF0VnfGROmvsyC4XG2Oa79UEde3aFeHh4eBwOOByuTAzM8P9+/dVXRZRMqlUiqtXryI6OhpsNhsSiQSjR4+G3cSvldK+Om1XRWd8pM6a28guUjfDhw9HcnIyJBKJIvjKy9Wn24o0XEVFBS5duoSAgAAcOnQIcrkcEokEIpEIAHD9+nWE7NkGyBp3tqZu21VR8JE6UebILtK0TJkyBRUVFRCJRNDS0oKBgQFkMhmFXxOUmZmJY8eOYdGiRejRowcsLCwQEBAAgUCAL774osZjq0Pw9LZV0NZu3GhMdduuioKP1ElIXGaj22ABCIlvfDvk3TI3N4euri4KCwuhpaUFgUAALpeL69evq7o08hoymQyJiYkIDg7G5MmT0bp1a3Tv3h2///47bG1tERgYiKKiIvz9999gs9n46quvFM9ls9no2rUrsrKy4NbZqdltV0XX+EidNMeRXaTu2rVrh8ePH8PCwgJlZWUwNDREbGwshg4dqurSyP+rrKzEjRs3cO3aNVy9ehU3btyApaUlPD09MWjQIKxevRrt27cH6/8T7K+//oKHhwcSEhJgYGAAb29veHl5YebMmWjTpg0iIyOhq6sL4MV2VVceF0Agqf+lDnXcroqCj9RJcxzZRequf//+uHfvHvh8PioqKmBhYYG7d++quiyNlp2drQi5a9euISkpCd26dYOnpycWLFiAQ4cOwczMrMZzHj9+jJUrV+L8+fMQi8Xo06cPQkND8f777wN4McDl+vXrCAgIgLHx/waidbU1xqoRzg1cq9NZ7Qa10QR2UieLjyXg5O3sRrcztps1PutljKSkJCQlJUFfXx9z585VQoXkbbp58yZ69eoFV1dXtGjRAtra2sjNzUVcXJyqS9MIcrkc9+/fV4TctWvXUF5eDg8PD3h6esLT0xNubm7g8/m1nisUCvH999/j119/RVZWFlq3bo358+djyZIl0NLSqlcdtDsD0SjKWL1BLhGh5MphVMWdAp/Ph1AoRN++fREZGam8Qslbw2Kx0KVLF+jp6aFfv344ePAgcnJyVF1Ws1RVVYXY2FhF0MXExMDMzEwRcn379oWTk5Oi2/JlTp8+jbVr1yIuLg66urr44IMPsG7dOrRu3bpRtd3JLEFwZAoiHuY32e2qqKuT1MmEHjbYeulRo9pgsVgQJ0dBJpOhsrISAFBUVISwsDAMGjRIGWWSt4jNZqO4uBgsFgs9evTA9u3bVV1Ss5GTk6M4k7t27Rru378PFxcXeHp6Yu7cudi/fz/Mzc3f2E5qaipWrlyJs2fPQiAQoFevXjh79iyGDx+utFpdbIyxa4obCitECInPRHJOOcqEEhjyeXC2MsAEV/Vfp5fO+EidzTl4C/8kPW/QlAYWCxjYzgSOuRFYs2YNxGIxWCwW2rZti9TUVPB4PPTq1Qvz58/HxIkTwWbTgGN1w+PxoKOjA0tLS0RERMDGxgYymYz+X9WTXC5HUlJSjW7L4uJieHh4oG/fvopuSx0dnTq1JxaLsXHjRvzyyy/IyMiAra0t5syZgxUrVtS7K1NTUPCROkvMKMFHu2MaNLKLJZfAvxsHk4Z6gs1mo0ePHigoKICWlhamTZsGY2NjnDx5Erdv3wYAdOnSBdOnT8fcuXPpl1dNaGlpQSaToVWrVkhPTwebzUZCQgK6du2q6tLUmkAgQGxsrCLkoqOj0bJlS0XIeXp6wtnZud5fIM6fP4/vvvsOsbGx0NHRwejRo7F+/XrY29u/pXfSfNBXNVJn1SO7dHj1+2ejxQEKQn/B4k+9YWlpiS5dumDw4MF48uQJrl+/DolEgi1btsDW1hYXLlzA77//DmNjY3z++efg8/lwcnLCmjVrUFKiXptZahq5XA65XK7optbV1aW5fC/x/PlzHD9+HMuWLUOfPn1gamqKzz//HIWFhZg5cyYePHiAlJQU7Nu3D7Nnz0bHjh3rHHrp6emYMmUKDAwMMHr0aMhkMpw4cQIVFRX4/fffKfTqiM74SL01ZGTXryunKwax8Hg8DBkyBGfPnlU8tqKiAgcPHkRgYCDYbDYWLlyITz75BHFxcdiyZQsiIiJQVlYGW1tbjB07FitWrICNjfqsBNHcMQwDNpsNPp8PhmEgFArRpk0bDB06FD///LOqy1MZuVyO5OTkGtfnCgoKaoy27Nmzp2I+XEOIxWJs2bIFu3btQlpaGlq1aoVZs2bhiy++eOkoTvJmFHykQeo7sisqKgojR45EVVUVOBwOIiMj4enpWatdhmEQHh6OwMBAXLlyBVOnToWvry8cHBxw//59bNy4ERcuXEB+fj5MTU0xbNgwfP755+jcufO7e/MaSCqVQltbG23btsXTp08hk8nQr18/sNlsREVFqbq8d0YoFOLmzZuKkLt+/TqMjY0VIefp6VmvM7jX+eeffxAQEICYmBhoa2tjxIgRWL9+Pdq1a6eEd6LhGEIaoaBcyOyKSmEWH01gZuyLZRYfTWB2RaUwBeXCGo+Ty+WMo6MjY2hoyAQHBzOmpqbMH3/88dq2U1NTmeXLlzMmJibMyJEjmYsXLzIymYxhGIbJyMhgFi1axNja2jIAGAMDA2bUqFFMRETE23qrGk0gEDDa2trMxIkTmerDxsyZMxl7e3sVV/Z25eXlMSdOnGD8/f2ZPn36MLq6ukzPnj2ZxYsXM3/++SeTnZ2t1NfLyMhgpk6dyhgaGjJsNptxdXVlQkJClPoahGEo+Mg7ExcXxyQmJjIMwzDx8fGMnZ0d88033yjC7FUqKyuZ3bt3My4uLkz79u2Z7du3M6WlpYr7S0tLmTVr1jBOTk4Mi8Vi+Hw+079/f+bYsWNvbJu8nlwuZ7y9vZn33nuPYbPZTPfu3RkAjEAgYAIDAxkDAwNVl6g0crmcSUpKYvbs2cNMmzaNadeuHWNkZMQMGzaM+e6775jw8HCmoqJC6a8rkUiYH3/8kWnbti0DgLGysmK+/PJLprKyUumvRV6g4CMqk5OTw7i7uzPjx4+v0wFFLpczUVFRzIQJE5gWLVowCxcuZJKTk2s8RiQSMUFBQYyrqyvD5XIZLpfL9OjRg9mxYwcjEone1ltptuRyOdO5c2cGLxbYZ1gsFgOAOXToEHPr1i2GzWarusQGEwgEzNWrV5kffviBGT16NGNiYsK0adOGmTx5MhMcHMzcuXOHkUqlb+31IyIimPfee4/hcDgMn89nxo4dyzx48OCtvR75Hwo+olJCoZCZOnUq061bNyYtLa3Oz0tPT2e+/PJLxtzcnBkyZAhz5syZWgcpmUzGHDt2jOnfvz/D5/MZNpvNODs7MwEBATXOGMnrnTlzhtHV1WUAMHw+nwHAjB8/npFIJAwAJicnR9Ul1kl+fj5z8uRJZvny5YyHhwejq6vL9OjRg1m0aBFz7NgxJjMz863XkJOTw8ycOZMxMjJiWCwW061bN+bo0aNv/XVJTRR8ROXkcjnz448/MlZWVsy1a9fq9VyBQMDs27eP6dGjB9O2bVtm8+bNTHFx8UsfGxYWxowaNYoxMDBgWCwWY2dnxyxevJjJyspSxttotuRyOWNnZ8cAYLy9vRkAjK2tLcMwDKOlpaWW16DkcjmTnJzM/Prrr8yMGTMYJycnxtDQkBkyZAgTEBDAXLp0iSkvL693u/nlQmZnZArz2dF4Zvq+WOazo/HMzsja17T/TSqVMj/99BPj6OjIsFgsxsLCglmxYkWDXp8oB43qJGrj/PnzmDZtGjZt2oSpU6fW67kMwyAmJgaBgYG4cOECJk6ciIULF75ytOedO3ewceNG/P333ygoKIC5ublihGjHjh2V8XaalR07dmDhwoV48uQJHBwcwGazIZPJYGlpienTp+P7779XaX0ikQhxcXE1Rlvq6OjUWNuyc+fO4HA4DWo/MaMEOyJTEPUo/8XrvWQUs5eTGRb0d0RX2xfrU169ehWrV6/GlStXwOFwMGTIEKxfv55GIKsBCj6iVh48eIAxY8Zg7Nix2LBhQ4MOVDk5Ofj555/x888/w9nZGYsWLcLo0aPB5b58adr09HRs2rQJJ0+eRGZmJgwNDTFgwAD4+/ujb9++jX1LzYJMJsOpU6fg7e0NFosFFouF6OhozJs3DzY2Njhz5sw7raewsBDXr19XBF18fDycnJwUIefp6am0eZ71mbeqzWGjbeltxBzahJKSEnTu3BkrVqzAxx9/TEu7qREKPqJ2CgsL4ePjAx0dHRw5cgRGRkYNakcsFuOvv/5CYGAgsrKyMH/+fMyaNQumpqavfE5JSQm2bNmCo0ePIiUlBXw+H3369IGvry/GjRuncQevggoRQuIykZxbhjKhFIZ8LvZv+x6ctFhMnvABsrKykJycjHv37r21GhiGQUpKiiLkrl69iqysLPTu3VsRdL1794aBgYHSX/tF6NVvDzpGIkJ3VioOfD0bhoaGSq+JNF6TCb6X/QI6WxrCp4f6rwRO6k8ikWDx4sWIiIjA6dOn4ejYuB2cb926haCgIJw8eRLe3t7w8/ND9+7dX/scoVCIn3/+Gfv27cPdu3fBYrHQrVs3zJo1CzNnznzlGWRz8LquPblEBDabDV7+Iwy1ZeFo8AYUFBQo7bXFYjHi4+NrrIaipaVV42yuS5cub/3zb8zatDo8Do7N6aO22/JoOrUPvob0rZPmY+fOnQgICMCRI0cwcODARreXn5+P3bt3Y+fOnWjdujX8/Pzg7e0NHo/32ufJ5XIcPXoUu3btQmxsLCQSCZycnDB58mR89tln0NfXb3Rt6qKuXXuMXA5tLht5f+9Cya2Gd3UWFxcrui2vXr2K+Ph4ODo61ljE2c7OrsHtN1RjdyMZ2tECu6a4Kb8w0mhqHXzNZbdf0jgRERGYNGkSVq9ejQULFiilTalUipMnTyIwMBApKSmYN28e5syZAwsLizo9/59//sFPP/2Ey5cvo7KyEnZ2dhg/fjyWL18OS0tLpdSoCg3p2pOLhfh2XDdM6+vwxscyDIOnT58qQu7atWtIT09Hr169FEHXp08flXcRFlSI4LkhvFEbL2tz2bj++UDqkVJDaht8DfkF1OGxsWpEBwq/ZujJkycYPXo0vLy8sG3btjeeodVHYmIigoKCEBISglGjRsHPzw+9evWq8/Nv376NjRs3IjQ0FIWFhbCwsMCIESPw+eefw8nJSWl1vm2N6drT4gAh8zxrde1JJBIkJCTU2HuOw+HUOJvr2rWryrqNExIScPLkSfj6+tbY6HVX1BNsCU2GuOG5Bz6XjSWD22Pue2/+QkDeLbUMPupbJy9TVlaGjz/+GFVVVfjzzz9hYmKi1PaLiorw66+/Ijg4GObm5vDz84OPjw+0tev+jT0tLQ0bNmzA6dOnkZWVBSMjIwwcOBD+/v7w8PBQar3K1piuPYDBsE6W+GGUY43RlrGxsbC3t0f//v0VQde6dWuwWCxll98gv/zyC3x9fcHlcvHhhx9i0aJFOHjwIEIy9cBt1/j/X+O6tcLWid2UUClRJrUMPupbJ68ik8mwcuVKHD9+HKdPn34rc+5kMhnOnj2LwMBA3Lt3D3PmzMG8efNgbW1dr3aKioqwefNm/PHHH3jy5Al0dHTg7u4OPz8/jB49WiUjRAUCASZMmIDZs2djzJgxihqU0bUHmQRFexfArYszOnXqhLi4OERHRyMoKAi+vr5KegcvBr8UFxejpKQEZWVlKC0tRWlpKcrLy1FeXo6KigrFT2VlJaqqqiAQCBQ/QqEQQqEQYrEYBQUFLx2YY/3Rt+C1cW10rYOczfHr1J6Nbocol9oFH/Wtk7o4cOAA/P39sXfvXowcOfKtvc6DBw8QFBSE33//HUOHDoWfnx88PDzqfcYiFAoRHByM/fv34/79+2Cz2ejevTtmz56NadOmvbOuvufPn8PGxgZ8Ph/m5ub44YcfMH78ePxyJRVbLz1q1O8dl8VgpB2DhCObEB0dDbn8RVu9evVC+/btUVVVhaqqKkXwCIVCiEQiiEQiiMViSCQSiMViSKVSSKVSyGQyyGQyxQa4/z1UVc8nZLPZ4HA44HA44HK54HK54PF40NLSAo/Hg7a2tuJHR0cHfD4fOjo6EIlEuHHjBgoLCxXtOTo6IiAgAH+XWSLyWVXDP+j/R2d86kntgm9X1JNG/wL+t2+9uLgYERERGDdunNp0sTQHDMMoDkr/Pjj997b63l7Xx965cwerVq2Cj48PPvzww1r3K7OWyspKxMTE4MqVK9DS0kLfvn3h4uICDodT77ZlMhmSkpJw9+5d5OXlQS6Xo0WLFnBwcFDs5fY2Pi+5XA6RSITbt2/XCBELCwt8tO0CTt7ObvS/Cenj68j6a32N24yNjWFubg5tbW1oaWkpgkdHRwe6urrQ0dGBnp4e9PT0oK+vD319fRgYGMDAwACGhoYwMjKCoaEhjI2N0aJFC+jo6DT4bLmsrAzffvstDh48iPz8fJiYmKCgoAAGBgbw8vKCkZERHjx4gGc67aDX50OweQ3/8kzX+NSX2gXf4mMJSvkFdDEUoqf0Ac6fP49bt25BKpVi27Zt4HK5b+2A/a4P/KquBQDYbLbip/rb97//zuFwat3+qse/6rbX3S4Wi5GUlAQ9PT106NABXC63Qe3UtRYWi4W0tDQkJiYiNzcXLi4ucHNzg7GxcYNfMzk5GeHh4UhJSYFYLIaJiQl69uyJkSNHwtjYWGnvh81mo7S0FGPGjIFEIgGfz0eHDh2wbt06/JlnivDkvEb/3g1yNkfAICts3LgRv/76K0QiEVasWIH169e/+clviVwux++//46NGzfi7t27MDIygo+PDxYsWICwsDD4+/vXes6oCZNwr+1EMOyGn4lTz5P6Urvgm7H/plJ+AQUpscgL+bbGbU5OTtDV1VV8uzQwMICRkRH09fUVB1P+5sMAACAASURBVMzGHFTe5gFeHWtRl7PnyspKTJs2DZmZmThx4sQ7m07w+PFj7NixAwcOHICXlxf8/Pzg5eXVqM/l1q1b+PHHH/HPP/+gqKgIlpaWGDlyJD7//HOl7LxdVlYGY2Nj9OnTB5s3b4a7uzsA5X3hNK9MRez2hQBerIKzc+dOuLq6YujQoY1uu77u37+PL7/8EqGhoZBKpejVqxeGDBmC3NxchIaGIicnB2w2G5WVlbWeq62tjT7+vyJNZoyGHCBprIF6U7vgU9YvoFFRMh789gVkMhkYhgGbzUabNm1QWVkJgUCguKYgk70YOVp9dlJ9TaC6+6U6HFu0aAFTU1OYmZnBwsICVlZWaNWqFWxtbWFlZdWsV/FoCuRyOb777jv89ttvOHny5BtXZVGm8vJyHDx4EEFBQeBwOFi4cCGmTJkCPT29RrWbmpqqGCGak5MDY2NjDBo0CMuXL0fv3r0b3G5WVhZatWpV47ZdUU+wOTQZ9Zg9VItcIgL/8SU8OhXc8EYaqbKyEmvXrsW+ffuQm5sLKysrODk5obi4GE+ePIGxsbFiIEz155mRkYHY2FhFG1wuF3FxcWBa2NHo8mZK7YJPmdf4xnc0wvLly3H48GGYmpoiO/vlgSoSiZCVlYWMjAxkZmYiNzcXz58/R35+PoqKilBcXIzS0lLFKLG6Bmf1tYrq4DQxMYGZmRksLS1rBKelpSUFp5KEhIRg/vz5CA4Oho+Pzzt9bYZhEBYWhsDAQFy7dg1Tp06Fr68v2rZt2+i2CwoKFCNEU1NTFTsPLFq0CKNGjapXWydOnMBPP/2kGAySnp6O/DIhDKb8BHAaPj+SkYoxzzoTK5f4NbiNhvrjjz+wfv163LlzB1paWjAyMkJFRQXat28PkUiEjIwMVFRUwNraGqNHj8by5cvRunVrBAQEYPPmzRAIBAAAPp+PCxcuwMvLCwDNJ26u1C743saozjt37uDu3buYPHmyssqsQSgUKoIzKysLOTk5eP78OQoKClBYWIji4mKUlZWhvLxcMbRaJBIpRq4BjQtOKyurBm+30hwlJCRg7NixmD59OlavXg02+91PG0hNTUVwcDD27t2rmMIwePBgpXQPV1VVITg4GAcOHMCDBw/A4XDg6uqKOXPm4NNPP33jv4WzZ8/C29sbEolEcVu3bt3gtuQXXErOa9A0IkYuh+BxDBJ3LISVlVX9G2iABw8ewNfXF1evXoVUKgWbzYajoyM6dOiA1NRUPHr0CCKRCI6Ojpg4cSKWLFmCli1bQigUYtmyZfjtt9/AYrEwf/58sFgsbNmyBWvXrsWXX35Z43VoBanmR+2CD9C8eXxCoRCZmZnIyMhAdna2UoKz+lpmdXC2bNlSEZwWFhawtrauEZyqCIe3KTc3F97e3rC2tsb+/fsb3e3YUFVVVTh8+DACAwMhFouxcOFCTJ06VWk7Ccjlchw8eBA///wz4uLiIJVK0alTJ3zyySfw9fWFrq5ujceLxWIsX74c27dvB/Di302PHj0QHR2N8NtP4HfqCUTS+v/iySVClJ/4DsVPbivlfb0MwzCIi4vDV199haioKAiFQvB4PLi5ucHZ2Rm3bt1CUlISAMDFxQXTp0/HnDlzoKWlBeDF9c0FCxbg2LFj0NXVxfLly/Hll1+CzWYrFi/w9/d/6ZeTO5klCI5MQcTDfLAACF+yZvAAJzMs8HKk7s0mQC2Dj1ZuqZ9/B2f1GWdeXh7y8/NRWFiIkpKSGl211fOn6hKc1cPJX3aN08bGRtFVq47BKRKJMHfuXCQmJuL06dOwtbVVWS0Mw+Dy5csIDAxEeHg4pkyZgoULF6J9+/ZKfZ3z589j27ZtuHbtGqqqqmBvb68Ywfjtt9/iwIED0NbWxtChQ3H69Gnw+XzMnz8fp06dwsOHD9F32kpkmPYEuFp1f28SEUqj9qKrbhmioqKU+n7S0tIQFhaGffv2ITo6GlKpFDweD66urnB2dsa1a9fw5MkT8Pl8uLu7Y8GCBbW2j8rNzcXs2bNx/vx5mJiYYM2aNQ1e87WwQoSQ+Ewk55SjTCiBIZ8HZysDTHClXWKaErUMPoD61t8lgUBQ64wzLy8PeXl5imuc/z7jfFNwVs/TUofgZBgGW7ZswZYtWxASEqIYxahKGRkZ2LlzJ/bs2QNXV1f4+flh+PDhSv8MYmNjsX79epw/fx4SiQQsFgu9evXCoUOHYG9vDzs7O+Tl5YHFYkEikSh2CZe0cUeGqRtEUvnre13kcmhx2cgL3wuGYaBr3Q5u7v3Q1tYaHawatmVYXl4eIiIiEBYWhosXL+L58+eKSewdOnSAnZ0dEhMTkZOTgxYtWmDgwIFYsmQJPD09a7WVkpKCWbNm4fLly7CxscHGjRvx0Ucf1fNTJM2R2gYfQH3rTYVAIEBGRkat4Pz34KDGBmd1V625uXmt4LSwsHhjaJw/fx7Tpk3Dpk2bMHXq1HfxsbyRUCjE0aNHERgYiNLSUvj6+mL69OkwNm58b0VeXh5mz56Ns2fPwsTEBH5+fkhPT8fZs2eRm5uLli1bonfv3ordJQDAysoKVlZWuHr1Kh4Xil7Ztcdjv+gybSkvRXZ2NnRsO0Iul9eY7K3NZQFgvXbLMKlUil27dsHGxgaRkZEIDw9HWloarKyskJubi9LSUlhYWMDExASZmZkoKyuDtbU1Ro0ahRUrVsDB4eUTw+Pj4zFnzhzEx8ejXbt22L59u0qmUxD1pdbBB1Dfuiaoqqp6aVdt9TXO6jUZ/32Ns3pUrVz+4t9DdXBqaWnVusZZveIHh8NBaGgoXF1dMX/+fNjZ2cHW1hbm5uYq7aplGAbR0dEIDAzExYsX8dFHH2HhwoXo1KlTvdtKT0/HzJkzERYWBmtra2zatAmTJk2q8Zi8vDxs3rwZhw4dUox0ZrFY4PP5SEpKQuvWrQEAS5YsgV27jtDtPBDJOeUoqhDg3IkQ9Ha2wZUrV2A+aDokMoD1ms/uv19KhUIhrl+/jkuXLuHnn39GUVER2rZtC09PT8TFxSE5ORk8Hg9GRkYoLS2FWCyuNTjlVSIjI7FgwQIkJyeja9eu2LVrV6OmfZDmS+2Drxr1rZNXqaqqUkxFycrKUkxH+e/goOqFi4uLixUrz9QnOKu7aqtH1VafcSozOLOzs/Hzzz/jl19+QceOHRULWr9ppObDhw8xc+ZMXL9+Hfb29ti2bdtrpzlERUXBx8cHQUFBOHv2LA4ePAgA0NLSgpubG6ZPnw4/Pz+wWCysXbsWS5cuxeHDhzFlyhQY9RgFQ69pYPP4dX5fXMhgnBqBh+f2oFOnTpBIJLh9+3aNz19HRwdCoRBsNhsuLi6YNm0a5syZ88bdMf766y8sW7YM6enp8PT0xC+//IIOHTrUuTaieZpM8BGiLBKJBIsXL0ZERAROnz4NKyurGsH5pjPO6pX963LG+e81Jk1NTRVdtdWjau3s7GBqalorOMViMf78808EBQUhOzsbCxYswKxZs2ptxZSQkIDZs2cjPj4eTk5O2Llzp2IO2qucO3cO06ZNw9GjR9G3b1+899578Pb2xrJly7B//37s3r0bt27dUnRD83g8xUjKqw8yYDH5+3qFXjUem8HeyS5Ys2gGwsLCatynpaUFT09P+Pr61hqc8ip79uzBV199hfz8fAwZMgS7d++GjY1NvesimoeCj2isnTt3IiAgAEeOHMHAgQMb3E5FRYUiOP99jbO+wVm9q0D1Nc7qeZxsNhvPnz9HTk4OOnbsiBEjRkBPTw979uxBamoqunbtit27d6Nnzzdvf/P7779jyZIlOHXqFHr37o25c+eioKAAISEhNYbxu7m5IS4urtbzTcd9Cd12fV7bvflKjByS1Dhk/xFQ664lS5Zgy5Ytb2xCLpfjxx9/xPfff4/y8nJMmDABwcHBr+0CJeS/KPiIRouIiMCkSZOwevXqBg9xb6xXBWf14KDq6SilpaXIz8+HSCSq1cargvPfg4Nyc3ORkJCAxYsXw83NDTdv3sSxY8cQGxtba0ANn8+HSCRCixYt8OGHH0IqlWLv7yGwWbAXrHpMdahVp1yKEZLraKmnhczMTNy6dQtPnz7FkiVLsHbt2lc+TyqVYtWqVQgKCoJUKsW0adOwdevWWvMUCakLCj6i8Z48eYLRo0fDy8sL27ZtA4/X8GW73paQkBAsXboUmZmZ6NevH3x8fPDHH3/g6dOnmDZtGoYMGQKBQIDs7Gzk5ubWCs4nT56gsLAQhoaGkEgkEIlENVZu+W9wlpSUKM5G2Ww2zM3NUdXaA0Z9J7/TrXqqqqqwdOlS7N27F1wuFwsXLsS6detoiT/SKOo365iQd8zBwQExMTFIT0/H0KFDFRuTqoO9e/fCysoKEydORJcuXZCZmYmoqCgsXLgQly9fVkxP+OCDD3D48GF07twZK1euxNatW3Ho0CGcO3cO/fr1g6mpKdLT01FUVIQnT57A0tISx48fB8MwKC0txd27d3HmzBkEBQVh0aJFNWqQy+XIz8+Hvo1To0IPeDEqOzmnXPH3jIwMbNu2DUFBQTUeV1RUhI8++giGhoY4duwYAgICUF5ejg0bNlDokUaj4CMEgKGhIU6dOgU3Nzf07t0bDx48UGk9gYGBMDExwezZs9G3b1/k5+fj3LlzsLa2rvG4bt26Yc+ePUhJSUHnzp3h4+ODPn364PDhwxAIBJg3bx4iIiJw+fJlWFtbQyqV4qOPPsLkyZMxbtw4AICOjg5KSkoQGxuL/fv3Y8OGDS/m5bHZeO+993D79m1IpVIMHvmBUt5b/L1kjBs3Dg4ODmjXrh38/f1x4sQJAEBmZiZGjBgBMzMzREZGIjg4GMXFxfjiiy/UcnUg0jRRVych/3HgwAH4+/tj3759GDFixDt7Xblcju+//x4bN25EVVUVJk+ejKCgIOjr69e5DZlMhjNnzmDbtm2IiYmBpaUl/v77b8XSaMuXL0dCQgI2bNiAyMhIhIWF4erVq3BwcMCgQYMwcOBA9OvXD7a2tigtLVVMMeDxeLAY+znYbRs/L04r+zYeH/iqxm1GRkbgcDgoKiqChYUFtm/fjg8//LDRr0XIy1DwEfIS0dHRmDBhApYsWYJly5a91U13pVIpvvrqKwQGBkImk2HmzJnYvHkz+Pz6TxkAXlwXmzBhAkQiEdq2bYuQkBB4enqCzWbj0qVL4PP5MDMzw8CBAzFo0CB4eXnB1NQUSUlJOHLkCMLCwnDz5k1IpVIAL67/mZubY9qGQziRImnUzik8NuA/1BlueiUYO3Ysnj9/rrjWqK2tDS0tLVRVVUEmkynqtLe3h4uLCzw8PDBo0CCYm5s3+PUJAairk5CXcnd3R0xMDI4cOYJp06ZBKBQq/TVEIhEWLlwIfX19bN++HQsXLkRFRQV27NjR4NArLS3F0KFDoauriylTpkAikUBXVxdRUVE4c+YMjI2N8dVXX+HGjRvo27cv/vzzT/Tq1Qs8Hg8dO3bEzp07wePxMHjwYHC5XOjo6GDZsmXIysqC//h+aOz3ZLFYDFdjMYqKisDn8xWht2/fPgiFQpSVlUEqlSInJwd79uzB6NGjwTAMTp48iRkzZsDCwgJcLhempqbo1q0bJk2ahC1bttSYDE/Im9AZHyGvUVlZiWnTpiEzMxMnTpyApaVlo9usqKjAwoULceTIEfD5fKxYsUKxPU5DFRUV4eTJk/j8888hlUrBYrEUZ3Q9e/bE+PHj0blzZ6SkpODp06eQSqXgcDiws7NDv3794OTkhF27diEmJgbW1tZISEiAu7s7goODX6zpeT8N+2Jz8JxrDoD1Yi2y+mLkYGXdRdrhr8AwDPr374/du3dDJBKhU6dOdTqrFovFuH79OqKiohAfH49Hjx4hOzsb5eXlYBgGenp6sLCwgIODA7p164a+ffti4MCB9eouJs0fBR8hbyCXy/Hdd9/ht99+w8mTJ9G9e/cGtVNUVIR58+bh+PHjMDIywurVq+Hn59egwKuoqMCVK1cQHh6OsLAwPHr0CMCLM9U1a9YgJSUFZ8+exc2bN5Geng6GYWBiYoIuXbpgyJAh6N27N06dOoWDBw9iwIABSEtLU6z+cuvWLejp6WH8+PE4deoUjN1GQ7fvFLA4Wg2buP7/5BIhnh/+AkxhGkxNTZGRkaHUDZQfP36M8PBwxMTE4P79+4pRrBKJBDweDy1btoSdnR06deqEPn364P3333/lQtekeaPgI6SOQkJCMH/+fAQHB8PHx6fOz8vJycHs2bNx4cIFmJmZYd26dZg5c2a9XlssFiMmJgZhYWEIDw9HQkICevTogUGDBkFLSwvr169HixYtFKvEaGtro02bNtDV1YVAIEBcXNxLJ3uXl5fjp59+wjfffAOGYcDlctG/f3+EhoYiPDwcE1Zug2H/+q3L+TJysRDF4b+i4vYFxW0cDgdLly7Fxo0bG9X2m1RUVCAyMhJXrlzB7du3kZKSgufPn6OyshIsFgsGBgawtrZG+/bt4erqiv79+8PDw0OxgS1pfij4CKmHhIQEjB07FtOnT8fq1atfe7aWmpqKmTNnIjIyEjY2Nvjxxx/rPFJRJpMhISFBcUZ3/fp1ODs7o2/fvuBwOEhJSUFCQgIyMzMhl8uhr6+PXr16YciQIZg0aRLs7Oxw8eJFzJgxAzdv3kSrVq1e+VpLly7Ftm3balwjGzFiBLKFPBR2/6RRocfI5WBk4hehl3Ch1v0eHh64du1ag9tvDLlcjjt37iA8PBw3b95EUlISMjMzUVJSAplMBm1tbZiamsLe3h5dunSBh4cH3n//faV0dxPVouAj5P8VVIgQEpeJ5NwylAmlMORz4WxZe0PV3NxceHt7w9raGvv27YNEIkGLFi0U9z948ACzZs1CTEwM2rZti8DAQAwfPvy1r80wDJKTkxVndJGRkbC0tISLiwsEAgHS09Px5MkTlJeXg8/no02bNnBwcMDVq1fxyy+/1ArUp0+fwt3dHSEhIejXr99rXzsoKAgxMTEwNTWFqakprl+/jtDQULSauAZsu+5o0AGCYcBiAYM7WGB239ZwNtNBx44dkZmZWeNhLBYLW7duxWeffdaQV3lr8vLyFF847ty5g9TUVOTn50MoFILD4cDIyAitWrWCs7MzevbsiQEDBsDV1ZXmGjYRFHxE4yVmlGBHZAqiHuUDQI3h+tV7Pv53Q1WRSIS5c+ciNDQU5eXlyMnJQXJyMmbPno3ExER06NABu3btem3opKenIywsTBF21YNNRCIRcnJy8Pz5c8jlcpiZmcHFxQVDhgzB5MmTYW1tjYsXL+KTTz7B4cOHMWTIkBrtVlVVwcPDAzNmzKi1CsvrZGZmYtiwYUhKSsKiFatwnuveqKkLWhw2or8YqPjS8PXXX+OHH35QDL6ZMWMGfv31VwAvNgp+05cDdSCVShETE4PIyEjExcXh4cOHisE1crkcurq6tQbXDBgwAIaGhqouvU7q+uWvqaPgIxrtUMwzrDufDKFUhtf9Jvx3Q1XgxQLXQ4YMgVQqhbGxMUpLS9G9e3fs3r0brq6utdrIz89HeHi4ovuysLAQ5ubmEAgEKCoqQmVlJXR0dGBvbw9PT0/4+Phg0KBBtc4i/vjjD/j5+eHEiRPw8PCocR/DMPj000/BMAwOHjz4xpGSeXl5mDZtGvT19XH8+HE4ODggNDQUF55JsfXSo0YF33/X5UxMTES3bt3QuXNnPHr0CO7u7pg3bx4+/vhjMAyDu3fvonPnzg1+PVVLTU1FWFgYYmJicO/ePaSlpaGoqAhisRhcLhctW7aEra0tOnXqhN69e2PQoEFwcnJSddkAGvblrymj4CMa60XoJUEgqfvBXYfHxqoRHTCotTYcHR1RVVWluG/ZsmX48ccfFX8vKyvD5cuXERYWhn/++QdPnjyBkZERhEKhYvi9ubk5unbtiqFDh+Ljjz9+4/WjPXv24JtvvsGFCxfg4uJS6/6goCDs2bMH169fr9POBZcuXcLgwYMBvNiRYcGCBRg/fjx23xMjIrWyrh/LK3U3lmBWZx709fWhr6+PiIgI+Pj44Pnz5+jXrx8GDBiArVu3okuXLpDJZEhMTHzp+2rKKioqcPny5RqDa3Jzc1FRUQEWiwV9fX1YWVmhXbt2isE1np6eDZ7LWV+N+fLXVFHwEY2UmFGCj3bHQCCR1fu52hwWcg6tQHnafbDZbMWgED6fj9GjR6Nt27Y4e/YsHj58CD6fD7FYDLFYDB0dHTg4OKBv377w8fGBl5dXva4J/fjjj9ixYwdCQ0PRrl27WvdfvXoV3t7eiI6Ohr29PTIyMvD06VOkpaUptjz6964NaWlpKC8vf8krAfZTN0Bu1anen81/GVdmwDrlNCoqKlBeXo7y8nLFn6u/NGhra8Pa2hrPnj0DwzDo0aMHHB0dYWBgAAMDA8W+hP/978tua0oLWMvlcjx48ABhYWGIjY1FUlISMjIyUFJSAqlUqhhc06ZNG3Tp0gXu7u54//33a63X2hiN+fLXlMOPgo9opDkHb+GfpOev/Yb7KoxcjpZV6egpSsSePXtqrGbCYrEUf7ewsED37t0xbNgwTJo0qcFLbRUXF2PZsmUIDQ3FjBkzUFlZiefPnyM/Px+FhYUoLS1FSUkJCgsLweFwIJPJFDVwuVxoaWmBz+dDX18fRkZG4HK5ePDgASQSCUaOHImzZ88CeBFAn376KTZu3IhvLj7FydvZDar338Z1a4WtE7u99D6ZTIaIiAgMGzYMQ4cOxdKlSzF06FDIZDKMGTMGI0eOrBGU//3vf2+rqKgAj8erU0DWNVC1tbXf6nJ1r1JQUIDw8HBcu3YNd+7cwdOnT5Gfnw+BQAA2m60YXOPk5AQ3NzcMGDAAPXv2fOkXqe7du2PgwIH4/vvva0zRaMyXPx0eB8fm9IGLTdPs9qTgIxqnoEIEzw3hjbp+xYYcadumQC4oq3H73LlzkZeXh+TkZJw+fRqOjo6K+8RiMVJTU/H06VPFxrP/3q29uLgY5eXlqKyshEAggEQigUz2v4OSlpYWdHR0oKurCwMDAxgbG8PExASmpqYIDw9H165dMWfOHNjb26Nt27a1ViuRy+WYMWMGDhw4AE9PT5w7dw6GhoZo2bIlrK2tsWvXLvTu3Rs8Hg8bTsfjl+hMyNDwCeZ13XsvMjIS77//Pj755BP4+/vDxcUFcrkcAwYMQGhoaJ3P4hiGgUAgqHNQvuq2f99XPVWkvmeer7pPT0+vUSM/pVIpbty4gcjISMTHx+Phw4fIyspCWVkZ5HI5dHR0YG5uDgcHB3Tt2hVdunTBjBkzwOfzYW9vj5MnTyoWLG/Mlz8WCxja0QK7prg1+L2oEgUf0Ti7op40euAGSy5B1Y0/kRd1pMbtHh4eqKqqQkZGBoqKiqCtrQ2ZTAapVAqGYRQbvmppaUFXV1dxFtayZUuYmprC0tISVlZWsLW1hY2NDbZv346CggKcOXPmlSMD/fz8kJaWhpMnT77yoHr58mWMGzcOQqEQe/furTH9YdSoUfj777/B4XAgFovBMAx4Bi1hs2Av5KyGB582l43rnw+s02jAixcvYuTIkZg3bx6GDx+OMWPGgMfjwcTEBLdu3VJq9159iMVixdlkXYLyTfdVVVUpvrgoK0yrN06uHiUcHR2Ne/fu4dmzZ8jLy6vx5QkAhg8fjgVLVmBpVBXEsoYf/uvz/1fdUPARjbP4WIJSuvEq7oaj8NyWGrfZ29vD2NhYsdN5QkICPD09MWzYMJiZmYHH4ym6zlgs1iv/LBaLsWXLFjAMA39/f/D5fMX9DMNg165d8Pb2RnJyMo4dO4atW7dCX1+/VntisRg//PADoqOj4ebmhjVr1kBbW1vxGOBFKK5du1ZxgGSxWBg9ejTuGrtDbtkJaMAZCiOXQ5YWj8E6z9ChQwd06tQJ1tbWimB+2XsPDw/HZ599hqlTp8LMzAybNm2Cubk5iouLsXv3bri7u7/2M3vVn+vz2Lfdhlwuh0AgUARhZWWl4iy/OmDrG6xcLveVoXjr1i2kp6fX+H9jZmYGC68pKGvdFyxuw0Orrmf06oiCj2icGftvIjw5r9HttBRkwyjxCO7du4fi4mLIZDKMGzcOenp6imtsZWVliIqKgrm5OVxdXWuEV/Vj/vvn6uXJ+Hy+4jn/vr+8vBxRUVGKA6uHhwf09fVrtZeXl4e7d+8CAFxcXNCyZcsaj6moqMDjx49RUlLy0vdnZO+CFhMCwHB49f9wpGLkHFoBcW5KjZvbtGkDAwODV7730tJSZGdnw8TEBBKJBGVlZdDV1UVVVRVMTExgbGz8xs/v33+uz2PVoY3/qk+4Vv/9321JJJJau1a0aNECA77ch7jCxq+T+rpruOqs6QyBIkRJDPnK+Wff370ntv40GwDw8OFDHDt2DP7+/rWmEZSVleHjjz9GXl4eQkJCYGJi8so2CwoKMHz4cEyYMAE7dux4adflwYMHcfPmTVRWVkJLSwv9+/fHt99+qzgAVlVVYcyYMUhMTMSHH36IQ4cO1bhOdujQIXzzzTdITU2Fk5MTfvvtN+zbtw+nT59WPMbY2Bi5SbH4MyGnYaP+PuiO81k98fvv/ws+Ho+HpKSkNw7T379/P6ZPn461a9fi3LlzuHPnDjZs2ICVK1eid+/eOHPmTLNeIeVVgVn9ZaWwsBDFxcUoLCxEUVERiouLUVRUpLi9+rbi4mI8e/asxpQbU1NTtG/fHo+fZQIGrRtda5lQ0ug2VIGCj2gcZ0tDaHNzGz0529nKQPF3JycnrF69+qWPNTQ0xKlTp7By5Ur06tULp0+fRqdOtacKZGVlYfDgwRg7dizWrVv3ytGEly9fRmXlizl2XC4XgYGB0NLSwtdff41Dhw5h9uzZ0NfXx7Vr1+Du7g4AEAqF+PLLL7Fnzx5UVVVhyJAhuHjxItq1awe5XI7jx48r2tfT08OePXugra2tGLLekHleM70MVQAAHpdJREFUE3vsR0hIiGLPPYlEgl27dmHx4sWvbgTA1KlTUVVVBV9fX2zcuBEZGRkICgrC5cuXMWTIELRt2xa3bt2Cqanpa9tRVwzDoKysDEVFRbV+qsPsVT/Vu0yYmJigZcuWNX6sra3RuXPnGrdFR0dj6dKlWLVqFRYtWqQY8KSs7n5DfgN6A9QAdXUSjaOMUZ0NvbB/4MAB+Pv7Y+/evRg5cqTi9pSUFAwePBjz58/HjAWfvXbZKDMzMxQWFqJNmzZYsmQJVqxYAYZh0L59e9y7dw9z5sxBcHAw2Gw2Hj9+DD8/P1y6dAl6enqYNWsW1q1bpzjrunXrFkaMGIGKigps2LAB/v7+6NKlC27evFkjeO9kliA4MgURD/PBAiB8ycoeA5zMsMDLscYQ9+DgYPj6+sLd3R0MwyAmJgb29vaIi4ursb7py2zduhXLli3Dpk2bEBAQgC5duuDMmTNwc3NDbm4u/vnnH3h6etbr81cmmUyG0tLSeodXcXExdHV1FeH0shB72U+LFi2UNqldGQO86BofIU2MKodyR0dHY8KECVi8eDH8/f1x9+5dDB8+HLO/WIts4y5vXDYq6a9tmDthGD7++GOMGTMG586dU3SL3bhxA7169cKJEyewcuVKPHr0CA4ODlizZg0mT56saE8ul2PevHnYs2cPvLy8cPbsWejq6uLixYtwcHB46QR5ACisECEkPhPJOeUoE0pgyOfB2coAE1xfvZbjunXr8Nlnn0FfXx9nzpzB+PHjIZVK8d1332HVqlWv/azWr1+Pr776CmvXrsU333yDTz75BHv27MG4ceNw9uxZbN68+Y1nkG8ilUoVXYR1Da+ioiKUlZXBwMCgRjjVJcRatGihGImpKqr88qcOKPiIRlL15N2MjAx88MEHsLCwQHx8PCatDsbfz/Xq1Z3Iz7xVa1/ADh06IDc3F6WlpfDy8sL27dtrdavevn0bw4YNQ2lpKfbt24eJEyc2+H00hEwmw6BBgxAVFQUbGxvExcW9dnL/119/jXXr1mH58uXYtGkTNm7cCH9/f2zcuBErV66Et7c3jh07BolEUuN615uCq/qnsrISxsbGLw2p/2vvzuOiKvc/gH/OMAi4oFdcQBZxQZEMr+AKirjB1RQJNVBMTTREUSTzBUKmt1wyt0zBJfeLGkqiKEsqIYy5BuYCEkI4iAuCNLFcloF5fn94mV8ECswMDHC+77+Ss8x3CPjMOed5vs/bgqxTp04qXUi3qdE8PkJ4KOTGY6yPeohSNbVrOn/+PGbMmAHjsbMhHPpBtduHdWkjAHJi9qAgKbLaSD6O4+Dl5YXNmzfXOoHd29sbe/fuxahRoxAVFVVjn6Z06dIlTJ06FeXl5fD398fGjRsBQN60+68BtnfvXly+fBkDBw7E/fv3YWNjAy0tLflyTRzHQUNDo86rrdqCTFdXt1UPlnkTdX/4UycKPsJr8zccRPyfeoBQs0kb9J45cwaLFy/G1wdC8eX1QoU6pGhyDLmhgfjz93vyr2loaEAkEskHtVR58OABHBwckJ+fjwMHDmDOnDlKv4e3YYyhuLi4ziuvV69eISEhAX/88QcEAgE0NTXBGKs1oJKSknDv3j0MGDAAqamp2LdvH6ytrVFZWYlp06ZBIpFAJBLVujIGqR316iSEZ8RiMaytrXHkfBwuZJQ1eOCGoo4cOYLVq1cjMjISe5NlSvUM1cpNhY0sGW3atEFeXh7S0tLwwQcfyEeYymQy+Pr6Yvfu3RgxYgSio6MbtDZc1QjEhtw6/PsIxPpcdT1+/BheXl4oLS3F8uXLsXPnzlrrqWq5ZmFhgczMTIjFYnTu3BkymQz/+te/EBsbiz179uDjjz9u+DeUp2h1BkJ4gjGGqVOnYuTIkfIBFooM3Giob775Bjt27MDFixehZ2iqsgEGOVkZWLBgARITEzFq1CjExcUhJSUFDg4OyM3NRXBwMJydnRscXn8fgVjfQRyKjkB0cXFBeHg49PT0cPPmTfTpU3PE4KxZs3Dq1Cl5J5zMzEz5PMV169bhiy++wIcffoijR48q/H3lG0VH7bZUFHyEl8LCwrB27VrcuXOnWsf6xsIYw7///W+cPHkSly5dgomJicqGlLfPjMe9U9vl8+U6duyITp06QSwWQ0tLCzo6OigoKJA3pG5ogDX1CMRffvkFY8eORVFRERYtWoT9+/fX2MfZ2RkXLlyAlpYWLC0tcf36dfm26OhoODs7o1+/frh+/bpan2O2NE3x4a85oOAjvPPnn3/CwsICoaGhGDVqVKO/XtXtxoSEBPz444/yEYyqmkRcnnYVuRFb5csRCQQCCAQCrFq1Ch999FGLHYHo7u6OEydOoGPHjvj5559rjE6turUJALNnz652hZeVlYVhw4ahpKQE165dq7VhAOEv/g1lIrwXGBiI9957r0lCr6KiQn4LMi4urtqw/YLSCpW8xiQnF9y8eRPm5uYAXo/szMnJwcaNG2FmZgY9Pb0WF3oAcPz4cXmv0YEDB8Ld3b1aH8qYmBjY2NiA4zj85z//webNmwG8/qBhaGiI7OxsWFpaYtCgQQgJCVHLeyDNEwUf4ZUbN27gzJkz8j+Sjam0tBQzZ85ETk4OLl68KG+wXEVVPUO5ilJMnz4d6enp2LJlC+Lj49G5c2eVnFvdBg4cCIlEgkWLFuHEiRPQ1dVFYmKifHtcXBwGDx4MoVCI1atX46uvvkKPHj0QGBgIoVAIkUgEX19fzJ07F0uWLFHjOyHNCd3qJLwhlUoxZMgQ+Pv7Y9asWY36WkVFRXB2dkbnzp0REhJS63NEVTzj00AlXsUdQ+/y33Hx4sUW27+yPtLT0zFixAi8evUKLi4uCAsLA8dxkMlksLKywoMHD+RLK5mZmSEtLU1+7JkzZ+Dq6opBgwbh6tWrKmv9RVomuuIjvPHNN99AX18fbm5ujfo6+fn5mDBhAnr16oWTJ0++cfDMDGsjpV+roqISq93GIikpqVWHHgD07dsXeXl58PHxwZkzZ+SNuAUCAaZMmVJtwdWMjAwUFBTI/121dmFmZiYMDQ2Rnp5e20sQnqArPsILmZmZGDp0KG7duoXevXs32us8f/4cDg4OmDRpEjZv3vzGFRaqKNM2CjIZ7Pvp4YiHjWLFtmBVg1dycnIwbtw4/PTTTzX2OXfuHJycnAC87k0ZlpiN5Kd/IOanBPz58jlmOtjii/mTWtVoRVI/FHyk1WOMYfLkyRgzZgz8/f0b7XUyMzMxceJEeHh4wN/fv87QA/jdNkoVAgICsGnTJgCvB/UIBAL5lZ+JiQkirt5F0JX0Wht/y6RlEAqFmDiwB5aM6YtBxvz9PvIN3eokrd6pU6eQnZ2NlStXNtprJCcnw87ODitXrsTq1avrFXoAMMi4EwInm0NHs2G/iq/bRpnzOvQAYPz48fIRq4wxyGQyBAUFQVdXF4Xd/4npe0S49DAHZRWyGs9SBZpakHEa+PHBc7h+dx0hNx6r4R0QdaCFaEmrJpFI4Ovrix9++KHRJmLfvn0bU6dOxfbt2zF79uwGH6/MYq98l5aWBn19fbx8+RIymQyVlZVYtmwZAg5FISS5BBWsHh8oOAFKpTJ8GZkCAPR95QG61UlaNS8vLwDAnj17GuX8cXFxcHV1xaFDhzBlyhSlzvW2tlFaGhzAca2qbZQqMcaQn5+Pu3fv4pMNO5E/eC4Emg0fudlGAIR52dL3t5Wj4COt1rVr1zBz5kwkJyfXmEOnChEREVi4cCFOnz6NMWPGqOy8yRliOPt+BQnaYoClNazftWiVbaMay8f/+QWXUl6AoX63m/+KyWToqSFBwsYPG6Ey0lzQrU7SKkmlUnh6emLHjh2NEnohISFYtWoVoqKiMGSI6hbj3L59O/z8/NCrVy8kXr4MExMTlZ2bD/KKyhCflqtQ6AEAJxBALG2Psf+aitioc7xcp48P6P8qaZW2bt0KY2PjGiuUq0JQUBBWr16N2NhYlYVeTk4OLC0tsWrVKnz22WdIS0uj0FNAWGK20ufQ0mqDB/9tDxMTE7x48UIFVZHmhoKPtDoZGRnYtm0bgoOD6z26sj4YY1i/fj127NgBkUgECwsLlZx3165dMDIyQnFxMdLT07F27VqVnJePUl8UKNUJBwDKKwFXz0/Qtm1bmJqaIi4uTkXVkeaCgo+0KowxLFmyBH5+fjA1NVXpeT/99FOcOnUKIpFIJefOy8vD4MGDsWLFCvj7+yMjIwO9evVSvlgeU1Xj75IKIDU1FU5OTpgwYUKT9HYlTYeCj7QqJ0+exIsXL7BixQqVnbOyshILFy7EtWvXcOXKFRgYGCh9zj179qBHjx6QSCRIS0vDl19+qYJKiaoaf+tqa0IgEODUqVPYvn07AgICMHXqVMhkyl1NkuaBgo+0Gvn5+Vi5ciX279+vsjl7ZWVlcHNzQ1ZWFi5duqT0qgf5+fkYMmQIvL294evri8zMzFpXGSeKMdfXhZZQuT9r2kIBzA06yP/t4+MDkUiE2NhY9OnTB/n5+cqWSdSMgo+0Gv7+/pg+fTqGDx+ukvMVFxfDyckJMpkMFy5cUHol7wMHDsDAwAC5ublISUmh22eNQBWNvxmAGVbVz2NjY4OsrCwwxmBkZFRtxXfS8lDwkVZBJBIhKioKGzZsUMn5JBIJHBwc0KNHD4SGhkJLS/H5cxKJBMOHD4enpye8vb0hFovRv39/ldRJquvSXgtj+nWFomOamEyGAR1ltc6X7NKlC37//XeMHz8eo0aNwq5du5SslqgLBR9p8crLy+Hp6YmdO3eiY8eOSp8vJycH9vb2GDZsGA4ePAihUPHnRkeOHEH37t3x9OlT3Lt3D9u2bVO6PvJ2S+37Qluo2IrzWkIBYnZ8Ag0NDZiZmWHSpEnw8fFBUlISAEAgEOD8+fP48ssv4ePjAzc3N3ru1wJR8JEW7+uvv0afPn3g4uKi9LnEYjFGjx4NFxcXbN++XeEJzAUFBbCxscGCBQuwePFiZGVl4Z133lG6PlI3ZRp/fz71HXzh4wHGGNLT0xETE4Pdu3cjNTW12r4BAQG4dOkSzp49iwEDBlRb+480f9SyjLRojx49wsiRI5GUlKT0hO/U1FQ4ODjg008/xfLlyxU+T0hICBYuXIjOnTsjJiYGlpaWStVFFBNy47FCjb9lMhkGDRqEBw8eAAC0tbWRnJxc6zqOz549w9ChQ1FQUACRSIR//vOfjfV2iArRFR9psRhj8PLyQkBAgNKhl5SUhLFjx2L9+vUKh15RURHs7Owwd+5ceHh4IDs7m0JPjeaMMEXoxyPgaNEdWkIBtP822lNbKICWUABHi+4I/XiEfFUGgUCAQ4cOQVtbGzo6OjA2NoaZmRkCAwPx9+uEHj16QCwWY9iwYRgyZAgOHjzYVG+PKIMR0kIdO3aMDR48mEmlUqXOEx8fz7p27crCw8MVPsf333/PtLW1Wffu3dmdO3eUqoeoXl5hKdsbn85WfH+HLThyi634/g7bG5/O8gpL33jM8uXL2eHDhxljjO3YsYNpamoyExMTlpKSUuv+gYGBjOM49tFHHzXGWyAqRMFHWqS8vDzWvXt3dvv2baXOExkZybp27couX76s0PHFxcXM3t6ecRzHFi1axCorK5WqhzRfOTk5zMrKigkEArZ8+XImk8lq7HP+/HmmqanJLC0tWXFxsRqqJPVBz/hIi+Th4YH27dtj586dCp/j+++/x4oVK3Du3DmF5v6FhYVh7ty5aN++vcpXaSDN14EDB7B06VJ07twZ0dHRNZ7ricViDB06FOXl5bh+/ToGDBigpkrJG6k7eQlpqCtXrjAjIyNWUFCg8Dn27t3LDA0N2f379xt8bElJCZswYYL8thZd5fGPRCJhtra2jOM45uHhwSoqKqptLysrYzY2NkxDQ4MdP35cTVWSN6HgIy1KaWkp69+/v1LP4zZt2sR69erF0tPTG3xseHg4a9u2LdPT02M3btxQuAbSOpw4cYLp6OgwPT09dvXq1RrbV6xYwTiOY97e3mqojrwJBR9pUdatW8ecnZ0VOlYmkzE/Pz9mYWHBnj592qBjS0pKmKOjI+M4jn344Yd0lUfkioqK5HcAXF1dawy2Cg0NZUKhkA0bNoyVlZWpqUryV/SMj7QYv/32G2xtbXHnzh0YGxs36NjKykosXboUSUlJiI6Ohp6eXr2PvXDhAtzc3NCmTRucP38etra2DS2d8EBERATc3d2hoaGBsLAwTJgwQb7t0aNHGD58OAQCAW7dulXrnEDSdGgeH2kRGGNYvHgx1qxZ0+DQKy8vh7u7O9LS0hAbG1vv0CsvL8d7770HJycnODk5IS8vj0KPvFHVz8iYMWPg4OAAJycnlJWVAQDMzMzw7Nkz9OzZE+bm5jh79qyaq+U3Cj7SIhw9ehSFhYXw9vZu0HH//e9/4ezsjJKSEkRFRaFDhw51HwTIrwqr1uA7ceKEwu3LCH9oaWnh3LlzuHjxIhISEqCnp4eIiAgArzvAJCYmYv78+XBxcYGfn5+aq+UxNd9qJaROubm5rFu3biwxMbFBx0kkEjZ69Gg2Z84cVl5eXq9jysrK2LRp0xjHcWzGjBlKT44n/CWVStmsWbMYx3Fs/Pjx1eb1HT16lGloaLDRo0fTz5ga0DM+0uzNnz8fenp6DVrZIDc3F46OjrCxscG3335br6u12NhYeaPr8PBwjBs3TuGaCaly7do1TJs2DUVFRTh06BBmzZoFAHjw4AFsbW2ho6ODX375BUZGyq8lSOpJ3clLyNvExsYyExMTVlhYWO9jsrKyWP/+/dlnn31Wa3eNv5NKpczFxYVxHMfef/99+gROVK6iooItXLiQcRzHbGxsmEQiYYwxVlhYyCwsLFibNm1YTEyMmqvkDwo+0myVlJQwMzMzFhERUe9jfvvtN9azZ0+2bdu2eu0fFxfHOnbsyDp06EB/eEiju3PnDjMwMGBt2rRh+/fvl3/d3d2dcRzH1q1bp8bq+IOCjzRba9asYdOnT6/3/lV/VA4ePFjnvlKplLm6ujKO45iTkxPNryJNRiaTMR8fHyYQCJiVlRV7+fIlY4yx4OBgJhAImKOjI80TbWQUfKRZSklJYV26dGHZ2dn12v/q1ausW7du7PTp03XuKxKJ2D/+8Q/Wrl07FhkZqWyphCjk4cOHrGfPnkwoFLIdO3Ywxhi7desWa9euHTMyMmI5OTlqrrD1ovHZpNmRyWTw9PTE2rVrYWhoWOf+MTExcHZ2xrFjxzBjxoy3ntfd3R12dnYYMWIEXr16hcmTJ6uydELqzdzcHI8fP4afnx9WrlyJd955BwYGBsjOzoaWlhZ69uwJkUik7jJbJQo+0uwcPnwYZWVl8PLyqnPf06dPY968eTh37hwcHR3fuN/169fRtWtXnD17FmfPnkVUVBS0tLRUWTYhClm/fj0yMjJQUVEBU1NT7N69G2lpaZg0aRLs7e2xdetWdZfY+qj7kpOQv8rJyWHdunVjv/76a537fvfdd8zAwOCt+1ZWVrJ58+YxjuOYg4MDKykpUWW5hKjUpk2bmFAoZH369GEZGRls69atTCAQMGdnZ3rup0J0xUealZUrV2LevHkYNGjQW/fbtm0b1q9fj/j4+Dfue/v2bXTv3h2nTp3C6dOn8eOPP0JbW7sxyiZEJfz9/fHkyRO0a9cOZmZmyM3NxZUrVxATEwMzMzP88ccf6i6xdVB38hJS5eLFi8zU1JQVFRW9cR+ZTMYCAwOZubk5e/LkSa37VFZWMg8PD8ZxHBs3bhythE1apF27djFNTU1mbGzMEhISmLGxMWvbti27efOmuktr8eiKjzQLJSUl8PLyQlBQENq1a1frPjKZDMuWLUN0dDQSEhJq7XSRlJQEAwMDHD9+HCdPnkRsbCzatm3b2OUTonLe3t54/vw5DAwMYG9vjylTpmDUqFEYOXIkgoODUV5ejpkzZ+Lu3bvqLrXFoZZlpFkIDAxEeno6QkNDa90ulUqxYMECZGVlISIiAh07dqy2XSaTYcmSJdi/fz9Gjx6NyMhItG/fvilKJ6TRHTlyBIsXL0anTp3w/vvvY9++fejVqxfEYjEcHR0RGRmp7hJbFAo+onbJycmwt7fHvXv3YGBgUGN7aWkpPvjgA8hkMpw+fRo6OjrVtt+7dw+Ojo6QSCQ4cOAA3N3dm6p0QppMYWEhpkyZApFIBHNzczx8+BDA6xUhUlJSaqzxl1dUhrDEbKS+KEBBaQV0tYUw19fFTGsj6LXn94hmCj6iVjKZDHZ2dpgzZw4WL15cY3thYSGcnJygr6+PY8eOQVNTs9qxPj4+CAoKgo2NDaKioqCrq9uU5RPS5Hbv3o1ly5ZV+5qzszPCw8MBAHefSBB0JR3xabkAgLIKmXw/baEADIB9/65YMqYvBhl3arK6mxMKPqJW+/fvx+HDh/Hzzz/XWEEhLy8PkyZNgrW1NYKCgqChoSHflpycDAcHB7x69Qr79u3DvHnzmrp0QtRCKpUiJCQEn3/+ObKzs+Vfv3r1KjI1DLEhKhWlFZV42192jgO0hRoInGyOOSNMG7/oZoaCj6jNixcvYGlpidjYWLz77rvVtj19+lS+ivXGjRvBcZx8m6+vL7799lsMGzYM0dHR6NSJn59aCYmOjoarqyvKy8vRYfBkdBq7AFLG1X3g/+hoChA4eQDvwo+Cj6jNrFmzYGpqik2bNlX7ekZGBiZOnAhPT89qq1Q/fPgQDg4OePnyJYKDg+Hh4dHUJRPS7EilUkyd542UHg4QaDZ8nqqOpgZCPx4BSyP+fICk6QxELWJiYnDr1i2sWbOm2tfv378POzs7+Pn5VQu9VatWYeDAgdDX18fz588p9Aj5H01NTZhMWgQNBUIPAEorKhF8JV3FVTVvQnUXQPjj0aNHKC4uRr9+/bBkyRLs2bOn2hy7GzduYNq0adi5cyfc3Nzkx0ycOBHPnj1DcHAwPD091VU+Ic1SXlEZ4tNyoeitO8aAuN9y8aqojDejPemKjzSZr7/+GlZWVrC1tYW1tXW1ptKXL1+Gk5MTDh8+LA+9gIAAmJubQ09PD8+ePaPQI6QWYYnZde9UBw5AWJLy52kpKPhIkxGLxWCM4ddff0VsbCyioqIAAOHh4Zg9ezZ++OEHTJ48GRkZGejduze2bNmCnTt3IjExEV26dFFz9YQ0T6kvCqpNWVBEaYUMqc8LVVRR80e3OkmTefbsmfy/i4uLERoaipycHAQEBCAmJgZWVlb4/PPPsWHDBrz77rt4+vQpunXrpsaKCWn+CkorVHQeqUrO0xJQ8JEmIxaLwXEcunTpgu+++w5paWlYtGgRdu3aBT09PfTt2xdisRjbtm3DihUr1F0uIS2CrrZq/ozramvWvVMrQcFHVKauFkkVFRWYN28edu/ejS1btmDXrl3gOA6ffPIJvL29YWFhgSdPnkBfX1/db4WQFsNcXxdawhdK3e7UFgpgbtBBhVU1bzSPjyitvi2SvMb0gaVhR/j6+uLy5cvIyMhAWVkZAGDgwIG4f/++OsonpEXLKyqD7eaflAo+LaEA1/zG8WZUJ13xEaWE3Hj81hZJpf/7ZbyYkoP4tFwY595Gyf1EAJCHHsdxePDgARISEmBnZ9dktRPSGnRpr4Ux/bri0sOct7YpexOOA8b278qb0AMo+IgSXofeQ5RI6/6kyRhQKpUhvYMlzAZxuLZnLQwNDWFvb48BAwagd+/eGDx4cBNUTUjrs9S+L0SP8lAirWzwsdpCDSyx79sIVTVfdKuTKOTuEwncvruh0C+agFUgZL41bMxrLiRLCFFMQz6IVuFrr06ax0cUEnQlHaUVDQ89AGACIY798kLFFRHCb3NGmCJw8gDoaGqAq6NPNce97tHJx9AD6FYnUYC8RZKC9wr42CKJkKYwZ4QpLI06IfhKOuJ+ywWH/3/ODvz/YLOx/btiiX1fXjWm/isKPtJgqmyR5GnXR/mCCCFylkadsHfOELwqKkNYUjZSnxeioFQKXW1NmBt0wAwrWoGdgo80GLVIIqT502uvRR8s34Ce8ZEGoxZJhJCWjIKPNBi1SCKEtGQUfKTBXrdIUu5Hh28tkgghzQcFH2mwGdbKz79jAGZY0Tw+QkjTo+AjDVbVIqmuuUJvwscWSYSQ5oOCjyhkqX1faAs1FDqWjy2SCCHNBwUfUcgg404InGwOHc2G/Qi9bpFkztuJs4QQ9aN5fERhVa2O3rY6QxWOe32lFzjZnJctkgghzQc1qSZKu5ctoRZJhJAWg4KPqAy1SCKEtAQUfIQQQniFBrcQQgjhFQo+QgghvELBRwghhFco+AghhPAKBR8hhBBeoeAjhBDCKxR8hBBCeIWCjxBCCK9Q8BFCCOEVCj5CCCG8QsFHCCGEVyj4CCGE8AoFHyGEEF6h4COEEMIrFHyEEEJ4hYKPEEIIr1DwEUII4RUKPkIIIbxCwUcIIYRXKPgIIYTwCgUfIYQQXvk/WyWSFmfS/+AAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "top ='asyn120to140.lig41.pdb'\n",
    "traj ='test.dcd'\n",
    "desc = {'hydrophobicContacts': 6.0,'hbondContacts': 4.0,'chargedContacts':6.0,'aromaticStacking': 6.0}\n",
    "state = ['hydrophobicContacts','hbondContacts','chargedContacts','aromaticStacking']\n",
    "\n",
    "nLigandChains = 1\n",
    "nProteinChains = 1\n",
    "\n",
    "tn = TransitionNetworks(top=top, traj=traj, desc=desc,\n",
    "                        nLigandChains=nLigandChains,nProteinChains=nProteinChains,state=state,\n",
    "                        h5File='all.hdf5')\n",
    "\n",
    "tn.generateNetwork(minPopulation=0.0, minTransition=0.0, gexfName=\"all.gexf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "corr = tn.correlationCoefficients()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'hydrophobicContacts6.0+hydrophobicContacts6.0': nan,\n",
       " 'hydrophobicContacts6.0+hbondContacts4.0': nan,\n",
       " 'hydrophobicContacts6.0+chargedContacts6.0': nan,\n",
       " 'hydrophobicContacts6.0+aromaticStacking6.0': nan,\n",
       " 'hbondContacts4.0+hbondContacts4.0': 1.0,\n",
       " 'hbondContacts4.0+chargedContacts6.0': nan,\n",
       " 'hbondContacts4.0+aromaticStacking6.0': 0.1478936755661047,\n",
       " 'chargedContacts6.0+chargedContacts6.0': nan,\n",
       " 'chargedContacts6.0+aromaticStacking6.0': nan,\n",
       " 'aromaticStacking6.0+aromaticStacking6.0': 1.0}"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "corr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1004 [0] [2] [0]\n",
      "1006 [0] [2] [0]\n",
      "102 [0] [4] [0]\n",
      "1028 [0] [1] [0]\n",
      "1034 [0] [1] [1]\n",
      "1041 [0] [2] [1]\n",
      "1056 [0] [1] [0]\n",
      "1059 [0] [1] [0]\n",
      "1061 [0] [3] [1]\n",
      "1063 [0] [1] [0]\n",
      "1070 [0] [1] [0]\n",
      "1074 [0] [3] [0]\n",
      "1080 [0] [1] [0]\n",
      "1088 [0] [1] [0]\n",
      "1097 [0] [1] [0]\n",
      "1101 [0] [2] [1]\n",
      "1109 [0] [3] [0]\n",
      "120 [0] [1] [0]\n",
      "123 [0] [3] [0]\n",
      "130 [0] [1] [0]\n",
      "134 [0] [1] [0]\n",
      "141 [0] [3] [0]\n",
      "144 [0] [1] [1]\n",
      "16 [0] [3] [1]\n",
      "17 [0] [1] [0]\n",
      "186 [0] [2] [0]\n",
      "197 [0] [2] [2]\n",
      "199 [0] [2] [0]\n",
      "20 [0] [2] [2]\n",
      "202 [0] [1] [1]\n",
      "203 [0] [1] [2]\n",
      "205 [0] [1] [1]\n",
      "207 [0] [2] [1]\n",
      "21 [0] [3] [0]\n",
      "211 [0] [2] [2]\n",
      "220 [0] [1] [1]\n",
      "222 [0] [2] [0]\n",
      "229 [0] [3] [1]\n",
      "235 [0] [1] [0]\n",
      "252 [0] [1] [0]\n",
      "253 [0] [4] [0]\n",
      "259 [0] [1] [0]\n",
      "26 [0] [3] [0]\n",
      "270 [0] [1] [1]\n",
      "288 [0] [2] [1]\n",
      "291 [0] [1] [0]\n",
      "296 [0] [1] [1]\n",
      "301 [0] [2] [0]\n",
      "305 [0] [2] [0]\n",
      "308 [0] [2] [0]\n",
      "337 [0] [1] [0]\n",
      "339 [0] [1] [0]\n",
      "34 [0] [1] [0]\n",
      "344 [0] [1] [0]\n",
      "365 [0] [1] [1]\n",
      "369 [0] [3] [0]\n",
      "378 [0] [1] [0]\n",
      "380 [0] [1] [0]\n",
      "382 [0] [4] [1]\n",
      "391 [0] [2] [0]\n",
      "393 [0] [1] [1]\n",
      "41 [0] [2] [0]\n",
      "426 [0] [5] [0]\n",
      "427 [0] [1] [0]\n",
      "435 [0] [4] [0]\n",
      "445 [0] [2] [1]\n",
      "446 [0] [2] [0]\n",
      "448 [0] [1] [0]\n",
      "449 [0] [2] [1]\n",
      "450 [0] [1] [0]\n",
      "460 [0] [2] [1]\n",
      "467 [0] [1] [1]\n",
      "471 [0] [2] [0]\n",
      "473 [0] [1] [0]\n",
      "474 [0] [1] [1]\n",
      "491 [0] [1] [0]\n",
      "5 [0] [2] [1]\n",
      "511 [0] [2] [1]\n",
      "522 [0] [1] [0]\n",
      "527 [0] [2] [1]\n",
      "532 [0] [1] [0]\n",
      "535 [0] [1] [0]\n",
      "543 [0] [2] [1]\n",
      "55 [0] [2] [0]\n",
      "555 [0] [4] [0]\n",
      "579 [0] [1] [0]\n",
      "586 [0] [1] [0]\n",
      "594 [0] [3] [0]\n",
      "595 [0] [1] [0]\n",
      "600 [0] [1] [1]\n",
      "609 [0] [2] [1]\n",
      "618 [0] [1] [1]\n",
      "62 [0] [2] [1]\n",
      "626 [0] [2] [0]\n",
      "631 [0] [5] [0]\n",
      "633 [0] [1] [0]\n",
      "634 [0] [3] [0]\n",
      "649 [0] [2] [1]\n",
      "67 [0] [1] [1]\n",
      "676 [0] [1] [0]\n",
      "688 [0] [1] [0]\n",
      "693 [0] [2] [0]\n",
      "711 [0] [1] [2]\n",
      "717 [0] [3] [0]\n",
      "719 [0] [3] [1]\n",
      "721 [0] [1] [1]\n",
      "727 [0] [3] [1]\n",
      "747 [0] [1] [0]\n",
      "748 [0] [1] [0]\n",
      "750 [0] [3] [0]\n",
      "759 [0] [1] [1]\n",
      "760 [0] [1] [1]\n",
      "762 [0] [2] [1]\n",
      "765 [0] [3] [0]\n",
      "77 [0] [1] [0]\n",
      "774 [0] [2] [0]\n",
      "775 [0] [4] [1]\n",
      "776 [0] [1] [0]\n",
      "777 [0] [2] [0]\n",
      "796 [0] [2] [2]\n",
      "798 [0] [1] [0]\n",
      "818 [0] [4] [0]\n",
      "821 [0] [1] [0]\n",
      "831 [0] [3] [1]\n",
      "851 [0] [1] [1]\n",
      "866 [0] [1] [0]\n",
      "873 [0] [1] [2]\n",
      "887 [0] [3] [2]\n",
      "89 [0] [1] [0]\n",
      "891 [0] [1] [0]\n",
      "895 [0] [1] [0]\n",
      "899 [0] [1] [0]\n",
      "903 [0] [1] [1]\n",
      "904 [0] [1] [1]\n",
      "909 [0] [2] [0]\n",
      "910 [0] [1] [0]\n",
      "919 [0] [1] [1]\n",
      "921 [0] [3] [1]\n",
      "931 [0] [1] [1]\n",
      "940 [0] [2] [1]\n",
      "96 [0] [1] [1]\n",
      "963 [0] [1] [0]\n",
      "964 [0] [3] [0]\n",
      "969 [0] [1] [0]\n",
      "973 [0] [2] [1]\n",
      "985 [0] [1] [2]\n",
      "997 [0] [2] [1]\n"
     ]
    }
   ],
   "source": [
    "with h5.File('all.hdf5', 'r') as f:\n",
    "    #print(list(f))\n",
    "    #print(list(f['hydrophobicContacts4.0']['1009']))\n",
    "    for frame,frame, frame in zip(f['hydrophobicContacts6.0'],f['hbondContacts4.0'],f['aromaticStacking6.0']):\n",
    "        if 0 not in f['hydrophobicContacts6.0'][frame] or 0 not in f['hbondContacts4.0'][frame]:\n",
    "            print(frame, list(f['hydrophobicContacts6.0'][frame]), list(f['hbondContacts4.0'][frame]), list(f['aromaticStacking6.0'][frame]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tn._intermolecularContactPairs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tn._aromaticStacking()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tn._hydrophobicContacts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tn._chargedContacts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tn._hbondContacts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tn._polarContacts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#with h5.File('test.hdf5', 'r') as f:\n",
    "#    for frame in range(1000):\n",
    "#        if f['hbondContacts3.5'][str(frame)][0] != 0:\n",
    "#            print(frame, f['hbondContacts3.5'][str(frame)][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tn.generateNetwork(minPopulation=0.01, minTransition=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#aromatics = {'TYR': ['CG', 'CD1', 'CD2', 'CE1', 'CE2', 'CZ']}\n",
    "#\n",
    "#proteinAromaticCindex = []\n",
    "#tyr = []\n",
    "#ctyr = 0\n",
    "#for atom in tn.universe.atoms:\n",
    "#    if atom.resname == 'TYR':\n",
    "#        if atom.name in aromatics['TYR']:\n",
    "#            if ctyr < 5:\n",
    "#                tyr.append(atom.index)\n",
    "#                ctyr +=1\n",
    "#            else:\n",
    "#                tyr.append(atom.index)\n",
    "#                proteinAromaticCindex.append(tyr)\n",
    "#                tyr = []\n",
    "#               ctyr = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ligandAromaticC = tn.universe.atoms[304:314]\n",
    "#ligandAromaticC.center_of_mass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ligandAromaticC.guess_bonds()\n",
    "#print(ligandAromaticC.bonds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ligand = tn.universe.atoms[nAtomsPerProteinChain:]\n",
    "#ligand.guess_bonds()\n",
    "#\n",
    "#elements = [atom.type for atom in ligand]\n",
    "#\n",
    "#pos = 0\n",
    "#neg = 0\n",
    "#for residue in tn.universe.residues:\n",
    "#    if residue.resname == 'LIG':\n",
    "#        for atom in residue.atoms:\n",
    "#            element = atom.type\n",
    "#            atomIdx = atom.index\n",
    "#            \n",
    "#            if (element == 'N'):\n",
    "#                bondingDegree = 0\n",
    "#                for bond in ligand.bonds:\n",
    "#                    if (atomIdx in ligand.indices):\n",
    "#                        bondingDegree += 1\n",
    "#                \n",
    "#                if (bondingDegree == 4):\n",
    "#                    pos += 1\n",
    "#            \n",
    "#            elif (element == 'O'):  \n",
    "#                bondingDegree = 0\n",
    "#                for bond in ligand.bonds:\n",
    "#                    if (atomIdx in ligand.indices):\n",
    "#                        bondingDegree += 1\n",
    "#                        \n",
    "#                if (bondingDegree == 1):\n",
    "#                    neg -= 1\n",
    "#\n",
    "#charge = pos + neg\n",
    "#print('Charge of ligand: ', charge)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}