
from __future__ import annotations

from enum import Enum





class 						SCREAMING_SNAKE_CASE__		(A_ ):
     lowercase_   :			List[Any]   =   24
     lowercase_   :			List[Any]   =   21
     lowercase_   :			int   =   18
     lowercase_   :			Optional[int]   =   15
     lowercase_   :			Tuple   =   12
     lowercase_   :			List[str]   =   9
     lowercase_   :			Any   =   6
     lowercase_   :			List[str]   =   3
     lowercase_   :			str   =   2
     lowercase_   :			str   =   1
     lowercase_   :			Optional[int]   =   -1
     lowercase_   :			List[Any]   =   -2
     lowercase_   :			str   =   -3
     lowercase_   :			Tuple   =   -6
     lowercase_   :			Tuple   =   -9
     lowercase_   :			Optional[int]   =   -12
     lowercase_   :			str   =   -15
     lowercase_   :			Optional[Any]   =   -18
     lowercase_   :			Any   =   -21
     lowercase_   :			List[str]   =   -24





class 						SCREAMING_SNAKE_CASE__		(A_ ):
     lowercase_   :			str   =   8
     lowercase_   :			Optional[Any]   =   7
     lowercase_   :			Tuple   =   6
     lowercase_   :			List[Any]   =   5
     lowercase_   :			Optional[Any]   =   4
     lowercase_   :			Union[str, Any]   =   3
     lowercase_   :			Union[str, Any]   =   2
     lowercase_   :			int   =   1



def 		a_       (   __lowerCAmelCase      ,   __lowerCAmelCase      ,   __lowerCAmelCase      ,   ):







  if isinstance(lowercase__      ,   lowercase__							):
    lowerCAmelCase__								=			SIUnit[known_prefix.lower()]
  if isinstance(lowercase__      ,   lowercase__							):
    lowerCAmelCase__								=			SIUnit[unknown_prefix.lower()]
  lowerCAmelCase__								=			known_amount * (
      10 ** (known_prefix.value - unknown_prefix.value)
  )
  return unknown_amount
def 		a_       (   __lowerCAmelCase      ,   __lowerCAmelCase      ,   __lowerCAmelCase      ,   ):







  if isinstance(lowercase__      ,   lowercase__							):
    lowerCAmelCase__								=			BinaryUnit[known_prefix.lower()]
  if isinstance(lowercase__      ,   lowercase__							):
    lowerCAmelCase__								=			BinaryUnit[unknown_prefix.lower()]
  lowerCAmelCase__								=			known_amount * (
      2 ** ((known_prefix.value - unknown_prefix.value) * 10)
  )
  return unknown_amount


if __name__ == "__main__":
      import doctest

      doctest.testmod()







from __future__ import annotations

from collections.abc import Iterator
from typing import Any





class 						SCREAMING_SNAKE_CASE__		:
     def __init__(	self  :		int					,	__lowerCamelCase  :		Any	):



       """simple docstring"""
       lowerCAmelCase__								=			data
       lowerCAmelCase__								=			None



     def __str__(	self  :		int	):



       """simple docstring"""
       return F"""{self.data}"""





class 						SCREAMING_SNAKE_CASE__		:
     def __init__(	self  :		Union[str, Any]	):



       """simple docstring"""
       lowerCAmelCase__								=			None
       lowerCAmelCase__								=			None
     def __iter__(	self  :		List[Any]	):



       """simple docstring"""
       lowerCAmelCase__								=			self.front
       while node:
         yield node.data
         lowerCAmelCase__								=			node.next
     def __len__(	self  :		int	):



       """simple docstring"""
       return len(tuple(iter(self	)	)	)
     def __str__(	self  :		Optional[int]	):



       """simple docstring"""
       return " <- ".join(str(__lowerCamelCase	) for item in self	)
     def 					A__			(	self  :		Tuple	):



       """simple docstring"""
       return len(self	) == 0
     def 					A__			(	self  :		str					,	__lowerCamelCase  :		Any	):



       """simple docstring"""
       lowerCAmelCase__								=			Node(__lowerCamelCase	)
       if self.is_empty():
         lowerCAmelCase__								=			lowerCAmelCase__								=			node
       else:
         assert isinstance(self.rear					,	__lowerCamelCase	)
         lowerCAmelCase__								=			node
         lowerCAmelCase__								=			node
     def 					A__			(	self  :		Optional[Any]	):



       """simple docstring"""
       if self.is_empty():
         raise IndexError('''dequeue from empty queue'''	)
       assert isinstance(self.front					,	__lowerCamelCase	)
       lowerCAmelCase__								=			self.front
       lowerCAmelCase__								=			self.front.next
       if self.front is None:
         lowerCAmelCase__								=			None
       return node.data



     def 					A__			(	self  :		Tuple	):



       """simple docstring"""
       lowerCAmelCase__								=			lowerCAmelCase__								=			None


if __name__ == "__main__":
      from doctest import testmod

      testmod()

