


'''simple docstring'''


import functools
import math

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







def     snake_case_     (						SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__ = 4096  ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: List[Any]  	=   key.shape[-3:]
				_SCREAMING_SNAKE_CASE				: str  	=   value.shape[-1]
				_SCREAMING_SNAKE_CASE				: Optional[int]  	=   min(SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  )
				_SCREAMING_SNAKE_CASE				: Any  	=   query / jnp.sqrt(SCREAMING_SNAKE_CASE__  )

				@functools.partial(jax.checkpoint							,   prevent_cse=SCREAMING_SNAKE_CASE__  )
				def summarize_chunk(SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  ):
								_SCREAMING_SNAKE_CASE				: Optional[int]  	=   jnp.einsum("""...qhd,...khd->...qhk"""							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   precision=SCREAMING_SNAKE_CASE__  )

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

								_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   jnp.einsum("""...vhf,...qhv->...qhf"""							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   precision=SCREAMING_SNAKE_CASE__  )
								_SCREAMING_SNAKE_CASE				: Optional[int]  	=   jnp.einsum("""...qhk->...qh"""							,   SCREAMING_SNAKE_CASE__  )

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

				def chunk_scanner(SCREAMING_SNAKE_CASE__  ):
								# julienne key array
								_SCREAMING_SNAKE_CASE				: str  	=   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
								_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   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__  )

				_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: Optional[Any]  	=   jax.lax.map(f=SCREAMING_SNAKE_CASE__							,   xs=jnp.arange(0							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  )  )

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

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

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

				return all_values / all_weights







def     snake_case_     (						SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__=jax.lax.Precision.HIGHEST							,   SCREAMING_SNAKE_CASE__ = 1024							,   SCREAMING_SNAKE_CASE__ = 4096  ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: Optional[Any]  	=   query.shape[-3:]

				def chunk_scanner(SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  ):
								# julienne query array
								_SCREAMING_SNAKE_CASE				: Optional[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__  ),
								)

				_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: 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 					lowercase__						(		nn.Module      ):





							'''simple docstring'''


							A_							:   int
							A_							:   int   			=						8
							A_							:   int   			=						64
							A_							:   float   			=						0.0
							A_							:   bool   			=						False
							A_							:   jnp.dtype   			=						jnp.floataa






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

											# Weights were exported with old names {to_q, to_k, to_v, to_out}
											_SCREAMING_SNAKE_CASE				: str  	=   nn.Dense(__snake_case					,      use_bias=__snake_case					,      dtype=self.dtype					,      name="""to_q"""						)
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   nn.Dense(__snake_case					,      use_bias=__snake_case					,      dtype=self.dtype					,      name="""to_k"""						)
											_SCREAMING_SNAKE_CASE				: str  	=   nn.Dense(__snake_case					,      use_bias=__snake_case					,      dtype=self.dtype					,      name="""to_v"""						)

											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   nn.Dense(self.query_dim					,      dtype=self.dtype					,      name="""to_out_0"""						)
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   nn.Dropout(rate=self.dropout						)






							def UpperCAmelCase_			(					self					,      __snake_case						):
											_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: Optional[Any]  	=   tensor.shape
											_SCREAMING_SNAKE_CASE				: int  	=   self.heads
											_SCREAMING_SNAKE_CASE				: str  	=   tensor.reshape(__snake_case					,      __snake_case					,      __snake_case					,      dim // head_size						)
											_SCREAMING_SNAKE_CASE				: Any  	=   jnp.transpose(__snake_case					,      (0, 2, 1, 3)						)
											_SCREAMING_SNAKE_CASE				: Any  	=   tensor.reshape(batch_size * head_size					,      __snake_case					,      dim // head_size						)
											return tensor






							def UpperCAmelCase_			(					self					,      __snake_case						):
											_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: Tuple  	=   tensor.shape
											_SCREAMING_SNAKE_CASE				: Any  	=   self.heads
											_SCREAMING_SNAKE_CASE				: int  	=   tensor.reshape(batch_size // head_size					,      __snake_case					,      __snake_case					,      __snake_case						)
											_SCREAMING_SNAKE_CASE				: Any  	=   jnp.transpose(__snake_case					,      (0, 2, 1, 3)						)
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   tensor.reshape(batch_size // head_size					,      __snake_case					,      dim * head_size						)
											return tensor






							def __call__(					self					,      __snake_case					,      __snake_case=None					,      __snake_case=True						):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   hidden_states if context is None else context

											_SCREAMING_SNAKE_CASE				: str  	=   self.query(__snake_case						)
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   self.key(__snake_case						)
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   self.value(__snake_case						)

											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   self.reshape_heads_to_batch_dim(__snake_case						)
											_SCREAMING_SNAKE_CASE				: Any  	=   self.reshape_heads_to_batch_dim(__snake_case						)
											_SCREAMING_SNAKE_CASE				: Any  	=   self.reshape_heads_to_batch_dim(__snake_case						)

											if self.use_memory_efficient_attention:
															_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   query_states.transpose(1					,      0					,      2						)
															_SCREAMING_SNAKE_CASE				: Tuple  	=   key_states.transpose(1					,      0					,      2						)
															_SCREAMING_SNAKE_CASE				: Optional[int]  	=   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

															_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   query_states.shape[-3]
															if flatten_latent_dim % 64 == 0:
																			_SCREAMING_SNAKE_CASE				: Tuple  	=   int(flatten_latent_dim / 64						)
															elif flatten_latent_dim % 16 == 0:
																			_SCREAMING_SNAKE_CASE				: Optional[int]  	=   int(flatten_latent_dim / 16						)
															elif flatten_latent_dim % 4 == 0:
																			_SCREAMING_SNAKE_CASE				: int  	=   int(flatten_latent_dim / 4						)
															else:
																			_SCREAMING_SNAKE_CASE				: int  	=   int(__snake_case						)

															_SCREAMING_SNAKE_CASE				: str  	=   jax_memory_efficient_attention(
															    __snake_case					,      __snake_case					,      __snake_case					,      query_chunk_size=__snake_case					,      key_chunk_size=4096 * 4						)

															_SCREAMING_SNAKE_CASE				: Optional[int]  	=   hidden_states.transpose(1					,      0					,      2						)
											else:
															# compute attentions
															_SCREAMING_SNAKE_CASE				: int  	=   jnp.einsum("""b i d, b j d->b i j"""					,      __snake_case					,      __snake_case						)
															_SCREAMING_SNAKE_CASE				: str  	=   attention_scores * self.scale
															_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   nn.softmax(__snake_case					,      axis=2						)

															# attend to values
															_SCREAMING_SNAKE_CASE				: Any  	=   jnp.einsum("""b i j, b j d -> b i d"""					,      __snake_case					,      __snake_case						)

											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   self.reshape_batch_dim_to_heads(__snake_case						)
											_SCREAMING_SNAKE_CASE				: Any  	=   self.proj_attn(__snake_case						)
											return self.dropout_layer(__snake_case					,      deterministic=__snake_case						)





class 					lowercase__						(		nn.Module      ):





							'''simple docstring'''


							A_							:   int
							A_							:   int
							A_							:   int
							A_							:   float   			=						0.0
							A_							:   bool   			=						False
							A_							:   jnp.dtype   			=						jnp.floataa
							A_							:   bool   			=						False






							def UpperCAmelCase_			(					self						):
											# self attention (or cross_attention if only_cross_attention is True)
											_SCREAMING_SNAKE_CASE				: Any  	=   FlaxAttention(
											    self.dim					,      self.n_heads					,      self.d_head					,      self.dropout					,      self.use_memory_efficient_attention					,      dtype=self.dtype						)
											# cross attention
											_SCREAMING_SNAKE_CASE				: str  	=   FlaxAttention(
											    self.dim					,      self.n_heads					,      self.d_head					,      self.dropout					,      self.use_memory_efficient_attention					,      dtype=self.dtype						)
											_SCREAMING_SNAKE_CASE				: Dict  	=   FlaxFeedForward(dim=self.dim					,      dropout=self.dropout					,      dtype=self.dtype						)
											_SCREAMING_SNAKE_CASE				: int  	=   nn.LayerNorm(epsilon=1e-5					,      dtype=self.dtype						)
											_SCREAMING_SNAKE_CASE				: str  	=   nn.LayerNorm(epsilon=1e-5					,      dtype=self.dtype						)
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   nn.LayerNorm(epsilon=1e-5					,      dtype=self.dtype						)
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   nn.Dropout(rate=self.dropout						)






							def __call__(					self					,      __snake_case					,      __snake_case					,      __snake_case=True						):
											# self attention
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   hidden_states
											if self.only_cross_attention:
															_SCREAMING_SNAKE_CASE				: List[Any]  	=   self.attna(self.norma(__snake_case						)					,      __snake_case					,      deterministic=__snake_case						)
											else:
															_SCREAMING_SNAKE_CASE				: Tuple  	=   self.attna(self.norma(__snake_case						)					,      deterministic=__snake_case						)
											_SCREAMING_SNAKE_CASE				: Any  	=   hidden_states + residual

											# cross attention
											_SCREAMING_SNAKE_CASE				: str  	=   hidden_states
											_SCREAMING_SNAKE_CASE				: Dict  	=   self.attna(self.norma(__snake_case						)					,      __snake_case					,      deterministic=__snake_case						)
											_SCREAMING_SNAKE_CASE				: Tuple  	=   hidden_states + residual

											# feed forward
											_SCREAMING_SNAKE_CASE				: List[str]  	=   hidden_states
											_SCREAMING_SNAKE_CASE				: Tuple  	=   self.ff(self.norma(__snake_case						)					,      deterministic=__snake_case						)
											_SCREAMING_SNAKE_CASE				: str  	=   hidden_states + residual

											return self.dropout_layer(__snake_case					,      deterministic=__snake_case						)





class 					lowercase__						(		nn.Module      ):





							'''simple docstring'''


							A_							:   int
							A_							:   int
							A_							:   int
							A_							:   int   			=						1
							A_							:   float   			=						0.0
							A_							:   bool   			=						False
							A_							:   bool   			=						False
							A_							:   jnp.dtype   			=						jnp.floataa
							A_							:   bool   			=						False






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   nn.GroupNorm(num_groups=32					,      epsilon=1e-5						)

											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   self.n_heads * self.d_head
											if self.use_linear_projection:
															_SCREAMING_SNAKE_CASE				: Dict  	=   nn.Dense(__snake_case					,      dtype=self.dtype						)
											else:
															_SCREAMING_SNAKE_CASE				: Tuple  	=   nn.Conv(
															    __snake_case					,      kernel_size=(1, 1)					,      strides=(1, 1)					,      padding="""VALID"""					,      dtype=self.dtype					,      )

											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   [
											    FlaxBasicTransformerBlock(
											        __snake_case					,      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:
															_SCREAMING_SNAKE_CASE				: Any  	=   nn.Dense(__snake_case					,      dtype=self.dtype						)
											else:
															_SCREAMING_SNAKE_CASE				: int  	=   nn.Conv(
															    __snake_case					,      kernel_size=(1, 1)					,      strides=(1, 1)					,      padding="""VALID"""					,      dtype=self.dtype					,      )

											_SCREAMING_SNAKE_CASE				: List[str]  	=   nn.Dropout(rate=self.dropout						)






							def __call__(					self					,      __snake_case					,      __snake_case					,      __snake_case=True						):
											_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: Any  	=   hidden_states.shape
											_SCREAMING_SNAKE_CASE				: Dict  	=   hidden_states
											_SCREAMING_SNAKE_CASE				: Tuple  	=   self.norm(__snake_case						)
											if self.use_linear_projection:
															_SCREAMING_SNAKE_CASE				: List[str]  	=   hidden_states.reshape(__snake_case					,      height * width					,      __snake_case						)
															_SCREAMING_SNAKE_CASE				: str  	=   self.proj_in(__snake_case						)
											else:
															_SCREAMING_SNAKE_CASE				: Tuple  	=   self.proj_in(__snake_case						)
															_SCREAMING_SNAKE_CASE				: Any  	=   hidden_states.reshape(__snake_case					,      height * width					,      __snake_case						)

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

											if self.use_linear_projection:
															_SCREAMING_SNAKE_CASE				: Any  	=   self.proj_out(__snake_case						)
															_SCREAMING_SNAKE_CASE				: str  	=   hidden_states.reshape(__snake_case					,      __snake_case					,      __snake_case					,      __snake_case						)
											else:
															_SCREAMING_SNAKE_CASE				: Any  	=   hidden_states.reshape(__snake_case					,      __snake_case					,      __snake_case					,      __snake_case						)
															_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   self.proj_out(__snake_case						)

											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   hidden_states + residual
											return self.dropout_layer(__snake_case					,      deterministic=__snake_case						)





class 					lowercase__						(		nn.Module      ):





							'''simple docstring'''


							A_							:   int
							A_							:   float   			=						0.0
							A_							:   jnp.dtype   			=						jnp.floataa






							def UpperCAmelCase_			(					self						):
											# The second linear layer needs to be called
											# net_2 for now to match the index of the Sequential layer
											_SCREAMING_SNAKE_CASE				: Any  	=   FlaxGEGLU(self.dim					,      self.dropout					,      self.dtype						)
											_SCREAMING_SNAKE_CASE				: str  	=   nn.Dense(self.dim					,      dtype=self.dtype						)






							def __call__(					self					,      __snake_case					,      __snake_case=True						):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   self.net_a(__snake_case					,      deterministic=__snake_case						)
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   self.net_a(__snake_case						)
											return hidden_states





class 					lowercase__						(		nn.Module      ):





							'''simple docstring'''


							A_							:   int
							A_							:   float   			=						0.0
							A_							:   jnp.dtype   			=						jnp.floataa






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   self.dim * 4
											_SCREAMING_SNAKE_CASE				: List[str]  	=   nn.Dense(inner_dim * 2					,      dtype=self.dtype						)
											_SCREAMING_SNAKE_CASE				: int  	=   nn.Dropout(rate=self.dropout						)






							def __call__(					self					,      __snake_case					,      __snake_case=True						):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   self.proj(__snake_case						)
											_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: Optional[Any]  	=   jnp.split(__snake_case					,      2					,      axis=2						)
											return self.dropout_layer(hidden_linear * nn.gelu(__snake_case						)					,      deterministic=__snake_case						)








'''simple docstring'''


from ..utils import DummyObject, requires_backends





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[str]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   str   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Union[str, Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[str]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Tuple   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Optional[int]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Optional[int]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Optional[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Optional[int]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Tuple   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   str   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Dict   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   str   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Optional[int]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   str   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Tuple   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[str]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Optional[int]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[str]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   int   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Optional[int]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Tuple   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Dict   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Optional[int]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Union[str, Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[str]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Dict   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Tuple   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[str]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Any   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Dict   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Union[str, Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   Optional[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)





class 					lowercase__						(		metaclass=_snake_case      ):





							'''simple docstring'''


							A_							:   List[Any]   			=						["""tokenizers"""]






							def __init__(					self					,      *__snake_case					,      **__snake_case						):
											requires_backends(self					,      ["""tokenizers"""]						)




