code: 
  
  
  
  
  import math
  def 						lowerCAmelCase_       (	__a )       ->			bool:
  
  
  
  
  
  							"""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(__a ) + 1 )	,	6 ):
  														if number % i == 0 or number % (i + 2) == 0:
  																					return False
  							return True
  def 						lowerCAmelCase_       (	__a = 600851475143 )       ->			int:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							try:
  														SCREAMING_SNAKE_CASE			: Tuple	     =int(__a )
  							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.''' )
  							SCREAMING_SNAKE_CASE			: Tuple	     =0
  							if is_prime(__a ):
  														return n
  							while n % 2 == 0:
  														n //= 2
  							if is_prime(__a ):
  														return n
  							for i in range(3	,	int(math.sqrt(__a ) ) + 1	,	2 ):
  														if n % i == 0:
  																					if is_prime(n // i ):
  																												SCREAMING_SNAKE_CASE			: Any	     =n // i
  																												break
  																					elif is_prime(__a ):
  																												SCREAMING_SNAKE_CASE			: Tuple	     =i
  							return max_number
  
  
  if __name__ == "__main__":
  							print(F'''{solution() = }''')
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  import sys
  
  sys.set_int_max_str_digits(0)  # type: ignore
  def 						lowerCAmelCase_       (	__a )       ->			bool:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							SCREAMING_SNAKE_CASE			: Optional[int]	     =[0] * 11
  							SCREAMING_SNAKE_CASE			: str	     =[0] * 11
  
  							# mark last 9 numbers
  							for _ in range(9 ):
  														SCREAMING_SNAKE_CASE			: List[str]	     =1
  														SCREAMING_SNAKE_CASE			: List[Any]	     =number // 10
  							# flag
  							SCREAMING_SNAKE_CASE			: str	     =True
  
  							# check last 9 numbers for pandigitality
  
  							for x in range(9 ):
  														if not check_last[x + 1]:
  																					SCREAMING_SNAKE_CASE			: Dict	     =False
  							if not f:
  														return f
  
  							# mark first 9 numbers
  							SCREAMING_SNAKE_CASE			: Dict	     =int(str(__a )[:9] )
  
  							for _ in range(9 ):
  														SCREAMING_SNAKE_CASE			: Union[str, Any]	     =1
  														SCREAMING_SNAKE_CASE			: Optional[int]	     =number // 10
  
  							# check first 9 numbers for pandigitality
  
  							for x in range(9 ):
  														if not check_front[x + 1]:
  																					SCREAMING_SNAKE_CASE			: Any	     =False
  							return f
  def 						lowerCAmelCase_       (	__a )       ->			bool:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							SCREAMING_SNAKE_CASE			: Any	     =[0] * 11
  
  							# mark last 9 numbers
  							for _ in range(9 ):
  														SCREAMING_SNAKE_CASE			: int	     =1
  														SCREAMING_SNAKE_CASE			: Optional[Any]	     =number // 10
  							# flag
  							SCREAMING_SNAKE_CASE			: Any	     =True
  
  							# check last 9 numbers for pandigitality
  
  							for x in range(9 ):
  														if not check_last[x + 1]:
  																					SCREAMING_SNAKE_CASE			: Any	     =False
  							return f
  def 						lowerCAmelCase_       (	)       ->			int:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							SCREAMING_SNAKE_CASE			: int	     =1
  							SCREAMING_SNAKE_CASE			: List[Any]	     =1
  							SCREAMING_SNAKE_CASE			: List[Any]	     =2
  							# temporary Fibonacci numbers
  
  							SCREAMING_SNAKE_CASE			: Dict	     =1
  							SCREAMING_SNAKE_CASE			: Dict	     =1
  							SCREAMING_SNAKE_CASE			: Tuple	     =2
  							# temporary Fibonacci numbers mod 1e9
  
  							# mod m=1e9, done for fast optimisation
  							SCREAMING_SNAKE_CASE			: str	     =[0] * 1000000
  							SCREAMING_SNAKE_CASE			: Any	     =1000000000
  
  							for x in range(1000000 ):
  														SCREAMING_SNAKE_CASE			: Optional[int]	     =(aa + ba) % m
  														SCREAMING_SNAKE_CASE			: int	     =ba % m
  														SCREAMING_SNAKE_CASE			: Optional[int]	     =ca % m
  														if checka(__a ):
  																					SCREAMING_SNAKE_CASE			: List[Any]	     =1
  
  							for x in range(1000000 ):
  														SCREAMING_SNAKE_CASE			: Tuple	     =a + b
  														SCREAMING_SNAKE_CASE			: Union[str, Any]	     =b
  														SCREAMING_SNAKE_CASE			: List[str]	     =c
  														# perform check only if in tocheck
  														if tocheck[x + 3] and check(__a ):
  																					return x + 3  # first 2 already done
  							return -1
  
  
  if __name__ == "__main__":
  							print(F'''{solution() = }''')
  
  
  
  
  
  
  