






"""simple docstring"""
from __future__ import annotations

from collections import deque
from queue import Queue
from timeit import timeit

A_     :					int							=     {
    "A": ["B", "C"],
    "B": ["A", "D", "E"],
    "C": ["A", "F"],
    "D": ["B"],
    "E": ["B", "F"],
    "F": ["C", "E"],
}






def 			lowerCamelCase_    (		_lowerCamelCase     ,  _lowerCamelCase							):
 lowerCamelCase__	:     Tuple								=		{start}
 lowerCamelCase__	:     str								=		[start]
 lowerCamelCase__	:     Queue								=		Queue()
 queue.put(UpperCAmelCase_							)
 while not queue.empty():
  lowerCamelCase__	:     Union[str, Any]								=		queue.get()
  for w in graph[v]:
   if w not in explored:
    explored.add(UpperCAmelCase_							)
    result.append(UpperCAmelCase_							)
    queue.put(UpperCAmelCase_							)
 return result






def 			lowerCamelCase_    (		_lowerCamelCase     ,  _lowerCamelCase							):
 lowerCamelCase__	:     Tuple								=		{start}
 lowerCamelCase__	:     Optional[Any]								=		[start]
 lowerCamelCase__	:     Tuple								=		deque([start]							)
 while queue:
  lowerCamelCase__	:     Union[str, Any]								=		queue.popleft()
  for child in graph[v]:
   if child not in visited:
    visited.add(UpperCAmelCase_							)
    result.append(UpperCAmelCase_							)
    queue.append(UpperCAmelCase_							)
 return result






def 			lowerCamelCase_    (		_lowerCamelCase							):
 lowerCamelCase__	:     Dict								=		f'''from __main__ import G, {name}'''
 lowerCamelCase__	:     Any								=		1_0000
 lowerCamelCase__	:     Optional[int]								=		timeit(f'''{name}(G, \'A\')'''     ,  setup=UpperCAmelCase_     ,  number=UpperCAmelCase_							)
 print(f'''{name:<35} finished {number} runs in {res:.5f} seconds'''							)


if __name__ == "__main__":
      import doctest

      doctest.testmod()

      benchmark_function("breadth_first_search")
      benchmark_function("breadth_first_search_with_deque")
      # breadth_first_search                finished 10000 runs in 0.20999 seconds
      # breadth_first_search_with_deque     finished 10000 runs in 0.01421 seconds


"""simple docstring"""







import math
def     __UpperCAmelCase							(       UpperCAmelCase_       :							int    )				->     str:

	'''simple docstring'''





	if number == 0:
		__snake_case     :				Any 						=					'Zero'
		return words
	else:
		__snake_case     :				Optional[Any] 						=					math.logaa(UpperCAmelCase_    )
		__snake_case     :				Optional[Any] 						=					digits + 1
		__snake_case     :				List[str] 						=					{}
		__snake_case     :				List[str] 						=					''
		__snake_case     :				Any 						=					'One'
		__snake_case     :				List[str] 						=					'Two'
		__snake_case     :				Tuple 						=					'Three'
		__snake_case     :				str 						=					'Four'
		__snake_case     :				int 						=					'Five'
		__snake_case     :				Optional[Any] 						=					'Six'
		__snake_case     :				str 						=					'Seven'
		__snake_case     :				Optional[Any] 						=					'Eight'
		__snake_case     :				Tuple 						=					'Nine'

		__snake_case     :				Tuple 						=					{}
		__snake_case     :				Optional[int] 						=					''
		__snake_case     :				str 						=					'Twenty'
		__snake_case     :				List[str] 						=					'Thirty'
		__snake_case     :				str 						=					'Forty'
		__snake_case     :				Union[str, Any] 						=					'Fifty'
		__snake_case     :				str 						=					'Sixty'
		__snake_case     :				Tuple 						=					'Seventy'
		__snake_case     :				Dict 						=					'Eighty'
		__snake_case     :				Optional[Any] 						=					'Ninety'

		__snake_case     :				List[Any] 						=					{}
		__snake_case     :				Optional[Any] 						=					'Ten'
		__snake_case     :				List[str] 						=					'Eleven'
		__snake_case     :				Any 						=					'Twelve'
		__snake_case     :				Tuple 						=					'Thirteen'
		__snake_case     :				Tuple 						=					'Fourteen'
		__snake_case     :				Optional[int] 						=					'Fifteen'
		__snake_case     :				Any 						=					'Sixteen'
		__snake_case     :				int 						=					'Seventeen'
		__snake_case     :				Dict 						=					'Eighteen'
		__snake_case     :				List[Any] 						=					'Nineteen'

		__snake_case     :				List[Any] 						=					{}
		__snake_case     :				List[Any] 						=					'Hundred,'
		__snake_case     :				Union[str, Any] 						=					'Thousand,'
		__snake_case     :				List[Any] 						=					'Lakh,'
		__snake_case     :				List[Any] 						=					'Crore,'

		__snake_case     :				List[Any] 						=					number
		__snake_case     :				List[Any] 						=					''
		__snake_case     :				List[Any] 						=					0
		__snake_case     :				Union[str, Any] 						=					int(UpperCAmelCase_    )
		while counter < digits:
			__snake_case     :				List[str] 						=					temp_num % 10
			if counter % 2 == 0:
				__snake_case     :				Tuple 						=					''
				if counter in placevalue and current != 0:
					__snake_case     :				List[str] 						=					placevalue[counter]
				if counter == 2:
					__snake_case     :				Dict 						=					singles[current] + addition + words
				elif counter == 0:
					if ((temp_num % 1_00) // 10) == 1:
						__snake_case     :				Dict 						=					teens[current] + addition + words
						__snake_case     :				Dict 						=					temp_num // 10
						counter += 1
					else:
						__snake_case     :				Optional[Any] 						=					singles[current] + addition + words

				else:
					__snake_case     :				Any 						=					doubles[current] + addition + words

			else:
				if counter == 1:
					if current == 1:
						__snake_case     :				Dict 						=					teens[number % 10] + words
					else:
						__snake_case     :				Optional[int] 						=					''
						if counter in placevalue:
							__snake_case     :				Dict 						=					placevalue[counter]
						__snake_case     :				Union[str, Any] 						=					doubles[current] + addition + words
				else:
					__snake_case     :				List[Any] 						=					''
					if counter in placevalue:
						if current == 0 and ((temp_num % 1_00) // 10) == 0:
							__snake_case     :				Optional[Any] 						=					''
						else:
							__snake_case     :				Any 						=					placevalue[counter]
					if ((temp_num % 1_00) // 10) == 1:
						__snake_case     :				int 						=					teens[current] + addition + words
						__snake_case     :				Any 						=					temp_num // 10
						counter += 1
					else:
						__snake_case     :				List[str] 						=					singles[current] + addition + words
			counter += 1
			__snake_case     :				str 						=					temp_num // 10
	return words


if __name__ == "__main__":
	import doctest

	doctest.testmod()





