



from __future__ import annotations

from collections.abc import Iterator
from typing import Any

class    _SCREAMING_SNAKE_CASE						:





     def __init__(							self			:				Tuple  ,	UpperCamelCase			:				Any					)->None:
      __SCREAMING_SNAKE_CASE							:     Any							=						data
      __SCREAMING_SNAKE_CASE							:     Node | None							=						None






     def __str__(							self			:				int					)->str:
      return F"""{self.data}"""






class    _SCREAMING_SNAKE_CASE						:





     def __init__(							self			:				int					)->None:
      __SCREAMING_SNAKE_CASE							:     Node | None							=						None
      __SCREAMING_SNAKE_CASE							:     Node | None							=						None





     def __iter__(							self			:				Optional[Any]					)->Iterator[Any]:
      __SCREAMING_SNAKE_CASE							:     Any							=						self.front
      while node:
       yield node.data
       __SCREAMING_SNAKE_CASE							:     Tuple							=						node.next





     def __len__(							self			:				Tuple					)->int:
      return len(tuple(iter(self					)					)					)





     def __str__(							self			:				List[str]					)->str:
      return " <- ".join(str(UpperCamelCase					) for item in self					)





     def 						__snake_case     (							self			:				int					)->bool:
      return len(self					) == 0





     def 						__snake_case     (							self			:				Optional[Any]  ,	UpperCamelCase			:				Any					)->None:
      __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						Node(UpperCamelCase					)
      if self.is_empty():
       __SCREAMING_SNAKE_CASE							:     Dict							=						node
      else:
       assert isinstance(self.rear  ,	UpperCamelCase					)
       __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						node
       __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						node





     def 						__snake_case     (							self			:				List[Any]					)->Any:
      if self.is_empty():
       raise IndexError("dequeue from empty queue"					)
      assert isinstance(self.front  ,	UpperCamelCase					)
      __SCREAMING_SNAKE_CASE							:     List[str]							=						self.front
      __SCREAMING_SNAKE_CASE							:     int							=						self.front.next
      if self.front is None:
       __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						None
      return node.data






     def 						__snake_case     (							self			:				List[str]					)->None:
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						None


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

      testmod()









"""simple docstring"""





def     _A    (    UpperCamelCase_	:			str)      ->		int:
   '''simple docstring'''


   __lowercase								=		0
   for plain_chr in plain_text:
      __lowercase								=		(
          ord(UpperCamelCase_) + (hash_value << 6) + (hash_value << 16) - hash_value
      )
   return hash_value




