"""simple docstring"""

import math


def    lowerCAmelCase			(__UpperCamelCase							:    List[Any]			):
							"""simple docstring"""


							if 1 < number < 4:
														# 2 and 3 are primes
														return True
							elif number < 2 or number % 2 == 0 or number % 3 == 0:
														# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
														return False

							# All primes number are in format of 6k +/- 1
							for i in range(5							,					int(math.sqrt(__UpperCamelCase			) + 1			)							,					6			):
														if number % i == 0 or number % (i + 2) == 0:
																					return False
							return True


def    lowerCAmelCase			(__UpperCamelCase							:    Optional[Any] = 6_0_0_8_5_1_4_7_5_1_4_3			):
							"""simple docstring"""


							try:
														__UpperCamelCase							=int(__UpperCamelCase			)
							except (TypeError, ValueError):
														raise TypeError('''Parameter n must be int or castable to int.'''			)
							if n <= 0:
														raise ValueError('''Parameter n must be greater than or equal to one.'''			)
							__UpperCamelCase							=0
							if is_prime(__UpperCamelCase			):
														return n
							while n % 2 == 0:
														n //= 2
							if is_prime(__UpperCamelCase			):
														return n
							for i in range(3							,					int(math.sqrt(__UpperCamelCase			)			) + 1							,					2			):
														if n % i == 0:
																					if is_prime(n // i			):
																												__UpperCamelCase							=n // i
																												break
																					elif is_prime(__UpperCamelCase			):
																												__UpperCamelCase							=i
							return max_number


if __name__ == "__main__":
				print(f'''{solution() = }''')





"""simple docstring"""






def    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase = 1_000     )						->str:

   """simple docstring"""



   if (not isinstance(UpperCAmelCase ,   UpperCAmelCase     )) or (digit_position <= 0):
      raise ValueError("Digit position must be a positive integer"     )
   elif (not isinstance(UpperCAmelCase ,   UpperCAmelCase     )) or (precision < 0):
      raise ValueError("Precision must be a nonnegative integer"     )

   # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
   # accurate
   a_						   =     (
       4 * _subsum(UpperCAmelCase ,   1 ,   UpperCAmelCase     )
       - 2 * _subsum(UpperCAmelCase ,   4 ,   UpperCAmelCase     )
       - _subsum(UpperCAmelCase ,   5 ,   UpperCAmelCase     )
       - _subsum(UpperCAmelCase ,   6 ,   UpperCAmelCase     )
   )

   # return the first hex digit of the fractional part of the result
   return hex(int((sum_result % 1) * 16     )     )[2:]
def    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase ,   UpperCAmelCase     )						->float:

   """simple docstring"""



   a_						   =     0.0
   for sum_index in range(digit_pos_to_extract + precision     ):
      a_						   =     8 * sum_index + denominator_addend
      if sum_index < digit_pos_to_extract:
         # if the exponential term is an integer and we mod it by the denominator
         # before dividing, only the integer part of the sum will change;
         # the fractional part will not
         a_						   =     pow(
             16 ,   digit_pos_to_extract - 1 - sum_index ,   UpperCAmelCase     )
      else:
         a_						   =     pow(16 ,   digit_pos_to_extract - 1 - sum_index     )
      total += exponential_term / denominator
   return total


if __name__ == "__main__":
      import doctest

      doctest.testmod()