
    g                     4   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 ddlmZmZmZ dd	lmZ dd
lmZmZ ddlmZ ddlmZ ddlmZmZ ddlmZ ddlm Z  d dl!m"Z"m#Z# d Z$d Z%d Z& G d dee          Z' ed          Z(ddl)m*Z*m+Z+m,Z, ddlm-Z- dS )    )Tuple)defaultdict)reduce)
attrgetter   )_args_sortkey)global_parameters)_fuzzy_groupfuzzy_or	fuzzy_not)S)AssocOpAssocOpDispatcher)cacheit)equal_valued)ilcmigcd)Expr)UndefinedKind)is_sequencesiftc                     t          d | j        D                       }t          | j                  |z
  }||k    rdS ||k     rdS t          |                                 |                                  k               S )Nc              3   B   K   | ]}|                                 d V  dS )r   N)could_extract_minus_sign.0is     J/var/www/html/ai-engine/env/lib/python3.11/site-packages/sympy/core/add.py	<genexpr>z,_could_extract_minus_sign.<locals>.<genexpr>   sF       ) )a%%'') ) ) ) ) ) )    FT)sumargslenboolsort_key)exprnegative_argspositive_argss      r   _could_extract_minus_signr)      s      ) )49 ) ) ) ) )M	NN]2M}$$u		&	&t D5"2"2"4"44555r    c                 <    |                      t                     d S )Nkey)sortr   )r"   s    r   _addsortr.   !   s    II-I     r    c                  v   t          |           } g }t          j        }| rZ|                                 }|j        r|                     |j                   n"|j        r||z  }n|                    |           | Zt          |           |r|
                    d|           t                              |          S )a  Return a well-formed unevaluated Add: Numbers are collected and
    put in slot 0 and args are sorted. Use this when args have changed
    but you still want to return an unevaluated Add.

    Examples
    ========

    >>> from sympy.core.add import _unevaluated_Add as uAdd
    >>> from sympy import S, Add
    >>> from sympy.abc import x, y
    >>> a = uAdd(*[S(1.0), x, S(2)])
    >>> a.args[0]
    3.00000000000000
    >>> a.args[1]
    x

    Beyond the Number being in slot 0, there is no other assurance of
    order for the arguments since they are hash sorted. So, for testing
    purposes, output produced by this in some other function can only
    be tested against the output of this function or as one of several
    options:

    >>> opts = (Add(x, y, evaluate=False), Add(y, x, evaluate=False))
    >>> a = uAdd(x, y)
    >>> assert a in opts and a == uAdd(x, y)
    >>> uAdd(x + 1, x + 2)
    x + x + 3
    r   )listr   Zeropopis_Addextendr"   	is_Numberappendr.   insertAdd
_from_args)r"   newargscoas       r   _unevaluated_Addr=   &   s    : ::DG	
B
 	HHJJ8 	 KK[ 	!GBBNN1  	 W	 q">>'"""r    c                   8    e Zd ZU dZdZeedf         ed<   dZeZ	e
d             Ze
d             Zed             Zd	 Zed
             Zd>dZd Zed             Zd?dZd Zd@dZed             Zed             Zd Zd Zd Zd Zd Zd Z d Z!d Z"d Z#d Z$d  Z%d! Z&d" Z'd# Z(d$ Z)d% Z*d& Z+d' Z,d( Z-d) Z.d* Z/ fd+Z0d, Z1d- Z2 fd.Z3d/ Z4d0 Z5d1 Z6edAd2            Z7dBd3Z8dCd4Z9d5 Z:d6 Z;d7 Z<d8 Z=dDd9Z>ed:             Z?d; Z@ed<             ZA fd=ZB xZCS )Er8   a	  
    Expression representing addition operation for algebraic group.

    .. deprecated:: 1.7

       Using arguments that aren't subclasses of :class:`~.Expr` in core
       operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is
       deprecated. See :ref:`non-expr-args-deprecated` for details.

    Every argument of ``Add()`` must be ``Expr``. Infix operator ``+``
    on most scalar objects in SymPy calls this class.

    Another use of ``Add()`` is to represent the structure of abstract
    addition so that its arguments can be substituted to return different
    class. Refer to examples section for this.

    ``Add()`` evaluates the argument unless ``evaluate=False`` is passed.
    The evaluation logic includes:

    1. Flattening
        ``Add(x, Add(y, z))`` -> ``Add(x, y, z)``

    2. Identity removing
        ``Add(x, 0, y)`` -> ``Add(x, y)``

    3. Coefficient collecting by ``.as_coeff_Mul()``
        ``Add(x, 2*x)`` -> ``Mul(3, x)``

    4. Term sorting
        ``Add(y, x, 2)`` -> ``Add(2, x, y)``

    If no argument is passed, identity element 0 is returned. If single
    element is passed, that element is returned.

    Note that ``Add(*args)`` is more efficient than ``sum(args)`` because
    it flattens the arguments. ``sum(a, b, c, ...)`` recursively adds the
    arguments as ``a + (b + (c + ...))``, which has quadratic complexity.
    On the other hand, ``Add(a, b, c, d)`` does not assume nested
    structure, making the complexity linear.

    Since addition is group operation, every argument should have the
    same :obj:`sympy.core.kind.Kind()`.

    Examples
    ========

    >>> from sympy import Add, I
    >>> from sympy.abc import x, y
    >>> Add(x, 1)
    x + 1
    >>> Add(x, x)
    2*x
    >>> 2*x**2 + 3*x + I*y + 2*y + 2*x/5 + 1.0*y + 1
    2*x**2 + 17*x/5 + 3.0*y + I*y + 1

    If ``evaluate=False`` is passed, result is not evaluated.

    >>> Add(1, 2, evaluate=False)
    1 + 2
    >>> Add(x, x, evaluate=False)
    x + x

    ``Add()`` also represents the general structure of addition operation.

    >>> from sympy import MatrixSymbol
    >>> A,B = MatrixSymbol('A', 2,2), MatrixSymbol('B', 2,2)
    >>> expr = Add(x,y).subs({x:A, y:B})
    >>> expr
    A + B
    >>> type(expr)
    <class 'sympy.matrices.expressions.matadd.MatAdd'>

    Note that the printers do not display in args order.

    >>> Add(x, 1)
    x + 1
    >>> Add(x, 1).args
    (1, x)

    See Also
    ========

    MatAdd

     .r"   Tc                 	   ddl m} ddlm} ddlm} d}t          |          dk    rS|\  }}|j        r||}}|j        r|j        r||gg df}|r,t          d |d         D                       r|S g |d         dfS i }t          j        }	g }
g }|D ]qj        rAj        j        r|
D ]}|                              rd n8gfd|
D             z   }
Kj        rxt          j        u s|	t          j        u rj        d	u r|st          j        gg dfc S |	j        st)          |	|          r'|	z  }	|	t          j        u r|st          j        gg dfc S t)          |          r                    |	          }	t)          |          r|                               t)          |          r|	r                    |	          n}	Bt          j        u r+|	j        d	u r|st          j        gg dfc S t          j        }	{j        r|                    j                   j        r                                \  }}nqj        r\                                \  }}|j        r/|j        s|j        r!|j        r|                    ||z             t          j        }}nt          j        }}||v r:||xx         |z  cc<   ||         t          j        u r|st          j        gg dfc S l|||<   sg }d	}|                                 D ]\  }}|j        r|t          j        u r|                    |           n|j        r) |j!        |f|j        z    }|                    |           nP|j        r&|                    tE          ||d	
                     n#|                    tE          ||                     |p|j#         }|	t          j$        u rd |D             }n|	t          j%        u rd |D             }|	t          j        u rd |D             }|
rig }|D ]7}|
D ]                    |          rd} n||                    |           8||
z   }|
D ]%                    |	          rt          j        }	 n&tM          |           |	t          j        ur|'                    d|	           |r||z  }d}|rg |dfS |g dfS )a  
        Takes the sequence "seq" of nested Adds and returns a flatten list.

        Returns: (commutative_part, noncommutative_part, order_symbols)

        Applies associativity, all terms are commutable with respect to
        addition.

        NB: the removal of 0 is already handled by AssocOp.__new__

        See Also
        ========

        sympy.core.mul.Mul.flatten

        r   )AccumBounds)
MatrixExpr)TensExprN   c              3   $   K   | ]}|j         V  d S Nis_commutative)r   ss     r   r   zAdd.flatten.<locals>.<genexpr>   s%      77Aq'777777r    c                 >    g | ]}                     |          |S r?   )contains)r   o1os     r   
<listcomp>zAdd.flatten.<locals>.<listcomp>   s?     'F 'F 'Fajjnn'F'F 'F 'Fr    Fevaluatec                 .    g | ]}|j         	|j        |S r?   )is_extended_nonnegativeis_realr   fs     r   rN   zAdd.flatten.<locals>.<listcomp>U  '    XXXA0IXQYXaXXXr    c                 .    g | ]}|j         	|j        |S r?   )is_extended_nonpositiverS   rT   s     r   rN   zAdd.flatten.<locals>.<listcomp>X  rV   r    c                 .    g | ]}|j         r|j        |S rF   )	is_finiteis_extended_real)r   cs     r   rN   zAdd.flatten.<locals>.<listcomp>c  s7     Q Q QA Q010B0N 0N0N0Nr    T)(!sympy.calculus.accumulationboundsrA   sympy.matrices.expressionsrB   sympy.tensor.tensorrC   r#   is_Rationalis_Mulallr   r1   is_Orderr&   is_zerorK   r5   NaNComplexInfinityrZ   
isinstance__add__r6   r3   r4   r"   as_coeff_Mulis_Powas_base_exp
is_Integeris_negativeOneitems_new_rawargsMulrH   InfinityNegativeInfinityr.   r7   )clsseqrA   rB   rC   rvr<   btermscoefforder_factorsextrarL   r\   rI   enewseqnoncommutativecsnewseq2trM   s                        @r   flattenzAdd.flatten   sj   $ 	BAAAAA999999000000s88q==DAq} !1} *8 *QT)B '77A77777 I2a5$&  V	 V	A z D6> '  B{{1~~   9!" 'F 'F 'F 'F!.'F 'F 'F !F  6JJ%1+<"<"<u,,e,E7B,,,,? 1j&D&D 1QJE~~e~ !wD0000A{++ *		%((Az** &QAx(( !,18		%(((qa'''?e++E+E7B,,,,)  

16"""  ~~''11  }}1; AL $%M67mJJq!t$$$ua1 E EzzaA8qu$$U$E7B,,,,a KKMM 	D 	DDAqy -aea     8 
- (1$-9BMM"%%%%X -MM#aU";";";<<<< MM#a)),,,+C13C/CNN AJXXXXXFFa(((XXXXXFA%%%Q Q Q Q QF  	G & &&  Azz!}}   =NN1%%%},F"  ::e$$ FEE
 	 MM!U### 	"eOF!N  	$vt##2t##r    c                     dd| j         fS )N   r   )__name__)rt   s    r   	class_keyzAdd.class_key  s    !S\!!r    c                     t          d          }t          || j                  }t          |          }t	          |          dk    rt
          }n|\  }|S )Nkindr   )r   mapr"   	frozensetr#   r   )selfkkindsresults       r   r   zAdd.kind  sQ    vAty!!%  u::?? #FFGFr    c                      t          |           S rF   )r)   r   s    r   r   zAdd.could_extract_minus_sign  s    (...r    c                 "   r6t          | j        fdd          \  }} | j        | t          |          fS | j        d                                         \  }}|t
          j        ur||| j        dd         z   fS t
          j        | j        fS )aR  
        Returns a tuple (coeff, args) where self is treated as an Add and coeff
        is the Number term and args is a tuple of all other terms.

        Examples
        ========

        >>> from sympy.abc import x
        >>> (7 + 3*x).as_coeff_add()
        (7, (3*x,))
        >>> (7*x).as_coeff_add()
        (0, (7*x,))
        c                      | j          S rF   )has_free)xdepss    r   <lambda>z"Add.as_coeff_add.<locals>.<lambda>  s    zqz4/@ r    T)binaryr   r   N)r   r"   rp   tupleas_coeff_addr   r1   )r   r   l1l2ry   notrats    `    r   r   zAdd.as_coeff_add  s      	5$)%@%@%@%@NNNFB$4$b)59944	!1133v&49QRR=000vty  r    FNc                     | j         d         | j         dd         }}|j        r|r|j        r| | j        | fS t          j        | fS )zE
        Efficiently extract the coefficient of a summation.
        r   r   N)r"   r5   r`   rp   r   r1   )r   rationalr   ry   r"   s        r   as_coeff_AddzAdd.as_coeff_Add  sZ     ilDIabbMt? 	38 	3u/@ 	3+$+T222vt|r    c                    ddl m} ddlm} t	          | j                  dk    rt          d | j        D                       r|j        du r ||t          j	                  du r| j        \  }}|
                    t          j                  r||}}|
                    t          j                  }|r4|j        r-|j        r&|j        rt          j        S |j        rt          j        S d S |j        r| j        r ||           }|r|\  }}	|j        dk    rddlm}
  |
|dz  |	dz  z             }|j        rvdd	lm} dd
lm ddlm}  |
 |||z
  dz                      |j        z  }| |||z   t;          |	          z   |	          t          j        z  z   |j        z            z  S d S |dk    r.t=          ||	t          j        z  z
  d|dz  |	dz  z   z            S d S d S |j        rt;          |          dk    rtA          d | j        D              \  }}t          d |D                       rd|D ]$}	t;          |	          k    rt;          |	          %dk    r]tC          d          sOdd
lm  ffd|D             }tE          d tA          ||          D              |z  }|z  |z  S d S d S d S d S d S )Nr   )pure_complex)is_eqrD   c              3   $   K   | ]}|j         V  d S rF   is_infinite)r   _s     r   r   z"Add._eval_power.<locals>.<genexpr>  s$      &H&Hq}&H&H&H&H&H&Hr    Fr   )sqrt)factor_terms)sign)expand_multinomialc                 6    g | ]}|                                 S r?   )ri   r   s     r   rN   z#Add._eval_power.<locals>.<listcomp>  s"    ===a))===r    c              3   $   K   | ]}|j         V  d S rF   )is_Floatr   s     r   r   z"Add._eval_power.<locals>.<genexpr>  s$      ))!1:))))))r    c                 8    g | ]}|v r |          n|z  S r?   r?   )r   r   bigbigsr   s     r   rN   z#Add._eval_power.<locals>.<listcomp>  s1    DDDQAIIa1S5DDDr    c                     g | ]
\  }}||z  S r?   r?   )r   r\   ms      r   rN   z#Add._eval_power.<locals>.<listcomp>  s     "="="=41a1Q3"="="=r    )#evalfr   
relationalr   r#   r"   anyrd   r   rn   ry   ImaginaryUnitr[   is_extended_negativer1   is_extended_positiverf   r`   	is_numberq(sympy.functions.elementary.miscellaneousr   	exprtoolsr   $sympy.functions.elementary.complexesr   functionr   pabs_unevaluated_Mulr5   zipr   r8   )r   r|   r   r   r<   rw   icorirr   r   Dr   r   rootr\   r   addpowr   r   r   s                     @@@r   _eval_powerzAdd._eval_power  s   ''''''%%%%%%ty>>Q3&H&Hdi&H&H&H#H#HyE!!eeAquoo&>&>y1771?++  aqAggao.. 13/ 1A4F 1- & v- 1 00F= !	)T^ !	)d##B )13!88MMMMMMQTAqD[))A} L;;;;;;MMMMMM@@@@@@#tLL!a%$;$;<<acA#$6$6UCFFNTT!WWQ_-DDqs8K %L %L  L LL L "WW+Aao--1a4!Q$;) ) )) ) W [ 	)SVVq[[==49===>DAq))q))))) 
) % %A1vv}}!!ff77<Q#7#77IIIIII#;DDDDDDD!DDDA "="=3q!99"="="=>AF6&=(	) 	)[[
) 
)
 777r    c                 :     | j         fd| j        D              S )Nc                 :    g | ]}|                               S r?   )diff)r   r<   rI   s     r   rN   z(Add._eval_derivative.<locals>.<listcomp>  s#    888166!99888r    funcr"   )r   rI   s    `r   _eval_derivativezAdd._eval_derivative  s)    ty8888di88899r    r   c                 J    fd| j         D             } | j        | S )Nc                 B    g | ]}|                                S )nlogxcdir)nseries)r   r   r   r   r   r   s     r   rN   z%Add._eval_nseries.<locals>.<listcomp>  s-    LLLQ1488LLLr    )r"   r   )r   r   r   r   r   rx   s    ```` r   _eval_nserieszAdd._eval_nseries  s9    LLLLLLL$)LLLty%  r    c                     |                                  \  }}t          |          dk    r|d                             ||z
  |          S d S )Nr   r   )r   r#   matches)r   r&   	repl_dictry   rx   s        r   _matches_simplezAdd._matches_simple  sI    ((**uu::??8##D5L)<<<r    c                 0    |                      |||          S rF   )_matches_commutative)r   r&   r   olds       r   r   zAdd.matches  s    ((y#>>>r    c                   
 ddl m} t          j        t          j        f} | j        | s
 |j        | rddlm}  |d          
t          j        
t          j        
 i}d |                                D             }| 	                    |          |	                    |          z
  }|                    
          r|
                    
fdd           }|	                    |          }n| |z
  } ||          }	|	j        r|	n|S )	zp
        Returns lhs - rhs, but treats oo like a symbol so oo - oo
        returns 0, instead of a nan.
        r   )signsimpr   )Dummyooc                     i | ]\  }}||	S r?   r?   )r   r   vs      r   
<dictcomp>z(Add._combine_inverse.<locals>.<dictcomp>  s    333daQ333r    c                 $    | j         o| j        u S rF   )rj   base)r   r   s    r   r   z&Add._combine_inverse.<locals>.<lambda>  s    ah716R< r    c                     | j         S rF   )r   )r   s    r   r   z&Add._combine_inverse.<locals>.<lambda>  s    af r    )sympy.simplify.simplifyr   r   rr   rs   hassymbolr   ro   xreplacereplacer5   )lhsrhsr   infr   repsirepseqrv   srvr   s             @r   _combine_inversezAdd._combine_inverse  s.    	544444z1-.37C= 	GCGSM 	%%%%%%tB
B"RC)D 43djjll333Ed##cll4&8&88Bvvbzz &ZZ7777$$& & U##BBsBhrllm+ss+r    c                 J    | j         d          | j        | j         dd          fS )aZ  Return head and tail of self.

        This is the most efficient way to get the head and tail of an
        expression.

        - if you want only the head, use self.args[0];
        - if you want to process the arguments of the tail then use
          self.as_coef_add() which gives the head and a tuple containing
          the arguments of the tail when treated as an Add.
        - if you want the coefficient when self is treated as a Mul
          then use self.as_coeff_mul()[0]

        >>> from sympy.abc import x, y
        >>> (3*x - 2*y + 5).as_two_terms()
        (5, 3*x - 2*y)
        r   r   Nr"   rp   r   s    r   as_two_termszAdd.as_two_terms"  s*    $ y|.T.	!"">>>r    c                   
 |                                  \  }}t          |t                    s$t          ||d                                          S |                                \  }t          t                    }|j        D ]4}|                                \  }}||                             |           5t          |          dk    r=|
                                \  }}	 | j        fd|	D              t          ||          fS |                                D ]1\  }}	t          |	          dk    r|	d         ||<   $ | j        |	 ||<   2d t          t          |                                           D             \  
 | j        
fdt!          t                              D              t          
 }}	t          |	          t          ||          fS )a~  
        Decomposes an expression to its numerator part and its
        denominator part.

        Examples
        ========

        >>> from sympy.abc import x, y, z
        >>> (x*y/z).as_numer_denom()
        (x*y, z)
        >>> (x*(y + 1)/y**7).as_numer_denom()
        (x*(y + 1), y**7)

        See Also
        ========

        sympy.core.expr.Expr.as_numer_denom
        FrO   r   c                 0    g | ]}t          |          S r?   )_keep_coeff)r   nincons     r   rN   z&Add.as_numer_denom.<locals>.<listcomp>Y  s#    444B+dB''444r    r   c                 ,    g | ]}t          |          S r?   )r0   r   s     r   rN   z&Add.as_numer_denom.<locals>.<listcomp>c  s    BBBa$q''BBBr    c                 b    g | ]+}t          d |         |         gz   |dz   d          z    ,S )Nr   )rq   )r   r   denomsnumerss     r   rN   z&Add.as_numer_denom.<locals>.<listcomp>d  sR     0 0 0 vayk!9F1q566N!JL 0 0 0r    )	primitiverg   r8   rq   as_numer_denomr   r0   r"   r6   r#   popitemr   r   ro   r   iterrange)r   contentr&   dconndrU   r   didr   r  r   r  s             @@@r   r  zAdd.as_numer_denom6  s    ( (($$$ 	Gwu555DDFFF++--
d  	 	A%%''FBrFMM" r77a<<::<<DAq494444!44467B47K7KL L HHJJ 	& 	&DAq1vv{{!1!	11 CB3RXXZZ0@0@+ABBBty 0 0 0 0 0!#f++..0 0 0 125v,  4##[q%9%999r    c                 D    t          fd| j        D                       S )Nc              3   B   K   | ]}|                               V  d S rF   )_eval_is_polynomialr   termsymss     r   r   z*Add._eval_is_polynomial.<locals>.<genexpr>j  s1      HHd4++D11HHHHHHr    rb   r"   r   r  s    `r   r  zAdd._eval_is_polynomiali  s(    HHHHdiHHHHHHr    c                 D    t          fd| j        D                       S )Nc              3   B   K   | ]}|                               V  d S rF   )_eval_is_rational_functionr  s     r   r   z1Add._eval_is_rational_function.<locals>.<genexpr>m  s1      OOT422488OOOOOOr    r  r  s    `r   r  zAdd._eval_is_rational_functionl  s(    OOOOTYOOOOOOr    c                 L    t          fd| j        D             d          S )Nc              3   D   K   | ]}|                               V  d S rF   )is_meromorphic)r   argr<   r   s     r   r   z+Add._eval_is_meromorphic.<locals>.<genexpr>p  s3      KK#S//155KKKKKKr    T
quick_exitr
   r"   )r   r   r<   s    ``r   _eval_is_meromorphiczAdd._eval_is_meromorphico  s:    KKKKKKKK'+- - - 	-r    c                 D    t          fd| j        D                       S )Nc              3   B   K   | ]}|                               V  d S rF   )_eval_is_algebraic_exprr  s     r   r   z.Add._eval_is_algebraic_expr.<locals>.<genexpr>t  s1      LL$4//55LLLLLLr    r  r  s    `r   r"  zAdd._eval_is_algebraic_exprs  s(    LLLL$)LLLLLLr    c                 B    t          d | j        D             d          S )Nc              3   $   K   | ]}|j         V  d S rF   )rS   r   r<   s     r   r   zAdd.<lambda>.<locals>.<genexpr>x  s$      &&q&&&&&&r    Tr  r  r   s    r   r   zAdd.<lambda>w  s*    &&DI&&&4"9 "9 "9 r    c                 B    t          d | j        D             d          S )Nc              3   $   K   | ]}|j         V  d S rF   )r[   r%  s     r   r   zAdd.<lambda>.<locals>.<genexpr>z  %      //	//////r    Tr  r  r   s    r   r   zAdd.<lambda>y  -    ,//TY///D+B +B +B r    c                 B    t          d | j        D             d          S )Nc              3   $   K   | ]}|j         V  d S rF   )
is_complexr%  s     r   r   zAdd.<lambda>.<locals>.<genexpr>|  $      ))!))))))r    Tr  r  r   s    r   r   zAdd.<lambda>{  *    L))ty)))d%< %< %< r    c                 B    t          d | j        D             d          S )Nc              3   $   K   | ]}|j         V  d S rF   )is_antihermitianr%  s     r   r   zAdd.<lambda>.<locals>.<genexpr>~  r(  r    Tr  r  r   s    r   r   zAdd.<lambda>}  r)  r    c                 B    t          d | j        D             d          S )Nc              3   $   K   | ]}|j         V  d S rF   )rZ   r%  s     r   r   zAdd.<lambda>.<locals>.<genexpr>  s$      ((((((((r    Tr  r  r   s    r   r   zAdd.<lambda>  s*    <((di(((T$; $; $; r    c                 B    t          d | j        D             d          S )Nc              3   $   K   | ]}|j         V  d S rF   )is_hermitianr%  s     r   r   zAdd.<lambda>.<locals>.<genexpr>  $      ++A++++++r    Tr  r  r   s    r   r   zAdd.<lambda>  *    l+++++'> '> '> r    c                 B    t          d | j        D             d          S )Nc              3   $   K   | ]}|j         V  d S rF   )
is_integerr%  s     r   r   zAdd.<lambda>.<locals>.<genexpr>  r-  r    Tr  r  r   s    r   r   zAdd.<lambda>  r.  r    c                 B    t          d | j        D             d          S )Nc              3   $   K   | ]}|j         V  d S rF   is_rationalr%  s     r   r   zAdd.<lambda>.<locals>.<genexpr>  s$      **1******r    Tr  r  r   s    r   r   zAdd.<lambda>  s*    \**	***t&= &= &= r    c                 B    t          d | j        D             d          S )Nc              3   $   K   | ]}|j         V  d S rF   )is_algebraicr%  s     r   r   zAdd.<lambda>.<locals>.<genexpr>  r7  r    Tr  r  r   s    r   r   zAdd.<lambda>  r8  r    c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S rF   rG   r%  s     r   r   zAdd.<lambda>.<locals>.<genexpr>  s6       5- 5-5- 5- 5- 5- 5- 5-r    r  r   s    r   r   zAdd.<lambda>  s.     5- 5-"&)5- 5- 5- )- )- r    c                 P    d}| j         D ]}|j        }| d S |du r	|du r d S d}|S )NFT)r"   r   )r   sawinfr<   ainfs       r   _eval_is_infinitezAdd._eval_is_infinite  sO     	 	A=D|ttT>>44r    c                 8   g }g }| j         D ]}|j        r*|j        r|j        du r|                    |           0 d S |j        r#|                    |t
          j        z             ]|j        rgt
          j        |j         v rT|                    t
          j                  \  }}|t
          j        fk    r|j        r|                    |             d S  d S  | j	        | }|| k    r.|j        rt           | j	        | j                  S |j        du rdS d S d S NF)r"   r[   rd   r6   is_imaginaryr   r   ra   as_coeff_mulr   r   )r   nzim_Ir<   ry   airw   s          r   _eval_is_imaginaryzAdd._eval_is_imaginary  sG    	 	A! 9 Y%''IIaLLLLFF 	Aao-.... ao77NN1?;;	r!/+++0F+KK''''FFDIrN99y  D!1!9:::e##u	 9 $#r    c                 \   | j         du rd S g }d}d}d}| j        D ]}|j        r/|j        r|dz  }|j        du r|                    |           5 d S |j        r|dz  }E|j        rSt          j        |j        v r@|	                    t          j                  \  }}|t          j        fk    r
|j        rd} d S  d S |t          | j                  k    rdS t          |          dt          | j                  fv rd S  | j        | }|j        r|s|dk    rdS |dk    rdS |j        du rdS d S )NFr   r   T)rH   r"   r[   rd   r6   rK  ra   r   r   rL  r#   r   )	r   rM  zim_or_zimr<   ry   rO  rw   s	            r   _eval_is_zerozAdd._eval_is_zero  s   %'' F 	 	A! 9 FAAY%''IIaLLLLFF 	a ao77NN1?;;	r!/+++0F+"GGFFDI4r77q#di..)))4DIrN9 	! !7741WW 595 r    c                 x    d | j         D             }|sdS |d         j        r | j        |dd           j        S d S )Nc                 $    g | ]}|j         d u|S T)is_evenrT   s     r   rN   z$Add._eval_is_odd.<locals>.<listcomp>  s$    ===1!)t*;*;Q*;*;*;r    Fr   r   )r"   is_oddrp   rY  )r   ls     r   _eval_is_oddzAdd._eval_is_odd  sW    ==	=== 	5Q4; 	5$4$ae,44	5 	5r    c                     | j         D ]X}|j        }|rHt          | j                   }|                    |           t	          d |D                       r dS  d S | d S YdS )Nc              3   (   K   | ]}|j         d u V  dS )TNr>  )r   r   s     r   r   z*Add._eval_is_irrational.<locals>.<genexpr>  s)      ==q},======r    TF)r"   is_irrationalr0   removerb   )r   r   r<   otherss       r   _eval_is_irrationalzAdd._eval_is_irrational  s     		 		AA dia   ==f=====  44tty ur    c                 b    dx}}| j         D ]"}|j        r|r dS d}|j        r|r dS d}  d S dS )Nr   Fr   T)r"   is_nonnegativeis_nonpositive)r   nnnpr<   s       r   _all_nonneg_or_nonpposzAdd._all_nonneg_or_nonppos  sj    R 	 	A 	 ! 55!  ! 554r    c                    | j         r t                                                      S |                                 \  }}|j        sbddlm}  ||          }|O||z   }|| k    r|j        r	|j        rdS t          | j
                  dk    r ||           }||| k    r	|j        rdS dx}x}x}}	t                      }
d | j        D             }|sdS |D ]f}|j        }|j        }|r4|
                    t          ||j        f                     d|
v rd|
v r d S |rd}K|j        rd}U|j        rd}_| d S d}	g|
r)t          |
          dk    rd S |
                                S |	rd S |s|s|rdS |s|rdS |s|sdS d S d S )Nr   _monotonic_signTFc                      g | ]}|j         	|S r?   rd   r%  s     r   rN   z2Add._eval_is_extended_positive.<locals>.<listcomp>      666aAI6666r    )r   super_eval_is_extended_positiver   rd   r   rk  r   rR   r#   free_symbolssetr"   r   addr   rX   r2   )r   r\   r<   rk  r   rI   posnonnegnonposunknown_signsaw_INFr"   isposinfinite	__class__s                 r   rp  zAdd._eval_is_extended_positive  F   > 	87755777  ""1y 
	$222222""A}E99!79A<U94t())Q..'--A}dq7M#t/444f4v%%6649666 	5 	  	 A*E}H HeQ-F%GHHIII7??u'7'7FF * * LL 	7||a;;==  	F 	 	3 	4 	C 	4 	V 	5	 	 	 	r    c                 0   | j         s|                                 \  }}|j        sd|j        r_ddlm}  ||          }|N||z   }|| k    r	|j        rdS t          | j                  dk    r$ ||           }||| k    r|j        rdS d S d S d S d S d S d S d S d S Nr   rj  T)r   r   rd   rR   r   rk  r#   rq  r   r\   r<   rk  r   rI   s         r   _eval_is_extended_nonnegativez!Add._eval_is_extended_nonnegative8      ~ 	($$&&DAq9 
(!: 
(666666#OA&&=AADyyQ%>y#t4,--22+OD11=Q$YY1;TY#'4	( 	(
( 
( 
( 
( != 32(=YYYYr    c                 0   | j         s|                                 \  }}|j        sd|j        r_ddlm}  ||          }|N||z   }|| k    r	|j        rdS t          | j                  dk    r$ ||           }||| k    r|j        rdS d S d S d S d S d S d S d S d S r~  )r   r   rd   rX   r   rk  r#   rq  r  s         r   _eval_is_extended_nonpositivez!Add._eval_is_extended_nonpositiveG  r  r    c                    | j         r t                                                      S |                                 \  }}|j        sbddlm}  ||          }|O||z   }|| k    r|j        r	|j        rdS t          | j
                  dk    r ||           }||| k    r	|j        rdS dx}x}x}}	t                      }
d | j        D             }|sdS |D ]f}|j        }|j        }|r4|
                    t          ||j        f                     d|
v rd|
v r d S |rd}K|j        rd}U|j        rd}_| d S d}	g|
r)t          |
          dk    rd S |
                                S |	rd S |s|s|rdS |s|rdS |s|sdS d S d S )Nr   rj  TFc                      g | ]}|j         	|S r?   rm  r%  s     r   rN   z2Add._eval_is_extended_negative.<locals>.<listcomp>g  rn  r    )r   ro  _eval_is_extended_negativer   rd   r   rk  r   rX   r#   rq  rr  r"   r   rs  r   rR   r2   )r   r\   r<   rk  r   rI   negrv  ru  rw  rx  r"   isnegrz  r{  s                 r   r  zAdd._eval_is_extended_negativeV  r|  r    c                 |   j         s3t          j        u r# | j        v r|                       i          S d S |                                 \  }}                                \  }}|j        rD|j        r=||k    r|                     ||           S || k    r|                      ||          S |j        r|j        s||k    r| j                            |          | j                            |          }}t          |          t          |          k     rt          |          }	t          |          }
|
|	k     r#|	|
z
  } | j        || gfd|D             R  S | j                            |           }t          |          }
|
|	k     r'|	|
z
  } | j         ||gfd|D             R  S d S d S d S )Nc                 <    g | ]}|                               S r?   _subsr   rI   newr   s     r   rN   z"Add._eval_subs.<locals>.<listcomp>  '     D D Dqc!2!2 D D Dr    c                 <    g | ]}|                               S r?   r  r  s     r   rN   z"Add._eval_subs.<locals>.<listcomp>  r  r    )r3   r   rr   r"   r   r   r`   r   	make_argsr#   rr  )r   r   r  
coeff_self
terms_self	coeff_old	terms_oldargs_old	args_selfself_setold_setret_sets    ``         r   
_eval_subszAdd._eval_subs  sK   z 	aj  cTTY%6%6}}sdSD\2224!%!2!2!4!4
J"//11	9! 	>i&; 	>Y&&yyj9*===iZ''yy#z9===! 	Fi&; 	F**"&)"5"5# # I//
;;  H8}}s9~~--y>>h--X%%&0G$49S*yj F D D D D DG D D DF F F F  9..J   h--X%%&0G$49cT:y F D D D D DG D D DF F F F .- +* &%r    c                 8    d | j         D             } | j        | S )Nc                      g | ]}|j         	|S r?   rc   r%  s     r   rN   zAdd.removeO.<locals>.<listcomp>  s    777aAJ7777r    r   r   r"   s     r   removeOzAdd.removeO  s'    7749777 t $''r    c                 @    d | j         D             }|r
 | j        | S d S )Nc                      g | ]}|j         	|S r?   r  r%  s     r   rN   zAdd.getO.<locals>.<listcomp>  s    333a
3333r    r   r  s     r   getOzAdd.getO  s9    3349333 	,$4$d++	, 	,r    c                   
 ddl m
 g }t          t                    rng          sdgt	                    z  
fd| j        D             }|D ]q\  }}|D ]$\  }}|                    |          r
||k    rd} n%|/||fg}	|D ]8\  }}|                    |          r||k    r!|	                    ||f           9|	}rt          |          S )a`  
        Returns the leading term and its order.

        Examples
        ========

        >>> from sympy.abc import x
        >>> (x + 1 + 1/x**5).extract_leading_order(x)
        ((x**(-5), O(x**(-5))),)
        >>> (1 + x).extract_leading_order(x)
        ((1, O(1)),)
        >>> (x + x**2).extract_leading_order(x)
        ((x, O(x)),)

        r   Orderc           
      B    g | ]}| |gt                    R  fS r?   )r   )r   rU   r  pointsymbolss     r   rN   z-Add.extract_leading_order.<locals>.<listcomp>  s:    FFFq551S%001112FFFr    N)	sympy.series.orderr  r0   r   r#   r"   rK   r6   r   )r   r  r  lstru   efofr|   rM   new_lstr  s    ``       @r   extract_leading_orderzAdd.extract_leading_order  s3   " 	-,,,,,+g"6"6EwwWIFF 	%CG$EFFFFFFDIFFF 	 	FB  1::b>> a2ggBEzBxjG ' '1;;q>> a2gg1v&&&&CCSzzr    c                     | j         }g g }}|D ]E}|                    |          \  }}|                    |           |                    |           F | j        |  | j        | fS )a4  
        Return a tuple representing a complex number.

        Examples
        ========

        >>> from sympy import I
        >>> (7 + 9*I).as_real_imag()
        (7, 9)
        >>> ((1 + I)/(1 - I)).as_real_imag()
        (0, 1)
        >>> ((1 + 2*I)*(1 + 3*I)).as_real_imag()
        (-5, 5)
        )deep)r"   as_real_imagr6   r   )	r   r  hintssargsre_partim_partr  rerT  s	            r   r  zAdd.as_real_imag  s     	r 	 	D&&D&11FBNN2NN2	7#YTY%899r    c           
         ddl m}m} ddlm} ddlm ddlm}m	} ddl
m}	 |                                 }
|
 |d          }
|                                 }|                    |          r ||          }t          fd| j        D                       rd	d	d
d
d
d
d
d
d
d	} |j        di |} |	|          }|j        s|                    |          S d |j        D             }| |d          n|fd|j        D             } |d          d}}	 |D ]"} ||          }|r||vr|}|}||v r||z  }#n# t(          $ r |cY S w xY w||                                         }|j        }|-|                                                                }|j        }|d	u r	 |                                }n# t4          $ r t6          j        }Y nw xY w|                    |          rt6          j        } |d          }t6          j        }|j        r^|                    ||z   |                                                                                                          }|dz  }|j        ^|                    |          S |t6          j         u r|j!        "                    |          |
z   S |S )Nr   )r   Symbolr  )log)	Piecewisepiecewise_foldr   )
expand_mulc              3   8   K   | ]}t          |          V  d S rF   )rg   )r   r<   r  s     r   r   z,Add._eval_as_leading_term.<locals>.<genexpr>  s-      55az!S!!555555r    TF)	r  r  mul	power_exp
power_basemultinomialbasicforcefactorr   r   c                      g | ]}|j         	|S r?   r   r   r   s     r   rN   z-Add._eval_as_leading_term.<locals>.<listcomp>  s    :::!AM:A:::r    r   c                 @    g | ]}|                                S )r  )as_leading_term)r   r   _logxr   r   s     r   rN   z-Add._eval_as_leading_term.<locals>.<listcomp>  s.    XXX**15t*DDXXXr    r   rD   r?   )#sympy.core.symbolr   r  r  r  &sympy.functions.elementary.exponentialr  $sympy.functions.elementary.piecewiser  r  r   r  r  r  r   r   r"   expandr3   r  	TypeErrorsubsrd   trigsimpcancelgetnNotImplementedErrorr   rn   rc   r   powsimpre   r   r9   )r   r   r   r   r   r  r  r  r  r  rM   r   logflagsr&   rz  leading_termsminnew_exprr  orderrd   n0resincrr  r  s    ` `                    @@r   _eval_as_leading_termzAdd._eval_as_leading_term  s   33333333,,,,,,>>>>>>RRRRRRRR((((((IIKK9aAllnn779 	& .%%C 55554955555 	) $T%e#EETY! !H #*((x((Cz#{ 	A''4'@@@::ty:::!%f4XXXXXXdiXXXa!X
	% % %dA %e3..C#HHE\\$H%  	 	 	KKK	 <}}UCCFF33H"?((**1133H&Gd??XXZZ&   Uvvf~~ U%((C5D, ''RW4d'KKRRTT\\^^ggii	 ,  &&qt$&???8&&x00144 Os$   "%E EE6G G$#G$c                 4     | j         d | j        D              S )Nc                 6    g | ]}|                                 S r?   )adjointr  s     r   rN   z%Add._eval_adjoint.<locals>.<listcomp>C  s     :::1199;;:::r    r   r   s    r   _eval_adjointzAdd._eval_adjointB  s"    ty::	:::;;r    c                 4     | j         d | j        D              S )Nc                 6    g | ]}|                                 S r?   )	conjugater  s     r   rN   z'Add._eval_conjugate.<locals>.<listcomp>F       <<<Q1;;==<<<r    r   r   s    r   _eval_conjugatezAdd._eval_conjugateE  "    ty<<$)<<<==r    c                 4     | j         d | j        D              S )Nc                 6    g | ]}|                                 S r?   )	transposer  s     r   rN   z'Add._eval_transpose.<locals>.<listcomp>I  r  r    r   r   s    r   _eval_transposezAdd._eval_transposeH  r  r    c                 f   g }d}| j         D ]`}|                                \  }}|j        st          j        }|}|p|t          j        u }|                    |j        |j        |f           a|sAt          t          d |D             d          }t          t          d |D             d          }n@t          t          d |D             d          }t          t          d |D             d          }||cxk    rdk    rn nt          j        | fS |sCt          |          D ]2\  }\  }	}
}t          t          |	|z  ||
z  z            |          ||<   3nft          |          D ]V\  }\  }	}
}|
r*t          t          |	|z  ||
z  z            |          ||<   5t          t          |	|
          |          ||<   W|d         j        s|d         t          j        u r|                    d          }nd}t#          |           |r|                    d|           t          ||           | j        | fS )	a  
        Return ``(R, self/R)`` where ``R``` is the Rational GCD of ``self```.

        ``R`` is collected only from the leading coefficient of each term.

        Examples
        ========

        >>> from sympy.abc import x, y

        >>> (2*x + 4*y).primitive()
        (2, x + 2*y)

        >>> (2*x/3 + 4*y/9).primitive()
        (2/9, 3*x + 2*y)

        >>> (2*x/3 + 4.2*y).primitive()
        (1/3, 2*x + 12.6*y)

        No subprocessing of term factors is performed:

        >>> ((2 + 2*x)*x + 2).primitive()
        (1, x*(2*x + 2) + 2)

        Recursive processing can be done with the ``as_content_primitive()``
        method:

        >>> ((2 + 2*x)*x + 2).as_content_primitive()
        (2, x*(x + 1) + 1)

        See also: primitive() function in polytools.py

        Fc                     g | ]
}|d          S r   r?   r  s     r   rN   z!Add.primitive.<locals>.<listcomp>y       5 5 5!1 5 5 5r    r   c                     g | ]
}|d          S r   r?   r  s     r   rN   z!Add.primitive.<locals>.<listcomp>z  r  r    r   c                 .    g | ]}|d          
|d         S )r   r   r?   r  s     r   rN   z!Add.primitive.<locals>.<listcomp>|  %     = = =!! =1 = = =r    c                 .    g | ]}|d          
|d          S r  r?   r  s     r   rN   z!Add.primitive.<locals>.<listcomp>}  r  r    N)r"   ri   r`   r   rn   rf   r6   r   r   r   r   r   	enumerater   Rationalr5   r2   r.   r7   rp   )r   rx   r   r<   r\   r   ngcddlcmr   r   r   r  s               r   r  zAdd.primitiveK  s   F  	( 	(A>>##DAq= E/a//CLL!#qsA'''' 	B$ 5 5u 5 5 5q99D$ 5 5u 5 5 5q99DD$ = =u = = =qAAD$ = =u = = =qAAD415$; 	A#,U#3#3 L L<Aq$&xD470C'D'DdKKaL $-U#3#3 A A<Aq$ A*8QWtQw4G+H+H$OOE!HH*8Aq>>4@@E!HH 8 	qQ->!>!>		!AAA 	LLAd##%6T%6%>>>r    c           	          | j         fd| j        D                                              \  }}sP|j        sI|j        rB|                                \  }}||z  }t          d |j        D                       r|}n||z  }r|j        r|j        }g }d}	|D ]}
t          t                    }t          j
        |
          D ]p}|j        rg|                                \  }}|j        rI|j        rB||j                                     t!          t#          |                    |j        z             q|s n7|	"t'          |                                          }	n(|	t'          |                                          z  }	|	s n|                    |           |D ]V}t          |                                          D ]|	vr|                               |D ]t          |          |<   Wg |	D ]Pt-          t.          fd|D             d          }|dk    r&                    |t1          d          z             Qr$t           fd|D             } |j         | z  }||fS )a  Return the tuple (R, self/R) where R is the positive Rational
        extracted from self. If radical is True (default is False) then
        common radicals will be removed and included as a factor of the
        primitive expression.

        Examples
        ========

        >>> from sympy import sqrt
        >>> (3 + 3*sqrt(2)).as_content_primitive()
        (3, 1 + sqrt(2))

        Radical content can also be factored out of the primitive:

        >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)
        (2, sqrt(2)*(1 + 2*sqrt(5)))

        See docstring of Expr.as_content_primitive for more examples.
        c                 L    g | ] }t          |                                !S ))radicalclear)r   as_content_primitive)r   r<   r  r  s     r   rN   z,Add.as_content_primitive.<locals>.<listcomp>  sK      ?  ?  ?/0 !,Q-C-C5 .D .* .* !+  ?  ?  ?r    c              3   T   K   | ]#}|                                 d          j        V  $dS )r   N)ri   rl   r%  s     r   r   z+Add.as_content_primitive.<locals>.<genexpr>  s4      CCa1>>##A&1CCCCCCr    Nc                      g | ]
}|         S r?   r?   )r   r   r   s     r   rN   z,Add.as_content_primitive.<locals>.<listcomp>  s    %9%9%9qad%9%9%9r    r   r   c                     g | ]}|z  S r?   r?   )r   rO  Gs     r   rN   z,Add.as_content_primitive.<locals>.<listcomp>  s    000RBqD000r    )r   r"   r  rl   r3   r  r   r   r0   rq   r  rj   rk   r`   r   r6   r   intr   rr  keysr2   r   r   r  )r   r  r  conprimr  _pr"   radscommon_qr   	term_radsrO  rw   r|   r   gr  r   s    ``              @@r   r  zAdd.as_content_primitive  s   ( DI  ?  ?  ?  ?  ?48I ?  ?  ? @@I	 	T 	S^ 	 	''))FCaBCC27CCCCC q '	.t{ '	.9DDH ". ".'--	-** D DBy D!~~//1= DQ\ D%acN11#c!ff++qs2BCCC  E#"9>>#3#344HH'#inn.>.>*?*??H# I&&&&  * *A!!&&((^^ % %H,,EE!HHH * *"AaDz!* ! 4 4At%9%9%9%9D%9%9%91==AAvvHQNN!2333 .QA00004000DYTY--DDyr    c                 T    ddl m} t          t          | j        |                    S )Nr   )default_sort_keyr+   )sortingr  r   sortedr"   )r   r  s     r   _sorted_argszAdd._sorted_args  s2    ------VDI+;<<<===r    c                 N    ddl m  | j        fd| j        D              S )Nr   )difference_deltac                 *    g | ]} |          S r?   r?   )r   r<   ddr   steps     r   rN   z.Add._eval_difference_delta.<locals>.<listcomp>  s%    ===a22aD>>===r    )sympy.series.limitseqr  r   r"   )r   r   r  r  s    ``@r   _eval_difference_deltazAdd._eval_difference_delta  sC    @@@@@@ty======49===>>r    c                     ddl m} |                                 \  }}|                                \  }}|t          j        k    st          d           ||          j         ||          j        fS )z;
        Convert self to an mpmath mpc if possible
        r   )Floatz@Cannot convert Add to mpc. Must be of the form Number + Number*I)numbersr  r   ri   r   r   AttributeError_mpf_)r   r  r  restr  	imag_units         r   _mpc_z	Add._mpc_  s    
 	#"""""))++!..00AO++ !!cdddg$eeGnn&:;;r    c                     t           j        s t                                                      S t	          t
          j        |           S rF   )r	   
distributero  __neg__rq   r   NegativeOne)r   r{  s    r   r#  zAdd.__neg__  s4     + 	%77??$$$1=$'''r    )FNr  rJ  rF   rX  )Nr   )FT)Dr   
__module____qualname____doc__	__slots__tTupler   __annotations__r3   
_args_typeclassmethodr   r   propertyr   r   r   r   r   r   r   r   r   r   staticmethodr   r   r  r  r  r  r"  _eval_is_real_eval_is_extended_real_eval_is_complex_eval_is_antihermitian_eval_is_finite_eval_is_hermitian_eval_is_integer_eval_is_rational_eval_is_algebraic_eval_is_commutativerH  rP  rU  r\  rb  rh  rp  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r#  __classcell__)r{  s   @r   r8   r8   V   s9        T Tl I
s
FJR$ R$ [R$h " " [" 
 
 X
/ / / ! ! W!,   1) 1) 1)f : : W:! ! ! !  ? ? ? ? , , \,2 ? ? W?&1: 1: 1:fI I IP P P- - -M M M9 9MB B< <B B; ;O> >< <= => >- -    8' ' 'R5 5 5     4 4 4 4 4l( ( (( ( (4 4 4 4 4l#F #F #FJ( ( (, , ,
 # # # W#J: : : :.I I I IV< < <> > >> > >N? N? N?`F F F FP > > X>? ? ? < < X<( ( ( ( ( ( ( ( (r    r8   rs  )rq   r   r   )r  N).typingr   r)  collectionsr   	functoolsr   operatorr   r  r   
parametersr	   logicr
   r   r   	singletonr   
operationsr   r   cacher   r  r   intfuncr   r   r&   r   r   r   sympy.utilities.iterablesr   r   r)   r.   r=   r8   rs  r  rq   r   r   r  r?   r    r   <module>rE     s   " " " " " " # # # # # #                         ) ) ) ) ) ) 4 4 4 4 4 4 4 4 4 4       2 2 2 2 2 2 2 2       ! ! ! ! ! !                     7 7 7 7 7 7 7 76 6 6 ! ! !
-# -# -#`i( i( i( i( i($ i( i( i(V%  3 3 3 3 3 3 3 3 3 3        r    