





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

__lowerCamelCase	:					Dict			  =					logging.get_logger(__name__)

__lowerCamelCase	:					Dict			  =					{
    '''openai/whisper-base''': '''https://huggingface.co/openai/whisper-base/resolve/main/config.json''',
}

# fmt: off
__lowerCamelCase	:					List[Any]			  =					[
    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
]
__lowerCamelCase	:					str			  =					[
    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_      ):
      _UpperCAmelCase     :List[Any]						   =       'whisper'
      _UpperCAmelCase     :Any						   =       ['past_key_values']
      _UpperCAmelCase     :str						   =       {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}





      def __init__(			self	,							A_=5_1865	,							A_=80	,							A_=6	,							A_=4	,							A_=6	,							A_=4	,							A_=1536	,							A_=1536	,							A_=0.0	,							A_=0.0	,							A_=5_0257	,							A_=True	,							A_=True	,							A_="gelu"	,							A_=256	,							A_=0.0	,							A_=0.0	,							A_=0.0	,							A_=0.02	,							A_=False	,							A_=1500	,							A_=448	,							A_=5_0256	,							A_=5_0256	,							A_=5_0256	,							A_=None	,							A_=[220, 5_0256]	,							A_=False	,							A_=256	,							A_=False	,							A_=0.05	,							A_=10	,							A_=2	,							A_=0.0	,							A_=10	,							A_=0	,							A_=7	,							**A_	,							):
       '''simple docstring'''




       UpperCamelCase     : Dict	     =       vocab_size
       UpperCamelCase     : List[str]	     =       num_mel_bins
       UpperCamelCase     : str	     =       d_model
       UpperCamelCase     : Dict	     =       encoder_layers
       UpperCamelCase     : Tuple	     =       encoder_attention_heads
       UpperCamelCase     : Dict	     =       decoder_layers
       UpperCamelCase     : int	     =       decoder_attention_heads
       UpperCamelCase     : List[Any]	     =       decoder_ffn_dim
       UpperCamelCase     : List[Any]	     =       encoder_ffn_dim
       UpperCamelCase     : Optional[Any]	     =       dropout
       UpperCamelCase     : Tuple	     =       attention_dropout
       UpperCamelCase     : str	     =       activation_dropout
       UpperCamelCase     : Tuple	     =       activation_function
       UpperCamelCase     : List[Any]	     =       init_std
       UpperCamelCase     : Dict	     =       encoder_layerdrop
       UpperCamelCase     : Tuple	     =       decoder_layerdrop
       UpperCamelCase     : Dict	     =       use_cache
       UpperCamelCase     : List[Any]	     =       encoder_layers
       UpperCamelCase     : Union[str, Any]	     =       scale_embedding  # scale factor will be sqrt(d_model) if True
       UpperCamelCase     : Any	     =       max_source_positions
       UpperCamelCase     : int	     =       max_target_positions

       # Audio Classification-specific parameters. Feel free to ignore for other classes.
       UpperCamelCase     : Any	     =       classifier_proj_size
       UpperCamelCase     : str	     =       use_weighted_layer_sum

       # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
       UpperCamelCase     : Optional[Any]	     =       apply_spec_augment
       UpperCamelCase     : List[str]	     =       mask_time_prob
       UpperCamelCase     : List[str]	     =       mask_time_length
       UpperCamelCase     : Union[str, Any]	     =       mask_time_min_masks
       UpperCamelCase     : Optional[int]	     =       mask_feature_prob
       UpperCamelCase     : Union[str, Any]	     =       mask_feature_length
       UpperCamelCase     : Union[str, Any]	     =       mask_feature_min_masks

       UpperCamelCase     : Dict	     =       median_filter_width

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



class  A__       (	SCREAMING_SNAKE_CASE_      ):





      @property
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Any	     =       OrderedDict(
           [
               ("input_features", {0: "batch", 1: "feature_size", 2: "encoder_sequence"}),
           ]       )
       if self.use_past:
        UpperCamelCase     : List[str]	     =       {0: 'batch'}
       else:
        UpperCamelCase     : Dict	     =       {0: 'batch', 1: 'decoder_sequence'}

       if self.use_past:
        self.fill_with_past_key_values_(__a	,							direction="inputs"       )

       return common_inputs





      def 	__UpperCamelCase(			self	,							A_	,							A_ = -1	,							A_ = -1	,							A_ = False	,							A_ = None	,							A_ = 2_2050	,							A_ = 5.0	,							A_ = 220	,							):
       '''simple docstring'''




       UpperCamelCase     : Union[str, Any]	     =       OrderedDict()
       UpperCamelCase     : Any	     =       OnnxConfig.generate_dummy_inputs(
           self	,							preprocessor=preprocessor.feature_extractor	,							batch_size=__a	,							framework=__a	,							sampling_rate=__a	,							time_duration=__a	,							frequency=__a	,							)
       UpperCamelCase     : Union[str, Any]	     =       encoder_inputs['input_features'].shape[2]
       UpperCamelCase     : Optional[Any]	     =       encoder_sequence_length // 2 if self.use_past else seq_length

       UpperCamelCase     : List[Any]	     =       super().generate_dummy_inputs(
           preprocessor.tokenizer	,							__a	,							__a	,							__a	,							__a       )

       UpperCamelCase     : Any	     =       encoder_inputs.pop("input_features"       )
       UpperCamelCase     : Dict	     =       decoder_inputs.pop("decoder_input_ids"       )

       if "past_key_values" in decoder_inputs:
        UpperCamelCase     : Union[str, Any]	     =       decoder_inputs.pop("past_key_values"       )

       return dummy_inputs





      @property
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       return 1e-3







def 		A_    (					_lowerCAmelCase					)						->			int:
 if n == 1 or not isinstance(_lowerCAmelCase							,       _lowerCAmelCase					):
  return 0
 elif n == 2:
  return 1
 else:
  UpperCamelCase     : Optional[Any]	     =       [0, 1]
  for i in range(2							,       n + 1					):
   sequence.append(sequence[i - 1] + sequence[i - 2]					)

  return sequence[n]



def 		A_    (					_lowerCAmelCase					)						->			int:
 UpperCamelCase     : Any	     =       0
 UpperCamelCase     : List[Any]	     =       2

 while digits < n:
  index += 1
  UpperCamelCase     : Union[str, Any]	     =       len(str(fibonacci(_lowerCAmelCase					)					)					)

 return index



def 		A_    (					_lowerCAmelCase = 1000					)						->			int:
 return fibonacci_digits_index(_lowerCAmelCase					)


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