



'''simple docstring'''

def 		_snake_case		(					)			->						int:







	"""simple docstring"""

	for a in range(300							):
		for b in range(a + 1							,		400							):
			for c in range(b + 1							,		500							):
				if (a + b + c) == 1_000 and (a**2) + (b**2) == (c**2):
					return a * b * c

	return -1






def 		_snake_case		(					)			->						int:







	"""simple docstring"""

	for a in range(300							):
		for b in range(400							):
			lowerCAmelCase    =	1_000 - a - b
			if a < b < c and (a**2) + (b**2) == (c**2):
				return a * b * c

	return -1






def 		_snake_case		(					)			->						None:







	"""simple docstring"""
	import timeit

	print(
	    timeit.timeit("""solution()"""							,		setup="""from __main__ import solution"""							,		number=1_000							)							)
	print(
	    timeit.timeit(
	        """solution_fast()"""							,		setup="""from __main__ import solution_fast"""							,		number=1_000							)							)


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




'''simple docstring'''

from __future__ import annotations

import random
from collections.abc import Iterable
from typing import Any, Generic, TypeVar

UpperCAmelCase			=    TypeVar('T', bound=bool)

class __snake_case(      Generic[T]					):


						'''simple docstring'''



						def __init__(					self	,       A_      )	->	None:
							lowerCAmelCase    =	value
							lowerCAmelCase    =	None
							lowerCAmelCase    =	None


						@property
						def 				__snake_case    (					self      )	->	T:
							return self._value




						@staticmethod
						def 				__snake_case    (					A_	,       A_      )	->	RandomizedHeapNode[T] | None:
							if not roota:
								return roota

							if not roota:
								return roota

							if roota.value > roota.value:
								lowerCAmelCase,   lowerCAmelCase    =	roota, roota

							if random.choice([True, False]      ):
								lowerCAmelCase,   lowerCAmelCase    =	roota.right, roota.left

							lowerCAmelCase    =	RandomizedHeapNode.merge(roota.left	,       A_      )

							return roota







class __snake_case(      Generic[T]					):


						'''simple docstring'''



						def __init__(					self	,       A_ = ()      )	->	None:
							lowerCAmelCase    =	None

							if data:
								for item in data:
									self.insert(A_      )


						def 				__snake_case    (					self	,       A_      )	->	None:
							lowerCAmelCase    =	RandomizedHeapNode.merge(self._root	,       RandomizedHeapNode(A_      )      )


						def 				__snake_case    (					self      )	->	T | None:
							lowerCAmelCase    =	self.top()

							if self._root is None:
								return None

							lowerCAmelCase    =	RandomizedHeapNode.merge(self._root.left	,       self._root.right      )

							return result


						def 				__snake_case    (					self      )	->	T:
							if not self._root:
								raise IndexError("""Can't get top element for the empty heap."""      )
							return self._root.value


						def 				__snake_case    (					self      )	->	None:
							lowerCAmelCase    =	None


						def 				__snake_case    (					self      )	->	list[Any]:
							lowerCAmelCase    =	[]
							while self:
								result.append(self.pop()      )

							return result




						def __bool__(					self      )	->	bool:
							return self._root is not None


if __name__ == "__main__":
				import doctest

				doctest.testmod()