






from math import ceil
from typing import List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import BatchFeature, SequenceFeatureExtractor
from ...utils import TensorType, logging


a__       =     logging.get_logger(__name__)


class    _lowerCAmelCase			(		lowercase_      ):



				"""simple docstring"""



				_lowercase				:   Optional[int]      =					['''audio_values''', '''audio_mask''']



				def __init__(      self    :    int			,		UpperCamelCase__    :    Optional[Any]=2_0_4_8			,		UpperCamelCase__    :    Dict=1			,		UpperCamelCase__    :    str=[1_6, 1_6]			,		UpperCamelCase__    :    str=1_2_8			,		UpperCamelCase__    :    Union[str, Any]=4_4_1_0_0			,		UpperCamelCase__    :    Dict=8_6			,		UpperCamelCase__    :    Any=2_0_4_8			,		UpperCamelCase__    :    List[str]=0.0			,		**UpperCamelCase__    :    Tuple			,		):






											'''simple docstring'''







											super().__init__(
											    feature_size=UpperCamelCase__			,		sampling_rate=UpperCamelCase__			,		padding_value=UpperCamelCase__			,		**UpperCamelCase__			,		)

											snake_case__	  =       spectrogram_length
											snake_case__	  =       num_channels
											snake_case__	  =       patch_size
											snake_case__	  =       feature_size // self.patch_size[1]
											snake_case__	  =       n_fft
											snake_case__	  =       sampling_rate // hop_length_to_sampling_rate
											snake_case__	  =       sampling_rate
											snake_case__	  =       padding_value
											snake_case__	  =       mel_filter_bank(
											    num_frequency_bins=1 + n_fft // 2			,		num_mel_filters=UpperCamelCase__			,		min_frequency=0.0			,		max_frequency=2_2_0_5_0.0			,		sampling_rate=UpperCamelCase__			,		norm="""slaney"""			,		mel_scale="""slaney"""			,		).T



				def 					__magic_name__							(      self    :    Any			,		UpperCamelCase__    :    np.array):






											'''simple docstring'''







											snake_case__	  =       spectrogram(
											    UpperCamelCase__			,		window_function(self.n_fft			,		"""hann""")			,		frame_length=self.n_fft			,		hop_length=self.hop_length			,		power=2.0			,		mel_filters=self.mel_filters.T			,		log_mel="""dB"""			,		db_range=80.0			,		)
											snake_case__	  =       log_spec[:, :-1]
											snake_case__	  =       log_spec - 20.0
											snake_case__	  =       np.clip(log_spec / 40.0			,		-2.0			,		0.0) + 1.0
											return log_spec



				def __call__(      self    :    Dict			,		UpperCamelCase__    :    Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]			,		UpperCamelCase__    :    Optional[Union[str, TensorType]] = None			,		UpperCamelCase__    :    Optional[bool] = True			,		UpperCamelCase__    :    Optional[int] = None			,		UpperCamelCase__    :    bool = False			,		UpperCamelCase__    :    bool = False			,		**UpperCamelCase__    :    Optional[int]			,		):






											'''simple docstring'''







											if sampling_rate is not None:
																		if sampling_rate != self.sampling_rate:
																									raise ValueError(
																									    """This feature extractor is set to support sampling rate"""
																									    F''' of {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled'''
																									    F''' with {self.sampling_rate} and not {sampling_rate}.''')
											else:
																		logger.warning(
																		    """It is strongly recommended to pass the `sampling_rate` argument to this function. """
																		    """Failing to do so can result in silent errors that might be hard to debug.""")

											snake_case__	  =       isinstance(UpperCamelCase__			,		np.ndarray) and len(raw_speech.shape) > 1
											if is_batched_numpy and len(raw_speech.shape) > 2:
																		raise ValueError(F'''Only mono-channel audio is supported for input to {self}''')
											snake_case__	  =       is_batched_numpy or (
											    isinstance(UpperCamelCase__			,		(list, tuple)) and (isinstance(raw_speech[0]			,		(np.ndarray, tuple, list)))
											)
											if is_batched:
																		snake_case__	  =       [np.asarray([speech]			,		dtype=np.floataa).T for speech in raw_speech]
											elif not is_batched and not isinstance(UpperCamelCase__			,		np.ndarray):
																		snake_case__	  =       np.asarray(UpperCamelCase__			,		dtype=np.floataa)
											elif isinstance(UpperCamelCase__			,		np.ndarray) and raw_speech.dtype is np.dtype(np.floataa):
																		snake_case__	  =       raw_speech.astype(np.floataa)
											# always return batch
											if not is_batched:
																		snake_case__	  =       [np.asarray([raw_speech]).T]

											# Convert audio signals to log mel spectrograms, truncate by time axis
											snake_case__	  =       [
											    self._np_extract_fbank_features(waveform.squeeze()).T[: self.spectrogram_length] for waveform in raw_speech
											]
											if isinstance(audio_features[0]			,		UpperCamelCase__):
																		snake_case__	  =       [np.asarray(UpperCamelCase__			,		dtype=np.floataa) for feature in audio_features]

											# Create audio attention mask
											snake_case__	  =       max(
											    [ceil(feature.shape[0] / self.patch_size[0]) * self.freq_len for feature in audio_features])  # The maximum number of audio patches in a batch
											if return_attention_mask:
																		snake_case__	  =       [
																		    (ceil(feature.shape[0] / self.patch_size[0]) * self.freq_len) * [1]
																		    + (max_patch_len - ceil(feature.shape[0] / self.patch_size[0]) * self.freq_len) * [0]
																		    for feature in audio_features
																		]
																		snake_case__	  =       np.array(UpperCamelCase__).astype(np.floataa)

											# convert into correct format for padding
											snake_case__	  =       max_patch_len // self.freq_len * self.patch_size[0]  # The maximum audio size in a batch
											snake_case__	  =       np.ones([len(UpperCamelCase__), 1, max_time_len, self.feature_size]).astype(np.floataa)
											snake_case__	  =       padded_audio_features * self.padding_value
											for i in range(len(UpperCamelCase__)):
																		snake_case__	  =       audio_features[i]
																		snake_case__	  =       feature

											# return as BatchFeature
											if return_attention_mask:
																		snake_case__	  =       {"""audio_values""": padded_audio_features, """audio_mask""": audio_mask}
											else:
																		snake_case__	  =       {"""audio_values""": padded_audio_features}

											snake_case__	  =       BatchFeature(data=UpperCamelCase__			,		tensor_type=UpperCamelCase__)
											return encoded_inputs








def _UpperCAmelCase   (	a						:	int = 1000 ):
							snake_case__  , snake_case__	  =       1, 1
							snake_case__	  =       2
							while True:
														snake_case__	  =       0
														snake_case__	  =       fa + fa
														snake_case__  , snake_case__	  =       fa, f
														index += 1
														for _ in str(a ):
																					i += 1
														if i == n:
																					break
							return index


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