'''simple docstring'''

from ctypes import c_float, sizeof
from enum import Enum
from typing import TYPE_CHECKING, Optional, Union


if TYPE_CHECKING:
       from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore





class 				lowercase    (    snake_case__			):
   lowerCamelCase_            =c_float


   @property
   def __UpperCAmelCase							( self					:						Any)   ->       str:
         return sizeof(self.value)




def __a			(						__lowerCamelCase      :    List[str]			,		__lowerCamelCase      :    List[str]			,		__lowerCamelCase      :    str = 0					)						->				Dict:
      '''simple docstring'''


      if dimension <= 0:
            lowercase_     			=   fixed_dimension

      dimension -= num_token_to_add
      return dimension


def __a			(						__lowerCamelCase      :    Dict			,		__lowerCamelCase      :    List[str]					)						->				Optional[int]:
      '''simple docstring'''


      return num_parameters * dtype.size






def __a			(						__lowerCamelCase      :    str					)						->				int:
      '''simple docstring'''


      from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore

      try:
            return AutoProcessor.from_pretrained(__SCREAMING_SNAKE_CASE					)
      except (ValueError, OSError, KeyError):
            lowercase_     			=   None, None
            try:
                  lowercase_     			=   AutoTokenizer.from_pretrained(__SCREAMING_SNAKE_CASE					)
            except (OSError, KeyError):
                  pass
            try:
                  lowercase_     			=   AutoFeatureExtractor.from_pretrained(__SCREAMING_SNAKE_CASE					)
            except (OSError, KeyError):
                  pass

            if tokenizer is not None and feature_extractor is not None:
                  raise ValueError(
                      f'Couldn\'t auto-detect preprocessor for {model_name}. Found both a tokenizer and a feature extractor.'					)
            elif tokenizer is None and feature_extractor is None:
                  return None
            elif tokenizer is not None:
                  return tokenizer
            else:
                  return feature_extractor








'''simple docstring'''
def     UpperCamelCase_  (						__SCREAMING_SNAKE_CASE							):
    """simple docstring"""






    if number != int(__SCREAMING_SNAKE_CASE							):
        raise ValueError("factorial() only accepts integral values"							)
    if number < 0:
        raise ValueError("factorial() not defined for negative values"							)
    snake_case_			:     int        =    1
    for i in range(1,		number + 1							):
        value *= i
    return value

def     UpperCamelCase_  (						__SCREAMING_SNAKE_CASE							):
    """simple docstring"""






    if not isinstance(__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							):
        raise ValueError("factorial() only accepts integral values"							)
    if n < 0:
        raise ValueError("factorial() not defined for negative values"							)
    return 1 if n == 0 or n == 1 else n * factorial(n - 1							)


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  a_           =    int(input("Enter a positive integer: ").strip() or 0)
  print(f"""factorial{n} is {factorial(n)}""")




