

'''simple docstring'''

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

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


lowerCAmelCase_     =      logging.get_logger(__name__)

lowerCAmelCase_     =      {
    "facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/config.json",
    # See all Blenderbot models at https://huggingface.co/models?filter=blenderbot
}







class lowerCamelCase   (    __lowerCAmelCase				):
				snake_case_							     = '''blenderbot'''
				snake_case_							     = ['''past_key_values''']
				snake_case_							     = {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}

				def __init__(       self,						lowercase_=8008,						lowercase_=128,						lowercase_=2,						lowercase_=10240,						lowercase_=32,						lowercase_=24,						lowercase_=10240,						lowercase_=32,						lowercase_=0.0,						lowercase_=0.0,						lowercase_=True,						lowercase_=True,						lowercase_="gelu",						lowercase_=2560,						lowercase_=0.1,						lowercase_=0.0,						lowercase_=0.0,						lowercase_=0.02,						lowercase_=1,						lowercase_=False,						lowercase_=0,						lowercase_=1,						lowercase_=2,						lowercase_=3,						lowercase_=2,						**lowercase_,						)    ->							Any:
					snake_case							=					vocab_size
					snake_case							=					max_position_embeddings
					snake_case							=					d_model
					snake_case							=					encoder_ffn_dim
					snake_case							=					encoder_layers
					snake_case							=					encoder_attention_heads
					snake_case							=					decoder_ffn_dim
					snake_case							=					decoder_layers
					snake_case							=					decoder_attention_heads
					snake_case							=					dropout
					snake_case							=					attention_dropout
					snake_case							=					activation_dropout
					snake_case							=					activation_function
					snake_case							=					init_std
					snake_case							=					encoder_layerdrop
					snake_case							=					decoder_layerdrop
					snake_case							=					use_cache
					snake_case							=					encoder_layers
					snake_case							=					scale_embedding  # scale factor will be sqrt(d_model) if True

					super().__init__(
					    pad_token_id=lowercase_,						bos_token_id=lowercase_,						eos_token_id=lowercase_,						is_encoder_decoder=lowercase_,						decoder_start_token_id=lowercase_,						encoder_no_repeat_ngram_size=lowercase_,						forced_eos_token_id=lowercase_,						**lowercase_,						)







class lowerCamelCase   (    __lowerCAmelCase				):

				@property
				def 					_lowerCamelCase    (       self )    ->							Mapping[str, Mapping[int, str]]:
					if self.task in ["default", "seq2seq-lm"]:
						snake_case							=					OrderedDict(
						    [
						        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
						        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
						    ] )
						if self.use_past:
							snake_case							=					{0: 'batch'}
							snake_case							=					{0: 'batch', 1: 'past_decoder_sequence + sequence'}
						else:
							snake_case							=					{0: 'batch', 1: 'decoder_sequence'}
							snake_case							=					{0: 'batch', 1: 'decoder_sequence'}
						if self.use_past:
							self.fill_with_past_key_values_(lowercase_,						direction='inputs' )
					elif self.task == "causal-lm":
						snake_case							=					OrderedDict(
						    [
						        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
						        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
						    ] )
						if self.use_past:
							snake_case			,			snake_case							=					self.num_layers
							for i in range(lowercase_ ):
								snake_case							=					{0: 'batch', 2: 'past_sequence + sequence'}
								snake_case							=					{0: 'batch', 2: 'past_sequence + sequence'}
					else:
						snake_case							=					OrderedDict(
						    [
						        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
						        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
						        ('decoder_input_ids', {0: 'batch', 1: 'decoder_sequence'}),
						        ('decoder_attention_mask', {0: 'batch', 1: 'decoder_sequence'}),
						    ] )

					return common_inputs

				@property
				# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
				def 					_lowerCamelCase    (       self )    ->							Mapping[str, Mapping[int, str]]:
					if self.task in ["default", "seq2seq-lm"]:
						snake_case							=					super().outputs
					else:
						snake_case							=					super(lowercase_,						self ).outputs
						if self.use_past:
							snake_case			,			snake_case							=					self.num_layers
							for i in range(lowercase_ ):
								snake_case							=					{0: 'batch', 2: 'past_sequence + sequence'}
								snake_case							=					{0: 'batch', 2: 'past_sequence + sequence'}
					return common_outputs

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_ = -1,						lowercase_ = -1,						lowercase_ = False,						lowercase_ = None,						)    ->							Mapping[str, Any]:
					snake_case							=					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    lowercase_,						lowercase_,						lowercase_,						lowercase_,						lowercase_ )
					# Generate decoder inputs
					snake_case							=					seq_length if not self.use_past else 1
					snake_case							=					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    lowercase_,						lowercase_,						lowercase_,						lowercase_,						lowercase_ )
					snake_case							=					{F'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
					snake_case							=					dict(**lowercase_,						**lowercase_ )

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

						for _ in range(lowercase_ ):
							common_inputs["past_key_values"].append(
							    (
							        torch.zeros(lowercase_ ),
							        torch.zeros(lowercase_ ),
							        torch.zeros(lowercase_ ),
							        torch.zeros(lowercase_ ),
							    ) )
					return common_inputs

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_ = -1,						lowercase_ = -1,						lowercase_ = False,						lowercase_ = None,						)    ->							Mapping[str, Any]:
					snake_case							=					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    lowercase_,						lowercase_,						lowercase_,						lowercase_,						lowercase_ )

					if self.use_past:
						if not is_torch_available():
							raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.' )
						else:
							import torch
						snake_case			,			snake_case							=					common_inputs['input_ids'].shape
						snake_case							=					seqlen
						snake_case			,			snake_case							=					self.num_layers
						snake_case			,			snake_case							=					self.num_attention_heads
						snake_case							=					(
						    batch,
						    num_encoder_attention_heads,
						    past_key_values_length,
						    self._config.hidden_size // num_encoder_attention_heads,
						)
						snake_case							=					common_inputs['attention_mask'].dtype
						snake_case							=					torch.cat(
						    [common_inputs['attention_mask'], torch.ones(lowercase_,						lowercase_,						dtype=lowercase_ )],						dim=1 )
						snake_case							=					[
						    (torch.zeros(lowercase_ ), torch.zeros(lowercase_ )) for _ in range(lowercase_ )
						]
					return common_inputs

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_ = -1,						lowercase_ = -1,						lowercase_ = False,						lowercase_ = 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
					snake_case							=					compute_effective_axis_dimension(
					    lowercase_,						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
					snake_case							=					tokenizer.num_special_tokens_to_add(lowercase_ )
					snake_case							=					compute_effective_axis_dimension(
					    lowercase_,						fixed_dimension=OnnxConfig.default_fixed_sequence,						num_token_to_add=lowercase_ )

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

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_ = -1,						lowercase_ = -1,						lowercase_ = False,						lowercase_ = None,						)    ->							Mapping[str, Any]:
					if self.task in ["default", "seq2seq-lm"]:
						snake_case							=					self._generate_dummy_inputs_for_default_and_seqaseq_lm(
						    lowercase_,						batch_size=lowercase_,						seq_length=lowercase_,						is_pair=lowercase_,						framework=lowercase_ )

					elif self.task == "causal-lm":
						snake_case							=					self._generate_dummy_inputs_for_causal_lm(
						    lowercase_,						batch_size=lowercase_,						seq_length=lowercase_,						is_pair=lowercase_,						framework=lowercase_ )
					else:
						snake_case							=					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
						    lowercase_,						batch_size=lowercase_,						seq_length=lowercase_,						is_pair=lowercase_,						framework=lowercase_ )

					return common_inputs

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_,						lowercase_ )    ->							List[str]:
					if self.task in ["default", "seq2seq-lm"]:
						snake_case							=					super()._flatten_past_key_values_(lowercase_,						lowercase_,						lowercase_,						lowercase_ )
					else:
						snake_case							=					super(lowercase_,						self )._flatten_past_key_values_(
						    lowercase_,						lowercase_,						lowercase_,						lowercase_ )






				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_ )    ->							List[str]:
					if direction not in ["inputs", "outputs"]:
						raise ValueError(F'''direction must either be "inputs" or "outputs", but {direction} was given''' )

					snake_case							=					'past_key_values' if direction == 'inputs' else 'present'
					snake_case			,			snake_case							=					self.num_layers

					snake_case							=					'past_encoder_sequence'
					snake_case							=					'past_decoder_sequence' if direction == 'inputs' else 'past_decoder_sequence + sequence'

					for i in range(lowercase_ ):
						snake_case							=					{0: 'batch', 2: decoder_sequence}
						snake_case							=					{0: 'batch', 2: decoder_sequence}
						snake_case							=					{0: 'batch', 2: encoder_sequence}
						snake_case							=					{0: 'batch', 2: encoder_sequence}










import sys

sys.set_int_max_str_digits(0)  # type: ignore





def 				A      (	_UpperCAmelCase							:  int       )							->					bool:







			'''simple docstring'''
			_UpperCAmelCase									=  [0] * 11
			_UpperCAmelCase									=  [0] * 11

			# mark last 9 numbers
			for _ in range(9       ):
						_UpperCAmelCase									=  1
						_UpperCAmelCase									=  number // 10
			# flag
			_UpperCAmelCase									=  True

			# check last 9 numbers for pandigitality

			for x in range(9       ):
						if not check_last[x + 1]:
									_UpperCAmelCase									=  False
			if not f:
						return f

			# mark first 9 numbers
			_UpperCAmelCase									=  int(str(_UpperCAmelCase       )[:9]       )

			for _ in range(9       ):
						_UpperCAmelCase									=  1
						_UpperCAmelCase									=  number // 10

			# check first 9 numbers for pandigitality

			for x in range(9       ):
						if not check_front[x + 1]:
									_UpperCAmelCase									=  False
			return f





def 				A      (	_UpperCAmelCase							:  int       )							->					bool:







			'''simple docstring'''
			_UpperCAmelCase									=  [0] * 11

			# mark last 9 numbers
			for _ in range(9       ):
						_UpperCAmelCase									=  1
						_UpperCAmelCase									=  number // 10
			# flag
			_UpperCAmelCase									=  True

			# check last 9 numbers for pandigitality

			for x in range(9       ):
						if not check_last[x + 1]:
									_UpperCAmelCase									=  False
			return f





def 				A      (	)							->					int:







			'''simple docstring'''
			_UpperCAmelCase									=  1
			_UpperCAmelCase									=  1
			_UpperCAmelCase									=  2
			# temporary Fibonacci numbers

			_UpperCAmelCase									=  1
			_UpperCAmelCase									=  1
			_UpperCAmelCase									=  2
			# temporary Fibonacci numbers mod 1e9

			# mod m=1e9, done for fast optimisation
			_UpperCAmelCase									=  [0] * 1_000_000
			_UpperCAmelCase									=  1_000_000_000

			for x in range(1_000_000       ):
						_UpperCAmelCase									=  (aa + ba) % m
						_UpperCAmelCase									=  ba % m
						_UpperCAmelCase									=  ca % m
						if checka(_UpperCAmelCase       ):
									_UpperCAmelCase									=  1

			for x in range(1_000_000       ):
						_UpperCAmelCase									=  a + b
						_UpperCAmelCase									=  b
						_UpperCAmelCase									=  c
						# perform check only if in tocheck
						if tocheck[x + 3] and check(_UpperCAmelCase       ):
									return x + 3  # first 2 already done
			return -1


if __name__ == "__main__":
							print(f"""{solution() = }""")
