





"""simple docstring"""
import math
from datetime import datetime, timedelta



def 					__lowerCamelCase       (							a_					:		int							)      ->				datetime:
      __SCREAMING_SNAKE_CASE       :str		    =  year % 19
      __SCREAMING_SNAKE_CASE       :List[str]		    =  year % 4
      __SCREAMING_SNAKE_CASE       :int		    =  year % 7
      __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  math.floor(year / 1_00							)
      __SCREAMING_SNAKE_CASE       :str		    =  math.floor((13 + 8 * leap_day_inhibits) / 25							)
      __SCREAMING_SNAKE_CASE       :List[str]		    =  leap_day_inhibits / 4
      __SCREAMING_SNAKE_CASE       :List[Any]		    =  (
          15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
      ) % 30
      __SCREAMING_SNAKE_CASE       :Optional[int]		    =  (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

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

      # PHM -> Paschal Full Moon
      __SCREAMING_SNAKE_CASE       :List[str]		    =  (
          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(a_			,       4			,       19							)
      elif days_to_add == 28 and days_from_phm_to_sunday == 6:
            return datetime(a_			,       4			,       18							)
      else:
            return datetime(a_			,       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):
    lowerCamelCase_       =		"will be" if year > datetime.now().year else "was"
    print(f'Easter in {year} {tense} {gauss_easter(year)}')






"""simple docstring"""
import math
import random



def 					__lowerCamelCase       (							a_					:		float			,       a_					:		bool = False							)      ->				float:
      if deriv:
            return value * (1 - value)
      return 1 / (1 + math.exp(-value							))


# Initial Value
lowerCamelCase_       =		0.02



def 					__lowerCamelCase       (							a_					:		int			,       a_					:		int							)      ->				float:
      __SCREAMING_SNAKE_CASE       :Any		    =  float(2 * (random.randint(1			,       1_00							)) - 1							)

      for _ in range(a_							):
            # Forward propagation
            __SCREAMING_SNAKE_CASE       :Any		    =  sigmoid_function(INITIAL_VALUE * weight							)
            # How much did we miss?
            __SCREAMING_SNAKE_CASE       :Tuple		    =  (expected / 1_00) - layer_a
            # Error delta
            __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  layer_1_error * sigmoid_function(a_			,       a_							)
            # Update weight
            weight += INITIAL_VALUE * layer_1_delta

      return layer_a * 1_00


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  lowerCamelCase_       =		int(input("Expected value: "))
  lowerCamelCase_       =		int(input("Number of propagations: "))
  print(forward_propagation(expected, number_propagations))