import math






def  __lowerCamelCase						(		lowerCAmelCase__      ):

       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(snake_case_      ) + 1      )      ,    6      ):
              if number % i == 0 or number % (i + 2) == 0:
                     return False
       return True






def  __lowerCamelCase						(		lowerCAmelCase__ = 6_0_0_8_5_1_4_7_5_1_4_3      ):

       try:
              lowerCAmelCase__	      =   int(snake_case_      )
       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__	      =   0
       if is_prime(snake_case_      ):
              return n
       while n % 2 == 0:
              n //= 2
       if is_prime(snake_case_      ):
              return n
       for i in range(3      ,    int(math.sqrt(snake_case_      )      ) + 1      ,    2      ):
              if n % i == 0:
                     if is_prime(n // i      ):
                            lowerCAmelCase__	      =   n // i
                            break
                     elif is_prime(snake_case_      ):
                            lowerCAmelCase__	      =   i
       return max_number


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



'''simple docstring'''







from transformers import HfArgumentParser, PyTorchBenchmark, PyTorchBenchmarkArguments






def 					_SCREAMING_SNAKE_CASE		(						):
	_lowercase							=     HfArgumentParser(snake_case_	)
	try:
		_lowercase							=     parser.parse_args_into_dataclasses()[0]
	except ValueError as e:
		_lowercase							=     """Arg --no_{0} is no longer used, please use --no-{0} instead."""
		_lowercase							=     """ """.join(str(snake_case_	).split(""" """	)[:-1]	)
		_lowercase							=     """"""
		_lowercase							=     eval(str(snake_case_	).split(""" """	)[-1]	)
		_lowercase							=     []
		for arg in depreciated_args:
			# arg[2:] removes '--'
			if arg[2:] in PyTorchBenchmarkArguments.deprecated_args:
				# arg[5:] removes '--no_'
				full_error_msg += arg_error_msg.format(arg[5:]	)
			else:
				wrong_args.append(snake_case_	)
		if len(snake_case_	) > 0:
			_lowercase							=     full_error_msg + begin_error_msg + str(snake_case_	)
		raise ValueError(snake_case_	)

	_lowercase							=     PyTorchBenchmark(args=snake_case_	)
	benchmark.run()


if __name__ == "__main__":
							main()




