
import io
import os
import unicodedata
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


__lowerCAmelCase			:     Dict           =   logging.get_logger(__name__)

__lowerCAmelCase			:     str           =   '▁'

__lowerCAmelCase			:     List[str]           =   {'vocab_file': 'vocab.txt', 'sentencepiece_model_ckpt': 'sentencepiece.bpe.model'}

__lowerCAmelCase			:     List[str]           =   {
    'sentencepiece_model_file': 'sentencepiece.bpe.model',
    'vocab_file': 'vocab.txt',
}

__lowerCAmelCase			:     Any           =   {
    'vocab_file': {
        'ernie-m-base': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt',
        'ernie-m-large': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt',
    },
    'sentencepiece_model_file': {
        'ernie-m-base': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model',
        'ernie-m-large': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model',
    },
}

__lowerCAmelCase			:     Optional[int]           =   {
    'ernie-m-base': 514,
    'ernie-m-large': 514,
}

__lowerCAmelCase			:     Union[str, Any]           =   {
    'ernie-m-base': {'do_lower_case': False},
    'ernie-m-large': {'do_lower_case': False},
}




class        UpperCAmelCase_			( __lowerCamelCase     ):


  '''simple docstring'''







  a__           =		["input_ids"]

  a__           =		VOCAB_FILES_NAMES
  a__           =		PRETRAINED_INIT_CONFIGURATION
  a__           =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  a__           =		PRETRAINED_VOCAB_FILES_MAP
  a__           =		RESOURCE_FILES_NAMES
  def __init__( self			: Union[str, Any]			,							UpperCamelCase__			: Any			,							UpperCamelCase__			: Union[str, Any]=None			,							UpperCamelCase__			: str=False			,							UpperCamelCase__			: Union[str, Any]="utf8"			,							UpperCamelCase__			: int="[UNK]"			,							UpperCamelCase__			: Union[str, Any]="[SEP]"			,							UpperCamelCase__			: Optional[Any]="[PAD]"			,							UpperCamelCase__			: Dict="[CLS]"			,							UpperCamelCase__			: Any="[MASK]"			,							UpperCamelCase__			: Optional[Dict[str, Any]] = None			,							**UpperCamelCase__			: Union[str, Any]			,							)			->	Dict:







    """simple docstring"""






    __magic_name__				     =       {} if sp_model_kwargs is None else sp_model_kwargs
    super().__init__(
        do_lower_case=UpperCamelCase_			,							unk_token=UpperCamelCase_			,							sep_token=UpperCamelCase_			,							pad_token=UpperCamelCase_			,							cls_token=UpperCamelCase_			,							mask_token=UpperCamelCase_			,							vocab_file=UpperCamelCase_			,							encoding=UpperCamelCase_			,							sp_model_kwargs=self.sp_model_kwargs			,							**UpperCamelCase_			,							)
    __magic_name__				     =       do_lower_case
    __magic_name__				     =       sentencepiece_model_ckpt
    __magic_name__				     =       spm.SentencePieceProcessor(**self.sp_model_kwargs    )
    self.sp_model.Load(UpperCamelCase_    )

    # to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning
    if vocab_file is not None:
      __magic_name__				     =       self.load_vocab(filepath=UpperCamelCase_    )
    else:
      __magic_name__				     =       {self.sp_model.id_to_piece(UpperCamelCase_    ): id for id in range(self.sp_model.get_piece_size()    )}
    __magic_name__				     =       {v: k for k, v in self.vocab.items()}
  def 							_lowercase							( self			: List[str]			,							UpperCamelCase__			: Optional[int]    )			->	Optional[Any]:







    """simple docstring"""






    if text is None:
      return None

    __magic_name__				     =       self.tokenize(UpperCamelCase_    )
    __magic_name__     ,    __magic_name__				     =       """""", []

    for i, ch in enumerate(UpperCamelCase_    ):
      if ch in self.SP_CHAR_MAPPING:
        __magic_name__				     =       self.SP_CHAR_MAPPING.get(UpperCamelCase_    )
      else:
        __magic_name__				     =       unicodedata.normalize("""NFKC"""			,							UpperCamelCase_    )
      if self.is_whitespace(UpperCamelCase_    ):
        continue
      normalized_text += ch
      char_mapping.extend([i] * len(UpperCamelCase_    )    )

    __magic_name__     ,    __magic_name__     ,    __magic_name__				     =       normalized_text, [], 0

    if self.do_lower_case:
      __magic_name__				     =       text.lower()

    for token in split_tokens:
      if token[:1] == "▁":
        __magic_name__				     =       token[1:]
      __magic_name__				     =       text[offset:].index(UpperCamelCase_    ) + offset
      __magic_name__				     =       start + len(UpperCamelCase_    )

      token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1)    )
      __magic_name__				     =       end
    return token_mapping
  @property
  def 							_lowercase							( self			: Optional[int]    )			->	Optional[int]:







    """simple docstring"""






    return len(self.vocab    )
  def 							_lowercase							( self			: List[str]    )			->	List[str]:







    """simple docstring"""






    return dict(self.vocab			,							**self.added_tokens_encoder    )
  def __getstate__( self			: List[Any]    )			->	Tuple:







    """simple docstring"""






    __magic_name__				     =       self.__dict__.copy()
    __magic_name__				     =       None
    return state
  def __setstate__( self			: str			,							UpperCamelCase__			: Optional[Any]    )			->	Tuple:







    """simple docstring"""






    __magic_name__				     =       d

    # for backward compatibility
    if not hasattr(self			,							"""sp_model_kwargs"""    ):
      __magic_name__				     =       {}

    __magic_name__				     =       spm.SentencePieceProcessor(**self.sp_model_kwargs    )
    self.sp_model.Load(self.sentencepiece_model_ckpt    )
  def 							_lowercase							( self			: List[Any]			,							UpperCamelCase__			: List[Any]    )			->	List[Any]:







    """simple docstring"""






    return "".join((self.SP_CHAR_MAPPING.get(UpperCamelCase_			,							UpperCamelCase_    ) for c in text)    )
  def 							_lowercase							( self			: Union[str, Any]			,							UpperCamelCase__			: Tuple			,							UpperCamelCase__			: Any=False			,							UpperCamelCase__			: Union[str, Any]=64			,							UpperCamelCase__			: Union[str, Any]=0.1    )			->	List[str]:







    """simple docstring"""






    if self.sp_model_kwargs.get("""enable_sampling"""    ) is True:
      __magic_name__				     =       True
    if self.sp_model_kwargs.get("""alpha"""    ) is not None:
      __magic_name__				     =       self.sp_model_kwargs.get("""alpha"""    )
    if self.sp_model_kwargs.get("""nbest_size"""    ) is not None:
      __magic_name__				     =       self.sp_model_kwargs.get("""nbest_size"""    )

    if not enable_sampling:
      __magic_name__				     =       self.sp_model.EncodeAsPieces(UpperCamelCase_    )
    else:
      __magic_name__				     =       self.sp_model.SampleEncodeAsPieces(UpperCamelCase_			,							UpperCamelCase_			,							UpperCamelCase_    )
    __magic_name__				     =       []
    for pi, piece in enumerate(UpperCamelCase_    ):
      if piece == SPIECE_UNDERLINE:
        if not pieces[pi + 1].startswith(UpperCamelCase_    ) and pi != 0:
          new_pieces.append(UpperCamelCase_    )
          continue
        else:
          continue
      __magic_name__				     =       0
      for i, chunk in enumerate(UpperCamelCase_    ):
        if chunk == SPIECE_UNDERLINE:
          continue
        if self.is_ch_char(UpperCamelCase_    ) or self.is_punct(UpperCamelCase_    ):
          if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
            new_pieces.append(piece[lst_i:i]    )
          new_pieces.append(UpperCamelCase_    )
          __magic_name__				     =       i + 1
        elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit():
          if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
            new_pieces.append(piece[lst_i:i]    )
          __magic_name__				     =       i
        elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit():
          if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
            new_pieces.append(piece[lst_i:i]    )
          __magic_name__				     =       i
      if len(UpperCamelCase_    ) > lst_i:
        new_pieces.append(piece[lst_i:]    )
    return new_pieces
  def 							_lowercase							( self			: List[Any]			,							UpperCamelCase__			: Any    )			->	Any:







    """simple docstring"""






    __magic_name__				     =       """""".join(UpperCamelCase_    ).replace(UpperCamelCase_			,							""" """    ).strip()
    return out_string
  def 							_lowercase							( self			: List[Any]			,							UpperCamelCase__			: Tuple    )			->	Any:







    """simple docstring"""






    __magic_name__				     =       self.convert_ids_to_tokens(UpperCamelCase_    )
    __magic_name__				     =       """""".join(UpperCamelCase_    ).replace(UpperCamelCase_			,							""" """    ).strip()
    return out_string
  def 							_lowercase							( self			: List[str]			,							UpperCamelCase__			: Optional[Any]    )			->	Optional[int]:







    """simple docstring"""






    return self.vocab.get(UpperCamelCase_			,							self.vocab.get(self.unk_token    )    )
  def 							_lowercase							( self			: Optional[int]			,							UpperCamelCase__			: str    )			->	Tuple:







    """simple docstring"""






    return self.reverse_vocab.get(UpperCamelCase_			,							self.unk_token    )
  def 							_lowercase							( self			: str			,							UpperCamelCase__			: Any			,							UpperCamelCase__			: str=None    )			->	Any:







    """simple docstring"""






    if token_ids_a is None:
      return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
    __magic_name__				     =       [self.cls_token_id]
    __magic_name__				     =       [self.sep_token_id]
    return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep
  def 							_lowercase							( self			: Any			,							UpperCamelCase__			: int			,							UpperCamelCase__			: List[str]=None    )			->	str:







    """simple docstring"""






    if offset_mapping_a is None:
      return [(0, 0)] + offset_mapping_a + [(0, 0)]

    return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)]
  def 							_lowercase							( self			: Dict			,							UpperCamelCase__			: List[str]			,							UpperCamelCase__			: Tuple=None			,							UpperCamelCase__			: List[str]=False    )			->	Tuple:







    """simple docstring"""






    if already_has_special_tokens:
      if token_ids_a is not None:
        raise ValueError(
            """You should not supply a second sequence if the provided sequence of """
            """ids is already formatted with special tokens for the model."""    )
      return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]

    if token_ids_a is not None:
      return [1] + ([0] * len(UpperCamelCase_    )) + [1, 1] + ([0] * len(UpperCamelCase_    )) + [1]
    return [1] + ([0] * len(UpperCamelCase_    )) + [1]
  def 							_lowercase							( self			: Optional[int]			,							UpperCamelCase__			: List[int]			,							UpperCamelCase__			: Optional[List[int]] = None    )			->	Union[str, Any]:







    """simple docstring"""






    if token_ids_a is None:
      # [CLS] X [SEP]
      return (len(UpperCamelCase_    ) + 2) * [0]

    # [CLS] A [SEP] [SEP] B [SEP]
    return [0] * (len(UpperCamelCase_    ) + 1) + [1] * (len(UpperCamelCase_    ) + 3)
  def 							_lowercase							( self			: Union[str, Any]			,							UpperCamelCase__			: List[str]    )			->	Dict:







    """simple docstring"""






    if "\u4e00" <= char <= "\u9fff":
      return True
    return False
  def 							_lowercase							( self			: List[Any]			,							UpperCamelCase__			: List[str]    )			->	Dict:







    """simple docstring"""






    if ("a" <= char <= "z") or ("A" <= char <= "Z"):
      return True
    return False
  def 							_lowercase							( self			: Dict			,							UpperCamelCase__			: List[str]    )			->	Optional[Any]:







    """simple docstring"""






    if char in ",;:.?!~，；：。？！《》【】":
      return True
    return False
  def 							_lowercase							( self			: Dict			,							UpperCamelCase__			: Union[str, Any]    )			->	Dict:







    """simple docstring"""






    if char == " " or char == "\t" or char == "\n" or char == "\r":
      return True
    if len(UpperCamelCase_    ) == 1:
      __magic_name__				     =       unicodedata.category(UpperCamelCase_    )
      if cat == "Zs":
        return True
    return False
  def 							_lowercase							( self			: Optional[int]			,							UpperCamelCase__			: int    )			->	Union[str, Any]:







    """simple docstring"""






    __magic_name__				     =       {}
    with io.open(UpperCamelCase_			,							"""r"""			,							encoding="""utf-8"""    ) as f:
      for index, line in enumerate(UpperCamelCase_    ):
        __magic_name__				     =       line.rstrip("""\n"""    )
        __magic_name__				     =       int(UpperCamelCase_    )

    return token_to_idx





  def 							_lowercase							( self			: List[str]			,							UpperCamelCase__			: str			,							UpperCamelCase__			: Optional[str] = None    )			->	int:







    """simple docstring"""






    __magic_name__				     =       0
    if os.path.isdir(UpperCamelCase_    ):
      __magic_name__				     =       os.path.join(
          UpperCamelCase_			,							(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]    )
    else:
      __magic_name__				     =       (filename_prefix + """-""" if filename_prefix else """""") + save_directory
    with open(UpperCamelCase_			,							"""w"""			,							encoding="""utf-8"""    ) as writer:
      for token, token_index in sorted(self.vocab.items()			,							key=lambda UpperCamelCase__    : kv[1]    ):
        if index != token_index:
          logger.warning(
              F'''Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.'''
              """ Please check that the vocabulary is not corrupted!"""    )
          __magic_name__				     =       token_index
        writer.write(token + """\n"""    )
        index += 1

    __magic_name__				     =       os.path.join(UpperCamelCase_			,							"""sentencepiece.bpe.model"""    )
    with open(UpperCamelCase_			,							"""wb"""    ) as fi:
      __magic_name__				     =       self.sp_model.serialized_model_proto()
      fi.write(UpperCamelCase_    )

    return (vocab_file,)







import unittest

from transformers import BigBirdConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
       import jax

       from transformers.models.big_bird.modeling_flax_big_bird import (
           FlaxBigBirdForCausalLM,
           FlaxBigBirdForMaskedLM,
           FlaxBigBirdForMultipleChoice,
           FlaxBigBirdForPreTraining,
           FlaxBigBirdForQuestionAnswering,
           FlaxBigBirdForSequenceClassification,
           FlaxBigBirdForTokenClassification,
           FlaxBigBirdModel,
       )





class     lowerCamelCase__(					unittest.TestCase):
      def __init__(				self: Optional[int]    ,       UpperCamelCase_: Any    ,       UpperCamelCase_: int=2    ,       UpperCamelCase_: Optional[Any]=56    ,       UpperCamelCase_: Tuple=True    ,       UpperCamelCase_: Union[str, Any]=True    ,       UpperCamelCase_: Optional[Any]=True    ,       UpperCamelCase_: str=True    ,       UpperCamelCase_: str=99    ,       UpperCamelCase_: Tuple=32    ,       UpperCamelCase_: int=2    ,       UpperCamelCase_: Optional[int]=2    ,       UpperCamelCase_: Tuple=7    ,       UpperCamelCase_: Optional[int]="gelu_new"    ,       UpperCamelCase_: Any=0.1    ,       UpperCamelCase_: List[str]=0.1    ,       UpperCamelCase_: List[Any]=5_12    ,       UpperCamelCase_: Union[str, Any]=16    ,       UpperCamelCase_: int=2    ,       UpperCamelCase_: Dict=0.02    ,       UpperCamelCase_: Tuple=4    ,       UpperCamelCase_: Union[str, Any]="block_sparse"    ,       UpperCamelCase_: Optional[Any]=True    ,       UpperCamelCase_: Any=False    ,       UpperCamelCase_: Any=2    ,       UpperCamelCase_: int=3    ,       ):
             __lowerCamelCase   =						parent
             __lowerCamelCase   =						batch_size
             __lowerCamelCase   =						seq_length
             __lowerCamelCase   =						is_training
             __lowerCamelCase   =						use_attention_mask
             __lowerCamelCase   =						use_token_type_ids
             __lowerCamelCase   =						use_labels
             __lowerCamelCase   =						vocab_size
             __lowerCamelCase   =						hidden_size
             __lowerCamelCase   =						num_hidden_layers
             __lowerCamelCase   =						num_attention_heads
             __lowerCamelCase   =						intermediate_size
             __lowerCamelCase   =						hidden_act
             __lowerCamelCase   =						hidden_dropout_prob
             __lowerCamelCase   =						attention_probs_dropout_prob
             __lowerCamelCase   =						max_position_embeddings
             __lowerCamelCase   =						type_vocab_size
             __lowerCamelCase   =						type_sequence_label_size
             __lowerCamelCase   =						initializer_range
             __lowerCamelCase   =						num_choices

             __lowerCamelCase   =						rescale_embeddings
             __lowerCamelCase   =						attention_type
             __lowerCamelCase   =						use_bias
             __lowerCamelCase   =						block_size
             __lowerCamelCase   =						num_random_blocks
      def 			lowerCAmelCase__						(				self: int   ):
             __lowerCamelCase   =						ids_tensor([self.batch_size, self.seq_length]    ,       self.vocab_size   )

             __lowerCamelCase   =						None
             if self.use_attention_mask:
                    __lowerCamelCase   =						random_attention_mask([self.batch_size, self.seq_length]   )

             __lowerCamelCase   =						None
             if self.use_token_type_ids:
                    __lowerCamelCase   =						ids_tensor([self.batch_size, self.seq_length]    ,       self.type_vocab_size   )

             __lowerCamelCase   =						BigBirdConfig(
                 vocab_size=self.vocab_size    ,       hidden_size=self.hidden_size    ,       num_hidden_layers=self.num_hidden_layers    ,       num_attention_heads=self.num_attention_heads    ,       intermediate_size=self.intermediate_size    ,       hidden_act=self.hidden_act    ,       hidden_dropout_prob=self.hidden_dropout_prob    ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,       max_position_embeddings=self.max_position_embeddings    ,       type_vocab_size=self.type_vocab_size    ,       is_decoder=UpperCamelCase_    ,       initializer_range=self.initializer_range    ,       attention_type=self.attention_type    ,       block_size=self.block_size    ,       num_random_blocks=self.num_random_blocks    ,       use_bias=self.use_bias    ,       rescale_embeddings=self.rescale_embeddings    ,       )

             return config, input_ids, token_type_ids, attention_mask




      def 			lowerCAmelCase__						(				self: Dict   ):
             __lowerCamelCase   =						self.prepare_config_and_inputs()
             __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase,   __lowerCamelCase   =						config_and_inputs
             __lowerCamelCase   =						{
                 """input_ids""": input_ids,
                 """token_type_ids""": token_type_ids,
                 """attention_mask""": attention_mask,
             }
             return config, inputs_dict





@require_flax
class     lowerCamelCase__(					__lowerCamelCase ,     unittest.TestCase):
      UpperCAmelCase__      :	Optional[int]    		=   (
          (
              FlaxBigBirdForCausalLM,
              FlaxBigBirdModel,
              FlaxBigBirdForPreTraining,
              FlaxBigBirdForMaskedLM,
              FlaxBigBirdForMultipleChoice,
              FlaxBigBirdForQuestionAnswering,
              FlaxBigBirdForSequenceClassification,
              FlaxBigBirdForTokenClassification,
          )
          if is_flax_available()
          else ()
      )

      UpperCAmelCase__      :	Optional[int]    		=   False
      UpperCAmelCase__      :	Optional[int]    		=   False
      def 			lowerCAmelCase__						(				self: List[str]   ):
             __lowerCamelCase   =						FlaxBigBirdModelTester(self   )
      @slow
      # copied from `test_modeling_flax_common` because it takes much longer than other models
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             super().test_from_pretrained_save_pretrained()
      @slow
      # copied from `test_modeling_flax_common` because it takes much longer than other models
      def 			lowerCAmelCase__						(				self: List[Any]   ):
             super().test_from_pretrained_with_no_automatic_init()
      @slow
      # copied from `test_modeling_flax_common` because it takes much longer than other models
      def 			lowerCAmelCase__						(				self: List[Any]   ):
             super().test_no_automatic_init()
      @slow
      # copied from `test_modeling_flax_common` because it takes much longer than other models
      def 			lowerCAmelCase__						(				self: List[str]   ):
             super().test_hidden_states_output()
      @slow
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             for model_class_name in self.all_model_classes:
                    __lowerCamelCase   =						model_class_name.from_pretrained("""google/bigbird-roberta-base"""   )
                    self.assertIsNotNone(UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: Dict   ):
             if self.test_attn_probs:
                    super().test_attention_outputs()
      @slow
      # copied from `test_modeling_flax_common` because it takes much longer than other models
      def 			lowerCAmelCase__						(				self: List[Any]   ):
             __lowerCamelCase,   __lowerCamelCase   =						self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                    with self.subTest(model_class.__name__   ):
                           __lowerCamelCase   =						self._prepare_for_class(UpperCamelCase_    ,       UpperCamelCase_   )
                           __lowerCamelCase   =						model_class(UpperCamelCase_   )

                           @jax.jit
                           def model_jitted(UpperCamelCase_: Tuple    ,       UpperCamelCase_: List[Any]=None    ,       **UpperCamelCase_: Union[str, Any]   ):
                                  return model(input_ids=UpperCamelCase_    ,       attention_mask=UpperCamelCase_    ,       **UpperCamelCase_   )

                           with self.subTest("""JIT Enabled"""   ):
                                  __lowerCamelCase   =						model_jitted(**UpperCamelCase_   ).to_tuple()

                           with self.subTest("""JIT Disabled"""   ):
                                  with jax.disable_jit():
                                         __lowerCamelCase   =						model_jitted(**UpperCamelCase_   ).to_tuple()

                           self.assertEqual(len(UpperCamelCase_   )    ,       len(UpperCamelCase_   )   )
                           for jitted_output, output in zip(UpperCamelCase_    ,       UpperCamelCase_   ):
                                  self.assertEqual(jitted_output.shape    ,       output.shape   )




      def 			lowerCAmelCase__						(				self: List[Any]    ,       UpperCamelCase_: int    ,       UpperCamelCase_: List[str]    ,       UpperCamelCase_: Any    ,       UpperCamelCase_: Dict=1E-5    ,       UpperCamelCase_: List[str]="outputs"    ,       UpperCamelCase_: List[str]=None   ):
             # `bigbird_block_sparse_attention` in `FlaxBigBird` returns `attention_probs = None`, while in PyTorch version,
             # an effort was done to return `attention_probs` (yet to be verified).
             if name.startswith("""outputs.attentions"""   ):
                    return
             else:
                    super().check_pt_flax_outputs(UpperCamelCase_    ,       UpperCamelCase_    ,       UpperCamelCase_    ,       UpperCamelCase_    ,       UpperCamelCase_    ,       UpperCamelCase_   )

