






'''simple docstring'''







class _lowercase     :




							def __init__(							self:    str      ,							UpperCamelCase__:    int					):
														lowerCamelCase__ :     int	  =	size
														lowerCamelCase__ :     Optional[Any]	  =	[0] * size
														lowerCamelCase__ :     str	  =	[0] * size




							@staticmethod
							def 		lowerCamelCase_    (							UpperCamelCase__:    int					):
														return index | (index + 1)




							@staticmethod
							def 		lowerCamelCase_    (							UpperCamelCase__:    int					):
														return (index & (index + 1)) - 1




							def 		lowerCamelCase_    (							self:    Optional[int]      ,							UpperCamelCase__:    int      ,							UpperCamelCase__:    int					):
														lowerCamelCase__ :     int	  =	value
														while index < self.size:
																					lowerCamelCase__ :     Union[str, Any]	  =	self.get_prev(UpperCamelCase__					) + 1
																					if current_left_border == index:
																												lowerCamelCase__ :     Dict	  =	value
																					else:
																												lowerCamelCase__ :     List[Any]	  =	max(UpperCamelCase__      ,							UpperCamelCase__      ,							UpperCamelCase__					)
																					lowerCamelCase__ :     Optional[Any]	  =	self.get_next(UpperCamelCase__					)




							def 		lowerCamelCase_    (							self:    int      ,							UpperCamelCase__:    int      ,							UpperCamelCase__:    int					):
														right -= 1  # Because of right is exclusive
														lowerCamelCase__ :     Union[str, Any]	  =	0
														while left <= right:
																					lowerCamelCase__ :     Any	  =	self.get_prev(UpperCamelCase__					)
																					if left <= current_left:
																												lowerCamelCase__ :     Union[str, Any]	  =	max(UpperCamelCase__      ,							self.tree[right]					)
																												lowerCamelCase__ :     Tuple	  =	current_left
																					else:
																												lowerCamelCase__ :     Any	  =	max(UpperCamelCase__      ,							self.arr[right]					)
																												right -= 1
														return result


if __name__ == "__main__":
			import doctest

			doctest.testmod()









'''simple docstring'''







from __future__ import annotations

import typing
from collections.abc import Iterable

import numpy as np

_A     :      Optional[Any]   					=typing.Union[Iterable[float], Iterable[int], np.ndarray]  # noqa: UP007
_A     :      Optional[int]   					=typing.Union[np.floataa, int, float]  # noqa: UP007





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase    ,      UpperCamelCase				)				->	VectorOut:
							return np.sqrt(np.sum((np.asarray(UpperCamelCase				) - np.asarray(UpperCamelCase				)) ** 2				)				)





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase    ,      UpperCamelCase				)				->	VectorOut:
							return sum((va - va) ** 2 for va, va in zip(UpperCamelCase    ,      UpperCamelCase				)				) ** (1 / 2)


if __name__ == "__main__":





			def 			SCREAMING_SNAKE_CASE_	()				->	None:
										from timeit import timeit

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



			benchmark()

