'''simple docstring'''

lowercase_     		= {}



def 							UpperCamelCase__			(			a__			,      a__			,      a__      ):


						'''simple docstring'''






						if late == 3 or absent == 2:
												return 0

						# if we have no days left, and have not failed any other rules,
						# we have a prize string
						if days == 0:
												return 1

						# No easy solution, so now we need to do the recursive calculation

						# First, check if the combination is already in the cache, and
						# if yes, return the stored value from there since we already
						# know the number of possible prize strings from this point on
						_lowerCAmelCase										=(days, absent, late)
						if key in cache:
												return cache[key]

						# now we calculate the three possible ways that can unfold from
						# this point on, depending on our attendance today

						# 1) if we are late (but not absent), the "absent" counter stays as
						# it is, but the "late" counter increases by one
						_lowerCAmelCase										=_calculate(days - 1			,      a__			,      late + 1      )

						# 2) if we are absent, the "absent" counter increases by 1, and the
						# "late" counter resets to 0
						_lowerCAmelCase										=_calculate(days - 1			,      absent + 1			,      0      )

						# 3) if we are on time, this resets the "late" counter and keeps the
						# absent counter
						_lowerCAmelCase										=_calculate(days - 1			,      a__			,      0      )

						_lowerCAmelCase										=state_late + state_absent + state_ontime

						_lowerCAmelCase										=prizestrings
						return prizestrings



def 							UpperCamelCase__			(			a__ = 3_0      ):


						'''simple docstring'''






						return _calculate(a__			,      absent=0			,      late=0      )


if __name__ == "__main__":
							print(solution())






'''simple docstring'''

from __future__ import annotations



def 							UpperCamelCase__			(			a__      ):


						'''simple docstring'''






						_lowerCAmelCase										=len(a__      ) // 2

						# choose the middle 3 elements
						_lowerCAmelCase										=lst[m - 1 : m + 2]

						# if middle element is peak
						if three[1] > three[0] and three[1] > three[2]:
												return three[1]

						# if increasing, recurse on right
						elif three[0] < three[2]:
												if len(lst[:m]      ) == 2:
																		m -= 1
												return peak(lst[m:]      )

						# decreasing
						else:
												if len(lst[:m]      ) == 2:
																		m += 1
												return peak(lst[:m]      )


if __name__ == "__main__":
							import doctest

							doctest.testmod()





