import math


def SCREAMING_SNAKE_CASE				(     lowercase_:	Union[str, Any]				):
       _UpperCamelCase     :       List[Any]  						=  0
       if n % 2 == 0:
              count += 1
              while n % 2 == 0:
                     _UpperCamelCase     :       int  						=  int(n / 2				)
    # the n input value must be odd so that
    # we can skip one element (ie i += 2)

       _UpperCamelCase     :       Any  						=  3

       while i <= int(math.sqrt(lowercase_				)				):
              if n % i == 0:
                     count += 1
                     while n % i == 0:
                            _UpperCamelCase     :       Any  						=  int(n / i				)
              _UpperCamelCase     :       List[str]  						=  i + 2

       # this condition checks the prime
       # number n is greater than 2

       if n > 2:
              count += 1
       return count


if __name__ == "__main__":
 UpperCAmelCase					=				51_24_21_83
 print(f'''The number of distinct prime factors is/are {exact_prime_factor_count(n)}''')
 print(f'''The value of log(log(n)) is {math.log(math.log(n)):.4f}''')




import math
from collections.abc import Generator


def SCREAMING_SNAKE_CASE				(     lowercase_:	int				):
       _UpperCamelCase     :       Generator  						=  (i for i in range(1		,						(max_n + 1)				))
       for i in (n for n in numbers if n > 1):
              for j in range(2		,						lowercase_				):
                     if (i % j) == 0:
                            break
              else:
                     yield i


def SCREAMING_SNAKE_CASE				(     lowercase_:	int				):
       _UpperCamelCase     :       Generator  						=  (i for i in range(1		,						(max_n + 1)				))
       for i in (n for n in numbers if n > 1):
              # only need to check for factors up to sqrt(i)
              _UpperCamelCase     :       Any  						=  int(math.sqrt(lowercase_				)				) + 1
              for j in range(2		,						lowercase_				):
                     if (i % j) == 0:
                            break
              else:
                     yield i


def SCREAMING_SNAKE_CASE				(     lowercase_:	int				):
       _UpperCamelCase     :       Generator  						=  (i for i in range(1		,						(max_n + 1)		,						2				))
       # It's useless to test even numbers as they will not be prime
       if max_n > 2:
              yield 2  # Because 2 will not be tested, it's necessary to yield it now
       for i in (n for n in numbers if n > 1):
              _UpperCamelCase     :       Tuple  						=  int(math.sqrt(lowercase_				)				) + 1
              for j in range(3		,						lowercase_		,						2				):
                     # As we removed the even numbers, we don't need them now
                     if (i % j) == 0:
                            break
              else:
                     yield i


def SCREAMING_SNAKE_CASE				(     ):
       from timeit import timeit

       _UpperCamelCase     :       Optional[Any]  						=  'from __main__ import slow_primes, primes, fast_primes'
       print(timeit('slow_primes(1_000_000_000_000)'		,						setup=lowercase_		,						number=1000000				)				)
       print(timeit('primes(1_000_000_000_000)'		,						setup=lowercase_		,						number=1000000				)				)
       print(timeit('fast_primes(1_000_000_000_000)'		,						setup=lowercase_		,						number=1000000				)				)


if __name__ == "__main__":
 UpperCAmelCase					=				int(input('''Calculate primes up to:\n>> ''').strip())
 for ret in primes(number):
  print(ret)
 benchmark()



