






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







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )			->     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
					UpperCamelCase__      :       str	    =  (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
					UpperCamelCase__      :       Union[str, 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
					UpperCamelCase__      :       List[Any]	    =  _calculate(days - 1 ,   absent + 1 ,   0      )

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

					UpperCamelCase__      :       Tuple	    =  state_late + state_absent + state_ontime

					UpperCamelCase__      :       Dict	    =  prizestrings
					return prizestrings







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase = 30      )			->     int:
					return _calculate(__lowerCAmelCase ,   absent=0 ,   late=0      )


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







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     int:
     assert isinstance(__lowerCAmelCase ,   __lowerCAmelCase      ), f'The input value of [n={number}] is not an integer'

     if number == 1:
          return 2
     elif number < 1:
          UpperCamelCase__      :       List[Any]	    =  f'The input value of [n={number}] has to be > 0'
          raise ValueError(__lowerCAmelCase      )
     else:
          UpperCamelCase__      :       Optional[Any]	    =  sylvester(number - 1      )
          UpperCamelCase__      :       str	    =  num - 1
          UpperCamelCase__      :       int	    =  num
          return lower * upper + 1


if __name__ == "__main__":
 print(F"""The 8th number in Sylvester's sequence: {sylvester(8)}""")