
__A				={}





def 			lowerCamelCase_ (				lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__    ):

				# 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_						=			(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_						=			_calculate(days - 1	, lowerCamelCase__	, late + 1    )

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

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

				lowerCamelCase_						=			state_late + state_absent + state_ontime

				lowerCamelCase_						=			prizestrings
				return prizestrings





def 			lowerCamelCase_ (				lowerCamelCase__ = 3_0    ):
				return _calculate(lowerCamelCase__	, absent=0	, late=0    )


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



from torch import nn





class 		_lowercase						(					nn.Module       ):

 def __init__( self	:							Any   ,      snake_case	:							Dict   ,      snake_case	:							Union[str, Any]			)   ->						Dict:

  """simple docstring"""





  super().__init__()
  UpperCamelCase_					:						List[Any] =					class_size
  UpperCamelCase_					:						List[Any] =					embed_size
  # self.mlp1 = nn.Linear(embed_size, embed_size)
  # self.mlp2 = (nn.Linear(embed_size, class_size))
  UpperCamelCase_					:						int =					nn.Linear(snake_case   ,      snake_case			)


 def 						SCREAMING_SNAKE_CASE__   ( self	:							List[str]   ,      snake_case	:							Any			)   ->						str:

  """simple docstring"""





  UpperCamelCase_					:						Dict =					self.mlp(snake_case			)
  return logits



