





"""simple docstring"""



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 		__lowercase					(       snake_case_  :  Dict						)       ->bool:



    '''simple docstring'''







    __A   :						Optional[Any]									=					0
    __A   :						Optional[Any]									=					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 		__lowercase					(       snake_case_  :  Optional[Any]						)       ->bool:



    '''simple docstring'''







    __A   :						str									=					len(a__						) // 2
    __A   :						Optional[int]									=					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 		__lowercase					(       snake_case_  :  Union[str, Any]						)       ->bool:



    '''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 		__lowercase					(       snake_case_  :  Tuple						)       ->bool:



    '''simple docstring'''







    return s == s[::-1]







def 		__lowercase					(       snake_case_  :  Optional[int]						)       ->None:



    '''simple docstring'''







    __A   :						Any									=					F"""all({name}(key) is value for key, value in test_data.items())"""
    __A   :						Union[str, Any]									=					F"""from __main__ import test_data, {name}"""
    __A   :						Optional[int]									=					500000
    __A   :						Any									=					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""")











"""simple docstring"""



from typing import TYPE_CHECKING

from ....utils import _LazyModule


a_			=      {"""tokenization_tapex""": ["""TapexTokenizer"""]}


if TYPE_CHECKING:
       from .tokenization_tapex import TapexTokenizer


else:
       import sys

       a_			=      _LazyModule(__name__, globals()["""__file__"""], _import_structure)




