code: 
  
  
  import json
  import os
  import re
  import warnings
  from pathlib import Path
  from shutil import copyfile
  from typing import Any, Dict, List, Optional, Tuple, Union
  
  import sentencepiece
  
  from ...tokenization_utils import PreTrainedTokenizer
  from ...utils import logging
  
  
  A_    :					List[Any]             =logging.get_logger(__name__)
  
  A_    :					List[str]             ={
      """source_spm""": """source.spm""",
      """target_spm""": """target.spm""",
      """vocab""": """vocab.json""",
      """target_vocab_file""": """target_vocab.json""",
      """tokenizer_config_file""": """tokenizer_config.json""",
  }
  
  A_    :					Optional[Any]             ={
      """source_spm""": {
          """Helsinki-NLP/opus-mt-en-de""": """https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/source.spm"""
      },
      """target_spm""": {
          """Helsinki-NLP/opus-mt-en-de""": """https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/target.spm"""
      },
      """vocab""": {
          """Helsinki-NLP/opus-mt-en-de""": """https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/vocab.json"""
      },
      """tokenizer_config_file""": {
          """Helsinki-NLP/opus-mt-en-de""": (
              """https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/tokenizer_config.json"""
          )
      },
  }
  
  A_    :					int             ={"""Helsinki-NLP/opus-mt-en-de""": 512}
  A_    :					List[Any]             ={}
  
  
  
  
  
  class        lowercase_				( UpperCamelCase__):
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         snake_case_        =		VOCAB_FILES_NAMES
         snake_case_        =		PRETRAINED_VOCAB_FILES_MAP
         snake_case_        =		PRETRAINED_INIT_CONFIGURATION
         snake_case_        =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
         snake_case_        =		['''input_ids''', '''attention_mask''']
         snake_case_        =		re.compile('''>>.+<<''')  # type: re.Pattern
  
  
         def __init__(   self			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase=None			,    _UpperCAmelCase=None			,    _UpperCAmelCase=None			,    _UpperCAmelCase="<unk>"			,    _UpperCAmelCase="</s>"			,    _UpperCAmelCase="<pad>"			,    _UpperCAmelCase=512			,    _UpperCAmelCase = None			,    _UpperCAmelCase=False			,    **_UpperCAmelCase			,    ):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		{} if sp_model_kwargs is None else sp_model_kwargs
  
               super().__init__(
                   # bos_token=bos_token,  unused. Start decoding with config.decoder_start_token_id
                   source_lang=_UpperCAmelCase			,    target_lang=_UpperCAmelCase			,    unk_token=_UpperCAmelCase			,    eos_token=_UpperCAmelCase			,    pad_token=_UpperCAmelCase			,    model_max_length=_UpperCAmelCase			,    sp_model_kwargs=self.sp_model_kwargs			,    target_vocab_file=_UpperCAmelCase			,    separate_vocabs=_UpperCAmelCase			,    **_UpperCAmelCase			,    )
               assert Path(_UpperCAmelCase		).exists(), f"cannot find spm source {source_spm}"
  
               a_					=		separate_vocabs
               a_					=		load_json(_UpperCAmelCase		)
               if self.unk_token not in self.encoder:
                     raise KeyError("""<unk> token must be in vocab"""		)
               assert self.pad_token in self.encoder
  
               if separate_vocabs:
                     a_					=		load_json(_UpperCAmelCase		)
                     a_					=		{v: k for k, v in self.target_encoder.items()}
                     a_					=		[]
               else:
                     a_					=		{v: k for k, v in self.encoder.items()}
                     a_					=		[k for k in self.encoder if k.startswith(""">>"""		) and k.endswith("""<<"""		)]
  
               a_					=		source_lang
               a_					=		target_lang
               a_					=		[source_spm, target_spm]
  
               # load SentencePiece model for pre-processing
               a_					=		load_spm(_UpperCAmelCase			,    self.sp_model_kwargs		)
               a_					=		load_spm(_UpperCAmelCase			,    self.sp_model_kwargs		)
               a_					=		self.spm_source
               a_					=		self.encoder
  
               # Multilingual target side: default to using first supported language code.
  
               self._setup_normalizer()
  
  
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               try:
                     from sacremoses import MosesPunctNormalizer
  
                     a_					=		MosesPunctNormalizer(self.source_lang		).normalize
               except (ImportError, FileNotFoundError):
                     warnings.warn("""Recommended: pip install sacremoses."""		)
                     a_					=		lambda _UpperCAmelCase		: x
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               return self.punc_normalizer(_UpperCAmelCase		) if x else ""
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               return self.current_encoder.get(_UpperCAmelCase			,    self.current_encoder[self.unk_token]		)
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		self.language_code_re.match(_UpperCAmelCase		)
               a_					=		[match.group(0		)] if match else []
               return code, self.language_code_re.sub(""""""			,    _UpperCAmelCase		)
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_			,   a_					=		self.remove_language_code(_UpperCAmelCase		)
               a_					=		self.current_spm.encode(_UpperCAmelCase			,    out_type=_UpperCAmelCase		)
               return code + pieces
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               return self.decoder.get(_UpperCAmelCase			,    self.unk_token		)
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase			,    **_UpperCAmelCase		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               return super().batch_decode(_UpperCAmelCase			,    **_UpperCAmelCase		)
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase			,    **_UpperCAmelCase		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               return super().decode(_UpperCAmelCase			,    **_UpperCAmelCase		)
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		self.spm_source if self._decode_use_source_tokenizer else self.spm_target
               a_					=		[]
               a_					=		""""""
               for token in tokens:
                     # make sure that special tokens are not decoded using sentencepiece model
                     if token in self.all_special_tokens:
                           out_string += sp_model.decode_pieces(_UpperCAmelCase		) + token + " "
                           a_					=		[]
                     else:
                           current_sub_tokens.append(_UpperCAmelCase		)
               out_string += sp_model.decode_pieces(_UpperCAmelCase		)
               return out_string.strip()
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase=None		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               if token_ids_a is None:
                     return token_ids_a + [self.eos_token_id]
               # We don't expect to process pairs, but leave the pair logic for API consistency
               return token_ids_a + token_ids_a + [self.eos_token_id]
  
  
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		self.spm_source
               a_					=		self.encoder
  
  
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		self.spm_target
               if self.separate_vocabs:
                     a_					=		self.target_encoder
  
  
         @property
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               return len(self.encoder		)
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase = None		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               if not os.path.isdir(_UpperCAmelCase		):
                     logger.error(f"Vocabulary path ({save_directory}) should be a directory"		)
                     return
               a_					=		[]
  
               if self.separate_vocabs:
                     a_					=		os.path.join(
                         _UpperCAmelCase			,    (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab"""]			,    )
                     a_					=		os.path.join(
                         _UpperCAmelCase			,    (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""target_vocab_file"""]			,    )
                     save_json(self.encoder			,    _UpperCAmelCase		)
                     save_json(self.target_encoder			,    _UpperCAmelCase		)
                     saved_files.append(_UpperCAmelCase		)
                     saved_files.append(_UpperCAmelCase		)
               else:
                     a_					=		os.path.join(
                         _UpperCAmelCase			,    (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab"""]		)
                     save_json(self.encoder			,    _UpperCAmelCase		)
                     saved_files.append(_UpperCAmelCase		)
  
               for spm_save_filename, spm_orig_path, spm_model in zip(
                   [VOCAB_FILES_NAMES["""source_spm"""], VOCAB_FILES_NAMES["""target_spm"""]]			,    self.spm_files			,    [self.spm_source, self.spm_target]			,    ):
                     a_					=		os.path.join(
                         _UpperCAmelCase			,    (filename_prefix + """-""" if filename_prefix else """""") + spm_save_filename		)
                     if os.path.abspath(_UpperCAmelCase		) != os.path.abspath(_UpperCAmelCase		) and os.path.isfile(_UpperCAmelCase		):
                           copyfile(_UpperCAmelCase			,    _UpperCAmelCase		)
                           saved_files.append(_UpperCAmelCase		)
                     elif not os.path.isfile(_UpperCAmelCase		):
                           with open(_UpperCAmelCase			,    """wb"""		) as fi:
                                 a_					=		spm_model.serialized_model_proto()
                                 fi.write(_UpperCAmelCase		)
                           saved_files.append(_UpperCAmelCase		)
  
               return tuple(_UpperCAmelCase		)
  
  
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               return self.get_src_vocab()
  
  
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               return dict(self.encoder			,    **self.added_tokens_encoder		)
  
  
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               return dict(self.target_encoder			,    **self.added_tokens_decoder		)
  
  
         def __getstate__(   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		self.__dict__.copy()
               state.update(
                   {k: None for k in ["""spm_source""", """spm_target""", """current_spm""", """punc_normalizer""", """target_vocab_file"""]}		)
               return state
  
  
         def __setstate__(   self			,    _UpperCAmelCase		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		d
  
               # for backward compatibility
               if not hasattr(self			,    """sp_model_kwargs"""		):
                     a_					=		{}
  
               a_			,   a_					=		(load_spm(_UpperCAmelCase			,    self.sp_model_kwargs		) for f in self.spm_files)
               a_					=		self.spm_source
               self._setup_normalizer()
  
  
         def 						lowercase__     (   self			,    *_UpperCAmelCase			,    **_UpperCAmelCase		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               return 1
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		set(self.all_special_ids		)  # call it once instead of inside list comp
               all_special_ids.remove(self.unk_token_id		)  # <unk> is only sometimes special
               return [1 if x in all_special_ids else 0 for x in seq]
  
  
  
  
  
  
         def 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase = None			,    _UpperCAmelCase = False		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               if already_has_special_tokens:
                     return self._special_token_mask(_UpperCAmelCase		)
               elif token_ids_a is None:
                     return self._special_token_mask(_UpperCAmelCase		) + [1]
               else:
                     return self._special_token_mask(token_ids_a + token_ids_a		) + [1]
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__       ,    UpperCAmelCase__      ):
  
  
  
        """simple docstring"""
  
  
  
  
        a_					=		sentencepiece.SentencePieceProcessor(**__snake_case      )
        spm.Load(__snake_case      )
        return spm
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__       ,    UpperCAmelCase__      ):
  
  
  
        """simple docstring"""
  
  
  
  
        with open(__snake_case       ,    """w"""      ) as f:
              json.dump(__snake_case       ,    __snake_case       ,    indent=2      )
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__      ):
  
  
  
        """simple docstring"""
  
  
  
  
        with open(__snake_case       ,    """r"""      ) as f:
              return json.load(__snake_case      )
style_context: 
  
  
  import json
  import os
  import unittest
  
  from transformers import BartTokenizer, BartTokenizerFast, BatchEncoding
  from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES
  from transformers.testing_utils import require_tokenizers, require_torch
  from transformers.utils import cached_property
  
  from ...test_tokenization_common import TokenizerTesterMixin, filter_roberta_detectors
  
  
  
  
  
  @require_tokenizers
  class        lowercase_				( UpperCamelCase__			,unittest.TestCase):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  
  
  							snake_case_        =		BartTokenizer
  							snake_case_        =		BartTokenizerFast
  							snake_case_        =		True
  							snake_case_        =		filter_roberta_detectors
  
  
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													super().setUp()
  													a_					=		[
  													    """l""",
  													    """o""",
  													    """w""",
  													    """e""",
  													    """r""",
  													    """s""",
  													    """t""",
  													    """i""",
  													    """d""",
  													    """n""",
  													    """\u0120""",
  													    """\u0120l""",
  													    """\u0120n""",
  													    """\u0120lo""",
  													    """\u0120low""",
  													    """er""",
  													    """\u0120lowest""",
  													    """\u0120newer""",
  													    """\u0120wider""",
  													    """<unk>""",
  													]
  													a_					=		dict(zip(_UpperCAmelCase			,    range(len(_UpperCAmelCase		)		)		)		)
  													a_					=		["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
  													a_					=		{"""unk_token""": """<unk>"""}
  
  													a_					=		os.path.join(self.tmpdirname			,    VOCAB_FILES_NAMES["""vocab_file"""]		)
  													a_					=		os.path.join(self.tmpdirname			,    VOCAB_FILES_NAMES["""merges_file"""]		)
  													with open(self.vocab_file			,    """w"""			,    encoding="""utf-8"""		) as fp:
  																			fp.write(json.dumps(_UpperCAmelCase		) + """\n"""		)
  													with open(self.merges_file			,    """w"""			,    encoding="""utf-8"""		) as fp:
  																			fp.write("""\n""".join(_UpperCAmelCase		)		)
  
  
  							def 						lowercase__     (   self			,    **_UpperCAmelCase		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													kwargs.update(self.special_tokens_map		)
  													return self.tokenizer_class.from_pretrained(self.tmpdirname			,    **_UpperCAmelCase		)
  
  
  							def 						lowercase__     (   self			,    **_UpperCAmelCase		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													kwargs.update(self.special_tokens_map		)
  													return self.rust_tokenizer_class.from_pretrained(self.tmpdirname			,    **_UpperCAmelCase		)
  
  
  							def 						lowercase__     (   self			,    _UpperCAmelCase		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													return "lower newer", "lower newer"
  
  
  							@cached_property
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													return BartTokenizer.from_pretrained("""facebook/bart-large"""		)
  
  
  							@cached_property
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													return BartTokenizerFast.from_pretrained("""facebook/bart-large"""		)
  
  
  							@require_torch
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
  													a_					=		[0, 250, 251, 17_818, 13, 39_186, 1_938, 4, 2]
  
  													for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
  																			a_					=		tokenizer(_UpperCAmelCase			,    max_length=len(_UpperCAmelCase		)			,    padding=_UpperCAmelCase			,    return_tensors="""pt"""		)
  																			self.assertIsInstance(_UpperCAmelCase			,    _UpperCAmelCase		)
  
  																			self.assertEqual((2, 9)			,    batch.input_ids.shape		)
  																			self.assertEqual((2, 9)			,    batch.attention_mask.shape		)
  																			a_					=		batch.input_ids.tolist()[0]
  																			self.assertListEqual(_UpperCAmelCase			,    _UpperCAmelCase		)
  																			# Test that special tokens are reset
  
  
  							@require_torch
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
  													for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
  																			a_					=		tokenizer(_UpperCAmelCase			,    padding=_UpperCAmelCase			,    return_tensors="""pt"""		)
  																			# check if input_ids are returned and no labels
  																			self.assertIn("""input_ids"""			,    _UpperCAmelCase		)
  																			self.assertIn("""attention_mask"""			,    _UpperCAmelCase		)
  																			self.assertNotIn("""labels"""			,    _UpperCAmelCase		)
  																			self.assertNotIn("""decoder_attention_mask"""			,    _UpperCAmelCase		)
  
  
  							@require_torch
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		[
  													    """Summary of the text.""",
  													    """Another summary.""",
  													]
  													for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
  																			a_					=		tokenizer(text_target=_UpperCAmelCase			,    max_length=32			,    padding="""max_length"""			,    return_tensors="""pt"""		)
  																			self.assertEqual(32			,    targets["""input_ids"""].shape[1]		)
  
  
  							@require_torch
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
  																			a_					=		tokenizer(
  																			    ["""I am a small frog""" * 1_024, """I am a small frog"""]			,    padding=_UpperCAmelCase			,    truncation=_UpperCAmelCase			,    return_tensors="""pt"""		)
  																			self.assertIsInstance(_UpperCAmelCase			,    _UpperCAmelCase		)
  																			self.assertEqual(batch.input_ids.shape			,    (2, 1_024)		)
  
  
  							@require_torch
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		["""A long paragraph for summarization."""]
  													a_					=		[
  													    """Summary of the text.""",
  													]
  													for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
  																			a_					=		tokenizer(_UpperCAmelCase			,    return_tensors="""pt"""		)
  																			a_					=		tokenizer(text_target=_UpperCAmelCase			,    return_tensors="""pt"""		)
  																			a_					=		inputs["""input_ids"""]
  																			a_					=		targets["""input_ids"""]
  																			self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item()		)
  																			self.assertTrue((labels[:, 0] == tokenizer.bos_token_id).all().item()		)
  																			self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item()		)
  																			self.assertTrue((labels[:, -1] == tokenizer.eos_token_id).all().item()		)
  
  
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													pass
  
  
  
  
  
  
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
  																			with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"		):
  																									a_					=		self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase			,    **_UpperCAmelCase		)
  																									a_					=		self.tokenizer_class.from_pretrained(_UpperCAmelCase			,    **_UpperCAmelCase		)
  																									a_					=		"""A, <mask> AllenNLP sentence."""
  																									a_					=		tokenizer_r.encode_plus(_UpperCAmelCase			,    add_special_tokens=_UpperCAmelCase			,    return_token_type_ids=_UpperCAmelCase		)
  																									a_					=		tokenizer_p.encode_plus(_UpperCAmelCase			,    add_special_tokens=_UpperCAmelCase			,    return_token_type_ids=_UpperCAmelCase		)
  
  																									# token_type_ids should put 0 everywhere
  																									self.assertEqual(sum(tokens_r["""token_type_ids"""]		)			,    sum(tokens_p["""token_type_ids"""]		)		)
  
  																									# attention_mask should put 1 everywhere, so sum over length should be 1
  																									self.assertEqual(
  																									    sum(tokens_r["""attention_mask"""]		) / len(tokens_r["""attention_mask"""]		)			,    sum(tokens_p["""attention_mask"""]		) / len(tokens_p["""attention_mask"""]		)			,    )
  
  																									a_					=		tokenizer_r.convert_ids_to_tokens(tokens_r["""input_ids"""]		)
  																									a_					=		tokenizer_p.convert_ids_to_tokens(tokens_p["""input_ids"""]		)
  
  																									# Rust correctly handles the space before the mask while python doesnt
  																									self.assertSequenceEqual(tokens_p["""input_ids"""]			,    [0, 250, 6, 50_264, 3_823, 487, 21_992, 3_645, 4, 2]		)
  																									self.assertSequenceEqual(tokens_r["""input_ids"""]			,    [0, 250, 6, 50_264, 3_823, 487, 21_992, 3_645, 4, 2]		)
  
  																									self.assertSequenceEqual(
  																									    _UpperCAmelCase			,    ["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]		)
  																									self.assertSequenceEqual(
  																									    _UpperCAmelCase			,    ["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]		)