




'''simple docstring'''

from __future__ import annotations

import unittest

from transformers import DebertaVaConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import (
							    TFDebertaVaForMaskedLM,
							    TFDebertaVaForQuestionAnswering,
							    TFDebertaVaForSequenceClassification,
							    TFDebertaVaForTokenClassification,
							    TFDebertaVaModel,
							)






class 		a							:


				def __init__(						self       :   Optional[Any]			,							lowercase_       :   Dict			,							lowercase_       :   Tuple=13			,							lowercase_       :   Optional[int]=7			,							lowercase_       :   List[str]=True			,							lowercase_       :   int=True			,							lowercase_       :   Union[str, Any]=True			,							lowercase_       :   List[Any]=True			,							lowercase_       :   str=99			,							lowercase_       :   Any=32			,							lowercase_       :   Optional[Any]=2			,							lowercase_       :   Optional[int]=4			,							lowercase_       :   Union[str, Any]=37			,							lowercase_       :   int="gelu"			,							lowercase_       :   Dict=0.1			,							lowercase_       :   str=0.1			,							lowercase_       :   Any=512			,							lowercase_       :   Any=16			,							lowercase_       :   List[str]=2			,							lowercase_       :   List[str]=0.02			,							lowercase_       :   Union[str, Any]=False			,							lowercase_       :   Optional[int]=True			,							lowercase_       :   Optional[Any]="None"			,							lowercase_       :   Dict=3			,							lowercase_       :   Any=4			,							lowercase_       :   List[str]=None			,							):
									snake_case_		     =							parent
									snake_case_		     =							batch_size
									snake_case_		     =							seq_length
									snake_case_		     =							is_training
									snake_case_		     =							use_input_mask
									snake_case_		     =							use_token_type_ids
									snake_case_		     =							use_labels
									snake_case_		     =							vocab_size
									snake_case_		     =							hidden_size
									snake_case_		     =							num_hidden_layers
									snake_case_		     =							num_attention_heads
									snake_case_		     =							intermediate_size
									snake_case_		     =							hidden_act
									snake_case_		     =							hidden_dropout_prob
									snake_case_		     =							attention_probs_dropout_prob
									snake_case_		     =							max_position_embeddings
									snake_case_		     =							type_vocab_size
									snake_case_		     =							type_sequence_label_size
									snake_case_		     =							initializer_range
									snake_case_		     =							num_labels
									snake_case_		     =							num_choices
									snake_case_		     =							relative_attention
									snake_case_		     =							position_biased_input
									snake_case_		     =							pos_att_type
									snake_case_		     =							scope


				def     A_					(						self       :   int   ):
									snake_case_		     =							ids_tensor([self.batch_size, self.seq_length]			,							self.vocab_size   )

									snake_case_		     =							None
									if self.use_input_mask:
														snake_case_		     =							random_attention_mask([self.batch_size, self.seq_length]   )

									snake_case_		     =							None
									if self.use_token_type_ids:
														snake_case_		     =							ids_tensor([self.batch_size, self.seq_length]			,							self.type_vocab_size   )

									snake_case_		     =							None
									snake_case_		     =							None
									snake_case_		     =							None
									if self.use_labels:
														snake_case_		     =							ids_tensor([self.batch_size]			,							self.type_sequence_label_size   )
														snake_case_		     =							ids_tensor([self.batch_size, self.seq_length]			,							self.num_labels   )

									snake_case_		     =							DebertaVaConfig(
									    vocab_size=self.vocab_size			,							hidden_size=self.hidden_size			,							num_hidden_layers=self.num_hidden_layers			,							num_attention_heads=self.num_attention_heads			,							intermediate_size=self.intermediate_size			,							hidden_act=self.hidden_act			,							hidden_dropout_prob=self.hidden_dropout_prob			,							attention_probs_dropout_prob=self.attention_probs_dropout_prob			,							max_position_embeddings=self.max_position_embeddings			,							type_vocab_size=self.type_vocab_size			,							relative_attention=self.relative_attention			,							position_biased_input=self.position_biased_input			,							initializer_range=self.initializer_range			,							return_dict=lowercase_			,							)

									return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


				def     A_					(						self       :   Any			,							lowercase_       :   str			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   str			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   Optional[Any]			,							lowercase_       :   List[Any]   ):
									snake_case_		     =							TFDebertaVaModel(config=lowercase_   )
									snake_case_		     =							{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

									snake_case_		     =							[input_ids, input_mask]
									snake_case_		     =							model(lowercase_   )

									snake_case_		     =							model(lowercase_   )

									self.parent.assertEqual(result.last_hidden_state.shape			,							(self.batch_size, self.seq_length, self.hidden_size)   )


				def     A_					(						self       :   str			,							lowercase_       :   Dict			,							lowercase_       :   Optional[int]			,							lowercase_       :   Any			,							lowercase_       :   str			,							lowercase_       :   Optional[Any]			,							lowercase_       :   Dict			,							lowercase_       :   Tuple   ):
									snake_case_		     =							TFDebertaVaForMaskedLM(config=lowercase_   )
									snake_case_		     =							{
									    '''input_ids''': input_ids,
									    '''attention_mask''': input_mask,
									    '''token_type_ids''': token_type_ids,
									}
									snake_case_		     =							model(lowercase_   )
									self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.seq_length, self.vocab_size)   )


				def     A_					(						self       :   List[Any]			,							lowercase_       :   Dict			,							lowercase_       :   Dict			,							lowercase_       :   List[str]			,							lowercase_       :   int			,							lowercase_       :   List[Any]			,							lowercase_       :   Dict			,							lowercase_       :   str   ):
									snake_case_		     =							self.num_labels
									snake_case_		     =							TFDebertaVaForSequenceClassification(config=lowercase_   )
									snake_case_		     =							{
									    '''input_ids''': input_ids,
									    '''attention_mask''': input_mask,
									    '''token_type_ids''': token_type_ids,
									}

									snake_case_		     =							model(lowercase_   )
									self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.num_labels)   )


				def     A_					(						self       :   Union[str, Any]			,							lowercase_       :   Any			,							lowercase_       :   Tuple			,							lowercase_       :   Optional[int]			,							lowercase_       :   Optional[int]			,							lowercase_       :   Any			,							lowercase_       :   Optional[int]			,							lowercase_       :   int   ):
									snake_case_		     =							self.num_labels
									snake_case_		     =							TFDebertaVaForTokenClassification(config=lowercase_   )
									snake_case_		     =							{
									    '''input_ids''': input_ids,
									    '''attention_mask''': input_mask,
									    '''token_type_ids''': token_type_ids,
									}
									snake_case_		     =							model(lowercase_   )
									self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.seq_length, self.num_labels)   )


				def     A_					(						self       :   int			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   List[str]			,							lowercase_       :   List[str]			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   List[str]			,							lowercase_       :   int			,							lowercase_       :   Dict   ):
									snake_case_		     =							TFDebertaVaForQuestionAnswering(config=lowercase_   )
									snake_case_		     =							{
									    '''input_ids''': input_ids,
									    '''attention_mask''': input_mask,
									    '''token_type_ids''': token_type_ids,
									}

									snake_case_		     =							model(lowercase_   )
									self.parent.assertEqual(result.start_logits.shape			,							(self.batch_size, self.seq_length)   )
									self.parent.assertEqual(result.end_logits.shape			,							(self.batch_size, self.seq_length)   )


				def     A_					(						self       :   Any   ):
									snake_case_		     =							self.prepare_config_and_inputs()
									(
									    (
									    snake_case_
									)     ,(
									    snake_case_
									)     ,(
									    snake_case_
									)     ,(
									    snake_case_
									)     ,(
									    snake_case_
									)     ,(
									    snake_case_
									)     ,(
									    snake_case_
									)     ,
									)		     =							config_and_inputs
									snake_case_		     =							{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
									return config, inputs_dict







@require_tf
class 		a							(  _lowerCamelCase  ,	_lowerCamelCase  ,	unittest.TestCase	):
				snake_case_           =						(
				    (
				        TFDebertaVaModel,
				        TFDebertaVaForMaskedLM,
				        TFDebertaVaForQuestionAnswering,
				        TFDebertaVaForSequenceClassification,
				        TFDebertaVaForTokenClassification,
				    )
				    if is_tf_available()
				    else ()
				)
				snake_case_           =						(
				    {
				        "feature-extraction": TFDebertaVaModel,
				        "fill-mask": TFDebertaVaForMaskedLM,
				        "question-answering": TFDebertaVaForQuestionAnswering,
				        "text-classification": TFDebertaVaForSequenceClassification,
				        "token-classification": TFDebertaVaForTokenClassification,
				        "zero-shot": TFDebertaVaForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)

				snake_case_           =						False
				snake_case_           =						False


				def     A_					(						self       :   List[Any]   ):
									snake_case_		     =							TFDebertaVaModelTester(self   )
									snake_case_		     =							ConfigTester(self			,							config_class=lowercase_			,							hidden_size=37   )


				def     A_					(						self       :   Optional[Any]   ):
									self.config_tester.run_common_tests()


				def     A_					(						self       :   Tuple   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*lowercase_   )


				def     A_					(						self       :   List[Any]   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*lowercase_   )


				def     A_					(						self       :   List[str]   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*lowercase_   )


				def     A_					(						self       :   int   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*lowercase_   )


				def     A_					(						self       :   Union[str, Any]   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*lowercase_   )


				@slow
				def     A_					(						self       :   Union[str, Any]   ):
									snake_case_		     =							TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge'''   )
									self.assertIsNotNone(lowercase_   )







@require_tf
class 		a							(  unittest.TestCase	):


				@unittest.skip(reason='''Model not available yet'''   )
				def     A_					(						self       :   Any   ):
									pass


				@slow
				def     A_					(						self       :   List[Any]   ):
									snake_case_		     =							TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge'''   )
									snake_case_		     =							tf.constant([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]]   )
									snake_case_		     =							tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]   )
									snake_case_		     =							model(lowercase_			,							attention_mask=lowercase_   )[0]

									snake_case_		     =							tf.constant(
									    [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]]   )
									tf.debugging.assert_near(output[:, 1:4, 1:4]			,							lowercase_			,							atol=1e-4   )







'''simple docstring'''

from collections.abc import Generator


def 						__magic_name__       (      )						->   Generator[int, None, None]:

					'''simple docstring'''

					snake_case_     ,snake_case_		     =							0, 1
					while True:
										snake_case_     ,snake_case_		     =							b, a + b
										yield b


def 						__magic_name__       (      __UpperCAmelCase = 1000      )						->   int:

					'''simple docstring'''

					snake_case_		     =							1
					snake_case_		     =							fibonacci_generator()
					while len(str(next(__UpperCAmelCase      )      )      ) < n:
										answer += 1
					return answer + 1


if __name__ == "__main__":
							print(solution(int(str(input()).strip())))

