U
    ¯Ê¹jåZ  ã                   @   sl  d Z ddlmZ ddlmZ ddlZddlmZ ddlm  m	Z
 ddlmZ ddlmZmZ ddlmZmZmZmZmZmZmZ ddlmZmZ d	d
lmZ d	dlmZ d	dlmZ d	dlm Z m!Z! dgZ"G dd„ dej#ƒZ$G dd„ dej#ƒZ%G dd„ dej#ƒZ&G dd„ dej#ƒZ'G dd„ dej#ƒZ(eee)e)f dœdd„Z*eeee)e)f e)e)dœdd„ƒZ+G dd „ d ej#ƒZ,G d!d"„ d"ej#ƒZ-G d#d$„ d$ej#ƒZ.G d%d„ dej#ƒZ/d&d'„ Z0d>d)d*„Z1d?d,d-„Z2e e2d.d/�e2d.d/�e2d.d/�e2ƒ e2ƒ e2ƒ d0œƒZ3e!d@e/d1œd2d3„ƒZ4e!dAe/d1œd4d5„ƒZ5e!dBe/d1œd6d7„ƒZ6e!dCe/d1œd8d9„ƒZ7e!dDe/d1œd:d;„ƒZ8e!dEe/d1œd<d=„ƒZ9dS )Faf   DaViT: Dual Attention Vision Transformers

As described in https://arxiv.org/abs/2204.03645

Input size invariant transformer architecture that combines channel and spacial
attention in each block. The attention mechanisms used are linear in complexity.

DaViT model defs and weights adapted from https://github.com/dingmyu/davit, original copyright below

é    )Úpartial)ÚTupleN)ÚTensor©ÚIMAGENET_DEFAULT_MEANÚIMAGENET_DEFAULT_STD)ÚDropPathÚ	to_2tupleÚtrunc_normal_ÚMlpÚLayerNorm2dÚget_norm_layerÚuse_fused_attn)ÚNormMlpClassifierHeadÚClassifierHeadé   )Úbuild_model_with_cfg)Úregister_notrace_function)Úcheckpoint_seq)Úgenerate_default_cfgsÚregister_modelÚDaVitc                       s6   e Zd Zd	eeedœ‡ fdd„Zedœdd„Z‡  ZS )
Ú
ConvPosEncé   F©ÚdimÚkÚactc                    sD   t t| ƒ ¡  tj|||d|d |d�| _|r6t ¡ nt ¡ | _d S )Nr   é   )Úgroups)	Úsuperr   Ú__init__ÚnnÚConv2dÚprojÚGELUÚIdentityr   )Úselfr   r   r   ©Ú	__class__© úP/var/www/html/bwave/python/venv/lib/python3.8/site-packages/timm/models/davit.pyr!   "   s    zConvPosEnc.__init__©Úxc                 C   s   |   |¡}||  |¡ }|S ©N)r$   r   )r'   r-   Zfeatr*   r*   r+   Úforward(   s    
zConvPosEnc.forward)r   F)	Ú__name__Ú
__module__Ú__qualname__ÚintÚboolr!   r   r/   Ú__classcell__r*   r*   r(   r+   r   !   s   r   c                       s8   e Zd ZdZdddef‡ fdd„	Zedœdd	„Z‡  ZS )
ÚStemzŒ Size-agnostic implementation of 2D image to patch embedding,
        allowing input size to be adjusted during model forward operation
    r   é`   é   c                    sX   t ƒ  ¡  t|ƒ}|| _|| _|| _|d dks4t‚tj||d|dd�| _	||ƒ| _
d S )Nr   r8   é   r   ©Zkernel_sizeÚstrideÚpadding)r    r!   r	   r;   Úin_chsÚout_chsÚAssertionErrorr"   r#   ÚconvÚnorm)r'   r=   r>   r;   Ú
norm_layerr(   r*   r+   r!   3   s    
ûzStem.__init__r,   c              
   C   s†   |j \}}}}t |d| jd || jd   | jd  f¡}t |ddd| jd || jd   | jd  f¡}|  |¡}|  |¡}|S )Nr   r   )ÚshapeÚFÚpadr;   r@   rA   ©r'   r-   ÚBÚCÚHÚWr*   r*   r+   r/   I   s    .2

zStem.forward)	r0   r1   r2   Ú__doc__r   r!   r   r/   r5   r*   r*   r(   r+   r6   .   s   ûr6   c                       s.   e Zd Zef‡ fdd„	Zedœdd„Z‡  ZS )Ú
Downsamplec                    s:   t ƒ  ¡  || _|| _||ƒ| _tj||dddd�| _d S )Nr   r   r:   )r    r!   r=   r>   rA   r"   r#   r@   )r'   r=   r>   rB   r(   r*   r+   r!   S   s    

ûzDownsample.__init__r,   c              	   C   sb   |j \}}}}|  |¡}t |dd|d  d f¡}t |dddd|d  d f¡}|  |¡}|S )Nr   r   )rC   rA   rD   rE   r@   rF   r*   r*   r+   r/   f   s    
 
zDownsample.forward)r0   r1   r2   r   r!   r   r/   r5   r*   r*   r(   r+   rL   R   s   ürL   c                       s,   e Zd Zd‡ fdd„	Zedœdd„Z‡  ZS )	ÚChannelAttentioné   Fc                    sJ   t ƒ  ¡  || _|| }|d | _tj||d |d�| _t ||¡| _d S )Nç      à¿r   ©Úbias)r    r!   Ú	num_headsÚscaler"   ÚLinearÚqkvr$   )r'   r   rR   Úqkv_biasÚhead_dimr(   r*   r+   r!   q   s    

zChannelAttention.__init__r,   c           
      C   s¬   |j \}}}|  |¡ ||d| j|| j ¡ ddddd¡}| d¡\}}}|| j }| dd¡| }	|	jdd�}	|	| dd¡  dd¡}| dd¡ |||¡}|  	|¡}|S )	Nr   r   r   r   r8   éÿÿÿÿéþÿÿÿ©r   )
rC   rU   ÚreshaperR   ÚpermuteÚunbindrS   Ú	transposeÚsoftmaxr$   )
r'   r-   rG   ÚNrH   rU   Úqr   ÚvZ	attentionr*   r*   r+   r/   z   s    .

zChannelAttention.forward)rN   F)r0   r1   r2   r!   r   r/   r5   r*   r*   r(   r+   rM   o   s   	rM   c                       s>   e Zd Zdddejejddf‡ fdd„	Zedœdd	„Z‡  Z	S )
ÚChannelBlockç      @Fç        Tc
           
         s¾   t ƒ  ¡  t|d|	d�| _|| _||ƒ| _t|||d�| _|dkrJt|ƒnt	 
¡ | _t|d|	d�| _| jr¨||ƒ| _t|t|| ƒ|d�| _|dkrœt|ƒnt	 
¡ | _nd | _d | _d | _d S ©Nr   r   )rR   rV   re   )Zin_featuresZhidden_featuresÚ	act_layer)r    r!   r   Úcpe1ÚffnÚnorm1rM   Úattnr   r"   r&   Ú
drop_path1Úcpe2Únorm2r   r3   ÚmlpÚ
drop_path2)
r'   r   rR   Ú	mlp_ratiorV   Ú	drop_pathrg   rB   ri   Úcpe_actr(   r*   r+   r!   ‹   s$    



ýzChannelBlock.__init__r,   c                 C   s¸   |j \}}}}|  |¡ d¡ dd¡}|  |¡}|  |¡}||  |¡ }|  | dd¡ ||||¡¡}| j	d k	r´| d¡ dd¡}||  
|  	|  |¡¡¡ }| dd¡ ||||¡}|S )Nr   r   )rC   rh   Úflattenr^   rj   rk   rl   rm   Úviewro   rp   rn   )r'   r-   rG   rH   rI   rJ   Úcurr*   r*   r+   r/   ­   s    


zChannelBlock.forward)
r0   r1   r2   r"   r%   Ú	LayerNormr!   r   r/   r5   r*   r*   r(   r+   rc   ‰   s   ö"rc   )r-   Úwindow_sizec                 C   sj   | j \}}}}|  |||d  |d ||d  |d |¡} |  dddddd¡ ¡  d|d |d |¡}|S )z™
    Args:
        x: (B, H, W, C)
        window_size (int): window size
    Returns:
        windows: (num_windows*B, window_size, window_size, C)
    r   r   r   r   r8   é   rX   ©rC   ru   r\   Ú
contiguous)r-   rx   rG   rI   rJ   rH   Úwindowsr*   r*   r+   Úwindow_partitionÀ   s    ,,r}   )r|   rx   rI   rJ   c                 C   s^   | j d }|  d||d  ||d  |d |d |¡}| dddddd¡ ¡  d|||¡}|S )zÚ
    Args:
        windows: (num_windows*B, window_size, window_size, C)
        window_size (int): Window size
        H (int): Height of image
        W (int): Width of image
    Returns:
        x: (B, H, W, C)
    rX   r   r   r   r   r8   ry   rz   )r|   rx   rI   rJ   rH   r-   r*   r*   r+   Úwindow_reverseÎ   s    
,$r~   c                       sB   e Zd ZU dZejje ed< d	‡ fdd„	Z	e
dœdd„Z‡  ZS )
ÚWindowAttentiona§   Window based multi-head self attention (W-MSA) module with relative position bias.
    It supports both of shifted and non-shifted window.
    Args:
        dim (int): Number of input channels.
        window_size (tuple[int]): The height and width of the window.
        num_heads (int): Number of attention heads.
        qkv_bias (bool, optional):  If True, add a learnable bias to query, key, value. Default: True
    Ú
fused_attnTc                    sl   t ƒ  ¡  || _|| _|| _|| }|d | _tƒ | _tj	||d |d�| _
t 	||¡| _tjdd�| _d S )NrO   r   rP   rX   rZ   )r    r!   r   rx   rR   rS   r   r€   r"   rT   rU   r$   ZSoftmaxr_   )r'   r   rx   rR   rV   rW   r(   r*   r+   r!   ê   s    

zWindowAttention.__init__r,   c           
      C   s°   |j \}}}|  |¡ ||d| j|| j ¡ ddddd¡}| d¡\}}}| jr`t |||¡}n,|| j	 }|| 
dd¡ }	|  |	¡}	|	| }| 
dd¡ |||¡}|  |¡}|S )Nr   r   r   r   r8   rY   rX   )rC   rU   r[   rR   r\   r]   r€   rD   Zscaled_dot_product_attentionrS   r^   r_   r$   )
r'   r-   ZB_r`   rH   rU   ra   r   rb   rk   r*   r*   r+   r/   ø   s    .


zWindowAttention.forward)T)r0   r1   r2   rK   ÚtorchÚjitÚFinalr4   Ú__annotations__r!   r   r/   r5   r*   r*   r(   r+   r   ß   s   
r   c                       sD   e Zd ZdZddddejejddf‡ fdd„	Zed	œd
d„Z	‡  Z
S )ÚSpatialBlocka<   Windows Block.
    Args:
        dim (int): Number of input channels.
        num_heads (int): Number of attention heads.
        window_size (int): Window size.
        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
        drop_path (float, optional): Stochastic depth rate. Default: 0.0
        act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
    r9   rd   Tre   Fc                    sâ   t ƒ  ¡  || _|	| _|| _t|ƒ| _|| _t|d|
d�| _	||ƒ| _
t|| j||d�| _|dkrjt|ƒnt ¡ | _t|d|
d�| _| jrÌ||ƒ| _t|| ƒ}t|||d�| _|dkrÀt|ƒnt ¡ | _nd | _d | _d | _d S rf   )r    r!   r   ri   rR   r	   rx   rq   r   rh   rj   r   rk   r   r"   r&   rl   rm   rn   r3   r   ro   rp   )r'   r   rR   rx   rq   rV   rr   rg   rB   ri   rs   Zmlp_hidden_dimr(   r*   r+   r!     s8    


ü
ýzSpatialBlock.__init__r,   c              	   C   sÈ  |j \}}}}|  |¡ d¡ dd¡}|  |¡}| ||||¡}d }}| jd || jd   | jd  }	| jd || jd   | jd  }
t |dd||	||
f¡}|j \}}}}t	|| jƒ}| d| jd | jd  |¡}|  
|¡}| d| jd | jd |¡}t|| j||ƒ}|d d …d |…d |…d d …f  ¡ }| ||| |¡}||  |¡ }|  | dd¡ ||||¡¡}| jd k	�rÄ| d¡ dd¡}||  |  |  |¡¡¡ }| dd¡ ||||¡}|S )Nr   r   r   rX   )rC   rh   rt   r^   rj   ru   rx   rD   rE   r}   rk   r~   r{   rl   rm   ro   rp   rn   )r'   r-   rG   rH   rI   rJ   ZshortcutZpad_lZpad_tZpad_rZpad_bÚ_ZHpZWpZ	x_windowsZattn_windowsr*   r*   r+   r/   E  s.    
""
$zSpatialBlock.forward)r0   r1   r2   rK   r"   r%   rw   r!   r   r/   r5   r*   r*   r(   r+   r…     s   õ-r…   c                       sX   e Zd Zddddddddeejddf‡ fd	d
„	Zejj	ddd„ƒZ
edœdd„Z‡  ZS )Ú
DaVitStager   T©ÚspatialÚchannelr   r9   r8   )r   r   Fc                    sÐ   t ƒ  ¡  d| _|r&t|||d�| _n
t ¡ | _g }t|ƒD ]‚}g }t|ƒD ]`\}}|dkr‚| 	t
||||	|
| ||||d�	¡ qL|dkrL| 	t||||	|
| |||d�¡ qL| 	tj|Ž ¡ q<tj|Ž | _d S )NF©rB   r‰   )	r   rR   rq   rV   rr   rB   ri   rs   rx   rŠ   )r   rR   rq   rV   rr   rB   ri   rs   )r    r!   Úgrad_checkpointingrL   Ú
downsampler"   r&   ÚrangeÚ	enumerateÚappendr…   rc   Ú
SequentialÚblocks)r'   r=   r>   Údepthr�   Ú
attn_typesrR   rx   rq   rV   Údrop_path_ratesrB   Únorm_layer_clri   rs   Zstage_blocksZ	block_idxZdual_attention_blockZattn_idxZ	attn_typer(   r*   r+   r!   n  sD    

	÷
ø

zDaVitStage.__init__c                 C   s
   || _ d S r.   )rŒ   )r'   Úenabler*   r*   r+   Úset_grad_checkpointing®  s    z!DaVitStage.set_grad_checkpointingr,   c                 C   s6   |   |¡}| jr(tj ¡ s(t| j|ƒ}n
|  |¡}|S r.   )r�   rŒ   r�   r‚   Úis_scriptingr   r’   ©r'   r-   r*   r*   r+   r/   ²  s
    

zDaVitStage.forward)T)r0   r1   r2   r   r"   rw   r!   r�   r‚   Úignorer˜   r   r/   r5   r*   r*   r(   r+   r‡   m  s    ñ@r‡   c                       sˆ   e Zd ZdZd%‡ fdd„	Zdd„ Zejjd&dd„ƒZ	ejjd'dd„ƒZ
ejjdd„ ƒZd(dd„Zdd„ Zd)ed œd!d"„Zd#d$„ Z‡  ZS )*r   að   DaViT
        A PyTorch implementation of `DaViT: Dual Attention Vision Transformers`  - https://arxiv.org/abs/2204.03645
        Supports arbitrary input sizes and pyramid feature extraction
        
    Args:
        in_chans (int): Number of input image channels. Default: 3
        num_classes (int): Number of classes for classification head. Default: 1000
        depths (tuple(int)): Number of blocks in each stage. Default: (1, 1, 3, 1)
        embed_dims (tuple(int)): Patch embedding dimension. Default: (96, 192, 384, 768)
        num_heads (tuple(int)): Number of attention heads in different layers. Default: (3, 6, 12, 24)
        window_size (int): Window size. Default: 7
        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4
        qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
        drop_path_rate (float): Stochastic depth rate. Default: 0.1
        norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
    r   ©r   r   r   r   ©r7   éÀ   é€  é   ©r   é   é   é   r9   r8   TÚlayernorm2dÚ	layernormçñhãˆµøä>rˆ   Fre   éè  Úavgc                    s˜  t ƒ  ¡  t|ƒ}|t|ƒ  kr.t|ƒks4n t‚tt|ƒ|
d�}tt|	ƒ|
d�}	|| _|d | _|| _d| _	g | _
t||d |d�| _|d }dd„ t d|t|ƒ¡ |¡D ƒ}g }t|ƒD ]n}|| }t|||| |dk||| ||||| ||	||d�}|}| |¡ |  j
t|d	d
|› �d�g7  _
qÀtj|Ž | _|�rf|| jƒ| _t| j||| jd�| _n"t ¡ | _t| j||| j|d�| _|  | j¡ d S )N)ÚepsrX   Fr   r‹   c                 S   s   g | ]}|  ¡ ‘qS r*   )Útolist)Ú.0r-   r*   r*   r+   Ú
<listcomp>ð  s     z"DaVit.__init__.<locals>.<listcomp>)r“   r�   r”   rR   rx   rq   rV   r•   rB   r–   ri   rs   r   zstages.)Znum_chsZ	reductionÚmodule)Ú	pool_typeÚ	drop_rate)r¯   r°   rB   )r    r!   Úlenr?   r   r   Únum_classesZnum_featuresr°   rŒ   Zfeature_infor6   Ústemr�   ZlinspaceÚsumÚsplitrŽ   r‡   r�   Údictr"   r‘   ÚstagesÚnorm_prer   Úheadr&   r   ÚapplyÚ_init_weights)r'   Zin_chansÚdepthsÚ
embed_dimsrR   rx   rq   rV   rB   r–   Znorm_epsr”   ri   rs   r°   Zdrop_path_rater²   Úglobal_poolZhead_norm_firstZ
num_stagesr=   Zdprr·   Z	stage_idxr>   Ústager(   r*   r+   r!   Í  sj    
"
"ò
"ü

ûzDaVit.__init__c                 C   sD   t |tjƒr@t|jdd� t |tjƒr@|jd k	r@tj |jd¡ d S )Ng{®Gáz”?)Ústdr   )Ú
isinstancer"   rT   r
   ÚweightrQ   ÚinitZ	constant_)r'   Úmr*   r*   r+   r»      s    zDaVit._init_weightsc                 C   s   t d|rdndddgd�S )Nz^stemz^stages\.(\d+))z^stages\.(\d+).downsample)r   )z^stages\.(\d+)\.blocks\.(\d+)N)z	^norm_pre)iŸ† )r³   r’   )r¶   )r'   Zcoarser*   r*   r+   Úgroup_matcher&  s    ýþzDaVit.group_matcherc                 C   s"   || _ | jD ]}|j|d� qd S )N)r—   )rŒ   r·   r˜   )r'   r—   r¿   r*   r*   r+   r˜   1  s    
zDaVit.set_grad_checkpointingc                 C   s   | j jS r.   )r¹   Úfc)r'   r*   r*   r+   Úget_classifier7  s    zDaVit.get_classifierNc                 C   s   | j  ||¡ d S r.   )r¹   Úreset)r'   r²   r¾   r*   r*   r+   Úreset_classifier;  s    zDaVit.reset_classifierc                 C   s@   |   |¡}| jr(tj ¡ s(t| j|ƒ}n
|  |¡}|  |¡}|S r.   )r³   rŒ   r�   r‚   r™   r   r·   r¸   rš   r*   r*   r+   Úforward_features>  s    


zDaVit.forward_features©Ú
pre_logitsc                 C   s   |r| j |dd�S |   |¡S )NTrË   )r¹   )r'   r-   rÌ   r*   r*   r+   Úforward_headG  s    zDaVit.forward_headc                 C   s   |   |¡}|  |¡}|S r.   )rÊ   rÍ   rš   r*   r*   r+   r/   J  s    

zDaVit.forward)r   rœ   r�   r¡   r9   r8   Tr¥   r¦   r§   rˆ   TFre   re   r¨   r©   F)F)T)N)F)r0   r1   r2   rK   r!   r»   r�   r‚   r›   rÅ   r˜   rÇ   rÉ   rÊ   r4   rÍ   r/   r5   r*   r*   r(   r+   r   »  s>                     íS


	c                 C   sª   d| kr| S d| kr| d } ddl }i }|  ¡ D ]t\}}| dd|¡}| dd|¡}| d	d
¡}| dd¡}| dd¡}| dd¡}| dd¡}| dd¡}|||< q0|S )z  Remap MSFT checkpoints -> timm zhead.fc.weightÚ
state_dictr   Nzpatch_embeds.([0-9]+)zstages.\1.downsamplezmain_blocks.([0-9]+)zstages.\1.blockszdownsample.projzdownsample.convzstages.0.downsampler³   zhead.zhead.fc.znorms.z
head.norm.zcpe.0rh   zcpe.1rm   )ÚreÚitemsÚsubÚreplace)rÎ   ÚmodelrÏ   Zout_dictr   rb   r*   r*   r+   Úcheckpoint_filter_fnP  s"    
rÔ   Fc                 K   sP   t dd„ t| dd¡ƒD ƒƒ}| d|¡}tt| |fttd|d�dœ|—Ž}|S )	Nc                 s   s   | ]\}}|V  qd S r.   r*   )r¬   Úir†   r*   r*   r+   Ú	<genexpr>h  s     z _create_davit.<locals>.<genexpr>r¼   rœ   Úout_indicesT)Zflatten_sequentialr×   )Zpretrained_filter_fnZfeature_cfg)Útupler�   ÚgetÚpopr   r   rÔ   r¶   )ÚvariantÚ
pretrainedÚkwargsZdefault_out_indicesr×   rÓ   r*   r*   r+   Ú_create_davitg  s    ý
ûúrÞ   Ú c                 K   s   | dddddt tdddœ
|–S )	Nr¨   )r   éà   rà   )r9   r9   gffffffî?Zbicubicz	stem.convzhead.fc)
Úurlr²   Z
input_sizeZ	pool_sizeZcrop_pctÚinterpolationZmeanrÀ   Z
first_convÚ
classifierr   )rá   rÝ   r*   r*   r+   Ú_cfgv  s         ûúrä   ztimm/)Z	hf_hub_id)zdavit_tiny.msft_in1kzdavit_small.msft_in1kzdavit_base.msft_in1kÚdavit_largeÚ
davit_hugeÚdavit_giant)Úreturnc                 K   s(   t dddd�}tdd| it |f|Ž—ŽS )Nrœ   r�   r¡   ©r¼   r½   rR   Ú
davit_tinyrÜ   )rê   ©r¶   rÞ   ©rÜ   rÝ   Z
model_argsr*   r*   r+   rê   �  s    rê   c                 K   s(   t dddd�}tdd| it |f|Ž—ŽS )N©r   r   é	   r   r�   r¡   ré   Údavit_smallrÜ   )rï   rë   rì   r*   r*   r+   rï   –  s    rï   c                 K   s(   t dddd�}tdd| it |f|Ž—ŽS )Nrí   )é€   é   é   é   )r8   rN   é   é    ré   Ú
davit_baserÜ   )rö   rë   rì   r*   r*   r+   rö   œ  s    rö   c                 K   s(   t dddd�}tdd| it |f|Ž—ŽS )Nrí   )rž   rŸ   r    é   )r¢   r£   r¤   é0   ré   rå   rÜ   )rå   rë   rì   r*   r*   r+   rå   ¢  s    rå   c                 K   s(   t dddd�}tdd| it |f|Ž—ŽS )Nrí   )rñ   rò   ró   i   )rN   rô   rõ   é@   ré   ræ   rÜ   )ræ   rë   rì   r*   r*   r+   ræ   ¨  s    ræ   c                 K   s(   t dddd�}tdd| it |f|Ž—ŽS )N)r   r   r£   r   )rŸ   r    r÷   i   )r£   r¤   rø   r7   ré   rç   rÜ   )rç   rë   rì   r*   r*   r+   rç   ®  s    rç   )F)rß   )F)F)F)F)F)F):rK   Ú	functoolsr   Útypingr   r�   Ztorch.nnr"   Ztorch.nn.functionalZ
functionalrD   r   Z	timm.datar   r   Ztimm.layersr   r	   r
   r   r   r   r   r   r   Z_builderr   Z_features_fxr   Z_manipulater   Ú	_registryr   r   Ú__all__ÚModuler   r6   rL   rM   rc   r3   r}   r~   r   r…   r‡   r   rÔ   rÞ   rä   Zdefault_cfgsrê   rï   rö   rå   ræ   rç   r*   r*   r*   r+   Ú<module>   sp   $$7,bN 

ÿÿÿö