



"""simple docstring"""






import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
from .tokenization_wavaveca import WavaVecaCTCTokenizer






class        __snake_case       (	SCREAMING_SNAKE_CASE__):
  snake_case__				:   Optional[int]  			=						"Wav2Vec2FeatureExtractor"
  snake_case__				:   Optional[Any]  			=						"AutoTokenizer"




  def __init__( self     :						Tuple						,					__lowerCAmelCase     :						str						,					__lowerCAmelCase     :						Dict		):






         """simple docstring"""






         super().__init__(__lowerCAmelCase						,					__lowerCAmelCase		)
         _lowerCamelCase						:				Any    			= self.feature_extractor
         _lowerCamelCase						:				Optional[Any]    			= False




  @classmethod
  def 						SCREAMING_SNAKE_CASE				( cls     :						int						,					__lowerCAmelCase     :						Union[str, Any]						,					**__lowerCAmelCase     :						Optional[int]		):






         """simple docstring"""






         try:
                return super().from_pretrained(__lowerCAmelCase						,					**__lowerCAmelCase		)
         except OSError:
                warnings.warn(
                    f'''Loading a tokenizer inside {cls.__name__} from a config that does not'''
                    ''' include a `tokenizer_class` attribute is deprecated and will be '''
                    '''removed in v5. Please add `\'tokenizer_class\': \'Wav2Vec2CTCTokenizer\'`'''
                    ''' attribute to either your `config.json` or `tokenizer_config.json` '''
                    '''file to suppress this warning: '''						,					__lowerCAmelCase						,					)

                _lowerCamelCase						:				Optional[Any]    			= WavaVecaFeatureExtractor.from_pretrained(__lowerCAmelCase						,					**__lowerCAmelCase		)
                _lowerCamelCase						:				List[Any]    			= WavaVecaCTCTokenizer.from_pretrained(__lowerCAmelCase						,					**__lowerCAmelCase		)

                return cls(feature_extractor=__lowerCAmelCase						,					tokenizer=__lowerCAmelCase		)




  def __call__( self     :						Union[str, Any]						,					*__lowerCAmelCase     :						Optional[Any]						,					**__lowerCAmelCase     :						Union[str, Any]		):






         """simple docstring"""






         if self._in_target_context_manager:
                return self.current_processor(*__lowerCAmelCase						,					**__lowerCAmelCase		)

         if "raw_speech" in kwargs:
                warnings.warn('''Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'''		)
                _lowerCamelCase						:				int    			= kwargs.pop('''raw_speech'''		)
         else:
                _lowerCamelCase						:				str    			= kwargs.pop('''audio'''						,					__lowerCAmelCase		)
         _lowerCamelCase						:				int    			= kwargs.pop('''sampling_rate'''						,					__lowerCAmelCase		)
         _lowerCamelCase						:				List[Any]    			= kwargs.pop('''text'''						,					__lowerCAmelCase		)
         if len(__lowerCAmelCase		) > 0:
                _lowerCamelCase						:				Optional[int]    			= args[0]
                _lowerCamelCase						:				Optional[int]    			= args[1:]

         if audio is None and text is None:
                raise ValueError('''You need to specify either an `audio` or `text` input to process.'''		)

         if audio is not None:
                _lowerCamelCase						:				Dict    			= self.feature_extractor(__lowerCAmelCase						,					*__lowerCAmelCase						,					sampling_rate=__lowerCAmelCase						,					**__lowerCAmelCase		)
         if text is not None:
                _lowerCamelCase						:				int    			= self.tokenizer(__lowerCAmelCase						,					**__lowerCAmelCase		)

         if text is None:
                return inputs
         elif audio is None:
                return encodings
         else:
                _lowerCamelCase						:				List[str]    			= encodings['''input_ids''']
                return inputs




  def 						SCREAMING_SNAKE_CASE				( self     :						Optional[int]						,					*__lowerCAmelCase     :						int						,					**__lowerCAmelCase     :						int		):






         """simple docstring"""






         if self._in_target_context_manager:
                return self.current_processor.pad(*__lowerCAmelCase						,					**__lowerCAmelCase		)

         _lowerCamelCase						:				Union[str, Any]    			= kwargs.pop('''input_features'''						,					__lowerCAmelCase		)
         _lowerCamelCase						:				Optional[Any]    			= kwargs.pop('''labels'''						,					__lowerCAmelCase		)
         if len(__lowerCAmelCase		) > 0:
                _lowerCamelCase						:				Any    			= args[0]
                _lowerCamelCase						:				int    			= args[1:]

         if input_features is not None:
                _lowerCamelCase						:				Optional[Any]    			= self.feature_extractor.pad(__lowerCAmelCase						,					*__lowerCAmelCase						,					**__lowerCAmelCase		)
         if labels is not None:
                _lowerCamelCase						:				str    			= self.tokenizer.pad(__lowerCAmelCase						,					**__lowerCAmelCase		)

         if labels is None:
                return input_features
         elif input_features is None:
                return labels
         else:
                _lowerCamelCase						:				Union[str, Any]    			= labels['''input_ids''']
                return input_features




  def 						SCREAMING_SNAKE_CASE				( self     :						Union[str, Any]						,					*__lowerCAmelCase     :						Union[str, Any]						,					**__lowerCAmelCase     :						List[Any]		):






         """simple docstring"""






         return self.tokenizer.batch_decode(*__lowerCAmelCase						,					**__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE				( self     :						List[str]						,					*__lowerCAmelCase     :						Tuple						,					**__lowerCAmelCase     :						Dict		):






         """simple docstring"""






         return self.tokenizer.decode(*__lowerCAmelCase						,					**__lowerCAmelCase		)




  @contextmanager
  def 						SCREAMING_SNAKE_CASE				( self     :						Optional[Any]		):






         """simple docstring"""






         warnings.warn(
             '''`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '''
             '''labels by using the argument `text` of the regular `__call__` method (either in the same call as '''
             '''your audio inputs, or in a separate call.'''		)
         _lowerCamelCase						:				int    			= True
         _lowerCamelCase						:				str    			= self.tokenizer
         yield
         _lowerCamelCase						:				Dict    			= self.feature_extractor
         _lowerCamelCase						:				int    			= False



def    a__       (						__UpperCamelCase ):
      if n == 1 or not isinstance(__UpperCamelCase   ,					__UpperCamelCase ):
            return 0
      elif n == 2:
            return 1
      else:
            SCREAMING_SNAKE_CASE_      =     [0, 1]
            for i in range(2   ,					n + 1 ):
                  sequence.append(sequence[i - 1] + sequence[i - 2] )

            return sequence[n]


def    a__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     0
      SCREAMING_SNAKE_CASE_      =     2

      while digits < n:
            index += 1
            SCREAMING_SNAKE_CASE_      =     len(str(fibonacci(__UpperCamelCase ) ) )

      return index


def    a__       (						__UpperCamelCase = 1_0_0_0 ):
      return fibonacci_digits_index(__UpperCamelCase )


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


