



from __future__ import annotations

from collections.abc import Iterator
from typing import Any



class 		_lowercase		:

   def __init__(   self      :							List[str]				, __lowerCAmelCase      :							Any				)							->					None:


    """simple docstring"""






    a							=		data
    a							=		None




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


    """simple docstring"""






    return f"""{self.data}"""



class 		_lowercase		:

   def __init__(   self      :							Dict				)							->					None:


    """simple docstring"""






    a							=		None
    a							=		None

   def __iter__(   self      :							Dict				)							->					Iterator[Any]:


    """simple docstring"""






    a							=		self.front
    while node:
     yield node.data
     a							=		node.next

   def __len__(   self      :							Optional[Any]				)							->					int:


    """simple docstring"""






    return len(tuple(iter(self				)				)				)

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


    """simple docstring"""






    return " <- ".join(str(__lowerCAmelCase				) for item in self				)

   def 		A				(   self      :							Optional[Any]				)							->					bool:


    """simple docstring"""






    return len(self				) == 0

   def 		A				(   self      :							List[str]				, __lowerCAmelCase      :							Any				)							->					None:


    """simple docstring"""






    a							=		Node(__lowerCAmelCase				)
    if self.is_empty():
     a							=		a							=		node
    else:
     assert isinstance(self.rear				, __lowerCAmelCase				)
     a							=		node
     a							=		node

   def 		A				(   self      :							Optional[Any]				)							->					Any:


    """simple docstring"""






    if self.is_empty():
     raise IndexError("dequeue from empty queue"				)
    assert isinstance(self.front				, __lowerCAmelCase				)
    a							=		self.front
    a							=		self.front.next
    if self.front is None:
     a							=		None
    return node.data




   def 		A				(   self      :							str				)							->					None:


    """simple docstring"""






    a							=		a							=		None


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

     testmod()






import math
from timeit import timeit


def 	_A	(   _UpperCamelCase			):
				_UpperCAmelCase						:  str     					=	0
				_UpperCAmelCase						:  Tuple     					=	abs(_UpperCamelCase			)
				while True:
								_UpperCAmelCase						:  str     					=	n // 10
								digits += 1
								if n == 0:
												break
				return digits


def 	_A	(   _UpperCamelCase			):
				return 1 if n == 0 else math.floor(math.log(abs(_UpperCamelCase			)      ,					10			) + 1			)


def 	_A	(   _UpperCamelCase			):
				return len(str(abs(_UpperCamelCase			)			)			)


def 	_A	(   ):
				from collections.abc import Callable

				def benchmark_a_function(_UpperCamelCase      ,					_UpperCamelCase			) -> None:
								_UpperCAmelCase						:  List[str]     					=	F'''{func.__name__}({value})'''
								_UpperCAmelCase						:  Any     					=	timeit(F'''__main__.{call}'''      ,					setup='''import __main__'''			)
								print(F'''{call}: {func(_UpperCamelCase			)} -- {timing} seconds'''			)

				for value in (262_144, 1_125_899_906_842_624, 1_267_650_600_228_229_401_496_703_205_376):
								for func in (num_digits, num_digits_fast, num_digits_faster):
												benchmark_a_function(_UpperCamelCase      ,					_UpperCamelCase			)
								print()


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					benchmark()
