
    yIf/^                    &   d Z ddlmZ ddlZddlmZmZ ddlmZm	Z	m
Z
 ddlmZmZmZmZmZmZ ddlmZmZmZ ddlmZ dd	lmZmZmZ dd
lmZmZ ddlm Z  ddl!m"Z" ddl#m$Z$ erJddl%m&Z& ee$ee$         eej'        ej(        f         e$ee$         eege)e
ee$ddf                           f         Z* G d de"          Z+ G d de"          Z, G d de"          Z- G d de"          Z. G d de.          Z/ G d de-e,e+          Z0 G d de"          Z1 G d de1          Z2 G d d e"          Z3d7d#Z4d7d$Z5d%d&d'd(d)d*d+d,d-d.d/d0d1d2Z6d3 e67                                D             Z8d4 e67                                D             Z9 G d5 d6e"          Z:dS )8zThis module contains some base nodes that can be inherited for the different nodes.

Previously these were called Mixin nodes.
    )annotationsN)	GeneratorIterator)cached_property	lru_cachepartial)TYPE_CHECKINGAnyCallableClassVarOptionalUnion)basesnodesutil)
PY310_PLUS)CallContextInferenceContextbind_context_to_node)AttributeInferenceErrorInferenceError)dunder_lookup)NodeNG)InferenceResult)LocalsDictNodeNGc                  $    e Zd ZdZdZ	 d Zd ZdS )	StatementzpStatement node adding a few attributes.

    NOTE: This class is part of the public API of 'astroid.nodes'.
    Tc                    | j                             |           }|                    |           }	 ||dz            S # t          $ r Y dS w xY w)z|The next sibling statement node.

        :returns: The next sibling statement node.
        :rtype: NodeNG or None
           N)parentchild_sequenceindex
IndexErrorselfstmtsr"   s      M/var/www/piapp/venv/lib/python3.11/site-packages/astroid/nodes/_base_nodes.pynext_siblingzStatement.next_sibling:   s`     **400D!!	## 	 	 	44	s   
< 
A
	A
c                    | j                             |           }|                    |           }|dk    r||dz
           S dS )zThe previous sibling statement.

        :returns: The previous sibling statement node.
        :rtype: NodeNG or None
        r   N)r    r!   r"   r$   s      r'   previous_siblingzStatement.previous_siblingG   sG     **400D!!A::##t    N)__name__
__module____qualname____doc__is_statementr(   r*    r+   r'   r   r   1   sF         
 L2  
 
 
 
 
r+   r   c                      e Zd ZdZddZdS )NoChildrenNodez1Base nodes for nodes with no children, e.g. Pass.returnIterator[NodeNG]c              #     K   dE d {V  d S )Nr1   r1   r%   s    r'   get_childrenzNoChildrenNode.get_childrenW   s      r+   N)r4   r5   )r,   r-   r.   r/   r8   r1   r+   r'   r3   r3   T   s.        ;;     r+   r3   c                       e Zd ZdZddZd ZdS )FilterStmtsBaseNodez6Base node for statement filtering and assignment type.mystmtStatement | Nonec                @    |                                  |u r|gdfS |dfS )zAMethod used in _filter_stmts to get statements and trigger break.TF	statement)r%   _node_stmtsr;   s        r'   _get_filtered_stmtsz'FilterStmtsBaseNode._get_filtered_stmts^   s/    >>v%% 64<u}r+   c                    | S Nr1   r7   s    r'   assign_typezFilterStmtsBaseNode.assign_typef       r+   Nr;   r<   )r,   r-   r.   r/   rC   rF   r1   r+   r'   r:   r:   [   s=        @@       r+   r:   c                       e Zd ZdZd ZddZdS )AssignTypeNodez8Base node for nodes that can 'assign' such as AnnAssign.c                    | S rE   r1   r7   s    r'   rF   zAssignTypeNode.assign_typem   rG   r+   r;   r<   c                P    | |u r|dfS |                                  |u r|gdfS |dfS )zMethod used in filter_stmts.TFr>   )r%   lookup_noderA   rB   r;   s        r'   rC   z"AssignTypeNode._get_filtered_stmtsp   sB    6>>4<>>v%% 64<u}r+   NrH   )r,   r-   r.   r/   rF   rC   r1   r+   r'   rJ   rJ   j   s=        BB       r+   rJ   c                      e Zd ZdZd ZdS )ParentAssignNodezGBase node for nodes whose assign_type is determined by the parent node.c                4    | j                                         S rE   )r    rF   r7   s    r'   rF   zParentAssignNode.assign_type~   s    {&&(((r+   N)r,   r-   r.   r/   rF   r1   r+   r'   rO   rO   {   s)        QQ) ) ) ) )r+   rO   c                  D    e Zd ZU dZded<   	 ded<   	 d Zddd
ZddZdS )
ImportNodez$Base node for From and Import Nodes.
str | Nonemodnamezlist[tuple[str, str | None]]namesc                    |S rE   r1   )r%   framenames      r'   _infer_namezImportNode._infer_name   rG   r+   Nr4   nodes.Modulec                   |                                  }t          | dd          }|| j        }|r"|                    ||          |j        k    rd}nd}|                    ||t          |o|dk              |          S )zGReturn the ast for a module whose name is <modname> imported by <self>.levelNFTr   )r\   relative_only	use_cache)rootgetattrrT   relative_to_absolute_namerX   import_modulebool)r%   rT   mymoduler\   r^   s        r'   do_import_modulezImportNode.do_import_module   s    99;;#D'488?lG
 	 227EBBhmSSIII %%u3!44	 & 
 
 	
r+   asnamestrc                    | j         D ]9\  }}|dk    r|c S |s|                    dd          d         }|}||k    r|c S :t          d| |          )zGet name from 'as' name.*.r   r   z:Could not find original name for {attribute} in {target!r})target	attribute)rU   splitr   )r%   rf   rX   _asnames       r'   	real_namezImportNode.real_name   s    !Z 	 	MD's{{ zz#q))!,   !%H
 
 
 	
r+   rE   )rT   rS   r4   rZ   )rf   rg   r4   rg   )r,   r-   r.   r/   __annotations__rY   re   ro   r1   r+   r'   rR   rR      s|         ..
 ('''  
 
 
 
 
4
 
 
 
 
 
r+   rR   c                  b    e Zd ZU dZdZded<   ed             Zd Zd Z	d Z
edd            ZdS )MultiLineBlockNodea(  Base node for multi-line blocks, e.g. For and FunctionDef.

    Note that this does not apply to every node with a `body` field.
    For instance, an If node has a multi-line body, but the body of an
    IfExpr is not multi-line, and hence cannot contain Return nodes,
    Assign nodes, etc.
    r1   zClassVar[tuple[str, ...]]_multi_line_block_fieldsc                D     t           fd j        D                       S )Nc              3  8   K   | ]}t          |          V  d S rE   )r`   ).0fieldr%   s     r'   	<genexpr>z8MultiLineBlockNode._multi_line_blocks.<locals>.<genexpr>   s-      UUeWT5))UUUUUUr+   )tuplers   r7   s   `r'   _multi_line_blocksz%MultiLineBlockNode._multi_line_blocks   s)    UUUUt7TUUUUUUr+   c              #  l   K   | j         D ])}|D ]$}|j        r
|                                E d {V  %*d S rE   )rz   is_function _get_return_nodes_skip_functionsr%   block
child_nodes      r'   r}   z3MultiLineBlockNode._get_return_nodes_skip_functions   sr      , 	I 	IE# I I
) %FFHHHHHHHHHHI	I 	Ir+   c              #  l   K   | j         D ])}|D ]$}|j        r
|                                E d {V  %*d S rE   )rz   r|   _get_yield_nodes_skip_functionsr~   s      r'   r   z2MultiLineBlockNode._get_yield_nodes_skip_functions   sr      , 	H 	HE# H H
) %EEGGGGGGGGGGH	H 	Hr+   c              #  l   K   | j         D ])}|D ]$}|j        r
|                                E d {V  %*d S rE   )rz   	is_lambda_get_yield_nodes_skip_lambdasr~   s      r'   r   z0MultiLineBlockNode._get_yield_nodes_skip_lambdas   sr      , 	F 	FE# F F
' %CCEEEEEEEEEEF	F 	Fr+   r4   list[nodes.Assign]c                |    d | j         D             }t          t          j                            |                    S )Nc              3  .   K   | ]}|D ]}|j         V  d S rE   )_assign_nodes_in_scope)rv   r   r   s      r'   rx   z<MultiLineBlockNode._assign_nodes_in_scope.<locals>.<genexpr>   sP       !
 !
#!
 !
  -!
 !
 !
 !
 !
 !
 !
r+   )rz   list	itertoolschainfrom_iterable)r%   children_assign_nodess     r'   r   z)MultiLineBlockNode._assign_nodes_in_scope   sE    !
 !
0!
 !
 !

 IO112GHHIIIr+   N)r4   r   )r,   r-   r.   r/   rs   rp   r   rz   r}   r   r   r   r1   r+   r'   rr   rr      s           ;=<<<<V V _VI I IH H HF F F J J J _J J Jr+   rr   c                  4    e Zd ZdZed             Z	 dddZdS )MultiLineWithElseBlockNodez>Base node for multi-line blocks that can have else statements.c                    | j         S rE   )linenor7   s    r'   blockstart_tolinenoz.MultiLineWithElseBlockNode.blockstart_tolineno   s
    {r+   Nr   intorelselist[nodes.NodeNG]last
int | Noner4   tuple[int, int]c                    || j         k    r||fS |r2||d         j         k    r||d         j        fS ||d         j         dz
  fS ||p| j        fS )z_Handle block line numbers range for try/finally, for, if and while
        statements.
        r   r   )
fromlinenotolineno)r%   r   r   r   s       r'   _elsed_block_rangez-MultiLineWithElseBlockNode._elsed_block_range   sp     T_$$6>! 	4---vbz2226!9/!333t,t},,r+   rE   )r   r   r   r   r   r   r4   r   )r,   r-   r.   r/   r   r   r   r1   r+   r'   r   r      sS        HH  _ KO- - - - - - -r+   r   c                  0    e Zd ZdZed	d            Zd ZdS )
LookupMixInz+Mixin to look up a name in the right scope.rX   rg   r4   %tuple[LocalsDictNodeNG, list[NodeNG]]c                R    |                                                      | |          S )a#  Lookup where the given variable is assigned.

        The lookup starts from self's scope. If self is not a frame itself
        and the name is found in the inner frame locals, statements will be
        filtered to remove ignorable statements according to self's location.

        :param name: The name of the variable to find assignments for.

        :returns: The scope node and the list of assignments associated to the
            given name according to the scope where it has been found (locals,
            globals or builtin).
        )scopescope_lookup)r%   rX   s     r'   lookupzLookupMixIn.lookup  s"     zz||((t444r+   c                z    |                      |          \  }}t                      }t          j        |||          S )a
  Lookup the inferred values of the given variable.

        :param name: The variable name to find values for.
        :type name: str

        :returns: The inferred values of the statements returned from
            :meth:`lookup`.
        :rtype: iterable
        )r   r   r   _infer_stmts)r%   rX   rW   r&   contexts        r'   ilookupzLookupMixIn.ilookup  s9     {{4((u"$$!%%888r+   N)rX   rg   r4   r   )r,   r-   r.   r/   r   r   r   r1   r+   r'   r   r     sG        555 5 5 Y59 9 9 9 9r+   r   r4   rg   c                    d| dd          z   S )N__r   r1   rX   s    r'   _reflected_namer   &      48r+   c                    d| dd          z   S )N__ir   r1   r   s    r'   _augmented_namer   *  r   r+   __add____sub____truediv____floordiv____mul____pow____mod____and____or____xor__
__lshift__
__rshift__
__matmul__)+-/z//ri   z**%&|^z<<z>>@c                4    i | ]\  }}|t          |          S r1   )r   rv   keyvalues      r'   
<dictcomp>r   >  s3       $0S%C		  r+   c                :    i | ]\  }}|d z   t          |          S )=)r   r   s      r'   r   r   A  s7       *63C#Iu%%  r+   c                  4   e Zd Zed4d	            Zed5d            Zed6d            Zed7d            Ze	 d8d9d            Ze	 d8d:d            Z	ed;d#            Z
ed$             Zed5d%            Zed<d,            Zed=d.            Zed>d2            Zd3S )?OperatorNodeinfer_callablefCallable[[InferenceContext | None], Generator[InferenceResult | util.BadOperationMessage, None, None]]r   InferenceContext | Noneerrortype[util.BadOperationMessage]r4   &Generator[InferenceResult, None, None]c              #  l   K    | |          D ]%}t          ||          rt          j        V  !|V  &d S rE   )
isinstancer   Uninferable)r   r   r   results       r'   _filter_operation_errorsz%OperatorNode._filter_operation_errorsG  s\       %nW-- 	 	F&%((  &&&&&	 	r+   rc   c                R    t          | t          j                  o| j        t          u S )z0Check if the given const node is NotImplemented.)r   r   Constr   NotImplemented)consts    r'   _is_not_implementedz OperatorNode._is_not_implementedY  s"     %--O%+2OOr+   instancenodes.Constothernodes.NodeNGr   )tuple[util.UninferableBase | nodes.Const]c                t   t          |t          j                  rit          j        |j        v rt          j        fS fd|j        D             }t          d |D                       rt          d |D                       }nd}nt          |t          j                  ri }|j	        D ]}t          j
        |d                   }t          |t          j                  st          j        fc S t          j
        |d                   }t          |t          j                  st          j        fc S |j        ||j        <   n/t          |t          j                  r|j        }nt          j        fS 	 t          j        | j        |z            fS # t          t          t           f$ r t          j        fcY S w xY w)zInfer the result of '"string" % ...'.

        TODO: Instead of returning Uninferable we should rely
        on the call to '%' to see if the result is actually uninferable.
        c                :    g | ]}t          j        |          S r1   )r   
safe_infer)rv   ir   s     r'   
<listcomp>zCOperatorNode._infer_old_style_string_formatting.<locals>.<listcomp>j  s%    "S"S"S14?1g#>#>"S"S"Sr+   c              3  J   K   | ]}t          |t          j                  V  d S rE   )r   r   r   rv   r   s     r'   rx   zBOperatorNode._infer_old_style_string_formatting.<locals>.<genexpr>k  s.      KK!:a--KKKKKKr+   c              3  $   K   | ]}|j         V  d S rE   )r   r   s     r'   rx   zBOperatorNode._infer_old_style_string_formatting.<locals>.<genexpr>l  s$      DD1qwDDDDDDr+   Nr   r   )r   r   Tupler   r   eltsallry   Dictitemsr   r   r   const_factory	TypeErrorKeyError
ValueError)r   r   r   inferred_positionalvaluespairr   r   s     `     r'   "_infer_old_style_string_formattingz/OperatorNode._infer_old_style_string_formatting^  s    eU[)) 	'5:--(**"S"S"S"S
"S"S"SKK7JKKKKK DD0CDDDDDuz** 	'%'F 0 0od1gw77!#u{33 / ,....Q99!%55 / ,....$)Ksy!!0 u{++ 	'[FF$&&	''(?@@BB8Z0 	' 	' 	'$&&&&	's   3F $F76F7r   opnodenodes.AugAssign | nodes.BinOpoprg   method_namec                   t          j        | |          }t          ||           }|d         }||j        _        t          | t          j                  rIt          | j        t                    r/|dk    r)t          t                              | ||                    S 	 t          |                    |                    }n$# t          $ r}	t!          ||          |	d}	~	ww xY wt          |t"          j                  rt           t          | t          j        t          j        t          j        t          j        t,          j        f          st           |                     |||||          S )z8Invoke binary operation inference on the given instance.r   r   )r   )rA   r   N)r   r   r   callcontextcalleer   r   r   r   rg   iterr   r   nextinferStopIterationr   r   UninferableBaser   ListClassDefr   Instanceinfer_binary_op)
r   r   r   r   r   r   methodsmethodinferredes
             r'   _invoke_binop_inferencez$OperatorNode._invoke_binop_inference  sa     &x==&w99%+" x--		8>3//		 c		??eW   	FFLLL99::HH 	F 	F 	F fg>>>AE	Fh 455 	!  [%+uz5>5>R
 
 	! ! ''E7HMMMs   #C 
C#CC#Fnodes.AugAssignreverse/partial[Generator[InferenceResult, None, None]]c           	     \    t           |         }t          t          j        | |||||          S )z<Get an inference callable for an augmented binary operation.r   r   r   r   r   r   )AUGMENTED_OP_METHODr   r   r  r   r   r   r   r   r  r   s          r'   _aug_opzOperatorNode._aug_op  s=     *"-0#
 
 
 	
r+   c           	     |    |rt           |         }nt          |         }t          t          j        | |||||          S )zGet an inference callable for a normal binary operation.

        If *reverse* is True, then the reflected method will be used instead.
        r  )REFLECTED_BIN_OP_METHODBIN_OP_METHODr   r   r  r  s          r'   _bin_opzOperatorNode._bin_op  sQ      	,1"5KK'+K0#
 
 
 	
r+   left.bases.UnionType | nodes.ClassDef | nodes.Constrightc              #  8   K   t          j        | |          V  dS )z>Create a new UnionType instance for binary or, e.g. int | str.N)r   	UnionType)r  r  s     r'   _bin_op_or_union_typez"OperatorNode._bin_op_or_union_type  s&       odE*******r+   c              #     K   ||fD ]7}|                                  }t          |g          |_        d|_        |V  8dS )zGet contexts for binary operations.

        This will return two inference contexts, the first one
        for x.__op__(y), the other one for y.__rop__(x), where
        only the arguments are inversed.
        )argsN)cloner   r   	boundnode)r   r  r  argnew_contexts        r'   _get_binop_contextsz OperatorNode._get_binop_contexts  s^       4= 	 	C!--//K&1u&=&=&=K#$(K!		 	r+   c                V    |                                  |                                 k    S )z$Check if type1 is the same as type2.)qname)type1type2s     r'   
_same_typezOperatorNode._same_type  s     {{}}--r+   	left_typeInferenceResult | None
aug_opnode
right_typereverse_context5list[partial[Generator[InferenceResult, None, None]]]c           
     F   ddl m} |j                            d          }|j        }	t                              ||          r>t                              | ||	||          t                              | ||||          g}
n |                    ||          r=t                              | ||	||          t                              | ||||          g}
n|	                    ||          r\t                              | ||	||          t                              |||| |d          t                              | ||||          g}
n[t                              | ||	||          t                              | ||||          t                              |||| |d          g}
|
S )a  Get the flow for augmented binary operations.

        The rules are a bit messy:

            * if left and right have the same type, then left.__augop__(right)
            is first tried and then left.__op__(right).
            * if left and right are unrelated typewise, then
            left.__augop__(right) is tried, then left.__op__(right)
            is tried and then right.__rop__(left) is tried.
            * if left is a subtype of right, then left.__augop__(right)
            is tried and then left.__op__(right).
            * if left is a supertype of right, then left.__augop__(right)
            is tried, then right.__rop__(left) and then
            left.__op__(right)
        r   helpersr   Tr  )
astroidr6  r   stripr   r-  r  r  
is_subtypeis_supertype)r  r.  r0  r  r1  r   r2  r6  bin_opaug_opr  s              r'   _get_aug_flowzOperatorNode._get_aug_flow  s   2 	$#####$$S))""9j99 	$$T:vugNN$$T:vugNNGG 	:66 	$$T:vugNN$$T:vugNNGG !!)Z88 	$$T:vugNN$$:vt_d %   $$T:vugNNGG $$T:vugNN$$T:vugNN$$:vt_d %  G r+   binary_opnodec           	        ddl m} |j        }t                              ||          r t                              | ||||          g}	n|                    ||          r t                              | ||||          g}	n|                    ||          r?t                              |||| |d          t                              | ||||          g}	n>t                              | ||||          t                              |||| |d          g}	t          r|dk    rt          | t          j        t          j        f          s!t          | t          j                  r}| j        vt          |t          j        t          j        f          s!t          |t          j                  r6|j        /|	                    t#          t          j        | |          g           |	S )ax  Get the flow for binary operations.

        The rules are a bit messy:

            * if left and right have the same type, then only one
            method will be called, left.__op__(right)
            * if left and right are unrelated typewise, then first
            left.__op__(right) is tried and if this does not exist
            or returns NotImplemented, then right.__rop__(left) is tried.
            * if left is a subtype of right, then only left.__op__(right)
            is tried.
            * if left is a supertype of right, then right.__rop__(left)
            is first tried and then left.__op__(right)
        r   r5  Tr7  r   )r8  r6  r   r   r-  r  r:  r;  r   r   r   r   r   r  r   r   extendr   r!  )
r  r.  r?  r  r1  r   r2  r6  r   r  s
             r'   _get_binop_flowzOperatorNode._get_binop_flow0  s   0 	$#####""9j99 	#++D-UGTTUGG	:66 	#++D-UGTTUGG!!)Z88 	$$="dOT %   $$T="eWMM	GG $$T="eWMM$$="dOT %  G 	Wc		4%/5>!BCC  dEK00  J& 55?EN"CDD ' eU[11	 '
 K' NNGL$FeTTUVVVr+   flow_factoryGetFlowFactoryGGenerator[InferenceResult | util.BadBinaryOperationMessage, None, None]c           	   #    K   ddl m} t                              || |          \  }}|                    |           }|                    |          } || ||||||          }	|	D ]}
	 t           |
                      }t          d |D                       rt          j        V   dS t          t          t          j        |                    rlt          d |D                       }|r$|t          |          k    rt          j        V   dS |E d{V   dS # t          $ r Y t          $ r Y t           $ r t          j        V  Y  dS w xY wt          j        ||j        |          V  dS )zInfer a binary operation between a left operand and a right operand.

        This is used by both normal binary operations and augmented binary
        operations, the only difference is the flow factory used.
        r   r5  c              3  J   K   | ]}t          |t          j                  V  d S rE   )r   r   r  rv   r   s     r'   rx   z7OperatorNode._infer_binary_operation.<locals>.<genexpr>  s/      VVFz&$*>??VVVVVVr+   Nc              3  N   K   | ] }t                               |          d V  !dS )r   N)r   r   rH  s     r'   rx   z7OperatorNode._infer_binary_operation.<locals>.<genexpr>  sJ       & & |/O/OPV/W/W&& & & & & &r+   )r8  r6  r   r(  object_typer   anyr   r   r   mapr   sumlenAttributeErrorr   r   BadBinaryOperationMessager   )r  r  r?  r   rC  r6  r2  r.  r1  r  r  resultsnot_implementeds                r'   _infer_binary_operationz$OperatorNode._infer_binary_operationo  s      	$######/#C#CT5$
 $
  ''--	((//
,)]E:w
 
  	 	Fvvxx.. VVgVVVVV ****FFs<;WEEFF "% & &$+& & & # # # #g,,'F'F****FF""""""""/ "   *   !   &&&&, ,Y8H*UUUUUUUs   (D
E'	E2EEN)r   r   r   r   r   r   r4   r   )r4   rc   )r   r   r   r   r   r   r4   r   )r   r   r   r   r   rg   r   r   r   r   r   rg   r4   r   )F)r   r   r   r  r   rg   r   r   r   r   r  rc   r4   r  )r   r   r   r   r   rg   r   r   r   r   r  rc   r4   r  )r  r  r  r  r4   r   )r  r   r.  r/  r0  r  r  r   r1  r/  r   r   r2  r   r4   r3  )r  r   r.  r/  r?  r   r  r   r1  r/  r   r   r2  r   r4   r3  )r  r   r  r   r?  r   r   r   rC  rD  r4   rE  )r,   r-   r.   staticmethodr   r   r   r  r  r  r!  r(  r-  r>  rB  rS  r1   r+   r'   r   r   F  s          \" P P P \P "' "' "' \"'H $N $N $N \$NL  
 
 
 
 \
(  
 
 
 
 \
4 + + + \+   \ . . . \. 6 6 6 \6p < < < \<| 3V 3V 3V \3V 3V 3Vr+   r   )r4   rg   );r/   
__future__r   r   collections.abcr   r   	functoolsr   r   r   typingr	   r
   r   r   r   r   r8  r   r   r   astroid.constr   astroid.contextr   r   r   astroid.exceptionsr   r   astroid.interpreterr   astroid.nodes.node_ngr   astroid.typingr   astroid.nodes.node_classesr   	AugAssignBinOpr   rD  r   r3   r:   rJ   rO   rR   rr   r   r   r   r   r  r   r  r  r   r1   r+   r'   <module>rb     sT  
 
 # " " " " "     / / / / / / / / 9 9 9 9 9 9 9 9 9 9 J J J J J J J J J J J J J J J J & & & & & & & & & & $ $ $ $ $ $         
        . - - - - - ( ( ( ( ( ( * * * * * * ;;;;;;_%%/5;./_%	
 	WYd:;<=		?N               F    V       &       V   ") ) ) ) )~ ) ) );
 ;
 ;
 ;
 ;
$ni ;
 ;
 ;
|+J +J +J +J +J +J +J +J\- - - - -!3 - - -,9 9 9 9 9& 9 9 9D      
 
		
	
				

	   4A4G4G4I4I    :G:M:M:O:O   
]V ]V ]V ]V ]V6 ]V ]V ]V ]V ]Vr+   