

from __future__ import annotations

def     a__  (	UpperCAmelCase							:    int    )						->		List[Any]:
  UpperCAmelCase :							Optional[Any]								=				{1}
  UpperCAmelCase :							str								=				[1]
  for _ in range(2       ,				depth + 1    ):
    UpperCAmelCase :							List[str]								=				[*previous_coefficients, 0]
    UpperCAmelCase :							int								=				[0, *previous_coefficients]
    UpperCAmelCase :							Optional[Any]								=				[]
    for x, y in zip(UpperCamelCase__       ,				UpperCamelCase__    ):
      coefficients.add(x + y    )
      previous_coefficients.append(x + y    )
  return coefficients

def     a__  (	UpperCAmelCase							:    set[int]    )						->		Optional[Any]:
  UpperCAmelCase :							Union[str, Any]								=				set()
  for number in unique_coefficients:
    UpperCAmelCase :							Optional[int]								=				2
    UpperCAmelCase :							List[str]								=				number
    while divisor**2 <= copy_number:
      UpperCAmelCase :							str								=				0
      while copy_number % divisor == 0:
        copy_number //= divisor
        multiplicity += 1
      if multiplicity >= 2:
        non_squarefrees.add(UpperCamelCase__    )
        break
      divisor += 1

  return unique_coefficients.difference(UpperCamelCase__    )

def     a__  (	UpperCAmelCase							:    int = 51    )						->		Union[str, Any]:
  UpperCAmelCase :							Any								=				get_pascal_triangle_unique_coefficients(UpperCamelCase__    )
  UpperCAmelCase :							Dict								=				get_squarefrees(UpperCamelCase__    )
  return sum(UpperCamelCase__    )


if __name__ == "__main__":
     print(f"""{solution() = }""")








from __future__ import annotations

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

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

def     a__  (	UpperCAmelCase							:    dict       ,				UpperCAmelCase							:    str    )						->		list[str]:
  UpperCAmelCase :							Dict								=				{start}
  UpperCAmelCase :							Optional[int]								=				[start]
  UpperCAmelCase :							Queue								=				Queue()
  queue.put(UpperCAmelCase    )
  while not queue.empty():
    UpperCAmelCase :							List[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     a__  (	UpperCAmelCase							:    dict       ,				UpperCAmelCase							:    str    )						->		list[str]:
  UpperCAmelCase :							str								=				{start}
  UpperCAmelCase :							List[str]								=				[start]
  UpperCAmelCase :							Union[str, Any]								=				deque([start]    )
  while queue:
    UpperCAmelCase :							Dict								=				queue.popleft()
    for child in graph[v]:
      if child not in visited:
        visited.add(UpperCAmelCase    )
        result.append(UpperCAmelCase    )
        queue.append(UpperCAmelCase    )
  return result

def     a__  (	UpperCAmelCase							:    str    )						->		None:
  UpperCAmelCase :							Optional[int]								=				f'''from __main__ import G, {name}'''
  UpperCAmelCase :							Tuple								=				10_000
  UpperCAmelCase :							Any								=				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





