






import mpmath  # for roots of unity
import numpy as np
class     a    :



      """simple docstring"""


      def __init__(      self					:			Dict		,      __lowercase					:			Dict=None		,      __lowercase					:			Union[str, Any]=None					)							->      Optional[int]:
        __UpperCAmelCase							:	str           =  list(poly_a or [0]					)[:]
        __UpperCAmelCase							:	int           =  list(poly_b or [0]					)[:]

        # Remove leading zero coefficients
        while self.polyA[-1] == 0:
          self.polyA.pop()
        __UpperCAmelCase							:	List[str]           =  len(self.polyA					)

        while self.polyB[-1] == 0:
          self.polyB.pop()
        __UpperCAmelCase							:	Union[str, Any]           =  len(self.polyB					)

        # Add 0 to make lengths equal a power of 2
        __UpperCAmelCase							:	Dict           =  int(
            2 ** np.ceil(np.loga(len(self.polyA					) + len(self.polyB					) - 1					)					)					)

        while len(self.polyA					) < self.c_max_length:
          self.polyA.append(0					)
        while len(self.polyB					) < self.c_max_length:
          self.polyB.append(0					)
        # A complex root used for the fourier transform
        __UpperCAmelCase							:	Any           =  complex(mpmath.root(x=1		,      n=self.c_max_length		,      k=1					)					)

        # The product
        __UpperCAmelCase							:	Dict           =  self.__multiply()
      def 	UpperCAmelCase      (      self					:			Dict		,      __lowercase					:			Optional[Any]					)							->      Dict:
        __UpperCAmelCase							:	List[str]           =  [[x] for x in self.polyA] if which == """A""" else [[x] for x in self.polyB]
        # Corner case
        if len(__a					) <= 1:
          return dft[0]
        #
        __UpperCAmelCase							:	str           =  self.c_max_length // 2
        while next_ncol > 0:
          __UpperCAmelCase							:	Tuple           =  [[] for i in range(__a					)]
          __UpperCAmelCase							:	List[Any]           =  self.root**next_ncol

          # First half of next step
          __UpperCAmelCase							:	List[Any]           =  1
          for j in range(self.c_max_length // (next_ncol * 2)					):
            for i in range(__a					):
              new_dft[i].append(dft[i][j] + current_root * dft[i + next_ncol][j]					)
            current_root *= root
          # Second half of next step
          __UpperCAmelCase							:	Union[str, Any]           =  1
          for j in range(self.c_max_length // (next_ncol * 2)					):
            for i in range(__a					):
              new_dft[i].append(dft[i][j] - current_root * dft[i + next_ncol][j]					)
            current_root *= root
          # Update
          __UpperCAmelCase							:	Any           =  new_dft
          __UpperCAmelCase							:	Dict           =  next_ncol // 2
        return dft[0]
      def 	UpperCAmelCase      (      self					:			List[Any]					)							->      str:
        __UpperCAmelCase							:	Tuple           =  self.__dft("""A"""					)
        __UpperCAmelCase							:	str           =  self.__dft("""B"""					)
        __UpperCAmelCase							:	List[str]           =  [[dft_a[i] * dft_b[i] for i in range(self.c_max_length					)]]
        del dft_a
        del dft_b

        # Corner Case
        if len(inverce_c[0]					) <= 1:
          return inverce_c[0]
        # Inverse DFT
        __UpperCAmelCase							:	Optional[Any]           =  2
        while next_ncol <= self.c_max_length:
          __UpperCAmelCase							:	Optional[Any]           =  [[] for i in range(__a					)]
          __UpperCAmelCase							:	Dict           =  self.root ** (next_ncol // 2)
          __UpperCAmelCase							:	Optional[Any]           =  1
          # First half of next step
          for j in range(self.c_max_length // next_ncol					):
            for i in range(next_ncol // 2					):
              # Even positions
              new_inverse_c[i].append(
                  (
                      inverce_c[i][j]
                      + inverce_c[i][j + self.c_max_length // next_ncol]
                  )
                  / 2					)
              # Odd positions
              new_inverse_c[i + next_ncol // 2].append(
                  (
                      inverce_c[i][j]
                      - inverce_c[i][j + self.c_max_length // next_ncol]
                  )
                  / (2 * current_root)					)
            current_root *= root
          # Update
          __UpperCAmelCase							:	List[str]           =  new_inverse_c
          next_ncol *= 2
        # Unpack
        __UpperCAmelCase							:	List[str]           =  [round(x[0].real		,      8					) + round(x[0].imag		,      8					) * 1j for x in inverce_c]

        # Remove leading 0's
        while inverce_c[-1] == 0:
          inverce_c.pop()
        return inverce_c




      def __str__(      self					:			Any					)							->      int:
        __UpperCAmelCase							:	Optional[int]           =  """A = """ + """ + """.join(
            f"""{coef}*x^{i}""" for coef, i in enumerate(self.polyA[: self.len_A]					)					)
        __UpperCAmelCase							:	Any           =  """B = """ + """ + """.join(
            f"""{coef}*x^{i}""" for coef, i in enumerate(self.polyB[: self.len_B]					)					)
        __UpperCAmelCase							:	List[Any]           =  """A*B = """ + """ + """.join(
            f"""{coef}*x^{i}""" for coef, i in enumerate(self.product					)					)

        return f"""{a}\n{b}\n{c}"""


# Unit tests
if __name__ == "__main__":
       import doctest

       doctest.testmod()




"""simple docstring"""





from __future__ import annotations



def       lowerCamelCase__		(			__snake_case,     __snake_case	)							->		float:


					"""simple docstring"""





					_UpperCamelCase							 =  sorted(numsa + numsa	)
					_UpperCamelCase ,  _UpperCamelCase							 =  divmod(len(__snake_case	),     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()
				_a														=		[float(x) for x in input("""Enter the elements of first array: """).split()]
				_a														=		[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)}""")






