
"""simple docstring"""






def 						_snake_case       (	lowercase__		:  int		)  ->				list[int]:


			'''simple docstring'''





			if num <= 0:
						raise ValueError("""Input must be a positive integer"""		)

			lowerCAmelCase_    :str			     =  [True] * (num + 1)

			lowerCAmelCase_    :str			     =  2
			while p * p <= num:
						if primes[p]:
									for i in range(p * p      ,     num + 1      ,     lowercase__		):
												lowerCAmelCase_    :Any			     =  False
						p += 1

			return [prime for prime in range(2      ,     num + 1		) if primes[prime]]


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				__UpperCAmelCase       =  int(input('Enter a positive integer: ').strip())
				print(prime_sieve_eratosthenes(user_num))














from math import factorial

UpperCAmelCase__				   =		{str(digit): factorial(digit) for digit in range(10)}
def 						_a    (      a :int )							->			int:
 if not isinstance(a	,							a ):
  raise TypeError('''Parameter number must be int''' )

 if number < 0:
  raise ValueError('''Parameter number must be greater than or equal to 0''' )

 # Converts number in string to iterate on its digits and adds its factorial.
 return sum(DIGIT_FACTORIAL[digit] for digit in str(a ) )
def 						_a    (      a :int = 60	,							a :int = 1_000_000 )							->			int:

 if not isinstance(a	,							a ) or not isinstance(a	,							a ):
  raise TypeError('''Parameters chain_length and number_limit must be int''' )

 if chain_length <= 0 or number_limit <= 0:
  raise ValueError(
      '''Parameters chain_length and number_limit must be greater than 0''' )

 # the counter for the chains with the exact desired length
 a		  =      0
 # the cached sizes of the previous chains
 a		  =      {}

 for start_chain_element in range(1	,							a ):
  # The temporary set will contain the elements of the chain
  a		  =      set()
  a		  =      0

  # Stop computing the chain when you find a cached size, a repeating item or the
  # length is greater then the desired one.
  a		  =      start_chain_element
  while (
      chain_element not in chain_sets_lengths
      and chain_element not in chain_set
      and chain_set_length <= chain_length
  ):
   chain_set.add(a )
   chain_set_length += 1
   a		  =      digit_factorial_sum(a )

  if chain_element in chain_sets_lengths:
   chain_set_length += chain_sets_lengths[chain_element]

  a		  =      chain_set_length

  # If chain contains the exact amount of elements increase the counter
  if chain_set_length == chain_length:
   chains_counter += 1

 return chains_counter


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     print(f"""{solution()}""")


