




"""simple docstring"""




from typing import List, Optional, Union

import numpy as np

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


lowerCAmelCase				:     Optional[int]					=				logging.get_logger(__name__)






class        __magic_name__				(			UpperCAmelCase__							):






				'''simple docstring'''
				__UpperCamelCase         =		["input_values", "padding_mask"]





				def __init__(			self						,					_a = 1						,					_a = 24_000						,					_a = 0.0						,					_a = None						,					_a = None						,					**_a						,					):





							"""simple docstring"""
							super().__init__(feature_size=_a						,					sampling_rate=_a						,					padding_value=_a						,					**_a					)
							lowerCamelCase      =   chunk_length_s
							lowerCamelCase      =   overlap





				@property
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							if self.chunk_length_s is None:
										return None
							else:
										return int(self.chunk_length_s * self.sampling_rate					)





				@property
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							if self.chunk_length_s is None or self.overlap is None:
										return None
							else:
										return max(1						,					int((1.0 - self.overlap) * self.chunk_length					)					)





				def __call__(			self						,					_a						,					_a = None						,					_a = False						,					_a = None						,					_a = None						,					_a = None						,					):





							"""simple docstring"""
							if sampling_rate is not None:
										if sampling_rate != self.sampling_rate:
													raise ValueError(
													    f'The model corresponding to this feature extractor: {self} was trained using a sampling rate of'
													    f' {self.sampling_rate}. Please make sure that the provided audio input was sampled with'
													    f' {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."""					)

							if padding and truncation:
										raise ValueError("""Both padding and truncation were set. Make sure you only set one."""					)
							elif padding is None:
										# by default let's pad the inputs
										lowerCamelCase      =   True

							lowerCamelCase      =   bool(
							    isinstance(_a						,					(list, tuple)					) and (isinstance(raw_audio[0]						,					(np.ndarray, tuple, list)					))					)

							if is_batched:
										lowerCamelCase      =   [np.asarray(_a						,					dtype=np.floataa					).T for audio in raw_audio]
							elif not is_batched and not isinstance(_a						,					np.ndarray					):
										lowerCamelCase      =   np.asarray(_a						,					dtype=np.floataa					)
							elif isinstance(_a						,					np.ndarray					) and raw_audio.dtype is np.dtype(np.floataa					):
										lowerCamelCase      =   raw_audio.astype(np.floataa					)

							# always return batch
							if not is_batched:
										lowerCamelCase      =   [np.asarray(_a					).T]

							# verify inputs are valid
							for idx, example in enumerate(_a					):
										if example.ndim > 2:
													raise ValueError(f'Expected input shape (channels, length) but got shape {example.shape}'					)
										if self.feature_size == 1 and example.ndim != 1:
													raise ValueError(f'Expected mono audio but example has {example.shape[-1]} channels'					)
										if self.feature_size == 2 and example.shape[-1] != 2:
													raise ValueError(f'Expected stereo audio but example has {example.shape[-1]} channels'					)

							lowerCamelCase      =   None
							lowerCamelCase      =   BatchFeature({"""input_values""": raw_audio}					)
							if self.chunk_stride is not None and self.chunk_length is not None and max_length is None:
										if truncation:
													lowerCamelCase      =   min(array.shape[0] for array in raw_audio					)
													lowerCamelCase      =   int(np.floor(max_length / self.chunk_stride					)					)
													lowerCamelCase      =   (nb_step - 1) * self.chunk_stride + self.chunk_length
										elif padding:
													lowerCamelCase      =   max(array.shape[0] for array in raw_audio					)
													lowerCamelCase      =   int(np.ceil(max_length / self.chunk_stride					)					)
													lowerCamelCase      =   (nb_step - 1) * self.chunk_stride + self.chunk_length
													lowerCamelCase      =   """max_length"""
										else:
													lowerCamelCase      =   input_values

        # normal padding on batch
							if padded_inputs is None:
										lowerCamelCase      =   self.pad(
										    _a						,					max_length=_a						,					truncation=_a						,					padding=_a						,					return_attention_mask=_a						,					)
										if padding:
													lowerCamelCase      =   padded_inputs.pop("""attention_mask"""					)

							lowerCamelCase      =   []
							for example in padded_inputs.pop("""input_values"""					):
										if self.feature_size == 1:
													lowerCamelCase      =   example[..., None]
										input_values.append(example.T					)

							lowerCamelCase      =   input_values
							if return_tensors is not None:
										lowerCamelCase      =   padded_inputs.convert_to_tensors(_a					)

							return padded_inputs









"""simple docstring"""




def        a__					(							snake_case__ = 10_00							)		->   int:
			lowerCamelCase ,  lowerCamelCase      =   1, 1
			lowerCamelCase      =   2
			while True:
						lowerCamelCase      =   0
						lowerCamelCase      =   fa + fa
						lowerCamelCase ,  lowerCamelCase      =   fa, f
						index += 1
						for _ in str(snake_case__							):
									i += 1
						if i == n:
									break
			return index


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



