Upload benchmark script and set

.gitattributes

@@ -33,3 +33,5 @@ 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
+latent_space_plots/ChemBERTa_latent_interpolation.png filter=lfs diff=lfs merge=lfs -text
+latent_space_plots/FastChemTokenizerHF_latent_interpolation.png filter=lfs diff=lfs merge=lfs -text

benchmark/FastChemTokenizer.py

@@ -0,0 +1,621 @@
+import torch
+import json
+import os
+from typing import List, Union, Optional, Tuple
+from transformers.tokenization_utils_base import BatchEncoding
+from functools import lru_cache
+
+# Copyright 2025 Genta Pramillean Bayu (@gbyuvd)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class TrieNode:
+    __slots__ = ['children', 'token_id']
+    def __init__(self):
+        self.children = {}
+        self.token_id = None  # If set, this node completes a valid token
+
+
+class FastChemTokenizer:
+    def __init__(self, token_to_id, model_max_length=512):
+        self.token_to_id = token_to_id
+        self.id_to_token = {v: k for k, v in token_to_id.items()}
+        # No more self.token_set — replaced by trie
+        self.model_max_length = model_max_length
+
+        # Precompute max token length for possible use & clarity
+        self.max_token_len = max(len(t) for t in token_to_id.keys())
+
+        # Build trie for fast longest-match lookup
+        self.trie_root = self._build_trie(token_to_id)
+
+        # Validate required special tokens
+        required_special_tokens = ["<s>", "</s>", "<pad>", "<unk>", "<mask>"]
+        for tok in required_special_tokens:
+            if tok not in token_to_id:
+                raise KeyError(f"Required special token '{tok}' not found in vocab.")
+
+        # Special token IDs
+        self.bos_token_id = token_to_id["<s>"]
+        self.eos_token_id = token_to_id["</s>"]
+        self.pad_token_id = token_to_id["<pad>"]
+        self.unk_token_id = token_to_id["<unk>"]
+        self.mask_token_id = token_to_id["<mask>"]
+
+        # Special tokens for convenience
+        self.bos_token = "<s>"
+        self.eos_token = "</s>"
+        self.pad_token = "<pad>"
+        self.unk_token = "<unk>"
+        self.mask_token = "<mask>"
+
+    def _build_trie(self, token_to_id):
+        root = TrieNode()
+        for token, tid in token_to_id.items():
+            node = root
+            for char in token:
+                if char not in node.children:
+                    node.children[char] = TrieNode()
+                node = node.children[char]
+            node.token_id = tid
+        return root
+
+    def __len__(self):
+        """Return vocab size — REQUIRED for HF compatibility."""
+        return len(self.token_to_id)
+
+    def __call__(self, text: Union[str, List[str]], text_pair: Optional[Union[str, List[str]]] = None, **kwargs) -> BatchEncoding:
+        if isinstance(text, list):
+            batch = [(t, p) if p is not None else t for t, p in zip(text, text_pair)] if text_pair else text
+            return self.batch_encode_plus(batch, **kwargs)
+        else:
+            return self.encode_plus(text=text, text_pair=text_pair, **kwargs)
+
+    @lru_cache(maxsize=10000)
+    def _cached_encode_str(self, s: str) -> Tuple[int, ...]:
+        return tuple(self._encode_core(s))
+
+    def _encode_core(self, text: str) -> List[int]:
+        """Core encoding logic using Trie — no caching."""
+        tokens = text
+        result_ids = []
+        i = 0
+        n = len(tokens)
+
+        while i < n:
+            node = self.trie_root
+            j = i
+            last_match_id = None
+            last_match_end = i
+
+            # Traverse trie while characters match
+            while j < n and tokens[j] in node.children:
+                node = node.children[tokens[j]]
+                j += 1
+                if node.token_id is not None:
+                    last_match_id = node.token_id
+                    last_match_end = j  # Remember end of valid token
+
+            if last_match_id is not None:
+                result_ids.append(last_match_id)
+                i = last_match_end
+            else:
+                # Fallback: encode single char
+                tok = tokens[i]
+                result_ids.append(self.token_to_id.get(tok, self.unk_token_id))
+                i += 1
+
+        return result_ids
+
+    def encode(self, text: str) -> List[int]:
+        """Public encode method — strips input and uses cache."""
+        return list(self._cached_encode_str(text.strip()))
+
+    def decode(self, token_ids: Union[List[int], torch.Tensor], skip_special_tokens: bool = False) -> str:
+        if isinstance(token_ids, torch.Tensor):
+            token_ids = token_ids.tolist()
+
+        if skip_special_tokens:
+            special_ids = {
+                self.bos_token_id,
+                self.eos_token_id,
+                self.pad_token_id,
+                self.mask_token_id,  
+            }
+        else:
+            special_ids = set()
+
+        tokens = []
+        for tid in token_ids:
+            if tid in special_ids:
+                continue
+            token = self.id_to_token.get(tid, self.unk_token)
+            tokens.append(token)
+
+        return "".join(tokens)
+
+    def decode_with_trace(self, token_ids: List[int]) -> None:
+        print(f"\n🔍 Decoding {len(token_ids)} tokens:")
+        for i, tid in enumerate(token_ids):
+            token = self.id_to_token.get(tid, self.unk_token)
+            print(f"  [{i:03d}] ID={tid:5d} → '{token}'")
+
+    def convert_ids_to_tokens(self, ids: List[int]) -> List[str]:
+        return [self.id_to_token.get(i, self.unk_token) for i in ids]
+
+    def convert_tokens_to_ids(self, tokens: List[str]) -> List[int]:
+        return [self.token_to_id.get(t, self.unk_token_id) for t in tokens]
+
+    def encode_plus(
+        self,
+        text: str,
+        text_pair: Optional[str] = None,
+        add_special_tokens: bool = True,
+        padding: Union[bool, str] = False,
+        truncation: bool = False,
+        max_length: Optional[int] = None,
+        return_tensors: Optional[str] = None,
+        return_attention_mask: bool = True,
+        return_token_type_ids: bool = True,
+    ) -> BatchEncoding:
+        if max_length is None:
+            max_length = self.model_max_length
+
+        ids_a = self.encode(text)
+
+        if text_pair is not None:
+            ids_b = self.encode(text_pair)
+        else:
+            ids_b = None
+
+        input_ids = []
+        token_type_ids = []
+
+        if add_special_tokens:
+            input_ids.append(self.bos_token_id)
+            token_type_ids.append(0)
+            if ids_b is not None:
+                input_ids.extend(ids_a)
+                token_type_ids.extend([0] * len(ids_a))
+                input_ids.append(self.eos_token_id)
+                token_type_ids.append(0)
+
+                input_ids.extend(ids_b)
+                token_type_ids.extend([1] * len(ids_b))
+                input_ids.append(self.eos_token_id)
+                token_type_ids.append(1)
+            else:
+                input_ids.extend(ids_a)
+                token_type_ids.extend([0] * len(ids_a))
+                input_ids.append(self.eos_token_id)
+                token_type_ids.append(0)
+        else:
+            input_ids = ids_a
+            token_type_ids = [0] * len(input_ids)
+            if ids_b is not None:
+                input_ids.extend(ids_b)
+                token_type_ids.extend([1] * len(ids_b))
+
+        if truncation and len(input_ids) > max_length:
+            input_ids = input_ids[:max_length]
+            token_type_ids = token_type_ids[:max_length]
+
+        if padding:
+            pad_len = max_length - len(input_ids)
+            if pad_len > 0:
+                input_ids.extend([self.pad_token_id] * pad_len)
+                token_type_ids.extend([0] * pad_len)
+
+        attention_mask = [1 if tid != self.pad_token_id else 0 for tid in input_ids]
+
+        encoded_dict = {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask,
+        }
+        if return_token_type_ids:
+            encoded_dict["token_type_ids"] = token_type_ids
+
+        if return_tensors == "pt":
+            output = {}
+            for k, v in encoded_dict.items():
+                tensor = torch.tensor(v, dtype=torch.long)  #  Fixed: use torch.tensor, not as_tensor
+                if tensor.ndim == 1:
+                    tensor = tensor.unsqueeze(0)
+                output[k] = tensor
+        else:
+            output = encoded_dict
+
+        return BatchEncoding(output, tensor_type=return_tensors)
+
+    def batch_encode_plus(
+        self,
+        batch_text_or_text_pairs: List[Union[str, Tuple[str, str]]],
+        **kwargs
+    ) -> BatchEncoding:
+        all_input_ids = []
+        all_attention_masks = []
+        all_token_type_ids = []
+
+        for item in batch_text_or_text_pairs:
+            if isinstance(item, tuple):
+                text, text_pair = item
+            else:
+                text, text_pair = item, None
+
+            encoded = self.encode_plus(
+                text=text,
+                text_pair=text_pair,
+                **kwargs
+            )
+            all_input_ids.append(encoded["input_ids"])
+            all_attention_masks.append(encoded["attention_mask"])
+            if "token_type_ids" in encoded:
+                all_token_type_ids.append(encoded["token_type_ids"])
+
+        batched = {
+            "input_ids": all_input_ids,
+            "attention_mask": all_attention_masks,
+        }
+        if all_token_type_ids:
+            batched["token_type_ids"] = all_token_type_ids
+
+        if kwargs.get("return_tensors") == "pt":
+            def to_tensor_list(lst):
+                # Fixed: Handle both tensor and non-tensor items properly
+                return [item.clone().detach() if isinstance(item, torch.Tensor) 
+                    else torch.tensor(item, dtype=torch.long) for item in lst]
+            batched = {
+                k: torch.nn.utils.rnn.pad_sequence(
+                    to_tensor_list(v),
+                    batch_first=True,
+                    padding_value=self.pad_token_id if k == "input_ids" else 0
+                )
+                for k, v in batched.items()
+            }
+
+        return BatchEncoding(batched, tensor_type=kwargs.get("return_tensors"))
+
+    # Save vocab to directory
+    def save_pretrained(self, save_directory: str):
+        """
+        Save tokenizer vocab as `vocab.json` in target directory.
+        Mimics Hugging Face convention.
+        """
+        if not os.path.exists(save_directory):
+            os.makedirs(save_directory)
+
+        vocab_file = os.path.join(save_directory, "vocab.json")
+
+        # Keys are strings, values are ints — JSON-safe
+        with open(vocab_file, "w", encoding="utf-8") as f:
+            json.dump(self.token_to_id, f, ensure_ascii=False, indent=2)
+
+        print(f"✅ Tokenizer vocab saved to: {vocab_file}")
+
+    # Load from pretrained directory
+    @classmethod
+    def from_pretrained(cls, pretrained_directory: str, model_max_length=512):
+        """
+        Load tokenizer from directory containing `vocab.json`.
+        """
+        vocab_file = os.path.join(pretrained_directory, "vocab.json")
+
+        if not os.path.exists(vocab_file):
+            raise FileNotFoundError(f"Vocab file not found: {vocab_file}")
+
+        with open(vocab_file, "r", encoding="utf-8") as f:
+            token_to_id = json.load(f)
+
+        # Convert keys to str (JSON loads as str anyway), values to int
+        token_to_id = {str(k): int(v) for k, v in token_to_id.items()}
+
+        return cls(token_to_id=token_to_id, model_max_length=model_max_length)
+
+class FastChemTokenizerSelfies:
+    def __init__(self, token_to_id, model_max_length=512):
+        self.token_to_id = token_to_id
+        self.id_to_token = {v: k for k, v in token_to_id.items()}
+        # No more self.token_set — replaced by trie
+        self.model_max_length = model_max_length
+
+        # Precompute max token length for possible use & clarity
+        self.max_token_len = max(len(t) for t in token_to_id.keys())
+
+        # Build trie for fast longest-match lookup
+        self.trie_root = self._build_trie(token_to_id)
+
+        # Validate required special tokens
+        required_special_tokens = ["<s>", "</s>", "<pad>", "<unk>", "<mask>"]
+        for tok in required_special_tokens:
+            if tok not in token_to_id:
+                raise KeyError(f"Required special token '{tok}' not found in vocab.")
+
+        # Special token IDs
+        self.bos_token_id = token_to_id["<s>"]
+        self.eos_token_id = token_to_id["</s>"]
+        self.pad_token_id = token_to_id["<pad>"]
+        self.unk_token_id = token_to_id["<unk>"]
+        self.mask_token_id = token_to_id["<mask>"]
+
+        # Special tokens for convenience
+        self.bos_token = "<s>"
+        self.eos_token = "</s>"
+        self.pad_token = "<pad>"
+        self.unk_token = "<unk>"
+        self.mask_token = "<mask>"
+
+    def _build_trie(self, token_to_id):
+        root = TrieNode()
+        for token, tid in token_to_id.items():
+            node = root
+            for char in token:
+                if char not in node.children:
+                    node.children[char] = TrieNode()
+                node = node.children[char]
+            node.token_id = tid
+        return root
+
+    def __len__(self):
+        """Return vocab size — REQUIRED for HF compatibility."""
+        return len(self.token_to_id)
+
+    def __call__(self, text: Union[str, List[str]], text_pair: Optional[Union[str, List[str]]] = None, **kwargs) -> BatchEncoding:
+        if isinstance(text, list):
+            batch = [(t, p) if p is not None else t for t, p in zip(text, text_pair)] if text_pair else text
+            return self.batch_encode_plus(batch, **kwargs)
+        else:
+            return self.encode_plus(text=text, text_pair=text_pair, **kwargs)
+
+    @lru_cache(maxsize=10000)
+    def _cached_encode_str(self, s: str) -> Tuple[int, ...]:
+        return tuple(self._encode_core(s))
+
+    def _encode_core(self, text: str) -> List[int]:
+        """Core encoding logic using Trie — skips whitespace if not part of a token."""
+        result_ids = []
+        i = 0
+        n = len(text)
+
+        while i < n:
+            if text[i].isspace():  # ← Skip whitespace unless part of a token
+                i += 1
+                continue
+
+            node = self.trie_root
+            j = i
+            last_match_id = None
+            last_match_end = i
+
+            # Traverse trie while characters match
+            while j < n and text[j] in node.children:
+                node = node.children[text[j]]
+                j += 1
+                if node.token_id is not None:
+                    last_match_id = node.token_id
+                    last_match_end = j
+
+            if last_match_id is not None:
+                result_ids.append(last_match_id)
+                i = last_match_end
+            else:
+                # Fallback: encode single char
+                result_ids.append(self.token_to_id.get(text[i], self.unk_token_id))
+                i += 1
+
+        return result_ids
+
+
+    def encode(self, text: str) -> List[int]:
+        """Public encode method — strips input and uses cache."""
+        return list(self._cached_encode_str(text.strip()))
+
+    def decode(self, token_ids: Union[List[int], torch.Tensor], skip_special_tokens: bool = False) -> str:
+        if isinstance(token_ids, torch.Tensor):
+            token_ids = token_ids.tolist()
+
+        if skip_special_tokens:
+            special_ids = {
+                self.bos_token_id,
+                self.eos_token_id,
+                self.pad_token_id,
+                self.mask_token_id,
+            }
+        else:
+            special_ids = set()
+
+        tokens = []
+        for tid in token_ids:
+            if tid in special_ids:
+                continue
+            token = self.id_to_token.get(tid, self.unk_token)
+            tokens.append(token)
+
+        # ✅ Join with SPACE between tokens — this reconstructs original format
+        return " ".join(tokens)
+
+    def decode_with_trace(self, token_ids: List[int]) -> None:
+        print(f"\n🔍 Decoding {len(token_ids)} tokens:")
+        for i, tid in enumerate(token_ids):
+            token = self.id_to_token.get(tid, self.unk_token)
+            print(f"  [{i:03d}] ID={tid:5d} → '{token}'")
+
+    def convert_ids_to_tokens(self, ids: List[int]) -> List[str]:
+        return [self.id_to_token.get(i, self.unk_token) for i in ids]
+
+    def convert_tokens_to_ids(self, tokens: List[str]) -> List[int]:
+        return [self.token_to_id.get(t, self.unk_token_id) for t in tokens]
+
+    def encode_plus(
+        self,
+        text: str,
+        text_pair: Optional[str] = None,
+        add_special_tokens: bool = True,
+        padding: Union[bool, str] = False,
+        truncation: bool = False,
+        max_length: Optional[int] = None,
+        return_tensors: Optional[str] = None,
+        return_attention_mask: bool = True,
+        return_token_type_ids: bool = True,
+    ) -> BatchEncoding:
+        if max_length is None:
+            max_length = self.model_max_length
+
+        ids_a = self.encode(text)
+
+        if text_pair is not None:
+            ids_b = self.encode(text_pair)
+        else:
+            ids_b = None
+
+        input_ids = []
+        token_type_ids = []
+
+        if add_special_tokens:
+            input_ids.append(self.bos_token_id)
+            token_type_ids.append(0)
+            if ids_b is not None:
+                input_ids.extend(ids_a)
+                token_type_ids.extend([0] * len(ids_a))
+                input_ids.append(self.eos_token_id)
+                token_type_ids.append(0)
+
+                input_ids.extend(ids_b)
+                token_type_ids.extend([1] * len(ids_b))
+                input_ids.append(self.eos_token_id)
+                token_type_ids.append(1)
+            else:
+                input_ids.extend(ids_a)
+                token_type_ids.extend([0] * len(ids_a))
+                input_ids.append(self.eos_token_id)
+                token_type_ids.append(0)
+        else:
+            input_ids = ids_a
+            token_type_ids = [0] * len(input_ids)
+            if ids_b is not None:
+                input_ids.extend(ids_b)
+                token_type_ids.extend([1] * len(ids_b))
+
+        if truncation and len(input_ids) > max_length:
+            input_ids = input_ids[:max_length]
+            token_type_ids = token_type_ids[:max_length]
+
+        if padding:
+            pad_len = max_length - len(input_ids)
+            if pad_len > 0:
+                input_ids.extend([self.pad_token_id] * pad_len)
+                token_type_ids.extend([0] * pad_len)
+
+        attention_mask = [1 if tid != self.pad_token_id else 0 for tid in input_ids]
+
+        encoded_dict = {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask,
+        }
+        if return_token_type_ids:
+            encoded_dict["token_type_ids"] = token_type_ids
+
+        if return_tensors == "pt":
+            output = {}
+            for k, v in encoded_dict.items():
+                tensor = torch.tensor(v, dtype=torch.long)  #  Fixed: use torch.tensor, not as_tensor
+                if tensor.ndim == 1:
+                    tensor = tensor.unsqueeze(0)
+                output[k] = tensor
+        else:
+            output = encoded_dict
+
+        return BatchEncoding(output, tensor_type=return_tensors)
+
+    def batch_encode_plus(
+        self,
+        batch_text_or_text_pairs: List[Union[str, Tuple[str, str]]],
+        **kwargs
+    ) -> BatchEncoding:
+        all_input_ids = []
+        all_attention_masks = []
+        all_token_type_ids = []
+
+        for item in batch_text_or_text_pairs:
+            if isinstance(item, tuple):
+                text, text_pair = item
+            else:
+                text, text_pair = item, None
+
+            encoded = self.encode_plus(
+                text=text,
+                text_pair=text_pair,
+                **kwargs
+            )
+            all_input_ids.append(encoded["input_ids"])
+            all_attention_masks.append(encoded["attention_mask"])
+            if "token_type_ids" in encoded:
+                all_token_type_ids.append(encoded["token_type_ids"])
+
+        batched = {
+            "input_ids": all_input_ids,
+            "attention_mask": all_attention_masks,
+        }
+        if all_token_type_ids:
+            batched["token_type_ids"] = all_token_type_ids
+
+        if kwargs.get("return_tensors") == "pt":
+            def to_tensor_list(lst):
+                # Fixed: Handle both tensor and non-tensor items properly
+                return [item.clone().detach() if isinstance(item, torch.Tensor) 
+                    else torch.tensor(item, dtype=torch.long) for item in lst]
+            batched = {
+                k: torch.nn.utils.rnn.pad_sequence(
+                    to_tensor_list(v),
+                    batch_first=True,
+                    padding_value=self.pad_token_id if k == "input_ids" else 0
+                )
+                for k, v in batched.items()
+            }
+
+        return BatchEncoding(batched, tensor_type=kwargs.get("return_tensors"))
+
+    # Save vocab to directory
+    def save_pretrained(self, save_directory: str):
+        """
+        Save tokenizer vocab as `vocab.json` in target directory.
+        Mimics Hugging Face convention.
+        """
+        if not os.path.exists(save_directory):
+            os.makedirs(save_directory)
+
+        vocab_file = os.path.join(save_directory, "vocab.json")
+
+        # Keys are strings, values are ints — JSON-safe
+        with open(vocab_file, "w", encoding="utf-8") as f:
+            json.dump(self.token_to_id, f, ensure_ascii=False, indent=2)
+
+        print(f"✅ Tokenizer vocab saved to: {vocab_file}")
+
+    # Load from pretrained directory
+    @classmethod
+    def from_pretrained(cls, pretrained_directory: str, model_max_length=512):
+        """
+        Load tokenizer from directory containing `vocab.json`.
+        """
+        vocab_file = os.path.join(pretrained_directory, "vocab.json")
+
+        if not os.path.exists(vocab_file):
+            raise FileNotFoundError(f"Vocab file not found: {vocab_file}")
+
+        with open(vocab_file, "r", encoding="utf-8") as f:
+            token_to_id = json.load(f)
+
+        # Convert keys to str (JSON loads as str anyway), values to int
+        token_to_id = {str(k): int(v) for k, v in token_to_id.items()}
+
+        return cls(token_to_id=token_to_id, model_max_length=model_max_length)

benchmark/benchmark_HF_efficient.py

@@ -0,0 +1,1119 @@
+#
+# Molecule Tokenizer Benchmark & VAE Training Pipeline
+# PATCHED VERSION — Updated for FastChemTokenizerHF (HF compatible)
+#
+
+#
+# Step 1.1 — Imports & Reproducibility
+#
+
+import os
+import time
+import random
+import pandas as pd
+from pathlib import Path
+from datetime import datetime
+import torch
+import numpy as np
+# Tokenizers
+from transformers import AutoTokenizer
+from FastChemTokenizerHF import FastChemTokenizer
+# Optional: for progress bars
+from tqdm import tqdm
+from rdkit import Chem
+from sklearn.model_selection import train_test_split
+import torch.nn as nn
+import torch.nn.functional as F
+from ranger21 import Ranger21
+from torch.utils.data import DataLoader, Dataset
+from scipy.stats import entropy
+import json
+import math
+from typing import Optional, Tuple, Union
+from rdkit import RDLogger
+RDLogger.DisableLog('rdApp.*')  
+# Set seeds for reproducibility
+def set_seed(seed=42):
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    os.environ['PYTHONHASHSEED'] = str(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+set_seed(42)
+
+# Device setup
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+print(f"Using device: {device}")
+
+#
+# Step 1.2 — Load & Preprocess SMILES Corpus
+#
+
+data_path = "../data/sample_1k_smi_42.csv"
+df = pd.read_csv(data_path)
+
+if 'SMILES' not in df.columns:
+    raise ValueError("Expected column 'SMILES' in CSV")
+
+smiles_list = df['SMILES'].dropna().tolist()
+print(f"Loaded {len(smiles_list)} SMILES (assumed pre-canonicalized)")
+
+# Validate with RDKit
+
+def is_valid_smiles(smiles):
+    return Chem.MolFromSmiles(smiles) is not None
+
+print("Validating SMILES with RDKit...")
+valid_mask = [is_valid_smiles(s) for s in tqdm(smiles_list)]
+smiles_list = [s for s, valid in zip(smiles_list, valid_mask) if valid]
+print(f"After RDKit filtering: {len(smiles_list)} valid SMILES")
+
+#
+# Step 1.3 — Train/Val/Test Split (80/10/10)
+#
+
+train_smiles, temp_smiles = train_test_split(smiles_list, test_size=0.2, random_state=42, shuffle=True)
+val_smiles, test_smiles = train_test_split(temp_smiles, test_size=0.5, random_state=42, shuffle=True)
+
+print(f"Train: {len(train_smiles)}")
+print(f"Val:   {len(val_smiles)}")
+print(f"Test:  {len(test_smiles)}")
+
+# Cache splits
+splits = {'train': train_smiles, 'val': val_smiles, 'test': test_smiles}
+for split_name, smiles in splits.items():
+    with open(f"../data/{split_name}_smiles.txt", "w") as f:
+        f.write("\n".join(smiles))
+
+#
+# Step 1.4 — Tokenizer Wrapper (Simplified for HF compatibility)
+#
+
+class TokenizerWrapper:
+    def __init__(self, tokenizer, name,
+                 bos_token="<s>", eos_token="</s>",
+                 pad_token="<pad>", unk_token="<unk>"):
+        self.tokenizer = tokenizer
+        self.name = name
+
+        # Only call add_special_tokens if the tokenizer actually supports it
+        if hasattr(tokenizer, "add_special_tokens") and callable(tokenizer.add_special_tokens):
+            try:
+                tokenizer.add_special_tokens({
+                    "bos_token": bos_token,
+                    "eos_token": eos_token,
+                    "pad_token": pad_token,
+                    "unk_token": unk_token,
+                })
+            except NotImplementedError:
+                # Your FastChemTokenizerHF already defines these tokens internally
+                pass
+
+
+
+    def encode(self, smiles: str, add_special_tokens: bool = True):
+        return self.tokenizer(
+            smiles,
+            add_special_tokens=add_special_tokens,
+            return_attention_mask=False,
+            return_tensors=None
+        )
+
+    def decode(self, token_ids, skip_special_tokens=True):
+        return self.tokenizer.decode(token_ids, skip_special_tokens=skip_special_tokens)
+
+    def __len__(self):
+        return len(self.tokenizer)
+
+    def get_vocab(self):
+        return self.tokenizer.get_vocab()
+    
+    @property
+    def bos_token_id(self):
+        return self.tokenizer.bos_token_id
+
+    @property
+    def eos_token_id(self):
+        return self.tokenizer.eos_token_id
+
+    @property
+    def pad_token_id(self):
+        return self.tokenizer.pad_token_id
+
+    @property
+    def unk_token_id(self):
+        return self.tokenizer.unk_token_id
+
+#
+# Step 1.5 — Initialize Tokenizers
+#
+
+tok1_hf = AutoTokenizer.from_pretrained("seyonec/ChemBERTa-zinc-base-v1")
+tok2_fast = FastChemTokenizer.from_pretrained("../smitok_core")
+
+tokenizer1 = TokenizerWrapper(tok1_hf, name="ChemBERTa", bos_token="<s>", eos_token="</s>", pad_token="<pad>", unk_token="<unk>")
+tokenizer2 = TokenizerWrapper(tok2_fast, name="FastChemTokenizerHF", bos_token="<s>", eos_token="</s>", pad_token="<pad>", unk_token="<unk>")
+
+TOKENIZERS = [tokenizer1, tokenizer2]
+
+
+#
+# Step 1.6 — Benchmarking Functions (Fixed Bug #4 implicitly via epsilon)
+#
+
+def benchmark_tokenizer(tokenizer, smiles_sample, encode_only=False):
+    V = len(tokenizer)
+    sample = smiles_sample[:10000] if len(smiles_sample) > 10000 else smiles_sample
+
+    encode_times, token_counts, char_counts = [], [], []
+    unk_counts, total_tokens = 0, 0
+
+    for smiles in tqdm(sample, desc=f"Encoding with {tokenizer.name}", leave=False):
+        char_counts.append(len(smiles))
+        start = time.perf_counter()
+        enc = tokenizer.encode(smiles, add_special_tokens=True)
+        end = time.perf_counter()
+        encode_times.append(end - start)
+
+        input_ids = enc['input_ids']
+        token_counts.append(len(input_ids))
+        total_tokens += len(input_ids)
+        unk_id = tokenizer.tokenizer.unk_token_id
+        unk_counts += input_ids.count(unk_id)
+
+    L_bar = np.mean(token_counts)
+    C = np.mean(char_counts) / L_bar
+    U = unk_counts / total_tokens if total_tokens > 0 else 0.0
+    Tenc = len(sample) / sum(encode_times)
+
+    metrics = {
+        'vocab_size': V,
+        'avg_tokens_per_mol': L_bar,
+        'compression_ratio': C,
+        'percent_unknown': U * 100,
+        'encode_throughput_smiles_per_sec': Tenc,
+    }
+
+    if encode_only:
+        return metrics
+
+    decode_times, reconstruction_ok = [], 0
+
+    for smiles in tqdm(sample, desc=f"Decoding with {tokenizer.name}", leave=False):
+        enc = tokenizer.encode(smiles, add_special_tokens=True)
+        input_ids = enc['input_ids']
+        start = time.perf_counter()
+        decoded = tokenizer.decode(input_ids, skip_special_tokens=True)
+        end = time.perf_counter()
+        decode_times.append(end - start)
+        if decoded == smiles:
+            reconstruction_ok += 1
+
+    Tdec = len(sample) / sum(decode_times)
+    recon_acc = reconstruction_ok / len(sample)
+
+    metrics.update({
+        'decode_throughput_smiles_per_sec': Tdec,
+        'decode_reconstruction_accuracy': recon_acc * 100,
+    })
+
+    return metrics
+
+
+#
+# Step 1.7 — Run Benchmark
+#
+
+benchmark_sample = train_smiles
+results = []
+
+for tokenizer in TOKENIZERS:
+    print(f"\n=== Benchmarking {tokenizer.name} ===")
+    metrics = benchmark_tokenizer(tokenizer, benchmark_sample)
+    metrics['tokenizer'] = tokenizer.name
+    results.append(metrics)
+    for k, v in metrics.items():
+        if k != 'tokenizer':
+            print(f"{k:35s}: {v:.4f}" if isinstance(v, float) else f"{k:35s}: {v}")
+
+df_results = pd.DataFrame(results)
+df_results.to_csv("tokenizer_benchmark_results.csv", index=False)
+print("\nTokenizer benchmark results saved to 'tokenizer_benchmark_results.csv'")
+
+#
+# Step 2.1 — VAE Model Class (PATCHED: decode stops at EOS)
+#
+
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Tuple, Optional
+
+class MoleculeVAE(nn.Module):
+    """
+    Optimized MoleculeVAE with:
+    - Bidirectional encoder (restored)
+    - Proper latent2hidden + latent2cell (restored)
+    - Adjustable dropout for small dataset
+    - Attention pooling option
+    - Quantization-ready hooks
+    """
+
+    def __init__(self, 
+                 vocab_size: int, 
+                 embed_dim: int = 128,
+                 hidden_dim: int = 256,
+                 latent_dim: int = 128,
+                 num_layers: int = 2,
+                 pad_token_id: int = 0, 
+                 bos_token_id: int = 1, 
+                 eos_token_id: int = 2,
+                 dropout: float = 0.2,
+                 use_attention: bool = True,
+                 quantize_ready: bool = False):
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.embed_dim = embed_dim
+        self.hidden_dim = hidden_dim
+        self.latent_dim = latent_dim
+        self.num_layers = num_layers
+        self.pad_token_id = pad_token_id
+        self.bos_token_id = bos_token_id
+        self.eos_token_id = eos_token_id
+        self.use_attention = use_attention
+
+        # Shared embedding
+        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=pad_token_id)
+
+        # Bidirectional encoder
+        self.encoder_lstm = nn.LSTM(
+            embed_dim, hidden_dim, num_layers,
+            batch_first=True, dropout=dropout if num_layers > 1 else 0,
+            bidirectional=True
+        )
+
+        # Attention pooling (optional)
+        if use_attention:
+            self.attention = nn.MultiheadAttention(
+                hidden_dim * 2, num_heads=4, dropout=dropout, batch_first=True
+            )
+            self.attention_linear = nn.Linear(hidden_dim * 2, 1)
+
+        self.encoder_norm = nn.LayerNorm(hidden_dim * 2)
+
+        # Latent bottleneck
+        self.fc_mu = nn.Linear(hidden_dim * 2, latent_dim)
+        self.fc_logvar = nn.Linear(hidden_dim * 2, latent_dim)
+
+        # Decoder init (restored)
+        self.latent2hidden = nn.Linear(latent_dim, num_layers * hidden_dim)
+        self.latent2cell   = nn.Linear(latent_dim, num_layers * hidden_dim)
+
+        # Decoder
+        self.decoder_lstm = nn.LSTM(
+            embed_dim, hidden_dim, num_layers,
+            batch_first=True, dropout=dropout if num_layers > 1 else 0
+        )
+        self.decoder_norm = nn.LayerNorm(hidden_dim)
+        self.fc_out = nn.Linear(hidden_dim, vocab_size)
+
+        # Weight tying
+        if embed_dim == hidden_dim:
+            self.fc_out.weight = self.embedding.weight
+
+        self.dropout = nn.Dropout(dropout)
+
+        # Quantization stubs
+        if quantize_ready:
+            self.quant = torch.quantization.QuantStub()
+            self.dequant = torch.quantization.DeQuantStub()
+        else:
+            self.quant = self.dequant = nn.Identity()
+
+        self._init_weights()
+
+    def _init_weights(self):
+        for name, param in self.named_parameters():
+            if 'weight' in name:
+                if param.ndim >= 2:
+                    nn.init.xavier_uniform_(param)
+                else:
+                    nn.init.normal_(param, 0, 0.01)
+            elif 'bias' in name:
+                nn.init.zeros_(param)
+
+    def _pool_sequence(self, packed_output, lengths):
+        output, _ = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)
+        if self.use_attention:
+            attn_out, _ = self.attention(output, output, output)
+            weights = torch.softmax(self.attention_linear(attn_out), dim=1)
+            pooled = (weights * output).sum(dim=1)
+        else:
+            # mean pooling with mask
+            batch_size, max_len, _ = output.size()
+            mask = torch.arange(max_len, device=output.device).expand(batch_size, max_len) < lengths.unsqueeze(1)
+            masked_output = output * mask.unsqueeze(-1).float()
+            pooled = masked_output.sum(dim=1) / lengths.unsqueeze(-1).float()
+        return pooled
+
+    def encode(self, x: torch.Tensor, lengths: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        x = self.quant(x)
+        embedded = self.dropout(self.embedding(x))
+        packed = nn.utils.rnn.pack_padded_sequence(
+            embedded, lengths.cpu(), batch_first=True, enforce_sorted=False
+        )
+        packed_out, _ = self.encoder_lstm(packed)
+        h = self._pool_sequence(packed_out, lengths)
+        h = self.encoder_norm(h)
+        mu, logvar = self.fc_mu(h), self.fc_logvar(h)
+        return mu, logvar
+
+    def reparameterize(self, mu: torch.Tensor, logvar: torch.Tensor) -> torch.Tensor:
+        if self.training:
+            std = torch.exp(0.5 * logvar)
+            eps = torch.randn_like(std)
+            return mu + eps * std
+        return mu
+
+    def _init_decoder_state(self, z: torch.Tensor):
+        batch_size = z.size(0)
+        h0 = self.latent2hidden(z).view(self.num_layers, batch_size, self.hidden_dim)
+        c0 = self.latent2cell(z).view(self.num_layers, batch_size, self.hidden_dim)
+        return h0, c0
+
+    def decode(self, z: torch.Tensor, max_length: int = 64, mode: str = "greedy", temperature: float = 1.0):
+        batch_size = z.size(0)
+        device = z.device
+        h0, c0 = self._init_decoder_state(z)
+        hidden = (h0, c0)
+
+        input_ids = torch.full((batch_size, 1), self.bos_token_id, dtype=torch.long, device=device)
+        finished = torch.zeros(batch_size, dtype=torch.bool, device=device)
+        logits_list = []
+
+        for _ in range(max_length):
+            embedded = self.embedding(input_ids)
+            output, hidden = self.decoder_lstm(embedded, hidden)
+            output = self.decoder_norm(output)
+            logit = self.fc_out(output)
+            logits_list.append(logit)
+
+            if mode == "greedy":
+                next_tokens = logit.argmax(dim=-1)
+            elif mode == "sample":
+                probs = F.softmax(logit.squeeze(1) / temperature, dim=-1)
+                next_tokens = torch.multinomial(probs, 1)
+            else:
+                raise ValueError(f"Unknown decode mode: {mode}")
+
+            just_finished = (next_tokens.squeeze(-1) == self.eos_token_id)
+            finished |= just_finished
+            next_tokens = torch.where(
+                finished.unsqueeze(-1),
+                torch.tensor(self.pad_token_id, device=device),
+                next_tokens
+            )
+            input_ids = next_tokens
+            if finished.all():
+                break
+
+        return self.dequant(torch.cat(logits_list, dim=1))
+
+    def forward(self, input_ids: torch.Tensor, lengths: torch.Tensor,
+                target_seq: Optional[torch.Tensor] = None,
+                teacher_forcing_ratio: float = 0.0,
+                temperature: float = 1.0):
+        mu, logvar = self.encode(input_ids, lengths)
+        z = self.reparameterize(mu, logvar)
+        if self.training and target_seq is not None and teacher_forcing_ratio > 0:
+            return self._forward_teacher_forcing(z, target_seq, teacher_forcing_ratio), mu, logvar
+        else:
+            max_len = target_seq.size(1) if target_seq is not None else 64
+            return self.decode(z, max_length=max_len, temperature=temperature), mu, logvar
+
+    def _forward_teacher_forcing(self, z: torch.Tensor, target_seq: torch.Tensor, teacher_forcing_ratio: float):
+        batch_size, seq_len = target_seq.size()
+        h0, c0 = self._init_decoder_state(z)
+        hidden = (h0, c0)
+        logits_list = []
+        input_token = target_seq[:, 0:1]
+
+        for t in range(1, seq_len):
+            embedded = self.embedding(input_token)
+            output, hidden = self.decoder_lstm(embedded, hidden)
+            output = self.decoder_norm(output)
+            logit = self.fc_out(output)
+            logits_list.append(logit)
+
+            if torch.rand(1).item() < teacher_forcing_ratio:
+                input_token = target_seq[:, t:t+1]
+            else:
+                input_token = logit.argmax(dim=-1)
+
+        return torch.cat(logits_list, dim=1)
+
+#
+# Step 2.2 — Loss Function (PATCHED: β applied OUTSIDE, not inside)
+#
+
+# PATCH 2: Fix VAE Loss Function - Ensure beta is properly applied
+# Replace the existing vae_loss function:
+
+def vae_loss(logits, targets, mu, logvar, pad_token_id, beta=1.0):
+    # 1. align lengths
+    max_len = max(logits.size(1), targets.size(1))
+    if logits.size(1) < max_len:
+        logits = F.pad(logits, (0, 0, 0, max_len - logits.size(1)))
+    if targets.size(1) < max_len:
+        targets = F.pad(targets, (0, max_len - targets.size(1)), value=pad_token_id)
+
+    logits_flat = logits.view(-1, logits.size(-1))          # [B*L, V]
+    targets_flat = targets.reshape(-1)                      # [B*L]
+
+    mask = (targets_flat != pad_token_id).float()
+    ce_loss = F.cross_entropy(logits_flat, targets_flat, reduction='none')
+    mask_sum = mask.sum()
+    ce_loss = (ce_loss * mask).sum() / (mask_sum + 1e-8)
+
+    # FIXED: Raw KL loss computation
+    kl_loss_raw = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp(), dim=1)
+    # Apply mask to KL loss if needed (but typically KL is per-sample)
+    kl_loss = kl_loss_raw.mean()
+    
+    # CRITICAL FIX: Apply beta scaling correctly
+    total_loss = ce_loss + beta * kl_loss
+    
+    return total_loss, ce_loss, kl_loss
+
+#
+# Step 2.3 — KLAnnealer (Fixed Bug #5: double increment)
+#
+
+import math
+
+class KLAnnealer:
+    def __init__(self, total_steps, n_cycle=1, ratio=0.3, mode="linear", per_epoch=False, steps_per_epoch=None):
+        self.total_steps = total_steps
+        self.n_cycle = n_cycle
+        self.ratio = ratio
+        self.mode = mode
+        self.per_epoch = per_epoch
+        self.steps_per_epoch = steps_per_epoch
+        self.current_step = 0
+        self.current_epoch = 0
+
+    def get_beta(self, increment=True):
+        """Get current KL weight (beta).
+        Args:
+            increment (bool): whether to advance the annealer (use False in validation).
+        """
+        if increment:
+            self.current_step += 1
+
+        # Calculate progress based on total steps
+        progress = min(self.current_step / max(self.total_steps, 1.0), 1.0)
+        
+        # For cyclical annealing
+        if self.n_cycle > 1:
+            cycle_length = self.total_steps / self.n_cycle
+            pos_in_cycle = (self.current_step % cycle_length)
+            cycle_progress = min(pos_in_cycle / max(cycle_length * self.ratio, 1.0), 1.0)
+        else:
+            # For single cycle, use full progress
+            cycle_progress = min(progress / self.ratio, 1.0) if self.ratio > 0 else 1.0
+
+        if self.mode == "linear":
+            beta = min(cycle_progress, 1.0)
+        elif self.mode == "sigmoid":
+            k = 6
+            # scale progress ∈ [0,1] → [-3, +3] for a smooth S curve
+            beta = 1 / (1 + math.exp(-k * (cycle_progress - 0.5)))
+        elif self.mode == "cosine":
+            # Cosine annealing from 0 to 1
+            beta = 0.5 * (1 + math.cos(math.pi * (1 - cycle_progress)))
+        else:
+            raise ValueError(f"Unknown mode: {self.mode}")
+
+        return min(beta, 1.0)
+
+    def step(self):
+        """Increment the step counter."""
+        self.current_step += 1
+
+    def epoch_step(self):
+        """Increment the epoch counter."""
+        self.current_epoch += 1
+
+#
+# Teacher forcing ratio
+#
+
+def get_teacher_forcing_ratio(epoch, num_epochs, min_tfr=0.6, warmup_fraction=0.3):
+    """
+    Linear decay of teacher forcing ratio (TFR).
+    - Starts at 1.0
+    - Decays to min_tfr by (warmup_fraction * num_epochs)
+    - Then stays flat
+    """
+    warmup_epochs = int(num_epochs * warmup_fraction)
+    if epoch < warmup_epochs:
+        # linearly decay from 1.0 → min_tfr
+        return 1.0 - (1.0 - min_tfr) * (epoch / warmup_epochs)
+    else:
+        return min_tfr
+
+
+#
+# Step 2.4 — Collate Function (Fixed Bug #2: dynamic pad id)
+#
+
+def collate_fn(batch, tokenizer, max_length=128):
+    encodings = [tokenizer.encode(s, add_special_tokens=True) for s in batch]
+    input_ids = [e['input_ids'] for e in encodings]
+
+    max_len = min(max(len(ids) for ids in input_ids), max_length)
+    padded = []
+    lengths = []
+
+    pad_token_id = tokenizer.tokenizer.pad_token_id  #   FIXED: dynamic
+
+    for ids in input_ids:
+        if len(ids) > max_length:
+            ids = ids[:max_length]
+        else:
+            ids = ids + [pad_token_id] * (max_len - len(ids))
+        padded.append(ids)
+        lengths.append(min(len(ids), max_length))
+
+    return torch.tensor(padded, dtype=torch.long), torch.tensor(lengths, dtype=torch.long)
+
+#
+# Step 2.5 — Dataset & DataLoader
+#
+
+class SmilesDataset(Dataset):
+    def __init__(self, smiles_list):
+        self.smiles_list = smiles_list
+    def __len__(self):
+        return len(self.smiles_list)
+    def __getitem__(self, idx):
+        return self.smiles_list[idx]
+
+#
+# Step 3.x — Training Loop (PATCHED: per-tokenizer annealer, exponential TFR, device-safe eval, KL beta logging clarity)
+#
+
+LEARNING_RATE = 1e-5
+BATCH_SIZE = 16
+ACCUMULATION_STEPS = 4
+NUM_EPOCHS = 5
+MAX_SEQ_LEN = 128
+KL_ANNEAL_RATIO = 0.3
+
+def train_vae(
+    model,
+    train_loader,
+    val_loader,
+    optimizer,
+    kl_annealer,
+    pad_token_id,
+    device,
+    num_epochs,
+    accumulation_steps=4,
+    save_dir="./checkpoints",
+    tokenizer_name="default"
+):
+    os.makedirs(save_dir, exist_ok=True)
+    log_file = os.path.join(save_dir, f"training_log_{tokenizer_name}.csv")
+
+    with open(log_file, "w") as f:
+        f.write("epoch,step,train_loss,train_ce,train_kl,val_loss,val_ce,val_kl,kl_beta\n")
+
+    best_val_loss = float('inf')
+
+    for epoch in range(num_epochs):
+        print(f"\n=== Epoch {epoch+1}/{num_epochs} ===")
+        model.train()
+        total_train_loss = total_train_ce = total_train_kl = 0.0
+        num_batches = 0
+
+        optimizer.zero_grad()
+
+        for step, (input_ids, lengths) in enumerate(tqdm(train_loader, desc="Training")):
+            input_ids, lengths = input_ids.to(device), lengths.to(device)
+
+            # ← PATCHED: exponential decay per epoch (not per batch, but smoother than linear)
+            tfr = get_teacher_forcing_ratio(epoch, num_epochs, min_tfr=0.6, warmup_fraction=0.3)
+
+            logits, mu, logvar = model(input_ids, lengths, target_seq=input_ids, teacher_forcing_ratio=tfr)
+            beta = kl_annealer.get_beta(increment=True)
+            loss, ce_loss, kl_loss = vae_loss(logits, input_ids, mu, logvar, pad_token_id, beta=beta)
+
+            loss = loss / accumulation_steps
+            loss.backward()
+
+            total_train_loss += loss.item() * accumulation_steps
+            total_train_ce += ce_loss.item()
+            total_train_kl += kl_loss.item()
+            num_batches += 1
+
+            if (step + 1) % accumulation_steps == 0:
+                optimizer.step()
+                optimizer.zero_grad()
+
+        if len(train_loader) % accumulation_steps != 0:
+            optimizer.step()
+            optimizer.zero_grad()
+
+        # ✅ CAPTURE BETA AFTER TRAINING — BEFORE VALIDATION
+        # This ensures we log the beta that was actually used during training
+        current_beta = kl_annealer.get_beta(increment=False)
+
+        # Validation — DO NOT query beta again here
+        model.eval()
+        total_val_loss = total_val_ce = total_val_kl = 0.0
+        val_batches = 0
+
+        with torch.no_grad():
+            for input_ids, lengths in tqdm(val_loader, desc="Validating"):
+                input_ids, lengths = input_ids.to(device), lengths.to(device)
+                # Use captured beta — DO NOT call kl_annealer again here
+                logits, mu, logvar = model(input_ids, lengths, target_seq=input_ids, teacher_forcing_ratio=0.0)
+                loss, ce_loss, kl_loss = vae_loss(logits, input_ids, mu, logvar, pad_token_id, beta=current_beta)
+
+                total_val_loss += loss.item()
+                total_val_ce += ce_loss.item()
+                total_val_kl += kl_loss.item()
+                val_batches += 1
+
+        avg_train_loss = total_train_loss / num_batches
+        avg_val_loss = total_val_loss / val_batches
+
+        current_step = (epoch + 1) * len(train_loader)
+        with open(log_file, "a") as f:
+            f.write(f"{epoch+1},{current_step},{avg_train_loss:.6f},{total_train_ce/num_batches:.6f},{total_train_kl/num_batches:.6f},"
+                    f"{avg_val_loss:.6f},{total_val_ce/val_batches:.6f},{total_val_kl/val_batches:.6f},{current_beta:.6f}\n")
+
+        print(f"Train Loss: {avg_train_loss:.4f}")
+        print(f"Val Loss:   {avg_val_loss:.4f}")
+        print(f"KL Beta:    {current_beta:.4f}")  # ← Now explicitly the training beta
+
+        if avg_val_loss < best_val_loss:
+            best_val_loss = avg_val_loss
+            checkpoint_path = os.path.join(save_dir, f"best_model_{tokenizer_name}.pt")
+            torch.save({
+                'epoch': epoch + 1,
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'val_loss': avg_val_loss,
+            }, checkpoint_path)
+            print(f"→ Saved best model to {checkpoint_path}")
+
+    return best_val_loss
+
+#
+#   TRAINING LOOP OVER TOKENIZERS (PATCHED: KLAnnealer reset per tokenizer)
+#
+
+for tokenizer in TOKENIZERS:
+    print(f"\n  STARTING TRAINING FOR: {tokenizer.name}\n")
+
+    vocab_size = len(tokenizer)
+    pad_token_id = tokenizer.tokenizer.pad_token_id
+
+    # Validate token IDs
+    sample_ids = tokenizer.encode(train_smiles[0], add_special_tokens=True)['input_ids']
+    max_id_in_sample = max(sample_ids)
+    assert max_id_in_sample < vocab_size, f"Token ID {max_id_in_sample} >= vocab size {vocab_size} in {tokenizer.name}"
+
+    model = MoleculeVAE(
+        vocab_size=len(tokenizer),
+        pad_token_id=tokenizer.pad_token_id,
+        bos_token_id=tokenizer.bos_token_id,
+        eos_token_id=tokenizer.eos_token_id
+    ).to(device)
+
+    ########################################################################
+    # 1. CREATE A FRESH annealer FOR EVERY TOKENIZER
+    ########################################################################
+    
+
+
+    optimizer = Ranger21(
+        model.parameters(),
+        lr=LEARNING_RATE,
+        weight_decay=0.01,
+        use_adabelief=True,
+        use_warmup=True,
+        use_madgrad=True,
+        num_epochs=NUM_EPOCHS,
+        num_batches_per_epoch=len(train_smiles) // (BATCH_SIZE * ACCUMULATION_STEPS),
+        warmdown_active=False,
+    )
+
+    train_dataset = SmilesDataset(train_smiles)
+    val_dataset = SmilesDataset(val_smiles)
+
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=BATCH_SIZE,
+        shuffle=True,
+        collate_fn=lambda batch: collate_fn(batch, tokenizer, max_length=MAX_SEQ_LEN),
+        num_workers=0,
+        pin_memory=True
+    )
+
+    val_loader = DataLoader(
+        val_dataset,
+        batch_size=BATCH_SIZE,
+        shuffle=False,
+        collate_fn=lambda batch: collate_fn(batch, tokenizer, max_length=MAX_SEQ_LEN),
+        num_workers=0,
+        pin_memory=True
+    )
+
+    steps_per_epoch = len(train_loader)
+    total_steps = steps_per_epoch * NUM_EPOCHS
+    # total_steps = (len(train_smiles) // (BATCH_SIZE * ACCUMULATION_STEPS)) * NUM_EPOCHS
+    kl_annealer = KLAnnealer(
+        total_steps=total_steps,
+        n_cycle=1,               # REDUCED: 2 cycles instead of 4 for longer warmup per cycle
+        ratio=0.6,               # INCREASED: 60% of each cycle is warmup (was 25%)
+        mode="linear",           # CHANGED: Linear is more predictable than sigmoid
+        per_epoch=False
+    )
+
+    train_vae(
+        model=model,
+        train_loader=train_loader,
+        val_loader=val_loader,
+        optimizer=optimizer,
+        kl_annealer=kl_annealer,
+        pad_token_id=pad_token_id,
+        device=device,
+        num_epochs=NUM_EPOCHS,
+        accumulation_steps=ACCUMULATION_STEPS,
+        save_dir=f"./checkpoints/{tokenizer.name}",
+        tokenizer_name=tokenizer.name
+    )
+    
+#
+# Step 4.x — Evaluation Pipeline (Fixed Bug #6, #7, #8)
+#
+
+def canonicalize_smiles(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return None
+    return Chem.MolToSmiles(mol, isomericSmiles=True)
+
+def evaluate_reconstruction(model, dataloader, tokenizer, device, max_length=128):
+    model.eval()
+    total_token_correct = total_tokens = exact_matches = valid_count = total_samples = 0
+    all_generated, all_targets = [], []
+
+    pad_id = tokenizer.tokenizer.pad_token_id
+    eos_id = tokenizer.tokenizer.eos_token_id
+    special_ids = {pad_id, eos_id}
+
+    def trim_to_special(ids, specials):
+        for i, id_ in enumerate(ids):
+            if id_ in specials:
+                return ids[:i]
+        return ids
+
+    with torch.no_grad():
+        for input_ids, lengths in tqdm(dataloader, desc="Evaluating Reconstruction"):
+            input_ids, lengths = input_ids.to(device), lengths.to(device)
+            B = input_ids.size(0)
+
+            mu, logvar = model.encode(input_ids, lengths)
+            z = model.reparameterize(mu, logvar)
+            logits = model.decode(z, max_length=128, mode="greedy")  # FIXED #7 for reconstruction
+            preds = logits.argmax(dim=-1)
+
+            # FIXED: Align logits and targets to same sequence length
+            min_len = min(logits.size(1), input_ids.size(1))
+            preds = preds[:, :min_len]          # trim predictions
+            input_ids_eval = input_ids[:, :min_len]  # trim targets
+
+            mask = (input_ids_eval != pad_id)
+            token_correct = ((preds == input_ids_eval) & mask).sum().item()
+            total_token_correct += token_correct
+            total_tokens += mask.sum().item()
+
+            for i in range(B):
+                target_ids = input_ids_eval[i].cpu().tolist()
+                pred_ids = preds[i].cpu().tolist()
+
+                # FIXED BUG #6: Trim before decode
+                target_ids_trim = trim_to_special(target_ids, special_ids)
+                pred_ids_trim = trim_to_special(pred_ids, special_ids)
+
+                target_smiles = tokenizer.decode(target_ids_trim, skip_special_tokens=False)
+                pred_smiles = tokenizer.decode(pred_ids_trim, skip_special_tokens=False)
+
+                all_targets.append(target_smiles)
+                all_generated.append(pred_smiles)
+
+                if pred_smiles == target_smiles:
+                    exact_matches += 1
+                if Chem.MolFromSmiles(pred_smiles) is not None:
+                    valid_count += 1
+                total_samples += 1
+
+    token_acc = total_token_correct / total_tokens if total_tokens > 0 else 0.0
+    exact_match_rate = exact_matches / total_samples
+    validity_rate = valid_count / total_samples
+
+    print(f"Token-level Accuracy: {token_acc:.4f}")
+    print(f"Exact Match Rate:     {exact_match_rate:.4f}")
+    print(f"Validity Rate:        {validity_rate:.4f}")
+
+    return {
+        'token_accuracy': token_acc,
+        'exact_match_rate': exact_match_rate,
+        'validity_rate': validity_rate,
+        'generated_smiles': all_generated,
+        'target_smiles': all_targets
+    }
+
+def compute_uniqueness_and_novelty(generated_smiles, train_smiles_set):
+    total = len(generated_smiles)
+    unique = len(set(generated_smiles))
+    novel = len([s for s in generated_smiles if s not in train_smiles_set])
+    uniqueness = unique / total if total > 0 else 0.0
+    novelty = novel / total if total > 0 else 0.0
+    print(f"Uniqueness: {uniqueness:.4f} ({unique}/{total})")
+    print(f"Novelty:    {novelty:.4f} ({novel}/not in train)")
+    return uniqueness, novelty
+
+def kl_divergence_from_samples(samples, bins=512):
+    dim_kls = []
+    for d in range(samples.shape[1]):
+        data = samples[:, d]
+        hist, bin_edges = np.histogram(data, bins=bins, density=True)
+        bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+        norm_pdf = (1 / np.sqrt(2 * np.pi)) * np.exp(-0.5 * bin_centers**2)
+        hist = np.clip(hist, 1e-10, None)
+        norm_pdf = np.clip(norm_pdf, 1e-10, None)
+        kl = entropy(hist, norm_pdf)
+        dim_kls.append(kl)
+    return np.mean(dim_kls)
+
+def evaluate_latent_kl(model, dataloader, device, latent_dim=128, bins=512):
+    model.eval()
+    all_z = []
+    with torch.no_grad():
+        for input_ids, lengths in tqdm(dataloader, desc="Sampling Latents"):
+            input_ids, lengths = input_ids.to(device), lengths.to(device)
+            mu, logvar = model.encode(input_ids, lengths)
+            z = model.reparameterize(mu, logvar)
+            all_z.append(z.cpu().numpy())
+    all_z = np.concatenate(all_z, axis=0)
+    kl_div = kl_divergence_from_samples(all_z, bins=bins)
+    print(f"KL Divergence (empirical vs N(0,1)): {kl_div:.4f}")
+    return kl_div
+
+def evaluate_interpolation_validity(model, tokenizer, test_smiles, device, num_pairs=100, steps=10, max_length=128):
+    model.eval()
+    pairs = random.sample(list(zip(test_smiles[::2], test_smiles[1::2])), min(num_pairs, len(test_smiles)//2))
+    valid_interps = total_interps = 0
+
+    with torch.no_grad():
+        for smiles_a, smiles_b in tqdm(pairs, desc="Interpolation Validity"):
+            if not smiles_a or not smiles_b: continue
+
+            enc_a = tokenizer.encode(smiles_a, add_special_tokens=True)
+            enc_b = tokenizer.encode(smiles_b, add_special_tokens=True)
+
+            ids_a = torch.tensor([enc_a['input_ids']], device=device)
+            ids_b = torch.tensor([enc_b['input_ids']], device=device)
+            len_a = torch.tensor([len(enc_a['input_ids'])], device=device)
+            len_b = torch.tensor([len(enc_b['input_ids'])], device=device)
+
+            mu_a, _ = model.encode(ids_a, len_a)
+            mu_b, _ = model.encode(ids_b, len_b)
+
+            alphas = torch.linspace(0, 1, steps, device=device)
+            for alpha in alphas:
+                z_interp = alpha * mu_b + (1 - alpha) * mu_a
+                # Ensure z_interp maintains batch dimension [1, latent_dim]
+                if z_interp.dim() == 1:
+                    z_interp = z_interp.unsqueeze(0)
+                
+                logits = model.decode(z_interp, max_length=max_length, mode="sample", temperature=0.8)
+                preds = logits.argmax(dim=-1)
+                # Handle batch dimension properly
+                if preds.dim() > 1:
+                    preds = preds[0]  # Take first (and only) batch item
+                pred_smiles = tokenizer.decode(preds.cpu().tolist(), skip_special_tokens=True)
+                if Chem.MolFromSmiles(pred_smiles) is not None:
+                    valid_interps += 1
+                total_interps += 1
+
+    interp_validity = valid_interps / total_interps if total_interps > 0 else 0.0
+    print(f"Interpolation Validity: {interp_validity:.4f}")
+    return interp_validity
+
+def sample_from_latent(model, tokenizer, num_samples=30000, latent_dim=128, max_length=128, device=device, temperature=0.8):
+    model.eval()
+    generated_smiles = []
+    with torch.no_grad():
+        for _ in tqdm(range(0, num_samples, BATCH_SIZE), desc="Sampling from Latent"):
+            current_batch_size = min(BATCH_SIZE, num_samples - len(generated_smiles))
+            if current_batch_size <= 0: break
+            z = torch.randn(current_batch_size, latent_dim, device=device)
+            logits = model.decode(z, max_length=max_length, mode="sample", temperature=temperature)
+            preds = logits.argmax(dim=-1)
+            for i in range(current_batch_size):
+                pred_ids = preds[i].cpu().tolist()
+                smiles = tokenizer.decode(pred_ids, skip_special_tokens=True)
+                generated_smiles.append(smiles)
+                if len(generated_smiles) >= num_samples: break
+    return generated_smiles
+
+def measure_inference_throughput(model, tokenizer, test_smiles, device,
+                                 max_length=128,
+                                 batch_sizes=[1, 4, 8, 16]):
+    """
+    Benchmark inference speed & peak GPU memory across several batch sizes.
+    Returns a JSON-serialisable dict:
+        {batch_size: {'tokens_per_sec': <float>, 'peak_mem_mb': <float>}, ...}
+    """
+    model.eval()
+    results = {}
+
+    for bs in batch_sizes:
+        # Build a small fixed subset so every BS processes the same #samples
+        subset = SmilesDataset(test_smiles[:bs * 10])
+        loader = DataLoader(
+            subset,
+            batch_size=bs,
+            shuffle=False,
+            num_workers=0,
+            collate_fn=lambda b: collate_fn(b, tokenizer, max_length=max_length),
+        )
+
+        total_tokens = 0
+        if torch.cuda.is_available():
+            torch.cuda.reset_peak_memory_stats(device)
+
+        start_time = time.perf_counter()
+        with torch.no_grad():
+            for input_ids, lengths in loader:
+                input_ids, lengths = input_ids.to(device), lengths.to(device)
+                mu, logvar = model.encode(input_ids, lengths)
+                z = model.reparameterize(mu, logvar)
+                logits = model.decode(z, max_length=max_length)
+                total_tokens += logits.numel()  # number of float elements
+        duration = time.perf_counter() - start_time
+
+        tokens_per_sec = total_tokens / duration
+        peak_mem_mb = (
+            torch.cuda.max_memory_allocated(device) / (1024 ** 2)
+            if torch.cuda.is_available()
+            else 0.0
+        )
+
+        # Store as plain Python floats
+        results[bs] = {
+            "tokens_per_sec": float(tokens_per_sec),
+            "peak_mem_mb": float(peak_mem_mb),
+        }
+        print(f"BS {bs:3d} → {tokens_per_sec:8.2f} tok/s | Peak Mem: {peak_mem_mb:.2f} MB")
+
+    return results
+
+#
+# FINAL EVALUATION PIPELINE
+#
+
+def full_evaluation_pipeline(model, tokenizer, train_smiles, test_smiles, device, save_dir):
+    print(f"\n  FULL EVALUATION FOR: {tokenizer.name}")
+
+    test_dataset = SmilesDataset(test_smiles)
+    test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False,
+        collate_fn=lambda b: collate_fn(b, tokenizer, max_length=MAX_SEQ_LEN),
+        num_workers=0)
+
+    # 1. Reconstruction
+    recon_metrics = evaluate_reconstruction(model, test_loader, tokenizer, device)
+
+    # 2. Uniqueness & Novelty
+    train_set = set(train_smiles)
+    uniqueness, novelty = compute_uniqueness_and_novelty(recon_metrics['generated_smiles'], train_set)
+
+    # 3. KL Divergence
+    kl_div = evaluate_latent_kl(model, test_loader, device)
+
+    # 4. Interpolation Validity
+    interp_validity = evaluate_interpolation_validity(model, tokenizer, test_smiles, device)
+
+    # 5. Latent Sampling (for FCD — optional)
+    # gen_smiles_30k = sample_from_latent(model, tokenizer, num_samples=10000, temperature=0.8)  # reduce for speed
+    # fcd_score = compute_fcd(test_smiles, gen_smiles_30k) if 'get_fcd' in globals() else None
+
+    # 6. Throughput & Memory
+    # throughput = measure_inference_throughput(model, tokenizer, test_loader, device)
+
+    eval_results = {
+        **recon_metrics,
+        'uniqueness': uniqueness,
+        'novelty': novelty,
+        'kl_divergence': kl_div,
+        'interpolation_validity': interp_validity,
+        # 'fcd': fcd_score,
+        # 'inference_throughput': throughput,
+    }
+
+    eval_path = os.path.join(save_dir, "evaluation_results.json")
+    with open(eval_path, "w") as f:
+        json.dump(eval_results, f, indent=2, default=str)
+
+    print(f"  Evaluation saved to {eval_path}")
+    return eval_results
+
+#
+#   RUN EVALUATION FOR EACH TOKENIZER
+#
+
+for tokenizer in TOKENIZERS:
+    print(f"\n🔄 LOADING BEST MODEL FOR: {tokenizer.name}")
+    checkpoint_path = f"./checkpoints/{tokenizer.name}/best_model_{tokenizer.name}.pt"
+    if not os.path.exists(checkpoint_path):
+        print(f"⚠️  Checkpoint not found: {checkpoint_path}")
+        continue
+
+    vocab_size = len(tokenizer)
+    pad_token_id = tokenizer.tokenizer.pad_token_id
+    model = MoleculeVAE(
+        vocab_size=vocab_size, 
+        pad_token_id=pad_token_id,
+        bos_token_id=tokenizer.bos_token_id,
+        eos_token_id=tokenizer.eos_token_id
+    ).to(device)
+
+    checkpoint = torch.load(checkpoint_path, map_location=device)
+    model.load_state_dict(checkpoint['model_state_dict'])
+    model.eval()
+
+    full_evaluation_pipeline(
+        model=model,
+        tokenizer=tokenizer,
+        train_smiles=train_smiles,
+        test_smiles=test_smiles,
+        device=device,
+        save_dir=f"./checkpoints/{tokenizer.name}"
+    )
+
+print("\n🎉 PIPELINE COMPLETE — ALL TOKENIZERS BENCHMARKED, TRAINED, AND EVALUATED!")

benchmark/benchmark_HF_simpler.py

@@ -0,0 +1,895 @@
+#
+# Molecule Tokenizer Benchmark & VAE Training Pipeline
+# PATCHED VERSION — Updated for FastChemTokenizerHF (HF compatible)
+# PATCHED: Simplified KL annealing (linear warmup), updated TFR schedule, updated training loop
+#
+#
+# Step 1.1 — Imports & Reproducibility
+#
+import os
+import time
+import random
+import pandas as pd
+from pathlib import Path
+from datetime import datetime
+import torch
+import numpy as np
+# Tokenizers
+from transformers import AutoTokenizer
+from FastChemTokenizerHF import FastChemTokenizer
+# Optional: for progress bars
+from tqdm import tqdm
+from rdkit import Chem
+from sklearn.model_selection import train_test_split
+import torch.nn as nn
+import torch.nn.functional as F
+from ranger21 import Ranger21
+from torch.utils.data import DataLoader, Dataset
+from scipy.stats import entropy
+import json
+import math
+from typing import Optional, Tuple, Union
+from rdkit import RDLogger
+RDLogger.DisableLog('rdApp.*')  
+# Set seeds for reproducibility
+def set_seed(seed=42):
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    os.environ['PYTHONHASHSEED'] = str(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+set_seed(42)
+# Device setup
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+print(f"Using device: {device}")
+#
+# Step 1.2 — Load & Preprocess SMILES Corpus
+#
+data_path = "./data/chunk_1smi.csv"
+df = pd.read_csv(data_path)
+# Replace df with a 10% sample for prototyping
+df = df.sample(frac=0.1, random_state=42).reset_index(drop=True)
+print(f"Prototype size: {len(df)} rows")
+if 'SMILES' not in df.columns:
+    raise ValueError("Expected column 'SMILES' in CSV")
+smiles_list = df['SMILES'].dropna().tolist()
+print(f"Loaded {len(smiles_list)} SMILES (assumed pre-canonicalized)")
+# Validate with RDKit
+def is_valid_smiles(smiles):
+    return Chem.MolFromSmiles(smiles) is not None
+print("Validating SMILES with RDKit...")
+valid_mask = [is_valid_smiles(s) for s in tqdm(smiles_list)]
+smiles_list = [s for s, valid in zip(smiles_list, valid_mask) if valid]
+print(f"After RDKit filtering: {len(smiles_list)} valid SMILES")
+#
+# Step 1.3 — Train/Val/Test Split (80/10/10)
+#
+train_smiles, temp_smiles = train_test_split(smiles_list, test_size=0.2, random_state=42, shuffle=True)
+val_smiles, test_smiles = train_test_split(temp_smiles, test_size=0.5, random_state=42, shuffle=True)
+print(f"Train: {len(train_smiles)}")
+print(f"Val:   {len(val_smiles)}")
+print(f"Test:  {len(test_smiles)}")
+# Cache splits
+splits = {'train': train_smiles, 'val': val_smiles, 'test': test_smiles}
+for split_name, smiles in splits.items():
+    with open(f"./data/{split_name}_smiles.txt", "w") as f:
+        f.write("\n".join(smiles))
+#
+# Step 1.4 — Tokenizer Wrapper (Simplified for HF compatibility)
+#
+class TokenizerWrapper:
+    def __init__(self, tokenizer, name,
+                 bos_token="<s>", eos_token="</s>",
+                 pad_token="<pad>", unk_token="<unk>"):
+        self.tokenizer = tokenizer
+        self.name = name
+        # Only call add_special_tokens if the tokenizer actually supports it
+        if hasattr(tokenizer, "add_special_tokens") and callable(tokenizer.add_special_tokens):
+            try:
+                tokenizer.add_special_tokens({
+                    "bos_token": bos_token,
+                    "eos_token": eos_token,
+                    "pad_token": pad_token,
+                    "unk_token": unk_token,
+                })
+            except NotImplementedError:
+                # Your FastChemTokenizerHF already defines these tokens internally
+                pass
+    def encode(self, smiles: str, add_special_tokens: bool = True):
+        return self.tokenizer(
+            smiles,
+            add_special_tokens=add_special_tokens,
+            return_attention_mask=False,
+            return_tensors=None
+        )
+    def decode(self, token_ids, skip_special_tokens=True):
+        return self.tokenizer.decode(token_ids, skip_special_tokens=skip_special_tokens)
+    def __len__(self):
+        return len(self.tokenizer)
+    def get_vocab(self):
+        return self.tokenizer.get_vocab()
+    @property
+    def bos_token_id(self):
+        return self.tokenizer.bos_token_id
+    @property
+    def eos_token_id(self):
+        return self.tokenizer.eos_token_id
+    @property
+    def pad_token_id(self):
+        return self.tokenizer.pad_token_id
+    @property
+    def unk_token_id(self):
+        return self.tokenizer.unk_token_id
+#
+# Step 1.5 — Initialize Tokenizers
+#
+tok1_hf = AutoTokenizer.from_pretrained("seyonec/ChemBERTa-zinc-base-v1")
+tok2_fast = FastChemTokenizer.from_pretrained("../smitok")
+tokenizer1 = TokenizerWrapper(tok1_hf, name="ChemBERTa", bos_token="<s>", eos_token="</s>", pad_token="<pad>", unk_token="<unk>")
+tokenizer2 = TokenizerWrapper(tok2_fast, name="FastChemTokenizerHF", bos_token="<s>", eos_token="</s>", pad_token="<pad>", unk_token="<unk>")
+TOKENIZERS = [tokenizer1, tokenizer2]
+#
+# Step 1.6 — Benchmarking Functions (Fixed Bug #4 implicitly via epsilon)
+#
+def benchmark_tokenizer(tokenizer, smiles_sample, encode_only=False):
+    V = len(tokenizer)
+    sample = smiles_sample[:10000] if len(smiles_sample) > 10000 else smiles_sample
+    encode_times, token_counts, char_counts = [], [], []
+    unk_counts, total_tokens = 0, 0
+    for smiles in tqdm(sample, desc=f"Encoding with {tokenizer.name}", leave=False):
+        char_counts.append(len(smiles))
+        start = time.perf_counter()
+        enc = tokenizer.encode(smiles, add_special_tokens=True)
+        end = time.perf_counter()
+        encode_times.append(end - start)
+        input_ids = enc['input_ids']
+        token_counts.append(len(input_ids))
+        total_tokens += len(input_ids)
+        unk_id = tokenizer.tokenizer.unk_token_id
+        unk_counts += input_ids.count(unk_id)
+    L_bar = np.mean(token_counts)
+    C = np.mean(char_counts) / L_bar
+    U = unk_counts / total_tokens if total_tokens > 0 else 0.0
+    Tenc = len(sample) / sum(encode_times)
+    metrics = {
+        'vocab_size': V,
+        'avg_tokens_per_mol': L_bar,
+        'compression_ratio': C,
+        'percent_unknown': U * 100,
+        'encode_throughput_smiles_per_sec': Tenc,
+    }
+    if encode_only:
+        return metrics
+    decode_times, reconstruction_ok = [], 0
+    for smiles in tqdm(sample, desc=f"Decoding with {tokenizer.name}", leave=False):
+        enc = tokenizer.encode(smiles, add_special_tokens=True)
+        input_ids = enc['input_ids']
+        start = time.perf_counter()
+        decoded = tokenizer.decode(input_ids, skip_special_tokens=True)
+        end = time.perf_counter()
+        decode_times.append(end - start)
+        if decoded == smiles:
+            reconstruction_ok += 1
+    Tdec = len(sample) / sum(decode_times)
+    recon_acc = reconstruction_ok / len(sample)
+    metrics.update({
+        'decode_throughput_smiles_per_sec': Tdec,
+        'decode_reconstruction_accuracy': recon_acc * 100,
+    })
+    return metrics
+#
+# Step 1.7 — Run Benchmark
+#
+benchmark_sample = train_smiles
+results = []
+for tokenizer in TOKENIZERS:
+    print(f"\n=== Benchmarking {tokenizer.name} ===")
+    metrics = benchmark_tokenizer(tokenizer, benchmark_sample)
+    metrics['tokenizer'] = tokenizer.name
+    results.append(metrics)
+    for k, v in metrics.items():
+        if k != 'tokenizer':
+            print(f"{k:35s}: {v:.4f}" if isinstance(v, float) else f"{k:35s}: {v}")
+df_results = pd.DataFrame(results)
+df_results.to_csv("tokenizer_benchmark_results.csv", index=False)
+print("\nTokenizer benchmark results saved to 'tokenizer_benchmark_results.csv'")
+#
+# Step 2.1 — VAE Model Class (PATCHED: decode stops at EOS)
+#
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Tuple, Union
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Tuple, Optional
+class MoleculeVAE(nn.Module):
+    """
+    Optimized MoleculeVAE with:
+    - Bidirectional encoder (restored)
+    - Proper latent2hidden + latent2cell (restored)
+    - Adjustable dropout for small dataset
+    - Attention pooling option
+    - Quantization-ready hooks
+    """
+    def __init__(self, 
+                 vocab_size: int, 
+                 embed_dim: int = 64,
+                 hidden_dim: int = 128,
+                 latent_dim: int = 64,
+                 num_layers: int = 2,
+                 pad_token_id: int = 0, 
+                 bos_token_id: int = 1, 
+                 eos_token_id: int = 2,
+                 dropout: float = 0.2,
+                 use_attention: bool = True,
+                 quantize_ready: bool = False):
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.embed_dim = embed_dim
+        self.hidden_dim = hidden_dim
+        self.latent_dim = latent_dim
+        self.num_layers = num_layers
+        self.pad_token_id = pad_token_id
+        self.bos_token_id = bos_token_id
+        self.eos_token_id = eos_token_id
+        self.use_attention = use_attention
+        # Shared embedding
+        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=pad_token_id)
+        # Bidirectional encoder
+        self.encoder_lstm = nn.LSTM(
+            embed_dim, hidden_dim, num_layers,
+            batch_first=True, dropout=dropout if num_layers > 1 else 0,
+            bidirectional=True
+        )
+        # Attention pooling (optional)
+        if use_attention:
+            self.attention = nn.MultiheadAttention(
+                hidden_dim * 2, num_heads=4, dropout=dropout, batch_first=True
+            )
+            self.attention_linear = nn.Linear(hidden_dim * 2, 1)
+        self.encoder_norm = nn.LayerNorm(hidden_dim * 2)
+        # Latent bottleneck
+        self.fc_mu = nn.Linear(hidden_dim * 2, latent_dim)
+        self.fc_logvar = nn.Linear(hidden_dim * 2, latent_dim)
+        # Decoder init (restored)
+        self.latent2hidden = nn.Linear(latent_dim, num_layers * hidden_dim)
+        self.latent2cell   = nn.Linear(latent_dim, num_layers * hidden_dim)
+        # Decoder
+        self.decoder_lstm = nn.LSTM(
+            embed_dim, hidden_dim, num_layers,
+            batch_first=True, dropout=dropout if num_layers > 1 else 0
+        )
+        self.decoder_norm = nn.LayerNorm(hidden_dim)
+        self.fc_out = nn.Linear(hidden_dim, vocab_size)
+        # Weight tying
+        if embed_dim == hidden_dim:
+            self.fc_out.weight = self.embedding.weight
+        self.dropout = nn.Dropout(dropout)
+        # Quantization stubs
+        if quantize_ready:
+            self.quant = torch.quantization.QuantStub()
+            self.dequant = torch.quantization.DeQuantStub()
+        else:
+            self.quant = self.dequant = nn.Identity()
+        self._init_weights()
+    def _init_weights(self):
+        for name, param in self.named_parameters():
+            if 'weight' in name:
+                if param.ndim >= 2:
+                    nn.init.xavier_uniform_(param)
+                else:
+                    nn.init.normal_(param, 0, 0.01)
+            elif 'bias' in name:
+                nn.init.zeros_(param)
+    def _pool_sequence(self, packed_output, lengths):
+        output, _ = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)
+        if self.use_attention:
+            attn_out, _ = self.attention(output, output, output)
+            weights = torch.softmax(self.attention_linear(attn_out), dim=1)
+            pooled = (weights * output).sum(dim=1)
+        else:
+            # mean pooling with mask
+            batch_size, max_len, _ = output.size()
+            mask = torch.arange(max_len, device=output.device).expand(batch_size, max_len) < lengths.unsqueeze(1)
+            masked_output = output * mask.unsqueeze(-1).float()
+            pooled = masked_output.sum(dim=1) / lengths.unsqueeze(-1).float()
+        return pooled
+    def encode(self, x: torch.Tensor, lengths: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        x = self.quant(x)
+        embedded = self.dropout(self.embedding(x))
+        packed = nn.utils.rnn.pack_padded_sequence(
+            embedded, lengths.cpu(), batch_first=True, enforce_sorted=False
+        )
+        packed_out, _ = self.encoder_lstm(packed)
+        h = self._pool_sequence(packed_out, lengths)
+        h = self.encoder_norm(h)
+        mu, logvar = self.fc_mu(h), self.fc_logvar(h)
+        return mu, logvar
+    def reparameterize(self, mu: torch.Tensor, logvar: torch.Tensor) -> torch.Tensor:
+        if self.training:
+            std = torch.exp(0.5 * logvar)
+            eps = torch.randn_like(std)
+            return mu + eps * std
+        return mu
+    def _init_decoder_state(self, z: torch.Tensor):
+        batch_size = z.size(0)
+        h0 = self.latent2hidden(z).view(self.num_layers, batch_size, self.hidden_dim)
+        c0 = self.latent2cell(z).view(self.num_layers, batch_size, self.hidden_dim)
+        return h0, c0
+    def decode(self, z: torch.Tensor, max_length: int = 64, mode: str = "greedy", temperature: float = 1.0):
+        batch_size = z.size(0)
+        device = z.device
+        h0, c0 = self._init_decoder_state(z)
+        hidden = (h0, c0)
+        input_ids = torch.full((batch_size, 1), self.bos_token_id, dtype=torch.long, device=device)
+        finished = torch.zeros(batch_size, dtype=torch.bool, device=device)
+        logits_list = []
+        for _ in range(max_length):
+            embedded = self.embedding(input_ids)
+            output, hidden = self.decoder_lstm(embedded, hidden)
+            output = self.decoder_norm(output)
+            logit = self.fc_out(output)
+            logits_list.append(logit)
+            if mode == "greedy":
+                next_tokens = logit.argmax(dim=-1)
+            elif mode == "sample":
+                probs = F.softmax(logit.squeeze(1) / temperature, dim=-1)
+                next_tokens = torch.multinomial(probs, 1)
+            else:
+                raise ValueError(f"Unknown decode mode: {mode}")
+            just_finished = (next_tokens.squeeze(-1) == self.eos_token_id)
+            finished |= just_finished
+            next_tokens = torch.where(
+                finished.unsqueeze(-1),
+                torch.tensor(self.pad_token_id, device=device),
+                next_tokens
+            )
+            input_ids = next_tokens
+            if finished.all():
+                break
+        return self.dequant(torch.cat(logits_list, dim=1))
+    def forward(self, input_ids: torch.Tensor, lengths: torch.Tensor,
+                target_seq: Optional[torch.Tensor] = None,
+                teacher_forcing_ratio: float = 0.0,
+                temperature: float = 1.0):
+        mu, logvar = self.encode(input_ids, lengths)
+        z = self.reparameterize(mu, logvar)
+        if self.training and target_seq is not None and teacher_forcing_ratio > 0:
+            return self._forward_teacher_forcing(z, target_seq, teacher_forcing_ratio), mu, logvar
+        else:
+            max_len = target_seq.size(1) if target_seq is not None else 64
+            return self.decode(z, max_length=max_len, temperature=temperature), mu, logvar
+    def _forward_teacher_forcing(self, z: torch.Tensor, target_seq: torch.Tensor, teacher_forcing_ratio: float):
+        batch_size, seq_len = target_seq.size()
+        h0, c0 = self._init_decoder_state(z)
+        hidden = (h0, c0)
+        logits_list = []
+        input_token = target_seq[:, 0:1]
+        for t in range(1, seq_len):
+            embedded = self.embedding(input_token)
+            output, hidden = self.decoder_lstm(embedded, hidden)
+            output = self.decoder_norm(output)
+            logit = self.fc_out(output)
+            logits_list.append(logit)
+            if torch.rand(1).item() < teacher_forcing_ratio:
+                input_token = target_seq[:, t:t+1]
+            else:
+                input_token = logit.argmax(dim=-1)
+        return torch.cat(logits_list, dim=1)
+
+# ============================
+# Utility: Simple Linear KL Warmup (PATCHED IN)
+# ============================
+def linear_kl_beta(global_step: int, warmup_steps: int, start: float = 0.0, end: float = 1.0):
+    """Linear schedule from start → end over warmup_steps. Caps at end."""
+    if warmup_steps <= 0:
+        return float(end)
+    frac = float(global_step) / float(max(1, warmup_steps))
+    return float(start + (end - start) * min(1.0, frac))
+
+#
+# Step 2.2 — Loss Function (PATCHED: β applied OUTSIDE, not inside)
+#
+# PATCH 2: Fix VAE Loss Function - Ensure beta is properly applied
+# Replace the existing vae_loss function:
+def vae_loss(logits, targets, mu, logvar, pad_token_id, beta=1.0):
+    # 1. align lengths
+    max_len = max(logits.size(1), targets.size(1))
+    if logits.size(1) < max_len:
+        logits = F.pad(logits, (0, 0, 0, max_len - logits.size(1)))
+    if targets.size(1) < max_len:
+        targets = F.pad(targets, (0, max_len - targets.size(1)), value=pad_token_id)
+    logits_flat = logits.view(-1, logits.size(-1))          # [B*L, V]
+    targets_flat = targets.reshape(-1)                      # [B*L]
+    mask = (targets_flat != pad_token_id).float()
+    ce_loss = F.cross_entropy(logits_flat, targets_flat, reduction='none')
+    mask_sum = mask.sum()
+    ce_loss = (ce_loss * mask).sum() / (mask_sum + 1e-8)
+    # FIXED: Raw KL loss computation
+    kl_loss_raw = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp(), dim=1)
+    # Apply mask to KL loss if needed (but typically KL is per-sample)
+    kl_loss = kl_loss_raw.mean()
+    # CRITICAL FIX: Apply beta scaling correctly
+    total_loss = ce_loss + beta * kl_loss
+    return total_loss, ce_loss, kl_loss
+
+# ============================
+# Teacher Forcing Ratio Schedule (PATCHED IN)
+# ============================
+def get_teacher_forcing_ratio(epoch, num_epochs, min_tfr=0.6, warmup_fraction=0.3):
+    """Linear schedule: 1.0 until warmup_epochs, then linear decay to min_tfr."""
+    warmup_epochs = int(num_epochs * warmup_fraction)
+    if epoch < warmup_epochs:
+        return 1.0
+    else:
+        progress = (epoch - warmup_epochs) / max(1, num_epochs - warmup_epochs)
+        return max(min_tfr, 1.0 - (1.0 - min_tfr) * progress)
+
+# REMOVED: KLAnnealer class (PATCHED OUT)
+
+#
+# Step 2.4 — Collate Function (Fixed Bug #2: dynamic pad id)
+#
+def collate_fn(batch, tokenizer, max_length=128):
+    encodings = [tokenizer.encode(s, add_special_tokens=True) for s in batch]
+    input_ids = [e['input_ids'] for e in encodings]
+    max_len = min(max(len(ids) for ids in input_ids), max_length)
+    padded = []
+    lengths = []
+    pad_token_id = tokenizer.tokenizer.pad_token_id  #   FIXED: dynamic
+    for ids in input_ids:
+        if len(ids) > max_length:
+            ids = ids[:max_length]
+        else:
+            ids = ids + [pad_token_id] * (max_len - len(ids))
+        padded.append(ids)
+        lengths.append(min(len(ids), max_length))
+    return torch.tensor(padded, dtype=torch.long), torch.tensor(lengths, dtype=torch.long)
+#
+# Step 2.5 — Dataset & DataLoader
+#
+class SmilesDataset(Dataset):
+    def __init__(self, smiles_list):
+        self.smiles_list = smiles_list
+    def __len__(self):
+        return len(self.smiles_list)
+    def __getitem__(self, idx):
+        return self.smiles_list[idx]
+
+# ============================
+# Training Loop (PATCHED: Uses linear_kl_beta)
+# ============================
+LEARNING_RATE = 1e-5
+BATCH_SIZE = 16
+ACCUMULATION_STEPS = 4
+NUM_EPOCHS = 1
+MAX_SEQ_LEN = 128
+KL_WARMUP_FRAC = 0.1  # PATCHED: New parameter for KL warmup fraction
+
+def train_vae(
+    model,
+    train_loader,
+    val_loader,
+    optimizer,
+    pad_token_id,
+    device,
+    num_epochs,
+    accumulation_steps=4,
+    save_dir="./checkpoints",
+    tokenizer_name="default",
+    warmup_steps=100, # PATCHED: New parameter for warmup steps
+):
+    os.makedirs(save_dir, exist_ok=True)
+    log_file = os.path.join(save_dir, f"training_log_{tokenizer_name}.csv")
+    with open(log_file, "w") as f:
+        f.write("epoch,step,train_loss,train_ce,train_kl,val_loss,val_ce,val_kl,kl_beta\n")
+
+    best_val_loss = float('inf')
+    global_step = 0  # PATCHED: Initialize global step counter
+
+    for epoch in range(num_epochs):
+        print(f"\n=== Epoch {epoch+1}/{num_epochs} ===")
+        model.train()
+        total_train_loss = total_train_ce = total_train_kl = 0.0
+        num_batches = 0
+
+        optimizer.zero_grad()
+
+        for step, (input_ids, lengths) in enumerate(tqdm(train_loader, desc="Training")):
+            input_ids, lengths = input_ids.to(device), lengths.to(device)
+            tfr = get_teacher_forcing_ratio(epoch, num_epochs, min_tfr=0.6, warmup_fraction=0.3)
+
+            logits, mu, logvar = model(input_ids, lengths, target_seq=input_ids, teacher_forcing_ratio=tfr)
+
+            beta = linear_kl_beta(global_step, warmup_steps) # PATCHED: Use linear_kl_beta
+            loss, ce_loss, kl_loss = vae_loss(logits, input_ids, mu, logvar, pad_token_id, beta=beta)
+
+            loss = loss / accumulation_steps
+            loss.backward()
+
+            total_train_loss += loss.item() * accumulation_steps
+            total_train_ce += ce_loss.item()
+            total_train_kl += kl_loss.item()
+            num_batches += 1
+
+            if (step + 1) % accumulation_steps == 0:
+                optimizer.step()
+                optimizer.zero_grad()
+                global_step += 1  # PATCHED: Increment global step
+
+        if len(train_loader) % accumulation_steps != 0:
+            optimizer.step()
+            optimizer.zero_grad()
+            global_step += 1  # PATCHED: Increment global step
+
+        current_beta = linear_kl_beta(global_step, warmup_steps) # PATCHED: Get current beta after training
+
+        model.eval()
+        total_val_loss = total_val_ce = total_val_kl = 0.0
+        val_batches = 0
+
+        with torch.no_grad():
+            for input_ids, lengths in tqdm(val_loader, desc="Validating"):
+                input_ids, lengths = input_ids.to(device), lengths.to(device)
+                logits, mu, logvar = model(input_ids, lengths, target_seq=input_ids, teacher_forcing_ratio=0.0)
+                loss, ce_loss, kl_loss = vae_loss(logits, input_ids, mu, logvar, pad_token_id, beta=current_beta) # PATCHED: Use current_beta
+                total_val_loss += loss.item()
+                total_val_ce += ce_loss.item()
+                total_val_kl += kl_loss.item()
+                val_batches += 1
+
+        avg_train_loss = total_train_loss / num_batches
+        avg_val_loss = total_val_loss / val_batches
+
+        current_step = (epoch + 1) * len(train_loader)
+        with open(log_file, "a") as f:
+            f.write(f"{epoch+1},{current_step},{avg_train_loss:.6f},{total_train_ce/num_batches:.6f},{total_train_kl/num_batches:.6f},"
+                    f"{avg_val_loss:.6f},{total_val_ce/val_batches:.6f},{total_val_kl/val_batches:.6f},{current_beta:.6f}\n")
+
+        print(f"Train Loss: {avg_train_loss:.4f}")
+        print(f"Val Loss:   {avg_val_loss:.4f}")
+        print(f"KL Beta:    {current_beta:.4f}")
+
+        if avg_val_loss < best_val_loss:
+            best_val_loss = avg_val_loss
+            checkpoint_path = os.path.join(save_dir, f"best_model_{tokenizer_name}.pt")
+            torch.save({
+                'epoch': epoch + 1,
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'val_loss': avg_val_loss,
+            }, checkpoint_path)
+            print(f"→ Saved best model to {checkpoint_path}")
+
+    return best_val_loss # PATCHED: Return best_val_loss
+
+#
+#   TRAINING LOOP OVER TOKENIZERS (PATCHED: Uses linear_kl_beta, calculates warmup_steps)
+#
+for tokenizer in TOKENIZERS:
+    print(f"\n  STARTING TRAINING FOR: {tokenizer.name}\n")
+    vocab_size = len(tokenizer)
+    pad_token_id = tokenizer.tokenizer.pad_token_id
+    # Validate token IDs
+    sample_ids = tokenizer.encode(train_smiles[0], add_special_tokens=True)['input_ids']
+    max_id_in_sample = max(sample_ids)
+    assert max_id_in_sample < vocab_size, f"Token ID {max_id_in_sample} >= vocab size {vocab_size} in {tokenizer.name}"
+    model = MoleculeVAE(
+        vocab_size=len(tokenizer),
+        pad_token_id=tokenizer.pad_token_id,
+        bos_token_id=tokenizer.bos_token_id,
+        eos_token_id=tokenizer.eos_token_id
+    ).to(device)
+    ########################################################################
+    # 1. CREATE A FRESH optimizer FOR EVERY TOKENIZER
+    ########################################################################
+    optimizer = Ranger21(
+        model.parameters(),
+        lr=LEARNING_RATE,
+        weight_decay=0.01,
+        use_adabelief=True,
+        use_warmup=True, # Keep Ranger21's LR warmup as-is
+        use_madgrad=True,
+        num_epochs=NUM_EPOCHS,
+        num_batches_per_epoch=len(train_smiles) // (BATCH_SIZE * ACCUMULATION_STEPS),
+        warmdown_active=False,
+    )
+    train_dataset = SmilesDataset(train_smiles)
+    val_dataset = SmilesDataset(val_smiles)
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=BATCH_SIZE,
+        shuffle=True,
+        collate_fn=lambda batch: collate_fn(batch, tokenizer, max_length=MAX_SEQ_LEN),
+        num_workers=0,
+        pin_memory=True
+    )
+    val_loader = DataLoader(
+        val_dataset,
+        batch_size=BATCH_SIZE,
+        shuffle=False,
+        collate_fn=lambda batch: collate_fn(batch, tokenizer, max_length=MAX_SEQ_LEN),
+        num_workers=0,
+        pin_memory=True
+    )
+    steps_per_epoch = len(train_loader)
+    total_steps = steps_per_epoch * NUM_EPOCHS
+    # Calculate warmup steps based on total steps and fraction
+    warmup_steps = int(total_steps * KL_WARMUP_FRAC) # PATCHED: Calculate warmup steps
+
+    train_vae(
+        model=model,
+        train_loader=train_loader,
+        val_loader=val_loader,
+        optimizer=optimizer,
+        pad_token_id=pad_token_id,
+        device=device,
+        num_epochs=NUM_EPOCHS,
+        accumulation_steps=ACCUMULATION_STEPS,
+        save_dir=f"./checkpoints/{tokenizer.name}",
+        tokenizer_name=tokenizer.name,
+        warmup_steps=warmup_steps, # PATCHED: Pass warmup_steps
+    )
+
+#
+# Step 4.x — Evaluation Pipeline (Fixed Bug #6, #7, #8)
+#
+def canonicalize_smiles(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return None
+    return Chem.MolToSmiles(mol, isomericSmiles=True)
+def evaluate_reconstruction(model, dataloader, tokenizer, device, max_length=128):
+    model.eval()
+    total_token_correct = total_tokens = exact_matches = valid_count = total_samples = 0
+    all_generated, all_targets = [], []
+    pad_id = tokenizer.tokenizer.pad_token_id
+    eos_id = tokenizer.tokenizer.eos_token_id
+    special_ids = {pad_id, eos_id}
+    def trim_to_special(ids, specials):
+        for i, id_ in enumerate(ids):
+            if id_ in specials:
+                return ids[:i]
+        return ids
+    with torch.no_grad():
+        for input_ids, lengths in tqdm(dataloader, desc="Evaluating Reconstruction"):
+            input_ids, lengths = input_ids.to(device), lengths.to(device)
+            B = input_ids.size(0)
+            mu, logvar = model.encode(input_ids, lengths)
+            z = model.reparameterize(mu, logvar)
+            logits = model.decode(z, max_length=128, mode="greedy")  # FIXED #7 for reconstruction
+            preds = logits.argmax(dim=-1)
+            # FIXED: Align logits and targets to same sequence length
+            min_len = min(logits.size(1), input_ids.size(1))
+            preds = preds[:, :min_len]          # trim predictions
+            input_ids_eval = input_ids[:, :min_len]  # trim targets
+            mask = (input_ids_eval != pad_id)
+            token_correct = ((preds == input_ids_eval) & mask).sum().item()
+            total_token_correct += token_correct
+            total_tokens += mask.sum().item()
+            for i in range(B):
+                target_ids = input_ids_eval[i].cpu().tolist()
+                pred_ids = preds[i].cpu().tolist()
+                # FIXED BUG #6: Trim before decode
+                target_ids_trim = trim_to_special(target_ids, special_ids)
+                pred_ids_trim = trim_to_special(pred_ids, special_ids)
+                target_smiles = tokenizer.decode(target_ids_trim, skip_special_tokens=False)
+                pred_smiles = tokenizer.decode(pred_ids_trim, skip_special_tokens=False)
+                all_targets.append(target_smiles)
+                all_generated.append(pred_smiles)
+                if pred_smiles == target_smiles:
+                    exact_matches += 1
+                if Chem.MolFromSmiles(pred_smiles) is not None:
+                    valid_count += 1
+                total_samples += 1
+    token_acc = total_token_correct / total_tokens if total_tokens > 0 else 0.0
+    exact_match_rate = exact_matches / total_samples
+    validity_rate = valid_count / total_samples
+    print(f"Token-level Accuracy: {token_acc:.4f}")
+    print(f"Exact Match Rate:     {exact_match_rate:.4f}")
+    print(f"Validity Rate:        {validity_rate:.4f}")
+    return {
+        'token_accuracy': token_acc,
+        'exact_match_rate': exact_match_rate,
+        'validity_rate': validity_rate,
+        'generated_smiles': all_generated,
+        'target_smiles': all_targets
+    }
+def compute_uniqueness_and_novelty(generated_smiles, train_smiles_set):
+    total = len(generated_smiles)
+    unique = len(set(generated_smiles))
+    novel = len([s for s in generated_smiles if s not in train_smiles_set])
+    uniqueness = unique / total if total > 0 else 0.0
+    novelty = novel / total if total > 0 else 0.0
+    print(f"Uniqueness: {uniqueness:.4f} ({unique}/{total})")
+    print(f"Novelty:    {novelty:.4f} ({novel}/not in train)")
+    return uniqueness, novelty
+def kl_divergence_from_samples(samples, bins=512):
+    dim_kls = []
+    for d in range(samples.shape[1]):
+        data = samples[:, d]
+        hist, bin_edges = np.histogram(data, bins=bins, density=True)
+        bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+        norm_pdf = (1 / np.sqrt(2 * np.pi)) * np.exp(-0.5 * bin_centers**2)
+        hist = np.clip(hist, 1e-10, None)
+        norm_pdf = np.clip(norm_pdf, 1e-10, None)
+        kl = entropy(hist, norm_pdf)
+        dim_kls.append(kl)
+    return np.mean(dim_kls)
+def evaluate_latent_kl(model, dataloader, device, latent_dim=128, bins=512):
+    model.eval()
+    all_z = []
+    with torch.no_grad():
+        for input_ids, lengths in tqdm(dataloader, desc="Sampling Latents"):
+            input_ids, lengths = input_ids.to(device), lengths.to(device)
+            mu, logvar = model.encode(input_ids, lengths)
+            z = model.reparameterize(mu, logvar)
+            all_z.append(z.cpu().numpy())
+    all_z = np.concatenate(all_z, axis=0)
+    kl_div = kl_divergence_from_samples(all_z, bins=bins)
+    print(f"KL Divergence (empirical vs N(0,1)): {kl_div:.4f}")
+    return kl_div
+def evaluate_interpolation_validity(model, tokenizer, test_smiles, device, num_pairs=100, steps=10, max_length=128):
+    model.eval()
+    pairs = random.sample(list(zip(test_smiles[::2], test_smiles[1::2])), min(num_pairs, len(test_smiles)//2))
+    valid_interps = total_interps = 0
+    with torch.no_grad():
+        for smiles_a, smiles_b in tqdm(pairs, desc="Interpolation Validity"):
+            if not smiles_a or not smiles_b: continue
+            enc_a = tokenizer.encode(smiles_a, add_special_tokens=True)
+            enc_b = tokenizer.encode(smiles_b, add_special_tokens=True)
+            ids_a = torch.tensor([enc_a['input_ids']], device=device)
+            ids_b = torch.tensor([enc_b['input_ids']], device=device)
+            len_a = torch.tensor([len(enc_a['input_ids'])], device=device)
+            len_b = torch.tensor([len(enc_b['input_ids'])], device=device)
+            mu_a, _ = model.encode(ids_a, len_a)
+            mu_b, _ = model.encode(ids_b, len_b)
+            alphas = torch.linspace(0, 1, steps, device=device)
+            for alpha in alphas:
+                z_interp = alpha * mu_b + (1 - alpha) * mu_a
+                # Ensure z_interp maintains batch dimension [1, latent_dim]
+                if z_interp.dim() == 1:
+                    z_interp = z_interp.unsqueeze(0)
+                logits = model.decode(z_interp, max_length=max_length, mode="sample", temperature=0.8)
+                preds = logits.argmax(dim=-1)
+                # Handle batch dimension properly
+                if preds.dim() > 1:
+                    preds = preds[0]  # Take first (and only) batch item
+                pred_smiles = tokenizer.decode(preds.cpu().tolist(), skip_special_tokens=True)
+                if Chem.MolFromSmiles(pred_smiles) is not None:
+                    valid_interps += 1
+                total_interps += 1
+    interp_validity = valid_interps / total_interps if total_interps > 0 else 0.0
+    print(f"Interpolation Validity: {interp_validity:.4f}")
+    return interp_validity
+def sample_from_latent(model, tokenizer, num_samples=30000, latent_dim=128, max_length=128, device=device, temperature=0.8):
+    model.eval()
+    generated_smiles = []
+    with torch.no_grad():
+        for _ in tqdm(range(0, num_samples, BATCH_SIZE), desc="Sampling from Latent"):
+            current_batch_size = min(BATCH_SIZE, num_samples - len(generated_smiles))
+            if current_batch_size <= 0: break
+            z = torch.randn(current_batch_size, latent_dim, device=device)
+            logits = model.decode(z, max_length=max_length, mode="sample", temperature=temperature)
+            preds = logits.argmax(dim=-1)
+            for i in range(current_batch_size):
+                pred_ids = preds[i].cpu().tolist()
+                smiles = tokenizer.decode(pred_ids, skip_special_tokens=True)
+                generated_smiles.append(smiles)
+                if len(generated_smiles) >= num_samples: break
+    return generated_smiles
+def measure_inference_throughput(model, tokenizer, test_smiles, device,
+                                 max_length=128,
+                                 batch_sizes=[1, 4, 8, 16]):
+    """
+    Benchmark inference speed & peak GPU memory across several batch sizes.
+    Returns a JSON-serialisable dict:
+        {batch_size: {'tokens_per_sec': <float>, 'peak_mem_mb': <float>}, ...}
+    """
+    model.eval()
+    results = {}
+    for bs in batch_sizes:
+        # Build a small fixed subset so every BS processes the same #samples
+        subset = SmilesDataset(test_smiles[:bs * 10])
+        loader = DataLoader(
+            subset,
+            batch_size=bs,
+            shuffle=False,
+            num_workers=0,
+            collate_fn=lambda b: collate_fn(b, tokenizer, max_length=max_length),
+        )
+        total_tokens = 0
+        if torch.cuda.is_available():
+            torch.cuda.reset_peak_memory_stats(device)
+        start_time = time.perf_counter()
+        with torch.no_grad():
+            for input_ids, lengths in loader:
+                input_ids, lengths = input_ids.to(device), lengths.to(device)
+                mu, logvar = model.encode(input_ids, lengths)
+                z = model.reparameterize(mu, logvar)
+                logits = model.decode(z, max_length=max_length)
+                total_tokens += logits.numel()  # number of float elements
+        duration = time.perf_counter() - start_time
+        tokens_per_sec = total_tokens / duration
+        peak_mem_mb = (
+            torch.cuda.max_memory_allocated(device) / (1024 ** 2)
+            if torch.cuda.is_available()
+            else 0.0
+        )
+        # Store as plain Python floats
+        results[bs] = {
+            "tokens_per_sec": float(tokens_per_sec),
+            "peak_mem_mb": float(peak_mem_mb),
+        }
+        print(f"BS {bs:3d} → {tokens_per_sec:8.2f} tok/s | Peak Mem: {peak_mem_mb:.2f} MB")
+    return results
+#
+# FINAL EVALUATION PIPELINE
+#
+def full_evaluation_pipeline(model, tokenizer, train_smiles, test_smiles, device, save_dir):
+    print(f"\n  FULL EVALUATION FOR: {tokenizer.name}")
+    test_dataset = SmilesDataset(test_smiles)
+    test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False,
+        collate_fn=lambda b: collate_fn(b, tokenizer, max_length=MAX_SEQ_LEN),
+        num_workers=0)
+    # 1. Reconstruction
+    recon_metrics = evaluate_reconstruction(model, test_loader, tokenizer, device)
+    # 2. Uniqueness & Novelty
+    train_set = set(train_smiles)
+    uniqueness, novelty = compute_uniqueness_and_novelty(recon_metrics['generated_smiles'], train_set)
+    # 3. KL Divergence
+    kl_div = evaluate_latent_kl(model, test_loader, device)
+    # 4. Interpolation Validity
+    interp_validity = evaluate_interpolation_validity(model, tokenizer, test_smiles, device)
+    # 5. Latent Sampling (for FCD — optional)
+    # gen_smiles_30k = sample_from_latent(model, tokenizer, num_samples=10000, temperature=0.8)  # reduce for speed
+    # fcd_score = compute_fcd(test_smiles, gen_smiles_30k) if 'get_fcd' in globals() else None
+    # 6. Throughput & Memory
+    # throughput = measure_inference_throughput(model, tokenizer, test_loader, device)
+    eval_results = {
+        **recon_metrics,
+        'uniqueness': uniqueness,
+        'novelty': novelty,
+        'kl_divergence': kl_div,
+        'interpolation_validity': interp_validity,
+        # 'fcd': fcd_score,
+        # 'inference_throughput': throughput,
+    }
+    eval_path = os.path.join(save_dir, "evaluation_results.json")
+    with open(eval_path, "w") as f:
+        json.dump(eval_results, f, indent=2, default=str)
+    print(f"  Evaluation saved to {eval_path}")
+    return eval_results
+#
+#   RUN EVALUATION FOR EACH TOKENIZER
+#
+for tokenizer in TOKENIZERS:
+    print(f"\n🔄 LOADING BEST MODEL FOR: {tokenizer.name}")
+    checkpoint_path = f"./checkpoints/{tokenizer.name}/best_model_{tokenizer.name}.pt"
+    if not os.path.exists(checkpoint_path):
+        print(f"⚠️  Checkpoint not found: {checkpoint_path}")
+        continue
+    vocab_size = len(tokenizer)
+    pad_token_id = tokenizer.tokenizer.pad_token_id
+    model = MoleculeVAE(
+        vocab_size=vocab_size, 
+        pad_token_id=pad_token_id,
+        bos_token_id=tokenizer.bos_token_id,
+        eos_token_id=tokenizer.eos_token_id
+    ).to(device)
+    checkpoint = torch.load(checkpoint_path, map_location=device)
+    model.load_state_dict(checkpoint['model_state_dict'])
+    model.eval()
+    full_evaluation_pipeline(
+        model=model,
+        tokenizer=tokenizer,
+        train_smiles=train_smiles,
+        test_smiles=test_smiles,
+        device=device,
+        save_dir=f"./checkpoints/{tokenizer.name}"
+    )
+print("\n🎉 PIPELINE COMPLETE — ALL TOKENIZERS BENCHMARKED, TRAINED, AND EVALUATED!")

benchmark/benchmark_legacy.py

@@ -0,0 +1,1039 @@
+#
+# Molecule Tokenizer Benchmark & VAE Training Pipeline
+# PATCHED VERSION — All 5 critical bugs fixed + KL Beta Logging Clarity
+#
+
+#
+# Step 1.1 — Imports & Reproducibility
+#
+
+import os
+import time
+import random
+import pandas as pd
+from pathlib import Path
+from datetime import datetime
+import torch
+import numpy as np
+
+# Tokenizers
+from transformers import AutoTokenizer
+from FastChemTokenizer import FastChemTokenizer  # assuming it's in PYTHONPATH
+# Optional: for progress bars
+from tqdm import tqdm
+from rdkit import Chem
+from sklearn.model_selection import train_test_split
+import torch.nn as nn
+import torch.nn.functional as F
+from ranger21 import Ranger21
+from torch.utils.data import DataLoader, Dataset
+from scipy.stats import entropy
+import json
+import math
+
+from rdkit import RDLogger
+RDLogger.DisableLog('rdApp.*')  
+# Set seeds for reproducibility
+def set_seed(seed=42):
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    os.environ['PYTHONHASHSEED'] = str(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+set_seed(42)
+
+# Device setup
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+print(f"Using device: {device}")
+
+#
+# Step 1.2 — Load & Preprocess SMILES Corpus
+#
+
+data_path = "../data/sample_1k_smi_42.csv"
+df = pd.read_csv(data_path)
+
+if 'SMILES' not in df.columns:
+    raise ValueError("Expected column 'SMILES' in CSV")
+
+smiles_list = df['SMILES'].dropna().tolist()
+print(f"Loaded {len(smiles_list)} SMILES (assumed pre-canonicalized)")
+
+# Validate with RDKit
+
+def is_valid_smiles(smiles):
+    return Chem.MolFromSmiles(smiles) is not None
+
+print("Validating SMILES with RDKit...")
+valid_mask = [is_valid_smiles(s) for s in tqdm(smiles_list)]
+smiles_list = [s for s, valid in zip(smiles_list, valid_mask) if valid]
+print(f"After RDKit filtering: {len(smiles_list)} valid SMILES")
+
+#
+# Step 1.3 — Train/Val/Test Split (80/10/10)
+#
+
+train_smiles, temp_smiles = train_test_split(smiles_list, test_size=0.2, random_state=42, shuffle=True)
+val_smiles, test_smiles = train_test_split(temp_smiles, test_size=0.5, random_state=42, shuffle=True)
+
+print(f"Train: {len(train_smiles)}")
+print(f"Val:   {len(val_smiles)}")
+print(f"Test:  {len(test_smiles)}")
+
+# Cache splits
+splits = {'train': train_smiles, 'val': val_smiles, 'test': test_smiles}
+for split_name, smiles in splits.items():
+    with open(f"../data/{split_name}_smiles.txt", "w") as f:
+        f.write("\n".join(smiles))
+
+#
+# Step 1.4 — Tokenizer Wrapper (Fixed Bug #2, #3, #6)
+#
+
+class TokenizerWrapper:
+    def __init__(self, tokenizer, name, bos_token="<s>", eos_token="</s>", pad_token="<pad>", unk_token="<unk>"):
+        self.tokenizer = tokenizer
+        self.name = name
+        self.bos_token = bos_token
+        self.eos_token = eos_token
+        self.pad_token = pad_token
+        self.unk_token = unk_token
+
+        if hasattr(tokenizer, 'add_special_tokens'):
+            tokenizer.add_special_tokens({
+                'bos_token': bos_token,
+                'eos_token': eos_token,
+                'pad_token': pad_token,
+                'unk_token': unk_token
+            })
+
+    def encode(self, smiles: str, add_special_tokens: bool = True):
+        if isinstance(self.tokenizer, FastChemTokenizer):
+            # 1. get ids directly
+            ids = self.tokenizer.encode(smiles)          # ← no .tokenize() here
+            # 2. add specials ourselves
+            if add_special_tokens:
+                ids = [self.tokenizer.bos_token_id] + ids + [self.tokenizer.eos_token_id]
+            return {'input_ids': ids}
+        else:
+            # Hugging-Face style tokenizer
+            return self.tokenizer(
+                smiles,
+                add_special_tokens=add_special_tokens,
+                return_attention_mask=False,
+                return_tensors=None
+            )
+
+    def decode(self, token_ids, skip_special_tokens=True):
+        if isinstance(self.tokenizer, FastChemTokenizer):
+            # 1. map single ids → tokens
+            tokens = [self.tokenizer.id_to_token.get(tid, self.tokenizer.unk_token)
+                    for tid in token_ids]
+            # 2. drop specials if requested
+            if skip_special_tokens:
+                specials = {self.tokenizer.bos_token,
+                            self.tokenizer.eos_token,
+                            self.tokenizer.pad_token,
+                            self.tokenizer.unk_token}   # add any others you use
+                tokens = [t for t in tokens if t not in specials]
+            # 3. detokenise
+            if hasattr(self.tokenizer, 'detokenize'):
+                return self.tokenizer.detokenize(tokens)
+            else:
+                return "".join(tokens)          # chemistry tokens are atomic
+        else:
+            return self.tokenizer.decode(token_ids, skip_special_tokens=skip_special_tokens)
+
+    def __len__(self):
+        if isinstance(self.tokenizer, FastChemTokenizer):
+            # FastChemTokenizer uses ._vocab or .vocab depending on version
+            return len(getattr(self.tokenizer, 'vocab',
+                            getattr(self.tokenizer, '_vocab', self.tokenizer)))
+        else:
+            return len(self.tokenizer)
+
+    def get_vocab(self):
+        if isinstance(self.tokenizer, FastChemTokenizer):
+            return self.tokenizer.vocab
+        else:
+            return self.tokenizer.get_vocab()
+    
+    @property
+    def bos_token_id(self):
+        return self.tokenizer.bos_token_id
+
+    @property
+    def eos_token_id(self):
+        return self.tokenizer.eos_token_id
+
+    @property
+    def pad_token_id(self):
+        return self.tokenizer.pad_token_id
+
+    @property
+    def unk_token_id(self):
+        return self.tokenizer.unk_token_id
+
+#
+# Step 1.5 — Initialize Tokenizers
+#
+
+tok1_hf = AutoTokenizer.from_pretrained("seyonec/ChemBERTa-zinc-base-v1")
+tok2_fast = FastChemTokenizer.from_pretrained("../smitok")
+
+tokenizer1 = TokenizerWrapper(tok1_hf, name="ChemBERTa", bos_token="<s>", eos_token="</s>", pad_token="<pad>", unk_token="<unk>")
+tokenizer2 = TokenizerWrapper(tok2_fast, name="FastChemTokenizer", bos_token="[BOS]", eos_token="[EOS]", pad_token="[PAD]", unk_token="[UNK]")
+
+TOKENIZERS = [tokenizer1, tokenizer2]
+
+#
+# Step 1.6 — Benchmarking Functions (Fixed Bug #4 implicitly via epsilon)
+#
+
+def benchmark_tokenizer(tokenizer, smiles_sample, encode_only=False):
+    V = len(tokenizer)
+    sample = smiles_sample[:10000] if len(smiles_sample) > 10000 else smiles_sample
+
+    encode_times = []
+    token_counts = []
+    char_counts = []
+    unk_counts = 0
+    total_tokens = 0
+
+    for smiles in tqdm(sample, desc=f"Encoding with {tokenizer.name}", leave=False):
+        char_counts.append(len(smiles))
+
+        start = time.perf_counter()
+        enc = tokenizer.encode(smiles, add_special_tokens=True)
+        end = time.perf_counter()
+        encode_times.append(end - start)
+
+        input_ids = enc['input_ids']
+        token_counts.append(len(input_ids))
+        total_tokens += len(input_ids)
+
+        if isinstance(tokenizer.tokenizer, FastChemTokenizer):
+            unk_id = tokenizer.tokenizer.convert_tokens_to_ids(tokenizer.unk_token)
+        else:
+            unk_id = tokenizer.tokenizer.unk_token_id
+
+        unk_counts += input_ids.count(unk_id)
+
+    L̄ = np.mean(token_counts)
+    C = np.mean(char_counts) / L̄
+    U = unk_counts / total_tokens if total_tokens > 0 else 0.0
+    Tenc = len(sample) / sum(encode_times)
+
+    metrics = {
+        'vocab_size': V,
+        'avg_tokens_per_mol': L̄,
+        'compression_ratio': C,
+        'percent_unknown': U * 100,
+        'encode_throughput_smiles_per_sec': Tenc,
+    }
+
+    if encode_only:
+        return metrics
+
+    decode_times = []
+    reconstruction_ok = 0
+
+    for smiles in tqdm(sample, desc=f"Decoding with {tokenizer.name}", leave=False):
+        enc = tokenizer.encode(smiles, add_special_tokens=True)
+        input_ids = enc['input_ids']
+
+        start = time.perf_counter()
+        decoded = tokenizer.decode(input_ids, skip_special_tokens=True)
+        end = time.perf_counter()
+        decode_times.append(end - start)
+
+        if decoded == smiles:
+            reconstruction_ok += 1
+
+    Tdec = len(sample) / sum(decode_times)
+    recon_acc = reconstruction_ok / len(sample)
+
+    metrics.update({
+        'decode_throughput_smiles_per_sec': Tdec,
+        'decode_reconstruction_accuracy': recon_acc * 100,
+    })
+
+    return metrics
+
+#
+# Step 1.7 — Run Benchmark
+#
+
+benchmark_sample = train_smiles
+results = []
+
+for tokenizer in TOKENIZERS:
+    print(f"\n=== Benchmarking {tokenizer.name} ===")
+    metrics = benchmark_tokenizer(tokenizer, benchmark_sample)
+    metrics['tokenizer'] = tokenizer.name
+    results.append(metrics)
+    for k, v in metrics.items():
+        if k != 'tokenizer':
+            print(f"{k:35s}: {v:.4f}" if isinstance(v, float) else f"{k:35s}: {v}")
+
+df_results = pd.DataFrame(results)
+df_results.to_csv("tokenizer_benchmark_results.csv", index=False)
+print("\nTokenizer benchmark results saved to 'tokenizer_benchmark_results.csv'")
+
+#
+# Step 2.1 — VAE Model Class (PATCHED: decode stops at EOS)
+#
+
+class MoleculeVAE(nn.Module):
+    def __init__(self, vocab_size, embed_dim=256, hidden_dim=512, latent_dim=128, num_layers=2,
+                 pad_token_id=0, bos_token_id=1, eos_token_id=2):
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.embed_dim = embed_dim
+        self.hidden_dim = hidden_dim
+        self.latent_dim = latent_dim
+        self.num_layers = num_layers
+        self.pad_token_id = pad_token_id
+        self.bos_token_id = bos_token_id
+        self.eos_token_id = eos_token_id
+
+        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=pad_token_id)
+        self.encoder_lstm = nn.LSTM(embed_dim, hidden_dim, num_layers, batch_first=True, bidirectional=True)
+        self.fc_mu = nn.Linear(hidden_dim * 2, latent_dim)
+        self.fc_logvar = nn.Linear(hidden_dim * 2, latent_dim)
+
+        self.decoder_lstm = nn.LSTM(embed_dim, hidden_dim, num_layers, batch_first=True)
+        self.fc_out = nn.Linear(hidden_dim, vocab_size)
+
+        self.latent2hidden = nn.Linear(latent_dim, num_layers * hidden_dim)
+        self.latent2cell = nn.Linear(latent_dim, num_layers * hidden_dim)
+
+        self._init_weights()
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.LSTM):
+                for name, param in m.named_parameters():
+                    if 'weight' in name:
+                        nn.init.orthogonal_(param)
+                    elif 'bias' in name:
+                        nn.init.zeros_(param)
+
+    def encode(self, x, lengths):
+        embedded = self.embedding(x)
+        packed = nn.utils.rnn.pack_padded_sequence(embedded, lengths.cpu(), batch_first=True, enforce_sorted=False)
+        packed_out, (hidden, _) = self.encoder_lstm(packed)
+        h_forward = hidden[-2]
+        h_backward = hidden[-1]
+        h = torch.cat([h_forward, h_backward], dim=1)
+        mu = self.fc_mu(h)
+        logvar = self.fc_logvar(h)
+        return mu, logvar
+
+    def reparameterize(self, mu, logvar):
+        if self.training:
+            std = torch.exp(0.5 * logvar)
+            eps = torch.randn_like(std)
+            return mu + eps * std
+        else:
+            return mu
+
+    def decode(self, z, max_length=128, mode="greedy", temperature=1.0):
+        """
+        Decode latent vector z into a sequence.
+        Returns full logits at each step.
+        PATCHED: stops generation when EOS is predicted.
+        """
+        batch_size = z.size(0)
+        device = z.device
+
+        # Initialize hidden states from latent
+        h0 = self.latent2hidden(z).view(self.num_layers, batch_size, self.hidden_dim)
+        c0 = self.latent2cell(z).view(self.num_layers, batch_size, self.hidden_dim)
+        hidden = (h0, c0)
+
+        # Start with BOS token — shape: (batch_size, 1)
+        input_token = torch.full((batch_size, 1), self.bos_token_id, dtype=torch.long, device=device)
+        logits = []
+        finished = torch.zeros(batch_size, dtype=torch.bool, device=device)  # ← TRACK FINISHED SEQS
+
+        for _ in range(max_length):
+            embedded = self.embedding(input_token)  # (batch, 1, embed_dim)
+            output, hidden = self.decoder_lstm(embedded, hidden)
+            logit = self.fc_out(output)  # (batch, 1, vocab)
+            logits.append(logit)
+
+            if mode == "greedy":
+                input_token = logit.argmax(dim=-1)  # (batch, 1)
+            elif mode == "sample":
+                probs = torch.softmax(logit.squeeze(1) / temperature, dim=-1)  # (batch, vocab)
+                input_token = torch.multinomial(probs, 1)  # (batch, 1)
+            else:
+                raise ValueError(f"Unknown decode mode: {mode}")
+
+            # ← EARLY STOPPING AT EOS
+            just_finished = (input_token.squeeze(1) == self.eos_token_id)
+            finished |= just_finished
+            input_token[finished] = self.pad_token_id  # pad finished sequences
+            if finished.all():
+                break
+
+        return torch.cat(logits, dim=1)  # (batch, seq_len, vocab)
+
+    def forward(self, input_ids, lengths, target_seq=None, teacher_forcing_ratio=0.0, temperature=1.0):
+        mu, logvar = self.encode(input_ids, lengths)
+        z = self.reparameterize(mu, logvar)
+
+        if self.training and target_seq is not None and teacher_forcing_ratio > 0:
+            # Training with teacher forcing
+            batch_size, seq_len = target_seq.size()
+            device = target_seq.device
+            
+            # Initialize hidden states
+            h0 = self.latent2hidden(z).view(self.num_layers, batch_size, self.hidden_dim)
+            c0 = self.latent2cell(z).view(self.num_layers, batch_size, self.hidden_dim)
+            hidden = (h0, c0)
+            
+            logits = []
+            input_token = target_seq[:, 0].unsqueeze(1)  # BOS
+
+            for t in range(1, seq_len):
+                embedded = self.embedding(input_token)
+                output, hidden = self.decoder_lstm(embedded, hidden)
+                logit = self.fc_out(output)
+                logits.append(logit)
+
+                use_teacher = torch.rand(1).item() < teacher_forcing_ratio
+                if use_teacher:
+                    input_token = target_seq[:, t].unsqueeze(1)
+                else:
+                    input_token = logit.argmax(dim=-1)
+
+            logits = torch.cat(logits, dim=1)
+        else:
+            # Inference mode
+            max_len = target_seq.size(1) if target_seq is not None else 128
+            logits = self.decode(z, max_length=max_len, mode="greedy", temperature=temperature)
+
+        return logits, mu, logvar
+
+#
+# Step 2.2 — Loss Function (PATCHED: β applied OUTSIDE, not inside)
+#
+
+def vae_loss(logits, targets, mu, logvar, pad_token_id, beta=1.0):
+    # 1. align lengths
+    max_len = max(logits.size(1), targets.size(1))
+    if logits.size(1) < max_len:
+        logits = F.pad(logits, (0, 0, 0, max_len - logits.size(1)))
+    if targets.size(1) < max_len:
+        targets = F.pad(targets, (0, max_len - targets.size(1)), value=pad_token_id)
+
+    logits_flat = logits.view(-1, logits.size(-1))          # [B*L, V]
+    targets_flat = targets.reshape(-1)                      # [B*L]
+
+    mask = (targets_flat != pad_token_id).float()
+    ce_loss = F.cross_entropy(logits_flat, targets_flat, reduction='none')
+    mask_sum = mask.sum()
+    ce_loss = (ce_loss * mask).sum() / (mask_sum + 1e-8)
+
+    kl_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp(), dim=1).mean()
+    # ← β is applied OUTSIDE — so return raw KL
+    return ce_loss + kl_loss, ce_loss, kl_loss
+
+#
+# Step 2.3 — KLAnnealer (Fixed Bug #5: double increment)
+#
+
+class KLAnnealer:
+    def __init__(self, total_steps, n_cycle=1, ratio=0.3, mode="linear", per_epoch=False, steps_per_epoch=None):
+        self.total_steps = total_steps
+        self.n_cycle = n_cycle
+        self.ratio = ratio
+        self.mode = mode
+        self.per_epoch = per_epoch
+        self.steps_per_epoch = steps_per_epoch
+        self.current_step = 0
+
+    def get_beta(self, increment=True):
+        """Get current KL weight.
+        Args:
+            increment (bool): whether to advance the annealer (use False in validation).
+        """
+        if increment:
+            self.current_step += 1
+
+        if self.current_step > self.total_steps:
+            return 1.0
+
+        # effective cycle length
+        if self.per_epoch:
+            assert self.steps_per_epoch is not None, "steps_per_epoch required if per_epoch=True"
+            cycle_length = self.steps_per_epoch / self.n_cycle
+            pos_in_cycle = (self.current_step % self.steps_per_epoch) / cycle_length
+        else:
+            cycle_length = self.total_steps / self.n_cycle
+            pos_in_cycle = (self.current_step % cycle_length) / cycle_length
+
+        pos_in_cycle = min(pos_in_cycle, 1.0)
+
+        # warmup phase
+        fraction = pos_in_cycle / self.ratio if pos_in_cycle < self.ratio else 1.0
+
+        if self.mode == "linear":
+            return min(fraction, 1.0)
+        elif self.mode == "sigmoid":
+            # Map pos_in_cycle ∈ [0,1] to sigmoid ∈ [0,1]
+            # Center at 0.5, so at pos_in_cycle=0.5, sigmoid=0.5
+            k = 6
+            return 1 / (1 + math.exp(-k * (pos_in_cycle - 0.5)))
+        else:
+            raise ValueError(f"Unknown mode: {self.mode}")
+
+#
+# Step 2.4 — Collate Function (Fixed Bug #2: dynamic pad id)
+#
+
+def collate_fn(batch, tokenizer, max_length=128):
+    encodings = [tokenizer.encode(s, add_special_tokens=True) for s in batch]
+    input_ids = [e['input_ids'] for e in encodings]
+
+    max_len = min(max(len(ids) for ids in input_ids), max_length)
+    padded = []
+    lengths = []
+
+    pad_token_id = tokenizer.tokenizer.pad_token_id  #   FIXED: dynamic
+
+    for ids in input_ids:
+        if len(ids) > max_length:
+            ids = ids[:max_length]
+        else:
+            ids = ids + [pad_token_id] * (max_len - len(ids))
+        padded.append(ids)
+        lengths.append(min(len(ids), max_length))
+
+    return torch.tensor(padded, dtype=torch.long), torch.tensor(lengths, dtype=torch.long)
+
+#
+# Step 2.5 — Dataset & DataLoader
+#
+
+class SmilesDataset(Dataset):
+    def __init__(self, smiles_list):
+        self.smiles_list = smiles_list
+    def __len__(self):
+        return len(self.smiles_list)
+    def __getitem__(self, idx):
+        return self.smiles_list[idx]
+
+#
+# Step 3.x — Training Loop (PATCHED: per-tokenizer annealer, exponential TFR, device-safe eval, KL beta logging clarity)
+#
+
+LEARNING_RATE = 5e-6
+BATCH_SIZE = 16
+ACCUMULATION_STEPS = 4
+NUM_EPOCHS = 5
+MAX_SEQ_LEN = 128
+KL_ANNEAL_RATIO = 0.3
+
+def train_vae(
+    model,
+    train_loader,
+    val_loader,
+    optimizer,
+    kl_annealer,
+    pad_token_id,
+    device,
+    num_epochs,
+    accumulation_steps=4,
+    save_dir="./checkpoints",
+    tokenizer_name="default"
+):
+    os.makedirs(save_dir, exist_ok=True)
+    log_file = os.path.join(save_dir, f"training_log_{tokenizer_name}.csv")
+
+    with open(log_file, "w") as f:
+        f.write("epoch,step,train_loss,train_ce,train_kl,val_loss,val_ce,val_kl,kl_beta\n")
+
+    best_val_loss = float('inf')
+
+    for epoch in range(num_epochs):
+        print(f"\n=== Epoch {epoch+1}/{num_epochs} ===")
+        model.train()
+        total_train_loss = total_train_ce = total_train_kl = 0.0
+        num_batches = 0
+
+        optimizer.zero_grad()
+
+        for step, (input_ids, lengths) in enumerate(tqdm(train_loader, desc="Training")):
+            input_ids, lengths = input_ids.to(device), lengths.to(device)
+
+            # ← PATCHED: exponential decay per epoch (not per batch, but smoother than linear)
+            tfr = 1.0 * (0.5 ** (epoch / max(1, num_epochs-1)))  # decay from 1.0 → 0.5
+
+            logits, mu, logvar = model(input_ids, lengths, target_seq=input_ids, teacher_forcing_ratio=tfr)
+            beta = kl_annealer.get_beta(increment=True)
+            loss, ce_loss, kl_loss = vae_loss(logits, input_ids, mu, logvar, pad_token_id, beta=beta)
+
+            loss = loss / accumulation_steps
+            loss.backward()
+
+            total_train_loss += loss.item() * accumulation_steps
+            total_train_ce += ce_loss.item()
+            total_train_kl += kl_loss.item()
+            num_batches += 1
+
+            if (step + 1) % accumulation_steps == 0:
+                optimizer.step()
+                optimizer.zero_grad()
+
+        if len(train_loader) % accumulation_steps != 0:
+            optimizer.step()
+            optimizer.zero_grad()
+
+        # ✅ CAPTURE BETA AFTER TRAINING — BEFORE VALIDATION
+        # This ensures we log the beta that was actually used during training
+        current_beta = kl_annealer.get_beta(increment=False)
+
+        # Validation — DO NOT query beta again here
+        model.eval()
+        total_val_loss = total_val_ce = total_val_kl = 0.0
+        val_batches = 0
+
+        with torch.no_grad():
+            for input_ids, lengths in tqdm(val_loader, desc="Validating"):
+                input_ids, lengths = input_ids.to(device), lengths.to(device)
+                # Use captured beta — DO NOT call kl_annealer again here
+                logits, mu, logvar = model(input_ids, lengths, target_seq=input_ids, teacher_forcing_ratio=0.0)
+                loss, ce_loss, kl_loss = vae_loss(logits, input_ids, mu, logvar, pad_token_id, beta=current_beta)
+
+                total_val_loss += loss.item()
+                total_val_ce += ce_loss.item()
+                total_val_kl += kl_loss.item()
+                val_batches += 1
+
+        avg_train_loss = total_train_loss / num_batches
+        avg_val_loss = total_val_loss / val_batches
+
+        current_step = (epoch + 1) * len(train_loader)
+        with open(log_file, "a") as f:
+            f.write(f"{epoch+1},{current_step},{avg_train_loss:.6f},{total_train_ce/num_batches:.6f},{total_train_kl/num_batches:.6f},"
+                    f"{avg_val_loss:.6f},{total_val_ce/val_batches:.6f},{total_val_kl/val_batches:.6f},{current_beta:.6f}\n")
+
+        print(f"Train Loss: {avg_train_loss:.4f}")
+        print(f"Val Loss:   {avg_val_loss:.4f}")
+        print(f"KL Beta:    {current_beta:.4f}")  # ← Now explicitly the training beta
+
+        if avg_val_loss < best_val_loss:
+            best_val_loss = avg_val_loss
+            checkpoint_path = os.path.join(save_dir, f"best_model_{tokenizer_name}.pt")
+            torch.save({
+                'epoch': epoch + 1,
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'val_loss': avg_val_loss,
+            }, checkpoint_path)
+            print(f"→ Saved best model to {checkpoint_path}")
+
+    return best_val_loss
+
+#
+#   TRAINING LOOP OVER TOKENIZERS (PATCHED: KLAnnealer reset per tokenizer)
+#
+
+for tokenizer in TOKENIZERS:
+    print(f"\n  STARTING TRAINING FOR: {tokenizer.name}\n")
+
+    vocab_size = len(tokenizer)
+    pad_token_id = tokenizer.tokenizer.pad_token_id
+
+    # Validate token IDs
+    sample_ids = tokenizer.encode(train_smiles[0], add_special_tokens=True)['input_ids']
+    max_id_in_sample = max(sample_ids)
+    assert max_id_in_sample < vocab_size, f"Token ID {max_id_in_sample} >= vocab size {vocab_size} in {tokenizer.name}"
+
+    model = MoleculeVAE(
+        vocab_size=len(tokenizer),
+        pad_token_id=tokenizer.pad_token_id,
+        bos_token_id=tokenizer.bos_token_id,
+        eos_token_id=tokenizer.eos_token_id
+    ).to(device)
+
+    ########################################################################
+    # 1. CREATE A FRESH annealer FOR EVERY TOKENIZER
+    ########################################################################
+    total_steps = (len(train_smiles) // (BATCH_SIZE*ACCUMULATION_STEPS)) * NUM_EPOCHS
+    kl_annealer = KLAnnealer(
+        total_steps=total_steps,
+        n_cycle=4,               # 4 cycles across all epochs → real cyclical
+        ratio=0.25,              # 25% of each cycle is warmup
+        mode="sigmoid",
+        per_epoch=False
+    )
+
+    optimizer = Ranger21(
+        model.parameters(),
+        lr=LEARNING_RATE,
+        weight_decay=0.01,
+        use_adabelief=True,
+        use_warmup=True,
+        use_madgrad=True,
+        num_epochs=NUM_EPOCHS,
+        num_batches_per_epoch=len(train_smiles) // (BATCH_SIZE * ACCUMULATION_STEPS),
+        warmdown_active=False,
+    )
+
+    train_dataset = SmilesDataset(train_smiles)
+    val_dataset = SmilesDataset(val_smiles)
+
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=BATCH_SIZE,
+        shuffle=True,
+        collate_fn=lambda batch: collate_fn(batch, tokenizer, max_length=MAX_SEQ_LEN),
+        num_workers=0,
+        pin_memory=True
+    )
+
+    val_loader = DataLoader(
+        val_dataset,
+        batch_size=BATCH_SIZE,
+        shuffle=False,
+        collate_fn=lambda batch: collate_fn(batch, tokenizer, max_length=MAX_SEQ_LEN),
+        num_workers=0,
+        pin_memory=True
+    )
+
+    train_vae(
+        model=model,
+        train_loader=train_loader,
+        val_loader=val_loader,
+        optimizer=optimizer,
+        kl_annealer=kl_annealer,
+        pad_token_id=pad_token_id,
+        device=device,
+        num_epochs=NUM_EPOCHS,
+        accumulation_steps=ACCUMULATION_STEPS,
+        save_dir=f"./checkpoints/{tokenizer.name}",
+        tokenizer_name=tokenizer.name
+    )
+    
+#
+# Step 4.x — Evaluation Pipeline (Fixed Bug #6, #7, #8)
+#
+
+def canonicalize_smiles(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return None
+    return Chem.MolToSmiles(mol, isomericSmiles=True)
+
+def evaluate_reconstruction(model, dataloader, tokenizer, device, max_length=128):
+    model.eval()
+    total_token_correct = total_tokens = exact_matches = valid_count = total_samples = 0
+    all_generated, all_targets = [], []
+
+    pad_id = tokenizer.tokenizer.pad_token_id
+    eos_id = tokenizer.tokenizer.eos_token_id
+    special_ids = {pad_id, eos_id}
+
+    def trim_to_special(ids, specials):
+        for i, id_ in enumerate(ids):
+            if id_ in specials:
+                return ids[:i]
+        return ids
+
+    with torch.no_grad():
+        for input_ids, lengths in tqdm(dataloader, desc="Evaluating Reconstruction"):
+            input_ids, lengths = input_ids.to(device), lengths.to(device)
+            B = input_ids.size(0)
+
+            mu, logvar = model.encode(input_ids, lengths)
+            z = model.reparameterize(mu, logvar)
+            logits = model.decode(z, max_length=128, mode="greedy")  # FIXED #7 for reconstruction
+            preds = logits.argmax(dim=-1)
+
+            # FIXED: Align logits and targets to same sequence length
+            min_len = min(logits.size(1), input_ids.size(1))
+            preds = preds[:, :min_len]          # trim predictions
+            input_ids_eval = input_ids[:, :min_len]  # trim targets
+
+            mask = (input_ids_eval != pad_id)
+            token_correct = ((preds == input_ids_eval) & mask).sum().item()
+            total_token_correct += token_correct
+            total_tokens += mask.sum().item()
+
+            for i in range(B):
+                target_ids = input_ids_eval[i].cpu().tolist()
+                pred_ids = preds[i].cpu().tolist()
+
+                # FIXED BUG #6: Trim before decode
+                target_ids_trim = trim_to_special(target_ids, special_ids)
+                pred_ids_trim = trim_to_special(pred_ids, special_ids)
+
+                target_smiles = tokenizer.decode(target_ids_trim, skip_special_tokens=False)
+                pred_smiles = tokenizer.decode(pred_ids_trim, skip_special_tokens=False)
+
+                all_targets.append(target_smiles)
+                all_generated.append(pred_smiles)
+
+                if pred_smiles == target_smiles:
+                    exact_matches += 1
+                if Chem.MolFromSmiles(pred_smiles) is not None:
+                    valid_count += 1
+                total_samples += 1
+
+    token_acc = total_token_correct / total_tokens if total_tokens > 0 else 0.0
+    exact_match_rate = exact_matches / total_samples
+    validity_rate = valid_count / total_samples
+
+    print(f"Token-level Accuracy: {token_acc:.4f}")
+    print(f"Exact Match Rate:     {exact_match_rate:.4f}")
+    print(f"Validity Rate:        {validity_rate:.4f}")
+
+    return {
+        'token_accuracy': token_acc,
+        'exact_match_rate': exact_match_rate,
+        'validity_rate': validity_rate,
+        'generated_smiles': all_generated,
+        'target_smiles': all_targets
+    }
+
+def compute_uniqueness_and_novelty(generated_smiles, train_smiles_set):
+    total = len(generated_smiles)
+    unique = len(set(generated_smiles))
+    novel = len([s for s in generated_smiles if s not in train_smiles_set])
+    uniqueness = unique / total if total > 0 else 0.0
+    novelty = novel / total if total > 0 else 0.0
+    print(f"Uniqueness: {uniqueness:.4f} ({unique}/{total})")
+    print(f"Novelty:    {novelty:.4f} ({novel}/not in train)")
+    return uniqueness, novelty
+
+def kl_divergence_from_samples(samples, bins=512):
+    dim_kls = []
+    for d in range(samples.shape[1]):
+        data = samples[:, d]
+        hist, bin_edges = np.histogram(data, bins=bins, density=True)
+        bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+        norm_pdf = (1 / np.sqrt(2 * np.pi)) * np.exp(-0.5 * bin_centers**2)
+        hist = np.clip(hist, 1e-10, None)
+        norm_pdf = np.clip(norm_pdf, 1e-10, None)
+        kl = entropy(hist, norm_pdf)
+        dim_kls.append(kl)
+    return np.mean(dim_kls)
+
+def evaluate_latent_kl(model, dataloader, device, latent_dim=128, bins=512):
+    model.eval()
+    all_z = []
+    with torch.no_grad():
+        for input_ids, lengths in tqdm(dataloader, desc="Sampling Latents"):
+            input_ids, lengths = input_ids.to(device), lengths.to(device)
+            mu, logvar = model.encode(input_ids, lengths)
+            z = model.reparameterize(mu, logvar)
+            all_z.append(z.cpu().numpy())
+    all_z = np.concatenate(all_z, axis=0)
+    kl_div = kl_divergence_from_samples(all_z, bins=bins)
+    print(f"KL Divergence (empirical vs N(0,1)): {kl_div:.4f}")
+    return kl_div
+
+def evaluate_interpolation_validity(model, tokenizer, test_smiles, device, num_pairs=100, steps=10, max_length=128):
+    model.eval()
+    pairs = random.sample(list(zip(test_smiles[::2], test_smiles[1::2])), min(num_pairs, len(test_smiles)//2))
+    valid_interps = total_interps = 0
+
+    with torch.no_grad():
+        for smiles_a, smiles_b in tqdm(pairs, desc="Interpolation Validity"):
+            if not smiles_a or not smiles_b: continue
+
+            enc_a = tokenizer.encode(smiles_a, add_special_tokens=True)
+            enc_b = tokenizer.encode(smiles_b, add_special_tokens=True)
+
+            ids_a = torch.tensor([enc_a['input_ids']], device=device)
+            ids_b = torch.tensor([enc_b['input_ids']], device=device)
+            len_a = torch.tensor([len(enc_a['input_ids'])], device=device)
+            len_b = torch.tensor([len(enc_b['input_ids'])], device=device)
+
+            mu_a, _ = model.encode(ids_a, len_a)
+            mu_b, _ = model.encode(ids_b, len_b)
+
+            alphas = torch.linspace(0, 1, steps, device=device)
+            for alpha in alphas:
+                z_interp = alpha * mu_b + (1 - alpha) * mu_a
+                # Ensure z_interp maintains batch dimension [1, latent_dim]
+                if z_interp.dim() == 1:
+                    z_interp = z_interp.unsqueeze(0)
+                
+                logits = model.decode(z_interp, max_length=max_length, mode="sample", temperature=0.8)
+                preds = logits.argmax(dim=-1)
+                # Handle batch dimension properly
+                if preds.dim() > 1:
+                    preds = preds[0]  # Take first (and only) batch item
+                pred_smiles = tokenizer.decode(preds.cpu().tolist(), skip_special_tokens=True)
+                if Chem.MolFromSmiles(pred_smiles) is not None:
+                    valid_interps += 1
+                total_interps += 1
+
+    interp_validity = valid_interps / total_interps if total_interps > 0 else 0.0
+    print(f"Interpolation Validity: {interp_validity:.4f}")
+    return interp_validity
+
+def sample_from_latent(model, tokenizer, num_samples=30000, latent_dim=128, max_length=128, device=device, temperature=0.8):
+    model.eval()
+    generated_smiles = []
+    with torch.no_grad():
+        for _ in tqdm(range(0, num_samples, BATCH_SIZE), desc="Sampling from Latent"):
+            current_batch_size = min(BATCH_SIZE, num_samples - len(generated_smiles))
+            if current_batch_size <= 0: break
+            z = torch.randn(current_batch_size, latent_dim, device=device)
+            logits = model.decode(z, max_length=max_length, mode="sample", temperature=temperature)
+            preds = logits.argmax(dim=-1)
+            for i in range(current_batch_size):
+                pred_ids = preds[i].cpu().tolist()
+                smiles = tokenizer.decode(pred_ids, skip_special_tokens=True)
+                generated_smiles.append(smiles)
+                if len(generated_smiles) >= num_samples: break
+    return generated_smiles
+
+def measure_inference_throughput(model, tokenizer, test_smiles, device,
+                                 max_length=128,
+                                 batch_sizes=[1, 4, 8, 16]):
+    """
+    Benchmark inference speed & peak GPU memory across several batch sizes.
+    Returns a JSON-serialisable dict:
+        {batch_size: {'tokens_per_sec': <float>, 'peak_mem_mb': <float>}, ...}
+    """
+    model.eval()
+    results = {}
+
+    for bs in batch_sizes:
+        # Build a small fixed subset so every BS processes the same #samples
+        subset = SmilesDataset(test_smiles[:bs * 10])
+        loader = DataLoader(
+            subset,
+            batch_size=bs,
+            shuffle=False,
+            num_workers=0,
+            collate_fn=lambda b: collate_fn(b, tokenizer, max_length=max_length),
+        )
+
+        total_tokens = 0
+        if torch.cuda.is_available():
+            torch.cuda.reset_peak_memory_stats(device)
+
+        start_time = time.perf_counter()
+        with torch.no_grad():
+            for input_ids, lengths in loader:
+                input_ids, lengths = input_ids.to(device), lengths.to(device)
+                mu, logvar = model.encode(input_ids, lengths)
+                z = model.reparameterize(mu, logvar)
+                logits = model.decode(z, max_length=max_length)
+                total_tokens += logits.numel()  # number of float elements
+        duration = time.perf_counter() - start_time
+
+        tokens_per_sec = total_tokens / duration
+        peak_mem_mb = (
+            torch.cuda.max_memory_allocated(device) / (1024 ** 2)
+            if torch.cuda.is_available()
+            else 0.0
+        )
+
+        # Store as plain Python floats
+        results[bs] = {
+            "tokens_per_sec": float(tokens_per_sec),
+            "peak_mem_mb": float(peak_mem_mb),
+        }
+        print(f"BS {bs:3d} → {tokens_per_sec:8.2f} tok/s | Peak Mem: {peak_mem_mb:.2f} MB")
+
+    return results
+
+#
+# FINAL EVALUATION PIPELINE
+#
+
+def full_evaluation_pipeline(model, tokenizer, train_smiles, test_smiles, device, save_dir):
+    print(f"\n  FULL EVALUATION FOR: {tokenizer.name}")
+
+    test_dataset = SmilesDataset(test_smiles)
+    test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False,
+        collate_fn=lambda b: collate_fn(b, tokenizer, max_length=MAX_SEQ_LEN),
+        num_workers=0)
+
+    # 1. Reconstruction
+    recon_metrics = evaluate_reconstruction(model, test_loader, tokenizer, device)
+
+    # 2. Uniqueness & Novelty
+    train_set = set(train_smiles)
+    uniqueness, novelty = compute_uniqueness_and_novelty(recon_metrics['generated_smiles'], train_set)
+
+    # 3. KL Divergence
+    kl_div = evaluate_latent_kl(model, test_loader, device)
+
+    # 4. Interpolation Validity
+    interp_validity = evaluate_interpolation_validity(model, tokenizer, test_smiles, device)
+
+    # 5. Latent Sampling (for FCD — optional)
+    # gen_smiles_30k = sample_from_latent(model, tokenizer, num_samples=10000, temperature=0.8)  # reduce for speed
+    # fcd_score = compute_fcd(test_smiles, gen_smiles_30k) if 'get_fcd' in globals() else None
+
+    # 6. Throughput & Memory
+    # throughput = measure_inference_throughput(model, tokenizer, test_loader, device)
+
+    eval_results = {
+        **recon_metrics,
+        'uniqueness': uniqueness,
+        'novelty': novelty,
+        'kl_divergence': kl_div,
+        'interpolation_validity': interp_validity,
+        # 'fcd': fcd_score,
+        # 'inference_throughput': throughput,
+    }
+
+    eval_path = os.path.join(save_dir, "evaluation_results.json")
+    with open(eval_path, "w") as f:
+        json.dump(eval_results, f, indent=2, default=str)
+
+    print(f"  Evaluation saved to {eval_path}")
+    return eval_results
+
+#
+#   RUN EVALUATION FOR EACH TOKENIZER
+#
+
+for tokenizer in TOKENIZERS:
+    print(f"\n🔄 LOADING BEST MODEL FOR: {tokenizer.name}")
+    checkpoint_path = f"./checkpoints/{tokenizer.name}/best_model_{tokenizer.name}.pt"
+    if not os.path.exists(checkpoint_path):
+        print(f"⚠️  Checkpoint not found: {checkpoint_path}")
+        continue
+
+    vocab_size = len(tokenizer)
+    pad_token_id = tokenizer.tokenizer.pad_token_id
+    model = MoleculeVAE(
+        vocab_size=vocab_size, 
+        pad_token_id=pad_token_id,
+        bos_token_id=tokenizer.bos_token_id,
+        eos_token_id=tokenizer.eos_token_id
+    ).to(device)
+
+    checkpoint = torch.load(checkpoint_path, map_location=device)
+    model.load_state_dict(checkpoint['model_state_dict'])
+    model.eval()
+
+    full_evaluation_pipeline(
+        model=model,
+        tokenizer=tokenizer,
+        train_smiles=train_smiles,
+        test_smiles=test_smiles,
+        device=device,
+        save_dir=f"./checkpoints/{tokenizer.name}"
+    )
+
+print("\n🎉 PIPELINE COMPLETE — ALL TOKENIZERS BENCHMARKED, TRAINED, AND EVALUATED!")

benchmark/data/test_smiles.txt

@@ -0,0 +1,1628 @@
+CN(CCc1ccccc1)C(=O)C=Cc1ccccc1
+OCc1cc(CC2(NCC3CCCCC3)COC2)no1
+COc1ccc(C23CCC(=O)C=C2N(C)CC3)cc1OC
+CC1(C)CC2C(=O)CCC3OC3(C)CCC21
+CCOC(=O)CC(c1c(O)c2ccccc2[nH]c1=O)C(C)C
+CC(OC(=O)Cn1cnc2ccccc2c1=O)C(N)=O
+CC(C)NC(=O)NC1C2COC(O2)C(n2ccnc2)C1O
+O=C(O)CNC(=O)c1cccc(Cl)c1
+Cc1ccc(C(C)CC=CC(C)(C)O)cc1O
+NC1CCN(Cc2ccc(OCc3ccccc3)cc2)CC1
+O=C1N=CN=C2C1=NC(=S)N2C1OC(CO)C(O)C1O
+CC1(C)NCCc2cc(O)c(O)cc21
+CC(=O)c1c(C)cc2c(c1O)C(=O)C=CC2=O
+COC1C(O)OC(C)C(N)C1O
+Nc1cc2nncoc-2c1
+Cc1ccc(Nc2nc(Cl)nc(NC(C)(C)C)n2)cc1
+CC(C)CCC(=O)OCCCc1ccc(O)c(O)c1
+C=C(C)C=CC12CC(C)C3CCC(C)([NH2+][CH2-])C(CCC1C)C32
+C[C@]12Cc3ccccc3C[C@](C)(N1)c1ccccc12
+CCOC(=O)c1ccc(NC(=O)CCCCC2SCC3NC(=O)NC32)cc1
+CCCCCCCCCCCCCCCCCCCC(C)CC
+CC1=C(CCC(C)(O)C(O)CO)C2(C)CCCC(C)(C)C2CC1
+CN(C)CCOc1ccc2c(=O)cc(-c3ccccc3)oc2c1
+COc1cc(O)c2c(c1)Cc1cc(C)cc(O)c1C2=O
+CC1=CCC2CC3C(C)CCC13C2(C)C
+Cc1nccn1C1C2OCC(O2)C(NCc2ccccn2)C1O
+C=C1CCC2OC1C1C(C(C)C)CCC21C
+CC1CC2CCCN2C(CC(=O)CC2N3CCCC3CC(C)C2(O)c2ccccc2)C1(O)c1ccccc1
+CCC(C)Cc1ccc(C(C)O)oc1=O
+Cc1cccc2c1sc1c(C)cccc12
+CC1(C)CC2C=C(C=O)C34CC3(C(=O)OC4O)C2C1
+CCC(C)C(NC(=O)C(N)CCSC)C(=O)NC(CCCN=C(N)N)C(=O)O
+O=C(Oc1ccc2c(c1)OC(=Cc1ccco1)C2=O)c1ccccc1F
+N#CCCCC1CS1
+CC(C)CC(C(=O)NCC1CCCN2CCCCC12)n1cccc1
+c1csc(-c2nnc3n2C2(CCCC2)Cc2ccccc2-3)c1
+C#CC=CC1C(O)CCCC12CCCC(CC=C)N2
+CC(C)C(CCNCc1ccc(N(C)C)cc1)c1ccco1
+NC(=O)C(CCC(=O)O)NC(=O)C1=CC(NC(=O)NC2CCCCC2)C(O)C(O)C1
+O=c1c(O)cccc2ccc(O)c(O)c12
+COC=Cc1cc2ccc(=O)oc2cc1OC
+C#CC=CC(Cl)C(O)C1CC2OC2CC(Br)C(CC)O1
+C=C1CCC2C(C3CC(C4CCCCC4)CC13)C2(CN)CCC
+C=C(C)CC1CCC=C2C(=O)CC(C)(C)C21
+CCCCCCCCCCCCCCCC(C)(C)C
+CN1CCN(CC2OCC(NCc3nccn3C)C2O)CC1
+COc1cc(Cc2cnc(N)nc2N)cc(OCCC(=O)O)c1OC
+CC(=NOCCSC(=N)N)c1ccc(Cl)c(Cl)c1
+CC1=Cc2cc3c(c(O)c2C(C)O1)C(=O)C=C(O)C3=O
+CN1C(=O)Nc2cccc(CN)c2S1(=O)=O
+c1ccc2c(CNCCCNCc3cccc4ccccc34)cccc2c1
+O=P(O)(O)c1ccccc1O
+CC(C)(C)NCC(=O)Nc1c2c(nc3c1CCC3)CCC2
+COC(=O)CC(C)CCC1C(C)=CCC2C(C)(C)C(=O)CCC12C
+CC(C)CCNC1(Cc2cc(-c3cccc(O)c3)on2)COC1
+CCc1c(O)cc(CCC(C)C)oc1=O
+CC(C)C1Oc2cc3oc(=O)ccc3cc2C1=O
+O=NN1CCCc2cc3c(cc21)N(NO)CCC3
+CCNC(=O)Nc1ccc(C(O)C2COCC(=O)N2C)cc1
+CC=CC=Cc1cc(O)cc(O)c1C=O
+O=C(Nc1ccccc1[NH+]([O-])O)C(F)(F)F
+CCOC(=O)C1=C(C)N=C(C)/C(=C(/O)OCC)C1c1cccc(I)c1
+COC1COC2C(NS(=O)(=O)c3cccs3)COC12
+CCCCCCCc1ccc(C#Cc2ccc(OCCCC)cc2)nc1
+COC(=O)c1c(C)oc2ccc(OC(=O)c3ccc(F)cc3)cc12
+Clc1cc(Cl)c(Cl)c(-c2cccc(Cl)c2Cl)c1
+COc1cc(OC)c(C(=O)C=Cc2ccccc2OC)c(OC)c1
+Cc1c(O)cc2c(c1C)OC(C)(CCCC(C)CCCC(C)CCCC(C)C)CC2
+COc1cc(C(O)C(O)c2ccccc2)oc(=O)c1
+COc1ccccc1CC[C@H](O)CC[C@@H]1[C@@H](CCCCCCC(=O)O)[C@@H](O)C[C@H]1O
+CC1=CC(c2ccccc2)CC(=O)O1
+CC1C(O)CCC2(C)CC(=O)C(C(C)(C)O)=CC12
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCOC(=O)CCCCCCCCCCCCCCCCCCC
+CC(C)=CCc1ccc2[nH]c3c(CC(C)O)c(C)c(O)cc3c2c1
+CCC(C)=CC(=O)OC1C(O)C(C2(C)CO2)CC2(C)C(C)CC(=O)CC12
+CCCCCCCCCCCCCCCC=CCCC=CCCCC(=O)OC
+COc1ccc2c3c([nH]c2c1)-c1cc(C)cc(=O)n1CC3
+CCCCCCC(Br)(Br)C(=O)C(Br)Br
+O=CCCCCCCCC1OC1CCCCCCCC(=O)O
+C1=CC(=Nn2cccc2)C=CC1=Nn1cccc1
+CCCCCC(=O)CCCC(=O)CCCCCC(=O)CCCC(=O)CCCCC
+CC(C)CC1=C(O)N(O)C(CC(C)C)C=N1
+c1ccc2ncncc2c1
+CC#CC#CC#Cc1ccc(-c2ccccc2)s1
+COc1ccc(C2Oc3cc(OC)cc(O)c3C(=O)C2O)cc1
+CCCCCCCCCCCCC=CC(O)C(COC1OC(CO)C(O)C(O)C1O)NC(=O)C(O)CCCCCCCCCCCCCCCC
+COc1ccc(-c2cn3nccnc3n2)c(OC)c1
+OCC1OC(n2nnc3ccccc32)C(O)C(O)C1O
+CC(C)(C)c1ccc(-c2nc(I)ccc2O)cc1
+C(=NC(N=Cc1ccco1)c1ccco1)c1ccco1
+CC(=O)OCC1(O)CC23CCC4C(C)(C)CCCC4(C)C2CCC1C3
+CC1=CCC(C)(C)C(O)C2CC2(C)C(O)CC1
+CC12CCC3c4ccc(O)cc4CCC3C1CCC2O
+COc1c2c(cc3ccoc13)C=CC(O)O2
+O=C1C2CC(CN3CCC(O)CC23)C2=CC(O)CCN12
+C=C(C(=O)O)C1CC=C2CCCC(C)C2(C)C1
+CC1(C)CCCC1(C)c1cc(C=O)cc(O)c1O
+CCCCCCCCCCCCCCCC1CCNCCCN(C)CCCCNCCCN1
+CN(Cc1ccccc1)Cc1cc(CC2CNCCC2CC(=O)N2CCc3ccccc3C2)no1
+CCCCCCC(=O)/C=C\C=C\C(=O)c1ccc(C(=O)OC)cc1
+CC1=C(C(=O)O)C(c2ccccc2)N(C)C(=O)N1C
+CCC(C)C(O)(CC(=O)O)C(=O)O
+CC(=NO)C(CC(C)C)=NO
+C=C(C)C(CC=C(C)C)Cc1c(O)ccc(C(=O)C=Cc2ccccc2O)c1O
+CCCCCCCCCCCCCC(=O)OC(CO)CO
+CCCCCCCc1cc(=O)c2ccccc2n1C
+O=C(O)C(CCCc1ccccc1)c1ccccc1
+C=C=Cn1nc(C)c2c(C)nc(CCC)n2c1=O
+c1ccc(CNCCCNCCCCCCCNCCCNCc2ccccc2)cc1
+C=C1C(=O)OC2C1CCC(C)C1CCC(OC(C)=O)C12C
+CC=CC#CC#CC=CC=CCCCC
+CCC=CC=CC1(C)OC(CC(CO)OC)=CC1=O
+CN1CCc2nc(N(C)C)cc(N)c2C1
+C#CCOC(=O)C=C(C)C=CCC(C)CCCC(C)C
+COc1ccc(O)c2oc3ccc(O)cc3c(=O)c12
+COC(=O)Cc1c(C)c2ccc(OCc3ccc(C)cc3)cc2oc1=O
+CCC1CN(C(C)=O)CCC1CC(=O)Nc1ccccc1
+CC=CC#CC#CC=CCC(CCOC(C)=O)OC(C)=O
+C=CCOC(=O)COc1ccc2c(=O)c(Oc3ccc(OC)cc3)coc2c1
+O=C(CCc1c[nH]c2ccccc12)NCCn1ccc2ccccc21
+CCCCCC(O)c1cccc(OCc2ccccn2)c1
+CC1(C)CC(CCNC(=O)c2ccccc2C(=O)O)(Cc2ccccc2)CCO1
+Cc1ccc(Br)cc1F
+Cc1c(CC(=O)NC(C)C)c(=O)oc2cc(O)cc(O)c12
+C=CC1(C)C=C2C(=O)OC34CCCC(C)(C)C3C(=O)OC24CC1
+COc1cc(C(Br)=CC=CC=CC=CC=CC=CC=CC=CC(=O)O)ccc1Br
+O=C1CCC(=O)N(O)CCCCCNC(=O)CCC(=O)N(O)CCCCCN1
+CCCCCCCCCCCCCCCC(=O)OC(CO)COC(=O)CCCCCCCCCCCCCC
+COc1ccc(C(=O)CSC(=N)N)cc1[NH+]([O-])O
+CNS(=O)(=O)Cc1ccc2[nH]cc(CCN(C)C)c2c1
+ON=C1C2CCCC1C1(O)CCCCC1C2
+C=C(C)C1CC=C(C)C(=O)C1O
+c1ccc(CNC2CC2)cc1
+C=C(C)C1CC(=O)C2CCC(O)C(C)C2(C)C1
+CC1(C)CC=CC23CCC(C=C12)C3(C)C
+C=C(C(=O)O)C(CCCCCCCCCCCCCCC(C)O)C(=O)O
+CCOc1ccc2[nH]c([S+]([O-])Cc3ccccc3N)nc2c1
+Cc1ccccc1-n1c(=O)[nH]c(O)c(C2NCCc3ccccc32)c1=O
+COc1ccc(C(=O)Nc2ccccc2Cl)cc1OC(C)=O
+C=C1C(=O)OC2CC3(COC(C)=O)C(CC12)C(=C)C1OC(O)C3O1
+c1cnc2c(C3NCCc4c3[nH]c3ccccc43)cccc2c1
+CC(=O)OC1C(C(C)C)C(O)CC(C)=C2CCC(C)(O)C21
+O=C1NCCc2c1[nH]c1ccc([NH+]([O-])O)cc21
+CC(C)C(NC(=O)OCC1c2ccccc2-c2ccccc21)C(=O)O
+COc1ccc2c3ccnc4c3n(c2c1O)C(=O)CC4
+C=C(CCC(C(=O)O)C1CCC2C3=CCC4CC(O)CCC4(C)C3CCC21C)C(C)C
+COCCC(=O)Nc1ccc2n(c1=O)CC1CC2CN(C(C)=O)C1
+CNCC(O)c1cc(O)c(O)cc1F
+C=C(C(=O)OC)C(C)O
+CC1=CC(=O)CC2(C)CCC(=O)C=C12
+COc1ccc(-c2cc3ccc(OC(=O)c4ccccc4OC)cc3oc2=O)cc1
+Clc1ccc(Sc2ccc(NC3=NCCN3)cc2)cc1
+C=C(C)C(=O)OC1CC(C(=O)OC)=CCCC(C)=CC2OC(=O)C(=C)C21
+CCCCCCCC1CC=CC(=O)O1
+Cn1c(O)c(C(=O)C(Cl)Cl)c(=O)c2ccccc21
+CCCCCCCCC=CCCCCCCCC(=O)C1=C(O)CCC(O)C1=O
+O=C(NCCCn1ccnc1)c1cccs1
+CCCCC(CC)CC1(CC)C=C(CC)C(CC(=O)O)OO1
+C=c1[nH]c2onnc2c1=C
+CCCCCCC=CCCCCCCCCCC(=O)OCC(COC(=O)CCCCCCCCCC=CCCCCCCCC)OC(=O)CCCCCCCC=CCCCCCCCC
+CC(O)CC(=O)CCCCCCCCCCCCCCCCCCCCCCCC(O)CCOC1OC(CO)C(O)C(O)C1O
+c1coc(Cc2ccc(Cc3ccco3)o2)c1
+O=C(O)CCC(O)C=C(O)C(=O)O
+CCCCCCCCCCCCCC=CC=CC=CC=CC(=O)O
+CC(C)=CCOc1ccc(C=O)cc1
+CC1CC(O)CC(C)(C)C1
+CC=CC#CC#CC(=O)O
+C=Cc1ccc(OC)c(OC)c1
+C=CCCCCCCCCC1CC(CC(COC)OC)C(=O)O1
+COc1cc(Br)cc2c(O)cc(C(=O)O)nc12
+CC(C)(C)OC(=O)NCC1OCC(N)C1O
+CCOC(=O)c1c(C)oc2ccc(OCC(=O)OC(C)(C)C)cc12
+O=C(Cl)ON1C(=O)CCC1=O
+COc1ccccc1CNC1C2COC(O2)C(N(C)CCc2ccccn2)C1O
+S=c1c2ccccc2oc2ccccc12
+CC(C)=CCCC(C=O)=CC=O
+Oc1ccc(C=Cc2c(O)c(O)c3c(c2O)CCCC3)cc1O
+C=CC(C)(CCC=C(C)Cc1cc(C)co1)CC(=O)c1ccc(O)cc1O
+COc1cc(C2(COC(=O)C(C)C)CO2)c(OC(=O)C(C)C)cc1C
+CCCCCC(=O)c1ccc(O)c(C(=O)Nc2ccc(Br)cc2)c1
+COc1ccc(C(=O)C=Cc2cc3ccccc3o2)c(OCc2ccccc2)c1
+CCCCCCC1CC1CCCC(=O)O
+CC(CCCCCCCCCCCCCCCC(O)CC(=O)O)OC1OC(C)C(O)CC1O
+CCC=CCC=CCC=CCCCCCCCC(=O)O[Si](C)(C)C
+O=C(O)CCCCC1C2NC(=O)NC2CS1(=O)=O
+O=C1CC(=Cc2ccc3[nH]ccc3c2)C(=O)N1
+CC12CCCCC1CCC1C2CCC2(C)C(C3=CC(=O)OC3)CCC12
+CCCCCCCCCCCCCCCC(=O)CC(=O)CCC
+O=C(CN1CCCCC1CCO)c1c[nH]c2ccccc12
+CS(=O)(=O)c1ccc(-c2ccccc2-c2ccc(F)c(Cl)c2)cc1
+Cc1nn(-c2ccccc2)c(Cl)c1C=NO
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC=O
+COc1ccc2nc(CC3CN(C4CCOCC4)CCC3CC(=O)O)[nH]c2c1
+O=P(Cc1ccccc1OCCCCCOc1ccccc1)(c1ccccc1)c1ccccc1
+CC1N=CC23CCC4C(CCC5CC(N)CCC54C)C2CCC13
+CCC(O)CCC=CC#Cc1cccs1
+COC1C(O)COC(O)C1O
+C=C1C(=O)OC(CCCCCCCCCCC)C1C(=O)O
+CCCCCCCCCCCCCCCCCCCC(=O)OCC(O)CO
+CC(=O)OCC(COC(C)=O)=C1C=CC2(C)CC=C(C)CCC3OC3(C)CCC12
+COC(=O)C1C(NC(=O)C2CCCC2)CCN1C(C)=O
+C[Si](C)(C)OC1CSSCC1O[Si](C)(C)C
+Nc1ccn(C2OC(CO)C(O)C2O)c(=O)n1
+C=C(C)C1CC=C(C=NO)CC1
+Nc1ccc(O)c(F)c1
+CN(C)Cc1c(O)ccc2c1OC(=Cc1ccccc1Cl)C2=O
+SCOC(OCS)c1ccccc1
+Nc1cc(C2CC3CCC2N3)cnc1Cl
+O=C(O)c1cn2c(n1)COc1ccccc1-2
+CCCCCCCCCCCCCCCCCCN(CC)c1ccc(C(=O)O)cc1
+N=C(N)c1cccc(OCCNC(=O)c2ccc(C(=O)N3CCCC3)cc2)c1
+CCCCOc1cc(OCCCC)c2c3c(c(=O)oc2c1)CCC3
+COc1ccc2cc([NH+]([O-])O)ccc2c1C(=O)O
+COC(=O)CCC(C)CCCCCCC(C)C
+COC(=O)COCCOCC(=O)OC
+C=C(C)C1(O)CCC(C)=CC1=O
+COc1cc2c(cc1OC)C(=CC(=O)c1ccccn1)NCC2
+CC1=CCCC(C)(O)C=CC(C(C)C)CCC(C)(CO)C(=O)C1
+CCNC=C1C(=O)C=C(C2C(C)C=CC3CCCCC32)OC1=O
+O=C(C(c1ccccc1)n1cnnn1)N1CCCCC1c1cccnc1
+CC(=O)C=Cc1ccc(C)c(C)c1C
+COc1cccc2c1C(O)(CC#N)C(O)=N2
+CC(=O)c1ccc(C)cc1OC(=O)c1ccccc1OC(C)C
+CCn1cc(Br)ccc1=O
+C=C(C)c1oc2ccc(C(=O)COC(C)=O)cc2c1OC
+COc1cc(C=Cc2ccccc2)cc(O)c1O
+CC12CC(CCl)C3c4ccc(O)cc4CCC3C1CCC2O
+C=C(C)C1CC=C2C=C(C(C)C)CCC2(O)C1(C)CCC(=O)O
+OC1CCOC1Cc1ccccc1
+CCNc1ccccc1C(=O)O
+OB(O)c1cccc(-c2ccccc2)c1
+CCCCCCC=CCCC=CCCCCCCCCCCCCCCCCCCCC(=O)O
+CCCCCCCC(C)CCCCC
+CCn1c(=O)[nH]c2cc(C(=O)O)ccc2c1=O
+CC(CCO)CCC1C(C)(O)CCC2C(C)(C)CCCC21C
+COc1ccc2c3ccnc(C)c3n(C)c2c1
+CC1(C)C2CCC(C(=O)O)(C2)C1O
+CCCCC/C=C\C/C=C\C/C=C\C/C=C\CCCC(=O)Nc1ccc(O)cc1
+COC(=O)C1(c2cc3ccccc3[nH]2)COCC=C2CNCCC21
+Cc1cc(O)c(O)c2c(=O)c(O)c(-c3ccc(O)cc3)oc12
+CCCC1CC(O)C(Cl)C(O)(C(Br)Br)O1
+COc1cc2c(cc1O)C(Cc1ccccc1)NCC2
+CCOC(=O)C=C1CCC2C(O)(CCC3C(C)(C)CCCC32C)C1
+O=C(O)Cc1c(O)cccc1O
+CC(C)CCCC(C)CCCC(C)CCCC(C)C(O)CO
+C[C]1[CH][CH][C](N)[NH+](C[C]2[CH][CH][CH][CH][C]2C)[CH]1
+COc1cc(-c2cc3ccccc3o2)c(C)c(O)c1C
+c1ccc(N=Nc2ccccc2N=Nc2ccccc2)cc1
+N=C(N)NCCCC(NC(CCC(=O)O)C(=O)O)C(=O)O
+Cc1ccc2oc(-c3cc(NCCCC#N)ccc3Cl)nc2c1
+COc1ccc(CC(C)N)c(OC)c1OC
+CCc1cc(C(C)=O)c(O)cc1OCCCCCCC(=O)NC
+NC(Cc1ccc(-c2ccc(CC(N)C(=O)O)cc2O)c(O)c1)C(=O)O
+CCCCCc1ncc(C)s1
+CCCCCCCCCCCCCCCC(=O)OCC(O)COP(=O)(O)OC1C(O)C(O)C(O)C(O)C1O
+COC1=CC(=O)OC(CC(O)c2ccccc2)C1
+CCOC(=O)C(NCC(O)COc1ccccc1C)C(=O)OCC
+Cn1ccc2c(c1=O)C(=O)OC2(C)C
+Cc1cc2cnnc-2no1
+N=C(N)SCc1cccc(CSC(=N)N)c1
+C=C1CCC2C(C)(C)CCCC2(C)C1CC=C1CC(OCC)OC1=O
+CCCCCCC(O)C(=O)O
+CC1=CC2OC(O)C3(C)OC23CCC(C)=CCCC2(C)OC2CC1
+COCCNc1ncccc1-c1noc(C2CCCN2CC(C)C)n1
+CNCc1cccc(OC)c1O
+CCCC=C1OC(=O)c2ccccc21
+Cc1c(CCC(=O)NCCC(=O)O)c(=O)oc2cc3occ(C(C)(C)C)c3cc12
+CC(C)C(Nc1nc(N)nc2[nH]cnc12)C(=O)O
+Cc1c[nH]cc1-c1ccccc1
+O=C1CC2C=CC1CC2
+Cc1ccc(C(=O)NC(=O)CSc2nccc(O)n2)cc1
+COc1cc(O)ccc1-c1oc2cc(O)cc(O)c2c(=O)c1CC=C(C)C
+COc1ccc2nc(C)c(C(N)=O)cc2c1
+CC1C(=O)Oc2cc3c(c(O)c21)CCC1C(C)(C)CCCC31C
+CC(O)C(O)(C(=O)OCC1CCN2CCCC12)C(C)(C)O
+CCCCc1cccc(CCC)c1O
+O=Cc1ccc2ccoc2c1
+CC(C)NC(C)C(O)COc1ccc(CC(N)=O)cc1
+CC(=O)OC1C=C(CCO)C(C)CC2OC(=O)C(C)C12
+CC(=O)OC1CC(C)C2(CCCC(=O)O2)C2(C)CCCC(C)(C)C12
+CC(=CC(=O)O)C1CC2C(C)(CCC3C(C)(C)CCCC32C)O1
+COc1cc2c3c(c1O)C1(CCC(O)CC1)CCC3N(C)CC2
+Oc1nnc2c[nH]ccc1-2
+CCCCCC=CCC=CCCCC1CC(=O)C2CCCCC2N1C
+O=C1C(=CC=Cc2ccccc2)CCC1=C1SCCCS1
+CCN(CC)C(=O)C1CCCN(CCCCCCCCCCCCN2CCCC(C(=O)N(CC)CC)C2)C1
+CC(C=CC1=C(C)CCCC1(C)C)=CC=CC(C)=CC(=O)NC(C)C(=O)O
+O=C(O)CCCCCCCCC(=O)O
+COc1cccc(CCc2ccccc2)c1
+COc1cc2oc(=O)c(CC(=O)NCCCCCC(=O)O)c(C)c2cc1Cl
+COCCCN1C(=O)C(O)=C(C(=O)c2ccc(OCC(C)C)cc2C)C1c1ccncc1
+c1cn(-c2ccon2)cn1
+CC(=O)Nc1nc2ncc(C(=O)O)nc2c(=O)[nH]1
+COc1ccc(O)c2c1C(=O)OC(CCCC(C)=O)C2
+C=C(C)C#Cc1cc(O)c(C#CC(=C)C)c(CO)c1O
+NCc1ccc2c(Br)cccc2c1
+COc1ccc(C=C2Cc3cc(OC)c(OC)cc3C2=O)c(OC)c1
+OC1CNC(c2nc(-c3cnccn3)no2)C1
+CCC=CC=C1COC2(CCC(CO)O2)C1O
+C#CCOC(=O)C(F)(F)F
+CC1CCC(C(C)C)C(OC2OC(CO)C(O)C(O)C2O)C1
+Cc1cc(=O)c2c(o1)-c1cc(O)c(O)cc1OC2
+CC(N)C(=O)NC(CCCCN)C(=O)NC(CCCCN)C(=O)O
+NC(CC[Se][Se]CCC(N)C(=O)O)C(=O)O
+CC(C)=CCCC=C(C)COc1ccc2ccc(=O)oc2c1
+NC(=O)c1cc(Br)ccc1F
+C=CC=C(C)COCC(=O)C#CC
+CC(NC(=O)c1c(O)c2cccc3c2n(c1=O)CC3)c1ccccc1
+O=C(O)Cc1ccc(C(F)(F)F)cc1Br
+CCCCCC1(O)C(C)=C(C)C(=O)C1CC(=O)O
+Cc1cc(=O)c(O)c(C(CC(N)=O)c2cccnc2)o1
+CCOC(=O)Cc1nc(-c2ccc(OC)cc2)oc1-c1ccco1
+CCCCNC(=O)[C@H](C)C[C@H](O)[C@@H](N)C[C@@H](C)Cc1ccccc1
+CCCN=C(C)c1ccccc1
+OCC1OC(n2nnc3c(O)ncnc32)C(O)C1O
+CC(C)=CCCC1(C)C=Cc2c(c(C=O)cc3c2[nH]c2ccccc23)O1
+CCCCCCC=CCCCCCC(OC(C)=O)C(C)NC(C)=O
+C=C1C(=O)CC2CC3(C)CCCC(=C)C3CC12
+COc1cccc(C=CC(=O)O)c1C(C)C
+CCCCCCCCCCCCC(=O)C1(O)C(O)C=CC1OC(C)=O
+CC(=O)C(C)=CC1C(C)=CCCC1(C)C
+CCCCSCC(NC(=O)CC[C@H](N)C(=O)O)C(=O)NCC(=O)O
+O=C1NC2c3ccccc3C3CCC2C3NC(=O)N1c1ccccc1
+CC(=O)OCC1=CCN2CCC(OC(C)=O)C12
+COc1ccccc1C(CCN=Cc1ccc(N(C)C)cc1)C1CCOC(C)(C)C1
+CC(=O)OCC(C)(O)c1ccc(C)cc1
+O=C(O)c1ccc(CN2CCN3C(=O)N(c4ccccc4)CC3C2)cc1
+CCCCCCCCCCCCCCCCCc1cc(O)cc(O)c1
+Cc1ccccc1-c1nc(-c2ccccc2)nc(N)c1CN
+COC(=O)C(C)COC(=O)c1ccccc1
+O=C1C=CCCCc2ccc(O)c(c2)-c2cc(ccc2O)C1
+CCCCCCCCCCCC=CC(O)C(COC1OC(CO)C(O)C(O)C1O)NC(=O)C(O)CCCCCCCCCCCCCCCCCCCCCC
+N=c1ncoc2[nH]ccc12
+COc1ccccc1CCNCC1C(=O)OC2CC3=CCCC(C)C3(C)C(O)C21
+COc1cc(OC(C)=O)c2c(=O)cc(C)oc2c1OC
+CCCCCCCCCCCC(=O)SCCNC(=O)CCNC(=O)C(O)C(C)(C)COP(=O)(O)O
+CNCCN1CCN([NH+](O)NOc2ccnc(Cl)n2)CC1
+C[C]1[CH][CH][CH][NH+](C[C]2[CH][CH][CH][CH][C]2F)[CH]1
+C=C1C(=O)OC2CC(C)(C3CO3)C(C(=C)C=O)CC12
+CC=CC(=O)OC(=O)C=CC
+C=C1CCC2C(C3C(=C)C(OC)OC(OC(C)=O)C13)C2(C)C
+C=C1CCC2C(=C)C(=O)OC2C=C(C)CCC1=O
+O=S(=O)(O)c1ccc2c3c1-c1cc(ccc1O)CCC=CC3CC2
+CC(=O)OC1CCC2(C)C(CCC(C)=CCO)C(C)=CCC2C1(C)C
+CC(=O)OC1CC(C)C(C=O)=C2C(C)CC(C)(C)C21
+O=C(O)CCCC/C=C(\c1ccccc1)c1cccnc1
+COC(=O)CNC(=O)N1CCc2nc[nH]c2C1c1ccncc1
+COc1cc(CCc2ccc(O)c(O)c2)cc(O)c1OC
+CCCCC=CCCCCCCCc1cc(OC)cc(OC)c1
+C=CCCCCCCCCCCCC=CCCCCCCCC
+N=C(N)c1ccc(CN2CCN(c3cccc(OCC(=O)O)c3)CC2)cc1
+CCCCCCCCCCCCC(C)CCCCCCCCCCCC
+CNC1=CC(=O)CCC1
+Cc1cccc2c1ccn2CCNC(=O)CCC1NC(=O)c2ccccc2NC1=O
+CSC=CC(=O)NCCCCNC(=O)C=Cc1ccccc1
+O=C(O)c1cc2ccc(O)cc2oc1=O
+CC(C(O)c1ccccc1)N(C)Cc1ccccc1
+CCCCCC1C=CC(=O)CCCCCCCCC(=O)O1
+C=C(C)C=Cc1cccc2c1NC1ON=C(C(=O)OC)CC21O
+CCCCC=CCCCCCCCCCCCCCCCCCC1=C(O)C(=O)C=C(O)C1=O
+CC(=O)C(C=NCC(C)C)C(C)=O
+COCCc1nccc(CC2C(NCc3ccc(F)c(F)c3)CC(O)C2CO)n1
+Nc1ccc2ccccc2n1
+CCCCc1ccccc1-c1n[nH]c(-c2cccc(OC)c2)n1
+CCCCCC=CCC=CCCCCCCCC(=O)OCC(COC(=O)CCCCCCCCCCCCCCC)OC(=O)CCCCCCCC=CCC=CCCCCC
+CC=C(C)C=CCC(C)CCC=C(C)CCC=C(C)C
+COc1ccc2c(c1)cc(C(=O)NC(C(=O)NC(C(=O)O)C(C)C)C(C)C)n2C
+NS(=O)(=O)Oc1cccc(Br)c1
+COc1ccc(C2=CC=C3C=CC=CC3[OH+]2)cc1OC
+CNCCCCCCCCCCCCCc1cccnc1
+c1ccc(C2Nc3ccccc3C3OCCC23)cc1
+O=C1CCCC2=C1C1(CC3c4ccccc4CCN23)SCCS1
+CC(=O)OCCC#Cc1ccc(-c2cccs2)s1
+O=C(c1ccccc1)c1ccc(O)cc1O
+CCCCN(C)CC1OCC(NC(C)=O)C1O
+CN(C=Cc1ccccc1)C(=O)C1OC1c1ccccc1
+CC(=CC(=O)O)CCC1(CO)C(C)CCC2(C)C(C)=CCCC21
+C=C(C)C1CC2(C)C(=CC1=O)CCC(OC(=O)C=CC(C)COC(C)=O)C2C
+Cc1c(OCC(=O)Nc2ccc(C(N)=O)cc2)c(=O)ccn1CCC(C)C
+CC=C1CN2CCc3c([nH]c4ccccc34)C2CC1C(C)=O
+CSC(C)CC(=O)C1=C(C)CCCC1(C)C
+CCCc1nc(OC(C)=O)n(-c2ccccc2)n1
+CCCCn1c(=O)c2cc(C(=O)O)cn2c2ccccc21
+CNC(=O)C(C)(C)N1CCCC1C(=O)NCCN1CCOCC1
+COC1(C)C=CC(C(C)C)CCC2=CC(CC(C)=CCC1)OC2=O
+COc1ccc(CC(C(=O)O)C(=O)O)cc1OC
+CCOC1(C)CCC2C1C1C(CCC2(C)O)C1(C)C
+CCCCCC1NCCS1
+CC(C)n1c(=O)nc(-c2ccccc2)c2cc3c(cc21)OCO3
+CC(=O)OCC1=CCCC2C1(C)CCC(C)C2(C)CCC(C)=CC(=O)O
+Fc1ccc(C2CC3CCC2N3)cn1
+CC(C)C(=O)C1CCC2(O)CCCC(C)C12C
+CC1Cc2ccccc2C1(O)c1ccccc1
+CC1(O)CCC(C2=CCCC3CCCCC23)CC2C1CCC2(C)O
+COc1ccc2oc3c(OC)c(O)cc(O)c3c(=O)c2c1
+OCc1cc(CC2(NCc3ccccc3)COC2)no1
+CC(=O)OCN1C(=O)c2ccccc2S1(=O)=O
+COC(C(O)C=O)C(O)C(O)CO
+COc1ccc(C2COc3cc(O)ccc3C2)cc1
+CC(=O)OCC=C(C)C(=O)C=CC(C)(C)OO
+COCc1cn(C2COC3C(NC(=O)C4CCCCC4)COC32)nn1
+COc1nc(N)nc2c1ncn2C1OC(CO)C(O)C1O
+CC(=O)OC1OCC=C2OC(=O)C=C21
+COC(=O)C=CCCCCC1OC2(CCCCCCCCCCCCCCCOCC(N)CO)CCC(O)C1O2
+CCCCc1ncc(C)nc1C
+NC(CCC(=O)NCCC(=O)O)C(=O)O
+COC1C=C(CCC2(C)C(C)=CC(=O)CC2C)C(=O)O1
+C=C1CC(O)C(O)C2(C)CCC(C(C)(O)CO)CC12
+CC(C)(C)c1nnc(C2CCN(Cc3ccncc3)C2)o1
+CCCC1(CCC)C(=N)NC(=S)N=C1O
+Brc1ccc2n(-c3ccccc3)nc3ccccc3c1-2
+COC(=O)C1Cc2c([nH]c3ccccc23)C2CCC(=O)N12
+O=C(C=Cc1cccc(O)c1O)OC1CC(O)(C(=O)O)CC(O)C1O
+COc1cccc(NC(=O)N2CCOCC(OC)C2)c1
+O=CCCCCC(=O)O
+COc1ccccc1OC
+CCCCCCCCCCCCCCCCCCCCCCCCCC(C)(O)CCO
+CC(C)(C)NCC(O)COc1nsnc1N(CCO)CC(=O)O
+CCCCCCCCCCCC(=O)C1C(=O)CCC(C(=O)OC)=C1O
+O=C1C(=Cc2ccccc2F)Oc2c1ccc(O)c2CN1CCOCC1
+CC(=O)NCC1OC(CO)C(O)C1N(C)CCc1ccccc1
+C#CC=CCC(Br)=C1CC2CC(CC)C(Br)CC2O1
+COc1ccccc1COc1ccc2c3c(c(=O)oc2c1C)CCC3
+CC1(C)CCCC2CC3CC21CC=C3C(=O)O
+C=C(C)C1CCC(C)CC1=O
+CC1CCCc2c(O)c(O)c3c(c21)COC(=O)C3(C)O
+Oc1ccncc1-c1ncccc1O
+[O-][N+]12CCCCC1C(CO)CCC2
+COC(=O)CCC(C)C1CCC2C3CCC4CCCCC4(C)C3CC(O)C12C
+COCCCCCCN/N=C(\C)C(=O)O
+CCCCCCCCC1OCCCC1CCCCCCC
+COC(=O)C1CN(C(=O)c2ccccc2)CCN1C(C)=O
+Cc1ccc(S(=O)(=O)NC(=O)Nc2ccc(Cl)cc2)cc1
+COc1ccc(O)c2c(=O)c3c(O)cc(O)cc3oc12
+CC(C)CCCCCCCCCCCCCCCCCCC(O)C(=O)O
+C=C(C)CCCC(C)=C1CC=C(C)CC1
+c1ccc2oc(C3CCN(C4CCC4)C3)nc2c1
+COc1c(O)cccc1C(=O)OCc1ccccc1
+C=C(CC(=O)C(C)=CCCC(=CCCC(C)=CCO)CO)C(C)C
+CC1=CCCC2C1(C)CCC(C)C2(C)CCC1CC(=O)OC1O
+COC=C(C(=O)OC)C(=CC=Cc1ccccc1)CO
+NC(=O)CC[C@H](NC(=O)OCc1ccccc1)c1nc2ccsc2c(=O)o1
+CC(=O)OC1C=C2C(C)(C)OOC2(O)CC1C
+Cc1cccc(C)c1C(=O)OC1OC(CO)C(O)C(O)C1O
+CN(O)C(=O)Cc1ccccc1
+COc1ccc(C(CC(=O)NCCCNc2ccccc2)c2cc3c(cc2O)OCO3)cc1
+COc1cc(C2c3cc(OC)c(O)cc3CC(C)C2C)ccc1O
+CC(C)=CCc1cc(C(=O)O)ccc1OC(=O)C=C(C)C
+CC(C)CC(N)C(=O)NC(CO)C(=O)O
+OC1C(NCC2CCCCC2)C2COC(O2)C1n1ccnc1
+Cc1cc2c(c(=O)o1)C(c1ccsc1)CC(=O)O2
+CC(=O)OCCI
+CCCCCCCCC(C)CCCCCCCC=CCCCCCCC1OCC(N)C1O
+CC(C)=CCCOc1c2ccoc2cc2oc(=O)ccc12
+O=C1c2[nH]cnc2N(Cc2ccc(F)cc2)C2=NCCN12
+CN1C(=O)c2ccccc2NC(=O)C12OC2c1cccc(O)c1
+CC(=O)OCC1(O)CCC2C1CC(C)(C)CC1CC12C
+Cc1cccc(CC(=O)O)c1
+COc1cc(CC2COCC2C(O)c2ccc(O)c(OC)c2)ccc1O
+CCC=CCC=CCC=CCCCCCCCC(=O)OCC(COC(=O)CCCCCCCC=CCC=CCCCCC)OC(=O)CCCCCCCCCCCCC
+CC1(C)C=Cc2cc(C=Cc3cc(O)cc(O)c3)ccc2O1
+NC(CC(O)C(O)C(=O)O)C(=O)O
+CCOC1c2c(ccc3ccc(=O)oc23)OC1C(C)C
+Nc1nc(Cl)nc2c1ncn2C1CCC(CO)O1
+COC(=O)CN1C(=O)C2CC(O)CN2C2(CN(CC(C)C)C2)C1=O
+COC1CC(NC(C)=O)C(O)C(C)O1
+On1cc2nccc-2cn1
+C=CCCCC=CC=C(C)CCCCC=CCCC=CC(=O)NC(CO)CO
+COc1ccccc1C=C1Oc2c(ccc(O)c2CN2CCCC2)C1=O
+COc1ccc2ccc(=O)oc2c1C(O)C(O)C(C)C
+C=CC1CN2CCC1CC2CNC(=O)c1ccc2c(c1)OCO2
+CN1CCCN2CCN(CCCN(CCC#N)CC1)CC2
+Cc1c([N+](=O)[O-])oc2ccccc12
+O=C(NCC1CCCCC1)c1cccc2nc(CCl)cn12
+COC(=O)c1cncc(C(C)OC)c1
+O=C(C=Cc1ccccc1)NCCc1ccc(O)cc1
+CN(C)c1ccc(C=C(C#N)c2nc(O)c3ccccc3n2)cc1
+O=C(CCCN1Cc2ccccc2C1=O)NCC1CCCN2CCCCC12
+CCCCCCCCCCCCCCCCCCCCCCC(=O)OCC=C(C)CCCC(C)CCCC(C)CCCC(C)C
+C=C1CCC(=O)C(C)CCC2C1CC2(C)C(=O)CCC(C)O
+COc1ccc(C2OC(=O)C(C)(C)C(=O)C2C)cc1OC
+Cc1ccccc1NC(=O)Oc1ccc2c(c1)[C@]1(C)CCN(C)C1N2
+C=C1CCC2C(C)(C(=O)O)CCCC2(C)C1CCC1COC(OC)C1
+CC12CCC3c4ccc(O)cc4C(=O)CC3C1CCC2O
+NC(CCNC(CNC(Cc1c[nH]cn1)C(=O)O)C(=O)O)C(=O)O
+COc1cc2[nH]c(C(=O)O)c(C=O)c2cc1OC
+COc1cccc(C2CC(CO)C3CC(O)CCN3C2)n1
+CC(C)N1CCN2C(=O)N(C3CCCCC3)CC2C1
+CC(NC(=O)C(N)CC(=O)O)NC(=O)N(C)C(C)(C)C
+CCCCCC=CCC=CCCCCCCCC(=O)OC(COC(=O)CCCCCCCCCCCCCC)COC(=O)CCCCCCCCCCCCCCC
+CC(C)COC(=O)c1ccccc1C(=O)OCC1CCCCC1
+COc1cc(NCCCN)c2nccc(C)c2c1Oc1ccccc1
+Clc1ccc(-c2nnc(-c3ccc(Cl)cc3)s2)cc1
+O=C1Nc2ccccc2-c2cccn2[C@H]1Cc1ccc(O)cc1
+CC(C=O)=CCCC(C)(O)C=Cc1cc(O)ccc1O
+CC(=O)c1ccc2[nH]c3c(c2c1)CCCC3=NCCO
+CC1=CCC(C(C)=CC(O)C(O)C(C)(C)O)CC1
+CC1=CCC2(O)C(C)=CCC3C(C)C(=O)OC3C12
+C=C(C(=O)OC)C1CCC2(C)C(O)C(O)CC(=C)C2C1O
+CCCCCNC(=O)COc1ccc2nc3n(c(=O)c2c1)CCCCC3
+CCOc1cccnc1
+CC(=O)NCCCCC(=O)O
+CN(C)c1ccc(-c2nc3ccc(I)cc3s2)cc1
+CCCCCC=CCC=CCCC1OC1CCCC(=O)O
+c1ccc2c(c1)NCC(C1=NCCN1)O2
+COc1cc2c(c3c1C=COC=C3)OC(C(C)(C)O)C2
+O=C1NC(=O)C2=C1CCC2O
+CCC(CC=CCCC(=O)O)CCCCCCC1C=CCC1
+CCCCCC(O)CCC(=O)Cc1ccc(O)c(OC)c1
+CC(=O)OC(C)(C)C1CCC(C)=CCCC(C)=CCCC2(C)OC2C1
+CC(C)CNC1C2COC(O2)C(n2cncn2)C1O
+O=CCS(=O)(=O)O
+CC(C)C(NC(=O)C(CS)NC(=O)CCCC(N)C(=O)O)C(=O)O
+Clc1ccc(C2N(c3ccccc3)CCN2c2ccccc2)cc1
+CC1(C)SC2C(N=C(O)CCCCO)C(=O)N2C1C(=O)O
+CC(=O)C=CCC(C)C1CCC(C)c2c(O)cc(C(=O)O)cc21
+CNC1CCC2(C)C(=CCC3C2CCC24C(=O)OC(C)C2CCC34)C1
+C=CCn1ncc2c(CC)ncn2c1=S
+CCC(=O)C=CC=CC(C)C(O)CC
+N=c1cn[nH]c2cocc12
+COP(=O)(O)N(C)N=C(O)C(N)CC(C)C
+COc1cccc2ccn(CCC(=O)N3CCC(C(=O)O)CC3)c12
+C=CC1C2C=C(CO)CC1(NC)c1ccc(=O)[nH]c1C2
+COc1cccc2c1C(=O)c1ccccc1C2=O
+CCCCCCC(=O)C(Br)=C(Br)Br
+O=C(O)c1cc(C=CC(=O)c2ccccc2O)c2c(c1)COCO2
+CC=C1CN(C)CC2CCc3c([nH]c4ccccc34)C(=O)C12
+N#CC(C#N)=Cc1ccc2c(c1)OCO2
+Nc1ccc(-c2nc3cc(F)ccc3s2)cc1Cl
+CCn1c(SCC(=O)Nc2cccc(C)c2C)nc2c(=O)[nH]cnc21
+CCCC=CCC1CC=CC=C(C)C=CC=CC(O)CC=C(C)C=CC=CC(O)=N1
+Oc1ccccc1CNC1C2COC(O2)C(n2cnc3ccccc32)C1O
+CC(C)[C@H](N)C(=O)O
+C=C(CC=CC(C)(C)OO)C1CC=C(C)CC1
+O=C(NCc1ccc2c(c1)OCO2)NC(Cc1ccccc1)C(=O)O
+COC(=O)/C=C/c1ccccc1OCC(O)CNCCNC(=O)C(C)C
+O=C(O)c1ccccc1C(=O)NCCC(c1ccccc1)c1ccco1
+COc1cccc(C=CC2=NCCCC2)c1
+CCCCCCCCCCCCC(SCCC(=O)O)SCCC(=O)O
+CC(C)(C)CCNC1CC(O)C(CO)C1Cc1ccnc(-c2ccccc2)n1
+NC(N)=NCCCC(N)C(=O)NC(Cc1ccccc1)C(=O)O
+CC(=O)c1ccccc1OCC(=O)O
+Cc1c(O)cc2c3c1C(=O)OCC3(C)CC2(C)C
+O=C(Cc1ccccc1)NC1COC(CN2CCC(F)(F)CC2)C1O
+N#Cn1c(N)nc2ccccc21
+CCCCCCCCCC(O)CNC(C)=O
+COc1cc(CCC(=O)CC(O)CC(C)CCCO)ccc1O
+CC1CCC2(O)C(C)(C)C3CC(O)C2(C)C1C3
+O=C(O)c1ccc(C(=O)CBr)cc1
+CCCC=CC=CC1CC(O)C(O)C(O)C1
+C=C1CC(=O)OC1=O
+CCCc1ncc(C)nc1C
+CCCCCCCCCCCCCC(=O)CC(O)CCCCC
+C=CCC=CCC=CCCCCCCC=CCCCC(=O)O
+O=Cc1ccc(COCCc2ccc(O)cc2)[nH]1
+CCCCCCCCCCC(O)CCCCCCCCCCCCCC(=O)O
+COc1ccc(C(=O)COC(C)=O)cc1OC
+CN[C@H](CS)CCC(=O)O
+CC1OC(O)CC(O)C1O
+C=CCOC(=O)CCCCC
+O=C(O)CCSCCSCCC(=O)O
+CC12CCC3C4CCC(=O)C=C4CCC3C1CCC2OC(=O)CCC1CCCC1
+OCc1ccc(COCCc2ccccc2)o1
+COC(=O)c1ccccc1NC(=O)N1CCc2nc[nH]c2C1c1cccnc1
+CCCCCCCCCCCCCCCCCCCC(=O)OCC(COC(=O)CCCCCCCCCCCCCCCCC)OC(=O)CCCCCCCCCCCCCCCCC
+C=C1CCC2C(C)(C)CCCC2(C)C1COC(C)=O
+O=C1NCCCC1=CC(=O)c1c[nH]c2ccccc12
+C=C(C)C1CC=C(C)CCC=C(C)CC1
+O=C1C(O)=CC(=O)c2c(O)cccc21
+O=C(CC1Sc2ccccc2N(CCC2OCCO2)C1=O)NO
+O=c1ccc2c(OC3OC(CO)C(O)C(O)C3O)cccc2o1
+C=C1CCC2C(C3CC(C)CC13)C2(C(N)C=O)C1CCCCC1
+CCCCOc1ccc([C@@H]2CC[C@H](NC)c3ccccc32)cc1
+O=C(O)[C@H]1C[C@@H](CO)N1
+N=S(=O)(O)c1ccccc1
+CC(C)CC(NCC=Cc1ccccc1)C(=O)O
+O=CNCCCCN(CCCNC(=O)c1ccccc1)C(=O)C=Cc1ccccc1
+CC1C(c2ccccc2)OC(C#Cc2ccccc2)N1C
+CCC(C)CC(C)C
+N#CCCC1CS1
+COc1c2c(cc3c1[nH]c1ccccc13)C(=O)CC2O
+CCCCCCC=CCCCC1=NC(=Cc2ccc(O)cc2)C(=O)O1
+OCCN(CCO)CCc1ccc(CSc2ccccc2)cc1
+CC12CCCC(O)(C1)C1CCC1C(O)C2
+OCC(O)CC#CC#Cc1ccccc1
+COc1cc(O)cc2c1C(=O)C(O)C(c1ccccc1)O2
+CCc1cc2c(=O)c(-c3nc(C)cs3)c(C(=O)O)oc2cc1O
+CCCCCC(=O)NCC(=O)c1ccc(O)cc1
+CC(C)(C)N=C1C(=O)N=C2C=CC=CN21
+C=CCc1cc(OC)c(OC)c(OC)c1OC
+COc1ccc2c(c1)C=CC(c1ccccc1)O2
+OC(c1ccccc1)C1CCCCN1CCc1ccccc1
+CCCCCCCCCCCCOc1ccc(C(=N)N)cc1
+CCOc1ccc2c(=O)c(Oc3ccccc3)c(C)oc2c1
+CC#CC=C1C=CC2(CCCO2)O1
+Cc1cc2ncccc2c2nc(N)n(C)c12
+O=C(C1=C(O)CCC1)C1CC1
+COC=C(C(=O)OC)C(C)C(C=Cc1ccccc1)OC
+COC(=O)C(CC=Cc1ccccc1)NC(C)=O
+Nc1ccc(-c2nc3ccc(F)cc3s2)cc1I
+CCCCCCCCCCCCCc1cc(=O)c2c(O)cc(O)cc2o1
+CC(=O)NCCc1c(Br)[nH]c2ccccc12
+C#CCN(C)Cc1nc(C2(O)CCN(C(=O)CCc3ccccc3)CC2)cs1
+Cc1c(C)c(CCl)c2ccccc2c1CCl
+CNCC1(c2ccc(OC)c(OC)c2)CCCC1
+CC(c1cc2ncccc2s1)N(O)C(N)=O
+CCC(=O)c1ccc2c(c1)N(CCCN(C)C)c1ccccc1S2
+CCCc1scnc1CC
+O=C(N[C@H]1CN2CCC1CC2)c1ccccc1
+CC(C)COC(=O)C1C(=O)CC(C)(O)C(C(=O)OCC(C)C)C1c1ccc(O)cc1
+COC1=CC23CCN(C)C(Cc4ccc(O)c(OC)c42)C3=CC1=O
+COc1cc2[nH]c3cccc(OC)c3c2cc1C
+CC(=O)Nc1ccc(F)c(Cl)c1
+CCCCCCCC(C)CCCCCCCC(O)CC(=O)OCCCc1cc(O)c(O)c(OC)c1
+Nc1cccc(OC2OC(C(=O)O)C(O)C(O)C2O)c1
+CC(=CCOc1ccc2ccc(=O)oc2c1)CCC(=O)C(C)C
+CC/C(=C(/c1ccccc1)c1ccc(O)cc1)c1ccccc1
+C=CCC/C=C(\NC(=O)C1CC1(C)C)C(=O)O
+CCc1ccc2cc(-c3ccc(Cl)cc3)cn2c1
+CCC(CC)C(C)C
+O=C1OC(=O)C2C3OC(C=C3COC3CCCCC3)C12
+C=CC1(C)Cc2c(O)ccc(OC)c2CC1C(=C)C
+C=C1CC(OC(=O)C(O)=CCO)C2C(=C)C(=O)OC2C2C(C)=CCC12
+O=NN(CCF)C(=O)NCCF
+Cc1ccc2[nH]c(C3CCN(C(=O)c4ccccc4)C3)nc2c1
+CC1=CCCC2C1(C)CCC1(C)C3=C(CC21C)C(=O)C=C(NCC(C)C)C3=O
+Cc1ccc(C(=O)Oc2ccccc2)cc1
+c1ccc(CCc2ccccc2OCCCCN2CCNCC2)cc1
+Cc1ncc2n1-c1ccc(Cl)cc1C(c1ccccc1F)=NC2
+O=C(NC(=O)c1ccccc1Cl)Nc1ccc(OC(F)(F)F)cc1
+CNCCc1cc(Br)c(OCCCN)c(Br)c1
+CCCCC(C)CC(C)CC(C)C(=O)OC
+COc1ccc(C(=O)C=Cc2cccs2)c(OC(=O)c2ccccc2)c1
+COc1ccccc1CCNC(=O)Cn1cc(OC)c(=O)cc1C
+CC=C(CC(C)C(O)(CO)C(=O)O)C(=O)O
+CCC=CCC(O)CCO
+CCC=CCC=CCC(O)C(O)C(O)C=CCC=CCC=CCCC(=O)O
+CCOC(=O)C1(c2ccccc2)CCN(C)CC1
+C=C1C=Cc2c(c(O)c3occc3c2CC=C(C)C)O1
+N=C(N)NCCCCNCCCNCCCNCCCNC(=O)c1ccc(O)cc1
+CC(=O)N(C)CCc1c[nH]c2ccccc12
+CCCCCCCCCCCCC1(O)C(O)C=CC(=O)C1O
+CCC(C)CC(C)CCCCCCCCCCC(O)C(C)N
+O=C1CCCCCCCCCCC(=O)OCCC1
+C=C1C=CC(C(C)C)C12CC=C(C(=O)O)CC2
+COc1cc(C)cc(OC)c1
+C=CC1(C)CCC(C(=C)C)C2C3(C(=O)Nc4ccccc43)C21NC
+COC(=O)C(C)COc1coc2c1c(O)cn2Cc1ccccc1
+CCN(CC)CCCNc1nccc2c(C)c3[nH]c4ccc(O)cc4c3cc12
+O=C(NCC1CCCN2CCCCC12)c1n[nH]c2ccccc12
+CCC(CC(C)=O)N1CNc2nc[nH]c(=O)c21
+O=C1CCOC(c2ccccc2)C1
+O=C(O)C(c1ccccc1)c1ccccn1
+O=C1Nc2ccc(Br)cc2C(=O)N2CCN(C(=O)NC3CCCCC3)CC12
+CC(C)(C)OC(=O)NNC(=NCC(=O)O)NNC(=O)OC(C)(C)C
+O=C1c2scc(-c3ccc(F)cc3)c2-n2cccc21
+Cc1cc(C)c2nc(C)cc(O)c2c1
+CC(=O)Nc1nc(C)c(O)c(C)c1C
+ON(Cc1c(F)cccc1Cl)Cc1c(F)cccc1Cl
+CCCCCCCCCCCCC(C)=O
+O=C(O)C1CCCN1C(=O)OCc1ccccc1
+COc1ccc(CN2Cc3nc[nH]c3CC2C(=O)NC2CCCCC2)c2ccccc12
+CC(=O)NC(Cc1cn(C)cn1)C(=O)O
+COC(=O)c1c(C)c(C)c(O)c(C)c1O
+c1ccc(Cc2nnc(C3CCN(C4CCCCC4)C3)o2)cc1
+CN(C)CCN(Cc1cccs1)c1ccccc1
+COc1ccc(-c2coc3cc(O)c(O)cc3c2=O)cc1O
+C=CCC(=NOS(=O)(=O)O)SC1OC(O)C(O)C(O)C1CO
+CCN1c2ncccc2-c2nccn2-c2cccnc21
+CCCC(O)C(O)C1CC(OC)=CC(=O)O1
+CC1=CC(=O)C2C(C)CCC(=C(C)C)C2C1
+COc1ccc(C2NC(CO)C(O)C2O)cc1O
+CCOCCOCCO
+CCCCCCCCCC=CCCC=CC(O)C(CO)NC(=O)C(O)CCCCCCCCC
+CCNC(=O)CNC(=O)COc1ccccc1C(=O)OC
+CCOC1CC(CCC2(C)C(C)CCC3(C)C(CO)=CCCC32)CO1
+O=C(CC(=O)OCc1ccccc1)OCc1ccccc1
+Cc1cc2nnncc2o1
+CCCC=CC(CC)CC1C=C(CC)C(=CC(=O)OC)O1
+CCn1c2ccccc2c2ccc(N)nc21
+[CH2-][NH2+]C1C(C(C)C)CCC(C)C12C=C(C)CC2
+CC(C)(C)CC(=O)NCC1COCc2nc3cccnc3n21
+COCCN(CC1CCCN2CCCCC12)C(=O)c1cc(CCC(C)C)n[nH]1
+COc1c2occc2cc2c(=O)cc(-c3ccccc3)oc12
+CC(=NNC(N)=S)C(=O)Nc1ccc(Br)cc1
+Oc1cc(-c2ccccc2Cl)nc2cc3c(cc12)OCO3
+N#Cc1cncc(/C=C/c2ccccc2)c1Oc1ccc2[nH]ccc2c1
+CCc1ccc(C(C)NC(=S)NC2CCCCC2)cc1
+COC(=O)C=Cc1ccc(OC2OC(CO)C(O)C(O)C2O)c(OC)c1
+C=C1CCC=C(C)CCC2C1C(=O)OC2(C=CC=C(C)C)CO
+Cc1cc(Nc2cccnc2)c2c(ccc3c[nH]nc32)n1
+C#CC(Br)C1CC(O)C(CC(OC(C)=O)C(Br)CC=CCC)O1
+CC(C)C1=CC(O)C(C)(O)CC1O
+CC1(C)CCCC2(C)C1CCC1(C)C3COC(=O)C3=CC(O)C12
+COc1ccc(C(=O)Nc2cc(C)ccc2C)cc1OC
+CC1=CCCC(=O)C=CC(C)(C)CCC1
+CCCCCCSc1cc(C(N)=S)cc(Cl)n1
+C=CC(C)(O)CCC1(C)C2=CC(=O)CC(C)(C(=O)O)C2CCC1C
+COc1cc(OC)c2ccc(=O)oc2c1OCC=C(C)C
+C#CCN(C)CC1CN2CCC1CC2CNC(=S)NCCN1CCOCC1
+CC(C)(C)CC(=O)NC1C(c2cccs2)N(C(=O)c2ccccc2)CCC1(C)O
+COc1ccc2c(C)c(CCC(=O)NC(C)C(=O)O)c(=O)oc2c1
+CC(C)Nc1ncccn1
+C=CCC1CC2(CC=C(C)C)OCOC2=CC1=O
+COc1ccc2c(c1)OC=C(c1ccc(OC)c(OC)c1)C2O
+O=C(NCCCN1CCC(Cc2ccc(F)cc2)CC1)NC1CCCCC1
+C=C(C)C1CC2C(C)(C)C(Br)=CC(O)C2(C)OCO1
+O=C(CC(CN1CCN(CC=Cc2ccccc2)CC1)C(=O)O)Nc1cccc(O)c1
+Cc1[nH]c(O)nc1C(=O)c1ccc(Cl)cc1
+CC(=O)OCC(=CCCC(C)=CCO)CCCC(C)C(=O)CC=C(C)C
+Oc1c2ccccc2cc2ccccc12
+CC(O)C12CCCN3CCc4c(n(c5ccccc45)CC1)C32
+CCCCCCCCCCCCCCCCCCC(O)CC(=O)c1ccccc1
+Cc1ccc2c(c1C)CCc1cc(C(C)C)c(O)cc1-2
+Cc1ncc(COP(=O)(O)O)c(CO)c1O
+COc1c(C=O)c(CC(C)=O)cc(O)c1CO
+CC(C)C=CC=C(CO)C1CCC2(C)CC(O)(CCC2O)C1CO
+CNC1=CC2=NCCc3c[nH]c(c32)C1=O
+CC1=CC2CC(C)C1(C)CCC1=CC(=O)N(CC(=O)O)C12
+C=CCc1cc(C(C)=O)c(O)cc1OCCCCCC(=O)OC
+CCCCCCCCCC=CC=C(C)C(=O)O
+COc1ccc(CNc2nnc(-c3ccccc3)c3ccccc23)cc1
+CC1=NN(c2cc(C)ccn2)CC1
+COc1cc2c(c3oc(CO)cc(=O)c13)C=CC(C)(C)O2
+CC1CC2C=CC3COC(=O)C3(C)C2CC1O
+CCOC(=O)c1ccc2[nH]c(O)c(Cc3ccccc3)c(=O)c2c1
+CCC(C(=O)c1ccc(OC)cc1)C1CCC(OC)CC1
+CC1(C)CCn2nc(COc3ccccc3)cc2C1=O
+CCCN(CCC)C(=O)c1ccccc1CN(CC)Cc1ccccc1
+CCCCCCCCCCCCCCCCC(C)=O
+CCC=CCC=CCC=CC=CC(O)CC=CCCCCCC(=O)OCC
+CC=C1CN2CCC3(C(=O)Nc4ccccc43)C2CC1CCO
+CCC1(C)COc2ccc(C(=O)CCCC3CC3)cc21
+COc1cccc2c1ccn2CCNC(C)=O
+Cc1ccc(C(C)(C)O)cc1
+CC1(C)S[C@@H]2[C@H](S)C(=O)N2[C@H]1C(=O)O
+COc1cccc(CN=C(O)CCCCCc2ccccc2)c1
+COc1c(C)c(CCCCCCCCCCSC(C)=O)oc(=O)c1OC
+CCCCC1=CC(=O)C=C(OC)C1=O
+O=C(CCC1NC(=O)c2ccccc2NC1=O)Nc1ccc2[nH]ccc2c1
+CC(C)C=C(NC(=O)c1ccccc1)C(=O)O
+C=CCCCC=CCC=CCC=CCC=CCCCCC
+CC(C)Oc1ccc(C(=O)NC(Cc2c[nH]c3ccccc23)C(=O)O)cc1
+C#CC1(O)CCC2C3CCC4=CC(=NO)CCC4C3CCC21CC
+COc1c(C(C)C)cc2c3c1OC(=O)C31CCCC(C)(C)C1CC2
+CNC1=CC(=CCC(=O)O)CC1
+CC1=CCSS1
+COC(=Cc1ccc(O)cc1)C(=O)NC=Cc1ccc(O)cc1
+Nc1ccccc1C(=O)OC1CCCCC1
+O=C(CCn1ccc2c(Br)cccc21)NC(Cc1ccccc1)C(=O)O
+Oc1cccc2[nH]ccc12
+COc1cccc2nc3c(O)cccc3nc12
+COc1cc(CC(C)C(C)C(OC(C)=O)c2ccc3c(c2)OCO3)ccc1O
+COCC(=O)NCC1C=C(C)C(CC(=O)N2CCN(C)CC2)CC1C(C)C
+CCC(=O)OC1c2c(C)coc2C(=O)C2C(O)CCC(C)C12C
+Oc1cc(-c2ccccc2)c(O)c2c1-c1ccccc1CO2
+C=C(C=CC=CC=CCCC)CC
+Oc1cccc(CCC=CCC=CCCCCCCCc2cccc(O)c2O)c1O
+COc1ccccc1C(CCNC(C)c1ccccc1)C1CCOC(C)(C)C1
+CC1CCC(C)C12CCC1C2=CC2(C)CCC(C)(C)C12
+O=C(O)CCCCCCCCC(=O)Nc1ccc(Cl)c(Cl)c1
+COc1ccc(C(=O)CCN2CCCCCC2)c(OC)c1
+CCCCCCCCCCC=CCC=CCCCCCC1=CC(C)(O)OC1=O
+C=C1CCCC2(C)CC3OC(=O)C(CN(C)CC(O)c4ccc(O)cc4)C3CC12
+CC(=O)NC1C(SCC(O)CN)OC(CO)C(O)C1O
+Cc1coc2cc3oc(=O)c(CC(=O)N4CCOCC4)c(C)c3cc12
+CC12CCC(C(OC(=O)C=Cc3ccc(O)cc3)C1)C2(C)C
+CC(C)=CCCC(C)=CCCC1(C)OC1CCC(=CCO)CO
+CCCCCCCCCCCCCCCCCCCC(=O)OCCCCCCCCCCCCCCCCC
+CC(C)c1cc(C=O)c(C2CCCC(C)(C)C2C=O)cc1O
+CCCCCCCC(C)=CC(CC=CCCC(=O)OC)OC
+CCCCCC(=O)NC1COC(CN2CCN(C)CC2)C1O
+CCCCCC(O)C(O)C(O)C=CCCCCCCCC(=O)O
+CC=C(COC(=O)C(C)=CC)OC(=O)CC=Cc1cc(OC)c2c(c1)OCO2
+CC#CC#Cc1ccc(C#CC(O)COC(C)=O)s1
+CCNC1=NC(=O)C2(CC(C)(C)Oc3ccc(F)cc32)N1
+COC(=O)C1(C)CCCC2(C)C(Cc3ccoc3)CCCC12
+Clc1ccc(C2OCC3(CO2)CC2C=CC3C2)cc1
+CC(C)C(=O)OCC1(c2ccc(CO)cc2OC(=O)C(C)C)CO1
+Cc1cc(C)c(C=CC(=O)c2ccccc2)c(C)c1
+CC(=CCCC12C(=O)OC3(O)CC1CC2C3C)C(N)=O
+c1ccc2c3c([nH]c2c1)CNCC3
+OC1C(NC2CCCC2)C2COC(O2)C1n1cnc2ccccc21
+CCCCNC(=O)NNC(=O)OCC
+CC(=O)OCC(C)=CC(=O)OC1C=CC(C)(C)C(C)=C1C=O
+O=C(O)C1CCCN2CCCCC12
+CC(C)N1CC2OCC(=O)N(C(C)C)C2C1
+c1ccc(-c2c[nH]c(C3COCCN3C3CCC3)n2)cc1
+Cc1cncc(SCc2ccco2)n1
+C=CC(C)(C)OC1OC(CO)C(O)C(O)C1O
+C=CC(C)(CCC=C(C)CCC=C(C)C(O)C(O)C=C(C)C)Oc1ccc(O)cc1CC(=O)OC
+CCOC(=O)c1ccc(NC(=O)CSc2nc3c(=O)[nH]cnc3n2C)cc1
+COc1c(O)ccc2c1OC1c3cc(O)cc(O)c3COC1C2=O
+C=C1C(=O)OC2CC(C)C3CCC(O)C3(C)C(O)C12
+CC1(C)CCCC2(C)C(O)C(C=O)=CC(OC(=O)C=Cc3ccccc3)C12
+Oc1cc(O)cc(CCc2ccc(O)cc2O)c1
+CC(C)=CCCC(C)=CC(O)CC(C)=CCCC(C)(O)C=Cc1cc(O)c(C)cc1O
+CC1CCC2(O)C(CCCC2(C)C)C1(C)CCc1ccoc1
+O=C(O)C1C(O)CCC2CN3CCc4c([nH]c5ccccc45)C3CC21
+C=C(Cl)C(Cl)(CBr)CCC(Cl)C(C)(C)Br
+CCCCCCC=CCCCCCC(CC(=O)O)CC1(c2ccccc2)CCC2(CCCC2)C1
+CC1=CCCC2C(=O)OC3C2C(C1=O)C1CC13C
+CCC12CN3CC(C)(CN(C1)C3c1cccnc1)C2O
+CCCCNc1ccc(C(=O)OCCN(C)C)cc1
+Cn1c(-c2cc3ccc(O)c(CN4CCCC4)c3oc2=O)nc2ccccc21
+COC(=O)C(C)Oc1ccc2c3c(c(=O)oc2c1C)CCC3
+Cc1cc(C)c2c(c1)Oc1ccccc1C(=O)N2
+COc1cc2c(cc1O)C1C=c3cc(O)c(OC)cc3=C[NH+]1CC2
+O=c1[nH]c(O)c(C2NCCc3ccccc32)c(=O)n1CCc1ccccc1
+OC1CSC(O)CS1
+COc1ccc(C=C2COc3cc(O)c(OC)c(O)c3C2=O)cc1
+CCC12CCc3[nH]c4ccccc4c3CCN(CC(O)C1)C2
+COCCC(NC(=O)OC(C)(C)C)C(=O)O
+CC=CC(=O)C1=C(C)C=CCC1(C)C
+COc1ccc2cc(C(C)=O)ccc2c1
+O=S1(=O)CSCSSC1
+CC1CC(=O)O1
+C=CCCCCCC(OC(C)=O)C(OC(C)=O)C(O)C#CC#CCCC
+CC(O)(C=CC1C(C)(O)C(O)C(O)C2C(C)(C)CCCC21C)C(O)CO
+COC(=O)/C=C/C(Cc1ccccc1)NC(=O)CN
+O=C(CCCCC1SCC2NC(=O)NC21)Nc1nccs1
+C=C(C)C1CC2OC(=O)C3(CCC(O)C3(C)C1)C2O
+CC1NC(=O)c2ccccc2N(CC(=O)NCCSc2ccccc2)C1=O
+c1c2c(c3c4c1C15CCNC1CCC(O3)C5OC4)OCO2
+O=C(CSc1ccc2nncn2n1)NCC1CCCN2CCCCC12
+CCc1ccc(C(=O)c2cncc(Br)c2)cc1
+O=c1c2ccccc2nc2n1CCC2=Cc1ccc(Br)cc1
+CCCCCC=CCCC(O)CCCCCCCC(=O)O
+O=P(O)(O)OCC1OC(O)CC1O
+CC1=CC(=O)C2CC1C2(C)COC1OC(CO)C(O)C(O)C1O
+COc1ccc(Br)c(CCN(C)CC(C)O)c1Br
+CCCC1OC1c1cc(OC)cc(=O)o1
+C=C(C)C1CCC2(C)C(CC=C3C4CC(C)(C)CCC4(C)CCC32C)C1(C)CCC(=O)O
+CN(CC#CCN1CCCC1=O)CCCCl
+CC(O)C(O)CO
+CCCCCC=CCC=CCC=CCC=CCCCC(=O)OCC(CO)OC(=O)CCCCCCCCCCCCCCCCCCCCC
+Cc1nnc(C2CCN(Cc3ccc4c(c3)OCO4)C2)o1
+CC(=Nc1ccccn1)c1cc2ccccc2oc1=O
+CC1(C)C2CCC3=CCCC(C)(O)C3(C)C21
+C=C(C)CN1CCN(Cc2oc(C)cc(=O)c2O)CC1
+CC(c1sc2ccccc2c1Cl)N(O)C(N)=O
+CCCCNC(=O)Oc1ccc2c(c1)[C@@H]1CCN(CC)C1C2
+S=C=Nc1cc(-c2ncon2)ccc1Cl
+CC1CCCCC1
+CC(C)CCCCCCOC(=O)C1CCCCC1C(=O)OCCCCCCC(C)C
+CN(C)c1ccc(CNCCCCNCc2ccc(N(C)C)cc2)cc1
+CC1(C)CC2C=C(C(=O)O)C3CC(O)C(C)(O)C23C1
+COC(=O)c1[nH]c(=O)c2ccccc2c1-c1ccc[nH]1
+COc1cc(C2Oc3ccc(CCCOC(C)=O)cc3C2COC(C)=O)ccc1OC(C)=O
+COc1ccc(C2CCc3ccc(O)cc3O2)cc1O
+Cc1coc2c1C(O)C1(C)C(CCC(O)C1C)C2
+CC1(C)CCc2cc(CC3OC(=O)C(O)=C3c3ccc(O)cc3)ccc2O1
+COc1cc(N2C(=O)NC(CC(=O)O)C2=O)cc(OC)c1OC
+COc1ccc(O)c(C=Cc2cc(O)cc(OC)c2Cc2ccc(O)cc2)c1
+CC(=O)C(C)=CC=CC=CC=CC=CC=CC=CC=CC=CC=CC=CC=CCC(O)CC(=O)O
+C=C(C)C1C=C(C(C)C)CCC2(C)OC2CCC(C)CC1=O
+C=C(C)C1CCC(C)C2CCC(C(=O)O)=CC12
+CC1(C(=O)O)CSC(c2ccccc2O)=N1
+O=C1c2ccccc2NS(=O)(=O)N1COCc1ccccc1
+CN1CC(O)=C(C(=O)/C=C/C=C/c2ccccc2)C1=O
+CCCCCC(=O)CCCCC=CCCCCCC(=O)OC
+Cc1oc2c(C)c(O)ccc2c(=O)c1-c1ccc2c(c1)OCCO2
+CC(=O)OC(C)(C)C1CC=C(C)CC1
+COc1ccc(-c2coc3c(OC)c(O)c(OC)c(O)c3c2=O)cc1
+CCCCCCCCCCCCCCCCCCCCCCOC(=O)CCCCCC
+CC(O)C1OC(O)C(O)C1O
+CC=CC=CC(=O)c1cc(C(=O)O)c(OC)cc1O
+COc1cccc2c1CCC[C@H]2CN(C)CCc1ccc2ocnc2c1
+Oc1c(C2OCCc3ccccc32)ccc2cccnc12
+O=C(CCCCCNC(=O)N1CCn2c1nc1ccccc12)NC(C(=O)O)c1ccccc1
+CCCCCCCCCC=CC(O)C(C)N
+Cn1cnc(CC(N)C(=O)O)c1SSc1c(CC(N)C(=O)O)ncn1C
+Clc1nssc1=NC1=NCCS1
+OC(c1cccnc1)c1cccs1
+Oc1nc2ccccc2nc1N1CCNCC1
+NS(=O)(=O)CC/N=C(\S)Nc1c(Cl)cccc1Cl
+N=c1c2c(n(Cc3c(Cl)cccc3Cl)c3c1CCC3)CCCC2
+COc1c2c(c(COC(=O)CC(C)C)c3c(C)coc13)C(C)CC=C2
+OCC(CO)(CO)NCCCNC(CO)(CO)CO
+CCCCCCCCOC(=O)c1cccc(N)c1
+COc1c(-c2ccc(O)c(O)c2)cc2oc3cc(O)c(O)cc3c2c1O
+CC(O)=Nc1nc(O)c2nc[nH]c2n1
+Oc1ccc2cncn2n1
+Cc1cc2cc(O)cc(O)c2c2oc(=O)cc(O)c12
+O=C(CCC1NC(=O)c2ccccc2NC1=O)Nc1cccc(O)c1
+CCCCCCCCCCCCCCCCCCN=C(S)NN=Cc1ccccc1[NH+]([O-])O
+CC(C)=CCCC(C)C1CCC(C)=C2CC=C(C)C2C1
+Cc1cc(C(=O)O)cc2c1OC(C(C)(O)CO)C2
+CN1CCC(NCC2OC(CO)C(O)C2N2CCCCC2)CC1
+COc1cc(C(=O)n2ccc(C)n2)cc(OC)c1OC
+O=C(O)c1cc2cc3ccccc3cc2ccc1=O
+COc1ccc(C2CC(=O)Oc3cc(OC)cc(O)c32)cc1
+COc1ccc(C=CC(=O)N2CCC3(O)CCCCC3C2)cc1OC
+CC(=O)Nc1ccccc1C(=O)C(=O)NCCc1c[nH]c2ccccc12
+Cc1ccc2c(COC(=O)C(C)C)coc2c1
+CCCCCC=CCC=CCCCCCCCCCCCC(=O)OC(CO)COP(=O)(O)OCCN
+COC(=O)Oc1ccccc1C(=O)O
+CN1C=CCC=C1C=NO
+Cc1ccc(O)c(C(=O)CCC(=O)c2cc(C)ccc2O)c1
+CN1C(=O)Nc2cc(CN)ccc2S1(=O)=O
+CCCC1=C(C)C(=O)C(O)O1
+c1cc(-c2conn2)c[nH]1
+COC1C=CC(O)CC(O)CC=CC=CC(O)CC=CC=CC(=O)OC(C)CCCC1O
+Cc1cc(=O)n(C)c2ccccc12
+C/C=C/COc1noc2c1CNCC2.Cl
+COc1cccc2[nH]cc(CC3(O)C(=O)OC4C(O)COC43O)c12
+CC1(O)CCC(C(C)(C)O)CC1
+CCCCCCCCCCCCCCc1cc(=O)c2ccccc2n1C
+COc1ccc2[nH]c3c(c2c1)CN(C(=O)C1CCCCC1)CC3
+CC1CCC23C1CCC2(C)CC(C)(C)C3O
+CCCCC1OCC2(COC(=O)NC(C)C)C(C)C=C(C)C1C2C
+CCCCS(=O)(=O)Nc1ccc2[nH]c(=O)c3ccccc3c2c1
+O=C(CNC(=O)c1ccccc1)Oc1ccc([N+](=O)[O-])cc1
+COc1ccc2[nH]c3c(C)c4cc[n+](C)c(N(C)C)c4cc3c2c1
+CC1CC2OC2C=CC=CC(=O)CC2C(Cl)=C(O)C=C(O)C2C(=O)O1
+CC1OC2OC(=O)C1(O)C2O
+CC=CC=CC1CC2=C(C(O)O1)C(O)C(C)(O)C(O)C2=O
+COc1cc(OC)c(C(C)O)c2c1C=CC(C)(C)O2
+COC1=CC(=O)C23CCN(Cc4c2cc2c(c4OC)OCO2)C3C1
+O=C1NC(=O)c2ccccc2C1=Cc1ccco1
+Oc1ccccc1-c1cc[nH]n1
+Cc1cc2c(cc1O)OC(c1ccc(O)cc1)C(O)C2=O
+CC(=O)C(C)CCC=C(C)C1OC(=O)C(C)CC1C
+CCCCOCc1ccc(O)c(OC)c1
+CCC1(C)C=C2C(=O)C(C)(C)C(=O)C(C)(C)C2(O)OO1
+Nc1nc(=O)c2c(ncn2O)[nH]1
+O=C1CC(Oc2ccc(C(=O)C=Cc3ccc(Cl)cc3)cc2)N1
+C=CC1(C)CC2OC(=O)C(=C)C2CC1C(=C)CO
+C=CCC1=CC(=O)C2C(=O)C1(O)CC(O)C2(C)C
+COc1ccc(C2Cc3cccc(O)c3C(=O)O2)cc1OC
+O=S(=O)(O)c1cc(N=Nc2cccc3ccccc23)c(O)c2ncccc12
+CCCCCC=CC(=O)CCc1ccc(O)c(CO)c1
+CCC=CCC=CCC1OC1C(O)C=CCC=CCCCCCC(=O)O
+OC=c1ncc2ccnn12
+CC1CC2CC(C)C(C)(C#N)C3CCC4C(C1CCC4(C)C#N)C23
+COc1ccc(CN2Cc3ccccc3N3CCCC23)cc1
+CC(C)C1CC(O)C(C)(O)C(O)C1O
+C=C(C)C1C(=C)C(OC(=O)C(C)C)C=CC1OC(C)=O
+CCCCCCCCCC(=O)Nc1cc(Cl)ccc1O
+COc1ccc2nc(O)c(CN(C)C(=O)CC(C)C)cc2c1
+CC1=C(CO)C2(C)CCCC(C)(C)C2C(O)C1O
+Oc1[nH]cc2nccnc12
+COc1cc(OC)c2[nH]c3cc(O)c(C=O)cc3c2c1
+CCCN(CCC)CCCCOc1ccc(/C=C/c2nc3ccccc3s2)cc1
+[O-][NH+](O)c1ccc(O)c(Cl)c1
+C=CCC1OC(=O)C(C)(C2CC(CCc3ccccc3)OC(C)(C)O2)C1O
+Brc1ccc(Oc2ccc(Br)c(Br)c2)c(Br)c1
+CC1(C)OC(S)=Nc2ccc(-c3ccc(F)c(F)c3)cc21
+Cn1c(O)c(C(=O)C=Cc2ccccn2)c(=O)c2ccccc21
+CN(C)Cc1cn(O)c2ccccc12
+O=C(O)C1=C(O)C2=COC(CCCCCCCO)CC2=CC1=O
+COc1c(C)c(O)cc2c1CCC(c1ccccc1)O2
+CC(=O)OC1C2=C(C)C(=O)OC2=CC2(O)C(O)CCC(C)C12C
+C=C1CC23CC(C)(C)CC(O)C2(C)CCC1O3
+O=C(C=Cc1cc2ccccc2o1)c1ccccc1OCc1ccccc1
+CCN(CC)C(=O)Oc1ccc2c(c1)OC(=Cc1ccccc1Br)C2=O
+CN(C)c1ncnc2c1ncn2Cc1cccc(C#N)c1
+N=c1cnn2occcc1-2
+O=C(Nc1ccccc1)Nc1ccc2cnccc2c1
+O=CSCc1ccco1
+COc1ccc(C(=O)CNC(=O)CC2NC(=O)c3ccccc3NC2=O)cc1
+CCNC(=O)OC1COC2C(NC(=S)Nc3ccc(N(C)C)cc3)COC12
+COc1nc(N)nc2[nH]cc(C#N)c12
+CCCC(CCC)C(N)=O
+CC(C)=CC1CC(C)C2=C(O1)C(=O)C(C)=CC2=O
+CCC(C)NC(=O)COc1ccc(OCCNCC(O)COc2ccccc2)cc1
+CCCC1CC2=C(C(OC)O1)C(O)C(O)C(O)C2O
+COc1ccc(-c2c(C)noc2-c2ccc(OC)cc2O)cc1
+CC=CC(OC1OC(C)C(O)C(O)C1O)=C1C(=O)OCC1CO
+CCOC1OCC(CO)C1OCC
+O=C(O)C1OC(OC2C(O)C(O)OC(CO)C2O)C(O)C(O)C1O
+CC(C)=CCC1Oc2cc(C)c(O)cc2C1C
+C=C1C(=O)OC2C1C(O)CC1(C)CCC=C(C)C21
+O=C(CCc1c[nH]c2ccccc12)NCCNC(=O)c1ccc2cc[nH]c2c1
+O=C1C=Cc2cc3ccccc3cc2C1=O
+C=CCn1cc2c3c(cccc31)C(CC(C)C)NC(C(=O)NCC1CC1)C2
+C=C(C)C1CCC(C)=C1CC(C)(C)C=NCc1ccco1
+Cc1coc2c1C(OC(=O)C(C)C)C1(C)C(C)CCC(Cl)C1C2=O
+COc1cc(O)cc(OC)c1C=O
+Cc1cc2c(cc1Br)C1(C)CCC(C)C1(C=O)O2
+N=C(N)Nc1ccc(Cl)cc1
+OCC1=CCCCC1
+CC1=CCCC2(C)OC2CCC(C)=CC(O)C(C(C)(C)O)CC1
+O=C(CC1CC2OC(CNC3CCC3)C(O)C2O1)N1CCOCC1
+CN(C)CCSC1Cc2ccccc2Sc2ccccc21
+O=C(O)C1C2C=CC3(CN(CC4CCCO4)C(=O)C13)O2
+NCCCNCCCCNCCCNCCCN
+CC(C)Cn1ccc2c(NC(=O)c3cccnc3)cccc21
+CCN(CC)CCCOC(=O)C[C@@H](C)CC[C@H]1C(CO)=CC[C@H]2C(C)(C)CCC[C@]12C
+O=c1oc2cc(O)cc(O)c2c2c1CCC2
+CC(C)(O)C1CCC2(C)C(O)CCC(C)(O)C2C1O
+CC(C)CCCCCOc1ccc(C2NC(=O)NC2=O)cc1
+CN(C)C(=O)Oc1cccc([N+](C)(C)C)c1.[Br-]
+O=C(O)c1cc(-c2ccccc2)sc1-n1cccc1
+N#CCCN1N=C(c2ccc(OCc3ccccc3)cc2)OCC1=S
+CCOC(=O)c1c(C)oc2ccc(OC(=O)c3ccc(F)cc3)cc12
+CC1=CCc2c(cc(O)c3c(=O)cc(C)oc23)OC1
+C=CCC1(CC(O)C(C)(C)O)C=C2OCOC2=CC1=O
+COc1cc2c(cc1OC)CN(C(=O)CC#N)CC2
+CCCCCCCCCC(C)(C)C(=O)Nc1c(OC)cc(OC)cc1OC
+Nc1ncnc2c1ncn2C1OC(CF)C(O)C1O
+CC(C)(C)OC(=O)NCC(CO)NC(=O)OCc1ccccc1
+CC(=O)N1CC23C=CC(CC2CC12CCCC2)O3
+C=C(C)c1cc2c(o1)C(=O)c1c(O)cccc1C2=O
+CC12CCC(O)C(C)(C)C1CC(=O)c1c2ccc(O)c1O
+CC(=NNC(N)=O)c1c(O)n(C)c2ccccc2c1=O
+COC1C=C2CC(C)CCC2C(CCC2CC(O)CC(=O)O2)C1C
+CC(=O)Nc1ccccc1O
+COc1ccc(NC(=O)Cc2ccccc2)c(OC)c1
+COc1ccc(-c2coc3c(C)c(OCCN4CCOCC4)ccc3c2=O)cc1
+CC1(C)CC2CC(C)(CN2Cc2c(O)occ(CN3CCCCCC3)c2=O)C1
+CCCCCCCCCCCCc1ccc(C(C)=O)o1
+COc1ccc(C(=O)c2ccc(Cl)cc2)cc1OC
+CCC=CCC=CC(OC(C)=O)C(C=CC=CCC=CCCCC(=O)OC)OC(C)=O
+CCCCCCCCCCCCC(N)=O
+Cc1cc(=O)c2c(=O)oc3ccccc3c2o1
+O=C(CCCn1cccn1)Nc1ccc2c(c1)C(=O)N1CCCC1C(=O)N2
+CCC1CN(S(=O)(=O)c2ccccc2)CCC1CC(=O)O
+O=C(NC1CCCCC1)c1ccccc1
+O=C(CCCCCCCCCCCCC1C=CCC1)OCC(O)CO
+CC1CN(CCCc2ccc(COc3ccccc3)cc2)CCO1
+CC(C)C1=CC2C(C)(OC(=O)C=Cc3ccccc3)CCC(O)C2(C)CC1
+O=C(O)CC1CCN(C(=O)C2CCCC2)CC1CCN1CCN(c2ccccn2)CC1
+CC=C1CN2CCC34C(=C(C=O)C1CC23)Nc1c(O)cccc14
+CC(=NNS(=O)(=O)c1ccc(C)cc1)c1ccccc1
+O=C(O)c1ccc(CC2CCC2)nc1O
+COC1CC(=O)C2C34CCC5CCCCC5C3(C)C(C)(CC4)C12O
+O=c1c2ccccc2oc2ccc(OCCOC3CCCCO3)cc12
+C#CC#CCCCCCCCC=C1C(=O)OC(C)C1O
+COc1ccc(C(=O)C=Cc2ccc(OC)cc2OC)cc1
+N#Cc1cc(N)ccc1F
+CCCCCCCCCCCC1=C(O)C(=O)C=C(NCCc2ccccc2)C1=O
+COC(=O)CCCC#CCCCCCCCCCCCCCc1ccco1
+CC1CC23NC4CCN2CCCC32C(CC(=O)C42)C1O
+CC(=O)OCCCCCCCC=CC(=O)O
+Oc1nccc2c1[nH]c1ccccc12
+CCCCCCCCCCCCCCCCCC(=O)NC(COC1OC(CO)C(O)C(O)C1O)C(O)CCCCCCCCCCCCCCC
+CCNC(=O)N1CC2OCC(=O)N(CC3CC3)C2C1
+CCOC(=O)CC(=O)C(=O)OCC
+c1ccc(SCc2ccc(CN3CCOCC3)cc2)cc1
+C=C(C)C1CCC(C)=C1COC(=O)c1ccncc1
+Cc1cc(CNC(=O)C2CCCC(NC3CCOCC3)CN(C)C(=O)C2)no1
+COc1ccc(OCC(O)CNC(C)C)c(/C=C/CO)c1
+CCOC(=O)N=C(C)c1c(O)n(C)c2ccccc2c1=O
+COc1cc(C(N)=O)cc(OC)c1O
+O=C(O)CCC1NC(=O)N(Cc2ccc3c(c2)OCO3)C1=O
+CC1=CC2C(CC=O)C1(C)CCCC2(C)C
+CC1(C)CCCC2(C)C1CCC13CC(CCC12)C1(CO1)C3=O
+COC(=O)C(O)=Cc1ccc(O)c(O)c1
+C#CC(O)C=CCCCCCCCCCCCCCCC=CC(O)C#C
+NC(=O)NN1c2ccccc2CCc2ccccc21
+Cc1cc(C)c(C)c(C)c1
+O=C(Cc1ccon1)c1ccc(O)cc1O
+CC(=CCC(O)C(C)(Cl)CBr)C(O)CBr
+CC(=O)Nc1ccc(CC(=O)NCCNCC(O)c2ccccc2)cc1
+CCCCP(=O)(O)O
+CCc1cc(C(=O)Cn2cnc3ccccc32)c(O)cc1O
+COc1ccc(-c2cc(=O)c3ccc4occc4c3o2)cc1
+CNc1nc2c(c(=O)[nH]c(=O)n2C)n1CCC(C)C
+CCCCCCCCCCCCCOP1(=O)OCC2COC(=O)C2=C(CCCC)O1
+COC(=O)C1c2ccoc2CC2(C)C(C)CCC12C
+COC(=O)Cc1ccc(OCCCOc2cc3c(cc2O)CCO3)cc1
+CCOP(=O)(c1ccccc1)c1ccccc1O
+COc1cc(C=CCO)cc(O)c1O
+CC12CCC(C(CO)C1)C2(C)C
+COc1cc2c3c(c1OC)C(=O)NC3Cc1ccccc1-2
+COc1c(O)c(OC)c2occ(-c3ccc(O)cc3)c(=O)c2c1O
+CC(C)c1ccc(C2c3ccccc3C(=O)c3ccccc32)cc1
+Cc1c(C)c2ccc(OC(=O)CCCNC(=O)OC(C)(C)C)cc2oc1=O
+C[C@@H]1CC2C(CCC3(C)C(=O)CCC23)C2(C)C=CC(=O)C=C12
+OCC1OC(OCCc2c[nH]c3ccccc23)C(O)C(O)C1O
+COc1ccc2c(ccn2CCC(=O)N2CCc3[nH]c4ccc(Cl)cc4c3C2)c1
+COc1cc(C(C)=CC(=O)O)oc(=O)c1C
+CN(CCC1CN(C(=O)Nc2ccccc2)CCC1CC(=O)O)c1ccccc1
+O=C(O)C1=CC(OP(=O)(O)O)C(O)C(O)C1
+CC(C=CC=C(C)C=CC1(O)C(C)(C)CCCC1(C)O)=CC=CC=C(C)C(=O)O
+CC(=O)c1ccc(NC(=O)NC2COC3C(OC(=O)Nc4ccccc4)COC23)cc1
+C#CC#CC=C=CC=CC=CCC(=O)O
+NC(N)=NCCCC(N)[PH](=O)O
+CC(C)CCCCCCCCCCCCOC(=O)CC(C)C
+C=C(C(=O)OC)C(O)CO
+CC(CCC(=O)O)C1CCC2C3CCC4CC(O)CCC4(C)C3C=CC12C
+Cc1cc(CCCCCOc2c(Cl)cc(C3=NCCO3)cc2Cl)on1
+COc1cccc(-c2cc(=O)c3cc(OC)ccc3o2)c1
+Oc1ccc2c(c1)Cc1ccccc1-2
+CC1=CC(C)C2COC3(CCCC3)C1C2C
+COc1c(O)cc2ccc(=O)oc2c1OC
+Clc1cc2c(cc1Cl)Oc1cc(Cl)c(Cl)cc1O2
+CC(NC1=NC(C)(C)Cc2ccccc21)C(=O)O
+CCCCCCCCCNS(=O)(=O)O
+C=C1CCCC(C)CCC2=C(C)C3C1CCC3(C)C(O)C2O
+CC(C)C=Cc1c(O)cc(-c2cc3ccc(O)cc3o2)cc1O
+CCCCCCCCCCCCCC=CC(O)C(COC1OC(CO)C(O)C(O)C1O)NC(=O)CCCCCCCCCCCCCCCCCCCCCCC
+Oc1ccc2c(c1)CCNC2c1ccc(F)cc1
+O=C(CCl)Nc1ccccc1C(F)(F)F
+COC(=O)C(C)C1CCC(C)(CCC(=O)C(C)(C)CCCC(C)=O)OO1
+CC(CC(=O)O)c1ccc(C(=O)O)cc1
+Cc1ccc2c(c1)C1CN(C)CCC1N2S(=O)(=O)c1cccnc1
+CCC(O)C=CC=CCCc1cc(=O)c2ccccc2[nH]1
+CCCCCCCCCCCCCCCCC=CCCC=CCCCCC1OCC(N)C1O
+N=c1occ2cc[nH]nc1-2
+CCC(=O)C(C)C(C)=O
+CCCCC(=O)OCCCC(C)C
+COC(=O)C=C(C(C)=O)C1CCC(C)(Cl)C(Br)C1
+COc1cc(C=Cc2cc(OC)c3c(c2)OC(C)(C)C=C3)ccc1O
+CC(C)=CCCc1cc2c(c(O)c1O)C(=O)c1ccccc1C2=O
+CC(C)NCC(O)COc1ccc2[nH]cc(CCN)c2c1
+COC1C=CC(CO)(OC)O1
+CC1(Cl)CCCCC1O
+CC(C)C1CC(O)C2(C)C3CC(O)C2(C)C(=O)C13
+O=C1OC2C(CO)OC(O)C(O)C2(O)C1=Cc1ccc(O)cc1
+CSC1OC(Cn2cnc3c(=O)[nH]cnc32)C(O)C1O
+COC1C(C)OC(Oc2cccc3c2NC(=O)CC3)C(O)C1O
+CC(C)C12CCC(C)(O)C3CCC(C)(O)C3C1O2
+Cc1cccc(O)c1C(=O)OC1C(=O)C(CO)=CC(O)C1O
+Cc1cc2c(cc1O)[nH]c1c3c(ccc12)OC(C)(C)C=C3
+O=[N+]([O-])c1nccn1C1SC(CO)C(O)C(O)C1O
+CC1C(=O)c2c(O)cc(O)cc2OC1c1ccc(O)c(O)c1
+Cc1ccc(NC(=O)NCCCCNC(=O)N(O)c2ccccc2)cc1
+CC1=CC(=O)C(O)C(C)(C)C1CCC(C)O
+CCN(CC)c1ccccc1
+O=C1C2CCCCN2C(=O)N1CCCN1CCN(c2ccc(F)cc2)CC1
+CC1(C)CC23CC(=O)CC2C1CCC3C(=O)O
+CN1C(=O)CNC(=O)c2c1ncn2C
+O=C1CCc2cccc3c2N1CC3
+COc1ccc(C(=N)S)cc1
+COc1cc2ccc(=O)oc2c(OC)c1OC
+CC1C(=O)OC(CCc2ccccc2)CC1O
+COc1ccc2c(c1OC)C(=O)c1ccccc1C2=O
+CCc1ccc(C2CC3CCC(C2C(C)=O)N3C)cc1
+COc1cccc2c3c([nH]c12)C(=O)NC(=O)C3=O
+CC(=O)C1(O)CCC2C3CCC4=CC(=O)CCC4(C)C3CCC21C
+CN1CCC(N2CCC(c3nnc(C(C)(C)C)o3)C2)CC1
+Cc1oc2cc(O)ccc2c(=O)c1-c1nc2ccccc2n1C
+O=C(O)CCCCCO
+CC1CN(c2ccncc2)Cc2ccccc21
+CCC1Cc2cc(OC)c(O)cc2C(c2ccc(O)c(OC)c2)C1CC
+COc1ccc2[nH]c3c(c2c1)CN(C(=O)C=Cc1cccs1)CC3
+COc1c(O)cc(-c2ccccc2)cc1CC=C(C)C
+CC(=O)c1ccc2c(c1)C=CC(C)(CO)O2
+CCCCC=CCC=O
+COc1ccccc1-c1coc2c(CN(C)C)c(O)ccc2c1=O
+CC1(C)CCc2cc(CC(=O)NCC3CCCN4CCCCC34)ccc2O1
+CCC=CC=CCCC=CCCCCCCCC(=O)O
+CCN(CC)c1ccc2c(C)cc(=O)oc2c1
+O=C1OC(O)C(Cc2ccccc2)=C1c1ccccc1
+O=c1oc2ccc(O)c3c(=O)oc4c(O)ccc1c4c23
+CCCCCCCC/C=C\CCCCCCCCOC(=O)N1CCOC(CCCCCCCCCCCC)C1
+CC1=CC23CCC1C(C)(C)C2CCC3C
+CCCCCCCCCCCCCCCCCCCCCCCCC(=O)CCCCC
+CC1OCC(=O)C(O)C1=O
+CC(=O)Nc1cccc2c1ccn2CC(=O)NCC(C)C
+CCCCC=CC=CC#CC#CC=CCO
+CC12CCCC3C1C(C)(CCC2)N(C=O)C3(C)CO
+CC=CC1OC2C(C)OC(=O)C2C(O)C1O
+Cc1nn(C)c2nc(C(C)C)cc(C(=O)NCC3CCCN4CCCCC34)c12
+COc1cc(OC)c(C(C)=O)c2c1C=CC(C)(C)O2
+C(=NNc1ccccc1)c1ccc[nH]1
+CC(O)C(C)(O)C(C)O
+CC1=C2CC3(C)C(=CC2OC1=O)C(O)CCC3C
+CC(C)C(C)CCC(C)C1CCC2C3CCC4CCCCC4(C)C3CCC12C
+C=CC1CC(C)(C)C(O)C1=C(CO)C1COC(=O)C1
+CCC(C)CNC(N)=S
+COc1ccc2c(ccn2CCC(=O)NC(CC(C)C)C(=O)O)c1
+CCc1ccccc1NCN1C(=O)c2ccccc2C1=O
+c1cncc(O[C@H]2CCNC2)c1
+CC1=C(C=O)NC(=C2C=CC=CC2=O)S1
+CN1C(=O)c2cccnc2OC2CN(Cc3ccccc3)CC21
+CC(C(=O)O)c1cccc(Oc2ccccc2)c1
+CC(=O)NC1C(O)OC(C)C(O)C1O
+O=C(O)C1CSC(c2nc3ccc(O)cc3s2)=N1
+CC(C)=CC1C(C(=O)NCc2ccccn2)C1(C)C
+CC1=CCC(C)(CCC(=O)C(C)C)C=CCC(C)=C(C)C(=O)C1
+CC(C)=CC1OC(=O)C(=CCC(O)C(C)=CCCC(C)=CCO)C1O
+OCC=CC#CC#CC(O)C=CCCCCO
+CC1(C)C2CCC(C(=O)O)C1C2
+C1=C(c2ccccc2)CCN(CCCCc2c[nH]c3ccccc23)C1
+SC1=NCCCN1
+Cc1cccc2c1C(=O)NC2=O
+CC1=CC(CO)C(C)(C)C12CCCC2(C)C
+COC(=O)c1ccc(OC(=O)c2ccccc2Cl)cc1
+COC(=O)C(=CCCC(=CCCc1ccoc1)C(=O)OC)CCC=C(C)C
+CCCCCCCC(O)CCCC1Cc2cc(O)cc(O)c2CO1
+COc1cc(C)c(Br)c(C)c1
+CC1CCC(C(C)C)C2CC(C)(N)CC=C12
+CC(C)NC(=O)NC1C2COC(O2)C(n2cccn2)C1O
+COCC1CCCN1CC1CN2CCC1CC2CNC(=O)Nc1ccccc1
+OC12CC3CC(CC(C3)C1)C2
+CC(=O)c1cc2c(CO)cc(O)cc2oc1=O
+CCN(CC)CCOC(=O)C(O)(c1ccccc1)c1ccccc1
+NC1CCCN(P(N)(=O)NS(=O)(=O)O)C1=O
+N=Cc1coc2cncn12
+C=C1CCC2C(C)(C)CCC(OC(C)=O)C2(C)C1COC(C)=O
+CCCCCCCC=CCC=CCC1OC1CC
+CCNC(=O)c1ccc(COC(COCc2ccc(OC)cc2)Cn2ccnc2)cc1
+CCCCCCCCC=CCCCCCCCCCCCC(=O)OC(CO)COC(=O)CCCCCCCCCCCCCCCCCCCCC
+CN1CCN(C(c2ccccc2)c2ccccc2)CC1
+NC(=O)c1ccccc1[NH+]([O-])O
+CC(C)=CCCC(C)=CCCC1(C)C=Cc2cc(O)ccc2O1
+Nc1ncnc2c1ncn2C1OC(CSCC(N)C(=O)O)C(O)C1O
+Cc1nccc2nonc12
+S=C=NC=CCCCCCCCCCCCCCCCC=CN=C=S
+O=C(O)C=CC=CCCCCC(=O)O
+CCOC(O)=Nc1c([NH+]([O-])O)cc(Cl)cc1[NH+]([O-])O
+CCC(O)c1cccc(O)c1CN
+CC1=C2C(=CC1)C(C)(O)CCC1C(C)C(=O)OC21
+COc1c(O)c(O)cc2c1-c1ccc(OC)c(=O)cc1C(NC(C)=O)CC2
+C=CCCCCCCCCCCC(O)CC(O)CCOC(C)=O
+C=C(C)CC1CCC(C)C1
+CCCCCCCCCCCCOc1ccc(N2C(N)=NC(N)=NC2(C)C)cc1
+C=CC(=C)CCC1C(=C)CCC2C(C)(COC(=O)C=Cc3ccc(O)cc3)CCCC12C
+NC(CC(O)(Cc1c[nH]c2ccccc12)C(=O)O)C(=O)O
+C=CCn1ncc2c(C)nc(Cc3ccccc3)n2c1=O
+CCOCCn1c(N2CCN(CC)CC2)nc2ccccc21
+COC(=O)c1cccc2nc(C3CCN(C4CCCCC4)C3)oc12
+O=C(C=Cc1ccccc1Cl)c1ccc(OC(=O)c2ccccc2Cl)cc1
+NNc1ccc([NH+]([O-])O)cn1
+COC(=O)c1ccccc1N(C)C
+O=C1C=CC2CCCN12
+CC1(C)C=Cc2cc(OC3OC(CO)C(O)C3O)ccc2O1
+CCCCCC(C)CCCC(C)CCCC(C)=CCOP(=O)(O)O
+Cc1ccc(-c2cc(=O)c3cc(NC(=O)c4ccccc4Br)ccc3o2)cc1
+CCOC(=O)Cc1nc(-c2ccc(N=C=S)cc2)no1
+C=CC(C)=CC=CC(C)=CC=C1C(C)=CCCC1(C)C
+CCCCCCCCC(O)C(C)C(=O)O
+Cn1nc(C(C)(C)C)cc1C(=O)NCC1CCCN2CCCCC12
+CN(C)CCOc1ccc2c(c1)CCCC(c1ccccc1)=C2c1ccc(O)cc1
+COc1ccc2c(c1OC)C(=O)OC2CC(=O)Nc1ccc(O)c(C(=O)O)c1
+COC(=O)CCC(=O)CC=CCc1ccccc1
+C=C(CCC=C(C)CO)C1CCC(C)(O)C1C
+CCCCCCCC=CC#CC#CCCCC(=O)OC(C)C(=O)O
+C=C(C)C1CCC(C)(O)C2CCC(C)(O)C2C1
+CC(=O)NCCC(F)CNC(=O)CCC(=O)N(O)CCC(F)CNC(=O)CCC(=O)N(O)CCC(F)CNC(C)=O
+CC1(CO)CC2C=C(C(=O)O)C3CCC3(C)C2C1
+N#CCCn1nc(-c2ccc(OCc3ccccc3)cc2)oc1=S
+CCC(C)CCCCCCCCCCC(=O)OC
+CC1=C2CC(C)(CO)CC2CC2(C)CCC12O
+c1ccc(CCc2nn3c(-c4ccco4)nnc3s2)cc1
+C=CC1(C)C=C2CCC3C(C)(C)CCCC3(C)C2CC1
+OC1CCCc2nc3ccccc3c(NCc3cccs3)c21
+Cn1nc(CC(=O)NCC2CCCN3CCCCC23)c2ccccc2c1=O
+CC1NC2(CCCCC2)CC(C)(C)c2ccccc21
+CC(C)=CCc1ccc(O)c(CO)c1-c1ccc(C)o1
+CC=CC=CC(O)=C1C(=O)C2(C)C(=O)C(C)(O)C1N1CCCC12
+CC1CCC2(C)CC(O)C3(C)CCC4C3=C2C1CCC4C
+COc1ccccc1C=CC(=O)Nc1cccc2ncccc12
+COc1ccc(CN2CC3CN(C(=O)C(C)(C)C)CCN3C(C)(C)C2)cc1
+CCC(C)C(=O)OCC1OC(Oc2ccc(C(=O)O)cc2)C(O)C(O)C1O
+O=c1c(-c2ccccc2)nccn1C(CN1CCCC1)c1ccccc1
+CC1NC(CCCCCCCCCCCC(=O)O)CCC1O
+COc1cc2c(cc1OC)CCN(C)C(C(=O)c1ccccc1)=C2
+CCCC=CCOC(=O)CCC
+C=C1CCCC1(C)C1(C)CC=C(CO)CC1
+NC(CS(=O)Cc1ccccc1)C(=O)O
+O=C(O)C1=CN(CCOC(=O)c2cc(Br)c[nH]2)CC=C1
+Oc1ccc2c(c1)C[C@@H]1c3ccc(O)cc3CC[C@H]21
+CC(CCCCCCCCCCCCCCCCCCCCC(=O)C(C)C(=O)NCCO)OC1OC(C)C(O)CC1O
+C=C(C)CC=Cc1ccoc1
+COCC(=O)NC1C(c2ccccc2)N(Cc2nccs2)CCC1(C)O
+CC(=O)N1CCN(CC2OCC(NC(=O)NC3CCC3)C2O)CC1
+CCC(C)C(NC1=NC(C)(C)Cc2ccccc21)C(=O)O
+O=C(Nc1nccs1)C1CN2CCC1CC2Cn1cc(CO)nn1
+CCCCCCCCCCCCCCCCCCCC=O
+CC=CCCCCCCCCCCc1oc(=O)cc2c1C(=O)OC(C)C2
+CC(C)C(=O)NCCNCC(O)COc1ccccc1
+O=C(NC1CCC(C(=O)O)CC1)OCc1ccccc1
+CSCSc1nc(O)c(C)c(Cc2ccccc2)n1
+CCOC(=O)CC(CCc1ccc(O)cc1)OC(C)=O
+CC(=O)NC(C)C(=O)CCC(=O)O
+Cc1cc(O)cc2c1OC(C)(CCCC(C)CCCC(C)CCCC(C)C)CC2
+CC(C)N1CCC(c2nnc(-c3cncn3C)o2)C1
+c1coc(-c2nnc(C3CCN(Cc4ncc[nH]4)C3)o2)c1
+CCCCc1cc(OC)c(CC(C)N)cc1OC
+C=CC1C(OC2OC(CO)C(O)C(O)C2O)OC=C2C(=O)OCCC21
+CNCCc1nc(-c2cn(C)c3ccccc23)no1
+Cc1ncc(-c2ccccc2F)cn1
+CC(=O)NCC1OC(CC(=O)NCc2ccc(F)cc2)C(O)C1O
+CC(C)=CCCC(C)=CCc1cc(C(=O)O)ccc1O
+CC(=O)N(O)CCCCCNC(=O)C(O)(CC(=O)O)CC(=O)NCCCN(O)C(C)=O
+C=C(C)C1=CC2=C(C=CC2=C)C(C)=CC1
+CCS(=O)(=O)CCN1CC2CC(C1)c1cccc(=O)n1C2
+COc1ccc(-c2noc(C(C)NC(=O)c3ccccn3)c2C(=O)O)cc1
+CCCCCCCCCCCCCCCC(O)CC(O)CO
+O=C(C=Cc1ccc(O)cc1)Oc1ccc(O)cc1
+O=C(CNCCc1cc2ccccc2[nH]1)Nc1c2c(nc3ccccc13)CCC2
+CSCC(=O)NC1CCN2C(=O)c3cc(-c4ccsc4)ccc3NC(=O)C12
+CC1(C)c2cc(O)c(O)cc2CCN1C(CO)CO
+COc1ccc(C(=O)CN2CCc3cc(OC)c(OC)cc3C2)cc1
+Cc1ccc(S(=O)(=O)OCC2C3CCC(C3)C2(C)C)cc1
+COc1ccc(C2C3CCCCC3(O)CCN2C(=O)C=Cc2ccccc2)c(OC)c1
+C=Cc1nccc2c1[nH]c1c(OC)cccc12
+CC(C)=CCCC(C)=CCCC(=CCc1cc(O)ccc1O)C(=O)O
+Cc1c(C)c2ccc(OC(C)C(=O)NCC(=O)O)cc2oc1=O
+CC1(C)CCCC2(C)C1CCC1CC3CC12CCC3(O)CO
+C=C1C=CC(OC)C(C)CC(=O)c2c(C)coc2C1
+CC1(CN)c2ccccc2Cc2ccccc21
+CCC=C1CC2C(O)Nc3cc(O)c(OC)cc3C(=O)N2C1
+COc1c2occc2c(OC)c2c(=O)ccoc12
+CC1CC2=C(CC1C1OCC(CN3CCCCC3)O1)C(C)(C)CCC2
+Cc1cc(=O)oc2cc(OCC(=O)NCCCO)ccc12
+CC=C(C)CSC
+Nc1ncc(Cc2ccc3c(c2)CCCN3)c(N)n1
+CC12CC3OCCC3(CCO1)O2
+CCCCCCCOc1ccc(C(=O)O)cc1CC(=O)C(F)(F)F
+COc1cccc(Sc2ccc(NC3=NCCN3)cc2)c1
+O=P(O)(O)c1ccccc1OCCOc1ccccc1P(=O)(O)O
+CCOC(=O)CCN1CCN(c2ccccn2)CC1
+CC(=O)OCC(O)C(O)C1OC(O)(C(=O)O)CC(O)C1N
+[O-][NH+](O)c1ccc(N=Cc2ccccc2O)cc1
+O=c1cc(-c2cc3ccccc3o2)c2cc3c(cc2o1)CCCC3
+COC12C3=CC(O)CC1c1cc4c(cc1C[NH+]2CC3)OCO4
+O=C(CCc1ccc(O)cc1)n1cccc1
+CN(C)Cc1c(O)ccc2cc(-c3ccc(Cl)cc3)c(=O)oc12
+O=c1occ(CN2CCc3ccccc3C2)c(O)c1CN1CCOCC1
+CC1CC2C3=CCCN4CCCC(C(=O)C2O)C34C1
+C=CC1(C)CC(O)C2(C)C(C1)C(=O)CC1C3(C)CCCC12OC3=O
+Cc1ccc2c(c1)c1c3n2CCN=C3CCC1
+Cc1cc(O)cc2c1C(=O)C=C(O)C2=O
+OCC1NC(O)C(O)C(O)C1O
+CCCCOC(=O)CCC1OC(=O)C(O)=C1c1ccccc1
+COc1cc2oc(=O)ccc2cc1C(O)C(O)C(C)(C)O
+NC(CCCCNCC(=O)c1ccco1)C(=O)O
+Brc1cccc2cc(C=NNc3ccccc3)ccc12
+O=C(O)C1Cc2c([nH]c3ccccc23)C(c2cccc(O)c2)N1
+OCC=CC#CC#CCCO
+CCC(C)=CC=CC1CC2OC(C=C=CBr)CC2O1
+Nc1nc(N)c2ccn(COCCO)c2n1
+COc1ccc(C=O)cc1CN1CCCCC1c1cccnc1
+Cc1ccc(C(=O)c2ccc(Cl)cc2)c(O)c1
+CC(C)C(N)C(=O)NC(C(=O)O)C(C)O
+O=C(CCCCC1CCSS1)Nc1ccc(N2CCCS2(=O)=O)cc1
+CC1(C)CC(=O)CC(C)(C)N1Cc1ccccc1
+CCC(C)C(=O)OCC(C)(OC)c1ccc(C)cc1O
+CC(C)=C1C=CC(C)C2CCC(C)C2C1
+CC(C)(C)c1cc(-c2nnc(O)s2)cc(C(C)(C)C)c1O
+COc1ccc(N=O)c(C=CN(C)C)n1
+O=C(O)CCC(NC(=O)c1cncc(O)c1)C(=O)O
+CCOC(=O)C1C(=O)C=C(C=Cc2ccco2)CC1c1ccccc1
+COC(=O)C1C2C=CC3(CN(Cc4ccco4)C(=O)C13)O2
+CNC(=N)NC(CCCC(=O)CC(=O)CCc1ccc(O)c2c1CCCO2)CCn1ccnc1
+Clc1ccc(-c2cc(Cl)c(Cl)c(Cl)c2)cc1Cl
+C=CC1CC=C(CC)C(C(=O)OC)C2CC(=O)C=CCC12
+CCN1CCC[C@@H](c2cccc(O)c2)C1
+COCCN(CC1CCCN2CCCCC12)C(=O)c1ccccc1-n1nnnc1C
+Cc1cccc(CN2CCN3C(=O)NCC3C2)n1
+CC12CCC3c4ccc(O)cc4CCC3C1CCC2=O
+O=c1c(-c2ccccc2)coc2c(CN3CCOCC3)c(O)ccc12
+CC(C)(C)CNC1CC(Cc2cc(CN3CCOCC3)on2)C1(C)C
+COc1cc(CC=CC#Cc2ccc(O)cc2)ccc1O
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+CCCCCC1C=CC(CCCCCC(CO)C(=O)O)C(O)C1
+CC(CNc1ccc(C(=O)O)cc1O)C(=O)O
+COc1cc(OC)c2cc(C(=O)O)n(C)c2c1
+CC=CC1C=CC(=O)C(O)C1C(=O)C(C)O
+C=C1C(O)CC2C3(CO3)CC3OC(=O)C(C)C3CC12O
+CCCCCCC(C)CC(C)(C)C
+CC(=O)N=C(N)Nc1nc(C)c2cc(C)ccc2n1
+CCOC(=O)[C@H](Cc1ccc(O)cc1)NC(=O)c1ccccn1
+N#CC(C(=O)O)C1C(=O)Nc2ccccc21
+CC(=O)C=Cc1ccc(O)c(O)c1
+N#Cc1ccccc1NC(=O)Nc1ccccc1O
+CCCCCCC=CC#CCCCCCCC1CC(CO)OC1=O
+CC(O)CCCC(O)C=CC1C(O)CC(=O)C1CC=CCCCC(=O)O
+Cn1c(O)c(C(=O)O)c(=O)c2ccccc21
+COc1c2c(cc3c1C(CC(=O)C=CC1=C(C)CCCC1(C)C)N(C)CC3)OCO2
+Cn1ccc2c(NC(=O)CC3NC(=O)N(CCc4ccccc4)C3=O)cccc21
+CC(O)c1c(-c2ccc(Cl)cc2)noc1C(=O)N1CCCC1
+C=C1CCC2COC(C3CCC=C(C)C3)C1C2
+CC(=O)C1CC(=O)C(C)C(Cc2ccccc2)C1
+O=C(Nc1ccc2c(c1)OCCO2)NC(Cc1c[nH]c2ccccc12)C(=O)O
+C=CC1(C)C=C2C(O)C3OC(=O)C4(CCCC(C)(C)C34)C2(O)CC1O
+CCCCSSCC
+NC(=O)[C@H]1CCCN1C(=O)[C@H](CCC(=O)O)NC(=O)[C@H]1CCC(=O)N1
+C=CCCCCC=CC=CC#CC=CC(=O)C=C
+CCCCCCCCCCCCCCCCCCCC(=O)CCCCCCCCCC(=O)O
+CC(=O)OC1CC(C)=C2C(C=C(C)C(=O)O)CCC(C)C21
+OC1C(NCc2ccncc2)C2COC(O2)C1N1CCOCC1
+CC(C)=CC(=O)C(C)c1ccc(C)c(O)c1
+CCCCCCN(CCCCCC)C(=O)NC(=O)C(F)(F)F
+COc1cc(N)c(Cl)cc1NC(=O)C1CCN(CC2CCC2)CC1
+CC1c2ccoc2CC2C1CCC1C(C)(C(=O)O)CCCC21C
+CCc1cnc(C)s1
+O=C1CN=C(c2ccccc2Cl)c2cc([NH+]([O-])O)ccc2N1
+CC(=O)N1CC2COCCN2C2(CN(CC(C)C)C2)C1
+CCCCCC1CCCC1
+Cc1ccc(C(=O)c2ccc3n2CCC3C(=O)O)cc1
+CN(C)CCN(C)CCC1CN(C(=O)Cc2cccs2)CCC1CC(=O)O
+Cc1ccc(O)c(C(O)Cc2ccccc2)c1
+COc1ccc(C(Cc2ccc(N)cc2)n2ccnc2)cc1
+O=C1CCc2ccc(O)c(OC3OC(CO)C(O)C(O)C3O)c2O1
+O=S(=O)([O-])Nc1ccc(-c2nc3ccccc3s2)cc1I.[Na+]
+NC(Cc1cnc[nH]1)C(=O)NC(CO)C(=O)O
+Cc1c(O)cc(O)c2c1C(C)(O)C(C)OC2=O
+CC1C(=O)OC2C1CCC(C)(O)C2O
+O=C1NC(Cc2c[nH]c3ccccc23)C(=O)N1CCc1ccccc1
+CCC=CC=CC=CC=O
+O=c1cc(-c2ccccc2)c2ccc(O)c(CN3CCCCC3)c2o1
+O=C(CCNC(=O)N1CCc2c([nH]c3ccccc23)C1)NC1CC1
+CCC(C)C1SCSS1
+Cc1cccc(Nc2c3ccccc3nc3ccccc23)c1
+CC1CC(O)C2C(C=O)=COC(OC3OC(CO)C(O)C(O)C3O)C12
+C[C@@H](NC(=O)c1ccccc1)C(=O)O
+CCCCOC(=O)CC(O)(CC(=O)OCCCC)C(=O)OCCCC
+O=C(O)C(=O)/C=C(\O)c1cccc(Br)c1
+COc1cc2c(cc1OC)CN(C(=O)NCCC(=O)O)CC2
+S=C=Nc1ccc(-c2noc(C3CCCCC3)n2)cc1
+CC(=O)NC[C@H]1CN(c2ccn(-c3ccc(F)cc3)c2)C(=O)O1
+CCCCCCCCCCCCC(O)C(O)CCC=CCCC=CCCC(O)CCCCCC(O)CC1=CC(C)OC1=O
+CCCCC1C(=O)C(C)=C(C)C1(O)CCCCCCC(=O)OC
+CC(=O)OC1CC(C)=CCCC(C)=CC2OC(=O)C(O)(CO)C21
+O=c1oc2cc(O)ccc2c2c(O)cc(O)cc12
+C=C(OC1C=CC(C(=O)CCC(=O)O)C(C(=O)O)C1O)C(=O)O
+CCc1cc(O)c(O)c(-c2cc(O)c(O)cc2CC)c1
+C=C1CC2C=CC3(CC(C)CC13)C1C2C1(C)C(N)C=O
+CCCC1NCCc2c1[nH]c1ccc(O)cc21
+COc1cc(C=CC=O)cc(CC2OC2(C)C)c1O
+CC1=CCC2C(C1)CN1CCc3c([nH]c4ccccc34)C21
+N=Cc1c[nH]c2ocnc12
+Oc1c(Cl)cc(I)cc1Cl
+CCCCCC=CCC(O)C(O)C=CC1CC1C1CCCC(=O)O1
+CCCCCCC=CCCC=CCCCCCCCCCCCCC=CCCC=CCCCC(=O)O
+CCCN(C)C(=O)c1c(-c2ccc(F)cc2)noc1C(C)O
+COC(=O)CCCCCCCCC(C)=O
+CC(CCC(=O)NC(CC(=O)O)C(=O)O)C1CCC2C3CCC4CC(O)CCC4(C)C3CC(O)C12C
+COc1ccc(-c2nnc(C3CCN(Cc4ccccc4)C3)o2)cc1
+CCCCCCCCC=CCCCC1CCCC(C)N1
+COC(=O)CN1C(=O)N2CCc3c([nH]c4ccccc34)C2(C)C1=O
+CCCC1C(c2ccc(F)cc2)CC2C[C@@H](F)C1N2C
+CC12CCC3c4ccc(O)cc4CCC3C1CC(=NO)C2=O
+C1CCCC(C2CCCCCC2)CC1
+CCCCCCCCCCCCCCCCCCCCCC(O)CCO
+COC(=O)C(Cc1cccc(I)c1)NC(=O)OC(C)(C)C
+N/C(=N/CCCC(N)[PH](=O)O)N[N+](=O)[O-]
+O=C(NCC1(COc2cccnc2)CC(O)C(O)C1)c1cnccn1
+CC1=CC2OC3CC(OC(=O)C=CC=CC(O)C(C)O)C(C)(C2(C)CC1)C31CO1
+CCCCC1(CCCC)C(=O)N=C(Nc2cccc(OC)c2)N=C1O
+CCCCCC1SSC(C)S1
+COc1ccc2[nH]c3c(c2c1)CN(C(=O)C1CCCO1)CC3
+COc1ccc(C=CCOC2OC(CO)C(O)C(O)C2O)c(OC)c1OC
+O=C(O)c1cccc(C(=O)CO[NH+]([O-])O)c1
+O=S1(=O)CCC(Br)C1
+Cc1ccc(NC(=O)c2oc3ccccc3c2C)cc1
+C#CC=CCCCCCCCCCCCCCC=CCCCCC=CCCCCC#CC(O)C#CCCCCCCC=CC(O)C#C
+CCOC(=O)Cc1cc(O)cc(O)c1C(=O)CCCCCC(C)=O
+COC1(C)Oc2cc(O)cc3cc(C)nc(c23)C1=O
+OC1CN=C2C=CC=CN2C1
+CC1CCC2C3CCC4CC(O)CCC4(C)C3CCC2(C)C1OS(=O)(=O)O
+CCCCCCC=CCCCC=CCCC(=O)O
+CC1=C(CCC2=CC=CC(O)=COC2)C2(C)CCCC(C)(C)C2CC1
+Cc1cc(C)c(CC(O)c2cc3ccccc3o2)c(C)c1
+CCCn1cnc2c1c(=O)n(CCCCC(C)=O)c(=O)n2C
+C=C(C)c1ccc(O)c(OC)c1
+CCCCCCC=CCC=CCCCCCCCCC(=O)O
+Cn1c(NC(=O)C(F)(F)F)cc(=O)n(C)c1=O
+CCCCCCCCSCC(O)CN1CC2CC(C1)c1cccc(=O)n1C2
+COc1cc(O)c2c(c1C)C(C)(O)C(CO)OC2=O
+CC1(C)CCCC2(C)C1C(OC(=O)C=CC(=O)O)C=C1COC(=O)C12O
+NC(Cc1ccc(O)c(Br)c1)C(=O)O
+O=C(COC(=O)c1ccccc1)c1ccccc1
+CC(Cc1ccc(O)c(O)c1)C(C)Cc1ccc(O)c(O)c1
+CC12CCC3c4ccc(OC#N)cc4CCC3C1CCC2=O
+CC1(C)CC2C1CC1OC1(C)C(=O)CCC2(O)CCl
+CCCCCCCCCCCCCCCCCCCC1Oc2c(C)c(C)c(O)c(C)c2S1
+CCCCCCCCC=CCCCc1cc(=O)c2ccccc2n1C
+CNC1CCC23CC24CCC2(C)C(C(C)NC(C)=O)CCC2(C)C4CCC3C1
+O=C(Nc1ccccc1C(=O)NC(Cc1ccc(O)cc1)C(=O)O)c1ccccc1
+OCC1OC(c2ccc(O)cc2)C=C1c1ccc(O)cc1
+Fc1ccc(-c2cc(NCCCCN3CCCC3)c3ccccc3n2)cc1
+CCOC(=O)C(NCC(O)COc1ccc(CCC(=O)OC)cc1)C(=O)OCC
+CCOC(=O)C1C2C=CC3(CN(CC4CCCO4)C(=O)C13)O2
+COc1ccc(C=C(C#N)C(=O)OC(C)C)c(OC)c1OC
+NC(CCCNO)C(=O)O
+COc1ccc(C=CCc2ccc(O)c(OC)c2)c(O)c1
+O=C1OCC(Cc2ccc3c(c2)OCO3)C1=Cc1cccc2c1OCO2
+CC(CCCC(=O)O)c1ccccc1
+CC1(C)CCCC2(C)C3CCC4(C)C(CC=C5COC(O)C54)C3=CCC12
+CCC(C)C(=O)OCC1CC(=O)OC(C)C1C
+CC(=O)OCCN(CCOC(C)=O)CC(c1ccccc1)c1ccccc1
+CCOC(=O)COc1ccc2c(c1)OC(=Cc1cccc(F)c1)C2=O
+S=C=NCCCCc1ccccc1
+COC(=O)CC(=O)OCC1=CCCC2C1(C)CC(O)C(C)C2(C)CCC1COC(OC)C1
+COc1cc(O)cc2oc(C)c(C)c(=O)c12
+COC(=O)C(NC(=O)c1ccccn1)C(C)O
+COc1cc(OC)cc(-c2cc(=O)c3c(OC)cccc3o2)c1
+NC(=O)CCNC(=O)C1=CC(N)C(O)C(O)C1
+Cc1ccccc1COc1ccc2oc(C)c(C(=O)O)c2c1
+CCCNC(=O)Nc1cccc2c1CN(C)CC2c1ccccc1
+C[C@H](N)Cn1ccc2cc(F)c(F)cc21
+CC(=O)C1C(O)CCC23OC2C(O)CC(C)C13C
+O=c1ccc2cc3c(-c4ccc5c(c4)OCCCO5)coc3cc2o1
+O=C1Cc2cc([NH+]([O-])O)ccc21
+COc1c2occc2cc2c(OCC=C(C)C)cc(=O)oc12
+CNC(=O)C(C1CC1)N1CCCC1C(=O)NC(C)C
+CN(C)C(=O)Oc1ccc2c(c1)OC(=Cc1cccc(Cl)c1)C2=O
+COc1cc(-n2cc(C(C)=O)c3ccccc32)ccc1C(N)=O
+CC1(C)CCc2cc(CC(=O)Nc3ccc4[nH]ccc4c3)ccc2O1
+CC1(C)CCc2c(c(O)cc3oc4cc(O)cc(O)c4c(=O)c23)O1
+N#Cc1cccc(CN2CC(O)CC2c2nc(C3CC3)no2)c1
+CC1CC=CC2(C)c3occc3CCC12C
+CCCc1cc(O)cc(OC2OC(CO)C(O)C(O)C2O)c1C(=O)O
+CCOc1ccccc1OC(c1ccccc1)C1CNCCO1
+N=Cc1cc2oncn2c1
+O=S1(=O)NC2CN(Cc3ccncc3Cl)CC2Oc2ncccc21
+CC(C)(CC(=O)O)Cc1nc2ccccc2n1Cc1ccc(O)cc1
+O=C(NCc1cccc(F)c1)n1ccnc1
+O=c1cc(-c2ccccc2)oc2cc(O)cc(OC3OCC(O)C(O)C3O)c12
+Cl.NC(N)=NC(=O)c1ccc2c(c1)C(O)c1c(Cl)cccc1-2
+CCC=CC(CC)CC(C)=CC1(CC)CC(C=CC(=O)O)(CC)OO1
+CC1(CO)CN(Cc2ccccc2)CC2CN(C(=O)C3CCCCC3)CCN21
+O=C(CCCc1nc(-c2cccnc2)no1)NCCc1c[nH]c2ccccc12
+CC(=O)OC1CCC2(C)C(CCC3C4CCC(=O)C4(C)CC(O)C32)C1
+COc1cc2oc(-c3ccccc3)cc(N)c-2c(=O)c1OC
+COC(=O)C1Cc2c([nH]c3ccccc23)C(c2ccccc2)N1
+CCC1=CC(O)CCC1=O
+Cc1c(CC(=O)N(C)CCc2ccccn2)c(=O)oc2cc(O)ccc12
+O=C(O)C=CC(=O)Nc1c(Cl)cc(Cl)cc1Cl
+C=Nc1noc2[nH]ccc12
+CC1CCCC=CCCC(=O)CCCC=CC=CC(O)CC=CC=CC(=O)O1
+CC1=CCC2CC1C2(C)C
+CCOC(=O)c1[nH]c2ccc3nc[nH]c3c2c1CCN1C(=O)c2ccccc2C1=O
+O=C(NC1COC2C(O)COC12)c1ccco1
+COc1oc(CCCCCC(C)O)c(C)c(=O)c1C
+COc1c(OC)c(OC)c(C(C)=O)c(OC)c1OC
+CC1OC(=O)Cc2c3c(c(O)c(O)c21)OC(C)(C)CC3
+CC(NC(=O)C1CCCCC1)c1c(-c2ccc(F)cc2)noc1C(=O)O
+CCCCCC=CCCCCCCCCc1cccc(O)c1O
+CC(=O)C1CC2C(C)(N=C=S)CCC(C(C)C)C2(O)C1O
+CCCc1nc(C)c(C)o1
+CC(C)=CCc1c(O)ccc2c1C(=O)C(O)=C(C)C2=O
+CC(=O)CC1CC1C1OC2=C(Br)CC(C=C=CBr)OC21
+CCCCC(=O)c1cc(O)cc(OC)c1
+O=C(COc1ccc(C(Cc2ccccc2)=NO)c(O)c1)OCc1ccccc1
+CC(O)C1NC(=O)CNC1=O
+O=C1CCc2c1c(CCCO)cn(CCO)c2=O
+O=C(Nc1cc(F)cc(F)c1)[C@H]1CCCC[C@H]1C(=O)O
+CCCCCCCCCCCCc1ccccc1C(SCCC(=O)O)[S+]([O-])CCC(=O)O
+CC#CC#CC#CC=CC(=O)CCCCO
+C=C1C(=O)OC2CC(C)C3C(O)CC(O)C3(C)C(OC(=O)C=C(C)C)C12
+CC1c2ccccc2CCN1c1ccncc1
+C=CC(C)(O)CCC1=C(C)C(O)CC(Br)C1(C)C
+C=CC(C)(O)CCC=C(C)C(O)C(=O)C=C(C)C
+COc1ccccc1C(=O)NCC1Cn2cc(-c3ccccc3)nc2CO1
+COc1cc(OC)c(C2COc3cc(O)cc(O)c3C2=O)cc1OC
+CC(=O)C=CC1CCc2c(cc(CC=C(C)C)c(O)c2C=O)O1
+Cc1nccc2onnc12
+O=C1C(O)=C(O)OC1C(O)CO
+CC1C(=O)Nc2cc(O)cc(c2O)C(Cc2ccccc2C(=O)O)CC=CC=CC1O
+O=C(NCc1ccc2c(c1)OCO2)c1c(O)c2cccc3c2n(c1=O)CCC3
+CNC1=CC(=O)C2(C)CCC1C2(C)C
+CC(O)C1(C)NC(=O)c2ccccc2N1
+COCOc1ccccc1[PH](=O)O
+CC1CCC2=C(COC2=O)C2(O)CC(C)(C)CC12
+CCCCCCCCCCCCC(C)CCC(=O)O
+O=C(c1cc(Cl)c(Cl)[nH]1)c1ccccc1O
+CC12COc3cc(CCc4ccccc4)cc(O)c3C1C2
+O=C(O)CC(=O)CBr
+COc1cc2c(c(O)c1O)C(=O)C(=O)C=C2
+Cc1ocnc2cnnc1-2
+CC1CCN(C2C(CNC(=O)N3CCOCC3)OC(CO)C2O)CC1
+O=P(O)(O)c1ccccc1OCCO
+CCC1CCCCN1Cc1c(O)ccc2c(=O)c(-c3nc4ccccc4s3)coc12
+OC1C=CC23c4cc5c(cc4CN(CC2O)C3C1)OCO5
+F[C]1[CH][CH][CH][C](C[NH+]2[CH][CH][CH][CH][CH]2)[CH]1
+CCCCCCCCCCC(C)(C)C(=O)Nc1c(OC)cc(OC)cc1OC
+CC(=O)OCC(C)=CCC(O)C(C)=CCCC(C)=CCO
+COc1ccccc1OCCCN1CCN(C(=O)c2ccc(=O)[nH]n2)CC1
+C=C1CCC2(N=C=S)C(C)CCC3C(C)CC(CC(C)(C)NC=O)C1C32
+CC(C(=O)O)c1ccc(OC2OC(CO)C(O)C(O)C2O)cc1
+Cn1cnc2c1CCNC2
+COc1c(O)cc(C(=O)O)cc1CC=C(C)C
+CC(C)C(N)C(=O)OCCOCn1cnc2c(=O)nc(N)[nH]c21
+C=CC(C)(O)C=CC=C(C)C(O)CC=C(C)C
+COc1ccc(C2=CC=C(N)[NH+](CCCC(=O)O)N2)cc1
+CCCCCc1cc(=O)c2cccc(OC)c2n1C
+O=C(NC(CO)C(O)c1ccc([N+](=O)[O-])cc1)C1CC1
+CCN(CC)CC1OCC(NS(C)(=O)=O)C1O
+Cc1ccc(Cl)c(C)c1
+NS(=O)(=O)c1nnc(NC(=O)CNCC(=O)O)s1
+O=C1Nc2ccc(-c3ccsc3)cc2C(=O)N2CCN(C(=O)C3CCCN3)CC12
+CC(=O)OCCC(C)=C(Cl)C=CC(C)(Cl)CBr
+N=Cc1cc2ncon2c1
+CCC(=O)N(CCC(Cc1ccccc1)c1ccco1)Cc1ccco1
+CC#Cc1ccc(-c2ccc(C(CCl)OC(C)=O)s2)s1
+COC(=O)C(C)C1CCC(C)(CCC=C(C)CCC=C(C)CCC=C(C)C)OO1
+CC(O)C(O)C12C(=O)OC(C=CC1C)C2O
+COC1CCC(=CC#N)C(OC2OC(CO)C(O)C(O)C2O)C1
+Nc1ccc2nc(NCCCN3CCOCC3)oc2c1
+CC#Cc1ccc(C=O)s1
+O=c1cc(-c2cccc(O)c2)oc2c1ccc1ccccc12
+CC1(c2ccncc2)CCC(=O)NC1=O
+O=P(NCc1ccccc1)(c1ccccc1)c1ccccc1
+O=C(NC1CCN2C(=O)c3ccccc3NC(=O)C2C1)c1cccs1
+O=C(O)Cc1cccc2nc3ccccc3nc12
+CC(C)=CCc1c(C=O)cc(O)c2[nH]c3ccccc3c12
+[O-][NH+]1CC=CC=C1SSC1=CC=CC[NH+]1[O-]
+COc1ccc(N2CN(C=O)c3ccc(OC)cc3C2=O)c(CO)c1
+CCP(=O)(OC)C(=O)C(C)(C)C
+CCCC(=O)c1ccc(O)cc1O
+CCC(CC)C(=O)N1CCC(CC(=O)O)C(CC2=NCCc3ccc(C)cc32)C1
+CC(C)=CCCC(C)(O)C1CC(=O)C(C)=CC1O
+COc1cccc2oc3ccc(O)cc3c(=O)c12
+Cc1nc(C(=O)O)sc1CCOP(=O)(O)O
+O=C1CC2C(O)C=C(CO)C2(CO)O1
+COc1ccc2c(ccn2CCC(=O)NC(Cc2ccccc2)C(=O)O)c1
+CCCCCCCCCCCCCCCCCCCC1CC(O)CC(=O)O1
+C=Cc1ccc(O)c(C(=O)C=C(C)C)c1
+COCC(=O)N1CCN2C(=O)N(CC(N)=O)C(=O)C2C1
+CCOC(=O)c1ccc([NH+]([O-])O)cc1NC(=O)c1ccccc1
+CC(C)(C)CC(=O)NC(Cn1cc(F)c(=O)[nH]c1=O)C(=O)O
+O=P(N1CC1)(N1CC1)N1CC1
+Cc1[nH]cnc1CSCC/N=C(\N)NCCSCc1nccs1
+CC1CC(=O)c2c(O)cc(O)cc2O1
+CC1=CC(O)CC(C)=CC(O)CC(C)(O)C=CC(C(C)C)CC1
+CC(=O)CCc1oc2ccc(C)cc2c1-c1ccccc1
+Cc1cccc(OC2COCCN(C(=O)c3cnccn3)C2)n1
+O=C(c1ccccc1)N1CCc2[nH]c3c(Br)cccc3c2C1
+CC(=O)Nc1ccc2c(c1)Cc1cc(NC(C)=O)ccc1-2
+NC(=O)CCNC(=O)C1=CC(NC(=O)c2cccc(F)c2)C(O)C(O)C1
+CC1=C2CC3C(C)(C=CC(O)C34CO4)CC2OC1=O
+COc1ccc(CO)c2c1Nc1c(C(=O)O)cccc1N2C(=O)CO
+COc1ccc(C=CC(=O)c2c(O)cc(OC)c(O)c2OC)cc1
+O=C(O)COc1ccc2c(c1)OC(=Cc1cccc(Br)c1)C2=O
+CN1C(=O)COCC1C(O)c1ccc(NC(=O)c2ccco2)cc1
+CCOP(=O)(CCN)OCC
+Cc1cc2oc(=O)cc(CN3CCCCC3C)c2cc1O
+CC1(C)CCCC2(C)C1CCC(C)(O)C2CC(=O)c1ccoc1
+CCN1C(=O)C(Cc2c[nH]c3ccccc23)NC1=S
+CCCCCCC1CCCCCCCCCCC(=O)OC2C(O1)OC(CO)C(O)C2O

benchmark/data/val_smiles.txt

@@ -0,0 +1,1627 @@
+C=CCON=C(CCC)C1C(=O)CC(C)(C)C(C(=O)OC)C1=O
+CC(=O)OC1c2c(C)coc2CC2C(=O)CCC(C)C21C
+COc1ccccc1-c1nnc(N)[nH]1
+CCN(CC)CCOC(=O)C(C)Oc1ccc(Cl)cc1
+COc1ccc(CCNC(=O)c2ccc3ccn(C)c3c2)cc1OC
+Cc1ccc(C2CC(O)C(O)C2NCC(C)(C)O)cc1
+COc1ccc(OC)c(-c2oc3ccccc3c(=O)c2O)c1
+CC1CC(=O)OCC1O
+NC(=O)C1(O)CC(O)C2OC21
+C#CCCCCCCCCCC=C1C(=O)OC(=C)C1OC
+C#CC1CN2CCC1CC2CNC(=O)N1CCOCC1
+COc1ccc(CNCC(CO)C2(c3ccccc3)CCOC(C)(C)C2)cc1
+OCC1OC(n2cnc3c(NC4CCCC4O)ncnc32)C(O)C1O
+Ic1ccc(NCn2nnc3ccccc32)cc1
+CCC(C)CCc1oc(=O)c(C)c(O)c1C
+C=C(C)C1CCC(C)(O)C1C
+c1ccc(C2=NN(c3ccccc3)C2)cc1
+Cc1ccc(OP(=O)(Oc2ccc(C)cc2)Oc2ccc(C)cc2)cc1
+Cc1c(O)cc(O)c(C=O)c1C
+O=C(NCC1CCCO1)c1c(O)c2ccccc2[nH]c1=O
+COC1CC(=O)OC(C)CCCCCC(O)C1=O
+COc1cc2c(c(O)c1OC)C(C)N(C)CC2O
+COc1ccc2[nH]c3c(NN)nncc3c2c1
+O=C(O)CCc1ccc(O)cc1O
+COc1ccccc1C=CC(=O)c1ccc(NC(C)=O)cc1O
+C#CCN(C)Cc1nc(C2(O)CCN(C(=O)C3CCCCC3)CC2)cs1
+CCC1CN2CCC3(C(=O)Nc4cc(OC)ccc43)C2CC1CCO
+COC(=O)c1c(O)cc(O)c(CC=C(C)CCC=C(C)CCC=C(C)C)c1C
+CCCCCC[N+](C)(C)CCO
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCOC(=O)CCCCCCCCCCCCCCC
+CCNC(=O)/C=C(C)/C=C/CC(C)CCCC(C)(C)OC
+O=C(NCCc1ccccc1)c1cc2ccc(O)c(O)c2cn1
+CC1CCOC1=O
+O=C(OCCO)c1cc(O)c(CO)cc1C(=O)c1ccccc1O
+CCCC(CC(CCc1ccc(OC)c(O)c1)OC(C)=O)OC(C)=O
+COc1c(C)c(O)cc2cc(CC(C)O)oc(=O)c12
+C=C1CCCC(C)(C)C1CCC(C)=CCO
+CNCC(c1ccccc1)c1ccccc1
+CCCCCCCCc1cc2cn(C3CCC(CO)O3)c(=O)nc2o1
+CC(C)CCn1c(N)nc2c1c(=O)n(C)c(=O)n2C
+O=C(Cc1ccc(Cl)cc1)NC1C(c2cncnc2)CC(O)C1O
+CC(C)=CCCC(C)=CCOc1cc(O)c(C(=O)c2ccccc2)c(O)c1
+COc1cc(C=CC(=O)NC2=C(O)CCC2=O)ccc1O
+CCCCCCCCCCCCCCCC(=O)OCCC
+Oc1ccc(-c2ccc(-c3ccc(O)nn3)cc2)nn1
+CC(=O)C1CCC(C)C1c1occc1C(C)C
+CCCCCC=CCC1OC(C=C=CBr)CC1OC(C)=O
+C=C1C(=O)OC2CC(=C)C3C(OC(C)=O)CC(C)(O)C3CC12
+CNC1C(O)CC(N)C(OC2OC(CN)=CCC2N)C1O
+O=C(CC(CO)C(=O)c1ccc2c(c1)OCO2)c1ccc2c(c1)OCO2
+CC(C)C(N)C(=O)NC(C(=O)O)C1CC(O)C(O)CN1
+COc1cc(C=CC(=O)OCC2CCCN3CCCCC23)ccc1O
+CC1CCC(C)(COC(=O)CCc2ccccc2)C1(C)C
+CCCOC(=O)C(Cl)(C(F)(F)F)C(F)(F)F
+COc1c(C)c(O)c(C=O)c2c1C(=O)OC2
+Nc1ccc(F)c(CO)c1
+O=C(/C=C/c1ccc(OCc2ccccc2)cc1)N(O)CCc1ccccc1
+CC=Cc1ccc(OC)cc1
+CCC=CCCCCO
+CC(C)C1CCC2(CO)CCC3(C)CC(O)C4(C)CC4C3C12
+COc1ccc(-c2coc3cc(O)c(OC)cc3c2=O)c(O)c1
+C=C(COCC(O)COC(=O)CCCC=CCC=CCC=CCC=CCCCCC)C(=O)O
+C=CC1(C)CC2(O)OC(=O)C(C)=C2CC1C(=C)C(=O)OC
+CCCCCn1cnc2c(S)nc(N)nc21
+COc1c(C)c(O)c2c(c1C(=O)O)C(O)OC2
+CNC(Cc1c[nH]c2cccc([NH+]([O-])O)c12)C(=O)O
+O=c1ccn(C2OC(CO)C(O)C2O)c(=O)[nH]1
+COc1ccc(-n2cc(-c3ccccn3)nn2)cc1N
+O=Cc1ccc(O)c(Br)c1
+CC(=CCO)CCCC(C)(C)O
+O=C1CC2CCN(Cc3ccccc3)CC2CCN1C1CCCCC1
+CC(C)=CCCC(=CCCC(=CCCC(=CCO)CO)CO)CO
+S=CC=NCc1ccccc1
+CCC(C)CCC1=C(C)C(=O)C(=O)c2c1[nH]c1ccccc21
+CC=CC=CC=CC(=O)CC=C1CC=C(O)C(OC)C1
+COc1ccc2c(c1)OC1C3C=CC(OC)C=C3OCC21O
+CC(O)C(=O)OC1C=CC(CC(=O)C(=O)O)(C(=O)O)C=C1
+CCCC(C)CCCCC(C)CC
+COc1ccc2c3c1OC1C(=O)CCC4C(C2)N(C)CCC314
+CCCCN(C)Cc1cc(=O)oc2ccc3ccccc3c12
+COC1CC2C(=O)N3CCN(C(=O)NC(C)C)CC3C(=O)N2C1
+CCCCCCCC(=O)c1c(O)cccc1O
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC=CCCC1OC(=O)COC1=O
+CC(C)[C@H](NC(=O)[C@@H](S)Cc1ccccc1)C(=O)N1CCCC1C(=O)O
+CCCCOCC(C)OCC(C)OCC(C)OCC(C)OCC(C)O
+CCc1ccc(C)c(O)c1
+CC(=O)Nc1ccc(-c2ccc(N=Nc3ccccc3)cc2)cc1
+CCCCCC=CCC=CC=CC(O)C(O)C=CCCCC(=O)O
+Cc1ccccc1CN1CCN2C(=O)N(Cc3ccccn3)CC2C1
+CC(C)CC(NC(=O)C(CC(=N)O)NC(=O)CN)C(=O)O
+CC=Cc1cc(OC)c2oc(-c3ccc(O)cc3O)cc2c1
+O=C1CCCCCCCC=CCCCCCCC1
+CC12CCC3C(C)(CO)C(O)CCC3(C)C1CC(C1=CCOC1=O)O2
+CCCCCC(O)C=CC(=O)CCCCCCCCC(=O)O
+COC1C=CC2(C(=O)OCc3cc4c(cc32)OCO4)C(N(C)C=O)C1
+O=C(O)C=Cc1ccc2ccccc2n1
+CC(=O)c1ncco1
+CC(C)N(C(=O)CS(=O)(=O)O)c1ccccc1
+C=CC(C)(O)CCC1(C)C(C)CCC2(C)C(C)=CCC(C)C21
+CO[C]1[CH][CH][C]([C]2[NH2+][CH][CH][CH][C]2[O-])[CH][C]1N
+Fc1ccc2[nH]c(C3CCN(Cc4ccccn4)C3)nc2c1
+C=C1CCC2C3(C)COC3CCC2(C)C1CC=C1C(=O)OCC1O
+Cc1cc(C)nc(NC(Cc2ccccc2)C(=O)O)n1
+CCOc1ccc(Cc2ccc(NC3=NCCN3)cc2)cc1
+COC1CCC(OC2CCC(O)C(C)O2)C(C)O1
+COc1ccc2c(O)c(C(=O)O)cnc2c1
+CC[C]1[CH][CH][CH][NH+](C[C]2[CH][CH][C](Cl)[CH][CH]2)[CH]1
+CCSC(SCC)C(CCC(O)CNC(C)=O)NC(C)=O
+CC1Oc2c(O)cc3ccc(=O)oc3c2C1(C)C
+C=CCC1(Cl)C(O)=C(Cl)C(=NCCCC(=O)OC)C1(OC)OC
+Clc1cn2ccsc2n1
+CN(C)Cc1ccccc1Sc1ccc(Br)cc1N
+CC(C)CCCC(=O)CCCCCCC(=O)CCN(O)C(=O)C(N)CO
+C=C1C(=O)OC2C=C(CO)CCC=C(C)CC(OCC(C)C)C12
+CC(=O)NC(CCC(O)=CNN)C(=O)O
+CCCCCCCCC=CCCCCCCCCCC(=O)OCC(CO)OC(=O)CCCCCCCCCC=CCCCCCCCC
+C=CC(C)(CCC1C2(C)CCC(O2)C1(C)CCC=C(C)C)OC(C)=O
+COC(=O)C1Cc2c([nH]c3ccccc23)C(C)N1
+c1coc(-c2ccc(C3=Nc4cccc5cccc(c45)N3)cc2)c1
+COc1cc2c(cc1O)C1CCc3cc(OC)c(O)cc3N1CC2
+C#CC#CCCCC=CCCCC(=O)NCC(C)C
+CCCCCCCCC(C)CCCCCCCC(=O)OC1C(O)C(O)C(O)C(O)C1OC1OCC(O)C(O)C1O
+Nc1nc(O)c2ncn(CCC(CO)CO)c2n1
+CCOC(=O)C1(CCCc2ccc(Cl)cc2)OC12CCCCC2
+COc1ccccc1N1CCN(CCN2C(=O)CC3(CCCC3)CC2=O)CC1
+CC(=O)OCC(C)CCCC(C)C1CCC(C)C12CC=C(C)C(O)C2
+CC1=C(C(=O)O)C2(C)CCCC(C)(C(=O)O)C2CC1O
+CC1=CCC(C)(C)C2CCC(C)C2(O)CC1
+CC1(C)CCCC2(C)CC=C(C=O)C3CC312
+CCOc1cc(OC)c(CC(C)N)cc1OC
+CC1CC2OC2(C)CCC(=O)C2CC(C)(C)C12
+O=Cc1cc(O)c2[nH]c3ccccc3c2c1
+CC(C)Oc1ccc(CNCC2CCOC(C)(C)C2)cc1
+O=C(O)c1ccc(Nc2ncc(F)c(Nc3ccccc3F)n2)cc1
+CCc1[nH]c(O)nc1C(=O)NCCCn1ccnc1
+Cc1cc(-c2ccc(N)c(C)c2)ccc1N
+CCOC(=O)c1c(O)cc(O)cc1CCCCCCCC(C)O
+CCCCCCCCCCC(=O)CC(=O)N[C@H]1CCOC1=O
+CC12CCC3C(C(=O)CC4CC(=O)CCC43C)C1CCC2=O
+Nc1ccc([N+](=O)[O-])cc1C(=O)O
+C#Cc1cc(O)nc(O)n1
+NC(Cc1ccc(S(=O)(=O)O)cc1)C(=O)O
+COC(=O)C=CC(O)=C1C(=O)Oc2cc(O)c(O)cc21
+COC(=O)C(C)=CCCC(C)=CCC1(CC(=O)O)CC(=O)CCC1=O
+O=C(O)CNC(=O)c1ccc(C(O)c2ccccc2)cn1
+CCCC(=O)C(CC)Sc1ccoc1C
+O=c1cc2c3c(ccn2CCCO)cnc3c1O
+COc1ccc(CCNC(=O)CCCc2c[nH]c3ccccc23)cc1
+COc1ccc2oc(C)c(C(=O)Nc3ccccc3C)c2c1
+CC=C(C)C(=O)OC1c2occ(C)c2CC2(C)C(C)CCCC12
+CCCCN(C(C)=O)C(CC)C(=O)NCc1ccccc1
+Cc1cc(O)c2c(c1)C1C(C(C)C)CCC1(C)C(O)C(O)C2=O
+CCCCCC(CC)OC1OC(COC(=O)CC(C)(O)CC(=O)O)C(O)C(O)C1O
+CC1C(=O)OC2C=C(CO)CCC=C(C=O)CC(O)C21
+CCC1(c2ccc(N)cc2)CCC(=O)NC1=O
+C[C]1[CH][CH][NH+](C[C]2[CH][CH][CH][CH][C]2F)[C](C)[CH]1
+NC(N)=NCCCCC(N)C(=O)O
+CC(C)=C1CCC2=CC(=O)CC(C)C2(C)C1
+C=CC1(C)CC(O)C2C(O)(CCC3C(C)(C)CCCC32C)C1
+CCCCCCC=CCCCCCCCc1cc(O)cc(OC(C)=O)c1
+C=C1C=CC(C(=C)C)CC1
+CN(C)/N=N/c1ccccc1C(N)=O
+CC(C)(C)NC(=O)CC1CCNCC1Cc1cc(C(C)(C)C)on1
+CC(=O)NC1C(O)C=C(CO)C(O)C1O
+CC(C)=CCc1ccc2[nH]ccc2c1
+CC1CCCC1C
+CC1=CCC2C(C)(C)CC(O)CC2(C)C1CCC(C)CCO
+CC1CC2OC(=O)C3=CCCC(C1(C)CC(O)C1=CC(=O)OC1O)C32C
+Cc1cccc(Nc2cc(Cl)nc(SCC(=O)O)n2)c1C
+CCCCCCCCCCCCCCCCc1ccc(CC(=O)O)o1
+CC=C(C)C(=O)OCC1=CCN2CCC(OC(=O)C=C(C)CO)C12
+COc1cc2c(c(OC)c1OC)C(=O)C(Cc1ccc(O)cc1)CO2
+Oc1ccc(C=Nc2ccccc2)cc1
+O=C(O)CCCCCNc1ccc(C(=O)O)cc1
+CCCCCCCCCCc1ccc2c(c1)N(C)[C@@H](C(C)C)C(=O)N[C@H](CO)C2
+C=CCCCCC=CC#CCCCCCCCCC1CC(CO)OC1=O
+C=C1OC(=O)C(C(C=CC)C=CC(=O)C=O)C1=O
+CC(=O)c1c(O)cc(O)cc1CC1Cc2cc(O)cc(O)c2C(=O)O1
+CCC(C)C(NC(=O)NCC(C)C)C(=O)O
+COc1cc(O)c2c(c1)CCCCCCCCCCCCCC(C)OC2=O
+NC(=O)c1ccccc1NC(=O)c1ncn2c(=O)n(CCCl)nnc12
+CC1Cc2cc(O)cc(O)c2C(=O)O1
+COc1c(Br)cc(C=CC(=O)NCCCNCCCCNCCCN)cc1Br
+CC1Cc2c(O)c(O)cc(O)c2C(=O)O1
+CCCCCCCCC=C=CCCCCCCCCCCCCCCCCCCCC
+CC(C)=CCC1C(=O)C(C(=O)CCC(C)C)=C(O)C1O
+COc1c(C)c(O)c2c(=O)c(O)c(-c3ccccc3)oc2c1C
+CC#CC#CC#CC=CC1OCCCC1O
+CN(C)Cc1c[nH]c2ccccc12
+Oc1ccc(O)nc1
+CCCCOCCn1c(N2CCCN(C)CC2)nc2ccccc21
+CCCCCCCCCCCCCCCC(=O)OCC1(O)OCC(O)C(O)C1O
+CC(C)=CCCC(C)=CCc1cc2c(cc1O)oc(=O)c1c3ccc(O)cc3oc21
+CCCCCC1=C(C(=O)OCC)C(c2cccc(C)c2)NC(=O)N1
+CC(C)CC(=O)OC1CC2CC(O)C(C1)N2C
+CC(O)C(O)C(O)CO
+CCC(C)C=Cc1cc2cc(O)c(C)c(O)c2c(=O)o1
+CCC(C)=CCC(O)CCCCCCCCCCCCCCCOC(C)=O
+CCCCCCCCCCCCCCCC(=O)OCC(C=COC(C)=O)=CCC1C(C)=CCCC1(C)C
+NCCCCCCCCCCC(=O)O
+C=C1CCC2OC2(C)C(O)CC2C(C=O)=CC(C=C(C)C)C(O)C12
+Cc1cc(C)c(C#N)c(SCc2cc(=O)oc3cc(O)c(O)cc23)n1
+O=Cc1ccc(CO)n1CCc1ccc(O)cc1
+CC(CC1=C(CO)COC1=O)C1=CC(C)(C)CC1
+COc1ccc2c(=O)c(-c3ccccc3)c(C)oc2c1
+C[n+]1ccn(COCCCS(C)(=O)=O)c1/C=N/O.[Cl-]
+COc1ccc(-c2oc3cc(OC)ccc3c(=O)c2O)cc1
+C=C1CCC2C(C)(C)C(O)CCC2(C)C1CCC(C)CCO
+C=CC=CC1OC(C)CC1O
+Cc1cccc(O)c1-c1nc2c(C(=O)O)cccc2o1
+COc1cccc(CO)c1O
+OCC1CCC(O)CN1
+O=C1c2ccccc2CC2C=CC=CC12
+CC(C)NCC(O)COC(=O)c1ccccc1Cl
+O=C1c2ccccc2-c2c1c1ccccc1c(=O)n2CCCn1ccnc1
+CCCCN1CCC[C@H]1CNC(=O)c1cc(SC)cc2c1OCCN2C
+COc1cc(O)cc2c1CCN(C)C2
+O=C(Cc1ccccc1)NNc1ccc([NH+]([O-])O)cc1
+COC(=O)c1ccc2c(c1)-c1cc(O)ccc1OC2(C)C
+CC(=O)CC(C[NH+]([O-])O)c1ccccc1
+COc1ccc2ccc3oc([N+](=O)[O-])cc3c2c1OC
+NCCN(C(=O)c1ccc(Cl)cc1Cl)c1ccc(F)cc1
+CC1=CCCC2(C)OC2CC(=C(C)CO)C(=O)C1
+CC=C(C)C(=O)Oc1ccc(OC(=O)C(C)C)cc1C1OC1C
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC(C)=O
+C=CCc1ccc(O)c(-c2cc(OC(O)C=C)ccc2O)c1
+CCc1c(C)c(O)cc2c1C=CC1C(C)(C)C(=O)CCC21C
+CCCCCCCCCCCCCCCC1OC(COP(=O)([O-])O)CS1.[Na+]
+CN(C)Cc1ccccc1-c1ccc2n(c1=O)CC1CC2CN(C(=O)CSCC(=O)O)C1
+CC(C)=CCCC(C)=CCCC(C)CC(=O)O
+CCN1CCCC1CNC(=O)COc1cc(O)c2c(c1)OC(C)(C)CC2=O
+CC1(C)CCC2(CCC(C)(C)O2)O1
+C=CC(C1=CC(O)C(OC)=CC1OC)c1ccccc1
+C#CCn1ccc2cc(C(=O)OC)ccc21
+CC(=O)Oc1cc(O)c2c(c1)OC(c1ccccc1)CC2=O
+Nc1ncc(-c2ccc(O)cc2)nc1Cc1ccccc1
+COc1ccccc1CCN1CC(C(=O)NCC2CCCN3CCCCC23)CC1=O
+CCCCc1cc(OC)c(OC)cc1OC
+COc1cc(OC)c2c(C)c(CC(=O)NCCC(=O)O)c(=O)oc2c1
+Cc1ccc2c(c1)C(=O)CCC2C
+Cc1cc(N)ccc1C(=O)OCC(O)CNC(C)(C)C
+CCN(CC)C(=O)C=C(C)C(F)(F)F
+CC(=O)OC1OC2OC=C(C(=O)CC=C(C)C)C3CCC1C23
+CCCCC(=O)N1CSC[C@H]1C(=O)N1CCCC1
+COc1c(C=CC=O)cc2c(c1OC)OCO2
+O=C(NCC1CC2CCN1CC2CN1CCOCC1)c1ccco1
+COC(=O)c1ccc(CCCCCCCCCCC(C)=O)cn1
+CNc1ccccc1C(=O)CC(NC(C)=O)C(=O)OC
+O=C(O)CSCC(=O)N1CC2CC(C1)c1ccc(-c3cccnc3)c(=O)n1C2
+C=C1C(=O)OC2CC(=C)C3CCC4(C)OC34CC12
+CC(=O)Nc1ccccc1-c1onc(-c2ccccc2)c1-c1ccccc1
+CCC(=O)C(C)C
+CCn1nnnc1Cc1ccc2[nH]cc(CCN(C)C)c2c1
+COC1COCCN(C(=O)c2cccc(F)c2)C1
+COc1ccc2c(C)c(CC(=O)NC(C)C)c(=O)oc2c1OC
+COc1cc(OC)c(C(=O)CC(C)=O)c(OC)c1
+CC(=O)OCC=C(C)CCC1C(C)=CCC2C(C)(C)C(OC(C)=O)CCC12C
+CC1=C(C)C(=O)C(CCC(C)(O)CCC(=O)O)=C(C)C1=O
+Cc1cc2c(c(C)c1CCO)CC(C)(CO)C2
+C=C(C(=O)OC1C2C(CC(C)C3C=CC(=O)C31C)OC(=O)C2C)C(C)O
+CC=CC#CC#CCCCOC(=O)CC(C)C
+COc1cc(C=Cc2ccc3c(c2)OCO3)oc(=O)c1
+CC(=CC(=O)c1ccccc1)NCCCC(=O)O
+COc1cccc(C2=CCN(C)CC2)c1
+COc1ccc(CN2CC3CN(Cc4ccccn4)CCN3C2=O)cc1
+CC1CC23C4=CCCN2CCCC3C(=O)CC4C1O
+Cc1cc2c(cc1Br)C1(C)CCC(C)(O2)C1C
+CN(CCc1ccccc1)C1C(CNC(=O)c2cccc(F)c2)OC(CO)C1O
+CC[C]1[CH][CH][CH][NH+](CC(=O)[C]2[CH][CH][CH][CH][CH]2)[CH]1
+CCCC=CCOC(=O)CCCCCCC
+CNC(=S)N(O)c1ccccc1
+CC1=CCc2c(cc(CCc3ccc(O)cc3)c(C(=O)O)c2O)OC1
+CC(=CCC(Br)C(C)=CC(Cl)Cl)CBr
+O=C(O)c1ccccc1C1c2ccc(O)cc2Oc2cc(O)ccc21
+CC(=O)CCC(=O)c1ccoc1
+CN1CCC(c2c[nH]c3ccc(-n4cnnc4)cc23)CC1
+C=CC=CC=CCC
+O=C(O)c1cc(C(=O)O)c([NH+]([O-])O)cc1[NH+]([O-])O
+Cc1nnn(C2CCN(Cc3ccccc3)CC2)c1-c1ccccc1
+O=c1[nH]c2ccccc2o1
+CC(=O)OC1CC2(C)C3CC1C(C)(C)C2(O)CCC3C
+Cc1ccc(-c2cc(=O)c3cc(Cl)cc(Cl)c3o2)cc1
+NC(=O)Nc1ccc(C2=NNC(=O)CC2)cc1
+CC(C)(C)C1(C)CCNC1=O
+C=C1CCC2OC2(C)CCC2C(C)CC12
+CN(Cc1ccccc1)C(=O)CC1C(O)CCC2C(C)(CO)C(O)CCC12C
+COc1cc(C=CC(=O)O)c(O)cc1O
+CC(C)=CCCC(C)C1CC=C(C)C2CCC(C)=CC21
+CC1(C)C2C=CCC1C2
+O=C(O)C(=Cc1ccccc1[NH+]([O-])O)c1ccccc1
+[O-][NH+](O)c1cccc(NC2OC(CO)C(O)C2O)c1
+O=C(NCC1OC(CO)C(O)C1N1CCc2ccccc2C1)c1ccccc1
+CCCCCCC=CCCCCC=CCCCCCC(=O)O
+CCCCC12CN3CC(C)(CN(C1)C3C(O)C(O)C(O)CO)C2=O
+NC(=O)OCC(N)C(=O)O
+Cc1ccn(C(N)=O)n1
+CC1(C)C=C(n2ccccc2=O)c2cc(C#N)ccc2O1
+CC(=CC(=O)O)C=C(C)CC(C)CCCCC(O)CCO
+COC(=O)C1CCC=C(C)C(=O)C2CC(C)(C)CC12
+COC(=O)c1cocc2c(C)ccc1-2
+CC(=O)CCC1=C(C)CCC(C)C1(C)C
+CC(O)c1c(-c2ccc(F)cc2)noc1C(=O)NC1CCCCC1
+CCn1c(O)c(C(=O)NCCN(C)C)c(=O)c2ccccc21
+C=C(C)C1CCC2(C)OC3=C(CC12)C(=O)C1(O)COC3C1
+CCCCCCCCCCCCCCCCCCCCCC(=O)NC(CO)C(O)CCCCCCCCCCCCCCC
+COc1ccc(CCc2cc(=O)c3cc(OC)c(O)cc3o2)cc1O
+CCCCCCC(=O)CC(=O)NC1CCOC1=O
+COc1ccc(CCN(C)C)c2cc(-c3ccc(O)cc3)oc12
+CC[C@]1(CCCc2ccccc2)CN(c2ccc(OC)cc2)C1=O
+CC=C(C)CC1C(=O)Nc2ccccc21
+C=CC1(C)CCC2(C)C(=C)C1CCC2C
+COc1cc(O)ccc1C=CC(=O)c1ccc(O)cc1
+CC1=C2CC3C(C)(O)C4OC4C(O)C3(C)C=C2OC1=O
+OC(c1ccccc1)c1ccc(Br)cc1
+COc1ccc(OCC(=O)NCc2c3c(c(OC)c4c2OCO4)CN(C)CC3)cc1
+CC1=C(c2ccc(O)cc2)C(O)OC1=O
+CCCCCC=CCC=CCCCCCCCC(C)=O
+OCc1cc(Br)c(O)c(O)c1Br
+Fc1ccc(-c2c[nH]c(C3COCCN3Cc3ccccc3)n2)cc1
+CC=CC=CCCC(=O)CC(O)CCO
+COc1ccccc1C(=O)Oc1ccc(Cl)cc1C(=O)C=Cc1cccs1
+COC1CC(NC(C)=O)C(OC(C)=O)C(C)O1
+CC(C)(C)C1CC(O)C(C(O)C=Cc2ccccc2)C(=O)O1
+COc1cc2c(cc1O)CCN(C)C2Cc1ccc(O)cc1
+CN1C(=O)CCC1(O)c1cccnc1
+C=c1oc(=O)cc(OC)c1=CC(O)CC
+CC(C)=CC1CC(C)C2(CC=C(C)CC2)O1
+O=CC=Cc1ccccc1
+CCCCCCCC(CCc1ccc(O)c(OC)c1)OC(C)=O
+O=C(NCCc1ccccc1)c1c(O)c2cccc3c2n(c1=O)CC3
+CC=C(CO)C(=O)OCC1=CCN2CCC(OC(=O)C=C(C)CO)C12
+Nc1ccc(C(=O)c2ccc(N)c(N)c2)cc1N
+CCCCCC(O)CC(=O)CCc1ccc(OC)c(OC)c1
+COc1ccc(C2=C(c3ccc(OC)cc3)OCCC2)cc1
+CCCCC1(CCCC)C(=O)NC(=Nc2ccc(OC)cc2)NC1=O
+O=C(NCCOC(=O)N(O)c1ccc(Br)cc1)Oc1ccc(Cl)cc1Cl
+[O-][NH+]1C=CC=CC1c1ccccn1
+CCCCCC=CCC=CCCCCCCCC(=O)OCC(COC(=O)CCCCCCCCCCCCCCCCC)OC(=O)CCCCCCCCCCCCC
+COc1ccc2c(C)c(CC(=O)O)c(=O)oc2c1C
+Cc1cc2ocnc2nn1
+CNCCCCCNCCCCCNC
+CC(C)CCCCCCCCCC(C)C(=O)OCC(O)CO
+CC(=O)C1C(c2ccc3c(c2)OCO3)C=CC2CCCCC21
+Fc1ccccc1-c1nnc(C2CCN(Cc3cccs3)C2)o1
+O=C(NCCCNC(=O)c1ccc2c(O)c(O)ccc2c1)c1ccc2c(O)c(O)ccc2c1
+O=C(CSc1nc2ccccc2s1)NCC1CCCN(CCc2ccccc2)C1
+CCC(NC(=O)OCC1c2ccccc2-c2ccccc21)C(=O)O
+CC(C)CCCCCCCCCCC1(O)C=CC2N1CCC[NH+]2CCCCCNC(=N)N
+CC(NC(=O)Cc1ccccc1)C(=O)NC(C(=O)O)C(C)C
+O=C(O)C=CC(=O)Nc1ccc(C=Cc2ccccc2)cc1
+COc1cc(C2COc3cc(O)ccc3C2)ccc1O
+CN[C@@H](C)[C@H](O)c1ccc(O)c(O)c1
+CCC(c1ccc(O)cc1)C(CC)c1cc(I)c(O)c(I)c1
+C=NN(C)C=C(C)N
+CN1CCC(c2nc3ccccc3s2)C1
+Cc1ccc(-c2c[nH]c(C3COCCN3C)n2)cc1
+C=C(CCC1CCCC(=O)C1(C)C)CC(O)C=C(C)CC(=O)NCCc1ccccc1
+COc1ccc(S(=O)(=O)C(CCC2CCCCC2)CC(=O)NO)cc1
+COc1ccc(CCNC(=O)Cc2ccc3c(c2)OCC3)cc1OC
+CC1(C)C[C]2[NH2+][C](N)[C](C(=O)[O-])[CH][C]2CO1
+Cc1cc(=O)c2c(O)cc3c(c2o1)C=CC(C)(CO)O3
+CC(O)c1cnccc1C(=O)c1nccc2c1[nH]c1ccccc12
+CCC(C)(CC)C(C)C
+COc1cc2c(c(O)c1C(C)O)C(=O)CC(O)C2O
+Cc1cc(Br)c2c(C)ccc(C(C)C)cc1-2
+C=C(C)C(O)COc1ccc2c(OC)c3ccoc3nc2c1OC
+C#CC(C)N(C)C(=O)Nc1ccc(Cl)cc1
+CCCCCCCCCCCC(=O)c1cc(C(=O)CCCCCCCCCCC)cc(C(=O)CCCCCCCCCCC)c1
+C=C1CCC=C(CO)C(O)CC2C1CC2(C)COC(C)=O
+O=C1CN2Cc3cc(N4CCCC4)ccc3N=C2N1
+COc1cc2c(cc1OC)CCN(C)C(C(=O)c1cccc(N)c1)=C2
+O=C(COC(=O)c1ccc(Br)cc1)c1cccc([NH+]([O-])O)c1
+CN(C)C(=O)Oc1ccc2c(c1)OC(=Cc1cccc(F)c1)C2=O
+CC(C)c1cc(C=O)cc(C(C)C)c1O
+COC1=CC(=O)c2cc[nH]c2C1=O
+CC(=O)OC(C)C(C=C1C=C(C)C2=NCCC3OC123)OC(=O)C(C)C
+CC(C)C1=CC2CC1C1CCCC2C1O
+CC(C)COP(C)(=S)OCC1CCCN2CCCCC12
+CCOC(C)OO
+CC(C)C(N)CC(=O)O
+C=CC(=C)CCCC(C)CCCC(C)CCCC(C)C
+CC1C(O)c2cocc2C(O)C2CC(C)(C)CC12
+Nc1c(CC(=O)[O-])cccc1C(=O)c1ccc(Cl)cc1Cl.[Na+]
+CC12CCC(N)CC1=CCC1C2CCC2(C)C1CCC2C(O)[SH](=O)=O
+CC(C)=CCCC(C)(N)C1(C)CC=C(C)CC1
+CC(=O)CCCCCCCCCCCCCCC=Cc1ccc2c(c1)OCO2
+CCCC=CCC1(O)C2=C3C(CCC3N=C(N)N2)CC1C
+CC(NC(=O)C(N)CC(O)C(=O)O)C(O)C12CC1CC=CC2=O
+CC(=CC(=O)OC1C(C)=CC=C(C=O)C1(C)C)CO
+CCCCCCCCCC(C)OC(C)=O
+NC(=O)CCC(=O)O
+CC1CCC2(C)C(CCC(O)C2(C)O)C12COC(=O)C2
+O=C(NCCCN1CCC(Oc2ccccc2)CC1)C(c1ccccc1)c1ccccc1
+CC1Oc2c(c(=O)[nH]c3ccccc23)C1(C)C
+COc1ccc2oc3cc(O)c(O)c(O)c3c(=O)c2c1OC
+OC(CNc1ccccc1I)CON=C(C1CC1)C1CC1
+O=C1c2ccccc2C(=O)c2cc(CO)c(O)cc21
+CC1=CCCC(C)=CC(C)(C)C=CCC1
+CCCCCC=CCC=CCC=CCCCCC(=O)OC(CO)COC(=O)CCCCCCCC=CCC=CCCCCC
+COc1ccc2cc(C(C)C(=O)OCC(=O)O)ccc2c1
+Cc1c(CCC(=O)O)c(=O)oc2cc(OCC(=O)O)ccc12
+C=C(C)C1CCC2=CC(OC2=O)C2=C(C)CC(O)(C2=O)C(C)C(=O)C1O
+CCCCC(COCCOCCOCCO)CC(=O)O
+C=CC1(C)CC(OC(C)=O)C2C(=C)C(=O)OC2C1C(=C)C
+CCCCCCCCCCCCCC(=O)NC(COC1OC(CO)C(O)C(O)C1O)C(O)C=CCCC=C(C)CCCCCCCCC
+Cn1c(N)nc2c3nccnc3ccc21
+Cc1ccc2c(c1O)C(=O)c1c(O)cc(O)cc1C2=O
+COC(=O)CC(c1ccsc1)c1oc2ccccc2c(=O)c1O
+CC1(C)CCCC2(C)C(CO)C(CO)=CCC12
+COC1=CC(=O)c2c(O)cc(CC(C)=O)c(O)c2C1=O
+CC(O)C(OC1OC(C(=O)O)C(O)C(O)C1O)C(O)C(O)C=O
+CC(=O)OCC12CCC1(OC(C)=O)C1C=C(C)C2CC(C)(C)C1
+CCN(CC)c1ccc2c(COC(C)=O)cc(=O)oc2c1
+CC(=O)C12OC1C1(C)C(=CC2=O)CCC(O)C1C
+Cc1ccc2c(n1)CC(C(=O)CO)CCC2C
+CC(C)(C)OC(=O)NCCNC(=O)C(N)CCCCNCCC(=O)NCCS
+Brc1c(OCCCN2CCCCC2c2cccnc2)ccc2ccccc12
+COc1ccccc1CNCCCCCCCCCCNCCSSCCNCCCCCCCCCCNCc1ccccc1OC
+Oc1ccc(Oc2ccc(Br)cc2Br)cc1Br
+CCCN(CCC)[C@@H]1CCc2cccc(C(=O)c3ccccc3)c2[C@@H]1C
+CCC=CCC=CCC=CCC=CCC=CCCCC(=O)OC(CO)CO
+CC(C)C(=O)OCC(=O)c1cc2c(cc1O)OC(C)(C)C=C2
+CC1COC2=C1C(=O)C(=O)c1c2ccc2c1C(O)CCC2(C)C
+CC(O)c1cc(OCCCC(C)(C)C(=O)O)ccc1OCCCC(C)(C)C(=O)O
+Cc1ccc(C(C)C)c2c1CCC(C)(O)C2O
+CN(C)c1ccc2nc(N)oc2c1
+COC(=O)c1ccc(NC(=O)N2CCc3nc[nH]c3C2c2ccccn2)cc1
+O=C(OCC1OC(Oc2ccc(CO)cc2O)C(O)C(O)C1O)c1ccccc1
+C=C1C(=O)OC2C1C(OC(=O)C=C(C)C)C(O)C1(C)C(O)CCC(=C)C21
+CC(CCc1ccccc1)NC(=O)CC1NC(=O)c2ccccc2NC1=O
+CCCCC(N)CCCCCCC(C=CC(=O)O)Nc1ccc[nH]1
+COc1ccccc1C(=O)NCC1COCc2nc3cc(C)ccc3n21
+Cc1cc2ncoc2nn1
+C[C@@H]1CCC[C@@H]2C[C@@H](NC(=O)c3cc(Cl)ccc3O)CCN21
+C=C1CCC2C(C=C(C=O)CCC1O)C2(C)CO
+CC(C)CCCCCCCCCCCC=CC(=O)NC=Cc1ccc(OC2OC(C)C(O)C(O)C2C)cc1
+COc1ccc2c(c1)C1CNC2Cc2ccc(Cl)cc21
+C=CC(C)(C)C1C(=O)C=C(c2ccccc2)OC1=O
+Nc1ncnc2c1ncn2NC(=O)COCP(=O)(O)O
+O=c1c(-c2ccc(O)c(O)c2)coc2cc(O)cc(O)c12
+CCCC(=CCCC=CCCCCOC(C)=O)CCC
+COC(=O)c1cc(C)c[nH]1
+COc1c(C(C)=O)ccc2c1C=CC(C)(C)O2
+CCCCCCCCCCCCCCCCCC(=O)OC(C)C(=O)OC(C)C(=O)O
+CC#CC#CC#CC=CC=CC(CCO)OC(C)=O
+C=CCC(CC=C)(CC=C)c1ccc(CCCCCCCCC)cc1O
+O=C(NCC1OCC(NCc2cccs2)C1O)c1ccccc1
+COc1cc(NC(C)CCCN)c2ncccc2c1Oc1ccc(Cl)cc1
+C[C]1[CH][CH][C](N)[NH+](C[C]2[CH][CH][C](F)[CH][CH]2)[CH]1
+C#CC(C)(C#C)c1ccccc1
+NC(Cc1cc(O)c(O)cc1O)C(=O)O
+COc1ccc(NC(=O)OC2COC3C(NC(=S)NC4CCCCC4)COC23)cc1
+Cc1ccc(O)c(-c2cc3cc(C(=N)N)ccc3[nH]2)c1
+CC(C)CC(N)C(=O)NC(CCC(N)=O)C(=O)N1CCCC1C(=O)O
+CCCCCCCCCCCCCCCCNc1ccc(C(=O)NC(=O)c2ccccc2)cc1
+COc1ccc(C=CC(=O)NC(=S)N2CCCCC2c2cccnc2)cc1
+CC(=O)OC1CCC2(NC(=O)c3ccccc3)CSC1C2OC(C)=O
+CNc1ccc2ncnc(Nc3cccc(Br)c3)c2n1
+O=C(O)COc1cc(OCC(=O)O)c2c3c(c(=O)oc2c1)CCC3
+ClCC1Cc2ccccc2CN1
+COC(=O)CCC1C(=C(C)C)CCC(C)C1(C)Cc1c[nH]c2ccccc12
+CCc1c(C)nc2ccc(OC)cc2c1O
+C#CC=CC(O)C(C)O
+CCCCCCCCCCCCCCCCCCCCCOCC(O)CO
+COC(=O)CC(c1ccc(O)cc1)c1cc2c(cc1O)OCO2
+O=C(CCn1cnc2ccccc2c1=O)N1CC2CC(C1)C1CCCC(=O)N1C2
+O=S(=O)(c1ccc(F)cc1)N1CCCCC1c1cccnc1
+CCOc1ccc(C=CC(=O)c2cc(NC(C)=O)ccc2O)cc1
+CC(=O)OC1CCN2CC(N)CCC12
+Cn1c(C(C#N)=NNc2cccc(Cl)c2)nc2ccccc21
+O=C(O)C1CCCNC1
+COc1c(O)cc2c3c1-c1cc(O)ccc1CC3NC2=O
+O=C(CBr)Nc1ccc(Oc2ccc(C(=O)O)cc2)cc1
+COc1cc2c(cc1O)CNCC2c1ccc(O)c(C)c1
+CC(=O)Nc1ccc2c(c1)nc1n2C(CNCc2ccc(C(=O)O)cc2)COC1
+C=C1OC(=O)c2c(O)cc(OC)c(C)c2C1(C)O
+CC(NCc1c(O)ccc2c3c(c(=O)oc12)CCCC3)C(=O)O
+COCc1cn(C2COC3C(NC(=O)NC4CCCCC4)COC32)nn1
+CCCCCCCCCCCCCCCCCCCCCCCC(C)=CCCOC(=O)CCCC(C)O
+C=CC1(C)CCC2(C)C3=CC(=O)CC(C)(CO)C3CCC2C1
+NC(CSCCS(=O)(=O)O)C(=O)O
+COC(=O)c1ncn2c(=O)n(CCCl)nnc12
+CC(=O)OCC(C)C#CC(CO)=C1C=CC(=O)O1
+N#Cc1nc(C(=O)O)c(O)cc1-c1cccs1
+Cc1nc2c(=O)n(C)c(=O)n(C)c2[nH]c1=O
+Fc1ccc(CN2CCOCC(Oc3cccnc3)C2)cc1
+C1CNCCSCCSCCN1
+CNC(=O)C(Cc1ccccc1)N1CCCC1C(=O)NCCOC
+Nc1ccc(NC(=O)OCCCc2c[nH]cn2)cc1
+O=c1cccc2n1CC1C=NCC2C1
+Cc1ccc2c(CCl)cc(=O)oc2c1
+c1ccc(CCN2CCc3ccccc3C2)cc1
+CCCCCC=CC1C=CCCC1C(C)=O
+CC(C)(C)C(=O)Oc1ccc2c(c1)OC(=Cc1ccccc1Br)C2=O
+O=C(O)C(CCCCn1cnc2c1NC=NCC2O)Cc1cccc(Br)c1
+COc1ccc(C=CC(=O)C2(C)CO2)cc1OC
+CCCCCC=CCC=CCC=CCC=CCC=CCCC(=O)O
+CCCSSCc1ccco1
+N#Cc1ccc(OS(N)(=O)=O)cc1
+COc1cccc(CN2CCC(c3nc4ccccc4[nH]3)C2)c1
+CC(C)C1=Cc2ccc3c(c2C(=O)C1=O)C(O)CCC3(C)C
+CC(=O)OC1(C(C)=O)CCC2C3C=CC4=CC(=O)CCC4(C)C3CCC21C
+CC(=O)OC1C=CC(O)C2(CC(=O)OC2C=C(C)CCC=C(C)C)C1
+O=C(Cc1c[nH]c2ccccc12)OC1C(O)C(O)C(O)C(O)C1O
+COC(=O)c1c[nH]c(=O)c(C(CC(N)=O)c2cccnc2)c1O
+CCCCCCCCCC(C)CCCC
+O=C(C=Cc1ccccc1)c1cc2occc2cc1O
+CC(C)Oc1ccc(CNCCC(c2ccco2)C(C)C)cc1
+CC(C)=CCc1c(OCC(O)C(C)(C)O)ccc2ccc(=O)oc12
+COC(=O)c1cnn2c1NC1=C(C(=O)CCC1)C2c1ccc(OC)cc1
+C=CCC=CCC=CCCCCCCCc1cccc(O)c1
+CC(=O)N1CC2CN(CC(C)C)CCN2C(C)(CO)C1
+CC1OC(C)OC(C)O1
+COC(=O)C1CC(NC(=O)c2ccc(OC)cc2)CN1C(C)=O
+O=C(O)c1cc2ccccc2c(O)n1
+CCC(C)OC(=O)NC(CC)(C(F)(F)F)C(F)(F)F
+COC1=CC(=C(c2ccccc2)c2ccccc2)C=CC1=O
+O=C(NC=CNC(=O)c1ccccc1)c1ccccc1
+C=CC(C=Cc1ccc(O)cc1)c1ccc(O)c(OC)c1
+O=c1cc(CCc2ccccc2)oc2c1C(O)C(O)C(O)C2O
+O=C1/C(=C/c2ccccc2)Cc2ccccc21
+C=CC1CN(C(C)=O)CCC1CCCc1ccnc2ccccc12
+C=CC(C)(C)c1ccc2c(c1)CCC(C)(C)O2
+O=c1nccc2[nH][nH]cc1-2
+Cn1cc(C2CC(=O)Oc3c2c(=O)oc2ccccc32)cn1
+Cc1oc2c(C)c3oc(=O)c(CCC(=O)O)c(C)c3cc2c1C
+CN1CC2CN(C(=O)N3CCOCC3)CCN2C(C)(C)C1
+CCCCCC=CC=CC(=O)NCC(C)CC
+O=C(O)CCCCCCCCCCCCC1CCCC1
+CC12OC(=O)C1(C(O)C1C=CCCC1)NC(=O)C2CCCl
+CCCCCCCCCCCCCCCCCCNC(=O)OCC1(COC(=O)N(Cc2cccc[n+]2CC)C(C)=O)CCCCCC1.[I-]
+CC(C)=CCCC(C)(O)C1C(O)CC(C)(O)C1C
+COc1cccc(NC(=O)NC2COC(CN3CCOCC3)C2O)c1
+CCCNC(=O)NC1CC(COC)C(O)C1O
+O=C(O)C1CC(O)C=N1
+CCCCCC(=O)N1CCC(CC(=O)O)C(Cc2nc3ccc(C)cc3[nH]2)C1
+O=C(C1CCCCC1)N1CCC(c2nnc(-c3cccnc3)o2)C1
+COc1cc(O)c(C(C)=O)c2c1CC(C(C)(C)O)O2
+CC(=O)c1c(C)cccc1O
+C=CC(C)(C)C(=O)C(=O)CC(=O)c1ccccc1
+CCOC(=O)C1=CCCN(C)C1
+COc1ccc(-c2n[nH]cc2C(=O)NCC2CCCN3CCCCC23)cc1
+CC(=O)OC1CC(O)C23C(=O)C(C)C1C2(C)C(C)CCC3O
+C=C(C)C1CCC1C(=C)C
+CCOC(=O)CN1C(=O)C2CCCCN2C(=O)c2ccccc21
+CC(C)(C)OC(=O)N(CCCCCOCc1ccccc1)OCc1ccccc1
+C=C1OC(=O)C(=CCCCCCCCCCCCCCCCC)C1O
+CCCc1cc(C(=O)O)n(C)n1
+C=CC=CCCCCCCCC#CC#CCO
+CCc1cc(C)cc(C)n1
+COc1ccc(C=C2C(=O)OC(=O)c3ccccc32)cc1
+CC1OC(n2ccc(NC(=O)Cc3ccccc3)nc2=O)CCC1O
+CC1=CCc2oc3ccc(C)cc3c2-c2oc(C)cc21
+COC(=O)C(C)Oc1ccc2cc(-c3ccc(OC)cc3OC)c(=O)oc2c1
+COC1(OC)CCC2(C)C(CCC3C4CCC(O)C4(C)CCC32)C1
+O=C1C(=CCCO)C2OCC=CC2=C1O
+CCCCCCCCC/C=C/CC/C=C/[C@@H](O)[C@H](CO)NC(=O)CCCCCCCCCCCCCCC
+C=C1C=CC(C(C)C)CC1O
+O=C(C1CCCC1)N1CCOCC(Oc2cnccn2)C1
+CC1=CC2CC3(C=CC(=O)O3)C(C)(C)C2CC1
+CCOC(=O)C=C(Br)Br
+CCc1c(OC)cc2c(c1O)C(=O)C=CC2=O
+COC(=O)C1(O)CC(O)C(OC(=O)C=Cc2ccc(O)cc2)C(O)C1
+O=C(c1ccco1)c1coc2ccc(O)c(CN3CCCCC3)c12
+CCCN(CCC)[C@@H]1Cc2cccc(O)c2C[C@H]1C
+Nc1c(C=O)cc(C=O)c(N)c1N=O
+CC1CC2CC(=O)C3CCCN4CCC(O)C2C34C1
+Cc1cc2c(c3c1OCO3)C(C)CCC2C(C)CC(=O)CC(C)C
+CC(C)(C)c1cc(C(=O)c2cccs2)cc(C(C)(C)C)c1O
+CN(Cc1cccc(O)c1)C(=O)c1cc[nH]n1
+O=c1c(-c2cc(O)cc(O)c2)coc2cc(O)cc(O)c12
+Oc1cc2cnnc-2c[nH]1
+CC=CC=CC=CCCC=CC=CC(=O)NCC(C)(C)O
+C=C1C(=O)OC2CC3C(=CC12O)CCC1C(C)(C)CCCC31C
+CO[C]1[CH][CH][C](C(O)[C]2[NH2+][CH][CH]N2C)[CH][CH]1
+COc1ccc2c(=O)cc(-c3cc(OC)c(OC)cc3OC)oc2c1
+COCCNC(=O)C1CN2CCC1CC2Cn1cc(CN(C)C)nn1
+CC(C(=O)OC1C(O)C2CC(O)CC1N2C)C(O)c1ccccc1
+COC1=Nc2ccc(NC(=O)CCCCCCC(=O)NO)cc2C(C)(C)C1
+Cc1cnoc2ncnc1-2
+CCOC(=O)c1cc(C)n(-c2ccccn2)n1
+CC(C)[C@@H](NC(=O)[C@H](CO)NC(=O)CCC[C@H](N)C(=O)O)C(=O)O
+Clc1ccc(CNCCC(c2ccccc2)c2ccc3c(c2)OCO3)cc1
+CC1=CC(=O)C(C)(C2(C)CC(CO)=CC2=O)CC1
+CCC(C)CN=C(O)C=CCCCCC=Cc1ccc2c(c1)OCO2
+CC(=O)C1CC2(O)C3(C)COC2(C)CC1(O)C3
+c1ccc(OC(CC2CNC2)c2ccccc2)cc1
+Clc1ccc(-c2cn3cc(I)ccc3n2)cc1
+CC1(C)CN(S(C)(=O)=O)CC2CN(C3COC3)CCN21
+O=C1OC(O)C2C(CO)=CCC2C1CO
+C=C1OC(=O)C2(C(C=CC=CCCC)C=CC(O)C2O)C1O
+COc1cccc(-n2c(C)nc3ccc(OCC(C)=O)cc3c2=O)c1
+NC(CCC(=O)O)C(=O)O
+CCCCCCCCCCCCCCCCCCCCCCCC(O)CCCCO
+C=C(C)C1=CCC2(C)C(OC(=O)C(C)=CC)CCC(C)(O)C2C1
+CCCc1c(C)c2cc3c4c(c2oc1=O)CCCN4CCC3
+CCCCc1oc(CCc2ccc(O)c(OC3CCCC3)c2)cc1CO
+NS(=O)(=O)c1cccnc1[N+](=O)[O-]
+CCC=CC#CCCCCCCCCCCOC(C)=O
+CCCCCCCCC(C)CCC
+COc1cc(O)cc2c1-c1ccc(O)cc1CC2
+O=S1(=O)Cc2ncc3ccccc3c2C1
+Cn1sc(=O)n(-c2ccc(F)cc2)c1=O
+CC(=O)NC1=C2CCCN3CCCC4C(C1)CC(C)CC243
+COC(=O)C1(C(C)OC)CC(C)C(C)(OC(C)=O)C(=O)O1
+N=Nn1cc2cccc-2o1
+Cc1nc(C)c(-c2ccnc(N)n2)s1
+CC(=CC=CC=O)CO
+CCCCCCCCOC(=O)c1ccccc1C(=O)OC
+CC(=O)OC1CCC(C)(CCC=C(C)C)C2CC=C3COC(O)C3C12C
+CCCOCCN(C(=O)CCl)c1c(CC)cccc1CC
+O=C(C=Cc1ccc(O)cc1)CCCCc1ccc(O)cc1
+Nc1nc(NCC(O)CO)c(Cl)nc1[N+](=O)[O-]
+CC1CC(C)C2c3c(ccn(O)c3=O)OC(C)(C1)C2C
+c1cc(-c2c[nH]c(C3COCCN3C3CCC3)n2)ccn1
+O=C(CC1NC(=O)c2ccccc2NC1=O)NCc1ccco1
+COc1ccc(CCNC(=O)NC(C(=O)O)C(C)C)cc1
+C=CCCC(=O)C=CC1C(C)=CCCC1(C)C
+CC1=C2C(=O)C=C(C(=O)O)C2C2OC(=O)C(C)C2CC1
+CC(O)CCc1ccc(C(=O)O)nc1
+CC(=CCCC(C)=CCC=C(C)C1CC=C(C)CC1)CO
+COc1cc(CC(C)=O)c2c(=O)cc(C(=O)CCO)oc2c1
+C=CCNC(=O)CC1CCN(C(=O)c2ccccc2)CC1CC
+CC(=O)OCc1cc(O)c2c(c1)C(=O)c1cc(O)cc(O)c1C2=O
+COc1cc(CCC(O)CCCCc2ccccc2)ccc1O
+CC1=C(CC2C(C=O)=C(C)C3CC32)C(=O)OC1=O
+C[S+](C)(=O)CCO
+CC(C#N)C(C)OC1OC(CO)C(O)C(O)C1O
+CCCCCC1(O)C(=O)C(C)(C)C(=O)C(C)(C)C1O
+CC(NC(=O)C1CC1)c1onc(-c2ccc(F)cc2)c1C(=O)O
+CC1(C)SC2C(NC(=O)C3(N)CCCCC3)C(=O)N2C1C(=O)O
+Cn1c(=O)c2c(O)cc(=O)oc2c2ccccc21
+COc1ccc(CNC2(Cc3cc(CC(C)C)on3)COC2)cc1
+N=c1cccc2oncn12
+C=C(C)C1Cc2nc(N)nc(C)c2C1
+C=CCN1C(=O)C(C(=O)Nc2ccccc2)C2CC1(C)Oc1ccccc12
+COc1c(OC)c(OC(C)=O)c2cc(C)ccc2c1OC(C)=O
+Cn1c(=O)c2nc(O)[nH]c2n(C)c1=O
+Cc1cccc2c1CCc1cc(C(C)C)ccc1-2
+CCCCCCc1c(C)c2cc3c(C(C)(C)C)coc3c(C)c2oc1=O
+Nc1cccc(NC(=S)Nc2cccc(N)c2)c1
+C#CC[C@@H](N)C(=O)O
+O=C(NC1CCCCC1)OC1COC2C(NC(=S)Nc3ccc(F)cc3)COC12
+c1ccc2[nH]nnc2c1
+COc1c2ccccc2nc2oc(C(C)(O)COC(=O)c3ccccc3)cc12
+Cc1cc(C)c(CC(=O)c2cc3ccccc3o2)c(C)c1
+CN1CCc2cn(C)c3c2C1CC(=O)C3=O
+CC(=CCCc1ccoc1)CCC=C(C)CCCc1ccoc1
+CN1CCC23c4c5ccc(O)c4OC2C(=O)CCC3C1C5
+O=C1c2ccccc2C(=O)N1N1C(=O)c2ccccc2C1=O
+CC(=O)c1cnc(C)cn1
+CC(=O)OC1C=C2COC(O)C2(O)C2(C)CCC(O)C(C)(C)C12
+CCOc1ccc2c(C)c(-c3cccc(Cl)c3)c(=O)oc2c1
+CC1=C(Cn2c3ccc(Br)c(=O)c-3nc3ccccc32)C(O)CC(C)(C)C1
+Cc1ccccc1CC(C)C=O
+COc1cccc(CNC2CC(COc3cccc(C)n3)C(O)C2O)c1
+CC(C)COC(=O)Cc1cc(O)cc2c1C(=O)CC(CC(C)O)O2
+CCCCCCCCCCCCS(=O)(=O)N(C)[C@@H]1CCN2CCc3ccccc3[C@@H]2C1
+COc1cccc(CN2CC(F)C(OCc3nc4ccncc4[nH]3)C2)c1
+OCCOCCOCCOCCOCCOCCOCCOCCOCCOCCOCCO
+O=C(Nc1ccc(Cl)cc1Cl)C1CC2CC3CCC1C2C3
+CCCC(C)OC(=O)C(C)CCC
+COc1ccc(CCN2C(=O)NC(CC(=O)NCCO)C2=O)cc1
+CCOC(=O)c1c(-c2ccc(OC)cc2)oc2ccc(OC)cc12
+ON=Cc1ccc(O)c(O)c1
+CC1=CCCC(C)(O)C=CC(C(C)C)CC1
+COC(C)(CO)C1CC=C(/C=N/O)CC1
+CC(C)CCC(CCNCc1ccc(OC(C)C)cc1)C1CCOC(C)(C)C1
+CCCC=Cc1cc2c(O)ccc(O)c2c(=O)o1
+CC1CC(=O)Oc2cc(O)ccc21
+CC(=O)NCC1OC(CC(=O)NCCN2CCOCC2)C(O)C1O
+CCOC(=O)Cc1c(C)c2ccc(OC)c(OC)c2oc1=O
+CC(=O)c1cc(CC2CNCCC2CC(=O)N(C)Cc2ccccc2)no1
+CC12CCC3(CC1Cl)C(=CC(=O)CC3(C)C)C(=O)O2
+O=C(O)C1OC(OCC(Cl)(Cl)Cl)C(O)C(O)C1O
+CC1C=CCCC=CC=CCC=CCCC(=O)O1
+COC(=O)c1ccccc1NC(=O)Cc1ccccc1C(=O)O
+C=CCCCCC=CC#CC#CC=CC#CC=O
+Nc1cnn(-c2ccccc2)c(=O)c1Cl
+CC=C(C)C(O)C(C)C=C(C)C=CCC(C)=CCC(=O)NC(C)CC(=O)O
+CCCN(CCC)C(=O)C1CC(=O)OC12CCOC(C)(C)C2
+Cc1ccc(C(=O)c2cc(N)ccc2N2CCC(C)CC2)c(C)c1
+O=C(NC(=O)C(F)(F)F)Nc1ccc(I)cc1
+CCCCCC=CCC=CCCCCCCCC(=O)OC(COCCCCCCCCCCCCCCCCCCCC)COP(=O)(O)OCCN
+C=CC1(O)CC(NC=O)=CC1=O
+COc1ccc(-c2nnc(-c3nsc4ccccc34)o2)cc1
+CCc1cccc(C=O)c1
+c1ccc(Cc2nnc(C3CCN(C4CCC4)C3)o2)cc1
+Cn1c(=O)ccc2c(NC/C=C/C#CC(C)(C)C)cccc21
+CCCCCCCCCC(=O)CC(=O)NC1CCOC1=O
+Cc1nc(N)ncc1CNC(=O)Cn1c(C)cnc(NCCc2ccccc2)c1=O
+CNC1=NC(=Cc2c[nH]c3ccccc23)C(=O)N1C
+COCCOc1ncccc1-c1noc(C2CCCN2C)n1
+NCCCCOc1ccccc1CCc1ccccc1
+CN(CCc1ccccc1)c1cnc2nc(N)nc(N)c2c1
+C=CC(C)=CCC1(C)C(C(=O)O)=CCCC1C
+CN(C)c1nc(N)nc2c1ncn2CC(=O)O
+CCCCCC(O)CC(=O)CCCCCC(O)CCO
+COc1cccc2c(=O)c(=O)c12
+O=C(O)Cc1ccccc1Sc1c(Cl)c(Cl)cc(Cl)c1Cl
+CCCCCCCCCCCCOc1cc(C(N)=O)cc(C(N)=O)c1
+CC(C)CC(=O)OCC1(CO)CC(=C(C(C)C)C(C)C)C(=O)O1
+O=C1CCC2=C1C1=CCCOC1OC2
+CCNC(=O)NC1CC(Cc2cc(C(C)(C)C)on2)C1(C)C
+Brc1ccccc1Nc1nc2ccccc2n2ccnc12
+C=CC1(CO)CCC(C(C)(C)O)CC1C(=C)C
+COc1ccccc1S
+CC1[C@H]2Cc3ccc(NC=O)cc3[C@]1(C)CCN2CC1CC1
+CN1CCSCCN(C)CCSCC1
+Cc1c2c(cc3c1C(=O)CC3)C(=O)OCC2
+COc1ccc(C2(C(=O)NC(CO)C(C)C)CCOCC2)cc1
+CC1CCC23CC(=CCCC2C1(C)CCc1ccoc1)C(=O)O3
+CC(=NNC(N)=S)C(=S)Nc1ccccc1
+C=CCCCCCCCO
+CC1CC(=O)C(CC(=O)O)C1C[NH+]([O-])O
+CC1Oc2ccccc2C=C1C=O
+COC(=O)C(Cc1ccc(O)cc1)NC(=O)c1ccc(OCC(C)C)cc1
+O=C1N=C(c2c[nH]c3ccccc23)C(=S)N1
+Cc1cccc2cc[nH]c12
+CC1(O)CCC2C(C=CC3(C)OCCC(O)C23C)C1
+CCN(CCCCCCO)C1CCc2cc(OC)ccc2C1
+CC1(C)CC(C(=O)N2CCc3[nH]c4ccc(Cl)cc4c3C2)CCO1
+CCCC(NC(=O)c1ccccc1)c1nc2ccccc2[nH]1
+CC(NCc1c(O)ccc2c3c(c(=O)oc12)CCC3)C(=O)O
+CCCCCCCCCCc1ccccc1S(=O)(=O)O
+CCCCCC(O)C=CC1C(O)CC(=O)C1CC(=O)CCCCC(=O)O
+CCCC(=O)C1C(=O)OCC1CO
+NC(=O)C(c1ccccc1)(c1ccc(F)cc1)c1ccccc1F
+CSC=CC(=O)N(C)CCc1ccccc1
+CC(C)C(C)C(C)(C)C
+CN(C/C=C/c1ccccc1)Cc1ccc2c(c1)OCCO2
+CCCCC=C(C)C=CC1=C(C)C(=O)CCC1(C)C(=O)O
+O=C(NCC1OCC(NCc2ncc[nH]2)C1O)C1CCCC1
+CCCCCC=CCCCCCCCCCCCCCCCC(O)C(O)C(CO)NC(=O)C(O)CCCCCCCCCCCCCC
+COCCNC1C2OCC(O2)C(NCc2ccccn2)C1O
+CC(N)C(O)C=Cc1ccccc1
+CC(=O)NC(CCCC#CC=CCl)CCCC=CC=C(Cl)Cl
+O=C(CCC(=O)OCC(F)(F)F)NC(=S)Nc1cc(Cl)ccc1Cl
+COc1cc2c(cc1O)C1Cc3cccc(O)c3CN1CC2
+CCCCCCCCCCCCCCCCC(C)CO
+COc1ccc2c(c1)CCc1ccc(OC)c(OC)c1-2
+CC(C)CC1NC(C)SC(C)S1
+C=C1CCCC2(C)CCC3(O)OC12C(O)C3(C)CCC(=O)C(C)C
+COc1cc2c(c(O)c1CC=C(C)CCC=C(C)C)C(=O)N(CCc1ccccc1)C2
+CC1C=CCC2(C)C=CC(C(C)(C)O)CC12
+COc1cccc2c1C(=O)C(O)=CC2=O
+COC(=O)C(=CNCCc1c[nH]c2ccccc12)[NH+]([O-])O
+N#CC(=NNc1ccc(Cl)cc1)c1nc2ccccc2s1
+O=C(O)CCC(=O)NC1OCC=C1CO
+CC1CC(O)CC(C)(C)C1CCC(O)CO
+C=C1CCC2C(C=C(C)C(O)CC1O)OC(=O)C2C
+CC1(C)Cc2cc(C(=O)c3ccccc3)ccc2OC1=O
+CCCCCC(O)C=CC1C(O)CC(=O)C1CCCCCCCO
+O=C(NCCCc1ccccc1)[C@@H]1CCCN1S(=O)(=O)Cc1ccccc1
+C=CC[C@@H](CC/C(C)=C/C=C/CCCO)OC
+COc1ccc(NC(C)=O)cc1
+CC1=CC(O)C(C(C)C)C(OC(=O)C=Cc2ccc(O)cc2)CC(C)=CCC1
+COc1cc(OCC(O)CO)ccc1O
+CC(=CC1CCC(C)C2C1=C(C)CC2O)C(=O)O
+CC1=CCC(C(C)C)c2cc(C)ccc21
+CC1=CC(=O)C(=C(O)C=Cc2ccccc2)C1=O
+CC1CCC2C(C)(C)CCCC23Oc2ccccc2CC13C
+CC(=O)NCCC(F)CNC(=O)CCC(=O)N(O)CCC(F)CNC(=O)CCC(=O)N(O)CCC(F)CN
+CCC=CCC=CCC=CCC=CCC=CCC=CC(=O)O
+O=C(O)Cn1c(=O)c2ccc(F)cc2n(Cc2ccc(Br)cc2F)c1=O
+CC(=O)OCc1ccc(C(C)(O)COC(=O)C(C)C)c(O)c1
+CC(C)CC=CC1(C)OCC23CCC4C(CCC5CC(=O)C=CC54C)C2CCC13
+COCCC(=O)N1Cc2c(ncn2Cc2ccccc2)CC1C(=O)OC
+CNC(=O)C(C)(C)N1CCCC1C(=O)N1CCCCCC1
+CC(C=CC1=C(C)CCCC1(C)C)=COC1C=C(C)C(=O)O1
+CNCC(C)(O)c1ccccc1
+CCCCCCCC=CC(=O)NCCc1ccccc1
+COC(=O)CCCCCCc1ccc(OCCOCCO)cc1
+COc1ccc(-c2cc(=O)c3c(O)c(C)c(O)c(C)c3o2)cc1
+COc1cccc2c1CCCC2CCCCN1CCN(C2=NCCCC2)CC1
+CC(C)NCC(O)c1cc(O)cc(O)c1
+CC(=O)CC1OC(C)C(C)c2c(C)c(O)cc(O)c21
+CC(CCc1ccccc1)NCC(O)CNC(C)C1COc2ccccc2O1
+CCCCOC(=O)CC1(O)C(=O)OC1C(=O)OCCCC
+CC(C)CC12NC(=O)C3(O)C(=O)CC(Cc4ccccc4)(OC13)O2
+COc1c(-c2ccccc2)oc2cc3occc3cc2c1=O
+C#CC=CCC(OC(C)=O)C1CC=CCC(Br)C(CC)C1
+COC(=O)C(CCSC)NC(=O)c1cc(C(C)C)nc2ccccc12
+C=C(OC1C=C(C(=O)OC)C(O)C(O)C1O)C(=O)OC
+O=C(O)C1CCN2CC(O)CC12
+CN(CC#CCCC1SCCCS1)Cc1cccc2ccccc12
+CCCCCCCCCCC1CCCCC1
+Cc1ccc(N)c(S(=O)(=O)O)c1
+O=C(Oc1ccc2c(=O)c(-c3ccccc3)coc2c1)c1ccco1
+COc1ccc(NC(=O)N2CCc3c([nH]c4ccccc34)C2)cc1
+COc1ccc(C(=O)NC2COC3C(OC(=O)Nc4ccccc4)COC23)cc1
+Nc1ccc(C(=O)OCCCOC(=O)c2ccc(N)cc2)cc1
+CC(=O)C12OC1(C)CC1C3CC=C4CC(O)CCC4(C)C3CCC12C
+CC(=O)NC(CCCC#CC=CCl)CCCC#CC=C(Cl)Cl
+CC(C(O)c1ccccc1)N(C)CCO
+CCCCCC(O)CCCCCC(=O)O
+CC=C(C)C(=O)OC1CCC2CC3OC(=O)C(C)=C3C3OCC1C23C
+C=C1CCC2CCC3C(O)=NC(=CC(C)CC(O)C1)C3(O)C2(C)C
+COC1OC(OC2C(O)C(O)C(O)C(O)C2O)C(O)C(O)C1O
+CC(CCC(C=O)(OO)C(C)C)C1CCC2C3CC=C4CC(O)CCC4(C)C3CCC12C
+Cc1ccc(C)c(NC2=CC(=O)CC(C)(C)C2)c1C#N
+CC1(CO)CCCC23COC4OCC(=CCC12)C43
+CC1=CCCC2(C)OC2C(O)C(C(C)C)C(=O)C1
+CC(C)(Oc1cccc(CCCCCCCCO)c1)C(=O)O
+CC#Cc1ccc(-c2ccc(C(=O)C(O)C(C)=O)s2)s1
+CC(N)C(=O)N1CCCC1C(=O)OCc1ccccc1
+COC(=O)c1ccccc1N1C(=O)c2ccccc2C1=O
+CC1(C)CCc2cc(CC(=O)Cc3ccc(O)cc3)ccc2O1
+O=C(O)CC(O)(Cc1ccccc1)Cc1ccccc1
+CC(=O)C=CC1C(C)=CC(O)CC1(C)C
+C=C(C)C(O)Cc1c(O)ccc(C(=O)C=Cc2ccc(O)c(CC=C(C)C)c2)c1O
+CCCCC1C(C)CCC2C1(C)CCC1C(C)(C)CCCC12C
+O=C(C=Cc1ccccc1)c1cc2cc(Br)ccc2oc1=O
+O=C(O)CCCNC(=O)OCC1c2ccccc2-c2ccccc21
+CCC(C)CCC1C(COC2OC(C(O)CO)C(O)C2O)CCC2C(C)(C)CCCC12C
+NC1=CC(=O)c2ncccc2C1=O
+C=CC(C)(O)CCC1(C)C2=CCCC(C)(C)C2CCC1C
+O=C(O)CN1C(=O)[C@@H](NC(=O)[C@@H](CS)Cc2ccccc2)CCc2ccccc21
+CCC(C)C(O)C(=O)O
+CN(C)Cc1cn(CC2CC3CCN2CC3C(=O)N(C)C)nn1
+C=CC(C)=CCC1C(=C)CCC2C(C)(C(=O)O)CC(O)CC12C
+O=C(O)c1ccc(COc2ccc3ccc(=O)oc3c2)o1
+CNC(=S)N(C)CCc1cc2c(c(OC)c1C=NO)OCO2
+O=C1CC(O)Cc2cc(O)cc(O)c21
+OCC(NCC1NCC(O)C1O)c1ccccc1
+CC(C)(O)C=CC1=CC(O)C(O)C(O)C1O
+CC(C)(C)NC(=O)CCl
+COc1ccc(Cn2cccc2/C=C/C(=O)CC(=O)C(=O)O)cc1
+CC(=O)Oc1cc(C)c(O)cc1CC=C(C)CCCC(C)=CC(=O)CC(C)C
+CC(=O)c1cc(O)c2c(c1)OC(c1ccc(O)cc1)CC2=O
+CCCCCCCCCCCCCCCNC(=O)C1CCCCC1
+COc1ccc(CCNC(=O)Nc2cccc3[nH]ccc23)cc1OC
+CCN(CC)C1C2OCC(O2)C(NCc2ccc(CO)o2)C1O
+OC(CCC(c1ccc(F)cn1)N1CCNCC1)c1ccc(F)cc1
+C=C(CCC=C(C)CO)C1CCC(C)(O)CC1
+CC1OC(=O)C(O)C1OC(=O)C=Cc1ccc(O)c(O)c1
+CCCCC1Cc2ccccc21
+Cn1ccnc1CN1CC(F)C(OCc2nc3ccncc3[nH]2)C1
+CC1=CCCC(C(=O)O)=CCc2cc(ccc2O)OC(C)(C)C(O)CC1
+Cc1cc2c(c(CO)c1CCCl)CC(C)(C)C2O
+OCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCO
+C=Cc1cc2c(cn1)C(=O)OCC2
+C=CCNCc1ccccc1
+CCC(C)C(=O)OC1C(O)C2CC(O)CC1N2C
+CC(=O)OC1CCC2(C)C3CCc4ccoc4C3(C)CCC2C1(C)C
+CC(C)(O)C1Cc2c(ccc(C(=O)CCc3ccccc3)c2O)O1
+O=CCc1ccc(O)c(O)c1
+CCCCCCCCCCCCC(Br)CBr
+COC(=O)COc1cccc(OCCNCC(O)COc2ccccc2F)c1
+O=c1cc2cc[nH]n2cn1
+NCCC[Se](=O)O
+O=C(Nc1cccnc1)N1CCc2ccccc21
+O=C(O)CCNC(=O)CCn1ccc2c(Br)cccc21
+CCCCCC(=O)CC(O)CCc1ccc(OC)c(OC)c1
+CC(C)=CCCC(C)=C1C=C2C(C)CCCC2(C)CC1
+COc1ccc2c(c1)C(=O)c1c-2ncc(OC)c1C
+CC(C)(C)CN1CCC(c2nnc(-c3ccccc3)o2)C1
+O=C1c2c(O)cc(O)cc2OC(c2cc(O)ccc2O)C1O
+OCc1cc(O)c(O)c(Br)c1
+CC=C1C(=O)CC2C3CC=C4C(O)C(O)CCC4C3CCC12C
+COC(=O)Cc1nc2cc3ccccc3cc2[nH]c1=O
+CC(=O)Oc1ccc2oc(=O)c(-c3ccccc3)c(C)c2c1
+CCCCCC=CCC(O)C=CC(O)C1CC1C1CCCCCC(=O)O1
+Cc1cc2c(C(C)C)cc(O)c3c2c(c1O)OC3=O
+CCCCCC(O)CCCC(=O)OCC(O)CO
+CCCCCCCC/C=C\C/C=C\C=C\SCCCC(=O)O
+CC1=CCC(C(C)C)C2C=C(CO)CCC12
+CC(C)(O)CCc1c(-c2ccc(O)cc2O)oc2cc(O)cc(O)c2c1=O
+O=c1c2cccc(O)c2nc2n1-c1ccccc1C(O)=NC2
+Cc1cccc(-c2nn3c(-c4ccco4)nnc3s2)c1
+COc1ccc2[nH]c3c(c2c1)CN(C(=O)CCC(=O)NCc1ccccc1)CC3
+CCCNC(=O)N1CC2NS(=O)(=O)c3ccccc3OC2C1
+COc1ccc(-c2ccc3cccc4c3c2C=C(O)C4=O)cc1
+O=C(O)CCNC(=O)C(=Cc1ccc(O)cc1)NC(=O)c1ccccc1
+COc1cc(C=CC(=O)NCCCCN=C(N)N)cc(OC)c1O
+C=C1CCC(=O)C2(C)CCC(O)(C(C)C)CC12O
+CCCCCCCCC(=O)CC(=O)NC1CCOC1=O
+CC1c2[nH]c3ccccc3c2C(=O)C(O)C1C
+CSCC(C=O)=Cc1ccccc1
+C=C1CC(O)C=C(C)CCC(C(C)C)C(O)C1OO
+COc1cc(CCC(=O)CCCCc2cccc(O)c2)ccc1O
+CC1=C2CC34OC3(C)CC3OC34C(C)CC2OC1=O
+CCCCCCSc1cc(C(N)=O)cc(SCCCCC)n1
+CC(NC(=O)Cn1ccc2c(Br)cccc21)C(=O)O
+COC(=O)c1ccc(OC)cc1O
+COC(C#N)C(Oc1ccccc1)c1ccccc1
+CC(C)NC(=O)NC1CCN(C(=O)CC(C)(C)C)C1C(=O)N(C)CC(N)=O
+CC1=CC2C(=C(C)C)C(=O)CC(C)(O)C2CC1
+c1ccc(N(Cn2nnc3ccccc32)c2ccccc2)cc1
+CC(C)=CCc1c(CCCc2ccc(O)cc2O)cc(O)c2c1C=CC(C)(C)O2
+COc1ccc2c3c1OC1C(=O)C[C@H](C)C4C(C2)N(C)CCC314
+Cc1c(-c2cccc(Br)c2)c(=O)oc2ccc(Br)cc12
+Cc1cc(C)c(CCP(=O)(O)O)c(C[C@H](N)C(=O)O)c1
+CNCC(O)c1ccc(O)c2c1CCC(C)(C)C2
+C=CC(C)(C)c1ccc(OC)c(C=CC(=O)c2ccc(O)cc2)c1
+CC(=O)OCC=C(C)CCC1C(C)=CCC2C(C)(C)C(O)C(=O)CC12C
+COC(=O)CC1CCC(=O)Oc2ccc(C(=O)O)cc2N1
+COc1cc2c(c(O)c1OC)COC(C)C2
+CCCCCC=CC1=C(CO)C2OC(=O)OC2C(O)C1O
+COC(=O)CC(O)C1OC(c2ccccc2)C(O)C1O
+CC(C)(C)c1ccc(-c2cc(CC3CNCCC3CC(=O)NC3CCCCC3)no2)cc1
+CC1=CC=C2C(C)=CCC(C(C)C(=O)O)C=C12
+COc1ccc2c(=O)c3ccoc3n(CCC(C)(C)O)c2c1
+NCC(O)c1cccc2c1Cc1ccccc1-2
+C=CCCCCCCCCCC#CCCCCC(=O)OC
+Cc1ccc2nc(C3CCN(C)C3)[nH]c2c1
+CC(C)=CCCC(C)C1CCC(C)(O)C2CC=C(C)C2C1O
+COc1ccc(-c2coc3cc(O)c(O)c(O)c3c2=O)cc1O
+CCc1nc(C)c(C)s1
+Cc1cc(C)nc(NC(=O)c2cc(Cl)ccc2O)n1
+CSc1cccc(N=C=S)c1
+CCCCCC=CCC=CCC=CCCCCC(=O)OC(CO)COC(=O)CCCCCCCC=CCCCCCCCC
+C=C1CCC2C(CN3CCOCC3)C(=O)OC2C2C1CC1OC12C
+O=C(O)CCC(=O)C1COc2ccccc2O1
+CC1C=C2CCC3C(C)(C(=O)O)CCCC3(C)C2CC1
+C=C1CCN2CCCC12
+COc1cc(C)c(OC)c2c1OCO2
+C=CCCCC(C)C1CCC(C)=CC1=O
+Cc1nc(NC(=O)c2ccc(C(C)(C)C)cc2)c(C)c(C)c1O
+CC(C)c1ccc(NC(=O)OC2COC3C(NCC4CCCCC4)COC23)cc1
+COc1ccc(CCNC(=O)NC(CC(C)C)C(=O)O)cc1OC
+COc1ccccc1-c1nnc2n1NC(c1ccccc1)S2
+COc1cc(C(CC(C)C)NC(C)=O)oc(=O)c1
+C=CC1=CC(O)([NH2+][CH2-])C(=O)C1
+CN(CC/C=C/c1ccccc1)Cc1cccc2ccccc12
+CC(=O)C=C1CC(=O)Nc2ccccc2N1
+C#CC1Cc2sccc2C(N)=N1
+CC(C)C1CCC2(C)CC3OOC12C(O)C=C3C(=O)O
+CC(=CCOc1cc2oc(=O)ccc2cc1O)CO
+COc1ccc2[nH]cc(CCNC(=O)c3cccc4c3ccn4C)c2c1
+CN(C)C=CC(=O)C1C(=O)CCC1=O
+OCC#CCSc1nc2ccccc2o1
+O=C(O)c1cc(O)c(Cc2c(O)cc(C(=O)O)cc2O)c(O)c1
+CC(C)(O)C1CC=C(CO)CC1
+CCC1CN(C(C)=O)CCC1CC(=O)NCc1cccc2ccccc12
+CCC(NC(=O)OC)(C(F)(F)F)C(F)(F)F
+Cc1nnc(NC(=O)c2cc(Br)cc(Br)c2O)s1
+Cc1cc(=O)c2c(O)cc3oc(=O)c4cnccc4c3c2o1
+COc1ccccc1N1CCN(CCCCNC(=O)C(C)c2ccccc2)CC1
+Cc1cc(C)c2oc(=O)cc(O)c2c1
+C=C1CCCC2C1(C)CCC(C)C2(C)CC1=C(O)C(=O)C=C(O)C1=O
+CC(O)C1=Nc2c(nc(N)[nH]c2=O)NC1C
+CNC(=O)C(C)(C)N1CCCC1C(=O)N(C)Cc1ccccc1
+C=C1CC(O)CC2(C)CC3OC(=O)C(C)(O)C3CC12
+CC1=C(C=O)CC2C1(C)CCC1C(C(=O)O)C(C)CCC12C
+CC(CCc1ccc(O)cc1)NCCc1ccc(O)c(O)c1
+O=C(O)CCCC(O)C=CC=CCCC(O)CC=CCCCCC(O)O
+CCN(CC)CCNC(=O)c1cc(Cl)c(N)cc1OCC(OC)OC
+CC(C)=CCOc1ccc2ccc(=O)oc2c1CC=C(C)C
+CC(=O)C(O)Cc1ccccc1
+O=c1cc(-c2ccccc2)oc2ccc(OCCCCCCN3CCCCC3)cc12
+CN1C(C(=O)O)CSC1C1CSC(c2ccccc2O)=N1
+CN1CC2(C)CN(CC(N)=O)CC(C)(C1)C2
+COc1ccc(-c2c(O)cc3c(c2OC)OCO3)cc1
+CC1=C(Cn2c3ccc(Br)c(=O)c-3nc3ccccc32)CCC(C)(C)C1
+c1cc(-c2ccno2)[nH]n1
+C=C(C)CC(C)=O
+COC(=O)C1=CCC(C)CC1
+CC1CC=CC2(C)C1C=C(CCCO)C1CCCCC12
+COc1cccc(CN[C@@H](Cc2ccccc2)C(=O)OC(C)(C)C)c1
+COc1ccc2c(=O)c(-c3ccc(Cl)cc3)coc2c1C
+C=C1CCCC(C)(C)C1CCC(C)=CC(=O)OCC(O)CO
+Cc1ccc(NS(=O)(=O)c2ccc(N)cc2)nn1
+C=C1CCCC2(C)C1CCC13CC(CCC12)C(C(=O)O)C3
+CC(N)C(O)=NC(CC(Cl)C1(O)CN=C1O)C(=O)O
+CC1CC2OC(=O)C(C)C2C(O)C2(C)C(=O)C=CC12
+CC(C)c1ccccc1C(C)(C)C
+O=C(CC1OC(CNCc2ccccn2)C(O)C1O)N1CCN(c2ccccc2)CC1
+COBN1CCC(Cl)C1COCc1ccc(C(=O)OC)s1
+CC(=O)OCC1CC(O)C2(C)C(CO)=CCCC2C1(C)CCC(C)CCO
+CC(O)c1c(-c2ccc(Cl)cc2)noc1C(=O)NC1CCCC1
+O=C(O)CCCNc1ccccc1C(=O)O
+CCC(=O)c1ccc(OC)c(OC)c1
+CCCCCCCCC1(c2ccncc2)CCC(=O)NC1=O
+Oc1[nH]cc2ncncc12
+CNC(=O)[C@@H](NC(=O)[C@H](CCCc1ccccc1)CC(=O)NO)C(C)C
+CC(=O)CC(C)=O
+CC=CCC=CCCCCCCCCOC(C)=O
+C[C@H]1C(=O)CCC2C1CCC1(C)C(O)CCC21
+c1ccc2c(c1)c1[nH]ccc3cc[nH]c2c31
+O=Cc1ccc(NCc2ccc(F)cc2)cn1
+CCOC(=O)C1C(=O)C(=O)Nc2ccccc21
+COCCOC(=O)c1c(C)oc2ccc(OCC=C(C)C)cc12
+CCC=C(C)c1ccc(C(C)O)c(=O)o1
+CC(C)C(C)CCC(C)C1CCC2C3CCC4C(C)CCCC4(C)C3CCC12C
+O=C(O)COc1ccc2c(c1)OC(=Cc1ccccc1Br)C2=O
+O=C(O)C(Cc1c[nH]c2ccccc12)NS(=O)(=O)c1ccccc1
+CC(=O)N1c2ccccc2C2C1CC1CCC3C(C)(C)C(O)CCC3(C)C12C
+CC(C)CCN1CC2Oc3ccccc3C(=O)N(C)C2C1
+CC1(C)CCCC2(C)C1CC(O)C13C=CC(CC21)C(O)(CO)C3
+Cc1ccc(CCNc2ccccc2)cn1
+CC(=O)C(C)Cc1ccc2c(c1)OCO2
+COc1ccc(OC)c(-c2cc3ccc(OC)cc3oc2=O)c1
+COc1ccc(-c2oc3c(=O)cc(C)oc3c2CC(=O)NCCn2ccnc2)cc1
+CCOC(=O)C(=NNc1cccc([NH+]([O-])O)c1)C(C)=O
+N#Cc1cccc(CNC2C(c3cccnc3)CC(O)C2O)c1
+COCCOC(=O)c1c(C)oc2ccc(OCC(N)=O)cc12
+Nc1ncnc2[nH]cc(Br)c12
+CC(C)(O)C(O)Cc1ccc2c(c1O)COC2
+Clc1ccc(-c2c(Cl)cc(Cl)c(Cl)c2Cl)cc1Cl
+c1ccc(Sc2ccccc2)cc1
+COC(=O)C(O)C(N)C(=O)O
+O=c1[nH]c2sccc2c(=O)n1CCN1CCN(c2ccccc2)CC1
+CCCCNc1nc(NC(C)(C)C)nc(NC(C)(C)C)n1
+CC1=C2CC3C(CC2(C)CCC1)OC(=O)C3CN1CCSCC1
+C=C(CCC(OO)C(=C)C)C1CC=C(C)CC1
+O=C(CCc1nc2cccnc2[nH]1)Nc1ccc(O)c(C(=O)O)c1
+Cc1cc(O)c2c(c1)Cc1cc(O)cc(O)c1OC2=O
+COc1ccc2c(c1)c(=O)oc1c(C)c3occ(C)c3cc12
+CC1=CCC2OC1CC1=CCC(C(C)C)C1(C)CC(=O)C2(C)O
+Nc1nc(O)c2c(n1)C(=O)C=CC2=O
+CCCCCCCC/C=C\C/C=C\C=C\Sc1cccc(C(=O)OC)c1
+O=C1CCC(=O)NCCCCCCN(O)C(=O)CCC(=O)NCCCCCN(O)C(=O)CCC(=O)NCCCCCCN1
+CSCCC(NC(=O)Cn1ccc2c(Br)cccc21)C(=O)O
+CC(C)(C)c1cc(CC2CC(NC(=O)C3CC3)C2(C)C)no1
+CCCOc1ccc(NCCC(=O)c2ccc3c(c2)OCO3)cc1
+COc1ccc2c(c1CCCC(=O)O)OC(c1ccc(O)cc1O)CC2
+NCCC(O)(P(=O)(O)O)P(=O)(O)O
+CC(C)CCCCCCCCCCC(=O)O
+CC=CC1=C(C=CC)C(=O)C2(C1)CC(O)C(=O)O2
+CC12CCC3C(C(=O)CC4C(O)CCCC43C)C1CCC2O
+O=C(OCC1CC2c3ccccc3C1c1ccccc12)C(Cl)Cl
+C=C(C)COc1ccc2c(C)c(CC(=O)NCCc3ccncc3)c(=O)oc2c1
+C#CC=CCCCCCCCCCCC=CCCCCCCCCCCCCC#CC#CCO
+CCCSSCCC
+COC(=O)c1ccc2c(=O)n(CC(N)=O)cnc2c1
+O=C(O)COc1ccc2c(c1)OC(=Cc1cccc(F)c1)C2=O
+COC(=O)/C=C/CNC(=O)[C@@H](CCSC)NC(C)=O
+CCCc1cc(-c2onc(C)c2-c2ccc(C(=O)OCC)o2)c(O)cc1OC
+C1=CC=CC=CC=CC=CC=CC=CC=C1
+C=c1ccn2c(=N)onc12
+Cc1cc(C)c(C)c(N)c1
+CC(=O)NC(Cc1ccc(F)cc1)C(=O)O
+CN1C(=O)NC(=Cc2ccccc2)C1=O
+CC(=O)c1cc2c(c(O)c1C)C(=O)C(=O)c1c(O)cccc1-2
+CN1CCN(C(=O)CC2CCNCC2Cc2cc(CN3CCCCC3)on2)CC1
+COCCOCC1(CNC(=O)c2nc3ccccc3[nH]2)CC(O)C(O)C1
+CC1CCC(C(C)C)C(OC(=O)c2ccccc2)C1
+C=C1CCC=C(C)CC2OC(CC2C(=C)C)C(C)(O)CCC1O
+CNC1CC(c2ccc(Cl)cc2)c2ccccc21
+CC(=O)OC(C)(C)C1CC=C(C)CCC=C(C)CC(O)C=C(C)CC1
+COC(=O)c1c[nH]c2cc(Br)ccc12
+C=CCCC(CC=C(C)CCOC(C)=O)C(=C)C
+OCC1=CCN2CC(O)C(O)C12
+CCCCSSC(CC)SC
+CC1=CC2C(C(C)O)CCC(C)(C)C2CC1
+Cc1c(Cl)cnc(N=C(N)N)c1Cl
+O=C1Nc2cc(Cl)ccc2C1=Cc1c[nH]c2ncccc12
+CCCCCCCCCC[S+]([O-])CCC(=O)NC(CO)(CO)CO
+COc1cc2c3c(cc4ccccc4c3c1O)NC2=O
+Cc1cc2oc(=O)cc(C)c2c(O)c1CN1CCCC1
+CC(=O)N[C@@H](CS)C(=O)N[C@H](C(N)=O)C(C)C
+CC(C)=CCCC1COC2OC(O)C3=CCC=C(C)CCC1C32
+C=C1CC23CCC4C(C)(C(=O)OC)CCCC4(C)C2(O)CCC1C3
+CC1(CO)CCCC2(C)c3ccccc3C(CO)C12
+CC(=O)NCCOc1cccc2c1N(C(=O)c1ccc3c(c1)OCO3)CCC2
+CCCCCCCCCCCCCCCCCc1ccc(O)c(O)c1
+CC(C)CCn1c(N(C)C)nc2c1c(=O)n(C)c(=O)n2C
+CCCCCC(CC(=O)CCc1ccc(O)c(OC)c1)OC
+CC(=O)OC1CCC2(C)C(CCC3C4CCCOC4(C)CCC32)C1
+OCC1CCN2CCC(O)C12
+CC1CCC2(OC2(C)C)C(=O)C1
+CC(C#N)c1ccccc1[NH+]([O-])O
+Cc1c(O)cc(C=Cc2ccccc2)cc1O
+COc1cc(=O)oc(C)c1C=CC(C)O
+CC(C)CCCCCCCCCCC=COCC(COP(=O)(O)OCCN)OC(=O)CCCCCCCCCCCC(C)C
+CCCCC(O)CCCCCCCCCCC(=O)O
+CCCCCCCC=CCCCCCC(=O)O
+COc1cc2c(c(O)c1C)C(=O)CCC2O
+C=C1OC2CC(C(=O)O)C=CC2NC1=O
+O=C(NNC(=O)c1cc([N+](=O)[O-])c[nH]1)Nc1ccccc1
+COC(=O)c1cccc(Nc2cc(C)nc3ccc(OC)cc23)c1
+COc1ccc(CCN2C(=O)NC(CC(=O)N3CCCC3)C2=O)cc1
+CC(C)c1cc(C(=O)N2CC[C@@H](N)C2)nn1C(C)(C)C
+CN(C)C(=O)Oc1ccc2cc(-c3ccc(Cl)cc3)c(=O)oc2c1
+CC(=O)Oc1ccc(C2Oc3cc(OC(C)=O)ccc3CC2OC(C)=O)cc1
+CCC(=O)OCC(C)=CCCC1(C)OC2(C)C=CC1CC2
+CC(=O)OC1c2c(C)coc2C(=O)C2CCCC(C)C21C
+CCC1CN(C)CC2C(C(=O)OC)c3c([nH]c4ccccc34)C(=O)CC12
+CC1(CO)CCCC2(C)C1CC(O)C13C=C(CC=O)C(CCC21)C3
+O=C(NC1CC2C(=O)NCC(CCC(=O)N3CCOCC3)N2C1)C1CC1
+Cc1cccc(OCC2(CNC(=O)NC(C)C)CC(O)C(O)C2)n1
+COP(=O)(O)ON1C(N)=NCC1CN(C)C
+CC(O)=NC(CCC(=O)O)C(=O)OP(=O)(O)O
+NCCCCC(=O)O
+CC(=O)OCC(=CCCC(=CCO)CO)CCC=C(C)C(O)CC=C(C)C
+Cc1ccc(C(C)(C)O)c(O)c1
+CC12CCC3C(CCC4CC(O)CCC43C)C1CCC2CCO
+c1ccc(-c2cc3ccncc3cn2)cc1
+CCCCCCCCCCCCCCC(O)CO
+NC(=O)NCCCCC(NC(=O)OCC1c2ccccc2-c2ccccc21)C(=O)O
+CC(CO)CCC(=O)C(C)C1CCC2C3CC=C4CC(O)CCC4(C)C3CCC12C
+COc1ccc(Cn2cnc3c([nH]c4cc(OC)ccc43)c2=O)cc1
+C=C1CCCC2(C)CC3OC(=O)C(CNC4CCCCC4Cc4ccco4)C3CC12
+NC(Cc1c[nH]c2ccc(O)cc12)C(=O)O
+CC1=CC(=O)C2=C(CO)CCC3C(C)C(=O)OC3C12
+CNCCCCCN
+NCCCC(N)C(=O)NCC(=O)O
+COc1ccc(SCc2cnc3nc(N)nc(N)c3n2)cc1OC
+COc1cc(O)c2c(=O)c3c(C)cc(O)cc3oc2c1
+CC(=O)NC(CSNN=C1N=CN=C1C(N)=O)C(=O)O
+N=c1cc2[nH]nccc-2o1
+CSc1cc(=O)n2c3ccccc3c3ccnc1c32
+C=CC(C)=CC(C)C(=O)C=CCC1CC(=O)NC(=O)C1
+COc1ccc(C(=O)CCc2ccccc2)c(OC)c1CC=C(C)C
+CC1CCCC(C)(C)C1=NO
+COC1OC(=O)C2=C1C1(C)CCCC(C)(C)C1CC2O
+COc1ccc(C2NCCc3[nH]cnc32)cc1
+CCC=CCC=CCC=CCC=CCC=CCCCCCC(=O)OC(CO)COC(=O)CCCCCCCCCCCC=CCCCCCCCC
+Cc1[nH]c2ccccc2c1CCNC(=O)c1c(F)cccc1F
+C=C(C(=O)OC)C1CCC2(C)C(=O)C=CC(C)(O)C2C1O
+CCOC(=O)CC(c1ccc2nccnc2c1)c1oc(CO)cc(=O)c1O
+CCOC(=O)CC1CC(C(C)C)C(CNC(=O)C(C)(C)C)C=C1C
+CCN(CC)C(=O)c1ccccc1
+CC1CCCCCCCC(=O)O1
+COc1ccc2nc(CC3CN(Cc4cnc[nH]4)CCC3CC(=O)O)[nH]c2c1
+CC(C=C1CN2CCCC2C(C)(O)C1)CO
+COc1ccc(C(=O)Nc2c(Cl)cncc2Cl)cc1OC
+CCC=CSC
+C=CC=CCC1=C(C)C(O)CC1=O
+CCOc1ccc(NC2=CC(=O)c3ncsc3C2=O)cc1
+CC1=CCCC2(C)OC2C(O)C(C(C)C)CC1
+CCCCCC(O)CC(=O)CCCC(=O)CC(O)CCCCCCCC(O)CC(=O)CCCC(=O)CC(O)CCCCC
+CCCOc1ccc(C(=O)Oc2cc(=O)oc3ccccc23)cc1
+CC(=O)OC1CC2C(C)(C)CCC(O)C2(C)C2CCC3CC12C1OC31C
+CCOC(=O)C(C#N)=Cc1ccc(N(C)C)cc1
+Cc1c[nH]c(=O)[nH]ccc(=O)n(Br)c1=O
+COCC(COC(C)=O)OC(C)=O
+CC(=O)Nc1cccc(Cl)c1Cl
+CC(NC(=O)c1ccccc1)c1c(-c2ccc(F)cc2)noc1C(=O)O
+CCCCCC=CCCCCCCC=CC=CC(=O)NCC(C)C
+CCCCC=CC=CC=CCCCCCCCC(=O)OCC
+CC(C)CC(N)C(=O)NC(CCC(=O)O)C(=O)NC(CCCCN)C(=O)O
+CCCCCCCCCC(=O)CC1C2=COC(CC(C)O)=CC2=CC(=O)C1(C)O
+c1ccc(C2=NOC(c3ccccc3)C2)cc1
+COc1ccccc1CCn1cnc2c([nH]c3ccccc32)c1=O
+Cc1coc2c1c(C)cc1oc(=O)c(CC(=O)NCCN(C)C)c(C)c12
+CC(=O)c1c[nH]c2ccccc12
+N[C@H](C(=O)O)c1ccc(C(=O)O)c(O)c1
+CS(=O)(=O)NCC1OCC(NC2COC2)C1O
+COc1ccc(C=CCC(CO)C(O)c2ccc(OC)c(OC)c2)cc1
+COc1ccc(CNC(=S)NCc2ccccc2)cc1
+COc1ccccc1-c1c(C)oc2cc(OCC(N)=O)ccc2c1=O
+O=C(O)Cc1ccc(O)c(O)c1
+CCCc1oc2c(c(=O)c1CC)C(=O)CC(C)(C)C2
+CC1=CCOC1=O
+CC(=NCCc1ccccn1)c1c(O)n(C)c2ccccc2c1=O
+C1CSCCOCCSCCO1
+Cc1cc2c(c(=O)o1)C(c1ccc3c(c1)OCCO3)CC(=O)O2
+COc1cc(O)c(-c2cc(=O)c3c(O)cc(O)c(OC)c3o2)cc1O
+COC(=O)C1C2CCC(CC1OC(=O)c1ccccc1)N2
+CC(C)=CCC=C(C)C(C)c1c(O)c2c(C)cccc2oc1=O
+OCC=CC#CC#Cc1ccccc1
+CC1(C)C=Cc2c(ccc(-c3cc4ccc(O)cc4o3)c2O)O1
+COC(=O)c1csnn1
+CCCCCC=CCC=CCC=CCCCCCCC(=O)NCCO
+Nc1c(OS(=O)(=O)O)cccc1C(=O)CC(N)C(=O)O
+CC(=O)OC1c2c(C)coc2C(=O)C2C(O)CCC(C)C12C
+COC(=O)CC(c1oc(CSc2ccc(OC)cc2)cc(=O)c1O)C(C)C
+O=C(Cn1ccc2cc(OCc3ccccc3)ccc21)NCC1CCCN2CCCCC12
+CC(C)=CCCC(C)=CCc1c(O)oc2cccc(C=O)c2c1=O
+C=C(CC)C(=O)O
+N#CCCCCC=CCC=CCCCCCCCCCCCCCCc1ccc(C=O)[nH]1
+CC1OC(=O)C=CC(O)C=CC(Cl)C1O
+O=C(O)c1c(O)c(Cl)cc(Cl)c1Cl
+CC(=O)C=CC12OC1(C)CC(O)C(O)C2(C)C
+CC1(C)Cc2ccccc2-c2nnc(-c3cccc(O)c3)n21
+CC(=O)SC(C)SC(C)=O
+COc1ccc2c(c1)nc(CC(C)(C)CC(=O)O)n2Cc1ccc(Cl)cc1
+CC1(C)C2CCC3(C)C(C2)C(C(=O)O)CCC13O
+CC(C)=CC1C(C)CCC2C(C)CCC12O
+Cc1ccc2c(c1)C(=O)c1c(O)cccc1C2=O
+CCCCCCCCCCCC(O)C(Cc1ccccc1)NC(C)=O
+CCOC(=O)C(=O)c1ccc(O)cc1
+CCCCCc1ccc(C(=O)OCC2CCCN3CCCCC23)c(=O)o1
+Cc1ccc(N)c(C)c1
+CCC=CCC=CCC=CCC=CCC=CCCCCCC(=O)OC(CO)COC(=O)CCCCCC=CCC=CCC=CCC=CCCCCC
+CCCCCCCCCCCC(=O)OCC(CO)OC(=O)CCCCCCCCCCC
+COC1(C)CCC2(CC1Br)C(C)=CC(=O)CC2(C)C
+O=C1C=CC2C3c4ccccc4C(c4ccccc43)C2C=C1
+CC=Cc1ccc(OC(=O)Cc2ccccc2)c(OC)c1
+O=C(Cc1ccccc1)NNc1ccccc1
+CN(c1ccccc1)c1nc(Cl)nc(Cl)n1
+O=C(NCCCOc1ccc2nc(O)ccc2c1)N(C1CCCCCCC1)[C@H]1CCCC[C@@H]1O
+CCCCCCC[C@H](CC(=O)O)C(=O)N[C@@H](Cc1ccccc1)C(=O)NC
+CC(=O)NC(COC(C)=O)Cc1ccccc1
+CC(=O)Nc1ccc(OC(=O)c2ccc(Cl)cc2)c(C(C)=O)c1
+COc1ccc(OC)c2c1cc(C(=O)NCc1ccc3c(c1)OCO3)n2C
+CC1=NN(c2ccccc2)C(=O)C1=Cc1ccccc1O
+COC(=O)CC1C(C)=CC(=O)CC1(C)C
+CC1=CCCC(C)CC(=O)C2(C)CC(=O)C(C(C)C)C2CC1
+CCCC[NH+]1CCc2cc(OC)c(OC)cc2C1C
+Cc1ccc(NC=C2C(=O)OC(C)(C)OC2=O)cc1
+Cc1ccc2c(c1)C(=O)c1ccc(O)c(O)c1C2=O
+O=C(O)c1cccc(-c2ccc(F)cc2)c1
+O=C(NC(=O)C(F)(F)F)Nc1cc(Cl)ccc1Cl
+Cc1cc2c3ccccc3[nH]c2c2c[n+](C)ccc12.[I-]
+COc1c(C)c(O)c2c(c1C)COC2=O
+OC1COCCN(c2nc3ccccc3o2)C1
+O=C(C=Cc1ccc(Cl)cc1)c1cc(F)ccc1O
+CCOc1ccc(-c2cc(=O)c3cc(O)ccc3o2)cc1
+CN1C(=O)NC(=Cc2ccc([NH+]([O-])O)cc2)C1=O
+CCCCCCCC(O)C(O)CC#CC#CC(=O)CC
+CC(C)=C1C(=O)C=C2CCC(O)C(C)C2(C)C1O
+CCC(=NNC(N)=O)C1CC2(C)CCC1C2(C)C
+O=C1CCCCC1(O)CCO
+O=C(Cn1cnc2ccccc2c1=O)NC(Cc1ccc(O)cc1)C(=O)O
+C=C(C)C(O)COc1ccc2ccc(=O)oc2c1
+[O-][NH+](O)c1cc(-c2cn3ccccc3n2)ccc1I
+CCCCCC=CCC=CCCCCCCCC(=O)OCCCCCCCCCCCCCCCCCCCCO
+CCC=CCC=CCCCOS(=O)(=O)O
+CCCCC(C)C=C(C)C(=O)CC
+CCCCCCCCCCCCCCCCCCCC(=O)OCC(O)COP(=O)(O)OCCN
+CC(=O)C1(CCC(C)CCO)C(O)CC2C(C)(C)C(O)CCC21C
+CC(C)=CCCC(C)=CCOc1ccc(C=C2C(=O)N(O)C(C)C(=O)N2O)cc1
+C=C1C(=O)OC2C1CC=C(C)C1CC=C(C)C12
+CC(NC(=O)Cc1ccccc1)c1onc(-c2ccc(F)cc2)c1C(=O)O
+O=C(c1ccc(O)cc1)c1oc2cc(O)ccc2c1-c1ccc(O)cc1
+O=C1N[C@@H](Cc2ccccc2)C(O)[C@H](Cc2ccccc2)N1
+NCCC1=CC(C(C=O)CCCCCC(CC=CCCC(=O)O)Cc2ccc(O)cc2)CC1
+O=C(NNC(=O)c1ccc([NH+]([O-])O)cc1)Nc1ccccc1
+CCC1CN(C(=O)c2ccccc2)CCC1CC(=O)N1CCC(O)CC1
+c1ccc(-c2ccnc(NC3COC4C(NCC5CCCCC5)COC34)n2)cc1
+O=c1[nH]c(=O)n(C2CC(O)C(CO)O2)cc1F
+CC(O)C1CCC2C3CC=C4CC(N)CCC4(C)C3CCC12C
+CC1(C)COC(c2ccccc2Br)=N1
+Nc1c2c3c(cccc3[nH]c1=O)C(=O)c1ccccc1-2
+CCCCCCCCCCCCCCCCCCC(C)CCCCCCCC(C)C(C)=O
+CC(O)CCOC(=O)c1ccccc1C(=O)O
+CCC(C(=O)O)C(C)C
+CCCCC12CN3CC(C)(CN(C1)C3c1ccco1)C2=O
+O=C1C(CO)=CC(=O)c2c1cc1ccccc1c2O
+O=C(O)c1cc(Cc2c(O)ccc3ccccc23)ccc1O
+CCC(C)C1OC1(C)C1(O)C(C)=CC2CC(CO)=CCC2C1C=CC=CC=CC(=O)O
+O=C1c2ccc(O)cc2OCC1(O)c1ccc(O)cc1
+COC(=O)c1cc2ccccc2c(O)c1C(=O)OC
+CC(C)NC(=O)NCC1OC(CO)C(O)C1N(C)CCN(C)C
+CCCCCCCCCCCCC=CC(O)C(COC1OC(CO)C(O)C(O)C1O)NC(=O)CCCCCCCCCCCCCCCCCCCC
+COc1ccc(CNC(=O)CC2CCNCC2Cc2cc(CN(C)C)on2)cc1
+COc1ccc2c([nH]c3cc(O)c(C=O)cc32)c1CC=C(C)CCC=C(C)C
+Cc1nc2ncccc2c(=O)n1CCNC(=O)c1ccc2c(c1)OCO2
+C=CC(C)(O)CC(O)C=C(C)CC(O)C=C(C)C
+CC(=CC(O)C(=O)O)C1CC(=O)OC1(C)C
+C=C(C(=O)OC)C1CCC(C)(OCC)C2CC(O)C(C)=CC12
+CCCCCC(O)C=CC1CCC(=O)C1CCCCCCC(=O)NCCCN(C)C
+CS(=O)(=O)N1CC(F)C(OCc2nc3ccccc3o2)C1
+O=S(=O)(c1cccc([NH+]([O-])O)c1)N1CCCCC1
+COc1ccc2c(c1O)-c1ccc(O)cc1CC2
+CNCCCC(=O)c1ccc(O)nc1
+c1ccc2c(c1)-c1nc3ccccc3nc1-2
+CC(=O)OCC(=CCCC(C)=CCO)CCC=C(CCC=C(C)C)C(=O)O
+CC(=CC(=O)O)CCC1(C)C(C)CCC2(C)C(C)=C(C=O)CC21
+CCOC(=O)C1COC(=O)C2C1CCC2(C)O
+Cc1ccc(Br)c(N)c1
+CC(=O)OC1CC(C)(O)C2=CCC(C)=C2C2OC(=O)C(C)C12
+CCC1(C)CC(CCNCc2ccccc2)(C(C)C)CCO1
+COc1cccc2c3c(c(=O)n(C)c12)CC(C(C)C)O3
+O=C(NC1COC2C(Nc3nccc(C4CCCC4)n3)COC12)N1CCOCC1
+COc1cc(C2Cc3cc(O)cc(O)c3C(=O)O2)ccc1O
+CC=C(C)C=C(C)C(O)C(C)C(=O)CCC
+CCCCC=CC=CC=CCCCCCCCC(=O)OCC(O)CO
+CC1=CC(=O)CC(C)(C)C1CO
+COc1ccc(-c2[nH]nc(C)c2-c2ccc(OC)c(O)c2)c(O)c1
+COC(=O)C1=CC2C(O)C(C)(C)CC23C1COC(=O)C31CO1
+CC(CO)Cc1cc(O)c(O)c(Br)c1Br
+Cc1ccc(C(C)C)o1
+CCCCCCCC1CCCC(=O)NCCCN(O)CCCCNCCCN1
+CCCCC=CCCCC=CCCCCC=O
+O=C(CCC(O)Cc1ccccc1)OC1OC(C(=O)O)C(O)C(O)C1O
+O=C(O)C1C2C=CC3(CN(c4ccccc4)C(=O)C13)O2
+CCCCCCCCCCCCCC=CC(O)=C(O)C(=O)O
+CC(=CC(=O)O)CCC=C(C)CCC(=O)O
+CC(=O)N(CCC(Cc1ccccc1)c1ccco1)C(C)c1ccccc1
+O=c1ncncn1C1OC(CO)C(O)C1O
+COC1=CC(=O)C2=C(CCc3cccc(O)c32)C1=O
+Clc1ccc(-c2cn3cc(I)ccc3n2)cc1Cl
+CCCCCCCCCCCCCCCC(OC(C)=O)C(CO)NC(C)=O
+NC1COC2C(OC(=O)Nc3ccccc3)COC12
+CCCCCC(O)CC(CC(=O)O)OC1OC(CO)C(O)C(O)C1O
+CCCCCCCCCCCCCCCCCCCCCCCCCCCC(=O)NCCc1c[nH]c2ccccc12
+COc1ccc(-c2noc(C3CC(NCC4CC4)CN3C)n2)cc1
+CC=CC1=CC(O)C(O)C1=O
+CCCCCC(O)CC(CCc1ccc(O)c2c1CCC1CCCC1O2)OC(C)=O
+S=C(Nc1ccccc1)NN1c2ccccc2CCc2ccccc21
+CC1=CCCC2(C)OC2CCC(C)=CC2OC(=O)C(C)=C2CC1
+CNCCc1cc(O)c(O)c(O)c1
+CC1(C)CC2CC(C)(O)c3cocc3C(O)C2C1
+O=C(CC1(n2cccc2)CCOCC1)NCC1CCCN2CCCCC12
+CCCCCCC(=O)C=CC=CC(O)=NCC(C)C
+CCCCCCCCCCCCCCCC(=O)NCC
+CCCCC#CC#CC#CCCCCCCCCCC(=O)O
+O=C(Cl)CCc1ccccc1
+O=C1CCC(=O)NCCCCCN(O)C(=O)CCC(=O)NCCCCCN(O)C(=O)CCC(=O)NCCCCCN1
+O=C(O)C1CC(O)CN1C(=O)C1CCCN1
+CC(=O)OCCCC=CC=CC#Cc1cccs1
+COc1ccc(NCCNC(C)=O)c2c1C(=O)c1ccccc1C2=O
+COc1ccc(C=CCOC(=O)CCCCCCCC=CCC=CCCCCCO)cc1OC
+COc1cc(O)c(Cc2ccc(O)cc2)c(CCc2ccccc2O)c1
+COc1c2c(cc3c1C1C(OC3OC)C(O)C=C3CCN(C)C31)OCO2
+CCCCC/C=C\C/C=C\C/C=C\C/C=C\CCCC(=O)OCc1ccco1
+COC(COC(C)=O)C(OC)C(O)C(CO)OC(C)=O
+CCCCCCCCCCC=CCCC(=O)O
+CC(C)=CCCC(C)=CCCC1(C)OC1Cc1c[nH]c([NH+]([O-])O)c1
+CCCCCC(=O)CC(=O)C=Cc1cc(CCO)c(O)c(OC)c1
+CC(C)=CCO
+COc1ccccc1CCO
+COc1ccc(CC(C)C(C)Cc2cc(O)c(OC)c(O)c2)cc1OC
+CC(=O)N1C(=O)C2CCCN2C(=O)c2ccccc21
+CN1Cc2sc(Br)cc2C(c2ccccc2)C1
+CCCCC1(CCCC)C(=O)NC(=O)N(C)C1=S
+COc1ccc(NCC(=O)CC(c2ccccc2)C2CCOC(C)(C)C2)cc1
+CC(C=CC1(O)C(C)=CC(O)CC1(C)CO)=CC(=O)O
+COC1COCCN(Cc2cn(C)c3ccccc23)C1
+CSCCC(NC(=O)CCn1ccc2cc(OCc3ccccc3)ccc21)C(=O)O
+CCCNC1CCc2nc(N)sc2C1=O
+C=C(C)C1CCC2(C)CC(=O)C=C(C)C2C1
+COC1C=C(C)CC(=O)C2(O)C(CC2(C)C)C(CO)=C1
+NC1C2COC(O2)C(Sc2ccccc2)C1O
+CCCOC(NC(C)c1ccc(OC)c(OC)c1)OCCC
+COc1cc(C(C)=CC(C)=CC(=O)O)oc(=O)c1CO
+CCCCc1oc2ccccc2c1C(=O)c1ccc(OCCC[N+](C)(C)C)cc1
+C=C(C)C12C=C3CCC4C(C)(C(=O)O)CCCC4(C)C3(CC1)OO2
+C#CC(O)C=CCCCCCCCCCCCCC=CCCCCCCCCCCCCCCC(O)C#CC#CC#CCO
+CCCCCCCCCOc1ccc(C=Nc2ccc(CCCC)cc2)cc1
+COc1cc(O)c2c(-c3cc(O)ccc3O)cc(=O)oc2c1
+O=C(NCCNC(=O)c1c[nH]c2ccccc12)c1c[nH]c2ccccc12
+CC(C)=CCc1c(O)c(O)c2c(c1CC=C(C)C)C(=O)C1C(O)=CC=C(O)C1O2
+CC=CC=CC(=O)C=CC1OC(=O)C(C)C1O
+C=CCNc1nnc(SCC(=O)N2CCN(c3ccccc3Cl)CC2)s1
+CC(C)NC(=O)CC1CC2OC(CNC(=O)N3CCOCC3)C(O)C2O1
+CC(C)C(CC(=N)O)c1ccco1
+CCCS(=O)(=O)N1CCC(C(=O)N(C)C)CC1
+CC1=CCC(C(C)(N)CC=CC(C)(C)O)CC1
+Cc1c(Br)cc2c(c1Br)OC1(CO)CCC2(C)C1C
+O=C(CC1OC(CNC(=O)c2ccccc2)C(O)C1O)NCCN1CCOCC1
+C=C1C(OC(C)=O)CC(C(C)CCC=C(C)C)C2OC12
+CC(C)=CCOc1cc(O)c2c(c1)OC(c1ccc(O)cc1)C(O)C2=O
+CCCC(=O)N[C@@H](Cc1ccc(O)cc1)C(=O)NCCCCCCCCCCCN
+C=C1CCC2(C)CCC(O)C(C)(C)C23CC13
+Cc1ccc2c(c1)OC(c1ccc3c(c1)OCCO3)CC2=O
+CCCC(C)c1cccc(CC)c1O
+CC1(C)CC2C(O)C(O)C3=CCC3(C)C2C1
+CCC12C=CCN(CCc3c([nH]c4ccccc34)C(C(=O)OC)C1)C2
+COc1cccc2c1[NH+]([O-])c1cccc(O)c1[NH+]2[O-]
+CC(=O)OC1(C(C)=O)CCCCC1
+O=C(NCCS(=O)(=O)O)C(=O)c1c[nH]c2ccccc12
+COC(=O)C1=C(C)NC(=O)NC1c1ccc(Cl)cc1
+CC1=CC=CC(C)(C)C=C1
+CCCCCc1cc(O)cc(O)c1C(=O)OCC
+CC(=O)c1ccc(OCC(=O)NC(c2ccccc2)c2cccs2)cc1
+COc1cc(O)c(C)c2cc(C)ncc12
+CC=CCCC1Cc2cc(O)c(CC=CC)c(O)c2C(=O)O1
+Cc1ccc(NC(=O)C2CCC(=O)N2C2OC(=O)c3ccccc32)c(C)c1
+CC1(C)CCCC2(C)C3=C(CCC12)COC3=O
+COc1c(C)cc2c(C(C)C)cc(=O)oc2c1O
+COc1c2c(c(Br)c3c1C(=O)N(C)CC3)OCO2
+CC1CC2CC(=O)C3(O)CCCN4CCCC2(O)C43C1
+COc1ccc(-c2cc(C=CC=O)ccc2O)cc1C=CC=O
+CC=CC=CC#CC=CCOC(C)=O
+CCCCCCCCn1sccc1=O
+C#CC=CC(O)CCCCCCCCCCCCCC=CCCC=CC#CC(O)C#CCCCCC=CCCCCCCC=CC(O)C#C
+O=C(O)CCCCCCCCCCCCCCCCCCCCCCCO
+COC(=O)c1occ2c1C(C)(O)C1CC(C)(C)CC1C2O
+CC(C)n1cc(CCC(=O)Nc2ccc(C(N)=O)cc2)c2ccccc21
+CC12CN3CC(C)(CN(C1)C3c1cccc3[nH]ccc13)C2=O
+CCCCCCCCCCC(=O)C1(O)C(OC(C)=O)C=CC1OC(C)=O
+CNCC(C)Cc1ccc2c(c1)OCO2
+CC(C)(C)NC(=O)NC1CC(CO)C(O)C1O
+Nc1c(Cl)cccc1-c1c[nH]c(C(=O)O)c1
+COc1ccc2c(c1)CN(C(=O)NC(C)C)CCC1COC(=O)N21
+CC(C(O)CC(=O)O)C1CCC2C3C(O)CC4CC(O)CCC4(C)C3CCC12C
+CCC1c2ccc(C)n2CCN1C(=O)Nc1cc(OC)ccc1OC
+O=C(O)CC(NC(=O)CP(=O)(O)O)C(=O)O
+CC(C)C(NC(=O)Nc1ccc(OC(F)(F)F)cc1)C(=O)O
+CCCCCCC(=O)CCCCCCCC1CCC(=O)O1
+Cc1coc2c1C(OC(=O)CC(C)C)C1(C)C(C)CCCC1C2=O
+NC(=O)c1ccccc1NC(=O)CC(CN1CCCC1)C(=O)O
+CC(C)CCCCCCC#CC=COCC(O)CO
+O=C1C(=Cc2ccccc2)Oc2c1ccc(O)c2CN1CCCCC1
+CCCCC(Br)=CC(=O)O
+O=CC(O)CS(=O)(=O)O
+C=C1CCC2C(C)(C(=O)O)CCCC2(C)C1CCC(C)(O)CC(=O)O
+C=CC1(C)CCC2(C)C(CCC3(O)C2CCCC3(C)COC(C)=O)C1
+CO[C@@H]1CCOP(=O)(NCCCl)N1CCCl
+CC(O)C(=O)CCC(=O)OCCc1ccccc1
+CC=CC#CC#CC=CC=CCCCCC(=O)OC
+CCCCCCCCCc1ccc(Oc2ccc(C)cc2CC(=O)O)c(Cl)c1
+C[C]1[CH][CH][C](C(=O)C[NH+]2[CH][C](C)[CH][CH][C]2N)[CH][CH]1
+CC(=O)OC1C2CC(CC(=O)O2)OC1c1ccccc1
+CN(C)CCOc1cc2c(c3ccccc13)-c1ccc(O)cc1C2=O
+Cc1c(C)c2c(cc(C)c3c(C)coc32)oc1=O
+CC1=C2C(O)CC2(C)C2CC(C)(CO)C=C2C1=O
+COc1cc2oc(=O)ccc2c2c1C=CC(C)(C)O2
+COC(CN(C)CC1C(=O)OC2CC3(C)CCCC4(CO4)C3CC21)OC
+CC1=CC(=C(c2ccc(N)cc2)c2ccc(N)cc2)C=CC1=N
+CC=C(C)C=C(C)c1oc(=O)cc(OC)c1C
+COC(C)=C1C(=O)C=CC1=O
+C=C1C(=O)OC2C1C(OC(=O)C(C)=CC)CC(CO)C1CC=C(C)C12
+CC=Cc1cc(O)c(C(O)C(O)C(C)O)c(=O)o1
+CCCCCC/N=c1\ccn(Cc2ccccc2)c2c(OC)cccc12
+CCCCCCCCC=CCCCCCCCC(=O)NCc1ccccc1
+COc1cc2c(cc1OC)C1C(CC=C3CCN(C)C31)OC2
+O=C(C=Cc1ccccc1)OC1C(O)OC(CO)C(O)C1O
+CN(C)CCCCN(C)C
+CCc1cc2c(=O)c(-c3ccc(Cl)cc3)coc2cc1O
+COc1ccc2nc3n(c2c1)C(CNC(C)C)COC3
+CC(C)NCC(O)COc1cccc2ccccc12
+Cc1ccc(OCCNC(=O)C(=O)NCCC(C)C)cc1
+O=c1cc2[nH]ccn2cn1
+CC(CCCCCCCCCCCCCC=CC(=O)O)OC1OC(C)C(O)CC1O
+Oc1[nH]cc2nnccc12
+CC#CC#CC#CC=CC=CCCCC=O
+CCC1CCCCC1C
+CC1=CCCC(C=O)=CC2CC2(C)C(O)CC1
+Oc1ccc(-c2nnc3n2NC(c2ccco2)S3)cc1
+CC1=CCCC2=CC(CC(CO)=CC=C(C(C)C)CC1)OC2=O
+CC=C(C)C(=O)CC
+COC1=CC(=O)C(C)=C(OC)C1=O
+CCCCCC=CCC=CCC=CCCCCC(=O)OCC(O)COP(=O)(O)OCCN
+COC(=O)c1c(C)oc2cc(Br)c(OCc3ccccc3Br)cc12
+CC=CC#CC#CC=CCOC(C)=O
+O=C(O)CC(NC(=O)c1ccccc1NC(=O)c1ccccc1)C(=O)O
+CC(C)(C)CC(C)(C)c1ccc(O)c(Cc2ccc(Cl)cc2Cl)c1
+CN(CC1CCCN2CCCCC12)C(=O)CCCc1nc(-c2cccnc2)no1
+COc1ccc(Oc2oc3cc(O)cc(O)c3c(=O)c2O)cc1
+CC(C)=CCc1c(O)cccc1C(=O)c1c(O)cc(O)c(CC=C(C)C)c1O
+O=C(O)Nc1ccc(Cl)cc1
+COc1ccc(O)c(-c2cc(=O)c3c(O)cc(O)cc3o2)c1
+O=C(OCC1CCCN2CCCCC12)c1ccc2c(c1)OCO2
+COC(=O)C1C[C]2[NH2+][CH]N(C)[C]2CN1C(=O)CCC(=O)[O-]
+C=C1C(O)CCC(CC(=O)c2cc(O)ccc2O)(C(=O)O)C1O
+COc1ccccc1N1CC(C(=O)Nc2ccc3oc(=O)ccc3c2)CC1=O
+CCC(O)C=CC1C(O)CC(=O)C1CC=CCC=CCC=CCCC(=O)O
+CC1=CC2OC3C(O)C(O)C(C)(C2(CO)CC1O)C31CO1
+CC(C)C(N)C(=O)N1CC(O)CC1C(O)C(=O)O
+CCOC(=O)Cc1nc(-c2ccc(Cl)cc2)oc1-c1ccc(Br)o1
+Oc1ccc2cccc(N3CCNCC3)c2c1
+CC(C)CC1c2cc(O)c(O)cc2C=C2c3ccc(O)c(O)c3CCC21
+CN(C=Cc1ccccc1)C(=O)C=Cc1ccccc1
+O=C(O)C(Cl)=CCl
+CC12CCC(C(=CN(O)c3ccccc3)C1=O)C2(C)C
+O=C1CC2(CCCCC2)Oc2ccc(O)cc21
+O=C(O)CCCNC(=O)OCc1ccccc1
+CC(C)=CCCC(C)=CCCC(C)=CCCC(C)=CCC1(CC(=O)O)CC(=O)C=CC1=O
+Cc1cccc(OCC2CC(NC(=O)Nc3ccccc3)C(O)C2O)n1
+CC1(O)Cc2cccc(F)c21
+CC1C(OC2OC(CO)C(O)C(O)C2O)CC2(C(C)C)CC12
+CN1CCCC(n2nc(Cc3ccc(Cl)cc3)c3ccccc3c2=O)CC1
+O=C1CN(C(=O)NC(Cc2ccccc2)C(=O)NC(CO)C(=O)O)c2ccccc2N1
+CCOC(=O)c1c(C)n(C)c2c1cc(O)c1occ(C)c12
+COc1ccc2oc(S(N)(=O)=O)cc2c1
+NC(=O)NC(=O)Nc1ccccc1Cl
+C=C(c1ccccc1)c1ccccc1
+C#CCNC(=O)C1CCCN1C(C(=O)NC)c1ccccc1
+CNCC(C)CN1c2ccccc2Sc2ccccc21
+C=CC1(CO)CCC2(C)C(CCC3(O)C2CCCC3(C)C)C1
+C=C1OC(=O)C(CCCCCCCCCCCCCc2ccc3c(c2)OCO3)C1=O
+CNC(=O)OCc1c(COC(=O)NC)c(C)n(-c2ccccc2)c1C
+CCCOc1ccccc1-c1nc2nc[nH]c2c(=O)[nH]1
+CCC1CN(C(=O)c2ccc(F)cc2)CCC1CC(=O)NCCO
+NC(=O)NC=C(C=O)c1ccccc1
+COc1cccc(CN2CCN3C(=O)N(c4ccccc4)CC3C2)n1
+COc1ccc2c3c1OC1CC(O)C=CC31CCNC2
+CC(C)CCCCCCCCCCCCCCCCCCCC(O)CO
+COC(=O)C1=CC2CC(C)(C)CCC(C)(O)C2CC1
+CC(=O)N1CC2CN(C(C)C)CCN2C(C)(CO)C1
+CC(C)NC(=O)C1CN2CCC1CC2Cn1cc(CO)nn1
+CON(C)CCCCCCCCCCC=CC#CCCCCC1=CC=C[NH+](C)C1
+C=NC1(C)CCC2C(C)CC3CC(C)(C)CC4=C3C2C1CC4
+CCc1cn(C2OCC(O)C2CO)c(=O)nc1O
+CCC=CC#CC#CC=CCCC(=O)CCOC1OC(CO)C(O)C(O)C1O
+NCCCCCNC(=O)C(Cc1ccc(O)cc1)NC(=O)C1OC1C(=O)O
+COc1cccc(I)c1O
+CC#Cc1cn(C2OC(CO)C(O)C2O)c(=O)[nH]c1=O
+CCCCCCCCCCC(=O)CCCC(=O)OC
+O=C(NN1CCC=C(CCCO)C1)c1ccccc1
+CC=CC#CC#CC=CCOC(=O)C(C)=CC
+COc1cc2c(cc1OC)C(=O)C(=Cc1cccnc1)C2
+NC(=S)NN=Cc1ccccc1O
+CC1(C)C2CCC3(C)C(C=CCC13O)C2
+CCOC(=O)C=Cc1ccc(OC2OC(CO)C(O)C(O)C2O)c(OC)c1
+Nc1cc([NH+]([O-])O)ccc1Cl
+COc1ccccc1C
+CC1=CC(=O)C2(C)CC(=O)C(C(C)C)C2CCC(C)=CCC1
+CC1CC2C=CC3(O)COC(=O)C3(C)C2CC1O
+CCC=CCC=CC=CC(O)CCCCCCCC(=O)OC
+CCC1(C)CC(CCNCc2ccc(OC)c(OC)c2)(CCC(C)C)CCO1
+CCCCCCCC(O)CCCCCCCCCCCCCCCCCCCCCCCC(C)CC
+Oc1cc2c(cc1O)C(c1ccco1)=NCC2
+COc1cc(CC(C)NCC#N)c(OC)cc1I
+CC(C)NC(C)C(O)COc1ccc(Cl)c(Cl)c1
+O=C(O)C(=O)CC(=O)c1ccc(Cc2ccc(Cl)c(Cl)c2)cc1
+CC(=O)OCCC(C)OC(C)=O
+CC1(C)CCCC2(C)C(CO)=CC1C2CCO
+COc1cc(O)c2c(c1C)C(C)(O)C(C)OC2=O
+CC(C)(O)C(NC(=O)C(CS)NC(=O)CCCC(N)C(=O)O)C(=O)NCC(=O)O
+CC1CC2OC(=O)C(C)C2CC2(C)C(O)OCCC12
+CCCCCCCCCCCCCCCC(=O)N1CCc2c([nH]c3ccccc23)C1C
+CC(C)=CCCC(C)(O)C1CC=C(COC(=O)c2ccco2)CC1
+CCn1c(C(=O)NCCc2c[nH]c3ccccc23)cc2sccc21
+COc1ccc(NC(=O)N2CCC(CO)N(C)c3cccnc3C2)cc1
+C#CC(O)C=CCCCCCCC#Cc1ccc(C#CCCCCCCC=CC(O)C#C)o1
+Cc1csc(C)c1
+COc1cc(C=CCO)ccc1Oc1ccc(C(O)C(O)CO)cc1OC
+COC(=O)CNC(=O)c1ccccc1
+CCCCCCC(=O)C=CC(=O)CCCCCCCC(=O)O
+Cc1cc(C)c2oc(=O)cc(CN3CCCCC3)c2c1
+COc1cc2c(cc1C(=O)COC(C)=O)C=CC(C)(C)O2
+CN1CCc2cc3c(c(OCC(N)=O)c2C1=O)OCO3
+CC(=O)OCC1(C)CCCC2(C)C1CCC1(C)OC(CO)(C(O)CO)CCC12
+CC(C)=CC(=O)OCC=CC=CCCC=CC(=O)NCC(C)C
+OC1CCCOC1C=CC#Cc1cccs1
+CC=C1CC2CCC(C)C1(C)C2(C)C
+NC(=O)C(=Cc1ccc(Cl)cc1Cl)c1nc2ccccc2s1
+O=C(O)c1ccccc1C1C(=O)c2ccccc2C1=O
+CCCCCCCCCCCc1cc(=O)c2c(O)cccc2o1
+CC(O)C#CC1(C)CCCC(C)(C)O1
+CC(C)CC/C=C(\NC(=O)C1CC1(C)C)C(=O)O
+CC(C=CC(=O)O)C1CCC2C3C=CC4=CC(=O)CCC4(C)C3CCC12C
+CCc1cn(CC(NC(=O)c2ccco2)C(=O)O)c(=O)[nH]c1=O
+CC=CC(=O)OC1C=CC(C)OC(=O)CCC(OC(C)=O)C1O
+CC(C)CCCOC(=O)CCC(C)C
+CC1(C)C2C=CC(O2)C(Cl)C1O
+NCC(=O)Oc1c(-c2ccc(O)cc2)oc2cc(O)cc(O)c2c1=O
+CC=CC(N)=S
+C=Cc1c(N)ccc2cnccc12
+COC(=O)c1ccccc1NC(=O)NCCC(C)C
+CC(=O)C(O)Cc1ccc(O)cc1
+CC(=O)OC1(C(C)C)CC=C(C)C2CCC(C)=CC21
+NCC(O)P(=O)(O)O
+O=C1C(=Cc2ccc(O)cc2)C(=O)c2ccccc21
+COc1cc(-c2cc(=O)c3ccccc3o2)cc(I)c1OC
+N#Cc1ccc(Cn2ccnc2)cc1OCCc1ccc(-c2ccccc2)cc1
+COc1ccc(C(=O)OCc2cc3cc(OC)ccc3nc2O)cc1
+NC(=O)[C@H](Cc1ccccc1)NC(=O)Nc1nnc(S)s1
+CN(C)CCN(C)CC1CN2CCC1CC2CNC(=O)c1ccccc1
+CCCCCCCCCCCCCCCC(O)CCO
+COCC(=O)NC1C(c2cccs2)N(CCC(C)(C)C)CCC1(C)O
+C=C(C)C(=O)OCCOP(=O)(O)Oc1ccccc1
+CC(=O)NC[C@@H]1OC(=O)N2c3ccc(-c4ccccc4)cc3C[C@@H]12
+COc1c2c(cc3c1C(Nc1ccncc1)N(C)CC3)OCO2
+C=CCOc1ccc2c(C)cc(=O)oc2c1OCC=C
+C#CC(O)C=CCCCCCCCCCCCC#CCCCCCCCCCCCC(O)C#CC#CCO
+CNCC(O)CN1CCc2c(Br)cccc2C1
+COc1ccc(-n2cc(C(=O)O)c3c2C(c2cccnc2)CC(=O)N3)cc1
+CC(NC(=O)C1CC1)c1c(-c2ccc(Cl)cc2)noc1C(=O)O
+CCNc1c(C=O)c(=O)oc2ccccc12
+COc1ccc(NC2OC(=O)c3c2ccc(OC)c3OC)c(OC)c1
+O=C(Cl)CCC(=O)Cl
+O=C(O)C=CCCCCCCCCCC=C(Br)Br
+O=C(O)Cc1cc(O)cc(O)c1O
+CC1=CCC(C(C)CCC(O)C(C)(C)O)CC1=O
+CCOC(CNC(=O)c1cc(Br)c(Br)[nH]1)CC(=O)OC
+COc1c(O)ccc(CCC(=O)CC(O)CC(C)CCCO)c1-c1ccc(CN)cc1
+Cc1[nH]c2ccccc2c(=O)c1C(=O)C=Cc1ccccc1
+C/C=C(\NC(=O)CCCCCC)C(=O)O
+COc1c(O)cc2c(c1O)C(=O)c1ccccc1C2=O
+COc1ccc(C(=O)c2nccc3cc(OC)c(OC)cc23)cc1
+CC1=C2COCC(C)C2CC1O
+CCC(C)C(C)C(O)CN
+C=C(C)C1CCC2(C)CC(Br)CC(C)C2(O)C1
+C[C]1[CH][C](C)[C]2CCCC[C]2[NH2+]1
+COc1ccc(Cl)cc1C(=O)C=Cc1ccc(F)cc1
+O=C(OCC1CCCN2CCCCC12)c1cc2ccccc2oc1=O
+CCCNC(=O)NC1CC(O)(C(=O)NCC(N)=O)CC(O)C1O
+Cc1cc(C=C2C=CC(=O)O2)oc1C
+CC(=O)OCC1=C(C(=O)O)N2C(=O)C(NC(=O)C=Cc3ccccc3)C2SC1
+COC(=O)C1SCC(NC(=O)c2ccccc2)C1OC(C)=O
+NS(=O)(=O)c1ccc(NC(=O)CNCC(=O)O)c(Br)c1
+CC1CCCC2CCCCC12
+CCC(=O)c1cn(-c2ccc(F)cc2)c2ccc(Cl)cc12
+COc1cc(OC)c2c(c1)C(=O)c1cccc(O)c1C2=O
+COC(=O)c1cccc(Nc2nc(NCCO)c3ccccc3n2)c1
+O=S(=O)(O)OC1C(Oc2ccc(O)cc2)OC(CO)C(O)C1O
+CCN(CC)CCN=C(O)COc1ccc(OC)cc1
+CC1=CC(=O)C(C(C)CCC(O)C(C)(C)O)CC1
+O=C(Nc1ccc(OCCN2CCCC2)cc1)C1(c2ccccc2)CCOCC1
+CN1C(=O)c2ccccc2NC(=O)C12OC2c1ccccc1
+CC(=O)N[C@@H](CC(C)C)C(=O)O
+COc1ccc2oc3cccc(O)c3c(=O)c2c1
+O=C(Nc1cccc(C(=O)O)c1)NC(Cc1ccccc1)C(=O)O
+CN(C)CCc1c[nH]c2ccsc12
+C=C1C(O)CC2C(C)(C)CCCC2(C)C1CCC(C)=O
+COC(=O)c1ccccc1NC(=O)N1CCc2nc[nH]c2C1c1ccc(OC)cc1
+O=C(O)c1ccc2c(c1)OCO2
+O=C(NCCOC(=O)Nc1ccccc1)Nc1ccc(Cl)c(Cl)c1
+COc1c(O)cc2cc3c(c(O)c2c1C)C(=O)CC(O)C3
+NC(C(=O)O)c1ccc(C(=O)O)cc1
+CCCCCCCCC1C2C=CC3(O)C(C(=O)O)=CC(O)C4CC1C2C43
+O=c1cccc2n1CC1CCCN3CCCC2(O)C13
+CCCCCCCCCCCCCCCCC(C)CCCCCC
+COC(OC)C1(C)CCCC2(C)c3cc(O)c(C(C)C)cc3CCC21
+Cc1ccc(C(=O)NCC2OC(CC(=O)N3CCC(C)CC3)C(O)C2O)cc1
+CC1=C(O)C(=O)C23C(=O)C1C(C)(C)C2CCC3C
+O=C(O)C1OC(OCC2OC(O)C(O)C(O)C2O)C(O)C(O)C1O
+COc1ccc(CN2C(=O)NC(CC(=O)NC(CO)CCSC)C2=O)cc1
+c1ccc(-c2cc3c(cn2)CCCC3)cc1
+CC1=CCC2=C(C)CC(OC(=O)c3ccc(O)cc3)C(C(C)C)CC12
+CCC1CC2(CC)OC(=O)C3(CC)OC(=O)C1C23
+CC(=O)OCC1=C(C(=O)O)N2C(=O)C(NC(=O)Cc3ccccc3)C2SC1
+Oc1cccc2c1ccc1c3ccccc3ccc21
+CCCCCCCCCCC(=O)NCC(=O)O
+O=C(CCCCC1CCSS1)N1CCCC1c1nnc2ccccn12
+ClCCOC1CCCN(Cc2ccccc2)CO1
+COc1c(O)ccc2c1CC(O)C(c1ccccc1)O2
+Nc1nc(N)c2c3c(oc2n1)CN(Cc1ccccc1)CC3
+CCC12CCCN3CCC4(c5ccccc5NC4C(C(=O)O)C1)C32
+CN1c2ccccc2C(C)(C)C1O
+COC(CCC=CCCCCC(=O)CCCCCCC(=O)CCC=CCCCCCCO)C(=O)NCCc1ccc(O)cc1
+CCC=CCC=CCC=CCC=CCC=CCCCCCC(=O)OCC(CO)OC(=O)CCCCCCCC=CCCCCCCCC
+CCOC(=O)c1c(C)oc2ccc(OC(=O)c3ccc(Br)cc3)cc12
+CC(=O)CC1=C(C)C(=O)c2c(O)cc(O)cc2C1=O
+COc1cc(CCCCCCCCC(=O)c2c(O)cccc2O)ccc1O
+COc1cc2c(cc1OC)CC(=O)N(CC(=O)NCCn1ccc3ccccc31)C=C2
+CCCc1cc(OC)cc(O)c1C(=O)O
+C=C1CCCC2C1(C)CCC(C)C2(C)CC1=CC(=O)C=C(N)C1=O
+COc1cccc2c1CC(Cc1ccncc1)C2
+COC(=O)Cc1c(C)c2ccc(OCC=C(C)C)cc2oc1=O
+C=CC=CC=CC(O)C(C)O
+CCC1C(=O)Nc2cc3[nH]c(-c4cccnc4)nc3cc21
+C=C1C=C(CCC(=O)O)C(=O)OC1C=CC=CC
+O=C(NC1C(c2ccccc2)CC(O)C1O)c1cccnc1
+Nc1cccc2c1ccc1ccccc12
+Cc1ccc(C)c(Cl)c1
+CNCc1cn(CC2OC(CC(=O)N3CCCC3)C(O)C2O)nn1
+COC(=O)C(C)(C)CCCOc1ccc(C)c(OCCCC(C)(C)C(=O)OC)c1
+CC(C)(O)c1cc(CC2(N)COC2)no1

benchmark/latent_visualization_legacy.py

@@ -0,0 +1,723 @@
+#!/usr/bin/env python3
+"""
+Latent Space Visualization for Molecule VAE Models
+Integrated with existing benchmark pipeline structure
+"""
+
+import os
+import time
+import random
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from matplotlib.colors import ListedColormap
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, Dataset
+
+from sklearn.manifold import TSNE
+from sklearn.decomposition import PCA
+from tqdm import tqdm
+from rdkit import Chem
+from rdkit import RDLogger
+RDLogger.DisableLog('rdApp.*')
+
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+# Import from existing benchmark code
+from transformers import AutoTokenizer
+try:
+    from FastChemTokenizer import FastChemTokenizer
+except ImportError:
+    print("FastChemTokenizer not found. Please ensure it's in your PYTHONPATH.")
+    FastChemTokenizer = None
+
+# Set seeds for reproducibility
+def set_seed(seed=42):
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    os.environ['PYTHONHASHSEED'] = str(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+set_seed(42)
+
+# Device setup
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+class TokenizerWrapper:
+    def __init__(self, tokenizer, name, bos_token="<s>", eos_token="</s>", pad_token="<pad>", unk_token="<unk>"):
+        self.tokenizer = tokenizer
+        self.name = name
+        self.bos_token = bos_token
+        self.eos_token = eos_token
+        self.pad_token = pad_token
+        self.unk_token = unk_token
+
+        if hasattr(tokenizer, 'add_special_tokens'):
+            tokenizer.add_special_tokens({
+                'bos_token': bos_token,
+                'eos_token': eos_token,
+                'pad_token': pad_token,
+                'unk_token': unk_token
+            })
+
+    def encode(self, smiles: str, add_special_tokens: bool = True):
+        if isinstance(self.tokenizer, FastChemTokenizer):
+            # 1. get ids directly
+            ids = self.tokenizer.encode(smiles)          # ← no .tokenize() here
+            # 2. add specials ourselves
+            if add_special_tokens:
+                ids = [self.tokenizer.bos_token_id] + ids + [self.tokenizer.eos_token_id]
+            return {'input_ids': ids}
+        else:
+            # Hugging-Face style tokenizer
+            return self.tokenizer(
+                smiles,
+                add_special_tokens=add_special_tokens,
+                return_attention_mask=False,
+                return_tensors=None
+            )
+
+    def decode(self, token_ids, skip_special_tokens=True):
+        if isinstance(self.tokenizer, FastChemTokenizer):
+            # 1. map single ids → tokens
+            tokens = [self.tokenizer.id_to_token.get(tid, self.tokenizer.unk_token)
+                    for tid in token_ids]
+            # 2. drop specials if requested
+            if skip_special_tokens:
+                specials = {self.tokenizer.bos_token,
+                            self.tokenizer.eos_token,
+                            self.tokenizer.pad_token,
+                            self.tokenizer.unk_token}   # add any others you use
+                tokens = [t for t in tokens if t not in specials]
+            # 3. detokenise
+            if hasattr(self.tokenizer, 'detokenize'):
+                return self.tokenizer.detokenize(tokens)
+            else:
+                return "".join(tokens)          # chemistry tokens are atomic
+        else:
+            return self.tokenizer.decode(token_ids, skip_special_tokens=skip_special_tokens)
+
+    def __len__(self):
+        if isinstance(self.tokenizer, FastChemTokenizer):
+            # FastChemTokenizer uses ._vocab or .vocab depending on version
+            return len(getattr(self.tokenizer, 'vocab',
+                            getattr(self.tokenizer, '_vocab', self.tokenizer)))
+        else:
+            return len(self.tokenizer)
+
+    def get_vocab(self):
+        if isinstance(self.tokenizer, FastChemTokenizer):
+            return self.tokenizer.vocab
+        else:
+            return self.tokenizer.get_vocab()
+    
+    @property
+    def bos_token_id(self):
+        return self.tokenizer.bos_token_id
+
+    @property
+    def eos_token_id(self):
+        return self.tokenizer.eos_token_id
+
+    @property
+    def pad_token_id(self):
+        return self.tokenizer.pad_token_id
+
+    @property
+    def unk_token_id(self):
+        return self.tokenizer.unk_token_id
+
+def collate_fn(batch, tokenizer, max_length=128):
+    encodings = [tokenizer.encode(s, add_special_tokens=True) for s in batch]
+    input_ids = [e['input_ids'] for e in encodings]
+
+    max_len = min(max(len(ids) for ids in input_ids), max_length)
+    padded = []
+    lengths = []
+
+    pad_token_id = tokenizer.tokenizer.pad_token_id  #   FIXED: dynamic
+
+    for ids in input_ids:
+        if len(ids) > max_length:
+            ids = ids[:max_length]
+        else:
+            ids = ids + [pad_token_id] * (max_len - len(ids))
+        padded.append(ids)
+        lengths.append(min(len(ids), max_length))
+
+    return torch.tensor(padded, dtype=torch.long), torch.tensor(lengths, dtype=torch.long)
+
+
+class SmilesDataset(Dataset):
+    def __init__(self, smiles_list):
+        self.smiles_list = smiles_list
+    def __len__(self):
+        return len(self.smiles_list)
+    def __getitem__(self, idx):
+        return self.smiles_list[idx]
+
+
+
+class MoleculeVAE(nn.Module):
+    def __init__(self, vocab_size, embed_dim=256, hidden_dim=512, latent_dim=128, num_layers=2,
+                 pad_token_id=0, bos_token_id=1, eos_token_id=2):
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.embed_dim = embed_dim
+        self.hidden_dim = hidden_dim
+        self.latent_dim = latent_dim
+        self.num_layers = num_layers
+        self.pad_token_id = pad_token_id
+        self.bos_token_id = bos_token_id
+        self.eos_token_id = eos_token_id
+
+        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=pad_token_id)
+        self.encoder_lstm = nn.LSTM(embed_dim, hidden_dim, num_layers, batch_first=True, bidirectional=True)
+        self.fc_mu = nn.Linear(hidden_dim * 2, latent_dim)
+        self.fc_logvar = nn.Linear(hidden_dim * 2, latent_dim)
+
+        self.decoder_lstm = nn.LSTM(embed_dim, hidden_dim, num_layers, batch_first=True)
+        self.fc_out = nn.Linear(hidden_dim, vocab_size)
+
+        self.latent2hidden = nn.Linear(latent_dim, num_layers * hidden_dim)
+        self.latent2cell = nn.Linear(latent_dim, num_layers * hidden_dim)
+
+        self._init_weights()
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.LSTM):
+                for name, param in m.named_parameters():
+                    if 'weight' in name:
+                        nn.init.orthogonal_(param)
+                    elif 'bias' in name:
+                        nn.init.zeros_(param)
+
+    def encode(self, x, lengths):
+        embedded = self.embedding(x)
+        packed = nn.utils.rnn.pack_padded_sequence(embedded, lengths.cpu(), batch_first=True, enforce_sorted=False)
+        packed_out, (hidden, _) = self.encoder_lstm(packed)
+        h_forward = hidden[-2]
+        h_backward = hidden[-1]
+        h = torch.cat([h_forward, h_backward], dim=1)
+        mu = self.fc_mu(h)
+        logvar = self.fc_logvar(h)
+        return mu, logvar
+
+    def reparameterize(self, mu, logvar):
+        if self.training:
+            std = torch.exp(0.5 * logvar)
+            eps = torch.randn_like(std)
+            return mu + eps * std
+        else:
+            return mu
+
+    def decode(self, z, max_length=128, mode="greedy", temperature=1.0):
+        """
+        Decode latent vector z into a sequence.
+        Returns full logits at each step.
+        PATCHED: stops generation when EOS is predicted.
+        """
+        batch_size = z.size(0)
+        device = z.device
+
+        # Initialize hidden states from latent
+        h0 = self.latent2hidden(z).view(self.num_layers, batch_size, self.hidden_dim)
+        c0 = self.latent2cell(z).view(self.num_layers, batch_size, self.hidden_dim)
+        hidden = (h0, c0)
+
+        # Start with BOS token — shape: (batch_size, 1)
+        input_token = torch.full((batch_size, 1), self.bos_token_id, dtype=torch.long, device=device)
+        logits = []
+        finished = torch.zeros(batch_size, dtype=torch.bool, device=device)  # ← TRACK FINISHED SEQS
+
+        for _ in range(max_length):
+            embedded = self.embedding(input_token)  # (batch, 1, embed_dim)
+            output, hidden = self.decoder_lstm(embedded, hidden)
+            logit = self.fc_out(output)  # (batch, 1, vocab)
+            logits.append(logit)
+
+            if mode == "greedy":
+                input_token = logit.argmax(dim=-1)  # (batch, 1)
+            elif mode == "sample":
+                probs = torch.softmax(logit.squeeze(1) / temperature, dim=-1)  # (batch, vocab)
+                input_token = torch.multinomial(probs, 1)  # (batch, 1)
+            else:
+                raise ValueError(f"Unknown decode mode: {mode}")
+
+            # ← EARLY STOPPING AT EOS
+            just_finished = (input_token.squeeze(1) == self.eos_token_id)
+            finished |= just_finished
+            input_token[finished] = self.pad_token_id  # pad finished sequences
+            if finished.all():
+                break
+
+        return torch.cat(logits, dim=1)  # (batch, seq_len, vocab)
+
+    def forward(self, input_ids, lengths, target_seq=None, teacher_forcing_ratio=0.0, temperature=1.0):
+        mu, logvar = self.encode(input_ids, lengths)
+        z = self.reparameterize(mu, logvar)
+
+        if self.training and target_seq is not None and teacher_forcing_ratio > 0:
+            # Training with teacher forcing
+            batch_size, seq_len = target_seq.size()
+            device = target_seq.device
+            
+            # Initialize hidden states
+            h0 = self.latent2hidden(z).view(self.num_layers, batch_size, self.hidden_dim)
+            c0 = self.latent2cell(z).view(self.num_layers, batch_size, self.hidden_dim)
+            hidden = (h0, c0)
+            
+            logits = []
+            input_token = target_seq[:, 0].unsqueeze(1)  # BOS
+
+            for t in range(1, seq_len):
+                embedded = self.embedding(input_token)
+                output, hidden = self.decoder_lstm(embedded, hidden)
+                logit = self.fc_out(output)
+                logits.append(logit)
+
+                use_teacher = torch.rand(1).item() < teacher_forcing_ratio
+                if use_teacher:
+                    input_token = target_seq[:, t].unsqueeze(1)
+                else:
+                    input_token = logit.argmax(dim=-1)
+
+            logits = torch.cat(logits, dim=1)
+        else:
+            # Inference mode
+            max_len = target_seq.size(1) if target_seq is not None else 128
+            logits = self.decode(z, max_length=max_len, mode="greedy", temperature=temperature)
+
+        return logits, mu, logvar
+
+class LatentSpaceVisualizer:
+    def __init__(self, model_path, tokenizer, device='cuda' if torch.cuda.is_available() else 'cpu'):
+        self.device = device
+        self.tokenizer = tokenizer
+        self.model = self.load_model(model_path)
+        
+    def load_model(self, model_path):
+        """Load the trained VAE model"""
+        checkpoint = torch.load(model_path, map_location=self.device)
+        
+        # Extract model parameters from checkpoint
+        if 'model_state_dict' in checkpoint:
+            state_dict = checkpoint['model_state_dict']
+        else:
+            state_dict = checkpoint
+            
+        # Get vocab size from tokenizer
+        vocab_size = len(self.tokenizer)
+        pad_token_id = self.tokenizer.tokenizer.pad_token_id
+        
+        # Initialize model with correct parameters
+        model = MoleculeVAE(vocab_size=vocab_size, pad_token_id=pad_token_id)
+        model.load_state_dict(state_dict)
+        model.to(self.device)
+        model.eval()
+        
+        return model
+    
+    def encode_molecules(self, smiles_list, batch_size=32):
+        """Encode molecules to latent space"""
+        dataset = SmilesDataset(smiles_list)
+        dataloader = DataLoader(
+            dataset, 
+            batch_size=batch_size, 
+            shuffle=False,
+            collate_fn=lambda batch: collate_fn(batch, self.tokenizer, max_length=128)
+        )
+        
+        all_mus = []
+        with torch.no_grad():
+            for input_ids, lengths in tqdm(dataloader, desc="Encoding molecules"):
+                input_ids = input_ids.to(self.device)
+                lengths = lengths.to(self.device)
+                
+                mu, logvar = self.model.encode(input_ids, lengths)
+                all_mus.append(mu.cpu().numpy())
+        
+        return np.concatenate(all_mus, axis=0)
+    
+    def create_grid_latent_points(self, grid_size=100, z_range=4):
+        """Create a grid of points in 2D latent space"""
+        x = np.linspace(-z_range, z_range, grid_size)
+        y = np.linspace(-z_range, z_range, grid_size)
+        xx, yy = np.meshgrid(x, y)
+        
+        # Create circular mask
+        center = grid_size // 2
+        radius = grid_size // 2
+        y_coords, x_coords = np.ogrid[:grid_size, :grid_size]
+        mask = (x_coords - center) ** 2 + (y_coords - center) ** 2 <= radius ** 2
+        
+        return xx, yy, mask
+    
+    def classify_latent_points(self, latent_points, dim1=0, dim2=1, additional_dim=None):
+        """
+        Classify latent points by chemical validity (RDKit parseable)
+        Returns: 0 for invalid/unparseable molecules, 1 for valid molecules
+        """
+        classifications = []
+        
+        with torch.no_grad():
+            # Process in batches to avoid memory issues
+            batch_size = 32
+            for i in range(0, len(latent_points), batch_size):
+                batch_points = latent_points[i:i+batch_size]
+                
+                # Create full latent vectors (sample from normal for other dimensions)
+                full_z = torch.randn(len(batch_points), self.model.latent_dim, device=self.device) * 0.1
+                full_z[:, dim1] = torch.FloatTensor(batch_points[:, 0]).to(self.device)
+                full_z[:, dim2] = torch.FloatTensor(batch_points[:, 1]).to(self.device)
+                
+                # If additional dimension specified (for z2 plots)
+                if additional_dim is not None:
+                    if isinstance(additional_dim, dict):
+                        for dim_idx, dim_val in additional_dim.items():
+                            full_z[:, dim_idx] = dim_val
+                
+                try:
+                    # Decode to SMILES
+                    logits = self.model.decode(full_z, max_length=64, temperature=0.8)
+                    predictions = torch.argmax(logits, dim=-1)
+                    
+                    # Check chemical validity for each decoded molecule
+                    batch_classes = []
+                    for pred in predictions:
+                        pred_ids = pred.cpu().tolist()
+                        
+                        # Remove padding and special tokens
+                        pad_id = self.tokenizer.tokenizer.pad_token_id
+                        eos_id = self.tokenizer.tokenizer.eos_token_id
+                        
+                        # Trim at EOS or pad
+                        for j, token_id in enumerate(pred_ids):
+                            if token_id in [pad_id, eos_id]:
+                                pred_ids = pred_ids[:j]
+                                break
+                        
+                        try:
+                            decoded_smiles = self.tokenizer.decode(pred_ids, skip_special_tokens=True)
+                            # Test chemical validity with RDKit
+                            mol = Chem.MolFromSmiles(decoded_smiles)
+                            
+                            if mol is None:
+                                # Invalid/unparseable molecule
+                                batch_classes.append(0)
+                            else:
+                                # Valid, RDKit-parseable molecule
+                                batch_classes.append(1)
+                                
+                        except Exception:
+                            # Decoding or parsing failed - invalid
+                            batch_classes.append(0)
+                    
+                    classifications.extend(batch_classes)
+                    
+                except Exception as e:
+                    # If decoding fails, all points in batch are invalid
+                    classifications.extend([0] * len(batch_points))
+        
+        return np.array(classifications)
+    
+    def plot_latent_space_interpolation(self, grid_size=100, z_range=4, save_path=None):
+        """
+        Create latent space interpolation plots similar to the reference images
+        """
+        fig, axes = plt.subplots(2, 4, figsize=(20, 10))
+        axes = axes.flatten()
+        
+        # Create color map (RED for invalid molecules, GREEN for valid molecules)
+        colors = ['#FF4444', '#44AA44']  # Red (invalid) and Green (valid)
+        cmap = ListedColormap(colors)
+        
+        plot_idx = 0
+        
+        # First row: different dimension pairs
+        dimension_pairs = [(0, 1), (2, 3), (4, 5), (6, 7)]
+        
+        for dim_pair in dimension_pairs:
+            dim1, dim2 = dim_pair
+            
+            # Create grid
+            xx, yy, mask = self.create_grid_latent_points(grid_size, z_range)
+            
+            # Get points within circular boundary
+            valid_points = []
+            valid_coords = []
+            
+            for i in range(grid_size):
+                for j in range(grid_size):
+                    if mask[i, j]:
+                        valid_points.append([xx[i, j], yy[i, j]])
+                        valid_coords.append([i, j])
+            
+            valid_points = np.array(valid_points)
+            
+            # Classify points based on chemical validity
+            print(f"Classifying latent space chemical validity for dimensions {dim1}, {dim2}...")
+            classifications = self.classify_latent_points(valid_points, dim1, dim2)
+            
+            # Create classification grid
+            class_grid = np.zeros((grid_size, grid_size))
+            class_grid.fill(np.nan)  # Fill with NaN for areas outside circle
+            
+            for point_idx, (i, j) in enumerate(valid_coords):
+                class_grid[i, j] = classifications[point_idx]
+            
+            # Plot
+            ax = axes[plot_idx]
+            im = ax.imshow(class_grid, extent=[-z_range, z_range, -z_range, z_range], 
+                          origin='lower', cmap=cmap, alpha=0.8, vmin=0, vmax=1)
+            
+            # Add concentric circles
+            circles = [1, 2, 3, 4]
+            for radius in circles:
+                if radius <= z_range:
+                    circle = plt.Circle((0, 0), radius, fill=False, color='black', 
+                                      alpha=0.3, linewidth=0.5)
+                    ax.add_patch(circle)
+            
+            # Set labels and title
+            ax.set_xlabel(f'Latent dimension z{dim1}')
+            ax.set_ylabel(f'Latent dimension z{dim2}')
+            ax.set_title('SMILES')
+            ax.set_xlim(-z_range, z_range)
+            ax.set_ylim(-z_range, z_range)
+            ax.set_aspect('equal')
+            
+            plot_idx += 1
+        
+        # Second row: fix z0, z1 and vary z2
+        for z2_val in [-2, -1, 1, 2]:
+            dim1, dim2 = 0, 1  # Use z0 and z1 for x,y
+            
+            # Create grid
+            xx, yy, mask = self.create_grid_latent_points(grid_size, z_range)
+            
+            # Get points within circular boundary
+            valid_points = []
+            valid_coords = []
+            
+            for i in range(grid_size):
+                for j in range(grid_size):
+                    if mask[i, j]:
+                        valid_points.append([xx[i, j], yy[i, j]])
+                        valid_coords.append([i, j])
+            
+            valid_points = np.array(valid_points)
+            
+            # Classify points with z2 fixed - check chemical validity
+            print(f"Classifying latent space chemical validity for z0, z1 with z2 = {z2_val}...")
+            classifications = self.classify_latent_points(
+                valid_points, dim1, dim2, 
+                additional_dim={2: z2_val}
+            )
+            
+            # Create classification grid
+            class_grid = np.zeros((grid_size, grid_size))
+            class_grid.fill(np.nan)
+            
+            for point_idx, (i, j) in enumerate(valid_coords):
+                class_grid[i, j] = classifications[point_idx]
+            
+            # Plot
+            ax = axes[plot_idx]
+            im = ax.imshow(class_grid, extent=[-z_range, z_range, -z_range, z_range], 
+                          origin='lower', cmap=cmap, alpha=0.8, vmin=0, vmax=1)
+            
+            # Add concentric circles
+            for radius in circles:
+                if radius <= z_range:
+                    circle = plt.Circle((0, 0), radius, fill=False, color='black', 
+                                      alpha=0.3, linewidth=0.5)
+                    ax.add_patch(circle)
+            
+            ax.set_xlabel('Latent dimension z0')
+            ax.set_ylabel('Latent dimension z1') 
+            ax.set_title(f'SMILES; z2 = {z2_val}')
+            ax.set_xlim(-z_range, z_range)
+            ax.set_ylim(-z_range, z_range)
+            ax.set_aspect('equal')
+            
+            plot_idx += 1
+        
+        plt.suptitle(f'Latent Space Chemical Validity - {self.tokenizer.name}\n(Red: Invalid molecules, Green: Valid molecules)', fontsize=16)
+        plt.tight_layout()
+        
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        
+        plt.show()
+    
+    def plot_molecule_embeddings(self, smiles_list, method='tsne', save_path=None):
+        """Plot actual molecule embeddings in 2D using dimensionality reduction"""
+        print(f"Encoding {len(smiles_list)} molecules...")
+        embeddings = self.encode_molecules(smiles_list)
+        
+        # Create simple labels based on molecular properties
+        labels = []
+        for smiles in smiles_list:
+            mol = Chem.MolFromSmiles(smiles)
+            if mol is None:
+                labels.append(0)
+            else:
+                # Simple binary classification
+                mw = Chem.Descriptors.MolWt(mol)
+                labels.append(1 if mw > 200 else 0)
+        
+        labels = np.array(labels)
+        
+        # Reduce dimensionality
+        print(f"Computing {method.upper()} projection...")
+        if method == 'tsne':
+            reducer = TSNE(n_components=2, random_state=42, perplexity=min(30, len(smiles_list)//4))
+        else:
+            reducer = PCA(n_components=2, random_state=42)
+            
+        embeddings_2d = reducer.fit_transform(embeddings)
+        
+        # Plot
+        plt.figure(figsize=(10, 8))
+        scatter = plt.scatter(embeddings_2d[:, 0], embeddings_2d[:, 1], 
+                            c=labels, cmap='RdYlGn', alpha=0.7, s=20)
+        plt.colorbar(scatter, label='Molecular Weight > 200')
+        plt.title(f'{method.upper()} of Molecule Embeddings - {self.tokenizer.name}')
+        plt.xlabel(f'{method.upper()} 1')
+        plt.ylabel(f'{method.upper()} 2')
+        
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        
+        plt.show()
+
+def load_data_and_tokenizers():
+    """Load data and tokenizers using your existing structure"""
+    # Load SMILES data (adjust path as needed)
+    data_path = "../data/sample_all_8k_smi.csv"
+    if not os.path.exists(data_path):
+        print(f"Data file not found: {data_path}")
+        print("Please update the data_path in the script.")
+        return None, None
+    
+    df = pd.read_csv(data_path)
+    if 'SMILES' not in df.columns:
+        raise ValueError("Expected column 'SMILES' in CSV")
+
+    smiles_list = df['SMILES'].dropna().tolist()
+    
+    # Validate SMILES
+    valid_smiles = []
+    for smiles in smiles_list:
+        if Chem.MolFromSmiles(smiles) is not None:
+            valid_smiles.append(smiles)
+    
+    print(f"Loaded {len(valid_smiles)} valid SMILES")
+    
+    # Initialize tokenizers
+    try:
+        tok1_hf = AutoTokenizer.from_pretrained("seyonec/ChemBERTa-zinc-base-v1")
+        tokenizer1 = TokenizerWrapper(tok1_hf, name="ChemBERTa", 
+                                    bos_token="<s>", eos_token="</s>", 
+                                    pad_token="<pad>", unk_token="<unk>")
+    except Exception as e:
+        print(f"Failed to load ChemBERTa tokenizer: {e}")
+        tokenizer1 = None
+    
+    try:
+        tok2_fast = FastChemTokenizer.from_pretrained("../smitok")
+        tokenizer2 = TokenizerWrapper(tok2_fast, name="FastChemTokenizer", 
+                                    bos_token="[BOS]", eos_token="[EOS]", 
+                                    pad_token="[PAD]", unk_token="[UNK]")
+    except Exception as e:
+        print(f"Failed to load FastChemTokenizer: {e}")
+        tokenizer2 = None
+    
+    tokenizers = [t for t in [tokenizer1, tokenizer2] if t is not None]
+    
+    return valid_smiles, tokenizers
+
+def create_latent_visualizations():
+    """Main function to create latent space visualizations"""
+    
+    # Load data and tokenizers
+    smiles_list, tokenizers = load_data_and_tokenizers()
+    if smiles_list is None or not tokenizers:
+        print("Failed to load data or tokenizers. Please check your setup.")
+        return
+    
+    # Use a subset for faster visualization
+    viz_smiles = smiles_list[:1000]  # Adjust size as needed
+    
+    # Model paths
+    model_paths = {
+        'ChemBERTa': './checkpoints/ChemBERTa/best_model_ChemBERTa.pt',
+        'FastChemTokenizer': './checkpoints/FastChemTokenizer/best_model_FastChemTokenizer.pt'
+    }
+    
+    # Create output directory
+    os.makedirs('latent_space_plots', exist_ok=True)
+    
+    for tokenizer in tokenizers:
+        model_path = model_paths.get(tokenizer.name)
+        if model_path is None or not os.path.exists(model_path):
+            print(f"Model not found for {tokenizer.name}: {model_path}")
+            continue
+            
+        print(f"\n{'='*60}")
+        print(f"Creating visualizations for {tokenizer.name}")
+        print(f"{'='*60}")
+        
+        try:
+            # Create visualizer
+            visualizer = LatentSpaceVisualizer(model_path, tokenizer, device)
+            
+            # Create latent space interpolation plots
+            print("Creating latent space interpolation plots...")
+            save_path = f'latent_space_plots/{tokenizer.name}_latent_interpolation.png'
+            visualizer.plot_latent_space_interpolation(save_path=save_path)
+            
+            # Create molecule embedding plots
+            print("Creating t-SNE embedding plot...")
+            save_path = f'latent_space_plots/{tokenizer.name}_embeddings_tsne.png'
+            visualizer.plot_molecule_embeddings(viz_smiles, method='tsne', save_path=save_path)
+            
+            print("Creating PCA embedding plot...")
+            save_path = f'latent_space_plots/{tokenizer.name}_embeddings_pca.png'
+            visualizer.plot_molecule_embeddings(viz_smiles, method='pca', save_path=save_path)
+            
+        except Exception as e:
+            print(f"Error processing {tokenizer.name}: {str(e)}")
+            import traceback
+            traceback.print_exc()
+            continue
+    
+    print(f"\n{'='*60}")
+    print("Visualization complete! Check the 'latent_space_plots' directory for results.")
+    print(f"{'='*60}")
+
+if __name__ == "__main__":
+    # Import RDKit descriptors for molecular property calculation
+    try:
+        from rdkit.Chem import Descriptors, rdMolDescriptors
+    except ImportError:
+        print("RDKit Descriptors not available. Using simpler classification.")
+        # Fallback to simple classification if descriptors not available
+        Descriptors = None
+        rdMolDescriptors = None
+    
+    create_latent_visualizations()