






"""simple docstring"""




from timeit import timeit

__magic_name__:					List[Any]							=     {
    "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    UpperCamelCase						(	_A			):






						"""simple docstring"""







						__magic_name__      :       List[Any]       						= 0
						__magic_name__      :       str       						= len(_A			) - 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    UpperCamelCase						(	_A			):






						"""simple docstring"""







						__magic_name__      :       List[Any]       						= len(_A			) // 2
						__magic_name__      :       Dict       						= len(_A			)

						# 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(_A			)			)

def    UpperCamelCase						(	_A			):






						"""simple docstring"""







						if len(_A			) <= 2:
												return True
						if s[0] == s[len(_A			) - 1]:
												return is_palindrome_recursive(s[1:-1]			)
						else:
												return False

def    UpperCamelCase						(	_A			):






						"""simple docstring"""







						return s == s[::-1]

def    UpperCamelCase						(	_A			):






						"""simple docstring"""







						__magic_name__      :       Tuple       						= f'all({name}(key) is value for key, value in test_data.items())'
						__magic_name__      :       str       						= f'from __main__ import test_data, {name}'
						__magic_name__      :       List[Any]       						= 500000
						__magic_name__      :       List[str]       						= timeit(stmt=_A,   setup=_A,   number=_A			)
						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")








import sys

from .dependency_versions_table import deps
from .utils.versions import require_version, require_version_core


# define which module versions we always want to check at run time
# (usually the ones defined in `install_requires` in setup.py)
#
# order specific notes:
# - tqdm must be checked before tokenizers

__magic_name__:					int							=     "python tqdm regex requests packaging filelock numpy tokenizers".split()
if sys.version_info < (3, 7):
		pkgs_to_check_at_runtime.append("dataclasses")
if sys.version_info < (3, 8):
		pkgs_to_check_at_runtime.append("importlib_metadata")

for pkg in pkgs_to_check_at_runtime:
		if pkg in deps:
				if pkg == "tokenizers":
						# must be loaded here, or else tqdm check may fail
						from .utils import is_tokenizers_available

						if not is_tokenizers_available():
								continue  # not required, check version only if installed

				require_version_core(deps[pkg])
		else:
				raise ValueError(F"""can't find {pkg} in {deps.keys()}, check dependency_versions_table.py""")

def    UpperCamelCase						(	_A,   _A=None			):






						"""simple docstring"""







						require_version(deps[pkg],   _A			)
