





"""simple docstring"""


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

def      UpperCamelCase							(SCREAMING_SNAKE_CASE							,     SCREAMING_SNAKE_CASE							,     SCREAMING_SNAKE_CASE     ):

						# 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				:		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
						UpperCamelCase				:		Dict				   =			_calculate(days - 1							,     SCREAMING_SNAKE_CASE							,     late + 1     )

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

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

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

						UpperCamelCase				:		Any				   =			prizestrings
						return prizestrings

def      UpperCamelCase							(SCREAMING_SNAKE_CASE = 30     ):
						return _calculate(SCREAMING_SNAKE_CASE							,     absent=0							,     late=0     )


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










from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding




class 	UpperCamelCase_							(  UpperCamelCase__     ):
							lowerCamelCase_							     =       ["image_processor", "tokenizer"]
							lowerCamelCase_							     =       "AutoImageProcessor"
							lowerCamelCase_							     =       "AutoTokenizer"


							def __init__(				self     :Optional[int]				,					__A     :Optional[Any]				,					__A     :Dict		) -> Dict:



									"""simple docstring"""



									super().__init__(__A				,					__A		)
									SCREAMING_SNAKE_CASE__								=   self.image_processor


							def __call__(				self     :int				,					__A     :str=None				,					__A     :int=None				,					__A     :Union[str, Any]=None				,					**__A     :str		) -> Optional[Any]:



									"""simple docstring"""



									if text is None and images is None:
											raise ValueError("""You have to specify either text or images. Both cannot be none."""		)

									if text is not None:
											SCREAMING_SNAKE_CASE__								=   self.tokenizer(__A				,					return_tensors=__A				,					**__A		)

									if images is not None:
											SCREAMING_SNAKE_CASE__								=   self.image_processor(__A				,					return_tensors=__A				,					**__A		)

									if text is not None and images is not None:
											SCREAMING_SNAKE_CASE__								=   image_features.pixel_values
											return encoding
									elif text is not None:
											return encoding
									else:
											return BatchEncoding(data=dict(**__A		)				,					tensor_type=__A		)


							def   _snake_case	(				self     :str				,					*__A     :List[str]				,					**__A     :List[str]		) -> List[Any]:



									"""simple docstring"""



									return self.tokenizer.batch_decode(*__A				,					**__A		)


							def   _snake_case	(				self     :List[str]				,					*__A     :Any				,					**__A     :Any		) -> Tuple:



									"""simple docstring"""



									return self.tokenizer.decode(*__A				,					**__A		)


							@property
							def   _snake_case	(				self     :Dict		) -> List[Any]:



									"""simple docstring"""



									return ["input_ids", "attention_mask", "pixel_values"]