





from __future__ import annotations

from typing import Any



class        _SCREAMING_SNAKE_CASE						:







 '''simple docstring'''

 def __init__(self    :       Union[str, Any]	,			UpperCAmelCase_    :       int = 6)	->None:



   '''simple docstring'''



   lowerCamelCase__:				Node | None        =None
   lowerCamelCase__:				Node | None        =None
   self.create_linked_list(_SCREAMING_SNAKE_CASE)

 def 							SCREAMING_SNAKE_CASE_ (self    :       List[Any]	,			UpperCAmelCase_    :       int)	->None:



   '''simple docstring'''



   lowerCamelCase__:				Optional[int]        =Node()
   lowerCamelCase__:				str        =current_node
   lowerCamelCase__:				int        =current_node
   lowerCamelCase__:				Union[str, Any]        =current_node
   for _ in range(1	,			_SCREAMING_SNAKE_CASE):
     lowerCamelCase__:				List[str]        =Node()
     lowerCamelCase__:				int        =current_node
     lowerCamelCase__:				str        =previous_node
     lowerCamelCase__:				Optional[Any]        =current_node
   lowerCamelCase__:				List[Any]        =self.front
   lowerCamelCase__:				List[str]        =previous_node

 def 							SCREAMING_SNAKE_CASE_ (self    :       Optional[int])	->bool:



   '''simple docstring'''



   return (
       self.front == self.rear
       and self.front is not None
       and self.front.data is None
   )

 def 							SCREAMING_SNAKE_CASE_ (self    :       List[str])	->Any | None:



   '''simple docstring'''



   self.check_can_perform_operation()
   return self.front.data if self.front else None

 def 							SCREAMING_SNAKE_CASE_ (self    :       List[str]	,			UpperCAmelCase_    :       Any)	->None:



   '''simple docstring'''



   if self.rear is None:
     return

   self.check_is_full()
   if not self.is_empty():
     lowerCamelCase__:				Optional[int]        =self.rear.next
   if self.rear:
     lowerCamelCase__:				Optional[int]        =data

 def 							SCREAMING_SNAKE_CASE_ (self    :       str)	->Any:



   '''simple docstring'''



   self.check_can_perform_operation()
   if self.rear is None or self.front is None:
     return None
   if self.front == self.rear:
     lowerCamelCase__:				str        =self.front.data
     lowerCamelCase__:				Tuple        =None
     return data

   lowerCamelCase__:				List[Any]        =self.front
   lowerCamelCase__:				Tuple        =old_front.next
   lowerCamelCase__:				List[str]        =old_front.data
   lowerCamelCase__:				List[str]        =None
   return data

 def 							SCREAMING_SNAKE_CASE_ (self    :       str)	->None:



   '''simple docstring'''



   if self.is_empty():
     raise Exception("Empty Queue")







 def 							SCREAMING_SNAKE_CASE_ (self    :       Union[str, Any])	->None:



   '''simple docstring'''



   if self.rear and self.rear.next == self.front:
     raise Exception("Full Queue")



class        _SCREAMING_SNAKE_CASE						:







 '''simple docstring'''

 def __init__(self    :       Optional[Any])	->None:



   '''simple docstring'''



   lowerCamelCase__:				Any | None        =None
   lowerCamelCase__:				Node | None        =None
   lowerCamelCase__:				Node | None        =None


if __name__ == "__main__":
     import doctest

     doctest.testmod()







def 					lowerCAmelCase_			(	__a		)					->		str:







  """simple docstring"""





  if isinstance(__a     ,   __a		):
    raise TypeError("'float' object cannot be interpreted as an integer"		)
  if isinstance(__a     ,   __a		):
    raise TypeError("'str' object cannot be interpreted as an integer"		)

  if num == 0:
    return "0b0"

  lowerCamelCase__:				Optional[int]        =False

  if num < 0:
    lowerCamelCase__:				Optional[Any]        =True
    lowerCamelCase__:				List[Any]        =-num

  lowerCamelCase__:				list[int]        =[]
  while num > 0:
    binary.insert(0     ,   num % 2		)
    num >>= 1

  if negative:
    return "-0b" + "".join(str(__a		) for e in binary		)

  return "0b" + "".join(str(__a		) for e in binary		)


if __name__ == "__main__":
     import doctest

     doctest.testmod()

