






from timeit import timeit

a_							=    {
    '''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        _a  (     UpperCamelCase_					:				str   ) ->   bool:
						"""simple docstring"""







						lowerCAmelCase__       =						0
						lowerCAmelCase__       =						len(UpperCamelCase_   ) - 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        _a  (     UpperCamelCase_					:				str   ) ->   bool:
						"""simple docstring"""







						lowerCAmelCase__       =						len(UpperCamelCase_   ) // 2
						lowerCAmelCase__       =						len(UpperCamelCase_   )

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


def        _a  (     UpperCamelCase_					:				str   ) ->   bool:
						"""simple docstring"""







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


def        _a  (     UpperCamelCase_					:				str   ) ->   bool:
						"""simple docstring"""







						return s == s[::-1]


def        _a  (     UpperCamelCase_					:				str   ) ->   None:
						"""simple docstring"""







						lowerCAmelCase__       =						F"all({name}(key) is value for key, value in test_data.items())"
						lowerCAmelCase__       =						F"from __main__ import test_data, {name}"
						lowerCAmelCase__       =						500_000
						lowerCAmelCase__       =						timeit(stmt=UpperCamelCase_    ,   setup=UpperCamelCase_    ,   number=UpperCamelCase_   )
						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''')














from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


a_							=    {'''configuration_sew''': ['''SEW_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''SEWConfig''']}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a_							=    [
	    '''SEW_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''SEWForCTC''',
	    '''SEWForSequenceClassification''',
	    '''SEWModel''',
	    '''SEWPreTrainedModel''',
	]

if TYPE_CHECKING:
	from .configuration_sew import SEW_PRETRAINED_CONFIG_ARCHIVE_MAP, SEWConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_sew import (
		    SEW_PRETRAINED_MODEL_ARCHIVE_LIST,
		    SEWForCTC,
		    SEWForSequenceClassification,
		    SEWModel,
		    SEWPreTrainedModel,
		)


else:
	import sys

	a_							=    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






