
    *eTL                       d Z ddlmZ ddlmZ ddl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mZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:  G d d          Z;d>dZ<d?dZ=d@dZ> ed          Z?eeee@f         e
e?         f         ZA G d dee?                   ZBee
e?         e
e?         f         ZC G d de.eCe?                            ZD G d deDe:                   ZEdAdZF	 dBdCd#ZG G d$ d%eDe:                   ZHdDd'ZI G d( d)eDe:                   ZJdAd*ZKdEd-ZL G d. d/eDe:                   ZMdFd0ZNdZOd1ZP	 dGdHd=ZQd2S )IzData-flow analyses.    )annotations)abstractmethod)DictGenericIterableIteratorSetTupleTypeVar)
all_values)+AssignAssignMulti
BasicBlockBoxBranchCallCallCCastComparisonOp	ControlOpExtendFloatFloatComparisonOpFloatNegFloatOpGetAttrGetElementPtrGoto
InitStaticIntegerIntOp	KeepAliveLoadAddressLoadErrorValue
LoadGlobalLoadLiteralLoadMem
LoadStatic
MethodCallOp	OpVisitorRaiseStandardError
RegisterOpReturnSetAttrSetMemTruncateTupleGetTupleSetUnborrowUnboxUnreachableValuec                  "    e Zd ZdZdd	ZddZdS )CFGzyControl-flow graph.

    Node 0 is always assumed to be the entry point. There must be a
    non-empty set of exits.
    succ"dict[BasicBlock, list[BasicBlock]]predexitsset[BasicBlock]returnNonec                8    |sJ || _         || _        || _        d S N)r:   r<   r=   )selfr:   r<   r=   s       7lib/python3.11/site-packages/mypyc/analysis/dataflow.py__init__zCFG.__init__?   s&     		


    strc                Z    t          | j        d           }d| d| j         d| j         S )Nc                *    t          | j                  S rB   )intlabel)es    rD   <lambda>zCFG.__str__.<locals>.<lambda>K   s    QW rF   )keyzexits: z
succ: z
pred: )sortedr=   r:   r<   )rC   r=   s     rD   __str__zCFG.__str__J   s<    tz'='=>>>FFF	FF49FFFrF   N)r:   r;   r<   r;   r=   r>   r?   r@   r?   rG   )__name__
__module____qualname____doc__rE   rP    rF   rD   r9   r9   8   sL         	 	 	 	G G G G G GrF   r9   blockslist[BasicBlock]r?   c                   i }i }t                      }| D ]}t          d |j        dd         D                       r
J d            t          |j                                                  }|s|                    |           |g|z   D ]#}|j        r|                    |j                   $|||<   g ||<   |	                                D ]%\  }}|D ]}	||	                             |           &t          |||          S )zCalculate basic block control-flow graph.

    The result is a dictionary like this:

         basic block index -> (successors blocks, predecesssor blocks)
    c              3  @   K   | ]}t          |t                    V  d S rB   )
isinstancer   ).0ops     rD   	<genexpr>zget_cfg.<locals>.<genexpr>Z   s=       
 
*,Jr9%%
 
 
 
 
 
rF   Nz-Control-flow ops must be at the end of blocks)setanyopslist
terminatortargetsadderror_handlerappenditemsr9   )
rW   succ_mappred_mapr=   blockr:   error_pointprevnxtrK   s
             rD   get_cfgrp   O   sW    H35HEEE   
 
05	#2#
 
 
 
 
 	; 	;:	; 	; 	; E$,,..// 	IIe "7T> 	7 	7K( 7K5666^^%% ) )	c 	) 	)EUO""4((((	)x5)))rF   rK   r   c                    t          | j                  dk    r2t          | j        d         t                    r| j        d         j        } | S )N   r_   )lenrb   r[   r   rK   )rK   s    rD   get_real_targetrt   z   s=    
59~~z%)B->>	"#LrF   r@   c                   d}|r| D ]V}t          |j                                                  D ]-\  }}|j                            |t	          |                     .Wd}t          |           }|                                 }|                                  t          |          D ]0\  }}|dk    s|j        |         r| 	                    |           .d}1|dS dS )zCleanup the control flow graph.

    This eliminates obviously dead basic blocks and eliminates blocks that contain
    nothing but a single jump.

    There is a lot more that could be done.
    TFr   N)
	enumeraterd   re   
set_targetrt   rp   copyclearr<   rh   )rW   changedrl   itgtcfgorig_blockss          rD   cleanup_cfgr      s    G
  	E 	EE#E$4$<$<$>$>?? E E3 ++As/C/CDDDDE fookkmm!+.. 	 	HAuAvv%ve$$$$      rF   Tc                      e Zd Zd
dZddZd	S )AnalysisResultbeforeAnalysisDict[T]afterr?   r@   c                "    || _         || _        d S rB   r   r   )rC   r   r   s      rD   rE   zAnalysisResult.__init__   s    


rF   rG   c                (    d| j          d| j         dS )Nzbefore: z
after: 
r   )rC   s    rD   rP   zAnalysisResult.__str__   s    >$+>>
>>>>rF   N)r   r   r   r   r?   r@   rQ   )rR   rS   rT   rE   rP   rV   rF   rD   r   r      s<           ? ? ? ? ? ?rF   r   c                  V   e Zd ZdGdZedHd            ZedId	            ZedJd            ZedKd            ZdLdZ	dMdZ
dNdZdOdZdPdZdQdZdRdZdSdZdTdZdUd!ZdVd#ZdWd%ZdXd'ZdYd)ZdZd+Zd[d-Zd\d/Zd]d1Zd^d3Zd_d5Zd`d7Zdad9Zdbd;Zdcd=Z ddd?Z!dedAZ"dfdCZ#dgdEZ$dFS )hBaseAnalysisVisitorr]   r   r?   GenAndKill[T]c                :    t                      t                      fS rB   r`   rC   r]   s     rD   
visit_gotozBaseAnalysisVisitor.visit_goto       uucee|rF   r-   c                    t           rB   NotImplementedErrorr   s     rD   visit_register_opz%BaseAnalysisVisitor.visit_register_op       !!rF   r   c                    t           rB   r   r   s     rD   visit_assignz BaseAnalysisVisitor.visit_assign   r   rF   r   c                    t           rB   r   r   s     rD   visit_assign_multiz&BaseAnalysisVisitor.visit_assign_multi   r   rF   r0   c                    t           rB   r   r   s     rD   visit_set_memz!BaseAnalysisVisitor.visit_set_mem   r   rF   r   c                ,    |                      |          S rB   r   r   s     rD   
visit_callzBaseAnalysisVisitor.visit_call       %%b)))rF   r)   c                ,    |                      |          S rB   r   r   s     rD   visit_method_callz%BaseAnalysisVisitor.visit_method_call   r   rF   r$   c                ,    |                      |          S rB   r   r   s     rD   visit_load_error_valuez*BaseAnalysisVisitor.visit_load_error_value   r   rF   r&   c                ,    |                      |          S rB   r   r   s     rD   visit_load_literalz&BaseAnalysisVisitor.visit_load_literal   r   rF   r   c                ,    |                      |          S rB   r   r   s     rD   visit_get_attrz"BaseAnalysisVisitor.visit_get_attr   r   rF   r/   c                ,    |                      |          S rB   r   r   s     rD   visit_set_attrz"BaseAnalysisVisitor.visit_set_attr   r   rF   r(   c                ,    |                      |          S rB   r   r   s     rD   visit_load_staticz%BaseAnalysisVisitor.visit_load_static   r   rF   r   c                ,    |                      |          S rB   r   r   s     rD   visit_init_staticz%BaseAnalysisVisitor.visit_init_static   r   rF   r2   c                ,    |                      |          S rB   r   r   s     rD   visit_tuple_getz#BaseAnalysisVisitor.visit_tuple_get   r   rF   r3   c                ,    |                      |          S rB   r   r   s     rD   visit_tuple_setz#BaseAnalysisVisitor.visit_tuple_set   r   rF   r   c                ,    |                      |          S rB   r   r   s     rD   	visit_boxzBaseAnalysisVisitor.visit_box   r   rF   r5   c                ,    |                      |          S rB   r   r   s     rD   visit_unboxzBaseAnalysisVisitor.visit_unbox   r   rF   r   c                ,    |                      |          S rB   r   r   s     rD   
visit_castzBaseAnalysisVisitor.visit_cast   r   rF   r,   c                ,    |                      |          S rB   r   r   s     rD   visit_raise_standard_errorz.BaseAnalysisVisitor.visit_raise_standard_error   r   rF   r   c                ,    |                      |          S rB   r   r   s     rD   visit_call_cz BaseAnalysisVisitor.visit_call_c   r   rF   r1   c                ,    |                      |          S rB   r   r   s     rD   visit_truncatez"BaseAnalysisVisitor.visit_truncate   r   rF   r   c                ,    |                      |          S rB   r   r   s     rD   visit_extendz BaseAnalysisVisitor.visit_extend   r   rF   r%   c                ,    |                      |          S rB   r   r   s     rD   visit_load_globalz%BaseAnalysisVisitor.visit_load_global   r   rF   r!   c                ,    |                      |          S rB   r   r   s     rD   visit_int_opz BaseAnalysisVisitor.visit_int_op   r   rF   r   c                ,    |                      |          S rB   r   r   s     rD   visit_float_opz"BaseAnalysisVisitor.visit_float_op   r   rF   r   c                ,    |                      |          S rB   r   r   s     rD   visit_float_negz#BaseAnalysisVisitor.visit_float_neg   r   rF   r   c                ,    |                      |          S rB   r   r   s     rD   visit_comparison_opz'BaseAnalysisVisitor.visit_comparison_op   r   rF   r   c                ,    |                      |          S rB   r   r   s     rD   visit_float_comparison_opz-BaseAnalysisVisitor.visit_float_comparison_op  r   rF   r'   c                ,    |                      |          S rB   r   r   s     rD   visit_load_memz"BaseAnalysisVisitor.visit_load_mem  r   rF   r   c                ,    |                      |          S rB   r   r   s     rD   visit_get_element_ptrz)BaseAnalysisVisitor.visit_get_element_ptr  r   rF   r#   c                ,    |                      |          S rB   r   r   s     rD   visit_load_addressz&BaseAnalysisVisitor.visit_load_address  r   rF   r"   c                ,    |                      |          S rB   r   r   s     rD   visit_keep_alivez$BaseAnalysisVisitor.visit_keep_alive  r   rF   r4   c                ,    |                      |          S rB   r   r   s     rD   visit_unborrowz"BaseAnalysisVisitor.visit_unborrow  r   rF   N)r]   r   r?   r   )r]   r-   r?   r   )r]   r   r?   r   )r]   r   r?   r   )r]   r0   r?   r   )r]   r   r?   r   )r]   r)   r?   r   )r]   r$   r?   r   )r]   r&   r?   r   )r]   r   r?   r   )r]   r/   r?   r   )r]   r(   r?   r   )r]   r   r?   r   )r]   r2   r?   r   )r]   r3   r?   r   )r]   r   r?   r   )r]   r5   r?   r   )r]   r   r?   r   )r]   r,   r?   r   )r]   r   r?   r   )r]   r1   r?   r   )r]   r   r?   r   )r]   r%   r?   r   )r]   r!   r?   r   )r]   r   r?   r   )r]   r   r?   r   )r]   r   r?   r   )r]   r   r?   r   )r]   r'   r?   r   )r]   r   r?   r   )r]   r#   r?   r   )r]   r"   r?   r   )r]   r4   r?   r   )%rR   rS   rT   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rV   rF   rD   r   r      s           " " " ^" " " " ^" " " " ^" " " " ^"* * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * * * *rF   r   c                  T    e Zd ZdZdddZddZddZddZddZddZ	d dZ
d!dZdS )"DefinedVisitora  Visitor for finding defined registers.

    Note that this only deals with registers and not temporaries, on
    the assumption that we never access temporaries when they might be
    undefined.

    If strict_errors is True, then we regard any use of LoadErrorValue
    as making a register undefined. Otherwise we only do if
    `undefines` is set on the error value.

    This lets us only consider the things we care about during
    uninitialized variable checking while capturing all possibly
    undefined things for refcounting.
    Fstrict_errorsboolr?   r@   c                    || _         d S rB   r   )rC   r   s     rD   rE   zDefinedVisitor.__init__%  s    *rF   r]   r   GenAndKill[Value]c                :    t                      t                      fS rB   r   r   s     rD   visit_branchzDefinedVisitor.visit_branch(  r   rF   r.   c                :    t                      t                      fS rB   r   r   s     rD   visit_returnzDefinedVisitor.visit_return+  r   rF   r6   c                :    t                      t                      fS rB   r   r   s     rD   visit_unreachablez DefinedVisitor.visit_unreachable.  r   rF   r-   c                :    t                      t                      fS rB   r   r   s     rD   r   z DefinedVisitor.visit_register_op1  r   rF   r   c                    t          |j        t                    r)|j        j        s| j        rt                      |j        hfS |j        ht                      fS rB   )r[   srcr$   	undefinesr   r`   destr   s     rD   r   zDefinedVisitor.visit_assign4  sR    bfn-- 	$263C 	$tGY 	$5527)##G9cee##rF   r   c                :    t                      t                      fS rB   r   r   s     rD   r   z!DefinedVisitor.visit_assign_multi;  s    uucee|rF   r0   c                :    t                      t                      fS rB   r   r   s     rD   r   zDefinedVisitor.visit_set_mem?  r   rF   NF)r   r   r?   r@   r]   r   r?   r   r]   r.   r?   r   r]   r6   r?   r   r]   r-   r?   r   r]   r   r?   r   r]   r   r?   r   r]   r0   r?   r   )rR   rS   rT   rU   rE   r   r   r   r   r   r   r   rV   rF   rD   r   r     s         + + + + +            $ $ $ $        rF   r   r}   initial_defined
set[Value]AnalysisResult[Value]c                N    t          | |t                      |dt                    S )zCalculate potentially defined registers at each CFG location.

    A register is defined if it has a value along some path from the initial location.
    FrW   r}   gen_and_killinitialbackwardkind)run_analysisr   MAYBE_ANALYSIS)rW   r}   r   s      rD   analyze_maybe_defined_regsr   C  s3     #%%   rF   FregsIterable[Value]r   r   c                n    t          | |t          |          |dt          t          |                    S )aI  Calculate always defined registers at each CFG location.

    This analysis can work before exception insertion, since it is a
    sound assumption that registers defined in a block might not be
    initialized in its error handler.

    A register is defined if it has a value along all paths from the
    initial location.
    r   FrW   r}   r   r   r   r   universe)r   r   MUST_ANALYSISr`   )rW   r}   r   r   r   s        rD   analyze_must_defined_regsr  T  sA      #-@@@T   rF   c                  N    e Zd ZddZdd	ZddZddZddZddZddZ	ddZ
dS )BorrowedArgumentsVisitorargsr   r?   r@   c                    || _         d S rB   )r  )rC   r  s     rD   rE   z!BorrowedArgumentsVisitor.__init__p  s    			rF   r]   r   r   c                :    t                      t                      fS rB   r   r   s     rD   r   z%BorrowedArgumentsVisitor.visit_branchs  r   rF   r.   c                :    t                      t                      fS rB   r   r   s     rD   r   z%BorrowedArgumentsVisitor.visit_returnv  r   rF   r6   c                :    t                      t                      fS rB   r   r   s     rD   r   z*BorrowedArgumentsVisitor.visit_unreachabley  r   rF   r-   c                :    t                      t                      fS rB   r   r   s     rD   r   z*BorrowedArgumentsVisitor.visit_register_op|  r   rF   r   c                    |j         | j        v rt                      |j         hfS t                      t                      fS rB   )r   r  r`   r   s     rD   r   z%BorrowedArgumentsVisitor.visit_assign  s6    7di5527)##uucee|rF   r   c                :    t                      t                      fS rB   r   r   s     rD   r   z+BorrowedArgumentsVisitor.visit_assign_multi  r   rF   r0   c                :    t                      t                      fS rB   r   r   s     rD   r   z&BorrowedArgumentsVisitor.visit_set_mem  r   rF   N)r  r   r?   r@   r   r   r   r   r   r   r   )rR   rS   rT   rE   r   r   r   r   r   r   r   rV   rF   rD   r  r  o  s                          
        rF   r  borrowedc           	     R    t          | |t          |          |dt          |          S )zCalculate arguments that can use references borrowed from the caller.

    When assigning to an argument, it no longer is borrowed.
    Fr  )r   r  r  )rW   r}   r  s      rD   analyze_borrowed_argumentsr    s8     -h77   rF   c                  F    e Zd ZddZddZdd	ZddZddZddZddZ	dS )UndefinedVisitorr]   r   r?   r   c                :    t                      t                      fS rB   r   r   s     rD   r   zUndefinedVisitor.visit_branch  r   rF   r.   c                :    t                      t                      fS rB   r   r   s     rD   r   zUndefinedVisitor.visit_return  r   rF   r6   c                :    t                      t                      fS rB   r   r   s     rD   r   z"UndefinedVisitor.visit_unreachable  r   rF   r-   c                N    t                      |j        s|hnt                      fS rB   )r`   is_voidr   s     rD   r   z"UndefinedVisitor.visit_register_op  s"    uu"*7rdd#%%77rF   r   c                .    t                      |j        hfS rB   r`   r   r   s     rD   r   zUndefinedVisitor.visit_assign      uurwirF   r   c                .    t                      |j        hfS rB   r  r   s     rD   r   z#UndefinedVisitor.visit_assign_multi  r  rF   r0   c                :    t                      t                      fS rB   r   r   s     rD   r   zUndefinedVisitor.visit_set_mem  r   rF   Nr   r   r   r   r   r   r   
rR   rS   rT   r   r   r   r   r   r   r   rV   rF   rD   r  r    s                 8 8 8 8                   rF   r  c                    t          t          g |                     |z
  }t          | |t                      |dt                    S )zCalculate potentially undefined registers at each CFG location.

    A register is undefined if there is some path from initial block
    where it has an undefined value.

    Function arguments are assumed to be always defined.
    Fr   )r`   r   r   r  r   )rW   r}   r   initial_undefineds       rD   analyze_undefined_regsr#    sP     Jr62233oE%''!   rF   r]   r*   c                    t                      }|                                 D ]3}t          |t          t          f          s|                    |           4|S rB   )r`   sourcesr[   r    r   rf   )r]   resultsources      rD   non_trivial_sourcesr(    sQ    UUF**,,  &7E"233 	JJvMrF   c                  F    e Zd ZddZddZdd	ZddZddZddZddZ	dS )LivenessVisitorr]   r   r?   r   c                <    t          |          t                      fS rB   r(  r`   r   s     rD   r   zLivenessVisitor.visit_branch      "2&&--rF   r.   c                    t          |j        t          t          f          s|j        ht	                      fS t	                      t	                      fS rB   )r[   valuer    r   r`   r   s     rD   r   zLivenessVisitor.visit_return  s@    "(We$455 	 H:suu$$55#%%<rF   r6   c                :    t                      t                      fS rB   r   r   s     rD   r   z!LivenessVisitor.visit_unreachable  r   rF   r-   c                X    t          |          }|j        s||hfS |t                      fS rB   )r(  r  r`   )rC   r]   gens      rD   r   z!LivenessVisitor.visit_register_op  s3    !"%%z 	9:rF   r   c                0    t          |          |j        hfS rB   r(  r   r   s     rD   r   zLivenessVisitor.visit_assign      "2&&	11rF   r   c                0    t          |          |j        hfS rB   r4  r   s     rD   r   z"LivenessVisitor.visit_assign_multi  r5  rF   r0   c                <    t          |          t                      fS rB   r,  r   s     rD   r   zLivenessVisitor.visit_set_mem  r-  rF   Nr   r   r   r   r   r   r   r   rV   rF   rD   r*  r*    s        . . . .             2 2 2 22 2 2 2. . . . . .rF   r*  c                f    t          | |t                      t                      dt                    S )zCalculate live registers at each CFG location.

    A register is live at a location if it can be read along some CFG path starting
    from the location.
    Tr   )r   r*  r`   r   )rW   r}   s     rD   analyze_live_regsr9    s7     $&&   rF   rr   Nr   OpVisitor[GenAndKill[T]]r   set[T]r   rJ   r   r  set[T] | NoneAnalysisResult[T]c                n   i }i }| D ]z}	t                      }
t                      }|	j        }|rt          t          |                    }|D ]*}|                    |          \  }}|
|z
  |z  }
||z
  |z  }+|
||	<   |||	<   {t          |           }|s|ddd         }t          |          }i }i }| D ]`}	|t
          k    r#t                      ||	<   t                      ||	<   0|
J d            t          |          ||	<   t          |          ||	<   a|r|j        }|j        }n|j        }|j        }|r|                                }|	                    |           ||         rLd}||         D ]<}|t          ||                   }|t
          k    r|||         z  }1|||         z  }=|J nt          |          }|||<   |||         z
  ||         z  }|||         k    r9||         D ]0}||vr*|
                    |           |                    |           1|||<   |i }i }| D ]t}	|	}||         }t          |	j                  }|rt          t          |                    }|D ]3\  }}||||f<   |                    |          \  }}||z
  |z  }||||f<   4u|r||}}t          ||          S )aP  Run a general set-based data flow analysis.

    Args:
        blocks: All basic blocks
        cfg: Control-flow graph for the code
        gen_and_kill: Implementation of gen and kill functions for each op
        initial: Value of analysis for the entry points (for a forward analysis) or the
            exit points (for a backward analysis)
        kind: MUST_ANALYSIS or MAYBE_ANALYSIS
        backward: If False, the analysis is a forward analysis; it's backward otherwise
        universe: For a must analysis, the set of all possible values. This is the starting
            value for the work list algorithm, which will narrow this down until reaching a
            fixed point. For a maybe analysis the iteration always starts from an empty set
            and this argument is ignored.

    Return analysis results: (before, after)
    Nr_   z,Universe must be defined for a must analysis)r`   rb   rc   reversedacceptr   r:   r<   popremoverh   rf   rv   r   ) rW   r}   r   r   r   r   r  	block_gen
block_killrl   r2  killrb   r]   opgenopkillworklistworksetr   r   rk   rj   rK   
new_beforer<   	new_afterr:   	op_beforeop_aftercurops_enumidxs                                    rD   r   r     sx   4 IJ  ! !eeuui 	&x}}%%C 	+ 	+BIIl33ME6<5(C5LF*DD	% 
5 F||H "DDbD>(mmG')F&(E ) )>!!EEF5M55E%LL'')W'''MMF5Mx==E%LL 8888  !uE? 	&(,J  . .%!$U4[!1!1JJ^++%+-JJ%+-JJ))))WJ"u*U"33y7GG	e$$  & &w&&OOD)))KK%%% e-  !2 79I57H 
' 
'Um-6uy-A-A 	0X//H 	' 	'GC$'IeSj!IIl33ME6<5(C#&HUCZ  		'
  2'))X...rF   )rW   rX   r?   r9   )rK   r   r?   r   )rW   rX   r?   r@   )rW   rX   r}   r9   r   r   r?   r   r   )rW   rX   r}   r9   r   r   r   r   r   r   r?   r   )rW   rX   r}   r9   r  r   r?   r   )r]   r*   r?   r   )rW   rX   r}   r9   r?   r   rB   )rW   rX   r}   r9   r   r:  r   r;  r   rJ   r   r   r  r<  r?   r=  )RrU   
__future__r   abcr   typingr   r   r   r   r	   r
   r   mypyc.ir.func_irr   mypyc.ir.opsr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r9   rp   rt   r   r   rJ   AnalysisDictr   
GenAndKillr   r   r   r  r  r  r  r#  r(  r*  r9  r  r   r   rV   rF   rD   <module>rX     s     " " " " " "       I I I I I I I I I I I I I I I I I I ' ' ' ' ' ', , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,^G G G G G G G G.(* (* (* (*V      6 GCLLE*c/*CF23? ? ? ? ?WQZ ? ? ? 3q63q6>"
f* f* f* f* f*)JqM2 f* f* f*R+ + + + +(/ + + +\   ,      6    259   8   $    *51   .   *   . . . . .)%0 . . .<   "  #l/ l/ l/ l/ l/ l/ l/rF   