





import os
from typing import Optional

import fsspec
from fsspec.archive import AbstractArchiveFileSystem
from fsspec.utils import DEFAULT_BLOCK_SIZE






class 						UpperCamelCase_  (  snake_case__							):
					_a      :						Any						    =					''
					_a      :						str						    =					(
					    None  # protocol passed in prefix to the url. ex: "gzip", for gzip://file.txt::http://foo.bar/file.txt.gz
					)
					_a      :						str						    =					None  # compression type in fsspec. ex: "gzip"
					_a      :						str						    =					None  # extension of the filename to strip. ex: "".gz" to get file.txt from file.txt.gz



					def __init__(		self     :     List[Any]       ,      lowerCamelCase     :     str = ""       ,      lowerCamelCase     :     Optional[str] = None       ,      lowerCamelCase     :     Optional[dict] = None       ,      **lowerCamelCase     :     str						):
							super().__init__(self       ,      **lowerCamelCase						)
							# always open as "rb" since fsspec can then use the TextIOWrapper to make it work for "r" mode
							lowerCamelCase_	:     Dict 						=      fsspec.open(
							    lowerCamelCase       ,      mode='rb'       ,      protocol=lowerCamelCase       ,      compression=self.compression       ,      client_kwargs={
							        'requote_redirect_url': False,  # see https://github.com/huggingface/datasets/pull/5459
							        'trust_env': True,  # Enable reading proxy env variables.
							        **(target_options or {}).pop('client_kwargs'       ,      {}						),  # To avoid issues if it was already passed.
							    }       ,      **(target_options or {})       ,      )
							lowerCamelCase_	:     int 						=      os.path.basename(self.file.path.split('::'						)[0]						)
							lowerCamelCase_	:     List[Any] 						=      (
							    self.compressed_name[: self.compressed_name.rindex('.'						)]
							    if '.' in self.compressed_name
							    else self.compressed_name
							)
							lowerCamelCase_	:     Tuple 						=      None



					@classmethod
					def   __a     (		cls     :     Union[str, Any]       ,      lowerCamelCase     :     Union[str, Any]						):
							# compressed file paths are always relative to the archive root
							return super()._strip_protocol(lowerCamelCase						).lstrip('/'						)



					def   __a     (		self     :     Dict						):
							if self.dir_cache is None:
									lowerCamelCase_	:     int 						=      {**self.file.fs.info(self.file.path						), 'name': self.uncompressed_name}
									lowerCamelCase_	:     Tuple 						=      {f['name']: f}



					def   __a     (		self     :     Tuple       ,      lowerCamelCase     :     str						):
							return self.file.open().read()





					def   __a     (		self     :     Dict       ,      lowerCamelCase     :     str       ,      lowerCamelCase     :     str = "rb"       ,      lowerCamelCase     :     Optional[int]=None       ,      lowerCamelCase     :     int=True       ,      lowerCamelCase     :     Optional[int]=None       ,      **lowerCamelCase     :     Any       ,      ):
							lowerCamelCase_	:     Optional[int] 						=      self._strip_protocol(lowerCamelCase						)
							if mode != "rb":
									raise ValueError(F"Tried to read with mode {mode} on file {self.file.path} opened with mode 'rb'"						)
							return self.file.open()






class 						UpperCamelCase_  (  snake_case__							):
					_a      :						int						    =					'bz2'
					_a      :						Tuple						    =					'bz2'
					_a      :						Union[str, Any]						    =					'.bz2'






class 						UpperCamelCase_  (  snake_case__							):
					_a      :						Optional[int]						    =					'gzip'
					_a      :						Tuple						    =					'gzip'
					_a      :						List[Any]						    =					'.gz'






class 						UpperCamelCase_  (  snake_case__							):
					_a      :						str						    =					'lz4'
					_a      :						str						    =					'lz4'
					_a      :						Optional[int]						    =					'.lz4'






class 						UpperCamelCase_  (  snake_case__							):
					_a      :						Optional[int]						    =					'xz'
					_a      :						Optional[int]						    =					'xz'
					_a      :						Tuple						    =					'.xz'






class 						UpperCamelCase_  (  snake_case__							):
					_a      :						Optional[int]						    =					'zstd'
					_a      :						str						    =					'zstd'
					_a      :						Tuple						    =					'.zst'



					def __init__(		self     :     Optional[int]       ,      lowerCamelCase     :     str       ,      lowerCamelCase     :     str = "rb"       ,      lowerCamelCase     :     Optional[str] = None       ,      lowerCamelCase     :     Optional[dict] = None       ,      lowerCamelCase     :     int = DEFAULT_BLOCK_SIZE       ,      **lowerCamelCase     :     Optional[Any]       ,      ):
							super().__init__(
							    fo=lowerCamelCase       ,      mode=lowerCamelCase       ,      target_protocol=lowerCamelCase       ,      target_options=lowerCamelCase       ,      block_size=lowerCamelCase       ,      **lowerCamelCase       ,      )
							# We need to wrap the zstd decompressor to avoid this error in fsspec==2021.7.0 and zstandard==0.15.2:
							#
							# File "/Users/user/.virtualenvs/hf-datasets/lib/python3.7/site-packages/fsspec/core.py", line 145, in open
							#     out.close = close
							# AttributeError: 'zstd.ZstdDecompressionReader' object attribute 'close' is read-only
							#
							# see https://github.com/intake/filesystem_spec/issues/725
							lowerCamelCase_	:     Union[str, Any] 						=      self.file.__enter__






							class 						UpperCamelCase_  :



												def __init__(		self     :     Optional[int]       ,      lowerCamelCase     :     Dict						):
														lowerCamelCase_	:     Union[str, Any] 						=      file_



												def __enter__(		self     :     Tuple						):
														self._file.__enter__()
														return self



												def __exit__(		self     :     str       ,      *lowerCamelCase     :     List[str]       ,      **lowerCamelCase     :     str						):
														self._file.__exit__(*lowerCamelCase       ,      **lowerCamelCase						)



												def __iter__(		self     :     Union[str, Any]						):
														return iter(self._file						)



												def   __a     (		self     :     int						):
														return next(self._file						)





												def __getattr__(		self     :     List[str]       ,      lowerCamelCase     :     Optional[Any]						):
														return getattr(self._file       ,      lowerCamelCase						)

							def fixed_enter(*lowerCamelCase     :     Union[str, Any]       ,      **lowerCamelCase     :     List[Any]						):
									return WrappedFile(_enter(*lowerCamelCase       ,      **lowerCamelCase						)						)

							lowerCamelCase_	:     List[Any] 						=      fixed_enter







from __future__ import annotations

import math


def 		_SCREAMING_SNAKE_CASE     ( lowerCAmelCase__						):

		if num <= 0:
				lowerCamelCase_	:     Optional[int] 						=      F"{num}: Invalid input, please enter a positive integer."
				raise ValueError(lowerCAmelCase__						)

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