


'''simple docstring'''



A__						:   dict[tuple[int, int, int], int]				=    {}



def      UpperCAmelCase__   (      UpperCAmelCase_       :							int ,       UpperCAmelCase_       :							int ,       UpperCAmelCase_       :							int				)	->						int:

     # if we are absent twice, or late 3 consecutive days,
     # no further prize strings are possible
     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  :      List[Any]														=						(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  :      Tuple														=						_calculate(days - 1 ,       UpperCAmelCase_ ,       late + 1				)

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

     # 3) if we are on time, this resets the "late" counter and keeps the
     # absent counter
     __lowerCamelCase  :      List[Any]														=						_calculate(days - 1 ,       UpperCAmelCase_ ,       0				)

     __lowerCamelCase  :      Optional[int]														=						state_late + state_absent + state_ontime

     __lowerCamelCase  :      Union[str, Any]														=						prizestrings
     return prizestrings



def      UpperCAmelCase__   (      UpperCAmelCase_       :							int = 30				)	->						int:
     return _calculate(UpperCAmelCase_ ,       absent=0 ,       late=0				)


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











'''simple docstring'''

from __future__ import annotations







def a_     (    __UpperCAmelCase					)				->					list[int]:





			"""simple docstring"""







			snake_case:    Tuple      							=[True] * limit
			snake_case:    Optional[int]      							=False
			snake_case:    Union[str, Any]      							=False
			snake_case:    List[Any]      							=True

			for i in range(3				,							int(limit**0.5 + 1					)				,							2					):
						snake_case:    str      							=i * 2
						while index < limit:
									snake_case:    List[Any]      							=False
									snake_case:    List[str]      							=index + i

			snake_case:    Union[str, Any]      							=[2]

			for i in range(3				,							__UpperCAmelCase				,							2					):
						if is_prime[i]:
									primes.append(__UpperCAmelCase					)

			return primes







def a_     (    __UpperCAmelCase = 1_00_00_00					)				->					int:





			"""simple docstring"""







			snake_case:    str      							=prime_sieve(__UpperCAmelCase					)
			snake_case:    str      							=0
			snake_case:    str      							=0

			for i in range(len(__UpperCAmelCase					)					):
						for j in range(i + length				,							len(__UpperCAmelCase					)					):
									snake_case:    Tuple      							=sum(primes[i:j]					)
									if sol >= ceiling:
												break

									if sol in primes:
												snake_case:    List[str]      							=j - i
												snake_case:    Optional[int]      							=sol

			return largest


if __name__ == "__main__":
	print(F"""{solution() = }""")




