





def 	lowerCamelCase_		(							_UpperCamelCase					,							_UpperCamelCase					)						->		str:






				"""simple docstring"""


				snake_case_		:       Any           =    (boundary[1] - boundary[0]) / steps
				snake_case_		:       List[Any]           =    boundary[0]
				snake_case_		:       Tuple           =    boundary[1]
				snake_case_		:       Any           =    make_points(_UpperCamelCase					,							_UpperCamelCase					,							_UpperCamelCase					)
				snake_case_		:       int           =    0.0
				y += (h / 2.0) * f(_UpperCamelCase					)
				for i in x_i:
								# print(i)
								y += h * f(_UpperCamelCase					)
				y += (h / 2.0) * f(_UpperCamelCase					)
				return y






def 	lowerCamelCase_		(							_UpperCamelCase					,							_UpperCamelCase					,							_UpperCamelCase					)						->		str:






				"""simple docstring"""


				snake_case_		:       Optional[int]           =    a + h
				while x < (b - h):
								yield x
								snake_case_		:       List[Any]           =    x + h






def 	lowerCamelCase_		(							_UpperCamelCase					)						->		Optional[int]:  # enter your function here






				"""simple docstring"""


				snake_case_		:       Any           =    (x - 0) * (x - 0)
				return y






def 	lowerCamelCase_		(							)						->		List[Any]:






				"""simple docstring"""


				snake_case_		:       List[str]           =    0.0  # Lower bound of integration
				snake_case_		:       Dict           =    1.0  # Upper bound of integration
				snake_case_		:       List[Any]           =    10.0  # define number of steps or resolution
				snake_case_		:       Tuple           =    [a, b]  # define boundary of integration
				snake_case_		:       str           =    method_a(_UpperCamelCase					,							_UpperCamelCase					)
				print(f'''y = {y}'''					)


if __name__ == "__main__":
	main()







class     A     :
			'''simple docstring'''




			def __init__(     self  :       Optional[int]  )      ->      Dict:







					"""simple docstring"""






					A__     =  {}






			def   a_			(     self  :       Any  )      ->      None:







					"""simple docstring"""






					print(self.vertex  )
					for i in self.vertex:
							print(__lowerCAmelCase				,      """ -> """				,      """ -> """.join([str(__lowerCAmelCase  ) for j in self.vertex[i]]  )  )






			def   a_			(     self  :       Optional[int]				,      __lowerCAmelCase  :       int				,      __lowerCAmelCase  :       int  )      ->      None:







					"""simple docstring"""






					if from_vertex in self.vertex:
							self.vertex[from_vertex].append(__lowerCAmelCase  )
					else:
							# else make a new vertex
							A__     =  [to_vertex]






			def   a_			(     self  :       List[str]  )      ->      None:







					"""simple docstring"""






					A__     =  [False] * len(self.vertex  )

					# call the recursive helper function
					for i in range(len(self.vertex  )  ):
							if not visited[i]:
									self.dfs_recursive(__lowerCAmelCase				,      __lowerCAmelCase  )







			def   a_			(     self  :       List[str]				,      __lowerCAmelCase  :       int				,      __lowerCAmelCase  :       list  )      ->      None:







					"""simple docstring"""






					A__     =  True

					print(__lowerCAmelCase				,      end=""" """  )

					# Recur for all the vertices that are adjacent to this node
					for i in self.vertex:
							if not visited[i]:
									self.dfs_recursive(__lowerCAmelCase				,      __lowerCAmelCase  )


if __name__ == "__main__":
					A       :   Tuple					= Graph()
					g.add_edge(0, 1)
					g.add_edge(0, 2)
					g.add_edge(1, 2)
					g.add_edge(2, 0)
					g.add_edge(2, 3)
					g.add_edge(3, 3)

					g.print_graph()
					print('''DFS:''')
					g.dfs()

					# OUTPUT:
					# 0  ->  1 -> 2
					# 1  ->  2
					# 2  ->  0 -> 3
					# 3  ->  3
					# DFS:
					#  0 1 2 3



