




'''simple docstring'''


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


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

_snake_case : str  				=						{
    'tanreinama/GPTSAN-2.8B-spout_is_uniform': (
        'https://huggingface.co/tanreinama/GPTSAN-2.8B-spout_is_uniform/resolve/main/config.json'
    ),
}

class      A       (						_a       ):
							lowercase_							     =							'gptsan-japanese'
							lowercase_							     =							[
							    'past_key_values',
							]
							lowercase_							     =							{
							    'hidden_size': 'd_model',
							    'num_attention_heads': 'num_heads',
							    'num_hidden_layers': 'num_layers',
							}







							def __init__(    self			:    Union[str, Any]				,     lowerCAmelCase_			:    Dict=3_60_00				,     lowerCAmelCase_			:    Union[str, Any]=12_80				,     lowerCAmelCase_			:    Optional[int]=10_24				,     lowerCAmelCase_			:    Union[str, Any]=81_92				,     lowerCAmelCase_			:    int=40_96				,     lowerCAmelCase_			:    Dict=1_28				,     lowerCAmelCase_			:    Optional[int]=10				,     lowerCAmelCase_			:    Union[str, Any]=0				,     lowerCAmelCase_			:    Optional[Any]=16				,     lowerCAmelCase_			:    Optional[int]=16				,     lowerCAmelCase_			:    str=1_28				,     lowerCAmelCase_			:    Optional[int]=0.0				,     lowerCAmelCase_			:    int=1e-5				,     lowerCAmelCase_			:    Union[str, Any]=False				,     lowerCAmelCase_			:    List[str]=0.0				,     lowerCAmelCase_			:    Union[str, Any]="float32"				,     lowerCAmelCase_			:    Optional[Any]=False				,     lowerCAmelCase_			:    Any=False				,     lowerCAmelCase_			:    List[Any]=False				,     lowerCAmelCase_			:    List[str]=0.0_0_2				,     lowerCAmelCase_			:    Dict=False				,     lowerCAmelCase_			:    List[Any]=True				,     lowerCAmelCase_			:    List[Any]=3_59_98				,     lowerCAmelCase_			:    Tuple=3_59_95				,     lowerCAmelCase_			:    Optional[Any]=3_59_99				,     **lowerCAmelCase_			:    Any				,     )     ->				List[str]:


														"""simple docstring"""


														_a      	=							vocab_size
														_a      	=							max_position_embeddings
														_a      	=							d_model
														_a      	=							d_ff
														_a      	=							d_ext
														_a      	=							d_spout
														_a      	=							num_switch_layers
														_a      	=							num_ext_layers
														_a      	=							num_switch_layers + num_ext_layers
														_a      	=							num_heads
														_a      	=							num_experts
														_a      	=							expert_capacity
														_a      	=							dropout_rate
														_a      	=							layer_norm_epsilon
														_a      	=							router_bias
														_a      	=							router_jitter_noise
														_a      	=							router_dtype
														_a      	=							router_ignore_padding_tokens
														_a      	=							output_hidden_states
														_a      	=							output_attentions
														_a      	=							initializer_factor
														_a      	=							output_router_logits
														_a      	=							use_cache

														super().__init__(
														    separator_token_id=lowerCAmelCase_				,     pad_token_id=lowerCAmelCase_				,     eos_token_id=lowerCAmelCase_				,     **lowerCAmelCase_				,     )







'''simple docstring'''


from collections.abc import Generator
from math import sin
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							if len(UpperCamelCase ) != 32:
														raise ValueError('''Input must be of length 32''' )

							_a      	=							B''''''
							for i in [3, 2, 1, 0]:
														little_endian += string_aa[8 * i : 8 * i + 8]
							return little_endian
def 						snake_case_       (UpperCamelCase			:    int ):





							'''simple docstring'''


							if i < 0:
														raise ValueError('''Input must be non-negative''' )

							_a      	=							format(UpperCamelCase					,		'''08x''' )[-8:]
							_a      	=							B''''''
							for i in [3, 2, 1, 0]:
														little_endian_hex += hex_rep[2 * i : 2 * i + 2].encode('''utf-8''' )
							return little_endian_hex
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							_a      	=							B''''''
							for char in message:
														bit_string += format(UpperCamelCase					,		'''08b''' ).encode('''utf-8''' )
							_a      	=							format(len(UpperCamelCase )					,		'''064b''' ).encode('''utf-8''' )

							# Pad bit_string to a multiple of 512 chars
							bit_string += b"1"
							while len(UpperCamelCase ) % 512 != 448:
														bit_string += b"0"
							bit_string += to_little_endian(start_len[32:] ) + to_little_endian(start_len[:32] )

							return bit_string
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							if len(UpperCamelCase ) % 512 != 0:
														raise ValueError('''Input must have length that\'s a multiple of 512''' )

							for pos in range(0					,		len(UpperCamelCase )					,		512 ):
														_a      	=							bit_string[pos : pos + 512]
														_a      	=							[]
														for i in range(0					,		512					,		32 ):
																					block_words.append(int(to_little_endian(block[i : i + 32] )					,		2 ) )
														yield block_words
def 						snake_case_       (UpperCamelCase			:    int ):





							'''simple docstring'''


							if i < 0:
														raise ValueError('''Input must be non-negative''' )

							_a      	=							format(UpperCamelCase					,		'''032b''' )
							_a      	=							''''''
							for c in i_str:
														new_str += "1" if c == "0" else "0"
							return int(UpperCamelCase					,		2 )
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							return (a + b) % 2**32
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							if i < 0:
														raise ValueError('''Input must be non-negative''' )
							if shift < 0:
														raise ValueError('''Shift must be non-negative''' )
							return ((i << shift) ^ (i >> (32 - shift))) % 2**32
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							_a      	=							preprocess(UpperCamelCase )

							_a      	=							[int(2**32 * abs(sin(i + 1 ) ) ) for i in range(64 )]

							# Starting states
							_a      	=							0X67452301
							_a      	=							0Xefcdab89
							_a      	=							0X98badcfe
							_a      	=							0X10325476

							_a      	=							[
							    7,
							    12,
							    17,
							    22,
							    7,
							    12,
							    17,
							    22,
							    7,
							    12,
							    17,
							    22,
							    7,
							    12,
							    17,
							    22,
							    5,
							    9,
							    14,
							    20,
							    5,
							    9,
							    14,
							    20,
							    5,
							    9,
							    14,
							    20,
							    5,
							    9,
							    14,
							    20,
							    4,
							    11,
							    16,
							    23,
							    4,
							    11,
							    16,
							    23,
							    4,
							    11,
							    16,
							    23,
							    4,
							    11,
							    16,
							    23,
							    6,
							    10,
							    15,
							    21,
							    6,
							    10,
							    15,
							    21,
							    6,
							    10,
							    15,
							    21,
							    6,
							    10,
							    15,
							    21,
							]

							# Process bit string in chunks, each with 16 32-char words
							for block_words in get_block_words(UpperCamelCase ):
														_a      	=							aa
														_a      	=							ba
														_a      	=							ca
														_a      	=							da

														# Hash current chunk
														for i in range(64 ):
																					if i <= 15:
																												# f = (b & c) | (not_32(b) & d)     # Alternate definition for f
																												_a      	=							d ^ (b & (c ^ d))
																												_a      	=							i
																					elif i <= 31:
																												# f = (d & b) | (not_32(d) & c)     # Alternate definition for f
																												_a      	=							c ^ (d & (b ^ c))
																												_a      	=							(5 * i + 1) % 16
																					elif i <= 47:
																												_a      	=							b ^ c ^ d
																												_a      	=							(3 * i + 5) % 16
																					else:
																												_a      	=							c ^ (b | not_aa(UpperCamelCase ))
																												_a      	=							(7 * i) % 16
																					_a      	=							(f + a + added_consts[i] + block_words[g]) % 2**32
																					_a      	=							d
																					_a      	=							c
																					_a      	=							b
																					_a      	=							sum_aa(UpperCamelCase					,		left_rotate_aa(UpperCamelCase					,		shift_amounts[i] ) )

														# Add hashed chunk to running total
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )

							_a      	=							reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase )
							return digest


if __name__ == "__main__":
				import doctest

				doctest.testmod()

