



from ..utils import DummyObject, requires_backends
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   Dict       						=["""flax"""]




				def __init__(  self   :  Dict,   *__lowercase   :  List[str],   **__lowercase   :  Union[str, Any]  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Union[str, Any],   *__lowercase   :  str,   **__lowercase   :  List[Any]  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Dict,   *__lowercase   :  Optional[Any],   **__lowercase   :  str  ):
							requires_backends(cls,   ["flax"]  )
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   List[Any]       						=["""flax"""]




				def __init__(  self   :  Union[str, Any],   *__lowercase   :  Tuple,   **__lowercase   :  Any  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Any,   *__lowercase   :  Optional[int],   **__lowercase   :  Any  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Optional[int],   *__lowercase   :  int,   **__lowercase   :  Dict  ):
							requires_backends(cls,   ["flax"]  )
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   int       						=["""flax"""]




				def __init__(  self   :  int,   *__lowercase   :  List[Any],   **__lowercase   :  Optional[int]  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Any,   *__lowercase   :  Optional[Any],   **__lowercase   :  str  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Optional[int],   *__lowercase   :  Dict,   **__lowercase   :  List[Any]  ):
							requires_backends(cls,   ["flax"]  )
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   Union[str, Any]       						=["""flax"""]




				def __init__(  self   :  Optional[int],   *__lowercase   :  Tuple,   **__lowercase   :  Optional[int]  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Union[str, Any],   *__lowercase   :  Optional[int],   **__lowercase   :  Union[str, Any]  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Dict,   *__lowercase   :  Optional[int],   **__lowercase   :  Optional[Any]  ):
							requires_backends(cls,   ["flax"]  )
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   Any       						=["""flax"""]




				def __init__(  self   :  Any,   *__lowercase   :  int,   **__lowercase   :  Optional[Any]  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Union[str, Any],   *__lowercase   :  int,   **__lowercase   :  int  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Tuple,   *__lowercase   :  List[Any],   **__lowercase   :  Any  ):
							requires_backends(cls,   ["flax"]  )
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   Dict       						=["""flax"""]




				def __init__(  self   :  Any,   *__lowercase   :  List[str],   **__lowercase   :  Tuple  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  List[str],   *__lowercase   :  Dict,   **__lowercase   :  List[str]  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Any,   *__lowercase   :  Union[str, Any],   **__lowercase   :  Union[str, Any]  ):
							requires_backends(cls,   ["flax"]  )
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   Optional[Any]       						=["""flax"""]




				def __init__(  self   :  List[str],   *__lowercase   :  Union[str, Any],   **__lowercase   :  Dict  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  List[str],   *__lowercase   :  List[str],   **__lowercase   :  Union[str, Any]  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  int,   *__lowercase   :  List[Any],   **__lowercase   :  Dict  ):
							requires_backends(cls,   ["flax"]  )
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   List[str]       						=["""flax"""]




				def __init__(  self   :  Dict,   *__lowercase   :  str,   **__lowercase   :  int  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Optional[int],   *__lowercase   :  Dict,   **__lowercase   :  Tuple  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Any,   *__lowercase   :  Any,   **__lowercase   :  Union[str, Any]  ):
							requires_backends(cls,   ["flax"]  )
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   Optional[Any]       						=["""flax"""]




				def __init__(  self   :  Union[str, Any],   *__lowercase   :  List[Any],   **__lowercase   :  int  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Tuple,   *__lowercase   :  Dict,   **__lowercase   :  Dict  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  List[str],   *__lowercase   :  Union[str, Any],   **__lowercase   :  int  ):
							requires_backends(cls,   ["flax"]  )
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   int       						=["""flax"""]




				def __init__(  self   :  Dict,   *__lowercase   :  Dict,   **__lowercase   :  Union[str, Any]  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Dict,   *__lowercase   :  Tuple,   **__lowercase   :  Optional[int]  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  int,   *__lowercase   :  str,   **__lowercase   :  Optional[int]  ):
							requires_backends(cls,   ["flax"]  )
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   Any       						=["""flax"""]




				def __init__(  self   :  Any,   *__lowercase   :  Any,   **__lowercase   :  Optional[int]  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Tuple,   *__lowercase   :  List[str],   **__lowercase   :  int  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  List[str],   *__lowercase   :  List[str],   **__lowercase   :  Optional[Any]  ):
							requires_backends(cls,   ["flax"]  )
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   int       						=["""flax"""]




				def __init__(  self   :  List[str],   *__lowercase   :  str,   **__lowercase   :  Optional[int]  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  List[Any],   *__lowercase   :  Tuple,   **__lowercase   :  Tuple  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Optional[Any],   *__lowercase   :  List[Any],   **__lowercase   :  List[str]  ):
							requires_backends(cls,   ["flax"]  )
class 			_snake_case     (   metaclass=lowercase__):
				UpperCamelCase__			:   Optional[int]       						=["""flax"""]




				def __init__(  self   :  List[Any],   *__lowercase   :  List[str],   **__lowercase   :  List[str]  ):
							requires_backends(self,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  Optional[int],   *__lowercase   :  int,   **__lowercase   :  List[Any]  ):
							requires_backends(cls,   ["flax"]  )




				@classmethod
				def 							A__ (  cls   :  List[str],   *__lowercase   :  Union[str, Any],   **__lowercase   :  str  ):
							requires_backends(cls,   ["flax"]  )









from graphs.minimum_spanning_tree_kruskal import kruskal



def __lowerCAmelCase	(       ):
			lowercase__   					=			9
			lowercase__   					=			[
			    [0, 1, 4],
			    [0, 7, 8],
			    [1, 2, 8],
			    [7, 8, 7],
			    [7, 6, 1],
			    [2, 8, 2],
			    [8, 6, 6],
			    [2, 3, 7],
			    [2, 5, 4],
			    [6, 5, 2],
			    [3, 5, 14],
			    [3, 4, 9],
			    [5, 4, 10],
			    [1, 7, 11],
			]

			lowercase__   					=			kruskal(SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_					)

			lowercase__   					=			[
			    [7, 6, 1],
			    [2, 8, 2],
			    [6, 5, 2],
			    [0, 1, 4],
			    [2, 5, 4],
			    [2, 3, 7],
			    [0, 7, 8],
			    [3, 4, 9],
			]

			assert sorted(SCREAMING_SNAKE_CASE_					) == sorted(SCREAMING_SNAKE_CASE_					)




