





'''simple docstring'''

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





def 		UpperCamelCase							(				_lowerCamelCase   :   int		,			_lowerCamelCase   :   int		,			_lowerCamelCase   :   int			):
    assert len(str(_lowerCamelCase			)			) > 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__							=     year // 1_00
    A__							=     (5 * (century % 4) + 2) % 7
    A__							=     year % 1_00
    A__							=     centurian % 12
    A__							=     (
        (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
    ) % 7
    A__							=     (
        DOOMSDAY_NOT_LEAP[month - 1]
        if (year % 4 != 0) or (centurian == 0 and (year % 4_00) == 0)
        else DOOMSDAY_LEAP[month - 1]
    )
    A__							=     (dooms_day + day - day_anchor) % 7
    return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
  import doctest

  doctest.testmod()










'''simple docstring'''

from typing import Optional, Union

import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models.modeling_utils import ModelMixin






class   UpperCAmelCase      (			UpperCamelCase__     ,			UpperCamelCase__							):
 @register_to_config
 def __init__(							self :List[str]		,			lowercase_ :int = 7_68		,			)->				str:
     super().__init__()

     A__							=     nn.Parameter(torch.zeros(1		,			lowercase_				)				)
     A__							=     nn.Parameter(torch.ones(1		,			lowercase_				)				)
 def 	UpperCAmelCase_				(							self :List[Any]		,			lowercase_ :Optional[Union[str, torch.device]] = None		,			lowercase_ :Optional[torch.dtype] = None		,			)->				Tuple:
     A__							=     nn.Parameter(self.mean.to(lowercase_				).to(lowercase_				)				)
     A__							=     nn.Parameter(self.std.to(lowercase_				).to(lowercase_				)				)
     return self
 def 	UpperCAmelCase_				(							self :Optional[int]		,			lowercase_ :str				)->				Union[str, Any]:
     A__							=     (embeds - self.mean) * 1.0 / self.std
     return embeds



 def 	UpperCAmelCase_				(							self :Any		,			lowercase_ :List[Any]				)->				Tuple:
     A__							=     (embeds * self.std) + self.mean
     return embeds



