
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
from .tokenization_wavaveca import WavaVecaCTCTokenizer




class 					_SCREAMING_SNAKE_CASE  (      __UpperCamelCase ):
      _A						:		str    	=     'Wav2Vec2FeatureExtractor'
      _A						:		List[str]    	=     'AutoTokenizer'
      def __init__(			self		,	lowerCamelCase		,	lowerCamelCase ):
          super().__init__(lowerCamelCase		,	lowerCamelCase )
          snake_case__						=				self.feature_extractor
          snake_case__						=				False
      @classmethod
      def A_			(			cls		,	lowerCamelCase		,	**lowerCamelCase ):
          try:
              return super().from_pretrained(lowerCamelCase		,	**lowerCamelCase )
          except OSError:
              warnings.warn(
                  F"""Loading a tokenizer inside {cls.__name__} from a config that does not"""
                  " include a `tokenizer_class` attribute is deprecated and will be "
                  "removed in v5. Please add `'tokenizer_class': 'Wav2Vec2CTCTokenizer'`"
                  " attribute to either your `config.json` or `tokenizer_config.json` "
                  "file to suppress this warning: "		,	lowerCamelCase		,	)

              snake_case__						=				WavaVecaFeatureExtractor.from_pretrained(lowerCamelCase		,	**lowerCamelCase )
              snake_case__						=				WavaVecaCTCTokenizer.from_pretrained(lowerCamelCase		,	**lowerCamelCase )

              return cls(feature_extractor=lowerCamelCase		,	tokenizer=lowerCamelCase )
      def __call__(			self		,	*lowerCamelCase		,	**lowerCamelCase ):
          # For backward compatibility
          if self._in_target_context_manager:
              return self.current_processor(*lowerCamelCase		,	**lowerCamelCase )

          if "raw_speech" in kwargs:
              warnings.warn("Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead." )
              snake_case__						=				kwargs.pop("raw_speech" )
          else:
              snake_case__						=				kwargs.pop("audio"		,	lowerCamelCase )
          snake_case__						=				kwargs.pop("sampling_rate"		,	lowerCamelCase )
          snake_case__						=				kwargs.pop("text"		,	lowerCamelCase )
          if len(lowerCamelCase ) > 0:
              snake_case__						=				args[0]
              snake_case__						=				args[1:]

          if audio is None and text is None:
              raise ValueError("You need to specify either an `audio` or `text` input to process." )

          if audio is not None:
              snake_case__						=				self.feature_extractor(lowerCamelCase		,	*lowerCamelCase		,	sampling_rate=lowerCamelCase		,	**lowerCamelCase )
          if text is not None:
              snake_case__						=				self.tokenizer(lowerCamelCase		,	**lowerCamelCase )

          if text is None:
              return inputs
          elif audio is None:
              return encodings
          else:
              snake_case__						=				encodings["input_ids"]
              return inputs
      def A_			(			self		,	*lowerCamelCase		,	**lowerCamelCase ):
          # For backward compatibility
          if self._in_target_context_manager:
              return self.current_processor.pad(*lowerCamelCase		,	**lowerCamelCase )

          snake_case__						=				kwargs.pop("input_features"		,	lowerCamelCase )
          snake_case__						=				kwargs.pop("labels"		,	lowerCamelCase )
          if len(lowerCamelCase ) > 0:
              snake_case__						=				args[0]
              snake_case__						=				args[1:]

          if input_features is not None:
              snake_case__						=				self.feature_extractor.pad(lowerCamelCase		,	*lowerCamelCase		,	**lowerCamelCase )
          if labels is not None:
              snake_case__						=				self.tokenizer.pad(lowerCamelCase		,	**lowerCamelCase )

          if labels is None:
              return input_features
          elif input_features is None:
              return labels
          else:
              snake_case__						=				labels["input_ids"]
              return input_features
      def A_			(			self		,	*lowerCamelCase		,	**lowerCamelCase ):
          return self.tokenizer.batch_decode(*lowerCamelCase		,	**lowerCamelCase )
      def A_			(			self		,	*lowerCamelCase		,	**lowerCamelCase ):
          return self.tokenizer.decode(*lowerCamelCase		,	**lowerCamelCase )



      @contextmanager
      def A_			(			self ):
          warnings.warn(
              "`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your "
              "labels by using the argument `text` of the regular `__call__` method (either in the same call as "
              "your audio inputs, or in a separate call." )
          snake_case__						=				True
          snake_case__						=				self.tokenizer
          yield
          snake_case__						=				self.feature_extractor
          snake_case__						=				False





from math import factorial





def 	SCREAMING_SNAKE_CASE__    (      __lowerCAmelCase = 100							):
    return sum(int(__lowerCAmelCase							) for x in str(factorial(__lowerCAmelCase							)							)							)


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



