mphell-number.c

Go to the documentation of this file.

/* 
  MPHELL-4.0 
  Author(s): The MPHELL team

 (C) Copyright 2015-2018 - Institut Fourier / Univ. Grenoble Alpes (France) 

 This file is part of the MPHELL Library.
 MPHELL is free software: you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation, version 3 of the License.
 
 MPHELL is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with MPHELL.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "mphell-number.h"

/*********************************** TMP ALLOC *******************************/

void
number_tmp_alloc (number * t, const uint8_t size, uint8_t stack)
{
#if MPHELL_USE_GMP == 1
    /* We cannot handle GMP realloc, and LIMBS_PER_DIGIT_IN_BASE macro,
     * used in mpz_set_str can create realloc when the alloc size is < size +2 */
    gmp_tmp_alloc((number_ptr)(*t), size+2, stack);
#elif MPHELL_USE_IPP == 1
    ippcp_bn_tmp_alloc(t, size, stack);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_tmp_alloc((number_ptr)(*t), size, stack);
#endif
}

void
number_tmp_free (number * t, const uint8_t size, uint8_t stack)
{
#if MPHELL_USE_GMP == 1
    gmp_tmp_free((number_ptr)(*t), size+2, stack);
#elif MPHELL_USE_IPP == 1
    ippcp_bn_tmp_free(t, size, stack);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_tmp_free((number_ptr)(*t), size, stack);
#endif
}

/************************************ SETTERS ********************************/

void
number_init (number * dst, const uint8_t n)
{
#if MPHELL_USE_GMP == 1
    mpz_init2(*dst,  BLOCK_SIZE * n);
#elif MPHELL_USE_IPP == 1
    int ctxSize; 
    ippsBigNumGetSize(n, &ctxSize); 
    *dst = (IppsBigNumState*)malloc(ctxSize*sizeof(Ipp8u)); 
    ippsBigNumInit(n, *dst); /* Works with 32 bits blocks */
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_init(*dst);
    mbedtls_mpi_grow(*dst, n);
#endif
}

void
number_free (number * dst)
{
#if MPHELL_USE_GMP == 1
    mpz_clear(*dst);
#elif MPHELL_USE_IPP == 1
    free(*dst);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_free(*dst);
#endif
}

void
number_copy (number_ptr dst, number_srcptr src)
{
#if MPHELL_USE_GMP == 1
    mpz_set(dst, src);
#elif MPHELL_USE_IPP == 1
    int len;
    IppsBigNumSGN sgn;
    Ipp32u * data;
    ippsRef_BN(&sgn, &len, &data, src);
    ippsSet_BN(sgn, bits_to_nblock(len), data, dst);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_copy(dst, src);
#endif
}

void
number_set_ui (number_ptr dst, const block src)
{
#if MPHELL_USE_GMP == 1
    mpz_set_ui(dst, src);
#elif MPHELL_USE_IPP == 1
    ippsSet_BN(ippBigNumPOS, 1, (Ipp32u *)(&src), dst);
#elif MPHELL_USE_MBEDTLS == 1
    //mbedtls_mpi_lset(dst, (mbedtls_mpi_sint)src);
    memset(dst->p, 0, dst->n * BYTES_PER_LIMB);
    dst->p[0] = src;
    dst->s    = 1;
#endif
}

void 
number_set (number_ptr dst, const int8_t sign, const uint32_t size, ...)
{
#if MPHELL_USE_GMP == 1
    va_list ap;
    uint8_t i;

    va_start(ap, size);
    uint8_t n = ALLOC_SIZ(dst);
    for(i = 0; i < n; i++)
    {
        if(i < size)
        {
            LIMB(dst)[i] = (block)va_arg(ap, block);
        }
        else
        {
            LIMB(dst)[i] = (block)0;
        }
    }
    va_end(ap);
    
    SIZ(dst) = size;
    
    if(sign < 0) 
    {
        dst->_mp_size *= -1;
    }
#elif MPHELL_USE_IPP == 1
    va_list ap;
    va_start(ap, size);
    Ipp32u temp[18];
    uint8_t i;
    for(i = 0; i < size; i++)
    {
        temp[i]=va_arg(ap, Ipp32u);
    }
    if(sign < 0)
    {
        ippsSet_BN(ippBigNumNEG, size, temp, dst);
    }
    else
    {
        ippsSet_BN(ippBigNumPOS, size, temp, dst);
    }
    va_end(ap);
#elif MPHELL_USE_MBEDTLS == 1
    va_list ap;
    uint8_t i;
    mbedtls_mpi_lset(dst, 0);
    va_start(ap, size);
    dst->s = sign;
    for(i=0; i<size; i++)
    {
        dst->p[i] = (block)va_arg(ap, block);
    }
    va_end(ap);
#endif
}

void 
number_set_bit (number_ptr dst, const uint32_t bit)
{
#if (MPHELL_USE_GMP == 1 || MPHELL_USE_IPP == 1)
    uint8_t q = bit / BLOCK_SIZE;
    uint8_t r = bit % BLOCK_SIZE;
    uint8_t size = bits_to_nblock(bit+1);
#endif
#if MPHELL_USE_GMP == 1
    memset(LIMB(dst), 0, size * BYTES_PER_LIMB);
    LIMB(dst)[q] = (mp_limb_t)1 << r;
    SIZ(dst) = size;
#elif MPHELL_USE_IPP == 1
    Ipp32u data[size];
    memset(data, 0, size * BYTES_PER_LIMB);
    data[q] = (Ipp32u)1 << r;
    ippsSet_BN(IppsBigNumPOS, size, data, dst);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_set_bit(dst, bit, 1);
#endif
}

void 
number_random (number_ptr dst, const uint32_t size)
{
#if MPHELL_USE_GMP == 1
#if BLOCK_SIZE == 64
        mphell_rng(NULL, (unsigned char *)LIMB(dst), size*8);
#else
        mphell_rng(NULL, (unsigned char *)LIMB(dst), size*4);
#endif
    SIZ(dst) = size;
#elif MPHELL_USE_IPP == 1
    /* Get number of 32bits words dst can store */
    Ipp32u temp[size];
    mphell_rng(NULL, (unsigned char *)temp, size*4);
    ippsSet_BN(ippBigNumPOS, size, temp, dst);
#elif MPHELL_USE_MBEDTLS == 1
    /* Get number of 32bits words dst can store */
#if BLOCK_SIZE == 64
        mphell_rng(NULL, (unsigned char *)dst->p, size*8);
#else
        mphell_rng(NULL, (unsigned char *)dst->p, size*4);
#endif
    uint8_t i;
    for(i = size; i < dst->n; i++)
    {
        dst->p[i] = 0;
    }
#endif
}

void 
number_random1 (number_ptr dst, number_srcptr bound, uint8_t stack)
{
    number mask;
    int size;
#if MPHELL_USE_GMP == 1
    size = SIZ(bound);
#elif MPHELL_USE_IPP == 1
    ippsRef_BN(NULL, &size, NULL, bound);
    size = bits_to_nblock(size);
#elif MPHELL_USE_MBEDTLS == 1
    size = bound->n;
#endif
    number_tmp_alloc(&mask, size+1, stack);
    number_set_ui(mask, 0);
    uint16_t srcbits = number_log2(bound);
    number_set_bit(mask, srcbits);
    number_dec(mask, mask);
    do {
        number_random(dst, size);
        number_and(dst, dst, mask);
    } while (number_isgreatereq(dst, bound));
    number_tmp_free(&mask, size+1, stack);
}

/*********************************** STRING **********************************/

uint16_t 
number_log2 (number_srcptr src)
{
#if MPHELL_USE_GMP == 1
    return (uint16_t)mpz_sizeinbase(src, 2);
#elif MPHELL_USE_IPP == 1
    int size;
    ippsExtGet_BN(NULL, &size, NULL, src);
    return size;
#elif MPHELL_USE_MBEDTLS == 1
    return mbedtls_mpi_bitlen(src);
#endif
}

uint8_t 
number_block_size (number_srcptr src)
{
#if MPHELL_USE_GMP == 1
    return src->_mp_size;
#elif MPHELL_USE_IPP == 1
    int size;
    ippsExtGet_BN(NULL, &size, NULL, src);
    return bits_to_nblock(size);
#elif MPHELL_USE_MBEDTLS == 1
    return src->n;
#endif
}

uint8_t 
number_buffer_size (number_srcptr src)
{
#if MPHELL_USE_GMP == 1
    return src->_mp_alloc;
#elif MPHELL_USE_IPP == 1
    int size;
    ippsGetSize_BN(src, &size);
    return size;
#elif MPHELL_USE_MBEDTLS == 1
    return src->n;
#endif
}

void 
number_set_str (number_ptr dst, const char *str, const uint8_t base)
{
#if MPHELL_USE_GMP == 1
    mpz_set_str(dst, str, base);
#elif MPHELL_USE_IPP == 1
    int16_t i, j;
    int16_t len, len_chunk, lentmp;
    if(base == 2)
    {
        len = strlen(str);
        lentmp = len;
        len_chunk = bits_to_nblock(len);             /* Number of 32 bits blocks */
        Ipp32u data[len_chunk];
        memset(data, 0, len_chunk * 4);
        for(i=0; i<len_chunk; i++)
        {
            for(j=0; j<32; j++)
            {
                if(i*32+j<len)
                {
                    --lentmp;
                    if(str[lentmp]=='1')
                    {
                        data[i]^=((Ipp32u)1<<j);
                    }
                }
            }
        }
        ippsSet_BN(IppsBigNumPOS, len_chunk, data, dst); 
    }
    else if(base == 10)
    {
        len = strlen(str);
        int i = 0;
        number_set_ui(dst, str[i++]-'0');
        while(i < len)
        {
            number_mul_ui(dst, dst, 10);
            number_add_ui(dst, dst, str[i++]-'0');
        }
    }
    else if(base == 16)
    {
        char * tab[16]={"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"};
        j=0;
        len = strlen(str)*4;            /* Binary size */
        char str2[len+1];
        for(i=0; i<strlen(str); i++)
        {
            if(str[i]=='0')
            {
                memcpy(str2+j, tab[0], 4);
            }
            else if(str[i]=='1')
            {
                memcpy(str2+j, tab[1], 4);
            }
            else if(str[i]=='2')
            {
                memcpy(str2+j, tab[2], 4);
            }
            else if(str[i]=='3')
            {
                memcpy(str2+j, tab[3], 4);
            }
            else if(str[i]=='4')
            {
                memcpy(str2+j, tab[4], 4);
            }
            else if(str[i]=='5')
            {
                memcpy(str2+j, tab[5], 4);
            }
            else if(str[i]=='6')
            {
                memcpy(str2+j, tab[6], 4);
            }
            else if(str[i]=='7')
            {
                memcpy(str2+j, tab[7], 4);
            }
            else if(str[i]=='8')
            {
                memcpy(str2+j, tab[8], 4);
            }
            else if(str[i]=='9')
            {
                memcpy(str2+j, tab[9], 4);
            }
            else if(str[i]=='a' || str[i]=='A')
            {
                memcpy(str2+j, tab[10], 4);
            }
            else if(str[i]=='b' || str[i]=='B')
            {
                memcpy(str2+j, tab[11], 4);
            }
            else if(str[i]=='c' || str[i]=='C')
            {
                memcpy(str2+j, tab[12], 4);
            }
            else if(str[i]=='d' || str[i]=='D')
            {
                memcpy(str2+j, tab[13], 4);
            }
            else if(str[i]=='e' || str[i]=='E')
            {
                memcpy(str2+j, tab[14], 4);
            }
            else if(str[i]=='f' || str[i]=='F')
            {
                memcpy(str2+j, tab[15], 4);
            }
            else
            {
                /* Unknow character */
                break;
            }
            j+=4;
        }
        str2[j]='\0';
        number_set_str(dst, str2, 2);
    }
    else
    {
        mphell_error ("Error in number_set_str, base must be either 2, 10 or 16\n");
    }
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_lset(dst, 0);
    if(str[strlen(str)-1]=='\n')
    {
        uint16_t s = strlen(str);
        char tmp[s];
        memcpy(tmp, str, s-1);
        tmp[s-1]='\0'; /* Replace '\n' by '\0' */
        mbedtls_mpi_read_string(dst, base, tmp);
    }
    else
    {
        mbedtls_mpi_read_string(dst, base, str);
    }
#endif
}

void 
number_str (char **str, number_srcptr src, const uint8_t base)
{
#if MPHELL_USE_GMP == 1
    if(base == 16)
    {
        gmp_asprintf(str, "%Zx", src);
    }
    else if (base == 10)
    {
        gmp_asprintf(str, "%Zd", src);
    }
    else
    {
        *str = mpz_get_str (NULL, base, src);
    }
#elif MPHELL_USE_IPP == 1
    if(number_iszero(src))
    {
        *str = (char *)malloc(2*sizeof(char));
        (*str)[0]='0';
        (*str)[1]='\0';
    }
    else
    {
        if(base == 2)
        {
            int8_t i;
            uint32_t j = 0;
            int len;
            int len32;
            IppsBigNumSGN sgn;
            Ipp32u * data;
            ippsRef_BN(&sgn, &len, &data, src);
            len32 = bits_to_nblock(len);
            char * pstr;
            if(sgn==IppsBigNumNEG)
            {
                *str = (char *)malloc((len+2)*sizeof(char));
                (*str)[0]='-';
                pstr = *str+1;
                (*str)[len+1]='\0';
            }
            else
            {
                *str = (char *)malloc((len+1)*sizeof(char));
                pstr = *str;
                (*str)[len]='\0';
            }
            for(i=0; i<len32; i++)
            {
                for(j=0; j<32; j++)
                {
                    if(len > 0)
                    {
                        if(data[i] & (Ipp32u)1<<j)
                        {
                            pstr[--len]='1';
                        }
                        else
                        {
                            pstr[--len]='0';
                        }
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }
        else if (base == 10)
        {
            int i;
            int len;
            int len32;
            IppsBigNumSGN sgn;
            Ipp32u * data;
            ippsRef_BN(&sgn, &len, &data, src);
            len32 = bits_to_nblock(len);
            char * pstr;
            char tab[len32*10];
            number tmp;
            number_init(&tmp, len32);
            ippsSet_BN(IppsBigNumPOS, len32, data, tmp);
            
            int it = 0;
            block digit;
            while(!number_iszero(tmp))
            {
                number_mod_ui(&digit, tmp, 10);
                tab[it++]=digit + '0';
                number_div_ui(tmp, tmp, 10);
            }
            number_free(&tmp);
            if(sgn==IppsBigNumNEG)
            {
                *str = (char *)malloc((it+2)*sizeof(char));
                (*str)[0]='-';
                pstr = *str+1;
            }
            else
            {
                *str = (char *)malloc((it+1)*sizeof(char));
                pstr = *str;
            }
            for(i = 0; i<it; i++)
            {
                pstr[i]=tab[it-i-1];
            }
            pstr[i]='\0';
        }
        else if (base == 16)
        {
            char tab[16]={'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
            int8_t i;
            uint32_t j = 0;
            int8_t k = 0;
            int len;
            int len32;
            int len4;
            IppsBigNumSGN sgn;
            Ipp32u * data;
            ippsRef_BN(&sgn, &len, &data, src);
            len32 = bits_to_nblock(len);
            len4 = ((len / 4) + ((len % 4) != 0));
            char * pstr;
            if(sgn==IppsBigNumNEG)
            {
                *str = (char *)malloc((len4+2)*sizeof(char));
                (*str)[0]='-';
                pstr = *str+1;
                (*str)[len4+1]='\0';
            }
            else
            {
                *str = (char *)malloc((len4+1)*sizeof(char));
                pstr = *str;
                (*str)[len4]='\0';
            }
            for(i=0; i<len32; i++)
            {
                for(j=0; j<32; j+=4)
                {
                    if(len4 > 0)
                    {
                        k=0;
                        if(data[i] & (Ipp32u)1<<j)
                        {
                            k+=1;
                        }
                        if(data[i] & (Ipp32u)1<<(j+1))
                        {
                            k+=2;
                        }
                        if(data[i] & (Ipp32u)1<<(j+2))
                        {
                            k+=4;
                        }
                        if(data[i] & (Ipp32u)1<<(j+3))
                        {
                            k+=8;
                        }
                        pstr[--len4]=tab[k];
                    }
                }
            }
        }
        else
        {
            mphell_error ("Error in number_str, base must be either 2, 10 or 16\n");
        }
    }
#elif MPHELL_USE_MBEDTLS == 1
    size_t size = mbedtls_mpi_bitlen(src);
    if( base ==  10 ) 
    {
        size >>= 1;
    }
    if( base >= 16 ) 
    {
        size >>= 1;
    }
    size += 4;
    size_t outlen;
    *str = (char *)malloc(size*sizeof(char));
    mbedtls_mpi_write_string(src, base, *str, size, &outlen);
    if(((*str)[0]=='0' && outlen > 2) || ((*str)[0]=='-' && (*str)[1]=='0' && outlen > 3))
    {
        if((*str)[0]=='-')
        {
            size = 1;
        }
        else
        {
            size = 0;
        }
        for(; size < outlen-1; size++)
        {
            (*str)[size]=(*str)[size+1];
        }
    }
#endif
}

void 
number_get_ui (block * dst, number_srcptr src)
{
#if MPHELL_USE_GMP == 1
    *dst = mpz_get_ui(src);
#elif MPHELL_USE_IPP == 1
    int len;
    IppsBigNumSGN sgn;
    Ipp32u * data;
    ippsRef_BN(&sgn, &len, &data, src);
    *dst = data[0];
#elif MPHELL_USE_MBEDTLS == 1
    *dst = src->p[0];
#endif
}

void 
number_to_bit_string (char *str, number_srcptr src)
{
#if MPHELL_USE_GMP == 1
    mpz_get_str (str, 2, src);
#elif MPHELL_USE_IPP == 1
    if(number_iszero(src))
    {
        str[0]='0';
        str[1]='\0';
    }
    else
    {
        int8_t i;
        uint32_t j = 0;
        int len;
        int len32;
        IppsBigNumSGN sgn;
        Ipp32u * data;
        ippsRef_BN(&sgn, &len, &data, src);
        len32 = bits_to_nblock(len);
        str[len]='\0';
        for(i=0; i<len32; i++)
        {
            for(j=0; j<32; j++)
            {
                if(len > 0)
                {
                    if(data[i] & (Ipp32u)1<<j)
                    {
                        str[--len]='1';
                    }
                    else
                    {
                        str[--len]='0';
                    }
                }
                else
                {
                    break;
                }
            }
        }
    }
#elif MPHELL_USE_MBEDTLS == 1
    size_t size = mbedtls_mpi_bitlen(src)+4;
    mbedtls_mpi_write_string(src, 2, str, size, &size);
#endif
}

void 
number_print (number_srcptr src, const uint8_t base)
{
#if MPHELL_USE_GMP == 1
    if(base == 16)
    {
        gmp_printf("%Zx", src);
    }
    else if (base == 10)
    {
        gmp_printf("%Zd", src);
    }
    else
    {
        char * str;
        number_str(&str, src, base);
        printf("%s", str);
        free(str);
    }
#elif (MPHELL_USE_IPP == 1 || MPHELL_USE_MBEDTLS == 1)
    char * str;
    number_str(&str, src, base);
    printf("%s", str);
    free(str);
#endif
}

/*********************************** COMPARISON ******************************/

bool
number_iszero(number_srcptr src)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp_ui(src, (block)0) == 0);
#elif MPHELL_USE_IPP == 1
    Ipp32u test;
    ippsCmpZero_BN(src, &test);
    return (test==IS_ZERO);
#elif MPHELL_USE_MBEDTLS == 1
    return (mbedtls_mpi_cmp_int(src, 0) == 0);
#endif
}

bool 
number_isequal_ui (number_srcptr src1, const block src2)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp_ui(src1, src2) == 0);
#elif MPHELL_USE_IPP == 1
    int len;
    IppsBigNumSGN sgn;
    Ipp32u * data;
    ippsRef_BN(&sgn, &len, &data, src1);
    if((sgn == IppsBigNumNEG) || (len > 32) || (data[0]!=(Ipp32u)src2))
    {
        return false;
    }
    else
    {
        return true;
    }
#elif MPHELL_USE_MBEDTLS == 1
    return (mbedtls_mpi_cmp_int(src1, (mbedtls_mpi_sint)src2) == 0);
#endif
}

bool 
number_isequal (number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp(src1, src2) == 0);
#elif MPHELL_USE_IPP == 1
    Ipp32u test;
    ippsCmp_BN(src1, src2, &test);
    return (test==IS_ZERO);
#elif MPHELL_USE_MBEDTLS == 1
    return (mbedtls_mpi_cmp_mpi(src1, src2)==0);
#endif
}

bool 
number_isdiff_ui (number_srcptr src1, const block src2)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp_ui(src1, src2) != 0);
#elif (MPHELL_USE_IPP == 1 || MPHELL_USE_MBEDTLS == 1)
    return (!number_isequal_ui(src1, src2));
#endif
}

bool 
number_isdiff (number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp(src1, src2) != 0);
#elif (MPHELL_USE_IPP == 1 || MPHELL_USE_MBEDTLS == 1)
    return (!number_isequal(src1, src2));
#endif
}

bool 
number_islower_ui (number_srcptr src1, const block src2)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp_ui(src1, src2) < 0);
#elif MPHELL_USE_IPP == 1
    int len;
    IppsBigNumSGN sgn;
    Ipp32u * data;
    ippsRef_BN(&sgn, &len, &data, src1);
    if(sgn == IppsBigNumNEG)
    {
        return true;
    }
    if((len > 32) || (data[0]>=(Ipp32u)src2))
    {
        return false;
    }
    else
    {
        return true;
    }
#elif MPHELL_USE_MBEDTLS == 1
    return (mbedtls_mpi_cmp_int(src1, (mbedtls_mpi_sint)src2) < 0);
#endif
}

bool 
number_islower (number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp(src1, src2) < 0);
#elif MPHELL_USE_IPP == 1
    Ipp32u test;
    ippsCmp_BN(src1, src2, &test);
    return (test==LESS_THAN_ZERO);
#elif MPHELL_USE_MBEDTLS == 1
    return (mbedtls_mpi_cmp_mpi(src1, src2)<0);
#endif
}

bool
number_isgreater_ui (number_srcptr src1, const block src2)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp_ui(src1, src2) > 0);
#elif MPHELL_USE_IPP == 1
    int len;
    IppsBigNumSGN sgn;
    Ipp32u * data;
    ippsRef_BN(&sgn, &len, &data, src1);
    if (len > 32)
    {
        return true;
    }
    if((sgn == IppsBigNumNEG) || (data[0]<=(Ipp32u)src2))
    {
        return false;
    }
    else
    {
        return true;
    }
#elif MPHELL_USE_MBEDTLS == 1
    return (mbedtls_mpi_cmp_int(src1, (mbedtls_mpi_sint)src2) > 0);
#endif
}

bool 
number_isgreater (number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp(src1, src2) > 0);
#elif MPHELL_USE_IPP == 1
    Ipp32u test;
    ippsCmp_BN(src1, src2, &test);
    return (test==GREATER_THAN_ZERO);
#elif MPHELL_USE_MBEDTLS == 1
    return (mbedtls_mpi_cmp_mpi(src1, src2)>0);
#endif

}

bool 
number_islowereq_ui (number_srcptr src1, const block src2)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp_ui(src1, src2) <= 0);
#elif MPHELL_USE_IPP == 1
    return (number_islower_ui(src1, src2)==true || number_isequal_ui(src1, src2)==true);
#elif MPHELL_USE_MBEDTLS == 1
    return (mbedtls_mpi_cmp_int(src1, (mbedtls_mpi_sint)src2) <= 0);
#endif
}

bool
number_islowereq (number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp(src1, src2) <= 0);
#elif MPHELL_USE_IPP == 1
    return (number_islower(src1, src2)==true || number_isequal(src1, src2)==true);
#elif MPHELL_USE_MBEDTLS == 1
    return (mbedtls_mpi_cmp_mpi(src1, src2)<=0);
#endif
}

bool 
number_isgreatereq_ui (number_srcptr src1, const block src2)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp_ui(src1, src2) >= 0);
#elif MPHELL_USE_IPP == 1
    return (number_isgreater_ui(src1, src2)==true || number_isequal_ui(src1, src2)==true);
#elif MPHELL_USE_MBEDTLS == 1
    return (mbedtls_mpi_cmp_int(src1, (mbedtls_mpi_sint)src2) >= 0);
#endif
}

bool 
number_isgreatereq (number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    return (mpz_cmp(src1, src2) >= 0);
#elif MPHELL_USE_IPP == 1
    return (number_isgreater(src1, src2)==true || number_isequal(src1, src2)==true);
#elif MPHELL_USE_MBEDTLS == 1
    return (mbedtls_mpi_cmp_mpi(src1, src2)>=0);
#endif
}

int8_t
number_cmp_ui (number_srcptr src1, const block src2)
{
#if MPHELL_USE_GMP == 1
    return mpz_cmp_ui(src1, src2);
#elif MPHELL_USE_IPP == 1
    if(number_isgreater_ui(src1, src2))
    {
        return 1;
    }
    else if(number_islower_ui(src1, src2))
    {
        return -1;
    }
    return 0;
#elif MPHELL_USE_MBEDTLS == 1
    return mbedtls_mpi_cmp_int(src1, (mbedtls_mpi_sint)src2);
#endif
}

int8_t
number_cmp (number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    return mpz_cmp(src1, src2);
#elif MPHELL_USE_IPP == 1
    Ipp32u test;
    ippsCmp_BN(src1, src2, &test);
    if(test==IS_ZERO)
    {
        return 0;
    }
    else if (test==GREATER_THAN_ZERO)
    {
        return 1;
    }
    else
    {
        return -1;
    }
#elif MPHELL_USE_MBEDTLS == 1
    return mbedtls_mpi_cmp_mpi(src1, src2);
#endif
}

bool
number_iseven(number_srcptr src)
{
#if MPHELL_USE_GMP == 1
    return !(LIMB(src)[0] & (block)1);
#elif MPHELL_USE_IPP == 1
    Ipp32u * data;
    ippsRef_BN(NULL, NULL, &data, src);
    return !(data[0] & (block)1);
#elif MPHELL_USE_MBEDTLS == 1
    return !(src->p[0] & (block)1);
#endif
}

bool
number_isodd(number_srcptr src)
{
#if MPHELL_USE_GMP == 1
    return (LIMB(src)[0] & (block)1);
#elif MPHELL_USE_IPP == 1
    Ipp32u * data;
    ippsRef_BN(NULL, NULL, &data, src);
    return (data[0] & (block)1);
#elif MPHELL_USE_MBEDTLS == 1
    return (src->p[0] & (block)1);
#endif
}

/************************************ LOGICAL ********************************/

block 
number_and_ui (number_srcptr src1, const block src2, uint8_t stack)
{
#if MPHELL_USE_GMP == 1
    number t;
    number_tmp_alloc(&t, 1, stack);
    mpz_set_ui(t, src2);
    mpz_and(t, src1, t);
    block res = mpz_get_ui(t);
    number_tmp_free(&t, 1, stack);
    return res;
#elif MPHELL_USE_IPP == 1
    Ipp32u * data;
    ippsRef_BN(NULL, NULL, &data, src1);
    return data[0] & (Ipp32u)src2;
#elif MPHELL_USE_MBEDTLS == 1
    return (src1->p[0] & src2);
#endif
}

void 
number_and (number_ptr dst, number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    mpz_and(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    Ipp32u * data1, * data2;
    int len1, len2, lenchunk1, lenchunk2;
    ippsRef_BN(NULL, &len1, &data1, src1);
    ippsRef_BN(NULL, &len2, &data2, src2);
    lenchunk1 = bits_to_nblock(len1);
    lenchunk2 = bits_to_nblock(len2);
    int i;
    int min;
    if(lenchunk1 < lenchunk2)
    {
        min = lenchunk1;
    }
    else
    {
        min = lenchunk2;
    }
    Ipp32u tab[min];
    for (i=0; i<min; i++)
    {
        tab[i] = data1[i] & data2[i];
    }
    ippsSet_BN(IppsBigNumPOS, min, tab, dst);
#elif MPHELL_USE_MBEDTLS == 1
    int i;
    int min;
    if(src1->n < src2->n)
    {
        min = src1->n;
    }
    else
    {
        min = src2->n;
    }
    for (i=0; i<min; i++)
    {
        dst->p[i] = src1->p[i] & src2->p[i];
    }
    for (i=min; i<dst->n; i++)
    {
        dst->p[i] = 0;
    }
#endif
}

void 
number_or_ui (number_ptr dst, number_srcptr src1, const block src2, uint8_t stack)
{
#if MPHELL_USE_GMP == 1
    number t; 
    number_tmp_alloc(&t, 1, stack);
    mpz_set_ui(t, src2);
    mpz_ior(dst, src1, t);
    number_tmp_free(&t, 1, stack);
#elif MPHELL_USE_IPP == 1
    number_copy(dst, src1);
    Ipp32u * data;
    ippsRef_BN(NULL, NULL, &data, dst);
    data[0] |= src2;
#elif MPHELL_USE_MBEDTLS == 1
    number_copy(dst, src1);
    dst->p[0] |= src2;
#endif
}

void 
number_or (number_ptr dst, number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    mpz_ior(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    int i;
    Ipp32u * data1, * data2;
    int len1, len2, lenchunk1, lenchunk2;
    ippsRef_BN(NULL, &len1, &data1, src1);
    ippsRef_BN(NULL, &len2, &data2, src2);
    lenchunk1 = bits_to_nblock(len1);
    lenchunk2 = bits_to_nblock(len2);
    if(lenchunk1 < lenchunk2)
    {
        Ipp32u tab[lenchunk2];
        for (i=0; i<lenchunk1; i++)
        {
            tab[i] = data1[i] | data2[i];
        }
        for(i=lenchunk1; i<lenchunk2; i++)
        {
            tab[i] = data2[i];
        }
        ippsSet_BN(IppsBigNumPOS, lenchunk2, tab, dst); 
    }
    else
    {
        Ipp32u tab[lenchunk1];
        for (i=0; i<lenchunk2; i++)
        {
            tab[i] = data1[i] | data2[i];
        }
        for(i=lenchunk2; i<lenchunk1; i++)
        {
            tab[i] = data1[i];
        }
        ippsSet_BN(IppsBigNumPOS, lenchunk1, tab, dst); 
    }
#elif MPHELL_USE_MBEDTLS == 1
    int i;
    if(src1->n < src2->n)
    {
        for (i=0; i<src1->n; i++)
        {
            dst->p[i] = src1->p[i] | src2->p[i];
        }
        for(i=src1->n; i<src2->n; i++)
        {
            dst->p[i] = src2->p[i];
        }
    }
    else
    {
        for (i=0; i<src2->n; i++)
        {
            dst->p[i] = src1->p[i] | src2->p[i];
        }
        for(i=src2->n; i<src1->n; i++)
        {
            dst->p[i] = src1->p[i];
        }
    }
#endif
}

void 
number_xor_ui (number_ptr dst, number_srcptr src1, const block src2, uint8_t stack)
{
#if MPHELL_USE_GMP == 1
    number t; 
    number_tmp_alloc(&t, 1, stack);
    mpz_set_ui(t, src2);
    mpz_xor(dst, src1, t);
    number_tmp_free(&t, 1, stack);
#elif MPHELL_USE_IPP == 1
    number_copy(dst, src1);
    Ipp32u * data;
    ippsRef_BN(NULL, NULL, &data, dst);
    data[0] ^= src2;
#elif MPHELL_USE_MBEDTLS == 1
    number_copy(dst, src1);
    dst->p[0] ^= src2;
#endif
}

void 
number_xor (number_ptr dst, number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    mpz_xor(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    int i;
    Ipp32u * data1, * data2;
    int len1, len2, lenchunk1, lenchunk2;
    ippsRef_BN(NULL, &len1, &data1, src1);
    ippsRef_BN(NULL, &len2, &data2, src2);
    lenchunk1 = bits_to_nblock(len1);
    lenchunk2 = bits_to_nblock(len2);
    if(lenchunk1 < lenchunk2)
    {
        Ipp32u tab[lenchunk2];
        for (i=0; i<lenchunk1; i++)
        {
            tab[i] = data1[i] ^ data2[i];
        }
        for(i=lenchunk1; i<lenchunk2; i++)
        {
            tab[i] = data2[i];
        }
        ippsSet_BN(IppsBigNumPOS, lenchunk2, tab, dst); 
    }
    else
    {
        Ipp32u tab[lenchunk1];
        for (i=0; i<lenchunk2; i++)
        {
            tab[i] = data1[i] ^ data2[i];
        }
        for(i=lenchunk2; i<lenchunk1; i++)
        {
            tab[i] = data1[i];
        }
        ippsSet_BN(IppsBigNumPOS, lenchunk1, tab, dst); 
    }
#elif MPHELL_USE_MBEDTLS == 1
    int i;
    if(src1->n < src2->n)
    {
        for (i=0; i<src1->n; i++)
        {
            dst->p[i] = src1->p[i] ^ src2->p[i];
        }
        for(i=src1->n; i<src2->n; i++)
        {
            dst->p[i] = src2->p[i];
        }
    }
    else
    {
        for (i=0; i<src2->n; i++)
        {
            dst->p[i] = src1->p[i] ^ src2->p[i];
        }
        for(i=src2->n; i<src1->n; i++)
        {
            dst->p[i] = src1->p[i];
        }
    }
#endif
}

void 
number_lshift (number_ptr dst, number_srcptr src, const uint16_t shift)
{
#if MPHELL_USE_GMP == 1
    mpz_mul_2exp(dst, src, shift);
#elif MPHELL_USE_IPP == 1
    int q, r, len32;
    len32 = bits_to_nblock(shift);
    q = len32 - ((shift % 32)!=0);
    r = shift - q*32;
    int lenshift=len32+(r==0);
    Ipp32u data[lenshift];
    memset(data, 0, lenshift*4);
    data[lenshift-1] = (Ipp32u)1 << r;
    number tmp;
    number_init(&tmp, lenshift);
    ippsSet_BN(IppsBigNumPOS, lenshift, data, tmp); 
    ippsMul_BN(src, tmp, dst);
    number_free(&tmp);
#elif MPHELL_USE_MBEDTLS == 1
    number_copy(dst, src);
    mbedtls_mpi_shift_l(dst, shift);
#endif
}

void 
number_rshift (number_ptr dst, number_srcptr src, const uint16_t shift)
{
#if MPHELL_USE_GMP == 1
    mpz_tdiv_q_2exp(dst, src, shift);
#elif MPHELL_USE_IPP == 1
    int q, r, len32;
    len32 = bits_to_nblock(shift);
    q = len32 - ((shift % 32)!=0);
    r = shift - q*32;
    int lenshift=len32+(r==0);
    Ipp32u data[lenshift];
    memset(data, 0, lenshift*4);
    data[lenshift-1] = (Ipp32u)1 << r;
    number tmp;
    number_init(&tmp, lenshift);
    ippsSet_BN(IppsBigNumPOS, lenshift, data, tmp);
    number_div(dst, src, tmp);
    number_div(tmp, src, tmp);
    number_free(&tmp);
#elif MPHELL_USE_MBEDTLS == 1
    number_copy(dst, src);
    mbedtls_mpi_shift_r(dst, shift);
#endif
}


/********************************* ARITHMETIC ********************************/

void 
number_add_ui (number_ptr dst, number_srcptr src1,
        const block src2)
{
#if MPHELL_USE_GMP == 1
    mpz_add_ui(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    number tmp;
    number_init(&tmp, 1);
    number_set_ui(tmp, (Ipp32u)src2);
    ippsAdd_BN(src1, tmp, dst);
    number_free(&tmp);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_add_int(dst, src1, (mbedtls_mpi_sint)src2);
#endif
}

void 
number_add (number_ptr dst, number_srcptr src1, 
        number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    mpz_add(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    ippsAdd_BN(src1, src2, dst);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_add_mpi(dst, src1, src2);
#endif
}

void
number_inc (number_ptr dst, number_srcptr src)
{
    number_add_ui(dst, src, 1);
}

void 
number_sub_ui (number_ptr dst, number_srcptr src1, 
        const block src2)
{
#if MPHELL_USE_GMP == 1
    mpz_sub_ui(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    number tmp;
    number_init(&tmp, 1);
    number_set_ui(tmp, (Ipp32u)src2);
    ippsSub_BN(src1, tmp, dst);
    number_free(&tmp);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_sub_int(dst, src1, (mbedtls_mpi_sint)src2);
#endif
}

void 
number_sub (number_ptr dst, number_srcptr src1, 
        number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    mpz_sub(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    ippsSub_BN(src1, src2, dst);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_sub_mpi(dst, src1, src2);
#endif
}

void
number_dec (number_ptr dst, number_srcptr src)
{
    number_sub_ui(dst, src, 1);
}

void 
number_mul_ui (number_ptr dst, number_srcptr src1, const block src2)
{
#if MPHELL_USE_GMP == 1
    mpz_mul_ui(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    number tmp;
    number_init(&tmp, 1);
    number_set_ui(tmp, (Ipp32u)src2);
    ippsMul_BN(src1, tmp, dst);
    number_free(&tmp);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_mul_int(dst, src1, (mbedtls_mpi_uint)src2);
#endif
}

void 
number_addmul_ui (number_ptr dst, number_srcptr src1, const block src2)
{
#if MPHELL_USE_GMP == 1
    mpz_addmul_ui(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    number tmp;
    number_init(&tmp, 1);
    number_set_ui(tmp, src2);
    ippsMAC_BN_I(src1, tmp, dst);
    number_free(&tmp);
#elif MPHELL_USE_MBEDTLS == 1
    number tmp;
    number_init(&tmp, src1->n+1);
    number_mul_ui(tmp, src1, src2);
    number_add(dst, dst, tmp);
    number_free(&tmp);
#endif
}

void 
number_mul (number_ptr dst, number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    mpz_mul(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    ippsMul_BN(src1, src2, dst);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_mul_mpi(dst, src1, src2);
#endif
}

void number_mul_mod (number_ptr dst, number_srcptr src1, number_srcptr src2, number_srcptr mod, uint8_t stack)
{
#if MPHELL_USE_GMP == 1
    uint8_t size = SIZ(src1)+SIZ(src2);
    number tmp;
    number_tmp_alloc(&tmp, size, stack);
    mpz_mul(tmp, src1, src2);
    mpz_mod(dst, tmp, mod);
    number_tmp_free(&tmp, size, stack);
#elif MPHELL_USE_IPP == 1
    number mul;
    /* Get number of 32bits words src1 can store */
    int len1, len2, lenchunk1, lenchunk2;
    ippsRef_BN(NULL, &len1, NULL, src1);
    ippsRef_BN(NULL, &len2, NULL, src2);
    lenchunk1 = bits_to_nblock(len1);
    lenchunk2 = bits_to_nblock(len2);
    number_tmp_alloc(&mul, lenchunk1+lenchunk2, stack);
    ippsMul_BN(src1, src2, mul);
    ippsMod_BN(mul, mod, dst);
    number_tmp_free(&mul, lenchunk1+lenchunk2, stack);
#elif MPHELL_USE_MBEDTLS == 1
    uint8_t size = src1->n+src2->n;
    number tmp;
    number_tmp_alloc(&tmp, size, stack);
    mbedtls_mpi_mul_mpi(tmp, src1, src2);
    mbedtls_mpi_mod_mpi(dst, tmp, mod);
    number_tmp_free(&tmp, size, stack);
#endif
}

void 
number_addmul (number_ptr dst, number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    mpz_addmul(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    ippsMAC_BN_I(src1, src2, dst);
#elif MPHELL_USE_MBEDTLS == 1
    number tmp;
    number_init(&tmp, src1->n+src2->n);
    number_mul(tmp, src1, src2);
    number_add(dst, dst, tmp);
    number_free(&tmp);
#endif
}

void 
number_pow (number_ptr dst, number_srcptr src1, number_srcptr src2, uint8_t stack)
{
#if MPHELL_USE_GMP == 1
    mpz_pow_ui(dst, src1, mpz_get_ui(src2));
#elif MPHELL_USE_IPP == 1
    int len1, len2, lenchunk1, lenchunk2;
    ippsRef_BN(NULL, &len1, NULL, src1);
    ippsRef_BN(NULL, &len2, NULL, src2);
    lenchunk1 = bits_to_nblock(len1);
    lenchunk2 = bits_to_nblock(len2);
    
    number tmp;
    number_tmp_alloc(&tmp, lenchunk1*len2, stack);
    number_copy(tmp, src1);
    
    number m;
    number_tmp_alloc(&m, lenchunk2, stack);
    number_copy(m, src2);
    
    number_set_ui(dst, 1);
    while (!number_iszero(m)) 
    {
        if (number_isodd(m)) 
        {
            number_mul(dst, dst, tmp);
        }
        number_sqr(tmp, tmp);
        number_rshift(m, m, 1);
    }
    number_tmp_free(&tmp, lenchunk1*len2, stack);
    number_tmp_free(&m, lenchunk2, stack);
#elif MPHELL_USE_MBEDTLS == 1
    int16_t len2 = number_log2(src2);
    number tmp;
    number_tmp_alloc(&tmp, src1->n*len2, stack);
    number_copy(tmp, src1);
    
    number m;
    number_tmp_alloc(&m, src2->n, stack);
    number_copy(m, src2);
    
    number_set_ui(dst, 1);
    while (!number_iszero(m)) 
    {
        if (number_isodd(m)) 
        {
            number_mul(dst, dst, tmp);
        }
        number_sqr(tmp, tmp);
        number_rshift(m, m, 1);
    }
    number_tmp_free(&tmp, src1->n*len2, stack);
    number_tmp_free(&m, src2->n, stack);
#endif
}

void 
number_powm (number_ptr dst, number_srcptr src1, number_srcptr src2, number_srcptr mod, uint8_t stack)
{
#if MPHELL_USE_GMP == 1
    mpz_powm(dst, src1, src2, mod);
#elif MPHELL_USE_IPP == 1
    int i,len1, len2, lenchunk1;
    char *m;
    ippsRef_BN(NULL, &len1, NULL, mod);
    lenchunk1 = bits_to_nblock(len1);

    number tmp;
    number_tmp_alloc(&tmp, lenchunk1, stack);
    number_copy(tmp, src1);

    number_str(&m, src2, 2);
    len2=strlen(m);
    number_set_ui(dst, 1);
    for(i=len2-1; i>=0; i--)
    {
        if(m[i]=='1')
        {
            number_mul_mod(dst, dst, tmp, mod, stack);
        }
        number_mul_mod(tmp, tmp, tmp, mod, stack);
    }
    free(m);
    number_tmp_free(&tmp, lenchunk1, stack);
#elif MPHELL_USE_MBEDTLS == 1
    if(number_isodd(mod))
    {
        mbedtls_mpi_exp_mod(dst, src1, src2, mod, NULL);
    }
    else
    {
        int i;
        char *m;

        number tmp;
        number_tmp_alloc(&tmp, mod->n, stack);
        number_copy(tmp, src1);
        number_str(&m, src2, 2);
        number_set_ui(dst, 1);
        for(i=strlen(m)-1; i>=0; i--)
        {
            if(m[i]=='1')
            {
                number_mul_mod(dst, dst, tmp, mod, stack);
            }
            number_mul_mod(tmp, tmp, tmp, mod, stack);
        }
        free(m);
        number_tmp_free(&tmp, mod->n, stack);
    }
#endif
}

void 
number_powm_ui (number_ptr dst, number_srcptr src1, const block src2, number_srcptr mod, uint8_t stack)
{
#if MPHELL_USE_GMP == 1
    mpz_powm_ui(dst, src1, src2, mod);
#elif MPHELL_USE_IPP == 1
    block m = src2;
    int len1, lenchunk1;
    ippsRef_BN(NULL, &len1, NULL, mod);
    lenchunk1 = bits_to_nblock(len1);
    number tmp;
    number_tmp_alloc(&tmp, lenchunk1, stack);
    number_copy(tmp, src1);
    number_set_ui(dst, 1);
    while (m != (block)0) 
    {
        if (m & (block)1) 
        {
            number_mul_mod(dst, dst, tmp, mod, stack);
        }
        number_mul_mod(tmp, tmp, tmp, mod, stack);
        m >>= 1;
    }
    number_tmp_free(&tmp, lenchunk1, stack);
#elif MPHELL_USE_MBEDTLS == 1
    if(number_isodd(mod))
    {
        mbedtls_mpi B;
        mbedtls_mpi_uint p[1];

        p[0] = src2;
        B.s = 1;
        B.n = 1;
        B.p = p;
        mbedtls_mpi_exp_mod(dst, src1, &B, mod, NULL);
    }
    else
    {
        block m = src2;
        number tmp;
        number_tmp_alloc(&tmp, mod->n, stack);
        number_copy(tmp, src1);
        number_set_ui(dst, 1);
        while (m != (block)0) 
        {
            if (m & (block)1) 
            {
                number_mul_mod(dst, dst, tmp, mod, stack);
            }
            number_mul_mod(tmp, tmp, tmp, mod, stack);
            m >>= 1;
        }
        number_tmp_free(&tmp, mod->n, stack);
    }
#endif
}

void 
number_sqr (number_ptr dst, number_srcptr src)
{
#if MPHELL_USE_GMP == 1
    mpz_mul(dst, src, src);
#elif MPHELL_USE_IPP == 1
    ippsMul_BN(src, src, dst);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_mul_mpi(dst, src, src);
#endif
}

void
number_divmod_ui (number_ptr q, block *r, number_srcptr src1,
        const block src2)
{
#if MPHELL_USE_GMP == 1
    *r = mpz_fdiv_q_ui(q, src1, src2);
#elif MPHELL_USE_IPP == 1
    number rst;
    number_init(&rst, 1);
    number b;
    number_init(&b, 1);
    number_set_ui(b, src2);
    ippsDiv_BN(src1, b, q, rst);
    Ipp32u * data;
    ippsRef_BN(NULL, NULL, &data, rst);
    *r = data[0];
    number_free(&rst);
    number_free(&b);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi B;
    mbedtls_mpi_uint p[1];
    B.s = 1;
    B.n = 1;
    B.p = p;
    mbedtls_mpi_div_int(q, &B, src1, (mbedtls_mpi_sint)src2);
    *r = B.p[0];
#endif
}

void 
number_divmod (number_ptr q, number_ptr r, number_srcptr src1, 
        number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    mpz_divmod(q, r, src1, src2);
#elif MPHELL_USE_IPP == 1
    ippsDiv_BN(src1, src2, q, r);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_div_mpi(q, r, src1, src2);
#endif
}

void
number_div_ui (number_ptr dst, number_srcptr src1, const block src2)
{
#if MPHELL_USE_GMP == 1
    mpz_fdiv_q_ui(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    number rst;
    number_init(&rst, 1);
    number b;
    number_init(&b, 1);
    number_set_ui(b, src2);
    ippsDiv_BN(src1, b, dst, rst);
    number_free(&rst);
    number_free(&b);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi B;
    mbedtls_mpi_uint p[1];
    B.s = 1;
    B.n = 1;
    B.p = p;
    mbedtls_mpi_div_int(dst, &B, src1, (mbedtls_mpi_sint)src2);
#endif
}

void
number_div (number_ptr dst, number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    mpz_div(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    number rst;
    int len, lenchunk;
    ippsRef_BN(NULL, &len, NULL, src2);
    lenchunk = bits_to_nblock(len);
    number_init(&rst, lenchunk);
    ippsDiv_BN(src1, src2, dst, rst);
    number_free(&rst);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_div_mpi(dst, NULL, src1, src2);
#endif
}

void 
number_mod_ui (block *dst, number_srcptr src1, const block src2)
{
#if MPHELL_USE_GMP == 1
    *dst = mpz_fdiv_ui(src1, (block)src2);
#elif MPHELL_USE_IPP == 1
    number b, d;
    number_init(&b, 1);
    number_init(&d, 1);
    number_set_ui(b, src2);
    ippsMod_BN(src1, b, d);
    Ipp32u * data;
    ippsRef_BN(NULL, NULL, &data, d);
    *dst = data[0];
    number_free(&b);
    number_free(&d);
#elif MPHELL_USE_MBEDTLS == 1    
    mbedtls_mpi B;
    mbedtls_mpi_uint p[1];
    B.s = 1;
    B.n = 1;
    B.p = p;
    mbedtls_mpi C;
    mbedtls_mpi_uint q[1];
    C.s = 1;
    C.n = 1;
    C.p = q;
    C.p[0] = src2;
    mbedtls_mpi_mod_mpi(&B, src1, &C);
    *dst = B.p[0];
#endif
}


void 
number_mod (number_ptr dst, number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    mpz_mod(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    ippsMod_BN(src1, src2, dst);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_mod_mpi(dst, src1, src2);
#endif
}

void 
number_invmod (number_ptr dst, number_srcptr src1, number_srcptr src2)
{
    MPHELL_ASSERT_ALWAYS(number_iszero(src1) == false , "number_invmod : src1 == 0");
    if(number_isequal_ui(src1, 1))
    {
        number_copy(dst, src1);
        return;
    }    
#if MPHELL_USE_GMP == 1
    mpz_invert(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    if(dst == src1)
    {
        int len1, lenchunk1;
        ippsRef_BN(NULL, &len1, NULL, src1);
        lenchunk1 = bits_to_nblock(len1);
        number tmp;
        number_init(&tmp, lenchunk1);
        number_copy(tmp, src1);
        IppStatus st = ippsModInv_BN(tmp, src2, dst);
        if(st != ippStsNoErr)
        {
            printf("Error ippsModInv_BN: %s\n", ippcpGetStatusString(st));
        }
        number_free(&tmp);
    }
    else if(dst == src2)
    {
        int len2, lenchunk2;
        ippsRef_BN(NULL, &len2, NULL, src2);
        lenchunk2 = bits_to_nblock(len2);
        number tmp;
        number_init(&tmp, lenchunk2);
        number_copy(tmp, src2);
        IppStatus st = ippsModInv_BN(src1, tmp, dst);
        if(st != ippStsNoErr)
        {
            printf("Error ippsModInv_BN: %s\n", ippcpGetStatusString(st));
        }
        number_free(&tmp);
    }
    else
    {
        IppStatus st = ippsModInv_BN(src1, src2, dst);
        if(st != ippStsNoErr)
        {
            printf("Error ippsModInv_BN: %s\n", ippcpGetStatusString(st));
        }
    }
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_inv_mod(dst, src1, src2);
#endif
}

void number_inv_mod_basis(block * dst, const block src)
{
#if MPHELL_USE_GMP == 1
    /* minus_src = -src */
    mpz_t minus_src;
    mpz_init(minus_src);
    mpz_set_ui(minus_src, src);
    mpz_neg(minus_src, minus_src);
    
    /* base = 2^32 or 2^64 according to the block size */
    mpz_t one;
    mpz_t base;
    mpz_init(one);
    mpz_init(base);
    mpz_set_ui(one, 1);
    mpz_mul_2exp(base, one, BLOCK_SIZE);
    
    /* dst ; dst * (-src) = 1 mod base */
    mpz_t res;
    mpz_init(res);
    mpz_invert(res, minus_src, base);
    *dst = mpz_get_ui(res);
    
    /* Free */
    mpz_clear(minus_src);
    mpz_clear(one);
    mpz_clear(base);
    mpz_clear(res);
#elif MPHELL_USE_IPP == 1
    /* Not implemented */
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_uint x, m0 = src;
    unsigned int i;

    x  = m0;
    x += ( ( m0 + 2 ) & 4 ) << 1;

    for( i = sizeof(mbedtls_mpi_uint)<<3; i >= 8; i /= 2 )
        x *= ( 2 - ( m0 * x ) );

    *dst = ~x + 1;
#endif
}


#if MPHELL_USE_GMP == 1

void
redcify(number_ptr dst, number_srcptr src, number_srcptr p, uint8_t stack)
{
    number tp; 
    uint8_t n = SIZ(p)+SIZ(src);
    number_tmp_alloc(&tp, n, stack);
    mpz_mul_2exp(tp, src, SIZ(p)*BLOCK_SIZE);  /* a simple multiplication by 2^(n*BLOCK_SIZE)=R  */
    mpz_tdiv_r (dst, tp, p);
    number_tmp_free(&tp, n, stack);
}

void
gmp_rshift1(mpz_t dst, uint8_t size)
{
    uint8_t i;
    for (i = 0; i < size-1; i++)
    {
        LIMB(dst)[i]=LIMB(dst)[i+1];
    }
    LIMB(dst)[size-1]= 0;
    SIZ(dst) = size-1;
}

mp_size_t
gmp_redc_1 (mp_ptr rp, mp_ptr up, mp_srcptr mp, mp_size_t n, mp_limb_t invm)
{
    mp_size_t i, j, rs;
    mp_limb_t cy;

    for (j = n - 1; j >= 0; j--)
    {
        cy = mpn_addmul_1 (up, mp, n, (up[0] * invm) & GMP_NUMB_MASK);
        MPHELL_ASSERT (up[0] == 0, "mphell_redc_1 : up[0] == 0");
        up[0] = cy;
        up++;
    }
    cy = mpn_add_n (rp, up, up - n, n);
    
    if (cy != 0)
    {
        mpn_sub_n (rp, rp, mp, n);
    }
    if(mpn_cmp(rp, mp, n)>0)
    {
        mpn_sub_n (rp, rp, mp, n);
    }
    
    /* Adjust size */
    rs = n;
    for(i=n-1; i>=0; i--)
    {
        if(rp[i]==0)
        {
            rs--;
        }
        else
        {
            break;
        }
    }
    return rs;
}

void
gmp_mred_full(number_ptr dst, number_srcptr src1, number_srcptr src2, number_srcptr p,
        const block invp, uint8_t stack)
{
    uint8_t n = SIZ(p);
    
    number tmp;
    number_tmp_alloc(&tmp, 2*n, stack);
    mpn_mul_n(LIMB(tmp), LIMB(src1), LIMB(src2), n);
    SIZ(dst)=gmp_redc_1(LIMB(dst), LIMB(tmp), LIMB(p), n, invp);
    number_tmp_free(&tmp, 2*n, stack);
}

void
gmp_mred_block(number_ptr dst, number_srcptr src1, number_srcptr src2, number_srcptr p,
        const block invp, uint8_t stack)
{
    uint8_t n = SIZ(p);
    uint8_t n1 = SIZ(src1);
    
    if(number_iszero(src1) || number_iszero(src2))
    {
        number_set_ui(dst, (block)0);
        return;
    }
    
    number tmp;
    number_tmp_alloc(&tmp, n, stack);
    mpz_set_ui(tmp, 0);

    mp_limb_t *res = LIMB(tmp);
    mp_limb_t m, carry, a;
    uint8_t i;
    
    memset(res, 0, n*BLOCK_SIZE);

    for (i = 0; i < n1; i++)
    {
        /* m = (res[0] + y[0]*x[i])*invp */
        m = (res[0] + (LIMB(src1)[i] * LIMB(src2)[0])) * invp;
        
                
        /* res += y*x[i] + p*m */
        carry = mpn_addmul_1 (res, LIMB(src2), SIZ(src2), LIMB(src1)[i]);
        
        if((SIZ(src2) < n) && (carry > 0))
        {
            carry =  mpn_add_1 (res + SIZ(src2), res + SIZ(src2), n - SIZ(src2), carry);
        }
        
        a = mpn_addmul_1 (res, LIMB(p), n, m);
        gmp_rshift1(tmp, n);
        
        res[n - 1] = carry + a;
        /* res >=p ? res -= p */
        if ((res[n - 1] < a) || (res[n - 1] < carry))
        {
            mpn_sub (res, res, n, LIMB(p), n);
        }
        else if (mpn_cmp(res, LIMB(p), n)>=0)
        {
            mpn_sub (res, res, n, LIMB(p), n);
        }
    }
    for (i = n1; i < n; i++) 
    {
        /* m = res[0] * invp */
        m = res[0] * invp;
                
        /* res += p*m */
        a = mpn_addmul_1 (res, LIMB(p), n, m);
        
        /* res >>= BLOCK_SIZE */
        gmp_rshift1(tmp, n);
        
        res[n - 1] = a;
        
        /* res >=p ? res -= p */
        if (mpn_cmp(res, LIMB(p), n)>=0)
        {
            mpn_sub (res, res, n, LIMB(p), n);
        }
    }
    /* Adjust size */
    SIZ(tmp) = n;
    for(i=n-1; i>=0; i--)
    {
        if(res[i]==0)
        {
            SIZ(tmp)--;
        }
        else
        {
            break;
        }
    }
    mpn_copyi(LIMB(dst), res, SIZ(tmp));
    SIZ(dst) = SIZ(tmp);
    number_tmp_free(&tmp, n, stack);
}
#elif MPHELL_USE_IPP == 1
    /* Not implemented */
    
#elif MPHELL_USE_MBEDTLS == 1
    /* Not implemented */

void
redcify(number_ptr dst, number_srcptr src, number_srcptr p, uint8_t stack)
{
    number tp; 
    uint8_t n = p->n+src->n;
    number_tmp_alloc(&tp, n, stack);
    number_lshift(tp, src, p->n*BLOCK_SIZE);  /* a simple multiplication by 2^(n*BLOCK_SIZE)=R  */
    number_mod (dst, tp, p);
    number_tmp_free(&tp, n, stack);
}

/*
 * Helper for mbedtls_mpi multiplication
 */
static
#if defined(__APPLE__) && defined(__arm__)
/*
 * Apple LLVM version 4.2 (clang-425.0.24) (based on LLVM 3.2svn)
 * appears to need this to prevent bad ARM code generation at -O3.
 */
__attribute__ ((noinline))
#endif
void mpi_mul_hlp_mphell( size_t i, mbedtls_mpi_uint *s, mbedtls_mpi_uint *d, mbedtls_mpi_uint b )
{
    mbedtls_mpi_uint c = 0, t = 0;

#if defined(MULADDC_HUIT)
    for( ; i >= 8; i -= 8 )
    {
        MULADDC_INIT
        MULADDC_HUIT
        MULADDC_STOP
    }

    for( ; i > 0; i-- )
    {
        MULADDC_INIT
        MULADDC_CORE
        MULADDC_STOP
    }
#else /* MULADDC_HUIT */
    for( ; i >= 16; i -= 16 )
    {
        MULADDC_INIT
        MULADDC_CORE   MULADDC_CORE
        MULADDC_CORE   MULADDC_CORE
        MULADDC_CORE   MULADDC_CORE
        MULADDC_CORE   MULADDC_CORE

        MULADDC_CORE   MULADDC_CORE
        MULADDC_CORE   MULADDC_CORE
        MULADDC_CORE   MULADDC_CORE
        MULADDC_CORE   MULADDC_CORE
        MULADDC_STOP
    }

    for( ; i >= 8; i -= 8 )
    {
        MULADDC_INIT
        MULADDC_CORE   MULADDC_CORE
        MULADDC_CORE   MULADDC_CORE

        MULADDC_CORE   MULADDC_CORE
        MULADDC_CORE   MULADDC_CORE
        MULADDC_STOP
    }

    for( ; i > 0; i-- )
    {
        MULADDC_INIT
        MULADDC_CORE
        MULADDC_STOP
    }
#endif /* MULADDC_HUIT */

    t++;

    do {
        *d += c; c = ( *d < c ); d++;
    }
    while( c != 0 );
}

/*
 * Helper for mbedtls_mpi subtraction
 */
static void mpi_sub_hlp_mphell( size_t n, mbedtls_mpi_uint *s, mbedtls_mpi_uint *d )
{
    size_t i;
    mbedtls_mpi_uint c, z;

    for( i = c = 0; i < n; i++, s++, d++ )
    {
        z = ( *d <  c );     *d -=  c;
        c = ( *d < *s ) + z; *d -= *s;
    }

    while( c != 0 )
    {
        z = ( *d < c ); *d -= c;
        c = z; d++;
    }
}

void 
mpi_montmul_mphell(mbedtls_mpi *Dst, const mbedtls_mpi *A, const mbedtls_mpi *B, const mbedtls_mpi *N, mbedtls_mpi_uint mm, const mbedtls_mpi *T )
{
    size_t i, n, m;
    mbedtls_mpi_uint u0, u1, *d;

    memset( T->p, 0, T->n * BYTES_PER_LIMB );

    d = T->p;
    n = N->n;
    m = ( B->n < n ) ? B->n : n;

    for( i = 0; i < n; i++ )
    {
        /*
         * T = (T + u0*B + u1*N) / 2^biL
         */
        u0 = A->p[i];
        u1 = ( d[0] + u0 * B->p[0] ) * mm;

        mpi_mul_hlp_mphell( m, B->p, d, u0 );
        mpi_mul_hlp_mphell( n, N->p, d, u1 );

        *d++ = u0; d[n + 1] = 0;
    }

    memcpy( Dst->p, d, ( n + 1 ) * BYTES_PER_LIMB );

    if( mbedtls_mpi_cmp_abs( Dst, N ) >= 0 )
    {
        mpi_sub_hlp_mphell( n, N->p, Dst->p );
    }
}
#endif


void
number_mul_montgomery(number_ptr dst, number_srcptr src1, number_srcptr src2, number_srcptr p, const block invp, uint8_t stack)
{
#if MPHELL_USE_GMP == 1
    MPHELL_ASSERT(SIZ(src1) >= 0, "number_mul_montgomery : invalid size for src1");
    MPHELL_ASSERT(SIZ(src2) >= 0, "number_mul_montgomery : invalid size for src2");
    MPHELL_ASSERT(SIZ(p) >= 1, "number_mul_montgomery : invalid size for p");
    MPHELL_ASSERT(ALLOC_SIZ(dst) >= 1, "number_mul_montgomery : invalid size for dst");
    uint8_t n = SIZ(p);
    if((SIZ(src1) == n) && (SIZ(src2) == n))
    {
        gmp_mred_full(dst, src1, src2, p, invp, stack);
    }
    else
    {
        gmp_mred_block(dst, src1, src2, p, invp, stack);
    }
#elif MPHELL_USE_IPP == 1
    /* Not implemented */
#elif MPHELL_USE_MBEDTLS == 1
    number tmp;
    number_tmp_alloc(&tmp, p->n+2, stack); 
    mpi_montmul_mphell(dst, src1, src2, p, invp, tmp );
    number_tmp_free(&tmp, p->n+2, stack); 
#endif
}

void
number_mul_montgomery_block(number_ptr dst, number_srcptr src1, number_srcptr src2, number_srcptr p, const block invp, uint8_t stack)
{
#if MPHELL_USE_GMP == 1
    MPHELL_ASSERT(SIZ(src1) >= 0, "number_mul_montgomery : invalid size for src1");
    MPHELL_ASSERT(SIZ(src2) >= 0, "number_mul_montgomery : invalid size for src2");
    MPHELL_ASSERT(SIZ(p) >= 1, "number_mul_montgomery : invalid size for p");
    MPHELL_ASSERT(ALLOC_SIZ(dst) >= 1, "number_mul_montgomery : invalid size for dst");
    gmp_mred_block(dst, src1, src2, p, invp, stack);
#elif MPHELL_USE_IPP == 1
    /* Not implemented */
#elif MPHELL_USE_MBEDTLS == 1
    /* Not implemented */
    number tmp;
    number_tmp_alloc(&tmp, p->n+2, stack); 
    mpi_montmul_mphell(dst, src1, src2, p, invp, tmp );
    number_tmp_free(&tmp, p->n+2, stack);
#endif
}

void 
number_inv_montgomery(number_ptr dst, number_srcptr src, number_srcptr p, const block invp, 
        number_srcptr R2, number_srcptr one, uint8_t stack)
{
#if (MPHELL_USE_GMP == 1 || MPHELL_USE_MBEDTLS == 1)
    MPHELL_ASSERT(SIZ(src) >= 1, "u_invmod : invalid size for src");
    MPHELL_ASSERT(SIZ(R2) >= 1, "u_invmod : invalid size for R2");
    MPHELL_ASSERT(SIZ(p) >= 1, "u_invmod : invalid size for p");
    MPHELL_ASSERT(SIZ(one) >= 1, "u_invmod : invalid size for one");
    MPHELL_ASSERT(ALLOC_SIZ(dst) >= 1, "u_invmod : invalid size for dst");

    uint8_t n = SIZ(p);

    MPHELL_ASSERT_ALWAYS(number_iszero(src)==false, "u_invmod : inversion of 0");
    
    if(number_isequal(src, one))
    {
        number_copy(dst, one);
        return;
    }

    number t, s, r, v;
    number_tmp_alloc(&t, n, stack);
    number_tmp_alloc(&s, n, stack);
    number_tmp_alloc(&r, n, stack);
    number_tmp_alloc(&v, n+1, stack);

    number_copy(r, src);                            /* r <- src         */
    number_copy(t, p);                              /* t <- p           */
    number_set_ui(s, 1);                            /* s <- 1           */
    number_set_ui(v, 0);                            /* v <- 0           */

    block k;
    uint8_t c = 0;
    k = 0;
    
    while(number_isdiff_ui(r,0))
    {
        if(!(LIMB(t)[0] & 1))                       /* If tn != 1       */
        {
            number_rshift(t, t, 1);                 /* t >> 1           */
            number_lshift(s, s, 1);                 /* s = 2 * s        */
        }
        else if(!(LIMB(r)[0] & 1))                  /* If rn != 1       */
        {
            number_rshift(r, r, 1);                 /* r >> 1           */
            number_lshift(v, v, 1);                 /* v = 2 * v        */
        }
        else if(number_isgreater(t,r))
        {
            number_sub(t, t, r);
            number_rshift(t, t, 1);                 /* t >> 1           */
            number_add(v, v, s);
            number_lshift(s, s, 1);                 /* s = 2 * s        */
        }
        else
        {
            number_sub(r, r, t);
            number_rshift(r, r, 1);                 /* r >> 1           */
            number_add(s, v, s);
            number_lshift(v, v, 1);                 /* v = 2 * v        */
        }
        k++;
    }
    if(c)
    {
        number_sub(v, v, p);
    }
    if(number_isgreatereq(v, p))
    {
        number_sub(v, v, p);
    }
    number_sub(v, p, v);

    if(k <= (BLOCK_SIZE * n))
    {
        number_mul_montgomery(v, v, R2, p, invp, stack);
        k += BLOCK_SIZE * n;
    }

    number_mul_montgomery(v, v, R2, p, invp, stack);
    number_set_ui(s, 1);
    
    number_lshift(s, s, (2 * BLOCK_SIZE * n) - k);
    number_mul_montgomery(dst, v, s, p, invp, stack);

    number_tmp_free(&t, n, stack);
    number_tmp_free(&s, n, stack);
    number_tmp_free(&r, n, stack);
    number_tmp_free(&v, n+1, stack);
    
#elif MPHELL_USE_IPP == 1
    /* Not implemented */
#endif
}

int8_t 
number_legendre (number_srcptr src1, number_srcptr src2, uint8_t stack)
{
#if MPHELL_USE_GMP == 1
    return mpz_legendre(src1, src2);
#elif MPHELL_USE_IPP == 1
    int len, lenchunk;
    ippsRef_BN(NULL, &len, NULL, src2);
    lenchunk = bits_to_nblock(len);
    number tmp;
    number_tmp_alloc(&tmp, lenchunk, stack);
    number_copy(tmp, src2);
    number_dec(tmp, tmp);                       /* p-1              */
    number_div_ui(tmp, tmp, 2);                 /* (p-1)/2          */
    number_powm(tmp, src1, tmp, src2, stack);   /* src1^((p-1)/2)   */
    if(number_isequal_ui(tmp, 1))
    {
        number_tmp_free(&tmp, lenchunk, stack);
        return 1;
    }
    else if (number_iszero(tmp))
    {
        number_tmp_free(&tmp, lenchunk, stack);
        return 0;
    }
    else
    {
        number_tmp_free(&tmp, lenchunk, stack);
        return -1;
    }
#elif MPHELL_USE_MBEDTLS == 1
    number tmp, tmp1;
    uint8_t size = src2->n;
    number_tmp_alloc(&tmp, size, stack);
    number_tmp_alloc(&tmp1, size+1, stack);
    number_copy(tmp, src2);
    number_dec(tmp, tmp);                       /* p-1              */
    number_div_ui(tmp, tmp, 2);                 /* (p-1)/2          */
    number_powm(tmp1, src1, tmp, src2, stack);  /* src1^((p-1)/2)   */
    if(number_isequal_ui(tmp1, 1))
    {
        number_tmp_free(&tmp, size, stack);
        number_tmp_free(&tmp1, size+1, stack);
        return 1;
    }
    else if (number_iszero(tmp1))
    {
        number_tmp_free(&tmp, size, stack);
        number_tmp_free(&tmp1, size+1, stack);
        return 0;
    }
    else
    {
        number_tmp_free(&tmp, size, stack);
        number_tmp_free(&tmp1, size+1, stack);
        return -1;
    }
#endif
}

void 
number_gcd_ui (block * dst, number_srcptr src1, const block src2)
{
#if MPHELL_USE_GMP == 1
    *dst = mpz_gcd_ui(NULL, src1, src2);
#elif MPHELL_USE_IPP == 1
    number b;
    number_init(&b, 1);
    number d;
    number_init(&d, 1);
    number_set_ui(b, src2);
    ippsGcd_BN(src1, b, d);
    Ipp32u * data;
    ippsRef_BN(NULL, NULL, &data, d);
    *dst = data[0];
    number_free(&b);
    number_free(&d);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi B, C;
    mbedtls_mpi_uint p[1];
    mbedtls_mpi_uint q[1];
    B.s = 1;
    B.n = 1;
    B.p = p;
    C.s = 1;
    C.n = 1;
    C.p = q;
    C.p[0] = src2;
    mbedtls_mpi_gcd(&B, src1, &C);
    *dst = B.p[0];
#endif
}

void 
number_gcd (number_ptr dst, number_srcptr src1, number_srcptr src2)
{
#if MPHELL_USE_GMP == 1
    mpz_gcd(dst, src1, src2);
#elif MPHELL_USE_IPP == 1
    ippsGcd_BN(src1, src2, dst);
#elif MPHELL_USE_MBEDTLS == 1
    mbedtls_mpi_gcd(dst, src1, src2);
#endif
}

uint8_t
number_Rabin_Miller (number_srcptr src, const uint16_t bound)
{
#if MPHELL_USE_GMP == 1
    return mpz_probab_prime_p(src, (int)bound);
#elif MPHELL_USE_IPP == 1
    Ipp32u res;
    int ctxSize;
    int len;
    ippsRef_BN(NULL, &len, NULL, src);

    /* Define Prime context */
    ippsPrimeGetSize(len, &ctxSize);
    IppsPrimeState* pPrimeG = (IppsPrimeState*)(malloc(ctxSize) );
    ippsPrimeInit(len, pPrimeG);

    /* Define Pseudo Random Generator (default settings) */
    ippsPRNGGetSize(&ctxSize);
    IppsPRNGState* pRand = (IppsPRNGState*)(malloc(ctxSize));
    ippsPRNGInit(160, pRand);
    ippsPrimeTest_BN(src, (int) bound, &res, pPrimeG, ippsPRNGen, pRand);
    
    free(pPrimeG);
    free(pRand);
    if (res == IPP_IS_PRIME)
    {
        return 1;
    }
    return 0;
#elif MPHELL_USE_MBEDTLS == 1
    number tmp;
    number_init(&tmp, src->n);
    number_copy(tmp, src);
    while(tmp->p[tmp->n-1]==0)
    {
        tmp->n--;
    }
    int ret = mbedtls_mpi_is_prime(tmp, mphell_rng, NULL);
    number_free(&tmp);
    if (ret == 0)
    {
        return 1;
    }
    return 0;
#endif
}