





'''simple docstring'''

import math
from datetime import datetime, timedelta




def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      _snake_case		:	Optional[int]					     =     year % 19
      _snake_case		:	str					     =     year % 4
      _snake_case		:	Any					     =     year % 7
      _snake_case		:	Union[str, Any]					     =     math.floor(year / 100	)
      _snake_case		:	Tuple					     =     math.floor((13 + 8 * leap_day_inhibits) / 25	)
      _snake_case		:	Optional[int]					     =     leap_day_inhibits / 4
      _snake_case		:	Optional[int]					     =     (
          15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
      ) % 30
      _snake_case		:	Optional[int]					     =     (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

      # days to be added to March 21
      _snake_case		:	Optional[Any]					     =     (19 * metonic_cycle + secular_moon_shift) % 30

      # PHM -> Paschal Full Moon
      _snake_case		:	Union[str, Any]					     =     (
          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(lowerCAmelCase_			,      4			,      19	)
      elif days_to_add == 28 and days_from_phm_to_sunday == 6:
            return datetime(lowerCAmelCase_			,      4			,      18	)
      else:
            return datetime(lowerCAmelCase_			,      3			,      22	) + timedelta(
                days=int(days_to_add + days_from_phm_to_sunday	)	)


if __name__ == "__main__":
   for year in (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3):
      UpperCAmelCase					:		Optional[Any]		=							'will be' if year > datetime.now().year else 'was'
      print(F"""Easter in {year} {tense} {gauss_easter(year)}""")









'''simple docstring'''

import pickle
import unittest

import torch

from accelerate import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils import require_cpu





@require_cpu
class lowerCamelCase						(unittest.TestCase					):







  def 				UpperCAmelCase_				(		self		)		->						Union[str, Any]:






        """simple docstring"""





        _snake_case		:	Any					     =     torch.nn.Linear(10     ,     10		)
        _snake_case		:	Optional[int]					     =     torch.optim.SGD(model.parameters()     ,     0.1		)
        _snake_case		:	List[str]					     =     Accelerator()
        _snake_case		:	Optional[Any]					     =     accelerator.prepare(lowercase__		)
        try:
              pickle.loads(pickle.dumps(lowercase__		)		)
        except Exception as e:
              self.fail(F'''Accelerated optimizer pickling failed with {e}'''		)
        AcceleratorState._reset_state()


