

'''simple docstring'''
from math import sqrt


def  a__       (    _SCREAMING_SNAKE_CASE   :       int				)     ->					bool:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (
	    number >= 0
	), "'number' must been an int and positive"

	UpperCAmelCase_     :      int						=  True

	# 0 and 1 are none primes.
	if number <= 1:
		UpperCAmelCase_     :      List[Any]						=  False

	for divisor in range(2	,				int(round(sqrt(_SCREAMING_SNAKE_CASE				)				)				) + 1				):
		# if 'number' divisible by 'divisor' then sets 'status'
		# of false and break up the loop.
		if number % divisor == 0:
			UpperCAmelCase_     :      Dict						=  False
			break

    # precondition
	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				), "'status' must been from type bool"

	return status


def  a__       (    _SCREAMING_SNAKE_CASE   :       str				)     ->					List[str]:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (n > 2), "'N' must been an int and > 2"

	# beginList: contains all natural numbers from 2 up to N
	UpperCAmelCase_     :      Tuple						=  list(range(2	,				n + 1				)				)

	UpperCAmelCase_     :      Dict						=  []  # this list will be returns.

	# actual sieve of erathostenes
	for i in range(len(_SCREAMING_SNAKE_CASE				)				):
		for j in range(i + 1	,				len(_SCREAMING_SNAKE_CASE				)				):
			if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
				UpperCAmelCase_     :      List[Any]						=  0

    # filters actual prime numbers.
	UpperCAmelCase_     :      Any						=  [x for x in begin_list if x != 0]

	# precondition
	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				), "'ans' must been from type list"

	return ans


def  a__       (    _SCREAMING_SNAKE_CASE   :       str				)     ->					Tuple:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (n > 2), "'N' must been an int and > 2"

	UpperCAmelCase_     :      Union[str, Any]						=  []

	# iterates over all numbers between 2 up to N+1
	# if a number is prime then appends to list 'ans'
	for number in range(2	,				n + 1				):
		if is_prime(_SCREAMING_SNAKE_CASE				):
			ans.append(_SCREAMING_SNAKE_CASE				)

    # precondition
	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				), "'ans' must been from type list"

	return ans


def  a__       (    _SCREAMING_SNAKE_CASE   :       Optional[Any]				)     ->					List[str]:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and number >= 0, "'number' must been an int and >= 0"

	UpperCAmelCase_     :      Optional[Any]						=  []  # this list will be returns of the function.

	# potential prime number factors.

	UpperCAmelCase_     :      Optional[int]						=  2

	UpperCAmelCase_     :      Optional[Any]						=  number

	if number == 0 or number == 1:
		ans.append(_SCREAMING_SNAKE_CASE				)

	# if 'number' not prime then builds the prime factorization of 'number'
	elif not is_prime(_SCREAMING_SNAKE_CASE				):
		while quotient != 1:
			if is_prime(_SCREAMING_SNAKE_CASE				) and (quotient % factor == 0):
				ans.append(_SCREAMING_SNAKE_CASE				)
				quotient /= factor
			else:
				factor += 1

	else:
		ans.append(_SCREAMING_SNAKE_CASE				)

	# precondition
	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				), "'ans' must been from type list"

	return ans


def  a__       (    _SCREAMING_SNAKE_CASE   :       Union[str, Any]				)     ->					int:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (
	    number >= 0
	), "'number' bust been an int and >= 0"

	UpperCAmelCase_     :      Tuple						=  0

	# prime factorization of 'number'
	UpperCAmelCase_     :      str						=  prime_factorization(_SCREAMING_SNAKE_CASE				)

	UpperCAmelCase_     :      Any						=  max(_SCREAMING_SNAKE_CASE				)

	# precondition
	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				), "'ans' must been from type int"

	return ans


def  a__       (    _SCREAMING_SNAKE_CASE   :       Tuple				)     ->					Union[str, Any]:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (
	    number >= 0
	), "'number' bust been an int and >= 0"

	UpperCAmelCase_     :      List[str]						=  0

	# prime factorization of 'number'
	UpperCAmelCase_     :      Any						=  prime_factorization(_SCREAMING_SNAKE_CASE				)

	UpperCAmelCase_     :      Optional[Any]						=  min(_SCREAMING_SNAKE_CASE				)

	# precondition
	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				), "'ans' must been from type int"

	return ans


def  a__       (    _SCREAMING_SNAKE_CASE   :       List[str]				)     ->					Tuple:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				), "'number' must been an int"
	assert isinstance(number % 2 == 0	,				_SCREAMING_SNAKE_CASE				), "compare bust been from type bool"

	return number % 2 == 0


def  a__       (    _SCREAMING_SNAKE_CASE   :       List[Any]				)     ->					Dict:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				), "'number' must been an int"
	assert isinstance(number % 2 != 0	,				_SCREAMING_SNAKE_CASE				), "compare bust been from type bool"

	return number % 2 != 0


def  a__       (    _SCREAMING_SNAKE_CASE   :       List[Any]				)     ->					Union[str, Any]:


	"""simple docstring"""





	assert (
	    isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (number > 2) and is_even(_SCREAMING_SNAKE_CASE				)
	), "'number' must been an int, even and > 2"

	UpperCAmelCase_     :      Optional[Any]						=  []  # this list will returned

	# creates a list of prime numbers between 2 up to 'number'
	UpperCAmelCase_     :      Any						=  get_prime_numbers(_SCREAMING_SNAKE_CASE				)
	UpperCAmelCase_     :      List[str]						=  len(_SCREAMING_SNAKE_CASE				)

	# run variable for while-loops.
	UpperCAmelCase_     :      List[str]						=  0
	UpperCAmelCase_     :      Optional[Any]						=  None

	# exit variable. for break up the loops
	UpperCAmelCase_     :      Tuple						=  True

	while i < len_pn and loop:
		UpperCAmelCase_     :      Dict						=  i + 1

		while j < len_pn and loop:
			if prime_numbers[i] + prime_numbers[j] == number:
				UpperCAmelCase_     :      str						=  False
				ans.append(prime_numbers[i]				)
				ans.append(prime_numbers[j]				)

			j += 1

		i += 1

	# precondition
	assert (
	    isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				)
	    and (len(_SCREAMING_SNAKE_CASE				) == 2)
	    and (ans[0] + ans[1] == number)
	    and is_prime(ans[0]				)
	    and is_prime(ans[1]				)
	), "'ans' must contains two primes. And sum of elements must been eq 'number'"

	return ans


def  a__       (    _SCREAMING_SNAKE_CASE   :       str	,				_SCREAMING_SNAKE_CASE   :       Union[str, Any]				)     ->					str:


	"""simple docstring"""





	assert (
	    isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				)
	    and isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				)
	    and (numbera >= 0)
	    and (numbera >= 0)
	), "'number1' and 'number2' must been positive integer."

	UpperCAmelCase_     :      Any						=  0

	while numbera != 0:
		UpperCAmelCase_     :      Dict						=  numbera % numbera
		UpperCAmelCase_     :      str						=  numbera
		UpperCAmelCase_     :      Optional[int]						=  rest

	# precondition
	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (
	    numbera >= 0
	), "'number' must been from type int and positive"

	return numbera


def  a__       (    _SCREAMING_SNAKE_CASE   :       int	,				_SCREAMING_SNAKE_CASE   :       Union[str, Any]				)     ->					List[Any]:


	"""simple docstring"""





	assert (
	    isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				)
	    and isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				)
	    and (numbera >= 1)
	    and (numbera >= 1)
	), "'number1' and 'number2' must been positive integer."

	UpperCAmelCase_     :      str						=  1  # actual answer that will be return.

	# for kgV (x,1)
	if numbera > 1 and numbera > 1:
		# builds the prime factorization of 'number1' and 'number2'
		UpperCAmelCase_     :      Dict						=  prime_factorization(_SCREAMING_SNAKE_CASE				)
		UpperCAmelCase_     :      Tuple						=  prime_factorization(_SCREAMING_SNAKE_CASE				)

	elif numbera == 1 or numbera == 1:
		UpperCAmelCase_     :      List[str]						=  []
		UpperCAmelCase_     :      List[Any]						=  []
		UpperCAmelCase_     :      str						=  max(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				)

	UpperCAmelCase_     :      Optional[Any]						=  0
	UpperCAmelCase_     :      Union[str, Any]						=  0

	UpperCAmelCase_     :      str						=  []  # captured numbers int both 'primeFac1' and 'primeFac2'

	# iterates through primeFac1
	for n in prime_fac_a:
		if n not in done:
			if n in prime_fac_a:
				UpperCAmelCase_     :      Optional[int]						=  prime_fac_a.count(_SCREAMING_SNAKE_CASE				)
				UpperCAmelCase_     :      Tuple						=  prime_fac_a.count(_SCREAMING_SNAKE_CASE				)

				for _ in range(max(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				)				):
					ans *= n

			else:
				UpperCAmelCase_     :      Any						=  prime_fac_a.count(_SCREAMING_SNAKE_CASE				)

				for _ in range(_SCREAMING_SNAKE_CASE				):
					ans *= n

			done.append(_SCREAMING_SNAKE_CASE				)

    # iterates through primeFac2
	for n in prime_fac_a:
		if n not in done:
			UpperCAmelCase_     :      Dict						=  prime_fac_a.count(_SCREAMING_SNAKE_CASE				)

			for _ in range(_SCREAMING_SNAKE_CASE				):
				ans *= n

			done.append(_SCREAMING_SNAKE_CASE				)

    # precondition
	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (
	    ans >= 0
	), "'ans' must been from type int and positive"

	return ans


def  a__       (    _SCREAMING_SNAKE_CASE   :       Dict				)     ->					int:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (n >= 0), "'number' must been a positive int"

	UpperCAmelCase_     :      Tuple						=  0
	UpperCAmelCase_     :      Union[str, Any]						=  2  # this variable holds the answer

	while index < n:
		index += 1

		ans += 1  # counts to the next number

		# if ans not prime then
		# runs to the next prime number.
		while not is_prime(_SCREAMING_SNAKE_CASE				):
			ans += 1

    # precondition
	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and is_prime(
	    _SCREAMING_SNAKE_CASE				), "'ans' must been a prime number and from type int"

	return ans


def  a__       (    _SCREAMING_SNAKE_CASE   :       Tuple	,				_SCREAMING_SNAKE_CASE   :       Union[str, Any]				)     ->					List[Any]:


	"""simple docstring"""





	assert (
	    is_prime(_SCREAMING_SNAKE_CASE				) and is_prime(_SCREAMING_SNAKE_CASE				) and (p_number_a < p_number_a)
	), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

	UpperCAmelCase_     :      str						=  p_number_a + 1  # jump to the next number

	UpperCAmelCase_     :      Any						=  []  # this list will be returns.

	# if number is not prime then
	# fetch the next prime number.
	while not is_prime(_SCREAMING_SNAKE_CASE				):
		number += 1

	while number < p_number_a:
		ans.append(_SCREAMING_SNAKE_CASE				)

		number += 1

		# fetch the next prime number.
		while not is_prime(_SCREAMING_SNAKE_CASE				):
			number += 1

    # precondition
	assert (
	    isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				)
	    and ans[0] != p_number_a
	    and ans[len(_SCREAMING_SNAKE_CASE				) - 1] != p_number_a
	), "'ans' must been a list without the arguments"

	# 'ans' contains not 'pNumber1' and 'pNumber2' !
	return ans


def  a__       (    _SCREAMING_SNAKE_CASE   :       int				)     ->					int:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (n >= 1), "'n' must been int and >= 1"

	UpperCAmelCase_     :      Tuple						=  []  # will be returned.

	for divisor in range(1	,				n + 1				):
		if n % divisor == 0:
			ans.append(_SCREAMING_SNAKE_CASE				)

    # precondition
	assert ans[0] == 1 and ans[len(_SCREAMING_SNAKE_CASE				) - 1] == n, "Error in function getDivisiors(...)"

	return ans


def  a__       (    _SCREAMING_SNAKE_CASE   :       Union[str, Any]				)     ->					str:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (
	    number > 1
	), "'number' must been an int and >= 1"

	UpperCAmelCase_     :      List[Any]						=  get_divisors(_SCREAMING_SNAKE_CASE				)

	# precondition
	assert (
	    isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				)
	    and (divisors[0] == 1)
	    and (divisors[len(_SCREAMING_SNAKE_CASE				) - 1] == number)
	), "Error in help-function getDivisiors(...)"

	# summed all divisors up to 'number' (exclusive), hence [:-1]
	return sum(divisors[:-1]				) == number


def  a__       (    _SCREAMING_SNAKE_CASE   :       Optional[int]	,				_SCREAMING_SNAKE_CASE   :       int				)     ->					int:


	"""simple docstring"""





	assert (
	    isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				)
	    and isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				)
	    and (denominator != 0)
	), "The arguments must been from type int and 'denominator' != 0"

	# build the greatest common divisor of numerator and denominator.
	UpperCAmelCase_     :      int						=  gcd(abs(_SCREAMING_SNAKE_CASE				)	,				abs(_SCREAMING_SNAKE_CASE				)				)

	# precondition
	assert (
	    isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				)
	    and (numerator % gcd_of_fraction == 0)
	    and (denominator % gcd_of_fraction == 0)
	), "Error in function gcd(...,...)"

	return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)


def  a__       (    _SCREAMING_SNAKE_CASE   :       int				)     ->					Dict:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (n >= 0), "'n' must been a int and >= 0"

	UpperCAmelCase_     :      str						=  1  # this will be return.

	for factor in range(1	,				n + 1				):
		ans *= factor

	return ans





def  a__       (    _SCREAMING_SNAKE_CASE   :       Any				)     ->					List[Any]:


	"""simple docstring"""





	assert isinstance(_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE				) and (n >= 0), "'n' must been an int and >= 0"

	UpperCAmelCase_     :      Dict						=  0
	UpperCAmelCase_     :      Any						=  1
	UpperCAmelCase_     :      Any						=  1  # this will be return

	for _ in range(n - 1				):
		UpperCAmelCase_     :      List[str]						=  ans
		ans += fiba
		UpperCAmelCase_     :      Dict						=  tmp

	return ans











from timeit import timeit

_lowerCAmelCase				:   Tuple						       =						{
    '''MALAYALAM''': True,
    '''String''': False,
    '''rotor''': True,
    '''level''': True,
    '''A''': True,
    '''BB''': True,
    '''ABC''': False,
    '''amanaplanacanalpanama''': True,  # "a man a plan a canal panama"
}
# Ensure our test data is valid
assert all((key == key[::-1]) is value for key, value in test_data.items())

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    bool:
   A_       :					List[str]        =      0
   A_       :					str        =      len(_lowerCAmelCase						) - 1
   while start_i < end_i:
      if s[start_i] == s[end_i]:
         start_i += 1
         end_i -= 1
      else:
         return False
   return True

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    bool:
   A_       :					int        =      len(_lowerCAmelCase						) // 2
   A_       :					Union[str, Any]        =      len(_lowerCAmelCase						)

   # We need to traverse till half of the length of string
   # as we can get access of the i'th last element from
   # i'th index.
   # eg: [0,1,2,3,4,5] => 4th index can be accessed
   # with the help of 1st index (i==n-i-1)
   # where n is length of string
   return all(s[i] == s[n - i - 1] for i in range(_lowerCAmelCase						)						)

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    bool:
   if len(_lowerCAmelCase						) <= 2:
      return True
   if s[0] == s[len(_lowerCAmelCase						) - 1]:
      return is_palindrome_recursive(s[1:-1]						)
   else:
      return False

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    bool:
   return s == s[::-1]

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    None:
   A_       :					int        =      f"all({name}(key) is value for key, value in test_data.items())"
   A_       :					List[str]        =      f"from __main__ import test_data, {name}"
   A_       :					str        =      500000
   A_       :					List[str]        =      timeit(stmt=_lowerCAmelCase					,					setup=_lowerCAmelCase					,					number=_lowerCAmelCase						)
   print(f"{name:<35} finished {number:,} runs in {result:.5f} seconds"						)


if __name__ == "__main__":
 for key, value in test_data.items():
  assert is_palindrome(key) is is_palindrome_recursive(key)
  assert is_palindrome(key) is is_palindrome_slice(key)
  print(F'''{key:21} {value}''')
 print('''a man a plan a canal panama''')

 # finished 500,000 runs in 0.46793 seconds
 benchmark_function('''is_palindrome_slice''')
 # finished 500,000 runs in 0.85234 seconds
 benchmark_function('''is_palindrome''')
 # finished 500,000 runs in 1.32028 seconds
 benchmark_function('''is_palindrome_recursive''')
 # finished 500,000 runs in 2.08679 seconds
 benchmark_function('''is_palindrome_traversal''')
