






import functools
import math

import flax.linen as nn
import jax
import jax.numpy as jnp

def   snake_case					(UpperCAmelCase__	,    UpperCAmelCase__	,    UpperCAmelCase__	,    UpperCAmelCase__	,    UpperCAmelCase__ = 4_0_9_6  )       ->				Any:
  UpperCamelCase_:					Tuple          =				key.shape[-3:]
  UpperCamelCase_:					Optional[Any]          =				value.shape[-1]
  UpperCamelCase_:					List[Any]          =				min(SCREAMING_SNAKE_CASE__	,    SCREAMING_SNAKE_CASE__  )
  UpperCamelCase_:					Optional[Any]          =				query / jnp.sqrt(SCREAMING_SNAKE_CASE__  )

  @functools.partial(jax.checkpoint	,    prevent_cse=SCREAMING_SNAKE_CASE__  )
  def summarize_chunk(UpperCAmelCase__	,    UpperCAmelCase__	,    UpperCAmelCase__  ):
    UpperCamelCase_:					Tuple          =				jnp.einsum('...qhd,...khd->...qhk'	,    SCREAMING_SNAKE_CASE__	,    SCREAMING_SNAKE_CASE__	,    precision=SCREAMING_SNAKE_CASE__  )

    UpperCamelCase_:					str          =				jnp.max(SCREAMING_SNAKE_CASE__	,    axis=-1	,    keepdims=SCREAMING_SNAKE_CASE__  )
    UpperCamelCase_:					int          =				jax.lax.stop_gradient(SCREAMING_SNAKE_CASE__  )
    UpperCamelCase_:					List[str]          =				jnp.exp(attn_weights - max_score  )

    UpperCamelCase_:					str          =				jnp.einsum('...vhf,...qhv->...qhf'	,    SCREAMING_SNAKE_CASE__	,    SCREAMING_SNAKE_CASE__	,    precision=SCREAMING_SNAKE_CASE__  )
    UpperCamelCase_:					int          =				jnp.einsum('...qhk->...qh'	,    SCREAMING_SNAKE_CASE__  )

    return (exp_values, exp_weights.sum(axis=-1  ), max_score)

  def chunk_scanner(UpperCAmelCase__  ):
    # julienne key array
    UpperCamelCase_:					Tuple          =				jax.lax.dynamic_slice(
        operand=SCREAMING_SNAKE_CASE__	,    start_indices=[0] * (key.ndim - 3) + [chunk_idx, 0, 0]	,    slice_sizes=list(key.shape[:-3]  ) + [key_chunk_size, num_heads, k_features]	,    )

    # julienne value array
    UpperCamelCase_:					Optional[int]          =				jax.lax.dynamic_slice(
        operand=SCREAMING_SNAKE_CASE__	,    start_indices=[0] * (value.ndim - 3) + [chunk_idx, 0, 0]	,    slice_sizes=list(value.shape[:-3]  ) + [key_chunk_size, num_heads, v_features]	,    )

    return summarize_chunk(SCREAMING_SNAKE_CASE__	,    SCREAMING_SNAKE_CASE__	,    SCREAMING_SNAKE_CASE__  )

  UpperCamelCase_:					str          =				jax.lax.map(f=SCREAMING_SNAKE_CASE__	,    xs=jnp.arange(0	,    SCREAMING_SNAKE_CASE__	,    SCREAMING_SNAKE_CASE__  )  )

  UpperCamelCase_:					Optional[Any]          =				jnp.max(SCREAMING_SNAKE_CASE__	,    axis=0	,    keepdims=SCREAMING_SNAKE_CASE__  )
  UpperCamelCase_:					int          =				jnp.exp(chunk_max - global_max  )

  chunk_values *= jnp.expand_dims(SCREAMING_SNAKE_CASE__	,    axis=-1  )
  chunk_weights *= max_diffs

  UpperCamelCase_:					List[str]          =				chunk_values.sum(axis=0  )
  UpperCamelCase_:					str          =				jnp.expand_dims(SCREAMING_SNAKE_CASE__	,    -1  ).sum(axis=0  )

  return all_values / all_weights

def   snake_case					(UpperCAmelCase__	,    UpperCAmelCase__	,    UpperCAmelCase__	,    UpperCAmelCase__=jax.lax.Precision.HIGHEST	,    UpperCAmelCase__ = 1_0_2_4	,    UpperCAmelCase__ = 4_0_9_6  )       ->				List[str]:
  UpperCamelCase_:					Tuple          =				query.shape[-3:]

  def chunk_scanner(UpperCAmelCase__	,    UpperCAmelCase__  ):
    # julienne query array
    UpperCamelCase_:					int          =				jax.lax.dynamic_slice(
        operand=SCREAMING_SNAKE_CASE__	,    start_indices=([0] * (query.ndim - 3)) + [chunk_idx, 0, 0]	,    slice_sizes=list(query.shape[:-3]  ) + [min(SCREAMING_SNAKE_CASE__	,    SCREAMING_SNAKE_CASE__  ), num_heads, q_features]	,    )

    return (
        chunk_idx + query_chunk_size,  # unused ignore it
        _query_chunk_attention(
            query=SCREAMING_SNAKE_CASE__	,    key=SCREAMING_SNAKE_CASE__	,    value=SCREAMING_SNAKE_CASE__	,    precision=SCREAMING_SNAKE_CASE__	,    key_chunk_size=SCREAMING_SNAKE_CASE__  ),
    )

  UpperCamelCase_:					Union[str, Any]          =				jax.lax.scan(
      f=SCREAMING_SNAKE_CASE__	,    init=0	,    xs=SCREAMING_SNAKE_CASE__	,    length=math.ceil(num_q / query_chunk_size  )  )

  return jnp.concatenate(SCREAMING_SNAKE_CASE__	,    axis=-3  )  # fuse the chunked result back




class 				_lowerCAmelCase(       nn.Module					):





       """simple docstring"""







       a				:		Any									=42
       a				:		Dict									=8
       a				:		Optional[int]									=64
       a				:		Tuple									=0.0
       a				:		str									=False
       a				:		Optional[Any]									=jnp.floataa





       def 			_a    (					self							):
         UpperCamelCase_:					Union[str, Any]          =				self.dim_head * self.heads
         UpperCamelCase_:					Optional[int]          =				self.dim_head**-0.5

         # Weights were exported with old names {to_q, to_k, to_v, to_out}
         UpperCamelCase_:					int          =				nn.Dense(UpperCamelCase__  ,			use_bias=UpperCamelCase__  ,			dtype=self.dtype  ,			name='to_q'							)
         UpperCamelCase_:					Union[str, Any]          =				nn.Dense(UpperCamelCase__  ,			use_bias=UpperCamelCase__  ,			dtype=self.dtype  ,			name='to_k'							)
         UpperCamelCase_:					Tuple          =				nn.Dense(UpperCamelCase__  ,			use_bias=UpperCamelCase__  ,			dtype=self.dtype  ,			name='to_v'							)

         UpperCamelCase_:					Any          =				nn.Dense(self.query_dim  ,			dtype=self.dtype  ,			name='to_out_0'							)
         UpperCamelCase_:					Tuple          =				nn.Dropout(rate=self.dropout							)





       def 			_a    (					self  ,			_lowerCamelCase							):
         UpperCamelCase_:					List[str]          =				tensor.shape
         UpperCamelCase_:					Tuple          =				self.heads
         UpperCamelCase_:					int          =				tensor.reshape(UpperCamelCase__  ,			UpperCamelCase__  ,			UpperCamelCase__  ,			dim // head_size							)
         UpperCamelCase_:					int          =				jnp.transpose(UpperCamelCase__  ,			(0, 2, 1, 3)							)
         UpperCamelCase_:					str          =				tensor.reshape(batch_size * head_size  ,			UpperCamelCase__  ,			dim // head_size							)
         return tensor





       def 			_a    (					self  ,			_lowerCamelCase							):
         UpperCamelCase_:					List[Any]          =				tensor.shape
         UpperCamelCase_:					Optional[Any]          =				self.heads
         UpperCamelCase_:					Optional[int]          =				tensor.reshape(batch_size // head_size  ,			UpperCamelCase__  ,			UpperCamelCase__  ,			UpperCamelCase__							)
         UpperCamelCase_:					Any          =				jnp.transpose(UpperCamelCase__  ,			(0, 2, 1, 3)							)
         UpperCamelCase_:					List[str]          =				tensor.reshape(batch_size // head_size  ,			UpperCamelCase__  ,			dim * head_size							)
         return tensor





       def __call__(					self  ,			_lowerCamelCase  ,			_lowerCamelCase=None  ,			_lowerCamelCase=True							):
         UpperCamelCase_:					Optional[int]          =				hidden_states if context is None else context

         UpperCamelCase_:					Union[str, Any]          =				self.query(UpperCamelCase__							)
         UpperCamelCase_:					List[Any]          =				self.key(UpperCamelCase__							)
         UpperCamelCase_:					List[str]          =				self.value(UpperCamelCase__							)

         UpperCamelCase_:					int          =				self.reshape_heads_to_batch_dim(UpperCamelCase__							)
         UpperCamelCase_:					Optional[Any]          =				self.reshape_heads_to_batch_dim(UpperCamelCase__							)
         UpperCamelCase_:					Optional[Any]          =				self.reshape_heads_to_batch_dim(UpperCamelCase__							)

         if self.use_memory_efficient_attention:
           UpperCamelCase_:					Any          =				query_states.transpose(1  ,			0  ,			2							)
           UpperCamelCase_:					List[str]          =				key_states.transpose(1  ,			0  ,			2							)
           UpperCamelCase_:					List[Any]          =				value_states.transpose(1  ,			0  ,			2							)

           # this if statement create a chunk size for each layer of the unet
           # the chunk size is equal to the query_length dimension of the deepest layer of the unet

           UpperCamelCase_:					Union[str, Any]          =				query_states.shape[-3]
           if flatten_latent_dim % 6_4 == 0:
             UpperCamelCase_:					List[Any]          =				int(flatten_latent_dim / 6_4							)
           elif flatten_latent_dim % 1_6 == 0:
             UpperCamelCase_:					List[str]          =				int(flatten_latent_dim / 1_6							)
           elif flatten_latent_dim % 4 == 0:
             UpperCamelCase_:					Dict          =				int(flatten_latent_dim / 4							)
           else:
             UpperCamelCase_:					int          =				int(UpperCamelCase__							)

           UpperCamelCase_:					Any          =				jax_memory_efficient_attention(
               UpperCamelCase__  ,			UpperCamelCase__  ,			UpperCamelCase__  ,			query_chunk_size=UpperCamelCase__  ,			key_chunk_size=4_0_9_6 * 4							)

           UpperCamelCase_:					Union[str, Any]          =				hidden_states.transpose(1  ,			0  ,			2							)
         else:
           # compute attentions
           UpperCamelCase_:					Tuple          =				jnp.einsum('b i d, b j d->b i j'  ,			UpperCamelCase__  ,			UpperCamelCase__							)
           UpperCamelCase_:					List[str]          =				attention_scores * self.scale
           UpperCamelCase_:					str          =				nn.softmax(UpperCamelCase__  ,			axis=2							)

           # attend to values
           UpperCamelCase_:					Dict          =				jnp.einsum('b i j, b j d -> b i d'  ,			UpperCamelCase__  ,			UpperCamelCase__							)

         UpperCamelCase_:					Optional[int]          =				self.reshape_batch_dim_to_heads(UpperCamelCase__							)
         UpperCamelCase_:					List[str]          =				self.proj_attn(UpperCamelCase__							)
         return self.dropout_layer(UpperCamelCase__  ,			deterministic=UpperCamelCase__							)







class 				_lowerCAmelCase(       nn.Module					):





       """simple docstring"""







       a				:		Optional[int]									=42
       a				:		Dict									=42
       a				:		List[str]									=42
       a				:		Union[str, Any]									=0.0
       a				:		Optional[int]									=False
       a				:		Optional[Any]									=jnp.floataa
       a				:		Optional[Any]									=False





       def 			_a    (					self							):
         UpperCamelCase_:					Dict          =				FlaxAttention(
             self.dim  ,			self.n_heads  ,			self.d_head  ,			self.dropout  ,			self.use_memory_efficient_attention  ,			dtype=self.dtype							)
         # cross attention
         UpperCamelCase_:					List[Any]          =				FlaxAttention(
             self.dim  ,			self.n_heads  ,			self.d_head  ,			self.dropout  ,			self.use_memory_efficient_attention  ,			dtype=self.dtype							)
         UpperCamelCase_:					Optional[int]          =				FlaxFeedForward(dim=self.dim  ,			dropout=self.dropout  ,			dtype=self.dtype							)
         UpperCamelCase_:					Any          =				nn.LayerNorm(epsilon=1e-5  ,			dtype=self.dtype							)
         UpperCamelCase_:					str          =				nn.LayerNorm(epsilon=1e-5  ,			dtype=self.dtype							)
         UpperCamelCase_:					Any          =				nn.LayerNorm(epsilon=1e-5  ,			dtype=self.dtype							)
         UpperCamelCase_:					Union[str, Any]          =				nn.Dropout(rate=self.dropout							)





       def __call__(					self  ,			_lowerCamelCase  ,			_lowerCamelCase  ,			_lowerCamelCase=True							):
         UpperCamelCase_:					Any          =				hidden_states
         if self.only_cross_attention:
           UpperCamelCase_:					Any          =				self.attna(self.norma(UpperCamelCase__							)  ,			UpperCamelCase__  ,			deterministic=UpperCamelCase__							)
         else:
           UpperCamelCase_:					List[Any]          =				self.attna(self.norma(UpperCamelCase__							)  ,			deterministic=UpperCamelCase__							)
         UpperCamelCase_:					str          =				hidden_states + residual

         # cross attention
         UpperCamelCase_:					Tuple          =				hidden_states
         UpperCamelCase_:					List[str]          =				self.attna(self.norma(UpperCamelCase__							)  ,			UpperCamelCase__  ,			deterministic=UpperCamelCase__							)
         UpperCamelCase_:					List[Any]          =				hidden_states + residual

         # feed forward
         UpperCamelCase_:					Dict          =				hidden_states
         UpperCamelCase_:					int          =				self.ff(self.norma(UpperCamelCase__							)  ,			deterministic=UpperCamelCase__							)
         UpperCamelCase_:					str          =				hidden_states + residual

         return self.dropout_layer(UpperCamelCase__  ,			deterministic=UpperCamelCase__							)







class 				_lowerCAmelCase(       nn.Module					):





       """simple docstring"""







       a				:		Union[str, Any]									=42
       a				:		Any									=42
       a				:		Union[str, Any]									=42
       a				:		Optional[Any]									=1
       a				:		int									=0.0
       a				:		int									=False
       a				:		List[str]									=False
       a				:		str									=jnp.floataa
       a				:		str									=False





       def 			_a    (					self							):
         UpperCamelCase_:					int          =				nn.GroupNorm(num_groups=3_2  ,			epsilon=1e-5							)

         UpperCamelCase_:					Union[str, Any]          =				self.n_heads * self.d_head
         if self.use_linear_projection:
           UpperCamelCase_:					int          =				nn.Dense(UpperCamelCase__  ,			dtype=self.dtype							)
         else:
           UpperCamelCase_:					Optional[Any]          =				nn.Conv(
               UpperCamelCase__  ,			kernel_size=(1, 1)  ,			strides=(1, 1)  ,			padding='VALID'  ,			dtype=self.dtype  ,			)

         UpperCamelCase_:					Optional[Any]          =				[
             FlaxBasicTransformerBlock(
                 UpperCamelCase__  ,			self.n_heads  ,			self.d_head  ,			dropout=self.dropout  ,			only_cross_attention=self.only_cross_attention  ,			dtype=self.dtype  ,			use_memory_efficient_attention=self.use_memory_efficient_attention  ,			)
             for _ in range(self.depth							)
         ]

         if self.use_linear_projection:
           UpperCamelCase_:					Optional[int]          =				nn.Dense(UpperCamelCase__  ,			dtype=self.dtype							)
         else:
           UpperCamelCase_:					List[Any]          =				nn.Conv(
               UpperCamelCase__  ,			kernel_size=(1, 1)  ,			strides=(1, 1)  ,			padding='VALID'  ,			dtype=self.dtype  ,			)

         UpperCamelCase_:					Union[str, Any]          =				nn.Dropout(rate=self.dropout							)





       def __call__(					self  ,			_lowerCamelCase  ,			_lowerCamelCase  ,			_lowerCamelCase=True							):
         UpperCamelCase_:					str          =				hidden_states.shape
         UpperCamelCase_:					Union[str, Any]          =				hidden_states
         UpperCamelCase_:					Optional[int]          =				self.norm(UpperCamelCase__							)
         if self.use_linear_projection:
           UpperCamelCase_:					Tuple          =				hidden_states.reshape(UpperCamelCase__  ,			height * width  ,			UpperCamelCase__							)
           UpperCamelCase_:					List[str]          =				self.proj_in(UpperCamelCase__							)
         else:
           UpperCamelCase_:					Optional[Any]          =				self.proj_in(UpperCamelCase__							)
           UpperCamelCase_:					List[Any]          =				hidden_states.reshape(UpperCamelCase__  ,			height * width  ,			UpperCamelCase__							)

         for transformer_block in self.transformer_blocks:
           UpperCamelCase_:					List[str]          =				transformer_block(UpperCamelCase__  ,			UpperCamelCase__  ,			deterministic=UpperCamelCase__							)

         if self.use_linear_projection:
           UpperCamelCase_:					int          =				self.proj_out(UpperCamelCase__							)
           UpperCamelCase_:					Any          =				hidden_states.reshape(UpperCamelCase__  ,			UpperCamelCase__  ,			UpperCamelCase__  ,			UpperCamelCase__							)
         else:
           UpperCamelCase_:					Optional[Any]          =				hidden_states.reshape(UpperCamelCase__  ,			UpperCamelCase__  ,			UpperCamelCase__  ,			UpperCamelCase__							)
           UpperCamelCase_:					Any          =				self.proj_out(UpperCamelCase__							)

         UpperCamelCase_:					Dict          =				hidden_states + residual
         return self.dropout_layer(UpperCamelCase__  ,			deterministic=UpperCamelCase__							)







class 				_lowerCAmelCase(       nn.Module					):





       """simple docstring"""







       a				:		List[str]									=42
       a				:		Union[str, Any]									=0.0
       a				:		str									=jnp.floataa





       def 			_a    (					self							):
         UpperCamelCase_:					Union[str, Any]          =				FlaxGEGLU(self.dim  ,			self.dropout  ,			self.dtype							)
         UpperCamelCase_:					Dict          =				nn.Dense(self.dim  ,			dtype=self.dtype							)





       def __call__(					self  ,			_lowerCamelCase  ,			_lowerCamelCase=True							):
         UpperCamelCase_:					Tuple          =				self.net_a(UpperCamelCase__  ,			deterministic=UpperCamelCase__							)
         UpperCamelCase_:					int          =				self.net_a(UpperCamelCase__							)
         return hidden_states







class 				_lowerCAmelCase(       nn.Module					):





       """simple docstring"""







       a				:		List[Any]									=42
       a				:		Union[str, Any]									=0.0
       a				:		Optional[int]									=jnp.floataa





       def 			_a    (					self							):
         UpperCamelCase_:					Dict          =				self.dim * 4
         UpperCamelCase_:					Dict          =				nn.Dense(inner_dim * 2  ,			dtype=self.dtype							)
         UpperCamelCase_:					Optional[Any]          =				nn.Dropout(rate=self.dropout							)





       def __call__(					self  ,			_lowerCamelCase  ,			_lowerCamelCase=True							):
         UpperCamelCase_:					Dict          =				self.proj(UpperCamelCase__							)
         UpperCamelCase_:					List[str]          =				jnp.split(UpperCamelCase__  ,			2  ,			axis=2							)
         return self.dropout_layer(hidden_linear * nn.gelu(UpperCamelCase__							)  ,			deterministic=UpperCamelCase__							)

'''simple docstring'''
import os
import tempfile
import unittest
from typing import List

from transformers.models.esm.tokenization_esm import VOCAB_FILES_NAMES, EsmTokenizer
from transformers.testing_utils import require_tokenizers
from transformers.tokenization_utils import PreTrainedTokenizer
from transformers.tokenization_utils_base import PreTrainedTokenizerBase






@require_tokenizers
class      snake_case__    (	unittest.TestCase ):







		"""simple docstring"""

		lowerCamelCase							=		EsmTokenizer



		def 	lowerCAmelCase							(	self							:       List[Any]	)		->       Any:






				"""simple docstring"""







				super().setUp()
				snake_case   :    Optional[int]			       =		tempfile.mkdtemp()
				# fmt: off
				snake_case   :    List[str]			       =		["<cls>", "<pad>", "<eos>", "<unk>", "L", "A", "G", "V", "S", "E", "R", "T", "I", "D", "P", "K", "Q", "N", "F", "Y", "M", "H", "W", "C", "X", "B", "U", "Z", "O", ".", "-", "<null_1>", "<mask>"]  # noqa: E501
				# fmt: on
				snake_case   :    List[Any]			       =		os.path.join(self.tmpdirname   ,     VOCAB_FILES_NAMES['''vocab_file''']	)
				with open(self.vocab_file   ,     '''w'''   ,     encoding='''utf-8'''	) as vocab_writer:
						vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]	)	)



		def 	lowerCAmelCase							(	self							:       str   ,     **UpperCamelCase__							:       Union[str, Any]	)		->       List[PreTrainedTokenizerBase]:






				"""simple docstring"""







				return [self.get_tokenizer(**UpperCamelCase__	)]



		def 	lowerCAmelCase							(	self							:       Union[str, Any]   ,     **UpperCamelCase__							:       Tuple	)		->       PreTrainedTokenizer:






				"""simple docstring"""







				return self.tokenizer_class.from_pretrained(self.tmpdirname   ,     **UpperCamelCase__	)



		def 	lowerCAmelCase							(	self							:       List[str]	)		->       Tuple:






				"""simple docstring"""







				snake_case   :    str			       =		self.tokenizer_class(self.vocab_file	)

				snake_case   :    Optional[int]			       =		tokenizer.tokenize('''LAGVS'''	)
				self.assertListEqual(UpperCamelCase__   ,     ['''L''', '''A''', '''G''', '''V''', '''S''']	)
				self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCamelCase__	)   ,     [4, 5, 6, 7, 8]	)



		def 	lowerCAmelCase							(	self							:       List[Any]	)		->       int:






				"""simple docstring"""







				snake_case   :    Dict			       =		self.tokenizer_class(self.vocab_file	)

				snake_case   :    List[Any]			       =		'''LAGVS'''
				self.assertListEqual(tokenizer.encode(UpperCamelCase__	)   ,     [0, 4, 5, 6, 7, 8, 2]	)



		def 	lowerCAmelCase							(	self							:       List[str]	)		->       int:






				"""simple docstring"""







				snake_case   :    Union[str, Any]			       =		self.tokenizer_class(self.vocab_file	)

				snake_case   :    int			       =		['''LAGVS''', '''WCB''']
				snake_case   :    List[str]			       =		tokenizer(UpperCamelCase__   ,     padding=UpperCamelCase__	)['''input_ids''']

				self.assertListEqual(UpperCamelCase__   ,     [[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2]]	)



		def 	lowerCAmelCase							(	self							:       int	)		->       List[str]:






				"""simple docstring"""







				snake_case   :    Dict			       =		self.tokenizer_class(self.vocab_file	)

				snake_case   :    List[str]			       =		['''LAGVS''', '''WCB''']
				snake_case   :    Any			       =		tokenizer(UpperCamelCase__   ,     padding=UpperCamelCase__	)['''input_ids''']

				self.assertListEqual(UpperCamelCase__   ,     [[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2, 1, 1]]	)



		def 	lowerCAmelCase							(	self							:       Any	)		->       int:






				"""simple docstring"""







				snake_case   :    List[str]			       =		self.get_tokenizers(fast=UpperCamelCase__	)
				for tokenizer in tokenizers:
						with self.subTest(f'{tokenizer.__class__.__name__}'	):
								snake_case   :    int			       =		'''<unk>'''
								snake_case   :    int			       =		'''<mask>'''

								snake_case   :    Any			       =		tokenizer.tokenize(UpperCamelCase__	)
								snake_case   :    Any			       =		tokenizer.tokenize(UpperCamelCase__	)

								self.assertEqual(len(UpperCamelCase__	)   ,     1	)
								self.assertEqual(len(UpperCamelCase__	)   ,     1	)
								self.assertEqual(token_a[0]   ,     UpperCamelCase__	)
								self.assertEqual(token_a[0]   ,     UpperCamelCase__	)


