T.hvddlmZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddl"m#Z#ddl"m$Z$e rSddl%m&Z&ddl'Z(dd l)m*Z*dd!l)m+Z+dd"l,m-Z-dd#l,m.Z.dd$l/m0Z0dd%l1m2Z2dd&l1m3Z3dd'l1m4Z4e d(ee.e e-e e0e f)Z5Gd*d+eZ6Gd,d-eZ7dHd.Z8dId/Z9dJd0Z:dKd1Z;dLd2ZdOd5Z?dPd6Z@ dQd7ZAdRd8ZB dSdd9 dTd:ZCdUd;ZD dVd<ZE dWd=ZFdXd>ZGdYd?ZHdZd@ZIdZdAZJ d[dBZKd\dCZLd]dDZMd^dEZN d_dFZO d`dGZPy)a) annotationsN)Enum)auto) token_hex) TYPE_CHECKING)Any)Iterable)Sequence)TypeVar)Union)cast)warn)get_cudf)get_dask_dataframe) get_modin) get_pandas) get_polars) get_pyarrow)get_pyspark_sql)is_cudf_series)is_modin_series)is_pandas_dataframe)is_pandas_like_dataframe)is_pandas_like_series)is_pandas_series)is_polars_series)is_pyarrow_chunked_array)ColumnNotFoundError)InvalidOperationError) ModuleType)Self) TypeGuard DataFrame LazyFrameSeries)DTypes) IntoSeriesT)SizeUnitFrameOrSeriesT)boundc(eZdZeZeZy)VersionN)__name__ __module__ __qualname__rV1MAINb/var/www/html/School_Mangement_New/src/backend/venv/lib/python3.12/site-packages/narwhals/utils.pyr/r/5s B 6Dr6r/ceZdZdZeZ eZ eZ eZ eZ eZ eZ eZ e d dZddZddZddZddZddZddZdd Zdd Zdd Zy )Implementationz?Implementation of native object (pandas, Polars, PyArrow, ...).cttjttjt tj ttjttjttjttji}|j|tj S)zInstantiate Implementation object from a native namespace module. Arguments: native_namespace: Native namespace. Returns: Implementation. )rr9PANDASrMODINrCUDFrPYARROWrPYSPARKrPOLARSrDASKgetUNKNOWN)clsnative_namespacemappings r7from_native_namespacez$Implementation.from_native_namespaceOs L.// K-- J++ M>11  ~55 L.//  ."5"5 {{+^-C-CDDr6c`tjttjt tj t tjttjttjttjti}||S)zyReturn the native namespace module corresponding to Implementation. Returns: Native module. )r9r;rr<rr=rr>rr?rr@rrAr)selfrFs r7to_native_namespacez"Implementation.to_native_namespacefsu  ! !:<  )+     " "KM  " "O$5  ! !:<   !3!5 t}r6c&|tjuS)a^Return whether implementation is pandas. Returns: Boolean. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pandas() True )r9r;rIs r7 is_pandaszImplementation.is_pandasw~,,,,r6cd|tjtjtjhvS)asReturn whether implementation is pandas, Modin, or cuDF. Returns: Boolean. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pandas_like() True )r9r;r<r=rLs r7is_pandas_likezImplementation.is_pandas_likes(--~/C/C^EXEXYYYr6c&|tjuS)a^Return whether implementation is Polars. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_polars() True )r9r@rLs r7 is_polarszImplementation.is_polarsrNr6c&|tjuS)a[Return whether implementation is cuDF. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_cudf() False )r9r=rLs r7is_cudfzImplementation.is_cudf~****r6c&|tjuS)a]Return whether implementation is Modin. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_modin() False )r9r<rLs r7is_modinzImplementation.is_modins~++++r6c&|tjuS)aaReturn whether implementation is PySpark. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pyspark() False )r9r?rLs r7 is_pysparkzImplementation.is_pyspark~----r6c&|tjuS)aaReturn whether implementation is PyArrow. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pyarrow() False )r9r>rLs r7 is_pyarrowzImplementation.is_pyarrowrZr6c&|tjuS)a[Return whether implementation is Dask. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_dask() False )r9rArLs r7is_daskzImplementation.is_daskrUr6N)rDz type[Self]rEr returnr9)rIr!r_r )r_bool)r0r1r2__doc__rr;r<r=r>r?r@rArC classmethodrGrJrMrPrRrTrWrYr\r^r5r6r7r9r9:sI VF FE 6DfG!fG! VF 6DfG!E E+5E EE,"- Z - + , . . +r6r9c|tjurddlm}|S|tjurddlm}|Sd|}t |)Nr)dtypeszCongratulations, you have entered unreachable code. Please report an issue at https://github.com/narwhals-dev/narwhals/issues. Version: )r/r3narwhals.stable.v1rdr4narwhalsAssertionError)versionrdmsgs r7import_dtypes_modulerjsQ'**- M GLL # M  y " S!!r6cD|j|r|t|dS|SN) startswithlen)textprefixs r7 remove_prefixrqs$ vCKM"" Kr6cF|j|r|dt| S|Srl)endswithrn)rosuffixs r7 remove_suffixru s& }}VNs6{l## Kr6cP|sgSt|dk(rt|dr|dS|S)Nr)rn _is_iterable)argss r7flattenrzs.   4yA~,tAw/Aw Kr6c8t|ttfs|fS|Srl) isinstancelisttuple)args r7tupleifyrs cD%= )v Jr6c~ddlm}t|s t|rdt |d}t |t x}Rt||j|j|j|jfrdt |d}t |t|txrt|tt|f S)Nrr'z(Expected Narwhals class or scalar, got: z2. Perhaps you forgot a `nw.from_native` somewhere?z`. Hint: Perhaps you - forgot a `nw.from_native` somewhere? - used `pl.col` instead of `nw.col`?)narwhals.seriesr(rrtype TypeErrorrr|Exprr$r&r strbytes)rr(ripls r7rxrx!s&3#3C#88c Cuvnl'J bii",, =-7tCykB3 3 n c8 $ RZc5&=Q-R)RRr6cht|tr|jd}td|DS)zSimple version parser; split into a tuple of ints for comparison. Arguments: version: Version string to parse. Returns: Parsed version number. .c 3nK|]-}ttjddt|/yw)z\DN)intresubr).0vs r7 z parse_version..As&AARVVE2s1v./As35)r|rsplitr~)rhs r7 parse_versionr5s-'3--$ AA AAr6cddlm}t||r t||St||xst|txr t ||S)Nr)DType)narwhals.dtypesrr|r issubclass)objrDrs r7isinstance_or_issubclassrDsA%#u#s## c3  SJsD$9$Rjc>RSr6cddlmddlmtfd|Dstfd|Dryd|Dcgc] }t |c}}t |cc}w)Nrr#r%c36K|]}t|ywrlr|)ritemr$s r7rz$validate_laziness..Ps 94:dI & 9c36K|]}t|ywrlr)rrr&s r7rz$validate_laziness..Qs :DJtY ' :rzGThe items to concatenate should either all be eager, or all lazy, got: )narwhals.dataframer$r&allrr)itemsrrir$r&s @@r7validate_lazinessrLsZ,, 95 99 :E :: SlqTrdhUYZ^U_TrSs tC C.UssAcddlm}ddlm}d d}t t |}t t |}t t|dd|rt t|dd|r||jjj||jjj|j|jj|jjj|jjjSt t|dd|rt t|dd|r||jjj||jjj|j|jj|jjj|jjjSt t|dd|rt t|dd|r||jjj||jjj|j!|jj#|jjj|jjjSt t|dd|rt t|dd|r||jjj||jjj|j!|jj#|jjj|jjjSt%|t%|k7r%dt%|d t%|}t'||S) aAlign `lhs` to the Index of `rhs`, if they're both pandas-like. Arguments: lhs: Dataframe or Series. rhs: Dataframe or Series to align with. Returns: Same type as input. Notes: This is only really intended for backwards-compatibility purposes, for example if your library already aligns indices for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this only checks that `lhs` and `rhs` are the same length. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2]}, index=[3, 4]) >>> s_pd = pd.Series([6, 7], index=[4, 3]) >>> df = nw.from_native(df_pd) >>> s = nw.from_native(s_pd, series_only=True) >>> nw.to_native(nw.maybe_align_index(df, s)) a 4 2 3 1 r)PandasLikeDataFrame)PandasLikeSeriesc6|js d}t|y)Nz'given index doesn't have a unique index) is_unique ValueError)indexris r7_validate_indexz*maybe_align_index.._validate_index|s;CS/ !r6_compliant_frameN_compliant_seriesz6Expected `lhs` and `rhs` to have the same length, got z and )rrr_None)narwhals._pandas_like.dataframernarwhals._pandas_like.seriesrr rr|getattrr _native_framer_from_compliant_dataframe_from_native_framelocr_native_series_from_compliant_series_from_native_seriesrnr)lhsrhsrrrlhs_anyrhs_anyris r7maybe_align_indexrXsKBD=" 3nG3nG+T24G WW&8$?AT U00>>DDE00>>DDE00  $ $ 7 7((66::,,::@@   +T24G WW&94@BR S00>>DDE11@@FFG00  $ $ 7 7((66::--<<BB   ,d35E WW&8$?AT U11@@FFG00>>DDE--  % % 9 9))88<<,,::@@   ,d35E WW&94@BR S11@@FFG11@@FFG--  % % 9 9))88<<--<<BB    7|s7|#Fs7|nTYZ]^eZfYgho Jr6ctt|}|j}t|s t |r |j Sy)aGet the index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: Dataframe or Series. Returns: Same type as input. Notes: This is only really intended for backwards-compatibility purposes, for example if your library already aligns indices for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this returns `None`. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2], "b": [4, 5]}) >>> df = nw.from_native(df_pd) >>> nw.maybe_get_index(df) RangeIndex(start=0, stop=2, step=1) >>> series_pd = pd.Series([1, 2]) >>> series = nw.from_native(series_pd, series_only=True) >>> nw.maybe_get_index(series) RangeIndex(start=0, stop=2, step=1) N)r r to_nativerrr)robj_any native_objs r7maybe_get_indexrs<:3nG""$J +/DZ/P r6)rcddlm}tt|}|j}|| d}t ||s|s d}t ||.t |r|Dcgc] }||dc}n ||d}n|}t |r9|j|jj|j|St|rsddl m } |r d}t || |||jj|jj }|j#|jj%|S|Scc}w) aSet the index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: object for which maybe set the index (can be either a Narwhals `DataFrame` or `Series`). column_names: name or list of names of the columns to set as index. For dataframes, only one of `column_names` and `index` can be specified but not both. If `column_names` is passed and `df` is a Series, then a `ValueError` is raised. index: series or list of series to set as index. Returns: Same type as input. Raises: ValueError: If one of the following condition happens: - none of `column_names` and `index` are provided - both `column_names` and `index` are provided - `column_names` is provided and `df` is a Series Notes: This is only really intended for backwards-compatibility purposes, for example if your library already aligns indices for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this is a no-op. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2], "b": [4, 5]}) >>> df = nw.from_native(df_pd) >>> nw.to_native(nw.maybe_set_index(df, "b")) # doctest: +NORMALIZE_WHITESPACE a b 4 1 5 2 r)rz8Only one of `column_names` or `index` should be providedz3Either `column_names` or `index` should be providedT) pass_through)set_axisz/Cannot set index using column names on a Series)implementationbackend_version)narwhals.translaterr rrrxrrrr set_indexrnarwhals._pandas_like.utilsrr_implementation_backend_versionrr) r column_namesrrdf_anyrriidxkeysrs r7maybe_set_indexrsJ^- #s^F!!#JE$5Ho Co E";@ @3Ys . @5t4  +//  # # 6 6z7K7KD7Q R   z *8 CCS/ !  00@@11BB  ,,  $ $ 8 8 D   9 AsD?ctt|}|j}t|rX|j }t ||r|S|j |jj|jdSt|rX|j }t ||r|S|j|jj|jdS|S)aReset the index to the default integer index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: Dataframe or Series. Returns: Same type as input. Notes: This is only really intended for backwards-compatibility purposes, for example if your library already resets the index for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this is a no-op. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2], "b": [4, 5]}, index=([6, 7])) >>> df = nw.from_native(df_pd) >>> nw.to_native(nw.maybe_reset_index(df)) a b 0 1 4 1 2 5 >>> series_pd = pd.Series([1, 2]) >>> series = nw.from_native(series_pd, series_only=True) >>> nw.maybe_get_index(series) RangeIndex(start=0, stop=2, step=1) T)drop)r rrr__native_namespace___has_default_indexrrr reset_indexrrrr)rrrrEs r7maybe_reset_indexr:s>3nG""$J +"779 j*: ;N00  $ $ 7 7 8N8NTX8N8Y Z  Z("779 j*: ;N--  % % 9 9&&D&1   Nr6c|j}t||jxr:|jdk(xr)|jt |k(xr|j dk(S)Nrrw)rr| RangeIndexstartstoprnstep)native_frame_or_seriesrErs r7rrns] # ( (E5*556  KK1   JJ#e* $  JJ!O r6c Ztt|}|j}t|r:|j |j j |j|i|St|r:|j|jj|j|i|S|S)a9Convert columns or series to the best possible dtypes using dtypes supporting ``pd.NA``, if df is pandas-like. Arguments: obj: DataFrame or Series. *args: Additional arguments which gets passed through. **kwargs: Additional arguments which gets passed through. Returns: Same type as input. Notes: For non-pandas-like inputs, this is a no-op. Also, `args` and `kwargs` just get passed down to the underlying library as-is. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> import numpy as np >>> df_pd = pd.DataFrame( ... { ... "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")), ... "b": pd.Series([True, False, np.nan], dtype=np.dtype("O")), ... } ... ) >>> df = nw.from_native(df_pd) >>> nw.to_native(nw.maybe_convert_dtypes(df)).dtypes # doctest: +NORMALIZE_WHITESPACE a Int32 b boolean dtype: object ) r rrrrrrconvert_dtypesrrrr)rrykwargsrrs r7maybe_convert_dtypesrzsD3nG""$J +00  $ $ 7 7) ))4:6:   Z(--  % % 9 9) ))4:6:   Nr6cv|dvr|S|dvr|dz S|dvr|dz S|dvr|dz S|dvr|d z Sd |}t|) zScale size in bytes to other size units (eg: "kb", "mb", "gb", "tb"). Arguments: sz: original size in bytes unit: size unit to convert into Returns: Integer or float. >br>kb kilobytesi>mb megabytesi>gb gigabytesi@>tb terabyteslz9`unit` must be one of {'b', 'kb', 'mb', 'gb', 'tb'}, got )r)szunitris r7 scale_bytesrss ~ $ $Dy $ $G| $ $G| $ $G|KD8Tor6cddlm}t|jj}t |j|r<|j |jk(r#|jjjdS|j |jk(ry|j |jk7ry|j}t|r|j jdk(St|r|jj St#|r|jj St%|r|jj St'|r|j(j Sy)aReturn whether indices of categories are semantically meaningful. This is a convenience function to accessing what would otherwise be the `is_ordered` property from the DataFrame Interchange Protocol, see https://data-apis.org/dataframe-protocol/latest/API.html. - For Polars: - Enums are always ordered. - Categoricals are ordered if `dtype.ordering == "physical"`. - For pandas-like APIs: - Categoricals are ordered if `dtype.cat.ordered == True`. - For PyArrow table: - Categoricals are ordered if `dtype.type.ordered == True`. Arguments: series: Input Series. Returns: Whether the Series is an ordered categorical. Examples: >>> import narwhals as nw >>> import pandas as pd >>> import polars as pl >>> data = ["x", "y"] >>> s_pd = pd.Series(data, dtype=pd.CategoricalDtype(ordered=True)) >>> s_pl = pl.Series(data, dtype=pl.Categorical(ordering="physical")) Let's define a library-agnostic function: >>> @nw.narwhalify ... def func(s): ... return nw.is_ordered_categorical(s) Then, we can pass any supported library to `func`: >>> func(s_pd) True >>> func(s_pl) True r)InterchangeSeries is_orderedTFphysical)narwhals._interchange.seriesrrjr_versionr|dtype Categoricalrdescribe_categoricalrrrorderingrcatorderedrrrr)seriesrrd native_seriess r7is_ordered_categoricalrs'T? !&":":"C"C DF 6++->? LLF.. .''66KK   ||v{{" ||v)))$$&M &""++z99 &  (((}%  (((m$  ((( .!!))) r6c:d}t|dt||S)Nz}Use `generate_temporary_column_name` instead. `generate_unique_token` is deprecated and it will be removed in future versions1.13.0r)n_bytescolumns)issue_deprecation_warninggenerate_temporary_column_name)rrris r7generate_unique_tokenrs% ?cH5 )'7 KKr6cfd} t|}||vr|S|dz }|dkDrd|d|}t|/)aGenerates a unique column name that is not present in the given list of columns. It relies on [python secrets token_hex](https://docs.python.org/3/library/secrets.html#secrets.token_hex) function to return a string nbytes random bytes. Arguments: n_bytes: The number of bytes to generate for the token. columns: The list of columns to check for uniqueness. Returns: A unique token that is not present in the given list of columns. Raises: AssertionError: If a unique token cannot be generated after 100 attempts. Examples: >>> import narwhals as nw >>> columns = ["abc", "xyz"] >>> nw.generate_temporary_column_name(n_bytes=8, columns=columns) not in columns True rrwdzMInternal Error: Narwhals was not able to generate a column name with n_bytes=z and not in )rrg)rrcountertokenris r7rrs_,G '"  L1  S=*L 3 !% % r6c|j}t|}|r/|Dcgc] }||vs| }}|rtj|||Stt |j t |}|Scc}w)N)missing_columnsavailable_columns)rr}r'from_missing_and_available_column_namesset intersection)compliant_framerstrictcolsto_dropxr s r7parse_columns_to_dropr<s  " "D7mG &-?$1?? %MM /4  Ns4y--c'l;< N@s A7A7cHt|txrt|t Srl)r|r r)sequences r7is_sequence_but_not_strrNs h ) K*Xs2K.KKr6cpddl}ddlm}ddl}t ||j j }|j}d} |re|j|}|j|s*t|jddx}r#|jdr|j}|dz }n ~|S|re ~|S#~wxYw)zFind the first place in the stack that is not inside narwhals. Returns: Stacklevel. Taken from: https://github.com/pandas-dev/pandas/blob/ab89c53f48df67709a533b6a95ce3d911871a0a8/pandas/util/_exceptions.py#L30-L51 rN)Path co_qualnamezsingledispatch.rw) inspectpathlibrrfr__file__parent currentframegetfilermrf_codef_back)rrnwpkg_dirframenfnamequalnames r7find_stacklevelr+Rs$r{{#**+G  "E AOOE*E($U\\=$GGG''(9: Q  H'   H sA B2+B22B5c8t|tty)zIssue a deprecation warning. Arguments: message: The message associated with the warning. _version: Narwhals version when the warning was introduced. Just used for internal bookkeeping. )messagecategory stacklevelN)rDeprecationWarningr+)r-rs r7rr|s #5/BSTr6cn|||}|S|||rd}t|d| }|S|| |Sd}t|)Nz`strict` in `from_native` is deprecated, please use `pass_through` instead. Note: `strict` will remain available in `narwhals.stable.v1`. See https://narwhals-dev.github.io/narwhals/backcompat/ for more information. rrz,Cannot pass both `strict` and `pass_through`)rr)rrpass_through_defaultemit_deprecation_warningris r7validate_strict_and_pass_thoughr4sy~,.+     4 #b  &cH =!z  L4  =or6cb|dkr d}t|t|ts'|jj}d|d}t ||_|dkr d}t|t|ts'|jj}d|d}t |||kDr d}t |||fS|}||fS)Nrwz+window_size must be greater or equal than 1zargument 'window_size': 'z,' object cannot be interpreted as an integerz+min_periods must be greater or equal than 1zargument 'min_periods': 'z6`min_periods` must be less or equal than `window_size`)rr|r __class__r0rr) window_size min_periodsri_types r7_validate_rolling_argumentsr:sQ;o k3 '%%..'w/( ( n ??CS/ !+s+))22E+E73,, C.  $JC', ,  ##"  ##r6)rhr/r_r))rorrprr_r)rorrtrr_r)ryrr_z list[Any])rrr_r)rzAny | Iterable[Any]r_r`)rhzSequence[str | int]r_ztuple[int, ...])rrrDrr_r`)rz Iterable[Any]r_r)rr,rz-Series[Any] | DataFrame[Any] | LazyFrame[Any]r_r,)rz-DataFrame[Any] | LazyFrame[Any] | Series[Any]r_z Any | Nonerl)rr,rzstr | list[str] | Nonerz6Series[IntoSeriesT] | list[Series[IntoSeriesT]] | Noner_r,)rr,r_r,)rzpd.Series | pd.DataFramerErr_r`)rr,ryr`rz bool | strr_r,)rrrr+r_z int | float)rz Series[Any]r_r`)rrr list[str]r_r)rrrz Iterable[str]rr`r_r;)rrr_zTypeGuard[Sequence[Any]])r_r)r-rrrr_r) r bool | Nonerr<r2r`r3r`r_r`)r7rr8z int | Noner_ztuple[int, int])Q __future__rrenumrrsecretsrtypingrrr r r r r warningsrnarwhals.dependenciesrrrrrrrrrrrrrrrnarwhals.exceptionsrrtypesr pandaspdtyping_extensionsr!r"rr$r&rr(narwhals.typingr)r*r+r,r/r9rjrqrurzrrxrrrrrrrrrrrrrrrr+rr4r:r5r6r7rIsH"  *4+,,-1015:722:35 &+,,&&+(ininfSk&Q RN d {+T{+|    S( BT ^ ^K^^B!L,0ZEI Z Z(Z B Z  Zz1h 4 HK   0 0 $00:00f2EPL"&J   $L' TU   #   4!$!$#-!$!$r6