



'''simple docstring'''

UpperCAmelCase     		=   {}






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						int							,		_SCREAMING_SNAKE_CASE					:						int							,		_SCREAMING_SNAKE_CASE					:						int							)      ->						int:







	"""simple docstring"""

	# 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							,		_SCREAMING_SNAKE_CASE							,		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							,		_SCREAMING_SNAKE_CASE							,		0							)

	lowerCAmelCase   =     state_late + state_absent + state_ontime

	lowerCAmelCase   =     prizestrings
	return prizestrings






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						int = 30							)      ->						int:







	"""simple docstring"""
	return _calculate(_SCREAMING_SNAKE_CASE							,		absent=0							,		late=0							)


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




'''simple docstring'''

from __future__ import annotations

class __snake_case:


						'''simple docstring'''



						def __init__( self     ,	A_ = 0				)     ->     Dict:
							lowerCAmelCase   =     key


						def     __snake_case   ( self     ,	A_     ,	A_				)     ->     list[str]:
							assert isinstance(A_     ,	A_				) and isinstance(A_     ,	A_				)

							lowerCAmelCase   =     key or self.__key or 1

							# make sure key is an appropriate size
							key %= 255

							return [chr(ord(A_				) ^ key				) for ch in content]


						def     __snake_case   ( self     ,	A_     ,	A_				)     ->     list[str]:
							assert isinstance(A_     ,	A_				) and isinstance(A_     ,	A_				)

							lowerCAmelCase   =     key or self.__key or 1

							# make sure key is an appropriate size
							key %= 255

							return [chr(ord(A_				) ^ key				) for ch in content]


						def     __snake_case   ( self     ,	A_     ,	A_ = 0				)     ->     str:
							assert isinstance(A_     ,	A_				) and isinstance(A_     ,	A_				)

							lowerCAmelCase   =     key or self.__key or 1

							# make sure key can be any size
							while key > 255:
								key -= 255

							# This will be returned
							lowerCAmelCase   =     """"""

							for ch in content:
								ans += chr(ord(A_				) ^ key				)

							return ans


						def     __snake_case   ( self     ,	A_     ,	A_ = 0				)     ->     str:
							assert isinstance(A_     ,	A_				) and isinstance(A_     ,	A_				)

							lowerCAmelCase   =     key or self.__key or 1

							# make sure key can be any size
							while key > 255:
								key -= 255

							# This will be returned
							lowerCAmelCase   =     """"""

							for ch in content:
								ans += chr(ord(A_				) ^ key				)

							return ans


						def     __snake_case   ( self     ,	A_     ,	A_ = 0				)     ->     bool:
							assert isinstance(A_     ,	A_				) and isinstance(A_     ,	A_				)

							try:
								with open(A_				) as fin, open("""encrypt.out"""     ,	"""w+"""				) as fout:
									# actual encrypt-process
									for line in fin:
										fout.write(self.encrypt_string(A_     ,	A_				)				)

							except OSError:
								return False

							return True




						def     __snake_case   ( self     ,	A_     ,	A_				)     ->     bool:
							assert isinstance(A_     ,	A_				) and isinstance(A_     ,	A_				)

							try:
								with open(A_				) as fin, open("""decrypt.out"""     ,	"""w+"""				) as fout:
									# actual encrypt-process
									for line in fin:
										fout.write(self.decrypt_string(A_     ,	A_				)				)

							except OSError:
								return False

							return True


# Tests
# crypt = XORCipher()
# key = 67

# # test encrypt
# print(crypt.encrypt("hallo welt",key))
# # test decrypt
# print(crypt.decrypt(crypt.encrypt("hallo welt",key), key))

# # test encrypt_string
# print(crypt.encrypt_string("hallo welt",key))

# # test decrypt_string
# print(crypt.decrypt_string(crypt.encrypt_string("hallo welt",key),key))

# if (crypt.encrypt_file("test.txt",key)):
#       print("encrypt successful")
# else:
#       print("encrypt unsuccessful")

# if (crypt.decrypt_file("encrypt.out",key)):
#       print("decrypt successful")
# else:
#       print("decrypt unsuccessful")