

from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

# Create a generic variable that can be 'Enum', or any subclass.
__snake_case							:     Optional[int] 						=	TypeVar("""T""", bound="""Enum""")



@unique
class    A__(UpperCAmelCase__    ):
						"""simple docstring"""






						_A  :							List[str]   			=	80
						_A  :							Tuple   			=	70
						_A  :							Optional[int]   			=	60
						_A  :							List[str]   			=	50
						_A  :							List[str]   			=	40
						_A  :							Optional[int]   			=	30
						_A  :							Any   			=	20
						_A  :							Optional[Any]   			=	10







@unique
class    A__(UpperCAmelCase__    ):
						"""simple docstring"""






						_A  :							List[str]   			=	24
						_A  :							int   			=	21
						_A  :							str   			=	18
						_A  :							Any   			=	15
						_A  :							Tuple   			=	12
						_A  :							Optional[int]   			=	9
						_A  :							str   			=	6
						_A  :							str   			=	3
						_A  :							List[str]   			=	2
						_A  :							Any   			=	1
						_A  :							Union[str, Any]   			=	-1
						_A  :							Optional[Any]   			=	-2
						_A  :							Any   			=	-3
						_A  :							Union[str, Any]   			=	-6
						_A  :							Optional[Any]   			=	-9
						_A  :							List[str]   			=	-12
						_A  :							Tuple   			=	-15
						_A  :							Union[str, Any]   			=	-18
						_A  :							int   			=	-21
						_A  :							int   			=	-24





						@classmethod
						def 	UpperCamelCase__			(  cls  )      ->				Dict:
									return {unit.name: unit.value for unit in cls if unit.value > 0}





						@classmethod
						def 	UpperCamelCase__			(  cls  )      ->				Optional[int]:
									return {unit.name: unit.value for unit in cls if unit.value < 0}







def 			_UpperCAmelCase							(		a__):

			'''simple docstring'''



			a_		:		Dict				    =				SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
			for name_prefix, value_prefix in prefixes.items():
						a_		:		Optional[int]				    =				value / (1_0**value_prefix)
						if numerical_part > 1:
									return f'''{numerical_part!s} {name_prefix}'''
			return str(_A)


def 			_UpperCAmelCase							(		a__):

			'''simple docstring'''



			for prefix in BinaryUnit:
						a_		:		Union[str, Any]				    =				value / (2**prefix.value)
						if numerical_part > 1:
									return f'''{numerical_part!s} {prefix.name}'''
			return str(_A)


if __name__ == "__main__":
	import doctest

	doctest.testmod()









def 			_UpperCAmelCase							(		a__):

			'''simple docstring'''



			return 1 if input_a == 0 else 0


def 			_UpperCAmelCase							(		):

			'''simple docstring'''



			assert not_gate(0) == 1
			assert not_gate(1) == 0


if __name__ == "__main__":
	print(not_gate(0))
	print(not_gate(1))


