


"""simple docstring"""
def 		lowercase							(     _snake_case						:      Tuple     ,   _snake_case						:      Dict     )     ->bool:
	"""simple docstring"""





	__snake_case	:						Dict						=				len(UpperCamelCase_     ) + 1
	__snake_case	:						Tuple						=				len(UpperCamelCase_     ) + 1

	# dp is a 2d matrix where dp[i][j] denotes whether prefix string of
	# length i of input_string matches with prefix string of length j of
	# given pattern.
	# "dp" stands for dynamic programming.
	__snake_case	:						int						=				[[0 for i in range(UpperCamelCase_     )] for j in range(UpperCamelCase_     )]

	# since string of zero length match pattern of zero length
	__snake_case	:						int						=				1

	# since pattern of zero length will never match with string of non-zero length
	for i in range(1     ,   UpperCamelCase_     ):
		__snake_case	:						Optional[Any]						=				0

	# since string of zero length will match with pattern where there
	# is at least one * alternatively
	for j in range(1     ,   UpperCamelCase_     ):
		__snake_case	:						Optional[int]						=				dp[0][j - 2] if pattern[j - 1] == '''*''' else 0

	# now using bottom-up approach to find for all remaining lengths
	for i in range(1     ,   UpperCamelCase_     ):
		for j in range(1     ,   UpperCamelCase_     ):
			if input_string[i - 1] == pattern[j - 1] or pattern[j - 1] == ".":
				__snake_case	:						int						=				dp[i - 1][j - 1]

			elif pattern[j - 1] == "*":
				if dp[i][j - 2] == 1:
					__snake_case	:						Tuple						=				1
				elif pattern[j - 2] in (input_string[i - 1], "."):
					__snake_case	:						Any						=				dp[i - 1][j]
				else:
					__snake_case	:						Union[str, Any]						=				0
			else:
				__snake_case	:						str						=				0

	return bool(dp[-1][-1]     )


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			# inputing the strings
			# input_string = input("input a string :")
			# pattern = input("input a pattern :")

			SCREAMING_SNAKE_CASE :    Optional[int]									=				"""aab"""
			SCREAMING_SNAKE_CASE :    Tuple									=				"""c*a*b"""

			# using function to check whether given string matches the given pattern
			if match_pattern(input_string, pattern):
						print(F'{input_string} matches the given pattern {pattern}')
			else:
						print(F'{input_string} does not match with the given pattern {pattern}')







import flax.linen as nn
import jax.numpy as jnp

from .attention_flax import FlaxTransformeraDModel
from .resnet_flax import FlaxDownsampleaD, FlaxResnetBlockaD, FlaxUpsampleaD




class 						lowercase__  (						nn.Module  ):
	A__    :   int
	A__    :   int
	A__    :   float				       =0.0
	A__    :   int				       =1
	A__    :   int				       =1
	A__    :   bool				       =True
	A__    :   bool				       =False
	A__    :   bool				       =False
	A__    :   bool				       =False
	A__    :   jnp.dtype				       =jnp.floataa
	def      A_				(			self							:   Optional[Any]							):
						SCREAMING_SNAKE_CASE__													= []
						SCREAMING_SNAKE_CASE__													= []

						for i in range(self.num_layers							):
											SCREAMING_SNAKE_CASE__													= self.in_channels if i == 0 else self.out_channels

											SCREAMING_SNAKE_CASE__													= FlaxResnetBlockaD(
											    in_channels=UpperCAmelCase_       ,   out_channels=self.out_channels       ,   dropout_prob=self.dropout       ,   dtype=self.dtype       ,   )
											resnets.append(UpperCAmelCase_							)

											SCREAMING_SNAKE_CASE__													= FlaxTransformeraDModel(
											    in_channels=self.out_channels       ,   n_heads=self.num_attention_heads       ,   d_head=self.out_channels // self.num_attention_heads       ,   depth=1       ,   use_linear_projection=self.use_linear_projection       ,   only_cross_attention=self.only_cross_attention       ,   use_memory_efficient_attention=self.use_memory_efficient_attention       ,   dtype=self.dtype       ,   )
											attentions.append(UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= resnets
						SCREAMING_SNAKE_CASE__													= attentions

						if self.add_downsample:
											SCREAMING_SNAKE_CASE__													= FlaxDownsampleaD(self.out_channels       ,   dtype=self.dtype							)





	def __call__(			self							:   int       ,   UpperCAmelCase_							:   str       ,   UpperCAmelCase_							:   Tuple       ,   UpperCAmelCase_							:   Dict       ,   UpperCAmelCase_							:   int=True							):
						SCREAMING_SNAKE_CASE__													= ()

						for resnet, attn in zip(self.resnets       ,   self.attentions							):
											SCREAMING_SNAKE_CASE__													= resnet(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)
											SCREAMING_SNAKE_CASE__													= attn(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)
											output_states += (hidden_states,)

						if self.add_downsample:
											SCREAMING_SNAKE_CASE__													= self.downsamplers_a(UpperCAmelCase_							)
											output_states += (hidden_states,)

						return hidden_states, output_states





class 						lowercase__  (						nn.Module  ):
	A__    :   int
	A__    :   int
	A__    :   float				       =0.0
	A__    :   int				       =1
	A__    :   bool				       =True
	A__    :   jnp.dtype				       =jnp.floataa
	def      A_				(			self							:   List[str]							):
						SCREAMING_SNAKE_CASE__													= []

						for i in range(self.num_layers							):
											SCREAMING_SNAKE_CASE__													= self.in_channels if i == 0 else self.out_channels

											SCREAMING_SNAKE_CASE__													= FlaxResnetBlockaD(
											    in_channels=UpperCAmelCase_       ,   out_channels=self.out_channels       ,   dropout_prob=self.dropout       ,   dtype=self.dtype       ,   )
											resnets.append(UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= resnets

						if self.add_downsample:
											SCREAMING_SNAKE_CASE__													= FlaxDownsampleaD(self.out_channels       ,   dtype=self.dtype							)





	def __call__(			self							:   List[str]       ,   UpperCAmelCase_							:   Any       ,   UpperCAmelCase_							:   Union[str, Any]       ,   UpperCAmelCase_							:   List[Any]=True							):
						SCREAMING_SNAKE_CASE__													= ()

						for resnet in self.resnets:
											SCREAMING_SNAKE_CASE__													= resnet(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)
											output_states += (hidden_states,)

						if self.add_downsample:
											SCREAMING_SNAKE_CASE__													= self.downsamplers_a(UpperCAmelCase_							)
											output_states += (hidden_states,)

						return hidden_states, output_states





class 						lowercase__  (						nn.Module  ):
	A__    :   int
	A__    :   int
	A__    :   int
	A__    :   float				       =0.0
	A__    :   int				       =1
	A__    :   int				       =1
	A__    :   bool				       =True
	A__    :   bool				       =False
	A__    :   bool				       =False
	A__    :   bool				       =False
	A__    :   jnp.dtype				       =jnp.floataa
	def      A_				(			self							:   List[str]							):
						SCREAMING_SNAKE_CASE__													= []
						SCREAMING_SNAKE_CASE__													= []

						for i in range(self.num_layers							):
											SCREAMING_SNAKE_CASE__													= self.in_channels if (i == self.num_layers - 1) else self.out_channels
											SCREAMING_SNAKE_CASE__													= self.prev_output_channel if i == 0 else self.out_channels

											SCREAMING_SNAKE_CASE__													= FlaxResnetBlockaD(
											    in_channels=resnet_in_channels + res_skip_channels       ,   out_channels=self.out_channels       ,   dropout_prob=self.dropout       ,   dtype=self.dtype       ,   )
											resnets.append(UpperCAmelCase_							)

											SCREAMING_SNAKE_CASE__													= FlaxTransformeraDModel(
											    in_channels=self.out_channels       ,   n_heads=self.num_attention_heads       ,   d_head=self.out_channels // self.num_attention_heads       ,   depth=1       ,   use_linear_projection=self.use_linear_projection       ,   only_cross_attention=self.only_cross_attention       ,   use_memory_efficient_attention=self.use_memory_efficient_attention       ,   dtype=self.dtype       ,   )
											attentions.append(UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= resnets
						SCREAMING_SNAKE_CASE__													= attentions

						if self.add_upsample:
											SCREAMING_SNAKE_CASE__													= FlaxUpsampleaD(self.out_channels       ,   dtype=self.dtype							)





	def __call__(			self							:   str       ,   UpperCAmelCase_							:   str       ,   UpperCAmelCase_							:   Any       ,   UpperCAmelCase_							:   str       ,   UpperCAmelCase_							:   Any       ,   UpperCAmelCase_							:   Union[str, Any]=True							):
						for resnet, attn in zip(self.resnets       ,   self.attentions							):
											# pop res hidden states
											SCREAMING_SNAKE_CASE__													= res_hidden_states_tuple[-1]
											SCREAMING_SNAKE_CASE__													= res_hidden_states_tuple[:-1]
											SCREAMING_SNAKE_CASE__													= jnp.concatenate((hidden_states, res_hidden_states)       ,   axis=-1							)

											SCREAMING_SNAKE_CASE__													= resnet(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)
											SCREAMING_SNAKE_CASE__													= attn(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)

						if self.add_upsample:
											SCREAMING_SNAKE_CASE__													= self.upsamplers_a(UpperCAmelCase_							)

						return hidden_states





class 						lowercase__  (						nn.Module  ):
	A__    :   int
	A__    :   int
	A__    :   int
	A__    :   float				       =0.0
	A__    :   int				       =1
	A__    :   bool				       =True
	A__    :   jnp.dtype				       =jnp.floataa
	def      A_				(			self							:   List[Any]							):
						SCREAMING_SNAKE_CASE__													= []

						for i in range(self.num_layers							):
											SCREAMING_SNAKE_CASE__													= self.in_channels if (i == self.num_layers - 1) else self.out_channels
											SCREAMING_SNAKE_CASE__													= self.prev_output_channel if i == 0 else self.out_channels

											SCREAMING_SNAKE_CASE__													= FlaxResnetBlockaD(
											    in_channels=resnet_in_channels + res_skip_channels       ,   out_channels=self.out_channels       ,   dropout_prob=self.dropout       ,   dtype=self.dtype       ,   )
											resnets.append(UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= resnets

						if self.add_upsample:
											SCREAMING_SNAKE_CASE__													= FlaxUpsampleaD(self.out_channels       ,   dtype=self.dtype							)





	def __call__(			self							:   Tuple       ,   UpperCAmelCase_							:   Any       ,   UpperCAmelCase_							:   Any       ,   UpperCAmelCase_							:   Dict       ,   UpperCAmelCase_							:   Dict=True							):
						for resnet in self.resnets:
											# pop res hidden states
											SCREAMING_SNAKE_CASE__													= res_hidden_states_tuple[-1]
											SCREAMING_SNAKE_CASE__													= res_hidden_states_tuple[:-1]
											SCREAMING_SNAKE_CASE__													= jnp.concatenate((hidden_states, res_hidden_states)       ,   axis=-1							)

											SCREAMING_SNAKE_CASE__													= resnet(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)

						if self.add_upsample:
											SCREAMING_SNAKE_CASE__													= self.upsamplers_a(UpperCAmelCase_							)

						return hidden_states





class 						lowercase__  (						nn.Module  ):
	A__    :   int
	A__    :   float				       =0.0
	A__    :   int				       =1
	A__    :   int				       =1
	A__    :   bool				       =False
	A__    :   bool				       =False
	A__    :   jnp.dtype				       =jnp.floataa
	def      A_				(			self							:   Optional[int]							):
						# there is always at least one resnet
						SCREAMING_SNAKE_CASE__													= [
						    FlaxResnetBlockaD(
						        in_channels=self.in_channels       ,   out_channels=self.in_channels       ,   dropout_prob=self.dropout       ,   dtype=self.dtype       ,   )
						]

						SCREAMING_SNAKE_CASE__													= []

						for _ in range(self.num_layers							):
											SCREAMING_SNAKE_CASE__													= FlaxTransformeraDModel(
											    in_channels=self.in_channels       ,   n_heads=self.num_attention_heads       ,   d_head=self.in_channels // self.num_attention_heads       ,   depth=1       ,   use_linear_projection=self.use_linear_projection       ,   use_memory_efficient_attention=self.use_memory_efficient_attention       ,   dtype=self.dtype       ,   )
											attentions.append(UpperCAmelCase_							)

											SCREAMING_SNAKE_CASE__													= FlaxResnetBlockaD(
											    in_channels=self.in_channels       ,   out_channels=self.in_channels       ,   dropout_prob=self.dropout       ,   dtype=self.dtype       ,   )
											resnets.append(UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= resnets
						SCREAMING_SNAKE_CASE__													= attentions





	def __call__(			self							:   str       ,   UpperCAmelCase_							:   Union[str, Any]       ,   UpperCAmelCase_							:   Optional[int]       ,   UpperCAmelCase_							:   List[str]       ,   UpperCAmelCase_							:   Any=True							):
						SCREAMING_SNAKE_CASE__													= self.resnets[0](UpperCAmelCase_       ,   UpperCAmelCase_							)
						for attn, resnet in zip(self.attentions       ,   self.resnets[1:]							):
											SCREAMING_SNAKE_CASE__													= attn(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)
											SCREAMING_SNAKE_CASE__													= resnet(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)

						return hidden_states





