
    Eg	Q                       d Z ddlmZ ddlZddlmZmZ ddlmZ ddl	m
Z
mZmZ ddlZddlmZmZ ddlmZ dd	lmZ ddlmc mZ dd
lmZmZmZ ddlm Z  ddl!m"Z" ddl#m$Z$ ddl%m&Z& ddl'm(Z( ddl)m*Z*m+Z+ e
rddl,m-Z-m.Z.  G d dej/                  Z0 G d dej1                  Z1 G d de1          Z2 G d dej3                  Z3 G d de3          Z4 G d de4          Z5 G d de3          Z6 G d  d!e6          Z7 G d" d#ej8                  Z8 G d$ d%e"          Z9d& Z: G d' d(ej;                  Z< G d) d*          Z=d.d-Z>dS )/z1 manage PyTables query interface via Expressions     )annotationsN)DecimalInvalidOperation)partial)TYPE_CHECKINGAnyClassVar)	Timedelta	Timestamp)UndefinedVariableError)is_list_like)expropsscope)ensure_decoded)BaseExprVisitor)is_term)extract_array)Index)pprint_thingpprint_thing_encoded)Selfnptc                  8     e Zd ZU dZded<   	 	 	 dd fd
Z xZS )PyTablesScope)
queryablesdict[str, Any]r   Nlevelintdict[str, Any] | NonereturnNonec                h    t                                          |dz   ||           |pi | _        d S )N   )global_dict
local_dict)super__init__r   )selfr   r%   r&   r   	__class__s        U/var/www/sysmax/venv/lib/python3.11/site-packages/pandas/core/computation/pytables.pyr(   zPyTablesScope.__init__7   s8     	
SSS$*    )NNN)r   r   r   r    r!   r"   )__name__
__module____qualname__	__slots____annotations__r(   __classcell__r*   s   @r+   r   r   2   s`         I
 ,0+ + + + + + + + + + +r,   r   c                  R     e Zd ZU ded<   d
dZd
d fdZd Zed	             Z xZ	S )Termr   envNc                t    t          |t                    r| }nt          }t                              |          S N)
isinstancestrConstantobject__new__)clsnamer6   sideencodingklasss         r+   r=   zTerm.__new__E   s2    dC   	EEE~~e$$$r,   r!   r"   c                R    t                                          ||||           d S N)r@   rA   )r'   r(   r)   r?   r6   r@   rA   r*   s        r+   r(   zTerm.__init__L   s*    sAAAAAr,   c                   | j         dk    r?| j        | j        j        vr%t	          dt          | j                   d          | j        S 	 | j                            | j        d          S # t          $ r
 | j        cY S w xY w)Nleftzname z is not definedF)is_local)r@   r?   r6   r   	NameErrorreprresolver   r)   s    r+   _resolve_namezTerm._resolve_nameO   s    9y 333 HTY H H HIII9	8##DI#>>>% 	 	 	9	s    A- -B Bc                    | j         S r8   )_valuerL   s    r+   valuez
Term.value^   s
    {r,   NNr6   r   r!   r"   )
r-   r.   r/   r1   r=   r(   rM   propertyrP   r2   r3   s   @r+   r5   r5   B   s         % % % %B B B B B B B     X    r,   r5   c                  (     e Zd Zdd	 fdZd Z xZS )
r;   Nr6   r   r!   r"   c                    t          |t                    sJ t          |                      t                                          ||||           d S rD   )r9   r   typer'   r(   rE   s        r+   r(   zConstant.__init__d   sN    #}--88tCyy888sAAAAAr,   c                    | j         S r8   )_namerL   s    r+   rM   zConstant._resolve_nameh   s
    zr,   rQ   rR   )r-   r.   r/   r(   rM   r2   r3   s   @r+   r;   r;   c   sX        B B B B B B B      r,   r;   c                       e Zd ZU dZded<   ded<   ded<   d fd
ZddZd Zd Ze	dd            Z
e	dd            Ze	d             Ze	d             Ze	d             ZddZddZddZ xZS )BinOp   r:   opr   r   z
str | None	conditionr!   r"   c                x    t                                          |||           || _        || _        d | _        d S r8   )r'   r(   r   rA   r]   )r)   r\   lhsrhsr   rA   r*   s         r+   r(   zBinOp.__init__s   s8    S#&&&$ r,   c                    d S r8    rL   s    r+   _disallow_scalar_only_bool_opsz$BinOp._disallow_scalar_only_bool_opsy       r,   c                H     fd} j          j        }}t          |          r&t          |          r ||j        |j                  }nt          |          s4t          |          r% ||                              |j                  }nt          |          r4t          |          s% ||j        |                                        }nPt          |          sAt          |          s2 ||                              |                                        }|S )Nc                   | |S || S }t          | t                    rBt          |t                    rt          }n{t          | |          r| S t          ||          r|S nVt          | t                    rAt          |t                    rt          }n$t          | |          r| S t          ||          r|S  |j        | |j        j                                                  S )z5create and return a new specialized BinOp from myselfN)r   rA   )	r9   ConditionBinOpJointConditionBinOpFilterBinOpJointFilterBinOpr\   r   rA   evaluate)rG   rightkrB   r)   s      r+   przBinOp.prune.<locals>.pr}   s   |A$// !e^44 !+AAa(( !Kq)) ! L! D+.. !e[11 !(AAa(( !Kq)) ! L1u4=  hjjr,   )r_   r`   r   rP   prune)r)   rB   rn   rG   rl   ress   ``    r+   ro   zBinOp.prune|   s$   	 	 	 	 	 	8 he4== 	<WU^^ 	<"TZ--CC 	<75>> 	<"TZZ&&44CCT]] 	<75>> 	<"TZU!3!344CC$-- 	<75>> 	<"TZZ&&E(:(:;;C
r,   c                    t          |          s|g}t          |t          j                  r|                                }|S )zinplace conform rhs)r   r9   npndarrayravel)r)   r`   s     r+   conformzBinOp.conform   s?    C   	%Cc2:&& 	))++C
r,   boolc                    | j         | j        v S )z$return True if this is a valid field)r_   r   rL   s    r+   is_validzBinOp.is_valid   s     x4?**r,   c                D    | j                             | j                  duS )zx
        return True if this is a valid column name for generation (e.g. an
        actual column in the table)
        N)r   getr_   rL   s    r+   is_in_tablezBinOp.is_in_table   s!     ""48,,D88r,   c                ^    t          | j                            | j                  dd          S )zthe kind of my fieldkindNgetattrr   rz   r_   rL   s    r+   r}   z
BinOp.kind   (     t**4844fdCCCr,   c                ^    t          | j                            | j                  dd          S )zthe meta of my fieldmetaNr~   rL   s    r+   r   z
BinOp.meta   r   r,   c                ^    t          | j                            | j                  dd          S )zthe metadata of my fieldmetadataNr~   rL   s    r+   r   zBinOp.metadata   s(     t**4844j$GGGr,   c                b    |                     | j                  }d| j         d| j         d| dS )z2create and return the op string for this TermValue( ))tostringrA   r_   r\   )r)   vvals      r+   generatezBinOp.generate   s:    jj''.48..dg......r,   	TermValuec           	          fd}t           j                  }t           j                  }|dk    s|r|                    d          rt	          |t
          t          f          r ||          }t          |          }t          |                              d          }|j	        |
                    d          }t          ||j        |          S |dv rnt	          |t                    rt          |          }nt          |d	          }|                    d          j        }t          t          |          ||          S |d
k    rEt           j        d          }||vrd}n|                    |d          }t          ||d          S |dk    rd	 t%          |          }t          |                    d                    }n# t(          $ r t          |           Y nw xY wt          |||          S |dk    r t          |          }t          |||          S |dk    r^t	          |t                    r)|                                                                dv}nt/          |          }t          |||          S t	          |t                    rt          | ||          d          S t1          d| dt3          |           d| d          )zn
        convert the expression that is in the term to something that is
        accepted by pytables
        c                \    j         t          | j                   S t          |           S )N)rA   )rA   r   r   )rP   r)   s    r+   	stringifyz&BinOp.convert_value.<locals>.stringify   s.    }(+EDMJJJJ&&&r,   datetime
datetime64nsNUTC)timedelta64	timedeltas)unitcategoryT)extract_numpyrG   )r@   integerROUND_HALF_EVEN)roundingfloatrv   )	falsefnonnone0z[]z{} stringzCannot compare z	 of type z to z column)r   r}   r   
startswithr9   r   r   r   as_unittz
tz_convertr   rO   r:   r
   r   r   searchsortedr   to_integral_exactr   striplowerrv   	TypeErrorrV   )r)   r   r   r}   r   r   resultv_decs   `       r+   convert_valuezBinOp.convert_value   s   	' 	' 	' 	' 	'
 di((di((:$4??<+H+H!c5\** !IaLLq!!A!$$T**AtLL''Q$///111!S!! +aLLac***		$&ASVVQ---Z$T]$GGGH  !..qv.>>VVY777YM

 //9J/KKLL $    a Q4(((W__aAQ4(((V^^!S!! GGIIOO%% 
. 
 GGQ4(((3 	VQ		!h777TaTT$q''TTtTTTUUUs   G G)(G)c                    d S r8   rb   rL   s    r+   convert_valueszBinOp.convert_values  rd   r,   )r\   r:   r   r   r!   r"   r!   r"   r!   rv   r!   r:   )r!   r   )r-   r.   r/   _max_selectorsr1   r(   rc   ro   ru   rS   rx   r{   r}   r   r   r   r   r   r2   r3   s   @r+   rZ   rZ   l   sw        NGGG        ( ( (T   + + + X+ 9 9 9 X9 D D XD D D XD H H XH/ / / /
EV EV EV EVN       r,   rZ   c                  F    e Zd ZU dZded<   ddZddZd	 ZddZdddZ	dS )ri   Nztuple[Any, Any, Index] | Nonefilterr!   r:   c                l    | j         dS t          d| j         d          d| j         d          d          S )NzFilter: Not Initializedz[Filter : [r   z] -> [r$   ])r   r   rL   s    r+   __repr__zFilterBinOp.__repr__  s>    ;,,Q$+a.QQAQQQRRRr,   r   c                |    | j         4| j         d         |                     d          | j         d         f| _         | S )zinvert the filterNr   T)invert   )r   generate_filter_oprL   s    r+   r   zFilterBinOp.invert"  s@    ;"A''t'44ADK
 r,   c                    | j         gS )zreturn the actual filter format)r   rL   s    r+   formatzFilterBinOp.format,  s    }r,   Self | Nonec                   | j         st          d|  d          |                     | j                  }t	          |          }| j        rU| j        dv rJt          |          | j        k    r2| 	                                }| j
        |t          |          f| _        | S d S | j        dv r1| 	                                }| j
        |t          |          f| _        nt          d|  d          | S )Nquery term is not valid [r   ==!=z7passing a filterable condition to a non-table indexer [)rx   
ValueErrorru   r`   listr{   r\   lenr   r   r_   r   r   r   )r)   r`   values	filter_ops       r+   rk   zFilterBinOp.evaluate1  s   } 	B@@@@AAAll48$$c 	w,&&3v;;9L+L+L 3355	#xE&MMB4 7l""//11I8Yf>DKK Q$QQQ   r,   Fr   rv   c                B    | j         dk    r|r| j         dk    r|rd S d S )Nr   r   c                .    |                      |           S r8   isinaxisvalss     r+   <lambda>z0FilterBinOp.generate_filter_op.<locals>.<lambda>O  s    tyy&6 r,   c                ,    |                      |          S r8   r   r   s     r+   r   z0FilterBinOp.generate_filter_op.<locals>.<lambda>Q  s    diioo r,   )r\   )r)   r   s     r+   r   zFilterBinOp.generate_filter_opM  s1    GtOOFO4F666555r,   r   r!   r   r!   r   )F)r   rv   )
r-   r.   r/   r   r1   r   r   r   rk   r   rb   r,   r+   ri   ri     s         ,0F0000S S S S
     
   86 6 6 6 6 6 6r,   ri   c                      e Zd Zd ZddZdS )rj   c                     t          d          )Nz unable to collapse Joint FiltersNotImplementedErrorrL   s    r+   r   zJointFilterBinOp.formatU  s    !"DEEEr,   r!   r   c                    | S r8   rb   rL   s    r+   rk   zJointFilterBinOp.evaluateY  s    r,   Nr   )r-   r.   r/   r   rk   rb   r,   r+   rj   rj   T  s:        F F F     r,   rj   c                  *    e Zd Zd	dZd Zd Zd
dZdS )rg   r!   r:   c                2    t          d| j         d          S )Nz[Condition : [z]])r   r]   rL   s    r+   r   zConditionBinOp.__repr__^  s    ?T^???@@@r,   c                     t          d          )zinvert the conditionz6cannot use an invert condition when passing to numexprr   rL   s    r+   r   zConditionBinOp.inverta  s    
 "D
 
 	
r,   c                    | j         S )zreturn the actual ne format)r]   rL   s    r+   r   zConditionBinOp.formatj  s
    ~r,   r   c                ~     j         st          d  d           j        sd S                       j                  } fd|D             } j        dv rGt          |           j        k    r- fd|D             }dd                    |           d _	        n"d S  
                    |d	                    _	         S )
Nr   r   c                :    g | ]}                     |          S rb   )r   .0r   r)   s     r+   
<listcomp>z+ConditionBinOp.evaluate.<locals>.<listcomp>x  s'    555A$$$Q''555r,   r   c                :    g | ]}                     |          S rb   )r   r   s     r+   r   z+ConditionBinOp.evaluate.<locals>.<listcomp>~  s%    7771dmmA&&777r,   r   z | r   r   )rx   r   r{   ru   r`   r\   r   r   joinr]   r   )r)   r`   r   vss   `   r+   rk   zConditionBinOp.evaluateo  s    } 	B@@@@AAA  	4ll48$$5555555 7l""6{{d1117777777!6UZZ^^!6!6!6 t!]]6!955DNr,   Nr   r   )r-   r.   r/   r   r   r   rk   rb   r,   r+   rg   rg   ]  s^        A A A A
 
 
  
     r,   rg   c                      e Zd ZddZdS )rh   r!   r   c                Z    d| j         j         d| j         d| j        j         d| _        | S )Nr   r   r   )r_   r]   r\   r`   rL   s    r+   rk   zJointConditionBinOp.evaluate  s5    QTX/QQ$'QQDH<NQQQr,   Nr   )r-   r.   r/   rk   rb   r,   r+   rh   rh     s(             r,   rh   c                      e Zd Zd ZdS )UnaryOpc                8   | j         dk    rt          d          | j        }|                    |          }|at	          |t
                    r|j        1t	          |t
                    s0t	          |t                    r|j        |	                                S d S )N~z$UnaryOp only support invert type ops)
r\   r   operandro   
issubclassrg   r]   ri   r   r   )r)   rB   r   s      r+   ro   zUnaryOp.prune  s    7c>>%&LMMM,--&&un-- !-e^44 .5+.. . *>>###tr,   N)r-   r.   r/   ro   rb   r,   r+   r   r     s#            r,   r   c                  l     e Zd ZU eZded<   eZded<   d fdZdd	Z	d
 Z
d ZddZd Zd Zd Z xZS )PyTablesExprVisitorzClassVar[type[ops.Term]]
const_typezClassVar[type[Term]]	term_typer!   r"   c                    t                                          |||           | j        D ](}| j        |         }t	          | d| |ffd	           )d S )Nvisit_c                *    t          t          |fi S r8   )r   rZ   )nodebin_opkwargss     r+   r   z.PyTablesExprVisitor.__init__.<locals>.<lambda>  s    GE6,L,LV,L,L r,   )r'   r(   
binary_opsbinary_op_nodes_mapsetattr)r)   r6   engineparserr   r   bin_noder*   s       `  r+   r(   zPyTablesExprVisitor.__init__  s    ff---o 	 	F/7H###$*LLLLL   	 	r,   ops.Term | UnaryOp | Nonec                   t          |j        t          j        t          j        f          r(t          d|                     |j                            S t          |j        t          j                  r9| 	                    |                     |j                  j
         | j                  S t          |j        t          j                  rt          d          d S )Nr   zUnary addition not supported)r9   r\   astNotInvertr   visitr   USubr   rP   r6   UAddr   r)   r   r   s      r+   visit_UnaryOpz!PyTablesExprVisitor.visit_UnaryOp  s    dg455 	F3

4< 8 8999** 	F??DJJt|$<$<$B#BDHMMM** 	F%&DEEEtr,   c                @    |                      |j                  j        S r8   )r	  rP   r  s      r+   visit_IndexzPyTablesExprVisitor.visit_Index  s    zz$*%%++r,   c                    t          j        t          j                    g|j        d         |j        g          }|                     |          S )Nr   )r   rG   comparators)r  CompareEqtargetsrP   r	  )r)   r   r   cmprs       r+   visit_Assignz PyTablesExprVisitor.visit_Assign  sE    {
atzl
 
 
 zz$r,   ops.Termc           	        |                      |j                  }|                      |j                  }	 |j        }n# t          $ r Y nw xY wt	          |t
                    r|j        }	 |                     ||         | j                  S # t          $ r5}t          dt          |           dt          |                     |d }~ww xY w)Nzcannot subscript z with )r	  rP   sliceAttributeErrorr9   r5   r   r6   r   r   rJ   )r)   r   r   rP   slobjerrs         r+   visit_Subscriptz#PyTablesExprVisitor.visit_Subscript  s     

4:&&

4:&&	KEE 	 	 	D	 eT"" 	 KE	??5<::: 	 	 	DDKKDDtE{{DD 	s'   > 
A
A+ B 
C0CCc                   |j         }|j        }t          |j                  }|t          j        k    r|                     |          }	 |j        }n# t          $ r Y nw xY w	 |                     t          ||          | j
                  S # t          $ r, t          |t          j                  r|j        |k    r|cY S Y nw xY wt          d|j                   )NzInvalid Attribute context )attrrP   rV   ctxr  Loadr	  r  r   r   r6   r9   Nameidr   r-   )r)   r   r   r  rP   r   resolveds          r+   visit_Attributez#PyTablesExprVisitor.visit_Attribute  s    y
48nn#(??zz%((H#>!   $~~gh&=&=txHHH! $ $ $eSX.. $58t3C3C#OOO$
 DclDDEEEs$   	A 
AA"(B 1C Cc                `    t          |t          j                  rt          j                    n|S r8   )r9   r  Inr  )r)   r\   s     r+   translate_Inz PyTablesExprVisitor.translate_In  s#    %b#&119svxxxr9r,   c                H    |                      |j                  |j        ||fS r8   )r	  r\   )r)   r   rG   rl   s       r+   _rewrite_membership_opz*PyTablesExprVisitor._rewrite_membership_op  s!    zz$'""DGT588r,   r   )r!   r  )r!   r  )r-   r.   r/   r;   r   r1   r5   r   r(   r  r  r  r  r%  r(  r*  r2   r3   s   @r+   r   r     s         +3J3333&*I****        , , ,        *F F F0: : :9 9 9 9 9 9 9r,   r   c                z    t          | t          t          f          st          |           st	          d          | S )a  
    Validate that the where statement is of the right type.

    The type may either be String, Expr, or list-like of Exprs.

    Parameters
    ----------
    w : String term expression, Expr, or list-like of Exprs.

    Returns
    -------
    where : The original where clause if the check was successful.

    Raises
    ------
    TypeError : An invalid data type was passed in for w (e.g. dict).
    zLwhere must be passed as a string, PyTablesExpr, or list-like of PyTablesExpr)r9   PyTablesExprr:   r   r   )ws    r+   _validate_wherer.    sF    $ q<-.. 
,q// 
+
 
 	

 Hr,   c                  P    e Zd ZU dZded<   ded<   ded<   	 	 	 dddZddZd ZdS )r,  a  
    Hold a pytables-like expression, comprised of possibly multiple 'terms'.

    Parameters
    ----------
    where : string term expression, PyTablesExpr, or list-like of PyTablesExprs
    queryables : a "kinds" map (dict of column name -> kind), or None if column
        is non-indexable
    encoding : an encoding that will encode the query terms

    Returns
    -------
    a PyTablesExpr object

    Examples
    --------
    'index>=date'
    "columns=['A', 'D']"
    'columns=A'
    'columns==A'
    "~(columns=['A','B'])"
    'index>df.index[3] & string="bar"'
    '(index>df.index[3] & index<=df.index[6]) | string="bar"'
    "ts>=Timestamp('2012-02-01')"
    "major_axis>=20130101"
    zPyTablesExprVisitor | None_visitorr   r6   r:   r   Nr   r   r    scope_levelr   r!   r"   c                "   t          |          }|| _        d | _        d | _        d | _        d | _        d }t          |t                    r|j        j	        }|j
        }nt          |          rt          |          }t          |          D ]9\  }}t          |t                    r|j        j	        }'t          |          ||<   :d                    d t          j        |          D                       }n|}|| _
        t#          |dz   |          | _        |rt          | j
        t$                    rZ| j        j                            |           t+          | j        |dd|          | _        |                                 | _        d S d S d S )Nz & c                    g | ]}d | d	S )r   r   rb   )r   r-  s     r+   r   z)PyTablesExpr.__init__.<locals>.<listcomp>Q  s      F F FaQ F F Fr,   r$   )r&   pytables)r   r  r  rA   )r.  rA   r]   r   termsr0  r9   r,  r6   r   r   r   r   	enumerater   comflattenr   r:   r   updater   parse)	r)   wherer   rA   r1  r&   _whereidxr-  s	            r+   r(   zPyTablesExpr.__init__4  s     && 
 <@
e\** 	JZFF%   
	KKE#E** 4 4Qa.. 4!"JJ!0!3!3E#JJZZ F F3;u3E3E F F FGGFF F	 qZHHH!jC&@&@!H&&z222/%!!!  DM DJJJ "!!!r,   c                `    | j         t          | j                   S t          | j                  S r8   )r5  r   r   rL   s    r+   r   zPyTablesExpr.__repr__d  s*    :!
+++DI&&&r,   c                n   	 | j                             t                    | _        n.# t          $ r!}t          d| j         d|  d          |d}~ww xY w	 | j                             t                    | _        n.# t          $ r!}t          d| j         d|  d          |d}~ww xY w| j        | j        fS )z2create and return the numexpr condition and filterzcannot process expression [z], [z] is not a valid conditionNz] is not a valid filter)	r5  ro   rg   r]   r  r   r   ri   r   )r)   r  s     r+   rk   zPyTablesExpr.evaluatei  s   	!Z--n==DNN 	 	 	+di + +T + + +  	
	***;77DKK 	 	 	(di ( (T ( ( (  	 ~t{**s,   $' 
AAA$A; ;
B&B!!B&)NNr   )r   r    r1  r   r!   r"   r   )r-   r.   r/   __doc__r1   r(   r   rk   rb   r,   r+   r,  r,    s          6 )(((III
 -1.& .& .& .& .&`' ' ' '
+ + + + +r,   r,  c                  "    e Zd ZdZd	dZd
dZdS )r   z<hold a term value the we use to construct a condition/filterr}   r:   r!   r"   c                n    t          |t                    s
J |            || _        || _        || _        d S r8   )r9   r:   rP   	convertedr}   )r)   rP   rC  r}   s       r+   r(   zTermValue.__init__  s9    $$$**d***
"			r,   c                    | j         dk    r!|t          | j                  S d| j         dS | j         dk    rt          | j                  S t          | j                  S )z6quote the string if not encoded else encode and returnr   N"r   )r}   r:   rC  rJ   )r)   rA   s     r+   r   zTermValue.tostring  sg    9  #4>***(t~((((Y'!! '''4>"""r,   N)r}   r:   r!   r"   r   )r-   r.   r/   r@  r(   r   rb   r,   r+   r   r   }  sB        FF   
# 
# 
# 
# 
# 
#r,   r   r!   rv   c                     t           t                    sdS t          j        t          j        z   dz   }t           fd|D                       S )z7loose checking if s is a pytables-acceptable expressionF)=c              3      K   | ]}|v V  	d S r8   rb   )r   r\   r   s     r+   	<genexpr>z#maybe_expression.<locals>.<genexpr>  s'      ,,2rQw,,,,,,r,   )r9   r:   r   r   	unary_opsany)r   
operationss   ` r+   maybe_expressionrM    sV    a u$/2E2OORXXJ ,,,,,,,,,,r,   r   )?r@  
__future__r   r  decimalr   r   	functoolsr   typingr   r   r	   numpyrr   pandas._libs.tslibsr
   r   pandas.errorsr   pandas.core.dtypes.commonr   pandas.core.commoncorecommonr7  pandas.core.computationr   r   r   _scopepandas.core.computation.commonr   pandas.core.computation.exprr   pandas.core.computation.opsr   pandas.core.constructionr   pandas.core.indexes.baser   pandas.io.formats.printingr   r   pandas._typingr   r   Scoper   r5   r;   rZ   ri   rj   rg   rh   r   r   r.  Exprr,  r   rM  rb   r,   r+   <module>rd     s>   7 7 " " " " " " 



                                  1 0 0 0 0 0 2 2 2 2 2 2                           
 : 9 9 9 9 9 8 8 8 8 8 8 / / / / / / 2 2 2 2 2 2 * * * * * *       
         + + + + +FL + + +     38   B    t   k k k k kCI k k k\76 76 76 76 76% 76 76 76t    {   * * * * *U * * *Z    .       ck   &R9 R9 R9 R9 R9/ R9 R9 R9j  6f+ f+ f+ f+ f+49 f+ f+ f+R# # # # # # # #,- - - - - -r,   