
'''simple docstring'''






import mpmath  # for roots of unity
import numpy as np

class  UpperCAmelCase__						:



    def __init__(	self      :       Any,__A      :       int=None,__A      :       str=None     ):
          # Input as list
          _lowerCamelCase				:   List[Any]								=   list(poly_a or [0]     )[:]
          _lowerCamelCase				:   Tuple								=   list(poly_b or [0]     )[:]

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

          while self.polyB[-1] == 0:
                self.polyB.pop()
          _lowerCamelCase				:   Any								=   len(self.polyB     )

          # Add 0 to make lengths equal a power of 2
          _lowerCamelCase				:   Optional[int]								=   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
          _lowerCamelCase				:   int								=   complex(mpmath.root(x=1,n=self.c_max_length,k=1     )     )

          # The product
          _lowerCamelCase				:   Any								=   self.__multiply()



    def   lowerCamelCase_  (	self      :       List[str],__A      :       List[Any]     ):
          _lowerCamelCase				:   int								=   [[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]
          #
          _lowerCamelCase				:   Optional[int]								=   self.c_max_length // 2
          while next_ncol > 0:
                _lowerCamelCase				:   Union[str, Any]								=   [[] for i in range(__A     )]
                _lowerCamelCase				:   List[str]								=   self.root**next_ncol

                # First half of next step
                _lowerCamelCase				:   List[str]								=   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
                _lowerCamelCase				:   List[str]								=   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
                _lowerCamelCase				:   Dict								=   new_dft
                _lowerCamelCase				:   Dict								=   next_ncol // 2
          return dft[0]



    def   lowerCamelCase_  (	self      :       Optional[Any]     ):
          _lowerCamelCase				:   Tuple								=   self.__dft("A"     )
          _lowerCamelCase				:   str								=   self.__dft("B"     )
          _lowerCamelCase				:   Dict								=   [[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
          _lowerCamelCase				:   Union[str, Any]								=   2
          while next_ncol <= self.c_max_length:
                _lowerCamelCase				:   Dict								=   [[] for i in range(__A     )]
                _lowerCamelCase				:   Optional[Any]								=   self.root ** (next_ncol // 2)
                _lowerCamelCase				:   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
                _lowerCamelCase				:   List[Any]								=   new_inverse_c
                next_ncol *= 2
          # Unpack
          _lowerCamelCase				:   Any								=   [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     ):
          _lowerCamelCase				:   Dict								=   "A = " + " + ".join(
              f'{coef}*x^{i}' for coef, i in enumerate(self.polyA[: self.len_A]     )     )
          _lowerCamelCase				:   Any								=   "B = " + " + ".join(
              f'{coef}*x^{i}' for coef, i in enumerate(self.polyB[: self.len_B]     )     )
          _lowerCamelCase				:   Optional[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 math import sqrt







def 		A_       (	_lowerCAmelCase   :    int = 1000000							):



      """simple docstring"""




      _lowerCamelCase				:   int								=   0
      _lowerCamelCase				:   int								=   0
      _lowerCamelCase				:   int

      while num_cuboids <= limit:
            max_cuboid_size += 1
            for sum_shortest_sides in range(2				,	2 * max_cuboid_size + 1							):
                  if sqrt(sum_shortest_sides**2 + max_cuboid_size**2							).is_integer():
                        num_cuboids += (
                            min(_lowerCAmelCase				,	sum_shortest_sides // 2							)
                            - max(1				,	sum_shortest_sides - max_cuboid_size							)
                            + 1
                        )

      return max_cuboid_size


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