§
    JŠtj0A  ã                   óp  — d Z ddlZddlmZ ddlmZ ddlmZmZmZmZm	Z	m
Z
mZ dgdz  Z edd¦  «        D ]Zegdd	ez
  z  z  edez  ddedz   z  …<   ŒdAd„Zd„ Zd„ Zedk    rddlZej        Zej        Zd„ Zedk    r ej        ¦   «         dk    rd„ Znd„ Zd„  ed¦  «        D ¦   «         Zd„ Zd„ Zd„ Zedk    reZeZnedk    rej        ZeZeZneZeZedk    rd ee¦  «        v rej        Zd„  ed¦  «        D ¦   «         Zd„  ed¦  «        D ¦   «         Z d„ Z!dZ"de"fd „Z#dde"fd!„Z$dde"fd"„Z%edk    re%Z&ne$Z&dd#z  Z'dd$z  Z(dd%z  Z)dd&z  Z*d'Z+d(Z,d)„ Z-d*„ Z.d+„ Z/d,„ Z0d-„ Z1e1Z2edk    r9 ej        ¦   «         dk    rej3        xZ4xZ5Z3ej6        Z7n7ej8        xZ4xZ5Z3ej7        Z7n$edk    r e9ed.d/„ ¦  «        xZ4xZ5Z3d0„ Z7ne-Z4e.Z5e0Z3e/Z7i fd1„Z:d2Z;ddd3œfd4„Z<ddiddigfd5„Z=edk    rej>        Z<nedk    r
d6„ Z<ej?        Z:d7„ Z@edk    rd8„ Z@d9ZA eBeA¦  «        ZCd:„ ZDd;„ ZEd<„ ZFd=ZGde
ifd>„ZHd?„ ZId@„ ZJdS )Bzw
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                 ó~   — |g}|d         | |z  k    r!||d         |z  dz   gz   }|d         | |z  k    °!|ddd…         S )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]

    éÿÿÿÿr   N© )ÚstartÚtargetÚnÚLs       úU/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/mpmath/libmp/libintmath.pyÚgiant_stepsr      sV   € ð& 
ˆ€AØ
ˆBŒ%�%˜‘'Š/ˆ/Ø��2”˜‘˜A‘�Ñˆð ˆBŒ%�%˜‘'Š/ˆ/àˆTˆTˆrˆTŒ7€Nó    c                 ó$   — |dk    r| |z	  S | | z  S )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€v�a˜1‘fˆ}Ø˜Q˜B‘iÐr   c                 ó$   — |dk    r| |z  S | | z	  S )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                 óŽ   — | sdS | dz  }|rt           |         S d}| dz  } | dz  s| dz  } |dz  }| dz  ¯|t           | dz           z   S )z1Count the number of trailing zero bits in abs(n).r   éÿ   r   )Úsmall_trailing)r   Úlow_byteÚts      r   Úpython_trailingr'   >   s{   € àð ØˆqØ�4‰x€HØð (Ý˜hÔ'Ð'Ø	€AØˆ!�G€AØ�$‰hð Ø	ˆa‰ˆØ	ˆQ‰ˆð �$‰hð ð �~˜a $™hÔ'Ñ'Ð'r   r   Ú2c                 óL   — | r!t          | ¦  «                             ¦   «         S dS ©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                 óL   — | r!t          | ¦  «                             ¦   «         S dS r*   )r
   Úscan1r,   s    r   r-   r-   S   s"   € àð �˜Q™œŸš™œÐ'Ø˜r   c                 ó   — g | ]}d |z  ‘ŒS )r   r   ©Ú.0Ú_s     r   ú
<listcomp>r4   Y   s   € Ð	#Ð	#Ð	#�1ˆ!ˆQ‰$Ð	#Ð	#Ð	#r   é,  c                 ó¬   — t          t          | ¦  «        }|dk    r|S t          t          j        | d¦  «        ¦  «        dz
  }|t
          | |z	           z   S )ú0Calculate bit size of the nonnegative integer n.r5   r   é   )r   ÚpowersÚintÚmathÚlogÚbctable)r   Úbcs     r   Úpython_bitcountr?   [   sN   € å	•˜Ñ	Ô	€BØ	ˆS‚y€yØˆ	Ý	�TŒX�a˜‰^Œ^Ñ	Ô	˜qÑ	 €BØ•˜˜2™”ÑÐr   c                 óN   — | r"t          | ¦  «                             d¦  «        S dS )r7   r   r   )r
   Ú	numdigitsr,   s    r   Úgmpy_bitcountrB   c   s(   € àð •�Q‘”×!Ò! !Ñ$Ô$Ð
$Ø�r   c                 óD   — t          | ¦  «                             ¦   «         S ©N)r
   Útrailing_zero_bitsr,   s    r   Úsage_trailingrF   l   s   € Ýˆq‰6Œ6×$Ò$Ñ&Ô&Ð&r   Ú
bit_lengthc                 ó,   — g | ]}t          |¦  «        ‘ŒS r   )Útrailing©r2   r   s     r   r4   r4   ~   s   € Ð.Ð.Ð.˜a�h�q‰kŒkÐ.Ð.Ð.r   c                 ó,   — g | ]}t          |¦  «        ‘ŒS r   )ÚbitcountrJ   s     r   r4   r4      s   € Ð
,Ð
,Ð
,˜1�8�A‰;Œ;Ð
,Ð
,Ð
,r   i   c                 ó2   — | t          |¦  «        |z  z  |z	  S )zaChanges 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_radixrR   ƒ   s   € ð •�D‘	”	˜7Ñ"Ñ# uÑ,Ð,r   Ú$0123456789abcdefghijklmnopqrstuvwxyzé
   c                 óÐ   — |dk    rt          | ¦  «        S g }| r0t          | |¦  «        \  } }|                     ||         ¦  «         | °0d                     |ddd…         ¦  «        S )ziReturn the string numeral of a positive integer in an arbitrary
    base. Most efficient for small input.rT   Ú Nr   )ÚstrÚdivmodÚappendÚjoin)r   rP   ÚdigitsÚdigsÚdigits        r   Úsmall_numeralr^   Š   st   € ð ˆr‚z€zÝ�1‰vŒvˆØ€DØ
ð #Ý˜!˜T‘?”?‰ˆˆ5Ø�Š�F˜5”MÑ"Ô"Ð"ð ð #ð �7Š7�4˜˜˜"˜”:ÑÔÐr   c                 ó,  — | dk    r| sdS dt          |  |||¦  «        z   S |dk     rt          | ||¦  «        S |dz  |dz  z   }t          | ||z  ¦  «        \  }}t          ||||¦  «        }t          ||||¦  «                             |d¦  «        }||z   S )á_  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   )Únumeralr^   rX   Úrjust©	r   rP   Úsizer[   ÚhalfÚAÚBÚadÚbds	            r   Únumeral_pythonrm   •   s¸   € ð 	ˆA‚v€vØð 	Ø�3Ø•W˜a˜R  t¨VÑ4Ô4Ñ4Ð4àˆc‚z€zÝ˜Q  fÑ-Ô-Ð-à�A‰I˜$ ™(Ñ#€DÝ�!�T˜4‘ZÑ Ô �D€A€qÝ	��D˜$ Ñ	'Ô	'€BÝ	��D˜$ Ñ	'Ô	'×	-Ò	-¨d°CÑ	8Ô	8€BØ�‰7€Nr   c                 óF  — | dk     rdt          |  |||¦  «        z   S |dk     rt          j        | |¦  «        S |dz  |dz  z   }t          | t	          |¦  «        |z  ¦  «        \  }}t          ||||¦  «        }t          ||||¦  «                             |d¦  «        }||z   S )r`   r   rb   i`ã r   r   ra   )rd   r   r[   rX   r
   re   rf   s	            r   Únumeral_gmpyro   «   s³   € ð 	ˆ1‚u€uØ•W˜a˜R  t¨VÑ4Ô4Ñ4Ð4ð ˆg‚~€~ÝŒ{˜1˜dÑ#Ô#Ð#à�A‰I˜$ ™(Ñ#€DÝ�!•S˜‘Y”Y ‘_Ñ%Ô%�D€A€qÝ	��D˜$ Ñ	'Ô	'€BÝ	��D˜$ Ñ	'Ô	'×	-Ò	-¨d°CÑ	8Ô	8€BØ�‰7€Nr   i   iX  i�  éÈ   l                l           c                 ó*  — | s| S | t           k     r6| t          k     rt          | dz  ¦  «        S t          | dz  dz  ¦  «        dz   }n8t          | ¦  «        }|dz  }t          | d|z  dz
  z	  dz  dz   ¦  «        |dz
  z  }	 || |z  z   dz	  }||k    r|S |}Œ)zd
    Correctly (floor) rounded integer square root, using
    division. Fast up to ~200 digits.
    ç      à?g-     ð?r   r   éd   é2   )Ú_1_800Ú_1_50r:   rL   )r   Úrr>   r   Úys        r   Úisqrt_small_pythonry   Í   s¿   € ð
 ð ØˆØ�6‚z€zà�uŠ9ˆ9Ý�q˜#‘v‘;”;Ðå��3‘Ð)Ñ)Ñ*Ô*¨QÑ.ˆˆå�a‰[Œ[ˆØ�‰EˆÝ��Q�q‘S˜‘W‘ Ñ# AÑ%Ñ&Ô&¨¨2©Ñ.ˆðØˆq�!‰t‰V�a‰KˆØ�Š6ˆ6ØˆHØˆð	r   c                 ó,  — | t           k     rVt          | dz  ¦  «        }| t          k    r7|| |z  z   dz	  }| t          k    r!|| |z  z   dz	  }| t          k    r|| |z  z   dz	  }|S t          | ¦  «        }d}| d|z  z  } |d|z  z  }||dz  z  }|dz  }t          d|¦  «        }t          dd|z  z  | |d|z  z
  z	  dz  z  ¦  «        }|}t          ||¦  «        D ]1}||z  d|z  |z
  z	  }	| ||z
  z	  |	z  |z	  }
|d|z  |
z
  z  |dz   z	  }|}Œ2|| |z	  z  ||z   z	  S )	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.
    rr   r   rT   r   rt   g       @g      à¿é   )ru   r:   Ú_1_100Ú_1_200Ú_1_400rL   Úminr   )r   rx   r>   Ú
guard_bitsÚhbcÚ	startprecrw   ÚppÚpÚr2Úxr2s              r   Úisqrt_fast_pythonr‡   ç   so  € ð$ 	�6‚z€zÝ��3‘‰KŒKˆØ•Š;ˆ;Ø�Q˜‘T‘˜a‘ˆAØ•FŠ{ˆ{Ø˜˜A™‘X !‘O�Ø�’;�;Ø˜Q ™T™ a™�AØˆÝ	�!‰Œ€BØ€JØˆ!ˆJ‰,Ñ€AØˆ!ˆJ‰,Ñ€BØˆ2ˆa‰4�L€BØ
ˆa‰%€CÝ�B˜‘”€IåˆC�!�I‘+Ñ !¨¨1¨Y©;©Ñ"7¸DÑ!@Ñ@ÑAÔA€AØ	€BÝ˜ CÑ(Ô(ð ð ˆà�‰c�q˜‘t˜a‘xÑ ˆà�b˜‘d‘˜rÑ! aÑ'ˆà�1�a‘4˜3‘,Ñ R¨¡TÑ*ˆØˆˆàˆq�#‰v‰J˜A˜j™LÑ)Ð)r   c                 ó  — | t           k     rt          | ¦  «        }|| ||z  z
  fS t          | ¦  «        dz   }| ||z  z
  }|dk     r|dz  }|dd|z  z   z  }|dk     °|r(|dd|z   z  k    r|dz  }|dd|z  z   z  }|dd|z   z  k    °||fS )z=Correctly rounded integer (floor) square root with remainder.r   r   r   )Ú_1_600ry   r‡   )r   rx   Úrems      r   Úsqrtrem_pythonr‹     sÌ   € ð 	�6‚z€zÝ˜qÑ!Ô!ˆØ�!�a˜‘c‘'ˆzÐÝ˜!ÑÔ˜qÑ €AØ
ˆa�‰c‰'€Cà
�Š'ˆ'Ø	ˆQ‰ˆØ��!�A‘#‘‰ˆð �Š'ˆ'ð ð 	Ø˜˜1˜Q™3™’-�-Ø�Q‘�Ø˜˜!˜A™#™‘�ð ˜˜1˜Q™3™’-�-ð ˆcˆ6€Mr   c                 ó,   — t          | ¦  «        d         S )z2Integer square root with correct (floor) rounding.r   )r‹   )r   s    r   Úisqrt_pythonr�   +  s   € å˜!ÑÔ˜QÔÐr   c                 ó&   — t          | |z  ¦  «        S rD   )Ú
isqrt_fast)r   Úprecs     r   Ú
sqrt_fixedr‘   /  s   € Ý�a˜‘gÑÔÐr   Úisqrtc                 óD   — t          | ¦  «                             ¦   «         S rD   )r
   r’   r,   s    r   ú<lambda>r”   =  s   € ­s°1©v¬v¯|ª|©~¬~€ r   c                 óD   — t          | ¦  «                             ¦   «         S rD   )r
   Úsqrtremr,   s    r   r”   r”   >  s   € �˜A™œŸšÑ(Ô(€ r   c                 óD  — | dk     rd|  dz   z  t          |  ¦  «        z  S | |v r||          S | }t          t          t          t          f\  }}}}| rE| dz  r!||z  }||z  |z   ||z  z   ||z  |z   }}| dz  } n||z  }||z  |z   |d|z  |z  z   }}| dz  } | °E|dk     r|||<   |S )zCComputes the nth Fibonacci number as an integer, for
    integer n.r   r   r   r   rc   )Úifibr   r   )	r   Ú_cacheÚmÚaÚbr„   ÚqÚaqÚqqs	            r   r˜   r˜   F  sõ   € ð 	ˆ1‚u€uØ�q�b˜‘d‰|�d A 2™hœhÑ&Ð&ØˆF€{€{Ø�aŒyÐØ	€Aõ �(¥H­gÐ5�J€A€qˆ!ˆQØ
ð Øˆq‰5ð 	Ø�1‘ˆBØ�Q‘3�r‘6˜!˜A™#‘:˜q ™s 2™vˆqˆAØ�‰FˆAˆAà�1‘ˆBØ�Q‘3�r‘6˜2˜a ™c !™e™8ˆqˆAØ�!‰GˆAð ð ð 	ˆ3‚w€wØˆˆq‰	Ø€Hr   iè  )r   r   c                 ó¼   — |                      | ¦  «        }|r|S t          |¦  «        }||dz
           }t          }|| k    r||z  }||k    r|||<   |dz  }|| k    °|S )z.Return n factorial (for integers n >= 0 only).r   )ÚgetÚlenÚMAX_FACTORIAL_CACHE)r   ÚmemoÚfÚkr„   ÚMAXs         r   Úifacr¨   a  sz   € à�Š�‰Œ€AØð ØˆÝˆD‰	Œ	€AØˆQˆq‰SŒ	€AÝ
€CØ
ˆqŠ&ˆ&Ø	ˆQ‰ˆØ�Š8ˆ8ØˆD�‰GØ	ˆQ‰ˆð	 ˆqŠ&ˆ&ð
 €Hr   c                 óÌ   — || dz           }|                      | ¦  «        }|r|S t          |¦  «        }||         }t          }|| k     r|dz  }||z  }||k    r|||<   || k     °|S )z4Return n!! (double factorial), integers n >= 0 only.r   r   )r¡   Úmaxr£   )r   Ú	memo_pairr¤   r¥   r¦   r„   r§   s          r   Úifac2r¬   p  sƒ   € à�Q�q‘SŒ>€DØ�Š�‰Œ€AØð ØˆÝˆD‰	Œ	€AØˆQŒ€AÝ
€CØ
ˆaŠ%ˆ%Ø	ˆQ‰ˆØ	ˆQ‰ˆØ�Š8ˆ8ØˆD�‰Gð	 ˆaŠ%ˆ%ð
 €Hr   c                 óD   — t          t          j        | ¦  «        ¦  «        S rD   )r:   r   Ú	factorialr,   s    r   r”   r”   ƒ  s   € •S�œ¨Ñ*Ô*Ñ+Ô+€ r   c                 ó  — | dz   } t          t          | ¦  «        ¦  «        }ddg|d d…<   t          dt          | dz  ¦  «        dz   ¦  «        D ]&}||         rt          |dz  | |¦  «        D ]}d||<   ŒŒ'd„ |D ¦   «         S )Nr   r   r   rr   c                 ó   — g | ]}|¯|‘ŒS r   r   )r2   r„   s     r   r4   zlist_primes.<locals>.<listcomp>Ž  s   € Ð"Ð"Ð"�! Ð"ˆAÐ"Ð"Ð"r   )Úlistr   r:   )r   ÚsieveÚiÚjs       r   Úlist_primesrµ   †  sŸ   € Ø	ˆA‰€AÝ•˜‘”‰OŒO€EØ�A�€Eˆ"ˆ1ˆ"�IÝ�A•s˜1˜c™6‘{”{ 1‘}Ñ%Ô%ð ð ˆØ�Œ8ð 	Ý˜A˜q™D ! QÑ'Ô'ð ð �Ø��a‘�øØ"Ð"�uÐ"Ñ"Ô"Ð"r   c                 óD   — d„ t          j        | dz   ¦  «        D ¦   «         S )Nc                 ó,   — g | ]}t          |¦  «        ‘ŒS r   )r:   r1   s     r   r4   zlist_primes.<locals>.<listcomp>”  s   € Ð1Ð1Ð1˜1•�A‘”Ð1Ð1Ð1r   r   )r   Úprimesr,   s    r   rµ   rµ   “  s$   € Ø1Ð1¥¤¨A¨a©CÑ 0Ô 0Ð1Ñ1Ô1Ð1r   )r{   é   r   é   é   é   é   é   é   é   é%   é)   é+   é/   c                 ó&  ‡ ‡‡‡— t          ‰ ¦  «        Š ‰ dz  s‰ dk    S ‰ dk     r	‰ t          v S t          D ]
}‰ |z  s dS Œ‰ dz
  Št          ‰¦  «        Š‰‰z	  Šˆˆˆ ˆfd„}‰ dk     rddg}n‰ dk     rg d	¢}nt          }|D ]} ||¦  «        s dS Œd
S )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   rt   Fc                 óŽ   •— t          | ‰‰¦  «        }|dk    s|‰k    rdS t          d‰¦  «        D ]}|dz  ‰z  }|‰k    r dS ŒdS )Nr   Tr   F)Úpowr   )r›   r   rw   Údrš   r   Úss      €€€€r   Útestzisprime.<locals>.test°  sf   ø€ Ý��!�A‰JŒJˆØ�Š6ˆ6�Q˜!’V�VØ�4Ý˜˜!‘”ð 	ð 	ˆAØ�1‘�q‘ˆAØ�AŠvˆvØ�t�tð àˆur   iÕõ r{   l   ÁHe%�Z	 )r   r{   r¹   r   rº   r»   r¼   T)r:   Úsmall_odd_primes_setÚsmall_odd_primesrI   )r   r„   rÊ   Ú	witnessesr›   rÈ   rš   rÉ   s   `    @@@r   ÚisprimerÎ   ™  s  øøøø€ õ 	ˆA‰Œ€AØˆq‰5ð Ø�AŠvˆØˆ2‚v€vØÕ(Ð(Ð(Ýð ð ˆØ�1‰uð 	Ø�5�5ð	à	ˆ!‰€AÝ�‰Œ€AØ	ˆQ‰€Aðð ð ð ð ð ð ð ð 	ˆ7‚{€{Ø�q�Eˆ	ˆ	Ø	
ˆ_Ò	Ð	Ø&Ð&Ð&ˆ	ˆ	å$ˆ	Øð ð ˆØˆt�A‰wŒwð 	Ø�5�5ð	àˆ4r   c                 ó   ‡— t          t          | ¦  «        ¦  «        } | dk     r| S g }t          d| dz   ¦  «        D ]BŠ| ‰z  s;| ‰dz  z  s dS t          ˆfd„|D ¦   «         ¦  «        s|                     ‰¦  «         ŒCdt          |¦  «        z  S )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   ó"   •K  — | ]	}‰|z  V — Œ
d S rD   r   )r2   r¥   r„   s     €r   ú	<genexpr>zmoebius.<locals>.<genexpr>Ô  s'   øè è € Ð.Ð. �q˜1‘uÐ.Ð.Ð.Ð.Ð.Ð.r   r   )Úabsr:   r   ÚsumrY   r¢   )r   Úfactorsr„   s     @r   ÚmoebiusrÕ   Å  s°   ø€ õ 	�C�‰FŒF‰Œ€AØˆ1‚u€uØˆØ€GÝ�A�q˜‘s‰^Œ^ð "ð "ˆØ�A‘ð 	"Ø˜˜1™‘Hð Ø�q�qÝÐ.Ð.Ð.Ð. gÐ.Ñ.Ô.Ñ.Ô.ð "Ø—’˜qÑ!Ô!Ð!øØ•�W‘”ÑÐr   c                  ó4   — d}| D ]}|r|r	|||z  }}|°	Œ|}Œ|S )Nr   r   )Úargsr›   rœ   s      r   ÚgcdrØ   Ø  sL   € Ø	€AØð ð ˆØð 	Øð  Ø˜!˜a™%�1�ð ð  øð ˆAˆAØ€Hr   iô  c                 óþ  — | dz  rt           S |                     | ¦  «        }|r|S t          }| }d„ dD ¦   «         }t          d| dz   ¦  «        D ]®}t          |dz   dd¦  «        D ](}|dz
  ||         z  |dz   ||dz            z  z   ||dz   <   Œ)|                     d¦  «         d}t          |dz   dd¦  «        D ]*}|||dz            z  }||k    rd|dz  z  |d|z  z  z  ||<   Œ+|| k    rd|dz  z  |z  d|z  z  c S Œ¯dS )	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   c                 ó,   — g | ]}t          |¦  «        ‘ŒS r   rN   r1   s     r   r4   zeulernum.<locals>.<listcomp>  s   € Ð'Ð'Ð'�A�ˆQ‰ŒÐ'Ð'Ð'r   )r   r   r   r   r   r   r   éþÿÿÿr   r   N)r   r¡   ÚMAX_EULER_CACHEÚrangerY   )	rš   r™   r¥   r§   r   r›   r´   Úsumar¦   s	            r   Úeulernumrß   ÿ  s^  € ð$ 	ˆ1�uð ÝˆØ�
Š
�1‰Œ€AØð ØˆÝ
€CØ	€AØ'Ð'˜Ð'Ñ'Ô'€AÝ�A�q˜‘s‰mŒmð 
/ð 
/ˆÝ�q˜‘s˜B Ñ#Ô#ð 	/ð 	/ˆAØ˜‘c˜1˜Qœ4‘Z 1 Q¡3¨¨!¨A©#¬¡,Ñ.ˆAˆa�‰c‰FˆFØ	�Š�‰ŒˆØˆÝ�q˜‘s˜B Ñ#Ô#ð 	:ð 	:ˆAØ�A�a˜‘c”F‰NˆDØ�CŠxˆxØ  A q¡D™\¨D°A°q±D©LÑ9��q‘	øØ�Š6ˆ6Ø˜1˜a™4‘L $Ñ&¨!¨Q©$Ñ.Ð.Ð.Ð.ð ð
/ð 
/r   c                 óp  — | dk     s|dk     rt           ‚|| k    rt          | |k    ¦  «        S |dk     rt          S t          g|dz   z  }t          |d<   t	          d| dz   ¦  «        D ]A}t	          t          ||¦  «        dd¦  «        D ]}|dz
  ||         z  ||dz
           z   ||<   Œ ŒBd| |z   z  ||         z  S )z,
    Stirling number of the first kind.
    r   r   r   r   )Ú
ValueErrorr
   r   r   r   r   )r   r¦   r   rš   r´   s        r   Ú	stirling1râ   %  sÙ   € ð 	ˆ1‚u€u��A’�ÝÐØˆA‚v€vÝ�1˜’6‰{Œ{ÐØˆ1‚u€uÝˆÝ	ˆ
�a˜‘cÑ€AÝ€A€a�DÝ�A�q˜‘s‰^Œ^ð )ð )ˆÝ�˜A˜q™	œ	 1 bÑ)Ô)ð 	)ð 	)ˆAØ�a‘C˜1˜Qœ4‘< ! A a¡C¤&Ñ(ˆAˆa‰DˆDð	)à�!�A‘#‰;˜˜1œÑÐr   c                 ó„  — | dk     s|dk     rt           ‚|| k    rt          | |k    ¦  «        S |dk    rt          |dk    ¦  «        S t          }t          }t	          |dz   ¦  «        D ]I}||z   dz  r||t          |¦  «        | z  z  z  }n||t          |¦  «        | z  z  z  }|||z
  z  |dz   z  }ŒJ|t          |¦  «        z  S )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€u��A’�ÝÐØˆA‚v€vÝ�1˜’6‰{Œ{ÐØˆA‚v€vÝ�1˜’6‰{Œ{ÐÝ€AÝ€AÝ�A�a‘C‰[Œ[ð #ð #ˆØ�‰E�Q‰;ð 	Ø�•S˜‘V”V˜Q‘Y‘ÑˆAˆAà�•S˜‘V”V˜Q‘Y‘ÑˆAØ��Q‘‰K˜A ™EÑ"ˆˆØ•�Q‘”‰<Ðr   )r   )KÚ__doc__r;   r   Úbackendr   r   r   r   r	   r
   r   r   r$   rÝ   r´   r   r   r!   Úoperatorr'   Úversionr-   r9   r?   rB   rF   rL   rI   Úsage_bitcountÚdirrG   Ú
trailtabler=   rR   Ú	stddigitsr^   rm   ro   rd   ru   r‰   r~   r}   r|   rv   ry   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   r   ú<module>rõ      sJ  ððð ð €€€Ø Ð Ð Ð Ð Ð à Ð Ð Ð Ð Ð Ø LÐ LÐ LÐ LÐ LÐ LÐ LÐ LÐ LÐ LÐ LÐ LÐ LÐ LÐ LÐ LÐ LÐ Là��s‘€Ø	ˆˆq�‰Œð 6ð 6€AØ&' S¨A°°!±©HÑ%5€N�1�a‘4�>˜˜Q˜q™S™�>Ñ"Ð"ðð ð ð ð0 ð  ð  ð ð  ð  ð ˆfÒÐØ€O€O€OØŒ_€FØŒ_€Fð(ð (ð (ð ˆfÒÐØ€t„|�~„~˜ÒÐð	ð 	ð 	ð 	ð
	ð 	ð 	ð 
$Ð	#˜˜˜c™
œ
Ð	#Ñ	#Ô	#€ðð ð ðð ð ð'ð 'ð 'ð ˆfÒÐØ€HØ€H€HØ�ÒÐØÔ'€MØ€HØ€H€Hà€HØ€Hà
ˆfÒÐ˜¨¨¨T©¬Ð2Ð2ØŒ€Hð /Ð. 5 5¨¡:¤:Ð.Ñ.Ô.€
Ø
,Ð
,   d¡¤Ð
,Ñ
,Ô
,€ð-ð -ð -ð
 3€	à Yð 	ð 	ð 	ð 	ð  A¨ið ð ð ð ð,  !¨Ið ð ð ð ð, ˆfÒÐØ€G€Gà€Gà	
ˆC‰€Ø	
ˆC‰€Ø	
ˆC‰€Ø	
ˆC‰€Ø	€Ø€ðð ð ð4.*ð .*ð .*ð`ð ð ð( ð  ð  ðð ð ð €à
ˆfÒÐØ€t„|�~„~˜ÒÐØ+/¬:Ð5ˆÐ5�j 5Ø”.ˆˆà+/¬9Ð4ˆÐ4�j 5Ø”,ˆˆØ�ÒÐàˆ�
˜GÐ%=Ð%=Ñ>Ô>ð?€Kð ?�*˜uà(Ð(€G€Gà$€KØ"€JØ€EØ€Gð ð ð ð ð ð2 Ð à˜��ð ð ð ð ð ˜1˜  !˜u�~ð ð ð ð ð  ˆfÒÐØŒ8€D€DØ�ÒÐØ+Ð+€DØŒ>€Dð#ð #ð #ð ˆfÒÐð2ð 2ð 2ð <Ð Ø�sÐ+Ñ,Ô,Ð ð*ð *ð *ðXð ð ð&ð ð ðJ €à˜'�{ð $/ð $/ð $/ð $/ðLð ð ð"ð ð ð ð r   