__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"""






from __future__ import annotations


def     UpperCAmelCase__ (       lowerCAmelCase__  :list[float]      ,	lowerCAmelCase__  :list[float]	)				->					float:
      '''simple docstring'''


      lowercase														=			sorted(numsa + numsa	)
      lowercase							,							lowercase														=			divmod(len(lowerCAmelCase__	)      ,	2	)
      if mod == 1:
            return all_numbers[div]
      else:
            return (all_numbers[div] + all_numbers[div - 1]) / 2


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       __lowerCAmelCase					: List[Any]        =[float(x) for x in input("""Enter the elements of first array: """).split()]
       __lowerCAmelCase					: List[Any]        =[float(x) for x in input("""Enter the elements of second array: """).split()]
       print(F"""The median of two arrays is: {median_of_two_arrays(array_a, array_a)}""")



