U 3dD@sdZddlmZddlmZddlmZddlmZddlZddl Z ddl Z ddl Z ddl Z ddlm Z ddlZddlZddlmZd d lmZd d lmZmZd d lmZd dlmZd dlmZd dlmZd dl m!Z!m"Z"d dl#m$Z$d dl%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0d dlm1Z1d dl2m3Z3ej4Z4ej5Z5ddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-gZ6e 7d.kZ8d/e 9d0d1kZ:d2d3Z;d4d5Zd:d;Z?dddddIdJd'ZEdddKdLd(ZFd>dMdNdOZGdPdQZHddRdSdTZIddUdVdWZJdXdYZKdZd[ZLd\d#ZMd]d^ZNednd_d`ZOdddadbdcZPdddeZQdfdgZRdhdiZSdjd)ZTdkdlZUdS)oz= The :mod:`sklearn.utils` module includes various utilities. )Sequence)contextmanager)compress)isliceN)suppress)issparse)murmurhash3_32)compute_class_weightcompute_sample_weight)_joblib)DataConversionWarning) deprecated)all_estimators) parse_versionthreadpool_info)estimator_html_repr) as_float_arrayassert_all_finitecheck_random_state column_or_1d check_arraycheck_consistent_length check_X_y indexablecheck_symmetric check_scalar_is_arraylike_not_scalar) get_config)Bunchr rrrrr r rrrrrrindices_to_maskrparallel_backendregister_parallel_backendresampleshufflecheck_matplotlib_supportrrrr PyPyP cCsddl}ddl}t}tdd|D}|s0dStd}|D]V}|ddkrNq<|d }|d }|dksr|dkrxd S|d kr\sz6_in_unstable_openblas_configuration..Fz0.3.16r+r,version architectureTZ neoversen1)numpyscipyranyrget)r4r5Z modules_infoZopen_blas_usedZopenblas_arm64_stable_versionr/Zopenblas_versionZopenblas_architecturer-r-r0#_in_unstable_openblas_configurationSs(    r8cCsDt|}t|jtjr|St|dr@t|jd}||}|S)aReturn a mask which is safe to use on X. Parameters ---------- X : {array-like, sparse matrix} Data on which to apply mask. mask : ndarray Mask to be used on X. Returns ------- mask : ndarray Array that is safe to use on X. Ztoarrayr)npasarrayZ issubdtypedtypeZ signedintegerhasattrarangeshape)Xmaskindr-r-r0 safe_maskts  rBcCs4|dkr|t||ddfStjd|jdfdS)aReturn a mask which is safer to use on X than safe_mask. This mask is safer than safe_mask since it returns an empty array, when a sparse matrix is sliced with a boolean mask with all False, instead of raising an unhelpful error in older versions of SciPy. See: https://github.com/scipy/scipy/issues/5361 Also note that we can avoid doing the dot product by checking if the len_mask is not zero in _huber_loss_and_gradient but this is not going to be the bottleneck, since the number of outliers and non_outliers are typically non-zero and it makes the code tougher to follow. Parameters ---------- X : {array-like, sparse matrix} Data on which to apply mask. mask : ndarray Mask to be used on X. len_mask : int The length of the mask. Returns ------- mask : ndarray Array that is safe to use on X. rNr)r>)rBr9zerosr>)r?r@Zlen_maskr-r-r0axis0_safe_slices rDcCsLt|r|dkrt|}t|tr,t|}|dkr<||S|dd|fS)zAIndex an array or scipy.sparse consistently across NumPy version.boolrN)rr9r: isinstancetuplelist)arraykey key_dtypeaxisr-r-r0_array_indexings   rMcCspt|rt|}|dkrsz"_list_indexing..)r9rQrFrPrHr)r?rJrKr-rVr0_list_indexings rXTc Cs|d}tdtdtdtjdi}ddddddd}|dkr8dSt|t|rvz|t|WSt k rtt |YnXt|t r|st d|j dkr|jdkrdSt|j }t|j}|dk r|dk r||krt ||dk r|S|St|ttfr6t|}dd |D}|sdSt|d kr.t ||St|d rpz||jjWSt k rnt |YnXt |dS) asDetermine the data type of key. Parameters ---------- key : scalar, slice or array-like The key from which we want to infer the data type. accept_slice : bool, default=True Whether or not to raise an error if the key is a slice. Returns ------- dtype : {'int', 'str', 'bool', None} Returns the data type of key. ~No valid specification of the columns. Only a scalar, list or slice of all integers or all strings, or boolean mask is allowedrNstrrE)iubOUSNzBOnly array-like or scalar are supported. A Python slice was given.cSsh|] }t|qSr-)_determine_key_type)r.eltr-r-r0 sz&_determine_key_type..rr;)rNrZrEr9Zbool_rFrGkeystypeKeyError ValueErrorrP TypeErrorstartstoprarHsetlenpopr<r;kind) rJZ accept_sliceerr_msgZ dtype_to_strZarray_dtype_to_strZkey_start_typeZ key_stop_typeZ unique_keyZkey_typer-r-r0ras\     rarOcCs|dkr |S|dkr"td|t|}|dkrB|dkrBtd|dkrj|jdkrjtd t||j|dkr|dkrt|d std t|d rt||||d St|drt||||d St|||SdS)aReturn rows, items or columns of X using indices. .. warning:: This utility is documented, but **private**. This means that backward compatibility might be broken without any deprecation cycle. Parameters ---------- X : array-like, sparse-matrix, list, pandas.DataFrame, pandas.Series Data from which to sample rows, items or columns. `list` are only supported when `axis=0`. indices : bool, int, str, slice, array-like - If `axis=0`, boolean and integer array-like, integer slice, and scalar integer are supported. - If `axis=1`: - to select a single column, `indices` can be of `int` type for all `X` types and `str` only for dataframe. The selected subset will be 1D, unless `X` is a sparse matrix in which case it will be 2D. - to select multiples columns, `indices` can be one of the following: `list`, `array`, `slice`. The type used in these containers can be one of the following: `int`, 'bool' and `str`. However, `str` is only supported when `X` is a dataframe. The selected subset will be 2D. axis : int, default=0 The axis along which `X` will be subsampled. `axis=0` will select rows while `axis=1` will select columns. Returns ------- subset Subset of X on axis 0 or 1. Notes ----- CSR, CSC, and LIL sparse matrices are supported. COO sparse matrices are not supported. N)rrzR'axis' should be either 0 (to index rows) or 1 (to index column). Got {} instead.rrZz.String indexing is not supported with 'axis=0'rr z'X' should be a 2D NumPy array, 2D sparse matrix or pandas dataframe when indexing the columns (i.e. 'axis=1'). Got {} instead with {} dimension(s).rSLSpecifying the columns using strings is only supported for pandas DataFramesrRrOr>) rgformatrandimrer<rTrMrX)r?indicesrLZ indices_dtyper-r-r0_safe_indexings6)  rt) row_indexercolumn_indexerc Csz|dkrtdddn|}|dkr,tdddn|}t|drjt tdt||j||f<W5QRXn ||||f<dS)anSafe assignment to a numpy array, sparse matrix, or pandas dataframe. Parameters ---------- X : {ndarray, sparse-matrix, dataframe} Array to be modified. It is expected to be 2-dimensional. values : ndarray The values to be assigned to `X`. row_indexer : array-like, dtype={int, bool}, default=None A 1-dimensional array to select the rows of interest. If `None`, all rows are selected. column_indexer : array-like, dtype={int, bool}, default=None A 1-dimensional array to select the columns of interest. If `None`, all columns are selected. NrRignore)rPr<warningscatch_warnings simplefilter FutureWarningrR)r?valuesrurvr-r-r0 _safe_assignis   r}c Cs|jd}t|}t|ttfr(|s(gS|dkrztt||}Wn8tk r|}zt d |d||W5d}~XYnXt | S|dkrz |j }Wntk rt dYnXt|tr|g}nlt|tr4|j|j}} |dk r||}| dk r|| d} n|d} ttt||| St|}zFg} |D]8} || } t| tjsrt d|d| | qFWn.tk r}zt d |W5d}~XYnX| St d dS) zGet feature column indices for input data X and key. For accepted values of `key`, see the docstring of :func:`_safe_indexing_column`. r)rErNz+all features must be in [0, {}] or [-{}, 0]NrZrpzSelected columns, z, are not unique in dataframez/A given column is not a column of the dataframerY)r>rarFrHrGrtr9r= IndexErrorrgrqZ atleast_1dtolistcolumnsAttributeErrorrZrPrirjZget_locrrangenumbersIntegralappendrf) r?rJZ n_columnsrKrUeZ all_columnsrrirjZcolumn_indicescolZcol_idxr-r-r0_get_column_indicessd           r)replace n_samples random_statestratifycs|}t|}t|dkrdS|d}t|dr8|jdnt|}|dkrN|}n||krj|sjtd||ft||dkr|r|jd||fdn t|| d|nt |ddd}|j dkrt d d |D}tj |d d \}} |jd} t| } ttj| d dt| dd} t| ||} gt| D](}|j| || ||d}|qB|dd |D}fdd |D}t|dkr|dS|SdS)aP Resample arrays or sparse matrices in a consistent way. The default strategy implements one step of the bootstrapping procedure. Parameters ---------- *arrays : sequence of array-like of shape (n_samples,) or (n_samples, n_outputs) Indexable data-structures can be arrays, lists, dataframes or scipy sparse matrices with consistent first dimension. replace : bool, default=True Implements resampling with replacement. If False, this will implement (sliced) random permutations. n_samples : int, default=None Number of samples to generate. If left to None this is automatically set to the first dimension of the arrays. If replace is False it should not be larger than the length of arrays. random_state : int, RandomState instance or None, default=None Determines random number generation for shuffling the data. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. stratify : array-like of shape (n_samples,) or (n_samples, n_outputs), default=None If not None, data is split in a stratified fashion, using this as the class labels. Returns ------- resampled_arrays : sequence of array-like of shape (n_samples,) or (n_samples, n_outputs) Sequence of resampled copies of the collections. The original arrays are not impacted. See Also -------- shuffle : Shuffle arrays or sparse matrices in a consistent way. Examples -------- It is possible to mix sparse and dense arrays in the same run:: >>> import numpy as np >>> X = np.array([[1., 0.], [2., 1.], [0., 0.]]) >>> y = np.array([0, 1, 2]) >>> from scipy.sparse import coo_matrix >>> X_sparse = coo_matrix(X) >>> from sklearn.utils import resample >>> X, X_sparse, y = resample(X, X_sparse, y, random_state=0) >>> X array([[1., 0.], [2., 1.], [1., 0.]]) >>> X_sparse <3x2 sparse matrix of type '<... 'numpy.float64'>' with 4 stored elements in Compressed Sparse Row format> >>> X_sparse.toarray() array([[1., 0.], [2., 1.], [1., 0.]]) >>> y array([0, 1, 0]) >>> resample(y, n_samples=2, random_state=0) array([0, 1]) Example using stratification:: >>> y = [0, 0, 1, 1, 1, 1, 1, 1, 1] >>> resample(y, n_samples=5, replace=False, stratify=y, ... random_state=0) [1, 1, 1, 0, 1] rNr>z@Cannot sample %d out of arrays with dim %d when replace is False)sizeF) ensure_2dr;r cSsg|]}d|dqS) rZ)joinastype)r.rowr-r-r0rWHszresample..T)Zreturn_inverseZ mergesort)rn)rcSs g|]}t|r|n|qSr-)rZtocsrr.ar-r-r0rW`scsg|]}t|qSr-)rtrrsr-r0rWasr)rrlr<r>rgrrandintr9r=r%rrrrIuniqueZbincountsplitZargsortZcumsum_approximate_moderchoiceextendZ permutation)rrrrarraysZ max_n_samplesfirstyclassesZ y_indicesZ n_classes class_countsZ class_indicesZn_ir[Z indices_iZresampled_arraysr-rr0r$sTU           )rrcGst|d||dS)aShuffle arrays or sparse matrices in a consistent way. This is a convenience alias to ``resample(*arrays, replace=False)`` to do random permutations of the collections. Parameters ---------- *arrays : sequence of indexable data-structures Indexable data-structures can be arrays, lists, dataframes or scipy sparse matrices with consistent first dimension. random_state : int, RandomState instance or None, default=None Determines random number generation for shuffling the data. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. n_samples : int, default=None Number of samples to generate. If left to None this is automatically set to the first dimension of the arrays. It should not be larger than the length of arrays. Returns ------- shuffled_arrays : sequence of indexable data-structures Sequence of shuffled copies of the collections. The original arrays are not impacted. See Also -------- resample : Resample arrays or sparse matrices in a consistent way. Examples -------- It is possible to mix sparse and dense arrays in the same run:: >>> import numpy as np >>> X = np.array([[1., 0.], [2., 1.], [0., 0.]]) >>> y = np.array([0, 1, 2]) >>> from scipy.sparse import coo_matrix >>> X_sparse = coo_matrix(X) >>> from sklearn.utils import shuffle >>> X, X_sparse, y = shuffle(X, X_sparse, y, random_state=0) >>> X array([[0., 0.], [2., 1.], [1., 0.]]) >>> X_sparse <3x2 sparse matrix of type '<... 'numpy.float64'>' with 3 stored elements in Compressed Sparse Row format> >>> X_sparse.toarray() array([[0., 0.], [2., 1.], [1., 0.]]) >>> y array([2, 1, 0]) >>> shuffle(y, n_samples=2, random_state=0) array([0, 1]) F)rrr)r$)rrrr-r-r0r%is B)copycCsRt|dddgdd}t|r8|r(|}|jdC_n|rF|d}n|dC}|S)aElement wise squaring of array-likes and sparse matrices. Parameters ---------- X : {array-like, ndarray, sparse matrix} copy : bool, default=True Whether to create a copy of X and operate on it or to perform inplace computation (default behaviour). Returns ------- X ** 2 : element wise square Return the element-wise square of the input. ZcsrZcscZcooF)Z accept_sparserr )rrrdata)r?rr-r-r0safe_sqrs rccs$tt||}|r|VqdSqdS)zzChunk generator, ``gen`` into lists of length ``chunksize``. The last chunk may have a length less than ``chunksize``.N)rHr)gen chunksizechunkr-r-r0_chunk_generatorsr)min_batch_sizeccst|tjstd||dkr,td|d}tt||D]*}||}|||krZq@t||V|}q@||krt||VdS)a,Generator to create slices containing `batch_size` elements from 0 to `n`. The last slice may contain less than `batch_size` elements, when `batch_size` does not divide `n`. Parameters ---------- n : int Size of the sequence. batch_size : int Number of elements in each batch. min_batch_size : int, default=0 Minimum number of elements in each batch. Yields ------ slice of `batch_size` elements See Also -------- gen_even_slices: Generator to create n_packs slices going up to n. Examples -------- >>> from sklearn.utils import gen_batches >>> list(gen_batches(7, 3)) [slice(0, 3, None), slice(3, 6, None), slice(6, 7, None)] >>> list(gen_batches(6, 3)) [slice(0, 3, None), slice(3, 6, None)] >>> list(gen_batches(2, 3)) [slice(0, 2, None)] >>> list(gen_batches(7, 3, min_batch_size=0)) [slice(0, 3, None), slice(3, 6, None), slice(6, 7, None)] >>> list(gen_batches(7, 3, min_batch_size=2)) [slice(0, 3, None), slice(3, 7, None)] z1gen_batches got batch_size=%s, must be an integerrz/gen_batches got batch_size=%s, must be positiveN)rFrrrhrgrrNrP)nZ batch_sizerri_endr-r-r0 gen_batchess%    r)rccszd}|dkrtd|t|D]T}||}|||kr@|d7}|dkr ||}|dk rbt||}t||dV|}q dS)aGenerator to create `n_packs` evenly spaced slices going up to `n`. If `n_packs` does not divide `n`, except for the first `n % n_packs` slices, remaining slices may contain fewer elements. Parameters ---------- n : int Size of the sequence. n_packs : int Number of slices to generate. n_samples : int, default=None Number of samples. Pass `n_samples` when the slices are to be used for sparse matrix indexing; slicing off-the-end raises an exception, while it works for NumPy arrays. Yields ------ `slice` representing a set of indices from 0 to n. See Also -------- gen_batches: Generator to create slices containing batch_size elements from 0 to n. Examples -------- >>> from sklearn.utils import gen_even_slices >>> list(gen_even_slices(10, 1)) [slice(0, 10, None)] >>> list(gen_even_slices(10, 10)) [slice(0, 1, None), slice(1, 2, None), ..., slice(9, 10, None)] >>> list(gen_even_slices(10, 5)) [slice(0, 2, None), slice(2, 4, None), ..., slice(8, 10, None)] >>> list(gen_even_slices(10, 3)) [slice(0, 4, None), slice(4, 7, None), slice(7, 10, None)] rrz+gen_even_slices got n_packs=%s, must be >=1N)rgrminrP)rZn_packsrriZpack_numZthis_nrr-r-r0gen_even_slicess&    rcCs0t|tjrt|St|tr$|St|SdS)aCast iterable x to a Sequence, avoiding a copy if possible. Parameters ---------- x : iterable The iterable to be converted. Returns ------- x : Sequence If `x` is a NumPy array, it returns it as a `ndarray`. If `x` is a `Sequence`, `x` is returned as-is. If `x` is from any other type, `x` is returned casted as a list. N)rFr9Zndarrayr:rrHxr-r-r0 tosequenceCs    rcCs"tjt|td}||dd<|S)avConvert sequence to a 1-D NumPy array of object dtype. numpy.array constructor has a similar use but it's output is ambiguous. It can be 1-D NumPy array of object dtype if the input is a ragged array, but if the input is a list of equal length arrays, then the output is a 2D numpy.array. _to_object_array solves this ambiguity by guarantying that the output is a 1-D NumPy array of objects for any input. Parameters ---------- sequence : array-like of shape (n_elements,) The sequence to be converted. Returns ------- out : ndarray of shape (n_elements,), dtype=object The converted sequence into a 1-D NumPy array of object dtype. Examples -------- >>> import numpy as np >>> from sklearn.utils import _to_object_array >>> _to_object_array([np.array([0]), np.array([1])]) array([array([0]), array([1])], dtype=object) >>> _to_object_array([np.array([0]), np.array([1, 2])]) array([array([0]), array([1, 2])], dtype=object) >>> _to_object_array([np.array([0]), np.array([1, 2])]) array([array([0]), array([1, 2])], dtype=object) r;N)r9emptyrlobject)sequenceoutr-r-r0_to_object_arrayZs rcCs0|t|krtdtj|td}d||<|S)aSConvert list of indices to boolean mask. Parameters ---------- indices : list-like List of integers treated as indices. mask_length : int Length of boolean mask to be generated. This parameter must be greater than max(indices). Returns ------- mask : 1d boolean nd-array Boolean array that is True where indices are present, else False. Examples -------- >>> from sklearn.utils import indices_to_mask >>> indices = [1, 2 , 3, 4] >>> indices_to_mask(indices, 5) array([False, True, True, True, True]) z-mask_length must be greater than max(indices)rT)r9maxrgrCrE)rsZ mask_lengthr@r-r-r0r!~s cCsXd|}|dkrd|d}nd|}d||f}dt|t|}d||d|fS) zCreate one line message for logging purposes. Parameters ---------- source : str String indicating the source or the reference of the message. message : str Short message. time : int Time in seconds. z[%s] <z%4.1fminz %5.1fsz %s, total=%sFz%s%s%s.)rl)sourcemessagetimeZ start_messageZtime_strZ end_messageZdots_lenr-r-r0_message_with_times rccs:|dkrdVn&t}dVtt||t|dS)ajLog elapsed time to stdout when the context is exited. Parameters ---------- source : str String indicating the source or the reference of the message. message : str, default=None Short message. If None, nothing will be printed. Returns ------- context_manager Prints elapsed time upon exit if verbose. N)timeitZ default_timerprintr)rrrir-r-r0_print_elapsed_times r) max_n_rowsworking_memorycCs`|dkrtd}t|d|}|dk r4t||}|dkr\td|t|dfd}|S)aCalculate how many rows can be processed within `working_memory`. Parameters ---------- row_bytes : int The expected number of bytes of memory that will be consumed during the processing of each row. max_n_rows : int, default=None The maximum return value. working_memory : int or float, default=None The number of rows to fit inside this number of MiB will be returned. When None (default), the value of ``sklearn.get_config()['working_memory']`` is used. Returns ------- int The number of rows which can be processed within `working_memory`. Warns ----- Issues a UserWarning if `row_bytes exceeds `working_memory` MiB. NrirzOCould not adhere to working_memory config. Currently %.0fMiB, %.0fMiB required.g>)rrNrrxwarnr9ceil)Z row_bytesrrZ chunk_n_rowsr-r-r0get_chunk_n_rowss  rc Cs4tt"ddlm}||kW5QRSQRXdS)aTest if x is pandas.NA. We intentionally do not use this function to return `True` for `pd.NA` in `is_scalar_nan`, because estimators that support `pd.NA` are the exception rather than the rule at the moment. When `pd.NA` is more universally supported, we may reconsider this decision. Parameters ---------- x : any type Returns ------- boolean r)NAF)r ImportErrorpandasr)rrr-r-r0 _is_pandas_nas  rcCst|tjot|S)a}Test if x is NaN. This function is meant to overcome the issue that np.isnan does not allow non-numerical types as input, and that np.nan is not float('nan'). Parameters ---------- x : any type Any scalar value. Returns ------- bool Returns true if x is NaN, and false otherwise. Examples -------- >>> import numpy as np >>> from sklearn.utils import is_scalar_nan >>> is_scalar_nan(np.nan) True >>> is_scalar_nan(float("nan")) True >>> is_scalar_nan(None) False >>> is_scalar_nan("") False >>> is_scalar_nan([np.nan]) False )rFrRealmathisnanrr-r-r0 is_scalar_nansrc Cst|}|||}t|}t||}|dkr||}tt|ddd}|D]V}t||k\} tt | |} |j | | dd} || d7<|| 8}|dkr`qq`| tS)aComputes approximate mode of multivariate hypergeometric. This is an approximation to the mode of the multivariate hypergeometric given by class_counts and n_draws. It shouldn't be off by more than one. It is the mostly likely outcome of drawing n_draws many samples from the population given by class_counts. Parameters ---------- class_counts : ndarray of int Population per class. n_draws : int Number of draws (samples to draw) from the overall population. rng : random state Used to break ties. Returns ------- sampled_classes : ndarray of int Number of samples drawn from each class. np.sum(sampled_classes) == n_draws Examples -------- >>> import numpy as np >>> from sklearn.utils import _approximate_mode >>> _approximate_mode(class_counts=np.array([4, 2]), n_draws=3, rng=0) array([2, 1]) >>> _approximate_mode(class_counts=np.array([5, 2]), n_draws=4, rng=0) array([3, 1]) >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), ... n_draws=2, rng=0) array([0, 1, 1, 0]) >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), ... n_draws=2, rng=42) array([1, 1, 0, 0]) rNrF)rrr) rsumr9floorrNsortrwhererrlrr) rZn_drawsrngZ continuousZflooredZ need_to_add remainderr|valueZindsZadd_nowr-r-r0r5s ( rc CsDz ddl}Wn2tk r>}ztd||W5d}~XYnXdS)aKRaise ImportError with detailed error message if mpl is not installed. Plot utilities like any of the Display's plotting functions should lazily import matplotlib and call this helper before any computation. Parameters ---------- caller_name : str The name of the caller that requires matplotlib. rNzP{} requires matplotlib. You can install matplotlib with `pip install matplotlib`) matplotlibrrq) caller_namerrr-r-r0r&zs  c CsFzddl}|WStk r@}ztd||W5d}~XYnXdS)asRaise ImportError with detailed error message if pandas is not installed. Plot utilities like :func:`fetch_openml` should lazily import pandas and call this helper before any computation. Parameters ---------- caller_name : str The name of the caller that requires pandas. Returns ------- pandas The pandas package. rNz{} requires pandas.)rrrq)rrrr-r-r0check_pandas_supports r)T)N)V__doc__collections.abcr contextlibr itertoolsrrrrplatformstructrrrxr4r9Z scipy.sparserZ murmurhashr Z class_weightr r r exceptionsr deprecationrZ discoveryrfixesrrZ_estimator_html_reprrZ validationrrrrrrrrrrrrZ_bunchr r"r#__all__python_implementationZIS_PYPYcalcsizeZ _IS_32BITr8rBrDrMrTrXrartr}rr$r%rrrrrrr!rrrrrrr&rr-r-r-r0s            4   !%  FL%EG 65$  )"E