Upload 350 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/resources/uk/ac/cam/ch/wwmm/opsin/resources/serialisedAutomata/chemical_reversed_SerialisedAutomaton.aut filter=lfs diff=lfs merge=lfs -text
+TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/resources/uk/ac/cam/ch/wwmm/opsin/resources/serialisedAutomata/chemicalSerialisedAutomaton.aut filter=lfs diff=lfs merge=lfs -text
+TransAntivirus/download_pubchem/pubchem_30m_new.csv filter=lfs diff=lfs merge=lfs -text

TransAntivirus/best_in_dataset.py

@@ -0,0 +1,130 @@
+from transformers import HfArgumentParser
+
+import torch
+import torch.multiprocessing
+torch.multiprocessing.set_sharing_strategy("file_system")
+from torch.utils.data import DataLoader, ConcatDataset
+
+from t5 import T5IUPACTokenizer, T5Collator
+from iupac_dataset import IUPACDataset
+from physprop_exp import levenshtein_distance
+
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+
+import sys
+import os
+import itertools
+from itertools import dropwhile
+from multiprocessing import Pool
+
+import numpy as np
+from scipy import ndimage
+
+@dataclass
+class IUPACArguments:
+    dataset_dir: str = field(
+            metadata={"help": "Directory where dataset is locaed"}
+    )
+    vocab_fn: str = field(
+            metadata={"help": "File containing sentencepiece model"}
+    )
+    dataset_filename: str = field(
+            default="iupacs_logp.txt",
+            metadata={"help": "Filename within dataset_dir containing the data"}
+    )
+    name_col: Optional[str] = field(
+            default="Preferred", # for logp
+            metadata={"help": "Name of column with IUPAC names"}
+    )
+
+
+def main():
+    parser = HfArgumentParser(IUPACArguments)
+    iupac_args, = parser.parse_args_into_dataclasses()
+
+    global tokenizer
+    tokenizer = T5IUPACTokenizer(vocab_file=iupac_args.vocab_fn)
+
+    pad = tokenizer._convert_token_to_id("<pad>")
+    unk = tokenizer._convert_token_to_id("<unk>")
+
+    dataset_kwargs = {
+            "dataset_dir": iupac_args.dataset_dir,
+            "tokenizer": tokenizer,
+            "max_length": 128,
+            "prepend_target": False,
+            "mean_span_length": 3,
+            "mask_probability": 0,
+            #"dataset_size": 200000,
+    }
+
+    pubchem_train = IUPACDataset(train=True, **dataset_kwargs)
+    pubchem_val = IUPACDataset(train=False, **dataset_kwargs)
+    pubchem = ConcatDataset([pubchem_train, pubchem_val])
+
+    batch_size = 2048
+
+    collator = T5Collator(tokenizer.pad_token_id)
+    def collate(batch):
+        # [:-1] to remove </s>
+        input_ids = [d["input_ids"][:-1] for d in batch]
+        lengths = torch.tensor([d.numel() for d in input_ids])
+        return torch.hstack([torch.tensor([len(batch)]), lengths] + input_ids)
+    loader = DataLoader(pubchem,
+                        batch_size=batch_size,
+                        num_workers=72,
+                        collate_fn=collate)
+
+    # we'll find clusters for each input molecule
+    input_iupacs = [n.strip() for n in sys.stdin.readlines()]
+    # [:-1] to get rid of </s>
+    base_tokenizeds = [tokenizer(b)["input_ids"][:-1] for b in input_iupacs]
+    base_tokenizeds = [torch.tensor(t)
+                       for t in base_tokenizeds if len(t) >= 10 and unk not in t]
+
+    potentially_reachables = []
+    for batch_idx, batch in enumerate(loader):
+        #num_processed = batch_idx * batch_size
+        #if batch_idx % 200 == 0:
+        #    print("completed {}/{} ({:>5.3f}%)...".format(num_processed, len(pubchem), num_processed / len(pubchem) * 100))
+
+        bs = batch[0]
+        lengths = batch[1:bs + 1]
+        tokenizeds = torch.split(batch[bs + 1:], lengths.tolist())
+        potentially_reachables += tokenizeds
+
+
+    pairs = list(itertools.product(potentially_reachables, base_tokenizeds))
+    pool = Pool(144)
+    is_reachable = pool.starmap(check_if_reachable, pairs)
+    pool.close()
+    pool.join()
+
+def check_if_reachable(tokenized, base_tokenized):
+    global tokenizer
+
+    tokenized_bag = set(tokenized.tolist())
+    base_bag = set(base_tokenized.tolist())
+
+    if len(tokenized_bag ^ base_bag) >= 15:
+        return False
+
+    if abs(len(tokenized) - len(base_tokenized)) > 15:
+        return False
+
+    dist, src_mask, _ = levenshtein_distance(base_tokenized, tokenized)
+    src_dilated = ndimage.binary_fill_holes(src_mask).astype(int)
+
+    # we used span lengths 1-5 in gen_t5.py
+    if 1 <= src_dilated.sum() <= 5:
+        # this is a match
+        base_iupac = tokenizer.decode(base_tokenized)
+        decoded = tokenizer.decode(tokenized)
+        print('"{}","{}"'.format(base_iupac, decoded))
+        return True
+
+    return False
+
+if __name__ == "__main__":
+    main()

TransAntivirus/data_utils.py

@@ -0,0 +1,206 @@
+import torch
+
+def mask_spans(tokenizer, input_ids, mask_probability, mean_span_length):
+    DEBUG = False
+    length = input_ids.numel()
+    if length < 2:
+        return input_ids, tokenizer.sentinels(torch.tensor([0]))
+
+    num_noise_tokens = round(length * mask_probability)
+    num_noise_tokens = min(max(num_noise_tokens, 0), length - 1)
+    if num_noise_tokens == 0:
+        return input_ids, tokenizer.sentinels(torch.tensor([0]))
+    DEBUG and print("num_noise_tokens", num_noise_tokens)
+    num_nonnoise_tokens = length - num_noise_tokens
+    DEBUG and print("num_nonnoise_tokens", num_nonnoise_tokens)
+
+    num_noise_spans = round(num_noise_tokens / mean_span_length)
+    num_noise_spans = max(num_noise_spans, 1)
+    DEBUG and print("num_noise_spans", num_noise_spans)
+
+    # probability of the last token being noise should be
+    # mask_probability, but right now it's 100%
+    if torch.rand(1).item() < mask_probability:
+        num_nonnoise_spans = num_noise_spans
+    else:
+        num_nonnoise_spans = num_noise_spans + 1
+
+    def _random_segmentation(num_items, num_segments):
+        ones = (torch.arange(num_items - 1) < num_segments - 1).int()
+        first_in_segment = torch.cat([torch.tensor([0]).int(),
+                                      ones[torch.randperm(num_items-1)]])
+        segment_id = torch.cumsum(first_in_segment, dim=0)
+        _, lengths = segment_id.unique_consecutive(return_counts=True)
+        return lengths
+    noise_span_lengths = _random_segmentation(num_noise_tokens,
+                                              num_noise_spans)
+    DEBUG and print("noise_span_lengths", noise_span_lengths)
+    nonnoise_span_lengths = _random_segmentation(num_nonnoise_tokens,
+                                                 num_nonnoise_spans)
+    DEBUG and print("nonnoise_span_lengths", nonnoise_span_lengths)
+    #print(noise_span_lengths.float().mean().item(), noise_span_lengths)
+    #print(nonnoise_span_lengths)
+    if num_nonnoise_spans > num_noise_spans:
+        noise_span_lengths = torch.cat([noise_span_lengths,
+                                        torch.tensor([0])])
+    interleaved_span_lengths = torch.stack([
+            nonnoise_span_lengths, noise_span_lengths
+        ], dim=1).view(-1)
+    if num_nonnoise_spans > num_noise_spans:
+        interleaved_span_lengths = interleaved_span_lengths[:-1]
+
+    DEBUG and print('interleaved', interleaved_span_lengths)
+    span_starts = torch.cumsum(interleaved_span_lengths, dim=0)[:-1]
+    DEBUG and print("span_starts", span_starts)
+    span_start_indicator = torch.zeros(length).bool()
+    span_start_indicator[span_starts] = 1
+    DEBUG and print("span_start_indicator", span_start_indicator)
+    span_num = torch.cumsum(span_start_indicator, dim=0)
+    DEBUG and print("span_num", span_num)
+    is_noise = span_num % 2 == 1
+    DEBUG and print("is_noise", is_noise)
+
+    def sentinelify(tokens, noise_mask):
+        prev_token_is_noise = torch.cat([torch.tensor([0]).bool(),
+                                         noise_mask[:-1]])
+        first_noise_tokens = noise_mask & ~prev_token_is_noise
+        subsequent_noise_tokens = noise_mask & prev_token_is_noise
+        sentinels = tokenizer.sentinels(
+                    torch.cumsum(first_noise_tokens, dim=0) - 1
+                )
+        tokens = torch.where(first_noise_tokens, sentinels, tokens)
+        return tokens[~subsequent_noise_tokens]
+
+    masked_input = sentinelify(input_ids, is_noise)
+    DEBUG and print("masked_input", masked_input)
+    target_ids = sentinelify(input_ids, ~is_noise)
+    DEBUG and print("target_ids", target_ids)
+
+    return masked_input, target_ids
+
+
+def collapse_sentinels(tokenizer, input_ids, target_ids):
+    def remove_extraneous(ids):
+        # delete everything after </s>
+        eos = tokenizer.eos_token_id
+        pad_mask = (ids == eos).cumsum(dim=0).clamp(0, 1).bool()
+        ids = ids[:ids.numel() - pad_mask.sum()]
+        return ids
+
+    input_ids = remove_extraneous(input_ids)
+    target_ids = remove_extraneous(target_ids)
+
+    num_sentinels = tokenizer._extra_ids
+    all_sentinel_ids = tokenizer.sentinels(
+                torch.arange(num_sentinels).to(input_ids.device)
+            )
+    min_sentinel_id = all_sentinel_ids.min()
+    max_sentinel_id = all_sentinel_ids.max()
+
+    def validate(ids, name="ids"):
+        #mask = (min_sentinel_id <= ids) & (ids <= max_sentinel_id)
+        mask = tokenizer.sentinel_mask(ids)
+        sentinels = ids[mask]
+        msg = "sentinels in {} are in the wrong order"
+        if not torch.all(sentinels==all_sentinel_ids[:sentinels.numel()]):
+            raise ValueError(msg.format(name))
+        return mask
+
+    input_sentinel_mask = validate(input_ids, "input_ids")
+    target_sentinel_mask = validate(target_ids, "target_ids")
+
+    input_span_types, input_span_lengths = \
+            input_sentinel_mask.unique_consecutive(return_counts=True)
+    target_span_types, target_span_lengths = \
+            target_sentinel_mask.unique_consecutive(return_counts=True)
+
+    input_sentinel_span_lengths = input_span_lengths[input_span_types]
+    target_sentinel_span_lengths = target_span_lengths[target_span_types]
+    if input_sentinel_span_lengths.sum() != input_span_types.sum():
+        raise ValueError("consecutive sentinel tokens in input_ids")
+    if target_sentinel_span_lengths.sum() != target_span_types.sum():
+        raise ValueError("consecutive sentinel tokens in target_ids")
+
+    msg = "invalid interleaving of sentinels between inputs and target"
+    if input_span_types.numel() != target_span_types.numel():
+        raise ValueError(msg)
+    xor = torch.logical_xor(input_span_types, target_span_types)
+    if xor.sum() != input_span_types.numel():
+        raise ValueError(msg)
+
+    input_repeat = input_sentinel_mask.long()
+    input_repeat[input_sentinel_mask] = target_span_lengths[~target_span_types]
+    input_repeat[input_repeat == 0] = 1
+
+    target_repeat = target_sentinel_mask.long()
+    target_repeat[target_sentinel_mask] = input_span_lengths[~input_span_types]
+    target_repeat[target_repeat == 0] = 1
+
+    input_repeated = input_ids.repeat_interleave(input_repeat)
+    target_repeated = target_ids.repeat_interleave(target_repeat)
+
+    #use_target = (min_sentinel_id <= input_repeated) & (input_repeated <= max_sentinel_id)
+    use_target = tokenizer.sentinel_mask(input_repeated)
+    collapsed = torch.where(use_target, target_repeated, input_repeated)
+
+    return collapsed
+
+
+
+def recoverd(x,y):
+    x = x.numpy()
+    y = y.numpy()
+
+    x_drop_index = np.where(x==1)[0][0]
+    x =x[:x_drop_index+1]
+
+    y_drop_index = np.where(y==1)[0][0]
+    y =y[:y_drop_index+1]
+
+    z = []
+    for i in y:
+        if i >1400:
+            z.append(i)
+
+    z = sorted(set(z),reverse=True)
+
+    final_pos = min(z)
+
+    if final_pos not in x:
+        y = y[:-2]
+        z = z[:-1]
+    else:
+        y = y[:-1]
+
+    final_list = []
+
+    index_in_x_last = 0
+    index_in_x_current = 0
+
+    next_y_index = 0
+    index_in_y_current = 0
+            
+    if len(z)==1:
+        index_in_x_current = np.where(x==z[0])[0][0]
+        final_list = list(x[index_in_x_last:index_in_x_current].flatten() )+ list(y[1:].flatten())+ list(x[index_in_x_current+1:].flatten())
+
+        #print(x,y,index_in_x_current,final_list)
+    else:
+        for i in range(len(z)):
+            index_in_x_current = np.where(x==z[i])[0][0]
+            index_in_y_current = np.where(y==z[i])[0][0]+1
+
+            #print(index_in_x_current,index_in_y_current,z)
+
+            if i==len(z)-1:
+                next_y_index = len(y)
+            else:
+                next_y_index = np.where(y==z[i+1])[0][0]
+
+            final_list = final_list + list(x[index_in_x_last:index_in_x_current].flatten()) + list(y[index_in_y_current:next_y_index].flatten())
+            index_in_x_last = index_in_x_current +1
+
+        final_list = final_list +list(x[index_in_x_last:].flatten())
+    final_list = np.array(final_list)
+    c = torch.from_numpy(final_list)
+    return c

TransAntivirus/download_pubchem/SARS0729_canon_desc.csv

@@ -0,0 +1,185 @@
+PubChem CID|name |Preferred|Canonical<|NumAtoms|MolWt|Log P|TPSA|HBA|HBD|Fsp3|ROTB|NumRings|AROM|NumHeavyAtom|NumStereo|QED|QEPPI|SAscore|NPscore|Lipinski|Ro4|PAINS
+290486.0|Triciribine|2-(5-amino-7-methyl-2,6,7,9,11-pentazatricyclo[6.3.1.04,12]dodeca-1(12),3,5,8,10-pentaen-2-yl)-5-(hydroxymethyl)oxolane-3,4-diol|CN1N=C(N)c2cn(C3OC(CO)C(O)C3O)c3ncnc1c23|23|320.3090000000001|-1.8870999999999987|142.25|10|4|0.46153846153846156|2|4|2|23|8|0.5030837169270522|0.2230377496655855|4.206336221285245|0.5141541547619305|1|0|False
+400633.0|Capecitabine|pentyl N-[1-(3,4-dihydroxy-5-methyloxolan-2-yl)-5-fluoro-2-oxopyrimidin-4-yl]carbamate|CCCCCOC(=O)Nc1nc(=O)n(C2OC(C)C(O)C2O)cc1F|25|359.35400000000004|0.7601999999999995|122.91000000000001|8|3|0.6666666666666666|6|2|1|25|8|0.640839151584694|0.3477485501574143|3.70159793901294|0.379648786773868|1|0|False
+1546.0|Cladribine|5-(6-amino-2-chloropurin-9-yl)-2-(hydroxymethyl)oxolan-3-ol |Nc1nc(Cl)nc2c1ncn2C1CC(O)C(CO)O1|19|285.69100000000003|-0.29740000000000044|119.31000000000002|8|3|0.5|2|3|2|19|6|0.6481668237451135|0.3813779140915048|3.622779613665122|0.7589084087510317|1|0|False
+16886.0|Decitabine|4-amino-1-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]-1,3,5-triazin-2-one|Nc1ncn(C2CC(O)C(CO)O2)c(=O)n1|16|228.20799999999997|-2.1388|123.49|8|3|0.625|2|2|1|16|6|0.5273624425093522|0.2441325945298081|3.643221050753482|1.1104565214827065|1|0|False
+3385.0|Fluorouracil (5-Fluoracil, 5-FU)|5-fluoro-1H-pyrimidine-2,4-dione|O=c1[nH]cc(F)c(=O)[nH]1|9|130.078|-0.7977000000000001|65.72|2|2|0.0|0|1|1|9|0|0.482564502908463|0.22429291396082054|2.6590876226101727|-0.7992390609873111|1|0|False
+248862.0|Nelarabine|2-(2-amino-6-methoxypurin-9-yl)-5-(hydroxymethyl)oxolane-3,4-diol|COc1nc(N)nc2c1ncn2C1OC(CO)C(O)C1O|21|297.271|-1.9713999999999994|148.76999999999998|10|4|0.5454545454545454|3|3|2|21|8|0.5056130599451503|0.23058502859583221|3.669441345268779|0.8720015392381619|1|0|False
+354624.0|Clofarabine|5-(6-amino-2-chloropurin-9-yl)-4-fluoro-2-(hydroxymethyl)oxolan-3-ol|Nc1nc(Cl)nc2c1ncn2C1OC(CO)C(O)C1F|20|303.681|-0.34940000000000027|119.31000000000002|8|3|0.5|2|3|2|20|8|0.648649936215886|0.3883700063918832|3.8712345426538963|0.6251566198496301|1|0|False
+3368.0|Fludarabine Phosphate|[5-(6-amino-2-fluoropurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methyl dihydrogen phosphate|Nc1nc(F)nc2c1ncn2C1OC(COP(=O)(O)O)C(O)C1O|24|365.21400000000006|-1.7239000000000007|186.07|10|5|0.5|4|3|2|24|8|0.30617189529250766|0.17310948790732877|3.9840913898753945|1.0864995352244873|0|0|False
+135605572.0|Entecavir Hydrate|2-amino-9-[4-hydroxy-3-(hydroxymethyl)-2-methylidenecyclopentyl]-1H-purin-6-one|C=C1C(CO)C(O)CC1n1cnc2c(=O)nc(N)[nH]c21|20|277.28399999999993|-0.8278000000000001|130.04999999999998|7|4|0.4166666666666667|2|3|2|20|6|0.5301148369563783|0.3229952345490085|4.052892286880503|0.9583882509483649|1|0|False
+2754.0|Cilostazol|6-[4-(1-cyclohexyltetrazol-5-yl)butoxy]-3,4-dihydro-1H-quinolin-2-one|O=C1CCc2cc(OCCCCc3nnnn3C3CCCCC3)ccc2N1|27|369.4690000000002|3.4647000000000014|81.93|6|1|0.6|7|4|2|27|0|0.755913406639335|0.7771342880231443|2.508630577222638|-1.5209469226199739|1|0|False
+3363.0|Floxuridine|5-fluoro-1-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidine-2,4-dione|O=c1[nH]c(=O)n(C2CC(O)C(CO)O2)cc1F|17|246.194|-1.6836|104.55000000000001|6|3|0.5555555555555556|2|2|1|17|6|0.5776171321259124|0.3356934148814366|3.473377071505359|0.6963745697774709|1|0|False
+5386.0|Tegafur (FT-207, NSC 148958)|5-fluoro-1-(oxolan-2-yl)pyrimidine-2,4-dione|O=c1[nH]c(=O)n(C2CCCO2)cc1F|14|200.16899999999998|-0.015300000000000313|64.09|4|1|0.5|1|2|1|14|2|0.6927125296086032|0.3535172217146212|2.9469611714043964|-0.4032937319470785|1|0|False
+5155.0|Stavudine (d4T)|1-[5-(hydroxymethyl)-2,5-dihydrofuran-2-yl]-5-methylpyrimidine-2,4-dione|Cc1cn(C2C=CC(CO)O2)c(=O)[nH]c1=O|16|224.21599999999998|-0.7090799999999999|84.32|5|2|0.4|2|2|1|16|4|0.6498890462135971|0.406330949617662|3.582011471393738|0.952976324214325|1|0|False
+3367.0|Fludarabine|2-(6-amino-2-fluoropurin-9-yl)-5-(hydroxymethyl)oxolane-3,4-diol|Nc1nc(F)nc2c1ncn2C1OC(CO)C(O)C1O|20|285.235|-1.8409000000000002|139.54000000000002|9|4|0.5|2|3|2|20|8|0.47183364718578485|0.24118104715477695|3.742329367828722|1.06082713921308|1|0|False
+5281078.0|Mycophenolate Mofetil|2-morpholin-4-ylethyl (E)-6-(4-hydroxy-6-methoxy-7-methyl-3-oxo-1H-2-benzofuran-5-yl)-4-methylhex-4-enoate|COc1c(C)c2c(c(O)c1CC=C(C)CCC(=O)OCCN1CCOCC1)C(=O)OC2|31|433.5010000000003|2.52402|94.53000000000002|8|1|0.5652173913043478|9|3|1|31|0|0.46901748000616883|0.37568520022091145|2.909809273894176|0.7259426339747483|1|0|False
+191.0|Adenosine|2-(6-aminopurin-9-yl)-5-(hydroxymethyl)oxolane-3,4-diol|Nc1ncnc2c1ncn2C1OC(CO)C(O)C1O|19|267.245|-1.9800000000000006|139.54000000000002|9|4|0.5|2|3|2|19|8|0.49051986767922323|0.23617270345702296|3.5313095881349117|1.3138998457117157|1|0|False
+1134.0|Telbivudine|1-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]-5-methylpyrimidine-2,4-dione|Cc1cn(C2CC(O)C(CO)O2)c(=O)[nH]c1=O|17|242.23099999999997|-1.5142799999999992|104.54999999999998|6|3|0.6|2|2|1|17|6|0.5842742137821719|0.33499679157314843|3.3763667036123843|1.0380300294610116|1|0|False
+135422442.0|Didanosine|9-[5-(hydroxymethyl)oxolan-2-yl]-1H-purin-6-one|O=c1[nH]cnc2c1ncn2C1CCC(CO)O1|17|236.23099999999997|-0.21050000000000008|93.03|6|2|0.5|2|3|2|17|4|0.7521450742487874|0.5432250422691189|3.611021286177671|0.6773893007177353|1|0|False
+9837769.0|Emtricitabine|4-amino-5-fluoro-1-[2-(hydroxymethyl)-1,3-oxathiolan-5-yl]pyrimidin-2-one|Nc1nc(=O)n(C2CSC(CO)O2)cc1F|16|247.25099999999998|-0.4550000000000003|90.37|7|2|0.5|2|2|1|16|4|0.7349748054075844|0.3453875663184652|3.8873632196454855|0.6995396761378563|1|0|False
+3387.0|Lamivudine|4-amino-1-[2-(hydroxymethyl)-1,3-oxathiolan-5-yl]pyrimidin-2-one|Nc1ccn(C2CSC(CO)O2)c(=O)n1|15|229.261|-0.5941000000000001|90.36999999999999|7|2|0.5|2|2|1|15|4|0.7038615838122525|0.3378624805129178|3.8064405703937787|1.4615989713898194|1|0|False
+3461.0|Gemcitabine|4-amino-1-[3,3-difluoro-4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidin-2-one|Nc1ccn(C2OC(CO)C(O)C2(F)F)c(=O)n1|18|263.2|-1.2886|110.60000000000001|7|3|0.5555555555555556|2|2|1|18|6|0.6120873727300361|0.30156266317008307|3.8632725293690937|1.2986545260508495|1|0|False
+5718.0|Zalcitabine|4-amino-1-[5-(hydroxymethyl)oxolan-2-yl]pyrimidin-2-one|Nc1ccn(C2CCC(CO)O2)c(=O)n1|15|211.22099999999998|-0.5046000000000002|90.36999999999999|6|2|0.5555555555555556|2|2|1|15|4|0.6875458801290977|0.3738843645665796|3.417990020943229|1.2753722241588197|1|0|False
+4463.0|Nevirapine|2-cyclopropyl-7-methyl-2,4,9,15-tetrazatricyclo[9.4.0.03,8]pentadeca-1(11),3,5,7,12,14-hexaen-10-one|Cc1ccnc2c1NC(=O)c1cccnc1N2C1CC1|20|266.30400000000003|2.6512200000000004|58.120000000000005|4|1|0.26666666666666666|1|4|2|20|0|0.861716125086419|0.5536172692074276|2.5944323945817214|-0.24728332568993|1|0|False
+253083.0|Trifluridine|1-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]-5-(trifluoromethyl)pyrimidine-2,4-dione|O=c1[nH]c(=O)n(C2CC(O)C(CO)O2)cc1C(F)(F)F|20|296.20099999999996|-0.8039000000000001|104.55000000000001|6|3|0.6|2|2|1|20|6|0.6622919739385443|0.35932251164721696|3.6118403697410404|0.4994653045681|1|0|False
+1805.0|Azacitidine|4-amino-1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]-1,3,5-triazin-2-one|Nc1ncn(C2OC(CO)C(O)C2O)c(=O)n1|17|244.207|-3.1679999999999997|143.72000000000003|9|4|0.625|2|2|1|17|8|0.4262474653048269|0.16004433948003915|3.687407323630228|1.3188208399256056|1|0|False
+191.0|Vidarabine|2-(6-aminopurin-9-yl)-5-(hydroxymethyl)oxolane-3,4-diol|Nc1ncnc2c1ncn2C1OC(CO)C(O)C1O|19|267.245|-1.9800000000000006|139.54000000000002|9|4|0.5|2|3|2|19|8|0.49051986767922323|0.23617270345702296|3.5313095881349117|1.3138998457117157|1|0|False
+266934.0|AICAR (Acadesine)|5-amino-1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]imidazole-4-carboxamide|NC(=O)c1ncn(C2OC(CO)C(O)C2O)c1N|18|258.23400000000004|-2.8242999999999996|156.85000000000002|8|5|0.5555555555555556|3|2|1|18|8|0.3908498923708794|0.14438999553237833|3.7095421627648637|0.8286879931867945|0|0|False
+135398513.0|Aciclovir|2-amino-9-(2-hydroxyethoxymethyl)-1H-purin-6-one|Nc1nc2c(ncn2COCCO)c(=O)[nH]1|16|225.20799999999997|-1.3318000000000003|119.04999999999998|7|3|0.375|4|2|2|16|0|0.554385971786765|0.45613595294095116|2.7707884753483327|-0.10317179830629376|1|0|False
+135398740.0|Ganciclovir|2-amino-9-(1,3-dihydroxypropan-2-yloxymethyl)-1H-purin-6-one|Nc1nc2c(ncn2COC(CO)CO)c(=O)[nH]1|18|255.23399999999998|-1.970899999999999|139.28|8|4|0.4444444444444444|5|2|2|18|0|0.4854930576221492|0.30914081370444985|2.9975492721457613|0.3788503786253501|1|0|False
+3687.0|Idoxuridine|1-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]-5-iodopyrimidine-2,4-dione|O=c1[nH]c(=O)n(C2CC(O)C(CO)O2)cc1I|17|354.1|-1.2181000000000002|104.55000000000001|6|3|0.5555555555555556|2|2|1|17|6|0.578029884636738|0.3781134158688138|3.6278549979267645|0.910464343233765|1|0|False
+3657.0|Hydroxyurea|hydroxyurea|NC(=O)NO|5|76.05499999999999|-0.9561000000000002|75.35000000000001|2|3|0.0|0|0|0|5|0|0.25664360627911675|0.1190984427030672|2.5247164941764755|-0.31540413797906003|1|0|False
+279063.0|Cyclocytidine HCl|4-(hydroxymethyl)-10-imino-3,7-dioxa-1,9-diazatricyclo[6.4.0.02,6]dodeca-8,11-dien-5-ol|N=c1ccn2c(n1)OC1C(O)C(CO)OC12|16|225.204|-1.62583|100.59000000000002|7|3|0.5555555555555556|1|3|1|16|8|0.5326902884382276|0.27411721766208946|4.446202327505897|1.497338959013144|1|0|False
+1177.0|Uridine|1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidine-2,4-dione|O=c1ccn(C2OC(CO)C(O)C2O)c(=O)[nH]1|17|244.20300000000003|-2.8519|124.78|7|4|0.5555555555555556|2|2|1|17|8|0.4435105912731592|0.21867146597756254|3.4839049824931045|1.4898002285532645|1|0|False
+3159.0|Doxifluridine|1-(3,4-dihydroxy-5-methyloxolan-2-yl)-5-fluoropyrimidine-2,4-dione|CC1OC(n2cc(F)c(=O)[nH]c2=O)C(O)C1O|17|246.19400000000002|-1.6851999999999996|104.55000000000001|6|3|0.5555555555555556|1|2|1|17|8|0.5484019207554993|0.3126320658718193|3.610332741690428|0.7868512061868354|1|0|False
+596.0|Cytidine|4-amino-1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidin-2-one|Nc1ccn(C2OC(CO)C(O)C2O)c(=O)n1|17|243.21900000000002|-2.563|130.82999999999998|8|4|0.5555555555555556|2|2|1|17|8|0.4489304892314893|0.18860344125062514|3.548894614600127|1.6478124261033116|1|0|False
+2691.0|CGS 21680 HCl|3-[4-[2-[[6-amino-9-[5-(ethylcarbamoyl)-3,4-dihydroxyoxolan-2-yl]purin-2-yl]amino]ethyl]phenyl]propanoic acid|CCNC(=O)C1OC(n2cnc3c(N)nc(NCCc4ccc(CCC(=O)O)cc4)nc32)C(O)C1O|36|499.52800000000025|-0.16439999999999827|197.73999999999995|11|6|0.43478260869565216|10|4|3|36|8|0.21654103037466466|0.1239959413009151|3.773892423920943|0.05996866085087501|0|0|False
+135402034.0|Guanosine|2-amino-9-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]-1H-purin-6-one|Nc1nc2c(ncn2C2OC(CO)C(O)C2O)c(=O)[nH]1|20|283.24399999999997|-2.6867000000000005|159.51|9|5|0.5|2|3|2|20|8|0.3981374161148042|0.16955766100498496|3.720175521674877|1.2488959303664646|0|0|False
+135402037.0|Inosine|9-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]-1H-purin-6-one|O=c1[nH]cnc2c1ncn2C1OC(CO)C(O)C1O|19|268.229|-2.2689|133.49|8|4|0.5|2|3|2|19|8|0.4822946675996651|0.27226976952981763|3.7484460177430403|1.1878722340647632|1|0|False
+5064.0|Ribavirin|1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]-1,2,4-triazole-3-carboxamide|NC(=O)c1ncn(C2OC(CO)C(O)C2O)n1|17|244.20700000000002|-3.0114999999999994|143.72000000000003|8|4|0.625|3|2|1|17|8|0.44284203167437103|0.19640354038822913|3.8687708687807296|0.6906384280796763|1|0|False
+5726.0|Zidovudine|1-[4-azido-5-(hydroxymethyl)oxolan-2-yl]-5-methylpyrimidine-2,4-dione|Cc1cn(C2CC(N=[N+]=[N-])C(CO)O2)c(=O)[nH]c1=O|19|267.245|-0.19628000000000012|133.07999999999998|6|2|0.6|3|2|1|19|6|0.4454004294146897|0.3925697774093064|3.849317511398737|0.8935864361663792|1|0|True
+91302628.0|Sofosbuvir (PSI-7977, GS-7977)|propan-2-yl 2-[[[5-(2,4-dioxopyrimidin-1-yl)-4-fluoro-3-hydroxy-4-methyloxolan-2-yl]methoxy-phenoxyphosphoryl]amino]propanoate|CC(C)OC(=O)C(C)NP(=O)(OCC1OC(n2ccc(=O)[nH]c2=O)C(C)(F)C1O)Oc1ccccc1|36|529.4580000000002|1.6565000000000003|158.17999999999995|10|3|0.5|10|3|2|36|12|0.30528322976796235|0.29165853488216725|4.375073076955571|0.24310435922934737|0|0|False
+214347.0|Dapivirine (TMC120)|4-[[4-(2,4,6-trimethylanilino)pyrimidin-2-yl]amino]benzonitrile|Cc1cc(C)c(Nc2ccnc(Nc3ccc(C#N)cc3)n2)c(C)c1|25|329.4070000000001|4.760740000000003|73.63|5|2|0.15|4|3|3|25|0|0.7216163650237382|0.8678943244497731|2.2542436522113114|-1.5749294902855966|1|0|False
+352992.0|Clevudine|1-[3-fluoro-4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]-5-methylpyrimidine-2,4-dione|Cc1cn(C2OC(CO)C(O)C2F)c(=O)[nH]c1=O|18|260.221|-1.5662799999999997|104.54999999999998|6|3|0.6|2|2|1|18|8|0.5958623283349754|0.3413235419835224|3.6783565858417866|0.7867064816243999|1|0|False
+193962.0|Etravirine (TMC125)|4-[6-amino-5-bromo-2-(4-cyanoanilino)pyrimidin-4-yl]oxy-3,5-dimethylbenzonitrile|Cc1cc(C#N)cc(C)c1Oc1nc(Nc2ccc(C#N)cc2)nc(N)c1Br|28|435.2850000000001|4.717400000000002|120.63999999999999|7|2|0.1|4|3|3|28|0|0.6084537970432328|0.7274550650547328|2.701548964781006|-1.0535754913840394|1|0|False
+1869.0|N6-methyladenosine (m6A)|2-(hydroxymethyl)-5-[6-(methylamino)purin-9-yl]oxolane-3,4-diol|CNc1ncnc2c1ncn2C1OC(CO)C(O)C1O|20|281.272|-1.5205000000000009|125.55000000000001|9|4|0.5454545454545454|3|3|2|20|8|0.5342275014319904|0.2703216790234994|3.6073528343621897|1.041930725635605|1|0|False
+248010.0|Cordycepin|2-(6-aminopurin-9-yl)-5-(hydroxymethyl)oxolan-3-ol|Nc1ncnc2c1ncn2C1OC(CO)CC1O|18|251.24599999999998|-0.9508000000000008|119.31000000000002|8|3|0.5|2|3|2|18|6|0.628993302830891|0.36275129625779995|3.6322713415862893|1.3733080654408107|1|0|False
+4602.0|Osalmid|2-hydroxy-N-(4-hydroxyphenyl)benzamide|O=C(Nc1ccc(O)cc1)c1ccccc1O|17|229.23499999999999|2.3501000000000007|69.56|3|3|0.0|2|2|2|17|0|0.6921374334367943|0.46153746799921075|1.5130819664559425|-0.744133777598706|1|0|False
+9679.0|4-Amino-5-imidazolecarboxamide|4-amino-1H-imidazole-5-carboxamide|NC(=O)c1nc[nH]c1N|9|126.119|-0.9092000000000005|97.79|3|3|0.0|1|1|1|9|0|0.4539721011557528|0.2552272944309776|2.9954741610717104|-0.5140951039502445|1|0|False
+135402019.0|2'-Deoxyinosine| 9-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]-1H-purin-6-one|O=c1[nH]cnc2c1ncn2C1CC(O)C(CO)O1|18|252.23|-1.2397000000000002|113.26|7|3|0.5|2|3|2|18|6|0.6158237953049276|0.4186149308280351|3.709847812174523|0.9179637393863056|1|0|False
+72830388.0|Valganciclovir HCl|[2-[(2-amino-6-oxo-4,5-dihydro-1H-purin-9-yl)methoxy]-3-hydroxypropyl] 2-amino-3-methylbutanoate|CC(C)C(N)C(=O)OCC(CO)OCN1C=NC2C(=O)NC(N)=NC21|25|356.38300000000004|-2.668999999999996|164.86|10|4|0.7142857142857143|8|2|0|25|8|0.3418489997940892|0.10362369303515996|4.612915133583076|0.8576886024449053|0|0|False
+135398748.0|Penciclovir|2-amino-9-[4-hydroxy-3-(hydroxymethyl)butyl]-1H-purin-6-one|Nc1nc(=O)c2ncn(CCC(CO)CO)c2[nH]1|18|253.26199999999997|-1.3073|130.05|7|4|0.5|5|2|2|18|0|0.5232780259906572|0.36417216397814534|2.885575425991915|-0.025008256510316646|1|0|False
+135403646.0|Azaguanine-8|5-amino-2,6-dihydrotriazolo[4,5-d]pyrimidin-7-one|Nc1nc2[nH]nnc2c(=O)[nH]1|11|152.11700000000002|-1.3766000000000003|113.34|5|3|0.0|0|2|2|11|0|0.4303161239320503|0.4073247679104095|3.506466837537925|-0.6790146471510455|1|0|False
+22138239.0|Ademetionine disulfate tosylate|2-amino-4-[[5-(6-aminopurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methyl-methylsulfonio]butanoate|C[S+](CCC(N)C(=O)[O-])CC1OC(n2cnc3c(N)ncnc32)C(O)C1O|27|398.4450000000001|-3.256899999999996|185.45999999999998|11|4|0.6|7|3|2|27|12|0.34496993620130295|0.2235483545193125|4.7565494434378035|0.9079142947079224|0|0|False
+3203.0|Efavirenz|6-chloro-4-(2-cyclopropylethynyl)-4-(trifluoromethyl)-1H-3,1-benzoxazin-2-one|O=C1Nc2ccc(Cl)cc2C(C#CC2CC2)(C(F)(F)F)O1|21|315.67799999999994|4.073100000000001|38.33|2|1|0.35714285714285715|0|3|1|21|2|0.7328090954055055|0.2532354094918868|3.5657078249547665|0.06666647788737144|1|0|False
+72661.0|Nicotinamide N-oxide|1-oxidopyridin-1-ium-3-carboxamide|NC(=O)c1ccc[n+]([O-])c1|10|138.12599999999998|-0.5811|70.03|2|1|0.0|1|1|1|10|0|0.4162538873709143|0.23477866525463617|2.587100135906283|-1.3023827034912496|1|0|False
+1134.0|Thymidine|1-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]-5-methylpyrimidine-2,4-dione|Cc1cn(C2CC(O)C(CO)O2)c(=O)[nH]c1=O|17|242.23099999999997|-1.5142799999999992|104.54999999999998|6|3|0.6|2|2|1|17|6|0.5842742137821719|0.33499679157314843|3.3763667036123843|1.0380300294610116|1|0|False
+1177.0|Uracil 1-?-D-arabinofuranoside|1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidine-2,4-dione|O=c1ccn(C2OC(CO)C(O)C2O)c(=O)[nH]1|17|244.20300000000003|-2.8519|124.78|7|4|0.5555555555555556|2|2|1|17|8|0.4435105912731592|0.21867146597756254|3.4839049824931045|1.4898002285532645|1|0|False
+98961.0|2,2'-Cyclouridine|5-hydroxy-4-(hydroxymethyl)-3,7-dioxa-1,9-diazatricyclo[6.4.0.02,6]dodeca-8,11-dien-10-one|O=c1ccn2c(n1)OC1C(O)C(CO)OC12|16|226.18800000000002|-1.7451000000000005|93.81000000000002|7|2|0.5555555555555556|1|3|1|16|8|0.589765502233582|0.30625756971028406|4.082753096736665|1.3490016836473129|1|0|False
+5353599.0|Brivudine|5-[(E)-2-bromoethenyl]-1-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidine-2,4-dione|O=c1[nH]c(=O)n(C2CC(O)C(CO)O2)cc1C=CBr|19|333.13800000000003|-0.45710000000000006|104.55000000000001|6|3|0.45454545454545453|3|2|1|19|6|0.6945612204028229|0.40567778230739426|3.850417215540748|1.1374943613292103|1|0|False
+23700083.0|Ganciclovir sodium|2-amino-9-(1,3-dihydroxypropan-2-yloxymethyl)purin-6-olate|Nc1nc([O-])c2ncn(COC(CO)CO)c2n1|18|254.22599999999997|-2.1905999999999994|142.37|9|3|0.4444444444444444|5|2|2|18|0|0.545640459838781|0.34612172025925764|3.4886751182996063|0.03842276244240006|1|0|False
+5136.0|Ademetionine|2-amino-4-[[5-(6-aminopurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methyl-methylsulfonio]butanoate|C[S+](CCC(N)C(=O)[O-])CC1OC(n2cnc3c(N)ncnc32)C(O)C1O|27|398.4450000000001|-3.256899999999996|185.45999999999998|11|4|0.6|7|3|2|27|12|0.34496993620130295|0.2235483545193125|4.7565494434378035|0.9079142947079224|0|0|False
+1971.0|Abacavir|[4-[2-amino-6-(cyclopropylamino)purin-9-yl]cyclopent-2-en-1-yl]methanol|Nc1nc(NC2CC2)c2ncn(C3C=CC(CO)C3)c2n1|21|286.33900000000006|1.0922999999999998|101.88|7|3|0.5|4|4|2|21|4|0.7272302824304794|0.532844209200051|3.688999973120933|0.026597937866581003|1|0|False
+135605572.0|Entecavir|2-amino-9-[4-hydroxy-3-(hydroxymethyl)-2-methylidenecyclopentyl]-1H-purin-6-one|C=C1C(CO)C(O)CC1n1cnc2c(=O)nc(N)[nH]c21|20|277.28399999999993|-0.8278000000000001|130.04999999999998|7|4|0.4166666666666667|2|3|2|20|6|0.5301148369563783|0.3229952345490085|4.052892286880503|0.9583882509483649|1|0|False
+224.0|Adenosine 5'-monophosphate monohydrate|[5-(6-aminopurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methyl dihydrogen phosphate|Nc1ncnc2c1ncn2C1OC(COP(=O)(O)O)C(O)C1O|23|347.224|-1.8630000000000009|186.07|10|5|0.5|4|3|2|23|8|0.39017854457244017|0.17004544392240475|3.8048894493072236|1.2966757882455953|0|0|False
+191.0|Vidarabine monohydrate|2-(6-aminopurin-9-yl)-5-(hydroxymethyl)oxolane-3,4-diol|Nc1ncnc2c1ncn2C1OC(CO)C(O)C1O|19|267.245|-1.9800000000000006|139.54000000000002|9|4|0.5|2|3|2|19|8|0.49051986767922323|0.23617270345702296|3.5313095881349117|1.3138998457117157|1|0|False
+44399265.0|PSI-6206 (RO-2433, GS-331007)|1-[3-fluoro-4-hydroxy-5-(hydroxymethyl)-3-methyloxolan-2-yl]pyrimidine-2,4-dione|CC1(F)C(O)C(CO)OC1n1ccc(=O)[nH]c1=O|18|260.221|-1.4846000000000001|104.54999999999998|6|3|0.6|2|2|1|18|8|0.6009771935170747|0.3417002787027479|3.9142777396879405|1.009482945923539|1|0|False
+22451303.0|Regadenoson|1-[6-amino-9-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]purin-2-yl]-N-methylpyrazole-4-carboxamide|CNC(=O)c1cnn(-c2nc(N)c3ncn(C4OC(CO)C(O)C4O)c3n2)c1|28|390.36000000000007|-2.4346999999999985|186.45999999999998|12|5|0.4|4|4|3|28|8|0.32033113268604546|0.16974155969442686|3.8655802133882755|-0.1474028333819392|0|0|False
+56640146.0|Dasabuvir(ABT-333)|N-[6-[3-tert-butyl-5-(2,4-dioxopyrimidin-1-yl)-2-methoxyphenyl]naphthalen-2-yl]methanesulfonamide|COc1c(-c2ccc3cc(NS(C)(=O)=O)ccc3c2)cc(-n2ccc(=O)[nH]c2=O)cc1C(C)(C)C|35|493.58500000000026|4.023600000000002|110.25999999999999|6|2|0.23076923076923078|5|4|4|35|0|0.4363022246167922|0.771847321512829|2.7135256012508666|-0.6786278979178144|1|1|False
+4483256.0|Cimicifugoside|[2-hydroxy-1,4',6',12',17',17'-hexamethyl-18'-(3,4,5-trihydroxyoxan-2-yl)oxyspiro[3,6-dioxabicyclo[3.1.0]hexane-4,8'-9-oxahexacyclo[11.9.0.01,21.04,12.05,10.016,21]docos-13-ene]-3'-yl] acetate|CC(=O)OC1CC23CC24CCC(OC2OCC(O)C(O)C2O)C(C)(C)C4CC=C3C2(C)CC3OC4(CC(C)C3C12C)OC(O)C1(C)OC41|48|674.8280000000003|2.9487000000000005|156.67000000000002|11|4|0.918918918918919|3|9|0|48|36|0.1983763747315937|0.09644092817770795|7.190522840793108|3.4998626023441517|0|0|False
+640.0|2’-deoxyuridine|1-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidine-2,4-dione|O=c1ccn(C2CC(O)C(CO)O2)c(=O)[nH]1|16|228.20399999999998|-1.8226999999999993|104.55000000000001|6|3|0.5555555555555556|2|2|1|16|6|0.552382719533219|0.32881089343575925|3.4575535682360012|1.247112165436718|1|0|False
+596.0|Cytarabine hydrochloride|4-amino-1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidin-2-one|Nc1ccn(C2OC(CO)C(O)C2O)c(=O)n1|17|243.21900000000002|-2.563|130.82999999999998|8|4|0.5555555555555556|2|2|1|17|8|0.4489304892314893|0.18860344125062514|3.548894614600127|1.6478124261033116|1|0|False
+5375662.0|trans-Zeatin-riboside|2-(hydroxymethyl)-5-[6-[[(E)-4-hydroxy-3-methylbut-2-enyl]amino]purin-9-yl]oxolane-3,4-diol|CC(=CCNc1ncnc2c1ncn2C1OC(CO)C(O)C1O)CO|25|351.36300000000006|-1.2117|145.78|10|5|0.5333333333333333|6|3|2|25|8|0.40449115551681625|0.20327430040647024|3.9559301432792626|1.339358707119148|1|0|False
+1835.0|5-Methyl-2'-deoxycytidine|4-amino-1-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]-5-methylpyrimidin-2-one|Cc1cn(C2CC(O)C(CO)O2)c(=O)nc1N|17|241.24699999999996|-1.2253799999999995|110.6|7|3|0.6|2|2|1|17|6|0.5979214123745736|0.29479101867497837|3.566450315652517|1.1019204230282296|1|0|False
+53398647.0|Cytidine 5?-triphosphate (disodium salt)|[[[5-(4-amino-2-oxopyrimidin-1-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-hydroxyphosphoryl]oxy-oxidophosphoryl] hydrogen phosphate |Nc1ccn(C2OC(COP(=O)(O)OP(=O)([O-])OP(=O)([O-])O)C(O)C2O)c(=O)n1|29|481.14000000000016|-3.4759999999999986|276.0799999999999|15|5|0.5555555555555556|8|2|1|29|14|0.22541264416469642|0.1419968753465064|5.071692352902783|1.1942632211265276|0|0|False
+262543.0|5-Methylcytidine|4-amino-1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]-5-methylpyrimidin-2-one|Cc1cn(C2OC(CO)C(O)C2O)c(=O)nc1N|18|257.246|-2.2545799999999994|130.83|8|4|0.6|2|2|1|18|8|0.4701900203991378|0.19188032083627155|3.6185412012264013|1.2991831736939943|1|0|False
+249989.0|5-Methyluridine|1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]-5-methylpyrimidine-2,4-dione|Cc1cn(C2OC(CO)C(O)C2O)c(=O)[nH]c1=O|18|258.23|-2.5434799999999993|124.78|7|4|0.6|2|2|1|18|8|0.4628801121855684|0.22236210404580592|3.4482133166110174|1.2290593987107328|1|0|False
+13401.0|3-Hydroxypicolinic acid|3-hydroxypyridine-2-carboxylic acid|O=C(O)c1ncccc1O|10|139.10999999999999|0.4853999999999999|70.42|3|2|0.0|1|1|1|10|0|0.5933874162122502|0.298934256110774|2.01811039231654|-0.41014214009500005|1|0|False
+4349538.0|NADH, disodium salt hydrate|[[5-(6-aminopurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-oxidophosphoryl] [5-(3-carbamoyl-4H-pyridin-1-yl)-3,4-dihydroxyoxolan-2-yl]methyl phosphate|NC(=O)C1=CN(C2OC(COP(=O)([O-])OP(=O)([O-])OCC3OC(n4cnc5c(N)ncnc54)C(O)C3O)C(O)C2O)C=CC1|44|663.4300000000004|-3.950399999999993|323.2800000000001|20|6|0.5238095238095238|11|5|2|44|20|0.12490354999455602|0.11711205769249591|5.678699754875055|0.6523253136204249|0|0|False
+5625.0|Delavirdine (mesylate)|N-[2-[4-[3-(propan-2-ylamino)pyridin-2-yl]piperazine-1-carbonyl]-1H-indol-5-yl]methanesulfonamide|CC(C)Nc1cccnc1N1CCN(C(=O)c2cc3cc(NS(C)(=O)=O)ccc3[nH]2)CC1|32|456.5720000000002|2.7171000000000003|110.43|6|3|0.36363636363636365|6|4|3|32|0|0.5260863337385334|0.7849383937725847|2.5284878962420905|-1.7469754852284307|1|0|False
+254731.0|uridine triacetate|[3,4-diacetyloxy-5-(2,4-dioxopyrimidin-1-yl)oxolan-2-yl]methyl acetate|CC(=O)OCC1OC(n2ccc(=O)[nH]c2=O)C(OC(C)=O)C1OC(C)=O|26|370.31400000000014|-1.1394999999999988|142.99|10|1|0.5333333333333333|5|2|1|26|8|0.5022752412372868|0.27310239595191593|3.644050594368478|1.1717654190198035|0|0|False
+58460047.0|Doravirine (MK-1439)|3-chloro-5-[1-[(4-methyl-5-oxo-1H-1,2,4-triazol-3-yl)methyl]-2-oxo-4-(trifluoromethyl)pyridin-3-yl]oxybenzonitrile|Cn1c(Cn2ccc(C(F)(F)F)c(Oc3cc(Cl)cc(C#N)c3)c2=O)n[nH]c1=O|29|425.7540000000001|2.654580000000001|105.69999999999999|7|1|0.17647058823529413|4|3|3|29|0|0.6914051268589833|0.7336281656644693|3.0219252915309625|-1.6455219788390623|1|0|False
+76450047.0|SGC 0946|1-[3-[[5-(4-amino-5-bromopyrrolo[2,3-d]pyrimidin-7-yl)-3,4-dihydroxyoxolan-2-yl]methyl-propan-2-ylamino]propyl]-3-(4-tert-butylphenyl)urea|CC(C)N(CCCNC(=O)Nc1ccc(C(C)(C)C)cc1)CC1OC(n2cc(Br)c3c(N)ncnc32)C(O)C1O|40|618.5770000000002|3.614900000000002|150.79|9|5|0.5357142857142857|9|4|3|40|8|0.22841744599826647|0.22982258021111773|4.078247297329462|-0.7007523337719948|0|0|False
+328839.0|Zebularine|1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidin-2-one|O=c1ncccn1C1OC(CO)C(O)C1O|16|228.204|-2.1451999999999996|104.81000000000002|7|3|0.5555555555555556|2|2|1|16|8|0.5330176479739586|0.29115142413250616|3.5563030967366647|0.9772741509174374|1|0|False
+6451164.0|Rilpivirine|4-[[4-[4-[(E)-2-cyanoethenyl]-2,6-dimethylanilino]pyrimidin-2-yl]amino]benzonitrile|Cc1cc(C=CC#N)cc(C)c1Nc1ccnc(Nc2ccc(C#N)cc2)n1|28|366.4280000000001|4.989100000000003|97.42|6|2|0.09090909090909091|5|3|3|28|0|0.6174794624332792|0.8431090497228149|2.682510236970355|-1.1293515643212821|1|0|False
+76450046.0|EPZ004777|1-[3-[[5-(4-aminopyrrolo[2,3-d]pyrimidin-7-yl)-3,4-dihydroxyoxolan-2-yl]methyl-propan-2-ylamino]propyl]-3-(4-tert-butylphenyl)urea|CC(C)N(CCCNC(=O)Nc1ccc(C(C)(C)C)cc1)CC1OC(n2ccc3c(N)ncnc32)C(O)C1O|39|539.6810000000004|2.8524000000000007|150.79|9|5|0.5357142857142857|9|4|3|39|8|0.26053822184509995|0.24195225681633897|3.956960961496261|-0.6697887882081127|0|0|False
+4984.0|Puromycin 2HCl|2-amino-N-[5-[6-(dimethylamino)purin-9-yl]-4-hydroxy-2-(hydroxymethyl)oxolan-3-yl]-3-(4-methoxyphenyl)propanamide|COc1ccc(CC(N)C(=O)NC2C(CO)OC(n3cnc4c(N(C)C)ncnc43)C2O)cc1|34|471.5180000000002|-0.7936999999999972|160.88|11|4|0.45454545454545453|8|4|3|34|10|0.32750374532544374|0.2740730496068429|3.938746143561504|0.4059082870695618|0|0|False
+5468049.0|Triapine|[(Z)-(3-aminopyridin-2-yl)methylideneamino]thiourea|NC(=S)NN=Cc1ncccc1N|13|195.251|-0.16910000000000014|89.32|4|3|0.0|2|1|1|13|0|0.3461858313292753|0.3468357875734713|2.880743596162672|-1.803547330412908|1|0|False
+74405855.0|VER155008|4-[[5-[6-amino-8-[(3,4-dichlorophenyl)methylamino]purin-9-yl]-3,4-dihydroxyoxolan-2-yl]methoxymethyl]benzonitrile|N#Cc1ccc(COCC2OC(n3c(NCc4ccc(Cl)c(Cl)c4)nc4c(N)ncnc43)C(O)C2O)cc1|38|556.4100000000003|3.0350800000000007|164.35999999999999|11|4|0.28|8|5|4|38|8|0.2535931056491399|0.25407821914119455|3.881323921608492|-0.48547704742053677|0|0|False
+3032861.0|6-Thio-dG|2-amino-9-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]-3H-purine-6-thione|Nc1nc(=S)c2ncn(C3CC(O)C(CO)O3)c2[nH]1|19|283.313|-0.28821000000000024|122.21000000000001|8|4|0.5|2|3|2|19|6|0.5585666589379309|0.29376434618526803|3.8831343306462536|0.7695013335480106|1|0|False
+23712387.0|8-Bromo-cAMP|6-(6-amino-8-bromopurin-9-yl)-2-oxido-2-oxo-4a,6,7,7a-tetrahydro-4H-furo[3,2-d][1,3,2]dioxaphosphinin-7-ol|Nc1ncnc2c1nc(Br)n2C1OC2COP(=O)([O-])OC2C1O|23|407.0970000000001|-0.6869000000000003|157.67|11|2|0.5|1|4|2|23|10|0.4580747351009518|0.28611028834400404|4.886716744658878|0.5502166703091175|0|0|False
+16760396.0|Dibutyryl-cAMP (Bucladesine)|[6-[6-(butanoylamino)purin-9-yl]-2-oxido-2-oxo-4a,6,7,7a-tetrahydro-4H-furo[3,2-d][1,3,2]dioxaphosphinin-7-yl] butanoate|CCCC(=O)Nc1ncnc2c1ncn2C1OC2COP(=O)([O-])OC2C1OC(=O)CCC|32|468.3830000000003|1.057999999999999|166.82|12|1|0.6111111111111112|7|4|2|32|10|0.45563025867212836|0.35203094284843184|4.558877319850212|0.39303810441434994|0|0|False
+236184.0|Bromodeoxyuridine (BrdU)|5-bromo-1-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidine-2,4-dione|O=c1[nH]c(=O)n(C2CC(O)C(CO)O2)cc1Br|17|307.1|-1.0602|104.55000000000001|6|3|0.5555555555555556|2|2|1|17|6|0.6458903815058055|0.3614417237796252|3.5611586768565298|0.865449848697765|1|0|False
+409805.0|NSC 23766|6-N-[2-[5-(diethylamino)pentan-2-ylamino]-6-methylpyrimidin-4-yl]-2-methylquinoline-4,6-diamine|CCN(CC)CCCC(C)Nc1nc(C)cc(Nc2ccc3nc(C)cc(N)c3c2)n1|31|421.5930000000002|4.889840000000003|91.99|7|3|0.4583333333333333|10|3|3|31|2|0.42909503459369336|0.5500110053919122|3.111060885927593|-1.299117956324184|1|0|False
+5604.0|Tubercidin|2-(4-aminopyrrolo[2,3-d]pyrimidin-7-yl)-5-(hydroxymethyl)oxolane-3,4-diol|Nc1ncnc2c1ccn2C1OC(CO)C(O)C1O|19|266.25699999999995|-1.3750000000000007|126.65|8|4|0.45454545454545453|2|3|2|19|8|0.5275658981283201|0.2793960532890429|3.649636728918657|1.0957341600283055|1|0|False
+5270.0|SQ22536|9-(oxolan-2-yl)purin-6-amine|Nc1ncnc2c1ncn2C1CCCO1|15|205.22099999999995|0.7174999999999998|78.85000000000001|6|1|0.4444444444444444|1|3|2|15|2|0.7415418091420238|0.5011659803359577|2.957435140772226|0.09555946645130006|1|0|False
+1830.0|5-Iodotubercidin|2-(4-amino-5-iodopyrrolo[2,3-d]pyrimidin-7-yl)-5-(hydroxymethyl)oxolane-3,4-diol|Nc1ncnc2c1c(I)cn2C1OC(CO)C(O)C1O|20|392.1530000000001|-0.7703999999999998|126.65|8|4|0.45454545454545453|2|3|2|20|8|0.4946949398053289|0.31898773411320597|3.8417019552413096|0.9361303704689201|1|0|False
+137795344.0|LLY-284|2-(4-aminopyrrolo[2,3-d]pyrimidin-7-yl)-5-[hydroxy(phenyl)methyl]oxolane-3,4-diol|Nc1ncnc2c1ccn2C1OC(C(O)c2ccccc2)C(O)C1O|25|342.355|0.3663000000000001|126.65|8|4|0.29411764705882354|3|4|3|25|10|0.5413254255627207|0.37218328519283805|3.804013205830268|0.7875002540522721|1|0|False
+22608122.0|A-317491|5-[(3-phenoxyphenyl)methyl-(1,2,3,4-tetrahydronaphthalen-1-yl)carbamoyl]benzene-1,2,4-tricarboxylic acid|O=C(O)c1cc(C(=O)O)c(C(=O)N(Cc2cccc(Oc3ccccc3)c2)C2CCCc3ccccc32)cc1C(=O)O|42|565.5780000000003|6.293500000000005|141.43999999999997|5|3|0.15151515151515152|9|5|4|42|2|0.21488624386430227|0.5815074358568025|3.049057713232612|-0.6471647529123546|0|1|False
+135402018.0|2'-Deoxyguanosine monohydrate|2-amino-9-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]-1H-purin-6-one|Nc1nc2c(ncn2C2CC(O)C(CO)O2)c(=O)[nH]1|19|267.24499999999995|-1.6575000000000002|139.28|8|4|0.5|2|3|2|19|6|0.5103728382686842|0.269347900063449|3.674451892329852|0.9964049194238052|1|0|False
+3479482.0|Khasianine|2-[4,5-dihydroxy-2-(hydroxymethyl)-6-(5',7,9,13-tetramethylspiro[5-oxapentacyclo[10.8.0.02,9.04,8.013,18]icos-18-ene-6,2'-piperidine]-16-yl)oxyoxan-3-yl]oxy-6-methyloxane-3,4,5-triol|CC1CCC2(NC1)OC1CC3C4CC=C5CC(OC6OC(CO)C(OC7OC(C)C(O)C(O)C7O)C(O)C6O)CCC5(C)C4CCC3(C)C1C2C|51|721.9289999999999|1.9629000000000019|179.56|12|7|0.9487179487179487|5|8|0|51|42|0.20575693831306613|0.05320714136035518|6.299089879544575|2.778465708811112|0|0|False
+223996.0|Isoguanosine|6-amino-9-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]-1H-purin-2-one|Nc1nc(=O)[nH]c2c1ncn2C1OC(CO)C(O)C1O|20|283.244|-2.6866999999999996|159.51|9|5|0.5|2|3|2|20|8|0.39813741611480424|0.16955766100498496|3.9266040531434063|1.0924191136221846|0|0|False
+636.0|2'-Deoxyadenosine monohydrate|5-(6-aminopurin-9-yl)-2-(hydroxymethyl)oxolan-3-ol|Nc1ncnc2c1ncn2C1CC(O)C(CO)O1|18|251.24599999999998|-0.9508000000000003|119.31000000000002|8|3|0.5|2|3|2|18|6|0.628993302830891|0.36275129625779995|3.4841962284641177|1.0509928850136445|1|0|False
+224.0|5'-Adenylic acid|[5-(6-aminopurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methyl dihydrogen phosphate|Nc1ncnc2c1ncn2C1OC(COP(=O)(O)O)C(O)C1O|23|347.224|-1.8630000000000009|186.07|10|5|0.5|4|3|2|23|8|0.39017854457244017|0.17004544392240475|3.8048894493072236|1.2966757882455953|0|0|False
+197.0|ADP|[5-(6-aminopurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methyl phosphono hydrogen phosphate|Nc1ncnc2c1ncn2C1OC(COP(=O)(O)OP(=O)(O)O)C(O)C1O|27|427.20300000000003|-1.7460000000000009|232.59999999999997|12|6|0.5|6|3|2|27|10|0.28079075856620234|0.1854502601232538|4.125297661526227|1.3883535027781002|0|0|False
+1189.0|Xanthosine Dihydrate|9-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]-3H-purine-2,6-dione|O=c1[nH]c(=O)c2ncn(C3OC(CO)C(O)C3O)c2[nH]1|20|284.228|-2.9755999999999996|153.46|8|5|0.5|2|3|2|20|8|0.39414005568585614|0.19608362822222536|3.7807159412552958|1.01042710944925|1|0|False
+1172.0|Uridine 5'-monophosphate| [5-(2,4-dioxopyrimidin-1-yl)-3,4-dihydroxyoxolan-2-yl]methyl dihydrogen phosphate|O=c1ccn(C2OC(COP(=O)(O)O)C(O)C2O)c(=O)[nH]1|21|324.182|-2.7349|171.31|8|5|0.5555555555555556|4|2|1|21|8|0.3684552666679203|0.15597877417689962|3.7734762637985257|1.4404129497273093|0|0|False
+5270766.0|Besifovir| [1-[(2-aminopurin-9-yl)methyl]cyclopropyl]oxymethylphosphonic acid|Nc1ncc2ncn(CC3(OCP(=O)(O)O)CC3)c2n1|20|299.2270000000001|0.09289999999999987|136.38|7|3|0.5|5|3|2|20|0|0.6607224923488081|0.4978291568100905|3.3061717394473806|-0.07424561820598499|1|0|False
+135398661.0|3-Methyladenine (3-MA)|3-methyl-7H-purin-6-imine|Cn1cnc(N)c2ncnc1-2|11|149.15699999999998|-0.1029000000000001|69.62|5|1|0.16666666666666666|0|2|0|11|0|0.56733716665046|0.2032784259567452|2.723105050937429|-0.6977762718276544|1|0|False
+1188.0|2,6-Dihydroxypurine|3,7-dihydropurine-2,6-dione|O=c1[nH]c(=O)c2[nH]cnc2[nH]1|11|152.113|-1.0605000000000004|94.4|3|3|0.0|0|2|2|11|0|0.44866812387763694|0.35339783622062465|2.855621676247601|-0.5009022124224091|1|0|False
+93556.0|Dihydrothymine|5-methyl-1,3-diazinane-2,4-dione|CC1CNC(=O)NC1=O|9|128.131|-0.5381|58.2|2|2|0.6|0|1|0|9|2|0.46007898954400794|0.1326482996202467|3.3119003089141454|0.44655419103448896|1|0|False
+667490.0|6-Mercaptopurine (6-MP) Monohydrate|3,7-dihydropurine-6-thione|S=c1nc[nH]c2nc[nH]c12|10|152.182|1.0154899999999998|57.36|3|2|0.0|0|2|2|10|0|0.5538546640663037|0.401710178865939|3.3698736107073435|-0.5813401541192601|1|0|False
+5359277.0|6-Chloropurine|6-chloro-7H-purine|Clc1ncnc2[nH]cnc12|10|154.56|1.0062999999999998|54.46|3|1|0.0|0|2|2|10|0|0.5764610700745062|0.39268763760375136|2.8791181730415616|-0.8371085619823599|1|0|False
+3758.0|IBMX|1-methyl-3-(2-methylpropyl)-7H-purine-2,6-dione|CC(C)Cn1c(=O)n(C)c(=O)c2nc[nH]c21|16|222.248|0.07929999999999976|72.68|5|1|0.5|2|2|2|16|0|0.7816409579492779|0.5763174668836328|2.741826113988761|-0.5844837553057187|1|0|False
+3134.0|6-(Dimethylamino)purine|N,N-dimethyl-7H-purin-6-amine|CN(C)c1ncnc2nc[nH]c12|12|163.18400000000003|0.4189|57.7|4|1|0.2857142857142857|1|2|2|12|0|0.6614854966833106|0.4787635273265147|2.72771441208657|-1.0546352869607836|1|0|False
+66950.0|Isocytosine|2-amino-1H-pyrimidin-6-one|Nc1nccc(=O)[nH]1|8|111.10399999999998|-0.6479000000000001|71.77|3|2|0.0|0|1|1|8|0|0.4670416161550293|0.27448926713621147|2.683688749895339|-0.2670902200110874|1|0|False
+940.0|Nicotinamide Riboside Chloride (NIAGEN)|1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]pyridin-1-ium-3-carboxamide|NC(=O)c1ccc[n+](C2OC(CO)C(O)C2O)c1|18|255.25|-2.3154999999999983|116.89000000000001|5|4|0.45454545454545453|3|2|1|18|8|0.45250669782783515|0.2942152228724691|3.86876227657962|0.937203306924639|1|0|False
+537159.0|Solasonine|2-[5-hydroxy-6-(hydroxymethyl)-2-(5',7,9,13-tetramethylspiro[5-oxapentacyclo[10.8.0.02,9.04,8.013,18]icos-18-ene-6,2'-piperidine]-16-yl)oxy-4-[3,4,5-trihydroxy-6-(hydroxymethyl)oxan-2-yl]oxyoxan-3-yl]oxy-6-methyloxane-3,4,5-triol|CC1CCC2(NC1)OC1CC3C4CC=C5CC(OC6OC(CO)C(O)C(OC7OC(CO)C(O)C(O)C7O)C6OC6OC(C)C(O)C(O)C6O)CCC5(C)C4CCC3(C)C1C2C|62|884.07|-0.2128999999999921|258.71|17|10|0.9555555555555556|8|9|0|62|52|0.14154743306960962|0.051891635005697746|6.761253268994176|2.31431842126156|0|0|False
+437080.0|Solamargine|2-[4-hydroxy-2-(hydroxymethyl)-6-(5',7,9,13-tetramethylspiro[5-oxapentacyclo[10.8.0.02,9.04,8.013,18]icos-18-ene-6,2'-piperidine]-16-yl)oxy-5-(3,4,5-trihydroxy-6-methyloxan-2-yl)oxyoxan-3-yl]oxy-6-methyloxane-3,4,5-triol|CC1CCC2(NC1)OC1CC3C4CC=C5CC(OC6OC(CO)C(OC7OC(C)C(O)C(O)C7O)C(O)C6OC6OC(C)C(O)C(O)C6O)CCC5(C)C4CCC3(C)C1C2C|61|868.071|0.8147000000000062|238.47999999999996|16|9|0.9555555555555556|7|9|0|61|52|0.16112638285309447|0.05545407431461643|6.750529522128671|2.3842641223563397|0|0|False
+240980.0|2'-Deoxy-5-Fluorocytidine|4-amino-5-fluoro-1-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidin-2-one|Nc1nc(=O)n(C2CC(O)C(CO)O2)cc1F|17|245.20999999999998|-1.3947000000000003|110.60000000000001|7|3|0.5555555555555556|2|2|1|17|6|0.5910181091914157|0.2952824050893773|3.606938275518738|0.7886448709701591|1|0|False
+284240.0|3'-Fluoro-3'-deoxythymidine (Alovudine)|1-[4-fluoro-5-(hydroxymethyl)oxolan-2-yl]-5-methylpyrimidine-2,4-dione|Cc1cn(C2CC(F)C(CO)O2)c(=O)[nH]c1=O|17|244.22199999999998|-0.53708|84.32|5|2|0.6|2|2|1|17|6|0.731622172408428|0.41646450691211045|3.586677740401681|0.507872196497247|1|0|False
+137795344.0|LLY-283|2-(4-aminopyrrolo[2,3-d]pyrimidin-7-yl)-5-[hydroxy(phenyl)methyl]oxolane-3,4-diol|Nc1ncnc2c1ccn2C1OC(C(O)c2ccccc2)C(O)C1O|25|342.355|0.3663000000000001|126.65|8|4|0.29411764705882354|3|4|3|25|10|0.5413254255627207|0.37218328519283805|3.804013205830268|0.7875002540522721|1|0|False
+155886644.0|EIDD-2801|[3,4-dihydroxy-5-[4-(hydroxyamino)-2-oxopyrimidin-1-yl]oxolan-2-yl]methyl 2-methylpropanoate|CC(C)C(=O)OCC1OC(n2ccc(=NO)[nH]c2=O)C(O)C1O|23|329.309|-1.7152999999999974|146.37|9|4|0.6153846153846154|4|2|1|23|8|0.29191347249939087|0.20002777173354394|4.189860275255468|1.2390387878063869|1|0|False
+1651.0|3-Deazaadenosine hydrochloride|2-(4-aminoimidazo[4,5-c]pyridin-1-yl)-5-(hydroxymethyl)oxolane-3,4-diol |Nc1nccc2c1ncn2C1OC(CO)C(O)C1O|19|266.257|-1.3750000000000007|126.65|8|4|0.45454545454545453|2|3|2|19|8|0.5275658981283201|0.2793960532890429|3.656019022097176|1.2390070639558106|1|0|False
+|Uridine 5-diphosphoglucose disodium salt|[[(2R,3S,4R,5R)-5-(2,4-dioxopyrimidin-1-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-[(2R,3S,4S,5R)-1,3,4,5-tetrahydroxy-6-oxohexan-2-yl]oxyphosphoryl] phosphate|O=CC(O)C(O)C(O)C(CO)OP(=O)(OCC1OC(n2ccc(=O)[nH]c2=O)C(O)C1O)OP(=O)([O-])[O-]|36|564.2860000000002|-6.215099999999993|310.48999999999995|18|7|0.6666666666666666|13|2|1|36|18|0.08650496257970032|0.08720964070568987|5.369017676264923|1.3690714143354032|0|0|False
+70639.0|3-Methylxanthine|3-methyl-7H-purine-2,6-dione|Cn1c(=O)[nH]c(=O)c2[nH]cnc21|12|166.14|-1.0501000000000005|83.54|4|2|0.16666666666666666|0|2|2|12|0|0.5233953855323817|0.4649418539506477|2.6826240788903544|-0.9379367321269417|1|0|False
+72386069.0|Acelarin (NUC-1031)|benzyl 2-[[[5-(4-amino-2-oxopyrimidin-1-yl)-4,4-difluoro-3-hydroxyoxolan-2-yl]methoxy-phenoxyphosphoryl]amino]propanoate|CC(NP(=O)(OCC1OC(n2ccc(N)nc2=O)C(F)(F)C1O)Oc1ccccc1)C(=O)OCc1ccccc1|40|580.4810000000003|2.6443000000000003|164.22999999999996|11|3|0.32|11|4|3|40|10|0.22561375399287723|0.27837300531820436|4.196538827820978|0.34838553412737994|0|0|False
+135401907.0|Allopurinol|1,5-dihydropyrazolo[3,4-d]pyrimidin-4-one|O=c1ncnc2[nH][nH]cc1-2|10|136.11399999999998|-0.4022000000000001|74.43|3|2|0.0|0|2|0|10|0|0.5169670612450268|0.16887078714484646|3.3223383321927544|0.49540116952077007|1|0|False
+3366.0|Flucytosine|6-amino-5-fluoro-1H-pyrimidin-2-one|Nc1nc(=O)[nH]cc1F|9|129.09399999999997|-0.5088000000000001|71.77|3|2|0.0|0|1|1|9|0|0.4952172017431901|0.27854681358196376|3.1539953149178643|-0.7210492950621221|1|0|False
+60871.0|Adefovir Dipivoxil|[2-(6-aminopurin-9-yl)ethoxymethyl-(2,2-dimethylpropanoyloxymethoxy)phosphoryl]oxymethyl 2,2-dimethylpropanoate|CC(C)(C)C(=O)OCOP(=O)(COCCn1cnc2c(N)ncnc21)OCOC(=O)C(C)(C)C|34|501.47700000000026|2.7025000000000006|166.97999999999996|13|1|0.65|11|2|2|34|0|0.2071524581096599|0.26242117414727406|3.2764101894129833|-0.33118745107923225|0|0|False
+2265.0|Azathioprine| 6-(3-methyl-5-nitroimidazol-4-yl)sulfanyl-7H-purine|Cn1cnc([N+](=O)[O-])c1Sc1ncnc2nc[nH]c12|19|277.269|1.1457999999999997|115.41999999999999|8|1|0.1111111111111111|3|3|3|19|0|0.43328794180573177|0.5104763505055192|3.144692533268106|-1.257220744395016|1|0|False
+2723601.0|Thioguanine|2-amino-3,7-dihydropurine-6-thione|Nc1nc(=S)c2[nH]cnc2[nH]1|11|167.197|0.5976899999999998|83.38|4|3|0.0|0|2|2|11|0|0.5014913838271434|0.43666862873652124|3.3037189467190657|-0.34551430559848184|1|0|False
+135483437.0|Valaciclovir HCl|2-[(2-amino-6-oxo-1H-purin-9-yl)methoxy]ethyl 2-amino-3-methylbutanoate|CC(C)C(N)C(=O)OCCOCn1cnc2c(=O)[nH]c(N)nc21|23|324.341|-0.7975999999999985|151.14000000000004|9|3|0.5384615384615384|7|2|2|23|2|0.44214276395859164|0.3730958971915234|3.2609439427942917|-0.16316017429853905|1|0|False
+657298.0|Propylthiouracil|6-propyl-2-sulfanylidene-1H-pyrimidin-4-one|CCCc1cc(=O)[nH]c(=S)[nH]1|11|170.237|1.38499|48.65|2|2|0.42857142857142855|2|1|1|11|0|0.6587322532597096|0.2559861332659623|2.683909567066461|-0.9512439041419182|1|0|False
+3830.0|Kinetin|N-(furan-2-ylmethyl)-7H-purin-6-amine|c1coc(CNc2ncnc3nc[nH]c23)c1|16|215.216|1.5579999999999996|79.63|5|2|0.1|3|3|3|16|0|0.6925924860226649|0.711699598509513|2.490935013809871|-1.402265304972444|1|0|False
+3324.0|Famciclovir|[2-(acetyloxymethyl)-4-(2-aminopurin-9-yl)butyl] acetate|CC(=O)OCC(CCn1cnc2cnc(N)nc21)COC(C)=O|23|321.33700000000016|0.5409999999999998|122.22|9|1|0.5|7|2|2|23|0|0.733115342152729|0.45204840142043734|2.806858282589218|-0.19600642021383782|1|0|False
+1269845.0|2-Thiouracil|2-sulfanylidene-1H-pyrimidin-4-one |O=c1cc[nH]c(=S)[nH]1|8|128.156|0.43249|48.65|2|2|0.0|0|1|1|8|0|0.49770208173400393|0.21652997475728783|3.059775463182052|-0.5315741715414|1|0|False
+667493.0|Methylthiouracil|6-methyl-2-sulfanylidene-1H-pyrimidin-4-one|Cc1cc(=O)[nH]c(=S)[nH]1|9|142.18300000000002|0.74091|48.65|2|2|0.2|0|1|1|9|0|0.5247689157489369|0.2203039974925121|3.0118414687640174|-1.153615214888089|1|0|False
+1174.0|Uracil|1H-pyrimidine-2,4-dione|O=c1cc[nH]c(=O)[nH]1|8|112.088|-0.9368000000000001|65.72|2|2|0.0|0|1|1|8|0|0.4546939811074878|0.22106494195155435|2.763417421224011|0.034934357644975|1|0|False
+62389.0|6-Benzylaminopurine|N-benzyl-7H-purin-6-amine|c1ccc(CNc2ncnc3nc[nH]c23)cc1|17|225.25500000000002|1.9649999999999996|66.49000000000001|4|2|0.08333333333333333|3|3|3|17|0|0.7147392861192281|0.6930151711707544|2.118574274148248|-0.9996364494840941|1|0|False
+597.0|Cytosine|6-amino-1H-pyrimidin-2-one|Nc1cc[nH]c(=O)n1|8|111.104|-0.6479000000000001|71.77000000000001|3|2|0.0|0|1|1|8|0|0.4670416161550293|0.27448926713621147|3.295071966678556|0.31089129653276254|1|0|False
+4564.0|NU2058|6-(cyclohexylmethoxy)-7H-purin-2-amine|Nc1nc(OCC2CCCCC2)c2nc[nH]c2n1|18|247.30199999999996|1.8941999999999999|89.71|5|2|0.5833333333333334|3|3|2|18|0|0.8640548613284358|0.6675384454567892|2.7087684013184763|-0.5693644300994334|1|0|False
+99920.0|Adenosine Dialdehyde (ADOX)|2-[1-(6-aminopurin-9-yl)-2-oxoethoxy]-3-hydroxypropanal|Nc1ncnc2c1ncn2C(C=O)OC(C=O)CO|19|265.229|-1.3176|133.22|9|2|0.3|6|2|2|19|4|0.6142899241146795|0.40414391704379254|4.0613930320623375|0.27190180955298426|1|0|False
+1135.0|Thymine|5-methyl-1H-pyrimidine-2,4-dione|Cc1c[nH]c(=O)[nH]c1=O|9|126.115|-0.6283800000000002|65.72|2|2|0.2|0|1|1|9|0|0.4857813089921775|0.22442590613459015|2.4711895456870963|-0.39816338972551113|1|0|False
+393593.0|Namodenoson (CF-102)|5-[2-chloro-6-[(3-iodophenyl)methylamino]purin-9-yl]-3,4-dihydroxy-N-methyloxolane-2-carboxamide|CNC(=O)C1OC(n2cnc3c(NCc4cccc(I)c4)nc(Cl)nc32)C(O)C1O|30|544.7370000000002|1.061599999999999|134.42|9|4|0.3333333333333333|5|4|3|30|8|0.27679674050364184|0.3780075367245393|3.858289643137513|-0.35311044843938993|0|0|False
+190.0|Adenine|7H-purin-6-amine|Nc1ncnc2[nH]cnc12|10|135.13|-0.0648999999999999|80.48|4|2|0.0|0|2|2|10|0|0.5296759293780585|0.46383358553871024|2.745044432988511|-0.22216883360209003|1|0|False
+22041878.0|2'-Deoxyuridine 5'-monophosphate disodium salt|[5-(2,4-dioxopyrimidin-1-yl)-3-hydroxyoxolan-2-yl]methyl phosphate|O=c1ccn(C2CC(O)C(COP(=O)([O-])[O-])O2)c(=O)[nH]1|20|306.167|-2.9696999999999987|156.74|9|2|0.5555555555555556|4|2|1|20|6|0.5581147155997511|0.2665509998411342|4.253945014153231|0.8390224194285251|1|0|False
+621.0|2'-Deoxyadenosine 5'-monophosphate|[5-(6-aminopurin-9-yl)-3-hydroxyoxolan-2-yl]methyl dihydrogen phosphate|Nc1ncnc2c1ncn2C1CC(O)C(COP(=O)(O)O)O1|22|331.225|-0.8338000000000003|165.83999999999997|9|4|0.5|4|3|2|22|6|0.518964726677587|0.2703973142533638|3.7330177714088277|1.0058182745873498|0|0|False
+624.0|2'-Deoxycytidine 5'-monophosphate|[5-(4-amino-2-oxopyrimidin-1-yl)-3-hydroxyoxolan-2-yl]methyl dihydrogen phosphate|Nc1ccn(C2CC(O)C(COP(=O)(O)O)O2)c(=O)n1|20|307.199|-1.4168|157.13|8|4|0.5555555555555556|4|2|1|20|6|0.48991422293348935|0.21590188566756152|3.7558655269737438|1.3705532333776147|1|0|False
+193.0|S-Adenosyl-L-homocysteine (SAH)|2-amino-4-[[5-(6-aminopurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methylsulfanyl]butanoic acid|Nc1ncnc2c1ncn2C1OC(CSCCC(N)C(=O)O)C(O)C1O|26|384.41800000000006|-1.4370999999999983|182.62999999999997|11|5|0.5714285714285714|7|3|2|26|10|0.3524104766503097|0.1706266479700945|3.9878562207640913|0.8322716321994499|0|0|False
+5513.0|Tomatine|2-[2-[4,5-dihydroxy-2-(hydroxymethyl)-6-(5',7,9,13-tetramethylspiro[5-oxapentacyclo[10.8.0.02,9.04,8.013,18]icosane-6,2'-piperidine]-16-yl)oxyoxan-3-yl]oxy-5-hydroxy-6-(hydroxymethyl)-4-(3,4,5-trihydroxyoxan-2-yl)oxyoxan-3-yl]oxy-6-(hydroxymethyl)oxane-3,4,5-triol|CC1CCC2(NC1)OC1CC3C4CCC5CC(OC6OC(CO)C(OC7OC(CO)C(O)C(OC8OCC(O)C(O)C8O)C7OC7OC(CO)C(O)C(O)C7O)C(O)C6O)CCC5(C)C4CCC3(C)C1C2C|72|1034.2000000000003|-2.6972999999999807|337.86|22|13|1.0|11|10|0|72|62|0.09370727646314425|0.03741186437663462|7.196015861300958|2.0025666159277615|0|0|False
+4739.0|Pentostatin|3-[4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]-7,8-dihydro-4H-imidazo[4,5-d][1,3]diazepin-8-ol|OCC1OC(n2cnc3c2NC=NCC3O)CC1O|19|268.273|-0.9890000000000005|112.13000000000001|8|4|0.6363636363636364|2|3|1|19|8|0.5477635402256686|0.20674293672099894|4.441045872605159|1.0618509123565736|1|0|False
+263976.0|2',3'-Dideoxyadenosine|[5-(6-aminopurin-9-yl)oxolan-2-yl]methanol|Nc1ncnc2c1ncn2C1CCC(CO)O1|17|235.24699999999996|0.07839999999999986|99.08000000000001|7|2|0.5|2|3|2|17|4|0.7642641295225605|0.4804378807684162|3.37615943374439|0.818243690205506|1|0|False
+1599.0|Puromycin aminonucleoside|4-amino-2-[6-(dimethylamino)purin-9-yl]-5-(hydroxymethyl)oxolan-3-ol|CN(C)c1ncnc2c1ncn2C1OC(CO)C(N)C1O|21|294.315|-1.5297999999999983|122.55000000000001|9|3|0.5833333333333334|3|3|2|21|8|0.6229174346076342|0.35532968935631826|3.892502883730317|0.5775648178855525|1|0|False
+3461.0|Gemcitabine|4-amino-1-[3,3-difluoro-4-hydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidin-2-one|Nc1ccn(C2OC(CO)C(O)C2(F)F)c(=O)n1|18|263.2|-1.2886|110.60000000000001|7|3|0.5555555555555556|2|2|1|18|6|0.6120873727300361|0.30156266317008307|3.8632725293690937|1.2986545260508495|1|0|False
+4213.0|Mizoribine|1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]-5-hydroxyimidazole-4-carboxamide|NC(=O)c1ncn(C2OC(CO)C(O)C2O)c1O|18|259.218|-2.7009|151.06|8|5|0.5555555555555556|3|2|1|18|8|0.3957886051129175|0.147172771208249|3.773041201226402|0.9518781068023058|0|0|False
+596.0|Cytarabine|4-amino-1-[3,4-dihydroxy-5-(hydroxymethyl)oxolan-2-yl]pyrimidin-2-one|Nc1ccn(C2OC(CO)C(O)C2O)c(=O)n1|17|243.21900000000002|-2.563|130.82999999999998|8|4|0.5555555555555556|2|2|1|17|8|0.4489304892314893|0.18860344125062514|3.548894614600127|1.6478124261033116|1|0|False
+24208296.0|ATP disodium|[[[5-(6-aminopurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-hydroxyphosphoryl]oxy-oxidophosphoryl] hydrogen phosphate|Nc1ncnc2c1ncn2C1OC(COP(=O)(O)OP(=O)([O-])OP(=O)([O-])O)C(O)C1O|31|505.1660000000001|-2.8929999999999993|284.79|16|5|0.5|8|3|2|31|14|0.22489036963823456|0.2003365594519469|5.011918199029612|1.0168482980546354|0|0|False
+925.0|NAD+| [[5-(6-aminopurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-hydroxyphosphoryl] [5-(3-carbamoylpyridin-1-ium-1-yl)-3,4-dihydroxyoxolan-2-yl]methyl phosphate|NC(=O)c1ccc[n+](C2OC(COP(=O)([O-])OP(=O)(O)OCC3OC(n4cnc5c(N)ncnc54)C(O)C3O)C(O)C2O)c1|44|663.4300000000004|-3.6478999999999964|321.0900000000001|18|7|0.47619047619047616|11|5|3|44|20|0.0767773571622719|0.12396315529857062|5.338067205606141|0.7011583949037886|0|0|False
+9896099.0|Abacavir sulfate|[(1S,4R)-4-[2-amino-6-(cyclopropylamino)purin-9-yl]cyclopent-2-en-1-yl]methanol|Nc1nc(NC2CC2)c2ncn(C3C=CC(CO)C3)c2n1|21|286.33900000000006|1.0922999999999998|101.88|7|3|0.5|4|4|2|21|4|0.7272302824304794|0.532844209200051|3.688999973120933|0.026597937866581003|1|0|False
+3743107.0|Citicoline sodium|[[5-(4-amino-2-oxopyrimidin-1-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-oxidophosphoryl] 2-(trimethylazaniumyl)ethyl phosphate|C[N+](C)(C)CCOP(=O)([O-])OP(=O)([O-])OCC1OC(n2ccc(N)nc2=O)C(O)C1O|31|487.3190000000002|-2.862499999999996|218.55|14|3|0.7142857142857143|10|2|1|31|12|0.22357629050096392|0.11977524271877953|5.089091608912945|1.1662562054042096|0|0|False
+156610574.0|Cangrelor Tetrasodium|[dichloro(phosphonato)methyl]-[[3,4-dihydroxy-5-[6-(2-methylsulfanylethylamino)-2-(3,3,3-trifluoropropylsulfanyl)purin-9-yl]oxolan-2-yl]methoxy-oxidophosphoryl]oxyphosphinate|CSCCNc1nc(SCCC(F)(F)F)nc2c1ncn2C1OC(COP(=O)([O-])OP(=O)([O-])C(Cl)(Cl)P(=O)([O-])[O-])C(O)C1O|44|772.3340000000004|0.32249999999999895|267.23|19|3|0.7058823529411765|15|3|2|44|12|0.0723261808950979|0.21464495331026204|5.531489339568375|-0.1466218200172386|0|0|False
+3986128.0|Flavin mononucleotide|[5-(7,8-dimethyl-2,4-dioxobenzo[g]pteridin-10-yl)-2,3,4-trihydroxypentyl] hydrogen phosphate|Cc1cc2nc3c(=O)[nH]c(=O)nc-3n(CC(O)C(O)C(O)COP(=O)([O-])O)c2cc1C|31|455.3400000000002|-2.2385599999999988|210.92|11|5|0.4117647058823529|7|3|1|31|8|0.18980818802860375|0.10778902916070311|4.425392476983317|0.08008486944120105|0|0|False
+4661174.0|?-Nicotinamide Mononucleotide|[5-(3-carbamoylpyridin-1-ium-1-yl)-3,4-dihydroxyoxolan-2-yl]methyl hydrogen phosphate|NC(=O)c1ccc[n+](C2OC(COP(=O)([O-])O)C(O)C2O)c1|22|334.22099999999995|-2.830499999999999|166.25|7|4|0.45454545454545453|5|2|1|22|10|0.33008457497205185|0.2491576086775115|4.570243080664501|0.7442067405707499|1|0|False
+13013858.0|Citicholine|[[5-(4-amino-2-oxopyrimidin-1-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-hydroxyphosphoryl] 2-(trimethylazaniumyl)ethyl phosphate|C[N+](C)(C)CCOP(=O)([O-])OP(=O)(O)OCC1OC(n2ccc(N)nc2=O)C(O)C1O|31|488.32700000000017|-2.2304999999999957|215.71999999999997|13|4|0.7142857142857143|10|2|1|31|12|0.20278188342870285|0.09819520093202008|4.814314685836021|1.371965225840339|0|0|False
+314.0|5'-Cytidylic acid|[5-(4-amino-2-oxopyrimidin-1-yl)-3,4-dihydroxyoxolan-2-yl]methyl dihydrogen phosphate|Nc1ccn(C2OC(COP(=O)(O)O)C(O)C2O)c(=O)n1|21|323.19800000000004|-2.446|177.36|9|5|0.5555555555555556|4|2|1|21|8|0.3735901348140529|0.13458832466329937|3.826860604457865|1.5683275858392525|0|0|False
+5644.0|UTP, Trisodium Salt|[[[5-(2,4-dioxopyrimidin-1-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-oxidophosphoryl]oxy-oxidophosphoryl] hydrogen phosphate|O=c1ccn(C2OC(COP(=O)([O-])OP(=O)([O-])OP(=O)([O-])O)C(O)C2O)c(=O)[nH]1|29|481.1160000000001|-4.396899999999998|272.86|15|4|0.5555555555555556|8|2|1|29|14|0.2551718313877904|0.18854093107244396|5.328826360999949|0.9171505343682239|0|0|False
+136005379.0|Inosine 5?-triphosphate trisodium salt|[[[3,4-dihydroxy-5-(6-oxo-1H-purin-9-yl)oxolan-2-yl]methoxy-oxidophosphoryl]oxy-oxidophosphoryl] hydrogen phosphate|O=c1[nH]cnc2c1ncn2C1OC(COP(=O)([O-])OP(=O)([O-])OP(=O)([O-])O)C(O)C1O|31|505.1420000000001|-3.8139|281.57|16|4|0.5|8|3|2|31|14|0.2500591032919711|0.2656860254054147|5.422037939530075|0.769043034145274|0|0|False
+135441845.0|Guanosine 5'-monophosphate disodium salt|[5-(2-amino-6-oxo-1H-purin-9-yl)-3,4-dihydroxyoxolan-2-yl]methyl phosphate|Nc1nc(=O)c2ncn(C3OC(COP(=O)([O-])[O-])C(O)C3O)c2[nH]1|24|361.20700000000005|-3.8336999999999994|211.7|12|4|0.5|4|3|2|24|8|0.38704670523942886|0.17415969497343173|4.404662987508528|0.877560502907929|0|0|False
+197.0|Adenosine 5?-diphosphate sodium salt|[5-(6-aminopurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methyl phosphono hydrogen phosphate|Nc1ncnc2c1ncn2C1OC(COP(=O)(O)OP(=O)(O)O)C(O)C1O|27|427.20300000000003|-1.7460000000000009|232.59999999999997|12|6|0.5|6|3|2|27|10|0.28079075856620234|0.1854502601232538|4.125297661526227|1.3883535027781002|0|0|False
+44134852.0|Triphosphopyridine nucleotide disodium salt|[2-(6-aminopurin-9-yl)-5-[[[[5-(3-carbamoylpyridin-1-ium-1-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-oxidophosphoryl]oxy-oxidophosphoryl]oxymethyl]-4-hydroxyoxolan-3-yl] hydrogen phosphate|NC(=O)c1ccc[n+](C2OC(COP(=O)([O-])OP(=O)([O-])OCC3OC(n4cnc5c(N)ncnc54)C(OP(=O)([O-])O)C3O)C(O)C2O)c1|48|741.3930000000005|-4.794899999999992|373.2800000000001|21|6|0.47619047619047616|13|5|3|48|22|0.07066446785799431|0.11623903144299709|5.927167227885624|0.5859635499812229|0|0|False
+137795696.0|Diquafosol Tetrasodium|[[5-(2,4-dioxopyrimidin-1-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-oxidophosphoryl] [[[5-(2,4-dioxopyrimidin-1-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-oxidophosphoryl]oxy-oxidophosphoryl] phosphate|O=c1ccn(C2OC(COP(=O)([O-])OP(=O)([O-])OP(=O)([O-])OP(=O)([O-])OCC3OC(n4ccc(=O)[nH]c4=O)C(O)C3O)C(O)C2O)c(=O)[nH]1|49|786.2750000000004|-6.718199999999994|415.7700000000001|25|6|0.5555555555555556|14|4|2|49|24|0.09690594623547874|0.1005939099621791|6.025108139184198|0.5218458453224182|0|0|False
+258.0|Blasticidin S|3-[[3-amino-5-[carbamimidoyl(methyl)amino]pentanoyl]amino]-6-(4-amino-2-oxopyrimidin-1-yl)-3,6-dihydro-2H-pyran-2-carboxylic acid |CN(CCC(N)CC(=O)NC1C=CC(n2ccc(N)nc2=O)OC1C(=O)O)C(=N)N|30|422.44600000000025|-2.2187299999999945|215.67|9|6|0.47058823529411764|8|2|1|30|8|0.150577431129479|0.10154891406114437|4.490427372075242|1.0509590801570832|0|0|False
+135545622.0|Disodium 5'-Inosinate|[3,4-dihydroxy-5-(6-oxo-1H-purin-9-yl)oxolan-2-yl]methyl phosphate|O=c1[nH]cnc2c1ncn2C1OC(COP(=O)([O-])[O-])C(O)C1O|23|346.192|-3.4158999999999984|185.67999999999998|11|3|0.5|4|3|2|23|8|0.4706220858439375|0.2667159039917633|4.448493844911617|0.9150235712723259|0|0|False
+4014956.0|Disodium uridine-5'-monophosphate|[5-(2,4-dioxopyrimidin-1-yl)-3,4-dihydroxyoxolan-2-yl]methyl phosphate|O=c1ccn(C2OC(COP(=O)([O-])[O-])C(O)C2O)c(=O)[nH]1|21|322.166|-3.9988999999999972|176.97|10|3|0.5555555555555556|4|2|1|21|8|0.4658768727043418|0.2057858099091487|4.292027087974349|1.133455884639928|0|0|False
+24208296.0|Adenosine disodium triphosphate|[[[5-(6-aminopurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-hydroxyphosphoryl]oxy-oxidophosphoryl] hydrogen phosphate|Nc1ncnc2c1ncn2C1OC(COP(=O)(O)OP(=O)([O-])OP(=O)([O-])O)C(O)C1O|31|505.1660000000001|-2.8929999999999993|284.79|16|5|0.5|8|3|2|31|14|0.22489036963823456|0.2003365594519469|5.011918199029612|1.0168482980546354|0|0|False
+65040.0|5-Methylcytosine|6-amino-5-methyl-1H-pyrimidin-2-one|Cc1cnc(=O)[nH]c1N|9|125.131|-0.33948000000000017|71.77|3|2|0.2|0|1|1|9|0|0.4979194736965626|0.27879359761277905|2.819639545687096|-0.4087731108036112|1|0|False
+135432442.0|Guanosine 5'-triphosphate trisodium salt|[[[5-(2-amino-6-oxo-1H-purin-9-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-hydroxyphosphoryl]oxy-oxidophosphoryl] phosphate|Nc1nc2c(ncn2C2OC(COP(=O)(O)OP(=O)([O-])OP(=O)([O-])[O-])C(O)C2O)c(=O)[nH]1|32|520.1570000000002|-4.231699999999997|307.59|17|5|0.5|8|3|2|32|12|0.2058114066028432|0.198961655563169|5.131529164316129|0.9874606492575717|0|0|False
+4073694.0|Thymidine 5'-monophosphate disodium salt|[3-hydroxy-5-(5-methyl-2,4-dioxopyrimidin-1-yl)oxolan-2-yl]methyl phosphate|Cc1cn(C2CC(O)C(COP(=O)([O-])[O-])O2)c(=O)[nH]c1=O|21|320.194|-2.6612799999999988|156.73999999999998|9|2|0.6|4|2|1|21|6|0.5689477538848637|0.27086147634366586|4.168970366666491|0.6891982972581047|1|0|False
+135545622.0|Disodium 5'-inosinate monohydrate|[3,4-dihydroxy-5-(6-oxo-1H-purin-9-yl)oxolan-2-yl]methyl phosphate|O=c1[nH]cnc2c1ncn2C1OC(COP(=O)([O-])[O-])C(O)C1O|23|346.192|-3.4158999999999984|185.67999999999998|11|3|0.5|4|3|2|23|8|0.4706220858439375|0.2667159039917633|4.448493844911617|0.9150235712723259|0|0|False
+44287897.0|Uridine-5'-diphosphate disodium salt|[[5-(2,4-dioxopyrimidin-1-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-oxidophosphoryl] hydrogen phosphate |O=c1ccn(C2OC(COP(=O)([O-])OP(=O)([O-])O)C(O)C2O)c(=O)[nH]1|25|402.14500000000004|-3.881899999999999|223.49999999999997|12|4|0.5555555555555556|6|2|1|25|12|0.33530080341395063|0.10747213319277059|4.854100270601977|1.0638946198671397|0|0|False
+238.0|ATP|[[5-(6-aminopurin-9-yl)-3,4-dihydroxyoxolan-2-yl]methoxy-hydroxyphosphoryl] phosphono hydrogen phosphate|Nc1ncnc2c1ncn2C1OC(COP(=O)(O)OP(=O)(O)OP(=O)(O)O)C(O)C1O|31|507.1820000000001|-1.629000000000001|279.13|14|7|0.5|8|3|2|31|12|0.19742203378388068|0.16844205143530697|4.41361201850629|1.3438955794867324|0|0|False
+135398638.0|Hypoxanthine|1,7-dihydropurin-6-one|O=c1[nH]cnc2nc[nH]c12|10|136.114|-0.35380000000000006|74.43|3|2|0.0|0|2|2|10|0|0.5192368565638923|0.39726961313423786|2.9399791809991207|-0.25903651864364996|1|0|False
+312827.0|Tomatidine|5',7,9,13-tetramethylspiro[5-oxapentacyclo[10.8.0.02,9.04,8.013,18]icosane-6,2'-piperidine]-16-ol|CC1CCC2(NC1)OC1CC3C4CCC5CC(O)CCC5(C)C4CCC3(C)C1C2C|30|415.66200000000026|5.366800000000006|41.489999999999995|3|2|1.0|0|6|0|30|24|0.5589811430146876|0.21002733429425308|5.369563102779233|2.885757885743727|0|0|False
+9449.0|Adenine sulfate|7H-purin-6-amine|Nc1ncnc2nc[nH]c12|10|135.13|-0.0648999999999999|80.47999999999999|4|2|0.0|0|2|2|10|0|0.5296759293780585|0.46383358553871024|2.6602057061980595|-0.48016737706869|1|0|False

TransAntivirus/download_pubchem/download.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+MIN=0
+MAX=1555
+
+PREFIX="ftp://ftp.ncbi.nlm.nih.gov/pubchem/Compound/CURRENT-Full/XML/"
+# fill this in
+#DOWNLOAD_DIR=/user4/c5t5-main/download_pubchem/
+DOWNLOAD_DIR=/root/autodl-tmp/c5t5-main/download_pubchem/
+
+prev_num="0000"
+for i in $(seq $MIN 5 $MAX); do
+    num=$(printf "%04d" $i)
+    fn="Compound_${prev_num}00001_${num}00000.xml"
+    prev_num=$num
+    echo "getting" $fn
+    if ! [[ -f $DOWNLOAD_DIR$fn ]]; then
+        orig_dir=$(pwd)
+        cd $DOWNLOAD_DIR
+        wget "${PREFIX}${fn}.gz"
+        wget "${PREFIX}${fn}.gz.md5"
+        if md5sum -c ${fn}.gz.md5; then
+            echo md5 passed
+            rm ${fn}.gz.md5
+            #gunzip $fn
+            pigz -d -p 8 $fn
+        else
+            echo md5 failed
+        fi
+        cd $orig_dir
+    fi
+    python extract_info.py $DOWNLOAD_DIR$fn "<PC-Compound>" Preferred 11 34 -26 Traditional 11 34 -26 "Canonical<" 11 34 -26 Mass 12 34 -26 Formula 11 34 -26 "Log P" 11 34 -26 >> ${DOWNLOAD_DIR}iupacs_properties.txt
+    rm $DOWNLOAD_DIR$fn
+done

TransAntivirus/download_pubchem/extract_info.py

@@ -0,0 +1,82 @@
+import sys
+import copy
+from multiprocessing import Pool
+import numpy as np
+import itertools
+
+# look through fn for all the provided search terms (keys),
+# and extract values as directed by the offset, start & end cols
+
+# example usage to get IUPAC:
+# python extract_mass_formula.py Compounds.xml <PC-Compound> Systematic 11 34 -26
+
+# Systematic 11 34 -26
+# Mass 12 34 -26
+# Formula 11 34 -26
+# Log P 11 34 -26
+
+# chemicals are separated by the 2nd arg
+
+LINES_PER_PROC = 10000
+
+fn = sys.argv[1]
+
+assert len(sys.argv) > 3, "need to provide search terms, etc."
+assert len(sys.argv[3:]) % 4 == 0, "each search term needs offset & cols"
+
+chemical_separator = sys.argv[2]
+
+search_terms = []
+line_offsets = []
+start_cols = []
+end_cols = []
+
+for i in range(3, len(sys.argv), 4):
+    search_terms.append(sys.argv[i])
+    line_offsets.append(int(sys.argv[i+1]))
+    start_cols.append(int(sys.argv[i+2]))
+    end_cols.append(int(sys.argv[i+3]))
+
+lines = []
+
+def find_relevant(start_line):
+    relevant_lines = []
+    max_length = len(lines)
+    for i in range(LINES_PER_PROC):
+        if start_line + i >= max_length:
+            return relevant_lines
+        line = lines[start_line + i]
+        if chemical_separator in line:
+            relevant_lines.append(start_line + i)
+        for search_term in search_terms:
+            if search_term in line:
+                relevant_lines.append(start_line + i)
+    return relevant_lines
+
+with open(fn, "r") as xml_file:
+    # first line is headers
+    found_values = copy.deepcopy(search_terms)
+
+    lines = xml_file.readlines()
+
+    p = Pool(32)
+    relevant_lines = p.map(find_relevant,
+                           range(0, len(lines), LINES_PER_PROC))
+    relevant_lines = itertools.chain.from_iterable(relevant_lines)
+    relevant_lines = np.array(list(relevant_lines))
+
+    for i in relevant_lines:
+        line = lines[i]
+        if chemical_separator in line:
+            # new chemical -- reset search term lines & found_values
+            print("|".join(found_values))
+            found_values = ["" for _ in search_terms]
+            continue
+
+        for j, search_term in enumerate(search_terms):
+            if search_term in line:
+                # found the jth search term on line i
+                found = i + line_offsets[j]
+                found_values[j] = lines[found][start_cols[j]:end_cols[j]]
+
+

TransAntivirus/download_pubchem/finetunev1_new.csv

@@ -0,0 +1,71 @@
+smiles|aLogP|canonical_smiles|CanonicalSMILES|IUPACName|XLogP
+CCN(CC)CCCC(C)Nc1ccnc2cc(Cl)ccc12|4.810600000000004|CCN(CC)CCCC(C)Nc1ccnc2cc(Cl)ccc12|CCN(CC)CCCC(C)NC1=C2C=CC(=CC2=NC=C1)Cl|4-N-(7-chloroquinolin-4-yl)-1-N,1-N-diethylpentane-1,4-diamine|4.6
+Cc1cccc(C)c1OCC(=O)NC(Cc1ccccc1)C(O)CC(Cc1ccccc1)NC(=O)C(C(C)C)N1CCCNC1=O|4.328140000000003|Cc1cccc(C)c1OCC(=O)NC(Cc1ccccc1)C(O)CC(Cc1ccccc1)NC(=O)C(C(C)C)N1CCCNC1=O|CC1=C(C(=CC=C1)C)OCC(=O)NC(CC2=CC=CC=C2)C(CC(CC3=CC=CC=C3)NC(=O)C(C(C)C)N4CCCNC4=O)O|N-[5-[[2-(2,6-dimethylphenoxy)acetyl]amino]-4-hydroxy-1,6-diphenylhexan-2-yl]-3-methyl-2-(2-oxo-1,3-diazinan-1-yl)butanamide|5.9
+O=C(Nc1ccc([N+](=O)[O-])cc1Cl)c1cc(Cl)ccc1O|3.859500000000001|O=C(Nc1ccc([N+](=O)[O-])cc1Cl)c1cc(Cl)ccc1O|C1=CC(=C(C=C1[N+](=O)[O-])Cl)NC(=O)C2=C(C=CC(=C2)Cl)O|5-chloro-N-(2-chloro-4-nitrophenyl)-2-hydroxybenzamide|4.0
+CN(C)C(=O)C(CCN1CCC(O)(c2ccc(Cl)cc2)CC1)(c1ccccc1)c1ccccc1|5.088000000000005|CN(C)C(=O)C(CCN1CCC(O)(c2ccc(Cl)cc2)CC1)(c1ccccc1)c1ccccc1|CN(C)C(=O)C(CCN1CCC(CC1)(C2=CC=C(C=C2)Cl)O)(C3=CC=CC=C3)C4=CC=CC=C4|4-[4-(4-chlorophenyl)-4-hydroxypiperidin-1-yl]-N,N-dimethyl-2,2-diphenylbutanamide|5.0
+CC1OC(OC2CC(O)C3(CO)C4C(O)CC5(C)C(C6=CC(=O)OC6)CCC5(O)C4CCC3(O)C2)C(O)C(O)C1O|-1.5149999999999972|CC1OC(OC2CC(O)C3(CO)C4C(O)CC5(C)C(C6=CC(=O)OC6)CCC5(O)C4CCC3(O)C2)C(O)C(O)C1O|CC1C(C(C(C(O1)OC2CC(C3(C4C(CCC3(C2)O)C5(CCC(C5(CC4O)C)C6=CC(=O)OC6)O)CO)O)O)O)O|3-[1,5,11,14-tetrahydroxy-10-(hydroxymethyl)-13-methyl-3-(3,4,5-trihydroxy-6-methyloxan-2-yl)oxy-2,3,4,6,7,8,9,11,12,15,16,17-dodecahydro-1H-cyclopenta[a]phenanthren-17-yl]-2H-furan-5-one|-1.7
+CCN(CC)CCOc1ccc(C(O)(Cc2ccc(Cl)cc2)c2ccc(C)cc2)cc1|5.847620000000007|CCN(CC)CCOc1ccc(C(O)(Cc2ccc(Cl)cc2)c2ccc(C)cc2)cc1|CCN(CC)CCOC1=CC=C(C=C1)C(CC2=CC=C(C=C2)Cl)(C3=CC=C(C=C3)C)O|2-(4-chlorophenyl)-1-[4-[2-(diethylamino)ethoxy]phenyl]-1-(4-methylphenyl)ethanol|6.2
+COc1ccc2cc1Oc1ccc(cc1)CC1c3cc(c(OC)cc3CCN1C)Oc1c(OC)c(OC)cc3c1C(C2)N(C)CC3|7.162400000000009|COc1ccc2cc1Oc1ccc(cc1)CC1c3cc(c(OC)cc3CCN1C)Oc1c(OC)c(OC)cc3c1C(C2)N(C)CC3|CN1CCC2=CC(=C3C=C2C1CC4=CC=C(C=C4)OC5=C(C=CC(=C5)CC6C7=C(O3)C(=C(C=C7CCN6C)OC)OC)OC)OC|9,20,21,25-tetramethoxy-15,30-dimethyl-7,23-dioxa-15,30-diazaheptacyclo[22.6.2.23,6.18,12.114,18.027,31.022,33]hexatriaconta-3(36),4,6(35),8,10,12(34),18,20,22(33),24,26,31-dodecaene|6.4
+CCN(CC)Cc1cc(Nc2ccnc3cc(Cl)ccc23)ccc1O|5.179200000000004|CCN(CC)Cc1cc(Nc2ccnc3cc(Cl)ccc23)ccc1O|CCN(CC)CC1=C(C=CC(=C1)NC2=C3C=CC(=CC3=NC=C2)Cl)O|4-[(7-chloroquinolin-4-yl)amino]-2-(diethylaminomethyl)phenol|2.6
+O=C1NCN(c2ccccc2)C12CCN(CCCC(c1ccc(F)cc1)c1ccc(F)cc1)CC2|5.305400000000005|O=C1NCN(c2ccccc2)C12CCN(CCCC(c1ccc(F)cc1)c1ccc(F)cc1)CC2|C1CN(CCC12C(=O)NCN2C3=CC=CC=C3)CCCC(C4=CC=C(C=C4)F)C5=CC=C(C=C5)F|8-[4,4-bis(4-fluorophenyl)butyl]-1-phenyl-1,3,8-triazaspiro[4.5]decan-4-one|5.6
+Cc1ccc(NC(=O)c2ccc(CN3CCN(C)CC3)cc2)cc1Nc1nccc(-c2cccnc2)n1|4.590320000000004|Cc1ccc(NC(=O)c2ccc(CN3CCN(C)CC3)cc2)cc1Nc1nccc(-c2cccnc2)n1|CC1=C(C=C(C=C1)NC(=O)C2=CC=C(C=C2)CN3CCN(CC3)C)NC4=NC=CC(=N4)C5=CN=CC=C5|4-[(4-methylpiperazin-1-yl)methyl]-N-[4-methyl-3-[(4-pyridin-3-ylpyrimidin-2-yl)amino]phenyl]benzamide|3.5
+CCN(CC)CCOc1ccc2c(c1)C(=O)c1cc(OCCN(CC)CC)ccc1-2|4.339200000000004|CCN(CC)CCOc1ccc2c(c1)C(=O)c1cc(OCCN(CC)CC)ccc1-2|CCN(CC)CCOC1=CC2=C(C=C1)C3=C(C2=O)C=C(C=C3)OCCN(CC)CC|2,7-bis[2-(diethylamino)ethoxy]fluoren-9-one|4.7
+COc1cc2c3cc1Oc1c(OC)c(OC)cc4c1C(Cc1ccc(O)c(c1)Oc1ccc(cc1)CC3N(C)CC2)N(C)CC4|6.859400000000009|COc1cc2c3cc1Oc1c(OC)c(OC)cc4c1C(Cc1ccc(O)c(c1)Oc1ccc(cc1)CC3N(C)CC2)N(C)CC4|CN1CCC2=CC(=C3C=C2C1CC4=CC=C(C=C4)OC5=C(C=CC(=C5)CC6C7=C(O3)C(=C(C=C7CCN6C)OC)OC)O)OC|20,21,25-trimethoxy-15,30-dimethyl-7,23-dioxa-15,30-diazaheptacyclo[22.6.2.23,6.18,12.114,18.027,31.022,33]hexatriaconta-3(36),4,6(35),8,10,12(34),18,20,22(33),24,26,31-dodecaen-9-ol|6.1
+OC(c1cc(C(F)(F)F)nc2c(C(F)(F)F)cccc12)C1CCCCN1|4.447900000000003|OC(c1cc(C(F)(F)F)nc2c(C(F)(F)F)cccc12)C1CCCCN1|C1CCNC(C1)C(C2=CC(=NC3=C2C=CC=C3C(F)(F)F)C(F)(F)F)O|[2,8-bis(trifluoromethyl)quinolin-4-yl]-piperidin-2-ylmethanol|3.6
+OCCN1CCN(CCCN2c3ccccc3Sc3ccc(C(F)(F)F)cc32)CC1|4.308100000000003|OCCN1CCN(CCCN2c3ccccc3Sc3ccc(C(F)(F)F)cc32)CC1|C1CN(CCN1CCCN2C3=CC=CC=C3SC4=C2C=C(C=C4)C(F)(F)F)CCO|2-[4-[3-[2-(trifluoromethyl)phenothiazin-10-yl]propyl]piperazin-1-yl]ethanol|4.4
+O=C(Nc1cc(Cl)cc(Cl)c1O)c1c(O)c(Cl)cc(Cl)c1Cl|5.6171000000000015|O=C(Nc1cc(Cl)cc(Cl)c1O)c1c(O)c(Cl)cc(Cl)c1Cl|C1=C(C=C(C(=C1NC(=O)C2=C(C(=CC(=C2Cl)Cl)Cl)O)O)Cl)Cl|2,3,5-trichloro-N-(3,5-dichloro-2-hydroxyphenyl)-6-hydroxybenzamide|5.7
+CCN(CCO)CCCC(C)Nc1ccnc2cc(Cl)ccc12|3.783000000000002|CCN(CCO)CCCC(C)Nc1ccnc2cc(Cl)ccc12|CCN(CCCC(C)NC1=C2C=CC(=CC2=NC=C1)Cl)CCO|2-[4-[(7-chloroquinolin-4-yl)amino]pentyl-ethylamino]ethanol|3.6
+CC(CN1c2ccccc2Sc2ccccc21)N(C)C|4.239400000000003|CC(CN1c2ccccc2Sc2ccccc21)N(C)C|CC(CN1C2=CC=CC=C2SC3=CC=CC=C31)N(C)C|N,N-dimethyl-1-phenothiazin-10-ylpropan-2-amine|4.8
+CCSc1ccc2c(c1)N(CCCN1CCN(C)CC1)c1ccccc1S2|5.0388000000000055|CCSc1ccc2c(c1)N(CCCN1CCN(C)CC1)c1ccccc1S2|CCSC1=CC2=C(C=C1)SC3=CC=CC=C3N2CCCN4CCN(CC4)C|2-ethylsulfanyl-10-[3-(4-methylpiperazin-1-yl)propyl]phenothiazine|5.4
+CC1OC(OC2C(O)CC(OC3C(O)CC(OC4CCC5(C)C(CCC6C5CC(O)C5(C)C(C7=CC(=O)OC7)CCC65O)C4)OC3C)OC2C)CC(O)C1O|2.218100000000003|CC1OC(OC2C(O)CC(OC3C(O)CC(OC4CCC5(C)C(CCC6C5CC(O)C5(C)C(C7=CC(=O)OC7)CCC65O)C4)OC3C)OC2C)CC(O)C1O|CC1C(C(CC(O1)OC2C(OC(CC2O)OC3C(OC(CC3O)OC4CCC5(C(C4)CCC6C5CC(C7(C6(CCC7C8=CC(=O)OC8)O)C)O)C)C)C)O)O|3-[3-[5-[5-(4,5-dihydroxy-6-methyloxan-2-yl)oxy-4-hydroxy-6-methyloxan-2-yl]oxy-4-hydroxy-6-methyloxan-2-yl]oxy-12,14-dihydroxy-10,13-dimethyl-1,2,3,4,5,6,7,8,9,11,12,15,16,17-tetradecahydrocyclopenta[a]phenanthren-17-yl]-2H-furan-5-one|1.3
+CN(C)CCCN1c2ccccc2CCc2ccc(Cl)cc21|4.528400000000004|CN(C)CCCN1c2ccccc2CCc2ccc(Cl)cc21|CN(C)CCCN1C2=CC=CC=C2CCC3=C1C=C(C=C3)Cl|3-(2-chloro-5,6-dihydrobenzo[b][1]benzazepin-11-yl)-N,N-dimethylpropan-1-amine|5.2
+CN(C)CCCN1c2ccccc2Sc2ccc(Cl)cc21|4.894400000000004|CN(C)CCCN1c2ccccc2Sc2ccc(Cl)cc21|CN(C)CCCN1C2=CC=CC=C2SC3=C1C=C(C=C3)Cl|3-(2-chlorophenothiazin-10-yl)-N,N-dimethylpropan-1-amine|5.2
+CCN(CC)CCOc1ccc(C(=C(Cl)c2ccccc2)c2ccccc2)cc1|6.562600000000006|CCN(CC)CCOc1ccc(C(=C(Cl)c2ccccc2)c2ccccc2)cc1|CCN(CC)CCOC1=CC=C(C=C1)C(=C(C2=CC=CC=C2)Cl)C3=CC=CC=C3|2-[4-(2-chloro-1,2-diphenylethenyl)phenoxy]-N,N-diethylethanamine|7.2
+CCC1OC(=O)C(C)C(OC2CC(C)(OC)C(O)C(C)O2)C(C)C(OC2OC(C)CC(N(C)C)C2O)C(C)(O)CC(C)CN(C)C(C)C(O)C1(C)O|1.9007000000000054|CCC1OC(=O)C(C)C(OC2CC(C)(OC)C(O)C(C)O2)C(C)C(OC2OC(C)CC(N(C)C)C2O)C(C)(O)CC(C)CN(C)C(C)C(O)C1(C)O|CCC1C(C(C(N(CC(CC(C(C(C(C(C(=O)O1)C)OC2CC(C(C(O2)C)O)(C)OC)C)OC3C(C(CC(O3)C)N(C)C)O)(C)O)C)C)C)O)(C)O|11-[4-(dimethylamino)-3-hydroxy-6-methyloxan-2-yl]oxy-2-ethyl-3,4,10-trihydroxy-13-(5-hydroxy-4-methoxy-4,6-dimethyloxan-2-yl)oxy-3,5,6,8,10,12,14-heptamethyl-1-oxa-6-azacyclopentadecan-15-one|4.0
+COc1ncnc(NS(=O)(=O)c2ccc(N)cc2)c1OC|0.8768|COc1ncnc(NS(=O)(=O)c2ccc(N)cc2)c1OC|COC1=C(N=CN=C1OC)NS(=O)(=O)C2=CC=C(C=C2)N|4-amino-N-(5,6-dimethoxypyrimidin-4-yl)benzenesulfonamide|0.7
+COc1ccc2nc(S(=O)Cc3ncc(C)c(OC)c3C)[nH]c2c1|2.8997400000000004|COc1ccc2nc(S(=O)Cc3ncc(C)c(OC)c3C)[nH]c2c1|CC1=CN=C(C(=C1OC)C)CS(=O)C2=NC3=C(N2)C=C(C=C3)OC|6-methoxy-2-[(4-methoxy-3,5-dimethylpyridin-2-yl)methylsulfinyl]-1H-benzimidazole|2.2
+CN(C)CCOc1ccc(C(=C(CCCl)c2ccccc2)c2ccccc2)cc1|6.215000000000006|CN(C)CCOc1ccc(C(=C(CCCl)c2ccccc2)c2ccccc2)cc1|CN(C)CCOC1=CC=C(C=C1)C(=C(CCCl)C2=CC=CC=C2)C3=CC=CC=C3|2-[4-(4-chloro-1,2-diphenylbut-1-enyl)phenoxy]-N,N-dimethylethanamine|7.2
+CSc1ccc2c(c1)N(CCC1CCCCN1C)c1ccccc1S2|5.885600000000005|CSc1ccc2c(c1)N(CCC1CCCCN1C)c1ccccc1S2|CN1CCCCC1CCN2C3=CC=CC=C3SC4=C2C=C(C=C4)SC|10-[2-(1-methylpiperidin-2-yl)ethyl]-2-methylsulfanylphenothiazine|5.9
+CC=CCC(C)C(O)C1C(=O)NC(CC)C(=O)N(C)CC(=O)N(C)C(CC(C)C)C(=O)NC(C(C)C)C(=O)N(C)C(CC(C)C)C(=O)NC(C)C(=O)NC(C)C(=O)N(C)C(CC(C)C)C(=O)N(C)C(CC(C)C)C(=O)N(C)C(C(C)C)C(=O)N1C|3.2690000000000046|CC=CCC(C)C(O)C1C(=O)NC(CC)C(=O)N(C)CC(=O)N(C)C(CC(C)C)C(=O)NC(C(C)C)C(=O)N(C)C(CC(C)C)C(=O)NC(C)C(=O)NC(C)C(=O)N(C)C(CC(C)C)C(=O)N(C)C(CC(C)C)C(=O)N(C)C(C(C)C)C(=O)N1C|CCC1C(=O)N(CC(=O)N(C(C(=O)NC(C(=O)N(C(C(=O)NC(C(=O)NC(C(=O)N(C(C(=O)N(C(C(=O)N(C(C(=O)N(C(C(=O)N1)C(C(C)CC=CC)O)C)C(C)C)C)CC(C)C)C)CC(C)C)C)C)C)CC(C)C)C)C(C)C)CC(C)C)C)C|30-ethyl-33-(1-hydroxy-2-methylhex-4-enyl)-1,4,7,10,12,15,19,25,28-nonamethyl-6,9,18,24-tetrakis(2-methylpropyl)-3,21-di(propan-2-yl)-1,4,7,10,13,16,19,22,25,28,31-undecazacyclotritriacontane-2,5,8,11,14,17,20,23,26,29,32-undecone|7.5
+CC(C)=CCCC1(C)C=Cc2c(O)c3c(c(CC=C(C)C)c2O1)OC12C(=CC4CC1C(C)(C)OC2(CC=C(C)C(=O)O)C4O)C3=O|7.031100000000008|CC(C)=CCCC1(C)C=Cc2c(O)c3c(c(CC=C(C)C)c2O1)OC12C(=CC4CC1C(C)(C)OC2(CC=C(C)C(=O)O)C4O)C3=O|CC(=CCCC1(C=CC2=C(C3=C(C(=C2O1)CC=C(C)C)OC45C6CC(C=C4C3=O)C(C5(OC6(C)C)CC=C(C)C(=O)O)O)O)C)C|4-[12,18-dihydroxy-8,21,21-trimethyl-5-(3-methylbut-2-enyl)-8-(4-methylpent-3-enyl)-14-oxo-3,7,20-trioxahexacyclo[15.4.1.02,15.02,19.04,13.06,11]docosa-4(13),5,9,11,15-pentaen-19-yl]-2-methylbut-2-enoic acid|7.0
+C=CC1CN2CCC1CC2C(O)c1ccnc2ccc(OC)cc12|3.1732000000000014|C=CC1CN2CCC1CC2C(O)c1ccnc2ccc(OC)cc12|COC1=CC2=C(C=CN=C2C=C1)C(C3CC4CCN3CC4C=C)O|(5-ethenyl-1-azabicyclo[2.2.2]octan-2-yl)-(6-methoxyquinolin-4-yl)methanol|2.9
+CCCCCC(=O)OC1(C(C)=O)CCC2C3CCC4=CC(=O)CCC4(C)C3CCC21C|5.969600000000007|CCCCCC(=O)OC1(C(C)=O)CCC2C3CCC4=CC(=O)CCC4(C)C3CCC21C|CCCCCC(=O)OC1(CCC2C1(CCC3C2CCC4=CC(=O)CCC34C)C)C(=O)C|(17-acetyl-10,13-dimethyl-3-oxo-2,6,7,8,9,11,12,14,15,16-decahydro-1H-cyclopenta[a]phenanthren-17-yl) hexanoate|5.7
+COc1ccc2cc1Oc1ccc(cc1)CC1c3c(cc4c(c3Oc3cc5c(cc3OC)CCN(C)C5C2)OCO4)CCN1C|6.873900000000009|COc1ccc2cc1Oc1ccc(cc1)CC1c3c(cc4c(c3Oc3cc5c(cc3OC)CCN(C)C5C2)OCO4)CCN1C|CN1CCC2=CC3=C(C4=C2C1CC5=CC=C(C=C5)OC6=C(C=CC(=C6)CC7C8=CC(=C(C=C8CCN7C)OC)O4)OC)OCO3|22,33-dimethoxy-13,28-dimethyl-2,5,7,20-tetraoxa-13,28-diazaoctacyclo[25.6.2.216,19.13,10.121,25.04,8.031,35.014,39]nonatriaconta-1(33),3(39),4(8),9,16(38),17,19(37),21,23,25(36),31,34-dodecaene|6.5
+CCC(=C(c1ccccc1)c1ccc(OCCN(C)C)cc1)c1ccccc1|5.9961000000000055|CCC(=C(c1ccccc1)c1ccc(OCCN(C)C)cc1)c1ccccc1|CCC(=C(C1=CC=CC=C1)C2=CC=C(C=C2)OCCN(C)C)C3=CC=CC=C3|2-[4-(1,2-diphenylbut-1-enyl)phenoxy]-N,N-dimethylethanamine|7.1
+OC1(c2ccc(Cl)c(C(F)(F)F)c2)CCN(CCCC(c2ccc(F)cc2)c2ccc(F)cc2)CC1|7.532700000000006|OC1(c2ccc(Cl)c(C(F)(F)F)c2)CCN(CCCC(c2ccc(F)cc2)c2ccc(F)cc2)CC1|C1CN(CCC1(C2=CC(=C(C=C2)Cl)C(F)(F)F)O)CCCC(C3=CC=C(C=C3)F)C4=CC=C(C=C4)F|1-[4,4-bis(4-fluorophenyl)butyl]-4-[4-chloro-3-(trifluoromethyl)phenyl]piperidin-4-ol|7.3
+Clc1ccc(Cn2c(CN3CCCC3)nc3ccccc32)cc1|4.333800000000003|Clc1ccc(Cn2c(CN3CCCC3)nc3ccccc32)cc1|C1CCN(C1)CC2=NC3=CC=CC=C3N2CC4=CC=C(C=C4)Cl|1-[(4-chlorophenyl)methyl]-2-(pyrrolidin-1-ylmethyl)benzimidazole|4.0
+C1CCC(C(CC2CCCCN2)C2CCCCC2)CC1|5.295400000000005|C1CCC(C(CC2CCCCN2)C2CCCCC2)CC1|C1CCC(CC1)C(CC2CCCCN2)C3CCCCC3|2-(2,2-dicyclohexylethyl)piperidine|6.8
+Oc1c(Cl)cc(Cl)c(Cl)c1Cc1c(O)c(Cl)cc(Cl)c1Cl|6.609000000000001|Oc1c(Cl)cc(Cl)c(Cl)c1Cc1c(O)c(Cl)cc(Cl)c1Cl|C1=C(C(=C(C(=C1Cl)Cl)CC2=C(C(=CC(=C2Cl)Cl)Cl)O)O)Cl|3,4,6-trichloro-2-[(2,3,5-trichloro-6-hydroxyphenyl)methyl]phenol|7.5
+CCC(C(=O)O)C1CCC(C)C(C(C)C(O)C(C)C(=O)C(CC)C2OC3(C=CC(O)C4(CCC(C)(C5CCC(O)(CC)C(C)O5)O4)O3)C(C)CC2C)O1|6.188000000000006|CCC(C(=O)O)C1CCC(C)C(C(C)C(O)C(C)C(=O)C(CC)C2OC3(C=CC(O)C4(CCC(C)(C5CCC(O)(CC)C(C)O5)O4)O3)C(C)CC2C)O1|CCC(C1CCC(C(O1)C(C)C(C(C)C(=O)C(CC)C2C(CC(C3(O2)C=CC(C4(O3)CCC(O4)(C)C5CCC(C(O5)C)(CC)O)O)C)C)O)C)C(=O)O|2-[6-[6-[3-(5-ethyl-5-hydroxy-6-methyloxan-2-yl)-15-hydroxy-3,10,12-trimethyl-4,6,8-trioxadispiro[4.1.57.35]pentadec-13-en-9-yl]-3-hydroxy-4-methyl-5-oxooctan-2-yl]-5-methyloxan-2-yl]butanoic acid|5.7
+Cc1cc(Nc2ncc(Cl)c(Nc3ccccc3S(=O)(=O)C(C)C)n2)c(OC(C)C)cc1C1CCNCC1|6.361920000000006|Cc1cc(Nc2ncc(Cl)c(Nc3ccccc3S(=O)(=O)C(C)C)n2)c(OC(C)C)cc1C1CCNCC1|CC1=CC(=C(C=C1C2CCNCC2)OC(C)C)NC3=NC=C(C(=N3)NC4=CC=CC=C4S(=O)(=O)C(C)C)Cl|5-chloro-2-N-(5-methyl-4-piperidin-4-yl-2-propan-2-yloxyphenyl)-4-N-(2-propan-2-ylsulfonylphenyl)pyrimidine-2,4-diamine|6.4
+CC1(C)C=Cc2c(c3c(c4c(=O)c(-c5ccc(O)cc5)coc24)OC(C)(C)CC3)O1|5.453400000000006|CC1(C)C=Cc2c(c3c(c4c(=O)c(-c5ccc(O)cc5)coc24)OC(C)(C)CC3)O1|CC1(CCC2=C3C(=C4C(=C2O1)C(=O)C(=CO4)C5=CC=C(C=C5)O)C=CC(O3)(C)C)C|5-(4-hydroxyphenyl)-10,10,16,16-tetramethyl-3,9,15-trioxatetracyclo[12.4.0.02,7.08,13]octadeca-1,4,7,13,17-pentaen-6-one|4.7
+C=CC(=O)Nc1cc(Nc2nccc(-c3cn(C)c4ccccc34)n2)c(OC)cc1N(C)CCN(C)C|4.509800000000003|C=CC(=O)Nc1cc(Nc2nccc(-c3cn(C)c4ccccc34)n2)c(OC)cc1N(C)CCN(C)C|CN1C=C(C2=CC=CC=C21)C3=NC(=NC=C3)NC4=C(C=C(C(=C4)NC(=O)C=C)N(C)CCN(C)C)OC|N-[2-[2-(dimethylamino)ethyl-methylamino]-4-methoxy-5-[[4-(1-methylindol-3-yl)pyrimidin-2-yl]amino]phenyl]prop-2-enamide|3.7
+Cc1c(-c2ccc(O)cc2)n(Cc2ccc(OCCN3CCCCCC3)cc2)c2ccc(O)cc12|6.331020000000006|Cc1c(-c2ccc(O)cc2)n(Cc2ccc(OCCN3CCCCCC3)cc2)c2ccc(O)cc12|CC1=C(N(C2=C1C=C(C=C2)O)CC3=CC=C(C=C3)OCCN4CCCCCC4)C5=CC=C(C=C5)O|1-[[4-[2-(azepan-1-yl)ethoxy]phenyl]methyl]-2-(4-hydroxyphenyl)-3-methylindol-5-ol|6.1
+CCCCCCOC(C)c1cccc(-c2csc(NC(=O)c3cc(Cl)c(C=C(C)C(=O)O)c(Cl)c3)n2)c1OC|8.523600000000004|CCCCCCOC(C)c1cccc(-c2csc(NC(=O)c3cc(Cl)c(C=C(C)C(=O)O)c(Cl)c3)n2)c1OC|CCCCCCOC(C)C1=CC=CC(=C1OC)C2=CSC(=N2)NC(=O)C3=CC(=C(C(=C3)Cl)C=C(C)C(=O)O)Cl|3-[2,6-dichloro-4-[[4-[3-(1-hexoxyethyl)-2-methoxyphenyl]-1,3-thiazol-2-yl]carbamoyl]phenyl]-2-methylprop-2-enoic acid|7.7
+CC(C)=CCc1c2c(c3occ(-c4ccc(O)cc4)c(=O)c3c1O)C=CC(C)(C)O2|5.564100000000006|CC(C)=CCc1c2c(c3occ(-c4ccc(O)cc4)c(=O)c3c1O)C=CC(C)(C)O2|CC(=CCC1=C2C(=C3C(=C1O)C(=O)C(=CO3)C4=CC=C(C=C4)O)C=CC(O2)(C)C)C|5-hydroxy-3-(4-hydroxyphenyl)-8,8-dimethyl-6-(3-methylbut-2-enyl)pyrano[2,3-h]chromen-4-one|5.9
+CCCCc1oc2ccc(NS(C)(=O)=O)cc2c1C(=O)c1ccc(OCCCN(CCCC)CCCC)cc1|7.0490000000000075|CCCCc1oc2ccc(NS(C)(=O)=O)cc2c1C(=O)c1ccc(OCCCN(CCCC)CCCC)cc1|CCCCC1=C(C2=C(O1)C=CC(=C2)NS(=O)(=O)C)C(=O)C3=CC=C(C=C3)OCCCN(CCCC)CCCC|N-[2-butyl-3-[4-[3-(dibutylamino)propoxy]benzoyl]-1-benzofuran-5-yl]methanesulfonamide|7.2
+CC(C)C(=O)OCC(=O)C12OC(C3CCCCC3)OC1CC1C3CCC4=CC(=O)C=CC4(C)C3C(O)CC12C|4.703900000000005|CC(C)C(=O)OCC(=O)C12OC(C3CCCCC3)OC1CC1C3CCC4=CC(=O)C=CC4(C)C3C(O)CC12C|CC(C)C(=O)OCC(=O)C12C(CC3C1(CC(C4C3CCC5=CC(=O)C=CC45C)O)C)OC(O2)C6CCCCC6|[2-(6-cyclohexyl-11-hydroxy-9,13-dimethyl-16-oxo-5,7-dioxapentacyclo[10.8.0.02,9.04,8.013,18]icosa-14,17-dien-8-yl)-2-oxoethyl] 2-methylpropanoate|5.3
+CC1(C)C=Cc2c(c3c(c4c(=O)c(-c5ccc(O)c(O)c5)coc24)OC(C)(C)CC3)O1|5.159000000000005|CC1(C)C=Cc2c(c3c(c4c(=O)c(-c5ccc(O)c(O)c5)coc24)OC(C)(C)CC3)O1|CC1(CCC2=C3C(=C4C(=C2O1)C(=O)C(=CO4)C5=CC(=C(C=C5)O)O)C=CC(O3)(C)C)C|5-(3,4-dihydroxyphenyl)-10,10,16,16-tetramethyl-3,9,15-trioxatetracyclo[12.4.0.02,7.08,13]octadeca-1,4,7,13,17-pentaen-6-one|4.4
+CCCCCOc1ccc(-c2ccc(-c3ccc(C(=O)NC4CC(O)C(O)NC(=O)C5C(O)C(C)CN5C(=O)C(C(C)O)NC(=O)C(C(O)C(O)c5ccc(O)cc5)NC(=O)C5CC(O)CN5C(=O)C(C(C)O)NC4=O)cc3)cc2)cc1|-0.927099999999986|CCCCCOc1ccc(-c2ccc(-c3ccc(C(=O)NC4CC(O)C(O)NC(=O)C5C(O)C(C)CN5C(=O)C(C(C)O)NC(=O)C(C(O)C(O)c5ccc(O)cc5)NC(=O)C5CC(O)CN5C(=O)C(C(C)O)NC4=O)cc3)cc2)cc1|CCCCCOC1=CC=C(C=C1)C2=CC=C(C=C2)C3=CC=C(C=C3)C(=O)NC4CC(C(NC(=O)C5C(C(CN5C(=O)C(NC(=O)C(NC(=O)C6CC(CN6C(=O)C(NC4=O)C(C)O)O)C(C(C7=CC=C(C=C7)O)O)O)C(C)O)C)O)O)O|N-[6-[1,2-dihydroxy-2-(4-hydroxyphenyl)ethyl]-11,20,21,25-tetrahydroxy-3,15-bis(1-hydroxyethyl)-26-methyl-2,5,8,14,17,23-hexaoxo-1,4,7,13,16,22-hexazatricyclo[22.3.0.09,13]heptacosan-18-yl]-4-[4-(4-pentoxyphenyl)phenyl]benzamide|2.3
+CC(C)(C)c1cc(C(C)(C)C)c(NC(=O)c2c[nH]c3ccccc3c2=O)cc1O|5.081000000000005|CC(C)(C)c1cc(C(C)(C)C)c(NC(=O)c2c[nH]c3ccccc3c2=O)cc1O|CC(C)(C)C1=CC(=C(C=C1NC(=O)C2=CNC3=CC=CC=C3C2=O)O)C(C)(C)C|N-(2,4-ditert-butyl-5-hydroxyphenyl)-4-oxo-1H-quinoline-3-carboxamide|5.6
+CCC(=C(c1ccc(OCCN(C)C)cc1)c1cccc(O)c1)c1ccccc1|5.701700000000006|CCC(=C(c1ccc(OCCN(C)C)cc1)c1cccc(O)c1)c1ccccc1|CCC(=C(C1=CC=C(C=C1)OCCN(C)C)C2=CC(=CC=C2)O)C3=CC=CC=C3|3-[1-[4-[2-(dimethylamino)ethoxy]phenyl]-2-phenylbut-1-enyl]phenol|6.8
+CCN1CCN(Cc2ccc(Nc3ncc(F)c(-c4cc(F)c5nc(C)n(C(C)C)c5c4)n3)nc2)CC1|4.936920000000004|CCN1CCN(Cc2ccc(Nc3ncc(F)c(-c4cc(F)c5nc(C)n(C(C)C)c5c4)n3)nc2)CC1|CCN1CCN(CC1)CC2=CN=C(C=C2)NC3=NC=C(C(=N3)C4=CC5=C(C(=C4)F)N=C(N5C(C)C)C)F|N-[5-[(4-ethylpiperazin-1-yl)methyl]pyridin-2-yl]-5-fluoro-4-(7-fluoro-2-methyl-3-propan-2-ylbenzimidazol-5-yl)pyrimidin-2-amine|3.8
+CCc1nc(C(N)=O)c(Nc2ccc(N3CCC(N4CCN(C)CC4)CC3)c(OC)c2)nc1NC1CCOCC1|2.6972000000000014|CCc1nc(C(N)=O)c(Nc2ccc(N3CCC(N4CCN(C)CC4)CC3)c(OC)c2)nc1NC1CCOCC1|CCC1=C(N=C(C(=N1)C(=O)N)NC2=CC(=C(C=C2)N3CCC(CC3)N4CCN(CC4)C)OC)NC5CCOCC5|6-ethyl-3-[3-methoxy-4-[4-(4-methylpiperazin-1-yl)piperidin-1-yl]anilino]-5-(oxan-4-ylamino)pyrazine-2-carboxamide|3.5
+CC(C)(C)c1ccc(C(=O)CCCN2CCC(OC(c3ccccc3)c3ccccc3)CC2)cc1|7.217600000000008|CC(C)(C)c1ccc(C(=O)CCCN2CCC(OC(c3ccccc3)c3ccccc3)CC2)cc1|CC(C)(C)C1=CC=C(C=C1)C(=O)CCCN2CCC(CC2)OC(C3=CC=CC=C3)C4=CC=CC=C4|4-(4-benzhydryloxypiperidin-1-yl)-1-(4-tert-butylphenyl)butan-1-one|7.2
+c1ccc2c(c1)Sc1ccccc1N2CC1CN2CCC1CC2|4.631100000000005|c1ccc2c(c1)Sc1ccccc1N2CC1CN2CCC1CC2|C1CN2CCC1C(C2)CN3C4=CC=CC=C4SC5=CC=CC=C53|10-(1-azabicyclo[2.2.2]octan-3-ylmethyl)phenothiazine|4.6
+CC1=NN(c2ccc(C)c(C)c2)C(=O)C1=NNc1cccc(-c2cccc(C(=O)O)c2)c1O|4.564840000000005|CC1=NN(c2ccc(C)c(C)c2)C(=O)C1=NNc1cccc(-c2cccc(C(=O)O)c2)c1O|CC1=C(C=C(C=C1)N2C(=O)C(=C(N2)C)N=NC3=CC=CC(=C3O)C4=CC(=CC=C4)C(=O)O)C|3-[3-[[2-(3,4-dimethylphenyl)-5-methyl-3-oxo-1H-pyrazol-4-yl]diazenyl]-2-hydroxyphenyl]benzoic acid|5.4
+COC(=O)NC(C(=O)NC(Cc1ccccc1)C(O)CN(Cc1ccc(-c2ccccn2)cc1)NC(=O)C(NC(=O)OC)C(C)(C)C)C(C)(C)C|4.2116000000000025|COC(=O)NC(C(=O)NC(Cc1ccccc1)C(O)CN(Cc1ccc(-c2ccccn2)cc1)NC(=O)C(NC(=O)OC)C(C)(C)C)C(C)(C)C|CC(C)(C)C(C(=O)NC(CC1=CC=CC=C1)C(CN(CC2=CC=C(C=C2)C3=CC=CC=N3)NC(=O)C(C(C)(C)C)NC(=O)OC)O)NC(=O)OC|methyl N-[1-[2-[2-hydroxy-3-[[2-(methoxycarbonylamino)-3,3-dimethylbutanoyl]amino]-4-phenylbutyl]-2-[(4-pyridin-2-ylphenyl)methyl]hydrazinyl]-3,3-dimethyl-1-oxobutan-2-yl]carbamate|5.6
+CN1C2CCC1CC(OC(c1ccccc1)c1ccccc1)C2|4.417800000000004|CN1C2CCC1CC(OC(c1ccccc1)c1ccccc1)C2|CN1C2CCC1CC(C2)OC(C3=CC=CC=C3)C4=CC=CC=C4|3-benzhydryloxy-8-methyl-8-azabicyclo[3.2.1]octane|4.5
+CC(C)N1CCN(c2ccc(OCC3COC(Cn4cncn4)(c4ccc(Cl)cc4Cl)O3)cc2)CC1|4.462700000000003|CC(C)N1CCN(c2ccc(OCC3COC(Cn4cncn4)(c4ccc(Cl)cc4Cl)O3)cc2)CC1|CC(C)N1CCN(CC1)C2=CC=C(C=C2)OCC3COC(O3)(CN4C=NC=N4)C5=C(C=C(C=C5)Cl)Cl|1-[4-[[2-(2,4-dichlorophenyl)-2-(1,2,4-triazol-1-ylmethyl)-1,3-dioxolan-4-yl]methoxy]phenyl]-4-propan-2-ylpiperazine|4.8
+C=CCOc1ccccc1OCC(O)CNC(C)C|1.9890999999999999|C=CCOc1ccccc1OCC(O)CNC(C)C|CC(C)NCC(COC1=CC=CC=C1OCC=C)O|1-(propan-2-ylamino)-3-(2-prop-2-enoxyphenoxy)propan-2-ol|2.1
+CCCCCC(O)C=CC1C(O)CC(=O)C1CCCCCCC(=O)O|3.475100000000002|CCCCCC(O)C=CC1C(O)CC(=O)C1CCCCCCC(=O)O|CCCCCC(C=CC1C(CC(=O)C1CCCCCCC(=O)O)O)O|7-[3-hydroxy-2-(3-hydroxyoct-1-enyl)-5-oxocyclopentyl]heptanoic acid|3.2
+CC1CCOC2Cn3cc(C(=O)NCc4ccc(F)cc4F)c(=O)c(O)c3C(=O)N12|1.3528|CC1CCOC2Cn3cc(C(=O)NCc4ccc(F)cc4F)c(=O)c(O)c3C(=O)N12|CC1CCOC2N1C(=O)C3=C(C(=O)C(=CN3C2)C(=O)NCC4=C(C=C(C=C4)F)F)O|N-[(2,4-difluorophenyl)methyl]-11-hydroxy-7-methyl-9,12-dioxo-4-oxa-1,8-diazatricyclo[8.4.0.03,8]tetradeca-10,13-diene-13-carboxamide|2.4
+OCCN1CCN(CCCN2c3ccccc3C=Cc3ccccc32)CC1|3.308500000000002|OCCN1CCN(CCCN2c3ccccc3C=Cc3ccccc32)CC1|C1CN(CCN1CCCN2C3=CC=CC=C3C=CC4=CC=CC=C42)CCO|2-[4-(3-benzo[b][1]benzazepin-11-ylpropyl)piperazin-1-yl]ethanol|3.6
+CCOC(=O)c1c(CSc2ccccc2)n(C)c2cc(Br)c(O)c(CN(C)C)c12|5.177000000000005|CCOC(=O)c1c(CSc2ccccc2)n(C)c2cc(Br)c(O)c(CN(C)C)c12|CCOC(=O)C1=C(N(C2=CC(=C(C(=C21)CN(C)C)O)Br)C)CSC3=CC=CC=C3|ethyl 6-bromo-4-[(dimethylamino)methyl]-5-hydroxy-1-methyl-2-(phenylsulfanylmethyl)indole-3-carboxylate|4.4
+CC(C)c1nc(CN(C)C(=O)NC(C(=O)NC(Cc2ccccc2)CC(O)C(Cc2ccccc2)NC(=O)OCc2cncs2)C(C)C)cs1|5.905200000000005|CC(C)c1nc(CN(C)C(=O)NC(C(=O)NC(Cc2ccccc2)CC(O)C(Cc2ccccc2)NC(=O)OCc2cncs2)C(C)C)cs1|CC(C)C1=NC(=CS1)CN(C)C(=O)NC(C(C)C)C(=O)NC(CC2=CC=CC=C2)CC(C(CC3=CC=CC=C3)NC(=O)OCC4=CN=CS4)O|1,3-thiazol-5-ylmethyl N-[3-hydroxy-5-[[3-methyl-2-[[methyl-[(2-propan-2-yl-1,3-thiazol-4-yl)methyl]carbamoyl]amino]butanoyl]amino]-1,6-diphenylhexan-2-yl]carbamate|6.0
+Cc1c(O)cccc1C(=O)NC(CSc1ccccc1)C(O)CN1CC2CCCCC2CC1C(=O)NC(C)(C)C|4.747620000000004|Cc1c(O)cccc1C(=O)NC(CSc1ccccc1)C(O)CN1CC2CCCCC2CC1C(=O)NC(C)(C)C|CC1=C(C=CC=C1O)C(=O)NC(CSC2=CC=CC=C2)C(CN3CC4CCCCC4CC3C(=O)NC(C)(C)C)O|N-tert-butyl-2-[2-hydroxy-3-[(3-hydroxy-2-methylbenzoyl)amino]-4-phenylsulfanylbutyl]-3,4,4a,5,6,7,8,8a-octahydro-1H-isoquinoline-3-carboxamide|5.7
+CC(C)(C)NC(=O)C1CC2CCCCC2CN1CC(O)C(Cc1ccccc1)NC(=O)C(CC(N)=O)NC(=O)c1ccc2ccccc2n1|3.092400000000003|CC(C)(C)NC(=O)C1CC2CCCCC2CN1CC(O)C(Cc1ccccc1)NC(=O)C(CC(N)=O)NC(=O)c1ccc2ccccc2n1|CC(C)(C)NC(=O)C1CC2CCCCC2CN1CC(C(CC3=CC=CC=C3)NC(=O)C(CC(=O)N)NC(=O)C4=NC5=CC=CC=C5C=C4)O|N-[4-[3-(tert-butylcarbamoyl)-3,4,4a,5,6,7,8,8a-octahydro-1H-isoquinolin-2-yl]-3-hydroxy-1-phenylbutan-2-yl]-2-(quinoline-2-carbonylamino)butanediamide|4.2
+CCCC1(CCc2ccccc2)CC(O)=C(C(CC)c2cccc(NS(=O)(=O)c3ccc(C(F)(F)F)cn3)c2)C(=O)O1|7.325500000000007|CCCC1(CCc2ccccc2)CC(O)=C(C(CC)c2cccc(NS(=O)(=O)c3ccc(C(F)(F)F)cn3)c2)C(=O)O1|CCCC1(CC(=C(C(=O)O1)C(CC)C2=CC(=CC=C2)NS(=O)(=O)C3=NC=C(C=C3)C(F)(F)F)O)CCC4=CC=CC=C4|N-[3-[1-[4-hydroxy-6-oxo-2-(2-phenylethyl)-2-propyl-3H-pyran-5-yl]propyl]phenyl]-5-(trifluoromethyl)pyridine-2-sulfonamide|7.0
+CC(C)CN(CC(O)C(Cc1ccccc1)NC(=O)OC1CCOC1)S(=O)(=O)c1ccc(N)cc1|2.4028|CC(C)CN(CC(O)C(Cc1ccccc1)NC(=O)OC1CCOC1)S(=O)(=O)c1ccc(N)cc1|CC(C)CN(CC(C(CC1=CC=CC=C1)NC(=O)OC2CCOC2)O)S(=O)(=O)C3=CC=C(C=C3)N|oxolan-3-yl N-[4-[(4-aminophenyl)sulfonyl-(2-methylpropyl)amino]-3-hydroxy-1-phenylbutan-2-yl]carbamate|2.9
+CC(C)CN(CC(O)C(Cc1ccccc1)NC(=O)OC1COC2OCCC12)S(=O)(=O)c1ccc(N)cc1|2.3753|CC(C)CN(CC(O)C(Cc1ccccc1)NC(=O)OC1COC2OCCC12)S(=O)(=O)c1ccc(N)cc1|CC(C)CN(CC(C(CC1=CC=CC=C1)NC(=O)OC2COC3C2CCO3)O)S(=O)(=O)C4=CC=C(C=C4)N|2,3,3a,4,5,6a-hexahydrofuro[2,3-b]furan-4-yl N-[4-[(4-aminophenyl)sulfonyl-(2-methylpropyl)amino]-3-hydroxy-1-phenylbutan-2-yl]carbamate|2.9
+CC(C)(C)NC(=O)C1CN(Cc2cccnc2)CCN1CC(O)CC(Cc1ccccc1)C(=O)NC1c2ccccc2CC1O|2.8669000000000016|CC(C)(C)NC(=O)C1CN(Cc2cccnc2)CCN1CC(O)CC(Cc1ccccc1)C(=O)NC1c2ccccc2CC1O|CC(C)(C)NC(=O)C1CN(CCN1CC(CC(CC2=CC=CC=C2)C(=O)NC3C(CC4=CC=CC=C34)O)O)CC5=CN=CC=C5|1-[4-benzyl-2-hydroxy-5-[(2-hydroxy-2,3-dihydro-1H-inden-1-yl)amino]-5-oxopentyl]-N-tert-butyl-4-(pyridin-3-ylmethyl)piperazine-2-carboxamide|2.8

TransAntivirus/download_pubchem/opsin-master.zip

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

TransAntivirus/download_pubchem/opsin-master/.github/workflows/maven.yml

@@ -0,0 +1,29 @@
+# This workflow will build a Java project with Maven
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
+
+name: Java CI with Maven
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    strategy:
+      matrix:
+        # test against latest update of each major Java version:
+        java: [ 8, 11, 17 ]
+    name: Java ${{ matrix.java }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v1
+        with:
+          path: ~/.m2/repository
+          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+          restore-keys: |
+            ${{ runner.os }}-maven-
+      - name: Setup java
+        uses: actions/setup-java@v1
+        with:
+          java-version: ${{ matrix.java }}
+      - name: Build with Maven
+        run: mvn -B clean test javadoc:javadoc package assembly:assembly

TransAntivirus/download_pubchem/opsin-master/.gitignore

@@ -0,0 +1,5 @@
+target/
+opsin-cli/src/main/java/dl/
+.classpath
+.project
+.settings

TransAntivirus/download_pubchem/opsin-master/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright 2017 Daniel Lowe
+
+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.

TransAntivirus/download_pubchem/opsin-master/README.md

@@ -0,0 +1,186 @@
+OPSIN - Open Parser for Systematic IUPAC Nomenclature
+=====================================================
+__Version 2.5.0 (see ReleaseNotes.txt for what's new in this version)__  
+__Source code: <https://github.com/dan2097/opsin>__  
+__Web interface and informational site: <http://opsin.ch.cam.ac.uk/>__  
+__License: [MIT License](https://opensource.org/licenses/MIT)__  
+
+OPSIN is a Java library for IUPAC name-to-structure conversion offering high recall and precision on organic chemical nomenclature. 
+
+Java 7 (or higher) is required for OPSIN 2.5.0 
+
+Supported outputs are SMILES, CML (Chemical Markup Language) and InChI (IUPAC International Chemical Identifier)
+
+### Simple Usage Examples
+#### Convert a chemical name to SMILES
+`java -jar opsin-2.5.0-jar-with-dependencies.jar -osmi input.txt output.txt`  
+where input.txt contains chemical name/s, one per line
+
+    NameToStructure nts = NameToStructure.getInstance();
+    String smiles = nts.parseToSmiles("acetonitrile");
+
+#### Convert a chemical name to CML
+`java -jar opsin-2.5.0-jar-with-dependencies.jar -ocml input.txt output.txt`  
+where input.txt contains chemical name/s, one per line
+
+    NameToStructure nts = NameToStructure.getInstance();
+    String cml = nts.parseToCML("acetonitrile");
+
+#### Convert a chemical name to StdInChI/StdInChIKey/InChI with FixedH 
+`java -jar opsin-2.5.0-jar-with-dependencies.jar -ostdinchi input.txt output.txt`  
+`java -jar opsin-2.5.0-jar-with-dependencies.jar -ostdinchikey input.txt output.txt`  
+`java -jar opsin-2.5.0-jar-with-dependencies.jar -oinchi input.txt output.txt`  
+where input.txt contains chemical name/s, one per line
+
+    NameToInchi nti = new NameToInchi()
+    String stdinchi = nti.parseToStdInchi("acetonitrile");
+    String stdinchikey = nti.parseToStdInchiKey("acetonitrile");
+    String inchi = nti.parseToInchi("acetonitrile");
+
+NOTE: OPSIN's non-standard InChI includes an additional layer (FixedH) that indicates which tautomer the chemical name described. StdInChI aims to be tautomer independent.
+### Advanced Usage
+OPSIN 2.5.0 allows enabling of the following options:
+
+* allowRadicals: Allows substituents to be interpretable e.g. allows interpretation of "ethyl"
+* wildcardRadicals: If allowRadicals is enabled, this option uses atoms in the output to represent radicals: 'R' in CML and '*' in SMILES e.g. changes the output of ethyl from C[CH2] to CC\*
+* detailedFailureAnalysis: Provides a potentially more accurate reason as to why a chemical name could not be parsed. This is done by parsing the chemical name from right to left. The trade-off for enabling this is slightly increased memory usage.
+* allowAcidsWithoutAcid: Allows interpretation of acids without the word acid e.g. "acetic"
+* allowUninterpretableStereo: Allows stereochemistry uninterpretable by OPSIN to be ignored (When used as a library the OpsinResult has a status of WARNING if stereochemistry was ignored)
+* verbose: Enables debugging output\*
+
+\*When used as a library this is done by modifying Log4J's logging level e.g. `Logger.getLogger("uk.ac.cam.ch.wwmm.opsin").setLevel(Level.DEBUG);`
+
+The usage of these options on the command line is described in the command line's help dialog accessible via:
+`java -jar opsin-2.5.0-jar-with-dependencies.jar -h`
+
+These options may be controlled using the following code:
+
+    NameToStructure nts = NameToStructure.getInstance();
+    NameToStructureConfig ntsconfig = new NameToStructureConfig();
+    //a new NameToStructureConfig starts as a copy of OPSIN's default configuration
+    ntsconfig.setAllowRadicals(true);
+    OpsinResult result = nts.parseChemicalName("acetonitrile", ntsconfig);
+    String cml = result.getCml();
+    String smiles = result.getSmiles();
+    String stdinchi = NameToInchi.convertResultToStdInChI(result);
+
+`result.getStatus()` may be checked to see if the conversion was successful.
+If a structure was generated but OPSIN believes there may be a problem a status of WARNING is returned. Currently this may occur if the name appeared to be ambiguous or stereochemistry was ignored.
+By default only optical rotation specification is ignored (this cannot be converted to stereo-configuration algorithmically).
+
+Convenience methods like `result.nameAppearsToBeAmbiguous()` may be used to check the cause of the warning.
+
+NOTE: (Std)InChI cannot be generated for polymers or radicals generated in combination with the wildcardRadicals option
+
+### Availability
+OPSIN is available as a standalone JAR from GitHub, <https://github.com/dan2097/opsin/releases>  
+`opsin-2.5.0-jar-with-dependencies.jar` can be executed as a commandline application or added to the classpath for library usage.
+OPSIN is also available from the Maven Central Repository for users of Apache Maven.  
+
+If you are using Maven then add the following to your pom.xml:
+
+    <dependency>
+       <groupId>uk.ac.cam.ch.opsin</groupId>
+       <artifactId>opsin-core</artifactId>
+       <version>2.5.0</version>
+    </dependency>
+
+If you need just CML or SMILES output support
+
+or
+
+    <dependency>
+       <groupId>uk.ac.cam.ch.opsin</groupId>
+       <artifactId>opsin-inchi</artifactId>
+       <version>2.5.0</version>
+    </dependency>
+
+  if you also need InChI output support.
+
+#### Building from source
+To build OPSIN from source, download Maven 3 and download OPSIN's source code.
+
+Running `mvn package assembly:assembly` in the root of OPSIN's source will build the jar with dependencies
+
+Running `mvn assembly:assembly` in the opsin-core folder will build the "excludingInChI-jar-with-dependencies"
+
+### About OPSIN
+
+The workings of OPSIN are more fully described in:
+
+    Chemical Name to Structure: OPSIN, an Open Source Solution
+    Daniel M. Lowe, Peter T. Corbett, Peter Murray-Rust, Robert C. Glen
+    Journal of Chemical Information and Modeling 2011 51 (3), 739-753
+
+If you use OPSIN in your work, then it would be great if you could cite us.
+
+The following list broadly summarises what OPSIN can currently do and what will be worked on in the future.
+
+#### Supported nomenclature includes:
+* alkanes/alkenes/alkynes/heteroatom chains e.g. hexane, hex-1-ene, tetrasiloxane and their cyclic analogues e.g. cyclopropane
+* All IUPAC 1993 recommended rings
+* Trivial acids
+* Hantzsch-Widman e.g. 1,3-oxazole
+* Spiro systems
+* All von Baeyer rings e.g. bicyclo[2.2.2]octane
+* Hydro e.g. 2,3-dihydropyridine
+* Indicated hydrogen e.g. 1H-benzoimidazole
+* Heteroatom replacement
+* Specification of charge e.g. ium/ide/ylium/uide
+* Multiplicative nomenclature e.g. ethylenediaminetetraacetic acid
+* Conjunctive nomenclature e.g. cyclohexaneethanol
+* Fused ring systems e.g. imidazo[4,5-d]pyridine
+* Ring assemblies e.g. biphenyl
+* Most prefix and infix functional replacement nomenclature
+* The following functional classes: acetals, acids, alcohols, amides, anhydrides, anilides, azetidides, azides, bromides, chlorides,
+cyanates, cyanides, esters, di/tri/tetra esters, ethers, fluorides, fulminates, glycol ethers, glycols, hemiacetals, hemiketal,
+hydrazides, hydrazones, hydrides, hydroperoxides, hydroxides, imides, iodides, isocyanates, isocyanides, isoselenocyanates, isothiocyanates,
+ketals, ketones, lactams, lactims, lactones, mercaptans, morpholides, oxides, oximes, peroxides, piperazides, piperidides, pyrrolidides,
+selenides, selenocyanates, selenoketones, selenolsselenosemicarbazones, selenones, selenoxides, selones, semicarbazones, sulfides, sulfones,
+sulfoxides, sultams, sultims, sultines, sultones, tellurides, telluroketones, tellurones, tellurosemicarbazones, telluroxides, thiocyanates,
+thioketones, thiols, thiosemicarbazones
+* Greek letters
+* Lambda convention
+* Amino Acids and derivatives
+* Structure-based polymer names e.g. poly(2,2'-diamino-5-hexadecylbiphenyl-3,3'-diyl)
+* Bridge prefixes e.g. methano
+* Specification of oxidation numbers and charge on elements
+* Perhalogeno terms
+* Subtractive prefixes: deoxy, dehydro, anhydro, demethyl, deamino
+* Stoichiometry ratios and mixture indicators
+* Nucleosides, (oligo)nucleotides and their esters
+* Carbohydrate nomenclature
+* Simple CAS names including inverted CAS names
+* Steroids including alpha/beta stereochemistry
+* Isotopic labelling
+* E/Z/R/S stereochemistry
+* cis/trans indicating relative stereochemistry on rings and as a synonym of E/Z
+
+#### Currently UNsupported nomenclature includes:
+* Other less common stereochemical terms
+* Most alkaloids/terpenoids
+* Natural product specific nomenclature operations
+
+### Developers and Contributors
+* Rich Apodaca
+* Albina Asadulina
+* Peter Corbett
+* Daniel Lowe (Current maintainer)
+* John Mayfield
+* Peter Murray-Rust
+* Noel O'Boyle
+* Mark Williamson
+
+Thanks also to the many users who have contributed through suggestions and bug reporting.
+
+![YourKit Logo](https://www.yourkit.com/images/yklogo.png)
+
+OPSIN's developers use YourKit to profile and optimise code.
+
+YourKit supports open source projects with its full-featured Java Profiler.
+YourKit, LLC is the creator of [YourKit Java Profiler](https://www.yourkit.com/java/profiler/index.jsp) and [YourKit .NET Profiler](https://www.yourkit.com/.net/profiler/index.jsp), innovative and intelligent tools for profiling Java and .NET applications.
+
+Good Luck and let us know if you have problems, comments or suggestions!
+Bugs may be reported on the project's [issue tracker](https://github.com/dan2097/opsin/issues).
+
+![Build Status](https://github.com/dan2097/opsin/workflows/Java%20CI%20with%20Maven/badge.svg)

TransAntivirus/download_pubchem/opsin-master/ReleaseNotes.txt

@@ -0,0 +1,332 @@
+Version 2.5.0 (2020-10-04)
+OPSIN now requires Java 7 (or higher)
+Support for traditional oxidation state names e.g. ferric
+Added support for defining the stereochemistry of phosphines/arsines
+Added newly discovered elements
+Improved algorithm for correctly interpreting ester names with a missing space e.g. 3-aminophenyl-4-aminobenzenesulfonate
+Fixed structure of canavanine
+Corrected interpretation of silver oxide
+Vocabulary improvements
+Minor improvements/bug fixes
+
+Internal XML Changes:
+tokenList files now all use the same schema (tokenLists.dtd)
+
+Version 2.4.0 (2018-12-23)
+OPSIN is now licensed under the MIT License
+Locant labels included in extended SMILES output
+Command-line now has a name flag to include the input name in SMILES/InChI output (tab delimited)
+Added support for carotenoids
+Added support for Vitamin B-6 related compounds
+Added support for more fused ring system bridge prefixes
+Added support for anilide as a functional replacement group
+Allow heteroatom replacement as a detachable prefix e.g. 3,6,9-triaza-2-(4-phenylbutyl)undecanoic acid
+Support Boughton system isotopic suffixes for 13C/14C/15N/17O/18O
+Support salts of acids in CAS inverted names
+Improved support for implicitly positively charged purine nucleosides/nucleotides
+Added various biochemical groups/substituents
+Improved logic for determining intended substitution in names with too few brackets
+Incorrectly capitalized locants can now be used to reference ring fusion atoms
+Some names no longer allow substitution e.g. water, hydrochloride
+Many minor precision/recall improvements
+
+Version 2.3.1 (2017-07-23)
+Fixed fused ring numbering algorithm incorrectly numbering some ortho- and peri-fused fused systems involving 7-membered rings
+Support P-thio to indicate thiophosphate linkage
+Count of isotopic replacements no longer required if locants given
+Fixed bug where CIP algorithm could assign priorities to identical substituents
+Fixed "DL" before a substituent not assigning the substituted alpha-carbon as racemic stereo
+L-stereochemistry no longer assumed on semi-systematic glycine derivatives e.g. phenylglycine
+Fixed some cases where substituents like carbonyl should have been part of an implicitly bracketed section 
+Fixed interpretation of leucinic acid and 3/4/5-pyrazolone
+
+Version 2.3.0 (2017-02-23)
+D/L stereochemistry can now be assigned algorithmically e.g. L-2-aminobutyric acid
+Other minor improvements to amino acid support e.g. homoproline added
+Extended SMILES added to command-line interface
+Names intended to include the triiodide/tribromide anion no longer erroneously have three monohalides
+Ambiguity detected when applying unlocanted subtractive prefixes
+Better support for adjacent multipliers e.g. ditrifluoroacetic acid
+deoxynucleosides are now implicitly 2'-deoxynucleosides
+Added support for <number> as a syntax for a superscripted number
+Added support for amidrazones
+Aluminium hydrides/chlorides/bromides/iodides are now covalently bonded
+Fixed names with isotopes less than 10 not being supported
+Fixed interpretation of some trivial names that clash with systematic names
+
+Version 2.2.0 (2016-10-16)
+Added support for IUPAC system for isotope specification e.g. (3-14C,2,2-2H2)butane
+Added support for specifying deuteration using the Boughton system e.g. butane-2,2-d2
+Added support for multiplied bridges e.g. 1,2:3,4-diepoxy
+Front locants after a von baeyer descriptor are now supported e.g. bicyclo[2.2.2]-7-octene
+onosyl substituents now supported e.g. glucuronosyl
+More sugar substituents e.g. glucosaminyl
+Improved support for malformed polycyclic spiro names
+Support for oximino as a suffix
+Added method [NameToStructure.getVersion()] to retrieve OPSIN version number
+Allowed bridges to be used as detachable prefixes
+Allow odd numbers of hydro to be added e.g. trihydro
+Added support for unbracketed R stereochemistry (but not S, for the moment, due to the ambiguity with sulfur locants)
+Various minor bug fixes e.g. stereochemistry was incorrect for isovaline
+Minor vocabulary improvements
+
+Version 2.1.0 (2016-03-12)
+Added support for fractional multipliers e.g. hemihydrochloride
+Added support for abbreviated common salts e.g. HCl
+Added support for sandwich compounds e.g. ferrocene
+Improved recognition of names missing the last 'e' (common in German)
+Support for E/Z directly before double bond indication e.g. 2Z-ylidene, 2Z-ene
+Improved support for functional class ethers e.g. "glycerol triglycidyl ether"
+Added general support for names involving an ester formed from an alcohol and an ate group
+Grignards reagents and certain compounds (e.g. uranium hexafluoride), are now treated as covalent rather than ionic
+Added experimental support for outputting extended SMILES. Polymers and attachment points are annotated explicitly
+Polymers when output as SMILES now have atom classes to indicate which end of the repeat unit is which
+Support * as a superscript indicator e.g. *6* to mean superscript 6
+Improved recognition of racemic stereochemistry terms
+Added general support for names like "beta-alanine N,N-diacetic acid"
+Allowed "one" and "ol" suffixes to be used in more cases where another suffix is also present
+"ic acid halide" is not interpreted the same as "ic halide"
+Fixed some cases where ambiguous operations were not considered ambiguous e.g. monosubstitututed phenyl
+Improvements/bug fixes to heuristics for detecting when spaces are omitted from ether/ester names
+Improved support for stereochemistry in older CAS index names
+Many precision improvements e.g. cyclotriphosphazene, thiazoline, TBDMS/TBDPS protecting groups, S-substituted-methionine
+Various minor bug fixes e.g. names containing "SULPH" not recognized
+Minor vocabulary improvements
+
+Internal XML Changes:
+Synonymns of the same concept are now or-ed rather being seperate entities e.g. <token>tertiary|tert-|t-</token>
+
+Version 2.0.0 (2015-07-10)
+MAJOR CHANGES:
+Requires Java 1.6 or higher
+CML (Chemical Markup Language) is now returned as a String rather than a XOM Element
+OPSIN now attempts to identify if a chemical name is ambiguous. Names that appear ambiguous return with a status of WARNING with the structure provided being one interpretation of the name
+
+Added support for "alcohol esters" e.g. phenol acetate [meaning phenyl acetate]
+Multiplied unlocanted substitution is now more intelligent e.g. all substituents must connect to same group, and degeneracy of atom environments is taken into account
+The ester interpretation is now preferred in more cases where a name does not contain a space but the parent is methanoate/ethanoate/formate/acetate/carbamate
+Inorganic oxides are now interpreted, yielding structures with [O-2] ions
+Added more trivial names of simple molecules
+Support for nitrolic acids
+Fixed parsing issue where a directly substituted acetal was not interpretable
+Fixed certain groups e.g. phenethyl, not having their suffix attached to a specific location
+Corrected interpretation of xanthyl, and various trivial names that look systematic
+Name to structure is now ~20% faster
+Initialisation time reduced by a third
+InChI generation is now ~20% faster
+XML processing dependency changed from XOM to Woodstox
+Significant internal refactoring
+Utility functions designed for internal use are no longer on the public API
+Various minor bug fixes
+
+Internal XML Changes:
+Groups lacking a labels attribute now have no locants (previously had ascending numeric locants)
+Syntax for addGroup/addHeteroAtom/addBond attributes changed to be easier to parse and allow specification of whether the name is ambiguous if a locant is not provided
+
+Version 1.6.0 (2014-04-26)
+Added API/command-line options to generate StdInchiKeys
+Added support for the IUPAC recommended nomenclature for carbobohydrate lactones
+Added support for boronic acid pinacol esters
+Added basic support for specifying chalcogen acid tautomer form e.g. thioacetic S-acid
+Fused ring bridges are now numbered
+Names with Endo/Exo/Syn/Anti stereochemistry can now be partially interpreted if warnRatherThanFailOnUninterpretableStereochemistry is used
+The warnRatherThanFailOnUninterpretableStereochemistry option will now assign as much stereochemistry as OPSIN understands (All ignored stereochemistry terms are mentioned in the OpsinResult message)
+Many minor nomenclature support improvements e.g. succinic imide; hexaldehyde; phenyldiazonium, organotrifluoroborates etc.
+Added more trivial names that can be confused with systematic names e.g. Imidazolidinyl urea
+Fixed StackOverFlowError that could occur when processing molecules with over 5000 atoms
+Many minor bug fixes
+Minor vocabulary improvements
+Minor speed improvements
+NOTE: This is the last release to support Java 1.5
+
+Version 1.5.0 (2013-07-21)
+Command line interface now accepts files to read and write to as arguments
+Added option to allow interpretation of acids missing the word acid e.g. "acetic" (off by default)
+Added option to treat uninterpretable stereochemistry as a warning rather than a failure (off by default)
+Added support for nucleotide chains e.g. guanylyl(3'-5')uridine
+Added support for parabens, azetidides, morpholides, piperazides, piperidides and pyrrolidides
+Vocabulary improvements e.g. homo/beta amino acids
+Many minor bug fixes e.g. fulminic acid correctly interpreted
+
+Version 1.4.0 (2013-01-27)
+Added support for dialdoses,diketoses,ketoaldoses,alditols,aldonic acids,uronic acids,aldaric acids,glycosides,oligosacchardides, named systematically or from trivial stems, in cyclic or acyclic form
+Added support for ketoses named using dehydro
+Added support for anhydro
+Added more trivial carbohydrate names
+Added support for sn-glcyerol
+Improved heuristics for phospho substitution
+Added hydrazido and anilate suffixes
+Allowed more functional class nomenclature to apply to amino acids
+Added support for inverting CAS names with substituted functional terms e.g. Acetaldehyde, O-methyloxime
+Double substitution of a deoxy chiral centre now uses the CIP rules to decide which substituent replaced the hydroxy group
+Unicode right arrows, superscripts and the soft hyphen are now recognised
+
+Version 1.3.0 (2012-09-16)
+Added option to output radicals as R groups (* in SMILES)
+Added support for carbolactone/dicarboximide/lactam/lactim/lactone/olide/sultam/sultim/sultine/sultone suffixes
+Resolved some cases of ambiguity in the grammar; the program's capability to handle longer peptide names is improved
+Allowed one (as in ketone) before yl e.g. indol-2-on-3-yl
+Allowed primed locants to be used as unprimed locants in a bracket e.g. 2-(4'-methylphenyl)pyridine
+Vocabulary improvements
+SMILES writer will no longer reuse ring closures on the same atom
+Fixed case where a name formed of many words that could be parsed ambiguously would cause OPSIN to run out of memory
+NameToStructure.getInstance() no longer throws a checked exception
+Many minor bug fixes
+
+Version 1.2.0 (2011-12-06)
+OPSIN is now available from Maven Central
+Basic support for cylised carbohydrates e.g. alpha-D-glucopyranose
+Basic support for systematic carbohydrate stems e.g. D-glycero-D-gluco-Heptose
+Added heuristic for correcting esters with omitted spaces
+Added support for xanthates/xanthic acid
+Minor vocabulary improvements
+Fixed a few minor bugs/limitations in the Cahn-Ingold-Prelog rules implementation and made more memory efficient
+Many minor improvements and bug fixes
+
+Version 1.1.0 (2011-06-16)
+Significant improvements to fused ring numbering code, specifically 3/4/5/7/8 member rings are no longer only allowed in chains of rings
+Added support for outputting to StdInChI
+Small improvements to fused ring building code
+Improvements to heuristics for disambiguating what group is being referred to by a locant
+Lower case indicated hydrogen is now recognised
+Improvements to parsing speed
+Many minor improvements and bug fixes
+
+Version 1.0.0 (2011-03-09)
+Added native isomeric SMILES output
+Improved command-line interface. The desired format i.e. CML/SMILES/InChI as well as options such as allowing radicals can now all be specified via flags
+Debugging is now performed using log4j rather than by passing a verbose flag
+Added traditional locants to carboxylic acids and alkanes e.g. beta-hydroxybutyric acid
+Added support for cis/trans indicating the relative stereochemistry of two substituents on rings and fused rings sytems
+Added support for stoichiometry ratios and mixture indicators
+Added support for alpha/beta stereochemistry on steroids
+Added support for the method for naming spiro systems described in the 1979 recommendations rule A-42
+Added detailedFailureAnalysis option to detect the part of a chemical name that fails to parse
+Added support for deoxy
+Added open-chain saccharides
+Improvements to CAS index name uninversion algorithm
+Added support for isotopes into the program allowing deuterio/tritio
+Added support for R/S stereochemistry indicated by a locant which is also used to indicate the point of substitution for a substituent
+Many minor improvements and bug fixes
+
+Version 0.9.0 (2010-11-01)
+Added transition metals/f-block elements and nobel gases
+Added support for specifying the charge or oxidation number on elements e.g. aluminium(3+), iron(II)
+Calculations based off a van Arkel diagram are now used to determine whether functional bonds to metals should be treated as ionic or covalent
+Improved support for prefix functional replacement e.g. hydrazono/amido/imido/hydrazido/nitrido/pseudohalides can now be used for functional replacement on appropriate acids
+Ortho/meta/para handling improved - can now only apply to six membered rings
+Added support for methylenedioxy
+Added support for simple bridge prefixes e.g. methano as in 2,3-methanoindene
+Added support for perfluoro/perchloro/perbromo/periodo
+Generalised alkane support to allow alkanes of lengths up to 9999 to be described without enumeration
+Updated dependency on JNI-InChI to 0.7, hence InChI 1.03 is now used.
+Improved algorithm for assigning unlocanted hydro terms
+Improved heuristic for determing meaning of oxido
+Improved charge balancing e.g. ionic substance of an implicit ratio 2:3 can now be handled rather than being represented as a net charged 1:1 mixture
+Grammar is a bit more lenient of placement of stereochemistry and multipliers
+Vocabulary improvements especially in the area of nucleosides and nucleotides
+Esters of biochemical compounds e.g. triphosphates are now supported
+Many minor improvements and bug fixes
+
+Version 0.8.0 (2010-07-16)
+NameToStructureConfig can now be used to configure whether radicals e.g. ethyl are output or not.
+Names like carbon tetrachloride are now supported
+glycol ethers e.g. ethylene glycol ethyl ether are now supported
+Prefix functional replacement support now includes halogens e.g. chlorophosphate
+Added support for epoxy/epithio/episeleno/epitelluro
+Added suport for hydrazides/fluorohydrins/chlorohydrins/bromohydrins/iodohydrins/cyanohydrins/acetals/ketals/hemiacetals/hemiketals/diketones/disulfones named using functional class nomenclature
+Improvements to algorithm for assigning and finding atoms corresponding to element symbol locants
+Added experimental right to left parser (ReverseParseRules.java)
+Vocabulary improvements
+Parsing is now even faster
+Various bug fixes and name intepretation fixes
+
+Version 0.7.0 (2010-06-09)
+Added full support for conjunctive nomenclature e.g. 1,3,5-benzenetriacetic acid
+Added basic support for CAS names
+Added trivial poly-noncarboxylic acids and more trivial carboxylic acids
+Added support for spirobi/spiroter/dispiroter and the majority of spiro(ring-locant-ring) nomenclature
+Indicators of the direction that a chemical rotates plane polarised light are now detected and ignored
+Fixed many cases of trivial names being interpreted systematically by adding more trivial names and detecting such cases
+Names such as oxalic bromide cyanide where a halide/pseudohalide replaces an oxygen are now supported
+Amino acid ester named from the neutral amino acid are now supported e.g. glycine ethyl ester
+Added more heteroatom replacement terms
+Allowed creation of an OPSIN parse through NameToStructure.getOpsinParser()
+Added support for dehydro - for unsaturating bonds
+Improvements to element symbol locant assignment and retrieving appropriate atoms from locants like N2
+OPSIN's SMILES parser now accept specification of number of hydrogens in cases other than chiral atoms
+Mixtures specified by separating components by semicolonspace are now supported
+Many internal improvements and bug fixes
+
+Version 0.6.1 (2010-03-18)
+Counter ions are now duplicated such as to lead to if possible a neutral compound
+In names like nitrous amide the atoms modified by the functional replacement can now be substituted
+Allowed ~number~ for specifying superscripts
+Vocabulary improvements
+Added quinone suffix
+Tetrahedral sulfur stereochemistry is now recognised
+Bug fixes to fix incorrect interpretation of some names e.g. triphosgene is now unparseable rather than 3 x phosghene, phospho has different meanings depending on whether it used on an amino acid or another group etc.
+
+Version 0.6.0 (2010-02-18)
+OPSIN is now a mavenised project consisting of two modules: core and inchi. Core does name -->CML, inchi depends on core and allows conversion to inchi
+Instead of CML an OpsinResult can be returned which can yield information as to why a name was not interpretable
+Added support for unlocanted R/S/E/Z stereochemistry. Removed limit on number of atoms that stereochemistry code can handle
+Added support for polymers e.g. poly(ethylene)
+Improvements in handling of multiplicative nomenclature
+Improvements to fusion nomenclature handling: multiplied components and multi parent systems are now supported
+Improved support for functional class nomenclature; space detection has been improved and support has been added for anhydride,oxide,oxime,hydrazone,semicarbazone,thiosemicarbazone,selenosemicarbazone,tellurosemicarbazone,imide
+Support for the lambda convention
+Locanted esters
+Improvements in dearomatisation code
+CML output changed to being CML-Lite compliant
+Speed improvements
+Support for greek letters e.g. as alpha or $a or α
+Added more infixes
+Added more suffixes
+Vocabulary improvements
+Systematic handling of amino acid nomenclature
+Added support for perhydro
+Support for ylium/uide
+Support for locants like N-1 (instead of N1)
+Fixed potential infinite loop in fused ring numbering
+Made grammar more lenient in many places e.g. euphonic o, optional sqaure brackets
+Sulph is now treated like sulf as in sulphuric acid
+and many misc fixes and improvements
+
+Version 0.5.3 (2009-10-22)
+Added support for amic, aldehydic, anilic, anilide, carboxanilide and amoyl suffixes
+Added support for cyclic imides e.g. succinimide/succinimido
+Added support for amide functional class
+Support for locants such as N5 which means a nitrogen that is attached in some way to position 5. Locants of this type may also be used in ester formation.
+Some improvements to functional replacement using prefixes e.g. thioethanoic acid now works
+Disabled stereochemistry in molecules with over 300 atoms as a temporary fix to the problem in 0.52
+Slight improvement in method for deciding which group detachable hydro prefixes apply to.
+Minor vocabulary update
+
+Version 0.5.2 (2009-10-04)
+Outputting directly to InChI is now supported using the separately available nameToInchi jar (an OPSIN jar is expected in the same location as the nameToInchi jar)
+Fused rings with any number of rings in a chain or formed entirely of 6 membered rings can now be numbered
+Added support for E/Z/R/S where locants are given. Unlocanted cases will be dealt with in a subsequent release. In very large molecules a lack of memory may be encountered, this will be resolved in a subsequent release
+Some Infixes are now supported e.g. ethanthioic acid
+All spiro systems with Von Baeyer brackets are now supported e.g. dispiro[4.2.4.2]tetradecane
+Vocabulary increase (especially: terpenes, ingorganic acids, fused ring components)
+Fixed some problems with components with both acylic and cyclic sections e.g. trityl
+Improved locant assignments e.g. 2-furyl is now also fur-2-yl
+Speed improvements
+Removed dependence on Nux/Saxon
+Misc minor fixes
+
+Version 0.5.1 (2009-07-20)
+Huge reduction in OPSIN initialisation time (typical ~7 seconds -->800ms)
+Allowed thio/seleno/telluro as divalent linkers and for functional replacement when used as prefixes. Peroxy can now be used for functional replacement
+Better support for semi-trivally named hydrocarbon fused rings e.g. tetracene
+Better handling of carbonic acid derivatives
+Improvements to locant assignment
+Support for names like triethyltetramine and triethylene glycol
+Misc other fixes to prevent OPSIN generating the wrong structure for certain types of names
+
+Version 0.5 (2009-06-23)
+Too many changes to list
+
+Version 0.1 (2006-10-11)
+Initial release

TransAntivirus/download_pubchem/opsin-master/fullAssembly.xml

@@ -0,0 +1,49 @@
+<assembly>
+  <id>jar-with-dependencies</id>
+  <formats>
+    <format>jar</format>
+  </formats>
+  <moduleSets>
+    <moduleSet>
+      <includes>
+        <include>uk.ac.cam.ch.opsin:opsin-core</include>
+        <include>uk.ac.cam.ch.opsin:opsin-inchi</include>
+        <include>uk.ac.cam.ch.opsin:opsin-cli</include>
+      </includes>
+      <sources>
+        <includeModuleDirectory>false</includeModuleDirectory>
+        <fileSets>
+          <fileSet>
+            <directory>src/main/java</directory>
+          </fileSet>
+        </fileSets>
+      </sources>
+      <binaries>
+        <unpack>true</unpack>
+      </binaries>
+    </moduleSet>
+  </moduleSets>
+  <files>
+    <file>
+      <source>LICENSE.txt</source>
+    </file>
+    <file>
+      <source>README.md</source>
+    </file>
+    <file>
+      <source>ReleaseNotes.txt</source>
+    </file>
+  </files>
+  <includeBaseDirectory>false</includeBaseDirectory>
+  <dependencySets>
+    <dependencySet>
+      <unpack>true</unpack>
+      <scope>runtime</scope>
+    </dependencySet>
+  </dependencySets>
+  <fileSets>
+    <fileSet>
+      <directory>${project.build.outputDirectory}</directory>
+    </fileSet>
+  </fileSets>
+</assembly>

TransAntivirus/download_pubchem/opsin-master/opsin-cli/pom.xml

@@ -0,0 +1,58 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+   <parent>
+      <artifactId>opsin</artifactId>
+      <groupId>uk.ac.cam.ch.opsin</groupId>
+      <version>3.0-SNAPSHOT</version>
+   </parent>
+  <artifactId>opsin-cli</artifactId>
+  <name>OPSIN Command Line interface</name>
+  <description>Command line interface for using OPSIN to convert names to SMILES/InChI/InChIKey/CML</description>
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>3.2.4</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+            <configuration>
+              <finalName>opsin-${project.version}</finalName>
+              <createDependencyReducedPom>false</createDependencyReducedPom>
+              <transformers>
+                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                  <manifestEntries>
+                    <Main-Class>uk.ac.cam.ch.wwmm.opsin.Cli</Main-Class>
+                  </manifestEntries>
+                </transformer>
+              </transformers>
+            </configuration>
+            </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+  <dependencies>
+    <dependency>
+      <groupId>uk.ac.cam.ch.opsin</groupId>
+      <artifactId>opsin-inchi</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>commons-cli</groupId>
+      <artifactId>commons-cli</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-core</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>

TransAntivirus/download_pubchem/opsin-master/opsin-cli/src/main/java/uk/ac/cam/ch/wwmm/opsin/Cli.java

@@ -0,0 +1,268 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.lang.reflect.Method;
+import java.nio.charset.StandardCharsets;
+
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.DefaultParser;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.Option.Builder;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.UnrecognizedOptionException;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.core.config.Configurator;
+
+import com.ctc.wstx.api.WstxOutputProperties;
+import com.ctc.wstx.stax.WstxOutputFactory;
+
+public class Cli {
+
+	private enum InchiType {
+		inchiWithFixedH, stdInchi, stdInchiKey
+	}
+
+	/**
+	 * Run OPSIN as a command-line application.
+	 *
+	 * @param args
+	 * @throws Exception
+	 */
+	public static void main(String[] args) throws Exception {
+		Options options = buildCommandLineOptions();
+		CommandLineParser parser = new DefaultParser();
+		CommandLine cmd = null;
+		try {
+			cmd = parser.parse(options, args);
+		} catch (UnrecognizedOptionException e) {
+			System.err.println(e.getMessage());
+			System.exit(1);
+		}
+		if (cmd.hasOption("h")) {
+			displayUsage(options);
+		}
+		if (cmd.hasOption("v")) {
+			Configurator.setLevel("uk.ac.cam.ch.wwmm.opsin", Level.DEBUG);
+		}
+
+		NameToStructureConfig n2sconfig = generateOpsinConfigObjectFromCmd(cmd);
+
+		InputStream input = System.in;
+		OutputStream output = System.out;
+		String[] unparsedArgs = cmd.getArgs();
+		if (unparsedArgs.length == 0) {
+			System.err.println("Run the jar using the -h flag for help. Enter a chemical name to begin:");
+		} else if (unparsedArgs.length == 1) {
+			input = new FileInputStream(new File(unparsedArgs[0]));
+		} else if (unparsedArgs.length == 2) {
+			input = new FileInputStream(new File(unparsedArgs[0]));
+			output = new FileOutputStream(new File(unparsedArgs[1]));
+		} else {
+			displayUsage(options);
+		}
+		try {
+			String outputType = cmd.getOptionValue("o", "smi");
+			boolean outputName = cmd.hasOption("n");
+			if (outputType.equalsIgnoreCase("cml")) {
+				interactiveCmlOutput(input, output, n2sconfig);
+			} else if (outputType.equalsIgnoreCase("smi") || outputType.equalsIgnoreCase("smiles")) {
+				interactiveSmilesOutput(input, output, n2sconfig, false, outputName);
+			} else if (outputType.equalsIgnoreCase("inchi")) {
+				interactiveInchiOutput(input, output, n2sconfig, InchiType.inchiWithFixedH, outputName);
+			} else if (outputType.equalsIgnoreCase("stdinchi")) {
+				interactiveInchiOutput(input, output, n2sconfig, InchiType.stdInchi, outputName);
+			} else if (outputType.equalsIgnoreCase("stdinchikey")) {
+				interactiveInchiOutput(input, output, n2sconfig, InchiType.stdInchiKey, outputName);
+			} else if (outputType.equalsIgnoreCase("extendedsmi") || outputType.equalsIgnoreCase("extendedsmiles")
+					|| outputType.equalsIgnoreCase("cxsmi") || outputType.equalsIgnoreCase("cxsmiles")) {
+				interactiveSmilesOutput(input, output, n2sconfig, true, outputName);
+			} else {
+				System.err.println("Unrecognised output format: " + outputType);
+				System.err.println(
+						"Expected output types are \"cml\", \"smi\", \"inchi\", \"stdinchi\" and \"stdinchikey\"");
+				System.exit(1);
+			}
+		} finally {
+			if (output != System.out) {
+				output.close();
+			}
+			if (input != System.in) {
+				input.close();
+			}
+		}
+	}
+
+	private static void displayUsage(Options options) {
+		HelpFormatter formatter = new HelpFormatter();
+		String version = NameToStructure.getVersion();
+		formatter.printHelp("java -jar opsin-" + (version != null ? version : "[version]")
+				+ "-jar-with-dependencies.jar [options] [inputfile] [outputfile]" + OpsinTools.NEWLINE
+				+ "OPSIN converts systematic chemical names to CML, SMILES or InChI/StdInChI/StdInChIKey"
+				+ OpsinTools.NEWLINE
+				+ "Names should be new line delimited and may be read from stdin (default) or a file and output to stdout (default) or a file",
+				options);
+		System.exit(0);
+	}
+
+	private static Options buildCommandLineOptions() {
+		Options options = new Options();
+		Builder outputBuilder = Option.builder("o");
+		outputBuilder.longOpt("output");
+		outputBuilder.hasArg();
+		outputBuilder.argName("format");
+		StringBuilder outputOptionsDesc = new StringBuilder();
+		outputOptionsDesc.append("Sets OPSIN's output format (default smi)").append(OpsinTools.NEWLINE);
+		outputOptionsDesc.append("Allowed values are:").append(OpsinTools.NEWLINE);
+		outputOptionsDesc.append("cml for Chemical Markup Language").append(OpsinTools.NEWLINE);
+		outputOptionsDesc.append("smi for SMILES").append(OpsinTools.NEWLINE);
+		outputOptionsDesc.append("extendedsmi for Extended SMILES").append(OpsinTools.NEWLINE);
+		outputOptionsDesc.append("inchi for InChI (with FixedH)").append(OpsinTools.NEWLINE);
+		outputOptionsDesc.append("stdinchi for StdInChI").append(OpsinTools.NEWLINE);
+		outputOptionsDesc.append("stdinchikey for StdInChIKey");
+		outputBuilder.desc(outputOptionsDesc.toString());
+		options.addOption(outputBuilder.build());
+		options.addOption("h", "help", false, "Displays the allowed command line flags");
+		options.addOption("v", "verbose", false, "Enables debugging");
+
+		options.addOption("a", "allowAcidsWithoutAcid", false,
+				"Allows interpretation of acids without the word acid e.g. \"acetic\"");
+		options.addOption("f", "detailedFailureAnalysis", false,
+				"Enables reverse parsing to more accurately determine why parsing failed");
+		options.addOption("n", "name", false, "Include name in SMILES/InChI output (tab delimited)");
+		options.addOption("r", "allowRadicals", false, "Enables interpretation of radicals");
+		options.addOption("s", "allowUninterpretableStereo", false,
+				"Allows stereochemistry uninterpretable by OPSIN to be ignored");
+		options.addOption("w", "wildcardRadicals", false, "Radicals are output as wildcard atoms");
+		return options;
+	}
+
+	/**
+	 * Uses the command line parameters to configure a new NameToStructureConfig
+	 * 
+	 * @param cmd
+	 * @return The configured NameToStructureConfig
+	 */
+	private static NameToStructureConfig generateOpsinConfigObjectFromCmd(CommandLine cmd) {
+		NameToStructureConfig n2sconfig = new NameToStructureConfig();
+		n2sconfig.setInterpretAcidsWithoutTheWordAcid(cmd.hasOption("a"));
+		n2sconfig.setDetailedFailureAnalysis(cmd.hasOption("f"));
+		n2sconfig.setAllowRadicals(cmd.hasOption("r"));
+		n2sconfig.setWarnRatherThanFailOnUninterpretableStereochemistry(cmd.hasOption("s"));
+		n2sconfig.setOutputRadicalsAsWildCardAtoms(cmd.hasOption("w"));
+		return n2sconfig;
+	}
+
+	private static void interactiveCmlOutput(InputStream input, OutputStream out, NameToStructureConfig n2sconfig) throws IOException, XMLStreamException {
+		NameToStructure nts = NameToStructure.getInstance();
+		BufferedReader inputReader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8));
+		XMLOutputFactory factory = new WstxOutputFactory();
+		factory.setProperty(WstxOutputProperties.P_OUTPUT_ESCAPE_CR, false);
+		XMLStreamWriter writer = factory.createXMLStreamWriter(out, "UTF-8");
+		writer = new IndentingXMLStreamWriter(writer, 2);
+		writer.writeStartDocument();
+		CMLWriter cmlWriter = new CMLWriter(writer);
+		cmlWriter.writeCmlStart();
+		int id = 1;
+		String line;
+		while ((line = inputReader.readLine()) != null) {
+			int splitPoint = line.indexOf('\t');
+			String name = splitPoint >= 0 ? line.substring(0, splitPoint) : line;
+			OpsinResult result = nts.parseChemicalName(name, n2sconfig);
+			Fragment structure = result.getStructure();
+			cmlWriter.writeMolecule(structure, name, id++);
+			writer.flush();
+			if (structure == null) {
+				System.err.println(result.getMessage());
+			}
+		}
+		cmlWriter.writeCmlEnd();
+		writer.writeEndDocument();
+		writer.flush();
+		writer.close();
+	}
+
+	private static void interactiveSmilesOutput(InputStream input, OutputStream out, NameToStructureConfig n2sconfig, boolean extendedSmiles, boolean outputName) throws IOException {
+		NameToStructure nts = NameToStructure.getInstance();
+		BufferedReader inputReader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8));
+		BufferedWriter outputWriter = new BufferedWriter(new OutputStreamWriter(out, StandardCharsets.UTF_8));
+		String line;
+		while ((line = inputReader.readLine()) != null) {
+			int splitPoint = line.indexOf('\t');
+			String name = splitPoint >= 0 ? line.substring(0, splitPoint) : line;
+			OpsinResult result = nts.parseChemicalName(name, n2sconfig);
+			String output = extendedSmiles ? result.getExtendedSmiles() : result.getSmiles();
+			if (output == null) {
+				System.err.println(result.getMessage());
+			} else {
+				outputWriter.write(output);
+			}
+			if (outputName) {
+				outputWriter.write('\t');
+				outputWriter.write(line);
+			}
+			outputWriter.newLine();
+			outputWriter.flush();
+		}
+	}
+
+	private static void interactiveInchiOutput(InputStream input, OutputStream out, NameToStructureConfig n2sconfig, InchiType inchiType, boolean outputName) throws Exception {
+		NameToStructure nts = NameToStructure.getInstance();
+		BufferedReader inputReader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8));
+		BufferedWriter outputWriter = new BufferedWriter(new OutputStreamWriter(out, StandardCharsets.UTF_8));
+		Class<?> c;
+		try {
+			c = Class.forName("uk.ac.cam.ch.wwmm.opsin.NameToInchi");
+		} catch (ClassNotFoundException e) {
+			System.err.println("Could not initialise NameToInChI module. Is it on your classpath?");
+			throw new RuntimeException(e);
+		}
+		Method m;
+		switch (inchiType) {
+		case inchiWithFixedH:
+			m = c.getMethod("convertResultToInChI", new Class[] { OpsinResult.class });
+			break;
+		case stdInchi:
+			m = c.getMethod("convertResultToStdInChI", new Class[] { OpsinResult.class });
+			break;
+		case stdInchiKey:
+			m = c.getMethod("convertResultToStdInChIKey", new Class[] { OpsinResult.class });
+			break;
+		default:
+			throw new IllegalArgumentException("Unexepected enum value: " + inchiType);
+		}
+
+		String line;
+		while ((line = inputReader.readLine()) != null) {
+			int splitPoint = line.indexOf('\t');
+			String name = splitPoint >= 0 ? line.substring(0, splitPoint) : line;
+			OpsinResult result = nts.parseChemicalName(name, n2sconfig);
+			String output = (String) m.invoke(null, result);
+			if (output == null) {
+				System.err.println(result.getMessage());
+			} else {
+				outputWriter.write(output);
+			}
+			if (outputName) {
+				outputWriter.write('\t');
+				outputWriter.write(line);
+			}
+			outputWriter.newLine();
+			outputWriter.flush();
+		}
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-cli/src/main/resources/log4j2.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="WARN">
+  <Appenders>
+    <Console name="Console" target="SYSTEM_ERR">
+      <PatternLayout pattern="%level - %m%n"/>
+    </Console>
+  </Appenders>
+  <Loggers>
+    <Root level="warn">
+      <AppenderRef ref="Console"/>
+    </Root>
+  </Loggers>
+</Configuration>

TransAntivirus/download_pubchem/opsin-master/opsin-core/pom.xml

@@ -0,0 +1,67 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+    <parent>
+      <artifactId>opsin</artifactId>
+      <groupId>uk.ac.cam.ch.opsin</groupId>
+      <version>3.0-SNAPSHOT</version>
+    </parent>
+  <artifactId>opsin-core</artifactId>
+  <name>OPSIN Core</name>
+  <description>Core files of OPSIN. Allows conversion of chemical names to CML (Chemical Markup Language)</description>
+  <build>
+    <resources>
+      <resource>
+        <directory>src/main/resources</directory>
+        <filtering>true</filtering>
+        <includes>
+          <include>**/*.props</include>
+        </includes>
+      </resource>
+      <resource>
+        <directory>src/main/resources</directory>
+        <filtering>false</filtering>
+        <excludes>
+          <exclude>**/*.props</exclude>
+        </excludes>
+      </resource>
+    </resources>
+  </build>
+  <dependencies>
+    <dependency>
+      <groupId>dk.brics</groupId>
+      <artifactId>automaton</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.codehaus.woodstox</groupId>
+      <artifactId>woodstox-core-asl</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>commons-io</groupId>
+      <artifactId>commons-io</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-api</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.hamcrest</groupId>
+      <artifactId>hamcrest-library</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-core</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/AmbiguityChecker.java

@@ -0,0 +1,214 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+class AmbiguityChecker {
+
+	static boolean isSubstitutionAmbiguous(List<Atom> substitutableAtoms, int numberToBeSubstituted) {
+		if (substitutableAtoms.size() == 0) {
+			throw new IllegalArgumentException("OPSIN Bug: Must provide at least one substituable atom");
+		}
+		if (substitutableAtoms.size() < numberToBeSubstituted) {
+			throw new IllegalArgumentException("OPSIN Bug: substitutableAtoms must be >= numberToBeSubstituted");
+		}
+		if (substitutableAtoms.size() == numberToBeSubstituted){
+			return false;
+		}
+		if (allAtomsConnectToDefaultInAtom(substitutableAtoms, numberToBeSubstituted)) {
+			return false;
+		}
+		Set<Atom> uniqueAtoms = new HashSet<>(substitutableAtoms);
+		if (uniqueAtoms.size() == 1) {
+			return false;
+		}
+		if (allAtomsEquivalent(uniqueAtoms) && (numberToBeSubstituted == 1 || numberToBeSubstituted == substitutableAtoms.size() - 1)){
+			return false;
+		}
+		return true;
+	}
+	
+	static boolean allAtomsEquivalent(Collection<Atom> atoms) {
+		StereoAnalyser analyser = analyseRelevantAtomsAndBonds(atoms);
+		Set<String> uniqueEnvironments = new HashSet<>();
+		for (Atom a : atoms) {
+			uniqueEnvironments.add(getAtomEnviron(analyser, a));
+		}
+		return uniqueEnvironments.size() == 1;
+	}
+
+	static boolean allBondsEquivalent(Collection<Bond> bonds) {
+		Set<Atom> relevantAtoms = new HashSet<>();
+		for (Bond b : bonds) {
+			relevantAtoms.add(b.getFromAtom());
+			relevantAtoms.add(b.getToAtom());
+		}
+		StereoAnalyser analyser = analyseRelevantAtomsAndBonds(relevantAtoms);
+		Set<String> uniqueBonds = new HashSet<>();
+		for (Bond b : bonds) {
+			uniqueBonds.add(bondToCanonicalEnvironString(analyser, b));
+		}
+		return uniqueBonds.size() == 1;
+	}
+
+	private static String bondToCanonicalEnvironString(StereoAnalyser analyser, Bond b) {
+		String s1 = getAtomEnviron(analyser, b.getFromAtom());
+		String s2 = getAtomEnviron(analyser, b.getToAtom());
+		if (s1.compareTo(s2) > 0){
+			return s1 + s2;
+		}
+		else {
+			return s2 + s1;
+		}
+	}
+
+	static String getAtomEnviron(StereoAnalyser analyser, Atom a) {
+		Integer env = analyser.getAtomEnvironmentNumber(a);
+		if (env == null) {
+			throw new RuntimeException("OPSIN Bug: Atom was not part of ambiguity analysis");
+		}
+		//"identical" atoms may be distinguished by bonds yet to be formed, hence split by outvalency
+		// e.g. [PH3] vs [PH3]=
+		return env + "\t" + a.getOutValency();
+	}
+
+	private static boolean allAtomsConnectToDefaultInAtom(List<Atom> substitutableAtoms, int numberToBeSubstituted) {
+		Atom defaultInAtom = substitutableAtoms.get(0).getFrag().getDefaultInAtom();
+		if (defaultInAtom != null) {
+			for (int i = 0; i < numberToBeSubstituted; i++) {
+				if (!substitutableAtoms.get(i).equals(defaultInAtom)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	}
+
+	static StereoAnalyser analyseRelevantAtomsAndBonds(Collection<Atom> startingAtoms) {
+		Set<Atom> atoms = new HashSet<>();
+		Set<Bond> bonds = new HashSet<>();
+		Deque<Atom> stack = new ArrayDeque<>(startingAtoms);
+		while (!stack.isEmpty()) {
+			Atom a = stack.removeLast();
+			if (!atoms.contains(a)) {
+				atoms.add(a);
+				for (Bond b : a.getBonds()) {
+					bonds.add(b);
+					stack.add(b.getOtherAtom(a));
+				}
+			}
+		}
+		
+		List<Atom> ghostHydrogens = new ArrayList<>();
+		for (Atom atom : atoms) {
+			int explicitHydrogensToAdd = StructureBuildingMethods.calculateSubstitutableHydrogenAtoms(atom);
+			for (int i = 0; i < explicitHydrogensToAdd; i++) {
+				Atom ghostHydrogen = new Atom(ChemEl.H);
+				Bond b = new Bond(ghostHydrogen, atom, 1);
+				atom.addBond(b);
+				ghostHydrogen.addBond(b);
+				ghostHydrogens.add(ghostHydrogen);
+			}
+		}
+		atoms.addAll(ghostHydrogens);
+		StereoAnalyser analyzer = new StereoAnalyser(atoms, bonds);
+		for (Atom ghostHydrogen : ghostHydrogens) {
+			Bond b = ghostHydrogen.getFirstBond();
+			b.getOtherAtom(ghostHydrogen).removeBond(b);
+		}
+		return analyzer;
+	}
+
+	static List<Atom> useAtomEnvironmentsToGivePlausibleSubstitution(List<Atom> substitutableAtoms, int numberToBeSubstituted) {
+		if (substitutableAtoms.size() == 0) {
+			throw new IllegalArgumentException("OPSIN Bug: Must provide at least one substituable atom");
+		}
+		if (substitutableAtoms.size() < numberToBeSubstituted) {
+			throw new IllegalArgumentException("OPSIN Bug: substitutableAtoms must be >= numberToBeSubstituted");
+		}
+		if (substitutableAtoms.size() == numberToBeSubstituted){
+			return substitutableAtoms;
+		}
+
+		List<Atom> preferredAtoms = findPlausibleSubstitutionPatternUsingSymmmetry(substitutableAtoms, numberToBeSubstituted);
+		if (preferredAtoms != null){
+			return preferredAtoms;
+		}
+		return findPlausibleSubstitutionPatternUsingLocalEnvironment(substitutableAtoms, numberToBeSubstituted);
+	}
+
+	private static List<Atom> findPlausibleSubstitutionPatternUsingSymmmetry(List<Atom> substitutableAtoms, int numberToBeSubstituted) {
+		//cf. octaethylporphyrin (8 identical atoms capable of substitution)
+		StereoAnalyser analyser = analyseRelevantAtomsAndBonds(new HashSet<>(substitutableAtoms));
+		Map<String, List<Atom>> atomsInEachEnvironment = new HashMap<>();
+		for (Atom a : substitutableAtoms) {
+			String env = getAtomEnviron(analyser, a);
+			List<Atom> atomsInEnvironment = atomsInEachEnvironment.get(env);
+			if (atomsInEnvironment == null) {
+				atomsInEnvironment = new ArrayList<>();
+				atomsInEachEnvironment.put(env, atomsInEnvironment);
+			}
+			atomsInEnvironment.add(a);
+		}
+		List<Atom> preferredAtoms = null;
+		for (List<Atom> atoms : atomsInEachEnvironment.values()) {
+			if (atoms.size() == numberToBeSubstituted){
+				if (preferredAtoms != null){
+					return null;
+				}
+				preferredAtoms = atoms;
+			}
+		}
+		if (preferredAtoms == null) {
+			//check for environments with double the required atoms where this means each atom can support two substitutions c.f. cyclohexane
+			for (List<Atom> atoms : atomsInEachEnvironment.values()) {
+				if (atoms.size() == (numberToBeSubstituted * 2)){
+					Set<Atom> uniquified = new LinkedHashSet<>(atoms);//retain deterministic atom ordering
+					if (uniquified.size() == numberToBeSubstituted) {
+						if (preferredAtoms != null){
+							return null;
+						}
+						preferredAtoms = new ArrayList<>(uniquified);
+					}
+				}
+			}
+		}
+		return preferredAtoms;
+	}
+	
+	private static List<Atom> findPlausibleSubstitutionPatternUsingLocalEnvironment(List<Atom> substitutableAtoms, int numberToBeSubstituted) {
+		//cf. pentachlorotoluene (5 sp2 carbons vs sp3 methyl)
+		Map<String, List<Atom>> atomsInEachLocalEnvironment = new HashMap<>();
+		for (Atom a : substitutableAtoms) {
+			int valency = a.determineValency(true);	
+			int currentValency = a.getIncomingValency() + a.getOutValency();
+			int numOfBonds = (valency - currentValency) + a.getBondCount();//distinguish sp2 and sp3 atoms
+			String s = a.getElement().toString() +"\t" + valency + "\t" + numOfBonds + "\t" + a.hasSpareValency();
+			List<Atom> atomsInEnvironment = atomsInEachLocalEnvironment.get(s);
+			if (atomsInEnvironment == null) {
+				atomsInEnvironment = new ArrayList<>();
+				atomsInEachLocalEnvironment.put(s, atomsInEnvironment);
+			}
+			atomsInEnvironment.add(a);
+		}
+		List<Atom> preferredAtoms = null;
+		for (List<Atom> atoms : atomsInEachLocalEnvironment.values()) {
+			if (atoms.size() == numberToBeSubstituted){
+				if (preferredAtoms != null){
+					return null;
+				}
+				preferredAtoms = atoms;
+			}
+		}
+		return preferredAtoms;
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/AnnotatorState.java

@@ -0,0 +1,72 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+
+/**
+ * Contains the state needed during finite-state parsing
+ * From this the tokens string and their semantics can be generated
+ * @author Daniel
+ *
+ */
+class AnnotatorState {
+
+	/** The current state of the DFA. */
+	private final int state;
+	/** The annotation so far. */
+	private final char annot;
+	
+	/** The index of the first char in the chemical name that has yet to be tokenised */
+	private final int posInName;
+	
+	private final boolean isCaseSensitive;
+	
+	private final AnnotatorState previousAs;
+
+	
+	AnnotatorState(int state, char annot, int posInName, boolean isCaseSensitive, AnnotatorState previousAs) {
+		this.state = state;
+		this.annot = annot;
+		this.posInName = posInName;
+		this.isCaseSensitive = isCaseSensitive;
+		this.previousAs = previousAs;
+	}
+
+	/**
+	 * The current state in the DFA
+	 * @return
+	 */
+	int getState() {
+		return state;
+	}
+
+	/**
+	 * The annotation that was consumed to transition to this state
+	 * @return
+	 */
+	char getAnnot() {
+		return annot;
+	}
+
+	/**
+	 * The index of the first char in the chemical name that has yet to be tokenised (at the point of creating this AnnotatorState)
+	 * @return
+	 */
+	int getPosInName() {
+		return posInName;
+	}
+
+	/**
+	 * Where the corresponding token is case sensitive
+	 * @return
+	 */
+	boolean isCaseSensitive() {
+		return isCaseSensitive;
+	}
+
+	/**
+	 * The last annotator state for the previous token (or null if this is the first)
+	 * @return
+	 */
+	AnnotatorState getPreviousAs() {
+		return previousAs;
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/Atom.java

@@ -0,0 +1,647 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+
+import static uk.ac.cam.ch.wwmm.opsin.OpsinTools.*;
+
+/**
+ * An atom. Carries information about which fragment it is in, and an ID
+ * number and a list of bonds that it is involved. It may also have other information such as
+ * whether it has "spare valencies" due to unsaturation, its charge, locant labels, stereochemistry and notes
+ *
+ * @author ptc24
+ * @author dl387
+ *
+ */
+class Atom {
+
+	/**The (unique over the molecule) ID of the atom.*/
+	private final int id;
+
+	/**The chemical element of the atom. */
+	private ChemEl chemEl;
+
+	/**The locants that pertain to the atom.*/
+	private final List<String> locants = new ArrayList<>(2);
+
+	/**The formal charge on the atom.*/
+	private int charge = 0;
+	
+	/**The isotope of the atom. Null if not defined explicitly.*/
+	private Integer isotope = null;
+
+	/**
+	 * Holds the atomParity object associated with this object
+	 * null by default
+	 */
+	private AtomParity atomParity = null;
+
+	/**The bonds that involve the atom*/
+	private final List<Bond> bonds = new ArrayList<>(4);
+
+	/**A map between PropertyKey s as declared here and useful atom properties, usually relating to some kind of special case. */
+	@SuppressWarnings("rawtypes")
+	private final Map<PropertyKey, Object> properties = new HashMap<>();
+	/** A set of atoms that were equally plausible to perform functional replacement on */
+	static final PropertyKey<Set<Atom>> AMBIGUOUS_ELEMENT_ASSIGNMENT = new PropertyKey<>("ambiguousElementAssignment");
+	/** The atom class which will be output when serialised to SMILES. Useful for distinguishing attachment points */
+	static final PropertyKey<Integer> ATOM_CLASS = new PropertyKey<>("atomClass");
+	/** Used on wildcard atoms to indicate their meaning */
+	static final PropertyKey<String> HOMOLOGY_GROUP = new PropertyKey<>("homologyGroup");
+	/** Used on wildcard atoms to indicate that they are a position variation bond */
+	static final PropertyKey<List<Atom>> POSITION_VARIATION_BOND = new PropertyKey<>("positionVariationBond");
+	/** The hydrogen count as set in the SMILES*/
+	static final PropertyKey<Integer> SMILES_HYDROGEN_COUNT = new PropertyKey<>("smilesHydrogenCount");
+	/** The oxidation number as specified by Roman numerals in the name*/
+	static final PropertyKey<Integer> OXIDATION_NUMBER = new PropertyKey<>("oxidationNumber");
+	/** Is this atom the carbon of an aldehyde? (however NOT formaldehyde)*/
+	static final PropertyKey<Boolean> ISALDEHYDE = new PropertyKey<>("isAldehyde");
+	/** Indicates that this atom is an anomeric atom in a cyclised carbohydrate*/
+	static final PropertyKey<Boolean> ISANOMERIC = new PropertyKey<>("isAnomeric");
+	/** Transient integer used to indicate traversal of fragments*/
+	static final PropertyKey<Integer> VISITED = new PropertyKey<>("visited");
+
+	/**The fragment to which the atom belongs.*/
+	private Fragment frag;
+
+	/** Whether an atom is part of a delocalised set of double bonds. A double bond in a kekule structure
+	 * can be mapped to a single bond with this attribute set to true on both atoms that were in the double bond
+	 * For example, benzene could be temporarily represented by six singly-bonded atoms, each with a set
+	 * spare valency attribute , and later converted into a fully-specified valence structure.*/
+	private boolean spareValency = false;
+
+	/**The total bond order of all bonds that are expected to be used for inter fragment bonding
+	 * e.g. in butan-2-ylidene this would be 2 for the atom at position 2 and 0 for the other 3 */
+	private int outValency = 0;
+
+	/** Null by default or set by the lambda convention.*/
+	private Integer lambdaConventionValency;
+	
+	/** Null by default or set by the SMILES builder*/
+	private Integer minimumValency;
+	
+	/** Can this atom have implicit hydrogen? True unless explicitly set otherwise otherwise*/
+	private boolean implicitHydrogenAllowed = true;
+
+	/** This is modified by ium/ide/ylium/uide and is used to choose the appropriate valency for the atom*/
+	private int protonsExplicitlyAddedOrRemoved = 0;
+
+	/**
+	 * Takes same values as type in Fragment. Useful for discriminating suffix atoms from other atoms when a suffix is incorporated into another fragments
+	 */
+	private String type;
+
+	/**
+	 * Is this atom in a ring. Default false. Set by the CycleDetector.
+	 * Double bonds are only converted to spareValency if atom is in a ring
+	 * Some suffixes have different meanings if an atom is part of a ring or not c.g. cyclohexanal vs ethanal
+	 */
+	private boolean atomIsInACycle = false;
+
+	/**
+	 * Builds an Atom from scratch.
+	 * GENERALLY EXCEPT FOR TESTING SHOULD NOT BE CALLED EXCEPT FROM THE FRAGMANAGER
+	 * @param id The ID number, unique to the atom in the molecule being built
+	 * @param chemlEl The chemical element
+	 * @param frag the Fragment to contain the Atom
+	 */
+	Atom(int id, ChemEl chemlEl, Fragment frag) {
+		if (frag == null){
+			throw new IllegalArgumentException("Atom is not in a fragment!");
+		}
+		if (chemlEl == null){
+			throw new IllegalArgumentException("Atom does not have an element!");
+		}
+		this.frag = frag;
+		this.id = id;
+		this.chemEl = chemlEl;
+		this.type =frag.getType();
+	}
+	
+	/** Used to build a DUMMY atom.
+	 * Does not have an id/frag/type as would be expected for a proper atom
+	 * @param chemlEl The chemical element
+	 */
+	Atom(ChemEl chemlEl){
+		this.chemEl = chemlEl;
+		this.id = 0;
+	}
+	
+	/**
+	 * Uses the lambdaConventionValency or if that is not available
+	 * the default valency assuming this is >= the current valency
+	 * If not then allowed the chemically sensible valencies of the atom are checked with the one that is closest and >= to the current valency
+	 * being returned. If the valency has still not been determined the current valency i.e. assuming the atom to have 0 implicit hydrogen is returned.
+	 * This is the correct behaviour for inorganics. For p block elements it means that OPSIN does not believe the atom to be in a valid valency (too high)
+	 * 
+	 * if considerOutValency is true, the valency that will be used to form bonds using the outAtoms is
+	 * taken into account i.e. if any radicals were used to form bonds
+	 * @param considerOutValency
+	 * @return
+	 */
+	int determineValency(boolean considerOutValency) {
+		if (lambdaConventionValency != null){
+			return lambdaConventionValency + protonsExplicitlyAddedOrRemoved;
+		}
+		int currentValency = getIncomingValency();
+		if (considerOutValency){
+			currentValency += outValency;
+		}
+		Integer calculatedMinValency = minimumValency == null ? null : minimumValency + protonsExplicitlyAddedOrRemoved;
+		if (charge ==0 || protonsExplicitlyAddedOrRemoved != 0){
+			Integer defaultValency = ValencyChecker.getDefaultValency(chemEl);
+			if (defaultValency != null){
+				defaultValency += protonsExplicitlyAddedOrRemoved;
+				if (currentValency <= defaultValency && (calculatedMinValency == null || defaultValency >= calculatedMinValency)){
+					return defaultValency;
+				}
+			}
+		}
+		Integer[] possibleValencies = ValencyChecker.getPossibleValencies(chemEl, charge);
+		if (possibleValencies != null) {
+			if (calculatedMinValency != null  && calculatedMinValency >= currentValency){
+				return calculatedMinValency;
+			}
+			for (Integer possibleValency : possibleValencies) {
+				if (calculatedMinValency != null && possibleValency < calculatedMinValency){
+					continue;
+				}
+				if (currentValency <= possibleValency){
+					return possibleValency;
+				}
+			}
+		}
+		if (calculatedMinValency != null && calculatedMinValency >= currentValency){
+			return calculatedMinValency;
+		}
+		else{
+			return currentValency;
+		}
+	}
+
+	/**Adds a locant to the Atom. Other locants are preserved.
+	 * Also associates the locant with the atom in the parent fragments hash
+	 *
+	 * @param locant The new locant
+	 */
+	void addLocant(String locant) {
+		locants.add(locant);
+		frag.addMappingToAtomLocantMap(locant, this);
+	}
+
+	/**Replaces all existing locants with a new one.
+	 *
+	 * @param locant The new locant
+	 */
+	void replaceLocants(String locant) {
+		clearLocants();
+		addLocant(locant);
+	}
+
+	void removeLocant(String locantToRemove) {
+		int locantArraySize = locants.size();
+		for (int i = locantArraySize -1; i >=0 ; i--) {
+			if (locants.get(i).equals(locantToRemove)){
+				locants.remove(i);
+				frag.removeMappingFromAtomLocantMap(locantToRemove);
+			}
+		}
+	}
+
+	/**Removes all locants from the Atom.
+	 *
+	 */
+	void clearLocants() {
+		for (int i = 0, l = locants.size(); i < l; i++) {
+			frag.removeMappingFromAtomLocantMap(locants.get(i));
+		}
+		locants.clear();
+	}
+
+	/**
+	 * Removes only elementSymbolLocants: e.g. N, S', Se
+	 */
+	void removeElementSymbolLocants() {
+		for (int i = locants.size() - 1; i >= 0; i--) {
+			String locant = locants.get(i);
+			if (MATCH_ELEMENT_SYMBOL_LOCANT.matcher(locant).matches()){
+				frag.removeMappingFromAtomLocantMap(locant);
+				locants.remove(i);
+			}
+		}
+	}
+	
+	/**
+	 * Removes all locants other than elementSymbolLocants (e.g. N, S', Se)
+	 * Hence removes numeric locants and greek locants
+	 */
+	void removeLocantsOtherThanElementSymbolLocants() {
+		for (int i = locants.size() - 1; i >= 0; i--) {
+			String locant = locants.get(i);
+			if (!MATCH_ELEMENT_SYMBOL_LOCANT.matcher(locant).matches()){
+				frag.removeMappingFromAtomLocantMap(locant);
+				locants.remove(i);
+			}
+		}
+	}
+
+	/**Checks if the Atom has a given locant.
+	 *
+	 * @param locant The locant to test for
+	 * @return true if it has, false if not
+	 */
+	boolean hasLocant(String locant) {
+		if (locants.contains(locant)) {
+			return true;
+		}
+		Matcher m = MATCH_AMINOACID_STYLE_LOCANT.matcher(locant);
+		if (m.matches()){//e.g. N'5
+			if (chemEl.toString().equals(m.group(1))){//element symbol
+				if (!m.group(2).equals("") && (!hasLocant(m.group(1) +m.group(2)))){//has primes
+					return false;//must have exact locant e.g. N'
+				}
+				if (OpsinTools.depthFirstSearchForNonSuffixAtomWithLocant(this, m.group(3)) != null){
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	/**Gets the first locant for the Atom. This may be the locant that was initially
+	 * specified, or the most recent locant specified using replaceLocant, or first
+	 * locant to be added since the last invocation of clearLocants.
+	 *
+	 * @return The locant, or null if there is no locant
+	 */
+	String getFirstLocant() {
+		return locants.size() > 0 ? locants.get(0) : null;
+	}
+
+	/**Returns the array of locants containing all locants associated with the atom
+	 *
+	 * @return The list of locants (may be empty)
+	 */
+	List<String> getLocants() {
+		return Collections.unmodifiableList(locants);
+	}
+
+	/**Returns the subset of the locants which are element symbol locants e.g. N, S', Se
+	 *
+	 * @return The list of locants (may be empty)
+	 */
+	List<String> getElementSymbolLocants() {
+		List<String> elementSymbolLocants = new ArrayList<>(1);
+		for (int i = 0, l = locants.size(); i < l; i++) {
+			String locant = locants.get(i);
+            if (MATCH_ELEMENT_SYMBOL_LOCANT.matcher(locant).matches()) {
+                elementSymbolLocants.add(locant);
+            }
+        }
+		return elementSymbolLocants;
+	}
+
+	void setFrag(Fragment f) {
+		frag = f;
+	}
+
+	Fragment getFrag() {
+		return frag;
+	}
+
+	/**Gets the ID of the atom.
+	 *
+	 * @return The ID of the atom
+	 */
+	int getID() {
+		return id;
+	}
+
+	/**Gets the chemical element corresponding to the element of the atom.
+	 *
+	 * @return The chemical element corresponding to the element of the atom
+	 */
+	ChemEl getElement() {
+		return chemEl;
+	}
+
+	/**Sets the chemical element corresponding to the element of the atom.
+	 *
+	 * @param chemEl The chemical element corresponding to the element of the atom
+	 */
+	void setElement(ChemEl chemEl) {
+		this.chemEl = chemEl;
+	}
+
+	/**Gets the formal charge on the atom.
+	 *
+	 * @return The formal charge on the atom
+	 */
+	int getCharge() {
+		return charge;
+	}
+	
+	/**Modifies the charge of this atom by the amount given. This can be any integer
+	 * The number of protons changed is noted so as to calculate the correct valency for the atom. This can be any integer.
+	 * For example ide is the loss of a proton so is charge=-1, protons =-1
+	 * @param charge
+	 * @param protons
+	 */
+	void addChargeAndProtons(int charge, int protons){
+		this.charge += charge;
+		protonsExplicitlyAddedOrRemoved+=protons;
+	}
+
+	/**Sets the formal charge on the atom.
+	 * NOTE: make sure to update protonsExplicitlyAddedOrRemoved if necessary
+	 * 
+	 * @param c The formal charge on the atom
+	 */
+	void setCharge(int c) {
+		charge = c;
+	}
+	
+	 /** 
+	 * Sets the formal charge and number of protonsExplicitlyAddedOrRemoved to 0
+	 */
+	void neutraliseCharge() {
+		charge = 0;
+		protonsExplicitlyAddedOrRemoved = 0;
+	}
+
+	/**
+	 * Gets the mass number of the atom or null if not explicitly defined
+	 * e.g. 3 for tritium
+	 * @return
+	 */
+	Integer getIsotope() {
+		return isotope;
+	}
+
+	/**
+	 * Sets the mass number of the atom explicitly
+	 * @param isotope
+	 */
+	void setIsotope(Integer isotope) {
+		if (isotope != null && isotope < chemEl.ATOMIC_NUM) {
+			throw new RuntimeException("Isotopic mass cannot be less than the element's number of protons: " + chemEl.toString() + " " + isotope + " < " + chemEl.ATOMIC_NUM );
+		}
+		this.isotope = isotope;
+	}
+
+	/**Adds a bond to the atom
+	 *
+	 * @param b The bond to be added
+	 */
+	void addBond(Bond b) {
+		if (bonds.contains(b)){
+			throw new IllegalArgumentException("Atom already has given bond (This is not allowed as this would give two bonds between the same atoms!)");
+		}
+		bonds.add(b);
+	}
+
+	/**Removes a bond to the atom
+	 *
+	 * @param b The bond to be removed
+     * @return whether bond was present
+	 */
+	boolean removeBond(Bond b) {
+		return bonds.remove(b);
+	}
+
+	/**Calculates the number of bonds connecting to the atom, excluding bonds to implicit
+	 * hydrogens. Double bonds count as
+	 * two bonds, etc. Eg ethene - both C's have an incoming valency of 2.
+	 *
+	 * @return Incoming Valency
+	 */
+	int getIncomingValency() {
+		int v = 0;
+		for (int i = 0, len = bonds.size(); i < len; i++) {
+			v += bonds.get(i).getOrder();
+		}
+		return v;
+	}
+
+	int getProtonsExplicitlyAddedOrRemoved() {
+		return protonsExplicitlyAddedOrRemoved;
+	}
+
+	void setProtonsExplicitlyAddedOrRemoved(int protonsExplicitlyAddedOrRemoved) {
+		this.protonsExplicitlyAddedOrRemoved = protonsExplicitlyAddedOrRemoved;
+	}
+	
+	/**Does the atom have spare valency to form double bonds?
+	 *
+	 * @return true if atom has spare valency
+	 */
+	boolean hasSpareValency() {
+		return spareValency;
+	}
+
+	/**Set whether an atom has spare valency
+	 *
+	 * @param sv The spare valency
+	 */
+	void setSpareValency(boolean sv) {
+		spareValency = sv;
+	}
+
+	/**Gets the total bond order of the bonds expected to be created from this atom for inter fragment bonding
+	 *
+	 * @return The outValency
+	 */
+	int getOutValency() {
+		return outValency;
+	}
+
+	/**Adds to the total bond order of the bonds expected to be created from this atom for inter fragment bonding
+	 *
+	 * @param outV The outValency to be added
+	 */
+	void addOutValency(int outV) {
+		outValency += outV;
+	}
+
+	List<Bond> getBonds() {
+		return Collections.unmodifiableList(bonds);
+	}
+	
+	int getBondCount() {
+		return bonds.size();
+	}
+
+	/**Gets a list of atoms that connect to the atom
+	 *
+	 * @return The list of atoms connected to the atom
+	 */
+	List<Atom> getAtomNeighbours(){
+		int bondCount = bonds.size();
+		List<Atom> results = new ArrayList<>(bondCount);
+		for (int i = 0; i < bondCount; i++) {
+			results.add(bonds.get(i).getOtherAtom(this));
+		}
+		return results;
+	}
+
+	Integer getLambdaConventionValency() {
+		return lambdaConventionValency;
+	}
+
+	void setLambdaConventionValency(Integer valency) {
+		this.lambdaConventionValency = valency;
+	}
+
+	String getType() {
+		return type;
+	}
+
+	void setType(String type) {
+		this.type = type;
+	}
+
+	boolean getAtomIsInACycle() {
+		return atomIsInACycle;
+	}
+
+	/**
+	 * Sets whether atom is in a cycle, true if it is
+	 * @param atomIsInACycle
+	 */
+	void setAtomIsInACycle(boolean atomIsInACycle) {
+		this.atomIsInACycle = atomIsInACycle;
+	}
+
+	AtomParity getAtomParity() {
+		return atomParity;
+	}
+
+	void setAtomParity(AtomParity atomParity) {
+		this.atomParity = atomParity;
+	}
+
+	void setAtomParity(Atom[] atomRefs4, int parity) {
+		atomParity = new AtomParity(atomRefs4, parity);
+	}
+	
+	Integer getMinimumValency() {
+		return minimumValency;
+	}
+
+	void setMinimumValency(Integer minimumValency) {
+		this.minimumValency = minimumValency;
+	}
+	
+	boolean getImplicitHydrogenAllowed() {
+		return implicitHydrogenAllowed;
+	}
+
+	void setImplicitHydrogenAllowed(boolean implicitHydrogenAllowed) {
+		this.implicitHydrogenAllowed = implicitHydrogenAllowed;
+	}
+
+    @SuppressWarnings("unchecked")
+	<T> T getProperty(PropertyKey<T> propertyKey) {
+        return (T) properties.get(propertyKey);
+    }
+
+	<T> void setProperty(PropertyKey<T> propertyKey, T value) {
+		properties.put(propertyKey, value);
+	}
+
+	/**
+	 * Checks if the valency of this atom allows it to have the amount of spare valency that the atom currently has
+	 * May reduce the spare valency on the atom to be consistent with the valency of the atom
+	 * Does nothing if the atom has no spare valency
+	 * @param takeIntoAccountExternalBonds
+	 * @throws StructureBuildingException
+	 */
+	void ensureSVIsConsistantWithValency(boolean takeIntoAccountExternalBonds) throws StructureBuildingException {
+		if (spareValency) {
+			Integer maxValency;
+			if (lambdaConventionValency != null) {
+				maxValency = lambdaConventionValency + protonsExplicitlyAddedOrRemoved;
+			}
+			else{
+				Integer hwValency = ValencyChecker.getHWValency(chemEl);
+				if (hwValency == null) {
+					throw new StructureBuildingException(chemEl + " is not expected to be aromatic!");
+				}
+				maxValency = hwValency + protonsExplicitlyAddedOrRemoved;
+			}
+			int maxSpareValency;
+			if (takeIntoAccountExternalBonds) {
+				maxSpareValency = maxValency - getIncomingValency() - outValency;
+			}
+			else{
+				maxSpareValency = maxValency - frag.getIntraFragmentIncomingValency(this);
+			}
+			if (maxSpareValency < 1) {
+				setSpareValency(false);
+			}
+		}
+	}
+	
+	/**
+	 * Returns the the first bond in the atom's bond list or null if it has no bonds
+	 * @return
+	 */
+	Bond getFirstBond() {
+		if (bonds.size() > 0){
+			return bonds.get(0);
+		}
+		return null;
+	}
+	
+	/**Gets the bond between this atom and a given atom
+	 *
+	 * @param a The atom to find a bond to
+	 * @return The bond, or null if there is no bond
+	 */
+	Bond getBondToAtom(Atom a) {
+		for (int i = 0, l = bonds.size(); i < l; i++) {
+			Bond b = bonds.get(i);
+			if(b.getOtherAtom(this) == a){
+				return b;
+			}
+		}
+		return null;
+	}
+
+	/**Gets the bond between this atom and a given atom, throwing if fails.
+	 *
+	 * @param a The atom to find a bond to
+	 * @return The bond found
+	 * @throws StructureBuildingException
+	 */
+	Bond getBondToAtomOrThrow(Atom a) throws StructureBuildingException {
+		Bond b = getBondToAtom(a);
+		if(b == null){
+			throw new StructureBuildingException("Couldn't find specified bond");
+		}
+		return b;
+	}
+
+	/**
+	 * Set the stereo group, ignored if the atom does not have any parity info.
+	 * @param stroGrp the stereo group.
+	 */
+	public void setStereoGroup(StereoGroup stroGrp) {
+		if (atomParity != null)
+			atomParity.setStereoGroup(stroGrp);
+	}
+
+	/**
+	 * Access the stereo group on the atom parity info.
+	 * @return the stereo group
+	 */
+	public StereoGroup getStereoGroup() {
+		return atomParity != null ? atomParity.getStereoGroup() : StereoGroup.Unk;
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/AtomParity.java

@@ -0,0 +1,64 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+/**
+ * Hold information about 4 atoms and their chiral determinant allowing the description of tetrahedral stereochemistry
+ * @author dl387
+ *
+ */
+class AtomParity {
+	/**
+	 * A dummy hydrogen atom. Used to represent an implicit hydrogen that is attached to a tetrahedral stereocentre
+	 */
+	static final Atom hydrogen = new Atom(ChemEl.H);
+	/**
+	 * A dummy hydrogen atom. Used to represent the hydrogen that replaced a hydroxy at a tetrahedral stereocentre
+	 */
+	static final Atom deoxyHydrogen = new Atom(ChemEl.H);
+	private Atom[] atomRefs4;
+	private int parity;
+	private StereoGroup stereoGroup = StereoGroup.Abs;
+	private int stereoGroupNum = 1;
+	
+	/**
+	 * Create an atomParity from an array of 4 atoms and the parity of the chiral determinant
+	 * @param atomRefs4
+	 * @param parity
+	 */
+	AtomParity(Atom[] atomRefs4, int parity){
+		if (atomRefs4.length !=4){
+			throw new IllegalArgumentException("atomRefs4 must contain references to 4 atoms");
+		}
+		this.atomRefs4 = atomRefs4;
+		this.parity = parity;
+	}
+
+	Atom[] getAtomRefs4() {
+		return atomRefs4;
+	}
+	void setAtomRefs4(Atom[] atomRefs4) {
+		this.atomRefs4 = atomRefs4;
+	}
+	int getParity() {
+		return parity;
+	}
+	void setParity(int parity) {
+		this.parity = parity;
+	}
+
+	public void setStereoGroup(StereoGroup stroGrp, int num) {
+		this.stereoGroup = stroGrp;
+		this.stereoGroupNum = num;
+	}
+
+	public void setStereoGroup(StereoGroup stroGrp) {
+		setStereoGroup(stroGrp, 1);
+	}
+
+	public StereoGroup getStereoGroup() {
+		return this.stereoGroup;
+	}
+
+	public int getStereoGroupNum() {
+		return this.stereoGroupNum;
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/AtomProperties.java

@@ -0,0 +1,160 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.EnumMap;
+import java.util.Map;
+
+/**
+ * Holds useful atomic properties
+ * @author dl387
+ *
+ */
+class AtomProperties {
+
+	private static final Map<ChemEl, Double> elementToPaulingElectronegativity = new EnumMap<>(ChemEl.class);
+	private static final Map<ChemEl, Integer> elementToHwPriority = new EnumMap<>(ChemEl.class);
+	
+	static{
+		elementToPaulingElectronegativity.put(ChemEl.H, 2.20);
+		elementToPaulingElectronegativity.put(ChemEl.Li, 0.98);
+		elementToPaulingElectronegativity.put(ChemEl.Be, 1.57);
+		elementToPaulingElectronegativity.put(ChemEl.B, 2.04);
+		elementToPaulingElectronegativity.put(ChemEl.C, 2.55);
+		elementToPaulingElectronegativity.put(ChemEl.N, 3.04);
+		elementToPaulingElectronegativity.put(ChemEl.O, 3.44);
+		elementToPaulingElectronegativity.put(ChemEl.F, 3.98);
+		elementToPaulingElectronegativity.put(ChemEl.Na, 0.93);
+		elementToPaulingElectronegativity.put(ChemEl.Mg, 1.31);
+		elementToPaulingElectronegativity.put(ChemEl.Al, 1.61);
+		elementToPaulingElectronegativity.put(ChemEl.Si, 1.90);
+		elementToPaulingElectronegativity.put(ChemEl.P, 2.19);
+		elementToPaulingElectronegativity.put(ChemEl.S, 2.58);
+		elementToPaulingElectronegativity.put(ChemEl.Cl, 3.16);
+		elementToPaulingElectronegativity.put(ChemEl.K, 0.82);
+		elementToPaulingElectronegativity.put(ChemEl.Ca, 1.00);
+		elementToPaulingElectronegativity.put(ChemEl.Sc, 1.36);
+		elementToPaulingElectronegativity.put(ChemEl.Ti, 1.54);
+		elementToPaulingElectronegativity.put(ChemEl.V, 1.63);
+		elementToPaulingElectronegativity.put(ChemEl.Cr, 1.66);
+		elementToPaulingElectronegativity.put(ChemEl.Mn, 1.55);
+		elementToPaulingElectronegativity.put(ChemEl.Fe, 1.83);
+		elementToPaulingElectronegativity.put(ChemEl.Co, 1.88);
+		elementToPaulingElectronegativity.put(ChemEl.Ni, 1.91);
+		elementToPaulingElectronegativity.put(ChemEl.Cu, 1.90);
+		elementToPaulingElectronegativity.put(ChemEl.Zn, 1.65);
+		elementToPaulingElectronegativity.put(ChemEl.Ga, 1.81);
+		elementToPaulingElectronegativity.put(ChemEl.Ge, 2.01);
+		elementToPaulingElectronegativity.put(ChemEl.As, 2.18);
+		elementToPaulingElectronegativity.put(ChemEl.Se, 2.55);
+		elementToPaulingElectronegativity.put(ChemEl.Br, 2.96);
+		elementToPaulingElectronegativity.put(ChemEl.Kr, 3.00);
+		elementToPaulingElectronegativity.put(ChemEl.Rb, 0.82);
+		elementToPaulingElectronegativity.put(ChemEl.Sr, 0.95);
+		elementToPaulingElectronegativity.put(ChemEl.Y, 1.22);
+		elementToPaulingElectronegativity.put(ChemEl.Zr, 1.33);
+		elementToPaulingElectronegativity.put(ChemEl.Nb, 1.6);
+		elementToPaulingElectronegativity.put(ChemEl.Mo, 2.16);
+		elementToPaulingElectronegativity.put(ChemEl.Tc, 1.9);
+		elementToPaulingElectronegativity.put(ChemEl.Ru, 2.2);
+		elementToPaulingElectronegativity.put(ChemEl.Rh, 2.28);
+		elementToPaulingElectronegativity.put(ChemEl.Pd, 2.20);
+		elementToPaulingElectronegativity.put(ChemEl.Ag, 1.93);
+		elementToPaulingElectronegativity.put(ChemEl.Cd, 1.69);
+		elementToPaulingElectronegativity.put(ChemEl.In, 1.78);
+		elementToPaulingElectronegativity.put(ChemEl.Sn, 1.96);
+		elementToPaulingElectronegativity.put(ChemEl.Sb, 2.05);
+		elementToPaulingElectronegativity.put(ChemEl.Te, 2.1);
+		elementToPaulingElectronegativity.put(ChemEl.I, 2.66);
+		elementToPaulingElectronegativity.put(ChemEl.Xe, 2.60);
+		elementToPaulingElectronegativity.put(ChemEl.Cs, 0.79);
+		elementToPaulingElectronegativity.put(ChemEl.Ba, 0.89);
+		elementToPaulingElectronegativity.put(ChemEl.La, 1.1);
+		elementToPaulingElectronegativity.put(ChemEl.Ce, 1.12);
+		elementToPaulingElectronegativity.put(ChemEl.Pr, 1.13);
+		elementToPaulingElectronegativity.put(ChemEl.Nd, 1.14);
+		elementToPaulingElectronegativity.put(ChemEl.Pm, 1.13);
+		elementToPaulingElectronegativity.put(ChemEl.Sm, 1.17);
+		elementToPaulingElectronegativity.put(ChemEl.Eu, 1.2);
+		elementToPaulingElectronegativity.put(ChemEl.Gd, 1.2);
+		elementToPaulingElectronegativity.put(ChemEl.Tb, 1.1);
+		elementToPaulingElectronegativity.put(ChemEl.Dy, 1.22);
+		elementToPaulingElectronegativity.put(ChemEl.Ho, 1.23);
+		elementToPaulingElectronegativity.put(ChemEl.Er, 1.24);
+		elementToPaulingElectronegativity.put(ChemEl.Tm, 1.25);
+		elementToPaulingElectronegativity.put(ChemEl.Yb, 1.1);
+		elementToPaulingElectronegativity.put(ChemEl.Lu, 1.27);
+		elementToPaulingElectronegativity.put(ChemEl.Hf, 1.3);
+		elementToPaulingElectronegativity.put(ChemEl.Ta, 1.5);
+		elementToPaulingElectronegativity.put(ChemEl.W, 2.36);
+		elementToPaulingElectronegativity.put(ChemEl.Re, 1.9);
+		elementToPaulingElectronegativity.put(ChemEl.Os, 2.2);
+		elementToPaulingElectronegativity.put(ChemEl.Ir, 2.20);
+		elementToPaulingElectronegativity.put(ChemEl.Pt, 2.28);
+		elementToPaulingElectronegativity.put(ChemEl.Au, 2.54);
+		elementToPaulingElectronegativity.put(ChemEl.Hg, 2.00);
+		elementToPaulingElectronegativity.put(ChemEl.Tl, 1.62);
+		elementToPaulingElectronegativity.put(ChemEl.Pb, 2.33);
+		elementToPaulingElectronegativity.put(ChemEl.Bi, 2.02);
+		elementToPaulingElectronegativity.put(ChemEl.Po, 2.0);
+		elementToPaulingElectronegativity.put(ChemEl.At, 2.2);
+		elementToPaulingElectronegativity.put(ChemEl.Rn, 2.2);
+		elementToPaulingElectronegativity.put(ChemEl.Fr, 0.7);
+		elementToPaulingElectronegativity.put(ChemEl.Ra, 0.9);
+		elementToPaulingElectronegativity.put(ChemEl.Ac, 1.1);
+		elementToPaulingElectronegativity.put(ChemEl.Th, 1.3);
+		elementToPaulingElectronegativity.put(ChemEl.Pa, 1.5);
+		elementToPaulingElectronegativity.put(ChemEl.U, 1.38);
+		elementToPaulingElectronegativity.put(ChemEl.Np, 1.36);
+		elementToPaulingElectronegativity.put(ChemEl.Pu, 1.28);
+		elementToPaulingElectronegativity.put(ChemEl.Am, 1.13);
+		elementToPaulingElectronegativity.put(ChemEl.Cm, 1.28);
+		elementToPaulingElectronegativity.put(ChemEl.Bk, 1.3);
+		elementToPaulingElectronegativity.put(ChemEl.Cf, 1.3);
+		elementToPaulingElectronegativity.put(ChemEl.Es, 1.3);
+		elementToPaulingElectronegativity.put(ChemEl.Fm, 1.3);
+		elementToPaulingElectronegativity.put(ChemEl.Md, 1.3);
+		elementToPaulingElectronegativity.put(ChemEl.No, 1.3);
+		elementToPaulingElectronegativity.put(ChemEl.Lr, 1.3);
+
+		elementToHwPriority.put(ChemEl.F, 23);
+		elementToHwPriority.put(ChemEl.Cl, 22);
+		elementToHwPriority.put(ChemEl.Br, 21);
+		elementToHwPriority.put(ChemEl.I, 20);
+		elementToHwPriority.put(ChemEl.O, 19);
+		elementToHwPriority.put(ChemEl.S, 18);
+		elementToHwPriority.put(ChemEl.Se, 17);
+		elementToHwPriority.put(ChemEl.Te, 16);
+		elementToHwPriority.put(ChemEl.N, 15);
+		elementToHwPriority.put(ChemEl.P, 14);
+		elementToHwPriority.put(ChemEl.As, 13);
+		elementToHwPriority.put(ChemEl.Sb, 12);
+		elementToHwPriority.put(ChemEl.Bi, 11);
+		elementToHwPriority.put(ChemEl.Si, 10);
+		elementToHwPriority.put(ChemEl.Ge, 9);
+		elementToHwPriority.put(ChemEl.Sn, 8);
+		elementToHwPriority.put(ChemEl.Pb, 7);
+		elementToHwPriority.put(ChemEl.B, 6);
+		elementToHwPriority.put(ChemEl.Al, 5);
+		elementToHwPriority.put(ChemEl.Ga, 4);
+		elementToHwPriority.put(ChemEl.In, 3);
+		elementToHwPriority.put(ChemEl.Tl, 2);
+		elementToHwPriority.put(ChemEl.Hg, 1);
+	}
+
+	/**
+	 * Useful to give an indication of whether a bond is like to be ionic (diff >1.8), polar or covalent (diff < 1.2)
+	 * @param chemEl
+	 * @return
+	 */
+	static Double getPaulingElectronegativity(ChemEl chemEl) {
+		return elementToPaulingElectronegativity.get(chemEl);
+	}
+
+	/**
+	 * Maps chemEl to the priority of that atom in Hantzch-Widman system. A higher value indicates a higher priority.
+	 * @param chemEl
+	 * @return
+	 */
+	static Integer getHwpriority(ChemEl chemEl) {
+		return elementToHwPriority.get(chemEl);
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/Attribute.java

@@ -0,0 +1,74 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+class Attribute {
+
+	private final String name;
+	private String value;
+
+	Attribute(String name, String value) {
+		this.name = name;
+		this.value = value;
+	}
+
+	/**
+	 * Creates a copy
+	 * @param attribute
+	 */
+	Attribute(Attribute attribute) {
+		this.name = attribute.getName();
+		this.value = attribute.getValue();
+	}
+
+	String getValue() {
+		return value;
+	}
+
+	String getName() {
+		return name;
+	}
+	
+	void setValue(String value) {
+		this.value = value;
+	}
+
+	String toXML() {
+		return getName() + "=\"" + escapeText(value) + "\"";
+	}
+
+	public String toString() {
+		return name +"\t" + value;
+	}
+
+	private String escapeText(String s) {
+		StringBuilder result = new StringBuilder();
+		for (int i = 0, l = s.length(); i < l; i++) {
+			char c = s.charAt(i);
+			switch (c) {
+			case '\t':
+				result.append("&#x09;");
+				break;
+			case '\n':
+				result.append("&#x0A;");
+				break;
+			case '\r':
+				result.append("&#x0D;");
+				break;
+			case '"':
+				result.append("&quot;");
+				break;
+			case '&':
+				result.append("&amp;");
+				break;
+			case '<':
+				result.append("&lt;");
+				break;
+			case '>':
+				result.append("&gt;");
+				break;
+			default:
+				result.append(c);
+			}
+		}
+		return result.toString();
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/AutomatonInitialiser.java

@@ -0,0 +1,105 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import dk.brics.automaton.Automaton;
+import dk.brics.automaton.RegExp;
+import dk.brics.automaton.RunAutomaton;
+import dk.brics.automaton.SpecialOperations;
+
+/**
+ * Handles storing and retrieving automata to/from files
+ * This is highly useful to do as building these deterministic automata from scratch can take minutes
+ * @author dl387
+ *
+ */
+class AutomatonInitialiser {
+	
+	private static final Logger LOG = LogManager.getLogger(AutomatonInitialiser.class);
+	private final ResourceGetter resourceGetter;
+	
+	AutomatonInitialiser(String resourcePath) {
+		resourceGetter = new ResourceGetter(resourcePath);
+	}
+
+	/**
+	 * In preference serialised automata and their hashes will be looked for in the resource folder in your working directory
+	 * If it cannot be found there then these files will be looked for in the standard resource folder
+	 * (this is actually the standard behaviour of the resourceGetter but I'm reiterating it here as if the stored hash doesn't match
+	 * the current hash then the creation of an updated serialised automaton and hash will occur in the working directory resource folder as the standard
+	 * resource folder will not typically be writable)
+	 * @param automatonName : A name for the automaton so that it can it can be saved/loaded from disk
+	 * @param regex : the regex from which to build the RunAutomaton
+	 * @param reverseAutomaton : should the automaton be reversed
+	 * @param tableize: if true, a transition table is created which makes the run method faster in return of a higher memory usage (adds ~256kb)
+	 * @return A RunAutomaton, may have been built from scratch or loaded from a file
+	 */
+	RunAutomaton loadAutomaton(String automatonName, String regex, boolean tableize, boolean reverseAutomaton) {
+		if (reverseAutomaton){
+			automatonName+="_reversed_";
+		}
+		try{
+			if (isAutomatonCached(automatonName, regex)) {
+				return loadCachedAutomaton(automatonName);
+			}
+		}
+		catch (IOException e) {
+			LOG.warn("Error loading cached automaton: "+automatonName, e);
+		}
+		RunAutomaton automaton = createAutomaton(regex, tableize, reverseAutomaton);
+		cacheAutomaton(automatonName, automaton, regex);
+		return automaton;
+	}
+	
+	private boolean isAutomatonCached(String automatonName, String regex) {
+		String currentRegexHash = getRegexHash(regex);
+		String cachedRegexHash = getCachedRegexHash(automatonName);
+		return currentRegexHash.equals(cachedRegexHash);
+	}
+	
+	private String getRegexHash(String regex) {
+		return Integer.toString(regex.hashCode());
+	}
+
+	private String getCachedRegexHash(String automatonName) {
+		/*This file contains the hashcode of the regex which was used to generate the automaton on the disk */
+		return resourceGetter.getFileContentsAsString(automatonName + "RegexHash.txt");
+	}
+	
+	private RunAutomaton loadCachedAutomaton(String automatonName) throws IOException{
+		try (InputStream automatonInput = resourceGetter.getInputstreamFromFileName(automatonName +"SerialisedAutomaton.aut")){
+			return RunAutomaton.load(new BufferedInputStream(automatonInput));
+		} catch (Exception e) {
+			IOException ioe = new IOException("Error loading automaton");
+			ioe.initCause(e);
+			throw ioe;
+		}
+	}
+	
+	private static RunAutomaton createAutomaton(String regex, boolean tableize, boolean reverseAutomaton) {
+		Automaton a = new RegExp(regex).toAutomaton();
+		if (reverseAutomaton){
+			SpecialOperations.reverse(a);
+		}
+		return new RunAutomaton(a, tableize);
+	}
+
+	private void cacheAutomaton(String automatonName, RunAutomaton automaton, String regex) {
+		try (OutputStream regexHashOutputStream = resourceGetter.getOutputStream(automatonName + "RegexHash.txt")) {
+			regexHashOutputStream.write(getRegexHash(regex).getBytes(StandardCharsets.UTF_8));
+			try (OutputStream automatonOutputStream = resourceGetter.getOutputStream(automatonName + "SerialisedAutomaton.aut")) {
+				automaton.store(automatonOutputStream);
+			}
+		} catch (IOException e) {
+			LOG.warn("Error serialising automaton: "+automatonName, e);
+		}
+	}
+	
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/Bond.java

@@ -0,0 +1,184 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import uk.ac.cam.ch.wwmm.opsin.BondStereo.BondStereoValue;
+
+/**A bond, between two atoms.
+ *
+ * @author ptc24
+ * @author dl387
+ *
+ */
+class Bond {
+	/** The Atom the bond comes from */
+	private final Atom from;
+	/** The Atom the bond goes to */
+	private final Atom to;
+	/** The bond order */
+	private int order;
+
+	static enum SMILES_BOND_DIRECTION{
+		RSLASH,
+		LSLASH
+	}
+	/** If this bond was built from SMILES can be set to either RSLASH or LSLASH. Subsequently read to add a bondStereoElement
+	 * null by default*/
+	private SMILES_BOND_DIRECTION smilesBondDirection = null;
+
+	/**
+	 * Holds the bondStereo object associated with this bond
+	 * null by default
+	 */
+	private BondStereo bondStereo = null;
+
+	/** DO NOT CALL DIRECTLY EXCEPT FOR TESTING
+	 * Creates a new Bond.
+	 *
+	 * @param from The Atom the bond comes from.
+	 * @param to The Atom the bond goes to.
+	 * @param order The bond order.
+	 */
+	Bond(Atom from, Atom to, int order) {
+		if (from == to){
+			throw new IllegalArgumentException("Bonds must be made between different atoms");
+		}
+		if (order < 1 || order > 3){
+			throw new IllegalArgumentException("Bond order must be 1, 2 or 3");
+		}
+		if (from == null){
+			throw new IllegalArgumentException("From atom was null!");
+		}
+		if (to == null){
+			throw new IllegalArgumentException("To atom was null!");
+		}
+		this.from = from;
+		this.to = to;
+		this.order = order;
+	}
+
+	/**
+	 * Gets from ID
+	 * @return ID
+	 */
+	int getFrom() {
+		return from.getID();
+	}
+
+	/**
+	 * Gets to ID
+	 * @return ID
+	 */
+	int getTo() {
+		return to.getID();
+	}
+
+	/**Gets order.
+    * @return*/
+	int getOrder() {
+		return order;
+	}
+
+	/**Sets order.
+    * @param order*/
+	void setOrder(int order) {
+		this.order = order;
+	}
+
+	/**
+	 * Gets from Atom
+	 * @return Atom
+	 */
+	Atom getFromAtom() {
+		return from;
+	}
+
+	/**
+	 * Gets to Atom
+	 * @return Atom
+	 */
+	Atom getToAtom() {
+		return to;
+	}
+
+	/**Adds to the bond order.
+	 *
+	 * @param o The value to be added to the bond order.
+	 */
+	void addOrder(int o) {
+		order += o;
+	}
+
+	/**
+	 * Returns either null or RSLASH or LSLASH
+	 * @return
+	 */
+	SMILES_BOND_DIRECTION getSmilesStereochemistry() {
+		return smilesBondDirection;
+	}
+
+	void setSmilesStereochemistry(SMILES_BOND_DIRECTION bondDirection) {
+		this.smilesBondDirection = bondDirection;
+	}
+
+	BondStereo getBondStereo() {
+		return bondStereo;
+	}
+
+	void setBondStereo(BondStereo bondStereo) {
+		this.bondStereo = bondStereo;
+	}
+
+	void setBondStereoElement(Atom[] atomRefs4, BondStereoValue cOrT) {
+		bondStereo = new BondStereo(atomRefs4, cOrT);
+	}
+
+	/**
+	 * Returns the atom at the other end of the bond to given atom
+	 * @param atom
+	 * @return
+	 */
+	Atom getOtherAtom(Atom atom) {
+		if (from == atom){
+			return to;
+		}
+		else if (to == atom){
+			return from;
+		}
+		else{
+			return null;
+		}
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + from.getID();
+		result = prime * result + to.getID();
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (obj == null) {
+			return false;
+		}
+		if (getClass() != obj.getClass()) {
+			return false;
+		}
+		Bond other = (Bond) obj;
+		
+		if (from == other.from && 
+				to == other.to){
+			return true;
+		}
+		if (from == other.to && 
+				to == other.from){
+			return true;
+		}
+		
+		return false;
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/BondStereo.java

@@ -0,0 +1,58 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+/**
+ * Holds information about the positions of 2 atoms relative to a double bond allowing the specification of cis/trans stereochemistry
+ * @author dl387
+ *
+ */
+class BondStereo {
+
+	private Atom[] atomRefs4;
+	private BondStereoValue bondStereoValue;
+	
+	/**
+	 * Possible values for a bondStereo element
+	 * @author dl387
+	 *
+	 */
+	enum BondStereoValue{
+		CIS("C"),
+		TRANS("T");
+
+		private final String value;  
+		BondStereoValue(String value){
+			this.value = value;
+		}
+		@Override
+		public String toString() {
+			return value;
+		}
+	}
+
+	/**
+	 * Create a bondStereo from an array of 4 atoms. The 2nd and 3rd atoms of this array are connected via a double bond.
+	 * The 1st and 4th atoms are at either end of this bond and indication is given as to whether they are cis or trans to each other.
+	 * @param atomRefs4
+	 * @param cOrT
+	 */
+	BondStereo(Atom[] atomRefs4, BondStereoValue cOrT) {
+		if (atomRefs4.length !=4){
+			throw new IllegalArgumentException("atomRefs4 must contain references to 4 atoms");
+		}
+		this.atomRefs4 = atomRefs4;
+		this.bondStereoValue = cOrT;
+	}
+	
+	Atom[] getAtomRefs4() {
+		return atomRefs4;
+	}
+	void setAtomRefs4(Atom[] atomRefs4) {
+		this.atomRefs4 = atomRefs4;
+	}
+	BondStereoValue getBondStereoValue() {
+		return bondStereoValue;
+	}
+	void setBondStereoValue(BondStereoValue bondStereoValue) {
+		this.bondStereoValue = bondStereoValue;
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/BuildResults.java

@@ -0,0 +1,150 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * A "struct" to hold the results of fragment building.
+ * @author dl387
+ *
+ */
+class BuildResults {
+	/**Holds the atoms that are currently marked as radicals. An atom may be listed twice for say diyl
+	 * Typically these will be utilised by a word rule e.g. the ethyl of ethyl ethanoate has one
+	 * Also holds the order of the bond that will be created when it is used (valency)
+	 * setExplicitly says whether the outAtom absolutely definitely refers to that atom or not.
+	 * e.g. propyl is stored as prop-1-yl with this set to false while prop-2-yl has it set to true
+	 * These OutAtoms are the same objects as are present in the fragments*/
+	private final List<OutAtom> outAtoms = new ArrayList<>();
+
+	/**The atoms that may be used to from things like esters*/
+	private final List<FunctionalAtom> functionalAtoms = new ArrayList<>();
+
+	/**A list of fragments that have been evaluated to form this BuildResults. They are in the order they would be found in the XML*/
+	private final Set<Fragment> fragments = new LinkedHashSet<>();
+
+	/**A BuildResults is constructed from a list of Fragments.
+	 * This constructor creates this list from the groups present in an XML word/bracket/sub element.
+     * @param wordSubOrBracket*/
+	BuildResults(Element wordSubOrBracket) {
+		List<Element> groups = OpsinTools.getDescendantElementsWithTagName(wordSubOrBracket, XmlDeclarations.GROUP_EL);
+		for (Element group : groups) {
+			Fragment frag = group.getFrag();
+			fragments.add(frag);
+			for (int i = 0, l = frag.getOutAtomCount(); i < l; i++) {
+				outAtoms.add(frag.getOutAtom(i));
+			}
+			int functionalAtomCount = frag.getFunctionalAtomCount();
+			if (functionalAtomCount > 0){
+				Element parent = group.getParent();
+				if (parent.getName().equals(XmlDeclarations.ROOT_EL) ||
+						OpsinTools.getNextGroup(group) == null) {
+					for (int i = 0; i < functionalAtomCount; i++) {
+						functionalAtoms.add(frag.getFunctionalAtom(i));
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Construct a blank buildResults
+	 */
+	BuildResults() {}
+
+	/**
+	 * Returns a read only view of the fragments in this BuildResults
+	 * @return
+	 */
+	Set<Fragment> getFragments(){
+		return Collections.unmodifiableSet(fragments);
+	}
+
+	int getFragmentCount(){
+		return fragments.size();
+	}
+
+	OutAtom getOutAtom(int i) {
+		return outAtoms.get(i);
+	}
+
+	int getOutAtomCount() {
+		return outAtoms.size();
+	}
+
+	OutAtom removeOutAtom(int i) {
+		OutAtom outAtom = outAtoms.get(i);
+		outAtom.getAtom().getFrag().removeOutAtom(outAtom);
+		return outAtoms.remove(i);
+	}
+
+	void removeAllOutAtoms() {
+		for (int i = outAtoms.size() -1; i >=0 ; i--) {
+			removeOutAtom(i);
+		}
+	}
+
+	/**
+	 * Returns the atom corresponding to position i in the functionalAtoms list
+	 * @param i index
+	 * @return atom
+	 */
+	Atom getFunctionalAtom(int i) {
+		return functionalAtoms.get(i).getAtom();
+	}
+
+	FunctionalAtom removeFunctionalAtom(int i) {
+		FunctionalAtom functionalAtom = functionalAtoms.get(i);
+		functionalAtom.getAtom().getFrag().removeFunctionalAtom(functionalAtom);
+		return functionalAtoms.remove(i);
+	}
+
+	int getFunctionalAtomCount(){
+		return functionalAtoms.size();
+	}
+
+	/**
+	 * Returns the first OutAtom
+	 * @return OutAtom
+	 */
+	OutAtom getFirstOutAtom() {
+		return outAtoms.get(0);
+	}
+
+	/**
+	 * Returns the atom corresponding to the given id assuming the atom the id corresponds to is within the list of fragment in this Buildresults
+	 * @param id index
+	 * @return atom
+	 * @throws StructureBuildingException
+	 */
+	Atom getAtomByIdOrThrow(int id) throws StructureBuildingException {
+		for (Fragment fragment : fragments) {
+			Atom outAtom =fragment.getAtomByID(id);
+			if (outAtom != null){
+				return outAtom;
+			}
+		}
+		throw new StructureBuildingException("No fragment contained this id: " + id);
+	}
+
+	void mergeBuildResults(BuildResults otherBR) {
+		outAtoms.addAll(otherBR.outAtoms);
+		functionalAtoms.addAll(otherBR.functionalAtoms);
+		fragments.addAll(otherBR.fragments);
+	}
+
+	/**
+	 * Returns the sum of the charges of the fragments in the buildResults
+	 * @return
+	 */
+	int getCharge() {
+		int totalCharge = 0;
+		for (Fragment frag : fragments) {
+			totalCharge += frag.getCharge();
+		}
+		return totalCharge;
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/BuildState.java

@@ -0,0 +1,46 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import uk.ac.cam.ch.wwmm.opsin.OpsinWarning.OpsinWarningType;
+
+/**
+ * Used to pass the current configuration and FragmentManager around
+ * The currentWordRule can be mutated to keep track of what the parent wordRule is at the given time
+ *
+ * @author dl387
+ *
+ */
+class BuildState {
+
+	final FragmentManager fragManager;
+	final HashMap<Element, List<Fragment>> xmlSuffixMap;
+	final NameToStructureConfig n2sConfig;
+	// counter is used for DL- racemic stereochemistry in oligomers, we place each one in a separate racemic group,
+	// there is implicitly one group in-case the input has a combination of (RS)- and then DL-
+	int numRacGrps = 1;
+	private final List<OpsinWarning> warnings = new ArrayList<>();
+	
+	WordRule currentWordRule = null;
+
+	BuildState(NameToStructureConfig n2sConfig) {
+		this.n2sConfig = n2sConfig;
+		IDManager idManager = new IDManager();
+		fragManager = new FragmentManager(new SMILESFragmentBuilder(idManager), idManager);
+		xmlSuffixMap = new HashMap<>();
+	}
+
+	List<OpsinWarning> getWarnings() {
+		return warnings;
+	}
+	
+	void addWarning(OpsinWarningType type, String message) {
+		warnings.add(new OpsinWarning(type, message));
+	}
+	
+	void addIsAmbiguous(String message) {
+		warnings.add(new OpsinWarning(OpsinWarningType.APPEARS_AMBIGUOUS, message));
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/CASTools.java

@@ -0,0 +1,248 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Tools for converting CAS nomenclature into IUPAC nomenclature.
+ * @author dl387
+ */
+class CASTools {
+
+	private static final Pattern matchCasCollectiveIndex = Pattern.compile("([\\[\\(\\{]([1-9][0-9]?[cC][iI][, ]?)+[\\]\\)\\}])+|[1-9][0-9]?[cC][iI]", Pattern.CASE_INSENSITIVE);
+	private static final Pattern matchAcid = Pattern.compile("acid[\\]\\)\\}]*", Pattern.CASE_INSENSITIVE);
+	private static final Pattern matchCommaSpace = Pattern.compile(", ");
+	private static final Pattern matchCompoundWithPhrase = Pattern.compile("(compd\\. with|compound with|and) ", Pattern.CASE_INSENSITIVE);
+	private static final Pattern matchFunctionalTermAllowingSubstituentPrefix = Pattern.compile("(amide|hydrazide|(thi|selen|tellur)?oxime|hydrazone|(iso)?(semicarbazone|thiosemicarbazone|selenosemicarbazone|tellurosemicarbazone)|imide|imine|semioxamazone)[\\]\\)\\}]*", Pattern.CASE_INSENSITIVE);
+	
+	/**
+	 * Inverts a CAS name.
+	 * Throws an exception is OPSIN is unable to determine whether something is a substituent or functional term
+	 * or if something unexpected in a CAS name is encountered
+	 * @param name
+	 * @return
+	 * @throws ParsingException
+	 */
+	static String uninvertCASName(String name, ParseRules parseRules) throws ParsingException {
+		List<String> nameComponents = new ArrayList<>(Arrays.asList(matchCommaSpace.split(name)));
+		List<String> substituents = new ArrayList<>();
+		List<String> seperateWordSubstituents = new ArrayList<>();
+		List<String> functionalTerms = new ArrayList<>();
+
+		String parent = nameComponents.get(0);
+		String[] parentNameParts = parent.split(" ");
+		if (parentNameParts.length != 1) {
+			if (matchCasCollectiveIndex.matcher(parentNameParts[parentNameParts.length - 1]).matches()) {//CAS collective index description should be ignored
+				StringBuilder parentSB = new StringBuilder();
+				for (int i = 0; i < parentNameParts.length - 1; i++) {
+					parentSB.append(parentNameParts[i]);
+				}
+				parent = parentSB.toString();
+				parentNameParts = parent.split(" ");
+			}
+			for (int i = 1; i < parentNameParts.length; i++) {
+				if (!matchAcid.matcher(parentNameParts[i]).matches()) {
+					ParseRulesResults results = parseRules.getParses(parentNameParts[i]);
+					List<ParseTokens> parseTokens = results.getParseTokensList();
+					if (parseTokens.isEmpty()) {
+						throw new ParsingException("Invalid CAS name. Parent compound was followed by an unexpected term");
+					}
+				}
+			}
+		}
+		boolean addedBracket = false;
+		boolean esterEncountered = false;
+		for (int i = 1; i < nameComponents.size(); i++) {
+			String nameComponent = nameComponents.get(i);
+			Matcher m = matchCompoundWithPhrase.matcher(nameComponent);
+			boolean compoundWithcomponent = false;
+			if (m.lookingAt()) {
+				nameComponent = nameComponent.substring(m.group().length());
+				compoundWithcomponent = true;
+			}
+			String[] components = nameComponents.get(i).split(" ");
+			for (int c = 0, componentLen = components.length; c < componentLen; c++) {
+				String component = components[c];
+				if (compoundWithcomponent) {
+					functionalTerms.add(component);
+					continue;
+				}
+				if (component.endsWith("-")) {
+					Character missingCloseBracket = missingCloseBracketCharIfApplicable(component);
+					if (missingCloseBracket !=null) {
+						if (addedBracket) {
+							throw new ParsingException("Close bracket appears to be missing");
+						}
+						parent += missingCloseBracket;
+						addedBracket = true;
+					}
+					substituents.add(component);
+				} else {
+					ParseRulesResults results = parseRules.getParses(component);
+					List<ParseTokens> parseTokens = results.getParseTokensList();
+					if (parseTokens.size() > 0) {
+						List<ParseWord> parseWords = WordTools.splitIntoParseWords(parseTokens, component);
+
+						List<ParseTokens> firstParseWordTokens = parseWords.get(0).getParseTokens();
+						WordType firstWordType = OpsinTools.determineWordType(firstParseWordTokens.get(0).getAnnotations());
+						for (int j = 1; j < firstParseWordTokens.size(); j++) {
+							if (!firstWordType.equals(OpsinTools.determineWordType(firstParseWordTokens.get(j).getAnnotations()))) {
+								throw new ParsingException(component + "can be interpreted in multiple ways. For the sake of precision OPSIN has decided not to process this as a CAS name");
+							}
+						}
+						
+						if (parseWords.size() == 1) {
+							switch (firstWordType) {
+							case functionalTerm:
+								if (component.equalsIgnoreCase("ester")) {
+									if (seperateWordSubstituents.size() ==0){
+										throw new ParsingException("ester encountered but no substituents were specified in potential CAS name!");
+									}
+									if (esterEncountered) {
+										throw new ParsingException("ester formation was mentioned more than once in CAS name!");
+									}
+									parent = uninvertEster(parent);
+									esterEncountered = true;
+								} else {
+									functionalTerms.add(component);
+								}
+								break;
+							case substituent:
+								seperateWordSubstituents.add(component);
+								break;
+							case full:
+								if (StringTools.endsWithCaseInsensitive(component, "ate") || StringTools.endsWithCaseInsensitive(component, "ite")//e.g. Piperazinium, 1,1-dimethyl-, 2,2,2-trifluoroacetate hydrochloride
+										|| StringTools.endsWithCaseInsensitive(component, "ium")
+										|| StringTools.endsWithCaseInsensitive(component, "hydrofluoride") || StringTools.endsWithCaseInsensitive(component, "hydrochloride") 
+										|| StringTools.endsWithCaseInsensitive(component, "hydrobromide") || StringTools.endsWithCaseInsensitive(component, "hydroiodide")) {
+									functionalTerms.add(component);
+								} else if (StringTools.endsWithCaseInsensitive(component, "ic") && c + 1 < componentLen && components[c + 1].equalsIgnoreCase("acid")) {
+									functionalTerms.add(component);
+									functionalTerms.add(components[++c]);
+								} else {
+									throw new ParsingException("Unable to interpret: " + component + " (as part of a CAS index name)- A full word was encountered where a substituent or functionalTerm was expected");
+								}
+								break;
+							default:
+								throw new ParsingException("Unrecognised CAS index name form");
+							}
+						}
+						else if (parseWords.size() == 2 && firstWordType.equals(WordType.substituent)) {
+							//could be something like O-methyloxime which is parsed as [O-methyl] [oxime]
+							List<ParseTokens> secondParseWordTokens = parseWords.get(1).getParseTokens();
+							WordType secondWordType = OpsinTools.determineWordType(secondParseWordTokens.get(0).getAnnotations());
+							for (int j = 1; j < secondParseWordTokens.size(); j++) {
+								if (!secondWordType.equals(OpsinTools.determineWordType(secondParseWordTokens.get(j).getAnnotations()))) {
+									throw new ParsingException(component + "can be interpreted in multiple ways. For the sake of precision OPSIN has decided not to process this as a CAS name");
+								}
+							}
+							if (secondWordType.equals(WordType.functionalTerm) && 
+									matchFunctionalTermAllowingSubstituentPrefix.matcher(parseWords.get(1).getWord()).matches()){
+								functionalTerms.add(component);
+							}
+							else{
+								throw new ParsingException("Unrecognised CAS index name form, could have a missing space?");
+							}
+						}
+						else {
+							throw new ParsingException("Unrecognised CAS index name form");
+						}
+					} else {
+						if (!matchCasCollectiveIndex.matcher(component).matches()) {//CAS collective index description should be ignored
+							throw new ParsingException("Unable to interpret: " + component + " (as part of a CAS index name)");
+						}
+					}
+				}
+			}
+		}
+		StringBuilder casName = new StringBuilder();
+		for (String prefixFunctionalTerm : seperateWordSubstituents) {
+			casName.append(prefixFunctionalTerm);
+			casName.append(" ");
+		}
+		for (int i = substituents.size() - 1; i >= 0; i--) {
+			//stereochemistry term comes after substituent term. In older CAS names (9CI) this stereochemistry term can apply to the substituent term. Hence append in reverse order
+			casName.append(substituents.get(i));
+		}
+		casName.append(parent);
+		for (String functionalTerm : functionalTerms) {
+			casName.append(" ");
+			casName.append(functionalTerm);
+		}
+		return casName.toString();
+	}
+
+	private static Character missingCloseBracketCharIfApplicable(String component) {
+		int bracketLevel =0;
+		Character missingCloseBracket =null;
+		for (int i = 0, l = component.length(); i < l; i++) {
+			char character = component.charAt(i);
+			if (character == '(' || character == '[' || character == '{') {
+				bracketLevel++;
+				if (bracketLevel ==1){
+					missingCloseBracket = character;
+				}
+			}
+			if (character == ')' || character == ']' || character == '}') {
+				bracketLevel--;
+				if (bracketLevel<0){
+					return null;
+				}
+			}
+		}
+		if (bracketLevel == 1){
+			if (missingCloseBracket == '('){
+				return ')';
+			}
+			if (missingCloseBracket == '['){
+				return ']';
+			}
+			if (missingCloseBracket == '{'){
+				return '}';
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Modifies the name of the parent acid from ic to ate (or ous to ite)
+	 * hence allowing the formation of the uninverted ester
+	 * @param parent
+	 * @return
+	 * @throws ParsingException
+	 */
+	private static String uninvertEster(String parent) throws ParsingException {
+		int len = parent.length();
+		if (len == 0) {
+			throw new ParsingException("Failed to uninvert CAS ester");
+		}
+		char lastChar = parent.charAt(len - 1);
+		if (lastChar == ')') {
+			if (StringTools.endsWithCaseInsensitive(parent, "ic acid)")) {
+				parent = parent.substring(0, parent.length() - 8) + "ate)";
+			} else if (StringTools.endsWithCaseInsensitive(parent, "ous acid)")) {
+				parent = parent.substring(0, parent.length() - 9) + "ite)";
+			} else if (StringTools.endsWithCaseInsensitive(parent, "ine)")){//amino acid
+				parent = parent.substring(0, parent.length() - 2) + "ate)";
+			}
+			else{
+				throw new ParsingException("Failed to uninvert CAS ester");
+			}
+		} else {
+			if (StringTools.endsWithCaseInsensitive(parent, "ic acid")) {
+				parent = parent.substring(0, parent.length() - 7) + "ate";
+			} else if (StringTools.endsWithCaseInsensitive(parent, "ous acid")) {
+				parent = parent.substring(0, parent.length() - 8) + "ite";
+			} else if (StringTools.endsWithCaseInsensitive(parent, "ine")){//amino acid
+				parent = parent.substring(0, parent.length() - 1) + "ate";
+			}
+			else{
+				throw new ParsingException("Failed to uninvert CAS ester");
+			}
+		}
+		return parent;
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/CMLWriter.java

@@ -0,0 +1,217 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.io.ByteArrayOutputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.List;
+
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+import com.ctc.wstx.api.WstxOutputProperties;
+import com.ctc.wstx.stax.WstxOutputFactory;
+
+class CMLWriter {
+	/**
+	 * CML Elements/Attributes/NameSpace
+	 */
+	static final String CML_NAMESPACE = "http://www.xml-cml.org/schema";
+
+	private static final XMLOutputFactory factory = new WstxOutputFactory();
+	static {
+		factory.setProperty(WstxOutputProperties.P_OUTPUT_ESCAPE_CR, false);
+	}
+	
+	/**The XML writer*/
+	private final XMLStreamWriter writer;
+
+	/**
+	 * Creates a CML writer for the given fragment
+	 * @param writer 
+
+	 */
+	CMLWriter(XMLStreamWriter writer) {
+		this.writer = writer;
+	}
+	
+	static String generateCml(Fragment structure, String chemicalName) {
+		return generateCml(structure, chemicalName, false);
+	}
+	
+	static String generateIndentedCml(Fragment structure, String chemicalName) {
+		return generateCml(structure, chemicalName, true);
+	}
+	
+	private static String generateCml(Fragment structure, String chemicalName, boolean indent) {
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		try {
+			XMLStreamWriter xmlWriter = factory.createXMLStreamWriter(out, "UTF-8");
+			if (indent) {
+				xmlWriter = new IndentingXMLStreamWriter(xmlWriter, 2);
+			}
+			CMLWriter cmlWriter = new CMLWriter(xmlWriter);
+			cmlWriter.writeCmlStart();
+			cmlWriter.writeMolecule(structure, chemicalName, 1);
+			cmlWriter.writeCmlEnd();
+			xmlWriter.close();
+		} catch (XMLStreamException e) {
+			throw new RuntimeException(e);
+		}
+		try {
+			return out.toString("UTF-8");
+		} catch (UnsupportedEncodingException e) {
+			throw new RuntimeException("JVM doesn't support UTF-8...but it should do!");
+		}
+	}
+
+	void writeCmlStart(){
+		try {
+			writer.writeStartElement("cml");
+			writer.writeDefaultNamespace(CML_NAMESPACE);
+			writer.writeAttribute("convention", "conventions:molecular");
+			writer.writeNamespace("conventions", "http://www.xml-cml.org/convention/");
+			writer.writeNamespace("cmlDict", "http://www.xml-cml.org/dictionary/cml/");
+			writer.writeNamespace("nameDict", "http://www.xml-cml.org/dictionary/cml/name/");
+		} catch (XMLStreamException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	void writeCmlEnd(){
+		try {		
+			writer.writeEndElement();
+			writer.flush();
+		} catch (XMLStreamException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	void writeMolecule(Fragment structure, String chemicalName, int id) throws XMLStreamException {
+		writer.writeStartElement("molecule");
+		writer.writeAttribute("id", "m" + id);
+
+		writer.writeStartElement("name");
+		writer.writeAttribute("dictRef", "nameDict:unknown");
+		writer.writeCharacters(chemicalName);
+		writer.writeEndElement();
+		
+		if (structure != null) {
+			writer.writeStartElement("atomArray");
+			for(Atom atom : structure.getAtomList()) {
+				writeAtom(atom);
+			}
+			writer.writeEndElement();
+			
+			writer.writeStartElement("bondArray");
+			for(Bond bond : structure.getBondSet()) {
+				writeBond(bond);
+			}
+			writer.writeEndElement();
+		}
+		
+		writer.writeEndElement();
+	}
+	
+	private void writeAtom(Atom atom) throws XMLStreamException {
+		writer.writeStartElement("atom");
+		writer.writeAttribute("id", "a" + Integer.toString(atom.getID()));
+		writer.writeAttribute("elementType", atom.getElement().toString());
+		if(atom.getCharge() != 0){
+			writer.writeAttribute("formalCharge", Integer.toString(atom.getCharge()));
+		}
+		if(atom.getIsotope() != null){
+			writer.writeAttribute("isotopeNumber", Integer.toString(atom.getIsotope()));
+		}
+		if (atom.getElement() != ChemEl.H){
+			int hydrogenCount =0;
+			List<Atom> neighbours = atom.getAtomNeighbours();
+			for (Atom neighbour : neighbours) {
+				if (neighbour.getElement() == ChemEl.H){
+					hydrogenCount++;
+				}
+			}
+			if (hydrogenCount==0){//prevent adding of implicit hydrogen
+				writer.writeAttribute("hydrogenCount", "0");
+			}
+		}
+		AtomParity atomParity = atom.getAtomParity();
+		if(atomParity != null) {
+			StereoGroup stereoGroupType = atomParity.getStereoGroup();
+        	if (!((stereoGroupType == StereoGroup.Rac || stereoGroupType == StereoGroup.Rel) &&
+					countStereoGroup(atom) == 1)) {
+    			writeAtomParity(atomParity);
+        	}
+		}
+		for(String locant : atom.getLocants()) {
+			writer.writeStartElement("label");
+			writer.writeAttribute("value", locant);
+			writer.writeAttribute("dictRef", "cmlDict:locant");
+			writer.writeEndElement();
+		}
+		writer.writeEndElement();
+	}
+
+	private int countStereoGroup(Atom atom) {
+		int count = 0;
+		for (Atom a : atom.getFrag().getAtomList()) {
+			if (a.getAtomParity() == null)
+				continue;
+			if (a.getAtomParity().getStereoGroup().equals(atom.getAtomParity().getStereoGroup()) &&
+				a.getAtomParity().getStereoGroupNum() == atom.getAtomParity().getStereoGroupNum())
+				count++;
+		}
+		return count;
+	}
+
+	private void writeAtomParity(AtomParity atomParity) throws XMLStreamException {
+		writer.writeStartElement("atomParity");
+		writeAtomRefs4(atomParity.getAtomRefs4());
+		writer.writeCharacters(Integer.toString(atomParity.getParity()));
+		writer.writeEndElement();
+	}
+
+	private void writeBond(Bond bond) throws XMLStreamException {
+		writer.writeStartElement("bond");
+		writer.writeAttribute("id", "a" + Integer.toString(bond.getFrom()) + "_a" + Integer.toString(bond.getTo()));
+		writer.writeAttribute("atomRefs2", "a" + Integer.toString(bond.getFrom()) + " a" + Integer.toString(bond.getTo()));
+		switch (bond.getOrder()) {
+		case 1:
+			writer.writeAttribute("order", "S");
+			break;
+		case 2:
+			writer.writeAttribute("order", "D");
+			break;
+		case 3:
+			writer.writeAttribute("order", "T");
+			break;
+		default:
+			writer.writeAttribute("order", "unknown");
+			break;
+		}
+		BondStereo bondStereo = bond.getBondStereo();
+		if (bondStereo != null){
+			writeBondStereo(bondStereo);
+		}
+		writer.writeEndElement();
+	}
+
+	private void writeBondStereo(BondStereo bondStereo) throws XMLStreamException {
+		writer.writeStartElement("bondStereo");
+		writeAtomRefs4(bondStereo.getAtomRefs4());
+		writer.writeCharacters(bondStereo.getBondStereoValue().toString());
+		writer.writeEndElement();
+	}
+
+	private void writeAtomRefs4(Atom[] atomRefs4) throws XMLStreamException {
+		StringBuilder atomRefsSb = new StringBuilder();
+		for(int i = 0; i< atomRefs4.length - 1; i++) {
+			atomRefsSb.append('a');
+			atomRefsSb.append(atomRefs4[i].getID());
+			atomRefsSb.append(' ');
+		}
+		atomRefsSb.append('a');
+		atomRefsSb.append(atomRefs4[atomRefs4.length - 1].getID());
+		writer.writeAttribute("atomRefs4", atomRefsSb.toString());
+	}
+
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/ChemEl.java

@@ -0,0 +1,138 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+enum ChemEl {
+	R(0),
+	
+	H(1),
+	He(2),
+	Li(3),
+	Be(4),
+	B(5),
+	C(6),
+	N(7),
+	O(8),
+	F(9),
+	Ne(10),
+	Na(11),
+	Mg(12),
+	Al(13),
+	Si(14),
+	P(15),
+	S(16),
+	Cl(17),
+	Ar(18),
+	K(19),
+	Ca(20),
+	Sc(21),
+	Ti(22),
+	V(23),
+	Cr(24),
+	Mn(25),
+	Fe(26),
+	Co(27),
+	Ni(28),
+	Cu(29),
+	Zn(30),
+	Ga(31),
+	Ge(32),
+	As(33),
+	Se(34),
+	Br(35),
+	Kr(36),
+	Rb(37),
+	Sr(38),
+	Y(39),
+	Zr(40),
+	Nb(41),
+	Mo(42),
+	Tc(43),
+	Ru(44),
+	Rh(45),
+	Pd(46),
+	Ag(47),
+	Cd(48),
+	In(49),
+	Sn(50),
+	Sb(51),
+	Te(52),
+	I(53),
+	Xe(54),
+	Cs(55),
+	Ba(56),
+	La(57),
+	Ce(58),
+	Pr(59),
+	Nd(60),
+	Pm(61),
+	Sm(62),
+	Eu(63),
+	Gd(64),
+	Tb(65),
+	Dy(66),
+	Ho(67),
+	Er(68),
+	Tm(69),
+	Yb(70),
+	Lu(71),
+	Hf(72),
+	Ta(73),
+	W(74),
+	Re(75),
+	Os(76),
+	Ir(77),
+	Pt(78),
+	Au(79),
+	Hg(80),
+	Tl(81),
+	Pb(82),
+	Bi(83),
+	Po(84),
+	At(85),
+	Rn(86),
+	Fr(87),
+	Ra(88),
+	Ac(89),
+	Th(90),
+	Pa(91),
+	U(92),
+	Np(93),
+	Pu(94),
+	Am(95),
+	Cm(96),
+	Bk(97),
+	Cf(98),
+	Es(99),
+	Fm(100),
+	Md(101),
+	No(102),
+	Lr(103),
+	Rf(104),
+	Db(105),
+	Sg(106),
+	Bh(107),
+	Hs(108),
+	Mt(109),
+	Ds(110),
+	Rg(111),
+	Cn(112),
+	Nh(113),
+	Fl(114),
+	Mc(115),
+	Lv(116),
+	Ts(117),
+	Og(118);
+	
+	final int ATOMIC_NUM;
+
+	private ChemEl(int atomicNum) {
+		this.ATOMIC_NUM = atomicNum;
+	}
+	
+	boolean isChalcogen() {
+		return (this == O || this == S || this == Se || this == Te);
+	}
+	
+	boolean isHalogen() {
+		return (this == F || this == Cl || this == Br || this == I);
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/CipOrderingException.java

@@ -0,0 +1,29 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+/**Thrown if the ordering of ligands can now be determined by OPSIN's implementation of the CIP rules.
+ * This could be due to a limitation of the implementation or ligands actually being indistinguishable
+ *
+ * @author dl387
+ *
+ */
+class CipOrderingException extends StereochemistryException {
+
+	private static final long serialVersionUID = 1L;
+
+	CipOrderingException() {
+		super();
+	}
+
+	CipOrderingException(String message) {
+		super(message);
+	}
+
+	CipOrderingException(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+	CipOrderingException(Throwable cause) {
+		super(cause);
+	}
+
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/CipSequenceRules.java

@@ -0,0 +1,470 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * An implementation of rules 1-2 of the CIP rules i.e. constitutional differences then isotopes if there is a tie
+ * Cases that require rules 3-5 to distinguish result in an exception
+ * 
+ * Phantom atoms are not added as I believe that the results of the program will still be the same even in their absence as everything beats a phantom and comparing phantoms to phantoms achieves nothing
+ * (higher ligancy beats lower ligancy when comparisons are performed)
+ * @author dl387
+ *
+ */
+class CipSequenceRules {
+	private static class CipOrderingRunTimeException extends RuntimeException {
+		private static final long serialVersionUID = 1L;
+		CipOrderingRunTimeException(String message) {
+			super(message);
+		}
+	}
+	
+	private final Atom chiralAtom;
+	
+    CipSequenceRules(Atom chiralAtom) {
+		this.chiralAtom = chiralAtom;
+	}
+    
+	/**
+	 * Returns the chiral atom's neighbours in CIP order from lowest priority to highest priority
+	 * @return
+	 * @throws CipOrderingException 
+	 */
+	List<Atom> getNeighbouringAtomsInCipOrder() throws CipOrderingException {
+		List<Atom> neighbours = chiralAtom.getAtomNeighbours();
+		try {
+			Collections.sort(neighbours, new SortByCipOrder(chiralAtom));
+		}
+		catch (CipOrderingRunTimeException e) {
+			throw new CipOrderingException(e.getMessage());
+		}
+		return neighbours;
+	}
+	
+	/**
+	 * Returns  the chiral atom's neighbours, with the exception of the given atom, in CIP order from lowest priority to highest priority
+	 * @param neighbourToIgnore
+	 * @return
+	 * @throws CipOrderingException 
+	 */
+	List<Atom> getNeighbouringAtomsInCipOrderIgnoringGivenNeighbour(Atom neighbourToIgnore) throws CipOrderingException {
+		List<Atom> neighbours = chiralAtom.getAtomNeighbours();
+		if (!neighbours.remove(neighbourToIgnore)) {
+			throw new IllegalArgumentException("OPSIN bug: Atom" + neighbourToIgnore.getID() +" was not a neighbour of the given stereogenic atom");
+		}
+		try {
+			Collections.sort(neighbours, new SortByCipOrder(chiralAtom));
+		}
+		catch (CipOrderingRunTimeException e) {
+			throw new CipOrderingException(e.getMessage());
+		}
+		return neighbours;
+	}
+
+	
+	/**
+	 * Holds information about what atoms to try next next and how those atoms were reached (to prevent immediate back tracking and to detect cycles)
+	 * @author dl387
+	 *
+	 */
+	private static class CipState {
+		CipState(List<AtomWithHistory> nextAtoms1, List<AtomWithHistory> nextAtoms2) {
+			this.nextAtoms1 = nextAtoms1;
+			this.nextAtoms2 = nextAtoms2;
+		}
+		final List<AtomWithHistory> nextAtoms1;
+		final List<AtomWithHistory> nextAtoms2;
+	}
+	
+	/**
+	 * Holds an atom with associated visited atoms
+	 * @author dl387
+	 *
+	 */
+	private static class AtomWithHistory {
+		AtomWithHistory(Atom atom, List<Atom> visitedAtoms, Integer indexOfOriginalFromRoot) {
+			this.atom = atom;
+			this.visitedAtoms = visitedAtoms;
+			this.indexOfOriginalFromRoot = indexOfOriginalFromRoot;
+		}
+		final Atom atom;
+		final List<Atom> visitedAtoms;
+		final Integer indexOfOriginalFromRoot;
+	}
+	
+	/**
+	 * Sorts atoms by their CIP order, low to high
+	 * @author dl387
+	 *
+	 */
+	private class SortByCipOrder implements Comparator<Atom> {
+		private final Atom chiralAtom;
+		private final AtomListCipComparator atomListCipComparator = new AtomListCipComparator();
+		private final ListOfAtomListsCipComparator listOfAtomListsCipComparator = new ListOfAtomListsCipComparator();
+		private final CipComparator cipComparator = new CipComparator();
+		private int rule = 0;
+		
+
+		SortByCipOrder(Atom chiralAtom) {
+			this.chiralAtom = chiralAtom;
+		}
+		
+		public int compare(Atom a, Atom b) {
+	    	/*
+	    	 * rule = 0 --> Rule 1a Higher atomic number precedes lower
+	    	 * rule = 1 --> Rule 1b A duplicated atom, with its predecessor node having the same label closer to the root, ranks higher than a duplicated atom, with its predecessor node having the same label farther from the root, which ranks higher than any non-duplicated atom node
+	    	 * rule = 2 --> Rule 2 Higher atomic mass number precedes lower
+	    	 */
+	    	for (rule = 0; rule <= 2; rule++) {
+				List<Atom> atomsVisted = new ArrayList<>();
+				atomsVisted.add(chiralAtom);
+				AtomWithHistory aWithHistory = new AtomWithHistory(a, atomsVisted, null);
+				AtomWithHistory bWithHistory = new AtomWithHistory(b, new ArrayList<>(atomsVisted), null);
+				
+	    		int compare = compareByCipRules(aWithHistory, bWithHistory);
+				if (compare != 0) {
+					return compare;
+				}
+				
+				List<AtomWithHistory> nextAtoms1 = new ArrayList<>();
+				nextAtoms1.add(aWithHistory);
+				
+				List<AtomWithHistory> nextAtoms2 = new ArrayList<>();
+				nextAtoms2.add(bWithHistory);
+
+				CipState startingState = new CipState(nextAtoms1, nextAtoms2);
+		    	Deque<CipState> cipStateQueue = new ArrayDeque<>();
+		    	cipStateQueue.add(startingState);
+		    	/* Go through CIP states in a breadth-first manner:
+		    	 * Neighbours of the given atom/s (if multiple atoms this is because so far the two paths leading to them have been equivalent) are evaluated for both a and b
+		    	 * Neighbours are sorted by CIP priority
+		    	 * Comparisons performed between neighbours of a and neighbours of b (will break if compare != 0)
+		    	 * Degenerate neighbours grouped together
+		    	 * CIP state formed for each list of neighbours and added to queue in order of priority
+		    	 *
+		    	 */
+		    	while(!cipStateQueue.isEmpty()) {
+		    		CipState currentState = cipStateQueue.removeFirst();
+		    		compare = compareAtNextLevel(currentState, cipStateQueue);
+		    		if (compare != 0) {
+		    			return compare;
+		    		}
+		    	}
+			}
+	    	throw new CipOrderingRunTimeException("Failed to assign CIP stereochemistry, this indicates a bug in OPSIN or a limitation in OPSIN's implementation of the sequence rules");
+	    }
+
+		/**
+		 * Compares the neighbours of the atoms specified in nextAtom1/2 in cipstate.
+		 * Returns the result of the comparison between these neighbours
+		 * If the comparison returned 0 adds new cipstates to the queue
+		 * @param cipState
+		 * @param queue
+		 * @return
+		 */
+		private int compareAtNextLevel(CipState cipState, Queue<CipState> queue) {
+			List<List<AtomWithHistory>> neighbours1 = getNextLevelNeighbours(cipState.nextAtoms1);
+			List<List<AtomWithHistory>> neighbours2 = getNextLevelNeighbours(cipState.nextAtoms2);
+
+			int compare = compareNeighboursByCipPriorityRules(neighbours1, neighbours2);
+
+			if (compare != 0) {
+				return compare;
+			}
+	    	List<List<AtomWithHistory>> prioritisedNeighbours1 = formListsWithSamePriority(neighbours1);
+	    	List<List<AtomWithHistory>> prioritisedNeighbours2 = formListsWithSamePriority(neighbours2);
+
+	    	//As earlier compare was 0, prioritisedNeighbours1.size() == prioritisedNeighbours2.size()
+	    	for (int i = prioritisedNeighbours1.size() - 1; i >= 0; i--) {
+	    		queue.add(new CipState(prioritisedNeighbours1.get(i), prioritisedNeighbours2.get(i)));
+			}
+	    	return 0;
+		}
+		
+		private int compareNeighboursByCipPriorityRules(List<List<AtomWithHistory>> neighbours1, List<List<AtomWithHistory>> neighbours2) {
+			int difference = listOfAtomListsCipComparator.compare(neighbours1, neighbours2);
+			if (difference >0) {
+				return 1;
+			}
+			if (difference < 0) {
+				return -1;
+			}
+			return 0;
+		}
+		
+		private List<List<AtomWithHistory>> getNextLevelNeighbours(List<AtomWithHistory> nextAtoms) {
+			List<List<AtomWithHistory>> neighbourLists = new ArrayList<>();
+			for (AtomWithHistory nextAtom : nextAtoms) {
+				neighbourLists.add(getNextAtomsWithAppropriateGhostAtoms(nextAtom));
+			}
+			Collections.sort(neighbourLists, atomListCipComparator);
+			return neighbourLists;
+		}
+
+		/**
+		 * If given say [H,C,C] this becomes [H] [C,C] 
+		 * If given say [H,C,C] [H,C,C] this becomes [H,H] [C,C,C,C]
+		 * If given say [H,C,C] [H,C,F] this becomes [H],[C,C][H][C][F]
+		 * as [H,C,F] is higher priority than [H,C,C] so all its atoms must be evaluated first
+		 * The input lists of neighbours are assumed to have been presorted.
+		 * @param neighbourLists
+		 */
+		private List<List<AtomWithHistory>> formListsWithSamePriority(List<List<AtomWithHistory>> neighbourLists) {
+			int intialNeighbourListCount = neighbourLists.size();
+			if (intialNeighbourListCount > 1) {
+				List<List<AtomWithHistory>> listsToRemove  = new ArrayList<>();
+				for (int i = 0; i < intialNeighbourListCount; i++) {
+					List<List<AtomWithHistory>> neighbourListsToCombine = new ArrayList<>();
+					List<AtomWithHistory> primaryAtomList = neighbourLists.get(i);
+					for (int j = i + 1; j < intialNeighbourListCount; j++) {
+						List<AtomWithHistory> neighbourListToCompareWith = neighbourLists.get(j);
+						if (atomListCipComparator.compare(primaryAtomList, neighbourListToCompareWith) == 0) {
+							neighbourListsToCombine.add(neighbourListToCompareWith);
+							i++;
+						}
+						else {
+							break;
+						}
+					}
+					for (List<AtomWithHistory> neighbourList: neighbourListsToCombine) {
+						listsToRemove.add(neighbourList);
+						primaryAtomList.addAll(neighbourList);
+					}
+				}
+				neighbourLists.removeAll(listsToRemove);
+			}
+
+			List<List<AtomWithHistory>> updatedNeighbourLists  = new ArrayList<>();
+			//lists of same priority have already been combined (see above) e.g. [H,C,C] [H,C,C] -->[H,C,C,H,C,C]
+			//now sort these combined lists by CIP priority
+			//then group atoms that have the same CIP priority
+			for (int i = 0, lstsLen = neighbourLists.size(); i < lstsLen; i++) {
+				List<AtomWithHistory> neighbourList = neighbourLists.get(i);
+				Collections.sort(neighbourList, cipComparator);
+				AtomWithHistory lastAtom = null;
+				List<AtomWithHistory> currentAtomList = new ArrayList<>();
+				for (int j = 0, lstLen = neighbourList.size(); j < lstLen; j++) {
+					AtomWithHistory a = neighbourList.get(j);
+					if (lastAtom != null && compareByCipRules(lastAtom, a) != 0) {
+						updatedNeighbourLists.add(currentAtomList);
+						currentAtomList = new ArrayList<>();
+					}
+					currentAtomList.add(a);
+					lastAtom = a;
+				}
+				if (!currentAtomList.isEmpty()) {
+					updatedNeighbourLists.add(currentAtomList);
+				}
+			}
+			return updatedNeighbourLists;
+		}
+
+
+		/**
+		 * Sorts atoms by their atomic number, low to high
+		 * @author dl387
+		 *
+		 */
+		private class CipComparator implements Comparator<AtomWithHistory> {
+		    public int compare(AtomWithHistory a, AtomWithHistory b) {
+		    	return compareByCipRules(a, b);
+		    }
+		}
+
+		/**
+		 * Sorts atomLists by CIP rules, low to high
+		 * @author dl387
+		 *
+		 */
+		private class AtomListCipComparator implements Comparator<List<AtomWithHistory>> {
+			public int compare(List<AtomWithHistory> a, List<AtomWithHistory> b) {
+		    	int aSize = a.size();
+		    	int bSize = b.size();
+		    	int differenceInSize = aSize - bSize;
+		    	int maxCommonSize = aSize > bSize ? bSize : aSize;
+		    	for (int i = 1; i <= maxCommonSize; i++) {
+					int difference = compareByCipRules(a.get(aSize - i), b.get(bSize - i));
+					if (difference > 0) {
+						return 1;
+					}
+					if (difference < 0) {
+						return -1;
+					}
+				}
+		    	if (differenceInSize > 0) {
+		    		return 1;
+		    	}
+		    	if (differenceInSize < 0) {
+		    		return -1;
+		    	}
+		    	return 0;
+		    }
+		}
+		
+		/**
+		 * Sorts lists of atomLists by CIP rules, low to high
+		 * @author dl387
+		 *
+		 */
+		private class ListOfAtomListsCipComparator implements Comparator<List<List<AtomWithHistory>>> {
+			public int compare(List<List<AtomWithHistory>> a, List<List<AtomWithHistory>> b) {
+		    	int aSize = a.size();
+		    	int bSize = b.size();
+		    	int differenceInSize = aSize - bSize;
+		    	int maxCommonSize = aSize > bSize ? bSize : aSize;
+		    	for (int i = 1; i <= maxCommonSize; i++) {
+		    		List<AtomWithHistory> aprime = a.get(aSize - i);
+		    		List<AtomWithHistory> bprime = b.get(bSize - i);
+			    	int aprimeSize = aprime.size();
+			    	int bprimeSize = bprime.size();
+			    	int differenceInSizeprime = aprimeSize - bprimeSize;
+			    	int maxCommonSizeprime = aprimeSize > bprimeSize ? bprimeSize : aprimeSize;
+			    	for (int j = 1; j <= maxCommonSizeprime; j++) {
+			    		int difference = compareByCipRules(aprime.get(aprimeSize - j), bprime.get(bprimeSize - j));
+						if (difference > 0) {
+							return 1;
+						}
+						if (difference < 0) {
+							return -1;
+						}
+			    	}
+			    	if (differenceInSizeprime > 0) {
+			    		return 1;
+			    	}
+			    	if (differenceInSizeprime < 0) {
+			    		return -1;
+			    	}
+				}
+		    	if (differenceInSize > 0) {
+		    		return 1;
+		    	}
+		    	if (differenceInSize < 0) {
+		    		return -1;
+		    	}
+		    	return 0;
+		    }
+		}
+		
+		/**
+		 * Gets the neighbouring atoms bar the previous atom in CIP order
+		 * If the neighbouring atom has already been visited it is replaced with a ghost atom
+		 * Multiple bonds including those to previous atoms yield ghost atoms unless the bond goes to the chiral atom e.g. in a sulfoxide
+		 * @param atoms
+		 * @return
+		 */
+		private List<AtomWithHistory> getNextAtomsWithAppropriateGhostAtoms(AtomWithHistory atomWithHistory) {
+			Atom atom = atomWithHistory.atom;
+			List<Atom> visitedAtoms = atomWithHistory.visitedAtoms;
+			Atom previousAtom = visitedAtoms.get(visitedAtoms.size()-1);
+			List<Atom> visitedAtomsIncludingCurrentAtom = new ArrayList<>(visitedAtoms);
+			visitedAtomsIncludingCurrentAtom.add(atom);
+
+			List<AtomWithHistory> neighboursWithHistory = new ArrayList<>();
+			for(Bond b :  atom.getBonds()) {
+				Atom atomBondConnectsTo = b.getOtherAtom(atom);
+				if (!atomBondConnectsTo.equals(chiralAtom)) {//P-91.1.4.2.4 (higher order bonds to chiral centre do not involve duplication of atoms)
+					for (int j = b.getOrder(); j >1; j--) {//add ghost atoms to represent higher order bonds
+						Atom ghost = new Atom(atomBondConnectsTo.getElement());
+						if (rule > 0) {
+							int indexOfOriginalAtom = visitedAtoms.indexOf(atomBondConnectsTo);
+							if (indexOfOriginalAtom != -1) {
+								neighboursWithHistory.add(new AtomWithHistory(ghost, visitedAtomsIncludingCurrentAtom, indexOfOriginalAtom));
+							}
+							else{
+								neighboursWithHistory.add(new AtomWithHistory(ghost, visitedAtomsIncludingCurrentAtom, visitedAtoms.size() + 1));
+							}
+						}
+						else{
+							neighboursWithHistory.add(new AtomWithHistory(ghost, visitedAtomsIncludingCurrentAtom, null));
+						}
+					}
+				}
+				if (!atomBondConnectsTo.equals(previousAtom)) {
+					if (visitedAtoms.contains(atomBondConnectsTo)) {//cycle detected, add ghost atom instead
+						Atom ghost = new Atom(atomBondConnectsTo.getElement());
+						if (rule > 0) {
+							neighboursWithHistory.add(new AtomWithHistory(ghost, visitedAtomsIncludingCurrentAtom, visitedAtoms.indexOf(atomBondConnectsTo)));
+						}
+						else{
+							neighboursWithHistory.add(new AtomWithHistory(ghost, visitedAtomsIncludingCurrentAtom, null));
+						}
+					}
+					else{
+						neighboursWithHistory.add(new AtomWithHistory(atomBondConnectsTo, visitedAtomsIncludingCurrentAtom, null));
+					}
+				}
+			}
+			Collections.sort(neighboursWithHistory, cipComparator);
+			return neighboursWithHistory;
+		}
+		
+		/**
+		 * Greater than 0 means a is preferred over b (vice versa for less than 1)
+		 * @param a
+		 * @param b
+		 * @return
+		 */
+	    private int compareByCipRules(AtomWithHistory a, AtomWithHistory b) {
+	    	//rule 1a
+	    	//prefer higher atomic number
+	    	int atomicNumber1 = a.atom.getElement().ATOMIC_NUM;
+	    	int atomicNumber2 = b.atom.getElement().ATOMIC_NUM;
+	    	if (atomicNumber1 > atomicNumber2) {
+	    		return 1;
+	    	}
+	    	else if (atomicNumber1 < atomicNumber2) {
+	    		return -1;
+	    	}
+	    	if (rule > 0) {
+	    		//rule 1b
+	    		//prefer duplicate to non-duplicate
+	    		Integer indexFromRoot1 = a.indexOfOriginalFromRoot;
+	       		Integer indexFromRoot2 = b.indexOfOriginalFromRoot;
+	    		if (indexFromRoot1 != null && indexFromRoot2 == null) {
+	    			return 1;
+	    		}
+	    		if (indexFromRoot1 == null && indexFromRoot2 != null) {
+	    			return -1;
+	    		}
+	    		//prefer duplicate of node closer to root
+	    		if (indexFromRoot1 != null && indexFromRoot2 != null) {
+	    	 		if (indexFromRoot1 < indexFromRoot2 ) {
+		    			return 1;
+		    		}
+	    	 		if (indexFromRoot1 > indexFromRoot2 ) {
+		    			return -1;
+		    		}
+	    		}
+	    		if (rule > 1) {
+		    		//rule 2
+		    		//prefer higher atomic mass
+	    	    	Integer atomicMass1 = a.atom.getIsotope();
+	    	    	Integer atomicMass2 = b.atom.getIsotope();
+	    	    	if (atomicMass1 != null && atomicMass2 == null) {
+	    	    		return 1;
+	    	    	}
+	    	    	else if (atomicMass1 == null && atomicMass2 != null) {
+	    	    		return -1;
+	    	    	}
+	    	    	else if (atomicMass1 != null && atomicMass2 != null) {
+	    	        	if (atomicMass1 > atomicMass2) {
+		    	    		return 1;
+		    	    	}
+		    	    	else if (atomicMass1 < atomicMass2) {
+		    	    		return -1;
+		    	    	}
+	    	    	}
+	    		}
+	    		
+	    	}
+			return 0;
+	    }
+	}
+
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/ComponentGenerationException.java

@@ -0,0 +1,28 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+/**Thrown during component generation.
+ *
+ * @author ptc24
+ *
+ */
+class ComponentGenerationException extends Exception {
+
+	private static final long serialVersionUID = 1L;
+
+	ComponentGenerationException() {
+		super();
+	}
+
+	ComponentGenerationException(String message) {
+		super(message);
+	}
+
+	ComponentGenerationException(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+	ComponentGenerationException(Throwable cause) {
+		super(cause);
+	}
+
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/CycleDetector.java

@@ -0,0 +1,128 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Assigns whether atoms are in rings or not
+ * @author dl387
+ *
+ */
+class CycleDetector {
+
+	/**
+	 * Performs a depth first search for rings hence assigning whether atoms are in rings or not
+	 * This is necessary for deciding the applicability, and in some cases meaning, of suffixes and to determine what atoms are capable of having spare valency
+	 * Fragments made of disconnected sections are supported
+	 * @param frag
+	 */
+	static void assignWhetherAtomsAreInCycles(Fragment frag) {
+		List<Atom> atomList = frag.getAtomList();
+		for (Atom atom : atomList) {
+			atom.setAtomIsInACycle(false);
+			atom.setProperty(Atom.VISITED, null);
+		}
+		for (Atom a : atomList) {//as OPSIN does not disallow disconnected sections within a single "fragment" (e.g. in suffixes) for vigorousness this for loop is required
+			if(a.getProperty(Atom.VISITED) == null){//true for only the first atom in a fully connected molecule
+				traverseRings(a, null, 0);
+			}
+		}
+	}
+	
+	private static int traverseRings(Atom currentAtom, Atom previousAtom, int depth){
+		Integer previouslyAssignedDepth = currentAtom.getProperty(Atom.VISITED);
+		if(previouslyAssignedDepth != null){
+			return previouslyAssignedDepth;
+		}
+		currentAtom.setProperty(Atom.VISITED, depth);
+		List<Atom> equivalentAtoms = new ArrayList<>();
+		equivalentAtoms.add(currentAtom);
+		
+		List<Atom> neighbours;
+		for(;;) {
+			//Non-recursively process atoms in a chain
+			//add the atoms in the chain to equivalentAtoms as either all or none of them are in a ring
+			neighbours = currentAtom.getAtomNeighbours();
+			neighbours.remove(previousAtom);
+			if (neighbours.size() != 1) {
+				break;
+			}
+			Atom nextAtom = neighbours.get(0);
+			if (nextAtom.getProperty(Atom.VISITED) != null) {
+				//chain reached a previously visited atom, must be a ring
+				break;
+			}
+			previousAtom = currentAtom;
+			currentAtom = nextAtom;
+			equivalentAtoms.add(currentAtom);
+			currentAtom.setProperty(Atom.VISITED, ++depth);
+		}
+
+		int result = depth + 1;
+		for (Atom neighbour : neighbours) {
+		  int temp = traverseRings(neighbour, currentAtom, depth + 1);
+		  result = Math.min(result, temp);
+		}
+		if (result < depth){
+			for (Atom a : equivalentAtoms) {
+				a.setAtomIsInACycle(true);
+			}
+		} else if (result == depth) {
+			currentAtom.setAtomIsInACycle(true);
+		}
+		return result;
+	}
+
+	private static class PathSearchState{
+		final Atom currentAtom;
+		final List<Atom> orderAtomsVisited;
+		public PathSearchState(Atom currentAtom, List<Atom> orderAtomsVisited ) {
+			this.currentAtom = currentAtom;
+			this.orderAtomsVisited = orderAtomsVisited;
+		}
+		Atom getCurrentAtom() {
+			return currentAtom;
+		}
+		List<Atom> getOrderAtomsVisited() {
+			return orderAtomsVisited;
+		}
+	}
+	
+	/**
+	 * Attempts to find paths from a1 to a2 using only the given bonds
+	 * @param a1
+	 * @param a2
+	 * @param peripheryBonds
+	 * @return
+	 */
+	static List<List<Atom>> getPathBetweenAtomsUsingBonds(Atom a1, Atom a2, Set<Bond> peripheryBonds){
+		List<List<Atom>> paths = new ArrayList<>();
+		Deque<PathSearchState> stateStack = new ArrayDeque<>();
+		stateStack.add(new PathSearchState(a1, new ArrayList<>()));
+		while (stateStack.size()>0){
+			PathSearchState state  =stateStack.removeLast();//depth first traversal
+			List<Atom> orderAtomsVisited = state.getOrderAtomsVisited();
+			Atom nextAtom = state.getCurrentAtom();
+			orderAtomsVisited.add(nextAtom);
+			Set<Bond> neighbourBonds = new LinkedHashSet<>(nextAtom.getBonds());
+			neighbourBonds.retainAll(peripheryBonds);
+			for (Bond neighbourBond : neighbourBonds) {
+				Atom neighbour = neighbourBond.getOtherAtom(nextAtom);
+				if (orderAtomsVisited.contains(neighbour)){//atom already visited by this path
+					continue;
+				}
+				if (neighbour ==a2 ){//target atom found
+					paths.add(new ArrayList<>(orderAtomsVisited.subList(1, orderAtomsVisited.size())));
+				}
+				else{//add atom to stack, its neighbours will be recursively investigated shortly
+					stateStack.add(new PathSearchState(neighbour, new ArrayList<>(orderAtomsVisited)));
+				}
+			}
+		}
+		return paths;
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/CyclicAtomList.java

@@ -0,0 +1,140 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.List;
+
+/**
+ * Convenience class for iterating over a list of atoms that form a ring
+ * Doing getNext when the index is the final atom in the list will return the first atom
+ * Doing getPrevious when the index is the first atom in the list will return the final atom
+ * @author dl387
+ *
+ */
+class CyclicAtomList{
+	private int index = -1;
+	private final List<Atom> atomList;
+
+	/**
+	 * Construct a cyclicAtomList from an atomList
+	 * Index defaults to -1
+	 * @param atomList
+	 */
+	CyclicAtomList(List<Atom> atomList) {
+		this.atomList = atomList;
+	}
+	
+	/**
+	 * Construct a cyclicAtomList from an atomList
+	 * The second parameter sets the current index
+	 * @param atomList
+	 * @param index
+	 */
+	CyclicAtomList(List<Atom> atomList, int index)  {
+		this.atomList = atomList;
+		setIndex(index);
+	}
+	
+	/**
+	 * Returns the number of elements in this list. If this list contains more
+	 * than <tt>Integer.MAX_VALUE</tt> elements, returns
+	 * <tt>Integer.MAX_VALUE</tt>.
+	 * 
+	 * @return the number of elements in this list
+	 */
+	int size() {
+		return atomList.size();
+	}
+
+	/**
+	 * Returns the atom at the specified position in this list.
+	 * @param index index of the element to return
+	 * @return Atom the atom at the specified position in this list
+	 * @throws IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= size())
+	 */
+	Atom get(int index) throws IndexOutOfBoundsException {
+		return atomList.get(index);
+	}
+
+	/**
+	 * Return the current index in the list
+	 * @return
+	 */
+	int getIndex() {
+		return index;
+	}
+
+	/**
+	 * Set the current index
+	 * @param index
+	 */
+	void setIndex(int index) {
+		if (index >= atomList.size()){
+			throw new IllegalArgumentException("Specified index is not within ringAtom list");
+		}
+		this.index = index;
+	}
+
+	/**
+	 * Increments and returns the atom at the new index in the list (next atom)
+	 * When the index is the final atom in the list will return the first atom
+	 * @return
+	 */
+	Atom next() {
+		int tempIndex = index + 1;
+		if (tempIndex >= atomList.size()){
+			tempIndex = 0;
+		}
+		index = tempIndex;
+		return atomList.get(index);
+	}
+	
+	/**
+	 * Decrements and returns the atom at the new index in the list (previous atom)
+	 * when the index is the first atom in the list will return the final atom
+	 * @return
+	 */
+	Atom previous() {
+		int tempIndex = index - 1;
+		if (tempIndex < 0){
+			tempIndex = atomList.size() -1 ;
+		}
+		index = tempIndex;
+		return atomList.get(index);
+	}
+	
+	/**
+	 * Returns the next atom in the list
+	 * When the index is the final atom in the list will return the first atom
+	 * Doesn't effect the list
+	 * @return
+	 */
+	Atom peekNext() {
+		int tempIndex = index + 1;
+		if (tempIndex >= atomList.size()){
+			tempIndex = 0;
+		}
+		return atomList.get(tempIndex);
+	}
+	
+	/**
+	 * Returns the previous atom in the list
+	 * when the index is the first atom in the list will return the final atom
+	 * Doesn't effect the list
+	 * @return
+	 */
+	Atom peekPrevious() {
+		int tempIndex = index - 1;
+		if (tempIndex < 0){
+			tempIndex = atomList.size() -1 ;
+		}
+		return atomList.get(tempIndex);
+	}
+
+	/**
+	 * Returns the atom corresponding to the current index
+	 * Note that CycliAtomLists have a default index of -1
+	 * @return
+	 */
+	Atom getCurrent() {
+		return atomList.get(index);
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/Element.java

@@ -0,0 +1,229 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayList;
+import java.util.List;
+
+abstract class Element {
+
+	protected String name;
+	protected Element parent = null;
+	protected final List<Attribute> attributes = new ArrayList<>();
+
+	Element(String name) {
+		this.name = name;
+	}
+
+	void addAttribute(Attribute attribute) {
+		attributes.add(attribute);
+	}
+
+	void addAttribute(String atrName, String atrValue) {
+		attributes.add(new Attribute(atrName, atrValue));
+	}
+
+	/**
+	 * Adds a child element
+	 * @param child
+	 */
+	abstract void addChild(Element child);
+
+	/**
+	 * Creates a deep copy with no parent
+	 */
+	abstract Element copy();
+
+	void detach() {
+		if (parent != null) {
+			parent.removeChild(this);
+		}
+	}
+	
+	Attribute getAttribute(int index) {
+		return attributes.get(index);
+	}
+	
+	/**
+	 * Returns the attribute with the given name
+	 * or null if the attribute doesn't exist
+	 * @param name
+	 * @return
+	 */
+	Attribute getAttribute(String name) {
+		for (int i = 0, len = attributes.size(); i < len; i++) {
+			Attribute a = attributes.get(i);
+			if (a.getName().equals(name)) {
+				return a;
+			}
+		}
+		return null;
+	}
+
+	int getAttributeCount() {
+		return attributes.size();
+	}
+
+	/**
+	 * Returns the value of the attribute with the given name
+	 * or null if the attribute doesn't exist
+	 * @param name
+	 * @return
+	 */
+	String getAttributeValue(String name) {
+		Attribute attribute = getAttribute(name);
+		if (attribute != null) {
+			return attribute.getValue();
+		}
+		return null;
+	}
+
+	/**
+	 * Returns the child at the given index in the children list
+	 * @param index
+	 * @return
+	 */
+	abstract Element getChild(int index);
+
+	/**
+	 * Returns the number of children
+	 * @return
+	 */
+	abstract int getChildCount();
+
+	/**
+	 * Returns a copy of the child elements
+	 * 
+	 * @return
+	 */
+	abstract List<Element> getChildElements();
+	
+	/**
+	 * Gets child elements with this name (in iteration order)
+	 * @param name
+	 * @return
+	 */
+	abstract List<Element> getChildElements(String name);
+
+	/**
+	 * Returns the first child element with the specified name
+	 * 
+	 * @param name
+	 * @return
+	 */
+	abstract Element getFirstChildElement(String name);
+	
+	/**
+	 * Returns the fragment associated with this element (only applicable to tokens)
+	 * @return
+	 */
+	Fragment getFrag() {
+		throw new UnsupportedOperationException("Only tokens can have associated fragments");
+	}
+
+	String getName() {
+		return name;
+	}
+
+	Element getParent() {
+		return this.parent;
+	}
+
+	abstract String getValue();
+
+	/**
+	 * Returns the index of the given child in the children list (or -1 if it isn't a child)
+	 * @param child
+	 * @return
+	 */
+	abstract int indexOf(Element child);
+
+	/**
+	 * Inserts the element at the given index in the children list
+	 * @param child
+	 * @param index
+	 */
+	abstract void insertChild(Element child, int index);
+
+	boolean removeAttribute(Attribute attribute) {
+		return attributes.remove(attribute);
+	}
+
+	/**
+	 * Removes the given child element
+	 * @param child
+	 * @return
+	 */
+	abstract boolean removeChild(Element child);
+	
+	/**
+	 * Removes the element at the given index in the children list
+	 * @param index
+	 * @return
+	 */
+	abstract Element removeChild(int index);
+	
+	/**
+	 * Replaces a child element with another element
+	 * @param oldChild
+	 * @param newChild
+	 */
+	abstract void replaceChild(Element oldChild, Element newChild);
+	
+	/**
+	 * Sets the fragment associated with this element (only applicable to tokens!)
+	 * @param frag
+	 */
+	void setFrag(Fragment frag) {
+		throw new UnsupportedOperationException("Only tokens can have associated fragments");
+	}
+
+	void setName(String name) {
+		this.name = name;
+	}
+
+	void setParent(Element newParentEl) {
+		this.parent = newParentEl;
+	}
+
+	abstract void setValue(String text);
+
+	public String toString() {
+		return toXML();
+	}
+	
+	String toXML() {
+		return toXML(0).toString();
+	}
+	
+	private StringBuilder toXML(int indent) {
+		StringBuilder result = new StringBuilder();
+		for (int i = 0; i < indent; i++) {
+			result.append("  ");
+		}
+		result.append('<');
+		result.append(name);
+		for (Attribute atr : attributes) {
+			result.append(' ');
+			result.append(atr.toXML());
+		}
+		result.append('>');
+		if (getChildCount() > 0){
+			for (Element child : getChildElements()) {
+				result.append(OpsinTools.NEWLINE);
+				result.append(child.toXML(indent + 1));
+			}
+			result.append(OpsinTools.NEWLINE);
+			for (int i = 0; i < indent; i++) {
+				result.append("  ");
+			}
+		}
+		else{
+			result.append(getValue());
+		}
+		result.append("</");
+		result.append(name);
+		result.append('>');
+
+		return result;
+	}
+
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/Fragment.java

@@ -0,0 +1,633 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+
+import static uk.ac.cam.ch.wwmm.opsin.OpsinTools.*;
+import static uk.ac.cam.ch.wwmm.opsin.XmlDeclarations.*;
+
+/**A fragment of a molecule, holds bonds and atoms.
+ *
+ * @author ptc24
+ * @author dl387
+ *
+ */
+class Fragment implements Iterable<Atom> {
+
+	/**A mapping between IDs and the atoms in this fragment, by default is ordered by the order atoms are added to the fragment*/
+	private final Map<Integer, Atom> atomMapFromId = new LinkedHashMap<>();
+
+	/**Equivalent to and synced to atomMapFromId.values() */
+	private final Collection<Atom> atomCollection = atomMapFromId.values();
+
+	/**A mapping between locants and the atoms in this fragment*/
+	private final Map<String, Atom> atomMapFromLocant = new HashMap<>();
+
+	/**The bonds in the fragment*/
+	private final Set<Bond> bondSet = new LinkedHashSet<>();
+
+	/**The associated token element*/
+	private Element tokenEl;
+
+	/**The atoms that are used when this fragment is connected to another fragment. Unused outAtoms means that the fragment is a radical or an error has occurred
+	 * Initially empty */
+	private final List<OutAtom> outAtoms = new ArrayList<>();
+
+	/**The atoms that are used on this fragment to form things like esters
+	 * Initially empty */
+	private final List<FunctionalAtom> functionalAtoms = new ArrayList<>();
+
+	/**The atom that fragments connecting to this fragment should connect to in preference
+	 * e.g. for amino acids the alpha amino group
+	 * Null by default*/
+	private Atom defaultInAtom = null;
+
+	/**The atoms in the fragment that have been indicated to have hydrogen at the SMILES level.*/
+	private final List<Atom> indicatedHydrogen = new ArrayList<>();
+	
+	/**Pseudo atoms indicating start and end of polymer structure repeat unit*/
+	private List<Atom> polymerAttachmentPoints =  null;
+
+	/**
+	 * DO NOT CALL DIRECTLY EXCEPT FOR TESTING
+	 * Makes an empty Fragment associated with the given tokenEl
+	 * @param tokenEl
+	 */
+	Fragment(Element tokenEl) {
+		this.tokenEl = tokenEl;
+	}
+	
+	/**
+	 * DO NOT CALL DIRECTLY EXCEPT FOR TESTING
+	 * Makes an empty Fragment with the given type
+	 * 
+	 * @param type
+	 */
+	Fragment(String type) {
+		this.tokenEl = new TokenEl("");
+		this.tokenEl.addAttribute(TYPE_ATR, type);
+	}
+
+	/**Adds an atom to the fragment and associates it with this fragment*/
+	void addAtom(Atom atom) {
+		List<String> locants =atom.getLocants();
+		for (String locant: locants) {
+			atomMapFromLocant.put(locant, atom);
+		}
+		atomMapFromId.put(atom.getID(), atom);
+		atom.setFrag(this);
+	}
+	
+	/**
+	 * Return the number of atoms in the fragment
+	 * @return
+	 */
+	int getAtomCount() {
+		return atomCollection.size();
+	}
+
+	/**
+	 * Returns a copy of the fragment's atoms
+	 * @return
+	 */
+	List<Atom> getAtomList() {
+		return new ArrayList<>(atomCollection);
+	}
+
+
+	/**
+	 * Adds a bond to the fragment.
+	 * @param bond
+	 */
+	void addBond(Bond bond) {
+		bondSet.add(bond);
+	}
+	
+	/**Removes a bond to the fragment if it is present.
+    * @param bond
+    * @return*/
+	boolean removeBond(Bond bond) {
+		return bondSet.remove(bond);
+	}
+
+	/**Gets bondSet.*/
+	Set<Bond> getBondSet() {
+		return Collections.unmodifiableSet(bondSet);
+	}
+
+	/**Gets the id of the atom in the fragment with the specified locant.
+	 *
+	 * @param locant The locant to look for
+	 * @return The id of the found atom, or 0 if it is not found
+	 */
+	int getIDFromLocant(String locant)  {
+		Atom a = getAtomByLocant(locant);
+		if (a != null){
+			return a.getID();
+		}
+		return 0;
+	}
+
+	/**Gets the id of the atom in the fragment with the specified locant, throwing if this fails.
+	 *
+	 * @param locant The locant to look for
+	 * @return The id of the found atom
+     * @throws StructureBuildingException
+	 */
+	int getIDFromLocantOrThrow(String locant) throws StructureBuildingException {
+		int id = getIDFromLocant(locant);
+		if(id == 0) {
+			throw new StructureBuildingException("Couldn't find id from locant " + locant + ".");
+		}
+		return id;
+	}
+
+	/**Gets the atom in the fragment with the specified locant.
+	 *
+	 * @param locant The locant to look for
+	 * @return The found atom, or null if it is not found
+	 */
+	Atom getAtomByLocant(String locant) {
+		Atom a =atomMapFromLocant.get(locant);
+		if (a != null){
+			return a;
+		}
+		Matcher m =MATCH_AMINOACID_STYLE_LOCANT.matcher(locant);
+		if (m.matches()){//e.g. N5
+			Atom backboneAtom =atomMapFromLocant.get(m.group(3));//the atom corresponding to the numeric or greek component
+			if (backboneAtom==null){
+				return null;
+			}
+			a = FragmentTools.getAtomByAminoAcidStyleLocant(backboneAtom,  m.group(1), m.group(2));
+			if (a != null){
+				return a;
+			}
+		}
+		return null;
+	}
+
+	/**Gets the atom in the fragment with the specified locant, throwing if this fails.
+	 *
+	 * @param locant The locant to look for
+	 * @return The found atom
+	 * @throws StructureBuildingException
+	 */
+	Atom getAtomByLocantOrThrow(String locant) throws StructureBuildingException {
+		Atom a = getAtomByLocant(locant);
+		if(a == null) {
+			throw new StructureBuildingException("Could not find the atom with locant " + locant + ".");
+		}
+		return a;
+	}
+
+	/**Gets the atom in the fragment with the specified ID.
+	 *
+	 * @param id The id of the atom.
+	 * @return The found atom, or null.
+	 */
+	Atom getAtomByID(int id) {
+		return atomMapFromId.get(id);
+	}
+
+	/**Gets the atom in the fragment with the specified ID, throwing if this fails.
+	 *
+	 * @param id The id of the atom.
+	 * @return The found atom
+     * @throws StructureBuildingException
+	 */
+	Atom getAtomByIDOrThrow(int id) throws StructureBuildingException {
+		Atom a = getAtomByID(id);
+		if(a == null) {
+			throw new StructureBuildingException("Couldn't find atom with id " + id + ".");
+		}
+		return a;
+	}
+
+	/**Finds a bond between two specified atoms the first of which must be within the fragment
+	 *
+	 * @param ID1 The id of one atom
+	 * @param ID2 The id of the other atom
+	 * @return The bond found, or null
+	 */
+	Bond findBond(int ID1, int ID2) {
+		Atom a = atomMapFromId.get(ID1);
+		if (a != null){
+			for (Bond b : a.getBonds()) {
+				if((b.getFrom() == ID1 && b.getTo() == ID2) ||
+						(b.getTo() == ID1 && b.getFrom() == ID2)) {
+					return b;
+				}
+			}
+		}
+		return null;
+	}
+
+	/**Finds a bond between two specified atoms the first of which must be within the fragment, throwing if it fails.
+	 *
+	 * @param ID1 The id of one atom
+	 * @param ID2 The id of the other atom
+	 * @return The bond found
+     * @throws StructureBuildingException
+	 */
+	Bond findBondOrThrow(int ID1, int ID2) throws StructureBuildingException {
+		Bond b = findBond(ID1, ID2);
+		if(b == null) {
+			throw new StructureBuildingException("Couldn't find specified bond");
+		}
+		return b;
+	}
+
+	/**Works out how many atoms there are in the fragment there are
+	 * with consecutive locants, starting from 1 that are in a chain
+	 *
+	 * @return The number of atoms in the locant chain
+	 */
+	int getChainLength() {
+		int length = 0;
+		Atom next = getAtomByLocant(Integer.toString(length + 1));
+		Atom previous = null;
+		while (next != null){
+			if (previous != null && previous.getBondToAtom(next) == null){
+				break;
+			}
+			length++;
+			previous = next;
+			next = getAtomByLocant(Integer.toString(length + 1));
+		}
+		return length;
+	}
+
+	/**
+	 * Gets the type of the corresponding tokenEl
+	 * Returns "" if undefined
+	 * @return
+	 */
+	String getType() {
+		String type = tokenEl.getAttributeValue(TYPE_ATR);
+		return type != null ? type : "";
+	}
+
+	/**
+	 * Gets the subType of the corresponding tokenEl
+	 * Returns "" if undefined
+	 * @return
+	 */
+	String getSubType() {
+		String subType = tokenEl.getAttributeValue(SUBTYPE_ATR);
+		return subType != null ? subType : "";
+	}
+
+	/**
+	 * Gets the associate tokenEl
+	 * Whether or not this is a real token can be tested by whether it has a parent
+	 * @return
+	 */
+	Element getTokenEl() {
+		return tokenEl;
+	}
+
+	/**
+	 * Sets the associated tokenEl
+	 * Type/subType are inherited from the tokenEl
+	 * @param tokenEl
+	 */
+	void setTokenEl(Element tokenEl) {
+		this.tokenEl = tokenEl;
+	}
+
+	/**
+	 * How many OutAtoms (i.e. radicals) are associated with this fragment
+	 * @return
+	 */
+	int getOutAtomCount() {
+		return outAtoms.size();
+	}
+
+	/**
+	 * Gets the outAtom at a specific index of the outAtoms linkedList
+	 * @param i
+	 * @return
+	 */
+	OutAtom getOutAtom(int i) {
+		return outAtoms.get(i);
+	}
+
+	/**
+	 * Adds an outAtom
+	 * @param id
+	 * @param valency
+	 * @param setExplicitly
+	 * @throws StructureBuildingException 
+	 */
+	void addOutAtom(int id, int valency, Boolean setExplicitly) throws StructureBuildingException {
+		addOutAtom(getAtomByIDOrThrow(id), valency, setExplicitly);
+	}
+	
+	/**
+	 * Adds an outAtom
+	 * @param atom
+	 * @param valency
+	 * @param setExplicitly
+	 */
+	void addOutAtom(Atom atom, int valency, Boolean setExplicitly) {
+		outAtoms.add(new OutAtom(atom, valency, setExplicitly));
+	}
+	
+	/**
+	 * Includes the OutAtoms of a given fragment into this fragment
+	 * Note that no OutAtoms are created in doing this 
+	 * @param frag
+	 */
+	void incorporateOutAtoms(Fragment frag) {
+		outAtoms.addAll(frag.outAtoms);
+	}
+
+	/**
+	 * Removes the outAtom at a specific index of the outAtom linkedList
+	 * @param i
+	 */
+	void removeOutAtom(int i) {
+		OutAtom removedOutAtom = outAtoms.remove(i);
+		if (removedOutAtom.isSetExplicitly()){
+			removedOutAtom.getAtom().addOutValency(-removedOutAtom.getValency());
+		}
+	}
+
+	/**
+	 * Removes the specified outAtom from the outAtoms linkedList
+	 * @param outAtom
+	 */
+	void removeOutAtom(OutAtom outAtom) {
+		if (outAtoms.remove(outAtom) && outAtom.isSetExplicitly()){
+			outAtom.getAtom().addOutValency(-outAtom.getValency());
+		}
+	}
+
+	/**
+	 * How many functionalAtoms (i.e. locations that can form esters) are associated with this fragment
+	 * @return
+	 */
+	int getFunctionalAtomCount() {
+		return functionalAtoms.size();
+	}
+
+	/**
+	 * Gets the functionalAtom at a specific index of the functionalAtoms linkedList
+	 * @param i
+	 * @return
+	 */
+	FunctionalAtom getFunctionalAtom(int i) {
+		return functionalAtoms.get(i);
+	}
+	
+	/**Adds a functionalAtom
+    * @param atom*/
+	void addFunctionalAtom(Atom atom) {
+		functionalAtoms.add(new FunctionalAtom(atom));
+	}
+	
+	/**
+	 * Includes the FunctionalAtoms of a given fragment into this fragment
+	 * Note that no FunctionalAtoms are created in doing this 
+	 * @param frag
+	 */
+	void incorporateFunctionalAtoms(Fragment frag) {
+		functionalAtoms.addAll(frag.functionalAtoms);
+	}
+
+	/**
+	 * Removes the functionalAtom at a specific index of the functionalAtoms linkedList
+	 * @param i
+	 * @return 
+	 */
+	FunctionalAtom removeFunctionalAtom(int i) {
+		return functionalAtoms.remove(i);
+	}
+
+	/**
+	 * Removes the specified functionalAtom from the functionalAtoms linkedList
+	 * @param functionalAtom
+	 */
+	void removeFunctionalAtom(FunctionalAtom functionalAtom) {
+		functionalAtoms.remove(functionalAtom);
+	}
+	
+	List<Atom> getPolymerAttachmentPoints() {
+		return polymerAttachmentPoints;
+	}
+
+	void setPolymerAttachmentPoints(List<Atom> polymerAttachmentPoints) {
+		this.polymerAttachmentPoints = polymerAttachmentPoints;
+	}
+
+	/**Gets a list of atoms in the fragment that connect to a specified atom
+	 *
+	 * @param atom The reference atom
+	 * @return The list of atoms connected to the atom
+	 */
+	List<Atom> getIntraFragmentAtomNeighbours(Atom atom) {
+		List<Atom> results = new ArrayList<>(atom.getBondCount());
+		for(Bond b : atom.getBonds()) {
+			Atom otherAtom = b.getOtherAtom(atom);
+			if (otherAtom == null) {
+				throw new RuntimeException("OPSIN Bug: A bond associated with an atom does not involve it");
+			}
+			//If the other atom is in atomMapFromId then it is in this fragment
+			if (atomMapFromId.get(otherAtom.getID()) != null) {
+				results.add(otherAtom);
+			}
+		}
+		return results;
+	}
+
+	/**Calculates the number of bonds connecting to the atom, excluding bonds to implicit
+	 * hydrogens. Double bonds count as
+	 * two bonds, etc. Eg ethene - both C's have an incoming valency of 2.
+	 *
+	 * Only bonds to atoms within the fragment are counted. Suffix atoms are excluded
+	 *
+	 * @param atom
+     * @return Incoming Valency
+	 * @throws StructureBuildingException
+	 */
+	int getIntraFragmentIncomingValency(Atom atom) throws StructureBuildingException {
+		int v = 0;
+		for(Bond b :  atom.getBonds()) {
+			//recalled atoms will be null if they are not part of this fragment
+			if(b.getFromAtom() == atom) {
+				Atom a =getAtomByID(b.getTo());
+				if (a != null && !a.getType().equals(SUFFIX_TYPE_VAL)){
+					v += b.getOrder();
+				}
+			} else if(b.getToAtom() == atom) {
+				Atom a =getAtomByID(b.getFrom());
+				if (a != null && !a.getType().equals(SUFFIX_TYPE_VAL)){
+					v += b.getOrder();
+				}
+			}
+			else{
+				throw new StructureBuildingException("A bond associated with an atom does not involve it");
+			}
+		}
+		return v;
+	}
+
+	/**
+	 * Checks valencies are sensible
+	 * @throws StructureBuildingException
+	 */
+	void checkValencies() throws StructureBuildingException {
+		for(Atom a : atomCollection) {
+			if(!ValencyChecker.checkValency(a)) {
+				throw new StructureBuildingException("Atom is in unphysical valency state! Element: " + a.getElement() + " valency: " + a.getIncomingValency());
+			}
+		}
+	}
+
+	/**
+	 * Removes an atom from this fragment
+	 * @param atom
+	 */
+	void removeAtom(Atom atom) {
+		int atomID =atom.getID();
+		atomMapFromId.remove(atomID);
+		for (String l : atom.getLocants()) {
+			atomMapFromLocant.remove(l);
+		}
+		if (defaultInAtom == atom){
+			defaultInAtom = null;
+		}
+	}
+	/**
+	 * Retrieves the overall charge of the fragment by querying all its atoms
+	 * @return
+	 */
+	int getCharge() {
+		int charge=0;
+		for (Atom a : atomCollection) {
+			charge+=a.getCharge();
+		}
+		return charge;
+	}
+	
+	Atom getDefaultInAtom() {
+		return defaultInAtom;
+	}
+
+	void setDefaultInAtom(Atom inAtom) {
+		this.defaultInAtom = inAtom;
+	}
+	
+	Atom getDefaultInAtomOrFirstAtom() {
+		return defaultInAtom != null ? defaultInAtom : getFirstAtom();
+	}
+
+	/**
+	 * Adds a mapping between the locant and atom object
+	 * @param locant A locant as a string
+	 * @param a An atom
+	 */
+	void addMappingToAtomLocantMap(String locant, Atom a){
+		atomMapFromLocant.put(locant, a);
+	}
+
+	/**
+	 * Removes a mapping between a locant
+	 * @param locant A locant as a string
+	 */
+	void removeMappingFromAtomLocantMap(String locant){
+		atomMapFromLocant.remove(locant);
+	}
+
+	/**
+	 * Checks to see whether a locant is present on this fragment
+	 * @param locant
+	 * @return
+	 */
+	boolean hasLocant(String locant) {
+		return getAtomByLocant(locant) != null;
+	}
+	
+
+	/**
+	 * Returns an unmodifiable list of the locants associated with this fragment
+	 * @return
+	 */
+	Set<String> getLocants() {
+		return Collections.unmodifiableSet(atomMapFromLocant.keySet());
+	}
+
+	List<Atom> getIndicatedHydrogen() {
+		return indicatedHydrogen;
+	}
+	
+	void addIndicatedHydrogen(Atom atom) {
+		indicatedHydrogen.add(atom);
+	}
+
+	/**
+	 * Returns the id of the first atom in the fragment
+	 * @return
+	 * @throws StructureBuildingException
+	 */
+	int getIdOfFirstAtom() {
+		return getFirstAtom().getID();
+	}
+
+	/**
+	 * Returns the the first atom in the fragment or null if it has no atoms
+	 * Typically the first atom will be the first atom that was added to the fragment
+	 * @return firstAtom
+	 */
+	Atom getFirstAtom(){
+		Iterator<Atom> atomIterator =atomCollection.iterator();
+		if (atomIterator.hasNext()){
+			return atomIterator.next();
+		}
+		return null;
+	}
+
+	/**
+	 * Clears and recreates atomMapFromId (and hence AtomCollection) using the order of the atoms in atomList
+	 * @param atomList
+	 * @throws StructureBuildingException
+	 */
+	void reorderAtomCollection(List<Atom> atomList) throws StructureBuildingException {
+		if (atomMapFromId.size() != atomList.size()){
+			throw new StructureBuildingException("atom list is not the same size as the number of atoms in the fragment");
+		}
+		atomMapFromId.clear();
+		for (Atom atom : atomList) {
+			atomMapFromId.put(atom.getID(), atom);
+		}
+	}
+
+	/**
+	 * Reorders the fragment's internal atomList by the value of the first locant of the atoms
+	 * e.g. 1,2,3,3a,3b,4
+	 * Used for assuring the correct order of atom iteration when performing ring fusion
+	 * @throws StructureBuildingException 
+	 */
+	void sortAtomListByLocant() throws StructureBuildingException {
+		List<Atom> atomList =getAtomList();
+		Collections.sort(atomList, new FragmentTools.SortByLocants());
+		reorderAtomCollection(atomList);
+	}
+
+	@Override
+	public Iterator<Atom> iterator() {
+		return atomCollection.iterator();
+	}
+}
+
+
+

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/FragmentManager.java

@@ -0,0 +1,767 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import static uk.ac.cam.ch.wwmm.opsin.XmlDeclarations.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+/** Holds the Fragments during the construction of the molecule,
+ * handles the building of new fragments and handles the creation/deletion of atoms/bonds
+ *
+ * @author ptc24
+ * @author dl387
+ *
+ */
+class FragmentManager {
+
+	/** A mapping between fragments and inter fragment bonds */
+	private final Map<Fragment,Set<Bond>> fragToInterFragmentBond = new LinkedHashMap<>();
+	
+	/** All of the atom-containing fragments in the molecule */
+	private final Set<Fragment> fragments = fragToInterFragmentBond.keySet();
+	
+	/** A builder for fragments specified as SMILES */
+	private final SMILESFragmentBuilder sBuilder;
+	
+	/** A source of unique integers */
+	private final IDManager idManager;
+
+	/** Sets up a new Fragment manager, containing no fragments.
+	 *
+	 * @param sBuilder A SMILESFragmentBuilder - dependency injection.
+	 * @param idManager An IDManager.
+	 */
+	FragmentManager(SMILESFragmentBuilder sBuilder, IDManager idManager) {
+		if (sBuilder == null || idManager == null ){
+			throw new IllegalArgumentException("FragmentManager was parsed a null object in its constructor!");
+		}
+		this.sBuilder = sBuilder;
+		this.idManager = idManager;
+	}
+
+	/** Builds a fragment, based on an SMILES string
+	 * The fragment will not correspond to a token
+	 *
+	 * @param smiles The fragment to build
+	 * @return The built fragment
+	 * @throws StructureBuildingException
+	 */
+	Fragment buildSMILES(String smiles) throws StructureBuildingException {
+		return buildSMILES(smiles, "", NONE_LABELS_VAL);
+	}
+	
+	/** Builds a fragment, based on an SMILES string
+	 * The fragment will not correspond to a token
+	 * 
+	 * @param smiles
+	 * @param type
+	 * @param labelMapping
+	 * @return
+	 * @throws StructureBuildingException
+	 */
+	Fragment buildSMILES(String smiles, String type, String labelMapping) throws StructureBuildingException {
+		Fragment newFrag = sBuilder.build(smiles, type, labelMapping);
+		addFragment(newFrag);
+		return newFrag;
+	}
+
+	/** Builds a fragment, based on an SMILES string
+	 * The fragment will correspond to the given tokenEl
+	 * 
+	 * @param smiles The fragment to build
+	 * @param tokenEl The corresponding tokenEl
+	 * @param labelMapping How to label the fragment
+	 * @return The built fragment
+	 * @throws StructureBuildingException
+	 */
+	Fragment buildSMILES(String smiles, Element tokenEl, String labelMapping) throws StructureBuildingException {
+		Fragment newFrag = sBuilder.build(smiles, tokenEl, labelMapping);
+		addFragment(newFrag);
+		return newFrag;
+	}
+
+	/**Creates a new fragment, containing all of the atoms and bonds
+	 * of all of the other fragments - i.e. the whole molecule. This updates
+	 * which fragments the atoms think they are in to the new super fragment
+	 * but does not change the original fragments.
+	 * Hence the original fragments remain associated with their atoms
+	 * Atoms and Bonds are not copied.
+	 *
+	 * @return The unified fragment
+	 */
+	Fragment getUnifiedFragment() {
+		Fragment uniFrag = new Fragment("");
+		for (Entry<Fragment, Set<Bond>> entry : fragToInterFragmentBond.entrySet()) {
+			Fragment f = entry.getKey();
+			Set<Bond> interFragmentBonds = entry.getValue();
+			for(Atom atom : f.getAtomList()) {
+				uniFrag.addAtom(atom);
+			}
+			for(Bond bond : f.getBondSet()) {
+				uniFrag.addBond(bond);
+			}
+			uniFrag.incorporateOutAtoms(f);
+			uniFrag.incorporateFunctionalAtoms(f);
+
+			for (Bond interFragmentBond : interFragmentBonds) {
+				uniFrag.addBond(interFragmentBond);
+			}
+		}
+		addFragment(uniFrag);
+		return uniFrag;
+	}
+
+	/** Incorporates a fragment, usually a suffix, into a parent fragment
+	 * This does:
+	 * Imports all of the atoms and bonds from another fragment into this one.
+	 * Also imports outAtoms and functionalAtoms
+	 * Reassigns inter-fragment bonds of the child fragment as either intra-fragment bonds
+	 * of the parent fragment or as inter-fragment bonds of the parent fragment
+	 *
+	 * The original fragment still maintains its original atomList/bondList
+	 *
+	 * @param childFrag The fragment to be incorporated
+	 * @param parentFrag The parent fragment
+     * @throws StructureBuildingException
+	 */
+	void incorporateFragment(Fragment childFrag, Fragment parentFrag) throws StructureBuildingException {
+		for(Atom atom : childFrag.getAtomList()) {
+			parentFrag.addAtom(atom);
+		}
+		for(Bond bond : childFrag.getBondSet()) {
+			parentFrag.addBond(bond);
+		}
+		parentFrag.incorporateOutAtoms(childFrag);
+		parentFrag.incorporateFunctionalAtoms(childFrag);
+
+		Set<Bond> interFragmentBonds = fragToInterFragmentBond.get(childFrag);
+		if (interFragmentBonds == null){
+			throw new StructureBuildingException("Fragment not registered with this FragmentManager!");
+		}
+		for (Bond bond : interFragmentBonds) {//reassign inter-fragment bonds of child
+			if (bond.getFromAtom().getFrag() == parentFrag && bond.getToAtom().getFrag() == parentFrag){
+				//bond is now enclosed within parentFrag so make it an intra-fragment bond
+				//and remove it from the inter-fragment set of the parentFrag
+				parentFrag.addBond(bond);
+				fragToInterFragmentBond.get(parentFrag).remove(bond);
+			}
+			else{
+				//bond was an inter-fragment bond between the childFrag and another frag
+				//It is now between the parentFrag and another frag
+				addInterFragmentBond(bond);
+			}
+		}
+		fragToInterFragmentBond.remove(childFrag);
+	}
+	
+	/** Incorporates a fragment, usually a suffix, into a parent fragment, creating a bond between them.
+	 *
+	 * @param childFrag The fragment to be incorporated
+	 * @param fromAtom An atom on that fragment
+	 * @param parentFrag The parent fragment
+	 * @param toAtom An atom on that fragment
+	 * @param bondOrder The order of the joining bond
+     * @throws StructureBuildingException
+	 */
+	void incorporateFragment(Fragment childFrag, Atom fromAtom, Fragment parentFrag, Atom toAtom, int bondOrder) throws StructureBuildingException {
+		if (!fromAtom.getFrag().equals(childFrag)){
+			throw new StructureBuildingException("OPSIN Bug: fromAtom was not associated with childFrag!");
+		}
+		if (!toAtom.getFrag().equals(parentFrag)){
+			throw new StructureBuildingException("OPSIN Bug: toAtom was not associated with parentFrag!");
+		}
+		incorporateFragment(childFrag, parentFrag);
+		createBond(fromAtom, toAtom, bondOrder);
+	}
+
+	/** Converts an atom in a fragment to a different atomic symbol described by a SMILES string
+	 * Charged atoms can also be specified eg. [NH4+]
+	 *
+	 * @param a The atom to change to a heteroatom
+	 * @param smiles The SMILES for one atom
+	 * @throws StructureBuildingException
+	 */
+	void replaceAtomWithSmiles(Atom a, String smiles) throws StructureBuildingException {
+		replaceAtomWithAtom(a, getHeteroatom(smiles), false);
+	}
+
+	/**
+	 * Converts the smiles for a heteroatom to an atom
+	 * @param smiles
+	 * @return
+	 * @throws StructureBuildingException
+	 */
+	Atom getHeteroatom(String smiles) throws StructureBuildingException {
+		Fragment heteroAtomFrag = sBuilder.build(smiles);
+		if (heteroAtomFrag.getAtomCount() != 1){
+			throw new StructureBuildingException("Heteroatom smiles described a fragment with multiple SMILES!");
+		}
+		return heteroAtomFrag.getFirstAtom();
+	}
+	
+	/** Uses the information given in the given heteroatom to change the atomic symbol
+	 * and charge of the given atom
+	 *
+	 * @param a The atom to change to a heteroatom
+	 * @param heteroAtom The atom to copy element/charge properties from
+	 * @param assignLocant Whether a locant should be assigned to the heteroatom if the locant is not used elsewhere
+	 * @throws StructureBuildingException if a charge disagreement occurs
+	 */
+	void replaceAtomWithAtom(Atom a, Atom heteroAtom, boolean assignLocant) throws StructureBuildingException {
+		ChemEl chemEl =heteroAtom.getElement();
+		int replacementCharge =heteroAtom.getCharge();
+		if (replacementCharge!=0){
+			if (a.getCharge()==0){
+				a.addChargeAndProtons(replacementCharge, heteroAtom.getProtonsExplicitlyAddedOrRemoved());
+			}
+			else if (a.getCharge()==replacementCharge){
+				a.setProtonsExplicitlyAddedOrRemoved(heteroAtom.getProtonsExplicitlyAddedOrRemoved());
+			}
+			else{
+				throw new StructureBuildingException("Charge conflict between replacement term and atom to be replaced");
+			}
+		}
+		a.setElement(chemEl);
+		a.removeElementSymbolLocants();
+		if (assignLocant){
+			String primes = "";
+			while (a.getFrag().getAtomByLocant(chemEl.toString() + primes) != null){//if element symbol already assigned, add a prime and try again
+				primes += "'";
+			}
+			a.addLocant(chemEl.toString() + primes);
+		}
+	}
+
+	/** Gets an atom, given an id number
+	 * Use this if you don't know what fragment the atom is in
+	 * @param id The id of the atom
+	 * @return The atom, or null if no such atom exists.
+	 */
+	Atom getAtomByID(int id) {
+		for(Fragment f : fragments) {
+			Atom a = f.getAtomByID(id);
+			if(a != null) {
+				return a;
+			}
+		}
+		return null;
+	}
+
+	/** Gets an atom, given an id number, throwing if fails.
+	 * Use this if you don't know what fragment the atom is in
+	 * @param id The id of the atom
+	 * @return The atom
+     * @throws StructureBuildingException
+	 */
+	Atom getAtomByIDOrThrow(int id) throws StructureBuildingException {
+		Atom a = getAtomByID(id);
+		if(a == null) {
+			throw new StructureBuildingException("Couldn't get atom by id");
+		}
+		return a;
+	}
+
+	/**Turns all of the spare valencies in the fragments into double bonds.
+	 *
+	 * @throws StructureBuildingException
+	 */
+	void convertSpareValenciesToDoubleBonds() throws StructureBuildingException {
+		for(Fragment f : fragments) {
+			FragmentTools.convertSpareValenciesToDoubleBonds(f);
+		}
+	}
+
+	/**
+	 * Checks valencies are all chemically reasonable. An exception is thrown if any are not
+	 * @throws StructureBuildingException
+	 */
+	void checkValencies() throws StructureBuildingException {
+		for(Fragment f : fragments) {
+			f.checkValencies();
+		}
+	}
+
+	Set<Fragment> getFragments() {
+		return Collections.unmodifiableSet(fragments);
+	}
+
+	/**
+	 * Registers a fragment
+	 * @param frag
+	 */
+	private void addFragment(Fragment frag)  {
+		fragToInterFragmentBond.put(frag, new LinkedHashSet<>());
+	}
+
+	/**
+	 * Removes a fragment
+	 * Any inter-fragment bonds of this fragment are removed from the fragments it was connected to
+	 * Throws an exception if fragment wasn't present
+	 * @param frag
+	 * @throws StructureBuildingException
+	 */
+	void removeFragment(Fragment frag) throws StructureBuildingException {
+		Set<Bond> interFragmentBondsInvolvingFragmentSet = fragToInterFragmentBond.get(frag);
+		if (interFragmentBondsInvolvingFragmentSet == null) {
+			throw new StructureBuildingException("Fragment not registered with this FragmentManager!");
+		}
+		List<Bond> interFragmentBondsInvolvingFragment = new ArrayList<>(interFragmentBondsInvolvingFragmentSet);
+		for (Bond bond : interFragmentBondsInvolvingFragment) {
+			if (bond.getFromAtom().getFrag() == frag){
+				fragToInterFragmentBond.get(bond.getToAtom().getFrag()).remove(bond);
+			}
+			else{
+				fragToInterFragmentBond.get(bond.getFromAtom().getFrag()).remove(bond);
+			}
+		}
+		fragToInterFragmentBond.remove(frag);
+	}
+
+	int getOverallCharge() {
+		int totalCharge = 0;
+		for (Fragment frag : fragments) {
+			totalCharge += frag.getCharge();
+		}
+		return totalCharge;
+	}
+
+	/**
+	 * Creates a copy of a fragment by copying data
+	 * labels the atoms using new ids from the idManager
+	 * @param originalFragment
+	 * @return the clone of the fragment
+	 * @throws StructureBuildingException
+	 */
+	Fragment copyFragment(Fragment originalFragment) throws StructureBuildingException {
+		return copyAndRelabelFragment(originalFragment, 0);
+	}
+
+	/**
+	 * Creates a copy of a fragment by copying data
+	 * labels the atoms using new ids from the idManager
+	 * @param originalFragment
+	 * @param primesToAdd: The minimum number of primes to add to the cloned atoms. More primes will be added if necessary to keep the locants unique e.g. N in the presence of N' becomes N'' when this is 1
+	 * @return the clone of the fragment
+	 */
+	Fragment copyAndRelabelFragment(Fragment originalFragment, int primesToAdd) {
+		Element tokenEl = new TokenEl("");
+		tokenEl.addAttribute(TYPE_ATR, originalFragment.getType());
+		tokenEl.addAttribute(SUBTYPE_ATR, originalFragment.getSubType());
+		Fragment newFragment = new Fragment(tokenEl);
+		HashMap<Atom, Atom> oldToNewAtomMap = new HashMap<>();//maps old Atom to new Atom
+		List<Atom> atomList =originalFragment.getAtomList();
+		for (Atom atom : atomList) {
+			int id = idManager.getNextID();
+			ArrayList<String> newLocants = new ArrayList<>(atom.getLocants());
+			if (primesToAdd !=0){
+				for (int i = 0; i < newLocants.size(); i++) {
+					String currentLocant = newLocants.get(i);
+					int currentPrimes = StringTools.countTerminalPrimes(currentLocant);
+					String locantSansPrimes = currentLocant.substring(0, currentLocant.length()-currentPrimes);
+					int highestNumberOfPrimesWithThisLocant = currentPrimes;
+					while (originalFragment.getAtomByLocant(locantSansPrimes + StringTools.multiplyString("'", highestNumberOfPrimesWithThisLocant +1 ))!=null){
+						highestNumberOfPrimesWithThisLocant++;
+					}
+					newLocants.set(i, locantSansPrimes + StringTools.multiplyString("'", ((highestNumberOfPrimesWithThisLocant +1)*primesToAdd) + currentPrimes));
+				}
+			}
+			Atom newAtom =new Atom(id, atom.getElement(), newFragment);
+			for (String newLocant : newLocants) {
+				newAtom.addLocant(newLocant);
+			}
+			newAtom.setCharge(atom.getCharge());
+			newAtom.setIsotope(atom.getIsotope());
+			newAtom.setSpareValency(atom.hasSpareValency());
+			newAtom.setProtonsExplicitlyAddedOrRemoved(atom.getProtonsExplicitlyAddedOrRemoved());
+			newAtom.setLambdaConventionValency(atom.getLambdaConventionValency());
+			//outValency is derived from the outAtoms so is automatically cloned
+			newAtom.setAtomIsInACycle(atom.getAtomIsInACycle());
+			newAtom.setType(atom.getType());//may be different from fragment type if the original atom was formerly in a suffix
+			newAtom.setMinimumValency(atom.getMinimumValency());
+			newAtom.setImplicitHydrogenAllowed(atom.getImplicitHydrogenAllowed());
+			newFragment.addAtom(newAtom);
+			oldToNewAtomMap.put(atom, newAtom);
+		}
+		for (Atom atom : atomList) {
+			if (atom.getAtomParity() != null){
+				Atom[] oldAtomRefs4 = atom.getAtomParity().getAtomRefs4();
+				Atom[] newAtomRefs4 = new Atom[4];
+				for (int i = 0; i < oldAtomRefs4.length; i++) {
+					Atom oldAtom = oldAtomRefs4[i];
+					if (oldAtom.equals(AtomParity.hydrogen)){
+						newAtomRefs4[i] = AtomParity.hydrogen;
+					}
+					else if (oldAtom.equals(AtomParity.deoxyHydrogen)){
+						newAtomRefs4[i] = AtomParity.deoxyHydrogen;
+					}
+					else{
+						newAtomRefs4[i] = oldToNewAtomMap.get(oldAtom);
+					}
+				}
+				AtomParity newAtomParity =new AtomParity(newAtomRefs4, atom.getAtomParity().getParity());
+				newAtomParity.setStereoGroup(atom.getAtomParity().getStereoGroup());
+				oldToNewAtomMap.get(atom).setAtomParity(newAtomParity);
+			}
+			Set<Atom> oldAmbiguousElementAssignmentAtoms = atom.getProperty(Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT);
+			if (oldAmbiguousElementAssignmentAtoms!=null){
+				Set<Atom> newAtoms = new LinkedHashSet<>();
+				for (Atom oldAtom : oldAmbiguousElementAssignmentAtoms) {
+					newAtoms.add(oldToNewAtomMap.get(oldAtom));
+				}
+				oldToNewAtomMap.get(atom).setProperty(Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT, newAtoms);
+			}
+			Integer smilesHydrogenCount = atom.getProperty(Atom.SMILES_HYDROGEN_COUNT);
+			if (smilesHydrogenCount!=null){
+				oldToNewAtomMap.get(atom).setProperty(Atom.SMILES_HYDROGEN_COUNT, smilesHydrogenCount);
+			}
+			Integer oxidationNumber = atom.getProperty(Atom.OXIDATION_NUMBER);
+			if (oxidationNumber!=null){
+				oldToNewAtomMap.get(atom).setProperty(Atom.OXIDATION_NUMBER, oxidationNumber);
+			}
+			Boolean isAldehyde = atom.getProperty(Atom.ISALDEHYDE);
+			if (isAldehyde!=null){
+				oldToNewAtomMap.get(atom).setProperty(Atom.ISALDEHYDE, isAldehyde);
+			}
+			Boolean isAnomeric = atom.getProperty(Atom.ISANOMERIC);
+			if (isAnomeric!=null){
+				oldToNewAtomMap.get(atom).setProperty(Atom.ISANOMERIC, isAnomeric);
+			}
+			Integer atomClass = atom.getProperty(Atom.ATOM_CLASS);
+			if (atomClass!=null){
+				oldToNewAtomMap.get(atom).setProperty(Atom.ATOM_CLASS, atomClass);
+			}
+			String homologyGroup = atom.getProperty(Atom.HOMOLOGY_GROUP);
+			if (homologyGroup != null) {
+				oldToNewAtomMap.get(atom).setProperty(Atom.HOMOLOGY_GROUP, homologyGroup);
+			}
+			List<Atom> oldPositionVariationAtoms = atom.getProperty(Atom.POSITION_VARIATION_BOND);
+			if (oldPositionVariationAtoms != null) {
+				List<Atom> newAtoms = new ArrayList<>();
+				for (Atom oldAtom : oldPositionVariationAtoms) {
+					newAtoms.add(oldToNewAtomMap.get(oldAtom));
+				}
+				oldToNewAtomMap.get(atom).setProperty(Atom.POSITION_VARIATION_BOND, newAtoms);
+			}
+		}
+		for (int i = 0, l = originalFragment.getOutAtomCount(); i < l; i++) {
+			OutAtom outAtom = originalFragment.getOutAtom(i);
+            newFragment.addOutAtom(oldToNewAtomMap.get(outAtom.getAtom()), outAtom.getValency(), outAtom.isSetExplicitly());
+            if (outAtom.getLocant() !=null){
+            	newFragment.getOutAtom(newFragment.getOutAtomCount() -1).setLocant(outAtom.getLocant() + StringTools.multiplyString("'", primesToAdd) );
+            }
+        }
+		for (int i = 0, l = originalFragment.getFunctionalAtomCount(); i < l; i++) {
+			FunctionalAtom functionalAtom = originalFragment.getFunctionalAtom(i);
+			newFragment.addFunctionalAtom(oldToNewAtomMap.get(functionalAtom.getAtom()));
+		}
+		if (originalFragment.getDefaultInAtom() != null) {
+			newFragment.setDefaultInAtom(oldToNewAtomMap.get(originalFragment.getDefaultInAtom()));
+		}
+		Set<Bond> bondSet =originalFragment.getBondSet();
+		for (Bond bond : bondSet) {
+			Bond newBond = createBond(oldToNewAtomMap.get(bond.getFromAtom()), oldToNewAtomMap.get(bond.getToAtom()), bond.getOrder());
+			newBond.setSmilesStereochemistry(bond.getSmilesStereochemistry());
+			if (bond.getBondStereo() != null){
+				Atom[] oldAtomRefs4 = bond.getBondStereo().getAtomRefs4();
+				Atom[] newAtomRefs4 = new Atom[4];
+				for (int i = 0; i < oldAtomRefs4.length; i++) {
+					newAtomRefs4[i] = oldToNewAtomMap.get(oldAtomRefs4[i]);
+				}
+				newBond.setBondStereoElement(newAtomRefs4, bond.getBondStereo().getBondStereoValue());
+			}
+		}
+		List<Atom> indicatedHydrogenAtoms = originalFragment.getIndicatedHydrogen();
+		for (Atom atom : indicatedHydrogenAtoms) {
+			newFragment.addIndicatedHydrogen(oldToNewAtomMap.get(atom));
+		}
+		addFragment(newFragment);
+		return newFragment;
+	}
+
+	/**
+	 * Takes an element and produces a copy of it. Groups and suffixes are copied so that the new element
+	 * has its own group and suffix fragments
+	 * @param elementToBeCloned
+	 * @param state The current buildstate
+	 * @return
+	 * @throws StructureBuildingException
+	 */
+	Element cloneElement(BuildState state, Element elementToBeCloned) throws StructureBuildingException {
+		return cloneElement(state, elementToBeCloned, 0);
+	}
+
+	/**
+	 * Takes an element and produces a copy of it. Groups and suffixes are copied so that the new element
+	 * has its own group and suffix fragments
+	 * @param elementToBeCloned
+	 * @param state The current buildstate
+	 * @param primesToAdd: The minimum number of primes to add to the cloned atoms. More primes will be added if necessary to keep the locants unique e.g. N in the presence of N' becomes N'' when this is 1
+	 * @return
+	 * @throws StructureBuildingException
+	 */
+	Element cloneElement(BuildState state, Element elementToBeCloned, int primesToAdd) throws StructureBuildingException {
+		Element clone = elementToBeCloned.copy();
+		List<Element> originalGroups = OpsinTools.getDescendantElementsWithTagName(elementToBeCloned, XmlDeclarations.GROUP_EL);
+		List<Element> clonedGroups = OpsinTools.getDescendantElementsWithTagName(clone,  XmlDeclarations.GROUP_EL);
+		HashMap<Fragment,Fragment> oldNewFragmentMapping  =new LinkedHashMap<>();
+		for (int i = 0; i < originalGroups.size(); i++) {
+			Fragment originalFragment = originalGroups.get(i).getFrag();
+			Fragment newFragment = copyAndRelabelFragment(originalFragment, primesToAdd);
+			oldNewFragmentMapping.put(originalFragment, newFragment);
+			newFragment.setTokenEl(clonedGroups.get(i));
+			clonedGroups.get(i).setFrag(newFragment);
+			List<Fragment> originalSuffixes =state.xmlSuffixMap.get(originalGroups.get(i));
+			List<Fragment> newSuffixFragments =new ArrayList<>();
+			for (Fragment suffix : originalSuffixes) {
+				newSuffixFragments.add(copyFragment(suffix));
+			}
+			state.xmlSuffixMap.put(clonedGroups.get(i), newSuffixFragments);
+		}
+		Set<Bond> interFragmentBondsToClone = new LinkedHashSet<>();
+		for (Fragment originalFragment : oldNewFragmentMapping.keySet()) {//add inter fragment bonds to cloned fragments
+			for (Bond bond : fragToInterFragmentBond.get(originalFragment)) {
+				interFragmentBondsToClone.add(bond);
+			}
+		}
+		for (Bond bond : interFragmentBondsToClone) {
+			Atom originalFromAtom = bond.getFromAtom();
+			Atom originalToAtom = bond.getToAtom();
+			Fragment originalFragment1 = originalFromAtom.getFrag();
+			Fragment originalFragment2 = originalToAtom.getFrag();
+			if (!oldNewFragmentMapping.containsKey(originalFragment1) || (!oldNewFragmentMapping.containsKey(originalFragment2))){
+				throw new StructureBuildingException("An element that was a clone contained a bond that went outside the scope of the cloning");
+			}
+			Fragment newFragment1 = oldNewFragmentMapping.get(originalFragment1);
+			Fragment newFragment2 = oldNewFragmentMapping.get(originalFragment2);
+			Atom fromAtom = newFragment1.getAtomList().get(originalFragment1.getAtomList().indexOf(originalFromAtom));
+			Atom toAtom = newFragment2.getAtomList().get(originalFragment2.getAtomList().indexOf(originalToAtom));
+			createBond(fromAtom, toAtom, bond.getOrder());
+		}
+		return clone;
+	}
+	
+	/**
+	 * Takes an atom, removes it and bonds everything that was bonded to it to the replacementAtom with the original bond orders.
+	 * Non element symbol locants are copied to the replacement atom
+	 * @param atomToBeReplaced
+	 * @param replacementAtom
+	 */
+	void replaceAtomWithAnotherAtomPreservingConnectivity(Atom atomToBeReplaced, Atom replacementAtom) {
+		atomToBeReplaced.removeElementSymbolLocants();
+		List<String> locants = new ArrayList<>(atomToBeReplaced.getLocants());
+		for (String locant : locants) {
+			atomToBeReplaced.removeLocant(locant);
+			replacementAtom.addLocant(locant);
+		}
+		List<Bond> bonds = atomToBeReplaced.getBonds();
+		for (Bond bond : bonds) {
+			Atom connectedAtom = bond.getOtherAtom(atomToBeReplaced);
+			if (connectedAtom.getAtomParity() != null){
+				Atom[] atomRefs4 = connectedAtom.getAtomParity().getAtomRefs4();
+				for (int i = 0 ; i < 4; i++) {
+					if (atomRefs4[i] == atomToBeReplaced){
+						atomRefs4[i] = replacementAtom;
+						break;
+					}
+				}
+			}
+			if (bond.getBondStereo() != null){
+				Atom[] atomRefs4 = bond.getBondStereo().getAtomRefs4();
+				for (int i = 0 ; i < 4; i++) {
+					if (atomRefs4[i] == atomToBeReplaced){
+						atomRefs4[i] = replacementAtom;
+						break;
+					}
+				}
+			}
+			createBond(replacementAtom, bond.getOtherAtom(atomToBeReplaced), bond.getOrder());
+		}
+		removeAtomAndAssociatedBonds(atomToBeReplaced);
+	}
+
+	/**
+	 * Removes a bond from the inter-fragment bond mappings if it was present
+	 * @param bond
+	 */
+	private void removeInterFragmentBondIfPresent(Bond bond) {
+		fragToInterFragmentBond.get(bond.getFromAtom().getFrag()).remove(bond);
+		fragToInterFragmentBond.get(bond.getToAtom().getFrag()).remove(bond);
+	}
+	
+	/**
+	 * Adds a bond to the fragment to inter-fragment bond mappings
+	 * @param bond
+	 */
+	private void addInterFragmentBond(Bond bond) {
+		fragToInterFragmentBond.get(bond.getFromAtom().getFrag()).add(bond);
+		fragToInterFragmentBond.get(bond.getToAtom().getFrag()).add(bond);
+	}
+
+	/**
+	 * Gets an unmodifiable view of the set of the inter-fragment bonds a fragment is involved in
+	 * @param frag
+	 * @return set of inter fragment bonds
+	 */
+	Set<Bond> getInterFragmentBonds(Fragment frag) {
+		Set<Bond> interFragmentBonds = fragToInterFragmentBond.get(frag);
+		if (interFragmentBonds == null) {
+			throw new IllegalArgumentException("Fragment not registered with this FragmentManager!");
+		}
+		return Collections.unmodifiableSet(interFragmentBonds);
+	}
+
+	/**
+	 * Create a new Atom of the given element belonging to the given fragment
+	 * @param chemEl
+	 * @param frag
+	 * @return Atom
+	 */
+	Atom createAtom(ChemEl chemEl, Fragment frag) {
+		Atom a = new Atom(idManager.getNextID(), chemEl, frag);
+		frag.addAtom(a);
+		return a;
+	}
+	
+	/**
+	 * Create a new bond between two atoms.
+	 * The bond is associated with these atoms.
+	 * It is also listed as an inter-fragment bond or associated with a fragment
+	 * @param fromAtom
+	 * @param toAtom
+	 * @param bondOrder
+	 * @return Bond
+	 */
+	Bond createBond(Atom fromAtom, Atom toAtom, int bondOrder) {
+		Bond b = new Bond(fromAtom, toAtom, bondOrder);
+		fromAtom.addBond(b);
+		toAtom.addBond(b);
+		if (fromAtom.getFrag() == toAtom.getFrag()){
+			fromAtom.getFrag().addBond(b);
+		}
+		else{
+			addInterFragmentBond(b);
+		}
+		return b;
+	}
+	
+	void removeAtomAndAssociatedBonds(Atom atom){
+		List<Bond> bondsToBeRemoved = new ArrayList<>(atom.getBonds());
+		for (Bond bond : bondsToBeRemoved) {
+			removeBond(bond);
+		}
+		atom.getFrag().removeAtom(atom);
+		Set<Atom> ambiguousElementAssignment = atom.getProperty(Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT);
+		if (ambiguousElementAssignment != null){
+			ambiguousElementAssignment.remove(atom);
+			if (ambiguousElementAssignment.size() == 1){
+				ambiguousElementAssignment.iterator().next().setProperty(Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT, null);
+			}
+		}
+	}
+	
+	void removeBond(Bond bond){
+		bond.getFromAtom().getFrag().removeBond(bond);
+		bond.getFromAtom().removeBond(bond);
+		bond.getToAtom().removeBond(bond);
+		removeInterFragmentBondIfPresent(bond);
+	}
+	
+	/**
+	 * Valency is used to determine the expected number of hydrogen
+	 * Hydrogens are then added to bring the number of connections up to the minimum required to satisfy the atom's valency
+	 * This allows the valency of the atom to be encoded e.g. phopshane-3 hydrogen, phosphorane-5 hydrogen.
+	 * It is also necessary when considering stereochemistry as a hydrogen beats nothing in the CIP rules
+	 * @throws StructureBuildingException
+	 */
+	void makeHydrogensExplicit() throws StructureBuildingException {
+		for (Fragment fragment : fragments) {
+			List<Atom> atomList = fragment.getAtomList();
+			for (Atom parentAtom : atomList) {
+				int explicitHydrogensToAdd = StructureBuildingMethods.calculateSubstitutableHydrogenAtoms(parentAtom);
+				for (int i = 0; i < explicitHydrogensToAdd; i++) {
+					Atom hydrogen = createAtom(ChemEl.H, fragment);
+					createBond(parentAtom, hydrogen, 1);
+				}
+				if (parentAtom.getAtomParity() != null){
+					if (explicitHydrogensToAdd > 1) {
+						//Cannot have tetrahedral chirality and more than 2 hydrogens
+						parentAtom.setAtomParity(null);//probably caused by deoxy
+					}
+					else {
+						modifyAtomParityToTakeIntoAccountExplicitHydrogen(parentAtom);
+					}
+				}
+			}
+		}
+	}
+	
+	private void modifyAtomParityToTakeIntoAccountExplicitHydrogen(Atom atom) throws StructureBuildingException {
+		AtomParity atomParity = atom.getAtomParity();
+		if (!StereoAnalyser.isPossiblyStereogenic(atom)){
+			//no longer a stereoCentre e.g. due to unsaturation
+			atom.setAtomParity(null);
+		}
+		else{
+			Atom[] atomRefs4 = atomParity.getAtomRefs4();
+			Integer positionOfImplicitHydrogen = null;
+			Integer positionOfDeoxyHydrogen = null;
+			for (int i = 0; i < atomRefs4.length; i++) {
+				Atom a = atomRefs4[i];
+				if (a.equals(AtomParity.hydrogen)){
+					positionOfImplicitHydrogen = i;
+				}
+				else if (a.equals(AtomParity.deoxyHydrogen)){
+					positionOfDeoxyHydrogen = i;
+				}
+			}
+			if (positionOfImplicitHydrogen != null || positionOfDeoxyHydrogen != null) {
+				//atom parity was set in SMILES, the dummy hydrogen atom has now been substituted
+				List<Atom> neighbours = atom.getAtomNeighbours();
+				for (Atom atomRef : atomRefs4) {
+					neighbours.remove(atomRef);
+				}
+				if (neighbours.size() == 0) {
+					throw new StructureBuildingException("OPSIN Bug: Unable to determine which atom has substituted a hydrogen at stereocentre");
+				}
+				else if (neighbours.size() == 1 && positionOfDeoxyHydrogen != null) {
+					atomRefs4[positionOfDeoxyHydrogen] = neighbours.get(0);
+					if (positionOfImplicitHydrogen != null){
+						throw new StructureBuildingException("OPSIN Bug: Unable to determine which atom has substituted a hydrogen at stereocentre");
+					}
+				}
+				else if (neighbours.size() == 1 && positionOfImplicitHydrogen != null) {
+					atomRefs4[positionOfImplicitHydrogen] = neighbours.get(0);
+				}
+				else if (neighbours.size() == 2 && positionOfDeoxyHydrogen != null && positionOfImplicitHydrogen != null) {
+					try{
+						List<Atom> cipOrderedAtoms = new CipSequenceRules(atom).getNeighbouringAtomsInCipOrder();
+						//higher priority group replaces the former hydroxy groups (deoxyHydrogen)
+						if (cipOrderedAtoms.indexOf(neighbours.get(0)) > cipOrderedAtoms.indexOf(neighbours.get(1))) {
+							atomRefs4[positionOfDeoxyHydrogen] = neighbours.get(0);
+							atomRefs4[positionOfImplicitHydrogen] = neighbours.get(1);
+						}
+						else{
+							atomRefs4[positionOfDeoxyHydrogen] = neighbours.get(1);
+							atomRefs4[positionOfImplicitHydrogen] = neighbours.get(0);
+						}
+					}
+					catch (CipOrderingException e){
+						//assume ligands equivalent so it makes no difference which is which
+						atomRefs4[positionOfDeoxyHydrogen] = neighbours.get(0);
+						atomRefs4[positionOfImplicitHydrogen] = neighbours.get(1);
+					}
+				}
+				else{
+					throw new StructureBuildingException("OPSIN Bug: Unable to determine which atom has substituted a hydrogen at stereocentre");
+				}
+			}
+		}
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/FragmentTools.java

@@ -0,0 +1,1242 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static uk.ac.cam.ch.wwmm.opsin.OpsinTools.*;
+import static uk.ac.cam.ch.wwmm.opsin.XmlDeclarations.*;
+
+/**
+ * Sorts a list of atoms such that their order agrees with the order symbolic locants are typically assigned
+ * 
+ * Preferred atoms are sorted to the START of the list
+ * @author dl387
+ *
+ */
+class SortAtomsForElementSymbols implements Comparator<Atom> {
+
+	public int compare(Atom a, Atom b){
+		int bondOrderA = a.getProperty(Atom.VISITED);
+		int bondOrderB = b.getProperty(Atom.VISITED);
+    	if (bondOrderA > bondOrderB) {//lower order bond is preferred
+    		return 1;
+    	}
+    	if (bondOrderA < bondOrderB) {
+    		return -1;
+    	}
+    	
+    	if (a.getOutValency() > b.getOutValency()) {//prefer atoms with outValency
+    		return -1;
+    	}
+    	if (a.getOutValency() < b.getOutValency()) {
+    		return 1;
+    	}
+
+    	int expectedHydrogenA = StructureBuildingMethods.calculateSubstitutableHydrogenAtoms(a);
+    	int expectedHydrogenB = StructureBuildingMethods.calculateSubstitutableHydrogenAtoms(b);
+
+    	if (expectedHydrogenA > expectedHydrogenB) {//prefer atoms with more hydrogen
+    		return -1;
+    	}
+    	if (expectedHydrogenA < expectedHydrogenB) {
+    		return 1;
+    	}
+    	return 0;
+    }
+}
+
+/**
+ * Performs a very crude sort of atoms such that those that are more likely to be substitued are preferred for low locants
+ * Preferred atoms are sorted to the START of the list
+ * @author dl387
+ *
+ */
+class SortAtomsForMainGroupElementSymbols implements Comparator<Atom> {
+
+    public int compare(Atom a, Atom b){
+    	int compare = a.getElement().compareTo(b.getElement());
+    	if (compare != 0) {//only bother comparing properly if elements are the same
+    		return compare;
+    	}
+
+    	int aExpectedHydrogen = StructureBuildingMethods.calculateSubstitutableHydrogenAtoms(a);
+    	int bExpectedHydrogen = StructureBuildingMethods.calculateSubstitutableHydrogenAtoms(b);
+    	if (aExpectedHydrogen > 0 &&  bExpectedHydrogen == 0) {//having substitutable hydrogen preferred
+    		return -1;
+    	}
+    	if (aExpectedHydrogen == 0 && bExpectedHydrogen > 0) {
+    		return 1;
+    	}
+    	List<String> locantsA = a.getLocants();
+    	List<String> locantsB = b.getLocants();
+    	if (locantsA.size() == 0 &&  locantsB.size() > 0) {//having no locants preferred
+    		return -1;
+    	}
+    	if (locantsA.size() > 0 &&  locantsB.size() == 0) {
+    		return 1;
+    	}
+    	return 0;
+    }
+}
+
+class FragmentTools {
+	/**
+	 * Sorts by number, then by letter e.g. 4,3,3b,5,3a,2 -->2,3,3a,3b,4,5
+	 * @author dl387
+	 *
+	 */
+	static class SortByLocants implements Comparator<Atom> {
+      	static final Pattern locantSegmenter =Pattern.compile("(\\d+)([a-z]?)('*)");
+
+	    public int compare(Atom atoma, Atom atomb){
+	    	if (atoma.getType().equals(SUFFIX_TYPE_VAL) && !atomb.getType().equals(SUFFIX_TYPE_VAL)){//suffix atoms go to the back
+	    		return 1;
+	    	}
+	    	if (atomb.getType().equals(SUFFIX_TYPE_VAL) && !atoma.getType().equals(SUFFIX_TYPE_VAL)){
+	    		return -1;
+	    	}
+
+	    	String locanta =atoma.getFirstLocant();
+	    	String locantb =atomb.getFirstLocant();
+	    	if (locanta==null|| locantb==null){
+	    		return 0;
+	    	}
+
+	    	Matcher m1  =locantSegmenter.matcher(locanta);
+	    	Matcher m2  =locantSegmenter.matcher(locantb);
+	    	if (!m1.matches()|| !m2.matches()){//inappropriate locant
+	    		return 0;
+	    	}
+        	String locantaPrimes = m1.group(3);
+        	String locantbPrimes = m2.group(3);
+            if (locantaPrimes.compareTo(locantbPrimes)>=1) {
+                return 1;//e.g. 1'' vs 1'
+            } else if (locantbPrimes.compareTo(locantaPrimes)>=1) {
+                return -1;//e.g. 1' vs 1''
+            }
+            else{
+		    	int locantaNumber = Integer.parseInt(m1.group(1));
+		    	int locantbNumber = Integer.parseInt(m2.group(1));
+	
+		        if (locantaNumber >locantbNumber) {
+		            return 1;//e.g. 3 vs 2 or 3a vs 2
+		        } else if (locantbNumber >locantaNumber) {
+		            return -1;//e.g. 2 vs 3 or 2 vs 3a
+		        }
+		        else{
+		        	String locantaLetter = m1.group(2);
+		        	String locantbLetter = m2.group(2);
+		            if (locantaLetter.compareTo(locantbLetter)>=1) {
+		                return 1;//e.g. 1b vs 1a
+		            } else if (locantbLetter.compareTo(locantaLetter)>=1) {
+		                return -1;//e.g. 1a vs 1b
+		            }
+			        return 0;
+		        }
+            }
+	    }
+	}
+	
+	/**
+	 * Assign element locants to groups/suffixes. These are in addition to any numerical locants that are present.
+	 * Adds primes to make each locant unique.
+	 * For groups a locant is not given to carbon atoms
+	 * If an element appears in a suffix then element locants are not assigned to occurrences of that element in the parent group
+	 * HeteroAtoms in acidStems connected to the first Atom of the fragment are treated as if they were suffix atoms
+	 * @param suffixableFragment
+	 * @param suffixFragments
+	 * @throws StructureBuildingException 
+	 */
+	static void assignElementLocants(Fragment suffixableFragment, List<Fragment> suffixFragments) throws StructureBuildingException {
+		
+		Map<String,Integer> elementCount = new HashMap<>();//keeps track of how many times each element has been seen
+		Set<Atom> atomsToIgnore = new HashSet<>();//atoms which already have a symbolic locant
+		
+		List<Fragment> allFragments = new ArrayList<>(suffixFragments);
+		allFragments.add(suffixableFragment);
+		/*
+		 * First check whether any element locants have already been assigned, these will take precedence
+		 */
+		for (Fragment fragment : allFragments) {
+			List<Atom> atomList = fragment.getAtomList();
+			for (Atom atom : atomList) {
+				List<String> elementSymbolLocants = atom.getElementSymbolLocants();
+				for (String locant : elementSymbolLocants) {
+					int primeCount = StringTools.countTerminalPrimes(locant);
+					String element = locant.substring(0, locant.length() - primeCount);
+					Integer seenCount = elementCount.get(element);
+					if (seenCount == null || (seenCount < primeCount + 1)){
+						elementCount.put(element, primeCount + 1);
+					}
+					atomsToIgnore.add(atom);
+				}
+			}
+		}
+		
+		{
+			Set<String> elementsToIgnore = elementCount.keySet();
+	
+			for (Fragment fragment : allFragments) {
+				List<Atom> atomList = fragment.getAtomList();
+				for (Atom atom : atomList) {
+					if (elementsToIgnore.contains(atom.getElement().toString())){
+						atomsToIgnore.add(atom);
+					}
+				}
+			}
+		}
+
+		String fragType = suffixableFragment.getType();
+		if (fragType.equals(NONCARBOXYLICACID_TYPE_VAL) || fragType.equals(CHALCOGENACIDSTEM_TYPE_VAL)){
+			if (suffixFragments.size() != 0){
+				throw new StructureBuildingException("No suffix fragments were expected to be present on non carboxylic acid");
+			}
+			processNonCarboxylicAcidLabelling(suffixableFragment, elementCount, atomsToIgnore);
+		}
+		else{
+			if (suffixFragments.size() > 0){
+				processSuffixLabelling(suffixFragments, elementCount, atomsToIgnore);
+				Integer seenCount = elementCount.get("N");
+				if (seenCount != null && seenCount > 1){//look for special case violation of IUPAC rule, =(N)=(NN) is N//N' in practice rather than N/N'/N''
+					//this method will put both locants on the N with substituable hydrogen
+					detectAndCorrectHydrazoneDerivativeViolation(suffixFragments);
+				}
+			}
+			processMainGroupLabelling(suffixableFragment, elementCount, atomsToIgnore);
+		}
+	}
+
+	private static void detectAndCorrectHydrazoneDerivativeViolation(List<Fragment> suffixFragments) {
+		fragmentLoop: for (Fragment suffixFrag : suffixFragments) {
+			List<Atom> atomList = suffixFrag.getAtomList();
+			for (Atom atom : atomList) {
+				if (atom.getElement() == ChemEl.N && atom.getIncomingValency() ==3 ){
+					List<String> locants =atom.getLocants();
+					if (locants.size()==1 && MATCH_ELEMENT_SYMBOL_LOCANT.matcher(locants.get(0)).matches()){
+						List<Atom> neighbours = atom.getAtomNeighbours();
+						for (Atom neighbour : neighbours) {
+							if (neighbour.getElement() == ChemEl.N && neighbour.getIncomingValency()==1){
+								String locantToAdd = locants.get(0);
+								atom.clearLocants();
+								neighbour.addLocant(locantToAdd);
+								continue fragmentLoop;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	private static void processMainGroupLabelling(Fragment suffixableFragment, Map<String, Integer> elementCount, Set<Atom> atomsToIgnore) {
+		Set<String> elementToIgnore = new HashSet<>(elementCount.keySet());
+		List<Atom> atomList = suffixableFragment.getAtomList();
+		Collections.sort(atomList, new SortAtomsForMainGroupElementSymbols());
+		Atom atomToAddCLabelTo = null;//only add a C label if there is only one C in the main group
+		boolean seenMoreThanOneC = false;
+		for (Atom atom : atomList) {
+			if (atomsToIgnore.contains(atom)){
+				continue;
+			}
+			ChemEl chemEl = atom.getElement();
+			if (elementToIgnore.contains(chemEl.toString())){
+				continue;
+			}
+			if (chemEl == ChemEl.C) {
+				if (seenMoreThanOneC) {
+					continue;
+				}
+				if (atomToAddCLabelTo != null){
+					atomToAddCLabelTo = null;
+					seenMoreThanOneC = true;
+				}
+				else{
+					atomToAddCLabelTo = atom;
+				}
+			}
+			else{
+				assignLocant(atom, elementCount);
+			}
+		}
+		if (atomToAddCLabelTo != null){
+			atomToAddCLabelTo.addLocant("C");
+		}
+	}
+
+	private static void processSuffixLabelling(List<Fragment> suffixFragments, Map<String, Integer> elementCount, Set<Atom> atomsToIgnore) {
+		List<Atom> startingAtoms = new ArrayList<>();
+		Set<Atom> atomsVisited = new HashSet<>();
+		for (Fragment fragment : suffixFragments) {
+			Atom rAtom = fragment.getFirstAtom();
+			List<Atom> nextAtoms = getIntraFragmentNeighboursAndSetVisitedBondOrder(rAtom);
+			atomsVisited.addAll(nextAtoms);
+			startingAtoms.addAll(nextAtoms);
+		}
+		Collections.sort(startingAtoms, new SortAtomsForElementSymbols());
+
+		Deque<Atom> atomsToConsider = new ArrayDeque<>(startingAtoms);
+		while (atomsToConsider.size() > 0){
+			assignLocantsAndExploreNeighbours(elementCount, atomsToIgnore, atomsVisited, atomsToConsider);
+		}
+	}
+
+	private static void processNonCarboxylicAcidLabelling(Fragment suffixableFragment, Map<String, Integer> elementCount, Set<Atom> atomsToIgnore) {
+		Set<Atom> atomsVisited = new HashSet<>();
+		Atom firstAtom = suffixableFragment.getFirstAtom();
+		List<Atom> startingAtoms = getIntraFragmentNeighboursAndSetVisitedBondOrder(firstAtom);
+		
+		Collections.sort(startingAtoms, new SortAtomsForElementSymbols());
+		atomsVisited.add(firstAtom);
+		Deque<Atom> atomsToConsider = new ArrayDeque<>(startingAtoms);
+		while (atomsToConsider.size() > 0){
+			assignLocantsAndExploreNeighbours(elementCount, atomsToIgnore, atomsVisited, atomsToConsider);
+		}
+		if (!atomsToIgnore.contains(firstAtom) && firstAtom.determineValency(true) > firstAtom.getIncomingValency()) {
+			//e.g. carbonimidoyl the carbon has locant C
+			assignLocant(firstAtom, elementCount);
+		}
+	}
+
+	private static void assignLocantsAndExploreNeighbours(Map<String, Integer> elementCount, Set<Atom> atomsToIgnore, Set<Atom> atomsVisited, Deque<Atom> atomsToConsider) {
+		Atom atom = atomsToConsider.removeFirst();
+		atomsVisited.add(atom);
+		if (!atomsToIgnore.contains(atom)) {//assign locant
+			assignLocant(atom, elementCount);
+		}
+		List<Atom> atomsToExplore = getIntraFragmentNeighboursAndSetVisitedBondOrder(atom);
+		atomsToExplore.removeAll(atomsVisited);
+		Collections.sort(atomsToExplore, new SortAtomsForElementSymbols());
+		for (int i = atomsToExplore.size() - 1; i >= 0; i--) {
+			atomsToConsider.addFirst(atomsToExplore.get(i));
+		}
+	}
+
+	/**
+	 * Gets the neighbours of an atom that claim to be within the same frag
+	 * The order of bond taken to get to the neighbour is set on the neighbours Atom.VISITED property
+	 * @param atom
+	 * @return
+	 */
+	private static List<Atom> getIntraFragmentNeighboursAndSetVisitedBondOrder(Atom atom) {
+		List<Atom> atomsToExplore = new ArrayList<>();
+		List<Bond> bonds = atom.getBonds();
+		for (Bond bond : bonds) {
+			Atom neighbour = bond.getOtherAtom(atom);
+			if (neighbour.getFrag().equals(atom.getFrag())) {
+				atomsToExplore.add(neighbour);
+				neighbour.setProperty(Atom.VISITED, bond.getOrder());
+			}
+		}
+		return atomsToExplore;
+	}
+
+	private static void assignLocant(Atom atom, Map<String, Integer> elementCount) {
+		String element = atom.getElement().toString();
+		Integer count = elementCount.get(element);
+		if (count == null){
+			atom.addLocant(element);
+			elementCount.put(element, 1);
+		}
+		else{
+			atom.addLocant(element + StringTools.multiplyString("'", count));
+			elementCount.put(element, count + 1);
+		}
+	}
+
+	/** Adjusts the order of a bond in a fragment.
+	 *
+	 * @param fromAtom The lower-numbered atom in the bond
+	 * @param bondOrder The new bond order
+	 * @param fragment The fragment
+	 * @return The bond that was unsaturated
+     * @throws StructureBuildingException
+	 */
+	static Bond unsaturate(Atom fromAtom, int bondOrder, Fragment fragment) throws StructureBuildingException {
+		Atom toAtom = null;
+		Integer locant = null;
+		try{
+			String primes ="";
+			String locantStr = fromAtom.getFirstLocant();
+			int numberOfPrimes = StringTools.countTerminalPrimes(locantStr);
+			locant = Integer.parseInt(locantStr.substring(0, locantStr.length()-numberOfPrimes));
+			primes = StringTools.multiplyString("'", numberOfPrimes);
+			Atom possibleToAtom = fragment.getAtomByLocant(String.valueOf(locant +1)+primes);
+			if (possibleToAtom !=null && fromAtom.getBondToAtom(possibleToAtom)!=null){
+				toAtom = possibleToAtom;
+			}
+			else if (possibleToAtom ==null && fromAtom.getAtomIsInACycle()){//allow something like cyclohexan-6-ene, something like butan-4-ene will still fail
+				possibleToAtom = fragment.getAtomByLocant("1" + primes);
+				if (possibleToAtom !=null && fromAtom.getBondToAtom(possibleToAtom)!=null){
+					toAtom =possibleToAtom;
+				}
+			}
+		}
+		catch (Exception e) {
+			List<Atom> atomList = fragment.getAtomList();
+			int initialIndice = atomList.indexOf(fromAtom);
+			if (initialIndice +1 < atomList.size() && fromAtom.getBondToAtom(atomList.get(initialIndice +1))!=null){
+				toAtom = atomList.get(initialIndice +1);
+			}
+		}
+		if (toAtom==null){
+			if (locant!=null){
+				throw new StructureBuildingException("Could not find bond to unsaturate starting from the atom with locant: " +locant);
+			}
+			else{
+				throw new StructureBuildingException("Could not find bond to unsaturate");
+			}
+		}
+		Bond b = fromAtom.getBondToAtomOrThrow(toAtom);
+		if (b.getOrder() != 1) {
+			throw new StructureBuildingException("Bond indicated to be unsaturated was already unsaturated");
+		}
+		b.setOrder(bondOrder);
+		return b;
+	}
+
+	/** Adjusts the order of a bond in a fragment.
+	 *
+	 * @param fromAtom The first atom in the bond
+	 * @param locantTo The locant of the other atom in the bond
+	 * @param bondOrder The new bond order
+	 * @param fragment The fragment
+     * @throws StructureBuildingException
+	 */
+	static void unsaturate(Atom fromAtom, String locantTo, int bondOrder, Fragment fragment) throws StructureBuildingException {
+		Atom toAtom = fragment.getAtomByLocantOrThrow(locantTo);
+		Bond b = fromAtom.getBondToAtomOrThrow(toAtom);
+		if (b.getOrder() != 1) {
+			throw new StructureBuildingException("Bond indicated to be unsaturated was already unsaturated");
+		}
+		b.setOrder(bondOrder);
+	}
+
+	/**Adjusts the labeling on a fused ring system, such that bridgehead atoms
+	 * have locants endings in 'a' or 'b' etc. Example: naphthalene
+	 * 1,2,3,4,5,6,7,8,9,10->1,2,3,4,4a,5,6,7,8,8a
+     * @param atomList
+	 */
+	static void relabelLocantsAsFusedRingSystem(List<Atom> atomList) {
+		int locantVal = 0;
+		char locantLetter = 'a';
+		for (Atom atom : atomList) {
+			atom.clearLocants();
+		}
+		for (Atom atom : atomList) {
+			if(atom.getElement() != ChemEl.C || atom.getBondCount() < 3) {
+				locantVal++;
+				locantLetter = 'a';
+				atom.addLocant(Integer.toString(locantVal));
+			} else {
+				atom.addLocant(Integer.toString(locantVal) + locantLetter);
+				locantLetter++;
+			}
+		}
+	}
+	
+	/**
+	 * Adds the given string to all the locants of the atoms.
+	 * @param atomList
+	 * @param stringToAdd
+	 */
+	static void relabelLocants(List<Atom> atomList, String stringToAdd) {
+		for (Atom atom : atomList) {
+			List<String> locants = new ArrayList<>(atom.getLocants());
+			atom.clearLocants();
+			for (String locant : locants) {
+				atom.addLocant(locant + stringToAdd);
+			}
+		}
+	}
+	
+	/**
+	 * Adds the given string to all the numeric locants of the atoms.
+	 * @param atomList
+	 * @param stringToAdd
+	 */
+	static void relabelNumericLocants(List<Atom> atomList, String stringToAdd) {
+		for (Atom atom : atomList) {
+			List<String> locants = new ArrayList<>(atom.getLocants());
+			for (String locant : locants) {
+				if (MATCH_NUMERIC_LOCANT.matcher(locant).matches()){
+					atom.removeLocant(locant);
+					atom.addLocant(locant + stringToAdd);
+				}
+			}
+		}
+	}
+
+
+	static void splitOutAtomIntoValency1OutAtoms(OutAtom outAtom) {
+		Fragment frag =outAtom.getAtom().getFrag();
+		for (int i = 1; i < outAtom.getValency(); i++) {
+			frag.addOutAtom(outAtom.getAtom(), 1, outAtom.isSetExplicitly());
+		}
+		outAtom.setValency(1);
+	}
+
+	/**
+	 * Checks if the specified Nitrogen is potentially involved in [NH]C=N <-> N=C[NH] tautomerism
+	 * Given the starting nitrogen returns the other nitrogen or null if that nitrogen does not appear to be involved in such tautomerism
+	 * @param nitrogen
+	 * @return null or the other nitrogen
+	 */
+	static Atom detectSimpleNitrogenTautomer(Atom nitrogen) {
+		if (nitrogen.getElement() == ChemEl.N && nitrogen.getAtomIsInACycle()){
+			for (Atom neighbour : nitrogen.getAtomNeighbours()) {
+				if (neighbour.hasSpareValency() && neighbour.getElement() == ChemEl.C && neighbour.getAtomIsInACycle()){
+					List<Atom> distance2Neighbours = neighbour.getAtomNeighbours();
+					distance2Neighbours.remove(nitrogen);
+					for (Atom distance2Neighbour : distance2Neighbours) {
+						if (distance2Neighbour.hasSpareValency() && distance2Neighbour.getElement() == ChemEl.N && distance2Neighbour.getAtomIsInACycle() && distance2Neighbour.getCharge()==0){
+							return distance2Neighbour;
+						}
+					}
+				}
+			}
+		}
+		return null;
+	}
+
+	/**Increases the order of bonds joining atoms with spareValencies,
+	 * and uses up said spareValencies.
+	 * [spare valency is an indication of the atom's desire to form the maximum number of non-cumulative double bonds]
+	 * @param frag
+     * @throws StructureBuildingException If the algorithm can't work out where to put the bonds
+	 */
+	static void convertSpareValenciesToDoubleBonds(Fragment frag) throws StructureBuildingException {
+		List<Atom> atomCollection = frag.getAtomList();
+		/* pick atom, getAtomNeighbours, decideIfTerminal, resolve */
+
+		/*
+		 * Remove spare valency on atoms with valency precluding creation of double bonds
+		 */
+		for(Atom a : atomCollection) {
+			a.ensureSVIsConsistantWithValency(true);
+		}
+
+		/*
+		 * Remove spare valency on atoms that are not adjacent to another atom with spare valency
+		 */
+		atomLoop: for(Atom a : atomCollection) {
+			if(a.hasSpareValency()) {
+				for(Atom aa : frag.getIntraFragmentAtomNeighbours(a)) {
+					if(aa.hasSpareValency()) {
+						continue atomLoop;
+					}
+				}
+				a.setSpareValency(false);
+			}
+		}
+
+		/*
+		*  The indicated hydrogen from the original SMILES definition of the fragment e.g. [nH] are used to disambiguate if there are
+		*  an odd number of atoms with spare valency. Hence pyrrole is unambiguously 1H-pyrrole unless specified otherwise
+		*  Things gets more complicated if the input contained multiple indicated hydrogen as it is unclear whether these still apply to the final molecule
+		*/
+		Atom atomToReduceValencyAt = null;
+		List<Atom> originalIndicatedHydrogen = frag.getIndicatedHydrogen();
+		List<Atom> indicatedHydrogen = new ArrayList<>(originalIndicatedHydrogen.size());
+		for (Atom atom : frag.getIndicatedHydrogen()) {
+			if (atom.hasSpareValency() && atom.getCharge() == 0) {
+				indicatedHydrogen.add(atom);
+			}
+		}
+		if (indicatedHydrogen.size() > 0) {
+			//typically there will be only one indicated hydrogen
+			if (indicatedHydrogen.size() > 1) {
+				for (Atom indicatedAtom : indicatedHydrogen) {
+					boolean couldBeInvolvedInSimpleNitrogenTautomerism = false;//fix for guanine like purine derivatives
+					if (indicatedAtom.getElement() == ChemEl.N && indicatedAtom.getAtomIsInACycle()) {
+						atomloop : for (Atom neighbour : indicatedAtom.getAtomNeighbours()) {
+							if (neighbour.getElement() == ChemEl.C && neighbour.getAtomIsInACycle()) {
+								List<Atom> distance2Neighbours = neighbour.getAtomNeighbours();
+								distance2Neighbours.remove(indicatedAtom);
+								for (Atom distance2Neighbour : distance2Neighbours) {
+									if (distance2Neighbour.getElement() == ChemEl.N && distance2Neighbour.getAtomIsInACycle() && !originalIndicatedHydrogen.contains(distance2Neighbour)){
+										couldBeInvolvedInSimpleNitrogenTautomerism = true;
+										break atomloop;
+									}
+								}
+							}
+						}
+					}
+					//retain spare valency if has the cyclic [NH]C=N moiety but substitution has meant that this tautomerism doesn't actually occur cf. 8-oxoguanine
+					if (!couldBeInvolvedInSimpleNitrogenTautomerism || detectSimpleNitrogenTautomer(indicatedAtom) != null) {
+						indicatedAtom.setSpareValency(false);
+					}
+				}
+			}
+			else{
+				atomToReduceValencyAt = indicatedHydrogen.get(0);
+			}
+		}
+		
+		int svCount = 0;
+		for(Atom a : atomCollection) {
+			svCount += a.hasSpareValency() ? 1 :0;
+		}
+
+		/*
+		 * Double-bonds go between pairs of atoms so if there are an off number of candidate atoms (e.g. pyrrole) an atom must be chosen
+		 * The atom with indicated hydrogen (see above) is used in preference else heuristics are used to chose a candidate
+		 */
+		if((svCount & 1) == 1) {
+			if (atomToReduceValencyAt == null) {
+				atomToReduceValencyAt = findBestAtomToRemoveSpareValencyFrom(frag, atomCollection);
+			}
+			atomToReduceValencyAt.setSpareValency(false);
+			svCount--;
+		}
+
+		while(svCount > 0) {
+			boolean foundTerminalFlag = false;
+			boolean foundNonBridgeHeadFlag = false;
+			boolean foundBridgeHeadFlag = false;
+			//First handle cases where double bond placement is completely unambiguous i.e. an atom where only one neighbour has spare valency
+			for(Atom a : atomCollection) {
+				if(a.hasSpareValency()) {
+					int count = 0;
+					for(Atom aa : frag.getIntraFragmentAtomNeighbours(a)) {
+						if(aa.hasSpareValency()) {
+							count++;
+						}
+					}
+					if(count == 1) {
+						for(Atom aa : frag.getIntraFragmentAtomNeighbours(a)) {
+							if(aa.hasSpareValency()) {
+								foundTerminalFlag = true;
+								a.setSpareValency(false);
+								aa.setSpareValency(false);
+								a.getBondToAtomOrThrow(aa).addOrder(1);
+								svCount -= 2;//Two atoms where for one of them this bond is the only double bond it can possible form
+								break;
+							}
+						}
+					}
+				}
+			}
+			if(foundTerminalFlag) {
+				continue;
+			}
+
+			//Find two atoms where one, or both, of them are not bridgeheads
+			for(Atom a : atomCollection) {
+				List<Atom> neighbours = frag.getIntraFragmentAtomNeighbours(a);
+				if(a.hasSpareValency() && neighbours.size() < 3) {
+					for(Atom aa : neighbours) {
+						if(aa.hasSpareValency()) {
+							foundNonBridgeHeadFlag = true;
+							a.setSpareValency(false);
+							aa.setSpareValency(false);
+							a.getBondToAtomOrThrow(aa).addOrder(1);
+							svCount -= 2;//Two atoms where one of them is not a bridge head
+							break;
+						}
+					}
+				}
+				if(foundNonBridgeHeadFlag) {
+					break;
+				}
+			}
+			if(foundNonBridgeHeadFlag) {
+				continue;
+			}
+			
+			//Find two atoms where both of them are bridgheads
+			for(Atom a : atomCollection) {
+				List<Atom> neighbours = frag.getIntraFragmentAtomNeighbours(a);
+				if(a.hasSpareValency()) {
+					for(Atom aa : neighbours) {
+						if(aa.hasSpareValency()) {
+							foundBridgeHeadFlag = true;
+							a.setSpareValency(false);
+							aa.setSpareValency(false);
+							a.getBondToAtomOrThrow(aa).addOrder(1);
+							svCount -= 2;//Two atoms where both of them are a bridge head e.g. necessary for something like coronene
+							break;
+						}
+					}
+				}
+				if(foundBridgeHeadFlag) {
+					break;
+				}
+			}
+			if(!foundBridgeHeadFlag) {
+				throw new StructureBuildingException("Failed to assign all double bonds! (Check that indicated hydrogens have been appropriately specified)");
+			}
+		}
+	}
+
+	private static Atom findBestAtomToRemoveSpareValencyFrom(Fragment frag, List<Atom> atomCollection) {
+		for(Atom a : atomCollection) {//try and find an atom with SV that neighbours only one atom with SV
+			if(a.hasSpareValency()) {
+				int atomsWithSV = 0;
+				for(Atom aa : frag.getIntraFragmentAtomNeighbours(a)) {
+					if(aa.hasSpareValency()) {
+						atomsWithSV++;
+					}
+				}
+				if (atomsWithSV == 1) {
+					return a;
+				}
+			}
+		}
+		atomLoop: for(Atom a : atomCollection) {//try and find an atom with bridgehead atoms with SV on both sides c.f. phenoxastibinine == 10H-phenoxastibinine
+			if(a.hasSpareValency()) {
+				List<Atom> neighbours = frag.getIntraFragmentAtomNeighbours(a);
+				if (neighbours.size() == 2) {
+					for(Atom aa : neighbours) {
+						if(frag.getIntraFragmentAtomNeighbours(aa).size() < 3){
+							continue atomLoop;
+						}
+					}
+					return a;
+				}
+			}
+		}
+		//Prefer nitrogen to carbon e.g. get NHC=C rather than N=CCH
+		Atom firstAtomWithSpareValency = null;
+		Atom firstHeteroAtomWithSpareValency = null;
+		for(Atom a : atomCollection) {
+			if(a.hasSpareValency()) {
+				if (a.getElement() != ChemEl.C) {
+					if (a.getCharge() == 0) {
+						return a;
+					}
+					if(firstHeteroAtomWithSpareValency == null) {
+						firstHeteroAtomWithSpareValency = a;
+					}
+				}
+				if(firstAtomWithSpareValency == null) {
+					firstAtomWithSpareValency = a;
+				}
+			}
+		}
+		if (firstAtomWithSpareValency == null) {
+			throw new IllegalArgumentException("OPSIN Bug: No atom had spare valency!");
+		}
+		return firstHeteroAtomWithSpareValency != null ? firstHeteroAtomWithSpareValency : firstAtomWithSpareValency;
+	}
+
+
+	static Atom getAtomByAminoAcidStyleLocant(Atom backboneAtom, String elementSymbol, String primes) {
+		//Search for appropriate atom by using the same algorithm as is used to assign locants initially
+
+		List<Atom> startingAtoms = new ArrayList<>();
+		Set<Atom> atomsVisited = new HashSet<>();
+		List<Atom> neighbours = getIntraFragmentNeighboursAndSetVisitedBondOrder(backboneAtom);
+		mainLoop: for (Atom neighbour : neighbours) {
+			atomsVisited.add(neighbour);
+			if (!neighbour.getType().equals(SUFFIX_TYPE_VAL)){
+				for (String neighbourLocant : neighbour.getLocants()) {
+					if (MATCH_NUMERIC_LOCANT.matcher(neighbourLocant).matches()){//gone to an inappropriate atom
+						continue mainLoop;
+					}
+				}
+			}
+			startingAtoms.add(neighbour);
+		}
+
+		Collections.sort(startingAtoms, new SortAtomsForElementSymbols());
+		Map<String,Integer> elementCount = new HashMap<>();//keeps track of how many times each element has been seen
+	
+		Deque<Atom> atomsToConsider = new ArrayDeque<>(startingAtoms);
+		boolean hydrazoneSpecialCase =false;//look for special case violation of IUPAC rule where the locant of the =N- atom is skipped. This flag is set when =N- is encountered
+		while (atomsToConsider.size() > 0){
+			Atom atom = atomsToConsider.removeFirst();
+			atomsVisited.add(atom);
+			int primesOnPossibleAtom =0;
+			String element =atom.getElement().toString();
+			if (elementCount.get(element)==null){
+				elementCount.put(element,1);
+			}
+			else{
+				int count =elementCount.get(element);
+				primesOnPossibleAtom =count;
+				elementCount.put(element, count +1);
+			}
+			if (hydrazoneSpecialCase){
+				if (element.equals(elementSymbol) && primes.length() == primesOnPossibleAtom -1){
+					return atom;
+				}
+				hydrazoneSpecialCase =false;
+			}
+
+			List<Atom> atomNeighbours = getIntraFragmentNeighboursAndSetVisitedBondOrder(atom);
+			atomNeighbours.removeAll(atomsVisited);
+			for (int i = atomNeighbours.size() -1; i >=0; i--) {
+				Atom neighbour = atomNeighbours.get(i);
+				if (!neighbour.getType().equals(SUFFIX_TYPE_VAL)){
+					for (String neighbourLocant : neighbour.getLocants()) {
+						if (MATCH_NUMERIC_LOCANT.matcher(neighbourLocant).matches()){//gone to an inappropriate atom
+							atomNeighbours.remove(i);
+							break;
+						}
+					}
+				}
+			}
+			if (atom.getElement() == ChemEl.N && atom.getIncomingValency() ==3 && atom.getCharge()==0 
+					&& atomNeighbours.size()==1 && atomNeighbours.get(0).getElement() == ChemEl.N){
+				hydrazoneSpecialCase =true;
+			}
+			else{
+				if (element.equals(elementSymbol)){
+					if (primes.length() == primesOnPossibleAtom){
+						return atom;
+					}
+				}
+			}
+
+			Collections.sort(atomNeighbours, new SortAtomsForElementSymbols());
+			for (int i = atomNeighbours.size() - 1; i >= 0; i--) {
+				atomsToConsider.addFirst(atomNeighbours.get(i));
+			}
+		}
+
+		if (primes.equals("") && backboneAtom.getElement().toString().equals(elementSymbol)){//maybe it meant the starting atom
+			return backboneAtom;
+		}
+		return null;
+	}
+	
+	
+	/**
+	 * Determines whether the bond between two elements is likely to be covalent
+	 * This is crudely determined based on whether the combination of elements fall outside the ionic and
+	 * metallic sections of a van Arkel diagram
+	 * @param chemEl1
+	 * @param chemEl2
+	 * @return
+	 */
+	static boolean isCovalent(ChemEl chemEl1, ChemEl chemEl2) {
+		Double atom1Electrongegativity = AtomProperties.getPaulingElectronegativity(chemEl1);
+		Double atom2Electrongegativity = AtomProperties.getPaulingElectronegativity(chemEl2);
+		if (atom1Electrongegativity!=null && atom2Electrongegativity !=null){
+			double halfSum = (atom1Electrongegativity + atom2Electrongegativity)/2;
+			double difference = Math.abs(atom1Electrongegativity - atom2Electrongegativity);
+			if (halfSum < 1.6){
+				return false;//probably metallic
+			}
+			if (difference < 1.76 * halfSum - 3.03){
+				return true;
+			}			
+		}
+		return false;
+	}
+	
+	/**
+	 * Is the atom a suffix atom/carbon of an aldehyde atom/chalcogen functional atom/hydroxy (or chalcogen equivalent)
+	 * (by special step heterostems are not considered hydroxy e.g. disulfane)
+	 * @param atom
+	 * @return
+	 */
+	static boolean isCharacteristicAtom(Atom atom) {
+		if (atom.getType().equals(SUFFIX_TYPE_VAL) || 
+			(atom.getElement().isChalcogen() && !HETEROSTEM_SUBTYPE_VAL.equals(atom.getFrag().getSubType()) &&
+			atom.getIncomingValency() == 1 &&
+			atom.getOutValency() == 0 && atom.getCharge() == 0)) {
+			return true;
+		}
+		return isFunctionalAtomOrAldehyde(atom);
+	}
+	
+	/**
+	 * Is the atom an aldehyde atom or a chalcogen functional atom
+	 * @param atom
+	 * @return
+	 */
+	static boolean isFunctionalAtomOrAldehyde(Atom atom) {
+		if (Boolean.TRUE.equals(atom.getProperty(Atom.ISALDEHYDE))){//substituting an aldehyde would make it no longer an aldehyde
+			return true;
+		}
+		return isFunctionalAtom(atom);
+	}
+	
+	/**
+	 * Is the atom a chalcogen functional atom
+	 * @param atom
+	 * @return
+	 */
+	static boolean isFunctionalAtom(Atom atom) {
+		ChemEl chemEl = atom.getElement();
+		if (chemEl.isChalcogen()) {//potential chalcogen functional atom
+			Fragment frag = atom.getFrag();
+			for (int i = 0, l = frag.getFunctionalAtomCount(); i < l; i++) {
+				if (atom.equals(frag.getFunctionalAtom(i).getAtom())){
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+
+	/**
+	 * Checks that all atoms in a ring appear to be equivalent
+	 * @param ring
+	 * @return true if all equivalent, else false
+	 */
+	static boolean  allAtomsInRingAreIdentical(Fragment ring){
+		List<Atom> atomList = ring.getAtomList();
+		Atom firstAtom = atomList.get(0);
+		ChemEl chemEl = firstAtom.getElement();
+		int valency = firstAtom.getIncomingValency();
+		boolean spareValency = firstAtom.hasSpareValency();
+		for (Atom atom : atomList) {
+			if (atom.getElement() != chemEl){
+				return false;
+			}
+			if (atom.getIncomingValency() != valency){
+				return false;
+			}
+			if (atom.hasSpareValency() != spareValency){
+				return false;
+			}
+		}
+		return true;
+	}
+	
+	static void removeTerminalAtom(BuildState state, Atom atomToRemove) {
+		AtomParity atomParity =  atomToRemove.getAtomNeighbours().get(0).getAtomParity();
+		if (atomParity!=null){//replace reference to atom with reference to implicit hydrogen
+			Atom[] atomRefs4= atomParity.getAtomRefs4();
+			for (int i = 0; i < atomRefs4.length; i++) {
+				if (atomRefs4[i]==atomToRemove){
+					atomRefs4[i] = AtomParity.deoxyHydrogen;
+					break;
+				}
+			}
+		}
+		state.fragManager.removeAtomAndAssociatedBonds(atomToRemove);
+	}
+	
+	/**
+	 * Removes a terminal oxygen from the atom 
+	 * An exception is thrown if no suitable oxygen could be found connected to the atom
+	 * Note that [N+][O-] is treated as N=O
+	 * @param state
+	 * @param atom
+	 * @param desiredBondOrder
+	 * @throws StructureBuildingException
+	 */
+	static void removeTerminalOxygen(BuildState state, Atom atom, int desiredBondOrder) throws StructureBuildingException {
+		//TODO prioritise [N+][O-]
+		List<Atom> neighbours = atom.getAtomNeighbours();
+		for (Atom neighbour : neighbours) {
+			if (neighbour.getElement() == ChemEl.O && neighbour.getBondCount()==1){
+				Bond b = atom.getBondToAtomOrThrow(neighbour);
+				if (b.getOrder()==desiredBondOrder && neighbour.getCharge()==0){
+					FragmentTools.removeTerminalAtom(state, neighbour);
+					if (atom.getLambdaConventionValency()!=null){//corrects valency for phosphin/arsin/stibin
+						atom.setLambdaConventionValency(atom.getLambdaConventionValency()-desiredBondOrder);
+					}
+					if (atom.getMinimumValency()!=null){//corrects valency for phosphin/arsin/stibin
+						atom.setMinimumValency(atom.getMinimumValency()-desiredBondOrder);
+					}
+					return;
+				}
+				else if (neighbour.getCharge() ==-1 && b.getOrder()==1 && desiredBondOrder == 2){
+					if (atom.getCharge() ==1 && atom.getElement() == ChemEl.N){
+						FragmentTools.removeTerminalAtom(state, neighbour);
+						atom.neutraliseCharge();
+						return;
+					}
+				}
+			}
+		}
+		if (desiredBondOrder ==2){
+			throw new StructureBuildingException("Double bonded oxygen not found at suffix attachment position. Perhaps a suffix has been used inappropriately");
+		}
+		else if (desiredBondOrder ==1){
+			throw new StructureBuildingException("Hydroxy oxygen not found at suffix attachment position. Perhaps a suffix has been used inappropriately");
+		}
+		else {
+			throw new StructureBuildingException("Suitable oxygen not found at suffix attachment position Perhaps a suffix has been used inappropriately");
+		}
+
+	}
+
+
+	/**
+	 * Finds terminal atoms of the given element type from the list given
+	 * The terminal atoms be single bonded, not radicals and uncharged
+	 * @param atoms
+	 * @param chemEl
+	 * @return 
+	 */
+	static List<Atom> findHydroxyLikeTerminalAtoms(List<Atom> atoms, ChemEl chemEl) {
+		List<Atom> matches =new ArrayList<>();
+		for (Atom atom : atoms) {
+			if (atom.getElement() == chemEl && atom.getIncomingValency() == 1 &&
+				atom.getOutValency() == 0 && atom.getCharge() == 0){
+				matches.add(atom);
+			}
+		}
+		return matches;
+	}
+
+	/**
+	 * Checks whether a bond is part of a 6 member or smaller ring.
+	 * This is necessary as such double bonds are assumed to not be capable of having E/Z stereochemistry
+	 * @param bond
+	 * @return true unless in a 6 member or smaller rings
+	 */
+	static boolean notIn6MemberOrSmallerRing(Bond bond) {
+		Atom fromAtom =bond.getFromAtom();
+		Atom toAtom = bond.getToAtom();
+		if (fromAtom.getAtomIsInACycle() && toAtom.getAtomIsInACycle()){//obviously both must be in rings
+			//attempt to get from the fromAtom to the toAtom in 6 or fewer steps.
+			List<Atom> visitedAtoms = new ArrayList<>();
+			Deque<Atom> atomsToInvestigate = new ArrayDeque<>();//A queue is not used as I need to make sure that only up to depth 6 is investigated
+			List<Atom> neighbours =fromAtom.getAtomNeighbours();
+			neighbours.remove(toAtom);
+			for (Atom neighbour : neighbours) {
+				atomsToInvestigate.add(neighbour);
+			}
+			visitedAtoms.add(fromAtom);
+			for (int i = 0; i < 5; i++) {//up to 5 bonds from the neighbours of the fromAtom i.e. up to ring size 6
+				if (atomsToInvestigate.isEmpty()){
+					break;
+				}
+				Deque<Atom> atomsToInvestigateNext = new ArrayDeque<>();
+				while (!atomsToInvestigate.isEmpty()) {
+					Atom currentAtom =atomsToInvestigate.removeFirst();
+					if (currentAtom == toAtom){
+						return false;
+					}
+					visitedAtoms.add(currentAtom);
+					neighbours =currentAtom.getAtomNeighbours();
+					for (Atom neighbour : neighbours) {
+						if (!visitedAtoms.contains(neighbour) && neighbour.getAtomIsInACycle()){
+							atomsToInvestigateNext.add(neighbour);
+						}
+					}
+				}
+				atomsToInvestigate = atomsToInvestigateNext;
+			}
+		}
+		return true;
+	}
+	
+	/**
+	 * Finds the hydroxy atom of all hydroxy functional groups in a fragment
+	 * i.e. not in carboxylic acid or oxime
+	 * @param frag
+	 * @return
+	 * @throws StructureBuildingException 
+	 */
+	static List<Atom> findHydroxyGroups(Fragment frag) throws StructureBuildingException {
+		List<Atom> hydroxyAtoms = new ArrayList<>();
+		List<Atom> atoms = frag.getAtomList();
+		for (Atom atom : atoms) {
+			if (atom.getElement() == ChemEl.O && atom.getIncomingValency() == 1 && atom.getOutValency() == 0 && atom.getCharge() == 0){
+				Atom adjacentAtom = atom.getAtomNeighbours().get(0);
+				List<Atom> neighbours = adjacentAtom.getAtomNeighbours();
+				if (adjacentAtom.getElement() == ChemEl.C){
+					neighbours.remove(atom);
+					if (neighbours.size() >= 1 && neighbours.get(0).getElement() == ChemEl.O && adjacentAtom.getBondToAtomOrThrow(neighbours.get(0)).getOrder()==2){
+						continue;
+					}
+					if (neighbours.size() >= 2 && neighbours.get(1).getElement() == ChemEl.O && adjacentAtom.getBondToAtomOrThrow(neighbours.get(1)).getOrder()==2){
+						continue;
+					}
+					hydroxyAtoms.add(atom);
+				}
+			}
+		}
+		return hydroxyAtoms;
+	}
+	
+	static List<Atom> findnAtomsForSubstitution(List<Atom> atomList, Atom preferredAtom, int numberOfSubstitutionsRequired, int bondOrder, boolean takeIntoAccountOutValency, boolean preserveValency) {
+		int atomCount = atomList.size();
+		int startingIndex = preferredAtom != null ? atomList.indexOf(preferredAtom) : 0;
+		if (startingIndex < 0){
+			throw new IllegalArgumentException("OPSIN Bug: preferredAtom should be part of the list of atoms to search through");
+		}
+		CyclicAtomList atoms = new CyclicAtomList(atomList, startingIndex - 1);//next() will retrieve the atom at the startingIndex
+		List<Atom> substitutableAtoms = new ArrayList<>();
+		if (atomCount == 1 && ELEMENTARYATOM_TYPE_VAL.equals(atomList.get(0).getFrag().getType())) {
+			Atom atom = atomList.get(0);
+			int timesAtomCanBeSubstituted = getTimesElementaryAtomCanBeSubstituted(atom);
+			for (int j = 1; j <= timesAtomCanBeSubstituted; j++) {
+				substitutableAtoms.add(atom);
+			}
+		}
+		else {
+			for (int i = 0; i < atomCount; i++) {//aromaticity preserved, standard valency assumed, characteristic atoms ignored
+				Atom atom = atoms.next();
+				if (!FragmentTools.isCharacteristicAtom(atom) || (numberOfSubstitutionsRequired == 1 && atom == preferredAtom)) {
+					int currentExpectedValency = atom.determineValency(takeIntoAccountOutValency);
+					int usedValency = atom.getIncomingValency() + (atom.hasSpareValency() ? 1 : 0) + (takeIntoAccountOutValency ? atom.getOutValency() : 0);
+					int timesAtomCanBeSubstituted = ((currentExpectedValency - usedValency)/ bondOrder);
+					for (int j = 1; j <= timesAtomCanBeSubstituted; j++) {
+						substitutableAtoms.add(atom);
+					}
+				}
+			}
+		}
+		if (substitutableAtoms.size() >= numberOfSubstitutionsRequired){
+			return substitutableAtoms;
+		}
+		substitutableAtoms.clear();
+		for (int i = 0; i < atomCount; i++) {//aromaticity preserved, standard valency assumed, functional suffixes ignored
+			Atom atom = atoms.next();
+			if (!FragmentTools.isFunctionalAtomOrAldehyde(atom) || (numberOfSubstitutionsRequired == 1 && atom == preferredAtom)) {
+				int currentExpectedValency = atom.determineValency(takeIntoAccountOutValency);
+				int usedValency = atom.getIncomingValency() + (atom.hasSpareValency() ? 1 : 0) + (takeIntoAccountOutValency ? atom.getOutValency() : 0);
+				int timesAtomCanBeSubstituted = ((currentExpectedValency - usedValency)/ bondOrder);
+				for (int j = 1; j <= timesAtomCanBeSubstituted; j++) {
+					substitutableAtoms.add(atom);
+				}
+			}
+		}
+		if (substitutableAtoms.size() >= numberOfSubstitutionsRequired){
+			return substitutableAtoms;
+		}
+		if (preserveValency) {
+			return null;
+		}
+		substitutableAtoms.clear();
+		
+		for (int i = 0; i < atomCount; i++) {//aromaticity preserved, any sensible valency allowed, anything substitutable
+			Atom atom = atoms.next();
+			Integer maximumValency = ValencyChecker.getMaximumValency(atom);
+			if (maximumValency != null) {
+				int usedValency = atom.getIncomingValency() + (atom.hasSpareValency() ? 1 : 0) + (takeIntoAccountOutValency ? atom.getOutValency() : 0);
+				int timesAtomCanBeSubstituted = ((maximumValency - usedValency)/ bondOrder);
+				for (int j = 1; j <= timesAtomCanBeSubstituted; j++) {
+					substitutableAtoms.add(atom);
+				}
+			}
+			else{
+				for (int j = 0; j < numberOfSubstitutionsRequired; j++) {
+					substitutableAtoms.add(atom);
+				}
+			}
+		}
+		if (substitutableAtoms.size() >= numberOfSubstitutionsRequired){
+			return substitutableAtoms;
+		}
+		substitutableAtoms.clear();
+
+		for (int i = 0; i < atomCount; i++) {//aromaticity dropped, any sensible valency allowed, anything substitutable
+			Atom atom = atoms.next();
+			Integer maximumValency = ValencyChecker.getMaximumValency(atom);
+			if (maximumValency != null) {
+				int usedValency = atom.getIncomingValency() + (takeIntoAccountOutValency ? atom.getOutValency() : 0);
+				int timesAtomCanBeSubstituted = ((maximumValency - usedValency)/ bondOrder);
+				for (int j = 1; j <= timesAtomCanBeSubstituted; j++) {
+					substitutableAtoms.add(atom);
+				}
+			}
+			else {
+				for (int j = 0; j < numberOfSubstitutionsRequired; j++) {
+					substitutableAtoms.add(atom);
+				}
+			}
+		}
+		if (substitutableAtoms.size() >= numberOfSubstitutionsRequired){
+			return substitutableAtoms;
+		}
+		return null;
+	}
+	
+	private static int getTimesElementaryAtomCanBeSubstituted(Atom atom) {
+		Integer oxidationNumber = atom.getProperty(Atom.OXIDATION_NUMBER);//explicitly set oxidation state
+		if (oxidationNumber == null) {
+			String oxidationStates = atom.getFrag().getTokenEl().getAttributeValue(COMMONOXIDATIONSTATESANDMAX_ATR);//properties of this element
+			if (oxidationStates != null) {
+				String[] commonOxidationStates = oxidationStates.split(":")[0].split(",");
+				//highest common oxidation state
+				oxidationNumber = Integer.parseInt(commonOxidationStates[commonOxidationStates.length - 1]);
+			}
+			else {
+				oxidationNumber = 0;
+			}
+		}
+		
+		int usedValency = atom.getIncomingValency();
+		return (oxidationNumber > usedValency) ? oxidationNumber - usedValency : 0;
+	}
+
+	static List<Atom> findnAtomsForSubstitution(List<Atom> atomList, Atom preferredAtom, int numberOfSubstitutionsRequired, int bondOrder, boolean takeIntoAccountOutValency) {
+		return findnAtomsForSubstitution(atomList, preferredAtom, numberOfSubstitutionsRequired, bondOrder, takeIntoAccountOutValency, false);
+	}
+	
+	static List<Atom> findnAtomsForSubstitution(Fragment frag, Atom preferredAtom, int numberOfSubstitutionsRequired, int bondOrder, boolean takeIntoAccountOutValency) {
+		return findnAtomsForSubstitution(frag.getAtomList(), preferredAtom, numberOfSubstitutionsRequired, bondOrder, takeIntoAccountOutValency);
+	}
+	
+	/**
+	 * Returns a list of atoms of size >= numberOfSubstitutionsDesired (or null if this not possible)
+	 * An atom must have have sufficient valency to support a substituent requiring a bond of order bondOrder
+	 * If an atom can support multiple substituents it will appear in the list multiple times
+	 * This method iterates over the the fragment atoms attempting to fulfil these requirements with incrementally more lenient constraints:
+	 * aromaticity preserved, standard valency assumed, characteristic atoms ignored
+	 * aromaticity preserved, standard valency assumed, functional suffixes ignored
+	 * aromaticity preserved, any sensible valency allowed, anything substitutable
+	 * aromaticity dropped, any sensible valency allowed, anything substitutable
+	 * 
+	 * Iteration starts from the defaultInAtom (if applicable, else the first atom) i.e. the defaultInAtom if substitutable will be the first atom in the list
+	 * @param frag
+	 * @param numberOfSubstitutionsRequired
+	 * @param bondOrder
+	 * @return
+	 */
+	static List<Atom> findnAtomsForSubstitution(Fragment frag, int numberOfSubstitutionsRequired, int bondOrder) {
+		return findnAtomsForSubstitution(frag.getAtomList(), frag.getDefaultInAtom(), numberOfSubstitutionsRequired, bondOrder, true);
+	}
+	
+	/**
+	 * Returns a list of the most preferable atoms for substitution (empty list if none are)
+	 * An atom must have have sufficient valency to support a substituent requiring a bond of order bondOrder
+	 * If an atom can support multiple substituents it will appear in the list multiple times
+	 * This method iterates over the the fragment atoms attempting to fulfil these requirements with incrementally more lenient constraints:
+	 * aromaticity preserved, standard valency assumed, characteristic atoms ignored
+	 * aromaticity preserved, standard valency assumed, functional suffixes ignored
+	 * aromaticity preserved, any sensible valency allowed, anything substitutable
+	 * aromaticity dropped, any sensible valency allowed, anything substitutable
+	 * 
+	 * Iteration starts from the defaultInAtom (if applicable, else the first atom) i.e. the defaultInAtom if substitutable will be the first atom in the list
+	 * @param frag
+	 * @param bondOrder
+	 * @return
+	 */
+	static List<Atom> findSubstituableAtoms(Fragment frag, int bondOrder) {
+		List<Atom> potentialAtoms = findnAtomsForSubstitution(frag, 1, bondOrder);
+		if (potentialAtoms == null) {
+			return Collections.emptyList();
+		}
+		return potentialAtoms;
+	}
+
+	static Atom lastNonSuffixCarbonWithSufficientValency(Fragment conjunctiveFragment) {
+		List<Atom> atomList = conjunctiveFragment.getAtomList();
+		for (int i = atomList.size()-1; i >=0; i--) {
+			Atom a = atomList.get(i);
+			if (a.getType().equals(SUFFIX_TYPE_VAL)){
+				continue;
+			}
+			if (a.getElement() != ChemEl.C){
+				continue;
+			}
+			if (ValencyChecker.checkValencyAvailableForBond(a, 1)){
+				return a;
+			}
+		}
+		return null;
+	}
+
+
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/FunctionalAtom.java

@@ -0,0 +1,20 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+/**
+ * Struct for a FunctionalAtom. As expected holds the atom.
+ * This is used to indicate, for example, that this atom may form an ester
+ * 
+ * @author dl387
+ *
+ */
+class FunctionalAtom {
+	private final Atom atom;
+
+	FunctionalAtom(Atom atom) {
+		this.atom = atom;
+	}
+
+	Atom getAtom() {
+		return atom;
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/FunctionalReplacement.java

@@ -0,0 +1,1176 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import static uk.ac.cam.ch.wwmm.opsin.XmlDeclarations.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+/**
+ * Methods for performing functional replacement
+ * @author dl387
+ *
+ */
+class FunctionalReplacement {
+
+	/**
+	 * Sorts infix transformations by the number of acceptable inputs for the transformation.
+	 * e.g. thio ends up towards the end of the list as it accepts both -O or =O whilst say imido only accepts =O
+	 * @author dl387
+	 *
+	 */
+	private static class SortInfixTransformations implements Comparator<String> {
+		public int compare(String infixTransformation1, String infixTransformation2) {
+			int allowedInputs1 = infixTransformation1.split(",").length;
+			int allowedInputs2 = infixTransformation2.split(",").length;
+			if (allowedInputs1 < allowedInputs2){//infixTransformation1 preferred
+				return -1;
+			}
+			if (allowedInputs1 > allowedInputs2){//infixTransformation2 preferred
+				return 1;
+			}
+			else{
+				return 0;
+			}
+		}
+	}
+	private static enum PREFIX_REPLACEMENT_TYPE{
+		chalcogen,//ambiguous
+		halideOrPseudoHalide,//only mean functional replacement when applied to non carboxylic acids
+		dedicatedFunctionalReplacementPrefix,//no ambiguity exists
+		hydrazono,//ambiguous, only applies to non carboxylic acid
+		peroxy//ambiguous, also applies to etheric oxygen
+	}	
+
+	static final Pattern matchChalcogenReplacement= Pattern.compile("thio|seleno|telluro");
+	
+	private final BuildState state;
+
+	FunctionalReplacement(BuildState state) {
+		this.state = state;
+	}
+
+	/**
+	 * Applies the effects of acid replacing functional class nomenclature
+	 * This must be performed early so that prefix/infix functional replacement is performed correctly
+	 * and so that element symbol locants are assigned appropriately
+	 * @param finalSubOrRootInWord
+	 * @param word
+	 * @throws ComponentGenerationException 
+	 * @throws StructureBuildingException 
+	 */
+	void processAcidReplacingFunctionalClassNomenclature(Element finalSubOrRootInWord, Element word) throws ComponentGenerationException, StructureBuildingException {
+		Element wordRule = OpsinTools.getParentWordRule(word);
+		if (WordRule.valueOf(wordRule.getAttributeValue(WORDRULE_ATR)) == WordRule.acidReplacingFunctionalGroup){
+			Element parentWordRule = word.getParent();
+			if (parentWordRule.indexOf(word)==0){
+				for (int i = 1, l = parentWordRule.getChildCount(); i < l ; i++) {
+					Element acidReplacingWord = parentWordRule.getChild(i);
+					if (!acidReplacingWord.getName().equals(WORD_EL)) {
+						throw new RuntimeException("OPSIN bug: problem with acidReplacingFunctionalGroup word rule");
+					}
+					String type = acidReplacingWord.getAttributeValue(TYPE_ATR);
+					if (type.equals(WordType.full.toString())) {
+						//case where functionalTerm is substituted
+						//as words are processed from right to left in cases like phosphoric acid tri(ethylamide) this will be phosphoric acid ethylamide ethylamide ethylamide
+						processAcidReplacingFunctionalClassNomenclatureFullWord(finalSubOrRootInWord, acidReplacingWord);
+					}
+					else if (type.equals(WordType.functionalTerm.toString())) {
+						processAcidReplacingFunctionalClassNomenclatureFunctionalWord(finalSubOrRootInWord, acidReplacingWord);
+					}
+					else {
+						throw new RuntimeException("OPSIN bug: problem with acidReplacingFunctionalGroup word rule");
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Performs prefix functional replacement e.g. thio in thioacetic acid replaces an O with S
+	 * Prefixes will present themselves as substituents. There is potential ambiguity between usage as a substituent
+	 * and as a functional replacement term in some cases. If the substituent is deemed to indicate functional replacement
+	 * it will be detached and its effects applied to the subsequent group
+	 * 
+	 * The list of groups and substituents given to this method will be mutated in the process.
+	 * 
+	 * For heterocyclic rings functional replacement should technically be limited to :
+	 * pyran, morpholine, chromene, isochromene and xanthene, chromane and isochromane.
+	 * but this is not currently enforced
+	 * @param groups
+	 * @param substituents
+	 * @return boolean: has any functional replacement occurred
+	 * @throws StructureBuildingException
+	 * @throws ComponentGenerationException 
+	 */
+	boolean processPrefixFunctionalReplacementNomenclature(List<Element> groups, List<Element> substituents) throws StructureBuildingException, ComponentGenerationException {
+		int originalNumberOfGroups = groups.size();
+		for (int i = originalNumberOfGroups-1; i >=0; i--) {
+			Element group =groups.get(i);
+			String groupValue = group.getValue();
+			PREFIX_REPLACEMENT_TYPE replacementType = null;
+			if (matchChalcogenReplacement.matcher(groupValue).matches() && !isChalcogenSubstituent(group) || groupValue.equals("thiono")){
+				replacementType =PREFIX_REPLACEMENT_TYPE.chalcogen;
+			}
+			else if (HALIDEORPSEUDOHALIDE_SUBTYPE_VAL.equals(group.getAttributeValue(SUBTYPE_ATR))){
+				replacementType =PREFIX_REPLACEMENT_TYPE.halideOrPseudoHalide;
+			}
+			else if (DEDICATEDFUNCTIONALREPLACEMENTPREFIX_SUBTYPE_VAL.equals(group.getAttributeValue(SUBTYPE_ATR))){
+				replacementType =PREFIX_REPLACEMENT_TYPE.dedicatedFunctionalReplacementPrefix;
+			}
+			else if (groupValue.equals("hydrazono")){
+				replacementType =PREFIX_REPLACEMENT_TYPE.hydrazono;
+			}
+			else if (groupValue.equals("peroxy")){
+				replacementType =PREFIX_REPLACEMENT_TYPE.peroxy;
+			}
+			if (replacementType != null) {
+				//need to check whether this is an instance of functional replacement by checking the substituent/root it is applying to
+				Element substituent = group.getParent();
+				Element nextSubOrBracket = OpsinTools.getNextSibling(substituent);
+				if (nextSubOrBracket!=null && (nextSubOrBracket.getName().equals(ROOT_EL) || nextSubOrBracket.getName().equals(SUBSTITUENT_EL))){
+					Element groupToBeModified = nextSubOrBracket.getFirstChildElement(GROUP_EL);
+					if (groupPrecededByElementThatBlocksPrefixReplacementInterpetation(groupToBeModified)) {
+						if (replacementType == PREFIX_REPLACEMENT_TYPE.dedicatedFunctionalReplacementPrefix){
+							throw new ComponentGenerationException("dedicated Functional Replacement Prefix used in an inappropriate position :" + groupValue);
+						}
+						continue;//not 2,2'-thiodipyran
+					}
+					Element locantEl = null;//null unless a locant that agrees with the multiplier is present
+					Element multiplierEl = null;
+					int numberOfAtomsToReplace = 1;//the number of atoms to be functionally replaced, modified by a multiplier e.g. dithio
+					Element possibleMultiplier = OpsinTools.getPreviousSibling(group);
+					if (possibleMultiplier != null) {
+						Element possibleLocant;
+						if (possibleMultiplier.getName().equals(MULTIPLIER_EL)) {
+							numberOfAtomsToReplace = Integer.valueOf(possibleMultiplier.getAttributeValue(VALUE_ATR));
+							possibleLocant = OpsinTools.getPreviousSibling(possibleMultiplier);
+							multiplierEl = possibleMultiplier;
+						}
+						else{
+							possibleLocant = possibleMultiplier;
+						}
+						if (possibleLocant !=null && possibleLocant.getName().equals(LOCANT_EL) && possibleLocant.getAttribute(TYPE_ATR) == null) {
+							int numberOfLocants = possibleLocant.getValue().split(",").length;
+							if (numberOfLocants == numberOfAtomsToReplace){//locants and number of replacements agree
+								locantEl = possibleLocant;
+							}
+							else if (numberOfAtomsToReplace > 1) {//doesn't look like prefix functional replacement
+								if (replacementType  == PREFIX_REPLACEMENT_TYPE.dedicatedFunctionalReplacementPrefix){
+									throw new ComponentGenerationException("dedicated Functional Replacement Prefix used in an inappropriate position :" + groupValue);
+								}
+								continue;
+							}
+						}
+					}
+
+					int oxygenReplaced;
+					if (replacementType == PREFIX_REPLACEMENT_TYPE.chalcogen) {
+						oxygenReplaced = performChalcogenFunctionalReplacement(groupToBeModified, locantEl, numberOfAtomsToReplace, group.getAttributeValue(VALUE_ATR));
+					}
+					else if (replacementType == PREFIX_REPLACEMENT_TYPE.peroxy) {
+						if (nextSubOrBracket.getName().equals(SUBSTITUENT_EL)) {
+							continue;
+						}
+						oxygenReplaced = performPeroxyFunctionalReplacement(groupToBeModified, locantEl, numberOfAtomsToReplace);
+					}
+					else if (replacementType == PREFIX_REPLACEMENT_TYPE.dedicatedFunctionalReplacementPrefix){
+						if (!groupToBeModified.getAttributeValue(TYPE_ATR).equals(NONCARBOXYLICACID_TYPE_VAL)
+								&& !(groupToBeModified.getValue().equals("form") && groupValue.equals("imido"))){
+							throw new ComponentGenerationException("dedicated Functional Replacement Prefix used in an inappropriate position :" + groupValue);
+						}
+						oxygenReplaced = performFunctionalReplacementOnAcid(groupToBeModified, locantEl, numberOfAtomsToReplace, group.getAttributeValue(VALUE_ATR));
+						if (oxygenReplaced==0){
+							throw new ComponentGenerationException("dedicated Functional Replacement Prefix used in an inappropriate position :" + groupValue);
+						}
+					}
+					else if (replacementType == PREFIX_REPLACEMENT_TYPE.hydrazono || replacementType == PREFIX_REPLACEMENT_TYPE.halideOrPseudoHalide){
+						Fragment acidFrag = groupToBeModified.getFrag();
+						if (!groupToBeModified.getAttributeValue(TYPE_ATR).equals(NONCARBOXYLICACID_TYPE_VAL) ||
+								acidHasSufficientHydrogenForSubstitutionInterpretation(acidFrag, group.getFrag().getOutAtom(0).getValency(), locantEl)){
+							//hydrazono replacement only applies to non carboxylic acids e.g. hydrazonooxalic acid
+							//need to be careful to note that something like chlorophosphonic acid isn't functional replacement
+							continue;
+						}
+						oxygenReplaced = performFunctionalReplacementOnAcid(groupToBeModified, locantEl, numberOfAtomsToReplace, group.getAttributeValue(VALUE_ATR));
+					}
+					else{
+						throw new StructureBuildingException("OPSIN bug: Unexpected prefix replacement type");
+					}
+					if (oxygenReplaced>0){
+						state.fragManager.removeFragment(group.getFrag());
+						substituent.removeChild(group);
+						groups.remove(group);
+						List<Element> remainingChildren =substituent.getChildElements();//there may be a locant that should be moved
+						for (int j = remainingChildren.size()-1; j>=0; j--){
+							Element child =substituent.getChild(j);
+							child.detach();
+							nextSubOrBracket.insertChild(child, 0);
+						}
+						substituents.remove(substituent);
+						substituent.detach();
+						if (oxygenReplaced>1){
+							multiplierEl.detach();
+						}
+					}
+				}
+				else if (replacementType  == PREFIX_REPLACEMENT_TYPE.dedicatedFunctionalReplacementPrefix){
+					throw new ComponentGenerationException("dedicated Functional Replacement Prefix used in an inappropriate position :" + groupValue);
+				}
+			}
+		}
+		return groups.size() != originalNumberOfGroups;
+	}
+	
+	private boolean isChalcogenSubstituent(Element group) {
+		//Is this group followed by a hyphen and directly preceded by a substituent i.e. no multiplier/locant
+		//e.g. methylthio-
+		Element next = OpsinTools.getNextSibling(group);
+		if (next != null && next.getName().equals(HYPHEN_EL) &&
+				OpsinTools.getPreviousSibling(group) == null) {
+			Element previousGroup = OpsinTools.getPreviousGroup(group);
+			if (previousGroup != null) {
+				//TODO We actually want to know if a carbon atom is the attachment point... but we don't know the attachment point locations at this point
+				Element suffix = OpsinTools.getNextSibling(previousGroup, SUFFIX_EL);
+				if (suffix == null || suffix.getFrag() == null) {
+					for (Atom a : previousGroup.getFrag()) {
+						if (a.getElement() == ChemEl.C) {
+							return true;
+						}
+					}
+				}
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Currently prefix replacement terms must be directly adjacent to the groupToBeModified with an exception made
+	 * for carbohydrate stereochemistry prefixes e.g. 'gluco' and for substractive prefixes e.g. 'deoxy'
+	 * @param groupToBeModified
+	 * @return
+	 */
+	private boolean groupPrecededByElementThatBlocksPrefixReplacementInterpetation(Element groupToBeModified) {
+		Element previous = OpsinTools.getPreviousSibling(groupToBeModified);
+		while (previous !=null && (previous.getName().equals(SUBTRACTIVEPREFIX_EL)
+				|| (previous.getName().equals(STEREOCHEMISTRY_EL) && previous.getAttributeValue(TYPE_ATR).equals(CARBOHYDRATECONFIGURATIONPREFIX_TYPE_VAL)))){
+			previous = OpsinTools.getPreviousSibling(previous);
+		}
+		return previous != null;
+	}
+	
+	
+	/*
+	 * 
+	 */
+	
+	/**
+	 * Performs functional replacement using infixes e.g. thio in ethanthioic acid replaces an O with S
+	 * @param suffixFragments May be modified if a multiplier is determined to mean multiplication of a suffix, usually untouched
+	 * @param suffixes The suffix elements  May be modified if a multiplier is determined to mean multiplication of a suffix, usually untouched
+	 * @throws StructureBuildingException
+	 * @throws ComponentGenerationException
+	 */
+	void processInfixFunctionalReplacementNomenclature(List<Element> suffixes, List<Fragment> suffixFragments) throws StructureBuildingException, ComponentGenerationException {
+		for (int i = 0; i < suffixes.size(); i++) {
+			Element suffix = suffixes.get(i);
+			if (suffix.getAttribute(INFIX_ATR) != null){
+				Fragment fragToApplyInfixTo = suffix.getFrag();
+				Element possibleAcidGroup = OpsinTools.getPreviousSiblingIgnoringCertainElements(suffix, new String[]{MULTIPLIER_EL, INFIX_EL, SUFFIX_EL});
+				if (possibleAcidGroup !=null && possibleAcidGroup.getName().equals(GROUP_EL) && 
+						(possibleAcidGroup.getAttributeValue(TYPE_ATR).equals(NONCARBOXYLICACID_TYPE_VAL)|| possibleAcidGroup.getAttributeValue(TYPE_ATR).equals(CHALCOGENACIDSTEM_TYPE_VAL))){
+					fragToApplyInfixTo = possibleAcidGroup.getFrag();
+				}
+				if (fragToApplyInfixTo ==null){
+					throw new ComponentGenerationException("infix has erroneously been assigned to a suffix which does not correspond to a suffix fragment. suffix: " + suffix.getValue());
+				}
+				//e.g. =O:S,-O:S (which indicates replacing either a double or single bonded oxygen with S)
+				//This is semicolon delimited for each infix
+				List<String> infixTransformations = StringTools.arrayToList(suffix.getAttributeValue(INFIX_ATR).split(";"));
+
+				List<Atom> atomList =fragToApplyInfixTo.getAtomList();
+				LinkedList<Atom> singleBondedOxygen = new LinkedList<>();
+				LinkedList<Atom> doubleBondedOxygen = new LinkedList<>();
+				populateTerminalSingleAndDoubleBondedOxygen(atomList, singleBondedOxygen, doubleBondedOxygen);
+				int oxygenAvailable = singleBondedOxygen.size() +doubleBondedOxygen.size();
+
+				/*
+				 * Modifies suffixes, suffixFragments, suffix and infixTransformations as appropriate
+				 */
+				disambiguateMultipliedInfixMeaning(suffixes, suffixFragments, suffix, infixTransformations, oxygenAvailable);
+
+				/*
+				 * Sort infixTransformations so more specific transformations are performed first
+				 * e.g. ethanthioimidic acid-->ethanimidthioic acid as imid can only apply to the double bonded oxygen
+				 */
+				Collections.sort(infixTransformations, new SortInfixTransformations());
+
+				for (String infixTransformation : infixTransformations) {
+					String[] transformationArray = infixTransformation.split(":");
+					if (transformationArray.length !=2){
+						throw new StructureBuildingException("Atom to be replaced and replacement not specified correctly in infix: " + infixTransformation);
+					}
+					String[] transformations = transformationArray[0].split(",");
+					String replacementSMILES = transformationArray[1];
+					boolean acceptDoubleBondedOxygen = false;
+					boolean acceptSingleBondedOxygen = false;
+					boolean nitrido =false;
+					for (String transformation : transformations) {
+						if (transformation.startsWith("=")){
+							acceptDoubleBondedOxygen = true;
+						}
+						else if (transformation.startsWith("-")){
+							acceptSingleBondedOxygen = true;
+						}
+						else if (transformation.startsWith("#")){
+							nitrido =true;
+						}
+						else{
+							throw new StructureBuildingException("Malformed infix transformation. Expected to start with either - or =. Transformation was: " +transformation);
+						}
+						if (transformation.length()<2 || transformation.charAt(1)!='O'){
+							throw new StructureBuildingException("Only replacement by oxygen is supported. Check infix defintions");
+						}
+					}
+					boolean infixAssignmentAmbiguous =false;
+					if ((acceptSingleBondedOxygen ||nitrido)  && !acceptDoubleBondedOxygen){
+						if (singleBondedOxygen.size() ==0){
+							throw new StructureBuildingException("Cannot find single bonded oxygen for infix with SMILES: "+ replacementSMILES+ " to modify!");
+						}
+						if (singleBondedOxygen.size() !=1){
+							infixAssignmentAmbiguous=true;
+						}
+					}
+					if (!acceptSingleBondedOxygen && (acceptDoubleBondedOxygen || nitrido)){
+						if (doubleBondedOxygen.size()==0){
+							throw new StructureBuildingException("Cannot find double bonded oxygen for infix with SMILES: "+ replacementSMILES+ " to modify!");
+						}
+						if (doubleBondedOxygen.size() != 1){
+							infixAssignmentAmbiguous=true;
+						}
+					}
+					if (acceptSingleBondedOxygen && acceptDoubleBondedOxygen){
+						if (oxygenAvailable ==0){
+							throw new StructureBuildingException("Cannot find oxygen for infix with SMILES: "+ replacementSMILES+ " to modify!");
+						}
+						if (oxygenAvailable !=1){
+							infixAssignmentAmbiguous=true;
+						}
+					}
+
+					Set<Atom> ambiguousElementAtoms = new LinkedHashSet<>();
+					Atom atomToUse = null;
+					if ((acceptDoubleBondedOxygen || nitrido) && doubleBondedOxygen.size()>0 ){
+						atomToUse = doubleBondedOxygen.removeFirst();
+					}
+					else if (acceptSingleBondedOxygen && singleBondedOxygen.size()>0 ){
+						atomToUse = singleBondedOxygen.removeFirst();
+					}
+					else{
+						throw new StructureBuildingException("Cannot find oxygen for infix with SMILES: "+ replacementSMILES+ " to modify!");//this would be a bug
+					}
+					Fragment replacementFrag = state.fragManager.buildSMILES(replacementSMILES, SUFFIX_TYPE_VAL, NONE_LABELS_VAL);
+					if (replacementFrag.getOutAtomCount()>0){//SMILES include an indication of the bond order the replacement fragment will have, this is not intended to be an outatom
+						replacementFrag.removeOutAtom(0);
+					}
+					Atom atomThatWillReplaceOxygen =replacementFrag.getFirstAtom();
+					if (replacementFrag.getAtomCount()==1 && atomThatWillReplaceOxygen.getElement().isChalcogen()){
+						atomThatWillReplaceOxygen.setCharge(atomToUse.getCharge());
+						atomThatWillReplaceOxygen.setProtonsExplicitlyAddedOrRemoved(atomToUse.getProtonsExplicitlyAddedOrRemoved());
+					}
+					removeOrMoveObsoleteFunctionalAtoms(atomToUse, replacementFrag);//also will move charge if necessary
+					moveObsoleteOutAtoms(atomToUse, replacementFrag);//if the replaced atom was an outatom the fragments outatom list need to be corrected
+					if (nitrido){
+						atomToUse.getFirstBond().setOrder(3);
+						Atom removedHydroxy = singleBondedOxygen.removeFirst();
+						state.fragManager.removeAtomAndAssociatedBonds(removedHydroxy);
+						removeAssociatedFunctionalAtom(removedHydroxy);
+					}
+					state.fragManager.incorporateFragment(replacementFrag, atomToUse.getFrag());
+					state.fragManager.replaceAtomWithAnotherAtomPreservingConnectivity(atomToUse, atomThatWillReplaceOxygen);
+					if (infixAssignmentAmbiguous){
+						ambiguousElementAtoms.add(atomThatWillReplaceOxygen);
+						if (atomThatWillReplaceOxygen.getProperty(Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT)!=null){
+							ambiguousElementAtoms.addAll(atomThatWillReplaceOxygen.getProperty(Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT));
+						}
+					}
+					if (infixAssignmentAmbiguous){//record what atoms could have been replaced. Often this ambiguity is resolved later e.g. S-methyl ethanthioate
+						for (Atom a : doubleBondedOxygen) {
+							ambiguousElementAtoms.add(a);
+							if (a.getProperty(Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT)!=null){
+								ambiguousElementAtoms.addAll(a.getProperty(Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT));
+							}
+						}
+						for (Atom a : singleBondedOxygen) {
+							ambiguousElementAtoms.add(a);
+							if (a.getProperty(Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT)!=null){
+								ambiguousElementAtoms.addAll(a.getProperty(Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT));
+							}
+						}
+						for (Atom atom : ambiguousElementAtoms) {
+							atom.setProperty(Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT, ambiguousElementAtoms);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	/*
+	 * Functional class nomenclature
+	 */
+	
+	/**
+	 * Replaces the appropriate number of functional oxygen atoms with the corresponding fragment
+	 * @param acidContainingRoot
+	 * @param acidReplacingWord
+	 * @throws ComponentGenerationException
+	 * @throws StructureBuildingException
+	 */
+	private void processAcidReplacingFunctionalClassNomenclatureFullWord(Element acidContainingRoot, Element acidReplacingWord) throws ComponentGenerationException, StructureBuildingException {
+		String locant = acidReplacingWord.getAttributeValue(LOCANT_ATR);
+		Element acidReplacingGroup = StructureBuildingMethods.findRightMostGroupInBracket(acidReplacingWord);
+		if (acidReplacingGroup ==null){
+			throw new ComponentGenerationException("OPSIN bug: acid replacing group not found where one was expected for acidReplacingFunctionalGroup wordRule");
+		}
+		String functionalGroupName = acidReplacingGroup.getValue();
+		Fragment acidReplacingFrag = acidReplacingGroup.getFrag();
+		if (acidReplacingGroup.getParent().getChildCount() != 1){
+			throw new ComponentGenerationException("Unexpected qualifier to: " + functionalGroupName);
+		}
+		
+		Element groupToBeModified = acidContainingRoot.getFirstChildElement(GROUP_EL);
+		List<Atom> oxygenAtoms = findFunctionalOxygenAtomsInApplicableSuffixes(groupToBeModified);
+		if (oxygenAtoms.size() == 0){
+			oxygenAtoms = findFunctionalOxygenAtomsInGroup(groupToBeModified);
+		}
+		if (oxygenAtoms.size() == 0){
+			List<Element> conjunctiveSuffixElements =OpsinTools.getNextSiblingsOfType(groupToBeModified, CONJUNCTIVESUFFIXGROUP_EL);
+			for (Element conjunctiveSuffixElement : conjunctiveSuffixElements) {
+				oxygenAtoms.addAll(findFunctionalOxygenAtomsInGroup(conjunctiveSuffixElement));
+			}
+		}
+		if (oxygenAtoms.size() < 1){
+			throw new ComponentGenerationException("Insufficient oxygen to replace with " + functionalGroupName +"s in " + acidContainingRoot.getFirstChildElement(GROUP_EL).getValue());
+		}
+		
+		boolean isAmide = functionalGroupName.equals("amide") || functionalGroupName.equals("amid");
+		if (isAmide) {
+			if (acidReplacingFrag.getAtomCount()!=1){
+				throw new ComponentGenerationException("OPSIN bug: " + functionalGroupName + " not found where expected");
+			}
+			Atom amideNitrogen = acidReplacingFrag.getFirstAtom();
+			amideNitrogen.neutraliseCharge();
+			amideNitrogen.clearLocants();
+			acidReplacingFrag.addMappingToAtomLocantMap("N", amideNitrogen);
+		}
+		Atom chosenOxygen = locant != null ? removeOxygenWithAppropriateLocant(oxygenAtoms, locant) : oxygenAtoms.get(0);
+		state.fragManager.replaceAtomWithAnotherAtomPreservingConnectivity(chosenOxygen, acidReplacingFrag.getFirstAtom());
+		removeAssociatedFunctionalAtom(chosenOxygen);
+	}
+	
+
+	/**
+	 * Replaces the appropriate number of functional oxygen atoms with the corresponding fragment
+	 * @param acidContainingRoot
+	 * @param functionalWord
+	 * @throws ComponentGenerationException
+	 * @throws StructureBuildingException
+	 */
+	private void processAcidReplacingFunctionalClassNomenclatureFunctionalWord(Element acidContainingRoot, Element functionalWord) throws ComponentGenerationException, StructureBuildingException {
+		if (functionalWord !=null && functionalWord.getAttributeValue(TYPE_ATR).equals(WordType.functionalTerm.toString())){
+			Element functionalTerm = functionalWord.getFirstChildElement(FUNCTIONALTERM_EL);
+			if (functionalTerm ==null){
+				throw new ComponentGenerationException("OPSIN bug: functionalTerm word not found where one was expected for acidReplacingFunctionalGroup wordRule");
+			}
+			Element acidReplacingGroup = functionalTerm.getFirstChildElement(FUNCTIONALGROUP_EL);
+			String functionalGroupName = acidReplacingGroup.getValue();
+			Element possibleLocantOrMultiplier = OpsinTools.getPreviousSibling(acidReplacingGroup);
+			int numberOfAcidicHydroxysToReplace = 1;
+			String[] locants = null;
+			if (possibleLocantOrMultiplier != null){
+				if (possibleLocantOrMultiplier.getName().equals(MULTIPLIER_EL)){
+					numberOfAcidicHydroxysToReplace = Integer.parseInt(possibleLocantOrMultiplier.getAttributeValue(VALUE_ATR));
+					possibleLocantOrMultiplier.detach();
+					possibleLocantOrMultiplier = OpsinTools.getPreviousSibling(acidReplacingGroup);
+				}
+				if (possibleLocantOrMultiplier != null){
+					if (possibleLocantOrMultiplier.getName().equals(LOCANT_EL)){
+						locants = StringTools.removeDashIfPresent(possibleLocantOrMultiplier.getValue()).split(",");
+						possibleLocantOrMultiplier.detach();
+					}
+					else {
+						throw new ComponentGenerationException("Unexpected qualifier to acidReplacingFunctionalGroup functionalTerm");
+					}
+				}
+			}
+			if (functionalTerm.getChildCount() != 1){
+				throw new ComponentGenerationException("Unexpected qualifier to acidReplacingFunctionalGroup functionalTerm");
+			}
+			
+			Element groupToBeModified = acidContainingRoot.getFirstChildElement(GROUP_EL);
+			List<Atom> oxygenAtoms = findFunctionalOxygenAtomsInApplicableSuffixes(groupToBeModified);
+			if (oxygenAtoms.size()==0) {
+				oxygenAtoms = findFunctionalOxygenAtomsInGroup(groupToBeModified);
+			}
+			if (oxygenAtoms.size()==0) {
+				List<Element> conjunctiveSuffixElements =OpsinTools.getNextSiblingsOfType(groupToBeModified, CONJUNCTIVESUFFIXGROUP_EL);
+				for (Element conjunctiveSuffixElement : conjunctiveSuffixElements) {
+					oxygenAtoms.addAll(findFunctionalOxygenAtomsInGroup(conjunctiveSuffixElement));
+				}
+			}
+			if (numberOfAcidicHydroxysToReplace > oxygenAtoms.size()){
+				throw new ComponentGenerationException("Insufficient oxygen to replace with nitrogen in " + acidContainingRoot.getFirstChildElement(GROUP_EL).getValue());
+			}
+			boolean isAmide = functionalGroupName.equals("amide") || functionalGroupName.equals("amid");
+			if (isAmide) {
+				for (int i = 0; i < numberOfAcidicHydroxysToReplace; i++) {
+					Atom functionalOxygenToReplace = locants != null ? removeOxygenWithAppropriateLocant(oxygenAtoms, locants[i]) : oxygenAtoms.get(i);
+					removeAssociatedFunctionalAtom(functionalOxygenToReplace);
+					functionalOxygenToReplace.setElement(ChemEl.N);
+				}
+			}
+			else{
+				String groupValue = acidReplacingGroup.getAttributeValue(VALUE_ATR);
+				String labelsValue = acidReplacingGroup.getAttributeValue(LABELS_ATR);
+				Fragment acidReplacingFrag = state.fragManager.buildSMILES(groupValue, SUFFIX_TYPE_VAL, labelsValue != null ? labelsValue : NONE_LABELS_VAL);
+				Fragment acidFragment = groupToBeModified.getFrag();
+				if (acidFragment.hasLocant("2")){//prefer numeric locants on group to those of replacing group
+					for (Atom atom : acidReplacingFrag.getAtomList()) {
+						atom.clearLocants();
+					}
+				}
+				Atom firstFunctionalOxygenToReplace = locants != null ? removeOxygenWithAppropriateLocant(oxygenAtoms, locants[0]) : oxygenAtoms.get(0);
+				state.fragManager.replaceAtomWithAnotherAtomPreservingConnectivity(firstFunctionalOxygenToReplace, acidReplacingFrag.getFirstAtom());
+				removeAssociatedFunctionalAtom(firstFunctionalOxygenToReplace);
+				for (int i = 1; i < numberOfAcidicHydroxysToReplace; i++) {
+					Fragment clonedHydrazide = state.fragManager.copyAndRelabelFragment(acidReplacingFrag, i);
+					Atom functionalOxygenToReplace = locants != null ? removeOxygenWithAppropriateLocant(oxygenAtoms, locants[i]) : oxygenAtoms.get(i);
+					state.fragManager.replaceAtomWithAnotherAtomPreservingConnectivity(functionalOxygenToReplace, clonedHydrazide.getFirstAtom());
+					state.fragManager.incorporateFragment(clonedHydrazide, functionalOxygenToReplace.getFrag());
+					removeAssociatedFunctionalAtom(functionalOxygenToReplace);
+				}
+				state.fragManager.incorporateFragment(acidReplacingFrag, firstFunctionalOxygenToReplace.getFrag());
+			}
+		}
+		else{
+			throw new ComponentGenerationException("amide word not found where expected, bug?");
+		}
+	}
+	
+	private Atom removeOxygenWithAppropriateLocant(List<Atom> oxygenAtoms, String locant) throws ComponentGenerationException {
+		for (Iterator<Atom> iterator = oxygenAtoms.iterator(); iterator.hasNext();) {
+			Atom atom = iterator.next();
+			if (atom.hasLocant(locant)) {
+				iterator.remove();
+				return atom;
+			}	
+		}
+		//Look for the case whether the locant refers to the backbone
+		for (Iterator<Atom> iterator = oxygenAtoms.iterator(); iterator.hasNext();) {
+			Atom atom = iterator.next();
+			if (OpsinTools.depthFirstSearchForNonSuffixAtomWithLocant(atom, locant) != null){
+				iterator.remove();
+				return atom;
+			}	
+		}
+		throw new ComponentGenerationException("Failed to find acid group at locant: " + locant);
+	}
+	
+
+	/*
+	 * Prefix functional replacement nomenclature
+	 */
+
+	
+	private boolean acidHasSufficientHydrogenForSubstitutionInterpretation(Fragment acidFrag, int hydrogenRequiredForSubstitutionInterpretation, Element locantEl) {
+		List<Atom> atomsThatWouldBeSubstituted = new ArrayList<>();
+		if (locantEl !=null){
+			String[] possibleLocants = locantEl.getValue().split(",");
+			for (String locant : possibleLocants) {
+				Atom atomToBeSubstituted = acidFrag.getAtomByLocant(locant);
+				if (atomToBeSubstituted !=null){
+					atomsThatWouldBeSubstituted.add(atomToBeSubstituted);
+				}
+				else{
+					atomsThatWouldBeSubstituted.clear();
+					atomsThatWouldBeSubstituted.add(acidFrag.getDefaultInAtomOrFirstAtom());
+					break;
+				}
+			}
+		}
+		else{
+			atomsThatWouldBeSubstituted.add(acidFrag.getDefaultInAtomOrFirstAtom());
+		}
+		for (Atom atom : atomsThatWouldBeSubstituted) {
+			if (StructureBuildingMethods.calculateSubstitutableHydrogenAtoms(atom) < hydrogenRequiredForSubstitutionInterpretation){
+				return false;//insufficient hydrogens for substitution interpretation
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Performs replacement of oxygen atoms by chalogen atoms
+	 * If this is ambiguous e.g. thioacetate then Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT is populated
+	 * @param groupToBeModified
+	 * @param locantEl
+	 * @param numberOfAtomsToReplace
+	 * @param replacementSmiles
+	 * @return
+	 * @throws StructureBuildingException
+	 */
+	private int performChalcogenFunctionalReplacement(Element groupToBeModified, Element locantEl, int numberOfAtomsToReplace, String replacementSmiles) throws StructureBuildingException {
+		List<Atom> oxygenAtoms = findOxygenAtomsInApplicableSuffixes(groupToBeModified);
+		if (oxygenAtoms.size() == 0) {
+			oxygenAtoms = findOxygenAtomsInGroup(groupToBeModified);
+		}
+		if (locantEl != null) {//locants are used to indicate replacement on trivial groups
+			List<Atom> oxygenWithAppropriateLocants = pickOxygensWithAppropriateLocants(locantEl, oxygenAtoms);
+			if(oxygenWithAppropriateLocants.size() < numberOfAtomsToReplace) {
+				numberOfAtomsToReplace = 1;
+				//e.g. -1-thioureidomethyl
+			}
+			else{
+				locantEl.detach();
+				oxygenAtoms = oxygenWithAppropriateLocants;
+			}
+		}
+		List<Atom> replaceableAtoms = new ArrayList<>();
+		if (replacementSmiles.startsWith("=")) {
+			//e.g. thiono
+			replacementSmiles = replacementSmiles.substring(1);
+			for (Atom oxygen : oxygenAtoms) {
+				int incomingValency = oxygen.getIncomingValency();
+				int bondCount = oxygen.getBondCount();
+				if (bondCount == 1 && incomingValency == 2) {
+					replaceableAtoms.add(oxygen);
+				}
+			}
+		}
+		else {
+			List<Atom> doubleBondedOxygen = new ArrayList<>();
+			List<Atom> singleBondedOxygen = new ArrayList<>();
+			List<Atom> ethericOxygen = new ArrayList<>();
+			for (Atom oxygen : oxygenAtoms) {
+				int incomingValency = oxygen.getIncomingValency();
+				int bondCount = oxygen.getBondCount();
+				if (bondCount == 1 && incomingValency ==2 ) {
+					doubleBondedOxygen.add(oxygen);
+				}
+				else if (bondCount == 1 && incomingValency == 1) {
+					singleBondedOxygen.add(oxygen);
+				}
+				else if (bondCount == 2 && incomingValency == 2) {
+					ethericOxygen.add(oxygen);
+				}
+			}
+			replaceableAtoms.addAll(doubleBondedOxygen);
+			replaceableAtoms.addAll(singleBondedOxygen);
+			replaceableAtoms.addAll(ethericOxygen);
+		}
+
+		int totalOxygen = replaceableAtoms.size();
+		if (numberOfAtomsToReplace >1){
+			if (totalOxygen < numberOfAtomsToReplace){
+				numberOfAtomsToReplace=1;
+			}
+		}
+
+		int atomsReplaced =0;
+		if (totalOxygen >=numberOfAtomsToReplace){//check that there atleast as many oxygens as requested replacements
+			boolean prefixAssignmentAmbiguous =false;
+			Set<Atom> ambiguousElementAtoms = new LinkedHashSet<>();
+			if (totalOxygen != numberOfAtomsToReplace){
+				prefixAssignmentAmbiguous=true;
+			}
+
+			for (Atom atomToReplace : replaceableAtoms) {
+				if (atomsReplaced == numberOfAtomsToReplace){
+					ambiguousElementAtoms.add(atomToReplace);
+					continue;
+				}
+				else{
+					state.fragManager.replaceAtomWithSmiles(atomToReplace, replacementSmiles);
+					if (prefixAssignmentAmbiguous){
+						ambiguousElementAtoms.add(atomToReplace);
+					}
+				}
+				atomsReplaced++;
+			}
+
+			if (prefixAssignmentAmbiguous){//record what atoms could have been replaced. Often this ambiguity is resolved later e.g. S-methyl thioacetate
+				for (Atom atom : ambiguousElementAtoms) {
+					atom.setProperty(Atom.AMBIGUOUS_ELEMENT_ASSIGNMENT, ambiguousElementAtoms);
+				}
+			}
+		}
+		return atomsReplaced;
+	}
+
+
+	/**
+	 * Converts functional oxygen to peroxy e.g. peroxybenzoic acid
+	 * Returns the number of oxygen replaced
+	 * @param groupToBeModified
+	 * @param locantEl
+	 * @param numberOfAtomsToReplace
+	 * @return
+	 * @throws StructureBuildingException
+	 */
+	private int performPeroxyFunctionalReplacement(Element groupToBeModified, Element locantEl, int numberOfAtomsToReplace) throws StructureBuildingException {
+		List<Atom> oxygenAtoms = findFunctionalOxygenAtomsInApplicableSuffixes(groupToBeModified);
+		if (oxygenAtoms.size()==0){
+			oxygenAtoms = findEthericOxygenAtomsInGroup(groupToBeModified);
+			oxygenAtoms.addAll(findFunctionalOxygenAtomsInGroup(groupToBeModified));
+		}
+		if (locantEl !=null){
+			List<Atom> oxygenWithAppropriateLocants = pickOxygensWithAppropriateLocants(locantEl, oxygenAtoms);
+			if(oxygenWithAppropriateLocants.size() < numberOfAtomsToReplace){
+				numberOfAtomsToReplace =1;
+			}
+			else{
+				locantEl.detach();
+				oxygenAtoms = oxygenWithAppropriateLocants;
+			}
+		}
+		if (numberOfAtomsToReplace >1 && oxygenAtoms.size() < numberOfAtomsToReplace){
+			numberOfAtomsToReplace=1;
+		}
+		int atomsReplaced = 0;
+		if (oxygenAtoms.size() >=numberOfAtomsToReplace){//check that there atleast as many oxygens as requested replacements
+			atomsReplaced = numberOfAtomsToReplace;
+			for (int j = 0; j < numberOfAtomsToReplace; j++) {
+				Atom oxygenToReplace = oxygenAtoms.get(j);
+				if (oxygenToReplace.getBondCount()==2){//etheric oxygen
+					Fragment newOxygen = state.fragManager.buildSMILES("O", SUFFIX_TYPE_VAL, NONE_LABELS_VAL);
+					Bond bondToRemove = oxygenToReplace.getFirstBond();
+					Atom atomToAttachTo = bondToRemove.getFromAtom() == oxygenToReplace ?  bondToRemove.getToAtom() :  bondToRemove.getFromAtom();
+					state.fragManager.createBond(atomToAttachTo, newOxygen.getFirstAtom(), 1);
+					state.fragManager.createBond(newOxygen.getFirstAtom(), oxygenToReplace, 1);
+					state.fragManager.removeBond(bondToRemove);
+					state.fragManager.incorporateFragment(newOxygen, groupToBeModified.getFrag());
+				}
+				else{
+					Fragment replacementFrag = state.fragManager.buildSMILES("OO", SUFFIX_TYPE_VAL, NONE_LABELS_VAL);
+					removeOrMoveObsoleteFunctionalAtoms(oxygenToReplace, replacementFrag);
+					state.fragManager.replaceAtomWithAnotherAtomPreservingConnectivity(oxygenToReplace, replacementFrag.getFirstAtom());
+					state.fragManager.incorporateFragment(replacementFrag, groupToBeModified.getFrag());
+				}
+			}
+		}
+		return atomsReplaced;
+	}
+	
+	/**
+	 * Replaces double bonded oxygen and/or single bonded oxygen depending on the input SMILES
+	 * SMILES with a valency 1 outAtom replace -O, SMILES with a valency 2 outAtom replace =O
+	 * SMILES with a valency 3 outAtom replace -O and =O (nitrido)
+	 * Returns the number of oxygen replaced
+	 * @param groupToBeModified
+	 * @param locantEl
+	 * @param numberOfAtomsToReplace
+	 * @param replacementSmiles
+     * @return
+	 * @throws StructureBuildingException
+	 */
+	private int performFunctionalReplacementOnAcid(Element groupToBeModified, Element locantEl, int numberOfAtomsToReplace, String replacementSmiles) throws StructureBuildingException {
+		int outValency;
+		if (replacementSmiles.startsWith("-")){
+			outValency =1;
+		}
+		else if (replacementSmiles.startsWith("=")){
+			outValency =2;
+		}
+		else if (replacementSmiles.startsWith("#")){
+			outValency =3;
+		}
+		else{
+			throw new StructureBuildingException("OPSIN bug: Unexpected valency on fragment for prefix functional replacement");
+		}
+		replacementSmiles = replacementSmiles.substring(1);
+		List<Atom> oxygenAtoms = findOxygenAtomsInApplicableSuffixes(groupToBeModified);
+		if (oxygenAtoms.size()==0){
+			oxygenAtoms = findOxygenAtomsInGroup(groupToBeModified);
+		}
+		if (locantEl !=null){//locants are used to indicate replacement on trivial groups
+			List<Atom> oxygenWithAppropriateLocants = pickOxygensWithAppropriateLocants(locantEl, oxygenAtoms);
+			List<Atom> singleBondedOxygen = new ArrayList<>();
+			List<Atom> terminalDoubleBondedOxygen = new ArrayList<>();
+			populateTerminalSingleAndDoubleBondedOxygen(oxygenWithAppropriateLocants, singleBondedOxygen, terminalDoubleBondedOxygen);
+			if (outValency ==1){
+				oxygenWithAppropriateLocants.removeAll(terminalDoubleBondedOxygen);
+			}
+			else if (outValency ==2){
+				oxygenWithAppropriateLocants.removeAll(singleBondedOxygen);
+			}
+			if(oxygenWithAppropriateLocants.size() < numberOfAtomsToReplace){
+				numberOfAtomsToReplace =1;
+				//e.g. -1-thioureidomethyl
+			}
+			else{
+				locantEl.detach();
+				oxygenAtoms = oxygenWithAppropriateLocants;
+			}
+		}
+		List<Atom> singleBondedOxygen = new ArrayList<>();
+		List<Atom> terminalDoubleBondedOxygen = new ArrayList<>();
+		populateTerminalSingleAndDoubleBondedOxygen(oxygenAtoms, singleBondedOxygen, terminalDoubleBondedOxygen);
+		if (outValency ==1){
+			oxygenAtoms.removeAll(terminalDoubleBondedOxygen);
+		}
+		else if (outValency ==2){
+			oxygenAtoms.removeAll(singleBondedOxygen);
+			//favour bridging oxygen over double bonded oxygen c.f. imidodicarbonate
+			oxygenAtoms.removeAll(terminalDoubleBondedOxygen);
+			oxygenAtoms.addAll(terminalDoubleBondedOxygen);
+		}
+		else {
+			if (singleBondedOxygen.size()==0 || terminalDoubleBondedOxygen.size()==0){
+				throw new StructureBuildingException("Both a -OH and =O are required for nitrido prefix functional replacement");
+			}
+			oxygenAtoms.removeAll(singleBondedOxygen);
+		}
+		if (numberOfAtomsToReplace >1 && oxygenAtoms.size() < numberOfAtomsToReplace){
+			numberOfAtomsToReplace=1;
+		}
+
+		int atomsReplaced =0;
+		if (oxygenAtoms.size() >=numberOfAtomsToReplace){//check that there atleast as many oxygens as requested replacements
+			for (Atom atomToReplace : oxygenAtoms) {
+				if (atomsReplaced == numberOfAtomsToReplace){
+					continue;
+				}
+				else{
+					Fragment replacementFrag = state.fragManager.buildSMILES(replacementSmiles, atomToReplace.getFrag().getTokenEl(), NONE_LABELS_VAL);
+					if (outValency ==3){//special case for nitrido
+						atomToReplace.getFirstBond().setOrder(3);
+						Atom removedHydroxy = singleBondedOxygen.remove(0);
+						state.fragManager.removeAtomAndAssociatedBonds(removedHydroxy);
+						removeAssociatedFunctionalAtom(removedHydroxy);
+					}
+					state.fragManager.replaceAtomWithAnotherAtomPreservingConnectivity(atomToReplace, replacementFrag.getFirstAtom());
+					if (outValency ==1){
+						removeOrMoveObsoleteFunctionalAtoms(atomToReplace, replacementFrag);
+					}
+					moveObsoleteOutAtoms(atomToReplace, replacementFrag);
+					state.fragManager.incorporateFragment(replacementFrag, atomToReplace.getFrag());
+				}
+				atomsReplaced++;
+			}
+		}
+		return atomsReplaced;
+	}
+	
+	/*
+	 * Infix functional replacement nomenclature
+	 */
+
+	/**
+	 * This block handles infix multiplication. Unless brackets are provided this is ambiguous without knowledge of the suffix that is being modified
+	 * For example butandithione could be intepreted as butandi(thione) or butan(dithi)one.
+	 * Obviously the latter is wrong in this case but it is the correct interpretation for butandithiate
+	 * @param suffixes
+	 * @param suffixFragments
+	 * @param suffix
+	 * @param infixTransformations
+	 * @param oxygenAvailable
+	 * @throws ComponentGenerationException
+	 * @throws StructureBuildingException
+	 */
+	private void disambiguateMultipliedInfixMeaning(List<Element> suffixes,
+			List<Fragment> suffixFragments,Element suffix, List<String> infixTransformations, int oxygenAvailable)
+			throws ComponentGenerationException, StructureBuildingException {
+		Element possibleInfix = OpsinTools.getPreviousSibling(suffix);
+		if (possibleInfix.getName().equals(INFIX_EL)){//the infix is only left when there was ambiguity
+			Element possibleMultiplier = OpsinTools.getPreviousSibling(possibleInfix);
+			if (possibleMultiplier.getName().equals(MULTIPLIER_EL)){
+				int multiplierValue =Integer.parseInt(possibleMultiplier.getAttributeValue(VALUE_ATR));
+				if (infixTransformations.size() + multiplierValue-1 <=oxygenAvailable){//multiplier means multiply the infix e.g. butandithiate
+					for (int j = 1; j < multiplierValue; j++) {
+						infixTransformations.add(0, infixTransformations.get(0));
+					}
+				}
+				else{
+					Element possibleLocant = OpsinTools.getPreviousSibling(possibleMultiplier);
+					String[] locants = null;
+					if (possibleLocant.getName().equals(LOCANT_EL)) {
+						locants = possibleLocant.getValue().split(",");
+					}
+					if (locants !=null){
+						if (locants.length!=multiplierValue){
+							throw new ComponentGenerationException("Multiplier/locant disagreement when multiplying infixed suffix");
+						}
+					    suffix.addAttribute(new Attribute(LOCANT_ATR, locants[0]));
+					}
+					suffix.addAttribute(new Attribute(MULTIPLIED_ATR, "multiplied"));
+					for (int j = 1; j < multiplierValue; j++) {//multiplier means multiply the infixed suffix e.g. butandithione
+						Element newSuffix = suffix.copy();
+						Fragment newSuffixFrag = state.fragManager.copyFragment(suffix.getFrag());
+						newSuffix.setFrag(newSuffixFrag);
+						suffixFragments.add(newSuffixFrag);
+						OpsinTools.insertAfter(suffix, newSuffix);
+						suffixes.add(newSuffix);
+						if (locants !=null){//assign locants if available
+							newSuffix.getAttribute(LOCANT_ATR).setValue(locants[j]);
+						}
+					}
+					if (locants!=null){
+						possibleLocant.detach();
+					}
+				}
+				possibleMultiplier.detach();
+				possibleInfix.detach();
+			}
+			else{
+				throw new ComponentGenerationException("Multiplier expected in front of ambiguous infix");
+			}
+		}
+	}
+	
+	/*
+	 * Convenience Methods
+	 */
+	
+	/**
+	 * Given an atom that is to be replaced by a functional replacement fragment
+	 * determines whether this atom is a functional atom and, if it is, performs the following processes:
+	 * The functionalAtom is removed. If the the replacement fragment is an atom of O/S/Se/Te or the
+	 * the terminal atom of the fragment is a single bonded O/S/Se/Te a functionAom is added to this atom.
+	 * @param atomToBeReplaced
+	 * @param replacementFrag
+	 */
+	private void removeOrMoveObsoleteFunctionalAtoms(Atom atomToBeReplaced, Fragment replacementFrag){
+		List<Atom> replacementAtomList = replacementFrag.getAtomList();
+		Fragment origFrag = atomToBeReplaced.getFrag();
+		for (int i = origFrag.getFunctionalAtomCount() - 1; i >=0; i--) {
+			FunctionalAtom functionalAtom = origFrag.getFunctionalAtom(i);
+			if (atomToBeReplaced.equals(functionalAtom.getAtom())){
+				atomToBeReplaced.getFrag().removeFunctionalAtom(i);
+				Atom terminalAtomOfReplacementFrag = replacementAtomList.get(replacementAtomList.size()-1);
+				if ((terminalAtomOfReplacementFrag.getIncomingValency() ==1 || replacementAtomList.size()==1)&& terminalAtomOfReplacementFrag.getElement().isChalcogen()){
+					replacementFrag.addFunctionalAtom(terminalAtomOfReplacementFrag);
+					terminalAtomOfReplacementFrag.setCharge(atomToBeReplaced.getCharge());
+					terminalAtomOfReplacementFrag.setProtonsExplicitlyAddedOrRemoved(atomToBeReplaced.getProtonsExplicitlyAddedOrRemoved());
+				}
+				atomToBeReplaced.neutraliseCharge();
+			}
+		}
+	}
+	
+	/**
+	 * Given an atom that is to be replaced by a functional replacement fragment
+	 * determines whether this atom has outvalency and if it does removes the outatom from the atom's fragment
+	 * and adds an outatom to the replacementFrag
+	 * @param atomToBeReplaced
+	 * @param replacementFrag
+	 */
+	private void moveObsoleteOutAtoms(Atom atomToBeReplaced, Fragment replacementFrag){
+		if (atomToBeReplaced.getOutValency() >0){//this is not known to occur in well formed IUPAC names but would occur in thioxy (as a suffix)
+			List<Atom> replacementAtomList = replacementFrag.getAtomList();
+			Fragment origFrag = atomToBeReplaced.getFrag();
+			for (int i = origFrag.getOutAtomCount() - 1; i >=0; i--) {
+				OutAtom outAtom = origFrag.getOutAtom(i);
+				if (atomToBeReplaced.equals(outAtom.getAtom())){
+					atomToBeReplaced.getFrag().removeOutAtom(i);
+					Atom terminalAtomOfReplacementFrag = replacementAtomList.get(replacementAtomList.size()-1);
+					replacementFrag.addOutAtom(terminalAtomOfReplacementFrag, outAtom.getValency(), outAtom.isSetExplicitly());
+				}
+			}
+		}
+	}
+	
+	private void removeAssociatedFunctionalAtom(Atom atomWithFunctionalAtom) throws StructureBuildingException {
+		Fragment frag = atomWithFunctionalAtom.getFrag();
+		for (int i = frag.getFunctionalAtomCount() - 1; i >=0; i--) {
+			FunctionalAtom functionalAtom = frag.getFunctionalAtom(i);
+			if (atomWithFunctionalAtom.equals(functionalAtom.getAtom())){
+				atomWithFunctionalAtom.getFrag().removeFunctionalAtom(i);
+				return;
+			}
+		}
+		throw new StructureBuildingException("OPSIN bug: Unable to find associated functionalAtom");
+	}
+	
+
+	/**
+	 * Returns the subset of oxygenAtoms that possess one of the locants in locantEl
+	 * Searches for locant on nearest non suffix atom in case of suffixes
+	 * @param locantEl
+	 * @param oxygenAtoms
+	 * @return
+	 */
+	private List<Atom> pickOxygensWithAppropriateLocants(Element locantEl, List<Atom> oxygenAtoms) {
+		String[] possibleLocants = locantEl.getValue().split(",");
+		boolean pLocantSpecialCase = allLocantsP(possibleLocants);
+		List<Atom> oxygenWithAppropriateLocants = new ArrayList<>();
+		for (Atom atom : oxygenAtoms) {
+			List<String> atomlocants = atom.getLocants();
+			if (atomlocants.size() > 0) {
+				for (String locantVal : possibleLocants) {
+					if (atomlocants.contains(locantVal)) {
+						 oxygenWithAppropriateLocants.add(atom);
+						 break;
+					}
+				}
+			}
+			else if (pLocantSpecialCase) {
+				for (Atom neighbour : atom.getAtomNeighbours()) {
+					if (neighbour.getElement() == ChemEl.P) {
+						 oxygenWithAppropriateLocants.add(atom);
+						 break;
+					}
+				}
+			}
+			else {
+				Atom atomWithNumericLocant = OpsinTools.depthFirstSearchForAtomWithNumericLocant(atom);
+				if (atomWithNumericLocant != null) {
+					List<String> atomWithNumericLocantLocants = atomWithNumericLocant.getLocants();
+					for (String locantVal : possibleLocants) {
+						if (atomWithNumericLocantLocants.contains(locantVal)) {
+							 oxygenWithAppropriateLocants.add(atom);
+							 break;
+						}
+					}
+				}
+			}
+		}
+		return oxygenWithAppropriateLocants;
+	}
+
+	private boolean allLocantsP(String[] locants) {
+		if (locants.length == 0) {
+			return false;
+		}
+		for (String locant : locants) {
+			if (!locant.equals("P")) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Returns oxygen atoms in suffixes with functionalAtoms
+	 * @param groupToBeModified
+	 * @return
+	 */
+	private List<Atom> findFunctionalOxygenAtomsInApplicableSuffixes(Element groupToBeModified) {
+		List<Element> suffixElements =OpsinTools.getNextSiblingsOfType(groupToBeModified, SUFFIX_EL);
+		List<Atom> oxygenAtoms = new ArrayList<>();
+		for (Element suffix : suffixElements) {
+			Fragment suffixFrag = suffix.getFrag();
+			if (suffixFrag != null) {//null for non carboxylic acids
+				for (int i = 0, l = suffixFrag.getFunctionalAtomCount(); i < l; i++) {
+					Atom a = suffixFrag.getFunctionalAtom(i).getAtom();
+					if (a.getElement() == ChemEl.O) {
+						oxygenAtoms.add(a);
+					}
+				}
+			}
+		}
+		return oxygenAtoms;
+	}
+
+	/**
+	 * Returns functional oxygen atoms in groupToBeModified
+	 * @param groupToBeModified
+	 * @return
+	 */
+	private List<Atom> findFunctionalOxygenAtomsInGroup(Element groupToBeModified) {
+		List<Atom> oxygenAtoms = new ArrayList<>();
+		Fragment frag = groupToBeModified.getFrag();
+		for (int i = 0, l = frag.getFunctionalAtomCount(); i < l; i++) {
+			Atom a = frag.getFunctionalAtom(i).getAtom();
+			if (a.getElement() == ChemEl.O){
+				oxygenAtoms.add(a);
+			}
+		}
+		return oxygenAtoms;
+	}
+	
+	
+	/**
+	 * Returns etheric oxygen atoms in groupToBeModified
+	 * @param groupToBeModified
+	 * @return
+	 */
+	private List<Atom> findEthericOxygenAtomsInGroup(Element groupToBeModified) {
+		List<Atom> oxygenAtoms = new ArrayList<>();
+		List<Atom> atomList = groupToBeModified.getFrag().getAtomList();
+		for (Atom a: atomList) {
+			if (a.getElement() == ChemEl.O && a.getBondCount()==2 && a.getCharge()==0 && a.getIncomingValency()==2){
+				oxygenAtoms.add(a);
+			}
+		}
+		return oxygenAtoms;
+	}
+	
+	
+	/**
+	 * Returns oxygen atoms in suffixes with functionalAtoms or acidStem suffixes or aldehyde suffixes (1979 C-531)
+	 * @param groupToBeModified
+	 * @return
+	 */
+	private List<Atom> findOxygenAtomsInApplicableSuffixes(Element groupToBeModified) {
+		List<Element> suffixElements =OpsinTools.getNextSiblingsOfType(groupToBeModified, SUFFIX_EL);
+		List<Atom> oxygenAtoms = new ArrayList<>();
+		for (Element suffix : suffixElements) {
+			Fragment suffixFrag = suffix.getFrag();
+			if (suffixFrag != null) {//null for non carboxylic acids
+				if (suffixFrag.getFunctionalAtomCount() > 0 || groupToBeModified.getAttributeValue(TYPE_ATR).equals(ACIDSTEM_TYPE_VAL) || suffix.getAttributeValue(VALUE_ATR).equals("aldehyde")) {
+					List<Atom> atomList = suffixFrag.getAtomList();
+					for (Atom a : atomList) {
+						if (a.getElement() == ChemEl.O) {
+							oxygenAtoms.add(a);
+						}
+					}
+				}
+			}
+		}
+		return oxygenAtoms;
+	}
+	
+	/**
+	 * Returns oxygen atoms in groupToBeModified
+	 * @param groupToBeModified
+	 * @return
+	 */
+	private List<Atom> findOxygenAtomsInGroup(Element groupToBeModified) {
+		List<Atom> oxygenAtoms = new ArrayList<>();
+		List<Atom> atomList = groupToBeModified.getFrag().getAtomList();
+		for (Atom a : atomList) {
+			if (a.getElement() == ChemEl.O){
+				oxygenAtoms.add(a);
+			}
+		}
+		return oxygenAtoms;
+	}
+	
+
+	private void populateTerminalSingleAndDoubleBondedOxygen(List<Atom> atomList, List<Atom> singleBondedOxygen, List<Atom> doubleBondedOxygen) throws StructureBuildingException {
+		for (Atom a : atomList) {
+			if (a.getElement() == ChemEl.O){//find terminal oxygens
+				if (a.getBondCount()==1){
+					int incomingValency = a.getIncomingValency();
+					if (incomingValency ==2){
+						doubleBondedOxygen.add(a);
+					}
+					else if (incomingValency ==1){
+						singleBondedOxygen.add(a);
+					}
+					else{
+						throw new StructureBuildingException("Unexpected bond order to oxygen; excepted 1 or 2 found: " +incomingValency);
+					}
+
+				}
+			}
+		}
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/FusedRingBuilder.java

@@ -0,0 +1,1030 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+import static uk.ac.cam.ch.wwmm.opsin.OpsinTools.*;
+import static uk.ac.cam.ch.wwmm.opsin.XmlDeclarations.*;
+
+/**
+ * Assembles fused rings named using fusion nomenclature
+ * @author dl387
+ *
+ */
+class FusedRingBuilder {
+	private final BuildState state;
+	private final List<Element> groupsInFusedRing;
+	private final Element lastGroup;
+	private final Fragment parentRing;
+	private final Map<Integer,Fragment> fragmentInScopeForEachFusionLevel = new HashMap<>();
+	private final Map<Atom, Atom> atomsToRemoveToReplacementAtom = new HashMap<>();
+
+	private FusedRingBuilder(BuildState state, List<Element> groupsInFusedRing) {
+		this.state = state;
+		this.groupsInFusedRing = groupsInFusedRing;
+		lastGroup = groupsInFusedRing.get(groupsInFusedRing.size()-1);
+		parentRing = lastGroup.getFrag();
+		fragmentInScopeForEachFusionLevel.put(0, parentRing);
+	}
+
+	/**
+	 * Master method for processing fused rings. Fuses groups together
+	 * @param state: contains the current id and fragment manager
+	 * @param subOrRoot Element (substituent or root)
+	 * @throws StructureBuildingException
+	 */
+	static void processFusedRings(BuildState state, Element subOrRoot) throws  StructureBuildingException {
+		List<Element> groups = subOrRoot.getChildElements(GROUP_EL);
+		if (groups.size() < 2){
+			return;//nothing to fuse
+		}
+		List<Element> groupsInFusedRing =new ArrayList<>();
+		for (int i = groups.size()-1; i >=0; i--) {//group groups into fused rings
+			Element group =groups.get(i);
+			groupsInFusedRing.add(0, group);
+			if (i!=0){
+				Element startingEl = group;
+				if ((group.getValue().equals("benz") || group.getValue().equals("benzo")) && FUSIONRING_SUBTYPE_VAL.equals(group.getAttributeValue(SUBTYPE_ATR))){
+					Element beforeBenzo = OpsinTools.getPreviousSibling(group);
+					if (beforeBenzo !=null && beforeBenzo.getName().equals(LOCANT_EL)){
+						startingEl = beforeBenzo;
+					}
+				}
+				Element possibleGroup = OpsinTools.getPreviousSiblingIgnoringCertainElements(startingEl, new String[]{MULTIPLIER_EL, FUSION_EL});
+				if (!groups.get(i-1).equals(possibleGroup)){//end of fused ring system
+					if (groupsInFusedRing.size()>=2){
+						//This will be invoked in cases where there are multiple fused ring systems in the same subOrRoot such as some spiro systems
+						new FusedRingBuilder(state, groupsInFusedRing).buildFusedRing();
+					}
+					groupsInFusedRing.clear();
+				}
+			}
+		}
+		if (groupsInFusedRing.size()>=2){
+			new FusedRingBuilder(state, groupsInFusedRing).buildFusedRing();
+		}
+	}
+
+	/**
+	 * Combines the groups given in the {@link FusedRingBuilder} constructor to destructively create the fused ring system
+	 * This fused ring is then numbered
+	 * @throws StructureBuildingException
+	 */
+	void buildFusedRing() throws StructureBuildingException{
+		/*
+		 * Apply any nonstandard ring numbering, sorts atomOrder by locant
+		 * Aromatises appropriate cycloalkane rings, Rejects groups with acyclic atoms
+		 */
+        processRingNumberingAndIrregularities();
+		processBenzoFusions();//FR-2.2.8  e.g. in 2H-[1,3]benzodioxino[6',5',4':10,5,6]anthra[2,3-b]azepine  benzodioxino is one component
+		List<Element> nameComponents = formNameComponentList();
+		nameComponents.remove(lastGroup);
+
+		List<Fragment> componentFragments = new ArrayList<>();//all the ring fragments (other than the parentRing). These will later be merged into the parentRing
+		List<Fragment> parentFragments = new ArrayList<>();
+		parentFragments.add(parentRing);
+		
+		int numberOfParents = 1;
+		Element possibleMultiplier = OpsinTools.getPreviousSibling(lastGroup);
+		if (nameComponents.size()>0 && possibleMultiplier !=null && possibleMultiplier.getName().equals(MULTIPLIER_EL)){
+			numberOfParents = Integer.parseInt(possibleMultiplier.getAttributeValue(VALUE_ATR));
+			possibleMultiplier.detach();
+			for (int j = 1; j < numberOfParents; j++) {
+				Fragment copyOfParentRing =state.fragManager.copyFragment(parentRing);
+				parentFragments.add(copyOfParentRing);
+				componentFragments.add(copyOfParentRing);
+			}
+		}
+
+		/*The indice from nameComponents to use next. Work from right to left i.e. starts at nameComponents.size()-1*/
+		int ncIndice = processMultiParentSystem(parentFragments, nameComponents, componentFragments);//handle multiparent systems
+		/*
+		 * The number of primes on the component to be connected. 
+		 * This is initially 0 indicating fusion of unprimed locants with the letter locants of the parentRing
+		 * Subsequently it will switch to 1 indicating fusion of a second order component (primed locants) with a 
+		 * first order component (unprimed locants)
+		 * Next would be double primed fusing to single primed locants etc.
+		 * 
+		 */
+		int fusionLevel = (nameComponents.size()-1 -ncIndice)/2;
+		for (; ncIndice>=0; ncIndice--) {
+			Element fusion = null;
+			if (nameComponents.get(ncIndice).getName().equals(FUSION_EL)){
+				fusion = nameComponents.get(ncIndice--);
+			}
+			if (ncIndice <0 || !nameComponents.get(ncIndice).getName().equals(GROUP_EL)){
+				throw new StructureBuildingException("Group not found where group expected. This is probably a bug");
+			}
+			Fragment nextComponent = nameComponents.get(ncIndice).getFrag();
+			int multiplier = 1;
+			Element possibleMultiplierEl = OpsinTools.getPreviousSibling(nameComponents.get(ncIndice));//e.g. the di of difuro
+			if (possibleMultiplierEl != null && possibleMultiplierEl.getName().equals(MULTIPLIER_EL)){
+				multiplier = Integer.parseInt(possibleMultiplierEl.getAttributeValue(VALUE_ATR));
+			}
+			String[] fusionDescriptors =null;
+			if (fusion !=null){
+				String fusionDescriptorString = fusion.getValue().toLowerCase(Locale.ROOT).substring(1, fusion.getValue().length()-1);
+				if (multiplier ==1){
+					fusionDescriptors = new String[]{fusionDescriptorString};
+				}
+				else{
+					if (fusionDescriptorString.split(";").length >1){
+						fusionDescriptors = fusionDescriptorString.split(";");
+					}
+					else if (fusionDescriptorString.split(":").length >1){
+						fusionDescriptors = fusionDescriptorString.split(":");
+					}
+					else if (fusionDescriptorString.split(",").length >1){
+						fusionDescriptors = fusionDescriptorString.split(",");
+					}
+					else{//multiplier does not appear to mean multiplied component. Could be indicating multiplication of the whole fused ring system
+						if (ncIndice!=0){
+							throw new StructureBuildingException("Unexpected multiplier: " + possibleMultiplierEl.getValue() +" or incorrect fusion descriptor: " + fusionDescriptorString);
+						}
+						multiplier =1;
+						fusionDescriptors = new String[]{fusionDescriptorString};
+					}
+				}
+			}
+			if (multiplier >1){
+				possibleMultiplierEl.detach();
+			}
+			Fragment[] fusionComponents = new Fragment[multiplier];
+			for (int j = 0; j < multiplier; j++) {
+				if (j>0){
+					fusionComponents[j] = state.fragManager.copyAndRelabelFragment(nextComponent,  j);
+				}
+				else{
+					fusionComponents[j] = nextComponent;
+				}
+			}
+			
+			for (int j = 0; j < multiplier; j++) {
+				Fragment component = fusionComponents[j];
+				componentFragments.add(component);
+				if (fusion !=null){
+					if (fusionDescriptors[j].split(":").length==1){//A fusion bracket without a colon is used when applying to the parent component (except in a special case where locants are ommitted)
+						//check for case of omitted locant from a higher order fusion bracket e.g. cyclopenta[4,5]pyrrolo[2,3-c]pyridine
+						if (fusionDescriptors[j].split("-").length==1 && 
+								fusionDescriptors[j].split(",").length >1 &&
+								FragmentTools.allAtomsInRingAreIdentical(component)
+								&& ((StringTools.countTerminalPrimes(fusionDescriptors[j].split(",")[0])) != fusionLevel) ){//Could be like cyclopenta[3,4]cyclobuta[1,2]benzene where the first fusion to occur has parent locants omitted not child locants
+							int numberOfPrimes = StringTools.countTerminalPrimes(fusionDescriptors[j].split(",")[0]);
+							//note that this is the number of primes on the parent ring. So would expect the child ring and hence the fusionLevel to be 1 higher
+							if (numberOfPrimes + 1 != fusionLevel){
+								if (numberOfPrimes + 2 == fusionLevel){//ring could be in previous fusion level e.g. the benzo in benzo[10,11]phenanthro[2',3',4',5',6':4,5,6,7]chryseno[1,2,3-bc]coronene
+									fusionLevel--;
+								}
+								else{
+									throw new StructureBuildingException("Incorrect number of primes in fusion bracket: " +fusionDescriptors[j]);
+								}
+							}
+							relabelAccordingToFusionLevel(component, fusionLevel);
+							List<String> numericalLocantsOfParent = Arrays.asList(fusionDescriptors[j].split(","));
+							List<String> numericalLocantsOfChild = findPossibleNumericalLocants(component, determineAtomsToFuse(fragmentInScopeForEachFusionLevel.get(fusionLevel), numericalLocantsOfParent, null).size()-1);
+							processHigherOrderFusionDescriptors(component, fragmentInScopeForEachFusionLevel.get(fusionLevel), numericalLocantsOfChild, numericalLocantsOfParent);
+						}
+						else{
+							fusionLevel = 0;
+							relabelAccordingToFusionLevel(component, fusionLevel);
+							String fusionDescriptor = fusionDescriptors[j];
+							String[] fusionArray = determineNumericalAndLetterComponents(fusionDescriptor);
+							int numberOfPrimes =0;
+							if (!fusionArray[1].equals("")){
+								numberOfPrimes =StringTools.countTerminalPrimes(fusionArray[1]);
+								if (fusionArray[0].equals("")){
+									fusionDescriptor = fusionArray[1].replaceAll("'", "");
+								}
+								else{
+									fusionDescriptor = fusionArray[0]+ "-" +fusionArray[1].replaceAll("'", "");
+								}
+								if (numberOfPrimes >= parentFragments.size()){
+									throw new StructureBuildingException("Unexpected prime in fusion descriptor");
+								}
+							}
+							performSimpleFusion(fusionDescriptor, component, parentFragments.get(numberOfPrimes));//e.g. pyrano[3,2-b]imidazo[4,5-e]pyridine where both are level 0 fusions
+						}
+					}
+					else{
+						//determine number of primes in fusor and hence determine fusion level
+						int numberOfPrimes = -j + StringTools.countTerminalPrimes(fusionDescriptors[j].split(",")[0]);
+						if (numberOfPrimes != fusionLevel){
+							if (fusionLevel == numberOfPrimes +1){
+								fusionLevel--;
+							}
+							else{
+								throw new StructureBuildingException("Incorrect number of primes in fusion bracket: " +fusionDescriptors[j]);
+							}
+						}
+						relabelAccordingToFusionLevel(component, fusionLevel);
+						performHigherOrderFusion(fusionDescriptors[j], component, fragmentInScopeForEachFusionLevel.get(fusionLevel));
+					}
+				}
+				else{
+					relabelAccordingToFusionLevel(component, fusionLevel);
+					performSimpleFusion(null, component, fragmentInScopeForEachFusionLevel.get(fusionLevel));
+				}
+			}
+			fusionLevel++;
+			if (multiplier ==1){//multiplied components may not be substituted onto
+				fragmentInScopeForEachFusionLevel.put(fusionLevel, fusionComponents[0]);
+			}
+		}
+		for (Fragment ring : componentFragments) {
+			state.fragManager.incorporateFragment(ring, parentRing);
+		}
+		removeMergedAtoms();
+
+		FusedRingNumberer.numberFusedRing(parentRing);//numbers the fused ring;
+
+		StringBuilder fusedRingName = new StringBuilder();
+		for (Element element : nameComponents) {
+			fusedRingName.append(element.getValue());
+		}
+		fusedRingName.append(lastGroup.getValue());
+
+		Element fusedRingEl =lastGroup;//reuse this element to save having to remap suffixes...
+		fusedRingEl.getAttribute(VALUE_ATR).setValue(fusedRingName.toString());
+		fusedRingEl.getAttribute(TYPE_ATR).setValue(RING_TYPE_VAL);
+		fusedRingEl.setValue(fusedRingName.toString());
+
+		for (Element element : nameComponents) {
+			element.detach();
+		}
+	}
+
+	private void removeMergedAtoms() {
+		for (Atom a : atomsToRemoveToReplacementAtom.keySet()) {
+			state.fragManager.removeAtomAndAssociatedBonds(a);
+		}
+		atomsToRemoveToReplacementAtom.clear();
+	}
+
+	/**
+	 * Forms a list a list of all group and fusion elements between the first and last group in the fused ring
+	 * @return
+	 */
+	private List<Element> formNameComponentList() {
+		List<Element> nameComponents  = new ArrayList<>();
+		Element currentEl = groupsInFusedRing.get(0);
+		while(currentEl != lastGroup){
+			if (currentEl.getName().equals(GROUP_EL) || currentEl.getName().equals(FUSION_EL)){
+				nameComponents.add(currentEl);
+			}
+			currentEl = OpsinTools.getNextSibling(currentEl);
+		}
+		return nameComponents;
+	}
+
+	private void processRingNumberingAndIrregularities() throws StructureBuildingException {
+		for (Element group : groupsInFusedRing) {
+            Fragment ring = group.getFrag();
+            if (ALKANESTEM_SUBTYPE_VAL.equals(group.getAttributeValue(SUBTYPE_ATR))){
+            	aromatiseCyclicAlkane(group);
+            }
+            processPartiallyUnsaturatedHWSystems(group, ring);
+            if (group == lastGroup) {
+                //perform a quick check that every atom in this group is infact cyclic. Fusion components are enumerated and hence all guaranteed to be purely cyclic
+                List<Atom> atomList = ring.getAtomList();
+                for (Atom atom : atomList) {
+                    if (!atom.getAtomIsInACycle()) {
+                        throw new StructureBuildingException("Inappropriate group used in fusion nomenclature. Only groups composed entirely of atoms in cycles may be used. i.e. not: " + group.getValue());
+                    }
+                }
+                if (group.getAttribute(FUSEDRINGNUMBERING_ATR) != null) {
+                    String[] standardNumbering = group.getAttributeValue(FUSEDRINGNUMBERING_ATR).split("/", -1);
+                    for (int j = 0; j < standardNumbering.length; j++) {
+                        atomList.get(j).replaceLocants(standardNumbering[j]);
+                    }
+                } else {
+                    ring.sortAtomListByLocant();//for those where the order the locants are in is sensible					}
+                }
+                for (Atom atom : atomList) {
+                    atom.clearLocants();//the parentRing does not have locants, letters are used to indicate the edges
+                }
+            } else if (group.getAttribute(FUSEDRINGNUMBERING_ATR) == null) {
+                ring.sortAtomListByLocant();//for those where the order the locants are in is sensible
+            }
+        }
+	}
+
+	/**
+	 * Interprets the unlocanted unsaturator after a partially unsaturated HW Rings as indication of spare valency and detaches it
+     * This is necessary as this unsaturator can only refer to the HW ring and for names like 2-Benzoxazolinone to avoid confusion as to what the 2 refers to.
+	 * @param group
+	 * @param ring
+	 */
+	private void processPartiallyUnsaturatedHWSystems(Element group, Fragment ring) {
+		if (HANTZSCHWIDMAN_SUBTYPE_VAL.equals(group.getAttributeValue(SUBTYPE_ATR)) && group.getAttribute(ADDBOND_ATR)!=null){
+			List<Element> unsaturators = OpsinTools.getNextAdjacentSiblingsOfType(group, UNSATURATOR_EL);
+			if (unsaturators.size()>0){
+				Element unsaturator = unsaturators.get(0);
+				if (unsaturator.getAttribute(LOCANT_ATR)==null && unsaturator.getAttributeValue(VALUE_ATR).equals("2")){
+					unsaturator.detach();
+					List<Bond> bondsToUnsaturate = StructureBuildingMethods.findBondsToUnSaturate(ring, 2, true);
+					if (bondsToUnsaturate.size() == 0) {
+						throw new RuntimeException("Failed to find bond to unsaturate on partially saturated HW ring");
+					}
+					Bond b = bondsToUnsaturate.get(0);
+					b.getFromAtom().setSpareValency(true);
+					b.getToAtom().setSpareValency(true);
+				}
+			}
+		}		
+	}
+
+	/**
+	 * Given a cyclicAlkaneGroup determines whether or not it should be aromatised. Unlocanted ene will be detached if it is an aromatisation hint
+	 * No unsaturators -->aromatise
+	 * Just ane -->don't
+	 * More than 1 ene or locants on ene -->don't
+	 * yne --> don't
+	 * @param cyclicAlkaneGroup
+	 */
+	private void aromatiseCyclicAlkane(Element cyclicAlkaneGroup) {
+		Element next = OpsinTools.getNextSibling(cyclicAlkaneGroup);
+		List<Element> unsaturators = new ArrayList<>();
+		while (next!=null && next.getName().equals(UNSATURATOR_EL)){
+			unsaturators.add(next);
+			next = OpsinTools.getNextSibling(next);
+		}
+		boolean conjugate =true;
+		if (unsaturators.size()==1){
+			int value = Integer.parseInt(unsaturators.get(0).getAttributeValue(VALUE_ATR));
+			if (value !=2){
+				conjugate =false;
+			}
+			else if (unsaturators.get(0).getAttribute(LOCANT_ATR)!=null){
+				conjugate =false;
+			}
+		}
+		else if (unsaturators.size()==2){
+			int value1 = Integer.parseInt(unsaturators.get(0).getAttributeValue(VALUE_ATR));
+			if (value1 !=1){
+				conjugate =false;
+			}
+			else{
+				int value2 = Integer.parseInt(unsaturators.get(1).getAttributeValue(VALUE_ATR));
+				if (value2 !=2 || unsaturators.get(1).getAttribute(LOCANT_ATR)!=null){
+					conjugate =false;
+				}
+			}
+		}
+		else if (unsaturators.size() >2){
+			conjugate =false;
+		}
+		if (conjugate){
+			for (Element unsaturator : unsaturators) {
+				unsaturator.detach();
+			}
+			List<Atom> atomList = cyclicAlkaneGroup.getFrag().getAtomList();
+		    for (Atom atom : atomList) {
+		        atom.setSpareValency(true);
+		    }
+		}
+	}
+
+	private int processMultiParentSystem(List<Fragment> parentFragments, List<Element> nameComponents, List<Fragment> componentFragments) throws StructureBuildingException {
+		int i = nameComponents.size()-1;
+		int fusionLevel =0;
+		if (i>=0 && parentFragments.size()>1){
+			List<Fragment> previousFusionLevelFragments = parentFragments;
+			for (; i>=0; i--) {
+				if (previousFusionLevelFragments.size()==1){//completed multi parent system
+					fragmentInScopeForEachFusionLevel.put(fusionLevel, previousFusionLevelFragments.get(0));
+					break;
+				}
+				Element fusion = null;
+				if (nameComponents.get(i).getName().equals(FUSION_EL)){
+					fusion = nameComponents.get(i--);
+				}
+				else{
+					throw new StructureBuildingException("Fusion bracket not found where fusion bracket expected");
+				}
+				if (i <0 || !nameComponents.get(i).getName().equals(GROUP_EL)){
+					throw new StructureBuildingException("Group not found where group expected. This is probably a bug");
+				}
+				Fragment nextComponent = nameComponents.get(i).getFrag();
+				relabelAccordingToFusionLevel(nextComponent, fusionLevel);
+				int multiplier = 1;
+				Element possibleMultiplierEl = OpsinTools.getPreviousSibling(nameComponents.get(i));
+				if (possibleMultiplierEl != null && possibleMultiplierEl.getName().equals(MULTIPLIER_EL)){
+					multiplier = Integer.parseInt(possibleMultiplierEl.getAttributeValue(VALUE_ATR));
+					possibleMultiplierEl.detach();
+				}
+				List<Fragment> fusionComponents = new ArrayList<>();
+				for (int j = 0; j < multiplier; j++) {
+					if (j>0){
+						Fragment clonedFrag = state.fragManager.copyFragment(nextComponent);
+						relabelAccordingToFusionLevel(clonedFrag, j);//fusionLevels worth of primes already added
+						fusionComponents.add(clonedFrag);
+					}
+					else{
+						fusionComponents.add(nextComponent);
+					}
+				}
+				fusionLevel+=multiplier;
+				if (multiplier>1 && multiplier != previousFusionLevelFragments.size()){
+					throw new StructureBuildingException("Mismatch between number of components and number of parents in fused ring system");
+				}
+				String fusionDescriptorString = fusion.getValue().toLowerCase(Locale.ROOT).substring(1, fusion.getValue().length()-1);
+				String[] fusionDescriptors =null;
+				if (fusionDescriptorString.split(";").length >1){
+					fusionDescriptors = fusionDescriptorString.split(";");
+				}
+				else if (fusionDescriptorString.split(":").length >1){
+					fusionDescriptors = fusionDescriptorString.split(":");
+				}
+				else if (fusionDescriptorString.split(",").length >1){
+					fusionDescriptors = fusionDescriptorString.split(",");
+				}
+				else{
+					throw new StructureBuildingException("Invalid fusion descriptor: " + fusionDescriptorString);
+				}
+				if (fusionDescriptors.length != previousFusionLevelFragments.size()){
+					throw new StructureBuildingException("Invalid fusion descriptor: "+fusionDescriptorString +"(Number of locants disagrees with number of parents)");
+				}
+				for (int j = 0; j < fusionDescriptors.length; j++) {
+					String fusionDescriptor = fusionDescriptors[j];
+					Fragment component = multiplier>1 ? fusionComponents.get(j) : nextComponent;
+					Fragment parentToUse = previousFusionLevelFragments.get(j);
+					boolean simpleFusion = fusionDescriptor.split(":").length <= 1;
+					if (simpleFusion){
+						String[] fusionArray = determineNumericalAndLetterComponents(fusionDescriptor);
+						if (fusionArray[1].length() != 0){
+							int numberOfPrimes =StringTools.countTerminalPrimes(fusionArray[1]);
+							if (fusionArray[0].length() == 0){
+								fusionDescriptor = fusionArray[1].replaceAll("'", "");
+							}
+							else{
+								fusionDescriptor = fusionArray[0]+ "-" +fusionArray[1].replaceAll("'", "");
+							}
+							if (numberOfPrimes !=j){//check the number of primes on the letter part agree with the parent to use e.g.[4,5-bcd:1,2-c']difuran
+								throw new StructureBuildingException("Incorrect number of primes in fusion descriptor: " + fusionDescriptor);
+							}
+						}
+						performSimpleFusion(fusionDescriptor, component, parentToUse);
+					}
+					else{
+						performHigherOrderFusion(fusionDescriptor, component, parentToUse);
+					}
+				}
+				previousFusionLevelFragments = fusionComponents;
+				componentFragments.addAll(fusionComponents);
+			}
+			if (previousFusionLevelFragments.size()!=1){
+				throw new StructureBuildingException("Invalid fused ring system. Incomplete multiparent system");
+			}
+		}
+		return i;
+	}
+
+	/**
+	 * Splits a first order fusion component into it's numerical and letter parts
+	 * Either one of these can be the blank string as they may have been omitted
+	 * The first entry in the array is the numbers and the second the letters
+	 * @param fusionDescriptor
+	 * @return
+	 */
+	private String[] determineNumericalAndLetterComponents(String fusionDescriptor) {
+		String[] fusionArray = fusionDescriptor.split("-");
+		if (fusionArray.length ==2){
+			return fusionArray;
+		}
+		else{
+			String[] components = new String[2];
+			if (fusionArray[0].contains(",")){//the digit section
+				components[0]=fusionArray[0];
+				components[1]="";
+			}
+			else{
+				components[0]="";
+				components[1]=fusionArray[0];
+			}
+			return components;
+		}
+	}
+
+	/**
+	 * Searches groups for benz(o) components and fuses them in accordance with
+	 * FR-2.2.8 Heterobicyclic components with a benzene ring
+	 * @throws StructureBuildingException
+	 */
+	private void processBenzoFusions() throws StructureBuildingException {
+		for(int i = groupsInFusedRing.size() - 2; i >= 0; i--) {
+			Element group = groupsInFusedRing.get(i);
+			if (group.getValue().equals("benz") || group.getValue().equals("benzo")) {
+				Element possibleFusionbracket = OpsinTools.getNextSibling(group);
+				if (!possibleFusionbracket.getName().equals(FUSION_EL)) {
+					Element possibleMultiplier = OpsinTools.getPreviousSibling(group);
+					if (possibleMultiplier == null || !possibleMultiplier.getName().equals(MULTIPLIER_EL) || possibleMultiplier.getAttributeValue(TYPE_ATR).equals(GROUP_TYPE_VAL)) {
+						//e.g. 2-benzofuran. Fused rings of this type are a special case treated as being a single component
+						//and have a special convention for indicating the position of heteroatoms 
+						benzoSpecificFusion(group, groupsInFusedRing.get(i + 1));
+						group.detach();
+						groupsInFusedRing.remove(i);
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Modifies nextComponent's locants according to the fusionLevel.
+	 * @param component
+	 * @param fusionLevel
+	 */
+	private void relabelAccordingToFusionLevel(Fragment component, int fusionLevel)  {
+		if (fusionLevel > 0){
+			FragmentTools.relabelNumericLocants(component.getAtomList(), StringTools.multiplyString("'", fusionLevel));
+		}
+	}
+
+	/**
+	 * Handles fusion between components where the fusion descriptor is of the form:
+	 * comma separated locants dash letters
+	 * e.g imidazo[4,5-d]pyridine
+	 * The fusionDescriptor may be given as null or the letter/numerical part omitted.
+	 * Sensible defaults will be found instead
+	 * @param fusionDescriptor
+	 * @param childRing
+	 * @param parentRing
+	 * @throws StructureBuildingException
+	 */
+	private void performSimpleFusion(String fusionDescriptor, Fragment childRing, Fragment parentRing) throws StructureBuildingException {
+		List<String> numericalLocantsOfChild = null;
+		List<String> letterLocantsOfParent = null;
+		if (fusionDescriptor != null){
+			String[] fusionArray = fusionDescriptor.split("-");
+			if (fusionArray.length ==2){
+				numericalLocantsOfChild = Arrays.asList(fusionArray[0].split(","));
+				char[] tempLetterLocantsOfParent = fusionArray[1].toCharArray();
+				letterLocantsOfParent = new ArrayList<>();
+                for (char letterLocantOfParent : tempLetterLocantsOfParent) {
+                    letterLocantsOfParent.add(String.valueOf(letterLocantOfParent));
+                }
+			}
+			else{
+				if (fusionArray[0].contains(",")){//only has digits
+					String[] numericalLocantsOfChildTemp = fusionArray[0].split(",");
+					numericalLocantsOfChild = Arrays.asList(numericalLocantsOfChildTemp);
+				}
+				else{//only has letters
+					char[] tempLetterLocantsOfParentCharArray = fusionArray[0].toCharArray();
+					letterLocantsOfParent = new ArrayList<>();
+                    for (char letterLocantOfParentCharArray : tempLetterLocantsOfParentCharArray) {
+                        letterLocantsOfParent.add(String.valueOf(letterLocantOfParentCharArray));
+                    }
+				}
+			}
+		}
+
+		int edgeLength =1;
+		if (numericalLocantsOfChild != null){
+			if (numericalLocantsOfChild.size() <=1){
+				throw new StructureBuildingException("At least two numerical locants must be provided to perform fusion!");
+			}
+			edgeLength = numericalLocantsOfChild.size()-1;
+		}
+		else if (letterLocantsOfParent != null){
+			edgeLength = letterLocantsOfParent.size();
+		}
+
+		if (numericalLocantsOfChild == null){
+			numericalLocantsOfChild = findPossibleNumericalLocants(childRing, edgeLength);
+		}
+
+		if (letterLocantsOfParent == null){
+			letterLocantsOfParent = findPossibleLetterLocants(parentRing, edgeLength);
+		}
+		if (numericalLocantsOfChild == null || letterLocantsOfParent ==null){
+			throw new StructureBuildingException("Unable to find bond to form fused ring system. Some information for forming fused ring system was only supplyed implicitly");
+		}
+
+		processFirstOrderFusionDescriptors(childRing, parentRing, numericalLocantsOfChild, letterLocantsOfParent);//fuse the rings
+	}
+
+	/**
+	 * Takes a ring an returns and array with one letter corresponding to a side/s
+	 * that contains two adjacent non bridgehead carbons
+	 * The number of sides is specified by edgeLength
+	 * @param ring
+	 * @param edgeLength The number of bonds to be fused along
+	 * @return
+	 */
+	private List<String> findPossibleLetterLocants(Fragment ring, int edgeLength) {
+		List<Integer> carbonAtomIndexes = new ArrayList<>();
+		int numberOfAtoms = ring.getAtomCount();
+		CyclicAtomList cyclicAtomList = new CyclicAtomList(ring.getAtomList());
+		for (int i = 0; i <= numberOfAtoms; i++) {
+			//iterate backwards in list to use highest locanted edge in preference.
+			//this retains what is currently locant 1 on the parent ring as locant 1 if the first two atoms found match
+			//the last atom in the list is potentially tested twice e.g. on a 6 membered ring, 6-5 and 1-6 are both possible
+			Atom atom = cyclicAtomList.previous();
+			//want non-bridgehead carbon atoms. Double-check that these carbon atoms are actually bonded (e.g. von baeyer systems have non-consecutive atom numbering!)
+			if (atom.getElement() == ChemEl.C && atom.getBondCount() == 2
+					&& (carbonAtomIndexes.size() == 0 || atom.getAtomNeighbours().contains(cyclicAtomList.peekNext()))){
+				carbonAtomIndexes.add(cyclicAtomList.getIndex());
+				if (carbonAtomIndexes.size() == edgeLength + 1){//as many carbons in a row as to give that edgelength ->use these side/s
+					Collections.reverse(carbonAtomIndexes);
+					List<String> letterLocantsOfParent = new ArrayList<>();
+					for (int j = 0; j < edgeLength; j++) {
+						letterLocantsOfParent.add(String.valueOf((char)(97 + carbonAtomIndexes.get(j))));//97 is ascii for a	
+					}
+					return letterLocantsOfParent;
+				}
+			}
+			else{
+				carbonAtomIndexes.clear();
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Takes a ring and returns an array of numbers corresponding to a side/s
+	 * that contains two adjacent non bridgehead carbons
+	 * The number of sides is specified by edgeLength
+	 * @param ring
+	 * @param edgeLength The number of bonds to be fused along
+	 * @return
+	 */
+	private List<String> findPossibleNumericalLocants(Fragment ring, int edgeLength) {
+		List<String> carbonLocants = new ArrayList<>();
+		int numberOfAtoms = ring.getAtomCount();
+		CyclicAtomList cyclicAtomList = new CyclicAtomList(ring.getAtomList());
+		for (int i = 0; i <= numberOfAtoms; i++) {
+			//the last atom in the list is potentially tested twice e.g. on a 6 membered ring, 1-2 and 6-1 are both possible
+			Atom atom = cyclicAtomList.next();
+			//want non-bridgehead carbon atoms. Double-check that these carbon atoms are actually bonded (e.g. von baeyer systems have non-consecutive atom numbering!)
+			if (atom.getElement() == ChemEl.C && atom.getBondCount() == 2
+					&& (carbonLocants.size() == 0 || atom.getAtomNeighbours().contains(cyclicAtomList.peekPrevious()))){
+				carbonLocants.add(atom.getFirstLocant());
+				if (carbonLocants.size() == edgeLength + 1){//as many carbons in a row as to give that edgelength ->use these side/s
+					List<String> numericalLocantsOfChild = new ArrayList<>();
+					for (String locant : carbonLocants) {
+						numericalLocantsOfChild.add(locant);
+					}
+					return numericalLocantsOfChild;
+				}
+			}
+			else{
+				carbonLocants.clear();
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Performs a single ring fusion using the values in numericalLocantsOfChild/letterLocantsOfParent
+	 * @param childRing
+	 * @param parentRing
+	 * @param numericalLocantsOfChild
+	 * @param letterLocantsOfParent
+	 * @throws StructureBuildingException
+	 */
+	private void processFirstOrderFusionDescriptors(Fragment childRing, Fragment parentRing, List<String> numericalLocantsOfChild, List<String> letterLocantsOfParent) throws StructureBuildingException {
+		List<Atom> childAtoms = determineAtomsToFuse(childRing, numericalLocantsOfChild, letterLocantsOfParent.size() +1);
+		if (childAtoms ==null){
+			throw new StructureBuildingException("Malformed fusion bracket!");
+		}
+
+		List<Atom> parentAtoms = new ArrayList<>();
+		List<Atom> parentPeripheralAtomList = getPeripheralAtoms(parentRing.getAtomList());
+		CyclicAtomList cyclicListAtomsOnSurfaceOfParent = new CyclicAtomList(parentPeripheralAtomList, (int)letterLocantsOfParent.get(0).charAt(0) -97);//convert from lower case character through ascii to 0-23
+		parentAtoms.add(cyclicListAtomsOnSurfaceOfParent.getCurrent());
+		for (int i = 0; i < letterLocantsOfParent.size(); i++) {
+			parentAtoms.add(cyclicListAtomsOnSurfaceOfParent.next());
+		}
+		fuseRings(childAtoms, parentAtoms);
+	}
+	
+	/**
+	 * Returns the sublist of the given atoms that are peripheral atoms given that the list is ordered such that the interior atoms are at the end of the list
+	 * @param atomList
+	 * @return
+	 */
+	private List<Atom> getPeripheralAtoms(List<Atom> atomList) {
+		//find the indice of the last atom on the surface of the ring. This obviously connects to the first atom. The objective is to exclude any interior atoms.
+		List<Atom> neighbours = atomList.get(0).getAtomNeighbours();
+		int indice = Integer.MAX_VALUE;
+		for (Atom atom : neighbours) {
+			int indexOfAtom =atomList.indexOf(atom);
+			if (indexOfAtom ==1){//not the next atom
+				continue;
+			}
+			else if (indexOfAtom ==-1){//not in parentRing
+				continue;
+			}
+			if (atomList.indexOf(atom)< indice){
+				indice = indexOfAtom;
+			}
+		}
+		return atomList.subList(0, indice +1);
+	}
+
+	/**
+	 * Handles fusion between components where the fusion descriptor is of the form:
+	 * comma separated locants colon comma separated locants
+	 * e.g pyrido[1'',2'':1',2']imidazo
+	 * @param fusionDescriptor
+	 * @param nextComponent
+	 * @param fusedRing
+	 * @throws StructureBuildingException 
+	 */
+	private void performHigherOrderFusion(String fusionDescriptor, Fragment nextComponent, Fragment fusedRing) throws StructureBuildingException {
+		List<String> numericalLocantsOfChild = null;
+		List<String> numericalLocantsOfParent = null;
+		String[] fusionArray = fusionDescriptor.split(":");
+		if (fusionArray.length ==2){
+			numericalLocantsOfChild = Arrays.asList(fusionArray[0].split(","));
+			numericalLocantsOfParent = Arrays.asList(fusionArray[1].split(","));
+		}
+		else{
+			throw new StructureBuildingException("Malformed fusion bracket: This is an OPSIN bug, check regexTokens.xml");
+		}
+		processHigherOrderFusionDescriptors(nextComponent, fusedRing, numericalLocantsOfChild, numericalLocantsOfParent);//fuse the rings
+	}
+
+	/**
+	 * Performs a single ring fusion using the values in numericalLocantsOfChild/numericalLocantsOfParent
+	 * @param childRing
+	 * @param parentRing
+	 * @param numericalLocantsOfChild
+	 * @param numericalLocantsOfParent
+	 * @throws StructureBuildingException
+	 */
+	private void processHigherOrderFusionDescriptors(Fragment childRing, Fragment parentRing, List<String> numericalLocantsOfChild, List<String> numericalLocantsOfParent) throws StructureBuildingException {
+		List<Atom> childAtoms =determineAtomsToFuse(childRing, numericalLocantsOfChild, null);
+		if (childAtoms ==null){
+			throw new StructureBuildingException("Malformed fusion bracket!");
+		}
+
+		List<Atom> parentAtoms = determineAtomsToFuse(parentRing, numericalLocantsOfParent, childAtoms.size());
+		if (parentAtoms ==null){
+			throw new StructureBuildingException("Malformed fusion bracket!");
+		}
+		fuseRings(childAtoms, parentAtoms);
+	}
+
+	/**
+	 * Determines which atoms on a ring should be used for fusion given a set of numerical locants.
+	 * If from the other ring involved in the fusion it is known how many atoms are expected to be found this should be provided
+	 * If this is not known it should be set to null and the smallest number of fusion atoms will be returned.
+	 * @param ring
+	 * @param numericalLocantsOnRing
+	 * @param expectedNumberOfAtomsToBeUsedForFusion
+	 * @return
+	 * @throws StructureBuildingException
+	 */
+	private List<Atom> determineAtomsToFuse(Fragment ring, List<String> numericalLocantsOnRing, Integer expectedNumberOfAtomsToBeUsedForFusion) throws StructureBuildingException {
+		List<Atom> parentPeripheralAtomList = getPeripheralAtoms(ring.getAtomList());
+		String firstLocant = numericalLocantsOnRing.get(0);
+		String lastLocant = numericalLocantsOnRing.get(numericalLocantsOnRing.size() - 1);
+		int indexfirst = parentPeripheralAtomList.indexOf(ring.getAtomByLocantOrThrow(firstLocant));
+		if (indexfirst == -1) {
+			throw new StructureBuildingException(firstLocant + " refers to an atom that is not a peripheral atom!");
+		}
+		int indexfinal = parentPeripheralAtomList.indexOf(ring.getAtomByLocantOrThrow(lastLocant));
+		if (indexfinal == -1) {
+			throw new StructureBuildingException(lastLocant + " refers to an atom that is not a peripheral atom!");
+		}
+		CyclicAtomList cyclicRingAtomList = new CyclicAtomList(parentPeripheralAtomList, indexfirst);
+		List<Atom> fusionAtoms = null;
+		
+		List<Atom> potentialFusionAtomsAscending = new ArrayList<>();
+		potentialFusionAtomsAscending.add(cyclicRingAtomList.getCurrent());
+		while (cyclicRingAtomList.getIndex() != indexfinal){//assume numbers are ascending
+			potentialFusionAtomsAscending.add(cyclicRingAtomList.next());
+		}
+		if (expectedNumberOfAtomsToBeUsedForFusion ==null ||expectedNumberOfAtomsToBeUsedForFusion == potentialFusionAtomsAscending.size()){
+			boolean notInPotentialParentAtoms =false;
+			for (int i =1; i < numericalLocantsOnRing.size()-1 ; i ++){
+				if (!potentialFusionAtomsAscending.contains(ring.getAtomByLocantOrThrow(numericalLocantsOnRing.get(i)))){
+					notInPotentialParentAtoms =true;
+				}
+			}
+			if (!notInPotentialParentAtoms){
+				fusionAtoms = potentialFusionAtomsAscending;
+			}
+		}
+		
+		if (fusionAtoms ==null || expectedNumberOfAtomsToBeUsedForFusion ==null){//that didn't work, so try assuming the numbers are descending
+			cyclicRingAtomList.setIndex(indexfirst);
+			List<Atom> potentialFusionAtomsDescending = new ArrayList<>();
+			potentialFusionAtomsDescending.add(cyclicRingAtomList.getCurrent());
+			while (cyclicRingAtomList.getIndex() != indexfinal){//assume numbers are descending
+				potentialFusionAtomsDescending.add(cyclicRingAtomList.previous());
+			}
+			if (expectedNumberOfAtomsToBeUsedForFusion ==null || expectedNumberOfAtomsToBeUsedForFusion == potentialFusionAtomsDescending.size()){
+				boolean notInPotentialParentAtoms =false;
+				for (int i =1; i < numericalLocantsOnRing.size()-1 ; i ++){
+					if (!potentialFusionAtomsDescending.contains(ring.getAtomByLocantOrThrow(numericalLocantsOnRing.get(i)))){
+						notInPotentialParentAtoms =true;
+					}
+				}
+				if (!notInPotentialParentAtoms){
+					if (fusionAtoms!=null && expectedNumberOfAtomsToBeUsedForFusion ==null){
+						//prefer less fusion atoms
+						if (potentialFusionAtomsDescending.size()< fusionAtoms.size()){
+							fusionAtoms = potentialFusionAtomsDescending;
+						}
+					}
+					else{
+						fusionAtoms = potentialFusionAtomsDescending;
+					}
+				}
+			}
+		}
+		return fusionAtoms;
+	}
+
+	/**
+	 * Creates the bonds required to fuse two rings together.
+	 * The child atoms are recorded as atoms that should be removed later
+	 * @param childAtoms
+	 * @param parentAtoms
+	 * @throws StructureBuildingException
+	 */
+	private void fuseRings(List<Atom> childAtoms, List<Atom> parentAtoms) throws StructureBuildingException {
+		if (parentAtoms.size()!=childAtoms.size()){
+			throw new StructureBuildingException("Problem with fusion descriptors: Parent atoms specified: " + parentAtoms.size() +" Child atoms specified: " + childAtoms.size() + " These should have been identical!");
+		}
+		//replace parent atoms if the atom has already been used in fusion with the original atom
+		//This will occur if fusion has resulted in something resembling a spiro centre e.g. cyclopenta[1,2-b:5,1-b']bis[1,4]oxathiine
+		for (int i = parentAtoms.size() -1; i >=0; i--) {
+			if (atomsToRemoveToReplacementAtom.get(parentAtoms.get(i))!=null){
+				parentAtoms.set(i, atomsToRemoveToReplacementAtom.get(parentAtoms.get(i)));
+			}
+			if (atomsToRemoveToReplacementAtom.get(childAtoms.get(i))!=null){
+				childAtoms.set(i, atomsToRemoveToReplacementAtom.get(childAtoms.get(i)));
+			}
+		}
+		
+		//sync spareValency and check that element type matches
+		for (int i = 0; i < childAtoms.size(); i++) {
+			Atom parentAtom = parentAtoms.get(i);
+			Atom childAtom = childAtoms.get(i);
+			if (childAtom.hasSpareValency()){
+				parentAtom.setSpareValency(true);
+			}
+			if (parentAtom.getElement() != childAtom.getElement()){
+				throw new StructureBuildingException("Invalid fusion descriptor: Heteroatom placement is ambiguous as it is not present in both components of the fusion");
+			}
+			atomsToRemoveToReplacementAtom.put(childAtom, parentAtom);
+		}
+		
+		Set<Bond> fusionEdgeBonds  = new HashSet<>();//these bonds already exist in both the child and parent atoms
+		for (int i = 0; i < childAtoms.size() -1; i++) {
+			fusionEdgeBonds.add(childAtoms.get(i).getBondToAtomOrThrow(childAtoms.get(i+1)));
+			fusionEdgeBonds.add(parentAtoms.get(i).getBondToAtomOrThrow(parentAtoms.get(i+1)));
+		}
+
+		Set<Bond> bondsToAddToParentAtoms = new LinkedHashSet<>();
+		for (Atom childAtom : childAtoms) {
+			for (Bond b : childAtom.getBonds()) {
+				if (!fusionEdgeBonds.contains(b)){
+					bondsToAddToParentAtoms.add(b);
+				}
+			}
+		}
+		
+		Set<Bond> bondsToAddToChildAtoms = new LinkedHashSet<>();
+		for (Atom parentAtom : parentAtoms) {
+			for (Bond b : parentAtom.getBonds()) {
+				if (!fusionEdgeBonds.contains(b)){
+					bondsToAddToChildAtoms.add(b);
+				}
+			}
+		}
+		
+		for (Bond bond : bondsToAddToParentAtoms) {
+			Atom from = bond.getFromAtom();
+			int indiceInChildAtoms = childAtoms.indexOf(from);
+			if (indiceInChildAtoms !=-1){
+				from = parentAtoms.get(indiceInChildAtoms);
+			}
+			Atom to = bond.getToAtom();
+			indiceInChildAtoms = childAtoms.indexOf(to);
+			if (indiceInChildAtoms !=-1){
+				to = parentAtoms.get(indiceInChildAtoms);
+			}
+			state.fragManager.createBond(from, to, 1);
+		}
+
+		for (Bond bond : bondsToAddToChildAtoms) {
+			Atom from = bond.getFromAtom();
+			int indiceInParentAtoms = parentAtoms.indexOf(from);
+			if (indiceInParentAtoms !=-1){
+				from = childAtoms.get(indiceInParentAtoms);
+			}
+			Atom to = bond.getToAtom();
+			indiceInParentAtoms = parentAtoms.indexOf(to);
+			if (indiceInParentAtoms !=-1){
+				to = childAtoms.get(indiceInParentAtoms);
+			}
+			Bond newBond = new Bond(from, to, 1);
+			if (childAtoms.contains(from)){
+				from.addBond(newBond);
+			}
+			else{
+				to.addBond(newBond);
+			}
+		}
+	}
+
+	/**
+	 * Fuse the benzo with the subsequent ring
+	 * Uses locants in front of the benz/benzo group to assign heteroatoms on the now numbered fused ring system
+	 * @param benzoEl
+	 * @param parentEl
+	 * @throws StructureBuildingException
+	 */
+	private void benzoSpecificFusion(Element benzoEl, Element parentEl) throws StructureBuildingException {
+		/*
+		 * Perform the fusion, number it and associate it with the parentEl
+		 */
+		Fragment benzoRing = benzoEl.getFrag();
+		Fragment parentRing = parentEl.getFrag();
+		performSimpleFusion(null, benzoRing , parentRing);
+		state.fragManager.incorporateFragment(benzoRing, parentRing);
+		removeMergedAtoms();
+		FusedRingNumberer.numberFusedRing(parentRing);//numbers the fused ring;
+		Fragment fusedRing =parentRing;
+		setBenzoHeteroatomPositioning(benzoEl, fusedRing);
+	}
+
+	/**
+	 * Checks for locant(s) before benzo and uses these to set 
+	 * @param benzoEl
+	 * @param fusedRing
+	 * @throws StructureBuildingException
+	 */
+	private void setBenzoHeteroatomPositioning(Element benzoEl, Fragment fusedRing) throws StructureBuildingException {
+		Element locantEl = OpsinTools.getPreviousSibling(benzoEl);
+		if (locantEl != null && locantEl.getName().equals(LOCANT_EL)) {
+			String[] locants = locantEl.getValue().split(",");
+			if (locantsCouldApplyToHeteroatomPositions(locants, benzoEl)) {
+				List<Atom> atomList =fusedRing.getAtomList();
+				List<Atom> heteroatoms = new ArrayList<>();
+				List<ChemEl> elementOfHeteroAtom = new ArrayList<>();
+				for (Atom atom : atomList) {//this iterates in the same order as the numbering system
+					if (atom.getElement() != ChemEl.C){
+						heteroatoms.add(atom);
+						elementOfHeteroAtom.add(atom.getElement());
+					}
+				}
+				if (locants.length == heteroatoms.size()){//as many locants as there are heteroatoms to assign
+					//check for special case of a single locant indicating where the group substitutes e.g. 4-benzofuran-2-yl
+					if (!(locants.length == 1 && OpsinTools.getPreviousSibling(locantEl) == null
+							 && ComponentProcessor.checkLocantPresentOnPotentialRoot(state, benzoEl.getParent(), locants[0]))) {
+						for (Atom atom : heteroatoms) {
+							atom.setElement(ChemEl.C);
+						}
+						for (int i=0; i< heteroatoms.size(); i++) {
+							fusedRing.getAtomByLocantOrThrow(locants[i]).setElement(elementOfHeteroAtom.get(i));
+						}
+						locantEl.detach();
+					}
+				}
+				else if (locants.length > 1){
+					throw new StructureBuildingException("Unable to assign all locants to benzo-fused ring or multiplier was mising");
+				}
+			}
+		}
+	}
+
+	private boolean locantsCouldApplyToHeteroatomPositions(String[] locants, Element benzoEl) {
+		if (!locantsAreAllNumeric(locants)) {
+			return false;
+		}
+		List<Element> suffixes = benzoEl.getParent().getChildElements(SUFFIX_EL);
+		int suffixesWithoutLocants = 0;
+		for (Element suffix : suffixes) {
+			if (suffix.getAttribute(LOCANT_ATR)==null){
+				suffixesWithoutLocants++;
+			}
+		}
+		if (locants.length == suffixesWithoutLocants){//In preference locants will be assigned to suffixes rather than to this nomenclature
+			return false;
+		}
+		return true;
+	}
+
+	private boolean locantsAreAllNumeric(String[] locants) {
+		for (String locant : locants) {
+			if (!MATCH_NUMERIC_LOCANT.matcher(locant).matches()){
+				return false;
+			}
+		}
+		return true;
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/FusedRingNumberer.java

@@ -0,0 +1,1849 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * Numbers fusedRings
+ * @author aa593
+ * @author dl387
+ *
+ */
+class FusedRingNumberer {
+	
+	private static final Logger LOG = LogManager.getLogger(FusedRingNumberer.class);
+	private static class RingConnectivityTable {
+		final List<RingShape> ringShapes = new ArrayList<>();
+		final List<Ring> neighbouringRings = new ArrayList<>();
+		final List<Integer> directionFromRingToNeighbouringRing = new ArrayList<>();
+		final List<Ring> usedRings = new ArrayList<>();
+
+		RingConnectivityTable copy(){
+			RingConnectivityTable copy = new RingConnectivityTable();
+			copy.ringShapes.addAll(ringShapes);
+			copy.neighbouringRings.addAll(neighbouringRings);
+			copy.directionFromRingToNeighbouringRing.addAll(directionFromRingToNeighbouringRing);
+			copy.usedRings.addAll(usedRings);
+			return copy;
+		}
+	}
+
+	/**
+	 * Wrapper for a ring of a fused ring system with the shape that ring is currently being treated as having
+	 * @author dl387
+	 *
+	 */
+	private static class RingShape{
+		private final Ring ring;
+		private final FusionRingShape shape;
+		public RingShape(Ring ring, FusionRingShape shape) {
+			this.ring = ring;
+			this.shape = shape;
+		}
+		Ring getRing() {
+			return ring;
+		}
+		FusionRingShape getShape() {
+			return shape;
+		}
+	}
+
+	enum FusionRingShape {
+		enterFromLeftHouse,//5 membered ring
+		enterFromTopLeftHouse,//5 membered ring
+		enterFromTopRightHouse,//5 membered ring
+		enterFromRightHouse,//5 membered ring
+		enterFromLeftSevenMembered,//7 membered ring
+		enterFromTopSevenMembered,//7 membered ring
+		enterFromRightSevenMembered,//7 membered ring
+		enterFromBottomRightSevenMembered,//7 membered ring
+		enterFromBottomLeftSevenMembered,//7 membered ring
+		standard
+	}
+
+	private static class Chain {
+		private final int length;
+		private final int startingX;
+		private final int y;
+
+		Chain(int length, int startingX, int y) {
+			this.length = length;
+			this.startingX = startingX;
+			this.y = y;
+		}
+
+		int getLength() {
+			return length;
+		}
+		int getStartingX() {
+			return startingX;
+		}
+		int getY() {
+			return y;
+		}
+	}
+
+	/**
+	 * Sorts by atomSequences by the IUPAC rules for determining the preferred labelling
+	 * The most preferred will be sorted to the back (0th position)
+	 * @author dl387
+	 *
+	 */
+	private static class SortAtomSequences implements Comparator<List<Atom>> {
+
+	    public int compare(List<Atom> sequenceA, List<Atom> sequenceB){
+	    	if (sequenceA.size() != sequenceB.size()){
+	    		//Error in fused ring building. Identified ring sequences not the same lengths!
+	    		return 0;
+	    	}
+
+	    	int i=0;
+	    	int j=0;
+	    	//Give low numbers for the heteroatoms as a set.
+	    	while(i < sequenceA.size()){
+				Atom atomA=sequenceA.get(i);
+				boolean isAaHeteroatom = atomA.getElement() != ChemEl.C;
+
+
+				//bridgehead carbon do not increment numbering
+				if (!isAaHeteroatom && atomA.getBondCount()>=3){
+					i++;
+					continue;
+				}
+
+				Atom atomB=sequenceB.get(j);
+				boolean isBaHeteroatom =atomB.getElement() != ChemEl.C;
+				if (!isBaHeteroatom && atomB.getBondCount()>=3){
+					j++;
+					continue;
+				}
+
+				if (isAaHeteroatom && !isBaHeteroatom){
+					return -1;
+				}
+				if (isBaHeteroatom && !isAaHeteroatom){
+					return 1;
+				}
+	    		i++;j++;
+	    	}
+
+	    	i=0;
+	    	j=0;
+	    	//Give low numbers for heteroatoms when considered in the order: O, S, Se, Te, N, P, As, Sb, Bi, Si, Ge, Sn, Pb, B, Hg
+	    	while(i < sequenceA.size()){
+				Atom atomA=sequenceA.get(i);
+
+				//bridgehead carbon do not increment numbering
+				if (atomA.getElement() == ChemEl.C && atomA.getBondCount()>=3){
+					i++;
+					continue;
+				}
+
+				Atom atomB=sequenceB.get(j);
+				if (atomB.getElement() == ChemEl.C && atomB.getBondCount()>=3){
+					j++;
+					continue;
+				}
+
+				Integer heteroAtomPriorityA = heteroAtomValues.get(atomA.getElement());
+				int atomAElementValue = heteroAtomPriorityA != null ? heteroAtomPriorityA : 0;
+				
+				Integer heteroAtomPriorityB = heteroAtomValues.get(atomB.getElement());
+				int atomBElementValue = heteroAtomPriorityB != null ? heteroAtomPriorityB : 0;
+
+				if (atomAElementValue > atomBElementValue){
+					return -1;
+				}
+				if (atomAElementValue < atomBElementValue){
+					return 1;
+				}
+				i++;j++;
+	    	}
+
+	    	//Give low numbers to fusion carbon atoms.
+	    	for ( i = 0; i < sequenceA.size(); i++) {
+				Atom atomA=sequenceA.get(i);
+				Atom atomB=sequenceB.get(i);
+				if (atomA.getBondCount()>=3 && atomA.getElement() == ChemEl.C){
+					if (!(atomB.getBondCount()>=3 && atomB.getElement() == ChemEl.C)){
+						return -1;
+					}
+				}
+				if (atomB.getBondCount()>=3 && atomB.getElement() == ChemEl.C){
+					if (!(atomA.getBondCount()>=3 && atomA.getElement() == ChemEl.C)){
+						return 1;
+					}
+				}
+			}
+	    	//Note that any sequences still unsorted at this step will have fusion carbon atoms in the same places
+	    	//which means you can go through both sequences without constantly looking for fusion carbons i.e. the variable j is no longer needed
+
+	    	//Give low numbers to fusion rather than non-fusion atoms of the same heteroelement.
+	    	for (i = 0; i < sequenceA.size(); i++) {
+				Atom atomA=sequenceA.get(i);
+				Atom atomB=sequenceB.get(i);
+				if (atomA.getBondCount()>=3){
+					if (!(atomB.getBondCount()>=3)){
+						return -1;
+					}
+				}
+				if (atomB.getBondCount()>=3){
+					if (!(atomA.getBondCount()>=3)){
+						return 1;
+					}
+				}
+			}
+	    	//TODO consider heteroatoms FR5.4d
+	    	return 0;
+	    }
+	}
+
+	private static final Map<ChemEl, Integer> heteroAtomValues = new EnumMap<>(ChemEl.class);
+	static{
+		//unknown heteroatoms or carbon are given a value of 0
+		heteroAtomValues.put(ChemEl.Hg, 2);
+		heteroAtomValues.put(ChemEl.Tl, 3);
+		heteroAtomValues.put(ChemEl.In, 4);
+		heteroAtomValues.put(ChemEl.Ga, 5);
+		heteroAtomValues.put(ChemEl.Al, 6);
+		heteroAtomValues.put(ChemEl.B, 7);
+		heteroAtomValues.put(ChemEl.Pb, 8);
+		heteroAtomValues.put(ChemEl.Sn, 9);
+		heteroAtomValues.put(ChemEl.Ge, 10);
+		heteroAtomValues.put(ChemEl.Si, 11);
+		heteroAtomValues.put(ChemEl.Bi, 12);
+		heteroAtomValues.put(ChemEl.Sb, 13);
+		heteroAtomValues.put(ChemEl.As, 14);
+		heteroAtomValues.put(ChemEl.P, 15);
+		heteroAtomValues.put(ChemEl.N, 16);
+		heteroAtomValues.put(ChemEl.Te, 17);
+		heteroAtomValues.put(ChemEl.Se, 18);
+		heteroAtomValues.put(ChemEl.S, 19);
+		heteroAtomValues.put(ChemEl.O, 20);
+		heteroAtomValues.put(ChemEl.I, 21);
+		heteroAtomValues.put(ChemEl.Br, 22);
+		heteroAtomValues.put(ChemEl.Cl, 23);
+		heteroAtomValues.put(ChemEl.F, 24);
+	}
+	/*
+	 * The meaning of the integers used is as follows:
+	 *        2
+	 *    3   ^  1
+	 *      \ | /
+	 * +-4 <-   -> 0
+	 *      / | \
+	 *   -3   v  -1
+	 *       -2
+	 *
+	 * They indicate the relative directions between rings
+	 * Possibly enums should be used...
+	 */
+
+	/**
+	 * Numbers the fused ring
+	 * Works reliably for all common ring systems.
+	 * Some complex fused ring systems involving multiple connections to rings with an odd number of edges may still be wrong
+	 * @param fusedRing
+	 * @throws StructureBuildingException
+	 */
+	static void numberFusedRing(Fragment fusedRing) throws StructureBuildingException {
+		List<Ring> rings = SSSRFinder.getSetOfSmallestRings(fusedRing);
+		if (rings.size() <2) {
+			throw new StructureBuildingException("Ring perception system found less than 2 rings within input fragment!");
+		}
+		List<Atom> atomList = fusedRing.getAtomList();
+		setupAdjacentFusedRingProperties(rings);
+		if (!checkRingApplicability(rings)) {
+			for (Atom atom : atomList) {
+				atom.clearLocants();
+			}
+			return;
+		}
+		List<List<Atom>> atomSequences = determinePossiblePeripheryAtomOrders(rings, atomList.size());
+		if (atomSequences.size()==0){
+			for (Atom atom : atomList) {
+				atom.clearLocants();
+			}
+			return;
+		}
+
+		// add missing atoms to each path
+		for (List<Atom> path : atomSequences) {//TODO properly support interior atom labelling
+			for(Atom atom : atomList) {
+				if(!path.contains(atom)) {
+					path.add(atom);
+				}
+			}
+		}
+		// find the preferred numbering scheme then relabel with this scheme
+		Collections.sort(atomSequences, new SortAtomSequences());
+		FragmentTools.relabelLocantsAsFusedRingSystem(atomSequences.get(0));
+		fusedRing.reorderAtomCollection(atomSequences.get(0));
+	}
+
+	/**
+	 * Populates rings with their neighbouring fused rings and the bonds involved
+	 * @param rings
+	 */
+	static void setupAdjacentFusedRingProperties(List<Ring> rings){
+		for (int i = 0, l = rings.size(); i < l; i++) {
+			Ring curRing  = rings.get(i);
+			bondLoop : for (Bond bond : curRing.getBondList()) {		// go through all the bonds for the current ring
+				for (int j = i + 1; j < l; j++) {
+					Ring otherRing = rings.get(j);	
+					if (otherRing.getBondList().contains(bond)) {		// check if this bond belongs to any other ring
+						otherRing.addNeighbour(bond, curRing);
+						curRing.addNeighbour(bond, otherRing);			// if so, then associate the bond with the adjacent ring
+						continue bondLoop;
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Checks that all the rings are of sizes 3-8 or if larger than 8 are involved in 2 or fewer fused bonds
+	 * @param rings
+	 * @return
+	 */
+	private static boolean checkRingApplicability(List<Ring> rings) {
+		for (Ring ring : rings) {
+			if (ring.size() <=2){
+				throw new RuntimeException("Invalid ring size: " +ring.size());
+			}
+			if (ring.size() >8 && ring.getNumberOfFusedBonds() > 2){
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Returns possible enumerations of atoms. Currently Interior atoms are not considered.
+	 * These enumerations will be compliant with rules FR5.1-FR5.3 of the fused ring nomenclature guidelines
+	 * http://www.chem.qmul.ac.uk/iupac/fusedring/FR51.html
+	 * @param rings
+	 * @param atomCountOfFusedRingSystem 
+	 * @return
+	 * @throws StructureBuildingException
+	 */
+	private static List<List<Atom>> determinePossiblePeripheryAtomOrders(List<Ring> rings, int atomCountOfFusedRingSystem) throws StructureBuildingException {
+		List<Ring> tRings = findTerminalRings(rings);
+		if (tRings.size()<1) {
+			throw new RuntimeException("OPSIN bug: Unable to find a terminal ring in fused ring system");
+		}
+		Ring tRing = tRings.get(0);
+		Bond b1 = getStartingNonFusedBond(tRing);
+		if(b1 == null) {
+			throw new RuntimeException("OPSIN Bug: Non-fused bond from terminal ring not found");
+		}
+
+		List<RingConnectivityTable> cts = new ArrayList<>();
+		RingConnectivityTable startingCT = new RingConnectivityTable();
+		cts.add(startingCT);
+		buildRingConnectionTables(tRing, null, 0, b1, b1.getFromAtom(), startingCT, cts);
+		//The preference against fusion to elongated edges is built into the construction of the ring table
+		
+		/* FR 5.1.1/FR 5.1.2 Preferred shapes preferred to distorted shapes */
+		removeCTsWithDistortedRingShapes(cts);
+		//TODO better implement the corner cases of FR 5.1.3-5.1.5
+
+		/* FR-5.2a. Maximum number of rings in a horizontal row */
+		Map<RingConnectivityTable, List<Integer>> horizonalRowDirections = findLongestChainDirections(cts);
+		List<Ring[][]> ringMaps = createRingMapsAlignedAlongGivenhorizonalRowDirections(horizonalRowDirections);
+		/* FR-5.2b-d */
+		return findPossiblePaths(ringMaps, atomCountOfFusedRingSystem);
+	}
+
+	/**
+	 * Finds the rings with the minimum number of fused bonds
+	 * @param rings
+	 * @return
+	 */
+	private static List<Ring> findTerminalRings(List<Ring> rings) {
+		List<Ring> tRings = new ArrayList<>();
+
+		int minFusedBonds = Integer.MAX_VALUE;
+		for (Ring ring : rings){
+			if (ring.getNumberOfFusedBonds() < minFusedBonds) {
+				minFusedBonds = ring.getNumberOfFusedBonds();
+			}
+		}
+
+		for  (Ring ring : rings){
+			if (ring.getNumberOfFusedBonds() == minFusedBonds) {
+				tRings.add(ring);
+			}
+		}
+		return tRings;
+	}
+
+	/**
+	 * Recursive function to create the connectivity table of the rings, for each connection includes both directions
+	 * @param currentRing
+	 * @param previousRing
+	 * @param previousDir
+	 * @param previousBond
+	 * @param atom
+	 * @param ct
+	 * @param cts
+	 * @return
+	 */
+	private static List<RingConnectivityTable> buildRingConnectionTables(Ring currentRing, Ring previousRing, int previousDir, Bond previousBond, Atom atom, RingConnectivityTable ct, List<RingConnectivityTable> cts) {
+		// order atoms and bonds in the ring
+		currentRing.makeCyclicLists(previousBond, atom);
+		List<RingConnectivityTable> generatedCts = new ArrayList<>();
+		List<FusionRingShape> allowedShapes = getAllowedShapesForRing(currentRing, previousBond);
+		if (allowedShapes.size() == 0) {
+			throw new RuntimeException("OPSIN limitation, unsupported ring size in fused ring numbering");
+		}
+		ct.usedRings.add(currentRing);
+		for (int i = allowedShapes.size() - 1; i >=0; i--) {
+			FusionRingShape fusionRingShape = allowedShapes.get(i);
+			RingConnectivityTable currentCT;
+			if (i==0) {
+				currentCT = ct;
+			}
+			else{
+				currentCT = ct.copy();
+				cts.add(currentCT);
+				generatedCts.add(currentCT);
+			}
+			RingShape ringShape = new RingShape(currentRing, fusionRingShape);
+			List<RingConnectivityTable> ctsToExpand = new ArrayList<>();
+			ctsToExpand.add(currentCT);//all the cts to consider, the currentCT and generated clones
+			for (Ring neighbourRing : currentRing.getNeighbours()) {
+				//find the directions between the current ring and all neighbouring rings including the previous ring
+				// this means that the direction to the previous ring will then be known in both directions
+
+				// find direction
+				Bond currentBond = findFusionBond(currentRing, neighbourRing);
+
+				int dir = 0;
+				if (neighbourRing == previousRing) {
+					dir = getOppositeDirection(previousDir);
+				}
+				else {
+					dir = calculateRingDirection(ringShape, previousBond, currentBond, previousDir);
+				}
+				//System.out.println(currentRing +"|" +neighbourRing +"|" +dir +"|" +(neighbourRing==previousRing));
+
+				// place into connectivity table, like graph, rings and their connection
+				for (RingConnectivityTable ctToExpand : ctsToExpand) {
+					ctToExpand.ringShapes.add(ringShape);
+					ctToExpand.neighbouringRings.add(neighbourRing);
+					ctToExpand.directionFromRingToNeighbouringRing.add(dir);
+				}
+				if (!currentCT.usedRings.contains(neighbourRing)) {
+					List<RingConnectivityTable> newCts = new ArrayList<>();
+					for (RingConnectivityTable ctToExpand : ctsToExpand) {
+						Atom a = getAtomFromBond(currentRing, currentBond);
+						List<RingConnectivityTable> generatedDownStreamCts = buildRingConnectionTables(neighbourRing, currentRing, dir, currentBond, a, ctToExpand, cts);
+						newCts.addAll(generatedDownStreamCts);
+					}
+					ctsToExpand.addAll(newCts);
+					generatedCts.addAll(newCts);
+				}
+			}
+		}
+		return generatedCts;
+	}
+
+	/**
+	 * Returns the allowed shapes for the given ring.
+	 * The starting bond is required to assured that elongated bonds do not unnecesarily correspond to fusions
+	 * Currently only 5 membered rings are considered in multiple orientations but the same
+	 * is probably required for 7+ member rings
+	 * @param ring
+	 * @param startingBond
+	 * @return
+	 */
+	private static List<FusionRingShape> getAllowedShapesForRing(Ring ring, Bond startingBond) {
+		List<FusionRingShape> allowedRingShapes = new ArrayList<>();
+		int size = ring.size();
+		if (size==5){
+			List<Bond> fusedBonds = ring.getFusedBonds();
+			int fusedBondCount = fusedBonds.size();
+			if (fusedBondCount==1){
+				allowedRingShapes.add(FusionRingShape.enterFromLeftHouse);
+			}
+			else if (fusedBondCount==2 || fusedBondCount==3 || fusedBondCount==4){
+				List<Integer> distances = new ArrayList<>();//one distance is likely to be 0
+				for (Bond fusedBond : fusedBonds) {
+					distances.add(calculateDistanceBetweenBonds(startingBond, fusedBond, ring));
+				}
+				if (!distances.contains(1)){
+					allowedRingShapes.add(FusionRingShape.enterFromLeftHouse);
+				}
+				if (!distances.contains(4)){
+					allowedRingShapes.add(FusionRingShape.enterFromRightHouse);
+				}
+
+				if (!distances.contains(2)){
+					allowedRingShapes.add(FusionRingShape.enterFromTopLeftHouse);
+				}
+				else if (!distances.contains(3)){
+					allowedRingShapes.add(FusionRingShape.enterFromTopRightHouse);
+				}
+				allowedRingShapes = removeDegenerateRingShapes(allowedRingShapes, distances, 5);
+			}
+			else if (fusedBondCount==5){
+				allowedRingShapes.add(FusionRingShape.enterFromLeftHouse);
+				allowedRingShapes.add(FusionRingShape.enterFromRightHouse);
+				//top left and top right are the same other than position of the elongated bond which will invariably be used anyway
+				allowedRingShapes.add(FusionRingShape.enterFromTopLeftHouse);
+			}
+		}
+		else if (size==7){
+			List<Bond> fusedBonds = ring.getFusedBonds();
+			int fusedBondCount = fusedBonds.size();
+			if (fusedBondCount==1){
+				allowedRingShapes.add(FusionRingShape.enterFromLeftSevenMembered);
+			}
+			else{
+				List<Integer> distances = new ArrayList<>();//one distance is likely to be 0
+				for (Bond fusedBond : fusedBonds) {
+					distances.add(calculateDistanceBetweenBonds(startingBond, fusedBond, ring));
+				}
+				if (!distances.contains(4) && !distances.contains(6)){
+					allowedRingShapes.add(FusionRingShape.enterFromLeftSevenMembered);
+				}
+				if (!distances.contains(1) && !distances.contains(6)){
+					allowedRingShapes.add(FusionRingShape.enterFromTopSevenMembered);
+				}
+				if (!distances.contains(1) && !distances.contains(3)){
+					allowedRingShapes.add(FusionRingShape.enterFromRightSevenMembered);
+				}
+				if (!distances.contains(2) && !distances.contains(4)){
+					allowedRingShapes.add(FusionRingShape.enterFromBottomRightSevenMembered);
+				}
+				if (!distances.contains(3) && !distances.contains(5)){
+					allowedRingShapes.add(FusionRingShape.enterFromBottomLeftSevenMembered);
+				}
+				allowedRingShapes = removeDegenerateRingShapes(allowedRingShapes, distances, 7);
+			}
+		}
+		else{
+			allowedRingShapes.add(FusionRingShape.standard);
+		}
+		return allowedRingShapes;
+	}
+
+	/**
+	 * Removes the ring shapes that for given distances have identical properties
+	 * @param allowedRingShapes
+	 * @param distances
+	 * @param ringSize 
+	 */
+	private static List<FusionRingShape> removeDegenerateRingShapes(List<FusionRingShape> allowedRingShapes, List<Integer> distances, int ringSize) {
+		distances = new ArrayList<>(distances);
+		distances.remove((Integer)0);//remove distance 0 if present, this invariably comes from the starting bond and is not of interest (and breaks getDirectionFromDist)
+		for (int i = allowedRingShapes.size() - 1; i >=0; i--) {
+			FusionRingShape shapeToConsiderRemoving = allowedRingShapes.get(i);
+			for (int j = i - 1; j >=0; j--) {
+				FusionRingShape shapeToCompareWith = allowedRingShapes.get(j);
+				boolean foundDifference = false;
+				for (Integer distance : distances) {
+					if (getDirectionFromDist(shapeToConsiderRemoving, ringSize, distance) != getDirectionFromDist(shapeToCompareWith, ringSize, distance)){
+						foundDifference = true;
+						break;
+					}
+				}
+				if (!foundDifference){
+					allowedRingShapes.remove(i);
+					break;
+				}
+			}
+		}
+
+		return allowedRingShapes;
+	}
+
+	/**
+	 * Calculates the direction of the next ring according to the distance between fusion bonds and the previous direction
+	 * @param ringShape
+	 * @param previousBond
+	 * @param currentBond
+	 * @param previousDir
+	 * @return
+	 */
+	private static int calculateRingDirection(RingShape ringShape, Bond previousBond, Bond currentBond, int previousDir) {
+		// take the ring fused to one from the previous loop step
+		Ring ring = ringShape.getRing();
+		if (ring.getCyclicBondList() == null ) {
+			throw new RuntimeException("OPSIN bug: cyclic bond set should have already been populated");
+		}
+
+		int dist = calculateDistanceBetweenBonds(previousBond, currentBond, ring);
+
+		if (dist == 0) {
+			throw new RuntimeException("OPSIN bug: Distance between bonds is equal to 0");
+		}
+
+		int relativeDir = getDirectionFromDist(ringShape.getShape(), ring.size(), dist);
+		return determineAbsoluteDirectionUsingPreviousDirection(ringShape.getShape(), ring.size(), relativeDir, previousDir);
+	}
+
+	/**
+	 * Given two bonds on a ring returns the distance (in bonds) between them
+	 * @param bond1
+	 * @param bond2
+	 * @param ring
+	 * @return
+	 */
+	private static int calculateDistanceBetweenBonds(Bond bond1, Bond bond2, Ring ring) {
+		List<Bond> cyclicBondList =ring.getCyclicBondList();
+		int previousBondIndice = cyclicBondList.indexOf(bond1);
+		int currentBondIndice = cyclicBondList.indexOf(bond2);
+		if (previousBondIndice==-1 || currentBondIndice==-1){
+			throw new RuntimeException("OPSIN bug: previous and current bond were not present in the cyclic bond list of the current ring");
+		}
+		int ringSize =ring.size();
+		int dist = (ringSize + currentBondIndice - previousBondIndice) % ringSize;
+		return dist;
+	}
+
+	/**
+	 * Uses the ring shape, the ring size and distance between the incoming and outgoing fused bond to determine
+	 * the relative direction between the entry point on the ring and the exit point
+	 * @param fusionRingShape
+	 * @param ringSize
+	 * @param dist
+	 * @return
+	 */
+	private static int getDirectionFromDist(FusionRingShape fusionRingShape, int ringSize, int dist) {
+		int dir=0;
+		if (ringSize == 3) { // 3 member ring
+			if (dist == 1) {
+				dir = -1;
+			}
+			else if (dist == 2) {
+				dir = 1;
+			}
+			else throw new RuntimeException("Impossible distance between bonds for a 3 membered ring");
+		}
+		else if (ringSize == 4) { // 4 member ring
+			if (dist ==1) {
+				dir = -2;
+			}
+			else if (dist == 2) {
+				dir = 0;
+			}
+			else if (dist ==3) {
+				dir = 2;
+			}
+			else throw new RuntimeException("Impossible distance between bonds for a 4 membered ring");
+		}
+		else if (ringSize == 5) { // 5 member ring
+			switch (fusionRingShape) {
+			case enterFromLeftHouse:
+				if (dist ==1){
+					dir = -2;//fusion to an elongated bond
+				}
+				else if (dist ==2){
+					dir = 0;
+				}
+				else if (dist ==3){
+					dir = 1;
+				}
+				else if (dist ==4){
+					dir = 3;
+				}
+				else {
+					throw new RuntimeException("Impossible distance between bonds for a 5 membered ring");
+				}
+				break;
+			case enterFromTopLeftHouse:
+				if (dist ==1){
+					dir = -3;
+				}
+				else if (dist ==2){
+					dir = -1;//fusion to an elongated bond
+				}
+				else if (dist ==3){
+					dir = 1;
+				}
+				else if (dist ==4){
+					dir = 3;
+				}
+				else {
+					throw new RuntimeException("Impossible distance between bonds for a 5 membered ring");
+				}
+				break;
+			case enterFromTopRightHouse:
+				if (dist ==1){
+					dir = -3;
+				}
+				else if (dist ==2){
+					dir = -1;
+				}
+				else if (dist ==3){
+					dir = 1;//fusion to an elongated bond
+				}
+				else if (dist ==4){
+					dir = 3;
+				}
+				else {
+					throw new RuntimeException("Impossible distance between bonds for a 5 membered ring");
+				}
+				break;
+			case enterFromRightHouse:
+				if (dist ==1){
+					dir = -3;
+				}
+				else if (dist ==2){
+					dir = -1;
+				}
+				else if (dist ==3){
+					dir = 0;
+				}
+				else if (dist ==4){
+					dir = 2;//fusion to an elongated bond
+				}
+				else {
+					throw new RuntimeException("Impossible distance between bonds for a 5 membered ring");
+				}
+				break;
+			default :
+				throw new RuntimeException("OPSIN Bug: Unrecognised fusion ring shape for 5 membered ring");
+			}
+		}
+		else if (ringSize == 7) { // 7 member ring
+			switch (fusionRingShape) {
+			case enterFromLeftSevenMembered:
+				if (dist ==1){
+					dir = -3;
+				}
+				else if (dist ==2){
+					dir = -1;
+				}
+				else if (dist ==3){
+					dir = 0;
+				}
+				else if (dist ==4){
+					dir = 1;//fusion to an abnormally angled bond
+				}
+				else if (dist ==5){
+					dir = 2;
+				}
+				else if (dist ==6){
+					dir = 3;//fusion to an abnormally angled bond
+				}
+				else {
+					throw new RuntimeException("Impossible distance between bonds for a 7 membered ring");
+				}
+				break;
+			case enterFromTopSevenMembered:
+				if (dist ==1){
+					dir = -3;//fusion to an abnormally angled bond
+				}
+				else if (dist ==2){
+					dir = -2;
+				}
+				else if (dist ==3){
+					dir = -1;
+				}
+				else if (dist ==4){
+					dir = 1;
+				}
+				else if (dist ==5){
+					dir = 2;
+				}
+				else if (dist ==6){
+					dir = 3;//fusion to an abnormally angled bond
+				}
+				else {
+					throw new RuntimeException("Impossible distance between bonds for a 7 membered ring");
+				}
+				break;
+			case enterFromRightSevenMembered:
+				if (dist ==1){
+					dir = -3;//fusion to an abnormally angled bond
+				}
+				else if (dist ==2){
+					dir = -2;
+				}
+				else if (dist ==3){
+					dir = -1;//fusion to an abnormally angled bond
+				}
+				else if (dist ==4){
+					dir = 0;
+				}
+				else if (dist ==5){
+					dir = 1;
+				}
+				else if (dist ==6){
+					dir = 3;
+				}
+				else {
+					throw new RuntimeException("Impossible distance between bonds for a 7 membered ring");
+				}
+				break;
+			case enterFromBottomRightSevenMembered:
+				if (dist ==1){
+					dir = -3;
+				}
+				else if (dist ==2){
+					dir = -2;//fusion to an abnormally angled bond
+				}
+				else if (dist ==3){
+					dir = -1;
+				}
+				else if (dist ==4){
+					dir = 0;//fusion to an abnormally angled bond
+				}
+				else if (dist ==5){
+					dir = 1;
+				}
+				else if (dist ==6){
+					dir = 3;
+				}
+				else {
+					throw new RuntimeException("Impossible distance between bonds for a 7 membered ring");
+				}
+				break;
+			case enterFromBottomLeftSevenMembered:
+				if (dist ==1){
+					dir = -3;
+				}
+				else if (dist ==2){
+					dir = -1;
+				}
+				else if (dist ==3){
+					dir = 0;//fusion to an abnormally angled bond
+				}
+				else if (dist ==4){
+					dir = 1;
+				}
+				else if (dist ==5){
+					dir = 2;//fusion to an abnormally angled bond
+				}
+				else if (dist ==6){
+					dir = 3;
+				}
+				else {
+					throw new RuntimeException("Impossible distance between bonds for a 7 membered ring");
+				}
+				break;
+			default:
+				throw new RuntimeException("OPSIN Bug: Unrecognised fusion ring shape for 7 membered ring");
+			}
+		}
+		else if (ringSize % 2 == 0) {//general case even number of atoms ring (a 6 membered ring or distortion of)
+			if (dist == 1) {
+				dir = -3;
+			}
+			else if (dist == ringSize-1) {
+				dir = 3;
+			}
+			else {
+				dir = dist - ringSize/2;
+				if (Math.abs(dir) > 2 && ringSize >= 8){// 8 and more neighbours
+					dir = -2 * Integer.signum(dir);
+				}
+			}
+		}
+		else {// general case odd number of atoms ring (distortion of an even numbered ring by insertion of one atom).
+			if (dist == 1) {
+				dir = -3;
+			}
+			else if (dist == ringSize/2 || dist == ringSize/2 + 1) {//0 in both cases as effectively we are using a different depiction of the ring system. See FR-5.1.1 (this is done to give the longest horizontal row)
+				dir = 0;
+			}
+			else if (dist == ringSize-1) {
+				dir = 3;
+			}
+			else if(dist < ringSize/2) {
+				dir = -2;
+			}
+			else if(dist > ringSize/2+1) {
+				dir = 2;
+			}
+			else{
+				throw new RuntimeException("OPSIN Bug: Unable to determine direction between odd number of atoms ring and next ring");
+			}
+		}
+		return dir;
+	}
+
+	private static void removeCTsWithDistortedRingShapes(List<RingConnectivityTable> cts) {
+		Map<RingConnectivityTable, List<Integer>> ctToDistortedRings = new HashMap<>();
+		for (RingConnectivityTable ct : cts) {
+			List<Integer> distortedRingSizes = new ArrayList<>();
+			ctToDistortedRings.put(ct, distortedRingSizes);
+			List<RingShape> ringShapes = ct.ringShapes;
+			for (int i = 0; i < ringShapes.size(); i++) {
+				Ring r1 = ringShapes.get(i).getRing();
+				Ring r2 = ct.neighbouringRings.get(i);
+				for (int j = i +1; j < ringShapes.size(); j++) {
+					if (ringShapes.get(j).getRing().equals(r2) && ct.neighbouringRings.get(j).equals(r1)){//look for the reverse entry in the ring connection table
+						int expectedDir = getOppositeDirection(ct.directionFromRingToNeighbouringRing.get(i));
+						if (expectedDir != ct.directionFromRingToNeighbouringRing.get(j)){
+							distortedRingSizes.add(r2.size());
+						}
+					}
+				}
+			}
+		}
+		int minDistortedRings = Integer.MAX_VALUE;//find the minimum number of distorted rings
+		for (List<Integer> distortedRingSizes : ctToDistortedRings.values()) {
+			if (distortedRingSizes.size() < minDistortedRings){
+				minDistortedRings = distortedRingSizes.size();
+			}
+		}
+		for (int i = cts.size()-1; i>=0; i--) {
+			if (ctToDistortedRings.get(cts.get(i)).size()>minDistortedRings){
+				cts.remove(i);
+			}
+		}
+	}
+
+	/**
+	 * Given a list of cts find the longest chain of rings in a line. This can be used to find a possible horizontal row
+	 * The output is a map between the connection tables and the directions which give the longest chains
+	 * Some cts may have no directions that give a chain of rings of this length
+	 *
+	 * @param cts
+	 * @return
+	 */
+	private static Map<RingConnectivityTable, List<Integer>> findLongestChainDirections(List<RingConnectivityTable> cts){
+		Map<RingConnectivityTable, List<Integer>> horizonalRowDirections = new LinkedHashMap<>();
+		int maxChain = 0;
+		for (RingConnectivityTable ct : cts) {
+			if (ct.ringShapes.size() != ct.neighbouringRings.size() || ct.neighbouringRings.size() != ct.directionFromRingToNeighbouringRing.size()) {
+				throw new RuntimeException("OPSIN Bug: Sizes of arrays in fused ring numbering connection table are not equal");
+			}
+			int ctEntriesSize = ct.ringShapes.size();
+			List<Integer> directions = new ArrayList<>();
+			horizonalRowDirections.put(ct, directions);
+
+			for (int i = 0; i < ctEntriesSize; i++) {
+				Ring neighbour = ct.neighbouringRings.get(i);
+				int curChain = 1;
+				int curDir = ct.directionFromRingToNeighbouringRing.get(i);
+
+				nextRingInChainLoop: for (int k = 0; k <= ct.usedRings.size(); k++) {//<= rather than < so buggy behaviour can be caught
+					int indexOfNeighbour = indexOfCorrespondingRingshape(ct.ringShapes, neighbour);
+
+					if (indexOfNeighbour >= 0) {
+						for (int j = indexOfNeighbour; j < ctEntriesSize; j++) {
+							if (ct.ringShapes.get(j).getRing() == neighbour && ct.directionFromRingToNeighbouringRing.get(j) == curDir) {
+								curChain++;
+								neighbour = ct.neighbouringRings.get(j);
+								continue nextRingInChainLoop;
+							}
+						}
+					}
+					else{
+						throw new RuntimeException("OPSIN bug: fused ring numbering: Ring missing from connection table");
+					}
+					if (curChain >= maxChain ) {
+						int oDir = getOppositeDirection(curDir);
+						if(curChain > maxChain){//new longest chain found
+							for (List<Integer> previousDirections: horizonalRowDirections.values()) {
+								previousDirections.clear();
+							}
+						}
+						// if we has this direction before or its opposite, it is the same orientation
+						if(curChain > maxChain || (!directions.contains(curDir) && !directions.contains(oDir))) {
+							directions.add(curDir);
+						}
+						maxChain = curChain;
+					}
+					break;
+				}
+				if (maxChain > ct.usedRings.size()){
+					throw new RuntimeException("OPSIN bug: fused ring layout contained a loop: more rings in a chain than there were rings!");
+				}
+			}
+		}
+		return horizonalRowDirections;
+	}
+
+	/**
+	 * Given a list of ringShapes finds the indice of the ringShape corresponding to the given ring
+	 * returns -1 if this is not possible
+	 * @param ringShapes
+	 * @param ring
+	 * @return
+	 */
+	private static int indexOfCorrespondingRingshape(List<RingShape> ringShapes, Ring ring) {
+		for (int i = 0; i < ringShapes.size(); i++) {
+			if (ringShapes.get(i).getRing().equals(ring)){
+				return i;
+			}
+		}
+		return -1;
+	}
+	
+	
+	/**
+	 * For each RingConnectivityTable and for each horizontal row direction creates a ringMap aligned along the given horizontal row direction
+	 * @param horizonalRowDirectionsMap
+	 * @return
+	 * @throws StructureBuildingException
+	 */
+	private static List<Ring[][]> createRingMapsAlignedAlongGivenhorizonalRowDirections(Map<RingConnectivityTable, List<Integer>> horizonalRowDirectionsMap) throws StructureBuildingException {
+		List<Ring[][]> ringMaps = new ArrayList<>();
+		for (Entry<RingConnectivityTable, List<Integer>> entry : horizonalRowDirectionsMap.entrySet()) {
+			RingConnectivityTable ct = entry.getKey();
+			if ( ct.ringShapes.size() != ct.neighbouringRings.size() || ct.neighbouringRings.size() != ct.directionFromRingToNeighbouringRing.size() || ct.ringShapes.size() <= 0) {
+				throw new RuntimeException("OPSIN Bug: Sizes of arrays in fused ring numbering connection table are not equal");
+			}
+			int ctEntriesSize = ct.ringShapes.size();
+			for (Integer horizonalRowDirection : entry.getValue()) {
+				int[] directionFromRingToNeighbouringRing = new int[ctEntriesSize];
+				// turn the ring system such as to be aligned along the horizonalRowDirection
+				for(int i=0; i<ctEntriesSize; i++){
+					RingShape ringShape = ct.ringShapes.get(i);
+					directionFromRingToNeighbouringRing[i] = determineAbsoluteDirectionUsingPreviousDirection(ringShape.getShape(), ringShape.getRing().size(), ct.directionFromRingToNeighbouringRing.get(i), -horizonalRowDirection);
+				}
+				Ring[][] ringMap = generateRingMap(ct, directionFromRingToNeighbouringRing);
+				if (ringMap !=null){//null if overlapping bonds rings present
+					ringMaps.add(ringMap);
+				}
+			}
+		}
+		if (ringMaps.size()==0){
+			throw new StructureBuildingException("Fused ring systems with overlapping rings such as in helices cannot currently be numbered");
+		}
+		return ringMaps;
+	}
+
+	/**
+	 * Applies FR5.2 B, C and D to determine the preferred orientation and returns lists of potential peripheral atom orderings
+	 * @param ringMaps
+	 * @param atomCountOfFusedRingSystem 
+	 * @return
+	 */
+	private static List<List<Atom>> findPossiblePaths(List<Ring[][]> ringMaps, int atomCountOfFusedRingSystem){
+		List<Double[]> chainQs = new ArrayList<>();
+		List<Ring[][]> correspondingRingMap = new ArrayList<>();
+		for (Ring[][] ringMap : ringMaps) {
+			List<Chain> chains = findChainsOfMaximumLengthInHorizontalDir(ringMap);
+			// For each chain count the number of rings in each quadrant
+			for (Chain chain : chains) {
+				int midChainXcoord = chain.getLength() + chain.getStartingX() - 1;//Remember the X axis is measured in 1/2s so don't need to 1/2 length
+
+				Double[] qs = countQuadrants(ringMap, midChainXcoord, chain.getY());
+				chainQs.add(qs);
+				correspondingRingMap.add(ringMap);
+			}
+		}
+
+		/*
+		 * The quadrant numbers are as follows:
+		 *
+		 *  1  |  0
+		 * ----+----
+		 *  2  |  3
+		 *
+		 *  But at this stage it is not known what the mapping between these numbers and the/a preferred orientation of the structure is
+		 */
+		//  order for each right corner candidates for each chain
+		List<List<Integer>> allowedUpperRightQuadrantsForEachChain =rulesBCD(chainQs);
+
+		List<List<Atom>> paths = new ArrayList<> ();
+		for (int c=0; c < chainQs.size(); c++) {
+			Ring[][] ringMap = correspondingRingMap.get(c);
+			List<Integer> allowedUpperRightQuadrants = allowedUpperRightQuadrantsForEachChain.get(c);
+
+			for (Integer upperRightQuadrant : allowedUpperRightQuadrants) {
+				Ring[][] qRingMap = transformQuadrantToUpperRightOfRingMap(ringMap, upperRightQuadrant);
+				if (LOG.isTraceEnabled()){
+					debugRingMap(qRingMap);
+				}
+				boolean inverseAtoms = (upperRightQuadrant == 2 || upperRightQuadrant == 0);
+				List<Atom> peripheralAtomPath = orderAtoms(qRingMap, inverseAtoms, atomCountOfFusedRingSystem);
+				paths.add(peripheralAtomPath);
+			}
+		}
+
+		return paths;
+	}
+
+	private static Ring[][] generateRingMap(RingConnectivityTable ct, int[] directionFromRingToNeighbouringRing) {
+		int ctEntriesSize = ct.ringShapes.size();
+		// Find max and min coordinates for ringMap
+		// we put the first ring into takenRings to start with it in the connection table
+		int nRings = ct.usedRings.size();
+		int[][] coordinates = new int[nRings][]; // correspondent to usedRings
+		Ring[] takenRings = new Ring[nRings];
+		int takenRingsCnt = 0;
+		int maxX = 0;
+		int minX = 0;
+		int maxY = 0;
+		int minY = 0;
+
+		takenRings[takenRingsCnt++] = ct.ringShapes.get(0).getRing();
+		coordinates[0] = new int[]{0,0};
+
+		// Go through the rings in a system
+		// Find the rings connected to them and assign coordinates according to the direction
+		// Each time we go to the ring, whose coordinates were already identified.
+		for(int tr=0; tr<nRings-1; tr++) {
+			Ring currentRing = takenRings[tr];
+			if (currentRing == null){
+				throw new RuntimeException("OPSIN bug: Unexpected null ring in fused ring numbering");
+			}
+
+			int indexOfCurrentRing = indexOfCorrespondingRingshape(ct.ringShapes, currentRing);
+
+			int xy[] = coordinates[tr]; // find the correspondent coordinates for the ring
+
+			if (indexOfCurrentRing >= 0) {
+				for (int j=indexOfCurrentRing; j< ctEntriesSize; j++) {
+					if (ct.ringShapes.get(j).getRing() == currentRing) {
+						Ring neighbour = ct.neighbouringRings.get(j);
+						if (arrayContains(takenRings, neighbour)) {
+							continue;
+						}
+
+						int[] newXY = new int[2];
+						newXY[0] = xy[0] + Math.round(2 * countDX(directionFromRingToNeighbouringRing[j]));
+						newXY[1] = xy[1] + countDY(directionFromRingToNeighbouringRing[j]);
+
+						if(takenRingsCnt > takenRings.length) {
+							throw new RuntimeException("OPSIN Bug: Fused ring numbering bug");
+						}
+						takenRings[takenRingsCnt] = neighbour;
+						coordinates[takenRingsCnt] = newXY;
+						takenRingsCnt++;
+
+						if (newXY[0] > maxX){
+							maxX = newXY[0];
+						}
+						else if (newXY[0] < minX) {
+							minX = newXY[0];
+						}
+
+						if (newXY[1] > maxY){
+							maxY = newXY[1];
+						}
+						else if (newXY[1] < minY) {
+							minY = newXY[1];
+						}
+					}
+				}
+			}
+			else{
+				throw new RuntimeException("OPSIN bug: fused ring numbering: Ring missing from connection table");
+			}
+		}
+		// the height and the width of the map
+		int h = maxY - minY + 1;
+		int w = maxX - minX + 1;
+
+		Ring[][] ringMap = new Ring[w][h];
+
+		// Map rings using coordinates calculated in the previous step, and transform them according to found minX and minY
+
+		int ix = -minX;
+		int iy = -minY;
+		if (ix >= w || iy >= h) {
+			throw new RuntimeException("OPSIN Bug: Fused ring numbering bug, Coordinates have been calculated wrongly");
+		}
+
+		int curX = 0;
+		int curY = 0;
+		for (int ti = 0; ti < takenRings.length; ti++){
+			int[] xy = coordinates[ti];
+			curX = xy[0] - minX;
+			curY = xy[1] - minY;
+			if(curX <0 || curX > w || curY < 0 || curY > h) {
+				throw new RuntimeException("OPSIN Bug: Fused ring numbering bug, Coordinates have been calculated wrongly");
+			}
+			if (ringMap[curX][curY] != null){
+				return null;
+			}
+			ringMap[curX][curY] = takenRings[ti];
+		}
+		return ringMap;
+	}
+
+	/**
+	 * Finds all the chains of maximum length for the current direction
+	 * @param ringMap
+	 * @return
+	 */
+	private static List<Chain> findChainsOfMaximumLengthInHorizontalDir(Ring[][] ringMap){
+		int w = ringMap.length;
+		int h = ringMap[0].length;
+
+		List<Chain> chains = new ArrayList<>();
+
+		int maxChain = 0;
+		int chain = 0;
+
+		// Find the longest chain
+		for (int j=0; j<h; j++)	{
+			for (int i=0; i<w; i++)	 {
+				if(ringMap[i][j] != null) {
+					chain = 1;
+					while(i + 2*chain < w && ringMap[i + 2*chain][j] != null ) {
+						chain++; // *2 because along the x axis the step is 2
+					}
+					if (chain > maxChain){
+						chains.clear();
+						maxChain = chain;
+					}
+					if(chain >= maxChain) {
+						chains.add(new Chain(chain, i, j));
+					}
+					i += 2*chain;
+				}
+			}
+		}
+		return chains;
+	}
+
+	/**
+	 * Counts number of rings in each quadrant
+	 * @param ringMap
+	 * @param midChainXcoord
+	 * @param yChain
+	 * @return
+	 */
+	private static Double[] countQuadrants(Ring[][] ringMap, int midChainXcoord, int yChain){
+		Double[] qs = new Double[4];
+		qs[0] = 0d;
+		qs[1] = 0d;
+		qs[2] = 0d;
+		qs[3] = 0d;
+		int w = ringMap.length;
+		int h = ringMap[0].length;
+
+		// Count rings in each quadrants
+		for (int x=0; x<w; x++)	 {
+			for (int y=0; y<h; y++)	{
+				if (ringMap[x][y] == null) {
+					continue;
+				}
+
+				if (x == midChainXcoord || y == yChain ) {// if the ring is on the axis
+					if( x == midChainXcoord && y > yChain ) {
+						qs[0]+=0.5;
+						qs[1]+=0.5;
+					}
+					else if( x == midChainXcoord && y < yChain ) {
+						qs[2]+=0.5;
+						qs[3]+=0.5;
+					}
+					else if( x < midChainXcoord && y == yChain ) {
+						qs[1]+=0.5;
+						qs[2]+=0.5;
+					}
+					else if( x > midChainXcoord && y == yChain ) {
+						qs[0]+=0.5;
+						qs[3]+=0.5;
+					}
+					if (x==midChainXcoord && y==yChain ){
+						qs[0]+=0.25;
+						qs[1]+=0.25;
+						qs[2]+=0.25;
+						qs[3]+=0.25;
+					}
+				}
+				else if(x > midChainXcoord && y > yChain) {
+					qs[0]++;
+				}
+				else if(x < midChainXcoord && y > yChain) {
+					qs[1]++;
+				}
+				else if(x < midChainXcoord && y < yChain) {
+					qs[2]++;
+				}
+				else if(x > midChainXcoord && y < yChain) {
+					qs[3]++;
+				}
+			}
+		}
+
+		return qs;
+	}
+
+	/**
+	 * Applying rules FR5.2 B, C and D to the ring system.
+	 * Return a list of possible upper right quadrants for each chain given. A chain may have multiple possible upper right quadrants (due to symmetry)
+	 * or none if other chains can be shown to be preferable by application of the rules
+	 * @param chainQs - array with number of ring in each quadrant for each chain.
+	 */
+	private static List<List<Integer>> rulesBCD(List<Double[]> chainQs) {
+		List<List<Integer>> possibleUpperRightQuadrantsForEachChain = new ArrayList<>();
+		int nChains = chainQs.size();
+		if (nChains==0){
+			throw new RuntimeException("OPSIN Bug: Fused ring numbering, no chains found?");
+		}
+
+		// Rule B: Maximum number of rings in upper right quadrant. Upper right corner candidates (it is not at this stage known which quadrant is the upper right one)
+		double qmax = 0;
+
+		for (Double[] chainQ : chainQs) {
+			for (int j = 0; j < 4; j++)	{
+				Double q = chainQ[j];
+				if(q > qmax) {
+					qmax = q;
+				}
+			}
+		}
+
+		for (Double[] chainQ : chainQs) {
+			List<Integer> allowedUpperRightQuadrants = new ArrayList<>();
+			for (int j = 0; j < 4; j++){
+				if (chainQ[j] == qmax) {
+					allowedUpperRightQuadrants.add(j);
+				}
+			}
+			possibleUpperRightQuadrantsForEachChain.add(allowedUpperRightQuadrants);
+		}
+
+		// Rule C: Minimum number of rings in lower left quadrant
+		double qmin = Double.MAX_VALUE;
+
+		for (int c = 0; c < nChains; c++) {
+			List<Integer> possibleUpperRightQuadrant = possibleUpperRightQuadrantsForEachChain.get(c);
+			for (Integer upperRightQuad : possibleUpperRightQuadrant) {
+				int qdiagonal = (upperRightQuad + 2) % 4;
+				if (chainQs.get(c)[qdiagonal] < qmin){
+					qmin = chainQs.get(c)[qdiagonal];
+				}
+			}
+		}
+		for (int c = 0; c < nChains; c++) {
+			List<Integer> possibleUpperRightQuadrant = possibleUpperRightQuadrantsForEachChain.get(c);
+			List<Integer> allowedUpperRightQuadrants = new ArrayList<>();
+			for (Integer upperRightQuad : possibleUpperRightQuadrant) {
+				int qdiagonal = (upperRightQuad + 2) % 4;
+				if (chainQs.get(c)[qdiagonal]==qmin) {
+					allowedUpperRightQuadrants.add(upperRightQuad);
+				}
+			}
+			possibleUpperRightQuadrantsForEachChain.set(c, allowedUpperRightQuadrants);
+		}
+
+		// Rule D: Maximum number of rings above the horizontal row
+		double rMax = 0;
+		for (int c = 0; c < nChains; c++) {
+			List<Integer> possibleUpperRightQuadrant = possibleUpperRightQuadrantsForEachChain.get(c);
+			for (Integer upperRightQuad : possibleUpperRightQuadrant) {
+				int upperLeftQuad;
+				if (upperRightQuad % 2 == 0) {
+					upperLeftQuad = upperRightQuad + 1;
+				}
+				else {
+					upperLeftQuad = upperRightQuad - 1;
+				}
+
+				if (chainQs.get(c)[upperLeftQuad] + chainQs.get(c)[upperRightQuad] > rMax) {
+					rMax = chainQs.get(c)[upperLeftQuad] + chainQs.get(c)[upperRightQuad];
+				}
+			}
+		}
+		for (int c = 0; c < nChains; c++) {
+			List<Integer> possibleUpperRightQuadrant = possibleUpperRightQuadrantsForEachChain.get(c);
+			List<Integer> allowedUpperRightQuadrants = new ArrayList<>();
+			for (Integer upperRightQuad : possibleUpperRightQuadrant) {
+				int upperLeftQuad;
+				if (upperRightQuad % 2 == 0) {
+					upperLeftQuad = upperRightQuad + 1;
+				}
+				else {
+					upperLeftQuad = upperRightQuad - 1;
+				}
+
+				if (chainQs.get(c)[upperLeftQuad] + chainQs.get(c)[upperRightQuad] == rMax) {
+					allowedUpperRightQuadrants.add(upperRightQuad);
+				}
+			}
+			possibleUpperRightQuadrantsForEachChain.set(c, allowedUpperRightQuadrants);
+		}
+		return possibleUpperRightQuadrantsForEachChain;
+	}
+
+	/**
+	 * Enumerates the peripheral atoms in a system in accordance with FR-5.3:
+	 * First finds the uppermost right ring, takes the next neighbour in the clockwise direction, and so on until the starting atom is reached
+	 * @param ringMap
+	 * @param inverseAtoms The direction in which the periphery atoms should be enumerated. Anticlockwise by default
+	 * @param atomCountOfFusedRingSystem 
+	 * @return
+	 */
+	private static List<Atom> orderAtoms(Ring[][] ringMap, boolean inverseAtoms, int atomCountOfFusedRingSystem){
+		int w = ringMap.length;
+		int h = ringMap[0].length;
+
+		// find upper right ring
+		Ring upperRightRing = null;
+		for (int i=w-1; i>=0; i--) {
+			if (ringMap[i][h-1] != null) {
+				upperRightRing = ringMap[i][h-1];
+				break;
+			}
+		}
+		if (upperRightRing == null) {
+			throw new RuntimeException("OPSIN Bug: Upper right ring not found when performing fused ring numbering");
+		}
+		List<Ring> visitedRings = new ArrayList<>();
+		visitedRings.add(upperRightRing);
+		while (isEntirelyFusionAtoms(upperRightRing)){//c.f cyclopropa[de]anthracene
+			upperRightRing = findClockwiseRingFromUpperRightRing(ringMap, upperRightRing, visitedRings);
+			if (upperRightRing==null){
+				throw new RuntimeException("OPSIN Bug: Unabled to find clockwise ring without fusion atoms");
+			}
+			visitedRings.add(upperRightRing);
+		}
+
+		Ring prevRing = findUpperLeftNeighbourOfUpperRightRing(ringMap, upperRightRing);
+		Bond prevBond = findFusionBond(upperRightRing, prevRing);
+		Bond nextBond = null;
+
+		Ring currentRing = upperRightRing;
+		Ring nextRing = null;
+		List<Atom> atomPath = new ArrayList<>();
+		int count = 0;
+		mainLoop: for (; count <= atomCountOfFusedRingSystem; count++) {
+			int ringSize = currentRing.size();
+
+			int startingBondIndex = currentRing.getBondIndex(prevBond) ;
+
+			List<Bond> cyclicBonds = currentRing.getCyclicBondList();
+			List<Bond> fusedBonds = currentRing.getFusedBonds();
+			if (!inverseAtoms) {
+				for(int bondIndex = 0; bondIndex < ringSize; bondIndex++) {
+					int i = (startingBondIndex + bondIndex + 1) % ringSize; // +1 because we start from the bond next to stBond and end with it
+					// if this bond is fused then it indicates the next ring to move to
+					Bond bond = cyclicBonds.get(i);
+					if(fusedBonds.contains(bond)) {
+						nextBond = bond;
+						break;
+					}
+				}
+			}
+			else {
+				for(int bondIndex = 0; bondIndex < ringSize; bondIndex++) {
+					int i = (startingBondIndex - bondIndex -1 + ringSize) % ringSize; // -1 because we start from the bond next to stBond and end with it
+					// if this bond is fused then it indicates the next ring to move to
+					Bond bond = cyclicBonds.get(i);
+					if(fusedBonds.contains(bond)) {
+						nextBond = bond;
+						break;
+					}
+				}
+			}
+			if (nextBond == null) {
+				throw new RuntimeException("OPSIN Bug: None of the bonds from this ring were fused, but this is not possible ");
+			}
+
+			// next ring
+			nextRing = currentRing.getNeighbourOfFusedBond(nextBond);
+
+			int endNumber = currentRing.getBondIndex(nextBond) ;
+
+			// Add atoms in order, considering inverse or not inverse
+			if (!inverseAtoms) {
+				// if distance between prev bond and cur bond = 1 (it means that fused bonds are next to each other) i.e. come under interior atom numbering
+				// we don't add that atom, cause it was added already
+				if ( (endNumber - startingBondIndex + ringSize) % ringSize != 1) {
+					startingBondIndex = (startingBondIndex + 1) % ringSize;
+					endNumber = (endNumber - 1 + ringSize ) % ringSize;
+					if (startingBondIndex > endNumber) {
+						endNumber += ringSize;
+					}
+
+					// start from the atom next to fusion
+					for (int j = startingBondIndex; j <= endNumber; j++) {
+						Atom atom = currentRing.getCyclicAtomList().get(j % ringSize);
+						if (atomPath.contains(atom)) {
+							break mainLoop;
+						}
+						atomPath.add(atom);
+					}
+				}
+			}
+			else {
+				if ( ( startingBondIndex - endNumber + ringSize) % ringSize != 1) {
+					startingBondIndex = (startingBondIndex - 2 + ringSize ) % ringSize;
+					endNumber = endNumber % ringSize;
+					if (startingBondIndex < endNumber) {
+						startingBondIndex += ringSize;
+					}
+
+					for (int j = startingBondIndex; j >= endNumber; j-- ) {
+						Atom atom = currentRing.getCyclicAtomList().get(j % ringSize);
+						if (atomPath.contains(atom)) {
+							break mainLoop;
+						}
+						atomPath.add(atom);
+					}
+				}
+			}
+			prevBond = nextBond;
+			prevRing = currentRing;
+			currentRing = nextRing;
+		}
+		if (count ==atomCountOfFusedRingSystem){
+			throw new RuntimeException("OPSIN Bug: Fused ring numbering may have been stuck in an infinite loop while enumerating peripheral numbering");
+		}
+		return atomPath;
+	}
+
+	private static boolean isEntirelyFusionAtoms(Ring upperRightRing) {
+		List<Atom> atomList = upperRightRing.getAtomList();
+		for (Atom atom : atomList) {
+			if (atom.getBondCount() < 3){
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Finds the neighbour ring, which is the clockwise of the given ring.
+	 * @param ringMap
+	 * @param upperRightRing
+	 * @param visitedRings 
+	 * @return
+	 */
+	private static Ring findClockwiseRingFromUpperRightRing (Ring[][] ringMap, Ring upperRightRing, List<Ring> visitedRings){
+		Ring clockwiseRing = null;
+		int maxX = 0;
+		int maxY = 0;
+
+		for (Ring ring : upperRightRing.getNeighbours()) {
+			if (visitedRings.contains(ring)){
+				continue;
+			}
+			int xy[] = findRingPosition(ringMap, ring);
+			if (xy==null) {
+				throw new RuntimeException("OPSIN Bug: Ring not found in ringMap when performing fused ring numbering");
+			}
+
+			if (xy[0] > maxX  ||  xy[0] == maxX && xy[1] > maxY ) {
+				maxX = xy[0];
+				maxY = xy[1];
+				clockwiseRing = ring;
+			}
+		}
+		return clockwiseRing;
+	}
+
+	/**
+	 * Finds the neighbour ring, which is the uppermost and on the left side from the given ring. Used to find previous bond for the uppermost right ring, from which we start to enumerate
+	 * @param ringMap
+	 * @param upperRightRing
+	 * @return
+	 */
+	private static Ring findUpperLeftNeighbourOfUpperRightRing (Ring[][] ringMap, Ring upperRightRing){
+		Ring nRing = null;
+		int minX = Integer.MAX_VALUE;
+		int maxY = 0;
+
+		for (Ring ring : upperRightRing.getNeighbours()) {
+			// upper left would be previous ring
+			int xy[] = findRingPosition(ringMap, ring);
+			if (xy==null) {
+				throw new RuntimeException("OPSIN Bug: Ring not found in ringMap when performing fused ring numbering");
+			}
+
+			if (xy[1] > maxY  ||  xy[1] == maxY && xy[0] < minX ) {
+				minX = xy[0];
+				maxY = xy[1];
+				nRing = ring;
+			}
+		}
+		return nRing;
+	}
+
+	/**
+	 * Finds the position(i,j) of the ring in the map
+	 * @param ringMap
+	 * @param ring
+	 * @return
+	 */
+	private static int[] findRingPosition(Ring[][] ringMap, Ring ring) {
+		int w = ringMap.length;
+		int h = ringMap[0].length;
+
+		for(int i=0; i<w; i++) {
+			for(int j=0; j<h; j++) {
+				if (ringMap[i][j] == ring) {
+					return new int[]{i,j};
+				}
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Transform the map such that the candidate upper right quadrant actually is in the upper right corner
+	 * @param ringMap
+	 * @param upperRightQuadrant
+	 * @return
+	 */
+	private static Ring[][] transformQuadrantToUpperRightOfRingMap(Ring[][] ringMap, int upperRightQuadrant){
+		int w = ringMap.length;
+		int h = ringMap[0].length;
+
+		Ring[][] rearrangedMap = new Ring[w][h];
+		for (int i=0; i < w; i++) {
+			for (int j=0; j < h; j++) {
+				if (upperRightQuadrant == 0) {//already is in the upper right
+					rearrangedMap[i][j] = ringMap[i][j];
+				}
+				if(upperRightQuadrant == 1) {//flip in y axis
+					rearrangedMap[w-i-1][j] = ringMap[i][j];
+				}
+				else if(upperRightQuadrant == 2) {//flip in x and y axes
+					rearrangedMap[w-i-1][h-j-1] = ringMap[i][j];
+				}
+				else if(upperRightQuadrant == 3) {//flip in x axis
+					rearrangedMap[i][h-j-1] = ringMap[i][j];
+				}
+			}
+		}
+
+		return rearrangedMap;
+	}
+
+	/**
+	 * Checks if array contains an object
+	 * @param array
+	 * @param obj
+	 * @return
+	 */
+	private static boolean arrayContains(Object[] array, Object obj) {
+		for (Object arrObj : array) {
+			if (arrObj == obj) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Returns a bond which is not a bond that is in two rings
+	 * Preference is given to a bond that is at least a bond away from a fused bond to avoid problems with 5 member rings starting in bad orientations
+	 * @param tRing
+	 * @return
+	 */
+	private static Bond getStartingNonFusedBond(Ring tRing){
+		List<Bond> allBonds = new ArrayList<>(tRing.getBondList());
+		for (Bond fusedBond : tRing.getFusedBonds()) {
+			List<Bond> neighbouringBonds = fusedBond.getFromAtom().getBonds();
+			for (Bond bond : neighbouringBonds) {
+				allBonds.remove(bond);
+			}
+			neighbouringBonds = fusedBond.getToAtom().getBonds();
+			for (Bond bond : neighbouringBonds) {
+				allBonds.remove(bond);
+			}
+		}
+		if (allBonds.size() > 0){
+			return allBonds.get(0);
+		}
+		for (Bond bond : tRing.getBondList()) {
+			if(tRing.getNeighbourOfFusedBond(bond) == null){
+				// return a non-fused bond
+				return bond;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Given the direction of the bond from ring1 to ring2, returns the opposite direction: from ring2 to ring1
+	 * @param prevDir
+	 * @return
+	 */
+	static int getOppositeDirection(int prevDir) {
+		int dir;
+		if (prevDir == 0) {
+			dir = 4;
+		}
+		else if (Math.abs(prevDir) == 4){
+			dir =0;
+		}
+		else if (Math.abs(prevDir) == 2){
+			dir = 2 * -1 * Integer.signum(prevDir);
+		}
+		else if (Math.abs(prevDir) == 1){
+			dir = 3 * -1 * Integer.signum(prevDir);
+		}
+		else {//prevDir will be +-3
+			dir = 1 * -1 * Integer.signum(prevDir);
+		}
+		return dir;
+	}
+
+	/**
+	 * Finds the atom connected to the bond, takes into account the order of the bonds and atoms in the ring
+	 * @param ring
+	 * @param curBond
+	 * @return
+	 */
+	private static Atom getAtomFromBond(Ring ring, Bond curBond) {
+		if (ring.getCyclicBondList() == null) {
+			throw new RuntimeException("The cyclic bond list should already have been generated");
+		}
+		int bondIndice= ring.getCyclicBondList().indexOf(curBond);
+		int atomIndice = ( bondIndice - 1 + ring.size() ) % ring.size();
+		return ring.getCyclicAtomList().get(atomIndice);
+	}
+
+	/**
+	 * Finds the fusion bond between 2 rings
+	 * @param r1
+	 * @param r2
+	 * @return
+	 */
+	private static Bond findFusionBond (Ring r1, Ring r2) {
+		List<Bond> b2 = r2.getBondList();
+		for(Bond bond : r1.getBondList()){
+			if (b2.contains(bond)) {
+				return bond;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Counts delta x distance between previous and next rings
+	 * @param val
+	 * @return
+	 */
+	private static float countDX (int val) {
+		float dX = 0;
+		if (Math.abs(val) == 1) {
+			dX += 0.5f;
+		}
+		else if (Math.abs(val) == 3) {
+			dX -= 0.5f;
+		}
+		else if (Math.abs(val) == 0) {
+			dX += 1f;
+		}
+		else if (Math.abs(val) == 4) {
+			dX -= 1f;
+		}
+		return dX;
+	}
+
+	/**
+	 * Counts delta y distance (height) between previous and next rings
+	 * @param val
+	 * @return
+	 */
+
+	private static int countDY (int val) {
+		int dY = 0;
+		if (Math.abs(val) != 4) {
+			if (val > 0) {
+				dY = 1;
+			}
+			if (val < 0) {
+				dY = -1;
+			}
+		}
+		return dY;
+	}
+
+	/**
+	 * Take into account the previous direction to convert the given relative direction into a direction that is absolute for the fused ring system
+	 * @param fusionRingShape
+	 * @param ringSize
+	 * @param relativeDirection
+	 * @param previousDir
+	 * @return
+	 */
+	static int determineAbsoluteDirectionUsingPreviousDirection(FusionRingShape fusionRingShape, int ringSize, int relativeDirection, int previousDir){
+		int interimDirection;
+		if (Math.abs(previousDir) == 4) {
+			if (relativeDirection == 0) {
+				interimDirection = 4;
+			}
+			else {
+				interimDirection = relativeDirection + 4 * -1 * Integer.signum(relativeDirection); // if dir<0 we add 4, if dir>0 we add -4
+			}
+		}
+		else {
+			interimDirection = relativeDirection + previousDir;
+		}
+		if (Math.abs(interimDirection) > 4) {// Added
+			interimDirection = (8 - Math.abs(interimDirection)) *  Integer.signum(interimDirection) * -1;
+		}
+		//TODO investigate this function and unit test
+		 /* Even numbered rings when angled do not have direction 2.
+		 * Almost true for 5 member except for corner case where fusion to elongated bond occurs
+		 */
+		if (Math.abs(interimDirection) == 2 && ((ringSize % 2 ==0) || ringSize==5 || ringSize==7)) {
+			// if (one of them equal to 1 and another is equal to 3, we decrease absolute value and conserve the sign)
+			if (Math.abs(relativeDirection)==1 && Math.abs(previousDir)==3  ||  Math.abs(relativeDirection)==3 && Math.abs(previousDir)==1) {
+				interimDirection = 1 * Integer.signum(interimDirection);
+			}
+			// if both are equal to 1
+			else if(Math.abs(relativeDirection)==1 && Math.abs(previousDir)==1 ) {
+				interimDirection = 3 * Integer.signum(interimDirection);
+			}
+			// if both are equal to 3
+			else if(Math.abs(relativeDirection)==3 && Math.abs(previousDir)==3 ) {
+				interimDirection = 3 * Integer.signum(interimDirection);
+			}
+			// else it is correctly 2
+		}
+
+		if (interimDirection == -4) {
+			interimDirection = 4;
+		}
+
+		return interimDirection;
+	}
+
+	private static void debugRingMap(Ring[][] ringMap) {
+		Ring[][] yxOrdered = new Ring[ringMap[0].length][ringMap.length];
+		for (int x = 0; x < ringMap.length; x++) {
+			Ring[] yRings = ringMap[x];
+			for (int y = 0; y < yRings.length; y++) {
+				yxOrdered[y][x] =yRings[y];
+			}
+		}
+		for (int y = yxOrdered.length-1; y >=0 ; y--) {
+			Ring[] xRings = yxOrdered[y];
+			StringBuilder sb = new StringBuilder();
+			for (Ring ring : xRings) {
+				if (ring!=null){
+					int size = ring.size();
+					if (size>9){
+						if (size==10){
+							sb.append("0");
+						}
+						else if (size % 2 ==0){
+							sb.append("2");
+						}
+						else{
+							sb.append("1");
+						}
+					}
+					else{
+						sb.append(size);
+					}
+				}
+				else{
+					sb.append(" ");
+				}
+			}
+			LOG.trace(sb.toString());
+		}
+		LOG.trace("#########");
+
+	}
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/GroupingEl.java

@@ -0,0 +1,121 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class GroupingEl extends Element{
+	
+	private final List<Element> children = new ArrayList<>();
+	
+	GroupingEl(String name) {
+		super(name);
+	}
+
+	@Override
+	void addChild(Element child) {
+		child.setParent(this);
+		children.add(child);
+	}
+	
+	@Override
+	Element copy() {
+		GroupingEl copy = new GroupingEl(this.name);
+		for (Element childEl : this.children) {
+			Element newChild = childEl.copy();
+			newChild.setParent(copy);
+			copy.addChild(newChild);
+		}
+		for (int i = 0, len = this.attributes.size(); i < len; i++) {
+			Attribute atr = this.attributes.get(i);
+			copy.addAttribute(new Attribute(atr));
+		}
+		return copy;
+	}
+	
+	@Override
+	Element getChild(int index) {
+		return children.get(index);
+	}
+	
+	@Override
+	int getChildCount() {
+		return children.size();
+	}
+
+	@Override
+	List<Element> getChildElements() {
+		return new ArrayList<>(children);
+	}
+	
+	@Override
+	List<Element> getChildElements(String name) {
+		List<Element> elements = new ArrayList<>(1);
+		for (Element element : children) {
+			if (element.name.equals(name)) {
+				elements.add(element);
+			}
+		}
+		return elements;
+	}
+
+	@Override
+	Element getFirstChildElement(String name) {
+		for (Element child : children) {
+			if (child.getName().equals(name)) {
+				return child;
+			}
+		}
+		return null;
+	}
+
+	String getValue() {
+		int childCount = getChildCount();
+		if (childCount == 0) {
+			return "";
+		}
+		StringBuilder result = new StringBuilder();
+		for (int i = 0; i < childCount; i++) {
+			result.append(children.get(i).getValue());
+		}
+		return result.toString();
+	}
+	
+	@Override
+	int indexOf(Element child) {
+		return children.indexOf(child);
+	}
+
+	@Override
+	void insertChild(Element child, int index) {
+		child.setParent(this);
+		children.add(index, child);
+	}
+
+	@Override
+	boolean removeChild(Element child) {
+		child.setParent(null);
+		return children.remove(child);
+	}
+	
+	@Override
+	Element removeChild(int index) {
+		Element removed = children.remove(index);
+		removed.setParent(null);
+		return removed;
+	}
+	
+	@Override
+	void replaceChild(Element oldChild, Element newChild) {
+		int index = indexOf(oldChild);
+		if (index == -1) {
+			throw new RuntimeException("oldChild is not a child of this element.");
+		}
+		removeChild(index);
+		insertChild(newChild, index);
+	}
+	
+	void setValue(String text) {
+		throw new UnsupportedOperationException("Token groups do not have a value");
+	}
+
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/IDManager.java

@@ -0,0 +1,30 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+/**A source of unique integers. Starts at 1 by default.
+ *
+ * @author ptc24
+ *
+ */
+class IDManager {
+	/**the last integer generated, or 0 at first*/
+	private int currentID;
+
+	int getCurrentID() {
+		return currentID;
+	}
+
+	/**Initialises currentID at zero - will give 1 when first called */
+	IDManager() {
+		currentID = 0;
+	}
+
+	/**Generates a new, unique integer. This is one
+	 * higher than the previous integer, or 1 if previously uncalled.
+	 * @return The generated integer.
+	 */
+	int getNextID() {
+		currentID += 1;
+		return currentID;
+	}
+
+}

TransAntivirus/download_pubchem/opsin-master/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/IndentingXMLStreamWriter.java

@@ -0,0 +1,50 @@
+package uk.ac.cam.ch.wwmm.opsin;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.codehaus.stax2.util.StreamWriterDelegate;
+
+/**
+ * This only overrides the commands actually used by the CmlWriter i.e. it isn't general
+ */
+class IndentingXMLStreamWriter extends StreamWriterDelegate {
+
+	private final int indentSize;
+	private int depth = 0;
+	private boolean atStartOfNewline = false;
+			
+	IndentingXMLStreamWriter(XMLStreamWriter writer, int indentSize) {
+		super(writer);
+		this.indentSize = indentSize;
+	}
+
+	@Override
+	public void writeStartElement(String arg0) throws XMLStreamException {
+		if (!atStartOfNewline){
+			super.writeCharacters(OpsinTools.NEWLINE);
+		}
+		super.writeCharacters(StringTools.multiplyString(" ", depth * indentSize));
+		super.writeStartElement(arg0);
+		atStartOfNewline = false;
+		depth++;
+	}
+	
+	@Override
+	public void writeEndElement() throws XMLStreamException {
+		depth--;
+		if (atStartOfNewline) {
+			super.writeCharacters(StringTools.multiplyString(" ", depth * indentSize));
+		}
+		super.writeEndElement();
+		super.writeCharacters(OpsinTools.NEWLINE);
+		atStartOfNewline = true;
+	}
+	
+	@Override
+	public void writeCharacters(String arg0) throws XMLStreamException {
+		super.writeCharacters(arg0);
+		atStartOfNewline = false;
+	}
+	
+}