
import math






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






def 						lowerCamelCase__							(      a = 60_08_51_47_51_43   )   ->     int:

			try:
						_A:						Optional[int]	    = 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.'''   )
			_A:						str	    = 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   ):
												_A:						Tuple	    = n // i
												break
									elif is_prime(a   ):
												_A:						int	    = i
			return max_number


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





UpperCAmelCase__	:  str      =   1000






def 						lowerCamelCase__							(      a   )   ->     float:
   return x * x






def 						lowerCamelCase__							(      a	,	a	,	a	,	a = 4   )   ->     float:
   assert callable(
       a   ), f"""the function(object) passed should be callable your input : {function}"""
   assert isinstance(a	,	(float, int)   ), f"""a should be float or integer your input : {a}"""
   assert isinstance(function(a   )	,	(float, int)   ), (
       "the function should return integer or float return type of your function, "
       f"""{type(a   )}"""
   )
   assert isinstance(a	,	(float, int)   ), f"""b should be float or integer your input : {b}"""
   assert (
       isinstance(a	,	a   ) and precision > 0
   ), f"""precision should be positive integer your input : {precision}"""

   # just applying the formula of simpson for approximate integration written in
   # mentioned article in first comment of this file and above this function

   _A:						int	    = (b - a) / N_STEPS
   _A:						Any	    = function(a   ) + function(a   )

   for i in range(1	,	a   ):
      _A:						List[Any]	    = a + h * i
      result += function(a   ) * (4 if i % 2 else 2)

   result *= h / 3
   return round(a	,	a   )


if __name__ == "__main__":
   import doctest

   doctest.testmod()



