
def 				__magic_name__				(     __lowerCAmelCase			:		List[str]	,						__lowerCAmelCase			:		Optional[int]							)    ->     List[Any]:
				__lowerCamelCase					      =			1
				while b > 0:
								if b & 1:
												res *= a

								a *= a
								b >>= 1

				return res




def 				__magic_name__				(     __lowerCAmelCase			:		Optional[int]	,						__lowerCAmelCase			:		str	,						__lowerCAmelCase			:		Optional[int]							)    ->     Optional[Any]:
				__lowerCamelCase					      =			1
				while b > 0:
								if b & 1:
												__lowerCamelCase					      =			((res % c) * (a % c)) % c

								a *= a
								b >>= 1

				return res





from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


SCREAMING_SNAKE_CASE__     :    int      							=					logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__     :    List[str]      							=					{
    "facebook/m2m100_418M": "https://huggingface.co/facebook/m2m100_418M/resolve/main/config.json",
    # See all M2M100 models at https://huggingface.co/models?filter=m2m_100
}

class      lowerCAmelCase__  (			__lowercase    ):
		a__ :		Union[str, Any]   						=	"""m2m_100"""
		a__ :		Optional[int]   						=	["""past_key_values"""]
		a__ :		List[Any]   						=	{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}






		def __init__(	self	:							int							,    SCREAMING_SNAKE_CASE__	:							Tuple=12_81_12							,    SCREAMING_SNAKE_CASE__	:							Any=10_24							,    SCREAMING_SNAKE_CASE__	:							int=12							,    SCREAMING_SNAKE_CASE__	:							List[str]=40_96							,    SCREAMING_SNAKE_CASE__	:							Optional[int]=16							,    SCREAMING_SNAKE_CASE__	:							Optional[int]=12							,    SCREAMING_SNAKE_CASE__	:							int=40_96							,    SCREAMING_SNAKE_CASE__	:							Optional[Any]=16							,    SCREAMING_SNAKE_CASE__	:							Dict=0.05							,    SCREAMING_SNAKE_CASE__	:							List[Any]=0.05							,    SCREAMING_SNAKE_CASE__	:							Dict=True							,    SCREAMING_SNAKE_CASE__	:							Tuple=True							,    SCREAMING_SNAKE_CASE__	:							Optional[Any]="relu"							,    SCREAMING_SNAKE_CASE__	:							Dict=10_24							,    SCREAMING_SNAKE_CASE__	:							Optional[int]=0.1							,    SCREAMING_SNAKE_CASE__	:							Tuple=0.1							,    SCREAMING_SNAKE_CASE__	:							str=0.0							,    SCREAMING_SNAKE_CASE__	:							Any=0.02							,    SCREAMING_SNAKE_CASE__	:							int=2							,    SCREAMING_SNAKE_CASE__	:							List[Any]=True							,    SCREAMING_SNAKE_CASE__	:							Any=1							,    SCREAMING_SNAKE_CASE__	:							Union[str, Any]=0							,    SCREAMING_SNAKE_CASE__	:							str=2							,    **SCREAMING_SNAKE_CASE__	:							Tuple							,    )  ->							Tuple:
						__lowerCamelCase					      =			vocab_size
						__lowerCamelCase					      =			max_position_embeddings
						__lowerCamelCase					      =			d_model
						__lowerCamelCase					      =			encoder_ffn_dim
						__lowerCamelCase					      =			encoder_layers
						__lowerCamelCase					      =			encoder_attention_heads
						__lowerCamelCase					      =			decoder_ffn_dim
						__lowerCamelCase					      =			decoder_layers
						__lowerCamelCase					      =			decoder_attention_heads
						__lowerCamelCase					      =			dropout
						__lowerCamelCase					      =			attention_dropout
						__lowerCamelCase					      =			activation_dropout
						__lowerCamelCase					      =			activation_function
						__lowerCamelCase					      =			init_std
						__lowerCamelCase					      =			encoder_layerdrop
						__lowerCamelCase					      =			decoder_layerdrop
						__lowerCamelCase					      =			use_cache
						__lowerCamelCase					      =			encoder_layers
						__lowerCamelCase					      =			scale_embedding  # scale factor will be sqrt(d_model) if True

						super().__init__(
						    pad_token_id=SCREAMING_SNAKE_CASE__							,    bos_token_id=SCREAMING_SNAKE_CASE__							,    eos_token_id=SCREAMING_SNAKE_CASE__							,    is_encoder_decoder=SCREAMING_SNAKE_CASE__							,    decoder_start_token_id=SCREAMING_SNAKE_CASE__							,    **SCREAMING_SNAKE_CASE__							,    )





class      lowerCAmelCase__  (			__lowercase    ):






		@property
		def 				__A (	self	:							List[Any]						)  ->							Mapping[str, Mapping[int, str]]:
						__lowerCamelCase					      =			OrderedDict(
						    [
						        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
						        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
						    ]						)

						if self.use_past:
										__lowerCamelCase					      =			{0: '''batch'''}
										__lowerCamelCase					      =			{0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
						else:
										__lowerCamelCase					      =			{0: '''batch''', 1: '''decoder_sequence'''}
										__lowerCamelCase					      =			{0: '''batch''', 1: '''decoder_sequence'''}

						if self.use_past:
										self.fill_with_past_key_values_(SCREAMING_SNAKE_CASE__							,    direction='''inputs'''						)
						return common_inputs






		def 				__A (	self	:							Any							,    SCREAMING_SNAKE_CASE__	:							PreTrainedTokenizer							,    SCREAMING_SNAKE_CASE__	:							int = -1							,    SCREAMING_SNAKE_CASE__	:							int = -1							,    SCREAMING_SNAKE_CASE__	:							bool = False							,    SCREAMING_SNAKE_CASE__	:							Optional[TensorType] = None							,    )  ->							Mapping[str, Any]:
						# Copied from OnnxConfig.generate_dummy_inputs
						# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
						# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
						__lowerCamelCase					      =			compute_effective_axis_dimension(
						    SCREAMING_SNAKE_CASE__							,    fixed_dimension=OnnxConfig.default_fixed_batch							,    num_token_to_add=0						)

						# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
						__lowerCamelCase					      =			tokenizer.num_special_tokens_to_add(SCREAMING_SNAKE_CASE__						)
						__lowerCamelCase					      =			compute_effective_axis_dimension(
						    SCREAMING_SNAKE_CASE__							,    fixed_dimension=OnnxConfig.default_fixed_sequence							,    num_token_to_add=SCREAMING_SNAKE_CASE__						)

						# Generate dummy inputs according to compute batch and sequence
						__lowerCamelCase					      =			[''' '''.join([tokenizer.unk_token]						) * seq_length] * batch_size
						__lowerCamelCase					      =			dict(tokenizer(SCREAMING_SNAKE_CASE__							,    return_tensors=SCREAMING_SNAKE_CASE__						)						)
						return common_inputs






		def 				__A (	self	:							Union[str, Any]							,    SCREAMING_SNAKE_CASE__	:							PreTrainedTokenizer							,    SCREAMING_SNAKE_CASE__	:							int = -1							,    SCREAMING_SNAKE_CASE__	:							int = -1							,    SCREAMING_SNAKE_CASE__	:							bool = False							,    SCREAMING_SNAKE_CASE__	:							Optional[TensorType] = None							,    )  ->							Mapping[str, Any]:
						__lowerCamelCase					      =			self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
						    SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__						)

						# Generate decoder inputs
						__lowerCamelCase					      =			seq_length if not self.use_past else 1
						__lowerCamelCase					      =			self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
						    SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__						)
						__lowerCamelCase					      =			{f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
						__lowerCamelCase					      =			dict(**SCREAMING_SNAKE_CASE__							,    **SCREAMING_SNAKE_CASE__						)

						if self.use_past:
										if not is_torch_available():
														raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''						)
										else:
														import torch
										__lowerCamelCase      ,					__lowerCamelCase					      =			common_inputs['''input_ids'''].shape
										__lowerCamelCase					      =			common_inputs['''decoder_input_ids'''].shape[1]
										__lowerCamelCase      ,					__lowerCamelCase					      =			self.num_attention_heads
										__lowerCamelCase					      =			(
										    batch,
										    num_encoder_attention_heads,
										    encoder_seq_length,
										    self._config.hidden_size // num_encoder_attention_heads,
										)
										__lowerCamelCase					      =			decoder_seq_length + 3
										__lowerCamelCase					      =			(
										    batch,
										    num_decoder_attention_heads,
										    decoder_past_length,
										    self._config.hidden_size // num_decoder_attention_heads,
										)

										__lowerCamelCase					      =			torch.cat(
										    [common_inputs['''decoder_attention_mask'''], torch.ones(SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__						)]							,    dim=1						)

										__lowerCamelCase					      =			[]
										# If the number of encoder and decoder layers are present in the model configuration, both are considered
										__lowerCamelCase      ,					__lowerCamelCase					      =			self.num_layers
										__lowerCamelCase					      =			min(SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__						)
										__lowerCamelCase					      =			max(SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__						) - min_num_layers
										__lowerCamelCase					      =			'''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''

										for _ in range(SCREAMING_SNAKE_CASE__						):
														common_inputs["past_key_values"].append(
														    (
														        torch.zeros(SCREAMING_SNAKE_CASE__						),
														        torch.zeros(SCREAMING_SNAKE_CASE__						),
														        torch.zeros(SCREAMING_SNAKE_CASE__						),
														        torch.zeros(SCREAMING_SNAKE_CASE__						),
														    )						)
										# TODO: test this.
										__lowerCamelCase					      =			encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
										for _ in range(SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__						):
														common_inputs["past_key_values"].append((torch.zeros(SCREAMING_SNAKE_CASE__						), torch.zeros(SCREAMING_SNAKE_CASE__						))						)
						return common_inputs







		a__ :		Dict   						=	_generate_dummy_inputs_for_default_and_seqaseq_lm



