


'''simple docstring'''


from __future__ import annotations

import math




def      lowerCamelCase					(      lowerCamelCase  :      int):

   if num <= 0:
      A_						:  List[Any]          =				F'{num}: Invalid input, please enter a positive integer.'
      raise ValueError(lowerCamelCase)

   A_						:  str          =				[True] * (num + 1)
   A_						:  Tuple          =				[]
   A_						:  str          =				2
   A_						:  Any          =				int(math.sqrt(lowerCamelCase))

   while start <= end:
      # If start is a prime
      if sieve[start] is True:
         prime.append(lowerCamelCase)

         # Set multiples of start be False
         for i in range(start * start							,						num + 1							,						lowerCamelCase):
            if sieve[i] is True:
               A_						:  Union[str, Any]          =				False

      start += 1

   for j in range(end + 1							,						num + 1):
      if sieve[j] is True:
         prime.append(lowerCamelCase)

   return prime


if __name__ == "__main__":
     print(prime_sieve(int(input('Enter a positive integer: ').strip())))




'''simple docstring'''


from __future__ import annotations




def      lowerCamelCase					(      lowerCamelCase  :      dict							,						lowerCamelCase  :      str):
      A_   ,					A_						:  List[Any]          =				set(lowerCamelCase), [start]

      while stack:
            A_						:  Optional[Any]          =				stack.pop()
            explored.add(lowerCamelCase)
            # Differences from BFS:
            # 1) pop last element instead of first one
            # 2) add adjacent elements to stack without exploring them
            for adj in reversed(graph[v]):
                  if adj not in explored:
                        stack.append(lowerCamelCase)
      return explored


__magic_name__			=      {
    'A': ['B', 'C', 'D'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B', 'D'],
    'E': ['B', 'F'],
    'F': ['C', 'E', 'G'],
    'G': ['F'],
}

if __name__ == "__main__":
     import doctest

     doctest.testmod()
     print(depth_first_search(G, 'A'))
