
"""simple docstring"""


from __future__ import annotations

_lowercase							      = [-10, -5, 0, 5, 5.1, 11, 13, 21, 3, 4, -21, -10, -5, -1, 0]
_lowercase							      = [-5, 0, 5, 5.1, 11, 13, 21, -1, 4, -1, -10, -5, -1, 0, -1]






def 					_snake_case (						snake_case__      :   list[float]   ):
	A        =      []
	A        =      len(snake_case__   )

	for i in range(snake_case__   ):
		A        =      -1
		for j in range(i + 1		,					snake_case__   ):
			if arr[i] < arr[j]:
				A        =      arr[j]
				break
		result.append(snake_case__   )
	return result






def 					_snake_case (						snake_case__      :   list[float]   ):
	A        =      []
	for i, outer in enumerate(snake_case__   ):
		A        =      -1
		for inner in arr[i + 1 :]:
			if outer < inner:
				A        =      inner
				break
		result.append(snake_case__   )
	return result






def 					_snake_case (						snake_case__      :   list[float]   ):
	A        =      len(snake_case__   )
	A        =      []
	A        =      [-1] * arr_size

	for index in reversed(range(snake_case__   )   ):
		if stack:
			while stack[-1] <= arr[index]:
				stack.pop()
				if not stack:
					break
		if stack:
			A        =      stack[-1]
		stack.append(arr[index]   )
	return result


if __name__ == "__main__":
		from doctest import testmod
		from timeit import timeit

		testmod()
		print(next_greatest_element_slow(arr))
		print(next_greatest_element_fast(arr))
		print(next_greatest_element(arr))

		_lowercase							      = (
		    '''from __main__ import arr, next_greatest_element_slow, '''
		    '''next_greatest_element_fast, next_greatest_element'''
		)
		print(
		    '''next_greatest_element_slow():''',
		    timeit('''next_greatest_element_slow(arr)''', setup=setup),
		)
		print(
		    '''next_greatest_element_fast():''',
		    timeit('''next_greatest_element_fast(arr)''', setup=setup),
		)
		print(
		    '''     next_greatest_element():''',
		    timeit('''next_greatest_element(arr)''', setup=setup),
		)



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







def        SCREAMING_SNAKE_CASE_						(			__A :			int  ,    __A :			int  ,    __A :			int				)	->		str:

       """simple docstring"""

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


if __name__ == "__main__":
   import doctest

   doctest.testmod()


