§
    9²¸j£=  ã                   ór  — d Z ddlZddlmZmZmZmZ ddlmZ ddl	m
Z
  edd	¦  «         ed
d¦  «         edd¦  «         edd¦  «         edd¦  «         edd¦  «         edd¦  «         edd¦  «         edd¦  «         edd¦  «        g
Zdee         fd„ZdeiZ G d„ d e¦  «        Z G d!„ d"e¦  «        Z G d#„ d$e¦  «        Z G d%„ d&e¦  «        Z G d'„ d(e¦  «        Z G d)„ d*e¦  «        Z G d+„ d,e¦  «        Z G d-„ d.e¦  «        Z G d/„ d0e¦  «        Zd1eeej        f         dej        fd2„ZdS )3a  GGUF -> transformers weight conversion mappings, one entry per architecture.

`WeightRenaming`s map GGUF names into the transformers namespace and chain; `WeightConverter`s then
undo llama.cpp's value/layout transforms, matching on the renamed key, at most one per key.
é    Né   )ÚConversionOpsÚWeightConverterÚWeightRenamingÚWeightTransformé   )Ú
GGML_BLOCK)Údequantize_blocksz^token_embd\.zmodel.embed_tokens.z	^output\.zlm_head.ú^blk\.zmodel.layers.z
\.attn_q\.z.self_attn.q_proj.z
\.attn_k\.z.self_attn.k_proj.z
\.attn_v\.z.self_attn.v_proj.z\.attn_output\.z.self_attn.o_proj.z\.ffn_gate\.z.mlp.gate_proj.z
\.ffn_up\.z.mlp.up_proj.z\.ffn_down\.z.mlp.down_proj.Úreturnc                 óþ  — |                       ¦   «         }|j        }|j        |z  }|j        }d|j        z  |z  }||f}t          g |¢|‘R Ž }t          |Ž }t          d|j        › d�d¦  «        g}	|	t          z   t          dd¦  «        t          dd¦  «        t          d	d
¦  «        t          dd¦  «        t          dd¦  «        t          dd¦  «        t          dd¦  «        t          dd¦  «        t          dd¦  «        g	z   }
t          ddt          ¦   «         g¬¦  «        t          ddt          ¦   «         g¬¦  «        t          ddt          ¦   «         g¬¦  «        t          ddt          ¦   «         g¬¦  «        t          d d!t          ¦   «         g¬¦  «        g}t          d"d"t          ¦   «         |g¬¦  «        t          d#d#|g¬¦  «        t          d$d$|g¬¦  «        t          d%d%|g¬¦  «        g}t          d&d&|g¬¦  «        t          d'd't          g |¢|‘R d(|iŽg¬¦  «        t          d)d)t          g |¢|‘R d(|iŽt          d*¦  «        g¬¦  «        t          d+d+t          g |¢|‘R Ž g¬¦  «        g}|
|z   |z   |z   S ),aý  Qwen3.5: hybrid GatedDeltaNet linear attention + full attention every fourth layer.

    llama.cpp's converter differs in five ways, each undone below:

    1. Names: `blk.N.*` with ggml leaf names.
    2. Zero-centred norms stored as `w + 1`, except `ssm_norm` (`SubtractOne`, in fp32).
    3. `ssm_a` holds `-exp(A_log)` (`LogNegate`).
    4. `conv1d` is squeezed to 2D (`Unsqueeze`).
    5. Value heads are tiled rather than grouped, on every v-indexed tensor: `PermuteRows` where the
       tensor produces the value dimension, `PermuteInputFeatures` for the one that consumes it.

    Only (5)'s column permute crosses quantization blocks, so `out_proj` is the one tensor that has
    to be dequantized; everything else stays packed or is F32 in the file.
    é   r   z\.zmtp.z\.attn_qkv\.z.linear_attn.in_proj_qkv.z\.attn_gate\.z.linear_attn.in_proj_z.z\.ssm_alpha\.z.linear_attn.in_proj_a.z\.ssm_beta\.z.linear_attn.in_proj_b.z\.ssm_conv1d\.z.linear_attn.conv1d.z\.ssm_norm\.z.linear_attn.norm.z\.ssm_out\.z.linear_attn.out_proj.z\.ssm_a$z.linear_attn.A_logz\.ssm_dt\.bias$z.linear_attn.dt_biasz^output_norm\.weightzmodel.norm.weight)Úsource_patternsÚtarget_patternsÚ
operationsz\.attn_norm\.weightz.input_layernorm.weightz\.post_attention_norm\.weightz .post_attention_layernorm.weightz\.attn_q_norm\.weightz.self_attn.q_norm.weightz\.attn_k_norm\.weightz.self_attn.k_norm.weightzlinear_attn.A_logzlinear_attn.dt_biaszlinear_attn.in_proj_a.weightzlinear_attn.in_proj_b.weightzlinear_attn.in_proj_z.weightzlinear_attn.in_proj_qkv.weightÚoffsetzlinear_attn.conv1d.weightr   zlinear_attn.out_proj.weight)Úget_text_configÚlinear_num_key_headsÚlinear_num_value_headsÚlinear_value_head_dimÚlinear_key_head_dimÚTiledToGroupedRowsr   Únum_hidden_layersÚDENSE_DECODER_RENAMINGSr   ÚSubtractOneÚ	LogNegateÚ	UnsqueezeÚTiledToGroupedInputs)ÚconfigÚtext_configÚnum_key_headsÚvalue_heads_per_key_headÚvalue_head_dimÚquery_key_rowsÚheadsÚ	per_valueÚper_headÚ	mtp_blockÚ	renamingsÚoffset_normsÚper_value_headÚvalue_reorders                 ú†/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/transformers/integrations/gguf/gguf_conversion_mapping.pyÚ_qwen35r.   +   sk  € ð ×(Ò(Ñ*Ô*€KØÔ4€MØ*ÔAÀ]ÑRÐØ Ô6€Nð ˜Ô8Ñ8¸=ÑH€Nð Ð4Ð5€EÝ"Ð: EÐ:¨>Ð:Ð:Ð:€IÝ! 5Ð)€Hõ
  Ð K¨+Ô*GÐ KÐ KÐ KÈVÑTÔTÐU€Ið 	Ý
!ñ	"õ ˜?Ð,GÑHÔHÝÐ+Ð-FÑGÔGÝÐ+Ð-FÑGÔGÝ˜?Ð,EÑFÔFÝÐ,Ð.DÑEÔEÝ˜?Ð,@ÑAÔAÝ˜>Ð+CÑDÔDÝ˜;Ð(<Ñ=Ô=ÝÐ-Ð/EÑFÔFð

ñ	
ð õ$ 	Ø3Ø/Ý#™œ�ð	
ñ 	
ô 	
õ
 	Ø2Ø5Ý#™œ�ð	
ñ 	
ô 	
õ
 	Ø<Ø>Ý#™œ�ð	
ñ 	
ô 	
õ
 	Ø4Ø6Ý#™œ�ð	
ñ 	
ô 	
õ
 	Ø4Ø6Ý#™œ�ð	
ñ 	
ô 	
ð+€Lõ< 	Ø/Ø/Ý!™œ XÐ.ð	
ñ 	
ô 	
õ
 	Ø1Ø1Ø �zð	
ñ 	
ô 	
õ
 	Ø:Ø:Ø �zð	
ñ 	
ô 	
õ
 	Ø:Ø:Ø �zð	
ñ 	
ô 	
ð!€Nõ2 	Ø:Ø:Ø!�{ð	
ñ 	
ô 	
õ
 	Ø<Ø<Ý*ÐY¨EÐY°>ÐYÐYÐYÈ.ÐYÐYÐZð	
ñ 	
ô 	
õ
 	Ø7Ø7Ý*ÐY¨EÐY°>ÐYÐYÐYÈ.ÐYÐYÕ[dÐefÑ[gÔ[gÐhð	
ñ 	
ô 	
õ 	Ø9Ø9Ý,ÐD¨eÐD°^ÐDÐDÐDÐEð	
ñ 	
ô 	
ð%€Mð2 �|Ñ# nÑ4°}ÑDÐDó    Úqwen35c                   óž   — e Zd ZdZddefd„Zej        dee	ej
        f         dee	         dee	         dee	ej
        f         fd	„¦   «         Zd
S )r   z?Undo llama.cpp storing zero-centred RMSNorm weights as `w + 1`.ç      ð?r   c                 ó   — || _         d S ©N©r   )Úselfr   s     r-   Ú__init__zSubtractOne.__init__·   s   € ØˆŒˆˆr/   Ú
input_dictr   r   r   c                 ó˜   — t          |¦  «        }|d         |                     ¦   «         | j        z
                       |j        ¦  «        iS ©Nr   )Ú_single_tensorÚfloatr   ÚtoÚdtype©r6   r8   r   r   ÚkwargsÚtensors         r-   ÚconvertzSubtractOne.convertº   s@   € õ   
Ñ+Ô+ˆØ Ô" V§\¢\¡^¤^°d´kÑ%A×$EÒ$EÀfÄlÑ$SÔ$SÐTÐTr/   N)r2   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r<   r7   ÚtorchÚno_gradÚdictÚstrÚTensorÚlistrB   © r/   r-   r   r   ´   s¨   € € € € € ØIÐIðð ˜uð ð ð ð ð „]ðUØ˜s E¤LÐ0Ô1ðUØDHÈÄIðUØ`dÐehÔ`iðUà	ˆc�5”<ÐÔ	 ðUð Uð Uñ „]ðUð Uð Ur/   r   c                   ó�   — e Zd ZdZej        deeej        f         de	e         de	e         deeej        f         fd„¦   «         Z
dS )r   zC`A_log = log(-a)`, undoing llama.cpp storing `ssm_a = -exp(A_log)`.r8   r   r   r   c                 ó®   — t          |¦  «        }|d         t          j        |                     ¦   «          ¦  «                             |j        ¦  «        iS r:   )r;   rG   Úlogr<   r=   r>   r?   s         r-   rB   zLogNegate.convertÅ   sE   € õ   
Ñ+Ô+ˆØ Ô"¥E¤I¨v¯|ª|©~¬~¨oÑ$>Ô$>×$AÒ$AÀ&Ä,Ñ$OÔ$OÐPÐPr/   N)rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rB   rM   r/   r-   r   r   Â   s†   € € € € € ØMÐMà
„]ðQØ˜s E¤LÐ0Ô1ðQØDHÈÄIðQØ`dÐehÔ`iðQà	ˆc�5”<ÐÔ	 ðQð Qð Qñ „]ðQð Qð Qr/   r   c                   óœ   — e Zd ZdZdefd„Zej        dee	ej
        f         dee	         dee	         dee	ej
        f         fd„¦   «         Zd	S )
r   zTAdd a size-1 dim, undoing llama.cpp squeezing `conv1d` from `(C, 1, K)` to `(C, K)`.Údimc                 ó   — || _         d S r4   ©rR   )r6   rR   s     r-   r7   zUnsqueeze.__init__Ð   s   € ØˆŒˆˆr/   r8   r   r   r   c                 ód   — t          |¦  «        }|d         |                     | j        ¦  «        iS r:   )r;   Ú	unsqueezerR   r?   s         r-   rB   zUnsqueeze.convertÓ   s1   € õ   
Ñ+Ô+ˆØ Ô" F×$4Ò$4°T´XÑ$>Ô$>Ð?Ð?r/   N)rC   rD   rE   rF   Úintr7   rG   rH   rI   rJ   rK   rL   rB   rM   r/   r-   r   r   Í   s£   € € € € € Ø^Ð^ð˜Cð ð ð ð ð „]ð@Ø˜s E¤LÐ0Ô1ð@ØDHÈÄIð@Ø`dÐehÔ`ið@à	ˆc�5”<ÐÔ	 ð@ð @ð @ñ „]ð@ð @ð @r/   r   c                   ó°   — e Zd ZdZdZddej        defd„Zej	        de
eej        f         dee         d	ee         d
e
eej        f         fd„¦   «         ZdS )ÚPermuteRowszãReorder rows (dim 0), optionally only those from `offset` onwards.

    `offset` covers tensors whose leading rows must stay put, e.g. Qwen3.5's fused `in_proj_qkv`.
    Safe on packed blocks: a block never spans two rows.
    Tr   Úpermutationr   c                 ó"   — || _         || _        d S r4   )rZ   r   )r6   rZ   r   s      r-   r7   zPermuteRows.__init__ä   s   € Ø&ˆÔØˆŒˆˆr/   r8   r   r   r   c                 ó.  — t          |¦  «        }| j                             |j        ¦  «        }| j        r=|d | j        …         || j        d …         }}t          j        |||         gd¬¦  «        }n||         }|d         |                     ¦   «         iS )Nr   rT   )r;   rZ   r=   Údevicer   rG   ÚcatÚ
contiguous)	r6   r8   r   r   r@   rA   ÚpermÚheadÚtails	            r-   rB   zPermuteRows.convertè   s–   € õ   
Ñ+Ô+ˆØÔ×"Ò" 6¤=Ñ1Ô1ˆØŒ;ð 	"Ø  $¤+ Ô.°°t´{°}°}Ô0E�$ˆDÝ”Y  d¨4¤jÐ1°qÐ9Ñ9Ô9ˆFˆFà˜D”\ˆFØ Ô" F×$5Ò$5Ñ$7Ô$7Ð8Ð8r/   N)r   )rC   rD   rE   rF   Úsupports_packedrG   rK   rW   r7   rH   rI   rJ   rL   rB   rM   r/   r-   rY   rY   Û   s²   € € € € € ðð ð €Oðð  E¤Lð ¸#ð ð ð ð ð „]ð
9Ø˜s E¤LÐ0Ô1ð
9ØDHÈÄIð
9Ø`dÐehÔ`ið
9à	ˆc�5”<ÐÔ	 ð
9ð 
9ð 
9ñ „]ð
9ð 
9ð 
9r/   rY   c                   óÐ   — e Zd ZdZdZdej        fd„Zedej        fd„¦   «         Z	ej
        deeej        f         dee         d	ee         deeej        f         fd
„¦   «         ZdS )ÚPermuteInputFeaturesa´  Reorder columns (dim 1), for a tensor that *consumes* an axis llama.cpp reordered.

    Columns cross quantization blocks, so permuting packed bytes would mean requantizing. It is not
    needed on the weight at all, since `x @ W[:, p].T == x[:, argsort(p)] @ W.T`: a packed weight is
    left as stored and `GgufLinear` gathers its input through `input_permutation` instead. A dense
    tensor still has its columns permuted here.
    TrZ   c                 ó   — || _         d S r4   )rZ   )r6   rZ   s     r-   r7   zPermuteInputFeatures.__init__  s   € Ø&ˆÔÐÐr/   r   c                 ó4   — t          j        | j        ¦  «        S )z¦Reordering for the input of the module holding this weight, when it stays packed.

        The inverse of the column permutation, not the permutation itself.
        )rG   ÚargsortrZ   )r6   s    r-   Úinput_permutationz&PermuteInputFeatures.input_permutation  s   € õ Œ}˜TÔ-Ñ.Ô.Ð.r/   r8   r   r   c                 óè   — t          |¦  «        }|j        t          j        k    r
|d         |iS | j                             |j        ¦  «        }|d         |d d …|f                              ¦   «         iS r:   )r;   r>   rG   Úuint8rZ   r=   r]   r_   )r6   r8   r   r   r@   rA   r`   s          r-   rB   zPermuteInputFeatures.convert  sp   € õ   
Ñ+Ô+ˆØŒ<�5œ;Ò&Ð&à# AÔ&¨Ð/Ð/ØÔ×"Ò" 6¤=Ñ1Ô1ˆØ Ô" F¨1¨1¨1¨d¨7¤O×$>Ò$>Ñ$@Ô$@ÐAÐAr/   N)rC   rD   rE   rF   rc   rG   rK   r7   Úpropertyri   rH   rI   rJ   rL   rB   rM   r/   r-   re   re   ö   sÙ   € € € € € ðð ð €Oð' E¤Lð 'ð 'ð 'ð 'ð ð/ 5¤<ð /ð /ð /ñ „Xð/ð „]ðBØ˜s E¤LÐ0Ô1ðBØDHÈÄIðBØ`dÐehÔ`iðBà	ˆc�5”<ÐÔ	 ðBð Bð Bñ „]ðBð Bð Br/   re   c            	       ó6   ‡ — e Zd ZdZd	dedededefˆ fd„Zˆ xZS )
r   a(  `PermuteRows` undoing llama.cpp's head reorder, for a tensor that *produces* the head axis.

    llama.cpp stores head-indexed axes tiled (`v0k0 v0k1 ... v1k0 ...`), transformers groups them by
    key head (`k0v0 k0v1 k1v0 ...`). `head_dim` defaults to 1, for per-head vectors like `A_log`.
    r   r   Únum_k_headsÚheads_per_kÚhead_dimr   c                 ó.  •— ||z  |z  }t          j        |d¬¦  «        }|                     |||¦  «                             dd¦  «                             d¦  «        }t          j        |¦  «        }t          ¦   «                              ||¬¦  «         d S )NÚcpu©r]   r   r   éÿÿÿÿr5   ©rG   ÚarangeÚreshapeÚ	transposerh   Úsuperr7   )
r6   rn   ro   rp   r   ÚtotalÚindicesÚtiled_from_groupedrZ   Ú	__class__s
            €r-   r7   zTiledToGroupedRows.__init__  s’   ø€ Ø˜kÑ)¨HÑ4ˆõ ”,˜u¨UÐ3Ñ3Ô3ˆØ$Ÿ_š_¨[¸+ÀxÑPÔP×ZÒZÐ[\Ð^_Ñ`Ô`×hÒhÐikÑlÔlÐÝ”mÐ$6Ñ7Ô7ˆÝ‰Œ×Ò˜¨VÐÑ4Ô4Ð4Ð4Ð4r/   )r   r   ©rC   rD   rE   rF   rW   r7   Ú__classcell__©r}   s   @r-   r   r     si   ø€ € € € € ðð ð5ð 5 Cð 5°cð 5ÀSð 5ÐVYð 5ð 5ð 5ð 5ð 5ð 5ð 5ð 5ð 5ð 5r/   r   c                   ó2   ‡ — e Zd ZdZddededefˆ fd„Zˆ xZS )r   zÂ`PermuteInputFeatures` undoing the same reorder, for a tensor that *consumes* the head axis.

    The permutation is the one `TiledToGroupedRows` builds, applied to columns instead of rows.
    r   rn   ro   rp   c                 ó*  •— ||z  |z  }t          j        |d¬¦  «        }|                     |||¦  «                             dd¦  «                             d¦  «        }t          j        |¦  «        }t          ¦   «                              |¦  «         d S )Nrr   rs   r   r   rt   ru   )	r6   rn   ro   rp   rz   r{   r|   rZ   r}   s	           €r-   r7   zTiledToGroupedInputs.__init__/  s�   ø€ Ø˜kÑ)¨HÑ4ˆõ ”,˜u¨UÐ3Ñ3Ô3ˆØ$Ÿ_š_¨[¸+ÀxÑPÔP×ZÒZÐ[\Ð^_Ñ`Ô`×hÒhÐikÑlÔlÐÝ”mÐ$6Ñ7Ô7ˆÝ‰Œ×Ò˜Ñ%Ô%Ð%Ð%Ð%r/   )r   r~   r€   s   @r-   r   r   )  sa   ø€ € € € € ðð ð
&ð & Cð &°cð &ÀSð &ð &ð &ð &ð &ð &ð &ð &ð &ð &r/   r   c                   ó¦   — e Zd ZdZdd„Zej        	 ddeeej	        f         de
e         de
e         d	edz  d
eeej	        f         f
d„¦   «         ZdS )ÚCasta{  Cast to the model's dtype, after every other transform has run.

    Last, not first: llama.cpp stores values this path does arithmetic on (`w + 1` norms, `-exp(A_log)`),
    and rounding those to bf16 before the arithmetic would spend the precision near 1.0. Blocks pass
    through untouched. The loader skips this itself for a pre-quantized checkpoint under renamed keys.
    r>   útorch.dtypec                 ó   — || _         d S r4   )r>   )r6   r>   s     r-   r7   zCast.__init__A  s   € ØˆŒ
ˆ
ˆ
r/   Nr8   r   r   Úfull_layer_namer   c                 ó¬   — t          |¦  «        }|�|n|d         }|j        t          j        | j        fv r||iS ||                     | j        ¦  «        iS r:   )r;   r>   rG   rk   r=   )r6   r8   r   r   r‡   r@   rA   Únames           r-   rB   zCast.convertD  s^   € õ   
Ñ+Ô+ˆØ"1Ð"=ˆˆÀ?ÐSTÔCUˆØŒ<�EœK¨¬Ð4Ð4Ð4Ø˜&�>Ð!Ø�f—i’i ¤
Ñ+Ô+Ð,Ð,r/   )r>   r…   r4   )rC   rD   rE   rF   r7   rG   rH   rI   rJ   rK   rL   rB   rM   r/   r-   r„   r„   9  s²   € € € € € ðð ðð ð ð ð „]ð '+ð-ð -à˜˜eœlÐ*Ô+ð-ð ˜cœð-ð ˜cœð	-ð
 ˜t™ð-ð 
ˆc�5”<ÐÔ	 ð-ð -ð -ñ „]ð-ð -ð -r/   r„   c                   ó¾   — e Zd ZdZdeeef         ddfd„Zej	        	 ddeeej
        f         dee         d	ee         d
edz  deeej
        f         f
d„¦   «         ZdS )Ú
DequantizeaA  Unpack GGUF blocks into values, on the parameter's own device.

    First in its chain, since every later transform is defined on dense values. One instance serves the
    whole file: llama.cpp mixes quantization types, so the type is looked up per parameter, and a
    parameter that is not listed keeps its blocks.
    Ú
ggml_typesr>   r…   c                 ó"   — || _         || _        d S r4   )rŒ   r>   )r6   rŒ   r>   s      r-   r7   zDequantize.__init__\  s   € Ø$ˆŒØˆŒ
ˆ
ˆ
r/   Nr8   r   r   r‡   r   c                 óð   — | j                              |¦  «        }|€|S t          |¦  «        }t          |         \  }}	|j        d         |j        d         |	z  |z  }}
|t          |||
|| j        ¦  «        iS )Nr   r   )rŒ   Úgetr;   r	   Úshaper
   r>   )r6   r8   r   r   r‡   r@   Ú	ggml_typeÚblocksÚblock_elementsÚblock_bytesÚrowsÚcolss               r-   rB   zDequantize.convert`  s€   € ð ”O×'Ò'¨Ñ8Ô8ˆ	ØÐØÐÝ 
Ñ+Ô+ˆÝ&0°Ô&;Ñ#ˆ˜Ø”\ !”_ f¤l°1¤o¸Ñ&DÀ~Ñ&UˆdˆØÕ!2°6¸9ÀdÈDÐRVÔR\Ñ!]Ô!]Ð^Ð^r/   r4   )rC   rD   rE   rF   rI   rJ   rW   r7   rG   rH   rK   rL   rB   rM   r/   r-   r‹   r‹   T  sÔ   € € € € € ðð ð 4¨¨S¨¤>ð ¸-ð ð ð ð ð „]ð '+ð_ð _à˜˜eœlÐ*Ô+ð_ð ˜cœð_ð ˜cœð	_ð
 ˜t™ð_ð 
ˆc�5”<ÐÔ	 ð_ð _ð _ñ „]ð_ð _ð _r/   r‹   r8   c                 ó   — t          | ¦  «        dk    rt          dt          | ¦  «        › �¦  «        ‚t          t	          |                      ¦   «         ¦  «        ¦  «        }t          |t          ¦  «        r|d         n|S )zIThese ops are all one-to-one; unwrap the single (possibly listed) tensor.r   z%expected a single source tensor, got r   )ÚlenÚ
ValueErrorrL   ÚnextÚiterÚvaluesÚ
isinstance)r8   Útensorss     r-   r;   r;   r  sp   € å
ˆ:�„˜!ÒÐÝÐSÅÀjÑAQÔAQÐSÐSÑTÔTÐTÝ•4˜
×)Ò)Ñ+Ô+Ñ,Ô,Ñ-Ô-€GÝ# G­TÑ2Ô2Ð?ˆ7�1Œ:ˆ:¸Ð?r/   )rF   rG   Úcore_model_loadingr   r   r   r   Údequantr	   Úkernelsr
   r   rL   r.   Ú
GGUF_ARCHSr   r   r   rY   re   r   r   r„   r‹   rI   rJ   rK   r;   rM   r/   r-   ú<module>r£      s*  ððð ð €€€à aÐ aÐ aÐ aÐ aÐ aÐ aÐ aÐ aÐ aÐ aÐ aØ Ð Ð Ð Ð Ð Ø &Ð &Ð &Ð &Ð &Ð &ð €NÐ#Ð%:Ñ;Ô;Ø€N�< Ñ,Ô,Ø€N�9˜oÑ.Ô.Ø€N�=Ð"6Ñ7Ô7Ø€N�=Ð"6Ñ7Ô7Ø€N�=Ð"6Ñ7Ô7Ø€NÐ%Ð';Ñ<Ô<Ø€N�?Ð$5Ñ6Ô6Ø€N�= /Ñ2Ô2Ø€N�?Ð$5Ñ6Ô6ðÐ ð@E�t˜OÔ,ð @Eð @Eð @Eð @EðJ ˆgð€
ð
Uð Uð Uð Uð U�-ñ Uô Uð UðQð Qð Qð Qð Q�ñ Qô Qð Qð@ð @ð @ð @ð @�ñ @ô @ð @ð9ð 9ð 9ð 9ð 9�-ñ 9ô 9ð 9ð6Bð Bð Bð Bð B˜=ñ Bô Bð BðD5ð 5ð 5ð 5ð 5˜ñ 5ô 5ð 5ð"&ð &ð &ð &ð &Ð/ñ &ô &ð &ð -ð -ð -ð -ð -ˆ=ñ -ô -ð -ð6_ð _ð _ð _ð _�ñ _ô _ð _ð<@˜t C¨¬Ð$5Ô6ð @¸5¼<ð @ð @ð @ð @ð @ð @r/   