
UpperCAmelCase    					=   {}

def      A (       A_							:					Tuple    ,							A_							:					Optional[Any]    ,							A_							:					str       ):



						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
						snake_case       :     Optional[int] =    (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
						snake_case       :     List[Any] =    _calculate(days - 1    ,							lowerCamelCase_    ,							late + 1       )

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

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

						snake_case       :     Optional[Any] =    state_late + state_absent + state_ontime

						snake_case       :     Optional[int] =    prizestrings
						return prizestrings

def      A (       A_							:					Tuple = 30       ):
						return _calculate(lowerCamelCase_    ,							absent=0    ,							late=0       )


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



'''simple docstring'''





from __future__ import annotations

import math

def      A (       A_							:					int       ):

						if num <= 0:
												snake_case       :     List[Any] =    F"""{num}: Invalid input, please enter a positive integer."""
												raise ValueError(A_       )

						snake_case       :     Optional[Any] =    [True] * (num + 1)
						snake_case       :     List[str] =    []
						snake_case       :     List[Any] =    2
						snake_case       :     str =    int(math.sqrt(A_       )       )

						while start <= end:
												# If start is a prime
												if sieve[start] is True:
																		prime.append(A_       )

																		# Set multiples of start be False
																		for i in range(start * start    ,							num + 1    ,							A_       ):
																								if sieve[i] is True:
																														snake_case       :     int =    False

												start += 1

						for j in range(end + 1    ,							num + 1       ):
												if sieve[j] is True:
																		prime.append(A_       )

						return prime


if __name__ == "__main__":
						print(prime_sieve(int(input("Enter a positive integer: ").strip())))

