'#include once "big_int/big_int_full.bi"
'headers translated using fbfrog
#pragma once
#inclib "big_int"

#include once "crt/stddef.bi"
#include once "crt/stdint.bi"

extern "C"

#define BIG_INT_FULL_H
#define BIG_INT_STR_FUNCS_H
#define BIG_INT_H
#define BIG_INT_BUILD_DATE_ __DATE__ " " __TIME__
#define BIG_INT_VERSION_ "0.0.50"
#define MEMORY_MANAGER_H

declare function bi_malloc(byval n as uinteger) as any ptr
declare function bi_realloc(byval p as any ptr, byval n as uinteger) as any ptr
declare sub bi_free(byval p as any ptr)
'' TODO: #define BIG_INT_API extern
const BIG_INT_DIGIT_SIZE = 32
type big_int_word as ulong
type big_int_dword as ulongint

#define BIG_INT_WORD_BYTES_CNT sizeof(big_int_word)
#define BIG_INT_WORD_BITS_CNT (sizeof(big_int_word) * 8)
#define BIG_INT_LO_WORD(n) cast(big_int_word, (n))
#define BIG_INT_HI_WORD(n) cast(big_int_word, cast(big_int_dword, (n)) shr BIG_INT_WORD_BITS_CNT)
#define BIG_INT_MAX_WORD_NUM BIG_INT_LO_WORD(not cast(big_int_word, 0))

type sign_type as long
enum
   PLUS
   MINUS
end enum

type bin_op_type as long
enum
   OP_ADD
   OP_SUB
   OP_MUL
   OP_DIV
   OP_MOD
   OP_CMP
   OP_POW
   OP_GCD
   OP_OR
   OP_XOR
   OP_AND
   OP_ANDNOT
end enum

type big_int
   num as big_int_word ptr
   sign as sign_type
   len as uinteger
   len_allocated as uinteger
end type

#define BIG_INT_STR_TYPES_H

type big_int_str
   str as zstring ptr
   len as uinteger
   len_allocated as uinteger
end type

declare function big_int_str_create(byval len as uinteger) as big_int_str ptr
declare function big_int_str_dup(byval s as const big_int_str ptr) as big_int_str ptr
declare sub big_int_str_destroy(byval s as big_int_str ptr)
declare function big_int_str_copy(byval src as const big_int_str ptr, byval dst as big_int_str ptr) as long
declare function big_int_str_copy_s(byval str as const zstring ptr, byval str_len as uinteger, byval dst as big_int_str ptr) as long
declare function big_int_str_realloc(byval s as big_int_str ptr, byval len as uinteger) as long
#define BIG_INT_SERVICE_FUNCS_H
declare function big_int_version() as const zstring ptr
declare function big_int_build_date() as const zstring ptr
declare function big_int_create(byval len as uinteger) as big_int ptr
declare function big_int_dup(byval a as const big_int ptr) as big_int ptr
declare sub big_int_destroy(byval a as big_int ptr)
declare sub big_int_clear_zeros(byval a as big_int ptr)
declare function big_int_copy(byval src as const big_int ptr, byval dst as big_int ptr) as long
declare function big_int_realloc(byval a as big_int ptr, byval len as uinteger) as long
declare function big_int_from_str(byval s as const big_int_str ptr, byval base as ulong, byval answer as big_int ptr) as long
declare function big_int_to_str(byval a as const big_int ptr, byval base as ulong, byval s as big_int_str ptr) as long
declare function big_int_from_int(byval value as long, byval a as big_int ptr) as long
declare function big_int_to_int(byval a as const big_int ptr, byval value as long ptr) as long
declare function big_int_base_convert(byval src as const big_int_str ptr, byval dst as big_int_str ptr, byval base_from as ulong, byval base_to as ulong) as long
declare function big_int_serialize(byval a as const big_int ptr, byval is_sign as long, byval s as big_int_str ptr) as long
declare function big_int_unserialize(byval s as const big_int_str ptr, byval is_sign as long, byval a as big_int ptr) as long
#define BIG_INT_BASIC_FUNCS_H
declare sub big_int_cmp_abs(byval a as const big_int ptr, byval b as const big_int ptr, byval cmp_flag as long ptr)
declare sub big_int_cmp(byval a as const big_int ptr, byval b as const big_int ptr, byval cmp_flag as long ptr)
declare sub big_int_sign(byval a as const big_int ptr, byval sign as sign_type ptr)
declare sub big_int_is_zero(byval a as const big_int ptr, byval is_zero as long ptr)
declare sub big_int_is_one(byval a as const big_int ptr, byval is_one as long ptr)
declare function big_int_abs(byval a as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_neg(byval a as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_inc(byval a as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_dec(byval a as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_sqr(byval a as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_mul(byval a as const big_int ptr, byval b as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_div(byval a as const big_int ptr, byval b as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_mod(byval a as const big_int ptr, byval b as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_add(byval a as const big_int ptr, byval b as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_sub(byval a as const big_int ptr, byval b as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_muladd(byval a as const big_int ptr, byval b as const big_int ptr, byval c as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_div_extended(byval a as const big_int ptr, byval b as const big_int ptr, byval q as big_int ptr, byval r as big_int ptr) as long
#define BIG_INT_NUMBER_THEORY_H
#define BIG_INT_MODULAR_ARITHMETIC_H
declare function big_int_addmod(byval a as const big_int ptr, byval b as const big_int ptr, byval modulus as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_submod(byval a as const big_int ptr, byval b as const big_int ptr, byval modulus as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_mulmod(byval a as const big_int ptr, byval b as const big_int ptr, byval modulus as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_divmod(byval a as const big_int ptr, byval b as const big_int ptr, byval modulus as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_powmod(byval a as const big_int ptr, byval b as const big_int ptr, byval modulus as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_factmod(byval a as const big_int ptr, byval modulus as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_absmod(byval a as const big_int ptr, byval modulus as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_invmod(byval a as const big_int ptr, byval modulus as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_sqrmod(byval a as const big_int ptr, byval modulus as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_cmpmod(byval a as const big_int ptr, byval b as const big_int ptr, byval modulus as const big_int ptr, byval cmp_flag as long ptr) as long
declare function big_int_gcd(byval a as const big_int ptr, byval b as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_gcd_extended(byval a as const big_int ptr, byval b as const big_int ptr, byval gcd as big_int ptr, byval x as big_int ptr, byval y as big_int ptr) as long
declare function big_int_pow(byval a as const big_int ptr, byval power as long, byval answer as big_int ptr) as long
declare function big_int_sqrt(byval a as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_sqrt_rem(byval a as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_fact(byval n as long, byval answer as big_int ptr) as long
declare function big_int_miller_test(byval a as const big_int ptr, byval base as const big_int ptr, byval is_prime as long ptr) as long
declare function big_int_is_prime(byval a as const big_int ptr, byval primes_to as ulong, byval level as long, byval is_prime as long ptr) as long
declare function big_int_next_prime(byval a as const big_int ptr, byval answer as big_int ptr) as long
declare function big_int_jacobi(byval a as const big_int ptr, byval b as const big_int ptr, byval jacobi as long ptr) as long
#define BIG_INT_BITSET_FUNCS_H
type big_int_rnd_fp as function() as long
declare sub big_int_bit_length(byval a as const big_int ptr, byval len as ulong ptr)
declare sub big_int_bit1_cnt(byval a as const big_int ptr, byval cnt as ulong ptr)
declare function big_int_subint(byval a as const big_int ptr, byval start_bit as uinteger, byval bit_len as uinteger, byval is_invert as long, byval answer as big_int ptr) as long
declare function big_int_or(byval a as const big_int ptr, byval b as const big_int ptr, byval start_bit as uinteger, byval answer as big_int ptr) as long
declare function big_int_and(byval a as const big_int ptr, byval b as const big_int ptr, byval start_bit as uinteger, byval answer as big_int ptr) as long
declare function big_int_andnot(byval a as const big_int ptr, byval b as const big_int ptr, byval start_bit as uinteger, byval answer as big_int ptr) as long
declare function big_int_xor(byval a as const big_int ptr, byval b as const big_int ptr, byval start_bit as uinteger, byval answer as big_int ptr) as long
declare function big_int_set_bit(byval a as const big_int ptr, byval n_bit as uinteger, byval answer as big_int ptr) as long
declare function big_int_clr_bit(byval a as const big_int ptr, byval n_bit as uinteger, byval answer as big_int ptr) as long
declare function big_int_inv_bit(byval a as const big_int ptr, byval n_bit as uinteger, byval answer as big_int ptr) as long
declare function big_int_test_bit(byval a as const big_int ptr, byval n_bit as uinteger, byval bit_value as long ptr) as long
declare function big_int_scan1_bit(byval a as const big_int ptr, byval pos_start as uinteger, byval pos_found as uinteger ptr) as long
declare function big_int_scan0_bit(byval a as const big_int ptr, byval pos_start as uinteger, byval pos_found as uinteger ptr) as long
declare function big_int_hamming_distance(byval a as const big_int ptr, byval b as const big_int ptr, byval distance as ulong ptr) as long
declare function big_int_rshift(byval a as const big_int ptr, byval n_bits as long, byval answer as big_int ptr) as long
declare function big_int_lshift(byval a as const big_int ptr, byval n_bits as long, byval answer as big_int ptr) as long
declare function big_int_rand(byval rand_func as big_int_rnd_fp, byval n_bits as uinteger, byval answer as big_int ptr) as long

end extern

#ifndef NULL
#define NULL 0
#endif

Type bigint
    Declare Constructor ( )
    Declare Constructor ( Byval rhs As Long )
    Declare Constructor ( Byref rhs As String )
    Declare Constructor ( Byref rhs As bigint )
    Declare Destructor ( )
    Declare Operator Let ( Byref rhs As bigint )
    Declare Operator Let ( Byval rhs As Long )
    Declare Operator Let ( Byref rhs As String )
    Declare Operator Cast ( ) As String
    Declare Operator Cast ( ) As Long
    Declare Operator Cast ( ) As Double
    Declare Operator Cast ( ) As Single
    '----------------------------------------------
    Declare Operator += (Byref rhs As bigint)
    Declare Operator += (Byval rhs as long)
    Declare Operator += (byref rhs as String)
    Declare Operator -= (Byref rhs As bigint)
    Declare Operator -= (byval rhs as long)
    Declare Operator -= (byref rhs as String)
    Declare Operator *= (Byref rhs As bigint)
    Declare Operator *= (byval rhs as long)
    Declare Operator *= (byref rhs as String)
    Declare Operator /= (Byref rhs As bigint)
    Declare Operator /= (byval rhs as long)
    Declare Operator /= (byref rhs as String)
    Declare Operator ^= (byval rhs as long)

    ' For Next Implicit step = +1
    Declare Operator For ( )
    Declare Operator Step( )
    Declare Operator Next( Byref end_cond As bigint ) As Integer
    ' For Next Exlicit step
    Declare Operator For ( Byref stp As bigint )
    Declare Operator Step( Byref stp As bigint )
    Declare Operator Next( Byref end_cond As bigint, Byref step_var As bigint ) As Integer
    '----------------------------------------------
    declare function toString( ) as string
    declare Function toLong ( ) As Long
    
    numptr As big_int ptr
End Type

function bigint.toString() as string
   dim as string retstr
    dim as big_int_str ptr s

    s = big_int_str_create( 1 )
    if( s = NULL ) then
        print "error when creating [s]"
        exit function
    end if
    
    if( big_int_to_str( this.numptr, 10, s ) <> 0 ) then
        print "error when converting number [num] to string [s]"
        exit function
    end if
    
    retstr=*s->str
    
    big_int_str_destroy( s )
    return retstr
end function

Function bigint.toLong ( ) As Long
   dim as Long ret
   if (big_int_to_int(this.numptr, @ret)<>0) then
      print "error in function bigint.toLong"
   end if
   return ret
End Function

Constructor bigint ( )
   this.numptr=big_int_create(1)
    if( this.numptr = NULL ) then
        print "error when creating big_int"
    else
      big_int_from_int(0, this.numptr)
    end if
End Constructor

Constructor bigint ( Byval rhs As Long )
   this.numptr=big_int_create(1)
    if( this.numptr = NULL ) then
        print "error when creating big_int"
    else
      big_int_from_int(rhs, this.numptr)
   end if
End Constructor

Constructor bigint ( Byref rhs As String )
   dim as long numbase=10
    dim as big_int_str ptr s

    s = big_int_str_create( len(rhs) )
    if( s = NULL ) then
        print "error when creating string"
    else
      s->len=len(rhs)
      *s->str=rhs
      this.numptr=big_int_create(1)
      if( this.numptr = NULL ) then
         print "error when creating big_int"
      else
         big_int_from_str( s , numbase, this.numptr)
      end if
   end if
   if( s <> NULL ) then big_int_str_destroy( s )
End Constructor

Constructor bigint ( Byref rhs As bigint )
   this.numptr=big_int_create(1)
    if( this.numptr = NULL ) then
        print "error when creating big_int"
    end if
    big_int_copy(rhs.numptr, this.numptr)
End Constructor

Destructor bigint ( )
   big_int_destroy(this.numptr)
End Destructor

Operator bigint.let ( Byref rhs As bigint )
    if (big_int_copy(rhs.numptr, this.numptr)<>0) then
      print "error when copying big_int"
   end if
End Operator

Operator bigint.let ( Byref rhs As String )
   dim as long numbase=10
    dim as big_int_str ptr s

    s = big_int_str_create( len(rhs) )
    if( s = NULL ) then
        print "error when creating string"
    else
      s->len=len(rhs)
      *s->str=rhs
      if (big_int_from_str( s , numbase, this.numptr)<>0) then
         print "error from big_int_from_str"
      end if
   end if
   if( s <> NULL ) then big_int_str_destroy( s )
End Operator

Operator bigint.Let ( Byval rhs As Long )
   if (big_int_from_int(rhs, this.numptr)<>0) then
      print "error from big_int_from_int"
   end if
End Operator



Operator bigint.cast ( ) As String
   dim as string retstr
    dim as big_int_str ptr s

    s = big_int_str_create( 1 )
    if( s = NULL ) then
        print "error when creating [s]"
        exit Operator
    end if
    
    if( big_int_to_str( this.numptr, 10, s ) <> 0 ) then
        print "error when converting number [num] to string [s]"
        exit Operator
    end if
    
    retstr=*s->str
    
    big_int_str_destroy( s )
    return retstr
End Operator

Operator bigint.cast ( ) As Long
   dim as Long ret
   big_int_to_int(this.numptr, @ret)
   return ret
End Operator

Operator bigint.cast ( ) As Double
   dim as string retstr
    dim as big_int_str ptr s

    s = big_int_str_create( 1 )
    if( s = NULL ) then
        print "error when creating [s]"
        exit Operator
    end if
    
    if( big_int_to_str( this.numptr, 10, s ) <> 0 ) then
        print "error when converting number [num] to string [s]"
        exit Operator
    end if
    
    retstr=*s->str
    
    big_int_str_destroy( s )
    return val(retstr)
End Operator

Operator bigint.cast ( ) As Single
   dim as string retstr
    dim as big_int_str ptr s

    s = big_int_str_create( 1 )
    if( s = NULL ) then
        print "error when creating [s]"
        exit Operator
    end if
    
    if( big_int_to_str( this.numptr, 10, s ) <> 0 ) then
        print "error when converting number [num] to string [s]"
        exit Operator
    end if
    
    retstr=*s->str
    
    big_int_str_destroy( s )
    return val(retstr)
End Operator


'============================================================================
'' For Next for bigint type
''
'' implicit step versions
'' 
'' In this example, we interpret implicit step
'' to mean 1
Operator bigint.for ( )
End Operator

Operator bigint.step ( )
   big_int_inc(this.numptr, this.numptr)
    'this = this+1 '
End Operator 
 
Operator bigint.next ( Byref end_cond As bigint ) As Integer
   dim as long flag
   big_int_cmp(this.numptr, end_cond.numptr, @flag)
    Return flag<=0 'this <= end_cond
End Operator
 
 
'' explicit step versions
'' 
Operator bigint.for ( Byref step_var As bigint )
End Operator
 
Operator bigint.step ( Byref step_var As bigint )
   big_int_add(this.numptr, step_var.numptr, this.numptr)
    'this = this + step_var '    
End Operator 

Operator bigint.next ( Byref end_cond As bigint, Byref step_var As bigint ) As Integer
   dim as long flag
   dim as sign_type flag2
   
   big_int_sign(step_var.numptr, @flag2)

    If flag2=MINUS Then
      big_int_cmp(this.numptr, end_cond.numptr, @flag)
      return flag>=0
      'Return this >= end_cond
    Else
      big_int_cmp(this.numptr, end_cond.numptr, @flag)
      return flag<=0
      'Return this <= end_cond
    End If
End Operator

'============================================================================

Operator + ( Byref lhs As bigint, Byref rhs As bigint ) As bigint
   Dim As bigint result
   big_int_add(lhs.numptr, rhs.numptr, result.numptr)
   return result
End Operator

Operator + ( Byref lhs As bigint, Byval rhs As long ) As bigint
   Dim As bigint result
   big_int_from_int(rhs, result.numptr)
   big_int_add(lhs.numptr, result.numptr, result.numptr)
   return result
End Operator

Operator + ( Byval lhs As long, Byref rhs As bigint ) As bigint
   Dim As bigint result
   big_int_from_int(lhs, result.numptr)
   big_int_add(rhs.numptr, result.numptr, result.numptr)
   return result
End Operator

'sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss
Operator + ( Byref lhs As bigint, Byval rhs As string ) As bigint
   Dim As bigint result=rhs
   big_int_add(lhs.numptr, result.numptr, result.numptr)
   return result
End Operator

Operator + ( Byref lhs As string , Byval rhs As bigint) As bigint
   Dim As bigint result=lhs
   big_int_add(result.numptr, rhs.numptr, result.numptr)
   return result
End Operator
'---------------------------------------------------------------------------

Operator - ( Byref lhs As bigint, Byref rhs As bigint ) As bigint
   Dim As bigint result
   big_int_sub(lhs.numptr, rhs.numptr, result.numptr)
   return result
End Operator

Operator - ( Byref lhs As bigint, Byval rhs As long ) As bigint
   Dim As bigint result
   big_int_from_int(rhs, result.numptr)
   big_int_sub(lhs.numptr, result.numptr, result.numptr)
   return result
End Operator

Operator - ( Byval lhs As long, Byref rhs As bigint ) As bigint
   Dim As bigint result
   big_int_from_int(lhs, result.numptr)
   big_int_sub( result.numptr, rhs.numptr, result.numptr)
   return result
End Operator

'sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss
Operator - ( Byref lhs As bigint, Byval rhs As string ) As bigint
   Dim As bigint result=rhs
   big_int_sub(lhs.numptr, result.numptr, result.numptr)
   return result
End Operator

Operator - ( Byref lhs As string , Byval rhs As bigint) As bigint
   Dim As bigint result=lhs
   big_int_sub(result.numptr, rhs.numptr, result.numptr)
   return result
End Operator
'---------------------------------------------------------------------------
Operator * ( Byref lhs As bigint, Byref rhs As bigint ) As bigint
   Dim As bigint result
   big_int_mul(lhs.numptr, rhs.numptr, result.numptr)
   return result
End Operator

Operator * ( Byref lhs As bigint, Byval rhs As long ) As bigint
   Dim As bigint result
   big_int_from_int(rhs, result.numptr)
   big_int_mul(lhs.numptr, result.numptr, result.numptr)
   return result
End Operator

Operator * ( Byval lhs As long, Byref rhs As bigint ) As bigint
   Dim As bigint result
   big_int_from_int(lhs, result.numptr)
   big_int_mul( result.numptr, rhs.numptr, result.numptr)
   return result
End Operator

'sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss
Operator * ( Byref lhs As bigint, Byval rhs As string ) As bigint
   Dim As bigint result=rhs
   big_int_mul(lhs.numptr, result.numptr, result.numptr)
   return result
End Operator

Operator * ( Byref lhs As string , Byval rhs As bigint) As bigint
   Dim As bigint result=lhs
   big_int_mul(result.numptr, rhs.numptr, result.numptr)
   return result
End Operator
'---------------------------------------------------------------------------

Operator / ( Byref lhs As bigint, Byref rhs As bigint ) As bigint
   Dim As bigint result
   big_int_div(lhs.numptr, rhs.numptr, result.numptr)
   return result
End Operator

Operator / ( Byref lhs As bigint, Byval rhs As long ) As bigint
   Dim As bigint result
   big_int_from_int(rhs, result.numptr)
   big_int_div(lhs.numptr, result.numptr, result.numptr)
   return result
End Operator

Operator / ( Byval lhs As long, Byref rhs As bigint ) As bigint
   Dim As bigint result
   big_int_from_int(lhs, result.numptr)
   big_int_div( result.numptr, rhs.numptr, result.numptr)
   return result
End Operator

'sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss
Operator / ( Byref lhs As bigint, Byval rhs As string ) As bigint
   Dim As bigint result=rhs
   big_int_div(lhs.numptr, result.numptr, result.numptr)
   return result
End Operator

Operator / ( Byref lhs As string , Byval rhs As bigint) As bigint
   Dim As bigint result=lhs
   big_int_div(result.numptr, rhs.numptr, result.numptr)
   return result
End Operator
'---------------------------------------------------------------------------

Operator ^ ( Byref lhs As bigint, Byval rhs As long ) As bigint
   Dim As bigint result
   big_int_pow(lhs.numptr, rhs, result.numptr)
   Return result
End Operator

Operator bigint.+= (byref rhs As bigint)
   big_int_add(this.numptr, rhs.numptr, this.numptr)
End Operator

Operator bigint.+= (Byval rhs as long)
   Dim As bigint result
   big_int_from_int(rhs, result.numptr)
   big_int_add(this.numptr, result.numptr, this.numptr)
End Operator

Operator bigint.+= (byref rhs as String)
   Dim As bigint tmp
   tmp=rhs
   big_int_add(this.numptr, tmp.numptr, this.numptr)
End Operator

Operator bigint.-= (byref rhs As bigint)
   big_int_sub(this.numptr, rhs.numptr, this.numptr)
End Operator

Operator bigint.-= (Byval rhs as long)
   Dim As bigint result
   big_int_from_int(rhs, result.numptr)
   big_int_sub(this.numptr, result.numptr, this.numptr)
End Operator

Operator bigint.-= (byref rhs as String)
   Dim As bigint tmp
   tmp=rhs
   big_int_sub(this.numptr, tmp.numptr, this.numptr)
End Operator

Operator bigint.*= (byref rhs As bigint)
   big_int_mul(this.numptr, rhs.numptr, this.numptr)
End Operator

Operator bigint.*= (Byval rhs as long)
   Dim As bigint result
   big_int_from_int(rhs, result.numptr)
   big_int_mul(this.numptr, result.numptr, this.numptr)
End Operator

Operator bigint.*= (byref rhs as String)
   Dim As bigint tmp
   tmp=rhs
   big_int_mul(this.numptr, tmp.numptr, this.numptr)
End Operator

Operator bigint./= (byref rhs As bigint)
   big_int_div(this.numptr, rhs.numptr, this.numptr)
End Operator

Operator bigint./= (Byval rhs as long)
   Dim As bigint result
   big_int_from_int(rhs, result.numptr)
   big_int_div(this.numptr, result.numptr, this.numptr)
End Operator

Operator bigint./= (byref rhs as String)
   Dim As bigint tmp
   tmp=rhs
   big_int_div(this.numptr, tmp.numptr, this.numptr)
End Operator

Operator bigint.^= ( Byval rhs As long )
   big_int_pow(this.numptr, rhs, this.numptr)
End Operator

Operator = ( Byref lhs As bigint, Byref rhs As bigint ) As Integer
   dim as long flag
    big_int_cmp(lhs.numptr, rhs.numptr, @flag)
   Return (flag = 0)
End Operator

Operator < ( Byref lhs As bigint, Byref rhs As bigint ) As Integer
   dim as long flag
    big_int_cmp(lhs.numptr, rhs.numptr, @flag)
   Return (flag < 0)
End Operator

Operator > ( Byref lhs As bigint, Byref rhs As bigint ) As Integer
   dim as long flag
    big_int_cmp(lhs.numptr, rhs.numptr, @flag)
   Return (flag > 0)
End Operator

Operator <= ( Byref lhs As bigint, Byref rhs As bigint ) As Integer
   dim as long flag
    big_int_cmp(lhs.numptr, rhs.numptr, @flag)
   Return (flag <= 0)
End Operator

Operator >= ( Byref lhs As bigint, Byref rhs As bigint ) As Integer
   dim as long flag
    big_int_cmp(lhs.numptr, rhs.numptr, @flag)
   Return (flag >= 0)
End Operator

Operator <> ( Byref lhs As bigint, Byref rhs As bigint ) As Integer
   dim as long flag
    big_int_cmp(lhs.numptr, rhs.numptr, @flag)
   Return (flag <> 0)
End Operator

function bigint_Abs(byref rhs As bigint) As bigint
   Dim As bigint result
   big_int_abs(rhs.numptr, result.numptr)
   return result
end function

function bigint_Sgn(byref rhs As bigint) As bigint
   dim as sign_type flag
   big_int_sign(rhs.numptr, @flag)
   Return flag=MINUS
end function

function bigint_fact(byval n as integer) As bigint
   Dim As bigint result
   big_int_fact(n, result.numptr)
   return result
end function

function bigint_miller_test(byref a As bigint, byref bas as bigint, byval is_prime as Long) As Integer
   return big_int_miller_test(a.numptr, bas.numptr, @is_prime)
   'return is_prime
end function

function bigint_next_prime(byref a As bigint) As bigint
   dim as bigint prime
   if (big_int_next_prime(a.numptr, prime.numptr)<>0) then
      print "error computing next prime"
      return 0
   else
      return prime
   end if
end function

function bigint_Sqr Overload (byref x As bigint) As bigint
   Dim As bigint result
   if (big_int_sqrt(x.numptr, result.numptr)<>0) then
      print "error computing sqrt"
      return 0
   else 
      return result
   end if
end function

function bigint_Sqr(byval x As ulong) As bigint
   Dim As bigint result
   if (big_int_from_int(x, result.numptr)<>0) then
      print "error converting from int"
      return 0
   elseif (big_int_sqrt(result.numptr, result.numptr)<>0) then
      print "error computing sqrt"
      return 0
   else
      return result
   end if
end function

function bigint_Sqr(byval x As string) As bigint
   Dim As bigint result=x
   if (big_int_sqrt(result.numptr, result.numptr)<>0) then
      print "error computing sqrt"
      return 0
   else
      return result
   end if
end function

function bigint_base_convert(byval src as string, byval base_from as long, byval base_to as long) as string
   dim as big_int_str ptr x, y
   dim as string ret
   x = big_int_str_create( len(src) )
   if( x = NULL ) then
      print "error when creating string"
      exit function
   else
      x->len=len(src)
      *x->str=src
   end if
   y = big_int_str_create( 1 )
   if( y = NULL ) then
      print "error when creating string"
      exit function   
   end if
   if (big_int_base_convert(x, y, base_from, base_to)<>0) then
      print "error, could not make conversion"
      exit function
   else
      ret= *y->str
   end if
   if( x <> NULL ) then big_int_str_destroy( x )
   if( y <> NULL ) then big_int_str_destroy( y )
   return ret
end function

function bigint_to_str(byref a as bigint, byval nbase as ulong) as string
   dim y as big_int_str ptr
   dim as string ret
   y = big_int_str_create( 1 )
   if( y = NULL ) then
      print "error when creating string"
      exit function
   end if
   if (big_int_to_str(a.numptr, nbase, y)<>0) then
      print "error, could not convert"
      exit function
   else
      ret=*y->str
   end if
   if( y <> NULL ) then big_int_str_destroy( y )
   return ret
end function

function bigint_from_str(byval s as string, byval nbase as ulong) as bigint
   dim as big_int_str ptr x
   dim as bigint ret
   x = big_int_str_create( len(s) )
   if( x = NULL ) then
      print "error when creating string"
   else
      x->len=len(s)
      *x->str=s
   end if
   if (big_int_from_str(x, nbase, ret.numptr)<>0) then
      print "error, could not convert"
   end if
   if( x <> NULL ) then big_int_str_destroy( x )
   return ret
end function