


from timeit import timeit

_snake_case  :	Dict			      =       {
    "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        lowerCAmelCase_  (      __lowerCamelCase			):
							__snake_case	:    List[str]											=     0
							__snake_case	:    List[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        lowerCAmelCase_  (      __lowerCamelCase			):
							__snake_case	:    str											=     len(__lowerCamelCase			) // 2
							__snake_case	:    Tuple											=     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        lowerCAmelCase_  (      __lowerCamelCase			):
							if len(__lowerCamelCase			) <= 2:
														return True
							if s[0] == s[len(__lowerCamelCase			) - 1]:
														return is_palindrome_recursive(s[1:-1]			)
							else:
														return False







def        lowerCAmelCase_  (      __lowerCamelCase			):
							return s == s[::-1]







def        lowerCAmelCase_  (      __lowerCamelCase			):
							__snake_case	:    Optional[int]											=     F'all({name}(key) is value for key, value in test_data.items())'
							__snake_case	:    Optional[int]											=     F'from __main__ import test_data, {name}'
							__snake_case	:    Optional[Any]											=     5_0_0_0_0_0
							__snake_case	:    List[Any]											=     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")





def        lowerCAmelCase_  (      __lowerCamelCase							,			__lowerCamelCase			):
							return int((input_a, input_a).count(0			) == 0			)







def        lowerCAmelCase_  (      ):
							assert and_gate(0							,			0			) == 0
							assert and_gate(0							,			1			) == 0
							assert and_gate(1							,			0			) == 0
							assert and_gate(1							,			1			) == 1


if __name__ == "__main__":
			test_and_gate()
			print(and_gate(1, 0))
			print(and_gate(0, 0))
			print(and_gate(0, 1))
			print(and_gate(1, 1))

