ó
    ‰*£h0A  ã                   ó2  • S r SSKrSSKJr  SSKJr  SSKJrJrJrJrJ	r	J
r
Jr  S/S-  r\" SS5       H  r\/SS	\-
  -  -  \S\-  SS\S-   -  2'   M      S=S
 jrS rS r\S:X  a  SSKr\R                   r\R"                  rS r\S:X  a  \R(                  " 5       S:¼  a  S rOS r\" S5       V s/ s H  n SU -  PM
     sn rS rS rS r\S:X  a  \r\rO\S:X  a  \R4                  r\r\rO\r\r\S:X  a  S\" \5      ;   a  \R<                  r\" S5       Vs/ s H  n\" U5      PM     snr\" S5       Vs/ s H  n\" U5      PM     snr S r!Sr"S\"4S jr#SS\"4S jr$SS\"4S jr%\S:X  a  \%r&O\$r&SS-  r'SS -  r(SS!-  r)SS"-  r*S#r+S$r,S% r-S& r.S' r/S( r0S) r1\1r2\S:X  aO  \R(                  " 5       S:¼  a  \Rf                  =r4=r5r3\Rl                  r7O>\Rp                  =r4=r5r3\Rn                  r7O!\S:X  a  \9" \S*S+ 5      =r4=r5r3S, r7O\-r4\.r5\0r3\/r70 4S- jr:S.r;SSS/.4S0 jr<SS0SS0/4S1 jr=\S:X  a  \R|                  r<O\S:X  a  S2 r<\R~                  r:S3 r@\S:X  a  S4 r@S5rA\B" \A5      rCS6 rDS7 rES8 rFS9rGS\
04S: jrHS; rIS< rJgs  sn f s  snf s  snf )>zw
Utility functions for integer math.

TODO: rename, cleanup, perhaps move the gmpy wrapper code
here from settings.py

é    N)Úbisecté   )Úxrange)ÚBACKENDÚgmpyÚsageÚ
sage_utilsÚMPZÚMPZ_ONEÚMPZ_ZEROé   é   é   c                 ód   • U/nUS   X-  :”  a  X3S   U-  S-   /-   nUS   X-  :”  a  M  USSS2   $ )aì  
Return a list of integers ~=

[start, n*start, ..., target/n^2, target/n, target]

but conservatively rounded so that the quotient between two
successive elements is actually slightly less than n.

With n = 2, this describes suitable precision steps for a
quadratically convergent algorithm such as Newton's method;
with n = 3 steps for cubic convergence (Halley's method), etc.

    >>> giant_steps(50,1000)
    [66, 128, 253, 502, 1000]
    >>> giant_steps(50,1000,4)
    [65, 252, 1000]

éÿÿÿÿé   N© )ÚstartÚtargetÚnÚLs       ÚT/home/mande/repo/quber/.venv/lib/python3.13/site-packages/mpmath/libmp/libintmath.pyÚgiant_stepsr      sJ   € ð& 
ˆ€AØ
ˆB‰%�%‘'‹/Ø�2‘˜‘˜A‘�Ñˆð ˆB‰%�%‘'�/à‰TˆrˆT‰7€Nó    c                 ó    • US:¼  a  X-	  $ X* -  $ )z¸For an integer x, calculate x >> n with the fastest (floor)
rounding. Unlike the plain Python expression (x >> n), n is
allowed to be negative, in which case a left shift is performed.r   r   ©Úxr   s     r   Úrshiftr   +   ó   € ð 	ˆAƒv�a‘fˆ}Ø˜B‘iÐr   c                 ó    • US:¼  a  X-  $ X* -	  $ )zµFor an integer x, calculate x << n. Unlike the plain Python
expression (x << n), n is allowed to be negative, in which case a
right shift with default (floor) rounding is performed.r   r   r   s     r   Úlshiftr!   2   r   r   r   c                 ó¨   • U (       d  gU S-  nU(       a	  [         U   $ SnU S-  n U S-  (       d  U S-  n US-  nU S-  (       d  M  U[         U S-     -   $ )z1Count the number of trailing zero bits in abs(n).r   éÿ   r   )Úsmall_trailing)r   Úlow_byteÚts      r   Úpython_trailingr'   >   sg   € æØØ�4‰x€HÞÜ˜hÑ'Ð'Ø	€AØˆ!�G€AØ�$�hØ	ˆa‰ˆØ	ˆQ‰ˆð �$�h‰hð Œ~˜a $™hÑ'Ñ'Ð'r   r   Ú2c                 óD   • U (       a  [        U 5      R                  5       $ g©z<Count the number of trailing zero bits in abs(n) using gmpy.r   )r
   Ú	bit_scan1©r   s    r   Úgmpy_trailingr-   N   s   € æœ˜Q›×)Ñ)Ó+Ð+Ør   c                 óD   • U (       a  [        U 5      R                  5       $ gr*   )r
   Úscan1r,   s    r   r-   r-   S   s   € æœ˜Q›Ÿ™›Ð'Ør   é,  c                 ó”   • [        [        U 5      nUS:w  a  U$ [        [        R                  " U S5      5      S-
  nU[
        X-	     -   $ )ú0Calculate bit size of the nonnegative integer n.r0   r   é   )r   ÚpowersÚintÚmathÚlogÚbctable)r   Úbcs     r   Úpython_bitcountr:   [   sD   € ä	”˜Ó	€BØ	ˆSƒyØˆ	Ü	ŒT�XŠX�a˜‹^Ó	˜qÑ	 €BØ”˜™‘ÑÐr   c                 óF   • U (       a  [        U 5      R                  S5      $ g)r2   r   r   )r
   Ú	numdigitsr,   s    r   Úgmpy_bitcountr=   c   s   € æ”�Q“×!Ñ! !Ó$Ð
$Ør   c                 ó4   • [        U 5      R                  5       $ ©N)r
   Útrailing_zero_bitsr,   s    r   Úsage_trailingrA   l   s   € Üˆq‹6×$Ñ$Ó&Ð&r   Ú
bit_lengthi   c                 ó*   • U [        U5      U-  -  U-	  $ )z]Changes radix of a fixed-point number; i.e., converts
x * 2**xbits to floor(x * 10**bdigits).)r
   )r   ÚxbitsÚbaseÚbdigitss       r   Úbin_to_radixrG   ƒ   s   € ð ”�D“	˜7Ñ"Ñ# uÑ,Ð,r   Ú$0123456789abcdefghijklmnopqrstuvwxyzé
   c                 ó¶   • US:X  a  [        U 5      $ / nU (       a)  [        X5      u  pUR                  X$   5        U (       a  M)  SR                  USSS2   5      $ )zeReturn the string numeral of a positive integer in an arbitrary
base. Most efficient for small input.rI   Ú Nr   )ÚstrÚdivmodÚappendÚjoin)r   rE   ÚdigitsÚdigsÚdigits        r   Úsmall_numeralrS   Š   sU   € ð ˆrƒzÜ�1‹vˆØ€DÞ
Ü˜!“?‰ˆØ�‰�F‘MÔ"÷ ˆ!ð �7‰7�4™˜"˜‘:ÓÐr   c                 óò   • U S::  a  U (       d  gS[        U * XU5      -   $ US:  a  [        XU5      $ US-  US-  -   n[        XU-  5      u  pV[        XQXC5      n[        XaXC5      R                  US5      nXx-   $ )áK  Represent the integer n as a string of digits in the given base.
Recursive division is used to make this function about 3x faster
than Python's str() for converting integers to decimal strings.

The 'size' parameters specifies the number of digits in n; this
number is only used to determine splitting points and need not be
exact.r   Ú0Ú-éú   r   r   )ÚnumeralrS   rM   Úrjust©	r   rE   ÚsizerP   ÚhalfÚAÚBÚadÚbds	            r   Únumeral_pythonrb   •   s‰   € ð 	ˆAƒvÞØØ”W˜a˜R ¨VÓ4Ñ4Ð4àˆcƒzÜ˜Q fÓ-Ð-à�A‰I˜$ ™(Ñ#€DÜ�!˜4‘ZÓ �D€AÜ	�˜$Ó	'€BÜ	�˜$Ó	'×	-Ñ	-¨d°CÓ	8€BØ‰7€Nr   c                 ó
  • U S:  a  S[        U * XU5      -   $ US:  a  [        R                  " X5      $ US-  US-  -   n[        U [	        U5      U-  5      u  pV[        XQXC5      n[        XaXC5      R                  US5      nXx-   $ )rU   r   rW   i`ã r   r   rV   )rY   r   rP   rM   r
   rZ   r[   s	            r   Únumeral_gmpyrd   «   s�   € ð 	ˆ1ƒuØ”W˜a˜R ¨VÓ4Ñ4Ð4ð ˆgƒ~Ü�{Š{˜1Ó#Ð#à�A‰I˜$ ™(Ñ#€DÜ�!”S˜“Y ‘_Ó%�D€AÜ	�˜$Ó	'€BÜ	�˜$Ó	'×	-Ñ	-¨d°CÓ	8€BØ‰7€Nr   i   iX  i�  éÈ   l                l           c                 ó  • U (       d  U $ U [         :  a-  U [        :  a  [        U S-  5      $ [        U S-  S-  5      S-   nO0[        U 5      nUS-  n[        U SU-  S-
  -	  S-  S-   5      US-
  -  n XU-  -   S-	  nXA:¼  a  U$ UnM  )zX
Correctly (floor) rounded integer square root, using
division. Fast up to ~200 digits.
ç      à?g-     ð?r   r   éd   é2   )Ú_1_800Ú_1_50r5   Úbitcount)r   Úrr9   r   Úys        r   Úisqrt_small_pythonro   Í   s¤   € ö
 ØˆØŒ6ƒzàŒu‹9Ü�q˜#‘v“;Ðä��3‘Ð)Ñ)Ó*¨QÑ.‰ä�a‹[ˆØ�‰EˆÜ��Q�q‘S˜‘W‘ Ñ# AÑ%Ó&¨¨2©Ñ.ˆð Ø�!‰t‰V�a‰KˆØ‹6ØˆHØˆñ	 r   c                 óò  • U [         :  aL  [        U S-  5      nU [        :¼  a2  XU-  -   S-	  nU [        :¼  a  XU-  -   S-	  nU [        :¼  a
  XU-  -   S-	  nU$ [        U 5      nSnU SU-  -  n USU-  -  nX"S-  -  nUS-  n[        SU5      n[        SSU-  -  XSU-  -
  -	  S-  -  5      nUn[        XT5       H0  nXf-  SU-  U-
  -	  n	XU-
  -	  U	-  U-	  n
USU-  U
-
  -  US-   -	  nUnM2     X`U-	  -  WU-   -	  $ )	aê  
Fast approximate integer square root, computed using division-free
Newton iteration for large x. For random integers the result is almost
always correct (floor(sqrt(x))), but is 1 ulp too small with a roughly
0.1% probability. If x is very close to an exact square, the answer is
1 ulp wrong with high probability.

With 0 guard bits, the largest error over a set of 10^5 random
inputs of size 1-10^5 bits was 3 ulp. The use of 10 guard bits
almost certainly guarantees a max 1 ulp error.
rg   r   rI   r   ri   g       @g      à¿é   )rj   r5   Ú_1_100Ú_1_200Ú_1_400rl   Úminr   )r   rn   r9   Ú
guard_bitsÚhbcÚ	startprecrm   ÚppÚpÚr2Úxr2s              r   Úisqrt_fast_pythonr}   ç   sD  € ð$ 	Œ6ƒzÜ��3‘‹KˆØ”‹;Ø˜‘T‘˜a‘ˆAØ”F‹{Ø˜A™‘X !‘O�Øœ“;Ø ™T™ a™�AØˆÜ	�!‹€BØ€JØˆ!ˆJ‰,Ñ€AØˆ!ˆJ‰,Ñ€BØˆa‰4�L€BØ
ˆa‰%€CÜ�B˜“€IäˆC�!�I‘+Ñ !¨1¨Y©;©Ñ"7¸DÑ!@Ñ@ÓA€AØ	€BÜ˜Ö(ˆà‰c�q˜‘t˜a‘xÑ ˆà˜‘d‘˜rÑ! aÑ'ˆà�1�a‘4˜3‘,Ñ R¨¡TÑ*ˆØŠñ )ð �#‰v‰J˜A˜j™LÑ)Ð)r   c                 ó
  • U [         :  a  [        U 5      nXX-  -
  4$ [        U 5      S-   nXU-  -
  nUS:  a  US-  nUSSU-  -   -  nUS:  a  M  U(       a*  USSU-   -  :”  a  US-  nUSSU-  -   -  nUSSU-   -  :”  a  M  X4$ )z=Correctly rounded integer (floor) square root with remainder.r   r   r   )Ú_1_600ro   r}   )r   rn   Úrems      r   Úsqrtrem_pythonr�     s¯   € ð 	Œ6ƒzÜ˜qÓ!ˆØ�a‘c‘'ˆzÐÜ˜!Ó˜qÑ €AØ
�‰c‰'€Cà
�‹'Ø	ˆQ‰ˆØ��!�A‘#‘‰ˆð ��'ö Ø˜˜1˜Q™3™“-Ø�Q‘�Ø˜˜!˜A™#™‘�ð ˜˜1˜Q™3™•-ð ˆ6€Mr   c                 ó   • [        U 5      S   $ )z2Integer square root with correct (floor) rounding.r   )r�   )r   s    r   Úisqrt_pythonrƒ   +  s   € ä˜!Ó˜QÑÐr   c                 ó   • [        X-  5      $ r?   )Ú
isqrt_fast)r   Úprecs     r   Ú
sqrt_fixedr‡   /  s   € Ü�a‘gÓÐr   Úisqrtc                 ó4   • [        U 5      R                  5       $ r?   )r
   rˆ   r,   s    r   Ú<lambda>rŠ   =  s   € ¬s°1«v¯|©|¬~r   c                 ó4   • [        U 5      R                  5       $ r?   )r
   Úsqrtremr,   s    r   rŠ   rŠ   >  s   € œ˜A›Ÿ™Ô(r   c                 ó:  • U S:  a  SU * S-   -  [        U * 5      -  $ X;   a  X   $ U n[        [        [        [        4u  p4pVU (       aI  U S-  (       a  X6-  nXF-  U-   X5-  -   XE-  U-   pCU S-  n OXf-  nXU-  U-   USU-  U-  -   peU S-  n U (       a  MI  US:  a  XAU'   U$ )z?Computes the nth Fibonacci number as an integer, for
integer n.r   r   r   r   rX   )Úifibr   r   )	r   Ú_cacheÚmÚaÚbrz   ÚqÚaqÚqqs	            r   rŽ   rŽ   F  sÄ   € ð 	ˆ1ƒuØ�q�b˜‘d‰|œd A 2›hÑ&Ð&Øƒ{Ø‰yÐØ	€Aô œ(¤H¬gÐ5�J€Aˆ!Þ
Øˆq�5Ø‘ˆBØ‘3�r‘6˜!™#‘:˜q™s 2™vˆqØ�‰F‰Aà‘ˆBØ‘3�r‘6˜2˜a ™c !™e™8ˆqØ�!‰GˆA÷ ˆ!ð 	ˆ3ƒwØˆq‰	Ø€Hr   iè  )r   r   c                 ó¦   • UR                  U 5      nU(       a  U$ [        U5      nXS-
     n[        nX0::  a  XC-  nX5::  a  XAU'   US-  nX0::  a  M  U$ )z.Return n factorial (for integers n >= 0 only).r   )ÚgetÚlenÚMAX_FACTORIAL_CACHE)r   ÚmemoÚfÚkrz   ÚMAXs         r   Úifacrž   a  s_   € à�‰�‹€AÞØˆÜˆD‹	€AØˆq‰S‰	€AÜ
€CØ
‹&Ø	‰ˆØ‹8Ø�‰GØ	ˆQ‰ˆð	 �&ð
 €Hr   c                 ó®   • XS-     nUR                  U 5      nU(       a  U$ [        U5      nX$   n[        nX@:  a  US-  nXT-  nXF::  a  XRU'   X@:  a  M  U$ )z4Return n!! (double factorial), integers n >= 0 only.r   r   )r—   Úmaxr™   )r   Ú	memo_pairrš   r›   rœ   rz   r�   s          r   Úifac2r¢   p  sf   € à�q‘S‰>€DØ�‰�‹€AÞØˆÜˆD‹	€AØ‰€AÜ
€CØ
‹%Ø	ˆQ‰ˆØ	‰ˆØ‹8Ø�‰Gð	 �%ð
 €Hr   c                 ó@   • [        [        R                  " U 5      5      $ r?   )r5   r   Ú	factorialr,   s    r   rŠ   rŠ   ƒ  s   € ”SœŸš¨Ó*Ô+r   c                 ó  • U S-   n [        [        U 5      5      nSS/US S& [        S[        U S-  5      S-   5       H(  nX   (       d  M  [        US-  X5       H  nSX'   M	     M*     U Vs/ s H  oD(       d  M  UPM     sn$ s  snf )Nr   r   r   rg   )Úlistr   r5   )r   ÚsieveÚiÚjrz   s        r   Úlist_primesrª   †  sƒ   € Ø	ˆA‰€AÜ”˜“‹O€EØ�A�€Eˆ"ˆ1€IÜ�A”s˜1˜c™6“{ 1‘}Ö%ˆØ�8‰8Ü˜A˜q™D !Ö'�Ø�“ó (ñ &ñ Ó"’u�!£�A‘uÑ"Ð"ùÒ"s   Á,
BÁ:Bc                 ór   • [         R                  " U S-   5       Vs/ s H  n[        U5      PM     sn$ s  snf )Nr   )r   Úprimesr5   )r   Ú_s     r   rª   rª   “  s-   € Ü $§¢¨A¨a©CÔ 0Ó1Ò 0˜1”�A–Ñ 0Ñ1Ð1ùÒ1s   œ4)rq   é   r   é   é   é   é   é   é   é   é%   é)   é+   é/   c                 ó4  ^ ^^^• [        T 5      m T S-  (       d  T S:H  $ T S:  a	  T [        ;   $ [         H  nT U-  (       a  M    g   T S-
  m[        T5      mTT-	  mUUU U4S jnT S:  a  SS/nOT S:  a  / S	QnO[        nU H  nU" U5      (       a  M    g   g
)a  
Determines whether n is a prime number. A probabilistic test is
performed if n is very large. No special trick is used for detecting
perfect powers.

    >>> sum(list_primes(100000))
    454396537
    >>> sum(n*isprime(n) for n in range(100000))
    454396537

r   r   ri   Fc                 ó€   >• [        U TT5      nUS:X  d  UT:X  a  g[        ST5       H  nUS-  T-  nUT:X  d  M    g   g)Nr   Tr   F)Úpowr   )r‘   r   rm   Údr�   r   Úss      €€€€r   ÚtestÚisprime.<locals>.test°  sL   ø€ Ü��!�A‹JˆØ�‹6�Q˜!“VØÜ˜˜!–ˆAØ�1‘�q‘ˆAØ�A�vÙñ ð r   iÕõ rq   l   ÁHe%�Z	 )r   rq   r®   r   r¯   r°   r±   T)r5   Úsmall_odd_primes_setÚsmall_odd_primesÚtrailing)r   rz   r¿   Ú	witnessesr‘   r½   r�   r¾   s   `    @@@r   ÚisprimerÅ   ™  s­   û€ ô 	ˆA‹€AØˆq�5Ø�A‰vˆØˆ2ƒvØÔ(Ñ(Ð(ßˆØ�1�u‰uÙñ ð 	
ˆ!‰€AÜ�‹€AØ	ˆQ‰€A÷ð ð 	ˆ7ƒ{Ø�q�E‰	Ø	
ˆ_Ó	Ú&‰	ä$ˆ	ÛˆÙ�A�w‹wÙñ ð r   c                 ó  ^• [        [        U 5      5      n U S:  a  U $ / n[        SU S-   5       HK  mU T-  (       a  M  U TS-  -  (       d    g[        U4S jU 5       5      (       a  M:  UR	                  T5        MM     S[        U5      -  $ )z¤
Evaluates the Moebius function which is `mu(n) = (-1)^k` if `n`
is a product of `k` distinct primes and `mu(n) = 0` otherwise.

TODO: speed up using factorization
r   r   r   c              3   ó.   >#   • U  H
  nTU-  v •  M     g 7fr?   r   )Ú.0r›   rz   s     €r   Ú	<genexpr>Úmoebius.<locals>.<genexpr>Ô  s   øé € Ð.¢g �q˜1–u¢gùs   ƒr   )Úabsr5   r   ÚsumrN   r˜   )r   Úfactorsrz   s     @r   ÚmoebiusrÎ   Å  s|   ø€ ô 	ŒC�‹F‹€AØˆ1ƒuØˆØ€GÜ�A�q˜‘sŽ^ˆØ�A—‘Ø˜˜1™—HÙÜÔ.¡gÓ.×.Ó.Ø—‘˜qÖ!ñ ð ”�W“ÑÐr   c                  ó`   • SnU  H%  nU(       a  U(       a  X!U-  p!U(       a  M  M!  M#  UnM'     U$ )Nr   r   )Úargsr‘   r’   s      r   ÚgcdrÑ   Ø  s5   € Ø	€AÛˆÞÞØ˜a™%�1÷ ”!ð ŠAñ ð €Hr   iô  c                 ó  • U S-  (       a  [         $ UR                  U 5      nU(       a  U$ [        nU nS Vs/ s H  n[        U5      PM     nn[	        SU S-   5       H�  n[	        US-   SS5       H   nUS-
  Xg   -  US-   XgS-      -  -   XgS-   '   M"     UR                  S5        Sn[	        US-   SS5       H'  n	X†U	S-      -  nXC::  d  M  SUS-  -  USU-  -  -  X'   M)     X@:X  d  MŒ  SUS-  -  U-  SU-  -  s  $    gs  snf )a”  
Computes the Euler numbers `E(n)`, which can be defined as
coefficients of the Taylor expansion of `1/cosh x`:

.. math ::

    \frac{1}{\cosh x} = \sum_{n=0}^\infty \frac{E_n}{n!} x^n

Example::

    >>> [int(eulernum(n)) for n in range(11)]
    [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521]
    >>> [int(eulernum(n)) for n in range(11)]   # test cache
    [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521]

r   )r   r   r   r   r   r   r   éþÿÿÿr   r   N)r   r—   ÚMAX_EULER_CACHEr
   ÚrangerN   )
r�   r�   r›   r�   r   r­   r‘   r©   Úsumarœ   s
             r   Úeulernumr×   ÿ  s  € ð$ 	ˆ1‡uÜˆØ�
‰
�1‹€AÞØˆÜ
€CØ	€AÙ&Ó'š�AŒˆQŽ™€AÐ'Ü�A�q˜‘sŽmˆÜ�q˜‘s˜B Ö#ˆAØ˜‘c˜1™4‘Z 1 Q¡3¨¨A©#©¡,Ñ.ˆA�‰c‹Fñ $à	�‰�ŒØˆÜ�q˜‘s˜B Ö#ˆAØ�a˜‘c‘F‰NˆDØ�xØ  A q¡D™\¨D°A°q±D©LÑ9�“	ñ $ð �6Ø˜1˜a™4‘L $Ñ&¨!¨Q©$Ñ.Ò.ò ùò 	(s   ·C?c                 ó4  • U S:  d  US:  a  [         eX:¼  a  [        X:H  5      $ US:  a  [        $ [        /US-   -  n[        US'   [	        SU S-   5       H4  n[	        [        X5      SS5       H  nUS-
  X$   -  X$S-
     -   X$'   M     M6     SX-   -  X!   -  $ )z$
Stirling number of the first kind.
r   r   r   r   )Ú
ValueErrorr
   r   r   r   ru   )r   rœ   r   r�   r©   s        r   Ú	stirling1rÚ   %  s©   € ð 	ˆ1ƒu��A“ÜÐØƒvÜ�1‘6‹{ÐØˆ1ƒuÜˆÜ	ˆ
�a˜‘cÑ€AÜ€A€a�DÜ�A�q˜‘sŽ^ˆÜœ˜A›	 1 bÖ)ˆAØ�a‘C˜1™4‘< ! a¡C¡&Ñ(ˆA‹Dó *ñ ð �!‘#‰;˜™ÑÐr   c                 óP  • U S:  d  US:  a  [         eX:¼  a  [        X:H  5      $ US::  a  [        US:H  5      $ [        n[        n[	        US-   5       HC  nX-   S-  (       a  X#[        U5      U -  -  -  nOX#[        U5      U -  -  -  nX1U-
  -  US-   -  nME     U[        U5      -  $ )z%
Stirling number of the second kind.
r   r   )rÙ   r
   r   r   r   rž   )r   rœ   r¾   r&   r©   s        r   Ú	stirling2rÜ   6  s®   € ð 	ˆ1ƒu��A“ÜÐØƒvÜ�1‘6‹{ÐØˆAƒvÜ�1˜‘6‹{ÐÜ€AÜ€AÜ�A�a‘CŽ[ˆØ‰E�Q�;Ø”S˜“V˜Q‘Y‘Ñ‰Aà”S˜“V˜Q‘Y‘ÑˆAØ�Q‘‰K˜A ™EÑ"Šñ ð ”�Q“‰<Ðr   )r   )KÚ__doc__r6   r   Úbackendr   r   r   r   r	   r
   r   r   r$   rÕ   r©   r   r   r!   Úoperatorr'   Úversionr-   r4   r:   r=   rA   rl   rÃ   Úsage_bitcountÚdirrB   Ú
trailtabler8   rG   Ú	stddigitsrS   rb   rd   rY   rj   r   rt   rs   rr   rk   ro   r}   r�   rƒ   r‡   Úsqrt_fixed2rˆ   Úisqrt_smallr…   Ú	isqrt_remrŒ   ÚsqrtÚgetattrrŽ   r™   rž   r¢   ÚfacÚ	fibonaccirª   rÂ   ÚsetrÁ   rÅ   rÎ   rÑ   rÔ   r×   rÚ   rÜ   )r­   r   s   00r   Ú<module>rí      s[  ðñó Ý å ß L× LÑ Là��s‘€Ù	ˆq�Ž€AØ&' S¨A°°!±©HÑ%5€N�1�a‘4�>˜˜Q˜q™S™�>Ó"ñ 
ôò0 ò ð ˆfÓÛØ�_‰_€FØ�_‰_€Fò(ð ˆfÓØ‡|‚|ƒ~˜Óó	ò
	ñ ˜cœ
Ó	#š
�1ˆ!ˆQŒ$™
Ñ	#€òòò'ð ˆfÓØ€HØ�HØ�ÓØ×'Ñ'€MØ€HØ�Hà€HØ€Hà
ˆfÓ˜©¨T«Ó2Ø�‰€Hñ $)¨¤:Ó.¢:˜a‰h�qŽk¡:Ñ.€
Ù % d¤Ó
,¢˜1‰8�AŽ;¡Ñ
,€ò-ð
 3€	à Yô 	ð  A¨iô ð,  !¨Iô ð, ˆfÓØ�Gà€Gà	
ˆC‰€Ø	
ˆC‰€Ø	
ˆC‰€Ø	
ˆC‰€Ø	€Ø€òò4.*ò`ò( òð €à
ˆfÓØ‡|‚|ƒ~˜ÓØ+/¯:©:Ð5ˆÐ5�j 5Ø—.‘.‰à+/¯9©9Ð4ˆÐ4�j 5Ø—,‘,‰Ø�Óá�
˜GÑ%=Ó>ð?€Kð ?�*˜uá(�Gà$€KØ"€JØ€EØ€Gð ô ð2 Ð à˜‘ô ð ˜1˜  !˜u�~ô ð  ˆfÓØ�8‰8�DØ�ÓÙ+€DØ�>‰>€Dò#ð ˆfÓò2ð <Ð ÙÐ+Ó,Ð ò*òXò&ðJ €à˜'�{ô $/òLó"ùò{ 
$ùòJ /ùÚ
,s   Â2J
ÄJÄ:J