





'''simple docstring'''




from math import ceil
def 	UpperCAmelCase_							(					__lowercase							:      int			,     __lowercase							:      List[Any]       )		->       List[str]:


     '''simple docstring'''



     _UpperCAmelCase     							=   list(range(0			,     lowerCamelCase__       )       )

     _UpperCAmelCase     							=   [item for sublist in list(device_map.values()       ) for item in sublist]

     # Duplicate check
     _UpperCAmelCase     							=   []
     for i in device_map_blocks:
          if device_map_blocks.count(lowerCamelCase__       ) > 1 and i not in duplicate_blocks:
               duplicate_blocks.append(lowerCamelCase__       )
    # Missing blocks
     _UpperCAmelCase     							=   [i for i in blocks if i not in device_map_blocks]
     _UpperCAmelCase     							=   [i for i in device_map_blocks if i not in blocks]

     if len(lowerCamelCase__       ) != 0:
          raise ValueError(
              "Duplicate attention blocks specified in device_map. Attention blocks must be specified to one device."
              " These attention blocks were specified more than once: " + str(lowerCamelCase__       )       )
     if len(lowerCamelCase__       ) != 0:
          raise ValueError(
              "There are attention blocks for this model that are not specified in the device_map. Add these attention "
              "blocks to a device on the device_map: " + str(lowerCamelCase__       )       )
     if len(lowerCamelCase__       ) != 0:
          raise ValueError(
              "The device_map contains more attention blocks than this model has. Remove these from the device_map:"
              + str(lowerCamelCase__       )       )






def 	UpperCAmelCase_							(					__lowercase							:      Dict			,     __lowercase							:      str       )		->       Tuple:


     '''simple docstring'''



     _UpperCAmelCase     							=   list(range(lowerCamelCase__       )       )
     _UpperCAmelCase     							=   int(ceil(n_layers / len(lowerCamelCase__       )       )       )
     _UpperCAmelCase     							=   [layers[i : i + n_blocks] for i in range(0			,     lowerCamelCase__			,     lowerCamelCase__       )]

     return dict(zip(lowerCamelCase__			,     lowerCamelCase__       )       )









'''simple docstring'''




from __future__ import annotations

import math



def 	a			( lowerCamelCase__    ):
			'''simple docstring'''





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

			A_	:						Dict	=     [True] * (num + 1)
			A_	:						List[Any]	=     []
			A_	:						Tuple	=     2
			A_	:						Optional[int]	=     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_	:						List[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())))