+
    0åûj�l  ã                   ó2  € R t ^ RIHt ^ RIHt ^ RIHt ^ RIHtH	t	H
t
 ^ RIHt ^ RIHtHtHtHt ^ RIHt ^ RIHt ^ R	IHt ^ R
IHt ^ RIHt ^ RIHtHt ^ RIH t H!t!H"t" ^ RI#H$t$ ^ RI%H&t& ^ RI'H(t(H)t)H*t* ^ RI+H,t, ^ RI-H.t.H/t/ ^ RI0H1t1H2t2H3t3H4t4H5t5H6t6H7t7H8t8H9t9H:t: ^ RI;H<t<H=t= ^ RI>H?t? ^ RI@HAtA ^ RIBHCtC ^ RIDHEtE ^ RIFHGtGHHtHHItI ])^È^3R ltJR tKR tLR tMR.R ltNR  tOR! tPR/R" ltQR# tRR$ tSR% tTR& tUR' tVR( tWR) tXR* tY]HR0R+ l4       tZR, t[]HR0R- l4       t\R# )1z*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Úsiftc           
     ó  € \        V ^ ,          \        4      '       d   V  Uu. uF  qf^ ,          NK  	  p p\        V 4      ^8X  d
   V ^ ,          # ^
p/ p\        VR4      '       d   VP                  M. p	Wt8:  Edd   V  Uu. uF"  qfP                  4       P                  W/4      NK$  	  p
pVP                  '       d    V
 Uu. uF  qfP                  V4      NK  	  p
p\        \        V4      \        V	4      RR7       FÔ  p\        W›4       F	  w  rÍWØV&   K  	  \        V
4       UUu. uF0  w  rÖ\        VP                  V4      P                  V4      4      V3NK2  	  ppp\        ;QJ d    R V 4       F  '       g   K   RM	  RM! R V 4       4      '       d   Kž  \!        V4      pVR,          w  w  ppw  ppVVR,          8”  g   KË  V V,          u # 	  V^,          pEKj  \#        RV,          4      hu upi u upi u upi u uppi )	zY
Return a factor having root ``v``
It is assumed that one of the factors has root ``v``.
ÚsymbolsT)ÚkÚ
repetitionc              3   ó8   "  € T F  w  rV\         9   x € K  	  R # 5i©N)r   )Ú.0ÚiÚ_s   &  Ú\C:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\sympy\polys\numberfields\minpoly.pyÚ	<genexpr>Ú!_choose_factor.<locals>.<genexpr>H   s   é € Ð8©Z¡T Q�1œ–=«Zùs   ‚F:Né   Nz4multiple candidates for the minimal polynomial of %si@B )Ú
isinstanceÚtupleÚlenÚhasattrr3   Úas_exprÚxreplaceÚ	is_numberÚnr   ÚrangeÚzipÚ	enumerateÚabsÚsubsÚanyÚsortedÚNotImplementedError)ÚfactorsÚxÚvÚdomÚprecÚboundÚfÚprec1Úpointsr3   ÚferF   Úsr9   Ú
candidatesÚcanÚaÚixÚbr:   s   &&&&&&              r;   Ú_choose_factorr_   (   s¹  € ô �'˜!•*œe×$Ò$Ù!(Ó)¡˜A�Q—4�4¡ˆÐ)Ü
ˆ7ƒ|�qÔØ�q�zÐà€EØ€FÜ$ S¨)×4Ò4ˆc�kŠk¸"€GØ
�-ñ 4;Ó;±7¨a�i‰i‹k×"Ñ" A 5Ö)±7ˆÐ;Ø�;�;ˆ;Ù%'Ó(¡R —#‘#�d–)¡RˆBÐ(ô œ˜u›¬¨W«À$×GˆAÜ˜Gž‘�Ø�q“	ñ (ô
 % Rœ=ô*Ù(‘C�Aô ˜qŸv™v f›~×/Ñ/°Ó6Ó7¸Ó;Ù(ð ñ *÷
 ‹sÑ8©ZÓ8�s�sŠsÑ8©ZÓ8×8Ò8Ùô
 ˜Ó$ˆCØ! "�g‰O‰GˆQ�‘V�a˜Ø�1�u•9Ž}Ø˜r•{Ò"ñ' Hð* 	��
‹ä
ÐTÐWXÕXÓ
YÐYùòM *ùò <ùâ(ùó*s   ¢G.Á=(G3Â=G8Ä!6G=c                 óº   € \         ;QJ d0    R  \        P                  ! V 4       4       F  '       d   K   R# 	  R# ! R  \        P                  ! V 4       4       4      # )c              3   óJ  "  € T F™  p\         P                  ! V4       F|  pVP                  ;'       gd    VP                  ;'       dP    VP                  P                  ;'       d2    ^VP
                  ,          P                  ;'       d    VP                  x € K~  	  K›  	  R# 5i)r>   N)r   Ú	make_argsÚis_RationalÚis_PowÚbaser   Ú
is_IntegerÚis_extended_real)r8   ÚtrU   s   &  r;   r<   Ú _is_sum_surds.<locals>.<genexpr>Y   s”   é € ð =á!ˆA¬3¯=ª=¸Ö+; að �}‰}÷ Kð K §¡÷ !Kð !KØ	�‰×Ñ÷!Kð !KØ ! !§%¡%¥×3Ñ3÷!Kð !KØ89×8JÑ8JôKá+;ñKã!ùs   ‚0B#³B#ÁB#Á%$B#Â
B#FT)Úallr   rb   )Úps   &r;   Ú_is_sum_surdsrl   X   sO   € ß‹3ñ =ä—’˜qÔ!ó=�3Œ3ð =Š3ð =ˆ3ñ =ä—’˜qÔ!ó=ó =ð =ó    c                óÚ  € R p. pV P                    EF  pVP                  '       gÅ   V! V4      '       d+   VP                  \        P                  V^,          34       KN  VP
                  '       d$   VP                  V\        P                  34       Kƒ  VP                  '       d@   VP                  P                  '       d$   VP                  V\        P                  34       KÔ  \        h\        VP                   VRR7      w  rEVP                  \        V!  \        V!  ^,          34       EK  	  VP                  R R7       VR,          ^,          \        P                  J d   V # V UUu. uF  w  r6VNK	  	  ppp\        \        V4      4       F  pWx,          ^8w  g   K   M	  ^ RIHp	 V	! VXR !  w  r«p. p. pV Fe  w  r6Wk9   d/   VP                  W6\        P"                  ,          ,          4       K9  VP                  W6\        P"                  ,          ,          4       Kg  	  \%        V!  p\%        V!  p\'        V^,          4      \'        V^,          4      ,
          p V # u uppi )	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                 ób   € V P                   ;'       d    V P                  \        P                  J # r7   )rd   r   r   ÚHalf)Úexprs   &r;   Úis_sqrtÚ_separate_sq.<locals>.is_sqrtx   s!   € Ø�{‰{×1Ð1˜tŸx™x¬1¯6©6Ð1Ð1rm   T)Úbinaryc                 ó   € V ^,          # )é   © )Úzs   &r;   Ú<lambda>Ú_separate_sq.<locals>.<lambda>‰   s   € ˜˜1žrm   )Úkey)Ú
_split_gcdNéÿÿÿÿ)ÚargsÚis_MulÚappendr   ÚOneÚis_Atomrd   r   Ú
is_integerrN   r1   r   ÚsortrG   rA   Úsympy.simplify.radsimpr|   rp   r   r   )rk   rr   r\   ÚyÚTÚFrx   Úsurdsr9   r|   ÚgÚb1Úb2Úa1Úa2Úp1Úp2s   &                r;   Ú_separate_sqr‘   ^   s¼  € ò42ð 	€AØ�V�VˆØ�x�xˆxÙ�q�zŠzØ—‘œ!Ÿ%™%  A¥˜Ö'Ø——�Ø—‘˜!œQŸU™U˜Ö$Ø——�˜aŸe™e×.×.Ð.Ø—‘˜!œQŸU™U˜Ö$ä)Ð)ä˜Ÿ™ °Ô5‰DˆAØ�H‰H”c˜1‘gœs A™w¨�zÐ*×+ñ ð ‡F�F‰~€FÔØˆ…uˆQ…x”1—5‘5ÓàˆÙÔ™1‘4�1‹Q™1€EÑÜ”3�u“:ÖˆØ�8�qŽ=Ùñ õ 2Ù˜E ! "˜IÑ&�I€Aˆ2Ø	€BØ	€BÛ‰ˆØŒ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   Å/I'c                ó  € \        V 4      p \        V4      pVP                  '       d   V^ 8”  d   \        V 4      '       g   R# V \        ^V4      ,          pW,          p  \	        V 4      pW@J d   VP                  W"V,          /4      p MTp K/  V^8X  dS   \        V 4      pV P                  W$P                  V4      ,          4      ^ 8  d   V ) p V P                  4       ^,          p V # \        V 4      ^,          p\        WRV4      pV# )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

N)r   rf   rl   r
   r‘   rK   r   Úcoeffr%   Ú	primitiver"   r_   )rk   rF   rP   Úpnr�   rO   Úresults   &&&    r;   Ú_minimal_polynomial_sqr—   Ÿ   sà   € ô. 	�‹
€AÜ�‹
€AØ�<�<ˆ<˜q 1œu¬M¸!×,<Ò,<ÙØ	
ŒH�Q˜‹NÕ	€Bà…F€AØ
Ü˜!‹_ˆØ‹7Ø—‘˜˜a�4˜Ó!ˆAØàŠAð
 	ˆA„vÜ�!‹WˆØ�7‰7�1—i‘i “l•?Ó# aÔ'Ø�ˆAØ�K‰K‹M˜!ÕˆØˆô ˜!‹n˜QÕ€Gä˜G¨Ó+€FØ€Mrm   Nc                óv  € \        \        V4      4      pVf   \        WV4      pVf   \        W'V4      pMVP                  W7/4      pV \        J dŠ   V\
        8X  dD   \        R\
        4      w  r‰V! \        V4      ^ ,          4      p
V! \        V4      ^ ,          4      pM]\        WSV,
          3W74      w  w  r«pV
P                  V4      pVP                  4       pM"V \        J d   \        WSV4      pM\        R4      hV \        J g   V\
        8w  d   \        XWgV.R7      pM&\        X
X4      p\!        VP#                  4       V4      p\%        WS4      p\%        Wg4      pV \        J d   V^8X  g   V^8X  d   V# \'        WÓVR7      pVP)                  4       w  pp\+        VW0! W4      V4      pVP                  4       # )ap  
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".

ÚXzoption not available©Úgens©Údomain)r   ÚstrÚ_minpoly_composerK   r   r   r,   r)   r'   ÚcomposerC   r   Ú_mulyrN   r$   r+   r*   Úas_expr_dictr%   r   r"   r_   )ÚopÚex1Úex2rP   rR   Úmp1Úmp2r†   ÚRr™   r�   r�   r:   ÚrÚmp1aÚdeg1Údeg2rO   Úress   &&&&&&&            r;   Ú_minpoly_op_algebraic_elementr®   Õ   sy  € ôH 	Œc�!‹f‹€AØ
‚{Ü˜s sÓ+ˆØ
‚{Ü˜s sÓ+‰à�h‰h˜�vÓˆà	ŒSƒyà”"Œ9Ü˜œR“=‰DˆAÙ”> #Ó& qÕ)Ó*ˆBÙ”> #Ó& qÕ)Ó*‰Bä1°3¸A½°,ÀÓE‰K‰HˆR�aØ—
‘
˜2“ˆAØ—9‘9“;‰Dà	Œs‹Ü�S˜QÓ‰ä!Ð"8Ó9Ð9à	ŒSƒy�Cœ2”IÜ�d˜C¨! fÔ-‰ä˜2˜rÓ"ˆÜ˜1Ÿ>™>Ó+¨QÓ/ˆä�#‹>€DÜ�#‹>€DØ	ŒSƒy�T˜Q”Y $¨!¤)ð ˆäˆQ˜#Ô€AØ—‘“�J€A€wÜ
˜ ! R¨£\°3Ó
7€CØ�;‰;‹=Ðrm   c                óÊ   € \        W4      ^ ,          p\        V4      pVP                  4        UUu. uF  w  w  rEWQW4,
          ,          ,          NK  	  ppp\        V!  # u uppi )z8
Returns ``expand_mul(x**degree(p, x)*p.subs(x, 1/x))``
©r&   r%   Útermsr   )rk   rP   r�   rF   r9   Úcr\   s   &&     r;   Ú_invertxr³   $  sR   € ô 
˜Ó	˜aÕ	 €Bäˆr‹
€AØ')§x¡x¤zÔ2¡z™G™D˜Qˆ�•�Z�ˆ¡z€AÑ2Ü�‰7€Nùó 	3s   ±"Ac                óæ   € \        W4      ^ ,          p\        V4      pVP                  4        UUu. uF*  w  w  rVWaV,          ,          W$V,
          ,          ,          NK,  	  ppp\        V!  # u uppi )z0
Returns ``_mexpand(y**deg*p.subs({x:x / y}))``
r°   )rk   rP   r†   r�   rF   r9   r²   r\   s   &&&     r;   r¡   r¡   /  s\   € ô 
˜Ó	˜aÕ	 €Bäˆr‹
€AØ.0¯h©h¬jÔ9©j¡7¡4 Aˆ��T��A˜A�•J×	Ð	©j€AÑ9Ü�‰7€Nùó 	:s   ±0A-c                ó:  € \        V4      pV'       g   \        WV4      pVP                  '       g   \        RV ,          4      hV^ 8  d9   WB8X  d   \	        RV ,          4      h\        WB4      pVR8X  d   V# V) p^V ,          p \        \        V4      4      pVP                  W%/4      pVP                  4       w  rg\        \        WBV,          WV,          ,
          V.R7      W#R7      pVP                  4       w  rš\        W¢W,          V4      pVP                  4       # )a8  
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 elementz
%s is zerorš   rœ   r}   )r   rŸ   Úis_rationalr   ÚZeroDivisionErrorr³   r   rž   rK   Úas_numer_denomr   r$   r"   r_   rC   )ÚexÚpwrP   rR   Úmpr†   rF   Údr­   r:   rO   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Ø	�‰�!�‹€BØ×ÑÓ�D€AÜ
Œy˜ �T A¥D�[°¨sÔ3°QÔ
C€CØ—‘Ó"�J€AÜ
˜ R¥V¨SÓ
1€CØ�;‰;‹=Ðrm   c           
     óÊ   € \        \        V^ ,          V^,          W4      pV^ ,          V^,          ,           pVR,           F  p\        \        WEWVR7      pWE,           pK   	  V# )z&
returns ``minpoly(Add(*a), dom, x)``
ºr>   NN©r¦   )r®   r   ©rP   rR   r\   r¼   rk   Úpxs   &&*   r;   Ú_minpoly_addrÄ   o  ó[   € ô 
'¤s¨A¨a­D°!°Aµ$¸Ó	?€BØ	ˆ!�ˆq��t�€AØ��eˆeˆÜ*¬3°°qÀ2ÔFˆØ�FŠñ ð €Irm   c           
     óÊ   € \        \        V^ ,          V^,          W4      pV^ ,          V^,          ,          pVR,           F  p\        \        WEWVR7      pWE,          pK   	  V# )z&
returns ``minpoly(Mul(*a), dom, x)``
rÀ   rÁ   )r®   r   rÂ   s   &&*   r;   Ú_minpoly_mulrÇ   {  rÅ   rm   c                ó   € V P                   ^ ,          P                  4       w  r#V\        J Ed¶   VP                  '       Ed£   VP                  p\        V4      pVP                  '       dS   \        V\        4      p\        \        V4       Uu. uF%  qaWF,
          ^,
          ,          W6,          ,          NK'  	  up!  # VP                  ^8X  dI   V^	8X  dB   ^@V^,          ,          ^`V^,          ,          ,
          ^$V^,          ,          ,           ^,
          # V^,          ^8X  do   \        V\        4      p\        V^,           4       Uu. uF  qaWF,
          ,          W6,          ,          NK   	  pp\        V!  p\        V4      w  r‰\        W‘V 4      p
V
# ^\        ^V,          \        ,          4      ,
          ^,          \        P                   ,          p\#        W±\$        4      p
V
# \'        RV ,          4      hu upi u upi )zi
Returns the minimal polynomial of ``sin(ex)``
see https://mathworld.wolfram.com/TrigonometryAngles.html
r¶   )r~   Úas_coeff_Mulr   r·   Úqr   Úis_primer   r   r   rG   rk   r"   r_   r   r   rp   rŸ   r   r   )rº   rP   r²   r\   rF   rÊ   r9   r©   r:   rO   r­   rq   s   &&          r;   Ú_minpoly_sinrÌ   ‡  sz  € ð
 �7‰7�1�:×"Ñ"Ó$�D€AØŒB„wØ�=�=‰=Ø—‘ˆAÜ˜“
ˆAØ�z�zˆzô # 1¤bÓ)�Ü¼%À¼(ÓC¹(°Q ¥¨¥�^¨A­D×0Ð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Ó;©l¨˜�•Z ¥—_�_©l�Ð;Ü˜‘G�Ü(¨›^‘
�Ü$ W°Ó4�Ø�
àœ˜Q˜q�S¤�V›•_ aÕ'¬!¯&©&Õ0ˆDÜ" 4¬BÓ/ˆCØˆJä
ÐDÀrÕIÓ
JÐJùò) Dùò <s   Â+G6Å$G;c           	     óú  € V P                   ^ ,          P                  4       w  r#V\        J Ed¸   VP                  '       Ed¥   VP                  ^8X  dƒ   VP
                  ^8X  d;   ^V^,          ,          ^V^,          ,          ,
          ^V,          ,
          ^,           # VP
                  ^	8X  d&   ^V^,          ,          ^V,          ,
          ^,
          # MvVP                  ^8X  df   \        VP
                  4      pVP                  '       d?   \        W4      p\        VP                  V\        ^V,
          ^,          4      /4      4      # \        VP
                  4      p\        V\        4      p\        V^,           4       Uu. uF  qqWg,
          ,          W7,          ,          NK   	  pp\!        V!  RVP                  ,          ,
          p\#        V4      w  rš\%        W¡V 4      pV# \'        RV ,          4      hu upi )zi
Returns the minimal polynomial of ``cos(ex)``
see https://mathworld.wolfram.com/TrigonometryAngles.html
r¶   r}   )r~   rÉ   r   r·   rk   rÊ   r   rË   rÌ   r   rK   r   Úintr   r   rG   r   r"   r_   r   )rº   rP   r²   r\   rÊ   rY   rF   r9   r©   r:   rO   r­   s   &&          r;   Ú_minpoly_cosrÏ   ­  sp  € ð
 �7‰7�1�:×"Ñ"Ó$�D€AØŒ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�D—�©,ˆAÐ7Ü�Q‘˜2 §¡�)Õ#ˆAÜ$ Q›‰JˆAÜ  ¨RÓ0ˆCØˆJä
ÐDÀrÕIÓ
JÐJùò 8s   Æ$G8c                óˆ  € V P                   ^ ,          P                  4       w  r#V\        J Ed   VP                  '       dò   V^,          p\	        VP
                  4      pVP                  ^,          ^ 8X  d   TM^p. p\        VP                  ^,           ^,          V^,           ^4       Fa  pVP                  W1V,          ,          4       W4V,
          ^,
          ,          WF,
          ,          ) V^,           V^,           ,          ,          pKc  	  \        V!  p\        V4      w  r‰\        W‘V 4      p
V
# \        RV ,          4      h)z_
Returns the minimal polynomial of ``tan(ex)``
see https://github.com/sympy/sympy/issues/21430
r¶   )r~   rÉ   r   r·   rÎ   rÊ   rk   rG   r€   r   r"   r_   r   )rº   rP   r²   r\   rF   r±   r4   r©   r:   rO   r­   s   &&         r;   Ú_minpoly_tanrÑ   Ì  sò   € ð
 �7‰7�1�:×"Ñ"Ó$�D€AØŒB„wØ�=�=ˆ=Ø�A•ˆAÜ�A—C‘C“ˆAØ—S‘S˜1•W ”\‘ qˆAØˆEÜ˜AŸC™C �E 1�9 a¨¥c¨1Ö-�Ø—‘˜Q !�t�VÔ$Ø˜1�˜Q�•i ¥•oÐ&¨A¨a­C°!°Aµ#­;Õ7’ñ .ô �U‘ˆAÜ$ Q›‰JˆAÜ  ¨RÓ0ˆCØˆJä
ÐDÀrÕIÓ
JÐJrm   c                óì  € V P                   ^ ,          P                  4       w  r#V\        \        ,          8X  Ed¥   VP                  '       Ed€   \        VP                  4      pVP                  ^8X  g   VP                  R8X  Ed   V^8X  d   V^,          V,
          ^,           # V^8X  d   V^,          ^,           # V^8X  d   V^,          V^,          ,
          ^,           # V^8X  d   V^,          ^,           # V^	8X  d   V^,          V^,          ,
          ^,           # V^
8X  d;   V^,          V^,          ,
          V^,          ,           V^,          ,
          ^,           # VP                  '       d'   ^ p\        V4       F  pWQ) V,          ,          pK  	  V# \        ^V,          4       Uu. uF  p\        Wa4      NK  	  pp\        WqV 4      pV# \        RV ,          4      h\        RV ,          4      hu upi )z/
Returns the minimal polynomial of ``exp(ex)``
r¶   r}   )r~   rÉ   r	   r   r·   r   rÊ   rk   rË   rG   r   r.   r_   r   )	rº   rP   r²   r\   rÊ   rY   r9   rO   r¼   s	   &&       r;   Ú_minpoly_exprÓ   ä  s‡  € ð �7‰7�1�:×"Ñ"Ó$�D€AØŒ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˜Ø˜b 1�W�šñ &à�Hô 7?¸qÀ½s´mÓD±m°” qÖ,±mˆGÐDÜ ¨BÓ/ˆBØˆIäÐLÈrÕQÓRÐRÜ
ÐDÀrÕIÓ
JÐJùò Es   Æ)G1c                ó¬   € V P                   pVP                  V P                  P                  ^ ,          V/4      p\	        W!4      w  r4\        WAV 4      pV# )z9
Returns the minimal polynomial of a ``CRootOf`` object.
)rq   rK   Úpolyr›   r"   r_   )rº   rP   rk   r:   rO   r–   s   &&    r;   Ú_minpoly_rootofrÖ     sI   € ð 	�‰€AØ	�‰�—‘—‘˜Q• Ð"Ó#€AÜ˜QÓ"�J€AÜ˜G¨Ó+€FØ€Mrm   c           
     óD  € V P                   '       d%   V P                  V,          V P                  ,
          # V \        J dK   \	        V^,          ^,           WR7      w  r4\        V4      ^8X  d   V^,          ^,           # V\        ,
          # V \        P                  J dq   \	        V^,          V,
          ^,
          WR7      w  r4\        V4      ^8X  d   V^,          V,
          ^,
          # \        WA^\        ^4      ,           ^,          VR7      # V \        P                  J dÌ   \	        V^,          V^,          ,
          V,
          ^,
          WR7      w  r4\        V4      ^8X  d&   V^,          V^,          ,
          V,
          ^,
          # ^\        ^^\        ^!4      ,          ,
          4      ,           \        ^^\        ^!4      ,          ,           4      ,           ^,          p\        WAWRR7      # \        VR4      '       d   WP                  9   d	   W,
          # VP                  '       dM   \        V 4      '       d<   T pW,          p  \!        V 4      pWpJ d   \        \	        V 4      ^,          W4      # Tp K1  V P"                  '       d   \%        W.V P&                  O5!  pV# V P(                  '       Edò   \+        V 4      P,                  p	\/        V	P1                  4       R 4      p
V
R,          '       Ed˜   V\2        8X  EdŒ   \5        V
R,          V
R,          ,            UU u. uF  w  r°W°,          NK  	  up p!  p\7        V
R,          4      pVP9                  4        Uu. uF  qÝP                  NK  	  pp\;        \<        V^4      p\        P>                  pVPA                  V\        PB                  4      pVP1                  4        UUu. uF1  w  ppVVP                  V,          VP                  ,          ,          NK3  	  ppp\5        V!  p\E        Wq4      pVP                  W,          ,          VP                  VVV,          ,          ,          ,
          pVV,          V\G        ^V4      ,          ,          p\I        \4        VVWVVR7      pV# \K        W.V P&                  O5!  p V# V PL                  '       d$   \O        V PP                  V PR                  W4      pV# V PT                  \V        J d   \Y        W4      pV# V PT                  \Z        J d   \]        W4      pV# V PT                  \^        J d   \a        W4      pV# V PT                  \R        J d   \c        W4      pV# V PT                  \d        J d   \g        W4      pV# \i        R	V ,          4      hu up pi u upi u uppi )
au  
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

rœ   )rR   r3   c                 ó^   € V ^ ,          P                   ;'       d    V ^,          P                   # )é    )rc   )Úitxs   &r;   ry   Ú"_minpoly_compose.<locals>.<lambda>J  s#   € ¨¨A­×(:Ñ(:×(QÐ(Q¸sÀ1½v×?QÑ?QÐ(Qrm   TFN)r¦   r§   r¶   )5rc   rÊ   rk   r	   r"   rA   r   ÚGoldenRatior_   r   ÚTribonacciConstantr   rB   r3   Úis_QQrl   r‘   Úis_AddrÄ   r~   r   r   rO   r1   Úitemsr   r   ÚdictÚvaluesr   r(   ÚNegativeOneÚpopÚZeroÚminimal_polynomialr
   r®   rÇ   rd   r¾   re   r   Ú	__class__r   rÌ   r   rÏ   r   rÑ   rÓ   r-   rÖ   r   )rº   rP   rR   r:   rO   ÚfacrQ   r¤   r­   rU   r©   ÚbxÚr1r†   ÚdensÚlcmdensÚneg1Úexpn1re   Únumsr¥   r¦   r§   s   &&&                    r;   rŸ   rŸ     sS  € ð  
‡~‡~€~Ø�t‰t�A�v˜Ÿ™�}ÐØ	ŒQƒwÜ   A¥¨¥¨1Ô9‰
ˆÜ˜w›<¨1Ô,ˆq�!�t�a�xÐ7°!´aµ%Ð7à	ŒQ�]‰]ÓÜ   A¥¨¥¨A¥¨qÔ=‰
ˆÜˆw‹<˜1ÔØ�a•4˜!•8˜a•<Ðä! '¨q´4¸³7­{¸A­oÀ3ÔGÐGà	ŒQ×!Ñ!Ó!Ü   A¥¨¨1­¥¨q¥°1Õ!4°aÔD‰
ˆÜˆw‹<˜1ÔØ�a•4˜!˜Q�$•; •? QÕ&Ð&à”t˜B ¤4¨£8¥�OÓ,Õ,¬t°B¸¼4À»8½µOÓ/DÕDÈÕIˆCÜ! '¨cÔ;Ð;äˆs�I×Ò 2¯©Ô#4Ø�vˆà
‡y‡y€y”] 2×&Ò&àˆØ
�ˆØÜ˜rÓ"ˆCØ‹yÜ%¤k°"£o°aÕ&8¸!Ó?Ð?à’à	‡y‡y€yÜ˜1Ð, B§G¡GÓ,ˆðL €JðK 
��‰Ü�B‹K×ÑˆÜ�—‘“ÑQÓRˆØˆT�7�7�sœb•yÜ¨Q¨u­X¸¸$½Ö-?Ô@Ñ-?¡6 2˜Ÿ˜Ñ-?Ò@ÑAˆCÜ�a˜•g“ˆBØ!#§¡¤Ó-¡˜A—C”C¡ˆDÐ-ÜœS $¨Ó*ˆGÜ—=‘=ˆDØ—F‘F˜4¤§¡Ó(ˆEØ>@¿h¹h¼jÔI¹j±7°4¸�D˜1Ÿ3™3˜w�;¨!¯#©#Õ-×.Ð.¹jˆDÑIÜ�t‘*ˆCÜ$ SÓ,ˆCð —%‘%˜�
Õ" 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Ó3ˆð €Jð 
�‰œÓ	Ü˜2Ó!ˆð €Jð 
�‰œÓ	Ü˜2Ó!ˆð €Jð 
�‰œÓ	Ü˜2Ó!ˆð €Jð 
�‰œÓ	Ü˜2Ó!ˆð
 €Jð	 
�‰œÓ	 Ü˜bÓ$ˆð €Jô ÐHÈ2ÕMÓNÐNùóA Aùâ-ùó Js   ÌV
ÍVÏ7Vc                ó”  € \        V 4      p V P                  '       d   \        V RR7      p \        V 4       F  pVP                  '       g   K  Rp M	  Ve   \        V4      \
        raM\        R4      \        raV'       g=   V P                  '       d%   \        \        \        V P                  4      4      pM\        p\        VR4      '       d$   WP                  9   d   \        RV: RV: 24      hV'       d†   \        WV4      pVP!                  4       ^,          pVP#                  V\%        Wq4      ,          4      pVP&                  '       d   \)        V) 4      pV'       d   V! WqRR7      # VP+                  V4      # VP,                  '       g   \/        R	4      h\1        WV4      pV'       d   V! WqRR7      # VP+                  V4      # )
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)Ú	recursiveFrP   r3   zthe variable z$ is an element of the ground domain )Úfieldz!groebner method only works for QQ)r   rE   r   r   Úis_AlgebraicNumberr   r   r    Úfree_symbolsr   r   ÚlistrB   r3   r   rŸ   r”   r“   r%   Úis_negativer   ÚcollectrÞ   rN   Ú_minpoly_groebner)	rº   rP   r    Úpolysr�   rq   Úclsr–   r²   s	   &&&&&    r;   ræ   ræ   p  sb  € ôn 
�‹€BØ	‡|‡|€|ä�b DÔ)ˆÜ" 2Ö&ˆØ×"×"Ò"ØˆGÙñ 'ð
 	‚}Ü˜“œT‰3ä�s“œXˆ3çØ�?�?ˆ?Ü"¤2¤t¨B¯O©OÓ'<Ó=‰FäˆFÜˆv�y×!Ò! a¯>©>Ô&9ÝÛ-.²ð8ó 9ð 	9÷ Ü! "¨Ó0ˆØ×!Ñ!Ó# AÕ&ˆØ�L‰L˜œF 6Ó-Õ-Ó.ˆØ�=�=ˆ=Ü  Ó(ˆFß-2‰s�6 DÔ)ÐI¸¿¹ÀqÓ8IÐIà�<�<ˆ<Ü!Ð"EÓFÐFä˜r cÓ*€Fß).‰3ˆv Ô%ÐE°F·N±NÀ1Ó4EÐErm   c                óH  aaaaaaa€ \        R\        R7      o/ / uooR
VVV3R lloVVVVVV3R loR pRp\        V 4      p V P                  '       d    V P	                  4       P                  S4      # V P                  '       d'   V P                  S,          V P                  ,
          pEM/V! V 4      pV'       d
   V R,          p RpV P                  '       dO   ^V P                  ,          P                  '       d,   ^V P                  ,          p\        V P                  VS4      pM,\        V 4      '       d   \        V \        P                   S4      pVe   TpVf   S! V 4      pSV,
          .\#        SP%                  4       4      ,           p	\'        V	\#        SP%                  4       4      S.,           RR	7      p
\)        V
R,          4      w  r¼\+        VSV 4      pV'       d@   \-        XS4      pVP/                  S\1        VS4      ,          4      ^ 8  d   \3        V) 4      pX# )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                 ó‚   <€ \        S4      pVSV &   Ve   W1,          V,           SV &   V# VP                  ! V4      SV &   V# r7   )ÚnextrC   )rº   r   re   r\   Ú	generatorÚmappingr3   s   &&& €€€r;   Úupdate_mappingÚ)_minpoly_groebner.<locals>.update_mappingß  sI   ø€ Ü�‹OˆØˆ�‰àÒØ�& 4�-ˆG�B‰Kð ˆð Ÿ+š+ a›.ˆG�B‰Kàˆrm   c                óŽ  <€ V P                   '       dE   V \        P                  J d   V S
9  d   S! V ^^4      # SV ,          # V P                  '       d   V # EMSV P                  '       d*   \        V P                   Uu. uF  pS! V4      NK  	  up!  # V P                  '       d*   \        V P                   Uu. uF  pS! V4      NK  	  up!  # V P                  '       Ed“   V P                  P                  '       Edu   V P                  ^ 8  dˆ   \        V P                  SS	4      p\        SV4      P                  4       pVP                  SV P                  4      P!                  4       pV P                  R8X  d	   S! V4      # W@P                  ) ,          p V P                  P"                  '       gV   V P                  V P                  P$                  ,          P!                  4       \'        ^V P                  P(                  4      reMV P                  V P                  reS! V4      pWV,          pVS
9  d5   VP"                  '       d   VP!                  4       # S! V^V,          V) 4      # SV,          # M8V P*                  '       d'   V S
9  d   S! W P-                  4       4      # SV ,          # \/        RV ,          4      hu upi u upi )a3  
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.

z*%s does not seem to be an algebraic numberr}   )r‚   r   ÚImaginaryUnitrc   rß   r   r~   r   r   rd   r   rø   re   r!   rC   rK   Úexpandrf   rk   r
   rÊ   ró   Úminpoly_of_elementr   )rº   rŠ   Úminpoly_baseÚinverseÚbase_invre   r   rq   Úbottom_up_scanrú   rÿ   r3   r   rP   s   &       €€€€€€r;   r	  Ú)_minpoly_groebner.<locals>.bottom_up_scanê  s#  ø€ ð8 �:�:ˆ:Ø”Q—_‘_Ó$Ø˜WÔ$Ù)¨"¨a°Ó3Ð3à" 2�;Ð&Ø——�Ø�	ñ  à�Y�YˆYÜ°R·W²WÓ>±W°™.¨Ö+±WÑ>Ñ?Ð?Ø�Y�YˆYÜ°R·W²WÓ>±W°™.¨Ö+±WÑ>Ñ?Ð?Ø�Y�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Ó+�Ø•y�à˜wÔ&Ø—~—~�~Ø#Ÿ{™{›}Ð,á-¨d°A¸µG¸d¸UÓCÐCà" 4�=Ð(ð1 "ð2 ×"×"Ð"Ø˜Ô Ù% b×*?Ñ*?Ó*AÓBÐBà˜r•{Ð"äÐGÈ"ÕLÓMÐMùòG ?ùâ>s   Á=J=Â8Kc                óæ  € V P                   '       dS   ^V P                  ,          P                  '       d0   V P                  ^ 8  d   V P                  P                  '       d   R# V P
                  '       d{   RpV P                   F^  pVP                  '       d    R# VP                   '       g   K,  VP                  P                  '       g   KJ  VP                  ^ 8”  g   K]   R# 	  V'       d   R# R# )zg
Returns True if it is more likely that the minimal polynomial
algorithm works better with the inverse
TF)rd   r   rƒ   re   rß   r   r~   )rº   Úhitrk   s   &  r;   Úsimpler_inverseÚ*_minpoly_groebner.<locals>.simpler_inverse4  s‘   € ð
 �9�9ˆ9Ø�"—&‘&•×$×$Ð$¨¯©°!¬Ø—7‘7—>—>�>ÙØ�9�9ˆ9ØˆCØ—W”W�Ø—8—8�8Ú Ø—8—8’8Ø—v‘v—}—}’}¨¯©°®Ú$ñ ÷ ÙÙrm   FÚlex)Úorderr7   r}   )r/   r   r   ró   r  rC   rc   rÊ   rk   rd   r   rf   r—   re   rl   r   r�   rõ   râ   r#   r"   r_   r³   r“   r%   r   )rº   rP   rú   r  Úinvertedr–   r­   rF   Úbusrˆ   ÚGr:   rO   r	  rþ   rÿ   r3   r   s   &ff          @@@@@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ˆ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ä# G¨Q°Ó3ˆFßÜ˜& !Ó$ˆØ�<‰<˜œ6 &¨!Ó,Õ,Ó-°Ô1Ü  Ó(ˆFà€Mrm   c                ó   € \        WW#VR7      # )z6This is a synonym for :py:func:`~.minimal_polynomial`.)rP   r    rù   r�   )ræ   )rº   rP   r    rù   r�   s   &&&&&r;   Úminpolyr  o  s   € ô ˜b¨wÈFÔSÐSrm   )NNr7   )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.utilitiesr/   r0   r1   r_   rl   r‘   r—   r®   r³   r¡   r¾   rÄ   rÇ   rÌ   rÏ   rÑ   rÓ   rÖ   rŸ   ræ   rø   r  rw   rm   r;   Ú<module>r0     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rm   