




'''simple docstring'''







from dataclasses import dataclass
from typing import Optional

import numpy as np
import torch
import torch.nn as nn

from ..utils import BaseOutput, is_torch_version, randn_tensor
from .attention_processor import SpatialNorm
from .unet_ad_blocks import UNetMidBlockaD, get_down_block, get_up_block


@dataclass
class     _a						(			__a				):
       __a       :  torch.FloatTensor






class     _a						(			nn.Module				):
       def __init__(			self		:			str     ,       lowercase		:			Tuple=3     ,       lowercase		:			Dict=3     ,       lowercase		:			Tuple=("DownEncoderBlock2D",)     ,       lowercase		:			int=(64,)     ,       lowercase		:			Union[str, Any]=2     ,       lowercase		:			Tuple=32     ,       lowercase		:			List[Any]="silu"     ,       lowercase		:			Any=True     ,       ):



           '''simple docstring'''

           super().__init__()
           UpperCAmelCase     =	layers_per_block

           UpperCAmelCase     =	torch.nn.Convad(
               lowercase     ,       block_out_channels[0]     ,       kernel_size=3     ,       stride=1     ,       padding=1     ,       )

           UpperCAmelCase     =	None
           UpperCAmelCase     =	nn.ModuleList([]       )

           # down
           UpperCAmelCase     =	block_out_channels[0]
           for i, down_block_type in enumerate(lowercase       ):
               UpperCAmelCase     =	output_channel
               UpperCAmelCase     =	block_out_channels[i]
               UpperCAmelCase     =	i == len(lowercase       ) - 1

               UpperCAmelCase     =	get_down_block(
                   lowercase     ,       num_layers=self.layers_per_block     ,       in_channels=lowercase     ,       out_channels=lowercase     ,       add_downsample=not is_final_block     ,       resnet_eps=1E-6     ,       downsample_padding=0     ,       resnet_act_fn=lowercase     ,       resnet_groups=lowercase     ,       attention_head_dim=lowercase     ,       temb_channels=lowercase     ,       )
               self.down_blocks.append(lowercase       )

           # mid
           UpperCAmelCase     =	UNetMidBlockaD(
               in_channels=block_out_channels[-1]     ,       resnet_eps=1E-6     ,       resnet_act_fn=lowercase     ,       output_scale_factor=1     ,       resnet_time_scale_shift='''default'''     ,       attention_head_dim=block_out_channels[-1]     ,       resnet_groups=lowercase     ,       temb_channels=lowercase     ,       )

           # out
           UpperCAmelCase     =	nn.GroupNorm(num_channels=block_out_channels[-1]     ,       num_groups=lowercase     ,       eps=1E-6       )
           UpperCAmelCase     =	nn.SiLU()

           UpperCAmelCase     =	2 * out_channels if double_z else out_channels
           UpperCAmelCase     =	nn.Convad(block_out_channels[-1]     ,       lowercase     ,       3     ,       padding=1       )

           UpperCAmelCase     =	False







       def 					A   (			self		:			List[Any]     ,       lowercase		:			int       ):



           '''simple docstring'''

           UpperCAmelCase     =	x
           UpperCAmelCase     =	self.conv_in(lowercase       )

           if self.training and self.gradient_checkpointing:

               def create_custom_forward(lowercase		:			Optional[Any]       ):
                   def custom_forward(*lowercase		:			int       ):
                       return module(*lowercase       )

                   return custom_forward

               # down
               if is_torch_version('''>='''     ,       '''1.11.0'''       ):
                   for down_block in self.down_blocks:
                       UpperCAmelCase     =	torch.utils.checkpoint.checkpoint(
                           create_custom_forward(lowercase       )     ,       lowercase     ,       use_reentrant=lowercase       )
                   # middle
                   UpperCAmelCase     =	torch.utils.checkpoint.checkpoint(
                       create_custom_forward(self.mid_block       )     ,       lowercase     ,       use_reentrant=lowercase       )
               else:
                   for down_block in self.down_blocks:
                       UpperCAmelCase     =	torch.utils.checkpoint.checkpoint(create_custom_forward(lowercase       )     ,       lowercase       )
                   # middle
                   UpperCAmelCase     =	torch.utils.checkpoint.checkpoint(create_custom_forward(self.mid_block       )     ,       lowercase       )

           else:
               # down
               for down_block in self.down_blocks:
                   UpperCAmelCase     =	down_block(lowercase       )

               # middle
               UpperCAmelCase     =	self.mid_block(lowercase       )

           # post-process
           UpperCAmelCase     =	self.conv_norm_out(lowercase       )
           UpperCAmelCase     =	self.conv_act(lowercase       )
           UpperCAmelCase     =	self.conv_out(lowercase       )

           return sample






class     _a						(			nn.Module				):
       def __init__(			self		:			Union[str, Any]     ,       lowercase		:			Optional[Any]=3     ,       lowercase		:			List[Any]=3     ,       lowercase		:			Optional[Any]=("UpDecoderBlock2D",)     ,       lowercase		:			Union[str, Any]=(64,)     ,       lowercase		:			Dict=2     ,       lowercase		:			Union[str, Any]=32     ,       lowercase		:			Tuple="silu"     ,       lowercase		:			Any="group"     ,       ):



           '''simple docstring'''

           super().__init__()
           UpperCAmelCase     =	layers_per_block

           UpperCAmelCase     =	nn.Convad(
               lowercase     ,       block_out_channels[-1]     ,       kernel_size=3     ,       stride=1     ,       padding=1     ,       )

           UpperCAmelCase     =	None
           UpperCAmelCase     =	nn.ModuleList([]       )

           UpperCAmelCase     =	in_channels if norm_type == '''spatial''' else None

           # mid
           UpperCAmelCase     =	UNetMidBlockaD(
               in_channels=block_out_channels[-1]     ,       resnet_eps=1E-6     ,       resnet_act_fn=lowercase     ,       output_scale_factor=1     ,       resnet_time_scale_shift='''default''' if norm_type == '''group''' else norm_type     ,       attention_head_dim=block_out_channels[-1]     ,       resnet_groups=lowercase     ,       temb_channels=lowercase     ,       )

           # up
           UpperCAmelCase     =	list(reversed(lowercase       )       )
           UpperCAmelCase     =	reversed_block_out_channels[0]
           for i, up_block_type in enumerate(lowercase       ):
               UpperCAmelCase     =	output_channel
               UpperCAmelCase     =	reversed_block_out_channels[i]

               UpperCAmelCase     =	i == len(lowercase       ) - 1

               UpperCAmelCase     =	get_up_block(
                   lowercase     ,       num_layers=self.layers_per_block + 1     ,       in_channels=lowercase     ,       out_channels=lowercase     ,       prev_output_channel=lowercase     ,       add_upsample=not is_final_block     ,       resnet_eps=1E-6     ,       resnet_act_fn=lowercase     ,       resnet_groups=lowercase     ,       attention_head_dim=lowercase     ,       temb_channels=lowercase     ,       resnet_time_scale_shift=lowercase     ,       )
               self.up_blocks.append(lowercase       )
               UpperCAmelCase     =	output_channel

           # out
           if norm_type == "spatial":
               UpperCAmelCase     =	SpatialNorm(block_out_channels[0]     ,       lowercase       )
           else:
               UpperCAmelCase     =	nn.GroupNorm(num_channels=block_out_channels[0]     ,       num_groups=lowercase     ,       eps=1E-6       )
           UpperCAmelCase     =	nn.SiLU()
           UpperCAmelCase     =	nn.Convad(block_out_channels[0]     ,       lowercase     ,       3     ,       padding=1       )

           UpperCAmelCase     =	False







       def 					A   (			self		:			int     ,       lowercase		:			Dict     ,       lowercase		:			Optional[int]=None       ):



           '''simple docstring'''

           UpperCAmelCase     =	z
           UpperCAmelCase     =	self.conv_in(lowercase       )

           UpperCAmelCase     =	next(iter(self.up_blocks.parameters()       )       ).dtype
           if self.training and self.gradient_checkpointing:

               def create_custom_forward(lowercase		:			List[str]       ):
                   def custom_forward(*lowercase		:			int       ):
                       return module(*lowercase       )

                   return custom_forward

               if is_torch_version('''>='''     ,       '''1.11.0'''       ):
                   # middle
                   UpperCAmelCase     =	torch.utils.checkpoint.checkpoint(
                       create_custom_forward(self.mid_block       )     ,       lowercase     ,       lowercase     ,       use_reentrant=lowercase       )
                   UpperCAmelCase     =	sample.to(lowercase       )

                   # up
                   for up_block in self.up_blocks:
                       UpperCAmelCase     =	torch.utils.checkpoint.checkpoint(
                           create_custom_forward(lowercase       )     ,       lowercase     ,       lowercase     ,       use_reentrant=lowercase       )
               else:
                   # middle
                   UpperCAmelCase     =	torch.utils.checkpoint.checkpoint(
                       create_custom_forward(self.mid_block       )     ,       lowercase     ,       lowercase       )
                   UpperCAmelCase     =	sample.to(lowercase       )

                   # up
                   for up_block in self.up_blocks:
                       UpperCAmelCase     =	torch.utils.checkpoint.checkpoint(create_custom_forward(lowercase       )     ,       lowercase     ,       lowercase       )
           else:
               # middle
               UpperCAmelCase     =	self.mid_block(lowercase     ,       lowercase       )
               UpperCAmelCase     =	sample.to(lowercase       )

               # up
               for up_block in self.up_blocks:
                   UpperCAmelCase     =	up_block(lowercase     ,       lowercase       )

        # post-process
           if latent_embeds is None:
               UpperCAmelCase     =	self.conv_norm_out(lowercase       )
           else:
               UpperCAmelCase     =	self.conv_norm_out(lowercase     ,       lowercase       )
           UpperCAmelCase     =	self.conv_act(lowercase       )
           UpperCAmelCase     =	self.conv_out(lowercase       )

           return sample






class     _a						(			nn.Module				):
       def __init__(			self		:			str     ,       lowercase		:			Optional[int]     ,       lowercase		:			Optional[int]     ,       lowercase		:			List[str]     ,       lowercase		:			Any=None     ,       lowercase		:			List[str]="random"     ,       lowercase		:			Tuple=False     ,       lowercase		:			Dict=True       ):



           '''simple docstring'''

           super().__init__()
           UpperCAmelCase     =	n_e
           UpperCAmelCase     =	vq_embed_dim
           UpperCAmelCase     =	beta
           UpperCAmelCase     =	legacy

           UpperCAmelCase     =	nn.Embedding(self.n_e     ,       self.vq_embed_dim       )
           self.embedding.weight.data.uniform_(-1.0 / self.n_e     ,       1.0 / self.n_e       )

           UpperCAmelCase     =	remap
           if self.remap is not None:
               self.register_buffer('''used'''     ,       torch.tensor(np.load(self.remap       )       )       )
               UpperCAmelCase     =	self.used.shape[0]
               UpperCAmelCase     =	unknown_index  # "random" or "extra" or integer
               if self.unknown_index == "extra":
                   UpperCAmelCase     =	self.re_embed
                   UpperCAmelCase     =	self.re_embed + 1
               print(
                   f"Remapping {self.n_e} indices to {self.re_embed} indices. "
                   f"Using {self.unknown_index} for unknown indices."       )
           else:
               UpperCAmelCase     =	n_e

           UpperCAmelCase     =	sane_index_shape
       def 					A   (			self		:			Optional[Any]     ,       lowercase		:			int       ):



           '''simple docstring'''

           UpperCAmelCase     =	inds.shape
           assert len(lowercase       ) > 1
           UpperCAmelCase     =	inds.reshape(ishape[0]     ,       -1       )
           UpperCAmelCase     =	self.used.to(lowercase       )
           UpperCAmelCase     =	(inds[:, :, None] == used[None, None, ...]).long()
           UpperCAmelCase     =	match.argmax(-1       )
           UpperCAmelCase     =	match.sum(2       ) < 1
           if self.unknown_index == "random":
               UpperCAmelCase     =	torch.randint(0     ,       self.re_embed     ,       size=new[unknown].shape       ).to(device=new.device       )
           else:
               UpperCAmelCase     =	self.unknown_index
           return new.reshape(lowercase       )
       def 					A   (			self		:			List[str]     ,       lowercase		:			Union[str, Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	inds.shape
           assert len(lowercase       ) > 1
           UpperCAmelCase     =	inds.reshape(ishape[0]     ,       -1       )
           UpperCAmelCase     =	self.used.to(lowercase       )
           if self.re_embed > self.used.shape[0]:  # extra token
               UpperCAmelCase     =	0  # simply set to zero
           UpperCAmelCase     =	torch.gather(used[None, :][inds.shape[0] * [0], :]     ,       1     ,       lowercase       )
           return back.reshape(lowercase       )
       def 					A   (			self		:			str     ,       lowercase		:			List[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	z.permute(0     ,       2     ,       3     ,       1       ).contiguous()
           UpperCAmelCase     =	z.view(-1     ,       self.vq_embed_dim       )

           # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
           UpperCAmelCase     =	torch.argmin(torch.cdist(lowercase     ,       self.embedding.weight       )     ,       dim=1       )

           UpperCAmelCase     =	self.embedding(lowercase       ).view(z.shape       )
           UpperCAmelCase     =	None
           UpperCAmelCase     =	None

           # compute loss for embedding
           if not self.legacy:
               UpperCAmelCase     =	self.beta * torch.mean((z_q.detach() - z) ** 2       ) + torch.mean((z_q - z.detach()) ** 2       )
           else:
               UpperCAmelCase     =	torch.mean((z_q.detach() - z) ** 2       ) + self.beta * torch.mean((z_q - z.detach()) ** 2       )

           # preserve gradients
           UpperCAmelCase     =	z + (z_q - z).detach()

           # reshape back to match original input shape
           UpperCAmelCase     =	z_q.permute(0     ,       3     ,       1     ,       2       ).contiguous()

           if self.remap is not None:
               UpperCAmelCase     =	min_encoding_indices.reshape(z.shape[0]     ,       -1       )  # add batch axis
               UpperCAmelCase     =	self.remap_to_used(lowercase       )
               UpperCAmelCase     =	min_encoding_indices.reshape(-1     ,       1       )  # flatten

           if self.sane_index_shape:
               UpperCAmelCase     =	min_encoding_indices.reshape(z_q.shape[0]     ,       z_q.shape[2]     ,       z_q.shape[3]       )

           return z_q, loss, (perplexity, min_encodings, min_encoding_indices)







       def 					A   (			self		:			List[Any]     ,       lowercase		:			Tuple     ,       lowercase		:			Optional[Any]       ):



           '''simple docstring'''

           if self.remap is not None:
               UpperCAmelCase     =	indices.reshape(shape[0]     ,       -1       )  # add batch axis
               UpperCAmelCase     =	self.unmap_to_all(lowercase       )
               UpperCAmelCase     =	indices.reshape(-1       )  # flatten again

           # get quantized latent vectors
           UpperCAmelCase     =	self.embedding(lowercase       )

           if shape is not None:
               UpperCAmelCase     =	z_q.view(lowercase       )
               # reshape back to match original input shape
               UpperCAmelCase     =	z_q.permute(0     ,       3     ,       1     ,       2       ).contiguous()

           return z_q






class     _a						(			__a				):
       def __init__(			self		:			Dict     ,       lowercase		:			Dict     ,       lowercase		:			Optional[Any]=False       ):



           '''simple docstring'''

           UpperCAmelCase     =	parameters
           UpperCAmelCase ,  UpperCAmelCase     =	torch.chunk(lowercase     ,       2     ,       dim=1       )
           UpperCAmelCase     =	torch.clamp(self.logvar     ,       -30.0     ,       20.0       )
           UpperCAmelCase     =	deterministic
           UpperCAmelCase     =	torch.exp(0.5 * self.logvar       )
           UpperCAmelCase     =	torch.exp(self.logvar       )
           if self.deterministic:
               UpperCAmelCase     =	UpperCAmelCase     =	torch.zeros_like(
                   self.mean     ,       device=self.parameters.device     ,       dtype=self.parameters.dtype       )
       def 					A   (			self		:			List[str]     ,       lowercase		:			Optional[torch.Generator] = None       ):



           '''simple docstring'''

           UpperCAmelCase     =	randn_tensor(
               self.mean.shape     ,       generator=lowercase     ,       device=self.parameters.device     ,       dtype=self.parameters.dtype       )
           UpperCAmelCase     =	self.mean + self.std * sample
           return x
       def 					A   (			self		:			Union[str, Any]     ,       lowercase		:			int=None       ):



           '''simple docstring'''

           if self.deterministic:
               return torch.Tensor([0.0]       )
           else:
               if other is None:
                   return 0.5 * torch.sum(torch.pow(self.mean     ,       2       ) + self.var - 1.0 - self.logvar     ,       dim=[1, 2, 3]       )
               else:
                   return 0.5 * torch.sum(
                       torch.pow(self.mean - other.mean     ,       2       ) / other.var
                       + self.var / other.var
                       - 1.0
                       - self.logvar
                       + other.logvar     ,       dim=[1, 2, 3]     ,       )
       def 					A   (			self		:			Optional[int]     ,       lowercase		:			List[Any]     ,       lowercase		:			Union[str, Any]=[1, 2, 3]       ):



           '''simple docstring'''

           if self.deterministic:
               return torch.Tensor([0.0]       )
           UpperCAmelCase     =	np.log(2.0 * np.pi       )
           return 0.5 * torch.sum(logtwopi + self.logvar + torch.pow(sample - self.mean     ,       2       ) / self.var     ,       dim=lowercase       )







       def 					A   (			self		:			Optional[int]       ):



           '''simple docstring'''

           return self.mean










'''simple docstring'''







def 		snake_case_							():
    for n in range(1					,     1_0_0_0_0_0_0  ):
        yield n * (n + 1) // 2





def 		snake_case_							(_a			:							Union[str, Any]  ):
    UpperCAmelCase     =	1
    UpperCAmelCase     =	2
    while i * i <= n:
        UpperCAmelCase     =	0
        while n % i == 0:
            n //= i
            multiplicity += 1
        divisors_count *= multiplicity + 1
        i += 1
    if n > 1:
        divisors_count *= 2
    return divisors_count





def 		snake_case_							():
    return next(i for i in triangle_number_generator() if count_divisors(_a  ) > 5_0_0  )


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




