+
    LV-jê?  ã                   óÊ   € R t . ROt^ RIt^ RIHtHt ^ RIHt ^ RIHt ^RI	H
t ^ RIHtHtHtHt RR ltRR ltRR ltRR	 ltRR
 ltRR ltRR ltRR ltRR ltRR ltR# )zB
Additional statistics functions with support for masked arrays.

N)Úfloat64Úndarray)ÚMaskedArray)Ú_mstats_basic)ÚnormÚbetaÚtÚbinomc                ó†  € R p\         P                  ! V R\        R7      p \        P                  ! \        P
                  ! V4      4      pVe   V P                  ^8X  d   V! WV4      pMAV P                  ^8”  d   \        RV P                   24      h\         P                  ! WBWV4      p\         P                  ! VRR7      # )at  
Computes quantile estimates with the Harrell-Davis method.

The quantile estimates are calculated as a weighted linear combination
of order statistics.

Parameters
----------
data : array_like
    Data array.
prob : sequence, optional
    Sequence of probabilities at which to compute the quantiles.
axis : int or None, optional
    Axis along which to compute the quantiles. If None, use a flattened
    array.
var : bool, optional
    Whether to return the variance of the estimate.

Returns
-------
hdquantiles : MaskedArray
    A (p,) array of quantiles (if `var` is False), or a (2,p) array of
    quantiles and variances (if `var` is True), where ``p`` is the
    number of quantiles.

See Also
--------
hdquantiles_sd

Examples
--------
>>> import numpy as np
>>> from scipy.stats.mstats import hdquantiles
>>>
>>> # Sample data
>>> data = np.array([1.2, 2.5, 3.7, 4.0, 5.1, 6.3, 7.0, 8.2, 9.4])
>>>
>>> # Probabilities at which to compute quantiles
>>> probabilities = [0.25, 0.5, 0.75]
>>>
>>> # Compute Harrell-Davis quantile estimates
>>> quantile_estimates = hdquantiles(data, prob=probabilities)
>>>
>>> # Display the quantile estimates
>>> for i, quantile in enumerate(probabilities):
...     print(f"{int(quantile * 100)}th percentile: {quantile_estimates[i]}")
25th percentile: 3.1505820231763066 # may vary
50th percentile: 5.194344084883956
75th percentile: 7.430626414674935

c                ó²  € \         P                  ! \         P                  ! V P                  4       P	                  \
        4      4      4      pVP                  p\         P                  ! ^\        V4      3\        4      pV^8  d)   \         P                  Vn        V'       d   V# V^ ,          # \         P                  ! V^,           4      \        V4      ,          p\        P                  p\!        V4       F‰  w  r‰V! Wd^,           V	,          V^,           ^V	,
          ,          4      p
V
R,          V
RR ,
          p\         P"                  ! W³4      pWÅ^ V3&   \         P"                  ! W³V,
          ^,          4      V^V3&   K‹  	  V^ ,          V^ V^ 8H  3&   VR,          V^ V^8H  3&   V'       d%   \         P                  ;V^V^ 8H  3&   V^V^8H  3&   V# V^ ,          # )zGComputes the HD quantiles for a 1D array. Returns nan for invalid data.ºé   NNNéÿÿÿÿ)ÚnpÚsqueezeÚsortÚ
compressedÚviewr   ÚsizeÚemptyÚlenr   ÚnanÚflatÚarangeÚfloatr   ÚcdfÚ	enumerateÚdot)ÚdataÚprobÚvarÚxsortedÚnÚhdÚvÚbetacdfÚiÚpÚ_wÚwÚhd_means   &&&          Úk/Volumes/fast/ai/experiments/ui-tars-smoke/.venv/lib/python3.14/site-packages/scipy/stats/_mstats_extras.pyÚ_hd_1DÚhdquantiles.<locals>._hd_1DP   su  € ä—*’*œRŸWšW T§_¡_Ó%6×%;Ñ%;¼GÓ%DÓEÓFˆà�L‰Lˆä�XŠX�qœ˜T›�m¤WÓ-ˆØˆqŒ5Ü—f‘fˆBŒGßØ�	Ø�a•5ˆLä�IŠI�a˜•c‹NœU 1›XÕ%ˆÜ—(‘(ˆÜ˜t–_‰EˆQÙ˜˜q�S !�G a¨¥c¨A¨a­C¥[Ó1ˆBØ�2•˜˜C˜R˜Õ ˆAÜ—f’f˜QÓ(ˆGØˆq�ˆs‰Gä—f’f˜Q¨¥°1Õ 4Ó5ˆBˆq�ˆs‹Gñ %ð # 1�:ˆˆ1ˆd�a‰iˆ<ÑØ" 2�;ˆˆ1ˆd�a‰iˆ<ÑßÜ24·&±&Ð8ˆBˆq�$˜!‘)ˆ|Ñ˜r ! T¨Q¡Y ,Ñ/ØˆIØ�!�uˆó    F©ÚcopyÚdtypeúBArray 'data' must be at most two dimensional, but got data.ndim = ©r0   )
ÚmaÚarrayr   r   Ú
atleast_1dÚasarrayÚndimÚ
ValueErrorÚapply_along_axisÚfix_invalid)r   r   Úaxisr    r,   r'   Úresults   &&&&   r+   Úhdquantilesr>      s¡   € òhô< �8Š8�D˜u¬GÔ4€DÜ
�Š”b—j’j Ó&Ó'€AàŠ˜$Ÿ)™) qœ.Ù˜ Ó%‰à�9‰9�qŒ=Üð  4Ø48·I±I°;ð@ó Að Aä×$Ò$ V°4¸CÓ@ˆä�>Š>˜& uÔ-Ð-r.   c                ó@   € \        V R.WR7      pVP                  4       # )aõ  
Returns the Harrell-Davis estimate of the median along the given axis.

Parameters
----------
data : ndarray
    Data array.
axis : int, optional
    Axis along which to compute the quantiles. If None, use a flattened
    array.
var : bool, optional
    Whether to return the variance of the estimate.

Returns
-------
hdmedian : MaskedArray
    The median values.  If ``var=True``, the variance is returned inside
    the masked array.  E.g. for a 1-D array the shape change from (1,) to
    (2,).

ç      à?)r<   r    )r>   r   )r   r<   r    r=   s   &&& r+   ÚhdmedianrA   |   s!   € ô, ˜˜s˜e¨$Ô8€FØ�>‰>ÓÐr.   c                ó|  € R p\         P                  ! V R\        R7      p \        P                  ! \        P
                  ! V4      4      pVf
   V! W4      pM@V P                  ^8”  d   \        RV P                   24      h\         P                  ! W2W4      p\         P                  ! VRR7      P                  4       # )aµ  
The standard error of the Harrell-Davis quantile estimates by jackknife.

Parameters
----------
data : array_like
    Data array.
prob : sequence, optional
    Sequence of quantiles to compute.
axis : int, optional
    Axis along which to compute the quantiles. If None, use a flattened
    array.

Returns
-------
hdquantiles_sd : MaskedArray
    Standard error of the Harrell-Davis quantile estimates.

See Also
--------
hdquantiles

c                óV  € \         P                  ! V P                  4       4      p\        V4      p\         P                  ! \        V4      \
        4      pV^8  d   \         P                  Vn        \         P                  ! V4      \        V^,
          4      ,          p\        P                  p\        V4       Fí  w  rxV! WSV,          V^V,
          ,          4      p	V	R,          V	RR ,
          p
\         P                  ! V4      p\         P                  ! W¢RR ,          4      VR&   VRR;;; \         P                  ! V
RRR1,          VR^ R1,          ,          4      RRR1,          ,          uuu% \         P                  ! VP!                  4       V^,
          ,          4      WG&   Kï  	  V# )z%Computes the std error for 1D arrays.r   Nr   )r   r   r   r   r   r   r   r   r   r   r   r   r   Ú
zeros_likeÚcumsumÚsqrtr    )r   r   r!   r"   ÚhdsdÚvvr%   r&   r'   r(   r)   Úmx_s   &&          r+   Ú_hdsd_1DÚ hdquantiles_sd.<locals>._hdsd_1D®   s/  € ä—'’'˜$Ÿ/™/Ó+Ó,ˆÜ�‹Lˆä�xŠxœ˜D›	¤7Ó+ˆØˆqŒ5ÜŸ™ˆDŒIä�YŠY�q‹\œE ! A¥#›JÕ&ˆÜ—(‘(ˆä˜t–_‰EˆQÙ˜˜q�S ! Q q¥S¥'Ó*ˆBØ�2•˜˜C˜R˜Õ ˆAô —-’- Ó(ˆCÜ—i’i ¨C¨R LÕ 0Ó1ˆC�‰Gà��‹HœŸ	š	 !¡D b D¥'¨G°E°Q°r°E­NÕ":Ó;¹D¸b¸DÕAÕA‹HÜ—g’g˜cŸg™g›i¨1¨q­5Õ1Ó2ˆD‹Gñ %ð ˆr.   Fr/   r2   r3   )r4   r5   r   r   r6   r7   r8   r9   r:   r;   Úravel)r   r   r<   rJ   r'   r=   s   &&&   r+   Úhdquantiles_sdrM   –   s›   € ò0ô2 �8Š8�D˜u¬GÔ4€DÜ
�Š”b—j’j Ó&Ó'€AàŠÙ˜$Ó"‰à�9‰9�qŒ=Üð  4Ø48·I±I°;ð@ó Að Aä×$Ò$ X°TÓ=ˆä�>Š>˜& uÔ-×3Ñ3Ó5Ð5r.   c                ó’  € \         P                  ! V RR7      p \        P                  ! WW$R7      pVP	                  V4      p\        P
                  ! WW$R7      pVP                  V4      ^,
          p\        P                  ! ^VR,          ,
          V4      p	\        P                  ! WiV,          ,
          WiV,          ,           34      # )a3  
Selected confidence interval of the trimmed mean along the given axis.

Parameters
----------
data : array_like
    Input data.
limits : {None, tuple}, optional
    None or a two item tuple.
    Tuple of the percentages to cut on each side of the array, with respect
    to the number of unmasked data, as floats between 0. and 1. If ``n``
    is the number of unmasked data before trimming, then
    (``n * limits[0]``)th smallest data and (``n * limits[1]``)th
    largest data are masked.  The total number of unmasked data after
    trimming is ``n * (1. - sum(limits))``.
    The value of one limit can be set to None to indicate an open interval.

    Defaults to (0.2, 0.2).
inclusive : (2,) tuple of boolean, optional
    If relative==False, tuple indicating whether values exactly equal to
    the absolute limits are allowed.
    If relative==True, tuple indicating whether the number of data being
    masked on each side should be rounded (True) or truncated (False).

    Defaults to (True, True).
alpha : float, optional
    Confidence level of the intervals.

    Defaults to 0.05.
axis : int, optional
    Axis along which to cut. If None, uses a flattened version of `data`.

    Defaults to None.

Returns
-------
trimmed_mean_ci : (2,) ndarray
    The lower and upper confidence intervals of the trimmed data.

Fr3   )ÚlimitsÚ	inclusiver<   ç       @)
r4   r5   ÚmstatsÚtrimrÚmeanÚtrimmed_stdeÚcountr   Úppfr   )
r   rO   rP   Úalphar<   ÚtrimmedÚtmeanÚtstdeÚdfÚtppfs
   &&&&&     r+   Útrimmed_mean_cir^   Õ   s’   € ôT �8Š8�D˜uÔ%€DÜ�lŠl˜4¸)ÔO€GØ�L‰L˜Ó€EÜ×Ò ¸YÔQ€EØ	�‰�tÓ	˜qÕ	 €BÜ�5Š5��5˜•8•˜BÓ€DÜ�8Š8�U %�ZÕ'¨°E­zÕ)9Ð:Ó;Ð;r.   c                ó$  € R p\         P                  ! V RR7      p V P                  ^8”  d   \        RV P                   24      h\        P
                  ! \        P                  ! V4      4      pVf	   V! W4      # \         P                  ! W2W4      # )aT  
Returns the Maritz-Jarrett estimators of the standard error of selected
experimental quantiles of the data.

Parameters
----------
data : ndarray
    Data array.
prob : sequence, optional
    Sequence of quantiles to compute.
axis : int or None, optional
    Axis along which to compute the quantiles. If None, use a flattened
    array.

c                 óì  € \         P                  ! V P                  4       4      p V P                  p\         P                  ! V4      V,          R ,           P                  \        4      p\        P                  p\         P                  ! \        V4      \        4      p\         P                  ! ^V^,           \        R7      V,          pVRV,          ,
          p\        V4       FŽ  w  r‰V! Wi^,
          W),
          4      V! Wy^,
          W),
          4      ,
          p
\         P                  ! W 4      p\         P                  ! W ^,          4      p\         P                  ! WË^,          ,
          4      WX&   K�  	  V# )r@   )r1   g      ð?)r   r   r   r   r5   ÚastypeÚintr   r   r   r   r   r   r   r   rF   )r   r'   r"   r   r%   ÚmjÚxÚyr&   ÚmÚWÚC1ÚC2s   &&           r+   Ú_mjci_1DÚmjci.<locals>._mjci_1D  sö   € Ü�wŠw�t—‘Ó(Ó)ˆØ�I‰IˆÜ—’˜“˜a• #Õ%×-Ñ-¬cÓ2ˆÜ—(‘(ˆä�XŠX”c˜$“i¤Ó)ˆÜ�IŠI�a˜˜!�¤7Ô+¨aÕ/ˆØ��1•�HˆÜ˜t–_‰EˆQÙ˜˜A�#˜a�cÓ"¡W¨Q°­s°1µ3Ó%7Õ7ˆAÜ—’˜“ˆBÜ—’˜ �'Ó"ˆBÜ—G’G˜B Q¥�JÓ'ˆB‹Eñ	 %ð
 ˆ	r.   Fr3   r2   )r4   r5   r8   r9   r   r6   r7   r:   )r   r   r<   rj   r'   s   &&&  r+   Úmjcirl     s€   € ò ô  �8Š8�D˜uÔ%€DØ‡y�y�1„}Üð 0Ø04·	±	¨{ð<ó =ð 	=ô 	�Š”b—j’j Ó&Ó'€AàŠÙ˜Ó Ð ä×"Ò" 8°4Ó;Ð;r.   c                óú   € \        V^V,
          4      p\        P                  ! ^VR,          ,
          4      p\        P                  ! W^ ^ VR7      p\        WVR7      pWTV,          ,
          WTV,          ,           3# )a}  
Computes the alpha confidence interval for the selected quantiles of the
data, with Maritz-Jarrett estimators.

Parameters
----------
data : ndarray
    Data array.
prob : sequence, optional
    Sequence of quantiles to compute.
alpha : float, optional
    Confidence level of the intervals.
axis : int or None, optional
    Axis along which to compute the quantiles.
    If None, use a flattened array.

Returns
-------
ci_lower : ndarray
    The lower boundaries of the confidence interval.  Of the same length as
    `prob`.
ci_upper : ndarray
    The upper boundaries of the confidence interval.  Of the same length as
    `prob`.

rQ   )ÚalphapÚbetapr<   ©r<   )Úminr   rW   rR   Ú
mquantilesrl   )r   r   rX   r<   ÚzÚxqÚsmjs   &&&&   r+   Úmquantiles_cimjrv   5  sc   € ô6 ��q˜5•yÓ!€EÜ�Š��U˜2•X•Ó€AÜ	×	Ò	˜4¨a°q¸tÔ	D€BÜ
ˆt Ô
%€CØ�S•�L˜" 3�w�,Ð'Ð'r.   c                óØ   € R p\         P                  ! V RR7      p Vf   V! W4      pV# V P                  ^8”  d   \        RV P                   24      h\         P                  ! W2W4      pV# )aý  
Computes the alpha-level confidence interval for the median of the data.

Uses the Hettmasperger-Sheather method.

Parameters
----------
data : array_like
    Input data. Masked values are discarded. The input should be 1D only,
    or `axis` should be set to None.
alpha : float, optional
    Confidence level of the intervals.
axis : int or None, optional
    Axis along which to compute the quantiles. If None, use a flattened
    array.

Returns
-------
median_cihs
    Alpha level confidence interval.

c                 ó  € \         P                  ! V P                  4       4      p \        V 4      p\	        V^V,
          4      p\        \        P                  ! VR,          VR4      4      p\        P                  ! W#,
          VR4      \        P                  ! V^,
          VR4      ,
          pV^V,
          8  dL   V^,          p\        P                  ! W#,
          VR4      \        P                  ! V^,
          VR4      ,
          p\        P                  ! W#,
          ^,
          VR4      \        P                  ! W2R4      ,
          pV^,
          V,           WE,
          ,          pW#,
          V,          \        W2^V,          ,
          V,          ,           4      ,          pWpV,          ,          ^V,
          W^,
          ,          ,          ,           WpW#,
          ^,
          ,          ,          ^V,
          WV,
          ,          ,          ,           3pV# )r   rQ   r@   )
r   r   r   r   rq   rb   r	   Ú_ppfr   r   )	r   rX   r"   ÚkÚgkÚgkkÚIÚlambdÚlimss	   &&       r+   Ú_cihs_1DÚmedian_cihs.<locals>._cihs_1Dn  s_  € Ü�wŠw�t—‘Ó(Ó)ˆÜ�‹IˆÜ�E˜1˜U�7Ó#ˆÜ”—
’
˜5 �8 Q¨Ó,Ó-ˆÜ�YŠY�q•s˜1˜SÓ!¤E§I¢I¨a°­c°!°CÓ$8Õ8ˆØ��%•Œ<Ø��FˆAÜ—’˜1�3˜q Ó%¬¯	ª	°!°Aµ#°a¸Ó(<Õ<ˆBÜ�iŠi˜�˜A�˜a Ó$¤u§y¢y°°SÓ'9Õ9ˆØ�!�V�e�^˜b�hÕ'ˆØ•˜•	œE !¨¨1­¥u¨a¥i¥-Ó0Õ0ˆØ˜1•g•  5¥¨$°­s­)Õ 3Õ3Ø˜1�3˜q�5•kÕ! Q u¥W¨d°Qµ3­iÕ$7Õ7ð9ˆàˆr.   Fr3   r2   )r4   r5   r8   r9   r:   )r   rX   r<   r€   r=   s   &&&  r+   Úmedian_cihsr‚   W  sv   € ò.ô �8Š8�D˜uÔ%€DàŠÙ˜$Ó&ˆð €Mð �9‰9�qŒ=Üð  4Ø48·I±I°;ð@ó Að Aä×$Ò$ X°TÓAˆà€Mr.   c                óˆ  € \         P                  ! WR7      \         P                  ! WR7      rC\        P                  ! WR7      \        P                  ! WR7      re\        P
                  ! W4,
          4      \         P                  ! V^,          V^,          ,           4      ,          p^\        P                  ! V4      ,
          # )a†  
Compares the medians from two independent groups along the given axis.

The comparison is performed using the McKean-Schrader estimate of the
standard error of the medians.

Parameters
----------
group_1 : array_like
    First dataset.  Has to be of size >=7.
group_2 : array_like
    Second dataset.  Has to be of size >=7.
axis : int, optional
    Axis along which the medians are estimated. If None, the arrays are
    flattened.  If `axis` is not None, then `group_1` and `group_2`
    should have the same shape.

Returns
-------
compare_medians_ms : {float, ndarray}
    If `axis` is None, then returns a float, otherwise returns a 1-D
    ndarray of floats with a length equal to the length of `group_1`
    along `axis`.

Examples
--------

>>> from scipy import stats
>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = [8, 9, 10, 11, 12, 13, 14]
>>> stats.mstats.compare_medians_ms(a, b, axis=None)
1.0693225866553746e-05

The function is vectorized to compute along a given axis.

>>> import numpy as np
>>> rng = np.random.default_rng()
>>> x = rng.random(size=(3, 7))
>>> y = rng.random(size=(3, 8))
>>> stats.mstats.compare_medians_ms(x, y, axis=1)
array([0.36908985, 0.36092538, 0.2765313 ])

References
----------
.. [1] McKean, Joseph W., and Ronald M. Schrader. "A comparison of methods
   for studentizing the sample median." Communications in
   Statistics-Simulation and Computation 13.6 (1984): 751-773.

rp   )	r4   ÚmedianrR   Ústde_medianr   ÚabsrF   r   r   )Úgroup_1Úgroup_2r<   Úmed_1Úmed_2Ústd_1Ústd_2rg   s   &&&     r+   Úcompare_medians_msr�   Š  s|   € ôd —i’i Ô2´B·I²I¸gÔ4PˆEÜ×(Ò(¨Ô<Ü×(Ò(¨Ô<ð ä
�Šˆu�}Ó¤§¢¨¨q­°5¸!µ8Õ(;Ó <Õ<€AØŒt�xŠx˜‹{�?Ðr.   c                ó¢   € R p\         P                  ! WR7      P                  \        4      p Vf	   V! V 4      # \         P                  ! W!V 4      # )a  
Returns an estimate of the lower and upper quartiles.

Uses the ideal fourths algorithm.

Parameters
----------
data : array_like
    Input array.
axis : int, optional
    Axis along which the quartiles are estimated. If None, the arrays are
    flattened.

Returns
-------
idealfourths : {list of floats, masked array}
    Returns the two internal values that divide `data` into four parts
    using the ideal fourths algorithm either along the flattened array
    (if `axis` is None) or along `axis` of `data`.

c                 ó®  € V P                  4       p\        V4      pV^8  d!   \        P                  \        P                  .# \	        VR,          R,           ^4      w  r4\        V4      p^V,
          W^,
          ,          ,          WAV,          ,          ,           pW#,
          p^V,
          W,          ,          WAV^,
          ,          ,          ,           pWW.# )é   g      @g«ªªªªªÚ?)r   r   r   r   Údivmodrb   )r   rd   r"   ÚjÚhÚqlorz   Úqups   &       r+   Ú_idfÚidealfourths.<locals>._idfÙ  sš   € Ø�O‰OÓˆÜ�‹FˆØˆqŒ5Ü—F‘Fœ2Ÿ6™6�?Ð"Ü�q˜•t˜e•| AÓ&‰ˆÜ�‹FˆØ��s�A˜•c•F�l˜Q �t�VÕ#ˆØ�EˆØ��s�A•D�j˜1˜q �s�V�8Õ#ˆØˆzÐr.   rp   )r4   r   r   r   r:   )r   r<   r–   s   && r+   Úidealfourthsr˜   Ã  sD   € ò,
ô �7Š7�4Ô#×(Ñ(¬Ó5€DØŠÙ�D‹zÐä×"Ò" 4¨tÓ4Ð4r.   c                ó<  € \         P                  ! V RR7      p Vf   T pM*\        P                  ! \        P                  ! V4      4      pV P
                  ^8w  d   \        R4      hV P                  4       p\        V RR7      pRVR,          V^ ,          ,
          ,          VR	,          ,          pV R
,          VR,          V,           8*  P                  ^ 4      pV R
,          VR,          V,
          8  P                  ^ 4      pWV,
          RV,          V,          ,          # )a½  
Evaluates Rosenblatt's shifted histogram estimators for each data point.

Rosenblatt's estimator is a centered finite-difference approximation to the
derivative of the empirical cumulative distribution function.

Parameters
----------
data : sequence
    Input data, should be 1-D. Masked values are ignored.
points : sequence or None, optional
    Sequence of points where to evaluate Rosenblatt shifted histogram.
    If None, use the data.

Fr3   Nz#The input array should be 1D only !rp   g333333ó?rQ   r   çš™™™™™É?)ºNNNN)Nr›   )
r4   r5   r   r6   r7   r8   ÚAttributeErrorrV   r˜   Úsum)r   Úpointsr"   Úrr“   ÚnhiÚnlos   &&     r+   Úrshr¢   ë  sÛ   € ô  �8Š8�D˜uÔ%€DØ‚~Ø‰ä—’œrŸzšz¨&Ó1Ó2ˆà‡y�y�A„~ÜÐBÓCÐCà�
‰
‹€AÜ�T Ô%€AØˆq��u�Q�q•T�zÕ˜Q �YÕ&€AØ��<˜6 &�>¨AÕ-Ñ-×
2Ñ
2°1Ó
5€CØ��<˜& �.¨1Õ,Ñ,×
1Ñ
1°!Ó
4€CØ�G˜˜1�˜Q�ÕÐr.   )
r�   r>   rA   rM   r˜   r‚   rl   rv   r¢   r^   )©g      Ð?r@   g      è?NF)r   F)r£   N))rš   rš   )TTçš™™™™™©?N)r£   r¤   N)r¤   N)N)Ú__doc__Ú__all__Únumpyr   r   r   Únumpy.mar4   r   Ú r   rR   Úscipy.stats.distributionsr   r   r   r	   r>   rA   rM   r^   rl   rv   r‚   r�   r˜   r¢   © r.   r+   Ú<module>r¬      sc   ðñò€ó ß "å Ý  å %ç :Ó :ô].ô@ô4<6ô~0<ôf*<ôZ(ôD0ôf6ôr%5öP r.   