






"""simple docstring"""





from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

# Create a generic variable that can be 'Enum', or any subclass.
UpperCamelCase					=     TypeVar("""T""", bound="""Enum""")







@unique
class 						_a  (		lowercase_       ):





   '''simple docstring'''






   UpperCamelCase__     	=							80
   UpperCamelCase__     	=							70
   UpperCamelCase__     	=							60
   UpperCamelCase__     	=							50
   UpperCamelCase__     	=							40
   UpperCamelCase__     	=							30
   UpperCamelCase__     	=							20
   UpperCamelCase__     	=							10







@unique
class 						_a  (		lowercase_       ):





   '''simple docstring'''






   UpperCamelCase__     	=							24
   UpperCamelCase__     	=							21
   UpperCamelCase__     	=							18
   UpperCamelCase__     	=							15
   UpperCamelCase__     	=							12
   UpperCamelCase__     	=							9
   UpperCamelCase__     	=							6
   UpperCamelCase__     	=							3
   UpperCamelCase__     	=							2
   UpperCamelCase__     	=							1
   UpperCamelCase__     	=							-1
   UpperCamelCase__     	=							-2
   UpperCamelCase__     	=							-3
   UpperCamelCase__     	=							-6
   UpperCamelCase__     	=							-9
   UpperCamelCase__     	=							-12
   UpperCamelCase__     	=							-15
   UpperCamelCase__     	=							-18
   UpperCamelCase__     	=							-21
   UpperCamelCase__     	=							-24





   @classmethod
   def __lowercase							(       cls)			->   dict:




          '''simple docstring'''




          return {unit.name: unit.value for unit in cls if unit.value > 0}





   @classmethod
   def __lowercase							(       cls)			->   dict:




          '''simple docstring'''




          return {unit.name: unit.value for unit in cls if unit.value < 0}







def 							A(    snake_case_						):
       """simple docstring"""





       lowercase__:							Union[str, Any]         =     SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
       for name_prefix, value_prefix in prefixes.items():
              lowercase__:							str         =     value / (10**value_prefix)
              if numerical_part > 1:
                     return F"""{numerical_part!s} {name_prefix}"""
       return str(snake_case_						)






def 							A(    snake_case_						):
       """simple docstring"""





       for prefix in BinaryUnit:
              lowercase__:							Tuple         =     value / (2**prefix.value)
              if numerical_part > 1:
                     return F"""{numerical_part!s} {prefix.name}"""
       return str(snake_case_						)


if __name__ == "__main__":
  import doctest

  doctest.testmod()














__lowerCamelCase						= {0: [1, 2], 1: [0, 3], 2: [0], 3: [1], 4: [5, 6], 5: [4, 6], 6: [4, 5]}

__lowerCamelCase						= {0: [1, 2, 3], 1: [0, 3], 2: [0], 3: [0, 1], 4: [], 5: []}






def    UpperCamelCase__  (   UpperCAmelCase    ,	UpperCAmelCase    ,	UpperCAmelCase     )     ->		list:







							"""simple docstring"""





							_a  :    List[Any]			=						True
							_a  :    Optional[Any]			=						[]

							for neighbour in graph[vert]:
														if not visited[neighbour]:
																					connected_verts += dfs(UpperCAmelCase    ,	UpperCAmelCase    ,	UpperCAmelCase     )

							return [vert, *connected_verts]






def    UpperCamelCase__  (   UpperCAmelCase     )     ->		list:







							"""simple docstring"""





							_a  :    Optional[int]			=						len(UpperCAmelCase     )
							_a  :    Optional[Any]			=						graph_size * [False]
							_a  :    Optional[int]			=						[]

							for i in range(UpperCAmelCase     ):
														if not visited[i]:
																					_a  :    List[str]			=						dfs(UpperCAmelCase    ,	UpperCAmelCase    ,	UpperCAmelCase     )
																					components_list.append(UpperCAmelCase     )

							return components_list


if __name__ == "__main__":
						import doctest

						doctest.testmod()