

"""simple docstring"""


import warnings
from typing import Any, Dict, List, Optional, Union

import numpy as np

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


__A						   =			logging.get_logger(__name__)





class     snake_case	(				lowerCamelCase_  ):
				SCREAMING_SNAKE_CASE_   :      str         =  ["""input_values""", """attention_mask"""]

				def __init__(	self							:				Optional[int]     ,  UpperCamelCase__							:				List[Any] = 1     ,  UpperCamelCase__							:				Tuple = 1_6_0_0_0     ,  UpperCamelCase__							:				Any = 0.0     ,  UpperCamelCase__							:				Tuple = False     ,  UpperCamelCase__							:				Optional[Any] = 8_0     ,  UpperCamelCase__							:				Dict = 1_6     ,  UpperCamelCase__							:				Tuple = 6_4     ,  UpperCamelCase__							:				int = "hann_window"     ,  UpperCamelCase__							:				List[Any] = 1.0     ,  UpperCamelCase__							:				str = 8_0     ,  UpperCamelCase__							:				Optional[Any] = 7_6_0_0     ,  UpperCamelCase__							:				Union[str, Any] = 1e-10     ,  UpperCamelCase__							:				List[Any] = 2     ,  UpperCamelCase__							:				List[str] = True     ,  **UpperCamelCase__							:				int     ,  )->   Dict:



						'''simple docstring'''


						super().__init__(feature_size=lowerCAmelCase__     ,  sampling_rate=lowerCAmelCase__     ,  padding_value=lowerCAmelCase__     ,  **lowerCAmelCase__)
						__lowerCAmelCase:       Any          =			do_normalize
						__lowerCAmelCase:       Any          =			return_attention_mask

						__lowerCAmelCase:       Any          =			num_mel_bins
						__lowerCAmelCase:       Optional[Any]          =			hop_length
						__lowerCAmelCase:       List[Any]          =			win_length
						__lowerCAmelCase:       Optional[Any]          =			win_function
						__lowerCAmelCase:       Dict          =			frame_signal_scale
						__lowerCAmelCase:       List[str]          =			fmin
						__lowerCAmelCase:       Optional[int]          =			fmax
						__lowerCAmelCase:       int          =			mel_floor
						__lowerCAmelCase:       Optional[int]          =			reduction_factor

						__lowerCAmelCase:       Any          =			win_length * sampling_rate // 1_0_0_0
						__lowerCAmelCase:       Optional[Any]          =			hop_length * sampling_rate // 1_0_0_0
						__lowerCAmelCase:       str          =			optimal_fft_length(self.sample_size)
						__lowerCAmelCase:       Optional[int]          =			(self.n_fft // 2) + 1

						__lowerCAmelCase:       Any          =			window_function(window_length=self.sample_size     ,  name=self.win_function     ,  periodic=lowerCAmelCase__)

						__lowerCAmelCase:       List[str]          =			mel_filter_bank(
						    num_frequency_bins=self.n_freqs     ,  num_mel_filters=self.num_mel_bins     ,  min_frequency=self.fmin     ,  max_frequency=self.fmax     ,  sampling_rate=self.sampling_rate     ,  norm="slaney"     ,  mel_scale="slaney"     ,  )

						if frame_signal_scale != 1.0:
								warnings.warn(
								    "The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers"     ,  lowerCAmelCase__     ,  )
						if reduction_factor != 2.0:
								warnings.warn(
								    "The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers"     ,  lowerCAmelCase__     ,  )

				@staticmethod
				# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
				def 							lowercase_     (	UpperCamelCase__							:				Dict     ,  UpperCamelCase__							:				Any     ,  UpperCamelCase__							:				Optional[Any] = 0.0)->   List[np.ndarray]:



						'''simple docstring'''


						if attention_mask is not None:
								__lowerCAmelCase:       Any          =			np.array(lowerCAmelCase__     ,  np.intaa)
								__lowerCAmelCase:       Tuple          =			[]

								for vector, length in zip(lowerCAmelCase__     ,  attention_mask.sum(-1)):
										__lowerCAmelCase:       Tuple          =			(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7)
										if length < normed_slice.shape[0]:
												__lowerCAmelCase:       Optional[int]          =			padding_value

										normed_input_values.append(lowerCAmelCase__)
						else:
								__lowerCAmelCase:       Union[str, Any]          =			[(x - x.mean()) / np.sqrt(x.var() + 1e-7) for x in input_values]

						return normed_input_values

				def 							lowercase_     (	self							:				int     ,  UpperCamelCase__							:				Dict     ,  )->   np.ndarray:



						'''simple docstring'''


						__lowerCAmelCase:       Tuple          =			spectrogram(
						    lowerCAmelCase__     ,  window=self.window     ,  frame_length=self.sample_size     ,  hop_length=self.sample_stride     ,  fft_length=self.n_fft     ,  mel_filters=self.mel_filters     ,  mel_floor=self.mel_floor     ,  log_mel="log10"     ,  )
						return log_mel_spec.T

				def __call__(	self							:				Any     ,  UpperCamelCase__							:				int = None     ,  UpperCamelCase__							:				Union[str, Any] = None     ,  UpperCamelCase__							:				int = False     ,  UpperCamelCase__							:				int = None     ,  UpperCamelCase__							:				Optional[Any] = False     ,  UpperCamelCase__							:				List[Any] = None     ,  UpperCamelCase__							:				Union[str, Any] = None     ,  UpperCamelCase__							:				List[str] = None     ,  UpperCamelCase__							:				List[str] = None     ,  **UpperCamelCase__							:				int     ,  )->   BatchFeature:



						'''simple docstring'''


						if audio is None and audio_target is None:
								raise ValueError("You must provide either `audio` or `audio_target` values.")

						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 audio is not None:
								__lowerCAmelCase:       Optional[Any]          =			self._process_audio(
								    lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  **lowerCAmelCase__     ,  )
						else:
								__lowerCAmelCase:       List[str]          =			None

						if audio_target is not None:
								__lowerCAmelCase:       Union[str, Any]          =			self._process_audio(
								    lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  lowerCAmelCase__     ,  **lowerCAmelCase__     ,  )

								if inputs is None:
										return inputs_target
								else:
										__lowerCAmelCase:       Union[str, Any]          =			inputs_target["input_values"]
										__lowerCAmelCase:       List[str]          =			inputs_target.get("attention_mask")
										if decoder_attention_mask is not None:
												__lowerCAmelCase:       str          =			decoder_attention_mask

						return inputs

				def 							lowercase_     (	self							:				str     ,  UpperCamelCase__							:				Optional[Any]     ,  UpperCamelCase__							:				Union[str, Any] = False     ,  UpperCamelCase__							:				Optional[Any] = False     ,  UpperCamelCase__							:				Optional[Any] = None     ,  UpperCamelCase__							:				int = False     ,  UpperCamelCase__							:				Union[str, Any] = None     ,  UpperCamelCase__							:				Union[str, Any] = None     ,  UpperCamelCase__							:				List[str] = None     ,  **UpperCamelCase__							:				List[str]     ,  )->   BatchFeature:



						'''simple docstring'''


						__lowerCAmelCase:       str          =			isinstance(lowerCAmelCase__     ,  np.ndarray) and len(speech.shape) > 1
						if is_batched_numpy and len(speech.shape) > 2:
								raise ValueError(f"Only mono-channel audio is supported for input to {self}")
						__lowerCAmelCase:       Optional[Any]          =			is_batched_numpy or (
						    isinstance(lowerCAmelCase__     ,  (list, tuple)) and (isinstance(speech[0]     ,  (np.ndarray, tuple, list)))
						)

						if is_batched:
								__lowerCAmelCase:       Union[str, Any]          =			[np.asarray(lowerCAmelCase__     ,  dtype=np.floataa) for speech in speech]
						elif not is_batched and not isinstance(lowerCAmelCase__     ,  np.ndarray):
								__lowerCAmelCase:       List[Any]          =			np.asarray(lowerCAmelCase__     ,  dtype=np.floataa)
						elif isinstance(lowerCAmelCase__     ,  np.ndarray) and speech.dtype is np.dtype(np.floataa):
								__lowerCAmelCase:       Tuple          =			speech.astype(np.floataa)

						# always return batch
						if not is_batched:
								__lowerCAmelCase:       str          =			[speech]

						# needed to make pad() work on spectrogram inputs
						__lowerCAmelCase:       Optional[Any]          =			self.feature_size

						# convert into correct format for padding
						if is_target:
								__lowerCAmelCase:       Tuple          =			[self._extract_mel_features(lowerCAmelCase__) for waveform in speech]
								__lowerCAmelCase:       Any          =			BatchFeature({"input_values": features})
								__lowerCAmelCase:       Optional[int]          =			self.num_mel_bins
						else:
								__lowerCAmelCase:       Union[str, Any]          =			BatchFeature({"input_values": speech})

						__lowerCAmelCase:       Union[str, Any]          =			self.pad(
						    lowerCAmelCase__     ,  padding=lowerCAmelCase__     ,  max_length=lowerCAmelCase__     ,  truncation=lowerCAmelCase__     ,  pad_to_multiple_of=lowerCAmelCase__     ,  return_attention_mask=lowerCAmelCase__     ,  **lowerCAmelCase__     ,  )

						__lowerCAmelCase:       int          =			feature_size_hack

						# convert input values to correct format
						__lowerCAmelCase:       List[str]          =			padded_inputs["input_values"]
						if not isinstance(input_values[0]     ,  np.ndarray):
								__lowerCAmelCase:       Union[str, Any]          =			[np.asarray(lowerCAmelCase__     ,  dtype=np.floataa) for array in input_values]
						elif (
						    not isinstance(lowerCAmelCase__     ,  np.ndarray)
						    and isinstance(input_values[0]     ,  np.ndarray)
						    and input_values[0].dtype is np.dtype(np.floataa)
						):
								__lowerCAmelCase:       Union[str, Any]          =			[array.astype(np.floataa) for array in input_values]
						elif isinstance(lowerCAmelCase__     ,  np.ndarray) and input_values.dtype is np.dtype(np.floataa):
								__lowerCAmelCase:       List[str]          =			input_values.astype(np.floataa)

						# convert attention_mask to correct format
						__lowerCAmelCase:       Optional[int]          =			padded_inputs.get("attention_mask")
						if attention_mask is not None:
								__lowerCAmelCase:       int          =			[np.asarray(lowerCAmelCase__     ,  dtype=np.intaa) for array in attention_mask]

						# zero-mean and unit-variance normalization
						if not is_target and self.do_normalize:
								__lowerCAmelCase:       int          =			(
								    attention_mask
								    if self._get_padding_strategies(lowerCAmelCase__     ,  max_length=lowerCAmelCase__) is not PaddingStrategy.DO_NOT_PAD
								    else None
								)
								__lowerCAmelCase:       Dict          =			self.zero_mean_unit_var_norm(
								    padded_inputs["input_values"]     ,  attention_mask=lowerCAmelCase__     ,  padding_value=self.padding_value)

						if return_tensors is not None:
								__lowerCAmelCase:       List[Any]          =			padded_inputs.convert_to_tensors(lowerCAmelCase__)

						return padded_inputs




				def 							lowercase_     (	self							:				List[Any])->   Dict[str, Any]:



						'''simple docstring'''


						__lowerCAmelCase:       Dict          =			super().to_dict()

						# Don't serialize these as they are derived from the other properties.
						__lowerCAmelCase:       Any          =			["window", "mel_filters", "sample_size", "sample_stride", "n_fft", "n_freqs"]
						for name in names:
								if name in output:
										del output[name]

						return output






"""simple docstring"""




def     lowercase			(SCREAMING_SNAKE_CASE_		:				int = 10_00  )   ->						int:
						SCREAMING_SNAKE_CASE													=					2**power
						SCREAMING_SNAKE_CASE													=					0
						while n:
												SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					r + n % 10, n // 10
						return r


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


