






def _UpperCAmelCase   (	a						:	list[int] ):
							if not numbers:
														return 0

							if not isinstance(a  ,					(list, tuple) ) or not all(
							    isinstance(a  ,					a ) for number in numbers ):
														raise ValueError("""numbers must be an iterable of integers""" )

							snake_case__	  =       snake_case__	  =       snake_case__	  =       numbers[0]

							for i in range(1  ,					len(a ) ):
														# update the maximum and minimum subarray products
														snake_case__	  =       numbers[i]
														if number < 0:
																					snake_case__  , snake_case__	  =       min_till_now, max_till_now
														snake_case__	  =       max(a  ,					max_till_now * number )
														snake_case__	  =       min(a  ,					min_till_now * number )

														# update the maximum product found till now
														snake_case__	  =       max(a  ,					a )

							return max_prod








def _UpperCAmelCase   (	a						:	int  ,					a						:	Optional[Any] ):
							# "extended trapezoidal rule"
							# int(f) = dx/2 * (f1 + 2f2 + ... + fn)
							snake_case__	  =       (boundary[1] - boundary[0]) / steps
							snake_case__	  =       boundary[0]
							snake_case__	  =       boundary[1]
							snake_case__	  =       make_points(a  ,					a  ,					a )
							snake_case__	  =       0.0
							y += (h / 2.0) * f(a )
							for i in x_i:
														# print(i)
														y += h * f(a )
							y += (h / 2.0) * f(a )
							return y

def _UpperCAmelCase   (	a						:	Dict  ,					a						:	Union[str, Any]  ,					a						:	Union[str, Any] ):
							snake_case__	  =       a + h
							while x < (b - h):
														yield x
														snake_case__	  =       x + h

def _UpperCAmelCase   (	a						:	Any ):  # enter your function here
							snake_case__	  =       (x - 0) * (x - 0)
							return y

def _UpperCAmelCase   (	):
							snake_case__	  =       0.0  # Lower bound of integration
							snake_case__	  =       1.0  # Upper bound of integration
							snake_case__	  =       10.0  # define number of steps or resolution
							snake_case__	  =       [a, b]  # define boundary of integration
							snake_case__	  =       method_a(a  ,					a )
							print(F'''y = {y}''' )


if __name__ == "__main__":
	main()
