


from __future__ import annotations

import math

def       lowercase_		(		_A			:    int						):

      """simple docstring"""




      if num <= 0:
            lowerCamelCase__		:				Union[str, Any]    =  F"{num}: Invalid input, please enter a positive integer."
            raise ValueError(_A						)

      lowerCamelCase__		:				int    =  [True] * (num + 1)
      lowerCamelCase__		:				List[Any]    =  []
      lowerCamelCase__		:				str    =  2
      lowerCamelCase__		:				Tuple    =  int(math.sqrt(_A						)						)

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

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

            start += 1

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

      return prime


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






class 			_lowercase :


       """simple docstring"""




       def __init__(   self							:			Any					,      __lowerCamelCase							:			int       ):


             '''simple docstring'''



             lowerCamelCase__		:				List[str]    =  n
             lowerCamelCase__		:				Union[str, Any]    =  [None] * self.n
             lowerCamelCase__		:				List[str]    =  0  # index of the first element
             lowerCamelCase__		:				Any    =  0
             lowerCamelCase__		:				Any    =  0





       def __len__(   self							:			Tuple       ):


             '''simple docstring'''



             return self.size





       def 						lowerCAmelCase     (   self							:			Optional[int]       ):


             '''simple docstring'''



             return self.size == 0





       def 						lowerCAmelCase     (   self							:			Union[str, Any]       ):


             '''simple docstring'''



             return False if self.is_empty() else self.array[self.front]





       def 						lowerCAmelCase     (   self							:			str					,      __lowerCamelCase							:			List[str]       ):


             '''simple docstring'''



             if self.size >= self.n:
                   raise Exception("QUEUE IS FULL"       )

             lowerCamelCase__		:				Optional[Any]    =  data
             lowerCamelCase__		:				Tuple    =  (self.rear + 1) % self.n
             self.size += 1
             return self





       def 						lowerCAmelCase     (   self							:			Tuple       ):


             '''simple docstring'''



             if self.size == 0:
                   raise Exception("UNDERFLOW"       )

             lowerCamelCase__		:				Any    =  self.array[self.front]
             lowerCamelCase__		:				List[Any]    =  None
             lowerCamelCase__		:				str    =  (self.front + 1) % self.n
             self.size -= 1
             return temp


