Ë
|
nñúh»U ã ó¨ d Z ddlmZ ddlmZmZmZmZ ddlZ ddl
|
m Z m Z m Z ddlmZmZmZmZmZmZ ddlmZmZmZ ddlmZ dd lm Z dd
|
l m Z m Z m Z ddl!m"c m#Z$ dd l%m&Z& erdd l'm(Z(m)Z) d dd Z* d ddZ+d dZ, d d dZ-d dZ.d dZ/ d! d"dZ0d#dZ1d$dZ2d%dZ3d&dZ4y)'z,
|
Quantilization functions and related stuff
|
é )Ú annotations)Ú TYPE_CHECKINGÚAnyÚCallableÚLiteralN)Ú TimedeltaÚ TimestampÚlib)Úensure_platform_intÚ is_bool_dtypeÚ
|
is_integerÚ is_list_likeÚis_numeric_dtypeÚ is_scalar)ÚCategoricalDtypeÚDatetimeTZDtypeÚExtensionDtype)Ú ABCSeries)Úisna)Ú CategoricalÚIndexÚ IntervalIndex)Ú dtype_to_unit)ÚDtypeObjÚIntervalLeftRightc
|
óX | } t | « }
|
t |
|
« \ }
|
} t j |« st |
|
||« }nIt |t « r|j r-t d« t |« }|j s t d« t |
|
|||||||¬« \ } }t | ||| « S )a
|
Bin values into discrete intervals.
|
|
Use `cut` when you need to segment and sort data values into bins. This
|
function is also useful for going from a continuous variable to a
|
categorical variable. For example, `cut` could convert ages to groups of
|
age ranges. Supports binning into an equal number of bins, or a
|
pre-specified array of bins.
|
|
Parameters
|
----------
|
x : array-like
|
The input array to be binned. Must be 1-dimensional.
|
bins : int, sequence of scalars, or IntervalIndex
|
The criteria to bin by.
|
|
* int : Defines the number of equal-width bins in the range of `x`. The
|
range of `x` is extended by .1% on each side to include the minimum
|
and maximum values of `x`.
|
* sequence of scalars : Defines the bin edges allowing for non-uniform
|
width. No extension of the range of `x` is done.
|
* IntervalIndex : Defines the exact bins to be used. Note that
|
IntervalIndex for `bins` must be non-overlapping.
|
|
right : bool, default True
|
Indicates whether `bins` includes the rightmost edge or not. If
|
``right == True`` (the default), then the `bins` ``[1, 2, 3, 4]``
|
indicate (1,2], (2,3], (3,4]. This argument is ignored when
|
`bins` is an IntervalIndex.
|
labels : array or False, default None
|
Specifies the labels for the returned bins. Must be the same length as
|
the resulting bins. If False, returns only integer indicators of the
|
bins. This affects the type of the output container (see below).
|
This argument is ignored when `bins` is an IntervalIndex. If True,
|
raises an error. When `ordered=False`, labels must be provided.
|
retbins : bool, default False
|
Whether to return the bins or not. Useful when bins is provided
|
as a scalar.
|
precision : int, default 3
|
The precision at which to store and display the bins labels.
|
include_lowest : bool, default False
|
Whether the first interval should be left-inclusive or not.
|
duplicates : {default 'raise', 'drop'}, optional
|
If bin edges are not unique, raise ValueError or drop non-uniques.
|
ordered : bool, default True
|
Whether the labels are ordered or not. Applies to returned types
|
Categorical and Series (with Categorical dtype). If True,
|
the resulting categorical will be ordered. If False, the resulting
|
categorical will be unordered (labels must be provided).
|
|
Returns
|
-------
|
out : Categorical, Series, or ndarray
|
An array-like object representing the respective bin for each value
|
of `x`. The type depends on the value of `labels`.
|
|
* None (default) : returns a Series for Series `x` or a
|
Categorical for all other inputs. The values stored within
|
are Interval dtype.
|
|
* sequence of scalars : returns a Series for Series `x` or a
|
Categorical for all other inputs. The values stored within
|
are whatever the type in the sequence is.
|
|
* False : returns an ndarray of integers.
|
|
bins : numpy.ndarray or IntervalIndex.
|
The computed or specified bins. Only returned when `retbins=True`.
|
For scalar or sequence `bins`, this is an ndarray with the computed
|
bins. If set `duplicates=drop`, `bins` will drop non-unique bin. For
|
an IntervalIndex `bins`, this is equal to `bins`.
|
|
See Also
|
--------
|
qcut : Discretize variable into equal-sized buckets based on rank
|
or based on sample quantiles.
|
Categorical : Array type for storing data that come from a
|
fixed set of values.
|
Series : One-dimensional array with axis labels (including time series).
|
IntervalIndex : Immutable Index implementing an ordered, sliceable set.
|
|
Notes
|
-----
|
Any NA values will be NA in the result. Out of bounds values will be NA in
|
the resulting Series or Categorical object.
|
|
Reference :ref:`the user guide <reshaping.tile.cut>` for more examples.
|
|
Examples
|
--------
|
Discretize into three equal-sized bins.
|
|
>>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3)
|
... # doctest: +ELLIPSIS
|
[(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...
|
Categories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ...
|
|
>>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3, retbins=True)
|
... # doctest: +ELLIPSIS
|
([(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...
|
Categories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ...
|
array([0.994, 3. , 5. , 7. ]))
|
|
Discovers the same bins, but assign them specific labels. Notice that
|
the returned Categorical's categories are `labels` and is ordered.
|
|
>>> pd.cut(np.array([1, 7, 5, 4, 6, 3]),
|
... 3, labels=["bad", "medium", "good"])
|
['bad', 'good', 'medium', 'medium', 'good', 'bad']
|
Categories (3, object): ['bad' < 'medium' < 'good']
|
|
``ordered=False`` will result in unordered categories when labels are passed.
|
This parameter can be used to allow non-unique labels:
|
|
>>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3,
|
... labels=["B", "A", "B"], ordered=False)
|
['B', 'B', 'A', 'A', 'B', 'B']
|
Categories (2, object): ['A', 'B']
|
|
``labels=False`` implies you just want the bins back.
|
|
>>> pd.cut([0, 1, 1, 2], bins=4, labels=False)
|
array([0, 1, 1, 3])
|
|
Passing a Series as an input returns a Series with categorical dtype:
|
|
>>> s = pd.Series(np.array([2, 4, 6, 8, 10]),
|
... index=['a', 'b', 'c', 'd', 'e'])
|
>>> pd.cut(s, 3)
|
... # doctest: +ELLIPSIS
|
a (1.992, 4.667]
|
b (1.992, 4.667]
|
c (4.667, 7.333]
|
d (7.333, 10.0]
|
e (7.333, 10.0]
|
dtype: category
|
Categories (3, interval[float64, right]): [(1.992, 4.667] < (4.667, ...
|
|
Passing a Series as an input returns a Series with mapping value.
|
It is used to map numerically to intervals based on bins.
|
|
>>> s = pd.Series(np.array([2, 4, 6, 8, 10]),
|
... index=['a', 'b', 'c', 'd', 'e'])
|
>>> pd.cut(s, [0, 2, 4, 6, 8, 10], labels=False, retbins=True, right=False)
|
... # doctest: +ELLIPSIS
|
(a 1.0
|
b 2.0
|
c 3.0
|
d 4.0
|
e NaN
|
dtype: float64,
|
array([ 0, 2, 4, 6, 8, 10]))
|
|
Use `drop` optional when bins is not unique
|
|
>>> pd.cut(s, [0, 2, 4, 6, 10, 10], labels=False, retbins=True,
|
... right=False, duplicates='drop')
|
... # doctest: +ELLIPSIS
|
(a 1.0
|
b 2.0
|
c 3.0
|
d 3.0
|
e NaN
|
dtype: float64,
|
array([ 0, 2, 4, 6, 10]))
|
|
Passing an IntervalIndex for `bins` results in those categories exactly.
|
Notice that values not covered by the IntervalIndex are set to NaN. 0
|
is to the left of the first bin (which is closed on the right), and 1.5
|
falls between two bins.
|
|
>>> bins = pd.IntervalIndex.from_tuples([(0, 1), (2, 3), (4, 5)])
|
>>> pd.cut([0, 0.5, 1.5, 2.5, 4.5], bins)
|
[NaN, (0.0, 1.0], NaN, (2.0, 3.0], (4.0, 5.0]]
|
Categories (3, interval[int64, right]): [(0, 1] < (2, 3] < (4, 5]]
|
z*Overlapping IntervalIndex is not accepted.z!bins must increase monotonically.)ÚrightÚlabelsÚ precisionÚinclude_lowestÚ
|
duplicatesÚordered) Ú_preprocess_for_cutÚ_coerce_to_typeÚnpÚiterableÚ_nbins_to_binsÚ
|
isinstancer Úis_overlappingÚ
|
ValueErrorr Úis_monotonic_increasingÚ _bins_to_cutsÚ_postprocess_for_cut) ÚxÚbinsr r Úretbinsr r r! r" ÚoriginalÚx_idxÚ_Úfacs úKH:\Change_password\venv_build\Lib\site-packages\pandas/core/reshape/tile.pyÚcutr6 4 s´ ðz HÜ Ó "EÜ uÓ%HE1ä ;;tÔ Ü e T¨5Ó1ä D-Ô (Ø × Ò Ü Ð IÓJÐ Jô T{Ø×+Ò+Ü Ð @ÓAÐ Aä Ø Ø ØØØØ%Ø Øô ICô T¨7°HÓ =Ð=ó c ó6 | }t | « }t |« \ }}t |« rt j dd|dz « n|} |j « j « j | « }
|
t |t |
|
« ||d|¬« \ } }
|
t | |
|
||« S )a!
|
Quantile-based discretization function.
|
|
Discretize variable into equal-sized buckets based on rank or based
|
on sample quantiles. For example 1000 values for 10 quantiles would
|
produce a Categorical object indicating quantile membership for each data point.
|
|
Parameters
|
----------
|
x : 1d ndarray or Series
|
q : int or list-like of float
|
Number of quantiles. 10 for deciles, 4 for quartiles, etc. Alternately
|
array of quantiles, e.g. [0, .25, .5, .75, 1.] for quartiles.
|
labels : array or False, default None
|
Used as labels for the resulting bins. Must be of the same length as
|
the resulting bins. If False, return only integer indicators of the
|
bins. If True, raises an error.
|
retbins : bool, optional
|
Whether to return the (bins, labels) or not. Can be useful if bins
|
is given as a scalar.
|
precision : int, optional
|
The precision at which to store and display the bins labels.
|
duplicates : {default 'raise', 'drop'}, optional
|
If bin edges are not unique, raise ValueError or drop non-uniques.
|
|
Returns
|
-------
|
out : Categorical or Series or array of integers if labels is False
|
The return type (Categorical or Series) depends on the input: a Series
|
of type category if input is a Series else Categorical. Bins are
|
represented as categories when categorical data is returned.
|
bins : ndarray of floats
|
Returned only if `retbins` is True.
|
|
Notes
|
-----
|
Out of bounds values will be NA in the resulting Categorical object
|
|
Examples
|
--------
|
>>> pd.qcut(range(5), 4)
|
... # doctest: +ELLIPSIS
|
[(-0.001, 1.0], (-0.001, 1.0], (1.0, 2.0], (2.0, 3.0], (3.0, 4.0]]
|
Categories (4, interval[float64, right]): [(-0.001, 1.0] < (1.0, 2.0] ...
|
|
>>> pd.qcut(range(5), 3, labels=["good", "medium", "bad"])
|
... # doctest: +SKIP
|
[good, good, medium, bad, bad]
|
Categories (3, object): [good < medium < bad]
|
|
>>> pd.qcut(range(5), 4, labels=False)
|
array([0, 0, 1, 2, 3])
|
r é T)r r r r! ) r# r$ r r% ÚlinspaceÚ to_seriesÚdropnaÚquantiler, r r- ) r. Úqr r0 r r! r1 r2 r3 Ú quantilesr/ r4 s r5 Úqcutr@ s ðz HÜ Ó "EÜ uÓ%HE1ä,6°q¬M Aq ! a¡%Ô(¸qIà ??Ó × #Ñ #Ó %× .Ñ .¨yÓ 9Dä Ø Ü d ØØØØ ô ICô T¨7°HÓ =Ð=r7 c ó< t |« r|dk r t d« | j dk( r t d« | j « | j « f}|\ }}t | j « r5t j |« st j |« r t d« ||k( rÐt | j « rdt | j « }t d¬« j |« }| j j ||z
|
||z |dz d|¬« }t# |« S ||dk7 rd t |« z nd z }||dk7 rd t |« z nd z }t j |||dz d
|
¬ « }t# |« S t | j « r9t | j « }| j j |||dz d|¬« }n t j |||dz d
|
¬ « }||z
|
d z } |r|dxx | z cc< t# |« S |d xx | z cc< t# |« S ) zl
|
If a user passed an integer N for bins, convert this to a sequence of N
|
equal(ish)-sized bins.
|
r9 z$`bins` should be a positive integer.r zCannot cut empty arrayz?cannot specify integer `bins` when input data contains infinity)ÚsecondsN)ÚstartÚendÚperiodsÚfreqÚunitgü©ñÒMbP?T)Úendpointéÿÿÿÿ)r r* ÚsizeÚminÚmaxr Údtyper% ÚisinfÚ _is_dt_or_tdr r Úas_unitÚ_valuesÚ_generate_rangeÚabsr: r )
|
r2 Únbinsr ÚrngÚmnÚmxrG Útdr/ Úadjs
|
r5 r' r' ` sû ô
|
ÔE AIÜÐ?Ó@Ð@à zzQÜÐ1Ó2Ð2à 99; Ð
|
$CØ FBä Ô$¬"¯(©(°2¬,¼"¿(¹(À2¼,äØ Mó
|
ð
|
ð
|
RxÜ Ô $ô ! §¡Ó-DÜ 1Ô%×-Ñ-¨dÓ3Bð ==×0Ñ0Ø2g 2¨¡7°E¸A±IÀDÈtð 1ó Dô8 ;Ðð1 R¨1¢W%#b'/°%Ñ 7BØ R¨1¢W%#b'/°%Ñ 7Bä;;r 2 u¨q¡y¸4Ô@Dô* ;Ðô' Ô $ô
|
! §¡Ó-Dð ==×0Ñ0Øb¨%°!©)¸$ÀTð 1ó Dô ;;r 2 u¨q¡y¸4Ô@DØBw%Ñ Ù Ø GsNGô ;Ðð HOHä ;Ðr7 c ó |s | t d« |dvr t d« t |t « r:|j | « }t |d¬« } t j || d¬« }
|
|
|
|fS t j |« } t | « t |« k r-t |« dk7 r |d k( rt d
|
t |« d « | }|rd nd } |j | | ¬« }t |« }|r d|| |d k( < t! | « |t |« k( z |dk( z }|j# « }|durû|t% |« s t d« |t' ||||¬« }nR|r+t t) |« « t |« k7 r t d« t |« t |« dz
|
k7 r t d« t t+ |dd « t « s0t |t t) |« « t |« k( r|nd |¬« }t- j. ||d« t j0 ||dz
|
« }
|
|
|
|fS |dz
|
}
|
|rD|
|
j3 t, j4 « }
|
t- j. |
|
|t, j6 « |
|
|fS # t $ r} | j j dk( r t d« | | j j |j j cxk( rdk( rn n t d« | | j j dk( r t d« | d } ~ ww xY w) Nz.'labels' must be provided if 'ordered = False')ÚraiseÚdropzHinvalid value for 'duplicates' parameter, valid options are: raise, dropT)r" F)rM Úvalidateé r[ zBin edges must be unique: z@.
|
You can drop duplicate edges by setting the 'duplicates' kwargÚleftr )ÚsideÚmz!bins must be of timedelta64 dtypeÚMzHCannot use timezone-naive bins with timezone-aware values, or vice-versaz bins must be of datetime64 dtyper9 r zJBin labels must either be False, None or passed in as a list-like argument)r r zNlabels must be unique if ordered=True; pass ordered=False for duplicate labelsz9Bin labels must be one fewer than the number of bin edgesrM )Ú
|
categoriesr" ) r* r( r Ú get_indexerr r Ú
|
from_codesÚalgosÚuniqueÚlenÚreprÚ searchsortedÚ TypeErrorrM Úkindr r Úanyr Ú_format_labelsÚsetÚgetattrr% ÚputmaskÚtake_ndÚastypeÚfloat64Únan)r2 r/ r r r r r! r" ÚidsÚ cat_dtypeÚresultÚ unique_binsr` ÚerrÚna_maskÚhas_nass r5 r, r, s ñ v~ÜÐIÓJÐJàÐ*Ñ*ÜØ Vó
|
ð
|
ô $ Ô&à× Ñ uÓ%Ü$ T°4Ô8 Ü ×'Ñ'¨°9ÀuÔMØt|Ðä,,tÓ$KÜ
|
;Ó#d)Ò#¬¨D« °QªØ Ò Ü Ø,¬T°$«Z¨Lð 9Qð Róð ð á/4¡V¸'DðØ× Ñ ¨DÐ Ó1ô cÓ
|
"CáØ !ET!WÑ Ñ ä5kS¤C¨£IÑ -Ñ.°#¸±(Ñ;GØkkmGà UÑؤ,¨vÔ"6Ü ð%óð ð
|
>Ü#Øi u¸^ôFñ S [Ó)¬S°«[Ò8Ü ð'óð ô
|
6{c $i¨!mÒ+Ü ØOóð ô ' &¨'°4Ó8Ô:JÔKÜ ØÜ%(¬¨V«Ó%5¼¸V»Ò%D6È$Ø ôFô
|
|
3 Ô#Ü v s¨Q¡wÓ/ð 4<Ðð qÙ Ø]]¤2§:¡:Ó.FÜ JJvw¬¯©Ô /à 4<Ðøôy ò ð ;;× Ñ sÒ "Ü Ð @ÓAÀsÐ JØ [[× Ñ §¡§ ¡ Ô 7°CÕ 7Ü ð óð ð ð [[× Ñ Ò $Ü Ð ?Ó@ÀcÐ Ià ûð ús à I2 É2 L É;B LÌL c ó d}t | j « r | j }nt | j « r | j t j
|
« } nit | j t « rOt | j « r:| j t j t j ¬« }t |« } t | « |fS )z¥
|
if the passed data is of datetime/timedelta, bool or nullable int type,
|
this method converts it to numeric so that cut or qcut method can
|
handle it
|
N)rM Úna_value) rO rM r rs r% Úint64r( r r Úto_numpyrt ru r )r. rM Úx_arrs r5 r$ r$ s ð "EäAGGÔ ØÜ qwwÔ à HHRXXÓ ô
|
|
AGG^Ô ,Ô1AÀ!Ç'Á'Ô1JØ
|
|
¤§¡´b·f±f
|
Ó=Ü %Lä 8U?Ðr7 c óR t | t « xs t j | d« S )NÚmM)r( r r
|
Ú is_np_dtype)rM s r5 rO rO s! ô e_Ó -Ò M´· ± ÀÈÓ1MÐMr7 c ó |rdnd}t | j « r t | j « d } fd}nt | « fd}fd}| D cg c]
|
} ||« }}|r|r ||d « |d< t | j « r t | « |« j « }t j ||¬« S c c}w ) z%based on the dtype, return our labelsr r_ c ó | S ©N© )r. s r5 ú<lambda>z _format_labels.<locals>.<lambda>1 s a r7 c óB | t d¬« j « z
|
S )Nr9 )rG )r rP )r. rG s r5 r z _format_labels.<locals>.<lambda>2 s ø 1y¨°Ô 6× >Ñ >¸tÓ DÑD r7 c ó t | « S r )Ú _round_frac©r. r s r5 r z _format_labels.<locals>.<lambda>5 s ø k¨!¨YÓ 7 r7 c ó | d z z
|
S )Né
|
r r s r5 r z _format_labels.<locals>.<lambda>6 s ø 1r y jÑ 1Ñ1 r7 r )Úclosed)rO rM r Ú_infer_precisionÚtyperP r Ú from_breaks)
|
r/ r r r r Ú formatterÚadjustÚbÚbreaksrG s
|
` @r5 rn rn " s¹ ù ñ ,1¡°fFô DJJÔ ô TZZÓ(Ù ÛDä$ Y°Ó5 Û7 Û1à$(Ö )qilÐ )FÐ )Ù á6 !9Ó%q äDJJÔ àdFÓ#×+Ñ+¨DÓ1ä × $Ñ $ V°FÔ ;Ð;ùò *s ÁCc ó t | dd« }|t j | « } | j dk7 r t d« t | « S )z
|
handles preprocessing for cut where we convert passed
|
input to array, strip the index information and store it
|
separately
|
ÚndimNr9 z!Input array must be 1 dimensional)rp r% Úasarrayr r* r )r. r s r5 r# r# D sD ô 1fdÓ #DØ |Ü JJqMØvv{ÜÐ<Ó=Ð=ä 8Or7 c óä t |t « r(|j | |j |j ¬« } |s| S t |t
|
« r!t |j « r |j }| |fS )z
|
handles post processing for the cut method where
|
we combine the index information if the originally passed
|
datatype was a series
|
)ÚindexÚname) r( r Ú _constructorr r r r rM rQ )r4 r/ r0 r1 s r5 r- r- U s^ ô (IÔ&Ø×#Ñ# C¨x¯~©~ÀHÇMÁMÐ#ÓRá Ø
|
ä$Ô Ô#3°D·J±JÔ#?Ø||à 9Ðr7 c ó( t j | « r| dk( r| S t j | « \ }}|dk( rBt t j t j
|
t |« « « « dz
|
|z }n|}t j | |« S )z7
|
Round the fractional part of the given number
|
r r9 )r% ÚisfiniteÚmodfÚintÚfloorÚlog10rS Úaround)r. r ÚfracÚwholeÚdigitss r5 r r g su ô ;;q>Q !VØäggaj eØ A:Ü"((¤2§8¡8¬C°«IÓ#6Ó7Ó8Ð8¸1Ñ<¸yÑHFà FÜyyFÓ#Ð#r7 c
|
óì t | d« D ]_ }t j |D cg c] }t ||« c}« }t j
|
|« j |j k( s]|c S | S c c}w )z8
|
Infer an appropriate precision for _round_frac
|
é )Úranger% r r rf rg rJ )Úbase_precisionr/ r r Úlevelss r5 r r v si ô >¨2Ó.ò ÜÀÖ E¸1[¨¨IÕ 6Ò EÓFÜ <<Ó × $Ñ $¨¯ © Ó 1Ø Ò ð ð Ðùò Fs £A1
|
)TNFé Fr[ T) r Úboolr0 r¯ r r¢ r r¯ r! Ústrr" r¯ )NFr® r[ )r0 r¯ r r¢ r! r° )r2 r rT r¢ r r¯ Úreturnr )TNr® Fr[ T)r2 r r/ r r r¯ r r¢ r r¯ r! r° r" r¯ )r. r r± z tuple[Index, DtypeObj | None])rM r r± r¯ )TF)r/ r r r¢ r r¯ r r¯ )r± r )r0 r¯ )r r¢ )r¬ r¢ r/ r r± r¢ )5Ú__doc__Ú
|
__future__r Útypingr r r r Únumpyr% Ú pandas._libsr r r
|
Úpandas.core.dtypes.commonr r r r r r Úpandas.core.dtypes.dtypesr r r Úpandas.core.dtypes.genericr Úpandas.core.dtypes.missingr Úpandasr r r Úpandas.core.algorithmsÚcoreÚ
|
algorithmsrf Ú pandas.core.arrays.datetimeliker Úpandas._typingr r r6 r@ r' r, r$ rO rn r# r- r r r r7 r5 ú<module>rÁ s² ðñõ #÷ó ó ÷ñ ÷ ÷ ÷ñ õ
|
1Ý +÷ñ ÷
|
'Ð &Ý 9á÷ð Ø ØØØ Ø ØðX>ð ðX>ð
|
ð X>ð ð X>ð ðX>ð ðX>ð óX>ð| ØØØ ð N>ð ð N>ð
|
ð N>ð ó N>ób:ð@ Ø ØØ Ø ØðdØ ðdà
|
ðdð ðdð
|
ð dð ð dð ðdð ódóNó0Nð Ø ð <Ø
|
ð <àð <ð ð <ð ó <óDó"ó$ $ô r7
|
