



'''simple docstring'''



from typing import Any






class 			_SCREAMING_SNAKE_CASE				:



			def __init__(     self		:						List[Any]			)      ->      int:
							"""simple docstring"""





							snake_case__      :   Optional[int]      =    []
							snake_case__      :   List[str]      =    0



			def __str__(     self		:						Any			)      ->      Tuple:
							"""simple docstring"""





							snake_case__      :   Any      =    '''<''' + str(self.stack			)[1:-1] + '''>'''
							return printed



			def 				lowerCAmelCase (     self		:						List[Any]    ,			__UpperCamelCase		:						Any			)      ->      None:
							"""simple docstring"""





							self.stack.append(__UpperCamelCase			)
							snake_case__      :   int      =    self.length + 1



			def 				lowerCAmelCase (     self		:						Union[str, Any]			)      ->      Any:
							"""simple docstring"""





							self.rotate(1			)
							snake_case__      :   Union[str, Any]      =    self.stack[self.length - 1]
							snake_case__      :   Optional[Any]      =    self.stack[:-1]
							self.rotate(self.length - 1			)
							snake_case__      :   Any      =    self.length - 1
							return dequeued



			def 				lowerCAmelCase (     self		:						List[str]    ,			__UpperCamelCase		:						int			)      ->      None:
							"""simple docstring"""





							for _ in range(__UpperCamelCase			):
											snake_case__      :   Any      =    self.stack[0]
											snake_case__      :   Optional[Any]      =    self.stack[1:]
											self.put(__UpperCamelCase			)
											snake_case__      :   List[Any]      =    self.length - 1



			def 				lowerCAmelCase (     self		:						Optional[Any]			)      ->      Any:
							"""simple docstring"""





							snake_case__      :   Any      =    self.get()
							self.put(__UpperCamelCase			)
							self.rotate(self.length - 1			)
							return front



			def 				lowerCAmelCase (     self		:						str			)      ->      int:
							"""simple docstring"""





							return self.length












from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

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

@unique
class        snake_case_				(							lowercase_   ):







   """simple docstring"""



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






@unique
class        snake_case_				(							lowercase_   ):







   """simple docstring"""



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

   @classmethod
   def       SCREAMING_SNAKE_CASE__					(     cls:						type[T]						)	->		dict:


       """simple docstring"""



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

   @classmethod
   def       SCREAMING_SNAKE_CASE__					(     cls:						type[T]						)	->		dict:


       """simple docstring"""



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






def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
    for name_prefix, value_prefix in prefixes.items():
        _lowercase     			=						value / (10**value_prefix)
        if numerical_part > 1:
            return f'''{numerical_part!s} {name_prefix}'''
    return str(_lowercase   )
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    for prefix in BinaryUnit:
        _lowercase     			=						value / (2**prefix.value)
        if numerical_part > 1:
            return f'''{numerical_part!s} {prefix.name}'''
    return str(_lowercase   )


if __name__ == "__main__":
   import doctest

   doctest.testmod()
