Ë
    (täiÆ„  ã                   óD  — d dl mZ d dlZd dlZd dlmZ ddlmZ ddl	m
Z
 ddlmZ ddlmZ dd	lmZmZmZmZ e G d
„ de«      «       Ze G d„ de«      «       Z G d„ dej,                  «      Z G d„ dej,                  «      Z G d„ dej,                  «      Z G d„ dej,                  «      Z G d„ dej,                  «      Z G d„ dej,                  «      Z G d„ de«      Z G d„ de«      Z G d„ dej,                  «      Z  G d „ d!ej,                  «      Z! G d"„ d#«      Z"y)$é    )Ú	dataclassNé   )Ú
BaseOutput)Úrandn_tensoré   )Úget_activation)ÚSpatialNorm)ÚAutoencoderTinyBlockÚUNetMidBlock2DÚget_down_blockÚget_up_blockc                   ó0   — e Zd ZU dZej
                  ed<   y)ÚEncoderOutputz³
    Output of encoding method.

    Args:
        latent (`torch.Tensor` of shape `(batch_size, num_channels, latent_height, latent_width)`):
            The encoded latent.
    ÚlatentN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__ÚtorchÚTensorÚ__annotations__© ó    úp/Volumes/fast/ai/experiments/MLX_z-image/.venv/lib/python3.12/site-packages/diffusers/models/autoencoders/vae.pyr   r       s   … ñð �L‰LÔr   r   c                   óX   — e Zd ZU dZej
                  ed<   dZej                  dz  ed<   y)ÚDecoderOutputzÍ
    Output of decoding method.

    Args:
        sample (`torch.Tensor` of shape `(batch_size, num_channels, height, width)`):
            The decoded output sample from the last layer of the model.
    ÚsampleNÚcommit_loss)	r   r   r   r   r   r   r   r   ÚFloatTensorr   r   r   r   r   -   s(   … ñð �L‰LÓØ,0€K�×"Ñ" TÑ)Ô0r   r   c                   ó¤   ‡ — e Zd ZdZ	 	 	 	 	 	 	 	 	 ddededeedf   deedf   deded	ed
efˆ fd„Zde	j                  de	j                  fd„Zˆ xZS )ÚEncoderaÇ  
    The `Encoder` layer of a variational autoencoder that encodes its input into a latent representation.

    Args:
        in_channels (`int`, *optional*, defaults to 3):
            The number of input channels.
        out_channels (`int`, *optional*, defaults to 3):
            The number of output channels.
        down_block_types (`tuple[str, ...]`, *optional*, defaults to `("DownEncoderBlock2D",)`):
            The types of down blocks to use. See `~diffusers.models.unet_2d_blocks.get_down_block` for available
            options.
        block_out_channels (`tuple[int, ...]`, *optional*, defaults to `(64,)`):
            The number of output channels for each block.
        layers_per_block (`int`, *optional*, defaults to 2):
            The number of layers per block.
        norm_num_groups (`int`, *optional*, defaults to 32):
            The number of groups for normalization.
        act_fn (`str`, *optional*, defaults to `"silu"`):
            The activation function to use. See `~diffusers.models.activations.get_activation` for available options.
        double_z (`bool`, *optional*, defaults to `True`):
            Whether to double the number of output channels for the last block.
    Úin_channelsÚout_channelsÚdown_block_types.Úblock_out_channelsÚlayers_per_blockÚnorm_num_groupsÚact_fnÚdouble_zc
                 ó’  •— t         ‰| �  «        || _        t        j                  ||d   ddd¬«      | _        t        j                  g «      | _        |d   }
t        |«      D ]Y  \  }}|
}||   }
|t        |«      dz
  k(  }t        || j                  ||
| dd|||
d ¬«      }| j                  j                  |«       Œ[ t        |d   d|dd|d   |d |	¬	«	      | _        t        j                  |d   |d¬
«      | _        t        j                   «       | _        |rd|z  n|}t        j                  |d   |dd¬«      | _        d| _        y )Nr   r   é   ©Úkernel_sizeÚstrideÚpaddingç�íµ ÷Æ°>)
Ú
num_layersr"   r#   Úadd_downsampleÚ
resnet_epsÚdownsample_paddingÚresnet_act_fnÚresnet_groupsÚattention_head_dimÚtemb_channelséÿÿÿÿÚdefault©	r"   r3   r5   Úoutput_scale_factorÚresnet_time_scale_shiftr7   r6   r8   Úadd_attention©Únum_channelsÚ
num_groupsÚepsr   ©r/   F)ÚsuperÚ__init__r&   ÚnnÚConv2dÚconv_inÚ
ModuleListÚdown_blocksÚ	enumerateÚlenr   Úappendr   Ú	mid_blockÚ	GroupNormÚconv_norm_outÚSiLUÚconv_actÚconv_outÚgradient_checkpointing)Úselfr"   r#   r$   r%   r&   r'   r(   r)   Úmid_block_add_attentionÚoutput_channelÚiÚdown_block_typeÚinput_channelÚis_final_blockÚ
down_blockÚconv_out_channelsÚ	__class__s                    €r   rE   zEncoder.__init__S   sr  ø€ ô 	‰ÑÔØ 0ˆÔä—y‘yØØ˜qÑ!ØØØô
ˆŒô Ÿ=™=¨Ó,ˆÔð ,¨AÑ.ˆÜ"+Ð,<Ö"=ÑˆAˆØ*ˆMØ/°Ñ2ˆNØ¤#Ð&8Ó"9¸AÑ"=Ñ=ˆNä'ØØ×0Ñ0Ø)Ø+Ø#1Ð1ØØ#$Ø$Ø-Ø#1Ø"ôˆJð ×Ñ×#Ñ# JÕ/ð% #>ô* (Ø*¨2Ñ.ØØ Ø !Ø$-Ø1°"Ñ5Ø)ØØ1ô

ˆŒô  Ÿ\™\Ð7IÈ"Ñ7MÐZiÐosÔtˆÔÜŸ™›	ˆŒá08˜A Ò,¸lÐÜŸ	™	Ð"4°RÑ"8Ð:KÈQÐXYÔZˆŒà&+ˆÕ#r   r   Úreturnc                 ó¢  — | j                  |«      }t        j                  «       rL| j                  r@| j                  D ]  }| j                  ||«      }Œ | j                  | j                  |«      }n*| j                  D ]
  } ||«      }Œ | j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }|S )z*The forward method of the `Encoder` class.)
rH   r   Úis_grad_enabledrT   rJ   Ú_gradient_checkpointing_funcrN   rP   rR   rS   )rU   r   r\   s      r   ÚforwardzEncoder.forward˜   s¿   € ð —‘˜fÓ%ˆä× Ñ Ô" t×'BÒ'Bà"×.Ô.�
Ø×:Ñ:¸:ÀvÓN‘ð /ð ×6Ñ6°t·~±~ÀvÓN‰Fð #×.Ô.�
Ù# FÓ+‘ð /ð —^‘^ FÓ+ˆFð ×#Ñ# FÓ+ˆØ—‘˜vÓ&ˆØ—‘˜vÓ&ˆàˆr   )	r   r   )ÚDownEncoderBlock2D©é@   r   é    ÚsiluTT)r   r   r   r   ÚintÚtupleÚstrÚboolrE   r   r   rc   Ú__classcell__©r^   s   @r   r!   r!   ;   s­   ø„ ñð2 ØØ,CØ.3Ø !Ø!ØØØ $ñC,àðC,ð ðC,ð    S ™/ð	C,ð
 " # s (™OðC,ð ðC,ð ðC,ð ðC,ð õC,ðJ˜eŸl™lð ¨u¯|©|÷ r   r!   c                   óÆ   ‡ — e Zd ZdZ	 	 	 	 	 	 	 	 	 ddededeedf   deedf   deded	ed
efˆ fd„Z	 ddej                  dej                  dz  dej                  fd„Z
ˆ xZS )ÚDecoderaÂ  
    The `Decoder` layer of a variational autoencoder that decodes its latent representation into an output sample.

    Args:
        in_channels (`int`, *optional*, defaults to 3):
            The number of input channels.
        out_channels (`int`, *optional*, defaults to 3):
            The number of output channels.
        up_block_types (`tuple[str, ...]`, *optional*, defaults to `("UpDecoderBlock2D",)`):
            The types of up blocks to use. See `~diffusers.models.unet_2d_blocks.get_up_block` for available options.
        block_out_channels (`tuple[int, ...]`, *optional*, defaults to `(64,)`):
            The number of output channels for each block.
        layers_per_block (`int`, *optional*, defaults to 2):
            The number of layers per block.
        norm_num_groups (`int`, *optional*, defaults to 32):
            The number of groups for normalization.
        act_fn (`str`, *optional*, defaults to `"silu"`):
            The activation function to use. See `~diffusers.models.activations.get_activation` for available options.
        norm_type (`str`, *optional*, defaults to `"group"`):
            The normalization type to use. Can be either `"group"` or `"spatial"`.
    r"   r#   Úup_block_types.r%   r&   r'   r(   Ú	norm_typec
                 ó  •— t         ‰| �  «        || _        t        j                  ||d   ddd¬«      | _        t        j                  g «      | _        |dk(  r|nd }
t        |d   d|d|dk(  rdn||d   ||
|	¬	«	      | _	        t        t        |«      «      }|d
   }t        |«      D ]_  \  }}|}||   }|t        |«      dz
  k(  }t        || j                  dz   |||| d||||
|¬«      }| j                  j                  |«       |}Œa |dk(  rt!        |d
   |
«      | _        n t        j$                  |d
   |d¬«      | _        t        j&                  «       | _        t        j                  |d
   |dd¬«      | _        d| _        y )Nr9   r   r+   r,   Úspatialr0   Úgroupr:   r;   r   ©r1   r"   r#   Úprev_output_channelÚadd_upsampler3   r5   r6   r7   r8   r=   r?   rC   F)rD   rE   r&   rF   rG   rH   rI   Ú	up_blocksr   rN   ÚlistÚreversedrK   rL   r   rM   r	   rP   rO   rQ   rR   rS   rT   )rU   r"   r#   rq   r%   r&   r'   r(   rr   rV   r8   Úreversed_block_out_channelsrW   rX   Úup_block_typerw   r[   Úup_blockr^   s                     €r   rE   zDecoder.__init__Ë   s²  ø€ ô 	‰ÑÔØ 0ˆÔä—y‘yØØ˜rÑ"ØØØô
ˆŒô Ÿ™ rÓ*ˆŒà'0°IÒ'=™À4ˆô (Ø*¨2Ñ.ØØ Ø !Ø1:¸gÒ1E¡IÈ9Ø1°"Ñ5Ø)Ø'Ø1ô

ˆŒô '+¬8Ð4FÓ+GÓ&HÐ#Ø4°QÑ7ˆÜ )¨.Ö 9ÑˆAˆ}Ø"0ÐØ8¸Ñ;ˆNà¤#Ð&8Ó"9¸AÑ"=Ñ=ˆNä#ØØ×0Ñ0°1Ñ4Ø/Ø+Ø$7Ø!/Ð/ØØ$Ø-Ø#1Ø+Ø(1ôˆHð �N‰N×!Ñ! (Ô+Ø"0Ñð+ !:ð0 ˜	Ò!Ü!,Ð-?ÀÑ-BÀMÓ!RˆDÕä!#§¡Ð;MÈaÑ;PÐ]lÐrvÔ!wˆDÔÜŸ™›	ˆŒÜŸ	™	Ð"4°QÑ"7¸ÀqÐRSÔTˆŒà&+ˆÕ#r   Nr   Úlatent_embedsr_   c                 óÔ  — | j                  |«      }t        j                  «       rN| j                  rB| j	                  | j
                  ||«      }| j                  D ]  }| j	                  |||«      }Œ n,| j                  ||«      }| j                  D ]  } |||«      }Œ |€| j                  |«      }n| j                  ||«      }| j                  |«      }| j                  |«      }|S )z*The forward method of the `Decoder` class.)
rH   r   ra   rT   rb   rN   ry   rP   rR   rS   )rU   r   r   r~   s       r   rc   zDecoder.forward  sÛ   € ð —‘˜fÓ%ˆä× Ñ Ô" t×'BÒ'Bà×6Ñ6°t·~±~ÀvÈ}Ó]ˆFð !ŸNœN�Ø×:Ñ:¸8ÀVÈ]Ó[‘ñ +ð —^‘^ F¨MÓ:ˆFð !ŸNœN�Ù! &¨-Ó8‘ð +ð Ð Ø×'Ñ'¨Ó/‰Fà×'Ñ'¨°Ó>ˆFØ—‘˜vÓ&ˆØ—‘˜vÓ&ˆàˆr   )	r   r   ©ÚUpDecoderBlock2Dre   r   rg   rh   ru   T©N©r   r   r   r   ri   rj   rk   rE   r   r   rc   rm   rn   s   @r   rp   rp   ´   sÉ   ø„ ñð0 ØØ*?Ø.3Ø !Ø!ØØ Ø $ñJ,àðJ,ð ðJ,ð ˜c 3˜h™ð	J,ð
 " # s (™OðJ,ð ðJ,ð ðJ,ð ðJ,ð õJ,ð^ .2ñ à—‘ð ð —|‘| dÑ*ð ð 
�‰÷	 r   rp   c                   óh   ‡ — e Zd ZdZdededdfˆ fd„Zdej                  dej                  fd„Zˆ xZ	S )	ÚUpSamplea&  
    The `UpSample` layer of a variational autoencoder that upsamples its input.

    Args:
        in_channels (`int`, *optional*, defaults to 3):
            The number of input channels.
        out_channels (`int`, *optional*, defaults to 3):
            The number of output channels.
    r"   r#   r_   Nc                 ó|   •— t         ‰| �  «        || _        || _        t	        j
                  ||ddd¬«      | _        y )Né   r   r+   r,   )rD   rE   r"   r#   rF   ÚConvTranspose2dÚdeconv)rU   r"   r#   r^   s      €r   rE   zUpSample.__init__E  s=   ø€ ô
 	‰ÑÔØ&ˆÔØ(ˆÔÜ×(Ñ(¨°lÐPQÐZ[ÐefÔgˆ�r   Úxc                 óR   — t        j                  |«      }| j                  |«      }|S )z+The forward method of the `UpSample` class.)r   ÚrelurŠ   ©rU   r‹   s     r   rc   zUpSample.forwardO  s!   € ä�J‰J�q‹MˆØ�K‰K˜‹NˆØˆr   ©
r   r   r   r   ri   rE   r   r   rc   rm   rn   s   @r   r†   r†   :  sH   ø„ ñðhàðhð ðhð 
õ	hð˜Ÿ™ð ¨%¯,©,÷ r   r†   c                   óz   ‡ — e Zd ZdZ	 	 	 ddededededdf
ˆ fd„Zdd	ej                  dej                  fd
„Zˆ xZ	S )ÚMaskConditionEncoderz)
    used in AsymmetricAutoencoderKL
    Úin_chÚout_chÚres_chr.   r_   Nc           
      ó4  •— t         ‰| �  «        g }|dkD  r6|dz  }|dz  }||kD  r|}|dk(  r|}|j                  ||f«       |dz  }|dkD  rŒ6g }|D ]  \  }}	|j                  |	«       Œ |j                  |d   d   «       g }
|}t        t	        |«      «      D ]f  }||   }|dk(  s|dk(  r*|
j                  t        j                  ||ddd¬«      «       n)|
j                  t        j                  ||ddd¬«      «       |}Œh t        j                  |
Ž | _        y )Nr+   r   r9   r   r   r,   rˆ   )	rD   rE   rM   ÚrangerL   rF   rG   Ú
SequentialÚlayers)rU   r’   r“   r”   r.   ÚchannelsÚin_ch_r#   Ú_in_chÚ_out_chr˜   ÚlÚout_ch_r^   s                €r   rE   zMaskConditionEncoder.__init__[  s)  ø€ ô 	‰ÑÔàˆØ�qŠjØ˜q‘[ˆFØ˜a‘ZˆFØ˜ŠØ�Ø˜Š{Ø�Ø�O‰O˜V VÐ,Ô-Ø�a‰KˆFð �q‹jð ˆÛ'‰OˆF�GØ×Ñ Õ(ð  (à×Ñ˜H R™L¨™OÔ,àˆØˆÜ”s˜<Ó(Ö)ˆAØ" 1‘oˆGØ�AŠv˜˜ašØ—‘œbŸi™i¨°ÀQÈqÐZ[Ô\Õ]à—‘œbŸi™i¨°ÀQÈqÐZ[Ô\Ô]Ø‰Fð *ô —m‘m VÐ,ˆ�r   r‹   c                 óê   — i }t        t        | j                  «      «      D ]O  }| j                  |   } ||«      }||t        t	        |j
                  «      «      <   t        j                  |«      }ŒQ |S )z7The forward method of the `MaskConditionEncoder` class.)r–   rL   r˜   rk   rj   Úshaper   r�   )rU   r‹   ÚmaskÚoutr�   Úlayers         r   rc   zMaskConditionEncoder.forward€  s`   € àˆÜ”s˜4Ÿ;™;Ó'Ö(ˆAØ—K‘K ‘NˆEÙ�a“ˆAØ'(ˆC””E˜!Ÿ'™'“NÓ#Ñ$Ü—
‘
˜1“‰Að	 )ð
 ˆ
r   )éÀ   i   é   rƒ   r�   rn   s   @r   r‘   r‘   V  sd   ø„ ñð ØØñ#-àð#-ð ð#-ð ð	#-ð
 ð#-ð 
õ#-ñJ˜Ÿ™ð °U·\±\÷ r   r‘   c                   ó  ‡ — e Zd ZdZ	 	 	 	 	 	 	 	 ddededeedf   deedf   deded	ed
efˆ fd„Z	 	 	 ddej                  dej                  dz  dej                  dz  dej                  dz  dej                  f
d„Z
ˆ xZS )ÚMaskConditionDecoderaü  The `MaskConditionDecoder` should be used in combination with [`AsymmetricAutoencoderKL`] to enhance the model's
    decoder with a conditioner on the mask and masked image.

    Args:
        in_channels (`int`, *optional*, defaults to 3):
            The number of input channels.
        out_channels (`int`, *optional*, defaults to 3):
            The number of output channels.
        up_block_types (`tuple[str, ...]`, *optional*, defaults to `("UpDecoderBlock2D",)`):
            The types of up blocks to use. See `~diffusers.models.unet_2d_blocks.get_up_block` for available options.
        block_out_channels (`tuple[int, ...]`, *optional*, defaults to `(64,)`):
            The number of output channels for each block.
        layers_per_block (`int`, *optional*, defaults to 2):
            The number of layers per block.
        norm_num_groups (`int`, *optional*, defaults to 32):
            The number of groups for normalization.
        act_fn (`str`, *optional*, defaults to `"silu"`):
            The activation function to use. See `~diffusers.models.activations.get_activation` for available options.
        norm_type (`str`, *optional*, defaults to `"group"`):
            The normalization type to use. Can be either `"group"` or `"spatial"`.
    r"   r#   rq   .r%   r&   r'   r(   rr   c	                 ó8  •— t         ‰| �  «        || _        t        j                  ||d   ddd¬«      | _        t        j                  g «      | _        |dk(  r|nd }	t        |d   d|d|dk(  rdn||d   ||	¬	«      | _	        t        t        |«      «      }
|
d
   }t        |«      D ]_  \  }}|}|
|   }|t        |«      dz
  k(  }t        || j                  dz   ||d | d||||	|¬«      }| j                  j                  |«       |}Œa t!        ||d
   |d   ¬«      | _        |dk(  rt%        |d
   |	«      | _        n t        j(                  |d
   |d¬«      | _        t        j*                  «       | _        t        j                  |d
   |dd¬«      | _        d| _        y )Nr9   r   r+   r,   rt   r0   ru   r:   )r"   r3   r5   r<   r=   r7   r6   r8   r   rv   )r’   r“   r”   r?   rC   F)rD   rE   r&   rF   rG   rH   rI   ry   r   rN   rz   r{   rK   rL   r   rM   r‘   Úcondition_encoderr	   rP   rO   rQ   rR   rS   rT   )rU   r"   r#   rq   r%   r&   r'   r(   rr   r8   r|   rW   rX   r}   rw   r[   r~   r^   s                    €r   rE   zMaskConditionDecoder.__init__¢  sÑ  ø€ ô 	‰ÑÔØ 0ˆÔä—y‘yØØ˜rÑ"ØØØô
ˆŒô Ÿ™ rÓ*ˆŒà'0°IÒ'=™À4ˆô (Ø*¨2Ñ.ØØ Ø !Ø1:¸gÒ1E¡IÈ9Ø1°"Ñ5Ø)Ø'ô	
ˆŒô '+¬8Ð4FÓ+GÓ&HÐ#Ø4°QÑ7ˆÜ )¨.Ö 9ÑˆAˆ}Ø"0ÐØ8¸Ñ;ˆNà¤#Ð&8Ó"9¸AÑ"=Ñ=ˆNä#ØØ×0Ñ0°1Ñ4Ø/Ø+Ø$(Ø!/Ð/ØØ$Ø-Ø#1Ø+Ø(1ôˆHð �N‰N×!Ñ! (Ô+Ø"0Ñð+ !:ô0 "6ØØ% aÑ(Ø% bÑ)ô"
ˆÔð ˜	Ò!Ü!,Ð-?ÀÑ-BÀMÓ!RˆDÕä!#§¡Ð;MÈaÑ;PÐ]lÐrvÔ!wˆDÔÜŸ™›	ˆŒÜŸ	™	Ð"4°QÑ"7¸ÀqÐRSÔTˆŒà&+ˆÕ#r   NÚzÚimager¡   r   r_   c                 ój  — |}| j                  |«      }t        t        | j                  j	                  «       «      «      j
                  }t        j                  «       �r| j                  �r| j                  | j                  ||«      }|j                  |«      }|�'|�%d|z
  |z  }| j                  | j                  ||«      }| j                  D ]w  }	|�`|�^t        t        |j                  «      «         }
t         j"                  j%                  ||j                  dd d¬«      }||z  |
d|z
  z  z   }| j                  |	||«      }Œy |��|��||z  t        t        |j                  «      «         d|z
  z  z   }nî| j                  ||«      }|j                  |«      }|�|�d|z
  |z  }| j                  ||«      }| j                  D ]m  }	|�`|�^t        t        |j                  «      «         }
t         j"                  j%                  ||j                  dd d¬«      }||z  |
d|z
  z  z   } |	||«      }Œo |�/|�-||z  t        t        |j                  «      «         d|z
  z  z   }|€| j'                  |«      }n| j'                  ||«      }| j)                  |«      }| j+                  |«      }|S )z7The forward method of the `MaskConditionDecoder` class.Nr+   éþÿÿÿÚnearest)ÚsizeÚmode)rH   ÚnextÚiterry   Ú
parametersÚdtyper   ra   rT   rb   rN   Útor©   rk   rj   r    rF   Ú
functionalÚinterpolaterP   rR   rS   )rU   rª   r«   r¡   r   r   Úupscale_dtypeÚmasked_imageÚim_xr~   Úsample_Úmask_s               r   rc   zMaskConditionDecoder.forwardó  sµ  € ð ˆØ—‘˜fÓ%ˆäœT $§.¡.×";Ñ";Ó"=Ó>Ó?×EÑEˆÜ× Ñ Õ" t×'BÓ'Bà×6Ñ6°t·~±~ÀvÈ}Ó]ˆFØ—Y‘Y˜}Ó-ˆFð Ð  TÐ%5Ø ! D¡¨EÑ1�Ø×8Ñ8Ø×*Ñ*Ø Øó�ð !ŸNœN�ØÐ$¨Ð)9Ø"¤3¤u¨V¯\©\Ó':Ó#;Ñ<�GÜŸM™M×5Ñ5°dÀÇÁÈbÈcÐARÐYbÐ5Óc�EØ# e™^¨g¸¸U¹Ñ.CÑC�FØ×:Ñ:¸8ÀVÈ]Ó[‘ð +ð Ñ  TÑ%5Ø $™¨¬c´%¸¿¹Ó2EÓ.FÑ)GÈ1ÈtÉ8Ñ)TÑT‘ð —^‘^ F¨MÓ:ˆFØ—Y‘Y˜}Ó-ˆFð Ð  TÐ%5Ø ! D¡¨EÑ1�Ø×-Ñ-¨l¸DÓA�ð !ŸNœN�ØÐ$¨Ð)9Ø"¤3¤u¨V¯\©\Ó':Ó#;Ñ<�GÜŸM™M×5Ñ5°dÀÇÁÈbÈcÐARÐYbÐ5Óc�EØ# e™^¨g¸¸U¹Ñ.CÑC�FÙ! &¨-Ó8‘ð +ð Ð  TÐ%5Ø $™¨¬c´%¸¿¹Ó2EÓ.FÑ)GÈ1ÈtÉ8Ñ)TÑT�ð Ð Ø×'Ñ'¨Ó/‰Fà×'Ñ'¨°Ó>ˆFØ—‘˜vÓ&ˆØ—‘˜vÓ&ˆàˆr   )r   r   r�   re   r   rg   rh   ru   )NNNr„   rn   s   @r   r§   r§   ‹  sò   ø„ ñð0 ØØ*?Ø.3Ø !Ø!ØØ ñO,àðO,ð ðO,ð ˜c 3˜h™ð	O,ð
 " # s (™OðO,ð ðO,ð ðO,ð ðO,ð õO,ðh &*Ø$(Ø-1ñ?à�<‰<ð?ð �|‰|˜dÑ"ð?ð �l‰l˜TÑ!ð	?ð
 —|‘| dÑ*ð?ð 
�‰÷?r   r§   c                   óT  ‡ — e Zd ZdZ	 	 	 	 ddedededededefˆ fd„Zd	e	j                  d
e	j                  fd„Zd	e	j                  d
e	j                  fd„Zde	j                  d
ee	j                  e	j                  ef   fd„Zde	j                  deedf   d
e	j                  fd„Zˆ xZS )ÚVectorQuantizerz´
    Improved version over VectorQuantizer, can be used as a drop-in replacement. Mostly avoids costly matrix
    multiplications and allows for post-hoc remapping of indices.
    Ún_eÚvq_embed_dimÚbetaÚunknown_indexÚsane_index_shapeÚlegacyc           	      ó>  •— t         ‰| �  «        || _        || _        || _        || _        t        j                  | j                  | j                  «      | _        | j                  j                  j                  j                  d| j                  z  d| j                  z  «       || _        | j                  �Ø| j                  dt        j                  t!        j"                  | j                  «      «      «       |  | j$                  j&                  d   | _        || _        | j*                  dk(  r%| j(                  | _        | j(                  dz   | _        t-        d| j                  › d| j(                  › d	| j*                  › d
�«       || _        y || _        || _        y )Ng      ð¿ç      ð?Úusedr   Úextrar+   z
Remapping z indices to z indices. Using z for unknown indices.)rD   rE   r¿   rÀ   rÁ   rÄ   rF   Ú	EmbeddingÚ	embeddingÚweightÚdataÚuniform_ÚremapÚregister_bufferr   ÚtensorÚnpÚloadrÇ   r    Úre_embedrÂ   ÚprintrÃ   )	rU   r¿   rÀ   rÁ   rÎ   rÂ   rÃ   rÄ   r^   s	           €r   rE   zVectorQuantizer.__init__>  sL  ø€ ô 	‰ÑÔØˆŒØ(ˆÔØˆŒ	ØˆŒäŸ™ d§h¡h°×0AÑ0AÓBˆŒØ�‰×Ñ×"Ñ"×+Ñ+¨D°4·8±8©O¸SÀ4Ç8Á8¹^ÔLàˆŒ
Ø�:‰:Ð!Ø× Ñ  ¬¯©´b·g±g¸d¿j¹jÓ6IÓ)JÔKÙØ ŸI™IŸO™O¨AÑ.ˆDŒMØ!.ˆDÔØ×!Ñ! WÒ,Ø%)§]¡]�Ô"Ø $§¡°Ñ 1�”ÜØ˜TŸX™X˜J l°4·=±=°/ð BØ×+Ñ+Ð,Ð,AðCôð !1ˆÕð  ˆDŒMà 0ˆÕr   Úindsr_   c                 ó  — |j                   }t        |«      dkD  sJ ‚|j                  |d   d«      }| j                  j	                  |«      }|d d …d d …d f   |d   k(  j                  «       }|j                  d«      }|j                  d«      dk  }| j                  dk(  rMt        j                  d| j                  ||   j                   ¬«      j	                  |j                  ¬«      ||<   n| j                  ||<   |j                  |«      S )	Nr+   r   r9   )NN.r   Úrandom)r¯   )Údevice)r    rL   ÚreshaperÇ   rµ   ÚlongÚargmaxÚsumrÂ   r   ÚrandintrÓ   rØ   )rU   rÕ   ÚishaperÇ   ÚmatchÚnewÚunknowns          r   Úremap_to_usedzVectorQuantizer.remap_to_usedc  sé   € Ø—‘ˆÜ�6‹{˜QŠÐˆØ�|‰|˜F 1™I rÓ*ˆØ�y‰y�|‰|˜DÓ!ˆØ’aš˜D�jÑ! T¨/Ñ%:Ñ:×@Ñ@ÓBˆØ�l‰l˜2ÓˆØ—)‘)˜A“, Ñ"ˆØ×Ñ Ò)Ü Ÿ=™=¨¨D¯M©MÀÀGÁ×@RÑ@RÔS×VÑVÐ^a×^hÑ^hÐVÓiˆC�ŠLà×-Ñ-ˆC�‰LØ�{‰{˜6Ó"Ð"r   c                 ó²  — |j                   }t        |«      dkD  sJ ‚|j                  |d   d«      }| j                  j	                  |«      }| j
                  | j                  j                   d   kD  rd||| j                  j                   d   k\  <   t        j                  |d d d …f   |j                   d   dgz  d d …f   d|«      }|j                  |«      S )Nr+   r   r9   )r    rL   rÙ   rÇ   rµ   rÓ   r   Úgather)rU   rÕ   rÞ   rÇ   Úbacks        r   Úunmap_to_allzVectorQuantizer.unmap_to_allq  s¸   € Ø—‘ˆÜ�6‹{˜QŠÐˆØ�|‰|˜F 1™I rÓ*ˆØ�y‰y�|‰|˜DÓ!ˆØ�=‰=˜4Ÿ9™9Ÿ?™?¨1Ñ-Ò-Ø/0ˆD�˜Ÿ™Ÿ™¨Ñ+Ñ+Ñ,Ü�|‰|˜D ¢q ™M¨$¯*©*°Q©-¸1¸#Ñ*=ºqÐ*@ÑAÀ1ÀdÓKˆØ�|‰|˜FÓ#Ð#r   rª   c                 óš  — |j                  dddd«      j                  «       }|j                  d| j                  «      }t	        j
                  t	        j                  || j                  j                  «      d¬«      }| j                  |«      j                  |j                  «      }d }d }| j                  sa| j                  t	        j                  |j                  «       |z
  dz  «      z  t	        j                  ||j                  «       z
  dz  «      z   }n`t	        j                  |j                  «       |z
  dz  «      | j                  t	        j                  ||j                  «       z
  dz  «      z  z   }|||z
  j                  «       z   }|j                  dddd«      j                  «       }| j                  �B|j                  |j                  d   d«      }| j!                  |«      }|j                  dd«      }| j"                  r:|j                  |j                  d   |j                  d   |j                  d   «      }|||||ffS )Nr   r   r   r+   r9   ©Údim)ÚpermuteÚ
contiguousÚviewrÀ   r   ÚargminÚcdistrÊ   rË   r    rÄ   rÁ   ÚmeanÚdetachrÎ   rÙ   râ   rÃ   )rU   rª   Úz_flattenedÚmin_encoding_indicesÚz_qÚ
perplexityÚmin_encodingsÚlosss           r   rc   zVectorQuantizer.forward{  sø  € à�I‰I�a˜˜A˜qÓ!×,Ñ,Ó.ˆØ—f‘f˜R ×!2Ñ!2Ó3ˆô  %Ÿ|™|¬E¯K©K¸ÀTÇ^Á^×EZÑEZÓ,[ÐabÔcÐà�n‰nÐ1Ó2×7Ñ7¸¿¹Ó@ˆØˆ
Øˆð �{Š{Ø—9‘9œuŸz™z¨3¯:©:«<¸!Ñ+;ÀÑ*AÓBÑBÄUÇZÁZÐQTÐWX×W_ÑW_ÓWaÑQaÐfgÑPgÓEhÑh‰Dä—:‘:˜sŸz™z›|¨aÑ/°AÑ5Ó6¸¿¹ÄUÇZÁZÐQTÐWX×W_ÑW_ÓWaÑQaÐfgÑPgÓEhÑ9hÑhˆDð   q¡× 0Ñ 0Ó 2Ñ2ˆð �k‰k˜!˜Q  1Ó%×0Ñ0Ó2ˆà�:‰:Ð!Ø#7×#?Ñ#?ÀÇÁÈÁ
ÈBÓ#OÐ Ø#'×#5Ñ#5Ð6JÓ#KÐ Ø#7×#?Ñ#?ÀÀAÓ#FÐ à× Ò Ø#7×#?Ñ#?ÀÇ	Á	È!ÁÈcÏiÉiÐXYÉlÐ\_×\eÑ\eÐfgÑ\hÓ#iÐ à�D˜: }Ð6JÐKÐKÐKr   Úindicesr    .c                 ó  — | j                   �7|j                  |d   d«      }| j                  |«      }|j                  d«      }| j                  |«      }|�3|j	                  |«      }|j                  dddd«      j                  «       }|S )Nr   r9   r   r+   r   )rÎ   rÙ   ræ   rÊ   rì   rê   rë   )rU   r÷   r    ró   s       r   Úget_codebook_entryz"VectorQuantizer.get_codebook_entry�  sƒ   € à�:‰:Ð!Ø—o‘o e¨A¡h°Ó3ˆGØ×'Ñ'¨Ó0ˆGØ—o‘o bÓ)ˆGð !ŸN™N¨7Ó3ˆàÐØ—(‘(˜5“/ˆCà—+‘+˜a  A qÓ)×4Ñ4Ó6ˆCàˆ
r   )Nr×   FT)r   r   r   r   ri   Úfloatrk   rl   rE   r   Ú
LongTensorrâ   ræ   r   rj   rc   rù   rm   rn   s   @r   r¾   r¾   5  sò   ø„ ñð Ø%Ø!&Øñ#1àð#1ð ð#1ð ð	#1ð ð#1ð ð#1ð õ#1ðJ# %×"2Ñ"2ð #°u×7GÑ7Gó #ð$ ×!1Ñ!1ð $°e×6FÑ6Fó $ð L˜Ÿ™ð  L¨%°·±¸e¿l¹lÈEÐ0QÑ*Ró  LðD¨%×*:Ñ*:ð À5ÈÈcÈÁ?ð ÐW\×WcÑWc÷ r   r¾   c                   ó  — e Zd Zddej                  defd„Zddej                  dz  dej                  fd„Zddd dej                  fd	„Z	g d
¢fdej                  de
edf   dej                  fd„Zdej                  fd„Zy)ÚDiagonalGaussianDistributionr³   Údeterministicc                 ó  — || _         t        j                  |dd¬«      \  | _        | _        t        j
                  | j                  dd«      | _        || _        t        j                  d| j                  z  «      | _        t        j                  | j                  «      | _	        | j                  rWt        j                  | j                  | j                   j                  | j                   j                  ¬«      x| _	        | _        y y )Nr   r+   rè   g      >Àg      4@ç      à?)rØ   r´   )r³   r   Úchunkrï   ÚlogvarÚclamprþ   ÚexpÚstdÚvarÚ
zeros_likerØ   r´   )rU   r³   rþ   s      r   rE   z%DiagonalGaussianDistribution.__init__°  s¹   € Ø$ˆŒÜ!&§¡¨Z¸ÀÔ!BÑˆŒ	�4”;Ü—k‘k $§+¡+¨u°dÓ;ˆŒØ*ˆÔÜ—9‘9˜S 4§;¡;Ñ.Ó/ˆŒÜ—9‘9˜TŸ[™[Ó)ˆŒØ×ÒÜ"'×"2Ñ"2Ø—	‘	 $§/¡/×"8Ñ"8ÀÇÁ×@UÑ@Uô#ð ˆDŒH�t•xð r   NÚ	generatorr_   c                 óÔ   — t        | j                  j                  || j                  j                  | j                  j
                  ¬«      }| j                  | j                  |z  z   }|S )N)r  rØ   r´   )r   rï   r    r³   rØ   r´   r  )rU   r  r   r‹   s       r   r   z#DiagonalGaussianDistribution.sample¼  sR   € äØ�I‰I�O‰OØØ—?‘?×)Ñ)Ø—/‘/×'Ñ'ô	
ˆð �I‰I˜Ÿ™ 6Ñ)Ñ)ˆØˆr   Úotherc                 ó  — | j                   rt        j                  dg«      S |€Wdt        j                  t        j                  | j
                  d«      | j                  z   dz
  | j                  z
  g d¢¬«      z  S dt        j                  t        j                  | j
                  |j
                  z
  d«      |j                  z  | j                  |j                  z  z   dz
  | j                  z
  |j                  z   g d¢¬«      z  S )Nç        r   r   rÆ   ©r+   r   r   rè   )rþ   r   r   rÜ   Úpowrï   r  r  )rU   r
  s     r   ÚklzDiagonalGaussianDistribution.klÇ  sá   € Ø×ÒÜ—<‘<  Ó&Ð&àˆ}ØœUŸY™YÜ—I‘I˜dŸi™i¨Ó+¨d¯h©hÑ6¸Ñ<¸t¿{¹{ÑJÚ!ôñ ð ð
 œUŸY™YÜ—I‘I˜dŸi™i¨%¯*©*Ñ4°aÓ8¸5¿9¹9ÑDØ—h‘h §¡Ñ*ñ+àñð —k‘kñ"ð —l‘lñ	#ò
 "ôñ ð r   r  r   Údims.c                 óB  — | j                   rt        j                  dg«      S t        j                  dt        j
                  z  «      }dt        j                  || j                  z   t        j                  || j                  z
  d«      | j                  z  z   |¬«      z  S )Nr  g       @r   r   rè   )rþ   r   r   rÑ   ÚlogÚpirÜ   r  r  rï   r  )rU   r   r  Úlogtwopis       r   Únllz DiagonalGaussianDistribution.nllÚ  s{   € Ø×ÒÜ—<‘<  Ó&Ð&Ü—6‘6˜#¤§¡™+Ó&ˆØ”U—Y‘YØ�t—{‘{Ñ"¤U§Y¡Y¨v¸¿	¹	Ñ/AÀ1Ó%EÈÏÉÑ%PÑPØô
ñ 
ð 	
r   c                 ó   — | j                   S rƒ   )rï   ©rU   s    r   r°   z!DiagonalGaussianDistribution.modeã  s   € Ø�y‰yÐr   )Frƒ   )r   r   r   r   r   rl   rE   Ú	Generatorr   r  rj   ri   r  r°   r   r   r   rý   rý   ¯  s’   „ ñ
 5§<¡<ð 
Àó 
ñ	 §¡°$Ñ 6ð 	À%Ç,Á,ó 	ñÐ6ð À%Ç,Á,ó ò& AJñ 
˜%Ÿ,™,ð 
¨e°C¸°H©oð 
ÈeÏlÉló 
ð�e—l‘lô r   rý   c                   óŒ   — e Zd Zdej                  fd„Zddej                  dz  dej                  fd„Zdej                  fd„Zy)	ÚIdentityDistributionr³   c                 ó   — || _         y rƒ   ©r³   )rU   r³   s     r   rE   zIdentityDistribution.__init__è  s	   € Ø$ˆ�r   Nr  r_   c                 ó   — | j                   S rƒ   r  )rU   r  s     r   r   zIdentityDistribution.sampleë  ó   € Ø�‰Ðr   c                 ó   — | j                   S rƒ   r  r  s    r   r°   zIdentityDistribution.modeî  r  r   rƒ   )	r   r   r   r   r   rE   r  r   r°   r   r   r   r  r  ç  sB   „ ð% 5§<¡<ó %ñ §¡°$Ñ 6ð À%Ç,Á,ó ð�e—l‘lô r   r  c            
       ó„   ‡ — e Zd ZdZdededeedf   deedf   def
ˆ fd„Zd	ej                  d
ej                  fd„Z
ˆ xZS )ÚEncoderTinya’  
    The `EncoderTiny` layer is a simpler version of the `Encoder` layer.

    Args:
        in_channels (`int`):
            The number of input channels.
        out_channels (`int`):
            The number of output channels.
        num_blocks (`tuple[int, ...]`):
            Each value of the tuple represents a Conv2d layer followed by `value` number of `AutoencoderTinyBlock`'s to
            use.
        block_out_channels (`tuple[int, ...]`):
            The number of output channels for each block.
        act_fn (`str`):
            The activation function to use. See `~diffusers.models.activations.get_activation` for available options.
    r"   r#   Ú
num_blocks.r%   r(   c                 óð  •— t         ‰| �  «        g }t        |«      D ]Ž  \  }}||   }	|dk(  r)|j                  t	        j
                  ||	dd¬«      «       n*|j                  t	        j
                  |	|	dddd¬«      «       t        |«      D ]  }
|j                  t        |	|	|«      «       Œ  Œ� |j                  t	        j
                  |d   |dd¬«      «       t	        j                  |Ž | _	        d| _
        y )	Nr   r   r+   ©r-   r/   r   F)r-   r/   r.   Úbiasr9   )rD   rE   rK   rM   rF   rG   r–   r
   r—   r˜   rT   )rU   r"   r#   r"  r%   r(   r˜   rX   Ú	num_blockr@   Ú_r^   s              €r   rE   zEncoderTiny.__init__  sã   ø€ ô 	‰ÑÔàˆÜ% jÖ1‰LˆAˆyØ-¨aÑ0ˆLà�AŠvØ—‘œbŸi™i¨°\ÈqÐZ[Ô\Õ]à—‘Ü—I‘IØ$Ø$Ø$%Ø !Ø Ø"ôô	ô ˜9Ö%�Ø—‘Ô2°<ÀÈvÓVÕWñ &ð# 2ð( 	�‰”b—i‘iÐ 2°2Ñ 6¸ÐRSÐ]^Ô_Ô`ä—m‘m VÐ,ˆŒØ&+ˆÕ#r   r‹   r_   c                 óà   — t        j                  «       r*| j                  r| j                  | j                  |«      }|S | j	                  |j                  d«      j                  d«      «      }|S )z.The forward method of the `EncoderTiny` class.r+   r   )r   ra   rT   rb   r˜   ÚaddÚdivrŽ   s     r   rc   zEncoderTiny.forward(  sX   € ä× Ñ Ô" t×'BÒ'BØ×1Ñ1°$·+±+¸qÓAˆAð ˆð —‘˜AŸE™E !›HŸL™L¨›OÓ,ˆAàˆr   r„   rn   s   @r   r!  r!  ò  si   ø„ ñð"",àð",ð ð",ð ˜#˜s˜(‘Oð	",ð
 " # s (™Oð",ð õ",ðH	˜Ÿ™ð 	¨%¯,©,÷ 	r   r!  c                   óŒ   ‡ — e Zd ZdZdededeedf   deedf   deded	efˆ fd
„Zdej                  dej                  fd„Z
ˆ xZS )ÚDecoderTinyaó  
    The `DecoderTiny` layer is a simpler version of the `Decoder` layer.

    Args:
        in_channels (`int`):
            The number of input channels.
        out_channels (`int`):
            The number of output channels.
        num_blocks (`tuple[int, ...]`):
            Each value of the tuple represents a Conv2d layer followed by `value` number of `AutoencoderTinyBlock`'s to
            use.
        block_out_channels (`tuple[int, ...]`):
            The number of output channels for each block.
        upsampling_scaling_factor (`int`):
            The scaling factor to use for upsampling.
        act_fn (`str`):
            The activation function to use. See `~diffusers.models.activations.get_activation` for available options.
    r"   r#   r"  .r%   Úupsampling_scaling_factorr(   Úupsample_fnc           
      ó  •— t         ‰| �  «        t        j                  ||d   dd¬«      t	        |«      g}t        |«      D ]ž  \  }	}
|	t        |«      dz
  k(  }||	   }t        |
«      D ]  }|j                  t        |||«      «       Œ  |s&|j                  t        j                  ||¬«      «       |s|n|}|j                  t        j                  ||dd|¬«      «       Œ  t        j                  |Ž | _        d| _        y )Nr   r   r+   r$  )Úscale_factorr°   )r-   r/   r%  F)rD   rE   rF   rG   r   rK   rL   r–   rM   r
   ÚUpsampler—   r˜   rT   )rU   r"   r#   r"  r%   r-  r(   r.  r˜   rX   r&  r[   r@   r'  Úconv_out_channelr^   s                  €r   rE   zDecoderTiny.__init__H  sú   ø€ ô 	‰ÑÔô �I‰I�kÐ#5°aÑ#8ÀaÐQRÔSÜ˜6Ó"ð
ˆô
 & jÖ1‰LˆAˆyØ¤3 z£?°QÑ#6Ñ7ˆNØ-¨aÑ0ˆLä˜9Ö%�Ø—‘Ô2°<ÀÈvÓVÕWð &ñ "Ø—‘œbŸk™kÐ7PÐWbÔcÔdá3A™|À|ÐØ�M‰MÜ—	‘	Ø Ø$Ø !ØØ'ôõð 2ô* —m‘m VÐ,ˆŒØ&+ˆÕ#r   r‹   r_   c                 ó  — t        j                  |dz  «      dz  }t        j                  «       r)| j                  r| j	                  | j
                  |«      }n| j                  |«      }|j                  d«      j                  d«      S )z.The forward method of the `DecoderTiny` class.r   r   r+   )r   Útanhra   rT   rb   r˜   ÚmulÚsubrŽ   s     r   rc   zDecoderTiny.forwardq  sj   € ô �J‰J�q˜1‘uÓ Ñ!ˆä× Ñ Ô" t×'BÒ'BØ×1Ñ1°$·+±+¸qÓA‰Aà—‘˜A“ˆAð �u‰u�Q‹x�|‰|˜A‹Ðr   r„   rn   s   @r   r,  r,  4  s}   ø„ ñð&',àð',ð ð',ð ˜#˜s˜(‘Oð	',ð
 " # s (™Oð',ð $'ð',ð ð',ð õ',ðR˜Ÿ™ð ¨%¯,©,÷ r   r,  c                   ó$   — e Zd Zd„ Zd„ Zd„ Zd„ Zy)ÚAutoencoderMixinc                 óp   — t        | d«      s#t        d| j                  j                  › d�«      ‚d| _        y)a  
        Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
        compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
        processing larger images.
        Ú
use_tilingz*Tiling doesn't seem to be implemented for Ú.TN)ÚhasattrÚNotImplementedErrorr^   r   r:  r  s    r   Úenable_tilingzAutoencoderMixin.enable_tiling€  s9   € ô �t˜\Ô*Ü%Ð(RÐSW×SaÑSa×SjÑSjÐRkÐklÐ&mÓnÐnØˆ�r   c                 ó   — d| _         y)zœ
        Disable tiled VAE decoding. If `enable_tiling` was previously enabled, this method will go back to computing
        decoding in one step.
        FN)r:  r  s    r   Údisable_tilingzAutoencoderMixin.disable_tilingŠ  s   € ð
  ˆ�r   c                 óp   — t        | d«      s#t        d| j                  j                  › d�«      ‚d| _        y)zç
        Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
        compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.
        Úuse_slicingz+Slicing doesn't seem to be implemented for r;  TN)r<  r=  r^   r   rB  r  s    r   Úenable_slicingzAutoencoderMixin.enable_slicing‘  s:   € ô
 �t˜]Ô+Ü%Ð(SÐTX×TbÑTb×TkÑTkÐSlÐlmÐ&nÓoÐoØˆÕr   c                 ó   — d| _         y)zž
        Disable sliced VAE decoding. If `enable_slicing` was previously enabled, this method will go back to computing
        decoding in one step.
        FN)rB  r  s    r   Údisable_slicingz AutoencoderMixin.disable_slicingš  s   € ð
 !ˆÕr   N)r   r   r   r>  r@  rC  rE  r   r   r   r8  r8    s   „ òò ò ó!r   r8  )#Údataclassesr   ÚnumpyrÑ   r   Útorch.nnrF   Úutilsr   Úutils.torch_utilsr   Úactivationsr   Úattention_processorr	   Úunets.unet_2d_blocksr
   r   r   r   r   r   ÚModuler!   rp   r†   r‘   r§   r¾   Úobjectrý   r  r!  r,  r8  r   r   r   Ú<module>rP     s  ðõ "ã Û Ý å Ý -Ý (Ý -÷ó ð ô	�Jó 	ó ð	ð ô
1�Jó 
1ó ð
1ôvˆb�i‰iô vôrCˆb�i‰iô CôLˆr�y‰yô ô82˜2Ÿ9™9ô 2ôjg˜2Ÿ9™9ô gôTw�b—i‘iô wôt5 6ô 5ôp˜6ô ô?�"—)‘)ô ?ôDH�"—)‘)ô H÷V !ò  !r   