




from collections import deque
from math import floor
from random import random
from time import time




class 			UpperCAmelCase_      :




							'''simple docstring'''



							def __init__(					self       :	Dict			)			->					Dict:
										SCREAMING_SNAKE_CASE           =					{}





							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	str       ,     a       :	Dict       ,     a       :	Optional[Any]=1			)			->					str:
										if self.graph.get(a			):
													if self.graph[u].count([w, v]			) == 0:
																self.graph[u].append([w, v]			)
										else:
													SCREAMING_SNAKE_CASE           =					[[w, v]]
										if not self.graph.get(a			):
													SCREAMING_SNAKE_CASE           =					[]





							def    _UpperCAmelCase     (					self       :	Tuple			)			->					Any:
										return list(self.graph			)





							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	Optional[Any]       ,     a       :	Tuple			)			->					Any:
										if self.graph.get(a			):
													for _ in self.graph[u]:
																if _[1] == v:
																			self.graph[u].remove(a			)





							def    _UpperCAmelCase     (					self       :	List[Any]       ,     a       :	Any=-2       ,     a       :	str=-1			)			->					Any:
										if s == d:
													return []
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										if s == -2:
													SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					s

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if visited.count(node[1]			) < 1:
																						if node[1] == d:
																									visited.append(a			)
																									return visited
																						else:
																									stack.append(node[1]			)
																									visited.append(node[1]			)
																									SCREAMING_SNAKE_CASE           =					node[1]
																									break

            # check if all the children are visited
													if s == ss:
																stack.pop()
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return visited





							def    _UpperCAmelCase     (					self       :	Optional[Any]       ,     a       :	Union[str, Any]=-1			)			->					Tuple:
										if c == -1:
													SCREAMING_SNAKE_CASE           =					floor(random() * 10_000			) + 10
										for i in range(a			):
													# every vertex has max 100 edges
													for _ in range(floor(random() * 102			) + 1			):
																SCREAMING_SNAKE_CASE           =					floor(random() * c			) + 1
																if n != i:
																			self.add_pair(a       ,     a       ,     1			)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	int=-2			)			->					Optional[Any]:
										SCREAMING_SNAKE_CASE           =					deque()
										SCREAMING_SNAKE_CASE           =					[]
										if s == -2:
													SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										d.append(a			)
										visited.append(a			)
										while d:
													SCREAMING_SNAKE_CASE           =					d.popleft()
													if len(self.graph[s]			) != 0:
																for node in self.graph[s]:
																			if visited.count(node[1]			) < 1:
																						d.append(node[1]			)
																						visited.append(node[1]			)
										return visited





							def    _UpperCAmelCase     (					self       :	Optional[int]       ,     a       :	List[str]			)			->					Optional[Any]:
										SCREAMING_SNAKE_CASE           =					0
										for x in self.graph:
													for y in self.graph[x]:
																if y[1] == u:
																			count += 1
										return count





							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	Any			)			->					Dict:
										return len(self.graph[u]			)





							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	Tuple=-2			)			->					Optional[int]:
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										if s == -2:
													SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					s
										SCREAMING_SNAKE_CASE           =					[]

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if visited.count(node[1]			) < 1:
																						stack.append(node[1]			)
																						visited.append(node[1]			)
																						SCREAMING_SNAKE_CASE           =					node[1]
																						break

            # check if all the children are visited
													if s == ss:
																sorted_nodes.append(stack.pop()			)
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return sorted_nodes





							def    _UpperCAmelCase     (					self       :	Optional[Any]			)			->					Any:
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					-2
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					s
										SCREAMING_SNAKE_CASE           =					False
										SCREAMING_SNAKE_CASE           =					set()

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if (
																			    visited.count(node[1]			) > 0
																			    and node[1] != parent
																			    and indirect_parents.count(node[1]			) > 0
																			    and not on_the_way_back
																			):
																						SCREAMING_SNAKE_CASE           =					len(a			) - 1
																						while len_stack >= 0:
																									if stack[len_stack] == node[1]:
																												anticipating_nodes.add(node[1]			)
																												break
																									else:
																												anticipating_nodes.add(stack[len_stack]			)
																												len_stack -= 1
																			if visited.count(node[1]			) < 1:
																						stack.append(node[1]			)
																						visited.append(node[1]			)
																						SCREAMING_SNAKE_CASE           =					node[1]
																						break

            # check if all the children are visited
													if s == ss:
																stack.pop()
																SCREAMING_SNAKE_CASE           =					True
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					False
																indirect_parents.append(a			)
																SCREAMING_SNAKE_CASE           =					s
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return list(a			)





							def    _UpperCAmelCase     (					self       :	Dict			)			->					Optional[int]:
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					-2
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					s
										SCREAMING_SNAKE_CASE           =					False
										SCREAMING_SNAKE_CASE           =					set()

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if (
																			    visited.count(node[1]			) > 0
																			    and node[1] != parent
																			    and indirect_parents.count(node[1]			) > 0
																			    and not on_the_way_back
																			):
																						SCREAMING_SNAKE_CASE           =					len(a			) - 1
																						while len_stack_minus_one >= 0:
																									if stack[len_stack_minus_one] == node[1]:
																												anticipating_nodes.add(node[1]			)
																												break
																									else:
																												return True
																			if visited.count(node[1]			) < 1:
																						stack.append(node[1]			)
																						visited.append(node[1]			)
																						SCREAMING_SNAKE_CASE           =					node[1]
																						break

            # check if all the children are visited
													if s == ss:
																stack.pop()
																SCREAMING_SNAKE_CASE           =					True
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					False
																indirect_parents.append(a			)
																SCREAMING_SNAKE_CASE           =					s
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return False





							def    _UpperCAmelCase     (					self       :	Optional[Any]       ,     a       :	Union[str, Any]=-2       ,     a       :	Tuple=-1			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					time()
										self.dfs(a       ,     a			)
										SCREAMING_SNAKE_CASE           =					time()
										return end - begin







							def    _UpperCAmelCase     (					self       :	List[str]       ,     a       :	List[str]=-2			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					time()
										self.bfs(a			)
										SCREAMING_SNAKE_CASE           =					time()
										return end - begin





class 			UpperCAmelCase_      :




							'''simple docstring'''



							def __init__(					self       :	Optional[Any]			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					{}





							def    _UpperCAmelCase     (					self       :	str       ,     a       :	Union[str, Any]       ,     a       :	Optional[int]       ,     a       :	Dict=1			)			->					Tuple:
										# check if the u exists
										if self.graph.get(a			):
													# if there already is a edge
													if self.graph[u].count([w, v]			) == 0:
																self.graph[u].append([w, v]			)
										else:
													# if u does not exist
													SCREAMING_SNAKE_CASE           =					[[w, v]]
										# add the other way
										if self.graph.get(a			):
													# if there already is a edge
													if self.graph[v].count([w, u]			) == 0:
																self.graph[v].append([w, u]			)
										else:
													# if u does not exist
													SCREAMING_SNAKE_CASE           =					[[w, u]]





							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	Any       ,     a       :	Any			)			->					List[str]:
										if self.graph.get(a			):
													for _ in self.graph[u]:
																if _[1] == v:
																			self.graph[u].remove(a			)
        # the other way round
										if self.graph.get(a			):
													for _ in self.graph[v]:
																if _[1] == u:
																			self.graph[v].remove(a			)





							def    _UpperCAmelCase     (					self       :	List[Any]       ,     a       :	Any=-2       ,     a       :	str=-1			)			->					str:
										if s == d:
													return []
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										if s == -2:
													SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					s

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if visited.count(node[1]			) < 1:
																						if node[1] == d:
																									visited.append(a			)
																									return visited
																						else:
																									stack.append(node[1]			)
																									visited.append(node[1]			)
																									SCREAMING_SNAKE_CASE           =					node[1]
																									break

            # check if all the children are visited
													if s == ss:
																stack.pop()
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return visited





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	Dict=-1			)			->					str:
										if c == -1:
													SCREAMING_SNAKE_CASE           =					floor(random() * 10_000			) + 10
										for i in range(a			):
													# every vertex has max 100 edges
													for _ in range(floor(random() * 102			) + 1			):
																SCREAMING_SNAKE_CASE           =					floor(random() * c			) + 1
																if n != i:
																			self.add_pair(a       ,     a       ,     1			)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	Tuple=-2			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE           =					deque()
										SCREAMING_SNAKE_CASE           =					[]
										if s == -2:
													SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										d.append(a			)
										visited.append(a			)
										while d:
													SCREAMING_SNAKE_CASE           =					d.popleft()
													if len(self.graph[s]			) != 0:
																for node in self.graph[s]:
																			if visited.count(node[1]			) < 1:
																						d.append(node[1]			)
																						visited.append(node[1]			)
										return visited





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	Dict			)			->					List[str]:
										return len(self.graph[u]			)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]			)			->					List[str]:
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					-2
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					s
										SCREAMING_SNAKE_CASE           =					False
										SCREAMING_SNAKE_CASE           =					set()

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if (
																			    visited.count(node[1]			) > 0
																			    and node[1] != parent
																			    and indirect_parents.count(node[1]			) > 0
																			    and not on_the_way_back
																			):
																						SCREAMING_SNAKE_CASE           =					len(a			) - 1
																						while len_stack >= 0:
																									if stack[len_stack] == node[1]:
																												anticipating_nodes.add(node[1]			)
																												break
																									else:
																												anticipating_nodes.add(stack[len_stack]			)
																												len_stack -= 1
																			if visited.count(node[1]			) < 1:
																						stack.append(node[1]			)
																						visited.append(node[1]			)
																						SCREAMING_SNAKE_CASE           =					node[1]
																						break

            # check if all the children are visited
													if s == ss:
																stack.pop()
																SCREAMING_SNAKE_CASE           =					True
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					False
																indirect_parents.append(a			)
																SCREAMING_SNAKE_CASE           =					s
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return list(a			)





							def    _UpperCAmelCase     (					self       :	Optional[Any]			)			->					Optional[int]:
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					-2
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					s
										SCREAMING_SNAKE_CASE           =					False
										SCREAMING_SNAKE_CASE           =					set()

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if (
																			    visited.count(node[1]			) > 0
																			    and node[1] != parent
																			    and indirect_parents.count(node[1]			) > 0
																			    and not on_the_way_back
																			):
																						SCREAMING_SNAKE_CASE           =					len(a			) - 1
																						while len_stack_minus_one >= 0:
																									if stack[len_stack_minus_one] == node[1]:
																												anticipating_nodes.add(node[1]			)
																												break
																									else:
																												return True
																			if visited.count(node[1]			) < 1:
																						stack.append(node[1]			)
																						visited.append(node[1]			)
																						SCREAMING_SNAKE_CASE           =					node[1]
																						break

            # check if all the children are visited
													if s == ss:
																stack.pop()
																SCREAMING_SNAKE_CASE           =					True
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					False
																indirect_parents.append(a			)
																SCREAMING_SNAKE_CASE           =					s
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return False





							def    _UpperCAmelCase     (					self       :	Tuple			)			->					List[Any]:
										return list(self.graph			)





							def    _UpperCAmelCase     (					self       :	int       ,     a       :	List[str]=-2       ,     a       :	str=-1			)			->					Any:
										SCREAMING_SNAKE_CASE           =					time()
										self.dfs(a       ,     a			)
										SCREAMING_SNAKE_CASE           =					time()
										return end - begin







							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	Optional[int]=-2			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					time()
										self.bfs(a			)
										SCREAMING_SNAKE_CASE           =					time()
										return end - begin












from __future__ import annotations

import typing
from collections.abc import Iterable

import numpy as np

__A						:							Dict							=  typing.Union[Iterable[float], Iterable[int], np.ndarray]  # noqa: UP007
__A						:							Tuple							=  typing.Union[np.floataa, int, float]  # noqa: UP007
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			return np.sqrt(np.sum((np.asarray(SCREAMING_SNAKE_CASE   ) - np.asarray(SCREAMING_SNAKE_CASE   )) ** 2   )   )
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			return sum((va - va) ** 2 for va, va in zip(SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   )   ) ** (1 / 2)


if __name__ == "__main__":
		def 					lowerCamelCase_    (    ):
					'''simple docstring'''
					from timeit import timeit

					print("""Without Numpy"""   )
					print(
					    timeit(
					        """euclidean_distance_no_np([1, 2, 3], [4, 5, 6])"""					,	number=1_00_00					,	globals=globals()					,	)   )
					print("""With Numpy"""   )
					print(
					    timeit(
					        """euclidean_distance([1, 2, 3], [4, 5, 6])"""					,	number=1_00_00					,	globals=globals()					,	)   )




		benchmark()






