Ë
    7^(h�l  ã                   ó&  — d Z ddlmZ ddlmZ ddlmZ ddlmZm	Z	m
Z
 ddlmZ ddlmZmZ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 ddlmZmZ ddlm Z m!Z!m"Z" ddl#m$Z$ ddl%m&Z& ddl'm(Z(m)Z)m*Z* ddl+m,Z, ddl-m.Z.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z: ddl;m<Z<m=Z= ddl>m?Z? ddl@mAZA ddlBmCZC ddlDmEZE ddlFmGZGmHZHmIZI e)ddfd„ZJd„ ZKd„ ZLd „ ZMd1d"„ZNd#„ ZOd$„ ZPd2d%„ZQd&„ ZRd'„ ZSd(„ ZTd)„ ZUd*„ ZVd+„ ZWd,„ ZXd-„ ZYeHd3d.„«       ZZd/„ Z[eHd3d0„«       Z\y!)4z*Minimal polynomials for algebraic numbers.é    )Úreduce)ÚAdd)ÚFactors)Ú
expand_mulÚexpand_multinomialÚ_mexpand)ÚMul)ÚIÚRationalÚpiÚ_illegal)ÚS)ÚDummy)Úsympify)Úpreorder_traversal)Úexp)ÚsqrtÚcbrt)ÚcosÚsinÚtan)Údivisors)Úsubsets)ÚZZÚQQÚFractionField)Údup_chebyshevt)ÚNotAlgebraicÚGeneratorsError)
ÚPolyÚPurePolyÚinvertÚfactor_listÚgroebnerÚ	resultantÚdegreeÚpoly_from_exprÚparallel_poly_from_exprÚlcm)Údict_from_exprÚexpr_from_dict)Úrs_compose_add)Úring)ÚCRootOf)Úcyclotomic_poly)Únumbered_symbolsÚpublicÚsiftéÈ   é   c           
      óF  — t        | d   t        «      r| D �cg c]  }|d   ‘Œ	 } }t        | «      dk(  r| d   S d}i }t        |d«      r|j                  ng }	||k  �r#| D �cg c]#  }|j                  «       j                  ||i«      ‘Œ% }
}|j                  r|
D �cg c]  }|j                  |«      ‘Œ }
}t        t        |«      t        |	«      d¬«      D ]œ  }t        |	|«      D ]
  \  }}|||<   Œ t        |
«      D ��cg c]0  \  }}t        |j                  |«      j                  |«      «      |f‘Œ2 }}}t        d„ |D «       «      rŒut!        |«      }|dd	 \  \  }}\  }}||d
z  kD  sŒ—| |   c S  |d	z  }||k  r�Œ#t#        d|z  «      ‚c c}w c c}w c c}w c c}}w )ze
    Return a factor having root ``v``
    It is assumed that one of the factors has root ``v``.
    r   é   é
   ÚsymbolsT)ÚkÚ
repetitionc              3   ó2   K  — | ]  \  }}|t         v –— Œ y ­w©N)r   )Ú.0ÚiÚ_s      ú^/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/polys/numberfields/minpoly.pyú	<genexpr>z!_choose_factor.<locals>.<genexpr>H   s   è ø€ Ò8¡T Q¨�1œ”=Ñ8ùs   ‚Né   i@B z4multiple candidates for the minimal polynomial of %s)Ú
isinstanceÚtupleÚlenÚhasattrr8   Úas_exprÚxreplaceÚ	is_numberÚnr   ÚrangeÚzipÚ	enumerateÚabsÚsubsÚanyÚsortedÚNotImplementedError)ÚfactorsÚxÚvÚdomÚprecÚboundÚfÚprec1Úpointsr8   ÚferJ   Úsr>   Ú
candidatesÚcanÚaÚixÚbr?   s                       r@   Ú_choose_factorrc   (   s¾  € ô �'˜!‘*œeÔ$Ø!(Ö)˜A�1�Q“4Ð)ˆÐ)Ü
ˆ7ƒ|�qÒØ�q‰zÐà€EØ€FÜ$ S¨)Ô4ˆc�kŠk¸"€GØ
�4‹-ð 4;Ö;¨aˆa�i‰i‹k×"Ñ" A a 5Õ)Ð;ˆÐ;Ø�;Š;Ø%'Ö( �!—#‘#�d•)Ð(ˆBÐ(ô œ˜u›¬¨W«À$ÔGò 	#ˆAÜ˜G Q›ò ‘��1Ø��q’	ðô
 % R›=÷*Ù�A�aô ˜qŸv™v f›~×/Ñ/°Ó6Ó7¸Ò;ð *ˆJñ *ô
 Ñ8¨ZÔ8Ô8Øô
 ˜Ó$ˆCØ! " 1˜g‰O‰GˆQ�‘V�a˜Ø�1�u‘9‹}Ø˜r‘{Ò"ð'	#ð* 	�‰
ˆð; �4Œ-ô> ÐTÐWXÑXÓ
YÐYùòM *ùò <ùâ(ùó*s   ˜FÁ!(FÂFÃ?5Fc                 óL   — t        d„ t        j                  | «      D «       «      S )Nc              3   ó  K  — | ]y  }t        j                  |«      D ]_  }|j                  xsM |j                  xr? |j                  j                  xr' d |j
                  z  j                  xr |j                  –— Œa Œ{ y­w)rB   N)r	   Ú	make_argsÚis_RationalÚis_PowÚbaser   Ú
is_IntegerÚis_extended_real)r=   ÚtrY   s      r@   rA   z _is_sum_surds.<locals>.<genexpr>Y   s…   è ø€ ò =à¬3¯=©=¸Ó+;ò=à&'ð �}‰}ò K §¡ò !KØ	�‰×Ñò!KØ ! !§%¡%¡×3Ñ3ò!KØ89×8JÑ8JóKð =ð Kñ =ùs   ‚A?B)Úallr   rf   )Úps    r@   Ú_is_sum_surdsro   X   s%   € Üñ =ä—‘˜qÓ!ô=ó =ð =ó    c                 ó  — d„ }g }| j                   D ]ð  }|j                  s¥ ||«      r%|j                  t        j                  |dz  f«       Œ<|j
                  r"|j                  |t        j                  f«       Œj|j                  r8|j                  j                  r"|j                  |t        j                  f«       Œ®t        ‚t        |j                   |d¬«      \  }}|j                  t        |Ž t        |Ž dz  f«       Œò |j                  d„ ¬«       |d   d   t        j                  u r| S |D ��cg c]  \  }}|‘Œ	 }}}t        t        |«      «      D ]  }||   dk7  sŒ n d	d
lm}	  |	|d Ž \  }
}}g }g }|D ]T  \  }}||v r&|j                  ||t        j"                  z  z  «       Œ0|j                  ||t        j"                  z  z  «       ŒV t%        |Ž }t%        |Ž }t'        |dz  «      t'        |dz  «      z
  } | S c c}}w )a?  
    helper function for ``_minimal_polynomial_sq``

    It selects a rational ``g`` such that the polynomial ``p``
    consists of a sum of terms whose surds squared have gcd equal to ``g``
    and a sum of terms with surds squared prime with ``g``;
    then it takes the field norm to eliminate ``sqrt(g)``

    See simplify.simplify.split_surds and polytools.sqf_norm.

    Examples
    ========

    >>> from sympy import sqrt
    >>> from sympy.abc import x
    >>> from sympy.polys.numberfields.minpoly import _separate_sq
    >>> p= -x + sqrt(2) + sqrt(3) + sqrt(7)
    >>> p = _separate_sq(p); p
    -x**2 + 2*sqrt(3)*x + 2*sqrt(7)*x - 2*sqrt(21) - 8
    >>> p = _separate_sq(p); p
    -x**4 + 4*sqrt(7)*x**3 - 32*x**2 + 8*sqrt(7)*x + 20
    >>> p = _separate_sq(p); p
    -x**8 + 48*x**6 - 536*x**4 + 1728*x**2 - 400

    c                 óV   — | j                   xr | j                  t        j                  u S r<   )rh   r   r   ÚHalf)Úexprs    r@   Úis_sqrtz_separate_sq.<locals>.is_sqrtx   s   € Ø�{‰{Ò1˜tŸx™x¬1¯6©6Ð1Ð1rp   rB   T)Úbinaryc                 ó   — | d   S )Nr6   © )Úzs    r@   ú<lambda>z_separate_sq.<locals>.<lambda>‰   s
   € ˜˜1™€ rp   )Úkeyéÿÿÿÿr6   r   )Ú
_split_gcdN)ÚargsÚis_MulÚappendr   ÚOneÚis_Atomrh   r   Ú
is_integerrR   r2   r	   ÚsortrK   rE   Úsympy.simplify.radsimpr}   rs   r   r   )rn   ru   r`   ÚyÚTÚFry   Úsurdsr>   r}   ÚgÚb1Úb2Úa1Úa2Úp1Úp2s                    r@   Ú_separate_sqr‘   ^   sÏ  € ò42ð 	€AØ�V‰Vò ,ˆØ�xŠxÙ�qŒzØ—‘œ!Ÿ%™%  A¡˜Õ'Ø—’Ø—‘˜!œQŸU™U˜Õ$Ø—’˜aŸe™e×.Ò.Ø—‘˜!œQŸU™U˜Õ$ä)Ð)ä˜Ÿ™ °Ô5‰DˆAˆqØ�H‰H”c˜1�gœs A˜w¨™zÐ*Õ+ð,ð ‡F�F‰~€FÔØˆ�uˆQ�x”1—5‘5ÑàˆØ×‘4�1�aŠQÐ€EÑÜ”3�u“:Óò ˆØ�‰8�q‹=Ùðõ 2Ù˜E ! "˜IÐ&�I€A€rˆ2Ø	€BØ	€BØò #‰ˆˆ1Ø�‰7Ø�I‰I�a˜œ1Ÿ6™6™	‘kÕ"à�I‰I�a˜œ1Ÿ6™6™	‘kÕ"ð	#ô
 
ˆbˆ€BÜ	ˆbˆ€BÜ��Q‘‹œ( 2 q¡5›/Ñ)€AØ€Hùó! s   Ä7Hc                 óº  — t        | «      } t        |«      }|j                  r|dkD  rt        | «      sy| t        d|«      z  }| |z  } 	 t	        | «      }|| u r|j                  |||z  i«      } n|} Œ)|dk(  rIt        | «      }| j                  ||j                  |«      z  «      dk  r|  } | j                  «       d   } | S t        | «      d   }t        |||«      }|S )a  
    Returns the minimal polynomial for the ``nth-root`` of a sum of surds
    or ``None`` if it fails.

    Parameters
    ==========

    p : sum of surds
    n : positive integer
    x : variable of the returned polynomial

    Examples
    ========

    >>> from sympy.polys.numberfields.minpoly import _minimal_polynomial_sq
    >>> from sympy import sqrt
    >>> from sympy.abc import x
    >>> q = 1 + sqrt(2) + sqrt(3)
    >>> _minimal_polynomial_sq(q, 3, x)
    x**12 - 4*x**9 - 4*x**6 + 16*x**3 - 8

    r   Nr6   )r   rj   ro   r   r‘   rO   r    Úcoeffr&   Ú	primitiver#   rc   )rn   rJ   rT   Úpnr�   rS   Úresults          r@   Ú_minimal_polynomial_sqr—   Ÿ   sê   € ô. 	�‹
€AÜ�‹
€AØ�<Š<˜q 1šu¬M¸!Ô,<ØØ	
ŒH�Q˜‹NÑ	€Bàˆ�F€AØ
Ü˜!‹_ˆØ�‰7Ø—‘˜˜1˜a™4˜Ó!ˆAØàˆAð ð 	ˆA‚vÜ�!‹WˆØ�7‰7�1�b—i‘i “l‘?Ó# aÒ'Ø�ˆAØ�K‰K‹M˜!ÑˆØˆô ˜!‹n˜QÑ€Gä˜G Q¨Ó+€FØ€Mrp   Nc                 óR  — t        t        |«      «      }|€t        |||«      }|€t        |||«      }n|j                  ||i«      }| t        u r|t
        k(  r<t        dt
        «      \  }}	 |t        |«      d   «      }
 |t        |«      d   «      }n[t        |||z
  f||«      \  \  }
}}|
j                  |«      }|j                  «       }n!| t        u rt        |||«      }nt        d«      ‚| t        u s	|t
        k7  rt        |||g¬«      }n&t        
«      }t!        |j#                  «       |«      }t%        ||«      }t%        ||«      }| t        u r|dk(  s|dk(  r|S t'        |||¬«      }|j)                  «       \  }}t+        || | ||«      |«      }|j                  «       S )aÜ  
    return the minimal polynomial for ``op(ex1, ex2)``

    Parameters
    ==========

    op : operation ``Add`` or ``Mul``
    ex1, ex2 : expressions for the algebraic elements
    x : indeterminate of the polynomials
    dom: ground domain
    mp1, mp2 : minimal polynomials for ``ex1`` and ``ex2`` or None

    Examples
    ========

    >>> from sympy import sqrt, Add, Mul, QQ
    >>> from sympy.polys.numberfields.minpoly import _minpoly_op_algebraic_element
    >>> from sympy.abc import x, y
    >>> p1 = sqrt(sqrt(2) + 1)
    >>> p2 = sqrt(sqrt(2) - 1)
    >>> _minpoly_op_algebraic_element(Mul, p1, p2, x, QQ)
    x - 1
    >>> q1 = sqrt(y)
    >>> q2 = 1 / y
    >>> _minpoly_op_algebraic_element(Add, q1, q2, x, QQ.frac_field(y))
    x**2*y**2 - 2*x*y - y**3 + 1

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Resultant
    .. [2] I.M. Isaacs, Proc. Amer. Math. Soc. 25 (1970), 638
           "Degrees of sums in a separable field extension".

    ÚXr   zoption not available©Úgensr6   ©Údomain)r   ÚstrÚ_minpoly_composerO   r   r   r-   r*   r(   ÚcomposerG   r	   Ú_mulyrR   r%   r,   r+   Úas_expr_dictr&   r    r#   rc   )ÚopÚex1Úex2rT   rV   Úmp1Úmp2r†   ÚRr™   r�   r�   r?   ÚrÚmp1aÚdeg1Údeg2rS   Úress                      r@   Ú_minpoly_op_algebraic_elementr®   Õ   s“  € ôH 	Œc�!‹f‹€AØ
€{Ü˜s A sÓ+ˆØ
€{Ü˜s A sÓ+‰à�h‰h˜˜1�vÓˆà	ŒS�yà”"Š9Ü˜œR“=‰DˆAˆqÙ”> #Ó& qÑ)Ó*ˆBÙ”> #Ó& qÑ)Ó*‰Bä1°3¸¸A¹°,ÀÀ1ÓE‰K‰HˆR��aØ—
‘
˜2“ˆAØ—9‘9“;‰Dà	Œs‰Ü�S˜!˜QÓ‰ä!Ð"8Ó9Ð9à	ŒS�y�Cœ2’IÜ�d˜C q¨! fÔ-‰ä˜2˜rÓ"ˆÜ˜1Ÿ>™>Ó+¨QÓ/ˆä�#�q‹>€DÜ�#�q‹>€DØ	ŒS�y�T˜Q’Y $¨!¢)ð ˆäˆQ�˜#Ô€AØ—‘“�J€A€wÜ
˜ !¡R¨¨S£\°3Ó
7€CØ�;‰;‹=Ðrp   c                 ó¬   — t        | |«      d   }t        |«      }|j                  «       D ��cg c]  \  \  }}||||z
  z  z  ‘Œ }}}t        |Ž S c c}}w )z@
    Returns ``expand_mul(x**degree(p, x)*p.subs(x, 1/x))``
    r   ©r'   r&   Útermsr   )rn   rT   r�   rJ   r>   Úcr`   s          r@   Ú_invertxr³   $  sW   € ô 
˜˜1Ó	˜aÑ	 €Bäˆr‹
€AØ')§x¡x£z×2™G™D˜Q !ˆˆQ��Q‘‰Z‹Ð2€AÑ2Ü�ˆ7€Nùó 	3s   ®Ac                 ó¸   — t        | |«      d   }t        |«      }|j                  «       D ��cg c]  \  \  }}|||z  z  |||z
  z  z  ‘Œ }}}t        |Ž S c c}}w )z8
    Returns ``_mexpand(y**deg*p.subs({x:x / y}))``
    r   r°   )rn   rT   r†   r�   rJ   r>   r²   r`   s           r@   r¡   r¡   /  s`   € ô 
˜˜1Ó	˜aÑ	 €Bäˆr‹
€AØ.0¯h©h«j×9¡7¡4 A¨ˆˆQ�‰T‰�A˜˜A™‘JÓ	Ð9€AÑ9Ü�ˆ7€Nùó 	:s   ®Ac                 óô  — t        |«      }|st        | ||«      }|j                  st        d| z  «      ‚|dk  r.||k(  rt	        d| z  «      ‚t        ||«      }|dk(  r|S | }d| z  } t        t        |«      «      }|j                  ||i«      }|j                  «       \  }}t        t        |||z  ||z  z
  |g¬«      ||¬«      }|j                  «       \  }	}
t        |
|| |z  |«      }|j                  «       S )a”  
    Returns ``minpoly(ex**pw, x)``

    Parameters
    ==========

    ex : algebraic element
    pw : rational number
    x : indeterminate of the polynomial
    dom: ground domain
    mp : minimal polynomial of ``p``

    Examples
    ========

    >>> from sympy import sqrt, QQ, Rational
    >>> from sympy.polys.numberfields.minpoly import _minpoly_pow, minpoly
    >>> from sympy.abc import x, y
    >>> p = sqrt(1 + sqrt(2))
    >>> _minpoly_pow(p, 2, x, QQ)
    x**2 - 2*x - 1
    >>> minpoly(p**2, x)
    x**2 - 2*x - 1
    >>> _minpoly_pow(y, Rational(1, 3), x, QQ.frac_field(y))
    x**3 - y
    >>> minpoly(y**Rational(1, 3), x)
    x**3 - y

    ú+%s does not seem to be an algebraic elementr   z
%s is zeror|   r6   rš   rœ   )r   rŸ   Úis_rationalr   ÚZeroDivisionErrorr³   r   rž   rO   Úas_numer_denomr    r%   r#   rc   rG   )ÚexÚpwrT   rV   Úmpr†   rJ   Údr­   r?   rS   s              r@   Ú_minpoly_powr¾   :  s   € ô< 
�‹€BÙÜ˜b ! SÓ)ˆØ�>Š>ÜÐHÈ2ÑMÓNÐNØ	ˆA‚vØ�Š7Ü# L°2Ñ$5Ó6Ð6Ü�b˜!‹_ˆØ�Š8ØˆIØˆSˆØˆr‰TˆäŒc�!‹f‹€AØ	�‰�!�Q�‹€BØ×ÑÓ�D€A€qÜ
Œy˜˜Q ™T A q¡D™[°¨sÔ3°Q¸sÔ
C€CØ—‘Ó"�J€A€wÜ
˜ ! R¨¡V¨SÓ
1€CØ�;‰;‹=Ðrp   c           	      ó–   — t        t        |d   |d   | |«      }|d   |d   z   }|dd D ]  }t        t        ||| ||¬«      }||z   }Œ |S )z.
    returns ``minpoly(Add(*a), dom, x)``
    r   r6   rB   N©r¦   )r®   r   ©rT   rV   r`   r¼   rn   Úpxs         r@   Ú_minpoly_addrÃ   o  óh   € ô 
'¤s¨A¨a©D°!°A±$¸¸3Ó	?€BØ	ˆ!‰ˆq�‰t‰€AØ��ˆeò ˆÜ*¬3°°2°q¸#À2ÔFˆØ�‰F‰ðð €Irp   c           	      ó–   — t        t        |d   |d   | |«      }|d   |d   z  }|dd D ]  }t        t        ||| ||¬«      }||z  }Œ |S )z.
    returns ``minpoly(Mul(*a), dom, x)``
    r   r6   rB   NrÀ   )r®   r	   rÁ   s         r@   Ú_minpoly_mulrÆ   {  rÄ   rp   c                 ó  — | j                   d   j                  «       \  }}|t        u �rB|j                  �r5|j                  }t        |«      }|j                  r>t        |t        «      }t        t        |«      D �cg c]  }|||z
  dz
  z  ||   z  ‘Œ c}Ž S |j                  dk(  r"|dk(  rd|dz  z  d|dz  z  z
  d|d	z  z  z   d
z
  S |d	z  dk(  r\t        |t        «      }t        |dz   «      D �cg c]  }|||z
  z  ||   z  ‘Œ }}t        |Ž }t        |«      \  }}	t        |	|| «      }
|
S dt        d	|z  t        z  «      z
  d	z  t        j                   z  }t#        ||t$        «      }
|
S t'        d| z  «      ‚c c}w c c}w )zu
    Returns the minimal polynomial of ``sin(ex)``
    see https://mathworld.wolfram.com/TrigonometryAngles.html
    r   r6   é	   é@   é   é`   é   é$   rB   é   r¶   )r~   Úas_coeff_Mulr   r·   Úqr   Úis_primer   r   r   rK   rn   r#   rc   r   r   rs   rŸ   r   r   )rº   rT   r²   r`   rJ   rÐ   r>   r©   r?   rS   r­   rt   s               r@   Ú_minpoly_sinrÒ   ‡  s€  € ð
 �7‰7�1‰:×"Ñ"Ó$�D€A€qØŒB‚wØ�=‹=Ø—‘ˆAÜ˜“
ˆAØ�zŠzô # 1¤bÓ)�Ü¼%À»(ÖC°Q˜Q  Q¡¨¡™^¨A¨a©DÓ0ÒCÐDÐDØ�s‰s�aŠxØ˜’6Ø˜a ™d™7 R¨¨1©¡WÑ,¨r°!°Q±$©wÑ6¸Ñ:Ð:à�1‰u˜Šzô # 1¤bÓ)�Ü.3°A¸±E«lÖ;¨�Q˜˜Q™‘Z  !¡“_Ð;�Ð;Ü˜�G�Ü(¨›^‘
��7Ü$ W¨a°Ó4�Ø�
àœ˜Q˜q™S¤™V›‘_ aÑ'¬!¯&©&Ñ0ˆDÜ" 4¨¬BÓ/ˆCØˆJä
ÐDÀrÑIÓ
JÐJùò) Dùò <s   Á<E:Ã1E?c           	      ó  — | j                   d   j                  «       \  }}|t        u �rM|j                  �r@|j                  dk(  rI|j
                  dk(  rd|dz  z  d|dz  z  z
  d|z  z
  dz   S |j
                  dk(  rxd|dz  z  d	|z  z
  dz
  S |j                  dk(  rXt        |j
                  «      }|j                  r7t        | |«      }t        |j                  |t        d|z
  dz  «      i«      «      S t        |j
                  «      }t        |t        «      }t        |dz   «      D �cg c]  }|||z
  z  ||   z  ‘Œ }}t!        |Ž d
|j                  z  z
  }t#        |«      \  }	}
t%        |
|| «      }|S t'        d| z  «      ‚c c}w )zu
    Returns the minimal polynomial of ``cos(ex)``
    see https://mathworld.wolfram.com/TrigonometryAngles.html
    r   r6   é   é   rÎ   rÌ   rB   rÈ   rÊ   r|   r¶   )r~   rÏ   r   r·   rn   rÐ   r   rÑ   rÒ   r   rO   r   Úintr   r   rK   r   r#   rc   r   )rº   rT   r²   r`   rÐ   r]   rJ   r>   r©   r?   rS   r­   s               r@   Ú_minpoly_cosr×   ­  sr  € ð
 �7‰7�1‰:×"Ñ"Ó$�D€A€qØŒB‚wØ�=‹=Ø�s‰s�aŠxØ—3‘3˜!’8Ø˜Q ™T™6 A a¨¡d¡F™?¨Q¨q©SÑ0°1Ñ4Ð4Ø—3‘3˜!’8Ø˜Q ™T™6 A a¡C™<¨!Ñ+Ð+Ø—‘˜’Ü˜AŸC™C“L�Ø—:’:Ü$ R¨Ó+�AÜ# A§F¡F¨A¬d°A¸±E¸1±9«oÐ+>Ó$?Ó@Ð@ô �A—C‘C“ˆAÜ˜q¤"Ó%ˆAÜ*/°°A±«,Ö7 Q��Q˜‘U‘˜A˜a™D“Ð7ˆAÐ7Ü�Q�˜2 §¡™)Ñ#ˆAÜ$ Q›‰JˆAˆwÜ  ¨!¨RÓ0ˆCØˆJä
ÐDÀrÑIÓ
JÐJùò 8s   Ä+Fc                 óè  — | j                   d   j                  «       \  }}|t        u r½|j                  r±|dz  }t	        |j
                  «      }|j                  dz  dk(  r|nd}g }t        |j                  dz   dz  |dz   d«      D ]7  }|j                  |||z  z  «       |||z
  dz
  z  ||z
  z   |dz   |dz   z  z  }Œ9 t        |Ž }t        |«      \  }}	t        |	|| «      }
|
S t        d| z  «      ‚)zk
    Returns the minimal polynomial of ``tan(ex)``
    see https://github.com/sympy/sympy/issues/21430
    r   rB   r6   r¶   )r~   rÏ   r   r·   rÖ   rÐ   rn   rK   r€   r   r#   rc   r   )rº   rT   r²   r`   rJ   r±   r9   r©   r?   rS   r­   s              r@   Ú_minpoly_tanrÙ   Ì  s  € ð
 �7‰7�1‰:×"Ñ"Ó$�D€A€qØŒB�wØ�=Š=Ø�A‘ˆAÜ�A—C‘C“ˆAØ—S‘S˜1‘W ’\‘ qˆAØˆEÜ˜AŸC™C ™E 1™9 a¨¡c¨1Ó-ò 8�Ø—‘˜Q˜q !™t™VÔ$Ø˜˜1™˜Q™‘i  1¡‘oÐ&¨A¨a©C°!°A±#©;Ñ7‘ð8ô �U�ˆAÜ$ Q›‰JˆAˆwÜ  ¨!¨RÓ0ˆCØˆJä
ÐDÀrÑIÓ
JÐJrp   c                 ó¼  — | j                   d   j                  «       \  }}|t        t        z  k(  �r|j                  rÿt        |j                  «      }|j                  dk(  s|j                  dk(  r˜|dk(  r|dz  |z
  dz   S |dk(  r|dz  dz   S |dk(  r|dz  |dz  z
  dz   S |dk(  r|dz  dz   S |d	k(  r|dz  |dz  z
  dz   S |d
k(  r|dz  |dz  z
  |dz  z   |dz  z
  dz   S |j                  rd}t        |«      D ]  }|| |z  z  }Œ |S t        d|z  «      D �cg c]  }t        ||«      ‘Œ }}t        ||| «      }|S t        d| z  «      ‚t        d| z  «      ‚c c}w )z7
    Returns the minimal polynomial of ``exp(ex)``
    r   r6   r|   rÎ   rB   rÌ   rÊ   rÕ   rÈ   r7   r¶   )r~   rÏ   r
   r   r·   r   rÐ   rn   rÑ   rK   r   r/   rc   r   )	rº   rT   r²   r`   rÐ   r]   r>   rS   r¼   s	            r@   Ú_minpoly_exprÛ   ä  s�  € ð �7‰7�1‰:×"Ñ"Ó$�D€A€qØŒAŒb‰DƒyØ�=Š=Ü˜Ÿ™“ˆAØ�s‰s�aŠx˜1Ÿ3™3 "š9Ø˜’6Ø˜a™4 !™8 a™<Ð'Ø˜’6Ø˜a™4 !™8�OØ˜’6Ø˜a™4 ! Q¡$™;¨™?Ð*Ø˜’6Ø˜a™4 !™8�OØ˜’6Ø˜a™4 ! Q¡$™;¨™?Ð*Ø˜’7Ø˜a™4 ! Q¡$™;¨¨A©Ñ-°°1±Ñ4°qÑ8Ð8Ø—:’:Ø�AÜ" 1›Xò %˜Ø˜q˜b 1™W™™ð%à�Hô 7?¸qÀ¹s³mÖD°” q¨!Õ,ÐDˆGÐDÜ ¨¨BÓ/ˆBØˆIäÐLÈrÑQÓRÐRÜ
ÐDÀrÑIÓ
JÐJùò Es   ÄEc                 óª   — | j                   }|j                  | j                  j                  d   |i«      }t	        ||«      \  }}t        ||| «      }|S )zA
    Returns the minimal polynomial of a ``CRootOf`` object.
    r   )rt   rO   Úpolyr›   r#   rc   )rº   rT   rn   r?   rS   r–   s         r@   Ú_minpoly_rootofrÞ     sO   € ð 	�‰€AØ	�‰�—‘—‘˜Q‘ Ð"Ó#€AÜ˜Q Ó"�J€A€wÜ˜G Q¨Ó+€FØ€Mrp   c           	      ó	  — | j                   r| j                  |z  | j                  z
  S | t        u r6t	        |dz  dz   ||¬«      \  }}t        |«      dk(  r|dz  dz   S |t        z
  S | t        j                  u rQt	        |dz  |z
  dz
  ||¬«      \  }}t        |«      dk(  r|dz  |z
  dz
  S t        ||dt        d«      z   dz  |¬«      S | t        j                  u r‰t	        |dz  |dz  z
  |z
  dz
  ||¬«      \  }}t        |«      dk(  r|dz  |dz  z
  |z
  dz
  S dt        ddt        d«      z  z
  «      z   t        ddt        d«      z  z   «      z   dz  }t        ||||¬«      S t        |d	«      r| |j                  v r|| z
  S |j                  r>t        | «      r3| }| |z  } 	 t!        | «      }|| u rt        t	        | «      d   ||«      S |} Œ+| j"                  rt%        ||g| j&                  ¢­Ž }|S | j(                  �ržt+        | «      j,                  }	t/        |	j1                  «       d
„ «      }
|
d   �rO|t2        k(  �rEt5        |
d   |
d   z   D �� cg c]
  \  }} || z  ‘Œ c} }Ž }t7        |
d   «      }|j9                  «       D �cg c]  }|j                  ‘Œ }}t;        t<        |d«      }t        j>                  }|jA                  |t        jB                  «      }|j1                  «       D ��cg c]$  \  }}||j                  |z  |j                  z  z  ‘Œ& }}}t5        |Ž }tE        ||«      }|j                  ||z  z  |j                  |||z  z  z  z
  }||z  |tG        d|«      z  z  }tI        t4        ||||||¬«      }|S tK        ||g| j&                  ¢­Ž }|S | jL                  r$tO        | jP                  | jR                  ||«      }|S | jT                  tV        u rtY        | |«      }|S | jT                  tZ        u rt]        | |«      }|S | jT                  t^        u rta        | |«      }|S | jT                  tR        u rtc        | |«      }|S | jT                  td        u rtg        | |«      }|S ti        d| z  «      ‚c c} }w c c}w c c}}w )a¡  
    Computes the minimal polynomial of an algebraic element
    using operations on minimal polynomials

    Examples
    ========

    >>> from sympy import minimal_polynomial, sqrt, Rational
    >>> from sympy.abc import x, y
    >>> minimal_polynomial(sqrt(2) + 3*Rational(1, 3), x, compose=True)
    x**2 - 2*x - 1
    >>> minimal_polynomial(sqrt(y) + 1/y, x, compose=True)
    x**2*y**2 - 2*x*y - y**3 + 1

    rB   r6   rœ   r4   )rV   rÎ   é   é!   r8   c                 óB   — | d   j                   xr | d   j                   S )Nr   r6   )rg   )Úitxs    r@   rz   z"_minpoly_compose.<locals>.<lambda>J  s   € ¨¨A©×(:Ñ(:Ò(Q¸sÀ1¹v×?QÑ?Q€ rp   TFN)r¦   r§   r¶   )5rg   rÐ   rn   r
   r#   rE   r   ÚGoldenRatiorc   r   ÚTribonacciConstantr   rF   r8   Úis_QQro   r‘   Úis_AddrÃ   r~   r   r   rS   r2   Úitemsr   r	   ÚdictÚvaluesr   r)   ÚNegativeOneÚpopÚZeroÚminimal_polynomialr   r®   rÆ   rh   r¾   ri   r   Ú	__class__r   rÒ   r   r×   r   rÙ   rÛ   r.   rÞ   r   )rº   rT   rV   r?   rS   ÚfacrU   r¤   r­   rY   r©   ÚbxÚr1r†   ÚdensÚlcmdensÚneg1Úexpn1ri   Únumsr¥   r¦   r§   s                          r@   rŸ   rŸ     ss  € ð  
‡~‚~Ø�t‰t�A‰v˜Ÿ™‰}ÐØ	ŒQ�wÜ   A¡¨¡¨1°SÔ9‰
ˆˆ7Ü˜w›<¨1Ò,ˆq�!‰t�a‰xÐ7°!´a±%Ð7à	ŒQ�]‰]ÑÜ   A¡¨¡¨A¡¨q¸Ô=‰
ˆˆ7Üˆw‹<˜1ÒØ�a‘4˜!‘8˜a‘<Ðä! '¨1¨q´4¸³7©{¸A©oÀ3ÔGÐGà	ŒQ×!Ñ!Ñ!Ü   A¡¨¨1©¡¨q¡°1Ñ!4°aÀÔD‰
ˆˆ7Üˆw‹<˜1ÒØ�a‘4˜!˜Q™$‘; ‘? QÑ&Ð&à”t˜B ¤4¨£8¡™OÓ,Ñ,¬t°B¸¼4À»8¹±OÓ/DÑDÈÑIˆCÜ! '¨1¨c°sÔ;Ð;äˆs�IÔ 2¨¯©Ñ#4Ø�2‰vˆà
‡y‚y”] 2Ô&àˆØ
ˆa‰ˆØÜ˜rÓ"ˆCØ�b‰yÜ%¤k°"£o°aÑ&8¸!¸QÓ?Ð?à�ð ð 
‡y‚yÜ˜1˜cÐ, B§G¡GÒ,ˆðL €JðK 
�‹Ü�B‹K×ÑˆÜ�—‘“ÑQÓRˆØˆT‹7�sœb“yÜ¨Q¨u©X¸¸$¹Ñ-?×@¡6 2 r˜˜B›Ó@ÐAˆCÜ�a˜‘g“ˆBØ!#§¡£Ö-˜A�A—C“CÐ-ˆDÐ-ÜœS $¨Ó*ˆGÜ—=‘=ˆDØ—F‘F˜4¤§¡Ó(ˆEØ>@¿h¹h»j×I±7°4¸�D˜1Ÿ3™3˜w™;¨!¯#©#Ñ-Ó.ÐIˆDÑIÜ�t�*ˆCÜ$ S¨!Ó,ˆCð —%‘%˜˜7™
Ñ" S§U¡U¨4°%¸±-Ñ+@Ñ%@Ñ@ˆCØ˜‘+ ¤X¨a°Ó%9Ñ 9Ñ9ˆCÜ/´°S¸#¸qÀ#È3ÐTWÔXˆCð" €Jô ˜q #Ð0¨¯©Ò0ˆCð €Jð 
�ŠÜ˜2Ÿ7™7 B§F¡F¨A¨sÓ3ˆð €Jð 
�‰œÑ	Ü˜2˜qÓ!ˆð €Jð 
�‰œÑ	Ü˜2˜qÓ!ˆð €Jð 
�‰œÑ	Ü˜2˜qÓ!ˆð €Jð 
�‰œÑ	Ü˜2˜qÓ!ˆð
 €Jð	 
�‰œÑ	 Ü˜b !Ó$ˆð €Jô ÐHÈ2ÑMÓNÐNùóA Aùâ-ùó Js   ÉQ<
ÊRË0)Rc                 ó
  — t        | «      } | j                  rt        | d¬«      } t        | «      D ]  }|j                  sŒd} n |�t        |«      t
        }}nt        d«      t        }}|s6| j                  r$t        t        t        | j                  «      «      }nt        }t        |d«      r||j                  v rt        d|›d|›�«      ‚|rtt        | ||«      }|j!                  «       d   }|j#                  |t%        ||«      z  «      }|j&                  rt)        | «      }|r |||d¬	«      S |j+                  |«      S |j,                  st/        d
«      ‚t1        | ||«      }|r |||d¬	«      S |j+                  |«      S )a-  
    Computes the minimal polynomial of an algebraic element.

    Parameters
    ==========

    ex : Expr
        Element or expression whose minimal polynomial is to be calculated.

    x : Symbol, optional
        Independent variable of the minimal polynomial

    compose : boolean, optional (default=True)
        Method to use for computing minimal polynomial. If ``compose=True``
        (default) then ``_minpoly_compose`` is used, if ``compose=False`` then
        groebner bases are used.

    polys : boolean, optional (default=False)
        If ``True`` returns a ``Poly`` object else an ``Expr`` object.

    domain : Domain, optional
        Ground domain

    Notes
    =====

    By default ``compose=True``, the minimal polynomial of the subexpressions of ``ex``
    are computed, then the arithmetic operations on them are performed using the resultant
    and factorization.
    If ``compose=False``, a bottom-up algorithm is used with ``groebner``.
    The default algorithm stalls less frequently.

    If no ground domain is given, it will be generated automatically from the expression.

    Examples
    ========

    >>> from sympy import minimal_polynomial, sqrt, solve, QQ
    >>> from sympy.abc import x, y

    >>> minimal_polynomial(sqrt(2), x)
    x**2 - 2
    >>> minimal_polynomial(sqrt(2), x, domain=QQ.algebraic_field(sqrt(2)))
    x - sqrt(2)
    >>> minimal_polynomial(sqrt(2) + sqrt(3), x)
    x**4 - 10*x**2 + 1
    >>> minimal_polynomial(solve(x**3 + x + 3)[0], x)
    x**3 + x + 3
    >>> minimal_polynomial(sqrt(y), x)
    x**2 - y

    T)Ú	recursiveFrT   r8   zthe variable z$ is an element of the ground domain r6   )Úfieldz!groebner method only works for QQ)r   rI   r   r   Úis_AlgebraicNumberr    r   r!   Úfree_symbolsr   r   ÚlistrF   r8   r   rŸ   r”   r“   r&   Úis_negativer   Úcollectræ   rR   Ú_minpoly_groebner)	rº   rT   r    Úpolysr�   rt   Úclsr–   r²   s	            r@   rî   rî   p  si  € ôn 
�‹€BØ	‡|‚|ä�b DÔ)ˆÜ" 2Ó&ò ˆØ×"Ó"ØˆGÙðð
 	€}Ü˜“œTˆ3‰ä�s“œXˆ3ˆáØ�?Š?Ü"¤2¤t¨B¯O©OÓ'<Ó=‰FäˆFÜˆv�yÔ! a¨6¯>©>Ñ&9ÝÚ-.±ð8ó 9ð 	9ñ Ü! " a¨Ó0ˆØ×!Ñ!Ó# AÑ&ˆØ�L‰L˜œF 6¨1Ó-Ñ-Ó.ˆØ�=Š=Ü  Ó(ˆFÙ-2‰s�6˜1 DÔ)ÐI¸¿¹ÀqÓ8IÐIà�<Š<Ü!Ð"EÓFÐFä˜r 1 cÓ*€FÙ).‰3ˆv�q Ô%ÐE°F·N±NÀ1Ó4EÐErp   c                 ó’  ‡‡‡‡‡‡‡— t        dt        ¬«      Ši i cŠŠdˆˆˆfd„	Šˆˆˆˆˆˆfd„Šd„ }d}t        | «      } | j                  r| j	                  «       j                  ‰«      S | j                  r| j                  ‰z  | j                  z
  }nø || «      }|r| dz  } d}| j                  r@d	| j                  z  j                  r'd	| j                  z  }t        | j                  |‰«      }n&t        | «      rt        | t        j                   ‰«      }|�|}|€o ‰| «      }‰|z
  gt#        ‰j%                  «       «      z   }	t'        |	t#        ‰j%                  «       «      ‰gz   d
¬«      }
t)        |
d   «      \  }}t+        |‰| «      }|r9t-        ‰«      }|j/                  ‰t1        |‰«      z  «      dk  rt3        | «      }S )a/  
    Computes the minimal polynomial of an algebraic number
    using Groebner bases

    Examples
    ========

    >>> from sympy import minimal_polynomial, sqrt, Rational
    >>> from sympy.abc import x
    >>> minimal_polynomial(sqrt(2) + 3*Rational(1, 3), x, compose=False)
    x**2 - 2*x - 1

    r`   )r  Nc                 óp   •— t        ‰«      }|‰| <   |�||z  |z   ‰| <   |S  |j                  |«      ‰| <   |S r<   )ÚnextrG   )rº   r   ri   r`   Ú	generatorÚmappingr8   s       €€€r@   Úupdate_mappingz)_minpoly_groebner.<locals>.update_mappingß  sM   ø€ Ü�‹OˆØˆ�‰àÐØ˜S™& 4™-ˆG�B‰Kð ˆð &˜#Ÿ+™+ a›.ˆG�B‰Kàˆrp   c                 ó¾  •— | j                   r4| t        j                  u r| ‰
vr
 ‰| dd«      S ‰|    S | j                  �r| S | j                  r&t        | j                  D �cg c]
  } ‰|«      ‘Œ c}Ž S | j                  r&t        | j                  D �cg c]
  } ‰|«      ‘Œ c}Ž S | j                  �rh| j                  j                  �r}| j                  dk  r‚t        | j                  ‰‰	«      }t        ‰|«      j                  «       }|j                  ‰| j                  «      j!                  «       }| j                  dk(  r ‰|«      S || j                   z  } | j                  j"                  sR| j                  | j                  j$                  z  j!                  «       t'        d| j                  j(                  «      }}n| j                  | j                  }} ‰|«      }||z  }|‰
vr*|j"                  r|j!                  «       S  ‰|d|z  | «      S ‰|   S | j*                  r | ‰
vr ‰| | j-                  «       «      S ‰|    S t/        d| z  «      ‚c c}w c c}w )aÓ  
        Transform a given algebraic expression *ex* into a multivariate
        polynomial, by introducing fresh variables with defining equations.

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

        The critical elements of the algebraic expression *ex* are root
        extractions, instances of :py:class:`~.AlgebraicNumber`, and negative
        powers.

        When we encounter a root extraction or an :py:class:`~.AlgebraicNumber`
        we replace this expression with a fresh variable ``a_i``, and record
        the defining polynomial for ``a_i``. For example, if ``a_0**(1/3)``
        occurs, we will replace it with ``a_1``, and record the new defining
        polynomial ``a_1**3 - a_0``.

        When we encounter a negative power we transform it into a positive
        power by algebraically inverting the base. This means computing the
        minimal polynomial in ``x`` for the base, inverting ``x`` modulo this
        poly (which generates a new polynomial) and then substituting the
        original base expression for ``x`` in this last polynomial.

        We return the transformed expression, and we record the defining
        equations for new symbols using the ``update_mapping()`` function.

        rB   r6   r   r|   z*%s does not seem to be an algebraic number)r‚   r   ÚImaginaryUnitrg   rç   r   r~   r   r	   rh   r   r   ri   r"   rG   rO   Úexpandrj   rn   r   rÐ   rû   Úminpoly_of_elementr   )rº   rŠ   Úminpoly_baseÚinverseÚbase_invri   r   rt   Úbottom_up_scanr  r  r8   r  rT   s           €€€€€€r@   r  z)_minpoly_groebner.<locals>.bottom_up_scanê  s  ø€ ð8 �:Š:Ø”Q—_‘_Ñ$Ø˜WÑ$Ù)¨"¨a°Ó3Ð3à" 2™;Ð&Ø—“Ø�	Ø�YŠYÜ°R·W±WÖ>°™.¨Õ+Ò>Ð?Ð?Ø�YŠYÜ°R·W±WÖ>°™.¨Õ+Ò>Ð?Ð?Ø�Y‹YØ�v‰v×!Ó!Ø—6‘6˜A’:Ü#4°R·W±W¸aÀÓ#E�LÜ$ Q¨Ó5×=Ñ=Ó?�GØ&Ÿ|™|¨A¨r¯w©wÓ7×>Ñ>Ó@�Hà—v‘v ’|Ù-¨hÓ7Ð7à%¨¯©¨Ñ0˜Ø—v‘v×(Ò(àŸ™ §¡§¡Ñ)¯6©6«8´X¸aÀÇÁÇÁÓ5Jð ‘Dð !#§¡¨¯©˜#�DÙ% dÓ+�Ø˜S‘y�à˜wÑ&Ø—~’~Ø#Ÿ{™{›}Ð,á-¨d°A¸±G¸d¸UÓCÐCà" 4™=Ð(Ø×"Ò"Ø˜Ñ Ù% b¨"×*?Ñ*?Ó*AÓBÐBà˜r‘{Ð"äÐGÈ"ÑLÓMÐMùòG ?ùâ>s   Á!IÂIc                 ód  — | j                   r?d| j                  z  j                  r&| j                  dk  r| j                  j                  ry| j
                  rYd}| j                  D ]E  }|j                  r y|j                   sŒ|j                  j                  sŒ5|j                  dkD  sŒE y |ryy)z
        Returns True if it is more likely that the minimal polynomial
        algorithm works better with the inverse
        r6   r   TF)rh   r   rƒ   ri   rç   r   r~   )rº   Úhitrn   s      r@   Úsimpler_inversez*_minpoly_groebner.<locals>.simpler_inverse4  s‡   € ð
 �9Š9Ø�"—&‘&‘×$Ò$¨¯©°!ªØ—7‘7—>’>ØØ�9Š9ØˆCØ—W‘Wò %�Ø—8’8Ù Ø—8“8Ø—v‘v—}“}¨¯©°«Ù$ð%ñ ØØrp   Fr|   r6   Úlex)Úorderr   r<   )r0   r   r   rû   r  rG   rg   rÐ   rn   rh   r   rj   r—   ri   ro   r   r�   rý   rê   r$   r#   rc   r³   r“   r&   r   )rº   rT   r  r  Úinvertedr–   r­   rJ   Úbusrˆ   ÚGr?   rS   r  r  r  r8   r  s    ``          @@@@@r@   r   r   Í  s¤  þ€ ô ! ¬%Ô0€IØ˜2Ð€GˆW÷	÷HNñ HNòTð, €HÜ	˜BÓ	€BØ	×ÒØ×$Ñ$Ó&×.Ñ.¨qÓ1Ð1Ø	�ŠØ—‘�a‘˜"Ÿ$™$‘‰á" 2Ó&ˆÙØ�R‘ˆBØˆØ�9Š9˜!˜BŸF™F™(×.Ò.Ø�"—&‘&‘ˆAÜ(¨¯©°!°QÓ7‰Cä˜2ÔÜ(¨¬Q¯U©U°AÓ6ˆCàˆ?ØˆFàˆ;Ù  Ó$ˆCØ�S‘�	œD §¡Ó!1Ó2Ñ2ˆAÜ˜œD §¡Ó!1Ó2°a°SÑ8ÀÔFˆAä$ Q r¡UÓ+‰JˆAˆwä# G¨Q°Ó3ˆFÙÜ˜& !Ó$ˆØ�<‰<˜œ6 &¨!Ó,Ñ,Ó-°Ò1Ü  Ó(ˆFà€Mrp   c                 ó"   — t        | ||||¬«      S )z6This is a synonym for :py:func:`~.minimal_polynomial`.)rT   r    r  r�   )rî   )rº   rT   r    r  r�   s        r@   Úminpolyr  o  s   € ô ˜b A¨w¸eÈFÔSÐSrp   )NNr<   )NTFN)]Ú__doc__Ú	functoolsr   Úsympy.core.addr   Úsympy.core.exprtoolsr   Úsympy.core.functionr   r   r   Úsympy.core.mulr	   Úsympy.core.numbersr
   r   r   r   Úsympy.core.singletonr   Úsympy.core.symbolr   Úsympy.core.sympifyr   Úsympy.core.traversalr   Ú&sympy.functions.elementary.exponentialr   Ú(sympy.functions.elementary.miscellaneousr   r   Ú(sympy.functions.elementary.trigonometricr   r   r   Úsympy.ntheory.factor_r   Úsympy.utilities.iterablesr   Úsympy.polys.domainsr   r   r   Úsympy.polys.orthopolysr   Úsympy.polys.polyerrorsr   r   Úsympy.polys.polytoolsr    r!   r"   r#   r$   r%   r&   r'   r(   r)   Úsympy.polys.polyutilsr*   r+   Úsympy.polys.ring_seriesr,   Úsympy.polys.ringsr-   Úsympy.polys.rootoftoolsr.   Úsympy.polys.specialpolysr/   Úsympy.utilitiesr0   r1   r2   rc   ro   r‘   r—   r®   r³   r¡   r¾   rÃ   rÆ   rÒ   r×   rÙ   rÛ   rÞ   rŸ   rî   r   r  rx   rp   r@   ú<module>r5     s  ðÙ 0å å Ý (ß HÑ HÝ ß :Ó :Ý "Ý #Ý &Ý 3Ý 6ß ?ß BÑ BÝ *Ý -ç 5Ñ 5Ý 1÷÷÷ ÷ ÷ AÝ 2Ý "Ý +Ý 4÷ñ ð
 ')¨s¸!ó -Zò`=ò?òB4ólLò^òó2òj	ò	ò#KòLKò>Kò0!KòHòZðz òYFó ðYFòx_ðD òTó ñTrp   