



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


__snake_case    :		Union[str, Any]  =logging.get_logger(__name__)



class 	lowerCamelCase__      (							lowerCamelCase__):




		'''simple docstring'''



		snake_case_     =["""input_values""", """padding_mask"""]



		def __init__(self		,__lowerCamelCase = 1		,__lowerCamelCase = 2_40_00		,__lowerCamelCase = 0.0		,__lowerCamelCase = None		,__lowerCamelCase = None		,**__lowerCamelCase		,)					->      str:

						"""simple docstring"""






						super().__init__(feature_size=__lowerCamelCase		,sampling_rate=__lowerCamelCase		,padding_value=__lowerCamelCase		,**__lowerCamelCase			)
						lowerCAmelCase__					:    List[Any]												=					chunk_length_s
						lowerCAmelCase__					:    List[Any]												=					overlap



		@property
		def 		lowerCAmelCase__				(self			)					->      Optional[int]:

						"""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			)					->      Optional[int]:

						"""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		,__lowerCamelCase		,__lowerCamelCase = None		,__lowerCamelCase = False		,__lowerCamelCase = None		,__lowerCamelCase = None		,__lowerCamelCase = None		,)					->      BatchFeature:

						"""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__					:    Any												=					True

						lowerCAmelCase__					:    Dict												=					bool(
						    isinstance(__lowerCamelCase		,(list, tuple)			) and (isinstance(raw_audio[0]		,(np.ndarray, tuple, list)			))			)

						if is_batched:
										lowerCAmelCase__					:    Any												=					[np.asarray(__lowerCamelCase		,dtype=np.floataa			).T for audio in raw_audio]
						elif not is_batched and not isinstance(__lowerCamelCase		,np.ndarray			):
										lowerCAmelCase__					:    str												=					np.asarray(__lowerCamelCase		,dtype=np.floataa			)
						elif isinstance(__lowerCamelCase		,np.ndarray			) and raw_audio.dtype is np.dtype(np.floataa			):
										lowerCAmelCase__					:    Union[str, Any]												=					raw_audio.astype(np.floataa			)

						# always return batch
						if not is_batched:
										lowerCAmelCase__					:    List[str]												=					[np.asarray(__lowerCamelCase			).T]

						# verify inputs are valid
						for idx, example in enumerate(__lowerCamelCase			):
										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__					:    Any												=					None
						lowerCAmelCase__					:    Optional[Any]												=					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__					:    str												=					min(array.shape[0] for array in raw_audio			)
														lowerCAmelCase__					:    Optional[int]												=					int(np.floor(max_length / self.chunk_stride			)			)
														lowerCAmelCase__					:    Optional[int]												=					(nb_step - 1) * self.chunk_stride + self.chunk_length
										elif padding:
														lowerCAmelCase__					:    Tuple												=					max(array.shape[0] for array in raw_audio			)
														lowerCAmelCase__					:    Optional[int]												=					int(np.ceil(max_length / self.chunk_stride			)			)
														lowerCAmelCase__					:    Optional[Any]												=					(nb_step - 1) * self.chunk_stride + self.chunk_length
														lowerCAmelCase__					:    Tuple												=					'''max_length'''
										else:
														lowerCAmelCase__					:    int												=					input_values

        # normal padding on batch
						if padded_inputs is None:
										lowerCAmelCase__					:    Any												=					self.pad(
										    __lowerCamelCase		,max_length=__lowerCamelCase		,truncation=__lowerCamelCase		,padding=__lowerCamelCase		,return_attention_mask=__lowerCamelCase		,)
										if padding:
														lowerCAmelCase__					:    Union[str, Any]												=					padded_inputs.pop('''attention_mask'''			)

						lowerCAmelCase__					:    Union[str, Any]												=					[]
						for example in padded_inputs.pop('''input_values'''			):
										if self.feature_size == 1:
														lowerCAmelCase__					:    Tuple												=					example[..., None]
										input_values.append(example.T			)

						lowerCAmelCase__					:    str												=					input_values
						if return_tensors is not None:
										lowerCAmelCase__					:    str												=					padded_inputs.convert_to_tensors(__lowerCamelCase			)

						return padded_inputs






from math import factorial






def      lowerCAmelCase__		(   lowerCamelCase_		:		int = 100):





				'''simple docstring'''

				return sum(map(lowerCamelCase_	,str(factorial(lowerCamelCase_))))


if __name__ == "__main__":
							print(solution(int(input('Enter the Number: ').strip())))

