


'''simple docstring'''
import math


def       _lowercase							(					):
 __A	:		Optional[Any]	  =      input('Enter message: '      )
 __A	:		Optional[Any]	  =      int(input(f"""Enter key [2-{len(UpperCamelCase__      ) - 1}]: """      )      )
 __A	:		Tuple	  =      input('Encryption/Decryption [e/d]: '      )

 if mode.lower().startswith('e'      ):
  __A	:		Union[str, Any]	  =      encrypt_message(UpperCamelCase__,					UpperCamelCase__      )
 elif mode.lower().startswith('d'      ):
  __A	:		Dict	  =      decrypt_message(UpperCamelCase__,					UpperCamelCase__      )

 # Append pipe symbol (vertical bar) to identify spaces at the end.
 print(f"""Output:\n{text + '|'}"""      )


def       _lowercase							(					UpperCamelCase__							:       int,					UpperCamelCase__							:       str      ):
 __A	:		Any	  =      [''] * key
 for col in range(UpperCamelCase__      ):
  __A	:		int	  =      col
  while pointer < len(UpperCamelCase__      ):
   cipher_text[col] += message[pointer]
   pointer += key
 return "".join(UpperCamelCase__      )


def       _lowercase							(					UpperCamelCase__							:       int,					UpperCamelCase__							:       str      ):
 __A	:		Tuple	  =      math.ceil(len(UpperCamelCase__      ) / key      )
 __A	:		Tuple	  =      key
 __A	:		Optional[int]	  =      (num_cols * num_rows) - len(UpperCamelCase__      )
 __A	:		List[Any]	  =      [''] * num_cols
 __A	:		Tuple	  =      0
 __A	:		Any	  =      0

 for symbol in message:
  plain_text[col] += symbol
  col += 1

  if (
      (col == num_cols)
      or (col == num_cols - 1)
      and (row >= num_rows - num_shaded_boxes)
  ):
   __A	:		Optional[int]	  =      0
   row += 1

 return "".join(UpperCamelCase__      )


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 main()










'''simple docstring'''
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     _lowerCamelCase       (     snake_case_					):




 '''simple docstring'''
 __lowercase					:		torch.FloatTensor


class     _lowerCamelCase       (     snake_case_     ,		snake_case_					):




 '''simple docstring'''


 @register_to_config
 def __init__(   self   ,   __lowercase = 16   ,   __lowercase = 88   ,   __lowercase = None   ,   __lowercase = None   ,   __lowercase = 1   ,   __lowercase = 0.0   ,   __lowercase = 32   ,   __lowercase = None   ,   __lowercase = False   ,   __lowercase = None   ,   __lowercase = "geglu"   ,   __lowercase = True   ,   __lowercase = True   ,   ):

  """simple docstring"""







  super().__init__()
  __A	:		Optional[int]	  =      num_attention_heads
  __A	:		Dict	  =      attention_head_dim
  __A	:		Optional[int]	  =      num_attention_heads * attention_head_dim

  __A	:		Optional[Any]	  =      in_channels

  __A	:		Optional[int]	  =      torch.nn.GroupNorm(num_groups=__lowercase   ,   num_channels=__lowercase   ,   eps=1E-6   ,   affine=__lowercase    )
  __A	:		Optional[Any]	  =      nn.Linear(__lowercase   ,   __lowercase    )

  # 3. Define transformers blocks
  __A	:		List[Any]	  =      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    )
      ]    )

  __A	:		Union[str, Any]	  =      nn.Linear(__lowercase   ,   __lowercase    )







 def 			snake_case__ (   self   ,   __lowercase   ,   __lowercase=None   ,   __lowercase=None   ,   __lowercase=None   ,   __lowercase=1   ,   __lowercase=None   ,   __lowercase = True   ,   ):

  """simple docstring"""







  __A  ,__A  ,__A  ,__A	:		int	  =      hidden_states.shape
  __A	:		Union[str, Any]	  =      batch_frames // num_frames

  __A	:		Union[str, Any]	  =      hidden_states

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

  __A	:		Dict	  =      self.norm(__lowercase    )
  __A	:		List[Any]	  =      hidden_states.permute(0   ,   3   ,   4   ,   2   ,   1    ).reshape(batch_size * height * width   ,   __lowercase   ,   __lowercase    )

  __A	:		Optional[Any]	  =      self.proj_in(__lowercase    )

  # 2. Blocks
  for block in self.transformer_blocks:
   __A	:		List[Any]	  =      block(
       __lowercase   ,   encoder_hidden_states=__lowercase   ,   timestep=__lowercase   ,   cross_attention_kwargs=__lowercase   ,   class_labels=__lowercase   ,   )

  # 3. Output
  __A	:		Optional[int]	  =      self.proj_out(__lowercase    )
  __A	:		int	  =      (
      hidden_states[None, None, :]
      .reshape(__lowercase   ,   __lowercase   ,   __lowercase   ,   __lowercase   ,   __lowercase    )
      .permute(0   ,   3   ,   4   ,   1   ,   2    )
      .contiguous()
  )
  __A	:		List[str]	  =      hidden_states.reshape(__lowercase   ,   __lowercase   ,   __lowercase   ,   __lowercase    )

  __A	:		str	  =      hidden_states + residual

  if not return_dict:
   return (output,)

  return TransformerTemporalModelOutput(sample=__lowercase    )






