


from ..utils import DummyObject, requires_backends
class  SCREAMING_SNAKE_CASE__  (				metaclass=lowercase__			):
      snake_case__				:     List[str]        =						['''torch''', '''transformers''', '''onnx''']
      def __init__(       self				:       List[Any]     ,							*SCREAMING_SNAKE_CASE__				:       Union[str, Any]     ,							**SCREAMING_SNAKE_CASE__				:       Tuple     )		->			Union[str, Any]:
             requires_backends(self     ,							['torch', 'transformers', 'onnx']     )
      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       List[str]     ,							*SCREAMING_SNAKE_CASE__				:       Optional[Any]     ,							**SCREAMING_SNAKE_CASE__				:       Union[str, Any]     )		->			Union[str, Any]:
             requires_backends(cls     ,							['torch', 'transformers', 'onnx']     )

      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       str     ,							*SCREAMING_SNAKE_CASE__				:       int     ,							**SCREAMING_SNAKE_CASE__				:       str     )		->			Any:
             requires_backends(cls     ,							['torch', 'transformers', 'onnx']     )
class  SCREAMING_SNAKE_CASE__  (				metaclass=lowercase__			):
      snake_case__				:     Union[str, Any]        =						['''torch''', '''transformers''', '''onnx''']
      def __init__(       self				:       str     ,							*SCREAMING_SNAKE_CASE__				:       str     ,							**SCREAMING_SNAKE_CASE__				:       Any     )		->			Optional[int]:
             requires_backends(self     ,							['torch', 'transformers', 'onnx']     )
      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       List[Any]     ,							*SCREAMING_SNAKE_CASE__				:       Tuple     ,							**SCREAMING_SNAKE_CASE__				:       List[Any]     )		->			Tuple:
             requires_backends(cls     ,							['torch', 'transformers', 'onnx']     )

      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       List[Any]     ,							*SCREAMING_SNAKE_CASE__				:       str     ,							**SCREAMING_SNAKE_CASE__				:       List[str]     )		->			Tuple:
             requires_backends(cls     ,							['torch', 'transformers', 'onnx']     )
class  SCREAMING_SNAKE_CASE__  (				metaclass=lowercase__			):
      snake_case__				:     Union[str, Any]        =						['''torch''', '''transformers''', '''onnx''']
      def __init__(       self				:       Dict     ,							*SCREAMING_SNAKE_CASE__				:       Optional[Any]     ,							**SCREAMING_SNAKE_CASE__				:       Any     )		->			Tuple:
             requires_backends(self     ,							['torch', 'transformers', 'onnx']     )
      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       Tuple     ,							*SCREAMING_SNAKE_CASE__				:       Optional[int]     ,							**SCREAMING_SNAKE_CASE__				:       Union[str, Any]     )		->			Any:
             requires_backends(cls     ,							['torch', 'transformers', 'onnx']     )

      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       int     ,							*SCREAMING_SNAKE_CASE__				:       List[str]     ,							**SCREAMING_SNAKE_CASE__				:       Optional[int]     )		->			List[Any]:
             requires_backends(cls     ,							['torch', 'transformers', 'onnx']     )
class  SCREAMING_SNAKE_CASE__  (				metaclass=lowercase__			):
      snake_case__				:     Tuple        =						['''torch''', '''transformers''', '''onnx''']
      def __init__(       self				:       List[str]     ,							*SCREAMING_SNAKE_CASE__				:       List[Any]     ,							**SCREAMING_SNAKE_CASE__				:       Optional[int]     )		->			Dict:
             requires_backends(self     ,							['torch', 'transformers', 'onnx']     )
      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       int     ,							*SCREAMING_SNAKE_CASE__				:       Optional[Any]     ,							**SCREAMING_SNAKE_CASE__				:       Optional[Any]     )		->			int:
             requires_backends(cls     ,							['torch', 'transformers', 'onnx']     )

      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       Dict     ,							*SCREAMING_SNAKE_CASE__				:       int     ,							**SCREAMING_SNAKE_CASE__				:       Optional[Any]     )		->			Union[str, Any]:
             requires_backends(cls     ,							['torch', 'transformers', 'onnx']     )
class  SCREAMING_SNAKE_CASE__  (				metaclass=lowercase__			):
      snake_case__				:     str        =						['''torch''', '''transformers''', '''onnx''']
      def __init__(       self				:       Union[str, Any]     ,							*SCREAMING_SNAKE_CASE__				:       int     ,							**SCREAMING_SNAKE_CASE__				:       Optional[int]     )		->			str:
             requires_backends(self     ,							['torch', 'transformers', 'onnx']     )
      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       Optional[Any]     ,							*SCREAMING_SNAKE_CASE__				:       List[str]     ,							**SCREAMING_SNAKE_CASE__				:       Dict     )		->			int:
             requires_backends(cls     ,							['torch', 'transformers', 'onnx']     )

      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       Optional[Any]     ,							*SCREAMING_SNAKE_CASE__				:       Any     ,							**SCREAMING_SNAKE_CASE__				:       Any     )		->			Any:
             requires_backends(cls     ,							['torch', 'transformers', 'onnx']     )
class  SCREAMING_SNAKE_CASE__  (				metaclass=lowercase__			):
      snake_case__				:     Union[str, Any]        =						['''torch''', '''transformers''', '''onnx''']
      def __init__(       self				:       List[str]     ,							*SCREAMING_SNAKE_CASE__				:       Tuple     ,							**SCREAMING_SNAKE_CASE__				:       Tuple     )		->			List[Any]:
             requires_backends(self     ,							['torch', 'transformers', 'onnx']     )
      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       Tuple     ,							*SCREAMING_SNAKE_CASE__				:       List[str]     ,							**SCREAMING_SNAKE_CASE__				:       Optional[Any]     )		->			Any:
             requires_backends(cls     ,							['torch', 'transformers', 'onnx']     )

      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       List[str]     ,							*SCREAMING_SNAKE_CASE__				:       Optional[Any]     ,							**SCREAMING_SNAKE_CASE__				:       Tuple     )		->			Dict:
             requires_backends(cls     ,							['torch', 'transformers', 'onnx']     )






UpperCAmelCase_      : Optional[int]  					=       [4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
UpperCAmelCase_      : str  					=       [3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
UpperCAmelCase_      : str  					=       {
    0: 'Sunday',
    1: 'Monday',
    2: 'Tuesday',
    3: 'Wednesday',
    4: 'Thursday',
    5: 'Friday',
    6: 'Saturday',
}







def        SCREAMING_SNAKE_CASE_						(			__A :			int  ,    __A :			int  ,    __A :			int				)	->		str:

       """simple docstring"""

       assert len(str(__A				)				) > 2, "year should be in YYYY format"
       assert 1 <= month <= 12, "month should be between 1 to 12"
       assert 1 <= day <= 31, "day should be between 1 to 31"

       # Doomsday algorithm:
       a_					:		List[str]							=  year // 1_00
       a_					:		Optional[int]							=  (5 * (century % 4) + 2) % 7
       a_					:		List[str]							=  year % 1_00
       a_					:		str							=  centurian % 12
       a_					:		List[str]							=  (
           (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
       ) % 7
       a_					:		Any							=  (
           DOOMSDAY_NOT_LEAP[month - 1]
           if (year % 4 != 0) or (centurian == 0 and (year % 4_00) == 0)
           else DOOMSDAY_LEAP[month - 1]
       )
       a_					:		Any							=  (dooms_day + day - day_anchor) % 7
       return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
   import doctest

   doctest.testmod()


