





from __future__ import annotations

import unittest

from transformers import AutoTokenizer, GPTJConfig, is_tf_available
from transformers.testing_utils import require_tf, slow, tooslow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
from ...utils.test_modeling_tf_core import TFCoreModelTesterMixin


if is_tf_available():
       import tensorflow as tf

       from transformers.models.gptj.modeling_tf_gptj import (
           TFGPTJForCausalLM,
           TFGPTJForQuestionAnswering,
           TFGPTJForSequenceClassification,
           TFGPTJModel,
           shape_list,
       )





class A_      :




   def __init__(self			:Optional[Any]					,     _UpperCamelCase			:List[Any]				)->      Tuple:
         __A      =       parent
         __A      =       13
         __A      =       7
         __A      =       True
         __A      =       True
         __A      =       True
         __A      =       True
         __A      =       True
         __A      =       99
         __A      =       32
         __A      =       4
         __A      =       2
         __A      =       4
         __A      =       37
         __A      =       '''gelu'''
         __A      =       0.1
         __A      =       0.1
         __A      =       512
         __A      =       16
         __A      =       2
         __A      =       0.0_2
         __A      =       3
         __A      =       4
         __A      =       None
         __A      =       self.vocab_size - 1
         __A      =       self.vocab_size - 1
         __A      =       self.vocab_size - 1




   def _lowerCAmelCase   (self			:Dict				)->      int:
         __A      =       ids_tensor([self.batch_size, self.seq_length]					,     self.vocab_size				)

         __A      =       None
         if self.use_input_mask:
               __A      =       random_attention_mask([self.batch_size, self.seq_length]				)

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

         __A      =       None
         if self.use_mc_token_ids:
               __A      =       ids_tensor([self.batch_size, self.num_choices]					,     self.seq_length				)

         __A      =       None
         __A      =       None
         __A      =       None
         if self.use_labels:
               __A      =       ids_tensor([self.batch_size]					,     self.type_sequence_label_size				)
               __A      =       ids_tensor([self.batch_size, self.seq_length]					,     self.num_labels				)
               __A      =       ids_tensor([self.batch_size]					,     self.num_choices				)

         __A      =       GPTJConfig(
             vocab_size=self.vocab_size					,     n_embd=self.hidden_size					,     n_layer=self.num_hidden_layers					,     n_head=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					,     n_positions=self.max_position_embeddings					,     type_vocab_size=self.type_vocab_size					,     initializer_range=self.initializer_range					,     bos_token_id=self.bos_token_id					,     eos_token_id=self.eos_token_id					,     pad_token_id=self.pad_token_id					,     rotary_dim=self.rotary_dim					,     return_dict=_UpperCamelCase					,     )

         __A      =       ids_tensor([self.num_hidden_layers, self.num_attention_heads]					,     2				)

         return (
             config,
             input_ids,
             input_mask,
             head_mask,
             token_type_ids,
             mc_token_ids,
             sequence_labels,
             token_labels,
             choice_labels,
         )




   def _lowerCAmelCase   (self			:List[str]					,     _UpperCamelCase			:Dict					,     _UpperCamelCase			:List[str]					,     _UpperCamelCase			:List[str]					,     _UpperCamelCase			:Any					,     _UpperCamelCase			:Union[str, Any]					,     *_UpperCamelCase			:Dict				)->      Tuple:
         __A      =       TFGPTJModel(config=_UpperCamelCase				)
         __A      =       {
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }
         __A      =       model(_UpperCamelCase				)

         __A      =       [input_ids, None, input_mask]  # None is the input for 'past'
         __A      =       model(_UpperCamelCase				)

         __A      =       model(_UpperCamelCase				)

         self.parent.assertEqual(result.last_hidden_state.shape					,     (self.batch_size, self.seq_length, self.hidden_size)				)




   def _lowerCAmelCase   (self			:Union[str, Any]					,     _UpperCamelCase			:Optional[Any]					,     _UpperCamelCase			:Optional[int]					,     _UpperCamelCase			:Any					,     _UpperCamelCase			:int					,     _UpperCamelCase			:Union[str, Any]					,     *_UpperCamelCase			:List[str]				)->      str:
         __A      =       TFGPTJModel(config=_UpperCamelCase				)

         # first forward pass
         __A      =       model(_UpperCamelCase					,     token_type_ids=_UpperCamelCase					,     use_cache=_UpperCamelCase				)
         __A      =       model(_UpperCamelCase					,     token_type_ids=_UpperCamelCase				)
         __A      =       model(_UpperCamelCase					,     token_type_ids=_UpperCamelCase					,     use_cache=_UpperCamelCase				)

         self.parent.assertTrue(len(_UpperCamelCase				) == len(_UpperCamelCase				)				)
         self.parent.assertTrue(len(_UpperCamelCase				) == len(_UpperCamelCase				) + 1				)

         __A     ,		__A      =       outputs.to_tuple()

         # create hypothetical next token and extent to next_input_ids
         __A      =       ids_tensor((self.batch_size, 1)					,     config.vocab_size				)
         __A      =       ids_tensor([self.batch_size, 1]					,     self.type_vocab_size				)

         # append to next input_ids and token_type_ids
         __A      =       tf.concat([input_ids, next_tokens]					,     axis=-1				)
         __A      =       tf.concat([token_type_ids, next_token_types]					,     axis=-1				)

         __A      =       model(_UpperCamelCase					,     token_type_ids=_UpperCamelCase				)['''last_hidden_state''']
         __A      =       model(_UpperCamelCase					,     token_type_ids=_UpperCamelCase					,     past_key_values=_UpperCamelCase				)[
             '''last_hidden_state'''
         ]

         # select random slice
         __A      =       int(ids_tensor((1,)					,     shape_list(_UpperCamelCase				)[-1]				)				)
         __A      =       output_from_no_past[:, -1, random_slice_idx]
         __A      =       output_from_past[:, 0, random_slice_idx]

         # test that outputs are equal for slice
         tf.debugging.assert_near(_UpperCamelCase					,     _UpperCamelCase					,     rtol=1e-6				)




   def _lowerCAmelCase   (self			:Dict					,     _UpperCamelCase			:int					,     _UpperCamelCase			:Optional[int]					,     _UpperCamelCase			:int					,     _UpperCamelCase			:Tuple					,     _UpperCamelCase			:Dict					,     *_UpperCamelCase			:Optional[int]				)->      str:
         __A      =       TFGPTJModel(config=_UpperCamelCase				)

         # create attention mask
         __A      =       self.seq_length // 2
         __A      =       tf.ones((self.batch_size, half_seq_length)					,     dtype=tf.intaa				)
         __A      =       tf.zeros((self.batch_size, self.seq_length - half_seq_length)					,     dtype=tf.intaa				)
         __A      =       tf.concat([attn_mask_begin, attn_mask_end]					,     axis=1				)

         # first forward pass
         __A     ,		__A      =       model(_UpperCamelCase					,     attention_mask=_UpperCamelCase				).to_tuple()

         # create hypothetical next token and extent to next_input_ids
         __A      =       ids_tensor((self.batch_size, 1)					,     config.vocab_size				)

         # change a random masked slice from input_ids
         __A      =       ids_tensor((1,)					,     _UpperCamelCase				).numpy() + 1
         __A      =       ids_tensor((self.batch_size, self.seq_length)					,     config.vocab_size				)
         __A      =       tf.range(self.seq_length				) == (self.seq_length - random_seq_idx_to_change)
         __A      =       tf.transpose(
             tf.broadcast_to(tf.expand_dims(_UpperCamelCase					,     -1				)					,     (self.seq_length, self.batch_size)				)				)
         __A      =       tf.where(_UpperCamelCase					,     _UpperCamelCase					,     _UpperCamelCase				)

         # append to next input_ids and attn_mask
         __A      =       tf.concat([input_ids, next_tokens]					,     axis=-1				)
         __A      =       tf.concat([attn_mask, tf.ones((shape_list(_UpperCamelCase				)[0], 1)					,     dtype=tf.intaa				)]					,     axis=1				)

         # get two different outputs
         __A      =       model(_UpperCamelCase					,     attention_mask=_UpperCamelCase				)['''last_hidden_state''']
         __A      =       model(_UpperCamelCase					,     past_key_values=_UpperCamelCase					,     attention_mask=_UpperCamelCase				)[
             '''last_hidden_state'''
         ]

         # select random slice
         __A      =       int(ids_tensor((1,)					,     shape_list(_UpperCamelCase				)[-1]				)				)
         __A      =       output_from_no_past[:, -1, random_slice_idx]
         __A      =       output_from_past[:, 0, random_slice_idx]

         # test that outputs are equal for slice
         tf.debugging.assert_near(_UpperCamelCase					,     _UpperCamelCase					,     rtol=1e-12				)




   def _lowerCAmelCase   (self			:List[Any]					,     _UpperCamelCase			:Union[str, Any]					,     _UpperCamelCase			:int					,     _UpperCamelCase			:List[Any]					,     _UpperCamelCase			:str					,     _UpperCamelCase			:Optional[Any]					,     *_UpperCamelCase			:int				)->      Union[str, Any]:
         __A      =       TFGPTJModel(config=_UpperCamelCase				)

         __A      =       input_ids[:1, :]
         __A      =       input_mask[:1, :]
         __A      =       token_type_ids[:1, :]
         __A      =       1

         # first forward pass
         __A      =       model(_UpperCamelCase					,     attention_mask=_UpperCamelCase					,     token_type_ids=_UpperCamelCase					,     use_cache=_UpperCamelCase				)

         __A     ,		__A      =       outputs.to_tuple()

         # create hypothetical next token and extent to next_input_ids
         __A      =       ids_tensor((self.batch_size, 3)					,     config.vocab_size				)
         __A      =       ids_tensor((self.batch_size, 3)					,     2				)
         __A      =       ids_tensor((self.batch_size, 3)					,     self.type_vocab_size				)

         # append to next input_ids and token_type_ids
         __A      =       tf.concat([input_ids, next_tokens]					,     axis=-1				)
         __A      =       tf.concat([input_mask, next_attn_mask]					,     axis=-1				)
         __A      =       tf.concat([token_type_ids, next_token_types]					,     axis=-1				)

         __A      =       model(
             _UpperCamelCase					,     token_type_ids=_UpperCamelCase					,     attention_mask=_UpperCamelCase				)['''last_hidden_state''']
         __A      =       model(
             _UpperCamelCase					,     token_type_ids=_UpperCamelCase					,     attention_mask=_UpperCamelCase					,     past_key_values=_UpperCamelCase					,     )['''last_hidden_state''']
         self.parent.assertTrue(output_from_past.shape[1] == next_tokens.shape[1]				)

         # select random slice
         __A      =       int(ids_tensor((1,)					,     shape_list(_UpperCamelCase				)[-1]				)				)
         __A      =       output_from_no_past[:, -3:, random_slice_idx]
         __A      =       output_from_past[:, :, random_slice_idx]

         # test that outputs are equal for slice
         tf.debugging.assert_near(_UpperCamelCase					,     _UpperCamelCase					,     rtol=1e-3				)




   def _lowerCAmelCase   (self			:int					,     _UpperCamelCase			:List[str]					,     _UpperCamelCase			:Optional[Any]					,     _UpperCamelCase			:Union[str, Any]					,     _UpperCamelCase			:int					,     _UpperCamelCase			:str					,     *_UpperCamelCase			:Tuple				)->      str:
         __A      =       TFGPTJForCausalLM(config=_UpperCamelCase				)
         __A      =       {
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }
         __A      =       model(_UpperCamelCase				)
         self.parent.assertEqual(result.logits.shape					,     (self.batch_size, self.seq_length, self.vocab_size)				)






   def _lowerCAmelCase   (self			:int				)->      str:
         __A      =       self.prepare_config_and_inputs()

         (
             (
             __A
         )     ,		(
             __A
         )     ,		(
             __A
         )     ,		(
             __A
         )     ,		(
             __A
         )     ,		(
             __A
         )     ,		(
             __A
         )     ,		(
             __A
         )     ,		(
             __A
         )     ,		
         )      =       config_and_inputs

         __A      =       {
             '''input_ids''': input_ids,
             '''token_type_ids''': token_type_ids,
             '''attention_mask''': input_mask,
         }
         return config, inputs_dict





@require_tf
class A_      (    _lowerCamelCase				,   _lowerCamelCase				,   _lowerCamelCase				,   unittest.TestCase     ):
   lowerCAmelCase__       =				(
       (TFGPTJForCausalLM, TFGPTJForSequenceClassification, TFGPTJForQuestionAnswering, TFGPTJModel)
       if is_tf_available()
       else ()
   )

   lowerCAmelCase__       =				(TFGPTJForCausalLM,) if is_tf_available() else ()
   lowerCAmelCase__       =				(
       {
           """feature-extraction""": TFGPTJModel,
           """question-answering""": TFGPTJForQuestionAnswering,
           """text-classification""": TFGPTJForSequenceClassification,
           """text-generation""": TFGPTJForCausalLM,
           """zero-shot""": TFGPTJForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   lowerCAmelCase__       =				False
   lowerCAmelCase__       =				False
   lowerCAmelCase__       =				False
   lowerCAmelCase__       =				False




   def _lowerCAmelCase   (self			:Union[str, Any]					,     _UpperCamelCase			:Optional[int]					,     _UpperCamelCase			:List[Any]					,     _UpperCamelCase			:Optional[int]					,     _UpperCamelCase			:str					,     _UpperCamelCase			:str				)->      Union[str, Any]:
         if (
             pipeline_test_casse_name == "QAPipelineTests"
             and tokenizer_name is not None
             and not tokenizer_name.endswith('''Fast'''				)
         ):
               # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
               # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
               # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
               return True

         return False




   def _lowerCAmelCase   (self			:Optional[int]				)->      int:
         __A      =       TFGPTJModelTester(self				)
         __A      =       ConfigTester(self					,     config_class=_UpperCamelCase					,     n_embd=37				)




   def _lowerCAmelCase   (self			:Optional[Any]				)->      List[str]:
         self.config_tester.run_common_tests()




   def _lowerCAmelCase   (self			:Optional[int]				)->      Tuple:
         __A      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_gptj_model(*_UpperCamelCase				)




   def _lowerCAmelCase   (self			:str				)->      str:
         __A      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_gptj_model_past(*_UpperCamelCase				)




   def _lowerCAmelCase   (self			:Any				)->      Any:
         __A      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_gptj_model_attention_mask_past(*_UpperCamelCase				)




   def _lowerCAmelCase   (self			:Dict				)->      Union[str, Any]:
         __A      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_gptj_model_past_large_inputs(*_UpperCamelCase				)




   def _lowerCAmelCase   (self			:Optional[Any]				)->      Dict:
         __A      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_gptj_lm_head_model(*_UpperCamelCase				)




   @slow
   @unittest.skipIf(
       not is_tf_available() or len(tf.config.list_physical_devices('''GPU'''				)				) > 0					,     '''skip testing on GPU for now to avoid GPU OOM.'''					,     )
   def _lowerCAmelCase   (self			:Tuple				)->      Tuple:
         __A      =       TFGPTJModel.from_pretrained('''EleutherAI/gpt-j-6B'''					,     from_pt=_UpperCamelCase				)
         self.assertIsNotNone(_UpperCamelCase				)






   @unittest.skip(reason='''Currently, model embeddings are going to undergo a major refactor.'''				)
   def _lowerCAmelCase   (self			:List[str]				)->      Optional[Any]:
         super().test_resize_token_embeddings()





@require_tf
@tooslow
# Marked as @tooslow due to GPU OOM -- but still useful to run locally. Requires ~39GB of RAM.
class A_      (    unittest.TestCase     ):




   def _lowerCAmelCase   (self			:List[str]				)->      Union[str, Any]:
         __A      =       TFGPTJForCausalLM.from_pretrained('''EleutherAI/gpt-j-6B'''					,     from_pt=_UpperCamelCase				)
         __A      =       tf.convert_to_tensor([[464, 3290]]					,     dtype=tf.intaa				)  # The dog
         # fmt: off
         # The dog is a man's best friend. It is a loyal companion, and it is a friend
         __A      =       [464, 3290, 318, 257, 582, 338, 1266, 1545, 13, 632, 318, 257, 9112, 1_5185, 11, 290, 340, 318, 257, 1545]
         # fmt: on
         __A      =       model.generate(_UpperCamelCase					,     do_sample=_UpperCamelCase				)
         self.assertListEqual(output_ids[0].numpy().tolist()					,     _UpperCamelCase				)




   def _lowerCAmelCase   (self			:str				)->      Union[str, Any]:
         __A      =       AutoTokenizer.from_pretrained('''EleutherAI/gpt-j-6B'''					,     revision='''float16'''				)
         __A      =       TFGPTJForCausalLM.from_pretrained('''EleutherAI/gpt-j-6B'''					,     revision='''float16'''					,     from_pt=_UpperCamelCase				)

         __A      =       tokenizer('''Today is a nice day and'''					,     return_tensors='''tf'''				)
         # forces the generation to happen on CPU, to avoid GPU-related quirks
         with tf.device(''':/CPU:0'''				):
               __A      =       model.generate(**_UpperCamelCase					,     do_sample=_UpperCamelCase					,     seed=[42, 0]				)
         __A      =       tokenizer.decode(output_ids[0]					,     skip_special_tokens=_UpperCamelCase				)

         __A      =       '''Today is a nice day and I’m going to go for a walk. I’'''
         self.assertEqual(_UpperCamelCase					,     _UpperCamelCase				)




   def _lowerCAmelCase   (self			:Optional[Any]				)->      str:
         __A      =       TFGPTJForCausalLM.from_pretrained('''EleutherAI/gpt-j-6B'''					,     revision='''float16'''					,     from_pt=_UpperCamelCase				)
         __A      =       AutoTokenizer.from_pretrained('''EleutherAI/gpt-j-6B'''					,     revision='''float16'''				)

         __A      =       '''left'''

         # Define PAD Token = EOS Token = 50256
         __A      =       tokenizer.eos_token
         __A      =       model.config.eos_token_id

         # use different length sentences to test batching
         __A      =       [
             '''Hello, my dog is a little''',
             '''Today, I''',
         ]
         __A      =       [
             '''Hello, my dog is a little over a year old and has been diagnosed with hip dysplasia''',
             '''Today, I’m going to be talking about a topic that’''',
         ]
         return model, tokenizer, sentences, expected_output_sentences




   def _lowerCAmelCase   (self			:int				)->      str:
         # Confirms that we get the expected results with left-padded beam search
         __A     ,		__A     ,		__A     ,		__A      =       self._get_beam_search_test_objects()

         __A      =       tokenizer(_UpperCamelCase					,     return_tensors='''tf'''					,     padding=_UpperCamelCase				)
         __A      =       model.generate(**_UpperCamelCase					,     do_sample=_UpperCamelCase					,     num_beams=2				)
         __A      =       tokenizer.batch_decode(_UpperCamelCase					,     skip_special_tokens=_UpperCamelCase				)
         self.assertListEqual(_UpperCamelCase					,     _UpperCamelCase				)




   def _lowerCAmelCase   (self			:int				)->      Union[str, Any]:
         # Confirms that left-padding is working properly
         __A     ,		__A     ,		__A     ,		__A      =       self._get_beam_search_test_objects()

         __A      =       tokenizer(_UpperCamelCase					,     return_tensors='''tf'''					,     padding=_UpperCamelCase				)
         __A      =       tokenizer(sentences[0]					,     return_tensors='''tf'''				)
         __A      =       model.generate(**_UpperCamelCase					,     do_sample=_UpperCamelCase					,     num_beams=2				)
         __A      =       (
             shape_list(inputs_non_padded['''input_ids''']				)[-1]
             - tf.reduce_sum(tf.cast(inputs['''attention_mask'''][-1]					,     tf.intaa				)				).numpy()
         )
         __A      =       tokenizer(sentences[1]					,     return_tensors='''tf'''				)
         __A      =       model.generate(
             **_UpperCamelCase					,     do_sample=_UpperCamelCase					,     num_beams=2					,     max_length=model.config.max_length - num_paddings				)
         __A      =       tokenizer.decode(output_non_padded[0]					,     skip_special_tokens=_UpperCamelCase				)
         __A      =       tokenizer.decode(output_padded[0]					,     skip_special_tokens=_UpperCamelCase				)
         self.assertListEqual(_UpperCamelCase					,     [non_padded_sentence, padded_sentence]				)






   def _lowerCAmelCase   (self			:Union[str, Any]				)->      List[str]:
         # Confirms that XLA is working properly
         __A     ,		__A     ,		__A     ,		__A      =       self._get_beam_search_test_objects()

         __A      =       tokenizer(_UpperCamelCase					,     return_tensors='''tf'''					,     padding=_UpperCamelCase				)
         __A      =       tf.function(model.generate					,     jit_compile=_UpperCamelCase				)
         __A      =       xla_generate(**_UpperCamelCase					,     do_sample=_UpperCamelCase					,     num_beams=2				)
         __A      =       tokenizer.batch_decode(_UpperCamelCase					,     skip_special_tokens=_UpperCamelCase				)
         self.assertListEqual(_UpperCamelCase					,     _UpperCamelCase				)












from ...configuration_utils import PretrainedConfig
from ...utils import logging


snake_case__      :							Optional[Any]									=  logging.get_logger(__name__)

snake_case__      :							List[str]									=  {
    'uw-madison/nystromformer-512': 'https://huggingface.co/uw-madison/nystromformer-512/resolve/main/config.json',
    # See all Nystromformer models at https://huggingface.co/models?filter=nystromformer
}





class A_      (    _lowerCamelCase     ):
   lowerCAmelCase__       =				"""nystromformer"""




   def __init__(self			:Union[str, Any]					,     _UpperCamelCase			:Optional[int]=3_0000					,     _UpperCamelCase			:Optional[int]=768					,     _UpperCamelCase			:List[str]=12					,     _UpperCamelCase			:Dict=12					,     _UpperCamelCase			:Any=3072					,     _UpperCamelCase			:List[str]="gelu_new"					,     _UpperCamelCase			:str=0.1					,     _UpperCamelCase			:Dict=0.1					,     _UpperCamelCase			:List[Any]=510					,     _UpperCamelCase			:str=2					,     _UpperCamelCase			:List[str]=64					,     _UpperCamelCase			:List[str]=64					,     _UpperCamelCase			:Optional[int]=65					,     _UpperCamelCase			:Optional[int]=False					,     _UpperCamelCase			:Optional[int]=0.0_2					,     _UpperCamelCase			:Dict=1e-5					,     _UpperCamelCase			:Tuple=1					,     _UpperCamelCase			:Union[str, Any]=0					,     _UpperCamelCase			:Optional[int]=2					,     **_UpperCamelCase			:Dict					,     )->      Any:
         __A      =       vocab_size
         __A      =       max_position_embeddings
         __A      =       hidden_size
         __A      =       num_hidden_layers
         __A      =       num_attention_heads
         __A      =       intermediate_size
         __A      =       hidden_act
         __A      =       hidden_dropout_prob
         __A      =       attention_probs_dropout_prob
         __A      =       initializer_range
         __A      =       type_vocab_size
         __A      =       segment_means_seq_len
         __A      =       num_landmarks
         __A      =       conv_kernel_size
         __A      =       inv_coeff_init_option
         __A      =       layer_norm_eps
         super().__init__(pad_token_id=_UpperCamelCase					,     bos_token_id=_UpperCamelCase					,     eos_token_id=_UpperCamelCase					,     **_UpperCamelCase				)





