
A  :			List[str]     				=				1_0_0_0

def 					__lowerCAmelCase    (    a__						) ->						float:
				return x * x

def 					__lowerCAmelCase    (    a__		,					a__		,					a__		,					a__ = 4						) ->						float:
				assert callable(
				    a__						), F"""the function(object) passed should be callable your input : {function}"""
				assert isinstance(a__		,					(float, int)						), F"""a should be float or integer your input : {a}"""
				assert isinstance(function(a__						)		,					(float, int)						), (
				    "the function should return integer or float return type of your function, "
				    F"""{type(a__						)}"""
				)
				assert isinstance(a__		,					(float, int)						), F"""b should be float or integer your input : {b}"""
				assert (
				    isinstance(a__		,					a__						) and precision > 0
				), F"""precision should be positive integer your input : {precision}"""

				# just applying the formula of simpson for approximate integration written in
				# mentioned article in first comment of this file and above this function

				__a    							=					(b - a) / N_STEPS
				__a    							=					function(a__						) + function(a__						)

				for i in range(1		,					a__						):
								__a    							=					a + h * i
								result += function(a__						) * (4 if i % 2 else 2)

				result *= h / 3
				return round(a__		,					a__						)


if __name__ == "__main__":
					import doctest

					doctest.testmod()

def 					__lowerCAmelCase    (    a__ = 99_8001						) ->						int:
				__a    							=					0
				for i in range(999		,					99		,					-1						):  # 3 digit numbers range from 999 down to 100
								for j in range(999		,					99		,					-1						):
												__a    							=					str(i * j						)
												if product_string == product_string[::-1] and i * j < n:
																__a    							=					max(a__		,					i * j						)
				return answer


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