Migrated from GitHub

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Bowen Jing, Hannes Stärk, Tommi Jaakkola, Bonnie Berger
+
+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.

data/design_inference.py

@@ -0,0 +1,173 @@
+import argparse
+import copy
+import json
+import pickle
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--sim_ckpt', type=str, default=None, required=True)
+parser.add_argument('--data_dir', type=str, default='share/4AA_data')
+parser.add_argument('--mddir', type=str, default='/data/cb/scratch/share/mdgen/4AA_sims')
+parser.add_argument('--suffix', type=str, default='')
+parser.add_argument('--pdb_id', nargs='*', default=[])
+parser.add_argument('--num_frames', type=int, default=100)
+parser.add_argument('--num_batches', type=int, default=100)
+parser.add_argument('--batch_size', type=int, default=10)
+parser.add_argument('--out_dir', type=str, default=".")
+parser.add_argument('--random_start_idx', action='store_true')
+parser.add_argument('--split', type=str, default='splits/4AA_test.csv')
+parser.add_argument('--chunk_idx', type=int, default=0)
+parser.add_argument('--n_chunks', type=int, default=1)
+args = parser.parse_args()
+import mdgen.analysis
+import os, torch, mdtraj, tqdm
+import numpy as np
+from mdgen.geometry import atom14_to_frames, atom14_to_atom37, atom37_to_torsions
+from mdgen.tensor_utils import tensor_tree_map
+
+from mdgen.residue_constants import restype_order, restype_atom37_mask
+from mdgen.wrapper import NewMDGenWrapper
+from mdgen.dataset import atom14_to_frames
+import pandas as pd
+import contextlib
+import numpy as np
+
+@contextlib.contextmanager
+def temp_seed(seed):
+    state = np.random.get_state()
+    np.random.seed(seed)
+    try:
+        yield
+    finally:
+        np.random.set_state(state)
+
+os.makedirs(args.out_dir, exist_ok=True)
+
+def get_sample(arr, seqres, start_idxs, start_state, end_state, num_frames=100):
+    start_idx = np.random.choice(start_idxs, 1).item()
+    if args.random_start_idx:
+        start_idx = np.random.randint(low=0,high=len(arr)-num_frames)
+    end_idx = start_idx + num_frames
+
+    arr = np.copy(arr[start_idx: end_idx]).astype(np.float32)
+    seqres = torch.tensor([restype_order[c] for c in seqres])
+
+    frames = atom14_to_frames(torch.from_numpy(arr))
+    atom37 = torch.from_numpy(atom14_to_atom37(arr, seqres)).float()
+    torsions, torsion_mask = atom37_to_torsions(atom37, seqres[None])
+
+    L = frames.shape[1]
+
+
+    mask = torch.ones(L)
+    return {
+        'torsions': torsions,
+        'torsion_mask': torsion_mask[0],
+        'trans': frames._trans,
+        'rots': frames._rots._rot_mats,
+        'seqres': seqres,
+        'start_idx': start_idx,
+        'end_idx': end_idx,
+        'start_state': start_state,
+        'end_state': end_state,
+        'mask': mask,  # (L,)
+    }
+
+def do(model, name, seqres):
+    print('doing', name)
+    if os.path.exists(f'{args.out_dir}/{name}_metadata.pkl'):
+        pkl_metadata = pickle.load(open(f'{args.out_dir}/{name}_metadata.pkl', 'rb'))
+        msm = pkl_metadata['msm']
+        cmsm = pkl_metadata['cmsm']
+        ref_kmeans = pkl_metadata['ref_kmeans']
+    else:
+        with temp_seed(137):
+            feats, ref = mdgen.analysis.get_featurized_traj(f'{args.mddir}/{name}/{name}', sidechains=True)
+            tica, _ = mdgen.analysis.get_tica(ref)
+            kmeans, ref_kmeans = mdgen.analysis.get_kmeans(tica.transform(ref))
+            try:
+                msm, pcca, cmsm = mdgen.analysis.get_msm(ref_kmeans, nstates=10)
+            except Exception as e:
+                print('ERROR', e, name, flush=True)
+                return
+        pickle.dump({
+            'msm': msm,
+            'cmsm': cmsm,
+            'tica': tica,
+            'pcca': pcca,
+            'kmeans': kmeans,
+            'ref_kmeans': ref_kmeans,
+        }, open(f'{args.out_dir}/{name}_metadata.pkl', 'wb'))
+
+    flux_mat = cmsm.transition_matrix * cmsm.pi[None, :]
+    np.fill_diagonal(flux_mat, 0)
+    start_state, end_state = np.unravel_index(np.argmax(flux_mat, axis=None), flux_mat.shape)
+    ref_discrete = msm.metastable_assignments[ref_kmeans]
+    
+    arr = np.lib.format.open_memmap(f'{args.data_dir}/{name}.npy', 'r')
+    if model.args.frame_interval:
+        arr = arr[::model.args.frame_interval]
+        ref_discrete = ref_discrete[::model.args.frame_interval]
+    
+    is_start = ref_discrete == start_state
+    is_end = ref_discrete == end_state
+
+    trans_indices = is_start[:-args.num_frames] * is_end[args.num_frames:]
+    start_idxs = np.where(trans_indices)[0]
+    if (trans_indices).sum() == 0:
+        print('No transition path found for ', name, 'skipping...')
+        return
+
+    
+
+    metadata = []
+    for i in tqdm.tqdm(range(args.num_batches), desc='num batch'):
+        batch_list = []
+        for _ in range(args.batch_size):
+            batch_list.append(
+                get_sample(arr, seqres, copy.deepcopy(start_idxs), start_state, end_state, num_frames=args.num_frames))
+        batch = next(iter(torch.utils.data.DataLoader(batch_list, batch_size=args.batch_size)))
+        batch = tensor_tree_map(lambda x: x.cuda(), batch)
+
+
+        print('Start tps for ', name, 'with start coords', batch['trans'][0, 0, 0], 'and with end coords', batch['trans'][0, -1, 0])
+        atom14s, aa_out = model.inference(batch)
+        for j in range(args.batch_size):
+            idx = i * args.batch_size + j
+            path = os.path.join(args.out_dir, f'{name}_{idx}.pdb')
+            atom14_to_pdb(atom14s[j].cpu().numpy(), batch['seqres'][0].cpu().numpy(), path)
+
+            traj = mdtraj.load(path)
+            traj.superpose(traj)
+            traj.save(os.path.join(args.out_dir, f'{name}_{idx}.xtc'))
+            traj[0].save(os.path.join(args.out_dir, f'{name}_{idx}.pdb'))
+            metadata.append({
+                'name': name,
+                'start_idx': batch['start_idx'][j].cpu().item(),
+                'end_idx': batch['end_idx'][j].cpu().item(),
+                'start_state': batch['start_state'][j].cpu().item(),
+                'end_state': batch['end_state'][j].cpu().item(),
+                'aa_out': aa_out[j].cpu().numpy().tolist(),  # 'aa_out': 'aa_out',
+                'path': path,
+            })
+    json.dump(metadata, open(f'{args.out_dir}/{name}_metadata.json', 'w'))
+
+
+@torch.no_grad()
+def main():
+    model = NewMDGenWrapper.load_from_checkpoint(args.sim_ckpt)
+    model.eval().to('cuda')
+    df = pd.read_csv(args.split, index_col='name')
+    names = np.array(df.index)
+
+    chunks = np.array_split(names, args.n_chunks)
+    chunk = chunks[args.chunk_idx]
+    print('#' * 20)
+    print(f'RUN NUMBER: {args.chunk_idx}, PROCESSING IDXS {args.chunk_idx * len(chunk)}-{(args.chunk_idx + 1) * len(chunk)}')
+    print('#' * 20)
+    for name in tqdm.tqdm(chunk, desc='num peptides'):
+        if args.pdb_id and name not in args.pdb_id:
+            continue
+        do(model, name, df.seqres[name])
+
+
+main()

data/mdgen/analysis.py

@@ -0,0 +1,100 @@
+import json
+import os
+
+import numpy as np
+import pyemma
+from tqdm import tqdm
+
+def get_featurizer(name, sidechains=False, cossin=True):
+    feat = pyemma.coordinates.featurizer(name+'.pdb')
+    feat.add_backbone_torsions(cossin=cossin)
+    if sidechains:
+        feat.add_sidechain_torsions(cossin=cossin)
+    return feat
+    
+def get_featurized_traj(name, sidechains=False, cossin=True):
+    feat = pyemma.coordinates.featurizer(name+'.pdb')
+    feat.add_backbone_torsions(cossin=cossin)
+    if sidechains:
+        feat.add_sidechain_torsions(cossin=cossin)
+    traj = pyemma.coordinates.load(name+'.xtc', features=feat)
+    return feat, traj
+
+def get_featurized_atlas_traj(name, sidechains=False, cossin=True):
+    feat = pyemma.coordinates.featurizer(name+'.pdb')
+    feat.add_backbone_torsions(cossin=cossin)
+    if sidechains:
+        feat.add_sidechain_torsions(cossin=cossin)
+    traj = pyemma.coordinates.load(name+'_prod_R1_fit.xtc', features=feat)
+    return feat, traj
+
+def get_tica(traj, lag=1000):
+    tica = pyemma.coordinates.tica(traj, lag=lag, kinetic_map=True)
+    # lag time 100 ps = 0.1 ns
+    return tica, tica.transform(traj)
+
+def get_kmeans(traj):
+    kmeans = pyemma.coordinates.cluster_kmeans(traj, k=100, max_iter=100, fixed_seed=137)
+    return kmeans, kmeans.transform(traj)[:,0]
+
+def get_msm(traj, lag=1000, nstates=10):
+    msm = pyemma.msm.estimate_markov_model(traj, lag=lag)
+    pcca = msm.pcca(nstates)
+    assert len(msm.metastable_assignments) == 100
+    cmsm = pyemma.msm.estimate_markov_model(msm.metastable_assignments[traj], lag=lag)
+    return msm, pcca, cmsm
+
+def discretize(traj, kmeans, msm):
+    return msm.metastable_assignments[kmeans.transform(traj)[:,0]]
+
+def load_tps_ensemble(name, directory):
+    metadata = json.load(open(os.path.join(directory, f'{name}_metadata.json'),'rb'))
+    all_feats = []
+    all_traj = []
+    for i, meta_dict in tqdm(enumerate(metadata)):
+        feats, traj = get_featurized_traj(f'{directory}/{name}_{i}', sidechains=True)
+        all_feats.append(feats)
+        all_traj.append(traj)
+    return all_feats, all_traj
+
+
+def sample_tp(trans, start_state, end_state, traj_len, n_samples):
+    s_1 = start_state
+    s_N = end_state
+    N = traj_len
+
+    s_t = np.ones(n_samples, dtype=int) * s_1
+    states = [s_t]
+    for t in range(1, N - 1):
+        numerator = np.linalg.matrix_power(trans, N - t - 1)[:, s_N] * trans[s_t, :]
+        probs = numerator / np.linalg.matrix_power(trans, N - t)[s_t, s_N][:, None]
+        s_t = np.zeros(n_samples, dtype=int)
+        for n in range(n_samples):
+            s_t[n] = np.random.choice(np.arange(len(trans)), 1, p=probs[n])
+        states.append(s_t)
+    states.append(np.ones(n_samples, dtype=int) * s_N)
+    return np.stack(states, axis=1)
+
+
+def get_tp_likelihood(tp, trans):
+    N = tp.shape[1]
+    n_samples = tp.shape[0]
+    s_N = tp[0, -1]
+    trans_probs = []
+    for i in range(N - 1):
+        t = i + 1
+        s_t = tp[:, i]
+        numerator = np.linalg.matrix_power(trans, N - t - 1)[:, s_N] * trans[s_t, :]
+        probs = numerator / np.linalg.matrix_power(trans, N - t)[s_t, s_N][:, None]
+
+        s_tp1 = tp[:, i + 1]
+        trans_prob = probs[np.arange(n_samples), s_tp1]
+        trans_probs.append(trans_prob)
+    probs = np.stack(trans_probs, axis=1)
+    probs[np.isnan(probs)] = 0
+    return probs
+
+
+def get_state_probs(tp, num_states=10):
+    stationary = np.bincount(tp.reshape(-1), minlength=num_states)
+    return stationary / stationary.sum()

data/mdgen/dataset.py

@@ -0,0 +1,101 @@
+import torch
+from .rigid_utils import Rigid
+from .residue_constants import restype_order
+import numpy as np
+import pandas as pd
+from .geometry import atom37_to_torsions, atom14_to_atom37, atom14_to_frames
+       
+class MDGenDataset(torch.utils.data.Dataset):
+    def __init__(self, args, split, repeat=1):
+        super().__init__()
+        self.df = pd.read_csv(split, index_col='name')
+        self.args = args
+        self.repeat = repeat
+    def __len__(self):
+        if self.args.overfit_peptide:
+            return 1000
+        return self.repeat * len(self.df)
+
+    def __getitem__(self, idx):
+        idx = idx % len(self.df)
+        if self.args.overfit:
+            idx = 0
+
+        if self.args.overfit_peptide is None:
+            name = self.df.index[idx]
+            seqres = self.df.seqres[name]
+        else:
+            name = self.args.overfit_peptide
+            seqres = name
+
+        if self.args.atlas:
+            i = np.random.randint(1, 4)
+            full_name = f"{name}_R{i}"
+        else:
+            full_name = name
+        arr = np.lib.format.open_memmap(f'{self.args.data_dir}/{full_name}{self.args.suffix}.npy', 'r')
+        if self.args.frame_interval:
+            arr = arr[::self.args.frame_interval]
+        
+        frame_start = np.random.choice(np.arange(arr.shape[0] - self.args.num_frames))
+        if self.args.overfit_frame:
+            frame_start = 0
+        end = frame_start + self.args.num_frames
+        # arr = np.copy(arr[frame_start:end]) * 10 # convert to angstroms
+        arr = np.copy(arr[frame_start:end]).astype(np.float32) # / 10.0 # convert to nm
+        if self.args.copy_frames:
+            arr[1:] = arr[0]
+
+        # arr should be in ANGSTROMS
+        frames = atom14_to_frames(torch.from_numpy(arr))
+        seqres = np.array([restype_order[c] for c in seqres])
+        aatype = torch.from_numpy(seqres)[None].expand(self.args.num_frames, -1)
+        atom37 = torch.from_numpy(atom14_to_atom37(arr, aatype)).float()
+        
+        L = frames.shape[1]
+        mask = np.ones(L, dtype=np.float32)
+        
+        if self.args.no_frames:
+            return {
+                'name': full_name,
+                'frame_start': frame_start,
+                'atom37': atom37,
+                'seqres': seqres,
+                'mask': restype_atom37_mask[seqres], # (L,)
+            }
+        torsions, torsion_mask = atom37_to_torsions(atom37, aatype)
+        
+        torsion_mask = torsion_mask[0]
+        
+        if self.args.atlas:
+            if L > self.args.crop:
+                start = np.random.randint(0, L - self.args.crop + 1)
+                torsions = torsions[:,start:start+self.args.crop]
+                frames = frames[:,start:start+self.args.crop]
+                seqres = seqres[start:start+self.args.crop]
+                mask = mask[start:start+self.args.crop]
+                torsion_mask = torsion_mask[start:start+self.args.crop]
+                
+            
+            elif L < self.args.crop:
+                pad = self.args.crop - L
+                frames = Rigid.cat([
+                    frames, 
+                    Rigid.identity((self.args.num_frames, pad), requires_grad=False, fmt='rot_mat')
+                ], 1)
+                mask = np.concatenate([mask, np.zeros(pad, dtype=np.float32)])
+                seqres = np.concatenate([seqres, np.zeros(pad, dtype=int)])
+                torsions = torch.cat([torsions, torch.zeros((torsions.shape[0], pad, 7, 2), dtype=torch.float32)], 1)
+                torsion_mask = torch.cat([torsion_mask, torch.zeros((pad, 7), dtype=torch.float32)])
+
+        return {
+            'name': full_name,
+            'frame_start': frame_start,
+            'torsions': torsions,
+            'torsion_mask': torsion_mask,
+            'trans': frames._trans,
+            'rots': frames._rots._rot_mats,
+            'seqres': seqres,
+            'mask': mask, # (L,)
+        }
+

data/mdgen/ema.py

@@ -0,0 +1,71 @@
+# https://github.com/aqlaboratory/openfold/blob/main/openfold/utils/exponential_moving_average.py
+from collections import OrderedDict
+import torch
+import torch.nn as nn
+
+from .tensor_utils import tensor_tree_map
+
+
+class ExponentialMovingAverage:
+    """
+    Maintains moving averages of parameters with exponential decay
+
+    At each step, the stored copy `copy` of each parameter `param` is
+    updated as follows:
+
+        `copy = decay * copy + (1 - decay) * param`
+
+    where `decay` is an attribute of the ExponentialMovingAverage object.
+    """
+
+    def __init__(self, model: nn.Module, decay: float):
+        """
+        Args:
+            model:
+                A torch.nn.Module whose parameters are to be tracked
+            decay:
+                A value (usually close to 1.) by which updates are
+                weighted as part of the above formula
+        """
+        super(ExponentialMovingAverage, self).__init__()
+
+        clone_param = lambda t: t.clone().detach()
+        self.params = tensor_tree_map(clone_param, model.state_dict())
+        self.decay = decay
+        self.device = next(model.parameters()).device
+
+    def to(self, device):
+        self.params = tensor_tree_map(lambda t: t.to(device), self.params)
+        self.device = device
+
+    def _update_state_dict_(self, update, state_dict):
+        with torch.no_grad():
+            for k, v in update.items():
+                stored = state_dict[k]
+                if not isinstance(v, torch.Tensor):
+                    self._update_state_dict_(v, stored)
+                else:
+                    diff = stored - v
+                    diff *= 1 - self.decay
+                    stored -= diff
+
+    def update(self, model: torch.nn.Module) -> None:
+        """
+        Updates the stored parameters using the state dict of the provided
+        module. The module should have the same structure as that used to
+        initialize the ExponentialMovingAverage object.
+        """
+        self._update_state_dict_(model.state_dict(), self.params)
+
+    def load_state_dict(self, state_dict: OrderedDict) -> None:
+        for k in state_dict["params"].keys():
+            self.params[k] = state_dict["params"][k].clone()
+        self.decay = state_dict["decay"]
+
+    def state_dict(self) -> OrderedDict:
+        return OrderedDict(
+            {
+                "params": self.params,
+                "decay": self.decay,
+            }
+        )

data/mdgen/geometry.py

@@ -0,0 +1,359 @@
+import torch
+import numpy as np
+
+from .rigid_utils import Rigid, Rotation
+from . import residue_constants as rc
+from .tensor_utils import batched_gather
+
+
+def atom14_to_atom37(atom14: np.ndarray, aatype, atom14_mask=None):
+    atom37 = batched_gather(
+        atom14,
+        rc.RESTYPE_ATOM37_TO_ATOM14[aatype],
+        dim=-2,
+        no_batch_dims=len(atom14.shape[:-2]),
+    )
+    atom37 *= rc.RESTYPE_ATOM37_MASK[aatype, :, None]
+    if atom14_mask is not None:
+        atom37_mask = batched_gather(
+            atom14_mask,
+            rc.RESTYPE_ATOM37_TO_ATOM14[aatype],
+            dim=-1,
+            no_batch_dims=len(atom14.shape[:-2]),
+        )
+        atom37_mask *= rc.RESTYPE_ATOM37_MASK[aatype]
+        return atom37, atom37_mask
+    else:
+        return atom37
+
+
+def atom37_to_atom14(atom37: np.ndarray, aatype, atom37_mask=None):
+    atom14 = batched_gather(
+        atom37,
+        rc.RESTYPE_ATOM14_TO_ATOM37[aatype],
+        dim=-2,
+        no_batch_dims=len(atom37.shape[:-2]),
+    )
+    atom14 *= rc.RESTYPE_ATOM14_MASK[aatype, :, None]
+    if atom37_mask is not None:
+        atom14_mask = batched_gather(
+            atom37_mask,
+            rc.RESTYPE_ATOM14_TO_ATOM37[aatype],
+            dim=-1,
+            no_batch_dims=len(atom37.shape[:-2]),
+        )
+        atom14_mask *= rc.RESTYPE_ATOM14_MASK[aatype]
+        return atom14, atom14_mask
+    else:
+        return atom14
+
+
+
+def frames_torsions_to_atom37(
+    frames: Rigid,
+    torsions: torch.Tensor,
+    aatype: torch.Tensor,
+):
+    atom14 = frames_torsions_to_atom14(frames, torsions, aatype)
+    return atom14_to_atom37(atom14, aatype)
+
+
+def frames_torsions_to_atom14(
+    frames: Rigid, torsions: torch.Tensor, aatype: torch.Tensor
+):
+    if type(torsions) is np.ndarray:
+        torsions = torch.from_numpy(torsions)
+    if type(aatype) is np.ndarray:
+        aatype = torch.from_numpy(aatype)
+    default_frames = torch.from_numpy(rc.restype_rigid_group_default_frame).to(
+        aatype.device
+    )
+    lit_positions = torch.from_numpy(rc.restype_atom14_rigid_group_positions).to(
+        aatype.device
+    )
+    group_idx = torch.from_numpy(rc.restype_atom14_to_rigid_group).to(aatype.device)
+    atom_mask = torch.from_numpy(rc.restype_atom14_mask).to(aatype.device)
+    frames_out = torsion_angles_to_frames(frames, torsions, aatype, default_frames)
+    return frames_and_literature_positions_to_atom14_pos(
+        frames_out, aatype, default_frames, group_idx, atom_mask, lit_positions
+    )
+
+
+def atom37_to_torsions(all_atom_positions, aatype, all_atom_mask=None):
+
+    if type(all_atom_positions) is np.ndarray:
+        all_atom_positions = torch.from_numpy(all_atom_positions)
+    if type(aatype) is np.ndarray:
+        aatype = torch.from_numpy(aatype)
+    if all_atom_mask is None:
+        all_atom_mask = torch.from_numpy(rc.RESTYPE_ATOM37_MASK[aatype]).to(
+            aatype.device
+        )
+    if type(all_atom_mask) is np.ndarray:
+        all_atom_mask = torch.from_numpy(all_atom_mask)
+
+    pad = all_atom_positions.new_zeros([*all_atom_positions.shape[:-3], 1, 37, 3])
+    prev_all_atom_positions = torch.cat(
+        [pad, all_atom_positions[..., :-1, :, :]], dim=-3
+    )
+
+    pad = all_atom_mask.new_zeros([*all_atom_mask.shape[:-2], 1, 37])
+    prev_all_atom_mask = torch.cat([pad, all_atom_mask[..., :-1, :]], dim=-2)
+
+    pre_omega_atom_pos = torch.cat(
+        [prev_all_atom_positions[..., 1:3, :], all_atom_positions[..., :2, :]],
+        dim=-2,
+    )
+    phi_atom_pos = torch.cat(
+        [prev_all_atom_positions[..., 2:3, :], all_atom_positions[..., :3, :]],
+        dim=-2,
+    )
+    psi_atom_pos = torch.cat(
+        [all_atom_positions[..., :3, :], all_atom_positions[..., 4:5, :]],
+        dim=-2,
+    )
+
+    pre_omega_mask = torch.prod(prev_all_atom_mask[..., 1:3], dim=-1) * torch.prod(
+        all_atom_mask[..., :2], dim=-1
+    )
+    phi_mask = prev_all_atom_mask[..., 2] * torch.prod(
+        all_atom_mask[..., :3], dim=-1, dtype=all_atom_mask.dtype
+    )
+    psi_mask = (
+        torch.prod(all_atom_mask[..., :3], dim=-1, dtype=all_atom_mask.dtype)
+        * all_atom_mask[..., 4]
+    )
+
+    chi_atom_indices = torch.as_tensor(get_chi_atom_indices(), device=aatype.device)
+
+    atom_indices = chi_atom_indices[..., aatype, :, :]
+    chis_atom_pos = batched_gather(
+        all_atom_positions, atom_indices, -2, len(atom_indices.shape[:-2])
+    )
+
+    chi_angles_mask = list(rc.chi_angles_mask)
+    chi_angles_mask.append([0.0, 0.0, 0.0, 0.0])
+    chi_angles_mask = all_atom_mask.new_tensor(chi_angles_mask)
+
+    chis_mask = chi_angles_mask[aatype, :]
+
+    chi_angle_atoms_mask = batched_gather(
+        all_atom_mask,
+        atom_indices,
+        dim=-1,
+        no_batch_dims=len(atom_indices.shape[:-2]),
+    )
+    chi_angle_atoms_mask = torch.prod(
+        chi_angle_atoms_mask, dim=-1, dtype=chi_angle_atoms_mask.dtype
+    )
+    chis_mask = chis_mask * chi_angle_atoms_mask
+
+    torsions_atom_pos = torch.cat(
+        [
+            pre_omega_atom_pos[..., None, :, :],
+            phi_atom_pos[..., None, :, :],
+            psi_atom_pos[..., None, :, :],
+            chis_atom_pos,
+        ],
+        dim=-3,
+    )
+
+    torsion_angles_mask = torch.cat(
+        [
+            pre_omega_mask[..., None],
+            phi_mask[..., None],
+            psi_mask[..., None],
+            chis_mask,
+        ],
+        dim=-1,
+    )
+
+    torsion_frames = Rigid.from_3_points(
+        torsions_atom_pos[..., 1, :],
+        torsions_atom_pos[..., 2, :],
+        torsions_atom_pos[..., 0, :],
+        eps=1e-8,
+    )
+
+    fourth_atom_rel_pos = torsion_frames.invert().apply(torsions_atom_pos[..., 3, :])
+
+    torsion_angles_sin_cos = torch.stack(
+        [fourth_atom_rel_pos[..., 2], fourth_atom_rel_pos[..., 1]], dim=-1
+    )
+
+    denom = torch.sqrt(
+        torch.sum(
+            torch.square(torsion_angles_sin_cos),
+            dim=-1,
+            dtype=torsion_angles_sin_cos.dtype,
+            keepdims=True,
+        )
+        + 1e-8
+    )
+    torsion_angles_sin_cos = torsion_angles_sin_cos / denom
+
+    torsion_angles_sin_cos = (
+        torsion_angles_sin_cos
+        * all_atom_mask.new_tensor(
+            [1.0, 1.0, -1.0, 1.0, 1.0, 1.0, 1.0],
+        )[((None,) * len(torsion_angles_sin_cos.shape[:-2])) + (slice(None), None)]
+    )
+
+    return torsion_angles_sin_cos, torsion_angles_mask
+
+
+
+def prot_to_frames(ca_coords, c_coords, n_coords):
+    prot_frames = Rigid.from_3_points(
+        torch.from_numpy(c_coords),
+        torch.from_numpy(ca_coords),
+        torch.from_numpy(n_coords),
+    )
+    rots = torch.eye(3)
+    rots[0, 0] = -1
+    rots[2, 2] = -1
+    rots = Rotation(rot_mats=rots)
+    return prot_frames.compose(Rigid(rots, None))
+
+def atom14_to_frames(atom14):
+    n_coords = atom14[:,:,rc.atom_order['N']]
+    ca_coords = atom14[:,:,rc.atom_order['CA']]
+    c_coords = atom14[:,:,rc.atom_order['C']]
+    prot_frames = Rigid.from_3_points(
+        c_coords,
+        ca_coords,
+        n_coords,
+    )
+    rots = torch.eye(3, device=atom14.device)[None,None].repeat(atom14.shape[0],atom14.shape[1], 1, 1)
+    rots[:,:, 0, 0] = -1
+    rots[:,:, 2, 2] = -1
+    rots = Rotation(rot_mats=rots)
+    return prot_frames.compose(Rigid(rots, None))
+    
+
+
+
+def frames_and_literature_positions_to_atom14_pos(
+    r: Rigid,
+    aatype: torch.Tensor,
+    default_frames,
+    group_idx,
+    atom_mask,
+    lit_positions,
+):
+    # [*, N, 14, 4, 4]
+    default_4x4 = default_frames[aatype, ...]
+
+    # [*, N, 14]
+    group_mask = group_idx[aatype, ...]
+
+    # [*, N, 14, 8]
+    group_mask = torch.nn.functional.one_hot(
+        group_mask,
+        num_classes=default_frames.shape[-3],
+    )
+
+    # [*, N, 14, 8]
+    t_atoms_to_global = r[..., None, :] * group_mask
+
+    # [*, N, 14]
+    t_atoms_to_global = t_atoms_to_global.map_tensor_fn(lambda x: torch.sum(x, dim=-1))
+
+    # [*, N, 14, 1]
+    atom_mask = atom_mask[aatype, ...].unsqueeze(-1)
+
+    # [*, N, 14, 3]
+    lit_positions = lit_positions[aatype, ...]
+    pred_positions = t_atoms_to_global.apply(lit_positions)
+    pred_positions = pred_positions * atom_mask
+
+    return pred_positions
+
+
+def torsion_angles_to_frames(
+    r: Rigid,
+    alpha: torch.Tensor,
+    aatype: torch.Tensor,
+    rrgdf: torch.Tensor,
+):
+    # [*, N, 8, 4, 4]
+    default_4x4 = rrgdf[aatype, ...]
+
+    # [*, N, 8] transformations, i.e.
+    #   One [*, N, 8, 3, 3] rotation matrix and
+    #   One [*, N, 8, 3]    translation matrix
+    default_r = r.from_tensor_4x4(default_4x4)
+
+    bb_rot = alpha.new_zeros((*((1,) * len(alpha.shape[:-1])), 2))
+    bb_rot[..., 1] = 1
+
+    # [*, N, 8, 2]
+    alpha = torch.cat([bb_rot.expand(*alpha.shape[:-2], -1, -1), alpha], dim=-2)
+
+    # [*, N, 8, 3, 3]
+    # Produces rotation matrices of the form:
+    # [
+    #   [1, 0  , 0  ],
+    #   [0, a_2,-a_1],
+    #   [0, a_1, a_2]
+    # ]
+    # This follows the original code rather than the supplement, which uses
+    # different indices.
+
+    all_rots = alpha.new_zeros(default_r.get_rots().get_rot_mats().shape)
+    all_rots[..., 0, 0] = 1
+    all_rots[..., 1, 1] = alpha[..., 1]
+    all_rots[..., 1, 2] = -alpha[..., 0]
+    all_rots[..., 2, 1:] = alpha
+
+    all_rots = Rigid(Rotation(rot_mats=all_rots), None)
+
+    all_frames = default_r.compose(all_rots)
+
+    chi2_frame_to_frame = all_frames[..., 5]
+    chi3_frame_to_frame = all_frames[..., 6]
+    chi4_frame_to_frame = all_frames[..., 7]
+
+    chi1_frame_to_bb = all_frames[..., 4]
+    chi2_frame_to_bb = chi1_frame_to_bb.compose(chi2_frame_to_frame)
+    chi3_frame_to_bb = chi2_frame_to_bb.compose(chi3_frame_to_frame)
+    chi4_frame_to_bb = chi3_frame_to_bb.compose(chi4_frame_to_frame)
+
+    all_frames_to_bb = Rigid.cat(
+        [
+            all_frames[..., :5],
+            chi2_frame_to_bb.unsqueeze(-1),
+            chi3_frame_to_bb.unsqueeze(-1),
+            chi4_frame_to_bb.unsqueeze(-1),
+        ],
+        dim=-1,
+    )
+
+    all_frames_to_global = r[..., None].compose(all_frames_to_bb)
+
+    return all_frames_to_global
+
+
+def get_chi_atom_indices():
+    """Returns atom indices needed to compute chi angles for all residue types.
+
+    Returns:
+      A tensor of shape [residue_types=21, chis=4, atoms=4]. The residue types are
+      in the order specified in rc.restypes + unknown residue type
+      at the end. For chi angles which are not defined on the residue, the
+      positions indices are by default set to 0.
+    """
+    chi_atom_indices = []
+    for residue_name in rc.restypes:
+        residue_name = rc.restype_1to3[residue_name]
+        residue_chi_angles = rc.chi_angles_atoms[residue_name]
+        atom_indices = []
+        for chi_angle in residue_chi_angles:
+            atom_indices.append([rc.atom_order[atom] for atom in chi_angle])
+        for _ in range(4 - len(atom_indices)):
+            atom_indices.append([0, 0, 0, 0])  # For chi angles not defined on the AA.
+        chi_atom_indices.append(atom_indices)
+
+    chi_atom_indices.append([[0, 0, 0, 0]] * 4)  # For UNKNOWN residue.
+
+    return chi_atom_indices

data/mdgen/logger.py

@@ -0,0 +1,34 @@
+import logging, socket, os
+
+model_dir = os.environ.get("MODEL_DIR", "./workdir/default")
+
+class Rank(logging.Filter):
+    def filter(self, record):
+        record.global_rank = os.environ.get("GLOBAL_RANK", 0)
+        record.local_rank = os.environ.get("LOCAL_RANK", 0)
+        return True
+
+
+def get_logger(name):
+    logger = logging.Logger(name)
+    # logger.addFilter(Rank())
+    level = {"crititical": 50, "error": 40, "warning": 30, "info": 20, "debug": 10}[
+        os.environ.get("LOGGER_LEVEL", "info")
+    ]
+    logger.setLevel(level)
+
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.INFO)
+    os.makedirs(model_dir, exist_ok=True)
+    fh = logging.FileHandler(os.path.join(model_dir, "log.out"))
+    fh.setLevel(logging.DEBUG)
+    # formatter = logging.Formatter(f'%(asctime)s [{socket.gethostname()}:%(process)d:%(global_rank)s:%(local_rank)s]
+    # [%(levelname)s] %(message)s') #  (%(name)s)
+    formatter = logging.Formatter(
+        f"%(asctime)s [{socket.gethostname()}:%(process)d] [%(levelname)s] %(message)s"
+    )
+    ch.setFormatter(formatter)
+    fh.setFormatter(formatter)
+    logger.addHandler(ch)
+    logger.addHandler(fh)
+    return logger

data/mdgen/model/ipa.py

@@ -0,0 +1,257 @@
+# Copyright 2021 AlQuraishi Laboratory
+# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .primitives import Linear, ipa_point_weights_init_
+
+"""
+from openfold.utils.feats import (
+    frames_and_literature_positions_to_atom14_pos,
+    torsion_angles_to_frames,
+)
+"""
+from ..rigid_utils import Rotation, Rigid
+from ..tensor_utils import (
+    permute_final_dims,
+    flatten_final_dims,
+)
+
+
+class InvariantPointAttention(nn.Module):
+    def __init__(self, c_s, c_z, c_hidden, no_heads, no_qk_points, no_v_points, inf=1e5, eps=1e-8, dropout=0.0):
+        """
+        Args:
+            c_s:
+                Single representation channel dimension
+            c_z:
+                Pair representation channel dimension
+            c_hidden:
+                Hidden channel dimension
+            no_heads:
+                Number of attention heads
+            no_qk_points:
+                Number of query/key points to generate
+            no_v_points:
+                Number of value points to generate
+        """
+        super(InvariantPointAttention, self).__init__()
+
+        self.c_s = c_s
+        self.c_z = c_z
+        self.c_hidden = c_hidden
+        self.no_heads = no_heads
+        self.no_qk_points = no_qk_points
+        self.no_v_points = no_v_points
+        self.inf = inf
+        self.eps = eps
+        self.dropout = dropout
+        # These linear layers differ from their specifications in the
+        # supplement. There, they lack bias and use Glorot initialization.
+        # Here as in the official source, they have bias and use the default
+        # Lecun initialization.
+        hc = self.c_hidden * self.no_heads
+        self.linear_q = Linear(self.c_s, hc)
+        self.linear_kv = Linear(self.c_s, 2 * hc)
+
+        hpq = self.no_heads * self.no_qk_points * 3
+        self.linear_q_points = Linear(self.c_s, hpq)
+
+        hpkv = self.no_heads * (self.no_qk_points + self.no_v_points) * 3
+        self.linear_kv_points = Linear(self.c_s, hpkv)
+
+        hpv = self.no_heads * self.no_v_points * 3
+
+        if self.c_z > 0:
+            self.linear_b = Linear(self.c_z, self.no_heads)
+
+        self.head_weights = nn.Parameter(torch.zeros((no_heads)))
+        ipa_point_weights_init_(self.head_weights)
+
+        concat_out_dim = self.no_heads * (
+            self.c_z + self.c_hidden + self.no_v_points * 4
+        )
+        self.linear_out = Linear(concat_out_dim, self.c_s, init="final")
+
+        self.softmax = nn.Softmax(dim=-1)
+        self.softplus = nn.Softplus()
+
+    def forward(self, s, r, z=None, frame_mask=None, attn_mask=None):
+        """
+        Args:
+            s:
+                [*, N_res, C_s] single representation
+            z:
+                [*, N_res, N_res, C_z] pair representation
+            r:
+                [*, N_res] transformation object
+            mask:
+                [*, N_res] mask
+        Returns:
+            [*, N_res, C_s] single representation update
+        """
+        
+        z = [z]
+
+        #######################################
+        # Generate scalar and point activations
+        #######################################
+        # [*, N_res, H * C_hidden]
+        q = self.linear_q(s)
+        kv = self.linear_kv(s)
+
+        # [*, N_res, H, C_hidden]
+        q = q.view(q.shape[:-1] + (self.no_heads, -1))
+
+        # [*, N_res, H, 2 * C_hidden]
+        kv = kv.view(kv.shape[:-1] + (self.no_heads, -1))
+
+        # [*, N_res, H, C_hidden]
+        k, v = torch.split(kv, self.c_hidden, dim=-1)
+
+        # [*, N_res, H * P_q * 3]
+        q_pts = self.linear_q_points(s)
+
+        # This is kind of clunky, but it's how the original does it
+        # [*, N_res, H * P_q, 3]
+        q_pts = torch.split(q_pts, q_pts.shape[-1] // 3, dim=-1)
+        q_pts = torch.stack(q_pts, dim=-1)
+        q_pts = r[..., None].apply(q_pts)
+
+        # [*, N_res, H, P_q, 3]
+        q_pts = q_pts.view(q_pts.shape[:-2] + (self.no_heads, self.no_qk_points, 3))
+
+        # [*, N_res, H * (P_q + P_v) * 3]
+        kv_pts = self.linear_kv_points(s)
+
+        # [*, N_res, H * (P_q + P_v), 3]
+        kv_pts = torch.split(kv_pts, kv_pts.shape[-1] // 3, dim=-1)
+        kv_pts = torch.stack(kv_pts, dim=-1)
+        kv_pts = r[..., None].apply(kv_pts)
+
+        # [*, N_res, H, (P_q + P_v), 3]
+        kv_pts = kv_pts.view(kv_pts.shape[:-2] + (self.no_heads, -1, 3))
+
+        # [*, N_res, H, P_q/P_v, 3]
+        k_pts, v_pts = torch.split(
+            kv_pts, [self.no_qk_points, self.no_v_points], dim=-2
+        )
+
+        ##########################
+        # Compute attention scores
+        ##########################
+        # [*, N_res, N_res, H]
+        if self.c_z > 0:
+            b = self.linear_b(z[0])
+
+        # [*, H, N_res, N_res]
+        a = torch.matmul(
+            permute_final_dims(q, (1, 0, 2)),  # [*, H, N_res, C_hidden]
+            permute_final_dims(k, (1, 2, 0)),  # [*, H, C_hidden, N_res]
+        )
+
+        a *= math.sqrt(1.0 / (3 * self.c_hidden))
+        if self.c_z:
+            a += math.sqrt(1.0 / 3) * permute_final_dims(b, (2, 0, 1))
+
+        # [*, N_res, N_res, H, P_q, 3]
+        pt_att = q_pts.unsqueeze(-4) - k_pts.unsqueeze(-5)
+        pt_att = pt_att**2
+
+        # [*, N_res, N_res, H, P_q]
+        pt_att = sum(torch.unbind(pt_att, dim=-1))
+        head_weights = self.softplus(self.head_weights).view(
+            *((1,) * len(pt_att.shape[:-2]) + (-1, 1))
+        )
+        head_weights = head_weights * math.sqrt(
+            1.0 / (3 * (self.no_qk_points * 9.0 / 2))
+        )
+        pt_att = pt_att * head_weights
+
+        # [*, N_res, N_res, H]
+        pt_att = torch.sum(pt_att, dim=-1) * (-0.5)
+        # [*, N_res, N_res]
+        
+        if frame_mask is not None:
+            square_mask = frame_mask.unsqueeze(-1) * frame_mask.unsqueeze(-2)
+            square_mask = self.inf * (square_mask - 1)
+
+        # [*, H, N_res, N_res]
+        pt_att = permute_final_dims(pt_att, (2, 0, 1))
+
+  
+        a = a + pt_att
+        if frame_mask is not None:
+            a = a + square_mask.unsqueeze(-3)
+        if attn_mask is not None:
+            attn_mask = self.inf * (attn_mask - 1)
+            a = a + attn_mask
+
+        a = self.softmax(a)
+        a = F.dropout(a, p=self.dropout, training=self.training)
+        ################
+        # Compute output
+        ################
+        # [*, N_res, H, C_hidden]
+        o = torch.matmul(a, v.transpose(-2, -3).to(dtype=a.dtype)).transpose(-2, -3)
+
+        # [*, N_res, H * C_hidden]
+        o = flatten_final_dims(o, 2)
+
+        # [*, H, 3, N_res, P_v]
+   
+        o_pt = torch.sum(
+            (
+                a[..., None, :, :, None]
+                * permute_final_dims(v_pts, (1, 3, 0, 2))[..., None, :, :]
+            ),
+            dim=-2,
+        )
+
+        # [*, N_res, H, P_v, 3]
+        o_pt = permute_final_dims(o_pt, (2, 0, 3, 1))
+        o_pt = r[..., None, None].invert_apply(o_pt)
+
+        # [*, N_res, H * P_v]
+        o_pt_norm = flatten_final_dims(
+            torch.sqrt(torch.sum(o_pt**2, dim=-1) + self.eps), 2
+        )
+
+        # [*, N_res, H * P_v, 3]
+        o_pt = o_pt.reshape(*o_pt.shape[:-3], -1, 3)
+
+        # [*, N_res, H, C_z]
+        if self.c_z > 0:
+            o_pair = torch.matmul(a.transpose(-2, -3), z[0].to(dtype=a.dtype))
+
+            # [*, N_res, H * C_z]
+            o_pair = flatten_final_dims(o_pair, 2)
+
+            # [*, N_res, C_s]
+            s = self.linear_out(
+                torch.cat(
+                    (o, *torch.unbind(o_pt, dim=-1), o_pt_norm, o_pair), dim=-1
+                ).to(dtype=z[0].dtype)
+            )
+        else:
+            s = self.linear_out(
+                torch.cat((o, *torch.unbind(o_pt, dim=-1), o_pt_norm), dim=-1).to(
+                    dtype=s.dtype
+                )
+            )
+        return s
+
+

data/mdgen/model/latent_model.py

@@ -0,0 +1,483 @@
+import torch, tqdm, math
+from torch.utils.checkpoint import checkpoint
+
+from .standalone_hyena import HyenaOperator
+from ..transport.transport import t_to_alpha
+from .mha import MultiheadAttention
+import numpy as np
+import torch.nn as nn
+from .layers import GaussianFourierProjection, TimestepEmbedder, FinalLayer
+from .layers import gelu, modulate
+from .ipa import InvariantPointAttention
+from ..utils import DirichletConditionalFlow, simplex_proj, get_offsets
+
+
+def grad_checkpoint(func, args, checkpointing=False):
+    if checkpointing:
+        return checkpoint(func, *args, use_reentrant=False)
+    else:
+        return func(*args)
+
+
+def get_1d_sincos_pos_embed_from_grid(embed_dim, pos):
+    """
+    embed_dim: output dimension for each position
+    pos: a list of positions to be encoded: size (M,)
+    out: (M, D)
+    """
+    assert embed_dim % 2 == 0
+    omega = np.arange(embed_dim // 2, dtype=np.float64)
+    omega /= embed_dim / 2.
+    omega = 1. / 10000 ** omega  # (D/2,)
+
+    pos = pos.reshape(-1)  # (M,)
+    out = np.einsum('m,d->md', pos, omega)  # (M, D/2), outer product
+
+    emb_sin = np.sin(out)  # (M, D/2)
+    emb_cos = np.cos(out)  # (M, D/2)
+
+    emb = np.concatenate([emb_sin, emb_cos], axis=1)  # (M, D)
+    return emb
+
+
+class LatentMDGenModel(nn.Module):
+    def __init__(self, args, latent_dim):
+        super().__init__()
+        self.args = args
+        if self.args.design:
+            assert self.args.prepend_ipa
+
+        self.latent_to_emb = nn.Linear(latent_dim, args.embed_dim)
+        if self.args.tps_condition or self.args.inpainting or self.args.dynamic_mpnn:
+            self.latent_to_emb_f = nn.Linear(7, args.embed_dim)
+            self.latent_to_emb_r = nn.Linear(7, args.embed_dim)
+
+        cond_dim = latent_dim
+        if self.args.design: cond_dim -= 20
+        self.cond_to_emb = nn.Linear(cond_dim, args.embed_dim)
+        self.mask_to_emb = nn.Embedding(2, args.embed_dim)
+        if self.args.design:
+            self.x_d_to_emb = nn.Linear(20, args.embed_dim)
+
+        ipa_args = {
+            'c_s': args.embed_dim,
+            'c_z': 0,
+            'c_hidden': args.ipa_head_dim,
+            'no_heads': args.ipa_heads,
+            'no_qk_points': args.ipa_qk,
+            'no_v_points': args.ipa_v,
+            'dropout': args.dropout,
+        }
+
+        if args.prepend_ipa:
+            if not self.args.no_aa_emb:
+                self.aatype_to_emb = nn.Embedding(21, args.embed_dim)
+            self.ipa_layers = nn.ModuleList(
+                [
+                    IPALayer(
+                        embed_dim=args.embed_dim,
+                        ffn_embed_dim=4 * args.embed_dim,
+                        mha_heads=args.mha_heads,
+                        dropout=args.dropout,
+                        use_rotary_embeddings=not args.no_rope,
+                        ipa_args=ipa_args
+                    )
+                    for _ in range(args.num_layers)
+                ]
+            )
+
+        self.layers = nn.ModuleList(
+            [
+                LatentMDGenLayer(
+                    embed_dim=args.embed_dim,
+                    ffn_embed_dim=4 * args.embed_dim,
+                    mha_heads=args.mha_heads,
+                    dropout=args.dropout,
+                    hyena=args.hyena,
+                    num_frames=args.num_frames,
+                    use_rotary_embeddings=not args.no_rope,
+                    use_time_attention=True,
+                    ipa_args=ipa_args if args.interleave_ipa else None,
+                )
+                for _ in range(args.num_layers)
+            ]
+        )
+
+        if not (self.args.dynamic_mpnn or self.args.mpnn):
+            self.emb_to_latent = FinalLayer(args.embed_dim, latent_dim)
+        if args.design:
+            self.fc1 = nn.Linear(args.embed_dim, args.embed_dim)
+            self.fc2 = nn.Linear(args.embed_dim, args.embed_dim)
+            self.fc3 = nn.Linear(args.embed_dim, args.embed_dim)
+            self.emb_to_logits = nn.Linear(args.embed_dim, 20)
+
+        self.t_embedder = TimestepEmbedder(args.embed_dim)
+        if args.abs_pos_emb:
+            self.register_buffer('pos_embed',
+                                 nn.Parameter(torch.zeros(1, args.crop, args.embed_dim), requires_grad=False))
+
+        if args.abs_time_emb:
+            self.register_buffer('time_embed',
+                                 nn.Parameter(torch.zeros(1, args.num_frames, args.embed_dim), requires_grad=False))
+
+        self.args = args
+        if self.args.design:
+            self.condflow = DirichletConditionalFlow(K=20, alpha_spacing=0.001,
+                                                     alpha_max=args.alpha_max)
+
+        self.initialize_weights()
+
+    def initialize_weights(self):
+        # Initialize transformer layers:
+        def _basic_init(module):
+            if isinstance(module, nn.Linear):
+                torch.nn.init.xavier_uniform_(module.weight)
+                if module.bias is not None:
+                    nn.init.constant_(module.bias, 0)
+
+        self.apply(_basic_init)
+
+        if self.args.prepend_ipa:
+            for block in self.ipa_layers:
+                nn.init.constant_(block.ipa.linear_out.weight, 0)
+                nn.init.constant_(block.ipa.linear_out.bias, 0)
+
+        if self.args.interleave_ipa:
+            for block in self.layers:
+                nn.init.constant_(block.ipa.linear_out.weight, 0)
+                nn.init.constant_(block.ipa.linear_out.bias, 0)
+
+        # # Initialize (and freeze) pos_embed by sin-cos embedding:
+        if self.args.abs_pos_emb:
+            pos_embed = get_1d_sincos_pos_embed_from_grid(self.pos_embed.shape[-1], np.arange(self.args.crop))
+            self.pos_embed.data.copy_(torch.from_numpy(pos_embed).float().unsqueeze(0))
+
+        if self.args.abs_time_emb:
+            time_embed = get_1d_sincos_pos_embed_from_grid(self.time_embed.shape[-1], np.arange(self.args.num_frames))
+            self.time_embed.data.copy_(torch.from_numpy(time_embed).float().unsqueeze(0))
+
+        # Initialize timestep embedding MLP:
+        nn.init.normal_(self.t_embedder.mlp[0].weight, std=0.02)
+        nn.init.normal_(self.t_embedder.mlp[2].weight, std=0.02)
+
+        # Zero-out adaLN modulation layers in DiT blocks:
+        for block in self.layers:
+            nn.init.constant_(block.adaLN_modulation[-1].weight, 0)
+            nn.init.constant_(block.adaLN_modulation[-1].bias, 0)
+
+        if not (self.args.dynamic_mpnn or self.args.mpnn):
+            # Zero-out output layers:
+            nn.init.constant_(self.emb_to_latent.adaLN_modulation[-1].weight, 0)
+            nn.init.constant_(self.emb_to_latent.adaLN_modulation[-1].bias, 0)
+            nn.init.constant_(self.emb_to_latent.linear.weight, 0)
+            nn.init.constant_(self.emb_to_latent.linear.bias, 0)
+
+    def run_ipa(
+            self,
+            t,
+            mask,
+            start_frames,
+            end_frames,
+            aatype,
+            x_d=None
+    ):
+        if self.args.sim_condition or self.args.mpnn:
+            B, L = mask.shape
+            x = torch.zeros(B, L, self.args.embed_dim, device=mask.device)
+            if aatype is not None and not self.args.no_aa_emb:
+                x = x + self.aatype_to_emb(aatype)
+            if self.args.design:
+                x = x + self.x_d_to_emb(x_d)  # pass in only the simplex data
+            for layer in self.ipa_layers:
+                x = layer(x, t, mask, frames=start_frames)
+        elif self.args.tps_condition or self.args.inpainting or self.args.dynamic_mpnn:
+            x_f = start_frames.invert().compose(end_frames).to_tensor_7()
+            x_r = end_frames.invert().compose(start_frames).to_tensor_7()
+            x_f = self.latent_to_emb_f(x_f)
+            x_r = self.latent_to_emb_r(x_r)
+            if aatype is not None and not self.args.no_aa_emb:
+                x_f = x_f + self.aatype_to_emb(aatype)
+                x_r = x_r + self.aatype_to_emb(aatype)
+            if self.args.design:
+                x_f = x_f + self.x_d_to_emb(x_d)
+                x_r = x_r + self.x_d_to_emb(x_d)
+            for layer in self.ipa_layers:
+                x_r = layer(x_r, t, mask, frames=start_frames)
+                x_f = layer(x_f, t, mask, frames=end_frames)
+            x = (x_r + x_f)
+
+        # x = x[:, None] + x_latent
+        return x
+
+    def forward(self, x, t, mask,
+                start_frames=None, end_frames=None,
+                x_cond=None, x_cond_mask=None,
+                aatype=None
+                ):
+        if self.args.dynamic_mpnn:
+            x = x[:, [0, -1]]
+            x_cond = x_cond[:, [0, -1]]
+            x_cond_mask = x_cond_mask[:, [0, -1]]
+            mask = mask[:, [0, -1]]
+        if self.args.mpnn:
+            x = x[:, :1]
+            x_cond = x_cond[:, :1]
+            x_cond_mask = x_cond_mask[:, :1]
+            mask = mask[:, :1]
+
+        if self.args.design:
+            x_d = x[..., -20:].mean(1)
+        else:
+            x_d = None
+
+        x = self.latent_to_emb(x)  # 384 dim token
+        if self.args.abs_pos_emb:
+            x = x + self.pos_embed
+
+        if self.args.abs_time_emb:
+            x = x + self.time_embed[:, :, None]
+
+        if x_cond is not None:
+            x = x + self.cond_to_emb(x_cond) + self.mask_to_emb(x_cond_mask)  # token has cond g, tau
+
+        t = self.t_embedder(t * self.args.time_multiplier)[:, None]
+
+        if self.args.prepend_ipa:  # IPA doesn't need checkpointing
+            x = x + self.run_ipa(t[:, 0], mask[:, 0], start_frames, end_frames, aatype, x_d=x_d)[:, None]
+
+        for layer_idx, layer in enumerate(self.layers):
+            x = grad_checkpoint(layer, (x, t, mask, start_frames), self.args.grad_checkpointing)
+
+        if not (self.args.dynamic_mpnn or self.args.mpnn):
+            latent = self.emb_to_latent(x, t)
+        if self.args.design:  ### this is also kind of weird
+            x_l = self.fc2(gelu(self.fc1(x)))
+            x_l = x_l.mean(1)
+            logits = self.emb_to_logits(gelu(self.fc3(x_l)))
+            if self.args.dynamic_mpnn or self.args.mpnn:
+                return logits[:, None, :]
+            latent[:, :, :, -20:] = latent[:, :, :, -20:] + logits[:, None, :, :]
+        return latent
+
+    # x, t, mask, start_frames=None, end_frames=None, x_cond=None, x_cond_mask=None, aatype=None
+    def forward_inference(self, x, t, mask,
+                          start_frames=None, end_frames=None,
+                          x_cond=None, x_cond_mask=None,
+                          aatype=None
+                          ):
+        if not self.args.design or self.args.dynamic_mpnn or self.args.mpnn:
+            return self.forward(x, t, mask, start_frames, end_frames, x_cond, x_cond_mask, aatype)
+        else:
+            x_discrete = x[:, :, :, -20:]
+            B, T, L, _ = x_discrete.shape
+            if not torch.allclose(x_discrete.sum(3), torch.ones((B, T, L), device=x.device), atol=1e-4) or not (
+                    x_discrete >= 0).all():
+                print(
+                    f'WARNING: xt.min(): {x_discrete.min()}. Some values of xt do not lie on the simplex. There are '
+                    f'we are '
+                    f'{(x_discrete < 0).sum()} negative values in xt of shape {x_discrete.shape} that are negative. '
+                    f'We are projecting '
+                    f'them onto the simplex.')
+
+                # x_discrete = simplex_proj(x_discrete)
+            latent = self.forward(x, t, mask, start_frames, end_frames, x_cond, x_cond_mask, aatype)
+            latent_continuous = latent[:, :, :, :-20]
+            logits = latent[:, :, :, -20:]
+
+            flow_probs = torch.nn.functional.softmax(logits / self.args.dirichlet_flow_temp, -1)
+            if not torch.allclose(flow_probs.sum(3), torch.ones((B, T, L), device=x.device), atol=1e-4) or not (
+                    flow_probs >= 0).all():
+                print(
+                    f'WARNING: flow_probs.min(): {flow_probs.min()}. Some values of flow_probs do not lie on the '
+                    f'simplex. There are we are {(flow_probs < 0).sum()} negative values in flow_probs of shape '
+                    f'{flow_probs.shape} that are negative. We are projecting them onto the simplex.')
+                flow_probs = simplex_proj(flow_probs)
+
+            alpha, dalpha_dt = t_to_alpha(t[0], self.args);
+            alpha = alpha.item()
+
+            if alpha > self.args.alpha_max:
+                alpha = self.args.alpha_max - self.condflow.alpha_spacing
+            c_factor = self.condflow.c_factor(x_discrete.cpu().numpy(), alpha)
+            c_factor = torch.from_numpy(c_factor).to(x_discrete)
+            if torch.isnan(c_factor).any():
+                print(f'NAN cfactor after: xt.min(): {x_discrete.min()}, flow_probs.min(): {flow_probs.min()}')
+
+                if self.args.allow_nan_cfactor:
+                    c_factor = torch.nan_to_num(c_factor)
+                else:
+                    raise RuntimeError(
+                        f'NAN cfactor after: xt.min(): {x_discrete.min()}, flow_probs.min(): {flow_probs.min()}')
+
+            if not (flow_probs >= 0).all(): print(f'flow_probs.min(): {flow_probs.min()}')
+            eye = torch.eye(20).to(x_discrete)
+            cond_flows = (eye - x_discrete.unsqueeze(-1)) * c_factor.unsqueeze(-2)
+            flow = (flow_probs.unsqueeze(-2) * cond_flows).sum(-1) * dalpha_dt
+
+            return torch.cat([latent_continuous, flow], -1)
+
+
+class AttentionWithRoPE(nn.Module):
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self.attn = MultiheadAttention(*args, **kwargs)
+
+    def forward(self, x, mask):
+        x = x.transpose(0, 1)
+        x, _ = self.attn(query=x, key=x, value=x, key_padding_mask=1 - mask)
+        x = x.transpose(0, 1)
+        return x
+
+
+class IPALayer(nn.Module):
+    """Transformer layer block."""
+
+    def __init__(self, embed_dim, ffn_embed_dim, mha_heads, dropout=0.0,
+                 use_rotary_embeddings=False, ipa_args=None):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.ffn_embed_dim = ffn_embed_dim
+        self.mha_heads = mha_heads
+        self.inf = 1e5
+        self.use_rotary_embeddings = use_rotary_embeddings
+        self._init_submodules(add_bias_kv=True, dropout=dropout, ipa_args=ipa_args)
+
+    def _init_submodules(self, add_bias_kv=False, dropout=0.0, ipa_args=None):
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(self.embed_dim, 6 * self.embed_dim, bias=True)
+        )
+
+        self.ipa_norm = nn.LayerNorm(self.embed_dim)
+        self.ipa = InvariantPointAttention(**ipa_args)
+
+        self.mha_l = AttentionWithRoPE(
+            self.embed_dim,
+            self.mha_heads,
+            add_bias_kv=add_bias_kv,
+            dropout=dropout,
+            use_rotary_embeddings=self.use_rotary_embeddings,
+        )
+
+        self.mha_layer_norm = nn.LayerNorm(self.embed_dim, elementwise_affine=False, eps=1e-6)
+
+        self.fc1 = nn.Linear(self.embed_dim, self.ffn_embed_dim)
+        self.fc2 = nn.Linear(self.ffn_embed_dim, self.embed_dim)
+
+        self.final_layer_norm = nn.LayerNorm(self.embed_dim, elementwise_affine=False, eps=1e-6)
+
+    def forward(self, x, t, mask=None, frames=None):
+        shift_msa_l, scale_msa_l, gate_msa_l, \
+            shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(t).chunk(6, dim=-1)
+        x = x + self.ipa(self.ipa_norm(x), frames, frame_mask=mask)
+
+        residual = x
+        x = modulate(self.mha_layer_norm(x), shift_msa_l, scale_msa_l)
+        x = self.mha_l(x, mask=mask)
+        x = residual + gate_msa_l.unsqueeze(1) * x
+
+        residual = x
+        x = modulate(self.final_layer_norm(x), shift_mlp, scale_mlp)
+        x = self.fc2(gelu(self.fc1(x)))
+        x = residual + gate_mlp.unsqueeze(1) * x
+
+        return x
+
+
+class LatentMDGenLayer(nn.Module):
+    """Transformer layer block."""
+
+    def __init__(self, embed_dim, ffn_embed_dim, mha_heads, dropout=0.0, num_frames=50, hyena=False,
+                 use_rotary_embeddings=False, use_time_attention=True, ipa_args=None):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.num_frames = num_frames
+        self.hyena = hyena
+        self.ffn_embed_dim = ffn_embed_dim
+        self.mha_heads = mha_heads
+        self.inf = 1e5
+        self.use_time_attention = use_time_attention
+        self.use_rotary_embeddings = use_rotary_embeddings
+        self._init_submodules(add_bias_kv=True, dropout=dropout, ipa_args=ipa_args)
+
+    def _init_submodules(self, add_bias_kv=False, dropout=0.0, ipa_args=None):
+
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(self.embed_dim, 9 * self.embed_dim, bias=True)
+        )
+
+        if ipa_args is not None:
+            self.ipa_norm = nn.LayerNorm(self.embed_dim)
+            self.ipa = InvariantPointAttention(**ipa_args)
+
+        if self.hyena:
+            self.mha_t = HyenaOperator(
+                d_model=self.embed_dim,
+                l_max=self.num_frames,
+                order=2,
+                filter_order=64,
+            )
+
+        else:
+            self.mha_t = AttentionWithRoPE(
+                self.embed_dim,
+                self.mha_heads,
+                add_bias_kv=add_bias_kv,
+                dropout=dropout,
+                use_rotary_embeddings=self.use_rotary_embeddings,
+            )
+
+        self.mha_l = AttentionWithRoPE(
+            self.embed_dim,
+            self.mha_heads,
+            add_bias_kv=add_bias_kv,
+            dropout=dropout,
+            use_rotary_embeddings=self.use_rotary_embeddings,
+        )
+
+        self.mha_layer_norm = nn.LayerNorm(self.embed_dim, elementwise_affine=False, eps=1e-6)
+
+        self.fc1 = nn.Linear(self.embed_dim, self.ffn_embed_dim)
+        self.fc2 = nn.Linear(self.ffn_embed_dim, self.embed_dim)
+
+        self.final_layer_norm = nn.LayerNorm(self.embed_dim, elementwise_affine=False, eps=1e-6)
+
+    def forward(self, x, t, mask=None, frames=None):
+        B, T, L, C = x.shape
+
+        shift_msa_l, scale_msa_l, gate_msa_l, \
+            shift_msa_t, scale_msa_t, gate_msa_t, \
+            shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(t).chunk(9, dim=-1)
+
+        if hasattr(self, 'ipa'):
+            x = x + self.ipa(self.ipa_norm(x), frames[:, None], frame_mask=mask)
+
+        residual = x
+        x = modulate(self.mha_layer_norm(x), shift_msa_l, scale_msa_l)
+        x = self.mha_l(
+            x.reshape(B * T, L, C),
+            mask=mask.reshape(B * T, L),  # [:,None].expand(-1, T, -1).reshape(B * T, L)
+        ).reshape(B, T, L, C)
+        x = residual + gate_msa_l.unsqueeze(1) * x
+
+        residual = x
+        x = modulate(self.mha_layer_norm(x), shift_msa_t, scale_msa_t)
+        if self.hyena:
+            assert (mask - 1).sum() == 0
+            x = self.mha_t(
+                x.transpose(1, 2).reshape(B * L, T, C)
+            ).reshape(B, L, T, C).transpose(1, 2)
+        else:
+            x = self.mha_t(
+                x.transpose(1, 2).reshape(B * L, T, C),
+                mask=mask.transpose(1, 2).reshape(B * L, T)
+            ).reshape(B, L, T, C).transpose(1, 2)
+        x = residual + gate_msa_t.unsqueeze(1) * x
+
+        residual = x
+        x = modulate(self.final_layer_norm(x), shift_mlp, scale_mlp)
+        x = self.fc2(gelu(self.fc1(x)))
+        x = residual + gate_mlp.unsqueeze(1) * x
+
+        return x

data/mdgen/model/layers.py

@@ -0,0 +1,327 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+import typing as T
+
+import numpy as np
+import torch, math
+import torch.nn.functional as F
+from einops import rearrange, repeat
+from torch.nn import LayerNorm 
+from torch import nn
+
+def modulate(x, shift, scale):
+    return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1)
+
+class TimestepEmbedder(nn.Module):
+    """
+    Embeds scalar timesteps into vector representations.
+    """
+    def __init__(self, hidden_size, frequency_embedding_size=256):
+        super().__init__()
+        self.mlp = nn.Sequential(
+            nn.Linear(frequency_embedding_size, hidden_size, bias=True),
+            nn.SiLU(),
+            nn.Linear(hidden_size, hidden_size, bias=True),
+        )
+        self.frequency_embedding_size = frequency_embedding_size
+
+    @staticmethod
+    def timestep_embedding(t, dim, max_period=10000):
+        """
+        Create sinusoidal timestep embeddings.
+        :param t: a 1-D Tensor of N indices, one per batch element.
+                          These may be fractional.
+        :param dim: the dimension of the output.
+        :param max_period: controls the minimum frequency of the embeddings.
+        :return: an (N, D) Tensor of positional embeddings.
+        """
+        
+        # https://github.com/openai/glide-text2im/blob/main/glide_text2im/nn.py
+        half = dim // 2
+        freqs = torch.exp(
+            -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half
+        ).to(device=t.device)
+        args = t[:, None].float() * freqs[None]
+        embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+        if dim % 2:
+            embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
+        return embedding
+
+    def forward(self, t):
+        t_freq = self.timestep_embedding(t, self.frequency_embedding_size)
+        t_emb = self.mlp(t_freq)
+        return t_emb
+        
+class FinalLayer(nn.Module):
+    """
+    The final layer of DiT.
+    """
+    def __init__(self, hidden_size, out_channels):
+        super().__init__()
+        self.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.linear = nn.Linear(hidden_size, out_channels, bias=True)
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size, 2 * hidden_size, bias=True)
+        )
+
+    def forward(self, x, c):
+        shift, scale = self.adaLN_modulation(c).chunk(2, dim=-1)
+        x = modulate(self.norm_final(x), shift, scale)
+        x = self.linear(x)
+        return x
+
+
+def gelu(x):
+    """Implementation of the gelu activation function.
+
+    For information: OpenAI GPT's gelu is slightly different
+    (and gives slightly different results):
+    0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))))
+    """
+    return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
+
+# class GaussianFourierProjection(nn.Module):
+#     """
+#     Gaussian random features for encoding time steps.
+#     """
+
+#     def __init__(self, embed_dim, scale=30.):
+#         super().__init__()
+#         # Randomly sample weights during initialization. These weights are fixed
+#         # during optimization and are not trainable.
+#         self.W = nn.Parameter(torch.randn(embed_dim // 2) * scale, requires_grad=False)
+
+#     def forward(self, x):
+#         x_proj = x[:, None] * self.W[None, :] * 2 * np.pi
+#         return torch.cat([torch.sin(x_proj), torch.cos(x_proj)], dim=-1)
+
+
+class GaussianFourierProjection(nn.Module):
+    """Gaussian Fourier embeddings for noise levels.
+    from https://github.com/yang-song/score_sde_pytorch/blob/1618ddea340f3e4a2ed7852a0694a809775cf8d0/models/layerspp.py#L32
+    """
+
+    def __init__(self, embedding_size=256, scale=1.0):
+        super().__init__()
+        self.W = nn.Parameter(
+            torch.randn(embedding_size // 2) * scale, requires_grad=False
+        )
+
+    def forward(self, x):
+        x_proj = x[:, None] * self.W[None, :] * 2 * np.pi
+        emb = torch.cat([torch.sin(x_proj), torch.cos(x_proj)], dim=-1)
+        return emb
+
+class Attention(nn.Module):
+    def __init__(self, embed_dim, num_heads, head_width, gated=False):
+        super().__init__()
+        assert embed_dim == num_heads * head_width
+
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.head_width = head_width
+
+        self.proj = nn.Linear(embed_dim, embed_dim * 3, bias=False)
+        self.o_proj = nn.Linear(embed_dim, embed_dim, bias=True)
+        self.gated = gated
+        if gated:
+            self.g_proj = nn.Linear(embed_dim, embed_dim)
+            torch.nn.init.zeros_(self.g_proj.weight)
+            torch.nn.init.ones_(self.g_proj.bias)
+
+        self.rescale_factor = self.head_width**-0.5
+
+        torch.nn.init.zeros_(self.o_proj.bias)
+
+    def forward(self, x, mask=None, bias=None, indices=None):
+        """
+        Basic self attention with optional mask and external pairwise bias.
+        To handle sequences of different lengths, use mask.
+
+        Inputs:
+          x: batch of input sequneces (.. x L x C)
+          mask: batch of boolean masks where 1=valid, 0=padding position (.. x L_k). optional.
+          bias: batch of scalar pairwise attention biases (.. x Lq x Lk x num_heads). optional.
+
+        Outputs:
+          sequence projection (B x L x embed_dim), attention maps (B x L x L x num_heads)
+        """
+
+        t = rearrange(self.proj(x), "... l (h c) -> ... h l c", h=self.num_heads)
+        q, k, v = t.chunk(3, dim=-1)
+
+        q = self.rescale_factor * q
+        a = torch.einsum("...qc,...kc->...qk", q, k)
+
+        # Add external attention bias.
+        if bias is not None:
+            a = a + rearrange(bias, "... lq lk h -> ... h lq lk")
+
+        # Do not attend to padding tokens.
+        if mask is not None:
+            mask = repeat(
+                mask, "... lk -> ... h lq lk", h=self.num_heads, lq=q.shape[-2]
+            )
+            a = a.masked_fill(mask == False, -np.inf)
+
+        a = F.softmax(a, dim=-1)
+
+        y = torch.einsum("...hqk,...hkc->...qhc", a, v)
+        y = rearrange(y, "... h c -> ... (h c)", h=self.num_heads)
+
+        if self.gated:
+            y = self.g_proj(x).sigmoid() * y
+        y = self.o_proj(y)
+
+        return y, rearrange(a, "... lq lk h -> ... h lq lk")
+
+
+class Dropout(nn.Module):
+    """
+    Implementation of dropout with the ability to share the dropout mask
+    along a particular dimension.
+    """
+
+    def __init__(self, r: float, batch_dim: T.Union[int, T.List[int]]):
+        super(Dropout, self).__init__()
+
+        self.r = r
+        if type(batch_dim) == int:
+            batch_dim = [batch_dim]
+        self.batch_dim = batch_dim
+        self.dropout = nn.Dropout(self.r)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        shape = list(x.shape)
+        if self.batch_dim is not None:
+            for bd in self.batch_dim:
+                shape[bd] = 1
+        return x * self.dropout(x.new_ones(shape))
+
+
+class SequenceToPair(nn.Module):
+    def __init__(self, sequence_state_dim, inner_dim, pairwise_state_dim):
+        super().__init__()
+
+        self.layernorm = nn.LayerNorm(sequence_state_dim)
+        self.proj = nn.Linear(sequence_state_dim, inner_dim * 2, bias=True)
+        self.o_proj = nn.Linear(2 * inner_dim, pairwise_state_dim, bias=True)
+
+        torch.nn.init.zeros_(self.proj.bias)
+        torch.nn.init.zeros_(self.o_proj.bias)
+
+    def forward(self, sequence_state):
+        """
+        Inputs:
+          sequence_state: B x L x sequence_state_dim
+
+        Output:
+          pairwise_state: B x L x L x pairwise_state_dim
+
+        Intermediate state:
+          B x L x L x 2*inner_dim
+        """
+
+        assert len(sequence_state.shape) == 3
+
+        s = self.layernorm(sequence_state)
+        s = self.proj(s)
+        q, k = s.chunk(2, dim=-1)
+
+        prod = q[:, None, :, :] * k[:, :, None, :]
+        diff = q[:, None, :, :] - k[:, :, None, :]
+
+        x = torch.cat([prod, diff], dim=-1)
+        x = self.o_proj(x)
+
+        return x
+
+
+class StructureModuleTransitionLayer(nn.Module):
+    def __init__(self, c):
+        super(StructureModuleTransitionLayer, self).__init__()
+
+        self.c = c
+
+        self.linear_1 = Linear(self.c, self.c, init="relu")
+        self.linear_2 = Linear(self.c, self.c, init="relu")
+        self.linear_3 = Linear(self.c, self.c, init="final")
+
+        self.relu = nn.ReLU()
+
+    def forward(self, s):
+        s_initial = s
+        s = self.linear_1(s)
+        s = self.relu(s)
+        s = self.linear_2(s)
+        s = self.relu(s)
+        s = self.linear_3(s)
+
+        s = s + s_initial
+
+        return s
+
+
+class StructureModuleTransition(nn.Module):
+    def __init__(self, c, num_layers, dropout_rate):
+        super().__init__()
+
+        self.c = c
+        self.num_layers = num_layers
+        self.dropout_rate = dropout_rate
+
+        self.layers = nn.ModuleList()
+        for _ in range(self.num_layers):
+            l = StructureModuleTransitionLayer(self.c)
+            self.layers.append(l)
+
+        self.dropout = nn.Dropout(self.dropout_rate)
+        self.layer_norm = LayerNorm(self.c)
+
+    def forward(self, s):
+        for l in self.layers:
+            s = l(s)
+
+        s = self.dropout(s)
+        s = self.layer_norm(s)
+        return s
+
+
+class PairToSequence(nn.Module):
+    def __init__(self, pairwise_state_dim, num_heads):
+        super().__init__()
+
+        self.layernorm = nn.LayerNorm(pairwise_state_dim)
+        self.linear = nn.Linear(pairwise_state_dim, num_heads, bias=False)
+
+    def forward(self, pairwise_state):
+        """
+        Inputs:
+          pairwise_state: B x L x L x pairwise_state_dim
+
+        Output:
+          pairwise_bias: B x L x L x num_heads
+        """
+        assert len(pairwise_state.shape) == 4
+        z = self.layernorm(pairwise_state)
+        pairwise_bias = self.linear(z)
+        return pairwise_bias
+
+
+class ResidueMLP(nn.Module):
+    def __init__(self, embed_dim, inner_dim, norm=nn.LayerNorm, dropout=0):
+        super().__init__()
+
+        self.mlp = nn.Sequential(
+            norm(embed_dim),
+            nn.Linear(embed_dim, inner_dim),
+            nn.ReLU(),
+            nn.Linear(inner_dim, embed_dim),
+            nn.Dropout(dropout),
+        )
+
+    def forward(self, x):
+        return x + self.mlp(x)

data/mdgen/model/mha.py

@@ -0,0 +1,510 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+from typing import Dict, Optional, Tuple
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor, nn
+from torch.nn import Parameter
+from esm.rotary_embedding import RotaryEmbedding
+
+
+import uuid
+
+
+def utils_softmax(x, dim: int, onnx_trace: bool = False):
+    if onnx_trace:
+        return F.softmax(x.float(), dim=dim)
+    else:
+        return F.softmax(x, dim=dim, dtype=torch.float32)
+
+
+class FairseqIncrementalState(object):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.init_incremental_state()
+
+    def init_incremental_state(self):
+        self._incremental_state_id = str(uuid.uuid4())
+
+    def _get_full_incremental_state_key(self, key: str) -> str:
+        return "{}.{}".format(self._incremental_state_id, key)
+
+    def get_incremental_state(
+        self,
+        incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]],
+        key: str,
+    ) -> Optional[Dict[str, Optional[Tensor]]]:
+        """Helper for getting incremental state for an nn.Module."""
+        full_key = self._get_full_incremental_state_key(key)
+        if incremental_state is None or full_key not in incremental_state:
+            return None
+        return incremental_state[full_key]
+
+    def set_incremental_state(
+        self,
+        incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]],
+        key: str,
+        value: Dict[str, Optional[Tensor]],
+    ) -> Optional[Dict[str, Dict[str, Optional[Tensor]]]]:
+        """Helper for setting incremental state for an nn.Module."""
+        if incremental_state is not None:
+            full_key = self._get_full_incremental_state_key(key)
+            incremental_state[full_key] = value
+        return incremental_state
+
+
+def with_incremental_state(cls):
+    cls.__bases__ = (FairseqIncrementalState,) + tuple(
+        b for b in cls.__bases__ if b != FairseqIncrementalState
+    )
+    return cls
+
+
+@with_incremental_state
+class MultiheadAttention(nn.Module):
+    """Multi-headed attention.
+
+    See "Attention Is All You Need" for more details.
+    """
+
+    def __init__(
+        self,
+        embed_dim,
+        num_heads,
+        kdim=None,
+        vdim=None,
+        dropout=0.0,
+        bias=True,
+        add_bias_kv: bool = False,
+        add_zero_attn: bool = False,
+        self_attention: bool = False,
+        encoder_decoder_attention: bool = False,
+        use_rotary_embeddings: bool = False,
+    ):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.kdim = kdim if kdim is not None else embed_dim
+        self.vdim = vdim if vdim is not None else embed_dim
+        self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim
+
+        self.batch_first = True
+        self.num_heads = num_heads
+        self.dropout = dropout
+        self.head_dim = embed_dim // num_heads
+        assert (
+            self.head_dim * num_heads == self.embed_dim
+        ), "embed_dim must be divisible by num_heads"
+        self.scaling = self.head_dim**-0.5
+
+        self.self_attention = self_attention
+        self.encoder_decoder_attention = encoder_decoder_attention
+
+        assert not self.self_attention or self.qkv_same_dim, (
+            "Self-attention requires query, key and " "value to be of the same size"
+        )
+
+        self.k_proj = nn.Linear(self.kdim, embed_dim, bias=bias)
+        self.v_proj = nn.Linear(self.vdim, embed_dim, bias=bias)
+        self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+        self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+        if add_bias_kv:
+            self.bias_k = Parameter(torch.Tensor(1, 1, embed_dim))
+            self.bias_v = Parameter(torch.Tensor(1, 1, embed_dim))
+        else:
+            self.bias_k = self.bias_v = None
+
+        self.add_zero_attn = add_zero_attn
+
+        self.reset_parameters()
+
+        self.onnx_trace = False
+        self.rot_emb = None
+        if use_rotary_embeddings:
+            self.rot_emb = RotaryEmbedding(dim=self.head_dim)
+
+        self.enable_torch_version = False
+        if hasattr(F, "multi_head_attention_forward"):
+            self.enable_torch_version = True
+        else:
+            self.enable_torch_version = False
+
+    def prepare_for_onnx_export_(self):
+        self.onnx_trace = True
+
+    def reset_parameters(self):
+        if self.qkv_same_dim:
+            # Empirically observed the convergence to be much better with
+            # the scaled initialization
+            nn.init.xavier_uniform_(self.k_proj.weight, gain=1 / math.sqrt(2))
+            nn.init.xavier_uniform_(self.v_proj.weight, gain=1 / math.sqrt(2))
+            nn.init.xavier_uniform_(self.q_proj.weight, gain=1 / math.sqrt(2))
+        else:
+            nn.init.xavier_uniform_(self.k_proj.weight)
+            nn.init.xavier_uniform_(self.v_proj.weight)
+            nn.init.xavier_uniform_(self.q_proj.weight)
+
+        nn.init.xavier_uniform_(self.out_proj.weight)
+        if self.out_proj.bias is not None:
+            nn.init.constant_(self.out_proj.bias, 0.0)
+        if self.bias_k is not None:
+            nn.init.xavier_normal_(self.bias_k)
+        if self.bias_v is not None:
+            nn.init.xavier_normal_(self.bias_v)
+
+    def forward(
+        self,
+        query,
+        key: Optional[Tensor],
+        value: Optional[Tensor],
+        key_padding_mask: Optional[Tensor] = None,
+        incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
+        need_weights: bool = True,
+        static_kv: bool = False,
+        attn_mask: Optional[Tensor] = None,
+        before_softmax: bool = False,
+        need_head_weights: bool = False,
+    ) -> Tuple[Tensor, Optional[Tensor]]:
+        """Input shape: Time x Batch x Channel
+
+        Args:
+            key_padding_mask (ByteTensor, optional): mask to exclude
+                keys that are pads, of shape `(batch, src_len)`, where
+                padding elements are indicated by 1s.
+            need_weights (bool, optional): return the attention weights,
+                averaged over heads (default: False).
+            attn_mask (ByteTensor, optional): typically used to
+                implement causal attention, where the mask prevents the
+                attention from looking forward in time (default: None).
+            before_softmax (bool, optional): return the raw attention
+                weights and values before the attention softmax.
+            need_head_weights (bool, optional): return the attention
+                weights for each head. Implies *need_weights*. Default:
+                return the average attention weights over all heads.
+        """
+        if need_head_weights:
+            need_weights = True
+
+        tgt_len, bsz, embed_dim = query.size()
+        assert embed_dim == self.embed_dim
+        assert list(query.size()) == [tgt_len, bsz, embed_dim]
+
+        if (
+            not self.rot_emb
+            and self.enable_torch_version
+            and not self.onnx_trace
+            and incremental_state is None
+            and not static_kv
+            # A workaround for quantization to work. Otherwise JIT compilation
+            # treats bias in linear module as method.
+            and not torch.jit.is_scripting()
+            and not need_head_weights
+        ):
+            assert key is not None and value is not None
+            return F.multi_head_attention_forward(
+                query,
+                key,
+                value,
+                self.embed_dim,
+                self.num_heads,
+                torch.empty([0]),
+                torch.cat((self.q_proj.bias, self.k_proj.bias, self.v_proj.bias)),
+                self.bias_k,
+                self.bias_v,
+                self.add_zero_attn,
+                self.dropout,
+                self.out_proj.weight,
+                self.out_proj.bias,
+                self.training,
+                key_padding_mask,
+                need_weights,
+                attn_mask,
+                use_separate_proj_weight=True,
+                q_proj_weight=self.q_proj.weight,
+                k_proj_weight=self.k_proj.weight,
+                v_proj_weight=self.v_proj.weight,
+            )
+        if incremental_state is not None:
+            saved_state = self._get_input_buffer(incremental_state)
+            if saved_state is not None and "prev_key" in saved_state:
+                # previous time steps are cached - no need to recompute
+                # key and value if they are static
+                if static_kv:
+                    assert self.encoder_decoder_attention and not self.self_attention
+                    key = value = None
+        else:
+            saved_state = None
+
+        if self.self_attention:
+            q = self.q_proj(query)
+            k = self.k_proj(query)
+            v = self.v_proj(query)
+        elif self.encoder_decoder_attention:
+            # encoder-decoder attention
+            q = self.q_proj(query)
+            if key is None:
+                assert value is None
+                k = v = None
+            else:
+                k = self.k_proj(key)
+                v = self.v_proj(key)
+
+        else:
+            assert key is not None and value is not None
+            q = self.q_proj(query)
+            k = self.k_proj(key)
+            v = self.v_proj(value)
+        q *= self.scaling
+
+        if self.bias_k is not None:
+            assert self.bias_v is not None
+            k = torch.cat([k, self.bias_k.repeat(1, bsz, 1)])
+            v = torch.cat([v, self.bias_v.repeat(1, bsz, 1)])
+            if attn_mask is not None:
+                attn_mask = torch.cat(
+                    [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1
+                )
+            if key_padding_mask is not None:
+                key_padding_mask = torch.cat(
+                    [
+                        key_padding_mask,
+                        key_padding_mask.new_zeros(key_padding_mask.size(0), 1),
+                    ],
+                    dim=1,
+                )
+
+        q = q.contiguous().view(tgt_len, bsz * self.num_heads, self.head_dim).transpose(0, 1)
+        if k is not None:
+            k = k.contiguous().view(-1, bsz * self.num_heads, self.head_dim).transpose(0, 1)
+        if v is not None:
+            v = v.contiguous().view(-1, bsz * self.num_heads, self.head_dim).transpose(0, 1)
+
+        if saved_state is not None:
+            # saved states are stored with shape (bsz, num_heads, seq_len, head_dim)
+            if "prev_key" in saved_state:
+                _prev_key = saved_state["prev_key"]
+                assert _prev_key is not None
+                prev_key = _prev_key.view(bsz * self.num_heads, -1, self.head_dim)
+                if static_kv:
+                    k = prev_key
+                else:
+                    assert k is not None
+                    k = torch.cat([prev_key, k], dim=1)
+            if "prev_value" in saved_state:
+                _prev_value = saved_state["prev_value"]
+                assert _prev_value is not None
+                prev_value = _prev_value.view(bsz * self.num_heads, -1, self.head_dim)
+                if static_kv:
+                    v = prev_value
+                else:
+                    assert v is not None
+                    v = torch.cat([prev_value, v], dim=1)
+            prev_key_padding_mask: Optional[Tensor] = None
+            if "prev_key_padding_mask" in saved_state:
+                prev_key_padding_mask = saved_state["prev_key_padding_mask"]
+            assert k is not None and v is not None
+            key_padding_mask = MultiheadAttention._append_prev_key_padding_mask(
+                key_padding_mask=key_padding_mask,
+                prev_key_padding_mask=prev_key_padding_mask,
+                batch_size=bsz,
+                src_len=k.size(1),
+                static_kv=static_kv,
+            )
+
+            saved_state["prev_key"] = k.view(bsz, self.num_heads, -1, self.head_dim)
+            saved_state["prev_value"] = v.view(bsz, self.num_heads, -1, self.head_dim)
+            saved_state["prev_key_padding_mask"] = key_padding_mask
+            # In this branch incremental_state is never None
+            assert incremental_state is not None
+            incremental_state = self._set_input_buffer(incremental_state, saved_state)
+        assert k is not None
+        src_len = k.size(1)
+
+        # This is part of a workaround to get around fork/join parallelism
+        # not supporting Optional types.
+        if key_padding_mask is not None and key_padding_mask.dim() == 0:
+            key_padding_mask = None
+
+        if key_padding_mask is not None:
+            assert key_padding_mask.size(0) == bsz
+            assert key_padding_mask.size(1) == src_len
+
+        if self.add_zero_attn:
+            assert v is not None
+            src_len += 1
+            k = torch.cat([k, k.new_zeros((k.size(0), 1) + k.size()[2:])], dim=1)
+            v = torch.cat([v, v.new_zeros((v.size(0), 1) + v.size()[2:])], dim=1)
+            if attn_mask is not None:
+                attn_mask = torch.cat(
+                    [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1
+                )
+            if key_padding_mask is not None:
+                key_padding_mask = torch.cat(
+                    [
+                        key_padding_mask,
+                        torch.zeros(key_padding_mask.size(0), 1).type_as(key_padding_mask),
+                    ],
+                    dim=1,
+                )
+
+        if self.rot_emb:
+            q, k = self.rot_emb(q, k)
+
+        attn_weights = torch.bmm(q, k.transpose(1, 2))
+        attn_weights = MultiheadAttention.apply_sparse_mask(attn_weights, tgt_len, src_len, bsz)
+
+        assert list(attn_weights.size()) == [bsz * self.num_heads, tgt_len, src_len]
+
+        if attn_mask is not None:
+            attn_mask = attn_mask.unsqueeze(0)
+            if self.onnx_trace:
+                attn_mask = attn_mask.repeat(attn_weights.size(0), 1, 1)
+            attn_weights += attn_mask
+
+        if key_padding_mask is not None:
+            # don't attend to padding symbols
+            attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
+            attn_weights = attn_weights.masked_fill(
+                key_padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool), float("-inf")
+            )
+            attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
+
+        if before_softmax:
+            return attn_weights, v
+
+        attn_weights_float = utils_softmax(attn_weights, dim=-1, onnx_trace=self.onnx_trace)
+        attn_weights = attn_weights_float.type_as(attn_weights)
+        attn_probs = F.dropout(
+            attn_weights_float.type_as(attn_weights),
+            p=self.dropout,
+            training=self.training,
+        )
+        assert v is not None
+        attn = torch.bmm(attn_probs, v)
+        assert list(attn.size()) == [bsz * self.num_heads, tgt_len, self.head_dim]
+        if self.onnx_trace and attn.size(1) == 1:
+            # when ONNX tracing a single decoder step (sequence length == 1)
+            # the transpose is a no-op copy before view, thus unnecessary
+            attn = attn.contiguous().view(tgt_len, bsz, embed_dim)
+        else:
+            attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim)
+        attn = self.out_proj(attn)
+        attn_weights: Optional[Tensor] = None
+        if need_weights:
+            attn_weights = attn_weights_float.view(
+                bsz, self.num_heads, tgt_len, src_len
+            ).type_as(attn).transpose(1, 0)
+            if not need_head_weights:
+                # average attention weights over heads
+                attn_weights = attn_weights.mean(dim=0)
+
+        return attn, attn_weights
+
+    @staticmethod
+    def _append_prev_key_padding_mask(
+        key_padding_mask: Optional[Tensor],
+        prev_key_padding_mask: Optional[Tensor],
+        batch_size: int,
+        src_len: int,
+        static_kv: bool,
+    ) -> Optional[Tensor]:
+        # saved key padding masks have shape (bsz, seq_len)
+        if prev_key_padding_mask is not None and static_kv:
+            new_key_padding_mask = prev_key_padding_mask
+        elif prev_key_padding_mask is not None and key_padding_mask is not None:
+            new_key_padding_mask = torch.cat(
+                [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1
+            )
+        # During incremental decoding, as the padding token enters and
+        # leaves the frame, there will be a time when prev or current
+        # is None
+        elif prev_key_padding_mask is not None:
+            filler = torch.zeros(
+                (batch_size, src_len - prev_key_padding_mask.size(1)),
+                device=prev_key_padding_mask.device,
+            )
+            new_key_padding_mask = torch.cat(
+                [prev_key_padding_mask.float(), filler.float()], dim=1
+            )
+        elif key_padding_mask is not None:
+            filler = torch.zeros(
+                (batch_size, src_len - key_padding_mask.size(1)),
+                device=key_padding_mask.device,
+            )
+            new_key_padding_mask = torch.cat([filler.float(), key_padding_mask.float()], dim=1)
+        else:
+            new_key_padding_mask = prev_key_padding_mask
+        return new_key_padding_mask
+
+    @torch.jit.export
+    def reorder_incremental_state(
+        self, incremental_state: Dict[str, Dict[str, Optional[Tensor]]], new_order: Tensor
+    ):
+        """Reorder buffered internal state (for incremental generation)."""
+        input_buffer = self._get_input_buffer(incremental_state)
+        if input_buffer is not None:
+            for k in input_buffer.keys():
+                input_buffer_k = input_buffer[k]
+                if input_buffer_k is not None:
+                    if self.encoder_decoder_attention and input_buffer_k.size(0) == new_order.size(
+                        0
+                    ):
+                        break
+                    input_buffer[k] = input_buffer_k.index_select(0, new_order)
+            incremental_state = self._set_input_buffer(incremental_state, input_buffer)
+        return incremental_state
+
+    def _get_input_buffer(
+        self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]]
+    ) -> Dict[str, Optional[Tensor]]:
+        result = self.get_incremental_state(incremental_state, "attn_state")
+        if result is not None:
+            return result
+        else:
+            empty_result: Dict[str, Optional[Tensor]] = {}
+            return empty_result
+
+    def _set_input_buffer(
+        self,
+        incremental_state: Dict[str, Dict[str, Optional[Tensor]]],
+        buffer: Dict[str, Optional[Tensor]],
+    ):
+        return self.set_incremental_state(incremental_state, "attn_state", buffer)
+
+    def apply_sparse_mask(attn_weights, tgt_len: int, src_len: int, bsz: int):
+        return attn_weights
+
+    def upgrade_state_dict_named(self, state_dict, name):
+        prefix = name + "." if name != "" else ""
+        items_to_add = {}
+        keys_to_remove = []
+        for k in state_dict.keys():
+            if k.endswith(prefix + "in_proj_weight"):
+                # in_proj_weight used to be q + k + v with same dimensions
+                dim = int(state_dict[k].shape[0] / 3)
+                items_to_add[prefix + "q_proj.weight"] = state_dict[k][:dim]
+                items_to_add[prefix + "k_proj.weight"] = state_dict[k][dim : 2 * dim]
+                items_to_add[prefix + "v_proj.weight"] = state_dict[k][2 * dim :]
+
+                keys_to_remove.append(k)
+
+                k_bias = prefix + "in_proj_bias"
+                if k_bias in state_dict.keys():
+                    dim = int(state_dict[k].shape[0] / 3)
+                    items_to_add[prefix + "q_proj.bias"] = state_dict[k_bias][:dim]
+                    items_to_add[prefix + "k_proj.bias"] = state_dict[k_bias][dim : 2 * dim]
+                    items_to_add[prefix + "v_proj.bias"] = state_dict[k_bias][2 * dim :]
+
+                    keys_to_remove.append(prefix + "in_proj_bias")
+
+        for k in keys_to_remove:
+            del state_dict[k]
+
+        for key, value in items_to_add.items():
+            state_dict[key] = value

data/mdgen/model/primitives.py

@@ -0,0 +1,830 @@
+# Copyright 2021 AlQuraishi Laboratory
+# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import importlib
+import math
+from typing import Optional, Callable, List, Tuple
+import numpy as np
+
+deepspeed_is_installed = importlib.util.find_spec("deepspeed") is not None
+ds4s_is_installed = deepspeed_is_installed and importlib.util.find_spec("deepspeed.ops.deepspeed4science") is not None
+if deepspeed_is_installed:
+    import deepspeed
+
+if ds4s_is_installed:
+    from deepspeed.ops.deepspeed4science import DS4Sci_EvoformerAttention
+
+fa_is_installed = importlib.util.find_spec("flash_attn") is not None
+if fa_is_installed:
+    from flash_attn.bert_padding import unpad_input
+    from flash_attn.flash_attn_interface import flash_attn_unpadded_kvpacked_func
+
+import torch
+import torch.nn as nn
+from scipy.stats import truncnorm
+
+# from openfold.utils.checkpointing import get_checkpoint_fn
+# from openfold.utils.kernel.attention_core import attention_core
+# from openfold.utils.precision_utils import is_fp16_enabled
+from ..tensor_utils import (
+    permute_final_dims,
+    flatten_final_dims,
+)
+
+
+DEFAULT_LMA_Q_CHUNK_SIZE = 1024
+DEFAULT_LMA_KV_CHUNK_SIZE = 4096
+
+
+def _prod(nums):
+    out = 1
+    for n in nums:
+        out = out * n
+    return out
+
+
+def _calculate_fan(linear_weight_shape, fan="fan_in"):
+    fan_out, fan_in = linear_weight_shape
+
+    if fan == "fan_in":
+        f = fan_in
+    elif fan == "fan_out":
+        f = fan_out
+    elif fan == "fan_avg":
+        f = (fan_in + fan_out) / 2
+    else:
+        raise ValueError("Invalid fan option")
+
+    return f
+
+
+def trunc_normal_init_(weights, scale=1.0, fan="fan_in"):
+    shape = weights.shape
+    f = _calculate_fan(shape, fan)
+    scale = scale / max(1, f)
+    a = -2
+    b = 2
+    std = math.sqrt(scale) / truncnorm.std(a=a, b=b, loc=0, scale=1)
+    size = _prod(shape)
+    samples = truncnorm.rvs(a=a, b=b, loc=0, scale=std, size=size)
+    samples = np.reshape(samples, shape)
+    with torch.no_grad():
+        weights.copy_(torch.tensor(samples, device=weights.device))
+
+
+def lecun_normal_init_(weights):
+    trunc_normal_init_(weights, scale=1.0)
+
+
+def he_normal_init_(weights):
+    trunc_normal_init_(weights, scale=2.0)
+
+
+def glorot_uniform_init_(weights):
+    nn.init.xavier_uniform_(weights, gain=1)
+
+
+def final_init_(weights):
+    with torch.no_grad():
+        weights.fill_(0.0)
+
+
+def gating_init_(weights):
+    with torch.no_grad():
+        weights.fill_(0.0)
+
+
+def normal_init_(weights):
+    torch.nn.init.kaiming_normal_(weights, nonlinearity="linear")
+
+
+def ipa_point_weights_init_(weights):
+    with torch.no_grad():
+        softplus_inverse_1 = 0.541324854612918
+        weights.fill_(softplus_inverse_1)
+
+
+class Linear(nn.Linear):
+    """
+    A Linear layer with built-in nonstandard initializations. Called just
+    like torch.nn.Linear.
+
+    Implements the initializers in 1.11.4, plus some additional ones found
+    in the code.
+    """
+
+    def __init__(
+        self,
+        in_dim: int,
+        out_dim: int,
+        bias: bool = True,
+        init: str = "default",
+        init_fn: Optional[Callable[[torch.Tensor, torch.Tensor], None]] = None,
+        precision=None
+    ):
+        """
+        Args:
+            in_dim:
+                The final dimension of inputs to the layer
+            out_dim:
+                The final dimension of layer outputs
+            bias:
+                Whether to learn an additive bias. True by default
+            init:
+                The initializer to use. Choose from:
+
+                "default": LeCun fan-in truncated normal initialization
+                "relu": He initialization w/ truncated normal distribution
+                "glorot": Fan-average Glorot uniform initialization
+                "gating": Weights=0, Bias=1
+                "normal": Normal initialization with std=1/sqrt(fan_in)
+                "final": Weights=0, Bias=0
+
+                Overridden by init_fn if the latter is not None.
+            init_fn:
+                A custom initializer taking weight and bias as inputs.
+                Overrides init if not None.
+        """
+        super(Linear, self).__init__(in_dim, out_dim, bias=bias)
+
+        if bias:
+            with torch.no_grad():
+                self.bias.fill_(0)
+
+        with torch.no_grad():
+            if init_fn is not None:
+                init_fn(self.weight, self.bias)
+            else:
+                if init == "default":
+                    lecun_normal_init_(self.weight)
+                elif init == "relu":
+                    he_normal_init_(self.weight)
+                elif init == "glorot":
+                    glorot_uniform_init_(self.weight)
+                elif init == "gating":
+                    gating_init_(self.weight)
+                    if bias:
+                        self.bias.fill_(1.0)
+                elif init == "normal":
+                    normal_init_(self.weight)
+                elif init == "final":
+                    final_init_(self.weight)
+                else:
+                    raise ValueError("Invalid init string.")
+
+        self.precision = precision
+
+    def forward(self, input: torch.Tensor) -> torch.Tensor:
+        d = input.dtype
+        deepspeed_is_initialized = (
+                deepspeed_is_installed and
+                deepspeed.comm.comm.is_initialized()
+        )
+        if self.precision is not None:
+            with torch.cuda.amp.autocast(enabled=False):
+                bias = self.bias.to(dtype=self.precision) if self.bias is not None else None
+                return nn.functional.linear(input.to(dtype=self.precision),
+                                            self.weight.to(dtype=self.precision),
+                                            bias).to(dtype=d)
+
+        if d is torch.bfloat16 and not deepspeed_is_initialized:
+            with torch.cuda.amp.autocast(enabled=False):
+                bias = self.bias.to(dtype=d) if self.bias is not None else None
+                return nn.functional.linear(input, self.weight.to(dtype=d), bias)
+
+        return nn.functional.linear(input, self.weight, self.bias)
+
+
+class LayerNorm(nn.Module):
+    def __init__(self, c_in, eps=1e-5):
+        super(LayerNorm, self).__init__()
+        
+        self.c_in = (c_in,)
+        self.eps = eps
+
+        self.weight = nn.Parameter(torch.ones(c_in))
+        self.bias = nn.Parameter(torch.zeros(c_in))
+
+    def forward(self, x): 
+        d = x.dtype
+        deepspeed_is_initialized = (
+            deepspeed_is_installed and 
+            deepspeed.comm.comm.is_initialized()
+        )
+        if d is torch.bfloat16 and not deepspeed_is_initialized:
+            with torch.cuda.amp.autocast(enabled=False):
+                out = nn.functional.layer_norm(
+                    x, 
+                    self.c_in, 
+                    self.weight.to(dtype=d), 
+                    self.bias.to(dtype=d), 
+                    self.eps
+                )
+        else:
+            out = nn.functional.layer_norm(
+                x,
+                self.c_in,
+                self.weight,
+                self.bias,
+                self.eps,
+            )
+
+        return out
+
+
+@torch.jit.ignore
+def softmax_no_cast(t: torch.Tensor, dim: int = -1) -> torch.Tensor:
+    """
+        Softmax, but without automatic casting to fp32 when the input is of
+        type bfloat16
+    """
+    d = t.dtype
+    deepspeed_is_initialized = (
+        deepspeed_is_installed and 
+        deepspeed.comm.comm.is_initialized()
+    )
+    if d is torch.bfloat16 and not deepspeed_is_initialized:
+        with torch.cuda.amp.autocast(enabled=False):
+            s = torch.nn.functional.softmax(t, dim=dim)
+    else:
+        s = torch.nn.functional.softmax(t, dim=dim)
+
+    return s
+
+
+#@torch.jit.script
+def _attention(query: torch.Tensor, key: torch.Tensor, value: torch.Tensor, biases: List[torch.Tensor]) -> torch.Tensor:
+    # [*, H, C_hidden, K]
+    key = permute_final_dims(key, (1, 0))
+
+    # [*, H, Q, K]
+    a = torch.matmul(query, key)
+
+    for b in biases:
+        a += b
+
+    a = softmax_no_cast(a, -1)
+
+    # [*, H, Q, C_hidden]
+    a = torch.matmul(a, value)
+
+    return a
+
+
+@torch.jit.ignore
+def _attention_chunked_trainable(
+    query, key, value, biases, chunk_size, chunk_dim, checkpoint, 
+):
+    if checkpoint and len(biases) > 2:
+        raise ValueError(
+            "Checkpointed version permits only permits two bias terms"
+        )
+
+    def _checkpointable_attention(q, k, v, b1, b2):
+        bs = [b for b in [b1, b2] if b is not None]
+        a = _attention(q, k, v, bs)
+        return a
+
+    o_chunks = []
+    checkpoint_fn = get_checkpoint_fn()
+    count = query.shape[chunk_dim]
+    for start in range(0, count, chunk_size):
+        end = start + chunk_size
+        idx = [slice(None)] * len(query.shape)
+        idx[chunk_dim] = slice(start, end)
+        idx_tup = tuple(idx)
+        q_chunk = query[idx_tup]
+        k_chunk = key[idx_tup]
+        v_chunk = value[idx_tup]
+
+        def _slice_bias(b):
+            idx[chunk_dim] = (
+                slice(start, end) if b.shape[chunk_dim] != 1 else slice(None)
+            )
+            return b[tuple(idx)]
+
+        if checkpoint:
+            bias_1_chunk, bias_2_chunk = [
+                _slice_bias(b) if b is not None else None
+                for b in (biases + [None, None])[:2]
+            ]
+
+            o_chunk = checkpoint_fn(_checkpointable_attention,
+                q_chunk, k_chunk, v_chunk, bias_1_chunk, bias_2_chunk
+            )
+        else:
+            bias_chunks = [
+                _slice_bias(b) for b in biases
+            ]
+
+            o_chunk = _attention(q_chunk, k_chunk, v_chunk, bias_chunks)
+            
+        o_chunk = o_chunk.transpose(-2, -3)
+        o_chunks.append(o_chunk)
+
+    o = torch.cat(o_chunks, dim=chunk_dim)
+    return o
+
+
+class Attention(nn.Module):
+    """
+    Standard multi-head attention using AlphaFold's default layer
+    initialization. Allows multiple bias vectors.
+    """
+    def __init__(
+        self,
+        c_q: int,
+        c_k: int,
+        c_v: int,
+        c_hidden: int,
+        no_heads: int,
+        gating: bool = True,
+    ):
+        """
+        Args:
+            c_q:
+                Input dimension of query data
+            c_k:
+                Input dimension of key data
+            c_v:
+                Input dimension of value data
+            c_hidden:
+                Per-head hidden dimension
+            no_heads:
+                Number of attention heads
+            gating:
+                Whether the output should be gated using query data
+        """
+        super(Attention, self).__init__()
+
+        self.c_q = c_q
+        self.c_k = c_k
+        self.c_v = c_v
+        self.c_hidden = c_hidden
+        self.no_heads = no_heads
+        self.gating = gating
+
+        # DISCREPANCY: c_hidden is not the per-head channel dimension, as
+        # stated in the supplement, but the overall channel dimension.
+
+        self.linear_q = Linear(
+            self.c_q, self.c_hidden * self.no_heads, bias=False, init="glorot"
+        )
+        self.linear_k = Linear(
+            self.c_k, self.c_hidden * self.no_heads, bias=False, init="glorot"
+        )
+        self.linear_v = Linear(
+            self.c_v, self.c_hidden * self.no_heads, bias=False, init="glorot"
+        )
+        self.linear_o = Linear(
+            self.c_hidden * self.no_heads, self.c_q, init="final"
+        )
+
+        self.linear_g = None
+        if self.gating:
+            self.linear_g = Linear(
+                self.c_q, self.c_hidden * self.no_heads, init="gating"
+            )
+
+        self.sigmoid = nn.Sigmoid()
+
+    def _prep_qkv(self,
+        q_x: torch.Tensor, 
+        kv_x: torch.Tensor,
+        apply_scale: bool = True
+    ) -> Tuple[
+        torch.Tensor, torch.Tensor, torch.Tensor
+    ]:
+        # [*, Q/K/V, H * C_hidden]
+        q = self.linear_q(q_x)
+        k = self.linear_k(kv_x)
+        v = self.linear_v(kv_x)
+
+        # [*, Q/K, H, C_hidden]
+        q = q.view(q.shape[:-1] + (self.no_heads, -1))
+        k = k.view(k.shape[:-1] + (self.no_heads, -1))
+        v = v.view(v.shape[:-1] + (self.no_heads, -1))
+
+        # [*, H, Q/K, C_hidden]
+        q = q.transpose(-2, -3)
+        k = k.transpose(-2, -3)
+        v = v.transpose(-2, -3)
+
+        if apply_scale:
+            q /= math.sqrt(self.c_hidden)
+
+        return q, k, v
+
+    def _wrap_up(self,
+        o: torch.Tensor, 
+        q_x: torch.Tensor
+    ) -> torch.Tensor:
+        if self.linear_g is not None:
+            g = self.sigmoid(self.linear_g(q_x))
+        
+            # [*, Q, H, C_hidden]
+            g = g.view(g.shape[:-1] + (self.no_heads, -1))
+            o = o * g
+
+        # [*, Q, H * C_hidden]
+        o = flatten_final_dims(o, 2)
+
+        # [*, Q, C_q]
+        o = self.linear_o(o)
+
+        return o
+
+    def forward(
+        self,
+        q_x: torch.Tensor,
+        kv_x: torch.Tensor,
+        biases: Optional[List[torch.Tensor]] = None,
+        use_memory_efficient_kernel: bool = False,
+        use_deepspeed_evo_attention: bool = False,
+        use_lma: bool = False,
+        lma_q_chunk_size: int = DEFAULT_LMA_Q_CHUNK_SIZE,
+        lma_kv_chunk_size: int = DEFAULT_LMA_KV_CHUNK_SIZE,
+        use_flash: bool = False,
+        flash_mask: Optional[torch.Tensor] = None
+    ) -> torch.Tensor:
+        """
+        Args:
+            q_x:
+                [*, Q, C_q] query data
+            kv_x:
+                [*, K, C_k] key data
+            biases:
+                List of biases that broadcast to [*, H, Q, K]
+            use_memory_efficient_kernel:
+                Whether to use a custom memory-efficient attention kernel.
+                This should be the default choice for most. If none of the
+                "use_<...>" flags are True, a stock PyTorch implementation
+                is used instead
+            use_deepspeed_evo_attention:
+                Whether to use DeepSpeed memory-efficient attention kernel.
+                If none of the "use_<...>" flags are True, a stock PyTorch
+                implementation is used instead
+            use_lma:
+                Whether to use low-memory attention (Staats & Rabe 2021). If
+                none of the "use_<...>" flags are True, a stock PyTorch 
+                implementation is used instead
+            lma_q_chunk_size:
+                Query chunk size (for LMA)
+            lma_kv_chunk_size:
+                Key/Value chunk size (for LMA)
+        Returns
+            [*, Q, C_q] attention update
+        """
+        if use_lma and (lma_q_chunk_size is None or lma_kv_chunk_size is None):
+            raise ValueError(
+                "If use_lma is specified, lma_q_chunk_size and "
+                "lma_kv_chunk_size must be provided"
+            )
+
+        if use_flash and biases is not None:
+            raise ValueError(
+                "use_flash is incompatible with the bias option. For masking, "
+                "use flash_mask instead"
+            )
+
+        attn_options = [use_memory_efficient_kernel, use_deepspeed_evo_attention, use_lma, use_flash]
+        if sum(attn_options) > 1:
+            raise ValueError(
+                "Choose at most one alternative attention algorithm"
+            )
+
+        if biases is None:
+            biases = []
+        
+        # DeepSpeed attention kernel applies scaling internally
+        q, k, v = self._prep_qkv(q_x, kv_x,
+                                 apply_scale=not use_deepspeed_evo_attention)
+
+        if is_fp16_enabled():
+            use_memory_efficient_kernel = False
+        
+        if use_memory_efficient_kernel:
+            if len(biases) > 2:
+                raise ValueError(
+                    "If use_memory_efficient_kernel is True, you may only "
+                    "provide up to two bias terms"
+                )
+            o = attention_core(q, k, v, *((biases + [None] * 2)[:2]))
+            o = o.transpose(-2, -3)
+        elif use_deepspeed_evo_attention:
+            if len(biases) > 2:
+                raise ValueError(
+                    "If use_deepspeed_evo_attention is True, you may only "
+                    "provide up to two bias terms"
+                )
+            o = _deepspeed_evo_attn(q, k, v, biases)
+        elif use_lma:
+            biases = [
+                b.expand(b.shape[:-2] + (q_x.shape[-2],) + (kv_x.shape[-2],)) 
+                for b in biases
+            ]
+            o = _lma(q, k, v, biases, lma_q_chunk_size, lma_kv_chunk_size)
+            o = o.transpose(-2, -3)
+        elif use_flash:
+            o = _flash_attn(q, k, v, flash_mask)
+        else:
+            o = _attention(q, k, v, biases)
+            o = o.transpose(-2, -3)
+
+        o = self._wrap_up(o, q_x)
+
+        return o
+
+
+class GlobalAttention(nn.Module):
+    def __init__(self, c_in, c_hidden, no_heads, inf, eps):
+        super(GlobalAttention, self).__init__()
+
+        self.c_in = c_in
+        self.c_hidden = c_hidden
+        self.no_heads = no_heads
+        self.inf = inf
+        self.eps = eps
+
+        self.linear_q = Linear(
+            c_in, c_hidden * no_heads, bias=False, init="glorot"
+        )
+
+        self.linear_k = Linear(
+            c_in, c_hidden, bias=False, init="glorot",
+        )
+        self.linear_v = Linear(
+            c_in, c_hidden, bias=False, init="glorot",
+        )
+        self.linear_g = Linear(c_in, c_hidden * no_heads, init="gating")
+        self.linear_o = Linear(c_hidden * no_heads, c_in, init="final")
+
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, 
+        m: torch.Tensor, 
+        mask: torch.Tensor,
+        use_lma: bool = False,
+    ) -> torch.Tensor:
+        # [*, N_res, C_in]
+        q = torch.sum(m * mask.unsqueeze(-1), dim=-2) / (
+            torch.sum(mask, dim=-1)[..., None] + self.eps
+        )
+
+        # [*, N_res, H * C_hidden]
+        q = self.linear_q(q)
+        q *= (self.c_hidden ** (-0.5))
+
+        # [*, N_res, H, C_hidden]
+        q = q.view(q.shape[:-1] + (self.no_heads, -1))
+
+        # [*, N_res, N_seq, C_hidden]
+        k = self.linear_k(m)
+        v = self.linear_v(m)
+
+        bias = (self.inf * (mask - 1))[..., :, None, :]
+        if not use_lma:
+            # [*, N_res, H, N_seq]
+            a = torch.matmul(
+                q,
+                k.transpose(-1, -2),  # [*, N_res, C_hidden, N_seq]
+            )
+            a += bias
+            a = softmax_no_cast(a)
+
+            # [*, N_res, H, C_hidden]
+            o = torch.matmul(
+                a,
+                v,
+            )
+        else:
+            o = _lma(
+                q, 
+                k, 
+                v, 
+                [bias], 
+                DEFAULT_LMA_Q_CHUNK_SIZE, 
+                DEFAULT_LMA_KV_CHUNK_SIZE
+            )
+
+        # [*, N_res, N_seq, C_hidden]
+        g = self.sigmoid(self.linear_g(m))
+
+        # [*, N_res, N_seq, H, C_hidden]
+        g = g.view(g.shape[:-1] + (self.no_heads, -1))
+
+        # [*, N_res, N_seq, H, C_hidden]
+        o = o.unsqueeze(-3) * g
+
+        # [*, N_res, N_seq, H * C_hidden]
+        o = o.reshape(o.shape[:-2] + (-1,))
+
+        # [*, N_res, N_seq, C_in]
+        m = self.linear_o(o)
+
+        return m
+
+
+@torch.jit.ignore
+def _deepspeed_evo_attn(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    biases: List[torch.Tensor],
+):
+    """""
+    Compute attention using the DeepSpeed DS4Sci_EvoformerAttention kernel.
+
+    Args:
+        q:
+            [*, H, Q, C_hidden] query data
+        k:
+            [*, H, K, C_hidden] key data
+        v:
+            [*, H, V, C_hidden] value data
+        biases:
+            List of biases that broadcast to [*, H, Q, K]
+    """
+
+    if not ds4s_is_installed:
+        raise ValueError(
+            "_deepspeed_evo_attn requires that DeepSpeed be installed "
+            "and that the deepspeed.ops.deepspeed4science package exists"
+        )
+
+    def reshape_dims(x):
+        no_batch_dims = len(x.shape[:-3])
+        if no_batch_dims < 2:
+            return x.reshape(*((1,) * (2 - no_batch_dims) + x.shape))
+        if no_batch_dims > 2:
+            return x.reshape(*((x.shape[0], -1) + x.shape[-3:]))
+        return x
+
+    # [*, Q/K, H, C_hidden]
+    q = q.transpose(-2, -3)
+    k = k.transpose(-2, -3)
+    v = v.transpose(-2, -3)
+
+    # Reshape tensors to match expected input shape [B, N, Q/K, H, C_hidden]
+    # for DS4Sci_EvoformerAttention() by adding or flattening batch dims as needed.
+    orig_shape = q.shape
+    if len(orig_shape[:-3]) != 2:
+        q = reshape_dims(q)
+        k = reshape_dims(k)
+        v = reshape_dims(v)
+        biases = [reshape_dims(b) for b in biases]
+
+    # DeepSpeed attn. kernel requires inputs to be type bf16 or fp16
+    # Cast to bf16 so kernel can be used during inference
+    orig_dtype = q.dtype
+    if orig_dtype not in [torch.bfloat16, torch.float16]:
+        o = DS4Sci_EvoformerAttention(q.to(dtype=torch.bfloat16),
+                                      k.to(dtype=torch.bfloat16),
+                                      v.to(dtype=torch.bfloat16),
+                                      [b.to(dtype=torch.bfloat16) for b in biases])
+
+        o = o.to(dtype=orig_dtype)
+    else:
+        o = DS4Sci_EvoformerAttention(q, k, v, biases)
+
+    o = o.reshape(orig_shape)
+    return o
+
+
+def _lma(
+    q: torch.Tensor, 
+    k: torch.Tensor, 
+    v: torch.Tensor, 
+    biases: List[torch.Tensor], 
+    q_chunk_size: int, 
+    kv_chunk_size: int,
+):
+    no_q, no_kv = q.shape[-2], k.shape[-2]
+
+    # [*, H, Q, C_hidden]
+    o = q.new_zeros(q.shape)
+    for q_s in range(0, no_q, q_chunk_size):
+        q_chunk = q[..., q_s: q_s + q_chunk_size, :]
+        large_bias_chunks = [
+            b[..., q_s: q_s + q_chunk_size, :] for b in biases
+        ]
+
+        maxes = []
+        weights = []
+        values = []
+        for kv_s in range(0, no_kv, kv_chunk_size):
+            k_chunk = k[..., kv_s: kv_s + kv_chunk_size, :]
+            v_chunk = v[..., kv_s: kv_s + kv_chunk_size, :]
+            small_bias_chunks = [
+                b[..., kv_s: kv_s + kv_chunk_size] for b in large_bias_chunks
+            ]
+
+            a = torch.einsum(
+                "...hqd,...hkd->...hqk", q_chunk, k_chunk,
+            )
+       
+            for b in small_bias_chunks:
+                a += b
+        
+            max_a = torch.max(a, dim=-1, keepdim=True)[0]
+            exp_a = torch.exp(a - max_a)
+            exp_v = torch.einsum("...hvf,...hqv->...hqf", v_chunk, exp_a)
+ 
+            maxes.append(max_a.detach().squeeze(-1))
+            weights.append(torch.sum(exp_a, dim=-1))
+            values.append(exp_v)
+
+        chunk_max = torch.stack(maxes, dim=-3)
+        chunk_weights = torch.stack(weights, dim=-3)
+        chunk_values = torch.stack(values, dim=-4)
+
+        global_max = torch.max(chunk_max, dim=-3, keepdim=True)[0]
+        max_diffs = torch.exp(chunk_max - global_max)
+        chunk_values = chunk_values * max_diffs.unsqueeze(-1)
+        chunk_weights = chunk_weights * max_diffs
+
+        all_values = torch.sum(chunk_values, dim=-4)
+        all_weights = torch.sum(chunk_weights.unsqueeze(-1), dim=-4)
+
+        q_chunk_out = all_values / all_weights
+
+        o[..., q_s: q_s + q_chunk_size, :] = q_chunk_out
+
+    return o
+
+
+@torch.jit.ignore
+def _flash_attn(q, k, v, kv_mask):
+    if not fa_is_installed:
+        raise ValueError(
+            "_flash_attn requires that FlashAttention be installed"
+        )
+   
+    batch_dims = q.shape[:-3]
+    no_heads, n, c = q.shape[-3:]
+    dtype = q.dtype
+
+    q = q.half()
+    k = k.half()
+    v = v.half()
+    kv_mask = kv_mask.half()
+
+    # [*, B, N, H, C]
+    q = q.transpose(-2, -3)
+    k = k.transpose(-2, -3)
+    v = v.transpose(-2, -3)
+
+    # [B_flat, N, H, C]
+    q = q.reshape(-1, *q.shape[-3:])
+    k = k.reshape(-1, *k.shape[-3:])
+    v = v.reshape(-1, *v.shape[-3:])
+
+    # Flattened batch size
+    batch_size = q.shape[0]
+    
+    # [B_flat * N, H, C]
+    q = q.reshape(-1, *q.shape[-2:])
+    
+    q_max_s = n
+    q_cu_seqlens = torch.arange(
+        0, (batch_size + 1) * n, step=n, dtype=torch.int32, device=q.device
+    )
+
+    # [B_flat, N, 2, H, C]
+    kv = torch.stack([k, v], dim=-3) 
+    kv_shape = kv.shape
+    
+    # [B_flat, N, 2 * H * C]
+    kv = kv.reshape(*kv.shape[:-3], -1) 
+    
+    kv_unpad, _, kv_cu_seqlens, kv_max_s = unpad_input(kv, kv_mask)
+    kv_unpad = kv_unpad.reshape(-1, *kv_shape[-3:])
+   
+    out = flash_attn_unpadded_kvpacked_func(
+        q,
+        kv_unpad,
+        q_cu_seqlens,
+        kv_cu_seqlens,
+        q_max_s,
+        kv_max_s,
+        dropout_p=0.,
+        softmax_scale=1.,  # q has been scaled already
+    )
+  
+    # [*, B, N, H, C]
+    out = out.reshape(*batch_dims, n, no_heads, c) 
+
+    out = out.to(dtype=dtype)
+
+    return out

data/mdgen/model/standalone_hyena.py

@@ -0,0 +1,289 @@
+# https://github.com/HazyResearch/safari/blob/main/standalone_hyena.py
+"""
+Simplified standalone version of Hyena: https://arxiv.org/abs/2302.10866, designed for quick experimentation.
+A complete version is available under `src.models.sequence.hyena`.
+"""
+
+import math
+import random
+
+import torch
+import torch.nn as nn
+from einops import rearrange
+
+
+def fftconv(u, k, D):
+    L = u.shape[-1]
+    fft_size = 2 * L
+
+    k_f = torch.fft.rfft(k, n=fft_size) / fft_size
+    u_f = torch.fft.rfft(u.to(dtype=k.dtype), n=fft_size)
+
+    if len(u.shape) > 3: k_f = k_f.unsqueeze(1)
+    y = torch.fft.irfft(u_f * k_f, n=fft_size, norm='forward')[..., L - 1: 2 * L - 1]
+
+    out = y + u * D.unsqueeze(-1)
+    return out.to(dtype=u.dtype)
+
+
+@torch.jit.script
+def mul_sum(q, y):
+    return (q * y).sum(dim=1)
+
+
+class OptimModule(nn.Module):
+    """ Interface for Module that allows registering buffers/parameters with configurable optimizer hyperparameters """
+
+    def register(self, name, tensor, lr=None, wd=0.0):
+        """Register a tensor with a configurable learning rate and 0 weight decay"""
+
+        if lr == 0.0:
+            self.register_buffer(name, tensor)
+        else:
+            self.register_parameter(name, nn.Parameter(tensor))
+
+            optim = {}
+            if lr is not None: optim["lr"] = lr
+            if wd is not None: optim["weight_decay"] = wd
+            setattr(getattr(self, name), "_optim", optim)
+
+
+class Sin(nn.Module):
+    def __init__(self, dim, w=10, train_freq=True):
+        super().__init__()
+        self.freq = nn.Parameter(w * torch.ones(1, dim)) if train_freq else w * torch.ones(1, dim)
+
+    def forward(self, x):
+        return torch.sin(self.freq * x)
+
+
+class PositionalEmbedding(OptimModule):
+    def __init__(self, emb_dim: int, seq_len: int, lr_pos_emb: float = 1e-5, **kwargs):
+        """Complex exponential positional embeddings for Hyena filters."""
+        super().__init__()
+
+        self.seq_len = seq_len
+        # The time embedding fed to the filteres is normalized so that t_f = 1
+        t = torch.linspace(0, 1, self.seq_len)[None, :, None]  # 1, L, 1
+
+        if emb_dim > 1:
+            bands = (emb_dim - 1) // 2
+            # To compute the right embeddings we use the "proper" linspace
+        t_rescaled = torch.linspace(0, seq_len - 1, seq_len)[None, :, None]
+        w = 2 * math.pi * t_rescaled / seq_len  # 1, L, 1
+
+        f = torch.linspace(1e-4, bands - 1, bands)[None, None]
+        z = torch.exp(-1j * f * w)
+        z = torch.cat([t, z.real, z.imag], dim=-1)
+        self.register("z", z, lr=lr_pos_emb)
+        self.register("t", t, lr=0.0)
+
+    def forward(self, L):
+        return self.z[:, :L], self.t[:, :L]
+
+
+class ExponentialModulation(OptimModule):
+    def __init__(
+            self,
+            d_model,
+            fast_decay_pct=0.3,
+            slow_decay_pct=1.5,
+            target=1e-2,
+            modulation_lr=0.0,
+            modulate: bool = True,
+            shift: float = 0.0,
+            **kwargs
+    ):
+        super().__init__()
+        self.modulate = modulate
+        self.shift = shift
+        max_decay = math.log(target) / fast_decay_pct
+        min_decay = math.log(target) / slow_decay_pct
+        deltas = torch.linspace(min_decay, max_decay, d_model)[None, None]
+        self.register("deltas", deltas, lr=modulation_lr)
+
+    def forward(self, t, x):
+        if self.modulate:
+            decay = torch.exp(-t * self.deltas.abs())
+            x = x * (decay + self.shift)
+        return x
+
+
+class HyenaFilter(OptimModule):
+    def __init__(
+            self,
+            d_model,
+            emb_dim=3,  # dim of input to MLP, augments with positional encoding
+            order=16,  # width of the implicit MLP
+            fused_fft_conv=False,
+            seq_len=1024,
+            lr=1e-3,
+            lr_pos_emb=1e-5,
+            dropout=0.0,
+            w=1,  # frequency of periodic activations
+            wd=0,  # weight decay of kernel parameters
+            bias=True,
+            num_inner_mlps=2,
+            normalized=False,
+            **kwargs
+    ):
+        """
+        Implicit long filter with modulation.
+        
+        Args:
+            d_model: number of channels in the input
+            emb_dim: dimension of the positional encoding (`emb_dim` - 1) // 2 is the number of bands
+            order: width of the FFN
+            num_inner_mlps: number of inner linear layers inside filter MLP
+        """
+        super().__init__()
+        self.d_model = d_model
+        self.use_bias = bias
+        self.fused_fft_conv = fused_fft_conv
+        self.bias = nn.Parameter(torch.randn(self.d_model))
+        self.dropout = nn.Dropout(dropout)
+
+        act = Sin(dim=order, w=w)
+        self.emb_dim = emb_dim
+        assert emb_dim % 2 != 0 and emb_dim >= 3, "emb_dim must be odd and greater or equal to 3 (time, " \
+                                                  "sine and cosine)"
+        self.seq_len = seq_len
+
+        self.pos_emb = PositionalEmbedding(emb_dim, seq_len, lr_pos_emb)
+
+        self.implicit_filter = nn.Sequential(
+            nn.Linear(emb_dim, order),
+            act,
+        )
+        for i in range(num_inner_mlps):
+            self.implicit_filter.append(nn.Linear(order, order))
+            self.implicit_filter.append(act)
+
+        self.implicit_filter.append(nn.Linear(order, d_model, bias=False))
+
+        self.modulation = ExponentialModulation(d_model, **kwargs)
+
+        self.normalized = normalized
+        for c in self.implicit_filter.children():
+            for name, v in c.state_dict().items():
+                optim = {"weight_decay": wd, "lr": lr}
+                setattr(getattr(c, name), "_optim", optim)
+
+    def filter(self, L, *args, **kwargs):
+        z, t = self.pos_emb(L)
+        h = self.implicit_filter(z)
+        h = self.modulation(t, h)
+        return h
+
+    def forward(self, x, L, k=None, bias=None, *args, **kwargs):
+        if k is None: k = self.filter(2 * L - 1)
+
+        # Ensure compatibility with filters that return a tuple 
+        k = k[0] if type(k) is tuple else k
+
+        y = fftconv(x, k, bias)
+        return y
+
+
+class HyenaOperator(nn.Module):
+    def __init__(
+            self,
+            d_model,
+            l_max,
+            order=2,
+            filter_order=64,
+            dropout=0.0,
+            filter_dropout=0.0,
+            **filter_args,
+    ):
+        r"""
+        Hyena operator described in the paper https://arxiv.org/pdf/2302.10866.pdf
+        
+        Args:
+            d_model (int): Dimension of the input and output embeddings (width of the layer)
+            l_max: (int): Maximum input sequence length. Defaults to None
+            order: (int): Depth of the Hyena recurrence. Defaults to 2
+            dropout: (float): Dropout probability. Defaults to 0.0
+            filter_dropout: (float): Dropout probability for the filter. Defaults to 0.0
+        """
+        super().__init__()
+        self.d_model = d_model
+        self.l_max = l_max
+        self.order = order
+        inner_width = d_model * (order + 1)
+        self.dropout = nn.Dropout(dropout)
+        self.in_proj = nn.Linear(d_model, inner_width)
+        self.out_proj = nn.Linear(d_model, d_model)
+
+        self.short_filter = nn.Conv1d(
+            inner_width,
+            inner_width,
+            3,
+            padding=2,
+            groups=inner_width
+        )
+        self.filter_fn = HyenaFilter(
+            d_model * (order - 1),
+            order=filter_order,
+            seq_len=l_max,
+            channels=1,
+            dropout=filter_dropout,
+            **filter_args
+        )
+
+    def forward(self, u, *args, **kwargs):
+        l = u.size(-2)
+        l_filter = min(l, self.l_max)
+        u = self.in_proj(u)
+        u = rearrange(u, 'b l d -> b d l')
+
+        uc = self.short_filter(u)[..., :l_filter]
+        *x, v = uc.split(self.d_model, dim=1)
+
+        k = self.filter_fn.filter(l_filter)[0]
+        k = rearrange(k, 'l (o d) -> o d l', o=self.order - 1)
+        bias = rearrange(self.filter_fn.bias, '(o d) -> o d', o=self.order - 1)
+
+        for o, x_i in enumerate(reversed(x[1:])):
+            v = self.dropout(v * x_i)
+            v = self.filter_fn(v, l_filter, k=k[o], bias=bias[o])
+
+        y = rearrange(v * x[0], 'b d l -> b l d')
+
+        y = self.out_proj(y)
+        return y
+
+if __name__ == '__main__':
+    h = torch.FloatTensor([1, 1, 1, 1, 1, 1, 1])
+    x = torch.FloatTensor([1, 1, 1, 1])
+    L = len(x)
+    res = torch.fft.irfft(torch.fft.rfft(h, n=2 * L) * torch.fft.rfft(x, n=2 * L))
+    print('all', res)
+    print('cropped', res[L - 1: 2 * L - 1])
+    a = torch.Tensor([random.random() for _ in range(8)])
+    b = torch.Tensor([random.random() for _ in range(8)])
+
+    a_rf = torch.fft.rfft(a, norm="forward")
+    b_rf = torch.fft.rfft(b, norm="forward")
+    c_rf = a_rf * b_rf
+    cr = torch.fft.irfft(c_rf, norm="forward")
+
+    a_f = torch.fft.fft(a, norm="forward")
+    b_f = torch.fft.fft(b, norm="forward")
+    c_f = a_f * b_f
+    c = torch.fft.irfft(c_f, norm="forward")
+
+    layer = HyenaOperator(
+        d_model=512,
+        l_max=1024,
+        order=2,
+        filter_order=64
+    )
+    x = torch.randn(1, 1024, 512, requires_grad=True)
+    y = layer(x)
+
+    print(x.shape, y.shape)
+
+    grad = torch.autograd.grad(y[:, 10, :].sum(), x)[0]
+    print('Causality check: gradients should not flow "from future to past"')
+    print(grad[0, 105, :].sum(), grad[0, 0, :].sum())

data/mdgen/parsing.py

@@ -0,0 +1,127 @@
+from argparse import ArgumentParser
+import os
+
+
+def parse_train_args():
+    parser = ArgumentParser()
+
+    ## Trainer settings
+    parser.add_argument("--ckpt", type=str, default=None)
+    parser.add_argument("--validate", action='store_true', default=False)
+    parser.add_argument("--num_workers", type=int, default=4)
+    
+    ## Epoch settings
+    group = parser.add_argument_group("Epoch settings")
+    group.add_argument("--epochs", type=int, default=100)
+    group.add_argument("--overfit", action='store_true')
+    group.add_argument("--overfit_peptide", type=str, default=None)
+    group.add_argument("--overfit_frame", action='store_true')
+    group.add_argument("--train_batches", type=int, default=None)
+    group.add_argument("--val_batches", type=int, default=None)
+    group.add_argument("--val_repeat", type=int, default=1)
+    group.add_argument("--inference_batches", type=int, default=0)
+    group.add_argument("--batch_size", type=int, default=8)
+    group.add_argument("--val_freq", type=int, default=None)
+    group.add_argument("--val_epoch_freq", type=int, default=1)
+    group.add_argument("--no_validate", action='store_true')
+    group.add_argument("--designability_freq", type=int, default=1)
+
+    ## Logging args
+    group = parser.add_argument_group("Logging settings")
+    group.add_argument("--print_freq", type=int, default=100)
+    group.add_argument("--ckpt_freq", type=int, default=1)
+    group.add_argument("--wandb", action="store_true")
+    group.add_argument("--run_name", type=str, default="default")
+    
+
+    ## Optimization settings
+    group = parser.add_argument_group("Optimization settings")
+    group.add_argument("--accumulate_grad", type=int, default=1)
+    group.add_argument("--grad_clip", type=float, default=1.)
+    group.add_argument("--check_grad", action='store_true')
+    group.add_argument('--grad_checkpointing', action='store_true')
+    group.add_argument('--adamW', action='store_true')
+    group.add_argument('--ema', action='store_true')
+    group.add_argument('--ema_decay', type=float, default=0.999)
+    group.add_argument("--lr", type=float, default=1e-4)
+    group.add_argument('--precision', type=str, default='32-true')
+    
+    ## Training data 
+    group = parser.add_argument_group("Training data settings")
+    group.add_argument('--train_split', type=str, default=None, required=True)
+    group.add_argument('--val_split', type=str, default=None, required=True)
+    group.add_argument('--data_dir', type=str, default=None, required=True)
+    group.add_argument('--num_frames', type=int, default=50)
+    group.add_argument('--crop', type=int, default=256)
+    group.add_argument('--suffix', type=str, default='')
+    group.add_argument('--atlas', action='store_true')
+    group.add_argument('--copy_frames', action='store_true')
+    group.add_argument('--no_pad', action='store_true')
+    group.add_argument('--short_md', action='store_true')
+
+    ### Masking settings
+    group = parser.add_argument_group("Masking settings")
+    group.add_argument('--design_key_frames', action='store_true')
+    group.add_argument('--no_aa_emb', action='store_true')
+    group.add_argument("--no_torsion", action='store_true')
+    group.add_argument("--no_design_torsion", action='store_true')
+    group.add_argument("--supervise_no_torsions", action='store_true')
+    group.add_argument("--supervise_all_torsions", action='store_true')
+
+    ## Ablations settings
+    group = parser.add_argument_group("Ablations settings")
+    group.add_argument('--no_offsets', action='store_true')
+    group.add_argument('--no_frames', action='store_true')
+    
+    
+    ## Model settings
+    group = parser.add_argument_group("Model settings")
+    group.add_argument('--hyena', action='store_true')
+    group.add_argument('--no_rope', action='store_true')
+    group.add_argument('--dropout', type=float, default=0.0)
+    group.add_argument('--scale_factor', type=float, default=1.0)
+    group.add_argument('--interleave_ipa', action='store_true')
+    group.add_argument('--prepend_ipa', action='store_true')
+    group.add_argument('--oracle', action='store_true')
+    group.add_argument('--num_layers', type=int, default=5)
+    group.add_argument('--embed_dim', type=int, default=384)
+    group.add_argument('--mha_heads', type=int, default=16)
+    group.add_argument('--ipa_heads', type=int, default=4)
+    # group.add_argument('--ipa_layers', type=int, default=None)
+    group.add_argument('--ipa_head_dim', type=int, default=32)
+    group.add_argument('--ipa_qk', type=int, default=8)
+    group.add_argument('--ipa_v', type=int, default=8)
+
+    group.add_argument('--time_multiplier', type=float, default=100.)
+    group.add_argument('--abs_pos_emb', action='store_true')
+    group.add_argument('--abs_time_emb', action='store_true')
+
+    group = parser.add_argument_group("Transport arguments")
+    group.add_argument("--path-type", type=str, default="GVP", choices=["Linear", "GVP", "VP"])
+    group.add_argument("--prediction", type=str, default="velocity", choices=["velocity", "score", "noise"])
+    group.add_argument("--sampling_method", type=str, default="dopri5", choices=["dopri5", "euler"])
+    group.add_argument('--alpha_max', type=float, default=8)
+    group.add_argument('--discrete_loss_weight', type=float, default=0.5)
+    group.add_argument("--dirichlet_flow_temp", type=float, default=1.0)
+    group.add_argument('--allow_nan_cfactor', action='store_true')
+    # group.add_argument("--loss-weight", type=none_or_str, default=None, choices=[None, "velocity", "likelihood"])
+    
+
+    ## video settings
+    group = parser.add_argument_group("Video settings")
+    group.add_argument('--tps_condition', action='store_true')
+    group.add_argument('--design', action='store_true')
+    group.add_argument('--design_from_traj', action='store_true')
+    group.add_argument('--sim_condition', action='store_true')
+    group.add_argument('--inpainting', action='store_true')
+    group.add_argument('--dynamic_mpnn', action='store_true')
+    group.add_argument('--mpnn', action='store_true')
+    group.add_argument('--frame_interval', type=int, default=None)
+    group.add_argument('--cond_interval', type=int, default=None) # for superresolution
+    
+    args = parser.parse_args()
+    os.environ["MODEL_DIR"] = os.path.join("workdir", args.run_name)
+    
+    return args
+
+

data/mdgen/protein.py

@@ -0,0 +1,636 @@
+# Copyright 2021 AlQuraishi Laboratory
+# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Protein data type."""
+import dataclasses
+import io
+from typing import Any, Sequence, Mapping, Optional
+import re
+import string
+
+from . import residue_constants
+from Bio.PDB import PDBParser
+import numpy as np
+# import modelcif
+# import modelcif.model
+# import modelcif.dumper
+# import modelcif.reference
+# import modelcif.protocol
+# import modelcif.alignment
+# import modelcif.qa_metric
+
+
+FeatureDict = Mapping[str, np.ndarray]
+ModelOutput = Mapping[str, Any]  # Is a nested dict.
+PICO_TO_ANGSTROM = 0.01
+
+PDB_CHAIN_IDS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+PDB_MAX_CHAINS = len(PDB_CHAIN_IDS)
+assert(PDB_MAX_CHAINS == 62)
+
+
+@dataclasses.dataclass(frozen=True)
+class Protein:
+    """Protein structure representation."""
+
+    # Cartesian coordinates of atoms in angstroms. The atom types correspond to
+    # residue_constants.atom_types, i.e. the first three are N, CA, CB.
+    atom_positions: np.ndarray  # [num_res, num_atom_type, 3]
+
+    # Amino-acid type for each residue represented as an integer between 0 and
+    # 20, where 20 is 'X'.
+    aatype: np.ndarray  # [num_res]
+
+    # Binary float mask to indicate presence of a particular atom. 1.0 if an atom
+    # is present and 0.0 if not. This should be used for loss masking.
+    atom_mask: np.ndarray  # [num_res, num_atom_type]
+
+    # Residue index as used in PDB. It is not necessarily continuous or 0-indexed.
+    residue_index: np.ndarray  # [num_res]
+
+    # B-factors, or temperature factors, of each residue (in sq. angstroms units),
+    # representing the displacement of the residue from its ground truth mean
+    # value.
+    b_factors: np.ndarray  # [num_res, num_atom_type]
+
+    # Chain indices for multi-chain predictions
+    chain_index: Optional[np.ndarray] = None
+
+    # Optional remark about the protein. Included as a comment in output PDB
+    # files
+    remark: Optional[str] = None
+
+    # Templates used to generate this protein (prediction-only)
+    parents: Optional[Sequence[str]] = None
+
+    # Chain corresponding to each parent
+    parents_chain_index: Optional[Sequence[int]] = None
+
+    def __post_init__(self):
+        if(len(np.unique(self.chain_index)) > PDB_MAX_CHAINS):
+            raise ValueError(
+                f"Cannot build an instance with more than {PDB_MAX_CHAINS} "
+                "chains because these cannot be written to PDB format"
+            )
+
+
+def from_pdb_string(pdb_str: str, chain_id: Optional[str] = None) -> Protein:
+    """Takes a PDB string and constructs a Protein object.
+
+    WARNING: All non-standard residue types will be converted into UNK. All
+      non-standard atoms will be ignored.
+
+    Args:
+      pdb_str: The contents of the pdb file
+      chain_id: If None, then the whole pdb file is parsed. If chain_id is specified (e.g. A), then only that chain
+        is parsed.
+
+    Returns:
+      A new `Protein` parsed from the pdb contents.
+    """
+    pdb_fh = io.StringIO(pdb_str)
+    parser = PDBParser(QUIET=True)
+    structure = parser.get_structure("none", pdb_fh)
+    models = list(structure.get_models())
+    if len(models) != 1:
+        raise ValueError(
+            f"Only single model PDBs are supported. Found {len(models)} models."
+        )
+    model = models[0]
+
+    atom_positions = []
+    aatype = []
+    atom_mask = []
+    residue_index = []
+    chain_ids = []
+    b_factors = []
+
+    for chain in model:
+        if(chain_id is not None and chain.id != chain_id):
+            continue
+
+        for res in chain:
+            if res.id[2] != " ":
+                raise ValueError(
+                    f"PDB contains an insertion code at chain {chain.id} and residue "
+                    f"index {res.id[1]}. These are not supported."
+                )
+            res_shortname = residue_constants.restype_3to1.get(res.resname, "X")
+            restype_idx = residue_constants.restype_order.get(
+                res_shortname, residue_constants.restype_num
+            )
+            pos = np.zeros((residue_constants.atom_type_num, 3))
+            mask = np.zeros((residue_constants.atom_type_num,))
+            res_b_factors = np.zeros((residue_constants.atom_type_num,))
+            for atom in res:
+                if atom.name not in residue_constants.atom_types:
+                    continue
+                pos[residue_constants.atom_order[atom.name]] = atom.coord
+                mask[residue_constants.atom_order[atom.name]] = 1.0
+                res_b_factors[
+                    residue_constants.atom_order[atom.name]
+                ] = atom.bfactor
+            if np.sum(mask) < 0.5:
+                # If no known atom positions are reported for the residue then skip it.
+                continue
+
+            aatype.append(restype_idx)
+            atom_positions.append(pos)
+            atom_mask.append(mask)
+            residue_index.append(res.id[1])
+            chain_ids.append(chain.id)
+            b_factors.append(res_b_factors)
+
+    parents = None
+    parents_chain_index = None
+    if("PARENT" in pdb_str):
+        parents = []
+        parents_chain_index = []
+        chain_id = 0
+        for l in pdb_str.split("\n"):
+            if("PARENT" in l):
+                if(not "N/A" in l):
+                    parent_names = l.split()[1:]
+                    parents.extend(parent_names)
+                    parents_chain_index.extend([
+                        chain_id for _ in parent_names
+                    ])
+                chain_id += 1
+
+    unique_chain_ids = np.unique(chain_ids)
+    chain_id_mapping = {cid: n for n, cid in enumerate(string.ascii_uppercase)}
+    chain_index = np.array([chain_id_mapping[cid] for cid in chain_ids])
+
+    return Protein(
+        atom_positions=np.array(atom_positions),
+        atom_mask=np.array(atom_mask),
+        aatype=np.array(aatype),
+        residue_index=np.array(residue_index),
+        chain_index=chain_index,
+        b_factors=np.array(b_factors),
+        parents=parents,
+        parents_chain_index=parents_chain_index,
+    )
+
+
+def from_proteinnet_string(proteinnet_str: str) -> Protein:
+    tag_re = r'(\[[A-Z]+\]\n)'
+    tags = [
+        tag.strip() for tag in re.split(tag_re, proteinnet_str) if len(tag) > 0
+    ]
+    groups = zip(tags[0::2], [l.split('\n') for l in tags[1::2]])
+
+    atoms = ['N', 'CA', 'C']
+    aatype = None
+    atom_positions = None
+    atom_mask = None
+    for g in groups:
+        if("[PRIMARY]" == g[0]):
+            seq = g[1][0].strip()
+            for i in range(len(seq)):
+                if(seq[i] not in residue_constants.restypes):
+                    seq[i] = 'X'
+            aatype = np.array([
+                residue_constants.restype_order.get(
+                    res_symbol, residue_constants.restype_num
+                ) for res_symbol in seq
+            ])
+        elif("[TERTIARY]" == g[0]):
+            tertiary = []
+            for axis in range(3):
+                tertiary.append(list(map(float, g[1][axis].split())))
+            tertiary_np = np.array(tertiary)
+            atom_positions = np.zeros(
+                (len(tertiary[0])//3, residue_constants.atom_type_num, 3)
+            ).astype(np.float32)
+            for i, atom in enumerate(atoms):
+                atom_positions[:, residue_constants.atom_order[atom], :] = (
+                    np.transpose(tertiary_np[:, i::3])
+                )
+            atom_positions *= PICO_TO_ANGSTROM
+        elif("[MASK]" == g[0]):
+            mask = np.array(list(map({'-': 0, '+': 1}.get, g[1][0].strip())))
+            atom_mask = np.zeros(
+                (len(mask), residue_constants.atom_type_num,)
+            ).astype(np.float32)
+            for i, atom in enumerate(atoms):
+                atom_mask[:, residue_constants.atom_order[atom]] = 1
+            atom_mask *= mask[..., None]
+
+    return Protein(
+        atom_positions=atom_positions,
+        atom_mask=atom_mask,
+        aatype=aatype,
+        residue_index=np.arange(len(aatype)),
+        b_factors=None,
+    )
+
+
+def _chain_end(atom_index, end_resname, chain_name, residue_index) -> str:
+    chain_end = 'TER'
+    return(
+        f'{chain_end:<6}{atom_index:>5}      {end_resname:>3} '
+        f'{chain_name:>1}{residue_index:>4}'
+    )
+
+
+def get_pdb_headers(prot: Protein, chain_id: int = 0) -> Sequence[str]:
+    pdb_headers = []
+
+    remark = prot.remark
+    if(remark is not None):
+        pdb_headers.append(f"REMARK {remark}")
+
+    parents = prot.parents
+    parents_chain_index = prot.parents_chain_index
+    if(parents_chain_index is not None):
+        parents = [
+            p for i, p in zip(parents_chain_index, parents) if i == chain_id
+        ]
+
+    if(parents is None or len(parents) == 0):
+        parents = ["N/A"]
+
+    pdb_headers.append(f"PARENT {' '.join(parents)}")
+
+    return pdb_headers
+
+
+def add_pdb_headers(prot: Protein, pdb_str: str) -> str:
+    """ Add pdb headers to an existing PDB string. Useful during multi-chain
+        recycling
+    """
+    out_pdb_lines = []
+    lines = pdb_str.split('\n')
+
+    remark = prot.remark
+    if(remark is not None):
+        out_pdb_lines.append(f"REMARK {remark}")
+
+    parents_per_chain = None
+    if(prot.parents is not None and len(prot.parents) > 0):
+        parents_per_chain = []
+        if(prot.parents_chain_index is not None):
+            cur_chain = prot.parents_chain_index[0]
+            parent_dict = {}
+            for p, i in zip(prot.parents, prot.parents_chain_index):
+                parent_dict.setdefault(str(i), [])
+                parent_dict[str(i)].append(p)
+
+            max_idx = max([int(chain_idx) for chain_idx in parent_dict])
+            for i in range(max_idx + 1):
+                chain_parents = parent_dict.get(str(i), ["N/A"])
+                parents_per_chain.append(chain_parents)
+        else:
+            parents_per_chain.append(prot.parents)
+    else:
+        parents_per_chain = [["N/A"]]
+
+    make_parent_line = lambda p: f"PARENT {' '.join(p)}"
+
+    out_pdb_lines.append(make_parent_line(parents_per_chain[0]))
+
+    chain_counter = 0
+    for i, l in enumerate(lines):
+        if("PARENT" not in l and "REMARK" not in l):
+            out_pdb_lines.append(l)
+        if("TER" in l and not "END" in lines[i + 1]):
+            chain_counter += 1
+            if(not chain_counter >= len(parents_per_chain)):
+                chain_parents = parents_per_chain[chain_counter]
+            else:
+                chain_parents = ["N/A"]
+
+            out_pdb_lines.append(make_parent_line(chain_parents))
+
+    return '\n'.join(out_pdb_lines)
+
+
+def to_pdb(prot: Protein) -> str:
+    """Converts a `Protein` instance to a PDB string.
+
+    Args:
+      prot: The protein to convert to PDB.
+
+    Returns:
+      PDB string.
+    """
+    restypes = residue_constants.restypes + ["X"]
+    res_1to3 = lambda r: residue_constants.restype_1to3.get(restypes[r], "UNK")
+    atom_types = residue_constants.atom_types
+
+    pdb_lines = []
+
+    atom_mask = prot.atom_mask
+    aatype = prot.aatype
+    atom_positions = prot.atom_positions
+    residue_index = prot.residue_index.astype(np.int32)
+    b_factors = prot.b_factors
+    chain_index = prot.chain_index.astype(np.int32)
+
+    if np.any(aatype > residue_constants.restype_num):
+        raise ValueError("Invalid aatypes.")
+
+    # Construct a mapping from chain integer indices to chain ID strings.
+    chain_ids = {}
+    for i in np.unique(chain_index): # np.unique gives sorted output.
+        if i >= PDB_MAX_CHAINS:
+            raise ValueError(
+                f"The PDB format supports at most {PDB_MAX_CHAINS} chains."
+            )
+        chain_ids[i] = PDB_CHAIN_IDS[i]
+
+    headers = get_pdb_headers(prot)
+    if (len(headers) > 0):
+        pdb_lines.extend(headers)
+
+    pdb_lines.append("MODEL     1")
+    n = aatype.shape[0]
+    atom_index = 1
+    last_chain_index = chain_index[0]
+    prev_chain_index = 0
+    chain_tags = string.ascii_uppercase
+
+    # Add all atom sites.
+    for i in range(aatype.shape[0]):
+        # Close the previous chain if in a multichain PDB.
+        if last_chain_index != chain_index[i]:
+            pdb_lines.append(
+                _chain_end(
+                    atom_index, 
+                    res_1to3(aatype[i - 1]), 
+                    chain_ids[chain_index[i - 1]], 
+                    residue_index[i - 1]
+                )
+            )
+            last_chain_index = chain_index[i]
+            atom_index += 1 # Atom index increases at the TER symbol.
+
+        res_name_3 = res_1to3(aatype[i])
+        for atom_name, pos, mask, b_factor in zip(
+            atom_types, atom_positions[i], atom_mask[i], b_factors[i]
+        ):
+            if mask < 0.5:
+                continue
+
+            record_type = "ATOM"
+            name = atom_name if len(atom_name) == 4 else f" {atom_name}"
+            alt_loc = ""
+            insertion_code = ""
+            occupancy = 1.00
+            element = atom_name[
+                0
+            ]  # Protein supports only C, N, O, S, this works.
+            charge = ""
+
+            chain_tag = "A"
+            if(chain_index is not None):
+                chain_tag = chain_tags[chain_index[i]]
+
+            # PDB is a columnar format, every space matters here!
+            atom_line = (
+                f"{record_type:<6}{atom_index:>5} {name:<4}{alt_loc:>1}"
+                #TODO: check this refactor, chose main branch version
+                #f"{res_name_3:>3} {chain_ids[chain_index[i]]:>1}"
+                f"{res_name_3:>3} {chain_tag:>1}"
+                f"{residue_index[i]:>4}{insertion_code:>1}   "
+                f"{pos[0]:>8.3f}{pos[1]:>8.3f}{pos[2]:>8.3f}"
+                f"{occupancy:>6.2f}{b_factor:>6.2f}          "
+                f"{element:>2}{charge:>2}"
+            )
+            pdb_lines.append(atom_line)
+            atom_index += 1
+
+        should_terminate = (i == n - 1)
+        if(chain_index is not None):
+            if(i != n - 1 and chain_index[i + 1] != prev_chain_index):
+                should_terminate = True
+                prev_chain_index = chain_index[i + 1]
+
+        if(should_terminate):
+            # Close the chain.
+            chain_end = "TER"
+            chain_termination_line = (
+                f"{chain_end:<6}{atom_index:>5}      "
+                f"{res_1to3(aatype[i]):>3} "
+                f"{chain_tag:>1}{residue_index[i]:>4}"
+            )
+            pdb_lines.append(chain_termination_line)
+            atom_index += 1
+
+            if(i != n - 1):
+                # "prev" is a misnomer here. This happens at the beginning of
+                # each new chain.
+                pdb_lines.extend(get_pdb_headers(prot, prev_chain_index))
+
+    pdb_lines.append("ENDMDL")
+    pdb_lines.append("END")
+
+    # Pad all lines to 80 characters
+    pdb_lines = [line.ljust(80) for line in pdb_lines]
+    return '\n'.join(pdb_lines) + '\n' # Add terminating newline.
+
+
+def to_modelcif(prot: Protein) -> str:
+    """
+    Converts a `Protein` instance to a ModelCIF string. Chains with identical modelled coordinates
+    will be treated as the same polymer entity. But note that if chains differ in modelled regions,
+    no attempt is made at identifying them as a single polymer entity.
+
+    Args:
+      prot: The protein to convert to PDB.
+
+    Returns:
+      ModelCIF string.
+    """
+
+    restypes = residue_constants.restypes + ["X"]
+    atom_types = residue_constants.atom_types
+
+    atom_mask = prot.atom_mask
+    aatype = prot.aatype
+    atom_positions = prot.atom_positions
+    residue_index = prot.residue_index.astype(np.int32)
+    b_factors = prot.b_factors
+    chain_index = prot.chain_index
+
+    n = aatype.shape[0]
+    if chain_index is None:
+        chain_index = [0 for i in range(n)]
+
+    system = modelcif.System(title='OpenFold prediction')
+
+    # Finding chains and creating entities
+    seqs = {}
+    seq = []
+    last_chain_idx = None
+    for i in range(n):
+        if last_chain_idx is not None and last_chain_idx != chain_index[i]:
+            seqs[last_chain_idx] = seq
+            seq = []
+        seq.append(restypes[aatype[i]])
+        last_chain_idx = chain_index[i]
+    # finally add the last chain
+    seqs[last_chain_idx] = seq
+
+    # now reduce sequences to unique ones (note this won't work if different asyms have different unmodelled regions)
+    unique_seqs = {}
+    for chain_idx, seq_list in seqs.items():
+        seq = "".join(seq_list)
+        if seq in unique_seqs:
+            unique_seqs[seq].append(chain_idx)
+        else:
+            unique_seqs[seq] = [chain_idx]
+
+    # adding 1 entity per unique sequence
+    entities_map = {}
+    for key, value in unique_seqs.items():
+        model_e = modelcif.Entity(key, description='Model subunit')
+        for chain_idx in value:
+            entities_map[chain_idx] = model_e
+
+    chain_tags = string.ascii_uppercase
+    asym_unit_map = {}
+    for chain_idx in set(chain_index):
+        # Define the model assembly
+        chain_id = chain_tags[chain_idx]
+        asym = modelcif.AsymUnit(entities_map[chain_idx], details='Model subunit %s' % chain_id, id=chain_id)
+        asym_unit_map[chain_idx] = asym
+    modeled_assembly = modelcif.Assembly(asym_unit_map.values(), name='Modeled assembly')
+
+    class _LocalPLDDT(modelcif.qa_metric.Local, modelcif.qa_metric.PLDDT):
+        name = "pLDDT"
+        software = None
+        description = "Predicted lddt"
+
+    class _GlobalPLDDT(modelcif.qa_metric.Global, modelcif.qa_metric.PLDDT):
+        name = "pLDDT"
+        software = None
+        description = "Global pLDDT, mean of per-residue pLDDTs"
+
+    class _MyModel(modelcif.model.AbInitioModel):
+        def get_atoms(self):
+            # Add all atom sites.
+            for i in range(n):
+                for atom_name, pos, mask, b_factor in zip(
+                        atom_types, atom_positions[i], atom_mask[i], b_factors[i]
+                ):
+                    if mask < 0.5:
+                        continue
+                    element = atom_name[0]  # Protein supports only C, N, O, S, this works.
+                    yield modelcif.model.Atom(
+                        asym_unit=asym_unit_map[chain_index[i]], type_symbol=element,
+                        seq_id=residue_index[i], atom_id=atom_name,
+                        x=pos[0], y=pos[1], z=pos[2],
+                        het=False, biso=b_factor, occupancy=1.00)
+
+        def add_scores(self):
+            # local scores
+            plddt_per_residue = {}
+            for i in range(n):
+                for mask, b_factor in zip(atom_mask[i], b_factors[i]):
+                    if mask < 0.5:
+                        continue
+                    # add 1 per residue, not 1 per atom
+                    if chain_index[i] not in plddt_per_residue:
+                        # first time a chain index is seen: add the key and start the residue dict
+                        plddt_per_residue[chain_index[i]] = {residue_index[i]: b_factor}
+                    if residue_index[i] not in plddt_per_residue[chain_index[i]]:
+                        plddt_per_residue[chain_index[i]][residue_index[i]] = b_factor
+            plddts = []
+            for chain_idx in plddt_per_residue:
+                for residue_idx in plddt_per_residue[chain_idx]:
+                    plddt = plddt_per_residue[chain_idx][residue_idx]
+                    plddts.append(plddt)
+                    self.qa_metrics.append(
+                        _LocalPLDDT(asym_unit_map[chain_idx].residue(residue_idx), plddt))
+            # global score
+            self.qa_metrics.append((_GlobalPLDDT(np.mean(plddts))))
+
+    # Add the model and modeling protocol to the file and write them out:
+    model = _MyModel(assembly=modeled_assembly, name='Best scoring model')
+    model.add_scores()
+
+    model_group = modelcif.model.ModelGroup([model], name='All models')
+    system.model_groups.append(model_group)
+
+    fh = io.StringIO()
+    modelcif.dumper.write(fh, [system])
+    return fh.getvalue()
+
+
+def ideal_atom_mask(prot: Protein) -> np.ndarray:
+    """Computes an ideal atom mask.
+
+    `Protein.atom_mask` typically is defined according to the atoms that are
+    reported in the PDB. This function computes a mask according to heavy atoms
+    that should be present in the given sequence of amino acids.
+
+    Args:
+      prot: `Protein` whose fields are `numpy.ndarray` objects.
+
+    Returns:
+      An ideal atom mask.
+    """
+    return residue_constants.STANDARD_ATOM_MASK[prot.aatype]
+
+
+def from_prediction(
+    features: FeatureDict,
+    result: ModelOutput,
+    b_factors: Optional[np.ndarray] = None,
+    remove_leading_feature_dimension: bool = True,
+    remark: Optional[str] = None,
+    parents: Optional[Sequence[str]] = None,
+    parents_chain_index: Optional[Sequence[int]] = None
+) -> Protein:
+    """Assembles a protein from a prediction.
+
+    Args:
+      features: Dictionary holding model inputs.
+      result: Dictionary holding model outputs.
+      b_factors: (Optional) B-factors to use for the protein.
+      remove_leading_feature_dimension: Whether to remove the leading dimension 
+        of the `features` values
+      chain_index: (Optional) Chain indices for multi-chain predictions
+      remark: (Optional) Remark about the prediction
+      parents: (Optional) List of template names
+    Returns:
+      A protein instance.
+    """
+    def _maybe_remove_leading_dim(arr: np.ndarray) -> np.ndarray:
+        return arr[0] if remove_leading_feature_dimension else arr
+
+    if 'asym_id' in features:
+        chain_index = _maybe_remove_leading_dim(features["asym_id"]) - 1
+    else:
+        chain_index = np.zeros_like(
+            _maybe_remove_leading_dim(features["aatype"])
+        )
+
+    if b_factors is None:
+        b_factors = np.zeros_like(result["final_atom_mask"])
+
+    return Protein(
+        aatype=_maybe_remove_leading_dim(features["aatype"]),
+        atom_positions=result["final_atom_positions"],
+        atom_mask=result["final_atom_mask"],
+        residue_index=_maybe_remove_leading_dim(features["residue_index"]) + 1,
+        b_factors=b_factors,
+        chain_index=chain_index,
+        remark=remark,
+        parents=parents,
+        parents_chain_index=parents_chain_index,
+    )

data/mdgen/residue_constants.py

@@ -0,0 +1,1486 @@
+# Copyright 2021 AlQuraishi Laboratory
+# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Constants used in AlphaFold."""
+
+import collections
+import functools
+from typing import Mapping, List, Tuple
+from importlib import resources
+
+import numpy as np
+import tree
+
+
+# Distance from one CA to next CA [trans configuration: omega = 180].
+ca_ca = 3.80209737096
+
+# Format: The list for each AA type contains chi1, chi2, chi3, chi4 in
+# this order (or a relevant subset from chi1 onwards). ALA and GLY don't have
+# chi angles so their chi angle lists are empty.
+chi_angles_atoms = {
+    "ALA": [],
+    # Chi5 in arginine is always 0 +- 5 degrees, so ignore it.
+    "ARG": [
+        ["N", "CA", "CB", "CG"],
+        ["CA", "CB", "CG", "CD"],
+        ["CB", "CG", "CD", "NE"],
+        ["CG", "CD", "NE", "CZ"],
+    ],
+    "ASN": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "OD1"]],
+    "ASP": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "OD1"]],
+    "CYS": [["N", "CA", "CB", "SG"]],
+    "GLN": [
+        ["N", "CA", "CB", "CG"],
+        ["CA", "CB", "CG", "CD"],
+        ["CB", "CG", "CD", "OE1"],
+    ],
+    "GLU": [
+        ["N", "CA", "CB", "CG"],
+        ["CA", "CB", "CG", "CD"],
+        ["CB", "CG", "CD", "OE1"],
+    ],
+    "GLY": [],
+    "HIS": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "ND1"]],
+    "ILE": [["N", "CA", "CB", "CG1"], ["CA", "CB", "CG1", "CD1"]],
+    "LEU": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD1"]],
+    "LYS": [
+        ["N", "CA", "CB", "CG"],
+        ["CA", "CB", "CG", "CD"],
+        ["CB", "CG", "CD", "CE"],
+        ["CG", "CD", "CE", "NZ"],
+    ],
+    "MET": [
+        ["N", "CA", "CB", "CG"],
+        ["CA", "CB", "CG", "SD"],
+        ["CB", "CG", "SD", "CE"],
+    ],
+    "PHE": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD1"]],
+    "PRO": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD"]],
+    "SER": [["N", "CA", "CB", "OG"]],
+    "THR": [["N", "CA", "CB", "OG1"]],
+    "TRP": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD1"]],
+    "TYR": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD1"]],
+    "VAL": [["N", "CA", "CB", "CG1"]],
+}
+
+# If chi angles given in fixed-length array, this matrix determines how to mask
+# them for each AA type. The order is as per restype_order (see below).
+chi_angles_mask = [
+    [0.0, 0.0, 0.0, 0.0],  # ALA
+    [1.0, 1.0, 1.0, 1.0],  # ARG
+    [1.0, 1.0, 0.0, 0.0],  # ASN
+    [1.0, 1.0, 0.0, 0.0],  # ASP
+    [1.0, 0.0, 0.0, 0.0],  # CYS
+    [1.0, 1.0, 1.0, 0.0],  # GLN
+    [1.0, 1.0, 1.0, 0.0],  # GLU
+    [0.0, 0.0, 0.0, 0.0],  # GLY
+    [1.0, 1.0, 0.0, 0.0],  # HIS
+    [1.0, 1.0, 0.0, 0.0],  # ILE
+    [1.0, 1.0, 0.0, 0.0],  # LEU
+    [1.0, 1.0, 1.0, 1.0],  # LYS
+    [1.0, 1.0, 1.0, 0.0],  # MET
+    [1.0, 1.0, 0.0, 0.0],  # PHE
+    [1.0, 1.0, 0.0, 0.0],  # PRO
+    [1.0, 0.0, 0.0, 0.0],  # SER
+    [1.0, 0.0, 0.0, 0.0],  # THR
+    [1.0, 1.0, 0.0, 0.0],  # TRP
+    [1.0, 1.0, 0.0, 0.0],  # TYR
+    [1.0, 0.0, 0.0, 0.0],  # VAL
+]
+
+# The following chi angles are pi periodic: they can be rotated by a multiple
+# of pi without affecting the structure.
+chi_pi_periodic = [
+    [0.0, 0.0, 0.0, 0.0],  # ALA
+    [0.0, 0.0, 0.0, 0.0],  # ARG
+    [0.0, 0.0, 0.0, 0.0],  # ASN
+    [0.0, 1.0, 0.0, 0.0],  # ASP
+    [0.0, 0.0, 0.0, 0.0],  # CYS
+    [0.0, 0.0, 0.0, 0.0],  # GLN
+    [0.0, 0.0, 1.0, 0.0],  # GLU
+    [0.0, 0.0, 0.0, 0.0],  # GLY
+    [0.0, 0.0, 0.0, 0.0],  # HIS
+    [0.0, 0.0, 0.0, 0.0],  # ILE
+    [0.0, 0.0, 0.0, 0.0],  # LEU
+    [0.0, 0.0, 0.0, 0.0],  # LYS
+    [0.0, 0.0, 0.0, 0.0],  # MET
+    [0.0, 1.0, 0.0, 0.0],  # PHE
+    [0.0, 0.0, 0.0, 0.0],  # PRO
+    [0.0, 0.0, 0.0, 0.0],  # SER
+    [0.0, 0.0, 0.0, 0.0],  # THR
+    [0.0, 0.0, 0.0, 0.0],  # TRP
+    [0.0, 1.0, 0.0, 0.0],  # TYR
+    [0.0, 0.0, 0.0, 0.0],  # VAL
+    [0.0, 0.0, 0.0, 0.0],  # UNK
+]
+
+# Atoms positions relative to the 8 rigid groups, defined by the pre-omega, phi,
+# psi and chi angles:
+# 0: 'backbone group',
+# 1: 'pre-omega-group', (empty)
+# 2: 'phi-group', (currently empty, because it defines only hydrogens)
+# 3: 'psi-group',
+# 4,5,6,7: 'chi1,2,3,4-group'
+# The atom positions are relative to the axis-end-atom of the corresponding
+# rotation axis. The x-axis is in direction of the rotation axis, and the y-axis
+# is defined such that the dihedral-angle-definiting atom (the last entry in
+# chi_angles_atoms above) is in the xy-plane (with a positive y-coordinate).
+# format: [atomname, group_idx, rel_position]
+rigid_group_atom_positions = {
+    "ALA": [
+        ["N", 0, (-0.525, 1.363, 0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.526, -0.000, -0.000)],
+        ["CB", 0, (-0.529, -0.774, -1.205)],
+        ["O", 3, (0.627, 1.062, 0.000)],
+    ],
+    "ARG": [
+        ["N", 0, (-0.524, 1.362, -0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.525, -0.000, -0.000)],
+        ["CB", 0, (-0.524, -0.778, -1.209)],
+        ["O", 3, (0.626, 1.062, 0.000)],
+        ["CG", 4, (0.616, 1.390, -0.000)],
+        ["CD", 5, (0.564, 1.414, 0.000)],
+        ["NE", 6, (0.539, 1.357, -0.000)],
+        ["NH1", 7, (0.206, 2.301, 0.000)],
+        ["NH2", 7, (2.078, 0.978, -0.000)],
+        ["CZ", 7, (0.758, 1.093, -0.000)],
+    ],
+    "ASN": [
+        ["N", 0, (-0.536, 1.357, 0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.526, -0.000, -0.000)],
+        ["CB", 0, (-0.531, -0.787, -1.200)],
+        ["O", 3, (0.625, 1.062, 0.000)],
+        ["CG", 4, (0.584, 1.399, 0.000)],
+        ["ND2", 5, (0.593, -1.188, 0.001)],
+        ["OD1", 5, (0.633, 1.059, 0.000)],
+    ],
+    "ASP": [
+        ["N", 0, (-0.525, 1.362, -0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.527, 0.000, -0.000)],
+        ["CB", 0, (-0.526, -0.778, -1.208)],
+        ["O", 3, (0.626, 1.062, -0.000)],
+        ["CG", 4, (0.593, 1.398, -0.000)],
+        ["OD1", 5, (0.610, 1.091, 0.000)],
+        ["OD2", 5, (0.592, -1.101, -0.003)],
+    ],
+    "CYS": [
+        ["N", 0, (-0.522, 1.362, -0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.524, 0.000, 0.000)],
+        ["CB", 0, (-0.519, -0.773, -1.212)],
+        ["O", 3, (0.625, 1.062, -0.000)],
+        ["SG", 4, (0.728, 1.653, 0.000)],
+    ],
+    "GLN": [
+        ["N", 0, (-0.526, 1.361, -0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.526, 0.000, 0.000)],
+        ["CB", 0, (-0.525, -0.779, -1.207)],
+        ["O", 3, (0.626, 1.062, -0.000)],
+        ["CG", 4, (0.615, 1.393, 0.000)],
+        ["CD", 5, (0.587, 1.399, -0.000)],
+        ["NE2", 6, (0.593, -1.189, -0.001)],
+        ["OE1", 6, (0.634, 1.060, 0.000)],
+    ],
+    "GLU": [
+        ["N", 0, (-0.528, 1.361, 0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.526, -0.000, -0.000)],
+        ["CB", 0, (-0.526, -0.781, -1.207)],
+        ["O", 3, (0.626, 1.062, 0.000)],
+        ["CG", 4, (0.615, 1.392, 0.000)],
+        ["CD", 5, (0.600, 1.397, 0.000)],
+        ["OE1", 6, (0.607, 1.095, -0.000)],
+        ["OE2", 6, (0.589, -1.104, -0.001)],
+    ],
+    "GLY": [
+        ["N", 0, (-0.572, 1.337, 0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.517, -0.000, -0.000)],
+        ["O", 3, (0.626, 1.062, -0.000)],
+    ],
+    "HIS": [
+        ["N", 0, (-0.527, 1.360, 0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.525, 0.000, 0.000)],
+        ["CB", 0, (-0.525, -0.778, -1.208)],
+        ["O", 3, (0.625, 1.063, 0.000)],
+        ["CG", 4, (0.600, 1.370, -0.000)],
+        ["CD2", 5, (0.889, -1.021, 0.003)],
+        ["ND1", 5, (0.744, 1.160, -0.000)],
+        ["CE1", 5, (2.030, 0.851, 0.002)],
+        ["NE2", 5, (2.145, -0.466, 0.004)],
+    ],
+    "ILE": [
+        ["N", 0, (-0.493, 1.373, -0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.527, -0.000, -0.000)],
+        ["CB", 0, (-0.536, -0.793, -1.213)],
+        ["O", 3, (0.627, 1.062, -0.000)],
+        ["CG1", 4, (0.534, 1.437, -0.000)],
+        ["CG2", 4, (0.540, -0.785, -1.199)],
+        ["CD1", 5, (0.619, 1.391, 0.000)],
+    ],
+    "LEU": [
+        ["N", 0, (-0.520, 1.363, 0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.525, -0.000, -0.000)],
+        ["CB", 0, (-0.522, -0.773, -1.214)],
+        ["O", 3, (0.625, 1.063, -0.000)],
+        ["CG", 4, (0.678, 1.371, 0.000)],
+        ["CD1", 5, (0.530, 1.430, -0.000)],
+        ["CD2", 5, (0.535, -0.774, 1.200)],
+    ],
+    "LYS": [
+        ["N", 0, (-0.526, 1.362, -0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.526, 0.000, 0.000)],
+        ["CB", 0, (-0.524, -0.778, -1.208)],
+        ["O", 3, (0.626, 1.062, -0.000)],
+        ["CG", 4, (0.619, 1.390, 0.000)],
+        ["CD", 5, (0.559, 1.417, 0.000)],
+        ["CE", 6, (0.560, 1.416, 0.000)],
+        ["NZ", 7, (0.554, 1.387, 0.000)],
+    ],
+    "MET": [
+        ["N", 0, (-0.521, 1.364, -0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.525, 0.000, 0.000)],
+        ["CB", 0, (-0.523, -0.776, -1.210)],
+        ["O", 3, (0.625, 1.062, -0.000)],
+        ["CG", 4, (0.613, 1.391, -0.000)],
+        ["SD", 5, (0.703, 1.695, 0.000)],
+        ["CE", 6, (0.320, 1.786, -0.000)],
+    ],
+    "PHE": [
+        ["N", 0, (-0.518, 1.363, 0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.524, 0.000, -0.000)],
+        ["CB", 0, (-0.525, -0.776, -1.212)],
+        ["O", 3, (0.626, 1.062, -0.000)],
+        ["CG", 4, (0.607, 1.377, 0.000)],
+        ["CD1", 5, (0.709, 1.195, -0.000)],
+        ["CD2", 5, (0.706, -1.196, 0.000)],
+        ["CE1", 5, (2.102, 1.198, -0.000)],
+        ["CE2", 5, (2.098, -1.201, -0.000)],
+        ["CZ", 5, (2.794, -0.003, -0.001)],
+    ],
+    "PRO": [
+        ["N", 0, (-0.566, 1.351, -0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.527, -0.000, 0.000)],
+        ["CB", 0, (-0.546, -0.611, -1.293)],
+        ["O", 3, (0.621, 1.066, 0.000)],
+        ["CG", 4, (0.382, 1.445, 0.0)],
+        # ['CD', 5, (0.427, 1.440, 0.0)],
+        ["CD", 5, (0.477, 1.424, 0.0)],  # manually made angle 2 degrees larger
+    ],
+    "SER": [
+        ["N", 0, (-0.529, 1.360, -0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.525, -0.000, -0.000)],
+        ["CB", 0, (-0.518, -0.777, -1.211)],
+        ["O", 3, (0.626, 1.062, -0.000)],
+        ["OG", 4, (0.503, 1.325, 0.000)],
+    ],
+    "THR": [
+        ["N", 0, (-0.517, 1.364, 0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.526, 0.000, -0.000)],
+        ["CB", 0, (-0.516, -0.793, -1.215)],
+        ["O", 3, (0.626, 1.062, 0.000)],
+        ["CG2", 4, (0.550, -0.718, -1.228)],
+        ["OG1", 4, (0.472, 1.353, 0.000)],
+    ],
+    "TRP": [
+        ["N", 0, (-0.521, 1.363, 0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.525, -0.000, 0.000)],
+        ["CB", 0, (-0.523, -0.776, -1.212)],
+        ["O", 3, (0.627, 1.062, 0.000)],
+        ["CG", 4, (0.609, 1.370, -0.000)],
+        ["CD1", 5, (0.824, 1.091, 0.000)],
+        ["CD2", 5, (0.854, -1.148, -0.005)],
+        ["CE2", 5, (2.186, -0.678, -0.007)],
+        ["CE3", 5, (0.622, -2.530, -0.007)],
+        ["NE1", 5, (2.140, 0.690, -0.004)],
+        ["CH2", 5, (3.028, -2.890, -0.013)],
+        ["CZ2", 5, (3.283, -1.543, -0.011)],
+        ["CZ3", 5, (1.715, -3.389, -0.011)],
+    ],
+    "TYR": [
+        ["N", 0, (-0.522, 1.362, 0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.524, -0.000, -0.000)],
+        ["CB", 0, (-0.522, -0.776, -1.213)],
+        ["O", 3, (0.627, 1.062, -0.000)],
+        ["CG", 4, (0.607, 1.382, -0.000)],
+        ["CD1", 5, (0.716, 1.195, -0.000)],
+        ["CD2", 5, (0.713, -1.194, -0.001)],
+        ["CE1", 5, (2.107, 1.200, -0.002)],
+        ["CE2", 5, (2.104, -1.201, -0.003)],
+        ["OH", 5, (4.168, -0.002, -0.005)],
+        ["CZ", 5, (2.791, -0.001, -0.003)],
+    ],
+    "VAL": [
+        ["N", 0, (-0.494, 1.373, -0.000)],
+        ["CA", 0, (0.000, 0.000, 0.000)],
+        ["C", 0, (1.527, -0.000, -0.000)],
+        ["CB", 0, (-0.533, -0.795, -1.213)],
+        ["O", 3, (0.627, 1.062, -0.000)],
+        ["CG1", 4, (0.540, 1.429, -0.000)],
+        ["CG2", 4, (0.533, -0.776, 1.203)],
+    ],
+}
+
+# A list of atoms (excluding hydrogen) for each AA type. PDB naming convention.
+residue_atoms = {
+    "ALA": ["C", "CA", "CB", "N", "O"],
+    "ARG": ["C", "CA", "CB", "CG", "CD", "CZ", "N", "NE", "O", "NH1", "NH2"],
+    "ASP": ["C", "CA", "CB", "CG", "N", "O", "OD1", "OD2"],
+    "ASN": ["C", "CA", "CB", "CG", "N", "ND2", "O", "OD1"],
+    "CYS": ["C", "CA", "CB", "N", "O", "SG"],
+    "GLU": ["C", "CA", "CB", "CG", "CD", "N", "O", "OE1", "OE2"],
+    "GLN": ["C", "CA", "CB", "CG", "CD", "N", "NE2", "O", "OE1"],
+    "GLY": ["C", "CA", "N", "O"],
+    "HIS": ["C", "CA", "CB", "CG", "CD2", "CE1", "N", "ND1", "NE2", "O"],
+    "ILE": ["C", "CA", "CB", "CG1", "CG2", "CD1", "N", "O"],
+    "LEU": ["C", "CA", "CB", "CG", "CD1", "CD2", "N", "O"],
+    "LYS": ["C", "CA", "CB", "CG", "CD", "CE", "N", "NZ", "O"],
+    "MET": ["C", "CA", "CB", "CG", "CE", "N", "O", "SD"],
+    "PHE": ["C", "CA", "CB", "CG", "CD1", "CD2", "CE1", "CE2", "CZ", "N", "O"],
+    "PRO": ["C", "CA", "CB", "CG", "CD", "N", "O"],
+    "SER": ["C", "CA", "CB", "N", "O", "OG"],
+    "THR": ["C", "CA", "CB", "CG2", "N", "O", "OG1"],
+    "TRP": [
+        "C",
+        "CA",
+        "CB",
+        "CG",
+        "CD1",
+        "CD2",
+        "CE2",
+        "CE3",
+        "CZ2",
+        "CZ3",
+        "CH2",
+        "N",
+        "NE1",
+        "O",
+    ],
+    "TYR": [
+        "C",
+        "CA",
+        "CB",
+        "CG",
+        "CD1",
+        "CD2",
+        "CE1",
+        "CE2",
+        "CZ",
+        "N",
+        "O",
+        "OH",
+    ],
+    "VAL": ["C", "CA", "CB", "CG1", "CG2", "N", "O"],
+}
+
+# Naming swaps for ambiguous atom names.
+# Due to symmetries in the amino acids the naming of atoms is ambiguous in
+# 4 of the 20 amino acids.
+# (The LDDT paper lists 7 amino acids as ambiguous, but the naming ambiguities
+# in LEU, VAL and ARG can be resolved by using the 3d constellations of
+# the 'ambiguous' atoms and their neighbours)
+# Because for LEU, VAL and ARG, no ambiguous exist when the prediction output is chi angle instead of the location of individual atoms.
+# For the rest, ASP and others, when you rotate the bond 180 degree, you get the same configuraiton due to symmetry.
+
+residue_atom_renaming_swaps = {
+    "ASP": {"OD1": "OD2"},
+    "GLU": {"OE1": "OE2"},
+    "PHE": {"CD1": "CD2", "CE1": "CE2"},
+    "TYR": {"CD1": "CD2", "CE1": "CE2"},
+}
+
+# Van der Waals radii [Angstroem] of the atoms (from Wikipedia)
+van_der_waals_radius = {
+    "C": 1.7,
+    "N": 1.55,
+    "O": 1.52,
+    "S": 1.8,
+}
+
+Bond = collections.namedtuple(
+    "Bond", ["atom1_name", "atom2_name", "length", "stddev"]
+)
+BondAngle = collections.namedtuple(
+    "BondAngle",
+    ["atom1_name", "atom2_name", "atom3name", "angle_rad", "stddev"],
+)
+
+
+@functools.lru_cache(maxsize=None)
+def load_stereo_chemical_props() -> Tuple[
+    Mapping[str, List[Bond]],
+    Mapping[str, List[Bond]],
+    Mapping[str, List[BondAngle]],
+]:
+    """Load stereo_chemical_props.txt into a nice structure.
+
+    Load literature values for bond lengths and bond angles and translate
+    bond angles into the length of the opposite edge of the triangle
+    ("residue_virtual_bonds").
+
+    Returns:
+      residue_bonds:  Dict that maps resname -> list of Bond tuples
+      residue_virtual_bonds: Dict that maps resname -> list of Bond tuples
+      residue_bond_angles: Dict that maps resname -> list of BondAngle tuples
+    """
+    # TODO: this file should be downloaded in a setup script
+    stereo_chemical_props = resources.read_text("openfold.resources", "stereo_chemical_props.txt")
+
+    lines_iter = iter(stereo_chemical_props.splitlines())
+    # Load bond lengths.
+    residue_bonds = {}
+    next(lines_iter)  # Skip header line.
+    for line in lines_iter:
+        if line.strip() == "-":
+            break
+        bond, resname, length, stddev = line.split()
+        atom1, atom2 = bond.split("-")
+        if resname not in residue_bonds:
+            residue_bonds[resname] = []
+        residue_bonds[resname].append(
+            Bond(atom1, atom2, float(length), float(stddev))
+        )
+    residue_bonds["UNK"] = []
+
+    # Load bond angles.
+    residue_bond_angles = {}
+    next(lines_iter)  # Skip empty line.
+    next(lines_iter)  # Skip header line.
+    for line in lines_iter:
+        if line.strip() == "-":
+            break
+        bond, resname, angle_degree, stddev_degree = line.split()
+        atom1, atom2, atom3 = bond.split("-")
+        if resname not in residue_bond_angles:
+            residue_bond_angles[resname] = []
+        residue_bond_angles[resname].append(
+            BondAngle(
+                atom1,
+                atom2,
+                atom3,
+                float(angle_degree) / 180.0 * np.pi,
+                float(stddev_degree) / 180.0 * np.pi,
+            )
+        )
+    residue_bond_angles["UNK"] = []
+
+    def make_bond_key(atom1_name, atom2_name):
+        """Unique key to lookup bonds."""
+        return "-".join(sorted([atom1_name, atom2_name]))
+
+    # Translate bond angles into distances ("virtual bonds").
+    residue_virtual_bonds = {}
+    for resname, bond_angles in residue_bond_angles.items():
+        # Create a fast lookup dict for bond lengths.
+        bond_cache = {}
+        for b in residue_bonds[resname]:
+            bond_cache[make_bond_key(b.atom1_name, b.atom2_name)] = b
+        residue_virtual_bonds[resname] = []
+        for ba in bond_angles:
+            bond1 = bond_cache[make_bond_key(ba.atom1_name, ba.atom2_name)]
+            bond2 = bond_cache[make_bond_key(ba.atom2_name, ba.atom3name)]
+
+            # Compute distance between atom1 and atom3 using the law of cosines
+            # c^2 = a^2 + b^2 - 2ab*cos(gamma).
+            gamma = ba.angle_rad
+            length = np.sqrt(
+                bond1.length ** 2
+                + bond2.length ** 2
+                - 2 * bond1.length * bond2.length * np.cos(gamma)
+            )
+
+            # Propagation of uncertainty assuming uncorrelated errors.
+            dl_outer = 0.5 / length
+            dl_dgamma = (
+                2 * bond1.length * bond2.length * np.sin(gamma)
+            ) * dl_outer
+            dl_db1 = (
+                2 * bond1.length - 2 * bond2.length * np.cos(gamma)
+            ) * dl_outer
+            dl_db2 = (
+                2 * bond2.length - 2 * bond1.length * np.cos(gamma)
+            ) * dl_outer
+            stddev = np.sqrt(
+                (dl_dgamma * ba.stddev) ** 2
+                + (dl_db1 * bond1.stddev) ** 2
+                + (dl_db2 * bond2.stddev) ** 2
+            )
+            residue_virtual_bonds[resname].append(
+                Bond(ba.atom1_name, ba.atom3name, length, stddev)
+            )
+
+    return (residue_bonds, residue_virtual_bonds, residue_bond_angles)
+
+
+# Between-residue bond lengths for general bonds (first element) and for Proline
+# (second element).
+between_res_bond_length_c_n = [1.329, 1.341]
+between_res_bond_length_stddev_c_n = [0.014, 0.016]
+
+# Between-residue cos_angles.
+between_res_cos_angles_c_n_ca = [-0.5203, 0.0353]  # degrees: 121.352 +- 2.315
+between_res_cos_angles_ca_c_n = [-0.4473, 0.0311]  # degrees: 116.568 +- 1.995
+
+# This mapping is used when we need to store atom data in a format that requires
+# fixed atom data size for every residue (e.g. a numpy array).
+atom_types = [
+    "N",
+    "CA",
+    "C",
+    "CB",
+    "O",
+    "CG",
+    "CG1",
+    "CG2",
+    "OG",
+    "OG1",
+    "SG",
+    "CD",
+    "CD1",
+    "CD2",
+    "ND1",
+    "ND2",
+    "OD1",
+    "OD2",
+    "SD",
+    "CE",
+    "CE1",
+    "CE2",
+    "CE3",
+    "NE",
+    "NE1",
+    "NE2",
+    "OE1",
+    "OE2",
+    "CH2",
+    "NH1",
+    "NH2",
+    "OH",
+    "CZ",
+    "CZ2",
+    "CZ3",
+    "NZ",
+    "OXT",
+]
+atom_order = {atom_type: i for i, atom_type in enumerate(atom_types)}
+atom_type_num = len(atom_types)  # := 37.
+
+# A compact atom encoding with 14 columns
+# pylint: disable=line-too-long
+# pylint: disable=bad-whitespace
+restype_name_to_atom14_names = {
+    "ALA": ["N", "CA", "C", "O", "CB", "", "", "", "", "", "", "", "", ""],
+    "ARG": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG",
+        "CD",
+        "NE",
+        "CZ",
+        "NH1",
+        "NH2",
+        "",
+        "",
+        "",
+    ],
+    "ASN": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG",
+        "OD1",
+        "ND2",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+    ],
+    "ASP": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG",
+        "OD1",
+        "OD2",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+    ],
+    "CYS": ["N", "CA", "C", "O", "CB", "SG", "", "", "", "", "", "", "", ""],
+    "GLN": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG",
+        "CD",
+        "OE1",
+        "NE2",
+        "",
+        "",
+        "",
+        "",
+        "",
+    ],
+    "GLU": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG",
+        "CD",
+        "OE1",
+        "OE2",
+        "",
+        "",
+        "",
+        "",
+        "",
+    ],
+    "GLY": ["N", "CA", "C", "O", "", "", "", "", "", "", "", "", "", ""],
+    "HIS": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG",
+        "ND1",
+        "CD2",
+        "CE1",
+        "NE2",
+        "",
+        "",
+        "",
+        "",
+    ],
+    "ILE": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG1",
+        "CG2",
+        "CD1",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+    ],
+    "LEU": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG",
+        "CD1",
+        "CD2",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+    ],
+    "LYS": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG",
+        "CD",
+        "CE",
+        "NZ",
+        "",
+        "",
+        "",
+        "",
+        "",
+    ],
+    "MET": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG",
+        "SD",
+        "CE",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+    ],
+    "PHE": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG",
+        "CD1",
+        "CD2",
+        "CE1",
+        "CE2",
+        "CZ",
+        "",
+        "",
+        "",
+    ],
+    "PRO": ["N", "CA", "C", "O", "CB", "CG", "CD", "", "", "", "", "", "", ""],
+    "SER": ["N", "CA", "C", "O", "CB", "OG", "", "", "", "", "", "", "", ""],
+    "THR": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "OG1",
+        "CG2",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+    ],
+    "TRP": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG",
+        "CD1",
+        "CD2",
+        "NE1",
+        "CE2",
+        "CE3",
+        "CZ2",
+        "CZ3",
+        "CH2",
+    ],
+    "TYR": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG",
+        "CD1",
+        "CD2",
+        "CE1",
+        "CE2",
+        "CZ",
+        "OH",
+        "",
+        "",
+    ],
+    "VAL": [
+        "N",
+        "CA",
+        "C",
+        "O",
+        "CB",
+        "CG1",
+        "CG2",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+    ],
+    "UNK": ["", "", "", "", "", "", "", "", "", "", "", "", "", ""],
+}
+# pylint: enable=line-too-long
+# pylint: enable=bad-whitespace
+
+
+# This is the standard residue order when coding AA type as a number.
+# Reproduce it by taking 3-letter AA codes and sorting them alphabetically.
+restypes = [
+    "A",
+    "R",
+    "N",
+    "D",
+    "C",
+    "Q",
+    "E",
+    "G",
+    "H",
+    "I",
+    "L",
+    "K",
+    "M",
+    "F",
+    "P",
+    "S",
+    "T",
+    "W",
+    "Y",
+    "V",
+]
+restype_order = {restype: i for i, restype in enumerate(restypes)}
+restype_num = len(restypes)  # := 20.
+unk_restype_index = restype_num  # Catch-all index for unknown restypes.
+
+restypes_with_x = restypes + ["X"]
+restype_order_with_x = {restype: i for i, restype in enumerate(restypes_with_x)}
+
+
+def sequence_to_onehot(
+    sequence: str, mapping: Mapping[str, int], map_unknown_to_x: bool = False
+) -> np.ndarray:
+    """Maps the given sequence into a one-hot encoded matrix.
+
+    Args:
+      sequence: An amino acid sequence.
+      mapping: A dictionary mapping amino acids to integers.
+      map_unknown_to_x: If True, any amino acid that is not in the mapping will be
+        mapped to the unknown amino acid 'X'. If the mapping doesn't contain
+        amino acid 'X', an error will be thrown. If False, any amino acid not in
+        the mapping will throw an error.
+
+    Returns:
+      A numpy array of shape (seq_len, num_unique_aas) with one-hot encoding of
+      the sequence.
+
+    Raises:
+      ValueError: If the mapping doesn't contain values from 0 to
+        num_unique_aas - 1 without any gaps.
+    """
+    num_entries = max(mapping.values()) + 1
+
+    if sorted(set(mapping.values())) != list(range(num_entries)):
+        raise ValueError(
+            "The mapping must have values from 0 to num_unique_aas-1 "
+            "without any gaps. Got: %s" % sorted(mapping.values())
+        )
+
+    one_hot_arr = np.zeros((len(sequence), num_entries), dtype=np.int32)
+
+    for aa_index, aa_type in enumerate(sequence):
+        if map_unknown_to_x:
+            if aa_type.isalpha() and aa_type.isupper():
+                aa_id = mapping.get(aa_type, mapping["X"])
+            else:
+                raise ValueError(
+                    f"Invalid character in the sequence: {aa_type}"
+                )
+        else:
+            aa_id = mapping[aa_type]
+        one_hot_arr[aa_index, aa_id] = 1
+
+    return one_hot_arr
+
+
+restype_1to3 = {
+    "A": "ALA",
+    "R": "ARG",
+    "N": "ASN",
+    "D": "ASP",
+    "C": "CYS",
+    "Q": "GLN",
+    "E": "GLU",
+    "G": "GLY",
+    "H": "HIS",
+    "I": "ILE",
+    "L": "LEU",
+    "K": "LYS",
+    "M": "MET",
+    "F": "PHE",
+    "P": "PRO",
+    "S": "SER",
+    "T": "THR",
+    "W": "TRP",
+    "Y": "TYR",
+    "V": "VAL",
+}
+
+
+# NB: restype_3to1 differs from Bio.PDB.protein_letters_3to1 by being a simple
+# 1-to-1 mapping of 3 letter names to one letter names. The latter contains
+# many more, and less common, three letter names as keys and maps many of these
+# to the same one letter name (including 'X' and 'U' which we don't use here).
+restype_3to1 = {v: k for k, v in restype_1to3.items()}
+
+# Define a restype name for all unknown residues.
+unk_restype = "UNK"
+
+resnames = [restype_1to3[r] for r in restypes] + [unk_restype]
+resname_to_idx = {resname: i for i, resname in enumerate(resnames)}
+
+
+# The mapping here uses hhblits convention, so that B is mapped to D, J and O
+# are mapped to X, U is mapped to C, and Z is mapped to E. Other than that the
+# remaining 20 amino acids are kept in alphabetical order.
+# There are 2 non-amino acid codes, X (representing any amino acid) and
+# "-" representing a missing amino acid in an alignment.  The id for these
+# codes is put at the end (20 and 21) so that they can easily be ignored if
+# desired.
+HHBLITS_AA_TO_ID = {
+    "A": 0,
+    "B": 2,
+    "C": 1,
+    "D": 2,
+    "E": 3,
+    "F": 4,
+    "G": 5,
+    "H": 6,
+    "I": 7,
+    "J": 20,
+    "K": 8,
+    "L": 9,
+    "M": 10,
+    "N": 11,
+    "O": 20,
+    "P": 12,
+    "Q": 13,
+    "R": 14,
+    "S": 15,
+    "T": 16,
+    "U": 1,
+    "V": 17,
+    "W": 18,
+    "X": 20,
+    "Y": 19,
+    "Z": 3,
+    "-": 21,
+}
+
+# Partial inversion of HHBLITS_AA_TO_ID.
+ID_TO_HHBLITS_AA = {
+    0: "A",
+    1: "C",  # Also U.
+    2: "D",  # Also B.
+    3: "E",  # Also Z.
+    4: "F",
+    5: "G",
+    6: "H",
+    7: "I",
+    8: "K",
+    9: "L",
+    10: "M",
+    11: "N",
+    12: "P",
+    13: "Q",
+    14: "R",
+    15: "S",
+    16: "T",
+    17: "V",
+    18: "W",
+    19: "Y",
+    20: "X",  # Includes J and O.
+    21: "-",
+}
+
+restypes_with_x_and_gap = restypes + ["X", "-"]
+MAP_HHBLITS_AATYPE_TO_OUR_AATYPE = tuple(
+    restypes_with_x_and_gap.index(ID_TO_HHBLITS_AA[i])
+    for i in range(len(restypes_with_x_and_gap))
+)
+
+
+def _make_standard_atom_mask() -> np.ndarray:
+    """Returns [num_res_types, num_atom_types] mask array."""
+    # +1 to account for unknown (all 0s).
+    mask = np.zeros([restype_num + 1, atom_type_num], dtype=np.int32)
+    for restype, restype_letter in enumerate(restypes):
+        restype_name = restype_1to3[restype_letter]
+        atom_names = residue_atoms[restype_name]
+        for atom_name in atom_names:
+            atom_type = atom_order[atom_name]
+            mask[restype, atom_type] = 1
+    return mask
+
+
+STANDARD_ATOM_MASK = _make_standard_atom_mask()
+
+
+# A one hot representation for the first and second atoms defining the axis
+# of rotation for each chi-angle in each residue.
+def chi_angle_atom(atom_index: int) -> np.ndarray:
+    """Define chi-angle rigid groups via one-hot representations."""
+    chi_angles_index = {}
+    one_hots = []
+
+    for k, v in chi_angles_atoms.items():
+        indices = [atom_types.index(s[atom_index]) for s in v]
+        indices.extend([-1] * (4 - len(indices)))
+        chi_angles_index[k] = indices
+
+    for r in restypes:
+        res3 = restype_1to3[r]
+        one_hot = np.eye(atom_type_num)[chi_angles_index[res3]]
+        one_hots.append(one_hot)
+
+    one_hots.append(np.zeros([4, atom_type_num]))  # Add zeros for residue `X`.
+    one_hot = np.stack(one_hots, axis=0)
+    one_hot = np.transpose(one_hot, [0, 2, 1])
+
+    return one_hot
+
+
+chi_atom_1_one_hot = chi_angle_atom(1)
+chi_atom_2_one_hot = chi_angle_atom(2)
+
+# An array like chi_angles_atoms but using indices rather than names.
+chi_angles_atom_indices = [chi_angles_atoms[restype_1to3[r]] for r in restypes]
+chi_angles_atom_indices = tree.map_structure(
+    lambda atom_name: atom_order[atom_name], chi_angles_atom_indices
+)
+chi_angles_atom_indices = np.array(
+    [
+        chi_atoms + ([[0, 0, 0, 0]] * (4 - len(chi_atoms)))
+        for chi_atoms in chi_angles_atom_indices
+    ]
+)
+
+# Mapping from (res_name, atom_name) pairs to the atom's chi group index
+# and atom index within that group.
+chi_groups_for_atom = collections.defaultdict(list)
+for res_name, chi_angle_atoms_for_res in chi_angles_atoms.items():
+    for chi_group_i, chi_group in enumerate(chi_angle_atoms_for_res):
+        for atom_i, atom in enumerate(chi_group):
+            chi_groups_for_atom[(res_name, atom)].append((chi_group_i, atom_i))
+chi_groups_for_atom = dict(chi_groups_for_atom)
+
+
+def _make_rigid_transformation_4x4(ex, ey, translation):
+    """Create a rigid 4x4 transformation matrix from two axes and transl."""
+    # Normalize ex.
+    ex_normalized = ex / np.linalg.norm(ex)
+
+    # make ey perpendicular to ex
+    ey_normalized = ey - np.dot(ey, ex_normalized) * ex_normalized
+    ey_normalized /= np.linalg.norm(ey_normalized)
+
+    # compute ez as cross product
+    eznorm = np.cross(ex_normalized, ey_normalized)
+    m = np.stack(
+        [ex_normalized, ey_normalized, eznorm, translation]
+    ).transpose()
+    m = np.concatenate([m, [[0.0, 0.0, 0.0, 1.0]]], axis=0)
+    return m
+
+
+# create an array with (restype, atomtype) --> rigid_group_idx
+# and an array with (restype, atomtype, coord) for the atom positions
+# and compute affine transformation matrices (4,4) from one rigid group to the
+# previous group
+restype_atom37_to_rigid_group = np.zeros([21, 37], dtype=int)
+restype_atom37_mask = np.zeros([21, 37], dtype=np.float32)
+restype_atom37_rigid_group_positions = np.zeros([21, 37, 3], dtype=np.float32)
+restype_atom14_to_rigid_group = np.zeros([21, 14], dtype=int)
+restype_atom14_mask = np.zeros([21, 14], dtype=np.float32)
+restype_atom14_rigid_group_positions = np.zeros([21, 14, 3], dtype=np.float32)
+restype_rigid_group_default_frame = np.zeros([21, 8, 4, 4], dtype=np.float32)
+
+
+def _make_rigid_group_constants():
+    """Fill the arrays above."""
+    for restype, restype_letter in enumerate(restypes):
+        resname = restype_1to3[restype_letter]
+        for atomname, group_idx, atom_position in rigid_group_atom_positions[
+            resname
+        ]:
+            atomtype = atom_order[atomname]
+            restype_atom37_to_rigid_group[restype, atomtype] = group_idx
+            restype_atom37_mask[restype, atomtype] = 1
+            restype_atom37_rigid_group_positions[
+                restype, atomtype, :
+            ] = atom_position
+
+            atom14idx = restype_name_to_atom14_names[resname].index(atomname)
+            restype_atom14_to_rigid_group[restype, atom14idx] = group_idx
+            restype_atom14_mask[restype, atom14idx] = 1
+            restype_atom14_rigid_group_positions[
+                restype, atom14idx, :
+            ] = atom_position
+
+    for restype, restype_letter in enumerate(restypes):
+        resname = restype_1to3[restype_letter]
+        atom_positions = {
+            name: np.array(pos)
+            for name, _, pos in rigid_group_atom_positions[resname]
+        }
+
+        # backbone to backbone is the identity transform
+        restype_rigid_group_default_frame[restype, 0, :, :] = np.eye(4)
+
+        # pre-omega-frame to backbone (currently dummy identity matrix)
+        restype_rigid_group_default_frame[restype, 1, :, :] = np.eye(4)
+
+        # phi-frame to backbone
+        mat = _make_rigid_transformation_4x4(
+            ex=atom_positions["N"] - atom_positions["CA"],
+            ey=np.array([1.0, 0.0, 0.0]),
+            translation=atom_positions["N"],
+        )
+        restype_rigid_group_default_frame[restype, 2, :, :] = mat
+
+        # psi-frame to backbone
+        mat = _make_rigid_transformation_4x4(
+            ex=atom_positions["C"] - atom_positions["CA"],
+            ey=atom_positions["CA"] - atom_positions["N"],
+            translation=atom_positions["C"],
+        )
+        restype_rigid_group_default_frame[restype, 3, :, :] = mat
+
+        # chi1-frame to backbone
+        if chi_angles_mask[restype][0]:
+            base_atom_names = chi_angles_atoms[resname][0]
+            base_atom_positions = [
+                atom_positions[name] for name in base_atom_names
+            ]
+            mat = _make_rigid_transformation_4x4(
+                ex=base_atom_positions[2] - base_atom_positions[1],
+                ey=base_atom_positions[0] - base_atom_positions[1],
+                translation=base_atom_positions[2],
+            )
+            restype_rigid_group_default_frame[restype, 4, :, :] = mat
+
+        # chi2-frame to chi1-frame
+        # chi3-frame to chi2-frame
+        # chi4-frame to chi3-frame
+        # luckily all rotation axes for the next frame start at (0,0,0) of the
+        # previous frame
+        for chi_idx in range(1, 4):
+            if chi_angles_mask[restype][chi_idx]:
+                axis_end_atom_name = chi_angles_atoms[resname][chi_idx][2]
+                axis_end_atom_position = atom_positions[axis_end_atom_name]
+                mat = _make_rigid_transformation_4x4(
+                    ex=axis_end_atom_position,
+                    ey=np.array([-1.0, 0.0, 0.0]),
+                    translation=axis_end_atom_position,
+                )
+                restype_rigid_group_default_frame[
+                    restype, 4 + chi_idx, :, :
+                ] = mat
+
+
+_make_rigid_group_constants()
+
+
+def make_atom14_dists_bounds(
+    overlap_tolerance=1.5, bond_length_tolerance_factor=15
+):
+    """compute upper and lower bounds for bonds to assess violations."""
+    restype_atom14_bond_lower_bound = np.zeros([21, 14, 14], np.float32)
+    restype_atom14_bond_upper_bound = np.zeros([21, 14, 14], np.float32)
+    restype_atom14_bond_stddev = np.zeros([21, 14, 14], np.float32)
+    residue_bonds, residue_virtual_bonds, _ = load_stereo_chemical_props()
+    for restype, restype_letter in enumerate(restypes):
+        resname = restype_1to3[restype_letter]
+        atom_list = restype_name_to_atom14_names[resname]
+
+        # create lower and upper bounds for clashes
+        for atom1_idx, atom1_name in enumerate(atom_list):
+            if not atom1_name:
+                continue
+            atom1_radius = van_der_waals_radius[atom1_name[0]]
+            for atom2_idx, atom2_name in enumerate(atom_list):
+                if (not atom2_name) or atom1_idx == atom2_idx:
+                    continue
+                atom2_radius = van_der_waals_radius[atom2_name[0]]
+                lower = atom1_radius + atom2_radius - overlap_tolerance
+                upper = 1e10
+                restype_atom14_bond_lower_bound[
+                    restype, atom1_idx, atom2_idx
+                ] = lower
+                restype_atom14_bond_lower_bound[
+                    restype, atom2_idx, atom1_idx
+                ] = lower
+                restype_atom14_bond_upper_bound[
+                    restype, atom1_idx, atom2_idx
+                ] = upper
+                restype_atom14_bond_upper_bound[
+                    restype, atom2_idx, atom1_idx
+                ] = upper
+
+        # overwrite lower and upper bounds for bonds and angles
+        for b in residue_bonds[resname] + residue_virtual_bonds[resname]:
+            atom1_idx = atom_list.index(b.atom1_name)
+            atom2_idx = atom_list.index(b.atom2_name)
+            lower = b.length - bond_length_tolerance_factor * b.stddev
+            upper = b.length + bond_length_tolerance_factor * b.stddev
+            restype_atom14_bond_lower_bound[
+                restype, atom1_idx, atom2_idx
+            ] = lower
+            restype_atom14_bond_lower_bound[
+                restype, atom2_idx, atom1_idx
+            ] = lower
+            restype_atom14_bond_upper_bound[
+                restype, atom1_idx, atom2_idx
+            ] = upper
+            restype_atom14_bond_upper_bound[
+                restype, atom2_idx, atom1_idx
+            ] = upper
+            restype_atom14_bond_stddev[restype, atom1_idx, atom2_idx] = b.stddev
+            restype_atom14_bond_stddev[restype, atom2_idx, atom1_idx] = b.stddev
+    return {
+        "lower_bound": restype_atom14_bond_lower_bound,  # shape (21,14,14)
+        "upper_bound": restype_atom14_bond_upper_bound,  # shape (21,14,14)
+        "stddev": restype_atom14_bond_stddev,  # shape (21,14,14)
+    }
+
+
+restype_atom14_ambiguous_atoms = np.zeros((21, 14), dtype=np.float32)
+restype_atom14_ambiguous_atoms_swap_idx = np.tile(
+    np.arange(14, dtype=int), (21, 1)
+)
+
+
+def _make_atom14_ambiguity_feats():
+    for res, pairs in residue_atom_renaming_swaps.items():
+        res_idx = restype_order[restype_3to1[res]]
+        for atom1, atom2 in pairs.items():
+            atom1_idx = restype_name_to_atom14_names[res].index(atom1)
+            atom2_idx = restype_name_to_atom14_names[res].index(atom2)
+            restype_atom14_ambiguous_atoms[res_idx, atom1_idx] = 1
+            restype_atom14_ambiguous_atoms[res_idx, atom2_idx] = 1
+            restype_atom14_ambiguous_atoms_swap_idx[
+                res_idx, atom1_idx
+            ] = atom2_idx
+            restype_atom14_ambiguous_atoms_swap_idx[
+                res_idx, atom2_idx
+            ] = atom1_idx
+
+
+_make_atom14_ambiguity_feats()
+
+
+def aatype_to_str_sequence(aatype):
+    return ''.join([
+        restypes_with_x[aatype[i]] 
+        for i in range(len(aatype))
+    ])
+
+
+### ALPHAFOLD MULTIMER STUFF ###    
+def _make_chi_atom_indices():
+  """Returns atom indices needed to compute chi angles for all residue types.
+
+  Returns:
+    A tensor of shape [residue_types=21, chis=4, atoms=4]. The residue types are
+    in the order specified in residue_constants.restypes + unknown residue type
+    at the end. For chi angles which are not defined on the residue, the
+    positions indices are by default set to 0.
+  """
+  chi_atom_indices = []
+  for residue_name in restypes:
+    residue_name = restype_1to3[residue_name]
+    residue_chi_angles = chi_angles_atoms[residue_name]
+    atom_indices = []
+    for chi_angle in residue_chi_angles:
+      atom_indices.append(
+          [atom_order[atom] for atom in chi_angle])
+    for _ in range(4 - len(atom_indices)):
+      atom_indices.append([0, 0, 0, 0])  # For chi angles not defined on the AA.
+    chi_atom_indices.append(atom_indices)
+
+  chi_atom_indices.append([[0, 0, 0, 0]] * 4)  # For UNKNOWN residue.
+
+  return np.array(chi_atom_indices)
+
+
+def _make_renaming_matrices():
+  """Matrices to map atoms to symmetry partners in ambiguous case."""
+  # As the atom naming is ambiguous for 7 of the 20 amino acids, provide
+  # alternative groundtruth coordinates where the naming is swapped
+  restype_3 = [
+      restype_1to3[res] for res in restypes
+  ]
+  restype_3 += ['UNK']
+  # Matrices for renaming ambiguous atoms.
+  all_matrices = {res: np.eye(14, dtype=np.float32) for res in restype_3}
+  for resname, swap in residue_atom_renaming_swaps.items():
+    correspondences = np.arange(14)
+    for source_atom_swap, target_atom_swap in swap.items():
+      source_index = restype_name_to_atom14_names[
+          resname].index(source_atom_swap)
+      target_index = restype_name_to_atom14_names[
+          resname].index(target_atom_swap)
+      correspondences[source_index] = target_index
+      correspondences[target_index] = source_index
+      renaming_matrix = np.zeros((14, 14), dtype=np.float32)
+      for index, correspondence in enumerate(correspondences):
+        renaming_matrix[index, correspondence] = 1.
+    all_matrices[resname] = renaming_matrix.astype(np.float32)
+  renaming_matrices = np.stack([all_matrices[restype] for restype in restype_3])
+  return renaming_matrices
+
+
+def _make_restype_atom37_mask():
+  """Mask of which atoms are present for which residue type in atom37."""
+  # create the corresponding mask
+  restype_atom37_mask = np.zeros([21, 37], dtype=np.float32)
+  for restype, restype_letter in enumerate(restypes):
+    restype_name = restype_1to3[restype_letter]
+    atom_names = residue_atoms[restype_name]
+    for atom_name in atom_names:
+      atom_type = atom_order[atom_name]
+      restype_atom37_mask[restype, atom_type] = 1
+  return restype_atom37_mask
+
+
+def _make_restype_atom14_mask():
+  """Mask of which atoms are present for which residue type in atom14."""
+  restype_atom14_mask = []
+
+  for rt in restypes:
+    atom_names = restype_name_to_atom14_names[
+        restype_1to3[rt]]
+    restype_atom14_mask.append([(1. if name else 0.) for name in atom_names])
+
+  restype_atom14_mask.append([0.] * 14)
+  restype_atom14_mask = np.array(restype_atom14_mask, dtype=np.float32)
+  return restype_atom14_mask
+
+
+def _make_restype_atom37_to_atom14():
+  """Map from atom37 to atom14 per residue type."""
+  restype_atom37_to_atom14 = []  # mapping (restype, atom37) --> atom14
+  for rt in restypes:
+    atom_names = restype_name_to_atom14_names[
+        restype_1to3[rt]]
+    atom_name_to_idx14 = {name: i for i, name in enumerate(atom_names)}
+    restype_atom37_to_atom14.append([
+        (atom_name_to_idx14[name] if name in atom_name_to_idx14 else 0)
+        for name in atom_types
+    ])
+
+  restype_atom37_to_atom14.append([0] * 37)
+  restype_atom37_to_atom14 = np.array(restype_atom37_to_atom14, dtype=np.int32)
+  return restype_atom37_to_atom14
+
+
+def _make_restype_atom14_to_atom37():
+  """Map from atom14 to atom37 per residue type."""
+  restype_atom14_to_atom37 = []  # mapping (restype, atom14) --> atom37
+  for rt in restypes:
+    atom_names = restype_name_to_atom14_names[
+        restype_1to3[rt]]
+    restype_atom14_to_atom37.append([
+        (atom_order[name] if name else 0)
+        for name in atom_names
+    ])
+  # Add dummy mapping for restype 'UNK'
+  restype_atom14_to_atom37.append([0] * 14)
+  restype_atom14_to_atom37 = np.array(restype_atom14_to_atom37, dtype=np.int32)
+  return restype_atom14_to_atom37
+
+
+def _make_restype_atom14_is_ambiguous():
+  """Mask which atoms are ambiguous in atom14."""
+  # create an ambiguous atoms mask.  shape: (21, 14)
+  restype_atom14_is_ambiguous = np.zeros((21, 14), dtype=np.float32)
+  for resname, swap in residue_atom_renaming_swaps.items():
+    for atom_name1, atom_name2 in swap.items():
+      restype = restype_order[
+          restype_3to1[resname]]
+      atom_idx1 = restype_name_to_atom14_names[resname].index(
+          atom_name1)
+      atom_idx2 = restype_name_to_atom14_names[resname].index(
+          atom_name2)
+      restype_atom14_is_ambiguous[restype, atom_idx1] = 1
+      restype_atom14_is_ambiguous[restype, atom_idx2] = 1
+
+  return restype_atom14_is_ambiguous
+
+
+def _make_restype_rigidgroup_base_atom37_idx():
+  """Create Map from rigidgroups to atom37 indices."""
+  # Create an array with the atom names.
+  # shape (num_restypes, num_rigidgroups, 3_atoms): (21, 8, 3)
+  base_atom_names = np.full([21, 8, 3], '', dtype=object)
+
+  # 0: backbone frame
+  base_atom_names[:, 0, :] = ['C', 'CA', 'N']
+
+  # 3: 'psi-group'
+  base_atom_names[:, 3, :] = ['CA', 'C', 'O']
+
+  # 4,5,6,7: 'chi1,2,3,4-group'
+  for restype, restype_letter in enumerate(restypes):
+    resname = restype_1to3[restype_letter]
+    for chi_idx in range(4):
+      if chi_angles_mask[restype][chi_idx]:
+        atom_names = chi_angles_atoms[resname][chi_idx]
+        base_atom_names[restype, chi_idx + 4, :] = atom_names[1:]
+
+  # Translate atom names into atom37 indices.
+  lookuptable = atom_order.copy()
+  lookuptable[''] = 0
+  restype_rigidgroup_base_atom37_idx = np.vectorize(lambda x: lookuptable[x])(
+      base_atom_names)
+  return restype_rigidgroup_base_atom37_idx
+
+
+CHI_ATOM_INDICES = _make_chi_atom_indices()
+RENAMING_MATRICES = _make_renaming_matrices()
+RESTYPE_ATOM14_TO_ATOM37 = _make_restype_atom14_to_atom37()
+RESTYPE_ATOM37_TO_ATOM14 = _make_restype_atom37_to_atom14()
+RESTYPE_ATOM37_MASK = _make_restype_atom37_mask()
+RESTYPE_ATOM14_MASK = _make_restype_atom14_mask()
+RESTYPE_ATOM14_IS_AMBIGUOUS = _make_restype_atom14_is_ambiguous()
+RESTYPE_RIGIDGROUP_BASE_ATOM37_IDX = _make_restype_rigidgroup_base_atom37_idx()
+
+# Create mask for existing rigid groups.
+RESTYPE_RIGIDGROUP_MASK = np.zeros([21, 8], dtype=np.float32)
+RESTYPE_RIGIDGROUP_MASK[:, 0] = 1
+RESTYPE_RIGIDGROUP_MASK[:, 3] = 1
+RESTYPE_RIGIDGROUP_MASK[:20, 4:] = chi_angles_mask

data/mdgen/rigid_utils.py

@@ -0,0 +1,1391 @@
+# Copyright 2021 AlQuraishi Laboratory
+# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+from functools import lru_cache
+from typing import Tuple, Any, Sequence, Callable, Optional
+
+import numpy as np
+import torch
+
+
+def rot_matmul(
+    a: torch.Tensor, 
+    b: torch.Tensor
+) -> torch.Tensor:
+    """
+        Performs matrix multiplication of two rotation matrix tensors. Written
+        out by hand to avoid AMP downcasting.
+
+        Args:
+            a: [*, 3, 3] left multiplicand
+            b: [*, 3, 3] right multiplicand
+        Returns:
+            The product ab
+    """
+    def row_mul(i):
+        return torch.stack(
+            [
+                a[..., i, 0] * b[..., 0, 0]
+                + a[..., i, 1] * b[..., 1, 0]
+                + a[..., i, 2] * b[..., 2, 0],
+                a[..., i, 0] * b[..., 0, 1]
+                + a[..., i, 1] * b[..., 1, 1]
+                + a[..., i, 2] * b[..., 2, 1],
+                a[..., i, 0] * b[..., 0, 2]
+                + a[..., i, 1] * b[..., 1, 2]
+                + a[..., i, 2] * b[..., 2, 2],
+            ],
+            dim=-1,
+        )
+
+    return torch.stack(
+        [
+            row_mul(0), 
+            row_mul(1), 
+            row_mul(2),
+        ], 
+        dim=-2
+    )
+
+
+def rot_vec_mul(
+    r: torch.Tensor, 
+    t: torch.Tensor
+) -> torch.Tensor:
+    """
+        Applies a rotation to a vector. Written out by hand to avoid transfer
+        to avoid AMP downcasting.
+
+        Args:
+            r: [*, 3, 3] rotation matrices
+            t: [*, 3] coordinate tensors
+        Returns:
+            [*, 3] rotated coordinates
+    """
+    x, y, z = torch.unbind(t, dim=-1)
+    return torch.stack(
+        [
+            r[..., 0, 0] * x + r[..., 0, 1] * y + r[..., 0, 2] * z,
+            r[..., 1, 0] * x + r[..., 1, 1] * y + r[..., 1, 2] * z,
+            r[..., 2, 0] * x + r[..., 2, 1] * y + r[..., 2, 2] * z,
+        ],
+        dim=-1,
+    )
+
+@lru_cache(maxsize=None)
+def identity_rot_mats(
+    batch_dims: Tuple[int], 
+    dtype: Optional[torch.dtype] = None, 
+    device: Optional[torch.device] = None, 
+    requires_grad: bool = True,
+) -> torch.Tensor:
+    rots = torch.eye(
+        3, dtype=dtype, device=device, requires_grad=requires_grad
+    )
+    rots = rots.view(*((1,) * len(batch_dims)), 3, 3)
+    rots = rots.expand(*batch_dims, -1, -1)
+    rots = rots.contiguous()
+
+    return rots
+
+
+@lru_cache(maxsize=None)
+def identity_trans(
+    batch_dims: Tuple[int], 
+    dtype: Optional[torch.dtype] = None,
+    device: Optional[torch.device] = None, 
+    requires_grad: bool = True,
+) -> torch.Tensor:
+    trans = torch.zeros(
+        (*batch_dims, 3), 
+        dtype=dtype, 
+        device=device, 
+        requires_grad=requires_grad
+    )
+    return trans
+
+
+@lru_cache(maxsize=None)
+def identity_quats(
+    batch_dims: Tuple[int], 
+    dtype: Optional[torch.dtype] = None,
+    device: Optional[torch.device] = None, 
+    requires_grad: bool = True,
+) -> torch.Tensor:
+    quat = torch.zeros(
+        (*batch_dims, 4), 
+        dtype=dtype, 
+        device=device, 
+        requires_grad=requires_grad
+    )
+
+    with torch.no_grad():
+        quat[..., 0] = 1
+
+    return quat
+
+
+_quat_elements = ["a", "b", "c", "d"]
+_qtr_keys = [l1 + l2 for l1 in _quat_elements for l2 in _quat_elements]
+_qtr_ind_dict = {key: ind for ind, key in enumerate(_qtr_keys)}
+
+
+def _to_mat(pairs):
+    mat = np.zeros((4, 4))
+    for pair in pairs:
+        key, value = pair
+        ind = _qtr_ind_dict[key]
+        mat[ind // 4][ind % 4] = value
+
+    return mat
+
+
+_QTR_MAT = np.zeros((4, 4, 3, 3))
+_QTR_MAT[..., 0, 0] = _to_mat([("aa", 1), ("bb", 1), ("cc", -1), ("dd", -1)])
+_QTR_MAT[..., 0, 1] = _to_mat([("bc", 2), ("ad", -2)])
+_QTR_MAT[..., 0, 2] = _to_mat([("bd", 2), ("ac", 2)])
+_QTR_MAT[..., 1, 0] = _to_mat([("bc", 2), ("ad", 2)])
+_QTR_MAT[..., 1, 1] = _to_mat([("aa", 1), ("bb", -1), ("cc", 1), ("dd", -1)])
+_QTR_MAT[..., 1, 2] = _to_mat([("cd", 2), ("ab", -2)])
+_QTR_MAT[..., 2, 0] = _to_mat([("bd", 2), ("ac", -2)])
+_QTR_MAT[..., 2, 1] = _to_mat([("cd", 2), ("ab", 2)])
+_QTR_MAT[..., 2, 2] = _to_mat([("aa", 1), ("bb", -1), ("cc", -1), ("dd", 1)])
+
+
+def quat_to_rot(quat: torch.Tensor) -> torch.Tensor:
+    """
+        Converts a quaternion to a rotation matrix.
+
+        Args:
+            quat: [*, 4] quaternions
+        Returns:
+            [*, 3, 3] rotation matrices
+    """
+    # [*, 4, 4]
+    quat = quat[..., None] * quat[..., None, :]
+
+    # [4, 4, 3, 3]
+    mat = _get_quat("_QTR_MAT", dtype=quat.dtype, device=quat.device)
+
+    # [*, 4, 4, 3, 3]
+    shaped_qtr_mat = mat.view((1,) * len(quat.shape[:-2]) + mat.shape)
+    quat = quat[..., None, None] * shaped_qtr_mat
+
+    # [*, 3, 3]
+    return torch.sum(quat, dim=(-3, -4))
+
+
+def rot_to_quat(
+    rot: torch.Tensor,
+):
+    if(rot.shape[-2:] != (3, 3)):
+        raise ValueError("Input rotation is incorrectly shaped")
+
+    rot = [[rot[..., i, j] for j in range(3)] for i in range(3)]
+    [[xx, xy, xz], [yx, yy, yz], [zx, zy, zz]] = rot 
+
+    k = [
+        [ xx + yy + zz,      zy - yz,      xz - zx,      yx - xy,],
+        [      zy - yz, xx - yy - zz,      xy + yx,      xz + zx,],
+        [      xz - zx,      xy + yx, yy - xx - zz,      yz + zy,],
+        [      yx - xy,      xz + zx,      yz + zy, zz - xx - yy,]
+    ]
+
+    k = (1./3.) * torch.stack([torch.stack(t, dim=-1) for t in k], dim=-2)
+
+    _, vectors = torch.linalg.eigh(k)
+    return vectors[..., -1]
+
+
+_QUAT_MULTIPLY = np.zeros((4, 4, 4))
+_QUAT_MULTIPLY[:, :, 0] = [[ 1, 0, 0, 0],
+                          [ 0,-1, 0, 0],
+                          [ 0, 0,-1, 0],
+                          [ 0, 0, 0,-1]]
+
+_QUAT_MULTIPLY[:, :, 1] = [[ 0, 1, 0, 0],
+                          [ 1, 0, 0, 0],
+                          [ 0, 0, 0, 1],
+                          [ 0, 0,-1, 0]]
+
+_QUAT_MULTIPLY[:, :, 2] = [[ 0, 0, 1, 0],
+                          [ 0, 0, 0,-1],
+                          [ 1, 0, 0, 0],
+                          [ 0, 1, 0, 0]]
+
+_QUAT_MULTIPLY[:, :, 3] = [[ 0, 0, 0, 1],
+                          [ 0, 0, 1, 0],
+                          [ 0,-1, 0, 0],
+                          [ 1, 0, 0, 0]]
+
+_QUAT_MULTIPLY_BY_VEC = _QUAT_MULTIPLY[:, 1:, :]
+
+_CACHED_QUATS = {
+    "_QTR_MAT": _QTR_MAT,
+    "_QUAT_MULTIPLY": _QUAT_MULTIPLY,
+    "_QUAT_MULTIPLY_BY_VEC": _QUAT_MULTIPLY_BY_VEC
+}
+
+@lru_cache(maxsize=None)
+def _get_quat(quat_key, dtype, device):
+    return torch.tensor(_CACHED_QUATS[quat_key], dtype=dtype, device=device)
+
+
+def quat_multiply(quat1, quat2):
+    """Multiply a quaternion by another quaternion."""
+    mat = _get_quat("_QUAT_MULTIPLY", dtype=quat1.dtype, device=quat1.device)
+    reshaped_mat = mat.view((1,) * len(quat1.shape[:-1]) + mat.shape)
+    return torch.sum(
+        reshaped_mat *
+        quat1[..., :, None, None] *
+        quat2[..., None, :, None],
+        dim=(-3, -2)
+      )
+
+
+def quat_multiply_by_vec(quat, vec):
+    """Multiply a quaternion by a pure-vector quaternion."""
+    mat = _get_quat("_QUAT_MULTIPLY_BY_VEC", dtype=quat.dtype, device=quat.device)
+    reshaped_mat = mat.view((1,) * len(quat.shape[:-1]) + mat.shape)
+    return torch.sum(
+        reshaped_mat *
+        quat[..., :, None, None] *
+        vec[..., None, :, None],
+        dim=(-3, -2)
+    )
+
+
+def invert_rot_mat(rot_mat: torch.Tensor):
+    return rot_mat.transpose(-1, -2)
+
+
+def invert_quat(quat: torch.Tensor):
+    quat_prime = quat.clone()
+    quat_prime[..., 1:] *= -1
+    inv = quat_prime / torch.sum(quat ** 2, dim=-1, keepdim=True)
+    return inv
+
+
+class Rotation:
+    """
+        A 3D rotation. Depending on how the object is initialized, the
+        rotation is represented by either a rotation matrix or a
+        quaternion, though both formats are made available by helper functions.
+        To simplify gradient computation, the underlying format of the
+        rotation cannot be changed in-place. Like Rigid, the class is designed
+        to mimic the behavior of a torch Tensor, almost as if each Rotation
+        object were a tensor of rotations, in one format or another.
+    """
+    def __init__(self,
+        rot_mats: Optional[torch.Tensor] = None,
+        quats: Optional[torch.Tensor] = None,
+        normalize_quats: bool = True,
+    ):
+        """
+            Args:
+                rot_mats:
+                    A [*, 3, 3] rotation matrix tensor. Mutually exclusive with
+                    quats
+                quats:
+                    A [*, 4] quaternion. Mutually exclusive with rot_mats. If
+                    normalize_quats is not True, must be a unit quaternion
+                normalize_quats:
+                    If quats is specified, whether to normalize quats
+        """
+        if((rot_mats is None and quats is None) or 
+            (rot_mats is not None and quats is not None)):
+            raise ValueError("Exactly one input argument must be specified")
+
+        if((rot_mats is not None and rot_mats.shape[-2:] != (3, 3)) or 
+            (quats is not None and quats.shape[-1] != 4)):
+            raise ValueError(
+                "Incorrectly shaped rotation matrix or quaternion"
+            )
+
+        # Force full-precision
+        if(quats is not None):
+            quats = quats.to(dtype=torch.float32)
+        if(rot_mats is not None):
+            rot_mats = rot_mats.to(dtype=torch.float32)
+
+        if(quats is not None and normalize_quats):
+            quats = quats / torch.linalg.norm(quats, dim=-1, keepdim=True)
+
+        self._rot_mats = rot_mats
+        self._quats = quats
+
+    @staticmethod
+    def identity(
+        shape,
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None,
+        requires_grad: bool = True,
+        fmt: str = "quat",
+    ) -> Rotation:
+        """
+            Returns an identity Rotation.
+
+            Args:
+                shape:
+                    The "shape" of the resulting Rotation object. See documentation
+                    for the shape property
+                dtype:
+                    The torch dtype for the rotation
+                device:
+                    The torch device for the new rotation
+                requires_grad:
+                    Whether the underlying tensors in the new rotation object
+                    should require gradient computation
+                fmt:
+                    One of "quat" or "rot_mat". Determines the underlying format
+                    of the new object's rotation 
+            Returns:
+                A new identity rotation
+        """
+        if(fmt == "rot_mat"):
+            rot_mats = identity_rot_mats(
+                shape, dtype, device, requires_grad,
+            )
+            return Rotation(rot_mats=rot_mats, quats=None)
+        elif(fmt == "quat"):
+            quats = identity_quats(shape, dtype, device, requires_grad)
+            return Rotation(rot_mats=None, quats=quats, normalize_quats=False)
+        else:
+            raise ValueError(f"Invalid format: f{fmt}")
+
+    # Magic methods
+
+    def __getitem__(self, index: Any) -> Rotation:
+        """
+            Allows torch-style indexing over the virtual shape of the rotation
+            object. See documentation for the shape property.
+
+            Args:
+                index:
+                    A torch index. E.g. (1, 3, 2), or (slice(None,))
+            Returns:
+                The indexed rotation
+        """
+        if type(index) != tuple:
+            index = (index,)
+
+        if(self._rot_mats is not None):
+            rot_mats = self._rot_mats[index + (slice(None), slice(None))]
+            return Rotation(rot_mats=rot_mats)
+        elif(self._quats is not None):
+            quats = self._quats[index + (slice(None),)]
+            return Rotation(quats=quats, normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+
+    def __mul__(self,
+        right: torch.Tensor,
+    ) -> Rotation:
+        """
+            Pointwise left multiplication of the rotation with a tensor. Can be
+            used to e.g. mask the Rotation.
+
+            Args:
+                right:
+                    The tensor multiplicand
+            Returns:
+                The product
+        """
+        if not(isinstance(right, torch.Tensor)):
+            raise TypeError("The other multiplicand must be a Tensor")
+
+        if(self._rot_mats is not None):
+            rot_mats = self._rot_mats * right[..., None, None]
+            return Rotation(rot_mats=rot_mats, quats=None)
+        elif(self._quats is not None):
+            quats = self._quats * right[..., None]
+            return Rotation(rot_mats=None, quats=quats, normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+
+    def __rmul__(self,
+        left: torch.Tensor,
+    ) -> Rotation:
+        """
+            Reverse pointwise multiplication of the rotation with a tensor.
+
+            Args:
+                left:
+                    The left multiplicand
+            Returns:
+                The product
+        """
+        return self.__mul__(left)
+    
+    # Properties
+
+    @property
+    def shape(self) -> torch.Size:
+        """
+            Returns the virtual shape of the rotation object. This shape is
+            defined as the batch dimensions of the underlying rotation matrix
+            or quaternion. If the Rotation was initialized with a [10, 3, 3]
+            rotation matrix tensor, for example, the resulting shape would be
+            [10].
+        
+            Returns:
+                The virtual shape of the rotation object
+        """
+        s = None
+        if(self._quats is not None):
+            s = self._quats.shape[:-1]
+        else:
+            s = self._rot_mats.shape[:-2]
+
+        return s
+
+    @property
+    def dtype(self) -> torch.dtype:
+        """
+            Returns the dtype of the underlying rotation.
+
+            Returns:
+                The dtype of the underlying rotation
+        """
+        if(self._rot_mats is not None):
+            return self._rot_mats.dtype
+        elif(self._quats is not None):
+            return self._quats.dtype
+        else:
+            raise ValueError("Both rotations are None")
+
+    @property
+    def device(self) -> torch.device:
+        """
+            The device of the underlying rotation
+
+            Returns:
+                The device of the underlying rotation
+        """
+        if(self._rot_mats is not None):
+            return self._rot_mats.device
+        elif(self._quats is not None):
+            return self._quats.device
+        else:
+            raise ValueError("Both rotations are None")
+
+    @property
+    def requires_grad(self) -> bool:
+        """
+            Returns the requires_grad property of the underlying rotation
+
+            Returns:
+                The requires_grad property of the underlying tensor
+        """
+        if(self._rot_mats is not None):
+            return self._rot_mats.requires_grad
+        elif(self._quats is not None):
+            return self._quats.requires_grad
+        else:
+            raise ValueError("Both rotations are None")
+
+    def get_rot_mats(self) -> torch.Tensor:
+        """
+            Returns the underlying rotation as a rotation matrix tensor.
+
+            Returns:
+                The rotation as a rotation matrix tensor
+        """
+        rot_mats = self._rot_mats
+        if(rot_mats is None):
+            if(self._quats is None):
+                raise ValueError("Both rotations are None")
+            else:
+                rot_mats = quat_to_rot(self._quats)
+
+        return rot_mats 
+
+    def get_quats(self) -> torch.Tensor:
+        """
+            Returns the underlying rotation as a quaternion tensor.
+
+            Depending on whether the Rotation was initialized with a
+            quaternion, this function may call torch.linalg.eigh.
+
+            Returns:
+                The rotation as a quaternion tensor.
+        """
+        quats = self._quats
+        if(quats is None):
+            if(self._rot_mats is None):
+                raise ValueError("Both rotations are None")
+            else:
+                quats = rot_to_quat(self._rot_mats)
+
+        return quats
+
+    def get_cur_rot(self) -> torch.Tensor:
+        """
+            Return the underlying rotation in its current form
+
+            Returns:
+                The stored rotation
+        """
+        if(self._rot_mats is not None):
+            return self._rot_mats
+        elif(self._quats is not None):
+            return self._quats
+        else:
+            raise ValueError("Both rotations are None")
+
+    # Rotation functions
+
+    def compose_q_update_vec(self, 
+        q_update_vec: torch.Tensor, 
+        normalize_quats: bool = True
+    ) -> Rotation:
+        """
+            Returns a new quaternion Rotation after updating the current
+            object's underlying rotation with a quaternion update, formatted
+            as a [*, 3] tensor whose final three columns represent x, y, z such 
+            that (1, x, y, z) is the desired (not necessarily unit) quaternion
+            update.
+
+            Args:
+                q_update_vec:
+                    A [*, 3] quaternion update tensor
+                normalize_quats:
+                    Whether to normalize the output quaternion
+            Returns:
+                An updated Rotation
+        """
+        quats = self.get_quats()
+        new_quats = quats + quat_multiply_by_vec(quats, q_update_vec)
+        return Rotation(
+            rot_mats=None, 
+            quats=new_quats, 
+            normalize_quats=normalize_quats,
+        )
+
+    def compose_r(self, r: Rotation) -> Rotation:
+        """
+            Compose the rotation matrices of the current Rotation object with
+            those of another.
+
+            Args:
+                r:
+                    An update rotation object
+            Returns:
+                An updated rotation object
+        """
+        r1 = self.get_rot_mats()
+        r2 = r.get_rot_mats()
+        new_rot_mats = rot_matmul(r1, r2)
+        return Rotation(rot_mats=new_rot_mats, quats=None)
+
+    def compose_q(self, r: Rotation, normalize_quats: bool = True) -> Rotation:
+        """
+            Compose the quaternions of the current Rotation object with those
+            of another.
+
+            Depending on whether either Rotation was initialized with
+            quaternions, this function may call torch.linalg.eigh.
+
+            Args:
+                r:
+                    An update rotation object
+            Returns:
+                An updated rotation object
+        """
+        q1 = self.get_quats()
+        q2 = r.get_quats()
+        new_quats = quat_multiply(q1, q2)
+        return Rotation(
+            rot_mats=None, quats=new_quats, normalize_quats=normalize_quats
+        )
+
+    def apply(self, pts: torch.Tensor) -> torch.Tensor:
+        """
+            Apply the current Rotation as a rotation matrix to a set of 3D
+            coordinates.
+
+            Args:
+                pts:
+                    A [*, 3] set of points
+            Returns:
+                [*, 3] rotated points
+        """
+        rot_mats = self.get_rot_mats()
+        return rot_vec_mul(rot_mats, pts)
+
+    def invert_apply(self, pts: torch.Tensor) -> torch.Tensor:
+        """
+            The inverse of the apply() method.
+
+            Args:
+                pts:
+                    A [*, 3] set of points
+            Returns:
+                [*, 3] inverse-rotated points
+        """
+        rot_mats = self.get_rot_mats()
+        inv_rot_mats = invert_rot_mat(rot_mats) 
+        return rot_vec_mul(inv_rot_mats, pts)
+
+    def invert(self) -> Rotation:
+        """
+            Returns the inverse of the current Rotation.
+
+            Returns:
+                The inverse of the current Rotation
+        """
+        if(self._rot_mats is not None):
+            return Rotation(
+                rot_mats=invert_rot_mat(self._rot_mats), 
+                quats=None
+            )
+        elif(self._quats is not None):
+            return Rotation(
+                rot_mats=None,
+                quats=invert_quat(self._quats),
+                normalize_quats=False,
+            )
+        else:
+            raise ValueError("Both rotations are None")
+
+    # "Tensor" stuff
+
+    def unsqueeze(self, 
+        dim: int,
+    ) -> Rigid:
+        """
+            Analogous to torch.unsqueeze. The dimension is relative to the
+            shape of the Rotation object.
+            
+            Args:
+                dim: A positive or negative dimension index.
+            Returns:
+                The unsqueezed Rotation.
+        """
+        if dim >= len(self.shape):
+            raise ValueError("Invalid dimension")
+
+        if(self._rot_mats is not None):
+            rot_mats = self._rot_mats.unsqueeze(dim if dim >= 0 else dim - 2)
+            return Rotation(rot_mats=rot_mats, quats=None)
+        elif(self._quats is not None):
+            quats = self._quats.unsqueeze(dim if dim >= 0 else dim - 1)
+            return Rotation(rot_mats=None, quats=quats, normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+
+    @staticmethod
+    def cat(
+        rs: Sequence[Rotation], 
+        dim: int,
+    ) -> Rigid:
+        """
+            Concatenates rotations along one of the batch dimensions. Analogous
+            to torch.cat().
+
+            Note that the output of this operation is always a rotation matrix,
+            regardless of the format of input rotations.
+
+            Args:
+                rs: 
+                    A list of rotation objects
+                dim: 
+                    The dimension along which the rotations should be 
+                    concatenated
+            Returns:
+                A concatenated Rotation object in rotation matrix format
+        """
+        rot_mats = [r.get_rot_mats() for r in rs]
+        rot_mats = torch.cat(rot_mats, dim=dim if dim >= 0 else dim - 2)
+
+        return Rotation(rot_mats=rot_mats, quats=None) 
+
+    def map_tensor_fn(self, 
+        fn: Callable[torch.Tensor, torch.Tensor]
+    ) -> Rotation:
+        """
+            Apply a Tensor -> Tensor function to underlying rotation tensors,
+            mapping over the rotation dimension(s). Can be used e.g. to sum out
+            a one-hot batch dimension.
+
+            Args:
+                fn:
+                    A Tensor -> Tensor function to be mapped over the Rotation 
+            Returns:
+                The transformed Rotation object
+        """ 
+        if(self._rot_mats is not None):
+            rot_mats = self._rot_mats.view(self._rot_mats.shape[:-2] + (9,))
+            rot_mats = torch.stack(
+                list(map(fn, torch.unbind(rot_mats, dim=-1))), dim=-1
+            )
+            rot_mats = rot_mats.view(rot_mats.shape[:-1] + (3, 3))
+            return Rotation(rot_mats=rot_mats, quats=None)
+        elif(self._quats is not None):
+            quats = torch.stack(
+                list(map(fn, torch.unbind(self._quats, dim=-1))), dim=-1
+            )
+            return Rotation(rot_mats=None, quats=quats, normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+    
+    def cuda(self) -> Rotation:
+        """
+            Analogous to the cuda() method of torch Tensors
+
+            Returns:
+                A copy of the Rotation in CUDA memory
+        """
+        if(self._rot_mats is not None):
+            return Rotation(rot_mats=self._rot_mats.cuda(), quats=None)
+        elif(self._quats is not None):
+            return Rotation(
+                rot_mats=None, 
+                quats=self._quats.cuda(),
+                normalize_quats=False
+            )
+        else:
+            raise ValueError("Both rotations are None")
+
+    def to(self, 
+        device: Optional[torch.device], 
+        dtype: Optional[torch.dtype]
+    ) -> Rotation:
+        """
+            Analogous to the to() method of torch Tensors
+
+            Args:
+                device:
+                    A torch device
+                dtype:
+                    A torch dtype
+            Returns:
+                A copy of the Rotation using the new device and dtype
+        """
+        if(self._rot_mats is not None):
+            return Rotation(
+                rot_mats=self._rot_mats.to(device=device, dtype=dtype), 
+                quats=None,
+            )
+        elif(self._quats is not None):
+            return Rotation(
+                rot_mats=None, 
+                quats=self._quats.to(device=device, dtype=dtype),
+                normalize_quats=False,
+            )
+        else:
+            raise ValueError("Both rotations are None")
+
+    def detach(self) -> Rotation:
+        """
+            Returns a copy of the Rotation whose underlying Tensor has been
+            detached from its torch graph.
+
+            Returns:
+                A copy of the Rotation whose underlying Tensor has been detached
+                from its torch graph
+        """
+        if(self._rot_mats is not None):
+            return Rotation(rot_mats=self._rot_mats.detach(), quats=None)
+        elif(self._quats is not None):
+            return Rotation(
+                rot_mats=None, 
+                quats=self._quats.detach(), 
+                normalize_quats=False,
+            )
+        else:
+            raise ValueError("Both rotations are None")
+
+
+class Rigid:
+    """
+        A class representing a rigid transformation. Little more than a wrapper
+        around two objects: a Rotation object and a [*, 3] translation
+        Designed to behave approximately like a single torch tensor with the 
+        shape of the shared batch dimensions of its component parts.
+    """
+    def __init__(self, 
+        rots: Optional[Rotation],
+        trans: Optional[torch.Tensor],
+    ):
+        """
+            Args:
+                rots: A [*, 3, 3] rotation tensor
+                trans: A corresponding [*, 3] translation tensor
+        """
+        # (we need device, dtype, etc. from at least one input)
+
+        batch_dims, dtype, device, requires_grad = None, None, None, None
+        if(trans is not None):
+            batch_dims = trans.shape[:-1]
+            dtype = trans.dtype
+            device = trans.device
+            requires_grad = trans.requires_grad
+        elif(rots is not None):
+            batch_dims = rots.shape
+            dtype = rots.dtype
+            device = rots.device
+            requires_grad = rots.requires_grad
+        else:
+            raise ValueError("At least one input argument must be specified")
+
+        if(rots is None):
+            rots = Rotation.identity(
+                batch_dims, dtype, device, requires_grad,
+            )
+        elif(trans is None):
+            trans = identity_trans(
+                batch_dims, dtype, device, requires_grad,
+            )
+
+        if((rots.shape != trans.shape[:-1]) or
+           (rots.device != trans.device)):
+            raise ValueError("Rots and trans incompatible")
+
+        # Force full precision. Happens to the rotations automatically.
+        trans = trans.to(dtype=torch.float32)
+
+        self._rots = rots
+        self._trans = trans
+
+    @staticmethod
+    def identity(
+        shape: Tuple[int], 
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None, 
+        requires_grad: bool = True,
+        fmt: str = "quat",
+    ) -> Rigid:
+        """
+            Constructs an identity transformation.
+
+            Args:
+                shape: 
+                    The desired shape
+                dtype: 
+                    The dtype of both internal tensors
+                device: 
+                    The device of both internal tensors
+                requires_grad: 
+                    Whether grad should be enabled for the internal tensors
+            Returns:
+                The identity transformation
+        """
+        return Rigid(
+            Rotation.identity(shape, dtype, device, requires_grad, fmt=fmt),
+            identity_trans(shape, dtype, device, requires_grad),
+        )
+
+    def __getitem__(self, 
+        index: Any,
+    ) -> Rigid:
+        """ 
+            Indexes the affine transformation with PyTorch-style indices.
+            The index is applied to the shared dimensions of both the rotation
+            and the translation.
+
+            E.g.::
+
+                r = Rotation(rot_mats=torch.rand(10, 10, 3, 3), quats=None)
+                t = Rigid(r, torch.rand(10, 10, 3))
+                indexed = t[3, 4:6]
+                assert(indexed.shape == (2,))
+                assert(indexed.get_rots().shape == (2,))
+                assert(indexed.get_trans().shape == (2, 3))
+
+            Args:
+                index: A standard torch tensor index. E.g. 8, (10, None, 3),
+                or (3, slice(0, 1, None))
+            Returns:
+                The indexed tensor 
+        """
+        if type(index) != tuple:
+            index = (index,)
+        
+        return Rigid(
+            self._rots[index],
+            self._trans[index + (slice(None),)],
+        )
+
+    def __mul__(self,
+        right: torch.Tensor,
+    ) -> Rigid:
+        """
+            Pointwise left multiplication of the transformation with a tensor.
+            Can be used to e.g. mask the Rigid.
+
+            Args:
+                right:
+                    The tensor multiplicand
+            Returns:
+                The product
+        """
+        if not(isinstance(right, torch.Tensor)):
+            raise TypeError("The other multiplicand must be a Tensor")
+
+        new_rots = self._rots * right
+        new_trans = self._trans * right[..., None]
+
+        return Rigid(new_rots, new_trans)
+
+    def __rmul__(self,
+        left: torch.Tensor,
+    ) -> Rigid:
+        """
+            Reverse pointwise multiplication of the transformation with a 
+            tensor.
+
+            Args:
+                left:
+                    The left multiplicand
+            Returns:
+                The product
+        """
+        return self.__mul__(left)
+
+    @property
+    def shape(self) -> torch.Size:
+        """
+            Returns the shape of the shared dimensions of the rotation and
+            the translation.
+            
+            Returns:
+                The shape of the transformation
+        """
+        s = self._trans.shape[:-1]
+        return s
+
+    @property
+    def device(self) -> torch.device:
+        """
+            Returns the device on which the Rigid's tensors are located.
+
+            Returns:
+                The device on which the Rigid's tensors are located
+        """
+        return self._trans.device
+
+    @property
+    def dtype(self) -> torch.dtype:
+        """
+            Returns the dtype of the Rigid tensors.
+
+            Returns:
+                The dtype of the Rigid tensors
+        """
+        return self._rots.dtype
+
+    def get_rots(self) -> Rotation:
+        """
+            Getter for the rotation.
+
+            Returns:
+                The rotation object
+        """
+        return self._rots
+
+    def get_trans(self) -> torch.Tensor:
+        """
+            Getter for the translation.
+
+            Returns:
+                The stored translation
+        """
+        return self._trans
+
+    def compose_q_update_vec(self, 
+        q_update_vec: torch.Tensor,
+    ) -> Rigid:
+        """
+            Composes the transformation with a quaternion update vector of
+            shape [*, 6], where the final 6 columns represent the x, y, and
+            z values of a quaternion of form (1, x, y, z) followed by a 3D
+            translation.
+
+            Args:
+                q_vec: The quaternion update vector.
+            Returns:
+                The composed transformation.
+        """
+        q_vec, t_vec = q_update_vec[..., :3], q_update_vec[..., 3:]
+        new_rots = self._rots.compose_q_update_vec(q_vec)
+
+        trans_update = self._rots.apply(t_vec)
+        new_translation = self._trans + trans_update
+
+        return Rigid(new_rots, new_translation)
+
+    def compose(self,
+        r: Rigid,
+    ) -> Rigid:
+        """
+            Composes the current rigid object with another.
+
+            Args:
+                r:
+                    Another Rigid object
+            Returns:
+                The composition of the two transformations
+        """
+        new_rot = self._rots.compose_r(r._rots)
+        new_trans = self._rots.apply(r._trans) + self._trans
+        return Rigid(new_rot, new_trans)
+
+    def apply(self, 
+        pts: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+            Applies the transformation to a coordinate tensor.
+
+            Args:
+                pts: A [*, 3] coordinate tensor.
+            Returns:
+                The transformed points.
+        """
+        rotated = self._rots.apply(pts) 
+        return rotated + self._trans
+
+    def invert_apply(self, 
+        pts: torch.Tensor
+    ) -> torch.Tensor:
+        """
+            Applies the inverse of the transformation to a coordinate tensor.
+
+            Args:
+                pts: A [*, 3] coordinate tensor
+            Returns:
+                The transformed points.
+        """
+        pts = pts - self._trans
+        return self._rots.invert_apply(pts) 
+
+    def invert(self) -> Rigid:
+        """
+            Inverts the transformation.
+
+            Returns:
+                The inverse transformation.
+        """
+        rot_inv = self._rots.invert() 
+        trn_inv = rot_inv.apply(self._trans)
+
+        return Rigid(rot_inv, -1 * trn_inv)
+
+    def map_tensor_fn(self, 
+        fn: Callable[torch.Tensor, torch.Tensor]
+    ) -> Rigid:
+        """
+            Apply a Tensor -> Tensor function to underlying translation and
+            rotation tensors, mapping over the translation/rotation dimensions
+            respectively.
+
+            Args:
+                fn:
+                    A Tensor -> Tensor function to be mapped over the Rigid
+            Returns:
+                The transformed Rigid object
+        """     
+        new_rots = self._rots.map_tensor_fn(fn) 
+        new_trans = torch.stack(
+            list(map(fn, torch.unbind(self._trans, dim=-1))), 
+            dim=-1
+        )
+
+        return Rigid(new_rots, new_trans)
+
+    def to_tensor_4x4(self) -> torch.Tensor:
+        """
+            Converts a transformation to a homogenous transformation tensor.
+
+            Returns:
+                A [*, 4, 4] homogenous transformation tensor
+        """
+        tensor = self._trans.new_zeros((*self.shape, 4, 4))
+        tensor[..., :3, :3] = self._rots.get_rot_mats()
+        tensor[..., :3, 3] = self._trans
+        tensor[..., 3, 3] = 1
+        return tensor
+
+    @staticmethod
+    def from_tensor_4x4(
+        t: torch.Tensor
+    ) -> Rigid:
+        """
+            Constructs a transformation from a homogenous transformation
+            tensor.
+
+            Args:
+                t: [*, 4, 4] homogenous transformation tensor
+            Returns:
+                T object with shape [*]
+        """
+        if(t.shape[-2:] != (4, 4)):
+            raise ValueError("Incorrectly shaped input tensor")
+
+        rots = Rotation(rot_mats=t[..., :3, :3], quats=None)
+        trans = t[..., :3, 3]
+        
+        return Rigid(rots, trans)
+
+    def to_tensor_7(self) -> torch.Tensor:
+        """
+            Converts a transformation to a tensor with 7 final columns, four 
+            for the quaternion followed by three for the translation.
+
+            Returns:
+                A [*, 7] tensor representation of the transformation
+        """
+        tensor = self._trans.new_zeros((*self.shape, 7))
+        tensor[..., :4] = self._rots.get_quats()
+        tensor[..., 4:] = self._trans
+
+        return tensor
+
+    @staticmethod
+    def from_tensor_7(
+        t: torch.Tensor,
+        normalize_quats: bool = False,
+    ) -> Rigid:
+        if(t.shape[-1] != 7):
+            raise ValueError("Incorrectly shaped input tensor")
+
+        quats, trans = t[..., :4], t[..., 4:]
+
+        rots = Rotation(
+            rot_mats=None, 
+            quats=quats, 
+            normalize_quats=normalize_quats
+        )
+
+        return Rigid(rots, trans)
+
+    @staticmethod
+    def from_3_points(
+        p_neg_x_axis: torch.Tensor, 
+        origin: torch.Tensor, 
+        p_xy_plane: torch.Tensor, 
+        eps: float = 1e-8
+    ) -> Rigid:
+        """
+            Implements algorithm 21. Constructs transformations from sets of 3 
+            points using the Gram-Schmidt algorithm.
+
+            Args:
+                p_neg_x_axis: [*, 3] coordinates
+                origin: [*, 3] coordinates used as frame origins
+                p_xy_plane: [*, 3] coordinates
+                eps: Small epsilon value
+            Returns:
+                A transformation object of shape [*]
+        """
+        p_neg_x_axis = torch.unbind(p_neg_x_axis, dim=-1)
+        origin = torch.unbind(origin, dim=-1)
+        p_xy_plane = torch.unbind(p_xy_plane, dim=-1)
+
+        e0 = [c1 - c2 for c1, c2 in zip(origin, p_neg_x_axis)]
+        e1 = [c1 - c2 for c1, c2 in zip(p_xy_plane, origin)]
+
+        denom = torch.sqrt(sum((c * c for c in e0)) + eps)
+        e0 = [c / denom for c in e0]
+        dot = sum((c1 * c2 for c1, c2 in zip(e0, e1)))
+        e1 = [c2 - c1 * dot for c1, c2 in zip(e0, e1)]
+        denom = torch.sqrt(sum((c * c for c in e1)) + eps)
+        e1 = [c / denom for c in e1]
+        e2 = [
+            e0[1] * e1[2] - e0[2] * e1[1],
+            e0[2] * e1[0] - e0[0] * e1[2],
+            e0[0] * e1[1] - e0[1] * e1[0],
+        ]
+
+        rots = torch.stack([c for tup in zip(e0, e1, e2) for c in tup], dim=-1)
+        rots = rots.reshape(rots.shape[:-1] + (3, 3))
+
+        rot_obj = Rotation(rot_mats=rots, quats=None)
+
+        return Rigid(rot_obj, torch.stack(origin, dim=-1))
+
+    def unsqueeze(self, 
+        dim: int,
+    ) -> Rigid:
+        """
+            Analogous to torch.unsqueeze. The dimension is relative to the
+            shared dimensions of the rotation/translation.
+            
+            Args:
+                dim: A positive or negative dimension index.
+            Returns:
+                The unsqueezed transformation.
+        """
+        if dim >= len(self.shape):
+            raise ValueError("Invalid dimension")
+        rots = self._rots.unsqueeze(dim)
+        trans = self._trans.unsqueeze(dim if dim >= 0 else dim - 1)
+
+        return Rigid(rots, trans)
+
+    @staticmethod
+    def cat(
+        ts: Sequence[Rigid], 
+        dim: int,
+    ) -> Rigid:
+        """
+            Concatenates transformations along a new dimension.
+
+            Args:
+                ts: 
+                    A list of T objects
+                dim: 
+                    The dimension along which the transformations should be 
+                    concatenated
+            Returns:
+                A concatenated transformation object
+        """
+        rots = Rotation.cat([t._rots for t in ts], dim) 
+        trans = torch.cat(
+            [t._trans for t in ts], dim=dim if dim >= 0 else dim - 1
+        )
+
+        return Rigid(rots, trans)
+
+    def apply_rot_fn(self, fn: Callable[Rotation, Rotation]) -> Rigid:
+        """
+            Applies a Rotation -> Rotation function to the stored rotation
+            object.
+
+            Args:
+                fn: A function of type Rotation -> Rotation
+            Returns:
+                A transformation object with a transformed rotation.
+        """
+        return Rigid(fn(self._rots), self._trans)
+
+    def apply_trans_fn(self, fn: Callable[torch.Tensor, torch.Tensor]) -> Rigid:
+        """
+            Applies a Tensor -> Tensor function to the stored translation.
+
+            Args:
+                fn: 
+                    A function of type Tensor -> Tensor to be applied to the
+                    translation
+            Returns:
+                A transformation object with a transformed translation.
+        """
+        return Rigid(self._rots, fn(self._trans))
+
+    def scale_translation(self, trans_scale_factor: float) -> Rigid:
+        """
+            Scales the translation by a constant factor.
+
+            Args:
+                trans_scale_factor:
+                    The constant factor
+            Returns:
+                A transformation object with a scaled translation.
+        """
+        fn = lambda t: t * trans_scale_factor
+        return self.apply_trans_fn(fn)
+
+    def stop_rot_gradient(self) -> Rigid:
+        """
+            Detaches the underlying rotation object
+
+            Returns:
+                A transformation object with detached rotations
+        """
+        fn = lambda r: r.detach()
+        return self.apply_rot_fn(fn)
+
+    @staticmethod
+    def make_transform_from_reference(n_xyz, ca_xyz, c_xyz, eps=1e-20):
+        """
+            Returns a transformation object from reference coordinates.
+  
+            Note that this method does not take care of symmetries. If you 
+            provide the atom positions in the non-standard way, the N atom will 
+            end up not at [-0.527250, 1.359329, 0.0] but instead at 
+            [-0.527250, -1.359329, 0.0]. You need to take care of such cases in 
+            your code.
+  
+            Args:
+                n_xyz: A [*, 3] tensor of nitrogen xyz coordinates.
+                ca_xyz: A [*, 3] tensor of carbon alpha xyz coordinates.
+                c_xyz: A [*, 3] tensor of carbon xyz coordinates.
+            Returns:
+                A transformation object. After applying the translation and 
+                rotation to the reference backbone, the coordinates will 
+                approximately equal to the input coordinates.
+        """    
+        translation = -1 * ca_xyz
+        n_xyz = n_xyz + translation
+        c_xyz = c_xyz + translation
+
+        c_x, c_y, c_z = [c_xyz[..., i] for i in range(3)]
+        norm = torch.sqrt(eps + c_x ** 2 + c_y ** 2)
+        sin_c1 = -c_y / norm
+        cos_c1 = c_x / norm
+        zeros = sin_c1.new_zeros(sin_c1.shape)
+        ones = sin_c1.new_ones(sin_c1.shape)
+
+        c1_rots = sin_c1.new_zeros((*sin_c1.shape, 3, 3))
+        c1_rots[..., 0, 0] = cos_c1
+        c1_rots[..., 0, 1] = -1 * sin_c1
+        c1_rots[..., 1, 0] = sin_c1
+        c1_rots[..., 1, 1] = cos_c1
+        c1_rots[..., 2, 2] = 1
+
+        norm = torch.sqrt(eps + c_x ** 2 + c_y ** 2 + c_z ** 2)
+        sin_c2 = c_z / norm
+        cos_c2 = torch.sqrt(c_x ** 2 + c_y ** 2) / norm
+
+        c2_rots = sin_c2.new_zeros((*sin_c2.shape, 3, 3))
+        c2_rots[..., 0, 0] = cos_c2
+        c2_rots[..., 0, 2] = sin_c2
+        c2_rots[..., 1, 1] = 1
+        c2_rots[..., 2, 0] = -1 * sin_c2
+        c2_rots[..., 2, 2] = cos_c2
+
+        c_rots = rot_matmul(c2_rots, c1_rots)
+        n_xyz = rot_vec_mul(c_rots, n_xyz)
+
+        _, n_y, n_z = [n_xyz[..., i] for i in range(3)]
+        norm = torch.sqrt(eps + n_y ** 2 + n_z ** 2)
+        sin_n = -n_z / norm
+        cos_n = n_y / norm
+
+        n_rots = sin_c2.new_zeros((*sin_c2.shape, 3, 3))
+        n_rots[..., 0, 0] = 1
+        n_rots[..., 1, 1] = cos_n
+        n_rots[..., 1, 2] = -1 * sin_n
+        n_rots[..., 2, 1] = sin_n
+        n_rots[..., 2, 2] = cos_n
+
+        rots = rot_matmul(n_rots, c_rots)
+
+        rots = rots.transpose(-1, -2)
+        translation = -1 * translation
+
+        rot_obj = Rotation(rot_mats=rots, quats=None)
+
+        return Rigid(rot_obj, translation)
+
+    def cuda(self) -> Rigid:
+        """
+            Moves the transformation object to GPU memory
+            
+            Returns:
+                A version of the transformation on GPU
+        """
+        return Rigid(self._rots.cuda(), self._trans.cuda())

data/mdgen/tensor_utils.py

@@ -0,0 +1,119 @@
+# Copyright 2021 AlQuraishi Laboratory
+# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from functools import partial
+from typing import List
+
+import torch
+import torch.nn as nn
+
+
+def add(m1, m2, inplace):
+    # The first operation in a checkpoint can't be in-place, but it's
+    # nice to have in-place addition during inference. Thus...
+    if(not inplace):
+        m1 = m1 + m2
+    else:
+        m1 += m2
+
+    return m1
+
+
+def permute_final_dims(tensor: torch.Tensor, inds: List[int]):
+    zero_index = -1 * len(inds)
+    first_inds = list(range(len(tensor.shape[:zero_index])))
+    return tensor.permute(first_inds + [zero_index + i for i in inds])
+
+
+def flatten_final_dims(t: torch.Tensor, no_dims: int):
+    return t.reshape(t.shape[:-no_dims] + (-1,))
+
+
+def masked_mean(mask, value, dim, eps=1e-4):
+    mask = mask.expand(*value.shape)
+    return torch.sum(mask * value, dim=dim) / (eps + torch.sum(mask, dim=dim))
+
+
+def pts_to_distogram(pts, min_bin=2.3125, max_bin=21.6875, no_bins=64):
+    boundaries = torch.linspace(
+        min_bin, max_bin, no_bins - 1, device=pts.device
+    )
+    dists = torch.sqrt(
+        torch.sum((pts.unsqueeze(-2) - pts.unsqueeze(-3)) ** 2, dim=-1)
+    )
+    return torch.bucketize(dists, boundaries)
+
+
+def dict_multimap(fn, dicts):
+    first = dicts[0]
+    new_dict = {}
+    for k, v in first.items():
+        all_v = [d[k] for d in dicts]
+        if type(v) is dict:
+            new_dict[k] = dict_multimap(fn, all_v)
+        else:
+            new_dict[k] = fn(all_v)
+
+    return new_dict
+
+
+def one_hot(x, v_bins):
+    reshaped_bins = v_bins.view(((1,) * len(x.shape)) + (len(v_bins),))
+    diffs = x[..., None] - reshaped_bins
+    am = torch.argmin(torch.abs(diffs), dim=-1)
+    return nn.functional.one_hot(am, num_classes=len(v_bins)).float()
+
+
+def batched_gather(data, inds, dim=0, no_batch_dims=0):
+    ranges = []
+    for i, s in enumerate(data.shape[:no_batch_dims]):
+        r = torch.arange(s)
+        r = r.view(*(*((1,) * i), -1, *((1,) * (len(inds.shape) - i - 1))))
+        ranges.append(r)
+
+    remaining_dims = [
+        slice(None) for _ in range(len(data.shape) - no_batch_dims)
+    ]
+    remaining_dims[dim - no_batch_dims if dim >= 0 else dim] = inds
+    ranges.extend(remaining_dims)
+    return data[ranges]
+
+
+# With tree_map, a poor man's JAX tree_map
+def dict_map(fn, dic, leaf_type):
+    new_dict = {}
+    for k, v in dic.items():
+        if type(v) is dict:
+            new_dict[k] = dict_map(fn, v, leaf_type)
+        else:
+            new_dict[k] = tree_map(fn, v, leaf_type)
+
+    return new_dict
+
+
+def tree_map(fn, tree, leaf_type):
+    if isinstance(tree, dict):
+        return dict_map(fn, tree, leaf_type)
+    elif isinstance(tree, list):
+        return [tree_map(fn, x, leaf_type) for x in tree]
+    elif isinstance(tree, tuple):
+        return tuple([tree_map(fn, x, leaf_type) for x in tree])
+    elif isinstance(tree, leaf_type):
+        return fn(tree)
+    else:
+        raise ValueError(f"Tree of type {type(tree)} not supported")
+
+
+tensor_tree_map = partial(tree_map, leaf_type=torch.Tensor)

data/mdgen/transport/integrators.py

@@ -0,0 +1,114 @@
+# https://github.com/willisma/SiT/
+import torch as th
+from torchdiffeq import odeint
+
+class sde:
+    """SDE solver class"""
+    def __init__(
+        self, 
+        drift,
+        diffusion,
+        *,
+        t0,
+        t1,
+        num_steps,
+        sampler_type,
+    ):
+        assert t0 < t1, "SDE sampler has to be in forward time"
+
+        self.inference_steps = num_steps
+        self.t = th.linspace(t0, t1, num_steps)
+        self.dt = self.t[1] - self.t[0]
+        self.drift = drift
+        self.diffusion = diffusion
+        self.sampler_type = sampler_type
+
+    def __Euler_Maruyama_step(self, x, mean_x, t, model, **model_kwargs):
+        w_cur = th.randn(x.size()).to(x)
+        t = th.ones(x.size(0)).to(x) * t
+        dw = w_cur * th.sqrt(self.dt)
+        drift = self.drift(x, t, model, **model_kwargs)
+        diffusion = self.diffusion(x, t)
+        mean_x = x + drift * self.dt
+        x = mean_x + th.sqrt(2 * diffusion) * dw
+        return x, mean_x
+    
+    def __Heun_step(self, x, _, t, model, **model_kwargs):
+        w_cur = th.randn(x.size()).to(x)
+        dw = w_cur * th.sqrt(self.dt)
+        t_cur = th.ones(x.size(0)).to(x) * t
+        diffusion = self.diffusion(x, t_cur)
+        xhat = x + th.sqrt(2 * diffusion) * dw
+        K1 = self.drift(xhat, t_cur, model, **model_kwargs)
+        xp = xhat + self.dt * K1
+        K2 = self.drift(xp, t_cur + self.dt, model, **model_kwargs)
+        return xhat + 0.5 * self.dt * (K1 + K2), xhat # at last time point we do not perform the heun step
+
+    def __forward_fn(self):
+        """TODO: generalize here by adding all private functions ending with steps to it"""
+        sampler_dict = {
+            "Euler": self.__Euler_Maruyama_step,
+            "Heun": self.__Heun_step,
+        }
+
+        try:
+            sampler = sampler_dict[self.sampler_type]
+        except:
+            raise NotImplementedError("Smapler type not implemented.")
+    
+        return sampler
+
+    def sample(self, init, model, **model_kwargs):
+        """forward loop of sde"""
+        x = init
+        mean_x = init 
+        samples = []
+        sampler = self.__forward_fn()
+        for ti in self.t[:-1]:
+            with th.no_grad():
+                x, mean_x = sampler(x, mean_x, ti, model, **model_kwargs)
+                samples.append(x)
+
+        return samples
+
+class ode:
+    """ODE solver class"""
+    def __init__(
+        self,
+        drift,
+        *,
+        t0,
+        t1,
+        sampler_type,
+        num_steps,
+        atol,
+        rtol,
+    ):
+        assert t0 < t1, "ODE sampler has to be in forward time"
+
+        self.drift = drift
+        self.t = th.linspace(t0, t1, num_steps)
+        self.atol = atol
+        self.rtol = rtol
+        self.sampler_type = sampler_type
+
+    def sample(self, x, model, **model_kwargs):
+        
+        device = x[0].device if isinstance(x, tuple) else x.device
+        def _fn(t, x):
+            t = th.ones(x[0].size(0)).to(device) * t if isinstance(x, tuple) else th.ones(x.size(0)).to(device) * t
+            model_output = self.drift(x, t, model, **model_kwargs)
+            return model_output
+
+        t = self.t.to(device)
+        atol = [self.atol] * len(x) if isinstance(x, tuple) else [self.atol]
+        rtol = [self.rtol] * len(x) if isinstance(x, tuple) else [self.rtol]
+        samples = odeint(
+            _fn,
+            x,
+            t,
+            method=self.sampler_type,
+            atol=atol,
+            rtol=rtol
+        )
+        return samples

data/mdgen/transport/path.py

@@ -0,0 +1,191 @@
+# https://github.com/willisma/SiT/
+import torch as th
+import numpy as np
+def expand_t_like_x(t, x):
+    """Function to reshape time t to broadcastable dimension of x
+    Args:
+      t: [batch_dim,], time vector
+      x: [batch_dim,...], data point
+    """
+    dims = [1] * (len(x.size()) - 1)
+    t = t.view(t.size(0), *dims)
+    return t
+
+
+#################### Coupling Plans ####################
+
+class ICPlan:
+    """Linear Coupling Plan"""
+    def __init__(self, sigma=0.0):
+        self.sigma = sigma
+
+    def compute_alpha_t(self, t):
+        """Compute the data coefficient along the path"""
+        return t, 1
+    
+    def compute_sigma_t(self, t):
+        """Compute the noise coefficient along the path"""
+        return 1 - t, -1
+    
+    def compute_d_alpha_alpha_ratio_t(self, t):
+        """Compute the ratio between d_alpha and alpha"""
+        return 1 / t
+
+    def compute_drift(self, x, t):
+        """We always output sde according to score parametrization; """
+        t = expand_t_like_x(t, x)
+        alpha_ratio = self.compute_d_alpha_alpha_ratio_t(t)
+        sigma_t, d_sigma_t = self.compute_sigma_t(t)
+        drift = alpha_ratio * x
+        diffusion = alpha_ratio * (sigma_t ** 2) - sigma_t * d_sigma_t
+
+        return -drift, diffusion
+
+    def compute_diffusion(self, x, t, form="constant", norm=1.0):
+        """Compute the diffusion term of the SDE
+        Args:
+          x: [batch_dim, ...], data point
+          t: [batch_dim,], time vector
+          form: str, form of the diffusion term
+          norm: float, norm of the diffusion term
+        """
+        t = expand_t_like_x(t, x)
+        choices = {
+            "constant": norm,
+            "SBDM": norm * self.compute_drift(x, t)[1],
+            "sigma": norm * self.compute_sigma_t(t)[0],
+            "linear": norm * (1 - t),
+            "decreasing": 0.25 * (norm * th.cos(np.pi * t) + 1) ** 2,
+            "inccreasing-decreasing": norm * th.sin(np.pi * t) ** 2,
+        }
+
+        try:
+            diffusion = choices[form]
+        except KeyError:
+            raise NotImplementedError(f"Diffusion form {form} not implemented")
+        
+        return diffusion
+
+    def get_score_from_velocity(self, velocity, x, t):
+        """Wrapper function: transfrom velocity prediction model to score
+        Args:
+            velocity: [batch_dim, ...] shaped tensor; velocity model output
+            x: [batch_dim, ...] shaped tensor; x_t data point
+            t: [batch_dim,] time tensor
+        """
+        t = expand_t_like_x(t, x)
+        alpha_t, d_alpha_t = self.compute_alpha_t(t)
+        sigma_t, d_sigma_t = self.compute_sigma_t(t)
+        mean = x
+        reverse_alpha_ratio = alpha_t / d_alpha_t
+        var = sigma_t**2 - reverse_alpha_ratio * d_sigma_t * sigma_t
+        score = (reverse_alpha_ratio * velocity - mean) / var
+        return score
+    
+    def get_noise_from_velocity(self, velocity, x, t):
+        """Wrapper function: transfrom velocity prediction model to denoiser
+        Args:
+            velocity: [batch_dim, ...] shaped tensor; velocity model output
+            x: [batch_dim, ...] shaped tensor; x_t data point
+            t: [batch_dim,] time tensor
+        """
+        t = expand_t_like_x(t, x)
+        alpha_t, d_alpha_t = self.compute_alpha_t(t)
+        sigma_t, d_sigma_t = self.compute_sigma_t(t)
+        mean = x
+        reverse_alpha_ratio = alpha_t / d_alpha_t
+        var = reverse_alpha_ratio * d_sigma_t - sigma_t
+        noise = (reverse_alpha_ratio * velocity - mean) / var
+        return noise
+
+    def get_velocity_from_score(self, score, x, t):
+        """Wrapper function: transfrom score prediction model to velocity
+        Args:
+            score: [batch_dim, ...] shaped tensor; score model output
+            x: [batch_dim, ...] shaped tensor; x_t data point
+            t: [batch_dim,] time tensor
+        """
+        t = expand_t_like_x(t, x)
+        drift, var = self.compute_drift(x, t)
+        velocity = var * score - drift
+        return velocity
+
+    def compute_mu_t(self, t, x0, x1):
+        """Compute the mean of time-dependent density p_t"""
+        t = expand_t_like_x(t, x1)
+        alpha_t, _ = self.compute_alpha_t(t)
+        sigma_t, _ = self.compute_sigma_t(t)
+        return alpha_t * x1 + sigma_t * x0
+    
+    def compute_xt(self, t, x0, x1):
+        """Sample xt from time-dependent density p_t; rng is required"""
+        xt = self.compute_mu_t(t, x0, x1)
+        return xt
+    
+    def compute_ut(self, t, x0, x1, xt):
+        """Compute the vector field corresponding to p_t"""
+        t = expand_t_like_x(t, x1)
+        _, d_alpha_t = self.compute_alpha_t(t)
+        _, d_sigma_t = self.compute_sigma_t(t)
+        return d_alpha_t * x1 + d_sigma_t * x0
+    
+    def plan(self, t, x0, x1):
+        xt = self.compute_xt(t, x0, x1)
+        ut = self.compute_ut(t, x0, x1, xt)
+        return t, xt, ut
+    
+
+class VPCPlan(ICPlan):
+    """class for VP path flow matching"""
+
+    def __init__(self, sigma_min=0.1, sigma_max=20.0):
+        self.sigma_min = sigma_min
+        self.sigma_max = sigma_max
+        self.log_mean_coeff = lambda t: -0.25 * ((1 - t) ** 2) * (self.sigma_max - self.sigma_min) - 0.5 * (1 - t) * self.sigma_min 
+        self.d_log_mean_coeff = lambda t: 0.5 * (1 - t) * (self.sigma_max - self.sigma_min) + 0.5 * self.sigma_min
+
+
+    def compute_alpha_t(self, t):
+        """Compute coefficient of x1"""
+        alpha_t = self.log_mean_coeff(t)
+        alpha_t = th.exp(alpha_t)
+        d_alpha_t = alpha_t * self.d_log_mean_coeff(t)
+        return alpha_t, d_alpha_t
+    
+    def compute_sigma_t(self, t):
+        """Compute coefficient of x0"""
+        p_sigma_t = 2 * self.log_mean_coeff(t)
+        sigma_t = th.sqrt(1 - th.exp(p_sigma_t))
+        d_sigma_t = th.exp(p_sigma_t) * (2 * self.d_log_mean_coeff(t)) / (-2 * sigma_t)
+        return sigma_t, d_sigma_t
+    
+    def compute_d_alpha_alpha_ratio_t(self, t):
+        """Special purposed function for computing numerical stabled d_alpha_t / alpha_t"""
+        return self.d_log_mean_coeff(t)
+
+    def compute_drift(self, x, t):
+        """Compute the drift term of the SDE"""
+        t = expand_t_like_x(t, x)
+        beta_t = self.sigma_min + (1 - t) * (self.sigma_max - self.sigma_min)
+        return -0.5 * beta_t * x, beta_t / 2
+    
+
+class GVPCPlan(ICPlan):
+    def __init__(self, sigma=0.0):
+        super().__init__(sigma)
+    
+    def compute_alpha_t(self, t):
+        """Compute coefficient of x1"""
+        alpha_t = th.sin(t * np.pi / 2)
+        d_alpha_t = np.pi / 2 * th.cos(t * np.pi / 2)
+        return alpha_t, d_alpha_t
+    
+    def compute_sigma_t(self, t):
+        """Compute coefficient of x0"""
+        sigma_t = th.cos(t * np.pi / 2)
+        d_sigma_t = -np.pi / 2 * th.sin(t * np.pi / 2)
+        return sigma_t, d_sigma_t
+    
+    def compute_d_alpha_alpha_ratio_t(self, t):
+        """Special purposed function for computing numerical stabled d_alpha_t / alpha_t"""
+        return np.pi / (2 * th.tan(t * np.pi / 2))

data/mdgen/transport/transport.py

@@ -0,0 +1,575 @@
+# https://github.com/willisma/SiT/
+import copy
+
+import torch
+import torch as th
+import numpy as np
+
+import enum
+
+from . import path
+
+
+def mean_flat(x, mask):
+    """
+    Take the mean over all non-batch dimensions.
+    """
+    return th.sum(x * mask, dim=list(range(1, len(x.size())))) / th.sum(mask, dim=list(range(1, len(x.size()))))
+
+
+from .integrators import ode, sde
+
+
+class ModelType(enum.Enum):
+    """
+    Which type of output the model predicts.
+    """
+
+    NOISE = enum.auto()  # the model predicts epsilon
+    SCORE = enum.auto()  # the model predicts \nabla \log p(x)
+    VELOCITY = enum.auto()  # the model predicts v(x)
+
+
+class PathType(enum.Enum):
+    """
+    Which type of path to use.
+    """
+
+    LINEAR = enum.auto()
+    GVP = enum.auto()
+    VP = enum.auto()
+
+
+class WeightType(enum.Enum):
+    """
+    Which type of weighting to use.
+    """
+
+    NONE = enum.auto()
+    VELOCITY = enum.auto()
+    LIKELIHOOD = enum.auto()
+
+
+def t_to_alpha(t, args):
+    """
+    Convert t to alpha for Dirichlet distribution.
+    """
+
+    return 1 * (1 - t) + t * args.alpha_max, (args.alpha_max - 1)
+
+
+class Transport:
+
+    def __init__(
+            self,
+            *,
+            args,
+            model_type,
+            path_type,
+            loss_type,
+            train_eps,
+            sample_eps,
+    ):
+        path_options = {
+            PathType.LINEAR: path.ICPlan,
+            PathType.GVP: path.GVPCPlan,
+            PathType.VP: path.VPCPlan,
+        }
+        self.args = args
+        self.loss_type = loss_type
+        self.model_type = model_type
+        self.path_sampler = path_options[path_type]()
+        self.train_eps = train_eps
+        self.sample_eps = sample_eps
+
+    def prior_logp(self, z):
+        '''
+            Standard multivariate normal prior
+            Assume z is batched
+        '''
+        shape = th.tensor(z.size())
+        N = th.prod(shape[1:])
+        _fn = lambda x: -N / 2. * np.log(2 * np.pi) - th.sum(x ** 2) / 2.
+        return th.vmap(_fn)(z)
+
+    def check_interval(
+            self,
+            train_eps,
+            sample_eps,
+            *,
+            diffusion_form="SBDM",
+            sde=False,
+            reverse=False,
+            eval=False,
+            last_step_size=0.0,
+    ):
+        t0 = 0
+        t1 = 1
+        eps = train_eps if not eval else sample_eps
+        if (type(self.path_sampler) in [path.VPCPlan]):
+
+            t1 = 1 - eps if (not sde or last_step_size == 0) else 1 - last_step_size
+
+        elif (type(self.path_sampler) in [path.ICPlan, path.GVPCPlan]) \
+                and (
+                self.model_type != ModelType.VELOCITY or sde):  # avoid numerical issue by taking a first
+            # semi-implicit step
+
+            t0 = eps if (diffusion_form == "SBDM" and sde) or self.model_type != ModelType.VELOCITY else 0
+            t1 = 1 - eps if (not sde or last_step_size == 0) else 1 - last_step_size
+
+        if reverse:
+            t0, t1 = 1 - t0, 1 - t1
+
+        return t0, t1
+
+    def sample(self, x1):
+        """Sampling x0 & t based on shape of x1 (if needed)
+          Args:
+            x1 - data point; [batch, *dim]
+        """
+
+        x0 = th.randn_like(x1)
+        t0, t1 = self.check_interval(self.train_eps, self.sample_eps)
+        t = th.rand((x1.shape[0],)) * (t1 - t0) + t0
+        t = t.to(x1)
+        return t, x0, x1
+
+    def training_losses(
+            self,
+            model,
+            x1,           # target tokens
+            aatype1=None, # target aatype
+            mask=None,
+            model_kwargs=None
+    ):
+        """Loss for training the score model
+        Args:
+        - model: backbone model; could be score, noise, or velocity
+        - x1: datapoint
+        - model_kwargs: additional arguments for the model
+        """
+
+        if model_kwargs == None:
+            model_kwargs = {}
+
+        t, x0, x1 = self.sample(x1)
+        t, xt, ut = self.path_sampler.plan(t, x0, x1)
+
+
+
+        if self.args.design:  # alterations made to the original SIT code to include dirichlet flow matching for design
+            assert self.model_type == ModelType.VELOCITY
+            if self.args.dynamic_mpnn or self.args.mpnn:
+                t = torch.ones_like(t, device=t.device)
+                x_d = torch.zeros(xt.shape[0], xt.shape[2], 20, device=xt.device)
+            else:
+                seq_one_hot = th.nn.functional.one_hot(aatype1, num_classes=20)
+                alphas, _ = t_to_alpha(t, self.args)
+                alphas = 1 + seq_one_hot * (alphas[:, None, None] - 1)
+                x_d = th.distributions.Dirichlet(alphas).sample()
+            x_d = x_d[:, None, :, :].expand(-1, xt.shape[1], -1, -1)
+            xt = th.cat([xt, x_d], dim=-1)
+
+        model_output = model(xt, t, **model_kwargs)
+        B, *_, C = xt.shape
+        if not (self.args.dynamic_mpnn or self.args.mpnn):
+            assert model_output.size() == (B, *xt.size()[1:-1], C)
+
+        if self.args.design:
+            if not (self.args.dynamic_mpnn or self.args.mpnn):
+                logits = model_output[:, :, :, -20:]
+                model_output = model_output[:, :, :, :-20]
+
+        terms = {}
+        terms['t'] = t
+        terms['pred'] = model_output
+        if not (self.args.dynamic_mpnn or self.args.mpnn):
+            if self.model_type == ModelType.VELOCITY:
+                terms['loss'] = mean_flat(((model_output - ut) ** 2), mask)
+            else:
+                _, drift_var = self.path_sampler.compute_drift(xt, t)
+                sigma_t, _ = self.path_sampler.compute_sigma_t(path.expand_t_like_x(t, xt))
+                if self.loss_type in [WeightType.VELOCITY]:
+                    weight = (drift_var / sigma_t) ** 2
+                elif self.loss_type in [WeightType.LIKELIHOOD]:
+                    weight = drift_var / (sigma_t ** 2)
+                elif self.loss_type in [WeightType.NONE]:
+                    weight = 1
+                else:
+                    raise NotImplementedError()
+
+                if self.model_type == ModelType.NOISE:
+                    terms['loss'] = mean_flat(weight * ((model_output - x0) ** 2), mask)
+                else:
+                    terms['loss'] = mean_flat(weight * ((model_output * sigma_t + x0) ** 2), mask)
+
+        # more changes for dirichlet flow matching
+
+        if self.args.design:
+            if self.args.dynamic_mpnn or self.args.mpnn:
+                logits = model_output
+                terms['loss_continuous'] = torch.tensor(torch.nan, device=xt.device)
+                loss_d = th.nn.functional.cross_entropy(logits.reshape(-1,20), aatype1.reshape(-1))
+                terms['loss'] = loss_d
+            else:
+                terms['loss_continuous'] = terms['loss']
+                seq_expanded = aatype1[:, None, :].expand(-1, xt.shape[1], -1)
+                loss_d = th.nn.functional.cross_entropy(logits.reshape(-1, 20), seq_expanded.reshape(-1))
+                terms['loss'] = loss_d * self.args.discrete_loss_weight + (1 - self.args.discrete_loss_weight) * terms['loss']
+            terms['loss_discrete'] = loss_d
+            terms['logits'] = logits
+
+        return terms
+
+    def get_drift(
+            self
+    ):
+        """member function for obtaining the drift of the probability flow ODE"""
+
+        def score_ode(x, t, model, **model_kwargs):
+            drift_mean, drift_var = self.path_sampler.compute_drift(x, t)
+            model_output = model(x, t, **model_kwargs)
+            return (-drift_mean + drift_var * model_output)  # by change of variable
+
+        def noise_ode(x, t, model, **model_kwargs):
+            drift_mean, drift_var = self.path_sampler.compute_drift(x, t)
+            sigma_t, _ = self.path_sampler.compute_sigma_t(path.expand_t_like_x(t, x))
+            model_output = model(x, t, **model_kwargs)
+            score = model_output / -sigma_t
+            return (-drift_mean + drift_var * score)
+
+        def velocity_ode(x, t, model, **model_kwargs):
+            model_output = model(x, t, **model_kwargs)
+            return model_output
+
+        if self.model_type == ModelType.NOISE:
+            drift_fn = noise_ode
+        elif self.model_type == ModelType.SCORE:
+            drift_fn = score_ode
+        else:
+            drift_fn = velocity_ode
+
+        def body_fn(x, t, model, **model_kwargs):
+            model_output = drift_fn(x, t, model, **model_kwargs)
+            assert model_output.shape == x.shape, "Output shape from ODE solver must match input shape"
+            return model_output
+
+        return body_fn
+
+    def get_score(
+            self,
+    ):
+        """member function for obtaining score of 
+            x_t = alpha_t * x + sigma_t * eps"""
+        if self.model_type == ModelType.NOISE:
+            score_fn = lambda x, t, model, **kwargs: model(x, t, **kwargs) / - \
+                self.path_sampler.compute_sigma_t(path.expand_t_like_x(t, x))[0]
+        elif self.model_type == ModelType.SCORE:
+            score_fn = lambda x, t, model, **kwagrs: model(x, t, **kwagrs)
+        elif self.model_type == ModelType.VELOCITY:
+            score_fn = lambda x, t, model, **kwargs: self.path_sampler.get_score_from_velocity(model(x, t, **kwargs), x,
+                                                                                               t)
+        else:
+            raise NotImplementedError()
+
+        return score_fn
+
+
+class Sampler:
+    """Sampler class for the transport model"""
+
+    def __init__(
+            self,
+            transport,
+    ):
+        """Constructor for a general sampler; supporting different sampling methods
+        Args:
+        - transport: an tranport object specify model prediction & interpolant type
+        """
+
+        self.transport = transport
+        self.drift = self.transport.get_drift()
+        self.score = self.transport.get_score()
+
+    def __get_sde_diffusion_and_drift(
+            self,
+            *,
+            diffusion_form="SBDM",
+            diffusion_norm=1.0,
+    ):
+
+        def diffusion_fn(x, t):
+            diffusion = self.transport.path_sampler.compute_diffusion(x, t, form=diffusion_form, norm=diffusion_norm)
+            return diffusion
+
+        sde_drift = \
+            lambda x, t, model, **kwargs: \
+                self.drift(x, t, model, **kwargs) + diffusion_fn(x, t) * self.score(x, t, model, **kwargs)
+
+        sde_diffusion = diffusion_fn
+
+        return sde_drift, sde_diffusion
+
+    def __get_last_step(
+            self,
+            sde_drift,
+            *,
+            last_step,
+            last_step_size,
+    ):
+        """Get the last step function of the SDE solver"""
+
+        if last_step is None:
+            last_step_fn = \
+                lambda x, t, model, **model_kwargs: \
+                    x
+        elif last_step == "Mean":
+            last_step_fn = \
+                lambda x, t, model, **model_kwargs: \
+                    x + sde_drift(x, t, model, **model_kwargs) * last_step_size
+        elif last_step == "Tweedie":
+            alpha = self.transport.path_sampler.compute_alpha_t  # simple aliasing; the original name was too long
+            sigma = self.transport.path_sampler.compute_sigma_t
+            last_step_fn = \
+                lambda x, t, model, **model_kwargs: \
+                    x / alpha(t)[0][0] + (sigma(t)[0][0] ** 2) / alpha(t)[0][0] * self.score(x, t, model,
+                                                                                             **model_kwargs)
+        elif last_step == "Euler":
+            last_step_fn = \
+                lambda x, t, model, **model_kwargs: \
+                    x + self.drift(x, t, model, **model_kwargs) * last_step_size
+        else:
+            raise NotImplementedError()
+
+        return last_step_fn
+
+    def sample_sde(
+            self,
+            *,
+            sampling_method="Euler",
+            diffusion_form="SBDM",
+            diffusion_norm=1.0,
+            last_step="Mean",
+            last_step_size=0.04,
+            num_steps=250,
+    ):
+        """returns a sampling function with given SDE settings
+        Args:
+        - sampling_method: type of sampler used in solving the SDE; default to be Euler-Maruyama
+        - diffusion_form: function form of diffusion coefficient; default to be matching SBDM
+        - diffusion_norm: function magnitude of diffusion coefficient; default to 1
+        - last_step: type of the last step; default to identity
+        - last_step_size: size of the last step; default to match the stride of 250 steps over [0,1]
+        - num_steps: total integration step of SDE
+        """
+
+        if last_step is None:
+            last_step_size = 0.0
+
+        sde_drift, sde_diffusion = self.__get_sde_diffusion_and_drift(
+            diffusion_form=diffusion_form,
+            diffusion_norm=diffusion_norm,
+        )
+
+        t0, t1 = self.transport.check_interval(
+            self.transport.train_eps,
+            self.transport.sample_eps,
+            diffusion_form=diffusion_form,
+            sde=True,
+            eval=True,
+            reverse=False,
+            last_step_size=last_step_size,
+        )
+
+        _sde = sde(
+            sde_drift,
+            sde_diffusion,
+            t0=t0,
+            t1=t1,
+            num_steps=num_steps,
+            sampler_type=sampling_method
+        )
+
+        last_step_fn = self.__get_last_step(sde_drift, last_step=last_step, last_step_size=last_step_size)
+
+        def _sample(init, model, **model_kwargs):
+            xs = _sde.sample(init, model, **model_kwargs)
+            ts = th.ones(init.size(0), device=init.device) * t1
+            x = last_step_fn(xs[-1], ts, model, **model_kwargs)
+            xs.append(x)
+
+            assert len(xs) == num_steps, "Samples does not match the number of steps"
+
+            return xs
+
+        return _sample
+
+    def sample_ode(
+            self,
+            *,
+            sampling_method="dopri5",
+            num_steps=50,
+            atol=1e-6,
+            rtol=1e-3,
+            reverse=False,
+    ):
+        """returns a sampling function with given ODE settings
+        Args:
+        - sampling_method: type of sampler used in solving the ODE; default to be Dopri5
+        - num_steps: 
+            - fixed solver (Euler, Heun): the actual number of integration steps performed
+            - adaptive solver (Dopri5): the number of datapoints saved during integration; produced by interpolation
+        - atol: absolute error tolerance for the solver
+        - rtol: relative error tolerance for the solver
+        - reverse: whether solving the ODE in reverse (data to noise); default to False
+        """
+        if reverse:
+            drift = lambda x, t, model, **kwargs: self.drift(x, th.ones_like(t) * (1 - t), model, **kwargs)
+        else:
+            drift = self.drift
+
+        t0, t1 = self.transport.check_interval(
+            self.transport.train_eps,
+            self.transport.sample_eps,
+            sde=False,
+            eval=True,
+            reverse=reverse,
+            last_step_size=0.0,
+        )
+
+        _ode = ode(
+            drift=drift,
+            t0=t0,
+            t1=t1,
+            sampler_type=sampling_method,
+            num_steps=num_steps,
+            atol=atol,
+            rtol=rtol,
+        )
+
+        return _ode.sample
+
+    def sample_ode_likelihood(
+            self,
+            *,
+            sampling_method="dopri5",
+            num_steps=50,
+            atol=1e-6,
+            rtol=1e-3,
+    ):
+
+        """returns a sampling function for calculating likelihood with given ODE settings
+        Args:
+        - sampling_method: type of sampler used in solving the ODE; default to be Dopri5
+        - num_steps: 
+            - fixed solver (Euler, Heun): the actual number of integration steps performed
+            - adaptive solver (Dopri5): the number of datapoints saved during integration; produced by interpolation
+        - atol: absolute error tolerance for the solver
+        - rtol: relative error tolerance for the solver
+        """
+
+        def _likelihood_drift(x, t, model, **model_kwargs):
+            x, _ = x
+            eps = th.randint(2, x.size(), dtype=th.float, device=x.device) * 2 - 1
+            t = th.ones_like(t) * (1 - t)
+            with th.enable_grad():
+                x.requires_grad = True
+                grad = th.autograd.grad(th.sum(self.drift(x, t, model, **model_kwargs) * eps), x)[0]
+                logp_grad = th.sum(grad * eps, dim=tuple(range(1, len(x.size()))))
+                drift = self.drift(x, t, model, **model_kwargs)
+            return (-drift, logp_grad)
+
+        t0, t1 = self.transport.check_interval(
+            self.transport.train_eps,
+            self.transport.sample_eps,
+            sde=False,
+            eval=True,
+            reverse=False,
+            last_step_size=0.0,
+        )
+
+        _ode = ode(
+            drift=_likelihood_drift,
+            t0=t0,
+            t1=t1,
+            sampler_type=sampling_method,
+            num_steps=num_steps,
+            atol=atol,
+            rtol=rtol,
+        )
+
+        def _sample_fn(x, model, **model_kwargs):
+            init_logp = th.zeros(x.size(0)).to(x)
+            input = (x, init_logp)
+            drift, delta_logp = _ode.sample(input, model, **model_kwargs)
+            drift, delta_logp = drift[-1], delta_logp[-1]
+            prior_logp = self.transport.prior_logp(drift)
+            logp = prior_logp - delta_logp
+            return logp, drift
+
+        return _sample_fn
+
+
+def create_transport(
+        args,
+        path_type='Linear',
+        prediction="velocity",
+        loss_weight=None,
+        train_eps=None,
+        sample_eps=None,
+):
+    """function for creating Transport object
+    **Note**: model prediction defaults to velocity
+    Args:
+    - path_type: type of path to use; default to linear
+    - learn_score: set model prediction to score
+    - learn_noise: set model prediction to noise
+    - velocity_weighted: weight loss by velocity weight
+    - likelihood_weighted: weight loss by likelihood weight
+    - train_eps: small epsilon for avoiding instability during training
+    - sample_eps: small epsilon for avoiding instability during sampling
+    """
+
+    if prediction == "noise":
+        model_type = ModelType.NOISE
+    elif prediction == "score":
+        model_type = ModelType.SCORE
+    else:
+        model_type = ModelType.VELOCITY
+
+    if loss_weight == "velocity":
+        loss_type = WeightType.VELOCITY
+    elif loss_weight == "likelihood":
+        loss_type = WeightType.LIKELIHOOD
+    else:
+        loss_type = WeightType.NONE
+
+    path_choice = {
+        "Linear": PathType.LINEAR,
+        "GVP": PathType.GVP,
+        "VP": PathType.VP,
+    }
+
+    path_type = path_choice[path_type]
+    if (path_type in [PathType.VP]):
+        train_eps = 1e-5 if train_eps is None else train_eps
+        sample_eps = 1e-3 if sample_eps is None else sample_eps
+    elif (path_type in [PathType.GVP, PathType.LINEAR] and model_type != ModelType.VELOCITY):
+        train_eps = 1e-3 if train_eps is None else train_eps
+        sample_eps = 1e-3 if sample_eps is None else sample_eps
+    else:  # velocity & [GVP, LINEAR] is stable everywhere
+        train_eps = 0
+        sample_eps = 0
+
+    # create flow state
+    state = Transport(
+        args=args,
+        model_type=model_type,
+        path_type=path_type,
+        loss_type=loss_type,
+        train_eps=train_eps,
+        sample_eps=sample_eps,
+    )
+
+    return state

data/mdgen/utils.py

@@ -0,0 +1,101 @@
+import numpy as np
+import scipy
+import torch
+from . import protein
+from .geometry import atom14_to_atom37
+
+def get_offsets(ref_frame, rigids):
+    B, T, L = rigids.shape
+    if T > 500000:
+        offsets1 = ref_frame.invert().compose(rigids[:, : 500000]).to_tensor_7()
+        offsets2 = ref_frame.invert().compose(rigids[:, 500000:]).to_tensor_7()
+        return torch.cat([offsets1, offsets2], 1)
+    else:
+        return ref_frame.invert().compose(rigids).to_tensor_7()
+
+def simplex_proj(seq):
+    """Algorithm from https://arxiv.org/abs/1309.1541 Weiran Wang, Miguel Á. Carreira-Perpiñán"""
+    Y = seq.reshape(-1, seq.shape[-1])
+    N, K = Y.shape
+    X, _ = torch.sort(Y, dim=-1, descending=True)
+    X_cumsum = torch.cumsum(X, dim=-1) - 1
+    div_seq = torch.arange(1, K + 1, dtype=Y.dtype, device=Y.device)
+    Xtmp = X_cumsum / div_seq.unsqueeze(0)
+
+    greater_than_Xtmp = (X > Xtmp).sum(dim=1, keepdim=True)
+    row_indices = torch.arange(N, dtype=torch.long, device=Y.device).unsqueeze(1)
+    selected_Xtmp = Xtmp[row_indices, greater_than_Xtmp - 1]
+
+    X = torch.max(Y - selected_Xtmp, torch.zeros_like(Y))
+    return X.view(seq.shape)
+
+class DirichletConditionalFlow:
+    def __init__(self, K=20, alpha_min=1, alpha_max=100, alpha_spacing=0.01):
+        self.alphas = np.arange(alpha_min, alpha_max + alpha_spacing, alpha_spacing)
+        self.beta_cdfs = []
+        self.bs = np.linspace(0, 1, 1000)
+        for alph in self.alphas:
+            self.beta_cdfs.append(scipy.special.betainc(alph, K-1, self.bs))
+        self.beta_cdfs = np.array(self.beta_cdfs)
+        self.beta_cdfs_derivative = np.diff(self.beta_cdfs, axis=0) / alpha_spacing
+        self.alpha_spacing = alpha_spacing
+        self.K = K
+
+    def c_factor(self, bs, alpha):
+        # if the bs is close to the edge of the simplex in one of its entries, then we want the c factor to be 0 for high alphas.
+        # That is the rationale for why we return 0s in the case of an overflow.
+
+        beta = scipy.special.beta(alpha, self.K - 1) # betafunction(alpha, K-1)
+        beta_div = np.where(bs < 1, beta / ((1 - bs) ** (self.K - 1)), 0)
+        beta_div_full = np.where((bs ** (alpha - 1)) > 0, beta_div / (bs ** (alpha - 1)), 0)
+
+        I_func = self.beta_cdfs_derivative[np.argmin(np.abs(alpha - self.alphas))]
+        interp = -np.interp(bs, self.bs, I_func)
+
+        final = interp * beta_div_full
+        return final
+
+def atom14_to_pdb(atom14, aatype, path):
+    prots = []
+    for i, pos in enumerate(atom14):
+        pos = atom14_to_atom37(pos, aatype)
+        prots.append(create_full_prot(pos, aatype=aatype))
+    with open(path, 'w') as f:
+        f.write(prots_to_pdb(prots))
+
+
+def create_full_prot(
+        atom37: np.ndarray,
+        aatype=None,
+        b_factors=None,
+    ):
+    assert atom37.ndim == 3
+    assert atom37.shape[-1] == 3
+    assert atom37.shape[-2] == 37
+    n = atom37.shape[0]
+    residue_index = np.arange(n)
+    atom37_mask = np.sum(np.abs(atom37), axis=-1) > 1e-7
+    if b_factors is None:
+        b_factors = np.zeros([n, 37])
+    if aatype is None:
+        aatype = np.zeros(n, dtype=int)
+    chain_index = np.zeros(n, dtype=int)
+    return protein.Protein(
+        atom_positions=atom37,
+        atom_mask=atom37_mask,
+        aatype=aatype,
+        residue_index=residue_index,
+        b_factors=b_factors,
+        chain_index=chain_index
+    )
+
+
+def prots_to_pdb(prots):
+    ss = ''
+    for i, prot in enumerate(prots):
+        ss += f'MODEL {i}\n'
+        prot = protein.to_pdb(prot)
+        ss += '\n'.join(prot.split('\n')[2:-3])
+        ss += '\nENDMDL\n'
+    return ss
+

data/mdgen/wrapper.py

@@ -0,0 +1,507 @@
+from .ema import ExponentialMovingAverage
+from .logger import get_logger
+from .residue_constants import aatype_to_str_sequence
+
+logger = get_logger(__name__)
+
+import pytorch_lightning as pl
+import torch, time, os, wandb
+import numpy as np
+import pandas as pd
+from .rigid_utils import Rigid, Rotation
+from collections import defaultdict
+from functools import partial
+
+from .model.latent_model import LatentMDGenModel
+from .transport.transport import create_transport, Sampler
+from .utils import get_offsets, atom14_to_pdb
+from .tensor_utils import tensor_tree_map
+from .geometry import frames_torsions_to_atom14, atom37_to_atom14
+
+
+def gather_log(log, world_size):
+    if world_size == 1:
+        return log
+    log_list = [None] * world_size
+    torch.distributed.all_gather_object(log_list, log)
+    log = {key: sum([l[key] for l in log_list], []) for key in log}
+    return log
+
+
+def get_log_mean(log):
+    out = {}
+    for key in log:
+        try:
+            out[key] = np.nanmean(log[key])
+        except:
+            pass
+    return out
+
+
+DESIGN_IDX = [1, 2]
+COND_IDX = [0, 3]
+DESIGN_MAP_TO_COND = [0, 0, 3, 3]
+
+
+class Wrapper(pl.LightningModule):
+
+    def __init__(self, args):
+        super().__init__()
+        self.save_hyperparameters()
+        self.args = args
+        self._log = defaultdict(list)
+        self.last_log_time = time.time()
+        self.iter_step = 0
+
+    def log(self, key, data):
+        if isinstance(data, torch.Tensor):
+            data = data.mean().item()
+        log = self._log
+        if self.stage == 'train' or self.args.validate:
+            log["iter_" + key].append(data)
+        log[self.stage + "_" + key].append(data)
+
+    def load_ema_weights(self):
+        # model.state_dict() contains references to model weights rather
+        # than copies. Therefore, we need to clone them before calling 
+        # load_state_dict().
+        logger.info('Loading EMA weights')
+        clone_param = lambda t: t.detach().clone()
+        self.cached_weights = tensor_tree_map(clone_param, self.model.state_dict())
+        self.model.load_state_dict(self.ema.state_dict()["params"])
+
+    def restore_cached_weights(self):
+        logger.info('Restoring cached weights')
+        self.model.load_state_dict(self.cached_weights)
+        self.cached_weights = None
+
+    def on_before_zero_grad(self, *args, **kwargs):
+        if self.args.ema:
+            self.ema.update(self.model)
+
+    def training_step(self, batch, batch_idx):
+        if self.args.ema:
+            if (self.ema.device != self.device):
+                self.ema.to(self.device)
+        return self.general_step(batch, stage='train')
+
+    def validation_step(self, batch, batch_idx):
+        if self.args.ema:
+            if (self.ema.device != self.device):
+                self.ema.to(self.device)
+            if (self.cached_weights is None):
+                self.load_ema_weights()
+
+        self.general_step(batch, stage='val')
+        self.validation_step_extra(batch, batch_idx)
+        if self.args.validate and self.iter_step % self.args.print_freq == 0:
+            self.print_log()
+
+    def validation_step_extra(self, batch, batch_idx):
+        pass
+
+    def on_train_epoch_end(self):
+        self.print_log(prefix='train', save=False)
+
+    def on_validation_epoch_end(self):
+        if self.args.ema:
+            self.restore_cached_weights()
+        self.print_log(prefix='val', save=False)
+
+    def on_before_optimizer_step(self, optimizer):
+        if (self.trainer.global_step + 1) % self.args.print_freq == 0:
+            self.print_log()
+
+        if self.args.check_grad:
+            for name, p in self.model.named_parameters():
+                if p.grad is None:
+                    logger.warning(f"Param {name} has no grad")
+
+    def on_load_checkpoint(self, checkpoint):
+        logger.info('Loading EMA state dict')
+        if self.args.ema:
+            ema = checkpoint["ema"]
+            self.ema.load_state_dict(ema)
+
+    def on_save_checkpoint(self, checkpoint):
+        if self.args.ema:
+            if self.cached_weights is not None:
+                self.restore_cached_weights()
+            checkpoint["ema"] = self.ema.state_dict()
+
+    def print_log(self, prefix='iter', save=False, extra_logs=None):
+        log = self._log
+        log = {key: log[key] for key in log if f"{prefix}_" in key}
+        log = gather_log(log, self.trainer.world_size)
+        mean_log = get_log_mean(log)
+
+        mean_log.update({
+            'epoch': self.trainer.current_epoch,
+            'trainer_step': self.trainer.global_step + int(prefix == 'iter'),
+            'iter_step': self.iter_step,
+            f'{prefix}_count': len(log[next(iter(log))]),
+
+        })
+        if extra_logs:
+            mean_log.update(extra_logs)
+        try:
+            for param_group in self.optimizers().optimizer.param_groups:
+                mean_log['lr'] = param_group['lr']
+        except:
+            pass
+
+        if self.trainer.is_global_zero:
+            logger.info(str(mean_log))
+            if self.args.wandb:
+                wandb.log(mean_log)
+            if save:
+                path = os.path.join(
+                    os.environ["MODEL_DIR"],
+                    f"{prefix}_{self.trainer.current_epoch}.csv"
+                )
+                pd.DataFrame(log).to_csv(path)
+        for key in list(log.keys()):
+            if f"{prefix}_" in key:
+                del self._log[key]
+
+    def configure_optimizers(self):
+        cls = torch.optim.AdamW if self.args.adamW else torch.optim.Adam
+        optimizer = cls(
+            filter(lambda p: p.requires_grad, self.model.parameters()), lr=self.args.lr,
+        )
+        return optimizer
+
+
+class NewMDGenWrapper(Wrapper):
+    def __init__(self, args):
+        super().__init__(args)
+        for key in [
+            'inpainting',
+            'no_torsion',
+            'hyena',
+            'no_aa_emb',
+            'supervise_all_torsions',
+            'supervise_no_torsions',
+            'design_key_frames',
+            'no_design_torsion',
+            'cond_interval',
+            'mpnn',
+            'dynamic_mpnn',
+            'no_offsets',
+            'no_frames',
+        ]:
+            if not hasattr(args, key):
+                setattr(args, key, False)
+        # args.latent_dim = 7 if not self.args.tps_condition else 14
+        latent_dim = 21 if not (self.args.tps_condition or self.args.inpainting or self.args.dynamic_mpnn) else 28
+        if args.design:
+            latent_dim += 20
+        if args.no_frames:
+            latent_dim = 111
+        
+        self.latent_dim = latent_dim
+        self.model = LatentMDGenModel(args, latent_dim)
+
+        self.transport = create_transport(
+            args,
+            args.path_type,
+            args.prediction,
+            None,  # args.loss_weight,
+            # args.train_eps,
+            # args.sample_eps,
+        )  # default: velocity; 
+        self.transport_sampler = Sampler(self.transport)
+
+        if not hasattr(args, 'ema'):
+            args.ema = False
+        if args.ema:
+            self.ema = ExponentialMovingAverage(
+                model=self.model, decay=args.ema_decay
+            )
+            self.cached_weights = None
+
+    def prep_hyena_batch(self, batch):
+        B, T, L, _ = batch['latents'].shape
+        rigids = Rigid(trans=batch['trans'], rots=Rotation(rot_mats=batch['rots']))
+
+        ########
+        cond_mask = torch.zeros(B, T, L, dtype=int, device=self.device)
+        if self.args.sim_condition:
+            cond_mask[:, 0] = 1
+        if self.args.tps_condition:
+            cond_mask[:, 0] = cond_mask[:, -1] = 1
+        if self.args.cond_interval:
+            cond_mask[:, ::self.args.cond_interval] = 1
+        if self.args.inpainting or self.args.dynamic_mpnn or self.args.mpnn:
+            cond_mask[:, :, COND_IDX] = 1
+
+        aatype_mask = torch.ones_like(batch['seqres'])
+        if self.args.design:
+            aatype_mask[:, DESIGN_IDX] = 0
+        ######## 
+        return {
+            'latents': batch['latents'].float(),
+            'loss_mask': batch['loss_mask'].unsqueeze(1).expand(-1, T, -1, -1),
+            'model_kwargs': {
+                'start_frames': rigids,
+                'mask': batch['mask'].unsqueeze(1).expand(-1, T, -1),
+                'aatype': torch.where(aatype_mask.bool(), batch['seqres'], 20),
+                'x_cond': torch.where(cond_mask.unsqueeze(-1).bool(), batch['latents'].float(), 0.0),
+                'x_cond_mask': cond_mask,
+            }
+        }
+
+    def prep_batch_no_frames(self, batch):
+        
+        B, T, L, _, _ = batch['atom37'].shape
+        
+        latents = batch['atom37'].reshape(B, T, L, 111)
+        mask = batch['mask'][:,None,:,1].expand(-1, T, -1)
+
+        loss_mask = batch['mask'][:,None,:,:,None].expand(-1, T, -1, -1, 3)
+        loss_mask = loss_mask.reshape(B, T, L, 111)
+        
+        ########
+        cond_mask = torch.zeros(B, T, L, dtype=int, device=mask.device)
+        if self.args.sim_condition:
+            cond_mask[:, 0] = 1
+            
+        aatype_mask = torch.ones_like(batch['seqres'])
+
+        return {
+            'latents': latents,
+            'loss_mask': loss_mask,
+            'model_kwargs': {
+                'mask': mask,
+                'aatype': torch.where(aatype_mask.bool(), batch['seqres'], 20),
+                'x_cond': torch.where(cond_mask.unsqueeze(-1).bool(), latents, 0.0),
+                'x_cond_mask': cond_mask,
+            }
+        }
+
+        
+    def prep_batch(self, batch):
+
+        if self.args.no_frames:
+            return self.prep_batch_no_frames(batch)
+
+        # if self.args.hyena:
+        if 'latents' in batch:
+            return self.prep_hyena_batch(batch)
+
+        rigids = Rigid(
+            trans=batch['trans'],
+            rots=Rotation(rot_mats=batch['rots'])
+        )  # B, T, L
+        B, T, L = rigids.shape
+        if self.args.design_key_frames:
+            rigids = Rigid.cat([
+                rigids[:, :1, DESIGN_MAP_TO_COND],  # replace designed rototranslations in the key frames
+                rigids[:, 1:-1],
+                rigids[:, -1:, DESIGN_MAP_TO_COND]
+            ], 1)
+
+        if self.args.no_offsets:
+            offsets = rigids.to_tensor_7()
+        else:
+            offsets = get_offsets(rigids[:, 0:1], rigids)
+        #### make sure the quaternions have real part
+        offsets[..., :4] *= torch.where(offsets[:, :, :, 0:1] < 0, -1, 1)
+
+        frame_loss_mask = batch['mask'].unsqueeze(-1).expand(-1, -1, 7)  # B, L, 7
+        torsion_loss_mask = batch['torsion_mask'].unsqueeze(-1).expand(-1, -1, -1, 2).reshape(B, L, 14)
+
+        if self.args.tps_condition or self.args.inpainting or self.args.dynamic_mpnn:
+            offsets_r = get_offsets(rigids[:, -1:], rigids)
+            offsets_r[..., :4] *= torch.where(offsets_r[:, :, :, 0:1] < 0, -1, 1)
+            offsets = torch.cat([offsets, offsets_r], -1)
+            frame_loss_mask = torch.cat([frame_loss_mask, frame_loss_mask], -1)
+
+        if self.args.no_torsion:
+            latents = torch.cat([offsets, torch.zeros_like(batch['torsions'].view(B, T, L, 14))], -1)
+        elif self.args.no_design_torsion:
+            torsions_ = batch['torsions'].clone()
+            torsions_[:, :, DESIGN_IDX] = 0
+            latents = torch.cat([offsets, torsions_.view(B, T, L, 14)], -1)
+        else:
+            latents = torch.cat([offsets, batch['torsions'].view(B, T, L, 14)], -1)
+
+        if self.args.supervise_all_torsions:
+            torsion_loss_mask = torch.ones_like(torsion_loss_mask)
+        elif self.args.supervise_no_torsions:
+            torsion_loss_mask = torch.zeros_like(torsion_loss_mask)
+
+        loss_mask = torch.cat([frame_loss_mask, torsion_loss_mask], -1)
+        loss_mask = loss_mask.unsqueeze(1).expand(-1, T, -1, -1)
+
+        ########
+        cond_mask = torch.zeros(B, T, L, dtype=int, device=offsets.device)
+        if self.args.sim_condition:
+            cond_mask[:, 0] = 1
+        if self.args.tps_condition:
+            cond_mask[:, 0] = cond_mask[:, -1] = 1
+        if self.args.cond_interval:
+            cond_mask[:, ::self.args.cond_interval] = 1
+        if self.args.inpainting or self.args.dynamic_mpnn or self.args.mpnn:
+            cond_mask[:, :, COND_IDX] = 1
+
+        aatype_mask = torch.ones_like(batch['seqres'])
+        if self.args.design:
+            aatype_mask[:, DESIGN_IDX] = 0
+        ######## 
+
+        return {
+            'rigids': rigids,
+            'latents': latents,
+            'loss_mask': loss_mask,
+            'model_kwargs': {
+                'start_frames': rigids[:, 0],
+                'end_frames': rigids[:, -1],
+                'mask': batch['mask'].unsqueeze(1).expand(-1, T, -1),
+                'aatype': torch.where(aatype_mask.bool(), batch['seqres'], 20),
+                'x_cond': torch.where(cond_mask.unsqueeze(-1).bool(), latents, 0.0),
+                'x_cond_mask': cond_mask,
+            }
+        }
+
+    def general_step(self, batch, stage='train'):
+        self.iter_step += 1
+        self.stage = stage
+        start1 = time.time()
+
+        prep = self.prep_batch(batch)
+
+        start = time.time()
+        out_dict = self.transport.training_losses(
+            model=self.model,
+            x1=prep['latents'],
+            aatype1=batch['seqres'] if self.args.design else None,
+            mask=prep['loss_mask'],
+            model_kwargs=prep['model_kwargs']
+        )
+        self.log('model_dur', time.time() - start)
+        loss = out_dict['loss']
+        self.log('loss', loss)
+
+        if self.args.design:
+            aa_out = torch.argmax(out_dict['logits'], dim=-1)
+            aa_recovery = aa_out == batch['seqres'][:, None, :].expand(-1, aa_out.shape[1], -1)
+
+            self.log('category_pred_design_aa_recovery', aa_recovery[:, :, 1:-1].float().mean().item())
+            cond_aa_recovery = torch.cat([aa_recovery[:, :, 0:1], aa_recovery[:, :, -1:]], 2)
+            self.log('category_pred_cond_aa_recovery', cond_aa_recovery.float().mean().item())
+
+            self.log('loss_continuous', out_dict['loss_continuous'].mean())
+            self.log('loss_discrete', out_dict['loss_discrete'])
+
+        self.log('time', out_dict['t'])
+        self.log('dur', time.time() - self.last_log_time)
+        if 'name' in batch:
+            self.log('name', ','.join(batch['name']))
+        self.log('general_step_dur', time.time() - start1)
+        self.last_log_time = time.time()
+        return loss.mean()
+
+    def inference(self, batch):
+
+        prep = self.prep_batch(batch)
+
+        latents = prep['latents']
+        if not self.args.no_frames:
+            rigids = prep['rigids']
+            B, T, L = rigids.shape
+        else:
+            B, T, L, _ = latents.shape
+
+        ### oracle
+        # if self.args.oracle:
+        #     assert self.args.sim_condition  # only works with that
+        #     offsets = get_offsets(rigids[:, 0:1], rigids)
+        #     torsions = batch['torsions'].view(B, T, L, 14)
+        # else:
+        if self.args.dynamic_mpnn or self.args.mpnn:
+            x1 = prep['latents']
+            x_d = torch.zeros(x1.shape[0], x1.shape[1], x1.shape[2], 20, device=self.device)
+            xt = torch.cat([x1, x_d], dim=-1)
+            logits = self.model.forward_inference(xt, torch.ones(B, device=self.device),
+                                                  **prep['model_kwargs'])
+            aa_out = torch.argmax(logits, -1)
+            atom14 = frames_torsions_to_atom14(rigids, batch['torsions'],
+                                               batch['seqres'][:, None].expand(B, T, L))
+            return atom14, aa_out
+
+        if self.args.design:
+            zs_continuous = torch.randn(B, T, L, self.latent_dim - 20, device=latents.device)
+            zs_discrete = torch.distributions.Dirichlet(torch.ones(B, L, 20, device=latents.device)).sample()
+            zs_discrete = zs_discrete[:, None].expand(-1, T, -1, -1)
+            zs = torch.cat([zs_continuous, zs_discrete], -1)
+        else:
+            zs = torch.randn(B, T, L, self.latent_dim, device=self.device)
+
+        sample_fn = self.transport_sampler.sample_ode(sampling_method=self.args.sampling_method)
+        # num_steps=self.args.inference_steps)  # default to ode
+
+        samples = sample_fn(
+            zs,
+            partial(self.model.forward_inference, **prep['model_kwargs'])
+        )[-1]
+
+        if self.args.no_frames:
+            atom14 = atom37_to_atom14(
+                samples.cpu().numpy().reshape(B, T, L, 37, 3),
+                batch['seqres'][0].cpu().numpy()
+            )
+            return torch.from_numpy(atom14).float(), None
+            
+        offsets = samples[..., :7]
+        
+        if self.args.tps_condition or self.args.inpainting:
+            torsions = samples[..., 14:28]
+            logits = samples[..., -20:]
+        else:
+            torsions = samples[..., 7:21]
+            logits = samples[..., -20:]
+
+        
+        if self.args.no_offsets:
+            frames = Rigid.from_tensor_7(offsets, normalize_quats=True)
+        else:
+            frames = rigids[:, 0:1].compose(Rigid.from_tensor_7(offsets, normalize_quats=True))
+        if self.args.design:
+            trans = frames.get_trans()
+            rots = frames.get_rots().get_rot_mats()
+            frames = Rigid(trans=trans, rots=Rotation(rot_mats=rots))
+        torsions = torsions.reshape(B, T, L, 7, 2)
+        if not self.args.oracle:
+            torsions = torsions / torch.linalg.norm(torsions, dim=-1, keepdims=True)
+        atom14 = frames_torsions_to_atom14(frames, torsions.view(B, T, L, 7, 2),
+                                           batch['seqres'][:, None].expand(B, T, L))
+
+        if self.args.design:
+            aa_out = torch.argmax(logits, -1)
+        else:
+            aa_out = batch['seqres'][:, None].expand(B, T, L)
+        return atom14, aa_out
+
+    def validation_step_extra(self, batch, batch_idx):
+
+        do_designability = batch_idx < self.args.inference_batches and (
+                (self.current_epoch + 1) % self.args.designability_freq == 0 or \
+                self.args.validate) and self.trainer.is_global_zero
+        if do_designability:
+            atom14, aa_out = self.inference(batch)
+            aa_recovery = aa_out == batch['seqres'][:, None, :].expand(-1, aa_out.shape[1], -1)
+            self.log('design_aa_recovery', aa_recovery[:, :, 1:-1].float().mean().item())
+            cond_aa_recovery = torch.cat([aa_recovery[:, :, 0:1], aa_recovery[:, :, -1:]], 2)
+            self.log('cond_aa_recovery', cond_aa_recovery.float().mean().item())
+            self.log('seq_pred', ','.join([aatype_to_str_sequence(aa) for aa in aa_out[:, 0]]))
+            self.log('seq_true', ','.join([aatype_to_str_sequence(aa) for aa in batch['seqres']]))
+            prot_name = batch['name'][0]
+            path = os.path.join(os.environ["MODEL_DIR"], f'epoch{self.current_epoch}_{prot_name}.pdb')
+
+            atom14_to_pdb(atom14[0].cpu().numpy(), batch['seqres'][0].cpu().numpy(), path)
+        else:
+            self.log('design_aa_recovery', np.nan)
+            self.log('cond_aa_recovery', np.nan)
+            self.log('seq_pred', 'nan')
+            self.log('seq_true', 'nan')

data/scripts/analyze_peptide_design.py

@@ -0,0 +1,96 @@
+import numpy as np
+import os
+import argparse
+from mdgen.residue_constants import aatype_to_str_sequence, restype_order
+import json
+from tqdm import tqdm
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--mddir', type=str, default='share/4AA_sims')
+parser.add_argument('--data_dir', type=str, default='share/4AA_sims_replica')
+parser.add_argument('--pdbdir', type=str, required=True)
+parser.add_argument('--split', type=str, default='splits/4AA_test.csv') 
+args = parser.parse_args()
+
+
+
+names = os.listdir(args.pdbdir)
+names = list(set([nam[:4] for nam in names if 'metadata.json' in nam]))
+
+metadatas = {name: json.load(open(f'{args.pdbdir}/{name}_metadata.json', 'rb')) for name in names}
+
+res = {}
+for name in names:
+    metadata = metadatas[name]
+    res[name] = [traj['aa_out'][0] for traj in metadata]
+
+designed_names = {}
+max_cond_recovery = 0
+max_design_recovery = 0
+
+all_recovery = 0
+design_recovery = 0
+final_design_recovery = 0
+most_frequent_middle_recovery = 0
+cond_recovery = 0
+for name in tqdm(names):
+    max_aa = []
+    name_numeric = np.array([restype_order[l] for l in name])
+    pred = np.array(res[name])
+    pred_str = [aatype_to_str_sequence(nam[1:-1]) for nam in pred]
+    
+    design_middles, index, counts = np.unique(np.array(pred_str), return_counts=True, return_index=True)
+    most_freq_idx = index[np.argmax(counts)]
+    #design_middle = design_middles[np.argmax(counts)]
+    most_freq_pred = pred[most_freq_idx]
+    design_middle = aatype_to_str_sequence(most_freq_pred[1:-1])
+    most_frequent_middle_recovery += (most_freq_pred == name_numeric)[1:-1].mean()
+        
+    recovery = (pred == name_numeric[None, :])
+    design_recovery += recovery[:, 1:-1].mean()
+    cond_recovery += np.concatenate([recovery[:, -1], recovery[:, 0]]).mean()
+
+    final_design_idx = np.argsort(recovery[:,0].astype(float) + recovery[:,-1].astype(float))[0]
+    final_design_name = pred[final_design_idx]
+    final_design_recovery += (name_numeric[1:-1] == final_design_name[1:-1]).mean()
+    
+    for i in range(4):
+        letters, counts = np.unique(np.array(res[name])[:,i], return_counts=True)
+        max_aa.append(letters[np.argmax(counts)])
+    max_aa = np.array(max_aa)
+    max_cond_recovery += ((name_numeric[0] == max_aa[0]).astype(float) + (name_numeric[-1] == max_aa[-1]).astype(float)) / 2
+    max_design_recovery += (name_numeric[1:-1] == max_aa[1:-1]).mean()
+
+    designed_name = name[0] + design_middle + name[-1]
+    
+
+    metadata = metadatas[name]
+    start_idx = metadata[most_freq_idx]['start_idx']
+    end_idx = metadata[most_freq_idx]['end_idx']
+
+    designed_names[name] = {
+        'designed_name': designed_name,
+        'start_idx': start_idx,
+        'end_idx': end_idx,
+        'start_state': metadata[most_freq_idx]['start_state'],
+        'end_state': metadata[most_freq_idx]['end_state']
+    }
+
+
+cond_recovery = cond_recovery / len(names)
+design_recovery = design_recovery / len(names)
+
+max_cond_recovery = max_cond_recovery / len(names)
+max_design_recovery = max_design_recovery / len(names)
+
+final_design_recovery = final_design_recovery/ len(names)
+most_frequent_middle_recovery = most_frequent_middle_recovery/ len(names)
+
+print('cond_recovery', cond_recovery)
+print('max_cond_recovery', max_cond_recovery)
+
+print('design_recovery', design_recovery)
+print('max_design_recovery', max_design_recovery)
+
+print('final_design_recovery', final_design_recovery)
+print('most_frequent_middle_recovery', most_frequent_middle_recovery)

data/scripts/analyze_peptide_sim.py

@@ -0,0 +1,229 @@
+import argparse
+parser = argparse.ArgumentParser()
+parser.add_argument('--mddir', type=str, default='share/4AA_sims')
+parser.add_argument('--pdbdir', type=str, required=True) 
+parser.add_argument('--save', action='store_true')
+parser.add_argument('--plot', action='store_true')
+parser.add_argument('--save_name', type=str, default='out.pkl')
+parser.add_argument('--pdb_id', nargs='*', default=[])
+parser.add_argument('--no_msm', action='store_true')
+parser.add_argument('--no_decorr', action='store_true')
+parser.add_argument('--no_traj_msm', action='store_true')
+parser.add_argument('--truncate', type=int, default=None)
+parser.add_argument('--msm_lag', type=int, default=10)
+parser.add_argument('--ito', action='store_true')
+parser.add_argument('--num_workers', type=int, default=1)
+
+args = parser.parse_args()
+
+import mdgen.analysis
+import pyemma, tqdm, os, pickle
+from scipy.spatial.distance import jensenshannon
+from multiprocessing import Pool
+import numpy as np
+import matplotlib.pyplot as plt
+from statsmodels.tsa.stattools import acovf, acf
+colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
+
+def main(name):
+    out = {}
+    np.random.seed(137)
+    fig, axs = plt.subplots(4, 4, figsize=(20, 20))
+
+    ### BACKBONE torsion marginals PLOT ONLY
+    if args.plot:
+        feats, traj = mdgen.analysis.get_featurized_traj(f'{args.pdbdir}/{name}', sidechains=False, cossin=False)
+        if args.truncate: traj = traj[:args.truncate]
+        feats, ref = mdgen.analysis.get_featurized_traj(f'{args.mddir}/{name}/{name}', sidechains=False, cossin=False)
+        pyemma.plots.plot_feature_histograms(ref, feature_labels=feats, ax=axs[0,0], color=colors[0])
+        pyemma.plots.plot_feature_histograms(traj, ax=axs[0,0], color=colors[1])
+        axs[0,0].set_title('BB torsions')
+
+    
+    ### JENSEN SHANNON DISTANCES ON ALL TORSIONS
+    feats, traj = mdgen.analysis.get_featurized_traj(f'{args.pdbdir}/{name}', sidechains=True, cossin=False)
+    if args.truncate: traj = traj[:args.truncate]
+    feats, ref = mdgen.analysis.get_featurized_traj(f'{args.mddir}/{name}/{name}', sidechains=True, cossin=False)
+
+    out['features'] = feats.describe()
+
+    out['JSD'] = {}
+    for i, feat in enumerate(feats.describe()):
+        ref_p = np.histogram(ref[:,i], range=(-np.pi, np.pi), bins=100)[0]
+        traj_p = np.histogram(traj[:,i], range=(-np.pi, np.pi), bins=100)[0]
+        out['JSD'][feat] = jensenshannon(ref_p, traj_p)
+
+    for i in [1,3]:
+        ref_p = np.histogram2d(*ref[:,i:i+2].T, range=((-np.pi, np.pi),(-np.pi,np.pi)), bins=50)[0]
+        traj_p = np.histogram2d(*traj[:,i:i+2].T, range=((-np.pi, np.pi),(-np.pi,np.pi)), bins=50)[0]
+        out['JSD']['|'.join(feats.describe()[i:i+2])] = jensenshannon(ref_p.flatten(), traj_p.flatten())
+
+    ############ Torsion decorrelations
+    if args.no_decorr:
+        pass
+    else:
+        out['md_decorrelation'] = {}
+        for i, feat in enumerate(feats.describe()):
+            
+            autocorr = acovf(np.sin(ref[:,i]), demean=False, adjusted=True, nlag=100000) + acovf(np.cos(ref[:,i]), demean=False, adjusted=True, nlag=100000)
+            baseline = np.sin(ref[:,i]).mean()**2 + np.cos(ref[:,i]).mean()**2
+            # E[(X(t) - E[X(t)]) * (X(t+dt) - E[X(t+dt)])] = E[X(t)X(t+dt) - E[X(t)]X(t+dt) - X(t)E[X(t+dt)] + E[X(t)]E[X(t+dt)]] = E[X(t)X(t+dt)] - E[X]**2
+            lags = 1 + np.arange(len(autocorr))
+            if 'PHI' in feat or 'PSI' in feat:
+                axs[0,1].plot(lags, (autocorr - baseline) / (1-baseline), color=colors[i%len(colors)])
+            else:
+                axs[0,2].plot(lags, (autocorr - baseline) / (1-baseline), color=colors[i%len(colors)])
+    
+            out['md_decorrelation'][feat] = (autocorr.astype(np.float16) - baseline) / (1-baseline)
+           
+        axs[0,1].set_title('Backbone decorrelation')
+        axs[0,2].set_title('Sidechain decorrelation')
+        axs[0,1].set_xscale('log')
+        axs[0,2].set_xscale('log')
+    
+        out['our_decorrelation'] = {}
+        for i, feat in enumerate(feats.describe()):
+            
+            autocorr = acovf(np.sin(traj[:,i]), demean=False, adjusted=True, nlag=1 if args.ito else 1000) + acovf(np.cos(traj[:,i]), demean=False, adjusted=True, nlag=1 if args.ito else 1000)
+            baseline = np.sin(traj[:,i]).mean()**2 + np.cos(traj[:,i]).mean()**2
+            # E[(X(t) - E[X(t)]) * (X(t+dt) - E[X(t+dt)])] = E[X(t)X(t+dt) - E[X(t)]X(t+dt) - X(t)E[X(t+dt)] + E[X(t)]E[X(t+dt)]] = E[X(t)X(t+dt)] - E[X]**2
+            lags = 1 + np.arange(len(autocorr))
+            if 'PHI' in feat or 'PSI' in feat:
+                axs[1,1].plot(lags, (autocorr - baseline) / (1-baseline), color=colors[i%len(colors)])
+            else:
+                axs[1,2].plot(lags, (autocorr - baseline) / (1-baseline), color=colors[i%len(colors)])
+    
+            out['our_decorrelation'][feat] = (autocorr.astype(np.float16) - baseline) / (1-baseline)
+    
+        axs[1,1].set_title('Backbone decorrelation')
+        axs[1,2].set_title('Sidechain decorrelation')
+        axs[1,1].set_xscale('log')
+        axs[1,2].set_xscale('log')
+
+    ####### TICA #############
+    feats, traj = mdgen.analysis.get_featurized_traj(f'{args.pdbdir}/{name}', sidechains=True, cossin=True)
+    if args.truncate: traj = traj[:args.truncate]
+    feats, ref = mdgen.analysis.get_featurized_traj(f'{args.mddir}/{name}/{name}', sidechains=True, cossin=True)
+
+    tica, _ = mdgen.analysis.get_tica(ref)
+    ref_tica = tica.transform(ref)
+    traj_tica = tica.transform(traj)
+    
+    tica_0_min = min(ref_tica[:,0].min(), traj_tica[:,0].min())
+    tica_0_max = max(ref_tica[:,0].max(), traj_tica[:,0].max())
+
+    tica_1_min = min(ref_tica[:,1].min(), traj_tica[:,1].min())
+    tica_1_max = max(ref_tica[:,1].max(), traj_tica[:,1].max())
+    
+    ref_p = np.histogram(ref_tica[:,0], range=(tica_0_min, tica_0_max), bins=100)[0]
+    traj_p = np.histogram(traj_tica[:,0], range=(tica_0_min, tica_0_max), bins=100)[0]
+    out['JSD']['TICA-0'] = jensenshannon(ref_p, traj_p)
+
+    ref_p = np.histogram2d(*ref_tica[:,:2].T, range=((tica_0_min, tica_0_max),(tica_1_min, tica_1_max)), bins=50)[0]
+    traj_p = np.histogram2d(*traj_tica[:,:2].T, range=((tica_0_min, tica_0_max),(tica_1_min, tica_1_max)), bins=50)[0]
+    out['JSD']['TICA-0,1'] = jensenshannon(ref_p.flatten(), traj_p.flatten())
+    
+    #### 1,0, 1,1 TICA FES
+    if args.plot:
+        pyemma.plots.plot_free_energy(*ref_tica[::100, :2].T, ax=axs[2,0], cbar=False)
+        pyemma.plots.plot_free_energy(*traj_tica[:, :2].T, ax=axs[2,1], cbar=False)
+        axs[2,0].set_title('TICA FES (MD)')
+        axs[2,1].set_title('TICA FES (ours)')
+
+
+    ####### TICA decorrelation ########
+    if args.no_decorr:
+        pass
+    else:
+        # x, adjusted=False, demean=True, fft=True, missing='none', nlag=None
+        autocorr = acovf(ref_tica[:,0], nlag=100000, adjusted=True, demean=False)
+        out['md_decorrelation']['tica'] = autocorr.astype(np.float16)
+        if args.plot:
+            axs[0,3].plot(autocorr)
+            axs[0,3].set_title('MD TICA')
+        
+    
+        autocorr = acovf(traj_tica[:,0], nlag=1 if args.ito else 1000, adjusted=True, demean=False)
+        out['our_decorrelation']['tica'] = autocorr.astype(np.float16)
+        if args.plot:
+            axs[1,3].plot(autocorr)
+            axs[1,3].set_title('Traj TICA')
+
+    ###### Markov state model stuff #################
+    if not args.no_msm:
+        kmeans, ref_kmeans = mdgen.analysis.get_kmeans(tica.transform(ref))
+        try:
+            msm, pcca, cmsm = mdgen.analysis.get_msm(ref_kmeans, nstates=10)
+    
+            out['kmeans'] = kmeans
+            out['msm'] = msm
+            out['pcca'] = pcca
+            out['cmsm'] = cmsm
+        
+            traj_discrete = mdgen.analysis.discretize(tica.transform(traj), kmeans, msm)
+            ref_discrete = mdgen.analysis.discretize(tica.transform(ref), kmeans, msm)
+            out['traj_metastable_probs'] = (traj_discrete == np.arange(10)[:,None]).mean(1)
+            out['ref_metastable_probs'] = (ref_discrete == np.arange(10)[:,None]).mean(1)
+            ######### 
+        
+            msm_transition_matrix = np.eye(10)
+            for a, i in enumerate(cmsm.active_set):
+                for b, j in enumerate(cmsm.active_set):
+                    msm_transition_matrix[i,j] = cmsm.transition_matrix[a,b]
+    
+            out['msm_transition_matrix'] = msm_transition_matrix
+            out['pcca_pi'] = pcca._pi_coarse
+        
+            msm_pi = np.zeros(10)
+            msm_pi[cmsm.active_set] = cmsm.pi
+            out['msm_pi'] = msm_pi
+            
+            if args.no_traj_msm:
+                pass
+            else:
+                
+                traj_msm = pyemma.msm.estimate_markov_model(traj_discrete, lag=args.msm_lag)
+                out['traj_msm'] = traj_msm
+        
+                traj_transition_matrix = np.eye(10)
+                for a, i in enumerate(traj_msm.active_set):
+                    for b, j in enumerate(traj_msm.active_set):
+                        traj_transition_matrix[i,j] = traj_msm.transition_matrix[a,b]
+                out['traj_transition_matrix'] = traj_transition_matrix
+                
+            
+                traj_pi = np.zeros(10)
+                traj_pi[traj_msm.active_set] = traj_msm.pi
+                out['traj_pi'] = traj_pi
+                
+        except Exception as e:
+            print('ERROR', e, name, flush=True)
+    
+    if args.plot:
+        fig.savefig(f'{args.pdbdir}/{name}.pdf')
+    
+    return name, out
+
+if args.pdb_id:
+    pdb_id = args.pdb_id
+else:
+    pdb_id = [nam.split('.')[0] for nam in os.listdir(args.pdbdir) if '.pdb' in nam and not '_traj' in nam]
+pdb_id = [nam for nam in pdb_id if os.path.exists(f'{args.pdbdir}/{nam}.xtc')]
+print('number of trajectories', len(pdb_id))
+
+    
+if args.num_workers > 1:
+    p = Pool(args.num_workers)
+    p.__enter__()
+    __map__ = p.imap
+else:
+    __map__ = map
+out = dict(tqdm.tqdm(__map__(main, pdb_id), total=len(pdb_id)))
+if args.num_workers > 1:
+    p.__exit__(None, None, None)
+
+if args.save:
+    with open(f"{args.pdbdir}/{args.save_name}", 'wb') as f:
+        f.write(pickle.dumps(out))
+
+

data/scripts/analyze_peptide_tps.py

@@ -0,0 +1,192 @@
+import argparse
+import json
+import pickle
+from multiprocessing import Pool
+
+from scipy.spatial.distance import jensenshannon
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--mddir', type=str, default='share/4AA_sims')
+parser.add_argument('--repdir', type=str, default='share/4AA_sims_replica')
+parser.add_argument('--pdbdir', type=str, required=True)
+parser.add_argument('--outdir', type=str, required=True)
+parser.add_argument('--save', action='store_true')
+parser.add_argument('--plot', action='store_true')
+parser.add_argument('--save_name', type=str, default='out.pkl')
+parser.add_argument('--pdb_id', nargs='*', default=[])
+parser.add_argument('--no_overwrite', nargs='*', default=[])
+parser.add_argument('--num_workers', type=int, default=1)
+args = parser.parse_args()
+
+import mdgen.analysis
+import pyemma, tqdm, os
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def main(name):
+    print(f'processing {name}')
+    np.random.seed(137)
+    name = name.split('_')[0]
+
+    feats, ref = mdgen.analysis.get_featurized_traj(f'{args.mddir}/{name}/{name}', sidechains=True)
+
+    tica, _ = mdgen.analysis.get_tica(ref)
+    out = pickle.load(open(os.path.join(args.pdbdir, f'{name}_metadata.pkl'), 'rb'))
+    msm = out['msm']
+    cmsm = out['cmsm']
+    kmeans = out['kmeans']
+    metadata = json.load(open(os.path.join(args.pdbdir, f'{name}_metadata.json'), 'rb'))
+    start_idx = metadata[0]['start_idx']
+    end_idx = metadata[0]['end_idx']
+    start_state = metadata[0]['start_state']
+    end_state = metadata[0]['end_state']
+
+    print("Reference Analysis")
+    gen_feats_list, gen_traj_list = mdgen.analysis.load_tps_ensemble(name, args.pdbdir)
+    gen_traj_cat = np.concatenate(gen_traj_list, axis=0)
+
+    fig, axs = plt.subplots(6, 4, figsize=(20, 20))
+
+    pyemma.plots.plot_free_energy(*tica.transform(gen_traj_cat)[:, :2].T, ax=axs[0, 1], cbar=False)
+    axs[0, 1].scatter(tica.transform(ref)[start_idx, 0], tica.transform(ref)[start_idx, 1], s=200, c='black')
+    axs[0, 1].scatter(tica.transform(ref)[end_idx, 0], tica.transform(ref)[end_idx, 1], s=200, c='black')
+    axs[0, 1].set_title('Transition Path Ensemble')
+
+    pyemma.plots.plot_free_energy(*tica.transform(ref)[::100, :2].T, ax=axs[0, 0], cbar=False)
+    axs[0, 0].scatter(tica.transform(ref)[start_idx, 0], tica.transform(ref)[start_idx, 1], s=200, c='black')
+    axs[0, 0].scatter(tica.transform(ref)[end_idx, 0], tica.transform(ref)[end_idx, 1], s=200, c='black')
+    axs[0, 0].set_title('Reference MD in TICA space with start and end state')
+    pyemma.plots.plot_markov_model(cmsm, minflux=4e-4, arrow_label_format='%.3f', ax=axs[1, 0])
+    axs[1, 0].set_title(f'Reference MD MSM. Start {start_state}. End {end_state}.')
+
+    ref_tp = mdgen.analysis.sample_tp(trans=cmsm.transition_matrix, start_state=start_state, end_state=end_state,
+                                      traj_len=11,
+                                      n_samples=1000)
+    ref_stateprobs = mdgen.analysis.get_state_probs(ref_tp)
+
+    print("generated Analysis")
+    highest_prob_state = cmsm.active_set[np.argmax(cmsm.pi)]
+    allidx_to_activeidx = {value: idx for idx, value in enumerate(cmsm.active_set)}
+    ### Generated analysis
+    gen_discrete = mdgen.analysis.discretize(tica.transform(np.concatenate(gen_traj_list)), kmeans, msm)
+    gen_tp_all = gen_discrete.reshape((len(gen_traj_list), - 1))
+    gen_tp = gen_tp_all[:, ::10]
+    gen_tp = np.concatenate([gen_tp, gen_tp_all[:, -1:]], axis=1)
+    gen_stateprobs = mdgen.analysis.get_state_probs(gen_tp)
+    gen_probs = mdgen.analysis.get_tp_likelihood(np.vectorize(allidx_to_activeidx.get)(gen_tp, highest_prob_state),
+                                                 cmsm.transition_matrix)
+    gen_prob = gen_probs.prod(-1)
+    out[f'gen_prob'] = gen_prob.mean()
+    out[f'gen_valid_prob'] = gen_prob[gen_prob > 0].mean()
+    out[f'gen_valid_rate'] = (gen_prob > 0).mean()
+    out[f'gen_JSD'] = jensenshannon(ref_stateprobs, gen_stateprobs)
+
+    ### Replica analysis
+    rep_feats, rep = mdgen.analysis.get_featurized_traj(f'{args.repdir}/{name}', sidechains=True)
+    rep_lens = [999999, 500000, 300000, 200000, 100000, 50000, 20000]
+    rep_names = ['100ns', '50ns', '30ns', '20ns', '10ns', '5ns', '2ns']
+    rep_stateprobs_list = []
+    print('Replica analysis')
+    for i in range(len(rep_lens)):
+        rep_small = rep[:rep_lens[i]]
+        rep_discrete = mdgen.analysis.discretize(tica.transform(rep_small), kmeans, msm)
+        rep_msm = pyemma.msm.estimate_markov_model(rep_discrete, lag=1000)  # 100ps time lag for the msm
+
+        idx_to_repidx = {value: idx for idx, value in enumerate(rep_msm.active_set)}
+        repidx_to_idx = {idx: value for idx, value in enumerate(rep_msm.active_set)}
+        if (start_state not in idx_to_repidx.keys()) or (end_state not in idx_to_repidx.keys()):
+            out[f'{rep_names[i]}_rep_prob'] = 0
+            out[f'{rep_names[i]}_rep_valid_prob'] = 0
+            out[f'{rep_names[i]}_rep_valid_rate'] = 0
+            out[f'{rep_names[i]}_rep_JSD'] = 1
+            out[f'{rep_names[i]}_repcheat_prob'] = np.nan
+            out[f'{rep_names[i]}_repcheat_valid_prob'] = np.nan
+            out[f'{rep_names[i]}_repcheat_valid_rate'] = np.nan
+            out[f'{rep_names[i]}_repcheat_JSD'] = np.nan
+            rep_stateprobs_list.append(np.zeros(10))
+            continue
+
+
+        repidx_start_state = idx_to_repidx[start_state]
+        repidx_end_state = idx_to_repidx[end_state]
+
+        repidx_tp = mdgen.analysis.sample_tp(trans=rep_msm.transition_matrix, start_state=repidx_start_state,
+                                             end_state=repidx_end_state, traj_len=11, n_samples=1000)
+        rep_tp = np.vectorize(repidx_to_idx.get)(repidx_tp)
+        assert rep_tp[0, 0] == start_state
+        assert rep_tp[0, -1] == end_state
+        rep_probs = mdgen.analysis.get_tp_likelihood(np.vectorize(allidx_to_activeidx.get)(rep_tp, highest_prob_state),
+                                                     cmsm.transition_matrix)
+        rep_prob = rep_probs.prod(-1)
+        rep_stateprobs = mdgen.analysis.get_state_probs(rep_tp)
+        rep_stateprobs_list.append(rep_stateprobs)
+        out[f'{rep_names[i]}_rep_prob'] = rep_prob.mean()
+        out[f'{rep_names[i]}_rep_valid_prob'] = rep_prob[rep_prob > 0].mean()
+        out[f'{rep_names[i]}_rep_valid_rate'] = (rep_prob > 0).mean()
+        out[f'{rep_names[i]}_rep_JSD'] = jensenshannon(ref_stateprobs, rep_stateprobs)
+        out[f'{rep_names[i]}_repcheat_prob'] = rep_prob.mean()
+        out[f'{rep_names[i]}_repcheat_valid_prob'] = rep_prob[rep_prob > 0].mean()
+        out[f'{rep_names[i]}_repcheat_valid_rate'] = (rep_prob > 0).mean()
+        out[f'{rep_names[i]}_repcheat_JSD'] = jensenshannon(ref_stateprobs, rep_stateprobs)
+
+    full_rep_discrete = mdgen.analysis.discretize(tica.transform(rep), kmeans, msm)
+    full_rep_msm = pyemma.msm.estimate_markov_model(full_rep_discrete, lag=1000)  # 100ps time lag for the msm
+
+    axs[0, 2].imshow(cmsm.transition_matrix == 0)
+    axs[0, 2].set_title('Reference 100ns MD transition matrix zeros')
+    axs[1, 2].imshow(full_rep_msm.transition_matrix == 0)
+    axs[1, 2].set_title('Replica 100ns MD transition matrix zeros')
+
+    data = np.stack([ref_stateprobs, gen_stateprobs, *rep_stateprobs_list])
+    row_names = ['Reference', 'Genereated', *[f'Replica {name}' for name in rep_names]]
+    axs[1, 1].imshow(data, cmap='viridis')
+    axs[1, 1].set_yticks(range(len(row_names)))
+    axs[1, 1].set_yticklabels(row_names)
+
+    gen_stack_all = np.stack(gen_traj_list, axis = 0)
+
+    for i in range(4):
+        for j in range(4):
+            idx = i * 4 + j
+            pyemma.plots.plot_free_energy(*tica.transform(ref)[::100, :2].T, ax=axs[2+i, j], cbar=False)
+            plot_traj = tica.transform(gen_stack_all[idx])[:,:2]
+            axs[2+i, j].plot(plot_traj[:,0],plot_traj[:,1], c='black', marker='o')
+            axs[2+i, j].set_title(f'Trajectory {idx}')
+
+    mapping = {value: idx for idx, value in enumerate(cmsm.active_set)}
+    ref_tpt = pyemma.msm.tpt(cmsm, [mapping[start_state]], [mapping[end_state]])
+    pyemma.plots.plot_flux(ref_tpt, minflux=4e-8, arrow_label_format='%.3f', state_labels=None, show_committor=True, ax=axs[0,3])
+    gen_tps_msm = pyemma.msm.estimate_markov_model(list(gen_tp), lag=1)
+    mapping = {value: idx for idx, value in enumerate(gen_tps_msm.active_set)}
+    gen_tpt = pyemma.msm.tpt(gen_tps_msm, [mapping[start_state]], [mapping[end_state]])
+    pyemma.plots.plot_flux(gen_tpt, minflux=4e-8, arrow_label_format='%.3f', state_labels=None, show_committor=True, ax=axs[1,3])
+
+    if args.plot:
+        os.makedirs(args.outdir, exist_ok=True)
+        fig.savefig(f'{args.outdir}/{name}.pdf')
+
+    with open(f"{args.outdir}/{name}.pkl", 'wb') as f:
+        f.write(pickle.dumps(out))
+
+    return name, out
+
+
+if args.pdb_id:
+    pdb_id = args.pdb_id
+else:
+    pdb_id = list(set([nam.split('_')[0] for nam in os.listdir(args.pdbdir) if '.pdb' in nam]))
+
+if args.num_workers > 1:
+    p = Pool(args.num_workers)
+    p.__enter__()
+    __map__ = p.imap
+else:
+    __map__ = map
+out = dict(tqdm.tqdm(__map__(main, pdb_id), total=len(pdb_id)))
+if args.num_workers > 1:
+    p.__exit__(None, None, None)
+
+if args.save:
+    with open(f"{args.outdir}/{args.save_name}", 'wb') as f:
+        f.write(pickle.dumps(out))

data/scripts/analyze_upsampling.py

@@ -0,0 +1,79 @@
+import argparse
+parser = argparse.ArgumentParser()
+parser.add_argument("--pdbdir", required=True)
+parser.add_argument("--mddir", default='share/4AA_sims_implicit')
+parser.add_argument('--pdb_id', nargs='*', default=[])
+args = parser.parse_args()
+
+import mdgen.analysis
+import tqdm, os
+import matplotlib.pyplot as plt
+from statsmodels.tsa.stattools import acovf
+import numpy as np
+colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
+
+def do(name):
+    feats, ref = mdgen.analysis.get_featurized_traj(f'{args.mddir}/{name}/{name}', sidechains=True, cossin=False)
+    feats, traj = mdgen.analysis.get_featurized_traj(f'{args.pdbdir}/{name}', sidechains=True, cossin=False)
+
+
+    md_autocorr = {}
+    our_autocorr = {}
+    subsample_autocorr = {}
+    for i, feat in enumerate(feats.describe()):
+        md_autocorr[feat] = acovf(np.sin(ref[:,i]), demean=False, adjusted=True) + acovf(np.cos(ref[:,i]), demean=False, adjusted=True)
+        our_autocorr[feat] = acovf(np.sin(traj[:,i]), demean=False, adjusted=True) + acovf(np.cos(traj[:,i]), demean=False, adjusted=True)
+        subsample_autocorr[feat] = acovf(np.sin(ref[::100,i]), demean=False, adjusted=True) + acovf(np.cos(ref[::100,i]), demean=False, adjusted=True)
+        
+    lags = 0.1 * (1 + np.arange(1000000))
+    subsample_lags = 10 * (1 + np.arange(1000000))
+
+    fig, axs = plt.subplots(1, 2, figsize=(10, 5))
+    
+    for i, key in enumerate([key for key in md_autocorr if 'CHI' in key]):
+        toplot = md_autocorr[key][1:]
+        axs[0].plot(lags[:len(toplot)], toplot, color=colors[i%len(colors)])
+    
+        toplot = subsample_autocorr[key][1:]
+        axs[0].scatter(subsample_lags[:len(toplot)], toplot, color=colors[i%len(colors)], label=key)
+    
+        toplot = our_autocorr[key][1:]
+        axs[0].plot(lags[:len(toplot)], toplot, color=colors[i%len(colors)], linestyle='--')
+    axs[0].set_title(f"{name} sidechains")
+    axs[0].set_xscale('log')
+    axs[0].set_xlim(0.1, 100)
+    axs[0].set_ylim(0.5, 1)
+    axs[0].set_xlabel('ps')
+    axs[0].legend(loc='upper center', bbox_to_anchor=(0.5, -0.05), ncol=3, fontsize=6)
+
+    for i, key in enumerate([key for key in md_autocorr if 'CHI' not in key]):
+        toplot = md_autocorr[key][1:]
+        axs[1].plot(lags[:len(toplot)], toplot, color=colors[i%len(colors)])
+    
+        toplot = subsample_autocorr[key][1:]
+        axs[1].scatter(subsample_lags[:len(toplot)], toplot, color=colors[i%len(colors)], label=key)
+    
+        toplot = our_autocorr[key][1:]
+        axs[1].plot(lags[:len(toplot)], toplot, color=colors[i%len(colors)], linestyle='--')
+    axs[1].set_title(f"{name} backbones")
+
+    axs[1].set_xscale('log')
+    axs[1].set_xlim(0.1, 100)
+    axs[1].set_ylim(0.5, 1)
+    axs[1].set_xlabel('ps')
+    axs[1].legend(loc='upper center', bbox_to_anchor=(0.5, -0.05), ncol=3, fontsize=6)
+
+    fig.savefig(f"{args.pdbdir}/{name}.pdf", bbox_inches='tight', pad_inches=0)
+    
+if args.pdb_id:
+    pdb_id = args.pdb_id
+else:
+    pdb_id = [nam.split('.')[0] for nam in os.listdir(args.pdbdir) if '.pdb' in nam]
+
+
+for name in tqdm.tqdm(pdb_id): 
+    if os.path.exists(f"{args.pdbdir}/{name}.pdf"): continue
+    try:
+        do(name)
+    except Exception as e:
+        print(name, e)

data/scripts/prep_sims.py

@@ -0,0 +1,80 @@
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--split', type=str, default='splits/atlas.csv')
+parser.add_argument('--sim_dir', type=str, default='/data/cb/scratch/datasets/atlas')
+parser.add_argument('--outdir', type=str, default='./data_atlas')
+parser.add_argument('--num_workers', type=int, default=1)
+parser.add_argument('--suffix', type=str, default='')
+parser.add_argument('--atlas', action='store_true')
+parser.add_argument('--stride', type=int, default=1)
+args = parser.parse_args()
+
+import mdtraj, os, tqdm
+import pandas as pd 
+from multiprocessing import Pool
+import numpy as np
+from mdgen import residue_constants as rc
+
+os.makedirs(args.outdir, exist_ok=True)
+
+df = pd.read_csv(args.split, index_col='name')
+names = df.index
+
+def main():
+    jobs = []
+    for name in names:
+        if os.path.exists(f'{args.outdir}/{name}{args.suffix}.npy'): continue
+        jobs.append(name)
+
+    if args.num_workers > 1:
+        p = Pool(args.num_workers)
+        p.__enter__()
+        __map__ = p.imap
+    else:
+        __map__ = map
+    for _ in tqdm.tqdm(__map__(do_job, jobs), total=len(jobs)):
+        pass
+    if args.num_workers > 1:
+        p.__exit__(None, None, None)
+
+# def prot_to_frames(ca_coords, c_coords, n_coords):
+#     prot_frames = Rigid.from_3_points(
+#         torch.from_numpy(c_coords),
+#         torch.from_numpy(ca_coords),
+#         torch.from_numpy(n_coords),
+#     )
+#     rots = torch.eye(3)
+#     rots[0, 0] = -1
+#     rots[2, 2] = -1
+#     rots = Rotation(rot_mats=rots)
+#     return prot_frames.compose(Rigid(rots, None))
+
+
+def traj_to_atom14(traj):
+    arr = np.zeros((traj.n_frames, traj.n_residues, 14, 3), dtype=np.float16)
+    for i, resi in enumerate(traj.top.residues):
+        for at in resi.atoms:
+            if at.name not in rc.restype_name_to_atom14_names[resi.name]:
+                print(resi.name, at.name, 'not found'); continue
+            j = rc.restype_name_to_atom14_names[resi.name].index(at.name)
+            arr[:,i,j] = traj.xyz[:,at.index] * 10.0
+    return arr
+
+if args.atlas:
+    def do_job(name):
+        for i in [1,2,3]:
+            traj = mdtraj.load(f'{args.atlas_dir}/{name}/{name}_prod_R{i}_fit.xtc', top=f'{args.atlas_dir}/{name}/{name}.pdb') 
+            traj.atom_slice([a.index for a in traj.top.atoms if a.element.symbol != 'H'], True)
+            traj.superpose(traj)
+            arr = traj_to_atom14(traj)
+            np.save(f'{args.outdir}/{name}_R{i}{args.suffix}.npy', arr[::args.stride])
+else:
+    def do_job(name):
+        traj = mdtraj.load(f'{args.atlas_dir}/{name}/{name}.xtc', top=f'{args.atlas_dir}/{name}/{name}.pdb')
+        traj.superpose(traj)
+        arr = traj_to_atom14(traj)
+        np.save(f'{args.outdir}/{name}{args.suffix}.npy', arr[::args.stride])
+
+if __name__ == "__main__":
+    main()

data/scripts/run_peptide_sim.py

@@ -0,0 +1,142 @@
+import argparse
+parser = argparse.ArgumentParser()
+parser.add_argument('--indir', type=str, default='4AA')
+parser.add_argument('--outdir', type=str, default='/data/cb/scratch/share/mdgen/4AA_sims')
+parser.add_argument('--worker_id', type=int, default=0)
+parser.add_argument('--num_workers', type=int, default=1)
+parser.add_argument('--pdb_id', nargs='*', default=[])
+parser.add_argument('--joblist', type=str, default='splits/1k_4AA.csv')
+parser.add_argument('--implicit', action='store_true')
+parser.add_argument('--job_id', nargs='*', default=[])
+parser.add_argument('--sim_ns', type=float, default=100)
+parser.add_argument('--print_freq', type=int, default=1000)
+parser.add_argument('--save_ps', type=float, default=0.1)
+parser.add_argument('--friction_coeff', type=float, default=0.3)
+parser.add_argument('--md_device', type=str, default="CUDA")
+args = parser.parse_args()
+
+import openmm, mdtraj, sys, os
+from openmm.app import PDBFile, ForceField, Modeller, PME, HBonds, Simulation, StateDataReporter
+from openmm import unit, LangevinMiddleIntegrator, Platform, MonteCarloBarostat
+import numpy as np
+import pandas as pd
+
+
+dt = 2 * unit.femtosecond
+total_steps = int((args.sim_ns * unit.nanosecond) / dt)
+save_interval = int((args.save_ps * unit.picosecond) / dt)
+print(f"Running for {total_steps} steps")
+print(f"Saving every {save_interval} steps")
+print(f"Will save {int(total_steps / save_interval)} frames")
+
+
+def make(aa):
+    if '_' in aa:
+        aa = aa.split('_')[0]
+    print(f'Making {aa}')
+    from pymol import cmd
+    cmd.reinitialize()
+    cmd.fab(aa, hydro=0)
+    cmd.save(f'{args.indir}/{aa}.pdb')
+    print(f'Fixing {aa}')
+    from pdbfixer import PDBFixer
+    fixer = PDBFixer(filename=f'{args.indir}/{aa}.pdb')
+    fixer.missingResidues = {}
+    fixer.findMissingAtoms()
+    fixer.addMissingAtoms()
+    with open(f'{args.indir}/{aa}.pdb', 'w') as f:
+        PDBFile.writeFile(fixer.topology, fixer.positions, f, True)
+
+    # subprocess.run(['pdbfixer', f'{args.indir}/{aa}.pdb', '--add-atoms=heavy'])
+    # subprocess.run(['mv', 'output.pdb', f'{args.indir}/{aa}.pdb'])
+
+def do(name):
+    os.makedirs(f"{args.outdir}/{name}", exist_ok=True)
+
+    aa = name.split('_')[0]
+    if not os.path.exists(f"{args.indir}/{aa}.pdb"):
+        make(aa)
+    pdb = PDBFile(f"{args.indir}/{aa}.pdb")
+    if args.implicit:
+        forcefield = ForceField('amber14-all.xml', 'implicit/gbn2.xml')
+    else:
+        forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')
+    modeller = Modeller(pdb.topology, pdb.positions)
+    modeller.addHydrogens(forcefield, pH=7)
+
+    if args.implicit:
+        system = forcefield.createSystem(modeller.topology, constraints=HBonds)
+    else:
+        modeller.addSolvent(forcefield, padding=1.0 * unit.nanometer)
+        system = forcefield.createSystem(modeller.topology, nonbondedMethod=PME,
+                                     nonbondedCutoff=1.0 * unit.nanometer,
+                                     constraints=HBonds)
+        
+    integrator = LangevinMiddleIntegrator(350 * unit.kelvin, args.friction_coeff / unit.picosecond, dt)
+    simulation = Simulation(modeller.topology, system, integrator,
+                            platform=Platform.getPlatformByName(args.md_device))
+    simulation.context.setPositions(modeller.positions)
+
+    top = mdtraj.Topology.from_openmm(modeller.topology)
+    print(f'System with {top.n_atoms} atoms')
+    mask = top.select("protein and not type H")
+    print(f'Reporting {len(mask)} atoms')
+    reporter = mdtraj.reporters.HDF5Reporter(f'{args.outdir}/{name}/{name}.h5', reportInterval=save_interval,
+                                             atomSubset=mask)
+
+    print('Minimizing energy')
+    simulation.minimizeEnergy()
+
+    print("Running NVT")
+    simulation.reporters.append(StateDataReporter(
+        sys.stdout,
+        reportInterval=args.print_freq,
+        step=True,
+        potentialEnergy=True,
+        temperature=True,
+        volume=True,
+        speed=True,
+        remainingTime=True,
+        totalSteps=total_steps + 10000
+    ))
+    simulation.reporters.append(StateDataReporter(
+        open(f'{args.outdir}/{name}/{name}.out', 'w'),
+        reportInterval=1000,
+        step=True,
+        potentialEnergy=True,
+        temperature=True,
+        volume=True,
+        speed=True,
+        remainingTime=True,
+        totalSteps=total_steps + 10000
+    ))
+    simulation.step(10000)
+
+    if not args.implicit:
+        print("Running NPT")
+        system.addForce(MonteCarloBarostat(1 * unit.bar, 350 * unit.kelvin))
+        simulation.context.reinitialize(preserveState=True)
+        
+    simulation.reporters.append(reporter)
+    simulation.step(total_steps)
+    reporter.close()
+
+    print("Converting to XTC")
+    traj = mdtraj.load(f'{args.outdir}/{name}/{name}.h5')
+    traj.superpose(traj)
+    traj.save(f'{args.outdir}/{name}/{name}.xtc')
+    traj[0].save(f'{args.outdir}/{name}/{name}.pdb')
+
+if args.pdb_id:
+    jobs = args.pdb_id
+else:
+    jobs = np.array(pd.read_csv(args.joblist, index_col='name').index)
+    if args.job_id:
+        jobs = jobs.index[list(map(int, args.job_id))]
+    else:
+        jobs = jobs[args.worker_id::args.num_workers]
+        
+for name in jobs:
+    do(name)
+
+

data/sim_inference.py

@@ -0,0 +1,140 @@
+import argparse
+parser = argparse.ArgumentParser()
+parser.add_argument('--sim_ckpt', type=str, default=None, required=True)
+parser.add_argument('--data_dir', type=str, default=None, required=True)
+parser.add_argument('--suffix', type=str, default='')
+parser.add_argument('--pdb_id', nargs='*', default=[])
+parser.add_argument('--num_frames', type=int, default=1000)
+parser.add_argument('--num_rollouts', type=int, default=100)
+parser.add_argument('--no_frames', action='store_true')
+parser.add_argument('--tps', action='store_true')
+parser.add_argument('--xtc', action='store_true')
+parser.add_argument('--out_dir', type=str, default=".")
+parser.add_argument('--split', type=str, default='splits/4AA_test.csv')
+args = parser.parse_args()
+
+import os, torch, mdtraj, tqdm, time
+import numpy as np
+from mdgen.geometry import atom14_to_frames, atom14_to_atom37, atom37_to_torsions
+from mdgen.residue_constants import restype_order, restype_atom37_mask
+from mdgen.tensor_utils import tensor_tree_map
+from mdgen.wrapper import NewMDGenWrapper
+from mdgen.utils import atom14_to_pdb
+import pandas as pd
+
+
+
+
+os.makedirs(args.out_dir, exist_ok=True)
+
+
+
+def get_batch(name, seqres, num_frames):
+    arr = np.lib.format.open_memmap(f'{args.data_dir}/{name}{args.suffix}.npy', 'r')
+
+    if not args.tps: # else keep all frames
+        arr = np.copy(arr[0:1]).astype(np.float32)
+
+    frames = atom14_to_frames(torch.from_numpy(arr))
+    seqres = torch.tensor([restype_order[c] for c in seqres])
+    atom37 = torch.from_numpy(atom14_to_atom37(arr, seqres[None])).float()
+    L = len(seqres)
+    mask = torch.ones(L)
+    
+    if args.no_frames:
+        return {
+            'atom37': atom37,
+            'seqres': seqres,
+            'mask': restype_atom37_mask[seqres],
+        }
+        
+    torsions, torsion_mask = atom37_to_torsions(atom37, seqres[None])
+    return {
+        'torsions': torsions,
+        'torsion_mask': torsion_mask[0],
+        'trans': frames._trans,
+        'rots': frames._rots._rot_mats,
+        'seqres': seqres,
+        'mask': mask, # (L,)
+    }
+
+def rollout(model, batch):
+
+    #print('Start sim', batch['trans'][0,0,0])
+    if args.no_frames:
+        
+        expanded_batch = {
+            'atom37': batch['atom37'].expand(-1, args.num_frames, -1, -1, -1),
+            'seqres': batch['seqres'],
+            'mask': batch['mask'],
+        }
+    else:    
+        expanded_batch = {
+            'torsions': batch['torsions'].expand(-1, args.num_frames, -1, -1, -1),
+            'torsion_mask': batch['torsion_mask'],
+            'trans': batch['trans'].expand(-1, args.num_frames, -1, -1),
+            'rots': batch['rots'].expand(-1, args.num_frames, -1, -1, -1),
+            'seqres': batch['seqres'],
+            'mask': batch['mask'],
+        }
+    atom14, _ = model.inference(expanded_batch)
+    new_batch = {**batch}
+
+    if args.no_frames:
+        new_batch['atom37'] = torch.from_numpy(
+            atom14_to_atom37(atom14[:,-1].cpu(), batch['seqres'][0].cpu())
+        ).cuda()[:,None].float()
+        
+        
+        
+    else:
+        frames = atom14_to_frames(atom14[:,-1])
+        new_batch['trans'] = frames._trans[None]
+        new_batch['rots'] = frames._rots._rot_mats[None]
+        atom37 = atom14_to_atom37(atom14[0,-1].cpu(), batch['seqres'][0].cpu())
+        torsions, _ = atom37_to_torsions(atom37, batch['seqres'][0].cpu())
+        new_batch['torsions'] = torsions[None, None].cuda()
+
+    return atom14, new_batch
+    
+    
+def do(model, name, seqres):
+
+    item = get_batch(name, seqres, num_frames = model.args.num_frames)
+    batch = next(iter(torch.utils.data.DataLoader([item])))
+
+    batch = tensor_tree_map(lambda x: x.cuda(), batch)  
+    
+    all_atom14 = []
+    start = time.time()
+    for _ in tqdm.trange(args.num_rollouts):
+        atom14, batch = rollout(model, batch)
+        # print(atom14[0,0,0,1], atom14[0,-1,0,1])
+        all_atom14.append(atom14)
+
+    print(time.time() - start)
+    all_atom14 = torch.cat(all_atom14, 1)
+    
+    path = os.path.join(args.out_dir, f'{name}.pdb')
+    atom14_to_pdb(all_atom14[0].cpu().numpy(), batch['seqres'][0].cpu().numpy(), path)
+
+    if args.xtc:
+        traj = mdtraj.load(path)
+        traj.superpose(traj)
+        traj.save(os.path.join(args.out_dir, f'{name}.xtc'))
+        traj[0].save(os.path.join(args.out_dir, f'{name}.pdb'))
+
+@torch.no_grad()
+def main():
+    model = NewMDGenWrapper.load_from_checkpoint(args.sim_ckpt)
+    model.eval().to('cuda')
+    
+    
+    df = pd.read_csv(args.split, index_col='name')
+    for name in df.index:
+        if args.pdb_id and name not in args.pdb_id:
+            continue
+        do(model, name, df.seqres[name])
+        
+
+main()

data/splits/4AA.csv

@@ -0,0 +1,3310 @@
+name,seqres
+EHFR,EHFR
+IMCP,IMCP
+YVTL,YVTL
+GQGV,GQGV
+PCFK,PCFK
+VVIV,VVIV
+QYTC,QYTC
+WGDY,WGDY
+CWLF,CWLF
+QHIN,QHIN
+ASKI,ASKI
+KITV,KITV
+SLYW,SLYW
+REVV,REVV
+NYLE,NYLE
+QGRE,QGRE
+AEHY,AEHY
+SRPT,SRPT
+NGDS,NGDS
+ATVV,ATVV
+DKFA,DKFA
+MSTP,MSTP
+VNWW,VNWW
+LDNH,LDNH
+CHSI,CHSI
+YFCS,YFCS
+WLSC,WLSC
+YYTK,YYTK
+GPNT,GPNT
+LTQE,LTQE
+VMHV,VMHV
+GTLM,GTLM
+QRRW,QRRW
+EGDW,EGDW
+IFRG,IFRG
+LRYM,LRYM
+ITGR,ITGR
+PTNI,PTNI
+KQSH,KQSH
+WTWS,WTWS
+CASF,CASF
+VKFG,VKFG
+GQYP,GQYP
+CMYH,CMYH
+VFGD,VFGD
+KWIC,KWIC
+PQHG,PQHG
+FLIS,FLIS
+QEGR,QEGR
+WQTE,WQTE
+MHTN,MHTN
+ISML,ISML
+HRCS,HRCS
+EQVR,EQVR
+NNKC,NNKC
+MVQY,MVQY
+FART,FART
+ENKE,ENKE
+TIDH,TIDH
+RDTI,RDTI
+KAPF,KAPF
+ICLP,ICLP
+HDQW,HDQW
+HAPV,HAPV
+AMEN,AMEN
+GPHG,GPHG
+QHFV,QHFV
+GHSS,GHSS
+NEEE,NEEE
+PRGM,PRGM
+YNML,YNML
+RHDG,RHDG
+VMVL,VMVL
+ETYF,ETYF
+EGVT,EGVT
+CWFC,CWFC
+DNYP,DNYP
+RREW,RREW
+QDCN,QDCN
+QNCG,QNCG
+VVVR,VVVR
+FRPQ,FRPQ
+FVFN,FVFN
+PEPR,PEPR
+TQVK,TQVK
+FCND,FCND
+FVLS,FVLS
+NMSG,NMSG
+KCWL,KCWL
+LMWL,LMWL
+WDHC,WDHC
+VGWM,VGWM
+NLQW,NLQW
+CETY,CETY
+EFMM,EFMM
+EDTV,EDTV
+PIRK,PIRK
+YTPA,YTPA
+HEKI,HEKI
+GYQH,GYQH
+FLRH,FLRH
+IMRY,IMRY
+RTVD,RTVD
+PIDV,PIDV
+AKIR,AKIR
+IPGD,IPGD
+HTIQ,HTIQ
+WWQW,WWQW
+KDFM,KDFM
+ESSS,ESSS
+ASRE,ASRE
+LCLQ,LCLQ
+VIYH,VIYH
+IVMA,IVMA
+RVQQ,RVQQ
+DQKV,DQKV
+KDDD,KDDD
+CPEE,CPEE
+WSAQ,WSAQ
+VQCL,VQCL
+CSYR,CSYR
+LAWA,LAWA
+VWVR,VWVR
+SPVN,SPVN
+MIAY,MIAY
+GLIL,GLIL
+AGVD,AGVD
+SNSF,SNSF
+FHSE,FHSE
+TLRK,TLRK
+IAMI,IAMI
+CPYV,CPYV
+NWWG,NWWG
+LQMG,LQMG
+KEGH,KEGH
+FGGW,FGGW
+NVFH,NVFH
+DLCG,DLCG
+APWF,APWF
+QVTC,QVTC
+YQGI,YQGI
+LVVF,LVVF
+RVQS,RVQS
+KAEP,KAEP
+WQVP,WQVP
+LWMR,LWMR
+NNDK,NNDK
+MHVR,MHVR
+EDQK,EDQK
+CACS,CACS
+CKHT,CKHT
+IWHF,IWHF
+IPTH,IPTH
+VDRN,VDRN
+YCPF,YCPF
+HELI,HELI
+SFCH,SFCH
+YLID,YLID
+GGHN,GGHN
+FSDP,FSDP
+CKVH,CKVH
+NTVG,NTVG
+IHNV,IHNV
+YMQN,YMQN
+PRVC,PRVC
+SDFS,SDFS
+SPFH,SPFH
+FSRK,FSRK
+QNWV,QNWV
+PYHQ,PYHQ
+FDNT,FDNT
+KAQW,KAQW
+PKDM,PKDM
+LIFE,LIFE
+ALDA,ALDA
+PGKM,PGKM
+QRNF,QRNF
+SSNN,SSNN
+FKKL,FKKL
+MWQK,MWQK
+RLKR,RLKR
+KSIY,KSIY
+GCIC,GCIC
+INVH,INVH
+NFQF,NFQF
+RDWY,RDWY
+SNIN,SNIN
+ESIC,ESIC
+LIRH,LIRH
+CIYL,CIYL
+MAFM,MAFM
+AASF,AASF
+HENV,HENV
+EHEV,EHEV
+LFNV,LFNV
+RQLP,RQLP
+PNHP,PNHP
+CFEE,CFEE
+DHAR,DHAR
+IDRH,IDRH
+EFPT,EFPT
+CEML,CEML
+KSVT,KSVT
+SMSN,SMSN
+AAYQ,AAYQ
+KQTG,KQTG
+WFPD,WFPD
+FYVR,FYVR
+RYSH,RYSH
+TFKF,TFKF
+LLRT,LLRT
+IERA,IERA
+KPHD,KPHD
+GMMY,GMMY
+RGQL,RGQL
+NYER,NYER
+NDWN,NDWN
+WKWY,WKWY
+QNCY,QNCY
+FFSG,FFSG
+WEFG,WEFG
+FCGM,FCGM
+EDTS,EDTS
+PEGV,PEGV
+RTNT,RTNT
+NNPT,NNPT
+DENA,DENA
+YEPH,YEPH
+NSYF,NSYF
+IYGF,IYGF
+DTGE,DTGE
+TWWQ,TWWQ
+FRID,FRID
+MRVV,MRVV
+ITDP,ITDP
+IVFN,IVFN
+PYDT,PYDT
+LPGP,LPGP
+MGNM,MGNM
+TFWF,TFWF
+LFHI,LFHI
+HYGW,HYGW
+LWPA,LWPA
+FLDY,FLDY
+QKAD,QKAD
+QYTM,QYTM
+YMSS,YMSS
+NWWL,NWWL
+FHWL,FHWL
+HFFG,HFFG
+DGNM,DGNM
+HWPA,HWPA
+VAEY,VAEY
+LKSL,LKSL
+HYAN,HYAN
+PEYE,PEYE
+QLFI,QLFI
+CGNH,CGNH
+EVFQ,EVFQ
+FSQR,FSQR
+ETIT,ETIT
+CNNF,CNNF
+ETRW,ETRW
+MKPK,MKPK
+YAQK,YAQK
+GMLH,GMLH
+WANF,WANF
+TQVG,TQVG
+THGW,THGW
+NSGW,NSGW
+HPLH,HPLH
+TWDS,TWDS
+SCQK,SCQK
+WQCY,WQCY
+FIRG,FIRG
+PSMR,PSMR
+THIC,THIC
+KQRT,KQRT
+LICP,LICP
+DLYC,DLYC
+WMDW,WMDW
+QYRQ,QYRQ
+WDWF,WDWF
+NGYG,NGYG
+CRTL,CRTL
+QADM,QADM
+GVVY,GVVY
+EWNK,EWNK
+MWGY,MWGY
+SLHS,SLHS
+PTHA,PTHA
+ANIP,ANIP
+ANMY,ANMY
+RMMC,RMMC
+MWCA,MWCA
+PTRW,PTRW
+ADSC,ADSC
+PYRM,PYRM
+QVLA,QVLA
+KSLG,KSLG
+GLCK,GLCK
+QIEG,QIEG
+PGNE,PGNE
+IPRW,IPRW
+HTSM,HTSM
+IPEM,IPEM
+NQRK,NQRK
+WVTA,WVTA
+SFIT,SFIT
+VDEF,VDEF
+NDPC,NDPC
+VVKC,VVKC
+TSTY,TSTY
+QRCV,QRCV
+SQFR,SQFR
+KTLL,KTLL
+TYHA,TYHA
+CIAC,CIAC
+KIED,KIED
+ANFS,ANFS
+KTNF,KTNF
+KAAC,KAAC
+ADYH,ADYH
+EKIA,EKIA
+HWRN,HWRN
+DKYV,DKYV
+DQPA,DQPA
+DIFK,DIFK
+MFVD,MFVD
+HWLK,HWLK
+TDQK,TDQK
+DFIC,DFIC
+LDDQ,LDDQ
+DAWF,DAWF
+TDPL,TDPL
+QCQW,QCQW
+MKHG,MKHG
+PCPL,PCPL
+MLPR,MLPR
+NDNV,NDNV
+LTPR,LTPR
+YRVC,YRVC
+HVHQ,HVHQ
+YMPM,YMPM
+FGMM,FGMM
+RFLT,RFLT
+SEAH,SEAH
+VHHC,VHHC
+SMAS,SMAS
+GSLP,GSLP
+NQEF,NQEF
+DEPV,DEPV
+THHL,THHL
+QSAP,QSAP
+VVLI,VVLI
+AGVI,AGVI
+STYP,STYP
+FYWL,FYWL
+SWGL,SWGL
+SSTS,SSTS
+LDGR,LDGR
+LKLW,LKLW
+RYPT,RYPT
+TTHG,TTHG
+SFQK,SFQK
+SNID,SNID
+KGCR,KGCR
+MVHP,MVHP
+FDNC,FDNC
+TFRF,TFRF
+LHIM,LHIM
+RCKP,RCKP
+MYYA,MYYA
+ALQG,ALQG
+DTCD,DTCD
+MLPY,MLPY
+RLEH,RLEH
+LQLG,LQLG
+LNWY,LNWY
+GLQK,GLQK
+GITD,GITD
+NPDS,NPDS
+MDKA,MDKA
+DLYV,DLYV
+AAKD,AAKD
+WRPI,WRPI
+MIQK,MIQK
+WDDK,WDDK
+YNKT,YNKT
+VIHL,VIHL
+ERQS,ERQS
+AYIY,AYIY
+NHDQ,NHDQ
+TKAK,TKAK
+VRNG,VRNG
+IPVY,IPVY
+SQVM,SQVM
+KTTF,KTTF
+KGHN,KGHN
+RTSK,RTSK
+IAIM,IAIM
+FGGV,FGGV
+SHPE,SHPE
+QDFY,QDFY
+SEME,SEME
+EKME,EKME
+YSCA,YSCA
+PTMP,PTMP
+KEWD,KEWD
+TGPT,TGPT
+ILIG,ILIG
+AAKQ,AAKQ
+SGLQ,SGLQ
+LQRL,LQRL
+TTLY,TTLY
+PFGV,PFGV
+FPCE,FPCE
+VSFH,VSFH
+PHEV,PHEV
+EHLC,EHLC
+FFSV,FFSV
+DCVV,DCVV
+RPEY,RPEY
+WYNA,WYNA
+FLKS,FLKS
+EPWP,EPWP
+PMPK,PMPK
+DNCQ,DNCQ
+MYCF,MYCF
+FLHM,FLHM
+WYIG,WYIG
+LNPR,LNPR
+HLSN,HLSN
+CQYS,CQYS
+QQSD,QQSD
+RSAH,RSAH
+SNCV,SNCV
+DIGN,DIGN
+WKRV,WKRV
+NYQM,NYQM
+PFTA,PFTA
+QASA,QASA
+WQRR,WQRR
+FFRN,FFRN
+WKSH,WKSH
+HEGV,HEGV
+SIKA,SIKA
+YSGC,YSGC
+HRND,HRND
+VFWY,VFWY
+NFRP,NFRP
+PVVH,PVVH
+YQIW,YQIW
+QNFH,QNFH
+ISFP,ISFP
+YLCA,YLCA
+NQSC,NQSC
+SMYW,SMYW
+HWTP,HWTP
+ARGH,ARGH
+CRMN,CRMN
+FKWW,FKWW
+QNMV,QNMV
+EWLN,EWLN
+MSLN,MSLN
+AFCQ,AFCQ
+WKPH,WKPH
+IKQG,IKQG
+GADR,GADR
+AKCN,AKCN
+PMMV,PMMV
+LDPH,LDPH
+QMKT,QMKT
+EANQ,EANQ
+HILY,HILY
+DGCA,DGCA
+QWFI,QWFI
+RRCY,RRCY
+AQFQ,AQFQ
+PICC,PICC
+GPGP,GPGP
+IAYH,IAYH
+MHGM,MHGM
+WMFD,WMFD
+VHTK,VHTK
+NWPN,NWPN
+LKRV,LKRV
+GFYF,GFYF
+QTSK,QTSK
+HPNK,HPNK
+QTSA,QTSA
+FGAR,FGAR
+ITWF,ITWF
+LRTE,LRTE
+AEAF,AEAF
+FHLQ,FHLQ
+PIAC,PIAC
+QWPL,QWPL
+KDKI,KDKI
+STSR,STSR
+PTIG,PTIG
+QIVA,QIVA
+MKCC,MKCC
+WSYN,WSYN
+NAWY,NAWY
+YVLE,YVLE
+VCRV,VCRV
+MHAQ,MHAQ
+TSWC,TSWC
+QKYR,QKYR
+TFIL,TFIL
+ITKR,ITKR
+DVGL,DVGL
+FVEL,FVEL
+CGPF,CGPF
+GPSL,GPSL
+LQPT,LQPT
+WKLD,WKLD
+MRLH,MRLH
+TYAM,TYAM
+VNAK,VNAK
+CEIA,CEIA
+WQDT,WQDT
+SRQV,SRQV
+CLHA,CLHA
+TPEA,TPEA
+EEKV,EEKV
+NHEL,NHEL
+NKCC,NKCC
+VVSN,VVSN
+EETC,EETC
+GTEV,GTEV
+NMYR,NMYR
+PYYT,PYYT
+FRCR,FRCR
+AMQN,AMQN
+KDYC,KDYC
+QNIE,QNIE
+MMDH,MMDH
+MWLR,MWLR
+AELN,AELN
+KNQT,KNQT
+TNHK,TNHK
+TDNF,TDNF
+YPDQ,YPDQ
+NTDP,NTDP
+SEGL,SEGL
+PMWQ,PMWQ
+CPQA,CPQA
+PDPH,PDPH
+NYWT,NYWT
+WTIN,WTIN
+TQLE,TQLE
+HFAP,HFAP
+NSCW,NSCW
+LVTE,LVTE
+CWWT,CWWT
+PECP,PECP
+WGWE,WGWE
+FYTW,FYTW
+LHGA,LHGA
+PFGR,PFGR
+SNIA,SNIA
+HPIQ,HPIQ
+KWMG,KWMG
+VIWL,VIWL
+LEIC,LEIC
+LSIQ,LSIQ
+VSSK,VSSK
+ICDY,ICDY
+FFCC,FFCC
+IFWQ,IFWQ
+YWWI,YWWI
+HTDL,HTDL
+DPDA,DPDA
+HLYC,HLYC
+SVCF,SVCF
+VGNK,VGNK
+IKGW,IKGW
+DVFC,DVFC
+PKSC,PKSC
+CAML,CAML
+INCE,INCE
+QEKW,QEKW
+EGSR,EGSR
+NDAL,NDAL
+VGCC,VGCC
+AHVE,AHVE
+KSKE,KSKE
+VPKS,VPKS
+AQYS,AQYS
+CHYC,CHYC
+EVNN,EVNN
+VQVG,VQVG
+ECDG,ECDG
+CSIT,CSIT
+EEFG,EEFG
+AFRN,AFRN
+NLSK,NLSK
+DSQY,DSQY
+ELHH,ELHH
+SNFS,SNFS
+SYPG,SYPG
+DFAK,DFAK
+QAQD,QAQD
+IIDS,IIDS
+MFSG,MFSG
+LANN,LANN
+KKNF,KKNF
+VLNM,VLNM
+DEWW,DEWW
+LEHK,LEHK
+SMVW,SMVW
+IING,IING
+GIIY,GIIY
+IHGP,IHGP
+PEFC,PEFC
+RKHR,RKHR
+DRPY,DRPY
+CPVD,CPVD
+CKVF,CKVF
+PEID,PEID
+LPRM,LPRM
+PRRA,PRRA
+YFTF,YFTF
+VWGW,VWGW
+AGTA,AGTA
+NRHA,NRHA
+VNVC,VNVC
+KHRY,KHRY
+RAKD,RAKD
+YGPH,YGPH
+GCHN,GCHN
+TDRL,TDRL
+HRLK,HRLK
+PWRH,PWRH
+KKTN,KKTN
+TELH,TELH
+EKTL,EKTL
+TWVR,TWVR
+SHQN,SHQN
+TCIA,TCIA
+THKW,THKW
+VGES,VGES
+KMHT,KMHT
+VDYD,VDYD
+KVYT,KVYT
+KGFR,KGFR
+NWNG,NWNG
+PQPK,PQPK
+FKVT,FKVT
+VIDA,VIDA
+AQMK,AQMK
+LGCI,LGCI
+AWDV,AWDV
+AHKR,AHKR
+HAPF,HAPF
+LINW,LINW
+SNYD,SNYD
+KVFQ,KVFQ
+SWML,SWML
+NMHN,NMHN
+RVSQ,RVSQ
+MYCI,MYCI
+WQPN,WQPN
+VNRT,VNRT
+QHTR,QHTR
+RCRP,RCRP
+HCWT,HCWT
+GQSH,GQSH
+RTHG,RTHG
+NQQL,NQQL
+SNHN,SNHN
+MKIF,MKIF
+YYHC,YYHC
+YRMP,YRMP
+SHQH,SHQH
+WAWT,WAWT
+TFIS,TFIS
+DDWR,DDWR
+AMDV,AMDV
+ADRK,ADRK
+HMHR,HMHR
+FNAG,FNAG
+EMYK,EMYK
+WVSQ,WVSQ
+AHFV,AHFV
+RQHV,RQHV
+TQYA,TQYA
+AIWE,AIWE
+CMKR,CMKR
+IKWC,IKWC
+RFML,RFML
+VCGS,VCGS
+RTNP,RTNP
+MTYG,MTYG
+MINS,MINS
+DIKD,DIKD
+KNFC,KNFC
+ENSS,ENSS
+MSPW,MSPW
+VAYR,VAYR
+YSME,YSME
+LKTH,LKTH
+PGHR,PGHR
+LPAH,LPAH
+QCWM,QCWM
+GWSQ,GWSQ
+IVSP,IVSP
+YYFW,YYFW
+WMAW,WMAW
+LLDC,LLDC
+WTHH,WTHH
+GCQH,GCQH
+WTGS,WTGS
+LFGA,LFGA
+LREV,LREV
+TYGD,TYGD
+VHTR,VHTR
+CGCQ,CGCQ
+FVIH,FVIH
+GQFY,GQFY
+ELYA,ELYA
+EMRT,EMRT
+DGDL,DGDL
+QEPC,QEPC
+NHDA,NHDA
+IISC,IISC
+NSMN,NSMN
+GLTR,GLTR
+CISI,CISI
+RGVQ,RGVQ
+KDMC,KDMC
+SGYG,SGYG
+ENNH,ENNH
+NDPM,NDPM
+AYAE,AYAE
+DFWH,DFWH
+GDII,GDII
+GFKP,GFKP
+CAYP,CAYP
+KHDS,KHDS
+GAWV,GAWV
+TTNE,TTNE
+FEDH,FEDH
+YTAV,YTAV
+AMVW,AMVW
+LSQT,LSQT
+NECR,NECR
+GLGA,GLGA
+PNYQ,PNYQ
+KSTF,KSTF
+KVCI,KVCI
+RKIS,RKIS
+PILN,PILN
+GCCR,GCCR
+SVCQ,SVCQ
+WVLQ,WVLQ
+LLGC,LLGC
+HAWM,HAWM
+AVQK,AVQK
+NPGA,NPGA
+TPEW,TPEW
+SDNG,SDNG
+PIQV,PIQV
+YIMK,YIMK
+NYMG,NYMG
+LTYP,LTYP
+GTTS,GTTS
+FERD,FERD
+EIGH,EIGH
+CPKM,CPKM
+QSNI,QSNI
+HSKL,HSKL
+CWEM,CWEM
+NDWV,NDWV
+FFIR,FFIR
+CNSC,CNSC
+KTGN,KTGN
+RGSY,RGSY
+CVLQ,CVLQ
+NKNQ,NKNQ
+CWYK,CWYK
+SSRN,SSRN
+KNGD,KNGD
+PECK,PECK
+NRKC,NRKC
+HTAN,HTAN
+NSKE,NSKE
+ALFY,ALFY
+KWPM,KWPM
+CFTK,CFTK
+PDKM,PDKM
+TQIS,TQIS
+DEWM,DEWM
+EHMK,EHMK
+IYNR,IYNR
+HAFR,HAFR
+DECE,DECE
+WYVV,WYVV
+GCPK,GCPK
+DRKK,DRKK
+KEVR,KEVR
+WNWC,WNWC
+PAYK,PAYK
+QKEE,QKEE
+QGEC,QGEC
+LYGF,LYGF
+IWAR,IWAR
+GRAR,GRAR
+AIYC,AIYC
+TTVF,TTVF
+HFLW,HFLW
+NARM,NARM
+RHRA,RHRA
+QQDS,QQDS
+FHSL,FHSL
+AVDA,AVDA
+HERQ,HERQ
+TMMP,TMMP
+PEMT,PEMT
+AAFS,AAFS
+QEEG,QEEG
+ATMV,ATMV
+CAFW,CAFW
+LSGH,LSGH
+YKLV,YKLV
+MPNS,MPNS
+CKMP,CKMP
+KKYS,KKYS
+IITA,IITA
+PAIY,PAIY
+WDCD,WDCD
+RSDW,RSDW
+QPAL,QPAL
+EYPW,EYPW
+FCWC,FCWC
+CFRY,CFRY
+QLCG,QLCG
+QETE,QETE
+TCNV,TCNV
+DQFR,DQFR
+HKTS,HKTS
+GWDT,GWDT
+SFMN,SFMN
+GHMF,GHMF
+HDRQ,HDRQ
+RTNL,RTNL
+YNKP,YNKP
+KDIG,KDIG
+LECA,LECA
+RRGK,RRGK
+LNPY,LNPY
+IMVW,IMVW
+PVDS,PVDS
+RERF,RERF
+KAER,KAER
+FMGP,FMGP
+PSAT,PSAT
+VKEQ,VKEQ
+CKCE,CKCE
+TAAR,TAAR
+QPRA,QPRA
+HEAH,HEAH
+LCNA,LCNA
+DEMY,DEMY
+TEPE,TEPE
+WNLY,WNLY
+SPHG,SPHG
+GQHQ,GQHQ
+ADYM,ADYM
+FQYW,FQYW
+VSDD,VSDD
+NAKM,NAKM
+QMDQ,QMDQ
+SDAK,SDAK
+HLDH,HLDH
+SCCY,SCCY
+HGSC,HGSC
+RAVV,RAVV
+KCND,KCND
+LIDG,LIDG
+GGMD,GGMD
+PFRW,PFRW
+NMLG,NMLG
+NWSN,NWSN
+TRGN,TRGN
+MIYA,MIYA
+IFAS,IFAS
+QICA,QICA
+VTIL,VTIL
+NYLP,NYLP
+QFGT,QFGT
+GLDV,GLDV
+DHNR,DHNR
+NYRP,NYRP
+CDKL,CDKL
+WQSQ,WQSQ
+ADPG,ADPG
+FEHM,FEHM
+DHFW,DHFW
+WSSW,WSSW
+FPMF,FPMF
+SLLD,SLLD
+KVRS,KVRS
+ITNH,ITNH
+GLAR,GLAR
+CACL,CACL
+HFDQ,HFDQ
+LDPE,LDPE
+FIQA,FIQA
+WFSN,WFSN
+NQQC,NQQC
+CGWR,CGWR
+QMDV,QMDV
+QCEQ,QCEQ
+YNKS,YNKS
+ALCP,ALCP
+RRKI,RRKI
+GPCV,GPCV
+HISI,HISI
+QVAD,QVAD
+DFWV,DFWV
+WEAM,WEAM
+CFWG,CFWG
+GCWP,GCWP
+PHPC,PHPC
+AVSM,AVSM
+TSPC,TSPC
+MWLF,MWLF
+RHSI,RHSI
+HKQL,HKQL
+IPTF,IPTF
+SSNP,SSNP
+ATLL,ATLL
+SAHD,SAHD
+YNQP,YNQP
+RPSF,RPSF
+TCHS,TCHS
+AVGR,AVGR
+HYPI,HYPI
+PQYL,PQYL
+GNIA,GNIA
+LWQD,LWQD
+SHSC,SHSC
+FNCR,FNCR
+VAGR,VAGR
+YNLS,YNLS
+NSLF,NSLF
+MIIM,MIIM
+RYPG,RYPG
+DCQI,DCQI
+PMFI,PMFI
+CIFL,CIFL
+TIRG,TIRG
+CRVF,CRVF
+WHEL,WHEL
+ALWP,ALWP
+CMKC,CMKC
+PWID,PWID
+ESTM,ESTM
+EHDY,EHDY
+EMIR,EMIR
+NAWM,NAWM
+LNCW,LNCW
+FYDK,FYDK
+WKEG,WKEG
+HHCG,HHCG
+NKPS,NKPS
+FCDI,FCDI
+HDSC,HDSC
+PAYR,PAYR
+YFMV,YFMV
+NTGH,NTGH
+SREK,SREK
+FYCL,FYCL
+GFHM,GFHM
+EQCV,EQCV
+GREQ,GREQ
+NYCP,NYCP
+EKER,EKER
+SAIS,SAIS
+RHIQ,RHIQ
+AITQ,AITQ
+FEAT,FEAT
+PKPF,PKPF
+HIMN,HIMN
+DSSQ,DSSQ
+KKYC,KKYC
+YSST,YSST
+LETH,LETH
+PSFA,PSFA
+VQLN,VQLN
+LCCH,LCCH
+MNWM,MNWM
+DNTG,DNTG
+YRQF,YRQF
+NPIF,NPIF
+AISE,AISE
+ECGH,ECGH
+WQRL,WQRL
+YMKK,YMKK
+IWQA,IWQA
+TLRF,TLRF
+HGYL,HGYL
+SHPF,SHPF
+WVNW,WVNW
+QKIH,QKIH
+REVN,REVN
+CQAA,CQAA
+YMCK,YMCK
+GCAE,GCAE
+IYCC,IYCC
+LHPT,LHPT
+HYGI,HYGI
+MVPE,MVPE
+LGKM,LGKM
+WGRS,WGRS
+GSIK,GSIK
+KPPN,KPPN
+MNGQ,MNGQ
+EYCW,EYCW
+SCWT,SCWT
+IGNE,IGNE
+DAVK,DAVK
+EWIH,EWIH
+NTWM,NTWM
+ADSL,ADSL
+QHHD,QHHD
+YAYE,YAYE
+CTVL,CTVL
+YPNQ,YPNQ
+GSTY,GSTY
+NYDY,NYDY
+SITI,SITI
+TWNQ,TWNQ
+KWRC,KWRC
+IVKV,IVKV
+QHKL,QHKL
+HRRT,HRRT
+SLIP,SLIP
+EPYW,EPYW
+WYST,WYST
+KRQD,KRQD
+KDKA,KDKA
+LVTY,LVTY
+PLKQ,PLKQ
+DFTH,DFTH
+PRYH,PRYH
+HKEW,HKEW
+DMII,DMII
+MKSQ,MKSQ
+AGAE,AGAE
+KSCD,KSCD
+STKQ,STKQ
+THTI,THTI
+KDNF,KDNF
+KAHG,KAHG
+RGQA,RGQA
+QDKS,QDKS
+QSIS,QSIS
+NMSV,NMSV
+WAAK,WAAK
+GYRA,GYRA
+METL,METL
+VYAY,VYAY
+HAQA,HAQA
+HETA,HETA
+KVYK,KVYK
+VYCP,VYCP
+LLGG,LLGG
+YQLI,YQLI
+AYLP,AYLP
+FIVM,FIVM
+WMAS,WMAS
+CTRV,CTRV
+NMDG,NMDG
+FPDC,FPDC
+CIYD,CIYD
+GSKT,GSKT
+CGFR,CGFR
+TRSH,TRSH
+MVSL,MVSL
+RRKV,RRKV
+VLQI,VLQI
+VSAC,VSAC
+DWSM,DWSM
+NHNN,NHNN
+AFYN,AFYN
+EDDP,EDDP
+DHMM,DHMM
+QTHP,QTHP
+TTPK,TTPK
+KWHA,KWHA
+WCTW,WCTW
+ELHW,ELHW
+PRGH,PRGH
+KTSE,KTSE
+HFIG,HFIG
+PRTR,PRTR
+GTPP,GTPP
+APLR,APLR
+FPAW,FPAW
+WNGE,WNGE
+EYQP,EYQP
+KHDF,KHDF
+WELM,WELM
+KPRK,KPRK
+YSVA,YSVA
+TQSV,TQSV
+VMIK,VMIK
+RNHG,RNHG
+SLGK,SLGK
+ETEG,ETEG
+MWKN,MWKN
+TVHD,TVHD
+TPHR,TPHR
+SIHY,SIHY
+LLWM,LLWM
+EVGN,EVGN
+NKIP,NKIP
+PQDM,PQDM
+YDMK,YDMK
+CTPI,CTPI
+FYEH,FYEH
+NENL,NENL
+ETVQ,ETVQ
+NLYD,NLYD
+SIRG,SIRG
+PGIN,PGIN
+QSMW,QSMW
+HMLW,HMLW
+QSLR,QSLR
+CCNM,CCNM
+LKAW,LKAW
+TIKC,TIKC
+RPFF,RPFF
+SIVL,SIVL
+TVYC,TVYC
+HWRD,HWRD
+PVDL,PVDL
+RVSH,RVSH
+QGGV,QGGV
+ERLR,ERLR
+IYTM,IYTM
+KSYI,KSYI
+KPGM,KPGM
+WTFI,WTFI
+ICAC,ICAC
+TSMW,TSMW
+PIRF,PIRF
+NKRN,NKRN
+VFNR,VFNR
+QQRK,QQRK
+KFMW,KFMW
+PHVT,PHVT
+KQFW,KQFW
+DHQD,DHQD
+SHLR,SHLR
+ADDC,ADDC
+RKQI,RKQI
+PPFQ,PPFQ
+VECA,VECA
+EPSY,EPSY
+RAYD,RAYD
+QRFT,QRFT
+CYAI,CYAI
+NSYW,NSYW
+VEGM,VEGM
+PVKV,PVKV
+CGEF,CGEF
+QDEA,QDEA
+EFET,EFET
+QTCH,QTCH
+LIFR,LIFR
+CQNM,CQNM
+HHPD,HHPD
+GFIK,GFIK
+TTLH,TTLH
+SGED,SGED
+PRPE,PRPE
+GIDF,GIDF
+DVSH,DVSH
+CCVH,CCVH
+KTCF,KTCF
+ISYI,ISYI
+NQII,NQII
+GPCY,GPCY
+HCVE,HCVE
+FSYV,FSYV
+SIAV,SIAV
+VVNC,VVNC
+VCHD,VCHD
+DTDS,DTDS
+CFVK,CFVK
+VNDH,VNDH
+VHWL,VHWL
+CSCE,CSCE
+KQFR,KQFR
+EFDP,EFDP
+RDAI,RDAI
+PTMQ,PTMQ
+SDGG,SDGG
+PTVI,PTVI
+MIMP,MIMP
+QSVW,QSVW
+ETQH,ETQH
+KVCK,KVCK
+QRSE,QRSE
+CQAE,CQAE
+HVFE,HVFE
+EHHR,EHHR
+IKYC,IKYC
+YWPA,YWPA
+PGVW,PGVW
+EHGF,EHGF
+IQDC,IQDC
+YVHI,YVHI
+TMFP,TMFP
+AEDA,AEDA
+PCTW,PCTW
+FNGV,FNGV
+AHVD,AHVD
+CGIY,CGIY
+CYFW,CYFW
+GQCG,GQCG
+NTSW,NTSW
+WYSQ,WYSQ
+WCLH,WCLH
+GHCP,GHCP
+YPMN,YPMN
+WCPF,WCPF
+MVGK,MVGK
+DCVI,DCVI
+WRPF,WRPF
+VEDP,VEDP
+WWNS,WWNS
+PQFN,PQFN
+ITGY,ITGY
+QRWD,QRWD
+FPDR,FPDR
+EKQQ,EKQQ
+FWYD,FWYD
+TYYL,TYYL
+THCL,THCL
+RGTI,RGTI
+ALVA,ALVA
+LEWG,LEWG
+RVQH,RVQH
+LFAS,LFAS
+SVHG,SVHG
+SREG,SREG
+GVDR,GVDR
+MMVT,MMVT
+VPGH,VPGH
+YTQD,YTQD
+DYPH,DYPH
+RRMG,RRMG
+AVDP,AVDP
+EVKQ,EVKQ
+LTFC,LTFC
+KATL,KATL
+MYKA,MYKA
+RYCC,RYCC
+VHKY,VHKY
+LVMI,LVMI
+YHFK,YHFK
+RLNQ,RLNQ
+EMEV,EMEV
+DPGV,DPGV
+AAWQ,AAWQ
+FDDC,FDDC
+SKLN,SKLN
+LCEE,LCEE
+VVWW,VVWW
+KLQI,KLQI
+DHDA,DHDA
+RTQF,RTQF
+STTP,STTP
+FFEI,FFEI
+IKCN,IKCN
+ACWP,ACWP
+AWGE,AWGE
+HYRY,HYRY
+FFVR,FFVR
+CEEV,CEEV
+LQMY,LQMY
+SACN,SACN
+MWWT,MWWT
+IDQT,IDQT
+QGCS,QGCS
+WRLE,WRLE
+AAPH,AAPH
+NTKN,NTKN
+FMSK,FMSK
+MGLI,MGLI
+YECV,YECV
+RFID,RFID
+CEDK,CEDK
+ILEE,ILEE
+RAMW,RAMW
+FPTQ,FPTQ
+HRCR,HRCR
+FIMH,FIMH
+KIPT,KIPT
+NNNH,NNNH
+ANWL,ANWL
+ARTD,ARTD
+APDW,APDW
+AFCR,AFCR
+FQPT,FQPT
+ALNI,ALNI
+FNWC,FNWC
+SYEV,SYEV
+IMYD,IMYD
+TRVA,TRVA
+RAMI,RAMI
+QCTI,QCTI
+NQRE,NQRE
+YEPV,YEPV
+CWAK,CWAK
+LFCK,LFCK
+NESI,NESI
+WHQL,WHQL
+DGVF,DGVF
+NHPH,NHPH
+YSQT,YSQT
+PWDL,PWDL
+FEDQ,FEDQ
+YMPP,YMPP
+RNCR,RNCR
+NWWQ,NWWQ
+VMVQ,VMVQ
+YSSP,YSSP
+QHKQ,QHKQ
+FPVM,FPVM
+ADHT,ADHT
+ATSY,ATSY
+DLPV,DLPV
+ETRD,ETRD
+MHVD,MHVD
+VIHG,VIHG
+FDEA,FDEA
+TSNQ,TSNQ
+YSIF,YSIF
+QIII,QIII
+RGGM,RGGM
+VAMH,VAMH
+CVGQ,CVGQ
+RPYI,RPYI
+DEFL,DEFL
+QHPN,QHPN
+MLEP,MLEP
+IEDW,IEDW
+YLWR,YLWR
+DHHD,DHHD
+KSWF,KSWF
+AVKM,AVKM
+SRER,SRER
+AMNH,AMNH
+MDDM,MDDM
+CGNP,CGNP
+GEHF,GEHF
+PLPD,PLPD
+FSHK,FSHK
+AISH,AISH
+GDAN,GDAN
+CQYQ,CQYQ
+AGEQ,AGEQ
+RQWE,RQWE
+RRQL,RRQL
+WHGN,WHGN
+PKYY,PKYY
+CCIM,CCIM
+KWRL,KWRL
+LTTE,LTTE
+MYNQ,MYNQ
+SSAI,SSAI
+LYCT,LYCT
+CMPV,CMPV
+HVCL,HVCL
+NRKH,NRKH
+KECR,KECR
+TWKA,TWKA
+WASS,WASS
+KKIY,KKIY
+VAFT,VAFT
+LDVC,LDVC
+YEPK,YEPK
+CISD,CISD
+NMWE,NMWE
+CVNT,CVNT
+TLDK,TLDK
+CYGK,CYGK
+PVTT,PVTT
+HDDC,HDDC
+LGLF,LGLF
+LAQN,LAQN
+NTFF,NTFF
+KISF,KISF
+GVLP,GVLP
+LNVM,LNVM
+NAGK,NAGK
+NHNV,NHNV
+LRCW,LRCW
+WMYG,WMYG
+GCYY,GCYY
+CSYK,CSYK
+PDLM,PDLM
+WSWA,WSWA
+GQSL,GQSL
+NWRM,NWRM
+EEHP,EEHP
+WCYP,WCYP
+NNAM,NNAM
+MHHK,MHHK
+FGFS,FGFS
+KPLK,KPLK
+TYPI,TYPI
+CDRS,CDRS
+WMFH,WMFH
+HEWG,HEWG
+PQNW,PQNW
+QVQH,QVQH
+NTPI,NTPI
+VMVI,VMVI
+RHAT,RHAT
+PKKF,PKKF
+IIHN,IIHN
+LVNS,LVNS
+YTSK,YTSK
+IAGS,IAGS
+KNGE,KNGE
+GESD,GESD
+IAKF,IAKF
+QPDG,QPDG
+CLEN,CLEN
+MQHR,MQHR
+YRFL,YRFL
+RTPP,RTPP
+IVKA,IVKA
+KDPY,KDPY
+SSFF,SSFF
+YKPE,YKPE
+NEDG,NEDG
+YEGS,YEGS
+FGGQ,FGGQ
+NDFM,NDFM
+HNEC,HNEC
+NQLR,NQLR
+RLVW,RLVW
+NVFD,NVFD
+PMNY,PMNY
+RLHA,RLHA
+DIII,DIII
+WMLQ,WMLQ
+KACN,KACN
+IATA,IATA
+LIAS,LIAS
+SVSF,SVSF
+CKIS,CKIS
+YNFT,YNFT
+CKGC,CKGC
+EQIV,EQIV
+FRKQ,FRKQ
+VAWY,VAWY
+NWPG,NWPG
+RIHV,RIHV
+TIEC,TIEC
+NLYT,NLYT
+CTYK,CTYK
+FTQN,FTQN
+WVER,WVER
+VPII,VPII
+DKNM,DKNM
+MYEK,MYEK
+WYWF,WYWF
+IDVQ,IDVQ
+SWTV,SWTV
+DTVE,DTVE
+CDKP,CDKP
+WEEQ,WEEQ
+AFRC,AFRC
+NTKQ,NTKQ
+KQED,KQED
+PESP,PESP
+HDTQ,HDTQ
+VHHE,VHHE
+SWGA,SWGA
+YEHR,YEHR
+EDWE,EDWE
+QSVY,QSVY
+AMWP,AMWP
+VLHP,VLHP
+KEYR,KEYR
+ECKA,ECKA
+LIAN,LIAN
+SFHW,SFHW
+VCHQ,VCHQ
+CHYW,CHYW
+PVPV,PVPV
+SPSG,SPSG
+LRIA,LRIA
+YQYS,YQYS
+GGLV,GGLV
+DTTL,DTTL
+TKKN,TKKN
+QIYT,QIYT
+NMYD,NMYD
+EFRP,EFRP
+FTIK,FTIK
+WLWV,WLWV
+CKVC,CKVC
+TPIG,TPIG
+WEWH,WEWH
+QCVC,QCVC
+NTDK,NTDK
+WDCT,WDCT
+RMKF,RMKF
+LRIY,LRIY
+FETM,FETM
+ECRP,ECRP
+RFVF,RFVF
+VQIP,VQIP
+DQEE,DQEE
+MVLS,MVLS
+CYIT,CYIT
+FNPE,FNPE
+IAGE,IAGE
+LMWK,LMWK
+GQAS,GQAS
+LEWQ,LEWQ
+IGHI,IGHI
+ICMM,ICMM
+MEDM,MEDM
+FGRY,FGRY
+VGWW,VGWW
+KDIN,KDIN
+RGRW,RGRW
+YGES,YGES
+HNTA,HNTA
+EGNH,EGNH
+VNTW,VNTW
+PPVQ,PPVQ
+PWWA,PWWA
+MTHR,MTHR
+NKCN,NKCN
+IGRL,IGRL
+FIWM,FIWM
+PGTT,PGTT
+HGAE,HGAE
+PMWS,PMWS
+KWNC,KWNC
+GFDW,GFDW
+QKKG,QKKG
+HVTG,HVTG
+SGET,SGET
+AWKW,AWKW
+TRPE,TRPE
+RVHE,RVHE
+EEPS,EEPS
+CVSY,CVSY
+SRPE,SRPE
+LMMY,LMMY
+CSDW,CSDW
+RIHP,RIHP
+YDTM,YDTM
+YTYT,YTYT
+GSHI,GSHI
+NCRV,NCRV
+MGVK,MGVK
+LWNY,LWNY
+MYWC,MYWC
+ETST,ETST
+NCVV,NCVV
+TIEI,TIEI
+DMMK,DMMK
+NMIR,NMIR
+EFVF,EFVF
+KTSK,KTSK
+EQFD,EQFD
+PVMD,PVMD
+IGYL,IGYL
+LLLM,LLLM
+HDRC,HDRC
+QGCV,QGCV
+WQPH,WQPH
+DRWA,DRWA
+MVVG,MVVG
+TMMC,TMMC
+KVYN,KVYN
+AIIA,AIIA
+FNYS,FNYS
+HRCA,HRCA
+IAWP,IAWP
+VDYL,VDYL
+VICL,VICL
+HYDA,HYDA
+ADSA,ADSA
+TYYT,TYYT
+SQRL,SQRL
+EIQM,EIQM
+HRNL,HRNL
+DQVF,DQVF
+PTWK,PTWK
+LCSY,LCSY
+FHST,FHST
+DKQV,DKQV
+PFSM,PFSM
+QLAQ,QLAQ
+EDMF,EDMF
+EKEN,EKEN
+LMPW,LMPW
+CALR,CALR
+RPAY,RPAY
+HVCH,HVCH
+GVQA,GVQA
+TLGN,TLGN
+QFIR,QFIR
+LKYW,LKYW
+MTWR,MTWR
+VRMD,VRMD
+LLFQ,LLFQ
+CEVE,CEVE
+MDDA,MDDA
+WPVP,WPVP
+DTVI,DTVI
+WGVM,WGVM
+DYDT,DYDT
+NWKV,NWKV
+DLPC,DLPC
+LEMF,LEMF
+VHVQ,VHVQ
+RVWF,RVWF
+KNDW,KNDW
+EAMT,EAMT
+IQLT,IQLT
+HYYY,HYYY
+PEGN,PEGN
+TRQR,TRQR
+EIML,EIML
+ETGF,ETGF
+QQSV,QQSV
+KFIP,KFIP
+TVAM,TVAM
+GTHA,GTHA
+QCHI,QCHI
+IGIR,IGIR
+HQLS,HQLS
+QYQM,QYQM
+PNEP,PNEP
+RKSK,RKSK
+AAYG,AAYG
+ATCM,ATCM
+DDCH,DDCH
+NTAF,NTAF
+LHNG,LHNG
+ECIA,ECIA
+EWAA,EWAA
+CKSK,CKSK
+MDTH,MDTH
+DNCP,DNCP
+NLDP,NLDP
+KFVS,KFVS
+TSLV,TSLV
+QVCA,QVCA
+DPDM,DPDM
+LSGA,LSGA
+MLVC,MLVC
+IAPM,IAPM
+CGFY,CGFY
+VIHV,VIHV
+GLRD,GLRD
+EYDE,EYDE
+FNEP,FNEP
+DIMC,DIMC
+AFIC,AFIC
+KFMD,KFMD
+YFNI,YFNI
+HTMD,HTMD
+EKFN,EKFN
+NFII,NFII
+MNHN,MNHN
+PFGK,PFGK
+EWSD,EWSD
+SGMK,SGMK
+SHTM,SHTM
+RFQL,RFQL
+LNTY,LNTY
+EWPT,EWPT
+KINA,KINA
+YYED,YYED
+LGSD,LGSD
+CRNH,CRNH
+NNSK,NNSK
+SPIQ,SPIQ
+KWQV,KWQV
+KKQA,KKQA
+TSFI,TSFI
+NPFE,NPFE
+MKCE,MKCE
+EQKH,EQKH
+WENH,WENH
+VDLI,VDLI
+WVDF,WVDF
+FFAM,FFAM
+SPSP,SPSP
+TWKI,TWKI
+TWTC,TWTC
+RTGE,RTGE
+SFSI,SFSI
+WTEF,WTEF
+DIFH,DIFH
+QFGV,QFGV
+NRRP,NRRP
+GHHS,GHHS
+IYMN,IYMN
+TTWT,TTWT
+NVSG,NVSG
+LAKQ,LAKQ
+WNAI,WNAI
+GHWG,GHWG
+SPPG,SPPG
+FWKT,FWKT
+ERKH,ERKH
+WWLW,WWLW
+MNKM,MNKM
+RITQ,RITQ
+MFMR,MFMR
+KVHQ,KVHQ
+TFFD,TFFD
+FWFT,FWFT
+LHLT,LHLT
+LQQF,LQQF
+CWVA,CWVA
+IRQW,IRQW
+EGHH,EGHH
+VHLC,VHLC
+TVKK,TVKK
+QSQH,QSQH
+DFIT,DFIT
+IGRW,IGRW
+FVHC,FVHC
+TERW,TERW
+KFSH,KFSH
+FECP,FECP
+DWFG,DWFG
+SWIH,SWIH
+KGTR,KGTR
+HEII,HEII
+PHDF,PHDF
+QLQA,QLQA
+RLYF,RLYF
+TGYA,TGYA
+KRKH,KRKH
+YQCY,YQCY
+MPWS,MPWS
+SQTV,SQTV
+RRNV,RRNV
+HPCP,HPCP
+SVRC,SVRC
+GHVA,GHVA
+LNVW,LNVW
+PSRY,PSRY
+ICRN,ICRN
+YTNI,YTNI
+YGIM,YGIM
+GGNN,GGNN
+TWEG,TWEG
+NCYT,NCYT
+WNDT,WNDT
+EVSF,EVSF
+KCDN,KCDN
+YYVE,YYVE
+RFVY,RFVY
+AVIG,AVIG
+AVKT,AVKT
+KKLH,KKLH
+MLTD,MLTD
+TPMH,TPMH
+LAQY,LAQY
+GDIH,GDIH
+NVEM,NVEM
+THMI,THMI
+EMLC,EMLC
+TFCW,TFCW
+RVQA,RVQA
+WHED,WHED
+SLRQ,SLRQ
+CKHA,CKHA
+INVT,INVT
+QHTI,QHTI
+VQYL,VQYL
+FSWQ,FSWQ
+SFSW,SFSW
+KPFI,KPFI
+QIND,QIND
+KWYI,KWYI
+IVFD,IVFD
+TYSC,TYSC
+KYGD,KYGD
+KDID,KDID
+HQTQ,HQTQ
+SACQ,SACQ
+VYIV,VYIV
+PNLV,PNLV
+MHFD,MHFD
+KWCN,KWCN
+GMRN,GMRN
+PIHW,PIHW
+QRYQ,QRYQ
+GESI,GESI
+WCHK,WCHK
+HQTR,HQTR
+PNDQ,PNDQ
+SRIN,SRIN
+FLWG,FLWG
+NGSN,NGSN
+GKSF,GKSF
+PCMM,PCMM
+DQPL,DQPL
+SYQY,SYQY
+YYTT,YYTT
+VIRS,VIRS
+LSSM,LSSM
+RACV,RACV
+KSTA,KSTA
+NFTQ,NFTQ
+CVVM,CVVM
+WTNV,WTNV
+LCVG,LCVG
+IMTD,IMTD
+HTHW,HTHW
+GNEP,GNEP
+NGQG,NGQG
+TFKL,TFKL
+SVYH,SVYH
+TVCM,TVCM
+CQYY,CQYY
+FFSS,FFSS
+TWVS,TWVS
+KMKK,KMKK
+VNVQ,VNVQ
+PWEA,PWEA
+LDIG,LDIG
+DFVM,DFVM
+SAAE,SAAE
+NQPC,NQPC
+ADMI,ADMI
+ETDI,ETDI
+FCCD,FCCD
+EDVT,EDVT
+YPLG,YPLG
+CLCS,CLCS
+CTTS,CTTS
+KYLL,KYLL
+QVGN,QVGN
+KPRW,KPRW
+DEQN,DEQN
+KHAQ,KHAQ
+TFSK,TFSK
+MMTS,MMTS
+QQHD,QQHD
+CSYV,CSYV
+DYGS,DYGS
+ITKD,ITKD
+LWLA,LWLA
+GKRS,GKRS
+YWLV,YWLV
+EFAN,EFAN
+MPMS,MPMS
+MAYH,MAYH
+PCRG,PCRG
+WEKY,WEKY
+MGED,MGED
+AQQM,AQQM
+CYCW,CYCW
+IEDM,IEDM
+NEND,NEND
+SFEE,SFEE
+FQNE,FQNE
+LPLF,LPLF
+MQCV,MQCV
+YDYS,YDYS
+IDCA,IDCA
+EWDN,EWDN
+TGWP,TGWP
+SPWD,SPWD
+DIDS,DIDS
+EVTC,EVTC
+KMIK,KMIK
+GDSE,GDSE
+DCYA,DCYA
+YLET,YLET
+LLCC,LLCC
+TGEQ,TGEQ
+IMWR,IMWR
+WQQW,WQQW
+QPPG,QPPG
+AMEV,AMEV
+TYEF,TYEF
+DGHR,DGHR
+HPHP,HPHP
+GHHY,GHHY
+ARNE,ARNE
+ACTC,ACTC
+PTNL,PTNL
+KWWQ,KWWQ
+EPSF,EPSF
+PIDQ,PIDQ
+QTIW,QTIW
+DAMF,DAMF
+RKGV,RKGV
+DDHT,DDHT
+TFIR,TFIR
+LQQC,LQQC
+RDWA,RDWA
+FINQ,FINQ
+VRAK,VRAK
+FDEE,FDEE
+RTCP,RTCP
+LHWM,LHWM
+KDNC,KDNC
+VLVP,VLVP
+VFEW,VFEW
+QIIN,QIIN
+DSQR,DSQR
+LNDW,LNDW
+VIPR,VIPR
+HQWN,HQWN
+NLDH,NLDH
+MSHM,MSHM
+STGT,STGT
+YQYH,YQYH
+KLRI,KLRI
+MMKE,MMKE
+VRKW,VRKW
+VKYE,VKYE
+DEAH,DEAH
+PECI,PECI
+CADI,CADI
+VSAK,VSAK
+ENMS,ENMS
+PSSQ,PSSQ
+DKCQ,DKCQ
+IDCS,IDCS
+SLLK,SLLK
+DPHG,DPHG
+HMFA,HMFA
+WRHF,WRHF
+KPKS,KPKS
+NEPY,NEPY
+CMIN,CMIN
+KAYQ,KAYQ
+TTMH,TTMH
+DDVL,DDVL
+ERPG,ERPG
+KKMP,KKMP
+TENK,TENK
+LNWM,LNWM
+GHAL,GHAL
+WMKD,WMKD
+FIWK,FIWK
+SWMY,SWMY
+LYHF,LYHF
+MKYP,MKYP
+REMS,REMS
+AMFA,AMFA
+YSYT,YSYT
+EKKW,EKKW
+LRTG,LRTG
+RFMT,RFMT
+LHHW,LHHW
+KAPS,KAPS
+TFTD,TFTD
+IMSG,IMSG
+YKMQ,YKMQ
+CPPP,CPPP
+FMDA,FMDA
+YYAM,YYAM
+GTSS,GTSS
+ALYP,ALYP
+RYND,RYND
+WWFL,WWFL
+WYAT,WYAT
+CIMM,CIMM
+IVHK,IVHK
+RYSF,RYSF
+ENEA,ENEA
+WPFT,WPFT
+QVLH,QVLH
+ECFV,ECFV
+HQPP,HQPP
+SQQV,SQQV
+NRTP,NRTP
+WEEA,WEEA
+ICNQ,ICNQ
+KVDG,KVDG
+GSLK,GSLK
+CMVY,CMVY
+GNNK,GNNK
+IRQM,IRQM
+ASHG,ASHG
+PHEM,PHEM
+NNSM,NNSM
+ADRM,ADRM
+TAYW,TAYW
+FCDK,FCDK
+ETYQ,ETYQ
+MMYF,MMYF
+FLIM,FLIM
+GKFT,GKFT
+IQAK,IQAK
+GINY,GINY
+VILD,VILD
+CPLH,CPLH
+LVHQ,LVHQ
+LCKP,LCKP
+RVNH,RVNH
+HCGK,HCGK
+HCQH,HCQH
+GFKI,GFKI
+AGET,AGET
+AIHM,AIHM
+QITF,QITF
+RWFE,RWFE
+GYED,GYED
+PCSM,PCSM
+CREN,CREN
+ASAL,ASAL
+VRTV,VRTV
+AQVE,AQVE
+QFND,QFND
+FGGR,FGGR
+KEAT,KEAT
+CRVT,CRVT
+PKKG,PKKG
+PHQM,PHQM
+PAKY,PAKY
+IYSC,IYSC
+GVVM,GVVM
+IKLF,IKLF
+HHYG,HHYG
+SACL,SACL
+GQCS,GQCS
+AQIM,AQIM
+FCVN,FCVN
+HVWG,HVWG
+NADT,NADT
+MHKK,MHKK
+VWLY,VWLY
+FPCQ,FPCQ
+PEKW,PEKW
+AFYP,AFYP
+TQYY,TQYY
+VECI,VECI
+KWFQ,KWFQ
+TIEG,TIEG
+STHY,STHY
+QSAM,QSAM
+RNDD,RNDD
+EQHA,EQHA
+VCFH,VCFH
+YRWF,YRWF
+VQKH,VQKH
+CSRT,CSRT
+PRNF,PRNF
+ADIG,ADIG
+FHNV,FHNV
+NVAH,NVAH
+WYLN,WYLN
+DKWK,DKWK
+GIWI,GIWI
+MEEF,MEEF
+HCMM,HCMM
+TLIM,TLIM
+PYKV,PYKV
+YATS,YATS
+QMQW,QMQW
+KMLA,KMLA
+ALWW,ALWW
+WKHD,WKHD
+DVHP,DVHP
+EYHF,EYHF
+DLSY,DLSY
+NIRC,NIRC
+GGFI,GGFI
+RGWM,RGWM
+SWMR,SWMR
+FNQD,FNQD
+WMAY,WMAY
+ITKT,ITKT
+LIAV,LIAV
+CHTP,CHTP
+QIDD,QIDD
+PHAG,PHAG
+IDNA,IDNA
+DHSC,DHSC
+EWLA,EWLA
+FSLW,FSLW
+QEYK,QEYK
+LHHR,LHHR
+VQYS,VQYS
+VDQD,VDQD
+RGGL,RGGL
+ERTH,ERTH
+WYDD,WYDD
+EMFN,EMFN
+DKEP,DKEP
+TLCW,TLCW
+QSHE,QSHE
+IDLS,IDLS
+KKRT,KKRT
+CHQI,CHQI
+PLWC,PLWC
+VIVA,VIVA
+KDTG,KDTG
+PTVC,PTVC
+YICD,YICD
+CKRT,CKRT
+DIDP,DIDP
+DTEI,DTEI
+GIAK,GIAK
+KQLM,KQLM
+PYPN,PYPN
+LFLK,LFLK
+MRGF,MRGF
+FAMD,FAMD
+TNTS,TNTS
+MMIA,MMIA
+HPQM,HPQM
+FHEQ,FHEQ
+CHLP,CHLP
+NMFS,NMFS
+LSRR,LSRR
+CSSG,CSSG
+PYHS,PYHS
+ILDG,ILDG
+MHWD,MHWD
+QCNV,QCNV
+QILA,QILA
+QSCQ,QSCQ
+QYTN,QYTN
+WKPR,WKPR
+RTHR,RTHR
+FYMW,FYMW
+SGGN,SGGN
+CAHL,CAHL
+HNIR,HNIR
+MFKN,MFKN
+KLTN,KLTN
+CKGT,CKGT
+CNHN,CNHN
+FIVT,FIVT
+MCWG,MCWG
+TPPR,TPPR
+FLEW,FLEW
+QSHA,QSHA
+DKAD,DKAD
+DIVY,DIVY
+MKVM,MKVM
+TACP,TACP
+TWNE,TWNE
+HAYR,HAYR
+VYRY,VYRY
+PDKC,PDKC
+WTCY,WTCY
+AMWN,AMWN
+FRFY,FRFY
+IMRC,IMRC
+VNPA,VNPA
+RPDP,RPDP
+TLEF,TLEF
+DLNF,DLNF
+TCPQ,TCPQ
+VLRR,VLRR
+WKWF,WKWF
+VEHK,VEHK
+DNEA,DNEA
+DIVA,DIVA
+FNSQ,FNSQ
+QYTG,QYTG
+WPSR,WPSR
+VATT,VATT
+CMIF,CMIF
+EREH,EREH
+LGKL,LGKL
+AWQH,AWQH
+KRCC,KRCC
+MWCW,MWCW
+VCGY,VCGY
+SFFG,SFFG
+TNRR,TNRR
+LCVI,LCVI
+DLSG,DLSG
+LTIN,LTIN
+NNDW,NNDW
+QIFI,QIFI
+DAQL,DAQL
+DYRG,DYRG
+HAWD,HAWD
+TKKH,TKKH
+HVPF,HVPF
+CMSK,CMSK
+HYAK,HYAK
+CTHE,CTHE
+ACLN,ACLN
+ILRS,ILRS
+RAHP,RAHP
+TTCW,TTCW
+LIFD,LIFD
+YRPE,YRPE
+GGEA,GGEA
+LGSN,LGSN
+HETY,HETY
+HVYV,HVYV
+PRLD,PRLD
+WYCQ,WYCQ
+TMQM,TMQM
+QNRH,QNRH
+PALF,PALF
+FDHP,FDHP
+DNET,DNET
+AKLN,AKLN
+IQGF,IQGF
+IMHG,IMHG
+NGPL,NGPL
+NVCF,NVCF
+LIFN,LIFN
+WLAP,WLAP
+WCGQ,WCGQ
+SGWP,SGWP
+HGFQ,HGFQ
+GQFR,GQFR
+NQER,NQER
+GRAM,GRAM
+GASV,GASV
+VWLA,VWLA
+QMMC,QMMC
+YLMA,YLMA
+FAEL,FAEL
+KEYH,KEYH
+GDFY,GDFY
+RPQT,RPQT
+MWVK,MWVK
+GWVS,GWVS
+WNKY,WNKY
+LCRD,LCRD
+CTKF,CTKF
+VCYP,VCYP
+SQFQ,SQFQ
+YLSR,YLSR
+HESM,HESM
+MVRG,MVRG
+LFEM,LFEM
+TCLH,TCLH
+LGEL,LGEL
+WYLC,WYLC
+GQRD,GQRD
+PHGL,PHGL
+WCDN,WCDN
+MVVI,MVVI
+RHYP,RHYP
+WSMV,WSMV
+YITL,YITL
+DYHL,DYHL
+MELW,MELW
+REYD,REYD
+VREK,VREK
+NCTQ,NCTQ
+HTWQ,HTWQ
+YSHI,YSHI
+WRIN,WRIN
+QGAY,QGAY
+NTQD,NTQD
+YRLW,YRLW
+LKYP,LKYP
+HYKY,HYKY
+AYQP,AYQP
+GFCI,GFCI
+GAMQ,GAMQ
+YPSG,YPSG
+YLNI,YLNI
+LYPL,LYPL
+SYCY,SYCY
+VGVW,VGVW
+NPPW,NPPW
+NMNG,NMNG
+RMSM,RMSM
+YHGR,YHGR
+LEPK,LEPK
+FYYH,FYYH
+TGVC,TGVC
+GQWY,GQWY
+IQDK,IQDK
+HQWA,HQWA
+TTYP,TTYP
+RPIM,RPIM
+HDEW,HDEW
+EKFK,EKFK
+TMNI,TMNI
+EQLS,EQLS
+VRIY,VRIY
+RHQH,RHQH
+HKWC,HKWC
+RQDW,RQDW
+NAEN,NAEN
+QLGK,QLGK
+PYFA,PYFA
+QDPF,QDPF
+LFFR,LFFR
+FEQT,FEQT
+CRYR,CRYR
+NGVY,NGVY
+KYLC,KYLC
+GYMS,GYMS
+NWHA,NWHA
+MLWS,MLWS
+NATQ,NATQ
+WIMA,WIMA
+AIGY,AIGY
+PAEF,PAEF
+MEIK,MEIK
+AILP,AILP
+ENWC,ENWC
+SMID,SMID
+APYM,APYM
+PSCG,PSCG
+ATSP,ATSP
+FFDQ,FFDQ
+FEYQ,FEYQ
+RRLH,RRLH
+QCLR,QCLR
+CQFG,CQFG
+SLWF,SLWF
+PGFK,PGFK
+KVDL,KVDL
+INPN,INPN
+LGAH,LGAH
+YCGI,YCGI
+YKIK,YKIK
+YCPT,YCPT
+KRGW,KRGW
+YTHK,YTHK
+GIPV,GIPV
+IVYQ,IVYQ
+VYNW,VYNW
+TTDF,TTDF
+MFNM,MFNM
+PIRS,PIRS
+PMWH,PMWH
+QLLN,QLLN
+PCIN,PCIN
+VPWE,VPWE
+VFNK,VFNK
+WTTV,WTTV
+SYPT,SYPT
+RDVN,RDVN
+CHPL,CHPL
+HSYA,HSYA
+KDTH,KDTH
+LTNM,LTNM
+GQPN,GQPN
+VEWI,VEWI
+RMLT,RMLT
+ENRS,ENRS
+RSMM,RSMM
+GSCI,GSCI
+SCEE,SCEE
+PFKV,PFKV
+YFDA,YFDA
+DCLA,DCLA
+HSHA,HSHA
+MVGG,MVGG
+FVDY,FVDY
+LIYY,LIYY
+DNQR,DNQR
+DFVS,DFVS
+VMLY,VMLY
+ETIR,ETIR
+MEME,MEME
+NSRN,NSRN
+EDEM,EDEM
+MMGP,MMGP
+QIQD,QIQD
+QNTE,QNTE
+VWFP,VWFP
+KLIY,KLIY
+WHYL,WHYL
+RGWE,RGWE
+WNTL,WNTL
+WDGL,WDGL
+RCEF,RCEF
+FEFV,FEFV
+ACGA,ACGA
+WLEA,WLEA
+NHYN,NHYN
+WMEM,WMEM
+YEEQ,YEEQ
+CYGR,CYGR
+QADC,QADC
+AGVP,AGVP
+MITR,MITR
+QDPC,QDPC
+FNWP,FNWP
+EFHR,EFHR
+NNPP,NNPP
+WMVF,WMVF
+DDRT,DDRT
+ILAP,ILAP
+DSNK,DSNK
+DYMN,DYMN
+HYTA,HYTA
+YKDI,YKDI
+TKIF,TKIF
+LWIK,LWIK
+RLRP,RLRP
+EAGH,EAGH
+WFHL,WFHL
+TIET,TIET
+RDIM,RDIM
+CMIM,CMIM
+AIFA,AIFA
+YDGQ,YDGQ
+DAFK,DAFK
+CDYL,CDYL
+DRKQ,DRKQ
+EESF,EESF
+IMQT,IMQT
+CIKV,CIKV
+WPTL,WPTL
+RIAK,RIAK
+PEKT,PEKT
+HFHH,HFHH
+HAHK,HAHK
+PWLE,PWLE
+QHTV,QHTV
+AKAP,AKAP
+GMMM,GMMM
+MLCG,MLCG
+KNAF,KNAF
+TNPQ,TNPQ
+GTYH,GTYH
+WYEC,WYEC
+GCDC,GCDC
+FVMF,FVMF
+AQTR,AQTR
+SGLL,SGLL
+VCFQ,VCFQ
+FFHT,FFHT
+QIDP,QIDP
+QNLR,QNLR
+EPYF,EPYF
+KMMT,KMMT
+WFTA,WFTA
+DSQW,DSQW
+CIVI,CIVI
+RCFH,RCFH
+CKSQ,CKSQ
+KQLY,KQLY
+FVHW,FVHW
+GKKL,GKKL
+VIDG,VIDG
+FATV,FATV
+ELCT,ELCT
+LDNI,LDNI
+NQIV,NQIV
+ECMW,ECMW
+YFHS,YFHS
+YSAS,YSAS
+WAKL,WAKL
+NSWN,NSWN
+DCMT,DCMT
+HNLH,HNLH
+TTAF,TTAF
+TQLW,TQLW
+KHMK,KHMK
+NPKL,NPKL
+VSIE,VSIE
+NAFY,NAFY
+CFCQ,CFCQ
+PSSP,PSSP
+RIPA,RIPA
+EYHC,EYHC
+LEQE,LEQE
+VFEY,VFEY
+TDRE,TDRE
+PFRL,PFRL
+LARK,LARK
+ATQI,ATQI
+AMPG,AMPG
+KHTN,KHTN
+MSKR,MSKR
+AGWM,AGWM
+DPND,DPND
+GLYG,GLYG
+MKCK,MKCK
+CQQF,CQQF
+CTCG,CTCG
+AIRV,AIRV
+DADI,DADI
+MGDL,MGDL
+FKGP,FKGP
+NWLS,NWLS
+CMSN,CMSN
+EMRG,EMRG
+WMEH,WMEH
+GDDP,GDDP
+SLIC,SLIC
+INSK,INSK
+DVHY,DVHY
+YRMG,YRMG
+IDHL,IDHL
+MARL,MARL
+WVCY,WVCY
+CKEE,CKEE
+VIYW,VIYW
+IRTD,IRTD
+QQRF,QQRF
+TVAI,TVAI
+YEKT,YEKT
+LSSF,LSSF
+HAWV,HAWV
+RERS,RERS
+SNGL,SNGL
+ETEA,ETEA
+DSPN,DSPN
+SVTP,SVTP
+VEHQ,VEHQ
+LDNC,LDNC
+EQPV,EQPV
+LCPI,LCPI
+NPPR,NPPR
+HDFV,HDFV
+MKGW,MKGW
+CSFY,CSFY
+KFPH,KFPH
+CNYD,CNYD
+SDMN,SDMN
+CSDC,CSDC
+TTTM,TTTM
+HQVK,HQVK
+ALQA,ALQA
+VIGC,VIGC
+IIHI,IIHI
+IWPY,IWPY
+HLDY,HLDY
+YCIW,YCIW
+HVGA,HVGA
+WHIA,WHIA
+ARVC,ARVC
+SEFA,SEFA
+PYKS,PYKS
+QDWV,QDWV
+GLKL,GLKL
+VLEA,VLEA
+KYAT,KYAT
+GAKS,GAKS
+WVLA,WVLA
+DNTM,DNTM
+WMGV,WMGV
+HLYK,HLYK
+TYHF,TYHF
+LSHV,LSHV
+RNCE,RNCE
+KVQF,KVQF
+DAIT,DAIT
+RRML,RRML
+MTSL,MTSL
+LTKG,LTKG
+AQNA,AQNA
+CTTP,CTTP
+IRQR,IRQR
+QWCT,QWCT
+HSHL,HSHL
+QCPG,QCPG
+MERP,MERP
+IDGG,IDGG
+CTDI,CTDI
+WTVK,WTVK
+AADY,AADY
+CEGA,CEGA
+ETAA,ETAA
+AHNR,AHNR
+WESS,WESS
+TWDE,TWDE
+QLPT,QLPT
+FAAF,FAAF
+TINK,TINK
+QESG,QESG
+DRNW,DRNW
+YTWY,YTWY
+TTCN,TTCN
+VTFP,VTFP
+PHRP,PHRP
+RFEI,RFEI
+PKEP,PKEP
+QSCW,QSCW
+VGYK,VGYK
+PPYM,PPYM
+GCDE,GCDE
+DGIS,DGIS
+HCWC,HCWC
+WPIR,WPIR
+KKMF,KKMF
+VVVV,VVVV
+GGMT,GGMT
+YKNA,YKNA
+ELAE,ELAE
+HYVR,HYVR
+IIEG,IIEG
+LETR,LETR
+TRKK,TRKK
+KTWK,KTWK
+CQHA,CQHA
+PCLP,PCLP
+WYVP,WYVP
+FYGW,FYGW
+IRPY,IRPY
+SFEP,SFEP
+DEAC,DEAC
+MHIA,MHIA
+FWPH,FWPH
+YRMQ,YRMQ
+ESAM,ESAM
+WSWY,WSWY
+MCIH,MCIH
+FNDC,FNDC
+EHFF,EHFF
+TYAH,TYAH
+SHSR,SHSR
+YNMS,YNMS
+TNCG,TNCG
+ECIF,ECIF
+HVFL,HVFL
+WYEA,WYEA
+SKEP,SKEP
+LRAR,LRAR
+PPFG,PPFG
+TGNE,TGNE
+WPHP,WPHP
+CETQ,CETQ
+QRMY,QRMY
+VPLQ,VPLQ
+ADVE,ADVE
+HGEE,HGEE
+VRGP,VRGP
+VTPT,VTPT
+ARRF,ARRF
+HMLH,HMLH
+RDWT,RDWT
+PGVH,PGVH
+DKEY,DKEY
+PLPI,PLPI
+SLHD,SLHD
+WQVK,WQVK
+PWSS,PWSS
+REHK,REHK
+NSNA,NSNA
+KNCF,KNCF
+EWPH,EWPH
+MPQG,MPQG
+DTEL,DTEL
+RASG,RASG
+CGHG,CGHG
+DCYT,DCYT
+YKCT,YKCT
+DPPQ,DPPQ
+QPIS,QPIS
+ADYS,ADYS
+GNMV,GNMV
+FAAI,FAAI
+DMQN,DMQN
+IAEL,IAEL
+TEER,TEER
+DFAR,DFAR
+DPHQ,DPHQ
+PWAD,PWAD
+PLWM,PLWM
+KCHD,KCHD
+MLEA,MLEA
+MSEK,MSEK
+DWMK,DWMK
+FNNT,FNNT
+YVCG,YVCG
+NQHS,NQHS
+IIAA,IIAA
+PVVK,PVVK
+LCPV,LCPV
+QSWE,QSWE
+IQCY,IQCY
+EAKQ,EAKQ
+CMFT,CMFT
+THWG,THWG
+IKKE,IKKE
+KLPK,KLPK
+VGHM,VGHM
+TPEL,TPEL
+RIRP,RIRP
+ITGT,ITGT
+WDRP,WDRP
+WHKT,WHKT
+SMCP,SMCP
+NYKW,NYKW
+HAAP,HAAP
+PRWL,PRWL
+YPKV,YPKV
+SHDF,SHDF
+TFKT,TFKT
+RCPL,RCPL
+ECWN,ECWN
+CPFA,CPFA
+PRNI,PRNI
+NYAG,NYAG
+RVDV,RVDV
+KQGV,KQGV
+RDKH,RDKH
+AMYF,AMYF
+IMDL,IMDL
+STAM,STAM
+GWFT,GWFT
+SFNT,SFNT
+IFGV,IFGV
+EMMI,EMMI
+GDLP,GDLP
+IDFE,IDFE
+PQFR,PQFR
+NTPP,NTPP
+CLWD,CLWD
+NHYA,NHYA
+ICMS,ICMS
+HLHC,HLHC
+KNDI,KNDI
+AWPE,AWPE
+PPCN,PPCN
+WHLQ,WHLQ
+AFMV,AFMV
+VSFD,VSFD
+WLNR,WLNR
+AMID,AMID
+HTGE,HTGE
+MPCW,MPCW
+TRTF,TRTF
+WRMV,WRMV
+ILIE,ILIE
+GPKK,GPKK
+SLQG,SLQG
+FPVY,FPVY
+WCLI,WCLI
+MYCE,MYCE
+GEQN,GEQN
+MFME,MFME
+KNKE,KNKE
+HHLF,HHLF
+VDQP,VDQP
+YGVK,YGVK
+CTLR,CTLR
+HGYN,HGYN
+VSEW,VSEW
+QPYQ,QPYQ
+QPNY,QPNY
+HDSR,HDSR
+HFTC,HFTC
+MYHV,MYHV
+LWNQ,LWNQ
+PAMN,PAMN
+PLPW,PLPW
+PMTV,PMTV
+YTDQ,YTDQ
+FCER,FCER
+QNNH,QNNH
+SFDF,SFDF
+RHQL,RHQL
+DLHE,DLHE
+KWKH,KWKH
+MQRH,MQRH
+NWET,NWET
+QVCV,QVCV
+EPEP,EPEP
+VRSE,VRSE
+ERMM,ERMM
+TVRI,TVRI
+GCMG,GCMG
+MAWA,MAWA
+DGLA,DGLA
+LPCQ,LPCQ
+THDF,THDF
+TWYH,TWYH
+IDAT,IDAT
+SFSE,SFSE
+WCHR,WCHR
+NNTH,NNTH
+QPHC,QPHC
+EERR,EERR
+EVIQ,EVIQ
+LRWA,LRWA
+LHIE,LHIE
+DATT,DATT
+ESDH,ESDH
+TRHH,TRHH
+HMGV,HMGV
+HNVN,HNVN
+MTLK,MTLK
+KGSQ,KGSQ
+GSGW,GSGW
+VPTP,VPTP
+RIGG,RIGG
+GVQR,GVQR
+ANVM,ANVM
+TQHM,TQHM
+CDGP,CDGP
+EIQR,EIQR
+SPTN,SPTN
+QWNF,QWNF
+TFFT,TFFT
+VENC,VENC
+LRKC,LRKC
+AQML,AQML
+ASGA,ASGA
+VHYM,VHYM
+QGRK,QGRK
+TGCF,TGCF
+KVLK,KVLK
+MCIN,MCIN
+APTA,APTA
+LCNK,LCNK
+CYLF,CYLF
+FCYN,FCYN
+ALGE,ALGE
+QDQP,QDQP
+VVFN,VVFN
+LLSQ,LLSQ
+GEYW,GEYW
+PFGI,PFGI
+MLQM,MLQM
+FRDP,FRDP
+EKST,EKST
+GSER,GSER
+HGPT,HGPT
+LQGA,LQGA
+VVDT,VVDT
+IGFS,IGFS
+ENWL,ENWL
+SCCA,SCCA
+WSNI,WSNI
+ALCI,ALCI
+DWFH,DWFH
+GNDD,GNDD
+NQWQ,NQWQ
+KLHW,KLHW
+WNNG,WNNG
+EETS,EETS
+HKKD,HKKD
+YCIK,YCIK
+YWKM,YWKM
+MSLT,MSLT
+HPMN,HPMN
+GRGT,GRGT
+GRNN,GRNN
+HINF,HINF
+HDIF,HDIF
+AKKT,AKKT
+HVVK,HVVK
+RTEH,RTEH
+QDKN,QDKN
+VLVT,VLVT
+VLIY,VLIY
+PVWT,PVWT
+NHTY,NHTY
+EYRT,EYRT
+ANAD,ANAD
+KAQH,KAQH
+VWCN,VWCN
+EDHN,EDHN
+DNMP,DNMP
+PIEA,PIEA
+TNIF,TNIF
+RHLM,RHLM
+FFWS,FFWS
+SFVF,SFVF
+IDEG,IDEG
+SRIK,SRIK
+WVGG,WVGG
+ICKQ,ICKQ
+HVKL,HVKL
+YNER,YNER
+IFNM,IFNM
+MCTR,MCTR
+KEKK,KEKK
+SVDK,SVDK
+IAYK,IAYK
+LPNI,LPNI
+DRWH,DRWH
+STAC,STAC
+CIQV,CIQV
+ASVA,ASVA
+EVQC,EVQC
+TLMM,TLMM
+YERP,YERP
+GNII,GNII
+HCGN,HCGN
+RECT,RECT
+HLKG,HLKG
+TRRA,TRRA
+RGES,RGES
+KKDA,KKDA
+EMFY,EMFY
+ARCE,ARCE
+VLTK,VLTK
+AMHN,AMHN
+LMQD,LMQD
+EHGH,EHGH
+QGSV,QGSV
+NCWW,NCWW
+RVSR,RVSR
+IWRS,IWRS
+EWMI,EWMI
+VFSE,VFSE
+IRLS,IRLS
+APFF,APFF
+YSWV,YSWV
+ANAL,ANAL
+VLPA,VLPA
+HTDS,HTDS
+GYKE,GYKE
+YVDL,YVDL
+MVLY,MVLY
+ITVP,ITVP
+GIHK,GIHK
+QSIW,QSIW
+ALGT,ALGT
+NVTI,NVTI
+GWVW,GWVW
+LGYN,LGYN
+YTCT,YTCT
+QWAC,QWAC
+AAMR,AAMR
+DRAT,DRAT
+CTCA,CTCA
+GYAS,GYAS
+FELH,FELH
+ATPA,ATPA
+DLMR,DLMR
+FYAH,FYAH
+WTNK,WTNK
+QHFT,QHFT
+NCCW,NCCW
+DLFE,DLFE
+LVLF,LVLF
+FASE,FASE
+ALQT,ALQT
+DINN,DINN
+WALA,WALA
+CGGS,CGGS
+GCSA,GCSA
+FCNY,FCNY
+DYTD,DYTD
+SKMQ,SKMQ
+FNDV,FNDV
+VTAA,VTAA
+LHEA,LHEA
+LFVW,LFVW
+ENHL,ENHL
+EGCY,EGCY
+HKGD,HKGD
+NACC,NACC
+HADF,HADF
+TSNK,TSNK
+ALHP,ALHP
+MAHN,MAHN
+EPEG,EPEG
+TQRA,TQRA
+QDVC,QDVC
+YEPQ,YEPQ
+WVNR,WVNR
+CVQA,CVQA
+AVVV,AVVV
+RCSP,RCSP
+FADC,FADC
+TVQA,TVQA
+VCSS,VCSS
+HNMT,HNMT
+FDNL,FDNL
+IKKQ,IKKQ
+NCEQ,NCEQ
+MVHE,MVHE
+LPIE,LPIE
+FNLH,FNLH
+VPLC,VPLC
+AGPK,AGPK
+AQIP,AQIP
+SLSE,SLSE
+SEVS,SEVS
+DLSC,DLSC
+HETF,HETF
+GQRM,GQRM
+YCEW,YCEW
+GYNC,GYNC
+CGEV,CGEV
+TNGY,TNGY
+PQEV,PQEV
+PMSP,PMSP
+EYLP,EYLP
+LHSK,LHSK
+ILRP,ILRP
+RMFL,RMFL
+CNAL,CNAL
+IHQM,IHQM
+QGES,QGES
+DHCH,DHCH
+CMPD,CMPD
+LSVQ,LSVQ
+WVPV,WVPV
+AQKR,AQKR
+EAKS,EAKS
+DDTA,DDTA
+HVLL,HVLL
+RHTK,RHTK
+AGAH,AGAH
+PTGS,PTGS
+VHDH,VHDH
+WCII,WCII
+QMGP,QMGP
+HWWY,HWWY
+KVGE,KVGE
+SPPD,SPPD
+AYLI,AYLI
+TWFS,TWFS
+TTKT,TTKT
+QHHN,QHHN
+IQYY,IQYY
+AWFM,AWFM
+ADKN,ADKN
+SEIG,SEIG
+SIRK,SIRK
+CQCG,CQCG
+NLWQ,NLWQ
+MKCR,MKCR
+NHYC,NHYC
+DMAF,DMAF
+EPMC,EPMC
+LNCI,LNCI
+NDPK,NDPK
+SVAH,SVAH
+YADM,YADM
+ANDQ,ANDQ
+QMNV,QMNV
+PWMR,PWMR
+VMHY,VMHY
+PRRP,PRRP
+DTTC,DTTC
+KGMG,KGMG
+NIFD,NIFD
+CDFS,CDFS
+CCKT,CCKT
+QLDC,QLDC
+HQKW,HQKW
+NTWH,NTWH
+PRFI,PRFI
+YARD,YARD
+PSED,PSED
+HGFP,HGFP
+RTAE,RTAE
+HGQD,HGQD
+ILLY,ILLY
+QQDC,QQDC
+IVGF,IVGF
+VTFE,VTFE
+RCTH,RCTH
+VAQC,VAQC
+WHFK,WHFK
+YWGT,YWGT
+PIPL,PIPL
+HDFY,HDFY
+HHML,HHML
+GWSG,GWSG
+SRSV,SRSV
+IWDV,IWDV
+HEIK,HEIK
+YMYA,YMYA
+LVEW,LVEW
+VERV,VERV
+KATH,KATH
+TVIN,TVIN
+EWNL,EWNL
+HNYH,HNYH
+ILRQ,ILRQ
+ATHA,ATHA
+SEVP,SEVP
+VWNV,VWNV
+TKCT,TKCT
+RYYV,RYYV
+KAKV,KAKV
+SSAY,SSAY
+LMCM,LMCM
+VVHK,VVHK
+QLVQ,QLVQ
+VNGR,VNGR
+SCVI,SCVI
+VTVG,VTVG
+HGRK,HGRK
+MEDV,MEDV
+ALRI,ALRI
+PKHD,PKHD
+QLRC,QLRC
+DHIG,DHIG
+CYWH,CYWH
+WMAL,WMAL
+YGAM,YGAM
+VGSD,VGSD
+EFYI,EFYI
+CSNS,CSNS
+EYTI,EYTI
+NDYM,NDYM
+PWST,PWST
+TCPY,TCPY
+HCDA,HCDA
+SLDY,SLDY
+VWLV,VWLV
+FEKA,FEKA
+IWPI,IWPI
+QKRM,QKRM
+FCDH,FCDH
+YYHN,YYHN
+NSMQ,NSMQ
+LVME,LVME
+HCDD,HCDD
+NAGS,NAGS
+MSVP,MSVP
+DNQC,DNQC
+LFCG,LFCG
+VTTD,VTTD
+SCKL,SCKL
+RSSI,RSSI
+RMCP,RMCP
+MTQM,MTQM
+LGRY,LGRY
+KPWM,KPWM
+RGPN,RGPN
+ERWD,ERWD
+IDRY,IDRY
+LPML,LPML
+PDAR,PDAR
+HISK,HISK
+TPCR,TPCR
+MDDL,MDDL
+GWMD,GWMD
+CVTS,CVTS
+LAID,LAID
+TVKF,TVKF
+MNVC,MNVC
+IAQE,IAQE
+IMHA,IMHA
+WHSL,WHSL
+KKGF,KKGF
+KCPR,KCPR
+THWR,THWR
+FQYV,FQYV
+IRTS,IRTS
+KVRG,KVRG
+ESEE,ESEE
+TWLW,TWLW
+DYNK,DYNK
+SKTQ,SKTQ
+IGAA,IGAA
+EQMR,EQMR
+GYVS,GYVS
+IMCH,IMCH
+GFNF,GFNF
+EIVW,EIVW
+PKFS,PKFS
+IQIT,IQIT
+VGYP,VGYP
+KVPL,KVPL
+EKTV,EKTV
+DSLP,DSLP
+SIHA,SIHA
+EPPK,EPPK
+MFHP,MFHP
+LCKA,LCKA
+VRAN,VRAN
+WDPV,WDPV
+GMAM,GMAM
+NPGM,NPGM
+VHNH,VHNH
+WCNN,WCNN
+ADNF,ADNF
+AGSC,AGSC
+VALE,VALE
+AIGG,AIGG
+PWVL,PWVL
+GGMN,GGMN
+VDWA,VDWA
+WYGE,WYGE
+PRMT,PRMT
+APAM,APAM
+DYDA,DYDA
+GHSG,GHSG
+YIPM,YIPM
+ITEM,ITEM
+YTAK,YTAK
+RVWA,RVWA
+AQPS,AQPS
+YAYN,YAYN
+WGWC,WGWC
+MTGS,MTGS
+ELVR,ELVR
+QGED,QGED
+LFPD,LFPD
+YHGA,YHGA
+PKIN,PKIN
+QKRC,QKRC
+KTRW,KTRW
+PVQD,PVQD
+NYSP,NYSP
+DDWI,DDWI
+GKAA,GKAA
+FHAQ,FHAQ
+HFVT,HFVT
+KWLY,KWLY
+VRQC,VRQC
+TWER,TWER
+AMEF,AMEF
+HIWR,HIWR
+VDEC,VDEC
+FLDR,FLDR
+MNTM,MNTM
+SKNF,SKNF
+IKER,IKER
+NLMT,NLMT
+QFMC,QFMC
+KGSE,KGSE
+HPNT,HPNT
+EYYH,EYYH
+FAPR,FAPR
+VSDL,VSDL
+DYME,DYME
+EGKV,EGKV
+SNGF,SNGF
+QKPM,QKPM
+FKST,FKST
+EMPY,EMPY
+TMCF,TMCF
+FMDK,FMDK
+VPYD,VPYD
+PRRN,PRRN
+WGPV,WGPV
+MGPI,MGPI
+KHDQ,KHDQ
+YCSM,YCSM
+MLAE,MLAE
+CVEK,CVEK
+MQAV,MQAV
+WGCR,WGCR
+RRVY,RRVY
+GINC,GINC
+QTSD,QTSD
+RDLK,RDLK
+IQTT,IQTT
+KQDD,KQDD
+FNYW,FNYW
+CHHY,CHHY
+YVCR,YVCR
+RTKF,RTKF
+MGEQ,MGEQ
+CCRV,CCRV
+SMQE,SMQE
+DCNY,DCNY
+DWKQ,DWKQ
+IVFT,IVFT
+PCHQ,PCHQ
+SPSR,SPSR
+FFTN,FFTN
+WVDV,WVDV
+MWRQ,MWRQ
+CEDC,CEDC
+NWGD,NWGD
+GGHG,GGHG
+SMRW,SMRW
+WNEF,WNEF
+GMRD,GMRD
+WCTM,WCTM
+VLGF,VLGF
+VYHK,VYHK
+LKSQ,LKSQ
+MEDW,MEDW
+DNGG,DNGG
+DGIK,DGIK
+VKEP,VKEP
+DPWG,DPWG
+RRET,RRET
+LDMR,LDMR
+WFND,WFND
+SKDS,SKDS
+ERIL,ERIL
+IKIM,IKIM
+ITRE,ITRE
+DMNE,DMNE
+FACL,FACL
+ACDG,ACDG
+SNPI,SNPI
+QHSM,QHSM
+PSGD,PSGD
+IPLY,IPLY
+TSVR,TSVR
+FSAF,FSAF
+IQKY,IQKY
+NFST,NFST
+WVGW,WVGW

data/splits/4AA_implicit.csv

@@ -0,0 +1,2847 @@
+name,seqres
+EHFR,EHFR
+YVTL,YVTL
+GQGV,GQGV
+PCFK,PCFK
+VVIV,VVIV
+WGDY,WGDY
+SLYW,SLYW
+QGRE,QGRE
+SRPT,SRPT
+NGDS,NGDS
+VNWW,VNWW
+LDNH,LDNH
+WLSC,WLSC
+YYTK,YYTK
+GPNT,GPNT
+LTQE,LTQE
+VMHV,VMHV
+GTLM,GTLM
+QRRW,QRRW
+LRYM,LRYM
+WTWS,WTWS
+VKFG,VKFG
+GQYP,GQYP
+KWIC,KWIC
+PQHG,PQHG
+FLIS,FLIS
+QEGR,QEGR
+ISML,ISML
+HRCS,HRCS
+NNKC,NNKC
+FART,FART
+TIDH,TIDH
+RDTI,RDTI
+ICLP,ICLP
+AMEN,AMEN
+QHFV,QHFV
+GHSS,GHSS
+YNML,YNML
+RHDG,RHDG
+VMVL,VMVL
+QNCG,QNCG
+FRPQ,FRPQ
+FVFN,FVFN
+FCND,FCND
+CETY,CETY
+GYQH,GYQH
+FLRH,FLRH
+IMRY,IMRY
+PIDV,PIDV
+HTIQ,HTIQ
+KDFM,KDFM
+ESSS,ESSS
+ASRE,ASRE
+LCLQ,LCLQ
+IVMA,IVMA
+RVQQ,RVQQ
+KDDD,KDDD
+VQCL,VQCL
+CSYR,CSYR
+SPVN,SPVN
+MIAY,MIAY
+SNSF,SNSF
+TLRK,TLRK
+IAMI,IAMI
+CPYV,CPYV
+NWWG,NWWG
+LQMG,LQMG
+DLCG,DLCG
+LVVF,LVVF
+LWMR,LWMR
+NNDK,NNDK
+EDQK,EDQK
+CACS,CACS
+IWHF,IWHF
+IPTH,IPTH
+VDRN,VDRN
+HELI,HELI
+GGHN,GGHN
+FSDP,FSDP
+CKVH,CKVH
+NTVG,NTVG
+SPFH,SPFH
+FSRK,FSRK
+PYHQ,PYHQ
+FDNT,FDNT
+PKDM,PKDM
+LIFE,LIFE
+ALDA,ALDA
+PGKM,PGKM
+QRNF,QRNF
+SSNN,SSNN
+FKKL,FKKL
+RLKR,RLKR
+KSIY,KSIY
+NFQF,NFQF
+MAFM,MAFM
+AASF,AASF
+CFEE,CFEE
+DHAR,DHAR
+IDRH,IDRH
+KSVT,KSVT
+SMSN,SMSN
+AAYQ,AAYQ
+FYVR,FYVR
+TFKF,TFKF
+GMMY,GMMY
+RGQL,RGQL
+NYER,NYER
+WKWY,WKWY
+EDTS,EDTS
+PEGV,PEGV
+NNPT,NNPT
+DENA,DENA
+YEPH,YEPH
+IYGF,IYGF
+FRID,FRID
+MRVV,MRVV
+IVFN,IVFN
+LPGP,LPGP
+MGNM,MGNM
+TFWF,TFWF
+LFHI,LFHI
+HYGW,HYGW
+FLDY,FLDY
+QYTM,QYTM
+YMSS,YMSS
+FHWL,FHWL
+HFFG,HFFG
+LKSL,LKSL
+HYAN,HYAN
+PEYE,PEYE
+EVFQ,EVFQ
+FSQR,FSQR
+ETIT,ETIT
+CNNF,CNNF
+MKPK,MKPK
+GMLH,GMLH
+SCQK,SCQK
+WQCY,WQCY
+FIRG,FIRG
+THIC,THIC
+KQRT,KQRT
+QYRQ,QYRQ
+WDWF,WDWF
+QADM,QADM
+GVVY,GVVY
+MWGY,MWGY
+SLHS,SLHS
+PTHA,PTHA
+PTRW,PTRW
+ADSC,ADSC
+QVLA,QVLA
+KSLG,KSLG
+PGNE,PGNE
+IPRW,IPRW
+HTSM,HTSM
+VDEF,VDEF
+VVKC,VVKC
+KTLL,KTLL
+KIED,KIED
+ANFS,ANFS
+DKYV,DKYV
+DQPA,DQPA
+HWLK,HWLK
+TDPL,TDPL
+QCQW,QCQW
+PCPL,PCPL
+MLPR,MLPR
+NDNV,NDNV
+LTPR,LTPR
+YRVC,YRVC
+RFLT,RFLT
+SEAH,SEAH
+VHHC,VHHC
+SMAS,SMAS
+NQEF,NQEF
+DEPV,DEPV
+THHL,THHL
+VVLI,VVLI
+AGVI,AGVI
+STYP,STYP
+LKLW,LKLW
+SFQK,SFQK
+SNID,SNID
+KGCR,KGCR
+FDNC,FDNC
+RCKP,RCKP
+MYYA,MYYA
+DTCD,DTCD
+LQLG,LQLG
+LNWY,LNWY
+MIQK,MIQK
+WDDK,WDDK
+YNKT,YNKT
+TKAK,TKAK
+VRNG,VRNG
+KTTF,KTTF
+IAIM,IAIM
+FGGV,FGGV
+SHPE,SHPE
+EKME,EKME
+YSCA,YSCA
+TGPT,TGPT
+AAKQ,AAKQ
+LQRL,LQRL
+TTLY,TTLY
+VSFH,VSFH
+WYNA,WYNA
+EPWP,EPWP
+DNCQ,DNCQ
+FLHM,FLHM
+WYIG,WYIG
+CQYS,CQYS
+SNCV,SNCV
+DIGN,DIGN
+NYQM,NYQM
+QASA,QASA
+FFRN,FFRN
+WKSH,WKSH
+HEGV,HEGV
+VFWY,VFWY
+QNFH,QNFH
+ISFP,ISFP
+ARGH,ARGH
+CRMN,CRMN
+QNMV,QNMV
+IKQG,IKQG
+PMMV,PMMV
+HILY,HILY
+AQFQ,AQFQ
+MHGM,MHGM
+WMFD,WMFD
+NWPN,NWPN
+HPNK,HPNK
+LRTE,LRTE
+AEAF,AEAF
+FHLQ,FHLQ
+PIAC,PIAC
+KDKI,KDKI
+MKCC,MKCC
+NAWY,NAWY
+YVLE,YVLE
+QKYR,QKYR
+TFIL,TFIL
+DVGL,DVGL
+VNAK,VNAK
+CEIA,CEIA
+CLHA,CLHA
+TPEA,TPEA
+EEKV,EEKV
+GTEV,GTEV
+PYYT,PYYT
+AMQN,AMQN
+KDYC,KDYC
+QNIE,QNIE
+MWLR,MWLR
+AELN,AELN
+TDNF,TDNF
+YPDQ,YPDQ
+PMWQ,PMWQ
+WTIN,WTIN
+TQLE,TQLE
+CWWT,CWWT
+PFGR,PFGR
+KWMG,KWMG
+ICDY,ICDY
+IFWQ,IFWQ
+VGNK,VGNK
+EGSR,EGSR
+KSKE,KSKE
+AQYS,AQYS
+ECDG,ECDG
+AFRN,AFRN
+NLSK,NLSK
+IIDS,IIDS
+MFSG,MFSG
+IING,IING
+IHGP,IHGP
+PEFC,PEFC
+LPRM,LPRM
+VWGW,VWGW
+RAKD,RAKD
+TDRL,TDRL
+PWRH,PWRH
+THKW,THKW
+AQMK,AQMK
+SNYD,SNYD
+KVFQ,KVFQ
+SWML,SWML
+NMHN,NMHN
+VNRT,VNRT
+QHTR,QHTR
+RTHG,RTHG
+MKIF,MKIF
+WAWT,WAWT
+TFIS,TFIS
+AIWE,AIWE
+MINS,MINS
+KNFC,KNFC
+YSME,YSME
+LKTH,LKTH
+PGHR,PGHR
+QCWM,QCWM
+YYFW,YYFW
+GCQH,GCQH
+LFGA,LFGA
+LREV,LREV
+CGCQ,CGCQ
+GQFY,GQFY
+DGDL,DGDL
+IISC,IISC
+GLTR,GLTR
+RGVQ,RGVQ
+DFWH,DFWH
+GFKP,GFKP
+TTNE,TTNE
+FEDH,FEDH
+YTAV,YTAV
+AMVW,AMVW
+NECR,NECR
+PNYQ,PNYQ
+WVLQ,WVLQ
+NPGA,NPGA
+LTYP,LTYP
+GTTS,GTTS
+CPKM,CPKM
+FFIR,FFIR
+KTGN,KTGN
+RGSY,RGSY
+NKNQ,NKNQ
+CWYK,CWYK
+SSRN,SSRN
+KNGD,KNGD
+PECK,PECK
+NRKC,NRKC
+HTAN,HTAN
+KWPM,KWPM
+PDKM,PDKM
+WYVV,WYVV
+GCPK,GCPK
+DRKK,DRKK
+WNWC,WNWC
+PAYK,PAYK
+QKEE,QKEE
+LYGF,LYGF
+GRAR,GRAR
+HFLW,HFLW
+FHSL,FHSL
+HERQ,HERQ
+TMMP,TMMP
+PEMT,PEMT
+LSGH,LSGH
+MPNS,MPNS
+KKYS,KKYS
+WDCD,WDCD
+RSDW,RSDW
+QPAL,QPAL
+EYPW,EYPW
+CFRY,CFRY
+QETE,QETE
+GWDT,GWDT
+HDRQ,HDRQ
+RTNL,RTNL
+IMVW,IMVW
+VKEQ,VKEQ
+HEAH,HEAH
+DEMY,DEMY
+WNLY,WNLY
+SPHG,SPHG
+FQYW,FQYW
+VSDD,VSDD
+SDAK,SDAK
+HLDH,HLDH
+GGMD,GGMD
+PFRW,PFRW
+NMLG,NMLG
+NWSN,NWSN
+TRGN,TRGN
+QICA,QICA
+DHNR,DHNR
+CDKL,CDKL
+ADPG,ADPG
+DHFW,DHFW
+WSSW,WSSW
+ITNH,ITNH
+CACL,CACL
+HFDQ,HFDQ
+FIQA,FIQA
+NQQC,NQQC
+ALCP,ALCP
+GPCV,GPCV
+DFWV,DFWV
+PHPC,PHPC
+AVSM,AVSM
+TSPC,TSPC
+MWLF,MWLF
+HKQL,HKQL
+SAHD,SAHD
+YNQP,YNQP
+PQYL,PQYL
+SHSC,SHSC
+FNCR,FNCR
+DHHE,DHHE
+MIIM,MIIM
+RYPG,RYPG
+PMFI,PMFI
+TIRG,TIRG
+WHEL,WHEL
+ALWP,ALWP
+CMKC,CMKC
+ESTM,ESTM
+EMIR,EMIR
+WKEG,WKEG
+NKPS,NKPS
+FCDI,FCDI
+PAYR,PAYR
+NTGH,NTGH
+GREQ,GREQ
+RHIQ,RHIQ
+KKYC,KKYC
+YSST,YSST
+MNWM,MNWM
+DNTG,DNTG
+NPIF,NPIF
+YLYA,YLYA
+AISE,AISE
+SAAR,SAAR
+WQRL,WQRL
+KIWI,KIWI
+YMKK,YMKK
+IWQA,IWQA
+TLRF,TLRF
+WVNW,WVNW
+QKIH,QKIH
+ENNT,ENNT
+CQAA,CQAA
+RMNL,RMNL
+DCMQ,DCMQ
+GCAE,GCAE
+IYCC,IYCC
+HYGI,HYGI
+LNMQ,LNMQ
+IGNE,IGNE
+CRNA,CRNA
+EWIH,EWIH
+VSRP,VSRP
+RWPF,RWPF
+ADSL,ADSL
+ARRH,ARRH
+GSTY,GSTY
+SITI,SITI
+IVKV,IVKV
+HTPP,HTPP
+QHKL,QHKL
+LDNT,LDNT
+KCWA,KCWA
+KDKA,KDKA
+DMII,DMII
+YDMP,YDMP
+KDNF,KDNF
+RGQA,RGQA
+QSIS,QSIS
+NMSV,NMSV
+METL,METL
+VYAY,VYAY
+VYCP,VYCP
+FIVM,FIVM
+CTRV,CTRV
+FPDC,FPDC
+GSKT,GSKT
+CGFR,CGFR
+TRSH,TRSH
+VSAC,VSAC
+WMEV,WMEV
+SKYM,SKYM
+IEMQ,IEMQ
+KTSE,KTSE
+HFIG,HFIG
+PRTR,PRTR
+WNGE,WNGE
+DFVP,DFVP
+KHDF,KHDF
+WELM,WELM
+KPRK,KPRK
+SLGK,SLGK
+MWKN,MWKN
+NTDY,NTDY
+NKIP,NKIP
+GCQW,GCQW
+CGNR,CGNR
+MDCH,MDCH
+FYEH,FYEH
+NENL,NENL
+TSMR,TSMR
+ETVQ,ETVQ
+NLYD,NLYD
+QSLR,QSLR
+CCNM,CCNM
+TIKC,TIKC
+RPFF,RPFF
+SIVL,SIVL
+ADRN,ADRN
+RVSH,RVSH
+VPTF,VPTF
+IYTM,IYTM
+ENRG,ENRG
+PIRF,PIRF
+SGHT,SGHT
+KFMW,KFMW
+VNVE,VNVE
+DHQD,DHQD
+RKQI,RKQI
+PPFQ,PPFQ
+CYAI,CYAI
+VEGM,VEGM
+PVKV,PVKV
+CGEF,CGEF
+EFET,EFET
+LHGV,LHGV
+CQNM,CQNM
+HHPD,HHPD
+GIDF,GIDF
+DVSH,DVSH
+EQNY,EQNY
+YWVP,YWVP
+SREV,SREV
+CFVK,CFVK
+CSCE,CSCE
+KQFR,KQFR
+GFMM,GFMM
+SDGG,SDGG
+PTVI,PTVI
+KVCK,KVCK
+GDQE,GDQE
+GVNQ,GVNQ
+EHHR,EHHR
+ESYE,ESYE
+MKLK,MKLK
+CKWA,CKWA
+IWGS,IWGS
+RHTY,RHTY
+EHGF,EHGF
+VGFI,VGFI
+YMQM,YMQM
+IQDC,IQDC
+TMFP,TMFP
+YLLA,YLLA
+FNGV,FNGV
+CQWN,CQWN
+IIFC,IIFC
+CYFW,CYFW
+NDCR,NDCR
+WCLH,WCLH
+ICRV,ICRV
+LFVP,LFVP
+MVGK,MVGK
+PDMV,PDMV
+FQWF,FQWF
+LICH,LICH
+WRPF,WRPF
+VEDP,VEDP
+MFAC,MFAC
+WWNS,WWNS
+CGMH,CGMH
+NTVT,NTVT
+YMLC,YMLC
+VTIH,VTIH
+MWML,MWML
+IHIF,IHIF
+RSVW,RSVW
+KFCC,KFCC
+IYSG,IYSG
+IVVS,IVVS
+FWYD,FWYD
+LMVK,LMVK
+LFAS,LFAS
+SVHG,SVHG
+GVDR,GVDR
+VIHW,VIHW
+GNQY,GNQY
+MMVT,MMVT
+DYPH,DYPH
+WHYA,WHYA
+FAIF,FAIF
+MNLG,MNLG
+SSLA,SSLA
+KATL,KATL
+RYCC,RYCC
+HKCL,HKCL
+LDTN,LDTN
+MFIG,MFIG
+HPVY,HPVY
+GPTW,GPTW
+LVMI,LVMI
+KLPT,KLPT
+RLNQ,RLNQ
+IKKN,IKKN
+AQKT,AQKT
+LCEE,LCEE
+FQCR,FQCR
+QSEW,QSEW
+VVWW,VVWW
+TSND,TSND
+SYQF,SYQF
+ATLM,ATLM
+WENR,WENR
+KTVS,KTVS
+GKTK,GKTK
+FFVR,FFVR
+CEEV,CEEV
+MACL,MACL
+MWWT,MWWT
+ICGH,ICGH
+IDQT,IDQT
+QGCS,QGCS
+IVIL,IVIL
+NTKN,NTKN
+DLPK,DLPK
+FRMH,FRMH
+LEWF,LEWF
+RFID,RFID
+PLYY,PLYY
+HIIP,HIIP
+CWMM,CWMM
+HIQQ,HIQQ
+ILEE,ILEE
+YNNA,YNNA
+FRFM,FRFM
+RWTW,RWTW
+NSQL,NSQL
+NMKK,NMKK
+LTSA,LTSA
+ARTD,ARTD
+WCYH,WCYH
+CMWP,CMWP
+PHCS,PHCS
+SPLN,SPLN
+APDW,APDW
+KEGM,KEGM
+SYEV,SYEV
+YCPI,YCPI
+TRVA,TRVA
+RAMI,RAMI
+DLEF,DLEF
+QCTI,QCTI
+YEPV,YEPV
+CWAK,CWAK
+DPDD,DPDD
+TTCK,TTCK
+NESI,NESI
+DGVF,DGVF
+DVYL,DVYL
+NHPH,NHPH
+KRKQ,KRKQ
+FEFA,FEFA
+LDAC,LDAC
+YSQT,YSQT
+TYFF,TYFF
+ALVN,ALVN
+VMVQ,VMVQ
+LVVR,LVVR
+RSWY,RSWY
+QHKQ,QHKQ
+LHEP,LHEP
+ARSK,ARSK
+FPVM,FPVM
+MHVD,MHVD
+RMQL,RMQL
+FDEA,FDEA
+YSIF,YSIF
+MEWG,MEWG
+QIII,QIII
+LIAY,LIAY
+LSPG,LSPG
+LSFH,LSFH
+VWAT,VWAT
+WMKT,WMKT
+SEWR,SEWR
+VAMH,VAMH
+CVGQ,CVGQ
+DAAY,DAAY
+CHYS,CHYS
+IWMF,IWMF
+SRCW,SRCW
+ETMQ,ETMQ
+QHPN,QHPN
+MLEP,MLEP
+YLWR,YLWR
+IHQN,IHQN
+KWPF,KWPF
+SKWK,SKWK
+YIRV,YIRV
+AVKM,AVKM
+SRER,SRER
+KVTF,KVTF
+MART,MART
+HLPC,HLPC
+CGNP,CGNP
+LIHW,LIHW
+WRHE,WRHE
+PLPD,PLPD
+AISH,AISH
+LVGA,LVGA
+GDAN,GDAN
+KFDC,KFDC
+TVYN,TVYN
+EHMH,EHMH
+KEHT,KEHT
+IGSA,IGSA
+HNMM,HNMM
+LWNH,LWNH
+PKYY,PKYY
+CCIM,CCIM
+TIDF,TIDF
+GYTV,GYTV
+LNIN,LNIN
+WRAS,WRAS
+LANP,LANP
+KEYL,KEYL
+PIAT,PIAT
+HNYA,HNYA
+ERTP,ERTP
+TAHS,TAHS
+CMPV,CMPV
+DPHY,DPHY
+HVCL,HVCL
+NRKH,NRKH
+RHCG,RHCG
+AKRV,AKRV
+TSYG,TSYG
+WASS,WASS
+NIDH,NIDH
+WNVC,WNVC
+TLSL,TLSL
+NMWE,NMWE
+LKIY,LKIY
+CVNT,CVNT
+EEAP,EEAP
+MGNK,MGNK
+KDQP,KDQP
+DTRQ,DTRQ
+QVIH,QVIH
+PTKM,PTKM
+FVNA,FVNA
+MTTV,MTTV
+TLDK,TLDK
+NRDV,NRDV
+WYSN,WYSN
+KKEI,KKEI
+VKTG,VKTG
+RTMS,RTMS
+GVTS,GVTS
+QVFG,QVFG
+FSID,FSID
+MCGK,MCGK
+KRYF,KRYF
+FSCA,FSCA
+ENWS,ENWS
+KLPS,KLPS
+WHPD,WHPD
+WERR,WERR
+GVPD,GVPD
+QATI,QATI
+QIRW,QIRW
+VCQD,VCQD
+NHNV,NHNV
+KSPQ,KSPQ
+MQQR,MQQR
+WMYG,WMYG
+YIGK,YIGK
+WAAR,WAAR
+ILEI,ILEI
+EWFS,EWFS
+YAGP,YAGP
+WSWA,WSWA
+WKMM,WKMM
+FWTN,FWTN
+NIRN,NIRN
+EEHP,EEHP
+GKPE,GKPE
+KPLK,KPLK
+EWPS,EWPS
+KLRS,KLRS
+EYWY,EYWY
+CFGR,CFGR
+NEGH,NEGH
+GDRM,GDRM
+VGTI,VGTI
+YCGL,YCGL
+EVMG,EVMG
+PQNW,PQNW
+QVQH,QVQH
+NTPI,NTPI
+VMVI,VMVI
+RHAT,RHAT
+RVCM,RVCM
+LSIN,LSIN
+ATKL,ATKL
+PSNL,PSNL
+WESL,WESL
+QPDG,QPDG
+YRFL,YRFL
+RTPP,RTPP
+IVKA,IVKA
+VVPK,VVPK
+YKPE,YKPE
+FHFW,FHFW
+TRLH,TRLH
+ITSL,ITSL
+GEIE,GEIE
+FGGQ,FGGQ
+SSPD,SSPD
+TWHQ,TWHQ
+GEDR,GEDR
+HNEC,HNEC
+PQNL,PQNL
+ECNQ,ECNQ
+TSEQ,TSEQ
+RLVW,RLVW
+RDNT,RDNT
+QMAH,QMAH
+NVFD,NVFD
+YHYT,YHYT
+PMNY,PMNY
+MGML,MGML
+AFYE,AFYE
+EGLV,EGLV
+PGLP,PGLP
+YNFY,YNFY
+KTAC,KTAC
+YHMC,YHMC
+IATA,IATA
+LPDV,LPDV
+LIAS,LIAS
+DDLY,DDLY
+MQNA,MQNA
+HISP,HISP
+VKIN,VKIN
+LGNP,LGNP
+SCGK,SCGK
+MKED,MKED
+VAWY,VAWY
+HWPF,HWPF
+LMPY,LMPY
+QICW,QICW
+CPCR,CPCR
+RSYT,RSYT
+NLYT,NLYT
+KIHC,KIHC
+LMCP,LMCP
+VTEC,VTEC
+WSWH,WSWH
+SSYR,SSYR
+FTQN,FTQN
+NRML,NRML
+SFFL,SFFL
+QRTP,QRTP
+VPII,VPII
+MYEK,MYEK
+TSTF,TSTF
+PKYM,PKYM
+IITN,IITN
+HPVW,HPVW
+VNLP,VNLP
+SVKP,SVKP
+CDKP,CDKP
+FDWC,FDWC
+AKSF,AKSF
+LYYM,LYYM
+EDWE,EDWE
+QDET,QDET
+YACA,YACA
+QMWK,QMWK
+IIMH,IIMH
+QCTC,QCTC
+PMHG,PMHG
+ECKA,ECKA
+KQYL,KQYL
+SPCL,SPCL
+MQEK,MQEK
+LIAN,LIAN
+SCDL,SCDL
+NDFP,NDFP
+QKGE,QKGE
+HNDV,HNDV
+HHHE,HHHE
+AWNV,AWNV
+SPSG,SPSG
+LRIA,LRIA
+IVID,IVID
+YQYS,YQYS
+DGTP,DGTP
+DTTL,DTTL
+HWDN,HWDN
+DGNC,DGNC
+QGEG,QGEG
+SNPP,SNPP
+KVSH,KVSH
+WLWV,WLWV
+LMMA,LMMA
+MGCM,MGCM
+LNKP,LNKP
+TPIG,TPIG
+WEWH,WEWH
+QCVC,QCVC
+RMKF,RMKF
+MDDE,MDDE
+PGPQ,PGPQ
+DVTF,DVTF
+DKCT,DKCT
+ECRP,ECRP
+CCGP,CCGP
+RFVF,RFVF
+LMNC,LMNC
+TICP,TICP
+AKWL,AKWL
+MTPT,MTPT
+NTVY,NTVY
+KNRS,KNRS
+CYIT,CYIT
+IAGE,IAGE
+ICKI,ICKI
+GQAS,GQAS
+RNFR,RNFR
+SAQL,SAQL
+ICMM,ICMM
+NVED,NVED
+RLSM,RLSM
+INMV,INMV
+FGRY,FGRY
+RGRW,RGRW
+CNNG,CNNG
+YGES,YGES
+YLCN,YLCN
+PASK,PASK
+LYIT,LYIT
+PLPM,PLPM
+GDMM,GDMM
+TQER,TQER
+MTHR,MTHR
+NKCN,NKCN
+NDQA,NDQA
+FIWM,FIWM
+ATER,ATER
+ISVY,ISVY
+HVTG,HVTG
+RPSV,RPSV
+SGET,SGET
+TNGR,TNGR
+SFLC,SFLC
+PPRD,PPRD
+AWKW,AWKW
+DLCW,DLCW
+RFFC,RFFC
+VIQR,VIQR
+KIPG,KIPG
+SRPE,SRPE
+LMMY,LMMY
+YDTM,YDTM
+MTIG,MTIG
+GSHI,GSHI
+NCRV,NCRV
+KPDS,KPDS
+CNNL,CNNL
+MGVK,MGVK
+GWED,GWED
+TYHW,TYHW
+NMVM,NMVM
+EHFA,EHFA
+SVCM,SVCM
+THET,THET
+QGYR,QGYR
+NTDC,NTDC
+ETST,ETST
+MLSM,MLSM
+YRRQ,YRRQ
+VWEA,VWEA
+PFYW,PFYW
+TIEI,TIEI
+ECCQ,ECCQ
+SVDV,SVDV
+RYKY,RYKY
+AMDS,AMDS
+DMMK,DMMK
+AMKE,AMKE
+GNHG,GNHG
+DVPC,DVPC
+IQVY,IQVY
+FNDE,FNDE
+HTLS,HTLS
+DFIG,DFIG
+PVMD,PVMD
+RAMS,RAMS
+IASS,IASS
+DMKH,DMKH
+KYPS,KYPS
+PVQF,PVQF
+SWPS,SWPS
+EQCI,EQCI
+CNMV,CNMV
+MVVG,MVVG
+SVDI,SVDI
+RRRN,RRRN
+AFSS,AFSS
+PAQD,PAQD
+QATV,QATV
+GFCR,GFCR
+FNYS,FNYS
+VNWN,VNWN
+PMIH,PMIH
+VDYL,VDYL
+VICL,VICL
+KYGL,KYGL
+FHIK,FHIK
+VVNY,VVNY
+TYYT,TYYT
+DLPN,DLPN
+RNGI,RNGI
+FFGV,FFGV
+EIQM,EIQM
+HRNL,HRNL
+FHGM,FHGM
+PQVA,PQVA
+WIVH,WIVH
+PTWK,PTWK
+MFHD,MFHD
+FHST,FHST
+NMHA,NMHA
+KSPI,KSPI
+DDTI,DDTI
+DVQS,DVQS
+KGAT,KGAT
+RITF,RITF
+PNPL,PNPL
+VICS,VICS
+EDMF,EDMF
+ESID,ESID
+VESG,VESG
+EKEN,EKEN
+KAYY,KAYY
+LMPW,LMPW
+ANLI,ANLI
+CALR,CALR
+KMGI,KMGI
+NEAE,NEAE
+QAIC,QAIC
+NKQE,NKQE
+IRTF,IRTF
+TCQN,TCQN
+RPAY,RPAY
+GTHQ,GTHQ
+HVCH,HVCH
+GVQA,GVQA
+KQTA,KQTA
+NWSA,NWSA
+GLSC,GLSC
+SPRS,SPRS
+EDHW,EDHW
+YHMA,YHMA
+QFIR,QFIR
+LKYW,LKYW
+VRMD,VRMD
+TPNP,TPNP
+LFCF,LFCF
+CEVE,CEVE
+MDDA,MDDA
+HNYT,HNYT
+WPVP,WPVP
+TTAV,TTAV
+RTRI,RTRI
+AYAG,AYAG
+DYDT,DYDT
+GEQE,GEQE
+EGSA,EGSA
+LEMF,LEMF
+IEFW,IEFW
+PIQS,PIQS
+EAMT,EAMT
+QCNI,QCNI
+QNGS,QNGS
+CFNL,CFNL
+QQSV,QQSV
+TCPN,TCPN
+SWSR,SWSR
+RTYL,RTYL
+YPAE,YPAE
+GLMQ,GLMQ
+QCHI,QCHI
+IGIR,IGIR
+ICPI,ICPI
+CDFV,CDFV
+PISQ,PISQ
+QYQM,QYQM
+DFHH,DFHH
+FVHV,FVHV
+RKSK,RKSK
+STLE,STLE
+MKLD,MKLD
+AAYG,AAYG
+LHNG,LHNG
+RWCV,RWCV
+QCWF,QCWF
+CKSK,CKSK
+QIGA,QIGA
+SFKL,SFKL
+PFLN,PFLN
+TGPF,TGPF
+HTEE,HTEE
+PDFH,PDFH
+IFIM,IFIM
+ITCK,ITCK
+SKKP,SKKP
+QLMD,QLMD
+NLYY,NLYY
+EVHQ,EVHQ
+TSLV,TSLV
+GRHR,GRHR
+HYQF,HYQF
+LSGA,LSGA
+IAPM,IAPM
+GEIN,GEIN
+GLRD,GLRD
+TDNC,TDNC
+NMTH,NMTH
+DHLQ,DHLQ
+GLQA,GLQA
+FNEP,FNEP
+KHSF,KHSF
+FKKS,FKKS
+DIMC,DIMC
+HWVN,HWVN
+RNFI,RNFI
+HDEG,HDEG
+WVVN,WVVN
+EQKE,EQKE
+SCFD,SCFD
+ADRR,ADRR
+TVAF,TVAF
+RVDC,RVDC
+YFNI,YFNI
+NGMW,NGMW
+EKFN,EKFN
+NFII,NFII
+SAFS,SAFS
+NNNY,NNNY
+PFGK,PFGK
+SGMK,SGMK
+SHTM,SHTM
+HDNH,HDNH
+EWWP,EWWP
+PFKH,PFKH
+WSYL,WSYL
+IHSC,IHSC
+YYED,YYED
+HCMW,HCMW
+RNKR,RNKR
+CRNH,CRNH
+HPVR,HPVR
+TKLY,TKLY
+NNSK,NNSK
+SPIQ,SPIQ
+KWQV,KWQV
+INEP,INEP
+TCQL,TCQL
+VKRD,VKRD
+VPHC,VPHC
+GNAN,GNAN
+IVNE,IVNE
+GMYD,GMYD
+VTLF,VTLF
+INSN,INSN
+EQKH,EQKH
+IRKL,IRKL
+APIY,APIY
+SPSP,SPSP
+TWKI,TWKI
+TWTC,TWTC
+SFSI,SFSI
+CSHN,CSHN
+RHCA,RHCA
+WTEF,WTEF
+SNCQ,SNCQ
+SLME,SLME
+GHEW,GHEW
+EMPE,EMPE
+ADFS,ADFS
+GHHS,GHHS
+HGMC,HGMC
+LWWR,LWWR
+NVSG,NVSG
+IVKI,IVKI
+YNHE,YNHE
+CPGT,CPGT
+LAKQ,LAKQ
+KNRG,KNRG
+DFGC,DFGC
+WNAI,WNAI
+SKCN,SKCN
+FYSC,FYSC
+CTIY,CTIY
+CSDP,CSDP
+CHTN,CHTN
+FWKT,FWKT
+DWQH,DWQH
+HWCS,HWCS
+WWLW,WWLW
+HADL,HADL
+RITQ,RITQ
+SREP,SREP
+VQIF,VQIF
+HMPQ,HMPQ
+TFFD,TFFD
+KGMF,KGMF
+DKVN,DKVN
+YWKS,YWKS
+LHLT,LHLT
+WHDD,WHDD
+WALN,WALN
+QSQH,QSQH
+DFIT,DFIT
+IGRW,IGRW
+SKVS,SKVS
+MDSD,MDSD
+HPER,HPER
+CRDW,CRDW
+WECW,WECW
+DWEI,DWEI
+DCDT,DCDT
+SWIH,SWIH
+VQGR,VQGR
+DPTP,DPTP
+PHDF,PHDF
+HHTM,HHTM
+DLYK,DLYK
+CLIQ,CLIQ
+APYR,APYR
+CPQV,CPQV
+RLYF,RLYF
+SSLI,SSLI
+FAEQ,FAEQ
+ELQC,ELQC
+ARFI,ARFI
+SQTV,SQTV
+SWHG,SWHG
+TNSD,TNSD
+HPCP,HPCP
+AFAN,AFAN
+KAHA,KAHA
+AMSN,AMSN
+VPMS,VPMS
+FRDK,FRDK
+STCQ,STCQ
+GIMS,GIMS
+ICRN,ICRN
+IYAG,IYAG
+VWSY,VWSY
+QAFG,QAFG
+NNCH,NNCH
+GGNN,GGNN
+HVMA,HVMA
+KGRI,KGRI
+LAFF,LAFF
+KCDN,KCDN
+RFVY,RFVY
+EYKW,EYKW
+ASIR,ASIR
+HPGV,HPGV
+AKDI,AKDI
+KDNH,KDNH
+KKLH,KKLH
+LCLD,LCLD
+MLTD,MLTD
+LAQY,LAQY
+EPFC,EPFC
+VRRL,VRRL
+FSNW,FSNW
+WDEK,WDEK
+YDDY,YDDY
+LNQE,LNQE
+NLHN,NLHN
+SLRQ,SLRQ
+AFAT,AFAT
+INVT,INVT
+YYNC,YYNC
+TMKL,TMKL
+AIKI,AIKI
+GALS,GALS
+IIML,IIML
+MQRK,MQRK
+KAWH,KAWH
+KWYI,KWYI
+MKIP,MKIP
+CLLI,CLLI
+HHCW,HHCW
+WWFP,WWFP
+ISTG,ISTG
+KYGD,KYGD
+RPCK,RPCK
+QMGG,QMGG
+DARI,DARI
+PMCE,PMCE
+VYIV,VYIV
+VHEY,VHEY
+QMCG,QMCG
+CLVL,CLVL
+EKCS,EKCS
+IKVP,IKVP
+DNRP,DNRP
+WLCW,WLCW
+RSNE,RSNE
+QKLT,QKLT
+TEND,TEND
+FMFY,FMFY
+QYKD,QYKD
+HQTR,HQTR
+ALVT,ALVT
+NGSN,NGSN
+EALD,EALD
+MPWC,MPWC
+GGMI,GGMI
+VIRS,VIRS
+LSSM,LSSM
+SYAY,SYAY
+CVVM,CVVM
+WTNV,WTNV
+TVFM,TVFM
+DECF,DECF
+RETI,RETI
+IMTD,IMTD
+MQDV,MQDV
+GNEP,GNEP
+RFMC,RFMC
+GGLH,GGLH
+PKFI,PKFI
+NGQG,NGQG
+TFKL,TFKL
+SRYN,SRYN
+FFSS,FFSS
+CKET,CKET
+DDCM,DDCM
+WRVY,WRVY
+RGTH,RGTH
+WWNN,WWNN
+NMGV,NMGV
+GFAE,GFAE
+MMPT,MMPT
+YIQY,YIQY
+TNSF,TNSF
+HHDM,HHDM
+DQMG,DQMG
+LHPN,LHPN
+PWEA,PWEA
+KGVA,KGVA
+DRRI,DRRI
+DFVM,DFVM
+WDVE,WDVE
+SQYV,SQYV
+GDIA,GDIA
+STMC,STMC
+CTLK,CTLK
+INYK,INYK
+DAVY,DAVY
+SAAE,SAAE
+NQPC,NQPC
+VGHL,VGHL
+TSVY,TSVY
+IDQL,IDQL
+ETDI,ETDI
+FCCD,FCCD
+SRGC,SRGC
+IHND,IHND
+HKYL,HKYL
+NQPS,NQPS
+YWAE,YWAE
+SDNQ,SDNQ
+ISEG,ISEG
+NATM,NATM
+NGCV,NGCV
+YNTC,YNTC
+FFKA,FFKA
+CTTS,CTTS
+EEAD,EEAD
+KHAQ,KHAQ
+STQQ,STQQ
+MMTS,MMTS
+HDHV,HDHV
+KGLQ,KGLQ
+PKAM,PKAM
+DQVY,DQVY
+QQHD,QQHD
+QQLR,QQLR
+YCEQ,YCEQ
+YYGY,YYGY
+RLRR,RLRR
+VRYS,VRYS
+ESHL,ESHL
+DYGS,DYGS
+ITKD,ITKD
+VTDQ,VTDQ
+GLYK,GLYK
+FNAL,FNAL
+HMHG,HMHG
+TDVT,TDVT
+VSGS,VSGS
+FSER,FSER
+MHAN,MHAN
+WYEG,WYEG
+PCRG,PCRG
+DIEM,DIEM
+ESNY,ESNY
+HYHD,HYHD
+VFCC,VFCC
+DSYW,DSYW
+AQQM,AQQM
+CYCW,CYCW
+GKWK,GKWK
+GRSD,GRSD
+QEKH,QEKH
+LPLF,LPLF
+YPYG,YPYG
+YDYS,YDYS
+TSHA,TSHA
+KMIK,KMIK
+ACWG,ACWG
+TGEQ,TGEQ
+PHKQ,PHKQ
+VGKH,VGKH
+GHQI,GHQI
+QPPG,QPPG
+TYEF,TYEF
+GHHY,GHHY
+SLSL,SLSL
+ARNE,ARNE
+DATD,DATD
+LAND,LAND
+QIQA,QIQA
+EHYP,EHYP
+CASL,CASL
+EPSF,EPSF
+VELW,VELW
+YERL,YERL
+DEKS,DEKS
+NQMW,NQMW
+WMHS,WMHS
+KNMV,KNMV
+QTIW,QTIW
+TQDA,TQDA
+PYGD,PYGD
+SFMV,SFMV
+GHCR,GHCR
+TFIR,TFIR
+YAEP,YAEP
+IYTY,IYTY
+FSEY,FSEY
+FINQ,FINQ
+CGKE,CGKE
+DDCQ,DDCQ
+FDEE,FDEE
+EMLR,EMLR
+CKFY,CKFY
+KRHR,KRHR
+RNVV,RNVV
+CVAP,CVAP
+GFQD,GFQD
+YSHN,YSHN
+FDRF,FDRF
+AEQN,AEQN
+VFEW,VFEW
+ETTF,ETTF
+MSME,MSME
+GNSW,GNSW
+YTGA,YTGA
+DYRD,DYRD
+CMQY,CMQY
+TCCW,TCCW
+MHEG,MHEG
+IDIK,IDIK
+MMKE,MMKE
+MVDE,MVDE
+PECI,PECI
+MLPV,MLPV
+AKEK,AKEK
+MTTY,MTTY
+NFHF,NFHF
+KVCV,KVCV
+PSSQ,PSSQ
+ILSQ,ILSQ
+RGCN,RGCN
+SLLK,SLLK
+TISM,TISM
+CKNM,CKNM
+HMFA,HMFA
+NEPY,NEPY
+FIWR,FIWR
+ACGP,ACGP
+CMIN,CMIN
+YQSH,YQSH
+TKRK,TKRK
+KKMP,KKMP
+HDGN,HDGN
+ANDY,ANDY
+HDWG,HDWG
+CGEE,CGEE
+FYLE,FYLE
+ICVE,ICVE
+KGWY,KGWY
+FVQW,FVQW
+QQVE,QQVE
+NCRD,NCRD
+DLFD,DLFD
+IVRM,IVRM
+FIWK,FIWK
+YLCY,YLCY
+SWMY,SWMY
+QWDN,QWDN
+DEGK,DEGK
+RPIK,RPIK
+AMFA,AMFA
+QTCQ,QTCQ
+NTKK,NTKK
+SCLE,SCLE
+LPME,LPME
+SEYY,SEYY
+WWRY,WWRY
+DDNS,DDNS
+EKNR,EKNR
+PKIQ,PKIQ
+LRTG,LRTG
+NANG,NANG
+SMNT,SMNT
+GHVQ,GHVQ
+KAPS,KAPS
+QHNC,QHNC
+RQAQ,RQAQ
+TAKP,TAKP
+GSCG,GSCG
+DYGD,DYGD
+GTSS,GTSS
+ALYP,ALYP
+TDER,TDER
+HYPN,HYPN
+ERAS,ERAS
+RMSP,RMSP
+CIMM,CIMM
+EYTT,EYTT
+YSEC,YSEC
+LLGP,LLGP
+PEAA,PEAA
+NQGY,NQGY
+HQPP,HQPP
+NRTP,NRTP
+LALL,LALL
+TPGN,TPGN
+LEIA,LEIA
+WEEA,WEEA
+GVAG,GVAG
+TCRA,TCRA
+KVDG,KVDG
+CMVY,CMVY
+CHMI,CHMI
+GGYF,GGYF
+MPTV,MPTV
+GNNK,GNNK
+GEIA,GEIA
+SHPY,SHPY
+PMRM,PMRM
+GRTR,GRTR
+PHEM,PHEM
+IYEL,IYEL
+FCDK,FCDK
+IYSF,IYSF
+NRDP,NRDP
+AHGE,AHGE
+MMYF,MMYF
+YKQE,YKQE
+GKFT,GKFT
+IENN,IENN
+HAHG,HAHG
+KVEH,KVEH
+VILD,VILD
+FSFE,FSFE
+LVHQ,LVHQ
+LICG,LICG
+WSEM,WSEM
+FHTK,FHTK
+WCSE,WCSE
+VDGM,VDGM
+VVYE,VVYE
+HPWQ,HPWQ
+PDAY,PDAY
+AGIA,AGIA
+HCGK,HCGK
+SAVI,SAVI
+EKHK,EKHK
+ICPA,ICPA
+RWFE,RWFE
+WHDE,WHDE
+QIRD,QIRD
+QKPK,QKPK
+TQCF,TQCF
+GVMW,GVMW
+QGGM,QGGM
+CREN,CREN
+ASAL,ASAL
+VRTV,VRTV
+DVAV,DVAV
+EFWC,EFWC
+EHMY,EHMY
+VWHM,VWHM
+FSLN,FSLN
+KYLA,KYLA
+QETP,QETP
+DDAG,DDAG
+ILAV,ILAV
+SSNL,SSNL
+CCNW,CCNW
+KPAI,KPAI
+WTVI,WTVI
+KQHA,KQHA
+QVRI,QVRI
+CRVT,CRVT
+PHQM,PHQM
+AEMH,AEMH
+HHYG,HHYG
+MSCY,MSCY
+EHLG,EHLG
+EPPA,EPPA
+AQIM,AQIM
+CNII,CNII
+NADT,NADT
+MHKK,MHKK
+EDFY,EDFY
+CPLP,CPLP
+LVDD,LVDD
+YFKR,YFKR
+DFID,DFID
+KKQF,KKQF
+VDNK,VDNK
+WWWQ,WWWQ
+VECI,VECI
+TIEG,TIEG
+TWRG,TWRG
+SANG,SANG
+YWFC,YWFC
+HCFS,HCFS
+SWFN,SWFN
+QQLK,QQLK
+HPYR,HPYR
+QDLI,QDLI
+HYTL,HYTL
+QSAM,QSAM
+LASK,LASK
+VDAW,VDAW
+LTGH,LTGH
+VCFH,VCFH
+QNGD,QNGD
+WMAR,WMAR
+CCLC,CCLC
+HSQV,HSQV
+KEWG,KEWG
+PWHA,PWHA
+HAPI,HAPI
+TAQW,TAQW
+PRNF,PRNF
+ADIG,ADIG
+DYLC,DYLC
+WYLN,WYLN
+IQEP,IQEP
+RNGR,RNGR
+QWQY,QWQY
+GIWI,GIWI
+MGTS,MGTS
+NRTE,NRTE
+MEEF,MEEF
+DNWK,DNWK
+HCMM,HCMM
+YATS,YATS
+QMQW,QMQW
+CWKE,CWKE
+NVSW,NVSW
+NIRC,NIRC
+RFVD,RFVD
+KGFK,KGFK
+SWTE,SWTE
+WMAY,WMAY
+NFLA,NFLA
+CHTP,CHTP
+HRMT,HRMT
+LDVQ,LDVQ
+HSLA,HSLA
+FSLW,FSLW
+RPNY,RPNY
+DCME,DCME
+RESY,RESY
+TKRF,TKRF
+TVHS,TVHS
+YPKI,YPKI
+VQYS,VQYS
+YHLW,YHLW
+EYQD,EYQD
+AQHV,AQHV
+VDQD,VDQD
+VEWT,VEWT
+NSLC,NSLC
+QFCW,QFCW
+AHCC,AHCC
+TSLH,TSLH
+ICSC,ICSC
+RGGL,RGGL
+QNEW,QNEW
+LAEL,LAEL
+CIDA,CIDA
+DKEP,DKEP
+NPYL,NPYL
+LPSA,LPSA
+NPKC,NPKC
+QVLV,QVLV
+DIWW,DIWW
+AQCR,AQCR
+ALNH,ALNH
+PQTE,PQTE
+QSHE,QSHE
+IDLS,IDLS
+WSKM,WSKM
+CHQI,CHQI
+INRL,INRL
+VIVA,VIVA
+VPYG,VPYG
+LFPL,LFPL
+SPDA,SPDA
+PTVC,PTVC
+HPVD,HPVD
+PNIY,PNIY
+FPYF,FPYF
+LSLS,LSLS
+PPSS,PPSS
+GSYS,GSYS
+ADCD,ADCD
+DTEI,DTEI
+VLMD,VLMD
+FWGY,FWGY
+HLWE,HLWE
+NCHC,NCHC
+WIQM,WIQM
+FAMD,FAMD
+CCKQ,CCKQ
+EMKY,EMKY
+HRMM,HRMM
+DRYC,DRYC
+LPHQ,LPHQ
+HPQC,HPQC
+TYMI,TYMI
+HPQM,HPQM
+CCWI,CCWI
+MPNQ,MPNQ
+IMIT,IMIT
+TWAR,TWAR
+HVVL,HVVL
+CSSG,CSSG
+PAEM,PAEM
+MHWD,MHWD
+QVYE,QVYE
+QCNV,QCNV
+RYDQ,RYDQ
+QILA,QILA
+ANYR,ANYR
+VNGE,VNGE
+WKPR,WKPR
+LVMT,LVMT
+HNIR,HNIR
+FFNS,FFNS
+GSRR,GSRR
+VTVI,VTVI
+PMML,PMML
+ECTM,ECTM
+CNHN,CNHN
+QSHA,QSHA
+AFNV,AFNV
+DKAD,DKAD
+WALC,WALC
+CNRV,CNRV
+MFKT,MFKT
+DIVY,DIVY
+VPES,VPES
+PLEW,PLEW
+HSCT,HSCT
+SHGA,SHGA
+TTET,TTET
+PIQW,PIQW
+DLTL,DLTL
+VPLE,VPLE
+VLTG,VLTG
+KCNM,KCNM
+IDCY,IDCY
+DSPK,DSPK
+PDKC,PDKC
+WTCY,WTCY
+RIMR,RIMR
+VNPA,VNPA
+FVDP,FVDP
+RPDP,RPDP
+TLEF,TLEF
+DLNF,DLNF
+CVES,CVES
+WKWF,WKWF
+PNMI,PNMI
+DIVA,DIVA
+GKWC,GKWC
+HDYC,HDYC
+HAMN,HAMN
+TEPW,TEPW
+VYHI,VYHI
+MTHE,MTHE
+IGYD,IGYD
+PARW,PARW
+FQCG,FQCG
+MLSF,MLSF
+NGFG,NGFG
+YDMF,YDMF
+ATVW,ATVW
+PFHY,PFHY
+QYTG,QYTG
+KISE,KISE
+WPSR,WPSR
+LLIN,LLIN
+CMIF,CMIF
+NKKT,NKKT
+PLYW,PLYW
+QQFN,QQFN
+SQMQ,SQMQ
+AWQH,AWQH
+RDCC,RDCC
+YRWA,YRWA
+PGCG,PGCG
+STHQ,STHQ
+EQFS,EQFS
+KWVH,KWVH
+PDVA,PDVA
+LCVI,LCVI
+LTIN,LTIN
+VYEM,VYEM
+DYRG,DYRG
+GSRP,GSRP
+IYFQ,IYFQ
+LYNA,LYNA
+QFWL,QFWL
+LTAF,LTAF
+KEDA,KEDA
+HVPF,HVPF
+GQSM,GQSM
+YRHQ,YRHQ
+QDCH,QDCH
+PEMD,PEMD
+QPTI,QPTI
+NGNG,NGNG
+NQNL,NQNL
+KYEH,KYEH
+TQFF,TQFF
+FPFA,FPFA
+AQLP,AQLP
+CTHE,CTHE
+VAVM,VAVM
+KPLY,KPLY
+SSLF,SSLF
+MIRW,MIRW
+RAHP,RAHP
+VREH,VREH
+NAMG,NAMG
+FKKQ,FKKQ
+KQRA,KQRA
+LIFD,LIFD
+YRPE,YRPE
+TFAD,TFAD
+QIAA,QIAA
+INFW,INFW
+CRKA,CRKA
+GDAV,GDAV
+HETY,HETY
+GVGT,GVGT
+NDIP,NDIP
+CRSM,CRSM
+HTGT,HTGT
+STMK,STMK
+EQGS,EQGS
+TMQM,TMQM
+ENKD,ENKD
+KAFL,KAFL
+LRLK,LRLK
+VSPT,VSPT
+AHLV,AHLV
+CYHE,CYHE
+RLWK,RLWK
+LYWK,LYWK
+SATM,SATM
+PMSW,PMSW
+NTYF,NTYF
+EDHE,EDHE
+MMIQ,MMIQ
+KGPY,KGPY
+TCRP,TCRP
+TSKR,TSKR
+EVDV,EVDV
+QWRH,QWRH
+TYTI,TYTI
+NRFT,NRFT
+FRPY,FRPY
+LLPI,LLPI
+FGPP,FGPP
+PHYI,PHYI
+CMCK,CMCK
+NMPI,NMPI
+GQFR,GQFR
+NQER,NQER
+LMKS,LMKS
+ENCI,ENCI
+TNNV,TNNV
+GRAM,GRAM
+AAMV,AAMV
+IFYL,IFYL
+EKIL,EKIL
+QMAP,QMAP
+RYGL,RYGL
+NQAI,NQAI
+LYSR,LYSR
+DRES,DRES
+PTHS,PTHS
+TLDQ,TLDQ
+KEYH,KEYH
+HDWC,HDWC
+RPQT,RPQT
+PMNG,PMNG
+GWVS,GWVS
+PQEW,PQEW
+QRRP,QRRP
+CEIQ,CEIQ
+WNKY,WNKY
+FRVE,FRVE
+PTYH,PTYH
+LCRD,LCRD
+MEWQ,MEWQ
+QMNY,QMNY
+NFDK,NFDK
+QRKH,QRKH
+YLSR,YLSR
+MVRG,MVRG
+IQQH,IQQH
+RMEE,RMEE
+HYDN,HYDN
+KMSH,KMSH
+LWEL,LWEL
+WYLC,WYLC
+NGLM,NGLM
+QWPS,QWPS
+WFMM,WFMM
+KFEY,KFEY
+CQMT,CQMT
+GHFL,GHFL
+TERR,TERR
+VFGH,VFGH
+NRRF,NRRF
+RMRM,RMRM
+ITAK,ITAK
+WQWH,WQWH
+MQLP,MQLP
+LTSP,LTSP
+VEYQ,VEYQ
+YYHP,YYHP
+KDHH,KDHH
+PETW,PETW
+HDEA,HDEA
+WSMV,WSMV
+YITL,YITL
+FLQY,FLQY
+LLDM,LLDM
+IEHF,IEHF
+KVWR,KVWR
+THAR,THAR
+VREK,VREK
+SARM,SARM
+FSKI,FSKI
+NCTQ,NCTQ
+VEGT,VEGT
+SIKV,SIKV
+WSTR,WSTR
+NTQD,NTQD
+DNDN,DNDN
+SGFT,SGFT
+YRLW,YRLW
+KNWK,KNWK
+AVKA,AVKA
+APIK,APIK
+YDSL,YDSL
+TNHT,TNHT
+HYKY,HYKY
+SDNK,SDNK
+GAMQ,GAMQ
+PWIH,PWIH
+SYQG,SYQG
+CPDS,CPDS
+TGFQ,TGFQ
+YLNI,YLNI
+NVFM,NVFM
+TIDN,TIDN
+ATTP,ATTP
+GGGT,GGGT
+CHAG,CHAG
+NMNG,NMNG
+QLRT,QLRT
+LKWC,LKWC
+CDDQ,CDDQ
+YHGR,YHGR
+LEPK,LEPK
+QANG,QANG
+IDCV,IDCV
+FYYH,FYYH
+MHDH,MHDH
+YSQC,YSQC
+EYFL,EYFL
+HLIS,HLIS
+IQDK,IQDK
+HSIE,HSIE
+EKFK,EKFK
+EGKE,EGKE
+TMNI,TMNI
+SSQA,SSQA
+SASM,SASM
+ECIL,ECIL
+VRAD,VRAD
+EQLS,EQLS
+WKPD,WKPD
+HKWC,HKWC
+RQDW,RQDW
+YEFT,YEFT
+RPMP,RPMP
+FLCK,FLCK
+MMGK,MMGK
+FAYK,FAYK
+TFHN,TFHN
+PYFA,PYFA
+QSDI,QSDI
+MRQR,MRQR
+NGVY,NGVY
+KYLC,KYLC
+NAFE,NAFE
+HMYC,HMYC
+YDQM,YDQM
+WKMF,WKMF
+SRFI,SRFI
+YRQK,YRQK
+GIMY,GIMY
+GYMS,GYMS
+FCME,FCME
+IRFT,IRFT
+NWHA,NWHA
+MLWS,MLWS
+RHFG,RHFG
+WIMA,WIMA
+PAEF,PAEF
+CHTE,CHTE
+MEIK,MEIK
+AILP,AILP
+PQSC,PQSC
+SAHG,SAHG
+LREP,LREP
+PFQN,PFQN
+SCYA,SCYA
+PSCG,PSCG
+SACP,SACP
+AVEV,AVEV
+ETED,ETED
+YIRN,YIRN
+AHTQ,AHTQ
+ATSP,ATSP
+QHRR,QHRR
+IVYE,IVYE
+IRCV,IRCV
+AWKE,AWKE
+KSSH,KSSH
+HWFY,HWFY
+RSVM,RSVM
+RCHT,RCHT
+YKIK,YKIK
+YERF,YERF
+YCPT,YCPT
+IRPV,IRPV
+CDWV,CDWV
+CTFA,CTFA
+GIPV,GIPV
+RWNY,RWNY
+YPKQ,YPKQ
+WAPI,WAPI
+TTCV,TTCV
+HNPW,HNPW
+IVYQ,IVYQ
+DSDC,DSDC
+TTDF,TTDF
+WTTV,WTTV
+SYPT,SYPT
+EVER,EVER
+NGTR,NGTR
+TTWV,TTWV
+CKRQ,CKRQ
+ENEI,ENEI
+KANP,KANP
+HDVL,HDVL
+ENWI,ENWI
+ENRS,ENRS
+RAEK,RAEK
+RSMM,RSMM
+KNCQ,KNCQ
+MCFD,MCFD
+SCEE,SCEE
+PFKV,PFKV
+DVTW,DVTW
+HSHA,HSHA
+MVGG,MVGG
+MLFY,MLFY
+SQLI,SQLI
+KCTN,KCTN
+ADDD,ADDD
+QAFQ,QAFQ
+VMLY,VMLY
+LWNE,LWNE
+CNAE,CNAE
+MMAN,MMAN
+AEQT,AEQT
+TWQQ,TWQQ
+CRVV,CRVV
+HIWA,HIWA
+NSRN,NSRN
+CETD,CETD
+HDVQ,HDVQ
+CERW,CERW
+EIWE,EIWE
+PRHF,PRHF
+RGWE,RGWE
+WNTL,WNTL
+DWSH,DWSH
+EFYV,EFYV
+WWAR,WWAR
+WLEA,WLEA
+ECRM,ECRM
+VQAI,VQAI
+MWSY,MWSY
+RHWS,RHWS
+YEEQ,YEEQ
+CLAV,CLAV
+VHGN,VHGN
+WSSQ,WSSQ
+QCRE,QCRE
+VLKI,VLKI
+VQIH,VQIH
+CYGR,CYGR
+IRPT,IRPT
+LYQQ,LYQQ
+RRFV,RRFV
+CLYP,CLYP
+SHYK,SHYK
+YVNE,YVNE
+HVTC,HVTC
+MDNG,MDNG
+MITR,MITR
+FNWP,FNWP
+HWDR,HWDR
+TIWW,TIWW
+EFHR,EFHR
+WEIP,WEIP
+WMVF,WMVF
+TITV,TITV
+CGGR,CGGR
+AHLH,AHLH
+RAFC,RAFC
+TEQF,TEQF
+CDHT,CDHT
+NSLS,NSLS
+MFYG,MFYG
+EIHC,EIHC
+RFII,RFII
+EIWP,EIWP
+YWWL,YWWL
+GIVG,GIVG
+WNTE,WNTE
+ETWT,ETWT
+KYVE,KYVE
+DSNK,DSNK
+CGCS,CGCS
+WTND,WTND
+TKML,TKML
+QHLM,QHLM
+HAMG,HAMG
+APSY,APSY
+LGVQ,LGVQ
+DSIL,DSIL
+LLEW,LLEW
+RDSQ,RDSQ
+NYFR,NYFR
+LWIK,LWIK
+MHME,MHME
+WRFL,WRFL
+DLEN,DLEN
+LSWQ,LSWQ
+WDLC,WDLC
+EAGH,EAGH
+RLRT,RLRT
+WFHL,WFHL
+VLYT,VLYT
+AIFA,AIFA
+MAEL,MAEL
+QPCF,QPCF
+NCCY,NCCY
+DRKQ,DRKQ
+GMQY,GMQY
+PYHE,PYHE
+NKQM,NKQM
+IMQT,IMQT
+LMAV,LMAV
+CIKV,CIKV
+SKLC,SKLC
+SQYW,SQYW
+WPTL,WPTL
+RIAK,RIAK
+PEKT,PEKT
+FTSS,FTSS
+HMGP,HMGP
+HAHK,HAHK
+NQKS,NQKS
+FDIG,FDIG
+WTWV,WTWV
+RQYK,RQYK
+PAGF,PAGF
+MAIL,MAIL
+AGTK,AGTK
+WYEC,WYEC
+AQTR,AQTR
+HPPF,HPPF
+QIDP,QIDP
+PTGW,PTGW
+LYHI,LYHI
+LDII,LDII
+HVMD,HVMD
+HQWP,HQWP
+WGYN,WGYN
+THGQ,THGQ
+DSQW,DSQW
+NFLD,NFLD
+CIVI,CIVI
+MKQR,MKQR
+EYYR,EYYR
+KQLY,KQLY
+PQVK,PQVK
+VIQW,VIQW
+WSRA,WSRA
+YDWH,YDWH
+QVIC,QVIC
+RCQE,RCQE
+GKKL,GKKL
+CDFW,CDFW
+HKCP,HKCP
+HTWG,HTWG
+HWSW,HWSW
+LFWT,LFWT
+DNSY,DNSY
+RISF,RISF
+ELCT,ELCT
+NQIV,NQIV
+LYMV,LYMV
+YSAS,YSAS
+WAKL,WAKL
+NSWN,NSWN
+AYPG,AYPG
+DCMT,DCMT
+QDHH,QDHH
+HNLH,HNLH
+NFCE,NFCE
+QQEC,QQEC
+VWHK,VWHK
+KHMK,KHMK
+GTQI,GTQI
+NPKL,NPKL
+YWVE,YWVE
+PLWT,PLWT
+QIKR,QIKR
+CFCQ,CFCQ
+VAKP,VAKP
+WKWW,WKWW
+CISE,CISE
+SMPI,SMPI
+RGTN,RGTN
+RIPA,RIPA
+LEQE,LEQE
+DCVQ,DCVQ
+VTMD,VTMD
+RTLY,RTLY
+HTNY,HTNY
+SASD,SASD
+KHTN,KHTN
+SLAH,SLAH
+MSKR,MSKR
+AQAI,AQAI
+GTYN,GTYN
+MKCK,MKCK
+PYNN,PYNN
+HCQV,HCQV
+PILK,PILK
+DADI,DADI
+ERPM,ERPM
+LEPE,LEPE
+YYWW,YYWW
+YEHE,YEHE
+MYTM,MYTM
+PPAP,PPAP
+CMSN,CMSN
+WPDT,WPDT
+YIPT,YIPT
+GHWP,GHWP
+CAGT,CAGT
+IRCG,IRCG
+VACC,VACC
+FFQY,FFQY
+INSK,INSK
+NWIP,NWIP
+GERH,GERH
+SDDG,SDDG
+MARL,MARL
+CTAD,CTAD
+CATS,CATS
+WVCY,WVCY
+TSSK,TSSK
+PKVD,PKVD
+FAWE,FAWE
+LSKT,LSKT
+EHAM,EHAM
+LSRK,LSRK
+CFKP,CFKP
+MHRY,MHRY
+QQRF,QQRF
+LWQS,LWQS
+FFSN,FFSN
+EEDD,EEDD
+KQMR,KQMR
+RPPK,RPPK
+PPSV,PPSV
+ETEA,ETEA
+GALG,GALG
+DSPN,DSPN
+PSEH,PSEH
+SIMA,SIMA
+NRQH,NRQH
+SFSA,SFSA
+EIWD,EIWD
+LCPI,LCPI
+YPVE,YPVE
+SKFG,SKFG
+THHE,THHE
+NLGT,NLGT
+VTWD,VTWD
+RVAC,RVAC
+CSFY,CSFY
+QEVY,QEVY
+TRQL,TRQL
+SGHY,SGHY
+GTNS,GTNS
+HQVK,HQVK
+ISWH,ISWH
+VIGC,VIGC
+DWYH,DWYH
+LPQE,LPQE
+PFCQ,PFCQ
+IFNF,IFNF
+QHYH,QHYH
+WRDP,WRDP
+WGVV,WGVV
+SHPK,SHPK
+RTRW,RTRW
+GCTQ,GCTQ
+RKHM,RKHM
+WHIA,WHIA
+ARVC,ARVC
+TCYV,TCYV
+NEWQ,NEWQ
+RHPM,RHPM
+QDWV,QDWV
+YQST,YQST
+LREE,LREE
+QSRY,QSRY
+RIRE,RIRE
+FGMR,FGMR
+IHIP,IHIP
+VWCS,VWCS
+LIYN,LIYN
+MDDQ,MDDQ
+CWND,CWND
+TKQM,TKQM
+THQI,THQI
+VQAN,VQAN
+WVLA,WVLA
+WMGV,WMGV
+CWFF,CWFF
+DFGH,DFGH
+DWHK,DWHK
+EYLG,EYLG
+TSWQ,TSWQ
+DAVT,DAVT
+YLSS,YLSS
+PFLH,PFLH
+NWTC,NWTC
+LHFH,LHFH
+RWDA,RWDA
+IRAN,IRAN
+LRSY,LRSY
+MEHV,MEHV
+GSTQ,GSTQ
+HYTF,HYTF
+TVSC,TVSC
+IDAI,IDAI
+EVMK,EVMK
+TWMD,TWMD
+MDPA,MDPA
+RVHY,RVHY
+CDHM,CDHM
+MTSL,MTSL
+DIIH,DIIH
+ATCF,ATCF
+WAHF,WAHF
+MIHQ,MIHQ
+GYQE,GYQE
+CQDE,CQDE
+HSPC,HSPC
+CSKH,CSKH
+PWCM,PWCM
+YIIE,YIIE
+IDGG,IDGG
+MKTE,MKTE
+TDEP,TDEP
+WTVK,WTVK
+WASA,WASA
+CEGA,CEGA
+CVLH,CVLH
+ETAA,ETAA
+DKYP,DKYP
+THGL,THGL
+AYAW,AYAW
+WESS,WESS
+IIIQ,IIIQ
+QPQR,QPQR
+TCHM,TCHM
+SEAQ,SEAQ
+TVAT,TVAT
+CSFT,CSFT
+KPWY,KPWY
+TAAE,TAAE
+HCKV,HCKV
+HQGG,HQGG
+AVAV,AVAV
+SEGI,SEGI
+PHRP,PHRP
+FFKV,FFKV
+RFEI,RFEI
+SKAR,SKAR
+WCMR,WCMR
+LMYG,LMYG
+VGYK,VGYK
+HFME,HFME
+CNNV,CNNV
+DGIS,DGIS
+QEAC,QEAC
+KKMF,KKMF
+DGQD,DGQD
+GLDP,GLDP
+ELAE,ELAE
+NYYC,NYYC
+PTSI,PTSI
+HYVR,HYVR
+AGKM,AGKM
+YGEG,YGEG
+AGRQ,AGRQ
+PMKC,PMKC
+KWAL,KWAL
+IIEG,IIEG
+RSFF,RSFF
+DAYV,DAYV
+CAYW,CAYW
+FNAS,FNAS
+DMPC,DMPC
+SFEP,SFEP
+YFHF,YFHF
+DEAC,DEAC
+MHIA,MHIA
+FWPH,FWPH
+GTQA,GTQA
+YRMQ,YRMQ
+HGMW,HGMW
+ESAM,ESAM
+WSWY,WSWY
+FNDC,FNDC
+HKES,HKES
+EHFF,EHFF
+PHNT,PHNT
+EMVC,EMVC
+PPFM,PPFM
+CEWC,CEWC
+ECIF,ECIF
+EPEI,EPEI
+PERF,PERF
+HVFL,HVFL
+DLND,DLND
+HTFC,HTFC
+AEDL,AEDL
+PPFG,PPFG
+WPHP,WPHP
+KSVL,KSVL
+MEEK,MEEK
+TAHI,TAHI
+LILA,LILA
+VRGP,VRGP
+DQPM,DQPM
+HKDS,HKDS
+GWNP,GWNP
+TNYH,TNYH
+PKEQ,PKEQ
+RYHA,RYHA
+FHHI,FHHI
+WSQS,WSQS
+PPEL,PPEL
+CCKG,CCKG
+PLPI,PLPI
+CKVK,CKVK
+IVWS,IVWS
+WQVK,WQVK
+YQKA,YQKA
+GWVH,GWVH
+PGQI,PGQI
+YICL,YICL
+NSNA,NSNA
+SLMP,SLMP
+LKNR,LKNR
+NVRQ,NVRQ
+TLAC,TLAC
+EWPH,EWPH
+DCHI,DCHI
+CCSK,CCSK
+IDMV,IDMV
+CYDP,CYDP
+INLI,INLI
+RHVE,RHVE
+MEYY,MEYY
+DTEL,DTEL
+MDSE,MDSE
+EKAI,EKAI
+ICYL,ICYL
+YIWR,YIWR
+PHCI,PHCI
+QQCF,QQCF
+GGTV,GGTV
+KTDV,KTDV
+KCMY,KCMY
+GNMV,GNMV
+FPYS,FPYS
+MPNI,MPNI
+KHIM,KHIM
+DMQN,DMQN
+GRAV,GRAV
+MADN,MADN
+RPCQ,RPCQ
+NANC,NANC
+MSEK,MSEK
+FNNT,FNNT
+TVFH,TVFH
+FSSV,FSSV
+WRYD,WRYD
+GPTV,GPTV
+NQHS,NQHS
+HDSH,HDSH
+IIAA,IIAA
+PVDI,PVDI
+EVTR,EVTR
+GEMY,GEMY
+QMEN,QMEN
+CMMG,CMMG
+KRDN,KRDN
+IAMY,IAMY
+IKKE,IKKE
+NDSA,NDSA
+PWRG,PWRG
+MEGA,MEGA
+KLPK,KLPK
+VGHM,VGHM
+NDGK,NDGK
+DEWH,DEWH
+IKPK,IKPK
+GFYA,GFYA
+TPEL,TPEL
+DPNQ,DPNQ
+CAAG,CAAG
+GGKF,GGKF
+VRPR,VRPR
+KIRL,KIRL
+HYKN,HYKN
+WDRP,WDRP
+YPMP,YPMP
+FKHG,FKHG
+KDCW,KDCW
+WVCW,WVCW
+GCLE,GCLE
+WHKT,WHKT
+RGIW,RGIW
+VNYM,VNYM
+IMWD,IMWD
+MHWW,MHWW
+ETDG,ETDG
+TNKF,TNKF
+NATY,NATY
+PHSS,PHSS
+FMDM,FMDM
+SHDF,SHDF
+PNVW,PNVW
+DDRF,DDRF
+KEDM,KEDM
+FLYK,FLYK
+HPHF,HPHF
+ECWN,ECWN
+FLNT,FLNT
+PRNI,PRNI
+MHTV,MHTV
+CIGK,CIGK
+HMPA,HMPA
+VQDI,VQDI
+SMYF,SMYF
+PFCI,PFCI
+RFWM,RFWM
+MDVL,MDVL
+TWYI,TWYI
+VNGV,VNGV
+CLWD,CLWD
+PWYD,PWYD
+MEYE,MEYE
+CFWW,CFWW
+GMLN,GMLN
+PYWN,PYWN
+QGIM,QGIM
+KTTE,KTTE
+SSPY,SSPY
+VNTY,VNTY
+NKYR,NKYR
+ISWS,ISWS
+AWPE,AWPE
+CLAN,CLAN
+HSIK,HSIK
+WHLQ,WHLQ
+AFMV,AFMV
+EGGM,EGGM
+DCMI,DCMI
+EFIW,EFIW
+QWHL,QWHL
+TVSY,TVSY
+MYKV,MYKV
+HTGE,HTGE
+EFAL,EFAL
+QFAP,QFAP
+QYHC,QYHC
+INDA,INDA
+DGNV,DGNV
+GGRM,GGRM
+NPYQ,NPYQ
+WEVQ,WEVQ
+HMQV,HMQV
+FNGY,FNGY
+ILIE,ILIE
+WCEG,WCEG
+SLQG,SLQG
+MSQT,MSQT
+MYCE,MYCE
+GEQN,GEQN
+GKPV,GKPV
+SEEN,SEEN
+NYPR,NYPR
+CPFK,CPFK
+KWCY,KWCY
+VHYW,VHYW
+PQYN,PQYN
+FWNT,FWNT
+WNQR,WNQR
+WVYV,WVYV
+VLSR,VLSR
+VSEW,VSEW
+MYYD,MYYD
+MKGP,MKGP
+HDFM,HDFM
+YPAA,YPAA
+QPNY,QPNY
+HDSR,HDSR
+LEVR,LEVR
+IVPD,IVPD
+KNFH,KNFH
+PGTF,PGTF
+CAIT,CAIT
+WEWL,WEWL
+YKAA,YKAA
+LRQA,LRQA
+IGKQ,IGKQ
+DQHG,DQHG
+FQQK,FQQK
+EISN,EISN
+HWDC,HWDC
+QNYR,QNYR
+LRSK,LRSK
+IPQL,IPQL
+QTQL,QTQL
+DRYV,DRYV
+QVCV,QVCV
+QVGT,QVGT
+HYRI,HYRI
+NGNW,NGNW
+SSNA,SSNA
+MYME,MYME
+CCHV,CCHV
+TEVD,TEVD
+ESSN,ESSN
+CVHV,CVHV
+WSEF,WSEF
+VRSE,VRSE
+TVRI,TVRI
+LPGK,LPGK
+IRGH,IRGH
+HNYD,HNYD
+MAWA,MAWA
+IAWD,IAWD
+LPCQ,LPCQ
+GCTR,GCTR
+THDF,THDF
+TWYH,TWYH
+PLYV,PLYV
+IDAT,IDAT
+QWMR,QWMR
+IWQS,IWQS
+SFSE,SFSE
+WCHR,WCHR
+NNTH,NNTH
+QPHC,QPHC
+NCMH,NCMH
+TIKL,TIKL
+EVIQ,EVIQ
+FRVV,FRVV
+DATT,DATT
+CYLN,CYLN
+PGER,PGER
+YEYT,YEYT
+WMTL,WMTL
+TRHH,TRHH
+NCCN,NCCN
+HMGV,HMGV
+LWIL,LWIL
+FGQW,FGQW
+IQQM,IQQM
+FALN,FALN
+VNNP,VNNP
+AMAR,AMAR
+MTLK,MTLK
+GVQR,GVQR
+FVEQ,FVEQ
+ANVM,ANVM
+TQHM,TQHM
+VMDD,VMDD
+LANV,LANV
+NLSL,NLSL
+SPTN,SPTN
+GMCT,GMCT
+INKV,INKV
+LCIQ,LCIQ
+VNPT,VNPT
+CKIL,CKIL
+QGRK,QGRK
+IKAS,IKAS
+EWDH,EWDH
+EDNM,EDNM
+DINK,DINK
+LDRY,LDRY
+VEQN,VEQN
+APTA,APTA
+RCAC,RCAC
+KIRK,KIRK
+GCYQ,GCYQ
+LAMP,LAMP
+VGGR,VGGR
+IPAR,IPAR
+PFEY,PFEY
+HQTL,HQTL
+YEHW,YEHW
+AVEG,AVEG
+MGKK,MGKK
+RIVL,RIVL
+VPDM,VPDM
+LLSQ,LLSQ
+GEYW,GEYW
+MQWC,MQWC
+TYTN,TYTN
+RAPP,RAPP
+DSWK,DSWK
+TQTY,TQTY
+PMNL,PMNL
+GDYN,GDYN
+AFHW,AFHW
+VYPL,VYPL
+IIHM,IIHM
+IGFS,IGFS
+SCCA,SCCA
+GSCW,GSCW
+KLNV,KLNV
+KLMQ,KLMQ
+GNDD,GNDD
+MWQC,MWQC
+NHTC,NHTC
+NQWQ,NQWQ
+PLGA,PLGA
+LHTG,LHTG
+IGTG,IGTG
+DKLF,DKLF
+KHEG,KHEG
+HKKD,HKKD
+TVVE,TVVE
+MSLT,MSLT
+RMND,RMND
+YVAL,YVAL
+GRGT,GRGT
+GRNN,GRNN
+HINF,HINF
+QMSP,QMSP
+EWQK,EWQK
+FAWH,FAWH
+HHKH,HHKH
+ALAF,ALAF
+QDKN,QDKN
+LSEK,LSEK
+VLVT,VLVT
+MELV,MELV
+KSDN,KSDN
+SQKC,SQKC
+HYNT,HYNT
+PYLT,PYLT
+GVND,GVND
+VDQW,VDQW
+RFSN,RFSN
+PTPF,PTPF
+NHTY,NHTY
+ADDP,ADDP
+MALD,MALD

data/splits/4AA_implicit_test.csv

@@ -0,0 +1,101 @@
+name,seqres
+EHFR,EHFR
+YVTL,YVTL
+GQGV,GQGV
+PCFK,PCFK
+VVIV,VVIV
+WGDY,WGDY
+SLYW,SLYW
+QGRE,QGRE
+SRPT,SRPT
+NGDS,NGDS
+VNWW,VNWW
+LDNH,LDNH
+WLSC,WLSC
+YYTK,YYTK
+GPNT,GPNT
+LTQE,LTQE
+VMHV,VMHV
+GTLM,GTLM
+QRRW,QRRW
+LRYM,LRYM
+WTWS,WTWS
+VKFG,VKFG
+GQYP,GQYP
+KWIC,KWIC
+PQHG,PQHG
+FLIS,FLIS
+QEGR,QEGR
+ISML,ISML
+HRCS,HRCS
+NNKC,NNKC
+FART,FART
+TIDH,TIDH
+RDTI,RDTI
+ICLP,ICLP
+AMEN,AMEN
+QHFV,QHFV
+GHSS,GHSS
+YNML,YNML
+RHDG,RHDG
+VMVL,VMVL
+QNCG,QNCG
+FRPQ,FRPQ
+FVFN,FVFN
+FCND,FCND
+CETY,CETY
+GYQH,GYQH
+FLRH,FLRH
+IMRY,IMRY
+PIDV,PIDV
+HTIQ,HTIQ
+KDFM,KDFM
+ESSS,ESSS
+ASRE,ASRE
+LCLQ,LCLQ
+IVMA,IVMA
+RVQQ,RVQQ
+KDDD,KDDD
+VQCL,VQCL
+CSYR,CSYR
+SPVN,SPVN
+MIAY,MIAY
+SNSF,SNSF
+TLRK,TLRK
+IAMI,IAMI
+CPYV,CPYV
+NWWG,NWWG
+LQMG,LQMG
+DLCG,DLCG
+LVVF,LVVF
+LWMR,LWMR
+NNDK,NNDK
+EDQK,EDQK
+CACS,CACS
+IWHF,IWHF
+IPTH,IPTH
+VDRN,VDRN
+HELI,HELI
+GGHN,GGHN
+FSDP,FSDP
+CKVH,CKVH
+NTVG,NTVG
+SPFH,SPFH
+FSRK,FSRK
+PYHQ,PYHQ
+FDNT,FDNT
+PKDM,PKDM
+LIFE,LIFE
+ALDA,ALDA
+PGKM,PGKM
+QRNF,QRNF
+SSNN,SSNN
+FKKL,FKKL
+RLKR,RLKR
+KSIY,KSIY
+NFQF,NFQF
+MAFM,MAFM
+AASF,AASF
+CFEE,CFEE
+DHAR,DHAR
+IDRH,IDRH

data/splits/4AA_implicit_train.csv

@@ -0,0 +1,2647 @@
+name,seqres
+EKME,EKME
+YSCA,YSCA
+TGPT,TGPT
+AAKQ,AAKQ
+LQRL,LQRL
+TTLY,TTLY
+VSFH,VSFH
+WYNA,WYNA
+EPWP,EPWP
+DNCQ,DNCQ
+FLHM,FLHM
+WYIG,WYIG
+CQYS,CQYS
+SNCV,SNCV
+DIGN,DIGN
+NYQM,NYQM
+QASA,QASA
+FFRN,FFRN
+WKSH,WKSH
+HEGV,HEGV
+VFWY,VFWY
+QNFH,QNFH
+ISFP,ISFP
+ARGH,ARGH
+CRMN,CRMN
+QNMV,QNMV
+IKQG,IKQG
+PMMV,PMMV
+HILY,HILY
+AQFQ,AQFQ
+MHGM,MHGM
+WMFD,WMFD
+NWPN,NWPN
+HPNK,HPNK
+LRTE,LRTE
+AEAF,AEAF
+FHLQ,FHLQ
+PIAC,PIAC
+KDKI,KDKI
+MKCC,MKCC
+NAWY,NAWY
+YVLE,YVLE
+QKYR,QKYR
+TFIL,TFIL
+DVGL,DVGL
+VNAK,VNAK
+CEIA,CEIA
+CLHA,CLHA
+TPEA,TPEA
+EEKV,EEKV
+GTEV,GTEV
+PYYT,PYYT
+AMQN,AMQN
+KDYC,KDYC
+QNIE,QNIE
+MWLR,MWLR
+AELN,AELN
+TDNF,TDNF
+YPDQ,YPDQ
+PMWQ,PMWQ
+WTIN,WTIN
+TQLE,TQLE
+CWWT,CWWT
+PFGR,PFGR
+KWMG,KWMG
+ICDY,ICDY
+IFWQ,IFWQ
+VGNK,VGNK
+EGSR,EGSR
+KSKE,KSKE
+AQYS,AQYS
+ECDG,ECDG
+AFRN,AFRN
+NLSK,NLSK
+IIDS,IIDS
+MFSG,MFSG
+IING,IING
+IHGP,IHGP
+PEFC,PEFC
+LPRM,LPRM
+VWGW,VWGW
+RAKD,RAKD
+TDRL,TDRL
+PWRH,PWRH
+THKW,THKW
+AQMK,AQMK
+SNYD,SNYD
+KVFQ,KVFQ
+SWML,SWML
+NMHN,NMHN
+VNRT,VNRT
+QHTR,QHTR
+RTHG,RTHG
+MKIF,MKIF
+WAWT,WAWT
+TFIS,TFIS
+AIWE,AIWE
+MINS,MINS
+KNFC,KNFC
+YSME,YSME
+LKTH,LKTH
+PGHR,PGHR
+QCWM,QCWM
+YYFW,YYFW
+GCQH,GCQH
+LFGA,LFGA
+LREV,LREV
+CGCQ,CGCQ
+GQFY,GQFY
+DGDL,DGDL
+IISC,IISC
+GLTR,GLTR
+RGVQ,RGVQ
+DFWH,DFWH
+GFKP,GFKP
+TTNE,TTNE
+FEDH,FEDH
+YTAV,YTAV
+AMVW,AMVW
+NECR,NECR
+PNYQ,PNYQ
+WVLQ,WVLQ
+NPGA,NPGA
+LTYP,LTYP
+GTTS,GTTS
+CPKM,CPKM
+FFIR,FFIR
+KTGN,KTGN
+RGSY,RGSY
+NKNQ,NKNQ
+CWYK,CWYK
+SSRN,SSRN
+KNGD,KNGD
+PECK,PECK
+NRKC,NRKC
+HTAN,HTAN
+KWPM,KWPM
+PDKM,PDKM
+WYVV,WYVV
+GCPK,GCPK
+DRKK,DRKK
+WNWC,WNWC
+PAYK,PAYK
+QKEE,QKEE
+LYGF,LYGF
+GRAR,GRAR
+HFLW,HFLW
+FHSL,FHSL
+HERQ,HERQ
+TMMP,TMMP
+PEMT,PEMT
+LSGH,LSGH
+MPNS,MPNS
+KKYS,KKYS
+WDCD,WDCD
+RSDW,RSDW
+QPAL,QPAL
+EYPW,EYPW
+CFRY,CFRY
+QETE,QETE
+GWDT,GWDT
+HDRQ,HDRQ
+RTNL,RTNL
+IMVW,IMVW
+VKEQ,VKEQ
+HEAH,HEAH
+DEMY,DEMY
+WNLY,WNLY
+SPHG,SPHG
+FQYW,FQYW
+VSDD,VSDD
+SDAK,SDAK
+HLDH,HLDH
+GGMD,GGMD
+PFRW,PFRW
+NMLG,NMLG
+NWSN,NWSN
+TRGN,TRGN
+QICA,QICA
+DHNR,DHNR
+CDKL,CDKL
+ADPG,ADPG
+DHFW,DHFW
+WSSW,WSSW
+ITNH,ITNH
+CACL,CACL
+HFDQ,HFDQ
+FIQA,FIQA
+NQQC,NQQC
+ALCP,ALCP
+GPCV,GPCV
+DFWV,DFWV
+PHPC,PHPC
+AVSM,AVSM
+TSPC,TSPC
+MWLF,MWLF
+HKQL,HKQL
+SAHD,SAHD
+YNQP,YNQP
+PQYL,PQYL
+SHSC,SHSC
+FNCR,FNCR
+DHHE,DHHE
+MIIM,MIIM
+RYPG,RYPG
+PMFI,PMFI
+TIRG,TIRG
+WHEL,WHEL
+ALWP,ALWP
+CMKC,CMKC
+ESTM,ESTM
+EMIR,EMIR
+WKEG,WKEG
+NKPS,NKPS
+FCDI,FCDI
+PAYR,PAYR
+NTGH,NTGH
+GREQ,GREQ
+RHIQ,RHIQ
+KKYC,KKYC
+YSST,YSST
+MNWM,MNWM
+DNTG,DNTG
+NPIF,NPIF
+YLYA,YLYA
+AISE,AISE
+SAAR,SAAR
+WQRL,WQRL
+KIWI,KIWI
+YMKK,YMKK
+IWQA,IWQA
+TLRF,TLRF
+WVNW,WVNW
+QKIH,QKIH
+ENNT,ENNT
+CQAA,CQAA
+RMNL,RMNL
+DCMQ,DCMQ
+GCAE,GCAE
+IYCC,IYCC
+HYGI,HYGI
+LNMQ,LNMQ
+IGNE,IGNE
+CRNA,CRNA
+EWIH,EWIH
+VSRP,VSRP
+RWPF,RWPF
+ADSL,ADSL
+ARRH,ARRH
+GSTY,GSTY
+SITI,SITI
+IVKV,IVKV
+HTPP,HTPP
+QHKL,QHKL
+LDNT,LDNT
+KCWA,KCWA
+KDKA,KDKA
+DMII,DMII
+YDMP,YDMP
+KDNF,KDNF
+RGQA,RGQA
+QSIS,QSIS
+NMSV,NMSV
+METL,METL
+VYAY,VYAY
+VYCP,VYCP
+FIVM,FIVM
+CTRV,CTRV
+FPDC,FPDC
+GSKT,GSKT
+CGFR,CGFR
+TRSH,TRSH
+VSAC,VSAC
+WMEV,WMEV
+SKYM,SKYM
+IEMQ,IEMQ
+KTSE,KTSE
+HFIG,HFIG
+PRTR,PRTR
+WNGE,WNGE
+DFVP,DFVP
+KHDF,KHDF
+WELM,WELM
+KPRK,KPRK
+SLGK,SLGK
+MWKN,MWKN
+NTDY,NTDY
+NKIP,NKIP
+GCQW,GCQW
+CGNR,CGNR
+MDCH,MDCH
+FYEH,FYEH
+NENL,NENL
+TSMR,TSMR
+ETVQ,ETVQ
+NLYD,NLYD
+QSLR,QSLR
+CCNM,CCNM
+TIKC,TIKC
+RPFF,RPFF
+SIVL,SIVL
+ADRN,ADRN
+RVSH,RVSH
+VPTF,VPTF
+IYTM,IYTM
+ENRG,ENRG
+PIRF,PIRF
+SGHT,SGHT
+KFMW,KFMW
+VNVE,VNVE
+DHQD,DHQD
+RKQI,RKQI
+PPFQ,PPFQ
+CYAI,CYAI
+VEGM,VEGM
+PVKV,PVKV
+CGEF,CGEF
+EFET,EFET
+LHGV,LHGV
+CQNM,CQNM
+HHPD,HHPD
+GIDF,GIDF
+DVSH,DVSH
+EQNY,EQNY
+YWVP,YWVP
+SREV,SREV
+CFVK,CFVK
+CSCE,CSCE
+KQFR,KQFR
+GFMM,GFMM
+SDGG,SDGG
+PTVI,PTVI
+KVCK,KVCK
+GDQE,GDQE
+GVNQ,GVNQ
+EHHR,EHHR
+ESYE,ESYE
+MKLK,MKLK
+CKWA,CKWA
+IWGS,IWGS
+RHTY,RHTY
+EHGF,EHGF
+VGFI,VGFI
+YMQM,YMQM
+IQDC,IQDC
+TMFP,TMFP
+YLLA,YLLA
+FNGV,FNGV
+CQWN,CQWN
+IIFC,IIFC
+CYFW,CYFW
+NDCR,NDCR
+WCLH,WCLH
+ICRV,ICRV
+LFVP,LFVP
+MVGK,MVGK
+PDMV,PDMV
+FQWF,FQWF
+LICH,LICH
+WRPF,WRPF
+VEDP,VEDP
+MFAC,MFAC
+WWNS,WWNS
+CGMH,CGMH
+NTVT,NTVT
+YMLC,YMLC
+VTIH,VTIH
+MWML,MWML
+IHIF,IHIF
+RSVW,RSVW
+KFCC,KFCC
+IYSG,IYSG
+IVVS,IVVS
+FWYD,FWYD
+LMVK,LMVK
+LFAS,LFAS
+SVHG,SVHG
+GVDR,GVDR
+VIHW,VIHW
+GNQY,GNQY
+MMVT,MMVT
+DYPH,DYPH
+WHYA,WHYA
+FAIF,FAIF
+MNLG,MNLG
+SSLA,SSLA
+KATL,KATL
+RYCC,RYCC
+HKCL,HKCL
+LDTN,LDTN
+MFIG,MFIG
+HPVY,HPVY
+GPTW,GPTW
+LVMI,LVMI
+KLPT,KLPT
+RLNQ,RLNQ
+IKKN,IKKN
+AQKT,AQKT
+LCEE,LCEE
+FQCR,FQCR
+QSEW,QSEW
+VVWW,VVWW
+TSND,TSND
+SYQF,SYQF
+ATLM,ATLM
+WENR,WENR
+KTVS,KTVS
+GKTK,GKTK
+FFVR,FFVR
+CEEV,CEEV
+MACL,MACL
+MWWT,MWWT
+ICGH,ICGH
+IDQT,IDQT
+QGCS,QGCS
+IVIL,IVIL
+NTKN,NTKN
+DLPK,DLPK
+FRMH,FRMH
+LEWF,LEWF
+RFID,RFID
+PLYY,PLYY
+HIIP,HIIP
+CWMM,CWMM
+HIQQ,HIQQ
+ILEE,ILEE
+YNNA,YNNA
+FRFM,FRFM
+RWTW,RWTW
+NSQL,NSQL
+NMKK,NMKK
+LTSA,LTSA
+ARTD,ARTD
+WCYH,WCYH
+CMWP,CMWP
+PHCS,PHCS
+SPLN,SPLN
+APDW,APDW
+KEGM,KEGM
+SYEV,SYEV
+YCPI,YCPI
+TRVA,TRVA
+RAMI,RAMI
+DLEF,DLEF
+QCTI,QCTI
+YEPV,YEPV
+CWAK,CWAK
+DPDD,DPDD
+TTCK,TTCK
+NESI,NESI
+DGVF,DGVF
+DVYL,DVYL
+NHPH,NHPH
+KRKQ,KRKQ
+FEFA,FEFA
+LDAC,LDAC
+YSQT,YSQT
+TYFF,TYFF
+ALVN,ALVN
+VMVQ,VMVQ
+LVVR,LVVR
+RSWY,RSWY
+QHKQ,QHKQ
+LHEP,LHEP
+ARSK,ARSK
+FPVM,FPVM
+MHVD,MHVD
+RMQL,RMQL
+FDEA,FDEA
+YSIF,YSIF
+MEWG,MEWG
+QIII,QIII
+LIAY,LIAY
+LSPG,LSPG
+LSFH,LSFH
+VWAT,VWAT
+WMKT,WMKT
+SEWR,SEWR
+VAMH,VAMH
+CVGQ,CVGQ
+DAAY,DAAY
+CHYS,CHYS
+IWMF,IWMF
+SRCW,SRCW
+ETMQ,ETMQ
+QHPN,QHPN
+MLEP,MLEP
+YLWR,YLWR
+IHQN,IHQN
+KWPF,KWPF
+SKWK,SKWK
+YIRV,YIRV
+AVKM,AVKM
+SRER,SRER
+KVTF,KVTF
+MART,MART
+HLPC,HLPC
+CGNP,CGNP
+LIHW,LIHW
+WRHE,WRHE
+PLPD,PLPD
+AISH,AISH
+LVGA,LVGA
+GDAN,GDAN
+KFDC,KFDC
+TVYN,TVYN
+EHMH,EHMH
+KEHT,KEHT
+IGSA,IGSA
+HNMM,HNMM
+LWNH,LWNH
+PKYY,PKYY
+CCIM,CCIM
+TIDF,TIDF
+GYTV,GYTV
+LNIN,LNIN
+WRAS,WRAS
+LANP,LANP
+KEYL,KEYL
+PIAT,PIAT
+HNYA,HNYA
+ERTP,ERTP
+TAHS,TAHS
+CMPV,CMPV
+DPHY,DPHY
+HVCL,HVCL
+NRKH,NRKH
+RHCG,RHCG
+AKRV,AKRV
+TSYG,TSYG
+WASS,WASS
+NIDH,NIDH
+WNVC,WNVC
+TLSL,TLSL
+NMWE,NMWE
+LKIY,LKIY
+CVNT,CVNT
+EEAP,EEAP
+MGNK,MGNK
+KDQP,KDQP
+DTRQ,DTRQ
+QVIH,QVIH
+PTKM,PTKM
+FVNA,FVNA
+MTTV,MTTV
+TLDK,TLDK
+NRDV,NRDV
+WYSN,WYSN
+KKEI,KKEI
+VKTG,VKTG
+RTMS,RTMS
+GVTS,GVTS
+QVFG,QVFG
+FSID,FSID
+MCGK,MCGK
+KRYF,KRYF
+FSCA,FSCA
+ENWS,ENWS
+KLPS,KLPS
+WHPD,WHPD
+WERR,WERR
+GVPD,GVPD
+QATI,QATI
+QIRW,QIRW
+VCQD,VCQD
+NHNV,NHNV
+KSPQ,KSPQ
+MQQR,MQQR
+WMYG,WMYG
+YIGK,YIGK
+WAAR,WAAR
+ILEI,ILEI
+EWFS,EWFS
+YAGP,YAGP
+WSWA,WSWA
+WKMM,WKMM
+FWTN,FWTN
+NIRN,NIRN
+EEHP,EEHP
+GKPE,GKPE
+KPLK,KPLK
+EWPS,EWPS
+KLRS,KLRS
+EYWY,EYWY
+CFGR,CFGR
+NEGH,NEGH
+GDRM,GDRM
+VGTI,VGTI
+YCGL,YCGL
+EVMG,EVMG
+PQNW,PQNW
+QVQH,QVQH
+NTPI,NTPI
+VMVI,VMVI
+RHAT,RHAT
+RVCM,RVCM
+LSIN,LSIN
+ATKL,ATKL
+PSNL,PSNL
+WESL,WESL
+QPDG,QPDG
+YRFL,YRFL
+RTPP,RTPP
+IVKA,IVKA
+VVPK,VVPK
+YKPE,YKPE
+FHFW,FHFW
+TRLH,TRLH
+ITSL,ITSL
+GEIE,GEIE
+FGGQ,FGGQ
+SSPD,SSPD
+TWHQ,TWHQ
+GEDR,GEDR
+HNEC,HNEC
+PQNL,PQNL
+ECNQ,ECNQ
+TSEQ,TSEQ
+RLVW,RLVW
+RDNT,RDNT
+QMAH,QMAH
+NVFD,NVFD
+YHYT,YHYT
+PMNY,PMNY
+MGML,MGML
+AFYE,AFYE
+EGLV,EGLV
+PGLP,PGLP
+YNFY,YNFY
+KTAC,KTAC
+YHMC,YHMC
+IATA,IATA
+LPDV,LPDV
+LIAS,LIAS
+DDLY,DDLY
+MQNA,MQNA
+HISP,HISP
+VKIN,VKIN
+LGNP,LGNP
+SCGK,SCGK
+MKED,MKED
+VAWY,VAWY
+HWPF,HWPF
+LMPY,LMPY
+QICW,QICW
+CPCR,CPCR
+RSYT,RSYT
+NLYT,NLYT
+KIHC,KIHC
+LMCP,LMCP
+VTEC,VTEC
+WSWH,WSWH
+SSYR,SSYR
+FTQN,FTQN
+NRML,NRML
+SFFL,SFFL
+QRTP,QRTP
+VPII,VPII
+MYEK,MYEK
+TSTF,TSTF
+PKYM,PKYM
+IITN,IITN
+HPVW,HPVW
+VNLP,VNLP
+SVKP,SVKP
+CDKP,CDKP
+FDWC,FDWC
+AKSF,AKSF
+LYYM,LYYM
+EDWE,EDWE
+QDET,QDET
+YACA,YACA
+QMWK,QMWK
+IIMH,IIMH
+QCTC,QCTC
+PMHG,PMHG
+ECKA,ECKA
+KQYL,KQYL
+SPCL,SPCL
+MQEK,MQEK
+LIAN,LIAN
+SCDL,SCDL
+NDFP,NDFP
+QKGE,QKGE
+HNDV,HNDV
+HHHE,HHHE
+AWNV,AWNV
+SPSG,SPSG
+LRIA,LRIA
+IVID,IVID
+YQYS,YQYS
+DGTP,DGTP
+DTTL,DTTL
+HWDN,HWDN
+DGNC,DGNC
+QGEG,QGEG
+SNPP,SNPP
+KVSH,KVSH
+WLWV,WLWV
+LMMA,LMMA
+MGCM,MGCM
+LNKP,LNKP
+TPIG,TPIG
+WEWH,WEWH
+QCVC,QCVC
+RMKF,RMKF
+MDDE,MDDE
+PGPQ,PGPQ
+DVTF,DVTF
+DKCT,DKCT
+ECRP,ECRP
+CCGP,CCGP
+RFVF,RFVF
+LMNC,LMNC
+TICP,TICP
+AKWL,AKWL
+MTPT,MTPT
+NTVY,NTVY
+KNRS,KNRS
+CYIT,CYIT
+IAGE,IAGE
+ICKI,ICKI
+GQAS,GQAS
+RNFR,RNFR
+SAQL,SAQL
+ICMM,ICMM
+NVED,NVED
+RLSM,RLSM
+INMV,INMV
+FGRY,FGRY
+RGRW,RGRW
+CNNG,CNNG
+YGES,YGES
+YLCN,YLCN
+PASK,PASK
+LYIT,LYIT
+PLPM,PLPM
+GDMM,GDMM
+TQER,TQER
+MTHR,MTHR
+NKCN,NKCN
+NDQA,NDQA
+FIWM,FIWM
+ATER,ATER
+ISVY,ISVY
+HVTG,HVTG
+RPSV,RPSV
+SGET,SGET
+TNGR,TNGR
+SFLC,SFLC
+PPRD,PPRD
+AWKW,AWKW
+DLCW,DLCW
+RFFC,RFFC
+VIQR,VIQR
+KIPG,KIPG
+SRPE,SRPE
+LMMY,LMMY
+YDTM,YDTM
+MTIG,MTIG
+GSHI,GSHI
+NCRV,NCRV
+KPDS,KPDS
+CNNL,CNNL
+MGVK,MGVK
+GWED,GWED
+TYHW,TYHW
+NMVM,NMVM
+EHFA,EHFA
+SVCM,SVCM
+THET,THET
+QGYR,QGYR
+NTDC,NTDC
+ETST,ETST
+MLSM,MLSM
+YRRQ,YRRQ
+VWEA,VWEA
+PFYW,PFYW
+TIEI,TIEI
+ECCQ,ECCQ
+SVDV,SVDV
+RYKY,RYKY
+AMDS,AMDS
+DMMK,DMMK
+AMKE,AMKE
+GNHG,GNHG
+DVPC,DVPC
+IQVY,IQVY
+FNDE,FNDE
+HTLS,HTLS
+DFIG,DFIG
+PVMD,PVMD
+RAMS,RAMS
+IASS,IASS
+DMKH,DMKH
+KYPS,KYPS
+PVQF,PVQF
+SWPS,SWPS
+EQCI,EQCI
+CNMV,CNMV
+MVVG,MVVG
+SVDI,SVDI
+RRRN,RRRN
+AFSS,AFSS
+PAQD,PAQD
+QATV,QATV
+GFCR,GFCR
+FNYS,FNYS
+VNWN,VNWN
+PMIH,PMIH
+VDYL,VDYL
+VICL,VICL
+KYGL,KYGL
+FHIK,FHIK
+VVNY,VVNY
+TYYT,TYYT
+DLPN,DLPN
+RNGI,RNGI
+FFGV,FFGV
+EIQM,EIQM
+HRNL,HRNL
+FHGM,FHGM
+PQVA,PQVA
+WIVH,WIVH
+PTWK,PTWK
+MFHD,MFHD
+FHST,FHST
+NMHA,NMHA
+KSPI,KSPI
+DDTI,DDTI
+DVQS,DVQS
+KGAT,KGAT
+RITF,RITF
+PNPL,PNPL
+VICS,VICS
+EDMF,EDMF
+ESID,ESID
+VESG,VESG
+EKEN,EKEN
+KAYY,KAYY
+LMPW,LMPW
+ANLI,ANLI
+CALR,CALR
+KMGI,KMGI
+NEAE,NEAE
+QAIC,QAIC
+NKQE,NKQE
+IRTF,IRTF
+TCQN,TCQN
+RPAY,RPAY
+GTHQ,GTHQ
+HVCH,HVCH
+GVQA,GVQA
+KQTA,KQTA
+NWSA,NWSA
+GLSC,GLSC
+SPRS,SPRS
+EDHW,EDHW
+YHMA,YHMA
+QFIR,QFIR
+LKYW,LKYW
+VRMD,VRMD
+TPNP,TPNP
+LFCF,LFCF
+CEVE,CEVE
+MDDA,MDDA
+HNYT,HNYT
+WPVP,WPVP
+TTAV,TTAV
+RTRI,RTRI
+AYAG,AYAG
+DYDT,DYDT
+GEQE,GEQE
+EGSA,EGSA
+LEMF,LEMF
+IEFW,IEFW
+PIQS,PIQS
+EAMT,EAMT
+QCNI,QCNI
+QNGS,QNGS
+CFNL,CFNL
+QQSV,QQSV
+TCPN,TCPN
+SWSR,SWSR
+RTYL,RTYL
+YPAE,YPAE
+GLMQ,GLMQ
+QCHI,QCHI
+IGIR,IGIR
+ICPI,ICPI
+CDFV,CDFV
+PISQ,PISQ
+QYQM,QYQM
+DFHH,DFHH
+FVHV,FVHV
+RKSK,RKSK
+STLE,STLE
+MKLD,MKLD
+AAYG,AAYG
+LHNG,LHNG
+RWCV,RWCV
+QCWF,QCWF
+CKSK,CKSK
+QIGA,QIGA
+SFKL,SFKL
+PFLN,PFLN
+TGPF,TGPF
+HTEE,HTEE
+PDFH,PDFH
+IFIM,IFIM
+ITCK,ITCK
+SKKP,SKKP
+QLMD,QLMD
+NLYY,NLYY
+EVHQ,EVHQ
+TSLV,TSLV
+GRHR,GRHR
+HYQF,HYQF
+LSGA,LSGA
+IAPM,IAPM
+GEIN,GEIN
+GLRD,GLRD
+TDNC,TDNC
+NMTH,NMTH
+DHLQ,DHLQ
+GLQA,GLQA
+FNEP,FNEP
+KHSF,KHSF
+FKKS,FKKS
+DIMC,DIMC
+HWVN,HWVN
+RNFI,RNFI
+HDEG,HDEG
+WVVN,WVVN
+EQKE,EQKE
+SCFD,SCFD
+ADRR,ADRR
+TVAF,TVAF
+RVDC,RVDC
+YFNI,YFNI
+NGMW,NGMW
+EKFN,EKFN
+NFII,NFII
+SAFS,SAFS
+NNNY,NNNY
+PFGK,PFGK
+SGMK,SGMK
+SHTM,SHTM
+HDNH,HDNH
+EWWP,EWWP
+PFKH,PFKH
+WSYL,WSYL
+IHSC,IHSC
+YYED,YYED
+HCMW,HCMW
+RNKR,RNKR
+CRNH,CRNH
+HPVR,HPVR
+TKLY,TKLY
+NNSK,NNSK
+SPIQ,SPIQ
+KWQV,KWQV
+INEP,INEP
+TCQL,TCQL
+VKRD,VKRD
+VPHC,VPHC
+GNAN,GNAN
+IVNE,IVNE
+GMYD,GMYD
+VTLF,VTLF
+INSN,INSN
+EQKH,EQKH
+IRKL,IRKL
+APIY,APIY
+SPSP,SPSP
+TWKI,TWKI
+TWTC,TWTC
+SFSI,SFSI
+CSHN,CSHN
+RHCA,RHCA
+WTEF,WTEF
+SNCQ,SNCQ
+SLME,SLME
+GHEW,GHEW
+EMPE,EMPE
+ADFS,ADFS
+GHHS,GHHS
+HGMC,HGMC
+LWWR,LWWR
+NVSG,NVSG
+IVKI,IVKI
+YNHE,YNHE
+CPGT,CPGT
+LAKQ,LAKQ
+KNRG,KNRG
+DFGC,DFGC
+WNAI,WNAI
+SKCN,SKCN
+FYSC,FYSC
+CTIY,CTIY
+CSDP,CSDP
+CHTN,CHTN
+FWKT,FWKT
+DWQH,DWQH
+HWCS,HWCS
+WWLW,WWLW
+HADL,HADL
+RITQ,RITQ
+SREP,SREP
+VQIF,VQIF
+HMPQ,HMPQ
+TFFD,TFFD
+KGMF,KGMF
+DKVN,DKVN
+YWKS,YWKS
+LHLT,LHLT
+WHDD,WHDD
+WALN,WALN
+QSQH,QSQH
+DFIT,DFIT
+IGRW,IGRW
+SKVS,SKVS
+MDSD,MDSD
+HPER,HPER
+CRDW,CRDW
+WECW,WECW
+DWEI,DWEI
+DCDT,DCDT
+SWIH,SWIH
+VQGR,VQGR
+DPTP,DPTP
+PHDF,PHDF
+HHTM,HHTM
+DLYK,DLYK
+CLIQ,CLIQ
+APYR,APYR
+CPQV,CPQV
+RLYF,RLYF
+SSLI,SSLI
+FAEQ,FAEQ
+ELQC,ELQC
+ARFI,ARFI
+SQTV,SQTV
+SWHG,SWHG
+TNSD,TNSD
+HPCP,HPCP
+AFAN,AFAN
+KAHA,KAHA
+AMSN,AMSN
+VPMS,VPMS
+FRDK,FRDK
+STCQ,STCQ
+GIMS,GIMS
+ICRN,ICRN
+IYAG,IYAG
+VWSY,VWSY
+QAFG,QAFG
+NNCH,NNCH
+GGNN,GGNN
+HVMA,HVMA
+KGRI,KGRI
+LAFF,LAFF
+KCDN,KCDN
+RFVY,RFVY
+EYKW,EYKW
+ASIR,ASIR
+HPGV,HPGV
+AKDI,AKDI
+KDNH,KDNH
+KKLH,KKLH
+LCLD,LCLD
+MLTD,MLTD
+LAQY,LAQY
+EPFC,EPFC
+VRRL,VRRL
+FSNW,FSNW
+WDEK,WDEK
+YDDY,YDDY
+LNQE,LNQE
+NLHN,NLHN
+SLRQ,SLRQ
+AFAT,AFAT
+INVT,INVT
+YYNC,YYNC
+TMKL,TMKL
+AIKI,AIKI
+GALS,GALS
+IIML,IIML
+MQRK,MQRK
+KAWH,KAWH
+KWYI,KWYI
+MKIP,MKIP
+CLLI,CLLI
+HHCW,HHCW
+WWFP,WWFP
+ISTG,ISTG
+KYGD,KYGD
+RPCK,RPCK
+QMGG,QMGG
+DARI,DARI
+PMCE,PMCE
+VYIV,VYIV
+VHEY,VHEY
+QMCG,QMCG
+CLVL,CLVL
+EKCS,EKCS
+IKVP,IKVP
+DNRP,DNRP
+WLCW,WLCW
+RSNE,RSNE
+QKLT,QKLT
+TEND,TEND
+FMFY,FMFY
+QYKD,QYKD
+HQTR,HQTR
+ALVT,ALVT
+NGSN,NGSN
+EALD,EALD
+MPWC,MPWC
+GGMI,GGMI
+VIRS,VIRS
+LSSM,LSSM
+SYAY,SYAY
+CVVM,CVVM
+WTNV,WTNV
+TVFM,TVFM
+DECF,DECF
+RETI,RETI
+IMTD,IMTD
+MQDV,MQDV
+GNEP,GNEP
+RFMC,RFMC
+GGLH,GGLH
+PKFI,PKFI
+NGQG,NGQG
+TFKL,TFKL
+SRYN,SRYN
+FFSS,FFSS
+CKET,CKET
+DDCM,DDCM
+WRVY,WRVY
+RGTH,RGTH
+WWNN,WWNN
+NMGV,NMGV
+GFAE,GFAE
+MMPT,MMPT
+YIQY,YIQY
+TNSF,TNSF
+HHDM,HHDM
+DQMG,DQMG
+LHPN,LHPN
+PWEA,PWEA
+KGVA,KGVA
+DRRI,DRRI
+DFVM,DFVM
+WDVE,WDVE
+SQYV,SQYV
+GDIA,GDIA
+STMC,STMC
+CTLK,CTLK
+INYK,INYK
+DAVY,DAVY
+SAAE,SAAE
+NQPC,NQPC
+VGHL,VGHL
+TSVY,TSVY
+IDQL,IDQL
+ETDI,ETDI
+FCCD,FCCD
+SRGC,SRGC
+IHND,IHND
+HKYL,HKYL
+NQPS,NQPS
+YWAE,YWAE
+SDNQ,SDNQ
+ISEG,ISEG
+NATM,NATM
+NGCV,NGCV
+YNTC,YNTC
+FFKA,FFKA
+CTTS,CTTS
+EEAD,EEAD
+KHAQ,KHAQ
+STQQ,STQQ
+MMTS,MMTS
+HDHV,HDHV
+KGLQ,KGLQ
+PKAM,PKAM
+DQVY,DQVY
+QQHD,QQHD
+QQLR,QQLR
+YCEQ,YCEQ
+YYGY,YYGY
+RLRR,RLRR
+VRYS,VRYS
+ESHL,ESHL
+DYGS,DYGS
+ITKD,ITKD
+VTDQ,VTDQ
+GLYK,GLYK
+FNAL,FNAL
+HMHG,HMHG
+TDVT,TDVT
+VSGS,VSGS
+FSER,FSER
+MHAN,MHAN
+WYEG,WYEG
+PCRG,PCRG
+DIEM,DIEM
+ESNY,ESNY
+HYHD,HYHD
+VFCC,VFCC
+DSYW,DSYW
+AQQM,AQQM
+CYCW,CYCW
+GKWK,GKWK
+GRSD,GRSD
+QEKH,QEKH
+LPLF,LPLF
+YPYG,YPYG
+YDYS,YDYS
+TSHA,TSHA
+KMIK,KMIK
+ACWG,ACWG
+TGEQ,TGEQ
+PHKQ,PHKQ
+VGKH,VGKH
+GHQI,GHQI
+QPPG,QPPG
+TYEF,TYEF
+GHHY,GHHY
+SLSL,SLSL
+ARNE,ARNE
+DATD,DATD
+LAND,LAND
+QIQA,QIQA
+EHYP,EHYP
+CASL,CASL
+EPSF,EPSF
+VELW,VELW
+YERL,YERL
+DEKS,DEKS
+NQMW,NQMW
+WMHS,WMHS
+KNMV,KNMV
+QTIW,QTIW
+TQDA,TQDA
+PYGD,PYGD
+SFMV,SFMV
+GHCR,GHCR
+TFIR,TFIR
+YAEP,YAEP
+IYTY,IYTY
+FSEY,FSEY
+FINQ,FINQ
+CGKE,CGKE
+DDCQ,DDCQ
+FDEE,FDEE
+EMLR,EMLR
+CKFY,CKFY
+KRHR,KRHR
+RNVV,RNVV
+CVAP,CVAP
+GFQD,GFQD
+YSHN,YSHN
+FDRF,FDRF
+AEQN,AEQN
+VFEW,VFEW
+ETTF,ETTF
+MSME,MSME
+GNSW,GNSW
+YTGA,YTGA
+DYRD,DYRD
+CMQY,CMQY
+TCCW,TCCW
+MHEG,MHEG
+IDIK,IDIK
+MMKE,MMKE
+MVDE,MVDE
+PECI,PECI
+MLPV,MLPV
+AKEK,AKEK
+MTTY,MTTY
+NFHF,NFHF
+KVCV,KVCV
+PSSQ,PSSQ
+ILSQ,ILSQ
+RGCN,RGCN
+SLLK,SLLK
+TISM,TISM
+CKNM,CKNM
+HMFA,HMFA
+NEPY,NEPY
+FIWR,FIWR
+ACGP,ACGP
+CMIN,CMIN
+YQSH,YQSH
+TKRK,TKRK
+KKMP,KKMP
+HDGN,HDGN
+ANDY,ANDY
+HDWG,HDWG
+CGEE,CGEE
+FYLE,FYLE
+ICVE,ICVE
+KGWY,KGWY
+FVQW,FVQW
+QQVE,QQVE
+NCRD,NCRD
+DLFD,DLFD
+IVRM,IVRM
+FIWK,FIWK
+YLCY,YLCY
+SWMY,SWMY
+QWDN,QWDN
+DEGK,DEGK
+RPIK,RPIK
+AMFA,AMFA
+QTCQ,QTCQ
+NTKK,NTKK
+SCLE,SCLE
+LPME,LPME
+SEYY,SEYY
+WWRY,WWRY
+DDNS,DDNS
+EKNR,EKNR
+PKIQ,PKIQ
+LRTG,LRTG
+NANG,NANG
+SMNT,SMNT
+GHVQ,GHVQ
+KAPS,KAPS
+QHNC,QHNC
+RQAQ,RQAQ
+TAKP,TAKP
+GSCG,GSCG
+DYGD,DYGD
+GTSS,GTSS
+ALYP,ALYP
+TDER,TDER
+HYPN,HYPN
+ERAS,ERAS
+RMSP,RMSP
+CIMM,CIMM
+EYTT,EYTT
+YSEC,YSEC
+LLGP,LLGP
+PEAA,PEAA
+NQGY,NQGY
+HQPP,HQPP
+NRTP,NRTP
+LALL,LALL
+TPGN,TPGN
+LEIA,LEIA
+WEEA,WEEA
+GVAG,GVAG
+TCRA,TCRA
+KVDG,KVDG
+CMVY,CMVY
+CHMI,CHMI
+GGYF,GGYF
+MPTV,MPTV
+GNNK,GNNK
+GEIA,GEIA
+SHPY,SHPY
+PMRM,PMRM
+GRTR,GRTR
+PHEM,PHEM
+IYEL,IYEL
+FCDK,FCDK
+IYSF,IYSF
+NRDP,NRDP
+AHGE,AHGE
+MMYF,MMYF
+YKQE,YKQE
+GKFT,GKFT
+IENN,IENN
+HAHG,HAHG
+KVEH,KVEH
+VILD,VILD
+FSFE,FSFE
+LVHQ,LVHQ
+LICG,LICG
+WSEM,WSEM
+FHTK,FHTK
+WCSE,WCSE
+VDGM,VDGM
+VVYE,VVYE
+HPWQ,HPWQ
+PDAY,PDAY
+AGIA,AGIA
+HCGK,HCGK
+SAVI,SAVI
+EKHK,EKHK
+ICPA,ICPA
+RWFE,RWFE
+WHDE,WHDE
+QIRD,QIRD
+QKPK,QKPK
+TQCF,TQCF
+GVMW,GVMW
+QGGM,QGGM
+CREN,CREN
+ASAL,ASAL
+VRTV,VRTV
+DVAV,DVAV
+EFWC,EFWC
+EHMY,EHMY
+VWHM,VWHM
+FSLN,FSLN
+KYLA,KYLA
+QETP,QETP
+DDAG,DDAG
+ILAV,ILAV
+SSNL,SSNL
+CCNW,CCNW
+KPAI,KPAI
+WTVI,WTVI
+KQHA,KQHA
+QVRI,QVRI
+CRVT,CRVT
+PHQM,PHQM
+AEMH,AEMH
+HHYG,HHYG
+MSCY,MSCY
+EHLG,EHLG
+EPPA,EPPA
+AQIM,AQIM
+CNII,CNII
+NADT,NADT
+MHKK,MHKK
+EDFY,EDFY
+CPLP,CPLP
+LVDD,LVDD
+YFKR,YFKR
+DFID,DFID
+KKQF,KKQF
+VDNK,VDNK
+WWWQ,WWWQ
+VECI,VECI
+TIEG,TIEG
+TWRG,TWRG
+SANG,SANG
+YWFC,YWFC
+HCFS,HCFS
+SWFN,SWFN
+QQLK,QQLK
+HPYR,HPYR
+QDLI,QDLI
+HYTL,HYTL
+QSAM,QSAM
+LASK,LASK
+VDAW,VDAW
+LTGH,LTGH
+VCFH,VCFH
+QNGD,QNGD
+WMAR,WMAR
+CCLC,CCLC
+HSQV,HSQV
+KEWG,KEWG
+PWHA,PWHA
+HAPI,HAPI
+TAQW,TAQW
+PRNF,PRNF
+ADIG,ADIG
+DYLC,DYLC
+WYLN,WYLN
+IQEP,IQEP
+RNGR,RNGR
+QWQY,QWQY
+GIWI,GIWI
+MGTS,MGTS
+NRTE,NRTE
+MEEF,MEEF
+DNWK,DNWK
+HCMM,HCMM
+YATS,YATS
+QMQW,QMQW
+CWKE,CWKE
+NVSW,NVSW
+NIRC,NIRC
+RFVD,RFVD
+KGFK,KGFK
+SWTE,SWTE
+WMAY,WMAY
+NFLA,NFLA
+CHTP,CHTP
+HRMT,HRMT
+LDVQ,LDVQ
+HSLA,HSLA
+FSLW,FSLW
+RPNY,RPNY
+DCME,DCME
+RESY,RESY
+TKRF,TKRF
+TVHS,TVHS
+YPKI,YPKI
+VQYS,VQYS
+YHLW,YHLW
+EYQD,EYQD
+AQHV,AQHV
+VDQD,VDQD
+VEWT,VEWT
+NSLC,NSLC
+QFCW,QFCW
+AHCC,AHCC
+TSLH,TSLH
+ICSC,ICSC
+RGGL,RGGL
+QNEW,QNEW
+LAEL,LAEL
+CIDA,CIDA
+DKEP,DKEP
+NPYL,NPYL
+LPSA,LPSA
+NPKC,NPKC
+QVLV,QVLV
+DIWW,DIWW
+AQCR,AQCR
+ALNH,ALNH
+PQTE,PQTE
+QSHE,QSHE
+IDLS,IDLS
+WSKM,WSKM
+CHQI,CHQI
+INRL,INRL
+VIVA,VIVA
+VPYG,VPYG
+LFPL,LFPL
+SPDA,SPDA
+PTVC,PTVC
+HPVD,HPVD
+PNIY,PNIY
+FPYF,FPYF
+LSLS,LSLS
+PPSS,PPSS
+GSYS,GSYS
+ADCD,ADCD
+DTEI,DTEI
+VLMD,VLMD
+FWGY,FWGY
+HLWE,HLWE
+NCHC,NCHC
+WIQM,WIQM
+FAMD,FAMD
+CCKQ,CCKQ
+EMKY,EMKY
+HRMM,HRMM
+DRYC,DRYC
+LPHQ,LPHQ
+HPQC,HPQC
+TYMI,TYMI
+HPQM,HPQM
+CCWI,CCWI
+MPNQ,MPNQ
+IMIT,IMIT
+TWAR,TWAR
+HVVL,HVVL
+CSSG,CSSG
+PAEM,PAEM
+MHWD,MHWD
+QVYE,QVYE
+QCNV,QCNV
+RYDQ,RYDQ
+QILA,QILA
+ANYR,ANYR
+VNGE,VNGE
+WKPR,WKPR
+LVMT,LVMT
+HNIR,HNIR
+FFNS,FFNS
+GSRR,GSRR
+VTVI,VTVI
+PMML,PMML
+ECTM,ECTM
+CNHN,CNHN
+QSHA,QSHA
+AFNV,AFNV
+DKAD,DKAD
+WALC,WALC
+CNRV,CNRV
+MFKT,MFKT
+DIVY,DIVY
+VPES,VPES
+PLEW,PLEW
+HSCT,HSCT
+SHGA,SHGA
+TTET,TTET
+PIQW,PIQW
+DLTL,DLTL
+VPLE,VPLE
+VLTG,VLTG
+KCNM,KCNM
+IDCY,IDCY
+DSPK,DSPK
+PDKC,PDKC
+WTCY,WTCY
+RIMR,RIMR
+VNPA,VNPA
+FVDP,FVDP
+RPDP,RPDP
+TLEF,TLEF
+DLNF,DLNF
+CVES,CVES
+WKWF,WKWF
+PNMI,PNMI
+DIVA,DIVA
+GKWC,GKWC
+HDYC,HDYC
+HAMN,HAMN
+TEPW,TEPW
+VYHI,VYHI
+MTHE,MTHE
+IGYD,IGYD
+PARW,PARW
+FQCG,FQCG
+MLSF,MLSF
+NGFG,NGFG
+YDMF,YDMF
+ATVW,ATVW
+PFHY,PFHY
+QYTG,QYTG
+KISE,KISE
+WPSR,WPSR
+LLIN,LLIN
+CMIF,CMIF
+NKKT,NKKT
+PLYW,PLYW
+QQFN,QQFN
+SQMQ,SQMQ
+AWQH,AWQH
+RDCC,RDCC
+YRWA,YRWA
+PGCG,PGCG
+STHQ,STHQ
+EQFS,EQFS
+KWVH,KWVH
+PDVA,PDVA
+LCVI,LCVI
+LTIN,LTIN
+VYEM,VYEM
+DYRG,DYRG
+GSRP,GSRP
+IYFQ,IYFQ
+LYNA,LYNA
+QFWL,QFWL
+LTAF,LTAF
+KEDA,KEDA
+HVPF,HVPF
+GQSM,GQSM
+YRHQ,YRHQ
+QDCH,QDCH
+PEMD,PEMD
+QPTI,QPTI
+NGNG,NGNG
+NQNL,NQNL
+KYEH,KYEH
+TQFF,TQFF
+FPFA,FPFA
+AQLP,AQLP
+CTHE,CTHE
+VAVM,VAVM
+KPLY,KPLY
+SSLF,SSLF
+MIRW,MIRW
+RAHP,RAHP
+VREH,VREH
+NAMG,NAMG
+FKKQ,FKKQ
+KQRA,KQRA
+LIFD,LIFD
+YRPE,YRPE
+TFAD,TFAD
+QIAA,QIAA
+INFW,INFW
+CRKA,CRKA
+GDAV,GDAV
+HETY,HETY
+GVGT,GVGT
+NDIP,NDIP
+CRSM,CRSM
+HTGT,HTGT
+STMK,STMK
+EQGS,EQGS
+TMQM,TMQM
+ENKD,ENKD
+KAFL,KAFL
+LRLK,LRLK
+VSPT,VSPT
+AHLV,AHLV
+CYHE,CYHE
+RLWK,RLWK
+LYWK,LYWK
+SATM,SATM
+PMSW,PMSW
+NTYF,NTYF
+EDHE,EDHE
+MMIQ,MMIQ
+KGPY,KGPY
+TCRP,TCRP
+TSKR,TSKR
+EVDV,EVDV
+QWRH,QWRH
+TYTI,TYTI
+NRFT,NRFT
+FRPY,FRPY
+LLPI,LLPI
+FGPP,FGPP
+PHYI,PHYI
+CMCK,CMCK
+NMPI,NMPI
+GQFR,GQFR
+NQER,NQER
+LMKS,LMKS
+ENCI,ENCI
+TNNV,TNNV
+GRAM,GRAM
+AAMV,AAMV
+IFYL,IFYL
+EKIL,EKIL
+QMAP,QMAP
+RYGL,RYGL
+NQAI,NQAI
+LYSR,LYSR
+DRES,DRES
+PTHS,PTHS
+TLDQ,TLDQ
+KEYH,KEYH
+HDWC,HDWC
+RPQT,RPQT
+PMNG,PMNG
+GWVS,GWVS
+PQEW,PQEW
+QRRP,QRRP
+CEIQ,CEIQ
+WNKY,WNKY
+FRVE,FRVE
+PTYH,PTYH
+LCRD,LCRD
+MEWQ,MEWQ
+QMNY,QMNY
+NFDK,NFDK
+QRKH,QRKH
+YLSR,YLSR
+MVRG,MVRG
+IQQH,IQQH
+RMEE,RMEE
+HYDN,HYDN
+KMSH,KMSH
+LWEL,LWEL
+WYLC,WYLC
+NGLM,NGLM
+QWPS,QWPS
+WFMM,WFMM
+KFEY,KFEY
+CQMT,CQMT
+GHFL,GHFL
+TERR,TERR
+VFGH,VFGH
+NRRF,NRRF
+RMRM,RMRM
+ITAK,ITAK
+WQWH,WQWH
+MQLP,MQLP
+LTSP,LTSP
+VEYQ,VEYQ
+YYHP,YYHP
+KDHH,KDHH
+PETW,PETW
+HDEA,HDEA
+WSMV,WSMV
+YITL,YITL
+FLQY,FLQY
+LLDM,LLDM
+IEHF,IEHF
+KVWR,KVWR
+THAR,THAR
+VREK,VREK
+SARM,SARM
+FSKI,FSKI
+NCTQ,NCTQ
+VEGT,VEGT
+SIKV,SIKV
+WSTR,WSTR
+NTQD,NTQD
+DNDN,DNDN
+SGFT,SGFT
+YRLW,YRLW
+KNWK,KNWK
+AVKA,AVKA
+APIK,APIK
+YDSL,YDSL
+TNHT,TNHT
+HYKY,HYKY
+SDNK,SDNK
+GAMQ,GAMQ
+PWIH,PWIH
+SYQG,SYQG
+CPDS,CPDS
+TGFQ,TGFQ
+YLNI,YLNI
+NVFM,NVFM
+TIDN,TIDN
+ATTP,ATTP
+GGGT,GGGT
+CHAG,CHAG
+NMNG,NMNG
+QLRT,QLRT
+LKWC,LKWC
+CDDQ,CDDQ
+YHGR,YHGR
+LEPK,LEPK
+QANG,QANG
+IDCV,IDCV
+FYYH,FYYH
+MHDH,MHDH
+YSQC,YSQC
+EYFL,EYFL
+HLIS,HLIS
+IQDK,IQDK
+HSIE,HSIE
+EKFK,EKFK
+EGKE,EGKE
+TMNI,TMNI
+SSQA,SSQA
+SASM,SASM
+ECIL,ECIL
+VRAD,VRAD
+EQLS,EQLS
+WKPD,WKPD
+HKWC,HKWC
+RQDW,RQDW
+YEFT,YEFT
+RPMP,RPMP
+FLCK,FLCK
+MMGK,MMGK
+FAYK,FAYK
+TFHN,TFHN
+PYFA,PYFA
+QSDI,QSDI
+MRQR,MRQR
+NGVY,NGVY
+KYLC,KYLC
+NAFE,NAFE
+HMYC,HMYC
+YDQM,YDQM
+WKMF,WKMF
+SRFI,SRFI
+YRQK,YRQK
+GIMY,GIMY
+GYMS,GYMS
+FCME,FCME
+IRFT,IRFT
+NWHA,NWHA
+MLWS,MLWS
+RHFG,RHFG
+WIMA,WIMA
+PAEF,PAEF
+CHTE,CHTE
+MEIK,MEIK
+AILP,AILP
+PQSC,PQSC
+SAHG,SAHG
+LREP,LREP
+PFQN,PFQN
+SCYA,SCYA
+PSCG,PSCG
+SACP,SACP
+AVEV,AVEV
+ETED,ETED
+YIRN,YIRN
+AHTQ,AHTQ
+ATSP,ATSP
+QHRR,QHRR
+IVYE,IVYE
+IRCV,IRCV
+AWKE,AWKE
+KSSH,KSSH
+HWFY,HWFY
+RSVM,RSVM
+RCHT,RCHT
+YKIK,YKIK
+YERF,YERF
+YCPT,YCPT
+IRPV,IRPV
+CDWV,CDWV
+CTFA,CTFA
+GIPV,GIPV
+RWNY,RWNY
+YPKQ,YPKQ
+WAPI,WAPI
+TTCV,TTCV
+HNPW,HNPW
+IVYQ,IVYQ
+DSDC,DSDC
+TTDF,TTDF
+WTTV,WTTV
+SYPT,SYPT
+EVER,EVER
+NGTR,NGTR
+TTWV,TTWV
+CKRQ,CKRQ
+ENEI,ENEI
+KANP,KANP
+HDVL,HDVL
+ENWI,ENWI
+ENRS,ENRS
+RAEK,RAEK
+RSMM,RSMM
+KNCQ,KNCQ
+MCFD,MCFD
+SCEE,SCEE
+PFKV,PFKV
+DVTW,DVTW
+HSHA,HSHA
+MVGG,MVGG
+MLFY,MLFY
+SQLI,SQLI
+KCTN,KCTN
+ADDD,ADDD
+QAFQ,QAFQ
+VMLY,VMLY
+LWNE,LWNE
+CNAE,CNAE
+MMAN,MMAN
+AEQT,AEQT
+TWQQ,TWQQ
+CRVV,CRVV
+HIWA,HIWA
+NSRN,NSRN
+CETD,CETD
+HDVQ,HDVQ
+CERW,CERW
+EIWE,EIWE
+PRHF,PRHF
+RGWE,RGWE
+WNTL,WNTL
+DWSH,DWSH
+EFYV,EFYV
+WWAR,WWAR
+WLEA,WLEA
+ECRM,ECRM
+VQAI,VQAI
+MWSY,MWSY
+RHWS,RHWS
+YEEQ,YEEQ
+CLAV,CLAV
+VHGN,VHGN
+WSSQ,WSSQ
+QCRE,QCRE
+VLKI,VLKI
+VQIH,VQIH
+CYGR,CYGR
+IRPT,IRPT
+LYQQ,LYQQ
+RRFV,RRFV
+CLYP,CLYP
+SHYK,SHYK
+YVNE,YVNE
+HVTC,HVTC
+MDNG,MDNG
+MITR,MITR
+FNWP,FNWP
+HWDR,HWDR
+TIWW,TIWW
+EFHR,EFHR
+WEIP,WEIP
+WMVF,WMVF
+TITV,TITV
+CGGR,CGGR
+AHLH,AHLH
+RAFC,RAFC
+TEQF,TEQF
+CDHT,CDHT
+NSLS,NSLS
+MFYG,MFYG
+EIHC,EIHC
+RFII,RFII
+EIWP,EIWP
+YWWL,YWWL
+GIVG,GIVG
+WNTE,WNTE
+ETWT,ETWT
+KYVE,KYVE
+DSNK,DSNK
+CGCS,CGCS
+WTND,WTND
+TKML,TKML
+QHLM,QHLM
+HAMG,HAMG
+APSY,APSY
+LGVQ,LGVQ
+DSIL,DSIL
+LLEW,LLEW
+RDSQ,RDSQ
+NYFR,NYFR
+LWIK,LWIK
+MHME,MHME
+WRFL,WRFL
+DLEN,DLEN
+LSWQ,LSWQ
+WDLC,WDLC
+EAGH,EAGH
+RLRT,RLRT
+WFHL,WFHL
+VLYT,VLYT
+AIFA,AIFA
+MAEL,MAEL
+QPCF,QPCF
+NCCY,NCCY
+DRKQ,DRKQ
+GMQY,GMQY
+PYHE,PYHE
+NKQM,NKQM
+IMQT,IMQT
+LMAV,LMAV
+CIKV,CIKV
+SKLC,SKLC
+SQYW,SQYW
+WPTL,WPTL
+RIAK,RIAK
+PEKT,PEKT
+FTSS,FTSS
+HMGP,HMGP
+HAHK,HAHK
+NQKS,NQKS
+FDIG,FDIG
+WTWV,WTWV
+RQYK,RQYK
+PAGF,PAGF
+MAIL,MAIL
+AGTK,AGTK
+WYEC,WYEC
+AQTR,AQTR
+HPPF,HPPF
+QIDP,QIDP
+PTGW,PTGW
+LYHI,LYHI
+LDII,LDII
+HVMD,HVMD
+HQWP,HQWP
+WGYN,WGYN
+THGQ,THGQ
+DSQW,DSQW
+NFLD,NFLD
+CIVI,CIVI
+MKQR,MKQR
+EYYR,EYYR
+KQLY,KQLY
+PQVK,PQVK
+VIQW,VIQW
+WSRA,WSRA
+YDWH,YDWH
+QVIC,QVIC
+RCQE,RCQE
+GKKL,GKKL
+CDFW,CDFW
+HKCP,HKCP
+HTWG,HTWG
+HWSW,HWSW
+LFWT,LFWT
+DNSY,DNSY
+RISF,RISF
+ELCT,ELCT
+NQIV,NQIV
+LYMV,LYMV
+YSAS,YSAS
+WAKL,WAKL
+NSWN,NSWN
+AYPG,AYPG
+DCMT,DCMT
+QDHH,QDHH
+HNLH,HNLH
+NFCE,NFCE
+QQEC,QQEC
+VWHK,VWHK
+KHMK,KHMK
+GTQI,GTQI
+NPKL,NPKL
+YWVE,YWVE
+PLWT,PLWT
+QIKR,QIKR
+CFCQ,CFCQ
+VAKP,VAKP
+WKWW,WKWW
+CISE,CISE
+SMPI,SMPI
+RGTN,RGTN
+RIPA,RIPA
+LEQE,LEQE
+DCVQ,DCVQ
+VTMD,VTMD
+RTLY,RTLY
+HTNY,HTNY
+SASD,SASD
+KHTN,KHTN
+SLAH,SLAH
+MSKR,MSKR
+AQAI,AQAI
+GTYN,GTYN
+MKCK,MKCK
+PYNN,PYNN
+HCQV,HCQV
+PILK,PILK
+DADI,DADI
+ERPM,ERPM
+LEPE,LEPE
+YYWW,YYWW
+YEHE,YEHE
+MYTM,MYTM
+PPAP,PPAP
+CMSN,CMSN
+WPDT,WPDT
+YIPT,YIPT
+GHWP,GHWP
+CAGT,CAGT
+IRCG,IRCG
+VACC,VACC
+FFQY,FFQY
+INSK,INSK
+NWIP,NWIP
+GERH,GERH
+SDDG,SDDG
+MARL,MARL
+CTAD,CTAD
+CATS,CATS
+WVCY,WVCY
+TSSK,TSSK
+PKVD,PKVD
+FAWE,FAWE
+LSKT,LSKT
+EHAM,EHAM
+LSRK,LSRK
+CFKP,CFKP
+MHRY,MHRY
+QQRF,QQRF
+LWQS,LWQS
+FFSN,FFSN
+EEDD,EEDD
+KQMR,KQMR
+RPPK,RPPK
+PPSV,PPSV
+ETEA,ETEA
+GALG,GALG
+DSPN,DSPN
+PSEH,PSEH
+SIMA,SIMA
+NRQH,NRQH
+SFSA,SFSA
+EIWD,EIWD
+LCPI,LCPI
+YPVE,YPVE
+SKFG,SKFG
+THHE,THHE
+NLGT,NLGT
+VTWD,VTWD
+RVAC,RVAC
+CSFY,CSFY
+QEVY,QEVY
+TRQL,TRQL
+SGHY,SGHY
+GTNS,GTNS
+HQVK,HQVK
+ISWH,ISWH
+VIGC,VIGC
+DWYH,DWYH
+LPQE,LPQE
+PFCQ,PFCQ
+IFNF,IFNF
+QHYH,QHYH
+WRDP,WRDP
+WGVV,WGVV
+SHPK,SHPK
+RTRW,RTRW
+GCTQ,GCTQ
+RKHM,RKHM
+WHIA,WHIA
+ARVC,ARVC
+TCYV,TCYV
+NEWQ,NEWQ
+RHPM,RHPM
+QDWV,QDWV
+YQST,YQST
+LREE,LREE
+QSRY,QSRY
+RIRE,RIRE
+FGMR,FGMR
+IHIP,IHIP
+VWCS,VWCS
+LIYN,LIYN
+MDDQ,MDDQ
+CWND,CWND
+TKQM,TKQM
+THQI,THQI
+VQAN,VQAN
+WVLA,WVLA
+WMGV,WMGV
+CWFF,CWFF
+DFGH,DFGH
+DWHK,DWHK
+EYLG,EYLG
+TSWQ,TSWQ
+DAVT,DAVT
+YLSS,YLSS
+PFLH,PFLH
+NWTC,NWTC
+LHFH,LHFH
+RWDA,RWDA
+IRAN,IRAN
+LRSY,LRSY
+MEHV,MEHV
+GSTQ,GSTQ
+HYTF,HYTF
+TVSC,TVSC
+IDAI,IDAI
+EVMK,EVMK
+TWMD,TWMD
+MDPA,MDPA
+RVHY,RVHY
+CDHM,CDHM
+MTSL,MTSL
+DIIH,DIIH
+ATCF,ATCF
+WAHF,WAHF
+MIHQ,MIHQ
+GYQE,GYQE
+CQDE,CQDE
+HSPC,HSPC
+CSKH,CSKH
+PWCM,PWCM
+YIIE,YIIE
+IDGG,IDGG
+MKTE,MKTE
+TDEP,TDEP
+WTVK,WTVK
+WASA,WASA
+CEGA,CEGA
+CVLH,CVLH
+ETAA,ETAA
+DKYP,DKYP
+THGL,THGL
+AYAW,AYAW
+WESS,WESS
+IIIQ,IIIQ
+QPQR,QPQR
+TCHM,TCHM
+SEAQ,SEAQ
+TVAT,TVAT
+CSFT,CSFT
+KPWY,KPWY
+TAAE,TAAE
+HCKV,HCKV
+HQGG,HQGG
+AVAV,AVAV
+SEGI,SEGI
+PHRP,PHRP
+FFKV,FFKV
+RFEI,RFEI
+SKAR,SKAR
+WCMR,WCMR
+LMYG,LMYG
+VGYK,VGYK
+HFME,HFME
+CNNV,CNNV
+DGIS,DGIS
+QEAC,QEAC
+KKMF,KKMF
+DGQD,DGQD
+GLDP,GLDP
+ELAE,ELAE
+NYYC,NYYC
+PTSI,PTSI
+HYVR,HYVR
+AGKM,AGKM
+YGEG,YGEG
+AGRQ,AGRQ
+PMKC,PMKC
+KWAL,KWAL
+IIEG,IIEG
+RSFF,RSFF
+DAYV,DAYV
+CAYW,CAYW
+FNAS,FNAS
+DMPC,DMPC
+SFEP,SFEP
+YFHF,YFHF
+DEAC,DEAC
+MHIA,MHIA
+FWPH,FWPH
+GTQA,GTQA
+YRMQ,YRMQ
+HGMW,HGMW
+ESAM,ESAM
+WSWY,WSWY
+FNDC,FNDC
+HKES,HKES
+EHFF,EHFF
+PHNT,PHNT
+EMVC,EMVC
+PPFM,PPFM
+CEWC,CEWC
+ECIF,ECIF
+EPEI,EPEI
+PERF,PERF
+HVFL,HVFL
+DLND,DLND
+HTFC,HTFC
+AEDL,AEDL
+PPFG,PPFG
+WPHP,WPHP
+KSVL,KSVL
+MEEK,MEEK
+TAHI,TAHI
+LILA,LILA
+VRGP,VRGP
+DQPM,DQPM
+HKDS,HKDS
+GWNP,GWNP
+TNYH,TNYH
+PKEQ,PKEQ
+RYHA,RYHA
+FHHI,FHHI
+WSQS,WSQS
+PPEL,PPEL
+CCKG,CCKG
+PLPI,PLPI
+CKVK,CKVK
+IVWS,IVWS
+WQVK,WQVK
+YQKA,YQKA
+GWVH,GWVH
+PGQI,PGQI
+YICL,YICL
+NSNA,NSNA
+SLMP,SLMP
+LKNR,LKNR
+NVRQ,NVRQ
+TLAC,TLAC
+EWPH,EWPH
+DCHI,DCHI
+CCSK,CCSK
+IDMV,IDMV
+CYDP,CYDP
+INLI,INLI
+RHVE,RHVE
+MEYY,MEYY
+DTEL,DTEL
+MDSE,MDSE
+EKAI,EKAI
+ICYL,ICYL
+YIWR,YIWR
+PHCI,PHCI
+QQCF,QQCF
+GGTV,GGTV
+KTDV,KTDV
+KCMY,KCMY
+GNMV,GNMV
+FPYS,FPYS
+MPNI,MPNI
+KHIM,KHIM
+DMQN,DMQN
+GRAV,GRAV
+MADN,MADN
+RPCQ,RPCQ
+NANC,NANC
+MSEK,MSEK
+FNNT,FNNT
+TVFH,TVFH
+FSSV,FSSV
+WRYD,WRYD
+GPTV,GPTV
+NQHS,NQHS
+HDSH,HDSH
+IIAA,IIAA
+PVDI,PVDI
+EVTR,EVTR
+GEMY,GEMY
+QMEN,QMEN
+CMMG,CMMG
+KRDN,KRDN
+IAMY,IAMY
+IKKE,IKKE
+NDSA,NDSA
+PWRG,PWRG
+MEGA,MEGA
+KLPK,KLPK
+VGHM,VGHM
+NDGK,NDGK
+DEWH,DEWH
+IKPK,IKPK
+GFYA,GFYA
+TPEL,TPEL
+DPNQ,DPNQ
+CAAG,CAAG
+GGKF,GGKF
+VRPR,VRPR
+KIRL,KIRL
+HYKN,HYKN
+WDRP,WDRP
+YPMP,YPMP
+FKHG,FKHG
+KDCW,KDCW
+WVCW,WVCW
+GCLE,GCLE
+WHKT,WHKT
+RGIW,RGIW
+VNYM,VNYM
+IMWD,IMWD
+MHWW,MHWW
+ETDG,ETDG
+TNKF,TNKF
+NATY,NATY
+PHSS,PHSS
+FMDM,FMDM
+SHDF,SHDF
+PNVW,PNVW
+DDRF,DDRF
+KEDM,KEDM
+FLYK,FLYK
+HPHF,HPHF
+ECWN,ECWN
+FLNT,FLNT
+PRNI,PRNI
+MHTV,MHTV
+CIGK,CIGK
+HMPA,HMPA
+VQDI,VQDI
+SMYF,SMYF
+PFCI,PFCI
+RFWM,RFWM
+MDVL,MDVL
+TWYI,TWYI
+VNGV,VNGV
+CLWD,CLWD
+PWYD,PWYD
+MEYE,MEYE
+CFWW,CFWW
+GMLN,GMLN
+PYWN,PYWN
+QGIM,QGIM
+KTTE,KTTE
+SSPY,SSPY
+VNTY,VNTY
+NKYR,NKYR
+ISWS,ISWS
+AWPE,AWPE
+CLAN,CLAN
+HSIK,HSIK
+WHLQ,WHLQ
+AFMV,AFMV
+EGGM,EGGM
+DCMI,DCMI
+EFIW,EFIW
+QWHL,QWHL
+TVSY,TVSY
+MYKV,MYKV
+HTGE,HTGE
+EFAL,EFAL
+QFAP,QFAP
+QYHC,QYHC
+INDA,INDA
+DGNV,DGNV
+GGRM,GGRM
+NPYQ,NPYQ
+WEVQ,WEVQ
+HMQV,HMQV
+FNGY,FNGY
+ILIE,ILIE
+WCEG,WCEG
+SLQG,SLQG
+MSQT,MSQT
+MYCE,MYCE
+GEQN,GEQN
+GKPV,GKPV
+SEEN,SEEN
+NYPR,NYPR
+CPFK,CPFK
+KWCY,KWCY
+VHYW,VHYW
+PQYN,PQYN
+FWNT,FWNT
+WNQR,WNQR
+WVYV,WVYV
+VLSR,VLSR
+VSEW,VSEW
+MYYD,MYYD
+MKGP,MKGP
+HDFM,HDFM
+YPAA,YPAA
+QPNY,QPNY
+HDSR,HDSR
+LEVR,LEVR
+IVPD,IVPD
+KNFH,KNFH
+PGTF,PGTF
+CAIT,CAIT
+WEWL,WEWL
+YKAA,YKAA
+LRQA,LRQA
+IGKQ,IGKQ
+DQHG,DQHG
+FQQK,FQQK
+EISN,EISN
+HWDC,HWDC
+QNYR,QNYR
+LRSK,LRSK
+IPQL,IPQL
+QTQL,QTQL
+DRYV,DRYV
+QVCV,QVCV
+QVGT,QVGT
+HYRI,HYRI
+NGNW,NGNW
+SSNA,SSNA
+MYME,MYME
+CCHV,CCHV
+TEVD,TEVD
+ESSN,ESSN
+CVHV,CVHV
+WSEF,WSEF
+VRSE,VRSE
+TVRI,TVRI
+LPGK,LPGK
+IRGH,IRGH
+HNYD,HNYD
+MAWA,MAWA
+IAWD,IAWD
+LPCQ,LPCQ
+GCTR,GCTR
+THDF,THDF
+TWYH,TWYH
+PLYV,PLYV
+IDAT,IDAT
+QWMR,QWMR
+IWQS,IWQS
+SFSE,SFSE
+WCHR,WCHR
+NNTH,NNTH
+QPHC,QPHC
+NCMH,NCMH
+TIKL,TIKL
+EVIQ,EVIQ
+FRVV,FRVV
+DATT,DATT
+CYLN,CYLN
+PGER,PGER
+YEYT,YEYT
+WMTL,WMTL
+TRHH,TRHH
+NCCN,NCCN
+HMGV,HMGV
+LWIL,LWIL
+FGQW,FGQW
+IQQM,IQQM
+FALN,FALN
+VNNP,VNNP
+AMAR,AMAR
+MTLK,MTLK
+GVQR,GVQR
+FVEQ,FVEQ
+ANVM,ANVM
+TQHM,TQHM
+VMDD,VMDD
+LANV,LANV
+NLSL,NLSL
+SPTN,SPTN
+GMCT,GMCT
+INKV,INKV
+LCIQ,LCIQ
+VNPT,VNPT
+CKIL,CKIL
+QGRK,QGRK
+IKAS,IKAS
+EWDH,EWDH
+EDNM,EDNM
+DINK,DINK
+LDRY,LDRY
+VEQN,VEQN
+APTA,APTA
+RCAC,RCAC
+KIRK,KIRK
+GCYQ,GCYQ
+LAMP,LAMP
+VGGR,VGGR
+IPAR,IPAR
+PFEY,PFEY
+HQTL,HQTL
+YEHW,YEHW
+AVEG,AVEG
+MGKK,MGKK
+RIVL,RIVL
+VPDM,VPDM
+LLSQ,LLSQ
+GEYW,GEYW
+MQWC,MQWC
+TYTN,TYTN
+RAPP,RAPP
+DSWK,DSWK
+TQTY,TQTY
+PMNL,PMNL
+GDYN,GDYN
+AFHW,AFHW
+VYPL,VYPL
+IIHM,IIHM
+IGFS,IGFS
+SCCA,SCCA
+GSCW,GSCW
+KLNV,KLNV
+KLMQ,KLMQ
+GNDD,GNDD
+MWQC,MWQC
+NHTC,NHTC
+NQWQ,NQWQ
+PLGA,PLGA
+LHTG,LHTG
+IGTG,IGTG
+DKLF,DKLF
+KHEG,KHEG
+HKKD,HKKD
+TVVE,TVVE
+MSLT,MSLT
+RMND,RMND
+YVAL,YVAL
+GRGT,GRGT
+GRNN,GRNN
+HINF,HINF
+QMSP,QMSP
+EWQK,EWQK
+FAWH,FAWH
+HHKH,HHKH
+ALAF,ALAF
+QDKN,QDKN
+LSEK,LSEK
+VLVT,VLVT
+MELV,MELV
+KSDN,KSDN
+SQKC,SQKC
+HYNT,HYNT
+PYLT,PYLT
+GVND,GVND
+VDQW,VDQW
+RFSN,RFSN
+PTPF,PTPF
+NHTY,NHTY
+ADDP,ADDP
+MALD,MALD

data/splits/4AA_implicit_val.csv

@@ -0,0 +1,101 @@
+name,seqres
+KSVT,KSVT
+SMSN,SMSN
+AAYQ,AAYQ
+FYVR,FYVR
+TFKF,TFKF
+GMMY,GMMY
+RGQL,RGQL
+NYER,NYER
+WKWY,WKWY
+EDTS,EDTS
+PEGV,PEGV
+NNPT,NNPT
+DENA,DENA
+YEPH,YEPH
+IYGF,IYGF
+FRID,FRID
+MRVV,MRVV
+IVFN,IVFN
+LPGP,LPGP
+MGNM,MGNM
+TFWF,TFWF
+LFHI,LFHI
+HYGW,HYGW
+FLDY,FLDY
+QYTM,QYTM
+YMSS,YMSS
+FHWL,FHWL
+HFFG,HFFG
+LKSL,LKSL
+HYAN,HYAN
+PEYE,PEYE
+EVFQ,EVFQ
+FSQR,FSQR
+ETIT,ETIT
+CNNF,CNNF
+MKPK,MKPK
+GMLH,GMLH
+SCQK,SCQK
+WQCY,WQCY
+FIRG,FIRG
+THIC,THIC
+KQRT,KQRT
+QYRQ,QYRQ
+WDWF,WDWF
+QADM,QADM
+GVVY,GVVY
+MWGY,MWGY
+SLHS,SLHS
+PTHA,PTHA
+PTRW,PTRW
+ADSC,ADSC
+QVLA,QVLA
+KSLG,KSLG
+PGNE,PGNE
+IPRW,IPRW
+HTSM,HTSM
+VDEF,VDEF
+VVKC,VVKC
+KTLL,KTLL
+KIED,KIED
+ANFS,ANFS
+DKYV,DKYV
+DQPA,DQPA
+HWLK,HWLK
+TDPL,TDPL
+QCQW,QCQW
+PCPL,PCPL
+MLPR,MLPR
+NDNV,NDNV
+LTPR,LTPR
+YRVC,YRVC
+RFLT,RFLT
+SEAH,SEAH
+VHHC,VHHC
+SMAS,SMAS
+NQEF,NQEF
+DEPV,DEPV
+THHL,THHL
+VVLI,VVLI
+AGVI,AGVI
+STYP,STYP
+LKLW,LKLW
+SFQK,SFQK
+SNID,SNID
+KGCR,KGCR
+FDNC,FDNC
+RCKP,RCKP
+MYYA,MYYA
+DTCD,DTCD
+LQLG,LQLG
+LNWY,LNWY
+MIQK,MIQK
+WDDK,WDDK
+YNKT,YNKT
+TKAK,TKAK
+VRNG,VRNG
+KTTF,KTTF
+IAIM,IAIM
+FGGV,FGGV
+SHPE,SHPE

data/splits/4AA_test.csv

@@ -0,0 +1,101 @@
+name,seqres
+FLRH,FLRH
+IMRY,IMRY
+RTVD,RTVD
+PIDV,PIDV
+AKIR,AKIR
+IPGD,IPGD
+HTIQ,HTIQ
+WWQW,WWQW
+KDFM,KDFM
+ESSS,ESSS
+ASRE,ASRE
+LCLQ,LCLQ
+VIYH,VIYH
+IVMA,IVMA
+RVQQ,RVQQ
+DQKV,DQKV
+KDDD,KDDD
+CPEE,CPEE
+WSAQ,WSAQ
+VQCL,VQCL
+CSYR,CSYR
+LAWA,LAWA
+VWVR,VWVR
+SPVN,SPVN
+MIAY,MIAY
+GLIL,GLIL
+AGVD,AGVD
+SNSF,SNSF
+FHSE,FHSE
+TLRK,TLRK
+IAMI,IAMI
+CPYV,CPYV
+NWWG,NWWG
+LQMG,LQMG
+KEGH,KEGH
+FGGW,FGGW
+NVFH,NVFH
+DLCG,DLCG
+APWF,APWF
+QVTC,QVTC
+YQGI,YQGI
+LVVF,LVVF
+RVQS,RVQS
+KAEP,KAEP
+WQVP,WQVP
+LWMR,LWMR
+NNDK,NNDK
+MHVR,MHVR
+EDQK,EDQK
+CACS,CACS
+CKHT,CKHT
+IWHF,IWHF
+IPTH,IPTH
+VDRN,VDRN
+YCPF,YCPF
+HELI,HELI
+SFCH,SFCH
+YLID,YLID
+GGHN,GGHN
+FSDP,FSDP
+CKVH,CKVH
+NTVG,NTVG
+IHNV,IHNV
+YMQN,YMQN
+PRVC,PRVC
+SDFS,SDFS
+SPFH,SPFH
+FSRK,FSRK
+QNWV,QNWV
+PYHQ,PYHQ
+FDNT,FDNT
+KAQW,KAQW
+PKDM,PKDM
+LIFE,LIFE
+ALDA,ALDA
+PGKM,PGKM
+QRNF,QRNF
+SSNN,SSNN
+FKKL,FKKL
+MWQK,MWQK
+RLKR,RLKR
+KSIY,KSIY
+GCIC,GCIC
+INVH,INVH
+NFQF,NFQF
+RDWY,RDWY
+SNIN,SNIN
+ESIC,ESIC
+LIRH,LIRH
+CIYL,CIYL
+MAFM,MAFM
+AASF,AASF
+HENV,HENV
+EHEV,EHEV
+LFNV,LFNV
+RQLP,RQLP
+PNHP,PNHP
+CFEE,CFEE
+DHAR,DHAR
+IDRH,IDRH

data/splits/4AA_train.csv

@@ -0,0 +1,3110 @@
+name,seqres
+EFPT,EFPT
+CEML,CEML
+KSVT,KSVT
+SMSN,SMSN
+AAYQ,AAYQ
+KQTG,KQTG
+WFPD,WFPD
+FYVR,FYVR
+RYSH,RYSH
+TFKF,TFKF
+LLRT,LLRT
+IERA,IERA
+KPHD,KPHD
+GMMY,GMMY
+RGQL,RGQL
+NYER,NYER
+NDWN,NDWN
+WKWY,WKWY
+QNCY,QNCY
+FFSG,FFSG
+WEFG,WEFG
+FCGM,FCGM
+EDTS,EDTS
+PEGV,PEGV
+RTNT,RTNT
+NNPT,NNPT
+DENA,DENA
+YEPH,YEPH
+NSYF,NSYF
+IYGF,IYGF
+DTGE,DTGE
+TWWQ,TWWQ
+FRID,FRID
+MRVV,MRVV
+ITDP,ITDP
+IVFN,IVFN
+PYDT,PYDT
+LPGP,LPGP
+MGNM,MGNM
+TFWF,TFWF
+LFHI,LFHI
+HYGW,HYGW
+LWPA,LWPA
+FLDY,FLDY
+QKAD,QKAD
+QYTM,QYTM
+YMSS,YMSS
+NWWL,NWWL
+FHWL,FHWL
+HFFG,HFFG
+DGNM,DGNM
+HWPA,HWPA
+VAEY,VAEY
+LKSL,LKSL
+HYAN,HYAN
+PEYE,PEYE
+QLFI,QLFI
+CGNH,CGNH
+EVFQ,EVFQ
+FSQR,FSQR
+ETIT,ETIT
+CNNF,CNNF
+ETRW,ETRW
+MKPK,MKPK
+YAQK,YAQK
+GMLH,GMLH
+WANF,WANF
+TQVG,TQVG
+THGW,THGW
+NSGW,NSGW
+HPLH,HPLH
+TWDS,TWDS
+SCQK,SCQK
+WQCY,WQCY
+FIRG,FIRG
+PSMR,PSMR
+THIC,THIC
+KQRT,KQRT
+LICP,LICP
+DLYC,DLYC
+WMDW,WMDW
+QYRQ,QYRQ
+WDWF,WDWF
+NGYG,NGYG
+CRTL,CRTL
+QADM,QADM
+GVVY,GVVY
+EWNK,EWNK
+MWGY,MWGY
+SLHS,SLHS
+PTHA,PTHA
+ANIP,ANIP
+ANMY,ANMY
+RMMC,RMMC
+MWCA,MWCA
+PTRW,PTRW
+ADSC,ADSC
+PYRM,PYRM
+QVLA,QVLA
+KSLG,KSLG
+GLCK,GLCK
+QIEG,QIEG
+PGNE,PGNE
+IPRW,IPRW
+HTSM,HTSM
+IPEM,IPEM
+NQRK,NQRK
+WVTA,WVTA
+SFIT,SFIT
+VDEF,VDEF
+NDPC,NDPC
+VVKC,VVKC
+TSTY,TSTY
+QRCV,QRCV
+SQFR,SQFR
+KTLL,KTLL
+TYHA,TYHA
+CIAC,CIAC
+KIED,KIED
+ANFS,ANFS
+KTNF,KTNF
+KAAC,KAAC
+ADYH,ADYH
+EKIA,EKIA
+HWRN,HWRN
+DKYV,DKYV
+DQPA,DQPA
+DIFK,DIFK
+MFVD,MFVD
+HWLK,HWLK
+TDQK,TDQK
+DFIC,DFIC
+LDDQ,LDDQ
+DAWF,DAWF
+TDPL,TDPL
+QCQW,QCQW
+MKHG,MKHG
+PCPL,PCPL
+MLPR,MLPR
+NDNV,NDNV
+LTPR,LTPR
+YRVC,YRVC
+HVHQ,HVHQ
+YMPM,YMPM
+FGMM,FGMM
+RFLT,RFLT
+SEAH,SEAH
+VHHC,VHHC
+SMAS,SMAS
+GSLP,GSLP
+NQEF,NQEF
+DEPV,DEPV
+THHL,THHL
+QSAP,QSAP
+VVLI,VVLI
+AGVI,AGVI
+STYP,STYP
+FYWL,FYWL
+SWGL,SWGL
+SSTS,SSTS
+LDGR,LDGR
+LKLW,LKLW
+RYPT,RYPT
+TTHG,TTHG
+SFQK,SFQK
+SNID,SNID
+KGCR,KGCR
+MVHP,MVHP
+FDNC,FDNC
+TFRF,TFRF
+LHIM,LHIM
+RCKP,RCKP
+MYYA,MYYA
+ALQG,ALQG
+DTCD,DTCD
+MLPY,MLPY
+RLEH,RLEH
+LQLG,LQLG
+LNWY,LNWY
+GLQK,GLQK
+GITD,GITD
+NPDS,NPDS
+MDKA,MDKA
+DLYV,DLYV
+AAKD,AAKD
+WRPI,WRPI
+MIQK,MIQK
+WDDK,WDDK
+YNKT,YNKT
+VIHL,VIHL
+ERQS,ERQS
+AYIY,AYIY
+NHDQ,NHDQ
+TKAK,TKAK
+VRNG,VRNG
+IPVY,IPVY
+SQVM,SQVM
+KTTF,KTTF
+KGHN,KGHN
+RTSK,RTSK
+IAIM,IAIM
+FGGV,FGGV
+SHPE,SHPE
+QDFY,QDFY
+SEME,SEME
+EKME,EKME
+YSCA,YSCA
+PTMP,PTMP
+KEWD,KEWD
+TGPT,TGPT
+ILIG,ILIG
+AAKQ,AAKQ
+SGLQ,SGLQ
+LQRL,LQRL
+TTLY,TTLY
+PFGV,PFGV
+FPCE,FPCE
+VSFH,VSFH
+PHEV,PHEV
+EHLC,EHLC
+FFSV,FFSV
+DCVV,DCVV
+RPEY,RPEY
+WYNA,WYNA
+FLKS,FLKS
+EPWP,EPWP
+PMPK,PMPK
+DNCQ,DNCQ
+MYCF,MYCF
+FLHM,FLHM
+WYIG,WYIG
+LNPR,LNPR
+HLSN,HLSN
+CQYS,CQYS
+QQSD,QQSD
+RSAH,RSAH
+SNCV,SNCV
+DIGN,DIGN
+WKRV,WKRV
+NYQM,NYQM
+PFTA,PFTA
+QASA,QASA
+WQRR,WQRR
+FFRN,FFRN
+WKSH,WKSH
+HEGV,HEGV
+SIKA,SIKA
+YSGC,YSGC
+HRND,HRND
+VFWY,VFWY
+NFRP,NFRP
+PVVH,PVVH
+YQIW,YQIW
+QNFH,QNFH
+ISFP,ISFP
+YLCA,YLCA
+NQSC,NQSC
+SMYW,SMYW
+HWTP,HWTP
+ARGH,ARGH
+CRMN,CRMN
+FKWW,FKWW
+QNMV,QNMV
+EWLN,EWLN
+MSLN,MSLN
+AFCQ,AFCQ
+WKPH,WKPH
+IKQG,IKQG
+GADR,GADR
+AKCN,AKCN
+PMMV,PMMV
+LDPH,LDPH
+QMKT,QMKT
+EANQ,EANQ
+HILY,HILY
+DGCA,DGCA
+QWFI,QWFI
+RRCY,RRCY
+AQFQ,AQFQ
+PICC,PICC
+GPGP,GPGP
+IAYH,IAYH
+MHGM,MHGM
+WMFD,WMFD
+VHTK,VHTK
+NWPN,NWPN
+LKRV,LKRV
+GFYF,GFYF
+QTSK,QTSK
+HPNK,HPNK
+QTSA,QTSA
+FGAR,FGAR
+ITWF,ITWF
+LRTE,LRTE
+AEAF,AEAF
+FHLQ,FHLQ
+PIAC,PIAC
+QWPL,QWPL
+KDKI,KDKI
+STSR,STSR
+PTIG,PTIG
+QIVA,QIVA
+MKCC,MKCC
+WSYN,WSYN
+NAWY,NAWY
+YVLE,YVLE
+VCRV,VCRV
+MHAQ,MHAQ
+TSWC,TSWC
+QKYR,QKYR
+TFIL,TFIL
+ITKR,ITKR
+DVGL,DVGL
+FVEL,FVEL
+CGPF,CGPF
+GPSL,GPSL
+LQPT,LQPT
+WKLD,WKLD
+MRLH,MRLH
+TYAM,TYAM
+VNAK,VNAK
+CEIA,CEIA
+WQDT,WQDT
+SRQV,SRQV
+CLHA,CLHA
+TPEA,TPEA
+EEKV,EEKV
+NHEL,NHEL
+NKCC,NKCC
+VVSN,VVSN
+EETC,EETC
+GTEV,GTEV
+NMYR,NMYR
+PYYT,PYYT
+FRCR,FRCR
+AMQN,AMQN
+KDYC,KDYC
+QNIE,QNIE
+MMDH,MMDH
+MWLR,MWLR
+AELN,AELN
+KNQT,KNQT
+TNHK,TNHK
+TDNF,TDNF
+YPDQ,YPDQ
+NTDP,NTDP
+SEGL,SEGL
+PMWQ,PMWQ
+CPQA,CPQA
+PDPH,PDPH
+NYWT,NYWT
+WTIN,WTIN
+TQLE,TQLE
+HFAP,HFAP
+NSCW,NSCW
+LVTE,LVTE
+CWWT,CWWT
+PECP,PECP
+WGWE,WGWE
+FYTW,FYTW
+LHGA,LHGA
+PFGR,PFGR
+SNIA,SNIA
+HPIQ,HPIQ
+KWMG,KWMG
+VIWL,VIWL
+LEIC,LEIC
+LSIQ,LSIQ
+VSSK,VSSK
+ICDY,ICDY
+FFCC,FFCC
+IFWQ,IFWQ
+YWWI,YWWI
+HTDL,HTDL
+DPDA,DPDA
+HLYC,HLYC
+SVCF,SVCF
+VGNK,VGNK
+IKGW,IKGW
+DVFC,DVFC
+PKSC,PKSC
+CAML,CAML
+INCE,INCE
+QEKW,QEKW
+EGSR,EGSR
+NDAL,NDAL
+VGCC,VGCC
+AHVE,AHVE
+KSKE,KSKE
+VPKS,VPKS
+AQYS,AQYS
+CHYC,CHYC
+EVNN,EVNN
+VQVG,VQVG
+ECDG,ECDG
+CSIT,CSIT
+EEFG,EEFG
+AFRN,AFRN
+NLSK,NLSK
+DSQY,DSQY
+ELHH,ELHH
+SNFS,SNFS
+SYPG,SYPG
+DFAK,DFAK
+QAQD,QAQD
+IIDS,IIDS
+MFSG,MFSG
+LANN,LANN
+KKNF,KKNF
+VLNM,VLNM
+DEWW,DEWW
+LEHK,LEHK
+SMVW,SMVW
+IING,IING
+GIIY,GIIY
+IHGP,IHGP
+PEFC,PEFC
+RKHR,RKHR
+DRPY,DRPY
+CPVD,CPVD
+CKVF,CKVF
+PEID,PEID
+LPRM,LPRM
+PRRA,PRRA
+YFTF,YFTF
+VWGW,VWGW
+AGTA,AGTA
+NRHA,NRHA
+VNVC,VNVC
+KHRY,KHRY
+RAKD,RAKD
+YGPH,YGPH
+GCHN,GCHN
+TDRL,TDRL
+HRLK,HRLK
+PWRH,PWRH
+KKTN,KKTN
+TELH,TELH
+EKTL,EKTL
+TWVR,TWVR
+SHQN,SHQN
+TCIA,TCIA
+THKW,THKW
+VGES,VGES
+KMHT,KMHT
+VDYD,VDYD
+KVYT,KVYT
+KGFR,KGFR
+NWNG,NWNG
+PQPK,PQPK
+FKVT,FKVT
+VIDA,VIDA
+AQMK,AQMK
+LGCI,LGCI
+AWDV,AWDV
+AHKR,AHKR
+HAPF,HAPF
+LINW,LINW
+SNYD,SNYD
+KVFQ,KVFQ
+SWML,SWML
+NMHN,NMHN
+RVSQ,RVSQ
+MYCI,MYCI
+WQPN,WQPN
+VNRT,VNRT
+QHTR,QHTR
+RCRP,RCRP
+HCWT,HCWT
+GQSH,GQSH
+RTHG,RTHG
+NQQL,NQQL
+SNHN,SNHN
+MKIF,MKIF
+YYHC,YYHC
+YRMP,YRMP
+SHQH,SHQH
+WAWT,WAWT
+TFIS,TFIS
+DDWR,DDWR
+AMDV,AMDV
+ADRK,ADRK
+HMHR,HMHR
+FNAG,FNAG
+EMYK,EMYK
+WVSQ,WVSQ
+AHFV,AHFV
+RQHV,RQHV
+TQYA,TQYA
+AIWE,AIWE
+CMKR,CMKR
+IKWC,IKWC
+RFML,RFML
+VCGS,VCGS
+RTNP,RTNP
+MTYG,MTYG
+MINS,MINS
+DIKD,DIKD
+KNFC,KNFC
+ENSS,ENSS
+MSPW,MSPW
+VAYR,VAYR
+YSME,YSME
+LKTH,LKTH
+PGHR,PGHR
+LPAH,LPAH
+QCWM,QCWM
+GWSQ,GWSQ
+IVSP,IVSP
+YYFW,YYFW
+WMAW,WMAW
+LLDC,LLDC
+WTHH,WTHH
+GCQH,GCQH
+WTGS,WTGS
+LFGA,LFGA
+LREV,LREV
+TYGD,TYGD
+VHTR,VHTR
+CGCQ,CGCQ
+FVIH,FVIH
+GQFY,GQFY
+ELYA,ELYA
+EMRT,EMRT
+DGDL,DGDL
+QEPC,QEPC
+NHDA,NHDA
+IISC,IISC
+NSMN,NSMN
+GLTR,GLTR
+CISI,CISI
+RGVQ,RGVQ
+KDMC,KDMC
+SGYG,SGYG
+ENNH,ENNH
+NDPM,NDPM
+AYAE,AYAE
+DFWH,DFWH
+GDII,GDII
+GFKP,GFKP
+CAYP,CAYP
+KHDS,KHDS
+GAWV,GAWV
+TTNE,TTNE
+FEDH,FEDH
+YTAV,YTAV
+AMVW,AMVW
+LSQT,LSQT
+NECR,NECR
+GLGA,GLGA
+PNYQ,PNYQ
+KSTF,KSTF
+KVCI,KVCI
+RKIS,RKIS
+PILN,PILN
+GCCR,GCCR
+SVCQ,SVCQ
+WVLQ,WVLQ
+LLGC,LLGC
+HAWM,HAWM
+AVQK,AVQK
+NPGA,NPGA
+TPEW,TPEW
+SDNG,SDNG
+PIQV,PIQV
+YIMK,YIMK
+NYMG,NYMG
+LTYP,LTYP
+GTTS,GTTS
+FERD,FERD
+EIGH,EIGH
+CPKM,CPKM
+QSNI,QSNI
+HSKL,HSKL
+CWEM,CWEM
+NDWV,NDWV
+FFIR,FFIR
+CNSC,CNSC
+KTGN,KTGN
+RGSY,RGSY
+CVLQ,CVLQ
+NKNQ,NKNQ
+CWYK,CWYK
+SSRN,SSRN
+KNGD,KNGD
+PECK,PECK
+NRKC,NRKC
+HTAN,HTAN
+NSKE,NSKE
+ALFY,ALFY
+KWPM,KWPM
+CFTK,CFTK
+PDKM,PDKM
+TQIS,TQIS
+DEWM,DEWM
+EHMK,EHMK
+IYNR,IYNR
+HAFR,HAFR
+DECE,DECE
+WYVV,WYVV
+GCPK,GCPK
+DRKK,DRKK
+KEVR,KEVR
+WNWC,WNWC
+PAYK,PAYK
+QKEE,QKEE
+QGEC,QGEC
+LYGF,LYGF
+IWAR,IWAR
+GRAR,GRAR
+AIYC,AIYC
+TTVF,TTVF
+HFLW,HFLW
+NARM,NARM
+RHRA,RHRA
+QQDS,QQDS
+FHSL,FHSL
+AVDA,AVDA
+HERQ,HERQ
+TMMP,TMMP
+PEMT,PEMT
+AAFS,AAFS
+QEEG,QEEG
+ATMV,ATMV
+CAFW,CAFW
+LSGH,LSGH
+YKLV,YKLV
+MPNS,MPNS
+CKMP,CKMP
+KKYS,KKYS
+IITA,IITA
+PAIY,PAIY
+WDCD,WDCD
+RSDW,RSDW
+QPAL,QPAL
+EYPW,EYPW
+FCWC,FCWC
+CFRY,CFRY
+QLCG,QLCG
+QETE,QETE
+TCNV,TCNV
+DQFR,DQFR
+HKTS,HKTS
+GWDT,GWDT
+SFMN,SFMN
+GHMF,GHMF
+HDRQ,HDRQ
+RTNL,RTNL
+YNKP,YNKP
+KDIG,KDIG
+LECA,LECA
+RRGK,RRGK
+LNPY,LNPY
+IMVW,IMVW
+PVDS,PVDS
+RERF,RERF
+KAER,KAER
+FMGP,FMGP
+PSAT,PSAT
+VKEQ,VKEQ
+CKCE,CKCE
+TAAR,TAAR
+QPRA,QPRA
+HEAH,HEAH
+LCNA,LCNA
+DEMY,DEMY
+TEPE,TEPE
+WNLY,WNLY
+SPHG,SPHG
+GQHQ,GQHQ
+ADYM,ADYM
+FQYW,FQYW
+VSDD,VSDD
+NAKM,NAKM
+QMDQ,QMDQ
+SDAK,SDAK
+HLDH,HLDH
+SCCY,SCCY
+HGSC,HGSC
+RAVV,RAVV
+KCND,KCND
+LIDG,LIDG
+GGMD,GGMD
+PFRW,PFRW
+NMLG,NMLG
+NWSN,NWSN
+TRGN,TRGN
+MIYA,MIYA
+IFAS,IFAS
+QICA,QICA
+VTIL,VTIL
+NYLP,NYLP
+QFGT,QFGT
+GLDV,GLDV
+DHNR,DHNR
+NYRP,NYRP
+CDKL,CDKL
+WQSQ,WQSQ
+ADPG,ADPG
+FEHM,FEHM
+DHFW,DHFW
+WSSW,WSSW
+FPMF,FPMF
+SLLD,SLLD
+KVRS,KVRS
+ITNH,ITNH
+GLAR,GLAR
+CACL,CACL
+HFDQ,HFDQ
+LDPE,LDPE
+FIQA,FIQA
+WFSN,WFSN
+NQQC,NQQC
+CGWR,CGWR
+QMDV,QMDV
+QCEQ,QCEQ
+YNKS,YNKS
+ALCP,ALCP
+RRKI,RRKI
+GPCV,GPCV
+HISI,HISI
+QVAD,QVAD
+DFWV,DFWV
+WEAM,WEAM
+CFWG,CFWG
+GCWP,GCWP
+PHPC,PHPC
+AVSM,AVSM
+TSPC,TSPC
+MWLF,MWLF
+RHSI,RHSI
+HKQL,HKQL
+IPTF,IPTF
+SSNP,SSNP
+ATLL,ATLL
+SAHD,SAHD
+YNQP,YNQP
+RPSF,RPSF
+TCHS,TCHS
+AVGR,AVGR
+HYPI,HYPI
+PQYL,PQYL
+GNIA,GNIA
+LWQD,LWQD
+SHSC,SHSC
+FNCR,FNCR
+VAGR,VAGR
+YNLS,YNLS
+NSLF,NSLF
+MIIM,MIIM
+RYPG,RYPG
+DCQI,DCQI
+PMFI,PMFI
+CIFL,CIFL
+TIRG,TIRG
+CRVF,CRVF
+WHEL,WHEL
+ALWP,ALWP
+CMKC,CMKC
+PWID,PWID
+ESTM,ESTM
+EHDY,EHDY
+EMIR,EMIR
+NAWM,NAWM
+LNCW,LNCW
+FYDK,FYDK
+WKEG,WKEG
+HHCG,HHCG
+NKPS,NKPS
+FCDI,FCDI
+HDSC,HDSC
+PAYR,PAYR
+YFMV,YFMV
+NTGH,NTGH
+SREK,SREK
+FYCL,FYCL
+GFHM,GFHM
+EQCV,EQCV
+GREQ,GREQ
+NYCP,NYCP
+EKER,EKER
+SAIS,SAIS
+RHIQ,RHIQ
+AITQ,AITQ
+FEAT,FEAT
+PKPF,PKPF
+HIMN,HIMN
+DSSQ,DSSQ
+KKYC,KKYC
+YSST,YSST
+LETH,LETH
+PSFA,PSFA
+VQLN,VQLN
+LCCH,LCCH
+MNWM,MNWM
+DNTG,DNTG
+YRQF,YRQF
+NPIF,NPIF
+AISE,AISE
+ECGH,ECGH
+WQRL,WQRL
+YMKK,YMKK
+IWQA,IWQA
+TLRF,TLRF
+HGYL,HGYL
+SHPF,SHPF
+WVNW,WVNW
+QKIH,QKIH
+REVN,REVN
+CQAA,CQAA
+YMCK,YMCK
+GCAE,GCAE
+IYCC,IYCC
+LHPT,LHPT
+HYGI,HYGI
+MVPE,MVPE
+LGKM,LGKM
+WGRS,WGRS
+GSIK,GSIK
+KPPN,KPPN
+MNGQ,MNGQ
+EYCW,EYCW
+SCWT,SCWT
+IGNE,IGNE
+DAVK,DAVK
+EWIH,EWIH
+NTWM,NTWM
+ADSL,ADSL
+QHHD,QHHD
+YAYE,YAYE
+CTVL,CTVL
+YPNQ,YPNQ
+GSTY,GSTY
+NYDY,NYDY
+SITI,SITI
+TWNQ,TWNQ
+KWRC,KWRC
+IVKV,IVKV
+QHKL,QHKL
+HRRT,HRRT
+SLIP,SLIP
+EPYW,EPYW
+WYST,WYST
+KRQD,KRQD
+KDKA,KDKA
+LVTY,LVTY
+PLKQ,PLKQ
+DFTH,DFTH
+PRYH,PRYH
+HKEW,HKEW
+DMII,DMII
+MKSQ,MKSQ
+AGAE,AGAE
+KSCD,KSCD
+STKQ,STKQ
+THTI,THTI
+KDNF,KDNF
+KAHG,KAHG
+RGQA,RGQA
+QDKS,QDKS
+QSIS,QSIS
+NMSV,NMSV
+WAAK,WAAK
+GYRA,GYRA
+METL,METL
+VYAY,VYAY
+HAQA,HAQA
+HETA,HETA
+KVYK,KVYK
+VYCP,VYCP
+LLGG,LLGG
+YQLI,YQLI
+AYLP,AYLP
+FIVM,FIVM
+WMAS,WMAS
+CTRV,CTRV
+NMDG,NMDG
+FPDC,FPDC
+CIYD,CIYD
+GSKT,GSKT
+CGFR,CGFR
+TRSH,TRSH
+MVSL,MVSL
+RRKV,RRKV
+VLQI,VLQI
+VSAC,VSAC
+DWSM,DWSM
+NHNN,NHNN
+AFYN,AFYN
+EDDP,EDDP
+DHMM,DHMM
+QTHP,QTHP
+TTPK,TTPK
+KWHA,KWHA
+WCTW,WCTW
+ELHW,ELHW
+PRGH,PRGH
+KTSE,KTSE
+HFIG,HFIG
+PRTR,PRTR
+GTPP,GTPP
+APLR,APLR
+FPAW,FPAW
+WNGE,WNGE
+EYQP,EYQP
+KHDF,KHDF
+WELM,WELM
+KPRK,KPRK
+YSVA,YSVA
+TQSV,TQSV
+VMIK,VMIK
+RNHG,RNHG
+SLGK,SLGK
+ETEG,ETEG
+MWKN,MWKN
+TVHD,TVHD
+TPHR,TPHR
+SIHY,SIHY
+LLWM,LLWM
+EVGN,EVGN
+NKIP,NKIP
+PQDM,PQDM
+YDMK,YDMK
+CTPI,CTPI
+FYEH,FYEH
+NENL,NENL
+ETVQ,ETVQ
+NLYD,NLYD
+SIRG,SIRG
+PGIN,PGIN
+QSMW,QSMW
+HMLW,HMLW
+QSLR,QSLR
+CCNM,CCNM
+LKAW,LKAW
+TIKC,TIKC
+RPFF,RPFF
+SIVL,SIVL
+TVYC,TVYC
+HWRD,HWRD
+PVDL,PVDL
+RVSH,RVSH
+QGGV,QGGV
+ERLR,ERLR
+IYTM,IYTM
+KSYI,KSYI
+KPGM,KPGM
+WTFI,WTFI
+ICAC,ICAC
+TSMW,TSMW
+PIRF,PIRF
+NKRN,NKRN
+VFNR,VFNR
+QQRK,QQRK
+KFMW,KFMW
+PHVT,PHVT
+KQFW,KQFW
+DHQD,DHQD
+SHLR,SHLR
+ADDC,ADDC
+RKQI,RKQI
+PPFQ,PPFQ
+VECA,VECA
+EPSY,EPSY
+RAYD,RAYD
+QRFT,QRFT
+CYAI,CYAI
+NSYW,NSYW
+VEGM,VEGM
+PVKV,PVKV
+CGEF,CGEF
+QDEA,QDEA
+EFET,EFET
+QTCH,QTCH
+LIFR,LIFR
+CQNM,CQNM
+HHPD,HHPD
+GFIK,GFIK
+TTLH,TTLH
+SGED,SGED
+PRPE,PRPE
+GIDF,GIDF
+DVSH,DVSH
+CCVH,CCVH
+KTCF,KTCF
+ISYI,ISYI
+NQII,NQII
+GPCY,GPCY
+HCVE,HCVE
+FSYV,FSYV
+SIAV,SIAV
+VVNC,VVNC
+VCHD,VCHD
+DTDS,DTDS
+CFVK,CFVK
+VNDH,VNDH
+VHWL,VHWL
+CSCE,CSCE
+KQFR,KQFR
+EFDP,EFDP
+RDAI,RDAI
+PTMQ,PTMQ
+SDGG,SDGG
+PTVI,PTVI
+MIMP,MIMP
+QSVW,QSVW
+ETQH,ETQH
+KVCK,KVCK
+QRSE,QRSE
+CQAE,CQAE
+HVFE,HVFE
+EHHR,EHHR
+IKYC,IKYC
+YWPA,YWPA
+PGVW,PGVW
+EHGF,EHGF
+IQDC,IQDC
+YVHI,YVHI
+TMFP,TMFP
+AEDA,AEDA
+PCTW,PCTW
+FNGV,FNGV
+AHVD,AHVD
+CGIY,CGIY
+CYFW,CYFW
+GQCG,GQCG
+NTSW,NTSW
+WYSQ,WYSQ
+WCLH,WCLH
+GHCP,GHCP
+YPMN,YPMN
+WCPF,WCPF
+MVGK,MVGK
+DCVI,DCVI
+WRPF,WRPF
+VEDP,VEDP
+WWNS,WWNS
+PQFN,PQFN
+ITGY,ITGY
+QRWD,QRWD
+FPDR,FPDR
+EKQQ,EKQQ
+FWYD,FWYD
+TYYL,TYYL
+THCL,THCL
+RGTI,RGTI
+ALVA,ALVA
+LEWG,LEWG
+RVQH,RVQH
+LFAS,LFAS
+SVHG,SVHG
+SREG,SREG
+GVDR,GVDR
+MMVT,MMVT
+VPGH,VPGH
+YTQD,YTQD
+DYPH,DYPH
+RRMG,RRMG
+AVDP,AVDP
+EVKQ,EVKQ
+LTFC,LTFC
+KATL,KATL
+MYKA,MYKA
+RYCC,RYCC
+VHKY,VHKY
+LVMI,LVMI
+YHFK,YHFK
+RLNQ,RLNQ
+EMEV,EMEV
+DPGV,DPGV
+AAWQ,AAWQ
+FDDC,FDDC
+SKLN,SKLN
+LCEE,LCEE
+VVWW,VVWW
+KLQI,KLQI
+DHDA,DHDA
+RTQF,RTQF
+STTP,STTP
+FFEI,FFEI
+IKCN,IKCN
+ACWP,ACWP
+AWGE,AWGE
+HYRY,HYRY
+FFVR,FFVR
+CEEV,CEEV
+LQMY,LQMY
+SACN,SACN
+MWWT,MWWT
+IDQT,IDQT
+QGCS,QGCS
+WRLE,WRLE
+AAPH,AAPH
+NTKN,NTKN
+FMSK,FMSK
+MGLI,MGLI
+YECV,YECV
+RFID,RFID
+CEDK,CEDK
+ILEE,ILEE
+RAMW,RAMW
+FPTQ,FPTQ
+HRCR,HRCR
+FIMH,FIMH
+KIPT,KIPT
+NNNH,NNNH
+ANWL,ANWL
+ARTD,ARTD
+APDW,APDW
+AFCR,AFCR
+FQPT,FQPT
+ALNI,ALNI
+FNWC,FNWC
+SYEV,SYEV
+IMYD,IMYD
+TRVA,TRVA
+RAMI,RAMI
+QCTI,QCTI
+NQRE,NQRE
+YEPV,YEPV
+CWAK,CWAK
+LFCK,LFCK
+NESI,NESI
+WHQL,WHQL
+DGVF,DGVF
+NHPH,NHPH
+YSQT,YSQT
+PWDL,PWDL
+FEDQ,FEDQ
+YMPP,YMPP
+RNCR,RNCR
+NWWQ,NWWQ
+VMVQ,VMVQ
+YSSP,YSSP
+QHKQ,QHKQ
+FPVM,FPVM
+ADHT,ADHT
+ATSY,ATSY
+DLPV,DLPV
+ETRD,ETRD
+MHVD,MHVD
+VIHG,VIHG
+FDEA,FDEA
+TSNQ,TSNQ
+YSIF,YSIF
+QIII,QIII
+RGGM,RGGM
+VAMH,VAMH
+CVGQ,CVGQ
+RPYI,RPYI
+DEFL,DEFL
+QHPN,QHPN
+MLEP,MLEP
+IEDW,IEDW
+YLWR,YLWR
+DHHD,DHHD
+KSWF,KSWF
+AVKM,AVKM
+SRER,SRER
+AMNH,AMNH
+MDDM,MDDM
+CGNP,CGNP
+GEHF,GEHF
+PLPD,PLPD
+FSHK,FSHK
+AISH,AISH
+GDAN,GDAN
+CQYQ,CQYQ
+AGEQ,AGEQ
+RQWE,RQWE
+RRQL,RRQL
+WHGN,WHGN
+PKYY,PKYY
+CCIM,CCIM
+KWRL,KWRL
+LTTE,LTTE
+MYNQ,MYNQ
+SSAI,SSAI
+LYCT,LYCT
+CMPV,CMPV
+HVCL,HVCL
+NRKH,NRKH
+KECR,KECR
+TWKA,TWKA
+WASS,WASS
+KKIY,KKIY
+VAFT,VAFT
+LDVC,LDVC
+YEPK,YEPK
+CISD,CISD
+NMWE,NMWE
+CVNT,CVNT
+TLDK,TLDK
+CYGK,CYGK
+PVTT,PVTT
+HDDC,HDDC
+LGLF,LGLF
+LAQN,LAQN
+NTFF,NTFF
+KISF,KISF
+GVLP,GVLP
+LNVM,LNVM
+NAGK,NAGK
+NHNV,NHNV
+LRCW,LRCW
+WMYG,WMYG
+GCYY,GCYY
+CSYK,CSYK
+PDLM,PDLM
+WSWA,WSWA
+GQSL,GQSL
+NWRM,NWRM
+EEHP,EEHP
+WCYP,WCYP
+NNAM,NNAM
+MHHK,MHHK
+FGFS,FGFS
+KPLK,KPLK
+TYPI,TYPI
+CDRS,CDRS
+WMFH,WMFH
+HEWG,HEWG
+PQNW,PQNW
+QVQH,QVQH
+NTPI,NTPI
+VMVI,VMVI
+RHAT,RHAT
+PKKF,PKKF
+IIHN,IIHN
+LVNS,LVNS
+YTSK,YTSK
+IAGS,IAGS
+KNGE,KNGE
+GESD,GESD
+IAKF,IAKF
+QPDG,QPDG
+CLEN,CLEN
+MQHR,MQHR
+YRFL,YRFL
+RTPP,RTPP
+IVKA,IVKA
+KDPY,KDPY
+SSFF,SSFF
+YKPE,YKPE
+NEDG,NEDG
+YEGS,YEGS
+FGGQ,FGGQ
+NDFM,NDFM
+HNEC,HNEC
+NQLR,NQLR
+RLVW,RLVW
+NVFD,NVFD
+PMNY,PMNY
+RLHA,RLHA
+DIII,DIII
+WMLQ,WMLQ
+KACN,KACN
+IATA,IATA
+LIAS,LIAS
+SVSF,SVSF
+CKIS,CKIS
+YNFT,YNFT
+CKGC,CKGC
+EQIV,EQIV
+FRKQ,FRKQ
+VAWY,VAWY
+NWPG,NWPG
+RIHV,RIHV
+TIEC,TIEC
+NLYT,NLYT
+CTYK,CTYK
+FTQN,FTQN
+WVER,WVER
+VPII,VPII
+DKNM,DKNM
+MYEK,MYEK
+WYWF,WYWF
+IDVQ,IDVQ
+SWTV,SWTV
+DTVE,DTVE
+CDKP,CDKP
+WEEQ,WEEQ
+AFRC,AFRC
+NTKQ,NTKQ
+KQED,KQED
+PESP,PESP
+HDTQ,HDTQ
+VHHE,VHHE
+SWGA,SWGA
+YEHR,YEHR
+EDWE,EDWE
+QSVY,QSVY
+AMWP,AMWP
+VLHP,VLHP
+KEYR,KEYR
+ECKA,ECKA
+LIAN,LIAN
+SFHW,SFHW
+VCHQ,VCHQ
+CHYW,CHYW
+PVPV,PVPV
+SPSG,SPSG
+LRIA,LRIA
+YQYS,YQYS
+GGLV,GGLV
+DTTL,DTTL
+TKKN,TKKN
+QIYT,QIYT
+NMYD,NMYD
+EFRP,EFRP
+FTIK,FTIK
+WLWV,WLWV
+CKVC,CKVC
+TPIG,TPIG
+WEWH,WEWH
+QCVC,QCVC
+NTDK,NTDK
+WDCT,WDCT
+RMKF,RMKF
+LRIY,LRIY
+FETM,FETM
+ECRP,ECRP
+RFVF,RFVF
+VQIP,VQIP
+DQEE,DQEE
+MVLS,MVLS
+CYIT,CYIT
+FNPE,FNPE
+IAGE,IAGE
+LMWK,LMWK
+GQAS,GQAS
+LEWQ,LEWQ
+IGHI,IGHI
+ICMM,ICMM
+MEDM,MEDM
+FGRY,FGRY
+VGWW,VGWW
+KDIN,KDIN
+RGRW,RGRW
+YGES,YGES
+HNTA,HNTA
+EGNH,EGNH
+VNTW,VNTW
+PPVQ,PPVQ
+PWWA,PWWA
+MTHR,MTHR
+NKCN,NKCN
+IGRL,IGRL
+FIWM,FIWM
+PGTT,PGTT
+HGAE,HGAE
+PMWS,PMWS
+KWNC,KWNC
+GFDW,GFDW
+QKKG,QKKG
+HVTG,HVTG
+SGET,SGET
+AWKW,AWKW
+TRPE,TRPE
+RVHE,RVHE
+EEPS,EEPS
+CVSY,CVSY
+SRPE,SRPE
+LMMY,LMMY
+CSDW,CSDW
+RIHP,RIHP
+YDTM,YDTM
+YTYT,YTYT
+GSHI,GSHI
+NCRV,NCRV
+MGVK,MGVK
+LWNY,LWNY
+MYWC,MYWC
+ETST,ETST
+NCVV,NCVV
+TIEI,TIEI
+DMMK,DMMK
+NMIR,NMIR
+EFVF,EFVF
+KTSK,KTSK
+EQFD,EQFD
+PVMD,PVMD
+IGYL,IGYL
+LLLM,LLLM
+HDRC,HDRC
+QGCV,QGCV
+WQPH,WQPH
+DRWA,DRWA
+MVVG,MVVG
+TMMC,TMMC
+KVYN,KVYN
+AIIA,AIIA
+FNYS,FNYS
+HRCA,HRCA
+IAWP,IAWP
+VDYL,VDYL
+VICL,VICL
+HYDA,HYDA
+ADSA,ADSA
+TYYT,TYYT
+SQRL,SQRL
+EIQM,EIQM
+HRNL,HRNL
+DQVF,DQVF
+PTWK,PTWK
+LCSY,LCSY
+FHST,FHST
+DKQV,DKQV
+PFSM,PFSM
+QLAQ,QLAQ
+EDMF,EDMF
+EKEN,EKEN
+LMPW,LMPW
+CALR,CALR
+RPAY,RPAY
+HVCH,HVCH
+GVQA,GVQA
+TLGN,TLGN
+QFIR,QFIR
+LKYW,LKYW
+MTWR,MTWR
+VRMD,VRMD
+LLFQ,LLFQ
+CEVE,CEVE
+MDDA,MDDA
+WPVP,WPVP
+DTVI,DTVI
+WGVM,WGVM
+DYDT,DYDT
+NWKV,NWKV
+DLPC,DLPC
+LEMF,LEMF
+VHVQ,VHVQ
+RVWF,RVWF
+KNDW,KNDW
+EAMT,EAMT
+IQLT,IQLT
+HYYY,HYYY
+PEGN,PEGN
+TRQR,TRQR
+EIML,EIML
+ETGF,ETGF
+QQSV,QQSV
+KFIP,KFIP
+TVAM,TVAM
+GTHA,GTHA
+QCHI,QCHI
+IGIR,IGIR
+HQLS,HQLS
+QYQM,QYQM
+PNEP,PNEP
+RKSK,RKSK
+AAYG,AAYG
+ATCM,ATCM
+DDCH,DDCH
+NTAF,NTAF
+LHNG,LHNG
+ECIA,ECIA
+EWAA,EWAA
+CKSK,CKSK
+MDTH,MDTH
+DNCP,DNCP
+NLDP,NLDP
+KFVS,KFVS
+TSLV,TSLV
+QVCA,QVCA
+DPDM,DPDM
+LSGA,LSGA
+MLVC,MLVC
+IAPM,IAPM
+CGFY,CGFY
+VIHV,VIHV
+GLRD,GLRD
+EYDE,EYDE
+FNEP,FNEP
+DIMC,DIMC
+AFIC,AFIC
+KFMD,KFMD
+YFNI,YFNI
+HTMD,HTMD
+EKFN,EKFN
+NFII,NFII
+MNHN,MNHN
+PFGK,PFGK
+EWSD,EWSD
+SGMK,SGMK
+SHTM,SHTM
+RFQL,RFQL
+LNTY,LNTY
+EWPT,EWPT
+KINA,KINA
+YYED,YYED
+LGSD,LGSD
+CRNH,CRNH
+NNSK,NNSK
+SPIQ,SPIQ
+KWQV,KWQV
+KKQA,KKQA
+TSFI,TSFI
+NPFE,NPFE
+MKCE,MKCE
+EQKH,EQKH
+WENH,WENH
+VDLI,VDLI
+WVDF,WVDF
+FFAM,FFAM
+SPSP,SPSP
+TWKI,TWKI
+TWTC,TWTC
+RTGE,RTGE
+SFSI,SFSI
+WTEF,WTEF
+DIFH,DIFH
+QFGV,QFGV
+NRRP,NRRP
+GHHS,GHHS
+IYMN,IYMN
+TTWT,TTWT
+NVSG,NVSG
+LAKQ,LAKQ
+WNAI,WNAI
+GHWG,GHWG
+SPPG,SPPG
+FWKT,FWKT
+ERKH,ERKH
+WWLW,WWLW
+MNKM,MNKM
+RITQ,RITQ
+MFMR,MFMR
+KVHQ,KVHQ
+TFFD,TFFD
+FWFT,FWFT
+LHLT,LHLT
+LQQF,LQQF
+CWVA,CWVA
+IRQW,IRQW
+EGHH,EGHH
+VHLC,VHLC
+TVKK,TVKK
+QSQH,QSQH
+DFIT,DFIT
+IGRW,IGRW
+FVHC,FVHC
+TERW,TERW
+KFSH,KFSH
+FECP,FECP
+DWFG,DWFG
+SWIH,SWIH
+KGTR,KGTR
+HEII,HEII
+PHDF,PHDF
+QLQA,QLQA
+RLYF,RLYF
+TGYA,TGYA
+KRKH,KRKH
+YQCY,YQCY
+MPWS,MPWS
+SQTV,SQTV
+RRNV,RRNV
+HPCP,HPCP
+SVRC,SVRC
+GHVA,GHVA
+LNVW,LNVW
+PSRY,PSRY
+ICRN,ICRN
+YTNI,YTNI
+YGIM,YGIM
+GGNN,GGNN
+TWEG,TWEG
+NCYT,NCYT
+WNDT,WNDT
+EVSF,EVSF
+KCDN,KCDN
+YYVE,YYVE
+RFVY,RFVY
+AVIG,AVIG
+AVKT,AVKT
+KKLH,KKLH
+MLTD,MLTD
+TPMH,TPMH
+LAQY,LAQY
+GDIH,GDIH
+NVEM,NVEM
+THMI,THMI
+EMLC,EMLC
+TFCW,TFCW
+RVQA,RVQA
+WHED,WHED
+SLRQ,SLRQ
+CKHA,CKHA
+INVT,INVT
+QHTI,QHTI
+VQYL,VQYL
+FSWQ,FSWQ
+SFSW,SFSW
+KPFI,KPFI
+QIND,QIND
+KWYI,KWYI
+IVFD,IVFD
+TYSC,TYSC
+KYGD,KYGD
+KDID,KDID
+HQTQ,HQTQ
+SACQ,SACQ
+VYIV,VYIV
+PNLV,PNLV
+MHFD,MHFD
+KWCN,KWCN
+GMRN,GMRN
+PIHW,PIHW
+QRYQ,QRYQ
+GESI,GESI
+WCHK,WCHK
+HQTR,HQTR
+PNDQ,PNDQ
+SRIN,SRIN
+FLWG,FLWG
+NGSN,NGSN
+GKSF,GKSF
+PCMM,PCMM
+DQPL,DQPL
+SYQY,SYQY
+YYTT,YYTT
+VIRS,VIRS
+LSSM,LSSM
+RACV,RACV
+KSTA,KSTA
+NFTQ,NFTQ
+CVVM,CVVM
+WTNV,WTNV
+LCVG,LCVG
+IMTD,IMTD
+HTHW,HTHW
+GNEP,GNEP
+NGQG,NGQG
+TFKL,TFKL
+SVYH,SVYH
+TVCM,TVCM
+CQYY,CQYY
+FFSS,FFSS
+TWVS,TWVS
+KMKK,KMKK
+VNVQ,VNVQ
+PWEA,PWEA
+LDIG,LDIG
+DFVM,DFVM
+SAAE,SAAE
+NQPC,NQPC
+ADMI,ADMI
+ETDI,ETDI
+FCCD,FCCD
+EDVT,EDVT
+YPLG,YPLG
+CLCS,CLCS
+CTTS,CTTS
+KYLL,KYLL
+QVGN,QVGN
+KPRW,KPRW
+DEQN,DEQN
+KHAQ,KHAQ
+TFSK,TFSK
+MMTS,MMTS
+QQHD,QQHD
+CSYV,CSYV
+DYGS,DYGS
+ITKD,ITKD
+LWLA,LWLA
+GKRS,GKRS
+YWLV,YWLV
+EFAN,EFAN
+MPMS,MPMS
+MAYH,MAYH
+PCRG,PCRG
+WEKY,WEKY
+MGED,MGED
+AQQM,AQQM
+CYCW,CYCW
+IEDM,IEDM
+NEND,NEND
+SFEE,SFEE
+FQNE,FQNE
+LPLF,LPLF
+MQCV,MQCV
+YDYS,YDYS
+IDCA,IDCA
+EWDN,EWDN
+TGWP,TGWP
+SPWD,SPWD
+DIDS,DIDS
+EVTC,EVTC
+KMIK,KMIK
+GDSE,GDSE
+DCYA,DCYA
+YLET,YLET
+LLCC,LLCC
+TGEQ,TGEQ
+IMWR,IMWR
+WQQW,WQQW
+QPPG,QPPG
+AMEV,AMEV
+TYEF,TYEF
+DGHR,DGHR
+HPHP,HPHP
+GHHY,GHHY
+ARNE,ARNE
+ACTC,ACTC
+PTNL,PTNL
+KWWQ,KWWQ
+EPSF,EPSF
+PIDQ,PIDQ
+QTIW,QTIW
+DAMF,DAMF
+RKGV,RKGV
+DDHT,DDHT
+TFIR,TFIR
+LQQC,LQQC
+RDWA,RDWA
+FINQ,FINQ
+VRAK,VRAK
+FDEE,FDEE
+RTCP,RTCP
+LHWM,LHWM
+KDNC,KDNC
+VLVP,VLVP
+VFEW,VFEW
+QIIN,QIIN
+DSQR,DSQR
+LNDW,LNDW
+VIPR,VIPR
+HQWN,HQWN
+NLDH,NLDH
+MSHM,MSHM
+STGT,STGT
+YQYH,YQYH
+KLRI,KLRI
+MMKE,MMKE
+VRKW,VRKW
+VKYE,VKYE
+DEAH,DEAH
+PECI,PECI
+CADI,CADI
+VSAK,VSAK
+ENMS,ENMS
+PSSQ,PSSQ
+DKCQ,DKCQ
+IDCS,IDCS
+SLLK,SLLK
+DPHG,DPHG
+HMFA,HMFA
+WRHF,WRHF
+KPKS,KPKS
+NEPY,NEPY
+CMIN,CMIN
+KAYQ,KAYQ
+TTMH,TTMH
+DDVL,DDVL
+ERPG,ERPG
+KKMP,KKMP
+TENK,TENK
+LNWM,LNWM
+GHAL,GHAL
+WMKD,WMKD
+FIWK,FIWK
+SWMY,SWMY
+LYHF,LYHF
+MKYP,MKYP
+REMS,REMS
+AMFA,AMFA
+YSYT,YSYT
+EKKW,EKKW
+LRTG,LRTG
+RFMT,RFMT
+LHHW,LHHW
+KAPS,KAPS
+TFTD,TFTD
+IMSG,IMSG
+YKMQ,YKMQ
+CPPP,CPPP
+FMDA,FMDA
+YYAM,YYAM
+GTSS,GTSS
+ALYP,ALYP
+RYND,RYND
+WWFL,WWFL
+WYAT,WYAT
+CIMM,CIMM
+IVHK,IVHK
+RYSF,RYSF
+ENEA,ENEA
+WPFT,WPFT
+QVLH,QVLH
+ECFV,ECFV
+HQPP,HQPP
+SQQV,SQQV
+NRTP,NRTP
+WEEA,WEEA
+ICNQ,ICNQ
+KVDG,KVDG
+GSLK,GSLK
+CMVY,CMVY
+GNNK,GNNK
+IRQM,IRQM
+ASHG,ASHG
+PHEM,PHEM
+NNSM,NNSM
+ADRM,ADRM
+TAYW,TAYW
+FCDK,FCDK
+ETYQ,ETYQ
+MMYF,MMYF
+FLIM,FLIM
+GKFT,GKFT
+IQAK,IQAK
+GINY,GINY
+VILD,VILD
+CPLH,CPLH
+LVHQ,LVHQ
+LCKP,LCKP
+RVNH,RVNH
+HCGK,HCGK
+HCQH,HCQH
+GFKI,GFKI
+AGET,AGET
+AIHM,AIHM
+QITF,QITF
+RWFE,RWFE
+GYED,GYED
+PCSM,PCSM
+CREN,CREN
+ASAL,ASAL
+VRTV,VRTV
+AQVE,AQVE
+QFND,QFND
+FGGR,FGGR
+KEAT,KEAT
+CRVT,CRVT
+PKKG,PKKG
+PHQM,PHQM
+PAKY,PAKY
+IYSC,IYSC
+GVVM,GVVM
+IKLF,IKLF
+HHYG,HHYG
+SACL,SACL
+GQCS,GQCS
+AQIM,AQIM
+FCVN,FCVN
+HVWG,HVWG
+NADT,NADT
+MHKK,MHKK
+VWLY,VWLY
+FPCQ,FPCQ
+PEKW,PEKW
+AFYP,AFYP
+TQYY,TQYY
+VECI,VECI
+KWFQ,KWFQ
+TIEG,TIEG
+STHY,STHY
+QSAM,QSAM
+RNDD,RNDD
+EQHA,EQHA
+VCFH,VCFH
+YRWF,YRWF
+VQKH,VQKH
+CSRT,CSRT
+PRNF,PRNF
+ADIG,ADIG
+FHNV,FHNV
+NVAH,NVAH
+WYLN,WYLN
+DKWK,DKWK
+GIWI,GIWI
+MEEF,MEEF
+HCMM,HCMM
+TLIM,TLIM
+PYKV,PYKV
+YATS,YATS
+QMQW,QMQW
+KMLA,KMLA
+ALWW,ALWW
+WKHD,WKHD
+DVHP,DVHP
+EYHF,EYHF
+DLSY,DLSY
+NIRC,NIRC
+GGFI,GGFI
+RGWM,RGWM
+SWMR,SWMR
+FNQD,FNQD
+WMAY,WMAY
+ITKT,ITKT
+LIAV,LIAV
+CHTP,CHTP
+QIDD,QIDD
+PHAG,PHAG
+IDNA,IDNA
+DHSC,DHSC
+EWLA,EWLA
+FSLW,FSLW
+QEYK,QEYK
+LHHR,LHHR
+VQYS,VQYS
+VDQD,VDQD
+RGGL,RGGL
+ERTH,ERTH
+WYDD,WYDD
+EMFN,EMFN
+DKEP,DKEP
+TLCW,TLCW
+QSHE,QSHE
+IDLS,IDLS
+KKRT,KKRT
+CHQI,CHQI
+PLWC,PLWC
+VIVA,VIVA
+KDTG,KDTG
+PTVC,PTVC
+YICD,YICD
+CKRT,CKRT
+DIDP,DIDP
+DTEI,DTEI
+GIAK,GIAK
+KQLM,KQLM
+PYPN,PYPN
+LFLK,LFLK
+MRGF,MRGF
+FAMD,FAMD
+TNTS,TNTS
+MMIA,MMIA
+HPQM,HPQM
+FHEQ,FHEQ
+CHLP,CHLP
+NMFS,NMFS
+LSRR,LSRR
+CSSG,CSSG
+PYHS,PYHS
+ILDG,ILDG
+MHWD,MHWD
+QCNV,QCNV
+QILA,QILA
+QSCQ,QSCQ
+QYTN,QYTN
+WKPR,WKPR
+RTHR,RTHR
+FYMW,FYMW
+SGGN,SGGN
+CAHL,CAHL
+HNIR,HNIR
+MFKN,MFKN
+KLTN,KLTN
+CKGT,CKGT
+CNHN,CNHN
+FIVT,FIVT
+MCWG,MCWG
+TPPR,TPPR
+FLEW,FLEW
+QSHA,QSHA
+DKAD,DKAD
+DIVY,DIVY
+MKVM,MKVM
+TACP,TACP
+TWNE,TWNE
+HAYR,HAYR
+VYRY,VYRY
+PDKC,PDKC
+WTCY,WTCY
+AMWN,AMWN
+FRFY,FRFY
+IMRC,IMRC
+VNPA,VNPA
+RPDP,RPDP
+TLEF,TLEF
+DLNF,DLNF
+TCPQ,TCPQ
+VLRR,VLRR
+WKWF,WKWF
+VEHK,VEHK
+DNEA,DNEA
+DIVA,DIVA
+FNSQ,FNSQ
+QYTG,QYTG
+WPSR,WPSR
+VATT,VATT
+CMIF,CMIF
+EREH,EREH
+LGKL,LGKL
+AWQH,AWQH
+KRCC,KRCC
+MWCW,MWCW
+VCGY,VCGY
+SFFG,SFFG
+TNRR,TNRR
+LCVI,LCVI
+DLSG,DLSG
+LTIN,LTIN
+NNDW,NNDW
+QIFI,QIFI
+DAQL,DAQL
+DYRG,DYRG
+HAWD,HAWD
+TKKH,TKKH
+HVPF,HVPF
+CMSK,CMSK
+HYAK,HYAK
+CTHE,CTHE
+ACLN,ACLN
+ILRS,ILRS
+RAHP,RAHP
+TTCW,TTCW
+LIFD,LIFD
+YRPE,YRPE
+GGEA,GGEA
+LGSN,LGSN
+HETY,HETY
+HVYV,HVYV
+PRLD,PRLD
+WYCQ,WYCQ
+TMQM,TMQM
+QNRH,QNRH
+PALF,PALF
+FDHP,FDHP
+DNET,DNET
+AKLN,AKLN
+IQGF,IQGF
+IMHG,IMHG
+NGPL,NGPL
+NVCF,NVCF
+LIFN,LIFN
+WLAP,WLAP
+WCGQ,WCGQ
+SGWP,SGWP
+HGFQ,HGFQ
+GQFR,GQFR
+NQER,NQER
+GRAM,GRAM
+GASV,GASV
+VWLA,VWLA
+QMMC,QMMC
+YLMA,YLMA
+FAEL,FAEL
+KEYH,KEYH
+GDFY,GDFY
+RPQT,RPQT
+MWVK,MWVK
+GWVS,GWVS
+WNKY,WNKY
+LCRD,LCRD
+CTKF,CTKF
+VCYP,VCYP
+SQFQ,SQFQ
+YLSR,YLSR
+HESM,HESM
+MVRG,MVRG
+LFEM,LFEM
+TCLH,TCLH
+LGEL,LGEL
+WYLC,WYLC
+GQRD,GQRD
+PHGL,PHGL
+WCDN,WCDN
+MVVI,MVVI
+RHYP,RHYP
+WSMV,WSMV
+YITL,YITL
+DYHL,DYHL
+MELW,MELW
+REYD,REYD
+VREK,VREK
+NCTQ,NCTQ
+HTWQ,HTWQ
+YSHI,YSHI
+WRIN,WRIN
+QGAY,QGAY
+NTQD,NTQD
+YRLW,YRLW
+LKYP,LKYP
+HYKY,HYKY
+AYQP,AYQP
+GFCI,GFCI
+GAMQ,GAMQ
+YPSG,YPSG
+YLNI,YLNI
+LYPL,LYPL
+SYCY,SYCY
+VGVW,VGVW
+NPPW,NPPW
+NMNG,NMNG
+RMSM,RMSM
+YHGR,YHGR
+LEPK,LEPK
+FYYH,FYYH
+TGVC,TGVC
+GQWY,GQWY
+IQDK,IQDK
+HQWA,HQWA
+TTYP,TTYP
+RPIM,RPIM
+HDEW,HDEW
+EKFK,EKFK
+TMNI,TMNI
+EQLS,EQLS
+VRIY,VRIY
+RHQH,RHQH
+HKWC,HKWC
+RQDW,RQDW
+NAEN,NAEN
+QLGK,QLGK
+PYFA,PYFA
+QDPF,QDPF
+LFFR,LFFR
+FEQT,FEQT
+CRYR,CRYR
+NGVY,NGVY
+KYLC,KYLC
+GYMS,GYMS
+NWHA,NWHA
+MLWS,MLWS
+NATQ,NATQ
+WIMA,WIMA
+AIGY,AIGY
+PAEF,PAEF
+MEIK,MEIK
+AILP,AILP
+ENWC,ENWC
+SMID,SMID
+APYM,APYM
+PSCG,PSCG
+ATSP,ATSP
+FFDQ,FFDQ
+FEYQ,FEYQ
+RRLH,RRLH
+QCLR,QCLR
+CQFG,CQFG
+SLWF,SLWF
+PGFK,PGFK
+KVDL,KVDL
+INPN,INPN
+LGAH,LGAH
+YCGI,YCGI
+YKIK,YKIK
+YCPT,YCPT
+KRGW,KRGW
+YTHK,YTHK
+GIPV,GIPV
+IVYQ,IVYQ
+VYNW,VYNW
+TTDF,TTDF
+MFNM,MFNM
+PIRS,PIRS
+PMWH,PMWH
+QLLN,QLLN
+PCIN,PCIN
+VPWE,VPWE
+VFNK,VFNK
+WTTV,WTTV
+SYPT,SYPT
+RDVN,RDVN
+CHPL,CHPL
+HSYA,HSYA
+KDTH,KDTH
+LTNM,LTNM
+GQPN,GQPN
+VEWI,VEWI
+RMLT,RMLT
+ENRS,ENRS
+RSMM,RSMM
+GSCI,GSCI
+SCEE,SCEE
+PFKV,PFKV
+YFDA,YFDA
+DCLA,DCLA
+HSHA,HSHA
+MVGG,MVGG
+FVDY,FVDY
+LIYY,LIYY
+DNQR,DNQR
+DFVS,DFVS
+VMLY,VMLY
+ETIR,ETIR
+MEME,MEME
+NSRN,NSRN
+EDEM,EDEM
+MMGP,MMGP
+QIQD,QIQD
+QNTE,QNTE
+VWFP,VWFP
+KLIY,KLIY
+WHYL,WHYL
+RGWE,RGWE
+WNTL,WNTL
+WDGL,WDGL
+RCEF,RCEF
+FEFV,FEFV
+ACGA,ACGA
+WLEA,WLEA
+NHYN,NHYN
+WMEM,WMEM
+YEEQ,YEEQ
+CYGR,CYGR
+QADC,QADC
+AGVP,AGVP
+MITR,MITR
+QDPC,QDPC
+FNWP,FNWP
+EFHR,EFHR
+NNPP,NNPP
+WMVF,WMVF
+DDRT,DDRT
+ILAP,ILAP
+DSNK,DSNK
+DYMN,DYMN
+HYTA,HYTA
+YKDI,YKDI
+TKIF,TKIF
+LWIK,LWIK
+RLRP,RLRP
+EAGH,EAGH
+WFHL,WFHL
+TIET,TIET
+RDIM,RDIM
+CMIM,CMIM
+AIFA,AIFA
+YDGQ,YDGQ
+DAFK,DAFK
+CDYL,CDYL
+DRKQ,DRKQ
+EESF,EESF
+IMQT,IMQT
+CIKV,CIKV
+WPTL,WPTL
+RIAK,RIAK
+PEKT,PEKT
+HFHH,HFHH
+HAHK,HAHK
+PWLE,PWLE
+QHTV,QHTV
+AKAP,AKAP
+GMMM,GMMM
+MLCG,MLCG
+KNAF,KNAF
+TNPQ,TNPQ
+GTYH,GTYH
+WYEC,WYEC
+GCDC,GCDC
+FVMF,FVMF
+AQTR,AQTR
+SGLL,SGLL
+VCFQ,VCFQ
+FFHT,FFHT
+QIDP,QIDP
+QNLR,QNLR
+EPYF,EPYF
+KMMT,KMMT
+WFTA,WFTA
+DSQW,DSQW
+CIVI,CIVI
+RCFH,RCFH
+CKSQ,CKSQ
+KQLY,KQLY
+FVHW,FVHW
+GKKL,GKKL
+VIDG,VIDG
+FATV,FATV
+ELCT,ELCT
+LDNI,LDNI
+NQIV,NQIV
+ECMW,ECMW
+YFHS,YFHS
+YSAS,YSAS
+WAKL,WAKL
+NSWN,NSWN
+DCMT,DCMT
+HNLH,HNLH
+TTAF,TTAF
+TQLW,TQLW
+KHMK,KHMK
+NPKL,NPKL
+VSIE,VSIE
+NAFY,NAFY
+CFCQ,CFCQ
+PSSP,PSSP
+RIPA,RIPA
+EYHC,EYHC
+LEQE,LEQE
+VFEY,VFEY
+TDRE,TDRE
+PFRL,PFRL
+LARK,LARK
+ATQI,ATQI
+AMPG,AMPG
+KHTN,KHTN
+MSKR,MSKR
+AGWM,AGWM
+DPND,DPND
+GLYG,GLYG
+MKCK,MKCK
+CQQF,CQQF
+CTCG,CTCG
+AIRV,AIRV
+DADI,DADI
+MGDL,MGDL
+FKGP,FKGP
+NWLS,NWLS
+CMSN,CMSN
+EMRG,EMRG
+WMEH,WMEH
+GDDP,GDDP
+SLIC,SLIC
+INSK,INSK
+DVHY,DVHY
+YRMG,YRMG
+IDHL,IDHL
+MARL,MARL
+WVCY,WVCY
+CKEE,CKEE
+VIYW,VIYW
+IRTD,IRTD
+QQRF,QQRF
+TVAI,TVAI
+YEKT,YEKT
+LSSF,LSSF
+HAWV,HAWV
+RERS,RERS
+SNGL,SNGL
+ETEA,ETEA
+DSPN,DSPN
+SVTP,SVTP
+VEHQ,VEHQ
+LDNC,LDNC
+EQPV,EQPV
+LCPI,LCPI
+NPPR,NPPR
+HDFV,HDFV
+MKGW,MKGW
+CSFY,CSFY
+KFPH,KFPH
+CNYD,CNYD
+SDMN,SDMN
+CSDC,CSDC
+TTTM,TTTM
+HQVK,HQVK
+ALQA,ALQA
+VIGC,VIGC
+IIHI,IIHI
+IWPY,IWPY
+HLDY,HLDY
+YCIW,YCIW
+HVGA,HVGA
+WHIA,WHIA
+ARVC,ARVC
+SEFA,SEFA
+PYKS,PYKS
+QDWV,QDWV
+GLKL,GLKL
+VLEA,VLEA
+KYAT,KYAT
+GAKS,GAKS
+WVLA,WVLA
+DNTM,DNTM
+WMGV,WMGV
+HLYK,HLYK
+TYHF,TYHF
+LSHV,LSHV
+RNCE,RNCE
+KVQF,KVQF
+DAIT,DAIT
+RRML,RRML
+MTSL,MTSL
+LTKG,LTKG
+AQNA,AQNA
+CTTP,CTTP
+IRQR,IRQR
+QWCT,QWCT
+HSHL,HSHL
+QCPG,QCPG
+MERP,MERP
+IDGG,IDGG
+CTDI,CTDI
+WTVK,WTVK
+AADY,AADY
+CEGA,CEGA
+ETAA,ETAA
+AHNR,AHNR
+WESS,WESS
+TWDE,TWDE
+QLPT,QLPT
+FAAF,FAAF
+TINK,TINK
+QESG,QESG
+DRNW,DRNW
+YTWY,YTWY
+TTCN,TTCN
+VTFP,VTFP
+PHRP,PHRP
+RFEI,RFEI
+PKEP,PKEP
+QSCW,QSCW
+VGYK,VGYK
+PPYM,PPYM
+GCDE,GCDE
+DGIS,DGIS
+HCWC,HCWC
+WPIR,WPIR
+KKMF,KKMF
+VVVV,VVVV
+GGMT,GGMT
+YKNA,YKNA
+ELAE,ELAE
+HYVR,HYVR
+IIEG,IIEG
+LETR,LETR
+TRKK,TRKK
+KTWK,KTWK
+CQHA,CQHA
+PCLP,PCLP
+WYVP,WYVP
+FYGW,FYGW
+IRPY,IRPY
+SFEP,SFEP
+DEAC,DEAC
+MHIA,MHIA
+FWPH,FWPH
+YRMQ,YRMQ
+ESAM,ESAM
+WSWY,WSWY
+MCIH,MCIH
+FNDC,FNDC
+EHFF,EHFF
+TYAH,TYAH
+SHSR,SHSR
+YNMS,YNMS
+TNCG,TNCG
+ECIF,ECIF
+HVFL,HVFL
+WYEA,WYEA
+SKEP,SKEP
+LRAR,LRAR
+PPFG,PPFG
+TGNE,TGNE
+WPHP,WPHP
+CETQ,CETQ
+QRMY,QRMY
+VPLQ,VPLQ
+ADVE,ADVE
+HGEE,HGEE
+VRGP,VRGP
+VTPT,VTPT
+ARRF,ARRF
+HMLH,HMLH
+RDWT,RDWT
+PGVH,PGVH
+DKEY,DKEY
+PLPI,PLPI
+SLHD,SLHD
+WQVK,WQVK
+PWSS,PWSS
+REHK,REHK
+NSNA,NSNA
+KNCF,KNCF
+EWPH,EWPH
+MPQG,MPQG
+DTEL,DTEL
+RASG,RASG
+CGHG,CGHG
+DCYT,DCYT
+YKCT,YKCT
+DPPQ,DPPQ
+QPIS,QPIS
+ADYS,ADYS
+GNMV,GNMV
+FAAI,FAAI
+DMQN,DMQN
+IAEL,IAEL
+TEER,TEER
+DFAR,DFAR
+DPHQ,DPHQ
+PWAD,PWAD
+PLWM,PLWM
+KCHD,KCHD
+MLEA,MLEA
+MSEK,MSEK
+DWMK,DWMK
+FNNT,FNNT
+YVCG,YVCG
+NQHS,NQHS
+IIAA,IIAA
+PVVK,PVVK
+LCPV,LCPV
+QSWE,QSWE
+IQCY,IQCY
+EAKQ,EAKQ
+CMFT,CMFT
+THWG,THWG
+IKKE,IKKE
+KLPK,KLPK
+VGHM,VGHM
+TPEL,TPEL
+RIRP,RIRP
+ITGT,ITGT
+WDRP,WDRP
+WHKT,WHKT
+SMCP,SMCP
+NYKW,NYKW
+HAAP,HAAP
+PRWL,PRWL
+YPKV,YPKV
+SHDF,SHDF
+TFKT,TFKT
+RCPL,RCPL
+ECWN,ECWN
+CPFA,CPFA
+PRNI,PRNI
+NYAG,NYAG
+RVDV,RVDV
+KQGV,KQGV
+RDKH,RDKH
+AMYF,AMYF
+IMDL,IMDL
+STAM,STAM
+GWFT,GWFT
+SFNT,SFNT
+IFGV,IFGV
+EMMI,EMMI
+GDLP,GDLP
+IDFE,IDFE
+PQFR,PQFR
+NTPP,NTPP
+CLWD,CLWD
+NHYA,NHYA
+ICMS,ICMS
+HLHC,HLHC
+KNDI,KNDI
+AWPE,AWPE
+PPCN,PPCN
+WHLQ,WHLQ
+AFMV,AFMV
+VSFD,VSFD
+WLNR,WLNR
+AMID,AMID
+HTGE,HTGE
+MPCW,MPCW
+TRTF,TRTF
+WRMV,WRMV
+ILIE,ILIE
+GPKK,GPKK
+SLQG,SLQG
+FPVY,FPVY
+WCLI,WCLI
+MYCE,MYCE
+GEQN,GEQN
+MFME,MFME
+KNKE,KNKE
+HHLF,HHLF
+VDQP,VDQP
+YGVK,YGVK
+CTLR,CTLR
+HGYN,HGYN
+VSEW,VSEW
+QPYQ,QPYQ
+QPNY,QPNY
+HDSR,HDSR
+HFTC,HFTC
+MYHV,MYHV
+LWNQ,LWNQ
+PAMN,PAMN
+PLPW,PLPW
+PMTV,PMTV
+YTDQ,YTDQ
+FCER,FCER
+QNNH,QNNH
+SFDF,SFDF
+RHQL,RHQL
+DLHE,DLHE
+KWKH,KWKH
+MQRH,MQRH
+NWET,NWET
+QVCV,QVCV
+EPEP,EPEP
+VRSE,VRSE
+ERMM,ERMM
+TVRI,TVRI
+GCMG,GCMG
+MAWA,MAWA
+DGLA,DGLA
+LPCQ,LPCQ
+THDF,THDF
+TWYH,TWYH
+IDAT,IDAT
+SFSE,SFSE
+WCHR,WCHR
+NNTH,NNTH
+QPHC,QPHC
+EERR,EERR
+EVIQ,EVIQ
+LRWA,LRWA
+LHIE,LHIE
+DATT,DATT
+ESDH,ESDH
+TRHH,TRHH
+HMGV,HMGV
+HNVN,HNVN
+MTLK,MTLK
+KGSQ,KGSQ
+GSGW,GSGW
+VPTP,VPTP
+RIGG,RIGG
+GVQR,GVQR
+ANVM,ANVM
+TQHM,TQHM
+CDGP,CDGP
+EIQR,EIQR
+SPTN,SPTN
+QWNF,QWNF
+TFFT,TFFT
+VENC,VENC
+LRKC,LRKC
+AQML,AQML
+ASGA,ASGA
+VHYM,VHYM
+QGRK,QGRK
+TGCF,TGCF
+KVLK,KVLK
+MCIN,MCIN
+APTA,APTA
+LCNK,LCNK
+CYLF,CYLF
+FCYN,FCYN
+ALGE,ALGE
+QDQP,QDQP
+VVFN,VVFN
+LLSQ,LLSQ
+GEYW,GEYW
+PFGI,PFGI
+MLQM,MLQM
+FRDP,FRDP
+EKST,EKST
+GSER,GSER
+HGPT,HGPT
+LQGA,LQGA
+VVDT,VVDT
+IGFS,IGFS
+ENWL,ENWL
+SCCA,SCCA
+WSNI,WSNI
+ALCI,ALCI
+DWFH,DWFH
+GNDD,GNDD
+NQWQ,NQWQ
+KLHW,KLHW
+WNNG,WNNG
+EETS,EETS
+HKKD,HKKD
+YCIK,YCIK
+YWKM,YWKM
+MSLT,MSLT
+HPMN,HPMN
+GRGT,GRGT
+GRNN,GRNN
+HINF,HINF
+HDIF,HDIF
+AKKT,AKKT
+HVVK,HVVK
+RTEH,RTEH
+QDKN,QDKN
+VLVT,VLVT
+VLIY,VLIY
+PVWT,PVWT
+NHTY,NHTY
+EYRT,EYRT
+ANAD,ANAD
+KAQH,KAQH
+VWCN,VWCN
+EDHN,EDHN
+DNMP,DNMP
+PIEA,PIEA
+TNIF,TNIF
+RHLM,RHLM
+FFWS,FFWS
+SFVF,SFVF
+IDEG,IDEG
+SRIK,SRIK
+WVGG,WVGG
+ICKQ,ICKQ
+HVKL,HVKL
+YNER,YNER
+IFNM,IFNM
+MCTR,MCTR
+KEKK,KEKK
+SVDK,SVDK
+IAYK,IAYK
+LPNI,LPNI
+DRWH,DRWH
+STAC,STAC
+CIQV,CIQV
+ASVA,ASVA
+EVQC,EVQC
+TLMM,TLMM
+YERP,YERP
+GNII,GNII
+HCGN,HCGN
+RECT,RECT
+HLKG,HLKG
+TRRA,TRRA
+RGES,RGES
+KKDA,KKDA
+EMFY,EMFY
+ARCE,ARCE
+VLTK,VLTK
+AMHN,AMHN
+LMQD,LMQD
+EHGH,EHGH
+QGSV,QGSV
+NCWW,NCWW
+RVSR,RVSR
+IWRS,IWRS
+EWMI,EWMI
+VFSE,VFSE
+IRLS,IRLS
+APFF,APFF
+YSWV,YSWV
+ANAL,ANAL
+VLPA,VLPA
+HTDS,HTDS
+GYKE,GYKE
+YVDL,YVDL
+MVLY,MVLY
+ITVP,ITVP
+GIHK,GIHK
+QSIW,QSIW
+ALGT,ALGT
+NVTI,NVTI
+GWVW,GWVW
+LGYN,LGYN
+YTCT,YTCT
+QWAC,QWAC
+AAMR,AAMR
+DRAT,DRAT
+CTCA,CTCA
+GYAS,GYAS
+FELH,FELH
+ATPA,ATPA
+DLMR,DLMR
+FYAH,FYAH
+WTNK,WTNK
+QHFT,QHFT
+NCCW,NCCW
+DLFE,DLFE
+LVLF,LVLF
+FASE,FASE
+ALQT,ALQT
+DINN,DINN
+WALA,WALA
+CGGS,CGGS
+GCSA,GCSA
+FCNY,FCNY
+DYTD,DYTD
+SKMQ,SKMQ
+FNDV,FNDV
+VTAA,VTAA
+LHEA,LHEA
+LFVW,LFVW
+ENHL,ENHL
+EGCY,EGCY
+HKGD,HKGD
+NACC,NACC
+HADF,HADF
+TSNK,TSNK
+ALHP,ALHP
+MAHN,MAHN
+EPEG,EPEG
+TQRA,TQRA
+QDVC,QDVC
+YEPQ,YEPQ
+WVNR,WVNR
+CVQA,CVQA
+AVVV,AVVV
+RCSP,RCSP
+FADC,FADC
+TVQA,TVQA
+VCSS,VCSS
+HNMT,HNMT
+FDNL,FDNL
+IKKQ,IKKQ
+NCEQ,NCEQ
+MVHE,MVHE
+LPIE,LPIE
+FNLH,FNLH
+VPLC,VPLC
+AGPK,AGPK
+AQIP,AQIP
+SLSE,SLSE
+SEVS,SEVS
+DLSC,DLSC
+HETF,HETF
+GQRM,GQRM
+YCEW,YCEW
+GYNC,GYNC
+CGEV,CGEV
+TNGY,TNGY
+PQEV,PQEV
+PMSP,PMSP
+EYLP,EYLP
+LHSK,LHSK
+ILRP,ILRP
+RMFL,RMFL
+CNAL,CNAL
+IHQM,IHQM
+QGES,QGES
+DHCH,DHCH
+CMPD,CMPD
+LSVQ,LSVQ
+WVPV,WVPV
+AQKR,AQKR
+EAKS,EAKS
+DDTA,DDTA
+HVLL,HVLL
+RHTK,RHTK
+AGAH,AGAH
+PTGS,PTGS
+VHDH,VHDH
+WCII,WCII
+QMGP,QMGP
+HWWY,HWWY
+KVGE,KVGE
+SPPD,SPPD
+AYLI,AYLI
+TWFS,TWFS
+TTKT,TTKT
+QHHN,QHHN
+IQYY,IQYY
+AWFM,AWFM
+ADKN,ADKN
+SEIG,SEIG
+SIRK,SIRK
+CQCG,CQCG
+NLWQ,NLWQ
+MKCR,MKCR
+NHYC,NHYC
+DMAF,DMAF
+EPMC,EPMC
+LNCI,LNCI
+NDPK,NDPK
+SVAH,SVAH
+YADM,YADM
+ANDQ,ANDQ
+QMNV,QMNV
+PWMR,PWMR
+VMHY,VMHY
+PRRP,PRRP
+DTTC,DTTC
+KGMG,KGMG
+NIFD,NIFD
+CDFS,CDFS
+CCKT,CCKT
+QLDC,QLDC
+HQKW,HQKW
+NTWH,NTWH
+PRFI,PRFI
+YARD,YARD
+PSED,PSED
+HGFP,HGFP
+RTAE,RTAE
+HGQD,HGQD
+ILLY,ILLY
+QQDC,QQDC
+IVGF,IVGF
+VTFE,VTFE
+RCTH,RCTH
+VAQC,VAQC
+WHFK,WHFK
+YWGT,YWGT
+PIPL,PIPL
+HDFY,HDFY
+HHML,HHML
+GWSG,GWSG
+SRSV,SRSV
+IWDV,IWDV
+HEIK,HEIK
+YMYA,YMYA
+LVEW,LVEW
+VERV,VERV
+KATH,KATH
+TVIN,TVIN
+EWNL,EWNL
+HNYH,HNYH
+ILRQ,ILRQ
+ATHA,ATHA
+SEVP,SEVP
+VWNV,VWNV
+TKCT,TKCT
+RYYV,RYYV
+KAKV,KAKV
+SSAY,SSAY
+LMCM,LMCM
+VVHK,VVHK
+QLVQ,QLVQ
+VNGR,VNGR
+SCVI,SCVI
+VTVG,VTVG
+HGRK,HGRK
+MEDV,MEDV
+ALRI,ALRI
+PKHD,PKHD
+QLRC,QLRC
+DHIG,DHIG
+CYWH,CYWH
+WMAL,WMAL
+YGAM,YGAM
+VGSD,VGSD
+EFYI,EFYI
+CSNS,CSNS
+EYTI,EYTI
+NDYM,NDYM
+PWST,PWST
+TCPY,TCPY
+HCDA,HCDA
+SLDY,SLDY
+VWLV,VWLV
+FEKA,FEKA
+IWPI,IWPI
+QKRM,QKRM
+FCDH,FCDH
+YYHN,YYHN
+NSMQ,NSMQ
+LVME,LVME
+HCDD,HCDD
+NAGS,NAGS
+MSVP,MSVP
+DNQC,DNQC
+LFCG,LFCG
+VTTD,VTTD
+SCKL,SCKL
+RSSI,RSSI
+RMCP,RMCP
+MTQM,MTQM
+LGRY,LGRY
+KPWM,KPWM
+RGPN,RGPN
+ERWD,ERWD
+IDRY,IDRY
+LPML,LPML
+PDAR,PDAR
+HISK,HISK
+TPCR,TPCR
+MDDL,MDDL
+GWMD,GWMD
+CVTS,CVTS
+LAID,LAID
+TVKF,TVKF
+MNVC,MNVC
+IAQE,IAQE
+IMHA,IMHA
+WHSL,WHSL
+KKGF,KKGF
+KCPR,KCPR
+THWR,THWR
+FQYV,FQYV
+IRTS,IRTS
+KVRG,KVRG
+ESEE,ESEE
+TWLW,TWLW
+DYNK,DYNK
+SKTQ,SKTQ
+IGAA,IGAA
+EQMR,EQMR
+GYVS,GYVS
+IMCH,IMCH
+GFNF,GFNF
+EIVW,EIVW
+PKFS,PKFS
+IQIT,IQIT
+VGYP,VGYP
+KVPL,KVPL
+EKTV,EKTV
+DSLP,DSLP
+SIHA,SIHA
+EPPK,EPPK
+MFHP,MFHP
+LCKA,LCKA
+VRAN,VRAN
+WDPV,WDPV
+GMAM,GMAM
+NPGM,NPGM
+VHNH,VHNH
+WCNN,WCNN
+ADNF,ADNF
+AGSC,AGSC
+VALE,VALE
+AIGG,AIGG
+PWVL,PWVL
+GGMN,GGMN
+VDWA,VDWA
+WYGE,WYGE
+PRMT,PRMT
+APAM,APAM
+DYDA,DYDA
+GHSG,GHSG
+YIPM,YIPM
+ITEM,ITEM
+YTAK,YTAK
+RVWA,RVWA
+AQPS,AQPS
+YAYN,YAYN
+WGWC,WGWC
+MTGS,MTGS
+ELVR,ELVR
+QGED,QGED
+LFPD,LFPD
+YHGA,YHGA
+PKIN,PKIN
+QKRC,QKRC
+KTRW,KTRW
+PVQD,PVQD
+NYSP,NYSP
+DDWI,DDWI
+GKAA,GKAA
+FHAQ,FHAQ
+HFVT,HFVT
+KWLY,KWLY
+VRQC,VRQC
+TWER,TWER
+AMEF,AMEF
+HIWR,HIWR
+VDEC,VDEC
+FLDR,FLDR
+MNTM,MNTM
+SKNF,SKNF
+IKER,IKER
+NLMT,NLMT
+QFMC,QFMC
+KGSE,KGSE
+HPNT,HPNT
+EYYH,EYYH
+FAPR,FAPR
+VSDL,VSDL
+DYME,DYME
+EGKV,EGKV
+SNGF,SNGF
+QKPM,QKPM
+FKST,FKST
+EMPY,EMPY
+TMCF,TMCF
+FMDK,FMDK
+VPYD,VPYD
+PRRN,PRRN
+WGPV,WGPV
+MGPI,MGPI
+KHDQ,KHDQ
+YCSM,YCSM
+MLAE,MLAE
+CVEK,CVEK
+MQAV,MQAV
+WGCR,WGCR
+RRVY,RRVY
+GINC,GINC
+QTSD,QTSD
+RDLK,RDLK
+IQTT,IQTT
+KQDD,KQDD
+FNYW,FNYW
+CHHY,CHHY
+YVCR,YVCR
+RTKF,RTKF
+MGEQ,MGEQ
+CCRV,CCRV
+SMQE,SMQE
+DCNY,DCNY
+DWKQ,DWKQ
+IVFT,IVFT
+PCHQ,PCHQ
+SPSR,SPSR
+FFTN,FFTN
+WVDV,WVDV
+MWRQ,MWRQ
+CEDC,CEDC
+NWGD,NWGD
+GGHG,GGHG
+SMRW,SMRW
+WNEF,WNEF
+GMRD,GMRD
+WCTM,WCTM
+VLGF,VLGF
+VYHK,VYHK
+LKSQ,LKSQ
+MEDW,MEDW
+DNGG,DNGG
+DGIK,DGIK
+VKEP,VKEP
+DPWG,DPWG
+RRET,RRET
+LDMR,LDMR
+WFND,WFND
+SKDS,SKDS
+ERIL,ERIL
+IKIM,IKIM
+ITRE,ITRE
+DMNE,DMNE
+FACL,FACL
+ACDG,ACDG
+SNPI,SNPI
+QHSM,QHSM
+PSGD,PSGD
+IPLY,IPLY
+TSVR,TSVR
+FSAF,FSAF
+IQKY,IQKY
+NFST,NFST
+WVGW,WVGW

data/splits/4AA_val.csv

@@ -0,0 +1,101 @@
+name,seqres
+EHFR,EHFR
+IMCP,IMCP
+YVTL,YVTL
+GQGV,GQGV
+PCFK,PCFK
+VVIV,VVIV
+QYTC,QYTC
+WGDY,WGDY
+CWLF,CWLF
+QHIN,QHIN
+ASKI,ASKI
+KITV,KITV
+SLYW,SLYW
+REVV,REVV
+NYLE,NYLE
+QGRE,QGRE
+AEHY,AEHY
+SRPT,SRPT
+NGDS,NGDS
+ATVV,ATVV
+DKFA,DKFA
+MSTP,MSTP
+VNWW,VNWW
+LDNH,LDNH
+CHSI,CHSI
+YFCS,YFCS
+WLSC,WLSC
+YYTK,YYTK
+GPNT,GPNT
+LTQE,LTQE
+VMHV,VMHV
+GTLM,GTLM
+QRRW,QRRW
+EGDW,EGDW
+IFRG,IFRG
+LRYM,LRYM
+ITGR,ITGR
+PTNI,PTNI
+KQSH,KQSH
+WTWS,WTWS
+CASF,CASF
+VKFG,VKFG
+GQYP,GQYP
+CMYH,CMYH
+VFGD,VFGD
+KWIC,KWIC
+PQHG,PQHG
+FLIS,FLIS
+QEGR,QEGR
+WQTE,WQTE
+MHTN,MHTN
+ISML,ISML
+HRCS,HRCS
+EQVR,EQVR
+NNKC,NNKC
+MVQY,MVQY
+FART,FART
+ENKE,ENKE
+TIDH,TIDH
+RDTI,RDTI
+KAPF,KAPF
+ICLP,ICLP
+HDQW,HDQW
+HAPV,HAPV
+AMEN,AMEN
+GPHG,GPHG
+QHFV,QHFV
+GHSS,GHSS
+NEEE,NEEE
+PRGM,PRGM
+YNML,YNML
+RHDG,RHDG
+VMVL,VMVL
+ETYF,ETYF
+EGVT,EGVT
+CWFC,CWFC
+DNYP,DNYP
+RREW,RREW
+QDCN,QDCN
+QNCG,QNCG
+VVVR,VVVR
+FRPQ,FRPQ
+FVFN,FVFN
+PEPR,PEPR
+TQVK,TQVK
+FCND,FCND
+FVLS,FVLS
+NMSG,NMSG
+KCWL,KCWL
+LMWL,LMWL
+WDHC,WDHC
+VGWM,VGWM
+NLQW,NLQW
+CETY,CETY
+EFMM,EFMM
+EDTV,EDTV
+PIRK,PIRK
+YTPA,YTPA
+HEKI,HEKI
+GYQH,GYQH

data/splits/atlas_test.csv

@@ -0,0 +1,83 @@
+name,seqres,release_date,msa_id,seqlen
+6o2v_A,GWNDPDRMLLRDVKALTLHYDRYTTSRRLDPIPQLKCVGGTAGCDSYTPKVIQCQNKGWDGYDVQWECCTDLDIAYKFGKTVVSCEGYESSEDQYVLRGSCGLEYNLDYTELGLQKLKESGKQHGFCSFSDYYYK,2019-05-29,6o2v_A,135
+7ead_A,GLPYPEGYRFWTHVKSMELKPGHPLYESFGGLHHIYVNPTGLRTYLEGKKAPFPKGTVIVFDLLEAKVEGNALLEGPRKLIGVMAKDPGRYPDTGGWGYYAFGPDKKPLAIDPKACHACHQGAANTDYVFSAFRP,2022-03-09,7ead_A,135
+6uof_A,DILTVEKLYRPSHEYGFLRETDTVKDYLDLVRKNRSSRFPVINQHQVVVGVVTMRDAGDKSPSTTIDKVMSRSLFLVGLSTNIANVSQRMIAEDFEMVPVVRSNQTLLGVVTRRDVMEK,2019-11-06,6uof_A,119
+6lus_A,DILTLENLGDILKYLNSADLTTLDEVSMRAALSLTCAGIRKTSRSMINTLTEQHVSAENLSPDQTQIIKQTYTGIHLDKGGNFEAALWKNWDRRSISLFLQAAISVLNTTPCESSKSVISAYNHFLQKPGDIK,2020-12-02,6lus_A,133
+6qj0_A,MRVTELIIDGFKSYAVRTVITGWDESFNAVTGLNGSGKSNILDAICFVLGITNMSTVRAQNLQDLIYKRGQAGVTKASVTIVFDNRDKKRSPIGFEEYATISVTRQIVLGGTTKYLINGHRAQQQTVQNLFQSVQLNINNPNFLIMQGRITKVLNMKPAEILAMIEEAAGTRMFEDRKEKALKTMAKKDLKLQEITELLRDEIEPKLEKLRQEKRSGGSGGSMNMIDSVEKKEMSLKHMMKTVLKDKHKIEETIATLDEYKRKALQETWEKVNGDFGQIFNELLPGSFAKLEPPEGKDLTDGLEVKVRLGKVWKQSLTELSGGQRSLIALSLIMALLQFKPAPMYILDEVDAALDLSHTQNIGRLIKTRFKGSQFIVVSLKDGMFQNANRIFRVRFSEGTSVVQALTPADLK,2019-07-03,6qj0_A,412
+6j56_A,ARQREIEMNRQQRFFRIPFIRPADQYKDPQSKKKGWWYAHFDGPWIARQMELHPDKPPILLVAGKDDMEMCELNLEETGLTRKRGAEILPRQFEEIWERCGGIQYLQNAIESRQARPTYATAMLQSLLK,2019-08-21,6j56_A,129
+7ec1_A,SMNYFVGNSLGVNLTGIEKAIINRLNLFKEMGRPAQCVFLSWNRYLYRNAQNYITSSDYINMYDFFQEATYLERNEPFDWLSYWTDECHYTLKHVENSHDFRIYDQERFLMYAHFQDPKYRILDYVNHFDSQRRKVKRDFYDVRGFLSCSRILVDKQQTLCEFFYNPEGDTKLEKYFSYKDGKPEVQKIIVYYANKQYFFNNETELGAFFIKQLYQHGDLFFSDRNVYTAPIFNLTPESIPVVAVLHSTHIKNIDALDSSPFKNVYKAMFENLSRYRAIIVSTEQQKLDVEKRINHTIPVVNIPVGYSETIDTPVQTLDQRSVKLISVARYSPEKQLHQQIELIKRLVSYVPKIELHMYGFGSESKKLNELIQKYGLENHVYLRGFLSNLDQEYSDAYLSLITSNMEGFSLALLESLAHGVPVISYDIKYGPNELITSDFNGYLITKNDEDALFDKVKYVIDHPEVQQRLSKGSLAKAQQYSKASLIKQWDQFVRLILEHHHHHH,2021-03-24,7ec1_A,505
+6xds_A,KTEEGKLVIWINGDKGYNGLAEVGKKFEKDTGIKVTVEHPDKLEEKFPQVAATGDGPDIIFWAHDRFGGYAQSGLLAEITPAAAFQDKLYPFTWDAVRYNGKLIAYPIAVEALSLIYNKDLLPNPPKTWEEIPALDKELKAKGKSALMFNLQEPYFTWPLIAADGGYAFKYAAGKYDIKDVGVDNAGAKAGLTFLVDLIKNKHMNADTDYSIAEHAFNHGETAMTINGPWAWSNIDTSAVNYGVTVLPTFKGQPSKPFVGVLSAGINAASPNKELAKEFLENYLLTDEGLEAVNKDKPLGAVALKSYEEELVKDPRVAATMENAQKGEIMPNIPQMSAFWYAVRTAVINAASGRQTVDAALAAAQTNAHDTTVFQGVAGQSLQVSCPYDSMKHWGRRKAWCRQLGEKGPCQRVVSTHNLWLLSFLRRWNGSTAITDDTLGGTLTITLRNLQPHDAGLYQCQSLHGSEADTLRKVLVEVLADPLDHHHHHHHH,2021-02-17,6xds_A,492
+6xrx_A,KIEEGKLVIWINGDKGYNGLAEVGKKFEKDTGIKVTVEHPDKLEEKFPQVAATGDGPDIIFWAHDRFGGYAQSGLLAEITPAAAFQDKLYPFTWDAVRYNGKLIAYPIAVEALSLIYNKDLLPNPPKTWEEIPALDKELKAKGKSALMFNLQEPYFTWPLIAADGGYAFKYAAGKYDIKDVGVDNAGAKAGLTFLVDLIKNKHMNADTDYSIAEAAFNKGETAMTINGPWAWSNIDTSAVNYGVTVLPTFKGQPSKPFVGVLSAGINAASPNKELAKEFLENYLLTDEGLEAVNKDKPLGAVALKSYEEELAKDPRIAATMENAQKGEIMPNIPQMSAFWYAVRTAVINAASGRQTVDAALAAAQTNAAAALKDDFQEFVDLVPVDKLVNVALQYLVSDKEFKEFFGYLQGEEFSAVWDQFFALNEVKDVLNYLEAADLAVYDALNTVADFLGLHHVKPTVHTLRTGGLTGFFDETVALLPLDKFEALFEEKLKTSPEFKAFFEKLRNLDYQKFVDFHNNSKEVQGFLQKLRSYGLDVDGFFNLVAGFFGWGKF,2021-03-24,6xrx_A,554
+6q9c_B,RSYPAIPRIYAETTLNMLLKRAKKPRVHSIDEYLKDGGYQALEKALNMSPEEIIDWVDKSTLRGRGGAGFPTGKKWKFAVQNPGPRYFICNADESEPGTFKDRIIIERDPHLLIEGIIISSYAIGANEAYIYIRGEYPAGYYILRDAIEEAKKKGFLGKNILGSGFDLEIYVARGAGAYICGEETALIESLEGKRGHPRLKPPYPVQKGLWGKPTVVNNVETIANVPFIISMGWEEYRYIGPSDYAGPKLFPVSGKVKKPGVYELPMNTTLREVIFKYAGGTLGNKKVKAVFSGALDCFSSEELDIPMDYSPLGFGGTGTVIVLTEEDDIVEAALKIAEFYEHETCGQCTPCRVGCYEQANLLEKIYKGEATEQDWEGFDFVNRNIQPTSICGLGAVAGRLIRQTLEKFPEEWEKYRK,2019-06-26,6q9c_B,418
+6rrv_A,GPKPKNTKENLSKSSWRQEWLANLKLISVSLVDEFPSELSDSDRQIINEKMQLLKDIFANNLKSAISNNFRESDIIILKGEIEDYPMSSEIKIYYNELQNKPDAKKARFWSFMKTQRFVSNMGFDIQ,2019-09-18,6rrv_A,127
+7lao_A,QGMNTIESITADLHGLGVRPGDLIMVHASLKAVGPVEGGAASVVSALRAAVGSAGTLMGYASWDRSPYEETLNGARMDEELRRRWPPFDLATSGTYPGFGLLNRFLLEAPDARRSAHPDASMVAVGPLAATLTEPHRLGQALGEGSPLERFVGHGGKVLLLGAPLDSVTVLHYAEAIAPIPNKRRVTYEMPMLGPDGRVRWELAEDFDSNGILDCFAVDGKPDAVETIAKAYVELGRHREGIVGRAPSYLFEAQDIVSFGVTYLEQHFGAP,2021-01-20,7lao_A,271
+6l4l_A,MNRQVIEFSKYNPSGNMTILVHSKHDASEYASIANQLMAATHVCCEQVGFIESTQNDDGNDFHLVMSGNEFCGNATMSYIHHLQESHLLKDQQFKVKVSGCSDLVQCAIHDCQYYEVQMPQAHRVVPTTINMGNHSWKALEIIYETYVHYVIPVKQVTTEIQHLVEAFVREQQWSHKYKTVGMMLFDEQRQFLQPLIYIPEIQSLIWENSCGSGTASIGVFNNYQRNDACKDFTVHQPGGSILVTSKRCHQLGYQTSIKGQVTTVATGKAYIELEHHHHHH,2020-10-21,6l4l_A,281
+7asg_A,GPNVCAVQKVIGTNRKYFTNCKQWYQRKICGKSTVISYECCPGYEKVPGEKGCPAALPLSNLYETLGVVGSTTTQLYTDRTEKLRPEMEGPGSFTIFAPSNEAWASLPAEVLDSLVSNVNIELLNALRYHMVGRRVLTDELKHGMTLTSMYQNSNIQIHHYPNGIVTVNCARLLKADHHATNGVVHLIDKVISTITNNIQQIIEIEDTFETLRAAVAASGLNTMLEGNGQYTLLAPTNEAFEKIPSETLNRILGDPEALRDLLNNHILKSAMCAEAIVAGLSVETLEGTTLEVGCSGDMLTINGKAIISNKDILATNGVIHYIDELLIPDSAKTLFELAAESDVSTAIDLFRQAGLGNHLSGSERLTLLAPLNSVFKDGTPPIDAHTRNLLRNHIIKDQLASKYLYHGQTLETLGGKKLRVFVYRNSLCIENSCIAAHDKRGRYGTLFTMDRVLTPPMGTVMDVLKGDNRFSMLVAAIQSAGLTETLNREGVYTVFAPTNEAFRALPPREWSRLLGDAKELANILKYHIGDEILVSGGIGALVRLKSLQGDKLEVSLKNNVVSVNKEPVAEPDIMATNGVVHVITNVLHHHHHH,2020-12-23,7asg_A,594
+6kty_A,GSHMASVDKKFLSGDPNIVDGQVDPGSAIPGDYAIEVVQLAQKPAAMSNGFPDKDQTQIGVGYIKFETPEGTKEVYINGSNSTLDGVMKQINAANVGLKAQVVEDRKDQENPFKLLVSGLSTGNDSQVTFPKIYLLDGDQDMYFEESRKAQNAKVKVDGFEIELPDNKSTDLVPGVTLDFKSAAPGREIRLSVKEN,2019-10-09,6kty_A,196
+6vjg_A,HHHHHHMKFAVIDRKNFTLIHFEIEKPIKPEILKEIEIPSVDTRKGVVISGRGPIWLHCFLAHKYHHTPFVAVYDPRLGAVVVQSHSELREGDVIDVVVEEILKGGVRHV,2020-09-02,6vjg_A,110
+6sms_A,QKEMDRKGLLGYYFKDKDFSNLTMFSPTRYNTLIYDQQTANKLLDKKQQEYQSIRWIGLIQSNKTGDFTFELSDDECAIIEMDGKVISNKGKEKQVVHLEKGKLVPIKIEYQLDEPLNIDDEKFKGFKLLKVDNQKQLHQVQQDELRNPEFNKKESQEFLAKASKINLFTKKIKRDIDEGTDTDGDSIPDMWEENGYTIQNRIAVKWNDSLASKGYTKFVSNPLDSHTVGDPYTDYEKASRDLDLSNAKETFNPLVAAFPSVNVSMEKVILSPNKNLSNSVESHSSTNWSYTNTEGASVEAGIGPKGFSFGVSANYQHSETVAQEWGASIGDTTQLNTASAGYLNANVRYNNVGTGAIYDVKPTTSFVLEKNTIATITAKSNSTALSISPGESYPKKGQNGIAITSMDDFNSHPITLNKKQLDQVLTNNPIMLETDQTDGIYKIKDTHGNIVTGGTWNGVTQQIKAKTASIIVDDGKQVAEKRVAAKDYAYPEDKTPSLTLKDALKLSFPEEIKETDGLLYYNNKPIYESSVMTYLDGNTAKEVKKQINDKTGEFKDVQHLYAVKLTPKMNFTIKVPVAYDTAKQAVNLGGDNPWGAKGLLGTWVNAMVVDNSGDKAYKRVEPGYLLSPTLEFSEGSLDNLKKNYSFYVSMYVKSDKPFTLRINAGPYSTKRTIEASNDFKRVDIPAFYIEGFPIDTIRLEGSDYPSAIWWKDVSITEVSAVKK,2021-02-10,6sms_A,724
+6l3r_E,GAILAARIAVSNLHKETKKVFSDVMEDLYNYINPHNGKHSPMVAKSTLDIVLANKDRLNSAIIYDRDFSYNYFGFKTLERSYLLKINGKVAERPQHMLMRVSVGIHKEDIDAAIETYNLLSERWFTHASPTLFNAGTNRPQLSSCFLLSMKDDSIEGIYDTLKQCALISKSAGGIGVAVSCIRATGSYIAGTNGNSNGLVPMLRVYNNTARYVDQGGNKRPGAFAIYLEPWHLDIFEFLDLKKNTGKEEQRARDLFFALWIPDLFMKRVETNQDWSLMCPNECPGLDEVWGEEFEKLYASYEKQGRVRKVVKAQQLWYAIIESQTETGTPYMLYKDSCNRKSNQQNLGTIKCSNLCTEIVEYTSKDEVAVCNLASLALNMYVTSEHTYDFKKLAEVTKVVVRNLNKIIDINYYPVPEACLSNKRHRPIGIGVQGLADAFILMRYPFESAEAQLLNKQIFETIYYGALEASCDLAKEQGPYETYEGSPVSKGILQYDMWNVTPTDLWDWKVLKEKIAKYGIRNSLLIAPMPTASTAQILGNNESIEPYTSNIYTRRVLSGEFQIVNPHLLKDLTERGLWHEEMKNQIIACNGSIQSIPEIPDDLKQLYKTVWEISQKTVLKMAAERGAFIDQSQSLNIHIAEPNYGKLTSMHFYGWKQGLKTGMYYLRTR,2020-10-28,6l3r_E,669
+7qsu_A,SGKAVDGNTLVLTEEFGLVKIKELYEKLDGKGRKTVEGNEEWTELETPVTVYGYRNGRIVGIKATHIYKGISSGMIEIRTRTGRKIKVTPIHKLFTGRVTKDGLALEEVMAMHIKPGDRIAVVKKIDGGEYVKLTTSPDFRKSRKIKVPEVLDEDLAEFLGYLIADGTLKPRTVAIYNNDESLLKRANFLSTKLFGINGKIVQERTVKALLIHSKPLVDFFRKLGIPESKKARNWKVPRELLLSPPSVVKAFINAYIVCDGYYHERKGEIEITTASEEGAYGLSYLLAKLGIYATFRKKQIKGKEYYRIAISGKTNLEKLGIKRETRGYTNIDIVILFDEVVEVKYIPEPQEVYDITTETHNFVGGNMPTLLHN,2022-03-30,7qsu_A,374
+7p46_A,KNLRDLEPGIHTDLEGRLTYGGYLRLDQLLSAQQPLSEPAHHDEMLFIIQSQTSELWLKLLAHELRAAIVHLQRDEVWQCRKVLARSKQVLRQLTEQWSVLETLTPSEYMGFRDVLGPSSGFQSLQYRYIEFLLGNKNPQMLQVFAYDPAGQARLREVLEAPSLYEEFLRYLARFGHAIPQQYQARDWTAAHVADDTLRPVFERIYENTDRYWREYSLCEDLVDVETQFQLWRFRHMRTVMRVIGFKRGTGGSSGVGFLQQALALTFFPELFDVRTSVGVDN,2021-10-06,7p46_A,282
+7e2s_A,MSDNLTELSQQLHDASEKKQLTAIAALAEMGEGGQGILLDYLAKNVPLEKPVLAVGNVYQTLRNLEQETITTQLQRNYPTGIFPLQSAQGIDYLPLQEALGSQDFETADEITRDKLCELAGPGASQRQWLYFTEVEKFPALDLHTINALWWLHSNGNFGFSVQRRLWLASGKEFTKLWPKIGWKSGNVWTRWPKGFTWDLSAPQGHLPLLNQLRGVRVAESLYRHPVWSQYGW,2021-08-25,7e2s_A,233
+6pxz_B,QRWVQFMKEAGQGSRDMWRAYSDMKKANWKNSDKYFHARGNYDAARRGPGGAWAAKVISDAREAVQKFTGHGAEDSRADQFANEWGRSGKDPNHFRPAGLPKRY,2019-08-28,6pxz_B,104
+6ovk_R,GAMGQDWRADYHSRIGEQRRLTLADGTQVQLNTDSALNVAFDQQARRLRLVRGEMLITRPALADSRPLWVDTEHGRLESTLAQFNVRLHGQHTQATVYQGSVALQPALHAYPPILLGAGEQASFNQQGLLARQAVAAVAPAWSQGMLVAQGQPLAAFIEDLARYRRGHLACDPALAGLRVSGTFPLENTDKIIAAVAETLQLEVQHFTRYWVTLKPRMA,2020-03-04,6ovk_R,219
+6ndw_B,MAKATTSVNYACNLDKRLPELPEGANRAQILESTWSTEFKVYDSFGEAHELQIDFARVPGEVNAWRATVNVDPTNADATATRVGIGTTDGVQNSFIVRFDNNGHLASVTDTAGNVTSPAGQVLVQISYNVVGANPDEAGAPTRHTFDVNLGEIGTSKNTITQFSDKSTTKAYEQDGYT,2019-08-14,6ndw_B,178
+6pce_B,PSMKERQVCWGARDEYWKCLDENLEDASQCKKLRSSFESSCPQQWIKYFDKRRDYLKFKEKFEAGQFEPS,2019-10-02,6pce_B,70
+7p41_D,MRGSMQQVGTVAQLWIYPVKSCKGVPVSEAECTAMGLRSGNLRDRFWLVINQEGNMVTARQEPRLVLISLTCDGDTLTLSAMNIFEMLRIDEGLRLKIYKDTEGYYTIGIGHLLTKSPSLNAAKSELDKAIGRNCNGVITKDEAEKLFNQDVDAAVRGILRNAKLKPVYDSLDAVRRCALINMVFQMGETGVAGFTNSLRMLQQKRWDEAAVNLAKSRWYNQTPNRAKRVITTFRTGTWDAYTKDLLLPIKTPTTNAVHKCRVHGLEIEGRDCGEATAQWITSFLKSQPYRLVHFEPHMRPRRPHQIADLFRPKDQIAYSDTSPFLILSEASLADLNSRLEKKVKATNFRPNIVISGCDVYAEDSWDELLIGDVELKRVMACSRCILTTVDPDTGVMSRKEPLETLKSYRQCDPSERKLYGKSPLFGQYFVLENPGTIKVGDPVYLLG,2021-08-18,7p41_D,448
+6h86_A,MADSDPGERSYDNMLKMLSDLNKDLEKLLEEMEKISVQATWMAYDMVVMRTNPTLAESMRRLEDAFLNCKEEMEKNWQELLTETKRKQ,2019-05-08,6h86_A,88
+7jfl_C,SALQDLLRTLKSPSSPQQQQQVLNILKSNPQLMAAFIKQRTAKYVAN,2020-09-09,7jfl_C,47
+6iah_A,MWIVFDVDGVLIDVRESYDEATKLTAEYFLGLFGVEREIKPEWVRELRRKGSFGDDFKVSEALILFALSGRAEELVEEFPEGGTIEWVREKFGFQVFGGSIERVFNTFYLGREYPERLFDFPGLWKKERPIVRRGLLERASKHFKLGVVTGRSALEMELAERIIGFKFENAVTREAYLKPDPRALWELVRGEPGVYIGDTINDELFVENYRGKYGDFDFVMVGRDVKDVNEFLENALEGG,2019-08-14,6iah_A,240
+6y2x_A,GSEPEPEQVIKNYTEELKVPPDEDCIICMEKLSTASGYSDVTDSKAIGSLAVGHLTKCSHAFHLLCLLAMYCNGNKDGSLQCPSCKTIYGEKTGTQPQGKMEVLRFQMSLPGHEDCGTILIVYSIPHGIQGPEHPNPGKPFTARGFPRQCYLPDNAQGRKVLELLKVAWKRRLIFTVGTSSTTGETDTVVWNEIHHKTEMDRNITGHGYPDPNYLQNVLAELAAQGVTEDCLEQQ,2020-09-02,6y2x_A,235
+7nmq_A,GNYALGPEGLKKALAETGSHILVMDLYAKTMIKQPNVNLSNIDLGSEGGELLKNIHLNQELSRINANYWLDTAKPQIQKTARNIVNYDEQFQNYYDTLVETVQKKDKAGLKEGINDLITTINTNSKEVTDVIKMLQDFKGKLYQNSTDFKNNVGGPDGKGGLTAILAGQQATIPQLQAEIEQLRSTQKKHFDDVLAWSIGGGLGAAILVIAAIGGAVVIVVTGGTATPAVVGGLSALGAAGIGLGTAAGVTASKHMDSYNEISNKIGELSMKADRANQAVLSLTNAKETLAYLYQTVDQAILSLTNIQKQWNTMGANYTDLLDNIDSMQDHKFSLIPDDLKAAKESWNDIHKDAEFISKDIAFKQ,2021-04-07,7nmq_A,365
+6xb3_H,SMELYNIKYAIDPTNKIVIEQVDNVDAFVHILEPGQEVFDETLSQYHQFPGVVSSIIFPQLVLNTIISVLSEDGSLLTLKLENTCFNFHVCNKRFVFGNLPAAVVNNETKQKLRIGAPIFAGKKLVSVVTAFHRVGENEWLLPVTGIREASQLSGHMKVLNGVRVEKWRPNMSVYGTVQLPYDKIKQHALEQENKTPNALESCVLFYKDSEIRITYNKGDYEIMHLRMPGPLIQPNTIYYS,2020-11-25,6xb3_H,241
+6jwh_A,GPLGSIKELAVDEELAAADGLIPRQKSKLCKHGDRGMCEYCSPLPPWDKEYHEKNKIKHISFHSYLKKLNENANKKENGSSYISPLSEPDFRINKRCHNGHEPWPRGICSKCQPSAITLQQQEFRMVDHVEFQKSEIINEFIQAWRYTGMQRFGYMYGSYSKYDNTPLGIKAVVEAIYEPPQHDEQDGLTMDVEQVKNEMLQIDRQAQEMGLSRIGLIFTDLSDAGAGDGSVFCKRHKDSFFLSSLEVIMAARHQTRHPNVSKYSEQGFFSSKFVTCVISGNLEGEIDISSYQVSTEAEALVTADMISGSTFPSMAYINDTTDERYVPEIFYMKSNEYGITVKENAKPAFPVDYLLVTLTHGFPNTDTETNSKFVSSTGFPWSNRQAMGQSQDYQELKKYLFNVASSGDFNLLHEKISNFHLLLYINSLQILSPDEWKLLIESAVKNEWEESLLKLVSSAGWQTLVMILQESG,2019-12-25,6jwh_A,473
+6l4p_B,GDLAAAKPALDAALEALNSIKDGDIKNLKALKKPPQIITRIFDCVLVLRMLPVTKAEYTDEKGRMVQVGNYPEAQKMMNQMSFLQDLKDFAKEQINDETVELLEPYFMSEDFTFENAQKASGNVAGLCNWAESMAKYHNVAKVVE,2020-02-19,6l4p_B,145
+6jpt_A,MEDTPLVISKQKTEVVCGVPTQVVCTAFSSHILVVVTQFGKMGTLVSLEPSSVASDVSKPVLTTKVLLGQDEPLIHVFAKNLVAFVSQEAGNRAVLLAVAVKDKSMEGLKALREVIRVCQVW,2019-05-29,6jpt_A,122
+7a66_B,MKIRAKVELTWEYEDEETAKAIANAVNVDNISIPEKLKKSLNLITFPDGARVVTKVKYEGEIESLVVALDDLIFAIKVAEEVLWSH,2022-03-23,7a66_B,86
+6okd_C,GSREGCASRCMKYNDELEKCEARMMSMSNTEEDCEQELEDLLYCLDHCHSQ,2020-04-15,6okd_C,51
+6in7_A,MMSREALQETLSAVMDNEADELELRRVLAACGEDAELRSTWSRYQLARSVMHREPTLPKLDIAAAVSAALADEAAPPKAEK,2019-07-24,6in7_A,81
+7onn_A,STSRGMITDRSGRPLAVSVPVGGGESRRYYPSGEVTAHLIGFTNVDSQGIEGVEKSFDKWLTGQGGGAAHNLALSIDERLQALVYRELNNAVAFNKAESGSAVLVDVNTGEVLAMANSPSYNPNNLSGTPKEAMRNRTITDVFEPGSTVKPMVVMTALQRGVVRENSVLNTIPYRINGHEIKDVARYSELTLTGVLQKSSNVGVSKLALAMPSSALVDTYSRFGLGKATNLGLVGERSGLYPQKQRWSDIERATFSFGYGLMVTPLQLARVYATIGSYGIYRPLSITKVDPPVPGERVFPESIVRTVVHMMESVALPGGGGVKAAIKGYRIAIKTGTAKKVGPDGRYINKYIAYTAGVAPASQPRFALVVVINDPQAGKYYGGAVSAPVFGAIMGGVLRTMNIEPDALTT,2021-08-04,7onn_A,410
+6ono_C,MDWRHKAVCRDEDPELFFPVGNSGPALAQIADAKLVCNRCPVTTECLSWALNTGQDSGVWGGMSEDERRALKRRNA,2019-11-27,6ono_C,76
+6d7y_A,IKTVLDTAQAPYKGSTVIGHALSKHAGRHPEIWGKVKGSMSGWNEQAMKHFKEIVRAPGEFRPTMNEKGITFLEKRLIDGRGVRLNLDGTFKGFID,2019-05-01,6d7y_A,96
+6odd_B,SRAQVLSLYRAMLRESKRFSAYNYRTYAVRRIRDAFRENKNVKDPVEIQTLVNKAKRDLGVIRRQVHIGQLYST,2019-11-27,6odd_B,74
+6p5x_B,MDHLPIFCQLRDRDCLIVGGGDVAERKARLLLEAGARLTVNALTFIPQFTVWANEGMLTLVEGPFDETLLDSCWLAIAATDDDTVNQRVSDAAESRRIFCNVVDAPKAASFIMPSIIDRSPLMVAVSAGGTSPVLARLLREKLESLLPQHLGQVARYAGQLRARVKKQFATMGERRRFWEKFFVNDRLAQSLANADEKAVNATTERLFSEPLDHRGEVVLVGAGPGDAGLLTLKGLQQIQQADIVVYDRLVSDDIMNLVRRDADRVFVGKRAGYHCVPQEEINQILLREAQKGKRVVRLKGGDPFIFGRGGEELETLCHAGIPFSVVPGITAASGCSAYSGIPLTHRDYAQSVRLVTGHLKTGGELDWENLAAEKQTLVFYMGLNQAATIQEKLIAFGMQADMPVALVENGTSVKQRVVHGVLTQLGELAQQVESPALIIVGRVVALRDKLNWFSNH,2020-02-26,6p5x_B,457
+6tgk_C,LDFQALEETTEYDGGYTRDSVLIREFWEIVHSFTDEQKRLFLQFTTGTDRAPVGGLGKLKMIIAKNGPDTERLPTSHTCFNVLLLPEYSSKEKLKERLLKAITYA,2020-02-26,6tgk_C,105
+7dmn_A,GSHMSNVTVSAFTVDKSISEEHVLPSSFIPGSGNIFPKFTSAIPKTAWELWYFDGISKDDKSSIVIGVTRNAEGLKHGGFKVQVFVIWADERTWHRDLFFPESVVSINESGVTDGIWKDATSNSSISFSCAGDLSKASLVFDVPGVVQGDMHLEALPGDTGLDTDARLGPSVYYVRPIGRASVKAQLSLYSSDATAAEQFSLGTSANGGMDRVWSPLSWPQVMTESYYLRTQVGPYAMQIMRIFPPAGSEDQPSTMARLYREGQLVCVAQHVVTREDALMTHDSLILSKQDNSDSEDVVTGGYRDKNTGYTVEFVEKGNEGQRWKFQVRHERIIWNTPTSRPGPDATGNTGFVEVLCGGTIGESYEGVGTGGQCELS,2021-10-06,7dmn_A,377
+7lp1_A,VTQSFLPPGWEMRIAPNGRPFFIDHNTKTTTWEDPRLKF,2021-07-28,7lp1_A,39
+6l34_A,KRPMSAYMLWLNASREKIKSDHPGISITDLSKKAGEIWKGMSKEKKEEWDRKAEDARRDYEKAMKEYE,2020-10-14,6l34_A,68
+7ned_A,MERITAARGLELRCKGWRQEALLRMLENVLENGENQKELIVYAALAKAARNWPSYHAIVRTLKELEEDETLVIQSGKPIGIFKTHRFAPLIVMANCNLVGRWATSENFYRLQEKGLLIWGGLTAAAWQYIGSQGVIQGTYEIFQSIARLHFNGSLAGKFILTAGLGGMGGAQPLAGTLAGAAILCVEVSEDRVDRRLQTNYLQRKTRSLDEALLWIEEAVDNLHPVSVGLTGNASDIYPELVRRGITPDIVTDQTSAHDLVYGYVPSGYRVEELEEARANDPEQLQRDAGASIAVEVEAMLELKKRGAIVFDNGNNIRSQAKEYGVQNAFDIDIFTEAFLRPLFARAIGPFRWVALSGELSDIHAIDEFILEAFSDNEVIANWIRLAREHVPVEGLPARIGWFGHGDRTKLALAVNQMVREGKLQGPIAFSRDHLDAASMTHPNIMTERMKDGSDAIADWPLLNAMLNCSSMADLVTIHSGGGGYAGYMTSAGVTLVADGSTESDIRLETTLNNDTGLGVLRYADAGYEESADEVRLKDIRWIKTN,2021-02-24,7ned_A,546
+7s86_A,TAVPRDVNGGTPPKSCSSGPVYCCNKTEDSKHLDKGTTALLGLLNIKIGDLKDLVGLNCSPLSVIGVGGNSCSAQTVCCTNTYQHGLVNVGCTPINIGL,2021-12-29,7s86_A,99
+6l8s_A,SSTAHKQQNINHLLDKIYEDTKYPDLQEIAKNFNPLGDTSMYNDQGAAAEVLMKELNDHRLLEQHHWYSLFNARQREEALMLFAVLNQCKVWHCFRNNAAYFREQMNEGEFVYALYVGVIHSKLGDGIVLPPLYEITPHMFTNSEVIDKAYSAKMTQKAGTFNVSFTGTKKNKEQRVAYFGEDIGMNIHHVTWHMDFPFWWQDSYGNHLDRKGELFFWVHHQLTARFDFERLSNWLDPVDELHWDRIIREGFAPLTSYKYGGEFPVRPDNIHFEDVDGVAHVHDMEITENRIYEAIDHGYITATDGHTIDIRQPKGIELLGDIIESSMYSPNAQYYGSLHNTAHVMLGRQGDPHGKFNLPPGVMEHFETATRDPSFFRLHKYMDNIFKKHTDSFPPYTHDDLEFAGMVVDGVAIDGELTTFFDEFQYSLINAVDSGESIEDVEINARVHRLNHKEFTYKITVSNSIGSDHLATFRIFLCPIEDNNGITLTLDKERWLCIELDKFFQKVPSGTHTIHRSSKDSSVTVPDMPSFHSLKEQADNAVNGGSDLDLSAYERSCGIPERMLLPKSKPEGMEFNLFVAVTDGVKDTEGHNGDHDHGGTHAQCGVHGEAYPDNRPLGYPLERRIPDERVFDGVPNIKHVVVKIVHHPE,2020-05-27,6l8s_A,650
+7bwf_B,SGLVPRGSHMIIKNYSYARQNLKALMTKVNDDSDMVTVTSTDDKNVVIMSESDYNSMMETLYLQQNPNNAEHLAQSIADLERGKTITKDIDV,2020-05-20,7bwf_B,92
+7aex_A,MHHHHHHSEINPAEFEQVNMVLQGFVETSVLPVLELSADESHIEFREHSRNAHTVVWKIISTSYQDELTVSLHITTGKLQIQGRPLSCYRVFTFNLAALLDLQGLEKVLIRQEDGKANIVQQEVARTYLQTVMADAYPHLHVTAEKLLVSGLCVKLAAPDLPDYCMLLYPELRTIEGVLKSKMSGLGMPVQQPAGFGTYFDKPAAHYILKPQFAATLRPEQINIISTAYTFFNVERHSLFHMETVVDASRMISDMARLMGKATRAWGIIKDLYIV,2021-06-09,7aex_A,275
+6d7y_B,MKELFEVIFEGVNTSRLFFLLKEIESKSDRIFDFNFSEDFFSSNVNVFSELLIDSFLGFNGDLYFGVSMEGFSVKDGLKLPVVLLRVLKYEGGVDVGLCFYMNDFNSAGKVMLEFQKYMNGISADFGFENFYGGLEPASDQETRFFTNNRLGPLL,2019-05-01,6d7y_B,155
+6e7e_A,ATANLHLYQDLQREVGSLKEINFMLSVLQKEFLHLSKEFATTSKDLSAVSQDFYSCLQGFRDNYKGFESLLDEYKNSTEEMRKLFSQEIIADLKGSVASLREEIRFLTPLAEEVRRLAHNQQSLTAAIEELKTIRDSLRDEIGQLSQLSKTLTSQIALQRKLEHHHHHH,2019-07-10,6e7e_A,169
+7k7p_B,EKTHVQLSLPVLQVRDVLVRGFGDSVEEVLSEARQHLKDGTCGLVEVEKGVLPQLEQPYVFIKRSDARTAPHGHVMVELVAELEGIQYGRSGETLGVLVPHVGEIPVAYRKVLLRKNG,2020-09-30,7k7p_B,118
+7buy_A,SGFRKMAFPSGKVEGCMVQVTCGTTTLNGLWLDDVVYCPRHVICTSEDMLNPNYEDLLIRKSNHNFLVQAGNVQLRVIGHSMQNCVLKLKVDTANPKTPKYKFVRIQPGQTFSVLACYNGSPSGVYQCAMRPNFTIKGSFLNGSCGSVGFNIDYDCVSFCYMHHMELPTGVHAGTDLEGNFYGPFVDRQTAQAAGTDTTITVNVLAWLYAAVINGDRWFLNRFTTTLNDFNLVAMKYNYEPLTQDHVDILGPLSAQTGIAVLDMCASLKELLQNGMNGRTILGSALLEDEFTPFDVVRQCSGVTFQ,2020-04-29,7buy_A,306
+6yhu_B,SEDKRAKVTSAMQTMLFTMLRKLDNDALNNIINNARDGCVPLNIIPLTTAAKLMVVIPDYNTYKNTCDGTTFTYASALWEIQQVVDADSKIVQLSEISMDNSPNLAWPLIVTALRAN,2020-04-29,6yhu_B,117
+6h49_A,GMEGAGQMAELPTHYGTIIKTLRKYMKLTQSKLSERTGFSQNTISNHENGNRNIGVNEIEIYGKGLGIPSYILHRISDEFKEKGYSPTLNDFGKFDKMYSYVNKAYYNDGDIYYSSYDLYDETIKLLELLKESKINVNDIDYDYVLKLYKQILSTDT,2019-08-28,6h49_A,157
+7aqx_A,AAEKGFKQAFWQPLCQVSEELDDQPKGALFTLQAAASKIQKMRDAALRASIYAEINHGTNRAKAAVIVANHYAMKADSGLEALKQTLSSQEVTATATASYLKGRIDEYLNLLLQTKESGTSGCMMDTSGTNTVTKAGGTIGGVPCKLQLSPIQPKRPAATYLGKAGYVGLTRQADAANNFHDNDAECRLASGHNTNGLGKSGQLSAAVTMAAGYVTVANSQTAVTVQALDALQEASGAAHQPWIDAWKAKKALTGAETAEFRNETAGIAGKTGVTKLVEEALLKKKDSEASEIQTELKKYFSGHENEQWTAIEKLISEQPVAQNLVGDNQPTKLGELEGNAKLTTILAYYRMETAGKFEVLTQK,2021-11-03,7aqx_A,364
+7c45_A,TSSATSSSSMILKYPYRVVDTHEKLKEAVTSLQGARSIALDIEAFCTTDQAKQLGRISLVQACSDAKPVVFLFDVLTLTPDVFVKDMQSLLSDREIRKLFFDCRRDVEALSCQLGVKPEGVLDLQVFFTAIQWKLRSVNRRSGMGYVLKSVAGLTRQEGDSAVQTAMTLGNRPVWDIRPLPDHFLEYAAGDVRHILLLSNYLVGNKDVPVDVVAVERLTAQYVEHYAVGKPVITEADATPAEVNRAWLERYIGPGGGCHFCGAKGHTEAECFKKQNGKAKCSFCGEVGHTARNCFKKHPQLL,2021-04-07,7c45_A,302
+6gus_A,QIQKAEQNDVKLAPPTDVRSGYIRLVKNVNYYIDSESIWVDNQEPQIVHFDAVVNLDKGLYVYPEPKRYARSVRQYKILNCANYHLTQVRTDFYDEFWGQGLRAAPKKQKKHTLSLTPDTTLYNAAQIICANYGEAFSVDKKKLAAALEHHHHHH,2019-05-29,6gus_A,155
+6q9c_A,FEFPEELKTKLQEHINYFPKKRQAILLCLHEIQNYYGYIPPESLKPLADMLELPLNHVEGVVAFYDMFDREDKAKYRIRVCVSIVCHLMGTNKLLKALENILGIKPGEVTPDGKFKIVPVQCLGACSEAPVFMVNDDEYKFESEVQLNEILSRYT,2019-06-26,6q9c_A,155
+7n0j_E,APQVITVSRFEVGKDKWAFNREEVMLTCRPGNALYVINPSTLVQYPLNDIAQKEVASGKTNAQPISVIQIDDPNNPGEKMSLAPFIERAEKLCVDHHHHHH,2022-03-09,7n0j_E,101
+6o6y_A,MGMKLLVVSWGDFERWKETKYRFGGETSVGPSTLPILQKVIKPDWTVIVLSDTIGKDFSSVETLREDVRNRVMDFLDRIGAGREVDVIIAPGIGEFTHGSFRGSAMDAYYYVLHALSEIIPTKGDLEVHFDSTHGLNYVTLLTYRALKDLLGIAAVMNTVTFYAYNSDPFVPKITKELNINTIETTMVKPTPLSEPLPGFDEYLCPYSMERAEFVRLKGSLNTLKNLRKEKKKLEAWIGSLLFGLPLLFLEEFPDIGRLESYIEELAETWGGAIAVNAEEKAVTRRLAFGSGFGTLVKLLFQARITRGLLVEEPYSIEKLYSVSDRLFRGSTLQRVRVELGKIEDKAIKYARKGAFPRDIPLRDFLGFDAANREVSPRNVLAHAGLEANVVEVSMEAWEPKRPEEEAGRHTHLKYTPVGLKKVEDIVSRALKESHHHHHH,2019-07-31,6o6y_A,440
+6zsl_B,SMAVGACVLCNSQTSLRCGACIRRPFLCCKCCYDHVISTSHKLVLSVNPYVCNAPGCDVTDVTQLYLGGMSYYCKSHKPPISFPLCANGQVFGLYKNTCVGSDNVTDFNAIATCDWTNAGDYILANTCTERLKLFAAETLKATEETFKLSYGIATVREVLSDRELHLSWEVGKPRPPLNRNYVFTGYRVTKNSKVQIGEYTFEKGDYGDAVVYRGTTTYKLNVGDYFVLTSHTVMPLSAPTLVPQEHYVRITGLYPTLNISDEFSSNVANYQKVGMQKYSTLQGPPGTGKSHFAIGLALYYPSARIVYTACSHAAVDALCEKALKYLPIDKCSRIIPARARVECFDKFKVNSTLEQYVFCTVNALPETTADIVVFDEISMATNYDLSVVNARLRAKHYVYIGDPAQLPAPRTLLTKGTLEPEYFNSVCRLMKTIGPDMFLGTCRRCPAEIVDTVSALVYDNKLKAHKDKSAQCFKMFYKGVITHDVSSAINRPQIGVVREFLTRNPAWRKAVFISPYNSQNAVASKILGLPTQTVDSSQGSEYDYVIFTQTTETAHSCNVNRFNVAITRAKVGILCIMSDRDLYDKLQFTSLEIPRRNVATLQ,2020-07-29,6zsl_B,603
+7rm7_A,MGSSHHHHHHSSGLVPRGSHMISKINGKLFADMIIQGAQNLSNNADLVDSLNVYPVPDGDTGTNMNLTMTSGREEVENNLSKNIGELGKTFSKGLLMGARGNSGVILSQLFRGFCKNIESESEINSKLLAESFQAGVETAYKAVMKPVEGTILTVAKDAAQAAIEKANNTEDCIELMEYIIVKANESLENTPNLLAVLKEVGVVDSGGKGLLCVYEGFLKALKGEKVE,2022-03-02,7rm7_A,228
+6ypi_A,GSGSPLAQQIKNILSLIGQADAAGRMDEVRTLQLNLCQLMVEYFQQSDGDGGSPLAQQIQNIHSFGHQAWAAGRLDEVRRIQENLYQLMKEYFQQSD,2021-04-28,6ypi_A,97
+6ro6_A,MEGALPKGLSDLIADPTLGPQITPDWVRTLSRIELRGKRPRDKQDWYEIYLHLKRILS,2019-10-09,6ro6_A,58
+7mf4_A,QGRAILTDRYINRGTAFTMEERQKLHILGRLPPVVETLEEQVARVYGQVKKYEKPINRYQHLVSVHSTNTTLYYATILAHLEEMLPIIYTPTVGEACMEYSHLFFRERGVYFNRLYKGQFRNIMRDAGYQKVEVVVITDGSRILGLGDLGSNGIGISIGKCSLYVAGAGIDPRLIVPVILDVGTNNERYLQDKDYLGMREKRLGDEEFYELLDEFMEAASAEWPNAVIQFEDFSNNHCFDIMERYQKKYRCFNDDIQGTGAVIAAGFLNAIKLSGVSPLQQRIVVFGAGSAAVGVANNIAALAARMYKFPVQDLVKTFYLVDTKGLVTTTRGDQLAAHKKLLARTDVSAEDSAKLRTLEEIVRFVKPTTLLGLGGVGPAFTEEIVKMVMQNTERPIIFPLSNPTSKAEVTPENAYKWTNGAAIVASGSPFPPTTIGGKTFKPSQGNNLYVFPGVGLGCALAQPTHIPEELLLTASESLNLLTTEGDLREGRLYPPLEDIHNISANVATDVILEAQRMKIDNNKKLPRTRDELLAFVKKAMWKPVYSGEVGEQVL,2021-07-28,7mf4_A,554
+7jrq_A,HHHHHHENLYFQSSEKEELFEKLKQTADEAVQLFQRLREIFDKGDDDSFEQVLEELEEALQKHRQLADQGRKKGLLTSEAAKQGDQFVQLFQRFREAWDKGDKDSLEQILEELEQVAQKAVELGLKILKTQ,2021-01-13,7jrq_A,131
+7wab_A,TTGEAYFEQLLDHHNPEKGTFSQRYWWSTEYWGGPGSPVVLFNPGEVSADGYEGYLTNDTLTGVYAQEIQGAVILIEHRYWGDSSPYEVLNAETLQYLTLDQSILDMTYFAETVKLQFDNSSRSNAQNAPWVMVGGSYSGALTAWTESIAPGTFWAYHATSAPVEAIYDFWQYFYPIQQGMAQNCSKDVSLVAEYVDKIGKNGTAKEQQELKELFGLGAVEHYDDFAAVLPNGPYLWQDNDFVTGYSSFFQFCDAVEGVEAGAAVTPGPEGVGLEKALANYANWFNSTILPNYCASYGYWTDEWSVACFDSYNASSPIFTDTSVGNPVDRQWEWFLCNEPFFWWQDGAPEGTSTIVPRLVSASYWQRQCPLYFPEVNGYTYGSAKGKNSATVNSWTGGWDMTRNTTRLIWTNGQYDPWRDSGVSSTFRPGGPLVSTANEPVQIIPGGFHCSDLYMEDYYANEGVRKVVDNEVKQIKEWVEEYYA,2022-01-12,7wab_A,484
+5znj_A,MKQSKVFIPTMRDVPSEAEAQSHRLLLKSGLIKQSTSGIYSYLPLATRVLNNITAIVRQEMERIDSVEILMPALQQAELWEESGRWGAYGPELMRLQDRHGRQFALGPTHEELVTSIVRNELKSYKQLPMTLFQIQSKFRDEKRPRFGLLRGREFIMKDAYSFHADEASLDQTYQDMYQAYSRIFERVGINARPVVADSGAIGGSHTHEFMALSAIGEDTIVYSKESDYTANIEKAEVVYEPNHKHSTVQPLEKIETPNVKTAQELADFLGRPVDEIAKTMIFKVDGEYIMVLVRGHHEINDIKLKSYFGTDNIELATQDEIVNLVGANPGSLGPVIDKEIKIYADNFVQDLNNLVVGANEDGYHLINVNVGRDFNVDEYGDFRFILEGEKLSDGSGVAHFAEGIEVGQVFKLGTKYSESMNATFLDNQGKAQPLIMGCYGIGISRTLSAIVEQNHDDNGIVWPKSVTPFDLHLISINPKKDDQRELADALYAEFNTKFDVLYDDRQERAGVKFNDADLIGLPLRIVVGKRASEGIVEVKERLTGDSEEVHIDDLMTVITNKYDNLK,2019-05-29,5znj_A,567
+6pnv_A,SNAVRIEITQGVDSARPIGVVPFKWAGPGAAPEDIGGIVAADLRNSGKFNPLDRSRLPQQPATAQEVQPTAWSALGIDAVVVGQVTPNPDGSYNVAYQLVDTGGAPGTVLAQNSYKVNKQWLRYAGHTASDEVFEKLTGIKGAFRTRIAYVVQTNGGQFPYELRVSDYDGYNQFVVHRSPQPLMSPAWSPDGSKLAYVTFESGRSALVIQTLANGAVRQVASFPRHNGAPAFSPDGTKLAFALSKTGSLNLYVMDLASGQIRQITDGRSNNTEPTWFPDSQTLAFTSDQAGRPQVYKMNINGGAAQRITWEGSQNQDADVSSDGKFMVMVSSNNGQQHIAKQDLVTGGVQVLSSTFLDETPSLAPNGTMVIYSSSQGMGSVLNLVSTDGRFKARLPATDGQVKSPAWSPYL,2019-07-17,6pnv_A,411
+6rwt_A,MILQLFRRKSKANEAIVLRVYEVIVAAARQKRFYAQFQVPDTPLGRYEMLSLHIFLALHRMKGENPALNALAQEIADEFFKDVDHSLRELGIGDQGVPKRMKKLARMFYGRVGAYGAALDANDAQALAAALTRNIRPDLEFWPHACYLGAYVLQCRDCLREISDEALAAGDISYMDVDQVDLAP,2019-09-18,6rwt_A,184
+6oz1_A,QGMTETISTPAATTTPDLADQQELERRVAQVVSNDPQLQALLPDDAVSGAVNEPGLTLIELIRRLLEGYGDRPALGQRAVELVTDEHGATTVALKTEFVTTSYRELWNRAEAIAAAWYAQGIRDGDFVAQLGFTSTDFASLDVAGLRLGTVSVPLQTGASVQQRNAILEETQPTVFAASVEYLEAAVDSVLATPSVQLLSVFDYHPEADAHRAALSAVRDRLETAGRTITIDSLGDAIARGRELPAAPQPSEDPDALRLLIYTSGSTGTPKGAMYPQWLVANLWQKKWLTTTVIPSVGVNFMPMSHLAGRLTLMGTLSGGGTAYYIASSDLSTFFEDIALIRPTEVLFVPRVVEMVFQRYQAELDRSLAPGESNAEIAEKIKVRIREEDFGGRVLNAGSGSAPLSPEMNDFMESLLQVAMLDGYGSTEAGAVWRDGVLQRPPVTEYKLVDVPELGYFTTDSPHPRGELRIKSETMFPGYYKRPETTADVFDEDGFYMTGDVVAELGPDHLKYLDRVKNVLKLAQGEFVAVSKLEAAYTGSPLVRQIFVYGNSERSYLLAVVVPTPEALERYADSPDALKPLIQDSLQQVAKGAELQSYEIPRDFIVETVPFTVESGLLSDARKLLRPKLKEHYGERLEALYAD,2020-04-22,6oz1_A,643
+6nl2_A,LADAVAHLTPERWEEANRLLVRKALAEFTHERLLTPEREPDDGGGQTYVVRSDDGQTAYRFTATVRALDHWQVDAASVTRHRDGAELPLAALDFFIELKQTLGLSDEILPVYLEEISSTLSGTCYKLTKPQLSSAELARSGDFQAVETGMTEGHPCFVANNGRLGFGIHEYLSYAPETASPVRLVWLAAHRSRAAFTAGVGIEYESFVRDELGAATVDRFHGVLRGRGLDPADYLLIPVHPWQWWNKLTVTFAAEVARGHLVCLGEGDDEYLAQQSIRTFFNASHPGKHYVKTALSVLNMGFMQGLSAAYMEATPAINDWLARLIEGDPVLKETGLSIIRERAAVGYRHLEYEQATDRYSPYRKMLAALWRESPVPSIREGETLATMASLVHQDHEGASFAGALIERSGLTPTEWLRHYLRAYYVPLLHSFYAYDLVYMPHGENVILVLADGVVRRAVYKDIAEEIAVMDPDAVLPPEVSRIAVDVPDDKKLLSIFTDVFDCFFRFLAANLAEEGIVTEDAFWRTVAEVTREYQESVPELADKFERYDMFAPEFALSCLNRLQLRDNRQMVDLADPSGALQLVGTLKNPLAGRG,2020-01-15,6nl2_A,594
+6p5h_A,GPLGSRFNAPQKYQKIKREEFNPETAEKNKIYLLEDQLVYLDIFGKVIDLGQTSDTCHRLFNAITTPFYQNYILYDEYIDPEESAEEAAMFEMGEIVKAKMKNID,2020-05-27,6p5h_A,105
+6q10_A,MAHHHHHHKLGERVSRTEMTDVTPAQLGETKVRVLNASGRGGQAADVAGALKDLGFTQPTAANDPVYADTRLDCQGQIRFGTAGQATAAAVWLVAPCTELFNDGRADDSVDLVLGTDFTTLAHNDDIDAVLSSLRPGATQPPDPTLIAKIHASSC,2019-08-14,6q10_A,155
+6jv8_A,LQLLHQKVEEQAAKYKHRVPKKCCYDGARENKYETCEQRVARVTIGPHCIRAFNECCTIADKIRKESHHKGMLLGR,2020-04-22,6jv8_A,76
+6lrd_A,MSRPAHWLLAPPASRDALLATMREWQVSPPVAQVLCGRDLRTELLALPLELTPNPALREAARHIVAAVREGKRIRIHGDYDADGVSATATLVLGLRAIGANVHGFIPHRLNEGYGIHPDRVPEHAAAADLVVTVDCGVSNLDEVKSLLATGTEVVVTDHHAPGENFPECLVVHPHLTPDYDPDRHNLTGAGVAYHLLWAVYEELGRPEPRALLPLATLGTVADVAPLLGENRALVRAGLAEMARTELPGLRALMNEKRVRQPTARDVAFILAPRINAAGRMGEADRALELLTTPSDHEAKSLAAYLEIRNQERRKIQDDMFAQALQLADPNDPALVLTHDDWHAGVMGIVASKLVETFNRPVYIVAQGKGSVRSTPGISAVQGLRESRDLLGRFGGHPGAAGFSLDPQNFGALRERIHGYVRQFPTPVPAVRLDAPLPVAALTPELLSELSILEPFGEGNPRPLWHLRGPLTDTRLVGKQGDVLQFRFGGVKGMKYSERDDAAGERDVAAELALNEWKGRTSLELHAAALRPLAPLALAGTEEGLPTLPRLNPREAMTFLKTGAAAYAEQGVATYLRDNVPGLTLLDTNAPHPGGDLILYGLPPESALRRWLHEAQEQGGRVAFALGPKTLAELDAALTLAKLLPDSHTEAAQEAAADAYRSWQWAHHYRVLNDAGWSASVYAMLGLPVPAALPKAAEALALAAG,2020-08-26,6lrd_A,705
+6tly_A,GSSAAPGAIQCMNRHKMERHGKMPAGYKGFDCNVCDQPMLKITEKAYMYRCEKCDYDVCNQCAESRKFKEVHFLCAKCGKKFPSQTKLQYHSRGCRGPS,2019-12-25,6tly_A,99
+7la6_A,SNADSLPERIDLFVSLFDYNSATTSYDIRSIQTDFPTRLLTPDSMLPQTSEYPLKDIQLLYKLAQSCTGKLPLSPLITEPLVFTRSLCKGSSLSPRWFARSGLIHPGGGTYAFRYAEKYPAQFANLLPYMHIQERPNAAEGTLLYHLQNMGEDAINALVSGASMFGSGSDLWLRKGDIYYLFNEETWLTNANKAGLSYSLLSADTCFIQRGNICWDVEDHS,2021-01-27,7la6_A,221

data/splits/atlas_val.csv

@@ -0,0 +1,40 @@
+name,seqres,release_date,msa_id
+6irx_A,VYWDLDIQTNAVIRERAPADHLPPHPEIELQRAQLTTKLRQHYHELCSQREGIEPPRESFNRWLLERKVVDKGLDPLLPSECDPVISPSMFREIMNDIPIRLSRIKYKEEARKLLFKYAEAAKKMIDSRNVTPESRKVVKWNVEDTMNWLRRDHSASKEDYMDRLENLRKQCGPHVASVAKDSVEGICSKIYHISAEYVRRIRQAHLTLLKECNISVDGTESAEVQDRLVYCYPVRLSIPAPPQTRVELHFENDIACLRFKGEMVKVSRGHFNKLELLYRYSCIDDPRFEKFLSRVWCLIKRYQVMFGSGVNEGSGLQGSLPVPVFEALNKQFGVTFECFASPLNCYFKQFCSAFPDIDGFFGSRGPFLSFSPASGSFEANPPFCEELMDAMVTHFEDLLGRSSEPLSFIIFVPEWRDPPTPALTRMEASRFRRHQMTVPAFEHEYRSGSQHICKREEIYYKAIHGTAVIFLQNNAGFAKWEPTTERIQELLAAYK,2018-12-05,6irx_A
+6cka_B,MLYIDEFKEAIDKGYILGDTVAIVRKNGKIFDYVLPHEKVRDDEVVTVERVEEVMVELDKLEHHHHHH,2018-11-14,6cka_B
+6hj6_A,ETGMPLSCSKNNSHHYIFVGNNSGLELTLTNTSLLNHKFCNLSDAHKRAQYDMALMSIVSTFHLSIPNFNQYEAMSCDFNGDNITVQYNLSHASAVDAANHCGTVANGILETFHKFFWSNNIKDAYQLPNQGKLAHCYSTSYQFLIIQNTTWEDHCTFSRPTGTKHHHHHH,2018-10-10,6hj6_A
+6dgk_B,ASRYLTDMTLEEMSRDWFMLMPKQKVAGSLCIRMDQAIMDKNIILKANFSVIFDRLETLILLRAFTEEGAIVGEISPLPSLPGHTDEDVKNAVGVLIGGLEANDNTVRVSETLQRFAWRS,2018-08-15,6dgk_B
+6fc0_B,GPHMQPSAALQSLRSARFLPGIVQDIYPPGIKSPNPALNEAVQKKGRIFKYDVQFLLQFQNVFTEKPSPDFDQQVKALIGD,2018-06-27,6fc0_B
+6dlm_A,GSPRSYLLKELADLSQHLVRLLERLVRESERVVEVLERGEVDEEELKRLEDLHRELEKAVREVRETHREIRERSR,2018-12-19,6dlm_A
+6mdw_A,GPGRPQESLSLVDASWELVDPTPDLQALFVQFNDQFFWGQLEAVEVKWSVRMTLCAGICSYEGKGGMCSIRLSEPLLKLRPRKDLVETLLHEMIHAYLFVTNNDKDREGHGPEFCKHMHRINSLTGANITVYHTFHDEVDEYRRHWWRCNGPCQHRPPYYGYVKRATNREPSAHDYWWAEHQKTCGGTYIKIKE,2019-04-10,6mdw_A
+6bwq_A,TADAVLMIEANLDDQTGEGLGYVMNQLLTAGAYDVFFTPIQMKKDRPATKLTVLGNVNDKDLLTKLILQETTTIGVRYQTWQRTIMQRHFLTVATPYGDVQVKVATYQDIEKKMPEYADCAQLAQQFHIPFRTVYQAALVAVDQLDEEA,2018-06-20,6bwq_A
+5ydn_A,MNYATVNDLCARYTRTRLDILTRPKTADGQPDDAVAEQALADASAFIDGYLAARFVLPLTVVPSLLKRQCCVVAWFYLNESQPTEQITATYRDTVRWLEQVRDGKTDPG,2018-07-11,5ydn_A
+5w82_E,HMMPSEDYAIWYARATIAALQAAEYRLAMPSASYTAWFTDAVSDKLDKISESLNTLVECVIDKRLAVSVPEPLPVRVENKVQVEVEDEVRVRVENKVDVEVKN,2018-12-26,5w82_E
+6cb7_A,HMDKLRVLYDEFVTISKDNLERETGLSASDVDMDFDLNIFMTLVPVLAAAVCAITPTIEDDKIVTMMKYCSYQSFSFWFLKSGAVVKSVYNKLDYVKKEKFVATFRDMLLNVQTLISLNSMY,2018-12-12,6cb7_A
+5yrv_I,MARVSDYPLANKHPEWVKTATNKTLDDFTLENVLSNKVTAQDMRITPETLRLQASIAKDAGRDRLAMNFERAAELTAVPDDRILEIYNALRPYRSTKEELLAIADDLESRYQAKICAAFVREAATLYVERKKLKGDD,2018-09-19,5yrv_I
+5z51_A,PTLWPQREALKSALQYPALAGPVFDALTVEGFTHPEYAAVRAAIDTAGGTSAGLSGAQWLDMVRQQTTSTVTSALISELGVEAIQVDDDKLPRYIAGVLARLQEVWLGRQIAEVKSKLQRMSPIEQGDEYHALFGDLVAMEAYRRSLLEQASGDDLHHHHHH,2018-11-28,5z51_A
+6a9a_A,MISDSMTVEEIRLHLGLALKEKDFVVDKTGVKTIEIIGASFVADEPFIFGALNDEYIQRELEWYKSKSLFVKDIPGETPKIWQQVASSKGEINSNYGWAIWSEDNYAQYDMCLAELGQNPDSRRGIMIYTRPSMQFDYNKDGMSDFMSTNTVQYLIRDKKINAVVNMRSNDVVFGFRNNYAWQKYVLDKLVSDLNAGDSTRQYKAGSIIWNVGSLHVYSRHFYLVDHWWKTGETHISKKDYVGKYA,2019-01-02,6a9a_A
+6atg_C,GHMNQRNINELKIFVEKAKYYSIKLDAIYNECTGAYNDIMTYSEGTFSDQSKVNQAISIFKKDNKIVNKFKELEKIIEEYKPMFLSKLIDDFAIELDQAVDNDVSNARHVADSYKKLRKSVVLAYIESFDVISSKFVDSKFVEASKKFVNKAKEFVEENDLIALECIVKTIGDMVNDREINSRSRYNNFYKKEADFLGAAVELEGAYKAIKQTL,2018-09-12,6atg_C
+5w4a_B,MDTNKREIVEFLGIRTYFFPNLALYAVNNDELLVSDPNKANSFAAYVFGASDKKPSVDDIVQILFPSGSDSGTILTSMDTLLALGPDFLTEFKKRNQDLARFNLTHDLSILAQGDEDAAKKKLNLMGRKAKLQKTEAAKILAILIKTINSEENYEKFTELSELCGLDLDFDAYVFTKILGLEDEDTADEVEVIRDNFLNRLDQTKPKLADIIRNGP,2018-06-13,5w4a_B
+5zmo_A,GSREAPKTFHRRVGDVRPARRAMGPALHRPVLLLWAIGQAVARAPRLQPWSTTRDAVAPLMEKYGQVEDGVDGVRYPFWALVRDDLWCVEQAEELTLTSRGRRPTLESLNAVDPSAGLREDDYNLLRSQPEAAASAAAGLIARYFHLLPAGLLEDFGLHELLAGRWPDALRP,2018-09-26,5zmo_A
+6bk4_A,ARKDNLAKTIAETAKIREVLIIQNVLNCFNDDQVRSDFLNGENGAKKLENTELELLEKFFIETQTRRPETADDVSFIATAQKSAELFYSTINARPKSFGEVSFEKLRSLFQQIQDSGYLDKYYL,2018-11-07,6bk4_A
+6eu8_A,MDKKDDVKETIKKSKTIDATKYEMWTYVNLETGQTETHRDFSEWHVMKNGKLLETIPAKGSEADIKIKWHIAIHRFDIRTNEGEAIATKETEFSKVTGLPAGDYKKDVEIKDKMLVGFNMADMMKSKFTVAGMAKVNPVLKTWIVENPMGKAPVLSKSVFVVKFKDGSYAKIKFTDATNDKQEKGHVSFNYEFQPK,2018-10-24,6eu8_A
+6mbg_A,SNATGERFHPLLGRRVLDPAPGARCFTGTVSSDRPAYLGEHWVYDAIVVLGVTYLEMALAAASRLLPGNAADTLIVEDVTVWSPLVLRAGAPARLRLRSEDERFEIHSAEPERSDDESAWTRHATGRIARRQLSPDATGQLPRLDGEAVELDAYYERMRIYYGPRLRNIRHLERRGREAIGHVCLQGEEAQESASYELHPALLDACFQCVFALIYAHESHREPFVPLGCARIELRARGVREVRVHLRLHPPRSTDHNQTHTADLRLFDMEGRLVASVDALQLKRA,2018-09-19,6mbg_A
+6bm5_A,GSKKPRTPPVTLEAARDNDFAFDWQAYTPPVAHRLGVQEVEASIETLRNYIDWTPFFMTWSLAGKYPRILEDEVVGVEAQRLFKDANDMLDKLSAEKTLNPRGVVGLFPANRVGDDIEIYRDETRTHVINVSHHLRQQTEKTGFANYCLADFVAPKLSGKADYIGAFAVTGGLEEDALADAFEAQHDDYNKIMVKALADRLAEAFAEYLHERVRKVYWGYAPNENLSNEELIRENYQGIRPAPGYPACPEHTEKATIWELLEVEKHTGMKLTESFAMWPGASVSGWYFSHPDSKYYAVAQIQRDQVEDYARRKGMSVTEVERWLAPNLGYDAD,2018-05-23,6bm5_A
+6f45_D,MAVQGPWVGSSYVAETGQNWASLAANELRVTERPFWISSFIGRSKEEIWEWTGENHSFNKDWLIGELRNRGGTPVVINIRAHQVSYTPGAPLFEFPGDLPNAYITLNIYADIYGRGGTGGVAYLGGNPGGDCIHNWIGNRLRINNQGWICGGGGGGGGFRVGHTEAGGGGGRPLGAGGVSSLNLNGDNATLGAPGRGYQLGNDYAGNGGDVGNPGSASSAEMGGGAAGRAVVGTSPQWINVGNIAGSWL,2018-08-01,6f45_D
+6fub_B,METGNKYIEKRAIDLSRERDPNFFDNPGIPVPECFWFMFKNNVRQDAGTCYSSWKMDMKVGPNWVHIKSDDNCNLSGDFPPGWIVLGKKRPGF,2018-06-13,6fub_B
+6gfx_C,MEAGRPRPVLRSVNSREPSQVIFCNRSPRVVLPVWLNFDGEPQPYPTLPPGTGRRIHSYRGHLWLFRDAGTHDGLLVNQTELFVPSLNVDGQPIFANITLPVYTLKERCLQVVRSLVKPENYRRLDIVRSLYEDLEDHPNVQKDLERLTQERIAHQRMGD,2018-07-11,6gfx_C
+6a02_A,MAATNMTDNVTLNNDKISGQAWQAMRDIGMSRFELFNGRTQKAEQLAAQAEKLLNDDSTDWNLYVKSDKKAPVEGDHYIRINSSITVAEDYLPAGQKNDAINKANQKMKEGDKKGTIEALKLAGVSVIENQELIPLQQTRKDVTTALSLMNEGKYYQAGLLLKSAQDGIVVDSQSVQLEHHHHHH,2019-02-06,6a02_A
+6c0h_A,SGMKSAKEPTIYQDVDIIRRIQELMVLCSLLPPDGKLREALELALALHEEPALARITPLTNLHPFATKAWLETLWLGEGVSSEEKELVAWQNKSENMGPAIRELKNAEQQSGITLVARLTS,2018-09-05,6c0h_A
+6dnm_A,SHMVVLGGDRDFWLQVGIDPIQIMTGTATFYTLRCYLDDRPIFLGRNGRISVFGSERALARYLADEHDHDLSDLSTYDDIRTAATDGSLAVAVTDDNVYVLSGLVDDFADGPDAVDREQLDLAVELLRDIGDYSEDSAVDKALETTRPLGQLVAYVLDPHSVGKPTAPYAAAVREWEKLERFVESRLRRE,2019-01-23,6dnm_A
+6as3_A,HHHHHHMEKKLSDAQVALVAAWRKYPDLRESLEEAASILSLIVFQAETLSDQANELANYIRRQGLEEAEGACRNIDIMRAKWVEVCGEVNQYGIRVYGDAIDRDVD,2018-08-29,6as3_A
+6bn0_A,QPYNPCKPQEVIDTKCMGPKDCLYPNPDSCTTYIQCVPLDEVGNAKPVVKPCPKGLQWNDNVGKKWCDYPNLSTCPVKT,2018-08-22,6bn0_A
+5wfy_A,MILKILNEIASIGSTKQKQAILEKNKDNELLKRVYRLTYSRGLQYYIKKWPKPGIATQSFGMLTLTDMLDFIEFTLATRKLTGNAAIEELTGYITDGKKDDVEVLRRVMMRDLECGASVSIANKVWPGLEHHHHHH,2018-09-26,5wfy_A
+6hem_A,GPDFSKHLKEETIQIITKASHEHEDKSPETVLQSAIKLEYARLVKLAQEDTPPETDYRLHHVVVYFIQNQAPKKIIEKTLLEQFGDRNLSFDERCHNIMKVAQAKLEMIKPEEVNLEEYEEWHQDYRKFRETTMYLIIGLENFQRESYIDSLLFLICAYQNNKELLSKGLYRGHDEELISHYRRECLLKLNEQAAELFESGEDREVNNGLIIMNEFIVPFLPLLLVDEMEEKDILAVEDMRNRWCSYLGQEMEPHLQEKLTDFLPKLLDCSMEIKSFHEPPKLPSYSTHELCERFARIMLSLS,2019-03-27,6hem_A
+5z1n_A,GPLSGLKKLIPEEGRELIGSVKKIIKRVSNEEKANEMEKNILKILIKVFFYIDSKAIQIGDLAKVDRALRDGFNHLDRAFRYYGVKKAADLVVILEKASTALKEAEQETVTLLTPFFRPHNIQLIRNTFAFLGSLDFFTKVWDDLEIEDDLFLLISALNKYTQIELIY,2018-10-17,5z1n_A
+5zlq_A,GPMGKIALQLKATLENITNLRPVGEDFRWYLKMKCGNCGEISDKWQYIRLMDSVALKGGRGSASMVQKCKLCARENSIEILSSTIKPYNAEDNENFKTIVEFECRGLEPVDFQPQAGFAAEGVESGTAFSDINLQEKDWTDYDEKAQESVGIYEVTHQFVKC,2018-10-10,5zlq_A
+5naz_A,SVAHGFLITRHSQTTDAPQCPQGTLQVYEGFSLLYVQGNKRAHGQDLGTAGSCLRRFSTMPFMFCNINNVCNFASRNDYSYWLSTPEPMPMSMQPLKGQSIQPFISRCAVCEAPAVVIAVHSQTIQIPHCPQGWDSLWIGYSFMMHTSAGAEGSGQALASPGSCLEEFRSAPFIECHGRGTCNYYANSYSFWLATVDVSDMFSKPQSETLKAGDLRTRISRCQVCMKRT,2018-09-12,5naz_A
+6e33_A,GKVKKRLPQAKRACAKCQKDNKKCDDARPCQRCIKAKTDCIDLPRKKRPTGVRRGPYKKLS,2018-10-24,6e33_A
+5ok6_A,MDREPQHEELPGLDSQWRQIENGESGRERPLRAGESWFLVEKHWYKQWEAYVQGGDQDSSTFPGCINNATLFQDEINWRLKEGLVEGEDYVLLPAAAWHYLVSWYGLEHGQPPIERKVIELPNIQKVEVYPVELLLVRHNDLGKSHTVQFSHTDSIGLVLRTARERFLVEPQEDTRLWAKNSEGSLDRLYDTHITVLDAALETGQLIIMETRKKDGTWPSAQLEHHHHHH,2018-08-08,5ok6_A
+6idx_A,GPGSMPPPSDIVKVAIEWPGANAQLLEIDQKRPLASIIKEVCDGWSLPNPEYYTLRYADGPQLYITEQTRSDIKNGTILQLAISPSRAARQLMERTQSSNMETRLDAMKELAKLSADVTFATEFINMDGIIVLTRLVESGTKLLSHYSEMLAFTLTAFLELMDHGIVSWDMVSITFIKQIAGYVSQPMVDVSILQRSLAILESMVLNSQSLYQKIAEEITVGQLISHLQVSNQEIQTYAIALINALFLKAPEDKRQDMANAFAQKHLRSIILNHVIRGNRPIKTEMAHQLYVLQVLTFNLLEERMMTKMDPNDQAQRDIIFELRRIAFDAESDPSNAPGSGTEKRKAMYTKDYKMLGFTNHINPAMDFTQTPPGMLALDNMLYLAKVHQDTYIRIVLENSSREDKHECPFGRSAIELTKMLCEILQVGELPNEGRNDYHPMFFTHDRAFEELFGICIQLLNKTWKEMRATAEDFNKVMQVVREQITRALPSKPNSLDQFKSKLRSLSYSEILRLRQSERMSQDD,2019-01-23,6idx_A
+6e5y_A,SNAMTTILPNLPTGQKVGIAFSGGLDTSAALLWMRQKGAVPYAYTANLGQPDEPDYDEIPRRAMQYGAEAARLVDCRAQLVAEGIAALQAGAFHISTAGLTYFNTTPIGRAVTGTMLVAAMKEDGVNIWGDGSTFKGNDIERFYRYGLLTNPDLKIYKPWLDQTFIDELGGRAEMSEYMRQAGFDYKMSAEKAYSTDSNMLGATHEAKDLELLSAGIRIVQPIMGVAFWQDSVQIKAEEVTVRFEEGQPVALNGVEYADPVELLLEANRIGGRHGLGMSDQIENRIIEAKSRGIYEAPGLALLFIAYERLVTGIHNEDTIEQYRENGRKLGRLLYQGRWFDPQAIMLRETAQRWVARAITGEVTLELRRGNDYSLLNTESANLTYAPERLSMEKVENAPFTPADRIGQLTMRNLDIVDTREKLFTYVKTGLLAPSAGSALPQIKDGKK,2018-08-01,6e5y_A
+6crk_G,MASNNTASIAQARKLVEQLKMEANIDRIKVSKAAADLMAYCEAHAKEDPLLTPVPASENPFREKKFFSAIL,2018-10-24,6crk_G

data/tps_inference.py

@@ -0,0 +1,171 @@
+import argparse
+import copy
+import json
+import pickle
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--sim_ckpt', type=str, default=None, required=True)
+parser.add_argument('--data_dir', type=str, default='share/4AA_data')
+parser.add_argument('--mddir', type=str, default='/data/cb/scratch/share/mdgen/4AA_sims')
+parser.add_argument('--suffix', type=str, default='')
+parser.add_argument('--pdb_id', nargs='*', default=[])
+parser.add_argument('--num_frames', type=int, default=1000)
+parser.add_argument('--num_batches', type=int, default=100)
+parser.add_argument('--batch_size', type=int, default=10)
+parser.add_argument('--out_dir', type=str, default=".")
+parser.add_argument('--split', type=str, default='splits/4AA_test.csv')
+parser.add_argument('--chunk_idx', type=int, default=0)
+parser.add_argument('--n_chunks', type=int, default=1)
+args = parser.parse_args()
+import mdgen.analysis
+import os, torch, mdtraj, tqdm
+from mdgen.geometry import atom14_to_atom37, atom37_to_torsions
+from mdgen.tensor_utils import tensor_tree_map
+
+from mdgen.residue_constants import restype_order
+from mdgen.wrapper import NewMDGenWrapper
+from mdgen.dataset import atom14_to_frames
+import pandas as pd
+import contextlib
+import numpy as np
+
+@contextlib.contextmanager
+def temp_seed(seed):
+    state = np.random.get_state()
+    np.random.seed(seed)
+    try:
+        yield
+    finally:
+        np.random.set_state(state)
+
+os.makedirs(args.out_dir, exist_ok=True)
+
+def get_sample(arr, seqres, start_idxs, end_idxs, start_state, end_state, num_frames=1000):
+    start_idx = np.random.choice(start_idxs, 1).item()
+    end_idx = np.random.choice(end_idxs, 1).item()
+
+    start_arr = np.copy(arr[start_idx:start_idx + 1]).astype(np.float32)
+    end_arr = np.copy(arr[end_idx:end_idx + 1]).astype(np.float32)
+    seqres = torch.tensor([restype_order[c] for c in seqres])
+
+    start_frames = atom14_to_frames(torch.from_numpy(start_arr))
+    start_atom37 = torch.from_numpy(atom14_to_atom37(start_arr, seqres)).float()
+    start_torsions, start_torsion_mask = atom37_to_torsions(start_atom37, seqres[None])
+    
+    end_frames = atom14_to_frames(torch.from_numpy(end_arr))
+    end_atom37 = torch.from_numpy(atom14_to_atom37(end_arr, seqres)).float()
+    end_torsions, end_torsion_mask = atom37_to_torsions(end_atom37, seqres[None])
+    L = start_frames.shape[1]
+    traj_torsions = start_torsions.expand(num_frames, -1, -1, -1).clone()
+    traj_torsions[-1] = end_torsions
+
+    traj_trans = start_frames._trans.expand(num_frames, -1, -1).clone()
+    traj_trans[-1] = end_frames._trans
+
+    traj_rots = start_frames._rots._rot_mats.expand(num_frames, -1, -1, -1).clone()
+    traj_rots[-1] = end_frames._rots._rot_mats
+
+    mask = torch.ones(L)
+    return {
+        'torsions': traj_torsions,
+        'torsion_mask': start_torsion_mask[0],
+        'trans': traj_trans,
+        'rots': traj_rots,
+        'seqres': seqres,
+        'start_idx': start_idx,
+        'end_idx': end_idx,
+        'start_state': start_state,
+        'end_state': end_state,
+        'mask': mask,  # (L,)
+    }
+
+def do(model, name, seqres):
+    print('doing', name)
+    if os.path.exists(f'{args.out_dir}/{name}_metadata.json'):
+        return
+    if os.path.exists(f'{args.out_dir}/{name}_metadata.pkl'):
+        pkl_metadata = pickle.load(open(f'{args.out_dir}/{name}_metadata.pkl', 'rb'))
+        msm = pkl_metadata['msm']
+        cmsm = pkl_metadata['cmsm']
+        ref_kmeans = pkl_metadata['ref_kmeans']
+    else:
+        with temp_seed(137):
+            feats, ref = mdgen.analysis.get_featurized_traj(f'{args.mddir}/{name}/{name}', sidechains=True)
+            tica, _ = mdgen.analysis.get_tica(ref)
+            kmeans, ref_kmeans = mdgen.analysis.get_kmeans(tica.transform(ref))
+            try:
+                msm, pcca, cmsm = mdgen.analysis.get_msm(ref_kmeans, nstates=10)
+            except Exception as e:
+                print('ERROR', e, name, flush=True)
+                return
+        pickle.dump({
+            'msm': msm,
+            'cmsm': cmsm,
+            'tica': tica,
+            'pcca': pcca,
+            'kmeans': kmeans,
+            'ref_kmeans': ref_kmeans,
+        }, open(f'{args.out_dir}/{name}_metadata.pkl', 'wb'))
+
+    flux_mat = cmsm.transition_matrix * cmsm.pi[None, :]
+    flux_mat[flux_mat < 0.0000001] = np.inf  # set 0 flux to inf so we do not choose that as the argmin
+    start_state, end_state = np.unravel_index(np.argmin(flux_mat, axis=None), flux_mat.shape)
+    ref_discrete = msm.metastable_assignments[ref_kmeans]
+    start_idxs = np.where(ref_discrete == start_state)[0]
+    end_idxs = np.where(ref_discrete == end_state)[0]
+    if (ref_discrete == start_state).sum() == 0 or (ref_discrete == end_state).sum() == 0:
+        print('No start or end state found for ', name, 'skipping...')
+        return
+
+    arr = np.lib.format.open_memmap(f'{args.data_dir}/{name}.npy', 'r')
+
+    metadata = []
+    for i in tqdm.tqdm(range(args.num_batches), desc='num batch'):
+        batch_list = []
+        for _ in range(args.batch_size):
+            batch_list.append(
+                get_sample(arr, seqres, copy.deepcopy(start_idxs), end_idxs, start_state, end_state, num_frames=args.num_frames))
+        batch = next(iter(torch.utils.data.DataLoader(batch_list, batch_size=args.batch_size)))
+        batch = tensor_tree_map(lambda x: x.cuda(), batch)
+        print('Start tps for ', name, 'with start coords', batch['trans'][0, 0, 0])
+        print('Start tps for ', name, 'with end coords', batch['trans'][0, -1, 0])
+        atom14s, _ = model.inference(batch)
+        for j in range(args.batch_size):
+            idx = i * args.batch_size + j
+            path = os.path.join(args.out_dir, f'{name}_{idx}.pdb')
+            atom14_to_pdb(atom14s[j].cpu().numpy(), batch['seqres'][0].cpu().numpy(), path)
+
+            traj = mdtraj.load(path)
+            traj.superpose(traj)
+            traj.save(os.path.join(args.out_dir, f'{name}_{idx}.xtc'))
+            traj[0].save(os.path.join(args.out_dir, f'{name}_{idx}.pdb'))
+            metadata.append({
+                'name': name,
+                'start_idx': batch['start_idx'][j].cpu().item(),
+                'end_idx': batch['end_idx'][j].cpu().item(),
+                'start_state': batch['start_state'][j].cpu().item(),
+                'end_state': batch['end_state'][j].cpu().item(),
+                'path': path,
+            })
+    json.dump(metadata, open(f'{args.out_dir}/{name}_metadata.json', 'w'))
+
+
+@torch.no_grad()
+def main():
+    model = NewMDGenWrapper.load_from_checkpoint(args.sim_ckpt)
+    model.eval().to('cuda')
+    df = pd.read_csv(args.split, index_col='name')
+    names = np.array(df.index)
+
+    chunks = np.array_split(names, args.n_chunks)
+    chunk = chunks[args.chunk_idx]
+    print('#' * 20)
+    print(f'RUN NUMBER: {args.chunk_idx}, PROCESSING IDXS {args.chunk_idx * len(chunk)}-{(args.chunk_idx + 1) * len(chunk)}')
+    print('#' * 20)
+    for name in tqdm.tqdm(chunk, desc='num peptides'):
+        if args.pdb_id and name not in args.pdb_id:
+            continue
+        do(model, name, df.seqres[name])
+
+
+main()

data/train.py

@@ -0,0 +1,77 @@
+from mdgen.parsing import parse_train_args
+args = parse_train_args()
+from mdgen.logger import get_logger
+logger = get_logger(__name__)
+
+import torch, os, wandb
+from mdgen.dataset import MDGenDataset
+from mdgen.wrapper import NewMDGenWrapper
+from pytorch_lightning.callbacks import ModelCheckpoint, ModelSummary
+import pytorch_lightning as pl
+
+
+torch.set_float32_matmul_precision('medium')
+
+if args.wandb:
+    wandb.init(
+        entity=os.environ["WANDB_ENTITY"],
+        settings=wandb.Settings(start_method="fork"),
+        project="mdgen",
+        name=args.run_name,
+        config=args,
+    )
+
+
+trainset = MDGenDataset(args, split=args.train_split)
+
+if args.overfit:
+    valset = trainset    
+else:
+    valset = MDGenDataset(args, split=args.val_split, repeat=args.val_repeat)
+
+train_loader = torch.utils.data.DataLoader(
+    trainset,
+    batch_size=args.batch_size,
+    num_workers=args.num_workers,
+    shuffle=True,
+)
+
+val_loader = torch.utils.data.DataLoader(
+    valset,
+    batch_size=args.batch_size,
+    num_workers=args.num_workers,
+)
+model = NewMDGenWrapper(args)
+    
+trainer = pl.Trainer(
+    accelerator="gpu" if torch.cuda.is_available() else 'auto',
+    max_epochs=args.epochs,
+    limit_train_batches=args.train_batches or 1.0,
+    limit_val_batches=0.0 if args.no_validate else (args.val_batches or 1.0),
+    num_sanity_val_steps=0,
+    precision=args.precision,
+    enable_progress_bar=not args.wandb or os.getlogin() == 'hstark',
+    gradient_clip_val=args.grad_clip,
+    default_root_dir=os.environ["MODEL_DIR"], 
+    callbacks=[
+        ModelCheckpoint(
+            dirpath=os.environ["MODEL_DIR"], 
+            save_top_k=-1,
+            every_n_epochs=args.ckpt_freq,
+        ),
+        ModelSummary(max_depth=2),
+    ],
+    accumulate_grad_batches=args.accumulate_grad,
+    val_check_interval=args.val_freq,
+    check_val_every_n_epoch=args.val_epoch_freq,
+    logger=False
+)
+
+# torch.manual_seed(137)
+# np.random.seed(137)
+
+
+if args.validate:
+    trainer.validate(model, val_loader, ckpt_path=args.ckpt)
+else:
+    trainer.fit(model, train_loader, val_loader, ckpt_path=args.ckpt)

data/upsampling_inference.py

@@ -0,0 +1,105 @@
+import argparse
+parser = argparse.ArgumentParser()
+parser.add_argument('--ckpt', type=str, default=None, required=True)
+parser.add_argument('--data_dir', type=str, default=None, required=True)
+parser.add_argument('--suffix', type=str, default='_i100')
+parser.add_argument('--pdb_id', nargs='*', default=[])
+parser.add_argument('--batch_size', type=int, default=1)
+parser.add_argument('--out_dir', type=str, default=".")
+parser.add_argument('--split', type=str, default='splits/4AA_implicit_test.csv')
+args = parser.parse_args()
+
+import os, torch, mdtraj, tqdm
+import numpy as np
+from mdgen.geometry import atom14_to_frames, atom14_to_atom37, atom37_to_torsions
+from mdgen.residue_constants import restype_order
+from mdgen.tensor_utils import tensor_tree_map
+from mdgen.wrapper import NewMDGenWrapper
+from mdgen.utils import atom14_to_pdb
+import pandas as pd
+
+
+
+
+os.makedirs(args.out_dir, exist_ok=True)
+
+
+
+def get_batch(name, seqres, num_frames):
+    arr = np.lib.format.open_memmap(f'{args.data_dir}/{name}{args.suffix}.npy', 'r')
+    arr = np.copy(arr).astype(np.float32)
+
+    frames = atom14_to_frames(torch.from_numpy(arr))
+    seqres = torch.tensor([restype_order[c] for c in seqres])
+    atom37 = torch.from_numpy(atom14_to_atom37(arr, seqres[None])).float()
+    torsions, torsion_mask = atom37_to_torsions(atom37, seqres[None])
+    L = frames.shape[1]
+    mask = torch.ones(L)
+    return {
+        'torsions': torsions,
+        'torsion_mask': torsion_mask[0],
+        'trans': frames._trans,
+        'rots': frames._rots._rot_mats,
+        'seqres': seqres,
+        'mask': mask, # (L,)
+    }
+
+def split_batch(item, num_frames=1000, cond_interval=100):
+    total_frames = item['torsions'].shape[0] * cond_interval
+    batches = []
+    total_items = int(total_frames / num_frames)
+    cond_frames = int(num_frames / cond_interval)
+    for i in tqdm.trange(total_items):
+        new_batch = {
+            'torsions': torch.zeros(num_frames, 4, 7, 2),
+            'torsion_mask': item['torsion_mask'],
+            'trans': torch.zeros(num_frames, 4, 3),
+            'rots': torch.zeros(num_frames, 4, 3, 3),
+            'seqres': item['seqres'],
+            'mask': item['mask'],
+        }
+        new_batch['rots'][:] = torch.eye(3)
+        new_batch['torsions'][::cond_interval] = item['torsions'][i*cond_frames:(i+1)*cond_frames]
+        new_batch['trans'][::cond_interval] = item['trans'][i*cond_frames:(i+1)*cond_frames]
+        new_batch['rots'][::cond_interval] = item['rots'][i*cond_frames:(i+1)*cond_frames]
+        batches.append(new_batch)
+    return batches
+    
+def do(model, name, seqres):
+
+    item = get_batch(name, seqres, num_frames = model.args.num_frames)
+    
+    items = split_batch(item, num_frames=model.args.num_frames, cond_interval=model.args.cond_interval)
+    
+    loader = torch.utils.data.DataLoader(items, shuffle=False, batch_size=args.batch_size)
+
+    all_atom14 = []
+    for batch in tqdm.tqdm(loader):
+        batch = tensor_tree_map(lambda x: x.cuda(), batch)  
+        atom14, _ = model.inference(batch)
+        all_atom14.extend(atom14)
+        
+    all_atom14 = torch.cat(all_atom14)
+    
+    path = os.path.join(args.out_dir, f'{name}.pdb')
+    atom14_to_pdb(all_atom14.cpu().numpy(), batch['seqres'][0].cpu().numpy(), path)
+    
+    traj = mdtraj.load(path)
+    traj.superpose(traj)
+    traj.save(os.path.join(args.out_dir, f'{name}.xtc'))
+    traj[0].save(os.path.join(args.out_dir, f'{name}.pdb'))
+
+@torch.no_grad()
+def main():
+    model = NewMDGenWrapper.load_from_checkpoint(args.ckpt)
+    model.eval().to('cuda')
+    
+    
+    df = pd.read_csv(args.split, index_col='name')
+    for name in df.index:
+        if args.pdb_id and name not in args.pdb_id:
+            continue
+        do(model, name, df.seqres[name])
+        
+
+main()