



'''simple docstring'''







from typing import List, Optional, Union

import numpy as np
import torch
import torchaudio.compliance.kaldi as ta_kaldi

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


SCREAMING_SNAKE_CASE__     : str				=   logging.get_logger(__name__)




class 				__lowerCAmelCase(							lowerCAmelCase__      ):
			__snake_case  :		str		=      ['input_values', 'attention_mask']






			def __init__(   self  :							List[str]      ,       SCREAMING_SNAKE_CASE  :							List[str]=1      ,       SCREAMING_SNAKE_CASE  :							Dict=16_000      ,       SCREAMING_SNAKE_CASE  :							Tuple=128      ,       SCREAMING_SNAKE_CASE  :							List[str]=1_024      ,       SCREAMING_SNAKE_CASE  :							int=0.0      ,       SCREAMING_SNAKE_CASE  :							Optional[int]=True      ,       SCREAMING_SNAKE_CASE  :							Optional[Any]=-4.2_67_73_93      ,       SCREAMING_SNAKE_CASE  :							Dict=4.5_68_99_74      ,       SCREAMING_SNAKE_CASE  :							Optional[Any]=False      ,       **SCREAMING_SNAKE_CASE  :							str      ,       ):




					"""simple docstring"""







					super().__init__(feature_size=SCREAMING_SNAKE_CASE      ,       sampling_rate=SCREAMING_SNAKE_CASE      ,       padding_value=SCREAMING_SNAKE_CASE      ,       **SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      num_mel_bins
					SCREAMING_SNAKE_CASE_						:str										=      max_length
					SCREAMING_SNAKE_CASE_						:int										=      do_normalize
					SCREAMING_SNAKE_CASE_						:Any										=      mean
					SCREAMING_SNAKE_CASE_						:Tuple										=      std
					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      return_attention_mask






			def 				_lowercase	(   self  :							Tuple      ,       SCREAMING_SNAKE_CASE  :							np.ndarray      ,       SCREAMING_SNAKE_CASE  :							int      ,       ):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Any										=      torch.from_numpy(SCREAMING_SNAKE_CASE	).unsqueeze(0	)
					SCREAMING_SNAKE_CASE_						:Any										=      ta_kaldi.fbank(
					    SCREAMING_SNAKE_CASE      ,       htk_compat=SCREAMING_SNAKE_CASE      ,       sample_frequency=self.sampling_rate      ,       use_energy=SCREAMING_SNAKE_CASE      ,       window_type='hanning'      ,       num_mel_bins=self.num_mel_bins      ,       dither=0.0      ,       frame_shift=10      ,       )

					SCREAMING_SNAKE_CASE_						:Dict										=      fbank.shape[0]
					SCREAMING_SNAKE_CASE_						:Any										=      max_length - n_frames

					# pad or truncate, depending on difference
					if difference > 0:
							SCREAMING_SNAKE_CASE_						:List[str]										=      torch.nn.ZeroPadad((0, 0, 0, difference)	)
							SCREAMING_SNAKE_CASE_						:str										=      pad_module(SCREAMING_SNAKE_CASE	)
					elif difference < 0:
							SCREAMING_SNAKE_CASE_						:Tuple										=      fbank[0:max_length, :]

					SCREAMING_SNAKE_CASE_						:List[Any]										=      fbank.numpy()

					return fbank






			def 				_lowercase	(   self  :							List[str]      ,       SCREAMING_SNAKE_CASE  :							np.ndarray	):




					"""simple docstring"""







					return (input_values - (self.mean)) / (self.std * 2)






			def __call__(   self  :							Optional[int]      ,       SCREAMING_SNAKE_CASE  :							Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]      ,       SCREAMING_SNAKE_CASE  :							Optional[int] = None      ,       SCREAMING_SNAKE_CASE  :							Optional[Union[str, TensorType]] = None      ,       **SCREAMING_SNAKE_CASE  :							List[Any]      ,       ):




					"""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 `raw_speech` 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.'	)

					SCREAMING_SNAKE_CASE_						:List[Any]										=      isinstance(SCREAMING_SNAKE_CASE      ,       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}'	)
					SCREAMING_SNAKE_CASE_						:Tuple										=      is_batched_numpy or (
					    isinstance(SCREAMING_SNAKE_CASE      ,       (list, tuple)	) and (isinstance(raw_speech[0]      ,       (np.ndarray, tuple, list)	))
					)

					if is_batched:
							SCREAMING_SNAKE_CASE_						:Optional[Any]										=      [np.asarray(SCREAMING_SNAKE_CASE      ,       dtype=np.floataa	) for speech in raw_speech]
					elif not is_batched and not isinstance(SCREAMING_SNAKE_CASE      ,       np.ndarray	):
							SCREAMING_SNAKE_CASE_						:Dict										=      np.asarray(SCREAMING_SNAKE_CASE      ,       dtype=np.floataa	)
					elif isinstance(SCREAMING_SNAKE_CASE      ,       np.ndarray	) and raw_speech.dtype is np.dtype(np.floataa	):
							SCREAMING_SNAKE_CASE_						:str										=      raw_speech.astype(np.floataa	)

					# always return batch
					if not is_batched:
							SCREAMING_SNAKE_CASE_						:Tuple										=      [raw_speech]

					# extract fbank features and pad/truncate to max_length
					SCREAMING_SNAKE_CASE_						:str										=      [self._extract_fbank_features(SCREAMING_SNAKE_CASE      ,       max_length=self.max_length	) for waveform in raw_speech]

					# convert into BatchFeature
					SCREAMING_SNAKE_CASE_						:Optional[Any]										=      BatchFeature({'input_values': features}	)

					# make sure list is in array format
					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      padded_inputs.get('input_values'	)
					if isinstance(input_values[0]      ,       SCREAMING_SNAKE_CASE	):
							SCREAMING_SNAKE_CASE_						:Tuple										=      [np.asarray(SCREAMING_SNAKE_CASE      ,       dtype=np.floataa	) for feature in input_values]

					# normalization
					if self.do_normalize:
							SCREAMING_SNAKE_CASE_						:List[str]										=      [self.normalize(SCREAMING_SNAKE_CASE	) for feature in input_values]

					if return_tensors is not None:
							SCREAMING_SNAKE_CASE_						:Tuple										=      padded_inputs.convert_to_tensors(SCREAMING_SNAKE_CASE	)

					return padded_inputs





'''simple docstring'''







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ):
		assert b != 0, "This cannot accept modulo that is == 0"
		if n == 0:
				return 1

		if n % 2 == 1:
				return (bin_exp_mod(SCREAMING_SNAKE_CASE ,		n - 1 ,		SCREAMING_SNAKE_CASE     ) * a) % b

		SCREAMING_SNAKE_CASE_						:List[str]										=      bin_exp_mod(SCREAMING_SNAKE_CASE ,		n / 2 ,		SCREAMING_SNAKE_CASE     )
		return (r * r) % b


if __name__ == "__main__":
							try:
														SCREAMING_SNAKE_CASE__     : Any				=   int(input("""Enter Base : """).strip())
														SCREAMING_SNAKE_CASE__     : str				=   int(input("""Enter Power : """).strip())
														SCREAMING_SNAKE_CASE__     : List[Any]				=   int(input("""Enter Modulo : """).strip())
							except ValueError:
														print("""Invalid literal for integer""")

							print(bin_exp_mod(BASE, POWER, MODULO))
