
    eiO                       d dl mZ d dlmZ d dlmZ d dlmZmZ d dl	Z	d dl	m
Z
 d dlmZmZmZmZmZmZmZmZmZ d dlmZ d d	lmZmZmZmZmZmZmZmZ d d
l m!Z! d dl"m#Z# erd dl$m%Z%m&Z&m'Z'm(Z( d dl)m*Z* d dl+m,Z, d dl-m.Z. d dl/Z0d dl1Z2d dl	m3Z3 d dl4m5Z5m6Z6 d dl7m8Z8 d dl9m:Z: d dl;m<Z< d dl=m>Z> d dl?m@Z@ d dlmAZA d dlBmCZC d dlmDZD d dlEmFZF d dlGmHZH d dlImJZK d dlLmMZMmNZNmOZO  G d ded    e      ZPy)!    )annotations)reduce)and_)TYPE_CHECKINGAnyN)StarExpression)	DeferredTimeZoneFcatch_duckdb_exceptioncolevaluate_exprs_and_aliasesjoin_column_nameslitnative_to_narwhals_dtypewindow_expression)SQLLazyFrame)ImplementationValidateBackendVersionVersionextend_boolgenerate_temporary_column_nameparse_columns_to_droprequires
zip_strict
get_duckdb)InvalidOperationError)IterableIteratorMappingSequence)BytesIO)Path)
ModuleType)
Expression)SelfTypeIs)CompliantDataFrameAny)
DuckDBExprDuckDBGroupByDuckDBNamespaceDuckDBInterchangeSeries)duckdb_dtypes)_EagerAllowedImpl)_LimitedContext)	LazyFrame)DType	DataFrame)AsofJoinStrategyJoinStrategyUniqueKeepStrategyc                  Z   e Zd Zej                  Zdd	 	 	 	 	 	 	 d,dZed-d       Ze	d.d       Z
e	 	 	 	 	 	 d/d       Z	 	 	 	 	 	 d0dZd1dZd1d	Zd2d
Zd3dZd4dZd5dZ	 	 	 	 	 	 d6dZd7dZd8dZd9dZd9dZd:dZd;d<dZd9dZd=dZed>d       Zed?d       Zd@dZdAdZ dBdZ!dCdZ"	 	 	 	 	 	 dDdZ#dEdZ$	 	 	 	 	 	 	 	 	 	 	 	 dFd Z%	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dGd!Z&d>d"Z'	 	 	 	 	 	 	 	 dHd#Z(dId$Z)dJd%Z*dKd&Z+dLd'Z,	 	 	 	 	 	 	 	 	 	 dMd(Z- e.j^                  d)      dNd*       Z0dOd+Z1y)PDuckDBLazyFrameF)validate_backend_versionc               b    || _         || _        d | _        d | _        |r| j	                          y y N)_native_frame_version_cached_native_schema_cached_columns_validate_backend_version)selfdfversionr<   s       \/var/www/html/glpi_dashboard/venv/lib/python3.12/site-packages/narwhals/_duckdb/dataframe.py__init__zDuckDBLazyFrame.__init__F   s7     79SW"15#**, $    c                6    | j                   j                         S r>   )_implementation_backend_versionrD   s    rG   rL   z DuckDBLazyFrame._backend_versionT   s    ##4466rI   c                6    t        | t        j                        S r>   )
isinstanceduckdbDuckDBPyRelation)objs    rG   
_is_nativezDuckDBLazyFrame._is_nativeX   s    #v6677rI   c              *     | ||j                         S NrF   )r@   )clsdatacontexts      rG   from_nativezDuckDBLazyFrame.from_native\   s     4!1!122rI   c                    | j                   t        j                  u rddlm}  || d      S | j                   j                  | d      S )Nr   r5   interchange)levellazy)r@   r   V1narwhals.stable.v1r6   	lazyframe)rD   argskwdsDataFrameV1s       rG   to_narwhalszDuckDBLazyFrame.to_narwhalsb   s>     ==GJJ&Ct=99}}&&t6&::rI   c                X    | j                   t        j                  urd}t        |      | S )Nz=__narwhals_dataframe__ is not implemented for DuckDBLazyFrame)r@   r   r_   AttributeError)rD   msgs     rG   __narwhals_dataframe__z&DuckDBLazyFrame.__narwhals_dataframe__k   s'    ==

*QC %%rI   c                    | S r>    rM   s    rG   __narwhals_lazyframe__z&DuckDBLazyFrame.__narwhals_lazyframe__r   s    rI   c                    t               S r>   r   rM   s    rG   __native_namespace__z$DuckDBLazyFrame.__native_namespace__u   s
    |rI   c                4    ddl m}  || j                        S )Nr   r,   rV   )narwhals._duckdb.namespacer-   r@   )rD   r-   s     rG   __narwhals_namespace__z&DuckDBLazyFrame.__narwhals_namespace__x   s    >t}}55rI   c                h    ddl m}  || j                  j                  |      | j                        S )Nr   r.   rV   )narwhals._duckdb.seriesr/   nativeselectr@   )rD   namer/   s      rG   
get_columnzDuckDBLazyFrame.get_column}   s%    C&t{{'9'9$'?WWrI   c              #  H   K   | j                   D ]  }t        |        y wr>   )columnsr   )rD   rv   s     rG   _iter_columnszDuckDBLazyFrame._iter_columns   s"     LL 	Dd)O	s    "c                >   ||t         j                  u r`ddlm} | j                  dk  r| j
                  j                         }n| j
                  j                         } ||d| j                  d      S |t         j                  u rCddl
m}  || j
                  j                         t         j                  d| j                  d      S |t         j                  u r3ddlm}  || j
                  j!                         d| j                  	      S d
| }t#        |      )Nr   )ArrowDataFrame)      T)r<   rF   validate_column_names)PandasLikeDataFrame)implementationr<   rF   r   )PolarsDataFrame)r<   rF   zUnsupported `backend` value: )r   PYARROWnarwhals._arrow.dataframer|   rL   rt   arrowfetch_arrow_tabler@   PANDASnarwhals._pandas_like.dataframer   rE   POLARSnarwhals._polars.dataframer   pl
ValueError)rD   backendkwargsr|   retr   r   rh   s           rG   collectzDuckDBLazyFrame.collect   s     ?g)?)??@$$v-kk'')kk335!)-&*	  n+++K& -44)-&*  n+++B" 4  .gY7orI   c                V    | j                  | j                  j                  |            S r>   )_with_nativert   limit)rD   ns     rG   headzDuckDBLazyFrame.head   s"      !2!21!566rI   c                R    | j                   | j                  j                  |       S r>   )r   rt   ru   )rD   column_namess     rG   simple_selectzDuckDBLazyFrame.simple_select   s%      !3!3!3\!BCCrI   c                    t        | g| D cg c]  \  }}|j                  |       }}}	 | j                  | j                  j	                  |            S c c}}w # t
        $ r}t        ||       d d }~ww xY wr>   )r   aliasr   rt   	aggregate	Exceptionr   )rD   exprsrv   val	selectiones         rG   r   zDuckDBLazyFrame.aggregate   s}    -G-Uu-U
 )cCIIdO
	 
	<$$T[[%:%:9%EFF	

  	<(D1t;	<s   A)A 	A:(A55A:c                    d t        | g| D        }	 | j                   | j                  j                  |       S # t        $ r}t        ||       d d }~ww xY w)Nc              3  D   K   | ]  \  }}|j                  |        y wr>   r   ).0rv   r   s      rG   	<genexpr>z)DuckDBLazyFrame.select.<locals>.<genexpr>   s!      
 )cCIIdO
    )r   r   rt   ru   r   r   )rD   r   r   r   s       rG   ru   zDuckDBLazyFrame.select   sb    
-G-Uu-U
		<$$%7T[[%7%7%CDD 	<(D1t;	<s   '= 	AAAc                   t        | ||      }| j                  D cg c]  }||vst        |       }}| j                   | j                  j
                  |       S c c}w )Nstrict)r   ry   r   r   rt   ru   )rD   ry   r   columns_to_droprv   r   s         rG   dropzDuckDBLazyFrame.drop   s[    /gfM+/<<W44;VSYW	W  !3!3!3Y!?@@ Xs
   	AANc                $    |d}t        |      | S )Nz.`backend` argument is not supported for DuckDB)r   )rD   r   _rh   s       rG   r^   zDuckDBLazyFrame.lazy   s    
 BCS/!rI   c                   t        t        | g|       }| j                  D cg c]1  }||v r |j                  |      j	                  |      n
t        |      3 }}|j                  d |j                         D               	 | j                   | j                  j                  |       S c c}w # t        $ r}t        ||       d d }~ww xY w)Nc              3  D   K   | ]  \  }}|j                  |        y wr>   r   )r   rv   values      rG   r   z/DuckDBLazyFrame.with_columns.<locals>.<genexpr>   s     SKD%ekk$'Sr   )dictr   ry   popr   r   extenditemsr   rt   ru   r   r   )rD   r   new_columns_maprv   resultr   s         rG   with_columnszDuckDBLazyFrame.with_columns   s    9$GGH
 	
  & %++D1T
 
 	S?;P;P;RSS	<$$%7T[[%7%7%@AA
  	<(D1t;	<s   6B+'B0 0	C9CCc                     ||       d   }	 | j                  | j                  j                  |            S # t        $ r}t	        ||       |d }~ww xY w)Nr   )r   rt   filterr   r   )rD   	predicatemaskr   s       rG   r   zDuckDBLazyFrame.filter   sT    q!	9$$T[[%7%7%=>> 	9(D1q8	9s   )7 	A AAc           
     z   | j                   8t        t        | j                  | j                  j
                              | _         t        | j                        }t        | j                  j                  | j                  j
                        D ci c]  \  }}|t        || j                  |       c}}S c c}}w r>   )
rA   r   zipry   rt   typesr	   r   r   r@   )rD   deferred_time_zonecolumn_nameduckdb_dtypes       rG   schemazDuckDBLazyFrame.schema   s    %%- *.c$,,@Q@Q.R)SD&-dkk:
 .8##T[[%6%6.	
 *\ 1dmm-? 
 	
 
s   "B7c                    | j                   <| j                  t        | j                        n| j                  j
                  | _         | j                   S r>   )rB   rA   listr   rt   ry   rM   s    rG   ry   zDuckDBLazyFrame.columns   sM    ' --9 T[[![[((  
 ###rI   c                6    | j                   j                         S r>   )rt   rE   rM   s    rG   	to_pandaszDuckDBLazyFrame.to_pandas  s    {{~~rI   c                p    | j                         j                  t        j                        j                  S r>   )r^   r   r   r   rt   rM   s    rG   to_arrowzDuckDBLazyFrame.to_arrow  s%    yy{"">#9#9:AAArI   c                <    | j                  | j                  |      S rU   )	__class__rt   )rD   rF   s     rG   _with_versionzDuckDBLazyFrame._with_version  s    ~~dkk7~;;rI   c                <    | j                  || j                        S rU   )r   r@   )rD   rE   s     rG   r   zDuckDBLazyFrame._with_native  s    ~~b$--~88rI   c               $    ddl m}  || ||      S )Nr   r*   )drop_null_keys)narwhals._duckdb.group_byr+   )rD   keysr   r+   s       rG   group_byzDuckDBLazyFrame.group_by  s     	<T4GGrI   c                    | j                   }fd|j                  D        }| j                   | j                   j                  |       S )Nc              3  v   K   | ]0  }|v rt        |      j                  |         n
t        |       2 y wr>   )r   r   )r   rv   mappings     rG   r   z)DuckDBLazyFrame.rename.<locals>.<genexpr>  s9      
 /3goCIOOGDM*3t9L
s   69)rt   ry   r   ru   )rD   r   rE   r   s    `  rG   renamezDuckDBLazyFrame.rename  sD    [[



	   !3!3!3Y!?@@rI   c               r   |dk(  rdn|}|dk(  rm| j                   dk  rd| j                    }t        |      | j                  j                  d      j	                  |j                  j                  d            }nq|J |J d t        ||      D        }	t        t        |	      }
| j                  j                  d      j                  |j                  j                  d      |
|	      }|d
v r| j                  D cg c]  }t        d| d       }}|j                  D ]  }|| j                  v }|dk(  r!|s|j                  t        d| d             7|dk(  s|r8|||vr2|j                  t        d| d      j                  | |              v|||vs}|j                  t        |               |j                  | j                  | j                  j                        }n4|j                  d      j                  | j                  j                        }| j                  |      S c c}w )Nfulloutercross)r}   r}   r~   z;'duckdb>=1.1.4' is required for cross-join, found version: lhsrhsc              3  `   K   | ]&  \  }}t        d | d      t        d| d      k(   ( ywlhs.""rhs."Nr   r   leftrights      rG   r   z'DuckDBLazyFrame.join.<locals>.<genexpr>5  s<      D% eD6O$eE7!,<(==   ,.)	conditionhow>   r   r   innerr   r   r   r   lhs.*)rL   NotImplementedErrorrt   	set_aliasr   r   r   r   joinry   r   appendr   ru   r   )rD   otherr   left_onright_onsuffix
native_howrh   relitr   xru   rv   
col_in_lhsress                   rG   r   zDuckDBLazyFrame.join!  s"    !$vW3
 $$y0STXTiTiSjk)#..++''.44U\\5K5KE5RSC &&&'''#-gx#@B %+4$4I++''.33&&u-#	 4 C <<15>AcE!A,'>F> 	-#'4<<#7
(MM#dV1o"67 G+H$4H8LMM#dV1o"6"<"<vfX=N"OP%X)=MM#d),	- #**f%//0A0ABC**W%//0A0ABC  %% ?s   ?H4c          	        | j                   }|j                   }	g }
|%|#|
j                  d t        ||      D               ng x}}|dk(  r/|
j                  t	        d| d      t	        d| d      k\         nA|dk(  r/|
j                  t	        d| d      t	        d| d      k         nd}t        |      t        t        |
      }dg}|	j                  D ]a  }||j                  v r$|||h|vr|j                  d| d	| | d       5|||h|vs?|j                  t        t	        |                   c d
dj                  |       d| d}| j                  t        j                  |            S )Nc              3  `   K   | ]&  \  }}t        d | d      t        d| d      k(   ( ywr   r   r   s      rG   r   z,DuckDBLazyFrame.join_asof.<locals>.<genexpr>b  s<      D% eD6O$eE7!,<(==r   backwardr   r   r   forwardzKOnly 'backward' and 'forward' strategies are currently supported for DuckDBr   z" as "z
            SELECT ,zD
            FROM lhs
            ASOF LEFT JOIN rhs
            ON 
            )rt   r   r   r   r   r   r   r   ry   strr   r   rP   sql)rD   r   r   r   by_leftby_rightstrategyr   r   r   
conditionsrh   r   ru   rv   querys                   rG   	join_asofzDuckDBLazyFrame.join_asofS  s    kkll')
8#7 #-gx#@ 
 "$#Ghz!cE'!"45uXJa=P9QQR"cE'!"45uXJa=P9QQR_C%c** &tZ 8	KK 	.Ds{{" D0EH0E$EdV6$xqAB!T(1FX1F%Fc#d)n-	.HHV$% & { 	   E!233rI   c                    | j                   S r>   )r   rM   s    rG   collect_schemazDuckDBLazyFrame.collect_schema  s    {{rI   c               :   |xs | j                   }| j                  |      x}r|t        d| j                   d      }|r|dk(  rt        dt	        |            nd }|dk(  r't        t        dt                     ||xs d||	      }nt        t        d
      ||xs d||	      }| j                  | j                  j                  t               |j                  |            j                  t        |      t        d      k(              j                  |gd      S )N   
row_index_)prefixlastTnonecountrk   )
descending
nulls_last
row_numberr}   Fr   )ry   _check_columns_existr   r   lenr   r
   r   r   rt   ru   r   r   r   r   r   )	rD   subsetkeeporder_bysubset_errortmp_nameflagsexprs	            rG   uniquezDuckDBLazyFrame.unique  s    (DLL--g6656K1!T\\,W4<D#h-0UY6>$'>+,B  D %,B  D   KK~/H1EFMMHQ'
 $z%$
(		)rI   c                   t        |t        |            }|rd t        ||      D        }nd t        ||      D        }| j                   | j                  j
                  |       S )Nc              3     K   | ]I  \  }}|st        |      j                         n&t        |      j                         j                          K y wr>   )r   r  descr   rv   r  s      rG   r   z'DuckDBLazyFrame.sort.<locals>.<genexpr>  sD      D$ /3D	$$&D	8H8S8S8UU   AAc              3     K   | ]I  \  }}|st        |      j                         n&t        |      j                         j                          K y wr>   )r   nulls_firstr  r   s      rG   r   z'DuckDBLazyFrame.sort.<locals>.<genexpr>  sD      D$ 04D	%%'T9I9U9U9WWr!  )r   r  r   r   rt   sort)rD   r  r  byr   s        rG   r$  zDuckDBLazyFrame.sort  sf     SW5
",R"<B
",R"<B   !1!1!12!677rI   c               h   | j                   }t        |      }t        |t              rt	        | t        |            }nt        d |D              }t        t        d      ||t	        dt        |                  }|t        |      k  }d| d}| j                  t        j                  |            S )Nc              3  "   K   | ]  }|  	 y wr>   rk   )r   revs     rG   r   z(DuckDBLazyFrame.top_k.<locals>.<genexpr>  s     :33w:s   r  T)r  r  r  z@
            SELECT *
            FROM _rel
            QUALIFY z	
        )rt   r   rO   boolr   r  tupler   r
   r   r   rP   r   )	rD   kr%  reverse_relr  r  r   r  s	            rG   top_kzDuckDBLazyFrame.top_k  s    {{"Xgt$$[#b':J:'::J lO!"4R1	
 CFN	 K  	
   E!233rI   c                    ||n| j                   }t        t        d |D              }| j                  | j                  j                  |            S )Nc              3  N   K   | ]  }t        |      j                           y wr>   )r   	isnotnull)r   rv   s     rG   r   z-DuckDBLazyFrame.drop_nulls.<locals>.<genexpr>  s     &Qs4y':':'<&Qs   #%)ry   r   r   r   rt   r   )rD   r  r  keep_conditions       rG   
drop_nullszDuckDBLazyFrame.drop_nulls  sD    ".&DLL&Q&QR  !3!3N!CDDrI   c                b   | j                   j                  }| j                         }D ]'  }||   }||j                  k7  sd| d}t	        |       t              dk7  rd}t        |      t        d         | j                  }| j                  }t        d      }	j                         t        d      z  |	kD  }
 |j                  |
      j                  fd|D         } |j                  |
       j                  fd|D         }| j                  |j!                  |            S )	Nz-`explode` operation not supported for dtype `z`, expected List typer}   zExploding on multiple columns is not supported with DuckDB backend since we cannot guarantee that the exploded columns have matching element counts.r   r  c              3  `   K   | ]%  }|v rt        d       j                  |      n| ' yw)unnestN)r
   r   )r   rv   col_to_explodery   s     rG   r   z*DuckDBLazyFrame.explode.<locals>.<genexpr>  s8       <@7?(N+11$7PTTs   +.c              3  ^   K   | ]$  }|v rt        d       j                  |      n| & y wr>   )r   r   )r   rv   ry   s     rG   r   z*DuckDBLazyFrame.explode.<locals>.<genexpr>  s1       *.D	%dBs   *-)r@   dtypesr  Listr   r  r   r   rt   ry   r   r1  r
   r   ru   r   union)rD   ry   r9  r   rv   dtyperh   r   original_columnszeronot_null_conditionnon_null_relnull_relr7  s    `           @rG   explodezDuckDBLazyFrame.explode  sM   %%$$& 	1D4LE#CE7 K) )  ,C00	1 w<1^  &c**WQZkk<<1v+557!E>:RRUYY<szz"45<<,
 :3::11299,
   !3!3H!=>>rI   c                x   |g n|}|| j                   D cg c]	  }||vs| c}n|}|dk(  rd}t        |      |dk(  rd}t        |      t        | }	| j                  }
d|	 dt	        |       dt	        |       d}| j                   t        j                  |      j                  g |||       S c c}w )N z:`variable_name` cannot be empty string for duckdb backend.z7`value_name` cannot be empty string for duckdb backend.z)
            unpivot _rel
            on z'
            into
                name z
                value r   )	ry   r   r   rt   r   r   rP   r   ru   )rD   onindexvariable_name
value_nameindex_con_rh   
unpivot_onr-  r  s               rG   unpivotzDuckDBLazyFrame.unpivot  s     }%>@j$,,:Q!6/q:bBNC%c**KC%c**&,
{{| -() *:' (   $FJJu$$&J&J&Jz&JK
 	
+ ;s
   	B7B7)r}      c                    |d}t        |      t        t        d      |      t        d      z
  j	                  |      }| j                  | j                  j                  |t                           S )Nz5Cannot pass `order_by` to `with_row_index` for DuckDBr  )r  r}   )		TypeErrorr   r
   r   r   r   rt   ru   r   )rD   rv   r  rh   r  s        rG   with_row_indexzDuckDBLazyFrame.with_row_index  se    ICC. !!L/HEANUU
   !3!3D.:J!KLLrI   c                R    | j                   }d| d}t        j                  |       y )Nz7
            COPY (SELECT * FROM _rel)
            TO 'z+'
            (FORMAT parquet)
            )rt   rP   r   )rD   filer-  r  s       rG   sink_parquetzDuckDBLazyFrame.sink_parquet#  s/    {{ 
 	

5rI   )rE   duckdb.DuckDBPyRelationrF   r   r<   r)  returnNone)rV  ztuple[int, ...])rR   zduckdb.DuckDBPyRelation | AnyrV  zTypeIs[duckdb.DuckDBPyRelation])rX   rU  rY   r2   rV  r&   )rb   r   rc   r   rV  ILazyFrame[duckdb.DuckDBPyRelation] | DataFrameV1[duckdb.DuckDBPyRelation])rV  r&   )rV  r$   )rV  r-   )rv   r   rV  r/   )rV  zIterator[Expression])r   z_EagerAllowedImpl | Noner   r   rV  r(   )r   intrV  r&   )r   r   rV  r&   )r   r)   rV  r&   )ry   Sequence[str]r   r)  rV  r&   r>   )r   rW  r   rW  rV  r&   )r   r)   rV  r&   )rV  zdict[str, DType])rV  z	list[str])rV  zpd.DataFrame)rV  zpa.Table)rF   r   rV  r&   )rE   rU  rV  r&   )r   z$Sequence[str] | Sequence[DuckDBExpr]r   r)  rV  r+   )r   zMapping[str, str]rV  r&   )r   r&   r   r8   r   Sequence[str] | Noner   r[  r   r   rV  r&   )r   r&   r   r   r   r   r   r[  r  r[  r  r7   r   r   rV  r&   )r  r[  r  r9   r  r[  rV  r&   )r%  r   r  bool | Sequence[bool]r  r)  rV  r&   )r+  rY  r%  zIterable[str]r,  r\  rV  r&   )r  r[  rV  r&   )ry   rZ  rV  r&   )
rE  r[  rF  r[  rG  r   rH  r   rV  r&   )rv   r   r  rZ  rV  r&   )rS  zstr | Path | BytesIOrV  rW  )2__name__
__module____qualname__r   DUCKDBrK   rH   propertyrL   staticmethodrS   classmethodrZ   re   ri   rl   rn   rq   rw   rz   r   r   r   r   ru   r   r^   r   r   r   ry   r   r   r   r   r   r   r   r  r  r  r$  r.  r3  rB  rM  r   backend_versionrQ  rT  rk   rI   rG   r;   r;   <   s    %++O */-#- 	-
 #'- 
- 7 7 8 8 3*3;J3	3 3
;;"%;	R;6
X
$/$;>$	$L7D<<A
<9 
 
  $ $ B<9H8HMQH	HA0&0& 	0&
 &0& '0& 0& 
0&d-4-4 	-4
 -4 &-4 '-4 #-4 -4 
-4^ )$ ) !	 )
 ' ) 
 )D84*E
'?R
 
 $
 	

 
 

B Xf%M &MrI   r;   )r)   rU  rX  )Q
__future__r   	functoolsr   operatorr   typingr   r   rP   r   narwhals._duckdb.utilsr	   r
   r   r   r   r   r   r   r   narwhals._sql.dataframer   narwhals._utilsr   r   r   r   r   r   r   r   narwhals.dependenciesr   narwhals.exceptionsr   collections.abcr   r   r    r!   ior"   pathlibr#   r   r$   pandaspdpyarrowpar%   typing_extensionsr&   r'   narwhals._compliant.typingr(   narwhals._duckdb.exprr)   r   r+   rp   r-   rs   r/   r0   narwhals._typingr1   r2   narwhals.dataframer3   narwhals.dtypesr4   r`   r6   rd   narwhals.typingr7   r8   r9   r;   rk   rI   rG   <module>r|     s    "   %  !
 
 
 1	 	 	 - 5EE !.@07:?42/,%;RRn	U
 nrI   