


'''simple docstring'''



from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxCrossAttnUpBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
    FlaxUpBlockaD,
)





@flax.struct.dataclass
class 				__UpperCamelCase							(						snake_case_   ):
	A_           =       42





@flax_register_to_config
class 				__UpperCamelCase							(						nn.Module						, snake_case_						, snake_case_   ):
	A_           =       32
	A_           =       4
	A_           =       4
	A_           =       (
	    "CrossAttnDownBlock2D",
	    "CrossAttnDownBlock2D",
	    "CrossAttnDownBlock2D",
	    "DownBlock2D",
	)
	A_           =       ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")
	A_           =       False
	A_           =       (320, 640, 1280, 1280)
	A_           =       2
	A_           =       8
	A_           =       None
	A_           =       1280
	A_           =       0.0
	A_           =       False
	A_           =       jnp.floataa
	A_           =       True
	A_           =       0
	A_           =       False




	def  __UpperCAmelCase				(  self		,							__a				):

						'''simple docstring'''





						__a     :			Optional[int]          =    (1, self.in_channels, self.sample_size, self.sample_size)
						__a     :			Union[str, Any]          =    jnp.zeros(lowerCAmelCase__		,							dtype=jnp.floataa				)
						__a     :			Union[str, Any]          =    jnp.ones((1,)		,							dtype=jnp.intaa				)
						__a     :			Any          =    jnp.zeros((1, 1, self.cross_attention_dim)		,							dtype=jnp.floataa				)

						__a     :			Dict          =    jax.random.split(lowerCAmelCase__				)
						__a     :			Dict          =    {'''params''': params_rng, '''dropout''': dropout_rng}

						return self.init(lowerCAmelCase__		,							lowerCAmelCase__		,							lowerCAmelCase__		,							lowerCAmelCase__				)["params"]




	def  __UpperCAmelCase				(  self				):

						'''simple docstring'''





						__a     :			List[Any]          =    self.block_out_channels
						__a     :			Any          =    block_out_channels[0] * 4

						if self.num_attention_heads is not None:
											raise ValueError(
											    'At the moment it is not possible to define the number of attention heads via `num_attention_heads` because of a naming issue as described in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131. Passing `num_attention_heads` will only be supported in diffusers v0.19.'				)

						# If `num_attention_heads` is not defined (which is the case for most models)
						# it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
						# The reason for this behavior is to correct for incorrectly named variables that were introduced
						# when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
						# Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
						# which is why we correct for the naming here.
						__a     :			Dict          =    self.num_attention_heads or self.attention_head_dim

						# input
						__a     :			List[Any]          =    nn.Conv(
						    block_out_channels[0]		,							kernel_size=(3, 3)		,							strides=(1, 1)		,							padding=((1, 1), (1, 1))		,							dtype=self.dtype		,							)

						# time
						__a     :			Dict          =    FlaxTimesteps(
						    block_out_channels[0]		,							flip_sin_to_cos=self.flip_sin_to_cos		,							freq_shift=self.config.freq_shift				)
						__a     :			List[Any]          =    FlaxTimestepEmbedding(lowerCAmelCase__		,							dtype=self.dtype				)

						__a     :			Optional[int]          =    self.only_cross_attention
						if isinstance(lowerCAmelCase__		,							lowerCAmelCase__				):
											__a     :			Tuple          =    (only_cross_attention,) * len(self.down_block_types				)

						if isinstance(lowerCAmelCase__		,							lowerCAmelCase__				):
											__a     :			Optional[Any]          =    (num_attention_heads,) * len(self.down_block_types				)

						# down
						__a     :			Optional[int]          =    []
						__a     :			Any          =    block_out_channels[0]
						for i, down_block_type in enumerate(self.down_block_types				):
											__a     :			Optional[int]          =    output_channel
											__a     :			Tuple          =    block_out_channels[i]
											__a     :			List[str]          =    i == len(lowerCAmelCase__				) - 1

											if down_block_type == "CrossAttnDownBlock2D":
																__a     :			Union[str, Any]          =    FlaxCrossAttnDownBlockaD(
																    in_channels=lowerCAmelCase__		,							out_channels=lowerCAmelCase__		,							dropout=self.dropout		,							num_layers=self.layers_per_block		,							num_attention_heads=num_attention_heads[i]		,							add_downsample=not is_final_block		,							use_linear_projection=self.use_linear_projection		,							only_cross_attention=only_cross_attention[i]		,							use_memory_efficient_attention=self.use_memory_efficient_attention		,							dtype=self.dtype		,							)
											else:
																__a     :			str          =    FlaxDownBlockaD(
																    in_channels=lowerCAmelCase__		,							out_channels=lowerCAmelCase__		,							dropout=self.dropout		,							num_layers=self.layers_per_block		,							add_downsample=not is_final_block		,							dtype=self.dtype		,							)

											down_blocks.append(lowerCAmelCase__				)
						__a     :			int          =    down_blocks

						# mid
						__a     :			List[str]          =    FlaxUNetMidBlockaDCrossAttn(
						    in_channels=block_out_channels[-1]		,							dropout=self.dropout		,							num_attention_heads=num_attention_heads[-1]		,							use_linear_projection=self.use_linear_projection		,							use_memory_efficient_attention=self.use_memory_efficient_attention		,							dtype=self.dtype		,							)

						# up
						__a     :			str          =    []
						__a     :			Optional[int]          =    list(reversed(lowerCAmelCase__				)				)
						__a     :			List[str]          =    list(reversed(lowerCAmelCase__				)				)
						__a     :			str          =    list(reversed(lowerCAmelCase__				)				)
						__a     :			List[Any]          =    reversed_block_out_channels[0]
						for i, up_block_type in enumerate(self.up_block_types				):
											__a     :			Optional[Any]          =    output_channel
											__a     :			Dict          =    reversed_block_out_channels[i]
											__a     :			int          =    reversed_block_out_channels[min(i + 1		,							len(lowerCAmelCase__				) - 1				)]

											__a     :			int          =    i == len(lowerCAmelCase__				) - 1

											if up_block_type == "CrossAttnUpBlock2D":
																__a     :			Union[str, Any]          =    FlaxCrossAttnUpBlockaD(
																    in_channels=lowerCAmelCase__		,							out_channels=lowerCAmelCase__		,							prev_output_channel=lowerCAmelCase__		,							num_layers=self.layers_per_block + 1		,							num_attention_heads=reversed_num_attention_heads[i]		,							add_upsample=not is_final_block		,							dropout=self.dropout		,							use_linear_projection=self.use_linear_projection		,							only_cross_attention=only_cross_attention[i]		,							use_memory_efficient_attention=self.use_memory_efficient_attention		,							dtype=self.dtype		,							)
											else:
																__a     :			Optional[Any]          =    FlaxUpBlockaD(
																    in_channels=lowerCAmelCase__		,							out_channels=lowerCAmelCase__		,							prev_output_channel=lowerCAmelCase__		,							num_layers=self.layers_per_block + 1		,							add_upsample=not is_final_block		,							dropout=self.dropout		,							dtype=self.dtype		,							)

											up_blocks.append(lowerCAmelCase__				)
											__a     :			Any          =    output_channel
						__a     :			Dict          =    up_blocks

						# out
						__a     :			int          =    nn.GroupNorm(num_groups=32		,							epsilon=1E-5				)
						__a     :			int          =    nn.Conv(
						    self.out_channels		,							kernel_size=(3, 3)		,							strides=(1, 1)		,							padding=((1, 1), (1, 1))		,							dtype=self.dtype		,							)





	def __call__(  self		,							__a		,							__a		,							__a		,							__a=None		,							__a=None		,							__a = True		,							__a = False		,							):

						'''simple docstring'''





						if not isinstance(lowerCAmelCase__		,							jnp.ndarray				):
											__a     :			Any          =    jnp.array([timesteps]		,							dtype=jnp.intaa				)
						elif isinstance(lowerCAmelCase__		,							jnp.ndarray				) and len(timesteps.shape				) == 0:
											__a     :			Dict          =    timesteps.astype(dtype=jnp.floataa				)
											__a     :			int          =    jnp.expand_dims(lowerCAmelCase__		,							0				)

						__a     :			int          =    self.time_proj(lowerCAmelCase__				)
						__a     :			Dict          =    self.time_embedding(lowerCAmelCase__				)

						# 2. pre-process
						__a     :			List[str]          =    jnp.transpose(lowerCAmelCase__		,							(0, 2, 3, 1)				)
						__a     :			str          =    self.conv_in(lowerCAmelCase__				)

						# 3. down
						__a     :			Union[str, Any]          =    (sample,)
						for down_block in self.down_blocks:
											if isinstance(lowerCAmelCase__		,							lowerCAmelCase__				):
																__a     :			Optional[int]          =    down_block(lowerCAmelCase__		,							lowerCAmelCase__		,							lowerCAmelCase__		,							deterministic=not train				)
											else:
																__a     :			List[str]          =    down_block(lowerCAmelCase__		,							lowerCAmelCase__		,							deterministic=not train				)
											down_block_res_samples += res_samples

						if down_block_additional_residuals is not None:
											__a     :			Optional[int]          =    ()

											for down_block_res_sample, down_block_additional_residual in zip(
											    lowerCAmelCase__		,							lowerCAmelCase__				):
																down_block_res_sample += down_block_additional_residual
																new_down_block_res_samples += (down_block_res_sample,)

											__a     :			List[str]          =    new_down_block_res_samples

						# 4. mid
						__a     :			Optional[int]          =    self.mid_block(lowerCAmelCase__		,							lowerCAmelCase__		,							lowerCAmelCase__		,							deterministic=not train				)

						if mid_block_additional_residual is not None:
											sample += mid_block_additional_residual

						# 5. up
						for up_block in self.up_blocks:
											__a     :			str          =    down_block_res_samples[-(self.layers_per_block + 1) :]
											__a     :			Optional[Any]          =    down_block_res_samples[: -(self.layers_per_block + 1)]
											if isinstance(lowerCAmelCase__		,							lowerCAmelCase__				):
																__a     :			Optional[Any]          =    up_block(
																    lowerCAmelCase__		,							temb=lowerCAmelCase__		,							encoder_hidden_states=lowerCAmelCase__		,							res_hidden_states_tuple=lowerCAmelCase__		,							deterministic=not train		,							)
											else:
																__a     :			Dict          =    up_block(lowerCAmelCase__		,							temb=lowerCAmelCase__		,							res_hidden_states_tuple=lowerCAmelCase__		,							deterministic=not train				)

        # 6. post-process
						__a     :			Optional[int]          =    self.conv_norm_out(lowerCAmelCase__				)
						__a     :			Any          =    nn.silu(lowerCAmelCase__				)
						__a     :			Dict          =    self.conv_out(lowerCAmelCase__				)
						__a     :			Union[str, Any]          =    jnp.transpose(lowerCAmelCase__		,							(0, 3, 1, 2)				)

						if not return_dict:
											return (sample,)

						return FlaxUNetaDConditionOutput(sample=lowerCAmelCase__				)








'''simple docstring'''



lowerCAmelCase_  :							List[Any]             =    [0, 2, 4, 6, 8]
lowerCAmelCase_  :							str             =    [1, 3, 5, 7, 9]
def        UpperCAmelCase (    A	:					int       ,		A	:					int       ,		A	:					list[int]       ,		A	:					int					):
							if remaining_length == 0:
														if digits[0] == 0 or digits[-1] == 0:
																					return 0

														for i in range(length // 2 - 1       ,		-1       ,		-1					):
																					remainder += digits[i] + digits[length - i - 1]

																					if remainder % 2 == 0:
																												return 0

																					remainder //= 10

														return 1

							if remaining_length == 1:
														if remainder % 2 == 0:
																					return 0

														SCREAMING_SNAKE_CASE       :   List[Any]         =      0
														for digit in range(10					):
																					SCREAMING_SNAKE_CASE       :   Optional[Any]         =      digit
																					result += reversible_numbers(
																					    0       ,		(remainder + 2 * digit) // 10       ,		A       ,		A					)
														return result

							SCREAMING_SNAKE_CASE       :   List[str]         =      0
							for digita in range(10					):
														SCREAMING_SNAKE_CASE       :   int         =      digita

														if (remainder + digita) % 2 == 0:
																					SCREAMING_SNAKE_CASE       :   str         =      ODD_DIGITS
														else:
																					SCREAMING_SNAKE_CASE       :   List[str]         =      EVEN_DIGITS

														for digita in other_parity_digits:
																					SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      digita
																					result += reversible_numbers(
																					    remaining_length - 2       ,		(remainder + digita + digita) // 10       ,		A       ,		A       ,		)
							return result
def        UpperCAmelCase (    A	:					int = 9					):
							SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      0
							for length in range(1       ,		max_power + 1					):
														result += reversible_numbers(A       ,		0       ,		[0] * length       ,		A					)
							return result


if __name__ == "__main__":
							print(f'{solution() = }')




