


from dataclasses import dataclass
from typing import Optional

import torch
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .attention import BasicTransformerBlock
from .modeling_utils import ModelMixin







@dataclass
class  snake_case__(							lowerCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__					:     torch.FloatTensor







class  snake_case__(							lowerCAmelCase__,  lowerCAmelCase__							):







						'''simple docstring'''




						@register_to_config
						def __init__( self      ,  __lowercase = 1_6      ,  __lowercase = 8_8      ,  __lowercase = None      ,  __lowercase = None      ,  __lowercase = 1      ,  __lowercase = 0.0      ,  __lowercase = 3_2      ,  __lowercase = None      ,  __lowercase = False      ,  __lowercase = None      ,  __lowercase = "geglu"      ,  __lowercase = True      ,  __lowercase = True      ,  )    ->			Any:
										super().__init__()
										lowerCAmelCase_       :					Tuple			 = num_attention_heads
										lowerCAmelCase_       :					int			 = attention_head_dim
										lowerCAmelCase_       :					List[Any]			 = num_attention_heads * attention_head_dim

										lowerCAmelCase_       :					Tuple			 = in_channels

										lowerCAmelCase_       :					List[Any]			 = torch.nn.GroupNorm(num_groups=lowercase_      ,  num_channels=lowercase_      ,  eps=1e-6      ,  affine=lowercase_							)
										lowerCAmelCase_       :					int			 = nn.Linear(lowercase_      ,  lowercase_							)

										# 3. Define transformers blocks
										lowerCAmelCase_       :					Optional[int]			 = nn.ModuleList(
										    [
										        BasicTransformerBlock(
										            lowercase_      ,  lowercase_      ,  lowercase_      ,  dropout=lowercase_      ,  cross_attention_dim=lowercase_      ,  activation_fn=lowercase_      ,  attention_bias=lowercase_      ,  double_self_attention=lowercase_      ,  norm_elementwise_affine=lowercase_      ,  )
										        for d in range(lowercase_							)
										    ]							)

										lowerCAmelCase_       :					Tuple			 = nn.Linear(lowercase_      ,  lowercase_							)




						def   lowercase_       ( self      ,  __lowercase      ,  __lowercase=None      ,  __lowercase=None      ,  __lowercase=None      ,  __lowercase=1      ,  __lowercase=None      ,  __lowercase = True      ,  )    ->			List[str]:
										lowerCAmelCase_       :					List[Any]			 = hidden_states.shape
										lowerCAmelCase_       :					Optional[int]			 = batch_frames // num_frames

										lowerCAmelCase_       :					Dict			 = hidden_states

										lowerCAmelCase_       :					List[Any]			 = hidden_states[None, :].reshape(lowercase_      ,  lowercase_      ,  lowercase_      ,  lowercase_      ,  lowercase_							)
										lowerCAmelCase_       :					Union[str, Any]			 = hidden_states.permute(0      ,  2      ,  1      ,  3      ,  4							)

										lowerCAmelCase_       :					Optional[int]			 = self.norm(lowercase_							)
										lowerCAmelCase_       :					Optional[int]			 = hidden_states.permute(0      ,  3      ,  4      ,  2      ,  1							).reshape(batch_size * height * width      ,  lowercase_      ,  lowercase_							)

										lowerCAmelCase_       :					Any			 = self.proj_in(lowercase_							)

										# 2. Blocks
										for block in self.transformer_blocks:
														lowerCAmelCase_       :					Union[str, Any]			 = block(
														    lowercase_      ,  encoder_hidden_states=lowercase_      ,  timestep=lowercase_      ,  cross_attention_kwargs=lowercase_      ,  class_labels=lowercase_      ,  )

										# 3. Output
										lowerCAmelCase_       :					Dict			 = self.proj_out(lowercase_							)
										lowerCAmelCase_       :					Dict			 = (
										    hidden_states[None, None, :]
										    .reshape(lowercase_      ,  lowercase_      ,  lowercase_      ,  lowercase_      ,  lowercase_							)
										    .permute(0      ,  3      ,  4      ,  1      ,  2							)
										    .contiguous()
										)
										lowerCAmelCase_       :					Union[str, Any]			 = hidden_states.reshape(lowercase_      ,  lowercase_      ,  lowercase_      ,  lowercase_							)

										lowerCAmelCase_       :					Optional[int]			 = hidden_states + residual

										if not return_dict:
														return (output,)

										return TransformerTemporalModelOutput(sample=lowercase_							)




"""simple docstring"""

import sys

lowercase__    :  Dict							    =	(
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)




def __lowercase			(							_a    ):
    snake_case_ :     List[Any]				=	1
    for digit in s:
        product *= int(_a    )
    return product




def __lowercase			(							_a = N    ):
    snake_case_ :     Optional[int]				=	-sys.maxsize - 1
    snake_case_ :     str				=	n[:13]
    snake_case_ :     List[Any]				=	13
    while cur_index < len(_a    ) - 13:
        if int(n[cur_index]    ) >= int(substr[0]    ):
            snake_case_ :     int				=	substr[1:] + n[cur_index]
            cur_index += 1
        else:
            snake_case_ :     Optional[Any]				=	max(_a		,			str_eval(_a    )    )
            snake_case_ :     Any				=	n[cur_index : cur_index + 13]
            cur_index += 13
    return largest_product


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





