o
    Þý°jél  ã                   @   s  d dl Z d dlZd dlmZ d dlmZmZmZmZm	Z	 ddl
mZ dZe jdkr-edƒ‚ed	eƒZd	ed
œZeedƒr@edƒ‚G dd„ deƒZeƒ Zed dkrnd dlmZmZmZmZ G dd„ deƒZdd„ Zeej_n
d dlmZ dd„ Zde d¡ Z G dd„ deƒZ!dS )é    N)Úis_native_int)ÚbackendÚload_libÚc_ulongÚc_size_tÚc_uint8_ptré   )ÚIntegerBaseaÆ  typedef unsigned long UNIX_ULONG;
        typedef struct { int a; int b; void *c; } MPZ;
        typedef MPZ mpz_t[1];
        typedef UNIX_ULONG mp_bitcnt_t;

        void __gmpz_init (mpz_t x);
        void __gmpz_init_set (mpz_t rop, const mpz_t op);
        void __gmpz_init_set_ui (mpz_t rop, UNIX_ULONG op);

        UNIX_ULONG __gmpz_get_ui (const mpz_t op);
        void __gmpz_set (mpz_t rop, const mpz_t op);
        void __gmpz_set_ui (mpz_t rop, UNIX_ULONG op);
        void __gmpz_add (mpz_t rop, const mpz_t op1, const mpz_t op2);
        void __gmpz_add_ui (mpz_t rop, const mpz_t op1, UNIX_ULONG op2);
        void __gmpz_sub_ui (mpz_t rop, const mpz_t op1, UNIX_ULONG op2);
        void __gmpz_addmul (mpz_t rop, const mpz_t op1, const mpz_t op2);
        void __gmpz_addmul_ui (mpz_t rop, const mpz_t op1, UNIX_ULONG op2);
        void __gmpz_submul_ui (mpz_t rop, const mpz_t op1, UNIX_ULONG op2);
        void __gmpz_import (mpz_t rop, size_t count, int order, size_t size,
                            int endian, size_t nails, const void *op);
        void * __gmpz_export (void *rop, size_t *countp, int order,
                              size_t size,
                              int endian, size_t nails, const mpz_t op);
        size_t __gmpz_sizeinbase (const mpz_t op, int base);
        void __gmpz_sub (mpz_t rop, const mpz_t op1, const mpz_t op2);
        void __gmpz_mul (mpz_t rop, const mpz_t op1, const mpz_t op2);
        void __gmpz_mul_ui (mpz_t rop, const mpz_t op1, UNIX_ULONG op2);
        int __gmpz_cmp (const mpz_t op1, const mpz_t op2);
        void __gmpz_powm (mpz_t rop, const mpz_t base, const mpz_t exp, const
                          mpz_t mod);
        void __gmpz_powm_ui (mpz_t rop, const mpz_t base, UNIX_ULONG exp,
                             const mpz_t mod);
        void __gmpz_pow_ui (mpz_t rop, const mpz_t base, UNIX_ULONG exp);
        void __gmpz_sqrt(mpz_t rop, const mpz_t op);
        void __gmpz_mod (mpz_t r, const mpz_t n, const mpz_t d);
        void __gmpz_neg (mpz_t rop, const mpz_t op);
        void __gmpz_abs (mpz_t rop, const mpz_t op);
        void __gmpz_and (mpz_t rop, const mpz_t op1, const mpz_t op2);
        void __gmpz_ior (mpz_t rop, const mpz_t op1, const mpz_t op2);
        void __gmpz_clear (mpz_t x);
        void __gmpz_tdiv_q_2exp (mpz_t q, const mpz_t n, mp_bitcnt_t b);
        void __gmpz_fdiv_q (mpz_t q, const mpz_t n, const mpz_t d);
        void __gmpz_mul_2exp (mpz_t rop, const mpz_t op1, mp_bitcnt_t op2);
        int __gmpz_tstbit (const mpz_t op, mp_bitcnt_t bit_index);
        int __gmpz_perfect_square_p (const mpz_t op);
        int __gmpz_jacobi (const mpz_t a, const mpz_t b);
        void __gmpz_gcd (mpz_t rop, const mpz_t op1, const mpz_t op2);
        UNIX_ULONG __gmpz_gcd_ui (mpz_t rop, const mpz_t op1,
                                     UNIX_ULONG op2);
        void __gmpz_lcm (mpz_t rop, const mpz_t op1, const mpz_t op2);
        int __gmpz_invert (mpz_t rop, const mpz_t op1, const mpz_t op2);
        int __gmpz_divisible_p (const mpz_t n, const mpz_t d);
        int __gmpz_divisible_ui_p (const mpz_t n, UNIX_ULONG d);

        size_t __gmpz_size (const mpz_t op);
        UNIX_ULONG __gmpz_getlimbn (const mpz_t op, size_t n);
        Úwin32zNot using GMP on WindowsÚgmp)ÚlibraryÚapiÚ__mpir_versionzMPIR library detectedc                   @   s   e Zd Zdd„ ZdS )Ú_GMPc                 C   s^   |  d¡rd|dd …  }n|  d¡rd|dd …  }ntd| ƒ‚tt|ƒ}t| ||ƒ |S )NÚmpz_Ú__gmpz_é   Úgmp_Ú__gmp_zAttribute %s is invalid)Ú
startswithÚAttributeErrorÚgetattrÚlibÚsetattr)ÚselfÚnameÚ	func_nameÚfunc© r   úŽ/root/aizidognhua/tmp/workspace/projects/ec89d86c-575f-41c9-af57-ac45cbdbf775/venv/lib/python3.10/site-packages/Cryptodome/Math/_IntegerGMP.pyÚ__getattr__p   s   


z_GMP.__getattr__N)Ú__name__Ú
__module__Ú__qualname__r    r   r   r   r   r   n   s    r   r   Úctypes)Ú	StructureÚc_intÚc_void_pÚbyrefc                   @   s"   e Zd ZdefdefdefgZdS )Ú_MPZÚ	_mp_allocÚ_mp_sizeÚ_mp_dN)r!   r"   r#   r&   r'   Ú_fields_r   r   r   r   r)   …   s
    þr)   c                   C   s
   t tƒ ƒS ©N)r(   r)   r   r   r   r   Únew_mpzŠ   ó   
r/   )Úffic                   C   s
   t  d¡S )NzMPZ*)r1   Únewr   r   r   r   r/   “   r0   é   ÚPc                   @   sà  e Zd ZdZeƒ Ze eedƒ¡ dd„ Z	dd„ Z
dd„ Zd	d
„ Zdd„ Zdd„ Zdmdd„Zedndd„ƒZdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zd d!„ Zd"d#„ ZeZd$d%„ Zd&d'„ Zd(d)„ Zd*d+„ Zd,d-„ Zd.d/„ Z dod1d2„Z!dod3d4„Z"d5d6„ Z#dod7d8„Z$d9d:„ Z%d;d<„ Z&d=d>„ Z'd?d@„ Z(dAdB„ Z)dCdD„ Z*dEdF„ Z+dGdH„ Z,dIdJ„ Z-dKdL„ Z.dMdN„ Z/dOdP„ Z0dQdR„ Z1dSdT„ Z2dUdV„ Z3dWdX„ Z4dYdZ„ Z5d[d\„ Z6d]d^„ Z7d_d`„ Z8dadb„ Z9dcdd„ Z:dedf„ Z;edgdh„ ƒZ<edidj„ ƒZ=dkdl„ Z>d0S )pÚ
IntegerGMPz#A fast, arbitrary precision integerr   c              	   C   s6  t ƒ | _d| _t|tƒrtdƒ‚t|ƒr‡t | j¡ d| _|dkr#dS t ƒ }t |¡ zG|dk}t	|ƒ}| 
¡ d d d }|dkrl|d }t |td||d ? @ ƒ¡ t ||t|d ƒ¡ t | j| j|¡ |dksBW t |¡ nt |¡ w |s…t | j| j¡ dS dS t|tƒr™t | j|j¡ d| _dS t‚)	z*Initialize the integer to the given value.Fz-A floating point type is not a natural numberTr   Nr   é    ì   ÿÿ )r/   Ú_mpz_pÚ_initializedÚ
isinstanceÚfloatÚ
ValueErrorr   Ú_gmpÚmpz_initÚabsÚ
bit_lengthÚ
mpz_set_uir   Úmpz_mul_2expÚmpz_addÚ	mpz_clearÚmpz_negr5   Úmpz_init_setÚNotImplementedError)r   ÚvalueÚtmpÚpositiveÚreduceÚslotsr   r   r   Ú__init__¡   s@   

ÿû€ÿ

zIntegerGMP.__init__c              	   C   sª   t ƒ }t || j¡ z9d}d}t || j¡dkr=t |¡d@ }|||d > O }t ||tdƒ¡ |d }t || j¡dksW t 	|¡ nt 	|¡ w | dk rQ| }t
|ƒS )Nr   r7   r6   r   )r/   r=   rF   r8   Úmpz_cmpÚ_zero_mpz_pÚ
mpz_get_uiÚmpz_tdiv_q_2expr   rD   Úint)r   rI   rH   ÚslotÚlsbr   r   r   Ú__int__Ë   s    ü€zIntegerGMP.__int__c                 C   ó   t t| ƒƒS r.   )ÚstrrR   ©r   r   r   r   Ú__str__Þ   ó   zIntegerGMP.__str__c                 C   s   dt | ƒ S )NzInteger(%s))rW   rX   r   r   r   Ú__repr__á   rZ   zIntegerGMP.__repr__c                 C   rV   r.   )ÚhexrR   rX   r   r   r   Ú__hex__å   rZ   zIntegerGMP.__hex__c                 C   s   t | ƒS r.   )rR   rX   r   r   r   Ú	__index__é   s   zIntegerGMP.__index__Úbigc                    s@  ˆdk rt dƒ‚t ˆj¡‰ tdkrd}tdˆ |d d ƒ‰ ntdkr0d	}tdˆ |d
 d ƒ‰ nt dƒ‚‡ ‡fdd„tˆ ƒD ƒ}tjd|ˆ   g|¢R Ž }t	|ƒ| }|dkr]| 
d¡}n$|dkrv|d|… d| krot dƒ‚||d… }n|dk r�d|  | }|dkr�|ddd… }n	|dkr’nt dƒ‚t	|ƒdkržd}|S )aª  Convert the number into a byte string.

        This method encodes the number in network order and prepends
        as many zero bytes as required. It only works for non-negative
        values.

        :Parameters:
          block_size : integer
            The exact size the output byte string must have.
            If zero, the string has the minimal length.
          byteorder : string
            'big' for big-endian integers (default), 'little' for litte-endian.
        :Returns:
          A byte string.
        :Raise ValueError:
          If the value is negative or if ``block_size`` is
          provided and the length of the byte string would exceed it.
        r   ú.Conversion only valid for non-negative numbersr6   ÚLr   é   r   é@   ÚQé   r3   zUnknown limb sizec                    s"   g | ]}t  ˆjˆ | d  ¡‘qS )r   )r=   Úmpz_getlimbnr8   )Ú.0Úi©Ú	num_limbsr   r   r   Ú
<listcomp>  s   " z'IntegerGMP.to_bytes.<locals>.<listcomp>ú>ó    Nz@Number is too big to convert to byte string of prescribed lengthÚlittleéÿÿÿÿr_   úIncorrect byteorder)r<   r=   Úmpz_sizer8   Ú	_sys_bitsÚmaxÚrangeÚstructÚpackÚlenÚlstrip)r   Ú
block_sizeÚ	byteorderÚspcharÚlimbsÚresultÚ
cutoff_lenr   ri   r   Úto_bytesì   s:   zIntegerGMP.to_bytesc              
   C   sd   t dƒ}|dkr	n|dkrt| ƒ} |  ¡  ntdƒ‚t |jtt| ƒƒdtdƒdtdƒt	| ƒ¡ |S )aŽ  Convert a byte string into a number.

        :Parameters:
          byte_string : byte string
            The input number, encoded in network order.
            It can only be non-negative.
          byteorder : string
            'big' for big-endian integers (default), 'little' for litte-endian.

        :Return:
          The ``Integer`` object carrying the same value as the input.
        r   r_   rn   rp   r   )
r5   Ú	bytearrayÚreverser<   r=   Ú
mpz_importr8   r   rw   r   )Úbyte_stringrz   r}   r   r   r   Ú
from_bytes(  s"   

ùzIntegerGMP.from_bytesc                 C   s    t |tƒs	t|ƒ}|| j|jƒS r.   )r:   r5   r8   )r   r   Útermr   r   r   Ú_apply_and_returnI  s   
zIntegerGMP._apply_and_returnc                 C   s(   t |tƒst|ƒsdS |  tj|¡dkS )NFr   ©r:   r5   r   r†   r=   rN   ©r   r…   r   r   r   Ú__eq__N  ó   zIntegerGMP.__eq__c                 C   s(   t |tƒst|ƒsdS |  tj|¡dkS )NTr   r‡   rˆ   r   r   r   Ú__ne__S  rŠ   zIntegerGMP.__ne__c                 C   s   |   tj|¡dk S ©Nr   ©r†   r=   rN   rˆ   r   r   r   Ú__lt__X  ó   zIntegerGMP.__lt__c                 C   s   |   tj|¡dkS rŒ   r�   rˆ   r   r   r   Ú__le__[  r�   zIntegerGMP.__le__c                 C   s   |   tj|¡dkS rŒ   r�   rˆ   r   r   r   Ú__gt__^  r�   zIntegerGMP.__gt__c                 C   s   |   tj|¡dkS rŒ   r�   rˆ   r   r   r   Ú__ge__a  r�   zIntegerGMP.__ge__c                 C   s   t  | j| j¡dkS rŒ   ©r=   rN   r8   rO   rX   r   r   r   Ú__nonzero__d  ó   zIntegerGMP.__nonzero__c                 C   s   t  | j| j¡dk S rŒ   r“   rX   r   r   r   Úis_negativeh  r•   zIntegerGMP.is_negativec                 C   óN   t dƒ}t|t ƒszt |ƒ}W n ty   t Y S w t |j| j|j¡ |S rŒ   )r5   r:   rG   ÚNotImplementedr=   rC   r8   ©r   r…   r}   r   r   r   Ú__add__l  ó   
ÿþzIntegerGMP.__add__c                 C   r—   rŒ   )r5   r:   rG   r˜   r=   Úmpz_subr8   r™   r   r   r   Ú__sub__x  r›   zIntegerGMP.__sub__c                 C   r—   rŒ   )r5   r:   rG   r˜   r=   Úmpz_mulr8   r™   r   r   r   Ú__mul__„  r›   zIntegerGMP.__mul__c                 C   sN   t |tƒs	t|ƒ}t |j| j¡dkrtdƒ‚tdƒ}t |j| j|j¡ |S )Nr   úDivision by zero)r:   r5   r=   rN   r8   rO   ÚZeroDivisionErrorÚ
mpz_fdiv_q)r   Údivisorr}   r   r   r   Ú__floordiv__�  s   
ÿÿþzIntegerGMP.__floordiv__c                 C   sb   t |tƒs	t|ƒ}t |j| j¡}|dkrtdƒ‚|dk r!tdƒ‚tdƒ}t |j| j|j¡ |S ©Nr   r    úModulus must be positive©	r:   r5   r=   rN   r8   rO   r¡   r<   Úmpz_mod)r   r£   Úcompr}   r   r   r   Ú__mod__œ  s   
ÿþzIntegerGMP.__mod__Nc                 C   sè   |d u r#|dk rt dƒ‚|dkrt dƒ‚t | j| jtt|ƒƒ¡ | S t|tƒs,t|ƒ}|s2tdƒ‚| 	¡ r:t dƒ‚t
|ƒr^|dk rFt dƒ‚|dk rYt | j| jt|ƒ|j¡ | S t|ƒ}n| 	¡ rft dƒ‚t | j| j|j|j¡ | S )Nr   zExponent must not be negativeé   zExponent is too bigr    r¦   é   )r<   r=   Ú
mpz_pow_uir8   r   rR   r:   r5   r¡   r–   r   Úmpz_powm_uiÚmpz_powm)r   ÚexponentÚmodulusr   r   r   Úinplace_pow«  sF   
þ
êý
ýzIntegerGMP.inplace_powc                 C   s   t | ƒ}| ||¡S r.   )r5   r²   )r   r°   r±   r}   r   r   r   Ú__pow__Ò  s   zIntegerGMP.__pow__c                 C   s   t dƒ}t |j| j¡ |S rŒ   )r5   r=   Úmpz_absr8   )r   r}   r   r   r   Ú__abs__Ö  s   zIntegerGMP.__abs__c                 C   sh   |du r| dk rt dƒ‚tdƒ}t |j| j¡ |S |dkr"t dƒ‚t|ƒ}t|  t| ƒ| |¡ƒ}|S )zGReturn the largest Integer that does not
        exceed the square rootNr   zSquare root of negative valuer¦   )r<   r5   r=   Úmpz_sqrtr8   rR   Ú_tonelli_shanks©r   r±   r}   r   r   r   ÚsqrtÛ  s   ÿûzIntegerGMP.sqrtc                 C   óŽ   t |ƒr;d|  krdk rn nt | j| jt|ƒ¡ | S d|  k r'dk r7n nt | j| jt| ƒ¡ | S t|ƒ}t | j| j|j¡ | S ©Nr   r¬   é ÿÿ)r   r=   Ú
mpz_add_uir8   r   Ú
mpz_sub_uir5   rC   rˆ   r   r   r   Ú__iadd__í  ó&   þþþzIntegerGMP.__iadd__c                 C   rº   r»   )r   r=   r¾   r8   r   r½   r5   rœ   rˆ   r   r   r   Ú__isub__ÿ  rÀ   zIntegerGMP.__isub__c                 C   sž   t |ƒrCd|  krdk rn nt | j| jt|ƒ¡ | S d|  k r'dk r?n nt | j| jt| ƒ¡ t | j| j¡ | S t|ƒ}t | j| j|j¡ | S r»   )r   r=   Ú
mpz_mul_uir8   r   rE   r5   rž   rˆ   r   r   r   Ú__imul__  s(   þþþzIntegerGMP.__imul__c                 C   sZ   t |tƒs	t|ƒ}t |j|j¡}|dkrtdƒ‚|dk r!tdƒ‚t | j| j|j¡ | S r¥   r§   )r   r£   r©   r   r   r   Ú__imod__$  s   
ÿþzIntegerGMP.__imod__c                 C   ó2   t dƒ}t|t ƒst |ƒ}t |j| j|j¡ |S rŒ   )r5   r:   r=   Úmpz_andr8   r™   r   r   r   Ú__and__3  ó   
þzIntegerGMP.__and__c                 C   rÅ   rŒ   )r5   r:   r=   Úmpz_iorr8   r™   r   r   r   Ú__or__<  rÈ   zIntegerGMP.__or__c                 C   sN   t dƒ}|dk rtdƒ‚|dkr| dk rdS dS t |j| jtt|ƒƒ¡ |S ©Nr   znegative shift countr¬   ro   )r5   r<   r=   rQ   r8   r   rR   ©r   Úposr}   r   r   r   Ú
__rshift__E  s   
þzIntegerGMP.__rshift__c                 C   sF   |dk rt dƒ‚|dkr| dk rdS dS t | j| jtt|ƒƒ¡ | S rË   )r<   r=   rQ   r8   r   rR   ©r   rÍ   r   r   r   Ú__irshift__S  s   
þzIntegerGMP.__irshift__c                 C   sJ   t dƒ}d|  krdk stdƒ‚ tdƒ‚t |j| jtt|ƒƒ¡ |S ©Nr   r¬   zIncorrect shift count)r5   r<   r=   rB   r8   r   rR   rÌ   r   r   r   Ú
__lshift__`  s   ÿ
þzIntegerGMP.__lshift__c                 C   sB   d|  krdk st dƒ‚ t dƒ‚t | j| jtt|ƒƒ¡ | S rÑ   )r<   r=   rB   r8   r   rR   rÏ   r   r   r   Ú__ilshift__i  s   ÿ
þzIntegerGMP.__ilshift__c                 C   sF   | dk rt dƒ‚|dk rt dƒ‚|dkrdS tt | jtt|ƒƒ¡ƒS )zPReturn True if the n-th bit is set to 1.
        Bit 0 is the least significant.r   z)no bit representation for negative valuesznegative bit countr¬   )r<   Úboolr=   Ú
mpz_tstbitr8   r   rR   )r   Únr   r   r   Úget_bitq  s   

ÿzIntegerGMP.get_bitc                 C   s   t  | jd¡dkS )Nr   r   ©r=   rÕ   r8   rX   r   r   r   Úis_odd  r�   zIntegerGMP.is_oddc                 C   s   t  | jd¡dkS rŒ   rØ   rX   r   r   r   Úis_even‚  r�   zIntegerGMP.is_evenc                 C   s   | dk rt dƒ‚t | jd¡S )z=Return the minimum number of bits that can encode the number.r   r`   é   )r<   r=   Úmpz_sizeinbaser8   rX   r   r   r   Úsize_in_bits…  s   zIntegerGMP.size_in_bitsc                 C   s   |   ¡ d d d S )z>Return the minimum number of bytes that can encode the number.r   r3   )rÝ   rX   r   r   r   Úsize_in_bytesŒ  s   zIntegerGMP.size_in_bytesc                 C   s   t  | j¡dkS rŒ   )r=   Úmpz_perfect_square_pr8   rX   r   r   r   Úis_perfect_square�  s   zIntegerGMP.is_perfect_squarec                 C   sb   t |ƒr#d|  k rdk rn nt | jt|ƒ¡rtdƒ‚dS t|ƒ}t | j|j¡r/tdƒ‚dS )z3Raise an exception if the small prime is a divisor.r   r¬   zThe value is compositeN)r   r=   Úmpz_divisible_ui_pr8   r   r<   r5   Úmpz_divisible_p)r   Úsmall_primer   r   r   Úfail_if_divisible_by“  s   ÿÿþzIntegerGMP.fail_if_divisible_byc                 C   s    t |tƒs	t|ƒ}t|ƒrDd|  k rdk r&n nt | j|jt|ƒ¡ | S d|  k r0dk r@n nt | j|jt| ƒ¡ | S t|ƒ}t | j|j|j¡ | S )z/Increment the number by the product of a and b.r   r¬   r¼   )	r:   r5   r   r=   Úmpz_addmul_uir8   r   Úmpz_submul_uiÚ
mpz_addmul)r   ÚaÚbr   r   r   Úmultiply_accumulate¡  s*   
þþþzIntegerGMP.multiply_accumulatec                 C   s&   t |tƒs	t|ƒ}t | j|j¡ | S )z'Set the Integer to have the given value)r:   r5   r=   Úmpz_setr8   )r   Úsourcer   r   r   Úset·  s   
ÿzIntegerGMP.setc                 C   sf   t |tƒs	t|ƒ}t |j| j¡}|dkrtdƒ‚|dk r!tdƒ‚t | j| j|j¡}|s1tdƒ‚| S )z…Compute the inverse of this number in the ring of
        modulo integers.

        Raise an exception if no inverse exists.
        r   úModulus cannot be zeror¦   z No inverse value can be computed)	r:   r5   r=   rN   r8   rO   r¡   r<   Ú
mpz_invert)r   r±   r©   r}   r   r   r   Úinplace_inverseÀ  s    
ÿþzIntegerGMP.inplace_inversec                 C   s   t | ƒ}| |¡ |S r.   )r5   rð   r¸   r   r   r   ÚinverseØ  s   
zIntegerGMP.inversec                 C   sb   t dƒ}t|ƒr%d|  k rdk r!n nt |j| jt|ƒ¡ |S t |ƒ}t |j| j|j¡ |S )zUCompute the greatest common denominator between this
        number and another term.r   iÿÿ  )r5   r   r=   Ú
mpz_gcd_uir8   r   Úmpz_gcdr™   r   r   r   ÚgcdÝ  s   þzIntegerGMP.gcdc                 C   rÅ   )zQCompute the least common multiplier between this
        number and another term.r   )r5   r:   r=   Úmpz_lcmr8   r™   r   r   r   Úlcmì  s
   
zIntegerGMP.lcmc                 C   sL   t | tƒs	t| ƒ} t |tƒst|ƒ}|dks| ¡ rtdƒ‚t | j|j¡S )zCompute the Jacobi symbolr   z,n must be positive odd for the Jacobi symbol)r:   r5   rÚ   r<   r=   Ú
mpz_jacobir8   )rè   rÖ   r   r   r   Újacobi_symbolö  s   

zIntegerGMP.jacobi_symbolc                 C   s„   t | tƒs	t| ƒ} t |tƒst|ƒ}t |tƒst|ƒ}|dk r#tdƒ‚|dkr+tdƒ‚|d@ dkr5tdƒ‚| | | }| | ¡ ¡S )Nr   r¦   rî   r   zOdd modulus is required)r:   r5   r<   r¡   r   rÞ   )Úterm1Úterm2r±   Úproductr   r   r   Ú_mult_modulo_bytes  s   


zIntegerGMP._mult_modulo_bytesc                 C   s>   z| j d ur| jrt | j ¡ d | _ W d S  ty   Y d S w r.   )r8   r9   r=   rD   r   rX   r   r   r   Ú__del__  s   
ÿzIntegerGMP.__del__)r   r_   )r_   r.   )?r!   r"   r#   Ú__doc__r/   rO   r=   Úmpz_init_set_uir   rM   rU   rY   r[   r]   r^   r   Ústaticmethodr„   r†   r‰   r‹   rŽ   r�   r‘   r’   r”   Ú__bool__r–   rš   r�   rŸ   r¤   rª   r²   r³   rµ   r¹   r¿   rÁ   rÃ   rÄ   rÇ   rÊ   rÎ   rÐ   rÒ   rÓ   r×   rÙ   rÚ   rÝ   rÞ   rà   rä   rê   rí   rð   rñ   rô   rö   rø   rü   rý   r   r   r   r   r5   ›   sx    *
< 

'
				


r5   )"Úsysru   ÚCryptodome.Util.py3compatr   ÚCryptodome.Util._raw_apir   r   r   r   r   Ú_IntegerBaser	   Úgmp_defsÚplatformÚImportErrorr   ÚimplementationÚhasattrÚobjectr   r=   r$   r%   r&   r'   r(   r)   r/   rf   Úrestyper1   Úcalcsizerr   r5   r   r   r   r   Ú<module>   s.   
:



