






class        snake_case_				:







   """simple docstring"""



   def __init__(     self:						Dict						)	->		Tuple:


       """simple docstring"""



       _lowercase     			=						[]
       _lowercase     			=						0
       _lowercase     			=						0

   def __str__(     self:						Dict						)	->		List[str]:


       """simple docstring"""



       _lowercase     			=						'''<''' + str(self.entries						)[1:-1] + '''>'''
       return printed

   def       SCREAMING_SNAKE_CASE__					(     self:						Optional[int] ,							snake_case__:						Union[str, Any]						)	->		Optional[Any]:


       """simple docstring"""



       self.entries.append(SCREAMING_SNAKE_CASE_						)
       _lowercase     			=						self.length + 1

   def       SCREAMING_SNAKE_CASE__					(     self:						Dict						)	->		List[Any]:


       """simple docstring"""



       _lowercase     			=						self.length - 1
       _lowercase     			=						self.entries[self.front]
       # self.front-=1
       # self.entries = self.entries[self.front:]
       _lowercase     			=						self.entries[1:]
       return dequeued

   def       SCREAMING_SNAKE_CASE__					(     self:						Tuple ,							snake_case__:						Dict						)	->		Union[str, Any]:


       """simple docstring"""



       for _ in range(SCREAMING_SNAKE_CASE_						):
           self.put(self.get()						)

   def       SCREAMING_SNAKE_CASE__					(     self:						List[str]						)	->		Optional[int]:


       """simple docstring"""



       return self.entries[0]

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


       """simple docstring"""



       return self.length


'''simple docstring'''





import math
from timeit import timeit

def   A			(							A_				:       int							):
						snake_case							:  List[str]			=     0
						snake_case							:  Any			=     abs(A_							)
						while True:
												snake_case							:  List[Any]			=     n // 10
												digits += 1
												if n == 0:
																		break
						return digits

def   A			(							A_				:       int							):
						return 1 if n == 0 else math.floor(math.log(abs(A_							)     ,				10							) + 1							)

def   A			(							A_				:       int							):
						return len(str(abs(A_							)							)							)

def   A			(							):
						from collections.abc import Callable

						def benchmark_a_function(A_				:       Callable     ,				A_				:       int							) -> None:
												snake_case							:  Optional[int]			=     F"""{func.__name__}({value})"""
												snake_case							:  Optional[int]			=     timeit(F"""__main__.{call}"""     ,				setup='''import __main__'''							)
												print(F"""{call}: {func(A_							)} -- {timing} seconds"""							)

						for value in (262144, 1125899906842624, 1267650600228229401496703205376):
												for func in (num_digits, num_digits_fast, num_digits_faster):
																		benchmark_a_function(A_     ,				A_							)
												print()


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						benchmark()

