"""simple docstring"""






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


def     UpperCAmelCase__ (       lowerCAmelCase__  :int      ,	lowerCAmelCase__  :int      ,	lowerCAmelCase__  :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
      lowercase														=			(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
      lowercase														=			_calculate(days - 1      ,	lowerCAmelCase__      ,	late + 1	)

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

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

      lowercase														=			state_late + state_absent + state_ontime

      lowercase														=			prizestrings
      return prizestrings


def     UpperCAmelCase__ (       lowerCAmelCase__  :int = 3_0	)				->					int:
      '''simple docstring'''


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


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




"""simple docstring"""






def     UpperCAmelCase__ (       lowerCAmelCase__  :int	)				->					bool:
      '''simple docstring'''


      lowercase														=			(1 + 2_4 * n) ** 0.5
      return ((1 + root) / 6) % 1 == 0


def     UpperCAmelCase__ (       lowerCAmelCase__  :int = 5_0_0_0	)				->					int:
      '''simple docstring'''


      lowercase														=			[(i * (3 * i - 1)) // 2 for i in range(1      ,	lowerCAmelCase__	)]
      for i, pentagonal_i in enumerate(lowerCAmelCase__	):
            for j in range(lowerCAmelCase__      ,	len(lowerCAmelCase__	)	):
                  lowercase														=			pentagonal_nums[j]
                  lowercase														=			pentagonal_i + pentagonal_j
                  lowercase														=			pentagonal_j - pentagonal_i
                  if is_pentagonal(lowerCAmelCase__	) and is_pentagonal(lowerCAmelCase__	):
                        return b

      return -1


if __name__ == "__main__":
       print(F"""{solution() = }""")



