






"""simple docstring"""


_UpperCamelCase    :   str   			=						[4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
_UpperCamelCase    :   List[Any]   			=						[3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
_UpperCamelCase    :   Tuple   			=						{
    0: 'Sunday',
    1: 'Monday',
    2: 'Tuesday',
    3: 'Wednesday',
    4: 'Thursday',
    5: 'Friday',
    6: 'Saturday',
}




def       snake_case  (A_				:int     ,      A_				:int     ,      A_				:int				):







  '''simple docstring'''

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

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


if __name__ == "__main__":
   import doctest

   doctest.testmod()












"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_UpperCamelCase    :   Optional[int]   			=						{
    'configuration_rag': ['RagConfig'],
    'retrieval_rag': ['RagRetriever'],
    'tokenization_rag': ['RagTokenizer'],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCamelCase    :   Dict   			=						[
       'RagModel',
       'RagPreTrainedModel',
       'RagSequenceForGeneration',
       'RagTokenForGeneration',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCamelCase    :   Optional[int]   			=						[
       'TFRagModel',
       'TFRagPreTrainedModel',
       'TFRagSequenceForGeneration',
       'TFRagTokenForGeneration',
   ]


if TYPE_CHECKING:
   from .configuration_rag import RagConfig
   from .retrieval_rag import RagRetriever
   from .tokenization_rag import RagTokenizer

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_rag import RagModel, RagPreTrainedModel, RagSequenceForGeneration, RagTokenForGeneration

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_rag import (
          TFRagModel,
          TFRagPreTrainedModel,
          TFRagSequenceForGeneration,
          TFRagTokenForGeneration,
      )

else:
   import sys

   _UpperCamelCase    :   int   			=						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




