






def 						_UpperCamelCase (     UpperCamelCase_							:       List[Any]     ,							UpperCamelCase_							:       str		)	-> str:

						"""simple docstring"""



						lowerCAmelCase__         =    (boundary[1] - boundary[0]) / steps
						lowerCAmelCase__         =    boundary[0]
						lowerCAmelCase__         =    boundary[1]
						lowerCAmelCase__         =    make_points(UpperCamelCase_     ,							UpperCamelCase_     ,							UpperCamelCase_		)
						lowerCAmelCase__         =    0.0
						y += (h / 3.0) * f(UpperCamelCase_		)
						lowerCAmelCase__         =    2
						for i in x_i:
												y += (h / 3) * (4 - 2 * (cnt % 2)) * f(UpperCamelCase_		)
												cnt += 1
						y += (h / 3.0) * f(UpperCamelCase_		)
						return y







def 						_UpperCamelCase (     UpperCamelCase_							:       Union[str, Any]     ,							UpperCamelCase_							:       List[str]     ,							UpperCamelCase_							:       Optional[int]		)	-> str:

						"""simple docstring"""



						lowerCAmelCase__         =    a + h
						while x < (b - h):
												yield x
												lowerCAmelCase__         =    x + h







def 						_UpperCamelCase (     UpperCamelCase_							:       Union[str, Any]		)	-> int:  # enter your function here

						"""simple docstring"""



						lowerCAmelCase__         =    (x - 0) * (x - 0)
						return y







def 						_UpperCamelCase (     )	-> Any:

						"""simple docstring"""



						lowerCAmelCase__         =    0.0  # Lower bound of integration
						lowerCAmelCase__         =    1.0  # Upper bound of integration
						lowerCAmelCase__         =    10.0  # define number of steps or resolution
						lowerCAmelCase__         =    [a, b]  # define boundary of integration
						lowerCAmelCase__         =    method_a(UpperCamelCase_     ,							UpperCamelCase_		)
						print(F"y = {y}"		)


if __name__ == "__main__":
					main()













from __future__ import annotations

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

__snake_case     :     str       =  TypeVar("""T""", bound=bool)


class      __SCREAMING_SNAKE_CASE       ( Generic[T]):






						def __init__(						self  ,    _UpperCamelCase ):






												"""simple docstring"""
												lowerCAmelCase__         =    value
												lowerCAmelCase__         =    None
												lowerCAmelCase__         =    None






						@property
						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												return self._value







						@staticmethod
						def    UpperCamelCase__   (						_UpperCamelCase  ,    _UpperCamelCase ):






												"""simple docstring"""
												if not roota:
																		return roota

												if not roota:
																		return roota

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

												lowerCAmelCase__         =    roota
												lowerCAmelCase__         =    roota.right
												lowerCAmelCase__         =    roota.left
												lowerCAmelCase__         =    SkewNode.merge(_UpperCamelCase  ,    _UpperCamelCase )

												return result




class      __SCREAMING_SNAKE_CASE       ( Generic[T]):






						def __init__(						self  ,    _UpperCamelCase = () ):






												"""simple docstring"""
												lowerCAmelCase__         =    None
												if data:
																		for item in data:
																								self.insert(_UpperCamelCase )






						def __bool__(						self ):






												"""simple docstring"""
												return self._root is not None






						def __iter__(						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    []
												while self:
																		result.append(self.pop() )

												# Pushing items back to the heap not to clear it.
												for item in result:
																		self.insert(_UpperCamelCase )

												return iter(_UpperCamelCase )






						def    UpperCamelCase__   (						self  ,    _UpperCamelCase ):






												"""simple docstring"""
												lowerCAmelCase__         =    SkewNode.merge(self._root  ,    SkewNode(_UpperCamelCase ) )






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    self.top()
												lowerCAmelCase__         =    (
												    SkewNode.merge(self._root.left  ,    self._root.right ) if self._root else None
												)

												return result






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												if not self._root:
																		raise IndexError('Can\'t get top element for the empty heap.' )
												return self._root.value







						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    None


if __name__ == "__main__":
					import doctest

					doctest.testmod()





