Update model on main, checkpoint

README.md

@@ -0,0 +1,43 @@
+---
+license: mit
+datasets:
+  - ZINC-22
+language:
+  - en
+tags:
+  - molecular-generation
+  - drug-discovery
+  - llama
+  - flash-attention
+pipeline_tag: text-generation
+---
+
+# NovoMolGen
+
+NovoMolGen is a family of molecular foundation models trained on 1.5 billion ZINC‑22 molecules using Llama architectures and FlashAttention. It achieves state‑of‑the‑art performance on both unconstrained and goal‑directed molecule generation tasks.
+
+## How to load
+
+```python
+from transformers import AutoTokenizer, AutoModelForCausalLM
+tokenizer = AutoTokenizer.from_pretrained("chandar-lab/NovoMolGen_300M_SMILES_BPE", trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained("chandar-lab/NovoMolGen_300M_SMILES_BPE", trust_remote_code=True)
+```
+
+## Quickstart
+
+```python
+outputs = model.sample(tokenizer=tokenizer, batch_size=4)
+print(outputs['SMILES'])
+```
+
+## Citation
+
+```bibtex
+@article{chitsaz2024novomolgen,
+  title={NovoMolGen: Rethinking Molecular Language Model Pretraining},
+  author={Chitsaz, Kamran and Balaji, Roshan and Fournier, Quentin and Bhatt, Nirav Pravinbhai and Chandar, Sarath},
+  journal={arXiv preprint},
+  year={2025},
+}
+```

config.json

@@ -0,0 +1,35 @@
+{
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "auto_map": {
+    "AutoModelForCausalLM": "modeling_novomolgen.NovoMolGen"
+  },
+  "bos_token_id": 2,
+  "eos_token_id": 3,
+  "fused_bias_fc": false,
+  "fused_dropout_add_ln": false,
+  "fused_mlp": false,
+  "head_dim": 64,
+  "hidden_act": "silu",
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "loss_type": "ForCausalLM",
+  "max_position_embeddings": 2048,
+  "max_seq_length": 64,
+  "mlp_bias": false,
+  "model_type": "llama",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 32,
+  "num_key_value_heads": 12,
+  "pretraining_tp": 1,
+  "residual_in_fp32": true,
+  "rms_norm_eps": 1e-06,
+  "rope_scaling": null,
+  "rope_theta": 10000.0,
+  "tie_word_embeddings": false,
+  "transformers_version": "4.46.2",
+  "use_cache": true,
+  "use_flash_attn": true,
+  "vocab_size": 500
+}

modeling_novomolgen.py

@@ -0,0 +1,341 @@
+import copy
+import json
+import os.path
+import re
+import shutil
+import inspect
+from typing import Optional, Union
+
+import torch
+import torch.nn.functional as F
+from transformers import LlamaConfig
+from transformers.loss.loss_utils import LOSS_MAPPING
+from transformers.modeling_outputs import CausalLMOutput
+from transformers.utils.hub import cached_file, get_checkpoint_shard_files
+from transformers.utils import (
+    SAFE_WEIGHTS_NAME,
+    WEIGHTS_INDEX_NAME,
+    WEIGHTS_NAME,
+)
+from transformers.modeling_utils import unwrap_model, logger
+from functools import partial
+from safetensors.torch import load_file as safe_load_file
+
+try:
+    from flash_attn.models.gpt import GPTLMHeadModel
+except ImportError:
+    GPTLMHeadModel = None
+
+try:
+    from flash_attn.models.llama import llama_config_to_gpt2_config, inv_remap_state_dict_hf_llama
+except ImportError:
+    llama_config_to_gpt2_config = None
+    inv_remap_state_dict_hf_llama = None
+
+
+def state_dict_from_pretrained(model_name, checkpoint_path: str = "", device=None, dtype=None):
+    """
+    code modified from: https://github.com/Dao-AILab/flash-attention/blob/main/flash_attn/utils/pretrained.py
+    """
+
+    # If not fp32, then we don't want to load directly to the GPU
+    mapped_device = "cpu" if dtype not in [torch.float32, None] else device
+    is_sharded = False
+    load_safe = False
+
+    # Try loading from HF hub instead of from local files
+    resolved_archive_file = cached_file(model_name, os.path.join(checkpoint_path, WEIGHTS_NAME),
+                                        _raise_exceptions_for_missing_entries=False)
+    if resolved_archive_file is None:
+        resolved_archive_file = cached_file(model_name, os.path.join(checkpoint_path, WEIGHTS_INDEX_NAME),
+                                            _raise_exceptions_for_missing_entries=False)
+        if resolved_archive_file is not None:
+            is_sharded = True
+
+    if resolved_archive_file is None:
+        raise EnvironmentError(f"Model name {model_name} was not found.")
+
+    if load_safe:
+        loader = partial(safe_load_file, device=mapped_device)
+    else:
+        loader = partial(torch.load, map_location=mapped_device)
+
+    if is_sharded:
+        # resolved_archive_file becomes a list of files that point to the different
+        # checkpoint shards in this case.
+        resolved_archive_file, sharded_metadata = get_checkpoint_shard_files(
+            model_name, resolved_archive_file
+        )
+        state_dict = {}
+        for sharded_file in resolved_archive_file:
+            state_dict.update(loader(sharded_file))
+    else:
+        state_dict = loader(resolved_archive_file)
+    # Convert dtype before moving to GPU to save memory
+    if dtype is not None:
+        state_dict = {k: v.to(dtype=dtype) for k, v in state_dict.items()}
+    state_dict = {k: v.to(device=device) for k, v in state_dict.items()}
+
+    return state_dict
+
+
+class NovoMolGenConfig(LlamaConfig):
+    # model_type = "NovoMolGen"
+
+    def __init__(self,
+                 use_flash_attn: bool = True,
+                 fused_bias_fc: bool = True,
+                 fused_mlp: bool = False,
+                 fused_dropout_add_ln: bool = True,
+                 residual_in_fp32: bool = True,
+                 loss_type: str = 'ForCausalLM',
+                 **kwargs
+                 ):
+        super().__init__(**kwargs)
+        self.use_flash_attn = use_flash_attn
+        self.fused_bias_fc = fused_bias_fc
+        self.fused_mlp = fused_mlp
+        self.fused_dropout_add_ln = fused_dropout_add_ln
+        self.residual_in_fp32 = residual_in_fp32
+        self.loss_type = loss_type
+        self.auto_map = {"AutoModelForCausalLM": "modeling_novomolgen.NovoMolGen"}
+
+    @classmethod
+    def from_pretrained(
+            cls,
+            pretrained_model_name_or_path: Union[str, os.PathLike],
+            checkpoint_path: str = "",
+            cache_dir: Optional[Union[str, os.PathLike]] = None,
+            force_download: bool = False,
+            local_files_only: bool = False,
+            token: Optional[Union[str, bool]] = None,
+            revision: str = "main",
+            **kwargs,
+    ):
+
+        resolved_archive_config_file = cached_file(pretrained_model_name_or_path,
+                                                   os.path.join(checkpoint_path, "config.json"),
+                                                   _raise_exceptions_for_missing_entries=False)
+
+        if resolved_archive_config_file is not None:
+            with open(resolved_archive_config_file, "r", encoding="utf-8") as reader:
+                text = reader.read()
+            config_dict = json.loads(text)
+
+        else:
+            raise EnvironmentError(f"config for {pretrained_model_name_or_path} was not found.")
+
+        if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type:
+            print(
+                f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
+                f"{cls.model_type}. This is not supported for all configurations of models and can yield errors."
+            )
+
+        return cls.from_dict(config_dict, **kwargs)
+
+
+class NovoMolGen(GPTLMHeadModel):
+    def __init__(
+            self,
+            config: NovoMolGenConfig,
+            mol_type: str = "SMILES",
+    ):
+        self.base_config = config
+        self.mol_type = mol_type
+        config = llama_config_to_gpt2_config(config)
+        config.use_flash_attn = self.base_config.use_flash_attn
+        config.fused_bias_fc = self.base_config.fused_bias_fc
+        config.fused_mlp = self.base_config.fused_mlp
+        config.fused_dropout_add_ln = self.base_config.fused_dropout_add_ln
+        config.residual_in_fp32 = self.base_config.residual_in_fp32
+        GPTLMHeadModel.__init__(self, config)
+
+    # TODO: here we ignore attention_mask to make it compatible with HF trainer. The MHA in flash-attention should
+    #  be reimplement and integrate attention_mask like here:
+    #  https://github.com/huggingface/transformers/blob/0864dd3beb238b7bec3528a3d1d6c17a28f51a51/src/transformers/models/llama/modeling_llama.py#L536
+    def forward(self, input_ids, attention_mask: Optional[torch.FloatTensor] = None,
+                labels: Optional[torch.LongTensor] = None, return_dict: Optional[bool] = None,
+                position_ids=None, inference_params=None, num_last_tokens=0, **loss_kwargs):
+        """
+                input_ids: (batch, seqlen) int tensor
+                inference_params: for generation. Adapted from Megatron-LM (and Apex)
+                https://github.com/NVIDIA/apex/blob/3ff1a10f72ec07067c4e44759442329804ac5162/apex/transformer/testing/standalone_transformer_lm.py#L470
+                num_last_tokens: if > 0, only return the logits for the last n tokens
+                """
+        assert (
+                input_ids.ndim == 2
+        ), f"Expected `input_ids` to have shape [b, slen], but got shape {input_ids.shape}"
+        b, slen = input_ids.shape
+        hidden_states = self.transformer(
+            input_ids, position_ids=position_ids, inference_params=inference_params
+        )
+        if inference_params is not None:
+            assert hidden_states.ndim == 3, "sequence_parallel is not supported in generation mode"
+        if num_last_tokens > 0:
+            hidden_states = hidden_states[:, -num_last_tokens:]
+        if self.project_out is not None:
+            hidden_states = self.project_out(hidden_states)
+        if self.output_scale != 1.0:
+            hidden_states = hidden_states * self.output_scale
+        if not self.norm_head:
+            lm_logits = self.lm_head(hidden_states)
+        else:
+            lm_head_weight = F.normalize(self.lm_head.weight)
+            # if isinstance(self.lm_head, ColumnParallelLinear) and self.lm_head.sequence_parallel:
+            #     hidden_states = all_gather(hidden_states, self.lm_head.process_group)
+            lm_logits = F.linear(hidden_states, lm_head_weight, bias=self.lm_head.bias)
+        # During inference, we want the full logit for sampling
+        # if isinstance(self.lm_head, ColumnParallelLinear) and inference_params is not None:
+        #     lm_logits, _ = all_gather_raw(lm_logits, self.lm_head.process_group)
+        #     lm_logits = rearrange(lm_logits, "(n b) ... d -> b ... (n d)", b=b)
+
+        loss = None
+        if labels is not None:
+            loss = self.loss_function(logits=lm_logits, labels=labels, vocab_size=self.base_config.vocab_size,
+                                      **loss_kwargs)
+
+        return CausalLMOutput(
+            loss=loss,
+            logits=lm_logits,
+            hidden_states=hidden_states
+        )
+
+    @property
+    def loss_function(self):
+        if getattr(self.base_config, "loss_type", None) is not None:
+            loss_type = self.base_config.loss_type
+        else:
+            loss_type = self.__class__.__name__
+            if loss_type not in LOSS_MAPPING:
+                loss_groups = f"({'|'.join(LOSS_MAPPING)})"
+                loss_type = re.findall(loss_groups, self.__class__.__name__)
+                if len(loss_type) > 0:
+                    loss_type = loss_type[0]
+                else:
+                    loss_type = None
+        if loss_type is None or loss_type not in LOSS_MAPPING and getattr(self.base_config, "loss_type",
+                                                                          None) is not None:
+            print(
+                f"`loss_type={loss_type}` was set in the base_config but it is unrecognised."
+                f"Using the default loss: `ForCausalLMLoss`."
+            )
+            loss_type = "ForCausalLM"
+        return LOSS_MAPPING[loss_type]
+
+    def save_pretrained(
+            self,
+            save_directory: Union[str, os.PathLike],
+            is_main_process: bool = True,
+            state_dict: Optional[dict] = None,
+            safe_serialization: bool = False,
+            **kwargs,
+    ):
+
+        if safe_serialization:
+            raise ImportError("`safe_serialization` is not implemented yet`.")
+
+        if os.path.isfile(save_directory):
+            logger.error(f"Provided path ({save_directory}) should be a directory, not a file")
+            return
+        os.makedirs(save_directory, exist_ok=True)
+        # Save the config
+        if is_main_process:
+            self.base_config.save_pretrained(save_directory)
+
+        # Save the model
+        if state_dict is None:
+            # Only save the model itself if we are using distributed training
+            model_to_save = unwrap_model(self)
+            state_dict = model_to_save.state_dict()
+
+        weights_name = SAFE_WEIGHTS_NAME if safe_serialization else WEIGHTS_NAME
+        torch.save(state_dict, os.path.join(save_directory, weights_name))
+
+        # find the file where NovoMolGen is defined
+        src = inspect.getsourcefile(type(self))
+        if src:
+            dst = os.path.join(save_directory, os.path.basename(src))
+            shutil.copy(src, dst)
+
+    @classmethod
+    def from_pretrained(
+        cls, 
+        pretrained_model_name_or_path, 
+        checkpoint_path: str = "",
+        config: Optional[Union[NovoMolGenConfig, str, os.PathLike]] = None,
+        **kwargs,
+        ):
+        if config is None:
+            config = NovoMolGenConfig.from_pretrained(pretrained_model_name_or_path, checkpoint_path=checkpoint_path)
+        model = cls(config)
+
+        if os.path.exists(pretrained_model_name_or_path):
+            state_dict = torch.load(os.path.join(pretrained_model_name_or_path, checkpoint_path, WEIGHTS_NAME))
+        else:
+            state_dict = state_dict_from_pretrained(pretrained_model_name_or_path, checkpoint_path=checkpoint_path)
+        model.load_state_dict(state_dict)
+        return model
+
+    def sample(
+            self,
+            tokenizer,
+            batch_size: int = 4,
+            max_length: int = 64,
+            temperature: float = 1.0,
+            top_k: int = 50,
+            top_p: float = 0.95,
+            device: torch.device = torch.device("cuda"),
+    ):
+        """
+        Generate a batch of sequences from the model.
+
+        Returns a dictionary with up to three keys:
+        {
+            "<mol_type>": <list of raw sequences in that moltype>,
+            "sequences": <torch.LongTensor of valid token IDs>
+        }
+        """
+        input_ids = tokenizer.encode("", return_tensors="pt").to(device)
+        # Repeat the prompt for the desired batch size
+        input_ids = input_ids.repeat_interleave(batch_size, dim=0)
+        # If the tokenizer includes an EOS token for an empty prompt, we remove it.
+        if input_ids.shape[1] > 1:
+            input_ids = input_ids[:, :-1]
+
+        generation_output = self.generate(
+            input_ids,
+            max_length=max_length,
+            temperature=temperature,
+            top_k=top_k,
+            top_p=top_p,
+            eos_token_id=tokenizer.eos_token_id,
+            return_dict_in_generate=True,
+        )
+
+        sequences = self._filter_tokens_after_eos(
+            generation_output.sequences, eos_id=tokenizer.eos_token_id
+        )
+
+        decoded_strings = tokenizer.batch_decode(sequences, skip_special_tokens=True)
+        decoded_strings = [s.replace(" ", "") for s in decoded_strings]
+
+        result = {
+            self.mol_type: decoded_strings,
+            "sequences": sequences,
+        }
+        return result
+
+    @staticmethod
+    def _filter_tokens_after_eos(sequences, eos_id):
+        output = copy.deepcopy(sequences)
+        for i in range(sequences.size(0)):
+            row = sequences[i]
+            eos_position = (row == eos_id).nonzero()
+            if eos_position.numel() > 0:
+                eos_position = eos_position[0, 0].item()  # Get the index of the first occurrence
+                output[i, eos_position + 1:] = eos_id
+        return output
+
+    def prepare_inputs_for_generation(self, input_ids, attention_mask=None, **kwargs):
+        # HF’s GenerationMixin would normally do more, but for a basic LM this usually suffices:
+        return {"input_ids": input_ids, "attention_mask": attention_mask}

pytorch_model.bin

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

special_tokens_map.json

@@ -0,0 +1,30 @@
+{
+  "bos_token": {
+    "content": "<bos>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<eos>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<pad>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer.json

@@ -0,0 +1,2456 @@
+{
+  "version": "1.0",
+  "truncation": null,
+  "padding": null,
+  "added_tokens": [
+    {
+      "id": 0,
+      "content": "<unk>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    {
+      "id": 1,
+      "content": "<pad>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    {
+      "id": 2,
+      "content": "<bos>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    {
+      "id": 3,
+      "content": "<eos>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    }
+  ],
+  "normalizer": null,
+  "pre_tokenizer": null,
+  "post_processor": {
+    "type": "TemplateProcessing",
+    "single": [
+      {
+        "SpecialToken": {
+          "id": "<bos>",
+          "type_id": 0
+        }
+      },
+      {
+        "Sequence": {
+          "id": "A",
+          "type_id": 0
+        }
+      },
+      {
+        "SpecialToken": {
+          "id": "<eos>",
+          "type_id": 0
+        }
+      }
+    ],
+    "pair": [
+      {
+        "Sequence": {
+          "id": "A",
+          "type_id": 0
+        }
+      },
+      {
+        "Sequence": {
+          "id": "B",
+          "type_id": 1
+        }
+      }
+    ],
+    "special_tokens": {
+      "<bos>": {
+        "id": "<bos>",
+        "ids": [
+          2
+        ],
+        "tokens": [
+          "<bos>"
+        ]
+      },
+      "<eos>": {
+        "id": "<eos>",
+        "ids": [
+          3
+        ],
+        "tokens": [
+          "<eos>"
+        ]
+      }
+    }
+  },
+  "decoder": {
+    "type": "BPEDecoder",
+    "suffix": "</w>"
+  },
+  "model": {
+    "type": "BPE",
+    "dropout": 0.1,
+    "unk_token": "<unk>",
+    "continuing_subword_prefix": null,
+    "end_of_word_suffix": null,
+    "fuse_unk": false,
+    "byte_fallback": false,
+    "ignore_merges": false,
+    "vocab": {
+      "<unk>": 0,
+      "<pad>": 1,
+      "<bos>": 2,
+      "<eos>": 3,
+      "#": 4,
+      "(": 5,
+      ")": 6,
+      "+": 7,
+      "-": 8,
+      ".": 9,
+      "/": 10,
+      "1": 11,
+      "2": 12,
+      "3": 13,
+      "4": 14,
+      "5": 15,
+      "6": 16,
+      "7": 17,
+      "8": 18,
+      "9": 19,
+      "=": 20,
+      "@": 21,
+      "B": 22,
+      "C": 23,
+      "F": 24,
+      "H": 25,
+      "I": 26,
+      "N": 27,
+      "O": 28,
+      "P": 29,
+      "S": 30,
+      "[": 31,
+      "]": 32,
+      "c": 33,
+      "e": 34,
+      "i": 35,
+      "l": 36,
+      "n": 37,
+      "o": 38,
+      "r": 39,
+      "s": 40,
+      "CC": 41,
+      "O)": 42,
+      "(C": 43,
+      "=O)": 44,
+      "(=O)": 45,
+      "[C": 46,
+      "[C@": 47,
+      "H]": 48,
+      "cc": 49,
+      ")C": 50,
+      "[C@H]": 51,
+      "[C@@": 52,
+      "c1": 53,
+      "C(=O)": 54,
+      "[C@@H]": 55,
+      "(C)": 56,
+      "(=O)N": 57,
+      "NC(=O)": 58,
+      "CCC": 59,
+      "c2": 60,
+      "N(C": 61,
+      "F)": 62,
+      "1CC": 63,
+      "c1cc": 64,
+      "2)": 65,
+      "1C": 66,
+      "(C)C": 67,
+      "N(C(=O)": 68,
+      "(F)": 69,
+      "(C(=O)N": 70,
+      "cn": 71,
+      "2CC": 72,
+      "(CC": 73,
+      ")C1": 74,
+      "2C": 75,
+      "c3": 76,
+      "CC1": 77,
+      "OC": 78,
+      "C(=O)N": 79,
+      "=C": 80,
+      "c2cc": 81,
+      "c(": 82,
+      "NC(=O)C": 83,
+      "n1": 84,
+      "[C@H](": 85,
+      "[n": 86,
+      "[nH]": 87,
+      "[C@@H](": 88,
+      "2)C1": 89,
+      "CC(=O)N": 90,
+      "3)": 91,
+      "CO": 92,
+      "1CCC": 93,
+      "c(C": 94,
+      "C[C@H]": 95,
+      "c1n": 96,
+      "C[C@@H]": 97,
+      "l)": 98,
+      "[C@]": 99,
+      "N(C)C": 100,
+      "CCCC": 101,
+      "[C@@]": 102,
+      "(N": 103,
+      "Cc1cc": 104,
+      "2CCC": 105,
+      "cc1": 106,
+      "nn": 107,
+      "[C@H]1C": 108,
+      ")C2)": 109,
+      "CC(C)": 110,
+      "CCO": 111,
+      "O=C": 112,
+      "N(C(=O)C": 113,
+      "O)C": 114,
+      "c3cc": 115,
+      "c(C(=O)N": 116,
+      "(CNC(=O)": 117,
+      "[C@@H]1C": 118,
+      "CCN": 119,
+      "1)": 120,
+      "[C@H]2C": 121,
+      "c(C)": 122,
+      "ccc1": 123,
+      "c1cn": 124,
+      "3CC": 125,
+      "F)C": 126,
+      "[C@H](C)": 127,
+      "(C)(C)C": 128,
+      "2)C": 129,
+      "[C@@H]2C": 130,
+      "[C@@H](C)": 131,
+      "Br": 132,
+      "(F)(F)": 133,
+      "[C@H]1": 134,
+      "3C": 135,
+      "cs": 136,
+      "c(Cl)": 137,
+      "1)C": 138,
+      "N(C)C(=O)": 139,
+      "[C@H]1CC": 140,
+      "(O)": 141,
+      "c(F)": 142,
+      "(CC(=O)N": 143,
+      ")CC": 144,
+      "[C@@H]1CC": 145,
+      "c2cccc": 146,
+      "1C(=O)": 147,
+      "[C@H](C": 148,
+      "C=C": 149,
+      "=CC": 150,
+      "CCC1": 151,
+      "C1": 152,
+      "ncc": 153,
+      "[C@@H]1": 154,
+      "[C@@H](C": 155,
+      "[C@H]2CC": 156,
+      "Br)": 157,
+      "(NC(=O)": 158,
+      "OCC": 159,
+      "CN": 160,
+      "[C@H](C)C": 161,
+      "3)C": 162,
+      "3)C2)": 163,
+      "c4": 164,
+      "c2cn": 165,
+      "Cc1n": 166,
+      "(C)CC": 167,
+      "2)CC1": 168,
+      "S(=O)": 169,
+      ")C(=O)N": 170,
+      "(Cl)": 171,
+      "=N": 172,
+      "[C@H](NC(=O)": 173,
+      "[C@]1": 174,
+      "c1C": 175,
+      "[C@@H](C)C": 176,
+      "O=C(N": 177,
+      "(C)C)": 178,
+      "[C@H](C(=O)N": 179,
+      "[C@@H](NC(=O)": 180,
+      "(N)": 181,
+      "c2)": 182,
+      "C#": 183,
+      "[C@@H]2CC": 184,
+      "C(=O)N1CC": 185,
+      "c[nH]": 186,
+      "[C@H]2": 187,
+      "[C@@]1": 188,
+      "c1cccc": 189,
+      "n1cc": 190,
+      "c(O)": 191,
+      "OC)": 192,
+      "#N": 193,
+      "co": 194,
+      "nc1": 195,
+      "[C@@H](C(=O)N": 196,
+      "3CCC": 197,
+      "NC": 198,
+      "n2": 199,
+      "(C)(C)": 200,
+      "SC": 201,
+      "c1ccccc1": 202,
+      "[C@@H]2": 203,
+      "c2C": 204,
+      "(CCC": 205,
+      "c2n": 206,
+      "[N": 207,
+      "N1C(=O)": 208,
+      "(F)F)": 209,
+      "COC": 210,
+      "NC(=O)c1cc": 211,
+      "N(C(=O)c2cc": 212,
+      "3)CC": 213,
+      "N1CC": 214,
+      "S(=O)(=O)": 215,
+      "Cc1": 216,
+      "(F)(F)F)": 217,
+      "2C(=O)": 218,
+      "2(CC": 219,
+      "(F)C": 220,
+      "2(C": 221,
+      "=O": 222,
+      "cc2": 223,
+      "+]": 224,
+      "COc1cc": 225,
+      "-]": 226,
+      "[C@H](O)": 227,
+      "F)C1": 228,
+      "n(C)": 229,
+      "1CC1": 230,
+      "[C@@H]1CCC": 231,
+      "[N+]": 232,
+      "c(N": 233,
+      "cn1": 234,
+      "c3cccc": 235,
+      "[C@H]3": 236,
+      "C[C@@H]1C": 237,
+      ")C(=O)": 238,
+      "(N)=O)": 239,
+      "[C@H]1CCC": 240,
+      "c1C(=O)N": 241,
+      "(C(=O)N2CC": 242,
+      "CC(=O)N1CC": 243,
+      "CS": 244,
+      "c(Br)": 245,
+      "[C@@H]3": 246,
+      "s1": 247,
+      "C[C@H]1C": 248,
+      "2CC2)": 249,
+      "[C@H](CC": 250,
+      "c1ncc": 251,
+      "nn1": 252,
+      "[C@@H](O)": 253,
+      "N(C(=O)CC": 254,
+      "[C@H](CNC(=O)": 255,
+      "[O": 256,
+      "[O-]": 257,
+      "N2C(=O)": 258,
+      "COC(=O)": 259,
+      "[C@](C)": 260,
+      "C=": 261,
+      "[C@H](O)C": 262,
+      "c2)C1": 263,
+      "o1": 264,
+      "3)C1": 265,
+      "NC(=O)C1": 266,
+      "CCN1C(=O)": 267,
+      "O=C(C": 268,
+      "#N)": 269,
+      "[C@@](C)": 270,
+      "[C@@H](O)C": 271,
+      "(CO)": 272,
+      "[C@@H](CC": 273,
+      "(=O)[O-]": 274,
+      "[N+](=O)[O-]": 275,
+      "c1)": 276,
+      "CCC(=O)N": 277,
+      "4)C": 278,
+      "[C@]2": 279,
+      "(Br)": 280,
+      "CC2": 281,
+      "(=O)=O)": 282,
+      "[nH]1": 283,
+      "cc1C": 284,
+      "O1": 285,
+      "[C@@]2": 286,
+      "C=CC": 287,
+      "N(": 288,
+      "c(-": 289,
+      "c3cn": 290,
+      "[C@H]3C": 291,
+      "CC(C)(C)C": 292,
+      "(NC(=O)C": 293,
+      "[C@H](NC(=O)C": 294,
+      "cc1C(=O)N": 295,
+      "2)CC": 296,
+      "/C=C": 297,
+      "2)c1": 298,
+      "(CC)": 299,
+      "/C=C/": 300,
+      "[C@@H]2CCC": 301,
+      "[C@H](C)C(=O)N": 302,
+      "c(=N": 303,
+      "[C@@H](CNC(=O)": 304,
+      "NC(=O)CC": 305,
+      "(C(=O)NC": 306,
+      "[C@@H](NC(=O)C": 307,
+      "[C@H]2CCC": 308,
+      "4)": 309,
+      "CC(C)(C)": 310,
+      "c2ncc": 311,
+      "c2ccccc2": 312,
+      "(CNC(=O)C": 313,
+      "N=": 314,
+      "(F)(F)C": 315,
+      "N(CC": 316,
+      "CC(C)C": 317,
+      "OC1": 318,
+      "cccc": 319,
+      "n3": 320,
+      "CCOCC": 321,
+      "(-": 322,
+      "(F)F": 323,
+      ")C2": 324,
+      "c3C": 325,
+      "C[C@@H]1CC": 326,
+      "c(C(=O)N2CC": 327,
+      "CC1)": 328,
+      "Cc1cn": 329,
+      "CCc1cc": 330,
+      "[C@H]3CC": 331,
+      "c(F)cc": 332,
+      "c3n": 333,
+      "[C@@H](C)C(=O)N": 334,
+      "C[C@H]1CC": 335,
+      "[N+](=O)[O-])": 336,
+      "n2cc": 337,
+      "(C)(C)C)": 338,
+      "CCN(C(=O)": 339,
+      "[C@@H]3C": 340,
+      "(C)CCC": 341,
+      "C(=O)NC": 342,
+      "ccc2": 343,
+      "nc2": 344,
+      "=CC(=O)N": 345,
+      "3(CC": 346,
+      "4CC": 347,
+      "1)N": 348,
+      "S(=O)(=O)N": 349,
+      "N2CC": 350,
+      "(O)C": 351,
+      "cnc1": 352,
+      "S(C)": 353,
+      "1)C2": 354,
+      "CCNC(=O)": 355,
+      "l)C": 356,
+      "Cn1": 357,
+      "N(C(=O)c3cc": 358,
+      "[C@H]1C(=O)N": 359,
+      "n2)": 360,
+      "NC(=O)c2cc": 361,
+      "c3ccccc3": 362,
+      "3CC3)": 363,
+      "c2nn": 364,
+      "2)C1)": 365,
+      "[C@@H]1C(=O)N": 366,
+      "(F)(F)F": 367,
+      "COCC": 368,
+      "CC2)": 369,
+      "CCCCC": 370,
+      "c1cs": 371,
+      "C[C@]1": 372,
+      "3)C2)C1": 373,
+      "n1)": 374,
+      "(C)=O)": 375,
+      "O=C(": 376,
+      "CCN(CC": 377,
+      "CCS": 378,
+      "cs1": 379,
+      "F)C(=O)N": 380,
+      "c(C)n": 381,
+      "N(C)": 382,
+      "[C@@H]3CC": 383,
+      "S(C)(=O)=O)": 384,
+      "N(C)C)": 385,
+      "CC1(C)C": 386,
+      "OCC(=O)N": 387,
+      "N(C(=O)C2": 388,
+      "OC(C)(C)C": 389,
+      "CCc1n": 390,
+      "c4cc": 391,
+      "(C(=O)N2C": 392,
+      "N(C(=O)c2": 393,
+      "N1CCC": 394,
+      "C[C@H]2C": 395,
+      "c1ccc(": 396,
+      "C1CC": 397,
+      "3(C": 398,
+      "n1C": 399,
+      "c1ccn": 400,
+      "CCO1": 401,
+      "N1C": 402,
+      "Cc1cccc": 403,
+      "CCOC": 404,
+      "c(Cl)cc": 405,
+      "=CCC": 406,
+      "c2c(": 407,
+      "2)cc1": 408,
+      "[C@H](CNC(=O)C": 409,
+      "N3": 410,
+      "N(C(=O)c2cn": 411,
+      "cnc2": 412,
+      "1)C(=O)N": 413,
+      "c(C(=O)NC": 414,
+      "NC(=O)c1cn": 415,
+      "Cn1cc": 416,
+      "[C@H](CC(=O)N": 417,
+      "c1[nH]": 418,
+      "OC)C": 419,
+      "C[C@@]1": 420,
+      "n2)C1": 421,
+      "cc2C": 422,
+      "O)C1": 423,
+      "2)n1": 424,
+      "(C)C)C": 425,
+      "(C(=O)N2CCC": 426,
+      "O=C(CC": 427,
+      "C#CC": 428,
+      "1)C(=O)": 429,
+      "OC)C(=O)N": 430,
+      "CN(CC": 431,
+      "1CCCC1": 432,
+      "c1ccc(F)": 433,
+      "c(CC(=O)N": 434,
+      "CC(=O)N1C": 435,
+      "c3)": 436,
+      "4C": 437,
+      "c1ccc(C": 438,
+      "CCC2": 439,
+      "c3ncc": 440,
+      "CCOC(=O)": 441,
+      "c(N)": 442,
+      "CC(=O)": 443,
+      "c(=O)": 444,
+      "CN1CC": 445,
+      "Cc1ncc": 446,
+      "c1Cl": 447,
+      "CCn1": 448,
+      "CC[C@H](C)": 449,
+      "C[C@@H]2C": 450,
+      "c(CC": 451,
+      "c(OC)": 452,
+      "(OC)": 453,
+      "NC(=O)c1": 454,
+      "CC(=O)N1CCC": 455,
+      "NC(=O)N": 456,
+      "C(=O)N1C": 457,
+      "CN(C": 458,
+      "C[C@H](C": 459,
+      ")CC1": 460,
+      "c2ccccc2)": 461,
+      "N#": 462,
+      "(C)(C)C(=O)N": 463,
+      "2CCCC": 464,
+      "3)CC1": 465,
+      "ncn": 466,
+      "3)CC2)": 467,
+      "(C#N)": 468,
+      "C[C@@H](C": 469,
+      "c(=N)": 470,
+      "(C)C)C1": 471,
+      "(F)cc": 472,
+      "[C@@H](CNC(=O)C": 473,
+      "[C@H]1CN(C(=O)": 474,
+      "c1ccc(Cl)": 475,
+      "C[C@H]1": 476,
+      "[C@@H]1CN(C(=O)": 477,
+      "(F)(": 478,
+      "CC1CC": 479,
+      "Cc1cc(C(=O)N": 480,
+      "C[C@@H]1": 481,
+      "c(C)c1": 482,
+      "C(=O)N1CCC": 483,
+      "c(C(=O)N2C": 484,
+      "CCCO": 485,
+      "4)CC": 486,
+      "(=N": 487,
+      "2CC2)C1": 488,
+      "(CCNC(=O)": 489,
+      "n[nH]": 490,
+      "cc3": 491,
+      "(O)CC": 492,
+      "2(CCC": 493,
+      "[S": 494,
+      "S(N)": 495,
+      "ccc1C": 496,
+      "N(C)C(=O)C": 497,
+      "F)C2)": 498,
+      "(F)F)C": 499
+    },
+    "merges": [
+      [
+        "C",
+        "C"
+      ],
+      [
+        "O",
+        ")"
+      ],
+      [
+        "(",
+        "C"
+      ],
+      [
+        "=",
+        "O)"
+      ],
+      [
+        "(",
+        "=O)"
+      ],
+      [
+        "[",
+        "C"
+      ],
+      [
+        "[C",
+        "@"
+      ],
+      [
+        "H",
+        "]"
+      ],
+      [
+        "c",
+        "c"
+      ],
+      [
+        ")",
+        "C"
+      ],
+      [
+        "[C@",
+        "H]"
+      ],
+      [
+        "[C@",
+        "@"
+      ],
+      [
+        "c",
+        "1"
+      ],
+      [
+        "C",
+        "(=O)"
+      ],
+      [
+        "[C@@",
+        "H]"
+      ],
+      [
+        "(C",
+        ")"
+      ],
+      [
+        "(=O)",
+        "N"
+      ],
+      [
+        "N",
+        "C(=O)"
+      ],
+      [
+        "CC",
+        "C"
+      ],
+      [
+        "c",
+        "2"
+      ],
+      [
+        "N",
+        "(C"
+      ],
+      [
+        "F",
+        ")"
+      ],
+      [
+        "1",
+        "CC"
+      ],
+      [
+        "c1",
+        "cc"
+      ],
+      [
+        "2",
+        ")"
+      ],
+      [
+        "1",
+        "C"
+      ],
+      [
+        "(C",
+        ")C"
+      ],
+      [
+        "N(C",
+        "(=O)"
+      ],
+      [
+        "(",
+        "F)"
+      ],
+      [
+        "(C",
+        "(=O)N"
+      ],
+      [
+        "c",
+        "n"
+      ],
+      [
+        "2",
+        "CC"
+      ],
+      [
+        "(",
+        "CC"
+      ],
+      [
+        ")C",
+        "1"
+      ],
+      [
+        "2",
+        "C"
+      ],
+      [
+        "c",
+        "3"
+      ],
+      [
+        "CC",
+        "1"
+      ],
+      [
+        "O",
+        "C"
+      ],
+      [
+        "C(=O)",
+        "N"
+      ],
+      [
+        "=",
+        "C"
+      ],
+      [
+        "c2",
+        "cc"
+      ],
+      [
+        "c",
+        "("
+      ],
+      [
+        "NC(=O)",
+        "C"
+      ],
+      [
+        "n",
+        "1"
+      ],
+      [
+        "[C@H]",
+        "("
+      ],
+      [
+        "[",
+        "n"
+      ],
+      [
+        "[n",
+        "H]"
+      ],
+      [
+        "[C@@H]",
+        "("
+      ],
+      [
+        "2",
+        ")C1"
+      ],
+      [
+        "CC",
+        "(=O)N"
+      ],
+      [
+        "3",
+        ")"
+      ],
+      [
+        "C",
+        "O"
+      ],
+      [
+        "1",
+        "CCC"
+      ],
+      [
+        "c",
+        "(C"
+      ],
+      [
+        "C",
+        "[C@H]"
+      ],
+      [
+        "c1",
+        "n"
+      ],
+      [
+        "C",
+        "[C@@H]"
+      ],
+      [
+        "l",
+        ")"
+      ],
+      [
+        "[C@",
+        "]"
+      ],
+      [
+        "N(C",
+        ")C"
+      ],
+      [
+        "CC",
+        "CC"
+      ],
+      [
+        "[C@@",
+        "]"
+      ],
+      [
+        "(",
+        "N"
+      ],
+      [
+        "C",
+        "c1cc"
+      ],
+      [
+        "2",
+        "CCC"
+      ],
+      [
+        "cc",
+        "1"
+      ],
+      [
+        "n",
+        "n"
+      ],
+      [
+        "[C@H]",
+        "1C"
+      ],
+      [
+        ")C",
+        "2)"
+      ],
+      [
+        "CC",
+        "(C)"
+      ],
+      [
+        "CC",
+        "O"
+      ],
+      [
+        "O",
+        "=C"
+      ],
+      [
+        "N(C(=O)",
+        "C"
+      ],
+      [
+        "O)",
+        "C"
+      ],
+      [
+        "c3",
+        "cc"
+      ],
+      [
+        "c",
+        "(C(=O)N"
+      ],
+      [
+        "(C",
+        "NC(=O)"
+      ],
+      [
+        "[C@@H]",
+        "1C"
+      ],
+      [
+        "CC",
+        "N"
+      ],
+      [
+        "1",
+        ")"
+      ],
+      [
+        "[C@H]",
+        "2C"
+      ],
+      [
+        "c",
+        "(C)"
+      ],
+      [
+        "cc",
+        "c1"
+      ],
+      [
+        "c1",
+        "cn"
+      ],
+      [
+        "3",
+        "CC"
+      ],
+      [
+        "F",
+        ")C"
+      ],
+      [
+        "[C@H]",
+        "(C)"
+      ],
+      [
+        "(C)",
+        "(C)C"
+      ],
+      [
+        "2",
+        ")C"
+      ],
+      [
+        "[C@@H]",
+        "2C"
+      ],
+      [
+        "[C@@H]",
+        "(C)"
+      ],
+      [
+        "B",
+        "r"
+      ],
+      [
+        "(F)",
+        "(F)"
+      ],
+      [
+        "[C@H]",
+        "1"
+      ],
+      [
+        "3",
+        "C"
+      ],
+      [
+        "c",
+        "s"
+      ],
+      [
+        "c(C",
+        "l)"
+      ],
+      [
+        "1",
+        ")C"
+      ],
+      [
+        "N(C)C",
+        "(=O)"
+      ],
+      [
+        "[C@H]",
+        "1CC"
+      ],
+      [
+        "(",
+        "O)"
+      ],
+      [
+        "c",
+        "(F)"
+      ],
+      [
+        "(CC",
+        "(=O)N"
+      ],
+      [
+        ")",
+        "CC"
+      ],
+      [
+        "[C@@H]",
+        "1CC"
+      ],
+      [
+        "c2cc",
+        "cc"
+      ],
+      [
+        "1",
+        "C(=O)"
+      ],
+      [
+        "[C@H]",
+        "(C"
+      ],
+      [
+        "C",
+        "=C"
+      ],
+      [
+        "=",
+        "CC"
+      ],
+      [
+        "CCC",
+        "1"
+      ],
+      [
+        "C",
+        "1"
+      ],
+      [
+        "n",
+        "cc"
+      ],
+      [
+        "[C@@H]",
+        "1"
+      ],
+      [
+        "[C@@H]",
+        "(C"
+      ],
+      [
+        "[C@H]",
+        "2CC"
+      ],
+      [
+        "Br",
+        ")"
+      ],
+      [
+        "(",
+        "NC(=O)"
+      ],
+      [
+        "O",
+        "CC"
+      ],
+      [
+        "C",
+        "N"
+      ],
+      [
+        "[C@H]",
+        "(C)C"
+      ],
+      [
+        "3",
+        ")C"
+      ],
+      [
+        "3",
+        ")C2)"
+      ],
+      [
+        "c",
+        "4"
+      ],
+      [
+        "c2",
+        "cn"
+      ],
+      [
+        "C",
+        "c1n"
+      ],
+      [
+        "(C)",
+        "CC"
+      ],
+      [
+        "2)",
+        "CC1"
+      ],
+      [
+        "S",
+        "(=O)"
+      ],
+      [
+        ")C",
+        "(=O)N"
+      ],
+      [
+        "(C",
+        "l)"
+      ],
+      [
+        "=",
+        "N"
+      ],
+      [
+        "[C@H](",
+        "NC(=O)"
+      ],
+      [
+        "[C@]",
+        "1"
+      ],
+      [
+        "c1",
+        "C"
+      ],
+      [
+        "[C@@H]",
+        "(C)C"
+      ],
+      [
+        "O=C",
+        "(N"
+      ],
+      [
+        "(C)C",
+        ")"
+      ],
+      [
+        "[C@H]",
+        "(C(=O)N"
+      ],
+      [
+        "[C@@H](",
+        "NC(=O)"
+      ],
+      [
+        "(N",
+        ")"
+      ],
+      [
+        "c2",
+        ")"
+      ],
+      [
+        "C",
+        "#"
+      ],
+      [
+        "[C@@H]",
+        "2CC"
+      ],
+      [
+        "C(=O)N",
+        "1CC"
+      ],
+      [
+        "c",
+        "[nH]"
+      ],
+      [
+        "[C@H]",
+        "2"
+      ],
+      [
+        "[C@@]",
+        "1"
+      ],
+      [
+        "c1cc",
+        "cc"
+      ],
+      [
+        "n1",
+        "cc"
+      ],
+      [
+        "c(",
+        "O)"
+      ],
+      [
+        "OC",
+        ")"
+      ],
+      [
+        "#",
+        "N"
+      ],
+      [
+        "c",
+        "o"
+      ],
+      [
+        "n",
+        "c1"
+      ],
+      [
+        "[C@@H]",
+        "(C(=O)N"
+      ],
+      [
+        "3",
+        "CCC"
+      ],
+      [
+        "N",
+        "C"
+      ],
+      [
+        "n",
+        "2"
+      ],
+      [
+        "(C)",
+        "(C)"
+      ],
+      [
+        "S",
+        "C"
+      ],
+      [
+        "c1cc",
+        "ccc1"
+      ],
+      [
+        "[C@@H]",
+        "2"
+      ],
+      [
+        "c2",
+        "C"
+      ],
+      [
+        "(",
+        "CCC"
+      ],
+      [
+        "c2",
+        "n"
+      ],
+      [
+        "[",
+        "N"
+      ],
+      [
+        "N",
+        "1C(=O)"
+      ],
+      [
+        "(F)",
+        "F)"
+      ],
+      [
+        "C",
+        "OC"
+      ],
+      [
+        "NC(=O)",
+        "c1cc"
+      ],
+      [
+        "N(C(=O)",
+        "c2cc"
+      ],
+      [
+        "3)",
+        "CC"
+      ],
+      [
+        "N",
+        "1CC"
+      ],
+      [
+        "S(=O)",
+        "(=O)"
+      ],
+      [
+        "C",
+        "c1"
+      ],
+      [
+        "(F)(F)",
+        "F)"
+      ],
+      [
+        "2",
+        "C(=O)"
+      ],
+      [
+        "2",
+        "(CC"
+      ],
+      [
+        "(",
+        "F)C"
+      ],
+      [
+        "2",
+        "(C"
+      ],
+      [
+        "=",
+        "O"
+      ],
+      [
+        "cc",
+        "2"
+      ],
+      [
+        "+",
+        "]"
+      ],
+      [
+        "CO",
+        "c1cc"
+      ],
+      [
+        "-",
+        "]"
+      ],
+      [
+        "[C@H](",
+        "O)"
+      ],
+      [
+        "F",
+        ")C1"
+      ],
+      [
+        "n",
+        "(C)"
+      ],
+      [
+        "1CC",
+        "1"
+      ],
+      [
+        "[C@@H]",
+        "1CCC"
+      ],
+      [
+        "[N",
+        "+]"
+      ],
+      [
+        "c(",
+        "N"
+      ],
+      [
+        "cn",
+        "1"
+      ],
+      [
+        "c3cc",
+        "cc"
+      ],
+      [
+        "[C@H]",
+        "3"
+      ],
+      [
+        "C[C@@H]",
+        "1C"
+      ],
+      [
+        ")C",
+        "(=O)"
+      ],
+      [
+        "(N)",
+        "=O)"
+      ],
+      [
+        "[C@H]",
+        "1CCC"
+      ],
+      [
+        "c1",
+        "C(=O)N"
+      ],
+      [
+        "(C(=O)N",
+        "2CC"
+      ],
+      [
+        "CC(=O)N",
+        "1CC"
+      ],
+      [
+        "C",
+        "S"
+      ],
+      [
+        "c(",
+        "Br)"
+      ],
+      [
+        "[C@@H]",
+        "3"
+      ],
+      [
+        "s",
+        "1"
+      ],
+      [
+        "C[C@H]",
+        "1C"
+      ],
+      [
+        "2CC",
+        "2)"
+      ],
+      [
+        "[C@H]",
+        "(CC"
+      ],
+      [
+        "c1n",
+        "cc"
+      ],
+      [
+        "n",
+        "n1"
+      ],
+      [
+        "[C@@H](",
+        "O)"
+      ],
+      [
+        "N(C(=O)",
+        "CC"
+      ],
+      [
+        "[C@H]",
+        "(CNC(=O)"
+      ],
+      [
+        "[",
+        "O"
+      ],
+      [
+        "[O",
+        "-]"
+      ],
+      [
+        "N",
+        "2C(=O)"
+      ],
+      [
+        "CO",
+        "C(=O)"
+      ],
+      [
+        "[C@]",
+        "(C)"
+      ],
+      [
+        "C",
+        "="
+      ],
+      [
+        "[C@H](",
+        "O)C"
+      ],
+      [
+        "c2",
+        ")C1"
+      ],
+      [
+        "o",
+        "1"
+      ],
+      [
+        "3",
+        ")C1"
+      ],
+      [
+        "NC(=O)C",
+        "1"
+      ],
+      [
+        "CCN",
+        "1C(=O)"
+      ],
+      [
+        "O=C",
+        "(C"
+      ],
+      [
+        "#N",
+        ")"
+      ],
+      [
+        "[C@@]",
+        "(C)"
+      ],
+      [
+        "[C@@H](",
+        "O)C"
+      ],
+      [
+        "(C",
+        "O)"
+      ],
+      [
+        "[C@@H]",
+        "(CC"
+      ],
+      [
+        "(=O)",
+        "[O-]"
+      ],
+      [
+        "[N+]",
+        "(=O)[O-]"
+      ],
+      [
+        "c1",
+        ")"
+      ],
+      [
+        "CC",
+        "C(=O)N"
+      ],
+      [
+        "4",
+        ")C"
+      ],
+      [
+        "[C@]",
+        "2"
+      ],
+      [
+        "(",
+        "Br)"
+      ],
+      [
+        "CC",
+        "2"
+      ],
+      [
+        "(=O)",
+        "=O)"
+      ],
+      [
+        "[nH]",
+        "1"
+      ],
+      [
+        "cc",
+        "1C"
+      ],
+      [
+        "O",
+        "1"
+      ],
+      [
+        "[C@@]",
+        "2"
+      ],
+      [
+        "C",
+        "=CC"
+      ],
+      [
+        "N",
+        "("
+      ],
+      [
+        "c(",
+        "-"
+      ],
+      [
+        "c3",
+        "cn"
+      ],
+      [
+        "[C@H]",
+        "3C"
+      ],
+      [
+        "CC(C)",
+        "(C)C"
+      ],
+      [
+        "(",
+        "NC(=O)C"
+      ],
+      [
+        "[C@H](",
+        "NC(=O)C"
+      ],
+      [
+        "cc1",
+        "C(=O)N"
+      ],
+      [
+        "2)",
+        "CC"
+      ],
+      [
+        "/",
+        "C=C"
+      ],
+      [
+        "2)",
+        "c1"
+      ],
+      [
+        "(CC",
+        ")"
+      ],
+      [
+        "/C=C",
+        "/"
+      ],
+      [
+        "[C@@H]",
+        "2CCC"
+      ],
+      [
+        "[C@H](C)C",
+        "(=O)N"
+      ],
+      [
+        "c(",
+        "=N"
+      ],
+      [
+        "[C@@H]",
+        "(CNC(=O)"
+      ],
+      [
+        "NC(=O)",
+        "CC"
+      ],
+      [
+        "(C(=O)N",
+        "C"
+      ],
+      [
+        "[C@@H](",
+        "NC(=O)C"
+      ],
+      [
+        "[C@H]",
+        "2CCC"
+      ],
+      [
+        "4",
+        ")"
+      ],
+      [
+        "CC(C)",
+        "(C)"
+      ],
+      [
+        "c2",
+        "ncc"
+      ],
+      [
+        "c2cccc",
+        "c2"
+      ],
+      [
+        "(C",
+        "NC(=O)C"
+      ],
+      [
+        "N",
+        "="
+      ],
+      [
+        "(F)",
+        "(F)C"
+      ],
+      [
+        "N",
+        "(CC"
+      ],
+      [
+        "CC",
+        "(C)C"
+      ],
+      [
+        "OC",
+        "1"
+      ],
+      [
+        "cc",
+        "cc"
+      ],
+      [
+        "n",
+        "3"
+      ],
+      [
+        "CCO",
+        "CC"
+      ],
+      [
+        "(",
+        "-"
+      ],
+      [
+        "(F)",
+        "F"
+      ],
+      [
+        ")C",
+        "2"
+      ],
+      [
+        "c3",
+        "C"
+      ],
+      [
+        "C[C@@H]",
+        "1CC"
+      ],
+      [
+        "c(C(=O)N",
+        "2CC"
+      ],
+      [
+        "CC1",
+        ")"
+      ],
+      [
+        "C",
+        "c1cn"
+      ],
+      [
+        "CC",
+        "c1cc"
+      ],
+      [
+        "[C@H]",
+        "3CC"
+      ],
+      [
+        "c(F)",
+        "cc"
+      ],
+      [
+        "c3",
+        "n"
+      ],
+      [
+        "[C@@H](C)C",
+        "(=O)N"
+      ],
+      [
+        "C[C@H]",
+        "1CC"
+      ],
+      [
+        "[N+](=O)[O-]",
+        ")"
+      ],
+      [
+        "n2",
+        "cc"
+      ],
+      [
+        "(C)(C)C",
+        ")"
+      ],
+      [
+        "CC",
+        "N(C(=O)"
+      ],
+      [
+        "[C@@H]",
+        "3C"
+      ],
+      [
+        "(C)",
+        "CCC"
+      ],
+      [
+        "C(=O)N",
+        "C"
+      ],
+      [
+        "cc",
+        "c2"
+      ],
+      [
+        "n",
+        "c2"
+      ],
+      [
+        "=",
+        "CC(=O)N"
+      ],
+      [
+        "3",
+        "(CC"
+      ],
+      [
+        "4",
+        "CC"
+      ],
+      [
+        "1)",
+        "N"
+      ],
+      [
+        "S(=O)",
+        "(=O)N"
+      ],
+      [
+        "N",
+        "2CC"
+      ],
+      [
+        "(",
+        "O)C"
+      ],
+      [
+        "cn",
+        "c1"
+      ],
+      [
+        "S",
+        "(C)"
+      ],
+      [
+        "1)C",
+        "2"
+      ],
+      [
+        "CC",
+        "NC(=O)"
+      ],
+      [
+        "l",
+        ")C"
+      ],
+      [
+        "C",
+        "n1"
+      ],
+      [
+        "N(C(=O)",
+        "c3cc"
+      ],
+      [
+        "[C@H]1",
+        "C(=O)N"
+      ],
+      [
+        "n",
+        "2)"
+      ],
+      [
+        "NC(=O)",
+        "c2cc"
+      ],
+      [
+        "c3cccc",
+        "c3"
+      ],
+      [
+        "3CC",
+        "3)"
+      ],
+      [
+        "c2",
+        "nn"
+      ],
+      [
+        "2)C1",
+        ")"
+      ],
+      [
+        "[C@@H]1",
+        "C(=O)N"
+      ],
+      [
+        "(F)(F)",
+        "F"
+      ],
+      [
+        "CO",
+        "CC"
+      ],
+      [
+        "CC",
+        "2)"
+      ],
+      [
+        "CC",
+        "CCC"
+      ],
+      [
+        "c1",
+        "cs"
+      ],
+      [
+        "C",
+        "[C@]1"
+      ],
+      [
+        "3)C",
+        "2)C1"
+      ],
+      [
+        "n1",
+        ")"
+      ],
+      [
+        "(C)",
+        "=O)"
+      ],
+      [
+        "O=C",
+        "("
+      ],
+      [
+        "CCN",
+        "(CC"
+      ],
+      [
+        "CC",
+        "S"
+      ],
+      [
+        "cs",
+        "1"
+      ],
+      [
+        "F)C",
+        "(=O)N"
+      ],
+      [
+        "c(C)",
+        "n"
+      ],
+      [
+        "N",
+        "(C)"
+      ],
+      [
+        "[C@@H]",
+        "3CC"
+      ],
+      [
+        "S(C)",
+        "(=O)=O)"
+      ],
+      [
+        "N(C)C",
+        ")"
+      ],
+      [
+        "CC1",
+        "(C)C"
+      ],
+      [
+        "O",
+        "CC(=O)N"
+      ],
+      [
+        "N(C(=O)C",
+        "2"
+      ],
+      [
+        "OC",
+        "(C)(C)C"
+      ],
+      [
+        "CC",
+        "c1n"
+      ],
+      [
+        "c4",
+        "cc"
+      ],
+      [
+        "(C(=O)N",
+        "2C"
+      ],
+      [
+        "N(C(=O)",
+        "c2"
+      ],
+      [
+        "N",
+        "1CCC"
+      ],
+      [
+        "C[C@H]",
+        "2C"
+      ],
+      [
+        "c1cc",
+        "c("
+      ],
+      [
+        "C",
+        "1CC"
+      ],
+      [
+        "3",
+        "(C"
+      ],
+      [
+        "n",
+        "1C"
+      ],
+      [
+        "c1cc",
+        "n"
+      ],
+      [
+        "CCO",
+        "1"
+      ],
+      [
+        "N",
+        "1C"
+      ],
+      [
+        "Cc1cc",
+        "cc"
+      ],
+      [
+        "CC",
+        "OC"
+      ],
+      [
+        "c(Cl)",
+        "cc"
+      ],
+      [
+        "=",
+        "CCC"
+      ],
+      [
+        "c2",
+        "c("
+      ],
+      [
+        "2)",
+        "cc1"
+      ],
+      [
+        "[C@H](C",
+        "NC(=O)C"
+      ],
+      [
+        "N",
+        "3"
+      ],
+      [
+        "N(C(=O)",
+        "c2cn"
+      ],
+      [
+        "cn",
+        "c2"
+      ],
+      [
+        "1)C",
+        "(=O)N"
+      ],
+      [
+        "c(C(=O)N",
+        "C"
+      ],
+      [
+        "NC(=O)",
+        "c1cn"
+      ],
+      [
+        "C",
+        "n1cc"
+      ],
+      [
+        "[C@H]",
+        "(CC(=O)N"
+      ],
+      [
+        "c1",
+        "[nH]"
+      ],
+      [
+        "OC",
+        ")C"
+      ],
+      [
+        "C",
+        "[C@@]1"
+      ],
+      [
+        "n",
+        "2)C1"
+      ],
+      [
+        "cc",
+        "2C"
+      ],
+      [
+        "O)C",
+        "1"
+      ],
+      [
+        "2)",
+        "n1"
+      ],
+      [
+        "(C)C",
+        ")C"
+      ],
+      [
+        "(C(=O)N",
+        "2CCC"
+      ],
+      [
+        "O=C",
+        "(CC"
+      ],
+      [
+        "C#",
+        "CC"
+      ],
+      [
+        "1)C",
+        "(=O)"
+      ],
+      [
+        "OC",
+        ")C(=O)N"
+      ],
+      [
+        "CN",
+        "(CC"
+      ],
+      [
+        "1CC",
+        "CC1"
+      ],
+      [
+        "c1cc",
+        "c(F)"
+      ],
+      [
+        "c",
+        "(CC(=O)N"
+      ],
+      [
+        "CC(=O)N",
+        "1C"
+      ],
+      [
+        "c3",
+        ")"
+      ],
+      [
+        "4",
+        "C"
+      ],
+      [
+        "c1cc",
+        "c(C"
+      ],
+      [
+        "CCC",
+        "2"
+      ],
+      [
+        "c3",
+        "ncc"
+      ],
+      [
+        "CCO",
+        "C(=O)"
+      ],
+      [
+        "c(N",
+        ")"
+      ],
+      [
+        "CC",
+        "(=O)"
+      ],
+      [
+        "c",
+        "(=O)"
+      ],
+      [
+        "CN",
+        "1CC"
+      ],
+      [
+        "Cc1n",
+        "cc"
+      ],
+      [
+        "c1C",
+        "l"
+      ],
+      [
+        "CC",
+        "n1"
+      ],
+      [
+        "CC",
+        "[C@H](C)"
+      ],
+      [
+        "C[C@@H]",
+        "2C"
+      ],
+      [
+        "c",
+        "(CC"
+      ],
+      [
+        "c(",
+        "OC)"
+      ],
+      [
+        "(",
+        "OC)"
+      ],
+      [
+        "NC(=O)",
+        "c1"
+      ],
+      [
+        "CC(=O)N",
+        "1CCC"
+      ],
+      [
+        "NC(=O)",
+        "N"
+      ],
+      [
+        "C(=O)N",
+        "1C"
+      ],
+      [
+        "C",
+        "N(C"
+      ],
+      [
+        "C[C@H]",
+        "(C"
+      ],
+      [
+        ")",
+        "CC1"
+      ],
+      [
+        "c2cccc",
+        "c2)"
+      ],
+      [
+        "N",
+        "#"
+      ],
+      [
+        "(C)(C)C",
+        "(=O)N"
+      ],
+      [
+        "2CC",
+        "CC"
+      ],
+      [
+        "3)",
+        "CC1"
+      ],
+      [
+        "n",
+        "cn"
+      ],
+      [
+        "3)CC",
+        "2)"
+      ],
+      [
+        "(C",
+        "#N)"
+      ],
+      [
+        "C[C@@H]",
+        "(C"
+      ],
+      [
+        "c(=N",
+        ")"
+      ],
+      [
+        "(C)C",
+        ")C1"
+      ],
+      [
+        "(F)",
+        "cc"
+      ],
+      [
+        "[C@@H](C",
+        "NC(=O)C"
+      ],
+      [
+        "[C@H]1C",
+        "N(C(=O)"
+      ],
+      [
+        "c1cc",
+        "c(Cl)"
+      ],
+      [
+        "C[C@H]",
+        "1"
+      ],
+      [
+        "[C@@H]1C",
+        "N(C(=O)"
+      ],
+      [
+        "(F)",
+        "("
+      ],
+      [
+        "CC",
+        "1CC"
+      ],
+      [
+        "Cc1cc",
+        "(C(=O)N"
+      ],
+      [
+        "C[C@@H]",
+        "1"
+      ],
+      [
+        "c(C)",
+        "c1"
+      ],
+      [
+        "C(=O)N",
+        "1CCC"
+      ],
+      [
+        "c(C(=O)N",
+        "2C"
+      ],
+      [
+        "CCC",
+        "O"
+      ],
+      [
+        "4",
+        ")CC"
+      ],
+      [
+        "(",
+        "=N"
+      ],
+      [
+        "2CC",
+        "2)C1"
+      ],
+      [
+        "(CC",
+        "NC(=O)"
+      ],
+      [
+        "n",
+        "[nH]"
+      ],
+      [
+        "cc",
+        "3"
+      ],
+      [
+        "(O)",
+        "CC"
+      ],
+      [
+        "2",
+        "(CCC"
+      ],
+      [
+        "[",
+        "S"
+      ],
+      [
+        "S",
+        "(N)"
+      ],
+      [
+        "ccc1",
+        "C"
+      ],
+      [
+        "N(C)C(=O)",
+        "C"
+      ],
+      [
+        "F",
+        ")C2)"
+      ],
+      [
+        "(F)",
+        "F)C"
+      ]
+    ]
+  }
+}

tokenizer_config.json

@@ -0,0 +1,43 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<pad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "<bos>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<eos>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<bos>",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<eos>",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<pad>",
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "unk_token": "<unk>"
+}