3;ji dZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z ddl mZddl mZddlmZddlmZddlmZd gZd d hZd>d Zd>dZdZdZdZd efddZdZ dZ!dZ"d?dZ#d efddZ$d efdddZ%d efdddZ&dZ'd?dZ(dZ)dZ*d Z+d!Z,d"Z-d#Z.d@d$Z/dAd&Z0d?d'Z1dBd(Z2dBd)Z3dBd*Z4dCd+Z5 dDddd,d-Z6d?d.Z7d/Z8d0Z9d1Z:d2Z;dEd3Zdd6d7Z?dDd8Z@d?d9ZAdBd:ZBd;ZCd<ZDdBd=ZEdS)GzTools to support array_api.N) get_config)array_api_compat)array_api_extra)numpy)is_df_or_series) parse_versionxpxrz(sklearn.externals.array_api_compat.numpyTc#4KdD]}|s |tvr|VdS)a7Yield supported namespace. This is meant to be used for testing purposes only. Parameters ---------- include_numpy_namespaces : bool, default=True If True, also yield numpy namespaces. Returns ------- array_namespace : str The name of the Array API namespace. )rarray_api_strictcupytorchN)_NUMPY_NAMESPACE_NAMES)include_numpy_namespacesarray_namespaces R/root/voice-cloning/.venv/lib/python3.11/site-packages/sklearn/utils/_array_api.pyyield_namespacesrsH   ( O?U,U,U   c#ZKt|D]}|dkr*tjddD] \}}|||fV |ddfV2|dkrX dd l}||d d fV||d dfVr#t $r|d d fV|d dfVYwxYw|d d fVd S) aYield supported namespace, device, dtype tuples for testing. Use this to test that an estimator works with all combinations. Use in conjunction with `ids=_get_namespace_device_dtype_ids` to give clearer pytest parametrization ID names. Parameters ---------- include_numpy_namespaces : bool, default=True If True, also yield numpy namespaces. Returns ------- array_namespace : str The name of the Array API namespace. device : str The name of the device on which to allocate the arrays. Can be None to indicate that the default value should be used. dtype_name : str The name of the data type to use for arrays. Can be None to indicate that the default value should be used. )rr )cpucudaxpufloat64float32mpsrr rN CPU_DEVICErdevice1)r itertoolsproductr Device ImportError)rrdevicedtyper s r)yield_namespace_device_dtype_combinationsr$;sY2,!9.. g % %!*!2&(>"" 5 5 &vu44444!5)3 3 3 3 3  2 2 2 <''''%'7'>'>|'L'LiWWWW%'7'>'>y'I'I9TTTTT < < <&|Y>>>>%y);;;;;;  <"4- - - - -/..s 8BB B c ddl}||dkrdS||dkrdS||dkrdSdS#t$rYdSwxYw)zNGet pytest parametrization IDs for `yield_namespace_device_dtype_combinations`rNrrdevice2)r r r!)paramr s r_get_namespace_device_dtype_idsr(ns  $++L99 9 9< $++I66 6 69 $++I66 6 69 7 6 ttsA A'&A'c|sdSttj}d}|t|krtd|dtjddkrtddS)zChecks that array API support is functional. In particular scipy needs to be recent enough and the environment variable needs to be set: SCIPY_ARRAY_API=1. Nz1.14.0zSciPy must be zY or newer (found {scipy.__version__}) to dispatch array using the array API specificationSCIPY_ARRAY_API1zScikit-learn array API support was enabled but scipy's own support is not enabled. Please set the SCIPY_ARRAY_API=1 environment variable before importing sklearn or scipy. More details at: https://docs.scipy.org/doc/scipy/dev/api-dev/array_api.html)rscipy __version__r!osenvironget RuntimeError)array_api_dispatch scipy_versionmin_scipy_versions r_check_array_api_dispatchr5s !%"344M }%67777 +. + + +    z~~'((C// J   0/rc\t|drtdsdS|jS)z0Hardware device where the array data resides on.r"r2N)hasattrrr")arrays r_single_array_devicer9s9 E8 $ $ ||01 t|r remove_none remove_typesct|||d}|sdSt|d}|ddD],}t|}||krtd|d|-|S)aDHardware device where the array data resides on. If the hardware device is not the same for all arrays, an error is raised. Parameters ---------- *array_list : arrays List of array instances from NumPy or an array API compatible library. remove_none : bool, default=True Whether to ignore None objects passed in array_list. remove_types : tuple or list, default=(str,) Types to ignore in array_list. Returns ------- out : device `device` object (see the "Device Support" section of the array API spec). r:Nrz$Input arrays use different devices: z, )_remove_non_arraysr9 ValueError)r;r< array_listdevice_r8 device_others rr"r"s*$ <J t":a=11G ABB+E22 l " "PwPP,PP  # Nrc4tj|jS)zReturn the total number of elements of x. Parameters ---------- x : array Array instance from NumPy or an array API compatible library. Returns ------- out : int Total number of elements. )mathprodshape)xs rsizerIs 9QW  rc|jtvS)z%Return True if xp is backed by NumPy.)__name__rxps r_is_numpy_namespacerNs ;0 00rctt|r?ddlm}||||\}}|t j||S|j|jcxkrdksnJ||||||gS)Nr) cached_uniquerLr>) rNsklearn.utils._uniquerPasarrayrunion1dndim unique_valuesconcat)abrMrPa_uniqueb_uniques r_union1dr[s2=777777*]1aB777(zz%-(;;<<< 6QV q  BIIr'7'7':':B>  # #  % %k)&< = = =r9.!!"*--- # $ $$rcg}t|}|D]R}|r|t||rtj|r-t |r=||S|S)aFilter arrays to exclude None and/or specific types. Sparse arrays are always filtered out. Parameters ---------- *arrays : array objects Array objects. remove_none : bool, default=True Whether to ignore None objects passed in arrays. remove_types : tuple or list, default=(str,) Types to ignore in the arrays. Returns ------- filtered_arrays : list List of arrays filtered as requested. An empty list is returned if no input passes the filters. )rc isinstancespissparserrb)r;r<arraysfiltered_arraysr8s rr?r?%s,O&&L & &  5=  e\ * *   ;u     5 ! !  u%%%% r)r;r<rMc0td}|s||dfStdfS||dfSt|||d}|s tdfSt|t j|d}}|jdkr&t|dr|d ||fS) aGet namespace of arrays. Introspect `arrays` arguments and return their common Array API compatible namespace object, if any. Note that sparse arrays are filtered by default. See: https://numpy.org/neps/nep-0047-array-api-standard.html If `arrays` are regular numpy arrays, `array_api_compat.numpy` is returned instead. Namespace support is not enabled by default. To enabled it call: sklearn.set_config(array_api_dispatch=True) or: with sklearn.config_context(array_api_dispatch=True): # your code here Otherwise `array_api_compat.numpy` is always returned irrespective of the fact that arrays implement the `__array_namespace__` protocol or not. Note that if no arrays pass the set filters, ``_NUMPY_API_WRAPPER_INSTANCE, False`` is returned. Parameters ---------- *arrays : array objects Array objects. remove_none : bool, default=True Whether to ignore None objects passed in arrays. remove_types : tuple or list, default=(str,) Types to ignore in the arrays. xp : module, default=None Precomputed array namespace module. When passed, typically from a caller that has already performed inspection of its own inputs, skips array namespace inspection. Returns ------- namespace : module Namespace shared by array objects. If any of the `arrays` are not arrays, the namespace defaults to the NumPy namespace. is_array_api_compliant : bool True if the arrays are containers that implement the array API spec (see https://data-apis.org/array-api/latest/index.html). Always False when array_api_dispatch=False. r2NFTr:r set_array_api_strict_flagsz2024.12) api_version) r np_compatr?r5r get_namespacerKr7ro)r;r<rMrlr2 namespaceis_array_api_compliants rrrrrKsn$&:; $ >u9 e# # ~4x  !F  %0111(8(F(OQU%I///G/55/ ,,,CCC , ,,rctdg}t|||d}t|i|}|t|i|\}}n|d}}|r|||fS|d|fS)aCombination into one single function of `get_namespace` and `device`. Parameters ---------- *array_list : array objects Array objects. remove_none : bool, default=True Whether to ignore None objects passed in arrays. remove_types : tuple or list, default=(str,) Types to ignore in the arrays. xp : module, default=None Precomputed array namespace module. When passed, typically from a caller that has already performed inspection of its own inputs, skips array namespace inspection. Returns ------- namespace : module Namespace shared by array objects. If any of the `arrays` are not arrays, the namespace defaults to NumPy. is_array_api_compliant : bool True if the arrays are containers that implement the Array API spec. Always False when array_api_dispatch=False. device : device `device` object (see the "Device Support" section of the array API spec). Fr:NT)dictr?r"rr)r;r<rMrAskip_remove_kwargs arrays_device is_array_apis rget_namespace_and_devicerzs:%bAAA# !J J=*<==M z(*K8JKKLLtL(<..5-''rcld|D}d|D}t|rt|stdg}t|||D]1\}}}|r|d|r||7t |\} } } || kr|| kr||l |||} n#tttttf$rqt|rt|| } nNt| r| ||} n't|| } | | |} YnwxYw|| 3t|dkr|dnt|S)aJMove all arrays to `xp` and `device`. Each array will be moved to the reference namespace and device if it is not already using it. Otherwise the array is left unchanged. `array` may contain `None` entries, these are left unchanged. Sparse arrays are accepted (as pass through) if the reference namespace is NumPy, in which case they are returned unchanged. Otherwise a `TypeError` is raised. Parameters ---------- *arrays : iterable of arrays Arrays to (potentially) move. xp : namespace Array API namespace to move arrays to. device : device Array API device to move arrays to. Returns ------- arrays : tuple or array Tuple of arrays with the same namespace and device as reference. Single array returned if only one `arrays` input. c6g|]}tj|S)rjrk.0r8s r zmove_to..s":::%2;u%%:::rcg|]}|duSNr}r~s rrzmove_to..s3335$333rzWSparse arrays are only accepted (and passed through) when the target namespace is NumpyNr"r>r)anyrN TypeErrorziprbrz from_dlpackAttributeErrorNotImplementedError BufferErrorr@_convert_to_numpyrRlenrc)rMr"rl sparse_mask none_maskconverted_arraysr8 is_sparseis_nonexp_array_ device_arrayarray_convertedarray_nps rmove_tors:;:6:::K33F333I ; 3B 7 7  !   %(i%H%H2929!y' 1 9  # #D ) ) ) ) / 9  # #E * * * *(@(G(G %HaX~~&L"8"8 ''....'N')nnU6n&J&JOO#' NNN+2.. N*;E8*L*L,X66N*,**U6**J*J $5UH#E#E*,**Xf**M*M'N(!''8888 ##34499uEU?V?VsCBE21E2ct||\}}t|r9|tjt j|Sdd|| zz S)NrLg?)rrrNrRspecialexpitrexp)XrMrs r_expitr2sj ! # # #EB2;zz'- a(8(899::: #r " ##rc|jdkr$tdt|j|||jt |}|jdvrtd|jdt|j}|jdkr1|jd|kr td |d |jd||fS) z:Validate arguments to `_fill_diagonal`/`_add_to_diagonal`.z+`array` should be 2D. Got array with shape r#r")rr>z2`value` needs to be a scalar or a 1D array, got a zD array instead.r>rzX`value` needs to be a scalar or 1D array of the same length as the diagonal of `array` (z). Got )rTr@rcrGrRr#r"min)r8valuerMmin_rows_columnss r_validate_diagonal_argsr:s zQ N% :L:L N N    JJuEKu J F FE z 2Z 2 2 2   5;'' zQ5;q>-=== N$4 N N=B[^ N N   " ""rc t|||\}}t|r|||ddS|jdkrt |D] }||||f< dSt |D]}|||||f<dS)aMinimal implementation of `numpy.fill_diagonal`. `wrap` is not supported (i.e. always False). `value` should be a scalar or 1D of greater or equal length as the diagonal (i.e., `value` is never repeated when shorter). Note `array` is altered in place. F)wraprN)rrN fill_diagonalrTrange)r8rrMris r_fill_diagonalrQs6eUBGGE 2 ' E22222 :??+,, $ $#ad  $ $+,, ' '#Ahad  ' 'rcNt|||\}}t|rE|jddz}|jd|jdz}|jd||xx|z cc<dS|j||z}t |D]}|||||f<dS)zAdd `value` to diagonal of `array`. Related to `fill_diagonal`. `value` should be a scalar or 1D of greater or equal length as the diagonal (i.e., `value` is never repeated when shorter). Note `array` is altered in place. r>N)rrNrGflatlinalgdiagonalr)r8rrMrstependrs r_add_to_diagonalrks6eUBGGE 2{1~!k!nu{1~- 9C9& I  u % % -E # $ $Ahad rc&|j|d|d|fvS)Nzarray_api_compat.z#sklearn.externals.array_api_compat.)rK)rMnames r_is_xp_namespacers/ ; "D""4d44 rct|dr)t|dr|jS|jS)zJReturn the float dtype with the highest precision supported by the device.r r)rstr startswithrrrMr"s r_max_precision_float_dtypersHG$$V)?)? **z :rcfd|D}fd|D}|r j|SdjS)aFind a suitable floating point dtype when computing with arrays. If any of the arrays are floating point, return the dtype with the highest precision by following official type promotion rules: https://data-apis.org/array-api/latest/API_specification/type_promotion.html If there are no floating point input arrays (all integral inputs for instance), return the default floating point dtype for the namespace. cZg|]'}t|d|(Sr#)r7rRrrWrMs rrz1_find_matching_floating_dtype..s2JJJqga6I6IJRZZ]]JJJrcTg|]$}|jd|j%S)r])isdtyper#rs rrz1_find_matching_floating_dtype..s@"**QWo*N*N r) result_typerRr#)rMrl dtyped_arraysfloating_dtypess` r_find_matching_floating_dtypersuKJJJFJJJM&O0r~// ::c??  rc ~t|||\}}}t|rX|r*|tj|||S|*|(|tj||S|||}||||}||j|jkr|:tdt|jdt|jdt|j|j|fkr=tdt|jd t|jd |d d g|j z}|j|||<| |t|}| |j d rtd|*| |j d rtdt|||}|||}||r|jn|j||S|||}|||||} |s| S|||} || dkrt+d| | z S)aPartial port of np.average to support the Array API. It does a best effort at mimicking the return dtype rule described at https://numpy.org/doc/stable/reference/generated/numpy.average.html but only for the common cases needed in scikit-learn. rL)axisweightsNrz+Axis must be specified when the shape of a z and weights z differ.zShape of weights weights.shape=z! must be consistent with a.shape=z and axis=.r>zcomplex floatingz;Complex floating point values are not supported by average.rrz(Weights sum to zero, can't be normalized)rzrNrRraveragedotrGrrcr@rTreshaperr#rrastypemeansummultiplyrZeroDivisionError) rWrr normalizerMrrBrG output_dtypesum_scales r_averagers.aR@@@NB725  5::emAD'JJJKK K \g1::ei73344 4 1W %%A**WW*55qw'-77 <:eAGnn:: //:::    AGDM#3 3 3I% 2F2FII+0>>II@DIII  af gdmd **WeEll33 zz!'-.. ! I   rzz'-9KLL! I   1GCCCL !\""A090"&!$????ii..G 66"++a))6 5 5D  FF7F & &E vveslL JKKK %<rFcPt||\}}}tj|r||d||St |dr||||St ||}|tj||||S)NrLg?)qdimkeepdimmedianrkeepdimsr) rzris_torch_namespacequantiler7rrrRr)rHrrrMrr"x_nps r_medianrs-Q2666MB6*2..A{{1x{@@@r8:yyy999 Q2 & & &D ::el4dXFFFv: V VVrc&t|||\}}}tjdd5|||z}dddn #1swxYwY||dk|d|j||S)NrLignore)divideinvalidrr)rzrerrstatelogwhererRr#)rHyrMrrBtemps r_xlogyr s-ar:::NB7 x : : :266!99} 88AHbjjDJwjOOQU V VVsAAAc *t||\}}}t|r)|tj||S||}|||||j |j |||}| ||}| |r7||||j |j ||}|SNrLrr) rzrNrRrnanminisnanrrinfr#allrnanrrrMrrBmasks r_nanminr.aB777NB72 zz%,qt444555xx{{ FF HHT2::rvgQWW:MMq Q Q    vvdv&& 66$<< Urzz"&zPPRSTTArc *t||\}}}t|r)|tj||S||}|||||j |j |||}| ||}| |r7||||j |j ||}|Sr) rzrNrRrnanmaxrmaxrrr#rrrrs r_nanmaxr)rrc t||\}}}t|r)|tj||S||}||||d|j|||}|| | ||j|}||z S)NrLrrr) rzrNrRrnanmeanrrrr#r logical_not)rrrMrrBrtotalcounts r_nanmeanr=s.aB777NB72zz%-555666xx{{ HHT2::c:II1 M MTX  ryy!5!5qw??dKKu}rc`t||\}}}t|r+|tj||||S||}|||d||j|}|||||S)NrLrrr#rr"r#) rzrNrRrnansumrrr#r) rrrMrr#rX_devicer masked_arrs r_nansumrLs/qR888OB82Vzz%,qtheTTTUUU 88A;;D$ 1XQW M MqQQJ 66*4(%6 H HHrrc t||\}}t|rH|durtj|||}ntj|||}||S|||||S)aHelper to support the order kwarg only for NumPy-backed arrays Memory layout parameter `order` is not exposed in the Array API standard, however some input validation code in scikit-learn needs to work both for classes and functions that will leverage Array API only operations and for code that inherently relies on NumPy backed data containers with specific memory layout constraints (e.g. our own Cython code). The purpose of this helper is to make it possible to share code for data container validation without memory copies for both downstream use cases: the `order` parameter is only enforced if the input array implementation is NumPy based, otherwise `order` is just silently ignored. rLT)orderr#)r#copyr")rrrNrr8rR)r8r#r r rMr"rs r_asarray_with_orderr Ys %B ' ' 'EB2 H 4<<KU%@@@EEM%uEBBBEzz%   zz%u4zGGGrct||\}}t|r=tj|}|tj|dS||dS)zArray API compliant version of np.ravel. For non numpy namespaces, it just returns a flattened array, that might be or not be a copy. rLC)r )rG)rrrNrrRravelr)r8rMrs r_ravelrwsp %B ' ' 'EB29 e$$zz%+e3777888 ::e5: ) ))rcvt|dr&|St|dr|St|dr`__. Parameters ---------- estimator : Estimator Estimator to convert converter : callable Callable that takes an array attribute and returns the converted array. Returns ------- new_estimator : Estimator Convert estimator r)clone __dlpack__) sklearn.baservarsitemsr7rirndarraysetattr) estimator converterr new_estimatorkey attributes r _estimator_with_converted_arraysr s&#"""""E)$$My////11//Y 9l + + -z)U]/S/S -! ),,I sI.... rcV| tj}tj|jdzS)z6Return the absolute tolerance for a given numpy dtype.Ni)rrfinfoeps)dtype_or_dtype_names r_atol_for_typer%s+"$m ;* + + /$ 66rc6|djS)aMReturn a platform-specific integer dtype suitable for indexing. On 32-bit platforms, this will typically return int32 and int64 otherwise. Note: using dtype is recommended for indexing transient array datastructures. For long-lived arrays, such as the fitted attributes of estimators, it is instead recommended to use platform-independent int32 if we do not expect to index more 2B elements. Using fixed dtypes simplifies the handling of serialized models, e.g. to deploy a model fit on a 64-bit platform to a target 32-bit platform such as WASM/pyodide. r)rRr#rLs rindexing_dtyper's* ::a== rc ,t|r+|tj||||S|j}||d}||d}|t ||||||S)zCalculates ``element in test_elements``, broadcasting over `element` only. Returns a boolean array of the same shape as `element` that is True where an element of `element` is in `test_elements` and False otherwise. )element test_elements assume_uniqueinvertr)ar1ar2rMr+r,)rNrRrisinrGr_in1d)r)r*rMr+r,original_element_shapes r_isinr2s2 zz J++       %]jj%((GJJ}e44M :: '        rct|||\}}|jdd|jddzzkr|rD||jd|jt |}|D] }|||kz} nC||jd|jt |}|D] }|||kz} |S|s-||\}}||}|||f} t | } | | d} | | d} | | | d} t| d kr/|r| d d | d d kn| d d | d d k}n.|r| d gn| dg}||| |g| f}| || d}|r|d |jdS| ||dS)aChecks whether each element of an array is also present in a second array. Returns a boolean array the same length as `ar1` that is True where an element of `ar1` is in `ar2` and False otherwise. This function has been adapted using the original implementation present in numpy: https://github.com/numpy/numpy/blob/v1.26.0/numpy/lib/arraysetops.py#L524-L758 rLr g(\?rT)stablerr>NrFr) rrrGonesboolr"zerosunique_inverserUrVargsorttakerIrR)r-r.rMr+r,rrrWrev_idxarrBr  reverse_ordersarbool_arflagrets rr0r0sY #sr * * *EB y|b39Q<50000  !7739QSYq\>""wwsG!w,,,rc0ddlm}t|||\}}t|r"t j|r||||S|jdksJ|||}|X|||}| ||j ddf}| ||j |z}|d||j }| ||dk||| S) zA variant of `sklearn.utils.sparsefuncs.count_nonzero` for the Array API. If the array `X` is sparse, and we are using the numpy namespace then we simply call the original function. This function only supports 2D arrays. r) count_nonzerorL)r sample_weightrrNr>rr)sklearn.utils.sparsefuncsrDrrrNrjrkrT ones_likerRrrGrr#rr) rrrErMr"rDrr zero_scalars r_count_nonzerorI#s# 877777 !]r 2 2 2EB2H2;q>>H}QTGGGG 6Q;;;;ll1Vl,,G  = @@  ==3Fq3I12MNN ))G]%899MI**QvW]*CCK 66"((167K88t6 D DDr)outcJt|r ||d|i|n||i|}|S)NrJ)rN)rMfuncrJargskwargss r_modify_in_place_if_numpyrO;sH2$ d&&v&&&&dD#F## Jrc>t||\}}t|dr||||St||}|t||}nd}t j|||}||t |S)NrLbincount)r minlengthr)rrr7rQrrrRr")r8rrRrMrr weights_npbin_outs r _bincountrUCs %B ' ' 'EBr:H{{5'Y{GGG 2...H&w2666  nXzYOOOG ::gfUmm: 4 44rct||\}}t|r|St||}d|DS)NrLc6g|]}|Sr})item)rr)s rrz_tolist..Xs 3 3 3wGLLNN 3 3 3r)rrrNtolistr)r8rMrrs r_tolistrZSs\ %B ' ' 'EB2||~~ 2...H 3 3( 3 3 33rc t||\}}}|!tt|jn|}t |}|j|vr|||d}|||d}||k}||d}|j ||<| ||j}| ||d|j} | | |||d|j|} | || z } | | |d| j} | | dk| | | z } || || z|z} || | } | jdkr| d n| } | S) NrLrrTr)r rrrr})rzrcrrTrgr#rRrrrrrisfiniterlog1prsqueeze)r8rrMrr"supported_dtypes array_max index_maxi_max_dtmshiftrsrJs r _logsumexprf[s -Ur:::MB6'+|5uz"" # # #D-b11 {*** 5(8(; <<u4$77I"I JJu4J ( (EwE)yyEK00H xdTEEA HH I 1IOF ;;  E &&  C sCI>>A aAE""A ((1++q !I -C **St* $ $CX]]#b''C Jrct|r!tj|dS|j|SNT)lower)rNr,rcholesky) covariancerMs r _choleskyrl~sC2.|$$Zt$<<<y!!*---rct|r"tj||dS|j||Srh)rNr,rsolve_triangularsolve)cov_chol eye_matrixrMs r _linalg_solverrsE25|,,Xz,NNNyx444rczt|||\}}}t|d|}|||j|}||jd||jdz}|t|||z}tt||z ||S)zGA version of the multinomial loss that is compatible with the array APIr>)rrMrrr)rrM) rzrfrRint64arangerGr;rfloatr) rpredrErMrrB log_sum_exp class_marginslabel_predictionss r_half_multinomial_lossr{s-a}EENB7Tb111K 1BHW 55AIIagajI99DJqMIMt a-.?@@ 00-BOOO  r)Tr)NNTN)NFN)NN)NNFN)NNN)FF)NNNN)F__doc__rrEr.rr, scipy.sparsesparserj scipy.specialrsklearn._configrsklearn.externalsrrr "sklearn.externals.array_api_compatrqsklearn.utils._dataframersklearn.utils.fixesr__all__rrr$r(r5r9rr"rIrNr[rgr?rrrzrrrrrrrrrrrrrrrr rrr r%r'r2r0rIrOrUrZrfrlrrr{r}rrrs!!  &&&&&&......444444AAAAAA444444------ '!#MN>0.0.0.0.f"   6    %)v)))))X    111 SSS,%,%,%,%^-1v#####L(,3&TS-S-S-S-S-n"4.(.(.(.(.(b]]]@$$$$###.'''46!!!2????DWWWW0WWWW((     I I I I)-H48HHHHH< * * * *    :7770D.-.-.-.-bEEEE048 5 5 5 5 4444    F...555      r