



"""simple docstring"""
import itertools
import json
import os
import unittest

from transformers import AddedToken, LongformerTokenizer, LongformerTokenizerFast
from transformers.models.longformer.tokenization_longformer import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


@require_tokenizers
class 							lowerCamelCase_(   __a,				unittest.TestCase    ):





					'''simple docstring'''



					lowercase__   :       Optional[Any]										= LongformerTokenizer
					lowercase__   :       str										= True
					lowercase__   :       List[str]										= LongformerTokenizerFast
					lowercase__   :       Union[str, Any]										= True

					def 			snake_case__      (    self   ):
									super().setUp()

									# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
									_lowerCamelCase        =				[
									    """l""",
									    """o""",
									    """w""",
									    """e""",
									    """r""",
									    """s""",
									    """t""",
									    """i""",
									    """d""",
									    """n""",
									    """\u0120""",
									    """\u0120l""",
									    """\u0120n""",
									    """\u0120lo""",
									    """\u0120low""",
									    """er""",
									    """\u0120lowest""",
									    """\u0120newer""",
									    """\u0120wider""",
									    """<unk>""",
									]
									_lowerCamelCase        =				dict(zip(a_				,       range(len(a_   )   )   )   )
									_lowerCamelCase        =				["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
									_lowerCamelCase        =				{"""unk_token""": """<unk>"""}

									_lowerCamelCase        =				os.path.join(self.tmpdirname				,       VOCAB_FILES_NAMES['''vocab_file''']   )
									_lowerCamelCase        =				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(a_   ) + '''\n'''   )
									with open(self.merges_file				,       '''w'''				,       encoding='''utf-8'''   ) as fp:
													fp.write('''\n'''.join(a_   )   )

					def 			snake_case__      (    self				,       **lowerCamelCase__   ):
									kwargs.update(self.special_tokens_map   )
									return self.tokenizer_class.from_pretrained(self.tmpdirname				,       **a_   )

					def 			snake_case__      (    self				,       **lowerCamelCase__   ):
									kwargs.update(self.special_tokens_map   )
									return self.rust_tokenizer_class.from_pretrained(self.tmpdirname				,       **a_   )

					def 			snake_case__      (    self				,       lowerCamelCase__   ):
									_lowerCamelCase        =				"""lower newer"""
									_lowerCamelCase        =				"""lower newer"""
									return input_text, output_text

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.tokenizer_class(self.vocab_file				,       self.merges_file				,       **self.special_tokens_map   )
									_lowerCamelCase        =				"""lower newer"""
									_lowerCamelCase        =				["""l""", """o""", """w""", """er""", """\u0120""", """n""", """e""", """w""", """er"""]
									_lowerCamelCase        =				tokenizer.tokenize(a_   )  # , add_prefix_space=True)
									self.assertListEqual(a_				,       a_   )

									_lowerCamelCase        =				tokens + [tokenizer.unk_token]
									_lowerCamelCase        =				[0, 1, 2, 1_5, 1_0, 9, 3, 2, 1_5, 1_9]
									self.assertListEqual(tokenizer.convert_tokens_to_ids(a_   )				,       a_   )

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.get_tokenizer()

									self.assertListEqual(tokenizer.encode('''Hello world!'''				,       add_special_tokens=a_   )				,       [0, 3_1_4_1_4, 2_3_2, 3_2_8, 2]   )
									self.assertListEqual(
									    tokenizer.encode('''Hello world! cécé herlolip 418'''				,       add_special_tokens=a_   )				,       [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 4_6_0_7_8, 1_5_8_8, 2]				,       )

					@slow
					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.tokenizer_class.from_pretrained('''allenai/longformer-base-4096'''   )

									_lowerCamelCase        =				tokenizer.encode('''sequence builders'''				,       add_special_tokens=a_   )
									_lowerCamelCase        =				tokenizer.encode('''multi-sequence build'''				,       add_special_tokens=a_   )

									_lowerCamelCase        =				tokenizer.encode(
									    '''sequence builders'''				,       add_special_tokens=a_				,       add_prefix_space=a_   )
									_lowerCamelCase        =				tokenizer.encode(
									    '''sequence builders'''				,       '''multi-sequence build'''				,       add_special_tokens=a_				,       add_prefix_space=a_   )

									_lowerCamelCase        =				tokenizer.build_inputs_with_special_tokens(a_   )
									_lowerCamelCase        =				tokenizer.build_inputs_with_special_tokens(a_				,       a_   )

									assert encoded_sentence == encoded_text_from_decode
									assert encoded_pair == encoded_pair_from_decode

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.get_tokenizer()

									_lowerCamelCase        =				"""Encode this sequence."""
									_lowerCamelCase        =				tokenizer.byte_encoder[""" """.encode('''utf-8'''   )[0]]

									# Testing encoder arguments
									_lowerCamelCase        =				tokenizer.encode(a_				,       add_special_tokens=a_				,       add_prefix_space=a_   )
									_lowerCamelCase        =				tokenizer.convert_ids_to_tokens(encoded[0]   )[0]
									self.assertNotEqual(a_				,       a_   )

									_lowerCamelCase        =				tokenizer.encode(a_				,       add_special_tokens=a_				,       add_prefix_space=a_   )
									_lowerCamelCase        =				tokenizer.convert_ids_to_tokens(encoded[0]   )[0]
									self.assertEqual(a_				,       a_   )

									tokenizer.add_special_tokens({'''bos_token''': '''<s>'''}   )
									_lowerCamelCase        =				tokenizer.encode(a_				,       add_special_tokens=a_   )
									_lowerCamelCase        =				tokenizer.convert_ids_to_tokens(encoded[1]   )[0]
									self.assertNotEqual(a_				,       a_   )

									# Testing spaces after special tokens
									_lowerCamelCase        =				"""<mask>"""
									tokenizer.add_special_tokens(
									    {'''mask_token''': AddedToken(a_				,       lstrip=a_				,       rstrip=a_   )}   )  # mask token has a left space
									_lowerCamelCase        =				tokenizer.convert_tokens_to_ids(a_   )

									_lowerCamelCase        =				"""Encode <mask> sequence"""
									_lowerCamelCase        =				"""Encode <mask>sequence"""

									_lowerCamelCase        =				tokenizer.encode(a_   )
									_lowerCamelCase        =				encoded.index(a_   )
									_lowerCamelCase        =				tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]   )[0]
									self.assertEqual(a_				,       a_   )

									_lowerCamelCase        =				tokenizer.encode(a_   )
									_lowerCamelCase        =				encoded.index(a_   )
									_lowerCamelCase        =				tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]   )[0]
									self.assertNotEqual(a_				,       a_   )

					def 			snake_case__      (    self   ):
									pass

					def 			snake_case__      (    self   ):



									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
													with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""   ):
																	_lowerCamelCase        =				self.rust_tokenizer_class.from_pretrained(a_				,       **a_   )
																	_lowerCamelCase        =				self.tokenizer_class.from_pretrained(a_				,       **a_   )
																	_lowerCamelCase        =				"""A, <mask> AllenNLP sentence."""
																	_lowerCamelCase        =				tokenizer_r.encode_plus(a_				,       add_special_tokens=a_				,       return_token_type_ids=a_   )
																	_lowerCamelCase        =				tokenizer_p.encode_plus(a_				,       add_special_tokens=a_				,       return_token_type_ids=a_   )

																	# 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''']   )				,       )

																	_lowerCamelCase        =				tokenizer_r.convert_ids_to_tokens(tokens_r['''input_ids''']   )
																	_lowerCamelCase        =				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, 2_5_0, 6, 5_0_2_6_4, 3_8_2_3, 4_8_7, 2_1_9_9_2, 3_6_4_5, 4, 2]   )
																	self.assertSequenceEqual(tokens_r['''input_ids''']				,       [0, 2_5_0, 6, 5_0_2_6_4, 3_8_2_3, 4_8_7, 2_1_9_9_2, 3_6_4_5, 4, 2]   )

																	self.assertSequenceEqual(
																	    a_				,       ['''<s>''', '''A''', ''',''', '''<mask>''', '''ĠAllen''', '''N''', '''LP''', '''Ġsentence''', '''.''', '''</s>''']   )
																	self.assertSequenceEqual(
																	    a_				,       ['''<s>''', '''A''', ''',''', '''<mask>''', '''ĠAllen''', '''N''', '''LP''', '''Ġsentence''', '''.''', '''</s>''']   )

					def 			snake_case__      (    self   ):



									for trim_offsets, add_prefix_space in itertools.product([True, False]				,       repeat=2   ):
													_lowerCamelCase        =				self.rust_tokenizer_class.from_pretrained(
													    self.tmpdirname				,       use_fast=a_				,       add_prefix_space=a_				,       trim_offsets=a_   )

													_lowerCamelCase        =				json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()   )
													_lowerCamelCase        =				json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()   )

													self.assertEqual(pre_tokenizer_state['''add_prefix_space''']				,       a_   )

													self.assertEqual(post_processor_state['''add_prefix_space''']				,       a_   )
													self.assertEqual(post_processor_state['''trim_offsets''']				,       a_   )





					def 			snake_case__      (    self   ):



									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
													with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""   ):
																	_lowerCamelCase        =				"""hello"""  # `hello` is a token in the vocabulary of `pretrained_name`
																	_lowerCamelCase        =				F"""{text_of_1_token} {text_of_1_token}"""

																	_lowerCamelCase        =				self.rust_tokenizer_class.from_pretrained(
																	    a_				,       use_fast=a_				,       add_prefix_space=a_				,       trim_offsets=a_   )
																	_lowerCamelCase        =				tokenizer_r(a_				,       return_offsets_mapping=a_				,       add_special_tokens=a_   )
																	self.assertEqual(encoding.offset_mapping[0]				,       (0, len(a_   ))   )
																	self.assertEqual(
																	    encoding.offset_mapping[1]				,       (len(a_   ) + 1, len(a_   ) + 1 + len(a_   ))				,       )

																	_lowerCamelCase        =				self.rust_tokenizer_class.from_pretrained(
																	    a_				,       use_fast=a_				,       add_prefix_space=a_				,       trim_offsets=a_   )
																	_lowerCamelCase        =				tokenizer_r(a_				,       return_offsets_mapping=a_				,       add_special_tokens=a_   )
																	self.assertEqual(encoding.offset_mapping[0]				,       (0, len(a_   ))   )
																	self.assertEqual(
																	    encoding.offset_mapping[1]				,       (len(a_   ) + 1, len(a_   ) + 1 + len(a_   ))				,       )

																	_lowerCamelCase        =				self.rust_tokenizer_class.from_pretrained(
																	    a_				,       use_fast=a_				,       add_prefix_space=a_				,       trim_offsets=a_   )
																	_lowerCamelCase        =				tokenizer_r(a_				,       return_offsets_mapping=a_				,       add_special_tokens=a_   )
																	self.assertEqual(encoding.offset_mapping[0]				,       (0, len(a_   ))   )
																	self.assertEqual(
																	    encoding.offset_mapping[1]				,       (len(a_   ), len(a_   ) + 1 + len(a_   ))				,       )

																	_lowerCamelCase        =				self.rust_tokenizer_class.from_pretrained(
																	    a_				,       use_fast=a_				,       add_prefix_space=a_				,       trim_offsets=a_   )
																	_lowerCamelCase        =				tokenizer_r(a_				,       return_offsets_mapping=a_				,       add_special_tokens=a_   )
																	self.assertEqual(encoding.offset_mapping[0]				,       (0, len(a_   ))   )
																	self.assertEqual(
																	    encoding.offset_mapping[1]				,       (len(a_   ), len(a_   ) + 1 + len(a_   ))				,       )

																	_lowerCamelCase        =				F""" {text}"""

																	# tokenizer_r = self.rust_tokenizer_class.from_pretrained(
																	#     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
																	# )
																	# encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
																	# self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
																	# self.assertEqual(
																	#     encoding.offset_mapping[1],
																	#     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
																	# )

																	_lowerCamelCase        =				self.rust_tokenizer_class.from_pretrained(
																	    a_				,       use_fast=a_				,       add_prefix_space=a_				,       trim_offsets=a_   )
																	_lowerCamelCase        =				tokenizer_r(a_				,       return_offsets_mapping=a_				,       add_special_tokens=a_   )
																	self.assertEqual(encoding.offset_mapping[0]				,       (1, 1 + len(a_   ))   )
																	self.assertEqual(
																	    encoding.offset_mapping[1]				,       (1 + len(a_   ) + 1, 1 + len(a_   ) + 1 + len(a_   ))				,       )

																	_lowerCamelCase        =				self.rust_tokenizer_class.from_pretrained(
																	    a_				,       use_fast=a_				,       add_prefix_space=a_				,       trim_offsets=a_   )
																	_lowerCamelCase        =				tokenizer_r(a_				,       return_offsets_mapping=a_				,       add_special_tokens=a_   )
																	self.assertEqual(encoding.offset_mapping[0]				,       (0, 1 + len(a_   ))   )
																	self.assertEqual(
																	    encoding.offset_mapping[1]				,       (1 + len(a_   ), 1 + len(a_   ) + 1 + len(a_   ))				,       )

																	_lowerCamelCase        =				self.rust_tokenizer_class.from_pretrained(
																	    a_				,       use_fast=a_				,       add_prefix_space=a_				,       trim_offsets=a_   )
																	_lowerCamelCase        =				tokenizer_r(a_				,       return_offsets_mapping=a_				,       add_special_tokens=a_   )
																	self.assertEqual(encoding.offset_mapping[0]				,       (0, 1 + len(a_   ))   )
																	self.assertEqual(
																	    encoding.offset_mapping[1]				,       (1 + len(a_   ), 1 + len(a_   ) + 1 + len(a_   ))				,       )











"""simple docstring"""
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    ):





					'''simple docstring'''



					def __init__(    self				,       lowerCamelCase__				,       lowerCamelCase__=2				,       lowerCamelCase__=5_6				,       lowerCamelCase__=True				,       lowerCamelCase__=True				,       lowerCamelCase__=True				,       lowerCamelCase__=True				,       lowerCamelCase__=9_9				,       lowerCamelCase__=3_2				,       lowerCamelCase__=2				,       lowerCamelCase__=2				,       lowerCamelCase__=7				,       lowerCamelCase__="gelu_new"				,       lowerCamelCase__=0.1				,       lowerCamelCase__=0.1				,       lowerCamelCase__=5_1_2				,       lowerCamelCase__=1_6				,       lowerCamelCase__=2				,       lowerCamelCase__=0.0_2				,       lowerCamelCase__=4				,       lowerCamelCase__="block_sparse"				,       lowerCamelCase__=True				,       lowerCamelCase__=False				,       lowerCamelCase__=2				,       lowerCamelCase__=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 			snake_case__      (    self   ):
									_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=lowerCamelCase__				,       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 			snake_case__      (    self   ):
									_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_(   A__,				unittest.TestCase    ):





					'''simple docstring'''



					lowercase__   :       List[str]										= (
					    (
					        FlaxBigBirdForCausalLM,
					        FlaxBigBirdModel,
					        FlaxBigBirdForPreTraining,
					        FlaxBigBirdForMaskedLM,
					        FlaxBigBirdForMultipleChoice,
					        FlaxBigBirdForQuestionAnswering,
					        FlaxBigBirdForSequenceClassification,
					        FlaxBigBirdForTokenClassification,
					    )
					    if is_flax_available()
					    else ()
					)

					lowercase__   :       Any										= False
					lowercase__   :       Optional[int]										= False

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				FlaxBigBirdModelTester(self   )

					@slow
					# copied from `test_modeling_flax_common` because it takes much longer than other models
					def 			snake_case__      (    self   ):
									super().test_from_pretrained_save_pretrained()

					@slow
					# copied from `test_modeling_flax_common` because it takes much longer than other models
					def 			snake_case__      (    self   ):
									super().test_from_pretrained_with_no_automatic_init()

					@slow
					# copied from `test_modeling_flax_common` because it takes much longer than other models
					def 			snake_case__      (    self   ):
									super().test_no_automatic_init()

					@slow
					# copied from `test_modeling_flax_common` because it takes much longer than other models
					def 			snake_case__      (    self   ):
									super().test_hidden_states_output()

					@slow
					def 			snake_case__      (    self   ):
									for model_class_name in self.all_model_classes:
													_lowerCamelCase        =				model_class_name.from_pretrained('''google/bigbird-roberta-base'''   )
													self.assertIsNotNone(lowerCamelCase__   )

					def 			snake_case__      (    self   ):
									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 			snake_case__      (    self   ):
									_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(lowerCamelCase__				,       lowerCamelCase__   )
																	_lowerCamelCase        =				model_class(lowerCamelCase__   )

																	@jax.jit
																	def model_jitted(lowerCamelCase__				,       lowerCamelCase__=None				,       **lowerCamelCase__   ):
																					return model(input_ids=lowerCamelCase__				,       attention_mask=lowerCamelCase__				,       **lowerCamelCase__   )

																	with self.subTest('''JIT Enabled'''   ):
																					_lowerCamelCase        =				model_jitted(**lowerCamelCase__   ).to_tuple()

																	with self.subTest('''JIT Disabled'''   ):
																					with jax.disable_jit():
																									_lowerCamelCase        =				model_jitted(**lowerCamelCase__   ).to_tuple()

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





					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__=1e-5				,       lowerCamelCase__="outputs"				,       lowerCamelCase__=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(lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   )
