code: 
  '''simple docstring'''
  
  import math
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       int		)    ->						bool:
  
    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(_lowerCamelCase		) + 1		)  ,      6		):
      if number % i == 0 or number % (i + 2) == 0:
        return False
    return True
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       int = 60_08_51_47_51_43		)    ->						int:
  
    try:
      _lowerCAmelCase       :  Tuple   				=					int(_lowerCamelCase		)
    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."""		)
    _lowerCAmelCase       :  Dict   				=					0
    if is_prime(_lowerCamelCase		):
      return n
    while n % 2 == 0:
      n //= 2
    if is_prime(_lowerCamelCase		):
      return n
    for i in range(3  ,      int(math.sqrt(_lowerCamelCase		)		) + 1  ,      2		):
      if n % i == 0:
        if is_prime(n // i		):
          _lowerCAmelCase       :  Tuple   				=					n // i
          break
        elif is_prime(_lowerCamelCase		):
          _lowerCAmelCase       :  str   				=					i
    return max_number
  
  
  if __name__ == "__main__":
       print(F'{solution() = }')
  
  
  
style_context: 
  '''simple docstring'''
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_flax_available,
      is_tf_available,
      is_torch_available,
  )
  
  
  UpperCamelCase_     			=       {
      """configuration_gptsan_japanese""": ["""GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTSanJapaneseConfig"""],
      """tokenization_gptsan_japanese""": ["""GPTSanJapaneseTokenizer"""],
  }
  
  try:
       if not is_torch_available():
            raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
       pass
  else:
       UpperCamelCase_     			=       [
           """GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """GPTSanJapaneseForConditionalGeneration""",
           """GPTSanJapaneseModel""",
           """GPTSanJapanesePreTrainedModel""",
       ]
       UpperCamelCase_     			=       [
           """GPTSanJapaneseTokenizer""",
       ]
  
  
  if TYPE_CHECKING:
       from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
       from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer
  
       try:
            if not is_torch_available():
                 raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
            pass
       else:
            from .modeling_gptsan_japanese import (
                GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
                GPTSanJapaneseForConditionalGeneration,
                GPTSanJapaneseModel,
                GPTSanJapanesePreTrainedModel,
            )
            from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer
  
  
  else:
       import sys
  
       UpperCamelCase_     			=       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
  
  
  