


from timeit import timeit

__lowerCAmelCase	: int  				={
    '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							(      lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     Optional[int]					=		0
						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		len(lowercase__      ) - 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							(      lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		len(lowercase__      ) // 2
						__SCREAMING_SNAKE_CASE						:     str					=		len(lowercase__      )

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


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


def        _UpperCamelCase							(      lowercase__      ):
						return s == s[::-1]


def        _UpperCamelCase							(      lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     List[str]					=		F'''all({name}(key) is value for key, value in test_data.items())'''
						__SCREAMING_SNAKE_CASE						:     Any					=		F'''from __main__ import test_data, {name}'''
						__SCREAMING_SNAKE_CASE						:     Dict					=		500000
						__SCREAMING_SNAKE_CASE						:     List[str]					=		timeit(stmt=lowercase__    ,       setup=lowercase__    ,       number=lowercase__      )
						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'''







import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin
class 				__SCREAMING_SNAKE_CASE  (lowerCamelCase_       ,							lowerCamelCase_      ):






				"""simple docstring"""







				@register_to_config
				def __init__(  self     :					Dict					,				*,
				    __a     :					int = 4					,				__a     :					int = 7_68					,				__a     :					int					,				__a     :					int					,				):
								super().__init__()

								_a								= nn.Parameter(torch.zeros(__a					)					)

								# parameters for additional clip time embeddings
								_a								= nn.Linear(__a					,				__a					)
								_a								= nn.Linear(__a					,				__a					)

								# parameters for encoder hidden states
								_a								= clip_extra_context_tokens
								_a								= nn.Linear(
								    __a					,				self.clip_extra_context_tokens * cross_attention_dim					)
								_a								= nn.Linear(__a					,				__a					)
								_a								= nn.LayerNorm(__a					)




				def   UpperCamelCase__   (  self     :					Optional[Any]					,				*, __a     :					Tuple					,				__a     :					Union[str, Any]					,				__a     :					Any					,				__a     :					List[Any]					):
								if do_classifier_free_guidance:
												# Add the classifier free guidance embeddings to the image embeddings
												_a								= image_embeddings.shape[0]
												_a								= self.learned_classifier_free_guidance_embeddings.unsqueeze(0					)
												_a								= classifier_free_guidance_embeddings.expand(
												    __a					,				-1					)
												_a								= torch.cat([classifier_free_guidance_embeddings, image_embeddings]					,				dim=0					)

								# The image embeddings batch size and the text embeddings batch size are equal
								assert image_embeddings.shape[0] == prompt_embeds.shape[0]

								_a								= prompt_embeds.shape[0]

								# "Specifically, we modify the architecture described in Nichol et al. (2021) by projecting and
								# adding CLIP embeddings to the existing timestep embedding, ...
								_a								= self.embedding_proj(__a					)
								_a								= self.clip_image_embeddings_project_to_time_embeddings(__a					)
								_a								= time_projected_image_embeddings + time_projected_prompt_embeds

								# ... and by projecting CLIP embeddings into four
								# extra tokens of context that are concatenated to the sequence of outputs from the GLIDE text encoder"
								_a								= self.clip_extra_context_tokens_proj(__a					)
								_a								= clip_extra_context_tokens.reshape(__a					,				-1					,				self.clip_extra_context_tokens					)
								_a								= clip_extra_context_tokens.permute(0					,				2					,				1					)

								_a								= self.encoder_hidden_states_proj(__a					)
								_a								= self.text_encoder_hidden_states_norm(__a					)
								_a								= torch.cat([clip_extra_context_tokens, text_encoder_hidden_states]					,				dim=1					)

								return text_encoder_hidden_states, additive_clip_time_embeddings
