




import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


_UpperCAmelCase		:  int	=   logging.get_logger(__name__)


_UpperCAmelCase		:  Tuple	=   {"vocab_file": "vocab.json", "merges_file": "merges.txt"}

# See all BART models at https://huggingface.co/models?filter=bart
_UpperCAmelCase		:  List[str]	=   {
    "vocab_file": {
        "facebook/bart-base": "https://huggingface.co/facebook/bart-base/resolve/main/vocab.json",
        "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/vocab.json",
        "facebook/bart-large-mnli": "https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json",
        "facebook/bart-large-cnn": "https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json",
        "facebook/bart-large-xsum": "https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json",
        "yjernite/bart_eli5": "https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json",
    },
    "merges_file": {
        "facebook/bart-base": "https://huggingface.co/facebook/bart-base/resolve/main/merges.txt",
        "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/merges.txt",
        "facebook/bart-large-mnli": "https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt",
        "facebook/bart-large-cnn": "https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt",
        "facebook/bart-large-xsum": "https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt",
        "yjernite/bart_eli5": "https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt",
    },
}

_UpperCAmelCase		:  Optional[Any]	=   {
    "facebook/bart-base": 1024,
    "facebook/bart-large": 1024,
    "facebook/bart-large-mnli": 1024,
    "facebook/bart-large-cnn": 1024,
    "facebook/bart-large-xsum": 1024,
    "yjernite/bart_eli5": 1024,
}



@lru_cache()
def 					UpperCAmelCase__     (   ):
  lowercase			:Any							=  (
      list(range(ord("!"      ),	ord("~"      ) + 1      )      ) + list(range(ord("¡"      ),	ord("¬"      ) + 1      )      ) + list(range(ord("®"      ),	ord("ÿ"      ) + 1      )      )
  )
  lowercase			:Optional[Any]							=  bs[:]
  lowercase			:Union[str, Any]							=  0
  for b in range(2**8      ):
    if b not in bs:
      bs.append(lowerCamelCase      )
      cs.append(2**8 + n      )
      n += 1
  lowercase			:Dict							=  [chr(lowerCamelCase      ) for n in cs]
  return dict(zip(lowerCamelCase,	lowerCamelCase      )      )



def 					UpperCAmelCase__     (   lowerCamelCase      ):
  lowercase			:int							=  set()
  lowercase			:Dict							=  word[0]
  for char in word[1:]:
    pairs.add((prev_char, char)      )
    lowercase			:Dict							=  char
  return pairs







class       __lowerCAmelCase				(							lowerCAmelCase):
       _a           =  VOCAB_FILES_NAMES
       _a           =  PRETRAINED_VOCAB_FILES_MAP
       _a           =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       _a           =  ['''input_ids''', '''attention_mask''']






       def __init__(      self:    List[str]				,    _lowerCAmelCase:    Union[str, Any]				,    _lowerCAmelCase:    List[Any]				,    _lowerCAmelCase:    Tuple="replace"				,    _lowerCAmelCase:    Optional[Any]="<s>"				,    _lowerCAmelCase:    Tuple="</s>"				,    _lowerCAmelCase:    Any="</s>"				,    _lowerCAmelCase:    List[str]="<s>"				,    _lowerCAmelCase:    Tuple="<unk>"				,    _lowerCAmelCase:    int="<pad>"				,    _lowerCAmelCase:    Optional[Any]="<mask>"				,    _lowerCAmelCase:    Optional[int]=False				,    **_lowerCAmelCase:    Union[str, Any]				,    ):
         lowercase			:Optional[int]							=  AddedToken(_lowerCAmelCase				,    lstrip=_lowerCAmelCase				,    rstrip=_lowerCAmelCase ) if isinstance(_lowerCAmelCase				,    _lowerCAmelCase ) else bos_token
         lowercase			:Optional[Any]							=  AddedToken(_lowerCAmelCase				,    lstrip=_lowerCAmelCase				,    rstrip=_lowerCAmelCase ) if isinstance(_lowerCAmelCase				,    _lowerCAmelCase ) else eos_token
         lowercase			:Union[str, Any]							=  AddedToken(_lowerCAmelCase				,    lstrip=_lowerCAmelCase				,    rstrip=_lowerCAmelCase ) if isinstance(_lowerCAmelCase				,    _lowerCAmelCase ) else sep_token
         lowercase			:Dict							=  AddedToken(_lowerCAmelCase				,    lstrip=_lowerCAmelCase				,    rstrip=_lowerCAmelCase ) if isinstance(_lowerCAmelCase				,    _lowerCAmelCase ) else cls_token
         lowercase			:int							=  AddedToken(_lowerCAmelCase				,    lstrip=_lowerCAmelCase				,    rstrip=_lowerCAmelCase ) if isinstance(_lowerCAmelCase				,    _lowerCAmelCase ) else unk_token
         lowercase			:List[Any]							=  AddedToken(_lowerCAmelCase				,    lstrip=_lowerCAmelCase				,    rstrip=_lowerCAmelCase ) if isinstance(_lowerCAmelCase				,    _lowerCAmelCase ) else pad_token

         # Mask token behave like a normal word, i.e. include the space before it
         lowercase			:Union[str, Any]							=  AddedToken(_lowerCAmelCase				,    lstrip=_lowerCAmelCase				,    rstrip=_lowerCAmelCase ) if isinstance(_lowerCAmelCase				,    _lowerCAmelCase ) else mask_token

         super().__init__(
             errors=_lowerCAmelCase				,    bos_token=_lowerCAmelCase				,    eos_token=_lowerCAmelCase				,    unk_token=_lowerCAmelCase				,    sep_token=_lowerCAmelCase				,    cls_token=_lowerCAmelCase				,    pad_token=_lowerCAmelCase				,    mask_token=_lowerCAmelCase				,    add_prefix_space=_lowerCAmelCase				,    **_lowerCAmelCase				,    )

         with open(_lowerCAmelCase				,    encoding="utf-8" ) as vocab_handle:
           lowercase			:Optional[int]							=  json.load(_lowerCAmelCase )
         lowercase			:List[str]							=  {v: k for k, v in self.encoder.items()}
         lowercase			:Tuple							=  errors  # how to handle errors in decoding
         lowercase			:Any							=  bytes_to_unicode()
         lowercase			:Any							=  {v: k for k, v in self.byte_encoder.items()}
         with open(_lowerCAmelCase				,    encoding="utf-8" ) as merges_handle:
           lowercase			:Tuple							=  merges_handle.read().split("\n" )[1:-1]
         lowercase			:Optional[int]							=  [tuple(merge.split() ) for merge in bpe_merges]
         lowercase			:Dict							=  dict(zip(_lowerCAmelCase				,    range(len(_lowerCAmelCase ) ) ) )
         lowercase			:Union[str, Any]							=  {}
         lowercase			:Any							=  add_prefix_space

         # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
         lowercase			:Dict							=  re.compile(r"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+" )






       @property
       def     SCREAMING_SNAKE_CASE			(      self:    Optional[int] ):
         return len(self.encoder )






       def     SCREAMING_SNAKE_CASE			(      self:    int ):
         return dict(self.encoder				,    **self.added_tokens_encoder )






       def     SCREAMING_SNAKE_CASE			(      self:    List[str]				,    _lowerCAmelCase:    Dict ):
         if token in self.cache:
           return self.cache[token]
         lowercase			:List[Any]							=  tuple(_lowerCAmelCase )
         lowercase			:Any							=  get_pairs(_lowerCAmelCase )

         if not pairs:
           return token

         while True:
           lowercase			:Optional[Any]							=  min(_lowerCAmelCase				,    key=lambda _lowerCAmelCase : self.bpe_ranks.get(_lowerCAmelCase				,    float("inf" ) ) )
           if bigram not in self.bpe_ranks:
             break
           lowercase		,			lowercase			:str							=  bigram
           lowercase			:List[str]							=  []
           lowercase			:Any							=  0
           while i < len(_lowerCAmelCase ):
             try:
               lowercase			:Tuple							=  word.index(_lowerCAmelCase				,    _lowerCAmelCase )
             except ValueError:
               new_word.extend(word[i:] )
               break
             else:
               new_word.extend(word[i:j] )
               lowercase			:Tuple							=  j

             if word[i] == first and i < len(_lowerCAmelCase ) - 1 and word[i + 1] == second:
               new_word.append(first + second )
               i += 2
             else:
               new_word.append(word[i] )
               i += 1
           lowercase			:Any							=  tuple(_lowerCAmelCase )
           lowercase			:Union[str, Any]							=  new_word
           if len(_lowerCAmelCase ) == 1:
             break
           else:
             lowercase			:Any							=  get_pairs(_lowerCAmelCase )
         lowercase			:int							=  " ".join(_lowerCAmelCase )
         lowercase			:Union[str, Any]							=  word
         return word






       def     SCREAMING_SNAKE_CASE			(      self:    Dict				,    _lowerCAmelCase:    Tuple ):
         lowercase			:List[Any]							=  []
         for token in re.findall(self.pat				,    _lowerCAmelCase ):
           lowercase			:str							=  "".join(
               self.byte_encoder[b] for b in token.encode("utf-8" ) )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
           bpe_tokens.extend(bpe_token for bpe_token in self.bpe(_lowerCAmelCase ).split(" " ) )
         return bpe_tokens






       def     SCREAMING_SNAKE_CASE			(      self:    Tuple				,    _lowerCAmelCase:    List[Any] ):
         return self.encoder.get(_lowerCAmelCase				,    self.encoder.get(self.unk_token ) )






       def     SCREAMING_SNAKE_CASE			(      self:    Tuple				,    _lowerCAmelCase:    Dict ):
         return self.decoder.get(_lowerCAmelCase )






       def     SCREAMING_SNAKE_CASE			(      self:    Union[str, Any]				,    _lowerCAmelCase:    Optional[int] ):
         lowercase			:str							=  "".join(_lowerCAmelCase )
         lowercase			:str							=  bytearray([self.byte_decoder[c] for c in text] ).decode("utf-8"				,    errors=self.errors )
         return text






       def     SCREAMING_SNAKE_CASE			(      self:    str				,    _lowerCAmelCase:    str				,    _lowerCAmelCase:    Optional[str] = None ):
         if not os.path.isdir(_lowerCAmelCase ):
           logger.error(F"Vocabulary path ({save_directory}) should be a directory" )
           return
         lowercase			:Tuple							=  os.path.join(
             _lowerCAmelCase				,    (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] )
         lowercase			:str							=  os.path.join(
             _lowerCAmelCase				,    (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"] )

         with open(_lowerCAmelCase				,    "w"				,    encoding="utf-8" ) as f:
           f.write(json.dumps(self.encoder				,    indent=2				,    sort_keys=_lowerCAmelCase				,    ensure_ascii=_lowerCAmelCase ) + "\n" )

         lowercase			:int							=  0
         with open(_lowerCAmelCase				,    "w"				,    encoding="utf-8" ) as writer:
           writer.write("#version: 0.2\n" )
           for bpe_tokens, token_index in sorted(self.bpe_ranks.items()				,    key=lambda _lowerCAmelCase : kv[1] ):
             if index != token_index:
               logger.warning(
                   F"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
                   " Please check that the tokenizer is not corrupted!" )
               lowercase			:Tuple							=  token_index
             writer.write(" ".join(_lowerCAmelCase ) + "\n" )
             index += 1

         return vocab_file, merge_file






       def     SCREAMING_SNAKE_CASE			(      self:    Optional[int]				,    _lowerCAmelCase:    List[int]				,    _lowerCAmelCase:    Optional[List[int]] = None ):
         if token_ids_a is None:
           return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
         lowercase			:Any							=  [self.cls_token_id]
         lowercase			:Optional[int]							=  [self.sep_token_id]
         return cls + token_ids_a + sep + sep + token_ids_a + sep






       def     SCREAMING_SNAKE_CASE			(      self:    List[Any]				,    _lowerCAmelCase:    List[int]				,    _lowerCAmelCase:    Optional[List[int]] = None				,    _lowerCAmelCase:    bool = False ):
         if already_has_special_tokens:
           return super().get_special_tokens_mask(
               token_ids_a=_lowerCAmelCase				,    token_ids_a=_lowerCAmelCase				,    already_has_special_tokens=_lowerCAmelCase )

         if token_ids_a is None:
           return [1] + ([0] * len(_lowerCAmelCase )) + [1]
         return [1] + ([0] * len(_lowerCAmelCase )) + [1, 1] + ([0] * len(_lowerCAmelCase )) + [1]






       def     SCREAMING_SNAKE_CASE			(      self:    Union[str, Any]				,    _lowerCAmelCase:    List[int]				,    _lowerCAmelCase:    Optional[List[int]] = None ):
         lowercase			:Union[str, Any]							=  [self.sep_token_id]
         lowercase			:Optional[int]							=  [self.cls_token_id]

         if token_ids_a is None:
           return len(cls + token_ids_a + sep ) * [0]
         return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]






       def     SCREAMING_SNAKE_CASE			(      self:    int				,    _lowerCAmelCase:    str				,    _lowerCAmelCase:    str=False				,    **_lowerCAmelCase:    str ):
         lowercase			:Dict							=  kwargs.pop("add_prefix_space"				,    self.add_prefix_space )
         if (is_split_into_words or add_prefix_space) and (len(_lowerCAmelCase ) > 0 and not text[0].isspace()):
           lowercase			:Any							=  " " + text
         return (text, kwargs)









import json
import os
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


_UpperCAmelCase		:  Dict	=   logging.get_logger(__name__)

_UpperCAmelCase		:  Optional[int]	=   "▁"

_UpperCAmelCase		:  int	=   {
    "vocab_file": "vocab.json",
    "spm_file": "sentencepiece.bpe.model",
}

_UpperCAmelCase		:  List[Any]	=   {
    "vocab_file": {
        "facebook/s2t-small-librispeech-asr": (
            "https://huggingface.co/facebook/s2t-small-librispeech-asr/resolve/main/vocab.json"
        ),
    },
    "spm_file": {
        "facebook/s2t-small-librispeech-asr": (
            "https://huggingface.co/facebook/s2t-small-librispeech-asr/resolve/main/sentencepiece.bpe.model"
        )
    },
}

_UpperCAmelCase		:  str	=   {
    "facebook/s2t-small-librispeech-asr": 1024,
}

_UpperCAmelCase		:  List[str]	=   ["pt", "fr", "ru", "nl", "ro", "it", "es", "de"]

_UpperCAmelCase		:  Tuple	=   {"mustc": MUSTC_LANGS}




class       __lowerCAmelCase				(							lowerCAmelCase):
       _a           =  VOCAB_FILES_NAMES
       _a           =  PRETRAINED_VOCAB_FILES_MAP
       _a           =  MAX_MODEL_INPUT_SIZES
       _a           =  ['''input_ids''', '''attention_mask''']

       _a           =  []






       def __init__(      self:    Dict				,    _lowerCAmelCase:    Optional[Any]				,    _lowerCAmelCase:    Optional[Any]				,    _lowerCAmelCase:    List[Any]="<s>"				,    _lowerCAmelCase:    List[str]="</s>"				,    _lowerCAmelCase:    Optional[int]="<pad>"				,    _lowerCAmelCase:    List[str]="<unk>"				,    _lowerCAmelCase:    Dict=False				,    _lowerCAmelCase:    Optional[Any]=False				,    _lowerCAmelCase:    Dict=None				,    _lowerCAmelCase:    Dict=None				,    _lowerCAmelCase:    Optional[Dict[str, Any]] = None				,    **_lowerCAmelCase:    Tuple				,    ):
         lowercase			:str							=  {} if sp_model_kwargs is None else sp_model_kwargs

         super().__init__(
             bos_token=_lowerCAmelCase				,    eos_token=_lowerCAmelCase				,    unk_token=_lowerCAmelCase				,    pad_token=_lowerCAmelCase				,    do_upper_case=_lowerCAmelCase				,    do_lower_case=_lowerCAmelCase				,    tgt_lang=_lowerCAmelCase				,    lang_codes=_lowerCAmelCase				,    sp_model_kwargs=self.sp_model_kwargs				,    **_lowerCAmelCase				,    )
         lowercase			:List[str]							=  do_upper_case
         lowercase			:List[str]							=  do_lower_case

         lowercase			:str							=  load_json(_lowerCAmelCase )
         lowercase			:List[Any]							=  {v: k for k, v in self.encoder.items()}
         lowercase			:str							=  spm_file
         lowercase			:Any							=  load_spm(_lowerCAmelCase				,    self.sp_model_kwargs )

         if lang_codes is not None:
           lowercase			:List[str]							=  lang_codes
           lowercase			:Tuple							=  LANGUAGES[lang_codes]
           lowercase			:Any							=  [F"<lang:{lang}>" for lang in self.langs]
           lowercase			:Any							=  {lang: self.sp_model.PieceToId(F"<lang:{lang}>" ) for lang in self.langs}

           lowercase			:Optional[Any]							=  self.lang_tokens
           lowercase			:List[str]							=  tgt_lang if tgt_lang is not None else self.langs[0]

           self.set_tgt_lang_special_tokens(self._tgt_lang )
         else:
           lowercase			:Tuple							=  {}






       @property
       def     SCREAMING_SNAKE_CASE			(      self:    Tuple ):
         return len(self.encoder )






       @property
       def     SCREAMING_SNAKE_CASE			(      self:    Optional[Any] ):
         return self._tgt_lang






       @tgt_lang.setter
       def     SCREAMING_SNAKE_CASE			(      self:    List[Any]				,    _lowerCAmelCase:    Optional[Any] ):
         lowercase			:Any							=  new_tgt_lang
         self.set_tgt_lang_special_tokens(_lowerCAmelCase )






       def     SCREAMING_SNAKE_CASE			(      self:    Optional[int]				,    _lowerCAmelCase:    str ):
         lowercase			:Any							=  self.lang_code_to_id[tgt_lang]
         lowercase			:List[Any]							=  [lang_code_id]






       def     SCREAMING_SNAKE_CASE			(      self:    Optional[Any]				,    _lowerCAmelCase:    str ):
         return self.sp_model.encode(_lowerCAmelCase				,    out_type=_lowerCAmelCase )






       def     SCREAMING_SNAKE_CASE			(      self:    Dict				,    _lowerCAmelCase:    Tuple ):
         return self.encoder.get(_lowerCAmelCase				,    self.encoder[self.unk_token] )






       def     SCREAMING_SNAKE_CASE			(      self:    List[str]				,    _lowerCAmelCase:    int ):
         return self.decoder.get(_lowerCAmelCase				,    self.unk_token )






       def     SCREAMING_SNAKE_CASE			(      self:    List[Any]				,    _lowerCAmelCase:    List[str] ):
         lowercase			:int							=  []
         lowercase			:Any							=  ""
         for token in tokens:
           # make sure that special tokens are not decoded using sentencepiece model
           if token in self.all_special_tokens:
             lowercase			:Dict							=  self.sp_model.decode(_lowerCAmelCase )
             out_string += (decoded.upper() if self.do_upper_case else decoded) + token + " "
             lowercase			:Any							=  []
           else:
             current_sub_tokens.append(_lowerCAmelCase )
         lowercase			:Dict							=  self.sp_model.decode(_lowerCAmelCase )
         out_string += decoded.upper() if self.do_upper_case else decoded
         return out_string.strip()






       def     SCREAMING_SNAKE_CASE			(      self:    Any				,    _lowerCAmelCase:    int				,    _lowerCAmelCase:    str=None ):
         if token_ids_a is None:
           return self.prefix_tokens + token_ids_a + [self.eos_token_id]
         # We don't expect to process pairs, but leave the pair logic for API consistency
         return self.prefix_tokens + token_ids_a + token_ids_a + [self.eos_token_id]






       def     SCREAMING_SNAKE_CASE			(      self:    int				,    _lowerCAmelCase:    List[int]				,    _lowerCAmelCase:    Optional[List[int]] = None				,    _lowerCAmelCase:    bool = False ):

         if already_has_special_tokens:
           return super().get_special_tokens_mask(
               token_ids_a=_lowerCAmelCase				,    token_ids_a=_lowerCAmelCase				,    already_has_special_tokens=_lowerCAmelCase )

         lowercase			:int							=  [1] * len(self.prefix_tokens )
         lowercase			:List[str]							=  [1]
         if token_ids_a is None:
           return prefix_ones + ([0] * len(_lowerCAmelCase )) + suffix_ones
         return prefix_ones + ([0] * len(_lowerCAmelCase )) + ([0] * len(_lowerCAmelCase )) + suffix_ones






       def     SCREAMING_SNAKE_CASE			(      self:    Dict ):
         lowercase			:int							=  self.encoder.copy()
         vocab.update(self.added_tokens_encoder )
         return vocab






       def __getstate__(      self:    Optional[Any] ):
         lowercase			:Union[str, Any]							=  self.__dict__.copy()
         lowercase			:Dict							=  None
         return state






       def __setstate__(      self:    Union[str, Any]				,    _lowerCAmelCase:    Dict ):
         lowercase			:List[Any]							=  d

         # for backward compatibility
         if not hasattr(self				,    "sp_model_kwargs" ):
           lowercase			:List[Any]							=  {}

         lowercase			:Union[str, Any]							=  load_spm(self.spm_file				,    self.sp_model_kwargs )






       def     SCREAMING_SNAKE_CASE			(      self:    Union[str, Any]				,    _lowerCAmelCase:    str				,    _lowerCAmelCase:    Optional[str] = None ):
         lowercase			:List[str]							=  Path(_lowerCAmelCase )
         assert save_dir.is_dir(), F"{save_directory} should be a directory"
         lowercase			:List[Any]							=  save_dir / (
             (filename_prefix + "-" if filename_prefix else "") + self.vocab_files_names["vocab_file"]
         )
         lowercase			:Any							=  save_dir / (
             (filename_prefix + "-" if filename_prefix else "") + self.vocab_files_names["spm_file"]
         )

         save_json(self.encoder				,    _lowerCAmelCase )

         if os.path.abspath(self.spm_file ) != os.path.abspath(_lowerCAmelCase ) and os.path.isfile(self.spm_file ):
           copyfile(self.spm_file				,    _lowerCAmelCase )
         elif not os.path.isfile(self.spm_file ):
           with open(_lowerCAmelCase				,    "wb" ) as fi:
             lowercase			:int							=  self.sp_model.serialized_model_proto()
             fi.write(_lowerCAmelCase )

         return (str(_lowerCAmelCase ), str(_lowerCAmelCase ))







def 					UpperCAmelCase__     (   lowerCamelCase,	lowerCamelCase      ):
  lowercase			:Tuple							=  sentencepiece.SentencePieceProcessor(**lowerCamelCase      )
  spm.Load(str(lowerCamelCase      )      )
  return spm



def 					UpperCAmelCase__     (   lowerCamelCase      ):
  with open(lowerCamelCase,	"r"      ) as f:
    return json.load(lowerCamelCase      )







def 					UpperCAmelCase__     (   lowerCamelCase,	lowerCamelCase      ):
  with open(lowerCamelCase,	"w"      ) as f:
    json.dump(lowerCamelCase,	lowerCamelCase,	indent=2      )



