




import math
from datetime import datetime, timedelta

def  SCREAMING_SNAKE_CASE							(       __UpperCamelCase)      ->					datetime:
     a     =				year % 19
     a     =				year % 4
     a     =				year % 7
     a     =				math.floor(year / 1_00)
     a     =				math.floor((13 + 8 * leap_day_inhibits) / 25)
     a     =				leap_day_inhibits / 4
     a     =				(
         15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
     ) % 30
     a     =				(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

     # days to be added to March 21
     a     =				(19 * metonic_cycle + secular_moon_shift) % 30

     # PHM -> Paschal Full Moon
     a     =				(
         2 * julian_leap_year
         + 4 * non_leap_year
         + 6 * days_to_add
         + century_starting_point
     ) % 7

     if days_to_add == 29 and days_from_phm_to_sunday == 6:
          return datetime(__UpperCamelCase		, 4		, 19)
     elif days_to_add == 28 and days_from_phm_to_sunday == 6:
          return datetime(__UpperCamelCase		, 4		, 18)
     else:
          return datetime(__UpperCamelCase		, 3		, 22) + timedelta(
              days=int(days_to_add + days_from_phm_to_sunday))


if __name__ == "__main__":
       for year in (1_994, 2_000, 2_010, 2_021, 2_023):
              lowercase__				:      List[Any]	   = "will be" if year > datetime.now().year else "was"
              print(F'Easter in {year} {tense} {gauss_easter(year)}')







from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


lowercase__				:      Tuple	   = logging.get_logger(__name__)

lowercase__				:      int	   = {
    "microsoft/resnet-50": "https://huggingface.co/microsoft/resnet-50/blob/main/config.json",
}




class       a__	( UpperCamelCase__       , UpperCamelCase__				):
     a		:      Any		 =     """resnet"""
     a		:      Tuple		 =     ["""basic""", """bottleneck"""]







     def __init__(     self  ,		A=3  ,		A=64  ,		A=[256, 512, 1024, 2048]  ,		A=[3, 4, 6, 3]  ,		A="bottleneck"  ,		A="relu"  ,		A=False  ,		A=None  ,		A=None  ,		**A  ,		)  ->   Any:



          '''simple docstring'''



          super().__init__(**A			)
          if layer_type not in self.layer_types:
               raise ValueError(F'''layer_type={layer_type} is not one of {",".join(self.layer_types			)}'''			)
          a     =				num_channels
          a     =				embedding_size
          a     =				hidden_sizes
          a     =				depths
          a     =				layer_type
          a     =				hidden_act
          a     =				downsample_in_first_stage
          a     =				["stem"] + [F'''stage{idx}''' for idx in range(1  ,		len(A			) + 1			)]
          a  ,				a     =				get_aligned_output_features_output_indices(
              out_features=A  ,		out_indices=A  ,		stage_names=self.stage_names			)







class       a__	( UpperCamelCase__				):
     a		:      Optional[int]		 =     version.parse("""1.11"""				)







     @property
     def       lowerCAmelCase_    (     self			)  ->   Mapping[str, Mapping[int, str]]:



          '''simple docstring'''



          return OrderedDict(
              [
                  ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
              ]			)







     @property
     def       lowerCAmelCase_    (     self			)  ->   float:



          '''simple docstring'''



          return 1e-3

