Upload 48 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+img/overview.png filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Arne Schneuing, Yuanqi Du, Charles Harris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

analysis/SA_Score/README.md

@@ -0,0 +1 @@
+Files taken from: https://github.com/rdkit/rdkit/tree/master/Contrib/SA_Score

analysis/SA_Score/fpscores.pkl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10dcef9340c873e7b987924461b0af5365eb8dd96be607203debe8ddf80c1e73
+size 3848394

analysis/SA_Score/sascorer.py

@@ -0,0 +1,173 @@
+#
+# calculation of synthetic accessibility score as described in:
+#
+# Estimation of Synthetic Accessibility Score of Drug-like Molecules based on Molecular Complexity and Fragment Contributions
+# Peter Ertl and Ansgar Schuffenhauer
+# Journal of Cheminformatics 1:8 (2009)
+# http://www.jcheminf.com/content/1/1/8
+#
+# several small modifications to the original paper are included
+# particularly slightly different formula for marocyclic penalty
+# and taking into account also molecule symmetry (fingerprint density)
+#
+# for a set of 10k diverse molecules the agreement between the original method
+# as implemented in PipelinePilot and this implementation is r2 = 0.97
+#
+# peter ertl & greg landrum, september 2013
+#
+
+
+from rdkit import Chem
+from rdkit.Chem import rdMolDescriptors
+import pickle
+
+import math
+from collections import defaultdict
+
+import os.path as op
+
+_fscores = None
+
+
+def readFragmentScores(name='fpscores'):
+    import gzip
+    global _fscores
+    # generate the full path filename:
+    if name == "fpscores":
+        name = op.join(op.dirname(__file__), name)
+    data = pickle.load(gzip.open('%s.pkl.gz' % name))
+    outDict = {}
+    for i in data:
+        for j in range(1, len(i)):
+            outDict[i[j]] = float(i[0])
+    _fscores = outDict
+
+
+def numBridgeheadsAndSpiro(mol, ri=None):
+    nSpiro = rdMolDescriptors.CalcNumSpiroAtoms(mol)
+    nBridgehead = rdMolDescriptors.CalcNumBridgeheadAtoms(mol)
+    return nBridgehead, nSpiro
+
+
+def calculateScore(m):
+    if _fscores is None:
+        readFragmentScores()
+
+    # fragment score
+    fp = rdMolDescriptors.GetMorganFingerprint(m,
+                                               2)  # <- 2 is the *radius* of the circular fingerprint
+    fps = fp.GetNonzeroElements()
+    score1 = 0.
+    nf = 0
+    for bitId, v in fps.items():
+        nf += v
+        sfp = bitId
+        score1 += _fscores.get(sfp, -4) * v
+    score1 /= nf
+
+    # features score
+    nAtoms = m.GetNumAtoms()
+    nChiralCenters = len(Chem.FindMolChiralCenters(m, includeUnassigned=True))
+    ri = m.GetRingInfo()
+    nBridgeheads, nSpiro = numBridgeheadsAndSpiro(m, ri)
+    nMacrocycles = 0
+    for x in ri.AtomRings():
+        if len(x) > 8:
+            nMacrocycles += 1
+
+    sizePenalty = nAtoms**1.005 - nAtoms
+    stereoPenalty = math.log10(nChiralCenters + 1)
+    spiroPenalty = math.log10(nSpiro + 1)
+    bridgePenalty = math.log10(nBridgeheads + 1)
+    macrocyclePenalty = 0.
+    # ---------------------------------------
+    # This differs from the paper, which defines:
+    #  macrocyclePenalty = math.log10(nMacrocycles+1)
+    # This form generates better results when 2 or more macrocycles are present
+    if nMacrocycles > 0:
+        macrocyclePenalty = math.log10(2)
+
+    score2 = 0. - sizePenalty - stereoPenalty - spiroPenalty - bridgePenalty - macrocyclePenalty
+
+    # correction for the fingerprint density
+    # not in the original publication, added in version 1.1
+    # to make highly symmetrical molecules easier to synthetise
+    score3 = 0.
+    if nAtoms > len(fps):
+        score3 = math.log(float(nAtoms) / len(fps)) * .5
+
+    sascore = score1 + score2 + score3
+
+    # need to transform "raw" value into scale between 1 and 10
+    min = -4.0
+    max = 2.5
+    sascore = 11. - (sascore - min + 1) / (max - min) * 9.
+    # smooth the 10-end
+    if sascore > 8.:
+        sascore = 8. + math.log(sascore + 1. - 9.)
+    if sascore > 10.:
+        sascore = 10.0
+    elif sascore < 1.:
+        sascore = 1.0
+
+    return sascore
+
+
+def processMols(mols):
+    print('smiles\tName\tsa_score')
+    for i, m in enumerate(mols):
+        if m is None:
+            continue
+
+        s = calculateScore(m)
+
+        smiles = Chem.MolToSmiles(m)
+        print(smiles + "\t" + m.GetProp('_Name') + "\t%3f" % s)
+
+
+if __name__ == '__main__':
+    import sys
+    import time
+
+    t1 = time.time()
+    readFragmentScores("fpscores")
+    t2 = time.time()
+
+    suppl = Chem.SmilesMolSupplier(sys.argv[1])
+    t3 = time.time()
+    processMols(suppl)
+    t4 = time.time()
+
+    print('Reading took %.2f seconds. Calculating took %.2f seconds' % ((t2 - t1), (t4 - t3)),
+          file=sys.stderr)
+
+#
+#  Copyright (c) 2013, Novartis Institutes for BioMedical Research Inc.
+#  All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+#       copyright notice, this list of conditions and the following
+#       disclaimer in the documentation and/or other materials provided
+#       with the distribution.
+#     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+#       nor the names of its contributors may be used to endorse or promote
+#       products derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#

analysis/docking.py

@@ -0,0 +1,197 @@
+import os
+import re
+import tempfile
+import numpy as np
+import torch
+from pathlib import Path
+import argparse
+import pandas as pd
+from rdkit import Chem
+from tqdm import tqdm
+
+try:
+    import utils
+except ModuleNotFoundError as e:
+    print(e)
+
+
+def calculate_smina_score(pdb_file, sdf_file):
+    # add '-o <name>_smina.sdf' if you want to see the output
+    out = os.popen(f'smina.static -l {sdf_file} -r {pdb_file} '
+                   f'--score_only').read()
+    matches = re.findall(
+        r"Affinity:[ ]+([+-]?[0-9]*[.]?[0-9]+)[ ]+\(kcal/mol\)", out)
+    return [float(x) for x in matches]
+
+
+def smina_score(rdmols, receptor_file):
+    """
+    Calculate smina score
+    :param rdmols: List of RDKit molecules
+    :param receptor_file: Receptor pdb/pdbqt file or list of receptor files
+    :return: Smina score for each input molecule (list)
+    """
+
+    if isinstance(receptor_file, list):
+        scores = []
+        for mol, rec_file in zip(rdmols, receptor_file):
+            with tempfile.NamedTemporaryFile(suffix='.sdf') as tmp:
+                tmp_file = tmp.name
+                utils.write_sdf_file(tmp_file, [mol])
+                scores.extend(calculate_smina_score(rec_file, tmp_file))
+
+    # Use same receptor file for all molecules
+    else:
+        with tempfile.NamedTemporaryFile(suffix='.sdf') as tmp:
+            tmp_file = tmp.name
+            utils.write_sdf_file(tmp_file, rdmols)
+            scores = calculate_smina_score(receptor_file, tmp_file)
+
+    return scores
+
+
+def sdf_to_pdbqt(sdf_file, pdbqt_outfile, mol_id):
+    os.popen(f'obabel {sdf_file} -O {pdbqt_outfile} '
+             f'-f {mol_id + 1} -l {mol_id + 1}').read()
+    return pdbqt_outfile
+
+
+def calculate_qvina2_score(receptor_file, sdf_file, out_dir, size=20,
+                           exhaustiveness=16, return_rdmol=False):
+
+    receptor_file = Path(receptor_file)
+    sdf_file = Path(sdf_file)
+
+    if receptor_file.suffix == '.pdb':
+        # prepare receptor, requires Python 2.7
+        receptor_pdbqt_file = Path(out_dir, receptor_file.stem + '.pdbqt')
+        os.popen(f'prepare_receptor4.py -r {receptor_file} -O {receptor_pdbqt_file}')
+    else:
+        receptor_pdbqt_file = receptor_file
+
+    scores = []
+    rdmols = []  # for if return rdmols
+    suppl = Chem.SDMolSupplier(str(sdf_file), sanitize=False)
+    for i, mol in enumerate(suppl):  # sdf file may contain several ligands
+        ligand_name = f'{sdf_file.stem}_{i}'
+        # prepare ligand
+        ligand_pdbqt_file = Path(out_dir, ligand_name + '.pdbqt')
+        out_sdf_file = Path(out_dir, ligand_name + '_out.sdf')
+
+        if out_sdf_file.exists():
+            with open(out_sdf_file, 'r') as f:
+                scores.append(
+                    min([float(x.split()[2]) for x in f.readlines()
+                         if x.startswith(' VINA RESULT:')])
+                )
+
+        else:
+            sdf_to_pdbqt(sdf_file, ligand_pdbqt_file, i)
+
+            # center box at ligand's center of mass
+            cx, cy, cz = mol.GetConformer().GetPositions().mean(0)
+
+            # run QuickVina 2
+            out = os.popen(
+                f'qvina2.1 --receptor {receptor_pdbqt_file} '
+                f'--ligand {ligand_pdbqt_file} '
+                f'--center_x {cx:.4f} --center_y {cy:.4f} --center_z {cz:.4f} '
+                f'--size_x {size} --size_y {size} --size_z {size} '
+                f'--exhaustiveness {exhaustiveness}'
+            ).read()
+
+            # clean up
+            ligand_pdbqt_file.unlink()
+
+            if '-----+------------+----------+----------' not in out:
+                scores.append(np.nan)
+                continue
+
+            out_split = out.splitlines()
+            best_idx = out_split.index('-----+------------+----------+----------') + 1
+            best_line = out_split[best_idx].split()
+            assert best_line[0] == '1'
+            scores.append(float(best_line[1]))
+
+            out_pdbqt_file = Path(out_dir, ligand_name + '_out.pdbqt')
+            if out_pdbqt_file.exists():
+                os.popen(f'obabel {out_pdbqt_file} -O {out_sdf_file}').read()
+
+                # clean up
+                out_pdbqt_file.unlink()
+
+        if return_rdmol:
+            rdmol = Chem.SDMolSupplier(str(out_sdf_file))[0]
+            rdmols.append(rdmol)
+
+    if return_rdmol:
+        return scores, rdmols
+    else:
+        return scores
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser('QuickVina evaluation')
+    parser.add_argument('--pdbqt_dir', type=Path,
+                        help='Receptor files in pdbqt format')
+    parser.add_argument('--sdf_dir', type=Path, default=None,
+                        help='Ligand files in sdf format')
+    parser.add_argument('--sdf_files', type=Path, nargs='+', default=None)
+    parser.add_argument('--out_dir', type=Path)
+    parser.add_argument('--write_csv', action='store_true')
+    parser.add_argument('--write_dict', action='store_true')
+    parser.add_argument('--dataset', type=str, default='moad')
+    args = parser.parse_args()
+
+    assert (args.sdf_dir is not None) ^ (args.sdf_files is not None)
+
+    args.out_dir.mkdir(exist_ok=True)
+
+    results = {'receptor': [], 'ligand': [], 'scores': []}
+    results_dict = {}
+    sdf_files = list(args.sdf_dir.glob('[!.]*.sdf')) \
+        if args.sdf_dir is not None else args.sdf_files
+    pbar = tqdm(sdf_files)
+    for sdf_file in pbar:
+        pbar.set_description(f'Processing {sdf_file.name}')
+
+        if args.dataset == 'moad':
+            """
+            Ligand file names should be of the following form:
+            <receptor-name>_<pocket-id>_<some-suffix>.sdf
+            where <receptor-name> and <pocket-id> cannot contain any 
+            underscores, e.g.: 1abc-bio1_pocket0_gen.sdf
+            """
+            ligand_name = sdf_file.stem
+            receptor_name, pocket_id, *suffix = ligand_name.split('_')
+            suffix = '_'.join(suffix)
+            receptor_file = Path(args.pdbqt_dir, receptor_name + '.pdbqt')
+        elif args.dataset == 'crossdocked':
+            ligand_name = sdf_file.stem
+            receptor_name = ligand_name[:-4]
+            receptor_file = Path(args.pdbqt_dir, receptor_name + '.pdbqt')
+
+        # try:
+        scores, rdmols = calculate_qvina2_score(
+            receptor_file, sdf_file, args.out_dir, return_rdmol=True)
+        # except AttributeError as e:
+        #     print(e)
+        #     continue
+        results['receptor'].append(str(receptor_file))
+        results['ligand'].append(str(sdf_file))
+        results['scores'].append(scores)
+
+        if args.write_dict:
+            results_dict[ligand_name] = {
+                'receptor': str(receptor_file),
+                'ligand': str(sdf_file),
+                'scores': scores,
+                'rmdols': rdmols
+            }
+
+    if args.write_csv:
+        df = pd.DataFrame.from_dict(results)
+        df.to_csv(Path(args.out_dir, 'qvina2_scores.csv'))
+
+    if args.write_dict:
+        torch.save(results_dict, Path(args.out_dir, 'qvina2_scores.pt'))

analysis/docking_py27.py

@@ -0,0 +1,27 @@
+import os
+import sys
+import glob
+
+
+def pdbs_to_pdbqts(pdb_dir, pdbqt_dir, dataset):
+    for file in glob.glob(os.path.join(pdb_dir, '*.pdb')):
+        name = os.path.splitext(os.path.basename(file))[0]
+        outfile = os.path.join(pdbqt_dir, name + '.pdbqt')
+        pdb_to_pdbqt(file, outfile, dataset)
+        print('Wrote converted file to {}'.format(outfile))
+
+
+def pdb_to_pdbqt(pdb_file, pdbqt_file, dataset):
+    if os.path.exists(pdbqt_file):
+        return pdbqt_file
+    if dataset == 'crossdocked':
+        os.system('prepare_receptor4.py -r {} -o {}'.format(pdb_file, pdbqt_file))
+    elif dataset == 'bindingmoad':
+        os.system('prepare_receptor4.py -r {} -o {} -A checkhydrogens -e'.format(pdb_file, pdbqt_file))
+    else:
+        raise NotImplementedError
+    return pdbqt_file
+
+
+if __name__ == '__main__':
+    pdbs_to_pdbqts(sys.argv[1], sys.argv[2], sys.argv[3])

analysis/metrics.py

@@ -0,0 +1,251 @@
+import numpy as np
+from tqdm import tqdm
+from rdkit import Chem, DataStructs
+from rdkit.Chem import Descriptors, Crippen, Lipinski, QED
+from analysis.SA_Score.sascorer import calculateScore
+
+from analysis.molecule_builder import build_molecule
+from copy import deepcopy
+
+
+class CategoricalDistribution:
+    EPS = 1e-10
+
+    def __init__(self, histogram_dict, mapping):
+        histogram = np.zeros(len(mapping))
+        for k, v in histogram_dict.items():
+            histogram[mapping[k]] = v
+
+        # Normalize histogram
+        self.p = histogram / histogram.sum()
+        self.mapping = deepcopy(mapping)
+
+    def kl_divergence(self, other_sample):
+        sample_histogram = np.zeros(len(self.mapping))
+        for x in other_sample:
+            # sample_histogram[self.mapping[x]] += 1
+            sample_histogram[x] += 1
+
+        # Normalize
+        q = sample_histogram / sample_histogram.sum()
+
+        return -np.sum(self.p * np.log(q / self.p + self.EPS))
+
+
+def rdmol_to_smiles(rdmol):
+    mol = Chem.Mol(rdmol)
+    Chem.RemoveStereochemistry(mol)
+    mol = Chem.RemoveHs(mol)
+    return Chem.MolToSmiles(mol)
+
+
+class BasicMolecularMetrics(object):
+    def __init__(self, dataset_info, dataset_smiles_list=None,
+                 connectivity_thresh=1.0):
+        self.atom_decoder = dataset_info['atom_decoder']
+        if dataset_smiles_list is not None:
+            dataset_smiles_list = set(dataset_smiles_list)
+        self.dataset_smiles_list = dataset_smiles_list
+        self.dataset_info = dataset_info
+        self.connectivity_thresh = connectivity_thresh
+
+    def compute_validity(self, generated):
+        """ generated: list of couples (positions, atom_types)"""
+        if len(generated) < 1:
+            return [], 0.0
+
+        valid = []
+        for mol in generated:
+            try:
+                Chem.SanitizeMol(mol)
+            except ValueError:
+                continue
+
+            valid.append(mol)
+
+        return valid, len(valid) / len(generated)
+
+    def compute_connectivity(self, valid):
+        """ Consider molecule connected if its largest fragment contains at
+        least x% of all atoms, where x is determined by
+        self.connectivity_thresh (defaults to 100%). """
+        if len(valid) < 1:
+            return [], 0.0
+
+        connected = []
+        connected_smiles = []
+        for mol in valid:
+            mol_frags = Chem.rdmolops.GetMolFrags(mol, asMols=True)
+            largest_mol = \
+                max(mol_frags, default=mol, key=lambda m: m.GetNumAtoms())
+            if largest_mol.GetNumAtoms() / mol.GetNumAtoms() >= self.connectivity_thresh:
+                smiles = rdmol_to_smiles(largest_mol)
+                if smiles is not None:
+                    connected_smiles.append(smiles)
+                    connected.append(largest_mol)
+
+        return connected, len(connected_smiles) / len(valid), connected_smiles
+
+    def compute_uniqueness(self, connected):
+        """ valid: list of SMILES strings."""
+        if len(connected) < 1 or self.dataset_smiles_list is None:
+            return [], 0.0
+
+        return list(set(connected)), len(set(connected)) / len(connected)
+
+    def compute_novelty(self, unique):
+        if len(unique) < 1:
+            return [], 0.0
+
+        num_novel = 0
+        novel = []
+        for smiles in unique:
+            if smiles not in self.dataset_smiles_list:
+                novel.append(smiles)
+                num_novel += 1
+        return novel, num_novel / len(unique)
+
+    def evaluate_rdmols(self, rdmols):
+        valid, validity = self.compute_validity(rdmols)
+        print(f"Validity over {len(rdmols)} molecules: {validity * 100 :.2f}%")
+
+        connected, connectivity, connected_smiles = \
+            self.compute_connectivity(valid)
+        print(f"Connectivity over {len(valid)} valid molecules: "
+              f"{connectivity * 100 :.2f}%")
+
+        unique, uniqueness = self.compute_uniqueness(connected_smiles)
+        print(f"Uniqueness over {len(connected)} connected molecules: "
+              f"{uniqueness * 100 :.2f}%")
+
+        _, novelty = self.compute_novelty(unique)
+        print(f"Novelty over {len(unique)} unique connected molecules: "
+              f"{novelty * 100 :.2f}%")
+
+        return [validity, connectivity, uniqueness, novelty], [valid, connected]
+
+    def evaluate(self, generated):
+        """ generated: list of pairs (positions: n x 3, atom_types: n [int])
+            the positions and atom types should already be masked. """
+
+        rdmols = [build_molecule(*graph, self.dataset_info)
+                  for graph in generated]
+        return self.evaluate_rdmols(rdmols)
+
+
+class MoleculeProperties:
+
+    @staticmethod
+    def calculate_qed(rdmol):
+        return QED.qed(rdmol)
+
+    @staticmethod
+    def calculate_sa(rdmol):
+        sa = calculateScore(rdmol)
+        return round((10 - sa) / 9, 2)  # from pocket2mol
+
+    @staticmethod
+    def calculate_logp(rdmol):
+        return Crippen.MolLogP(rdmol)
+
+    @staticmethod
+    def calculate_lipinski(rdmol):
+        rule_1 = Descriptors.ExactMolWt(rdmol) < 500
+        rule_2 = Lipinski.NumHDonors(rdmol) <= 5
+        rule_3 = Lipinski.NumHAcceptors(rdmol) <= 10
+        rule_4 = (logp := Crippen.MolLogP(rdmol) >= -2) & (logp <= 5)
+        rule_5 = Chem.rdMolDescriptors.CalcNumRotatableBonds(rdmol) <= 10
+        return np.sum([int(a) for a in [rule_1, rule_2, rule_3, rule_4, rule_5]])
+
+    @classmethod
+    def calculate_diversity(cls, pocket_mols):
+        if len(pocket_mols) < 2:
+            return 0.0
+
+        div = 0
+        total = 0
+        for i in range(len(pocket_mols)):
+            for j in range(i + 1, len(pocket_mols)):
+                div += 1 - cls.similarity(pocket_mols[i], pocket_mols[j])
+                total += 1
+        return div / total
+
+    @staticmethod
+    def similarity(mol_a, mol_b):
+        # fp1 = AllChem.GetMorganFingerprintAsBitVect(
+        #     mol_a, 2, nBits=2048, useChirality=False)
+        # fp2 = AllChem.GetMorganFingerprintAsBitVect(
+        #     mol_b, 2, nBits=2048, useChirality=False)
+        fp1 = Chem.RDKFingerprint(mol_a)
+        fp2 = Chem.RDKFingerprint(mol_b)
+        return DataStructs.TanimotoSimilarity(fp1, fp2)
+
+    def evaluate(self, pocket_rdmols):
+        """
+        Run full evaluation
+        Args:
+            pocket_rdmols: list of lists, the inner list contains all RDKit
+                molecules generated for a pocket
+        Returns:
+            QED, SA, LogP, Lipinski (per molecule), and Diversity (per pocket)
+        """
+
+        for pocket in pocket_rdmols:
+            for mol in pocket:
+                Chem.SanitizeMol(mol)
+                assert mol is not None, "only evaluate valid molecules"
+
+        all_qed = []
+        all_sa = []
+        all_logp = []
+        all_lipinski = []
+        per_pocket_diversity = []
+        for pocket in tqdm(pocket_rdmols):
+            all_qed.append([self.calculate_qed(mol) for mol in pocket])
+            all_sa.append([self.calculate_sa(mol) for mol in pocket])
+            all_logp.append([self.calculate_logp(mol) for mol in pocket])
+            all_lipinski.append([self.calculate_lipinski(mol) for mol in pocket])
+            per_pocket_diversity.append(self.calculate_diversity(pocket))
+
+        print(f"{sum([len(p) for p in pocket_rdmols])} molecules from "
+              f"{len(pocket_rdmols)} pockets evaluated.")
+
+        qed_flattened = [x for px in all_qed for x in px]
+        print(f"QED: {np.mean(qed_flattened):.3f} \pm {np.std(qed_flattened):.2f}")
+
+        sa_flattened = [x for px in all_sa for x in px]
+        print(f"SA: {np.mean(sa_flattened):.3f} \pm {np.std(sa_flattened):.2f}")
+
+        logp_flattened = [x for px in all_logp for x in px]
+        print(f"LogP: {np.mean(logp_flattened):.3f} \pm {np.std(logp_flattened):.2f}")
+
+        lipinski_flattened = [x for px in all_lipinski for x in px]
+        print(f"Lipinski: {np.mean(lipinski_flattened):.3f} \pm {np.std(lipinski_flattened):.2f}")
+
+        print(f"Diversity: {np.mean(per_pocket_diversity):.3f} \pm {np.std(per_pocket_diversity):.2f}")
+
+        return all_qed, all_sa, all_logp, all_lipinski, per_pocket_diversity
+
+    def evaluate_mean(self, rdmols):
+        """
+        Run full evaluation and return mean of each property
+        Args:
+            rdmols: list of RDKit molecules
+        Returns:
+            QED, SA, LogP, Lipinski, and Diversity
+        """
+
+        if len(rdmols) < 1:
+            return 0.0, 0.0, 0.0, 0.0, 0.0
+
+        for mol in rdmols:
+            Chem.SanitizeMol(mol)
+            assert mol is not None, "only evaluate valid molecules"
+
+        qed = np.mean([self.calculate_qed(mol) for mol in rdmols])
+        sa = np.mean([self.calculate_sa(mol) for mol in rdmols])
+        logp = np.mean([self.calculate_logp(mol) for mol in rdmols])
+        lipinski = np.mean([self.calculate_lipinski(mol) for mol in rdmols])
+        diversity = self.calculate_diversity(rdmols)
+
+        return qed, sa, logp, lipinski, diversity

analysis/molecule_builder.py

@@ -0,0 +1,250 @@
+import warnings
+import tempfile
+
+import torch
+import numpy as np
+from rdkit import Chem
+from rdkit.Chem.rdForceFieldHelpers import UFFOptimizeMolecule, UFFHasAllMoleculeParams
+import openbabel
+
+import utils
+from constants import bonds1, bonds2, bonds3, margin1, margin2, margin3, \
+    bond_dict
+
+
+def get_bond_order(atom1, atom2, distance):
+    distance = 100 * distance  # We change the metric
+
+    if atom1 in bonds3 and atom2 in bonds3[atom1] and distance < bonds3[atom1][atom2] + margin3:
+        return 3  # Triple
+
+    if atom1 in bonds2 and atom2 in bonds2[atom1] and distance < bonds2[atom1][atom2] + margin2:
+        return 2  # Double
+
+    if atom1 in bonds1 and atom2 in bonds1[atom1] and distance < bonds1[atom1][atom2] + margin1:
+        return 1  # Single
+
+    return 0      # No bond
+
+
+def get_bond_order_batch(atoms1, atoms2, distances, dataset_info):
+    if isinstance(atoms1, np.ndarray):
+        atoms1 = torch.from_numpy(atoms1)
+    if isinstance(atoms2, np.ndarray):
+        atoms2 = torch.from_numpy(atoms2)
+    if isinstance(distances, np.ndarray):
+        distances = torch.from_numpy(distances)
+
+    distances = 100 * distances  # We change the metric
+
+    bonds1 = torch.tensor(dataset_info['bonds1'], device=atoms1.device)
+    bonds2 = torch.tensor(dataset_info['bonds2'], device=atoms1.device)
+    bonds3 = torch.tensor(dataset_info['bonds3'], device=atoms1.device)
+
+    bond_types = torch.zeros_like(atoms1)  # 0: No bond
+
+    # Single
+    bond_types[distances < bonds1[atoms1, atoms2] + margin1] = 1
+
+    # Double (note that already assigned single bonds will be overwritten)
+    bond_types[distances < bonds2[atoms1, atoms2] + margin2] = 2
+
+    # Triple
+    bond_types[distances < bonds3[atoms1, atoms2] + margin3] = 3
+
+    return bond_types
+
+
+def make_mol_openbabel(positions, atom_types, atom_decoder):
+    """
+    Build an RDKit molecule using openbabel for creating bonds
+    Args:
+        positions: N x 3
+        atom_types: N
+        atom_decoder: maps indices to atom types
+    Returns:
+        rdkit molecule
+    """
+    atom_types = [atom_decoder[x] for x in atom_types]
+
+    with tempfile.NamedTemporaryFile() as tmp:
+        tmp_file = tmp.name
+
+        # Write xyz file
+        utils.write_xyz_file(positions, atom_types, tmp_file)
+
+        # Convert to sdf file with openbabel
+        # openbabel will add bonds
+        obConversion = openbabel.OBConversion()
+        obConversion.SetInAndOutFormats("xyz", "sdf")
+        ob_mol = openbabel.OBMol()
+        obConversion.ReadFile(ob_mol, tmp_file)
+
+        obConversion.WriteFile(ob_mol, tmp_file)
+
+        # Read sdf file with RDKit
+        tmp_mol = Chem.SDMolSupplier(tmp_file, sanitize=False)[0]
+
+    # Build new molecule. This is a workaround to remove radicals.
+    mol = Chem.RWMol()
+    for atom in tmp_mol.GetAtoms():
+        mol.AddAtom(Chem.Atom(atom.GetSymbol()))
+    mol.AddConformer(tmp_mol.GetConformer(0))
+
+    for bond in tmp_mol.GetBonds():
+        mol.AddBond(bond.GetBeginAtomIdx(), bond.GetEndAtomIdx(),
+                    bond.GetBondType())
+
+    return mol
+
+
+def make_mol_edm(positions, atom_types, dataset_info, add_coords):
+    """
+    Equivalent to EDM's way of building RDKit molecules
+    """
+    n = len(positions)
+
+    # (X, A, E): atom_types, adjacency matrix, edge_types
+    # X: N (int)
+    # A: N x N (bool) -> (binary adjacency matrix)
+    # E: N x N (int) -> (bond type, 0 if no bond)
+    pos = positions.unsqueeze(0)  # add batch dim
+    dists = torch.cdist(pos, pos, p=2).squeeze(0).view(-1)  # remove batch dim & flatten
+    atoms1, atoms2 = torch.cartesian_prod(atom_types, atom_types).T
+    E_full = get_bond_order_batch(atoms1, atoms2, dists, dataset_info).view(n, n)
+    E = torch.tril(E_full, diagonal=-1)  # Warning: the graph should be DIRECTED
+    A = E.bool()
+    X = atom_types
+
+    mol = Chem.RWMol()
+    for atom in X:
+        a = Chem.Atom(dataset_info["atom_decoder"][atom.item()])
+        mol.AddAtom(a)
+
+    all_bonds = torch.nonzero(A)
+    for bond in all_bonds:
+        mol.AddBond(bond[0].item(), bond[1].item(),
+                    bond_dict[E[bond[0], bond[1]].item()])
+
+    if add_coords:
+        conf = Chem.Conformer(mol.GetNumAtoms())
+        for i in range(mol.GetNumAtoms()):
+            conf.SetAtomPosition(i, (positions[i, 0].item(),
+                                     positions[i, 1].item(),
+                                     positions[i, 2].item()))
+        mol.AddConformer(conf)
+
+    return mol
+
+
+def build_molecule(positions, atom_types, dataset_info, add_coords=False,
+                   use_openbabel=True):
+    """
+    Build RDKit molecule
+    Args:
+        positions: N x 3
+        atom_types: N
+        dataset_info: dict
+        add_coords: Add conformer to mol (always added if use_openbabel=True)
+        use_openbabel: use OpenBabel to create bonds
+    Returns:
+        RDKit molecule
+    """
+    if use_openbabel:
+        mol = make_mol_openbabel(positions, atom_types,
+                                 dataset_info["atom_decoder"])
+    else:
+        mol = make_mol_edm(positions, atom_types, dataset_info, add_coords)
+
+    return mol
+
+
+def process_molecule(rdmol, add_hydrogens=False, sanitize=False, relax_iter=0,
+                     largest_frag=False):
+    """
+    Apply filters to an RDKit molecule. Makes a copy first.
+    Args:
+        rdmol: rdkit molecule
+        add_hydrogens
+        sanitize
+        relax_iter: maximum number of UFF optimization iterations
+        largest_frag: filter out the largest fragment in a set of disjoint
+            molecules
+    Returns:
+        RDKit molecule or None if it does not pass the filters
+    """
+
+    # Create a copy
+    mol = Chem.Mol(rdmol)
+
+    if sanitize:
+        try:
+            Chem.SanitizeMol(mol)
+        except ValueError:
+            warnings.warn('Sanitization failed. Returning None.')
+            return None
+
+    if add_hydrogens:
+        mol = Chem.AddHs(mol, addCoords=(len(mol.GetConformers()) > 0))
+
+    if largest_frag:
+        mol_frags = Chem.GetMolFrags(mol, asMols=True, sanitizeFrags=False)
+        mol = max(mol_frags, default=mol, key=lambda m: m.GetNumAtoms())
+        if sanitize:
+            # sanitize the updated molecule
+            try:
+                Chem.SanitizeMol(mol)
+            except ValueError:
+                return None
+
+    if relax_iter > 0:
+        if not UFFHasAllMoleculeParams(mol):
+            warnings.warn('UFF parameters not available for all atoms. '
+                          'Returning None.')
+            return None
+
+        try:
+            uff_relax(mol, relax_iter)
+            if sanitize:
+                # sanitize the updated molecule
+                Chem.SanitizeMol(mol)
+        except (RuntimeError, ValueError) as e:
+            return None
+
+    return mol
+
+
+def uff_relax(mol, max_iter=200):
+    """
+    Uses RDKit's universal force field (UFF) implementation to optimize a
+    molecule.
+    """
+    more_iterations_required = UFFOptimizeMolecule(mol, maxIters=max_iter)
+    if more_iterations_required:
+        warnings.warn(f'Maximum number of FF iterations reached. '
+                      f'Returning molecule after {max_iter} relaxation steps.')
+    return more_iterations_required
+
+
+def filter_rd_mol(rdmol):
+    """
+    Filter out RDMols if they have a 3-3 ring intersection
+    adapted from:
+    https://github.com/luost26/3D-Generative-SBDD/blob/main/utils/chem.py
+    """
+    ring_info = rdmol.GetRingInfo()
+    ring_info.AtomRings()
+    rings = [set(r) for r in ring_info.AtomRings()]
+
+    # 3-3 ring intersection
+    for i, ring_a in enumerate(rings):
+        if len(ring_a) != 3:
+            continue
+        for j, ring_b in enumerate(rings):
+            if i <= j:
+                continue
+            inter = ring_a.intersection(ring_b)
+            if (len(ring_b) == 3) and (len(inter) > 0): 
+                return False
+
+    return True

analysis/visualization.py

@@ -0,0 +1,472 @@
+import torch
+import numpy as np
+import os
+import glob
+import random
+import matplotlib
+import imageio
+
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+from analysis.molecule_builder import get_bond_order
+
+
+##############
+### Files ####
+###########-->
+
+
+def save_xyz_file(path, one_hot, positions, atom_decoder, id_from=0,
+                  name='molecule', batch_mask=None):
+    try:
+        os.makedirs(path)
+    except OSError:
+        pass
+
+    if batch_mask is None:
+        batch_mask = torch.zeros(len(one_hot))
+
+    for batch_i in torch.unique(batch_mask):
+        cur_batch_mask = (batch_mask == batch_i)
+        n_atoms = int(torch.sum(cur_batch_mask).item())
+        f = open(path + name + '_' + "%03d.xyz" % (batch_i + id_from), "w")
+        f.write("%d\n\n" % n_atoms)
+        atoms = torch.argmax(one_hot[cur_batch_mask], dim=1)
+        batch_pos = positions[cur_batch_mask]
+        for atom_i in range(n_atoms):
+            atom = atoms[atom_i]
+            atom = atom_decoder[atom]
+            f.write("%s %.9f %.9f %.9f\n" % (atom, batch_pos[atom_i, 0], batch_pos[atom_i, 1], batch_pos[atom_i, 2]))
+        f.close()
+
+
+def load_molecule_xyz(file, dataset_info):
+    with open(file, encoding='utf8') as f:
+        n_atoms = int(f.readline())
+        one_hot = torch.zeros(n_atoms, len(dataset_info['atom_decoder']))
+        positions = torch.zeros(n_atoms, 3)
+        f.readline()
+        atoms = f.readlines()
+        for i in range(n_atoms):
+            atom = atoms[i].split(' ')
+            atom_type = atom[0]
+            one_hot[i, dataset_info['atom_encoder'][atom_type]] = 1
+            position = torch.Tensor([float(e) for e in atom[1:]])
+            positions[i, :] = position
+        return positions, one_hot
+
+
+def load_xyz_files(path, shuffle=True):
+    files = glob.glob(path + "/*.xyz")
+    if shuffle:
+        random.shuffle(files)
+    return files
+
+
+# <----########
+### Files ####
+##############
+def draw_sphere(ax, x, y, z, size, color, alpha):
+    u = np.linspace(0, 2 * np.pi, 100)
+    v = np.linspace(0, np.pi, 100)
+
+    xs = size * np.outer(np.cos(u), np.sin(v))
+    ys = size * np.outer(np.sin(u), np.sin(v)) * 0.8  # Correct for matplotlib.
+    zs = size * np.outer(np.ones(np.size(u)), np.cos(v))
+    # for i in range(2):
+    #    ax.plot_surface(x+random.randint(-5,5), y+random.randint(-5,5), z+random.randint(-5,5),  rstride=4, cstride=4, color='b', linewidth=0, alpha=0.5)
+
+    ax.plot_surface(x + xs, y + ys, z + zs, rstride=2, cstride=2, color=color,
+                    linewidth=0,
+                    alpha=alpha)
+    # # calculate vectors for "vertical" circle
+    # a = np.array([-np.sin(elev / 180 * np.pi), 0, np.cos(elev / 180 * np.pi)])
+    # b = np.array([0, 1, 0])
+    # b = b * np.cos(rot) + np.cross(a, b) * np.sin(rot) + a * np.dot(a, b) * (
+    #             1 - np.cos(rot))
+    # ax.plot(np.sin(u), np.cos(u), 0, color='k', linestyle='dashed')
+    # horiz_front = np.linspace(0, np.pi, 100)
+    # ax.plot(np.sin(horiz_front), np.cos(horiz_front), 0, color='k')
+    # vert_front = np.linspace(np.pi / 2, 3 * np.pi / 2, 100)
+    # ax.plot(a[0] * np.sin(u) + b[0] * np.cos(u), b[1] * np.cos(u),
+    #         a[2] * np.sin(u) + b[2] * np.cos(u), color='k', linestyle='dashed')
+    # ax.plot(a[0] * np.sin(vert_front) + b[0] * np.cos(vert_front),
+    #         b[1] * np.cos(vert_front),
+    #         a[2] * np.sin(vert_front) + b[2] * np.cos(vert_front), color='k')
+    #
+    # ax.view_init(elev=elev, azim=0)
+
+
+def plot_molecule(ax, positions, atom_type, alpha, spheres_3d, hex_bg_color,
+                  dataset_info):
+    # draw_sphere(ax, 0, 0, 0, 1)
+    # draw_sphere(ax, 1, 1, 1, 1)
+
+    x = positions[:, 0]
+    y = positions[:, 1]
+    z = positions[:, 2]
+    # Hydrogen, Carbon, Nitrogen, Oxygen, Flourine
+
+    # ax.set_facecolor((1.0, 0.47, 0.42))
+    colors_dic = np.array(dataset_info['colors_dic'])
+    radius_dic = np.array(dataset_info['radius_dic'])
+    area_dic = 1500 * radius_dic ** 2
+    # areas_dic = sizes_dic * sizes_dic * 3.1416
+
+    areas = area_dic[atom_type]
+    radii = radius_dic[atom_type]
+    colors = colors_dic[atom_type]
+
+    if spheres_3d:
+        for i, j, k, s, c in zip(x, y, z, radii, colors):
+            draw_sphere(ax, i.item(), j.item(), k.item(), 0.7 * s, c, alpha)
+    else:
+        ax.scatter(x, y, z, s=areas, alpha=0.9 * alpha,
+                   c=colors)  # , linewidths=2, edgecolors='#FFFFFF')
+
+    for i in range(len(x)):
+        for j in range(i + 1, len(x)):
+            p1 = np.array([x[i], y[i], z[i]])
+            p2 = np.array([x[j], y[j], z[j]])
+            dist = np.sqrt(np.sum((p1 - p2) ** 2))
+            atom1, atom2 = dataset_info['atom_decoder'][atom_type[i]], \
+                           dataset_info['atom_decoder'][atom_type[j]]
+            s = (atom_type[i], atom_type[j])
+
+            draw_edge_int = get_bond_order(dataset_info['atom_decoder'][s[0]],
+                                           dataset_info['atom_decoder'][s[1]],
+                                           dist)
+            line_width = 2
+
+            draw_edge = draw_edge_int > 0
+            if draw_edge:
+                if draw_edge_int == 4:
+                    linewidth_factor = 1.5
+                else:
+                    # linewidth_factor = draw_edge_int  # Prop to number of
+                    # edges.
+                    linewidth_factor = 1
+                ax.plot([x[i], x[j]], [y[i], y[j]], [z[i], z[j]],
+                        linewidth=line_width * linewidth_factor,
+                        c=hex_bg_color, alpha=alpha)
+
+
+def plot_data3d(positions, atom_type, dataset_info, camera_elev=0,
+                camera_azim=0, save_path=None, spheres_3d=False,
+                bg='black', alpha=1.):
+    black = (0, 0, 0)
+    white = (1, 1, 1)
+    hex_bg_color = '#FFFFFF' if bg == 'black' else '#666666'
+
+    from mpl_toolkits.mplot3d import Axes3D
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.set_aspect('auto')
+    ax.view_init(elev=camera_elev, azim=camera_azim)
+    if bg == 'black':
+        ax.set_facecolor(black)
+    else:
+        ax.set_facecolor(white)
+    # ax.xaxis.pane.set_edgecolor('#D0D0D0')
+    ax.xaxis.pane.set_alpha(0)
+    ax.yaxis.pane.set_alpha(0)
+    ax.zaxis.pane.set_alpha(0)
+    ax._axis3don = False
+
+    if bg == 'black':
+        ax.w_xaxis.line.set_color("black")
+    else:
+        ax.w_xaxis.line.set_color("white")
+
+    plot_molecule(ax, positions, atom_type, alpha, spheres_3d,
+                  hex_bg_color, dataset_info)
+
+    # if 'qm9' in dataset_info['name']:
+    max_value = positions.abs().max().item()
+
+    # axis_lim = 3.2
+    axis_lim = min(40, max(max_value / 1.5 + 0.3, 3.2))
+    ax.set_xlim(-axis_lim, axis_lim)
+    ax.set_ylim(-axis_lim, axis_lim)
+    ax.set_zlim(-axis_lim, axis_lim)
+    # elif dataset_info['name'] == 'geom':
+    #     max_value = positions.abs().max().item()
+    #
+    #     # axis_lim = 3.2
+    #     axis_lim = min(40, max(max_value / 1.5 + 0.3, 3.2))
+    #     ax.set_xlim(-axis_lim, axis_lim)
+    #     ax.set_ylim(-axis_lim, axis_lim)
+    #     ax.set_zlim(-axis_lim, axis_lim)
+    # elif dataset_info['name'] == 'pdbbind':
+    #     max_value = positions.abs().max().item()
+    #
+    #     # axis_lim = 3.2
+    #     axis_lim = min(40, max(max_value / 1.5 + 0.3, 3.2))
+    #     ax.set_xlim(-axis_lim, axis_lim)
+    #     ax.set_ylim(-axis_lim, axis_lim)
+    #     ax.set_zlim(-axis_lim, axis_lim)
+    # else:
+    #     raise ValueError(dataset_info['name'])
+
+    dpi = 120 if spheres_3d else 50
+
+    if save_path is not None:
+        plt.savefig(save_path, bbox_inches='tight', pad_inches=0.0, dpi=dpi)
+
+        if spheres_3d:
+            img = imageio.imread(save_path)
+            img_brighter = np.clip(img * 1.4, 0, 255).astype('uint8')
+            imageio.imsave(save_path, img_brighter)
+    else:
+        plt.show()
+    plt.close()
+
+
+def plot_data3d_uncertainty(
+        all_positions, all_atom_types, dataset_info, camera_elev=0,
+        camera_azim=0,
+        save_path=None, spheres_3d=False, bg='black', alpha=1.):
+    black = (0, 0, 0)
+    white = (1, 1, 1)
+    hex_bg_color = '#FFFFFF' if bg == 'black' else '#666666'
+
+    from mpl_toolkits.mplot3d import Axes3D
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.set_aspect('auto')
+    ax.view_init(elev=camera_elev, azim=camera_azim)
+    if bg == 'black':
+        ax.set_facecolor(black)
+    else:
+        ax.set_facecolor(white)
+    # ax.xaxis.pane.set_edgecolor('#D0D0D0')
+    ax.xaxis.pane.set_alpha(0)
+    ax.yaxis.pane.set_alpha(0)
+    ax.zaxis.pane.set_alpha(0)
+    ax._axis3don = False
+
+    if bg == 'black':
+        ax.w_xaxis.line.set_color("black")
+    else:
+        ax.w_xaxis.line.set_color("white")
+
+    for i in range(len(all_positions)):
+        positions = all_positions[i]
+        atom_type = all_atom_types[i]
+        plot_molecule(ax, positions, atom_type, alpha, spheres_3d,
+                      hex_bg_color, dataset_info)
+
+    if 'qm9' in dataset_info['name']:
+        max_value = all_positions[0].abs().max().item()
+
+        # axis_lim = 3.2
+        axis_lim = min(40, max(max_value + 0.3, 3.2))
+        ax.set_xlim(-axis_lim, axis_lim)
+        ax.set_ylim(-axis_lim, axis_lim)
+        ax.set_zlim(-axis_lim, axis_lim)
+    elif dataset_info['name'] == 'geom':
+        max_value = all_positions[0].abs().max().item()
+
+        # axis_lim = 3.2
+        axis_lim = min(40, max(max_value / 2 + 0.3, 3.2))
+        ax.set_xlim(-axis_lim, axis_lim)
+        ax.set_ylim(-axis_lim, axis_lim)
+        ax.set_zlim(-axis_lim, axis_lim)
+    elif dataset_info['name'] == 'pdbbind':
+        max_value = all_positions[0].abs().max().item()
+
+        # axis_lim = 3.2
+        axis_lim = min(40, max(max_value / 2 + 0.3, 3.2))
+        ax.set_xlim(-axis_lim, axis_lim)
+        ax.set_ylim(-axis_lim, axis_lim)
+        ax.set_zlim(-axis_lim, axis_lim)
+    else:
+        raise ValueError(dataset_info['name'])
+
+    dpi = 120 if spheres_3d else 50
+
+    if save_path is not None:
+        plt.savefig(save_path, bbox_inches='tight', pad_inches=0.0, dpi=dpi)
+
+        if spheres_3d:
+            img = imageio.imread(save_path)
+            img_brighter = np.clip(img * 1.4, 0, 255).astype('uint8')
+            imageio.imsave(save_path, img_brighter)
+    else:
+        plt.show()
+    plt.close()
+
+
+def plot_grid():
+    import matplotlib.pyplot as plt
+    from mpl_toolkits.axes_grid1 import ImageGrid
+
+    im1 = np.arange(100).reshape((10, 10))
+    im2 = im1.T
+    im3 = np.flipud(im1)
+    im4 = np.fliplr(im2)
+
+    fig = plt.figure(figsize=(10., 10.))
+    grid = ImageGrid(fig, 111,  # similar to subplot(111)
+                     nrows_ncols=(6, 6),  # creates 2x2 grid of axes
+                     axes_pad=0.1,  # pad between axes in inch.
+                     )
+
+    for ax, im in zip(grid, [im1, im2, im3, im4]):
+        # Iterating over the grid returns the Axes.
+
+        ax.imshow(im)
+
+    plt.show()
+
+
+def visualize(path, dataset_info, max_num=25, wandb=None, spheres_3d=False):
+    files = load_xyz_files(path)[0:max_num]
+    for file in files:
+        positions, one_hot = load_molecule_xyz(file, dataset_info)
+        atom_type = torch.argmax(one_hot, dim=1).numpy()
+        dists = torch.cdist(positions.unsqueeze(0),
+                            positions.unsqueeze(0)).squeeze(0)
+        dists = dists[dists > 0]
+        # print("Average distance between atoms", dists.mean().item())
+        plot_data3d(positions, atom_type, dataset_info=dataset_info,
+                    save_path=file[:-4] + '.png',
+                    spheres_3d=spheres_3d)
+
+        if wandb is not None:
+            path = file[:-4] + '.png'
+            # Log image(s)
+            im = plt.imread(path)
+            wandb.log({'molecule': [wandb.Image(im, caption=path)]})
+
+
+def visualize_chain(path, dataset_info, wandb=None, spheres_3d=False,
+                    mode="chain"):
+    files = load_xyz_files(path)
+    files = sorted(files)
+    save_paths = []
+
+    for i in range(len(files)):
+        file = files[i]
+
+        positions, one_hot = load_molecule_xyz(file, dataset_info=dataset_info)
+
+        atom_type = torch.argmax(one_hot, dim=1).numpy()
+        fn = file[:-4] + '.png'
+        plot_data3d(positions, atom_type, dataset_info=dataset_info,
+                    save_path=fn, spheres_3d=spheres_3d, alpha=1.0)
+        save_paths.append(fn)
+
+    imgs = [imageio.imread(fn) for fn in save_paths]
+    dirname = os.path.dirname(save_paths[0])
+    gif_path = dirname + '/output.gif'
+    print(f'Creating gif with {len(imgs)} images')
+    # Add the last frame 10 times so that the final result remains temporally.
+    # imgs.extend([imgs[-1]] * 10)
+    imageio.mimsave(gif_path, imgs, subrectangles=True)
+
+    if wandb is not None:
+        wandb.log({mode: [wandb.Video(gif_path, caption=gif_path)]})
+
+
+def visualize_chain_uncertainty(
+        path, dataset_info, wandb=None, spheres_3d=False, mode="chain"):
+    files = load_xyz_files(path)
+    files = sorted(files)
+    save_paths = []
+
+    for i in range(len(files)):
+        if i + 2 == len(files):
+            break
+
+        file = files[i]
+        file2 = files[i + 1]
+        file3 = files[i + 2]
+
+        positions, one_hot, _ = load_molecule_xyz(file,
+                                                  dataset_info=dataset_info)
+        positions2, one_hot2, _ = load_molecule_xyz(
+            file2, dataset_info=dataset_info)
+        positions3, one_hot3, _ = load_molecule_xyz(
+            file3, dataset_info=dataset_info)
+
+        all_positions = torch.stack([positions, positions2, positions3], dim=0)
+        one_hot = torch.stack([one_hot, one_hot2, one_hot3], dim=0)
+
+        all_atom_type = torch.argmax(one_hot, dim=2).numpy()
+        fn = file[:-4] + '.png'
+        plot_data3d_uncertainty(
+            all_positions, all_atom_type, dataset_info=dataset_info,
+            save_path=fn, spheres_3d=spheres_3d, alpha=0.5)
+        save_paths.append(fn)
+
+    imgs = [imageio.imread(fn) for fn in save_paths]
+    dirname = os.path.dirname(save_paths[0])
+    gif_path = dirname + '/output.gif'
+    print(f'Creating gif with {len(imgs)} images')
+    # Add the last frame 10 times so that the final result remains temporally.
+    # imgs.extend([imgs[-1]] * 10)
+    imageio.mimsave(gif_path, imgs, subrectangles=True)
+
+    if wandb is not None:
+        wandb.log({mode: [wandb.Video(gif_path, caption=gif_path)]})
+
+
+if __name__ == '__main__':
+    # plot_grid()
+    import qm9.dataset as dataset
+    from configs.datasets_config import qm9_with_h, geom_with_h
+
+    matplotlib.use('macosx')
+
+    task = "visualize_molecules"
+    task_dataset = 'geom'
+
+    if task_dataset == 'qm9':
+        dataset_info = qm9_with_h
+
+
+        class Args:
+            batch_size = 1
+            num_workers = 0
+            filter_n_atoms = None
+            datadir = 'qm9/temp'
+            dataset = 'qm9'
+            remove_h = False
+
+
+        cfg = Args()
+
+        dataloaders, charge_scale = dataset.retrieve_dataloaders(cfg)
+
+        for i, data in enumerate(dataloaders['train']):
+            positions = data['positions'].view(-1, 3)
+            positions_centered = positions - positions.mean(dim=0, keepdim=True)
+            one_hot = data['one_hot'].view(-1, 5).type(torch.float32)
+            atom_type = torch.argmax(one_hot, dim=1).numpy()
+
+            plot_data3d(
+                positions_centered, atom_type, dataset_info=dataset_info,
+                spheres_3d=True)
+
+    elif task_dataset == 'geom':
+        files = load_xyz_files('outputs/data')
+        matplotlib.use('macosx')
+        for file in files:
+            x, one_hot, _ = load_molecule_xyz(file, dataset_info=geom_with_h)
+
+            positions = x.view(-1, 3)
+            positions_centered = positions - positions.mean(dim=0, keepdim=True)
+            one_hot = one_hot.view(-1, 16).type(torch.float32)
+            atom_type = torch.argmax(one_hot, dim=1).numpy()
+
+            mask = (x == 0).sum(1) != 3
+            positions_centered = positions_centered[mask]
+            atom_type = atom_type[mask]
+
+            plot_data3d(
+                positions_centered, atom_type, dataset_info=geom_with_h,
+                spheres_3d=False)
+
+    else:
+        raise ValueError(dataset)

colab/DiffSBDD.ipynb

@@ -0,0 +1,468 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU",
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "e293d4b7fb5e4d60a9303400a571d481": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "TextModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "TextModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "TextView",
+            "continuous_update": true,
+            "description": "",
+            "description_tooltip": null,
+            "disabled": false,
+            "layout": "IPY_MODEL_9ccaa9faa36646678a0278cd651c3f30",
+            "placeholder": "​",
+            "style": "IPY_MODEL_50a9c77fae984dab908378418b726eff",
+            "value": "A:330"
+          }
+        },
+        "9ccaa9faa36646678a0278cd651c3f30": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "50a9c77fae984dab908378418b726eff": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        }
+      }
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/arneschneuing/DiffSBDD/blob/main/colab/DiffSBDD.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# DiffSBDD: Structure-based Drug Design with Equivariant Diffusion Models\n",
+        "\n",
+        "[**[Paper]**](https://arxiv.org/abs/2210.13695)\n",
+        "[**[Code]**](https://github.com/arneschneuing/DiffSBDD)\n",
+        "\n",
+        "Make sure to select `Runtime` -> `Change runtime type` -> `GPU` before you run the script.\n",
+        "\n",
+        "<img src=\"https://raw.githubusercontent.com/arneschneuing/DiffSBDD/main/img/overview.png\" height=250>"
+      ],
+      "metadata": {
+        "id": "m12HrhIsNKkS"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title  Install condacolab (the kernel will be restarted, after that you can execute the remaining cells)\n",
+        "!pip install -q condacolab\n",
+        "import condacolab\n",
+        "condacolab.install()"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "iAiLo8O8klSG"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Install dependencies (this will take about 5-10 minutes)\n",
+        "%cd /content\n",
+        "\n",
+        "import os\n",
+        "\n",
+        "commands = [\n",
+        "    \"pip install torch==2.0.1 --extra-index-url https://download.pytorch.org/whl/cu118\",\n",
+        "    \"pip install pytorch-lightning==1.8.4\",\n",
+        "    \"pip install wandb==0.13.1\",\n",
+        "    \"pip install rdkit==2022.3.3\",\n",
+        "    \"pip install biopython==1.79\",\n",
+        "    \"pip install imageio==2.21.2\",\n",
+        "    \"pip install scipy==1.7.3\",\n",
+        "    \"pip install pyg-lib torch-scatter -f https://data.pyg.org/whl/torch-2.0.1+cu118.html\",\n",
+        "    \"pip install networkx==2.8.6\",\n",
+        "    \"pip install py3Dmol==1.8.1\",\n",
+        "    \"conda install openbabel -c conda-forge\",\n",
+        "    \"git clone https://github.com/arneschneuing/DiffSBDD.git\",\n",
+        "    \"mkdir -p /content/DiffSBDD/checkpoints\",\n",
+        "    \"wget -P /content/DiffSBDD/checkpoints https://zenodo.org/record/8183747/files/moad_fullatom_cond.ckpt\",\n",
+        "    \"wget -P /content/DiffSBDD/checkpoints https://zenodo.org/record/8183747/files/moad_fullatom_joint.ckpt\",\n",
+        "]\n",
+        "\n",
+        "errors = {}\n",
+        "\n",
+        "if not os.path.isfile(\"/content/READY\"):\n",
+        "  for cmd in commands:\n",
+        "    # os.system(cmd)\n",
+        "    with os.popen(cmd) as f:\n",
+        "      out = f.read()\n",
+        "      status = f.close()\n",
+        "\n",
+        "    if status is not None:\n",
+        "      errors[cmd] = out\n",
+        "      print(f\"\\n\\nAn error occurred while running '{cmd}'\\n\")\n",
+        "      print(\"Status:\\t\", status)\n",
+        "      print(\"Message:\\t\", out)\n",
+        "\n",
+        "if len(errors) == 0:\n",
+        "  os.system(\"touch /content/READY\")"
+      ],
+      "metadata": {
+        "id": "bZ5Q_kLdVIp7",
+        "cellView": "form"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Choose target PDB"
+      ],
+      "metadata": {
+        "id": "e46yNUYbdqZ3"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import files\n",
+        "from google.colab import output\n",
+        "output.enable_custom_widget_manager()\n",
+        "import os.path\n",
+        "from pathlib import Path\n",
+        "import urllib\n",
+        "import os\n",
+        "\n",
+        "input_dir = Path(\"/content/input_pdbs/\")\n",
+        "output_dir = Path(\"/content/output_sdfs/\")\n",
+        "input_dir.mkdir(exist_ok=True)\n",
+        "output_dir.mkdir(exist_ok=True)\n",
+        "\n",
+        "target = \"example (3rfm)\" #@param [\"example (3rfm)\", \"upload structure\"]\n",
+        "\n",
+        "if target == \"example (3rfm)\":\n",
+        "  pdbfile = Path(input_dir, '3rfm.pdb')\n",
+        "  urllib.request.urlretrieve('http://files.rcsb.org/download/3rfm.pdb', pdbfile)\n",
+        "\n",
+        "elif target == \"upload structure\":\n",
+        "  uploaded = files.upload()\n",
+        "  fn = list(uploaded.keys())[0]\n",
+        "  pdbfile = Path(input_dir, fn)\n",
+        "  Path(fn).rename(pdbfile)"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "tzkQJJeNdJMa"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Define binding pocket\n",
+        "\n",
+        "You can choose between two options to define the binding pocket:\n",
+        "1. **list of residues:** provide a list where each residue is specified as `<chain_id>:<res_id>`, e.g, `A:1 A:2 A:3 A:4 A:5 A:6 A:7`\n",
+        "2. **reference ligand:** if the uploaded PDB structure contains a reference ligand in the target pocket, you can specify its location as `<chain_id>:<res_id>` and the pocket will be extracted automatically"
+      ],
+      "metadata": {
+        "id": "eif7HG0Bd2qj"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title { run: \"auto\" }\n",
+        "import ipywidgets as widgets\n",
+        "\n",
+        "#@markdown **Note:** This cell is an interactive widget and the values will be updated automatically every time you change them. You do not need to execute the cell again. If you do, the default values will be reinserted.\n",
+        "\n",
+        "pocket_definition = \"reference ligand\" #@param [\"list of residues\", \"reference ligand\"]\n",
+        "\n",
+        "if pocket_definition == \"list of residues\":\n",
+        "  print('pocket_residues:')\n",
+        "  w = widgets.Text(value='A:9 A:59 A:60 A:62 A:63 A:64 A:66 A:67 A:80 A:81 A:84 A:85 A:88 A:167 A:168 A:169 A:170 A:172 A:174 A:177 A:181 A:246 A:249 A:250 A:252 A:253 A:256 A:265 A:267 A:270 A:271 A:273 A:274 A:275 A:277 A:278')\n",
+        "  pocket_flag = \"--resi_list\"\n",
+        "elif pocket_definition == \"reference ligand\":\n",
+        "  print('reference_ligand:')\n",
+        "  w = widgets.Text(value='A:330')\n",
+        "  pocket_flag = \"--ref_ligand\"\n",
+        "\n",
+        "display(w)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 67,
+          "referenced_widgets": [
+            "e293d4b7fb5e4d60a9303400a571d481",
+            "9ccaa9faa36646678a0278cd651c3f30",
+            "50a9c77fae984dab908378418b726eff"
+          ]
+        },
+        "cellView": "form",
+        "id": "E9AMhAo_VlUo",
+        "outputId": "b4f9f05f-123c-40d4-c4bd-77ef5e19cb63"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "reference_ligand:\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Text(value='A:330')"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "e293d4b7fb5e4d60a9303400a571d481"
+            }
+          },
+          "metadata": {
+            "application/vnd.jupyter.widget-view+json": {
+              "colab": {
+                "custom_widget_manager": {
+                  "url": "https://ssl.gstatic.com/colaboratory-static/widgets/colab-cdn-widget-manager/b3e629b1971e1542/manager.min.js"
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Settings\n",
+        "\n",
+        "Notes:\n",
+        "- `timesteps < 500` is an experimental feature\n",
+        "- `resamplings` and `jump_length` only pertain to the inpainting model"
+      ],
+      "metadata": {
+        "id": "eYgXjygkeG14"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@markdown ## Sampling\n",
+        "n_samples = 10 #@param {type:\"slider\", min:1, max:100, step:1}\n",
+        "ligand_nodes = 20 #@param {type:\"integer\"}\n",
+        "\n",
+        "model = \"Conditional model (Binding MOAD)\" #@param [\"Conditional model (Binding MOAD)\", \"Inpainting model (Binding MOAD)\"]\n",
+        "checkpoint = Path('/content', 'DiffSBDD', 'checkpoints', 'moad_fullatom_cond.ckpt') if model == \"Conditional model (Binding MOAD)\" else Path('DiffSBDD', 'checkpoints', 'moad_fullatom_joint.ckpt')\n",
+        "\n",
+        "timesteps = 100 #@param {type:\"slider\", min:1, max:500, step:1}\n",
+        "\n",
+        "#@markdown  ## Inpainting parameters\n",
+        "resamplings = 1 #@param {type:\"integer\"}\n",
+        "jump_length = 1 #@param {type:\"integer\"}\n",
+        "\n",
+        "#@markdown  ## Post-processing\n",
+        "keep_all_fragments = False #@param {type:\"boolean\"}\n",
+        "keep_all_fragments = \"--all_frags\" if keep_all_fragments else \"\"\n",
+        "sanitize = True #@param {type:\"boolean\"}\n",
+        "sanitize = \"--sanitize\" if sanitize else \"\"\n",
+        "relax = True #@param {type:\"boolean\"}\n",
+        "relax = \"--relax\" if relax else \"\""
+      ],
+      "metadata": {
+        "id": "VQ6xa7EPMtyI",
+        "cellView": "form"
+      },
+      "execution_count": 4,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Run sampling (this will take a few minutes; runtime depends on the input parameters `n_samples`, `timesteps` etc.)\n",
+        "%%capture\n",
+        "%cd /content/DiffSBDD\n",
+        "\n",
+        "import argparse\n",
+        "from pathlib import Path\n",
+        "import torch\n",
+        "import utils\n",
+        "from lightning_modules import LigandPocketDDPM\n",
+        "\n",
+        "\n",
+        "pdb_id = Path(pdbfile).stem\n",
+        "pocket = w.value\n",
+        "\n",
+        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
+        "\n",
+        "# Load model\n",
+        "model = LigandPocketDDPM.load_from_checkpoint(checkpoint, map_location=device)\n",
+        "model = model.to(device)\n",
+        "\n",
+        "num_nodes_lig = torch.ones(n_samples, dtype=int) * ligand_nodes\n",
+        "\n",
+        "if pocket_flag == '--ref_ligand':\n",
+        "  resi_list = None\n",
+        "  ref_ligand = pocket\n",
+        "else:\n",
+        "  resi_list = pocket.split()\n",
+        "  ref_ligand = None\n",
+        "\n",
+        "molecules = model.generate_ligands(\n",
+        "    pdbfile, n_samples, resi_list, ref_ligand,\n",
+        "    num_nodes_lig, (sanitize == '--sanitize'),\n",
+        "    largest_frag=not (keep_all_fragments == \"--all_frags\"),\n",
+        "    relax_iter=(200 if (relax == \"--relax\") else 0),\n",
+        "    resamplings=resamplings, jump_length=jump_length,\n",
+        "    timesteps=timesteps\n",
+        ")\n",
+        "\n",
+        "# Make SDF files\n",
+        "utils.write_sdf_file(Path(output_dir, f'{pdb_id}_mol.sdf'), molecules)"
+      ],
+      "metadata": {
+        "id": "pWitBCDUoRBw",
+        "cellView": "form"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Show generated molecules\n",
+        "\n",
+        "import sys\n",
+        "sys.path.append(\"/usr/local/lib/python3.9/site-packages\")\n",
+        "import py3Dmol\n",
+        "\n",
+        "view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js',)\n",
+        "view.addModel(open(pdbfile, 'r').read(), 'pdb')\n",
+        "view.setStyle({'model': -1}, {'cartoon': {'color': 'lime'}})\n",
+        "# view.addSurface(py3Dmol.VDW, {'opacity': 0.4, 'color': 'lime'})\n",
+        "view.addModelsAsFrames(open(Path(output_dir, f\"{pdbfile.stem}_mol.sdf\"), 'r').read())\n",
+        "view.setStyle({'model': -1}, {'stick': {}})\n",
+        "view.zoomTo({'model': -1})\n",
+        "view.zoom(0.5)\n",
+        "if target == \"example (3rfm)\":\n",
+        "  view.rotate(90, 'y')\n",
+        "view.animate({'loop': \"forward\", 'interval': 1000})\n",
+        "view.show()"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "lVyysoc0Rp_-"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Download .sdf file\n",
+        "files.download(Path(output_dir, f\"{pdbfile.stem}_mol.sdf\"))"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "3lQUv8rmQRd_"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

configs/crossdock_ca_cond.yml

@@ -0,0 +1,62 @@
+run_name: 'SE3-cond-CA'
+logdir: '/path/to/logdir'
+wandb_params:
+  mode: 'online'  # disabled, offline, online
+  entity: 'my_username'
+dataset: 'crossdock'
+datadir: '/path/to/processed_crossdock_noH_ca_only'
+enable_progress_bar: True
+num_sanity_val_steps: 0
+
+mode: 'pocket_conditioning'  # joint, pocket_conditioning
+pocket_representation: 'CA'  # CA, full-atom
+batch_size: 96
+lr: 1.0e-3
+noise_factor: 1.0
+n_epochs: 1000
+num_workers: 0
+gpus: 4
+clip_grad: True
+augment_rotation: False
+augment_noise: 0
+accumulate_grad_batches: 1
+
+auxiliary_loss: False
+loss_params:
+  max_weight: 0.001
+  schedule: 'linear'
+  clamp_lj: 3.0
+
+egnn_params:
+  device: 'cuda'
+  edge_cutoff_ligand: null
+  edge_cutoff_pocket: 5.0
+  edge_cutoff_interaction: 5.0
+  reflection_equivariant: False
+  joint_nf: 128
+  hidden_nf: 256
+  n_layers: 6
+  attention: True
+  tanh: True
+  norm_constant: 1
+  inv_sublayers: 1
+  sin_embedding: False
+  aggregation_method: 'sum'
+  normalization_factor: 100 #1  # used if aggregation_method='sum'
+
+diffusion_params:
+  diffusion_steps: 500
+  diffusion_noise_schedule: 'polynomial_2'  # learned, cosine
+  diffusion_noise_precision: 5.0e-4
+  diffusion_loss_type: 'l2'  # vlb, l2
+  normalize_factors: [1, 1]  #[10, 4]  # [x, h]
+
+eval_epochs: 50
+visualize_sample_epoch: 50
+visualize_chain_epoch: 50
+eval_params:
+  n_eval_samples: 100
+  eval_batch_size: 100
+  smiles_file: '/path/to/train_smiles.npy'
+  n_visualize_samples: 5
+  keep_frames: 100

configs/crossdock_ca_joint.yml

@@ -0,0 +1,62 @@
+run_name: 'SE3-inpaint-CA'
+logdir: '/path/to/logdir'
+wandb_params:
+  mode: 'online'  # disabled, offline, online
+  entity: 'my_username'
+dataset: 'crossdock'
+datadir: '/path/to/processed_crossdock_noH_ca_only'
+enable_progress_bar: True
+num_sanity_val_steps: 0
+
+mode: 'joint'  # joint, pocket_conditioning
+pocket_representation: 'CA'  # CA, full-atom
+batch_size: 96
+lr: 1.0e-3
+noise_factor: 1.0
+n_epochs: 1000
+num_workers: 0
+gpus: 4
+clip_grad: True
+augment_rotation: False
+augment_noise: 0
+accumulate_grad_batches: 1
+
+auxiliary_loss: False
+loss_params:
+  max_weight: 0.001
+  schedule: 'linear'
+  clamp_lj: 3.0
+
+egnn_params:
+  device: 'cuda'
+  edge_cutoff_ligand: null
+  edge_cutoff_pocket: 5.0
+  edge_cutoff_interaction: 5.0
+  reflection_equivariant: False
+  joint_nf: 128
+  hidden_nf: 256
+  n_layers: 6
+  attention: True
+  tanh: True
+  norm_constant: 1
+  inv_sublayers: 1
+  sin_embedding: False
+  aggregation_method: 'sum'
+  normalization_factor: 100 #1  # used if aggregation_method='sum'
+
+diffusion_params:
+  diffusion_steps: 500
+  diffusion_noise_schedule: 'polynomial_2'  # learned, cosine
+  diffusion_noise_precision: 5.0e-4
+  diffusion_loss_type: 'l2'  # vlb, l2
+  normalize_factors: [1, 1]  #[10, 4]  # [x, h]
+
+eval_epochs: 50
+visualize_sample_epoch: 50
+visualize_chain_epoch: 50
+eval_params:
+  n_eval_samples: 100
+  eval_batch_size: 100
+  smiles_file: '/path/to/train_smiles.npy'
+  n_visualize_samples: 5
+  keep_frames: 100

configs/crossdock_fullatom_cond.yml

@@ -0,0 +1,62 @@
+run_name: 'SE3-cond-full'
+logdir: '/path/to/logdir'
+wandb_params:
+  mode: 'online'  # disabled, offline, online
+  entity: 'my_username'
+dataset: 'crossdock'
+datadir: '/path/to/processed_crossdock_noH_full'
+enable_progress_bar: True
+num_sanity_val_steps: 0
+
+mode: 'pocket_conditioning'  # joint, pocket_conditioning
+pocket_representation: 'full-atom'  # CA, full-atom
+batch_size: 16
+lr: 1.0e-3
+noise_factor: 1.0
+n_epochs: 1000
+num_workers: 0
+gpus: 4
+clip_grad: True
+augment_rotation: False
+augment_noise: 0
+accumulate_grad_batches: 1
+
+auxiliary_loss: False
+loss_params:
+  max_weight: 0.001
+  schedule: 'linear'
+  clamp_lj: 3.0
+
+egnn_params:
+  device: 'cuda'
+  edge_cutoff_ligand: null
+  edge_cutoff_pocket: 5.0
+  edge_cutoff_interaction: 5.0
+  reflection_equivariant: False
+  joint_nf: 128
+  hidden_nf: 256
+  n_layers: 6
+  attention: True
+  tanh: True
+  norm_constant: 1
+  inv_sublayers: 1
+  sin_embedding: False
+  aggregation_method: 'sum'
+  normalization_factor: 100 #1  # used if aggregation_method='sum'
+
+diffusion_params:
+  diffusion_steps: 500
+  diffusion_noise_schedule: 'polynomial_2'  # learned, cosine
+  diffusion_noise_precision: 5.0e-4
+  diffusion_loss_type: 'l2'  # vlb, l2
+  normalize_factors: [1, 4]  #[10, 4]  # [x, h]
+
+eval_epochs: 50
+visualize_sample_epoch: 50
+visualize_chain_epoch: 50
+eval_params:
+  n_eval_samples: 100
+  eval_batch_size: 100
+  smiles_file: '/path/to/train_smiles.npy'
+  n_visualize_samples: 5
+  keep_frames: 100

configs/crossdock_fullatom_joint.yml

@@ -0,0 +1,62 @@
+run_name: 'SE3-inpaint-full'
+logdir: '/path/to/logdir'
+wandb_params:
+  mode: 'online'  # disabled, offline, online
+  entity: 'my_username'
+dataset: 'crossdock'
+datadir: '/path/to/processed_crossdock_noH_full'
+enable_progress_bar: True
+num_sanity_val_steps: 0
+
+mode: 'joint'  # joint, pocket_conditioning
+pocket_representation: 'full-atom'  # CA, full-atom
+batch_size: 8
+lr: 1.0e-3
+noise_factor: 1.0
+n_epochs: 1000
+num_workers: 0
+gpus: 4
+clip_grad: True
+augment_rotation: False
+augment_noise: 0
+accumulate_grad_batches: 4
+
+auxiliary_loss: False
+loss_params:
+  max_weight: 0.001
+  schedule: 'linear'
+  clamp_lj: 3.0
+
+egnn_params:
+  device: 'cuda'
+  edge_cutoff_ligand: null
+  edge_cutoff_pocket: 5.0
+  edge_cutoff_interaction: 5.0
+  reflection_equivariant: False
+  joint_nf: 32
+  hidden_nf: 128
+  n_layers: 5
+  attention: True
+  tanh: True
+  norm_constant: 1
+  inv_sublayers: 1
+  sin_embedding: False
+  aggregation_method: 'sum'
+  normalization_factor: 100 #1  # used if aggregation_method='sum'
+
+diffusion_params:
+  diffusion_steps: 500
+  diffusion_noise_schedule: 'polynomial_2'  # learned, cosine
+  diffusion_noise_precision: 5.0e-4
+  diffusion_loss_type: 'l2'  # vlb, l2
+  normalize_factors: [1, 4]  #[10, 4]  # [x, h]
+
+eval_epochs: 50
+visualize_sample_epoch: 50
+visualize_chain_epoch: 50
+eval_params:
+  n_eval_samples: 100
+  eval_batch_size: 100
+  smiles_file: '/path/to/train_smiles.npy'
+  n_visualize_samples: 5
+  keep_frames: 100

configs/moad_ca_cond.yml

@@ -0,0 +1,62 @@
+run_name: 'SE3-cond-CA'
+logdir: '/path/to/logdir'
+wandb_params:
+  mode: 'online'  # disabled, offline, online
+  entity: 'my_username'
+  group: 'bindingmoad'
+dataset: 'bindingmoad'
+datadir: '/path/to/processed_noH_ca/'
+enable_progress_bar: False
+num_sanity_val_steps: 0
+
+mode: 'pocket_conditioning'
+pocket_representation: 'CA'
+virtual_nodes: False
+batch_size: 64
+lr: 5.0e-4
+n_epochs: 1000
+num_workers: 2
+gpus: 1
+clip_grad: True
+augment_rotation: False
+augment_noise: 0
+
+auxiliary_loss: False
+loss_params:
+  max_weight: 0.001
+  schedule: 'linear'
+  clamp_lj: 3.0
+
+egnn_params:
+  device: 'cuda'
+  edge_cutoff_ligand: null
+  edge_cutoff_pocket: 8.0
+  edge_cutoff_interaction: 8.0
+  reflection_equivariant: False
+  edge_embedding_dim: null
+  joint_nf: 32
+  hidden_nf: 128
+  n_layers: 5
+  attention: True
+  tanh: True
+  norm_constant: 1
+  inv_sublayers: 1
+  sin_embedding: False
+  aggregation_method: 'sum'
+  normalization_factor: 100  # used if aggregation_method='sum'
+
+diffusion_params:
+  diffusion_steps: 500
+  diffusion_noise_schedule: 'polynomial_2'  # learned, cosine
+  diffusion_noise_precision: 1.0e-5
+  diffusion_loss_type: 'l2'  # vlb, l2
+  normalize_factors: [1, 4]  # [x, h]
+
+eval_epochs: 25
+visualize_sample_epoch: 25
+visualize_chain_epoch: 25
+eval_params:
+  n_eval_samples: 100
+  smiles_file: '/path/to/train_smiles.npy'
+  n_visualize_samples: 5
+  keep_frames: 100

configs/moad_ca_joint.yml

@@ -0,0 +1,62 @@
+run_name: 'SE3-joint-CA'
+logdir: '/path/to/logdir'
+wandb_params:
+  mode: 'online'  # disabled, offline, online
+  entity: 'my_username'
+  group: 'bindingmoad'
+dataset: 'bindingmoad'
+datadir: '/path/to/processed_noH_ca/'
+enable_progress_bar: False
+num_sanity_val_steps: 0
+
+mode: 'joint'
+pocket_representation: 'CA'
+virtual_nodes: False
+batch_size: 64
+lr: 5.0e-4
+n_epochs: 1000
+num_workers: 2
+gpus: 1
+clip_grad: True
+augment_rotation: False
+augment_noise: 0
+
+auxiliary_loss: False
+loss_params:
+  max_weight: 0.001
+  schedule: 'linear'
+  clamp_lj: 3.0
+
+egnn_params:
+  device: 'cuda'
+  edge_cutoff_ligand: null
+  edge_cutoff_pocket: 8.0
+  edge_cutoff_interaction: 8.0
+  reflection_equivariant: False
+  edge_embedding_dim: null
+  joint_nf: 32
+  hidden_nf: 128
+  n_layers: 5
+  attention: True
+  tanh: True
+  norm_constant: 1
+  inv_sublayers: 1
+  sin_embedding: False
+  aggregation_method: 'sum'
+  normalization_factor: 100  # used if aggregation_method='sum'
+
+diffusion_params:
+  diffusion_steps: 500
+  diffusion_noise_schedule: 'polynomial_2'  # learned, cosine
+  diffusion_noise_precision: 1.0e-5
+  diffusion_loss_type: 'l2'  # vlb, l2
+  normalize_factors: [1, 4]  # [x, h]
+
+eval_epochs: 25
+visualize_sample_epoch: 25
+visualize_chain_epoch: 25
+eval_params:
+  n_eval_samples: 100
+  smiles_file: '/path/to/train_smiles.npy'
+  n_visualize_samples: 5
+  keep_frames: 100

configs/moad_fullatom_cond.yml

@@ -0,0 +1,63 @@
+run_name: 'SE3-cond-fullAtom'
+logdir: '/path/to/logdir'
+wandb_params:
+  mode: 'online'  # disabled, offline, online
+  entity: 'my_username'
+  group: 'bindingmoad'
+dataset: 'bindingmoad'
+datadir: '/path/to/processed_noH_full/'
+enable_progress_bar: False
+num_sanity_val_steps: 0
+
+mode: 'pocket_conditioning'
+pocket_representation: 'full-atom'
+virtual_nodes: False
+batch_size: 32
+lr: 5.0e-4
+n_epochs: 1000
+num_workers: 2
+gpus: 2
+clip_grad: True
+augment_rotation: False
+augment_noise: 0
+
+auxiliary_loss: False
+loss_params:
+  max_weight: 0.001
+  schedule: 'linear'
+  clamp_lj: 3.0
+
+egnn_params:
+  device: 'cuda'
+  edge_cutoff_ligand: null
+  edge_cutoff_pocket: 4.0
+  edge_cutoff_interaction: 7.0
+  reflection_equivariant: False
+  edge_embedding_dim: 8
+  joint_nf: 128
+  hidden_nf: 192
+  n_layers: 6
+  attention: True
+  tanh: True
+  norm_constant: 1
+  inv_sublayers: 1
+  sin_embedding: False
+  aggregation_method: 'sum'
+  normalization_factor: 100  # used if aggregation_method='sum'
+
+diffusion_params:
+  diffusion_steps: 500
+  diffusion_noise_schedule: 'polynomial_2'  # learned, cosine
+  diffusion_noise_precision: 1.0e-5
+  diffusion_loss_type: 'l2'  # vlb, l2
+  normalize_factors: [1, 4]  # [x, h]
+
+eval_epochs: 25
+visualize_sample_epoch: 25
+visualize_chain_epoch: 25
+eval_params:
+  n_eval_samples: 100
+  eval_batch_size: 50
+  smiles_file: '/path/to/train_smiles.npy'
+  n_visualize_samples: 5
+  keep_frames: 100

configs/moad_fullatom_joint.yml

@@ -0,0 +1,63 @@
+run_name: 'SE3-joint-fullAtom'
+logdir: '/path/to/logdir'
+wandb_params:
+  mode: 'online'  # disabled, offline, online
+  entity: 'my_username'
+  group: 'bindingmoad'
+dataset: 'bindingmoad'
+datadir: '/path/to//processed_noH_full/'
+enable_progress_bar: False
+num_sanity_val_steps: 0
+
+mode: 'joint'
+pocket_representation: 'full-atom'
+virtual_nodes: False
+batch_size: 16
+lr: 5.0e-4
+n_epochs: 1000
+num_workers: 2
+gpus: 2
+clip_grad: True
+augment_rotation: False
+augment_noise: 0
+
+auxiliary_loss: False
+loss_params:
+  max_weight: 0.001
+  schedule: 'linear'
+  clamp_lj: 3.0
+
+egnn_params:
+  device: 'cuda'
+  edge_cutoff_ligand: null
+  edge_cutoff_pocket: 0.8  # = 4.0 / 5.0
+  edge_cutoff_interaction: 1.4  # = 7.0 / 5.0
+  reflection_equivariant: False
+  edge_embedding_dim: 8
+  joint_nf: 128
+  hidden_nf: 192
+  n_layers: 6
+  attention: True
+  tanh: True
+  norm_constant: 1
+  inv_sublayers: 1
+  sin_embedding: False
+  aggregation_method: 'sum'
+  normalization_factor: 100  # used if aggregation_method='sum'
+
+diffusion_params:
+  diffusion_steps: 500
+  diffusion_noise_schedule: 'polynomial_2'  # learned, cosine
+  diffusion_noise_precision: 1.0e-5
+  diffusion_loss_type: 'l2'  # vlb, l2
+  normalize_factors: [5, 5]  # [x, h]
+
+eval_epochs: 25
+visualize_sample_epoch: 25
+visualize_chain_epoch: 25
+eval_params:
+  n_eval_samples: 100
+  eval_batch_size: 50
+  smiles_file: '/path/to/train_smiles.npy'
+  n_visualize_samples: 5
+  keep_frames: 100

constants.py

@@ -0,0 +1,183 @@
+import numpy as np
+from rdkit import Chem
+import torch
+
+# ------------------------------------------------------------------------------
+# Computational
+# ------------------------------------------------------------------------------
+FLOAT_TYPE = torch.float32
+INT_TYPE = torch.int64
+
+
+# ------------------------------------------------------------------------------
+# Bond parameters
+# ------------------------------------------------------------------------------
+
+# margin1, margin2, margin3 = 10, 5, 3
+margin1, margin2, margin3 = 3, 2, 1
+
+allowed_bonds = {'H': 1, 'C': 4, 'N': 3, 'O': 2, 'F': 1, 'B': 3, 'Al': 3,
+                 'Si': 4, 'P': [3, 5],
+                 'S': 4, 'Cl': 1, 'As': 3, 'Br': 1, 'I': 1, 'Hg': [1, 2],
+                 'Bi': [3, 5]}
+
+# Bond lengths from:
+# http://www.wiredchemist.com/chemistry/data/bond_energies_lengths.html
+# And:
+# http://chemistry-reference.com/tables/Bond%20Lengths%20and%20Enthalpies.pdf
+bonds1 = {'H': {'H': 74, 'C': 109, 'N': 101, 'O': 96, 'F': 92,
+                'B': 119, 'Si': 148, 'P': 144, 'As': 152, 'S': 134,
+                'Cl': 127, 'Br': 141, 'I': 161},
+          'C': {'H': 109, 'C': 154, 'N': 147, 'O': 143, 'F': 135,
+                'Si': 185, 'P': 184, 'S': 182, 'Cl': 177, 'Br': 194,
+                'I': 214},
+          'N': {'H': 101, 'C': 147, 'N': 145, 'O': 140, 'F': 136,
+                'Cl': 175, 'Br': 214, 'S': 168, 'I': 222, 'P': 177},
+          'O': {'H': 96, 'C': 143, 'N': 140, 'O': 148, 'F': 142,
+                'Br': 172, 'S': 151, 'P': 163, 'Si': 163, 'Cl': 164,
+                'I': 194},
+          'F': {'H': 92, 'C': 135, 'N': 136, 'O': 142, 'F': 142,
+                'S': 158, 'Si': 160, 'Cl': 166, 'Br': 178, 'P': 156,
+                'I': 187},
+          'B': {'H':  119, 'Cl': 175},
+          'Si': {'Si': 233, 'H': 148, 'C': 185, 'O': 163, 'S': 200,
+                 'F': 160, 'Cl': 202, 'Br': 215, 'I': 243 },
+          'Cl': {'Cl': 199, 'H': 127, 'C': 177, 'N': 175, 'O': 164,
+                 'P': 203, 'S': 207, 'B': 175, 'Si': 202, 'F': 166,
+                 'Br': 214},
+          'S': {'H': 134, 'C': 182, 'N': 168, 'O': 151, 'S': 204,
+                'F': 158, 'Cl': 207, 'Br': 225, 'Si': 200, 'P': 210,
+                'I': 234},
+          'Br': {'Br': 228, 'H': 141, 'C': 194, 'O': 172, 'N': 214,
+                 'Si': 215, 'S': 225, 'F': 178, 'Cl': 214, 'P': 222},
+          'P': {'P': 221, 'H': 144, 'C': 184, 'O': 163, 'Cl': 203,
+                'S': 210, 'F': 156, 'N': 177, 'Br': 222},
+          'I': {'H': 161, 'C': 214, 'Si': 243, 'N': 222, 'O': 194,
+                'S': 234, 'F': 187, 'I': 266},
+          'As': {'H': 152}
+          }
+
+bonds2 = {'C': {'C': 134, 'N': 129, 'O': 120, 'S': 160},
+          'N': {'C': 129, 'N': 125, 'O': 121},
+          'O': {'C': 120, 'N': 121, 'O': 121, 'P': 150},
+          'P': {'O': 150, 'S': 186},
+          'S': {'P': 186, 'C': 160}}
+
+
+bonds3 = {'C': {'C': 120, 'N': 116, 'O': 113},
+          'N': {'C': 116, 'N': 110},
+          'O': {'C': 113}}
+
+bond_dict = [None, Chem.rdchem.BondType.SINGLE, Chem.rdchem.BondType.DOUBLE,
+             Chem.rdchem.BondType.TRIPLE, Chem.rdchem.BondType.AROMATIC]
+
+# https://en.wikipedia.org/wiki/Covalent_radius#Radii_for_multiple_bonds
+# (2022/08/14)
+covalent_radii = {'H': 32, 'C': 60, 'N': 54, 'O': 53, 'F': 53, 'B': 73,
+                  'Al': 111, 'Si': 102, 'P': 94, 'S': 94, 'Cl': 93, 'As': 106,
+                  'Br': 109, 'I': 125, 'Hg': 133, 'Bi': 135}
+
+# ------------------------------------------------------------------------------
+# Backbone geometry
+# Taken from: Bhagavan, N. V., and C. E. Ha.
+# "Chapter 4-Three-dimensional structure of proteins and disorders of protein misfolding."
+# Essentials of Medical Biochemistry (2015): 31-51.
+# https://www.sciencedirect.com/science/article/pii/B978012416687500004X
+# ------------------------------------------------------------------------------
+N_CA_DIST = 1.47
+CA_C_DIST = 1.53
+N_CA_C_ANGLE = 110 * np.pi / 180
+
+
+# ------------------------------------------------------------------------------
+# Dataset-specific constants
+# ------------------------------------------------------------------------------
+dataset_params = {}
+dataset_params['bindingmoad'] = {
+    'atom_encoder': {'C': 0, 'N': 1, 'O': 2, 'S': 3, 'B': 4, 'Br': 5, 'Cl': 6, 'P': 7, 'I': 8, 'F': 9},
+    'atom_decoder': ['C', 'N', 'O', 'S', 'B', 'Br', 'Cl', 'P', 'I', 'F'],
+    'aa_encoder': {'A': 0, 'C': 1, 'D': 2, 'E': 3, 'F': 4, 'G': 5, 'H': 6, 'I': 7, 'K': 8, 'L': 9, 'M': 10, 'N': 11, 'P': 12, 'Q': 13, 'R': 14, 'S': 15, 'T': 16, 'V': 17, 'W': 18, 'Y': 19},
+    'aa_decoder': ['A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y'],
+    # PyMOL colors, see: https://pymolwiki.org/index.php/Color_Values#Chemical_element_colours
+    'colors_dic': ['#33ff33', '#3333ff', '#ff4d4d', '#e6c540', '#ffb5b5', '#A62929', '#1FF01F', '#ff8000', '#940094', '#B3FFFF', '#b3e3f5'],
+    'radius_dic': [0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3],
+    'bonds1': [
+        [154.0, 147.0, 143.0, 182.0, 0.0, 194.0, 177.0, 184.0, 214.0, 135.0],
+        [147.0, 145.0, 140.0, 168.0, 0.0, 214.0, 175.0, 177.0, 222.0, 136.0],
+        [143.0, 140.0, 148.0, 151.0, 0.0, 172.0, 164.0, 163.0, 194.0, 142.0],
+        [182.0, 168.0, 151.0, 204.0, 0.0, 225.0, 207.0, 210.0, 234.0, 158.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 175.0, 0.0, 0.0, 0.0],
+        [194.0, 214.0, 172.0, 225.0, 0.0, 228.0, 214.0, 222.0, 0.0, 178.0],
+        [177.0, 175.0, 164.0, 207.0, 175.0, 214.0, 199.0, 203.0, 0.0, 166.0],
+        [184.0, 177.0, 163.0, 210.0, 0.0, 222.0, 203.0, 221.0, 0.0, 156.0],
+        [214.0, 222.0, 194.0, 234.0, 0.0, 0.0, 0.0, 0.0, 266.0, 187.0],
+        [135.0, 136.0, 142.0, 158.0, 0.0, 178.0, 166.0, 156.0, 187.0, 142.0]],
+    'bonds2': [[134.0, 129.0, 120.0, 160.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [129.0, 125.0, 121.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [120.0, 121.0, 121.0, 0.0, 0.0, 0.0, 0.0, 150.0, 0.0, 0.0],
+               [160.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 186.0, 0.0, 0.0],
+               [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [0.0, 0.0, 150.0, 186.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+    'bonds3': [[120.0, 116.0, 113.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [116.0, 110.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [113.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+               [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+    'lennard_jones_rm': [
+        [120.0, 116.0, 113.0, 160.0, 133.0, 194.0, 177.0, 184.0, 214.0, 135.0],
+        [116.0, 110.0, 121.0, 168.0, 127.0, 214.0, 175.0, 177.0, 222.0, 136.0],
+        [113.0, 121.0, 121.0, 151.0, 126.0, 172.0, 164.0, 150.0, 194.0, 142.0],
+        [160.0, 168.0, 151.0, 204.0, 167.0, 225.0, 207.0, 186.0, 234.0, 158.0],
+        [133.0, 127.0, 126.0, 167.0, 146.0, 182.0, 175.0, 167.0, 198.0, 126.0],
+        [194.0, 214.0, 172.0, 225.0, 182.0, 228.0, 214.0, 222.0, 234.0, 178.0],
+        [177.0, 175.0, 164.0, 207.0, 175.0, 214.0, 199.0, 203.0, 218.0, 166.0],
+        [184.0, 177.0, 150.0, 186.0, 167.0, 222.0, 203.0, 221.0, 219.0, 156.0],
+        [214.0, 222.0, 194.0, 234.0, 198.0, 234.0, 218.0, 219.0, 266.0, 187.0],
+        [135.0, 136.0, 142.0, 158.0, 126.0, 178.0, 166.0, 156.0, 187.0, 142.0]],
+    'atom_hist': {'C': 545542, 'N': 90205, 'O': 132965, 'S': 9342, 'B': 109,
+                  'Br': 1424, 'Cl': 5516, 'P': 5154, 'I': 445, 'F': 9742},
+    'aa_hist': {'A': 109798, 'C': 31556, 'D': 83921, 'E': 79405, 'F': 97083,
+                'G': 139319, 'H': 62661, 'I': 99008, 'K': 62403, 'L': 155105,
+                'M': 59977, 'N': 70437, 'P': 58833, 'Q': 48254, 'R': 74215,
+                'S': 103286, 'T': 90972, 'V': 119954, 'W': 42017, 'Y': 90596},
+}
+
+dataset_params['crossdock_full'] = {
+      'atom_encoder': {'C': 0, 'N': 1, 'O': 2, 'S': 3, 'B': 4, 'Br': 5, 'Cl': 6, 'P': 7, 'I': 8, 'F': 9, 'others': 10},
+      'atom_decoder': ['C', 'N', 'O', 'S', 'B', 'Br', 'Cl', 'P', 'I', 'F', 'others'],
+      'aa_encoder': {'C': 0, 'N': 1, 'O': 2, 'S': 3, 'B': 4, 'Br': 5, 'Cl': 6, 'P': 7, 'I': 8, 'F': 9, 'others': 10},
+      'aa_decoder': ['C', 'N', 'O', 'S', 'B', 'Br', 'Cl', 'P', 'I', 'F', 'others'],
+      'colors_dic': ['#33ff33', '#3333ff', '#ff4d4d', '#e6c540', '#ffb5b5', '#A62929', '#1FF01F', '#ff8000', '#940094', '#B3FFFF', '#ffb5b5'],
+      'radius_dic': [0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3],
+      'bonds1': [[154.0, 147.0, 143.0, 182.0, 0.0, 194.0, 177.0, 184.0, 214.0, 135.0, 0.0], [147.0, 145.0, 140.0, 168.0, 0.0, 214.0, 175.0, 177.0, 222.0, 136.0, 0.0], [143.0, 140.0, 148.0, 151.0, 0.0, 172.0, 164.0, 163.0, 194.0, 142.0, 0.0], [182.0, 168.0, 151.0, 204.0, 0.0, 225.0, 207.0, 210.0, 234.0, 158.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 175.0, 0.0, 0.0, 0.0, 0.0], [194.0, 214.0, 172.0, 225.0, 0.0, 228.0, 214.0, 222.0, 0.0, 178.0, 0.0], [177.0, 175.0, 164.0, 207.0, 175.0, 214.0, 199.0, 203.0, 0.0, 166.0, 0.0], [184.0, 177.0, 163.0, 210.0, 0.0, 222.0, 203.0, 221.0, 0.0, 156.0, 0.0], [214.0, 222.0, 194.0, 234.0, 0.0, 0.0, 0.0, 0.0, 266.0, 187.0, 0.0], [135.0, 136.0, 142.0, 158.0, 0.0, 178.0, 166.0, 156.0, 187.0, 142.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+      'bonds2': [[134.0, 129.0, 120.0, 160.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [129.0, 125.0, 121.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [120.0, 121.0, 121.0, 0.0, 0.0, 0.0, 0.0, 150.0, 0.0, 0.0, 0.0], [160.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 186.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 150.0, 186.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+      'bonds3': [[120.0, 116.0, 113.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [116.0, 110.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [113.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+      'lennard_jones_rm': [[120.0, 116.0, 113.0, 160.0, 133.0, 194.0, 177.0, 184.0, 214.0, 135.0, 0.0], [116.0, 110.0, 121.0, 168.0, 127.0, 214.0, 175.0, 177.0, 222.0, 136.0, 0.0], [113.0, 121.0, 121.0, 151.0, 126.0, 172.0, 164.0, 150.0, 194.0, 142.0, 0.0], [160.0, 168.0, 151.0, 204.0, 167.0, 225.0, 207.0, 186.0, 234.0, 158.0, 0.0], [133.0, 127.0, 126.0, 167.0, 146.0, 182.0, 175.0, 167.0, 198.0, 126.0, 0.0], [194.0, 214.0, 172.0, 225.0, 182.0, 228.0, 214.0, 222.0, 234.0, 178.0, 0.0], [177.0, 175.0, 164.0, 207.0, 175.0, 214.0, 199.0, 203.0, 218.0, 166.0, 0.0], [184.0, 177.0, 150.0, 186.0, 167.0, 222.0, 203.0, 221.0, 219.0, 156.0, 0.0], [214.0, 222.0, 194.0, 234.0, 198.0, 234.0, 218.0, 219.0, 266.0, 187.0, 0.0], [135.0, 136.0, 142.0, 158.0, 126.0, 178.0, 166.0, 156.0, 187.0, 142.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+      'atom_hist': {'C': 1570767, 'N': 273858, 'O': 396837, 'S': 26352, 'B': 0, 'Br': 0, 'Cl': 15058, 'P': 25994, 'I': 0, 'F': 30687, 'others': 0},
+      'aa_hist': {'C': 23302704, 'N': 6093090, 'O': 6701210, 'S': 276805, 'B': 0, 'Br': 0, 'Cl': 0, 'P': 0, 'I': 0, 'F': 0, 'others': 0},
+}
+
+dataset_params['crossdock'] = {
+      'atom_encoder': {'C': 0, 'N': 1, 'O': 2, 'S': 3, 'B': 4, 'Br': 5, 'Cl': 6, 'P': 7, 'I': 8, 'F': 9},
+      'atom_decoder': ['C', 'N', 'O', 'S', 'B', 'Br', 'Cl', 'P', 'I', 'F'],
+      'aa_encoder': {'A': 0, 'C': 1, 'D': 2, 'E': 3, 'F': 4, 'G': 5, 'H': 6, 'I': 7, 'K': 8, 'L': 9, 'M': 10, 'N': 11, 'P': 12, 'Q': 13, 'R': 14, 'S': 15, 'T': 16, 'V': 17, 'W': 18, 'Y': 19},
+      'aa_decoder': ['A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y'],
+      # PyMOL colors, see: https://pymolwiki.org/index.php/Color_Values#Chemical_element_colours
+      'colors_dic': ['#33ff33', '#3333ff', '#ff4d4d', '#e6c540', '#ffb5b5', '#A62929', '#1FF01F', '#ff8000', '#940094', '#B3FFFF'],
+      'radius_dic': [0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3],
+      'bonds1': [[154.0, 147.0, 143.0, 182.0, 0.0, 194.0, 177.0, 184.0, 214.0, 135.0], [147.0, 145.0, 140.0, 168.0, 0.0, 214.0, 175.0, 177.0, 222.0, 136.0], [143.0, 140.0, 148.0, 151.0, 0.0, 172.0, 164.0, 163.0, 194.0, 142.0], [182.0, 168.0, 151.0, 204.0, 0.0, 225.0, 207.0, 210.0, 234.0, 158.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 175.0, 0.0, 0.0, 0.0], [194.0, 214.0, 172.0, 225.0, 0.0, 228.0, 214.0, 222.0, 0.0, 178.0], [177.0, 175.0, 164.0, 207.0, 175.0, 214.0, 199.0, 203.0, 0.0, 166.0], [184.0, 177.0, 163.0, 210.0, 0.0, 222.0, 203.0, 221.0, 0.0, 156.0], [214.0, 222.0, 194.0, 234.0, 0.0, 0.0, 0.0, 0.0, 266.0, 187.0], [135.0, 136.0, 142.0, 158.0, 0.0, 178.0, 166.0, 156.0, 187.0, 142.0]],
+      'bonds2': [[134.0, 129.0, 120.0, 160.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [129.0, 125.0, 121.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [120.0, 121.0, 121.0, 0.0, 0.0, 0.0, 0.0, 150.0, 0.0, 0.0], [160.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 186.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 150.0, 186.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+      'bonds3': [[120.0, 116.0, 113.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [116.0, 110.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [113.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+      'lennard_jones_rm': [[120.0, 116.0, 113.0, 160.0, 133.0, 194.0, 177.0, 184.0, 214.0, 135.0], [116.0, 110.0, 121.0, 168.0, 127.0, 214.0, 175.0, 177.0, 222.0, 136.0], [113.0, 121.0, 121.0, 151.0, 126.0, 172.0, 164.0, 150.0, 194.0, 142.0], [160.0, 168.0, 151.0, 204.0, 167.0, 225.0, 207.0, 186.0, 234.0, 158.0], [133.0, 127.0, 126.0, 167.0, 146.0, 182.0, 175.0, 167.0, 198.0, 126.0], [194.0, 214.0, 172.0, 225.0, 182.0, 228.0, 214.0, 222.0, 234.0, 178.0], [177.0, 175.0, 164.0, 207.0, 175.0, 214.0, 199.0, 203.0, 218.0, 166.0], [184.0, 177.0, 150.0, 186.0, 167.0, 222.0, 203.0, 221.0, 219.0, 156.0], [214.0, 222.0, 194.0, 234.0, 198.0, 234.0, 218.0, 219.0, 266.0, 187.0], [135.0, 136.0, 142.0, 158.0, 126.0, 178.0, 166.0, 156.0, 187.0, 142.0]],
+      'atom_hist': {'C': 1570032, 'N': 273792, 'O': 396623, 'S': 26339, 'B': 0, 'Br': 0, 'Cl': 15055, 'P': 25975, 'I': 0, 'F': 30673},
+      'aa_hist': {'A': 277175, 'C': 92406, 'D': 254046, 'E': 201833, 'F': 234995, 'G': 376966, 'H': 147704, 'I': 290683, 'K': 173210, 'L': 421883, 'M': 157813, 'N': 174241, 'P': 148581, 'Q': 120232, 'R': 173848, 'S': 274430, 'T': 247605, 'V': 326134, 'W': 88552, 'Y': 226668},
+}

data/moad_test.txt

@@ -0,0 +1 @@
+5NDU-bio2_8V2:B:201,6PB9-bio1_PAM:A:301,2GM1-bio1_2AZ:A:371,3K3B-bio1_L31:A:371,3L9H-bio1_EMQ:A:601,2UYI-bio1_K02:A:604,5NCF-bio2_8T5:B:204,3F7H-bio2_419:B:1,1LT6-bio2_GAA:M:104,3F7I-bio1_G13:A:1,1EEI-bio1_GAA:G:507,2PG2-bio1_K01:A:604,1FD7-bio1_AI1:H:104,1YRS-bio2_L47:B:603,2PG2-bio1_K01:B:604,2VL8-bio1_CTS:A:1544,1J6Z-bio1_RHO:A:1381,3KEN-bio1_ZZD:A:370,1LT6-bio1_GAA:H:104,2FL6-bio2_N5T:B:605,2Q2Y-bio2_MKR:B:605,3F7I-bio2_G13:B:1,1YRS-bio1_L47:A:604,6C0B-bio1_PAM:B:202,6P7R-bio1_PAM:A:301,1MFI-bio1_FHC:C:117,1EFI-bio1_GAT:G:107,1FD7-bio2_AI1:P:104,5NCG-bio2_8TB:B:202,1DTL-bio1_BEP:A:206,1LT6-bio1_GAA:D:104,3CJO-bio1_K30:A:1,1FD7-bio2_AI1:N:104,1EFI-bio1_GAT:F:106,2UYI-bio2_K02:B:604,1RVX-bio1_NAG:A:3017,1EEI-bio1_GAA:E:505,1MFI-bio1_FHC:A:115,5NEG-bio1_8VK:B:201,5NEG-bio1_8VK:A:201,2VL8-bio3_CTS:C:1544,1DTL-bio1_BEP:A:204,7AKI-bio1_RJQ:A:203,1LT6-bio1_GAA:F:104,1Q0B-bio1_NAT:A:604,1RVX-bio2_NAG:G:3012,1EFI-bio1_GAT:H:108,3EKU-bio1_CY9:A:903,1RDW-bio1_LAR:X:391,3MN5-bio1_LAB:A:376,1RV0-bio1_NDG:H:642,3GT9-bio2_516:B:1,1FD7-bio1_AI1:E:104,3GTA-bio2_851:B:1,1BXM-bio1_ERG:A:99,4PA0-bio2_2OW:B:1101,2UYM-bio1_K03:A:604,2GM1-bio3_2AZ:D:371,1MFI-bio1_FHC:B:116,1DTL-bio1_BEP:A:205,3K3B-bio2_L31:B:372,1OKE-bio1_BOG:B:1400,2A5X-bio1_LAR:A:379,1LT6-bio2_GAA:P:104,2FME-bio1_3QC:A:370,3F7H-bio1_419:A:1,1FD7-bio1_AI1:G:104,6G6Y-bio1_EOK:A:403,1J78-bio2_VDY:B:500,1EFI-bio1_GAT:E:105,2FL2-bio1_N4T:A:604,1FD7-bio2_AI1:O:104,3GTA-bio1_851:A:1,7AKI-bio1_RJQ:A:202,5XDU-bio1_ZI6:A:403,3ZJX-bio3_BOG:C:1296,1EEI-bio1_GAA:F:506,2GM1-bio2_2AZ:B:371,1LT6-bio1_GAA:E:104,2X7E-bio2_X7E:B:1365,2UYM-bio2_K03:B:604,1FD7-bio1_AI1:D:104,3L9H-bio2_EMQ:B:602,2I3I-bio2_618:B:501,2VL8-bio2_CTS:B:1544,5NCG-bio1_8TB:A:203,2Q0U-bio1_LAB:A:401,2FME-bio2_3QC:B:370,2FL6-bio1_N5T:A:604,1Q0B-bio2_NAT:B:605,1LT6-bio1_GAA:G:104,5NCF-bio1_8T5:A:201,1EEI-bio1_GAA:D:504,1LT6-bio2_GAA:O:104,1FD7-bio2_AI1:M:104,1RV0-bio1_NDG:J:640,3GT9-bio1_516:A:1,2FKY-bio2_N2T:B:605,1RVX-bio1_NAG:A:3018,5NCP-bio1_EG5:A:201,5ZZB-bio2_LAB:D:401,3UKR-bio1_CKH:B:401,3PA8-bio1_621:B:300,2Q2Y-bio1_MKR:A:604,2FKY-bio1_N2T:A:604,1RV0-bio1_DAN:L:701,1RVT-bio1_NDG:H:742,1LT6-bio2_GAA:L:104,5NCG-bio1_8TB:A:201,1SQK-bio1_LAR:A:378,1ESV-bio1_LAR:A:401,1FD7-bio1_AI1:F:104,5NCG-bio1_8TB:A:202,1EEI-bio1_GAA:H:508,3EKS-bio1_CY9:A:903,6RCF-bio1_K0K:A:201,2FL2-bio2_N4T:B:605,3CJO-bio2_K30:B:603,4PA0-bio1_2OW:A:1101,1FD7-bio2_AI1:L:104,6RCJ-bio1_K0H:A:201,2I3I-bio1_618:A:501,2GM1-bio4_2AZ:E:371,5NDU-bio1_8V2:A:201,5NCG-bio2_8TB:B:201,3PA8-bio1_621:A:300,1LT6-bio2_GAA:N:104,3ZJX-bio4_BOG:D:1296,6RVP-bio1_MB3:A:403,1EFI-bio1_GAT:D:104

data/moad_val.txt

@@ -0,0 +1 @@
+1YEC_PNB:H:551,2JKL_CLM:A:1144,2JKL_BRX:A:1143,2JKL_BRX:B:1142,2JKL_BRX:B:1143,2JKL_CLM:B:1144,2JKL_BRX:C:1142,2JKL_CLM:C:1143,2JKL_BRX:E:1142,2JKL_CLM:E:1143,2JKL_BRX:D:1143,2JKL_CLM:D:1145,2JKL_BRX:D:1144,2JKL_BRX:F:1142,2JKL_CLM:F:1143,6V3J_NAG:G:301,3FO2_BZH:A:401,3FO2_BZH:H:401,2DDQ_HRB:L:502,5LN4_CHT:B:201,5LN4_CHT:C:201,1USQ_CLM:A:1143,1USQ_CLM:B:1143,1USQ_CLM:C:1143,1USQ_CLM:D:1142,1USQ_CLM:E:1143,1USQ_CLM:F:1144,2HXW_FLC:B:301,3GMM_PLM:A:301,1B09_PC:B:500,1B09_PC:D:500,1B09_PC:E:500,1B09_PC:C:500,1B09_PC:A:500,3VRI_1KX:A:301,2BMK_PDD:B:1217,2BMK_PDD:L:1215,1OAR_AZN:H:500,1OAR_AZN:I:500,1OAR_AZN:J:500,1OAR_AZN:K:500,2BFV_STG:H:200,2AJV_COC:L:501,1RUM_BEZ:H:1601,6ITP_HCY:B:201,6ITP_HCY:A:201,3CFB_SPB:B:302,3CFB_SPB:L:301,4MRH_2CQ:A:201,6VH6_QX4:B:701,6BE3_NAG:H:301,1UB5_SPB:H:601,1UB5_SPB:B:701,2JKJ_CLM:A:1141,2JKJ_CLM:B:1141,2JKJ_TH8:B:1142,2JKJ_CLM:C:1141,2JKJ_CLM:D:1142,2JKJ_TH8:D:1143,2JKJ_CLM:E:1141,2JKJ_CLM:F:1143,3OAZ_2M5:H:237,3OAZ_2M5:M:232,1X9Q_FLU:A:1341,2PYE_7PE:A:504,1RUA_BEZ:H:601,5ZQK_SAM:A:1001,3BQM_BQM:B:1,3BQM_BQM:C:1,1JGU_HBC:H:3001,1F3D_TPM:J:401,1F3D_TPM:L:400,1WC7_PP3:A:1214,1YEI_PGG:L:551,3FJG_3PG:C:301,3FJG_3PG:D:301,2PCP_1PC:B:227,2PCP_1PC:C:212,1LO3_AN1:Y:500,1LO3_AN1:H:501,35C8_NOX:L:212,1XDD_AAY:A:401,1XDD_AAY:B:501,1I7Z_COC:A:301,1I7Z_COC:C:302,4K3H_1OM:A:201,4K3H_1OM:D:201,4K3H_1OM:E:201,4K3H_1OM:G:201,6NPI_60Q:B:701,6NPI_KW1:B:702,1FE8_NAG:I:553,2OMN_IPH:B:401,2DWE_TBA:C:4001,6LB2_EKG:A:322,6LB2_EKG:C:316,3FO1_BZH:H:401,3FO1_BZH:B:401,3IF1_NGA:B:1,3IF1_NGA:D:213,6LAH_EKG:A:309,6LAH_EKG:C:321,3UPR_1KX:A:277,3UPR_1KX:C:277,6PVD_N18:A:301,6PVD_N18:C:301,1YEK_NPO:H:551,1RUL_BEZ:H:601,5J6H_NCA:A:402,3KDM_TES:H:226,3KDM_TES:B:226,6ITQ_HCY:D:201,6ITQ_HCY:B:201,6ITQ_HCY:A:201,6ITQ_HCY:C:201,1EAP_HEP:B:222,1GHQ_NDG:C:701,2Z93_END:C:1,2AJX_TGN:L:501,6X42_I3C:X:904,1RIU_RBE:H:201,1T66_FLU:L:300,1T66_FLU:C:301,1RIV_OBE:H:201,4MRG_24W:A:201,3VRJ_1KX:A:301,2YK1_NCT:H:300,2CJU_PHX:H:1114,1RD4_L08:A:328,1RD4_L08:B:1328,1RD4_L08:C:2328,1RD4_L08:D:3328,1LO2_OX1:Y:500,1LO2_OX1:H:501,1UM5_SS1:H:1001,4LCW_1VY:A:302,4LCW_1VY:C:301,6LT6_EKG:A:301,4F8N_PC:A:202,6PVC_P1J:A:402,6PVC_P1J:C:301,2C1P_FNZ:B:1215,2C1P_FNZ:H:1214,5U98_1KX:A:301,5U98_1KX:D:301,43CA_NPO:A:921,43CA_NPO:C:922,43CA_NPO:E:923,43CA_NPO:G:924,2YIO_YIO:A:1141,2YIO_YIO:B:1138,2YIP_YIO:A:1135,2YIP_YIO:B:1135,2YIP_YIO:C:1135,2YIP_YIO:D:1135,2YIP_YIO:E:1135,2YIP_YIO:F:1135,4NP2_2L1:A:201,1QYG_BCG:H:401,1UM4_SH4:H:1001,1MJJ_HAL:A:1001,1MJJ_HAL:H:1002,1MRF_DI:L:901,1LO0_BC1:Y:500,1LO0_BC1:H:501,1KN4_PDE:L:551,6NPP_KWG:B:701,2ICA_2IC:A:1,1MEX_RAC:H:601,1MH5_HAL:B:601,1MH5_HAL:H:602,1XUO_LA1:A:401,4F8L_AES:A:239,1A6V_NPC:H:430,1C1E_ENH:H:703,3F78_ICF:A:1,3F78_ICF:B:2,2CGR_GAS:H:215,1XDG_AB8:A:401,1XDG_AB8:B:501,3VKX_T3:A:301,1BFV_STG:H:200,1FLR_FLU:L:600,1GAF_NPE:H:218,25C8_GEP:L:212,5XQW_8EU:H:301,4L4V_1VY:A:301,4L4V_1VY:C:301,2O5Z_ANO:H:501,1CFV_E3G:H:200,3M6F_BJZ:A:1,1Y0L_HAN:H:501,1Y0L_HAN:A:601,1Y0L_HAN:D:701,1Y0L_HAN:F:801,6NUX_FOF:A:301,2YKL_NLD:H:1213,1JGL_EST:L:911,4IA6_EIC:A:608,1FL3_SPB:L:225,1FL3_SPB:A:226,2AJZ_ECG:L:301,2AJZ_ECG:A:302,6LAM_EKG:A:311,6LAM_EKG:C:316,1MJ7_HAL:H:301,4NP3_2L2:A:201,2BJM_ANF:H:500,3FJ7_PEQ:A:301,3FJ7_PEQ:B:301,1NGP_NPA:H:302,2HVK_TBA:C:4001,6OOY_A7M:C:201,1C5C_TK4:L:1001,1YEG_BPN:L:551,3T0W_DIW:A:204,1DL7_NCH:L:999,1Q72_COC:H:401,7JRA_VGY:B:301,2Z92_ENE:A:1,1YEF_PNC:L:551,2AJY_ECG:L:304,2O7N_2O7:A:1,2R2E_KDE:A:214,1YEE_PNB:H:551,1AJ7_NPE:H:217,1YNK_SC5:H:501,1Q0Y_MOI:H:401,6NPM_KVD:B:701,6DZN_AE3:L:304,1VPO_TES:H:1010,4MRF_2CK:A:203,3FO0_BZH:H:401,4MRE_2C9:A:202,1WZ1_DNS:H:200,2E27_AB0:H:6001,3T0X_DIW:A:201,1A4K_FRA:H:3083,1A4K_FRA:B:3083,1A0Q_HEP:H:214,1D6V_HOP:H:401,1H8S_AIC:A:1000,1F4X_MGS:H:301,1KN2_PNE:L:551,3CFD_SPB:B:302,3CFD_SPB:H:301

data/prepare_crossdocked.py

@@ -0,0 +1,55 @@
+import sys
+import torch
+import shutil
+from pathlib import Path
+
+from rdkit import Chem
+from tqdm import tqdm
+
+
+basedir = sys.argv[1]
+structure_dir = Path(basedir, 'crossdocked_pocket10')
+
+test_set = torch.load(Path(basedir, 'split_by_name.pt'))['test']
+
+receptor_dir = Path(basedir, 'receptor_pdbs')
+receptor_dir.mkdir(exist_ok=True)
+
+ref_ligand_dir = Path(basedir, 'reference_ligands')
+ref_ligand_dir.mkdir(exist_ok=True)
+
+methods = ['cvae', 'sbdd', 'p2m']
+for method in methods:
+    method_lig_dir = Path(basedir, f'{method}_processed')
+    method_lig_dir.mkdir(exist_ok=True)
+
+for pocket_idx, (receptor_name, ligand_name) in enumerate(tqdm(test_set)):
+
+    # copy receptor file and remove underscores
+    new_rec_name = Path(receptor_name).stem.replace('_', '-')
+    shutil.copy(Path(structure_dir, receptor_name), Path(receptor_dir, new_rec_name + '.pdb'))
+
+    # copy and rename reference ligands
+    new_lig_name = new_rec_name + '_' + Path(ligand_name).stem.replace('_', '-')
+    shutil.copy(Path(structure_dir, ligand_name), Path(ref_ligand_dir, new_lig_name + '.sdf'))
+
+    for method in methods:
+
+        method_pocket_dir = Path(basedir, method, f'pocket_{pocket_idx}')
+
+        generated_mols = [Chem.SDMolSupplier(str(file), sanitize=False)[0]
+                          for file in method_pocket_dir.glob(f'mol_*.sdf')]
+
+        # only select first 100 molecules
+        generated_mols = generated_mols[:100]
+        if len(generated_mols) < 1:
+            print('No molecule found for this pocket')
+            continue
+        if len(generated_mols) < 100:
+            print('Less than 100 molecules found for this pocket')
+
+        # write a combined sdf file
+        sdf_path = Path(basedir, f'{method}_processed', f'{new_rec_name}_mols-pocket-{pocket_idx}.sdf')
+        with Chem.SDWriter(str(sdf_path)) as w:
+            for mol in generated_mols:
+                w.write(mol)

data/timesplit_no_lig_or_rec_overlap_train

@@ -0,0 +1,14037 @@
+4lp9
+3dpf
+1me7
+2zy1
+5c0m
+4o2c
+2zv9
+3a2c
+3b2t
+1v2q
+4q87
+4j28
+3efw
+3k8c
+3s54
+2fda
+2q55
+3fzn
+3eoc
+4tn2
+3hfv
+2qo8
+5gg4
+5svi
+2r58
+1cw2
+1ft7
+4hww
+6b1j
+3di6
+5jaz
+5ema
+5am5
+4bnt
+1fq6
+3pqz
+4nw7
+4ahr
+1p1o
+3le8
+3nzk
+1eoc
+3qw8
+4za0
+5l8a
+5teg
+5u6j
+2wp1
+1zyr
+4m6q
+2jq9
+4m5h
+2ll6
+4hw3
+6eq5
+3hqy
+2gv6
+5yjb
+4lwv
+4lm4
+3g30
+5f32
+4dkr
+6b4l
+4j9a
+5w86
+4mpn
+5m51
+3bea
+2wtd
+2o65
+6dqb
+5q0e
+2r03
+4xv9
+4y0a
+4kqq
+5ota
+3u5l
+3m3o
+2w47
+2g5u
+5wzs
+5mky
+3ibc
+2qwf
+3p76
+4np3
+4kb8
+4tkf
+2xvd
+2fai
+5ar8
+2lzg
+3e62
+1p6e
+1p02
+6gjr
+1nhu
+4yyl
+3rdv
+3jzq
+4pce
+4gvu
+4n7g
+3s9e
+3k3b
+1pmn
+1ogd
+2j4i
+1oss
+1v0k
+1d4w
+6cn6
+2btr
+6egw
+4zx1
+4zfi
+2rfn
+5cep
+2xyu
+3eou
+4mme
+4fnn
+4gkh
+6d1l
+6dlj
+1q4l
+5i94
+1eb2
+4qzw
+3fu0
+4aif
+5eec
+2qlj
+5cfb
+5sy3
+1mhw
+2flu
+3e6y
+4wiv
+5oot
+4bae
+3po6
+2wo9
+1rp7
+1l2s
+5ab1
+3pce
+2w6z
+3e85
+3e12
+5arf
+1ikw
+6goo
+4zdu
+3wcb
+2w1h
+4x2i
+4mm5
+6ggv
+5f2u
+1o46
+3iej
+2jnw
+3gpj
+5uex
+1ndw
+1zhk
+4mcd
+4cps
+3gcp
+5try
+4c2v
+3otq
+2yns
+4m0e
+5tkj
+2m3z
+3ftu
+3pa5
+5o0b
+3m58
+5u6k
+4yw6
+3ewh
+3wc7
+1rhk
+3gi4
+2wd7
+3jq8
+5yr5
+2xye
+6fnf
+3hx3
+4mz6
+1ol2
+4aa5
+1olu
+2wk2
+1rry
+1ozv
+5jf6
+4mnq
+5wa5
+3nlb
+3f6e
+2xu5
+3wk7
+4p6w
+2pmc
+3byo
+5ehe
+6c8x
+3pp1
+3ad7
+3qzq
+2z97
+5d1r
+4pxf
+2w1e
+3upk
+4gj8
+1td7
+6erw
+4rhx
+1hxw
+6cbf
+5qal
+1q8w
+4mf0
+5t1s
+1fzk
+4tju
+5o0j
+2v87
+1my2
+1epo
+2r5p
+4pis
+5czm
+3ehy
+2r1x
+2f8i
+3dek
+5wre
+3hp2
+4bcw
+4uau
+5ap3
+2ksa
+5ekg
+5lh8
+2uw7
+3uvq
+2glp
+3m3r
+6bsx
+2ddf
+2mwp
+1h4n
+4jit
+5f4r
+4ybj
+4kz8
+4ogi
+5ufp
+4uiw
+3igv
+5b56
+1bn3
+2xg9
+5oua
+5qaa
+6h7j
+2o7v
+5v7t
+2r02
+2j94
+1o3k
+4mr4
+5am7
+6g35
+1ljt
+3srv
+4bi6
+2yoh
+5tln
+3rkb
+5jiq
+1tkz
+3qrk
+3c45
+3nf3
+2oaz
+3pwk
+3ryy
+2y7k
+6dm8
+5ism
+5i7u
+2qtn
+5n1y
+4kot
+5wa1
+188l
+3h2o
+1sw1
+1zuc
+2nnq
+4l8m
+5j75
+4afe
+5nwi
+2n06
+3l4w
+3ibl
+4l31
+4ruy
+5sxk
+4hnn
+4zij
+3fdn
+5fe6
+3nuj
+5h8x
+5ets
+1w3k
+3ro0
+3zi8
+1nl4
+5mb1
+5cao
+4gjd
+2p3d
+2z8e
+3w2p
+1f28
+2iw6
+1h9l
+4o78
+1soj
+3krw
+5drr
+3t4v
+1sqp
+5o0a
+4c4i
+2vwx
+6miq
+6guk
+5c3k
+5fhn
+3o75
+5kap
+4zo5
+2jko
+3iss
+4eg6
+4fcd
+4bcf
+1ikx
+6f6i
+1om2
+6axb
+3s3n
+1fl6
+4luo
+3zlw
+1qiw
+5f2w
+5tbj
+5k0c
+5ndf
+1ek2
+4zb8
+3r9o
+5qah
+3avb
+5mi6
+6fu5
+4ymq
+3dpo
+4z7q
+5mri
+2byp
+5du8
+1i7z
+1ec3
+5jmx
+4yxi
+3iw7
+3l4v
+3wcf
+5igk
+1wum
+3rv6
+1x7r
+2c57
+6cwh
+3hkq
+2xag
+5nw7
+5qau
+4ocz
+3chg
+6fns
+5oh1
+1hkm
+5e0l
+3mn8
+5ngf
+4bo6
+1b57
+5wzt
+4uzd
+1cyn
+3eys
+4umc
+6guh
+2e99
+2p8o
+2xb8
+5tus
+6ap7
+4ajn
+4od7
+5v40
+5wjj
+3kc0
+3zs1
+4igq
+5e8r
+4ci1
+3qd0
+2ohv
+3uw5
+3lp4
+3ftw
+6c5q
+4hbw
+2yoj
+4b2i
+3mkn
+1i5r
+5tig
+5bqs
+1oz0
+5a2s
+3fkv
+3qnj
+5w5o
+2cht
+5dj5
+5oje
+4hxs
+5t36
+5gmh
+4eh9
+3kr2
+3rk5
+2b54
+2zxa
+4e70
+4huo
+3zrk
+2iw8
+4ge4
+5nwc
+5lmb
+4i6h
+5y6e
+3n87
+5bvn
+4lxd
+3b3s
+5j9f
+3jzp
+2no3
+1ouk
+5epk
+1g7g
+6au2
+4wt6
+3w2q
+5tdr
+4xx9
+1jg0
+2n27
+5lyn
+1p1q
+1hi3
+2wih
+4hym
+4ew3
+5ixq
+1h60
+3ppk
+4x8s
+3ddf
+1kv2
+4djq
+1ze8
+5ia1
+2qcm
+5m9d
+2erz
+4g0l
+5tqg
+2i5j
+1met
+3r42
+3i97
+1alw
+2r5q
+5cav
+5wj6
+2o7n
+2r4f
+5nkn
+2g6p
+1bnu
+4itj
+4uc5
+3kze
+5dg6
+1nym
+6cki
+4kmz
+6hsh
+4zj8
+6ggn
+4qzx
+5ety
+1o5a
+4otf
+1pgp
+5wex
+4h4m
+4j53
+5dva
+1e3v
+4wop
+4jls
+5mxv
+4m7c
+3fvn
+4xu1
+5ivn
+2o4n
+4olh
+1m5b
+3t1a
+1mqi
+5n84
+4q1e
+5ifu
+5lgr
+5unf
+5w5u
+5tq1
+3dkj
+1br8
+3tsd
+6dvn
+1oxg
+4kz5
+5v3h
+4avi
+220l
+2xbv
+3twx
+5zo8
+2w4i
+4q8y
+5acy
+5l7e
+3arp
+4rt1
+4mq6
+6ey7
+3uzd
+2b9a
+5o4z
+3faa
+2ow0
+6f5w
+1x7q
+5agv
+5pzm
+6afh
+4z1e
+5flp
+1b4z
+5f1r
+1uwh
+3bmo
+1p19
+6fbv
+4lrr
+1gi9
+4xuh
+2weo
+5vqx
+5xpi
+4btm
+5h0e
+4gye
+6bgu
+5wlt
+1t49
+5k1v
+1fsw
+6cvx
+6c3e
+6cj5
+5fqc
+3uwl
+3pka
+5l3g
+5jnc
+3ps6
+6csr
+3hau
+3ud9
+6csp
+5lqf
+4bfz
+2xp6
+3sjo
+5os3
+4z8d
+5un1
+6esy
+3kjq
+5mgl
+5dp5
+3n0h
+5fao
+6dxl
+4qw0
+3q92
+3rwf
+2xke
+4gfo
+3t03
+3pd8
+3f18
+4utr
+5n1s
+3wkb
+2zdt
+2yit
+5x54
+5dpa
+4rt0
+2y5h
+3cde
+5lud
+3vva
+2wev
+5mrm
+4ypf
+5ea4
+3fr5
+4tkh
+4n9e
+5tyi
+1db1
+4hxj
+3hu1
+5ftg
+2eh8
+1jiz
+4est
+5nih
+1rr6
+4fp1
+4y24
+3lea
+4lch
+4qjr
+4os1
+4pft
+5eb3
+5qad
+3cpc
+3c94
+5jhb
+6b22
+3vfj
+6hmx
+1kuk
+2gh9
+1il9
+1xh6
+3eyl
+5hng
+3nes
+3i1y
+2anl
+3n2e
+2n0u
+4zt6
+4f6v
+5n7g
+4yc9
+4igr
+3q6w
+2cmb
+3pww
+4cpr
+3t2t
+5d7x
+3muf
+5f95
+5e2w
+2chx
+2pk6
+3bet
+6cje
+5khk
+4eh5
+1i9l
+4q4o
+1kf0
+1llb
+5aep
+2zp0
+3zze
+6dar
+5eyk
+3u7n
+4z0e
+5fh6
+5kj2
+2o4k
+5llg
+3li2
+3of8
+3mvh
+1jut
+1auj
+5awj
+5x73
+1f90
+4crd
+1d2e
+5byz
+3gol
+2h9m
+3vbg
+3rse
+2ydk
+4mp2
+3hhk
+5tur
+2xxr
+2r3w
+4u6e
+4qlt
+3db8
+2bub
+3s8o
+3eg6
+1jaq
+3ua8
+2kfg
+3d3x
+5a5v
+3nuu
+1jh1
+1iy7
+5zo7
+4xnw
+5dlz
+4wpf
+4pvy
+1sve
+4qmy
+5drq
+4leq
+1azg
+3wjw
+2qiq
+5yjp
+2qfu
+1thz
+1oi9
+3w1f
+2v12
+3cd5
+1fpy
+5f37
+1e03
+4q8x
+5uk8
+4v25
+3u8k
+5hlb
+4qfn
+4li7
+4gkm
+6f3e
+4rn4
+3vtb
+5l6i
+4lrh
+4jvq
+5est
+3gtc
+2jbu
+4yx9
+5bs0
+5ea3
+1vyf
+3cyw
+3kku
+3tvx
+6b4d
+4bny
+5j8x
+5tza
+5yg2
+1d6v
+5t4e
+2j4g
+5tci
+1z9y
+2ca8
+4hyf
+2r1y
+4bcq
+1lqf
+6b3v
+5htc
+2qh6
+4pul
+1gj7
+4mmf
+3sfg
+5ap2
+2oi9
+4h81
+3s77
+3s74
+4u5u
+6euz
+6eq3
+4obq
+4u4x
+2r23
+4tjw
+2a4z
+2mwy
+4pzh
+5m7m
+4mzj
+1o3l
+3d62
+2xow
+3rwq
+4fpf
+1f5k
+5c7c
+3q77
+4pnr
+5hz8
+5ho7
+5xmx
+2xpk
+6mdq
+3tge
+5fls
+3oku
+5jr2
+3e0q
+2l98
+5csz
+5yr6
+6m8w
+1ex8
+6ft7
+2bdj
+5l7g
+1cnx
+1mmp
+2ay2
+6fnq
+5eng
+4a6v
+2zq2
+4wag
+3s7a
+4is6
+5tq8
+4w9x
+5lto
+1o86
+5a69
+4zg7
+4unq
+2q88
+2jds
+5c1m
+6bgy
+4fil
+2qi1
+2x7o
+5icx
+6exj
+3nkk
+1q65
+2xxw
+1om9
+4jq7
+1lf2
+4xg4
+3sgx
+1sdt
+4kp8
+1hwr
+2cem
+5nzo
+3oaw
+2wwj
+4g11
+1lf3
+6hm4
+3jq9
+1qx1
+4old
+1g5s
+3tic
+3cs8
+4er4
+5kr0
+2pe0
+5abf
+3v04
+4e6q
+2yc3
+3bys
+5jeo
+4fci
+5eh5
+4r02
+5ef7
+3dt1
+5v5n
+5ehp
+5yr4
+6gl8
+3uvl
+3v0l
+5ne5
+4nvp
+4qok
+4ipj
+4zyi
+1o3j
+1lrt
+5zwe
+4hbn
+2gz2
+6bj2
+5tco
+3gc5
+4b4m
+4l6t
+1zsb
+5mnx
+5m23
+4do3
+2etr
+5gwy
+3b5j
+1oai
+2ath
+2v11
+2ym6
+4mwu
+6g86
+4f7l
+4nan
+4f63
+3m3x
+2bpm
+2wb5
+6fel
+3tdc
+4fgy
+4z1s
+6bh1
+1f8a
+3cyz
+3m8p
+2df6
+3jrs
+5oah
+2wmv
+3d50
+3aza
+1jqe
+4nb3
+1okw
+4n98
+6hzp
+6aoy
+4o3u
+5nev
+5byy
+4bo7
+3su2
+4hlf
+3sww
+2os9
+5eei
+4men
+4qq4
+2wxd
+3oqf
+3eht
+3dd0
+2ke1
+4v1f
+4e6d
+1jyi
+4ob1
+5x4n
+5alc
+2pbw
+5eym
+4e28
+4qtl
+5jz9
+3chr
+2p2a
+1v1j
+4o3b
+5v83
+5v5e
+3byu
+7abp
+5jga
+3sw2
+5jgb
+4dtk
+1nje
+4yrt
+5ih5
+6afe
+4res
+1sqn
+4oas
+5u5l
+1v79
+3hp5
+5ivc
+3avg
+3tws
+1rmz
+4rse
+5zae
+5w2q
+5glu
+5b4w
+5f62
+4y6r
+4mha
+5etk
+5nzm
+4o2b
+3p78
+1tyn
+2pj8
+3ejq
+3lvw
+2fw3
+2f6y
+6bic
+4p0x
+5tkt
+4acd
+5aki
+3zy2
+4tw7
+3b3w
+1nkm
+5uoo
+4l7u
+4iut
+1pbq
+4dow
+3hab
+1owe
+4rvm
+6ft3
+4y2q
+2hs1
+6gu6
+4j2c
+1s50
+5fox
+3jvs
+1zub
+5wxp
+5oh7
+4ydg
+3ovn
+1h08
+5wzv
+2fxs
+3f37
+4xtz
+4mww
+6gg4
+4zz3
+5cf4
+4twc
+3zsz
+4er2
+4uuh
+1i8j
+5opv
+3voz
+3d1g
+3kfc
+3qqs
+1oay
+5os4
+4abe
+4jwr
+1l6m
+3nf6
+3qip
+4udb
+1nlt
+3zdg
+3o84
+3ehn
+3k16
+5szb
+2j2u
+2weg
+1ttm
+3dz4
+4jdf
+3wyy
+3ifo
+5j41
+3fl5
+1q1m
+2y80
+3fr4
+3o56
+1yrs
+2gvv
+3uxk
+2zq0
+5uac
+2wk6
+184l
+6gvz
+6dik
+3u8w
+3rxb
+3nwe
+13gs
+4gpl
+4rxz
+4qbm
+5y9l
+1okz
+1mpl
+4rra
+5ey8
+4j03
+5npc
+5tt3
+1uwf
+4dgr
+5xzr
+4mw4
+3n5k
+4umq
+2l6e
+6drg
+2ksp
+1sps
+5hna
+6gnp
+3dxk
+5eom
+1e34
+5ff6
+2itp
+2zlf
+4iva
+2y4m
+4o1b
+2o9v
+4i7f
+4ezw
+1k4h
+2xgm
+4nud
+3m55
+4x34
+5fqr
+2h6k
+3fmr
+4kzb
+3tpx
+4hpy
+4mvh
+2nq7
+3n5u
+3rjw
+3emg
+2xm9
+1kzn
+5faq
+5f1u
+1c6y
+4j8g
+5lvr
+1xuo
+2vgo
+1grp
+2rol
+5cbm
+6hke
+5tr6
+3d6o
+5awu
+4wz8
+5egm
+1duv
+6b4n
+1t7j
+4jh0
+4q7s
+5cpr
+1bqm
+4fem
+4wnk
+4uv8
+5hgq
+6ck3
+3uzj
+3u2q
+1nl9
+5yzd
+2i0j
+4hvh
+4ool
+3s0n
+3b4p
+2ea4
+5k76
+1nvq
+2xzq
+1pq6
+2y81
+4bhf
+3f8s
+2hwh
+4y4g
+1q4w
+4h39
+3zmh
+5mkz
+1ftl
+4ok5
+2qcn
+1g52
+3i4a
+5x79
+2am2
+2ym7
+3adu
+3t6y
+4pgc
+1k1j
+3d14
+3el4
+2y0j
+2w1c
+5l7k
+4n6g
+5cp5
+2isc
+5cbs
+5hvu
+5mpn
+2o0u
+5zoo
+1t69
+1oj5
+5lle
+4ezk
+2c6o
+5vrl
+5za8
+1i80
+6ce2
+4cfx
+3m5e
+2xyn
+6eea
+3s3m
+5t4f
+6br3
+3krl
+3upy
+2rm0
+4app
+7gch
+5hx8
+4ok6
+5g3w
+1h27
+1wvc
+1idg
+5c8n
+3w33
+3rzb
+4xg6
+2rib
+3oz1
+2uuo
+1r1h
+5agu
+1r58
+1nlo
+3g70
+2ofu
+4k6z
+4x13
+5ihc
+2yiw
+6bgw
+6gji
+1tve
+5tq5
+4ujb
+4l33
+6cqz
+4avh
+5uga
+5tzy
+5op6
+1m7d
+4aia
+4qgh
+3uuo
+1me8
+4jr3
+1wdy
+4o4r
+2c3j
+2r9m
+5ual
+3vfq
+4c16
+6h7l
+3tv6
+2pyn
+2bj4
+4qvy
+2puy
+4abk
+3m53
+3cwk
+3d52
+1a4q
+4rvl
+4odp
+1ogz
+3luo
+4ran
+3uph
+1hpx
+3c8b
+2vtl
+1fj4
+2zm3
+3rxl
+3uo5
+1q1y
+2ql9
+1bhf
+2jg8
+2q2n
+4aof
+1heg
+3ff3
+4cae
+6fkq
+4i9i
+4msg
+3ask
+1dbj
+4zbf
+2io6
+3d1y
+3kwf
+1juj
+3i0r
+4gui
+2hy0
+6g9m
+3nnx
+5u48
+2v2v
+6f5h
+5mwh
+5m0d
+5fue
+3k5k
+5edi
+4d2p
+2cm7
+8cpa
+3doy
+1vyg
+6bmv
+5m4q
+5j4n
+4tpt
+2jbv
+5ue4
+5enj
+3m35
+4a9t
+5khx
+5f0h
+4wq3
+4ktu
+2qbr
+1sbr
+2f6z
+1z2b
+6cgt
+5nra
+3fed
+5l2o
+3uik
+4bzn
+1efi
+3nrm
+5kjm
+2cle
+3h9k
+5n4s
+3mfv
+5yie
+5yz7
+5cr7
+4e35
+6di0
+4w9n
+3vqh
+4z1j
+6b98
+4x6m
+2pu1
+4q1s
+3n7a
+4qbb
+6fng
+5ya5
+3qiz
+5awt
+3sv8
+3doz
+6dlx
+4rkx
+3h91
+4uma
+1lvc
+5gso
+4loo
+5ap0
+5drc
+4j5e
+2o22
+3rz0
+5unj
+5qcl
+3cii
+4nw6
+4qqi
+3r0i
+4w9g
+5uff
+4lbp
+5akh
+2yjb
+3dx0
+4dfg
+3g42
+5xpp
+2c4g
+2bz6
+3x00
+4nat
+4ppc
+3lpb
+3tlh
+3nok
+3lfs
+3o9h
+3we4
+4xek
+2kgi
+4jok
+5llc
+2wap
+5ogb
+5w8i
+1a42
+2llq
+5j7b
+2c6l
+1lt5
+5ai5
+3khj
+6hh3
+4uac
+5nob
+1ynd
+2on6
+5ut4
+2wkz
+5jvi
+3gww
+4uja
+1pq3
+4u5v
+4z83
+6dh8
+1h36
+3vjk
+1unh
+3hv7
+2vxj
+5lgo
+1a08
+1fgi
+5fqs
+4o0z
+1gvx
+5vqe
+2j7w
+3b1m
+5zah
+1iwq
+4zx8
+3wkd
+5mtv
+5myd
+3t6r
+2c6n
+2c6e
+3opm
+5n9r
+6gue
+3gnv
+5nyz
+1fh7
+5wae
+1tow
+1toj
+5een
+5fog
+6e9a
+5jek
+3m94
+1jet
+5qck
+6coj
+1if8
+5t6g
+5eje
+1ezf
+3twd
+3mo8
+4rvt
+6bbu
+4ejl
+1waw
+4heu
+6b67
+2cmc
+3arv
+4r4t
+1j80
+5ads
+6abp
+5a82
+3el7
+6fex
+4i9h
+4m5o
+3qgw
+1k1i
+5t8o
+3pcn
+3nw3
+5w84
+3bqn
+4pin
+2w3o
+5yic
+3vo3
+4unr
+4cp5
+4b73
+6c6o
+1xz8
+5zo9
+2g1r
+4xc2
+1oe8
+2z94
+5aic
+4m12
+1sld
+2h96
+6cn5
+4uro
+3bvb
+5x27
+3usx
+2f7i
+2iit
+3fzt
+5vgi
+5jv1
+1py1
+5ktx
+4b35
+1m0q
+5kjk
+2vey
+6dkg
+6gbx
+3e01
+1p03
+4zuq
+4wbo
+4rfd
+5alb
+3liw
+2mwo
+4yjl
+4ab8
+4at4
+1ke0
+5fpk
+1zz2
+5hz6
+2cll
+4m2v
+3ozt
+4ge7
+3pkd
+5t70
+3ts4
+3ogm
+5t18
+5c7d
+1ikv
+4obp
+4k6y
+2fb8
+3vbd
+5ung
+4b32
+2qlq
+3jzs
+3tiz
+1v2k
+3zzf
+1hpv
+5xo2
+5e2l
+1jn4
+5aly
+3rwp
+3r7r
+4url
+2wm0
+2brg
+2lgf
+5dlx
+4g2y
+5jzs
+5fd2
+5nqr
+3tkm
+5ti0
+5lxp
+4l7f
+3avi
+5zuj
+3p3h
+1g3d
+3d9v
+4gs8
+4dbn
+1gjc
+1udu
+4ir5
+5yp5
+5ukj
+6fgq
+4iuo
+4ibk
+5ali
+1b5h
+2y36
+3f81
+4e3f
+3t84
+4na7
+2ow7
+4ob0
+1qb1
+2iku
+3npc
+1k2v
+2w68
+1b2h
+4dfl
+3dri
+4qzs
+3sqq
+1d4l
+4dn0
+9hvp
+2lko
+1lev
+3aau
+4mib
+1lee
+1o5e
+4os4
+4b34
+3m56
+4qvw
+5wf6
+3u7k
+4j5d
+1r4w
+3buw
+1eou
+3vbq
+6g5j
+5t4u
+3fuh
+2pj4
+2zn7
+4n4v
+2obo
+1tjp
+6b1w
+1ru2
+1fh9
+4wcf
+6hh5
+5orz
+4xmb
+5f94
+4jfv
+6ekq
+4nrt
+4ura
+4prn
+6ev0
+1v3x
+2pqz
+3k5i
+4pn1
+5bue
+3ik1
+2h5d
+4yax
+5nhv
+2x97
+2q72
+2qpj
+4k6t
+6b1e
+3f3e
+2yog
+4kio
+3qem
+3ued
+2xtk
+5mge
+2bfq
+3mxs
+4k1b
+4p6g
+3td4
+5mnh
+5ien
+3lk8
+2zx6
+1rql
+3rm4
+5u4c
+4kb7
+5ap1
+4rj8
+5tkk
+4j04
+6i8b
+2nxl
+3zm4
+4dy6
+3h0z
+4zyf
+3e7o
+5li3
+4qjw
+4aq4
+3kpu
+5oq7
+3h2c
+5jn9
+2qnq
+2l8r
+3rxk
+1upf
+4qh7
+4w9k
+1vja
+4zw7
+5ov8
+5wag
+1x8j
+5a6b
+6br2
+1tok
+4b6p
+3drs
+3tvl
+5mlo
+2xaf
+3h0j
+4yas
+1o35
+5dex
+2x52
+3lgs
+3dcr
+4y5d
+4umb
+3l4y
+6fkp
+1ony
+6b95
+5ueu
+5ahj
+2xel
+2g1y
+6iiv
+3b1t
+5dht
+4zup
+4rlk
+1axs
+5fnj
+1izi
+4gvm
+4xmr
+5yhg
+3rg2
+3tao
+2q7o
+1pme
+6gl3
+4pct
+2tsr
+3qtw
+4uua
+5abe
+3ozp
+3q8d
+2bu5
+5kya
+2q6h
+1n95
+3k84
+3bl1
+3ui2
+2cgv
+4ez5
+3t3c
+3puk
+6css
+3ezr
+2gss
+1n1m
+3obu
+4awj
+5vt4
+4y62
+1bcd
+3w9k
+3qu0
+1zxc
+2vtj
+2pu2
+4hej
+5ive
+2wo8
+5i2f
+6dj7
+4a6w
+4q1x
+2g63
+1jak
+5knr
+5y7z
+5npb
+2izx
+2x38
+4knr
+3rwe
+3daj
+4mbi
+5a2k
+4cr9
+6ht1
+1uj5
+3ljt
+1kyn
+5osd
+5whc
+2r2l
+4qws
+3uwo
+5n8v
+2y54
+4m5n
+1yy6
+2j50
+3lvp
+2gdo
+3hyf
+3zmu
+2pt9
+5nxg
+4qsk
+5eif
+5l2z
+4djr
+2ceo
+4apo
+5gj9
+1q4x
+4keq
+2b17
+4kzu
+5bml
+1bdr
+4zjr
+3ftz
+2c2l
+4yo8
+1vj5
+1w4p
+1aaq
+2q9n
+2yay
+1szd
+5acb
+5ne1
+1vj6
+3n5h
+3arr
+3v0p
+2fqw
+5jf7
+2n14
+5mk3
+2pj6
+4c68
+4erw
+2bba
+5iz8
+6iiu
+3txo
+4nah
+4ir6
+4ufy
+6fer
+4zba
+1jij
+2piy
+5td2
+4yzc
+5qap
+5yhl
+1h1p
+5ni7
+4pf3
+4a6b
+4uy1
+2xwy
+2w71
+4d7b
+2jld
+4yoj
+2ms4
+4iwz
+5ctb
+3t85
+4lpg
+3uri
+3hfb
+4mr3
+3lq8
+3mlb
+4qwf
+4ixv
+5n34
+2xvn
+4njd
+5tzo
+5qa9
+5ai8
+3o23
+5i22
+4o72
+4ej8
+1dpu
+1rv1
+4ixh
+1w82
+3arx
+3k02
+5fnt
+3uf9
+5wij
+4oq5
+1z4o
+3lq5
+3u4h
+4f20
+4mg5
+5ufi
+4n8d
+6mu1
+5zag
+4emv
+4bqt
+3t2q
+1jyc
+4q81
+2fqx
+4kza
+5k51
+3u4i
+5ho8
+4ciz
+1yy4
+2w6p
+4flh
+4w4s
+3i28
+3oyl
+2nn1
+5lrk
+4e3i
+4xg9
+4d8n
+3lik
+4aj2
+5j7w
+3h2a
+6bjo
+3nik
+5lxc
+3qce
+1vrt
+4qxo
+5lne
+5am6
+5er1
+3ob1
+6e2m
+4lnp
+3el5
+1w84
+4zz1
+4gm8
+6hm7
+3o6t
+2ycm
+1g53
+5ot3
+5dp8
+5va9
+4wx7
+5kww
+6bu1
+1q6t
+1uto
+2bks
+4fmq
+5opr
+3ies
+6hti
+5u66
+4qz6
+6b1o
+4gy5
+5mrb
+4rrv
+3skk
+4mss
+4kju
+1hti
+5l6o
+2am1
+3t5i
+1dkd
+2onc
+6cvf
+6bkw
+3fdt
+4wh7
+5i3m
+1azx
+3fck
+5u6c
+4ded
+4k0u
+5xmu
+3wk9
+4kz0
+5a7c
+6g9j
+3iw6
+4ddk
+4z2o
+4e3h
+4c70
+2y57
+3dzt
+5e0g
+4nrb
+4qr3
+5ltn
+3omg
+6bod
+3fzs
+5edd
+4rww
+2oyl
+2bmc
+2xqq
+3kqy
+1oiy
+5y13
+4d1s
+3ked
+5djp
+4bo0
+4o2a
+5em6
+5tfx
+4d9p
+3tku
+4p1r
+5nwz
+4bs4
+3oys
+5lgs
+2vxn
+1y98
+3ck7
+1nh0
+4an0
+1mcz
+2h9n
+3h0s
+2ycq
+2x4s
+4acc
+5ows
+3rxa
+5lhi
+5l8c
+3rxi
+3r00
+5oq5
+1jev
+4ztn
+4a7j
+4os7
+3e3c
+5hvt
+4jfj
+5dxh
+1d4k
+5ewk
+1x6u
+3g2z
+1i7c
+5opb
+4y85
+6fii
+6c7q
+4jkt
+5dgz
+3run
+4qoc
+5twz
+4a4h
+6gl9
+4fxz
+2hu6
+4ayt
+2y7x
+1x8b
+5i8c
+2aoi
+3kgt
+3gwx
+5lyr
+3nk8
+5orv
+1mrx
+1pf8
+6dj1
+4jss
+3uii
+5cqt
+1yds
+3hy9
+5y5u
+6dko
+5hm0
+3s3o
+5om7
+2j9n
+5wzw
+1d3v
+4pvv
+4i0s
+4pmm
+6ftp
+4hct
+1c5t
+5urk
+5q0f
+5xv7
+4bj9
+1css
+1hqf
+5tg1
+3cvk
+6awp
+1t4e
+2nns
+5al5
+3cr5
+6equ
+5fl5
+2yex
+5lsh
+4fgz
+3mv0
+3juq
+1q6m
+5khh
+5c85
+1npw
+5w1e
+4j0a
+4mvn
+5ioz
+4yve
+5tbm
+2fx7
+4oex
+1nnu
+3c4h
+3vp1
+1bky
+5ajc
+1jcx
+8hvp
+4wvs
+5hkh
+2llo
+2jkm
+1q6p
+5mf6
+5afj
+4l50
+1o3e
+6evm
+1pyw
+4mnx
+4fll
+6hx5
+3ivc
+5wf5
+4c4g
+1w5w
+2w26
+4qk4
+4an9
+5n8j
+6mr5
+4l7r
+4aro
+6g07
+4hze
+2cbj
+5wbr
+5afx
+3bh3
+4ca8
+6aam
+1r78
+1gcz
+3bjc
+1o2x
+1b40
+4u45
+4qiy
+3v30
+3kyq
+3unn
+5elf
+5hjc
+2p4s
+1xoe
+2oqi
+5mpz
+4hxz
+4rfr
+3vp3
+6upj
+5xyy
+4wci
+2hnc
+3ocz
+1k4g
+3v3v
+5ihh
+4g0c
+5ngs
+2v77
+3nzs
+5tyk
+3dne
+1m5f
+2xk8
+4br3
+1bgq
+3fa3
+2y07
+4lpb
+4tlr
+1ocq
+4j5c
+2n3k
+2y5g
+4mf1
+4oho
+4u3f
+3tv5
+2xv1
+5kmh
+3n2v
+3o7u
+2ieo
+1wbo
+5i25
+4mhz
+5mmp
+3qs8
+5igm
+3zxz
+4zji
+4b71
+1fpp
+2y76
+1i3z
+5lch
+5gp7
+3mmr
+4qc1
+3sbi
+4bsq
+5yhe
+5hj9
+4qw1
+1q5l
+4i9z
+1o5b
+1ryf
+3oeu
+4mw7
+3nx7
+4izy
+5lvf
+3hll
+4jbp
+5icv
+2yln
+3n2c
+5om3
+1e2l
+2oyk
+2c0o
+5w5v
+3w8o
+6cvw
+6h2z
+2a3i
+5jnl
+6m9d
+4twp
+5gmu
+5wg4
+2mkr
+3elc
+3eb1
+5wlv
+4p0v
+5ahu
+5two
+2jf4
+1mm6
+3c4c
+5a2j
+3ti4
+3pd9
+4rx8
+2vr0
+6mim
+2k00
+3fr2
+5dgw
+3tiy
+4jxs
+5tpx
+5xva
+1o49
+3v66
+2mlm
+4alu
+1tv6
+4g2f
+2xp4
+2bz8
+4kbc
+5tho
+1wun
+3m17
+1slg
+3pcc
+1oh4
+2vio
+3v6r
+4n7h
+3fv8
+4f08
+2p33
+5a5d
+3n1v
+3wzp
+4j4o
+5ewm
+3ds4
+4b3b
+1sqi
+2nmx
+1gai
+1fax
+4deg
+6f6s
+5ujv
+1juf
+4zx3
+1m48
+5ttf
+4man
+5ljt
+1y0l
+6hsk
+3bi6
+3fue
+1c87
+4byj
+4r18
+6bnh
+3qpn
+4r4i
+4e5h
+4ojq
+3fu3
+3d1x
+4j48
+5uig
+5vcz
+5tzd
+4hva
+3mvl
+6b1c
+4e96
+5aeh
+4uvu
+3met
+6dh5
+4mrh
+5fqv
+5t8q
+6f7c
+5l17
+3zim
+3k83
+2p3a
+4wsj
+4cd1
+2xk7
+5w6u
+4u58
+6f5m
+3vw6
+1o42
+5uor
+2ycs
+1p06
+2i4z
+4q1d
+3ipy
+5m0s
+3qup
+1tr7
+5xpn
+2aa6
+4mk7
+5uv2
+3pgl
+5uir
+3shj
+1p57
+4ezx
+5csw
+4ag8
+3ibn
+4yht
+4wkt
+6ceh
+3k0k
+5neb
+4ysi
+1bo5
+1a28
+1ckb
+5j6d
+3hr1
+6hrq
+1py5
+3km4
+4c66
+1sr7
+1rnm
+3krx
+3d25
+5d6e
+5w4v
+2x8e
+4f09
+5afv
+6bkx
+2hug
+5dnu
+2woa
+5xvw
+3fi3
+4yho
+1h1s
+1sdv
+5fot
+5tmn
+5myk
+5f29
+1utl
+3zls
+4ff8
+5f6d
+2gfs
+1c86
+5e5g
+3zvy
+5i59
+2f3r
+4e5j
+3l5r
+5l01
+2vj8
+4b9w
+4i7m
+4qwu
+3rpr
+4i7k
+2c1n
+4ret
+1owk
+4mxc
+5huw
+5w14
+1f8e
+4ciy
+5etm
+2pwr
+4r1e
+4ncg
+2jbo
+4abf
+1my4
+4jib
+4nxr
+3zev
+1njd
+1pdq
+5fi6
+2vtp
+5dro
+1o3b
+4jln
+2yis
+1rt2
+4feq
+5za9
+4gii
+3gjs
+5eef
+2zx8
+3ujd
+5eto
+1c5p
+5tys
+6ayo
+4eh4
+3mhm
+2pow
+1w0y
+4dbm
+2ywp
+5uhi
+5am3
+1pxp
+2bq6
+1n1g
+966c
+3vws
+2of2
+2ydf
+4nbk
+1l0a
+4u43
+5trh
+5etv
+1h61
+2vcb
+3d1v
+1xq0
+1b3h
+3svj
+5fun
+4bw1
+4jof
+4izm
+4phu
+3jy9
+5ael
+4irx
+3avn
+5mm9
+5twl
+4w9l
+2ad5
+4h2o
+4b4g
+4yrs
+4a22
+5vfc
+3l3q
+6fn9
+4m14
+5a6h
+4c35
+3iob
+6apr
+6g3v
+2xpb
+3loo
+3drr
+3e4a
+5thi
+5mgm
+4i8n
+5obr
+6ee4
+2wzx
+5j8z
+2itz
+4mdn
+5nw0
+5l9o
+3bel
+4g69
+5ovv
+1i9n
+1hlk
+2hhn
+5v13
+2rcx
+5zms
+2ncz
+1a86
+5g2n
+3dpe
+5d3j
+2vaq
+4ui5
+5g1a
+3f39
+4owm
+1dl7
+3ce3
+5azg
+5l7f
+6fh7
+4ifi
+2xo8
+5lws
+5sve
+3q2h
+4e3n
+5eoc
+6b7h
+5ekn
+4erk
+5fso
+5e80
+2bpx
+1yw8
+3sc1
+5o4t
+5c2o
+2w17
+5nxy
+1oy7
+6dvm
+1py2
+4zx0
+4m5k
+4nkt
+3s1h
+2ym5
+6cis
+3hdm
+2yj2
+4ef4
+3kvw
+6c1s
+4j6i
+6bij
+5xgh
+5u2c
+3m3e
+3dga
+1b6k
+4gd6
+4ww6
+1zhy
+3eky
+2q38
+2ymt
+3gur
+1njs
+4na8
+4msa
+5nk8
+1o4k
+3l6h
+1i5h
+3t6b
+6ck6
+6gzd
+2yc5
+4aa4
+4ask
+4ea1
+3pxz
+4n4s
+5wkm
+4jg0
+3sie
+3pkc
+1w1g
+5y8c
+2c6m
+5ou3
+6d50
+5v3y
+5lzj
+5tya
+1sqc
+3eyu
+4xtm
+3agl
+2brh
+4mbf
+5d4a
+2zz6
+2gbi
+1t5f
+5jiy
+4x1r
+3hl7
+1zd4
+5fdc
+3dnj
+3cct
+4pm0
+4gj2
+5d6f
+4joj
+4jju
+5hn9
+4tjy
+6ffn
+5usf
+2clk
+5n70
+3eka
+5eq1
+5t35
+4qlq
+4acf
+4orx
+3fz1
+4zhm
+3rxo
+1atl
+5t1k
+3zt4
+1bdl
+4u6y
+5mob
+2igy
+5jlz
+4flj
+2zu4
+2w70
+5d6y
+4kip
+2uw0
+1r2b
+4qvm
+1w4q
+5okt
+5op4
+3al3
+2rvn
+3dp1
+4luz
+3o87
+4bf6
+1w2h
+1fiv
+1uh1
+6c8p
+4g8m
+4hai
+2q2z
+4yyt
+4od0
+5k9w
+3fyj
+3zlk
+5vh0
+5ale
+3th8
+4pvo
+4whs
+5hed
+5qbv
+2oei
+4y2s
+4px6
+2knh
+5kns
+2g96
+3cm7
+4gcj
+1qft
+3ztd
+4yzu
+4kiq
+1vwl
+3zyh
+6mx3
+1q8t
+4ue1
+2y7z
+3mdz
+4gtr
+6fh6
+4qvq
+3tti
+4mbj
+5ap6
+3tdj
+4lvt
+1xo2
+1pcg
+5fiv
+1g3e
+6gx3
+5dhj
+5ixt
+1xhm
+4po7
+6egs
+3iw8
+5qag
+5brz
+3mpt
+3ral
+1j14
+5wdj
+4io3
+4tpm
+3f35
+6mrg
+2oi3
+1onp
+4bjx
+2i0v
+4hmk
+5mat
+4h2m
+4ayx
+5iwg
+2xez
+5em7
+5kdf
+4y59
+3ti6
+5gn6
+4u7v
+3rz7
+1ejn
+5wxo
+1o2w
+4r0i
+1a30
+5nz2
+3rf4
+6ee6
+1a9u
+3iop
+5x4p
+3gl6
+1hqg
+2oji
+4ps3
+2w05
+1tnh
+2c9b
+2flb
+5itd
+5k00
+1t37
+3g0b
+2rfh
+4bdi
+4ikn
+1rww
+4g68
+5yum
+4hxl
+3dbd
+4hw7
+5mys
+4yt6
+2vvt
+3r2y
+5ng9
+1y2g
+2vwm
+3if7
+2hl4
+3ffp
+4qwg
+3g6z
+5dhf
+4y79
+3m57
+4oyi
+3s0b
+1yvx
+4md6
+4g9c
+3upi
+2w6m
+5tt7
+3pkb
+2weh
+5gid
+2w1g
+3mxc
+1ind
+5k0i
+4npv
+2q7q
+5xaf
+5hf1
+2aw1
+3o9i
+3dbu
+4l34
+5j0d
+5afl
+2x7x
+4qp1
+2w3i
+5ew3
+5e0m
+5jfu
+1o4h
+4w9p
+4onf
+4zhl
+3mj2
+3k22
+2xxy
+5m5q
+5kab
+1rsi
+5c42
+3tb6
+4myd
+2i40
+5nhj
+3ds6
+1lt6
+3eft
+2w8g
+4de3
+4yrc
+5yg4
+5hmh
+5nw2
+1k9r
+3mxf
+2q1j
+1u0h
+4ye3
+4k60
+5zop
+6htg
+2fx9
+4q83
+4y8y
+4gr0
+2yaz
+1k1m
+4i2w
+5ovx
+3db6
+1v2p
+5njx
+1wtg
+3uvn
+3h89
+2q7y
+4o2f
+3fv1
+3pwm
+1x7b
+4tmp
+5ulp
+6di1
+4iks
+5hg8
+5n9s
+3tjd
+6b1x
+5nw8
+5yve
+4uwg
+1jd5
+5km5
+2w4x
+3umx
+2ony
+1bm2
+2pj9
+2m41
+4z8a
+2yjq
+6mwe
+1prl
+5y1y
+1c5y
+5ak6
+2pv2
+1w25
+2fme
+4ba3
+1ydt
+6c2x
+4ijl
+3gxy
+3f3u
+4io2
+4drm
+3cjo
+5c87
+5ni8
+2ll7
+2bdf
+2pem
+2x7d
+3zc6
+1m2q
+4gk2
+3lqi
+3c1x
+2az9
+1fv0
+1gfy
+2nxm
+4yml
+4yog
+2g6q
+1t79
+3hdk
+3uij
+5vl2
+4aph
+6d1u
+4rn2
+2p4i
+1w80
+2vh0
+3kqa
+5jgi
+3g9n
+5var
+4lnf
+3e9h
+2xn3
+2fzz
+3cfv
+5h21
+5fdr
+5z7b
+6cj1
+5tts
+6bmx
+1mqd
+2qhd
+6e4a
+4tk0
+3fur
+3v1r
+3q4j
+4wwn
+1u9l
+1oqp
+1dmp
+2wnj
+4i6q
+4d8s
+2jb5
+4p58
+4usj
+6eq6
+3o0j
+5apj
+4ty1
+5avf
+5k1f
+1a7c
+5f2r
+2c9d
+3a9i
+3deh
+3q3k
+4xtw
+2r3l
+5qa4
+3wyx
+4ijp
+1s5z
+1y2h
+1c83
+5dts
+5e1d
+5j9k
+5o4f
+2wxi
+5f04
+2qmj
+3kvx
+5d48
+2vyt
+4cfv
+1qcp
+4hlm
+3snl
+4dzw
+2brm
+4q7v
+5teh
+5mro
+3b1u
+2z9g
+2rt5
+3gxz
+6f7b
+4qz5
+5dh5
+3k0h
+3l54
+2hd6
+5hbe
+2qi7
+1jao
+5ajp
+3gjq
+5y20
+1rwx
+4ibj
+5op2
+3c6u
+2w0s
+5yyb
+3ni5
+3t8w
+5ntp
+1o4e
+5tqu
+2xyd
+5tl9
+2vpo
+4ov5
+4qps
+4a9s
+3atk
+4ms0
+3fzr
+1i9m
+2y71
+3f33
+5q0h
+5x9p
+5ajo
+3c56
+4pnl
+4fmu
+3uli
+5nlk
+2vo5
+2fts
+3sfc
+3pke
+4dk5
+1lor
+3jya
+6bqg
+3p9t
+6fnj
+6fmc
+5c0k
+1mmq
+4fck
+5npe
+4j59
+4eol
+5m57
+4efk
+1oiq
+5dwr
+3wyk
+4qf9
+4c5w
+5tuq
+3oqk
+4xj0
+5mwg
+2vwu
+6dpy
+3wi6
+5owf
+3nw5
+4fhh
+3sna
+2vcg
+5j7j
+4gtt
+5jc1
+2hz0
+5l4i
+1y1m
+5kj0
+5vo1
+4y2v
+1ecq
+6eeo
+5jrs
+4l23
+6f34
+4r4q
+4quo
+6dq6
+4e3k
+1cet
+5e2k
+5jyy
+5jna
+4qls
+4ksq
+4py4
+6biy
+2hqu
+4yk5
+4km0
+5ttu
+2za3
+4o5g
+2y1g
+4ztr
+4jps
+4uin
+2x7t
+2q6c
+6ayr
+1pwy
+5lwe
+5cxi
+4n9b
+1fzo
+5ukm
+1ork
+4mk0
+1jbd
+1k2i
+4ifh
+4yh4
+3fee
+5tqe
+1jj9
+4li5
+1lah
+3ppm
+4kn7
+1nz7
+1m5w
+3vbx
+4ie2
+4r3s
+4qnu
+4qmu
+4os6
+4o6w
+2bge
+5xvg
+1nfu
+2zjf
+5id1
+5ukl
+3ccz
+2d3u
+5tyj
+1ggd
+5ofx
+4o12
+4wf4
+3pck
+5jt9
+5ggk
+6h5x
+1r5w
+4zw6
+5ep7
+4ps0
+4drk
+1los
+3s6t
+3be9
+4ipi
+3wf7
+4pow
+3fun
+4wk2
+4y46
+5izj
+1d4j
+4qg7
+2avm
+1g85
+1r1i
+3g1v
+4oti
+4a4o
+1fvv
+3uok
+5n3v
+4tim
+4a4g
+6c0s
+1w12
+4jn2
+4oyp
+4zt7
+2ypo
+3kmc
+4hwp
+3q2j
+4k5l
+3hwn
+5i83
+4ht6
+4fyh
+1kfy
+5g43
+4bnv
+5fpu
+1o48
+5hv1
+6ekd
+2k3w
+1uze
+3ksq
+5wkl
+4hzz
+2f8g
+2uw3
+6mi6
+4u91
+3f7u
+2qx0
+2f0z
+4bcc
+3qvv
+2oc1
+5he3
+1pun
+3pp7
+5o91
+4mjo
+3ff6
+4xnv
+3tay
+3ejs
+4c1w
+3njq
+6guc
+4el9
+3h0e
+4pri
+3pcb
+4jg8
+3lbj
+4a4x
+2wa3
+5tcy
+3wth
+1ylv
+5bve
+4g34
+5u28
+5if6
+5z5f
+4ot6
+2g97
+5n16
+1m5e
+3efk
+4h7q
+2v5a
+5vs6
+2cne
+1pxn
+1jqy
+5j6s
+4abv
+6d6t
+1t4s
+3zsx
+1p01
+2f4j
+3f78
+3h0w
+5d3x
+2vk2
+3zst
+2lbm
+6fil
+6ew7
+2iu0
+5ai9
+1tsm
+5wbm
+4ark
+3hlo
+6dk1
+5hk2
+1qhc
+3v5l
+2r59
+4no8
+5hmy
+2jql
+4lv4
+3kf7
+5hbh
+2vr3
+3wf9
+4ieh
+5ar0
+5dyw
+4xuz
+1mmr
+4h4b
+5elv
+2g79
+4w52
+3iqh
+2rnx
+2az8
+4lv3
+4mwb
+5a83
+1prm
+4gg5
+1rlq
+5fbn
+1f47
+4yfi
+2v10
+3pa3
+4jvi
+4gmy
+4cft
+2v7a
+1epp
+2hoc
+4r5g
+4k0y
+5zz2
+4ng9
+5hor
+3qci
+4msu
+5hg1
+1pyn
+1hmt
+2lpr
+4yha
+5hoa
+4h3c
+4lmu
+3tf6
+4z2p
+5ctc
+2hny
+5vd1
+3qcf
+5ia0
+3l7g
+1eld
+1xh9
+1h3c
+4urm
+4j7i
+4ly9
+1nu1
+5sz5
+6cdl
+1uvu
+2wl4
+4eo4
+5lj2
+3kc1
+5nqe
+6gon
+2xs8
+5gmj
+5eyd
+6c42
+4wks
+5d10
+3ka2
+4p6e
+4nnn
+3zvw
+4q6r
+5v8v
+2jdv
+5e8f
+5qcm
+5y80
+3ud5
+4n70
+4cgi
+2uw8
+4ivb
+4m6u
+2xu1
+4ud7
+5nvh
+2arm
+3fmq
+5jin
+2nt7
+1p4r
+3eqr
+3hxf
+4zwx
+4xx3
+4yee
+6aak
+2xae
+5t31
+3bhb
+5llh
+5nge
+4b9h
+5oxl
+5ipa
+1q3w
+6df1
+3ole
+2v16
+3g2s
+4led
+2uz6
+4pnu
+3nrz
+1f7b
+1j4k
+5ku9
+4uia
+5kv8
+2rke
+4e8z
+5ykp
+4z1n
+5sz1
+4oak
+3twu
+2r3p
+1jq9
+5cf6
+5l4j
+4qpa
+1u1b
+2k1q
+4eny
+4i0r
+5fxq
+3re4
+6cer
+6cf5
+2cbr
+5ece
+5t2t
+1x8r
+4n3w
+1klu
+5nxx
+5jcb
+5klt
+2mov
+6bid
+2f94
+4luv
+5gu4
+3wf8
+5ufo
+4n5t
+5uq9
+5hcx
+5mtw
+1o38
+5z1c
+4w4z
+4v27
+1u3s
+3jrx
+5l96
+1esz
+2m3m
+5ivf
+1o3p
+4auj
+2lyb
+5icy
+5j3l
+2fgu
+3snd
+2wsx
+4qfl
+5iu6
+1siv
+4ht2
+2ltz
+1o39
+4p0w
+3p8p
+5ypy
+3zvt
+2c5y
+3erk
+3exh
+6g4y
+4ucd
+3e16
+4i7p
+5alv
+1osg
+6gw1
+2oqs
+5wxg
+3tvw
+5hkb
+2r3n
+2iog
+1h1r
+5eyc
+1ogx
+3er3
+5itp
+4nuc
+4w9j
+4mz4
+5khj
+3gsm
+3hzv
+6dpx
+4hvg
+1s17
+6arm
+5jq7
+2v88
+5lay
+5nn4
+4hj2
+1rst
+1pzp
+3qcq
+3rx8
+5ewz
+5mgx
+4c1t
+3cso
+4wq2
+4gxl
+5isz
+2xj2
+4y5h
+3zcw
+1l8g
+5vex
+4tky
+4elh
+1d4i
+2wuf
+6gw4
+5ksu
+4jg6
+4eqf
+3hbo
+5yjy
+2gv7
+4x6p
+4hdf
+1yi3
+5edr
+5nmf
+4w7p
+4mb9
+4fz6
+1g4j
+4a2a
+5kx8
+5a0b
+4qta
+4fn5
+1gj8
+1kdw
+3d94
+6euw
+6glb
+2xaq
+3vh9
+1iky
+5j4v
+2f1g
+2r5a
+1g1e
+1bzj
+4abg
+3cho
+5t6j
+4jda
+5ywy
+6cdo
+6fo9
+1g74
+3oxi
+5t8p
+1fyr
+5hwu
+5ai1
+4e9u
+4uyn
+5k05
+6fgl
+5iha
+4aa2
+1wzy
+2w85
+3s2v
+4yuy
+6dud
+3chq
+3h5s
+1xdg
+4hiq
+3bgs
+3rqf
+1jmg
+4g93
+6c7b
+3zso
+4xjt
+4rsc
+5iyv
+1qxy
+5n20
+5c7e
+4x9v
+5tjx
+3tg5
+1b52
+1w1v
+5lg3
+2bmg
+5wii
+5zmq
+5wew
+5iua
+2g00
+4wef
+1i7m
+4hrc
+6at0
+4uhg
+5hvp
+1ugy
+5ll4
+5v6y
+1ru1
+2o4l
+2rc9
+2fci
+6evq
+3rah
+3g2v
+5ny1
+1p10
+5vsd
+5vqi
+5qax
+4aa0
+3ddu
+1pzi
+3sax
+4nmr
+5d26
+1elr
+3gc7
+3c84
+2y1d
+2uzo
+3v8s
+5mqv
+4zly
+3qqa
+5dlv
+4g3g
+3h9f
+4wr8
+5win
+4hzm
+3rqe
+5mw6
+5mwj
+1xap
+4zv2
+1ol1
+1a69
+4btt
+5t4h
+2oi2
+6bbs
+6aaj
+5i80
+1hte
+6cfd
+5kbe
+3saz
+2wej
+3kqr
+2b07
+3iue
+3bxf
+1is0
+5ktu
+4agd
+3nf8
+2nd0
+6fhq
+3vbv
+3f3t
+1zhl
+1g9s
+5vb9
+3qtr
+2ay4
+4u71
+1q66
+3qin
+5mzg
+5h08
+3rv7
+3rv8
+6ckx
+2itk
+4ij1
+1pxo
+5nt0
+5qao
+3le9
+4a6s
+3bls
+1pus
+3asx
+4lng
+3mvj
+4q3q
+3s9t
+4gfd
+5wqc
+3ri1
+5ih8
+6g6w
+3cjf
+6duh
+4pda
+1bp0
+3cpb
+4lmn
+1zm6
+6fjm
+2kup
+3v3b
+3vru
+3arg
+2o64
+2igx
+6ayi
+4qab
+4xu2
+5wzu
+1w6y
+5eis
+4ejf
+5wqd
+4aw5
+5f0f
+3iqg
+4p90
+5jfr
+5eak
+4n1u
+5alj
+6eku
+1j5i
+5hln
+2y7w
+3be2
+5uc1
+3ax5
+4f3k
+5qb0
+4llj
+4eyr
+5v3x
+4fys
+4crl
+2zxd
+2etk
+3ddp
+4q0a
+3el0
+2ica
+4jin
+5enc
+1pb9
+5lpm
+5jur
+5n1z
+5ou2
+4wet
+4y8d
+4gby
+5acw
+4r76
+5hrv
+3ocb
+4qxj
+5er5
+3hu2
+1v2l
+3dz5
+4j8b
+5vqs
+5khd
+5fho
+2f71
+5gmm
+3sd5
+3lxl
+3q8h
+4h36
+4qmz
+4ks5
+4dew
+1nf8
+3s73
+4r3b
+2oag
+2w06
+5j74
+2a2g
+4ju7
+3i81
+1af2
+5hda
+5zla
+3nu3
+6das
+5njz
+1b74
+2x6x
+1sts
+2co0
+4mw9
+5od1
+3pab
+2gnh
+5u06
+3uig
+2uw5
+2vrx
+1ele
+4j3m
+3hp9
+4mh7
+2xkc
+2w3l
+5hip
+4aqh
+4xv2
+1fch
+2j4k
+1o33
+2v57
+4a4w
+5bmm
+3dcw
+4i9o
+4ydn
+3lbk
+1gvu
+5j1r
+4no1
+5duf
+4wnp
+4djp
+4yzn
+4p75
+1b1h
+5hwv
+3rlb
+1c5f
+4fqo
+6b5m
+1iau
+4mcb
+5y93
+5qa6
+3wk5
+6fba
+2q8z
+4odl
+5mo0
+3wvm
+4qh8
+2w66
+2joa
+5fqt
+2viw
+4o76
+3cm2
+3ion
+1ero
+4y2u
+2rip
+6eiz
+3ieo
+2pk5
+2vgp
+2f6t
+1zfq
+5ypo
+2nnv
+4jvj
+2cej
+3hqw
+2boj
+3bzi
+5ut6
+2toh
+5urm
+5f3t
+5ml8
+2qpu
+6f5u
+3t3y
+2zx5
+5alu
+1z4n
+4w53
+5cf8
+4hcz
+1jik
+5ul6
+5l2n
+4k3q
+5vio
+2piz
+5ta4
+3jyj
+5ly2
+6do4
+1v2s
+4ezo
+3hl8
+4q1c
+3sk2
+6cdj
+4w4w
+5lca
+3rxf
+4q7w
+5ceq
+5aen
+3kjf
+2psj
+4avt
+5nxo
+2eg7
+3qn7
+1f73
+6eyz
+5ory
+2asu
+3rxg
+6ezq
+2chz
+3nzc
+1ilh
+1o4j
+6evp
+2wks
+2yc0
+4xy8
+2jg0
+1u33
+5iez
+2zxb
+2qnz
+3ob0
+1g36
+4at3
+5l3e
+3pd3
+5jjr
+4y8x
+3l4t
+3s2a
+4o3f
+5c28
+2zns
+4pp9
+4zvi
+5ul1
+3fwv
+2vvv
+2aof
+5vfd
+2qcf
+3bl0
+3gk1
+5i2i
+5w8v
+4bgk
+3piy
+4ptc
+4ddy
+2vwo
+6bt0
+5l99
+6f28
+1zh7
+5uiu
+4eh7
+5epp
+3iaf
+1o6h
+1b05
+5t5g
+5hva
+6b1k
+4k75
+3ips
+5obg
+2q89
+5a3o
+5owc
+5ggo
+4xk9
+3cf9
+5vrp
+3a1e
+1xlz
+5zz4
+5k0b
+2nta
+5fa7
+5fou
+4gvc
+5i4o
+4u7o
+1i5d
+2pmk
+3s1g
+6mvu
+6dvl
+5fe9
+5ur5
+3sbh
+2jiw
+2r43
+4ibb
+2v13
+4io8
+2vmc
+5ggn
+2afx
+1g3c
+4xty
+1xgi
+3mmf
+5v1d
+2uxz
+4wwo
+4kpz
+4xbb
+5up0
+2gzl
+4r5x
+3iet
+1oq5
+6afd
+1b55
+1xp0
+2q5k
+5ti7
+5uqx
+5w94
+1k1o
+4lm3
+1ek1
+2xxn
+5lsc
+4ui7
+6beh
+3ud7
+4zxx
+6gzh
+1uu9
+5jgq
+5l2y
+3v3l
+2gmv
+5bvo
+3snb
+5upf
+5tq3
+3gw5
+4wwp
+5wbo
+3ft2
+3rmf
+1fhd
+4flk
+2r0y
+2wbb
+3da6
+5ech
+3l4z
+1v2w
+4jjq
+2azb
+2oxn
+3f8w
+3moh
+5m3a
+3tz0
+3zyu
+2pzy
+5usy
+4mx0
+4cpq
+4aq6
+3qbn
+5gmv
+6rsa
+3u5j
+5h1t
+1ctr
+5lub
+4h5d
+5iz6
+5dhr
+4l2g
+4n99
+4r17
+4cc2
+4hzw
+5lbq
+3ati
+3pd2
+1f74
+1qyg
+5dhg
+4mwx
+5ohy
+4ob2
+3c0z
+2gtv
+4r75
+5w2s
+3wsy
+1rs2
+2r6w
+4gk4
+4qq5
+1n7t
+1ocn
+1gnj
+4u79
+3hmm
+2vl1
+1ec1
+3wk6
+5f4u
+4u5j
+4jfk
+4btw
+1vkj
+4jnc
+3fyk
+6f3i
+1w3l
+3gv9
+2ylc
+2fgi
+5sz9
+5gjg
+2q1q
+5yia
+2rny
+1o30
+3m1k
+6dj5
+1pfu
+4k42
+2wcg
+3oj8
+5g1n
+4lq9
+1jzs
+6g9h
+3axm
+4qp7
+4mma
+3zm9
+5wi0
+5iep
+2opy
+5c4l
+6eq1
+4y2j
+4x1s
+5mfs
+1bux
+4cjn
+5d2a
+6cms
+3g72
+4wz4
+2las
+4his
+5ohi
+2v86
+3wdc
+3d9m
+1fzj
+2ltw
+4kzl
+5ixf
+1fd7
+5f25
+5js3
+4ceb
+3dst
+4x7n
+4cr5
+4z2b
+3iph
+5t37
+3zqe
+6m9t
+3m54
+2oxx
+4mlx
+3uxg
+3qri
+4l0v
+1a07
+5qay
+3r0y
+1wbs
+6bgz
+1ecv
+4c94
+1ha2
+2kfx
+2be2
+6cjw
+2p94
+5tq7
+5fsc
+4btb
+5yov
+6eox
+5am2
+2pvm
+2ql7
+5j58
+1msm
+2bjm
+3rt8
+3ds3
+1m13
+4nxo
+2cfg
+3fqe
+3so9
+2m0v
+4r5b
+1v2j
+4bks
+4tkj
+1jld
+2ojf
+1z5m
+3m1s
+4lpf
+4zls
+4af3
+5eue
+2kvm
+5etl
+5hn0
+3f6g
+2jj3
+3sfh
+1ong
+3vb6
+3cen
+4rvr
+2wqp
+6fnt
+3ejt
+5c2h
+2hob
+3ml2
+1ld7
+1yz3
+3m2u
+2wcx
+1ec2
+3ccn
+3r1v
+3cn0
+4ks1
+5ah2
+3rtf
+2pvk
+3ppr
+4x9w
+5syn
+3g6g
+4hdb
+4bti
+1eef
+6bln
+4wyy
+4bw3
+3mks
+3iit
+2axi
+3aho
+3q2a
+2w12
+6e06
+5dy7
+1gi1
+3az8
+4ew2
+3tgs
+3zc5
+2ggx
+4ih3
+5u00
+4qkx
+4oef
+6gjn
+2xii
+5al2
+1o4p
+2xck
+3dcs
+2g0h
+5adr
+1kv1
+6h33
+2wl5
+6h3k
+3rwj
+5x4q
+2xk3
+3p4f
+5prc
+4gxs
+1qm5
+4aw8
+2eep
+5l15
+3tk2
+5heb
+5aia
+4nh9
+5nki
+3eos
+4m8y
+5u49
+5yh8
+3nxq
+2x3t
+5exl
+4x0z
+4rj6
+5ly1
+3zo4
+2nw4
+4n3r
+5ek0
+3otx
+4r4c
+1y3n
+5cal
+4dld
+5z89
+5sys
+1ybo
+2cmo
+1k3q
+2ima
+3caj
+1xug
+4l2k
+3gs6
+5sz4
+5alg
+4b4n
+4hxm
+2ov4
+3n9s
+4n07
+3zxr
+3v7x
+1aid
+4u8w
+2zis
+6e2o
+5yqn
+3oc0
+4qw7
+1c1r
+1zsf
+3cs7
+2x24
+5d7c
+1bji
+4yl3
+4k78
+2f9u
+3rl7
+5etu
+5drs
+6es0
+2g8n
+5ol3
+2i6a
+5gvk
+3sx4
+4q4r
+5nq5
+3ctt
+5kxc
+1tyr
+2uzn
+4oon
+3prs
+1f8c
+4jvb
+3eig
+1dbk
+4p74
+4zg9
+3wtn
+4cdr
+4fli
+2bts
+1u9q
+3n9r
+5ea6
+6db3
+4b6o
+3nnw
+3p5k
+2c4f
+2xuc
+4hvd
+3ijz
+5n4t
+4jr5
+6e9w
+5f63
+4cjq
+1b46
+4j4n
+4kcx
+4k4f
+6bky
+2bak
+5csd
+4mgc
+4mwv
+1mzs
+4ym2
+5ldo
+4ztm
+5epn
+3vb7
+5v7w
+3n49
+2zlg
+2kbr
+5fng
+2fgv
+1f4e
+2gd8
+3g6h
+5u0f
+4j44
+5v35
+1c9d
+6g6y
+4azi
+5kpk
+4ui8
+1q6j
+4p3h
+3gcs
+5ngu
+1sqo
+6bl1
+1o2j
+3u2k
+6mil
+1n7i
+3owl
+3g34
+1ec9
+3drg
+5j9y
+4crf
+3hha
+3qiy
+4pid
+2y55
+5hhx
+5etf
+4xar
+2pvu
+6b96
+5ito
+1li3
+3dya
+3ti3
+1tze
+6fmf
+1di9
+5f4p
+5sz7
+1m2p
+4yz9
+1uu8
+4y64
+3rt6
+3vs3
+4bdg
+5jv0
+4pge
+5cxz
+5ak4
+2j27
+4lte
+2ayr
+5m6f
+5dv4
+6ciy
+3ekq
+3c7q
+2osc
+2ph9
+4xqb
+5jr6
+2uwl
+1y3y
+1i8i
+2i7c
+4m1j
+6rnt
+3g5y
+3hwx
+1mik
+1sm3
+3py1
+5fah
+4pnn
+3tza
+3zmp
+2wxl
+5qaz
+4odf
+1eix
+5b2d
+5kdr
+3hcm
+2x91
+3frg
+6gch
+4qz2
+1hvh
+1g3m
+1tnl
+1vcj
+3s7f
+6cpa
+6g0w
+6ffh
+1nj5
+5epr
+6afr
+5kup
+4o97
+2i5f
+2f89
+5fsn
+3nex
+6b2c
+4zt5
+3sud
+5btx
+3fxb
+2x4z
+3l4x
+5svx
+5u98
+3lpr
+4pnk
+4ogj
+5k0s
+4oba
+6h7m
+3aas
+4zae
+4n6h
+4dsy
+4w9o
+2qbp
+5d45
+5lhu
+2bro
+1ugx
+4tx6
+6avi
+2aox
+4he9
+5n24
+2oz5
+1h8l
+3dz6
+3pwd
+1it6
+4rvk
+6b27
+2qu5
+4x7j
+5tyo
+2ym3
+5mjn
+3h26
+5ufs
+2wj1
+1rt1
+1kz8
+2zbk
+4krs
+5j87
+3u3u
+3g1d
+5bms
+2z7g
+4xv1
+4j8t
+5d11
+5c11
+3f17
+4alw
+3q3b
+3rwd
+1c70
+5kv9
+4wey
+4ok3
+2ctc
+4bcb
+5v49
+6e8m
+3shy
+4mnw
+5ut0
+3lcd
+5yc3
+2vwz
+2xbx
+1o0o
+2vj1
+6b33
+4hnp
+4bh3
+1ahy
+4rrr
+4rqv
+1hih
+5ovr
+4ach
+6c0u
+4k18
+1e72
+4ocq
+1b11
+3gds
+5ivs
+3bux
+3qc4
+5ovc
+3wzq
+1pu7
+1y3w
+6e7j
+1uu3
+5dh3
+3tu1
+4r5a
+4q3s
+4z16
+3uyr
+5wir
+5kby
+1bq4
+4iur
+4zv1
+5u8c
+4gtp
+6bj3
+2o8h
+3wqw
+5th7
+5tv3
+1tfz
+5ntw
+3cyy
+4q6f
+5w7x
+5tyl
+2v00
+4nks
+1ets
+2fq6
+4r59
+3bkl
+2boh
+2r5d
+1ikt
+5alh
+5szc
+1cr6
+4zzy
+1phw
+3l9n
+3eml
+3nij
+5amg
+3bv2
+2w73
+1h35
+3tne
+3jyr
+5l9g
+2xsb
+4f70
+2iuz
+1ml1
+3ewj
+4mk9
+2jiu
+4es0
+6dqa
+3kab
+5mxk
+2i0y
+4zy2
+3d4f
+6cqt
+2i47
+2i0d
+5oui
+2i80
+1nfw
+5wmg
+5uzk
+1y6a
+1e2k
+6ma4
+1nc6
+4zyv
+1wcc
+1kzk
+1nms
+1fwu
+5djr
+3a1c
+1hdq
+5ml6
+5l4h
+4rj3
+2x4t
+5nk9
+2xj1
+3mfw
+3gy3
+5nvv
+4rh5
+4x5q
+4jxv
+5ivv
+4axa
+5cbr
+5lli
+3q5h
+4wmu
+4lkf
+1rjk
+6g93
+4nni
+6exs
+6erv
+6msy
+1z3c
+3r5n
+1lol
+3qk5
+1rhm
+5avi
+4jfe
+3ti1
+5b5b
+4fjz
+1oxq
+3wk8
+6bl2
+3oe8
+3f7z
+4j3i
+5ogl
+6fob
+4o1l
+2uy0
+1g46
+5orl
+1uwu
+1g3b
+185l
+4z07
+2w8w
+3jwq
+1o2z
+5lsy
+3iok
+1sdu
+4xtp
+4qt2
+5fdd
+5ia2
+1ux7
+5jhk
+4ca4
+1qvt
+3kjn
+3t9t
+3lpf
+2bpv
+3jzr
+1fcz
+4p7m
+4hvb
+3cp9
+5jm4
+2q9y
+3eid
+4o4y
+6b1f
+3rxe
+4ap0
+4mu7
+1pvn
+4jfm
+1rej
+3ens
+4o7e
+3e9b
+4hby
+6guf
+5t1i
+5upj
+3c89
+3pcg
+3vbw
+3px8
+5kit
+6dh0
+1ukh
+5y5t
+4rxh
+2ien
+2upj
+3gzn
+3eio
+2hk5
+3emh
+1o3f
+5ipj
+6dai
+3hfj
+3su5
+3sh1
+5e0h
+4m3q
+4wf2
+2pj3
+2osf
+2r0z
+1jrs
+1i9q
+2qd8
+2jfh
+2aa9
+5vt1
+5vsj
+5l0c
+4ybk
+3zmt
+5kr1
+2r7b
+2lh8
+2wyn
+6lpr
+3v2n
+5oq8
+6bhd
+2pym
+4xaq
+5m0m
+3puj
+3tcp
+5k5c
+2rnw
+5qa8
+4gtm
+3uec
+4ncm
+5hvs
+1lxh
+5aux
+2h2d
+4qir
+1s89
+4bhz
+1qwf
+2avv
+5knt
+4odn
+3o1e
+3lj7
+3eov
+6cpw
+1qca
+1jii
+3lkh
+3rul
+4g4p
+1qk4
+5nkh
+1w0z
+1jlq
+4meo
+4pmt
+2vvc
+2v2h
+4lm2
+1bzs
+1v0n
+3d67
+4uxj
+4bo2
+4aa1
+3ga5
+5hka
+3vtd
+2gm1
+4x6x
+6ma2
+1tpw
+2uxi
+3gc4
+1v0p
+2uzb
+5xvq
+3r7b
+3b8q
+2y6c
+1jd6
+3bc5
+2bes
+4f6x
+3uvk
+6m8y
+4avu
+5vwi
+1ms6
+5xo7
+3dcq
+5idn
+2ygf
+1zsr
+4zzx
+1bl7
+4k7n
+5voj
+3ck8
+5d6q
+5y0f
+3dpk
+1bjv
+4kn4
+6bw5
+3dow
+1mzc
+2nng
+2xnm
+3f8e
+2ndg
+4lh5
+3e8r
+2e9o
+3uih
+4hlc
+5moo
+2i3h
+6ew6
+3ama
+4l0t
+1vj9
+3pup
+2xct
+5fh8
+5ivz
+1str
+2xxx
+5mra
+4o28
+1d6n
+1pr5
+2cma
+4qt0
+2a5c
+5yy9
+2x81
+2cv3
+5jo0
+3l0e
+6hly
+3p3j
+1eed
+5aib
+3qbc
+1n7j
+5fpi
+6gxw
+1rw8
+5zw6
+4e3d
+2mji
+6ayh
+1w2k
+3zns
+4jbo
+5mty
+6c3u
+4ks4
+3ds9
+4hld
+3elj
+4j45
+5cgj
+5v41
+2yne
+5nad
+5lvq
+3d9p
+3ske
+3ip5
+1w22
+4kbk
+5lqq
+5wyx
+3ps1
+5ou1
+2xru
+3lq2
+3t4p
+3uzp
+2o2u
+3dei
+3u93
+4z8m
+3lhs
+2f81
+3fn0
+4iqt
+5laz
+1xot
+1zs0
+1oau
+5d47
+3o4k
+6dcg
+1o4q
+1csi
+5nwd
+2wca
+1u1w
+5aae
+4gja
+2pj2
+5f2p
+2yme
+3cbs
+2wxg
+5u0y
+3uhm
+5qaw
+5d3h
+3sb0
+5alx
+5g57
+6afj
+5jf5
+4ccd
+5mhq
+5etx
+4k6u
+5tb6
+6g28
+4zyz
+1sj0
+4eh3
+2r5b
+5eq0
+1cil
+5le1
+5vm0
+2ff1
+3f8f
+2rka
+3dda
+4iu4
+2vc7
+5bs4
+5a0a
+4fyo
+1p2a
+4ps8
+2uze
+3iw4
+3nzu
+3gi6
+5dtt
+1gaf
+3nii
+2xm8
+4att
+2vex
+4jx7
+6h34
+4tvj
+3pvw
+1ai7
+1kc7
+2rl5
+6c0r
+4rcp
+1nhv
+5mw2
+5hct
+4mg7
+1drk
+4mzh
+1r6g
+5xpl
+4o74
+3bu8
+3cgf
+4nie
+1xos
+2wlz
+1a37
+5lpj
+1yvh
+4xhe
+2lct
+3lau
+1g2l
+4uiv
+6b4u
+3jqf
+4pvt
+5lpl
+3sdk
+5km3
+3fmz
+1t7f
+4p5z
+4tk1
+2j9a
+3bbt
+3tjc
+2qi4
+4acg
+5tuz
+5uuu
+5ckr
+2h2e
+5qai
+1qxk
+2wyf
+3f0r
+1rd4
+2ipo
+1ukt
+2xx2
+3hvh
+5d24
+4bdk
+2xu4
+6alc
+4r5y
+3kdm
+4gk3
+1x1z
+4pz5
+2duv
+6fnx
+5u4b
+4dfn
+1n9a
+5mny
+5ktw
+4qem
+3l81
+4c0r
+1utp
+5tuy
+5fb7
+3n7r
+3bze
+2bvd
+2fx6
+5vcw
+4ibf
+1zom
+4f6w
+1i91
+3ikd
+4w9e
+4ntj
+4wk7
+1cx9
+3f15
+4u6c
+1ing
+3wq6
+2yb0
+3wtl
+5yl2
+2hz4
+2gbf
+3r8z
+5cso
+2j95
+5jxq
+4ofb
+2fr3
+5b4l
+3ovx
+6cha
+4qwl
+1tl9
+3mo2
+3c8e
+3k5x
+3fhr
+1b3f
+5a8z
+5bvk
+2hb1
+3qxd
+3i4y
+6g9d
+6gop
+1oar
+5flt
+2zhd
+2xey
+4ikr
+4ckr
+5xvk
+4lq3
+1dtq
+5bpp
+6fg6
+3fl9
+6em7
+5cnj
+4os5
+6awn
+3atm
+5msb
+1odj
+2h5a
+2w3k
+5w1v
+1pi4
+4kx8
+5m25
+1dhj
+2qki
+3oag
+1n0t
+5dyo
+1ql9
+5u7k
+4mjr
+5mtx
+4u6w
+3d8z
+2pnc
+5em8
+5cil
+3iny
+5l2t
+5fow
+2owb
+1k1y
+3ijg
+4ad2
+4tqn
+3zzh
+3qel
+5jha
+3rxh
+5xqx
+3q2g
+5wl0
+4bic
+1xp9
+4u7t
+4ef6
+5jzb
+2h8h
+5sxm
+2ym8
+6fmi
+5f1h
+4qyg
+2qtu
+1vwf
+1ivp
+5typ
+5igq
+4h1j
+3sug
+3h85
+6hf5
+2poq
+6afa
+4mpc
+6c0t
+5dit
+3h8c
+2e9v
+2hfp
+4u5n
+5caq
+4m2w
+4tv3
+4ux4
+3oy8
+3owk
+3arn
+4i6f
+2dri
+4ymj
+5ix0
+4jr0
+1nzl
+5u4a
+4eg4
+1wbw
+3nee
+5fdp
+1hvs
+2w6q
+1n8v
+5ct7
+5dx4
+2fdd
+4ydf
+5c2e
+3qsb
+5zk3
+5vgy
+5ot8
+4j70
+6boe
+1c29
+2pjl
+1jd0
+2euf
+3as1
+3abu
+3dpd
+5aku
+4k6w
+4j3l
+4nau
+3fpm
+3c3q
+3mg7
+3buo
+3rhx
+5lyh
+1b0h
+4ynd
+5y0x
+5enb
+2a5b
+5mqe
+1tl1
+4iaw
+3way
+3gs7
+3ex3
+1szm
+5mxq
+2cnh
+4eyj
+6mj7
+4ln2
+4jia
+4l4z
+4qr4
+2er9
+5vnb
+5xff
+4prp
+2jqk
+1gi8
+2ynr
+5nk2
+1rsd
+5umz
+3jzf
+4k69
+6b5o
+4o4k
+2afw
+3nht
+5xof
+4f9w
+3wym
+1w31
+5c6o
+3nim
+1vso
+1o37
+5i8g
+3lbz
+4bqs
+3tfv
+1bra
+2k46
+2w76
+5jcj
+3b92
+3zha
+2i4x
+3ess
+3sap
+3wbl
+5trk
+2n8t
+3ge7
+4unn
+2ria
+4wgi
+4bds
+2y06
+6bhh
+1olx
+4raq
+5i56
+2xk4
+4az0
+3ov1
+4ycw
+5ei4
+4u1b
+3bv3
+5etp
+3kcf
+6fod
+3eq9
+1eat
+4giu
+3vyd
+2pvh
+5aaf
+2hdr
+1lgw
+2lsp
+4l02
+3ioe
+4c1m
+4obv
+3r6t
+1uj6
+1a09
+4yk6
+1rzx
+3cy2
+4la7
+1qwe
+2opb
+3psl
+5y5w
+2j4q
+5vfn
+3e37
+4fzg
+5qim
+1bzh
+6da4
+1oxr
+5hgc
+5ieg
+6cq0
+2ioa
+3lpg
+4mzo
+1w7x
+2aia
+5abg
+2xcn
+5toz
+5tp0
+4z22
+4wlb
+4pd5
+3zbx
+3pb9
+3f5l
+6bke
+4p7s
+5enh
+4m3p
+4jmg
+1k03
+4pni
+4asy
+1a4r
+4deu
+4hy9
+4g0p
+3wqv
+2r3m
+5ar5
+1drv
+4ua8
+5eh8
+4wy3
+2aov
+6dj2
+2og8
+10gs
+4uw1
+4hge
+5qcn
+6c4d
+1bai
+5hfb
+3i5n
+6epa
+3dgq
+5tzx
+4h3b
+1e5a
+5n93
+2exg
+5k4l
+1qpb
+1f3e
+4a0j
+5ula
+4cc3
+2oym
+1dis
+3ns7
+3uz5
+3ewz
+1qbo
+1nd5
+2qzr
+4oq3
+6e9l
+2n0w
+2hr6
+5vse
+5jsm
+1ssq
+3l4u
+2r3k
+3e3u
+4ibi
+3kgu
+1tni
+1dva
+5mno
+1qbu
+3px9
+5xpm
+4zjw
+4gqp
+3r21
+3lpp
+4bdt
+4ks2
+2v58
+3bft
+1il5
+5yco
+4p5e
+3rhk
+4q7p
+4x3h
+1ro7
+3lil
+4mwq
+3zsw
+3wf6
+1tft
+3hpt
+5t3n
+4oo9
+2b5j
+2bet
+3nuy
+5nea
+3kdd
+5ls6
+6f2n
+4rac
+4j47
+3iut
+4uvv
+2i4v
+5k48
+2hpa
+1mrs
+6fv4
+1q8u
+5aqz
+4ytc
+1ibc
+2v95
+3me9
+4kn0
+1ai5
+1n51
+1gnm
+4zur
+4zsj
+3v8w
+4tzm
+5ih9
+3gen
+4r6t
+5u7i
+4e81
+3v01
+3n4b
+1jmi
+4dcx
+4mzl
+5tcj
+2w54
+4o13
+5ufc
+2xs0
+4flp
+3o8p
+3tpu
+5yft
+5mql
+5w6e
+4pqn
+4m48
+2iiv
+4ohm
+4a9c
+6en4
+3wk4
+3p50
+3bpr
+5wys
+4oel
+4u01
+4ibc
+4jpy
+1q41
+2gvd
+5aip
+5i0b
+4zyt
+4yxd
+4qt1
+4w4y
+3e5u
+3kqd
+4uj2
+3k4q
+3b0w
+3t64
+1hty
+5dgm
+3bjm
+1b8o
+4l3p
+2b1z
+4yyi
+5ceh
+5ny6
+3ebl
+4bo8
+3fup
+5ot9
+3eax
+3vhk
+3cda
+5c1y
+1obx
+4tzn
+3qd3
+3wka
+3ihz
+5iis
+5vo6
+5tc0
+3fqk
+1dm2
+4y63
+6mvx
+4ucu
+5oht
+1n8u
+4xua
+2ybp
+2cgf
+1hn2
+3d4q
+4qp2
+4gsy
+2psv
+5lck
+1xxe
+5trg
+5dp6
+2lnw
+5kr2
+4utx
+1a8t
+4qw5
+2itt
+4m7y
+3kqo
+5ku3
+1oit
+1w1t
+4j26
+4yh3
+3nzw
+3vw9
+1csr
+2we3
+6mnf
+4ijh
+2jdk
+4kcg
+1kmv
+1mxu
+4ovh
+4mg8
+3lka
+4twy
+5vsb
+4ofl
+6cdm
+2f3k
+4tkg
+5w4e
+3zot
+2yak
+2pv1
+3avz
+2q8g
+3ilq
+3zw3
+1qbr
+4q08
+3zpu
+3rtp
+4b95
+2f9b
+2uz9
+4ehg
+4xsz
+6f22
+1tet
+3f3w
+4abd
+5jsg
+4op3
+6fsy
+3twv
+5d25
+2vto
+2oa0
+6csq
+6dh3
+6c7e
+5jq9
+4tmf
+4brx
+5zku
+2ghg
+2gvj
+4wnm
+5ayf
+4osf
+1i90
+3lzs
+3gdt
+6eru
+5ops
+2mpm
+4cc7
+2vvs
+1o4d
+4bkz
+6ep4
+4aom
+1wc6
+2pl9
+2p53
+4zyr
+6g9a
+3gqz
+4mlt
+1mf4
+1xxh
+3p3g
+4xu3
+3g0c
+5dbm
+5g60
+4a9u
+4gj7
+4nwd
+4ei4
+5yjf
+2won
+2f2c
+3mg8
+3i06
+2wa4
+3hzm
+3wkc
+4j7e
+3dxm
+3m9f
+4clp
+5a09
+5tg5
+1njf
+3ce0
+1tpz
+6bh0
+3su1
+2vtn
+5yp6
+4i74
+5zk8
+2al5
+3bh9
+4djo
+5m4u
+1wva
+3uvx
+2aod
+1pqc
+4n4t
+5fdi
+1lcp
+4ere
+1ci7
+2qju
+1ftj
+5hk9
+5y3o
+6ayn
+5os1
+2qm9
+2x6j
+5ei2
+5izc
+3u18
+4zek
+4s1g
+2wq4
+1nfy
+6bnt
+4jai
+2jb6
+5ahw
+4uit
+3bmn
+6gxu
+4gki
+3ccb
+4ezq
+5v7a
+4az3
+4ucr
+4pnt
+2wtj
+5amn
+4ux6
+3t8v
+1i33
+3r7n
+5nvy
+4aq3
+4d8z
+3wdz
+5nib
+6b8y
+1v2h
+5jpt
+1xge
+4umn
+2xrw
+2vvn
+3t07
+2vpp
+3zcz
+4ydq
+2dbl
+3ho9
+5w88
+2g71
+2lk1
+4ai5
+1o41
+1tsv
+5al3
+4fk7
+2o4z
+4a51
+4gwk
+3own
+1lcj
+1hk3
+3kbz
+4rhy
+4yoi
+3prf
+3slz
+2qwg
+1bdq
+4emt
+6bec
+1qf2
+2r0u
+1f2o
+1b9t
+2c1p
+1hn4
+6c2y
+4pg3
+3uw4
+1wdn
+3mho
+4yl1
+6cex
+3b7r
+4pop
+5f02
+3d7b
+4nal
+2zft
+4oya
+3otf
+2xhm
+5c20
+1zrz
+4rqk
+5k8o
+1tvo
+6fnr
+4zlo
+1nyx
+5aad
+3kqw
+3nw7
+6e59
+5ti6
+1ywr
+2xn5
+4cy1
+4rpv
+1yfz
+5e3a
+4a7c
+5ljq
+4yje
+1gi6
+2b1p
+1kc5
+3kpw
+1q5k
+4aml
+4ibg
+6e49
+2w8y
+3kmm
+2w6o
+3hdn
+1u8t
+4e8y
+4gj6
+3vf8
+4hbm
+4g3f
+4eok
+2rox
+1t48
+2xd6
+2fjn
+4z9l
+5ndb
+4j77
+3ui7
+5e73
+1h1h
+4ep2
+3kdc
+4jnm
+5h9s
+3cth
+2j34
+1h62
+6bil
+3mhc
+4zw8
+3g90
+4f7v
+4eh8
+5wkh
+4ycm
+4mk8
+2xj0
+2tpi
+4clz
+4ko8
+5qaj
+5dus
+2uzl
+1k1l
+4g95
+5g10
+4nnr
+3e64
+1fq8
+4c71
+4b0c
+3ft3
+1ybg
+4y2t
+5mme
+5dk4
+4dds
+3ggw
+5axi
+3ueo
+2r9b
+3ppj
+1meu
+4z7o
+3n8k
+2jup
+3p9j
+3hxe
+1e06
+3ika
+3su3
+5yyf
+4kc4
+2uy4
+4z7h
+5hcv
+5ir1
+1f9g
+5law
+3o99
+1yci
+6mu3
+3g3d
+3aje
+2o5d
+3b7i
+6af9
+2gvz
+4qmt
+3qj0
+2y9q
+5wg8
+4bzr
+1k6t
+3fui
+1lek
+5kql
+5d21
+1iig
+5ewh
+2gh6
+4x6y
+4mbl
+2v54
+5ug9
+3hvk
+3qts
+3q43
+4nvq
+3co9
+4dwb
+5jbi
+2il2
+1yt9
+3t6j
+2zu5
+5buj
+2xiy
+2fs9
+1al8
+4cig
+3cgy
+4mdq
+3st6
+4dzy
+1m0o
+1lkk
+4uu7
+1zky
+5d9l
+1zd3
+5t6f
+1g2o
+2i1m
+3khv
+3o88
+5fi2
+3idp
+2pov
+2qe4
+3qtz
+5alm
+3fts
+2x4u
+4o45
+1tkx
+2q8h
+4eop
+5akk
+5wtt
+3h9o
+3v4x
+5o0s
+5b6c
+4bch
+5nkg
+5c4k
+2br1
+6ajg
+3whw
+6b59
+5aan
+6fo5
+4ddh
+4pmp
+5i0l
+2xk9
+5mon
+2xib
+3c2r
+5mfr
+2ra6
+2xl2
+4w5a
+3zm6
+3zm5
+3zhz
+3ogq
+4rrq
+4wxi
+4asd
+5txy
+5u0w
+4xta
+3t2v
+2q9m
+5lyw
+3hmv
+6g92
+1z6f
+5a46
+3gnw
+5k03
+2bgn
+3ohi
+3acw
+3hng
+4j06
+1owj
+1gbt
+4fmo
+4g8v
+2fzc
+2vx0
+2o1c
+5unp
+4o7c
+4rxe
+5t90
+5jyo
+2wzy
+1tfq
+3s78
+2ei6
+3peq
+3o9f
+1mq6
+1k6v
+5m39
+3wz7
+1nwl
+3ard
+5e3d
+4ogn
+2woq
+3iw5
+2h15
+3avh
+2azr
+5vsk
+6ckr
+4up5
+4n84
+4eh2
+4cpw
+5f91
+4k3r
+4dgn
+2yer
+5ayt
+4cpz
+4y29
+5tq6
+3roc
+5lwm
+3gjd
+4zip
+6exm
+5qak
+4u0n
+5wo4
+1rrw
+5hls
+3pjc
+1cin
+3b2w
+1kmy
+4ys7
+4f0c
+3vqu
+3uoh
+1qr3
+5i8b
+2aay
+4jlm
+3wnr
+4en4
+5w0f
+4lxz
+4cjr
+4jj7
+2h5i
+3ezv
+3hkw
+3uxm
+5hjd
+4b5d
+2vtt
+2y1n
+5nin
+3uvo
+5anw
+5nvw
+4b9k
+1j4p
+4io5
+4dkp
+2jdt
+1iem
+4lm0
+5nr8
+6f7t
+5ort
+1h1q
+4twd
+4anm
+1e1v
+4tki
+4wv6
+4htx
+2qw1
+1t13
+4euo
+6gy1
+4civ
+5y8z
+5knv
+5hn7
+4kqr
+5vb5
+3f5p
+2kfh
+4b3u
+5nf5
+5mes
+4w55
+1sv3
+3p7a
+6frf
+1o2t
+5afm
+3cow
+6f9g
+3ds1
+6a6w
+2g8r
+6e05
+5cau
+1s38
+1zge
+1me4
+3cj4
+4pr5
+4gzf
+1q54
+5l9i
+1z6j
+2ez5
+3unk
+3o86
+4j51
+6fyi
+3cj2
+5ekm
+3f9y
+2uy5
+3u7l
+2brb
+5g45
+5jgd
+4ikt
+5opu
+4mwc
+1t7d
+2viq
+3ocp
+3wuv
+4yay
+2vh6
+2ra0
+5fwg
+1o3c
+2mip
+4bi0
+1kll
+3qtq
+3ho2
+3vw7
+6h37
+4rlw
+6dak
+3p3t
+3m11
+6fdp
+4c73
+5ksx
+1okl
+4gqq
+2x2i
+3sji
+1hkj
+5hu9
+5vom
+5fdo
+1uu7
+5iay
+5nu5
+4q06
+3apc
+1re8
+5uey
+1tcx
+3w0l
+3s45
+3n5j
+2p59
+1rhj
+5d0r
+2qp6
+2vqj
+4d3h
+2zaz
+2zir
+5alt
+5w5j
+3ekw
+4xas
+5mwy
+4mwy
+2z1w
+1d4t
+4yk0
+3hnb
+6g36
+1rhr
+3tzd
+2r3f
+6bcr
+5idp
+4n6z
+3qcx
+4z89
+4pkb
+1xoz
+3d9z
+2vnp
+4meq
+3so6
+3tiw
+6h7u
+3u0d
+1ur9
+4lar
+4css
+2a3c
+1h3a
+4aqc
+5l2s
+5vi6
+6cmr
+4e3m
+3vgc
+3chs
+5uc4
+2x6e
+5ey9
+4ih5
+1mto
+4qwi
+5nai
+4ym4
+3prz
+2nnp
+1vij
+5bvd
+5swf
+3pn3
+2pql
+3ekv
+5c7n
+1els
+5bqi
+4k5m
+1o2k
+4x69
+5mts
+1e9h
+4ykj
+6i3s
+1zpb
+4u70
+4wph
+4xy9
+4ith
+5aph
+5cy3
+3fat
+4ly1
+2vti
+1f0q
+4wsy
+1b7h
+3ej1
+3rux
+2vvu
+5a3t
+4qtd
+5a5s
+3t7g
+4gah
+5flq
+2hw2
+4hl5
+2imd
+1ndv
+5yji
+2hxm
+4jpx
+4uix
+2iv9
+4dwk
+4qvp
+2c1b
+5cw8
+3h22
+2d3z
+2oc9
+4ehz
+1ett
+1fdq
+2avo
+4r0a
+1zzz
+3moe
+5muc
+3zqi
+6f08
+6dif
+3mf5
+5qas
+3fu5
+3rv9
+5urj
+5oxk
+4y3y
+4tyb
+2glm
+2xnb
+3tt0
+6gmq
+4i5p
+2wnc
+1f92
+3psd
+5hcy
+2wot
+1q6n
+4tmn
+1tmn
+3zep
+1c88
+4fea
+5nwb
+1ppc
+5myx
+4ci3
+1z6d
+4kww
+4ixu
+1leg
+3a5y
+4bo3
+5cyi
+5uzj
+4mw0
+5j18
+5ml3
+2bmk
+2brc
+5oxm
+1bn1
+4qlv
+5wxf
+5yib
+3ig7
+4pgb
+4p73
+2y4s
+5tex
+3b4f
+4zyx
+3poa
+4m0y
+5e91
+1yc5
+3iqi
+1o2s
+1pmu
+4l58
+4mx1
+5am4
+2hs2
+4yne
+1ctt
+2zm1
+1lxf
+2f1b
+4zw5
+2oh0
+5n2z
+3f19
+2obf
+6f9t
+5vee
+4oyo
+5moq
+3ft4
+6cbg
+5wuu
+5f5b
+4xs2
+4rwl
+4hpi
+4e34
+2fxr
+5jy0
+5e1m
+5oq6
+1nhz
+3pjt
+5jzi
+4elf
+4fxy
+6dpz
+3mo0
+2waj
+2fqt
+3mxy
+1y91
+6biv
+5xjm
+3zmi
+4wn5
+2fv5
+3p3u
+3ryj
+3b95
+3i5r
+2ajl
+6c99
+3bx5
+2rf2
+2j2i
+5g0q
+4yuw
+2r3g
+2bgr
+4l9i
+4igk
+4qfp
+5ty8
+4odm
+3hs8
+4ele
+5zia
+2pvj
+5w5k
+4m5l
+3wz8
+1nfs
+5w7j
+4jfw
+6eda
+5m5d
+3kag
+4zam
+6eed
+2jbp
+4z3v
+2pu0
+4f14
+1pxh
+2hwp
+1u9e
+4wko
+5kqx
+1tog
+2xf0
+4uof
+4io7
+4ds1
+5diq
+3ti5
+4x8u
+3avm
+3kqm
+4zph
+2wou
+4jyu
+3ip8
+5ti3
+4cku
+3vdb
+3chd
+4i5h
+5i2r
+3tyv
+4uwk
+5j6a
+3lk0
+5k13
+2hj4
+3bfu
+4ajk
+3n45
+3te5
+5v9p
+2bzz
+3a6t
+1hvl
+5a2i
+4mx9
+4g8y
+4dko
+3kdb
+1lf9
+4qmp
+3w32
+4d2d
+4ksp
+6f8b
+3h6z
+5k0h
+3h2n
+5ke0
+5w4w
+5mxr
+5igl
+2h9p
+4iuu
+4d8a
+3dvp
+1lox
+3ao4
+4h38
+4bdb
+4j1p
+1o4b
+4mro
+5eel
+2ay3
+3e8n
+6g8m
+2pyy
+4m0z
+2mas
+4ks3
+4p72
+6ccx
+6aqq
+6em6
+4rqz
+4hkk
+2q6f
+5he1
+2wu6
+2pj7
+1bty
+1ule
+5ezg
+3atw
+3s7b
+4x48
+1kug
+2hdu
+1bmq
+3odu
+3l9m
+2ihj
+5mgk
+2n1g
+6hk6
+1mq5
+4kp5
+1yyr
+5al4
+2z4b
+6axl
+5mym
+4gv8
+2cni
+4xub
+6cjh
+3ig1
+4m2r
+5ime
+6d6u
+1utj
+1dfo
+5anu
+2ogz
+5vad
+2x9e
+6epz
+4yv2
+2jdh
+1w13
+4eos
+4x1f
+4gao
+5c8k
+4k5n
+3pj1
+1x7a
+1h9z
+6gjm
+3ipe
+3fuj
+5g11
+4asj
+4ybs
+5gmi
+3d04
+2fie
+3ary
+4anb
+6hmg
+4n9c
+2lsk
+2ksb
+5mwd
+1gfw
+5gja
+2f7o
+3mzc
+4nmq
+4qz7
+1bug
+5jf3
+2qft
+5jop
+4jaj
+3s9i
+6cvy
+3oaf
+5ta6
+5mae
+5m2v
+4zxy
+1g9r
+3pch
+5kkt
+2fqo
+5mn1
+3e3b
+4jlj
+4zga
+4jlg
+1pf7
+5ewd
+4dhf
+4ywa
+5fxr
+4e1k
+2zmd
+4jyv
+6iik
+3zxe
+2vx1
+3hav
+1trd
+3u10
+2a0c
+3ly2
+6f6n
+4rj5
+2xn6
+1irs
+2ntf
+3rum
+6iin
+5hzx
+1urw
+4umr
+5apr
+5ngt
+3q71
+3og7
+4oeg
+2ow6
+3sff
+3eu7
+2zju
+5tx5
+3v8t
+1nqc
+3t2c
+4afh
+3vhu
+2d1x
+2h2h
+5nvz
+4qy8
+3w2s
+4w9h
+4r6v
+5esq
+5v5d
+4q07
+4jrv
+2in6
+3bki
+6ayd
+4zyc
+4ybm
+6min
+3ibu
+5kde
+1br5
+1ujj
+1lan
+1gwq
+4av0
+4qpd
+4urk
+4uct
+5uwj
+4b8y
+5nvc
+6f23
+5w0e
+2hdq
+5c6p
+2amt
+2rgu
+6g9n
+6hu2
+3v7d
+5iz9
+2vev
+3dej
+2hxq
+4mvx
+2c3l
+5c29
+1we2
+6f9u
+2f80
+2ooz
+4py2
+4zcw
+5kx7
+4m13
+4kz6
+5ypw
+1qf5
+2zdn
+2i4w
+2xu3
+1wbn
+5lt9
+3zmv
+4efs
+7cpa
+2i72
+4rpo
+2h13
+4obo
+3f88
+6g47
+2y6d
+3o57
+5a0c
+2fl6
+5mja
+5g22
+3g9l
+1y2a
+5znp
+1hi4
+6ay5
+3f5k
+3et7
+6bvb
+5u94
+1m1b
+3ryv
+2peh
+4ppa
+5e1e
+3i51
+5fb0
+1rtl
+2i4p
+1a9m
+6au5
+4jyt
+4k3k
+2c5o
+2qu6
+4hwr
+6bqk
+4bqh
+4dea
+6gzm
+3fuk
+5y3n
+2ypi
+1b3l
+4o44
+2e1w
+4zz2
+4ucs
+5arg
+3sl0
+3p3r
+6an1
+3eor
+2uue
+1n4h
+3gk2
+3oot
+5i5z
+3hv3
+2hzi
+5yc2
+1g48
+5wbq
+4axm
+6g91
+4q0l
+6df2
+1d8e
+1lpg
+1gmy
+5yy4
+6ht8
+3orn
+2x5o
+1pk0
+1xt3
+4lkd
+1v2n
+4ufl
+5bsk
+3uza
+2w8f
+4nka
+6bef
+5oaj
+5abw
+6bkh
+5l30
+2clx
+4an1
+4ufz
+5nk6
+1syi
+3zsy
+5ul5
+3irx
+5ux4
+3e2m
+4bdc
+5fut
+3lgp
+2ivz
+2ydi
+3zxv
+4g2w
+3o95
+6gu4
+2doo
+3n5e
+2y5k
+3g0g
+4a9r
+1qfs
+5mli
+4o7b
+3ty0
+4uil
+3st5
+3f36
+6fqo
+6ghj
+1h8y
+2pq9
+5em3
+3juo
+1rlp
+1z9g
+1yvf
+4cqg
+3srb
+6fmk
+4o6e
+5xmv
+1ke9
+1mfd
+1a5h
+4b1j
+3up2
+2ay5
+5mqx
+3lpu
+3bmq
+5alp
+4qj0
+4j5b
+3pz4
+5ee8
+1ka7
+4np2
+3bwj
+5a0e
+5all
+4jze
+2xa4
+3b3x
+3sm0
+4yp8
+4bc5
+5f08
+4qw6
+5ofv
+4y83
+4y4j
+6cfc
+5eth
+1oky
+2ban
+4blb
+3f38
+3g0w
+2uy3
+6fdq
+4qmx
+4bo5
+2oph
+5t9w
+4av4
+2wxv
+5v8p
+4eqj
+4aoc
+5jk3
+4xtx
+2aoj
+1v7a
+1sqa
+3lzv
+3bum
+3fxw
+1b6j
+3f80
+4or0
+6dq5
+5lsx
+4bdd
+4x8v
+4od9
+3vye
+2yix
+2k4i
+3wci
+4z0f
+5dp7
+5llo
+3d20
+2ymd
+4hn2
+5n31
+4ffs
+4b5b
+4i73
+1fkw
+2pqb
+2i19
+1cbx
+1gsz
+5ws3
+5u4g
+4h3q
+4uvy
+4mfe
+4guj
+3c8a
+4ll3
+4pp0
+5hk1
+4rux
+3coj
+4kpx
+3d6p
+1o79
+3nti
+5hl9
+2e27
+3wdd
+3azb
+1lnm
+4x24
+4tsx
+1bqn
+4e8w
+5xyf
+4uco
+1eas
+2b7f
+4m5u
+3ipu
+2xog
+4p5d
+4bcp
+5thj
+3tam
+4jsc
+3ug2
+3c3r
+5e7n
+1ofz
+3uo4
+2buc
+3gr2
+2m0u
+6f7q
+1sme
+3h3c
+1xff
+4oc6
+3b3c
+1xa5
+1fe3
+5olb
+5a85
+2oz2
+4d8i
+5swh
+1inc
+4obz
+2clh
+4i5c
+1p28
+5j7s
+4iq6
+1hyz
+2pe2
+4f3c
+4ih7
+4puj
+4w9i
+3qrj
+4dcd
+4azg
+6azl
+6dxx
+4sga
+1gja
+5k4j
+4yef
+1sbg
+3s00
+5fcw
+4txe
+5xxf
+5jic
+4abh
+3nzx
+3q4l
+5edl
+3pcf
+3qqu
+1hgj
+2qch
+2yim
+4dtt
+4l09
+3f07
+4hki
+4cl6
+5amd
+1ym1
+1s64
+2w6t
+3tl5
+1w1y
+4eoh
+5i58
+4z5w
+6hu1
+3wav
+1nxy
+3n4c
+5c91
+2kzu
+5kre
+2jkk
+4hkp
+4y2y
+4w54
+4few
+1q95
+4bnu
+3lp7
+1gni
+2idw
+2xy9
+2q6b
+3uxd
+3ao1
+3v2o
+5ewj
+1i00
+2rgp
+2xln
+6ma5
+4d2w
+6eww
+4lkq
+4o7a
+5m4k
+1wm1
+4fzj
+2nyr
+2mc1
+2qky
+6eh2
+4glw
+3arb
+2vin
+4rss
+3q7j
+2h4g
+2x2c
+1gt4
+1fo0
+1ftk
+4kby
+1ch8
+5fnu
+3sv7
+5uah
+2wpa
+1a4h
+5lhg
+6eeh
+4mse
+3nnv
+6eq4
+5f1l
+3q0z
+2uzd
+1r0p
+1j16
+2qhz
+5h0b
+4nyt
+5ij7
+4l2l
+1afl
+5vd0
+2ves
+5tyn
+3gf2
+3nuo
+5w2p
+4uv9
+1dmb
+3b7u
+4xbd
+5m6h
+4zh3
+5d0c
+2e7l
+3kba
+5nhh
+1p0y
+2l7u
+3wns
+5u4d
+3axk
+4qpl
+5jt2
+2rk7
+5lss
+3sni
+4pb1
+3oe4
+5m63
+5xg5
+3lle
+4bo4
+4o10
+2yac
+4odk
+2x95
+5v9t
+2ig0
+2zdl
+4ay6
+2c1a
+1nny
+1nw4
+3kah
+4db7
+3ifl
+5f9e
+4p2t
+4exh
+6d2o
+6eee
+2oi0
+3lpl
+4tk3
+6eux
+2ojj
+3pyy
+3jy0
+3r5t
+3qo9
+4u2w
+5nme
+4mre
+1jtq
+4ryg
+3c14
+5kzi
+6bix
+5ldm
+1o2v
+4llx
+3lw0
+2op9
+4nhc
+5wi1
+4e20
+5uit
+6fjf
+2x2m
+5l98
+3qsd
+5lcj
+1adl
+2wa8
+4q9y
+2rkg
+3f70
+2xk6
+3juk
+5uf0
+3l1s
+6evr
+1lag
+1awi
+1pmx
+4kln
+5g61
+3wgg
+4o9v
+5n69
+3kqc
+1him
+3cd0
+2kbs
+2vgc
+1moq
+2f10
+2zb0
+2d41
+4bdh
+1ebz
+5lcf
+5u13
+4qwk
+4cd8
+1tvr
+3pd4
+1hq5
+5tiu
+1o44
+4btk
+2cli
+6cb5
+4lp6
+5afk
+2o3p
+1zpc
+3d1z
+2z3h
+1hms
+5t78
+5hg5
+3mxe
+4i7l
+5lmk
+3nu9
+5om9
+2qi3
+2nv7
+2wkt
+1aq1
+3ddq
+1vyj
+5ods
+1b8n
+4xhl
+4jft
+3n7o
+5j9z
+5ufr
+4qjm
+4uvx
+2yb9
+3qaa
+5mwo
+2onz
+2hiw
+2agv
+4qgg
+5x28
+1o4a
+3t5u
+4klv
+3lgl
+2wey
+1qk3
+1rti
+3clp
+4f8h
+4qwj
+1bmb
+5a5z
+2yiu
+2z5t
+3mna
+4xh2
+2p95
+3t09
+1fmb
+3s72
+5ia5
+4kp6
+1aqc
+4xtt
+1s9t
+2fhy
+4del
+3ao5
+4xii
+5cp9
+3vb4
+5el2
+2uup
+4z0d
+4jv6
+3e8u
+3ubd
+1tys
+4p10
+5ekj
+4bpi
+3n23
+3amb
+4gue
+4n8q
+1a9q
+2vtq
+1h1d
+5uw5
+4ty9
+6bfp
+2yiv
+3tfu
+5xyz
+2q1l
+4m7j
+3m8u
+5kbf
+3btl
+4ctj
+2ajb
+3unz
+2xgs
+5g1c
+5w19
+5vqw
+5yc8
+1w83
+6buv
+4zh2
+4amw
+3dnd
+1nzv
+6bbx
+5lgp
+6ay3
+1fwv
+3mg4
+2z4o
+3qmk
+4dma
+2r3c
+1d6s
+6do3
+1tg5
+5n7v
+1g5f
+1c5q
+1lb6
+4pv7
+3ii5
+4rab
+2w10
+5i86
+1uho
+5vsf
+3g08
+2zxg
+3hb4
+5j4y
+5lgt
+6boy
+5wa8
+2xdw
+2i0e
+4n7j
+3ptg
+4yp1
+5vp9
+3r02
+4mw2
+3djf
+5t1a
+5hrw
+5e2o
+4xuc
+3q32
+6c4g
+2csn
+4q9m
+3vry
+3fv7
+5lhh
+3fh5
+2qry
+4f9g
+4c8r
+4m6p
+4riu
+3dp3
+2r3i
+6ew3
+4bs5
+4g3e
+2wvz
+3wc5
+3exf
+4nb6
+5xmr
+4ps5
+4dvi
+3uvm
+2xix
+4c6z
+5alw
+3iaw
+2xnp
+6ccu
+6dvo
+1cgl
+4xv3
+5dya
+3c79
+2e9a
+6dil
+4caf
+5fov
+5n3w
+5ttv
+6f3b
+5cas
+3dz2
+1xhy
+5th4
+2wxn
+4q3t
+4yff
+3bti
+5vll
+4hy4
+6g3y
+4ykn
+5wg7
+1bwb
+3fnu
+2gvf
+6g84
+6ap6
+6hpg
+5if4
+5wgp
+3d6q
+2wer
+4cfl
+3uib
+6fgf
+5tx3
+3plu
+1zzl
+6db4
+5tpg
+3k8o
+2fxv
+3c2u
+1w8l
+1hiy
+1di8
+4cu1
+5gvl
+5nvx
+1bt6
+6d9x
+1vjb
+6b31
+2qo1
+3daz
+5c4t
+1v0l
+2qtb
+5ewy
+4i9u
+4afj
+5hzn
+4eqc
+3p8h
+5y53
+2za5
+1kat
+4kwo
+3k39
+4hys
+4lww
+3rdq
+4ega
+5fsl
+3ehw
+5gnk
+5n8b
+6h29
+1dy4
+3nu6
+5dxu
+5jf8
+2qd9
+5zaj
+2xkf
+1ywi
+5uiq
+1xr8
+4yvz
+2y82
+1pkx
+2qbw
+1ebg
+3a4p
+3ful
+5qb2
+6bgx
+1ela
+5j59
+2q63
+6cmj
+5nwk
+3w54
+4rrg
+2l1r
+2wva
+2vpn
+1qji
+4gts
+6gnw
+4afg
+5ty9
+4q18
+4ps7
+1o2p
+3qak
+1kak
+4u5o
+3h06
+2b4m
+4q99
+4dgb
+4hw2
+5uvc
+1yxd
+4cix
+4ehm
+5his
+2ihq
+4kmd
+5cin
+5v7i
+3itz
+3brn
+1h4w
+2ilp
+5th2
+1me3
+5fh7
+1rgk
+3iub
+1njt
+1ya4
+2x6i
+4yl0
+1at6
+3pr0
+4uzh
+3eyd
+4j93
+4dwg
+5ti2
+4pcs
+3qcj
+4qjo
+4qer
+2kp8
+4o2p
+4pd6
+2op3
+6got
+2weq
+5l97
+6bed
+4ezt
+5y8w
+4rj7
+2yol
+5t68
+2ltx
+5g17
+1mxl
+4c7t
+3uvu
+5a3r
+4yuz
+4j0r
+3nf9
+2fix
+3pgu
+4kn1
+3mi3
+5dpw
+3e5a
+2m3o
+1y1z
+5j8i
+4e5d
+3cd8
+2b53
+4x9r
+3rtx
+2zmj
+1xp6
+6cks
+3fw3
+4znx
+1q1g
+5o5m
+4w4v
+2w1d
+5d1j
+3ipq
+2ydj
+1mxo
+3gv6
+5l9h
+3odk
+6cze
+6c98
+2izl
+2wmx
+3qa2
+6gnm
+3q6z
+2oqv
+6g9u
+5exn
+3s53
+5lzg
+3mo5
+4x1q
+3ow3
+4a4c
+6ema
+2h6q
+2fjm
+5uez
+6ep9
+2q80
+4nj3
+4mdr
+5dri
+1v2r
+2vtr
+1hk4
+5xfj
+4z0q
+4heg
+5h3q
+4l7d
+3nb5
+3oay
+4aj4
+2w9h
+2iws
+3oy1
+2x6d
+3qpo
+2hog
+3rl8
+5ia4
+1x70
+3q5u
+2i0a
+2pcp
+5m77
+4a50
+1elb
+2ydm
+1rri
+4k9g
+2ptz
+3uo6
+2qwd
+5fdz
+6fiv
+5ehg
+1hqh
+5anv
+5k5e
+5aer
+2zu3
+6cw4
+5lwn
+1i9o
+1npv
+4piq
+2w0j
+6c5f
+1w8m
+5gjd
+5yql
+3ns9
+3zn1
+4eg7
+3u4r
+6hu0
+4c37
+4l6q
+3d9k
+5ucj
+3piz
+3ekt
+3m2w
+1mv0
+6emh
+1ttv
+5u12
+1w1p
+2i4t
+4z68
+1rhq
+3oxc
+3adt
+3r8u
+1udt
+1o36
+4ou3
+6apz
+5gmp
+2l84
+3o64
+3uo9
+6f6r
+3hy7
+3cwj
+3ans
+1mdl
+2fsv
+3p79
+4q9z
+6f55
+1gu1
+5y6k
+3ert
+3ant
+1azm
+5a3h
+3zdv
+3o1d
+6ar4
+2ym4
+3s3v
+3fk1
+3pbb
+3r6c
+1xh8
+5lh4
+2psu
+5gty
+2qi0
+2nn7
+5vb6
+4b8o
+1zp8
+5uqv
+4pci
+5f5z
+4rj4
+6dh4
+4ea2
+4y6m
+5d3p
+1gsf
+4l7l
+1tkt
+3a29
+2qci
+5ljj
+4gpk
+3qkv
+3ern
+3zhf
+1f4y
+6bgg
+5uz0
+2znt
+5du4
+1utn
+5ayy
+1lzo
+1gym
+5k8s
+3kb3
+3ijy
+5wio
+1yei
+4hlh
+2eg8
+5tkd
+1kpm
+3uyt
+3o9l
+3tcy
+4qxr
+5ejv
+6ekn
+2fky
+5vp0
+4rxa
+2xpa
+1kav
+5vlh
+4lko
+4m5r
+3fhe
+5sz0
+3u78
+3zt3
+4hkn
+4h58
+4f1l
+2jkh
+5w13
+3r88
+1yvz
+4qmq
+5aag
+1b6m
+4i47
+4ca6
+4ysl
+4gbz
+1aj7
+1wcq
+3m96
+6awo
+5t92
+6gjl
+4yxo
+5l2m
+4wov
+3l2y
+5v5y
+3a3y
+2gmx
+2fo4
+2h5j
+2r05
+1v11
+5npf
+1gt5
+4jfd
+4l53
+2qhr
+2sfp
+3rx5
+4e4l
+4mao
+3jzj
+5h9q
+5one
+3lp2
+2i4j
+5eta
+4yth
+3gsg
+2of4
+5inh
+3ed0
+5llp
+6esj
+5c8m
+3dkf
+4z6h
+4x6o
+2j47
+1usk
+3p55
+5w8j
+4x1p
+1xb7
+1lqe
+4apr
+5khm
+2ga2
+2ly0
+4zro
+4e26
+4uvw
+1f5l
+4ipn
+4hwt
+4g90
+1kds
+4bck
+5k6s
+5eqp
+1vwn
+4uye
+4gtq
+6fe1
+6gjj
+2ynn
+3hb8
+2zdm
+2vu3
+5alz
+3eyg
+4os2
+1j4q
+4o36
+6faf
+1mx1
+3lfn
+2i1r
+3hzy
+1a4k
+4zl4
+1dub
+3i90
+3qgy
+6gfy
+1o2u
+4xyn
+3rk7
+6atv
+2wu7
+4tnw
+2uwo
+3my1
+5w0l
+4dli
+4tw8
+6b8u
+5jg1
+2azm
+4qw3
+5ntk
+5jq8
+3gcq
+2zcs
+2bcd
+1ph0
+3nu5
+1t08
+4m7b
+4ge5
+4w9s
+5fat
+5l2w
+5nx2
+2gst
+5myn
+2xoi
+4r7m
+1kf6
+2on3
+5wa9
+5tw3
+1q4k
+6fu4
+5t97
+4ezy
+4pyx
+1fao
+1n46
+2ooh
+1q72
+3mag
+6euv
+4g5f
+4dgm
+3ken
+4d2r
+5fnq
+4z7f
+2o3z
+4xgz
+4i2z
+6g15
+5ypp
+2x09
+5lt6
+4tln
+4mrw
+3c10
+3sdi
+4tw6
+3pa4
+3q4k
+5l3a
+3b9g
+4ohp
+4rqi
+5vfj
+4x7k
+2q8s
+5oh4
+6ffs
+4loq
+4prb
+5vwk
+2yhw
+5eob
+5dgj
+2i4d
+5wlo
+5aln
+3p5l
+4q1y
+6c4u
+4l0s
+1gi7
+2jkt
+4yv1
+3ctj
+4wmy
+5c84
+3ie3
+5mnn
+3l8v
+1o2n
+4nmv
+5ok6
+4yab
+2vnf
+3r0w
+2uyq
+5j19
+3nth
+5ni0
+4uda
+4tpk
+1vyq
+4txs
+2wgs
+5gv2
+1b3g
+3kad
+6hgz
+3dng
+4u7q
+2c5x
+3m37
+2aqu
+5ho6
+5j5t
+1ke6
+5g5f
+3wff
+3m36
+4bb4
+3ai8
+2p16
+5u14
+4xe1
+4av5
+3bgc
+5i4v
+3g0d
+2aei
+4hup
+4yv9
+4uwf
+2ovy
+2oo8
+4dlj
+5qan
+4nwc
+4msc
+4iti
+6i8l
+2yof
+3qti
+5nf6
+5n7x
+3t0t
+3oyw
+4ab9
+1mfg
+3aw0
+3oyq
+2x2l
+2lkk
+3s3i
+6c28
+2ofv
+1b58
+4cpt
+4em7
+1t5a
+4xyf
+4j73
+2isw
+4xh6
+1j15
+3b7j
+3eqs
+3tkz
+3qw5
+6df4
+2jjb
+5auy
+2v5x
+2rcu
+5mqy
+2aoe
+1kl5
+4zsg
+3e0p
+3su6
+5tz3
+4hco
+3i6c
+2h4n
+2ow1
+4nue
+4hod
+3oik
+4jsz
+2viv
+4gih
+4wk1
+1b9s
+5i40
+4zb6
+5fns
+5hg9
+1h37
+1uj0
+3e9i
+4igt
+3i5z
+1v2v
+3lpt
+3k4d
+3nhi
+1cbr
+5uis
+5nk3
+3okv
+3krr
+3zyf
+3ivg
+5d3n
+4rs0
+5oxn
+1owd
+1w7h
+5o4s
+3hrf
+2r3h
+1yp9
+5oyd
+4uvb
+1b9j
+2bgd
+6giu
+5eek
+3tnh
+3bxs
+2ay1
+5cap
+3mkf
+5a3n
+4zx6
+6b5r
+1fbm
+5wou
+3g76
+2rkf
+5lav
+2rkn
+3jzo
+3kr5
+2vo4
+4lzr
+4wbg
+1vyz
+3ebi
+2qbx
+3gbb
+3vnt
+3erd
+1o34
+1lbk
+6czi
+4d1c
+1k1p
+2bmv
+1jlr
+5hx6
+2igw
+4o0r
+2isv
+3kr8
+4k3m
+5xiw
+2z5s
+5a3s
+4u03
+3w5e
+1zz3
+4rx9
+4ty7
+6g4z
+4j3e
+1s3k
+6ajh
+2wei
+5v5o
+4nbl
+3qqk
+4rxd
+1cp6
+1r5h
+4nnw
+16pk
+4cga
+3kb7
+4phw
+3zpq
+4b3c
+1wv7
+5hja
+3jzk
+1hsh
+6aro
+3vyf
+2v7d
+5eeq
+5mos
+1hyv
+3ska
+4bg1
+4lgg
+4anw
+6gr7
+2x7s
+1p05
+4zbi
+5c6v
+3qzv
+5etq
+1nhw
+2xx4
+1uys
+3zsq
+4h75
+3veh
+4d0w
+4pml
+3gyn
+5usq
+4e3b
+2hwi
+3kl8
+2vr4
+3o0e
+3dab
+4ynb
+1kr3
+4w9d
+4msl
+5k8v
+5zaf
+6cve
+4h85
+3d5m
+5uox
+4fcm
+2zz1
+4i1r
+5hkm
+5he2
+3n3g
+3g5v
+3k3j
+1utr
+3ixg
+4u44
+4ahs
+1o2y
+3fcf
+3bgm
+4yhq
+2nxd
+4k19
+5mkx
+3v3m
+4ph4
+1nja
+5i23
+5n17
+4bt5
+2ojg
+5x72
+6eq7
+3ehx
+1a5v
+5c4u
+3qcs
+5cy9
+3bgp
+3nf7
+4dmn
+2dxs
+4msk
+4gto
+2wmu
+4hws
+5c2a
+3cj5
+3lco
+4x3u
+5c7a
+1pa9
+3oe0
+3m67
+1j7z
+4kql
+5l8y
+4prj
+5cks
+4cc5
+3jzc
+2qzx
+4u73
+2an5
+1dzj
+6b97
+5y6d
+1qvu
+4ymx
+1yej
+6f3d
+5tg7
+2w1i
+1vyw
+3sw9
+4qz3
+8a3h
+3o3j
+5gn9
+4b7j
+2i4u
+3m8q
+1swi
+3pz1
+3q4c
+2jo9
+4bzo
+2x7c
+5duc
+3pty
+5f3i
+4q9o
+3e1r
+4j78
+4ucv
+6h38
+3wtk
+4lno
+2h65
+3odi
+3s4q
+3lp0
+4ajo
+5maj
+6hpw
+5fsb
+4f6u
+5h0g
+2zdk
+6hoy
+6bib
+3rpv
+1kel
+4v24
+4j4v
+3kai
+2v59
+5cs5
+5jqb
+6as8
+5dw2
+1mq1
+4gw1
+4gj9
+6e2n
+4qlu
+5jog
+4iu1
+3tyq
+6bg5
+3r2b
+5alr
+5c4s
+3pa8
+2qq7
+1qwu
+4qn9
+1yye
+1oir
+6ert
+5jn8
+3d7z
+6dq8
+4lsj
+2wxm
+3pj2
+1v1m
+3nwb
+4hwo
+3afk
+6acb
+6g85
+1kna
+4pvx
+5hex
+3jqa
+5xms
+4an2
+3rdh
+2r3y
+6few
+4cd4
+6anl
+1yyy
+3r16
+4al4
+2ovv
+4ya8
+3bgq
+1qpe
+5lpr
+5fap
+5cei
+3v5q
+4jx9
+4xqa
+3ghe
+3fci
+1zfp
+2l12
+4lil
+6eq2
+4l0i
+4zsl
+5yu9
+1p04
+1rnt
+2chm
+1nhx
+3ckb
+2vot
+5n1p
+5ztn
+4j82
+3hxb
+3qvu
+1hk5
+3atl
+3jzi
+4ad3
+4b6r
+3g8o
+4kc2
+7upj
+6do5
+5wfj
+2j4a
+5oy3
+4o55
+2qi5
+4jfs
+2y68
+3fv2
+5v3r
+3ioc
+5jyp
+4mm8
+4jjm
+5ccl
+5umy
+4n7e
+4f64
+3p9h
+4hz5
+4kin
+6cqf
+3feg
+3aaq
+3sl1
+4oee
+4i7d
+5ll5
+3s9y
+2p3b
+2x8i
+4ui3
+5ji6
+4lts
+5nkb
+1km3
+2qnx
+3myg
+4nms
+5ar7
+2h3e
+4lp0
+2ay9
+5trs
+6cdg
+6ful
+4x8n
+4w4x
+2vte
+5m29
+4ocx
+3sov
+4fxp
+3ex2
+4wpn
+5nwh
+1vik
+4uj9
+5tg4
+5hrx
+3wz6
+1mm7
+5v37
+5eol
+5n21
+3vhe
+3cj3
+4w9q
+4z93
+3jqb
+5f3c
+5ll9
+4zts
+5aei
+1o9d
+2iw9
+5b5g
+2qta
+1g54
+1ez9
+4c6x
+2g24
+1m9n
+5f60
+1rt9
+5jq5
+3ha6
+2yj9
+4nra
+3el8
+6afi
+4kni
+5v79
+4fxf
+4jog
+4x3s
+1dif
+4aa7
+4d1b
+5av0
+2clm
+4l10
+2ltv
+3rwh
+5yfs
+5xkm
+5mjb
+2i03
+2v0z
+3i3b
+1h1b
+6esa
+4ai8
+5ak3
+3wto
+1jjt
+1jdj
+2chw
+3ll8
+5j79
+5adq
+4r74
+5n53
+3ljg
+2lsr
+3rk9
+1add
+5ja0
+5x02
+5d12
+1o6q
+5f20
+4lgh
+5etr
+3mj5
+4km2
+1hmr
+3are
+5u9i
+1lv8
+5n99
+4gly
+1sh9
+4uns
+4cpu
+2rkd
+4psq
+3az9
+5wcm
+5vsc
+4nl1
+4um9
+4wa9
+2obj
+4zw3
+6htz
+3n2p
+2vwy
+4ge2
+5d7e
+4wx4
+3sgv
+5w12
+4gmc
+4dij
+1r5g
+4r3w
+5hn8
+4fk6
+5ggl
+2ks9
+1tq4
+1my8
+6mv3
+3kqs
+3gz9
+1uv5
+2bok
+1b42
+5mlw
+4qr5
+1r6n
+4pio
+3mp1
+4pz8
+5yfz
+5zwh
+4kb9
+2wmw
+1nax
+1o4n
+2znu
+5gvp
+3ma3
+3k15
+1gt1
+2jew
+5qae
+1v48
+1m5d
+2v2c
+2ql5
+3h0y
+3wpn
+3pdc
+2qa8
+1rs4
+5tgy
+2b7d
+2w8j
+3tdz
+2wxj
+5g2b
+3gwv
+1kne
+3kqe
+5khg
+4uiu
+4kyh
+1a4m
+4byi
+5ngz
+6fam
+5lgq
+2hb3
+2pnx
+4qmw
+1lzq
+3aid
+3psb
+5w6r
+4c4e
+4jxw
+5ngr
+1utz
+3r7o
+3umq
+1abt
+1tkc
+3mbp
+3i9g
+1rwq
+4iz0
+6dh2
+4rx7
+2cn8
+3bar
+1cny
+2bys
+4y6p
+4y6s
+2uxx
+5cs2
+4mgv
+2wxf
+6fyk
+1x8s
+5b25
+4tk5
+5nhp
+4lov
+1kui
+3art
+4d2v
+1bnv
+4kov
+6cyc
+2j4z
+2p3c
+1f0s
+3dy6
+3mww
+1hvk
+1x76
+2aez
+3k48
+2krd
+4bbg
+5otc
+3kqp
+4esi
+2rku
+2kpl
+1erb
+2xx5
+2fl2
+4a4v
+1lqd
+1lfo
+3hf6
+3bm8
+1a99
+3zly
+6cwn
+3d8y
+5icz
+1hgi
+4qgf
+3tn8
+6f3g
+1n3i
+3tz2
+1xws
+5uov
+2o9j
+3coh
+3h98
+1mes
+3ot3
+6f1x
+5gs9
+5fyx
+2hha
+1pfy
+4j3j
+4rn1
+4ze6
+3zpt
+4f9y
+4lbu
+2nno
+5v42
+2fyv
+4j8m
+6hjk
+3o9d
+1izh
+2r2b
+2xc0
+5uv5
+4ty8
+2vew
+3br9
+1utt
+6cd8
+3l8x
+4fe6
+5adt
+4f49
+5nzq
+6htt
+5k0t
+3pn1
+4ryc
+4nga
+4crc
+4xcu
+3f3c
+3obx
+6agg
+6cq5
+4nzn
+6hm2
+3w2r
+3dsu
+3zs0
+4wkv
+3w07
+1ntk
+4dk8
+4anv
+4ery
+4a4l
+4jzd
+3tjh
+4jwk
+4hyi
+4kne
+3u9q
+5ih2
+2h02
+1i8z
+4c6u
+5ohj
+4bid
+3lmp
+4j81
+5dey
+5k8n
+1pz5
+1shd
+3hhm
+5n0f
+3nba
+4u5s
+2ndo
+3vid
+1ik4
+1al7
+1fq7
+2x4r
+4kz3
+3s8l
+2xh5
+2aoc
+2p93
+5huy
+1agm
+1fv9
+4c72
+1vfn
+4xg3
+5vk0
+3hl5
+2xah
+5n58
+3mof
+3r22
+1utm
+3p8e
+1kl3
+5o5h
+5lpk
+3miy
+2vta
+1bnq
+4myh
+5llm
+4xsx
+1q6s
+1jws
+5xmp
+4ahv
+4e4n
+4o75
+3ogp
+3dk1
+4bdf
+2ybs
+2aj8
+4ght
+1e5j
+4odq
+1veb
+4wrq
+5nsp
+2wtx
+2rqu
+5kpl
+3g19
+3gy7
+4bhi
+3rjm
+3f3v
+4h42
+4y16
+1o3g
+1utc
+3wzu
+6b5q
+1u2r
+4ygf
+1nju
+3drp
+6azk
+3r9d
+4awi
+1ce5
+5vd2
+5kzq
+2bal
+1y2f
+2xxt
+5hlp
+2y8c
+5auu
+1bwa
+6gbe
+2zv2
+3f7b
+1e4h
+6arn
+3ryw
+6fr0
+5wbz
+1c8v
+1v41
+4oew
+5fbo
+3l9h
+5hi7
+3igg
+4hy0
+5enf
+2a4q
+1cwc
+5yjo
+2jc0
+186l
+6epy
+3qk0
+6cq4
+2jkq
+3gb2
+5xmt
+2ybu
+3arz
+2o5k
+5c13
+4gfm
+2fm2
+4jsa
+4pv0
+1hnn
+3bl2
+5dhp
+6c7i
+1inq
+5pzn
+1pye
+3upf
+3zcl
+2uyi
+1usi
+3dc3
+1ezq
+4qz0
+2vnt
+5ehy
+1mqj
+5gs4
+5xg4
+3h59
+1bv7
+1br6
+1mns
+2ybk
+1bcj
+1e02
+1ykr
+5vja
+3r5j
+5edu
+3kga
+6b5t
+5qaq
+1jpl
+5hmi
+3mjl
+4n8e
+1hrn
+2o4s
+1agw
+4wn1
+3tc5
+2pjb
+6ea1
+5epy
+3vc4
+2i0g
+3ah8
+6bau
+4drn
+1aw1
+5fl1
+4prg
+4ibe
+2yem
+3fql
+5zwf
+1x0n
+6ehh
+1cps
+5akl
+3g2t
+3vsx
+4dhl
+1hsg
+3vhv
+3ro4
+5myl
+4lyw
+3e92
+4o91
+3ipa
+1imx
+1u71
+5dx3
+4hvi
+4urn
+1h5v
+3p7b
+2rg5
+4i8x
+4bcn
+4d09
+5f8y
+5mwp
+3n76
+3gba
+4lyn
+6bik
+1unl
+3e6v
+3rsr
+1nlp
+5dxg
+2cji
+5zwi
+3o9a
+4ju4
+2x2k
+4n5d
+5l4f
+5nya
+5yqo
+4gzt
+3tki
+5dd0
+5ivt
+5mnr
+3asl
+2oc0
+3l3n
+5izf
+1i6v
+2y56
+2h4k
+1drj
+4yy6
+3hku
+3kfn
+1w5v
+2c3k
+5oha
+4myq
+3new
+1o5c
+4k5y
+5kbi
+5dhs
+1y19
+3hky
+5nka
+1wax
+6h9b
+4b6c
+1h3h
+5xw6
+4cra
+3d4l
+2nwn
+2zyb
+3rm9
+4bbe
+6gxa
+5h4j
+4ljh
+4a4f
+4nw5
+2vi5
+3eqy
+4tpp
+1pi5
+4bt3
+5oh2
+3kiv
+4xyc
+1zd2
+2vur
+5znr
+2k2r
+5j1x
+3pfp
+6g37
+3nsq
+6eq8
+5jrq
+5eci
+1nmk
+5ehr
+4qz1
+5zkb
+4f65
+5sym
+5ct2
+3wti
+4nwk
+5l8t
+5k0f
+1mqh
+1h3b
+1wxz
+3tt4
+5k0x
+2ez7
+5wbp
+4ddl
+2ygu
+3e7a
+5m7s
+2odd
+4eon
+3vf9
+1pxm
+4umt
+4rlt
+4f8j
+5dp9
+1ung
+4x7h
+3max
+4btu
+4hyb
+3nyx
+3nif
+5hmk
+3tz4
+3qxm
+6isd
+6g97
+5ccm
+5u0z
+2wbd
+3aav
+5vzu
+2hai
+6evn
+2yga
+1p17
+5fus
+5elw
+4azt
+6ea2
+1xbo
+2yhy
+4u0m
+6b3e
+5hff
+3iu8
+1dqx
+4o0v
+4gs6
+6gn1
+2j87
+4hy1
+5nmg
+2pgz
+1wdq
+4er1
+2l6j
+3itu
+5a7j
+3su4
+3r6g
+5ea7
+5qb1
+3grj
+4xjs
+2x85
+3le6
+5t19
+5ett
+2esm
+3u7s
+3c6w
+2clo
+3d0e
+2jqi
+1ekb
+4ovz
+3soq
+3rbm
+1hef
+5os0
+4tk2
+4j22
+4etz
+3gus
+3s76
+4pyv
+3c49
+2yz3
+1xnx
+1elc
+5i24
+5t9z
+5h1e
+2qt5
+5ekh
+3fbr
+2za0
+5wej
+2yel
+4anx
+1rtf
+1r5y
+1pzo
+5kam
+5i13
+3krj
+5exw
+1aj6
+3qs1
+2x9f
+2np8
+5ci7
+1m7y
+1fcx
+5ok3
+1hp0
+4jq8
+4bhn
+1i9p
+4hyh
+1jil
+5f2s
+1bwn
+1xh7
+1pmv
+5kbg
+4bg6
+4ycu
+3lxk
+4w57
+4kxl
+5mk9
+6er4
+6h1u
+3iae
+3fnm
+3mxr
+3c2o
+5eva
+4kbi
+3ogx
+5n0e
+5owa
+6bmr
+4mgb
+5ka9
+2bza
+3sad
+4wj5
+4o1d
+4pnc
+4mzf
+1f9e
+4whl
+2imb
+4llk
+4ih6
+3stj
+5tnt
+4hg7
+5dxe
+1hc9
+3dcc
+5azf
+5c5h
+4m7x
+5nve
+4dcy
+1r9l
+3l0k
+4iuv
+5j31
+5ulg
+2jxr
+4qwx
+4joe
+3sm1
+4prd
+5etn
+1ihy
+3ut5
+4gjc
+5c1x
+2oxy
+5can
+5hz9
+4oem
+3nzi
+4hfz
+4mn3
+1svh
+4zsa
+5y24
+5f9b
+4mka
+5wf7
+4o0y
+5w8h
+1t1s
+5w7i
+4o2e
+4e3j
+4jmu
+3dg8
+1fq4
+5u7o
+5owt
+5myr
+5ka3
+1orw
+1vea
+1j01
+2hkf
+2fv9
+1e55
+3cfs
+5nhy
+4x6s
+4q1w
+4o5b
+1b32
+2fzk
+2p3g
+1h24
+3qfd
+4xu0
+5ow1
+3du8
+4cby
+1mtr
+4uj1
+4omj
+2y58
+1onz
+3esj
+1zyj
+1fig
+3cd7
+2hf8
+1o4f
+5w0q
+1ql7
+3kv2
+3que
+2loz
+4zg6
+5f4l
+4mo4
+3mam
+2h44
+5cwa
+5hyr
+3wix
+5tw5
+4dem
+5di1
+6en5
+4ogv
+2r6y
+6c7w
+3dx4
+5qa7
+1os0
+4tn4
+5vm6
+4x5r
+3k23
+2q54
+2pe1
+4k2y
+4rfc
+6hqy
+4ie3
+2qbq
+5o07
+4mm7
+3rqg
+1a85
+5etb
+4bty
+1nvs
+2c9t
+2h6b
+4ivc
+5ar4
+1xfv
+6g6z
+4e1n
+2q2y
+2zwz
+2xe4
+3nin
+4py1
+4j52
+4mrf
+1ngw
+1m7q
+5c7b
+3lq4
+4m8t
+4qhp
+1my3
+5fgk
+2ff2
+5qat
+3chf
+4kox
+5v1b
+1det
+4cq0
+2iwx
+4isi
+4bcg
+1pro
+4mm6
+4m5m
+3v31
+4yt7
+3vp4
+3imy
+1rbo
+1u6q
+2w7y
+1k9q
+4erq
+5tzh
+2a3x
+5f61
+3el1
+5lkr
+1mn9
+4oym
+2iko
+1h39
+5nu1
+1qxz
+4qz4
+1o5p
+4i9c
+3wmc
+4xxh
+4ajl
+4zud
+3kig
+3wde
+6fdu
+4bw2
+1hk1
+1pph
+3wut
+2ate
+3nw9
+5ceo
+1g2m
+1o3i
+5ald
+2hjb
+5za1
+4pnw
+4uwl
+5c1w
+1m0n
+2nsj
+4imz
+4x3k
+4zgk
+3pvu
+2fah
+6ex0
+6gz9
+1ke8
+3tkw
+3m40
+4bo9
+4cqf
+5sy2
+3fh7
+5u4f
+5or9
+1msn
+5ow8
+5ekx
+1dar
+6iil
+3tsk
+3tzm
+3ttz
+4ibd
+4zx5
+2c4w
+1qf4
+2xgo
+3bm6
+3h8b
+4zy1
+4okg
+3btc
+4ivd
+1o4i
+3wtm
+6mxe
+5ygf
+4mpe
+1o2q
+4qtb
+3qw6
+4yb5
+1b5i
+1dbb
+4gj3
+5y5n
+5jdi
+1kv5
+4der
+2xc4
+3s3r
+5lso
+1n2v
+4jje
+5akw
+5f3z
+6dl9
+5wgd
+3muk
+3uw9
+1o32
+2zpk
+3hk1
+2f1a
+2haw
+4i54
+5d3s
+5m56
+2bkz
+5dxt
+1qw7
+4abu
+5x33
+5fjw
+4k5p
+5als
+5eqy
+4de0
+2a4g
+3hf8
+5em9
+4gr8
+4ztl
+2g1q
+4phv
+5tdb
+6dh7
+3rz3
+2vww
+5t4b
+5j7g
+1f4f
+5mev
+5cgd
+3vrw
+2o48
+4cgj
+4cbt
+5ofw
+3q2m
+4ce2
+2qqs
+4yw7
+1p93
+5wip
+6afl
+6b16
+2cgu
+4o24
+1z34
+3fvg
+1w6j
+3py0
+5nkc
+1os5
+3t70
+2nwl
+6dq4
+2brp
+5z95
+1tx7
+4yc8
+1hvr
+4e5w
+4f1s
+1xzx
+3fty
+6au9
+4eu0
+6fdt
+4d1a
+5ap7
+1sqb
+3wt5
+3eqb
+4o3c
+1rgl
+5cxh
+3r7q
+1jvu
+2ay8
+5ak5
+6dug
+3wgw
+6bfn
+2fx8
+4rxc
+6bny
+6h36
+5ugm
+5trj
+5xpo
+1jmf
+3wp1
+3ugc
+4jhz
+3p44
+1zp5
+1v2o
+5tbe
+1o2r
+4wsk
+5vdk
+3rni
+3kc3
+4pb2
+5euk
+5ukk
+2k2g
+4a4q
+4gtv
+5u0g
+4zh4
+3v2p
+3kqt
+4im0
+1ni1
+3wp0
+4tkn
+6bg3
+1o1s
+5d3l
+2qc6
+5lp6
+2br6
+5ku6
+5d3c
+5ny3
+5hjb
+4txc
+3waw
+5b1s
+3nu4
+2pwc
+4x3i
+3djk
+3qw7
+3ivx
+6b8j
+1y0x
+1ros
+4rwj
+6bto
+3ztc
+1jlx
+3l0v
+4ycn
+5qam
+4mep
+1bil
+5tzc
+4u6r
+4g2r
+4pg9
+2hzn
+3r8v
+1fzm
+5d9k
+4gg7
+3d9n
+6cct
+5f27
+2w6n
+3k8d
+4b9z
+4uiy
+5fl4
+2bbb
+1qon
+1ydk
+4jv8
+2bw7
+1li2
+4qag
+3hyg
+2qtr
+2cen
+4k3n
+5cxa
+1dzp
+3gcu
+4nbn
+4ctk
+1okx
+5fb1
+4r5v
+4det
+2xm2
+3exe
+1jje
+4wup
+3sjt
+6h8s
+5tqf
+3h1x
+4ps1
+3c72
+2dua
+4w97
+5diu
+2cbs
+4zy4
+4alx
+2gbg
+1y6b
+1tnj
+2g78
+5aml
+2vo7
+4qye
+4no9
+5ct1
+4elb
+5sz2
+4u0x
+4ztq
+2nnd
+4abj
+3uh4
+1pop
+3hv5
+3zll
+4rak
+5u7m
+5tuo
+5ur1
+4iqu
+3kac
+1t7r
+4um1
+5mwa
+4o77
+4r5t
+4ijq
+5ld8
+3hdz
+4bxn
+3vb5
+3rx7
+2qnp
+1k9s
+6cjy
+4zjj
+1bbz
+4rx5
+4nzm
+1m5c
+4djs
+5ect
+5ejw
+6f20
+1zea
+2zzu
+3rxp
+2z3z
+1oeb
+1gux
+4g8r
+1hk2
+5dfp
+5vc4
+4g55
+4o7d
+6cdp
+1v16
+5gvn
+3l8s
+4bis
+2baj
+1njj
+5wik
+5a7i
+4pnq
+2a5u
+5nn0
+3q6k
+6eab
+3s68
+1yw7
+4z88
+4x8p
+5vgo
+4yo6
+4lv1
+5ose
+4ogt
+4k76
+2pr9
+1z3j
+2g72
+4gdy
+2l1b
+6g0q
+5tri
+1g7q
+1o4g
+4cg8
+1v2u
+3wyj
+4kfq
+4hrd
+1no6
+5lax
+3f7g
+5tmp
+4deh
+4rad
+3d78
+5l72
+3avj
+4rg0
+5nt4
+2w08
+3lxo
+3ljj
+4kif
+2jdo
+1v0o
+1k3n
+1rgj
+4zt8
+6dub
+1zdp
+187l
+3n6k
+1tnk
+2h2g
+4mjq
+2gni
+4pre
+3bgb
+4ddm
+1mwt
+5nhl
+6b4w
+3sou
+3sm2
+5qik
+1loq
+4wmx
+4yqh
+5mi7
+4ynl
+2f9v
+1qbn
+3uod
+2w0z
+1fsy
+1tmm
+3va4
+2adu
+3ozs
+5g42
+5vo2
+4h3a
+5tzw
+1xkk
+3tdu
+3efj
+3as2
+2ity
+4zwy
+2nmy
+4amy
+5kad
+3p58
+6h1i
+5x13
+4d1d
+6aum
+1ftm
+4hla
+2qoe
+5em5
+3u0p
+3dx2
+4kn2
+2pou
+4ce1
+4b7r
+1rth
+3eq7
+3i0s
+2pgl
+2yj8
+2z6w
+6fs0
+1dhi
+4hdp
+5svz
+4mz5
+1a1c
+4p0n
+3n7s
+2aow
+1j19
+4k3o
+1m7i
+3s9z
+1igb
+4o9s
+5xyx
+4mex
+5jy3
+3hxc
+2c3i
+4itp
+4b12
+3o6m
+2vd4
+3tib
+5yj8
+1aze
+4yad
+3w37
+5e8z
+2p4y
+2xda
+1g6r
+4h5e
+3fuz
+1f2p
+1b51
+5lm6
+4wn0
+3h21
+4bjc
+3nnu
+3d32
+3l9l
+4kqo
+5w38
+2p2i
+4ohk
+5l2i
+4jlh
+4whh
+3u6i
+2khh
+1ogu
+1zeo
+1iq1
+4knb
+3lrh
+5iok
+5t6p
+2ow2
+4dx9
+2a0t
+5g3m
+1c5x
+1qxw
+3d83
+3pwh
+5g46
+1yw2
+4yhm
+1tka
+3qpp
+4g19
+1pdz
+3odl
+5mby
+3zt1
+1y3v
+3tv4
+2phb
+1bzf
+1m2r
+6g46
+3hvj
+3mhl
+4w9c
+3o9e
+4imq
+5k4i
+3abt
+3vuc
+4oyt
+5qb3
+5yv5
+4n1b
+1pip
+5iu8
+3zke
+5f1z
+4zlz
+5ai0
+4op2
+3tfn
+5cnm
+6dge
+1htg
+3rey
+1o6r
+3w5n
+4l52
+4b76
+5qar
+2kaw
+3eyh
+4ezz
+3hkt
+5e1b
+3ufa
+4btx
+5mgj
+5cst
+5ea5
+5kgn
+3jq7
+1qy2
+4fpk
+3hq5
+1at5
+1hge
+5ty1
+4b3d
+1lyb
+5mrd
+4zt4
+4ovg
+4pp7
+4elg
+5j71
+3i6o
+4mx5
+4pnm
+2g0g
+1x81
+4wkp
+4kxm
+1wht
+6q3q
+4gee
+2f70
+2wd1
+6aah
+4rfm
+2wvt
+3dx3
+5t4v
+1owh
+4k7o
+4z7n
+5ehw
+1ohr
+3c4e
+4k3h
+5y8y
+1pu8
+2mg5
+3tfk
+1t31
+4iho
+3i91
+5fdg
+5ntq
+5wa4
+5ene
+6ax4
+4aoi
+1u3r
+4b6f
+3src
+1sw2
+5fwa
+2q7m
+5g6u
+1puq
+3s56
+3ckt
+2jaj
+2qlb
+1l6y
+4tzq
+5u9d
+4nzb
+3ccc
+3isj
+5kbr
+5duw
+3ijh
+1uti
+5tw2
+4wuy
+3u8n
+1pl0
+6flg
+5w6o
+2v2q
+5jf4
+5a8y
+2nq6
+1tsy
+1rek
+2gtk
+4kom
+6en6
+3zmz
+3pb8
+6fap
+4whr
+5j1v
+1ld8
+4o37
+5qa5
+4c9w
+2olb
+4dru
+2h42
+5jnn
+1w0x
+6chh
+3av9
+3uzc
+1l83
+2osm
+5i89
+5wb6
+1b4h
+5e0a
+1nyy
+4bqg
+5axp
+2w1f
+4z1q
+4iax
+4q4q
+2bua
+4alv
+4jfx
+5kjn
+4u0w
+2k0g
+3uwk
+5iq6
+3o0g
+6fgg
+6hjj
+3iu9
+4xg8
+4xya
+1zfk
+3jvk
+5wxh
+3t0w
+5yg3
+1xpz
+4b60
+4j2t
+3ds0
+2l0i
+1pxk
+4da5
+1z6e
+4pry
+8lpr
+6bh5
+4bnz
+5fky
+2o4h
+4x2s
+2vth
+1i43
+1m21
+4xsy
+2pvn
+5htl
+4uwh
+5o7i
+3skh
+5wic
+1fvt
+4rio
+6dnp
+4ufu
+2ork
+5dkr
+3m59
+3btr
+5nps
+4nxs
+3r8i
+1z1h
+4jik
+6cjv
+1ff1
+1uwb
+4lgu
+4x3t
+5dtk
+2giu
+3meu
+3ove
+2zcq
+1qbt
+4n7y
+4e4a
+2ovq
+2avs
+4e3l
+1hbv
+3tl0
+3g15
+6c5t
+4ayu
+4aba
+5mmg
+5k09
+3fj7
+4y3j
+3dxg
+5a6n
+5lvd
+3c2f
+4m3m
+4x6k
+6h7b
+5gow
+2f18
+4kvm
+2qhn
+5y2f
+3fi2
+2y3p
+3vzv
+5h5q
+5gic
+1g6g
+5j47
+4tmr
+4inb
+1w6h
+1inf
+5alk
+3u8l
+5bnj
+5nk4
+5ug8
+6bgv
+3fzc
+5mgf
+4gfn
+2k0x
+4o0a
+4m1d
+2ds1
+3wnt
+2iwu
+2ogy
+6ffi
+6eu6
+3s0e
+3u1y
+3r04
+2nsl
+4knj
+1e1x
+5cs3
+5hfc
+5zob
+3hvi
+4erz
+5ant
+6ft4
+3th0
+1ijr
+4lnw
+4pyq
+2r3t
+5mkr
+2gz7
+3fcl
+1joj
+1j17
+3avf
+3u0t
+1c85
+6d4o
+2qic
+2tmn
+4cc6
+5k5n
+1zpa
+5n55
+3rxj
+3srg
+4bgm
+4m0r
+5nxv
+5j1w
+4bbf
+5czb
+4mot
+1tl7
+1bju
+2pmn
+1k6p
+5akz
+4ca7
+1mfa
+4qqc
+5e2q
+2fxu
+3ejp
+1a1b
+5k0j
+3h5u
+2rg6
+5fe7
+4pgd
+4rr6
+4o70
+5cfa
+2cfd
+2wtw
+3k3g
+4ju3
+2qhm
+2vqt
+5q0d
+3gcv
+4fmn
+5kgx
+2n9e
+3fc1
+1ok7
+4nru
+6fmp
+5fxs
+4dk7
+4e5f
+5ml0
+3v6s
+5cjf
+5e1o
+6bw8
+3h2f
+1yly
+4avs
+1sri
+1avn
+4cfw
+4jg7
+3fu6
+1g7f
+4l1u
+3ocg
+5wal
+4dq2
+1uz8
+4hgc
+2onb
+2lyw
+5xgl
+1ydr
+2r0h
+4q4s
+4riv
+4cp7
+1il4
+2qaf
+1idb
+1hos
+2xnn
+5myv
+5ti4
+3gi5
+2wxh
+4eo6
+3spk
+1g3f
+5iy4
+5op8
+5h1v
+3hig
+2c92
+1n7m
+5dif
+2py4
+1nfx
+4cst
+3h0v
+5z7j
+5ta2
+5nu3
+3k3i
+3zq9
+5cqj
+6axk
+4len
+4nmp
+3ch9
+5djv
+4hxw
+4euc
+1hvy
+2jk9
+3ncz
+3bu1
+4bb2
+3wqh
+6alz
+3qch
+4jv7
+3nan
+1oth
+2aie
+3dln
+3mv5
+5egu
+6dki
+5am0
+3vrt
+6dpt
+1ew9
+2w6u
+2ggu
+5jsj
+3zya
+5uwp
+2exc
+5e28
+2xng
+6esm
+1gi4
+3d2t
+3ekx
+2uwp
+1klg
+4y2x
+2dwx
+5lrq
+1od8
+4ci2
+1nq7
+4m5i
+1o9e
+3ejr
+4wrs
+1g1d
+4eor
+5ofi
+4eb9
+2kce
+5eko
+1ndy
+2nnk
+5ybe
+1svg
+5aes
+5j5x
+1cka
+5ehv
+3n7h
+3pxe
+4kz7
+1tcw
+3v5j
+2xp8
+5ier
+4bv2
+4i6b
+4oyb
+1ox9
+3zvv
+5f90
+1rdj
+4azb
+3o5n
+4uub
+3d1e
+1n5z
+6b1y
+2o7e
+3o9v
+4hf4
+2qi6
+3gss
+1c5c
+5l9l
+3ifp
+4fi9
+1cs4
+4ode
+1mui
+5vp1
+3vbt
+3sh0
+4avw
+1qf1
+3hjo
+1iiq
+2r2w
+3wtj
+4lys
+4lv2
+5ii1
+5d6p
+4nku
+1w1d
+1e37
+4pte
+3c7p
+4glx
+1hvi
+5f4n
+5f6u
+5ggj
+3gx0
+3ztx
+4uiz
+4cl9
+2wnl
+3ipx
+1i72
+3dsz
+3mhi
+4ap7
+2xcg
+3kwa
+7prc
+4e3o
+4int
+1zz1
+5bjt
+2xas
+4ny3
+5fi7
+1owi
+3qd4
+1ew8
+4hdc
+3h52
+5nzp
+1lbf
+1b6p
+5np8
+3qxt
+1ksn
+3twp
+3ti8
+6ewe
+5v82
+3t19
+3eu5
+2flr
+4acm
+1oe7
+2or9
+1v2m
+5fjx
+2c80
+3nm6
+4nak
+5y12
+2vwn
+5chk
+5akg
+5m7u
+6axp
+1upk
+1j36
+1uv6
+3f2a
+1ov3
+1yms
+4o4g
+3tsz
+6ma1
+2hrm
+5k4x
+3hzk
+5w5s
+6gh9
+5l26
+2lsv
+6eqa
+5fp0
+2jk7
+3h03
+4mk1
+1y20
+5yc1
+5lx6
+2er0
+5x4m
+3myq
+3mbl
+4a7i
+5koq
+3cx9
+4zom
+4j0s
+5sz6
+2vqm
+1syh
+1kwr
+6cyb
+2zym
+5fv7
+3shz
+6b5j
+1wn6
+5vd3
+1njc
+5ia3
+4a4e
+4iue
+2ewa
+5ew9
+5n8e
+4kow
+5w6i
+5mgg
+5oh3
+4hmh
+4f3i
+3kd7
+1w9u
+4n6y
+5jid
+1juy
+1f0r
+5iw0
+4ui4
+3tkh
+2gc8
+4f4p
+5qc4
+3wzj
+5l7h
+2kdh
+3sv9
+4b7q
+5a6i
+5om2
+5lgu
+5unh
+5u1q
+5nw1
+1uef
+4ck3
+1g42
+2e9d
+5k4z
+4l7b
+1so2
+6esn
+1ida
+4j3d
+3jzb
+1o2h
+5qby
+1nde
+6dne
+1f8d
+5ult
+4o15
+5alo
+4oar
+4zy0
+4pd7
+2aq7
+2zga
+5luu
+2l8j
+2wky
+4yrg
+2v22
+2ndf
+1jsv
+4u6z
+5wdl
+5nxi
+6i8y
+4yx4
+4u6x
+4mw5
+3ith
+4amx
+1wb0
+3arq
+3dp2
+1lst
+3fqh
+2ivu
+1s5q
+6ct7
+3pma
+2ay6
+5e90
+1re1
+4l32
+4bw4
+1pig
+2xne
+4qme
+5ugh
+1cpi
+3wd9
+1o5m
+5wfc
+4tun
+2y77
+5laq
+1ax2
+4ptg
+3hrb
+5dah
+5iza
+3thb
+4bi1
+2c97
+3arf
+4gwi
+6h1h
+5yzc
+4ec4
+5tg6
+3vap
+2q2a
+2fle
+2vwf
+1g2k
+2zz2
+5xhz
+4zim
+5fwr
+6g9i
+6bqa
+1g45
+4r1v
+3is9
+3wt7
+5vlr
+5fnr
+6cf6
+5t1m
+3uda
+3ur9
+3dp4
+6c7g
+5kmf
+4hev
+1zc9
+6d8e
+4nuf
+5acx
+5ouh
+2fde
+6c0n
+4wt2
+6cgp
+5dyt
+2xcs
+4z1k
+4b11
+2i2c
+5ko5
+3g2u
+6hlx
+1xgj
+6ayt
+5vij
+1ao8
+1c5z
+1b9v
+5toe
+4pox
+1gnn
+5kqg
+5am1
+2x4o
+1i37
+5uln
+3gpo
+2g01
+3fx6
+1ke7
+3my5
+4inr
+1jp5
+5eqe
+4muf
+5xhr
+2wmr
+3ebb
+4mwe
+5ap4
+5nwg
+4x8t
+4oz1
+3hvc
+1flr
+3pz3
+6hlz
+4drp
+4tw9
+5b4k
+4o3t
+4fev
+1o45
+4bcj
+1qkb
+5nho
+2x8d
+1aq7
+5y21
+5i12
+3bsc
+3s75
+4wki
+1ouy
+4jv9
+5o9h
+4ez3
+3dd8
+5h7g
+1sqt
+4enx
+1bap
+6enm
+5za7
+3dbs
+4mvw
+3vrv
+2azc
+3i60
+5hld
+2wxq
+4m8x
+5f6v
+4fhi
+5auv
+4l7c
+3wcl
+3gqo
+5dhh
+5u7d
+6grp
+1xm6
+1lpz
+5cvd
+3zmj
+1g6s
+5eud
+3wyl
+4wh9
+2who
+2nmz
+2xiz
+4hbx
+6bee
+3ryx
+5ans
+5zvw
+4zwz
+3q96
+4v05
+5jf2
+1wbv
+6c7x
+5m6u
+1m0b
+3qg6
+2gz8
+3nyn
+3lhj
+3g86
+1ny0
+3zj8
+3o6l
+2vb8
+3p9l
+4bnx
+5uch
+3sv6
+1gvk
+4ynk
+223l
+5orr
+4o0j
+3rxm
+4po0
+4z84
+4j21
+5yjm
+5n25
+4bky
+5svy
+5gmn
+5u7l
+1f1j
+4aji
+2oj9
+3oli
+4r4o
+4ql1
+1skj
+2wfj
+1wc1
+3hqz
+2r3o
+3m5a
+4lwc
+4j5p
+3n46
+3ttp
+1jjk
+5vb7
+2pj0
+3dog
+2bve
+5vfm
+4l2x
+3uvp
+4wno
+4y38
+2c69
+2zx9
+2alv
+3ip6
+3sio
+4xoe
+3sn8
+5y48
+5u7j
+5f3g
+1xh4
+4j79
+5ghv
+2i2b
+1gah
+3kr1
+5npd
+5mks
+1jwu
+4inh
+1tsl
+2wq5
+2e9u
+1hpo
+6aff
+6e99
+5vlp
+4u5t
+2uxu
+5byi
+4ris
+2hwo
+5e2s
+5q0g
+3lj3
+4qo4
+4bt9
+6b5a
+4mk2
+4idv
+5lj1
+3nal
+6d1m
+5kpm
+5sxn
+5doh
+3m6f
+6bsk
+1gui
+4m4q
+4ow0
+5ur6
+5iu7
+1bma
+5uxn
+1oiu
+4ln7
+2a5s
+6afg
+5e4w
+1oyq
+4xtv
+6eji
+3at1
+4q1a
+1njb
+4u0g
+1tou
+2pj5
+3avk
+6fmj
+2lto
+6czc
+3u8m
+2y5l
+3fjg
+5uwi
+6m9c
+3jxw
+4zqt
+5vc6
+5knx
+3pix
+3e6k
+4f7j
+3koo
+5n3y
+3jdw
+4nmo
+1ody
+5tpc
+6bsm
+2cm8
+5gn7
+4gql
+1yq7
+2gga
+4wy7
+2brn
+2fmb
+5n8t
+3nus
+5x5g
+5yls
+5u3b
+4x14
+4puk
+4nmt
+3uol
+4jzf
+4um3
+5k7h
+5x74
+3ddb
+1xd0
+4mm9
+1ulg
+3coz
+5epl
+3n3l
+4ear
+3vzg
+4qac
+1ai6
+3d8w
+2wtv
+6ge0
+4q3r
+4qb3
+2vip
+3pz2
+3f34
+3rin
+3acx
+5n2t
+5oqw
+3p4w
+2pvl
+1b0f
+4p6x
+3rcj
+5i9z
+5ai6
+3c4f
+1o4o
+1sje
+3alt
+5f41
+5yid
+3bgl
+4rdn
+4hso
+4ttv
+5yvx
+3ok9
+5y0g
+5twx
+1wug
+4a6c
+4lzs
+2zx7
+3gy2
+3jvr
+4as9
+3f1a
+4cd6
+4r06
+5h5s
+5w0i
+4wp7
+5e3g
+2ydt
+4abb
+5ji8
+4olc
+5ieo
+5i2z
+4zy5
+4qga
+3t82
+4dff
+3v4v
+4gw8
+2hxl
+4bkt
+2wj2
+4xwk
+1xk9
+3tv7
+1ajp
+1tps
+3ag9
+3ls4
+5wg3
+1cwb
+3mea
+1bjr
+5auz
+5l6p
+2y67
+2i3i
+5ivj
+4l7n
+5efj
+4jzi
+5vlk
+3rt4
+3zmm
+2wn9
+2a25
+4hmq
+5jim
+4zyy
+4bi7
+1f3j
+2b52
+2xkd
+1yys
+3vtr
+3zrl
+1ke5
+6hwz
+4d0x
+4mzs
+4a6l
+4eg5
+1sgu
+1w11
+3dkg
+1s19
+4msn
+4wyo
+3ppp
+4rlu
+2jjk
+5ovp
+6cd9
+3qio
+4wrb
+5na0
+1wbt
+4ael
+5eu1
+3nw6
+1c5s
+4ual
+2vsl
+5vil
+4o7f
+1b5j
+1pw6
+3rwg
+5wev
+2pjc
+3vi2
+4xum
+2zmm
+3fv3
+3ukr
+5myo
+3lbl
+4ppb
+1q0b
+4abi
+5ygd
+4z90
+4omk
+5bqh
+5lrj
+3ad8
+5izu
+4ty6
+5nut
+3zps
+5e2v
+4k43
+5e7r
+3rjc
+4uvc
+5up3
+3uix
+4rz1
+2p15
+3f66
+1gu3
+6cw8
+5ei8
+4psh
+4i71
+6f9v
+4yoz
+6hu3
+5e2m
+5ap5
+1uod
+3e63
+3mke
+3io7
+4whz
+4mt9
+4x21
+1ppi
+5jjs
+5icp
+4g1f
+1csh
+4mwr
+5al1
+4qxq
+3o9c
+2wxo
+4xmo
+4ii9
+4wr7
+4w9w
+4xjr
+5fhm
+5o2d
+5osk
+3i7e
+4kz4
+4d4d
+1sfi
+5uy8
+2l11
+5v2p
+2vtm
+5ef8
+4b2l
+3g32
+4x50
+2oax
+3ucj
+4c61
+1w2g
+5er2
+3up7
+3r01
+5izq
+3l6f
+3p9m
+4b74
+6fyz
+5g1z
+3t4h
+4wkc
+2o4j
+4bdj
+5hcl
+5mek
+4gvd
+5qil
+2e2b
+4bi2
+5l0h
+5ugb
+2ynd
+2wzz
+5wyz
+5may
+4eev
+1t1r
+4kiw
+2y7i
+3s71
+2qcd
+1vru
+1h00
+4uat
+3nyd
+3bkk
+4n9d
+1bim
+5zt1
+3kce
+5ml2
+3fpd
+6h7o
+3p8z
+4ewh
+3u15
+4uva
+5a3q
+4dai
+5o55
+3f69
+4puz
+5khi
+6f05
+3g35
+4qij
+4dxg
+3n1c
+4dt2
+5u2e
+3er5
+6c7j
+4cj4
+2w7x
+5iu4
+5upz
+3ffg
+5yba
+2f35
+4gsc
+4qvl
+1mwn
+1jeu
+1c3b
+3ual
+1rdn
+6dh1
+5iub
+5mav
+3t83
+6cwf
+2fpz
+5ml4
+5f2f
+1erq
+5t9u
+2qlf
+5jmp
+4s3f
+6hm6
+2qt9
+5mft
+5vih
+3mnu
+6djc
+6eqp
+5gsw
+4ca5
+5mar
+2w77
+2avq
+5eqq
+1tsi
+2vw2
+2ggd
+6f6d
+1f4g
+3ndm
+3l17
+5fni
+1c3r
+5trf
+1pau
+4li8
+4re9
+4l7o
+5kbh
+2oh4
+1joc
+1qxl
+4qge
+2yfe
+3g8e
+6czu
+2fs8
+4mk5
+4i60
+3fh8
+4h1m
+2qd7
+1uom
+3oim
+3f9w
+6ezi
+3r17
+4bcd
+1l6s
+2uzv
+4e1e
+3d28
+5kez
+1bn4
+6biz
+4lwt
+3jpv
+5fsm
+4mds
+4e6c
+3o9p
+5fyq
+4hxq
+3mj1
+1zm7
+1s63
+4nk9
+4qmm
+4zyw
+3kid
+2q8i
+3gfe
+5ih6
+4owo
+5o5f
+1qbq
+5du6
+1ymx
+1oe0
+4x5p
+1fhr
+1ntv
+1o5f
+1ui0
+3os3
+3d1f
+3lxs
+3lxg
+1pxl
+5n87
+1gz9
+1b6l
+5kcx
+2xni
+3ig6
+1p4u
+3r9h
+5n2x
+6aud
+5nee
+1bnw
+6bo6
+3kaf
+2fvd
+2xaj
+4a95
+5iv2
+3n2u
+4q6e
+2f34
+6evo
+5ksv
+2e9n
+5cgc
+1m51
+1d4h
+5kls
+3s2p
+1f0u
+4k3l
+4tww
+5f88
+3fcb
+4arw
+5kos
+4o9w
+3vzd
+2ay7
+5dcz
+5dqf
+3ttj
+3lc3
+1uml
+4oty
+4wzv
+1hxb
+5fcz
+5l87
+4ah9
+5ma7
+4hs8
+4qgd
+5zkc
+4d2t
+5elz
+3ara
+5cuh
+3jqg
+5w4s
+4n7m
+3tct
+4n1t
+5nhf
+2yge
+4gs9
+6bu3
+5vqr
+2am4
+5wr7
+4j58
+2bkt
+4buq
+3u7m
+3u51
+3w55
+2gfa
+3fum
+4hyu
+4pra
+4kyk
+3v2w
+2pog
+4li6
+3qj9
+5d3t
+2w67
+5fs5
+5qaf
+4crb
+6fe0
+3zmq
+5t1t
+5ks7
+2xm1
+4oaz
+6e8k
+2fys
+5egs
+4aac
+4wym
+2qbs
+1lke
+3smq
+5eds
+3wmb
+5j7q
+3cz1
+1s39
+1n94
+5lc0
+5wg5
+5ttg
+1ndz
+6gmx
+3fsj
+1cim
+2f2h
+4qsh
+2g9x
+1o47
+6aqf
+2ce9
+2ycf
+1t29
+4k5z
+5ijr
+5kks
+5tg2
+4yxu
+4i7c
+3ftv
+1ke3
+4bib
+3coy
+5orw
+5bns
+4bs0
+3igp
+2uw4
+4avj
+3qcy
+5vqz
+1yqj
+3a73
+4uu8
+4rwk
+5j5r
+2rkm
+1w14
+4edu
+3e73
+5o1s
+1mnc
+2ypp
+3wq5
+4j74
+3rz5
+5upe
+4eh6
+1c84
+4fcf
+1sc8
+3agm
+5w10
+1gzg
+4qvv
+4qp6
+3ip9
+5he0
+4yv5
+4uyd
+1nu3
+3ozr
+5qin
+4utv
+5x9o
+1okv
+3cyx
+4xhv
+5ll7
+4gm3
+2w78
+3bym
+1ga8
+1p5e
+4c4f
+2mps
+4w9f
+3lmk
+3sz1
+4tya
+3o2m
+2v85
+2ael
+4pv5
+3i02
+6fs1
+3twr
+2qoa
+4lk6
+3qtu
+3f8c
+2qhy
+5jmw
+3bun
+4l70
+6cd4
+4ymb
+4bcm
+6bh2
+5h0h
+1ppx
+6gnr
+2x6k
+3f9n
+4oys
+3rf5
+5orx
+3hub
+4mqu
+1i41
+3c5u
+4gw5
+1xp1
+2r9w
+5lm4
+2csm
+3n1w
+5nhz
+4zk5
+4kai
+1e6q
+4cg9
+4bf1
+2ycr
+3hd3
+4ehe
+5tku
+5wle
+2r64
+6ft8
+5ti5
+4tyt
+5lma
+3zt2
+5ai4
+3zh8
+6gjy
+3fl8
+3old
+3fqs
+4xct
+4mjp
+3g2y
+6g8n
+5kkr
+1fjs
+6dxg
+3che
+3qfv
+4tsz
+1r5v
+1pr1
+3nsn
+4p1u
+3szb
+5u11
+4o0t
+4q4i
+2nww
+4rsp
+1fsg
+1u0g
+2clv
+3opp
+4lg6
+1hps
+6bhe
+6bir
+5h09
+3kwj
+2bed
+3e51
+6axj
+3udd
+1zvx
+5o0e
+4eox
+2rly
+3ob2
+3osi
+5m7t
+5vqy
+5ei6
+6drt
+3mbz
+4f7n
+3ipb
+4zx9
+3nmq
+6gy5
+2hh5
+1vjy
+4hy5
+4ts1
+2qcg
+5lwd
+3oyn
+3rbq
+1y57
+3ujc
+3ekp
+3p7c
+3gws
+3fw4
+4pov
+4m0f
+3qaq
+4ovf
+1ps3
+4gw6
+5a4c
+2ovx
+1gwm
+2kwn
+4uce
+4y2p
+2q2c
+5lgn
+3i4b
+4qmo
+2wyg
+3kqb
+5eay
+2b4l
+2xd9
+3gjt
+2b1v
+3ctq
+5tzz
+3jup
+1h28
+4b13
+2aac
+4wku
+2fjp
+5eij
+4mga
+5ak2
+5dp4
+4inu
+4nrc
+1tng
+1xh3
+1toi
+2lya
+3mpm
+1qb9
+5hlw
+2fvc
+4muw
+3ikc
+3d91
+3img
+4op1
+4s3e
+3qxp
+4f5y
+4qmv
+3gwu
+4qtc
+6tim
+4h2j
+1x7e
+1b6h
+3opr
+4gjb
+5v3o
+5l44
+2c6i
+4ezr
+5u4e
+4wke
+3n3j
+5eg4
+2yiq
+4jmx
+4q2k
+2x2r
+2fzg
+1ajx
+3ccw
+5u0e
+5j32
+6gwr
+6gu7
+5dxb
+1hyo
+3lc5
+3arw
+3rz1
+5jv2
+4l2f
+5etj
+2a3w
+1h79
+6ed6
+5w85
+4x7l
+6mub
+5od5
+5ejl
+3ubx
+2c6k
+4rn0
+3pdq
+4unp
+3lp1
+5mng
+4w5j
+5afn
+1ahx
+2jst
+1o3h
+3rz8
+4na9
+1f0t
+4eym
+5vew
+4k3p
+4zs9
+3b9s
+5wcl
+4mmm
+2l65
+4lph
+3frz
+3rz9
+4kba
+5a8x
+5eps
+5f1j
+2oxd
+4g0k
+5gr9
+3uxl
+3fud
+4x68
+3k2f
+5lsg
+3zrm
+5v6u
+4lke
+1o4r
+4fcb
+4qp8
+1htf
+4yc0
+3q4b
+5dh4
+5ivy
+3sn7
+4waf
+3gst
+5ecv
+1hvj
+3m3c
+2ewb
+3ryz
+3a2o
+4ea3
+4wx6
+1i32
+4lge
+3cwe
+1h0r
+5m9w
+3jwr
+2q70
+4iu0
+1tl3
+2gqn
+3bc3
+4gk7
+2wd3
+4ybt
+5dms
+1nhg
+3f16
+4mw1
+3cgo
+5v4q
+4c36
+4x6n
+3bh8
+3f6h
+5d0j
+3l6x
+4c1u
+6fzx
+4hzx
+4g8o
+4mrz
+4tyo
+4umj
+4rfz
+1rxp
+2zyn
+5t54
+6bh3
+4cd5
+4hlk
+3t0x
+5dy5
+1ft4
+5org
+5to8
+6aox
+2y5f
+4x7o
+4y4v
+1h25
+5d2r
+2xch
+5ndd
+4nzo
+3mct
+5dia
+1iih
+3ime
+3tll
+1w2x
+2jle
+1h26
+5v88
+1o2o
+3e90
+4j46
+3dp9
+5ngb
+5jh6
+3rpy
+2vfz
+5xn3
+4xx4
+3ppo
+4qfo
+1o3d
+3s43
+6ar2
+3cyu
+1qf0
+4amz
+4mti
+6f29
+5mk1
+1qsc
+1uvr
+4whq
+4d08
+6gu3
+4b6q
+4agc
+4uu5
+3blt
+2zb1
+3krd
+3lm1
+1t32
+5kbq
+1gwr
+4k6v
+2vba
+3zrc
+4nmx
+4mbc
+1ie9
+3bgz
+2k62
+1mqg
+1qy1
+2x7u
+3iqq
+2g5p
+4q3u
+5flo
+4bo1
+5tyr
+5x26
+2drc
+4bbh
+3gkz
+5e6o
+4qy3
+1nq0
+2gu8
+1w9v
+5uci
+2veu
+5hvy
+3ewu
+1jm4
+5yas
+1ols
+4ojr
+1h0w
+3as0
+4e3g
+4euv
+2wly
+3lir
+3znr
+3q3t
+6ap8
+3g3n
+3c52
+3g2w
+4iku
+5bry
+3neo
+4wvu
+1abf
+1sjh
+3hc8
+2liq
+5dtw
+5dhu
+1jvp
+5jxn
+4mrd
+2yjc
+2o9r
+5en3
+5hpm
+3k05
+3h0q
+2a4l
+4xue
+1dtt
+4yzm
+4q4p
+3d9o
+3s8x
+6ek3
+2hds
+5fwj
+3kme
+1zog
+5bvf
+4c6v
+1xdd
+1dud
+3lzu
+2er6
+3f48
+2xuz
+3c39
+1ydd
+6fqu
+4fc0
+5w4r
+1bzc
+3pj8
+2auc
+4kp0
+2y7p
+3h23
+4ono
+3nc9
+4bjb
+3mz3
+5edc
+2xzg
+6bqj
+1ga9
+4oq6
+5ee7
+3rj7
+4y8z
+5ka1
+5vii
+5ele
+2ew6
+1s9v
+2x6w
+5mnc
+5eni
+1wqv
+4jve
+3oy0
+4ish
+6h41
+1ebw
+4zx4
+4q15
+6czv
+2wti
+5j9l
+1o5r
+2bq7
+4fic
+2ole
+3umw
+1a1e
+1ax0
+1fcy
+4ux9
+6bhi
+3pj3
+5m55
+2uw6
+2ea2
+5dl1
+6g7f
+5o8t
+5t1l
+1d09
+3ibi
+5h22
+4bgh
+2j9h
+2iyf
+5m28
+2v0c
+5b6g
+2q3z
+3pcj
+5y0z
+3u6h
+3dtc
+3cr4
+2igv
+4qaa
+3n35
+5ylj
+5dls
+5h1u
+4qw4
+4hv3
+4jfi
+2go4
+2m0o
+5vzy
+2h6t
+4x1n
+2qnn
+2aqb
+1zd5
+1bnt
+4z46
+2p8s
+3uh2
+1b2m
+5eiw
+4bfy
+5csx
+2rjp
+5o7n
+3d3p
+4l0l
+3zo2
+3zhx
+2hah
+3dx1
+4dkt
+3n0n
+4l4m
+6asz
+3hv4
+5boj
+3imc
+3eju
+5t6z
+4jaz
+1gjb
+5fl0
+3r9n
+3sw8
+5ggp
+1x8t
+6m9f
+3bva
+2wtc
+5lom
+2vwc
+6bw2
+4n1z
+2w16
+3lzb
+1fwe
+2i6b
+4j8r
+4je8
+2xn7
+3t60
+2n9x
+4lwu
+6ebe
+6ajj
+2xp7
+3ql9
+1q7a
+5dkn
+2gnl
+3rwc
+5npr
+1ajv
+6e4f
+5alf
+2xys
+6h5w
+2jfz
+4bda
+3rxd
+1f57
+9icd
+3zpr
+4ciw
+2zcr
+2w9r
+3hnz
+4r1y
+3olg
+1kwq
+5lrg
+5f0c
+3u8j
+1bl6
+4b6s
+1ej4
+4ht0
+3u6w
+4q09
+5jss
+2b1i
+5cls
+5mrh
+3nox
+2qe2
+3u6j
+1qka
+3k5u
+1ws1
+6ft9
+1ajn
+3zn0
+2i3z
+1y3x
+2r9s
+5vpm
+4occ
+3osw
+3hy5
+4j86
+5f1v
+5l4e
+2qve
+4erf
+1wss
+1ajq
+5h5r
+1hee
+3rq7
+1dxp
+1vgc
+3huc
+5fqb
+4mue
+1qbs
+1ujk
+4xo8
+4ww8
+4qxt
+2wxp
+5j3s
+2h1h
+3f82
+4lhm
+2rjs
+5nvf
+3l0n
+5b5f
+4oow
+3ej5
+1li6
+5swg
+6eum
+3fas
+5klr
+2vv9
+2byr
+5nr7
+3suf
+2xb9
+1f4x
+5v86
+3kl6
+1qng
+2a8g
+2j62
+3zi0
+5j5d
+1h6e
+3ap7
+3zj6
+4hp0
+1bmk
+1nj1
+5xp7
+4iwd
+1if7
+4ia0
+5yjk
+5j7f
+5ake
+1h2t
+4ezj
+4mzk
+5jfp
+4an3
+5v24
+2xmy
+2vts
+2i0h
+2hwg
+3ddg
+2zfs
+5wfd
+4lnb
+4qyy
+2r3j
+4eoi
+3pdh
+1y3p
+4g5y
+3v4t
+4okp
+1xpc
+3avl
+6gzl
+2pqc
+3wab
+5iop
+3bex
+3cdb
+6afc
+1v0m
+3ksl
+3fvl
+6c7d
+1t2v
+1jn2
+4k4e
+1a94
+1j81
+3e93
+1q9d
+4idt
+4k2f
+3snc
+4otg
+2lty
+5bnr
+6c7r
+3as3
+4ge9
+4xg7
+1d4y
+1gno
+5dqe
+3rwi
+4x8o
+3el9
+4kup
+3eks
+2kff
+1w5y
+2vwv
+3u3f
+3rvg
+4oeu
+3u4o
+2pv3
+4i0t
+3aru
+4yv0
+5uv1
+3vjc
+5vc5
+2ito
+3adv
+3oe6
+5mnb
+5gvm
+1r1j
+2qe5
+2rjr
+4cfm
+3c1n
+6ma3
+1z9h
+4jk6
+6g98
+1qm4
+4j24
+3pju
+1wvj
+4csy
+5cqx
+2yde
+4mqp
+2np9
+4zyu
+3ua9
+3fc2
+2xp5
+1umw
+5jer
+3dcv
+4aft
+4rhu
+3ahn
+6hth
+4ytf
+5os2
+5el9
+4oth
+2mnz
+1lkl
+6ela
+5vkf
+2oz6
+4q1f
+5usz
+4fxq
+3ggu
+1hiv
+4d2s
+2fkf
+4oz3
+6fkz
+2qd6
+1jyq
+3uvw
+4f6s
+2qk8
+1lvu
+11gs
+3ml5
+5vkc
+1wu1
+1ih0
+5m17
+1rne
+1l2z
+3s0d
+4nxq
+4at5
+5iu2
+1x78
+6bc9
+5dgu
+5juz
+4qvn
+5i7x
+5o7e
+1fl3
+1enu
+2clf
+4zs0
+4llp
+5nrf
+4z0k
+6cdc
+6bin
+4e1z
+2q64
+3s0o
+4z0u
+1ii5
+4lk7
+5ubt
+5m1z
+1t4j
+1g7v
+4q1n
+3l08
+5d7r
+2emt
+4y2b
+4g31
+5n0d
+6ecz
+4gb9
+4jfl
+2ow3
+1ibg
+3fyz
+5g5z
+7lpr
+4g8n
+4bie
+2yir
+4yps
+5jdc
+3p4v
+2fum
+5c4o
+1cj1
+6f09
+4ce3
+4ft2
+2pcu
+4mo8
+2g2r
+4utn
+5nxp
+5t52
+3iod
+1h01
+4deb
+4jjs
+5ts0
+3su0
+4yhf
+4u4s
+3heg
+2g70
+3p2h
+1sqq
+2f4b
+1igj
+3fcq
+2pja
+4ase
+2xyf
+5ka7
+5kzp
+3oob
+5w6t
+1h2u
+4zt3
+1w96
+2pzi
+4qf7
+3c88
+4y67
+2wzm
+4qtn
+3sue
+6fhu
+1qs4
+5u6b
+5edb
+2p2h
+5gtr
+4hbp
+3tia
+2cgw
+3gwt
+5t8r
+6fo7
+1g9t
+3kr0
+1gt3
+5c83
+2r9x
+5nk7
+4cfu
+5e2r
+4b4q
+3uil
+5fl6
+1ms7
+4csj
+4yat
+4f1q
+6fi1
+4lm1
+3hj0
+3oad
+4bd3
+6h7n
+5exm
+1ctu
+5l3f
+2ajd
+2c94
+3g3r
+4dro
+1uou
+6bsl
+1z4u
+3zyb
+4o43
+3wch
+5orb
+3kgp
+3zeb
+4pyy
+4b0j
+1jq8
+3u4w
+2xyt
+5jhd
+3hmp
+4dxj
+5hg7
+3zlx
+1zkk
+1gny
+4ju6
+1il3
+4daf
+4o0x
+5ygi
+6gla
+3mtw
+3mg0
+3d9l
+5edq
+4bci
+4e4x
+3wuu
+3udv
+1lpk
+4dkq
+4bfp
+5i2e
+3rm8
+4ahu
+3wi2
+4de2
+5g2g
+2wuu
+5nud
+4hcu
+3k37
+6prc
+2e7f
+4bb9
+1amk
+4l1a
+5wkf
+4qsm
+3sxu
+5lif
+4azf
+5ntt
+5d75
+3vsw
+5fos
+1qin
+3e7b
+3vjm
+3ny3
+6aqs
+1k6c
+1ydb
+6fc6
+2gnj
+4zy6
+5dhq
+2aou
+4b0b
+5t2p
+5efb
+5u0d
+5vjp
+5bui
+5e13
+5f5i
+4ivk
+7hvp
+3d7k
+4vgc
+5g1p
+6b1h
+2br8
+1cqp
+4w50
+4ehv
+3ws9
+2yfa
+5mpk
+4zz0
+3str
+5mrp
+5nkd
+5kqy
+4lw1
+1avp
+5xxk
+4oks
+4hxr
+3ur0
+4pns
+4i5m
+2vtd
+2gph
+3rme
+5fqp
+5hfu
+2iok
+4yux
+2hvx
+1n0s
+3s1y
+1g7p
+2rr4
+2x00
+2b55
+4wmv
+3evf
+4kc1
+2x39
+5joh
+2w0p
+4az6
+1o0f
+3haw
+1h8s
+4ge1
+3phe
+1evh
+6b30
+1g35
+5gjf
+6bt6
+5trr
+5ly3
+5eh0
+5ioy
+1xt8
+3c3o
+5e74
+3acl
+5abh
+5fol
+3qxv
+3ttm
+3iwy
+5lxb
+5n18
+6beb
+5nxw
+4muk
+4mm4
+4hs6
+5ncq
+4i72
+4hcv
+4pee
+1q63
+1qtn
+4rfy
+5dyy
+3ud8
+5itf
+5hey
+2ko7
+3oil
+5tks
+5o3q
+4k72
+4oma
+3hv6
+5tq4
+5uxf
+6df7
+5er4
+4no6
+1rev
+6hdq
+3c43
+1a7t
+6fky
+5n1r
+3rr4
+5bqg
+3b8r
+2pfy
+5c7f
+5l6j
+1etz
+3drf
+3k7f
+4b6e
+4kil
+6asu
+1fd0
+4zjc
+1y3g
+4joh
+4c38
+4h5c
+5kej
+6aji
+4mvy
+4pms
+6fx1
+3ioi
+2xbj
+1bnm
+1yda
+5mhp
+4fgt
+4hwb
+4aje
+1v2t
+3bc4
+5h85
+2ew5
+3uoj
+2aog
+3o5x
+5vr8
+2o4p
+1fh8
+4jz1
+5oq4
+3zdh
+3lnz
+6ee3
+3rak
+6ba7
+6czb
+2wyj
+4qyo
+3mxd
+2ri9
+2zq1
+3ljo
+6g2a
+1gj6
+5oug
+1g4o
+3mvm
+1iyl
+2cgx
+4yrr
+3v2x
+5iv4
+4m2u
+4q1b
+3ggc
+2c68
+1laf
+4kxn
+2ada
+1om1
+3wax
+5eh7
+4jk5
+4q93
+1x11
+4c4j
+3bzf
+4y7r
+4zow
+4ui6
+1pxi
+5ni5
+5v4b
+1o4m
+1urc
+3ads
+5gn5
+4mrg
+5ylt
+5k6a
+4nld
+2xl3
+4auy
+1zoe
+5lxd
+4pum
+3gbq
+5xs2
+4ggl
+5a14
+4au8
+5n49
+5x8i
+6c7f
+4j84
+3fvk
+4kqp
+5y97
+5mxx
+3lox
+2oc7
+6hsz
+1ilq
+3twj
+5vcx
+3svv
+4na4
+3v5g
+4p7e
+2vwl
+4umu
+3v4j
+6gfz
+6duf
+5ezh
+4yti
+4zyq
+4lop
+4nus
+2a3a
+2o9i
+3ia6
+5nfh
+1e00
+3n8n
+3kxz
+4fxj
+1gx0
+4u90
+3eq8
+3q44
+5e2p
+1pxj
+4p6c
+1zoh
+4i7j
+4hlg
+3wiy
+4k77
+1hsl
+4tjz
+5l6h
+6cbh
+6g38
+5wep
+1jwm
+3wfg
+5lvl
+5kqd
+1fq5
+5nn6
+5xag
+3w69
+4c4h
+5mgi
+5ad1
+4i7b
+6cwi
+1tkb
+3unj
+4u54
+2x0y
+3isw
+2xbw
+6fzu
+5wgq
+4kzc
+5btr
+1juq
+2idk
+2v25
+4prh
+5o5a
+1sle
+2ieh
+5ous
+1p7m
+3fuf
+1w10
+1guw
+1gbq
+5thn
+4xoc
+5ugc
+4h71
+5i43
+3t0d
+5eok
+4kw6
+4jrg
+4ra5
+4azp
+5sz3
+5hbj
+1npa
+4wi1
+3biz
+4bpj
+3lxe
+5qav
+4ge6
+4k1e
+3vje
+4qp9
+2xg5
+1w5x
+3omc
+5ii2
+5elq
+1ec0
+4x8g
+3cft
+4qd6
+5n1x
+4ucc
+5nne
+5ocj
+4mul
+3lok
+3eql
+5kyj
+3hfz
+2pg2
+3g3m
+4fs3
+1nnk
+4n9a
+6cvd
+4tkb
+3tfp
+5nsx
+6bbv
+5myg
+3ws8
+6ex1
+5m6m
+2jkr
+2vw5
+4ezl
+3dp0
+2a4r
+5hyq
+5iyy
+2oc4
+5div
+3p1d
+2r38
+3chp
+3ot8
+2wqb
+6bqh
+3gxl
+2ayp
+2pgj
+6gfx
+2i3v
+5yqw
+5n9t
+6cc9
+3p3s
+3oe9
+2y1o
+2o4r
+1dzm
+3vp2
+4oz2
+1p6d
+5mih
+4xt2
+3tf7
+5v19
+6g9k
+4ipf
+3bim
+4nwm
+2aeb
+3blu
+3vtc
+3nww
+3mp6
+1nu8
+3wzk
+3gvb
+4bt4
+2f6v
+5m53
+3iux
+4b0g
+4yvc
+1ai4
+1jr1
+1z1r
+1ryh
+1rhu
+3g0i
+4clb
+5cte
+4kmu
+6f9r
+3pjg
+3tww
+2lbv
+5w1w
+1s26
+3w9r
+5km0
+2h03
+1qnh
+4cpx
+4mnv
+4qo9
+4tk4
+5wg6
+5uwf
+4cjp
+3uu1
+4bxu
+2gyi
+4qwr
+1cnw
+4fzc
+4e5i
+3oq5
+3wig
+5my8
+4aj1
+4xcb
+3wf5
+5htb
+1ugp
+5anq
+1apb
+1ove
+1lrh
+3v7t
+1xk5
+4fiv
+4mcv
+1mrw
+4b14
+5isl
+5un9
+3nil
+1x07
+6fni
+4xt9
+4u2y
+4hbv
+6h2t
+4q6d
+3b8z
+2cnf
+4isu
+2ok1
+5u2f
+2cng
+4q90
+4l0b
+6g3q
+4ylu
+3w5t
+4dei
+2zjv
+2x6y
+3ikg
+5j7p
+4mcc
+3vqs
+3u9n
+2g5t
+3owj
+5bnm
+3hkn
+3qtx
+3qzt
+6fag
+1o43
+3vby
+6as6
+2r7g
+5vjn
+3skc
+3bg8
+1tc1
+5bq0
+5qac
+3l16
+5kw2
+3uj9
+6byk
+5kgw
+4wvt
+1bv9
+4ruz
+1fzq
+1srg
+4y73
+3upv
+4jj8
+5xvf
+1xka
+4ewn
+4ewr
+6g9b
+4u69
+1qb6
+3c6t
+3qar
+4k5o
+2gnf
+1u3q
+3g31
+3oev
+4uib
+1eby
+3uef
+4k0o
+5ehi
+5h63
+3wcg
+4jhq
+1hii
+3sgt
+4aua
+5mmn
+4hnc
+3bxh
+5g5v
+4j08
+4anu
+3hac
+2f7p
+5akj
+4ycl
+3hs4
+3s22
+3obq
+1o9k
+4xy2
+3k9x
+1xog
+4m5g
+4czs
+5eyr
+4lm5
+5xup
+4rao
+3qcl
+3lkj
+2xno
+1gjd
+4bzs
+4j7d
+1jfh
+2cgr
+4pd8
+3mz6
+5obj
+3gm0
+4j3u
+1uvt
+5ml5
+5vnd
+4r3c
+4kfp
+5xhs
+5mwz
+3n86
+5qab
+5zeq
+1fo3
+5n8w
+2exm
+4klb
+2qhc
+4qn7
+5wlg
+5nbw
+4k2g
+5l4m
+3qck
+3zo1
+4knx
+6dh6
+3k8q
+4kiu
+5f3e
+4own
+5uoy
+4gr3
+6cyd
+2f14
+5v2q
+3h2m
+3ao2
+1k1n
+3gfw
+4q19
+2b1g
+4pdk
+1oxn
+2pj1
+4o3a
+2y6s
+1inh
+4u5l
+4esg
+4mg6
+4de5
+3wke
+4mp7
+4de1
+4z6i
+2r4b
+4qyh
+4b33
+2koh
+5y94
+6fo8
+4mny
+5yqx
+5c26
+4eb8
+3lk1
+3mg6
+4oru
+2wpb
+4k7i
+5fsy
+3ava
+3ex6
+4b8p
+3l13
+3s3k
+3chc
+6bvh
+6b5i
+3gk4
+2lcs
+5fas
+1lyx
+6edr
+1ghz
+1egh
+2x6f
+5o48
+3znc
+1czq
+5f39
+2bpy
+5op5
+5oh9
+4ory
+3hu3
+2ybt
+1v1k
+5o22
+4eo8
+4bco
+2p3i
+3hii
+2xdm
+6axq
+2xhs
+5cyv
+1sre
+2y8o
+9lpr
+4l3o
+1dzk
+3lnj
+3fsm
+4ghi
+2nqi
+1i48
+5mo2
+6fr2
+1bnn
+2jbl
+1r17
+4rrf
+6apw
+1lgt
+2wl0
+3oe5
+3fjz
+3hxd
+6g3o
+2nqg
+3fc8
+2zvj
+3mw1
+2c5n
+3mhw
+5tdw
+5n7b
+4kij
+5axq
+3pxy
+3kjd
+5cf5
+5id0
+5e0j
+1xr9
+4kjv
+4e1m
+3gy4
+1xqc
+2hzy
+5brn
+2d0k
+3s8n
+5zc5
+3p5o
+1xh5
+4hv7
+4zt2
+2b7a
+1thl
+1jmq
+5h7h
+5mz3
+3dxj
+6ays
+3w2t
+1bkm
+3vjl
+2a8h
+5tt8
+5lyx
+1zaf
+2fuu
+4mw6
+2j6m
+3qai
+4kzq
+2uym
+2bqw
+2q8y
+6ary
+4daw
+4i06
+2wxk
+1r5n

data/timesplit_no_lig_or_rec_overlap_val

@@ -0,0 +1,1223 @@
+4mi6
+5ylv
+4ozo
+6gip
+3std
+3g2n
+6ax1
+6h96
+5q0m
+5hh5
+4idz
+6cec
+5wqa
+3k3e
+1ppk
+4og7
+4b5w
+4bgg
+4jgv
+2g9v
+4og3
+5lz2
+6chq
+5aqv
+4k67
+5j3v
+5lz9
+5t2y
+4el5
+2z60
+4zed
+4pks
+5cuu
+5q0x
+4x5z
+3hs9
+3v7s
+2qyn
+5ehn
+1sz0
+4x6i
+4u82
+2vrj
+6g2l
+2bow
+5o9y
+4mji
+6ccs
+1yvm
+3sym
+4fz3
+5tdi
+2ie4
+1n4m
+1c3i
+5eie
+5ye8
+5in9
+4b7z
+5ncz
+5lz4
+6bw4
+3sl4
+4dmy
+4cmt
+5a9u
+1fki
+4mc1
+5o9o
+4b5t
+4m3g
+1pyg
+3b67
+5l8o
+5mkj
+3oyp
+4anq
+5hog
+4de7
+5tkb
+2vle
+3f7i
+3v51
+3l7d
+2v6n
+4qna
+4cd0
+3iog
+4i8w
+2xup
+3t3i
+1db4
+5es1
+5i9i
+6ccm
+2xui
+1q91
+1bgo
+1akt
+1q84
+1yt7
+2l75
+5aac
+6nao
+5iuh
+3oof
+4ona
+5q0n
+3sfi
+2g9q
+1hlf
+5aqj
+1g9c
+1ayu
+6co4
+6bd1
+4yur
+3vw0
+6cea
+4nyf
+3v43
+2ya8
+1b4d
+2ccb
+5q1f
+1fkb
+3bcs
+1h46
+6dgt
+2ftd
+5t2l
+3i7c
+6ckw
+3csl
+1j07
+3omm
+4g17
+3v49
+4fny
+1fkh
+4u0e
+2g9r
+6hd4
+5oss
+2adm
+4b85
+2fm0
+4hgs
+2qn3
+1ddm
+3fal
+5q0y
+5q1a
+3g2k
+2j7b
+6ee2
+2jjr
+5q1i
+6b7a
+5kh7
+6gqm
+3mta
+3g2l
+4i4f
+5iaw
+5q0i
+3h1z
+4jbl
+5lvx
+6chm
+6fdc
+2ax6
+6cnj
+1pwu
+4fht
+3th9
+5db1
+2hvc
+4pp5
+5q15
+3u8h
+4el0
+4jt8
+5std
+2pwd
+5wh6
+3kf4
+1q83
+2xml
+1c2t
+4in9
+2jt5
+1icj
+3oy3
+3g2h
+3qo2
+3tu9
+3s0j
+1e3g
+6d1x
+6mx8
+3aqt
+6aol
+4m8e
+1ado
+5hh6
+4lkt
+2j78
+5q0o
+1d8m
+3suu
+1gyy
+5aqt
+3oap
+4zs3
+2qn1
+2p98
+4cmu
+4ie0
+1w3j
+5y59
+2mpa
+1akw
+5tyh
+5lb7
+1fkf
+3djv
+5nxq
+1kti
+3mrv
+5t2i
+4uuq
+2gfj
+4poh
+6by8
+6b7e
+4u0f
+5lp1
+4jym
+3suv
+6fse
+5e1s
+2eum
+6hai
+6h7f
+3suw
+2gg7
+3np7
+5l13
+6f8x
+2evc
+1z6q
+5o9r
+4pkt
+1haa
+5jan
+4oiv
+3djq
+3p7i
+2j7h
+3v7c
+2fw6
+3diw
+4dpt
+1tu6
+4pku
+1ggn
+2usn
+6baw
+1zxv
+3bl7
+5vdu
+6fsd
+4u0i
+4j8s
+1g49
+4hni
+6e83
+6f0y
+4mra
+1d5r
+3v3q
+6f8w
+1c7e
+4b5s
+4ara
+4glr
+4cff
+2q93
+5i8p
+1apw
+3sur
+4b84
+4duh
+3l7c
+1j4r
+3mrt
+1l7x
+4dv8
+1iep
+1bsk
+1i8h
+5xih
+5knj
+5ick
+2v3d
+1sln
+4k64
+6cck
+4ajw
+2hb9
+6std
+2w87
+4a23
+1ayv
+4bvb
+1nc1
+5q0p
+3zlv
+3okh
+1pwq
+3pp0
+4pgh
+2xbp
+2qrp
+4mho
+6gpb
+1aku
+6b7f
+3pcu
+1fm9
+5ddc
+5q0u
+1biw
+3ery
+2evo
+4cxx
+4g2l
+5h6v
+5yyz
+4nw2
+1em6
+3shv
+6cz3
+4lh2
+2gfk
+2z78
+4yv8
+2jt6
+3kdt
+6chp
+2xba
+5wbl
+5t2d
+3fqa
+5xii
+2j83
+4x6j
+2q94
+1vsn
+1c8k
+4b81
+5y86
+1caq
+1k3t
+2qrm
+4u68
+1exw
+1nlj
+3kdu
+1axr
+1kkq
+3mrx
+4z2h
+3oki
+6chl
+1ppl
+2q95
+5q13
+2j7g
+2w2u
+5aqq
+1ms0
+2b2v
+6bfa
+5kew
+2cbu
+1nli
+6bw3
+4h4e
+2ha5
+2aq9
+1g98
+2pri
+1apv
+1gar
+3szm
+8gpb
+1noi
+5foo
+2z4w
+3r93
+2z7i
+5vdr
+5ylu
+6f8r
+3upx
+3zyr
+2jnp
+2nm1
+4kab
+4n8r
+5z4h
+4f9v
+3l7a
+2am9
+2wec
+1h6h
+3nfl
+3wd1
+4mdt
+3sxf
+6ftn
+3gt9
+1oim
+1ywh
+1u9w
+1w70
+3u1i
+2v3e
+5jap
+3b68
+2qnb
+5hbs
+2ama
+2web
+6e4t
+4xm6
+6hd6
+4og4
+3il6
+4zs2
+2z50
+1nki
+4my6
+3vvy
+3nc4
+2z4y
+2euk
+3g4k
+2y2i
+1usn
+1y6r
+3bu6
+4u0c
+2ces
+5ye7
+2cbv
+5twg
+1f40
+5m2q
+4hvs
+4z2i
+3g0e
+3dct
+6bnl
+5v8q
+1au2
+3h0a
+2z52
+4ie5
+2auz
+2qn2
+4lh3
+5lyy
+4z2l
+2bmz
+2evm
+5wvd
+3o8h
+6e4w
+1syo
+1yk7
+5q11
+2ha0
+6ccn
+1mh5
+2ai8
+3rde
+5q17
+4zsh
+6aom
+1pot
+5i5x
+4cqe
+3l3x
+4ie6
+6cnk
+1c12
+1gfz
+4jal
+4ie7
+5tvn
+2qoh
+4z2g
+6b7b
+5kxi
+6f8v
+1xor
+1aqi
+6q73
+5t27
+5q0r
+1y2k
+5q1b
+5ko1
+1a8i
+3g2j
+5gwz
+1c8l
+4o42
+3r2a
+1d7i
+3ovz
+3l3z
+4i32
+2ych
+5aqp
+4xkc
+4og8
+3g8i
+2z7h
+3kfa
+3vfa
+5q0v
+3k41
+2pwg
+1au0
+1g9d
+4i8z
+6cef
+4mhs
+4xm7
+1c3e
+3kx1
+2gj4
+5q16
+4pli
+2j7e
+2j7d
+6q6y
+4gq6
+3k5v
+4j09
+3bl9
+2xuf
+1e1y
+6gi6
+5z4o
+5q18
+4foc
+6bcy
+4aaw
+2ha6
+4pl5
+3vw1
+6bq0
+2aux
+1mkd
+2q92
+1xon
+3aig
+3oxz
+2r6n
+4mmp
+5hki
+2gg0
+4qip
+3ms2
+5d1t
+2ot1
+2xpc
+4zcs
+5db3
+3t3h
+6cz4
+4h4d
+3h78
+5q10
+4jsr
+4qll
+4e90
+6dry
+5aqu
+5oei
+5hz5
+3kwz
+4m3d
+5xig
+3u3z
+2y2k
+5lz5
+1o8b
+4hlw
+4tq3
+1fkg
+3pkn
+2xb7
+5ov9
+3ggv
+3cke
+4m84
+6cho
+1m6p
+5jal
+1a0q
+4eky
+3vw2
+2y2n
+5q0q
+6gin
+2nmb
+3rik
+1akv
+4m3e
+4kwg
+5yun
+3mqf
+4pkw
+3k3h
+3t3v
+3t1n
+2bdl
+2prj
+5wh5
+4qhc
+4eoy
+2bv4
+1i7g
+5iui
+4og5
+5evk
+2fsa
+3sdg
+3g2i
+1y2d
+1c7f
+1qkn
+2etm
+3o1g
+3t3d
+1bxo
+2z5o
+3bla
+5o9p
+5g3n
+5v1y
+4gq4
+2vvo
+4u0b
+1opi
+3sut
+3wd2
+4xm8
+4kp4
+1hy7
+1g05
+5aaa
+5wmt
+2fj0
+1bxq
+5t2b
+1o6i
+4xdo
+5ez0
+5wqj
+5t8e
+6g22
+3o0u
+2gfd
+5fpp
+1tuf
+4v0i
+4og6
+3g4g
+2std
+1xnz
+2dw7
+4oue
+6ds0
+5jar
+4ibm
+1d5j
+2hrp
+1koj
+1d7j
+4ryl
+2f6j
+4eke
+4btl
+6b7d
+3bwk
+5aqg
+4i80
+1c3x
+2qrq
+1oif
+2p9a
+5f67
+4mc9
+4dpu
+3il5
+6bnk
+4lh7
+6ccl
+4m3b
+6drz
+4ebw
+6et8
+1g9b
+3vvz
+5q12
+1jys
+1g9a
+5q1c
+4mc6
+2gg9
+5t2m
+3gta
+5q0w
+5oa2
+3mt9
+5iql
+5q0t
+2gkl
+1z95
+6c91
+2z4z
+3syr
+4g16
+3qi3
+1z6p
+3p8o
+1qpl
+2pix
+4crj
+2cet
+4wf6
+4qfr
+1y2c
+4gh6
+1ct8
+3guz
+1oyn
+1d8f
+4x6h
+3gp0
+2srt
+4k63
+1pwp
+4k66
+4ql8
+4ie4
+2fm5
+3g4l
+5ix1
+5d1u
+4y8c
+2evl
+5dde
+5y7w
+6clv
+2fu8
+3hg1
+4xe0
+5k1i
+3c9e
+1gpy
+2gg2
+5vdv
+5eyz
+2wc4
+4qlk
+3t3g
+4xrq
+3v5p
+1exv
+1std
+5jjm
+5cc2
+4f9u
+5jao
+5dda
+3eta
+6f6u
+6cee
+4pl6
+3ms9
+4kwf
+5q0s
+5q1e
+5o83
+5lz7
+5kq5
+5xij
+5kh3
+4qfg
+3ebo
+2zdx
+6q74
+5bpe
+4poj
+4qgi
+2n7b
+1ow7
+3sx9
+2e92
+2amv
+4std
+5ur9
+2jdl
+3ktr
+1ogg
+1onh
+4ad6
+3sl5
+5v8o
+4yrd
+4dce
+3rcd
+3g4i
+3zqt
+3olf
+1j1a
+1aqj
+3fq7
+4cmo
+3b66
+4htp
+5vdw
+3l79
+3usn
+4i4e
+3d27
+2qrh
+2wc3
+4djh
+1jif
+3g58
+3mt7
+4yec
+6b7c
+1y2b
+2v3u
+2qlm
+7std
+2vpe
+2qln
+5wbk
+5ftq
+3fei
+2nsx
+4ebv
+4b82
+4pp3
+5ddd
+1l5r
+4psb
+4cnh
+1azl
+5evb
+5dpx
+4k9y
+1jq3
+2ggb
+2gm9
+4g2j
+5lz8
+2ylq
+5kz0
+5t8j
+4cts
+2j75
+3mt8
+1n3z
+4rme
+2gg8
+4z2k
+2ha7
+4mi3
+4k6i
+3nfk
+4pl4
+6ce8
+6bx6
+1xom
+4u0a
+3djp
+4zeb
+5q0j
+2wos
+5vtb
+1u9x
+1g4k
+1nc3
+4gu9
+6e4u
+4b83
+2p99
+5dtj
+3o8g
+2fwp
+4fod
+3np9
+5o9q
+3v9b
+1i1e
+3jsw
+4gu6
+1snk
+1bm6
+4fnz
+4qfs
+4nj9
+2ha2
+4ej2
+6ced
+3jsi
+2d1o
+4mc2
+6g2m
+6e86
+1l5q
+3g0f
+2jal
+5y1u
+2ya7
+5jau
+4c4n
+3tmk
+1t46
+5ddb
+5n6s
+1ppm
+5tbn
+2wbg
+6d28
+5q14
+3ik3
+5w99
+5q1h
+4joa
+5ha1
+3m3z
+4pzv
+5dd9
+2e91
+1mem
+1rdt
+5vds
+2xwd
+5k32
+3g4f
+4x5y
+3mtb
+2cc7
+4pkr
+1gyx
+5jas
+1xoq
+1u9v
+3mtd
+3kwb
+5aqn
+4ac3
+2ylp
+3p0g
+3bz3
+1xow
+3ew2
+1akq
+5da3
+4lh6
+1db5
+1g27
+2ao6
+5z9e
+5zun
+4cwb
+2ccc
+5tbp
+1nl6
+4pkv
+2ww2
+3upz
+5aab
+2ha4
+3mss
+1zkn
+4y87
+2pyi
+2yhd
+3rw9
+3f7h
+4q9s
+2g9u
+4jt9
+5twh
+4bj8
+4pl3
+2y2h
+4mi9
+5cdh
+4n5g
+7gpb
+2wr8
+3i7b
+1q9m
+1p2g
+4kao
+5l8n
+1bl4
+3iad
+1q6k
+4i31
+4fob
+5mlj
+5hm3
+2oz7
+5ehq
+4u0d
+6b2q
+4m3f
+3tcg
+6ccq
+4x0u
+1y6q
+3iof
+5db0
+1n4k
+4wht
+4dpy
+4cli
+3msc
+2ylo
+4x7q
+1g2a
+4arb
+5ncy
+1zaj
+3qt6
+3npa
+5aqh
+5oku
+1yon
+3ekn
+2bb7
+1akr
+5h2u
+4cfe
+4why
+3ril
+5q1d
+5aqo
+4cxw
+5osy
+4m8h
+1h5u
+5yea
+5t2g
+1c50
+5l3j
+4cxy
+6cco
+1ow8
+4k4j
+5q19
+5oxg
+3sus
+3kw9
+5wqk
+6f8u
+4i33
+4z2j
+1y2e
+4xpj
+6h0b
+2wor
+3ldq
+3ebp
+1bqo
+3ook
+3l7b
+1ow6
+5ye9
+2off
+1noj
+2aig
+1iup
+5eou
+5db2
+4wcu
+3ewc
+6ce6
+5fto
+4zei
+4b80
+3qi4
+2xi7
+2bqv
+5fkj
+4wj7
+6ez6
+1yhm
+2z92
+3sz9
+5ytu
+6f8t
+3amv
+3eyf
+5iug
+5d7a
+4clj
+5fum
+3v5t
+3ms7
+1yqy
+3aox
+4yjn
+3o4l
+2ax9
+5yto
+2wed
+3ozj
+2whp
+2qrg
+2gg5
+1k08
+2flh
+1l5s
+3n51
+2vpg
+5jat
+6drx
+4ktc
+4k8a
+2zof
+5aa9
+1kcs
+1y4z
+5oa6
+4du8
+2xwe
+3ms4
+2y2j
+6chn
+5q0l
+5aa8
+2qdt
+4a16
+3u8d
+5t28
+4xkb
+4hgl
+4l4v
+2gg3
+5ddf
+4ra1
+3t3u
+1ciz
+2j7x
+1x8d
+1kvo
+1b8y
+4yik
+1osv
+2hdx
+1k06
+3g1m
+5aqf
+1d7x
+5yf1
+3b5r
+3r0h
+6b41
+4mic
+2rin
+3bpc
+2e5y
+1n5r
+2j77
+1gag
+3djo
+4zec
+5xwr
+5d1s
+1uz1
+3sl8
+2j79
+3r5m
+3b65
+2e95
+3t3e
+5cj6
+1nok
+5wpb
+1hfs
+6e5x
+5evd
+5ikb
+5aqr
+3p8n
+5q0z
+1dg9
+3qt7
+5jah
+5ax9
+2q96
+2j7f
+5q1g
+2y2p
+5v84
+4pji

data/timesplit_test

@@ -0,0 +1,363 @@
+6qqw
+6d08
+6jap
+6np2
+6uvp
+6oxq
+6jsn
+6hzb
+6qrc
+6oio
+6jag
+6moa
+6hld
+6i9a
+6e4c
+6g24
+6jb4
+6s55
+6seo
+6dyz
+5zk5
+6jid
+5ze6
+6qlu
+6a6k
+6qgf
+6e3z
+6te6
+6pka
+6g2o
+6jsf
+5zxk
+6qxd
+6n97
+6jt3
+6qtr
+6oy1
+6n96
+6qzh
+6qqz
+6qmt
+6ibx
+6hmt
+5zk7
+6k3l
+6cjs
+6n9l
+6ibz
+6ott
+6gge
+6hot
+6e3p
+6md6
+6hlb
+6fe5
+6uwp
+6npp
+6g2f
+6mo7
+6bqd
+6nsv
+6i76
+6n53
+6g2c
+6eeb
+6n0m
+6uvy
+6ovz
+6olx
+6v5l
+6hhg
+5zcu
+6dz2
+6mjq
+6efk
+6s9w
+6gdy
+6kqi
+6ueg
+6oxt
+6oy0
+6qr7
+6i41
+6cyg
+6qmr
+6g27
+6ggb
+6g3c
+6n4e
+6fcj
+6quv
+6iql
+6i74
+6qr4
+6rnu
+6jib
+6izq
+6qw8
+6qto
+6qrd
+6hza
+6e5s
+6dz3
+6e6w
+6cyh
+5zlf
+6om4
+6gga
+6pgp
+6qqv
+6qtq
+6gj6
+6os5
+6s07
+6i77
+6hhj
+6ahs
+6oxx
+6mjj
+6hor
+6jb0
+6i68
+6pz4
+6mhb
+6uim
+6jsg
+6i78
+6oxy
+6gbw
+6mo0
+6ggf
+6qge
+6cjr
+6oxp
+6d07
+6i63
+6ten
+6uii
+6qlr
+6sen
+6oxv
+6g2b
+5zr3
+6kjf
+6qr9
+6g9f
+6e6v
+5zk9
+6pnn
+6nri
+6uwv
+6ooz
+6npi
+6oip
+6miv
+6s57
+6p8x
+6hoq
+6qts
+6ggd
+6pnm
+6oy2
+6oi8
+6mhd
+6agt
+6i5p
+6hhr
+6p8z
+6c85
+6g5u
+6j06
+6qsz
+6jbb
+6hhp
+6np5
+6nlj
+6qlp
+6n94
+6e13
+6qls
+6uil
+6st3
+6n92
+6s56
+6hzd
+6uhv
+6k05
+6q36
+6ic0
+6hhi
+6e3m
+6qtx
+6jse
+5zjy
+6o3y
+6rpg
+6rr0
+6gzy
+6qlt
+6ufo
+6o0h
+6o3x
+5zjz
+6i8t
+6ooy
+6oiq
+6od6
+6nrh
+6qra
+6hhh
+6m7h
+6ufn
+6qr0
+6o5u
+6h14
+6jwa
+6ny0
+6jan
+6ftf
+6oxw
+6jon
+6cf7
+6rtn
+6jsz
+6o9c
+6mo8
+6qln
+6qqu
+6i66
+6mja
+6gwe
+6d3z
+6oxr
+6r4k
+6hle
+6h9v
+6hou
+6nv9
+6py0
+6qlq
+6nv7
+6n4b
+6jaq
+6i8m
+6dz0
+6oxs
+6k2n
+6cjj
+6ffg
+6a73
+6qqt
+6a1c
+6oxu
+6qre
+6qtw
+6np4
+6hv2
+6n55
+6e3o
+6kjd
+6sfc
+6qi7
+6hzc
+6k04
+6op0
+6q38
+6n8x
+6np3
+6uvv
+6pgo
+6jbe
+6i75
+6qqq
+6i62
+6j9y
+6g29
+6h7d
+6mo9
+6jao
+6jmf
+6hmy
+6qfe
+5zml
+6i65
+6e7m
+6i61
+6rz6
+6qtm
+6qlo
+6oie
+6miy
+6nrf
+6gj5
+6jad
+6mj4
+6h12
+6d3y
+6qr2
+6qxa
+6o9b
+6ckl
+6oir
+6d40
+6e6j
+6i7a
+6g25
+6oin
+6jam
+6oxz
+6hop
+6rot
+6uhu
+6mji
+6nrj
+6nt2
+6op9
+6pno
+6e4v
+6k1s
+6a87
+6oim
+6cjp
+6pyb
+6h13
+6qrf
+6mhc
+6j9w
+6nrg
+6fff
+6n93
+6jut
+6g2e
+6nd3
+6os6
+6dql
+6inz
+6i67
+6quw
+6qwi
+6npm
+6i64
+6e3n
+6qrg
+6nxz
+6iby
+6gj7
+6qr3
+6qr1
+6s9x
+6q4q
+6hbn
+6nw3
+6tel
+6p8y
+6d5w
+6t6a
+6o5g
+6r7d
+6pya
+6ffe
+6d3x
+6gj8
+6mo2

dataset.py

@@ -0,0 +1,70 @@
+from itertools import accumulate
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+
+
+class ProcessedLigandPocketDataset(Dataset):
+    def __init__(self, npz_path, center=True, transform=None):
+
+        self.transform = transform
+
+        with np.load(npz_path, allow_pickle=True) as f:
+            data = {key: val for key, val in f.items()}
+
+        # split data based on mask
+        self.data = {}
+        for (k, v) in data.items():
+            if k == 'names' or k == 'receptors':
+                self.data[k] = v
+                continue
+
+            sections = np.where(np.diff(data['lig_mask']))[0] + 1 \
+                if 'lig' in k \
+                else np.where(np.diff(data['pocket_mask']))[0] + 1
+            self.data[k] = [torch.from_numpy(x) for x in np.split(v, sections)]
+
+            # add number of nodes for convenience
+            if k == 'lig_mask':
+                self.data['num_lig_atoms'] = \
+                    torch.tensor([len(x) for x in self.data['lig_mask']])
+            elif k == 'pocket_mask':
+                self.data['num_pocket_nodes'] = \
+                    torch.tensor([len(x) for x in self.data['pocket_mask']])
+
+        if center:
+            for i in range(len(self.data['lig_coords'])):
+                mean = (self.data['lig_coords'][i].sum(0) +
+                        self.data['pocket_coords'][i].sum(0)) / \
+                       (len(self.data['lig_coords'][i]) + len(self.data['pocket_coords'][i]))
+                self.data['lig_coords'][i] = self.data['lig_coords'][i] - mean
+                self.data['pocket_coords'][i] = self.data['pocket_coords'][i] - mean
+
+    def __len__(self):
+        return len(self.data['names'])
+
+    def __getitem__(self, idx):
+        data = {key: val[idx] for key, val in self.data.items()}
+        if self.transform is not None:
+            data = self.transform(data)
+        return data
+
+    @staticmethod
+    def collate_fn(batch):
+        out = {}
+        for prop in batch[0].keys():
+
+            if prop == 'names' or prop == 'receptors':
+                out[prop] = [x[prop] for x in batch]
+            elif prop == 'num_lig_atoms' or prop == 'num_pocket_nodes' \
+                    or prop == 'num_virtual_atoms':
+                out[prop] = torch.tensor([x[prop] for x in batch])
+            elif 'mask' in prop:
+                # make sure indices in batch start at zero (needed for
+                # torch_scatter)
+                out[prop] = torch.cat([i * torch.ones(len(x[prop]))
+                                       for i, x in enumerate(batch)], dim=0)
+            else:
+                out[prop] = torch.cat([x[prop] for x in batch], dim=0)
+
+        return out

environment.yaml

@@ -0,0 +1,29 @@
+name: diffsbdd
+channels:
+  - pyg
+  - pytorch
+  - nvidia
+  - anaconda
+  - conda-forge
+  - defaults
+dependencies:
+  - python=3.10.4
+  - pip=24.2
+  - pytorch=2.0.1=*cuda11.8*
+  - cudatoolkit=11.8
+  - pytorch-lightning=1.8.4
+  - wandb=0.13.1
+  - rdkit=2022.03.2
+  - biopython=1.79
+  - imageio=2.21.2
+  - scipy=1.13.1
+  - pytorch-scatter=2.1.2
+  - networkx=3.3
+  - numpy=1.26.4
+  - openbabel=3.1.1
+  - pandas=2.2.2  
+  - seaborn=0.13.2
+  - torchmetrics=1.4.2
+  - tqdm=4.66.5
+  - yaml=0.2.5
+  - protobuf=3.20.*

equivariant_diffusion/conditional_model.py

@@ -0,0 +1,746 @@
+import math
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch_scatter import scatter_add, scatter_mean
+
+import utils
+from equivariant_diffusion.en_diffusion import EnVariationalDiffusion
+
+
+class ConditionalDDPM(EnVariationalDiffusion):
+    """
+    Conditional Diffusion Module.
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        assert not self.dynamics.update_pocket_coords
+
+    def kl_prior(self, xh_lig, mask_lig, num_nodes):
+        """Computes the KL between q(z1 | x) and the prior p(z1) = Normal(0, 1).
+
+        This is essentially a lot of work for something that is in practice
+        negligible in the loss. However, you compute it so that you see it when
+        you've made a mistake in your noise schedule.
+        """
+        batch_size = len(num_nodes)
+
+        # Compute the last alpha value, alpha_T.
+        ones = torch.ones((batch_size, 1), device=xh_lig.device)
+        gamma_T = self.gamma(ones)
+        alpha_T = self.alpha(gamma_T, xh_lig)
+
+        # Compute means.
+        mu_T_lig = alpha_T[mask_lig] * xh_lig
+        mu_T_lig_x, mu_T_lig_h = \
+            mu_T_lig[:, :self.n_dims], mu_T_lig[:, self.n_dims:]
+
+        # Compute standard deviations (only batch axis for x-part, inflated for h-part).
+        sigma_T_x = self.sigma(gamma_T, mu_T_lig_x).squeeze()
+        sigma_T_h = self.sigma(gamma_T, mu_T_lig_h).squeeze()
+
+        # Compute KL for h-part.
+        zeros = torch.zeros_like(mu_T_lig_h)
+        ones = torch.ones_like(sigma_T_h)
+        mu_norm2 = self.sum_except_batch((mu_T_lig_h - zeros) ** 2, mask_lig)
+        kl_distance_h = self.gaussian_KL(mu_norm2, sigma_T_h, ones, d=1)
+
+        # Compute KL for x-part.
+        zeros = torch.zeros_like(mu_T_lig_x)
+        ones = torch.ones_like(sigma_T_x)
+        mu_norm2 = self.sum_except_batch((mu_T_lig_x - zeros) ** 2, mask_lig)
+        subspace_d = self.subspace_dimensionality(num_nodes)
+        kl_distance_x = self.gaussian_KL(mu_norm2, sigma_T_x, ones, subspace_d)
+
+        return kl_distance_x + kl_distance_h
+
+    def log_pxh_given_z0_without_constants(self, ligand, z_0_lig, eps_lig,
+                                           net_out_lig, gamma_0, epsilon=1e-10):
+
+        # Discrete properties are predicted directly from z_t.
+        z_h_lig = z_0_lig[:, self.n_dims:]
+
+        # Take only part over x.
+        eps_lig_x = eps_lig[:, :self.n_dims]
+        net_lig_x = net_out_lig[:, :self.n_dims]
+
+        # Compute sigma_0 and rescale to the integer scale of the data.
+        sigma_0 = self.sigma(gamma_0, target_tensor=z_0_lig)
+        sigma_0_cat = sigma_0 * self.norm_values[1]
+
+        # Computes the error for the distribution
+        # N(x | 1 / alpha_0 z_0 + sigma_0/alpha_0 eps_0, sigma_0 / alpha_0),
+        # the weighting in the epsilon parametrization is exactly '1'.
+        squared_error = (eps_lig_x - net_lig_x) ** 2
+        if self.vnode_idx is not None:
+            # coordinates of virtual atoms should not contribute to the error
+            squared_error[ligand['one_hot'][:, self.vnode_idx].bool(), :self.n_dims] = 0
+        log_p_x_given_z0_without_constants_ligand = -0.5 * (
+            self.sum_except_batch(squared_error, ligand['mask'])
+        )
+
+        # Compute delta indicator masks.
+        # un-normalize
+        ligand_onehot = ligand['one_hot'] * self.norm_values[1] + self.norm_biases[1]
+
+        estimated_ligand_onehot = z_h_lig * self.norm_values[1] + self.norm_biases[1]
+
+        # Centered h_cat around 1, since onehot encoded.
+        centered_ligand_onehot = estimated_ligand_onehot - 1
+
+        # Compute integrals from 0.5 to 1.5 of the normal distribution
+        # N(mean=z_h_cat, stdev=sigma_0_cat)
+        log_ph_cat_proportional_ligand = torch.log(
+            self.cdf_standard_gaussian((centered_ligand_onehot + 0.5) / sigma_0_cat[ligand['mask']])
+            - self.cdf_standard_gaussian((centered_ligand_onehot - 0.5) / sigma_0_cat[ligand['mask']])
+            + epsilon
+        )
+
+        # Normalize the distribution over the categories.
+        log_Z = torch.logsumexp(log_ph_cat_proportional_ligand, dim=1,
+                                keepdim=True)
+        log_probabilities_ligand = log_ph_cat_proportional_ligand - log_Z
+
+        # Select the log_prob of the current category using the onehot
+        # representation.
+        log_ph_given_z0_ligand = self.sum_except_batch(
+            log_probabilities_ligand * ligand_onehot, ligand['mask'])
+
+        return log_p_x_given_z0_without_constants_ligand, log_ph_given_z0_ligand
+
+    def sample_p_xh_given_z0(self, z0_lig, xh0_pocket, lig_mask, pocket_mask,
+                             batch_size, fix_noise=False):
+        """Samples x ~ p(x|z0)."""
+        t_zeros = torch.zeros(size=(batch_size, 1), device=z0_lig.device)
+        gamma_0 = self.gamma(t_zeros)
+        # Computes sqrt(sigma_0^2 / alpha_0^2)
+        sigma_x = self.SNR(-0.5 * gamma_0)
+        net_out_lig, _ = self.dynamics(
+            z0_lig, xh0_pocket, t_zeros, lig_mask, pocket_mask)
+
+        # Compute mu for p(zs | zt).
+        mu_x_lig = self.compute_x_pred(net_out_lig, z0_lig, gamma_0, lig_mask)
+        xh_lig, xh0_pocket = self.sample_normal_zero_com(
+            mu_x_lig, xh0_pocket, sigma_x, lig_mask, pocket_mask, fix_noise)
+
+        x_lig, h_lig = self.unnormalize(
+            xh_lig[:, :self.n_dims], z0_lig[:, self.n_dims:])
+        x_pocket, h_pocket = self.unnormalize(
+            xh0_pocket[:, :self.n_dims], xh0_pocket[:, self.n_dims:])
+
+        h_lig = F.one_hot(torch.argmax(h_lig, dim=1), self.atom_nf)
+        # h_pocket = F.one_hot(torch.argmax(h_pocket, dim=1), self.residue_nf)
+
+        return x_lig, h_lig, x_pocket, h_pocket
+
+    def sample_normal(self, *args):
+        raise NotImplementedError("Has been replaced by sample_normal_zero_com()")
+
+    def sample_normal_zero_com(self, mu_lig, xh0_pocket, sigma, lig_mask,
+                               pocket_mask, fix_noise=False):
+        """Samples from a Normal distribution."""
+        if fix_noise:
+            # bs = 1 if fix_noise else mu.size(0)
+            raise NotImplementedError("fix_noise option isn't implemented yet")
+
+        eps_lig = self.sample_gaussian(
+            size=(len(lig_mask), self.n_dims + self.atom_nf),
+            device=lig_mask.device)
+
+        out_lig = mu_lig + sigma[lig_mask] * eps_lig
+
+        # project to COM-free subspace
+        xh_pocket = xh0_pocket.detach().clone()
+        out_lig[:, :self.n_dims], xh_pocket[:, :self.n_dims] = \
+            self.remove_mean_batch(out_lig[:, :self.n_dims],
+                                   xh0_pocket[:, :self.n_dims],
+                                   lig_mask, pocket_mask)
+
+        return out_lig, xh_pocket
+
+    def noised_representation(self, xh_lig, xh0_pocket, lig_mask, pocket_mask,
+                              gamma_t):
+        # Compute alpha_t and sigma_t from gamma.
+        alpha_t = self.alpha(gamma_t, xh_lig)
+        sigma_t = self.sigma(gamma_t, xh_lig)
+
+        # Sample zt ~ Normal(alpha_t x, sigma_t)
+        eps_lig = self.sample_gaussian(
+            size=(len(lig_mask), self.n_dims + self.atom_nf),
+            device=lig_mask.device)
+
+        # Sample z_t given x, h for timestep t, from q(z_t | x, h)
+        z_t_lig = alpha_t[lig_mask] * xh_lig + sigma_t[lig_mask] * eps_lig
+
+        # project to COM-free subspace
+        xh_pocket = xh0_pocket.detach().clone()
+        z_t_lig[:, :self.n_dims], xh_pocket[:, :self.n_dims] = \
+            self.remove_mean_batch(z_t_lig[:, :self.n_dims],
+                                   xh_pocket[:, :self.n_dims],
+                                   lig_mask, pocket_mask)
+
+        return z_t_lig, xh_pocket, eps_lig
+
+    def log_pN(self, N_lig, N_pocket):
+        """
+        Prior on the sample size for computing
+        log p(x,h,N) = log p(x,h|N) + log p(N), where log p(x,h|N) is the
+        model's output
+        Args:
+            N: array of sample sizes
+        Returns:
+            log p(N)
+        """
+        log_pN = self.size_distribution.log_prob_n1_given_n2(N_lig, N_pocket)
+        return log_pN
+
+    def delta_log_px(self, num_nodes):
+        return -self.subspace_dimensionality(num_nodes) * \
+               np.log(self.norm_values[0])
+
+    def forward(self, ligand, pocket, return_info=False):
+        """
+        Computes the loss and NLL terms
+        """
+        # Normalize data, take into account volume change in x.
+        ligand, pocket = self.normalize(ligand, pocket)
+
+        # Likelihood change due to normalization
+        # if self.vnode_idx is not None:
+        #     delta_log_px = self.delta_log_px(ligand['size'] - ligand['num_virtual_atoms'] + pocket['size'])
+        # else:
+        delta_log_px = self.delta_log_px(ligand['size'])
+
+        # Sample a timestep t for each example in batch
+        # At evaluation time, loss_0 will be computed separately to decrease
+        # variance in the estimator (costs two forward passes)
+        lowest_t = 0 if self.training else 1
+        t_int = torch.randint(
+            lowest_t, self.T + 1, size=(ligand['size'].size(0), 1),
+            device=ligand['x'].device).float()
+        s_int = t_int - 1  # previous timestep
+
+        # Masks: important to compute log p(x | z0).
+        t_is_zero = (t_int == 0).float()
+        t_is_not_zero = 1 - t_is_zero
+
+        # Normalize t to [0, 1]. Note that the negative
+        # step of s will never be used, since then p(x | z0) is computed.
+        s = s_int / self.T
+        t = t_int / self.T
+
+        # Compute gamma_s and gamma_t via the network.
+        gamma_s = self.inflate_batch_array(self.gamma(s), ligand['x'])
+        gamma_t = self.inflate_batch_array(self.gamma(t), ligand['x'])
+
+        # Concatenate x, and h[categorical].
+        xh0_lig = torch.cat([ligand['x'], ligand['one_hot']], dim=1)
+        xh0_pocket = torch.cat([pocket['x'], pocket['one_hot']], dim=1)
+
+        # Center the input nodes
+        xh0_lig[:, :self.n_dims], xh0_pocket[:, :self.n_dims] = \
+            self.remove_mean_batch(xh0_lig[:, :self.n_dims],
+                                   xh0_pocket[:, :self.n_dims],
+                                   ligand['mask'], pocket['mask'])
+
+        # Find noised representation
+        z_t_lig, xh_pocket, eps_t_lig = \
+            self.noised_representation(xh0_lig, xh0_pocket, ligand['mask'],
+                                       pocket['mask'], gamma_t)
+
+        # Neural net prediction.
+        net_out_lig, _ = self.dynamics(
+            z_t_lig, xh_pocket, t, ligand['mask'], pocket['mask'])
+
+        # For LJ loss term
+        # xh_lig_hat does not need to be zero-centered as it is only used for
+        # computing relative distances
+        xh_lig_hat = self.xh_given_zt_and_epsilon(z_t_lig, net_out_lig, gamma_t,
+                                                  ligand['mask'])
+
+        # Compute the L2 error.
+        squared_error = (eps_t_lig - net_out_lig) ** 2
+        if self.vnode_idx is not None:
+            # coordinates of virtual atoms should not contribute to the error
+            squared_error[ligand['one_hot'][:, self.vnode_idx].bool(), :self.n_dims] = 0
+        error_t_lig = self.sum_except_batch(squared_error, ligand['mask'])
+
+        # Compute weighting with SNR: (1 - SNR(s-t)) for epsilon parametrization
+        SNR_weight = (1 - self.SNR(gamma_s - gamma_t)).squeeze(1)
+        assert error_t_lig.size() == SNR_weight.size()
+
+        # The _constants_ depending on sigma_0 from the
+        # cross entropy term E_q(z0 | x) [log p(x | z0)].
+        neg_log_constants = -self.log_constants_p_x_given_z0(
+            n_nodes=ligand['size'], device=error_t_lig.device)
+
+        # The KL between q(zT | x) and p(zT) = Normal(0, 1).
+        # Should be close to zero.
+        kl_prior = self.kl_prior(xh0_lig, ligand['mask'], ligand['size'])
+
+        if self.training:
+            # Computes the L_0 term (even if gamma_t is not actually gamma_0)
+            # and this will later be selected via masking.
+            log_p_x_given_z0_without_constants_ligand, log_ph_given_z0 = \
+                self.log_pxh_given_z0_without_constants(
+                    ligand, z_t_lig, eps_t_lig, net_out_lig, gamma_t)
+
+            loss_0_x_ligand = -log_p_x_given_z0_without_constants_ligand * \
+                              t_is_zero.squeeze()
+            loss_0_h = -log_ph_given_z0 * t_is_zero.squeeze()
+
+            # apply t_is_zero mask
+            error_t_lig = error_t_lig * t_is_not_zero.squeeze()
+
+        else:
+            # Compute noise values for t = 0.
+            t_zeros = torch.zeros_like(s)
+            gamma_0 = self.inflate_batch_array(self.gamma(t_zeros), ligand['x'])
+
+            # Sample z_0 given x, h for timestep t, from q(z_t | x, h)
+            z_0_lig, xh_pocket, eps_0_lig = \
+                self.noised_representation(xh0_lig, xh0_pocket, ligand['mask'],
+                                           pocket['mask'], gamma_0)
+
+            net_out_0_lig, _ = self.dynamics(
+                z_0_lig, xh_pocket, t_zeros, ligand['mask'], pocket['mask'])
+
+            log_p_x_given_z0_without_constants_ligand, log_ph_given_z0 = \
+                self.log_pxh_given_z0_without_constants(
+                    ligand, z_0_lig, eps_0_lig, net_out_0_lig, gamma_0)
+            loss_0_x_ligand = -log_p_x_given_z0_without_constants_ligand
+            loss_0_h = -log_ph_given_z0
+
+        # sample size prior
+        log_pN = self.log_pN(ligand['size'], pocket['size'])
+
+        info = {
+            'eps_hat_lig_x': scatter_mean(
+                net_out_lig[:, :self.n_dims].abs().mean(1), ligand['mask'],
+                dim=0).mean(),
+            'eps_hat_lig_h': scatter_mean(
+                net_out_lig[:, self.n_dims:].abs().mean(1), ligand['mask'],
+                dim=0).mean(),
+        }
+        loss_terms = (delta_log_px, error_t_lig, torch.tensor(0.0), SNR_weight,
+                      loss_0_x_ligand, torch.tensor(0.0), loss_0_h,
+                      neg_log_constants, kl_prior, log_pN,
+                      t_int.squeeze(), xh_lig_hat)
+        return (*loss_terms, info) if return_info else loss_terms
+    
+    def partially_noised_ligand(self, ligand, pocket, noising_steps):
+        """
+        Partially noises a ligand to be later denoised.
+        """
+
+        # Inflate timestep into an array
+        t_int = torch.ones(size=(ligand['size'].size(0), 1),
+            device=ligand['x'].device).float() * noising_steps
+
+        # Normalize t to [0, 1].
+        t = t_int / self.T
+
+        # Compute gamma_s and gamma_t via the network.
+        gamma_t = self.inflate_batch_array(self.gamma(t), ligand['x'])
+
+        # Concatenate x, and h[categorical].
+        xh0_lig = torch.cat([ligand['x'], ligand['one_hot']], dim=1)
+        xh0_pocket = torch.cat([pocket['x'], pocket['one_hot']], dim=1)
+
+        # Center the input nodes
+        xh0_lig[:, :self.n_dims], xh0_pocket[:, :self.n_dims] = \
+            self.remove_mean_batch(xh0_lig[:, :self.n_dims],
+                                   xh0_pocket[:, :self.n_dims],
+                                   ligand['mask'], pocket['mask'])
+
+        # Find noised representation
+        z_t_lig, xh_pocket, eps_t_lig = \
+            self.noised_representation(xh0_lig, xh0_pocket, ligand['mask'],
+                                       pocket['mask'], gamma_t)
+            
+        return z_t_lig, xh_pocket, eps_t_lig
+
+    def diversify(self, ligand, pocket, noising_steps):
+        """
+        Diversifies a set of ligands via noise-denoising
+        """
+
+        # Normalize data, take into account volume change in x.
+        ligand, pocket = self.normalize(ligand, pocket)
+
+        z_lig, xh_pocket, _ = self.partially_noised_ligand(ligand, pocket, noising_steps)
+
+        timesteps = self.T
+        n_samples = len(pocket['size'])
+        device = pocket['x'].device
+
+        # xh0_pocket is the original pocket while xh_pocket might be a
+        # translated version of it
+        xh0_pocket = torch.cat([pocket['x'], pocket['one_hot']], dim=1)
+
+        lig_mask = ligand['mask']
+
+        self.assert_mean_zero_with_mask(z_lig[:, :self.n_dims], lig_mask)
+
+        # Iteratively sample p(z_s | z_t) for t = 1, ..., T, with s = t - 1.
+
+        for s in reversed(range(0, noising_steps)):
+            s_array = torch.full((n_samples, 1), fill_value=s,
+                                 device=z_lig.device)
+            t_array = s_array + 1
+            s_array = s_array / timesteps
+            t_array = t_array / timesteps
+
+            z_lig, xh_pocket = self.sample_p_zs_given_zt(
+                s_array, t_array, z_lig.detach(), xh_pocket.detach(), lig_mask, pocket['mask'])
+
+        # Finally sample p(x, h | z_0).
+        x_lig, h_lig, x_pocket, h_pocket = self.sample_p_xh_given_z0(
+            z_lig, xh_pocket, lig_mask, pocket['mask'], n_samples)
+
+        self.assert_mean_zero_with_mask(x_lig, lig_mask)
+
+        # Overwrite last frame with the resulting x and h.
+        out_lig = torch.cat([x_lig, h_lig], dim=1)
+        out_pocket = torch.cat([x_pocket, h_pocket], dim=1)
+
+        # remove frame dimension if only the final molecule is returned
+        return out_lig, out_pocket, lig_mask, pocket['mask']
+
+
+    def xh_given_zt_and_epsilon(self, z_t, epsilon, gamma_t, batch_mask):
+        """ Equation (7) in the EDM paper """
+        alpha_t = self.alpha(gamma_t, z_t)
+        sigma_t = self.sigma(gamma_t, z_t)
+        xh = z_t / alpha_t[batch_mask] - epsilon * sigma_t[batch_mask] / \
+             alpha_t[batch_mask]
+        return xh
+
+    def sample_p_zt_given_zs(self, zs_lig, xh0_pocket, ligand_mask, pocket_mask,
+                             gamma_t, gamma_s, fix_noise=False):
+        sigma2_t_given_s, sigma_t_given_s, alpha_t_given_s = \
+            self.sigma_and_alpha_t_given_s(gamma_t, gamma_s, zs_lig)
+
+        mu_lig = alpha_t_given_s[ligand_mask] * zs_lig
+        zt_lig, xh0_pocket = self.sample_normal_zero_com(
+            mu_lig, xh0_pocket, sigma_t_given_s, ligand_mask, pocket_mask,
+            fix_noise)
+
+        return zt_lig, xh0_pocket
+
+    def sample_p_zs_given_zt(self, s, t, zt_lig, xh0_pocket, ligand_mask,
+                             pocket_mask, fix_noise=False):
+        """Samples from zs ~ p(zs | zt). Only used during sampling."""
+        gamma_s = self.gamma(s)
+        gamma_t = self.gamma(t)
+
+        sigma2_t_given_s, sigma_t_given_s, alpha_t_given_s = \
+            self.sigma_and_alpha_t_given_s(gamma_t, gamma_s, zt_lig)
+
+        sigma_s = self.sigma(gamma_s, target_tensor=zt_lig)
+        sigma_t = self.sigma(gamma_t, target_tensor=zt_lig)
+
+        # Neural net prediction.
+        eps_t_lig, _ = self.dynamics(
+            zt_lig, xh0_pocket, t, ligand_mask, pocket_mask)
+
+        # Compute mu for p(zs | zt).
+        # Note: mu_{t->s} = 1 / alpha_{t|s} z_t - sigma_{t|s}^2 / sigma_t / alpha_{t|s} epsilon
+        # follows from the definition of mu_{t->s} and Equ. (7) in the EDM paper
+        mu_lig = zt_lig / alpha_t_given_s[ligand_mask] - \
+                 (sigma2_t_given_s / alpha_t_given_s / sigma_t)[ligand_mask] * \
+                 eps_t_lig
+
+        # Compute sigma for p(zs | zt).
+        sigma = sigma_t_given_s * sigma_s / sigma_t
+
+        # Sample zs given the parameters derived from zt.
+        zs_lig, xh0_pocket = self.sample_normal_zero_com(
+            mu_lig, xh0_pocket, sigma, ligand_mask, pocket_mask, fix_noise)
+
+        self.assert_mean_zero_with_mask(zt_lig[:, :self.n_dims], ligand_mask)
+
+        return zs_lig, xh0_pocket
+
+    def sample_combined_position_feature_noise(self, lig_indices, xh0_pocket,
+                                               pocket_indices):
+        """
+        Samples mean-centered normal noise for z_x, and standard normal noise
+        for z_h.
+        """
+        raise NotImplementedError("Use sample_normal_zero_com() instead.")
+
+    def sample(self, *args):
+        raise NotImplementedError("Conditional model does not support sampling "
+                                  "without given pocket.")
+
+    @torch.no_grad()
+    def sample_given_pocket(self, pocket, num_nodes_lig, return_frames=1,
+                            timesteps=None):
+        """
+        Draw samples from the generative model. Optionally, return intermediate
+        states for visualization purposes.
+        """
+        timesteps = self.T if timesteps is None else timesteps
+        assert 0 < return_frames <= timesteps
+        assert timesteps % return_frames == 0
+
+        n_samples = len(pocket['size'])
+        device = pocket['x'].device
+
+        _, pocket = self.normalize(pocket=pocket)
+
+        # xh0_pocket is the original pocket while xh_pocket might be a
+        # translated version of it
+        xh0_pocket = torch.cat([pocket['x'], pocket['one_hot']], dim=1)
+
+        lig_mask = utils.num_nodes_to_batch_mask(
+            n_samples, num_nodes_lig, device)
+
+        # Sample from Normal distribution in the pocket center
+        mu_lig_x = scatter_mean(pocket['x'], pocket['mask'], dim=0)
+        mu_lig_h = torch.zeros((n_samples, self.atom_nf), device=device)
+        mu_lig = torch.cat((mu_lig_x, mu_lig_h), dim=1)[lig_mask]
+        sigma = torch.ones_like(pocket['size']).unsqueeze(1)
+
+        z_lig, xh_pocket = self.sample_normal_zero_com(
+            mu_lig, xh0_pocket, sigma, lig_mask, pocket['mask'])
+
+        self.assert_mean_zero_with_mask(z_lig[:, :self.n_dims], lig_mask)
+
+        out_lig = torch.zeros((return_frames,) + z_lig.size(),
+                              device=z_lig.device)
+        out_pocket = torch.zeros((return_frames,) + xh_pocket.size(),
+                                 device=device)
+
+        # Iteratively sample p(z_s | z_t) for t = 1, ..., T, with s = t - 1.
+        for s in reversed(range(0, timesteps)):
+            s_array = torch.full((n_samples, 1), fill_value=s,
+                                 device=z_lig.device)
+            t_array = s_array + 1
+            s_array = s_array / timesteps
+            t_array = t_array / timesteps
+
+            z_lig, xh_pocket = self.sample_p_zs_given_zt(
+                s_array, t_array, z_lig, xh_pocket, lig_mask, pocket['mask'])
+
+            # save frame
+            if (s * return_frames) % timesteps == 0:
+                idx = (s * return_frames) // timesteps
+                out_lig[idx], out_pocket[idx] = \
+                    self.unnormalize_z(z_lig, xh_pocket)
+
+        # Finally sample p(x, h | z_0).
+        x_lig, h_lig, x_pocket, h_pocket = self.sample_p_xh_given_z0(
+            z_lig, xh_pocket, lig_mask, pocket['mask'], n_samples)
+
+        self.assert_mean_zero_with_mask(x_lig, lig_mask)
+
+        # Correct CoM drift for examples without intermediate states
+        if return_frames == 1:
+            max_cog = scatter_add(x_lig, lig_mask, dim=0).abs().max().item()
+            if max_cog > 5e-2:
+                print(f'Warning CoG drift with error {max_cog:.3f}. Projecting '
+                      f'the positions down.')
+                x_lig, x_pocket = self.remove_mean_batch(
+                    x_lig, x_pocket, lig_mask, pocket['mask'])
+
+        # Overwrite last frame with the resulting x and h.
+        out_lig[0] = torch.cat([x_lig, h_lig], dim=1)
+        out_pocket[0] = torch.cat([x_pocket, h_pocket], dim=1)
+
+        # remove frame dimension if only the final molecule is returned
+        return out_lig.squeeze(0), out_pocket.squeeze(0), lig_mask, \
+               pocket['mask']
+
+    @torch.no_grad()
+    def inpaint(self, ligand, pocket, lig_fixed, resamplings=1, return_frames=1,
+                timesteps=None, center='ligand'):
+        """
+        Draw samples from the generative model while fixing parts of the input.
+        Optionally, return intermediate states for visualization purposes.
+        Inspired by Algorithm 1 in:
+        Lugmayr, Andreas, et al.
+        "Repaint: Inpainting using denoising diffusion probabilistic models."
+        Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern
+        Recognition. 2022.
+        """
+        timesteps = self.T if timesteps is None else timesteps
+        assert 0 < return_frames <= timesteps
+        assert timesteps % return_frames == 0
+
+        if len(lig_fixed.size()) == 1:
+            lig_fixed = lig_fixed.unsqueeze(1)
+
+        n_samples = len(ligand['size'])
+        device = pocket['x'].device
+
+        # Normalize
+        ligand, pocket = self.normalize(ligand, pocket)
+
+        # xh0_pocket is the original pocket while xh_pocket might be a
+        # translated version of it
+        xh0_pocket = torch.cat([pocket['x'], pocket['one_hot']], dim=1)
+        com_pocket_0 = scatter_mean(pocket['x'], pocket['mask'], dim=0)
+        xh0_ligand = torch.cat([ligand['x'], ligand['one_hot']], dim=1)
+        xh_ligand = xh0_ligand.clone()
+
+        # Center initial system, subtract COM of known parts
+        if center == 'ligand':
+            mean_known = scatter_mean(ligand['x'][lig_fixed.bool().view(-1)],
+                                      ligand['mask'][lig_fixed.bool().view(-1)],
+                                      dim=0)
+        elif center == 'pocket':
+            mean_known = scatter_mean(pocket['x'], pocket['mask'], dim=0)
+        else:
+            raise NotImplementedError(
+                f"Centering option {center} not implemented")
+
+        # Sample from Normal distribution in the ligand center
+        mu_lig_x = mean_known
+        mu_lig_h = torch.zeros((n_samples, self.atom_nf), device=device)
+        mu_lig = torch.cat((mu_lig_x, mu_lig_h), dim=1)[ligand['mask']]
+        sigma = torch.ones_like(pocket['size']).unsqueeze(1)
+
+        z_lig, xh_pocket = self.sample_normal_zero_com(
+            mu_lig, xh0_pocket, sigma, ligand['mask'], pocket['mask'])
+
+        # Output tensors
+        out_lig = torch.zeros((return_frames,) + z_lig.size(),
+                              device=z_lig.device)
+        out_pocket = torch.zeros((return_frames,) + xh_pocket.size(),
+                                 device=device)
+
+        # Iteratively sample with resampling iterations
+        for s in reversed(range(0, timesteps)):
+
+            # resampling iterations
+            for u in range(resamplings):
+
+                # Denoise one time step: t -> s
+                s_array = torch.full((n_samples, 1), fill_value=s,
+                                     device=device)
+                t_array = s_array + 1
+                s_array = s_array / timesteps
+                t_array = t_array / timesteps
+
+                gamma_t = self.gamma(t_array)
+                gamma_s = self.gamma(s_array)
+
+                # sample inpainted part
+                z_lig_unknown, xh_pocket = self.sample_p_zs_given_zt(
+                    s_array, t_array, z_lig, xh_pocket, ligand['mask'],
+                    pocket['mask'])
+
+                # sample known nodes from the input
+                com_pocket = scatter_mean(xh_pocket[:, :self.n_dims],
+                                          pocket['mask'], dim=0)
+                xh_ligand[:, :self.n_dims] = \
+                    ligand['x'] + (com_pocket - com_pocket_0)[ligand['mask']]
+                z_lig_known, xh_pocket, _ = self.noised_representation(
+                    xh_ligand, xh_pocket, ligand['mask'], pocket['mask'],
+                    gamma_s)
+
+                # move center of mass of the noised part to the center of mass
+                # of the corresponding denoised part before combining them
+                # -> the resulting system should be COM-free
+                com_noised = scatter_mean(
+                    z_lig_known[lig_fixed.bool().view(-1)][:, :self.n_dims],
+                    ligand['mask'][lig_fixed.bool().view(-1)], dim=0)
+                com_denoised = scatter_mean(
+                    z_lig_unknown[lig_fixed.bool().view(-1)][:, :self.n_dims],
+                    ligand['mask'][lig_fixed.bool().view(-1)], dim=0)
+                dx = com_denoised - com_noised
+                z_lig_known[:, :self.n_dims] = z_lig_known[:, :self.n_dims] + dx[ligand['mask']]
+                xh_pocket[:, :self.n_dims] = xh_pocket[:, :self.n_dims] + dx[pocket['mask']]
+
+                # combine
+                z_lig = z_lig_known * lig_fixed + z_lig_unknown * (
+                            1 - lig_fixed)
+
+                if u < resamplings - 1:
+                    # Noise the sample
+                    z_lig, xh_pocket = self.sample_p_zt_given_zs(
+                        z_lig, xh_pocket, ligand['mask'], pocket['mask'],
+                        gamma_t, gamma_s)
+
+                # save frame at the end of a resampling cycle
+                if u == resamplings - 1:
+                    if (s * return_frames) % timesteps == 0:
+                        idx = (s * return_frames) // timesteps
+
+                        out_lig[idx], out_pocket[idx] = \
+                            self.unnormalize_z(z_lig, xh_pocket)
+
+        # Finally sample p(x, h | z_0).
+        x_lig, h_lig, x_pocket, h_pocket = self.sample_p_xh_given_z0(
+            z_lig, xh_pocket, ligand['mask'], pocket['mask'], n_samples)
+
+        # Overwrite last frame with the resulting x and h.
+        out_lig[0] = torch.cat([x_lig, h_lig], dim=1)
+        out_pocket[0] = torch.cat([x_pocket, h_pocket], dim=1)
+
+        # remove frame dimension if only the final molecule is returned
+        return out_lig.squeeze(0), out_pocket.squeeze(0), ligand['mask'], \
+               pocket['mask']
+
+    @classmethod
+    def remove_mean_batch(cls, x_lig, x_pocket, lig_indices, pocket_indices):
+
+        # Just subtract the center of mass of the sampled part
+        mean = scatter_mean(x_lig, lig_indices, dim=0)
+
+        x_lig = x_lig - mean[lig_indices]
+        x_pocket = x_pocket - mean[pocket_indices]
+        return x_lig, x_pocket
+
+
+# ------------------------------------------------------------------------------
+# The same model without subspace-trick
+# ------------------------------------------------------------------------------
+class SimpleConditionalDDPM(ConditionalDDPM):
+    """
+    Simpler conditional diffusion module without subspace-trick.
+    - rotational equivariance is guaranteed by construction
+    - translationally equivariant likelihood is achieved by first mapping
+      samples to a space where the context is COM-free and evaluating the
+      likelihood there
+    - molecule generation is equivariant because we can first sample in the
+      space where the context is COM-free and translate the whole system back to
+      the original position of the context later
+    """
+    def subspace_dimensionality(self, input_size):
+        """ Override because we don't use the linear subspace anymore. """
+        return input_size * self.n_dims
+
+    @classmethod
+    def remove_mean_batch(cls, x_lig, x_pocket, lig_indices, pocket_indices):
+        """ Hacky way of removing the centering steps without changing too much
+        code. """
+        return x_lig, x_pocket
+
+    @staticmethod
+    def assert_mean_zero_with_mask(x, node_mask, eps=1e-10):
+        return
+
+    def forward(self, ligand, pocket, return_info=False):
+
+        # Subtract pocket center of mass
+        pocket_com = scatter_mean(pocket['x'], pocket['mask'], dim=0)
+        ligand['x'] = ligand['x'] - pocket_com[ligand['mask']]
+        pocket['x'] = pocket['x'] - pocket_com[pocket['mask']]
+
+        return super(SimpleConditionalDDPM, self).forward(
+            ligand, pocket, return_info)
+
+    @torch.no_grad()
+    def sample_given_pocket(self, pocket, num_nodes_lig, return_frames=1,
+                            timesteps=None):
+
+        # Subtract pocket center of mass
+        pocket_com = scatter_mean(pocket['x'], pocket['mask'], dim=0)
+        pocket['x'] = pocket['x'] - pocket_com[pocket['mask']]
+
+        return super(SimpleConditionalDDPM, self).sample_given_pocket(
+            pocket, num_nodes_lig, return_frames, timesteps)

equivariant_diffusion/dynamics.py

@@ -0,0 +1,187 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from equivariant_diffusion.egnn_new import EGNN, GNN
+from equivariant_diffusion.en_diffusion import EnVariationalDiffusion
+remove_mean_batch = EnVariationalDiffusion.remove_mean_batch
+import numpy as np
+
+
+class EGNNDynamics(nn.Module):
+    def __init__(self, atom_nf, residue_nf,
+                 n_dims, joint_nf=16, hidden_nf=64, device='cpu',
+                 act_fn=torch.nn.SiLU(), n_layers=4, attention=False,
+                 condition_time=True, tanh=False, mode='egnn_dynamics',
+                 norm_constant=0, inv_sublayers=2, sin_embedding=False,
+                 normalization_factor=100, aggregation_method='sum',
+                 update_pocket_coords=True, edge_cutoff_ligand=None,
+                 edge_cutoff_pocket=None, edge_cutoff_interaction=None,
+                 reflection_equivariant=True, edge_embedding_dim=None):
+        super().__init__()
+        self.mode = mode
+        self.edge_cutoff_l = edge_cutoff_ligand
+        self.edge_cutoff_p = edge_cutoff_pocket
+        self.edge_cutoff_i = edge_cutoff_interaction
+        self.edge_nf = edge_embedding_dim
+
+        self.atom_encoder = nn.Sequential(
+            nn.Linear(atom_nf, 2 * atom_nf),
+            act_fn,
+            nn.Linear(2 * atom_nf, joint_nf)
+        )
+
+        self.atom_decoder = nn.Sequential(
+            nn.Linear(joint_nf, 2 * atom_nf),
+            act_fn,
+            nn.Linear(2 * atom_nf, atom_nf)
+        )
+
+        self.residue_encoder = nn.Sequential(
+            nn.Linear(residue_nf, 2 * residue_nf),
+            act_fn,
+            nn.Linear(2 * residue_nf, joint_nf)
+        )
+
+        self.residue_decoder = nn.Sequential(
+            nn.Linear(joint_nf, 2 * residue_nf),
+            act_fn,
+            nn.Linear(2 * residue_nf, residue_nf)
+        )
+
+        self.edge_embedding = nn.Embedding(3, self.edge_nf) \
+            if self.edge_nf is not None else None
+        self.edge_nf = 0 if self.edge_nf is None else self.edge_nf
+
+        if condition_time:
+            dynamics_node_nf = joint_nf + 1
+        else:
+            print('Warning: dynamics model is _not_ conditioned on time.')
+            dynamics_node_nf = joint_nf
+
+        if mode == 'egnn_dynamics':
+            self.egnn = EGNN(
+                in_node_nf=dynamics_node_nf, in_edge_nf=self.edge_nf,
+                hidden_nf=hidden_nf, device=device, act_fn=act_fn,
+                n_layers=n_layers, attention=attention, tanh=tanh,
+                norm_constant=norm_constant,
+                inv_sublayers=inv_sublayers, sin_embedding=sin_embedding,
+                normalization_factor=normalization_factor,
+                aggregation_method=aggregation_method,
+                reflection_equiv=reflection_equivariant
+            )
+            self.node_nf = dynamics_node_nf
+            self.update_pocket_coords = update_pocket_coords
+
+        elif mode == 'gnn_dynamics':
+            self.gnn = GNN(
+                in_node_nf=dynamics_node_nf + n_dims, in_edge_nf=self.edge_nf,
+                hidden_nf=hidden_nf, out_node_nf=n_dims + dynamics_node_nf,
+                device=device, act_fn=act_fn, n_layers=n_layers,
+                attention=attention, normalization_factor=normalization_factor,
+                aggregation_method=aggregation_method)
+
+        self.device = device
+        self.n_dims = n_dims
+        self.condition_time = condition_time
+
+    def forward(self, xh_atoms, xh_residues, t, mask_atoms, mask_residues):
+
+        x_atoms = xh_atoms[:, :self.n_dims].clone()
+        h_atoms = xh_atoms[:, self.n_dims:].clone()
+
+        x_residues = xh_residues[:, :self.n_dims].clone()
+        h_residues = xh_residues[:, self.n_dims:].clone()
+
+        # embed atom features and residue features in a shared space
+        h_atoms = self.atom_encoder(h_atoms)
+        h_residues = self.residue_encoder(h_residues)
+
+        # combine the two node types
+        x = torch.cat((x_atoms, x_residues), dim=0)
+        h = torch.cat((h_atoms, h_residues), dim=0)
+        mask = torch.cat([mask_atoms, mask_residues])
+
+        if self.condition_time:
+            if np.prod(t.size()) == 1:
+                # t is the same for all elements in batch.
+                h_time = torch.empty_like(h[:, 0:1]).fill_(t.item())
+            else:
+                # t is different over the batch dimension.
+                h_time = t[mask]
+            h = torch.cat([h, h_time], dim=1)
+
+        # get edges of a complete graph
+        edges = self.get_edges(mask_atoms, mask_residues, x_atoms, x_residues)
+        assert torch.all(mask[edges[0]] == mask[edges[1]])
+
+        # Get edge types
+        if self.edge_nf > 0:
+            # 0: ligand-pocket, 1: ligand-ligand, 2: pocket-pocket
+            edge_types = torch.zeros(edges.size(1), dtype=int, device=edges.device)
+            edge_types[(edges[0] < len(mask_atoms)) & (edges[1] < len(mask_atoms))] = 1
+            edge_types[(edges[0] >= len(mask_atoms)) & (edges[1] >= len(mask_atoms))] = 2
+
+            # Learnable embedding
+            edge_types = self.edge_embedding(edge_types)
+        else:
+            edge_types = None
+
+        if self.mode == 'egnn_dynamics':
+            update_coords_mask = None if self.update_pocket_coords \
+                else torch.cat((torch.ones_like(mask_atoms),
+                                torch.zeros_like(mask_residues))).unsqueeze(1)
+            h_final, x_final = self.egnn(h, x, edges,
+                                         update_coords_mask=update_coords_mask,
+                                         batch_mask=mask, edge_attr=edge_types)
+            vel = (x_final - x)
+
+        elif self.mode == 'gnn_dynamics':
+            xh = torch.cat([x, h], dim=1)
+            output = self.gnn(xh, edges, node_mask=None, edge_attr=edge_types)
+            vel = output[:, :3]
+            h_final = output[:, 3:]
+
+        else:
+            raise Exception("Wrong mode %s" % self.mode)
+
+        if self.condition_time:
+            # Slice off last dimension which represented time.
+            h_final = h_final[:, :-1]
+
+        # decode atom and residue features
+        h_final_atoms = self.atom_decoder(h_final[:len(mask_atoms)])
+        h_final_residues = self.residue_decoder(h_final[len(mask_atoms):])
+
+        if torch.any(torch.isnan(vel)):
+            if self.training:
+                vel[torch.isnan(vel)] = 0.0
+            else:
+                raise ValueError("NaN detected in EGNN output")
+
+        if self.update_pocket_coords:
+            # in case of unconditional joint distribution, include this as in
+            # the original code
+            vel = remove_mean_batch(vel, mask)
+
+        return torch.cat([vel[:len(mask_atoms)], h_final_atoms], dim=-1), \
+               torch.cat([vel[len(mask_atoms):], h_final_residues], dim=-1)
+
+    def get_edges(self, batch_mask_ligand, batch_mask_pocket, x_ligand, x_pocket):
+        adj_ligand = batch_mask_ligand[:, None] == batch_mask_ligand[None, :]
+        adj_pocket = batch_mask_pocket[:, None] == batch_mask_pocket[None, :]
+        adj_cross = batch_mask_ligand[:, None] == batch_mask_pocket[None, :]
+
+        if self.edge_cutoff_l is not None:
+            adj_ligand = adj_ligand & (torch.cdist(x_ligand, x_ligand) <= self.edge_cutoff_l)
+
+        if self.edge_cutoff_p is not None:
+            adj_pocket = adj_pocket & (torch.cdist(x_pocket, x_pocket) <= self.edge_cutoff_p)
+
+        if self.edge_cutoff_i is not None:
+            adj_cross = adj_cross & (torch.cdist(x_ligand, x_pocket) <= self.edge_cutoff_i)
+
+        adj = torch.cat((torch.cat((adj_ligand, adj_cross), dim=1),
+                         torch.cat((adj_cross.T, adj_pocket), dim=1)), dim=0)
+        edges = torch.stack(torch.where(adj), dim=0)
+
+        return edges

equivariant_diffusion/egnn_new.py

@@ -0,0 +1,335 @@
+from torch import nn
+import torch
+import math
+
+
+class GCL(nn.Module):
+    def __init__(self, input_nf, output_nf, hidden_nf, normalization_factor, aggregation_method,
+                 edges_in_d=0, nodes_att_dim=0, act_fn=nn.SiLU(), attention=False):
+        super(GCL, self).__init__()
+        input_edge = input_nf * 2
+        self.normalization_factor = normalization_factor
+        self.aggregation_method = aggregation_method
+        self.attention = attention
+
+        self.edge_mlp = nn.Sequential(
+            nn.Linear(input_edge + edges_in_d, hidden_nf),
+            act_fn,
+            nn.Linear(hidden_nf, hidden_nf),
+            act_fn)
+
+        self.node_mlp = nn.Sequential(
+            nn.Linear(hidden_nf + input_nf + nodes_att_dim, hidden_nf),
+            act_fn,
+            nn.Linear(hidden_nf, output_nf))
+
+        if self.attention:
+            self.att_mlp = nn.Sequential(
+                nn.Linear(hidden_nf, 1),
+                nn.Sigmoid())
+
+    def edge_model(self, source, target, edge_attr, edge_mask):
+        if edge_attr is None:  # Unused.
+            out = torch.cat([source, target], dim=1)
+        else:
+            out = torch.cat([source, target, edge_attr], dim=1)
+        mij = self.edge_mlp(out)
+
+        if self.attention:
+            att_val = self.att_mlp(mij)
+            out = mij * att_val
+        else:
+            out = mij
+
+        if edge_mask is not None:
+            out = out * edge_mask
+        return out, mij
+
+    def node_model(self, x, edge_index, edge_attr, node_attr):
+        row, col = edge_index
+        agg = unsorted_segment_sum(edge_attr, row, num_segments=x.size(0),
+                                   normalization_factor=self.normalization_factor,
+                                   aggregation_method=self.aggregation_method)
+        if node_attr is not None:
+            agg = torch.cat([x, agg, node_attr], dim=1)
+        else:
+            agg = torch.cat([x, agg], dim=1)
+        out = x + self.node_mlp(agg)
+        return out, agg
+
+    def forward(self, h, edge_index, edge_attr=None, node_attr=None, node_mask=None, edge_mask=None):
+        row, col = edge_index
+        edge_feat, mij = self.edge_model(h[row], h[col], edge_attr, edge_mask)
+        h, agg = self.node_model(h, edge_index, edge_feat, node_attr)
+        if node_mask is not None:
+            h = h * node_mask
+        return h, mij
+
+
+class EquivariantUpdate(nn.Module):
+    def __init__(self, hidden_nf, normalization_factor, aggregation_method,
+                 edges_in_d=1, act_fn=nn.SiLU(), tanh=False, coords_range=10.0,
+                 reflection_equiv=True):
+        super(EquivariantUpdate, self).__init__()
+        self.tanh = tanh
+        self.coords_range = coords_range
+        self.reflection_equiv = reflection_equiv
+        input_edge = hidden_nf * 2 + edges_in_d
+        layer = nn.Linear(hidden_nf, 1, bias=False)
+        torch.nn.init.xavier_uniform_(layer.weight, gain=0.001)
+        self.coord_mlp = nn.Sequential(
+            nn.Linear(input_edge, hidden_nf),
+            act_fn,
+            nn.Linear(hidden_nf, hidden_nf),
+            act_fn,
+            layer)
+        self.cross_product_mlp = nn.Sequential(
+            nn.Linear(input_edge, hidden_nf),
+            act_fn,
+            nn.Linear(hidden_nf, hidden_nf),
+            act_fn,
+            layer
+        ) if not self.reflection_equiv else None
+        self.normalization_factor = normalization_factor
+        self.aggregation_method = aggregation_method
+
+    def coord_model(self, h, coord, edge_index, coord_diff, coord_cross,
+                    edge_attr, edge_mask, update_coords_mask=None):
+        row, col = edge_index
+        input_tensor = torch.cat([h[row], h[col], edge_attr], dim=1)
+        if self.tanh:
+            trans = coord_diff * torch.tanh(self.coord_mlp(input_tensor)) * self.coords_range
+        else:
+            trans = coord_diff * self.coord_mlp(input_tensor)
+
+        if not self.reflection_equiv:
+            phi_cross = self.cross_product_mlp(input_tensor)
+            if self.tanh:
+                phi_cross = torch.tanh(phi_cross) * self.coords_range
+            trans = trans + coord_cross * phi_cross
+
+        if edge_mask is not None:
+            trans = trans * edge_mask
+
+        agg = unsorted_segment_sum(trans, row, num_segments=coord.size(0),
+                                   normalization_factor=self.normalization_factor,
+                                   aggregation_method=self.aggregation_method)
+
+        if update_coords_mask is not None:
+            agg = update_coords_mask * agg
+
+        coord = coord + agg
+        return coord
+
+    def forward(self, h, coord, edge_index, coord_diff, coord_cross,
+                edge_attr=None, node_mask=None, edge_mask=None,
+                update_coords_mask=None):
+        coord = self.coord_model(h, coord, edge_index, coord_diff, coord_cross,
+                                 edge_attr, edge_mask,
+                                 update_coords_mask=update_coords_mask)
+        if node_mask is not None:
+            coord = coord * node_mask
+        return coord
+
+
+class EquivariantBlock(nn.Module):
+    def __init__(self, hidden_nf, edge_feat_nf=2, device='cpu', act_fn=nn.SiLU(), n_layers=2, attention=True,
+                 norm_diff=True, tanh=False, coords_range=15, norm_constant=1, sin_embedding=None,
+                 normalization_factor=100, aggregation_method='sum', reflection_equiv=True):
+        super(EquivariantBlock, self).__init__()
+        self.hidden_nf = hidden_nf
+        self.device = device
+        self.n_layers = n_layers
+        self.coords_range_layer = float(coords_range)
+        self.norm_diff = norm_diff
+        self.norm_constant = norm_constant
+        self.sin_embedding = sin_embedding
+        self.normalization_factor = normalization_factor
+        self.aggregation_method = aggregation_method
+        self.reflection_equiv = reflection_equiv
+
+        for i in range(0, n_layers):
+            self.add_module("gcl_%d" % i, GCL(self.hidden_nf, self.hidden_nf, self.hidden_nf, edges_in_d=edge_feat_nf,
+                                              act_fn=act_fn, attention=attention,
+                                              normalization_factor=self.normalization_factor,
+                                              aggregation_method=self.aggregation_method))
+        self.add_module("gcl_equiv", EquivariantUpdate(hidden_nf, edges_in_d=edge_feat_nf, act_fn=nn.SiLU(), tanh=tanh,
+                                                       coords_range=self.coords_range_layer,
+                                                       normalization_factor=self.normalization_factor,
+                                                       aggregation_method=self.aggregation_method,
+                                                       reflection_equiv=self.reflection_equiv))
+        self.to(self.device)
+
+    def forward(self, h, x, edge_index, node_mask=None, edge_mask=None,
+                edge_attr=None, update_coords_mask=None, batch_mask=None):
+        # Edit Emiel: Remove velocity as input
+        distances, coord_diff = coord2diff(x, edge_index, self.norm_constant)
+        if self.reflection_equiv:
+            coord_cross = None
+        else:
+            coord_cross = coord2cross(x, edge_index, batch_mask,
+                                      self.norm_constant)
+        if self.sin_embedding is not None:
+            distances = self.sin_embedding(distances)
+        edge_attr = torch.cat([distances, edge_attr], dim=1)
+        for i in range(0, self.n_layers):
+            h, _ = self._modules["gcl_%d" % i](h, edge_index, edge_attr=edge_attr,
+                                               node_mask=node_mask, edge_mask=edge_mask)
+        x = self._modules["gcl_equiv"](h, x, edge_index, coord_diff, coord_cross, edge_attr,
+                                       node_mask, edge_mask, update_coords_mask=update_coords_mask)
+
+        # Important, the bias of the last linear might be non-zero
+        if node_mask is not None:
+            h = h * node_mask
+        return h, x
+
+
+class EGNN(nn.Module):
+    def __init__(self, in_node_nf, in_edge_nf, hidden_nf, device='cpu', act_fn=nn.SiLU(), n_layers=3, attention=False,
+                 norm_diff=True, out_node_nf=None, tanh=False, coords_range=15, norm_constant=1, inv_sublayers=2,
+                 sin_embedding=False, normalization_factor=100, aggregation_method='sum', reflection_equiv=True):
+        super(EGNN, self).__init__()
+        if out_node_nf is None:
+            out_node_nf = in_node_nf
+        self.hidden_nf = hidden_nf
+        self.device = device
+        self.n_layers = n_layers
+        self.coords_range_layer = float(coords_range/n_layers)
+        self.norm_diff = norm_diff
+        self.normalization_factor = normalization_factor
+        self.aggregation_method = aggregation_method
+        self.reflection_equiv = reflection_equiv
+
+        if sin_embedding:
+            self.sin_embedding = SinusoidsEmbeddingNew()
+            edge_feat_nf = self.sin_embedding.dim * 2
+        else:
+            self.sin_embedding = None
+            edge_feat_nf = 2
+
+        edge_feat_nf = edge_feat_nf + in_edge_nf
+
+        self.embedding = nn.Linear(in_node_nf, self.hidden_nf)
+        self.embedding_out = nn.Linear(self.hidden_nf, out_node_nf)
+        for i in range(0, n_layers):
+            self.add_module("e_block_%d" % i, EquivariantBlock(hidden_nf, edge_feat_nf=edge_feat_nf, device=device,
+                                                               act_fn=act_fn, n_layers=inv_sublayers,
+                                                               attention=attention, norm_diff=norm_diff, tanh=tanh,
+                                                               coords_range=coords_range, norm_constant=norm_constant,
+                                                               sin_embedding=self.sin_embedding,
+                                                               normalization_factor=self.normalization_factor,
+                                                               aggregation_method=self.aggregation_method,
+                                                               reflection_equiv=self.reflection_equiv))
+        self.to(self.device)
+
+    def forward(self, h, x, edge_index, node_mask=None, edge_mask=None, update_coords_mask=None,
+                batch_mask=None, edge_attr=None):
+        # Edit Emiel: Remove velocity as input
+        edge_feat, _ = coord2diff(x, edge_index)
+        if self.sin_embedding is not None:
+            edge_feat = self.sin_embedding(edge_feat)
+        if edge_attr is not None:
+            edge_feat = torch.cat([edge_feat, edge_attr], dim=1)
+        h = self.embedding(h)
+        for i in range(0, self.n_layers):
+            h, x = self._modules["e_block_%d" % i](
+                h, x, edge_index, node_mask=node_mask, edge_mask=edge_mask,
+                edge_attr=edge_feat, update_coords_mask=update_coords_mask,
+                batch_mask=batch_mask)
+
+        # Important, the bias of the last linear might be non-zero
+        h = self.embedding_out(h)
+        if node_mask is not None:
+            h = h * node_mask
+        return h, x
+
+
+class GNN(nn.Module):
+    def __init__(self, in_node_nf, in_edge_nf, hidden_nf, aggregation_method='sum', device='cpu',
+                 act_fn=nn.SiLU(), n_layers=4, attention=False,
+                 normalization_factor=1, out_node_nf=None):
+        super(GNN, self).__init__()
+        if out_node_nf is None:
+            out_node_nf = in_node_nf
+        self.hidden_nf = hidden_nf
+        self.device = device
+        self.n_layers = n_layers
+        ### Encoder
+        self.embedding = nn.Linear(in_node_nf, self.hidden_nf)
+        self.embedding_out = nn.Linear(self.hidden_nf, out_node_nf)
+        for i in range(0, n_layers):
+            self.add_module("gcl_%d" % i, GCL(
+                self.hidden_nf, self.hidden_nf, self.hidden_nf,
+                normalization_factor=normalization_factor,
+                aggregation_method=aggregation_method,
+                edges_in_d=in_edge_nf, act_fn=act_fn,
+                attention=attention))
+        self.to(self.device)
+
+    def forward(self, h, edges, edge_attr=None, node_mask=None, edge_mask=None):
+        # Edit Emiel: Remove velocity as input
+        h = self.embedding(h)
+        for i in range(0, self.n_layers):
+            h, _ = self._modules["gcl_%d" % i](h, edges, edge_attr=edge_attr, node_mask=node_mask, edge_mask=edge_mask)
+        h = self.embedding_out(h)
+
+        # Important, the bias of the last linear might be non-zero
+        if node_mask is not None:
+            h = h * node_mask
+        return h
+
+
+class SinusoidsEmbeddingNew(nn.Module):
+    def __init__(self, max_res=15., min_res=15. / 2000., div_factor=4):
+        super().__init__()
+        self.n_frequencies = int(math.log(max_res / min_res, div_factor)) + 1
+        self.frequencies = 2 * math.pi * div_factor ** torch.arange(self.n_frequencies)/max_res
+        self.dim = len(self.frequencies) * 2
+
+    def forward(self, x):
+        x = torch.sqrt(x + 1e-8)
+        emb = x * self.frequencies[None, :].to(x.device)
+        emb = torch.cat((emb.sin(), emb.cos()), dim=-1)
+        return emb.detach()
+
+
+def coord2diff(x, edge_index, norm_constant=1):
+    row, col = edge_index
+    coord_diff = x[row] - x[col]
+    radial = torch.sum((coord_diff) ** 2, 1).unsqueeze(1)
+    norm = torch.sqrt(radial + 1e-8)
+    coord_diff = coord_diff/(norm + norm_constant)
+    return radial, coord_diff
+
+
+def coord2cross(x, edge_index, batch_mask, norm_constant=1):
+
+    mean = unsorted_segment_sum(x, batch_mask,
+                                num_segments=batch_mask.max() + 1,
+                                normalization_factor=None,
+                                aggregation_method='mean')
+    row, col = edge_index
+    cross = torch.cross(x[row]-mean[batch_mask[row]],
+                        x[col]-mean[batch_mask[col]], dim=1)
+    norm = torch.linalg.norm(cross, dim=1, keepdim=True)
+    cross = cross / (norm + norm_constant)
+    return cross
+
+
+def unsorted_segment_sum(data, segment_ids, num_segments, normalization_factor, aggregation_method: str):
+    """Custom PyTorch op to replicate TensorFlow's `unsorted_segment_sum`.
+        Normalization: 'sum' or 'mean'.
+    """
+    result_shape = (num_segments, data.size(1))
+    result = data.new_full(result_shape, 0)  # Init empty result tensor.
+    segment_ids = segment_ids.unsqueeze(-1).expand(-1, data.size(1))
+    result.scatter_add_(0, segment_ids, data)
+    if aggregation_method == 'sum':
+        result = result / normalization_factor
+
+    if aggregation_method == 'mean':
+        norm = data.new_zeros(result.shape)
+        norm.scatter_add_(0, segment_ids, data.new_ones(data.shape))
+        norm[norm == 0] = 1
+        result = result / norm
+    return result

equivariant_diffusion/en_diffusion.py

@@ -0,0 +1,1190 @@
+import math
+from typing import Dict
+
+import numpy as np
+import torch
+from torch import nn
+import torch.nn.functional as F
+from torch_scatter import scatter_add, scatter_mean
+
+import utils
+
+
+class EnVariationalDiffusion(nn.Module):
+    """
+    The E(n) Diffusion Module.
+    """
+
+    def __init__(
+            self,
+            dynamics: nn.Module, atom_nf: int, residue_nf: int,
+            n_dims: int, size_histogram: Dict,
+            timesteps: int = 1000, parametrization='eps',
+            noise_schedule='learned', noise_precision=1e-4,
+            loss_type='vlb', norm_values=(1., 1.), norm_biases=(None, 0.),
+            virtual_node_idx=None):
+        super().__init__()
+
+        assert loss_type in {'vlb', 'l2'}
+        self.loss_type = loss_type
+        if noise_schedule == 'learned':
+            assert loss_type == 'vlb', 'A noise schedule can only be learned' \
+                                       ' with a vlb objective.'
+
+        # Only supported parametrization.
+        assert parametrization == 'eps'
+
+        if noise_schedule == 'learned':
+            self.gamma = GammaNetwork()
+        else:
+            self.gamma = PredefinedNoiseSchedule(noise_schedule,
+                                                 timesteps=timesteps,
+                                                 precision=noise_precision)
+
+        # The network that will predict the denoising.
+        self.dynamics = dynamics
+
+        self.atom_nf = atom_nf
+        self.residue_nf = residue_nf
+        self.n_dims = n_dims
+        self.num_classes = self.atom_nf
+
+        self.T = timesteps
+        self.parametrization = parametrization
+
+        self.norm_values = norm_values
+        self.norm_biases = norm_biases
+        self.register_buffer('buffer', torch.zeros(1))
+
+        #  distribution of nodes
+        self.size_distribution = DistributionNodes(size_histogram)
+
+        # indicate if virtual nodes are present
+        self.vnode_idx = virtual_node_idx
+
+        if noise_schedule != 'learned':
+            self.check_issues_norm_values()
+
+    def check_issues_norm_values(self, num_stdevs=8):
+        zeros = torch.zeros((1, 1))
+        gamma_0 = self.gamma(zeros)
+        sigma_0 = self.sigma(gamma_0, target_tensor=zeros).item()
+
+        # Checked if 1 / norm_value is still larger than 10 * standard
+        # deviation.
+        norm_value = self.norm_values[1]
+
+        if sigma_0 * num_stdevs > 1. / norm_value:
+            raise ValueError(
+                f'Value for normalization value {norm_value} probably too '
+                f'large with sigma_0 {sigma_0:.5f} and '
+                f'1 / norm_value = {1. / norm_value}')
+
+    def sigma_and_alpha_t_given_s(self, gamma_t: torch.Tensor,
+                                  gamma_s: torch.Tensor,
+                                  target_tensor: torch.Tensor):
+        """
+        Computes sigma t given s, using gamma_t and gamma_s. Used during sampling.
+        These are defined as:
+            alpha t given s = alpha t / alpha s,
+            sigma t given s = sqrt(1 - (alpha t given s) ^2 ).
+        """
+        sigma2_t_given_s = self.inflate_batch_array(
+            -torch.expm1(F.softplus(gamma_s) - F.softplus(gamma_t)), target_tensor
+        )
+
+        # alpha_t_given_s = alpha_t / alpha_s
+        log_alpha2_t = F.logsigmoid(-gamma_t)
+        log_alpha2_s = F.logsigmoid(-gamma_s)
+        log_alpha2_t_given_s = log_alpha2_t - log_alpha2_s
+
+        alpha_t_given_s = torch.exp(0.5 * log_alpha2_t_given_s)
+        alpha_t_given_s = self.inflate_batch_array(
+            alpha_t_given_s, target_tensor)
+
+        sigma_t_given_s = torch.sqrt(sigma2_t_given_s)
+
+        return sigma2_t_given_s, sigma_t_given_s, alpha_t_given_s
+
+    def kl_prior_with_pocket(self, xh_lig, xh_pocket, mask_lig, mask_pocket,
+                             num_nodes):
+        """Computes the KL between q(z1 | x) and the prior p(z1) = Normal(0, 1).
+
+        This is essentially a lot of work for something that is in practice
+        negligible in the loss. However, you compute it so that you see it when
+        you've made a mistake in your noise schedule.
+        """
+        batch_size = len(num_nodes)
+
+        # Compute the last alpha value, alpha_T.
+        ones = torch.ones((batch_size, 1), device=xh_lig.device)
+        gamma_T = self.gamma(ones)
+        alpha_T = self.alpha(gamma_T, xh_lig)
+
+        # Compute means.
+        mu_T_lig = alpha_T[mask_lig] * xh_lig
+        mu_T_lig_x, mu_T_lig_h = mu_T_lig[:, :self.n_dims], \
+                                 mu_T_lig[:, self.n_dims:]
+
+        # Compute standard deviations (only batch axis for x-part, inflated for h-part).
+        sigma_T_x = self.sigma(gamma_T, mu_T_lig_x).squeeze()
+        sigma_T_h = self.sigma(gamma_T, mu_T_lig_h).squeeze()
+
+        # Compute means.
+        mu_T_pocket = alpha_T[mask_pocket] * xh_pocket
+        mu_T_pocket_x, mu_T_pocket_h = mu_T_pocket[:, :self.n_dims], \
+                                       mu_T_pocket[:, self.n_dims:]
+
+        # Compute KL for h-part.
+        zeros_lig = torch.zeros_like(mu_T_lig_h)
+        zeros_pocket = torch.zeros_like(mu_T_pocket_h)
+        ones = torch.ones_like(sigma_T_h)
+        mu_norm2 = self.sum_except_batch((mu_T_lig_h - zeros_lig) ** 2, mask_lig) + \
+                   self.sum_except_batch((mu_T_pocket_h - zeros_pocket) ** 2, mask_pocket)
+        kl_distance_h = self.gaussian_KL(mu_norm2, sigma_T_h, ones, d=1)
+
+        # Compute KL for x-part.
+        zeros_lig = torch.zeros_like(mu_T_lig_x)
+        zeros_pocket = torch.zeros_like(mu_T_pocket_x)
+        ones = torch.ones_like(sigma_T_x)
+        mu_norm2 = self.sum_except_batch((mu_T_lig_x - zeros_lig) ** 2, mask_lig) + \
+                   self.sum_except_batch((mu_T_pocket_x - zeros_pocket) ** 2, mask_pocket)
+        subspace_d = self.subspace_dimensionality(num_nodes)
+        kl_distance_x = self.gaussian_KL(mu_norm2, sigma_T_x, ones, subspace_d)
+
+        return kl_distance_x + kl_distance_h
+
+    def compute_x_pred(self, net_out, zt, gamma_t, batch_mask):
+        """Commputes x_pred, i.e. the most likely prediction of x."""
+        if self.parametrization == 'x':
+            x_pred = net_out
+        elif self.parametrization == 'eps':
+            sigma_t = self.sigma(gamma_t, target_tensor=net_out)
+            alpha_t = self.alpha(gamma_t, target_tensor=net_out)
+            eps_t = net_out
+            x_pred = 1. / alpha_t[batch_mask] * (zt - sigma_t[batch_mask] * eps_t)
+        else:
+            raise ValueError(self.parametrization)
+
+        return x_pred
+
+    def log_constants_p_x_given_z0(self, n_nodes, device):
+        """Computes p(x|z0)."""
+
+        batch_size = len(n_nodes)
+        degrees_of_freedom_x = self.subspace_dimensionality(n_nodes)
+
+        zeros = torch.zeros((batch_size, 1), device=device)
+        gamma_0 = self.gamma(zeros)
+
+        # Recall that sigma_x = sqrt(sigma_0^2 / alpha_0^2) = SNR(-0.5 gamma_0).
+        log_sigma_x = 0.5 * gamma_0.view(batch_size)
+
+        return degrees_of_freedom_x * (- log_sigma_x - 0.5 * np.log(2 * np.pi))
+
+    def log_pxh_given_z0_without_constants(
+            self, ligand, z_0_lig, eps_lig, net_out_lig,
+            pocket, z_0_pocket, eps_pocket, net_out_pocket,
+            gamma_0, epsilon=1e-10):
+
+        # Discrete properties are predicted directly from z_t.
+        z_h_lig = z_0_lig[:, self.n_dims:]
+        z_h_pocket = z_0_pocket[:, self.n_dims:]
+
+        # Take only part over x.
+        eps_lig_x = eps_lig[:, :self.n_dims]
+        net_lig_x = net_out_lig[:, :self.n_dims]
+        eps_pocket_x = eps_pocket[:, :self.n_dims]
+        net_pocket_x = net_out_pocket[:, :self.n_dims]
+
+        # Compute sigma_0 and rescale to the integer scale of the data.
+        sigma_0 = self.sigma(gamma_0, target_tensor=z_0_lig)
+        sigma_0_cat = sigma_0 * self.norm_values[1]
+
+        # Computes the error for the distribution
+        # N(x | 1 / alpha_0 z_0 + sigma_0/alpha_0 eps_0, sigma_0 / alpha_0),
+        # the weighting in the epsilon parametrization is exactly '1'.
+        log_p_x_given_z0_without_constants_ligand = -0.5 * (
+            self.sum_except_batch((eps_lig_x - net_lig_x) ** 2, ligand['mask'])
+        )
+
+        log_p_x_given_z0_without_constants_pocket = -0.5 * (
+            self.sum_except_batch((eps_pocket_x - net_pocket_x) ** 2,
+                                  pocket['mask'])
+        )
+
+        # Compute delta indicator masks.
+        # un-normalize
+        ligand_onehot = ligand['one_hot'] * self.norm_values[1] + self.norm_biases[1]
+        pocket_onehot = pocket['one_hot'] * self.norm_values[1] + self.norm_biases[1]
+
+        estimated_ligand_onehot = z_h_lig * self.norm_values[1] + self.norm_biases[1]
+        estimated_pocket_onehot = z_h_pocket * self.norm_values[1] + self.norm_biases[1]
+
+        # Centered h_cat around 1, since onehot encoded.
+        centered_ligand_onehot = estimated_ligand_onehot - 1
+        centered_pocket_onehot = estimated_pocket_onehot - 1
+
+        # Compute integrals from 0.5 to 1.5 of the normal distribution
+        # N(mean=z_h_cat, stdev=sigma_0_cat)
+        log_ph_cat_proportional_ligand = torch.log(
+            self.cdf_standard_gaussian((centered_ligand_onehot + 0.5) / sigma_0_cat[ligand['mask']])
+            - self.cdf_standard_gaussian((centered_ligand_onehot - 0.5) / sigma_0_cat[ligand['mask']])
+            + epsilon
+        )
+        log_ph_cat_proportional_pocket = torch.log(
+            self.cdf_standard_gaussian((centered_pocket_onehot + 0.5) / sigma_0_cat[pocket['mask']])
+            - self.cdf_standard_gaussian((centered_pocket_onehot - 0.5) / sigma_0_cat[pocket['mask']])
+            + epsilon
+        )
+
+        # Normalize the distribution over the categories.
+        log_Z = torch.logsumexp(log_ph_cat_proportional_ligand, dim=1,
+                                keepdim=True)
+        log_probabilities_ligand = log_ph_cat_proportional_ligand - log_Z
+
+        log_Z = torch.logsumexp(log_ph_cat_proportional_pocket, dim=1,
+                                keepdim=True)
+        log_probabilities_pocket = log_ph_cat_proportional_pocket - log_Z
+
+        # Select the log_prob of the current category using the onehot
+        # representation.
+        log_ph_given_z0_ligand = self.sum_except_batch(
+            log_probabilities_ligand * ligand_onehot, ligand['mask'])
+        log_ph_given_z0_pocket = self.sum_except_batch(
+            log_probabilities_pocket * pocket_onehot, pocket['mask'])
+
+        # Combine log probabilities of ligand and pocket for h.
+        log_ph_given_z0 = log_ph_given_z0_ligand + log_ph_given_z0_pocket
+
+        return log_p_x_given_z0_without_constants_ligand, \
+               log_p_x_given_z0_without_constants_pocket, log_ph_given_z0
+
+    def sample_p_xh_given_z0(self, z0_lig, z0_pocket, lig_mask, pocket_mask,
+                             batch_size, fix_noise=False):
+        """Samples x ~ p(x|z0)."""
+        t_zeros = torch.zeros(size=(batch_size, 1), device=z0_lig.device)
+        gamma_0 = self.gamma(t_zeros)
+        # Computes sqrt(sigma_0^2 / alpha_0^2)
+        sigma_x = self.SNR(-0.5 * gamma_0)
+        net_out_lig, net_out_pocket = self.dynamics(
+            z0_lig, z0_pocket, t_zeros, lig_mask, pocket_mask)
+
+        # Compute mu for p(zs | zt).
+        mu_x_lig = self.compute_x_pred(net_out_lig, z0_lig, gamma_0, lig_mask)
+        mu_x_pocket = self.compute_x_pred(net_out_pocket, z0_pocket, gamma_0,
+                                          pocket_mask)
+        xh_lig, xh_pocket = self.sample_normal(mu_x_lig, mu_x_pocket, sigma_x,
+                                               lig_mask, pocket_mask, fix_noise)
+
+        x_lig, h_lig = self.unnormalize(
+            xh_lig[:, :self.n_dims], z0_lig[:, self.n_dims:])
+        x_pocket, h_pocket = self.unnormalize(
+            xh_pocket[:, :self.n_dims], z0_pocket[:, self.n_dims:])
+
+        h_lig = F.one_hot(torch.argmax(h_lig, dim=1), self.atom_nf)
+        h_pocket = F.one_hot(torch.argmax(h_pocket, dim=1), self.residue_nf)
+
+        return x_lig, h_lig, x_pocket, h_pocket
+
+    def sample_normal(self, mu_lig, mu_pocket, sigma, lig_mask, pocket_mask,
+                      fix_noise=False):
+        """Samples from a Normal distribution."""
+        if fix_noise:
+            # bs = 1 if fix_noise else mu.size(0)
+            raise NotImplementedError("fix_noise option isn't implemented yet")
+        eps_lig, eps_pocket = self.sample_combined_position_feature_noise(
+            lig_mask, pocket_mask)
+
+        return mu_lig + sigma[lig_mask] * eps_lig, \
+               mu_pocket + sigma[pocket_mask] * eps_pocket
+
+    def noised_representation(self, xh_lig, xh_pocket, lig_mask, pocket_mask,
+                              gamma_t):
+        # Compute alpha_t and sigma_t from gamma.
+        alpha_t = self.alpha(gamma_t, xh_lig)
+        sigma_t = self.sigma(gamma_t, xh_lig)
+
+        # Sample zt ~ Normal(alpha_t x, sigma_t)
+        eps_lig, eps_pocket = self.sample_combined_position_feature_noise(
+            lig_mask, pocket_mask)
+
+        # Sample z_t given x, h for timestep t, from q(z_t | x, h)
+        z_t_lig = alpha_t[lig_mask] * xh_lig + sigma_t[lig_mask] * eps_lig
+        z_t_pocket = alpha_t[pocket_mask] * xh_pocket + \
+                     sigma_t[pocket_mask] * eps_pocket
+
+        return z_t_lig, z_t_pocket, eps_lig, eps_pocket
+
+    def log_pN(self, N_lig, N_pocket):
+        """
+        Prior on the sample size for computing
+        log p(x,h,N) = log p(x,h|N) + log p(N), where log p(x,h|N) is the
+        model's output
+        Args:
+            N: array of sample sizes
+        Returns:
+            log p(N)
+        """
+        log_pN = self.size_distribution.log_prob(N_lig, N_pocket)
+        return log_pN
+
+    def delta_log_px(self, num_nodes):
+        return -self.subspace_dimensionality(num_nodes) * \
+               np.log(self.norm_values[0])
+
+    def forward(self, ligand, pocket, return_info=False):
+        """
+        Computes the loss and NLL terms
+        """
+        # Normalize data, take into account volume change in x.
+        ligand, pocket = self.normalize(ligand, pocket)
+
+        # Likelihood change due to normalization
+        delta_log_px = self.delta_log_px(ligand['size'] + pocket['size'])
+
+        # Sample a timestep t for each example in batch
+        # At evaluation time, loss_0 will be computed separately to decrease
+        # variance in the estimator (costs two forward passes)
+        lowest_t = 0 if self.training else 1
+        t_int = torch.randint(
+            lowest_t, self.T + 1, size=(ligand['size'].size(0), 1),
+            device=ligand['x'].device).float()
+        s_int = t_int - 1  # previous timestep
+
+        # Masks: important to compute log p(x | z0).
+        t_is_zero = (t_int == 0).float()
+        t_is_not_zero = 1 - t_is_zero
+
+        # Normalize t to [0, 1]. Note that the negative
+        # step of s will never be used, since then p(x | z0) is computed.
+        s = s_int / self.T
+        t = t_int / self.T
+
+        # Compute gamma_s and gamma_t via the network.
+        gamma_s = self.inflate_batch_array(self.gamma(s), ligand['x'])
+        gamma_t = self.inflate_batch_array(self.gamma(t), ligand['x'])
+
+        # Concatenate x, and h[categorical].
+        xh_lig = torch.cat([ligand['x'], ligand['one_hot']], dim=1)
+        xh_pocket = torch.cat([pocket['x'], pocket['one_hot']], dim=1)
+
+        # Find noised representation
+        z_t_lig, z_t_pocket, eps_t_lig, eps_t_pocket = \
+            self.noised_representation(xh_lig, xh_pocket, ligand['mask'],
+                                       pocket['mask'], gamma_t)
+
+        # Neural net prediction.
+        net_out_lig, net_out_pocket = self.dynamics(
+            z_t_lig, z_t_pocket, t, ligand['mask'], pocket['mask'])
+
+        # For LJ loss term
+        xh_lig_hat = self.xh_given_zt_and_epsilon(z_t_lig, net_out_lig, gamma_t,
+                                                  ligand['mask'])
+
+        # Compute the L2 error.
+        error_t_lig = self.sum_except_batch((eps_t_lig - net_out_lig) ** 2,
+                                            ligand['mask'])
+
+        error_t_pocket = self.sum_except_batch(
+            (eps_t_pocket - net_out_pocket) ** 2, pocket['mask'])
+
+        # Compute weighting with SNR: (1 - SNR(s-t)) for epsilon parametrization
+        SNR_weight = (1 - self.SNR(gamma_s - gamma_t)).squeeze(1)
+        assert error_t_lig.size() == SNR_weight.size()
+
+        # The _constants_ depending on sigma_0 from the
+        # cross entropy term E_q(z0 | x) [log p(x | z0)].
+        neg_log_constants = -self.log_constants_p_x_given_z0(
+            n_nodes=ligand['size'] + pocket['size'], device=error_t_lig.device)
+
+        # The KL between q(zT | x) and p(zT) = Normal(0, 1).
+        # Should be close to zero.
+        kl_prior = self.kl_prior_with_pocket(
+            xh_lig, xh_pocket, ligand['mask'], pocket['mask'],
+            ligand['size'] + pocket['size'])
+
+        if self.training:
+            # Computes the L_0 term (even if gamma_t is not actually gamma_0)
+            # and this will later be selected via masking.
+            log_p_x_given_z0_without_constants_ligand, \
+            log_p_x_given_z0_without_constants_pocket, log_ph_given_z0 = \
+                self.log_pxh_given_z0_without_constants(
+                    ligand, z_t_lig, eps_t_lig, net_out_lig,
+                    pocket, z_t_pocket, eps_t_pocket, net_out_pocket, gamma_t)
+
+            loss_0_x_ligand = -log_p_x_given_z0_without_constants_ligand * \
+                              t_is_zero.squeeze()
+            loss_0_x_pocket = -log_p_x_given_z0_without_constants_pocket * \
+                              t_is_zero.squeeze()
+            loss_0_h = -log_ph_given_z0 * t_is_zero.squeeze()
+
+            # apply t_is_zero mask
+            error_t_lig = error_t_lig * t_is_not_zero.squeeze()
+            error_t_pocket = error_t_pocket * t_is_not_zero.squeeze()
+
+        else:
+            # Compute noise values for t = 0.
+            t_zeros = torch.zeros_like(s)
+            gamma_0 = self.inflate_batch_array(self.gamma(t_zeros), ligand['x'])
+
+            # Sample z_0 given x, h for timestep t, from q(z_t | x, h)
+            z_0_lig, z_0_pocket, eps_0_lig, eps_0_pocket = \
+                self.noised_representation(xh_lig, xh_pocket, ligand['mask'],
+                                           pocket['mask'], gamma_0)
+
+            net_out_0_lig, net_out_0_pocket = self.dynamics(
+                z_0_lig, z_0_pocket, t_zeros, ligand['mask'], pocket['mask'])
+
+            log_p_x_given_z0_without_constants_ligand, \
+            log_p_x_given_z0_without_constants_pocket, log_ph_given_z0 = \
+                self.log_pxh_given_z0_without_constants(
+                    ligand, z_0_lig, eps_0_lig, net_out_0_lig,
+                    pocket, z_0_pocket, eps_0_pocket, net_out_0_pocket, gamma_0)
+            loss_0_x_ligand = -log_p_x_given_z0_without_constants_ligand
+            loss_0_x_pocket = -log_p_x_given_z0_without_constants_pocket
+            loss_0_h = -log_ph_given_z0
+
+        # sample size prior
+        log_pN = self.log_pN(ligand['size'], pocket['size'])
+
+        info = {
+            'eps_hat_lig_x': scatter_mean(
+                net_out_lig[:, :self.n_dims].abs().mean(1), ligand['mask'],
+                dim=0).mean(),
+            'eps_hat_lig_h': scatter_mean(
+                net_out_lig[:, self.n_dims:].abs().mean(1), ligand['mask'],
+                dim=0).mean(),
+            'eps_hat_pocket_x': scatter_mean(
+                net_out_pocket[:, :self.n_dims].abs().mean(1), pocket['mask'],
+                dim=0).mean(),
+            'eps_hat_pocket_h': scatter_mean(
+                net_out_pocket[:, self.n_dims:].abs().mean(1), pocket['mask'],
+                dim=0).mean(),
+        }
+        loss_terms = (delta_log_px, error_t_lig, error_t_pocket, SNR_weight,
+                      loss_0_x_ligand, loss_0_x_pocket, loss_0_h,
+                      neg_log_constants, kl_prior, log_pN,
+                      t_int.squeeze(), xh_lig_hat)
+        return (*loss_terms, info) if return_info else loss_terms
+
+    def xh_given_zt_and_epsilon(self, z_t, epsilon, gamma_t, batch_mask):
+        """ Equation (7) in the EDM paper """
+        alpha_t = self.alpha(gamma_t, z_t)
+        sigma_t = self.sigma(gamma_t, z_t)
+        xh = z_t / alpha_t[batch_mask] - epsilon * sigma_t[batch_mask] / \
+             alpha_t[batch_mask]
+        return xh
+
+    def sample_p_zt_given_zs(self, zs_lig, zs_pocket, ligand_mask, pocket_mask,
+                             gamma_t, gamma_s, fix_noise=False):
+        sigma2_t_given_s, sigma_t_given_s, alpha_t_given_s = \
+            self.sigma_and_alpha_t_given_s(gamma_t, gamma_s, zs_lig)
+
+        mu_lig = alpha_t_given_s[ligand_mask] * zs_lig
+        mu_pocket = alpha_t_given_s[pocket_mask] * zs_pocket
+        zt_lig, zt_pocket = self.sample_normal(
+            mu_lig, mu_pocket, sigma_t_given_s, ligand_mask, pocket_mask,
+            fix_noise)
+
+        # Remove center of mass
+        zt_x = self.remove_mean_batch(
+            torch.cat((zt_lig[:, :self.n_dims], zt_pocket[:, :self.n_dims]),
+                      dim=0),
+            torch.cat((ligand_mask, pocket_mask))
+        )
+        zt_lig = torch.cat((zt_x[:len(ligand_mask)],
+                            zt_lig[:, self.n_dims:]), dim=1)
+        zt_pocket = torch.cat((zt_x[len(ligand_mask):],
+                               zt_pocket[:, self.n_dims:]), dim=1)
+
+        return zt_lig, zt_pocket
+
+    def sample_p_zs_given_zt(self, s, t, zt_lig, zt_pocket, ligand_mask,
+                             pocket_mask, fix_noise=False):
+        """Samples from zs ~ p(zs | zt). Only used during sampling."""
+        gamma_s = self.gamma(s)
+        gamma_t = self.gamma(t)
+
+        sigma2_t_given_s, sigma_t_given_s, alpha_t_given_s = \
+            self.sigma_and_alpha_t_given_s(gamma_t, gamma_s, zt_lig)
+
+        sigma_s = self.sigma(gamma_s, target_tensor=zt_lig)
+        sigma_t = self.sigma(gamma_t, target_tensor=zt_lig)
+
+        # Neural net prediction.
+        eps_t_lig, eps_t_pocket = self.dynamics(
+            zt_lig, zt_pocket, t, ligand_mask, pocket_mask)
+
+        # Compute mu for p(zs | zt).
+        combined_mask = torch.cat((ligand_mask, pocket_mask))
+        self.assert_mean_zero_with_mask(
+            torch.cat((zt_lig[:, :self.n_dims],
+                       zt_pocket[:, :self.n_dims]), dim=0),
+            combined_mask)
+        self.assert_mean_zero_with_mask(
+            torch.cat((eps_t_lig[:, :self.n_dims],
+                       eps_t_pocket[:, :self.n_dims]), dim=0),
+            combined_mask)
+
+        # Note: mu_{t->s} = 1 / alpha_{t|s} z_t - sigma_{t|s}^2 / sigma_t / alpha_{t|s} epsilon
+        # follows from the definition of mu_{t->s} and Equ. (7) in the EDM paper
+        mu_lig = zt_lig / alpha_t_given_s[ligand_mask] - \
+                 (sigma2_t_given_s / alpha_t_given_s / sigma_t)[ligand_mask] * \
+                 eps_t_lig
+        mu_pocket = zt_pocket / alpha_t_given_s[pocket_mask] - \
+                    (sigma2_t_given_s / alpha_t_given_s / sigma_t)[pocket_mask] * \
+                    eps_t_pocket
+
+        # Compute sigma for p(zs | zt).
+        sigma = sigma_t_given_s * sigma_s / sigma_t
+
+        # Sample zs given the paramters derived from zt.
+        zs_lig, zs_pocket = self.sample_normal(mu_lig, mu_pocket, sigma,
+                                               ligand_mask, pocket_mask,
+                                               fix_noise)
+
+        # Project down to avoid numerical runaway of the center of gravity.
+        zs_x = self.remove_mean_batch(
+            torch.cat((zs_lig[:, :self.n_dims],
+                       zs_pocket[:, :self.n_dims]), dim=0),
+            torch.cat((ligand_mask, pocket_mask))
+        )
+        zs_lig = torch.cat((zs_x[:len(ligand_mask)],
+                            zs_lig[:, self.n_dims:]), dim=1)
+        zs_pocket = torch.cat((zs_x[len(ligand_mask):],
+                               zs_pocket[:, self.n_dims:]), dim=1)
+        return zs_lig, zs_pocket
+
+    def sample_combined_position_feature_noise(self, lig_indices,
+                                               pocket_indices):
+        """
+        Samples mean-centered normal noise for z_x, and standard normal noise
+        for z_h.
+        """
+        z_x = self.sample_center_gravity_zero_gaussian_batch(
+            size=(len(lig_indices) + len(pocket_indices), self.n_dims),
+            lig_indices=lig_indices,
+            pocket_indices=pocket_indices
+        )
+        z_h_lig = self.sample_gaussian(
+            size=(len(lig_indices), self.atom_nf),
+            device=lig_indices.device)
+        z_lig = torch.cat([z_x[:len(lig_indices)], z_h_lig], dim=1)
+        z_h_pocket = self.sample_gaussian(
+            size=(len(pocket_indices), self.residue_nf),
+            device=pocket_indices.device)
+        z_pocket = torch.cat([z_x[len(lig_indices):], z_h_pocket], dim=1)
+        return z_lig, z_pocket
+
+    @torch.no_grad()
+    def sample(self, n_samples, num_nodes_lig, num_nodes_pocket,
+               return_frames=1, timesteps=None, device='cpu'):
+        """
+        Draw samples from the generative model. Optionally, return intermediate
+        states for visualization purposes.
+        """
+        timesteps = self.T if timesteps is None else timesteps
+        assert 0 < return_frames <= timesteps
+        assert timesteps % return_frames == 0
+
+        lig_mask = utils.num_nodes_to_batch_mask(n_samples, num_nodes_lig,
+                                                 device)
+        pocket_mask = utils.num_nodes_to_batch_mask(n_samples, num_nodes_pocket,
+                                                    device)
+
+        combined_mask = torch.cat((lig_mask, pocket_mask))
+
+        z_lig, z_pocket = self.sample_combined_position_feature_noise(
+            lig_mask, pocket_mask)
+
+        self.assert_mean_zero_with_mask(
+            torch.cat((z_lig[:, :self.n_dims], z_pocket[:, :self.n_dims]), dim=0),
+            combined_mask
+        )
+
+        out_lig = torch.zeros((return_frames,) + z_lig.size(),
+                              device=z_lig.device)
+        out_pocket = torch.zeros((return_frames,) + z_pocket.size(),
+                                 device=z_pocket.device)
+
+        # Iteratively sample p(z_s | z_t) for t = 1, ..., T, with s = t - 1.
+        for s in reversed(range(0, timesteps)):
+            s_array = torch.full((n_samples, 1), fill_value=s,
+                                 device=z_lig.device)
+            t_array = s_array + 1
+            s_array = s_array / timesteps
+            t_array = t_array / timesteps
+
+            z_lig, z_pocket = self.sample_p_zs_given_zt(
+                s_array, t_array, z_lig, z_pocket, lig_mask, pocket_mask)
+
+            # save frame
+            if (s * return_frames) % timesteps == 0:
+                idx = (s * return_frames) // timesteps
+                out_lig[idx], out_pocket[idx] = \
+                    self.unnormalize_z(z_lig, z_pocket)
+
+        # Finally sample p(x, h | z_0).
+        x_lig, h_lig, x_pocket, h_pocket = self.sample_p_xh_given_z0(
+            z_lig, z_pocket, lig_mask, pocket_mask, n_samples)
+
+        self.assert_mean_zero_with_mask(
+            torch.cat((x_lig, x_pocket), dim=0), combined_mask
+        )
+
+        # Correct CoM drift for examples without intermediate states
+        if return_frames == 1:
+            x = torch.cat((x_lig, x_pocket))
+            max_cog = scatter_add(x, combined_mask, dim=0).abs().max().item()
+            if max_cog > 5e-2:
+                print(f'Warning CoG drift with error {max_cog:.3f}. Projecting '
+                      f'the positions down.')
+                x = self.remove_mean_batch(x, combined_mask)
+                x_lig, x_pocket = x[:len(x_lig)], x[len(x_lig):]
+
+        # Overwrite last frame with the resulting x and h.
+        out_lig[0] = torch.cat([x_lig, h_lig], dim=1)
+        out_pocket[0] = torch.cat([x_pocket, h_pocket], dim=1)
+
+        # remove frame dimension if only the final molecule is returned
+        return out_lig.squeeze(0), out_pocket.squeeze(0), lig_mask, pocket_mask
+
+    def get_repaint_schedule(self, resamplings, jump_length, timesteps):
+        """ Each integer in the schedule list describes how many denoising steps
+        need to be applied before jumping back """
+        repaint_schedule = []
+        curr_t = 0
+        while curr_t < timesteps:
+            if curr_t + jump_length < timesteps:
+                if len(repaint_schedule) > 0:
+                    repaint_schedule[-1] += jump_length
+                    repaint_schedule.extend([jump_length] * (resamplings - 1))
+                else:
+                    repaint_schedule.extend([jump_length] * resamplings)
+                curr_t += jump_length
+            else:
+                residual = (timesteps - curr_t)
+                if len(repaint_schedule) > 0:
+                    repaint_schedule[-1] += residual
+                else:
+                    repaint_schedule.append(residual)
+                curr_t += residual
+
+        return list(reversed(repaint_schedule))
+
+    @torch.no_grad()
+    def inpaint(self, ligand, pocket, lig_fixed, pocket_fixed, resamplings=1,
+                jump_length=1, return_frames=1, timesteps=None):
+        """
+        Draw samples from the generative model while fixing parts of the input.
+        Optionally, return intermediate states for visualization purposes.
+        See:
+        Lugmayr, Andreas, et al.
+        "Repaint: Inpainting using denoising diffusion probabilistic models."
+        Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern
+        Recognition. 2022.
+        """
+        timesteps = self.T if timesteps is None else timesteps
+        assert 0 < return_frames <= timesteps
+        assert timesteps % return_frames == 0
+        assert jump_length == 1 or return_frames == 1, \
+            "Chain visualization is only implemented for jump_length=1"
+
+        if len(lig_fixed.size()) == 1:
+            lig_fixed = lig_fixed.unsqueeze(1)
+        if len(pocket_fixed.size()) == 1:
+            pocket_fixed = pocket_fixed.unsqueeze(1)
+
+        ligand, pocket = self.normalize(ligand, pocket)
+
+        n_samples = len(ligand['size'])
+        combined_mask = torch.cat((ligand['mask'], pocket['mask']))
+        xh0_lig = torch.cat([ligand['x'], ligand['one_hot']], dim=1)
+        xh0_pocket = torch.cat([pocket['x'], pocket['one_hot']], dim=1)
+
+        # Center initial system, subtract COM of known parts
+        mean_known = scatter_mean(
+            torch.cat((ligand['x'][lig_fixed.bool().view(-1)],
+                       pocket['x'][pocket_fixed.bool().view(-1)])),
+            torch.cat((ligand['mask'][lig_fixed.bool().view(-1)],
+                       pocket['mask'][pocket_fixed.bool().view(-1)])),
+            dim=0
+        )
+        xh0_lig[:, :self.n_dims] = \
+            xh0_lig[:, :self.n_dims] - mean_known[ligand['mask']]
+        xh0_pocket[:, :self.n_dims] = \
+            xh0_pocket[:, :self.n_dims] - mean_known[pocket['mask']]
+
+        # Noised representation at step t=T
+        z_lig, z_pocket = self.sample_combined_position_feature_noise(
+            ligand['mask'], pocket['mask'])
+
+        # Output tensors
+        out_lig = torch.zeros((return_frames,) + z_lig.size(),
+                              device=z_lig.device)
+        out_pocket = torch.zeros((return_frames,) + z_pocket.size(),
+                                 device=z_pocket.device)
+
+        # Iteratively sample according to a pre-defined schedule
+        schedule = self.get_repaint_schedule(resamplings, jump_length, timesteps)
+        s = timesteps - 1
+        for i, n_denoise_steps in enumerate(schedule):
+            for j in range(n_denoise_steps):
+                # Denoise one time step: t -> s
+                s_array = torch.full((n_samples, 1), fill_value=s,
+                                     device=z_lig.device)
+                t_array = s_array + 1
+                s_array = s_array / timesteps
+                t_array = t_array / timesteps
+
+                # sample known nodes from the input
+                gamma_s = self.inflate_batch_array(self.gamma(s_array),
+                                                   ligand['x'])
+                z_lig_known, z_pocket_known, _, _ = self.noised_representation(
+                    xh0_lig, xh0_pocket, ligand['mask'], pocket['mask'], gamma_s)
+
+                # sample inpainted part
+                z_lig_unknown, z_pocket_unknown = self.sample_p_zs_given_zt(
+                    s_array, t_array, z_lig, z_pocket, ligand['mask'],
+                    pocket['mask'])
+
+                # move center of mass of the noised part to the center of mass
+                # of the corresponding denoised part before combining them
+                # -> the resulting system should be COM-free
+                com_noised = scatter_mean(
+                    torch.cat((z_lig_known[:, :self.n_dims][lig_fixed.bool().view(-1)],
+                               z_pocket_known[:, :self.n_dims][pocket_fixed.bool().view(-1)])),
+                    torch.cat((ligand['mask'][lig_fixed.bool().view(-1)],
+                               pocket['mask'][pocket_fixed.bool().view(-1)])),
+                    dim=0
+                )
+                com_denoised = scatter_mean(
+                    torch.cat((z_lig_unknown[:, :self.n_dims][lig_fixed.bool().view(-1)],
+                               z_pocket_unknown[:, :self.n_dims][pocket_fixed.bool().view(-1)])),
+                    torch.cat((ligand['mask'][lig_fixed.bool().view(-1)],
+                               pocket['mask'][pocket_fixed.bool().view(-1)])),
+                    dim=0
+                )
+                z_lig_known[:, :self.n_dims] = \
+                    z_lig_known[:, :self.n_dims] + (com_denoised - com_noised)[ligand['mask']]
+                z_pocket_known[:, :self.n_dims] = \
+                    z_pocket_known[:, :self.n_dims] + (com_denoised - com_noised)[pocket['mask']]
+
+                # combine
+                z_lig = z_lig_known * lig_fixed + \
+                        z_lig_unknown * (1 - lig_fixed)
+                z_pocket = z_pocket_known * pocket_fixed + \
+                           z_pocket_unknown * (1 - pocket_fixed)
+
+                self.assert_mean_zero_with_mask(
+                    torch.cat((z_lig[:, :self.n_dims],
+                               z_pocket[:, :self.n_dims]), dim=0), combined_mask
+                )
+
+                # save frame at the end of a resample cycle
+                if n_denoise_steps > jump_length or i == len(schedule) - 1:
+                    if (s * return_frames) % timesteps == 0:
+                        idx = (s * return_frames) // timesteps
+                        out_lig[idx], out_pocket[idx] = \
+                            self.unnormalize_z(z_lig, z_pocket)
+
+                # Noise combined representation
+                if j == n_denoise_steps - 1 and i < len(schedule) - 1:
+                    # Go back jump_length steps
+                    t = s + jump_length
+                    t_array = torch.full((n_samples, 1), fill_value=t,
+                                         device=z_lig.device)
+                    t_array = t_array / timesteps
+
+                    gamma_s = self.inflate_batch_array(self.gamma(s_array),
+                                                       ligand['x'])
+                    gamma_t = self.inflate_batch_array(self.gamma(t_array),
+                                                       ligand['x'])
+
+                    z_lig, z_pocket = self.sample_p_zt_given_zs(
+                        z_lig, z_pocket, ligand['mask'], pocket['mask'],
+                        gamma_t, gamma_s)
+
+                    s = t
+
+                s -= 1
+
+        # Finally sample p(x, h | z_0).
+        x_lig, h_lig, x_pocket, h_pocket = self.sample_p_xh_given_z0(
+            z_lig, z_pocket, ligand['mask'], pocket['mask'], n_samples)
+
+        self.assert_mean_zero_with_mask(
+            torch.cat((x_lig, x_pocket), dim=0), combined_mask
+        )
+
+        # Correct CoM drift for examples without intermediate states
+        if return_frames == 1:
+            x = torch.cat((x_lig, x_pocket))
+            max_cog = scatter_add(x, combined_mask, dim=0).abs().max().item()
+            if max_cog > 5e-2:
+                print(f'Warning CoG drift with error {max_cog:.3f}. Projecting '
+                      f'the positions down.')
+                x = self.remove_mean_batch(x, combined_mask)
+                x_lig, x_pocket = x[:len(x_lig)], x[len(x_lig):]
+
+        # Overwrite last frame with the resulting x and h.
+        out_lig[0] = torch.cat([x_lig, h_lig], dim=1)
+        out_pocket[0] = torch.cat([x_pocket, h_pocket], dim=1)
+
+        # remove frame dimension if only the final molecule is returned
+        return out_lig.squeeze(0), out_pocket.squeeze(0), ligand['mask'], \
+               pocket['mask']
+
+    @staticmethod
+    def gaussian_KL(q_mu_minus_p_mu_squared, q_sigma, p_sigma, d):
+        """Computes the KL distance between two normal distributions.
+            Args:
+                q_mu_minus_p_mu_squared: Squared difference between mean of
+                    distribution q and distribution p: ||mu_q - mu_p||^2
+                q_sigma: Standard deviation of distribution q.
+                p_sigma: Standard deviation of distribution p.
+                d: dimension
+            Returns:
+                The KL distance
+            """
+        return d * torch.log(p_sigma / q_sigma) + \
+               0.5 * (d * q_sigma ** 2 + q_mu_minus_p_mu_squared) / \
+               (p_sigma ** 2) - 0.5 * d
+
+    @staticmethod
+    def inflate_batch_array(array, target):
+        """
+        Inflates the batch array (array) with only a single axis
+        (i.e. shape = (batch_size,), or possibly more empty axes
+        (i.e. shape (batch_size, 1, ..., 1)) to match the target shape.
+        """
+        target_shape = (array.size(0),) + (1,) * (len(target.size()) - 1)
+        return array.view(target_shape)
+
+    def sigma(self, gamma, target_tensor):
+        """Computes sigma given gamma."""
+        return self.inflate_batch_array(torch.sqrt(torch.sigmoid(gamma)),
+                                        target_tensor)
+
+    def alpha(self, gamma, target_tensor):
+        """Computes alpha given gamma."""
+        return self.inflate_batch_array(torch.sqrt(torch.sigmoid(-gamma)),
+                                        target_tensor)
+
+    @staticmethod
+    def SNR(gamma):
+        """Computes signal to noise ratio (alpha^2/sigma^2) given gamma."""
+        return torch.exp(-gamma)
+
+    def normalize(self, ligand=None, pocket=None):
+        if ligand is not None:
+            ligand['x'] = ligand['x'] / self.norm_values[0]
+
+            # Casting to float in case h still has long or int type.
+            ligand['one_hot'] = \
+                (ligand['one_hot'].float() - self.norm_biases[1]) / \
+                self.norm_values[1]
+
+        if pocket is not None:
+            pocket['x'] = pocket['x'] / self.norm_values[0]
+            pocket['one_hot'] = \
+                (pocket['one_hot'].float() - self.norm_biases[1]) / \
+                self.norm_values[1]
+
+        return ligand, pocket
+
+    def unnormalize(self, x, h_cat):
+        x = x * self.norm_values[0]
+        h_cat = h_cat * self.norm_values[1] + self.norm_biases[1]
+
+        return x, h_cat
+
+    def unnormalize_z(self, z_lig, z_pocket):
+        # Parse from z
+        x_lig, h_lig = z_lig[:, :self.n_dims], z_lig[:, self.n_dims:]
+        x_pocket, h_pocket = z_pocket[:, :self.n_dims], z_pocket[:, self.n_dims:]
+
+        # Unnormalize
+        x_lig, h_lig = self.unnormalize(x_lig, h_lig)
+        x_pocket, h_pocket = self.unnormalize(x_pocket, h_pocket)
+        return torch.cat([x_lig, h_lig], dim=1), \
+               torch.cat([x_pocket, h_pocket], dim=1)
+
+    def subspace_dimensionality(self, input_size):
+        """Compute the dimensionality on translation-invariant linear subspace
+        where distributions on x are defined."""
+        return (input_size - 1) * self.n_dims
+
+    @staticmethod
+    def remove_mean_batch(x, indices):
+        mean = scatter_mean(x, indices, dim=0)
+        x = x - mean[indices]
+        return x
+
+    @staticmethod
+    def assert_mean_zero_with_mask(x, node_mask, eps=1e-10):
+        largest_value = x.abs().max().item()
+        error = scatter_add(x, node_mask, dim=0).abs().max().item()
+        rel_error = error / (largest_value + eps)
+        assert rel_error < 1e-2, f'Mean is not zero, relative_error {rel_error}'
+
+    @staticmethod
+    def sample_center_gravity_zero_gaussian_batch(size, lig_indices,
+                                                  pocket_indices):
+        assert len(size) == 2
+        x = torch.randn(size, device=lig_indices.device)
+
+        # This projection only works because Gaussian is rotation invariant
+        # around zero and samples are independent!
+        x_projected = EnVariationalDiffusion.remove_mean_batch(
+            x, torch.cat((lig_indices, pocket_indices)))
+        return x_projected
+
+    @staticmethod
+    def sum_except_batch(x, indices):
+        return scatter_add(x.sum(-1), indices, dim=0)
+
+    @staticmethod
+    def cdf_standard_gaussian(x):
+        return 0.5 * (1. + torch.erf(x / math.sqrt(2)))
+
+    @staticmethod
+    def sample_gaussian(size, device):
+        x = torch.randn(size, device=device)
+        return x
+
+
+class DistributionNodes:
+    def __init__(self, histogram):
+
+        histogram = torch.tensor(histogram).float()
+        histogram = histogram + 1e-3  # for numerical stability
+
+        prob = histogram / histogram.sum()
+
+        self.idx_to_n_nodes = torch.tensor(
+            [[(i, j) for j in range(prob.shape[1])] for i in range(prob.shape[0])]
+        ).view(-1, 2)
+
+        self.n_nodes_to_idx = {tuple(x.tolist()): i
+                               for i, x in enumerate(self.idx_to_n_nodes)}
+
+        self.prob = prob
+        self.m = torch.distributions.Categorical(self.prob.view(-1),
+                                                 validate_args=True)
+
+        self.n1_given_n2 = \
+            [torch.distributions.Categorical(prob[:, j], validate_args=True)
+             for j in range(prob.shape[1])]
+        self.n2_given_n1 = \
+            [torch.distributions.Categorical(prob[i, :], validate_args=True)
+             for i in range(prob.shape[0])]
+
+        # entropy = -torch.sum(self.prob.view(-1) * torch.log(self.prob.view(-1) + 1e-30))
+        entropy = self.m.entropy()
+        print("Entropy of n_nodes: H[N]", entropy.item())
+
+    def sample(self, n_samples=1):
+        idx = self.m.sample((n_samples,))
+        num_nodes_lig, num_nodes_pocket = self.idx_to_n_nodes[idx].T
+        return num_nodes_lig, num_nodes_pocket
+
+    def sample_conditional(self, n1=None, n2=None):
+        assert (n1 is None) ^ (n2 is None), \
+            "Exactly one input argument must be None"
+
+        m = self.n1_given_n2 if n2 is not None else self.n2_given_n1
+        c = n2 if n2 is not None else n1
+
+        return torch.tensor([m[i].sample() for i in c], device=c.device)
+
+    def log_prob(self, batch_n_nodes_1, batch_n_nodes_2):
+        assert len(batch_n_nodes_1.size()) == 1
+        assert len(batch_n_nodes_2.size()) == 1
+
+        idx = torch.tensor(
+            [self.n_nodes_to_idx[(n1, n2)]
+             for n1, n2 in zip(batch_n_nodes_1.tolist(), batch_n_nodes_2.tolist())]
+        )
+
+        # log_probs = torch.log(self.prob.view(-1)[idx] + 1e-30)
+        log_probs = self.m.log_prob(idx)
+
+        return log_probs.to(batch_n_nodes_1.device)
+
+    def log_prob_n1_given_n2(self, n1, n2):
+        assert len(n1.size()) == 1
+        assert len(n2.size()) == 1
+        log_probs = torch.stack([self.n1_given_n2[c].log_prob(i.cpu())
+                                 for i, c in zip(n1, n2)])
+        return log_probs.to(n1.device)
+
+    def log_prob_n2_given_n1(self, n2, n1):
+        assert len(n2.size()) == 1
+        assert len(n1.size()) == 1
+        log_probs = torch.stack([self.n2_given_n1[c].log_prob(i.cpu())
+                                 for i, c in zip(n2, n1)])
+        return log_probs.to(n2.device)
+
+
+class PositiveLinear(torch.nn.Module):
+    """Linear layer with weights forced to be positive."""
+
+    def __init__(self, in_features: int, out_features: int, bias: bool = True,
+                 weight_init_offset: int = -2):
+        super(PositiveLinear, self).__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight = torch.nn.Parameter(
+            torch.empty((out_features, in_features)))
+        if bias:
+            self.bias = torch.nn.Parameter(torch.empty(out_features))
+        else:
+            self.register_parameter('bias', None)
+        self.weight_init_offset = weight_init_offset
+        self.reset_parameters()
+
+    def reset_parameters(self) -> None:
+        torch.nn.init.kaiming_uniform_(self.weight, a=math.sqrt(5))
+
+        with torch.no_grad():
+            self.weight.add_(self.weight_init_offset)
+
+        if self.bias is not None:
+            fan_in, _ = torch.nn.init._calculate_fan_in_and_fan_out(self.weight)
+            bound = 1 / math.sqrt(fan_in) if fan_in > 0 else 0
+            torch.nn.init.uniform_(self.bias, -bound, bound)
+
+    def forward(self, input):
+        positive_weight = F.softplus(self.weight)
+        return F.linear(input, positive_weight, self.bias)
+
+
+class GammaNetwork(torch.nn.Module):
+    """The gamma network models a monotonic increasing function.
+    Construction as in the VDM paper."""
+    def __init__(self):
+        super().__init__()
+
+        self.l1 = PositiveLinear(1, 1)
+        self.l2 = PositiveLinear(1, 1024)
+        self.l3 = PositiveLinear(1024, 1)
+
+        self.gamma_0 = torch.nn.Parameter(torch.tensor([-5.]))
+        self.gamma_1 = torch.nn.Parameter(torch.tensor([10.]))
+        self.show_schedule()
+
+    def show_schedule(self, num_steps=50):
+        t = torch.linspace(0, 1, num_steps).view(num_steps, 1)
+        gamma = self.forward(t)
+        print('Gamma schedule:')
+        print(gamma.detach().cpu().numpy().reshape(num_steps))
+
+    def gamma_tilde(self, t):
+        l1_t = self.l1(t)
+        return l1_t + self.l3(torch.sigmoid(self.l2(l1_t)))
+
+    def forward(self, t):
+        zeros, ones = torch.zeros_like(t), torch.ones_like(t)
+        # Not super efficient.
+        gamma_tilde_0 = self.gamma_tilde(zeros)
+        gamma_tilde_1 = self.gamma_tilde(ones)
+        gamma_tilde_t = self.gamma_tilde(t)
+
+        # Normalize to [0, 1]
+        normalized_gamma = (gamma_tilde_t - gamma_tilde_0) / (
+                gamma_tilde_1 - gamma_tilde_0)
+
+        # Rescale to [gamma_0, gamma_1]
+        gamma = self.gamma_0 + (self.gamma_1 - self.gamma_0) * normalized_gamma
+
+        return gamma
+
+
+def cosine_beta_schedule(timesteps, s=0.008, raise_to_power: float = 1):
+    """
+    cosine schedule
+    as proposed in https://openreview.net/forum?id=-NEXDKk8gZ
+    """
+    steps = timesteps + 2
+    x = np.linspace(0, steps, steps)
+    alphas_cumprod = np.cos(((x / steps) + s) / (1 + s) * np.pi * 0.5) ** 2
+    alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
+    betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
+    betas = np.clip(betas, a_min=0, a_max=0.999)
+    alphas = 1. - betas
+    alphas_cumprod = np.cumprod(alphas, axis=0)
+
+    if raise_to_power != 1:
+        alphas_cumprod = np.power(alphas_cumprod, raise_to_power)
+
+    return alphas_cumprod
+
+
+def clip_noise_schedule(alphas2, clip_value=0.001):
+    """
+    For a noise schedule given by alpha^2, this clips alpha_t / alpha_t-1.
+    This may help improve stability during
+    sampling.
+    """
+    alphas2 = np.concatenate([np.ones(1), alphas2], axis=0)
+
+    alphas_step = (alphas2[1:] / alphas2[:-1])
+
+    alphas_step = np.clip(alphas_step, a_min=clip_value, a_max=1.)
+    alphas2 = np.cumprod(alphas_step, axis=0)
+
+    return alphas2
+
+
+def polynomial_schedule(timesteps: int, s=1e-4, power=3.):
+    """
+    A noise schedule based on a simple polynomial equation: 1 - x^power.
+    """
+    steps = timesteps + 1
+    x = np.linspace(0, steps, steps)
+    alphas2 = (1 - np.power(x / steps, power))**2
+
+    alphas2 = clip_noise_schedule(alphas2, clip_value=0.001)
+
+    precision = 1 - 2 * s
+
+    alphas2 = precision * alphas2 + s
+
+    return alphas2
+
+
+class PredefinedNoiseSchedule(torch.nn.Module):
+    """
+    Predefined noise schedule. Essentially creates a lookup array for predefined
+    (non-learned) noise schedules.
+    """
+    def __init__(self, noise_schedule, timesteps, precision):
+        super(PredefinedNoiseSchedule, self).__init__()
+        self.timesteps = timesteps
+
+        if noise_schedule == 'cosine':
+            alphas2 = cosine_beta_schedule(timesteps)
+        elif 'polynomial' in noise_schedule:
+            splits = noise_schedule.split('_')
+            assert len(splits) == 2
+            power = float(splits[1])
+            alphas2 = polynomial_schedule(timesteps, s=precision, power=power)
+        else:
+            raise ValueError(noise_schedule)
+
+        sigmas2 = 1 - alphas2
+
+        log_alphas2 = np.log(alphas2)
+        log_sigmas2 = np.log(sigmas2)
+
+        log_alphas2_to_sigmas2 = log_alphas2 - log_sigmas2
+
+        self.gamma = torch.nn.Parameter(
+            torch.from_numpy(-log_alphas2_to_sigmas2).float(),
+            requires_grad=False)
+
+    def forward(self, t):
+        t_int = torch.round(t * self.timesteps).long()
+        return self.gamma[t_int]

example/3rfm_B_CFF.sdf

@@ -0,0 +1,77 @@
+CFF
+  ModelServer 0.9.11
+
+ 14 15  0  0  0  0  0  0  0  0  0
+    9.1740  -33.1560  -31.8810 N   0  0  0  0  0  0  0  0  0  0  0  0
+    9.5110  -33.9730  -32.9480 C   0  0  0  0  0  0  0  0  0  0  0  0
+   10.1800  -32.7900  -30.8620 C   0  0  0  0  0  0  0  0  0  0  0  0
+    7.8800  -32.6980  -31.7480 C   0  0  0  0  0  0  0  0  0  0  0  0
+    8.5600  -34.3290  -33.8820 N   0  0  0  0  0  0  0  0  0  0  0  0
+   10.7810  -34.4320  -33.0790 O   0  0  0  0  0  0  0  0  0  0  0  0
+    8.9230  -35.2040  -35.0040 C   0  0  0  0  0  0  0  0  0  0  0  0
+    7.2870  -33.8640  -33.7350 C   0  0  0  0  0  0  0  0  0  0  0  0
+    6.9250  -33.0680  -32.6990 C   0  0  0  0  0  0  0  0  0  0  0  0
+    6.2400  -34.1120  -34.5500 N   0  0  0  0  0  0  0  0  0  0  0  0
+    7.5520  -31.9080  -30.7050 O   0  0  0  0  0  0  0  0  0  0  0  0
+    5.6170  -32.7750  -32.8280 N   0  0  0  0  0  0  0  0  0  0  0  0
+    5.2350  -33.4220  -33.9540 C   0  0  0  0  0  0  0  0  0  0  0  0
+    4.7270  -31.9750  -31.9940 C   0  0  0  0  0  0  0  0  0  0  0  0
+  1  2  1  0  0  0  0
+  1  3  1  0  0  0  0
+  1  4  1  0  0  0  0
+  2  5  1  0  0  0  0
+  2  6  2  0  0  0  0
+  4  9  1  0  0  0  0
+  4 11  2  0  0  0  0
+  5  7  1  0  0  0  0
+  5  8  1  0  0  0  0
+  8  9  2  0  0  0  0
+  8 10  1  0  0  0  0
+  9 12  1  0  0  0  0
+ 10 13  2  0  0  0  0
+ 12 13  1  0  0  0  0
+ 12 14  1  0  0  0  0
+M  END
+> <model_server_result.job_id>
+yPgH9SanFvk0wz61gS-2-A
+
+> <model_server_result.datetime_utc>
+2024-06-19 19:43:15
+
+> <model_server_result.server_version>
+0.9.11
+
+> <model_server_result.query_name>
+ligand
+
+> <model_server_result.source_id>
+pdb-bcif
+
+> <model_server_result.entry_id>
+3rfm
+
+> <model_server_params.name>
+atom_site
+
+> <model_server_params.value>
+{"label_asym_id":"B","auth_seq_id":330}
+
+> <model_server_stats.io_time_ms>
+58
+
+> <model_server_stats.parse_time_ms>
+37
+
+> <model_server_stats.create_model_time_ms>
+3
+
+> <model_server_stats.query_time_ms>
+262
+
+> <model_server_stats.encode_time_ms>
+0
+
+> <model_server_stats.element_count>
+14
+
+$$$$

example/5ndu_C_8V2.sdf

@@ -0,0 +1,236 @@
+8V2
+  ModelServer 0.9.11
+
+ 91 97  0  0  1  0  0  0  0  0  0
+   -2.1940  -12.9610   26.5400 O   0  0  0  0  0  0  0  0  0  0  0  0
+   -4.8100   -9.4260   21.7910 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -8.1270   -5.8030   26.7400 O   0  0  0  0  0  0  0  0  0  0  0  0
+  -11.9880   -0.1610   25.5730 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -14.5120   -1.3900   25.7970 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -12.7190   -1.1730   29.4710 O   0  0  0  0  0  0  0  0  0  0  0  0
+   -4.7170   -6.2870   23.5540 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.3950  -12.4570   26.0960 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.4630   -5.7030   26.3340 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -9.3280   -3.1330   28.0820 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -10.6630   -2.4060   27.8600 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -10.9210   -2.1690   26.3410 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -12.0780   -1.4870   26.0700 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -13.3390   -2.0460   26.1190 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -13.1760    0.5220   25.2870 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -14.4120   -0.0670   25.3540 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.3350  -11.9920   24.7490 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.4890   -7.0560   25.8620 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.0930   -8.6240   24.0310 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.1000   -7.0580   22.3380 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -4.2420   -4.2060   27.7660 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -4.2080   -9.5890   24.6460 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -7.2860   -4.2920   29.7570 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.2240   -4.9870   28.6610 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.9000   -4.2090   29.5940 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -9.9310   -6.0190   30.2140 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.6910  -13.0290   23.7030 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -10.4970   -4.9760   29.2580 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -7.4870   -5.4460   27.7140 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -11.5960   -0.6690   29.3880 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -11.3020    0.6340   30.1490 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -8.7140   -6.3850   29.5490 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -8.1170   -5.0850   28.9210 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.1950  -12.8950   23.6280 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.3160  -11.3490   23.4180 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.1650  -10.7450   22.1100 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -4.4700   -8.3770   22.6460 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.3260  -14.3380   26.9150 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -4.0420   -5.2940   26.7290 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -4.2660  -10.8780   24.3810 N   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.1320   -7.3040   24.6240 N   0  0  0  0  0  0  0  0  0  0  0  0
+   -6.1660   -5.4790   27.6010 N   0  0  0  0  0  0  0  0  0  0  0  0
+  -10.5890   -1.1050   28.6090 N   0  0  0  0  0  0  0  0  0  0  0  0
+   -9.3500   -4.3230   28.7690 N   0  0  0  0  0  0  0  0  0  0  0  0
+   -4.3680  -12.2620   26.8450 O   0  0  0  0  0  0  0  0  0  0  0  0
+   -8.2700   -2.7530   27.5440 O   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.8340   -7.9950   26.6010 O   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.3200   -9.2290   25.4600 O   0  0  0  0  0  0  0  0  0  0  0  0
+  -13.5690   -3.6750   26.6640 CL  0  0  0  0  0  0  0  0  0  0  0  0
+   -4.8050   -9.1860   20.7280 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -11.0240    0.3430   25.4990 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -15.4800   -1.8820   25.8960 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.2340   -5.3290   23.6350 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.6350   -6.1450   23.5920 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.8730   -5.0030   25.6060 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -11.4760   -3.0100   28.2660 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -10.0840   -1.6100   25.9260 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -10.9710   -3.1390   25.8500 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -13.1100    1.5470   24.9230 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -15.3080    0.5000   25.1020 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.2950  -11.6950   24.6160 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -6.1150   -8.9750   23.8830 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -6.1850   -7.1780   22.3120 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -4.7490   -6.5980   21.4110 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -4.7440   -3.3520   27.3060 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.3360   -3.8870   28.2870 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -7.7600   -3.6350   30.4860 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -4.7660   -5.8510   29.1420 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.3300   -3.5360   30.2340 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -10.4620   -6.9010   30.4120 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -9.5090   -5.5750   31.0650 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.3250  -12.6930   22.7310 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.3040  -14.0260   23.9230 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -10.9230   -5.5090   28.4040 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -11.2520   -4.3190   29.6970 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -10.5790    1.2270   29.5880 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -10.8930    0.3960   31.1310 H   0  0  0  0  0  0  0  0  0  0  0  0
+  -12.2250    1.2020   30.2670 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -8.0110   -7.0140   30.1000 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -9.0890   -6.9500   28.6920 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.7010  -13.4820   22.8600 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.5750  -13.1570   24.6170 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -6.3170  -11.0600   23.7390 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.4170  -11.3840   21.2630 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.3930   -8.2400   22.7390 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.3630  -14.7140   27.2620 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.6520  -14.9190   26.0530 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.0610  -14.4280   27.7140 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.4060   -5.0410   25.8790 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.5980   -6.1200   27.2860 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -9.7140   -0.6210   28.6200 H   0  0  0  0  0  0  0  0  0  0  0  0
+  1  8  1  0  0  0  0
+  1 38  1  0  0  0  0
+  2 36  2  0  0  0  0
+  2 37  1  0  0  0  0
+  2 50  1  0  0  0  0
+  3 29  2  0  0  0  0
+  4 15  1  0  0  0  0
+  4 13  2  0  0  0  0
+  4 51  1  0  0  0  0
+  5 16  1  0  0  0  0
+  5 14  2  0  0  0  0
+  5 52  1  0  0  0  0
+  6 30  2  0  0  0  0
+  7 20  1  0  0  0  0
+  7 41  1  0  0  0  0
+  7 53  1  0  0  0  0
+  7 54  1  0  0  0  0
+  8 17  1  0  0  0  0
+  8 45  2  0  0  0  0
+  9 18  1  0  0  0  0
+  9 39  1  0  0  0  0
+  9 42  1  0  0  0  0
+  9 55  1  0  0  0  0
+ 10 46  2  0  0  0  0
+ 10 11  1  0  0  0  0
+ 10 44  1  0  0  0  0
+ 11 12  1  0  0  0  0
+ 11 43  1  0  0  0  0
+ 11 56  1  0  0  0  0
+ 12 13  1  0  0  0  0
+ 12 57  1  0  0  0  0
+ 12 58  1  0  0  0  0
+ 13 14  1  0  0  0  0
+ 14 49  1  0  0  0  0
+ 15 16  2  0  0  0  0
+ 15 59  1  0  0  0  0
+ 16 60  1  0  0  0  0
+ 17 27  1  0  0  0  0
+ 17 40  1  0  0  0  0
+ 17 61  1  0  0  0  0
+ 18 41  1  0  0  0  0
+ 18 47  2  0  0  0  0
+ 19 37  1  0  0  0  0
+ 19 41  1  0  0  0  0
+ 19 22  1  0  0  0  0
+ 19 62  1  0  0  0  0
+ 20 37  1  0  0  0  0
+ 20 63  1  0  0  0  0
+ 20 64  1  0  0  0  0
+ 21 39  1  0  0  0  0
+ 21 24  1  0  0  0  0
+ 21 65  1  0  0  0  0
+ 21 66  1  0  0  0  0
+ 22 40  1  0  0  0  0
+ 22 48  2  0  0  0  0
+ 23 33  1  0  0  0  0
+ 23 25  2  0  0  0  0
+ 23 67  1  0  0  0  0
+ 24 42  1  0  0  0  0
+ 24 25  1  0  0  0  0
+ 24 68  1  0  0  0  0
+ 25 69  1  0  0  0  0
+ 26 28  1  0  0  0  0
+ 26 32  1  0  0  0  0
+ 26 70  1  0  0  0  0
+ 26 71  1  0  0  0  0
+ 27 34  1  0  0  0  0
+ 27 72  1  0  0  0  0
+ 27 73  1  0  0  0  0
+ 28 44  1  0  0  0  0
+ 28 74  1  0  0  0  0
+ 28 75  1  0  0  0  0
+ 29 42  1  0  0  0  0
+ 29 33  1  0  0  0  0
+ 30 43  1  0  0  0  0
+ 30 31  1  0  0  0  0
+ 31 76  1  0  0  0  0
+ 31 77  1  0  0  0  0
+ 31 78  1  0  0  0  0
+ 32 33  1  0  0  0  0
+ 32 79  1  0  0  0  0
+ 32 80  1  0  0  0  0
+ 33 44  1  0  0  0  0
+ 34 35  1  0  0  0  0
+ 34 81  1  0  0  0  0
+ 34 82  1  0  0  0  0
+ 35 36  1  0  0  0  0
+ 35 40  1  0  0  0  0
+ 35 83  1  0  0  0  0
+ 36 84  1  0  0  0  0
+ 37 85  1  0  0  0  0
+ 38 86  1  0  0  0  0
+ 38 87  1  0  0  0  0
+ 38 88  1  0  0  0  0
+ 39 89  1  0  0  0  0
+ 39 90  1  0  0  0  0
+ 43 91  1  0  0  0  0
+M  END
+> <model_server_result.job_id>
+7nYBEFm_cwFEDILJPHMr2A
+
+> <model_server_result.datetime_utc>
+2024-06-19 19:52:24
+
+> <model_server_result.server_version>
+0.9.11
+
+> <model_server_result.query_name>
+ligand
+
+> <model_server_result.source_id>
+pdb-bcif
+
+> <model_server_result.entry_id>
+5ndu
+
+> <model_server_params.name>
+atom_site
+
+> <model_server_params.value>
+{"label_asym_id":"C","auth_seq_id":201}
+
+> <model_server_stats.io_time_ms>
+3
+
+> <model_server_stats.parse_time_ms>
+185
+
+> <model_server_stats.create_model_time_ms>
+8
+
+> <model_server_stats.query_time_ms>
+252
+
+> <model_server_stats.encode_time_ms>
+0
+
+> <model_server_stats.element_count>
+91
+
+$$$$

example/fragments.sdf

@@ -0,0 +1,41 @@
+fragments
+  PyMOL3.0          3D                             0
+
+ 17 18  0  0  1  0  0  0  0  0999 V2000
+  -12.0780   -1.4870   26.0700 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -11.9880   -0.1610   25.5730 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -13.3390   -2.0460   26.1190 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -13.1760    0.5220   25.2870 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -14.5120   -1.3900   25.7970 C   0  0  0  0  0  0  0  0  0  0  0  0
+  -13.5690   -3.6750   26.6640 Cl  0  0  0  0  0  0  0  0  0  0  0  0
+  -14.4120   -0.0670   25.3540 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.4630   -5.7030   26.3340 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -6.1660   -5.4790   27.6010 N   0  0  0  0  0  0  0  0  0  0  0  0
+   -4.0420   -5.2940   26.7290 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -7.4870   -5.4460   27.7140 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.2240   -4.9870   28.6610 C   0  0  1  0  0  0  0  0  0  0  0  0
+   -4.2420   -4.2060   27.7660 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -8.1170   -5.0850   28.9210 C   0  0  2  0  0  0  0  0  0  0  0  0
+   -8.1270   -5.8030   26.7400 O   0  0  0  0  0  0  0  0  0  0  0  0
+   -5.9000   -4.2090   29.5940 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -7.2860   -4.2920   29.7570 C   0  0  0  0  0  0  0  0  0  0  0  0
+  1  3  4  0  0  0  0
+  1  2  4  0  0  0  0
+  2  4  4  0  0  0  0
+  3  6  1  0  0  0  0
+  4  7  4  0  0  0  0
+  3  5  4  0  0  0  0
+  5  7  4  0  0  0  0
+  8  9  1  0  0  0  0
+  8 10  1  0  0  0  0
+  9 11  1  0  0  0  0
+ 11 14  1  0  0  0  0
+  9 12  1  0  0  0  0
+ 12 13  1  0  0  0  0
+ 12 16  1  0  0  0  0
+ 10 13  1  0  0  0  0
+ 11 15  2  0  0  0  0
+ 14 17  1  0  0  0  0
+ 16 17  2  0  0  0  0
+M  END
+$$$$

generate_ligands.py

@@ -0,0 +1,60 @@
+import argparse
+from pathlib import Path
+
+import torch
+from openbabel import openbabel
+openbabel.obErrorLog.StopLogging()  # suppress OpenBabel messages
+
+import utils
+from lightning_modules import LigandPocketDDPM
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('checkpoint', type=Path)
+    parser.add_argument('--pdbfile', type=str)
+    parser.add_argument('--resi_list', type=str, nargs='+', default=None)
+    parser.add_argument('--ref_ligand', type=str, default=None)
+    parser.add_argument('--outfile', type=Path)
+    parser.add_argument('--n_samples', type=int, default=20)
+    parser.add_argument('--batch_size', type=int, default=None)
+    parser.add_argument('--num_nodes_lig', type=int, default=None)
+    parser.add_argument('--all_frags', action='store_true')
+    parser.add_argument('--sanitize', action='store_true')
+    parser.add_argument('--relax', action='store_true')
+    parser.add_argument('--resamplings', type=int, default=10)
+    parser.add_argument('--jump_length', type=int, default=1)
+    parser.add_argument('--timesteps', type=int, default=None)
+    args = parser.parse_args()
+
+    pdb_id = Path(args.pdbfile).stem
+
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    if args.batch_size is None:
+        args.batch_size = args.n_samples
+    assert args.n_samples % args.batch_size == 0
+
+    # Load model
+    model = LigandPocketDDPM.load_from_checkpoint(
+        args.checkpoint, map_location=device)
+    model = model.to(device)
+
+    if args.num_nodes_lig is not None:
+        num_nodes_lig = torch.ones(args.n_samples, dtype=int) * \
+                        args.num_nodes_lig
+    else:
+        num_nodes_lig = None
+
+    molecules = []
+    for i in range(args.n_samples // args.batch_size):
+        molecules_batch = model.generate_ligands(
+            args.pdbfile, args.batch_size, args.resi_list, args.ref_ligand,
+            num_nodes_lig, args.sanitize, largest_frag=not args.all_frags,
+            relax_iter=(200 if args.relax else 0),
+            resamplings=args.resamplings, jump_length=args.jump_length,
+            timesteps=args.timesteps)
+        molecules.extend(molecules_batch)
+
+    # Make SDF files
+    utils.write_sdf_file(args.outfile, molecules)

geometry_utils.py

@@ -0,0 +1,141 @@
+import numpy as np
+
+from constants import CA_C_DIST, N_CA_DIST, N_CA_C_ANGLE
+
+
+def rotation_matrix(angle, axis):
+    """
+    Args:
+        angle: (n,)
+        axis: 0=x, 1=y, 2=z
+    Returns:
+        (n, 3, 3)
+    """
+    n = len(angle)
+    R = np.eye(3)[None, :, :].repeat(n, axis=0)
+
+    axis = 2 - axis
+    start = axis // 2
+    step = axis % 2 + 1
+    s = slice(start, start + step + 1, step)
+
+    R[:, s, s] = np.array(
+        [[np.cos(angle), (-1) ** (axis + 1) * np.sin(angle)],
+         [(-1) ** axis * np.sin(angle), np.cos(angle)]]
+    ).transpose(2, 0, 1)
+    return R
+
+
+def get_bb_transform(n_xyz, ca_xyz, c_xyz):
+    """
+    Compute translation and rotation of the canoncical backbone frame (triangle N-Ca-C) from a position with
+    Ca at the origin, N on the x-axis and C in the xy-plane to the global position of the backbone frame
+
+    Args:
+        n_xyz: (n, 3)
+        ca_xyz: (n, 3)
+        c_xyz: (n, 3)
+
+    Returns:
+        quaternion represented as array of shape (n, 4)
+        translation vector which is an array of shape (n, 3)
+    """
+
+    translation = ca_xyz
+    n_xyz = n_xyz - translation
+    c_xyz = c_xyz - translation
+
+    # Find rotation matrix that aligns the coordinate systems
+    #    rotate around y-axis to move N into the xy-plane
+    theta_y = np.arctan2(n_xyz[:, 2], -n_xyz[:, 0])
+    Ry = rotation_matrix(theta_y, 1)
+    n_xyz = np.einsum('noi,ni->no', Ry.transpose(0, 2, 1), n_xyz)
+
+    #    rotate around z-axis to move N onto the x-axis
+    theta_z = np.arctan2(n_xyz[:, 1], n_xyz[:, 0])
+    Rz = rotation_matrix(theta_z, 2)
+    # n_xyz = np.einsum('noi,ni->no', Rz.transpose(0, 2, 1), n_xyz)
+
+    #    rotate around x-axis to move C into the xy-plane
+    c_xyz = np.einsum('noj,nji,ni->no', Rz.transpose(0, 2, 1),
+                      Ry.transpose(0, 2, 1), c_xyz)
+    theta_x = np.arctan2(c_xyz[:, 2], c_xyz[:, 1])
+    Rx = rotation_matrix(theta_x, 0)
+
+    # Final rotation matrix
+    R = np.einsum('nok,nkj,nji->noi', Ry, Rz, Rx)
+
+    # Convert to quaternion
+    # q = w + i*u_x + j*u_y + k * u_z
+    quaternion = rotation_matrix_to_quaternion(R)
+
+    return quaternion, translation
+
+
+def get_bb_coords_from_transform(ca_coords, quaternion):
+    """
+    Args:
+        ca_coords: (n, 3)
+        quaternion: (n, 4)
+    Returns:
+        backbone coords (n*3, 3), order is [N, CA, C]
+        backbone atom types as a list of length n*3
+    """
+    R = quaternion_to_rotation_matrix(quaternion)
+    bb_coords = np.tile(np.array(
+        [[N_CA_DIST, 0, 0],
+         [0, 0, 0],
+         [CA_C_DIST * np.cos(N_CA_C_ANGLE), CA_C_DIST * np.sin(N_CA_C_ANGLE), 0]]),
+        [len(ca_coords), 1])
+    bb_coords = np.einsum('noi,ni->no', R.repeat(3, axis=0), bb_coords) + ca_coords.repeat(3, axis=0)
+    bb_atom_types = [t for _ in range(len(ca_coords)) for t in ['N', 'C', 'C']]
+
+    return bb_coords, bb_atom_types
+
+
+def quaternion_to_rotation_matrix(q):
+    """
+    x_rot = R x
+
+    Args:
+        q: (n, 4)
+    Returns:
+        R: (n, 3, 3)
+    """
+    # Normalize
+    q = q / (q ** 2).sum(1, keepdims=True) ** 0.5
+
+    # https://en.wikipedia.org/wiki/Rotation_matrix#Quaternion
+    w, x, y, z = q[:, 0], q[:, 1], q[:, 2], q[:, 3]
+    R = np.stack([
+        np.stack([1 - 2 * y ** 2 - 2 * z ** 2, 2 * x * y - 2 * z * w,
+                  2 * x * z + 2 * y * w], axis=1),
+        np.stack([2 * x * y + 2 * z * w, 1 - 2 * x ** 2 - 2 * z ** 2,
+                  2 * y * z - 2 * x * w], axis=1),
+        np.stack([2 * x * z - 2 * y * w, 2 * y * z + 2 * x * w,
+                  1 - 2 * x ** 2 - 2 * y ** 2], axis=1)
+    ], axis=1)
+
+    return R
+
+
+def rotation_matrix_to_quaternion(R):
+    """
+    https://en.wikipedia.org/wiki/Rotation_matrix#Quaternion
+    Args:
+        R: (n, 3, 3)
+    Returns:
+        q: (n, 4)
+    """
+
+    t = R[:, 0, 0] + R[:, 1, 1] + R[:, 2, 2]
+    r = np.sqrt(1 + t)
+    w = 0.5 * r
+    x = np.sign(R[:, 2, 1] - R[:, 1, 2]) * np.abs(
+        0.5 * np.sqrt(1 + R[:, 0, 0] - R[:, 1, 1] - R[:, 2, 2]))
+    y = np.sign(R[:, 0, 2] - R[:, 2, 0]) * np.abs(
+        0.5 * np.sqrt(1 - R[:, 0, 0] + R[:, 1, 1] - R[:, 2, 2]))
+    z = np.sign(R[:, 1, 0] - R[:, 0, 1]) * np.abs(
+        0.5 * np.sqrt(1 - R[:, 0, 0] - R[:, 1, 1] + R[:, 2, 2]))
+
+    return np.stack((w, x, y, z), axis=1)

inpaint.py

@@ -0,0 +1,230 @@
+import argparse
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from Bio.PDB import PDBParser
+from rdkit import Chem
+from torch_scatter import scatter_mean
+from openbabel import openbabel
+openbabel.obErrorLog.StopLogging()  # suppress OpenBabel messages
+
+import utils
+from lightning_modules import LigandPocketDDPM
+from constants import FLOAT_TYPE, INT_TYPE
+from analysis.molecule_builder import build_molecule, process_molecule
+
+
+def prepare_from_sdf_files(sdf_files, atom_encoder):
+
+    ligand_coords = []
+    atom_one_hot = []
+    for file in sdf_files:
+        rdmol = Chem.SDMolSupplier(str(file), sanitize=False)[0]
+        ligand_coords.append(
+            torch.from_numpy(rdmol.GetConformer().GetPositions()).float()
+        )
+        types = torch.tensor([atom_encoder[a.GetSymbol()] for a in rdmol.GetAtoms()])
+        atom_one_hot.append(
+            F.one_hot(types, num_classes=len(atom_encoder))
+        )
+
+    return torch.cat(ligand_coords, dim=0), torch.cat(atom_one_hot, dim=0)
+
+
+def prepare_ligand_from_pdb(biopython_atoms, atom_encoder):
+
+    coord = torch.tensor(np.array([a.get_coord()
+                                   for a in biopython_atoms]), dtype=FLOAT_TYPE)
+    types = torch.tensor([atom_encoder[a.element.capitalize()]
+                          for a in biopython_atoms])
+    one_hot = F.one_hot(types, num_classes=len(atom_encoder))
+
+    return coord, one_hot
+
+
+def prepare_substructure(ref_ligand, fix_atoms, pdb_model):
+
+    if fix_atoms[0].endswith(".sdf"):
+        # ligand as sdf file
+        coord, one_hot = prepare_from_sdf_files(fix_atoms, model.lig_type_encoder)
+
+    else:
+        # ligand contained in PDB; given in <chain>:<resi> format
+        chain, resi = ref_ligand.split(':')
+        ligand = utils.get_residue_with_resi(pdb_model[chain], int(resi))
+        fixed_atoms = [a for a in ligand.get_atoms() if a.get_name() in set(fix_atoms)]
+        coord, one_hot = prepare_ligand_from_pdb(fixed_atoms, model.lig_type_encoder)
+
+    return coord, one_hot
+
+
+def inpaint_ligand(model, pdb_file, n_samples, ligand, fix_atoms,
+                   add_n_nodes=None, center='ligand', sanitize=False,
+                   largest_frag=False, relax_iter=0, timesteps=None,
+                   resamplings=1, save_traj=False):
+    """
+    Generate ligands given a pocket
+    Args:
+        model: Lightning model
+        pdb_file: PDB filename
+        n_samples: number of samples
+        ligand: reference ligand given in <chain>:<resi> format if the ligand is
+                contained in the PDB file, or path to an SDF file that
+                contains the ligand; used to define the pocket
+        fix_atoms: ligand atoms that should be fixed, e.g. "C1 N6 C5 C12"
+        center: 'ligand' or 'pocket'
+        add_n_nodes: number of ligand nodes to add, sampled randomly if 'None'
+        sanitize: whether to sanitize molecules or not
+        largest_frag: only return the largest fragment
+        relax_iter: number of force field optimization steps
+        timesteps: number of denoising steps, use training value if None
+        resamplings: number of resampling iterations
+        save_traj: save intermediate states to visualize a denoising trajectory
+    Returns:
+        list of molecules
+    """
+    if save_traj and n_samples > 1:
+        raise NotImplementedError("Can only visualize trajectory with "
+                                  "n_samples=1.")
+    frames = timesteps if save_traj else 1
+    sanitize = False if save_traj else sanitize
+    relax_iter = 0 if save_traj else relax_iter
+    largest_frag = False if save_traj else largest_frag
+
+    # Load PDB
+    pdb_model = PDBParser(QUIET=True).get_structure('', pdb_file)[0]
+
+    # Define pocket based on reference ligand
+    residues = utils.get_pocket_from_ligand(pdb_model, ligand)
+    pocket = model.prepare_pocket(residues, repeats=n_samples)
+
+    # Get fixed ligand substructure
+    x_fixed, one_hot_fixed = prepare_substructure(ligand, fix_atoms, pdb_model)
+    n_fixed = len(x_fixed)
+
+    if add_n_nodes is None:
+        num_nodes_lig = model.ddpm.size_distribution.sample_conditional(
+            n1=None, n2=pocket['size'])
+        num_nodes_lig = torch.clamp(num_nodes_lig, min=n_fixed)
+    else:
+        num_nodes_lig = torch.ones(n_samples, dtype=int) * n_fixed + add_n_nodes
+
+    ligand_mask = utils.num_nodes_to_batch_mask(
+        len(num_nodes_lig), num_nodes_lig, model.device)
+
+    ligand = {
+        'x': torch.zeros((len(ligand_mask), model.x_dims),
+                         device=model.device, dtype=FLOAT_TYPE),
+        'one_hot': torch.zeros((len(ligand_mask), model.atom_nf),
+                               device=model.device, dtype=FLOAT_TYPE),
+        'size': num_nodes_lig,
+        'mask': ligand_mask
+    }
+
+    # fill in fixed atoms
+    lig_fixed = torch.zeros_like(ligand_mask)
+    for i in range(n_samples):
+        sele = (ligand_mask == i)
+
+        x_new = ligand['x'][sele]
+        x_new[:n_fixed] = x_fixed
+        ligand['x'][sele] = x_new
+
+        h_new = ligand['one_hot'][sele]
+        h_new[:n_fixed] = one_hot_fixed
+        ligand['one_hot'][sele] = h_new
+
+        fixed_new = lig_fixed[sele]
+        fixed_new[:n_fixed] = 1
+        lig_fixed[sele] = fixed_new
+
+    # Pocket's center of mass
+    pocket_com_before = scatter_mean(pocket['x'], pocket['mask'], dim=0)
+
+    # Run sampling
+    xh_lig, xh_pocket, lig_mask, pocket_mask = model.ddpm.inpaint(
+        ligand, pocket, lig_fixed, center=center,
+        resamplings=resamplings, timesteps=timesteps, return_frames=frames)
+
+    # Treat intermediate states as molecules for downstream processing
+    if save_traj:
+        xh_lig = utils.reverse_tensor(xh_lig)
+        xh_pocket = utils.reverse_tensor(xh_pocket)
+
+        lig_mask = torch.arange(xh_lig.size(0), device=model.device
+                                ).repeat_interleave(len(lig_mask))
+        pocket_mask = torch.arange(xh_pocket.size(0), device=model.device
+                                   ).repeat_interleave(len(pocket_mask))
+
+        xh_lig = xh_lig.view(-1, xh_lig.size(2))
+        xh_pocket = xh_pocket.view(-1, xh_pocket.size(2))
+
+    # Move generated molecule back to the original pocket position
+    pocket_com_after = scatter_mean(xh_pocket[:, :model.x_dims], pocket_mask, dim=0)
+
+    xh_pocket[:, :model.x_dims] += \
+        (pocket_com_before - pocket_com_after)[pocket_mask]
+    xh_lig[:, :model.x_dims] += \
+        (pocket_com_before - pocket_com_after)[lig_mask]
+
+    # Build mol objects
+    x = xh_lig[:, :model.x_dims].detach().cpu()
+    atom_type = xh_lig[:, model.x_dims:].argmax(1).detach().cpu()
+
+    molecules = []
+    for mol_pc in zip(utils.batch_to_list(x, lig_mask),
+                      utils.batch_to_list(atom_type, lig_mask)):
+
+        mol = build_molecule(*mol_pc, model.dataset_info, add_coords=True)
+        mol = process_molecule(mol,
+                               add_hydrogens=False,
+                               sanitize=sanitize,
+                               relax_iter=relax_iter,
+                               largest_frag=largest_frag)
+        if mol is not None:
+            molecules.append(mol)
+
+    return molecules
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('checkpoint', type=Path)
+    parser.add_argument('--pdbfile', type=str)
+    parser.add_argument('--ref_ligand', type=str, default=None)
+    parser.add_argument('--fix_atoms', type=str, nargs='+', default=None)
+    parser.add_argument('--center', type=str, default='ligand', choices={'ligand', 'pocket'})
+    parser.add_argument('--outfile', type=Path)
+    parser.add_argument('--n_samples', type=int, default=20)
+    parser.add_argument('--add_n_nodes', type=int, default=None)
+    parser.add_argument('--relax', action='store_true')
+    parser.add_argument('--sanitize', action='store_true')
+    parser.add_argument('--resamplings', type=int, default=20)
+    parser.add_argument('--timesteps', type=int, default=50)
+    parser.add_argument('--save_traj', action='store_true')
+    args = parser.parse_args()
+
+    pdb_id = Path(args.pdbfile).stem
+
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    # Load model
+    model = LigandPocketDDPM.load_from_checkpoint(
+        args.checkpoint, map_location=device)
+    model = model.to(device)
+
+    molecules = inpaint_ligand(model, args.pdbfile, args.n_samples,
+                               args.ref_ligand, args.fix_atoms,
+                               args.add_n_nodes, center=args.center,
+                               sanitize=args.sanitize,
+                               largest_frag=False,
+                               relax_iter=(200 if args.relax else 0),
+                               timesteps=args.timesteps,
+                               resamplings=args.resamplings,
+                               save_traj=args.save_traj)
+
+    # Make SDF files
+    utils.write_sdf_file(args.outfile, molecules)

lightning_modules.py

@@ -0,0 +1,914 @@
+import math
+from argparse import Namespace
+from typing import Optional
+from time import time
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+import pytorch_lightning as pl
+import wandb
+from torch_scatter import scatter_add, scatter_mean
+from Bio.PDB import PDBParser
+from Bio.PDB.Polypeptide import three_to_one
+
+from constants import dataset_params, FLOAT_TYPE, INT_TYPE
+from equivariant_diffusion.dynamics import EGNNDynamics
+from equivariant_diffusion.en_diffusion import EnVariationalDiffusion
+from equivariant_diffusion.conditional_model import ConditionalDDPM, \
+    SimpleConditionalDDPM
+from dataset import ProcessedLigandPocketDataset
+import utils
+from analysis.visualization import save_xyz_file, visualize, visualize_chain
+from analysis.metrics import BasicMolecularMetrics, CategoricalDistribution, \
+    MoleculeProperties
+from analysis.molecule_builder import build_molecule, process_molecule
+from analysis.docking import smina_score
+
+
+class LigandPocketDDPM(pl.LightningModule):
+    def __init__(
+            self,
+            outdir,
+            dataset,
+            datadir,
+            batch_size,
+            lr,
+            egnn_params: Namespace,
+            diffusion_params,
+            num_workers,
+            augment_noise,
+            augment_rotation,
+            clip_grad,
+            eval_epochs,
+            eval_params,
+            visualize_sample_epoch,
+            visualize_chain_epoch,
+            auxiliary_loss,
+            loss_params,
+            mode,
+            node_histogram,
+            pocket_representation='CA',
+            virtual_nodes=False
+    ):
+        super(LigandPocketDDPM, self).__init__()
+        self.save_hyperparameters()
+
+        ddpm_models = {'joint': EnVariationalDiffusion,
+                       'pocket_conditioning': ConditionalDDPM,
+                       'pocket_conditioning_simple': SimpleConditionalDDPM}
+        assert mode in ddpm_models
+        self.mode = mode
+        assert pocket_representation in {'CA', 'full-atom'}
+        self.pocket_representation = pocket_representation
+
+        self.dataset_name = dataset
+        self.datadir = datadir
+        self.outdir = outdir
+        self.batch_size = batch_size
+        self.eval_batch_size = eval_params.eval_batch_size \
+            if 'eval_batch_size' in eval_params else batch_size
+        self.lr = lr
+        self.loss_type = diffusion_params.diffusion_loss_type
+        self.eval_epochs = eval_epochs
+        self.visualize_sample_epoch = visualize_sample_epoch
+        self.visualize_chain_epoch = visualize_chain_epoch
+        self.eval_params = eval_params
+        self.num_workers = num_workers
+        self.augment_noise = augment_noise
+        self.augment_rotation = augment_rotation
+        self.dataset_info = dataset_params[dataset]
+        self.T = diffusion_params.diffusion_steps
+        self.clip_grad = clip_grad
+        if clip_grad:
+            self.gradnorm_queue = utils.Queue()
+            # Add large value that will be flushed.
+            self.gradnorm_queue.add(3000)
+
+        self.lig_type_encoder = self.dataset_info['atom_encoder']
+        self.lig_type_decoder = self.dataset_info['atom_decoder']
+        self.pocket_type_encoder = self.dataset_info['aa_encoder'] \
+            if self.pocket_representation == 'CA' \
+            else self.dataset_info['atom_encoder']
+        self.pocket_type_decoder = self.dataset_info['aa_decoder'] \
+            if self.pocket_representation == 'CA' \
+            else self.dataset_info['atom_decoder']
+
+        smiles_list = None if eval_params.smiles_file is None \
+            else np.load(eval_params.smiles_file)
+        self.ligand_metrics = BasicMolecularMetrics(self.dataset_info,
+                                                    smiles_list)
+        self.molecule_properties = MoleculeProperties()
+        self.ligand_type_distribution = CategoricalDistribution(
+            self.dataset_info['atom_hist'], self.lig_type_encoder)
+        if self.pocket_representation == 'CA':
+            self.pocket_type_distribution = CategoricalDistribution(
+                self.dataset_info['aa_hist'], self.pocket_type_encoder)
+        else:
+            self.pocket_type_distribution = None
+
+        self.train_dataset = None
+        self.val_dataset = None
+        self.test_dataset = None
+
+        self.virtual_nodes = virtual_nodes
+        self.data_transform = None
+        self.max_num_nodes = len(node_histogram) - 1
+        if virtual_nodes:
+            # symbol = 'virtual'
+            symbol = 'Ne'  # visualize as Neon atoms
+            self.lig_type_encoder[symbol] = len(self.lig_type_encoder)
+            self.virtual_atom = self.lig_type_encoder[symbol]
+            self.lig_type_decoder.append(symbol)
+            self.data_transform = utils.AppendVirtualNodes(
+                self.max_num_nodes, self.lig_type_encoder, symbol)
+
+            # Update dataset_info dictionary. This is necessary for using the
+            # visualization functions.
+            self.dataset_info['atom_encoder'] = self.lig_type_encoder
+            self.dataset_info['atom_decoder'] = self.lig_type_decoder
+
+        self.atom_nf = len(self.lig_type_decoder)
+        self.aa_nf = len(self.pocket_type_decoder)
+        self.x_dims = 3
+
+        net_dynamics = EGNNDynamics(
+            atom_nf=self.atom_nf,
+            residue_nf=self.aa_nf,
+            n_dims=self.x_dims,
+            joint_nf=egnn_params.joint_nf,
+            device=egnn_params.device if torch.cuda.is_available() else 'cpu',
+            hidden_nf=egnn_params.hidden_nf,
+            act_fn=torch.nn.SiLU(),
+            n_layers=egnn_params.n_layers,
+            attention=egnn_params.attention,
+            tanh=egnn_params.tanh,
+            norm_constant=egnn_params.norm_constant,
+            inv_sublayers=egnn_params.inv_sublayers,
+            sin_embedding=egnn_params.sin_embedding,
+            normalization_factor=egnn_params.normalization_factor,
+            aggregation_method=egnn_params.aggregation_method,
+            edge_cutoff_ligand=egnn_params.__dict__.get('edge_cutoff_ligand'),
+            edge_cutoff_pocket=egnn_params.__dict__.get('edge_cutoff_pocket'),
+            edge_cutoff_interaction=egnn_params.__dict__.get('edge_cutoff_interaction'),
+            update_pocket_coords=(self.mode == 'joint'),
+            reflection_equivariant=egnn_params.reflection_equivariant,
+            edge_embedding_dim=egnn_params.__dict__.get('edge_embedding_dim'),
+        )
+
+        self.ddpm = ddpm_models[self.mode](
+                dynamics=net_dynamics,
+                atom_nf=self.atom_nf,
+                residue_nf=self.aa_nf,
+                n_dims=self.x_dims,
+                timesteps=diffusion_params.diffusion_steps,
+                noise_schedule=diffusion_params.diffusion_noise_schedule,
+                noise_precision=diffusion_params.diffusion_noise_precision,
+                loss_type=diffusion_params.diffusion_loss_type,
+                norm_values=diffusion_params.normalize_factors,
+                size_histogram=node_histogram,
+                virtual_node_idx=self.lig_type_encoder[symbol] if virtual_nodes else None
+        )
+
+        self.auxiliary_loss = auxiliary_loss
+        self.lj_rm = self.dataset_info['lennard_jones_rm']
+        if self.auxiliary_loss:
+            self.clamp_lj = loss_params.clamp_lj
+            self.auxiliary_weight_schedule = WeightSchedule(
+                T=diffusion_params.diffusion_steps,
+                max_weight=loss_params.max_weight, mode=loss_params.schedule)
+
+    def configure_optimizers(self):
+        return torch.optim.AdamW(self.ddpm.parameters(), lr=self.lr,
+                                 amsgrad=True, weight_decay=1e-12)
+
+    def setup(self, stage: Optional[str] = None):
+        if stage == 'fit':
+            self.train_dataset = ProcessedLigandPocketDataset(
+                Path(self.datadir, 'train.npz'), transform=self.data_transform)
+            self.val_dataset = ProcessedLigandPocketDataset(
+                Path(self.datadir, 'val.npz'), transform=self.data_transform)
+        elif stage == 'test':
+            self.test_dataset = ProcessedLigandPocketDataset(
+                Path(self.datadir, 'test.npz'), transform=self.data_transform)
+        else:
+            raise NotImplementedError
+
+    def train_dataloader(self):
+        return DataLoader(self.train_dataset, self.batch_size, shuffle=True,
+                          num_workers=self.num_workers,
+                          collate_fn=self.train_dataset.collate_fn,
+                          pin_memory=True)
+
+    def val_dataloader(self):
+        return DataLoader(self.val_dataset, self.batch_size, shuffle=False,
+                          num_workers=self.num_workers,
+                          collate_fn=self.val_dataset.collate_fn,
+                          pin_memory=True)
+
+    def test_dataloader(self):
+        return DataLoader(self.test_dataset, self.batch_size, shuffle=False,
+                          num_workers=self.num_workers,
+                          collate_fn=self.test_dataset.collate_fn,
+                          pin_memory=True)
+
+    def get_ligand_and_pocket(self, data):
+        ligand = {
+            'x': data['lig_coords'].to(self.device, FLOAT_TYPE),
+            'one_hot': data['lig_one_hot'].to(self.device, FLOAT_TYPE),
+            'size': data['num_lig_atoms'].to(self.device, INT_TYPE),
+            'mask': data['lig_mask'].to(self.device, INT_TYPE),
+        }
+        if self.virtual_nodes:
+            ligand['num_virtual_atoms'] = data['num_virtual_atoms'].to(
+                self.device, INT_TYPE)
+
+        pocket = {
+            'x': data['pocket_coords'].to(self.device, FLOAT_TYPE),
+            'one_hot': data['pocket_one_hot'].to(self.device, FLOAT_TYPE),
+            'size': data['num_pocket_nodes'].to(self.device, INT_TYPE),
+            'mask': data['pocket_mask'].to(self.device, INT_TYPE)
+        }
+        return ligand, pocket
+
+    def forward(self, data):
+        ligand, pocket = self.get_ligand_and_pocket(data)
+
+        # Note: \mathcal{L} terms in the paper represent log-likelihoods while
+        # our loss terms are a negative(!) log-likelihoods
+        delta_log_px, error_t_lig, error_t_pocket, SNR_weight, \
+        loss_0_x_ligand, loss_0_x_pocket, loss_0_h, neg_log_const_0, \
+        kl_prior, log_pN, t_int, xh_lig_hat, info = \
+            self.ddpm(ligand, pocket, return_info=True)
+
+        if self.loss_type == 'l2' and self.training:
+            actual_ligand_size = ligand['size'] - ligand['num_virtual_atoms'] if self.virtual_nodes else ligand['size']
+
+            # normalize loss_t
+            denom_lig = self.x_dims * actual_ligand_size + \
+                        self.ddpm.atom_nf * ligand['size']
+            error_t_lig = error_t_lig / denom_lig
+            denom_pocket = (self.x_dims + self.ddpm.residue_nf) * pocket['size']
+            error_t_pocket = error_t_pocket / denom_pocket
+            loss_t = 0.5 * (error_t_lig + error_t_pocket)
+
+            # normalize loss_0
+            loss_0_x_ligand = loss_0_x_ligand / (self.x_dims * actual_ligand_size)
+            loss_0_x_pocket = loss_0_x_pocket / (self.x_dims * pocket['size'])
+            loss_0 = loss_0_x_ligand + loss_0_x_pocket + loss_0_h
+
+        # VLB objective or evaluation step
+        else:
+            # Note: SNR_weight should be negative
+            loss_t = -self.T * 0.5 * SNR_weight * (error_t_lig + error_t_pocket)
+            loss_0 = loss_0_x_ligand + loss_0_x_pocket + loss_0_h
+            loss_0 = loss_0 + neg_log_const_0
+
+        nll = loss_t + loss_0 + kl_prior
+
+        # Correct for normalization on x.
+        if not (self.loss_type == 'l2' and self.training):
+            nll = nll - delta_log_px
+
+            # always the same number of nodes if virtual nodes are added
+            if not self.virtual_nodes:
+                # Transform conditional nll into joint nll
+                # Note:
+                # loss = -log p(x,h|N) and log p(x,h,N) = log p(x,h|N) + log p(N)
+                # Therefore, log p(x,h|N) = -loss + log p(N)
+                # => loss_new = -log p(x,h,N) = loss - log p(N)
+                nll = nll - log_pN
+
+        # Add auxiliary loss term
+        if self.auxiliary_loss and self.loss_type == 'l2' and self.training:
+            x_lig_hat = xh_lig_hat[:, :self.x_dims]
+            h_lig_hat = xh_lig_hat[:, self.x_dims:]
+            weighted_lj_potential = \
+                self.auxiliary_weight_schedule(t_int.long()) * \
+                self.lj_potential(x_lig_hat, h_lig_hat, ligand['mask'])
+            nll = nll + weighted_lj_potential
+            info['weighted_lj'] = weighted_lj_potential.mean(0)
+
+        info['error_t_lig'] = error_t_lig.mean(0)
+        info['error_t_pocket'] = error_t_pocket.mean(0)
+        info['SNR_weight'] = SNR_weight.mean(0)
+        info['loss_0'] = loss_0.mean(0)
+        info['kl_prior'] = kl_prior.mean(0)
+        info['delta_log_px'] = delta_log_px.mean(0)
+        info['neg_log_const_0'] = neg_log_const_0.mean(0)
+        info['log_pN'] = log_pN.mean(0)
+        return nll, info
+
+    def lj_potential(self, atom_x, atom_one_hot, batch_mask):
+        adj = batch_mask[:, None] == batch_mask[None, :]
+        adj = adj ^ torch.diag(torch.diag(adj))  # remove self-edges
+        edges = torch.where(adj)
+
+        # Compute pair-wise potentials
+        r = torch.sum((atom_x[edges[0]] - atom_x[edges[1]])**2, dim=1).sqrt()
+
+        # Get optimal radii
+        lennard_jones_radii = torch.tensor(self.lj_rm, device=r.device)
+        # unit conversion pm -> A
+        lennard_jones_radii = lennard_jones_radii / 100.0
+        # normalization
+        lennard_jones_radii = lennard_jones_radii / self.ddpm.norm_values[0]
+        atom_type_idx = atom_one_hot.argmax(1)
+        rm = lennard_jones_radii[atom_type_idx[edges[0]],
+                                 atom_type_idx[edges[1]]]
+        sigma = 2 ** (-1 / 6) * rm
+        out = 4 * ((sigma / r) ** 12 - (sigma / r) ** 6)
+
+        if self.clamp_lj is not None:
+            out = torch.clamp(out, min=None, max=self.clamp_lj)
+
+        # Compute potential per atom
+        out = scatter_add(out, edges[0], dim=0, dim_size=len(atom_x))
+
+        # Sum potentials of all atoms
+        return scatter_add(out, batch_mask, dim=0)
+
+    def log_metrics(self, metrics_dict, split, batch_size=None, **kwargs):
+        for m, value in metrics_dict.items():
+            self.log(f'{m}/{split}', value, batch_size=batch_size, **kwargs)
+
+    def training_step(self, data, *args):
+        if self.augment_noise > 0:
+            raise NotImplementedError
+            # Add noise eps ~ N(0, augment_noise) around points.
+            eps = sample_center_gravity_zero_gaussian(x.size(), x.device)
+            x = x + eps * args.augment_noise
+
+        if self.augment_rotation:
+            raise NotImplementedError
+            x = utils.random_rotation(x).detach()
+
+        try:
+            nll, info = self.forward(data)
+        except RuntimeError as e:
+            # this is not supported for multi-GPU
+            if self.trainer.num_devices < 2 and 'out of memory' in str(e):
+                print('WARNING: ran out of memory, skipping to the next batch')
+                return None
+            else:
+                raise e
+
+        loss = nll.mean(0)
+
+        info['loss'] = loss
+        self.log_metrics(info, 'train', batch_size=len(data['num_lig_atoms']))
+
+        return info
+
+    def _shared_eval(self, data, prefix, *args):
+        nll, info = self.forward(data)
+        loss = nll.mean(0)
+
+        info['loss'] = loss
+
+        self.log_metrics(info, prefix, batch_size=len(data['num_lig_atoms']),
+                         sync_dist=True)
+
+        return info
+
+    def validation_step(self, data, *args):
+        self._shared_eval(data, 'val', *args)
+
+    def test_step(self, data, *args):
+        self._shared_eval(data, 'test', *args)
+
+    def validation_epoch_end(self, validation_step_outputs):
+
+        # Perform validation on single GPU
+        if not self.trainer.is_global_zero:
+            return
+
+        suffix = '' if self.mode == 'joint' else '_given_pocket'
+
+        if (self.current_epoch + 1) % self.eval_epochs == 0:
+            tic = time()
+
+            sampling_results = getattr(self, 'sample_and_analyze' + suffix)(
+                self.eval_params.n_eval_samples, self.val_dataset,
+                batch_size=self.eval_batch_size)
+            self.log_metrics(sampling_results, 'val')
+
+            print(f'Evaluation took {time() - tic:.2f} seconds')
+
+        if (self.current_epoch + 1) % self.visualize_sample_epoch == 0:
+            tic = time()
+            getattr(self, 'sample_and_save' + suffix)(
+                self.eval_params.n_visualize_samples)
+            print(f'Sample visualization took {time() - tic:.2f} seconds')
+
+        if (self.current_epoch + 1) % self.visualize_chain_epoch == 0:
+            tic = time()
+            getattr(self, 'sample_chain_and_save' + suffix)(
+                self.eval_params.keep_frames)
+            print(f'Chain visualization took {time() - tic:.2f} seconds')
+
+    @torch.no_grad()
+    def sample_and_analyze(self, n_samples, dataset=None, batch_size=None):
+        print(f'Analyzing sampled molecules at epoch {self.current_epoch}...')
+
+        batch_size = self.batch_size if batch_size is None else batch_size
+        batch_size = min(batch_size, n_samples)
+
+        # each item in molecules is a tuple (position, atom_type_encoded)
+        molecules = []
+        atom_types = []
+        aa_types = []
+        for i in range(math.ceil(n_samples / batch_size)):
+
+            n_samples_batch = min(batch_size, n_samples - len(molecules))
+
+            num_nodes_lig, num_nodes_pocket = \
+                self.ddpm.size_distribution.sample(n_samples_batch)
+
+            xh_lig, xh_pocket, lig_mask, _ = self.ddpm.sample(
+                n_samples_batch, num_nodes_lig, num_nodes_pocket,
+                device=self.device)
+
+            x = xh_lig[:, :self.x_dims].detach().cpu()
+            atom_type = xh_lig[:, self.x_dims:].argmax(1).detach().cpu()
+            lig_mask = lig_mask.cpu()
+
+            molecules.extend(list(
+                zip(utils.batch_to_list(x, lig_mask),
+                    utils.batch_to_list(atom_type, lig_mask))
+            ))
+
+            atom_types.extend(atom_type.tolist())
+            aa_types.extend(
+                xh_pocket[:, self.x_dims:].argmax(1).detach().cpu().tolist())
+
+        return self.analyze_sample(molecules, atom_types, aa_types)
+
+    def analyze_sample(self, molecules, atom_types, aa_types, receptors=None):
+        # Distribution of node types
+        kl_div_atom = self.ligand_type_distribution.kl_divergence(atom_types) \
+            if self.ligand_type_distribution is not None else -1
+        kl_div_aa = self.pocket_type_distribution.kl_divergence(aa_types) \
+            if self.pocket_type_distribution is not None else -1
+
+        # Convert into rdmols
+        rdmols = [build_molecule(*graph, self.dataset_info) for graph in molecules]
+
+        # Other basic metrics
+        (validity, connectivity, uniqueness, novelty), (_, connected_mols) = \
+            self.ligand_metrics.evaluate_rdmols(rdmols)
+
+        qed, sa, logp, lipinski, diversity = \
+            self.molecule_properties.evaluate_mean(connected_mols)
+
+        out = {
+            'kl_div_atom_types': kl_div_atom,
+            'kl_div_residue_types': kl_div_aa,
+            'Validity': validity,
+            'Connectivity': connectivity,
+            'Uniqueness': uniqueness,
+            'Novelty': novelty,
+            'QED': qed,
+            'SA': sa,
+            'LogP': logp,
+            'Lipinski': lipinski,
+            'Diversity': diversity
+        }
+
+        # Simple docking score
+        if receptors is not None:
+            # out['smina_score'] = np.mean(smina_score(rdmols, receptors))
+            out['smina_score'] = np.mean(smina_score(connected_mols, receptors))
+
+        return out
+
+    def get_full_path(self, receptor_name):
+        pdb, suffix = receptor_name.split('.')
+        receptor_name = f'{pdb.upper()}-{suffix}.pdb'
+        return Path(self.datadir, 'val', receptor_name)
+
+    @torch.no_grad()
+    def sample_and_analyze_given_pocket(self, n_samples, dataset=None,
+                                        batch_size=None):
+        print(f'Analyzing sampled molecules given pockets at epoch '
+              f'{self.current_epoch}...')
+
+        batch_size = self.batch_size if batch_size is None else batch_size
+        batch_size = min(batch_size, n_samples)
+
+        # each item in molecules is a tuple (position, atom_type_encoded)
+        molecules = []
+        atom_types = []
+        aa_types = []
+        receptors = []
+        for i in range(math.ceil(n_samples / batch_size)):
+
+            n_samples_batch = min(batch_size, n_samples - len(molecules))
+
+            # Create a batch
+            batch = dataset.collate_fn(
+                [dataset[(i * batch_size + j) % len(dataset)]
+                 for j in range(n_samples_batch)]
+            )
+
+            ligand, pocket = self.get_ligand_and_pocket(batch)
+            receptors.extend([self.get_full_path(x) for x in batch['receptors']])
+
+            if self.virtual_nodes:
+                num_nodes_lig = self.max_num_nodes
+            else:
+                num_nodes_lig = self.ddpm.size_distribution.sample_conditional(
+                    n1=None, n2=pocket['size'])
+
+            xh_lig, xh_pocket, lig_mask, _ = self.ddpm.sample_given_pocket(
+                pocket, num_nodes_lig)
+
+            x = xh_lig[:, :self.x_dims].detach().cpu()
+            atom_type = xh_lig[:, self.x_dims:].argmax(1).detach().cpu()
+            lig_mask = lig_mask.cpu()
+
+            if self.virtual_nodes:
+                # Remove virtual nodes for analysis
+                vnode_mask = (atom_type == self.virtual_atom)
+                x = x[~vnode_mask, :]
+                atom_type = atom_type[~vnode_mask]
+                lig_mask = lig_mask[~vnode_mask]
+
+            molecules.extend(list(
+                zip(utils.batch_to_list(x, lig_mask),
+                    utils.batch_to_list(atom_type, lig_mask))
+            ))
+
+            atom_types.extend(atom_type.tolist())
+            aa_types.extend(
+                xh_pocket[:, self.x_dims:].argmax(1).detach().cpu().tolist())
+
+        return self.analyze_sample(molecules, atom_types, aa_types,
+                                   receptors=receptors)
+
+    def sample_and_save(self, n_samples):
+        num_nodes_lig, num_nodes_pocket = \
+            self.ddpm.size_distribution.sample(n_samples)
+
+        xh_lig, xh_pocket, lig_mask, pocket_mask = \
+            self.ddpm.sample(n_samples, num_nodes_lig, num_nodes_pocket,
+                             device=self.device)
+
+        if self.pocket_representation == 'CA':
+            # convert residues into atom representation for visualization
+            x_pocket, one_hot_pocket = utils.residues_to_atoms(
+                xh_pocket[:, :self.x_dims], self.lig_type_encoder)
+        else:
+            x_pocket, one_hot_pocket = \
+                xh_pocket[:, :self.x_dims], xh_pocket[:, self.x_dims:]
+        x = torch.cat((xh_lig[:, :self.x_dims], x_pocket), dim=0)
+        one_hot = torch.cat((xh_lig[:, self.x_dims:], one_hot_pocket), dim=0)
+
+        outdir = Path(self.outdir, f'epoch_{self.current_epoch}')
+        save_xyz_file(str(outdir) + '/', one_hot, x, self.lig_type_decoder,
+                      name='molecule',
+                      batch_mask=torch.cat((lig_mask, pocket_mask)))
+        # visualize(str(outdir), dataset_info=self.dataset_info, wandb=wandb)
+        visualize(str(outdir), dataset_info=self.dataset_info, wandb=None)
+
+    def sample_and_save_given_pocket(self, n_samples):
+        batch = self.val_dataset.collate_fn(
+            [self.val_dataset[i] for i in torch.randint(len(self.val_dataset),
+                                                        size=(n_samples,))]
+        )
+        ligand, pocket = self.get_ligand_and_pocket(batch)
+
+        if self.virtual_nodes:
+            num_nodes_lig = self.max_num_nodes
+        else:
+            num_nodes_lig = self.ddpm.size_distribution.sample_conditional(
+                n1=None, n2=pocket['size'])
+
+        xh_lig, xh_pocket, lig_mask, pocket_mask = \
+            self.ddpm.sample_given_pocket(pocket, num_nodes_lig)
+
+        if self.pocket_representation == 'CA':
+            # convert residues into atom representation for visualization
+            x_pocket, one_hot_pocket = utils.residues_to_atoms(
+                xh_pocket[:, :self.x_dims], self.lig_type_encoder)
+        else:
+            x_pocket, one_hot_pocket = \
+                xh_pocket[:, :self.x_dims], xh_pocket[:, self.x_dims:]
+        x = torch.cat((xh_lig[:, :self.x_dims], x_pocket), dim=0)
+        one_hot = torch.cat((xh_lig[:, self.x_dims:], one_hot_pocket), dim=0)
+
+        outdir = Path(self.outdir, f'epoch_{self.current_epoch}')
+        save_xyz_file(str(outdir) + '/', one_hot, x, self.lig_type_decoder,
+                      name='molecule',
+                      batch_mask=torch.cat((lig_mask, pocket_mask)))
+        # visualize(str(outdir), dataset_info=self.dataset_info, wandb=wandb)
+        visualize(str(outdir), dataset_info=self.dataset_info, wandb=None)
+
+    def sample_chain_and_save(self, keep_frames):
+        n_samples = 1
+
+        num_nodes_lig, num_nodes_pocket = \
+            self.ddpm.size_distribution.sample(n_samples)
+
+        chain_lig, chain_pocket, _, _ = self.ddpm.sample(
+            n_samples, num_nodes_lig, num_nodes_pocket,
+            return_frames=keep_frames, device=self.device)
+
+        chain_lig = utils.reverse_tensor(chain_lig)
+        chain_pocket = utils.reverse_tensor(chain_pocket)
+
+        # Repeat last frame to see final sample better.
+        chain_lig = torch.cat([chain_lig, chain_lig[-1:].repeat(10, 1, 1)],
+                              dim=0)
+        chain_pocket = torch.cat(
+            [chain_pocket, chain_pocket[-1:].repeat(10, 1, 1)], dim=0)
+
+        # Prepare entire chain.
+        x_lig = chain_lig[:, :, :self.x_dims]
+        one_hot_lig = chain_lig[:, :, self.x_dims:]
+        one_hot_lig = F.one_hot(
+            torch.argmax(one_hot_lig, dim=2),
+            num_classes=len(self.lig_type_decoder))
+        x_pocket = chain_pocket[:, :, :self.x_dims]
+        one_hot_pocket = chain_pocket[:, :, self.x_dims:]
+        one_hot_pocket = F.one_hot(
+            torch.argmax(one_hot_pocket, dim=2),
+            num_classes=len(self.pocket_type_decoder))
+
+        if self.pocket_representation == 'CA':
+            # convert residues into atom representation for visualization
+            x_pocket, one_hot_pocket = utils.residues_to_atoms(
+                x_pocket, self.lig_type_encoder)
+
+        x = torch.cat((x_lig, x_pocket), dim=1)
+        one_hot = torch.cat((one_hot_lig, one_hot_pocket), dim=1)
+
+        # flatten (treat frame (chain dimension) as batch for visualization)
+        x_flat = x.view(-1, x.size(-1))
+        one_hot_flat = one_hot.view(-1, one_hot.size(-1))
+        mask_flat = torch.arange(x.size(0)).repeat_interleave(x.size(1))
+
+        outdir = Path(self.outdir, f'epoch_{self.current_epoch}', 'chain')
+        save_xyz_file(str(outdir), one_hot_flat, x_flat, self.lig_type_decoder,
+                      name='/chain', batch_mask=mask_flat)
+        visualize_chain(str(outdir), self.dataset_info, wandb=wandb)
+
+    def sample_chain_and_save_given_pocket(self, keep_frames):
+        n_samples = 1
+
+        batch = self.val_dataset.collate_fn([
+            self.val_dataset[torch.randint(len(self.val_dataset), size=(1,))]
+        ])
+        ligand, pocket = self.get_ligand_and_pocket(batch)
+
+        if self.virtual_nodes:
+            num_nodes_lig = self.max_num_nodes
+        else:
+            num_nodes_lig = self.ddpm.size_distribution.sample_conditional(
+                n1=None, n2=pocket['size'])
+
+        chain_lig, chain_pocket, _, _ = self.ddpm.sample_given_pocket(
+            pocket, num_nodes_lig, return_frames=keep_frames)
+
+        chain_lig = utils.reverse_tensor(chain_lig)
+        chain_pocket = utils.reverse_tensor(chain_pocket)
+
+        # Repeat last frame to see final sample better.
+        chain_lig = torch.cat([chain_lig, chain_lig[-1:].repeat(10, 1, 1)],
+                              dim=0)
+        chain_pocket = torch.cat(
+            [chain_pocket, chain_pocket[-1:].repeat(10, 1, 1)], dim=0)
+
+        # Prepare entire chain.
+        x_lig = chain_lig[:, :, :self.x_dims]
+        one_hot_lig = chain_lig[:, :, self.x_dims:]
+        one_hot_lig = F.one_hot(
+            torch.argmax(one_hot_lig, dim=2),
+            num_classes=len(self.lig_type_decoder))
+        x_pocket = chain_pocket[:, :, :3]
+        one_hot_pocket = chain_pocket[:, :, 3:]
+        one_hot_pocket = F.one_hot(
+            torch.argmax(one_hot_pocket, dim=2),
+            num_classes=len(self.pocket_type_decoder))
+
+        if self.pocket_representation == 'CA':
+            # convert residues into atom representation for visualization
+            x_pocket, one_hot_pocket = utils.residues_to_atoms(
+                x_pocket, self.lig_type_encoder)
+
+        x = torch.cat((x_lig, x_pocket), dim=1)
+        one_hot = torch.cat((one_hot_lig, one_hot_pocket), dim=1)
+
+        # flatten (treat frame (chain dimension) as batch for visualization)
+        x_flat = x.view(-1, x.size(-1))
+        one_hot_flat = one_hot.view(-1, one_hot.size(-1))
+        mask_flat = torch.arange(x.size(0)).repeat_interleave(x.size(1))
+
+        outdir = Path(self.outdir, f'epoch_{self.current_epoch}', 'chain')
+        save_xyz_file(str(outdir), one_hot_flat, x_flat, self.lig_type_decoder,
+                      name='/chain', batch_mask=mask_flat)
+        visualize_chain(str(outdir), self.dataset_info, wandb=wandb)
+
+    def prepare_pocket(self, biopython_residues, repeats=1):
+
+        if self.pocket_representation == 'CA':
+            pocket_coord = torch.tensor(np.array(
+                [res['CA'].get_coord() for res in biopython_residues]),
+                device=self.device, dtype=FLOAT_TYPE)
+            pocket_types = torch.tensor(
+                [self.pocket_type_encoder[three_to_one(res.get_resname())]
+                 for res in biopython_residues], device=self.device)
+        else:
+            pocket_atoms = [a for res in biopython_residues
+                            for a in res.get_atoms()
+                            if (a.element.capitalize() in self.pocket_type_encoder or a.element != 'H')]
+            pocket_coord = torch.tensor(np.array(
+                [a.get_coord() for a in pocket_atoms]),
+                device=self.device, dtype=FLOAT_TYPE)
+            pocket_types = torch.tensor(
+                [self.pocket_type_encoder[a.element.capitalize()]
+                 for a in pocket_atoms], device=self.device)
+
+        pocket_one_hot = F.one_hot(
+            pocket_types, num_classes=len(self.pocket_type_encoder)
+        )
+
+        pocket_size = torch.tensor([len(pocket_coord)] * repeats,
+                                   device=self.device, dtype=INT_TYPE)
+        pocket_mask = torch.repeat_interleave(
+            torch.arange(repeats, device=self.device, dtype=INT_TYPE),
+            len(pocket_coord)
+        )
+
+        pocket = {
+            'x': pocket_coord.repeat(repeats, 1),
+            'one_hot': pocket_one_hot.repeat(repeats, 1),
+            'size': pocket_size,
+            'mask': pocket_mask
+        }
+
+        return pocket
+
+    def generate_ligands(self, pdb_file, n_samples, pocket_ids=None,
+                         ref_ligand=None, num_nodes_lig=None, sanitize=False,
+                         largest_frag=False, relax_iter=0, timesteps=None,
+                         n_nodes_bias=0, n_nodes_min=0, **kwargs):
+        """
+        Generate ligands given a pocket
+        Args:
+            pdb_file: PDB filename
+            n_samples: number of samples
+            pocket_ids: list of pocket residues in <chain>:<resi> format
+            ref_ligand: alternative way of defining the pocket based on a
+                reference ligand given in <chain>:<resi> format if the ligand is
+                contained in the PDB file, or path to an SDF file that
+                contains the ligand
+            num_nodes_lig: number of ligand nodes for each sample (list of
+                integers), sampled randomly if 'None'
+            sanitize: whether to sanitize molecules or not
+            largest_frag: only return the largest fragment
+            relax_iter: number of force field optimization steps
+            timesteps: number of denoising steps, use training value if None
+            n_nodes_bias: added to the sampled (or provided) number of nodes
+            n_nodes_min: lower bound on the number of sampled nodes
+            kwargs: additional inpainting parameters
+        Returns:
+            list of molecules
+        """
+
+        assert (pocket_ids is None) ^ (ref_ligand is None)
+
+        self.ddpm.eval()
+
+        # Load PDB
+        pdb_struct = PDBParser(QUIET=True).get_structure('', pdb_file)[0]
+        if pocket_ids is not None:
+            # define pocket with list of residues
+            residues = [
+                pdb_struct[x.split(':')[0]][(' ', int(x.split(':')[1]), ' ')]
+                for x in pocket_ids]
+
+        else:
+            # define pocket with reference ligand
+            residues = utils.get_pocket_from_ligand(pdb_struct, ref_ligand)
+
+        pocket = self.prepare_pocket(residues, repeats=n_samples)
+
+        # Pocket's center of mass
+        pocket_com_before = scatter_mean(pocket['x'], pocket['mask'], dim=0)
+
+        # Create dummy ligands
+        if num_nodes_lig is None:
+            num_nodes_lig = self.ddpm.size_distribution.sample_conditional(
+                n1=None, n2=pocket['size'])
+
+        # Add bias
+        num_nodes_lig = num_nodes_lig + n_nodes_bias
+
+        # Apply minimum ligand size
+        num_nodes_lig = torch.clamp(num_nodes_lig, min=n_nodes_min)
+
+        # Use inpainting
+        if type(self.ddpm) == EnVariationalDiffusion:
+            lig_mask = utils.num_nodes_to_batch_mask(
+                len(num_nodes_lig), num_nodes_lig, self.device)
+
+            ligand = {
+                'x': torch.zeros((len(lig_mask), self.x_dims),
+                                 device=self.device, dtype=FLOAT_TYPE),
+                'one_hot': torch.zeros((len(lig_mask), self.atom_nf),
+                                       device=self.device, dtype=FLOAT_TYPE),
+                'size': num_nodes_lig,
+                'mask': lig_mask
+            }
+
+            # Fix all pocket nodes but sample
+            lig_mask_fixed = torch.zeros(len(lig_mask), device=self.device)
+            pocket_mask_fixed = torch.ones(len(pocket['mask']),
+                                           device=self.device)
+
+            xh_lig, xh_pocket, lig_mask, pocket_mask = self.ddpm.inpaint(
+                ligand, pocket, lig_mask_fixed, pocket_mask_fixed,
+                timesteps=timesteps, **kwargs)
+
+        # Use conditional generation
+        elif type(self.ddpm) == ConditionalDDPM:
+            xh_lig, xh_pocket, lig_mask, pocket_mask = \
+                self.ddpm.sample_given_pocket(pocket, num_nodes_lig,
+                                              timesteps=timesteps)
+
+        else:
+            raise NotImplementedError
+
+        # Move generated molecule back to the original pocket position
+        pocket_com_after = scatter_mean(
+            xh_pocket[:, :self.x_dims], pocket_mask, dim=0)
+
+        xh_pocket[:, :self.x_dims] += \
+            (pocket_com_before - pocket_com_after)[pocket_mask]
+        xh_lig[:, :self.x_dims] += \
+            (pocket_com_before - pocket_com_after)[lig_mask]
+
+        # Build mol objects
+        x = xh_lig[:, :self.x_dims].detach().cpu()
+        atom_type = xh_lig[:, self.x_dims:].argmax(1).detach().cpu()
+        lig_mask = lig_mask.cpu()
+
+        molecules = []
+        for mol_pc in zip(utils.batch_to_list(x, lig_mask),
+                          utils.batch_to_list(atom_type, lig_mask)):
+
+            mol = build_molecule(*mol_pc, self.dataset_info, add_coords=True)
+            mol = process_molecule(mol,
+                                   add_hydrogens=False,
+                                   sanitize=sanitize,
+                                   relax_iter=relax_iter,
+                                   largest_frag=largest_frag)
+            if mol is not None:
+                molecules.append(mol)
+
+        return molecules
+
+    def configure_gradient_clipping(self, optimizer, optimizer_idx,
+                                    gradient_clip_val, gradient_clip_algorithm):
+
+        if not self.clip_grad:
+            return
+
+        # Allow gradient norm to be 150% + 2 * stdev of the recent history.
+        max_grad_norm = 1.5 * self.gradnorm_queue.mean() + \
+                        2 * self.gradnorm_queue.std()
+
+        # Get current grad_norm
+        params = [p for g in optimizer.param_groups for p in g['params']]
+        grad_norm = utils.get_grad_norm(params)
+
+        # Lightning will handle the gradient clipping
+        self.clip_gradients(optimizer, gradient_clip_val=max_grad_norm,
+                            gradient_clip_algorithm='norm')
+
+        if float(grad_norm) > max_grad_norm:
+            self.gradnorm_queue.add(float(max_grad_norm))
+        else:
+            self.gradnorm_queue.add(float(grad_norm))
+
+        if float(grad_norm) > max_grad_norm:
+            print(f'Clipped gradient with value {grad_norm:.1f} '
+                  f'while allowed {max_grad_norm:.1f}')
+
+
+class WeightSchedule:
+    def __init__(self, T, max_weight, mode='linear'):
+        if mode == 'linear':
+            self.weights = torch.linspace(max_weight, 0, T + 1)
+        elif mode == 'constant':
+            self.weights = max_weight * torch.ones(T + 1)
+        else:
+            raise NotImplementedError(f'{mode} weight schedule is not '
+                                      f'available.')
+
+    def __call__(self, t_array):
+        """ all values in t_array are assumed to be integers in [0, T] """
+        return self.weights[t_array].to(t_array.device)

optimize.py

@@ -0,0 +1,249 @@
+import argparse
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from Bio.PDB import PDBParser
+from rdkit import Chem
+import pandas as pd
+import random
+from torch_scatter import scatter_mean
+from openbabel import openbabel
+openbabel.obErrorLog.StopLogging()  # suppress OpenBabel messages
+
+import utils
+from lightning_modules import LigandPocketDDPM
+from constants import FLOAT_TYPE, INT_TYPE
+from analysis.molecule_builder import build_molecule, process_molecule
+from analysis.metrics import MoleculeProperties
+
+
+def prepare_from_sdf_files(sdf_files, atom_encoder):
+
+    ligand_coords = []
+    atom_one_hot = []
+    for file in sdf_files:
+        rdmol = Chem.SDMolSupplier(str(file), sanitize=False)[0]
+        ligand_coords.append(
+            torch.from_numpy(rdmol.GetConformer().GetPositions()).float()
+        )
+        types = torch.tensor([atom_encoder[a.GetSymbol()] for a in rdmol.GetAtoms()])
+        atom_one_hot.append(
+            F.one_hot(types, num_classes=len(atom_encoder))
+        )
+
+    return torch.cat(ligand_coords, dim=0), torch.cat(atom_one_hot, dim=0)
+
+
+def prepare_ligands_from_mols(mols, atom_encoder, device='cpu'):
+
+    ligand_coords = []
+    atom_one_hots = []
+    masks = []
+    sizes = []
+    for i, mol in enumerate(mols):
+        coord = torch.tensor(mol.GetConformer().GetPositions(), dtype=FLOAT_TYPE)
+        types = torch.tensor([atom_encoder[a.GetSymbol()] for a in mol.GetAtoms()], dtype=INT_TYPE)
+        one_hot = F.one_hot(types, num_classes=len(atom_encoder))
+        mask = torch.ones(len(types), dtype=INT_TYPE) * i
+        ligand_coords.append(coord)
+        atom_one_hots.append(one_hot)
+        masks.append(mask)
+        sizes.append(len(types))
+
+    ligand = {
+        'x': torch.cat(ligand_coords, dim=0).to(device),
+        'one_hot': torch.cat(atom_one_hots, dim=0).to(device),
+        'size': torch.tensor(sizes, dtype=INT_TYPE).to(device),
+        'mask': torch.cat(masks, dim=0).to(device),
+    }
+
+    return ligand
+
+
+def prepare_ligand_from_pdb(biopython_atoms, atom_encoder):
+
+    coord = torch.tensor(np.array([a.get_coord()
+                                   for a in biopython_atoms]), dtype=FLOAT_TYPE)
+    types = torch.tensor([atom_encoder[a.element.capitalize()]
+                          for a in biopython_atoms])
+    one_hot = F.one_hot(types, num_classes=len(atom_encoder))
+
+    return coord, one_hot
+
+
+def prepare_substructure(ref_ligand, fix_atoms, pdb_model):
+
+    if fix_atoms[0].endswith(".sdf"):
+        # ligand as sdf file
+        coord, one_hot = prepare_from_sdf_files(fix_atoms, model.lig_type_encoder)
+
+    else:
+        # ligand contained in PDB; given in <chain>:<resi> format
+        chain, resi = ref_ligand.split(':')
+        ligand = utils.get_residue_with_resi(pdb_model[chain], int(resi))
+        fixed_atoms = [a for a in ligand.get_atoms() if a.get_name() in set(fix_atoms)]
+        coord, one_hot = prepare_ligand_from_pdb(fixed_atoms, model.lig_type_encoder)
+
+    return coord, one_hot
+
+
+def diversify_ligands(model, pocket, mols, timesteps,
+                    sanitize=False,
+                    largest_frag=False,
+                    relax_iter=0):
+    """
+    Diversify ligands for a specified pocket.
+    
+    Parameters:
+        model: The model instance used for diversification.
+        pocket: The pocket information including coordinates and types.
+        mols: List of RDKit molecule objects to be diversified.
+        timesteps: Number of denoising steps to apply during diversification.
+        sanitize: If True, performs molecule sanitization post-generation (default: False).
+        largest_frag: If True, only the largest fragment of the generated molecule is returned (default: False).
+        relax_iter: Number of iterations for force field relaxation of the generated molecules (default: 0).
+    
+    Returns:
+        A list of diversified RDKit molecule objects.
+    """
+
+    ligand = prepare_ligands_from_mols(mols, model.lig_type_encoder, device=model.device)
+
+    pocket_mask = pocket['mask']
+    lig_mask = ligand['mask']
+
+    # Pocket's center of mass
+    pocket_com_before = scatter_mean(pocket['x'], pocket['mask'], dim=0)
+
+    out_lig, out_pocket, _, _ = model.ddpm.diversify(ligand, pocket, noising_steps=timesteps)
+
+    # Move generated molecule back to the original pocket position
+    pocket_com_after = scatter_mean(out_pocket[:, :model.x_dims], pocket_mask, dim=0)
+
+    out_pocket[:, :model.x_dims] += \
+        (pocket_com_before - pocket_com_after)[pocket_mask]
+    out_lig[:, :model.x_dims] += \
+        (pocket_com_before - pocket_com_after)[lig_mask]
+
+    # Build mol objects
+    x = out_lig[:, :model.x_dims].detach().cpu()
+    atom_type = out_lig[:, model.x_dims:].argmax(1).detach().cpu()
+
+    molecules = []
+    for mol_pc in zip(utils.batch_to_list(x, lig_mask),
+                      utils.batch_to_list(atom_type, lig_mask)):
+
+        mol = build_molecule(*mol_pc, model.dataset_info, add_coords=True)
+        mol = process_molecule(mol,
+                               add_hydrogens=False,
+                               sanitize=sanitize,
+                               relax_iter=relax_iter,
+                               largest_frag=largest_frag)
+        if mol is not None:
+            molecules.append(mol)
+
+    return molecules
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--checkpoint', type=Path, default='checkpoints/crossdocked_fullatom_cond.ckpt')
+    parser.add_argument('--pdbfile', type=str, default='example/5ndu.pdb')
+    parser.add_argument('--ref_ligand', type=str, default='example/5ndu_linked_mols.sdf')
+    parser.add_argument('--objective', type=str, default='sa', choices={'qed', 'sa'})
+    parser.add_argument('--timesteps', type=int, default=100)
+    parser.add_argument('--population_size', type=int, default=100)
+    parser.add_argument('--evolution_steps', type=int, default=10)
+    parser.add_argument('--top_k', type=int, default=7)
+    parser.add_argument('--outfile', type=Path, default='output.sdf')
+    parser.add_argument('--relax', action='store_true')
+
+
+    args = parser.parse_args()
+
+    pdb_id = Path(args.pdbfile).stem
+
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    population_size = args.population_size
+    evolution_steps = args.evolution_steps
+    top_k = args.top_k
+
+    # Load model
+    model = LigandPocketDDPM.load_from_checkpoint(
+        args.checkpoint, map_location=device)
+    model = model.to(device)
+
+    # Prepare ligand + pocket
+    # Load PDB
+    pdb_model = PDBParser(QUIET=True).get_structure('', args.pdbfile)[0]
+    # Define pocket based on reference ligand
+    residues = utils.get_pocket_from_ligand(pdb_model, args.ref_ligand)
+    pocket = model.prepare_pocket(residues, repeats=population_size)
+
+
+    if args.objective == 'qed':
+        objective_function = MoleculeProperties().calculate_qed
+    elif args.objective == 'sa':
+        objective_function = MoleculeProperties().calculate_sa
+    else:
+        ### IMPLEMENT YOUR OWN OBJECTIVE
+        ### FUNCTIONS HERE 
+        raise ValueError(f"Objective function {args.objective} not recognized.")
+
+    ref_mol = Chem.SDMolSupplier(args.ref_ligand)[0]
+
+    # Store molecules in history dataframe 
+    buffer = pd.DataFrame(columns=['generation', 'score', 'fate' 'mol', 'smiles'])
+
+    # Population initialization
+    buffer = buffer.append({'generation': 0,
+                            'score': objective_function(ref_mol),
+                            'fate': 'initial', 'mol': ref_mol,
+                            'smiles': Chem.MolToSmiles(ref_mol)}, ignore_index=True)
+
+    for generation_idx in range(evolution_steps):
+
+        if generation_idx == 0:
+            molecules = buffer['mol'].tolist() * population_size
+        else:
+            # Select top k molecules from previous generation
+            previous_gen = buffer[buffer['generation'] == generation_idx]
+            top_k_molecules = previous_gen.nlargest(top_k, 'score')['mol'].tolist()
+            molecules = top_k_molecules * (population_size // top_k)
+
+            # Update the fate of selected top k molecules in the buffer
+            buffer.loc[buffer['generation'] == generation_idx, 'fate'] = 'survived'
+
+            # Ensure the right number of molecules
+            if len(molecules) < population_size:
+                molecules += [random.choice(molecules) for _ in range(population_size - len(molecules))]
+
+
+        # Diversify molecules
+        assert len(molecules) == population_size, f"Wrong number of molecules: {len(molecules)} when it should be {population_size}"
+        print(f"Generation {generation_idx}, mean score: {np.mean([objective_function(mol) for mol in molecules])}")
+        molecules = diversify_ligands(model,
+                                    pocket,
+                                    molecules,
+                                timesteps=args.timesteps,
+                                sanitize=True,
+                                relax_iter=(200 if args.relax else 0))
+        
+        
+        # Evaluate and save molecules
+        for mol in molecules:
+            buffer = buffer.append({'generation': generation_idx + 1,
+            'score': objective_function(mol),
+            'fate': 'purged',
+            'mol': mol,
+            'smiles': Chem.MolToSmiles(mol)}, ignore_index=True)
+
+
+    # Make SDF files
+    utils.write_sdf_file(args.outfile, molecules)
+    # Save buffer
+    buffer.drop(columns=['mol'])
+    buffer.to_csv(args.outfile.with_suffix('.csv'))

process_bindingmoad.py

@@ -0,0 +1,652 @@
+from pathlib import Path
+from time import time
+import random
+from collections import defaultdict
+import argparse
+import warnings
+
+from tqdm import tqdm
+import numpy as np
+import torch
+from Bio.PDB import PDBParser
+from Bio.PDB.Polypeptide import three_to_one, is_aa
+from Bio.PDB import PDBIO, Select
+from openbabel import openbabel
+from rdkit import Chem
+from rdkit.Chem import QED
+from scipy.ndimage import gaussian_filter
+
+from geometry_utils import get_bb_transform
+from analysis.molecule_builder import build_molecule
+from analysis.metrics import rdmol_to_smiles
+import constants
+from constants import covalent_radii, dataset_params
+import utils
+
+dataset_info = dataset_params['bindingmoad']
+amino_acid_dict = dataset_info['aa_encoder']
+atom_dict = dataset_info['atom_encoder']
+atom_decoder = dataset_info['atom_decoder']
+
+
+class Model0(Select):
+    def accept_model(self, model):
+        return model.id == 0
+
+
+def read_label_file(csv_path):
+    """
+    Read BindingMOAD's label file
+    Args:
+        csv_path: path to 'every.csv'
+    Returns:
+        Nested dictionary with all ligands. First level: EC number,
+            Second level: PDB ID, Third level: list of ligands. Each ligand is
+            represented as a tuple (ligand name, validity, SMILES string)
+    """
+    ligand_dict = {}
+
+    with open(csv_path, 'r') as f:
+        for line in f.readlines():
+            row = line.split(',')
+
+            # new protein class
+            if len(row[0]) > 0:
+                curr_class = row[0]
+                ligand_dict[curr_class] = {}
+                continue
+
+            # new protein
+            if len(row[2]) > 0:
+                curr_prot = row[2]
+                ligand_dict[curr_class][curr_prot] = []
+                continue
+
+            # new small molecule
+            if len(row[3]) > 0:
+                ligand_dict[curr_class][curr_prot].append(
+                    # (ligand name, validity, SMILES string)
+                    [row[3], row[4], row[9]]
+                )
+
+    return ligand_dict
+
+
+def compute_druglikeness(ligand_dict):
+    """
+    Computes RDKit's QED value and adds it to the dictionary
+    Args:
+        ligand_dict: nested ligand dictionary
+    Returns:
+        the same ligand dictionary with additional QED values
+    """
+    print("Computing QED values...")
+    for p, m in tqdm([(p, m) for c in ligand_dict for p in ligand_dict[c]
+                      for m in ligand_dict[c][p]]):
+        mol = Chem.MolFromSmiles(m[2])
+        if mol is None:
+            mol_id = f'{p}_{m}'
+            warnings.warn(f"Could not construct molecule {mol_id} from SMILES "
+                          f"string '{m[2]}'")
+            continue
+        m.append(QED.qed(mol))
+    return ligand_dict
+
+
+def filter_and_flatten(ligand_dict, qed_thresh, max_occurences, seed):
+
+    filtered_examples = []
+    all_examples = [(c, p, m) for c in ligand_dict for p in ligand_dict[c]
+                    for m in ligand_dict[c][p]]
+
+    # shuffle to select random examples of ligands that occur more than
+    # max_occurences times
+    random.seed(seed)
+    random.shuffle(all_examples)
+
+    ligand_name_counter = defaultdict(int)
+    print("Filtering examples...")
+    for c, p, m in tqdm(all_examples):
+
+        ligand_name, ligand_chain, ligand_resi = m[0].split(':')
+        if m[1] == 'valid' and len(m) > 3 and m[3] > qed_thresh:
+            if ligand_name_counter[ligand_name] < max_occurences:
+                filtered_examples.append(
+                    (c, p, m)
+                )
+                ligand_name_counter[ligand_name] += 1
+
+    return filtered_examples
+
+
+def split_by_ec_number(data_list, n_val, n_test, ec_level=1):
+    """
+    Split dataset into training, validation and test sets based on EC numbers
+    https://en.wikipedia.org/wiki/Enzyme_Commission_number
+    Args:
+        data_list: list of ligands
+        n_val: number of validation examples
+        n_test: number of test examples
+        ec_level: level in the EC numbering hierarchy at which the split is
+            made, i.e. items with matching EC numbers at this level are put in
+            the same set
+    Returns:
+        dictionary with keys 'train', 'val', and 'test'
+    """
+
+    examples_per_class = defaultdict(int)
+    for c, p, m in data_list:
+        c_sub = '.'.join(c.split('.')[:ec_level])
+        examples_per_class[c_sub] += 1
+
+    assert sum(examples_per_class.values()) == len(data_list)
+
+    # split ec numbers
+    val_classes = set()
+    for c, num in sorted(examples_per_class.items(), key=lambda x: x[1],
+                         reverse=True):
+        if sum([examples_per_class[x] for x in val_classes]) + num <= n_val:
+            val_classes.add(c)
+
+    test_classes = set()
+    for c, num in sorted(examples_per_class.items(), key=lambda x: x[1],
+                         reverse=True):
+        # skip classes already used in the validation set
+        if c in val_classes:
+            continue
+        if sum([examples_per_class[x] for x in test_classes]) + num <= n_test:
+            test_classes.add(c)
+
+    # remaining classes belong to test set
+    train_classes = {x for x in examples_per_class if
+                     x not in val_classes and x not in test_classes}
+
+    # create separate lists of examples
+    data_split = {}
+    data_split['train'] = [x for x in data_list if '.'.join(
+        x[0].split('.')[:ec_level]) in train_classes]
+    data_split['val'] = [x for x in data_list if '.'.join(
+        x[0].split('.')[:ec_level]) in val_classes]
+    data_split['test'] = [x for x in data_list if '.'.join(
+        x[0].split('.')[:ec_level]) in test_classes]
+
+    assert len(data_split['train']) + len(data_split['val']) + \
+           len(data_split['test']) == len(data_list)
+
+    return data_split
+
+
+def ligand_list_to_dict(ligand_list):
+    out_dict = defaultdict(list)
+    for _, p, m in ligand_list:
+        out_dict[p].append(m)
+    return out_dict
+
+
+def process_ligand_and_pocket(pdb_struct, ligand_name, ligand_chain,
+                              ligand_resi, dist_cutoff, ca_only,
+                              compute_quaternion=False):
+    try:
+        residues = {obj.id[1]: obj for obj in
+                    pdb_struct[0][ligand_chain].get_residues()}
+    except KeyError as e:
+        raise KeyError(f'Chain {e} not found ({pdbfile}, '
+                       f'{ligand_name}:{ligand_chain}:{ligand_resi})')
+    ligand = residues[ligand_resi]
+    assert ligand.get_resname() == ligand_name, \
+        f"{ligand.get_resname()} != {ligand_name}"
+
+    # remove H atoms if not in atom_dict, other atom types that aren't allowed
+    # should stay so that the entire ligand can be removed from the dataset
+    lig_atoms = [a for a in ligand.get_atoms()
+                 if (a.element.capitalize() in atom_dict or a.element != 'H')]
+    lig_coords = np.array([a.get_coord() for a in lig_atoms])
+
+    try:
+        lig_one_hot = np.stack([
+            np.eye(1, len(atom_dict), atom_dict[a.element.capitalize()]).squeeze()
+            for a in lig_atoms
+        ])
+    except KeyError as e:
+        raise KeyError(
+            f'Ligand atom {e} not in atom dict ({pdbfile}, '
+            f'{ligand_name}:{ligand_chain}:{ligand_resi})')
+
+    # Find interacting pocket residues based on distance cutoff
+    pocket_residues = []
+    for residue in pdb_struct[0].get_residues():
+        res_coords = np.array([a.get_coord() for a in residue.get_atoms()])
+        if is_aa(residue.get_resname(), standard=True) and \
+                (((res_coords[:, None, :] - lig_coords[None, :, :]) ** 2).sum(-1) ** 0.5).min() < dist_cutoff:
+            pocket_residues.append(residue)
+
+    # Compute transform of the canonical reference frame
+    n_xyz = np.array([res['N'].get_coord() for res in pocket_residues])
+    ca_xyz = np.array([res['CA'].get_coord() for res in pocket_residues])
+    c_xyz = np.array([res['C'].get_coord() for res in pocket_residues])
+
+    if compute_quaternion:
+        quaternion, c_alpha = get_bb_transform(n_xyz, ca_xyz, c_xyz)
+        if np.any(np.isnan(quaternion)):
+            raise ValueError(
+                f'Invalid value in quaternion ({pdbfile}, '
+                f'{ligand_name}:{ligand_chain}:{ligand_resi})')
+    else:
+        c_alpha = ca_xyz
+
+    if ca_only:
+        pocket_coords = c_alpha
+        try:
+            pocket_one_hot = np.stack([
+                np.eye(1, len(amino_acid_dict),
+                       amino_acid_dict[three_to_one(res.get_resname())]).squeeze()
+                for res in pocket_residues])
+        except KeyError as e:
+            raise KeyError(
+                f'{e} not in amino acid dict ({pdbfile}, '
+                f'{ligand_name}:{ligand_chain}:{ligand_resi})')
+    else:
+        pocket_atoms = [a for res in pocket_residues for a in res.get_atoms()
+                        if (a.element.capitalize() in atom_dict or a.element != 'H')]
+        pocket_coords = np.array([a.get_coord() for a in pocket_atoms])
+        try:
+            pocket_one_hot = np.stack([
+                np.eye(1, len(atom_dict), atom_dict[a.element.capitalize()]).squeeze()
+                for a in pocket_atoms
+            ])
+        except KeyError as e:
+            raise KeyError(
+                f'Pocket atom {e} not in atom dict ({pdbfile}, '
+                f'{ligand_name}:{ligand_chain}:{ligand_resi})')
+
+    pocket_ids = [f'{res.parent.id}:{res.id[1]}' for res in pocket_residues]
+
+    ligand_data = {
+        'lig_coords': lig_coords,
+        'lig_one_hot': lig_one_hot,
+    }
+    pocket_data = {
+        'pocket_coords': pocket_coords,
+        'pocket_one_hot': pocket_one_hot,
+        'pocket_ids': pocket_ids,
+    }
+    if compute_quaternion:
+        pocket_data['pocket_quaternion'] = quaternion
+    return ligand_data, pocket_data
+
+
+def compute_smiles(positions, one_hot, mask):
+    print("Computing SMILES ...")
+
+    atom_types = np.argmax(one_hot, axis=-1)
+
+    sections = np.where(np.diff(mask))[0] + 1
+    positions = [torch.from_numpy(x) for x in np.split(positions, sections)]
+    atom_types = [torch.from_numpy(x) for x in np.split(atom_types, sections)]
+
+    mols_smiles = []
+
+    pbar = tqdm(enumerate(zip(positions, atom_types)),
+                total=len(np.unique(mask)))
+    for i, (pos, atom_type) in pbar:
+        mol = build_molecule(pos, atom_type, dataset_info)
+
+        # BasicMolecularMetrics() computes SMILES after sanitization
+        try:
+            Chem.SanitizeMol(mol)
+        except ValueError:
+            continue
+
+        mol = rdmol_to_smiles(mol)
+        if mol is not None:
+            mols_smiles.append(mol)
+        pbar.set_description(f'{len(mols_smiles)}/{i + 1} successful')
+
+    return mols_smiles
+
+
+def get_n_nodes(lig_mask, pocket_mask, smooth_sigma=None):
+    # Joint distribution of ligand's and pocket's number of nodes
+    idx_lig, n_nodes_lig = np.unique(lig_mask, return_counts=True)
+    idx_pocket, n_nodes_pocket = np.unique(pocket_mask, return_counts=True)
+    assert np.all(idx_lig == idx_pocket)
+
+    joint_histogram = np.zeros((np.max(n_nodes_lig) + 1,
+                                np.max(n_nodes_pocket) + 1))
+
+    for nlig, npocket in zip(n_nodes_lig, n_nodes_pocket):
+        joint_histogram[nlig, npocket] += 1
+
+    print(f'Original histogram: {np.count_nonzero(joint_histogram)}/'
+          f'{joint_histogram.shape[0] * joint_histogram.shape[1]} bins filled')
+
+    # Smooth the histogram
+    if smooth_sigma is not None:
+        filtered_histogram = gaussian_filter(
+            joint_histogram, sigma=smooth_sigma, order=0, mode='constant',
+            cval=0.0, truncate=4.0)
+
+        print(f'Smoothed histogram: {np.count_nonzero(filtered_histogram)}/'
+              f'{filtered_histogram.shape[0] * filtered_histogram.shape[1]} bins filled')
+
+        joint_histogram = filtered_histogram
+
+    return joint_histogram
+
+
+def get_bond_length_arrays(atom_mapping):
+    bond_arrays = []
+    for i in range(3):
+        bond_dict = getattr(constants, f'bonds{i + 1}')
+        bond_array = np.zeros((len(atom_mapping), len(atom_mapping)))
+        for a1 in atom_mapping.keys():
+            for a2 in atom_mapping.keys():
+                if a1 in bond_dict and a2 in bond_dict[a1]:
+                    bond_len = bond_dict[a1][a2]
+                else:
+                    bond_len = 0
+                bond_array[atom_mapping[a1], atom_mapping[a2]] = bond_len
+
+        assert np.all(bond_array == bond_array.T)
+        bond_arrays.append(bond_array)
+
+    return bond_arrays
+
+
+def get_lennard_jones_rm(atom_mapping):
+    # Bond radii for the Lennard-Jones potential
+    LJ_rm = np.zeros((len(atom_mapping), len(atom_mapping)))
+
+    for a1 in atom_mapping.keys():
+        for a2 in atom_mapping.keys():
+            all_bond_lengths = []
+            for btype in ['bonds1', 'bonds2', 'bonds3']:
+                bond_dict = getattr(constants, btype)
+                if a1 in bond_dict and a2 in bond_dict[a1]:
+                    all_bond_lengths.append(bond_dict[a1][a2])
+
+            if len(all_bond_lengths) > 0:
+                # take the shortest possible bond length because slightly larger
+                # values aren't penalized as much
+                bond_len = min(all_bond_lengths)
+            else:
+                # Replace missing values with sum of average covalent radii
+                bond_len = covalent_radii[a1] + covalent_radii[a2]
+
+            LJ_rm[atom_mapping[a1], atom_mapping[a2]] = bond_len
+
+    assert np.all(LJ_rm == LJ_rm.T)
+    return LJ_rm
+
+
+def get_type_histograms(lig_one_hot, pocket_one_hot, atom_encoder, aa_encoder):
+
+    atom_decoder = list(atom_encoder.keys())
+    atom_counts = {k: 0 for k in atom_encoder.keys()}
+    for a in [atom_decoder[x] for x in lig_one_hot.argmax(1)]:
+        atom_counts[a] += 1
+
+    aa_decoder = list(aa_encoder.keys())
+    aa_counts = {k: 0 for k in aa_encoder.keys()}
+    for r in [aa_decoder[x] for x in pocket_one_hot.argmax(1)]:
+        aa_counts[r] += 1
+
+    return atom_counts, aa_counts
+
+
+def saveall(filename, pdb_and_mol_ids, lig_coords, lig_one_hot, lig_mask,
+            pocket_coords, pocket_quaternion, pocket_one_hot, pocket_mask):
+
+    np.savez(filename,
+        names=pdb_and_mol_ids,
+        lig_coords=lig_coords,
+        lig_one_hot=lig_one_hot,
+        lig_mask=lig_mask,
+        pocket_coords=pocket_coords,
+        pocket_quaternion=pocket_quaternion,
+        pocket_one_hot=pocket_one_hot,
+        pocket_mask=pocket_mask
+    )
+    return True
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('basedir', type=Path)
+    parser.add_argument('--outdir', type=Path, default=None)
+    parser.add_argument('--qed_thresh', type=float, default=0.3)
+    parser.add_argument('--max_occurences', type=int, default=50)
+    parser.add_argument('--num_val', type=int, default=300)
+    parser.add_argument('--num_test', type=int, default=300)
+    parser.add_argument('--dist_cutoff', type=float, default=8.0)
+    parser.add_argument('--ca_only', action='store_true')
+    parser.add_argument('--random_seed', type=int, default=42)
+    parser.add_argument('--make_split', action='store_true')
+    args = parser.parse_args()
+
+    pdbdir = args.basedir / 'BindingMOAD_2020/'
+
+    # Make output directory
+    if args.outdir is None:
+        suffix = '' if 'H' in atom_dict else '_noH'
+        suffix += '_ca_only' if args.ca_only else '_full'
+        processed_dir = Path(args.basedir, f'processed{suffix}')
+    else:
+        processed_dir = args.outdir
+
+    processed_dir.mkdir(exist_ok=True, parents=True)
+
+    if args.make_split:
+        # Process the label file
+        csv_path = args.basedir / 'every.csv'
+        ligand_dict = read_label_file(csv_path)
+        ligand_dict = compute_druglikeness(ligand_dict)
+        filtered_examples = filter_and_flatten(
+            ligand_dict, args.qed_thresh, args.max_occurences, args.random_seed)
+        print(f'{len(filtered_examples)} examples after filtering')
+
+        # Make data split
+        data_split = split_by_ec_number(filtered_examples, args.num_val,
+                                        args.num_test)
+
+    else:
+        # Use precomputed data split
+        data_split = {}
+        for split in ['test', 'val', 'train']:
+            with open(f'data/moad_{split}.txt', 'r') as f:
+                pocket_ids = f.read().split(',')
+            # (ec-number, protein, molecule tuple)
+            data_split[split] = [(None, x.split('_')[0][:4], (x.split('_')[1],))
+                          for x in pocket_ids]
+
+    n_train_before = len(data_split['train'])
+    n_val_before = len(data_split['val'])
+    n_test_before = len(data_split['test'])
+
+    # Read and process PDB files
+    n_samples_after = {}
+    for split in data_split.keys():
+        lig_coords = []
+        lig_one_hot = []
+        lig_mask = []
+        pocket_coords = []
+        pocket_one_hot = []
+        pocket_mask = []
+        pdb_and_mol_ids = []
+        receptors = []
+        count = 0
+
+        pdb_sdf_dir = processed_dir / split
+        pdb_sdf_dir.mkdir(exist_ok=True)
+
+        n_tot = len(data_split[split])
+        pair_dict = ligand_list_to_dict(data_split[split])
+
+        tic = time()
+        num_failed = 0
+        with tqdm(total=n_tot) as pbar:
+            for p in pair_dict:
+
+                pdb_successful = set()
+
+                # try all available .bio files
+                for pdbfile in sorted(pdbdir.glob(f"{p.lower()}.bio*")):
+
+                    # Skip if all ligands have been processed already
+                    if len(pair_dict[p]) == len(pdb_successful):
+                        continue
+
+                    pdb_struct = PDBParser(QUIET=True).get_structure('', pdbfile)
+                    struct_copy = pdb_struct.copy()
+
+                    n_bio_successful = 0
+                    for m in pair_dict[p]:
+
+                        # Skip already processed ligand
+                        if m[0] in pdb_successful:
+                            continue
+
+                        ligand_name, ligand_chain, ligand_resi = m[0].split(':')
+                        ligand_resi = int(ligand_resi)
+
+                        try:
+                            ligand_data, pocket_data = process_ligand_and_pocket(
+                                pdb_struct, ligand_name, ligand_chain, ligand_resi,
+                                dist_cutoff=args.dist_cutoff, ca_only=args.ca_only)
+                        except (KeyError, AssertionError, FileNotFoundError,
+                                IndexError, ValueError) as e:
+                            # print(type(e).__name__, e)
+                            continue
+
+                        pdb_and_mol_ids.append(f"{p}_{m[0]}")
+                        receptors.append(pdbfile.name)
+                        lig_coords.append(ligand_data['lig_coords'])
+                        lig_one_hot.append(ligand_data['lig_one_hot'])
+                        lig_mask.append(
+                            count * np.ones(len(ligand_data['lig_coords'])))
+                        pocket_coords.append(pocket_data['pocket_coords'])
+                        # pocket_quaternion.append(
+                        #     pocket_data['pocket_quaternion'])
+                        pocket_one_hot.append(pocket_data['pocket_one_hot'])
+                        pocket_mask.append(
+                            count * np.ones(len(pocket_data['pocket_coords'])))
+                        count += 1
+
+                        pdb_successful.add(m[0])
+                        n_bio_successful += 1
+
+                        # Save additional files for affinity analysis
+                        if split in {'val', 'test'}:
+                        # if split in {'val', 'test', 'train'}:
+                            # remove ligand from receptor
+                            try:
+                                struct_copy[0][ligand_chain].detach_child((f'H_{ligand_name}', ligand_resi, ' '))
+                            except KeyError:
+                                warnings.warn(f"Could not find ligand {(f'H_{ligand_name}', ligand_resi, ' ')} in {pdbfile}")
+                                continue
+
+                            # Create SDF file
+                            atom_types = [atom_decoder[np.argmax(i)] for i in ligand_data['lig_one_hot']]
+                            xyz_file = Path(pdb_sdf_dir, 'tmp.xyz')
+                            utils.write_xyz_file(ligand_data['lig_coords'], atom_types, xyz_file)
+
+                            obConversion = openbabel.OBConversion()
+                            obConversion.SetInAndOutFormats("xyz", "sdf")
+                            mol = openbabel.OBMol()
+                            obConversion.ReadFile(mol, str(xyz_file))
+                            xyz_file.unlink()
+
+                            name = f"{p}-{pdbfile.suffix[1:]}_{m[0]}"
+                            sdf_file = Path(pdb_sdf_dir, f'{name}.sdf')
+                            obConversion.WriteFile(mol, str(sdf_file))
+
+                            # specify pocket residues
+                            with open(Path(pdb_sdf_dir, f'{name}.txt'), 'w') as f:
+                                f.write(' '.join(pocket_data['pocket_ids']))
+
+                    if split in {'val', 'test'} and n_bio_successful > 0:
+                    # if split in {'val', 'test', 'train'} and n_bio_successful > 0:
+                        # create receptor PDB file
+                        pdb_file_out = Path(pdb_sdf_dir, f'{p}-{pdbfile.suffix[1:]}.pdb')
+                        io = PDBIO()
+                        io.set_structure(struct_copy)
+                        io.save(str(pdb_file_out), select=Model0())
+
+                pbar.update(len(pair_dict[p]))
+                num_failed += (len(pair_dict[p]) - len(pdb_successful))
+                pbar.set_description(f'#failed: {num_failed}')
+
+
+        lig_coords = np.concatenate(lig_coords, axis=0)
+        lig_one_hot = np.concatenate(lig_one_hot, axis=0)
+        lig_mask = np.concatenate(lig_mask, axis=0)
+        pocket_coords = np.concatenate(pocket_coords, axis=0)
+        pocket_one_hot = np.concatenate(pocket_one_hot, axis=0)
+        pocket_mask = np.concatenate(pocket_mask, axis=0)
+
+        np.savez(processed_dir / f'{split}.npz', names=pdb_and_mol_ids,
+                 receptors=receptors, lig_coords=lig_coords,
+                 lig_one_hot=lig_one_hot, lig_mask=lig_mask,
+                 pocket_coords=pocket_coords, pocket_one_hot=pocket_one_hot,
+                 pocket_mask=pocket_mask)
+
+        n_samples_after[split] = len(pdb_and_mol_ids)
+        print(f"Processing {split} set took {(time() - tic)/60.0:.2f} minutes")
+
+    # --------------------------------------------------------------------------
+    # Compute statistics & additional information
+    # --------------------------------------------------------------------------
+    with np.load(processed_dir / 'train.npz', allow_pickle=True) as data:
+        lig_mask = data['lig_mask']
+        pocket_mask = data['pocket_mask']
+        lig_coords = data['lig_coords']
+        lig_one_hot = data['lig_one_hot']
+        pocket_one_hot = data['pocket_one_hot']
+
+    # Compute SMILES for all training examples
+    train_smiles = compute_smiles(lig_coords, lig_one_hot, lig_mask)
+    np.save(processed_dir / 'train_smiles.npy', train_smiles)
+
+    # Joint histogram of number of ligand and pocket nodes
+    n_nodes = get_n_nodes(lig_mask, pocket_mask, smooth_sigma=1.0)
+    np.save(Path(processed_dir, 'size_distribution.npy'), n_nodes)
+
+    # Convert bond length dictionaries to arrays for batch processing
+    bonds1, bonds2, bonds3 = get_bond_length_arrays(atom_dict)
+
+    # Get bond length definitions for Lennard-Jones potential
+    rm_LJ = get_lennard_jones_rm(atom_dict)
+
+    # Get histograms of ligand and pocket node types
+    atom_hist, aa_hist = get_type_histograms(lig_one_hot, pocket_one_hot,
+                                             atom_dict, amino_acid_dict)
+
+    # Create summary string
+    summary_string = '# SUMMARY\n\n'
+    summary_string += '# Before processing\n'
+    summary_string += f'num_samples train: {n_train_before}\n'
+    summary_string += f'num_samples val: {n_val_before}\n'
+    summary_string += f'num_samples test: {n_test_before}\n\n'
+    summary_string += '# After processing\n'
+    summary_string += f"num_samples train: {n_samples_after['train']}\n"
+    summary_string += f"num_samples val: {n_samples_after['val']}\n"
+    summary_string += f"num_samples test: {n_samples_after['test']}\n\n"
+    summary_string += '# Info\n'
+    summary_string += f"'atom_encoder': {atom_dict}\n"
+    summary_string += f"'atom_decoder': {list(atom_dict.keys())}\n"
+    summary_string += f"'aa_encoder': {amino_acid_dict}\n"
+    summary_string += f"'aa_decoder': {list(amino_acid_dict.keys())}\n"
+    summary_string += f"'bonds1': {bonds1.tolist()}\n"
+    summary_string += f"'bonds2': {bonds2.tolist()}\n"
+    summary_string += f"'bonds3': {bonds3.tolist()}\n"
+    summary_string += f"'lennard_jones_rm': {rm_LJ.tolist()}\n"
+    summary_string += f"'atom_hist': {atom_hist}\n"
+    summary_string += f"'aa_hist': {aa_hist}\n"
+    summary_string += f"'n_nodes': {n_nodes.tolist()}\n"
+
+    # Write summary to text file
+    with open(processed_dir / 'summary.txt', 'w') as f:
+        f.write(summary_string)
+
+    # Print summary
+    print(summary_string)

process_crossdock.py

@@ -0,0 +1,443 @@
+from pathlib import Path
+from time import time
+import argparse
+import shutil
+import random
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from tqdm import tqdm
+import numpy as np
+
+from Bio.PDB import PDBParser
+from Bio.PDB.Polypeptide import three_to_one, is_aa
+from rdkit import Chem
+from scipy.ndimage import gaussian_filter
+
+import torch
+
+from analysis.molecule_builder import build_molecule
+from analysis.metrics import rdmol_to_smiles
+import constants
+from constants import covalent_radii, dataset_params
+
+
+def process_ligand_and_pocket(pdbfile, sdffile,
+                              atom_dict, dist_cutoff, ca_only):
+    pdb_struct = PDBParser(QUIET=True).get_structure('', pdbfile)
+
+    try:
+        ligand = Chem.SDMolSupplier(str(sdffile))[0]
+    except:
+        raise Exception(f'cannot read sdf mol ({sdffile})')
+
+    # remove H atoms if not in atom_dict, other atom types that aren't allowed
+    # should stay so that the entire ligand can be removed from the dataset
+    lig_atoms = [a.GetSymbol() for a in ligand.GetAtoms()
+                 if (a.GetSymbol().capitalize() in atom_dict or a.element != 'H')]
+    lig_coords = np.array([list(ligand.GetConformer(0).GetAtomPosition(idx))
+                           for idx in range(ligand.GetNumAtoms())])
+
+    try:
+        lig_one_hot = np.stack([
+            np.eye(1, len(atom_dict), atom_dict[a.capitalize()]).squeeze()
+            for a in lig_atoms
+        ])
+    except KeyError as e:
+        raise KeyError(
+            f'{e} not in atom dict ({sdffile})')
+
+    # Find interacting pocket residues based on distance cutoff
+    pocket_residues = []
+    for residue in pdb_struct[0].get_residues():
+        res_coords = np.array([a.get_coord() for a in residue.get_atoms()])
+        if is_aa(residue.get_resname(), standard=True) and \
+                (((res_coords[:, None, :] - lig_coords[None, :, :]) ** 2).sum(
+                    -1) ** 0.5).min() < dist_cutoff:
+            pocket_residues.append(residue)
+
+    pocket_ids = [f'{res.parent.id}:{res.id[1]}' for res in pocket_residues]
+    ligand_data = {
+        'lig_coords': lig_coords,
+        'lig_one_hot': lig_one_hot,
+    }
+    if ca_only:
+        try:
+            pocket_one_hot = []
+            full_coords = []
+            for res in pocket_residues:
+                for atom in res.get_atoms():
+                    if atom.name == 'CA':
+                        pocket_one_hot.append(np.eye(1, len(amino_acid_dict),
+                                                     amino_acid_dict[three_to_one(res.get_resname())]).squeeze())
+                        full_coords.append(atom.coord)
+            pocket_one_hot = np.stack(pocket_one_hot)
+            full_coords = np.stack(full_coords)
+        except KeyError as e:
+            raise KeyError(
+                f'{e} not in amino acid dict ({pdbfile}, {sdffile})')
+        pocket_data = {
+            'pocket_coords': full_coords,
+            'pocket_one_hot': pocket_one_hot,
+            'pocket_ids': pocket_ids
+        }
+    else:
+        full_atoms = np.concatenate(
+            [np.array([atom.element for atom in res.get_atoms()])
+             for res in pocket_residues], axis=0)
+        full_coords = np.concatenate(
+            [np.array([atom.coord for atom in res.get_atoms()])
+             for res in pocket_residues], axis=0)
+        try:
+            pocket_one_hot = []
+            for a in full_atoms:
+                if a in amino_acid_dict:
+                    atom = np.eye(1, len(amino_acid_dict),
+                                  amino_acid_dict[a.capitalize()]).squeeze()
+                elif a != 'H':
+                    atom = np.eye(1, len(amino_acid_dict),
+                                  len(amino_acid_dict)).squeeze()
+                pocket_one_hot.append(atom)
+            pocket_one_hot = np.stack(pocket_one_hot)
+        except KeyError as e:
+            raise KeyError(
+                f'{e} not in atom dict ({pdbfile})')
+        pocket_data = {
+            'pocket_coords': full_coords,
+            'pocket_one_hot': pocket_one_hot,
+            'pocket_ids': pocket_ids
+        }
+    return ligand_data, pocket_data
+
+
+def compute_smiles(positions, one_hot, mask):
+    print("Computing SMILES ...")
+
+    atom_types = np.argmax(one_hot, axis=-1)
+
+    sections = np.where(np.diff(mask))[0] + 1
+    positions = [torch.from_numpy(x) for x in np.split(positions, sections)]
+    atom_types = [torch.from_numpy(x) for x in np.split(atom_types, sections)]
+
+    mols_smiles = []
+
+    pbar = tqdm(enumerate(zip(positions, atom_types)),
+                total=len(np.unique(mask)))
+    for i, (pos, atom_type) in pbar:
+        mol = build_molecule(pos, atom_type, dataset_info)
+
+        # BasicMolecularMetrics() computes SMILES after sanitization
+        try:
+            Chem.SanitizeMol(mol)
+        except ValueError:
+            continue
+
+        mol = rdmol_to_smiles(mol)
+        if mol is not None:
+            mols_smiles.append(mol)
+        pbar.set_description(f'{len(mols_smiles)}/{i + 1} successful')
+
+    return mols_smiles
+
+
+def get_n_nodes(lig_mask, pocket_mask, smooth_sigma=None):
+    # Joint distribution of ligand's and pocket's number of nodes
+    idx_lig, n_nodes_lig = np.unique(lig_mask, return_counts=True)
+    idx_pocket, n_nodes_pocket = np.unique(pocket_mask, return_counts=True)
+    assert np.all(idx_lig == idx_pocket)
+
+    joint_histogram = np.zeros((np.max(n_nodes_lig) + 1,
+                                np.max(n_nodes_pocket) + 1))
+
+    for nlig, npocket in zip(n_nodes_lig, n_nodes_pocket):
+        joint_histogram[nlig, npocket] += 1
+
+    print(f'Original histogram: {np.count_nonzero(joint_histogram)}/'
+          f'{joint_histogram.shape[0] * joint_histogram.shape[1]} bins filled')
+
+    # Smooth the histogram
+    if smooth_sigma is not None:
+        filtered_histogram = gaussian_filter(
+            joint_histogram, sigma=smooth_sigma, order=0, mode='constant',
+            cval=0.0, truncate=4.0)
+
+        print(f'Smoothed histogram: {np.count_nonzero(filtered_histogram)}/'
+              f'{filtered_histogram.shape[0] * filtered_histogram.shape[1]} bins filled')
+
+        joint_histogram = filtered_histogram
+
+    return joint_histogram
+
+
+def get_bond_length_arrays(atom_mapping):
+    bond_arrays = []
+    for i in range(3):
+        bond_dict = getattr(constants, f'bonds{i + 1}')
+        bond_array = np.zeros((len(atom_mapping), len(atom_mapping)))
+        for a1 in atom_mapping.keys():
+            for a2 in atom_mapping.keys():
+                if a1 in bond_dict and a2 in bond_dict[a1]:
+                    bond_len = bond_dict[a1][a2]
+                else:
+                    bond_len = 0
+                bond_array[atom_mapping[a1], atom_mapping[a2]] = bond_len
+
+        assert np.all(bond_array == bond_array.T)
+        bond_arrays.append(bond_array)
+
+    return bond_arrays
+
+
+def get_lennard_jones_rm(atom_mapping):
+    # Bond radii for the Lennard-Jones potential
+    LJ_rm = np.zeros((len(atom_mapping), len(atom_mapping)))
+
+    for a1 in atom_mapping.keys():
+        for a2 in atom_mapping.keys():
+            all_bond_lengths = []
+            for btype in ['bonds1', 'bonds2', 'bonds3']:
+                bond_dict = getattr(constants, btype)
+                if a1 in bond_dict and a2 in bond_dict[a1]:
+                    all_bond_lengths.append(bond_dict[a1][a2])
+
+            if len(all_bond_lengths) > 0:
+                # take the shortest possible bond length because slightly larger
+                # values aren't penalized as much
+                bond_len = min(all_bond_lengths)
+            else:
+                if a1 == 'others' or a2 == 'others':
+                    bond_len = 0
+                else:
+                    # Replace missing values with sum of average covalent radii
+                    bond_len = covalent_radii[a1] + covalent_radii[a2]
+
+            LJ_rm[atom_mapping[a1], atom_mapping[a2]] = bond_len
+
+    assert np.all(LJ_rm == LJ_rm.T)
+    return LJ_rm
+
+
+def get_type_histograms(lig_one_hot, pocket_one_hot, atom_encoder, aa_encoder):
+    atom_decoder = list(atom_encoder.keys())
+    atom_counts = {k: 0 for k in atom_encoder.keys()}
+    for a in [atom_decoder[x] for x in lig_one_hot.argmax(1)]:
+        atom_counts[a] += 1
+
+    aa_decoder = list(aa_encoder.keys())
+    aa_counts = {k: 0 for k in aa_encoder.keys()}
+    for r in [aa_decoder[x] for x in pocket_one_hot.argmax(1)]:
+        aa_counts[r] += 1
+
+    return atom_counts, aa_counts
+
+
+def saveall(filename, pdb_and_mol_ids, lig_coords, lig_one_hot, lig_mask,
+            pocket_coords, pocket_one_hot, pocket_mask):
+    np.savez(filename,
+             names=pdb_and_mol_ids,
+             lig_coords=lig_coords,
+             lig_one_hot=lig_one_hot,
+             lig_mask=lig_mask,
+             pocket_coords=pocket_coords,
+             pocket_one_hot=pocket_one_hot,
+             pocket_mask=pocket_mask
+             )
+    return True
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('basedir', type=Path)
+    parser.add_argument('--outdir', type=Path, default=None)
+    parser.add_argument('--no_H', action='store_true')
+    parser.add_argument('--ca_only', action='store_true')
+    parser.add_argument('--dist_cutoff', type=float, default=8.0)
+    parser.add_argument('--random_seed', type=int, default=42)
+    args = parser.parse_args()
+
+    datadir = args.basedir / 'crossdocked_pocket10/'
+
+    if args.ca_only:
+        dataset_info = dataset_params['crossdock']
+    else:
+        dataset_info = dataset_params['crossdock_full']
+    amino_acid_dict = dataset_info['aa_encoder']
+    atom_dict = dataset_info['atom_encoder']
+    atom_decoder = dataset_info['atom_decoder']
+
+    # Make output directory
+    if args.outdir is None:
+        suffix = '_crossdock' if 'H' in atom_dict else '_crossdock_noH'
+        suffix += '_ca_only_temp' if args.ca_only else '_full_temp'
+        processed_dir = Path(args.basedir, f'processed{suffix}')
+    else:
+        processed_dir = args.outdir
+
+    processed_dir.mkdir(exist_ok=True, parents=True)
+
+    # Read data split
+    split_path = Path(args.basedir, 'split_by_name.pt')
+    data_split = torch.load(split_path)
+
+    # There is no validation set, copy 300 training examples (the validation set
+    # is not very important in this application)
+    # Note: before we had a data leak but it should not matter too much as most
+    # metrics monitored during training are independent of the pockets
+    data_split['val'] = random.sample(data_split['train'], 300)
+
+    n_train_before = len(data_split['train'])
+    n_val_before = len(data_split['val'])
+    n_test_before = len(data_split['test'])
+
+    failed_save = []
+
+    n_samples_after = {}
+    for split in data_split.keys():
+        lig_coords = []
+        lig_one_hot = []
+        lig_mask = []
+        pocket_coords = []
+        pocket_one_hot = []
+        pocket_mask = []
+        pdb_and_mol_ids = []
+        count_protein = []
+        count_ligand = []
+        count_total = []
+        count = 0
+
+        pdb_sdf_dir = processed_dir / split
+        pdb_sdf_dir.mkdir(exist_ok=True)
+
+        tic = time()
+        num_failed = 0
+        pbar = tqdm(data_split[split])
+        pbar.set_description(f'#failed: {num_failed}')
+        for pocket_fn, ligand_fn in pbar:
+
+            sdffile = datadir / f'{ligand_fn}'
+            pdbfile = datadir / f'{pocket_fn}'
+
+            try:
+                struct_copy = PDBParser(QUIET=True).get_structure('', pdbfile)
+            except:
+                num_failed += 1
+                failed_save.append((pocket_fn, ligand_fn))
+                print(failed_save[-1])
+                pbar.set_description(f'#failed: {num_failed}')
+                continue
+
+            try:
+                ligand_data, pocket_data = process_ligand_and_pocket(
+                    pdbfile, sdffile,
+                    atom_dict=atom_dict, dist_cutoff=args.dist_cutoff,
+                    ca_only=args.ca_only)
+            except (KeyError, AssertionError, FileNotFoundError, IndexError,
+                    ValueError) as e:
+                print(type(e).__name__, e, pocket_fn, ligand_fn)
+                num_failed += 1
+                pbar.set_description(f'#failed: {num_failed}')
+                continue
+
+            pdb_and_mol_ids.append(f"{pocket_fn}_{ligand_fn}")
+            lig_coords.append(ligand_data['lig_coords'])
+            lig_one_hot.append(ligand_data['lig_one_hot'])
+            lig_mask.append(count * np.ones(len(ligand_data['lig_coords'])))
+            pocket_coords.append(pocket_data['pocket_coords'])
+            pocket_one_hot.append(pocket_data['pocket_one_hot'])
+            pocket_mask.append(
+                count * np.ones(len(pocket_data['pocket_coords'])))
+            count_protein.append(pocket_data['pocket_coords'].shape[0])
+            count_ligand.append(ligand_data['lig_coords'].shape[0])
+            count_total.append(pocket_data['pocket_coords'].shape[0] +
+                               ligand_data['lig_coords'].shape[0])
+            count += 1
+
+            if split in {'val', 'test'}:
+                # Copy PDB file
+                new_rec_name = Path(pdbfile).stem.replace('_', '-')
+                pdb_file_out = Path(pdb_sdf_dir, f"{new_rec_name}.pdb")
+                shutil.copy(pdbfile, pdb_file_out)
+
+                # Copy SDF file
+                new_lig_name = new_rec_name + '_' + Path(sdffile).stem.replace('_', '-')
+                sdf_file_out = Path(pdb_sdf_dir, f'{new_lig_name}.sdf')
+                shutil.copy(sdffile, sdf_file_out)
+
+                # specify pocket residues
+                with open(Path(pdb_sdf_dir, f'{new_lig_name}.txt'), 'w') as f:
+                    f.write(' '.join(pocket_data['pocket_ids']))
+
+        lig_coords = np.concatenate(lig_coords, axis=0)
+        lig_one_hot = np.concatenate(lig_one_hot, axis=0)
+        lig_mask = np.concatenate(lig_mask, axis=0)
+        pocket_coords = np.concatenate(pocket_coords, axis=0)
+        pocket_one_hot = np.concatenate(pocket_one_hot, axis=0)
+        pocket_mask = np.concatenate(pocket_mask, axis=0)
+
+        saveall(processed_dir / f'{split}.npz', pdb_and_mol_ids, lig_coords,
+                lig_one_hot, lig_mask, pocket_coords,
+                pocket_one_hot, pocket_mask)
+
+        n_samples_after[split] = len(pdb_and_mol_ids)
+        print(f"Processing {split} set took {(time() - tic) / 60.0:.2f} minutes")
+
+    # --------------------------------------------------------------------------
+    # Compute statistics & additional information
+    # --------------------------------------------------------------------------
+    with np.load(processed_dir / 'train.npz', allow_pickle=True) as data:
+        lig_mask = data['lig_mask']
+        pocket_mask = data['pocket_mask']
+        lig_coords = data['lig_coords']
+        lig_one_hot = data['lig_one_hot']
+        pocket_one_hot = data['pocket_one_hot']
+
+    # Compute SMILES for all training examples
+    train_smiles = compute_smiles(lig_coords, lig_one_hot, lig_mask)
+    np.save(processed_dir / 'train_smiles.npy', train_smiles)
+
+    # Joint histogram of number of ligand and pocket nodes
+    n_nodes = get_n_nodes(lig_mask, pocket_mask, smooth_sigma=1.0)
+    np.save(Path(processed_dir, 'size_distribution.npy'), n_nodes)
+
+    # Convert bond length dictionaries to arrays for batch processing
+    bonds1, bonds2, bonds3 = get_bond_length_arrays(atom_dict)
+
+    # Get bond length definitions for Lennard-Jones potential
+    rm_LJ = get_lennard_jones_rm(atom_dict)
+
+    # Get histograms of ligand and pocket node types
+    atom_hist, aa_hist = get_type_histograms(lig_one_hot, pocket_one_hot,
+                                             atom_dict, amino_acid_dict)
+
+    # Create summary string
+    summary_string = '# SUMMARY\n\n'
+    summary_string += '# Before processing\n'
+    summary_string += f'num_samples train: {n_train_before}\n'
+    summary_string += f'num_samples val: {n_val_before}\n'
+    summary_string += f'num_samples test: {n_test_before}\n\n'
+    summary_string += '# After processing\n'
+    summary_string += f"num_samples train: {n_samples_after['train']}\n"
+    summary_string += f"num_samples val: {n_samples_after['val']}\n"
+    summary_string += f"num_samples test: {n_samples_after['test']}\n\n"
+    summary_string += '# Info\n'
+    summary_string += f"'atom_encoder': {atom_dict}\n"
+    summary_string += f"'atom_decoder': {list(atom_dict.keys())}\n"
+    summary_string += f"'aa_encoder': {amino_acid_dict}\n"
+    summary_string += f"'aa_decoder': {list(amino_acid_dict.keys())}\n"
+    summary_string += f"'bonds1': {bonds1.tolist()}\n"
+    summary_string += f"'bonds2': {bonds2.tolist()}\n"
+    summary_string += f"'bonds3': {bonds3.tolist()}\n"
+    summary_string += f"'lennard_jones_rm': {rm_LJ.tolist()}\n"
+    summary_string += f"'atom_hist': {atom_hist}\n"
+    summary_string += f"'aa_hist': {aa_hist}\n"
+    summary_string += f"'n_nodes': {n_nodes.tolist()}\n"
+
+    # Write summary to text file
+    with open(processed_dir / 'summary.txt', 'w') as f:
+        f.write(summary_string)
+
+    # Print summary
+    print(summary_string)
+
+    print(failed_save)

test.py

@@ -0,0 +1,176 @@
+import argparse
+import warnings
+from pathlib import Path
+from time import time
+
+import torch
+from rdkit import Chem
+from tqdm import tqdm
+
+from lightning_modules import LigandPocketDDPM
+from analysis.molecule_builder import process_molecule
+import utils
+
+MAXITER = 10
+MAXNTRIES = 10
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('checkpoint', type=Path)
+    parser.add_argument('--test_dir', type=Path)
+    parser.add_argument('--test_list', type=Path, default=None)
+    parser.add_argument('--outdir', type=Path)
+    parser.add_argument('--n_samples', type=int, default=100)
+    parser.add_argument('--all_frags', action='store_true')
+    parser.add_argument('--sanitize', action='store_true')
+    parser.add_argument('--relax', action='store_true')
+    parser.add_argument('--batch_size', type=int, default=120)
+    parser.add_argument('--resamplings', type=int, default=10)
+    parser.add_argument('--jump_length', type=int, default=1)
+    parser.add_argument('--timesteps', type=int, default=None)
+    parser.add_argument('--fix_n_nodes', action='store_true')
+    parser.add_argument('--n_nodes_bias', type=int, default=0)
+    parser.add_argument('--n_nodes_min', type=int, default=0)
+    parser.add_argument('--skip_existing', action='store_true')
+    args = parser.parse_args()
+
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    args.outdir.mkdir(exist_ok=args.skip_existing)
+    raw_sdf_dir = Path(args.outdir, 'raw')
+    raw_sdf_dir.mkdir(exist_ok=args.skip_existing)
+    processed_sdf_dir = Path(args.outdir, 'processed')
+    processed_sdf_dir.mkdir(exist_ok=args.skip_existing)
+    times_dir = Path(args.outdir, 'pocket_times')
+    times_dir.mkdir(exist_ok=args.skip_existing)
+
+    # Load model
+    model = LigandPocketDDPM.load_from_checkpoint(
+        args.checkpoint, map_location=device)
+    model = model.to(device)
+
+    test_files = list(args.test_dir.glob('[!.]*.sdf'))
+    if args.test_list is not None:
+        with open(args.test_list, 'r') as f:
+            test_list = set(f.read().split(','))
+        test_files = [x for x in test_files if x.stem in test_list]
+
+    pbar = tqdm(test_files)
+    time_per_pocket = {}
+    for sdf_file in pbar:
+        ligand_name = sdf_file.stem
+
+        pdb_name, pocket_id, *suffix = ligand_name.split('_')
+        pdb_file = Path(sdf_file.parent, f"{pdb_name}.pdb")
+        txt_file = Path(sdf_file.parent, f"{ligand_name}.txt")
+        sdf_out_file_raw = Path(raw_sdf_dir, f'{ligand_name}_gen.sdf')
+        sdf_out_file_processed = Path(processed_sdf_dir,
+                                      f'{ligand_name}_gen.sdf')
+        time_file = Path(times_dir, f'{ligand_name}.txt')
+
+        if args.skip_existing and time_file.exists() \
+                and sdf_out_file_processed.exists() \
+                and sdf_out_file_raw.exists():
+
+            with open(time_file, 'r') as f:
+                time_per_pocket[str(sdf_file)] = float(f.read().split()[1])
+
+            continue
+
+        for n_try in range(MAXNTRIES):
+
+            try:
+                t_pocket_start = time()
+
+                with open(txt_file, 'r') as f:
+                    resi_list = f.read().split()
+
+                if args.fix_n_nodes:
+                    # some ligands (e.g. 6JWS_bio1_PT1:A:801) could not be read with sanitize=True
+                    suppl = Chem.SDMolSupplier(str(sdf_file), sanitize=False)
+                    num_nodes_lig = suppl[0].GetNumAtoms()
+                else:
+                    num_nodes_lig = None
+
+                all_molecules = []
+                valid_molecules = []
+                processed_molecules = []  # only used as temporary variable
+                iter = 0
+                n_generated = 0
+                n_valid = 0
+                while len(valid_molecules) < args.n_samples:
+                    iter += 1
+                    if iter > MAXITER:
+                        raise RuntimeError('Maximum number of iterations has been exceeded.')
+
+                    num_nodes_lig_inflated = None if num_nodes_lig is None else \
+                        torch.ones(args.batch_size, dtype=int) * num_nodes_lig
+
+                    # Turn all filters off first
+                    mols_batch = model.generate_ligands(
+                        pdb_file, args.batch_size, resi_list,
+                        num_nodes_lig=num_nodes_lig_inflated,
+                        timesteps=args.timesteps, sanitize=False,
+                        largest_frag=False, relax_iter=0,
+                        n_nodes_bias=args.n_nodes_bias,
+                        n_nodes_min=args.n_nodes_min,
+                        resamplings=args.resamplings,
+                        jump_length=args.jump_length)
+
+                    all_molecules.extend(mols_batch)
+
+                    # Filter to find valid molecules
+                    mols_batch_processed = [
+                        process_molecule(m, sanitize=args.sanitize,
+                                         relax_iter=(200 if args.relax else 0),
+                                         largest_frag=not args.all_frags)
+                        for m in mols_batch
+                    ]
+                    processed_molecules.extend(mols_batch_processed)
+                    valid_mols_batch = [m for m in mols_batch_processed if m is not None]
+
+                    n_generated += args.batch_size
+                    n_valid += len(valid_mols_batch)
+                    valid_molecules.extend(valid_mols_batch)
+
+                # Remove excess molecules from list
+                valid_molecules = valid_molecules[:args.n_samples]
+
+                # Reorder raw files
+                all_molecules = \
+                    [all_molecules[i] for i, m in enumerate(processed_molecules)
+                     if m is not None] + \
+                    [all_molecules[i] for i, m in enumerate(processed_molecules)
+                     if m is None]
+
+                # Write SDF files
+                utils.write_sdf_file(sdf_out_file_raw, all_molecules)
+                utils.write_sdf_file(sdf_out_file_processed, valid_molecules)
+
+                # Time the sampling process
+                time_per_pocket[str(sdf_file)] = time() - t_pocket_start
+                with open(time_file, 'w') as f:
+                    f.write(f"{str(sdf_file)} {time_per_pocket[str(sdf_file)]}")
+
+                pbar.set_description(
+                    f'Last processed: {ligand_name}. '
+                    f'Validity: {n_valid / n_generated * 100:.2f}%. '
+                    f'{(time() - t_pocket_start) / len(valid_molecules):.2f} '
+                    f'sec/mol.')
+
+                break  # no more tries needed
+
+            except (RuntimeError, ValueError) as e:
+                if n_try >= MAXNTRIES - 1:
+                    raise RuntimeError("Maximum number of retries exceeded")
+                warnings.warn(f"Attempt {n_try + 1}/{MAXNTRIES} failed with "
+                              f"error: '{e}'. Trying again...")
+
+    with open(Path(args.outdir, 'pocket_times.txt'), 'w') as f:
+        for k, v in time_per_pocket.items():
+            f.write(f"{k} {v}\n")
+
+    times_arr = torch.tensor([x for x in time_per_pocket.values()])
+    print(f"Time per pocket: {times_arr.mean():.3f} \pm "
+          f"{times_arr.std(unbiased=False):.2f}")

train.py

@@ -0,0 +1,122 @@
+import argparse
+from argparse import Namespace
+from pathlib import Path
+import warnings
+
+import torch
+import pytorch_lightning as pl
+import yaml
+import numpy as np
+
+from lightning_modules import LigandPocketDDPM
+
+
+def merge_args_and_yaml(args, config_dict):
+    arg_dict = args.__dict__
+    for key, value in config_dict.items():
+        if key in arg_dict:
+            warnings.warn(f"Command line argument '{key}' (value: "
+                          f"{arg_dict[key]}) will be overwritten with value "
+                          f"{value} provided in the config file.")
+        if isinstance(value, dict):
+            arg_dict[key] = Namespace(**value)
+        else:
+            arg_dict[key] = value
+
+    return args
+
+
+def merge_configs(config, resume_config):
+    for key, value in resume_config.items():
+        if isinstance(value, Namespace):
+            value = value.__dict__
+        if key in config and config[key] != value:
+            warnings.warn(f"Config parameter '{key}' (value: "
+                          f"{config[key]}) will be overwritten with value "
+                          f"{value} from the checkpoint.")
+        config[key] = value
+    return config
+
+
+# ------------------------------------------------------------------------------
+# Training
+# ______________________________________________________________________________
+if __name__ == "__main__":
+    p = argparse.ArgumentParser()
+    p.add_argument('--config', type=str, required=True)
+    p.add_argument('--resume', type=str, default=None)
+    args = p.parse_args()
+
+    with open(args.config, 'r') as f:
+        config = yaml.safe_load(f)
+
+    assert 'resume' not in config
+
+    # Get main config
+    ckpt_path = None if args.resume is None else Path(args.resume)
+    if args.resume is not None:
+        resume_config = torch.load(
+            ckpt_path, map_location=torch.device('cpu'))['hyper_parameters']
+
+        config = merge_configs(config, resume_config)
+
+    args = merge_args_and_yaml(args, config)
+
+    out_dir = Path(args.logdir, args.run_name)
+    histogram_file = Path(args.datadir, 'size_distribution.npy')
+    histogram = np.load(histogram_file).tolist()
+    pl_module = LigandPocketDDPM(
+        outdir=out_dir,
+        dataset=args.dataset,
+        datadir=args.datadir,
+        batch_size=args.batch_size,
+        lr=args.lr,
+        egnn_params=args.egnn_params,
+        diffusion_params=args.diffusion_params,
+        num_workers=args.num_workers,
+        augment_noise=args.augment_noise,
+        augment_rotation=args.augment_rotation,
+        clip_grad=args.clip_grad,
+        eval_epochs=args.eval_epochs,
+        eval_params=args.eval_params,
+        visualize_sample_epoch=args.visualize_sample_epoch,
+        visualize_chain_epoch=args.visualize_chain_epoch,
+        auxiliary_loss=args.auxiliary_loss,
+        loss_params=args.loss_params,
+        mode=args.mode,
+        node_histogram=histogram,
+        pocket_representation=args.pocket_representation,
+        virtual_nodes=args.virtual_nodes
+    )
+
+    logger = pl.loggers.WandbLogger(
+        save_dir=args.logdir,
+        project='ligand-pocket-ddpm',
+        group=args.wandb_params.group,
+        name=args.run_name,
+        id=args.run_name,
+        resume='must' if args.resume is not None else False,
+        entity=args.wandb_params.entity,
+        mode=args.wandb_params.mode,
+    )
+
+    checkpoint_callback = pl.callbacks.ModelCheckpoint(
+        dirpath=Path(out_dir, 'checkpoints'),
+        filename="best-model-epoch={epoch:02d}",
+        monitor="loss/val",
+        save_top_k=1,
+        save_last=True,
+        mode="min",
+    )
+
+    trainer = pl.Trainer(
+        max_epochs=args.n_epochs,
+        logger=logger,
+        callbacks=[checkpoint_callback],
+        enable_progress_bar=args.enable_progress_bar,
+        num_sanity_val_steps=args.num_sanity_val_steps,
+        accelerator='gpu', devices=args.gpus,
+        strategy=('ddp' if args.gpus > 1 else None)
+    )
+
+    trainer.fit(model=pl_module, ckpt_path=ckpt_path)

utils.py

@@ -0,0 +1,234 @@
+from typing import Union, Iterable
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from rdkit import Chem
+import networkx as nx
+from networkx.algorithms import isomorphism
+from Bio.PDB.Polypeptide import is_aa
+
+
+class Queue():
+    def __init__(self, max_len=50):
+        self.items = []
+        self.max_len = max_len
+
+    def __len__(self):
+        return len(self.items)
+
+    def add(self, item):
+        self.items.insert(0, item)
+        if len(self) > self.max_len:
+            self.items.pop()
+
+    def mean(self):
+        return np.mean(self.items)
+
+    def std(self):
+        return np.std(self.items)
+
+
+def reverse_tensor(x):
+    return x[torch.arange(x.size(0) - 1, -1, -1)]
+
+
+#####
+
+
+def get_grad_norm(
+        parameters: Union[torch.Tensor, Iterable[torch.Tensor]],
+        norm_type: float = 2.0) -> torch.Tensor:
+    """
+    Adapted from: https://pytorch.org/docs/stable/_modules/torch/nn/utils/clip_grad.html#clip_grad_norm_
+    """
+
+    if isinstance(parameters, torch.Tensor):
+        parameters = [parameters]
+    parameters = [p for p in parameters if p.grad is not None]
+
+    norm_type = float(norm_type)
+
+    if len(parameters) == 0:
+        return torch.tensor(0.)
+
+    device = parameters[0].grad.device
+
+    total_norm = torch.norm(torch.stack(
+        [torch.norm(p.grad.detach(), norm_type).to(device) for p in
+         parameters]), norm_type)
+
+    return total_norm
+
+
+def write_xyz_file(coords, atom_types, filename):
+    out = f"{len(coords)}\n\n"
+    assert len(coords) == len(atom_types)
+    for i in range(len(coords)):
+        out += f"{atom_types[i]} {coords[i, 0]:.3f} {coords[i, 1]:.3f} {coords[i, 2]:.3f}\n"
+    with open(filename, 'w') as f:
+        f.write(out)
+
+
+def write_sdf_file(sdf_path, molecules):
+    # NOTE Changed to be compatitble with more versions of rdkit
+    #with Chem.SDWriter(str(sdf_path)) as w:
+    #    for mol in molecules:
+    #        w.write(mol)
+
+    w = Chem.SDWriter(str(sdf_path))
+    w.SetKekulize(False)
+    for m in molecules:
+        if m is not None:
+            w.write(m)
+
+    # print(f'Wrote SDF file to {sdf_path}')
+
+
+def residues_to_atoms(x_ca, atom_encoder):
+    x = x_ca
+    one_hot = F.one_hot(
+        torch.tensor(atom_encoder['C'], device=x_ca.device),
+        num_classes=len(atom_encoder)
+    ).repeat(*x_ca.shape[:-1], 1)
+    return x, one_hot
+
+
+def get_residue_with_resi(pdb_chain, resi):
+    res = [x for x in pdb_chain.get_residues() if x.id[1] == resi]
+    assert len(res) == 1
+    return res[0]
+
+
+def get_pocket_from_ligand(pdb_model, ligand, dist_cutoff=8.0):
+
+    if ligand.endswith(".sdf"):
+        # ligand as sdf file
+        rdmol = Chem.SDMolSupplier(str(ligand))[0]
+        ligand_coords = torch.from_numpy(rdmol.GetConformer().GetPositions()).float()
+        resi = None
+    else:
+        # ligand contained in PDB; given in <chain>:<resi> format
+        chain, resi = ligand.split(':')
+        ligand = get_residue_with_resi(pdb_model[chain], int(resi))
+        ligand_coords = torch.from_numpy(
+            np.array([a.get_coord() for a in ligand.get_atoms()]))
+
+    pocket_residues = []
+    for residue in pdb_model.get_residues():
+        if residue.id[1] == resi:
+            continue  # skip ligand itself
+
+        res_coords = torch.from_numpy(
+            np.array([a.get_coord() for a in residue.get_atoms()]))
+        if is_aa(residue.get_resname(), standard=True) \
+                and torch.cdist(res_coords, ligand_coords).min() < dist_cutoff:
+            pocket_residues.append(residue)
+
+    return pocket_residues
+
+
+def batch_to_list(data, batch_mask):
+    # data_list = []
+    # for i in torch.unique(batch_mask):
+    #     data_list.append(data[batch_mask == i])
+    # return data_list
+
+    # make sure batch_mask is increasing
+    idx = torch.argsort(batch_mask)
+    batch_mask = batch_mask[idx]
+    data = data[idx]
+
+    chunk_sizes = torch.unique(batch_mask, return_counts=True)[1].tolist()
+    return torch.split(data, chunk_sizes)
+
+
+def num_nodes_to_batch_mask(n_samples, num_nodes, device):
+    assert isinstance(num_nodes, int) or len(num_nodes) == n_samples
+
+    if isinstance(num_nodes, torch.Tensor):
+        num_nodes = num_nodes.to(device)
+
+    sample_inds = torch.arange(n_samples, device=device)
+
+    return torch.repeat_interleave(sample_inds, num_nodes)
+
+
+def rdmol_to_nxgraph(rdmol):
+    graph = nx.Graph()
+    for atom in rdmol.GetAtoms():
+        # Add the atoms as nodes
+        graph.add_node(atom.GetIdx(), atom_type=atom.GetAtomicNum())
+
+    # Add the bonds as edges
+    for bond in rdmol.GetBonds():
+        graph.add_edge(bond.GetBeginAtomIdx(), bond.GetEndAtomIdx())
+
+    return graph
+
+
+def calc_rmsd(mol_a, mol_b):
+    """ Calculate RMSD of two molecules with unknown atom correspondence. """
+    graph_a = rdmol_to_nxgraph(mol_a)
+    graph_b = rdmol_to_nxgraph(mol_b)
+
+    gm = isomorphism.GraphMatcher(
+        graph_a, graph_b,
+        node_match=lambda na, nb: na['atom_type'] == nb['atom_type'])
+
+    isomorphisms = list(gm.isomorphisms_iter())
+    if len(isomorphisms) < 1:
+        return None
+
+    all_rmsds = []
+    for mapping in isomorphisms:
+        atom_types_a = [atom.GetAtomicNum() for atom in mol_a.GetAtoms()]
+        atom_types_b = [mol_b.GetAtomWithIdx(mapping[i]).GetAtomicNum()
+                        for i in range(mol_b.GetNumAtoms())]
+        assert atom_types_a == atom_types_b
+
+        conf_a = mol_a.GetConformer()
+        coords_a = np.array([conf_a.GetAtomPosition(i)
+                             for i in range(mol_a.GetNumAtoms())])
+        conf_b = mol_b.GetConformer()
+        coords_b = np.array([conf_b.GetAtomPosition(mapping[i])
+                             for i in range(mol_b.GetNumAtoms())])
+
+        diff = coords_a - coords_b
+        rmsd = np.sqrt(np.mean(np.sum(diff * diff, axis=1)))
+        all_rmsds.append(rmsd)
+
+    if len(isomorphisms) > 1:
+        print("More than one isomorphism found. Returning minimum RMSD.")
+
+    return min(all_rmsds)
+
+
+class AppendVirtualNodes:
+    def __init__(self, max_ligand_size, atom_encoder, symbol):
+        self.max_ligand_size = max_ligand_size
+        self.atom_encoder = atom_encoder
+        self.vidx = atom_encoder[symbol]
+
+    def __call__(self, data):
+
+        n_virt = self.max_ligand_size - data['num_lig_atoms']
+        mu = data['lig_coords'].mean(0, keepdim=True)
+        sigma = data['lig_coords'].std(0).max()
+        virt_coords = torch.randn(n_virt, 3) * sigma + mu
+
+        # insert virtual atom column
+        one_hot = torch.cat((data['lig_one_hot'][:, :self.vidx],
+                            torch.zeros(data['num_lig_atoms'])[:, None],
+                            data['lig_one_hot'][:, self.vidx:]), dim=1)
+        virt_one_hot = torch.zeros(n_virt, len(self.atom_encoder))
+        virt_one_hot[:, self.vidx] = 1
+        virt_mask = torch.ones(n_virt) * data['lig_mask'][0]
+
+        data['lig_coords'] = torch.cat((data['lig_coords'], virt_coords))
+        data['lig_one_hot'] = torch.cat((one_hot, virt_one_hot))
+        data['num_lig_atoms'] = self.max_ligand_size
+        data['lig_mask'] = torch.cat((data['lig_mask'], virt_mask))
+        data['num_virtual_atoms'] = n_virt
+
+        return data