
import random

from .binary_exp_mod import bin_exp_mod






def   lowerCamelCase__							(					a		,		a=10_00      )      ->   Optional[int]:
   if n < 2:
      return False

   if n % 2 == 0:
      return n == 2

   # this means n is odd
   _A:  List[Any]					=       n - 1
   _A:  Dict					=       0
   while d % 2 == 0:
      d /= 2
      exp += 1

   # n - 1=d*(2**exp)
   _A:  List[str]					=       0
   while count < prec:
      _A:  Optional[int]					=       random.randint(2		,		n - 1      )
      _A:  Union[str, Any]					=       bin_exp_mod(a		,		a		,		a      )
      if b != 1:
         _A:  Optional[Any]					=       True
         for _ in range(a      ):
            if b == n - 1:
               _A:  int					=       False
               break
            _A:  Optional[Any]					=       b * b
            b %= n
         if flag:
            return False
         count += 1
   return True


if __name__ == "__main__":
   UpperCAmelCase__		:     Dict     			=      abs(int(input('Enter bound : ').strip()))
   print('Here\'s the list of primes:')
   print(', '.join(str(i) for i in range(n + 1) if is_prime_big(i)))





UpperCAmelCase__		:     Optional[Any]     			=      {
    'A': ['B', 'C', 'E'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F', 'G'],
    'D': ['B'],
    'E': ['A', 'B', 'D'],
    'F': ['C'],
    'G': ['C'],
}






def   lowerCamelCase__							(					a		,		a		,		a      )      ->   list[str]:
   _A:  Union[str, Any]					=       set()
   # keep track of all the paths to be checked
   _A:  Union[str, Any]					=       [[start]]

   # return path if start is goal
   if start == goal:
      return [start]

   # keeps looping until all possible paths have been checked
   while queue:
      # pop the first path from the queue
      _A:  Any					=       queue.pop(0      )
      # get the last node from the path
      _A:  Union[str, Any]					=       path[-1]
      if node not in explored:
         _A:  str					=       graph[node]
         # go through all neighbour nodes, construct a new path and
         # push it into the queue
         for neighbour in neighbours:
            _A:  Optional[int]					=       list(a      )
            new_path.append(a      )
            queue.append(a      )
            # return path if neighbour is goal
            if neighbour == goal:
               return new_path

            # mark node as explored
         explored.add(a      )

    # in case there's no path between the 2 nodes
   return []






def   lowerCamelCase__							(					a		,		a		,		a      )      ->   int:
   if not graph or start not in graph or target not in graph:
      return -1
   if start == target:
      return 0
   _A:  Any					=       [start]
   _A:  List[str]					=       set(a      )
   # Keep tab on distances from `start` node.
   _A:  Optional[int]					=       {start: 0, target: -1}
   while queue:
      _A:  Union[str, Any]					=       queue.pop(0      )
      if node == target:
         _A:  Dict					=       (
             dist[node] if dist[target] == -1 else min(dist[target]		,		dist[node]      )
         )
      for adjacent in graph[node]:
         if adjacent not in visited:
            visited.add(a      )
            queue.append(a      )
            _A:  List[Any]					=       dist[node] + 1
   return dist[target]


if __name__ == "__main__":
   print(bfs_shortest_path(demo_graph, 'G', 'D'))  # returns ['G', 'C', 'A', 'B', 'D']
   print(bfs_shortest_path_distance(demo_graph, 'G', 'D'))  # returns 4



