Ë
    7^(ha5 ã                  ór  — 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
 d dlZddlmZ dd	l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mZ ddlmZmZ ddlmZ ddlm Z  ddl!m"Z" ddl#m$Z$ d dl%m&Z&  G d„ d«      Z'd„ Z(d„ Z) G d„ dee«      Z* ed«      Z+d!d„Z,d"d„Z-d„ Z.ddl/m0Z0 ddl1m2Z2 dd l3m4Z4m5Z5 y)#é    )Ú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                  ó    — e Zd ZdZdZdZdZdZy)Ú	NC_MarkerFN)Ú__name__Ú
__module__Ú__qualname__Úis_OrderÚis_MulÚ	is_NumberÚis_PolyÚis_commutative© ó    úL/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/core/mul.pyr   r      s   „ Ø€HØ€FØ€IØ€Gà�Nr&   r   c                ó0   — | j                  t        ¬«       y )N©Úkey)Úsortr   ©Úargss    r'   Ú_mulsortr.   "   s   € à‡I�I”-€IÕ r&   c                 óâ  — g }g }t        | «      } t        j                  }| D ]…  }|j                  r6|j	                  «       \  }}| j                  |«       |j                  |«       ŒE|j                  r||z  }ŒW|j                  r|j                  |«       Œu|j                  |«       Œ‡ t        |«       |t        j                  ur|j                  d|«       t        j                  ||z   «      S )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$   Úappendr.   ÚinsertÚMulÚ
_from_args)r-   ÚcargsÚncargsÚcoÚaÚa_cÚa_ncs          r'   Ú_unevaluated_Mulr>   '   sÂ   € ð> €EØ€FÜ�‹:€DÜ	
�‰€BØò 
ˆØ�8Š8ØŸ
™
›‰IˆC�Ø�K‰K˜ÔØ�M‰M˜$ÕØ�[Š[Ø�!‰G‰BØ×ÒØ�L‰L˜�Oà�M‰M˜!Õð
ô ˆU„OØ	”—‘�Ø�‰�Q˜ÔÜ�>‰>˜% ™,Ó'Ð'r&   c                  óª  ‡ — e Zd ZU dZdZdZeZ edd¬«      Z	de
d<   ed„ «       Zerdd	œdLd
„ZedMd„«       Zd„ Zd„ Zed„ «       Zd„ Zed„ «       Zd„ Zed„ «       Zed„ «       Zeddœd„«       ZdNd„ZdOd„Zed„ «       Zd„ Zed„ «       Z eˆ fd„«       Z!d„ Z"d„ Z#dPd„Z$ed„ «       Z%edQd „«       Z&ed!„ «       Z'ed"„ «       Z(ed#„ «       Z)ed$„ «       Z*ed%„ «       Z+d&„ Z,d'„ Z-d(„ Z.d)„ Z/d*„ Z0d+„ Z1d,„ Z2d-„ Z3d.„ Z4d/„ Z5d0„ Z6d1„ Z7d2„ Z8d3„ Z9d4„ Z:d5„ Z;d6„ Z<d7„ Z=d8„ Z>d9„ Z?d:„ Z@d;„ ZAd<„ ZBd=„ ZCd>„ ZDd?„ ZEd@„ ZFdA„ ZGdB„ ZHdC„ ZIdRdD„ZJdE„ ZKdF„ ZLdG„ ZMdH„ ZNdSdI„ZOdQdJ„ZPedK„ «       ZQˆ xZRS )Tr6   aB  
    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   — d„ | j                   D «       } | j                  |Ž S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­w©N)Úkind©Ú.0r;   s     r'   ú	<genexpr>zMul.kind.<locals>.<genexpr>¬   s   è ø€ Ò/ �Q—V•VÑ/ùó   ‚)r-   Ú_kind_dispatcher)ÚselfÚ	arg_kindss     r'   rF   zMul.kindª   s#   € á/ T§Y¡YÔ/ˆ	Ø$ˆt×$Ñ$ iÐ0Ð0r&   ©Úevaluatec                ó   — y rE   r%   )ÚclsrO   r-   s      r'   Ú__new__zMul.__new__±   s   € Ør&   c                 ó   — y rE   r%   ©rL   s    r'   r-   zMul.args´   s   € àr&   c                ób   — | |  k(  ry| j                   d   }|j                  xr |j                  S )NFr   )r-   r"   Úis_extended_negative)rL   Úcs     r'   Úcould_extract_minus_signzMul.could_extract_minus_sign¸   s0   € Ø�T�EŠ?ØØ�I‰I�a‰LˆØ�{‰{Ò5˜q×5Ñ5Ð5r&   c                óH  — | j                  «       \  }}|d   t        j                  ur| }|t        j                  urJ|d   j                  r5t        |«      }|t        j                  u r
|d    |d<   n|dxx   |z  cc<   n|f|z   }| j                  || j                  «      S ©Nr   )	Úas_coeff_mulr   ÚComplexInfinityr1   r"   r0   ÚNegativeOner7   r$   )rL   rW   r-   s      r'   Ú__neg__zMul.__neg__¾   s˜   € Ø×#Ñ#Ó%‰ˆˆ4Ø�‰7œ!×+Ñ+Ñ+Ø�ˆAØ”A—E‘E‰>Ø�A‰w× Ò Ü˜D“z�ØœŸ™Ñ%Ø# A™w˜h�D˜’Gà˜“G˜q‘L”Gà�t˜d‘{�Ø�‰˜t T×%8Ñ%8Ó9Ð9r&   c           
     ó°  ‡"‡6— ddl m} ddlmŠ6 d}t	        |«      dk(  rö|\  }Š"‰"j
                  r	‰"|c}Š"|‰"g}|t        j                  usJ ‚|j
                  r¸|j                  s¬‰"j                  «       \  }Š"‰"j                  r�|t        j                  ur/||z  }|t        j                  u r‰"}n | ||z  ‰"d¬«      }|gg df}nLt        j                  r<‰"j                  r0t        ‰"j                  D �cg c]  }t!        ||«      ‘Œ c}Ž }	|	gg df}|r|S g }
g }g }t        j                  }g }g }t        j"                  }i }d}|D �]û  }|j$                  r|j'                  |«      \  }}|j(                  r~|j                  r|j+                  |j                  «       nU|j                  D ]1  }|j                  r|j-                  |«       Œ!|j-                  |«       Œ3 |j-                  t.        «       Œ®|j0                  r�|t        j2                  u s|t        j4                  u r"|j                  rt        j2                  gg dfc S |j0                  st7        ||«      r-||z  }|t        j2                  u rt        j2                  gg dfc S �ŒGt7        ||«      r|j9                  |«      }�Œf|t        j4                  u r*|st        j2                  gg dfc S t        j4                  }�Œ¢|sBt7        |t        «      r2t;        d„ |j                  D «       «      rt        j2                  gg dfc S |t        j<                  u r|t        j>                  z  }�Œ|j                  �r|jA                  «       \  Š"}|jB                  rÔ‰"j0                  rÈ|j
                  r�|jD                  r|tG        ‰"|«      z  }�Œn|jH                  r|j-                  tG        ‰"|«      «       �Œ—‰"jH                  r||z  }‰" Š"‰"t        j                  ur!|jK                  ‰"g «      j-                  |«       �Œà‰"jL                  s|jN                  r|j-                  ‰"|f«       �Œ|j-                  ‰"|f«       �Œ"|t.        ur|j-                  |«       |s�Œ?|jQ                  d«      }|s|j-                  |«       Œ)|jQ                  «       }|jA                  «       \  }}|jA                  «       \  }}||z   }||k(  rB|j                  s6||z  }|j                  r|j-                  |«       Œ˜|jS                  d|«       n|j+                  ||g«       |rŒ½�Œþ d	„ } ||«      } ||«      }tU        d«      D �]e  }g }d} |D �]   \  Š"}|j                  rr‰"j                  s‰"j(                  rYt;        ˆ"fd
„t        j4                  t        jV                  t        jX                  fD «       «      rt        j2                  gg dfc c S Œ…|t        j                  u r‰"j0                  r|‰"z  }Œ©‰"}!|t        j                  ur@tG        ‰"|«      }!|!jB                  r(‰"jB                  s‰"}|!jA                  «       \  Š"}‰"|k7  rd} |
j-                  !«       |j-                  ‰"|f«       �Œ# | r6t	        |D �"�ch c]  \  }"}|"’Œ	 c}}"«      t	        |«      k7  rg }
 ||«      }�Œf n i }#|D ]&  \  Š"}|#jK                  |g «      j-                  ‰"«       Œ( |#j[                  «       D ]  \  }Š" | ‰"Ž |#|<   Œ |
j+                  |#j[                  «       D ��"cg c]  \  }}"|sŒ	tG        |"|«      ‘Œ c}"}«       i }$|j[                  «       D ],  \  Š"}|$jK                  t        |Ž g «      j-                  ‰"«       Œ. ~g }%|$j[                  «       D ]�  \  }Š" | ‰"Ž Š"|j\                  dk(  r|tG        ‰"|«      z  }Œ*|j^                  |j\                  kD  rHta        |j^                  |j\                  «      \  }&}'|tG        ‰"|&«      z  }tc        |'|j\                  «      }|%j-                  ‰"|f«       ŒŸ ~$te        tf        «      }(d}|t	        |%«      k  �rÌ|%|   \  }})|dk(  r|dz  }Œ"g }*tU        |dz   t	        |%«      «      D ]é  }+|%|+   \  },}-|ji                  |,«      }.|.t        j                  usŒ/|)|-z   }|j\                  dk(  r|tG        |.|«      z  }nt|j^                  |j\                  kD  rHta        |j^                  |j\                  «      \  }&}'|tG        |.|&«      z  }tc        |'|j\                  «      }|*j-                  |.|f«       |,|.z  |-f|%|+<   ||.z  }|t        j                  u sŒé n |t        j                  ur{tG        ||)«      }/|/j0                  r||/z  }n]tj        jm                  |/«      D ]E  }/|/j0                  r||/z  }Œ|/jB                  sJ ‚|/j                  \  }})|(|)   j-                  |«       ŒG |%j+                  |*«       |dz  }|t	        |%«      k  r�ŒÌ|(j[                  «       D ]  \  }Š" | ‰"Ž |(|<   Œ |rº|jo                  «       \  }!}ta        |!|«      \  }0}!|0dz  r| }|dk(  r |
j-                  t        j<                  «       nk|!ritc        |!|«      }|(j[                  «       D ]  \  }Š"||k(  sŒ‰"jL                  sŒ‰" |(|<    n, |
j-                  tG        t        jp                  |d¬«      «       |
j+                  |(j[                  «       D ��"cg c]  \  }}"tG        |"|«      ‘Œ c}"}«       |t        jV                  t        jX                  fv r d„ }1 |1|
d«      \  }
}2 |1||2«      \  }}2||2z  }|t        j4                  u ra|
D �3cg c]%  }3ts        |3j                  «      r|3jt                  €|3‘Œ' }
}3|D �3cg c]%  }3ts        |3j                  «      r|3jt                  €|3‘Œ' }}3nR|j                  rFt;        ˆ6fd„|D «       «      r|g||fS t;        d„ |
D «       «      rt        j2                  gg |fS |gg |fS g }4|
D ]%  }|j0                  r||z  }Œ|4j-                  |«       Œ' |4}
tw        |
«       |t        j                  ur|
jS                  d|«       t        j                  ri|sgt	        |
«      dk(  rY|
d   j0                  rJ|
d   jx                  r;|
d   j                  r,|
d   }t        |
d   j                  D �5cg c]  }5||5z  ‘Œ	 c}5Ž g}
|
||fS c c}w c c}}"w c c}"}w c c}"}w c c}3w c c}3w c c}5w )a.  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é   FrN   c              3  ó²   K  — | ]O  }t         j                  |«      D ]5  }|t        j                  t        j                  t        j
                  fv –— Œ7 ŒQ y ­wrE   )r6   Ú	make_argsr   ÚNegativeInfinityr\   ÚInfinity)rH   Ú__Ú_s      r'   rI   zMul.flatten.<locals>.<genexpr>†  sS   è ø€ ò :Aà¬c¯m©m¸BÓ.?ò:Aà)*ð œ!×,Ñ,¬a×.?Ñ.?ÄÇÁÐLÔLð:AØLñ:Aùs   ‚AAc           
     óÐ  — i }| D ]L  \  }}|j                  «       }|j                  |i «      j                  |d   g «      j                  |d   «       ŒN |j                  «       D ](  \  }}|j                  «       D ]  \  }}t	        |Ž ||<   Œ Œ* g }|j                  «       D ]<  \  }}|j                  |j                  «       D �	�
cg c]  \  }	}
||
|	z  f‘Œ c}
}	«       Œ> |S c c}
}	w ©Nr	   r   )Úas_coeff_MulÚ
setdefaultr4   ÚitemsÚAddr3   )Úc_powersÚcommon_bÚbÚer:   ÚdÚdiÚliÚnew_c_powersÚtrW   s              r'   Ú_gatherzMul.flatten.<locals>._gatherã  só   € ØˆHØ ò -‘��1Ø—^‘^Ó%�Ø×#Ñ# A rÓ*×5Ñ5Ø�q‘E˜2óß%™v b¨¡e�}ð-ð !Ÿ™Ó(ò %‘��1ØŸg™g›iò %‘F�B˜Ü ˜H�A�b’Eñ%ð%ð ˆLØ Ÿ™Ó(ò F‘��1Ø×#Ñ#¸!¿'¹'»)×$D±$°!°Q a¨¨1©¢XÓ$DÕEðFàÐùó %Es   ÃC"c              3  ó:   •K  — | ]  }|‰j                   v –— Œ y ­wrE   r,   )rH   Úinftyrq   s     €r'   rI   zMul.flatten.<locals>.<genexpr>  s!   øè ø€ ò 6;Ø!ð 7<¸q¿v¹v´oñ 6;ùs   ƒTr	   c                ó|   — g }| D ]2  }|j                   rŒ|j                  r|dz  }Œ"|j                  |«       Œ4 ||fS ©Néÿÿÿÿ)Úis_extended_positiverV   r4   )Úc_partÚ
coeff_signÚ
new_c_partrw   s       r'   Ú_handle_for_ooz#Mul.flatten.<locals>._handle_for_oo¤  sS   € Ø�
Øò )�AØ×-Ò-Ø Ø×-Ò-Ø" bÑ(˜
Ø Ø×%Ñ% aÕ(ð)ð " :Ð-Ð-r&   c              3  ó6   •K  — | ]  }t        |‰«      –— Œ y ­wrE   )Ú
isinstance)rH   rW   ra   s     €r'   rI   zMul.flatten.<locals>.<genexpr>Â  s   øè ø€ Ò>°”:˜a ×,Ñ>ùs   ƒc              3  ó:   K  — | ]  }|j                   d k(  –— Œ y­w©FN©Ú	is_finite)rH   rW   s     r'   rI   zMul.flatten.<locals>.<genexpr>Ä  s   è ø€ Ò8¨A�1—;‘; %Õ'Ñ8ùó   ‚)=Ú!sympy.calculus.accumulationboundsr`   Úsympy.matrices.expressionsra   ÚlenÚis_Rationalr   r1   Úis_zerork   Úis_Addr   Ú
distributer$   rn   r-   Ú_keep_coeffÚZeror    Úas_expr_variablesr!   r3   r4   r   r"   ÚNaNr\   r„   Ú__mul__ÚanyÚImaginaryUnitÚHalfÚas_base_expÚis_PowÚ
is_IntegerÚPowÚis_negativerl   Úis_positiveÚ
is_integerÚpopr5   Úrangerf   re   rm   ÚqÚpÚdivmodÚRationalr   r0   Úgcdr6   rd   Úas_numer_denomr]   r   Úis_extended_realr.   rˆ   )7rQ   Úseqr`   Úrvr;   ÚrÚarÚarbÚbiÚnewbr   Únc_partÚnc_seqÚcoeffro   Únum_expÚneg1eÚpnum_ratÚorder_symbolsÚor¢   rr   Úo1Úb1Úe1Úb2Úe2Únew_expÚo12rx   Úirv   Úchangedr£   rq   Úinv_exp_dictÚcomb_eÚnum_ratÚe_iÚepÚpnewÚeiÚgrowÚjÚbjÚejÚgÚobjÚnr‚   r€   rW   Ú_newÚfra   s7                                     `                   @r'   ÚflattenzMul.flattenÍ   s_  ù€ õ^ 	BÝ9ØˆÜˆs‹8�qŠ=Ø‰DˆAˆqØ�}Š}Ø˜!���1Ø˜!�f�ØœAŸE™E‘>Ð!�>Ø�}Š} Q§Y¢YØ—~‘~Ó'‘��1Ø—8’8Ø¤§¡‘~à˜q™S˜Ø¤§¡™;Ø"#™Cá"% a¨¡c¨1°uÔ"=˜CØ!˜U B¨˜_™Ü*×5Ò5¸!×:JÒ:JÜ"À!Ç&Á&Ö$I¸B¤[°°BÕ%7Ò$IÐJ˜Ø"˜V R¨Ð-˜ÙØ�	ð ˆØˆàˆä—‘ˆð ˆð ˆô —‘ˆàˆð ˆð ó }	0ˆAà�zŠzØ#$×#6Ñ#6°}Ó#EÑ ��=ð �xŠxØ×#Ò#Ø—J‘J˜qŸv™vÕ&ð ŸV™Vò -˜Ø×+Ò+ØŸJ™J q�Mà"ŸM™M¨!Õ,ð	-ð —J‘JœyÔ)àð —’ØœŸ™‘: ¬!×*;Ñ*;Ñ!;ÀÇ	Â	äŸE™E˜7 B¨Ð,Ò,Ø—_’_¬
°5¸+Ô(FØ˜Q‘J�EØ¤§¡‘~ä !§¡˜w¨¨DÐ0Ò0Ùä˜A˜{Ô+ØŸ	™	 %Ó(�Ùà”a×'Ñ'Ñ'ÙäŸE™E˜7 B¨Ð,Ò,Ü×)Ñ)�Ùáœz¨!¬SÔ1´cñ :AàŸf™fô:Aô 7Aô Ÿ™�w  DÐ(Ò(à”a—o‘oÑ%ØœŸ™‘�Ùà×!Ó!ð —}‘}“‘��1ð —8’8Ø—{’{ð
 Ÿ=š=Ø Ÿ|š|Ø %¬¨Q°«Ñ 2 Ù (Ø!"§¢Ø #§
¡
¬3¨q°!«9Ô 5Ù (Ø!"§¢Ø %¨¡
 Ø%& B Ø ¬¯©™~Ø (× 3Ñ 3°A°rÓ :× AÑ AÀ!Ô DÙ$ØŸ]š]¨a¯lªlØ#ŸN™N¨A¨q¨6Ô2Ù$à—‘  A Ö'ð
 œIÑ%Ø—M‘M !Ô$ó ØŸ
™
 1›�AÙ"ØŸ™ qÔ)Ø ð !Ÿ™›�BØŸ^™^Ó-‘F�B˜ØŸ]™]›_‘F�B˜Ø  2™g�Gð
 ˜R’x¨¯ªØ  G™m˜ð ×-Ò-ØŸJ™J sœOØ$à"ŸM™M¨!¨SÕ1ð  Ÿ™¨¨A wÔ/ô7 ðE}	0òX	 ñ ˜8Ó$ˆñ ˜'Ó"ˆô0 �q“ó $	ˆAØˆLØˆGØ ó ,‘��1Ø—9’9àŸš A§H¢H´#ó 6;Ü&'×&7Ñ&7¼¿¹Ü&'×&8Ñ&8ð&:ô6;ô 3;ô !"§¡˜w¨¨DÐ0Ô0ØØœŸ™‘:Ø—{’{Ø ™
˜Ø Ø�AØœAŸE™E‘>Ü˜A˜q›	�Að —x’x¨¯ªØ˜Ø Ÿ}™}›™˜˜1Ø š7Ø&*˜GØ—‘˜aÔ Ø×#Ñ# Q¨ FÖ+ð1,ñ6 œ3Ø".÷ 0Ù˜!˜Q’Aó 0ó 1Ü47¸Ó4EòFð �Ù" <Ó0’áðI$	ðP ˆàò 	5‰DˆAˆqØ×#Ñ# A rÓ*×1Ñ1°!Õ4ð	5à ×&Ñ&Ó(ò 	&‰DˆAˆqÙ! 1˜gˆL˜ŠOð	&à�‰¨\×-?Ñ-?Ó-A×G¡T Q¨ÂQ”s˜1˜a•yÓGÔHð ˆØ—N‘NÓ$ò 	5‰DˆAˆqØ×Ñœc 1˜g rÓ*×1Ñ1°!Õ4ð	5àð ˆØ—L‘L“Nò 		#‰DˆAˆqÙ�Q�ˆAØ�s‰s�aŠxØœ˜Q ›Ñ"�ØØ�s‰s�Q—S‘SŠyÜ  §¡ a§c¡cÓ*‘��RØœ˜Q ›Ñ$�Ü˜R §¡Ó%�Ø�N‰N˜A˜q˜6Õ"ð		#ð ô œ4Ó ˆØˆØ”#�g“,ÓØ˜Q‘Z‰FˆB�Ø�QŠwØ�Q‘�ØØˆDÜ˜1˜q™5¤# g£,Ó/ò �Ø  ™‘��BØ—F‘F˜2“J�ØœAŸE™E’>ð ˜R™�AØ—s‘s˜a’xØ¤ Q¨£Ñ*™àŸ3™3 §¡š9Ü&,¨Q¯S©S°!·#±#Ó&6™G˜C Ø!¤S¨¨C£[Ñ0˜EÜ (¨¨Q¯S©SÓ 1˜AØŸ™ Q¨ FÔ+à"$ Q¡$¨ �G˜A‘Jà˜A™�BØœQŸU™U’{Ùð)ð* œŸ™‰Ü˜"˜b“k�Ø—=’=Ø˜S‘L‘Eô  #Ÿ}™}¨SÓ1ò 0˜ØŸ=š=Ø! S™L™Eà#&§:¢:Ð- :Ø%(§X¡X™F˜B Ø  ™HŸO™O¨BÕ/ð0ð �N‰N˜4Ô Ø�‰FˆAðU ”#�g“,ÔðZ —J‘J“Lò 	‰DˆAˆqÙ˜1�gˆD�ŠGð	ñ à×(Ñ(Ó*‰DˆAˆqä˜!˜Q“<‰DˆAˆqØ�1ŠuØ˜�à�AŠvØ—‘œaŸo™oÕ.Ùô !  A›�Ø ŸJ™J›Lò M‘D�A�qØ˜E“z a§m£mØ#$ "˜˜Q™ÙðMð —M‘M¤#¤a§m¡m°UÀUÔ"KÔLð 	�‰¨T¯Z©Z«\×:¡T Q¨”s˜1˜a•yÓ:Ô;ð ”Q—Z‘Z¤×!3Ñ!3Ð4Ñ4ò	.ñ "0°¸Ó!:ÑˆF�JÙ"0°¸*Ó"EÑˆG�ZØ�ZÑˆEð ”A×%Ñ%Ñ%ð "(ö Q˜A´	¸!¿)¹)Ô0DØ01×0BÑ0BÐ0Nò ð QˆFð Qà")ö S˜Q´)¸A¿I¹IÔ2FØ23×2DÑ2DÐ2Pò ð SˆGñ Sð �]Š]ô Ó>°gÔ>Ô>Ø�w ¨Ð6Ð6ÜÑ8°Ô8Ô8ÜŸ™�w  MÐ1Ð1Ø�7˜B Ð-Ð-ð ˆØò 	ˆAØ�{Š{Ø˜‘
‘à—‘˜A•ð		ð
 ˆô 	�Ôð œŸ™ÑØ�M‰M˜!˜UÔ#ô ×(Ò(±¼SÀ»[ÈAÒ=MØ�q‘	×#Ò#¨¨q©	×(;Ò(;ÀÀqÁ	×@PÒ@Pà˜1‘IˆEÜ¨V°A©Y¯^©^Ö<¨˜E !›GÒ<Ð=Ð>ˆFà�w Ð-Ð-ùò] %Jùót 0ùó  HùóJ ;ùò2QùòSùòD =s0   Ã4t2Út7Ü6
t=
Ýt=
ì2u
î(*u	ï*uôuc           
     óü  — | j                  d¬«      \  }}|j                  rDt        |D �cg c]  }t        ||d¬«      ‘Œ c}Ž t        t        j	                  |«      |d¬«      z  S |j
                  rÏ|j                  dk(  rÀ| j                  r´| j                  «       d   }|j
                  r•t        |dz  «      j                  «       \  }}t        |d«      \  }}|ret        |d«      \  }}|rTddlm}	 t        |«      |z  }
t        |
|j                   z  d |	|«      t"        j$                  z  z   |j                   z  «      S t        | |d¬«      }|j
                  s|j&                  r|j)                  «       S |S c c}w )NF)Úsplit_1rN   rb   r	   r   ©Úsign)r2   r›   r6   rœ   r7   r�   r¢   Úis_imaginaryÚas_real_imagÚabsr§   r   Ú$sympy.functions.elementary.complexesrÕ   r
   r>   r£   r   r—   Úis_FloatÚ_eval_expand_power_base)rL   Úexptr8   Úncrq   r;   rÎ   rs   rw   rÕ   r«   r£   s               r'   Ú_eval_powerzMul._eval_powerá  sJ  € ð —M‘M¨%�MÓ0‰	ˆˆrà�?Š?Ü¸uÖE¸!œ˜Q ¨uÖ5ÒEÐFÜ”C—N‘N 2Ó&¨°uÔ=ñ>ð >à×Ò §¡¨!¢Ø× Ò Ø×%Ñ%Ó'¨Ñ*�Ø—=’=Ü˜q ™s›8×2Ñ2Ó4‘D�A�qÜ*¨1¨aÓ0‘D�A�qÙÜ.¨q°!Ó4™˜˜1ÙÝQÜ '¨£
¨1¡˜AÜ#3°A°t·v±v±IÀÁDÈÃGÌAÏOÉOÑD[Ñ@[Ð^b×^dÑ^dÑ?dÓ#eÐeä��d UÔ+ˆà×Ò˜tŸ}š}Ø×,Ñ,Ó.Ð.àˆùò) Fs   «E9c                ó    — dd| j                   fS )Né   r   )r   ©rQ   s    r'   Ú	class_keyzMul.class_keyý  s   € à�!�S—\‘\Ð!Ð!r&   c                ó.  — | j                  «       \  }}|t        j                  u r=|j                  rt	        j
                  ||«       }n/|j                  |«      }|�|}| }nt	        j
                  | |«      }|j                  r|j                  «       S |S rE   )rk   r   r]   r!   r   Ú_eval_evalfÚ	is_numberÚexpand)rL   ÚprecrW   Úmrª   Úmnews         r'   rä   zMul._eval_evalf  s†   € Ø× Ñ Ó"‰ˆˆ1Ø”—‘ÑØ�xŠxÜ×)Ñ)¨!¨TÓ2Ð2‘à—}‘} TÓ*�ØÐ#Ø�AØ�R‘ä×$Ñ$ T¨4Ó0ˆBØ�<Š<Ø—9‘9“;ÐØˆ	r&   c                ó¶   — ddl m} | j                  «       \  }}|t        j                  urt        d«      ‚ |d«      j                   ||«      j                  fS )z;
        Convert self to an mpmath mpc if possible
        r	   )ÚFloatz7Cannot convert Mul to mpc. Must be of the form Number*Ir   )Únumbersrë   rk   r   r—   ÚAttributeErrorÚ_mpf_)rL   rë   Úim_partÚ	imag_units       r'   Ú_mpc_z	Mul._mpc_  sQ   € õ
 	#Ø!×.Ñ.Ó0Ñˆ�ØœAŸO™OÑ+ô !Ð!ZÓ[Ð[á�a“—‘¡ g£× 4Ñ 4Ð5Ð5r&   c                ó¨   — | j                   }t        |«      dk(  rt        j                  | fS t        |«      dk(  r|S |d    | j                  |dd Ž fS )ao  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	   rb   r   N)r-   rŒ   r   r1   Ú_new_rawargs)rL   r-   s     r'   Úas_two_termszMul.as_two_terms   s[   € ð* �y‰yˆäˆt‹9˜Š>Ü—5‘5˜$�;ÐÜ�‹Y˜!Š^ØˆKð ˜‘7Ð-˜D×-Ñ-¨t°A°B¨xÐ8Ð8Ð8r&   )Úrationalc               ó`  ‡— ‰r8t        | j                  ˆfd„d¬«      \  }} | j                  |Ž t        |«      fS | j                  }|d   j                  rG|r|d   j
                  r
|d   |dd  fS |d   j                  rt        j                  |d    f|dd  z   fS t        j                  |fS )Nc                ó"   •—  | j                   ‰Ž S rE   )Úhas)ÚxÚdepss    €r'   ú<lambda>z"Mul.as_coeff_mul.<locals>.<lambda>B  s   ø€ ¨u¨q¯u©u°d¨|€ r&   T)Úbinaryr   r	   )
r   r-   ró   Útupler"   r�   rV   r   r]   r1   )rL   rõ   rú   ÚkwargsÚl1Úl2r-   s     `    r'   r[   zMul.as_coeff_mul?  s°   ø€ áÜ˜$Ÿ)™)Ó%;ÀDÔI‰FˆB�Ø$�4×$Ñ$ bÐ)¬5°«9Ð4Ð4Ø�y‰yˆØ�‰7×ÒÙ˜t A™w×2Ò2Ø˜A‘w  Q R Ð(Ð(Ø�a‘×-Ò-Ü—}‘}¨¨Q© x k°D¸¸°HÑ&<Ð<Ð<Ü�u‰u�dˆ{Ðr&   c                óB  — | j                   d   | j                   dd }}|j                  rd|r|j                  r&t        |«      dk(  r||d   fS | | j                  |Ž fS |j
                  r$t        j                   | j                  | f|z   Ž fS t        j                  | fS )zC
        Efficiently extract the coefficient of a product.
        r   r	   N)	r-   r"   r�   rŒ   ró   rV   r   r]   r1   )rL   rõ   r²   r-   s       r'   rk   zMul.as_coeff_MulL  s    € ð —i‘i ‘l D§I¡I¨a¨b Mˆtˆà�?Š?Ù˜u×0Ò0Ü�t“9 ’>Ø  $ q¡'˜>Ð)à Ð"3 $×"3Ñ"3°TÐ":Ð:Ð:Ø×+Ò+Ü—}‘}Ð&7 d×&7Ñ&7¸E¸6¸)ÀdÑ:JÐ&LÐLÐLÜ�u‰u�dˆ{Ðr&   c                óÐ  — ddl m}m}m} g }g }g }t        j
                  }	| j                  D ]î  }
|
j                  «       \  }}|j                  r|j                  |«       Œ4|j                  r#|j                  |t        j                  z  «       Œc|
j                  ro|r|
j                  «       nd }t        |«      D ])  \  }}||k(  sŒ|j                   ||«      dz  «       ||=  Œ¹ |
j                  r|	|
z  }	ŒÌ|j                  |
«       ŒÞ|j                  |
«       Œð  | j                  |Ž }|j!                  d«      |k(  ry t#        |«      dz  r ||j%                  d«      «      }nt        j&                  } | j                  ||z   Ž }| ||«      z  | ||«      z  }}|	dk(  rY|dk(  r3|j                  r|t        j&                  fS t        j&                  ||z  fS |t        j&                  u r||fS | |z  ||z  fS ddlm}  ||	d¬«      j                  «       \  }}|t        j&                  u r||z  ||z  z
  ||z  ||z  z   fS | |z  ||z  }}||z  ||z  z
  ||z  ||z  z   fS )	Nr   )ÚAbsÚimÚrerb   Úignorer	   )Ú
expand_mulF)Údeep)rÙ   r  r  r  r   r1   r-   r×   rŽ   r4   r—   r$   Ú	conjugateÚ	enumerater�   ÚfuncÚgetrŒ   r    r’   Úfunctionr  )rL   r  Úhintsr  r  r  ÚotherÚcoeffrÚcoeffiÚaddtermsr;   r«   r¿   Úaconjrù   rè   ÚimcoÚrecor  ÚaddreÚaddims                        r'   r×   zMul.as_real_imag\  sM  € ßDÑDØˆØˆØˆÜ—5‘5ˆØ—‘ò 	 ˆAØ—>‘>Ó#‰DˆAˆqØ�yŠyØ—‘˜aÕ Ø—’Ø—‘˜a¤§¡Ñ/Õ0Ø×!Ò!Ù).˜Ÿ™œ°D�ä% eÓ,ò 	(‘D�A�qØ˜E“zØŸ™¡c¨!£f¨a¡iÔ0Ø! !˜HÙð		(ð —x’xØ  A™™àŸ™ Q�à—‘˜Q•ð)	 ð* ˆD�I‰I�uÐˆØ�9‰9�XÓ !Ò#ØÜˆv‹;˜Š?Ù�f—j‘j “mÓ$‰Dô —6‘6ˆDØˆt�y‰y˜6 F™?Ð,ˆØ‘R˜“U‘
˜D¡ A£™Jˆ1ˆØ�qŠ=Ø�AŠvØ—<’<Ø ¤!§&¡&˜>Ð)äŸF™F D¨¡IÐ.Ð.Ø”q—v‘v‰~Ø˜1�v�Ø�E˜!‘G˜T !™VÐ$Ð$Ý(Ù! (°Ô7×DÑDÓF‰ˆˆuØ”1—6‘6‰>Ø�e‘G˜a ™gÑ% q¨¡w°°5±Ñ'8Ð9Ð9à�5˜‘7˜D ™FˆqˆAØ�e‘G˜a ™gÑ% q¨¡w°°5±Ñ'8Ð9Ð9r&   c           	     ó:  — t        | «      }|dk(  r| d   j                  S g }t        j                  | d|dz   «      }t        j                  | |dz  d «      }|D ��cg c]  }|D ]  }t        ||«      ‘Œ Œ }}}t	        |Ž }t	        j
                  |«      S c c}}w )zk
        Helper function for _eval_expand_mul.

        sums must be a list of instances of Basic.
        r	   r   Nrb   )rŒ   r-   r6   Ú_expandsumsrn   rd   )ÚsumsÚLÚtermsÚleftÚrightr;   rq   Úaddeds           r'   r  zMul._expandsums“  s™   € ô �‹IˆØ�Š6Ø˜‘7—<‘<ÐØˆÜ�‰˜t E Q¨¡T˜{Ó+ˆÜ—‘  Q¨¡T U Ó,ˆà$(×8˜q°%Ò8¨Q”�Q˜•Ð8�Ð8ˆÑ8Ü�U�ˆÜ�}‰}˜UÓ#Ð#ùó 9s   ÁBc                ó:  — ddl m} | } |||j                  dd«      «      \  }}|j                  r3||fD �cg c]"  }|j                  r |j                  di |¤Žn|‘Œ$ c}\  }}||z  }|j                  s|S g g d}	}}|j
                  D ]Z  }
|
j                  r|j                  |
«       d}	Œ#|
j                  r|j                  |
«       ŒA|j                  t        |
«      «       Œ\ |	s|S  | j                  |Ž }|r›|j                  dd«      }| j                  j                  |«      }g }|D ]_  }| j                  ||«      }|j                  r.t        d„ |j
                  D «       «      r|r|j	                  «       }|j                  |«       Œa t        |Ž S |S c c}w )	Nr   ©ÚfractionÚexactFTr  c              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   )r�   rG   s     r'   rI   z'Mul._eval_expand_mul.<locals>.<genexpr>Ê  s   è ø€ Ò'A°Q¨¯­Ñ'AùrJ   r%   )Úsympy.simplify.radsimpr"  r  r!   Ú_eval_expand_mulr-   r�   r4   r$   r   r  r  r–   rn   )rL   r  r"  ÚexprrÎ   rs   r¿   Úplainr  ÚrewriteÚfactorr  r  r-   Útermrw   s                   r'   r&  zMul._eval_expand_mul¦  s‹  € Ý3ð ˆá˜˜eŸi™i¨°Ó7Ó8‰ˆˆ1Ø�8Š8à˜Q˜ö!Øð 45·8²8Ð&�A×&Ñ&Ñ/¨Ò/ÀÑBò !‰DˆAˆqà�‰sˆØ�{Š{ØˆKà! 2 u�WˆtˆØ—i‘iò 	/ˆFØ�}Š}Ø—‘˜FÔ#Ø‘à×(Ò(Ø—L‘L Õ(à—K‘K¤ f£Õ.ð	/ñ ØˆKà�D—I‘I˜uÐ%ˆEÙØ—y‘y ¨Ó/�ØŸ	™	×-Ñ-¨dÓ3�Ø�Ø!ò #�DØŸ	™	 %¨Ó.�AØ—x’x¤CÑ'A¸!¿&¹&Ô'AÔ$AÁdØ×.Ñ.Ó0˜Ø—K‘K •Nð	#ô
 ˜D�zÐ!à�ùòA!s   ·'Fc           
     ó0  — t        | j                  «      }g }t        t        |«      «      D ]T  }||   j	                  |«      }|sŒ|j                  t        d„ |d | |gz   ||dz   d  z   t        j                  «      «       ŒV t        j                  |«      S )Nc                ó   — | |z  S rE   r%   )rù   Úys     r'   rû   z&Mul._eval_derivative.<locals>.<lambda>Ú  s
   € °°1±€ r&   r	   )r0   r-   r¡   rŒ   Údiffr4   r   r   r1   rn   Úfromiter)rL   Úsr-   r  r¿   rs   s         r'   Ú_eval_derivativezMul._eval_derivativeÑ  sŽ   € ä�D—I‘I‹ˆØˆÜ”s˜4“yÓ!ò 	_ˆAØ�Q‘—‘˜Q“ˆAÚð —‘œVÑ$4°t¸B¸Q°xÀ1À#±~ÈÈQÐQRÉUÈVÈÑ7TÔWX×W\ÑW\Ó]Õ^ð	_ô �|‰|˜EÓ"Ð"r&   c                óH  •— ddl m} ddlm}m}m} t        |||f«      st        ‰| �!  ||«      S ddl	m
} | j                  }t        |«      }	t        |t        |f«      rkg }
ddlm}  ||	|«      D ]O  \  }}t!        t#        ||«      D ��cg c]  \  }}|j%                  ||f«      ‘Œ c}}Ž }|
j'                  ||z  «       ŒQ t)        |
Ž S ddlm} ddlm} dd	lm}  |d
|	z  |¬«      }|t7        |«      z
  } ||«      }|t9        t;        ||«      «      z   ||«      z  t!        t=        |	dz
  «      D �cg c]  }||   j%                  |||   f«      ‘Œ c}Ž z  |d   j%                  | |d|«      f«      z  |D �cg c]  }|d|f‘Œ	 c}}} ||g|¢­Ž S c c}}w c c}w c c}w )Nr	   )ÚAppliedUndef)ÚSymbolÚsymbolsÚDummy)ÚIntegerr   )Ú!multinomial_coefficients_iterator)ÚSum)Ú	factorial)ÚMaxzk1:%irá   r}   )r  r4  Úsymbolr5  r6  r7  r„   ÚsuperÚ_eval_derivative_n_timesrì   r8  r-   rŒ   ÚintÚsympy.ntheory.multinomialr9  r6   Úzipr/  r4   rn   Úsympy.concrete.summationsr:  Ú(sympy.functions.combinatorial.factorialsr;  Ú(sympy.functions.elementary.miscellaneousr<  ÚsumÚprodÚmapr¡   )rL   r1  rÎ   r4  r5  r6  r7  r8  r-   rè   r  r9  ÚkvalsrW   ÚkÚargr£   r:  r;  r<  ÚklastÚnfactrw   rr   ÚlÚ	__class__s                            €r'   r?  zMul._eval_derivative_n_timesÝ  sœ  ø€ å*ß2Ñ2Ü˜!˜l¨FÐ3Ô4ô ‘7Ñ3°A°qÓ9Ð9Ý$Ø�y‰yˆÜ�‹IˆÜ�aœ#˜w˜Ô(àˆEÝSÙ=¸aÀÓCò $‘��qÜ¼¸UÀDÓ9I×J©v¨q°#˜#Ÿ(™( A q 6Õ*ÓJÐK�Ø—‘˜Q ™UÕ#ð$ô ˜�;ÐÝ1ÝFÝ@Ù˜ !™¨Ô/ˆØ”C˜“J‘ˆÙ˜!“ˆà”$”s˜9 eÓ,Ó-Ñ-©i¸Ó.>Ñ>Ü´u¸Q¸q¹S³zÖB°!�$�q‘'—,‘,  5¨¡8˜}Õ-ÒBÐCñDà�‰H�M‰M˜1™c ! U›mÐ,Ó-ñ.ð !&Ö&˜1ˆa��AŠYÒ&ð	 ˆñ
 �1ˆz�qŠzÐùó Kùò Cùâ&s   Â
FÄ4 F
Å;Fc                ó²   — ddl m} | j                  d   }t        | j                  dd  Ž }|j	                  |||z   «       ||||«      z   ||||«      |z  z   S )Nr   )Údifference_deltar	   )Úsympy.series.limitseqrQ  r-   r6   Úsubs)rL   rÎ   ÚstepÚddÚarg0Úrests         r'   Ú_eval_difference_deltazMul._eval_difference_deltaý  sc   € Ý@Ø�y‰y˜‰|ˆÜ�D—I‘I˜a˜b�MÐ"ˆØ—	‘	˜!˜Q ™XÓ&©¨D°!°TÓ):Ñ:¹RÀÀaÈÓ=NØñ>ñ ð 	r&   c                óÒ   — | j                  «       \  }}t        j                  |«      }t        |«      dk(  r1| j                  j                  ||«      }|d   j                  ||«      S y rj   )rk   r6   rd   rŒ   rO  Ú_combine_inverseÚmatches)rL   r'  Ú	repl_dictr²   r  Únewexprs         r'   Ú_matches_simplezMul._matches_simple  s]   € à×(Ñ(Ó*‰ˆˆuÜ—‘˜eÓ$ˆÜˆu‹:˜Š?Ø—n‘n×5Ñ5°d¸EÓBˆGØ˜‘8×#Ñ# G¨YÓ7Ð7Ør&   c                ó  — t        |«      }| j                  r|j                  r| j                  |||«      S | j                  |j                  ury | j                  «       \  }}|j                  «       \  }}||fD �cg c]	  }|xs dg‘Œ c}\  }}t	        |Ž }	t	        |Ž }
|	j                  |
||«      }|s||k7  ry t        j                  |«      }t        j                  |«      }t        j                  |||«      }|xs d S c c}w ©Nr	   )r
   r$   Ú_matches_commutativer2   r6   r[  Ú_matches_expand_powsÚ_matches_noncomm)rL   r'  r\  ÚoldÚc1Únc1Úc2Únc2rW   Úcomm_mul_selfÚcomm_mul_exprs              r'   r[  zMul.matches  s  € Ü�t‹}ˆØ×Ò 4×#6Ò#6Ø×,Ñ,¨T°9¸cÓBÐBØ× Ñ ¨×(;Ñ(;Ñ;Øð —-‘-“/‰ˆˆCØ—-‘-“/‰ˆˆCØ%'¨ HÖ-˜q�!’(˜�s‘(Ò-‰ˆˆBô ˜R˜ˆÜ˜R˜ˆà!×)Ñ)¨-¸ÀCÓHˆ	ñ ˜R 2šXØô ×&Ñ& sÓ+ˆÜ×&Ñ& sÓ+ˆä×(Ñ(¨¨c°9Ó=ˆ	àÒ ˜DÐ ùò) .s   Á<Dc                óÄ   — g }| D ]X  }|j                   r9|j                  dkD  r*|j                  |j                  g|j                  z  «       ŒH|j	                  |«       ŒZ |S rZ   )rš   Úexpr3   Úbaser4   )Úarg_listÚnew_argsrK  s      r'   rb  zMul._matches_expand_pows-  sU   € àˆØò 	%ˆCØ�zŠz˜cŸg™g¨škØ—‘ §¡ 
¨S¯W©WÑ 4Õ5à—‘ Õ$ð		%ð
 ˆr&   c                ó¸  — |€i }n|j                  «       }g }d}|\  }}i }|t        |«      k  r«|t        | «      k  r�| |   }|j                  rt        j	                  ||«       t        j                  ||| |«      }	|	r'|	\  }
}|j                  |
«       |r|D ]
  }||   ||<   Œ |sy|j                  «       }|\  }}|t        |«      k  r|t        | «      k  rŒ�|S )zóNon-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_Wildr6   Ú_matches_add_wildcardÚ_matches_new_statesr3   r    )ÚnodesÚtargetsr\  ÚagendaÚstateÚnode_indÚ
target_indÚwildcard_dictÚnodeÚstates_matchesÚ
new_statesÚnew_matchesÚmatchs                r'   rc  zMul._matches_noncomm7  sý   € ð ÐØ‰Ià!Ÿ™Ó(ˆIð ˆàˆØ$Ñˆ�*àˆàœ3˜w›<Ò'¨H´s¸5³zÒ,AØ˜‘?ˆDà�|Š|Ü×)Ñ)¨-¸Ô?ä ×4Ñ4°]ÀEØ5:¸GóEˆNáØ*8Ñ'�
˜KØ—‘˜jÔ)ÙØ!,ò >˜Ø+6°uÑ+=˜	 %Ò(ð>áØàŸ
™
›�Ø',Ñ$�˜*ð% œ3˜w›<Ò'¨H´s¸5³zÓ,Að( Ðr&   c                óD   — |\  }}|| v r| |   \  }}||f| |<   y ||f| |<   y rE   r%   )Ú
dictionaryrx  ry  rz  ÚbeginÚends         r'   rs  zMul._matches_add_wildcardb  s@   € à$Ñˆ�*Ø�zÑ!Ø# HÑ-‰JˆE�3Ø$)¨:Ð#6ˆJ�xÒ à$.°
Ð#;ˆJ�xÒ r&   c                ó€  — |\  }}||   }||   }|t        |«      dz
  k\  r|t        |«      dz
  k  ry |j                  r«t        j                  | |||«      }|r�t        j	                  | ||«      }	|	D ]>  }
| |
   \  }}| |   \  }}|||dz    }|||dz    }t        ||«      D ]  \  }}||k7  sŒ  y  Œ@ ||dz   fg}|t        |«      dz
  k  r|j                  |dz   |dz   f«       ||fS y |t        |«      dz
  k\  r|t        |«      dz
  k  ry |j                  |«      }|r|dz   |dz   fg|fS ||k(  r|dz   |dz   fgd fS y r`  )rŒ   rr  r6   Ú_matches_match_wildsÚ_matches_get_other_nodesrB  r4   r[  )r‚  rx  ru  rv  ry  rz  r|  ÚtargetÚmatch_attemptÚother_node_indsÚindÚother_beginÚ	other_endÚ
curr_beginÚcurr_endÚother_targetsÚcurrent_targetsÚcurrr  Ú	new_states                       r'   rt  zMul._matches_new_statesk  s¶  € à$Ñˆ�*Ø�X‰ˆØ˜Ñ$ˆð œ˜W›¨Ñ)Ò)¨h¼¸U»Àa¹Ò.GØà�<Š<Ü×4Ñ4°ZÀØ5:¸GóEˆMáô #&×">Ñ">¸zØ?DÀhó#P�à*ò 	(�CØ-7¸©_Ñ*�K Ø+5°hÑ+?Ñ(�J à$+¨K¸	ÀA¹Ð$F�MØ&-¨j¸ÀA¹Ð&F�Oä'*¨?¸MÓ'Jò (™˜˜eØ 5›=Ú#'ñ(ð	(ð '¨
°Q©Ð7Ð8�	àœc %›j¨1™nÒ,Ø×$Ñ$ h°¡l°JÀ±NÐ%CÔDØ  -Ð/Ð/ð/ ð8 œ3˜u›:¨™>Ò)¨j¼3¸w»<È!Ñ;KÒ.KØà ŸL™L¨Ó0ˆMáØ! A™ z°A¡~Ð6Ð7¸ÐFÐFØ˜’Ø! A™ z°A¡~Ð6Ð7¸Ð=Ð=àr&   c                ó„   — ||   }| |   \  }}|||dz    }t        |«      dkD  rt        |Ž n|d   }|j                  |«      S )z@Determine matches of a wildcard with sub-expression in `target`.r	   r   )rŒ   r6   r[  )	r‚  Úwildcard_indru  rv  Úwildcardrƒ  r„  r  Úmults	            r'   r†  zMul._matches_match_wilds   sV   € ð ˜Ñ&ˆØ Ñ-‰
ˆˆsØ˜˜c A™gÐ&ˆä! %›j¨1šnŒs�E‰{°%¸±(ˆØ×Ñ Ó%Ð%r&   c                óH   — ||   }| D �cg c]  }||   |k(  sŒ|‘Œ c}S c c}w )z8Find other wildcards that may have already been matched.r%   )r‚  ru  ry  Úind_noder‹  s        r'   r‡  zMul._matches_get_other_nodesª  s,   € ð ˜‘?ˆØ)ÖD˜¨U°3©Z¸8Ó-C’ÒDÐDùÒDs   Š˜c                ó¨  — ddl m} ddlm} | |k(  rt        j
                  S d„ } || |«      s	 ||| «      rt        j
                  S t        d„ | |fD «       «      �rO |d«      }t        j                  |i}|t        j                  i}| j                  |«      j                  «       }|j                  |«      j                  «       }	t        |	«      }
t        |	j                  «       «      D ]:  }||v sŒ||xx   |	j                  |«      z  cc<   ||   rŒ*|j                  |«       Œ< t        |	«      |
k7  rvt        |j                  «       D ��cg c]
  \  }}||z  ‘Œ c}}Ž j                  |«      } t        |	j                  «       D ��cg c]
  \  }}||z  ‘Œ c}}Ž j                  |«      }| |z  } ||«      }|j                   r|S |S c c}}w c c}}w )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	   )r7  c                ó–   — | j                   r=|j                  r1| j                  d«      |j                  «       j                  d«      k(  S y)Nr   F)rÚ   Úis_comparableÚ__add__Úevalf)rN  r«   s     r'   Úcheckz#Mul._combine_inverse.<locals>.check¼  s8   € Ø�zŠz˜aŸošoð —y‘y “| q§w¡w£y×'8Ñ'8¸Ó';Ñ;Ð;Ør&   c              3  óP   K  — | ]  }|j                   xs |j                  –— Œ  y ­wrE   )rš   r!   ©rH   r¿   s     r'   rI   z'Mul._combine_inverse.<locals>.<genexpr>Å  s    è ø€ Ò8¨ˆq�x‰xÒ#˜1Ÿ8™8Ó#Ñ8ùó   ‚$&ÚI)Úsympy.simplify.simplifyr›  r=  r7  r   r1   r–   r—   ÚxreplaceÚas_powers_dictrŒ   rý   Úkeysr    r6   rm   r"   )ÚlhsÚrhsr›  r7  r   rs   Ú_iÚi_r;   rq   Úblenr®   rJ  Úvrª   Úsrvs                   r'   rZ  zMul._combine_inverse°  s‡  € õ 	5Ý!Ø�#Š:Ü—5‘5ˆLò	ñ ��cŒ?™e C¨œoÜ—5‘5ˆLÜÑ8¨c°3¨ZÔ8Õ8ñ �c“
ˆAÜ—/‘/ 1Ð%ˆBØ”Q—_‘_Ð%ˆBØ—‘˜RÓ ×/Ñ/Ó1ˆAØ—‘˜RÓ ×/Ñ/Ó1ˆAÜ�q“6ˆDÜ˜AŸF™F›H“oò "�Ø˜’7Ø�b“E˜QŸU™U 2›YÑ&“EØ˜R›5ØŸ™˜b�	ð	"ô
 �1‹v˜Š~Ü¨Q¯W©W«Y×7¡T Q¨˜A˜q›DÓ7Ð8×AÑAÀ"ÓE�Ü¨Q¯W©W«Y×7¡T Q¨˜A˜q›DÓ7Ð8×AÑAÀ"ÓE�Ø�‰WˆÙ�r‹lˆØ—m’mˆsÐ+¨Ð+ùó	 8ùÛ7s   ÅG
ÆG
c                ó¬   — t        t        «      }| j                  D ]5  }|j                  «       j	                  «       D ]  \  }}||xx   |z  cc<   Œ Œ7 |S rE   )r   r@  r-   r§  rm   )rL   rs   r+  rq   rr   s        r'   r§  zMul.as_powers_dictÚ  sX   € ÜœÓˆØ—I‘Iò 	ˆDØ×+Ñ+Ó-×3Ñ3Ó5ò ‘��1Ø�!“˜‘	”ñð	ð ˆr&   c           	     ó¼   — t        t        | j                  D �cg c]  }|j                  «       ‘Œ c}Ž «      \  }} | j                  |Ž  | j                  |Ž fS c c}w rE   )r0   rB  r-   r§   r  )rL   rÐ   ÚnumersÚdenomss       r'   r§   zMul.as_numer_denomá  sV   € ô œcÀÇ	Á	Ö#J¸1 A×$4Ñ$4Õ$6Ò#JÐKÓL‰ˆ�Øˆt�y‰y˜&Ð! 9 4§9¡9¨fÐ#5Ð5Ð5ùò $Ks   ™Ac                ó  — d }g }d}| j                   D ]f  }|j                  «       \  }}|j                  s|dz  }|€|}n*||k7  s|dkD  s|j                  s| t        j
                  fc S |j                  |«       Œh  | j                  |Ž |fS )Nr   r	   )r-   r™   r$   r›   r   r1   r4   r  )rL   rº   ÚbasesrÝ   rè   rq   rr   s          r'   r™   zMul.as_base_expè  s“   € ØˆØˆØˆØ—‘ò 	ˆAØ—=‘=“?‰DˆAˆqØ×#Ò#Ø�a‘�ØˆzØ‘Ø�b’˜B šF¨!¯,ª,ØœQŸU™U�{Ò"Ø�L‰L˜�Oð	ð ˆt�y‰y˜%Ð  "Ð$Ð$r&   c                ó@   ‡— t        ˆfd„| j                  D «       «      S )Nc              3  ó@   •K  — | ]  }|j                  ‰«      –— Œ y ­wrE   )Ú_eval_is_polynomial©rH   r+  Úsymss     €r'   rI   z*Mul._eval_is_polynomial.<locals>.<genexpr>ø  s   øè ø€ ÒH°d�4×+Ñ+¨D×1ÑHùó   ƒ©Úallr-   ©rL   rº  s    `r'   r¸  zMul._eval_is_polynomial÷  s   ø€ ÜÓH¸d¿i¹iÔHÓHÐHr&   c                ó@   ‡— t        ˆfd„| j                  D «       «      S )Nc              3  ó@   •K  — | ]  }|j                  ‰«      –— Œ y ­wrE   )Ú_eval_is_rational_functionr¹  s     €r'   rI   z1Mul._eval_is_rational_function.<locals>.<genexpr>û  s   øè ø€ ÒO¸T�4×2Ñ2°4×8ÑOùr»  r¼  r¾  s    `r'   rÁ  zMul._eval_is_rational_functionú  s   ø€ ÜÓOÀTÇYÁYÔOÓOÐOr&   c                óH   ‡‡— t        ˆˆfd„| j                  D «       d¬«      S )Nc              3  óB   •K  — | ]  }|j                  ‰‰«      –— Œ y ­wrE   )Úis_meromorphic)rH   rK  r;   rù   s     €€r'   rI   z+Mul._eval_is_meromorphic.<locals>.<genexpr>þ  s   øè ø€ ÒK¸#˜S×/Ñ/°°1×5ÑKùs   ƒT©Ú
quick_exit©r   r-   )rL   rù   r;   s    ``r'   Ú_eval_is_meromorphiczMul._eval_is_meromorphicý  s   ù€ ÜÔKÀÇÁÔKØ'+ô-ð 	-r&   c                ó@   ‡— t        ˆfd„| j                  D «       «      S )Nc              3  ó@   •K  — | ]  }|j                  ‰«      –— Œ y ­wrE   )Ú_eval_is_algebraic_exprr¹  s     €r'   rI   z.Mul._eval_is_algebraic_expr.<locals>.<genexpr>  s   øè ø€ ÒL¸$�4×/Ñ/°×5ÑLùr»  r¼  r¾  s    `r'   rË  zMul._eval_is_algebraic_expr  s   ø€ ÜÓLÀ$Ç)Á)ÔLÓLÐLr&   c                ó:   — t        d„ | j                  D «       «      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   )r$   rG   s     r'   rI   zMul.<lambda>.<locals>.<genexpr>  s   è ø€ ò 5-Øˆ×Õñ5-ùrJ   rÇ  rT   s    r'   rû   zMul.<lambda>  s   € ¬ñ 5-Ø"&§)¡)ô5-ó )-€ r&   c                óº   — t        d„ | j                  D «       «      }|du r:t        d„ | j                  D «       «      rt        d„ | j                  D «       «      ry y|S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   )Ú
is_complexrG   s     r'   rI   z'Mul._eval_is_complex.<locals>.<genexpr>  s   è ø€ Ò<¨Q˜AŸL�LÑ<ùrJ   Fc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   )Úis_infiniterG   s     r'   rI   z'Mul._eval_is_complex.<locals>.<genexpr>
  s   è ø€ Ò4 Q�1—=•=Ñ4ùrJ   c              3  ó8   K  — | ]  }|j                   d u–— Œ y­wr†   ©rŽ   rG   s     r'   rI   z'Mul._eval_is_complex.<locals>.<genexpr>  s   è ø€ ÒA°!�q—y‘y¨Ô-ÑAùó   ‚)r   r-   r–   )rL   Úcomps     r'   Ú_eval_is_complexzMul._eval_is_complex  sL   € ÜÑ<°$·)±)Ô<Ó<ˆØ�5‰=ÜÑ4¨$¯)©)Ô4Ô4ÜÑA°t·y±yÔAÔAØØØˆr&   c                óì   — dx}}| j                   D ]^  }|j                  r	|dur yd}Œ|j                  r	|dur yd}Œ-|du r|j                  €|dur yd }|du sŒJ|j                  �ŒW|dur yd }Œ` ||fS )NF)NNT)r-   rŽ   rÒ  )rL   Ú	seen_zeroÚseen_infiniter;   s       r'   Ú_eval_is_zero_infinite_helperz!Mul._eval_is_zero_infinite_helper  sŸ   € ðX %*Ð)ˆ	�Mà—‘ò 	)ˆAØ�yŠyØ ¨Ñ-Ù%Ø ‘	Ø—’Ø EÑ)Ù%Ø $‘à Ñ%¨!¯)©)Ð*;Ø$¨EÑ1Ù)Ø $�IØ  EÒ)¨a¯m©mÑ.CØ ¨Ñ-Ù)Ø$(‘Mð#	)ð& ˜-Ð'Ð'r&   c                óF   — | j                  «       \  }}|du ry|du r|du ryy ©NFT©rÛ  ©rL   rÙ  rÚ  s      r'   Ú_eval_is_zerozMul._eval_is_zeroS  s7   € ð $(×#EÑ#EÓ#GÑ ˆ	�=à˜ÑØØ˜$Ñ =°EÑ#9Øàr&   c                óF   — | j                  «       \  }}|du r|du ry|du ryy )NTFrÞ  rß  s      r'   Ú_eval_is_infinitezMul._eval_is_infinite_  s7   € ð $(×#EÑ#EÓ#GÑ ˆ	�=à˜DÑ  Y°%Ñ%7ØØ˜eÑ#Øàr&   c                óŒ   — t        d„ | j                  D «       d¬«      }|r|S |du rt        d„ | j                  D «       «      ryy y )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   )Úis_rationalrG   s     r'   rI   z(Mul._eval_is_rational.<locals>.<genexpr>o  s   è ø€ Ò;¨A˜!Ÿ-�-Ñ;ùrJ   TrÅ  Fc              3  ó8   K  — | ]  }|j                   d u –— Œ y­wr†   rÔ  rG   s     r'   rI   z(Mul._eval_is_rational.<locals>.<genexpr>t  ó   è ø€ Ò9¨!�1—9‘9 Ô%Ñ9ùrÕ  ©r   r-   r½  ©rL   r«   s     r'   Ú_eval_is_rationalzMul._eval_is_rationaln  sF   € ÜÑ;°·±Ô;ÈÔMˆÙØˆHØ�%‰ZäÑ9¨t¯y©yÔ9Ô9Øð :ð r&   c                óŒ   — t        d„ | j                  D «       d¬«      }|r|S |du rt        d„ | j                  D «       «      ryy y )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   )Úis_algebraicrG   s     r'   rI   z)Mul._eval_is_algebraic.<locals>.<genexpr>x  s   è ø€ Ò<¨Q˜!Ÿ.�.Ñ<ùrJ   TrÅ  Fc              3  ó8   K  — | ]  }|j                   d u –— Œ y­wr†   rÔ  rG   s     r'   rI   z)Mul._eval_is_algebraic.<locals>.<genexpr>}  rç  rÕ  rè  ré  s     r'   Ú_eval_is_algebraiczMul._eval_is_algebraicw  sF   € ÜÑ<°$·)±)Ô<ÈÔNˆÙØˆHØ�%‰ZäÑ9¨t¯y©yÔ9Ô9Øð :ð r&   c                ó  ‡— | j                  «       }|du ryg }g }d}| j                  D �]W  }d}|j                  r.t        |«      t        j
                  usŒ.|j                  |«       Œ@|j                  rd|j                  «       \  }}t        |«      t        j
                  ur|j                  |«       |t        j
                  usŒž|j                  |«       Œ°|j                  rœ|j                  «       \  }	}
|	j                  r|
j                  sdx}}|
j                  r?|j                  |t        j                  u rdnt        |t        j                  «      «       �Œ6|s|
j                  rJ ‚|
j                   rJ ‚ y  y  y  |s|syd„ }d„ }d„ }ddlmŠ |s|rt'        ˆfd	„|D «       «      ry|ry  ||«      r	 ||«      ry ||«      r|dgk(  ry ||«      r! ||«      rt)        |d
diŽdz
  j                  ryt+        |«      dk(  rq|d   }|j,                  r`|j.                  rTt1        |D �cg c]!  }|j.                  r|j                  «       d   ‘Œ# c}Ž t3        |j4                  «      z
  j6                  ryt+        |«      dk(  rt|d   }|j,                  rb|j.                  rUt1        |D �cg c]!  }|j.                  r|j                  «       d   ‘Œ# c}Ž t3        |j4                  «      z
  j                  ryy y y y c c}w c c}w )NFTrb   c                ó&   — t        d„ | D «       «      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   )Úis_oddr¢  s     r'   rI   z9Mul._eval_is_integer.<locals>.<lambda>.<locals>.<genexpr>¬  s   è ø€ Ò3¨A˜qŸx�xÑ3ùrJ   ©r½  ©rù   s    r'   rû   z&Mul._eval_is_integer.<locals>.<lambda>¬  s   € œ3Ñ3°Ô3Ó3€ r&   c                ó&   — t        d„ | D «       «      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   ©Úis_evenr¢  s     r'   rI   z9Mul._eval_is_integer.<locals>.<lambda>.<locals>.<genexpr>­  ó   è ø€ Ò5¨a §	¥	Ñ5ùrJ   rô  rõ  s    r'   rû   z&Mul._eval_is_integer.<locals>.<lambda>­  ó   € œCÑ5°1Ô5Ó5€ r&   c                ó&   — t        d„ | D «       «      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   rø  r¢  s     r'   rI   z9Mul._eval_is_integer.<locals>.<lambda>.<locals>.<genexpr>®  rú  rJ   )r–   rõ  s    r'   rû   z&Mul._eval_is_integer.<locals>.<lambda>®  rû  r&   r	   )Úis_gtc              3  óL   •K  — | ]  } ‰|t         j                  «      –— Œ y ­wrE   )r   r1   )rH   rh   rþ  s     €r'   rI   z'Mul._eval_is_integer.<locals>.<genexpr>±  s    øè ø€ ò 37Ø$%‘�aœŸ™—ñ37ùó   ƒ!$rO   r   )rê  r-   rŸ   rØ   r   r1   r4   r�   r§   rš   r™   r�   r˜   rœ   r]   rž   rŽ   Ú
relationalrþ  r½  r6   rŒ   r›   rù  rn   r   r£   Úis_nonnegative)rL   rå  Ú
numeratorsÚdenominatorsÚunknownr;   ÚhitrÎ   rs   rq   rr   ÚalloddÚallevenÚanyevenr¿   rþ  s                  @r'   Ú_eval_is_integerzMul._eval_is_integerƒ  sÑ  ø€ Ø×,Ñ,Ó.ˆØ˜%ÑØàˆ
ØˆØˆØ—‘ó 	ˆAØˆCØ�|Š|Ü�q“6¤§¡Ò&Ø×%Ñ% aÕ(Ø—’Ø×'Ñ'Ó)‘��1Ü�q“6¤§¡Ñ&Ø×%Ñ% aÔ(ØœAŸE™E’>Ø ×'Ñ'¨Õ*Ø—’Ø—}‘}“‘��1Ø—|’|¨1¯<ª<Ø$(Ð(�C˜'Ø—=’=Ø ×'Ñ'¨Q´!·&±&©[©Ü˜AœqŸ}™}Ó-ö/áà Ÿ}š}Ð,Ð,à ŸyšyÐ(˜=Ùñ áð9	ñ< ¡GØá3ˆÙ5ˆÙ5ˆå%Ù™l¬só 37Ø)5ô37ô 07àÙØÙ�JÔ¡G¨LÔ$9ØÙ�ZÔ  \°a°SÒ%8ØÙ�ZÔ ¡V¨Lô &Ü˜LÐ9°5Ñ9¸AÑ=ß‘+ðàÜˆ|Ó Ò!Ø˜Q‘ˆAØ�|Š| §	¢	ô Ø"ö1°Ø&'§i¢ið Ÿ-™-›/¨!Ó,ò 1ð 2Ü4<¸Q¿S¹S³MñBç(™.ð)ð  Üˆz‹?˜aÒØ˜1‘ˆAØ�|Š| §	¢	ô Ø$ö3°Ø()¯	ª	ð Ÿ-™-›/¨!Ó,ò 3ð 4Ü6>¸q¿s¹s³mñDç%™+ð&ð !ð&ð !*ˆ|ð  ùò	1ùò3s   È1&K?Ê0&Lc                óz   — t        d„ | j                  D «       «      }|xr t        d„ | j                  D «       «      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   )Úis_polar©rH   rK  s     r'   rI   z%Mul._eval_is_polar.<locals>.<genexpr>Ò  s   è ø€ Ò:¨˜Ÿ�Ñ:ùrJ   c              3  óP   K  — | ]  }|j                   xs |j                  –— Œ  y ­wrE   )r  rž   r  s     r'   rI   z%Mul._eval_is_polar.<locals>.<genexpr>Ô  s    è ø€ ÒE°C�—‘Ò/ §¡Ó/ÑEùr£  )r–   r-   r½  )rL   Ú	has_polars     r'   Ú_eval_is_polarzMul._eval_is_polarÑ  s7   € ÜÑ:°·	±	Ô:Ó:ˆ	Øò FÜÑE¸4¿9¹9ÔEÓEð	Fr&   c                ó$   — | j                  d«      S ©NT)Ú_eval_real_imagrT   s    r'   Ú_eval_is_extended_realzMul._eval_is_extended_realÖ  s   € Ø×#Ñ# DÓ)Ð)r&   c                óî  — d}d }| j                   D ]°  }|j                  xs |j                  du r|j                  du r y|j                  r| }Œ?|j                  r;|rŒN|j
                  }|s|du r|}Œc|sŒft        d„ | j                   D «       «      r y y |j                  du r|r y |}Œ›|j                  du r|r y |}Œ° y  |r&|j                  du r|r|S |j                  du r|s|S y y |du r|S |r|S y )NFc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   r‡   rG   s     r'   rI   z&Mul._eval_real_imag.<locals>.<genexpr>è  s   è ø€ Ò>¨q˜qŸ{�{Ñ>ùrJ   T)r-   rÐ  rÒ  r¨   rÖ   rŽ   r½  )rL   ÚrealÚzeroÚt_not_re_imrw   Úzs         r'   r  zMul._eval_real_imagÙ  s  € ØˆØˆà—‘ò 	ˆAØ—‘Ò- §¡°%Ñ7¸A×<NÑ<NÐRWÑ<WÙØ—’Ø�x‘Ø×#Ò#ÚØŸ	™	�AÙ ¨¡Ø ™ÚÜÑ>°D·I±IÔ>Ô>Ù#'ÙØ×#Ñ# uÑ,áÙØ‘Ø—‘ 5Ñ(ÙÙØ‘áð1	ñ4 Ø×+Ñ+¨uÑ4ÙØ�KØ×'Ñ'¨5Ñ0ÙØ�Kð ð 1ð �U‰]ØˆKÙØˆKð r&   c                ó^   — t        d„ | j                  D «       «      r| j                  d«      S y )Nc              3  óT   K  — | ]   }|j                   d u xr |j                  –— Œ" y­wr†   )rŽ   rˆ   rG   s     r'   rI   z)Mul._eval_is_imaginary.<locals>.<genexpr>  s%   è ø€ ÒE°aˆq�y‰y˜EÐ!Ò1 a§k¡kÓ1ÑEùs   ‚&(F)r½  r-   r  rT   s    r'   Ú_eval_is_imaginaryzMul._eval_is_imaginary  s+   € ÜÑE¸4¿9¹9ÔEÔEØ×'Ñ'¨Ó.Ð.ð Fr&   c                ó$   — | j                  d«      S r  ©Ú_eval_herm_antihermrT   s    r'   Ú_eval_is_hermitianzMul._eval_is_hermitian  s   € Ø×'Ñ'¨Ó-Ð-r&   c                ó$   — | j                  d«      S ©NFr   rT   s    r'   Ú_eval_is_antihermitianzMul._eval_is_antihermitian
  s   € Ø×'Ñ'¨Ó.Ð.r&   c                óÔ   — | j                   D ]:  }|j                  �|j                  € y |j                  rŒ*|j                  r| }Œ: y  |dur|S | j                  «       }|ry|du r|S y rÝ  )r-   Úis_hermitianÚis_antihermitianrà  )rL   Úhermrw   rŽ   s       r'   r!  zMul._eval_herm_antiherm  s   € Ø—‘ò 	ˆAØ�~‰~Ð%¨×);Ñ);Ð)CÙØ�~Š~ØØ×#Ò#Ø�x‘áð	ð �uÑØˆKà×$Ñ$Ó&ˆÙØØ˜ÑØˆKð r&   c                óü   — | j                   D ]P  }|j                  }|r<t        | j                   «      }|j                  |«       t	        d„ |D «       «      r y y |�ŒP y  t	        d„ | j                   D «       «      ryy )Nc              3  óf   K  — | ])  }|j                   xr t        |j                  «      d u –— Œ+ y­w)TN)rå  r   rŽ   ©rH   rù   s     r'   rI   z*Mul._eval_is_irrational.<locals>.<genexpr>'  s'   è ø€ ÒXÈA˜Ÿ™Ò>¬)°A·I±IÓ*>À4ÔGÑXùs   ‚/1Tc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   )Úis_realr,  s     r'   rI   z*Mul._eval_is_irrational.<locals>.<genexpr>,  s   è ø€ Ò,˜Qˆq�y�yÑ,ùrJ   F)r-   Úis_irrationalr0   Úremover½  )rL   rw   r;   Úotherss       r'   Ú_eval_is_irrationalzMul._eval_is_irrational!  ss   € Ø—‘ò 		ˆAØ—‘ˆAÙÜ˜dŸi™i›�Ø—‘˜aÔ ÜÑXÐQWÔXÔXÙÙØ‰yÙð		ô Ñ, $§)¡)Ô,Ô,Øð -r&   c                ó$   — | j                  d«      S )a‹  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_negrT   s    r'   Ú_eval_is_extended_positivezMul._eval_is_extended_positive/  s   € ð  ×!Ñ! !Ó$Ð$r&   c                ó†  — dx}}| j                   D ]š  }|j                  rŒ|j                  r| }Œ |j                  r t	        d„ | j                   D «       «      r y y |j
                  r| }d}Œ^|j                  rd}Œm|j                  du r
| }|r y d}Œ…|j                  du r|r y d}Œš y  |dk(  r	|du r|du ry|dk  ryy )NFc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrE   r‡   rG   s     r'   rI   z$Mul._eval_pos_neg.<locals>.<genexpr>I  s   è ø€ Ò6 q�q—{•{Ñ6ùrJ   Tr	   r   )	r-   r~   rV   rŽ   r½  Úis_extended_nonpositiveÚis_extended_nonnegativerž   r�   )rL   rÕ   Úsaw_NONÚsaw_NOTrw   s        r'   r5  zMul._eval_pos_negA  sà   € Ø!Ð!ˆ�'Ø—‘ò 	ˆAØ×%Ò%ØØ×'Ò'Ø�u‘Ø—’ÜÑ6¨D¯I©IÔ6Ô6Ù ÙØ×*Ò*Ø�u�Ø‘Ø×*Ò*Ø‘ð —‘ %Ñ'Ø�u�ÙÙØ‘Ø—‘ %Ñ'ÙÙØ‘áð7	ð8 �1Š9˜ EÑ)¨g¸Ñ.>ØØ�!Š8Øð r&   c                ó$   — | j                  d«      S r|   r4  rT   s    r'   Ú_eval_is_extended_negativezMul._eval_is_extended_negatived  s   € Ø×!Ñ! "Ó%Ð%r&   c                ó6  — | j                  «       }|dur|S ddlm}  || «      \  }}|j                  rt|j                  rht        t        j                  |«      D �cg c]!  }|j                  r|j                  «       d   ‘Œ# c}Ž t        |j                  «      z
  j                  ryy d\  }}| j                  D ]X  }t        |«      t        j                  u rŒ|j                  r y|du rn%|dk7  r||z   j                   rd}n|j                  €d }|}ŒZ |S c c}w )NTr   r!  r	   F)Tr	   )r
  r%  r"  r›   rù  rn   r6   rd   r™   r   r£   rž   r-   rØ   r   r1   ró  )	rL   rŸ   r"  rÎ   rs   r¿   r«   Úaccrw   s	            r'   Ú_eval_is_oddzMul._eval_is_oddg  s  € Ø×*Ñ*Ó,ˆ
Ø˜TÑ!ØÐå3Ù˜‹~‰ˆˆ1Ø�<Š<˜AŸIšIô Ü—M‘M !Ó$ö3¨QØ()¯	ª	ð —m‘m“o aÓ(ò 3ð 4Ü6>¸q¿s¹s³mñDç!‘kð"ð ØØ‰ˆˆ3Ø—‘ò 	ˆAÜ�1‹vœŸ™‰ØØ�yŠyÙØ�E‰zØØ˜’˜s Q™w×.Ò.Ø‘Ø—‘Ð"Ø�Ø‰Cð	ð ˆùò%3s   Á&Dc                ó2  — ddl m}  || «      \  }}|j                  ru|j                  rht	        t
        j                  |«      D �cg c]!  }|j                  r|j                  «       d   ‘Œ# c}Ž t        |j                  «      z
  j                  ryy y y c c}w )Nr   r!  r	   F)r%  r"  r›   rù  rn   r6   rd   r™   r   r£   r  )rL   r"  rÎ   rs   r¿   s        r'   Ú_eval_is_evenzMul._eval_is_even…  sŠ   € Ý3Ù˜‹~‰ˆˆ1Ø�<Š<˜AŸIšIô Ü—M‘M !Ó$ö3¨QØ()¯	ª	ð —m‘m“o aÓ(ò 3ð 4Ü6>¸q¿s¹s³mñDç$‘nð%ð ð%ð	 &ˆ<ùò3s   Á&Bc                ó”   — d}| j                   D ]1  }|j                  r|j                  s y|dz
  j                  sŒ-|dz  }Œ3 |dkD  ryy)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)r-   rŸ   rž   )rL   Únumber_of_argsrK  s      r'   Ú_eval_is_compositezMul._eval_is_composite‘  sU   € ð ˆØ—9‘9ò 	$ˆCØ—N’N s§¢ÙØ�A‘×"Ó"Ø !Ñ#‘ð		$ð ˜AÒØð r&   c           	     ó<  ‡(‡)‡*‡+‡,— ddl mŠ, ddlm} ddlmŠ+ ddlm} |j                  sy |j                  d   j                  rR|j                  d   dk  r@| j                  d   j                  r'| j                  d   dk  r| j                  | | «      S y d„ Š(ˆ(ˆ+fd„}ˆ(fd„}d	„ }d } || «      \  }	}
| }|
t        j                  urJ|	j                  ||«      |
j                  ||«      z  }|j                  s|j                  ||«      S || k7  r|}|j                  d   }|j                  d   }d }|j                  r#|j                  r||k7  r |j                  |«      }n|j                  r|S  ||«      \  Š)} ||«      \  Š*}|rf|j                  rZt!        |«      d
k7  rLt         |t!        |«      |«      «      }‰)j#                  |«       |‰)v r‰)|xx   |z  cc<   n|‰)|<   |||z  z  }nd
}d}t%        |«      t%        |«      kD  rd}nŽt%        ‰*«      t%        ‰)«      kD  rd}nt|D �ch c]  }|d   ’Œ	 c}j'                  |D �ch c]  }|d   ’Œ	 c}«      rd}n>t)        ‰*«      j'                  t)        ‰)«      «      rd}nt+        ˆ)ˆ*ˆ,fd„‰*D «       «      rd}|s|S ‰*sd }nKg }‰*j-                  «       D ]+  \  }}‰)|   }|j/                   |||«      «       |d   rŒ)|c S  t1        |«      }|s(d }t3        t%        |«      «      D ]  } |||   Ž ||<   Œ �nRd}t%        |«      }|xs t        j4                  }g }d}|�rà||z   t%        |«      k  �rÎd}g }t3        |«      D ]£  }|||z      d   ||   d   k7  r �nx|dk(  r(|j/                   ||||z      d
   ||   d
   «      «       nX||d
z
  k(  r(|j/                   ||||z      d
   ||   d
   «      «       n(|||z      d
   ||   d
   k7  r �n|j/                  d
«       |d
z  }Œ¥ t1        |«      } | rß|d
k(  r@|rt1        || «      } t7        || «       |||   d   ||   d
   | |d   d
   z  z
  «      z  ||<   nŽd
}  |||   d   ||   d
   | |d   d
   z  z
  «      }!|}"||z   d
z
  }#||#   d   ||#   d
   | |d   d
   z  z
  f}$|$d
   r4||z   t%        |«      k  r|!|"z  |$g||||z    n! ||$Ž }$|!|"z  |$z  g||||z    n|!|"z  g||||z    || z  }|| z  }d}|s|j/                  |«       |d
z  }|r||z   t%        |«      k  r�ŒÎ|s|S |j9                  t3        |t%        |«      «      «       |D ]  } |||   Ž j;                  ||«      ||<   Œ |€|}%n|€|}%nt1        ||«      }%g }&‰)D ]X  }|‰*v r'‰)|   ‰*|   |%z  z
  }'|&j/                   |||'«      «       Œ.|&j/                   ||j;                  ||«      ‰)|   «      «       ŒZ |r|st7        ||«      g|&z   }&| |j<                  |&Ž z   |j<                  |Ž z  S c c}w c c}w )Nr   rÔ   )Úmultiplicity)Ú	powdenestr!  c                ó‚   — ddl m} | j                  st        | |«      r| j	                  «       S | t
        j                  fS )Nr   )rl  )Ú&sympy.functions.elementary.exponentialrl  rš   r„   r™   r   r1   )r;   rl  s     r'   Úbase_expz Mul._eval_subs.<locals>.base_exp²  s1   € õ CØ�xŠxœ: a¨Ô-Ø—}‘}“Ð&Ø”a—e‘e�8ˆOr&   c                óN  •— t        t        «      g }}t        j                  | «      D ]x  } ‰	|«      } ‰|«      \  }}|t        j
                  ur$|j                  «       \  }}t        |||z  «      }|}|j                  r||xx   |z  cc<   Œf|j                  ||g«       Œz ||fS )zýbreak 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@  r6   rd   r   r1   r[   rœ   r$   r4   )
ÚeqrW   rÝ   r;   rq   rr   r:   rh   rL  rI  s
           €€r'   ÚbreakupzMul._eval_subs.<locals>.breakup»  s¡   ø€ ô #¤3Ó'¨�ˆQÜ—]‘] 2Ó&ò 
&�Ù˜a“L�Ù! !›‘��AØœAŸE™E‘>ØŸn™nÓ.‘G�R˜Ü˜A˜q ™t›�AØ�AØ×#Ò#Ø�a“D˜A‘I”Dà—I‘I˜q !˜fÕ%ð
&ð �r�7ˆNr&   c                ó8   •—  ‰| «      \  } }t        | ||z  «      S )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œ   )rq   r:   rr   rL  s      €r'   ÚrejoinzMul._eval_subs.<locals>.rejoinÐ  s"   ø€ ñ ˜a“[‰FˆQ�Ü�q˜!˜B™$“<Ðr&   c                ó„   — |j                   | j                   z  r| j                   |j                   z  st        | |z  «      S y)zÒif 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;   rq   s     r'   ÚndivzMul._eval_subs.<locals>.ndivÚ  s1   € ð
 —3‘3˜Ÿ™’9 A§C¡C¨!¯#©#¢IÜ˜1˜Q™3“x�Ør&   r	   TFc              3  óL   •K  — | ]  } ‰‰|   «       ‰‰|   «      k7  –— Œ y ­wrE   r%   )rH   rq   rW   Úold_crÕ   s     €€€r'   rI   z!Mul._eval_subs.<locals>.<genexpr>$  s&   øè ø€ Ò=°!‘�a˜‘d“™t E¨!¡H›~Õ-Ñ=ùr   r}   )rÙ   rÕ   Úsympy.ntheory.factor_rH  Úsympy.simplify.powsimprI  r%  r"  r!   r-   r"   Ú_subsr   r1   r�   Úextract_multiplicativelyrØ   r    rŒ   Ú
differenceÚsetr–   rm   r4   Úminr¡   rf   rœ   r3   rS  r  )-rL   rd  ÚnewrH  r"  rO  rR  rT  rª   rÎ   rs   Úself2Úco_selfÚco_oldÚco_xmulrÝ   Úold_ncr—  Úco_residualÚokr¿   ÚcdidÚratrq   Úold_eÚc_eÚncdidÚtakeÚlimitÚfailedr  rÉ   ÚndorN  ÚmidÚirr«   ÚdoÚmargsrr   rL  rW   rV  rI  rÕ   s-                                           @@@@@r'   Ú
_eval_subszMul._eval_subs¢  s¹  ü€ Ý=Ý6Ý4Ý3à�zŠzØð �8‰8�A‰;× Ò  S§X¡X¨a¡[°1¢_Ø�y‰y˜‰|×%Ò%Ø—9‘9˜Q‘< !Ò#ØŸ:™: s d¨S¨DÓ1Ð1Øò	õ	ô*	 ò	ð ˆÙ˜‹~‰ˆˆ1ØˆØ”A—E‘E‰>Ø—G‘G˜C Ó% a§g¡g¨c°3Ó&7Ñ7ˆEØ—<’<Ø—{‘{ 3¨Ó,Ð,Ø˜Š}Ø�ð —*‘*˜Q‘-ˆØ—‘˜!‘ˆØˆØ×Ò '×"5Ò"5ð ˜Ò Ø!×:Ñ:¸6ÓB‘Ø×ÒØˆIñ ˜%“.‰ˆˆBÙ! #›,‰ˆ�ñ �w×*Ò*¬s°6«{¸aÒ/?Ü‘\¤# f£+¨wÓ7Ó8ˆDØ�E‰E�'ŒNØ˜‰{Ø�&“	˜TÑ!”	à ��&‘	Ø! &¨$¡,Ñ.‰KàˆKð ˆÜˆv‹;œ˜R›Ò à‰BÜ�‹Zœ#˜a›&Ò à‰BØ"Ö#�qˆa�‹dÒ#×.Ñ.¸bÖ/A¸°°!³Ò/AÔBà‰BÜ�‹Z×"Ñ"¤3 q£6Ô*à‰BÜÕ=°uÔ=Ô=àˆBÙØˆIáØ‰DàˆCØ#Ÿk™k›mò ‘
��EØ˜‘d�Ø—
‘
™4  UÓ+Ô,Ø˜2“wØ’Ið	ô
 �s“8ˆDáØˆEÜœ3˜r›7“^ò '�Ù  1¡˜��1’ò'ð ˆEÜ�v“;ˆDØÒ&œAŸJ™JˆEØˆFØˆAÚ˜A ™H¬¨B«Ó/Ø�ð �Ü˜t›ò 3#�AØ˜!˜a™%‘y ‘| v¨a¡y°¡|Ò3ÚØ˜ašØŸ
™
¡4¨¨1¨q©5©	°!©°f¸Q±iÀ±lÓ#CÕDØ˜d Q™hšØŸ
™
¡4¨¨1¨q©5©	°!©°f¸Q±iÀ±lÓ#CÕDØ˜A ™E™ 1™¨°©°1©Ò5ÚàŸ
™
 1œØ˜‘F‘Að3#ô ˜c›(�CÙØ 1š9Ù#Ü&)¨$°£n Ü$'¨¨S£M±&¸¸A¹¸q¹Ø$& q¡E¨!¡H¨s°6¸!±9¸Q±<Ñ/?Ñ$?ó3Añ %A˜B˜qšEð #$˜Cñ !' r¨!¡u¨Q¡x°°A±°q±¸CØ$*¨1¡I¨a¡Lñ=1ñ 21ó !2˜Að
 #&˜Cð "# T¡¨A¡˜BØ!# B¡¨¡¨B¨r©F°1©I¸Ø!'¨¡¨A¡ñ9/ñ -/ð !0˜Aà  štØ#$ t¡8¬c°"«gÒ#5Ø67¸±e¸Q°Z B q¨¨T©¡Ná(.°¨
 AØ67¸±e¸A±g°Y B q¨¨T©¡Nð
 34°C±%°  1 Q¨¡X à ™˜Ø ™˜Ø"˜Ùð —M‘M !Ô$Ø�Q‘�ñC ˜A ™H¬¨B«Ô/ñH Ø�Ið —‘œe A¤s¨2£wÓ/Ô0Øò :�AÙ" B q¡E˜N×/Ñ/°°SÓ9�B�q’Eð:ð
 ˆ<Ø‰BØˆ]Ø‰Bä�U˜DÓ!ˆBàˆØò 	=ˆAØ�E‰zð �a‘D˜5 ™8 B™;Ñ&�Ø—‘™V A q›\Õ*à—‘™V A§F¡F¨3°Ó$4°a¸±dÓ;Õ<ð	=ñ ™ô ˜˜d“^Ð$ uÑ,ˆEØ˜:˜5Ÿ:™: uÐ-Ñ-¨j¨e¯j©j¸"¨oÑ=Ð=ùòU $ùÒ/As   È)XÉXc                óF  ‡ — ddl m} ddlm} ddlm} d„ }g }		 | j                  D ]@  }
|
j                  |«      \  }}|j                  |«      s|	j                  |
|f«       Œ<t        ‚ t        d„ |	D «       «      }g }|	D ]f  \  }
} |||z
  |j                  r|ndz   «      }|
j                  ||||¬«      }|j                  «       }|�||k  r|||z
  z  }|j                  |«       Œh 	 t&        j(                  }|D �cg c]  }t3        j4                  |«      ‘Œ }}t7        |Ž D ]O  }|D �cg c]  } |||«      ‘Œ }}t9        |Ž \  }}t        |«      }||z
  j:                  sŒ?|t=        |Ž ||z  z  z  }ŒQ ˆ fd„Š | j?                  |«      r=ddl m!} ddl"m#} 	  ‰ | |«      |k\  s || |«       |||«      k7  r| |||z  |«      z  }|S || k7  rc| |z
  jI                  |d«      t&        j(                  k(  r.|dkD  r)| jK                  |||¬«      }|t&        j(                  k(  r|S | |||z  |«      z  }|S # t        t        t         |f$ rÃ t#        t        d	„ |	D «       «      «      }|j$                  rt&        j(                  }| j                  D �
cg c]   }
|
j                  | |||z
  «      ||¬«      ‘Œ" nc c}
w }}
dd
lm}  | | j.                  |Ž j1                  «       dd¬«      }|j                  |«      r| |||z  |«      z  }|cY S w xY wc c}w c c}w # |$ r Y �ŒWw xY w)Nr	   )Ú	PoleErrorr   )Úceiling)ÚOrderc                óº   — | j                  |«      }|d   j                  |«      r	 | j                  |«      }|S |S # t        $ r | t        j
                  fcY S w xY wrZ   )Úas_coeff_exponentrø   ÚleadtermÚ
ValueErrorr   r’   )r+  rù   Últs      r'   Ú	coeff_expz$Mul._eval_nseries.<locals>.coeff_exp¯  s^   € Ø×'Ñ'¨Ó*ˆBØ�!‰u�y‰y˜Œ|ð(ØŸ™ qÓ)�Bð ˆI�2ˆIøô "ò (Ø¤§¡˜<Ò'ð(ús   §< ¼AÁAc              3  óF   K  — | ]  }|d    j                   sŒ|d    –— Œ y­w©r	   N©rå   ©rH   rw   s     r'   rI   z$Mul._eval_nseries.<locals>.<genexpr>Â  s   è ø€ Ò:˜a¨1¨Q©4¯>«>�Q�q•TÑ:ùó   ‚!—
!)rÎ   ÚlogxÚcdirc              3  óF   K  — | ]  }|d    j                   sŒ|d    –— Œ y­wr  r€  r�  s     r'   rI   z$Mul._eval_nseries.<locals>.<genexpr>Ñ  s   è ø€ ÒB a°1°Q±4·>³>˜Q˜q�TÑBùr‚  )Úpowsimprl  T)Úcombiner  c           	     ó¤  •‡— | ‰u rt         j                  S | j                  rt         j                  S | j                  rt        ˆˆfd„| j                  D «       «      S | j                  r't        | j                  D �cg c]  } ‰|‰«      ‘Œ c}Ž S | j                  r  ‰| j                  ‰«      | j                  z  S t         j                  S c c}w )Nc              3  ó0   •K  — | ]  } ‰|‰«      –— Œ y ­wrE   r%   )rH   r;   Ú
max_degreerù   s     €€r'   rI   z8Mul._eval_nseries.<locals>.max_degree.<locals>.<genexpr>ë  s   øè ø€ Ò<°™: a¨×+Ñ<ùs   ƒ)r   r1   Úis_Atomr’   r�   Úmaxr-   r!   rn   rš   rm  rl  )rr   rù   r;   rŠ  s    ` €r'   rŠ  z%Mul._eval_nseries.<locals>.max_degreeå  s–   ù€ Ø�A‰vÜ—u‘u�Ø�yŠyÜ—v‘v�Ø�xŠxÜÔ<°Q·V±VÔ<Ó<Ð<Ø�xŠxÜ°q·v±vÖ>°!™Z¨¨1Õ-Ò>Ð?Ð?Ø�xŠxÙ! !§&¡&¨!Ó,¨Q¯U©UÑ2Ð2Ü—6‘6ˆMùò ?s   Á=C)ÚPolynomialError)Údegree©rƒ  r„  )&r  ru  Ú#sympy.functions.elementary.integersrv  Úsympy.series.orderrw  r-   rz  rø   r4   r{  rF  rå   ÚnseriesÚgetnÚNotImplementedErrorÚ	TypeErrorr
   r  r   r’   rX  r†  r  ræ   rn   rd   r   rB  r�   r6   Úis_polynomialÚsympy.polys.polyerrorsr�  Úsympy.polys.polytoolsrŽ  rS  Ú_eval_as_leading_term)!rL   rù   rÎ   rƒ  r„  ru  rv  rw  r}  Úordsrw   r²   rl  Ún0Úfacsrè   Ún1r1  Únsr†  Úresr*  Úords2Úfacr+  Úords3ÚcoeffsÚpowersÚpowerr�  rŽ  r|  rŠ  s!                                   @r'   Ú_eval_nserieszMul._eval_nseriesª  s!  ø€ Ý'Ý?Ý,ò	ð ˆð	Ø—Y‘Yò %�ØŸZ™Z¨›]‘
��sØ—y‘y ”|Ø—K‘K  C Õ)ä$Ð$ð%ô Ñ: 4Ô:Ó:ˆBØˆDØò ‘��1Ù˜Q ™V¨A¯KªK¡q¸QÑ?Ó@�Ø—I‘I˜a 2¨D°t�IÓ<�Ø—V‘V“X�Ø�>Ø˜B’wØ˜R "™W™˜Ø—‘˜A•ñô. �f‰fˆØ59Ö:¨6”—‘˜vÕ&Ð:ˆÐ:ä˜E�?ò 	/ˆCØ47Ö8¨D‘Y˜t QÕ'Ð8ˆEÐ8Ü  %˜[‰NˆF�FÜ˜“KˆEØ˜‘	×&Ó&Ø”s˜F�| Q¨¡XÑ.Ñ.‘ð	/ô	ð ×Ñ˜aÔ Ý>Ý4ðÙ˜d AÓ&¨!Ò+©v°d¸A«Á&ÈÈaÃ.Ò/PØ™5  A¡ q›>Ñ)�Cð �
à�$Š;Ø�s‘
× Ñ   AÓ&¬!¯&©&Ò0°Q¸²UØ×/Ñ/°¸À4Ð/ÓH�ØœŸ™’<Ø�JØ‘5˜˜A™˜q“>Ñ!ˆCØˆ
øôm Ô/´¸IÐFò 	ô œÑB¨4ÔBÓBÓCˆBØ× Ò Ü—V‘V�ØQU×QZÑQZÖ[ÈA�A—I‘I˜a¡7¨1¨R©4£=°tÀ$�IÕGÑ[ùÒ[ˆDÐ[Ý6Ù˜)˜$Ÿ)™) TÐ*×1Ñ1Ó3¸UÈÔNˆCØ�w‰w�uŒ~Ø‘u˜Q ™T 1“~Ñ%�ØŠJð	üò ;ùò 9øð2 #ò Úðús>   šCH2 Ã=LÄ*LÆ.L È2AL
Ê%J2Ê1AL
Ì	L
ÌL ÌL c           
     ó~   —  | j                   | j                  D �cg c]  }|j                  |||¬«      ‘Œ c}Ž S c c}w )Nr�  )r  r-   Úas_leading_term)rL   rù   rƒ  r„  rw   s        r'   r™  zMul._eval_as_leading_term  s7   € Øˆt�y‰yÈtÏyÉyÖYÈ!˜1×,Ñ,¨Q°TÀÐ,ÕEÒYÐZÐZùÒYs   ›:c                óv   —  | j                   | j                  D �cg c]  }|j                  «       ‘Œ c}Ž S c c}w rE   )r  r-   r	  ©rL   rw   s     r'   Ú_eval_conjugatezMul._eval_conjugate  s+   € Øˆt�y‰y°$·)±)Ö<¨Q˜1Ÿ;™;�=Ò<Ð=Ð=ùÒ<s   ›6c                ó‚   —  | j                   | j                  d d d…   D �cg c]  }|j                  «       ‘Œ c}Ž S c c}w r|   )r  r-   Ú	transposerª  s     r'   Ú_eval_transposezMul._eval_transpose  s3   € Øˆt�y‰y°$·)±)¹D¸b¸D±/ÖB¨Q˜1Ÿ;™;�=ÒBÐCÐCùÒBó   ¡<c                ó‚   —  | j                   | j                  d d d…   D �cg c]  }|j                  «       ‘Œ c}Ž S c c}w r|   )r  r-   Úadjointrª  s     r'   Ú_eval_adjointzMul._eval_adjoint  s3   € Øˆt�y‰y°·	±	¹$¸B¸$±Ö@¨1˜1Ÿ9™9�;Ò@ÐAÐAùÒ@r¯  c                óè   — t         j                  }g }| j                  D ]A  }|j                  ||¬«      \  }}||z  }|t         j                  usŒ1|j	                  |«       ŒC | | j
                  |Ž fS )aU  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   r1   r-   Úas_content_primitiver4   r  )rL   r´  rµ  Úcoefr-   r;   rW   r£   s           r'   r¶  zMul.as_content_primitive  su   € ô �u‰uˆØˆØ—‘ò 	ˆAØ×)Ñ)°'ÀÐ)ÓG‰DˆAˆqØ�A‰IˆDØœŸ™Š~Ø—‘˜A•ð		ð �Y�T—Y‘Y Ð%Ð%Ð%r&   c                ó^   ‡— | j                  «       \  }}|j                  ˆfd„¬«       ||z   S )a  Transform 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                ó(   •— | j                  ‰¬«      S )N)Úorder)Úsort_key)r'  rº  s    €r'   rû   z(Mul.as_ordered_factors.<locals>.<lambda>9  s   ø€  D§M¡M¸ MÓ$>€ r&   r)   )r2   r+   )rL   rº  ÚcpartÚncparts    `  r'   Úas_ordered_factorszMul.as_ordered_factors+  s-   ø€ ð Ÿ™›‰ˆˆvØ�
‰
Ó>ˆ
Ô?Ø�v‰~Ðr&   c                ó4   — t        | j                  «       «      S rE   )rý   r¾  rT   s    r'   Ú_sorted_argszMul._sorted_args<  s   € ä�T×,Ñ,Ó.Ó/Ð/r&   )r-   zExpr | complexrO   ÚboolÚreturnr   )rÂ  ztuple[Expr, ...])F)Tr$  rE   )r   )FT)Sr   r   r   Ú__doc__Ú	__slots__r!   r   Ú
_args_typer   rK   Ú__annotations__ÚpropertyrF   r   rR   r-   rX   r^   ÚclassmethodrÑ   rÞ   râ   rä   rñ   r   rô   r[   rk   r×   Ústaticmethodr  r&  r2  r?  rX  r^  r[  rb  rc  rs  rt  r†  r‡  rZ  r§  r§   r™   r¸  rÁ  rÈ  rË  Ú_eval_is_commutativer×  rÛ  rà  râ  rê  rï  r
  r  r  r  r  r"  r%  r!  r2  r6  r5  r>  rA  rC  rF  rs  r¦  r™  r«  r®  r²  r¶  r¾  rÀ  Ú__classcell__)rO  s   @r'   r6   r6   [   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&   r6   Úmulc                ó8   — t        t        j                  | |«      S )a‹  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   ÚoperatorrÌ  )r;   Ústarts     r'   rG  rG  C  s   € ô. ”(—,‘,  5Ó)Ð)r&   c           
     óò  — | j                   s|j                   r| |} }n| |z  S |t        j                  u r| S | t        j                  u r|S | t        j                  u r|s| S |j                  rÇ|s·| j
                  r«| j                  dk7  rœ|j                  D �cg c]  }|j                  «       ‘Œ }}|D ��cg c]  \  }}t        || «      |f‘Œ }}}t        d„ |D «       «      rCt        j                  |D �cg c]$  }t        j                  |d   dk(  r|dd n|«      ‘Œ& c}«      S t        | |d¬«      S |j                  rrt        |j                  «      }|d   j                   r'|dxx   | z  cc<   |d   dk(  r$|j!                  d«       n|j#                  d| «       t        j                  |«      S | |z  }|j                   r#|j                   st        j                  | |f«      }|S c c}w c c}}w c c}w )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  ó:   K  — | ]  \  }}|j                   –— Œ y ­wrE   )r›   )rH   rW   rh   s      r'   rI   z_keep_coeff.<locals>.<genexpr>‡  s   è ø€ Ò1¡D A q�1—<•<Ñ1ùr‰   r   NFrN   )r"   r   r1   r]   r�   r�   r¢   r-   rk   r‘   r–   rn   r7   r6   r!   r0   r    r5   )	r²   Úfactorsrµ  rÕ   r¿   r-   rW   rè   rr  s	            r'   r‘   r‘   ]  s¼  € ð6 �?Š?Ø×ÒØ" G�U‰Gà˜‘=Ð Ø”!—%‘%ÑØˆØ”—‘�~ØˆØ	”!—-‘-Ñ	©ØˆxˆØ	�ŠÙ˜×*Ò*¨u¯w©w¸!ª|Ø.5¯l©lÖ;¨�A—N‘NÕ$Ð;ˆDÐ;Ø;?×@±4°1°a”[  EÓ*¨AÒ.Ð@ˆDÑ@ÜÑ1¨DÔ1Ô1Ü—~‘~Ø8<ö'>Ø34ô (+§~¡~Ø˜q™T QšY�A�a�b‘E¨Aõ(/ò '>ó ?ð ?ä�5˜'¨EÔ2Ð2Ø	�ŠÜ�W—\‘\Ó"ˆØ�‰8×ÒØ�!‹H˜Ñ‹HØ�Q‰x˜1Š}Ø—	‘	˜!•à�L‰L˜˜EÔ"Ü�~‰~˜eÓ$Ð$à�'‰MˆØ�;Š;˜w×0Ò0Ü—‘  wÐ/Ó0ˆAØˆùò' <ùÛ@ùò'>s   ÂG)Â7G.Ã7)G4c                ó    — d„ }t        | |«      S )Nc                óÄ   — | j                   rN| j                  «       \  }}|j                  r/|j                  r#t	        |j
                  D �cg c]  }||z  ‘Œ	 c}Ž S | S c c}w rE   )r!   rk   r"   r�   Ú_unevaluated_Addr-   )rr   rW   r«   Úris       r'   rq  zexpand_2arg.<locals>.do›  sO   € Ø�8Š8Ø—>‘>Ó#‰DˆAˆqØ�{Š{˜qŸxšxÜ'¸¿¹Ö)@°2¨!¨B«$Ò)@ÐAÐAØˆùò *As   ÁAr   )rr   rq  s     r'   Úexpand_2argr×  š  s   € òô �Q˜ÓÐr&   )r¥   rQ  )rn   rÕ  )r	   )TF)6Ú
__future__r   Útypingr   r   Úcollectionsr   Ú	functoolsr   Ú	itertoolsr   rÎ  r
   Úbasicr   r   Ú	singletonr   Ú
operationsr   r   Úcacher   Úintfuncr   r   Úlogicr   r   r'  r   Ú
parametersr   rF   r   Ú	traversalr   Úsympy.utilities.iterablesr   r   r.   r>   r6   rÌ  rG  r‘   r×  rì   r¥   r¥  rœ   Úaddrn   rÕ  r%   r&   r'   ú<module>rç     s‹   ðÝ "ß *å #Ý Ý Û å ß 'Ý ß 2Ý ß .ß *Ý Ý )Ý  Ý  Ý *÷
ñ ò!ò
1(ôhc0ˆ$�ô c0ñJ? ˜Ó€ó*ó4;òzõ Ý ß &Ð &r&   