






from __future__ import annotations

import bisect

def        UpperCAmelCase__		(						lowerCamelCase_       :       list[int]   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int = 0   ,  lowerCamelCase_       :       int = -1				):
			if hi < 0:
						__a						:  Optional[Any]									=     len(lowerCamelCase_				)

			while lo < hi:
						__a						:  str									=     lo + (hi - lo) // 2
						if sorted_collection[mid] < item:
									__a						:  List[Any]									=     mid + 1
						else:
									__a						:  Union[str, Any]									=     mid

			return lo

def        UpperCAmelCase__		(						lowerCamelCase_       :       list[int]   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int = 0   ,  lowerCamelCase_       :       int = -1				):
			if hi < 0:
						__a						:  Union[str, Any]									=     len(lowerCamelCase_				)

			while lo < hi:
						__a						:  List[str]									=     lo + (hi - lo) // 2
						if sorted_collection[mid] <= item:
									__a						:  List[Any]									=     mid + 1
						else:
									__a						:  Optional[int]									=     mid

			return lo

def        UpperCAmelCase__		(						lowerCamelCase_       :       list[int]   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int = 0   ,  lowerCamelCase_       :       int = -1				):
			sorted_collection.insert(bisect_left(lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_				)   ,  lowerCamelCase_				)

def        UpperCAmelCase__		(						lowerCamelCase_       :       list[int]   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int = 0   ,  lowerCamelCase_       :       int = -1				):
			sorted_collection.insert(bisect_right(lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_				)   ,  lowerCamelCase_				)

def        UpperCAmelCase__		(						lowerCamelCase_       :       list[int]   ,  lowerCamelCase_       :       int				):
			__a						:  str									=     0
			__a						:  Union[str, Any]									=     len(lowerCamelCase_				) - 1

			while left <= right:
						__a						:  List[Any]									=     left + (right - left) // 2
						__a						:  Union[str, Any]									=     sorted_collection[midpoint]
						if current_item == item:
									return midpoint
						elif item < current_item:
									__a						:  List[str]									=     midpoint - 1
						else:
									__a						:  int									=     midpoint + 1
			return None

def        UpperCAmelCase__		(						lowerCamelCase_       :       list[int]   ,  lowerCamelCase_       :       int				):
			__a						:  List[str]									=     bisect.bisect_left(lowerCamelCase_   ,  lowerCamelCase_				)
			if index != len(lowerCamelCase_				) and sorted_collection[index] == item:
						return index
			return None

def        UpperCAmelCase__		(						lowerCamelCase_       :       list[int]   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int				):
			if right < left:
						return None

			__a						:  Optional[Any]									=     left + (right - left) // 2

			if sorted_collection[midpoint] == item:
						return midpoint
			elif sorted_collection[midpoint] > item:
						return binary_search_by_recursion(lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_   ,  midpoint - 1				)
			else:
						return binary_search_by_recursion(lowerCamelCase_   ,  lowerCamelCase_   ,  midpoint + 1   ,  lowerCamelCase_				)


if __name__ == "__main__":
							SCREAMING_SNAKE_CASE__				     =			input('''Enter numbers separated by comma:\n''').strip()
							SCREAMING_SNAKE_CASE__				     =			sorted(int(item) for item in user_input.split(''','''))
							SCREAMING_SNAKE_CASE__				     =			int(input('''Enter a single number to be found in the list:\n'''))
							SCREAMING_SNAKE_CASE__				     =			binary_search(collection, target)
							if result is None:
														print(F"{target} was not found in {collection}.")
							else:
														print(F"{target} was found at position {result} in {collection}.")









'''simple docstring'''

from math import sqrt

def _SCREAMING_SNAKE_CASE (A = 1_000_000			)			->			int:






       """simple docstring"""







       lowercase__      =					0
       lowercase__      =					0
       lowercase__      =					42

       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(A    ,					sum_shortest_sides // 2			)
                                - max(1    ,					sum_shortest_sides - max_cuboid_size			)
                                + 1
                            )

       return max_cuboid_size


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




