Ë
    7^(hP£  ã                   óˆ  — d Z ddlmZmZmZmZmZmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZ ddlmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ ddl,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z; ddl<m=Z=m>Z> ddl?m@Z@ ddlAmBZBmCZCmDZDmEZEmFZF d„ ZGd	„ ZHd
„ ZId„ ZJd„ ZKd„ ZLd„ ZMd„ ZNd„ ZOd„ ZPd„ ZQd„ ZRd„ ZSd@d„ZTd„ ZUd„ ZVd„ ZWd„ ZXd„ ZYd„ ZZd„ Z[d@d„Z\d„ Z]d„ Z^d „ Z_d!„ Z`d"„ Zad#„ Zbd$„ Zcd%„ Zdd&„ Zed'„ Zfd(„ Zgd)Zhd*„ Zid+„ Zjd,„ Zkd-„ Zld.„ Zmd/„ Znd0„ Zod1„ Zpd2„ Zqd3„ Zrd4„ Zsd5„ Ztd6„ Zud7„ Zvd8„ Zwd9„ Zxd:„ Zyd;„ Zzd<„ Z{dAd=„Z|dAd>„Z}y?)BzEEuclidean algorithms, GCDs, LCMs and polynomial remainder sequences. é    )Údup_sub_mulÚdup_negÚdmp_negÚdmp_addÚdmp_subÚdup_mulÚdmp_mulÚdmp_powÚdup_divÚdmp_divÚdup_remÚdup_quoÚdmp_quoÚdup_premÚdmp_premÚdup_mul_groundÚdmp_mul_groundÚdmp_mul_termÚdup_quo_groundÚdmp_quo_groundÚdup_max_normÚdmp_max_norm)Ú	dup_stripÚ	dmp_raiseÚdmp_zeroÚdmp_oneÚ
dmp_groundÚ	dmp_one_pÚ
dmp_zero_pÚ	dmp_zerosÚ
dup_degreeÚ
dmp_degreeÚdmp_degree_inÚdup_LCÚdmp_LCÚdmp_ground_LCÚdmp_multi_deflateÚdmp_inflateÚdup_convertÚdmp_convertÚdmp_apply_pairs)Údup_clear_denomsÚdmp_clear_denomsÚdup_diffÚdmp_diffÚdup_evalÚdmp_evalÚdmp_eval_inÚ	dup_truncÚdmp_ground_truncÚ	dup_monicÚdmp_ground_monicÚdup_primitiveÚdmp_ground_primitiveÚdup_extractÚdmp_ground_extract©Úgf_intÚgf_crt)Úquery)ÚMultivariatePolynomialErrorÚHeuristicGCDFailedÚHomomorphismFailedÚNotInvertibleÚDomainErrorc                 óô   — |j                   st        d|z  «      ‚|j                  gg }}|r't        | ||«      \  }}||}} |t	        ||||«      }}|rŒ't        |t        | |«      |«      }t        | |«      } || fS )ar  
    Half extended Euclidean algorithm in `F[x]`.

    Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15
    >>> g = x**3 + x**2 - 4*x - 4

    >>> R.dup_half_gcdex(f, g)
    (-1/5*x + 3/5, x + 1)

    z(Cannot compute half extended GCD over %s)Úis_FieldrC   Úoner   r   r   r$   r5   )ÚfÚgÚKÚaÚbÚqÚrs          úU/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/polys/euclidtools.pyÚdup_half_gcdexrO   2   sŒ   € ð& �:Š:ÜÐDÀqÑHÓIÐIà�E‰Eˆ7�B€q€Aá
Ü�q˜!˜QÓ‰ˆˆ1Ø�!ˆ1ˆØ”+˜a  A qÓ)ˆ1ˆò ô
 	�qœ&  A›,¨Ó*€AÜ�!�Q‹€Aàˆaˆ4€Kó    c                 ó8   — |st        | ||«      S t        | |«      ‚)z�
    Half extended Euclidean algorithm in `F[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    )rO   r?   ©rG   rH   ÚurI   s       rN   Údmp_half_gcdexrT   U   s#   € ñ Ü˜a  AÓ&Ð&ä)¨!¨QÓ/Ð/rP   c                 ób   — t        | ||«      \  }}t        ||| |«      }t        |||«      }|||fS )a  
    Extended Euclidean algorithm in `F[x]`.

    Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15
    >>> g = x**3 + x**2 - 4*x - 4

    >>> R.dup_gcdex(f, g)
    (-1/5*x + 3/5, 1/5*x**2 - 6/5*x + 2, x + 1)

    )rO   r   r   )rG   rH   rI   ÚsÚhÚFÚts          rN   Ú	dup_gcdexrZ   f   s?   € ô& ˜!˜Q Ó"�D€A€qä�A�q˜!˜QÓ€AÜ��1�aÓ€Aàˆa�ˆ7€NrP   c                 ó8   — |st        | ||«      S t        | |«      ‚)z˜
    Extended Euclidean algorithm in `F[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    )rZ   r?   rR   s       rN   Ú	dmp_gcdexr\   �   s#   € ñ Ü˜˜A˜qÓ!Ð!ä)¨!¨QÓ/Ð/rP   c                 ór   — t        | ||«      \  }}||j                  gk(  rt        |||«      S t        d«      ‚)at  
    Compute multiplicative inverse of `f` modulo `g` in `F[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = x**2 - 1
    >>> g = 2*x - 1
    >>> h = x - 1

    >>> R.dup_invert(f, g)
    -4/3

    >>> R.dup_invert(f, h)
    Traceback (most recent call last):
    ...
    NotInvertible: zero divisor

    zzero divisor)rO   rF   r   rB   )rG   rH   rI   rV   rW   s        rN   Ú
dup_invertr^   ’   s=   € ô. ˜!˜Q Ó"�D€A€qàˆQ�U‰UˆG‚|Ü�q˜!˜QÓÐä˜NÓ+Ð+rP   c                 ó8   — |st        | ||«      S t        | |«      ‚)z¨
    Compute multiplicative inverse of `f` modulo `g` in `F[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    )r^   r?   rR   s       rN   Ú
dmp_invertr`   ±   s#   € ñ Ü˜!˜Q Ó"Ð"ä)¨!¨QÓ/Ð/rP   c                 óv   — | |g}t        | ||«      }|r%|j                  |«       ||}} t        | ||«      }|rŒ%|S )an  
    Euclidean polynomial remainder sequence (PRS) in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
    >>> g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21

    >>> prs = R.dup_euclidean_prs(f, g)

    >>> prs[0]
    x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
    >>> prs[1]
    3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
    >>> prs[2]
    -5/9*x**4 + 1/9*x**2 - 1/3
    >>> prs[3]
    -117/25*x**2 - 9*x + 441/25
    >>> prs[4]
    233150/19773*x - 102500/6591
    >>> prs[5]
    -1288744821/543589225

    )r   Úappend)rG   rH   rI   ÚprsrW   s        rN   Údup_euclidean_prsrd   Â   sL   € ð: ˆaˆ&€CÜ��1�aÓ€Aá
Ø�
‰
�1ŒØ�!ˆ1ˆÜ�A�q˜!Óˆò ð
 €JrP   c                 ó8   — |st        | ||«      S t        | |«      ‚)z©
    Euclidean polynomial remainder sequence (PRS) in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    )rd   r?   rR   s       rN   Údmp_euclidean_prsrf   ê   ó#   € ñ Ü   A qÓ)Ð)ä)¨!¨QÓ/Ð/rP   c                 óª   — | |g}t        t        | ||«      |«      \  }}|r2|j                  |«       ||}} t        t        | ||«      |«      \  }}|rŒ2|S )a;  
    Primitive polynomial remainder sequence (PRS) in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
    >>> g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21

    >>> prs = R.dup_primitive_prs(f, g)

    >>> prs[0]
    x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
    >>> prs[1]
    3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
    >>> prs[2]
    -5*x**4 + x**2 - 3
    >>> prs[3]
    13*x**2 + 25*x - 49
    >>> prs[4]
    4663*x - 6150
    >>> prs[5]
    1

    )r7   r   rb   )rG   rH   rI   rc   Ú_rW   s         rN   Údup_primitive_prsrj   û   sb   € ð: ˆaˆ&€CÜœ ! Q¨Ó*¨AÓ.�D€A€qá
Ø�
‰
�1ŒØ�!ˆ1ˆÜœX a¨¨AÓ.°Ó2‰ˆˆ1ò ð
 €JrP   c                 ó8   — |st        | ||«      S t        | |«      ‚)z©
    Primitive polynomial remainder sequence (PRS) in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    )rj   r?   rR   s       rN   Údmp_primitive_prsrl   #  rg   rP   c                 ó^  — t        | «      }t        |«      }||k  r|| }} ||}}| sg g fS |s| g|j                  gfS | |g}||z
  }|j                   |dz   z  }t        | ||«      }t        |||«      }t	        ||«      }	|	|z  }
|j                  |
g}|
 }
|r•t        |«      }|j                  |«       |||||z
  f\  } }}}|	 |
|z  z  }t        | ||«      }t        |||«      }t	        ||«      }	|dkD  r|
|dz
  z  }|j                  |	 |z  |«      }
n|	 }
|j                  |
 «       |rŒ•||fS )a  
    Subresultant PRS algorithm in `K[x]`.

    Computes the subresultant polynomial remainder sequence (PRS)
    and the non-zero scalar subresultants of `f` and `g`.
    By [1] Thm. 3, these are the constants '-c' (- to optimize
    computation of sign).
    The first subdeterminant is set to 1 by convention to match
    the polynomial and the scalar subdeterminants.
    If 'deg(f) < deg(g)', the subresultants of '(g,f)' are computed.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_inner_subresultants(x**2 + 1, x**2 - 1)
    ([x**2 + 1, x**2 - 1, -2], [1, 1, 4])

    References
    ==========

    .. [1] W.S. Brown, The Subresultant PRS Algorithm.
           ACM Transaction of Mathematical Software 4 (1978) 237-249

    é   )r!   rF   r   r   r$   rb   r   Úquo)rG   rH   rI   ÚnÚmÚRÚdrK   rW   ÚlcÚcÚSÚkrL   s                 rN   Údup_inner_subresultantsrx   4  sp  € ô8 	�1‹€AÜ�1‹€Aàˆ1‚uØ�!ˆ1ˆØ�!ˆ1ˆáØ�2ˆvˆáØˆs�Q—U‘U�Gˆ|Ðà	
ˆAˆ€AØ	ˆA‰€Aà
�%‰%ˆ�1�q‘5Ñ€Aä��A�qÓ€AÜ�q˜!˜QÓ€Aä	��1‹€BØ
ˆA‰€Að 
�‰�ˆ
€AØ	
ˆ€Aá
Ü�q‹MˆØ	�‰�Œà˜˜1˜a !™e�^‰
ˆˆ1ˆa�àˆC�!�Q‘$‰Jˆä�Q˜˜1ÓˆÜ˜1˜a Ó#ˆä�A�q‹\ˆàˆqŠ5Ø�A˜‘E‘
ˆAØ—‘˜�s˜Q‘h Ó"‰Aà�ˆAà	�‰�!�Œò' ð* ˆaˆ4€KrP   c                 ó"   — t        | ||«      d   S )zò
    Computes subresultant PRS of two polynomials in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_subresultants(x**2 + 1, x**2 - 1)
    [x**2 + 1, x**2 - 1, -2]

    r   )rx   ©rG   rH   rI   s      rN   Údup_subresultantsr{   „  s   € ô # 1 a¨Ó+¨AÑ.Ð.rP   c                 ó’   — | r|s|j                   g fS t        | ||«      \  }}t        |d   «      dkD  r|j                   |fS |d   |fS )zõ
    Resultant algorithm in `K[x]` using subresultant PRS.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_prs_resultant(x**2 + 1, x**2 - 1)
    (4, [x**2 + 1, x**2 - 1, -2])

    éÿÿÿÿr   )Úzerorx   r!   )rG   rH   rI   rr   rv   s        rN   Údup_prs_resultantr   •  sU   € ñ ‘AØ—‘˜ˆ|Ðä" 1 a¨Ó+�D€A€qä�!�B‘%Ó˜1ÒØ—‘˜ˆ{ÐàˆR‰5�!ˆ8€OrP   c                 ó@   — |rt        | ||«      S t        | ||«      d   S )zÐ
    Computes resultant of two polynomials in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_resultant(x**2 + 1, x**2 - 1)
    4

    r   )r   )rG   rH   rI   Ú
includePRSs       rN   Údup_resultantr‚   ®  s*   € ñ Ü   A qÓ)Ð)Ü˜Q  1Ó% aÑ(Ð(rP   c           	      ó  — |st        | ||«      S t        | |«      }t        ||«      }||k  r|| }} ||}}t        | |«      rg g fS |dz
  }t        ||«      r| gt        |j                  |«      gfS | |g}||z
  }t        t        |j                   |«      |dz   ||«      }	t        | |||«      }
t        |
|	d||«      }
t        ||«      }t        ||||«      }t        |j                  |«      |g}t        |||«      }t        |
|«      sùt        |
|«      }|j                  |
«       ||
|||z
  f\  } }}}t        t        |||«      t        ||||«      ||«      }	t        | |||«      }
|
D �cg c]  }t        ||	||«      ‘Œ }
}t        ||«      }|dkD  r9t        t        |||«      |||«      }t        ||dz
  ||«      }t        ||||«      }nt        |||«      }|j                  t        |||«      «       t        |
|«      sŒù||fS c c}w )a  
    Subresultant PRS algorithm in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = 3*x**2*y - y**3 - 4
    >>> g = x**2 + x*y**3 - 9

    >>> a = 3*x*y**4 + y**3 - 27*y + 4
    >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16

    >>> prs = [f, g, a, b]
    >>> sres = [[1], [1], [3, 0, 0, 0, 0], [-3, 0, 0, -12, 1, 0, -54, 8, 729, -216, 16]]

    >>> R.dmp_inner_subresultants(f, g) == (prs, sres)
    True

    rn   r   )rx   r"   r   r   rF   r
   r   r   r%   r   rb   r	   r   )rG   rH   rS   rI   rp   rq   Úvrr   rs   rK   rW   rt   ru   rv   rw   ÚchÚprL   s                     rN   Údmp_inner_subresultantsr‡   Á  s:  € ñ. Ü& q¨!¨QÓ/Ð/ä�1�aÓ€AÜ�1�aÓ€Aàˆ1‚uØ�!ˆ1ˆØ�!ˆ1ˆä�!�QÔØ�2ˆvˆà	ˆA‰€AÜ�!�QÔØˆs”Z §¡ qÓ)Ð*Ð*Ð*à	
ˆAˆ€AØ	ˆA‰€Aä”
˜AŸE™E˜6 1Ó% q¨1¡u¨a°Ó3€Aä��A�q˜!Ó€AÜ�Q˜˜1˜a Ó#€Aä	��1‹€BÜ��A�q˜!Ó€Aä	�A—E‘E˜1Ó	˜qÐ!€AÜ��1�aÓ€Aä˜˜AÔÜ�q˜!ÓˆØ	�‰�Œà˜˜1˜a !™e�^‰
ˆˆ1ˆa�ä”G˜B  1Ó%Ü˜A˜q ! QÓ'¨¨Aó/ˆô �Q˜˜1˜aÓ ˆØ-.Ö0 rŒg�b˜!˜Q Õ"Ð0ˆÐ0ä�A�q‹\ˆàˆqŠ5Üœ  A qÓ)¨1¨a°Ó3ˆAÜ˜˜1˜q™5 ! QÓ'ˆAÜ˜˜1˜a Ó#‰Aä˜˜A˜qÓ!ˆAà	�‰”˜˜A˜qÓ!Ô"ô+ ˜˜AÕð. ˆaˆ4€Kùò 1s   Å)Hc                 ó$   — t        | |||«      d   S )aœ  
    Computes subresultant PRS of two polynomials in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = 3*x**2*y - y**3 - 4
    >>> g = x**2 + x*y**3 - 9

    >>> a = 3*x*y**4 + y**3 - 27*y + 4
    >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16

    >>> R.dmp_subresultants(f, g) == [f, g, a, b]
    True

    r   )r‡   rR   s       rN   Údmp_subresultantsr‰     s   € ô( # 1 a¨¨AÓ.¨qÑ1Ð1rP   c                 óä   — |st        | ||«      S t        | |«      st        ||«      rt        |dz
  «      g fS t        | |||«      \  }}t	        |d   |«      dkD  rt        |dz
  «      |fS |d   |fS )a  
    Resultant algorithm in `K[X]` using subresultant PRS.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = 3*x**2*y - y**3 - 4
    >>> g = x**2 + x*y**3 - 9

    >>> a = 3*x*y**4 + y**3 - 27*y + 4
    >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16

    >>> res, prs = R.dmp_prs_resultant(f, g)

    >>> res == b             # resultant has n-1 variables
    False
    >>> res == b.drop(x)
    True
    >>> prs == [f, g, a, b]
    True

    rn   r}   r   )r   r   r   r‡   r"   )rG   rH   rS   rI   rr   rv   s         rN   Údmp_prs_resultantr‹   (  sƒ   € ñ4 Ü   A qÓ)Ð)ä�!�QÔœ: a¨Ô+Ü˜˜Q™“ Ð$Ð$ä" 1 a¨¨AÓ.�D€A€qä�!�B‘%˜Ó˜aÒÜ˜˜Q™“ Ð#Ð#àˆR‰5�!ˆ8€OrP   c           	      óÚ  — |st        t        | ||«      d   |z  |«      S |dz
  }t        | |«      }t        ||«      }t        | d|«      }t        |d|«      }	||	z  ||z  z   }
|j                  g|j                   }}t        |«      }t        |«      |
k  �rU	 ||j                  z  }||k(  rt        d«      ‚t        | t        ||«      d||«      }t        ||«      |k(  r)t        |t        ||«      d||«      }t        ||«      |k(  rnŒqt        |||||«      }t        ||||«      }|st        |g«      }t        |g«      }n|g}|g}|j                  t        |||«      |«      }t        |||«      }t        ||d|«      }t!        |t#        ||||«      ||«      }t%        ||||«      }t'        ||||«      }t)        ||j                  | g|«      }t+        |||«      }t        |«      |
k  r�ŒU|S )a  
    Compute resultant of `f` and `g` modulo a prime `p`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = x + y + 2
    >>> g = 2*x*y + x + 3

    >>> R.dmp_zz_modular_resultant(f, g, 5)
    -2*y**2 + 1

    r   rn   úno luck)r<   r   r"   r#   rF   r   r!   rA   r2   Údmp_zz_modular_resultantr1   r   Úinvertr0   r   r   r	   r   r   r4   r   r3   )rG   rH   r†   rS   rI   r„   rp   rq   ÚNÚMÚBÚDrJ   rM   rX   ÚGrr   Úers   ru   s                       rN   rŽ   rŽ   P  s  € ñ" ÜÔ'¨¨1¨aÓ0°Ñ3°aÑ7¸Ó;Ð;à	ˆA‰€Aä�1�aÓ€AÜ�1�aÓ€Aä�a˜˜AÓ€AÜ�a˜˜AÓ€Aà	ˆ!‰ˆa�‰c‰	€Aà�E‰Eˆ7�Q—U‘U�F€q€AÜ�‹€Aä
�Q‹-˜1Ó
ØØ�—‘‰JˆAà�AŠvÜ(¨Ó3Ð3ä˜Aœv a¨›|¨Q°°1Ó5ˆAä˜!˜QÓ 1Ò$Ü ¤6¨!¨Q£<°°A°qÓ9�ä˜a Ó# qÒ(Øð ô % Q¨¨1¨a°Ó3ˆÜ�Q˜˜1˜aÓ ˆáÜ˜1˜#“ˆAÜ˜1˜#“‰Aà�ˆAØ�ˆAà�H‰H”X˜a  AÓ&¨Ó*ˆÜ˜1˜a Ó#ˆÜ�a˜˜A˜qÓ!ˆä�A”w˜q ! Q¨Ó*¨A¨qÓ1ˆÜ�A�q˜!˜QÓˆä˜Q  1 aÓ(ˆä�A˜Ÿ™ ˜r�{ AÓ&ˆÜ�a˜˜AÓˆôG �Q‹-˜1Ô
ðJ €HrP   c                 ó>   — t        t        | |g||g|«      ||z  «      S )z2Wrapper of CRT for Collins's resultant algorithm. r;   )rM   rr   ÚPr†   rI   s        rN   Ú_collins_crtr˜   ™  s$   € ä”&˜!˜Q˜ ! Q ¨Ó+¨Q¨q©SÓ1Ð1rP   c                 óØ  — t        | |«      }t        ||«      }|dk  s|dk  rt        |dz
  «      S t        | ||«      }t        |||«      }t        | ||«      }t        |||«      }	|dz
  }
 |d«      |j	                   |||z   «      «      z  ||z  z  ||z  z  }t        |
«      |j
                  |j
                  }}}ddlm} ||k  r” | ||«      «      }||z  r|	|z  s | ||«      «      }||z  sŒ|	|z  sŒt        | |||«      }t        ||||«      }	 t        |||||«      }|j                  |«      r|}nt        ||t        |||f|
|«      }||z  }||k  rŒ”|S # t        $ r Y Œ¦w xY w)a  
    Collins's modular resultant algorithm in `Z[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = x + y + 2
    >>> g = 2*x*y + x + 3

    >>> R.dmp_zz_collins_resultant(f, g)
    -2*y**2 - 5*y + 1

    r   rn   é   )Ú	nextprime)r"   r   r   r&   Ú	factorialrF   Úsympy.ntheoryr›   r4   rŽ   rA   Úis_oner+   r˜   )rG   rH   rS   rI   rp   rq   ÚAr’   rJ   rK   r„   rM   r†   r—   r›   rX   r”   rr   s                     rN   Údmp_zz_collins_resultantr    ž  s”  € ô$ 	�1�aÓ€AÜ�1�aÓ€Aàˆ1‚u��A’Ü˜˜A™‹Ðä�Q˜˜1Ó€AÜ�Q˜˜1Ó€Aä�a˜˜AÓ€AÜ�a˜˜AÓ€Aà	ˆA‰€Aá	ˆ!‹ˆQ�[‰[™˜1˜q™5›Ó"Ñ" 1 a¡4Ñ'¨¨1©Ñ,€AÜ�q‹k˜1Ÿ5™5 !§%¡%ˆ!€q€Aå'à
ˆqŠ&Ù‰i˜‹l‹Oˆà�q’5 ! a¢%Ù‘)˜A“,“ˆAð �q“5 ! a£%ô ˜Q  1 aÓ(ˆÜ˜Q  1 aÓ(ˆð	Ü(¨¨A¨q°!°QÓ7ˆAð �8‰8�AŒ;Ø‰Aä  1¤l°Q¸¸1°I¸qÀ!ÓDˆAà	ˆQ‰ˆð' ˆq‹&ð* €Høô "ò 	Ùð	ús   ÄE Å	E)Å(E)c                 ó”  — t        | |«      }t        ||«      }|dk  s|dk  rt        |dz
  «      S |j                  «       }t        | |||«      \  }} t        ||||«      \  }}t	        | |||«      } t	        ||||«      }t        | |||«      }	t	        |	|dz
  ||«      }	|j                  ||z  ||z  z  |«      }
t        |	|
|dz
  |«      S )a$  
    Collins's modular resultant algorithm in `Q[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x,y = ring("x,y", QQ)

    >>> f = QQ(1,2)*x + y + QQ(2,3)
    >>> g = 2*x*y + x + 3

    >>> R.dmp_qq_collins_resultant(f, g)
    -2*y**2 - 7/3*y + 5/6

    r   rn   )r"   r   Úget_ringr-   r*   r    Úconvertr   )rG   rH   rS   ÚK0rp   rq   ÚK1ÚcfÚcgrM   ru   s              rN   Údmp_qq_collins_resultantr¨   Û  sß   € ô" 	�1�aÓ€AÜ�1�aÓ€Aàˆ1‚u��A’Ü˜˜A™‹Ðà	�‰‹€Bä˜Q  2 rÓ*�E€BˆÜ˜Q  2 rÓ*�E€Bˆä�A�q˜"˜bÓ!€AÜ�A�q˜"˜bÓ!€Aä   A q¨"Ó-€AÜ�A�q˜1‘u˜b "Ó%€Aà
�
‰
�2�q‘5˜2˜q™5‘= "Ó%€Aä˜!˜Q  A¡ rÓ*Ð*rP   c                 ó  — |st        | |||¬«      S |rt        | |||«      S |j                  r%|j                  r>t	        d«      r3t        | |||«      S |j                  rt	        d«      rt        | |||«      S t        | |||«      d   S )aH  
    Computes resultant of two polynomials in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = 3*x**2*y - y**3 - 4
    >>> g = x**2 + x*y**3 - 9

    >>> R.dmp_resultant(f, g)
    -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16

    )r�   ÚUSE_COLLINS_RESULTANTr   )r‚   r‹   rE   Úis_QQr>   r¨   Úis_ZZr    )rG   rH   rS   rI   r�   s        rN   Údmp_resultantr­     s‰   € ñ" Ü˜Q  1°Ô<Ð<áÜ   A q¨!Ó,Ð,à‡z‚zØ�7Š7”uÐ4Ô5Ü+¨A¨q°!°QÓ7Ð7à�7Š7”uÐ4Ô5Ü+¨A¨q°!°QÓ7Ð7ä˜Q  1 aÓ(¨Ñ+Ð+rP   c                 óÔ   — t        | «      }|dk  r|j                  S d||dz
  z  dz  z  }t        | |«      }t        | t	        | d|«      |«      }|j                  || ||«      z  «      S )zÐ
    Computes discriminant of a polynomial in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_discriminant(x**2 + 2*x + 3)
    -8

    r   r}   rn   rš   )r!   r~   r$   r‚   r.   ro   )rG   rI   rs   rV   ru   rM   s         rN   Údup_discriminantr¯   #  so   € ô 	�1‹€AàˆA‚vØ�v‰vˆà�A�q˜1‘u‘I !Ñ#Ñ$ˆÜ�1�a‹Lˆä˜!œX a¨¨AÓ.°Ó2ˆà�u‰u�Q˜™!˜A›$™ÓÐrP   c           	      ó  — |st        | |«      S t        | |«      |dz
  }}|dk  rt        |«      S d||dz
  z  dz  z  }t        | |«      }t	        | t        | d||«      ||«      }t        | ||«      ||«      }t        ||||«      S )zé
    Computes discriminant of a polynomial in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y,z,t = ring("x,y,z,t", ZZ)

    >>> R.dmp_discriminant(x**2*y + x*z + t)
    -4*y*t + z**2

    rn   r   r}   rš   )r¯   r"   r   r%   r­   r/   r   r   )rG   rS   rI   rs   r„   rV   ru   rM   s           rN   Údmp_discriminantr±   >  s›   € ñ Ü  1Ó%Ð%ä�a˜Ó˜Q ™U€q€AàˆA‚vÜ˜‹{Ðà�A�q˜1‘u‘I !Ñ#Ñ$ˆÜ�1�a‹Lˆä˜!œX a¨¨A¨qÓ1°1°aÓ8ˆÜ˜1™a ›d A qÓ)ˆä�q˜!˜Q Ó"Ð"rP   c                 ó6  — | s|sg g g fS | sF|j                  t        ||«      «      r|g |j                  gfS t        ||«      g |j                   gfS |sF|j                  t        | |«      «      r| |j                  gg fS t        | |«      |j                   gg fS y)ú3Handle trivial cases in GCD algorithm over a ring. N)Úis_nonnegativer$   rF   r   rz   s      rN   Ú_dup_rr_trivial_gcdrµ   ]  sž   € á‘Ø�2�rˆzÐÙØ×ÑœF 1 a›LÔ)Ø�b˜1Ÿ5™5˜'�>Ð!ä˜1˜a“= "¨¯© v hÐ.Ð.ÙØ×ÑœF 1 a›LÔ)Ø�q—u‘u�g˜r�>Ð!ä˜1˜a“= A§E¡E 6 (¨BÐ.Ð.àrP   c                 ó†   — | s|sg g g fS | st        ||«      g t        ||«      gfS |st        | |«      t        | |«      gg fS y)ú4Handle trivial cases in GCD algorithm over a field. N)r5   r$   rz   s      rN   Ú_dup_ff_trivial_gcdr¸   o  sR   € á‘Ø�2�rˆzÐÙÜ˜˜A‹ ¤V¨A¨q£\ NÐ2Ð2ÙÜ˜˜A‹¤¨¨1£ °Ð2Ð2àrP   c                 ó„  — t        | |«      }t        ||«      }t        | ||«      xs t        |||«      }|r|rt        t        d||«      «      S |rb|j	                  t        |||«      «      r|t        |«      t        ||«      fS t        |||«      t        |«      t        |j                   |«      fS |rb|j	                  t        | ||«      «      r| t        ||«      t        |«      fS t        | ||«      t        |j                   |«      t        |«      fS |rt        ||«      | |fS t        d«      rt        | |||«      S y)r³   é   ÚUSE_SIMPLIFY_GCDN)r   r   Útupler    r´   r&   r   r   r   r   rF   r>   Ú_dmp_simplify_gcd)rG   rH   rS   rI   Úzero_fÚzero_gÚif_contain_ones          rN   Ú_dmp_rr_trivial_gcdrÁ   {  s2  € ä˜˜1Ó€FÜ˜˜1Ó€FÜ˜q ! QÓ'Ò=¬9°Q¸¸1Ó+=€Ná‘&Ü”Y˜q ! QÓ'Ó(Ð(Ù	Ø×ÑœM¨!¨Q°Ó2Ô3Ø”h˜q“k¤7¨1¨a£=Ð0Ð0ä˜1˜a Ó#¤X¨a£[´*¸a¿e¹e¸VÀQÓ2GÐGÐGÙ	Ø×ÑœM¨!¨Q°Ó2Ô3Ø”g˜a “m¤X¨a£[Ð0Ð0ä˜1˜a Ó#¤Z°·±°¸Ó%:¼HÀQ»KÐGÐGÙ	Ü�q˜!‹}˜a Ð"Ð"Ü	Ð!Ô	"Ü   A q¨!Ó,Ð,àrP   c           	      óZ  — t        | |«      }t        ||«      }|r|rt        t        d||«      «      S |r.t        |||«      t	        |«      t        t        |||«      |«      fS |r.t        | ||«      t        t        | ||«      |«      t	        |«      fS t        d«      rt        | |||«      S y)r·   rº   r»   N)	r   r¼   r    r6   r   r   r&   r>   r½   )rG   rH   rS   rI   r¾   r¿   s         rN   Ú_dmp_ff_trivial_gcdrÃ   •  sº   € ä˜˜1Ó€FÜ˜˜1Ó€Fá‘&Ü”Y˜q ! QÓ'Ó(Ð(Ù	Ü   A qÓ)Ü˜“Üœ=¨¨A¨qÓ1°1Ó5ð7ð 	7ñ 
Ü   A qÓ)Üœ=¨¨A¨qÓ1°1Ó5Ü˜“ðð 	ô 
Ð!Ô	"Ü   A q¨!Ó,Ð,àrP   c           	      óž  — t        | |«      }t        ||«      }|dkD  r|dkD  ry|s|st        | |«      }t        ||«      }n5|st        | |«      }t        |||«      }nt        | ||«      }t        ||«      }|dz
  }t        ||||«      }	| D �
cg c]  }
t	        |
|	||«      ‘Œ }}
|D �cg c]  }t	        ||	||«      ‘Œ }}|	g||fS c c}
w c c}w )z7Try to eliminate `x_0` from GCD computation in `K[X]`. r   Nrn   )r"   r%   Údmp_contentÚdmp_gcdr   )rG   rH   rS   rI   ÚdfÚdgrX   r”   r„   rW   r¦   Úcffr§   Úcfgs                 rN   r½   r½   ª  så   € ä	�A�qÓ	€BÜ	�A�qÓ	€Bà	ˆA‚v�"�q’&Øá‘"Ü�1�a‹LˆÜ�1�a‹L‰áÜ�q˜!“ˆAÜ˜A˜q !Ó$‰Aä˜A˜q !Ó$ˆAÜ�q˜!“ˆAà	ˆA‰€AÜ��1�a˜Ó€Aà+,Ö
. RŒG�B˜˜1˜aÕ Ð
.€CÐ
.Ø+,Ö
. RŒG�B˜˜1˜aÕ Ð
.€CÐ
.àˆ3��Sˆ=Ðùò /ùÚ
.s   ÂCÂ(C
c                 óV  — t        | ||«      }|�|S t        | |«      \  }}t        ||«      \  }}|j                  ||«      }t        |||«      d   }	t        |	|«      \  }
}	||j	                  t        |	|«      «      z  }t        |	||«      }	t        | |	|«      }t        ||	|«      }|	||fS )aa  
    Computes polynomial GCD using subresultants over a ring.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
    and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_rr_prs_gcd(x**2 - 1, x**2 - 3*x + 2)
    (x - 1, x + 1, x - 2)

    r}   )rµ   r7   Úgcdr{   Úcanonical_unitr$   r   r   )rG   rH   rI   ÚresultÚfcrX   Úgcr”   ru   rW   ri   rÉ   rÊ   s                rN   Údup_rr_prs_gcdrÑ   Æ  sÀ   € ô" !  A qÓ)€FàÐØˆä˜!˜QÓ�E€BˆÜ˜!˜QÓ�E€Bˆà	�‰ˆb�"‹€Aä˜!˜Q Ó" 2Ñ&€AÜ˜˜AÓ�D€A€qàˆ×	Ñ	œ&  A›,Ó	'Ñ'€Aä�q˜!˜QÓ€Aä
�!�Q˜Ó
€CÜ
�!�Q˜Ó
€Càˆc�3ˆ;ÐrP   c                 óš   — t        | ||«      }|�|S t        | ||«      d   }t        ||«      }t        | ||«      }t        |||«      }|||fS )ab  
    Computes polynomial GCD using subresultants over a field.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
    and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> R.dup_ff_prs_gcd(x**2 - 1, x**2 - 3*x + 2)
    (x - 1, x + 1, x - 2)

    r}   )r¸   r{   r5   r   )rG   rH   rI   rÎ   rW   rÉ   rÊ   s          rN   Údup_ff_prs_gcdrÓ   î  sc   € ô" !  A qÓ)€FàÐØˆä˜!˜Q Ó" 2Ñ&€AÜ�!�Q‹€Aä
�!�Q˜Ó
€CÜ
�!�Q˜Ó
€Càˆc�3ˆ;ÐrP   c                 óÂ  — |st        | ||«      S t        | |||«      }|�|S t        | ||«      \  }}t        |||«      \  }}t        ||||«      d   }	t	        |||dz
  |«      \  }
}}t        |	||«      \  }}	t        |	|
d||«      }	|j                  t        |	||«      «      }||j                  k7  rt        |	|||«      }	t        | |	||«      }t        ||	||«      }|	||fS )a†  
    Computes polynomial GCD using subresultants over a ring.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
    and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> f = x**2 + 2*x*y + y**2
    >>> g = x**2 + x*y

    >>> R.dmp_rr_prs_gcd(f, g)
    (x + y, x + y, x)

    r}   rn   r   )rÑ   rÁ   Údmp_primitiver‰   Údmp_rr_prs_gcdr   rÍ   r&   rF   r   r   )rG   rH   rS   rI   rÎ   rÏ   rX   rÐ   r”   rW   ru   ri   ÚunitrÉ   rÊ   s                  rN   rÖ   rÖ     s  € ñ( Ü˜a  AÓ&Ð&ä   A q¨!Ó,€FàÐØˆä˜!˜Q Ó"�E€BˆÜ˜!˜Q Ó"�E€Bˆä˜!˜Q  1Ó% bÑ)€AÜ˜R  Q¨¡U¨AÓ.�G€A€qˆ!ä˜˜A˜qÓ!�D€A€qÜ�Q˜˜1˜a Ó#€Aà×ÑœM¨!¨Q°Ó2Ó3€Dàˆq�u‰u‚}Ü˜1˜d A qÓ)ˆä
�!�Q˜˜1Ó
€CÜ
�!�Q˜˜1Ó
€Càˆc�3ˆ;ÐrP   c                 ój  — |st        | ||«      S t        | |||«      }|�|S t        | ||«      \  }}t        |||«      \  }}t        ||||«      d   }	t	        |||dz
  |«      \  }
}}t        |	||«      \  }}	t        |	|
d||«      }	t        |	||«      }	t        | |	||«      }t        ||	||«      }|	||fS )a�  
    Computes polynomial GCD using subresultants over a field.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
    and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x,y, = ring("x,y", QQ)

    >>> f = QQ(1,2)*x**2 + x*y + QQ(1,2)*y**2
    >>> g = x**2 + x*y

    >>> R.dmp_ff_prs_gcd(f, g)
    (x + y, 1/2*x + 1/2*y, x)

    r}   rn   r   )rÓ   rÃ   rÕ   r‰   Údmp_ff_prs_gcdr   r6   r   )rG   rH   rS   rI   rÎ   rÏ   rX   rÐ   r”   rW   ru   ri   rÉ   rÊ   s                 rN   rÙ   rÙ   =  sâ   € ñ( Ü˜a  AÓ&Ð&ä   A q¨!Ó,€FàÐØˆä˜!˜Q Ó"�E€BˆÜ˜!˜Q Ó"�E€Bˆä˜!˜Q  1Ó% bÑ)€AÜ˜R  Q¨¡U¨AÓ.�G€A€qˆ!ä˜˜A˜qÓ!�D€A€qÜ�Q˜˜1˜a Ó#€AÜ˜˜A˜qÓ!€Aä
�!�Q˜˜1Ó
€CÜ
�!�Q˜˜1Ó
€Càˆc�3ˆ;ÐrP   é   c                 ól   — g }| r/| |z  }||dz  kD  r||z  }|j                  d|«       | |z
  |z  } | rŒ/|S )ú-Interpolate polynomial GCD from integer GCD. rš   r   )Úinsert)rW   ÚxrI   rG   rH   s        rN   Ú_dup_zz_gcd_interpolaterß   k  sM   € à
€Aá
Ø�‰Eˆàˆq�A‰vŠ:Ø�‰FˆAà	�‰��AŒØ�‰U�q‰Lˆò ð €HrP   c                 ó€  — t        | ||«      }|�|S t        | «      }t        |«      }t        | ||«      \  }} }|dk(  s|dk(  r|g| |fS t        | |«      }t        ||«      } |dt	        ||«      z  dz   «      }	t        t	        |	d|j                  |	«      z  «      dt	        |t        t        | |«      «      z  |t        t        ||«      «      z  «      z  dz   «      }
t        dt        «      D �]D  }t        | |
|«      }t        ||
|«      }|rü|rú|j                  ||«      }||z  }||z  }t        ||
|«      }t        ||«      d   }t        | ||«      \  }}|s&t        |||«      \  }}|st!        |||«      }|||fc S t        ||
|«      }t        | ||«      \  }}|s&t        |||«      \  }}|st!        |||«      }|||fc S t        ||
|«      }t        |||«      \  }}|s&t        | ||«      \  }}|st!        |||«      }|||fc S d|
z  |j                  |j                  |
«      «      z  dz  }
�ŒG t#        d	«      ‚)
a
  
    Heuristic polynomial GCD in `Z[x]`.

    Given univariate polynomials `f` and `g` in `Z[x]`, returns
    their GCD and cofactors, i.e. polynomials ``h``, ``cff`` and ``cfg``
    such that::

          h = gcd(f, g), cff = quo(f, h) and cfg = quo(g, h)

    The algorithm is purely heuristic which means it may fail to compute
    the GCD. This will be signaled by raising an exception. In this case
    you will need to switch to another GCD method.

    The algorithm computes the polynomial GCD by evaluating polynomials
    f and g at certain points and computing (fast) integer GCD of those
    evaluations. The polynomial GCD is recovered from the integer image
    by interpolation.  The final step is to verify if the result is the
    correct GCD. This gives cofactors as a side effect.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_zz_heu_gcd(x**2 - 1, x**2 - 3*x + 2)
    (x - 1, x + 1, x - 2)

    References
    ==========

    .. [1] [Liao95]_

    r   rš   é   éc   é   rn   éB  éƒi  r�   )rµ   r!   r9   r   ÚminÚmaxÚsqrtÚabsr$   ÚrangeÚHEU_GCD_MAXr0   rÌ   rß   r7   r   r   r@   )rG   rH   rI   rÎ   rÇ   rÈ   rÌ   Úf_normÚg_normr’   rÞ   ÚiÚffÚggrW   rÉ   rÊ   Úcff_rM   Úcfg_s                       rN   Údup_zz_heu_gcdró   {  s�  € ôF !  A qÓ)€FàÐØˆä	�A‹€BÜ	�A‹€Bä˜A˜q !Ó$�I€CˆˆAà	ˆQ‚w�"˜’'Øˆu�a˜ˆ{Ðä˜!˜QÓ€FÜ˜!˜QÓ€Fá	ˆ!ŒC�˜ÓÑ
 "Ñ
$Ó%€AäŒC��2�a—f‘f˜Q“i‘<Ó ØŒc�&œC¤ q¨!£Ó-Ñ-ØœC¤ q¨!£Ó-Ñ-ó/ñ /Ø12ñ3ó	4€Aô �1”kÓ"ó ,1ˆÜ�a˜˜AÓˆÜ�a˜˜AÓˆá‘"Ø—‘�b˜"“ˆAà˜‘'ˆCØ˜‘'ˆCä'¨¨1¨aÓ0ˆAÜ˜a Ó# AÑ&ˆAä˜a  AÓ&‰GˆD�!áÜ! ! Q¨Ó*‘��aáÜ& q¨#¨qÓ1�AØ˜d D˜=Ò(ä)¨#¨q°!Ó4ˆCä˜1˜c 1Ó%‰DˆAˆqáÜ! ! Q¨Ó*‘��aáÜ& q¨#¨qÓ1�AØ˜c 4˜<Ò'ä)¨#¨q°!Ó4ˆCä˜1˜c 1Ó%‰DˆAˆqáÜ! ! Q¨Ó*‘��aáÜ& q¨#¨qÓ1�AØ˜d C˜<Ò'à�!‰G�a—f‘f˜QŸV™V A›YÓ'Ñ'¨5Ñ0ŠðY,1ô\ ˜YÓ
'Ð'rP   c                 ó  — g }t        | |«      sIt        | |||«      }|j                  d|«       t        | |||«      } t	        | |||«      } t        | |«      sŒI|j                  t        ||dz   |«      «      rt        ||dz   |«      S |S )rÜ   r   rn   )r   r4   rÝ   r   r   Úis_negativer&   r   )rW   rÞ   r„   rI   rG   rH   s         rN   Ú_dmp_zz_gcd_interpolaterö   å  s�   € à
€Aä˜˜AÔÜ˜Q  1 aÓ(ˆØ	�‰��AŒä�A�q˜!˜QÓˆÜ˜1˜a  AÓ&ˆô ˜˜AÕð 	‡}�}”] 1 a¨!¡e¨QÓ/Ô0Ü�q˜!˜a™% Ó#Ð#àˆrP   c                 ó  — |st        | ||«      S t        | |||«      }|�|S t        | |||«      \  }} }t        | ||«      }t        |||«      } |dt	        ||«      z  dz   «      }t        t	        |d|j                  |«      z  «      dt	        |t        t        | ||«      «      z  |t        t        |||«      «      z  «      z  dz   «      }	t        dt        «      D �]   }
t        | |	||«      }t        ||	||«      }|dz
  }t        ||«      �sFt        ||«      �s9t        ||||«      \  }}}t        ||	||«      }t        |||«      d   }t!        | |||«      \  }}t        ||«      r2t!        ||||«      \  }}t        ||«      rt#        ||||«      }|||fc S t        ||	||«      }t!        | |||«      \  }}t        ||«      r2t!        ||||«      \  }}t        ||«      rt#        ||||«      }|||fc S t        ||	||«      }t!        ||||«      \  }}t        ||«      r2t!        | |||«      \  }}t        ||«      rt#        ||||«      }|||fc S d|	z  |j                  |j                  |	«      «      z  dz  }	�Œ£ t%        d	«      ‚)
a³  
    Heuristic polynomial GCD in `Z[X]`.

    Given univariate polynomials `f` and `g` in `Z[X]`, returns
    their GCD and cofactors, i.e. polynomials ``h``, ``cff`` and ``cfg``
    such that::

          h = gcd(f, g), cff = quo(f, h) and cfg = quo(g, h)

    The algorithm is purely heuristic which means it may fail to compute
    the GCD. This will be signaled by raising an exception. In this case
    you will need to switch to another GCD method.

    The algorithm computes the polynomial GCD by evaluating polynomials
    f and g at certain points and computing (fast) integer GCD of those
    evaluations. The polynomial GCD is recovered from the integer image
    by interpolation. The evaluation process reduces f and g variable by
    variable into a large integer.  The final step is to verify if the
    interpolated polynomial is the correct GCD. This gives cofactors of
    the input polynomials as a side effect.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> f = x**2 + 2*x*y + y**2
    >>> g = x**2 + x*y

    >>> R.dmp_zz_heu_gcd(f, g)
    (x + y, x + y, x)

    References
    ==========

    .. [1] [Liao95]_

    rš   rá   râ   rã   r   rn   rä   rå   r�   )ró   rÁ   r:   r   ræ   rç   rè   ré   r&   rê   rë   r1   r   Údmp_zz_heu_gcdrö   r8   r   r   r@   )rG   rH   rS   rI   rÎ   rÌ   rì   rí   r’   rÞ   rî   rï   rð   r„   rW   rÉ   rÊ   rñ   rM   rò   s                       rN   rø   rø   ö  sÈ  € ñP Ü˜a  AÓ&Ð&ä   A q¨!Ó,€FàÐØˆä" 1 a¨¨AÓ.�I€CˆˆAä˜!˜Q Ó"€FÜ˜!˜Q Ó"€Fá	ˆ!ŒC�˜ÓÑ
 "Ñ
$Ó%€AäŒC��2�a—f‘f˜Q“i‘<Ó ØŒc�&œC¤¨a°°AÓ 6Ó7Ñ7ØœC¤¨a°°AÓ 6Ó7Ñ7ó9ñ 9Ø;<ñ=ó	>€Aô �1”kÓ"ó +1ˆÜ�a˜˜A˜qÓ!ˆÜ�a˜˜A˜qÓ!ˆà�‰Eˆä˜2˜qÕ!¤Z°°AÕ%6Ü(¨¨R°°AÓ6‰KˆAˆs�Cä'¨¨1¨a°Ó3ˆAÜ$ Q¨¨1Ó-¨aÑ0ˆAä˜a  A qÓ)‰GˆD�!ä˜!˜QÔÜ! ! Q¨¨1Ó-‘��aä˜a Ô#Ü& q¨#¨q°!Ó4�AØ˜d D˜=Ò(ä)¨#¨q°!°QÓ7ˆCä˜1˜c 1 aÓ(‰DˆAˆqä˜!˜QÔÜ! ! Q¨¨1Ó-‘��aä˜a Ô#Ü& q¨#¨q°!Ó4�AØ˜c 4˜<Ò'ä)¨#¨q°!°QÓ7ˆCä˜1˜c 1 aÓ(‰DˆAˆqä˜!˜QÔÜ! ! Q¨¨1Ó-‘��aä˜a Ô#Ü& q¨#¨q°!Ó4�AØ˜d C˜<Ò'à�!‰G�a—f‘f˜QŸV™V A›YÓ'Ñ'¨5Ñ0ŠðW+1ôZ ˜YÓ
'Ð'rP   c                 óÖ  — t        | ||«      }|�|S |j                  «       }t        | ||«      \  }} t        |||«      \  }}t        | ||«      } t        |||«      }t	        | ||«      \  }}}	t        |||«      }t        ||«      }
t        ||«      }t        |||«      }t        |	||«      }	t        ||j                  |
|«      |«      }t        |	|j                  |
|«      |«      }	|||	fS )a‹  
    Heuristic polynomial GCD in `Q[x]`.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = QQ(1,2)*x**2 + QQ(7,4)*x + QQ(3,2)
    >>> g = QQ(1,2)*x**2 + x

    >>> R.dup_qq_heu_gcd(f, g)
    (x + 2, 1/2*x + 3/4, 1/2*x)

    )	r¸   r¢   r,   r)   ró   r$   r5   r   ro   )rG   rH   r¤   rÎ   r¥   r¦   r§   rW   rÉ   rÊ   ru   s              rN   Údup_qq_heu_gcdrú   a  sù   € ô( !  A rÓ*€FàÐØˆà	�‰‹€Bä˜Q  BÓ'�E€BˆÜ˜Q  BÓ'�E€Bˆä�A�r˜2Ó€AÜ�A�r˜2Ó€Aä   A rÓ*�K€A€sˆCä�A�r˜2Ó€Aäˆq�"‹€AÜ�!�RÓ€Aä
�c˜2˜rÓ
"€CÜ
�c˜2˜rÓ
"€Cä
˜˜bŸf™f Q¨›m¨RÓ
0€CÜ
˜˜bŸf™f Q¨›m¨RÓ
0€Càˆc�3ˆ;ÐrP   c                 óð  — t        | |||«      }|�|S |j                  «       }t        | |||«      \  }} t        ||||«      \  }}t        | |||«      } t        ||||«      }t	        | |||«      \  }}	}
t        ||||«      }t        |||«      }t        |||«      }t        |	|||«      }	t        |
|||«      }
t        |	|j                  ||«      ||«      }	t        |
|j                  ||«      ||«      }
||	|
fS )a�  
    Heuristic polynomial GCD in `Q[X]`.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x,y, = ring("x,y", QQ)

    >>> f = QQ(1,4)*x**2 + x*y + y**2
    >>> g = QQ(1,2)*x**2 + x*y

    >>> R.dmp_qq_heu_gcd(f, g)
    (x + 2*y, 1/4*x + 1/2*y, 1/2*x)

    )	rÃ   r¢   r-   r*   rø   r&   r6   r   ro   )rG   rH   rS   r¤   rÎ   r¥   r¦   r§   rW   rÉ   rÊ   ru   s               rN   Údmp_qq_heu_gcdrü   ’  s  € ô( !  A q¨"Ó-€FàÐØˆà	�‰‹€Bä˜Q  2 rÓ*�E€BˆÜ˜Q  2 rÓ*�E€Bˆä�A�q˜"˜bÓ!€AÜ�A�q˜"˜bÓ!€Aä   A q¨"Ó-�K€A€sˆCä�A�q˜"˜bÓ!€Aä�a˜˜BÓ€AÜ˜˜A˜rÓ"€Aä
�c˜1˜b "Ó
%€CÜ
�c˜1˜b "Ó
%€Cä
˜˜bŸf™f Q¨›m¨Q°Ó
3€CÜ
˜˜bŸf™f Q¨›m¨Q°Ó
3€Càˆc�3ˆ;ÐrP   c                 ó\  — |j                   s|j                  rh	 |j                  «       }t        | ||«      } t        |||«      }t        | ||«      \  }}}t        |||«      }t        |||«      }t        |||«      }|||fS |j                  r2|j                  rt        d«      r	 t        | ||«      S t        | ||«      S |j                  rt        d«      r	 t        | ||«      S t        | ||«      S # t        $ r |j                  g| |fcY S w xY w# t        $ r Y Œiw xY w# t        $ r Y ŒFw xY w)ag  
    Computes polynomial GCD and cofactors of `f` and `g` in `K[x]`.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_inner_gcd(x**2 - 1, x**2 - 3*x + 2)
    (x - 1, x + 1, x - 2)

    ÚUSE_HEU_GCD)Úis_RRÚis_CCÚ	get_exactrC   rF   r)   Údup_inner_gcdrE   r«   r>   rú   r@   rÓ   r¬   ró   rÑ   )rG   rH   rI   ÚexactrW   rÉ   rÊ   s          rN   r  r  Ã  s?  € ð: 	‡w‚w�!—'’'ð	!Ø—K‘K“MˆEô ˜˜1˜eÓ$ˆÜ˜˜1˜eÓ$ˆä# A q¨%Ó0‰ˆˆ3�ä˜˜5 !Ó$ˆÜ˜#˜u aÓ(ˆÜ˜#˜u aÓ(ˆà�#�sˆ{ÐØ	
�ŠØ�7Š7”u˜]Ô+ðÜ% a¨¨AÓ.Ð.ô ˜a  AÓ&Ð&à�7Š7”u˜]Ô+ðÜ% a¨¨AÓ.Ð.ô ˜a  AÓ&Ð&øô9 ò 	!Ø—E‘E�7˜A˜q�=Ò ð	!ûô" &ò Ùðûô &ò Ùðús5   šC1 Â%D ÃD Ã1DÄDÄ	DÄDÄ	D+Ä*D+c                 óV  — |j                   sn	 |j                  «       }t	        | |||«      } t	        ||||«      }t        | |||«      \  }}}t	        ||||«      }t	        ||||«      }t	        ||||«      }|||fS |j                  r4|j                  rt        d«      r	 t        | |||«      S t        | |||«      S |j                  rt        d«      r	 t        | |||«      S t        | |||«      S # t        $ r t        ||«      | |fcY S w xY w# t        $ r Y Œkw xY w# t        $ r Y ŒFw xY w)z'Helper function for `dmp_inner_gcd()`. rþ   )Úis_Exactr  rC   r   r*   Ú_dmp_inner_gcdrE   r«   r>   rü   r@   rÙ   r¬   rø   rÖ   )rG   rH   rS   rI   r  rW   rÉ   rÊ   s           rN   r  r    sL  € à�:Š:ð	'Ø—K‘K“MˆEô ˜˜1˜a Ó'ˆÜ˜˜1˜a Ó'ˆä$ Q¨¨1¨eÓ4‰ˆˆ3�ä˜˜1˜e QÓ'ˆÜ˜#˜q %¨Ó+ˆÜ˜#˜q %¨Ó+ˆà�#�sˆ{ÐØ	
�ŠØ�7Š7”u˜]Ô+ðÜ% a¨¨A¨qÓ1Ð1ô ˜a  A qÓ)Ð)à�7Š7”u˜]Ô+ðÜ% a¨¨A¨qÓ1Ð1ô ˜a  A qÓ)Ð)øô9 ò 	'Ü˜1˜a“= ! QÐ&Ò&ð	'ûô" &ò Ùðûô &ò Ùðús5   ŽC/ ÂD ÃD Ã/D
Ä	D
Ä	DÄDÄ	D(Ä'D(c                 óÀ   — |st        | ||«      S t        | |f||«      \  }\  } }t        | |||«      \  }}}t        ||||«      t        ||||«      t        ||||«      fS )aŒ  
    Computes polynomial GCD and cofactors of `f` and `g` in `K[X]`.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> f = x**2 + 2*x*y + y**2
    >>> g = x**2 + x*y

    >>> R.dmp_inner_gcd(f, g)
    (x + y, x + y, x)

    )r  r'   r  r(   )rG   rH   rS   rI   ÚJrW   rÉ   rÊ   s           rN   Údmp_inner_gcdr	  &  sz   € ñ( Ü˜Q  1Ó%Ð%ä! 1 a &¨!¨QÓ/�I€A�vˆˆ1Ü   A q¨!Ó,�K€A€sˆCä˜˜1˜a Ó#Ü˜˜Q  1Ó%Ü˜˜Q  1Ó%ð'ð 'rP   c                 ó"   — t        | ||«      d   S )zÕ
    Computes polynomial GCD of `f` and `g` in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_gcd(x**2 - 1, x**2 - 3*x + 2)
    x - 1

    r   )r  rz   s      rN   Údup_gcdr  E  s   € ô ˜˜A˜qÓ! !Ñ$Ð$rP   c                 ó$   — t        | |||«      d   S )zþ
    Computes polynomial GCD of `f` and `g` in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> f = x**2 + 2*x*y + y**2
    >>> g = x**2 + x*y

    >>> R.dmp_gcd(f, g)
    x + y

    r   )r	  rR   s       rN   rÆ   rÆ   V  s   € ô" ˜˜A˜q !Ó$ QÑ'Ð'rP   c                 ó  — | r|st        d«      S t        | |«      \  }} t        ||«      \  }}|j                  ||«      }t        t	        | ||«      t        | ||«      |«      }|j                  t        ||«      «      }t        |||z  |«      S )zå
    Computes polynomial LCM over a ring in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_rr_lcm(x**2 - 1, x**2 - 3*x + 2)
    x**3 - 2*x**2 - x + 2

    r   )	r   r7   Úlcmr   r   r  rÍ   r$   r   )rG   rH   rI   rÏ   rÐ   ru   rW   rS   s           rN   Ú
dup_rr_lcmr  j  s�   € ñ ‘AÜ˜‹{Ðä˜!˜QÓ�E€BˆÜ˜!˜QÓ�E€Bˆà	�‰ˆb�"‹€Aä”˜˜1˜aÓ Ü˜˜1˜aÓ  !ó	%€Að 	
×Ñœ  1›Ó&€Aä˜!˜Q˜q™S !Ó$Ð$rP   c                 ó`   — t        t        | ||«      t        | ||«      |«      }t        ||«      S )a  
    Computes polynomial LCM over a field in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = QQ(1,2)*x**2 + QQ(7,4)*x + QQ(3,2)
    >>> g = QQ(1,2)*x**2 + x

    >>> R.dup_ff_lcm(f, g)
    x**3 + 7/2*x**2 + 3*x

    )r   r   r  r5   )rG   rH   rI   rW   s       rN   Ú
dup_ff_lcmr  ˆ  s5   € ô" 	”˜˜1˜aÓ Ü˜˜1˜aÓ  !ó	%€Aô �Q˜‹?ÐrP   c                 óN   — |j                   rt        | ||«      S t        | ||«      S )zå
    Computes polynomial LCM of `f` and `g` in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_lcm(x**2 - 1, x**2 - 3*x + 2)
    x**3 - 2*x**2 - x + 2

    )rE   r  r  rz   s      rN   Údup_lcmr  Ÿ  s)   € ð 	‡z‚zÜ˜!˜Q Ó"Ð"ä˜!˜Q Ó"Ð"rP   c           	      óÎ   — t        | ||«      \  }} t        |||«      \  }}|j                  ||«      }t        t        | |||«      t	        | |||«      ||«      }t        ||||«      S )a  
    Computes polynomial LCM over a ring in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> f = x**2 + 2*x*y + y**2
    >>> g = x**2 + x*y

    >>> R.dmp_rr_lcm(f, g)
    x**3 + 2*x**2*y + x*y**2

    )r8   r  r   r	   rÆ   r   )rG   rH   rS   rI   rÏ   rÐ   ru   rW   s           rN   Ú
dmp_rr_lcmr  ³  ss   € ô" !  A qÓ)�E€BˆÜ   A qÓ)�E€Bˆà	�‰ˆb�"‹€Aä”˜˜1˜a Ó#Ü˜˜1˜a Ó# Q¨ó	+€Aô ˜!˜Q  1Ó%Ð%rP   c           	      óh   — t        t        | |||«      t        | |||«      ||«      }t        |||«      S )a"  
    Computes polynomial LCM over a field in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x,y, = ring("x,y", QQ)

    >>> f = QQ(1,4)*x**2 + x*y + y**2
    >>> g = QQ(1,2)*x**2 + x*y

    >>> R.dmp_ff_lcm(f, g)
    x**3 + 4*x**2*y + 4*x*y**2

    )r   r	   rÆ   r6   )rG   rH   rS   rI   rW   s        rN   Ú
dmp_ff_lcmr  Ï  s>   € ô" 	”˜˜1˜a Ó#Ü˜˜1˜a Ó# Q¨ó	+€Aô ˜A˜q !Ó$Ð$rP   c                 óp   — |st        | ||«      S |j                  rt        | |||«      S t        | |||«      S )a  
    Computes polynomial LCM of `f` and `g` in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> f = x**2 + 2*x*y + y**2
    >>> g = x**2 + x*y

    >>> R.dmp_lcm(f, g)
    x**3 + 2*x**2*y + x*y**2

    )r  rE   r  r  rR   s       rN   Údmp_lcmr  æ  s?   € ñ" Ü�q˜!˜QÓÐà‡z‚zÜ˜!˜Q  1Ó%Ð%ä˜!˜Q  1Ó%Ð%rP   c                 óä   — t        | |«      |dz
  }}t        | |«      r|S | dd D ]  }t        ||||«      }t        |||«      sŒ n |j	                  t        |||«      «      rt        |||«      S |S )zÖ
    Returns GCD of multivariate coefficients.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> R.dmp_content(2*x*y + 6*x + 4*y + 12)
    2*y + 6

    rn   N)r%   r   rÆ   r   rõ   r&   r   ©rG   rS   rI   Úcontr„   ru   s         rN   rÅ   rÅ      s…   € ô �Q˜‹l˜A ™Eˆ!€Dä�!�QÔØˆàˆqˆrˆUò ˆÜ�t˜Q  1Ó%ˆä�T˜1˜aÕ Ùð	ð 	‡}�}”] 4¨¨AÓ.Ô/Ü�t˜Q Ó"Ð"àˆrP   c           
      ó¦   — t        | ||«      |dz
  }}t        | |«      st        |||«      r|| fS || D �cg c]  }t        ||||«      ‘Œ c}fS c c}w )zð
    Returns multivariate content and a primitive polynomial.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> R.dmp_primitive(2*x*y + 6*x + 4*y + 12)
    (2*y + 6, x + 2)

    rn   )rÅ   r   r   r   r  s         rN   rÕ   rÕ     s\   € ô ˜!˜Q Ó" A¨¡Eˆ!€Dä�!�QÔœ9 T¨1¨aÔ0Ø�Qˆwˆà°qÖ:°!”w˜q $¨¨1Õ-Ò:Ð:Ð:ùÒ:s   µAc                 ó"   — t        | |d||¬«      S )zç
    Cancel common factors in a rational function `f/g`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_cancel(2*x**2 - 2, x**2 - 2*x + 1)
    (2*x + 2, x - 1)

    r   )Úinclude)Ú
dmp_cancel)rG   rH   rI   r  s       rN   Ú
dup_cancelr!  5  s   € ô �a˜˜A˜q¨'Ô2Ð2rP   c                 ó°  — d}|j                   rE|j                  r9||j                  «       }}t        | |||d¬«      \  }} t        ||||d¬«      \  }}n|j                  |j                  }}t        | |||«      \  }}	}
|�4|j                  ||«      \  }}}t        |	|||«      }	t        |
|||«      }
|}|j                  t        |	||«      «      }|j                  t        |
||«      «      }|r|rt        |	||«      t        |
||«      }
}	n%|r| t        |	||«      }	}n|r| t        |
||«      }
}|s|||	|
fS t        |	|||«      }	t        |
|||«      }
|	|
fS )zë
    Cancel common factors in a rational function `f/g`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> R.dmp_cancel(2*x**2 - 2, x**2 - 2*x + 1)
    (2*x + 2, x - 1)

    NT)r£   )rE   Úhas_assoc_Ringr¢   r-   rF   r	  Ú	cofactorsr*   rõ   r&   r   r   )rG   rH   rS   rI   r  r¤   ÚcqÚcpri   r†   rL   Úp_negÚq_negs                rN   r   r   F  sp  € ð 
€Bà‡z‚z�a×&Ò&Ø�1—:‘:“<ˆAˆä   A r¨1°dÔ;‰ˆˆAÜ   A r¨1°dÔ;‰ˆ‰Aà—‘˜Ÿ™ˆBˆä˜A˜q ! QÓ'�G€A€qˆ!à	€~Ø—K‘K  BÓ'‰	ˆˆ2ˆrä˜˜1˜a Ó$ˆÜ˜˜1˜a Ó$ˆàˆà�M‰Mœ-¨¨1¨aÓ0Ó1€EØ�M‰Mœ-¨¨1¨aÓ0Ó1€Eá‘Ü�q˜!˜QÓ¤¨¨A¨qÓ!1ˆ1‰Ù	Ø�”W˜Q  1Ó%ˆA‰Ù	Ø�”W˜Q  1Ó%ˆAˆáØ�2�q˜!ˆ|Ðä�q˜"˜a Ó#€AÜ�q˜"˜a Ó#€Aàˆaˆ4€KrP   N)F)T)~Ú__doc__Úsympy.polys.densearithr   r   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Úsympy.polys.densebasicr   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   Úsympy.polys.densetoolsr,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   Úsympy.polys.galoistoolsr<   r=   Úsympy.polys.polyconfigr>   Úsympy.polys.polyerrorsr?   r@   rA   rB   rC   rO   rT   rZ   r\   r^   r`   rd   rf   rj   rl   rx   r{   r   r‚   r‡   r‰   r‹   rŽ   r˜   r    r¨   r­   r¯   r±   rµ   r¸   rÁ   rÃ   r½   rÑ   rÓ   rÖ   rÙ   rë   rß   ró   rö   rø   rú   rü   r  r  r	  r  rÆ   r  r  r  r  r  r  rÅ   rÕ   r!  r   © rP   rN   ú<module>r1     sœ  ðÙ K÷ ÷  ÷  ÷  ÷  ÷  ÷	÷ 	÷ 	÷ 	÷ 	ñ 	÷%÷ %÷ %÷ %ñ %÷å (÷õ ò òF0ò"ò60ò",ò>0ò"%òP0ò"%òP0ò"Mò`/ò"ó2)ò&Mò`2ò.%òPFòR2ò
:òz$+óN,òB ò6#ò>ò$	òò4ò*ò8%òPò>-ò`)ðV €òò g(òTò"h(òV.òb.òb<'ò~!*òH'ò>%ò"(ò(%ò<ò.#ò(&ò8%ò.&ò4ò>;ó,3ô"2rP   