
    \ha5                   v   S SK Jr  S SKJrJr  S SKJr  S SKJr  S SK	J
r
  S SKrSSKJr  SS	KJrJr  SS
KJr  SSKJrJr  SSKJr  SSKJrJr  SSKJrJr  SSKJr  SSKJ r   SSK!J"r"  SSK#J$r$  S SK%J&r&   " S S5      r'S r(S r) " S S\\5      r*\" S5      r+S!S jr,S"S jr-S r.SSK/J0r0  SSK1J2r2  SS K3J4r4J5r5  g)#    )annotations)TYPE_CHECKINGClassVar)defaultdict)reduce)productN   )sympify)Basic_args_sortkey)S)AssocOpAssocOpDispatcher)cacheit)integer_nthroottrailing)	fuzzy_not_fuzzy_group)Expr)global_parameters)KindDispatcher	bottom_up)siftc                  (    \ rS rSrSrSrSrSrSrSr	g)	NC_Marker   F N)
__name__
__module____qualname____firstlineno__is_Orderis_Mul	is_Numberis_Polyis_commutative__static_attributes__r       F/var/www/auris/envauris/lib/python3.13/site-packages/sympy/core/mul.pyr   r      s    HFIGNr)   r   c                *    U R                  [        S9  g )Nkey)sortr   argss    r*   _mulsortr1   "   s    II-I r)   c                    / n/ n[        U 5      n [        R                  nU  H  nUR                  (       a6  UR	                  5       u  pVU R                  U5        UR                  U5        MJ  UR                  (       a  X4-  nMa  UR                  (       a  UR                  U5        M  UR                  U5        M     [        U5        U[        R                  La  UR                  SU5        [        R                  X-   5      $ )a  Return a well-formed unevaluated Mul: Numbers are collected and
put in slot 0, any arguments that are Muls will be flattened, and args
are sorted. Use this when args have changed but you still want to return
an unevaluated Mul.

Examples
========

>>> from sympy.core.mul import _unevaluated_Mul as uMul
>>> from sympy import S, sqrt, Mul
>>> from sympy.abc import x
>>> a = uMul(*[S(3.0), x, S(2)])
>>> a.args[0]
6.00000000000000
>>> a.args[1]
x

Two unevaluated Muls with the same arguments will
always compare as equal during testing:

>>> m = uMul(sqrt(2), sqrt(3))
>>> m == uMul(sqrt(3), sqrt(2))
True
>>> u = Mul(sqrt(3), sqrt(2), evaluate=False)
>>> m == uMul(u)
True
>>> m == Mul(*m.args)
False

r   )listr   Oner$   args_cncextendr%   r'   appendr1   insertMul
_from_args)r0   cargsncargscoaa_ca_ncs          r*   _unevaluated_MulrA   '   s    > EF:D	
B88

ICKKMM$[[GBLLOMM!  UO	Q>>%,''r)   c                    ^  \ rS rSr% SrSrSr\r\	" SSS9r
S\S'   \S	 5       r\(       a  SS
.SMS jjr\SNS j5       rS rS r\S 5       rS r\S 5       rS r\S 5       r\S 5       r\SS.S j5       rSOS jrSPS jr\S 5       rS r \S 5       r!\U 4S j5       r"S r#S r$SQS jr%\S  5       r&\SRS! j5       r'\S" 5       r(\S# 5       r)\S$ 5       r*\S% 5       r+\S& 5       r,S' r-S( r.S) r/S* r0S+ r1S, r2S- r3S. r4S/ r5S0 r6S1 r7S2 r8S3 r9S4 r:S5 r;S6 r<S7 r=S8 r>S9 r?S: r@S; rAS< rBS= rCS> rDS? rES@ rFSA rGSB rHSC rISD rJSSSE jrKSF rLSG rMSH rNSI rOSTSJ jrPSRSK jrQ\SL 5       rRSrSU =rT$ )Ur9   [   a~  
Expression representing multiplication operation for algebraic field.

.. 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 ``Mul()`` must be ``Expr``. Infix operator ``*``
on most scalar objects in SymPy calls this class.

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

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

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

2. Identity removing
    ``Mul(x, 1, y)`` -> ``Mul(x, y)``

3. Exponent collecting by ``.as_base_exp()``
    ``Mul(x, x**2)`` -> ``Pow(x, 3)``

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

Since multiplication can be vector space operation, arguments may
have the different :obj:`sympy.core.kind.Kind()`. Kind of the
resulting object is automatically inferred.

Examples
========

>>> from sympy import Mul
>>> from sympy.abc import x, y
>>> Mul(x, 1)
x
>>> Mul(x, x)
x**2

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

>>> Mul(1, 2, evaluate=False)
1*2
>>> Mul(x, x, evaluate=False)
x*x

``Mul()`` also represents the general structure of multiplication
operation.

>>> from sympy import MatrixSymbol
>>> A = MatrixSymbol('A', 2,2)
>>> expr = Mul(x,y).subs({y:A})
>>> expr
x*A
>>> type(expr)
<class 'sympy.matrices.expressions.matmul.MatMul'>

See Also
========

MatMul

r   TMul_kind_dispatcher)commutativezClassVar[Expr]identityc                F    S U R                    5       nU R                  " U6 $ )Nc              3  8   #    U  H  oR                   v   M     g 7fN)kind.0r>   s     r*   	<genexpr>Mul.kind.<locals>.<genexpr>   s     /YVVY   )r0   _kind_dispatcher)self	arg_kindss     r*   rJ   Mul.kind   s!    /TYY/	$$i00r)   evaluatec                   g rI   r   )clsrU   r0   s      r*   __new__Mul.__new__   s    r)   c                    g rI   r   rQ   s    r*   r0   Mul.args   s    r)   c                l    X * :X  a  gU R                   S   nUR                  =(       a    UR                  $ )NFr   )r0   r%   is_extended_negative)rQ   cs     r*   could_extract_minus_signMul.could_extract_minus_sign   s.    E?IIaL{{5q555r)   c                T   U R                  5       u  pUS   [        R                  La  U* nU[        R                  LaP  US   R                  (       a6  [        U5      nU[        R                  L a
  US   * US'   OUS==   U-  ss'   OU4U-   nU R                  X R                  5      $ Nr   )	as_coeff_mulr   ComplexInfinityr4   r%   r3   NegativeOner:   r'   )rQ   r_   r0   s      r*   __neg__Mul.__neg__   s    ##%7!+++AAEE>Aw  Dz%#AwhDGGqLGtd{t%8%899r)   c           
       ^"^6 SSK Jn  SSKJm6  Sn[	        U5      S:X  Ga  Uu  nm"T"R
                  (       a	  T"Usnm"UT"/nU[        R                  Ld   eUR
                  (       a  UR                  (       d  T"R                  5       u  nm"T"R                  (       a  U[        R                  La+  XE-  nU[        R                  L a  T"nO
U " XE-  T"SS9nU// S4nOX[        R                  (       aC  T"R                  (       a2  [        T"R                   Vs/ s H  n[!        XH5      PM     sn6 n	U	// S4nU(       a  U$ / n
/ n/ n[        R                  n/ n/ n[        R"                  n0 nSnU GH  nUR$                  (       a  UR'                  U5      u  nnUR(                  (       a  UR                  (       a  UR+                  UR                  5        O]UR                   H8  nUR                  (       a  UR-                  U5        M'  UR-                  U5        M:     UR-                  [.        5        M  UR0                  (       a  U[        R2                  L d$  U[        R4                  L a'  UR                  (       a  [        R2                  // S4s  $ UR0                  (       d  [7        X5      (       a.  UU-  nU[        R2                  L a  [        R2                  // S4s  $ GMv  [7        UU5      (       a  UR9                  U5      nGM  U[        R4                  L a0  U(       d  [        R2                  // S4s  $ [        R4                  nGM  U(       dL  [7        U[        5      (       a7  [;        S UR                   5       5      (       a  [        R2                  // S4s  $ U[        R<                  L a  U[        R>                  -  nGMZ  UR                  (       Ga6  URA                  5       u  m"nURB                  (       a  T"R0                  (       a  UR
                  (       a  URD                  (       a  U[G        T"U5      -  nGM  URH                  (       a  UR-                  [G        T"U5      5        GM  T"RH                  (       a  UU-  nT"* m"T"[        R                  La!  URK                  T"/ 5      R-                  U5        GMT  T"RL                  (       d  URN                  (       a  UR-                  T"U45        GM  UR-                  T"U45        GM  U[.        La  UR-                  U5        U(       d  GM  URQ                  S5      nU(       d  UR-                  U5        M5  URQ                  5       nURA                  5       u  nnURA                  5       u  nnUU-   nUU:X  aM  UR                  (       d<  UU-  nUR                  (       a  UR-                  U5        M  URS                  SU5        OUR+                  UU/5        U(       a  M  GM     S	 nU" U5      nU" U5      n[U        S5       GH  n/ nSn U GHJ  u  m"nUR                  (       a  T"R                  (       d  T"R(                  (       a_  [;        U"4S
 j[        R4                  [        RV                  [        RX                  4 5       5      (       a  [        R2                  // S4s  s  $ M  U[        R                  L a  T"R0                  (       a  UT"-  nM  T"n!U[        R                  LaK  [G        T"U5      n!U!RB                  (       a.  T"RB                  (       d  T"nU!RA                  5       u  m"nT"U:w  a  Sn U
R-                  W!5        UR-                  T"U45        GMM     U (       a;  [	        U V"Vs1 s H  u  n"nU"iM
     snn"5      [	        U5      :w  a  / n
U" U5      nGM    O   0 n#U H'  u  m"nU#RK                  U/ 5      R-                  T"5        M)     U#R[                  5        H  u  nm"U " T"6 U#U'   M     U
R+                  U#R[                  5        VV"s/ s H  u  nn"U(       d  M  [G        U"U5      PM     sn"n5        0 n$UR[                  5        H-  u  m"nU$RK                  [        U6 / 5      R-                  T"5        M/     A/ n%U$R[                  5        H  u  nm"U " T"6 m"UR\                  S:X  a  U[G        T"U5      -  nM,  UR^                  UR\                  :  aH  [a        UR^                  UR\                  5      u  n&n'U[G        T"U&5      -  n[c        U'UR\                  5      nU%R-                  T"U45        M     A$[e        [f        5      n(SnU[	        U%5      :  Ga  U%U   u  nn)US:X  a  US-  nM%  / n*[U        US-   [	        U%5      5       H  n+U%U+   u  n,n-URi                  U,5      n.U.[        R                  Ld  M1  U)U--   nUR\                  S:X  a  U[G        U.U5      -  nOuUR^                  UR\                  :  aH  [a        UR^                  UR\                  5      u  n&n'U[G        U.U&5      -  n[c        U'UR\                  5      nU*R-                  U.U45        U,U.-  U-4U%U+'   UU.-  nU[        R                  L d  M    O   U[        R                  La  [G        UU)5      n/U/R0                  (       a  UU/-  nOj[j        Rm                  U/5       HQ  n/U/R0                  (       a  UU/-  nM  U/RB                  (       d   eU/R                  u  nn)U(U)   R-                  U5        MS     U%R+                  U*5        US-  nU[	        U%5      :  a  GM  U(R[                  5        H  u  nm"U " T"6 U(U'   M     U(       a  URo                  5       u  n!n[a        U!U5      u  n0n!U0S-  (       a  U* nUS:X  a   U
R-                  [        R<                  5        OvU!(       ao  [c        U!U5      nU(R[                  5        H'  u  nm"UU:X  d  M  T"RL                  (       d  M!  T"* U(U'     O*   U
R-                  [G        [        Rp                  USS95        U
R+                  U(R[                  5        VV"s/ s H  u  nn"[G        U"U5      PM     sn"n5        U[        RV                  [        RX                  4;   a   S n1U1" U
S5      u  n
n2U1" UU25      u  nn2UU2-  nU[        R4                  L aw  U
 V3s/ s H.  n3[s        U3R                  5      (       a  U3Rt                  b  M,  U3PM0     n
n3U V3s/ s H.  n3[s        U3R                  5      (       a  U3Rt                  b  M,  U3PM0     nn3ObUR                  (       aQ  [;        U64S jU 5       5      (       a  U/UU4$ [;        S U
 5       5      (       a  [        R2                  // U4$ U// U4$ / n4U
 H,  nUR0                  (       a  UU-  nM  U4R-                  U5        M.     U4n
[w        U
5        U[        R                  La  U
RS                  SU5        [        R                  (       a  U(       dz  [	        U
5      S:X  ak  U
S   R0                  (       aW  U
S   Rx                  (       aC  U
S   R                  (       a/  U
S   n[        U
S   R                   V5s/ s H  n5UU5-  PM
     sn56 /n
XU4$ s  snf s  snn"f s  sn"nf s  sn"nf s  sn3f s  sn3f s  sn5f )a6  Return commutative, noncommutative and order arguments by
combining related terms.

Notes
=====
    * In an expression like ``a*b*c``, Python process this through SymPy
      as ``Mul(Mul(a, b), c)``. This can have undesirable consequences.

      -  Sometimes terms are not combined as one would like:
         {c.f. https://github.com/sympy/sympy/issues/4596}

        >>> from sympy import Mul, sqrt
        >>> from sympy.abc import x, y, z
        >>> 2*(x + 1) # this is the 2-arg Mul behavior
        2*x + 2
        >>> y*(x + 1)*2
        2*y*(x + 1)
        >>> 2*(x + 1)*y # 2-arg result will be obtained first
        y*(2*x + 2)
        >>> Mul(2, x + 1, y) # all 3 args simultaneously processed
        2*y*(x + 1)
        >>> 2*((x + 1)*y) # parentheses can control this behavior
        2*y*(x + 1)

        Powers with compound bases may not find a single base to
        combine with unless all arguments are processed at once.
        Post-processing may be necessary in such cases.
        {c.f. https://github.com/sympy/sympy/issues/5728}

        >>> a = sqrt(x*sqrt(y))
        >>> a**3
        (x*sqrt(y))**(3/2)
        >>> Mul(a,a,a)
        (x*sqrt(y))**(3/2)
        >>> a*a*a
        x*sqrt(y)*sqrt(x*sqrt(y))
        >>> _.subs(a.base, z).subs(z, a.base)
        (x*sqrt(y))**(3/2)

      -  If more than two terms are being multiplied then all the
         previous terms will be re-processed for each new argument.
         So if each of ``a``, ``b`` and ``c`` were :class:`Mul`
         expression, then ``a*b*c`` (or building up the product
         with ``*=``) will process all the arguments of ``a`` and
         ``b`` twice: once when ``a*b`` is computed and again when
         ``c`` is multiplied.

         Using ``Mul(a, b, c)`` will process all arguments once.

    * The results of Mul are cached according to arguments, so flatten
      will only be called once for ``Mul(a, b, c)``. If you can
      structure a calculation so the arguments are most likely to be
      repeats then this can save time in computing the answer. For
      example, say you had a Mul, M, that you wished to divide by ``d[i]``
      and multiply by ``n[i]`` and you suspect there are many repeats
      in ``n``. It would be better to compute ``M*n[i]/d[i]`` rather
      than ``M/d[i]*n[i]`` since every time n[i] is a repeat, the
      product, ``M*n[i]`` will be returned without flattening -- the
      cached value will be returned. If you divide by the ``d[i]``
      first (and those are more unique than the ``n[i]``) then that will
      create a new Mul, ``M/d[i]`` the args of which will be traversed
      again when it is multiplied by ``n[i]``.

      {c.f. https://github.com/sympy/sympy/issues/5706}

      This consideration is moot if the cache is turned off.

    NB
    --
      The validity of the above notes depends on the implementation
      details of Mul and flatten which may change at any time. Therefore,
      you should only consider them when your code is highly performance
      sensitive.

      Removal of 1 from the sequence is already handled by AssocOp.__new__.
r   )AccumBounds)
MatrixExprN   FrT   c              3     #    U  HT  n[         R                  U5        H7  nU[        R                  [        R                  [        R
                  4;   v   M9     MV     g 7frI   )r9   	make_argsr   NegativeInfinityre   Infinity)rL   ___s      r*   rM   Mul.flatten.<locals>.<genexpr>  sJ      :A$cmmB.? !,,a.?.?LL.? M$s   AAc           
        0 nU  HL  u  p#UR                  5       nUR                  U0 5      R                  US   / 5      R                  US   5        MN     UR                  5        H(  u  p%UR                  5        H  u  pg[	        U6 XV'   M     M*     / nUR                  5        H=  u  p#UR                  UR                  5        V	V
s/ s H  u  pX*U	-  4PM     sn
n	5        M?     U$ s  sn
n	f Nr	   r   )as_coeff_Mul
setdefaultr7   itemsAddr6   )c_powerscommon_bber=   ddilinew_c_powerstr_   s              r*   _gatherMul.flatten.<locals>._gather  s    H ^^%##Ar*55qE2%vbe} ! !(ggiFBHAE ( ) L (##!'')$D)$!a1X)$DE ) %Es   C&c              3  B   >#    U  H  nUTR                   ;   v   M     g 7frI   r/   )rL   inftyr|   s     r*   rM   rs     s$      6;&:E 7<qvvo&:s   Tr	   c                    / nU  H?  nUR                   (       a  M  UR                  (       a  US-  nM.  UR                  U5        MA     X!4$ N)is_extended_positiver^   r7   )c_part
coeff_sign
new_c_partr   s       r*   _handle_for_oo#Mul.flatten.<locals>._handle_for_oo  sL    
A-- --"b(
 %%a(   "--r)   c              3  <   >#    U  H  n[        UT5      v   M     g 7frI   )
isinstance)rL   r_   rk   s     r*   rM   rs     s     >g:a,,gs   c              3  >   #    U  H  oR                   S :H  v   M     g7fFN	is_finite)rL   r_   s     r*   rM   rs     s     8A;;%'   )=!sympy.calculus.accumulationboundsrj   sympy.matrices.expressionsrk   lenis_Rationalr   r4   is_zerorv   is_Addr   
distributer'   ry   r0   _keep_coeffZeror#   as_expr_variablesr$   r6   r7   r   r%   NaNre   r   __mul__anyImaginaryUnitHalfas_base_expis_Pow
is_IntegerPowis_negativerw   is_positive
is_integerpopr8   rangerp   ro   rx   qpdivmodRationalr   r3   gcdr9   rn   as_numer_denomrf   r   is_extended_realr1   r   )7rW   seqrj   rvr>   rararbbinewbr   nc_partnc_seqcoeffrz   num_expneg1epnum_ratorder_symbolsor   r}   o1b1e1b2e2new_expo12r   ir   changedr   r|   inv_exp_dictcomb_enum_rate_ieppneweigrowjbjejgobjnr   r   r_   _newfrk   s7                                     `                   @r*   flattenMul.flatten   sI   ^ 	B9s8q=DAq}}!1!fAEE>!>}}QYY~~'188~S;"#C"%ac1u"=C!UB_*55!:J:J"!&&$I&B[%7&$IJ"VR-	      Azz#$#6#6}#E = xx##JJqvv& VV++JJqM"MM!,	 $ JJy) :!*;*;!;		EE7B,,__
5(F(FQJE~ !wD00A{++		%(a'''EE7B,,))z!S11c :Aff:A 7A 7A wD((aoo%!!! }}1 88{{
 == || %Q 2 (!" #

3q!9 5 (!" %
%&B ~ ( 3 3Ar : A A! D$]]all#NNAq62$A'
 I%MM!$ f

1A"q)  !B^^-FB]]_FB 2gG
 Rx Gm --JJsO$"MM!S1  Aw/7 fE X	  8$ '"0 qALG 199AHH# 6;&'&7&7&'&8&8&:6; 3; 3; !"wD00:{{
 AAEE>Aq	A xx }}17&*Ga ##QF+1 !6 3". 0".$!QA, 0 1474EF "<0I P DAq##Ar*11!4  &&(DAq!1gLO )\-?-?-AG-ATQQys1ay-AGH NN$DAqc1gr*11!4 % LLNDAqQAssaxQ"ssQSSy acc*RQ$R%NNAq6" #  4 #g,QZFBQwQD1q5#g,/ BFF2JAEE> RAssaxQ*339&,QSS!##&6GC!SC[0E (QSS 1AQF+"$Q$GAJABQUU{) 0* "bk==SLE  #}}S1==!SLE#&::-:%(XXFB HOOB/  2 NN4 FAU #g,Z JJLDAq1gDG ! ((*DAq!Q<DAq1uAvaoo. !A JJLDAqEzammm#$"Q ) MM#ammUU"KL 	TZZ\:\TQs1ay\:; QZZ!3!344	. "0!:FJ"0*"EGZZE A%%% "( QA	!))0D0D010B0B F Q") S'Q)AII2F2F232D2D 'G SG ]] >g>>>w668888wM117B-- A{{
A	 
  	 MM!U# ((S[A=Mq	##q	(;(;q	@P@P1IEVAY^^<^E!G^<=>F--] %Jt 0  HJ ;2QSD =s<   {
{6{
{
9{
5+{!${!0+{&{&2{+c                .   U R                  SS9u  p#UR                  (       a@  [        U Vs/ s H  n[        XASS9PM     sn6 [        [        R	                  U5      USS9-  $ UR
                  (       a  UR                  S:X  a  U R                  (       a  U R                  5       S   nUR
                  (       a  [        US-  5      R                  5       u  pg[        US5      u  phU(       ah  [        US5      u  pxU(       aS  SSKJn	  [        U5      U-  n
[        XR                   -  SU	" U5      ["        R$                  -  -   UR                   -  5      $ [        XSS9nUR
                  (       d  UR&                  (       a  UR)                  5       $ U$ s  snf )NF)split_1rT   rl   r	   r   sign)r5   r   r9   r   r:   r   r   is_imaginaryas_real_imagabsr   r   $sympy.functions.elementary.complexesr   r
   rA   r   r   r   is_Float_eval_expand_power_base)rQ   exptr;   ncr|   r>   r   r~   r   r   r   r   s               r*   _eval_powerMul._eval_power  s@    MM%M0	??uEu!Qu5uEFCNN2&u=> >!  %%'*==qs8224DA*1a0DA.q!4Q '
1A#3AvvIDGAOOD[@[^b^d^d?d#eeU+t}},,..) Fs   Fc                     SSU R                   4$ )N   r   )r   rW   s    r*   	class_keyMul.class_key  s    !S\\!!r)   c                D   U R                  5       u  p#U[        R                  L aC  UR                  (       a  [        R
                  " X15      * nO0UR                  U5      nUb  UnU* nO[        R
                  " X5      nUR                  (       a  UR                  5       $ U$ rI   )rv   r   rf   r$   r   _eval_evalf	is_numberexpand)rQ   precr_   mr   mnews         r*   r   Mul._eval_evalf  s      "xx))!22}}T*#AR$$T0B<<99;	r)   c                    SSK Jn  U R                  5       u  p#U[        R                  La  [        S5      eU" S5      R                  U" U5      R                  4$ )z+
Convert self to an mpmath mpc if possible
r	   )Floatz7Cannot convert Mul to mpc. Must be of the form Number*Ir   )numbersr   rv   r   r   AttributeError_mpf_)rQ   r   im_part	imag_units       r*   _mpc_	Mul._mpc_  sO    
 	#!..0AOO+ !!Z[[ag 4 455r)   c                    U R                   n[        U5      S:X  a  [        R                  U 4$ [        U5      S:X  a  U$ US   U R                  " USS 6 4$ )a  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_mul() which gives the head and a tuple containing
  the arguments of the tail when treated as a Mul.
- if you want the coefficient when self is treated as an Add
  then use self.as_coeff_add()[0]

Examples
========

>>> from sympy.abc import x, y
>>> (3*x*y).as_two_terms()
(3, x*y)
r	   rl   r   N)r0   r   r   r4   _new_rawargs)rQ   r0   s     r*   as_two_termsMul.as_two_terms   sX    * yyt9>55$;Y!^K 7D--tABx888r)   )rationalc                 ^ T(       a5  [        U R                  U4S jSS9u  pEU R                  " U6 [        U5      4$ U R                  nUS   R                  (       aV  U(       a  US   R
                  (       a
  US   USS  4$ US   R                  (       a  [        R                  US   * 4USS  -   4$ [        R                  U4$ )Nc                "   > U R                   " T6 $ rI   )has)xdepss    r*   <lambda>"Mul.as_coeff_mul.<locals>.<lambda>B  s    quud|r)   T)binaryr   r	   )
r   r0   r  tupler%   r   r^   r   rf   r4   )rQ   r  r  kwargsl1l2r0   s     `    r*   rd   Mul.as_coeff_mul?  s    $))%;DIFB$$b)5944yy7tAw22AwQR((a--}}QxkDH&<<<uud{r)   c                f   U R                   S   U R                   SS p2UR                  (       ar  U(       a  UR                  (       a%  [        U5      S:X  a  X#S   4$ X R                  " U6 4$ UR
                  (       a$  [        R                  U R                  " U* 4U-   6 4$ [        R                  U 4$ )z3
Efficiently extract the coefficient of a product.
r   r	   N)	r0   r%   r   r   r  r^   r   rf   r4   )rQ   r  r   r0   s       r*   rv   Mul.as_coeff_MulL  s     iilDIIabMt??u00t9> q'>) "3"3T":::++}}d&7&7E6)d:J&LLLuud{r)   c                    SSK JnJnJn  / n/ n/ n[        R
                  n	U R                   GH  n
U
R                  5       u  pUR                  (       a  UR                  U5        M:  UR                  (       a$  UR                  U[        R                  -  5        Mo  U
R                  (       a{  U(       a  U
R                  5       OS n[        U5       H)  u  pX:X  d  M  UR                  U" U5      S-  5        Xl	   M     U
R                  (       a  X-  n	M  UR                  U
5        M  UR                  U
5        GM     U R                  " U6 nUR!                  S5      U:X  a  g [#        U5      S-  (       a  U" UR%                  S5      5      nO[        R&                  nU R                  " Xx-   6 nUU" U5      -  UU" U5      -  pU	S:X  a_  US:X  a8  UR                  (       a  U[        R&                  4$ [        R&                  UU-  4$ U[        R&                  L a  X4$ U* U-  UU-  4$ SSKJn  U" U	SS9R                  5       u  nnU[        R&                  L a  UU-  UU-  -
  UU-  UU-  -   4$ U* U-  UU-  pUU-  UU-  -
  UU-  UU-  -   4$ )	Nr   )Absimrerl   ignorer	   )
expand_mulF)deep)r   r  r  r  r   r4   r0   r   r   r7   r   r'   	conjugate	enumerater   funcgetr   r   r   functionr  )rQ   r  hintsr  r  r  othercoeffrcoeffiaddtermsr>   r   r   aconjr  r   imcorecor  addreaddims                        r*   r   Mul.as_real_imag\  s-   DD55A>>#DAyya a/0!!).D%e,DAzc!fai0!H	 - xx QQ) * IIu99X!#v;?fjjm$D 66Dyy6?,RU
DAJ1q=Av<< !&&>)FFDI..qvv~vE!GT!V$$(!(7DDFu166>eGag%qw5'89957DFqeGag%qw5'899r)   c           	     D   [        U 5      nUS:X  a  U S   R                  $ / n[        R                  U SUS-   5      n[        R                  XS-  S 5      nU VVs/ s H  oT  H  n[        XV5      PM     M     nnn[	        U6 n[        R
                  " U5      $ s  snnf )zS
Helper function for _eval_expand_mul.

sums must be a list of instances of Basic.
r	   r   Nrl   )r   r0   r9   _expandsumsry   rn   )sumsLtermsleftrightr>   r|   addeds           r*   r0  Mul._expandsums  s     I67<<tEQT{+TU,$(8Dq%QQ%D8U}}U## 9s   Bc                   SSK Jn  U nU" X1R                  SS5      5      u  pEUR                  (       a9  XE4 Vs/ s H(  nUR                  (       a  UR                  " S0 UD6OUPM*     snu  pEXE-  nUR                  (       d  U$ / / SpnUR
                   Hg  n
U
R                  (       a  UR                  U
5        Sn	M)  U
R                  (       a  UR                  U
5        MM  UR                  [        U
5      5        Mi     U	(       d  U$ U R                  " U6 nU(       a  UR                  SS5      nU R                  R                  U5      n/ nU Hn  nU R                  X~5      nUR                  (       a8  [        S UR
                   5       5      (       a  U(       a  UR	                  5       nUR                  U5        Mp     [        U6 $ U$ s  snf )	Nr   fractionexactFTr  c              3  8   #    U  H  oR                   v   M     g 7frI   )r   rK   s     r*   rM   'Mul._eval_expand_mul.<locals>.<genexpr>  s     'A&Q&rO   r   )sympy.simplify.radsimpr:  r"  r$   _eval_expand_mulr0   r   r7   r'   r   r!  r0  r   ry   )rQ   r$  r:  exprr   r~   r   plainr1  rewritefactorr  r3  r0   termr   s                   r*   r?  Mul._eval_expand_mul  sv   3 ii7888!A 4588A&&//B!DAs{{K!2uWiiF}}F#((LL(KKf.   KIIu%Eyy/		--d3!D		%.AxxC'A!&&'A$A$Ad..0KKN	 "
 Dz!A!s   /Gc           
     >   [        U R                  5      n/ n[        [        U5      5       HY  nX$   R	                  U5      nU(       d  M  UR                  [        S US U U/-   X$S-   S  -   [        R                  5      5        M[     [        R                  " U5      $ )Nc                
    X-  $ rI   r   )r  ys     r*   r  &Mul._eval_derivative.<locals>.<lambda>  s    r)   r	   )r3   r0   r   r   diffr7   r   r   r4   ry   fromiter)rQ   sr0   r3  r   r~   s         r*   _eval_derivativeMul._eval_derivative  s    DIIs4y!AQAq V$4tBQx1#~QRUV7TWXW\W\]^ " ||E""r)   c                Z  > SSK Jn  SSKJnJnJn  [        XU45      (       d  [        TU ]!  X5      $ SSK	J
n  U R                  n[        U5      n	[        U[        U45      (       ak  / n
SSKJn  U" X5       HO  u  p[!        [#        X5       VVs/ s H  u  pUR%                  X45      PM     snn6 nU
R'                  UU-  5        MQ     [)        U
6 $ SSKJn  SSKJn  SS	KJn  U" S
U	-  US9nU[7        U5      -
  nU" U5      nU[9        [;        UU5      5      -  U" U5      -  [!        [=        U	S-
  5       Vs/ s H  nUU   R%                  XU   45      PM     sn6 -  US   R%                  UU" SU5      45      -  U Vs/ s H  oSU4PM	     snnnU" U/UQ76 $ s  snnf s  snf s  snf )Nr	   )AppliedUndef)SymbolsymbolsDummy)Integerr   )!multinomial_coefficients_iterator)Sum)	factorial)Maxzk1:%ir   r   )r#  rP  symbolrQ  rR  rS  r   super_eval_derivative_n_timesr   rT  r0   r   intsympy.ntheory.multinomialrU  r9   ziprJ  r7   ry   sympy.concrete.summationsrV  (sympy.functions.combinatorial.factorialsrW  (sympy.functions.elementary.miscellaneousrX  sumprodmapr   )rQ   rL  r   rP  rQ  rR  rS  rT  r0   r   r3  rU  kvalsr_   kargr   rV  rW  rX  klastnfactr   r}   l	__class__s                            r*   r[  Mul._eval_derivative_n_times  s   *22!F344 73A99$yyIa#w((ES=aCU9IJ9Ivq#((A6*9IJKQU# D ;1F@!/CJ!$s9e,--i.>>uQqSzBz!$q',,8}-zBCDHMM1c!Um,-. !&&1AY&	 
 1zqz K C&s   F9"F#
F(c                    SSK Jn  U R                  S   n[        U R                  SS  6 nUR	                  XU-   5      U" XQU5      -  U" XAU5      U-  -   $ )Nr   )difference_deltar	   )sympy.series.limitseqrn  r0   r9   subs)rQ   r   stepddarg0rests         r*   _eval_difference_deltaMul._eval_difference_delta  s]    @yy|DIIabM"		!X&DT)::R=N>  	r)   c                    U R                  5       u  p4[        R                  U5      n[        U5      S:X  a/  U R                  R                  X5      nUS   R                  XR5      $ g ru   )rv   r9   rn   r   rk  _combine_inversematches)rQ   r@  	repl_dictr   r3  newexprs         r*   _matches_simpleMul._matches_simple  sW    ((*e$u:?nn55dBG8##G77r)   c                8   [        U5      nU R                  (       a#  UR                  (       a  U R                  XU5      $ U R                  UR                  La  g U R                  5       u  pEUR                  5       u  pgXF4 Vs/ s H  o=(       d    S/PM     snu  pF[	        U6 n	[	        U6 n
U	R                  XU5      nU(       d  XF:w  a  g [        R                  U5      n[        R                  U5      n[        R                  XWU5      nU=(       d    S $ s  snf Nr	   )r
   r'   _matches_commutativer5   r9   ry  _matches_expand_pows_matches_noncomm)rQ   r@  rz  oldc1nc1c2nc2r_   comm_mul_selfcomm_mul_exprs              r*   ry  Mul.matches  s    t}4#6#6,,TcBB  (;(;; --/--/%'H-Hq(s(H- RR!))-CH	 RX &&s+&&s+((9=	 D ) .s   Dc                    / nU  H`  nUR                   (       a;  UR                  S:  a+  UR                  UR                  /UR                  -  5        MO  UR	                  U5        Mb     U$ rc   )r   expr6   baser7   )arg_listnew_argsrg  s      r*   r  Mul._matches_expand_pows-  sP    Czzcggk
SWW 45$	 
 r)   c                   Uc  0 nOUR                  5       n/ nSnUu  pV0 nU[        U5      :  a  U[        U 5      :  a  X   nUR                  (       a  [        R	                  Xt5        [        R                  XtX5      n	U	(       a+  U	u  pUR                  U
5        U(       a  U H	  nX   X,'   M     U(       d  gUR                  5       nUu  pVU[        U5      :  a  U[        U 5      :  a  M  U$ )zNon-commutative multiplication matcher.

`nodes` is a list of symbols within the matcher multiplication
expression, while `targets` is a list of arguments in the
multiplication expression being matched against.
N)r   r   )copyr   is_Wildr9   _matches_add_wildcard_matches_new_statesr6   r   )nodestargetsrz  agendastatenode_ind
target_indwildcard_dictnodestates_matches
new_statesnew_matchesmatchs                r*   r  Mul._matches_noncomm7  s     I!(I $3w<'Hs5z,A?D||))-? 44]5:EN*8'
j)!,+6+=	( "-

',$% 3w<'Hs5z,A( r)   c                8    Uu  p#X ;   a  X   u  pEXC4X'   g X34X'   g rI   r   )
dictionaryr  r  r  beginends         r*   r  Mul._matches_add_wildcardb  s0    $!#-JE$)#6J $.#;J r)   c                   Uu  pEX$   nX5   nU[        U5      S-
  :  a  U[        U5      S-
  :  a  g UR                  (       a  [        R                  XX#5      nU(       a  [        R	                  U X$5      n	U	 H<  n
X
   u  pX   u  pX;US-    nX=US-    n[        UU5       H  u  nnUU:w  d  M      g    M>     XES-   4/nU[        U5      S-
  :  a  UR                  US-   US-   45        UU4$ g U[        U5      S-
  :  a  U[        U5      S-
  :  a  g UR                  U5      nU(       a  US-   US-   4/U4$ Xg:X  a  US-   US-   4/S 4$ g r  )r   r  r9   _matches_match_wilds_matches_get_other_nodesr^  r7   ry  )r  r  r  r  r  r  r  targetmatch_attemptother_node_indsindother_begin	other_end
curr_begincurr_endother_targetscurrent_targetscurrr%  	new_states                       r*   r  Mul._matches_new_statesk  s   $$ W))hUa.G<<44Z5:EM #&">">z?D#P*C-7_*K+5+?(J$+	A$FM&-A&FO'*?M'Je5=#' (K + 'Q78	c%j1n,$$hlJN%CD -/// 8 3u:>)j3w<!;K.K LL0M!AzA~67FF!AzA~67==r)   c                ~    X!   nX   u  pVX5US-    n[        U5      S:  a  [        U6 OUS   nUR                  U5      $ )z@Determine matches of a wildcard with sub-expression in `target`.r	   r   )r   r9   ry  )	r  wildcard_indr  r  wildcardr  r  r3  mults	            r*   r  Mul._matches_match_wilds  sN     &-
cAg&!%j1nsE{%(%%r)   c                N    X   nU  Vs/ s H  oAU   U:X  d  M  UPM     sn$ s  snf )z8Find other wildcards that may have already been matched.r   )r  r  r  ind_noder  s        r*   r  Mul._matches_get_other_nodes  s,     ?)Dz3Z8-CzDDDs   ""c                   SSK Jn  SSKJn  X:X  a  [        R
                  $ S nU" X5      (       d  U" X5      (       a  [        R
                  $ [        S X4 5       5      (       GaZ  U" S5      n[        R                  U0nU[        R                  0nU R                  U5      R                  5       nUR                  U5      R                  5       n	[        U	5      n
[        U	R                  5       5       HA  nX;   d  M
  X==   U	R                  U5      -  ss'   X   (       a  M0  UR                  U5        MC     [        U	5      U
:w  ax  [        UR                  5        VVs/ s H	  u  pX-  PM     snn6 R                  U5      n [        U	R                  5        VVs/ s H	  u  pX-  PM     snn6 R                  U5      nX-  nU" U5      nUR                   (       a  U$ U$ s  snnf s  snnf )z
Returns lhs/rhs, but treats arguments like symbols, so things
like oo/oo return 1 (instead of a nan) and ``I`` behaves like
a symbol instead of sqrt(-1).
r   )signsimpr	   )rS  c                    U R                   (       aB  UR                  (       a1  U R                  S5      UR                  5       R                  S5      :H  $ g)Nr   F)r   is_comparable__add__evalf)rj  r   s     r*   check#Mul._combine_inverse.<locals>.check  s8    zzaoo yy|qwwy'8'8';;;r)   c              3  ^   #    U  H#  oR                   =(       d    UR                  v   M%     g 7frI   )r   r$   rL   r   s     r*   rM   'Mul._combine_inverse.<locals>.<genexpr>  s     8Zxx#188#Z   +-I)sympy.simplify.simplifyr  rY  rS  r   r4   r   r   xreplaceas_powers_dictr   r  keysr   r9   rx   r%   )lhsrhsr  rS  r  r~   _ii_r>   r|   blenr   rf  vr   srvs                   r*   rx  Mul._combine_inverse  s{    	5!:55L	 ??eCoo55L8cZ888 c
A//1%BQ__%BR //1AR //1Aq6DAFFHo7EQUU2Y&E55b		 &
 1v~QWWY7YTQADY78AA"EQWWY7YTQADY78AA"EWrlmms++	 87s   "G#
G)
c                    [        [        5      nU R                   H6  nUR                  5       R	                  5        H  u  p4X==   U-  ss'   M     M8     U$ rI   )r   r\  r0   r  rx   )rQ   r~   rD  r|   r}   s        r*   r  Mul.as_powers_dict  sJ    IID++-335	 6  r)   c           	         [        [        U R                   Vs/ s H  oR                  5       PM     sn6 5      u  p#U R                  " U6 U R                  " U6 4$ s  snf rI   )r3   r^  r0   r   r!  )rQ   r   numersdenomss       r*   r   Mul.as_numer_denom  sR     c		#J	1$4$4$6	#JKLyy&!499f#555 $Ks   Ac                4   S n/ nSnU R                    Hr  nUR                  5       u  pVUR                  (       d  US-  nUc  UnO0Xa:w  d  US:  d  UR                  (       d  U [        R
                  4s  $ UR                  U5        Mt     U R                  " U6 U4$ )Nr   r	   )r0   r   r'   r   r   r4   r7   r!  )rQ   r   basesr   r   r|   r}   s          r*   r   Mul.as_base_exp  s    A==?DA##azBF!,,QUU{"LLO  yy% "$$r)   c                B   ^ [        U4S jU R                   5       5      $ )Nc              3  D   >#    U  H  oR                  T5      v   M     g 7frI   )_eval_is_polynomialrL   rD  symss     r*   rM   *Mul._eval_is_polynomial.<locals>.<genexpr>  s     Hid++D11i    allr0   rQ   r  s    `r*   r  Mul._eval_is_polynomial  s    HdiiHHHr)   c                B   ^ [        U4S jU R                   5       5      $ )Nc              3  D   >#    U  H  oR                  T5      v   M     g 7frI   )_eval_is_rational_functionr  s     r*   rM   1Mul._eval_is_rational_function.<locals>.<genexpr>  s     OYT22488Yr  r  r  s    `r*   r  Mul._eval_is_rational_function  s    OTYYOOOr)   c                D   ^^ [        UU4S jU R                   5       SS9$ )Nc              3  F   >#    U  H  oR                  TT5      v   M     g 7frI   )is_meromorphic)rL   rg  r>   r  s     r*   rM   +Mul._eval_is_meromorphic.<locals>.<genexpr>  s     K#//155s   !T
quick_exitr   r0   )rQ   r  r>   s    ``r*   _eval_is_meromorphicMul._eval_is_meromorphic  s    KK'+- 	-r)   c                B   ^ [        U4S jU R                   5       5      $ )Nc              3  D   >#    U  H  oR                  T5      v   M     g 7frI   )_eval_is_algebraic_exprr  s     r*   rM   .Mul._eval_is_algebraic_expr.<locals>.<genexpr>  s     L)$//55)r  r  r  s    `r*   r  Mul._eval_is_algebraic_expr  s    L$))LLLr)   c                :    [        S U R                   5       5      $ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )r'   rK   s     r*   rM   Mul.<lambda>.<locals>.<genexpr>  s      5-"+Q)rO   r  r[   s    r*   r  Mul.<lambda>  s     5-"&))5- )-r)   c                    [        S U R                   5       5      nUSL aD  [        S U R                   5       5      (       a#  [        S U R                   5       5      (       a  g gU$ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )
is_complexrK   s     r*   rM   'Mul._eval_is_complex.<locals>.<genexpr>  s     <)QLL)rO   Fc              3  8   #    U  H  oR                   v   M     g 7frI   )is_infiniterK   s     r*   rM   r  
  s     4)Q==)rO   c              3  <   #    U  H  oR                   S Lv   M     g7fr   r   rK   s     r*   rM   r    s     Ay!yy-y   )r   r0   r   )rQ   comps     r*   _eval_is_complexMul._eval_is_complex  sR    <$))<<5=4$))444AtyyAAAr)   c                   S=pU R                    Hu  nUR                  (       a  USLa    gSnM  UR                  (       a  USLa    gSnM;  USL a  UR                  c	  USLa    gS nUSL d  M]  UR                  b  Ml  USLa    gS nMw     X4$ )NF)NNT)r0   r   r	  )rQ   	seen_zeroseen_infiniter>   s       r*   _eval_is_zero_infinite_helper!Mul._eval_is_zero_infinite_helper  s    X %*)	Ayy -% 	E)% $%!))*;$E1) $I E)amm.C -)$(M# & ''r)   c                J    U R                  5       u  pUSL a  gUSL a  USL a  gg NFTr  rQ   r  r  s      r*   _eval_is_zeroMul._eval_is_zeroS  s5     $(#E#E#G 	$=E#9r)   c                J    U R                  5       u  pUSL a  USL a  gUSL a  gg )NTFr  r  s      r*   _eval_is_infiniteMul._eval_is_infinite_  s5     $(#E#E#G 	D Y%%7e#r)   c                    [        S U R                   5       SS9nU(       a  U$ USL a#  [        S U R                   5       5      (       a  gg g )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )is_rationalrK   s     r*   rM   (Mul._eval_is_rational.<locals>.<genexpr>o  s     ;A--rO   Tr  Fc              3  <   #    U  H  oR                   S L v   M     g7fr   r  rK   s     r*   rM   r!  t       9y!99%yr  r   r0   r  rQ   r   s     r*   _eval_is_rationalMul._eval_is_rationaln  sI    ;;MH%Z9tyy999 : r)   c                    [        S U R                   5       SS9nU(       a  U$ USL a#  [        S U R                   5       5      (       a  gg g )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )is_algebraicrK   s     r*   rM   )Mul._eval_is_algebraic.<locals>.<genexpr>x  s     <)Q..)rO   Tr  Fc              3  <   #    U  H  oR                   S L v   M     g7fr   r  rK   s     r*   rM   r+  }  r#  r  r$  r%  s     r*   _eval_is_algebraicMul._eval_is_algebraicw  sI    <$))<NH%Z9tyy999 : r)   c                `  ^ U R                  5       nUSL a  g/ n/ nSnU R                   GH  nSnUR                  (       a1  [        U5      [        R
                  La  UR                  U5        MF  MH  UR                  (       ag  UR                  5       u  px[        U5      [        R
                  La  UR                  U5        U[        R
                  La  UR                  U5        M  M  UR                  (       a  UR                  5       u  pU	R                  (       a  U
R                  (       d  S=pdU
R                  (       aA  UR                  U[        R                  L a  SO[        U[        R                  5      5        GMZ  U(       d(  U
R                  (       a   eU
R                   (       a   e  g   g   g    U(       d  U(       d  gS nS nS nSSKJm  U(       d"  U(       a  ['        U4S	 jU 5       5      (       a  gU(       a  g U" U5      (       a  U" U5      (       a  gU" U5      (       a  US/:X  a  gU" U5      (       a+  U" U5      (       a  [)        US
S06S-
  R                  (       a  g[+        U5      S:X  a  US   nUR,                  (       at  UR.                  (       ac  [1        U Vs/ s H)  nUR.                  (       d  M  UR                  5       S   PM+     sn6 [3        UR4                  5      -
  R6                  (       a  g[+        U5      S:X  a  US   nUR,                  (       av  UR.                  (       ad  [1        U Vs/ s H)  nUR.                  (       d  M  UR                  5       S   PM+     sn6 [3        UR4                  5      -
  R                  (       a  gg g g g s  snf s  snf )NFTrl   c                &    [        S U  5       5      $ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )is_oddr  s     r*   rM   9Mul._eval_is_integer.<locals>.<lambda>.<locals>.<genexpr>  s     3AxxrO   r  r  s    r*   r  &Mul._eval_is_integer.<locals>.<lambda>  s    3333r)   c                &    [        S U  5       5      $ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   is_evenr  s     r*   rM   r3         51a		1rO   r4  r5  s    r*   r  r6        C5155r)   c                &    [        S U  5       5      $ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   r9  r  s     r*   rM   r3    r;  rO   )r   r5  s    r*   r  r6    r<  r)   r	   )is_gtc              3  R   >#    U  H  nT" U[         R                  5      v   M     g 7frI   )r   r4   )rL   rr   r?  s     r*   rM   'Mul._eval_is_integer.<locals>.<genexpr>  s       37)5Aa   $'rU   r   )r&  r0   r   r   r   r4   r7   r   r   r   r   r   r   r   rf   r   r   
relationalr?  r  r9   r   r   r:  ry   r   r   is_nonnegative)rQ   r   
numeratorsdenominatorsunknownr>   hitr   r~   r|   r}   alloddallevenanyevenr   r?  s                  @r*   _eval_is_integerMul._eval_is_integer  s   ,,.%
AC||q6&%%a( ''')q6&%%a(AEE> ''* "}}||1<<$((C== ''Q!&&[Aq}}-/ }},, yy(= 9 < G355%ls 37)537 07 07JGL$9$9Z  \aS%8Z  VL & &L959A=+|!QA||		 "1" 23&'ii -!--/!,"1 24<QSSMB(.)  z?a1A||		 $3$ 23()		 -!--/!,$3 46>qssmD%+& !& !*|  	13s   /N&N&N+!N+c                    [        S U R                   5       5      nU=(       a    [        S U R                   5       5      $ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )is_polarrL   rg  s     r*   rM   %Mul._eval_is_polar.<locals>.<genexpr>  s     :		rO   c              3  ^   #    U  H#  oR                   =(       d    UR                  v   M%     g 7frI   )rP  r   rQ  s     r*   rM   rR    s     E9C//9r  )r   r0   r  )rQ   	has_polars     r*   _eval_is_polarMul._eval_is_polar  s7    :		::	 FE499EE	Fr)   c                $    U R                  S5      $ NT)_eval_real_imagr[   s    r*   _eval_is_extended_realMul._eval_is_extended_real  s    ##D))r)   c                   SnS nU R                    H  nUR                  =(       d    UR                  SL a  UR                  SL a    gUR                  (       a	  U(       + nMP  UR                  (       aS  U(       dJ  UR
                  nU(       d	  USL a  UnM  U(       a%  [        S U R                    5       5      (       a    g  g M  M  UR                  SL a  U(       a    g UnM  UR                  SL a  U(       a    g UnM    g    U(       a2  UR                  SL a	  U(       a  U$ UR                  SL a
  U(       d  U$ g g USL a  U$ U(       a  U$ g )NFc              3  8   #    U  H  oR                   v   M     g 7frI   r   rK   s     r*   rM   &Mul._eval_real_imag.<locals>.<genexpr>  s     >Iq{{IrO   T)r0   r  r	  r   r   r   r  )rQ   realzerot_not_re_imr   zs         r*   rY  Mul._eval_real_imag  s$   A-%7A<N<NRW<Wx##		A >DII>>>#' 	  ##u,5(1 4 ++u4K''50K  1 U]KK r)   c                h    [        S U R                   5       5      (       a  U R                  S5      $ g )Nc              3  b   #    U  H%  oR                   S L =(       a    UR                  v   M'     g7fr   )r   r   rK   s     r*   rM   )Mul._eval_is_imaginary.<locals>.<genexpr>  s#     E9ayyE!1akk19s   -/F)r  r0   rY  r[   s    r*   _eval_is_imaginaryMul._eval_is_imaginary  s.    E499EEE''.. Fr)   c                $    U R                  S5      $ rX  _eval_herm_antihermr[   s    r*   _eval_is_hermitianMul._eval_is_hermitian  s    ''--r)   c                $    U R                  S5      $ NFrj  r[   s    r*   _eval_is_antihermitianMul._eval_is_antihermitian
  s    ''..r)   c                   U R                    HL  nUR                  b  UR                  c    g UR                  (       a  M2  UR                  (       a	  U(       + nML    g    USLa  U$ U R                  5       nU(       a  gUSL a  U$ g r  )r0   is_hermitianis_antihermitianr  )rQ   hermr   r   s       r*   rk  Mul._eval_herm_antiherm  sz    A~~%););)C~~##x  uK$$&K r)   c                    U R                    H\  nUR                  nU(       aA  [        U R                   5      nUR                  U5        [	        S U 5       5      (       a    g  g Ub  M\    g    [	        S U R                    5       5      (       a  gg )Nc              3  t   #    U  H.  oR                   =(       a    [        UR                  5      S L v   M0     g7f)TN)r   r   r   rL   r  s     r*   rM   *Mul._eval_is_irrational.<locals>.<genexpr>'  s'     XQWA>)AII*>4GQWs   68Tc              3  8   #    U  H  oR                   v   M     g 7frI   )is_realry  s     r*   rM   rz  ,  s     ,)Qyy)rO   F)r0   is_irrationalr3   remover  )rQ   r   r>   otherss       r*   _eval_is_irrationalMul._eval_is_irrational!  st    AAdiia XQWXXXy  ,$)),,, -r)   c                $    U R                  S5      $ )a3  Return True if self is positive, False if not, and None if it
cannot be determined.

Explanation
===========

This algorithm is non-recursive and works by keeping track of the
sign which changes when a negative or nonpositive is encountered.
Whether a nonpositive or nonnegative is seen is also tracked since
the presence of these makes it impossible to return True, but
possible to return False if the end result is nonpositive. e.g.

    pos * neg * nonpositive -> pos or zero -> None is returned
    pos * neg * nonnegative -> neg or zero -> False is returned
r	   _eval_pos_negr[   s    r*   _eval_is_extended_positiveMul._eval_is_extended_positive/  s      !!!$$r)   c                   S=p#U R                    H  nUR                  (       a  M  UR                  (       a  U* nM,  UR                  (       a%  [	        S U R                    5       5      (       a    g  g UR
                  (       a  U* nSnMz  UR                  (       a  SnM  UR                  SL a  U* nU(       a    g SnM  UR                  SL a  U(       a    g SnM    g    US:X  a  USL a  USL a  gUS:  a  gg )NFc              3  8   #    U  H  oR                   v   M     g 7frI   r   rK   s     r*   rM   $Mul._eval_pos_neg.<locals>.<genexpr>I  s     6Iq{{IrO   Tr	   r   )	r0   r   r^   r   r  is_extended_nonpositiveis_extended_nonnegativer   r   )rQ   r   saw_NONsaw_NOTr   s        r*   r  Mul._eval_pos_negA  s    !!A%%''u6DII666 **u** %'u%'7 8 19E)g.>!8 r)   c                $    U R                  S5      $ r   r  r[   s    r*   _eval_is_extended_negativeMul._eval_is_extended_negatived  s    !!"%%r)   c                   U R                  5       nUSLa  U$ SSKJn  U" U 5      u  p4UR                  (       a  UR                  (       aw  [        [        R                  U5       Vs/ s H)  nUR                  (       d  M  UR                  5       S   PM+     sn6 [        UR                  5      -
  R                  (       a  gg Su  pgU R                   Hg  n[        U5      [        R                  L a  M!  UR                  (       a    gUSL a  O+US:w  a  Xx-   R                   (       a  SnOUR                  c  S nUnMi     U$ s  snf )NTr   r9  r	   F)Tr	   )rL  r>  r:  r   r:  ry   r9   rn   r   r   r   r   r0   r   r   r4   r2  )	rQ   r   r:  r   r~   r   r   accr   s	            r*   _eval_is_oddMul._eval_is_oddg  s   **,
T!3~<<AII MM!$3$ ./()		 )ammoa($3 46>qssmD!k" A1vyyEzsw.."C  %3s   &D>?D>c                b   SSK Jn  U" U 5      u  p#UR                  (       a  UR                  (       aw  [	        [
        R                  U5       Vs/ s H)  nUR                  (       d  M  UR                  5       S   PM+     sn6 [        UR                  5      -
  R                  (       a  gg g g s  snf )Nr   r9  r	   F)r>  r:  r   r:  ry   r9   rn   r   r   r   rD  )rQ   r:  r   r~   r   s        r*   _eval_is_evenMul._eval_is_even  s    3~<<AII MM!$3$ ./()		 )ammoa($3 46>qssmD$n% %	 &<3s   B,(B,c                    SnU R                    HB  nUR                  (       a  UR                  (       d    gUS-
  R                  (       d  M=  US-  nMD     US:  a  gg)z
Here we count the number of arguments that have a minimum value
greater than two.
If there are more than one of such a symbol then the result is composite.
Else, the result cannot be determined.
r   Nr	   T)r0   r   r   )rQ   number_of_argsrg  s      r*   _eval_is_compositeMul._eval_is_composite  sS     99CNNsA"""!#	  A r)   c           	       ^(^)^*^+^, SSK Jm,  SSKJn  SSKJm+  SSKJn  UR                  (       d  g UR                  S   R                  (       aY  UR                  S   S:  aF  U R                  S   R                  (       a(  U R                  S   S:  a  U R                  U* U* 5      $ g S m(U(U+4S jnU(4S jnS	 nS nU" U 5      u  pU nU
[        R                  LaL  U	R                  X5      U
R                  X5      -  nUR                  (       d  UR                  X5      $ X:w  a  UnUR                  S   nUR                  S   nS nUR                  (       a(  UR                  (       a  X:w  a  UR                  U5      nOUR                  (       a  U$ U" U5      u  m)nU" U5      u  m*nU(       am  UR                  (       a\  [!        U5      S
:w  aM  [        U" [!        U5      U5      5      nT)R#                  U5        UT);   a  T)U==   U-  ss'   OUT)U'   XU-  -  nOS
nSn[%        U5      [%        U5      :  a  SnO[%        T*5      [%        T)5      :  a  SnOU Vs1 s H  nUS   iM
     snR'                  U Vs1 s H  nUS   iM
     sn5      (       a  SnOI[)        T*5      R'                  [)        T)5      5      (       a  SnO[+        U)U*U,4S jT* 5       5      (       a  SnU(       d  U$ T*(       d  S nOR/ nT*R-                  5        H1  u  nnT)U   nUR/                  U" UU5      5        US   (       a  M/  Us  $    [1        U5      nU(       d*  S n[3        [%        U5      5       H  nU" UU   6 UU'   M     GOSn[%        U5      nU=(       d    [        R4                  n/ nSnU(       Ga  UU-   [%        U5      ::  Ga  Sn/ n[3        U5       H  nUUU-      S   UU   S   :w  a    GOUS:X  a(  UR/                  U" UUU-      S
   UU   S
   5      5        OZUUS
-
  :X  a(  UR/                  U" UUU-      S
   UU   S
   5      5        O)UUU-      S
   UU   S
   :w  a    GOUR/                  S
5        US
-  nM     [1        U5      n U (       a  US
:X  aE  U(       a  [1        UU 5      n [7        UU 5      U" UU   S   UU   S
   U US   S
   -  -
  5      -  UU'   OS
n U" UU   S   UU   S
   U US   S
   -  -
  5      n!Un"UU-   S
-
  n#UU#   S   UU#   S
   U US   S
   -  -
  4n$U$S
   (       a5  UU-   [%        U5      :  a  U!U"-  U$/UUUU-   & O!U" U$6 n$U!U"-  U$-  /UUUU-   & OU!U"-  /UUUU-   & UU -  nUU -  nSnU(       d  UR/                  U5        US
-  nU(       a  UU-   [%        U5      ::  a  GM  U(       d  U$ UR9                  [3        U[%        U5      5      5        U H  nU" UU   6 R;                  X5      UU'   M     Uc  Un%OUc  Un%O[1        UU5      n%/ n&T) H[  nUT*;   a(  T)U   T*U   U%-  -
  n'U&R/                  U" UU'5      5        M1  U&R/                  U" UR;                  X5      T)U   5      5        M]     U(       a  U(       d  [7        UU5      /U&-   n&UUR<                  " U&6 -  UR<                  " U6 -  $ s  snf s  snf )Nr   r   )multiplicity)	powdenestr9  c                    SSK Jn  U R                  (       d  [        X5      (       a  U R	                  5       $ U [
        R                  4$ )Nr   )r  )&sympy.functions.elementary.exponentialr  r   r   r   r   r4   )r>   r  s     r*   base_exp Mul._eval_subs.<locals>.base_exp  s2     Cxx:a--}}&aee8Or)   c                R  > [        [        5      / p![        R                  U 5       H{  nT	" U5      nT" U5      u  pEU[        R
                  La"  UR                  5       u  pg[        XEU-  5      nUnUR                  (       a  X==   U-  ss'   Mi  UR                  XE/5        M}     X4$ )zbreak up powers of eq when treated as a Mul:
   b**(Rational*e) -> b**e, Rational
commutatives come back as a dictionary {b**e: Rational}
noncommutatives come back as a list [(b**e, Rational)]
)
r   r\  r9   rn   r   r4   rd   r   r'   r7   )
eqr_   r   r>   r|   r}   r=   rr   r  r  s
           r*   breakupMul._eval_subs.<locals>.breakup  s     #3']]2&aL!!AEE>nn.GRAtAA##DAIDIIqf% ' 7Nr)   c                4   > T" U 5      u  p[        XU-  5      $ )z
Put rational back with exponent; in general this is not ok, but
since we took it from the exponent for analysis, it's ok to put
it back.
r   )r|   r=   r}   r  s      r*   rejoinMul._eval_subs.<locals>.rejoin  s     a[FQqB$<r)   c                    UR                   U R                   -  (       a  U R                   UR                   -  (       d  [        X-  5      $ g)zif b divides a in an extractive way (like 1/4 divides 1/2
but not vice versa, and 2/5 does not divide 1/3) then return
the integer number of times it divides, else return 0.
r   )r   r\  )r>   r|   s     r*   ndivMul._eval_subs.<locals>.ndiv  s/    
 339ACC!##I13xr)   r	   TFc              3  R   >#    U  H  nT" TU   5      T" TU   5      :g  v   M     g 7frI   r   )rL   r|   r_   old_cr   s     r*   rM   !Mul._eval_subs.<locals>.<genexpr>$  s&     =u!adtE!H~-urB  r   )r   r   sympy.ntheory.factor_r  sympy.simplify.powsimpr  r>  r:  r$   r0   r%   _subsr   r4   r   extract_multiplicativelyr   r   r   
differencesetr   rx   r7   minr   rp   r   r6   rp  r!  )-rQ   r  newr  r:  r  r  r  r   r   r~   self2co_selfco_oldco_xmulr   old_ncr  co_residualokr   cdidratr|   old_ec_encdidtakelimitfailedrH  r   ndorj  midirr   domargsr}   r  r_   r  r  r   s-                                           @@@@@r*   
_eval_subsMul._eval_subs  s   =643zz 88A;  SXXa[1_yy|%%99Q<!#::sdSD11		*	 	 ~AEE>GGC%aggc&77E<<{{3,,} **Q-!'"5"5  !::6BI %.B!#, w**s6{a/?\#f+w78DEE'N{&	T!	 &	!$,.KK v;R BZ#a& B"#FqadF#..b/Ab!b/ABBBZ""3q6**B=u===BIDC#kkm
Ed

4U+,2wwI	 ,
 s8DE3r7^11 $ Ev;D&AJJEFAAHB/ tA!a%y|vay|3a

41q5	!fQil#CDdQh

41q5	!fQil#CDAE115

1FA % c(C19#&)$n$'SM&Aq$&qE!Hs6!9Q</?$?3A %ABqE #$C !'r!uQxAqC$*1IaL=1 21 !2A
 #&C "#TAB!#BBrF1I!'A9/ -/ !0A t#$t8c"g#567eQZBqTN(.
A67eAgYBqTN
 34C%1QX" MM!$QC AHB/H I eAs2w/0A"BqEN//9BqE  
 <B]BUD!BAEz aD58B;&VAq\*VAFF3$4ad;<   d^$u,E5::u--ejj"o==U $/As   Z8:Z=c                  ^  SSK Jn  SSKJn  SSKJn  S n/ n	 U R                   HD  n
U
R                  U5      u  pUR                  U5      (       d  U	R                  X45        M@  [        e   [        S U	 5       5      n/ nU	 Hh  u  pU" X--
  UR                  (       a  UOS-   5      nU
R                  UUX4S9nUR                  5       nUb  UU:  a  UUU-
  -  nUR                  U5        Mj     [&        R(                  nU Vs/ s H  n[2        R4                  " U5      PM     nn[7        U6  HY  nU Vs/ s H  nU" UU5      PM     nn[9        U6 u  nn[        U5      nUU-
  R:                  (       d  MH  U[=        U6 UU-  -  -  nM[     U 4S jm U R?                  U5      (       a<  SSK J!n  SSK"J#n   T " X5      U:  d  U" X5      U" UU5      :w  a  UU" X-  U5      -  nU$ UU :w  aa  U U-
  RI                  US5      [&        R(                  :X  a,  US:  a&  U RK                  XUS9nU[&        R(                  :X  a  U$ UU" X-  U5      -  nU$ ! [        [        [         U4 a    [#        [        S	 U	 5       5      5      nUR$                  (       a  [&        R(                  nU R                   V
s/ s H  oR                  X" X--
  5      X4S9PM     Os  sn
f nn
SS
KJn  U" U R.                  " U6 R1                  5       SSS9nUR                  U5      (       a  UU" X-  U5      -  nUs $ f = fs  snf s  snf ! U a     GNZf = f)Nr	   )	PoleErrorr   )ceiling)Orderc                    U R                  U5      nUS   R                  U5      (       a   U R                  U5      nU$ U$ ! [         a    U [        R
                  4s $ f = frc   )as_coeff_exponentr  leadterm
ValueErrorr   r   )rD  r  lts      r*   	coeff_exp$Mul._eval_nseries.<locals>.coeff_exp  s`    ''*B!uyy||(q)B I2I " (<'(s   A A A c              3  V   #    U  H  oS    R                   (       d  M  US    v   M!     g7fr	   Nr   rL   r   s     r*   rM   $Mul._eval_nseries.<locals>.<genexpr>  s     :4aQ4>>TQqT4   )))r   logxcdirc              3  V   #    U  H  oS    R                   (       d  M  US    v   M!     g7fr  r  r  s     r*   rM   r    s     B4aQ4>>TQqT4r  )powsimpr  T)combiner  c           	       >^ U TL a  [         R                  $ U R                  (       a  [         R                  $ U R                  (       a   [        UU4S jU R                   5       5      $ U R                  (       a*  [        U R                   Vs/ s H  nT" UT5      PM     sn6 $ U R                  (       a   T" U R                  T5      U R                  -  $ [         R                  $ s  snf )Nc              3  6   >#    U  H  nT" UT5      v   M     g 7frI   r   )rL   r>   
max_degreer  s     r*   rM   8Mul._eval_nseries.<locals>.max_degree.<locals>.<genexpr>  s     <V:a++Vs   )r   r4   is_Atomr   r   maxr0   r$   ry   r   r  r  )r}   r  r>   r  s    ` r*   r  %Mul._eval_nseries.<locals>.max_degree  s    Avuuyyvvxx<QVV<<<xxqvv>v!Z1-v>??xx!!&&!,QUU2266M ?s   C&)PolynomialError)degreer  r  )&r#  r  #sympy.functions.elementary.integersr  sympy.series.orderr  r0   r  r  r7   r  rb  r   nseriesgetnNotImplementedError	TypeErrorr
   rD  r   r   r  r  r!  r   ry   rn   r   r^  r   r9   is_polynomialsympy.polys.polyerrorsr  sympy.polys.polytoolsr  rp  _eval_as_leading_term)!rQ   r  r   r  r  r  r  r  r  ordsr   r   r  n0facsr   n1rL  nsr  resrC  ords2facrD  ords3coeffspowerspowerr  r  r  r  s!                                   @r*   _eval_nseriesMul._eval_nseries  s   '?,	 	YYZZ]
yy||KK)$$  :4::BDQVAKKqQ?@IIa2DI<VVX>BwR"WA . ff59:T6v&T:E?C478CDYtQ'CE8 %[NFFKE	&&&sF|QX.. #	 a  >4d&!+vd&a./P5q>)C 
$;s
  A&!&&0QU//4/H<J5q>!C
m /IF 	 B4BBCB  VVQUQZQZ[QZAIIa714=tIGQZ[D[6$))T*113UNCwwu~~uQT1~%J	 ; 92 # s>   CI  L*5L/4-L4 A L',!KAL'&L'4L>=L>c                z    U R                   " U R                   Vs/ s H  oDR                  XUS9PM     sn6 $ s  snf )Nr  )r!  r0   as_leading_term)rQ   r  r  r  r   s        r*   r  Mul._eval_as_leading_term  s5    yytyyYy!,,Q,EyYZZY   8c                z    U R                   " U R                   Vs/ s H  oR                  5       PM     sn6 $ s  snf rI   )r!  r0   r  rQ   r   s     r*   _eval_conjugateMul._eval_conjugate  s+    yy$))<)Q;;=)<==<r  c                    U R                   " U R                  S S S2    Vs/ s H  oR                  5       PM     sn6 $ s  snf r   )r!  r0   	transposer  s     r*   _eval_transposeMul._eval_transpose  s3    yy$))DbD/B/Q;;=/BCCB   >c                    U R                   " U R                  S S S2    Vs/ s H  oR                  5       PM     sn6 $ s  snf r   )r!  r0   adjointr  s     r*   _eval_adjointMul._eval_adjoint  s3    yy		$B$@199;@AA@r  c                    [         R                  n/ nU R                   H>  nUR                  XS9u  pgX6-  nU[         R                  Ld  M-  UR	                  U5        M@     X0R
                  " U6 4$ )a  Return the tuple (R, self/R) where R is the positive Rational
extracted from self.

Examples
========

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

See docstring of Expr.as_content_primitive for more examples.
)radicalclear)r   r4   r0   as_content_primitiver7   r!  )rQ   r  r  coefr0   r>   r_   r   s           r*   r  Mul.as_content_primitive  sf     uuA))')GDAID~A	  YY%%%r)   c                V   ^ U R                  5       u  p#UR                  U4S jS9  X#-   $ )zTransform an expression into an ordered list of factors.

Examples
========

>>> from sympy import sin, cos
>>> from sympy.abc import x, y

>>> (2*x*y*sin(x)*cos(x)).as_ordered_factors()
[2, x, y, sin(x), cos(x)]

c                "   > U R                  TS9$ )N)order)sort_key)r@  r!  s    r*   r  (Mul.as_ordered_factors.<locals>.<lambda>9  s    DMMM$>r)   r,   )r5   r.   )rQ   r!  cpartncparts    `  r*   as_ordered_factorsMul.as_ordered_factors+  s)     

>
?~r)   c                4    [        U R                  5       5      $ rI   )r  r&  r[   s    r*   _sorted_argsMul._sorted_args<  s    T,,.//r)   )r0   zExpr | complexrU   boolreturnr   )r,  ztuple[Expr, ...])F)Tro  rI   )r   )FT)Ur   r    r!   r"   __doc__	__slots__r$   r   
_args_typer   rP   __annotations__propertyrJ   r   rX   r0   r`   rg   classmethodr   r   r   r   r  r   r  rd   rv   r   staticmethodr0  r?  rM  r[  ru  r|  ry  r  r  r  r  r  r  rx  r  r   r   r  r  r  r  _eval_is_commutativer  r  r  r  r&  r-  rL  rU  rZ  rY  rg  rl  rp  rk  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r&  r)  r(   __classcell__)rk  s   @r*   r9   r9   [   s   DJ IFJ%&;N1 1 ?C 	 
	 
	6: Q. Q.f8 " "  6 6 9 9< +/ 
 
 5:n $ $$)V 	# 	#  >!@   ( (T < < 2 2h & & E E
 ', ',R6%IP-M-A(F

L!\F
*(T/./(%$!F&<
"F>PYv[>DB&4" 0 0r)   r9   mulc                6    [        [        R                  X5      $ )aK  Return product of elements of a. Start with int 1 so if only
   ints are included then an int result is returned.

Examples
========

>>> from sympy import prod, S
>>> prod(range(3))
0
>>> type(_) is int
True
>>> prod([S(2), 3])
6
>>> _.is_Integer
True

You can start the product at something other than 1:

>>> prod([1, 2], 3)
6

)r   operatorr6  )r>   starts     r*   rc  rc  C  s    . (,,))r)   c           
     h   U R                   (       d  UR                   (       a  XpOX-  $ U[        R                  L a  U $ U [        R                  L a  U$ U [        R                  L a
  U(       d  U* $ UR                  (       a  U(       d  U R
                  (       a  U R                  S:w  a  UR                   Vs/ s H  oDR                  5       PM     nnU VVs/ s H  u  pg[        X`5      U4PM     nnn[        S U 5       5      (       aH  [        R                  " U Vs/ s H&  n[        R                  US   S:X  a  USS OU5      PM(     sn5      $ [        XSS9$ UR                  (       ax  [        UR                  5      nUS   R                   (       a(  US==   U -  ss'   US   S:X  a  UR!                  S5        OUR#                  SU 5        [        R                  U5      $ X-  nUR                   (       a'  UR                   (       d  [        R                  X45      nU$ s  snf s  snnf s  snf )a  Return ``coeff*factors`` unevaluated if necessary.

If ``clear`` is False, do not keep the coefficient as a factor
if it can be distributed on a single factor such that one or
more terms will still have integer coefficients.

If ``sign`` is True, allow a coefficient of -1 to remain factored out.

Examples
========

>>> from sympy.core.mul import _keep_coeff
>>> from sympy.abc import x, y
>>> from sympy import S

>>> _keep_coeff(S.Half, x + 2)
(x + 2)/2
>>> _keep_coeff(S.Half, x + 2, clear=False)
x/2 + 1
>>> _keep_coeff(S.Half, (x + 2)*y, clear=False)
y*(x + 2)/2
>>> _keep_coeff(S(-1), x + y)
-x - y
>>> _keep_coeff(S(-1), x + y, sign=True)
-(x + y)
r	   c              3  >   #    U  H  u  pUR                   v   M     g 7frI   )r   )rL   r_   rr   s      r*   rM   _keep_coeff.<locals>.<genexpr>  s     1DDA1<<Dr   r   NFrT   )r%   r   r4   rf   r   r   r   r0   rv   r   r   ry   r:   r9   r$   r3   r   r8   )	r   factorsr  r   r   r0   r_   r   r  s	            r*   r   r   ]  s   6 ??"U= !%%~	!--	x	**uww!|.5ll;lNN$lD;;?@441[*A.4D@1D111~~8<'>8<1 (+~~qTQYAabEA(/8<'> ? ?5E22	W\\"8!HHQx1}		!LLE"~~e$$M;;w00/0A' <@'>s   8H$H)-H/c                    S n[        X5      $ )Nc                    U R                   (       aY  U R                  5       u  pUR                  (       a6  UR                  (       a%  [	        UR
                   Vs/ s H  o1U-  PM	     sn6 $ U $ s  snf rI   )r$   rv   r%   r   _unevaluated_Addr0   )r}   r_   r   ris       r*   r  expand_2arg.<locals>.do  sO    88>>#DA{{qxx')@2B$)@AA *As   A-r   )r}   r  s     r*   expand_2argrC    s     Qr)   )r   r  )ry   r@  )r	   )TF)6
__future__r   typingr   r   collectionsr   	functoolsr   	itertoolsr   r8  r
   basicr   r   	singletonr   
operationsr   r   cacher   intfuncr   r   logicr   r   r@  r   
parametersr   rJ   r   	traversalr   sympy.utilities.iterablesr   r   r1   rA   r9   r6  rc  r   rC  r   r   r  r   addry   r@  r   r)   r*   <module>rS     s    " * #     '  2  . *  )     *
 !
1(hc0$ c0J? *4;z   & &r)   