


from timeit import timeit

snake_case    :   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     __lowerCamelCase						(			UpperCAmelCase_						:		str						):




      """simple docstring"""





      a						:Union[str, Any]										=	0
      a						:Tuple										=	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     __lowerCamelCase						(			UpperCAmelCase_						:		str						):




      """simple docstring"""





      a						:str										=	len(UpperCAmelCase_						) // 2
      a						:List[str]										=	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     __lowerCamelCase						(			UpperCAmelCase_						:		str						):




      """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     __lowerCamelCase						(			UpperCAmelCase_						:		str						):




      """simple docstring"""





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




      """simple docstring"""





      a						:Optional[int]										=	F'''all({name}(key) is value for key, value in test_data.items())'''
      a						:str										=	F'''from __main__ import test_data, {name}'''
      a						:List[Any]										=	50_0000
      a						:Tuple										=	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 ...utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_torch_available,
    is_transformers_available,
)


try:
     if not (is_transformers_available() and is_torch_available()):
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
     from .multicontrolnet import MultiControlNetModel
     from .pipeline_controlnet import StableDiffusionControlNetPipeline
     from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline
     from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline


if is_transformers_available() and is_flax_available():
     from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline





