



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

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


UpperCAmelCase							=       logging.get_logger(__name__)

UpperCAmelCase							=       {
    '''google/bigbird-pegasus-large-arxiv''': (
        '''https://huggingface.co/google/bigbird-pegasus-large-arxiv/resolve/main/config.json'''
    ),
    '''google/bigbird-pegasus-large-pubmed''': (
        '''https://huggingface.co/google/bigbird-pegasus-large-pubmed/resolve/main/config.json'''
    ),
    '''google/bigbird-pegasus-large-bigpatent''': (
        '''https://huggingface.co/google/bigbird-pegasus-large-bigpatent/resolve/main/config.json'''
    ),
    # See all BigBirdPegasus models at https://huggingface.co/models?filter=bigbird_pegasus
}

class 			__snake_case   ( _lowerCamelCase):







							'''simple docstring'''






							UpperCamelCase__					:   Tuple       =       """bigbird_pegasus"""
							UpperCamelCase__					:   Any       =       ["""past_key_values"""]
							UpperCamelCase__					:   List[Any]       =       {
							    """num_attention_heads""": """encoder_attention_heads""",
							    """hidden_size""": """d_model""",
							    """attention_probs_dropout_prob""": """attention_dropout""",
							}


							def __init__(				self	,	a_=96_103	,	a_=4_096	,	a_=16	,	a_=4_096	,	a_=16	,	a_=16	,	a_=4_096	,	a_=16	,	a_=0.0	,	a_=0.0	,	a_=True	,	a_=True	,	a_="gelu_new"	,	a_=1_024	,	a_=0.1	,	a_=0.0	,	a_=0.0	,	a_=0.02	,	a_=2	,	a_=0.0	,	a_=True	,	a_=0	,	a_=2	,	a_=1	,	a_="block_sparse"	,	a_=64	,	a_=3	,	a_=False	,	**a_	,	):
											a__					   =		vocab_size
											a__					   =		max_position_embeddings
											a__					   =		d_model
											a__					   =		encoder_ffn_dim
											a__					   =		encoder_layers
											a__					   =		encoder_attention_heads
											a__					   =		decoder_ffn_dim
											a__					   =		decoder_layers
											a__					   =		decoder_attention_heads
											a__					   =		dropout
											a__					   =		attention_dropout
											a__					   =		activation_dropout
											a__					   =		activation_function
											a__					   =		init_std
											a__					   =		encoder_layerdrop
											a__					   =		decoder_layerdrop
											a__					   =		classifier_dropout
											a__					   =		use_cache
											a__					   =		encoder_layers
											a__					   =		scale_embedding  # scale factor will be sqrt(d_model) if True

											# extra config
											a__					   =		attention_type
											a__					   =		block_size
											a__					   =		num_random_blocks
											a__					   =		use_bias

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




class 			__snake_case   ( _lowerCamelCase):







							'''simple docstring'''






							@property
							def _a   (				self		):







											if self.task in ["default", "seq2seq-lm"]:
															a__					   =		OrderedDict(
															    [
															        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
															        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
															    ]		)

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

															if self.use_past:
																			self.fill_with_past_key_values_(__UpperCamelCase	,	direction="""inputs"""		)
											elif self.task == "causal-lm":
															# TODO: figure this case out.
															a__					   =		OrderedDict(
															    [
															        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
															        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
															    ]		)
															if self.use_past:
																			a__					   =		self.num_layers
																			for i in range(__UpperCamelCase		):
																							a__					   =		{0: 'batch', 2: 'past_sequence + sequence'}
																							a__					   =		{0: 'batch', 2: 'past_sequence + sequence'}
											else:
															a__					   =		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
							def _a   (				self		):







											if self.task in ["default", "seq2seq-lm"]:
															a__					   =		super().outputs
											else:
															a__					   =		super(__UpperCamelCase	,	self		).outputs
															if self.use_past:
																			a__					   =		self.num_layers
																			for i in range(__UpperCamelCase		):
																							a__					   =		{0: 'batch', 2: 'past_sequence + sequence'}
																							a__					   =		{0: 'batch', 2: 'past_sequence + sequence'}
											return common_outputs


							def _a   (				self	,	a_	,	a_ = -1	,	a_ = -1	,	a_ = False	,	a_ = None	,	):
											a__					   =		self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
											    __UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase		)

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

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

															a__					   =		torch.cat(
															    [common_inputs["""decoder_attention_mask"""], torch.ones(__UpperCamelCase	,	__UpperCamelCase		)]	,	dim=1		)

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

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


							def _a   (				self	,	a_	,	a_ = -1	,	a_ = -1	,	a_ = False	,	a_ = None	,	):
											a__					   =		self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
											    __UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase		)

											if self.use_past:
															if not is_torch_available():
																			raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""		)
															else:
																			import torch
															a__					   =		common_inputs['input_ids'].shape
															# Not using the same length for past_key_values
															a__					   =		seqlen + 2
															a__					   =		self.num_layers
															a__					   =		self.num_attention_heads
															a__					   =		(
															    batch,
															    num_encoder_attention_heads,
															    past_key_values_length,
															    self._config.hidden_size // num_encoder_attention_heads,
															)

															a__					   =		common_inputs['attention_mask'].dtype
															a__					   =		torch.cat(
															    [common_inputs["""attention_mask"""], torch.ones(__UpperCamelCase	,	__UpperCamelCase	,	dtype=__UpperCamelCase		)]	,	dim=1		)
															a__					   =		[
															    (torch.zeros(__UpperCamelCase		), torch.zeros(__UpperCamelCase		)) for _ in range(__UpperCamelCase		)
															]
											return common_inputs


							def _a   (				self	,	a_	,	a_ = -1	,	a_ = -1	,	a_ = False	,	a_ = None	,	):
											a__					   =		compute_effective_axis_dimension(
											    __UpperCamelCase	,	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
											a__					   =		tokenizer.num_special_tokens_to_add(__UpperCamelCase		)
											a__					   =		compute_effective_axis_dimension(
											    __UpperCamelCase	,	fixed_dimension=OnnxConfig.default_fixed_sequence	,	num_token_to_add=__UpperCamelCase		)

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


							def _a   (				self	,	a_	,	a_ = -1	,	a_ = -1	,	a_ = False	,	a_ = None	,	):







											if self.task in ["default", "seq2seq-lm"]:
															a__					   =		self._generate_dummy_inputs_for_default_and_seqaseq_lm(
															    __UpperCamelCase	,	batch_size=__UpperCamelCase	,	seq_length=__UpperCamelCase	,	is_pair=__UpperCamelCase	,	framework=__UpperCamelCase		)

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

											return common_inputs







							def _a   (				self	,	a_	,	a_	,	a_	,	a_		):







											if self.task in ["default", "seq2seq-lm"]:
															a__					   =		super()._flatten_past_key_values_(__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase		)
											else:
															a__					   =		super(__UpperCamelCase	,	self		)._flatten_past_key_values_(
															    __UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase		)


def 					UpperCamelCase__		(							A__ = 400_0000       )  ->   int:

				if n <= 1:
								return 0
				snake_case__   :      Optional[Any]   				= 0
				snake_case__   :      Optional[int]   				= 2
				snake_case__   :      str   				= 0
				while 4 * b + a <= n:
								snake_case__				,    snake_case__   :      Optional[Any]   				= b, 4 * b + a
								count += a
				return count + b


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


