Ë
    ÓGìj/v  ã                  ó”
  — d dl mZ d dlZd dlZd dlZd dlmZ d dlmZ d dl	Z	d dl
Z
d dl
mZmZmZ d dl
mZ d dlmZmZmZmZ d dlmZ d d	lmZmZmZ 	 d d
lmZ dZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&i Z' e(e«      D � ci c]  }  e) e*e| «      e+«      sŒ e*e| «      | “Œ c} Z, G d„ de«      Z- G d„ de«      Z. G d„ de«      Z/ G d„ de«      Z0ej                  jb                   e	jd                  d«      ej                  jf                   e	jd                  d«      ej                  jh                   e	jd                  d«      ej                  jj                   e	jd                  d«      ej                  jl                  eiZ7ej                  jf                   e	jp                  d e	jr                  ¬ «       e	jp                  d!e	jr                  ¬ «      fej                  jb                   e	jp                  d"e	jt                  ¬ «       e	jp                  d#e	jt                  ¬ «      fej                  jj                   e	jp                  d e	jv                  ¬ «       e	jp                  d$e	jv                  ¬ «      fej                  jh                   e	jp                  d%e	jx                  ¬ «       e	jp                  d&e	jx                  ¬ «      fiZ=ej                  jb                   e	jp                  d'e	jt                  ¬ «       e	jp                  d#e	jt                  ¬ «      fej                  jh                   e	jp                  d(e	jx                  ¬ «       e	jp                  d&e	jx                  ¬ «      fiZ>ej                  jf                   e	jp                  d e	jr                  ¬ «       e	jp                  d#e	jr                  ¬ «      fej                  jb                   e	jp                  d)e	jt                  ¬ «       e	jp                  d*e	jt                  ¬ «      fej                  jj                   e	jp                  d e	jv                  ¬ «       e	jp                  d&e	jv                  ¬ «      fej                  jh                   e	jp                  d+e	jx                  ¬ «       e	jp                  d,e	jx                  ¬ «      fiZ?d-d.œd/„Z@dTd0„ZAdUd1„ZBd2„ ZC	 dVd3„ZDdWd4„ZEdWd5„ZFdXd6„ZG G d7„ d8«      ZH G d9„ d:«      ZI G d;„ d<«      ZJd=„ ZKd>„ ZLd?„ ZMd@„ ZNdYdA„ZOdB„ ZPdZdC„ZQd[dD„ZRd\dE„ZSd]dF„ZTd^dG„ZUd_dH„ZVd^dI„ZWd_dJ„ZXd`dK„ZYdadL„ZZdbdM„Z[dcdN„Z\dcdO„Z]dddP„Z^dddQ„Z_dddR„Z`dddS„Zay# e$ r dZY �Œçw xY wc c} w )eé    )ÚannotationsN)ÚEnum)ÚPath)Ú
ModelProtoÚTensorProtoÚexternal_data_helper)Úonnx_pb)Ú
make_graphÚ
make_modelÚ	make_nodeÚmake_tensor_value_info)ÚReferenceEvaluator)ÚGraphOptimizationLevelÚInferenceSessionÚSessionOptions©Úfloat8e4m3fnzonnx.quantizez0.1.0zai.onnxzcom.microsoftÚQuantizeLinearÚ_QuantizeLinear_InputÚDequantizeLinearÚ_DequantizeLinear_OutputÚ
_quantizedc                  ó*   — e Zd ZdZdZd„ Zed„ «       Zy)ÚQuantizationModer   é   c                ó   — | j                   S ©N©Úname©Úselfs    úhC:\Users\Stabi\Downloads\virtual-tryon(1)\venv\Lib\site-packages\onnxruntime/quantization/quant_utils.pyÚ__str__zQuantizationMode.__str__4   ó   € Ø�y‰yÐó    c                óD   — 	 t         |    S # t        $ r t        «       ‚w xY wr   )r   ÚKeyErrorÚ
ValueError)Úmodes    r"   Úfrom_stringzQuantizationMode.from_string7   s)   € ð	Ü# DÑ)Ð)øÜò 	Ü“,Ðð	úó   ‚ ‹N)Ú__name__Ú
__module__Ú__qualname__Ú
IntegerOpsÚ
QLinearOpsr#   Ústaticmethodr*   © r%   r"   r   r   0   s%   „ Ø€JØ€Jòð ñó ñr%   r   c                  ó*   — e Zd ZdZdZd„ Zed„ «       Zy)ÚQuantizedValueTyper   r   c                ó   — | j                   S r   r   r    s    r"   r#   zQuantizedValueType.__str__C   r$   r%   c                óD   — 	 t         |    S # t        $ r t        «       ‚w xY wr   )r4   r'   r(   )Úvs    r"   r*   zQuantizedValueType.from_stringF   s)   € ð	Ü% aÑ(Ð(øÜò 	Ü“,Ðð	úr+   N)r,   r-   r.   ÚInputÚInitializerr#   r1   r*   r2   r%   r"   r4   r4   ?   s%   „ Ø€EØ€Kòð ñó ñr%   r4   c                  óF   — e Zd ZdZdZdZdZdZd„ Ze	d„ «       Z
ed„ «       Zy	)
Ú	QuantTyper   r   é   é   é   c                ó   — | j                   S r   r   r    s    r"   r#   zQuantType.__str__U   r$   r%   c                óD   — 	 t         |    S # t        $ r t        «       ‚w xY wr   )r;   r'   r(   )Úts    r"   r*   zQuantType.from_stringX   s(   € ð	Ü˜Q‘<ÐøÜò 	Ü“,Ðð	úr+   c                ó~  — | t         j                  k(  rt        j                  S | t         j                  k(  rt        j
                  S | t         j                  k(  rt        j                  S | t         j                  k(  rt        j                  S | t         j                  k(  rt        j                  S t        d| ›d�«      ‚)NzUnexpected value qtype=Ú.)r;   ÚQInt8r   ÚINT8ÚQUInt8ÚUINT8ÚQUInt16ÚUINT16ÚQInt16ÚINT16ÚQFLOAT8E4M3FNÚFLOAT8E4M3FNr(   r    s    r"   Útensor_typezQuantType.tensor_type_   s—   € à”9—?‘?Ò"Ü×#Ñ#Ð#Ø”9×#Ñ#Ò#Ü×$Ñ$Ð$Ø”9×$Ñ$Ò$Ü×%Ñ%Ð%Ø”9×#Ñ#Ò#Ü×$Ñ$Ð$Ø”9×*Ñ*Ò*Ü×+Ñ+Ð+ÜÐ2°4°(¸!Ð<Ó=Ð=r%   N)r,   r-   r.   rD   rF   rL   rJ   rH   r#   r1   r*   ÚpropertyrN   r2   r%   r"   r;   r;   N   sH   „ Ø€EØ€FØ€MØ€FØ€Gòð ñó ðð ñ>ó ñ>r%   r;   c                  ó*   — e Zd ZdZdZd„ Zed„ «       Zy)ÚQuantFormatr   r   c                ó   — | j                   S r   r   r    s    r"   r#   zQuantFormat.__str__r   r$   r%   c                óD   — 	 t         |    S # t        $ r t        «       ‚w xY wr   )rQ   r'   r(   )Úformats    r"   r*   zQuantFormat.from_stringu   s)   € ð	Ü˜vÑ&Ð&øÜò 	Ü“,Ðð	úr+   N)r,   r-   r.   Ú	QOperatorÚQDQr#   r1   r*   r2   r%   r"   rQ   rQ   n   s%   „ Ø€IØ
€Còð ñó ñr%   rQ   Úint8Úuint8Úint16Úuint16©Údtypeéÿ   i€ÿÿÿé   iÿÿ  i €ÿÿiÿ  i�ÿÿÿi€ÿÿiÀÿÿÿé@   i Àÿÿi @  éÿÿÿÿ©Úzero_point_indexc                ó@  — g }t        |«      D ]ñ  \  }}t        j                  t        |«      t        j                  «      r%|j                  t        j                  |«      «       n=t        |t        j                  «      r|j                  |«       nt        d|› d|› �«      ‚|| k(  sŒ›|d   }|j                  t        j                  k(  s|j                  t        j                  k(  sŒÛt        d|j                  › �«      ‚ t        |«      dkD  rt        |«      S |d   S )Nzarg z is not an array: r`   zzero_point cannot be r   r   )Ú	enumerateÚnumpyÚ
issubdtypeÚtypeÚnumberÚappendÚarrayÚ
isinstanceÚndarrayÚ	TypeErrorr\   Úfloat32Úfloat16ÚlenÚtuple)rb   ÚargsÚnew_argsÚiÚar7   s         r"   Ú_check_typerv   ™   sà   € Ø€HÜ˜$–‰ˆˆ1Ü×ÑœD ›G¤U§\¡\Ô2Ø�O‰OœEŸK™K¨›NÕ+Ü˜œ5Ÿ=™=Ô)Ø�O‰O˜AÕä˜d 1 #Ð%7¸°sÐ;Ó<Ð<ØÐ Ó Ø˜‘ˆAØ�w‰wœ%Ÿ-™-Ò'¨1¯7©7´e·m±mÓ+CÜÐ"7¸¿¹°yÐ AÓBÐBð  ô " (›m¨aÒ/Œ5�‹?Ð@°X¸a±[Ð@r%   c                ó¾  — | t         v sJ d| › d�«       ‚| t        j                  j                  t        j                  j                  t        j                  j
                  t        j                  j                  fv �r/|dk7  rt        d|›d�«      ‚|j                  t        j                  k(  rt        j                  }nG|j                  t        j                  k(  rt        j                  }nt        d|j                  › d�«      ‚t        t!        t#        dg dgt$        j&                  j)                  d| g dg«      ¬	«      t#        d
g d¢dg«      gdt+        d|d «      t+        d|d «      gt+        d| d «      g«      «      }t-        |«      }t/        |j1                  d ||dœ«      d   «      S t         |    }	t3        | dd¬«      \  }
}|�t5        |
|«      n|
}|�t7        ||«      n|}t        j8                  |j;                  t        j                  «      |z  j=                  «       |z   «      }t        j>                  ||||¬«       t/        |j;                  |	«      «      S )NúUnexpected data type ú> requested. Only INT8, UINT8, INT16, and UINT16 are supported.r   z2zero_point is expected to be null for float 8 not rC   zUnexpected dtype ÚConstantÚ
zero_point)Úvaluer   )ÚXÚscaler{   ÚYÚqur}   r~   )r}   r~   FT)Úreduce_rangeÚ	symmetric)Úout) ÚONNX_TYPE_TO_NP_TYPEÚ
onnx_protor   rM   ÚFLOAT8E4M3FNUZÚ
FLOAT8E5M2ÚFLOAT8E5M2FNUZÚNotImplementedErrorr\   re   rn   ÚFLOATro   ÚFLOAT16r(   r   r
   r   ÚonnxÚhelperÚmake_tensorr   r   rv   ÚrunÚget_qmin_qmax_for_qTypeÚmaxÚminÚasarrayÚastypeÚroundÚclip)ÚqTypeÚarrr~   r{   ÚlowÚhighÚ	onnx_typeÚ
onnx_modelÚrefr\   ÚqminÚqmaxÚcliplowÚcliphighÚarr_fp32s                  r"   Úquantize_nparrayr£   ©   s+  € àÔ%Ñ%ðeà	˜u˜gÐ%cÐdóeØ%àÜ×Ñ×+Ñ+Ü×Ñ×-Ñ-Ü×Ñ×)Ñ)Ü×Ñ×-Ñ-ð	ò ð ˜Š?Ü%Ð(ZÐ[eÐZhÐhiÐ&jÓkÐkØ�9‰9œŸ™Ò%Ü#×)Ñ)‰IØ�Y‰Yœ%Ÿ-™-Ò'Ü#×+Ñ+‰IäÐ0°·±°¸1Ð=Ó>Ð>ÜÜäØ" B¨¨¼d¿k¹k×>UÑ>UÐVbÐdiÐkmÐpqÐorÓ>sôô Ð.Ò0LÈsÈeÓTð	ð ä*¨3°	¸4Ó@Ü*¨7°I¸tÓDðô (¨¨U°DÓ9Ð:óó
ˆ
ô  ! Ó,ˆÜ˜3Ÿ7™7 4¨s¸UÑ)CÓDÀQÑGÓHÐHä$ UÑ+ˆÜ.¨uÀ5ÐTXÔY‰ˆˆtà$' O”#�d˜C”.¸ˆØ&*Ð&6”3�t˜T”?¸DˆÜ—=‘= #§*¡*¬U¯]©]Ó";¸eÑ"C×!JÑ!JÓ!LÈzÑ!YÓZˆÜ�
‰
�8˜W h°HÕ=Ü˜8Ÿ?™?¨5Ó1Ó2Ð2r%   c           	     ó^  — |dkD  s|dk  rt        d|› d|› �«      ‚t        j                  | t        j                  d| j                  ¬«      «      } t        j
                  |t        j                  d|j                  ¬«      «      }|�t        || |z   «      }|rBt        j
                  t        j                  | «      t        j                  |«      «      }| } |­}||k  sJ d| › d|› �«       ‚t        j                  || z
  t        j                  ¬«      }t        j                  |t        j                  ¬«      t        j                  |t        j                  ¬«      z
  }t        j                  ||z  «      }	|	dk\  sJ d«       ‚|	t        j                  |j                  «      j                  k  rFt        j                  d|j                  ¬«      }	t        j                  d|j                  ¬«      }
|
|	gS |r^t        j                  t        j                  ||z   t        j                  d	t        j                  ¬«      z  «      |j                  ¬«      }
n:t        j                  t        j                  || |	z  z
  «      |j                  ¬«      }
|	j                  |j                  «      }	|
|	gS )
aè  Calculate the scale s and zero point z for the quantization relation
    r = s(q-z), where r are the original values and q are the corresponding
    quantized values.

    r and z are calculated such that every value within [rmin,rmax] has an
    approximate representation within [qmin,qmax]. In addition, qmin <= z <=
    qmax is enforced. If the symmetric flag is set to True, the interval
    [rmin,rmax] is symmetrized to [-absmax, +absmax], where
    absmax = max(abs(rmin), abs(rmax)).

    :parameter rmin: minimum value of r
    :parameter rmax: maximum value of r
    :parameter qmin: minimum value representable by the target quantization data type
    :parameter qmax: maximum value representable by the target quantization data type
    :parameter symmetric: True if the floating-point range should be made symmetric. Defaults to False.
    :parameter min_real_range: Minimum floating-point range (i.e., rmax - rmin) to enforce. Defaults to None.
    :return: zero and scale [z, s]

    r   úBqmin and qmax must meet requirement: qmin <= 0 <= qmax while qmin:ú, qmmax:r[   zqmin=z > qmax=z
scale isseç      ð?g       @)r(   re   Úminimumrj   r\   Úmaximumr‘   ÚabsÚfloat64ÚfinfoÚtinyr•   r”   )ÚrminÚrmaxrž   rŸ   r‚   Úmin_real_rangeÚabsmaxÚdrÚdqr~   r{   s              r"   Úcompute_scale_zpr´   Ø   s  € ð( ˆa‚x�4˜!’8ÜÐ]Ð^bÐ]cÐckÐlpÐkqÐrÓsÐsô
 �=‰=˜œuŸ{™{¨1°D·J±JÔ?Ó@€DÜ�=‰=˜œuŸ{™{¨1°D·J±JÔ?Ó@€Dð Ð!Ü�4˜ Ñ.Ó/ˆáÜ—‘œuŸy™y¨›´·	±	¸$³Ó@ˆØˆwˆØˆwˆà�4Š<Ð5˜5   h¨t¨fÐ5Ó5ˆ<Ü	�‰�T˜D‘[¬¯©Ô	6€BÜ	�‰�T¤§¡Ô	/´%·+±+¸dÌ%Ï-É-Ô2XÑ	X€BÜ�K‰K˜˜R™Ó €EØ�AŠ:Ð#�|Ó#ˆ:ØŒu�{‰{˜4Ÿ:™:Ó&×+Ñ+Ò+Ü—‘˜C t§z¡zÔ2ˆÜ—[‘[ ¨$¯*©*Ô5ˆ
ð ˜ÐÐñ ô Ÿ™Ü—‘˜T D™[¬E¯K©K¸Ä5Ç=Á=Ô,QÑQÓRÐZ^×ZdÑZdô‰Jô Ÿ™¤U§[¡[°¸¸u¹Ñ1DÓ%EÈTÏZÉZÔXˆJØ—‘˜TŸZ™ZÓ(ˆà˜ÐÐr%   c                ó¨  — d}| t         vr¸| t        j                  k(  rŒddlm} ddlm} |}t        d«      D �cg c]
  } ||«      ‘Œ }}t        j                  |D �cg c]0  }t        j                  |«      rŒt        j                  |«      rŒ/|‘Œ2 c}t        j                  ¬«      }nt        d| › d�«      ‚|t         | <   n| t        j                  k(  rddlm} |}|€t        d	| › d
�«      ‚t        j                  t         |    «      }	t        j                  d|¬«      }
t        j                  ||	z  |j                   ¬«      }|
|gS c c}w c c}w )ar  Calculate the scale s for a float8 type (E4M3FN).
    The function assumes the coefficient distribution and the float 8
    distribution are similar to two gaussian laws.

    :return: zero and scale [z, s]

    More details in notebook `quantization_fp8.ipynb
    <https://github.com/microsoft/onnxruntime/blob/main/docs/python/notebooks/quantization_fp8.ipynb>`_.
    Nr   )Úfloat8e4m3_to_float32r   é   r[   zQuantization to element_type=z not implemented.zUnexpected element_type rC   )ÚFLOAT8_DISTRIBUTIONSr   rM   Úonnx.numpy_helperr¶   Ú#onnx.reference.custom_element_typesr   Úrangere   rj   ÚisnanÚisinfrn   r(   rm   Ústdr\   )Úelement_typer¾   Úzp_dtyper¶   r   rt   Ú
all_valuesÚfÚvaluesÚstd_f8Úzeror~   s               r"   Úcompute_scale_zp_float8rÆ     s*  € ð €HØÔ/Ñ/Øœ;×3Ñ3Ò3Ý?ÝHà#ˆHÜ<AÀ#¼JÓG¹J°qÑ/°Õ2¸JˆJÐGÜ—[‘[Ù&ÓT™J�q¬e¯k©k¸!­nÄUÇ[Á[ÐQRÅ^’˜JÑTÔ\a×\iÑ\iô‰Fô Ð<¸\¸NÐJ[Ð\Ó]Ð]Ø-3Ô˜\Ò*Ø	œ×1Ñ1Ò	1ÝDàˆàÐÜÐ2°<°.ÀÐBÓCÐCÜ�Y‰YÔ+¨LÑ9Ó:€FÜ�;‰;�q Ô)€DÜ�K‰K˜˜f™¨C¯I©IÔ6€EØ�%ˆ=Ðùò# HùâTs   ¹E
ÁEÁ8EÂEc                óú  — t        | t        j                  «      st        dt	        | «      › d�«      ‚|�|}nt        | «      r| j                  «       nd}|�|}nt        | «      r| j                  «       nd}t        j                  || j                  ¬«      }t        j                  || j                  ¬«      }d}	t        j                  d| j                  ¬«      }
|t        j                  k(  rñ|rt        d«      ‚t        j                  | «      }t        ||«      \  }	}
t        || |
|	«      }t!        |j#                  t        j$                  «      j'                  «       dz  dk(  «      ret        j(                  | «      }t        d	|j                  «       › d
|j                  «       › d|j                  «       › d
|j                  «       › d�	«      ‚t+        |||	|
|d¬«      S |t        j,                  t        j.                  t        j0                  t        j2                  fv rNt        | «      r$t5        |||¬«      \  }}t7        ||||||«      \  }	}
t        || |
|	«      }t+        |||	|
|d¬«      S t9        d|› d�«      ‚)a¤  
    :param data: data to quantize
    :param qType: data type to quantize to. Supported types UINT8 and INT8
    :param symmetric: whether symmetric quantization is used or not. This is applied to INT8.
    :parameter reduce_range: True if the quantization range should be reduced. Defaults to False.
    :parameter min_real_range: Minimum floating-point range (i.e., rmax - rmin) to enforce. Defaults to None.
    :parameter rmin_override: The value of rmin to use if not None. Otherwise, uses min(data).
    :parameter rmax_override: The value of rmax to use if not None. Otherwise, uses max(data).
    :return: minimum, maximum, zero point, scale, and quantized weights

    To pack weights, we compute a linear transformation

    - when data `type == uint8` mode, from `[rmin, rmax]` -> :math:`[0, 2^{b-1}]` and
    - when data `type == int8`, from `[-m , m]` -> :math:`[-(2^{b-1}-1), 2^{b-1}-1]` where
        `m = max(abs(rmin), abs(rmax))`

    and add necessary intermediate nodes to trasnform quantized weight to full weight using the equation

    :math:`r = S(q-z)`, where

    - *r*: real original value
    - *q*: quantized value
    - *S*: scale
    - *z*: zero point
    z%Weight must be given as an array not rC   g        r[   r   r§   z1Unsupported option reduce_range=True for float 8.r^   z+One of the quantized value is NaN data in [z, z], quantized_data in [z].r<   ra   ©r‚   zUnexpected value for qType=)rk   re   rl   rm   rg   rp   r’   r‘   rj   r\   r   rM   ÚRuntimeErrorr¾   rÆ   r£   Úanyr”   rX   Úravelr“   rv   rE   rG   rK   rI   r�   r´   r(   )Údatar—   r‚   r�   r°   Úrmin_overrideÚrmax_overrider®   r¯   r{   r~   r¾   Úquantized_dataÚnp_datarž   rŸ   s                   r"   Úquantize_datarÑ   <  s/  € ô8 �dœEŸM™MÔ*ÜÐ?ÄÀTÃ
¸|È1ÐMÓNÐNØÐ Ø‰ä  œYˆt�x‰xŒz¨CˆàÐ Ø‰ä  œYˆt�x‰xŒz¨Cˆä�;‰;�t 4§:¡:Ô.€DÜ�;‰;�t 4§:¡:Ô.€DØ€JÜ�K‰K˜ 4§:¡:Ô.€Eà”×(Ñ(Ò(ÙÜÐRÓSÐSÜ�i‰i˜‹oˆÜ3°E¸3Ó?Ñˆ
�EÜ)¨%°°u¸jÓIˆÜ�×%Ñ%¤e§k¡kÓ2×8Ñ8Ó:¸SÑ@ÀSÑHÔIÜ—m‘m DÓ)ˆGÜØ=¸g¿k¹k»m¸_ÈBÈwÏ{É{Ë}Èoð ^&Ø&4×&8Ñ&8Ó&:Ð%;¸2¸n×>PÑ>PÓ>RÐ=SÐSUðWóð ô ˜4  z°5¸.Ð[\Ô]Ð]à”×!Ñ!¤;×#4Ñ#4´k×6GÑ6GÌ×I[ÑI[Ð\Ñ\ÜˆtŒ9Ü0°¸ÐPYÔZ‰JˆD�$Ü 0°°t¸TÀ4ÈÐTbÓ cÑˆJ˜Ü)¨%°°u¸jÓIˆÜ˜4  z°5¸.Ð[\Ô]Ð]ä
Ð2°5°'¸Ð;Ó
<Ð<r%   c                ój  — | t         j                  j                  k(  rt        d«      ‚d}|rt        j                  | «      }n)|r| t        v r
t        |    }nt        j                  | «      }|st        d| › d�«      ‚|\  }}|dkD  s|dk  r't        d|› d|› d|j                  › d	|› d
|› d| › �«      ‚|S )zÍ
    Return qmin and qmax, the minimum and maximum value representable by the given qType
    :parameter qType: onnx.onnx_pb.TensorProto.UINT8 or onnx.onnx_pb.TensorProto.UINT8
    :return: qmin, qmax
    z;This function is not implemented for float 8 as not needed.Nrx   ry   r   r¥   r¦   z, dtype=z, reduce_range=z, symmetric=z, qType=)
r…   r   rM   r‰   ÚONNX_INT_TYPE_REDUCED_RANGEÚgetÚONNX_INT_TYPE_SYMMETRIC_RANGEÚONNX_INT_TYPE_RANGEr(   r\   )r—   r�   r‚   Úqrangerž   rŸ   s         r"   r�   r�   �  sÚ   € ð ”
×&Ñ&×3Ñ3Ò3Ü!Ð"_Ó`Ð`à€FáÜ,×0Ñ0°Ó7‰Ù	�uÔ =Ñ=Ü.¨uÑ5‰ä$×(Ñ(¨Ó/ˆáÜÐ0°°Ð7uÐvÓwÐwà�J€Dˆ$Øˆa‚x�4˜!’8ÜðØ�6˜ $  x°·
±
¨|¸?È<È.ð YØ"˜ 8¨E¨7ð4ó
ð 	
ð €Mr%   c                ó.   — t        | ||¬«      \  }}||z
  S )z“
    Helper function to get the quantization range for a type.
        parameter qType: quantization type.
        return: quantization range.
    rÈ   )r�   )r—   r�   r‚   rž   rŸ   s        r"   Úget_qrange_for_qTyperÙ   ¡  s    € ô )¨°È	ÔR�J€Dˆ$Ø�$‰;Ðr%   c                ó:   — | dk  r| |z   n| }|dk\  xr ||k  }||fS )zç
    Helper function that tries to return a normalized axis in the range [0, rank - 1].
    :parameter axis: The axis to normalize.
    :parameter rank: The tensor rank (number of dimensions).
    :return (is_valid, axis_norm)
    r   r2   )ÚaxisÚrankÚ	axis_normÚis_valids       r"   Únormalize_axisrß   «  s3   € ð  $ ašx��t’¨T€IØ˜A‰~Ò2 )¨dÑ"2€HØ�YÐÐr%   c                  ó   — e Zd ZdZg g dfd„Zy)ÚQuantizedInitializerzJ
    Represents a linearly quantized weight input from ONNX operators
    Nc
                ó‚   — || _         || _        || _        || _        || _        || _        || _        || _        |	| _        y r   )	r   ÚinitializerÚrminsÚrmaxsÚzero_pointsÚscalesrÌ   rÏ   rÛ   )
r!   r   rã   rä   rå   ræ   rç   rÌ   rÏ   rÛ   s
             r"   Ú__init__zQuantizedInitializer.__init__¼  sF   € ð ˆŒ	Ø&ˆÔØˆŒ
ØˆŒ
à&ˆÔØˆŒØˆŒ	Ø,ˆÔàˆ�	r%   ©r,   r-   r.   Ú__doc__rè   r2   r%   r"   rá   rá   ·  s   „ ñð ØØôr%   rá   c                  ó    — e Zd ZdZ	 	 	 	 dd„Zy)ÚQuantizedValuezI
    Represents a linearly quantized value (input\output\intializer)
    Nc
                ó‚   — || _         || _        || _        || _        || _        || _        || _        || _        |	| _        y r   )	Úoriginal_nameÚq_nameÚ
scale_nameÚzp_nameÚ
value_typerÛ   Ú	node_typeÚ
node_qtypeÚ
scale_type)
r!   r   Únew_quantized_namerð   Úzero_point_nameÚquantized_value_typerÛ   ró   rô   rõ   s
             r"   rè   zQuantizedValue.__init__Û  sD   € ð "ˆÔØ(ˆŒØ$ˆŒØ&ˆŒØ.ˆŒØˆŒ	Ø"ˆŒØ$ˆŒØ$ˆ�r%   )NNNNré   r2   r%   r"   rì   rì   Ö  s   „ ñð ØØØô%r%   rì   c                  ó   — e Zd ZdZd„ Zy)ÚBiasToQuantizez+
    Represents a bias to be quantized
    c                ó.   — || _         || _        || _        y r   )Ú	bias_nameÚ
input_nameÚweight_name)r!   rü   rý   rþ   s       r"   rè   zBiasToQuantize.__init__÷  s   € Ø"ˆŒØ$ˆŒØ&ˆÕr%   Nré   r2   r%   r"   rú   rú   ò  s   „ ñó'r%   rú   c                óî  — | j                   dk(  rt        d| j                  › d�«      ‚| j                   dk(  r| j                  }�n#| j                   dk(  r| j                  }�n| j                   dk(  r| j
                  }nê| j                   dk(  r| j                  }nÎ| j                   dk(  r| j                  }n²| j                   d	k(  r| j                  }n–| j                   d
k(  r| j                  }nz| j                   dk(  r| j                  }n^| j                   dk(  r| j                  }nB| j                   dk(  r| j                  }n&t        d| j                  › d| j                   › d�«      ‚| j                  |iS )zÄ
    Convert attribute to kwarg format for use with onnx.helper.make_node.
        :parameter attribute: attribute in AttributeProto format.
        :return: attribute in {key: value} format.
    r   z
attribute z does not have type specified.r   r<   r=   r>   é   é   é   é   é	   é
   z has unsupported type rC   )rg   r(   r   rÂ   rt   ÚsrA   ÚgÚfloatsÚintsÚstringsÚtensorsÚgraphs)Ú	attributer|   s     r"   Úattribute_to_kwargr  ý  s;  € ð ‡~�~˜ÒÜ˜: i§n¡nÐ%5Ð5SÐTÓUÐUð ‡~�~˜ÒØ—‘ŠØ	�‰˜1Ò	Ø—‘ŠØ	�‰˜1Ò	Ø—‘‰Ø	�‰˜1Ò	Ø—‘‰Ø	�‰˜1Ò	Ø—‘‰Ø	�‰˜1Ò	Ø× Ñ ‰Ø	�‰˜1Ò	Ø—‘‰Ø	�‰˜1Ò	Ø×!Ñ!‰Ø	�‰˜1Ò	Ø×!Ñ!‰Ø	�‰˜2Ò	Ø× Ñ ‰ä˜: i§n¡nÐ%5Ð5KÈIÏNÉNÐK[Ð[\Ð]Ó^Ð^à�N‰N˜EÐ"Ð"r%   c                ót   — |D �cg c]  }|j                   | k(  sŒ|‘Œ }}t        |«      dkD  r|d   S dS c c}w )zÃ
    Helper function to find item by name in a list.
        parameter item_name: name of the item.
        parameter item_list: list of items.
        return: item if found. None otherwise.
    r   N)r   rp   )Ú	item_nameÚ	item_listÚitemÚitemss       r"   Úfind_by_namer  "  sB   € ñ (ÓB™i�d¨4¯9©9¸	Ó+AŠT˜i€EÐBÜ˜5“z A’~ˆ5�‰8Ð/¨4Ð/ùò Cs   …5š5c                óR   — d}t        t        |«      «      D ]  }||   | k(  sŒ|}Œ |S )zC
    Helper function to return index of an item in a node list
    r`   )r»   rp   )Ú	elem_nameÚ	elem_listÚelem_idxrt   s       r"   Úget_elem_indexr  -  s4   € ð €HÜ”3�y“>Ö"ˆØ�Q‰<˜9Ó$Ø‰Hð #ð €Or%   c                óH   — t         j                  j                  d| |g|«      S )zÝ
    Helper function to create a Mul node.
        parameter inputs: list of input names.
        parameter output: output name.
        parameter name: name of the node.
        return: Mul node in NodeProto format.
    ÚMul)rŒ   r�   r   )ÚinputsÚoutputr   s      r"   Úget_mul_noder  8  s!   € ô �;‰;× Ñ  ¨°°¸$Ó?Ð?r%   c                ól   — | j                   j                  | j                  |z   | j                  z   «      S )zp
    Helper function to generate a identifiable filepath by concatenating the given identifier as a suffix.
    )ÚparentÚjoinpathÚstemÚsuffix)ÚfilenameÚ
identifiers     r"   Úgenerate_identified_filenamer&  C  s+   € ð �?‰?×#Ñ# H§M¡M°JÑ$>ÀÇÁÑ$PÓQÐQr%   c                ó`  — dd l }dd lm} dd l} |j                  |j
                  ¬«       t        d«       t        | «       t        d«       t        |«       |j                  | |d¬«       |j                  d«       |j                  d«       |j                  d	«       |j                  «        y )
Nr   )Ú	thresholdz
Histogram:zHistogram Edges:T)ÚfillzTensor valueÚCountszTensor value V.S. Counts)ÚsysÚmatplotlib.pyplotÚpyplotre   Úset_printoptionsÚmaxsizeÚprintÚstairsÚxlabelÚylabelÚtitleÚshow)ÚhistÚ
hist_edgesr+  Úpltre   s        r"   Ú
apply_plotr9  J  s   € Ûå#Ûà€E×Ñ S§[¡[Õ1Ü	ˆ,ÔÜ	ˆ$„KÜ	Ð
ÔÜ	ˆ*ÔØ‡J�Jˆt�Z d€JÔ+Ø‡J�Jˆ~ÔØ‡J�JˆxÔØ‡I�IÐ(Ô)Ø‡H�H…Jr%   c                ó˜  — ddl }ddl}ddlmc mc m} ddlmc mc m} t        j                  d| › �«       t        t        j                  j                  |d«      d«      5 }|j                  |j                  | «      «       ddd«       |j!                  d«      }g }t#        | j%                  «       «      D ]­  }	| |	   }
t'        t)        t+        |
d   «      t+        |
d   «      «      «      }|j-                  |	«      }|j-                  |«      }|j/                  |«       |j1                  ||«       |j3                  ||«       |j5                  |«      }|j7                  |«       Œ¯ |j9                  |t;        |«      «       |D ]  }|j=                  |«       Œ |j?                  «       }|jA                  |«       |jC                  ||«       |jE                  |«      }|jG                  |«       |jI                  «       }t        t        j                  j                  |d«      d	«      5 }|j                  |«       ddd«       t        jJ                  jM                  d
d«      dv r“|j                  jO                  |d«      }|jQ                  «       }tS        |«      D ]Y  }|jU                  |«      }t        j                  |jW                  «       «       t        j                  |jY                  «       «       Œ[ t        t        j                  j                  |d«      d«      5 }t#        | j%                  «       «      D ]\  }	| |	   }|	dz   t'        t)        t+        |d   «      t+        |d   «      «      «      z   }|j                  |«       |j                  d«       Œ^ 	 ddd«       y# 1 sw Y   �Œ$xY w# 1 sw Y   �ŒyxY w# 1 sw Y   yxY w)z>
    Helper function to write calibration table to files.
    r   Nzcalibration cache: zcalibration.jsonÚwi   r   zcalibration.flatbuffersÚwbÚQUANTIZATION_DEBUG)r   Ú1zcalibration.cacheÚ Ú
)-ÚjsonÚflatbuffersÚ5onnxruntime.quantization.CalTableFlatBuffers.KeyValueÚquantizationÚCalTableFlatBuffersÚKeyValueÚ5onnxruntime.quantization.CalTableFlatBuffers.TrtTableÚTrtTableÚloggingÚinfoÚopenÚosÚpathÚjoinÚwriteÚdumpsÚBuilderÚsortedÚkeysÚstrr‘   rª   ÚCreateStringÚKeyValueStartÚKeyValueAddKeyÚKeyValueAddValueÚKeyValueEndri   ÚTrtTableStartDictVectorrp   ÚPrependUOffsetTRelativeÚ	EndVectorÚTrtTableStartÚTrtTableAddDictÚTrtTableEndÚFinishÚOutputÚenvironrÔ   ÚGetRootAsTrtTableÚ
DictLengthr»   ÚDictÚKeyÚValue)Úcalibration_cacheÚdirrA  rB  rF  rH  ÚfileÚbuilderÚkey_value_listÚkeyrÃ   r|   Úflat_keyÚ
flat_valueÚ	key_valueÚ	main_dictÚ	cal_tableÚbufÚdict_lenrt   r  s                        r"   Úwrite_calibration_tableru  \  s  € ó
 ãçLÓLßLÓLä‡L�LÐ&Ð'8Ð&9Ð:Ô;ä	Œb�g‰g�l‰l˜3Ð 2Ó3°SÔ	9¸TØ�
‰
�4—:‘:Ð/Ó0Ô1÷ 
:ð ×!Ñ! $Ó'€GØ€NÜÐ'×,Ñ,Ó.Ö/ˆØ" 3Ñ'ˆÜ”Cœ˜F 1™I›¬¨F°1©I«Ó7Ó8ˆà×'Ñ'¨Ó,ˆØ×)Ñ)¨%Ó0ˆ
à×Ñ˜wÔ'Ø×Ñ ¨Ô2Ø×!Ñ! '¨:Ô6Ø×(Ñ(¨Ó1ˆ	à×Ñ˜iÕ(ð 0ð ×$Ñ$ W¬c°.Ó.AÔBÛ#ˆ	Ø×'Ñ'¨	Õ2ð $à×!Ñ!Ó#€Ià×Ñ˜7Ô#Ø×Ñ˜W iÔ0Ø×$Ñ$ WÓ-€Ià‡N�N�9ÔØ
�.‰.Ó
€Cä	Œb�g‰g�l‰l˜3Ð 9Ó:¸DÔ	AÀTØ�
‰
�3Œ÷ 
Bô 
‡z�z‡~�~Ð*¨AÓ.°(Ñ:Ø×%Ñ%×7Ñ7¸¸QÓ?ˆ	Ø×'Ñ'Ó)ˆÜ�x–ˆAØ!Ÿ™ qÓ)ˆIÜ�L‰L˜Ÿ™›Ô)Ü�L‰L˜Ÿ™Ó*Õ+ð !ô 
Œb�g‰g�l‰l˜3Ð 3Ó4°cÔ	:¸dÜÐ+×0Ñ0Ó2Ö3ˆCØ% cÑ*ˆEØ�c‘	œC¤¤C¨¨a©£M´3°u¸Q±x³=Ó AÓBÑBˆAØ�J‰J�qŒMØ�J‰J�tÕñ	 4÷ 
;Ð	:÷[ 
:Ñ	9ú÷@ 
BÑ	Aú÷ 
;Ð	:ús%   Á#!N&È*N3Ì#A9O Î&N0Î3N=Ï O	c                ó¶  — | dk(  j                  t        j                  «      }| dk7  j                  t        j                  «      }|j                  «       }| j                  |z
  }|sy|t        |«      z  t        |«      z  }|dk  sJ d|||fz  «       ‚| j                  t        j                  «      }|||z  | |z  z   z  }|dk  j                  «       dk(  sJ ‚|S )a~  Given a discrete distribution (may have not been normalized to 1),
    smooth it by replacing zeros with eps multiplied by a scaling factor
    and taking the corresponding amount off the non-zero values.
    Ref: http://web.engr.illinois.edu/~hanj/cs412/bk3/KL-divergence.pdf
         https://github.com//apache/incubator-mxnet/blob/master/python/mxnet/contrib/quantization.py
    r   Nr§   z"n_zeros=%d, n_nonzeros=%d, eps1=%f)r”   re   rn   ÚsumÚsizeÚfloat)ÚpÚepsÚis_zerosÚis_nonzerosÚn_zerosÚ
n_nonzerosÚeps1r6  s           r"   Úsmooth_distributionr�  Ÿ  sÜ   € ð �Q‘�‰œuŸ}™}Ó-€HØ˜‘6—/‘/¤%§-¡-Ó0€KØ�l‰l‹n€GØ—‘˜'Ñ!€JáàØ”�w“Ñ¤%¨
Ó"3Ñ3€DØ�#Š:ð Ð;ØØØð?ñ ó ˆ:ð �8‰8”E—M‘MÓ"€DØˆC�(‰N˜t˜e {Ñ2Ñ2Ñ2€DØ�A‰I�?‰?Ó Ò!Ð!Ð!à€Kr%   c                ó²   — t        j                  | j                  «       d¬«      }|j                  j                  D ]  }t        j                  |«      sŒ y y)NF)Úload_external_dataT)rŒ   ÚloadÚas_posixÚgraphrã   r   Úuses_external_data)Ú
model_pathÚmodelÚ
intializers      r"   Úmodel_has_external_datar‹  ¼  sE   € Ü�I‰I�j×)Ñ)Ó+ÀÔF€EØ—k‘k×-Ô-ˆ
Ü×2Ñ2°:Õ>Ùð .ð r%   c                ó¸   — t        «       }|j                  «       |_        t        j                  |_        i }dg|d<   t        | j                  «       |fddgi|¤Ž}y)zø
        Generate model that applies graph optimization (constant folding, etc.)
        parameter model_path: path to the original onnx model
        parameter opt_model_path: path to the optimized onnx model
    :return: optimized onnx model
    ÚConstantSharingÚdisabled_optimizersÚ	providersÚCPUExecutionProviderN)r   r…  Úoptimized_model_filepathr   ÚORT_ENABLE_BASICÚgraph_optimization_levelr   )rˆ  Úopt_model_pathÚsess_optionÚkwargsÚ_s        r"   Úoptimize_modelr˜  Ä  sb   € ô !Ó"€KØ+9×+BÑ+BÓ+D€KÔ(Ü+A×+RÑ+R€KÔ(Ø€Fà%6Ð$7€FÐ Ñ!Ü˜×,Ñ,Ó.°ÑjÐH^ÐG_ÐjÐciÑj�Ar%   c                óÔ   — ddi}| j                   r8| j                   D ])  }|j                  |j                  |j                  i«       Œ+ t        j
                  j                  | |«       y)z>Tag the model that it went through quantization pre-processingúonnx.quant.pre_processúonnxruntime.quantN©Úmetadata_propsÚupdaterm  r|   rŒ   r�   Úset_model_props)r‰  r�  Úprops      r"   Úadd_pre_process_metadatar¡  Ô  sU   € à.Ð0CÐD€NØ×ÒØ×(Ô(ˆDØ×!Ñ! 4§8¡8¨T¯Z©ZÐ"8Õ9ð )ä‡K�K×Ñ  ~Õ6r%   c                ó€   — | j                   r2| j                   D ]#  }|j                  dk(  sŒ|j                  dk(  sŒ# y y)zCCheck the model whether it went through quantization pre-processingrš  r›  TF©r�  rm  r|   )r‰  r   s     r"   Úmodel_has_pre_process_metadatar¤  Ý  s<   € à×ÒØ×(Ô(ˆDØ�x‰xÐ3Ó3¸¿
¹
ÐFYÓ8YÙð )ð r%   c                óÔ   — ddi}| j                   r8| j                   D ])  }|j                  |j                  |j                  i«       Œ+ t        j
                  j                  | |«       y )Nú
onnx.inferr›  rœ  )r‰  r�  rz  s      r"   Úadd_infer_metadatar§  æ  sU   € Ø"Ð$7Ð8€NØ×ÒØ×%Ô%ˆAØ×!Ñ! 1§5¡5¨!¯'©'Ð"2Õ3ð &ä‡K�K×Ñ  ~Õ6r%   c                ó€   — | j                   r2| j                   D ]#  }|j                  dk(  sŒ|j                  dk(  sŒ# y y)Nr¦  r›  TFr£  )r‰  rz  s     r"   Úmodel_has_infer_metadatar©  î  s;   € Ø×ÒØ×%Ô%ˆAØ�u‰u˜Ó$¨¯©Ð4GÓ)GÙð &ð r%   c                óþ   — t        | d«      }t        j                  j                  t	        | «      t	        |«      «       t        j
                  |j                  «       «      }t        |«       |j                  «        |S )Nz	-inferred)	r&  rŒ   Úshape_inferenceÚinfer_shapes_pathrT  r„  r…  r§  Úunlink)rˆ  Úinferred_model_pathr‰  s      r"   Úload_model_with_shape_inferr¯  ö  s`   € Ü6°zÀ;ÓOÐÜ×Ñ×*Ñ*¬3¨z«?¼CÐ@SÓ<TÔUÜ�I‰IÐ)×2Ñ2Ó4Ó5€EÜ�uÔØ×ÑÔ Ø€Lr%   c                óð   — t        j                  d¬«      5 }t        |«      j                  d«      }t	        j
                  | |j                  «       d¬«       t        |«      cd d d «       S # 1 sw Y   y xY w)Nz
ort.quant.)Úprefixz
model.onnxT)Úsave_as_external_data)ÚtempfileÚTemporaryDirectoryr   r!  rŒ   Ú
save_modelr…  r¯  )r‰  Úquant_tmp_dirrˆ  s      r"   Ú&save_and_reload_model_with_shape_inferr·  ÿ  sT   € Ü	×	$Ñ	$¨LÕ	9¸]Ü˜-Ó(×1Ñ1°,Ó?ˆ
Ü�‰˜˜z×2Ñ2Ó4ÈDÕQÜ*¨:Ó6÷ 
:×	9Ò	9ús   —AA,Á,A5c                ó  — | j                   t        j                  j                  t        j                  j                  fv rt
        j                  j                  | «      S t        d| j                  › dt        | j                      › �«      ‚)Nz&Only float type is supported. Weights z is )Ú	data_typer…   r   rŠ   r‹   rŒ   Únumpy_helperÚto_arrayr(   r   Útype_to_name)rã   s    r"   Útensor_proto_to_arrayr½    su   € Ø×Ñ¤×!7Ñ!7×!=Ñ!=¼z×?UÑ?U×?]Ñ?]Ð ^Ñ^Ü× Ñ ×)Ñ)¨+Ó6Ð6ä
Ø
0°×1AÑ1AÐ0BÀ$Ä|ÐT_×TiÑTiÑGjÐFkÐlóð r%   c                ó   — | dz   S )NÚ_QuantizeLinearr2   ©Útensor_names    r"   Úadd_quant_suffixrÂ    s   € ØÐ*Ñ*Ð*r%   c                ó   — | t         z   S r   )ÚQUANT_INPUT_SUFFIXrÀ  s    r"   Úadd_quant_input_suffixrÅ    s   € ØÔ+Ñ+Ð+r%   c                ó   — | dz   S )NÚ_QuantizeLinear_Outputr2   rÀ  s    r"   Úadd_quant_output_suffixrÈ    s   € ØÐ1Ñ1Ð1r%   c                ó   — | dz   S )NÚ_DequantizeLinearr2   rÀ  s    r"   Úadd_dequant_suffixrË    s   € ØÐ,Ñ,Ð,r%   c                ó   — | dz   S )NÚ_DequantizeLinear_Inputr2   rÀ  s    r"   Úadd_dequant_input_suffixrÎ    s   € ØÐ2Ñ2Ð2r%   c                ó   — | t         z   S r   )ÚDEQUANT_OUTPUT_SUFFIXrÀ  s    r"   Úadd_dequant_output_suffixrÑ  #  s   € ØÔ.Ñ.Ð.r%   )NN)FN)FNNN)FF)rÛ   ÚintrÜ   rÒ  Úreturnztuple[bool, int])r$  r   r%  rT  rÓ  r   )rC   )g-Cëâ6?)rˆ  r   )rˆ  r   r”  r   )r‰  r   )r‰  r   rÓ  Úbool)rˆ  r   rÓ  r   )r‰  r   rÓ  r   )rã   r   rÓ  znumpy.ndarray)rÁ  rT  rÓ  rT  )rÓ  rT  )bÚ
__future__r   rI  rL  r³  Úenumr   Úpathlibr   re   rŒ   r   r   r   r	   r…   Úonnx.helperr
   r   r   r   Úonnx.referencer   Úonnxruntimer   r   r   rº   r   ÚImportErrorÚ__producer__Ú__version__Úonnx_domainÚ	ms_domainÚQUANT_OP_NAMErÄ  ÚDEQUANT_OP_NAMErÐ  ÚTENSOR_NAME_QUANT_SUFFIXr¸   ri  rk   ÚgetattrrÒ  r¼  r   r4   r;   rQ   rE   r\   rG   rK   rI   rM   r„   rj   rX   rW   rZ   rY   rÖ   rÕ   rÓ   rv   r£   r´   rÆ   rÑ   r�   rÙ   rß   rá   rì   rú   r  r  r  r  r&  r9  ru  r�  r‹  r˜  r¡  r¤  r§  r©  r¯  r·  r½  rÂ  rÅ  rÈ  rË  rÎ  rÑ  )Úks   0r"   Ú<module>rå     sÒ  ðõ #ã Û 	Û Ý Ý ã Û ß >Ñ >Ý &ß QÓ QÝ -ç PÑ PðÝ@ð
 €Ø€Ø€Ø€	Ø €Ø,Ð Ø$€Ø2Ð Ø'Ð àÐ á47¸Ô4DÓqÑ4D¨qÉ
ÑSZÐ[fÐhiÓSjÐloÕHp‘˜ QÓ'¨Ñ*Ð4DÑq€ô�tô ô˜ô ô>�ô >ô@�$ô ð  ×Ñ×Ñ  §¡¨VÓ!4Ø×Ñ× Ñ  + %§+¡+¨gÓ"6Ø×Ñ× Ñ  + %§+¡+¨gÓ"6Ø×Ñ×!Ñ! ; 5§;¡;¨xÓ#8Ø×Ñ×'Ñ'¨ðÐ ð ×Ñ× Ñ  ; 5§;¡;¨q¸¿¹Ô#DÀkÀeÇkÁkÐRUÐ]b×]hÑ]hÔFiÐ"jØ×Ñ×Ñ + %§+¡+¨d¸%¿*¹*Ô"EÀ{ÀuÇ{Á{ÐSVÐ^c×^hÑ^hÔGiÐ!jØ×Ñ×!Ñ! K E§K¡K°¸¿¹Ô$FÈÈÏÉÐTYÐaf×amÑamÔHnÐ#oØ×Ñ× Ñ  ; 5§;¡;¨v¸U¿[¹[Ô#IÈ;È5Ï;É;ÐW\Ðdi×doÑdoÔKpÐ"qð	Ð ð ×Ñ×Ñ + %§+¡+¨d¸%¿*¹*Ô"EÀ{ÀuÇ{Á{ÐSVÐ^c×^hÑ^hÔGiÐ!jØ×Ñ× Ñ  ; 5§;¡;¨v¸U¿[¹[Ô#IÈ;È5Ï;É;ÐW\Ðdi×doÑdoÔKpÐ"qð!Ð ð ×Ñ× Ñ  ; 5§;¡;¨q¸¿¹Ô#DÀkÀeÇkÁkÐRUÐ]b×]hÑ]hÔFiÐ"jØ×Ñ×Ñ + %§+¡+¨c¸¿¹Ô"DÀkÀeÇkÁkÐRTÐ\a×\fÑ\fÔFgÐ!hØ×Ñ×!Ñ! K E§K¡K°¸¿¹Ô$FÈÈÏÉÐTYÐaf×amÑamÔHnÐ#oØ×Ñ× Ñ  ; 5§;¡;¨v¸U¿[¹[Ô#IÈ;È5Ï;É;ÐW\Ðdi×doÑdoÔKpÐ"qð	Ð ð )+ô Aó ,3ó^<ò~"ðL hlóB=óJó@ó	÷ñ ÷>%ñ %÷8'ñ 'ò"#òJ0òò@óRòó$@óFó:ókó 7óó7óóó7óó+ó,ó2ó-ó3ô/øðU ò ØƒLðüò  rs   ÁT7 Á8UÂUÔ7UÕU