
'''simple docstring'''
def       _UpperCamelCase	(					)     ->       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) == 1000 and (a**2) + (b**2) == (c**2):
										return a * b * c

		return -1




def       _UpperCamelCase	(					)     ->       int:


		'''simple docstring'''


		for a in range(300 ):
				for b in range(400 ):
						snake_case     :					Dict     =	1000 - a - b
						if a < b < c and (a**2) + (b**2) == (c**2):
								return a * b * c

		return -1




def       _UpperCamelCase	(					)     ->       None:


		'''simple docstring'''


		import timeit

		print(
		    timeit.timeit('''solution()'''   ,					setup='''from __main__ import solution'''   ,					number=1000 ) )
		print(
		    timeit.timeit(
		        '''solution_fast()'''   ,					setup='''from __main__ import solution_fast'''   ,					number=1000 ) )


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




'''simple docstring'''
import numpy as np




def       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__ )     ->       Optional[Any]:


		'''simple docstring'''


		snake_case ,snake_case     :					str     =	a.shape
		snake_case     :					Union[str, Any]     =	min(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )
		snake_case     :					List[Any]     =	np.eye(SCREAMING_SNAKE_CASE__ )
		snake_case     :					Union[str, Any]     =	a.copy()

		for k in range(t - 1 ):
				# select a column of modified matrix A':
				snake_case     :					Union[str, Any]     =	r[k:, [k]]
				# construct first basis vector
				snake_case     :					str     =	np.zeros_like(SCREAMING_SNAKE_CASE__ )
				snake_case     :					List[str]     =	1.0
				# determine scaling factor
				snake_case     :					int     =	np.linalg.norm(SCREAMING_SNAKE_CASE__ )
				# construct vector v for Householder reflection
				snake_case     :					Optional[int]     =	x + np.sign(x[0] ) * alpha * ea
				v /= np.linalg.norm(SCREAMING_SNAKE_CASE__ )

				# construct the Householder matrix
				snake_case     :					Tuple     =	np.eye(m - k ) - 2.0 * v @ v.T
				# pad with ones and zeros as necessary
				snake_case     :					int     =	np.block([[np.eye(SCREAMING_SNAKE_CASE__ ), np.zeros((k, m - k) )], [np.zeros((m - k, k) ), q_k]] )

				snake_case     :					int     =	q @ q_k.T
				snake_case     :					Dict     =	q_k @ r

		return q, r


if __name__ == "__main__":
						import doctest

						doctest.testmod()


