






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

def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  int	,			__magic_name__					:  int	,			__magic_name__					:  int					)		->			int:






	"""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
	UpperCamelCase     :List[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     :List[str]          =	_calculate(days - 1	,			__magic_name__	,			late + 1					)

	# 2) if we are absent, the "absent" counter increases by 1, and the
	# "late" counter resets to 0
	UpperCamelCase     :Union[str, 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	,			__magic_name__	,			0					)

	UpperCamelCase     :Union[str, Any]          =	state_late + state_absent + state_ontime

	UpperCamelCase     :Optional[int]          =	prizestrings
	return prizestrings

def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  int = 30					)		->			int:






	"""simple docstring"""



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


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








from typing import Callable, Optional

from .. import Features
from ..packaged_modules.generator.generator import Generator
from .abc import AbstractDatasetInputStream

class     _SCREAMING_SNAKE_CASE       (			_a      ):





	def __init__(		self				:					List[Any] ,  __lowerCamelCase				:					Callable ,  __lowerCamelCase				:					Optional[Features] = None ,  __lowerCamelCase				:					str = None ,  __lowerCamelCase				:					bool = False ,  __lowerCamelCase				:					bool = False ,  __lowerCamelCase				:					Optional[dict] = None ,  __lowerCamelCase				:					Optional[int] = None ,  **__lowerCamelCase				:					List[Any] ,  ):
		super().__init__(
		    features=__lowerCamelCase ,  cache_dir=__lowerCamelCase ,  keep_in_memory=__lowerCamelCase ,  streaming=__lowerCamelCase ,  num_proc=__lowerCamelCase ,  **__lowerCamelCase ,  )
		UpperCamelCase     :Union[str, Any]          =	Generator(
		    cache_dir=__lowerCamelCase ,  features=__lowerCamelCase ,  generator=__lowerCamelCase ,  gen_kwargs=__lowerCamelCase ,  **__lowerCamelCase ,  )





	def 						_A (		self				:					List[str]	):
		# Build iterable dataset
		if self.streaming:
			UpperCamelCase     :Any          =	self.builder.as_streaming_dataset(split="""train"""	)
		# Build regular (map-style) dataset
		else:
			UpperCamelCase     :Tuple          =	None
			UpperCamelCase     :Dict          =	None
			UpperCamelCase     :Dict          =	None
			UpperCamelCase     :List[str]          =	None

			self.builder.download_and_prepare(
			    download_config=__lowerCamelCase ,  download_mode=__lowerCamelCase ,  verification_mode=__lowerCamelCase ,  base_path=__lowerCamelCase ,  num_proc=self.num_proc ,  )
			UpperCamelCase     :Tuple          =	self.builder.as_dataset(
			    split="""train""" ,  verification_mode=__lowerCamelCase ,  in_memory=self.keep_in_memory	)
		return dataset
