'''simple docstring'''




from typing import Optional

from torch import nn

from .transformer_ad import TransformeraDModel, TransformeraDModelOutput




class     a__      (   nn.Module ):






     def __init__( self		:		Dict  ,				a		:		int = 16  ,				a		:		int = 88  ,				a		:		Optional[int] = None  ,				a		:		int = 1  ,				a		:		float = 0.0  ,				a		:		int = 32  ,				a		:		Optional[int] = None  ,				a		:		bool = False  ,				a		:		Optional[int] = None  ,				a		:		Optional[int] = None  ,				a		:		str = "geglu"  ,				a		:		Optional[int] = None  ,				):





         """simple docstring"""



         super().__init__()
         __lowerCamelCase		=  nn.ModuleList(
             [
                 TransformeraDModel(
                     num_attention_heads=a  ,				attention_head_dim=a  ,				in_channels=a  ,				num_layers=a  ,				dropout=a  ,				norm_num_groups=a  ,				cross_attention_dim=a  ,				attention_bias=a  ,				sample_size=a  ,				num_vector_embeds=a  ,				activation_fn=a  ,				num_embeds_ada_norm=a  ,				)
                 for _ in range(2    )
             ]    )

         # Variables that can be set by a pipeline:

         # The ratio of transformer1 to transformer2's output states to be combined during inference
         __lowerCamelCase		=  0.5

         # The shape of `encoder_hidden_states` is expected to be
         # `(batch_size, condition_lengths[0]+condition_lengths[1], num_features)`
         __lowerCamelCase		=  [77, 2_57]

         # Which transformer to use to encode which condition.
         # E.g. `(1, 0)` means that we'll use `transformers[1](conditions[0])` and `transformers[0](conditions[1])`
         __lowerCamelCase		=  [1, 0]






     def    SCREAMING_SNAKE_CASE__   ( self		:		Optional[Any]  ,				a		:		Any  ,				a		:		List[Any]  ,				a		:		Optional[Any]=None  ,				a		:		Optional[Any]=None  ,				a		:		Tuple=None  ,				a		:		bool = True  ,				):





         """simple docstring"""



         __lowerCamelCase		=  hidden_states

         __lowerCamelCase		=  []
         __lowerCamelCase		=  0
         # attention_mask is not used yet
         for i in range(2    ):
             # for each of the two transformers, pass the corresponding condition tokens
             __lowerCamelCase		=  encoder_hidden_states[:, tokens_start : tokens_start + self.condition_lengths[i]]
             __lowerCamelCase		=  self.transformer_index_for_condition[i]
             __lowerCamelCase		=  self.transformers[transformer_index](
                 a  ,				encoder_hidden_states=a  ,				timestep=a  ,				cross_attention_kwargs=a  ,				return_dict=a  ,				)[0]
             encoded_states.append(encoded_state - input_states    )
             tokens_start += self.condition_lengths[i]

         __lowerCamelCase		=  encoded_states[0] * self.mix_ratio + encoded_states[1] * (1 - self.mix_ratio)
         __lowerCamelCase		=  output_states + input_states

         if not return_dict:
             return (output_states,)

         return TransformeraDModelOutput(sample=a    )






def 						lowerCamelCase__    (		):







	'''simple docstring'''





	snake_case_		    =     []
	snake_case_		    =     1

	while len(_A							) < 1E6:
		constant.append(str(_A							)							)
		i += 1

	snake_case_		    =     "".join(_A							)

	return (
	    int(constant[0]							)
	    * int(constant[9]							)
	    * int(constant[99]							)
	    * int(constant[999]							)
	    * int(constant[9999]							)
	    * int(constant[99999]							)
	    * int(constant[999999]							)
	)


if __name__ == "__main__":
		print(solution())
