



"""simple docstring"""


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

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...utils import logging


if TYPE_CHECKING:
				from ...feature_extraction_utils import FeatureExtractionMixin
				from ...tokenization_utils_base import PreTrainedTokenizerBase
				from ...utils import TensorType

snake_case_				     =       logging.get_logger(__name__)

snake_case_				     =       {
    """openai/whisper-base""": """https://huggingface.co/openai/whisper-base/resolve/main/config.json""",
}

# fmt: off
snake_case_				     =       [
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 357, 366, 438, 532, 685,
    705, 796, 930, 1058, 1220, 1267, 1279, 1303, 1343, 1377,
    1391, 1635, 1782, 1875, 2162, 2361, 2488, 3467, 4008, 4211,
    4600, 4808, 5299, 5855, 6329, 7203, 9609, 9959, 1_0563, 1_0786,
    1_1420, 1_1709, 1_1907, 1_3163, 1_3697, 1_3700, 1_4808, 1_5306, 1_6410, 1_6791,
    1_7992, 1_9203, 1_9510, 2_0724, 2_2305, 2_2935, 2_7007, 3_0109, 3_0420, 3_3409,
    3_4949, 4_0283, 4_0493, 4_0549, 4_7282, 4_9146, 5_0257, 5_0359, 5_0360, 5_0361
]
snake_case_				     =       [
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 359, 503, 522, 542, 873,
    893, 902, 918, 922, 931, 1350, 1853, 1982, 2460, 2627,
    3246, 3253, 3268, 3536, 3846, 3961, 4183, 4667, 6585, 6647,
    7273, 9061, 9383, 1_0428, 1_0929, 1_1938, 1_2033, 1_2331, 1_2562, 1_3793,
    1_4157, 1_4635, 1_5265, 1_5618, 1_6553, 1_6604, 1_8362, 1_8956, 2_0075, 2_1675,
    2_2520, 2_6130, 2_6161, 2_6435, 2_8279, 2_9464, 3_1650, 3_2302, 3_2470, 3_6865,
    4_2863, 4_7425, 4_9870, 5_0254, 5_0258, 5_0360, 5_0361, 5_0362
]







class       A_			(     SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							"""whisper"""
						__UpperCamelCase						=							["""past_key_values"""]
						__UpperCamelCase						=							{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}






						def __init__(					self :Optional[Any]   ,  lowercase_ :Dict=5_18_65   ,  lowercase_ :Tuple=80   ,  lowercase_ :str=6   ,  lowercase_ :Optional[Any]=4   ,  lowercase_ :Union[str, Any]=6   ,  lowercase_ :Any=4   ,  lowercase_ :Optional[int]=15_36   ,  lowercase_ :Optional[Any]=15_36   ,  lowercase_ :Tuple=0.0   ,  lowercase_ :List[Any]=0.0   ,  lowercase_ :List[Any]=5_02_57   ,  lowercase_ :str=True   ,  lowercase_ :Optional[int]=True   ,  lowercase_ :Tuple="gelu"   ,  lowercase_ :Union[str, Any]=2_56   ,  lowercase_ :Optional[int]=0.0   ,  lowercase_ :List[Any]=0.0   ,  lowercase_ :List[str]=0.0   ,  lowercase_ :Dict=0.02   ,  lowercase_ :Any=False   ,  lowercase_ :str=15_00   ,  lowercase_ :Union[str, Any]=4_48   ,  lowercase_ :List[str]=5_02_56   ,  lowercase_ :Any=5_02_56   ,  lowercase_ :Optional[int]=5_02_56   ,  lowercase_ :List[Any]=None   ,  lowercase_ :Dict=[2_20, 5_02_56]   ,  lowercase_ :Optional[int]=False   ,  lowercase_ :Optional[int]=2_56   ,  lowercase_ :Tuple=False   ,  lowercase_ :Any=0.05   ,  lowercase_ :Tuple=10   ,  lowercase_ :Dict=2   ,  lowercase_ :Union[str, Any]=0.0   ,  lowercase_ :List[str]=10   ,  lowercase_ :str=0   ,  lowercase_ :Tuple=7   ,  **lowercase_ :Optional[int]   ,  )				->			Optional[Any]:
												UpperCAmelCase             = vocab_size
												UpperCAmelCase             = num_mel_bins
												UpperCAmelCase             = d_model
												UpperCAmelCase             = encoder_layers
												UpperCAmelCase             = encoder_attention_heads
												UpperCAmelCase             = decoder_layers
												UpperCAmelCase             = decoder_attention_heads
												UpperCAmelCase             = decoder_ffn_dim
												UpperCAmelCase             = encoder_ffn_dim
												UpperCAmelCase             = dropout
												UpperCAmelCase             = attention_dropout
												UpperCAmelCase             = activation_dropout
												UpperCAmelCase             = activation_function
												UpperCAmelCase             = init_std
												UpperCAmelCase             = encoder_layerdrop
												UpperCAmelCase             = decoder_layerdrop
												UpperCAmelCase             = use_cache
												UpperCAmelCase             = encoder_layers
												UpperCAmelCase             = scale_embedding  # scale factor will be sqrt(d_model) if True
												UpperCAmelCase             = max_source_positions
												UpperCAmelCase             = max_target_positions

												# Audio Classification-specific parameters. Feel free to ignore for other classes.
												UpperCAmelCase             = classifier_proj_size
												UpperCAmelCase             = use_weighted_layer_sum

												# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
												UpperCAmelCase             = apply_spec_augment
												UpperCAmelCase             = mask_time_prob
												UpperCAmelCase             = mask_time_length
												UpperCAmelCase             = mask_time_min_masks
												UpperCAmelCase             = mask_feature_prob
												UpperCAmelCase             = mask_feature_length
												UpperCAmelCase             = mask_feature_min_masks

												UpperCAmelCase             = median_filter_width

												super().__init__(
												    pad_token_id=lowercase_   ,  bos_token_id=lowercase_   ,  eos_token_id=lowercase_   ,  is_encoder_decoder=lowercase_   ,  decoder_start_token_id=lowercase_   ,  suppress_tokens=lowercase_   ,  begin_suppress_tokens=lowercase_   ,  **lowercase_   ,  )







class       A_			(     SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""






						@property
						def 	UpperCAmelCase__     (					self :Any					)				->			Mapping[str, Mapping[int, str]]:
												UpperCAmelCase             = OrderedDict(
												    [
												        ('input_features', {0: 'batch', 1: 'feature_size', 2: 'encoder_sequence'}),
												    ]					)
												if self.use_past:
																		UpperCAmelCase             = {0: 'batch'}
												else:
																		UpperCAmelCase             = {0: 'batch', 1: 'decoder_sequence'}

												if self.use_past:
																		self.fill_with_past_key_values_(lowercase_   ,  direction='inputs'					)

												return common_inputs






						def 	UpperCAmelCase__     (					self :int   ,  lowercase_ :Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]   ,  lowercase_ :int = -1   ,  lowercase_ :int = -1   ,  lowercase_ :bool = False   ,  lowercase_ :Optional["TensorType"] = None   ,  lowercase_ :int = 2_20_50   ,  lowercase_ :float = 5.0   ,  lowercase_ :int = 2_20   ,  )				->			Mapping[str, Any]:
												UpperCAmelCase             = OrderedDict()
												UpperCAmelCase             = OnnxConfig.generate_dummy_inputs(
												    self   ,  preprocessor=preprocessor.feature_extractor   ,  batch_size=lowercase_   ,  framework=lowercase_   ,  sampling_rate=lowercase_   ,  time_duration=lowercase_   ,  frequency=lowercase_   ,  )
												UpperCAmelCase             = encoder_inputs['input_features'].shape[2]
												UpperCAmelCase             = encoder_sequence_length // 2 if self.use_past else seq_length

												UpperCAmelCase             = super().generate_dummy_inputs(
												    preprocessor.tokenizer   ,  lowercase_   ,  lowercase_   ,  lowercase_   ,  lowercase_					)

												UpperCAmelCase             = encoder_inputs.pop('input_features'					)
												UpperCAmelCase             = decoder_inputs.pop('decoder_input_ids'					)

												if "past_key_values" in decoder_inputs:
																		UpperCAmelCase             = decoder_inputs.pop('past_key_values'					)

												return dummy_inputs






						@property
						def 	UpperCAmelCase__     (					self :Dict					)				->			float:
												return 1E-3













"""simple docstring"""



def 						lowercase    (				__snake_case				: int	):
		if n == 1 or not isinstance(__snake_case		,					__snake_case	):
				return 0
		elif n == 2:
				return 1
		else:
				lowercase_ : Dict							       =   [0, 1]
				for i in range(2		,					n + 1	):
						sequence.append(sequence[i - 1] + sequence[i - 2]	)

				return sequence[n]



def 						lowercase    (				__snake_case				: int	):
		lowercase_ : str							       =   0
		lowercase_ : List[str]							       =   2

		while digits < n:
				index += 1
				lowercase_ : Any							       =   len(str(fibonacci(__snake_case	)	)	)

		return index



def 						lowercase    (				__snake_case				: int = 1_0_0_0	):
		return fibonacci_digits_index(__snake_case	)


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



