iPXE
Macros | Functions | Variables
bigint_test.c File Reference

Big integer self-tests. More...

#include <assert.h>
#include <string.h>
#include <ipxe/bigint.h>
#include <ipxe/test.h>

Go to the source code of this file.

Macros

#define BIGINT(...)   { __VA_ARGS__ }
 Define inline big integer. More...
 
#define bigint_add_ok(addend, value, expected)
 Report result of big integer addition test. More...
 
#define bigint_subtract_ok(subtrahend, value, expected)
 Report result of big integer subtraction test. More...
 
#define bigint_rol_ok(value, expected)
 Report result of big integer left rotation test. More...
 
#define bigint_ror_ok(value, expected)
 Report result of big integer right rotation test. More...
 
#define bigint_is_zero_ok(value, expected)
 Report result of big integer zero comparison test. More...
 
#define bigint_is_geq_ok(value, reference, expected)
 Report result of big integer greater-than-or-equal comparison test. More...
 
#define bigint_bit_is_set_ok(value, bit, expected)
 Report result of big integer bit-set test. More...
 
#define bigint_max_set_bit_ok(value, expected)
 Report result of big integer maximum set bit test. More...
 
#define bigint_multiply_ok(multiplicand, multiplier, expected)
 Report result of big integer multiplication test. More...
 
#define bigint_mod_multiply_ok(multiplicand, multiplier, modulus, expected)
 Report result of big integer modular multiplication test. More...
 
#define bigint_mod_exp_ok(base, modulus, exponent, expected)
 Report result of big integer modular exponentiation test. More...
 

Functions

 FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
 
void bigint_init_sample (bigint_element_t *value0, unsigned int size, const void *data, size_t len)
 
void bigint_done_sample (const bigint_element_t *value0, unsigned int size, void *out, size_t len)
 
void bigint_add_sample (const bigint_element_t *addend0, bigint_element_t *value0, unsigned int size)
 
void bigint_subtract_sample (const bigint_element_t *subtrahend0, bigint_element_t *value0, unsigned int size)
 
void bigint_rol_sample (bigint_element_t *value0, unsigned int size)
 
void bigint_ror_sample (bigint_element_t *value0, unsigned int size)
 
int bigint_is_zero_sample (const bigint_element_t *value0, unsigned int size)
 
int bigint_is_geq_sample (const bigint_element_t *value0, const bigint_element_t *reference0, unsigned int size)
 
int bigint_bit_is_set_sample (const bigint_element_t *value0, unsigned int size, unsigned int bit)
 
int bigint_max_set_bit_sample (const bigint_element_t *value0, unsigned int size)
 
void bigint_grow_sample (const bigint_element_t *source0, unsigned int source_size, bigint_element_t *dest0, unsigned int dest_size)
 
void bigint_shrink_sample (const bigint_element_t *source0, unsigned int source_size, bigint_element_t *dest0, unsigned int dest_size)
 
void bigint_multiply_sample (const bigint_element_t *multiplicand0, const bigint_element_t *multiplier0, bigint_element_t *result0, unsigned int size)
 
void bigint_mod_multiply_sample (const bigint_element_t *multiplicand0, const bigint_element_t *multiplier0, const bigint_element_t *modulus0, bigint_element_t *result0, unsigned int size, void *tmp)
 
void bigint_mod_exp_sample (const bigint_element_t *base0, const bigint_element_t *modulus0, const bigint_element_t *exponent0, bigint_element_t *result0, unsigned int size, unsigned int exponent_size, void *tmp)
 
static void bigint_test_exec (void)
 Perform big integer self-tests. More...
 

Variables

struct self_test bigint_test __self_test
 Big integer self-test. More...
 

Detailed Description

Big integer self-tests.

Definition in file bigint_test.c.

Macro Definition Documentation

◆ BIGINT

#define BIGINT (   ...)    { __VA_ARGS__ }

Define inline big integer.

Definition at line 41 of file bigint_test.c.

◆ bigint_add_ok

#define bigint_add_ok (   addend,
  value,
  expected 
)
Value:
do { \
static const uint8_t addend_raw[] = addend; \
static const uint8_t value_raw[] = value; \
static const uint8_t expected_raw[] = expected; \
uint8_t result_raw[ sizeof ( expected_raw ) ]; \
unsigned int size = \
bigint_required_size ( sizeof ( value_raw ) ); \
bigint_t ( size ) addend_temp; \
bigint_t ( size ) value_temp; \
{} /* Fix emacs alignment */ \
\
assert ( bigint_size ( &addend_temp ) == \
bigint_size ( &value_temp ) ); \
bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) ); \
bigint_init ( &addend_temp, addend_raw, \
sizeof ( addend_raw ) ); \
DBG ( "Add:\n" ); \
DBG_HDA ( 0, &addend_temp, sizeof ( addend_temp ) ); \
DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) ); \
bigint_add ( &addend_temp, &value_temp ); \
DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) ); \
bigint_done ( &value_temp, result_raw, sizeof ( result_raw ) ); \
\
ok ( memcmp ( result_raw, expected_raw, \
sizeof ( result_raw ) ) == 0 ); \
} while ( 0 )
assert
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
uint8_t
unsigned char uint8_t
Definition: stdint.h:10
bigint_size
#define bigint_size(bigint)
Determine number of elements in big-integer type.
Definition: bigint.h:38
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
ok
#define ok(success)
Definition: test.h:46
memcmp
int memcmp(const void *first, const void *second, size_t len)
Compare memory regions.
Definition: string.c:114

Report result of big integer addition test.

Parameters
addendBig integer to add
valueBig integer to be added to
expectedBig integer expected result

Definition at line 209 of file bigint_test.c.

◆ bigint_subtract_ok

#define bigint_subtract_ok (   subtrahend,
  value,
  expected 
)
Value:
do { \
static const uint8_t subtrahend_raw[] = subtrahend; \
static const uint8_t value_raw[] = value; \
static const uint8_t expected_raw[] = expected; \
uint8_t result_raw[ sizeof ( expected_raw ) ]; \
unsigned int size = \
bigint_required_size ( sizeof ( value_raw ) ); \
bigint_t ( size ) subtrahend_temp; \
bigint_t ( size ) value_temp; \
{} /* Fix emacs alignment */ \
\
assert ( bigint_size ( &subtrahend_temp ) == \
bigint_size ( &value_temp ) ); \
bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) ); \
bigint_init ( &subtrahend_temp, subtrahend_raw, \
sizeof ( subtrahend_raw ) ); \
DBG ( "Subtract:\n" ); \
DBG_HDA ( 0, &subtrahend_temp, sizeof ( subtrahend_temp ) ); \
DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) ); \
bigint_subtract ( &subtrahend_temp, &value_temp ); \
DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) ); \
bigint_done ( &value_temp, result_raw, sizeof ( result_raw ) ); \
\
ok ( memcmp ( result_raw, expected_raw, \
sizeof ( result_raw ) ) == 0 ); \
} while ( 0 )
subtrahend
static __always_inline off_t userptr_t subtrahend
Definition: efi_uaccess.h:61
assert
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
uint8_t
unsigned char uint8_t
Definition: stdint.h:10
bigint_size
#define bigint_size(bigint)
Determine number of elements in big-integer type.
Definition: bigint.h:38
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
ok
#define ok(success)
Definition: test.h:46
memcmp
int memcmp(const void *first, const void *second, size_t len)
Compare memory regions.
Definition: string.c:114

Report result of big integer subtraction test.

Parameters
subtrahendBig integer to subtract
valueBig integer to be subtracted from
expectedBig integer expected result

Definition at line 243 of file bigint_test.c.

◆ bigint_rol_ok

#define bigint_rol_ok (   value,
  expected 
)
Value:
do { \
static const uint8_t value_raw[] = value; \
static const uint8_t expected_raw[] = expected; \
uint8_t result_raw[ sizeof ( expected_raw ) ]; \
unsigned int size = \
bigint_required_size ( sizeof ( value_raw ) ); \
bigint_t ( size ) value_temp; \
{} /* Fix emacs alignment */ \
\
bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) ); \
DBG ( "Rotate left:\n" ); \
DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) ); \
bigint_rol ( &value_temp ); \
DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) ); \
bigint_done ( &value_temp, result_raw, sizeof ( result_raw ) ); \
\
ok ( memcmp ( result_raw, expected_raw, \
sizeof ( result_raw ) ) == 0 ); \
} while ( 0 )
bigint_init
#define bigint_init(value, data, len)
Initialise big integer.
Definition: bigint.h:48
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
uint8_t
unsigned char uint8_t
Definition: stdint.h:10
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
ok
#define ok(success)
Definition: test.h:46
memcmp
int memcmp(const void *first, const void *second, size_t len)
Compare memory regions.
Definition: string.c:114

Report result of big integer left rotation test.

Parameters
valueBig integer
expectedBig integer expected result

Definition at line 276 of file bigint_test.c.

◆ bigint_ror_ok

#define bigint_ror_ok (   value,
  expected 
)
Value:
do { \
static const uint8_t value_raw[] = value; \
static const uint8_t expected_raw[] = expected; \
uint8_t result_raw[ sizeof ( expected_raw ) ]; \
unsigned int size = \
bigint_required_size ( sizeof ( value_raw ) ); \
bigint_t ( size ) value_temp; \
{} /* Fix emacs alignment */ \
\
bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) ); \
DBG ( "Rotate right:\n" ); \
DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) ); \
bigint_ror ( &value_temp ); \
DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) ); \
bigint_done ( &value_temp, result_raw, sizeof ( result_raw ) ); \
\
ok ( memcmp ( result_raw, expected_raw, \
sizeof ( result_raw ) ) == 0 ); \
} while ( 0 )
bigint_init
#define bigint_init(value, data, len)
Initialise big integer.
Definition: bigint.h:48
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
uint8_t
unsigned char uint8_t
Definition: stdint.h:10
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
ok
#define ok(success)
Definition: test.h:46
memcmp
int memcmp(const void *first, const void *second, size_t len)
Compare memory regions.
Definition: string.c:114

Report result of big integer right rotation test.

Parameters
valueBig integer
expectedBig integer expected result

Definition at line 302 of file bigint_test.c.

◆ bigint_is_zero_ok

#define bigint_is_zero_ok (   value,
  expected 
)
Value:
do { \
static const uint8_t value_raw[] = value; \
unsigned int size = \
bigint_required_size ( sizeof ( value_raw ) ); \
bigint_t ( size ) value_temp; \
int is_zero; \
{} /* Fix emacs alignment */ \
\
bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) ); \
DBG ( "Zero comparison:\n" ); \
DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) ); \
is_zero = bigint_is_zero ( &value_temp ); \
DBG ( "...is %szero\n", ( is_zero ? "" : "not " ) ); \
ok ( ( !! is_zero ) == ( !! (expected) ) ); \
} while ( 0 )
bigint_init
#define bigint_init(value, data, len)
Initialise big integer.
Definition: bigint.h:48
bigint_is_zero
#define bigint_is_zero(value)
Test if big integer is equal to zero.
Definition: bigint.h:116
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
uint8_t
unsigned char uint8_t
Definition: stdint.h:10
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16

Report result of big integer zero comparison test.

Parameters
valueBig integer
expectedExpected result

Definition at line 328 of file bigint_test.c.

◆ bigint_is_geq_ok

#define bigint_is_geq_ok (   value,
  reference,
  expected 
)
Value:
do { \
static const uint8_t value_raw[] = value; \
static const uint8_t reference_raw[] = reference; \
unsigned int size = \
bigint_required_size ( sizeof ( value_raw ) ); \
bigint_t ( size ) value_temp; \
bigint_t ( size ) reference_temp; \
int is_geq; \
{} /* Fix emacs alignment */ \
\
assert ( bigint_size ( &reference_temp ) == \
bigint_size ( &value_temp ) ); \
bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) ); \
bigint_init ( &reference_temp, reference_raw, \
sizeof ( reference_raw ) ); \
DBG ( "Greater-than-or-equal comparison:\n" ); \
DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) ); \
DBG_HDA ( 0, &reference_temp, sizeof ( reference_temp ) ); \
is_geq = bigint_is_geq ( &value_temp, &reference_temp ); \
DBG ( "...is %sgreater than or equal\n", \
( is_geq ? "" : "not " ) ); \
ok ( ( !! is_geq ) == ( !! (expected) ) ); \
} while ( 0 )
bigint_is_geq
#define bigint_is_geq(value, reference)
Compare big integers.
Definition: bigint.h:127
assert
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
uint8_t
unsigned char uint8_t
Definition: stdint.h:10
bigint_size
#define bigint_size(bigint)
Determine number of elements in big-integer type.
Definition: bigint.h:38
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16

Report result of big integer greater-than-or-equal comparison test.

Parameters
valueBig integer
referenceReference big integer
expectedExpected result

Definition at line 351 of file bigint_test.c.

◆ bigint_bit_is_set_ok

#define bigint_bit_is_set_ok (   value,
  bit,
  expected 
)
Value:
do { \
static const uint8_t value_raw[] = value; \
unsigned int size = \
bigint_required_size ( sizeof ( value_raw ) ); \
bigint_t ( size ) value_temp; \
int bit_is_set; \
{} /* Fix emacs alignment */ \
\
bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) ); \
DBG ( "Bit set:\n" ); \
DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) ); \
bit_is_set = bigint_bit_is_set ( &value_temp, bit ); \
DBG ( "...bit %d is %sset\n", bit, \
( bit_is_set ? "" : "not " ) ); \
ok ( ( !! bit_is_set ) == ( !! (expected) ) ); \
} while ( 0 )
bit
static unsigned int unsigned int bit
Definition: bigint.h:208
bigint_init
#define bigint_init(value, data, len)
Initialise big integer.
Definition: bigint.h:48
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
uint8_t
unsigned char uint8_t
Definition: stdint.h:10
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
bigint_bit_is_set
#define bigint_bit_is_set(value, bit)
Test if bit is set in big integer.
Definition: bigint.h:139

Report result of big integer bit-set test.

Parameters
valueBig integer
bitBit to test
expectedExpected result

Definition at line 382 of file bigint_test.c.

◆ bigint_max_set_bit_ok

#define bigint_max_set_bit_ok (   value,
  expected 
)
Value:
do { \
static const uint8_t value_raw[] = value; \
unsigned int size = \
bigint_required_size ( sizeof ( value_raw ) ); \
bigint_t ( size ) value_temp; \
int max_set_bit; \
{} /* Fix emacs alignment */ \
\
bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) ); \
DBG ( "Maximum set bit:\n" ); \
DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) ); \
max_set_bit = bigint_max_set_bit ( &value_temp ); \
DBG ( "...maximum set bit is bit %d\n", ( max_set_bit - 1 ) ); \
ok ( max_set_bit == (expected) ); \
} while ( 0 )
bigint_max_set_bit
#define bigint_max_set_bit(value)
Find highest bit set in big integer.
Definition: bigint.h:149
bigint_init
#define bigint_init(value, data, len)
Initialise big integer.
Definition: bigint.h:48
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
uint8_t
unsigned char uint8_t
Definition: stdint.h:10
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16

Report result of big integer maximum set bit test.

Parameters
valueBig integer
expectedExpected result

Definition at line 405 of file bigint_test.c.

◆ bigint_multiply_ok

#define bigint_multiply_ok (   multiplicand,
  multiplier,
  expected 
)

Report result of big integer multiplication test.

Parameters
multiplicandBig integer to be multiplied
multiplierBig integer to be multiplied
expectedBig integer expected result

Definition at line 428 of file bigint_test.c.

◆ bigint_mod_multiply_ok

#define bigint_mod_multiply_ok (   multiplicand,
  multiplier,
  modulus,
  expected 
)

Report result of big integer modular multiplication test.

Parameters
multiplicandBig integer to be multiplied
multiplierBig integer to be multiplied
modulusBig integer modulus
expectedBig integer expected result

Definition at line 468 of file bigint_test.c.

◆ bigint_mod_exp_ok

#define bigint_mod_exp_ok (   base,
  modulus,
  exponent,
  expected 
)

Report result of big integer modular exponentiation test.

Parameters
baseBig integer base
modulusBig integer modulus
exponentBig integer exponent
expectedBig integer expected result

Definition at line 518 of file bigint_test.c.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL  )

◆ bigint_init_sample()

void bigint_init_sample ( bigint_element_t *  value0,
unsigned int  size,
const void *  data,
size_t  len 
)

Definition at line 45 of file bigint_test.c.

46  {
47  bigint_t ( size ) *value __attribute__ (( may_alias ))
48  = ( ( void * ) value0 );
49 
50  bigint_init ( value, data, len );
51 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
bigint_init
#define bigint_init(value, data, len)
Initialise big integer.
Definition: bigint.h:48
value0
static uint32_t * value0
Definition: bigint.h:57
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
len
uint32_t len
Length.
Definition: ena.h:14
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
data
uint8_t data[48]
Additional event data.
Definition: ena.h:22

References __attribute__, bigint_init, bigint_t, data, len, size, value, and value0.

◆ bigint_done_sample()

void bigint_done_sample ( const bigint_element_t *  value0,
unsigned int  size,
void *  out,
size_t  len 
)

Definition at line 53 of file bigint_test.c.

54  {
55  const bigint_t ( size ) *value __attribute__ (( may_alias ))
56  = ( ( const void * ) value0 );
57 
58  bigint_done ( value, out, len );
59 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
value0
static uint32_t * value0
Definition: bigint.h:57
out
__be32 out[4]
Definition: CIB_PRM.h:36
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
bigint_done
#define bigint_done(value, out, len)
Finalise big integer.
Definition: bigint.h:61
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
len
uint32_t len
Length.
Definition: ena.h:14
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16

References __attribute__, bigint_done, bigint_t, len, out, size, value, and value0.

◆ bigint_add_sample()

void bigint_add_sample ( const bigint_element_t *  addend0,
bigint_element_t *  value0,
unsigned int  size 
)

Definition at line 61 of file bigint_test.c.

62  {
63  const bigint_t ( size ) *addend __attribute__ (( may_alias ))
64  = ( ( const void * ) addend0 );
65  bigint_t ( size ) *value __attribute__ (( may_alias ))
66  = ( ( void * ) value0 );
67 
68  bigint_add ( addend, value );
69 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
value0
static uint32_t * value0
Definition: bigint.h:57
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
bigint_add
#define bigint_add(addend, value)
Add big integers.
Definition: bigint.h:72

References __attribute__, bigint_add, bigint_t, size, value, and value0.

◆ bigint_subtract_sample()

void bigint_subtract_sample ( const bigint_element_t *  subtrahend0,
bigint_element_t *  value0,
unsigned int  size 
)

Definition at line 71 of file bigint_test.c.

72  {
73  const bigint_t ( size ) *subtrahend __attribute__ (( may_alias ))
74  = ( ( const void * ) subtrahend0 );
75  bigint_t ( size ) *value __attribute__ (( may_alias ))
76  = ( ( void * ) value0 );
77 
78  bigint_subtract ( subtrahend, value );
79 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
value0
static uint32_t * value0
Definition: bigint.h:57
subtrahend
static __always_inline off_t userptr_t subtrahend
Definition: efi_uaccess.h:61
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
bigint_subtract
#define bigint_subtract(subtrahend, value)
Subtract big integers.
Definition: bigint.h:83

References __attribute__, bigint_subtract, bigint_t, size, subtrahend, value, and value0.

◆ bigint_rol_sample()

void bigint_rol_sample ( bigint_element_t *  value0,
unsigned int  size 
)

Definition at line 81 of file bigint_test.c.

81  {
82  bigint_t ( size ) *value __attribute__ (( may_alias ))
83  = ( ( void * ) value0 );
84 
85  bigint_rol ( value );
86 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
value0
static uint32_t * value0
Definition: bigint.h:57
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
bigint_rol
#define bigint_rol(value)
Rotate big integer left.
Definition: bigint.h:94
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16

References __attribute__, bigint_rol, bigint_t, size, value, and value0.

◆ bigint_ror_sample()

void bigint_ror_sample ( bigint_element_t *  value0,
unsigned int  size 
)

Definition at line 88 of file bigint_test.c.

88  {
89  bigint_t ( size ) *value __attribute__ (( may_alias ))
90  = ( ( void * ) value0 );
91 
92  bigint_ror ( value );
93 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
bigint_ror
#define bigint_ror(value)
Rotate big integer right.
Definition: bigint.h:104
value0
static uint32_t * value0
Definition: bigint.h:57
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16

References __attribute__, bigint_ror, bigint_t, size, value, and value0.

◆ bigint_is_zero_sample()

int bigint_is_zero_sample ( const bigint_element_t *  value0,
unsigned int  size 
)

Definition at line 95 of file bigint_test.c.

96  {
97  const bigint_t ( size ) *value __attribute__ (( may_alias ))
98  = ( ( const void * ) value0 );
99 
100  return bigint_is_zero ( value );
101 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
bigint_is_zero
#define bigint_is_zero(value)
Test if big integer is equal to zero.
Definition: bigint.h:116
value0
static uint32_t * value0
Definition: bigint.h:57
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16

References __attribute__, bigint_is_zero, bigint_t, size, value, and value0.

◆ bigint_is_geq_sample()

int bigint_is_geq_sample ( const bigint_element_t *  value0,
const bigint_element_t *  reference0,
unsigned int  size 
)

Definition at line 103 of file bigint_test.c.

105  {
106  const bigint_t ( size ) *value __attribute__ (( may_alias ))
107  = ( ( const void * ) value0 );
108  const bigint_t ( size ) *reference __attribute__ (( may_alias ))
109  = ( ( const void * ) reference0 );
110 
111  return bigint_is_geq ( value, reference );
112 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
reference0
static const uint32_t * reference0
Definition: bigint.h:180
value0
static uint32_t * value0
Definition: bigint.h:57
bigint_is_geq
#define bigint_is_geq(value, reference)
Compare big integers.
Definition: bigint.h:127
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16

References __attribute__, bigint_is_geq, bigint_t, reference0, size, value, and value0.

◆ bigint_bit_is_set_sample()

int bigint_bit_is_set_sample ( const bigint_element_t *  value0,
unsigned int  size,
unsigned int  bit 
)

Definition at line 114 of file bigint_test.c.

115  {
116  const bigint_t ( size ) *value __attribute__ (( may_alias ))
117  = ( ( const void * ) value0 );
118 
119  return bigint_bit_is_set ( value, bit );
120 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
bit
static unsigned int unsigned int bit
Definition: bigint.h:208
value0
static uint32_t * value0
Definition: bigint.h:57
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
bigint_bit_is_set
#define bigint_bit_is_set(value, bit)
Test if bit is set in big integer.
Definition: bigint.h:139

References __attribute__, bigint_bit_is_set, bigint_t, bit, size, value, and value0.

◆ bigint_max_set_bit_sample()

int bigint_max_set_bit_sample ( const bigint_element_t *  value0,
unsigned int  size 
)

Definition at line 122 of file bigint_test.c.

123  {
124  const bigint_t ( size ) *value __attribute__ (( may_alias ))
125  = ( ( const void * ) value0 );
126 
127  return bigint_max_set_bit ( value );
128 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
bigint_max_set_bit
#define bigint_max_set_bit(value)
Find highest bit set in big integer.
Definition: bigint.h:149
value0
static uint32_t * value0
Definition: bigint.h:57
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16

References __attribute__, bigint_max_set_bit, bigint_t, size, value, and value0.

◆ bigint_grow_sample()

void bigint_grow_sample ( const bigint_element_t *  source0,
unsigned int  source_size,
bigint_element_t *  dest0,
unsigned int  dest_size 
)

Definition at line 130 of file bigint_test.c.

132  {
133  const bigint_t ( source_size ) *source __attribute__ (( may_alias ))
134  = ( ( const void * ) source0 );
135  bigint_t ( dest_size ) *dest __attribute__ (( may_alias ))
136  = ( ( void * ) dest0 );
137 
138  bigint_grow ( source, dest );
139 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
bigint_grow
#define bigint_grow(source, dest)
Grow big integer.
Definition: bigint.h:159
dest_size
static unsigned int uint32_t unsigned int dest_size
Definition: bigint.h:253
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
dest
static void * dest
Definition: strings.h:176
source_size
static unsigned int source_size
Definition: bigint.h:252
dest0
static unsigned int uint32_t * dest0
Definition: bigint.h:252

References __attribute__, bigint_grow, bigint_t, dest, dest0, dest_size, and source_size.

◆ bigint_shrink_sample()

void bigint_shrink_sample ( const bigint_element_t *  source0,
unsigned int  source_size,
bigint_element_t *  dest0,
unsigned int  dest_size 
)

Definition at line 141 of file bigint_test.c.

143  {
144  const bigint_t ( source_size ) *source __attribute__ (( may_alias ))
145  = ( ( const void * ) source0 );
146  bigint_t ( dest_size ) *dest __attribute__ (( may_alias ))
147  = ( ( void * ) dest0 );
148 
149  bigint_shrink ( source, dest );
150 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
bigint_shrink
#define bigint_shrink(source, dest)
Shrink big integer.
Definition: bigint.h:172
dest_size
static unsigned int uint32_t unsigned int dest_size
Definition: bigint.h:253
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
dest
static void * dest
Definition: strings.h:176
source_size
static unsigned int source_size
Definition: bigint.h:252
dest0
static unsigned int uint32_t * dest0
Definition: bigint.h:252

References __attribute__, bigint_shrink, bigint_t, dest, dest0, dest_size, and source_size.

◆ bigint_multiply_sample()

void bigint_multiply_sample ( const bigint_element_t *  multiplicand0,
const bigint_element_t *  multiplier0,
bigint_element_t *  result0,
unsigned int  size 
)

Definition at line 152 of file bigint_test.c.

155  {
156  const bigint_t ( size ) *multiplicand __attribute__ (( may_alias ))
157  = ( ( const void * ) multiplicand0 );
158  const bigint_t ( size ) *multiplier __attribute__ (( may_alias ))
159  = ( ( const void * ) multiplier0 );
160  bigint_t ( size * 2 ) *result __attribute__ (( may_alias ))
161  = ( ( void * ) result0 );
162 
163  bigint_multiply ( multiplicand, multiplier, result );
164 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
multiplier
uint8_t multiplier
Port multiplier number.
Definition: edd.h:32
result
int result
Definition: bigint.h:160
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
bigint_multiply
#define bigint_multiply(multiplicand, multiplier, result)
Multiply big integers.
Definition: bigint.h:186
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16

References __attribute__, bigint_multiply, bigint_t, multiplier, result, and size.

◆ bigint_mod_multiply_sample()

void bigint_mod_multiply_sample ( const bigint_element_t *  multiplicand0,
const bigint_element_t *  multiplier0,
const bigint_element_t *  modulus0,
bigint_element_t *  result0,
unsigned int  size,
void *  tmp 
)

Definition at line 166 of file bigint_test.c.

171  {
172  const bigint_t ( size ) *multiplicand __attribute__ (( may_alias ))
173  = ( ( const void * ) multiplicand0 );
174  const bigint_t ( size ) *multiplier __attribute__ (( may_alias ))
175  = ( ( const void * ) multiplier0 );
176  const bigint_t ( size ) *modulus __attribute__ (( may_alias ))
177  = ( ( const void * ) modulus0 );
178  bigint_t ( size ) *result __attribute__ (( may_alias ))
179  = ( ( void * ) result0 );
180 
181  bigint_mod_multiply ( multiplicand, multiplier, modulus, result, tmp );
182 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
multiplier
uint8_t multiplier
Port multiplier number.
Definition: edd.h:32
tmp
unsigned long tmp
Definition: linux_pci.h:53
result
int result
Definition: bigint.h:160
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
bigint_mod_multiply
#define bigint_mod_multiply(multiplicand, multiplier, modulus, result, tmp)
Perform modular multiplication of big integers.
Definition: bigint.h:202
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16

References __attribute__, bigint_mod_multiply, bigint_t, multiplier, result, size, and tmp.

◆ bigint_mod_exp_sample()

void bigint_mod_exp_sample ( const bigint_element_t *  base0,
const bigint_element_t *  modulus0,
const bigint_element_t *  exponent0,
bigint_element_t *  result0,
unsigned int  size,
unsigned int  exponent_size,
void *  tmp 
)

Definition at line 184 of file bigint_test.c.

189  {
190  const bigint_t ( size ) *base __attribute__ (( may_alias ))
191  = ( ( const void * ) base0 );
192  const bigint_t ( size ) *modulus __attribute__ (( may_alias ))
193  = ( ( const void * ) modulus0 );
194  const bigint_t ( exponent_size ) *exponent __attribute__ (( may_alias ))
195  = ( ( const void * ) exponent0 );
196  bigint_t ( size ) *result __attribute__ (( may_alias ))
197  = ( ( void * ) result0 );
198 
199  bigint_mod_exp ( base, modulus, exponent, result, tmp );
200 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
bigint_mod_exp
#define bigint_mod_exp(base, modulus, exponent, result, tmp)
Perform modular exponentiation of big integers.
Definition: bigint.h:233
tmp
unsigned long tmp
Definition: linux_pci.h:53
result
int result
Definition: bigint.h:160
bigint_t
#define bigint_t(size)
Define a big-integer type.
Definition: bigint.h:17
base
uint16_t base
Base address.
Definition: edd.h:14
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16

References __attribute__, base, bigint_mod_exp, bigint_t, result, size, and tmp.

◆ bigint_test_exec()

static void bigint_test_exec ( void  )
static

Perform big integer self-tests.

Definition at line 563 of file bigint_test.c.

563  {
564 
565  bigint_add_ok ( BIGINT ( 0x8a ),
566  BIGINT ( 0x43 ),
567  BIGINT ( 0xcd ) );
568  bigint_add_ok ( BIGINT ( 0xc5, 0x7b ),
569  BIGINT ( 0xd6, 0xb1 ),
570  BIGINT ( 0x9c, 0x2c ) );
571  bigint_add_ok ( BIGINT ( 0xf9, 0xd9, 0xdc ),
572  BIGINT ( 0x6d, 0x4b, 0xca ),
573  BIGINT ( 0x67, 0x25, 0xa6 ) );
574  bigint_add_ok ( BIGINT ( 0xdd, 0xc2, 0x20, 0x5f ),
575  BIGINT ( 0x80, 0x32, 0xc4, 0xb0 ),
576  BIGINT ( 0x5d, 0xf4, 0xe5, 0x0f ) );
577  bigint_add_ok ( BIGINT ( 0x01, 0xed, 0x45, 0x4b, 0x41, 0xeb, 0x4c,
578  0x2e, 0x53, 0x07, 0x15, 0x51, 0x56, 0x47,
579  0x29, 0xfc, 0x9c, 0xbd, 0xbd, 0xfb, 0x1b,
580  0xd1, 0x1d ),
581  BIGINT ( 0x73, 0xed, 0xfc, 0x35, 0x31, 0x22, 0xd7,
582  0xb1, 0xea, 0x91, 0x5a, 0xe4, 0xba, 0xbc,
583  0xa1, 0x38, 0x72, 0xae, 0x4b, 0x1c, 0xc1,
584  0x05, 0xb3 ),
585  BIGINT ( 0x75, 0xdb, 0x41, 0x80, 0x73, 0x0e, 0x23,
586  0xe0, 0x3d, 0x98, 0x70, 0x36, 0x11, 0x03,
587  0xcb, 0x35, 0x0f, 0x6c, 0x09, 0x17, 0xdc,
588  0xd6, 0xd0 ) );
589  bigint_add_ok ( BIGINT ( 0x06, 0x8e, 0xd6, 0x18, 0xbb, 0x4b, 0x0c,
590  0xc5, 0x85, 0xde, 0xee, 0x9b, 0x3f, 0x65,
591  0x63, 0x86, 0xf5, 0x5a, 0x9f, 0xa2, 0xd7,
592  0xb2, 0xc7, 0xb6, 0x1d, 0x28, 0x6c, 0x50,
593  0x47, 0x10, 0x0a, 0x0e, 0x86, 0xcd, 0x2a,
594  0x64, 0xdc, 0xe6, 0x9d, 0x96, 0xd8, 0xf4,
595  0x56, 0x46, 0x6f, 0xbb, 0x7b, 0x64, 0x6f,
596  0xdc, 0x2a, 0xd1, 0x3b, 0xcc, 0x03, 0x85,
597  0x95, 0xf4, 0xe9, 0x68, 0x1f, 0x5c, 0xc5,
598  0xbf, 0x97, 0x19, 0x12, 0x88, 0x2e, 0x88,
599  0xb9, 0x34, 0xac, 0x74, 0x83, 0x2d, 0x8f,
600  0xb3, 0x97, 0x53, 0x99, 0xf3, 0xb4, 0x8b,
601  0x2d, 0x98, 0x69, 0x8d, 0x19, 0xf0, 0x40,
602  0x66, 0x3f, 0x60, 0x78, 0x34, 0x7f, 0x9b,
603  0xf7, 0x01, 0x74, 0x55, 0xca, 0x63, 0x25,
604  0x7b, 0x86, 0xe9, 0x73, 0xfd, 0x5d, 0x77,
605  0x32, 0x5e, 0x9e, 0x42, 0x53, 0xb6, 0x35,
606  0x92, 0xb9, 0xd7, 0x1b, 0xf7, 0x16, 0x55,
607  0xf6, 0xe2 ),
608  BIGINT ( 0x3f, 0x8f, 0x62, 0x21, 0x4a, 0x7a, 0xa2,
609  0xef, 0xa8, 0x79, 0x9b, 0x73, 0xac, 0xde,
610  0x72, 0xe4, 0xfc, 0x3c, 0xd3, 0xa9, 0x44,
611  0x1a, 0x6a, 0x02, 0x76, 0xe3, 0x78, 0x4d,
612  0x2e, 0x07, 0x9b, 0xb6, 0x3d, 0x5d, 0xc5,
613  0xcd, 0x68, 0x23, 0x4b, 0x5f, 0x89, 0x0e,
614  0xd7, 0xa7, 0xff, 0x18, 0x80, 0xdc, 0xfb,
615  0x34, 0x45, 0xca, 0x4b, 0xdb, 0x8a, 0x19,
616  0xcb, 0xc9, 0xe5, 0xa1, 0x63, 0xa2, 0x0d,
617  0x56, 0xc4, 0xf9, 0x51, 0x1b, 0x88, 0x4e,
618  0x36, 0xab, 0x15, 0x4d, 0x8f, 0xdc, 0x08,
619  0xc4, 0x4d, 0x43, 0xc7, 0x2b, 0xc9, 0x5c,
620  0x05, 0x26, 0xe3, 0x46, 0xf0, 0x64, 0xaa,
621  0x02, 0xa4, 0xbe, 0x3a, 0xd1, 0xca, 0x07,
622  0x6a, 0x6e, 0x62, 0xf4, 0x57, 0x71, 0x96,
623  0xec, 0xf0, 0x0b, 0xac, 0xa4, 0x4a, 0xa3,
624  0x6d, 0x01, 0xba, 0xbd, 0x62, 0xc0, 0x10,
625  0x54, 0x33, 0x8a, 0x71, 0xef, 0xaa, 0x1c,
626  0x25, 0x25 ),
627  BIGINT ( 0x46, 0x1e, 0x38, 0x3a, 0x05, 0xc5, 0xaf,
628  0xb5, 0x2e, 0x58, 0x8a, 0x0e, 0xec, 0x43,
629  0xd6, 0x6b, 0xf1, 0x97, 0x73, 0x4c, 0x1b,
630  0xcd, 0x31, 0xb8, 0x94, 0x0b, 0xe4, 0x9d,
631  0x75, 0x17, 0xa5, 0xc4, 0xc4, 0x2a, 0xf0,
632  0x32, 0x45, 0x09, 0xe8, 0xf6, 0x62, 0x03,
633  0x2d, 0xee, 0x6e, 0xd3, 0xfc, 0x41, 0x6b,
634  0x10, 0x70, 0x9b, 0x87, 0xa7, 0x8d, 0x9f,
635  0x61, 0xbe, 0xcf, 0x09, 0x82, 0xfe, 0xd3,
636  0x16, 0x5c, 0x12, 0x63, 0xa3, 0xb6, 0xd6,
637  0xef, 0xdf, 0xc1, 0xc2, 0x13, 0x09, 0x98,
638  0x77, 0xe4, 0x97, 0x61, 0x1f, 0x7d, 0xe7,
639  0x32, 0xbf, 0x4c, 0xd4, 0x0a, 0x54, 0xea,
640  0x68, 0xe4, 0x1e, 0xb3, 0x06, 0x49, 0xa3,
641  0x61, 0x6f, 0xd7, 0x4a, 0x21, 0xd4, 0xbc,
642  0x68, 0x76, 0xf5, 0x20, 0xa1, 0xa8, 0x1a,
643  0x9f, 0x60, 0x58, 0xff, 0xb6, 0x76, 0x45,
644  0xe6, 0xed, 0x61, 0x8d, 0xe6, 0xc0, 0x72,
645  0x1c, 0x07 ) );
646  bigint_subtract_ok ( BIGINT ( 0x83 ),
647  BIGINT ( 0x50 ),
648  BIGINT ( 0xcd ) );
649  bigint_subtract_ok ( BIGINT ( 0x2c, 0x7c ),
650  BIGINT ( 0x49, 0x0e ),
651  BIGINT ( 0x1c, 0x92 ) );
652  bigint_subtract_ok ( BIGINT ( 0x9c, 0x30, 0xbf ),
653  BIGINT ( 0xde, 0x4e, 0x07 ),
654  BIGINT ( 0x42, 0x1d, 0x48 ) );
655  bigint_subtract_ok ( BIGINT ( 0xbb, 0x77, 0x32, 0x5a ),
656  BIGINT ( 0x5a, 0xd5, 0xfe, 0x28 ),
657  BIGINT ( 0x9f, 0x5e, 0xcb, 0xce ) );
658  bigint_subtract_ok ( BIGINT ( 0x7b, 0xaa, 0x16, 0xcf, 0x15, 0x87,
659  0xe0, 0x4f, 0x2c, 0xa3, 0xec, 0x2f,
660  0x46, 0xfb, 0x83, 0xc6, 0xe0, 0xee,
661  0x57, 0xfa, 0x04, 0xce, 0xa6 ),
662  BIGINT ( 0x46, 0x55, 0xb6, 0x23, 0x63, 0xd0,
663  0x55, 0xdb, 0x8f, 0xcc, 0x55, 0xa8,
664  0x2f, 0x85, 0xc1, 0x9f, 0x2c, 0x13,
665  0x10, 0x9e, 0x76, 0x3c, 0x11 ),
666  BIGINT ( 0xca, 0xab, 0x9f, 0x54, 0x4e, 0x48,
667  0x75, 0x8c, 0x63, 0x28, 0x69, 0x78,
668  0xe8, 0x8a, 0x3d, 0xd8, 0x4b, 0x24,
669  0xb8, 0xa4, 0x71, 0x6d, 0x6b ) );
670  bigint_subtract_ok ( BIGINT ( 0x5b, 0x06, 0x77, 0x7b, 0xfd, 0x34,
671  0x5f, 0x0f, 0xd9, 0xbd, 0x8e, 0x5d,
672  0xc8, 0x4a, 0x70, 0x95, 0x1b, 0xb6,
673  0x48, 0xfb, 0x0e, 0x40, 0xce, 0x06,
674  0x66, 0xcc, 0x29, 0xe9, 0x51, 0x59,
675  0x59, 0xc9, 0x65, 0x07, 0x75, 0xb8,
676  0xd4, 0xcb, 0x07, 0x68, 0x14, 0x48,
677  0xc7, 0x1e, 0xfe, 0xb3, 0x4c, 0xf1,
678  0x10, 0xf0, 0xc7, 0x82, 0x38, 0x4c,
679  0xaf, 0x05, 0x6d, 0x91, 0xc5, 0x18,
680  0xfd, 0x1e, 0x26, 0x1b, 0xef, 0x71,
681  0x70, 0x2e, 0x06, 0x70, 0x8e, 0x54,
682  0xfa, 0x2b, 0x4d, 0x96, 0x85, 0x10,
683  0x03, 0x76, 0xe7, 0x17, 0x59, 0x86,
684  0x6c, 0x8b, 0x24, 0x6e, 0xd9, 0x30,
685  0xf3, 0xd2, 0x9b, 0x62, 0xdc, 0x23,
686  0x54, 0x06, 0x51, 0xb1, 0x95, 0x58,
687  0xec, 0x27, 0xf6, 0x19, 0xae, 0xf4,
688  0x31, 0xec, 0x72, 0x53, 0xcd, 0x32,
689  0xed, 0xf4, 0x25, 0x4a, 0x5b, 0x36,
690  0xa2, 0xb4, 0xa0, 0x29, 0x0c, 0x6b,
691  0x3f, 0xc2 ),
692  BIGINT ( 0x7a, 0xd4, 0x25, 0xf1, 0xb5, 0xf5,
693  0x00, 0x96, 0x47, 0x5b, 0x4f, 0x9f,
694  0x1f, 0x61, 0x69, 0xd9, 0x72, 0x47,
695  0xde, 0xbd, 0x87, 0x5d, 0x50, 0x91,
696  0x69, 0xd8, 0x35, 0xe0, 0x43, 0xd8,
697  0xd5, 0x15, 0xf2, 0xcd, 0x01, 0x73,
698  0x0d, 0x34, 0xf0, 0x34, 0x46, 0x76,
699  0xc0, 0x55, 0x7b, 0x27, 0xf5, 0x7b,
700  0x55, 0xe9, 0xd0, 0x29, 0x0b, 0x4b,
701  0x9f, 0x07, 0xbf, 0x2c, 0x3f, 0xef,
702  0x36, 0x34, 0xde, 0x29, 0x1d, 0x5d,
703  0x84, 0x5a, 0x5d, 0xc1, 0x02, 0x4d,
704  0x56, 0xf1, 0x47, 0x39, 0x37, 0xc9,
705  0xb5, 0x5f, 0x73, 0xec, 0x7c, 0x3d,
706  0xbd, 0xc0, 0xfd, 0x38, 0x6c, 0x91,
707  0x88, 0x4a, 0x0f, 0xee, 0xa1, 0x80,
708  0xf5, 0x6a, 0x7c, 0x8c, 0x02, 0xc3,
709  0x5a, 0xb2, 0x15, 0xa6, 0x2f, 0x6b,
710  0x5b, 0x78, 0xb5, 0xf3, 0xbd, 0xd0,
711  0xc8, 0xbc, 0xb1, 0xbb, 0xe1, 0xce,
712  0x22, 0x80, 0x34, 0x5a, 0x2a, 0x27,
713  0x83, 0xdc ),
714  BIGINT ( 0x1f, 0xcd, 0xae, 0x75, 0xb8, 0xc0,
715  0xa1, 0x86, 0x6d, 0x9d, 0xc1, 0x41,
716  0x57, 0x16, 0xf9, 0x44, 0x56, 0x91,
717  0x95, 0xc2, 0x79, 0x1c, 0x82, 0x8b,
718  0x03, 0x0c, 0x0b, 0xf6, 0xf2, 0x7f,
719  0x7b, 0x4c, 0x8d, 0xc5, 0x8b, 0xba,
720  0x38, 0x69, 0xe8, 0xcc, 0x32, 0x2d,
721  0xf9, 0x36, 0x7c, 0x74, 0xa8, 0x8a,
722  0x44, 0xf9, 0x08, 0xa6, 0xd2, 0xfe,
723  0xf0, 0x02, 0x51, 0x9a, 0x7a, 0xd6,
724  0x39, 0x16, 0xb8, 0x0d, 0x2d, 0xec,
725  0x14, 0x2c, 0x57, 0x50, 0x73, 0xf8,
726  0x5c, 0xc5, 0xf9, 0xa2, 0xb2, 0xb9,
727  0xb1, 0xe8, 0x8c, 0xd5, 0x22, 0xb7,
728  0x51, 0x35, 0xd8, 0xc9, 0x93, 0x60,
729  0x94, 0x77, 0x74, 0x8b, 0xc5, 0x5d,
730  0xa1, 0x64, 0x2a, 0xda, 0x6d, 0x6a,
731  0x6e, 0x8a, 0x1f, 0x8c, 0x80, 0x77,
732  0x29, 0x8c, 0x43, 0x9f, 0xf0, 0x9d,
733  0xda, 0xc8, 0x8c, 0x71, 0x86, 0x97,
734  0x7f, 0xcb, 0x94, 0x31, 0x1d, 0xbc,
735  0x44, 0x1a ) );
736  bigint_rol_ok ( BIGINT ( 0xe0 ),
737  BIGINT ( 0xc0 ) );
738  bigint_rol_ok ( BIGINT ( 0x43, 0x1d ),
739  BIGINT ( 0x86, 0x3a ) );
740  bigint_rol_ok ( BIGINT ( 0xac, 0xed, 0x9b ),
741  BIGINT ( 0x59, 0xdb, 0x36 ) );
742  bigint_rol_ok ( BIGINT ( 0x2c, 0xe8, 0x3a, 0x22 ),
743  BIGINT ( 0x59, 0xd0, 0x74, 0x44 ) );
744  bigint_rol_ok ( BIGINT ( 0x4e, 0x88, 0x4a, 0x05, 0x5e, 0x10, 0xee,
745  0x5b, 0xc6, 0x40, 0x0e, 0x03, 0xd7, 0x0d,
746  0x28, 0xa5, 0x55, 0xb2, 0x50, 0xef, 0x69,
747  0xd1, 0x1d ),
748  BIGINT ( 0x9d, 0x10, 0x94, 0x0a, 0xbc, 0x21, 0xdc,
749  0xb7, 0x8c, 0x80, 0x1c, 0x07, 0xae, 0x1a,
750  0x51, 0x4a, 0xab, 0x64, 0xa1, 0xde, 0xd3,
751  0xa2, 0x3a ) );
752  bigint_rol_ok ( BIGINT ( 0x07, 0x62, 0x78, 0x70, 0x2e, 0xd4, 0x41,
753  0xaa, 0x9b, 0x50, 0xb1, 0x9a, 0x71, 0xf5,
754  0x1c, 0x2f, 0xe7, 0x0d, 0xf1, 0x46, 0x57,
755  0x04, 0x99, 0x78, 0x4e, 0x84, 0x78, 0xba,
756  0x57, 0xea, 0xa5, 0x43, 0xf7, 0x02, 0xf0,
757  0x7a, 0x22, 0x60, 0x65, 0x42, 0xf2, 0x33,
758  0x7d, 0xe3, 0xa8, 0x1b, 0xc4, 0x14, 0xdb,
759  0xee, 0x4a, 0xf1, 0xe1, 0x52, 0xd4, 0xda,
760  0x23, 0xed, 0x13, 0x5d, 0xea, 0xcf, 0xf6,
761  0x5e, 0x39, 0x84, 0xe2, 0xb3, 0xa2, 0x05,
762  0xba, 0xd9, 0x49, 0x8e, 0x75, 0x1d, 0xdb,
763  0xe6, 0xb1, 0x6e, 0xda, 0x0a, 0x83, 0xd0,
764  0x6e, 0xcf, 0x7a, 0x66, 0xb7, 0x64, 0x84,
765  0xf5, 0x09, 0x5a, 0xa8, 0x11, 0x93, 0xf3,
766  0x4f, 0x02, 0x28, 0x00, 0x3a, 0xf0, 0xa9,
767  0x08, 0x77, 0x04, 0xf5, 0x04, 0xcd, 0x6b,
768  0x24, 0xbe, 0x0f, 0x6d, 0xe3, 0xb2, 0xd3,
769  0x07, 0x68, 0xe9, 0x00, 0x59, 0xa0, 0xe4,
770  0x9e, 0x5e ),
771  BIGINT ( 0x0e, 0xc4, 0xf0, 0xe0, 0x5d, 0xa8, 0x83,
772  0x55, 0x36, 0xa1, 0x63, 0x34, 0xe3, 0xea,
773  0x38, 0x5f, 0xce, 0x1b, 0xe2, 0x8c, 0xae,
774  0x09, 0x32, 0xf0, 0x9d, 0x08, 0xf1, 0x74,
775  0xaf, 0xd5, 0x4a, 0x87, 0xee, 0x05, 0xe0,
776  0xf4, 0x44, 0xc0, 0xca, 0x85, 0xe4, 0x66,
777  0xfb, 0xc7, 0x50, 0x37, 0x88, 0x29, 0xb7,
778  0xdc, 0x95, 0xe3, 0xc2, 0xa5, 0xa9, 0xb4,
779  0x47, 0xda, 0x26, 0xbb, 0xd5, 0x9f, 0xec,
780  0xbc, 0x73, 0x09, 0xc5, 0x67, 0x44, 0x0b,
781  0x75, 0xb2, 0x93, 0x1c, 0xea, 0x3b, 0xb7,
782  0xcd, 0x62, 0xdd, 0xb4, 0x15, 0x07, 0xa0,
783  0xdd, 0x9e, 0xf4, 0xcd, 0x6e, 0xc9, 0x09,
784  0xea, 0x12, 0xb5, 0x50, 0x23, 0x27, 0xe6,
785  0x9e, 0x04, 0x50, 0x00, 0x75, 0xe1, 0x52,
786  0x10, 0xee, 0x09, 0xea, 0x09, 0x9a, 0xd6,
787  0x49, 0x7c, 0x1e, 0xdb, 0xc7, 0x65, 0xa6,
788  0x0e, 0xd1, 0xd2, 0x00, 0xb3, 0x41, 0xc9,
789  0x3c, 0xbc ) );
790  bigint_ror_ok ( BIGINT ( 0x8f ),
791  BIGINT ( 0x47 ) );
792  bigint_ror_ok ( BIGINT ( 0xaa, 0x1d ),
793  BIGINT ( 0x55, 0x0e ) );
794  bigint_ror_ok ( BIGINT ( 0xf0, 0xbd, 0x68 ),
795  BIGINT ( 0x78, 0x5e, 0xb4 ) );
796  bigint_ror_ok ( BIGINT ( 0x33, 0xa0, 0x3d, 0x95 ),
797  BIGINT ( 0x19, 0xd0, 0x1e, 0xca ) );
798  bigint_ror_ok ( BIGINT ( 0xa1, 0xf4, 0xb9, 0x64, 0x91, 0x99, 0xa1,
799  0xf4, 0xae, 0xeb, 0x71, 0x97, 0x1b, 0x71,
800  0x09, 0x38, 0x3f, 0x8f, 0xc5, 0x3a, 0xb9,
801  0x75, 0x94 ),
802  BIGINT ( 0x50, 0xfa, 0x5c, 0xb2, 0x48, 0xcc, 0xd0,
803  0xfa, 0x57, 0x75, 0xb8, 0xcb, 0x8d, 0xb8,
804  0x84, 0x9c, 0x1f, 0xc7, 0xe2, 0x9d, 0x5c,
805  0xba, 0xca ) );
806  bigint_ror_ok ( BIGINT ( 0xc0, 0xb3, 0x78, 0x46, 0x69, 0x6e, 0x35,
807  0x94, 0xed, 0x28, 0xdc, 0xfd, 0xf6, 0xdb,
808  0x2d, 0x24, 0xcb, 0xa4, 0x6f, 0x0e, 0x58,
809  0x89, 0x04, 0xec, 0xc8, 0x0c, 0x2d, 0xb3,
810  0x58, 0xa7, 0x22, 0x6d, 0x93, 0xe0, 0xb8,
811  0x48, 0x6a, 0x3f, 0x04, 0x7e, 0xbe, 0xb8,
812  0xa7, 0x84, 0xf5, 0xc9, 0x2f, 0x60, 0x9e,
813  0x7c, 0xbc, 0xaf, 0x28, 0x89, 0x2f, 0xaa,
814  0xd1, 0x82, 0x77, 0xa4, 0xdf, 0xf3, 0x4a,
815  0xc6, 0xed, 0xa3, 0x07, 0xb4, 0xa9, 0xfd,
816  0xef, 0xf8, 0x20, 0xb9, 0xb3, 0xff, 0x35,
817  0x27, 0xed, 0x02, 0xea, 0xec, 0x63, 0xc0,
818  0x46, 0x97, 0xc0, 0x4c, 0xca, 0x89, 0xca,
819  0x14, 0xe8, 0xe0, 0x02, 0x14, 0x44, 0x46,
820  0xf3, 0x2f, 0xbc, 0x6a, 0x28, 0xa2, 0xbe,
821  0x20, 0xc8, 0xaa, 0x0f, 0xd9, 0x51, 0x8e,
822  0x8d, 0x51, 0x29, 0x61, 0xef, 0x48, 0xae,
823  0x3e, 0xe5, 0x10, 0xbf, 0xda, 0x9b, 0x92,
824  0xb3, 0x77 ),
825  BIGINT ( 0x60, 0x59, 0xbc, 0x23, 0x34, 0xb7, 0x1a,
826  0xca, 0x76, 0x94, 0x6e, 0x7e, 0xfb, 0x6d,
827  0x96, 0x92, 0x65, 0xd2, 0x37, 0x87, 0x2c,
828  0x44, 0x82, 0x76, 0x64, 0x06, 0x16, 0xd9,
829  0xac, 0x53, 0x91, 0x36, 0xc9, 0xf0, 0x5c,
830  0x24, 0x35, 0x1f, 0x82, 0x3f, 0x5f, 0x5c,
831  0x53, 0xc2, 0x7a, 0xe4, 0x97, 0xb0, 0x4f,
832  0x3e, 0x5e, 0x57, 0x94, 0x44, 0x97, 0xd5,
833  0x68, 0xc1, 0x3b, 0xd2, 0x6f, 0xf9, 0xa5,
834  0x63, 0x76, 0xd1, 0x83, 0xda, 0x54, 0xfe,
835  0xf7, 0xfc, 0x10, 0x5c, 0xd9, 0xff, 0x9a,
836  0x93, 0xf6, 0x81, 0x75, 0x76, 0x31, 0xe0,
837  0x23, 0x4b, 0xe0, 0x26, 0x65, 0x44, 0xe5,
838  0x0a, 0x74, 0x70, 0x01, 0x0a, 0x22, 0x23,
839  0x79, 0x97, 0xde, 0x35, 0x14, 0x51, 0x5f,
840  0x10, 0x64, 0x55, 0x07, 0xec, 0xa8, 0xc7,
841  0x46, 0xa8, 0x94, 0xb0, 0xf7, 0xa4, 0x57,
842  0x1f, 0x72, 0x88, 0x5f, 0xed, 0x4d, 0xc9,
843  0x59, 0xbb ) );
844  bigint_is_zero_ok ( BIGINT ( 0x9b ),
845  0 );
846  bigint_is_zero_ok ( BIGINT ( 0x5a, 0x9d ),
847  0 );
848  bigint_is_zero_ok ( BIGINT ( 0x5f, 0x80, 0x78 ),
849  0 );
850  bigint_is_zero_ok ( BIGINT ( 0xa0, 0x52, 0x47, 0x2e ),
851  0 );
852  bigint_is_zero_ok ( BIGINT ( 0x18, 0x08, 0x49, 0xdb, 0x7b, 0x5c,
853  0xe7, 0x41, 0x07, 0xdf, 0xed, 0xf9,
854  0xd3, 0x92, 0x0d, 0x75, 0xa6, 0xb0,
855  0x14, 0xfa, 0xdd, 0xfd, 0x82 ),
856  0 );
857  bigint_is_zero_ok ( BIGINT ( 0x04, 0x04, 0xb5, 0xf5, 0x01, 0xae,
858  0x2b, 0x91, 0xa7, 0xc1, 0x49, 0x97,
859  0x3f, 0x45, 0x53, 0x52, 0xb8, 0x52,
860  0xf1, 0x62, 0xa5, 0x21, 0x18, 0xd4,
861  0xb0, 0xb4, 0x8a, 0x17, 0x0e, 0xe8,
862  0xeb, 0xaa, 0x28, 0xae, 0x3d, 0x8e,
863  0xe3, 0x6c, 0xd0, 0x01, 0x0c, 0x54,
864  0xca, 0x23, 0xbb, 0x06, 0xcd, 0x7a,
865  0x61, 0x89, 0x38, 0x34, 0x6e, 0xc7,
866  0xc2, 0xee, 0xb1, 0x80, 0x61, 0x0e,
867  0xc6, 0x8d, 0x65, 0xa0, 0xeb, 0x34,
868  0xe9, 0x63, 0x09, 0x4c, 0x20, 0xac,
869  0x42, 0xe3, 0x35, 0xa2, 0x3e, 0x3b,
870  0x2e, 0x18, 0x70, 0x45, 0x7c, 0xab,
871  0x42, 0xcc, 0xe0, 0x9e, 0x7c, 0x42,
872  0xd1, 0xda, 0x6c, 0x51, 0x10, 0x1e,
873  0x0e, 0x3f, 0xe5, 0xd6, 0xd8, 0x56,
874  0x08, 0xb2, 0x3b, 0x15, 0xc4, 0x7c,
875  0x0c, 0x7e, 0xaf, 0x7b, 0x9d, 0xd6,
876  0x2b, 0xc0, 0x2f, 0xa2, 0xa3, 0xa3,
877  0x77, 0x58, 0x1b, 0xe9, 0xa8, 0x9a,
878  0x23, 0x7f ),
879  0 );
880  bigint_is_zero_ok ( BIGINT ( 0x00 ),
881  1 );
882  bigint_is_zero_ok ( BIGINT ( 0x00, 0x00 ),
883  1 );
884  bigint_is_zero_ok ( BIGINT ( 0x00, 0x00, 0x00 ),
885  1 );
886  bigint_is_zero_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00 ),
887  1 );
888  bigint_is_zero_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
889  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
890  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
891  0x00, 0x00, 0x00, 0x00, 0x00 ),
892  1 );
893  bigint_is_zero_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
894  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
895  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
896  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
897  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
898  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
899  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
900  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
901  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
902  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
903  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
904  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
905  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
906  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
907  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
908  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
909  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
910  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
911  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
912  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
913  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
914  0x00, 0x00 ),
915  1 );
916  bigint_is_zero_ok ( BIGINT ( 0xff ),
917  0 );
918  bigint_is_zero_ok ( BIGINT ( 0xff, 0xff ),
919  0 );
920  bigint_is_zero_ok ( BIGINT ( 0xff, 0xff, 0xff ),
921  0 );
922  bigint_is_zero_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff ),
923  0 );
924  bigint_is_zero_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
925  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
926  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
927  0xff, 0xff, 0xff, 0xff, 0xff ),
928  0 );
929  bigint_is_zero_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
930  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
931  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
932  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
933  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
934  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
935  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
936  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
937  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
938  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
939  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
940  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
941  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
942  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
943  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
944  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
945  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
946  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
947  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
948  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
949  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
950  0xff, 0xff ),
951  0 );
952  bigint_is_geq_ok ( BIGINT ( 0xa2 ),
953  BIGINT ( 0x58 ),
954  1 );
955  bigint_is_geq_ok ( BIGINT ( 0x58 ),
956  BIGINT ( 0xa2 ),
957  0 );
958  bigint_is_geq_ok ( BIGINT ( 0xa2 ),
959  BIGINT ( 0xa2 ),
960  1 );
961  bigint_is_geq_ok ( BIGINT ( 0x61, 0x29 ),
962  BIGINT ( 0x87, 0xac ),
963  0 );
964  bigint_is_geq_ok ( BIGINT ( 0x87, 0xac ),
965  BIGINT ( 0x61, 0x29 ),
966  1 );
967  bigint_is_geq_ok ( BIGINT ( 0x61, 0x29 ),
968  BIGINT ( 0x61, 0x29 ),
969  1 );
970  bigint_is_geq_ok ( BIGINT ( 0xe6, 0x63, 0x14 ),
971  BIGINT ( 0xb7, 0x2b, 0x76 ),
972  1 );
973  bigint_is_geq_ok ( BIGINT ( 0xb7, 0x2b, 0x76 ),
974  BIGINT ( 0xe6, 0x63, 0x14 ),
975  0 );
976  bigint_is_geq_ok ( BIGINT ( 0xe6, 0x63, 0x14 ),
977  BIGINT ( 0xe6, 0x63, 0x14 ),
978  1 );
979  bigint_is_geq_ok ( BIGINT ( 0xe7, 0x4f, 0xd4, 0x80 ),
980  BIGINT ( 0xb5, 0xf9, 0x9b, 0x90 ),
981  1 );
982  bigint_is_geq_ok ( BIGINT ( 0xb5, 0xf9, 0x9b, 0x90 ),
983  BIGINT ( 0xe7, 0x4f, 0xd4, 0x80 ),
984  0 );
985  bigint_is_geq_ok ( BIGINT ( 0xe7, 0x4f, 0xd4, 0x80 ),
986  BIGINT ( 0xe7, 0x4f, 0xd4, 0x80 ),
987  1 );
988  bigint_is_geq_ok ( BIGINT ( 0xe6, 0x2c, 0x7c, 0x24, 0x78, 0x8f, 0x12,
989  0x20, 0xde, 0xd3, 0x6b, 0xc9, 0x97, 0x2d,
990  0x66, 0x74, 0xe5, 0xb6, 0xf7, 0x8f, 0x2b,
991  0x60, 0x98 ),
992  BIGINT ( 0x77, 0xbc, 0x3b, 0x1b, 0x57, 0x43, 0x3b,
993  0x8c, 0x82, 0xda, 0xb5, 0xc7, 0x18, 0x09,
994  0xb3, 0x59, 0x0e, 0x53, 0x2a, 0xb9, 0xd8,
995  0xa2, 0xb4 ),
996  1 );
997  bigint_is_geq_ok ( BIGINT ( 0x77, 0xbc, 0x3b, 0x1b, 0x57, 0x43, 0x3b,
998  0x8c, 0x82, 0xda, 0xb5, 0xc7, 0x18, 0x09,
999  0xb3, 0x59, 0x0e, 0x53, 0x2a, 0xb9, 0xd8,
1000  0xa2, 0xb4 ),
1001  BIGINT ( 0xe6, 0x2c, 0x7c, 0x24, 0x78, 0x8f, 0x12,
1002  0x20, 0xde, 0xd3, 0x6b, 0xc9, 0x97, 0x2d,
1003  0x66, 0x74, 0xe5, 0xb6, 0xf7, 0x8f, 0x2b,
1004  0x60, 0x98 ),
1005  0 );
1006  bigint_is_geq_ok ( BIGINT ( 0xe6, 0x2c, 0x7c, 0x24, 0x78, 0x8f, 0x12,
1007  0x20, 0xde, 0xd3, 0x6b, 0xc9, 0x97, 0x2d,
1008  0x66, 0x74, 0xe5, 0xb6, 0xf7, 0x8f, 0x2b,
1009  0x60, 0x98 ),
1010  BIGINT ( 0xe6, 0x2c, 0x7c, 0x24, 0x78, 0x8f, 0x12,
1011  0x20, 0xde, 0xd3, 0x6b, 0xc9, 0x97, 0x2d,
1012  0x66, 0x74, 0xe5, 0xb6, 0xf7, 0x8f, 0x2b,
1013  0x60, 0x98 ),
1014  1 );
1015  bigint_is_geq_ok ( BIGINT ( 0x2a, 0x98, 0xfd, 0x87, 0x5d, 0x9f, 0xb4,
1016  0x8b, 0x5c, 0xcd, 0x5f, 0xcd, 0x53, 0xb3,
1017  0xd1, 0x81, 0x6a, 0x9c, 0x93, 0x66, 0x40,
1018  0xa7, 0x64, 0xe0, 0x8c, 0xec, 0x96, 0x63,
1019  0x4d, 0x29, 0xfa, 0xb1, 0x5d, 0x93, 0x2f,
1020  0xf9, 0x36, 0xea, 0x3b, 0xc1, 0xaf, 0x85,
1021  0xcb, 0xde, 0x2d, 0xc8, 0x48, 0x33, 0xce,
1022  0x7b, 0xa4, 0xa4, 0xda, 0x0f, 0xaa, 0x1b,
1023  0xcb, 0xed, 0xbe, 0x3a, 0xa5, 0xbb, 0x73,
1024  0x28, 0x04, 0xc6, 0x2a, 0xfb, 0x3a, 0xc3,
1025  0xae, 0x42, 0x1f, 0x53, 0x6c, 0xb2, 0x76,
1026  0xb7, 0xe2, 0x88, 0xcb, 0x88, 0xcf, 0xf0,
1027  0x52, 0x81, 0xd3, 0xb2, 0x1f, 0x56, 0xe1,
1028  0xe1, 0x47, 0x93, 0x6f, 0x2b, 0x49, 0xaa,
1029  0x50, 0x99, 0x7a, 0xc4, 0x56, 0xb7, 0x13,
1030  0x80, 0xf4, 0x73, 0x88, 0xc7, 0x39, 0x83,
1031  0x67, 0xc7, 0xcc, 0xb2, 0x28, 0x7a, 0xd3,
1032  0xdc, 0x48, 0xea, 0x62, 0x0d, 0xf5, 0x5a,
1033  0x27, 0x96 ),
1034  BIGINT ( 0xd4, 0x6b, 0x0a, 0x2e, 0x9f, 0xde, 0x4b,
1035  0x64, 0xfa, 0x6b, 0x37, 0x73, 0x66, 0x06,
1036  0xee, 0x04, 0xef, 0xe6, 0x3c, 0x7d, 0x57,
1037  0x22, 0x7f, 0x1f, 0x62, 0x1c, 0x7e, 0x20,
1038  0xda, 0x97, 0xd0, 0x27, 0x23, 0xf6, 0x77,
1039  0x5b, 0x49, 0x97, 0xe1, 0x65, 0x91, 0x13,
1040  0x93, 0xd6, 0x12, 0xc3, 0x66, 0x91, 0x76,
1041  0xe8, 0x47, 0x4c, 0x6a, 0x1b, 0xa2, 0x02,
1042  0xf8, 0x94, 0xaa, 0xe0, 0x1b, 0x0b, 0x17,
1043  0x86, 0x5e, 0xf5, 0x17, 0x23, 0xf5, 0x17,
1044  0x91, 0x6b, 0xd7, 0x2f, 0x5a, 0xfe, 0x8a,
1045  0x63, 0x28, 0x31, 0x1e, 0x09, 0x60, 0x29,
1046  0x5d, 0x55, 0xd8, 0x79, 0xeb, 0x78, 0x36,
1047  0x44, 0x69, 0xa4, 0x76, 0xa5, 0x35, 0x30,
1048  0xca, 0xc9, 0xf9, 0x62, 0xd7, 0x82, 0x13,
1049  0x56, 0xd0, 0x58, 0xfe, 0x16, 0x4b, 0xfb,
1050  0xa8, 0x4c, 0xb3, 0xd7, 0xcf, 0x5f, 0x93,
1051  0x9d, 0xc4, 0x11, 0xb4, 0xdd, 0xf8, 0x8f,
1052  0xe1, 0x11 ),
1053  0 );
1054  bigint_is_geq_ok ( BIGINT ( 0xd4, 0x6b, 0x0a, 0x2e, 0x9f, 0xde, 0x4b,
1055  0x64, 0xfa, 0x6b, 0x37, 0x73, 0x66, 0x06,
1056  0xee, 0x04, 0xef, 0xe6, 0x3c, 0x7d, 0x57,
1057  0x22, 0x7f, 0x1f, 0x62, 0x1c, 0x7e, 0x20,
1058  0xda, 0x97, 0xd0, 0x27, 0x23, 0xf6, 0x77,
1059  0x5b, 0x49, 0x97, 0xe1, 0x65, 0x91, 0x13,
1060  0x93, 0xd6, 0x12, 0xc3, 0x66, 0x91, 0x76,
1061  0xe8, 0x47, 0x4c, 0x6a, 0x1b, 0xa2, 0x02,
1062  0xf8, 0x94, 0xaa, 0xe0, 0x1b, 0x0b, 0x17,
1063  0x86, 0x5e, 0xf5, 0x17, 0x23, 0xf5, 0x17,
1064  0x91, 0x6b, 0xd7, 0x2f, 0x5a, 0xfe, 0x8a,
1065  0x63, 0x28, 0x31, 0x1e, 0x09, 0x60, 0x29,
1066  0x5d, 0x55, 0xd8, 0x79, 0xeb, 0x78, 0x36,
1067  0x44, 0x69, 0xa4, 0x76, 0xa5, 0x35, 0x30,
1068  0xca, 0xc9, 0xf9, 0x62, 0xd7, 0x82, 0x13,
1069  0x56, 0xd0, 0x58, 0xfe, 0x16, 0x4b, 0xfb,
1070  0xa8, 0x4c, 0xb3, 0xd7, 0xcf, 0x5f, 0x93,
1071  0x9d, 0xc4, 0x11, 0xb4, 0xdd, 0xf8, 0x8f,
1072  0xe1, 0x11 ),
1073  BIGINT ( 0x2a, 0x98, 0xfd, 0x87, 0x5d, 0x9f, 0xb4,
1074  0x8b, 0x5c, 0xcd, 0x5f, 0xcd, 0x53, 0xb3,
1075  0xd1, 0x81, 0x6a, 0x9c, 0x93, 0x66, 0x40,
1076  0xa7, 0x64, 0xe0, 0x8c, 0xec, 0x96, 0x63,
1077  0x4d, 0x29, 0xfa, 0xb1, 0x5d, 0x93, 0x2f,
1078  0xf9, 0x36, 0xea, 0x3b, 0xc1, 0xaf, 0x85,
1079  0xcb, 0xde, 0x2d, 0xc8, 0x48, 0x33, 0xce,
1080  0x7b, 0xa4, 0xa4, 0xda, 0x0f, 0xaa, 0x1b,
1081  0xcb, 0xed, 0xbe, 0x3a, 0xa5, 0xbb, 0x73,
1082  0x28, 0x04, 0xc6, 0x2a, 0xfb, 0x3a, 0xc3,
1083  0xae, 0x42, 0x1f, 0x53, 0x6c, 0xb2, 0x76,
1084  0xb7, 0xe2, 0x88, 0xcb, 0x88, 0xcf, 0xf0,
1085  0x52, 0x81, 0xd3, 0xb2, 0x1f, 0x56, 0xe1,
1086  0xe1, 0x47, 0x93, 0x6f, 0x2b, 0x49, 0xaa,
1087  0x50, 0x99, 0x7a, 0xc4, 0x56, 0xb7, 0x13,
1088  0x80, 0xf4, 0x73, 0x88, 0xc7, 0x39, 0x83,
1089  0x67, 0xc7, 0xcc, 0xb2, 0x28, 0x7a, 0xd3,
1090  0xdc, 0x48, 0xea, 0x62, 0x0d, 0xf5, 0x5a,
1091  0x27, 0x96 ),
1092  1 );
1093  bigint_is_geq_ok ( BIGINT ( 0x2a, 0x98, 0xfd, 0x87, 0x5d, 0x9f, 0xb4,
1094  0x8b, 0x5c, 0xcd, 0x5f, 0xcd, 0x53, 0xb3,
1095  0xd1, 0x81, 0x6a, 0x9c, 0x93, 0x66, 0x40,
1096  0xa7, 0x64, 0xe0, 0x8c, 0xec, 0x96, 0x63,
1097  0x4d, 0x29, 0xfa, 0xb1, 0x5d, 0x93, 0x2f,
1098  0xf9, 0x36, 0xea, 0x3b, 0xc1, 0xaf, 0x85,
1099  0xcb, 0xde, 0x2d, 0xc8, 0x48, 0x33, 0xce,
1100  0x7b, 0xa4, 0xa4, 0xda, 0x0f, 0xaa, 0x1b,
1101  0xcb, 0xed, 0xbe, 0x3a, 0xa5, 0xbb, 0x73,
1102  0x28, 0x04, 0xc6, 0x2a, 0xfb, 0x3a, 0xc3,
1103  0xae, 0x42, 0x1f, 0x53, 0x6c, 0xb2, 0x76,
1104  0xb7, 0xe2, 0x88, 0xcb, 0x88, 0xcf, 0xf0,
1105  0x52, 0x81, 0xd3, 0xb2, 0x1f, 0x56, 0xe1,
1106  0xe1, 0x47, 0x93, 0x6f, 0x2b, 0x49, 0xaa,
1107  0x50, 0x99, 0x7a, 0xc4, 0x56, 0xb7, 0x13,
1108  0x80, 0xf4, 0x73, 0x88, 0xc7, 0x39, 0x83,
1109  0x67, 0xc7, 0xcc, 0xb2, 0x28, 0x7a, 0xd3,
1110  0xdc, 0x48, 0xea, 0x62, 0x0d, 0xf5, 0x5a,
1111  0x27, 0x96 ),
1112  BIGINT ( 0x2a, 0x98, 0xfd, 0x87, 0x5d, 0x9f, 0xb4,
1113  0x8b, 0x5c, 0xcd, 0x5f, 0xcd, 0x53, 0xb3,
1114  0xd1, 0x81, 0x6a, 0x9c, 0x93, 0x66, 0x40,
1115  0xa7, 0x64, 0xe0, 0x8c, 0xec, 0x96, 0x63,
1116  0x4d, 0x29, 0xfa, 0xb1, 0x5d, 0x93, 0x2f,
1117  0xf9, 0x36, 0xea, 0x3b, 0xc1, 0xaf, 0x85,
1118  0xcb, 0xde, 0x2d, 0xc8, 0x48, 0x33, 0xce,
1119  0x7b, 0xa4, 0xa4, 0xda, 0x0f, 0xaa, 0x1b,
1120  0xcb, 0xed, 0xbe, 0x3a, 0xa5, 0xbb, 0x73,
1121  0x28, 0x04, 0xc6, 0x2a, 0xfb, 0x3a, 0xc3,
1122  0xae, 0x42, 0x1f, 0x53, 0x6c, 0xb2, 0x76,
1123  0xb7, 0xe2, 0x88, 0xcb, 0x88, 0xcf, 0xf0,
1124  0x52, 0x81, 0xd3, 0xb2, 0x1f, 0x56, 0xe1,
1125  0xe1, 0x47, 0x93, 0x6f, 0x2b, 0x49, 0xaa,
1126  0x50, 0x99, 0x7a, 0xc4, 0x56, 0xb7, 0x13,
1127  0x80, 0xf4, 0x73, 0x88, 0xc7, 0x39, 0x83,
1128  0x67, 0xc7, 0xcc, 0xb2, 0x28, 0x7a, 0xd3,
1129  0xdc, 0x48, 0xea, 0x62, 0x0d, 0xf5, 0x5a,
1130  0x27, 0x96 ),
1131  1 );
1132  bigint_bit_is_set_ok ( BIGINT ( 0x37 ),
1133  0, 1 );
1134  bigint_bit_is_set_ok ( BIGINT ( 0xe6, 0xcb ),
1135  0, 1 );
1136  bigint_bit_is_set_ok ( BIGINT ( 0xd9, 0x0c, 0x5b ),
1137  0, 1 );
1138  bigint_bit_is_set_ok ( BIGINT ( 0x8b, 0x56, 0x89, 0xaf ),
1139  0, 1 );
1140  bigint_bit_is_set_ok ( BIGINT ( 0x25, 0xfc, 0xaf, 0xeb, 0x81, 0xc3,
1141  0xb8, 0x2f, 0xbb, 0xe3, 0x07, 0xb2,
1142  0xe2, 0x2a, 0xe2, 0x2d, 0xb4, 0x4d,
1143  0x6d, 0xec, 0x51, 0xa0, 0x2f ),
1144  0, 1 );
1145  bigint_bit_is_set_ok ( BIGINT ( 0x25, 0xfc, 0xaf, 0xeb, 0x81, 0xc3,
1146  0xb8, 0x2f, 0xbb, 0xe3, 0x07, 0xb2,
1147  0xe2, 0x2a, 0xe2, 0x2d, 0xb4, 0x4d,
1148  0x6d, 0xec, 0x51, 0xa0, 0x2f ),
1149  45, 0 );
1150  bigint_bit_is_set_ok ( BIGINT ( 0x88, 0x04, 0xec, 0xe6, 0xfb, 0x31,
1151  0x87, 0x43, 0xb2, 0x04, 0x9e, 0x09,
1152  0xba, 0x3e, 0x6d, 0x64, 0x1a, 0x85,
1153  0xb6, 0x46, 0x7d, 0x71, 0x3c, 0x06,
1154  0xd6, 0x40, 0x52, 0x39, 0x95, 0xa1,
1155  0x06, 0xff, 0x6a, 0x5c, 0xa3, 0x6d,
1156  0x4a, 0xc9, 0x77, 0x87, 0x75, 0x25,
1157  0x57, 0x65, 0x72, 0x73, 0x64, 0x7e,
1158  0xe9, 0x16, 0x17, 0xf3, 0x65, 0x3f,
1159  0xd5, 0xcc, 0xd7, 0xa2, 0xee, 0xe7,
1160  0x8d, 0x48, 0xd5, 0x7e, 0xdd, 0x59,
1161  0x4b, 0xf0, 0x96, 0x8b, 0x21, 0x65,
1162  0x04, 0x66, 0xc5, 0xff, 0x3e, 0x60,
1163  0xba, 0x28, 0x38, 0x7d, 0x9c, 0x09,
1164  0xd1, 0x8e, 0xac, 0x73, 0x8e, 0xf2,
1165  0x1e, 0xdf, 0x83, 0x6e, 0x54, 0xd5,
1166  0x34, 0xc1, 0xc6, 0xf9, 0x62, 0x2a,
1167  0x7d, 0xec, 0x47, 0xf2, 0xfc, 0xa2,
1168  0x10, 0x0a, 0x67, 0x1b, 0xc6, 0x11,
1169  0x9d, 0x68, 0x25, 0x8b, 0xb5, 0x9b,
1170  0x83, 0xf8, 0xa2, 0x11, 0xf5, 0xd4,
1171  0xcb, 0xe0 ),
1172  0, 0 );
1173  bigint_bit_is_set_ok ( BIGINT ( 0x88, 0x04, 0xec, 0xe6, 0xfb, 0x31,
1174  0x87, 0x43, 0xb2, 0x04, 0x9e, 0x09,
1175  0xba, 0x3e, 0x6d, 0x64, 0x1a, 0x85,
1176  0xb6, 0x46, 0x7d, 0x71, 0x3c, 0x06,
1177  0xd6, 0x40, 0x52, 0x39, 0x95, 0xa1,
1178  0x06, 0xff, 0x6a, 0x5c, 0xa3, 0x6d,
1179  0x4a, 0xc9, 0x77, 0x87, 0x75, 0x25,
1180  0x57, 0x65, 0x72, 0x73, 0x64, 0x7e,
1181  0xe9, 0x16, 0x17, 0xf3, 0x65, 0x3f,
1182  0xd5, 0xcc, 0xd7, 0xa2, 0xee, 0xe7,
1183  0x8d, 0x48, 0xd5, 0x7e, 0xdd, 0x59,
1184  0x4b, 0xf0, 0x96, 0x8b, 0x21, 0x65,
1185  0x04, 0x66, 0xc5, 0xff, 0x3e, 0x60,
1186  0xba, 0x28, 0x38, 0x7d, 0x9c, 0x09,
1187  0xd1, 0x8e, 0xac, 0x73, 0x8e, 0xf2,
1188  0x1e, 0xdf, 0x83, 0x6e, 0x54, 0xd5,
1189  0x34, 0xc1, 0xc6, 0xf9, 0x62, 0x2a,
1190  0x7d, 0xec, 0x47, 0xf2, 0xfc, 0xa2,
1191  0x10, 0x0a, 0x67, 0x1b, 0xc6, 0x11,
1192  0x9d, 0x68, 0x25, 0x8b, 0xb5, 0x9b,
1193  0x83, 0xf8, 0xa2, 0x11, 0xf5, 0xd4,
1194  0xcb, 0xe0 ),
1195  45, 1 );
1196  bigint_bit_is_set_ok ( BIGINT ( 0x88, 0x04, 0xec, 0xe6, 0xfb, 0x31,
1197  0x87, 0x43, 0xb2, 0x04, 0x9e, 0x09,
1198  0xba, 0x3e, 0x6d, 0x64, 0x1a, 0x85,
1199  0xb6, 0x46, 0x7d, 0x71, 0x3c, 0x06,
1200  0xd6, 0x40, 0x52, 0x39, 0x95, 0xa1,
1201  0x06, 0xff, 0x6a, 0x5c, 0xa3, 0x6d,
1202  0x4a, 0xc9, 0x77, 0x87, 0x75, 0x25,
1203  0x57, 0x65, 0x72, 0x73, 0x64, 0x7e,
1204  0xe9, 0x16, 0x17, 0xf3, 0x65, 0x3f,
1205  0xd5, 0xcc, 0xd7, 0xa2, 0xee, 0xe7,
1206  0x8d, 0x48, 0xd5, 0x7e, 0xdd, 0x59,
1207  0x4b, 0xf0, 0x96, 0x8b, 0x21, 0x65,
1208  0x04, 0x66, 0xc5, 0xff, 0x3e, 0x60,
1209  0xba, 0x28, 0x38, 0x7d, 0x9c, 0x09,
1210  0xd1, 0x8e, 0xac, 0x73, 0x8e, 0xf2,
1211  0x1e, 0xdf, 0x83, 0x6e, 0x54, 0xd5,
1212  0x34, 0xc1, 0xc6, 0xf9, 0x62, 0x2a,
1213  0x7d, 0xec, 0x47, 0xf2, 0xfc, 0xa2,
1214  0x10, 0x0a, 0x67, 0x1b, 0xc6, 0x11,
1215  0x9d, 0x68, 0x25, 0x8b, 0xb5, 0x9b,
1216  0x83, 0xf8, 0xa2, 0x11, 0xf5, 0xd4,
1217  0xcb, 0xe0 ),
1218  1013, 0 );
1219  bigint_max_set_bit_ok ( BIGINT ( 0x3a ),
1220  6 );
1221  bigint_max_set_bit_ok ( BIGINT ( 0x03 ),
1222  2 );
1223  bigint_max_set_bit_ok ( BIGINT ( 0x00 ),
1224  0 );
1225  bigint_max_set_bit_ok ( BIGINT ( 0xff ),
1226  8 );
1227  bigint_max_set_bit_ok ( BIGINT ( 0x20, 0x30 ),
1228  14 );
1229  bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x10 ),
1230  5 );
1231  bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00 ),
1232  0 );
1233  bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff ),
1234  16 );
1235  bigint_max_set_bit_ok ( BIGINT ( 0x06, 0xdb, 0x7a ),
1236  19 );
1237  bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00 ),
1238  0 );
1239  bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00 ),
1240  0 );
1241  bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff, 0xff ),
1242  24 );
1243  bigint_max_set_bit_ok ( BIGINT ( 0xee, 0xcb, 0x7b, 0xfd ),
1244  32 );
1245  bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x01, 0xdd ),
1246  9 );
1247  bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00 ),
1248  0 );
1249  bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff ),
1250  32 );
1251  bigint_max_set_bit_ok ( BIGINT ( 0x32, 0x39, 0x96, 0x52, 0x10, 0x67,
1252  0x7e, 0x32, 0xfc, 0x4e, 0x56, 0xc3,
1253  0x68, 0x18, 0x76, 0x1a, 0xac, 0x0e,
1254  0x93, 0xee, 0x55, 0xc5, 0x6e ),
1255  182 );
1256  bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1257  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1258  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1259  0x00, 0x00, 0xc8, 0xe6, 0x59 ),
1260  24 );
1261  bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1262  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1263  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1264  0x00, 0x00, 0x00, 0x00, 0x00 ),
1265  0 );
1266  bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1267  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1268  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1269  0xff, 0xff, 0xff, 0xff, 0xff ),
1270  184 );
1271  bigint_max_set_bit_ok ( BIGINT ( 0xcd, 0xb3, 0x22, 0x30, 0xdd, 0xa7,
1272  0xff, 0x37, 0xbf, 0xe3, 0x38, 0xf7,
1273  0xe1, 0x41, 0x73, 0xea, 0x3a, 0xfc,
1274  0x78, 0x9e, 0xfb, 0x4f, 0x85, 0xdc,
1275  0x1c, 0x40, 0x89, 0x6e, 0xda, 0xf9,
1276  0x9d, 0x6d, 0x12, 0x97, 0xb1, 0x80,
1277  0x2a, 0xeb, 0x91, 0xce, 0x3b, 0x83,
1278  0xb8, 0xa5, 0x3d, 0xce, 0x46, 0x56,
1279  0xb7, 0xd1, 0x28, 0xbc, 0x93, 0x4e,
1280  0x8c, 0x29, 0x6d, 0x2c, 0xcc, 0x58,
1281  0x49, 0x2f, 0x37, 0xa0, 0x08, 0x37,
1282  0x86, 0xdd, 0x38, 0x21, 0xa7, 0x57,
1283  0x37, 0xe3, 0xc5, 0xcc, 0x50, 0x11,
1284  0x1a, 0xe4, 0xea, 0xe7, 0x4d, 0x3c,
1285  0x37, 0x65, 0x78, 0xd1, 0xf6, 0xc3,
1286  0x94, 0x46, 0xd4, 0x0e, 0xd3, 0x9a,
1287  0x21, 0x8b, 0xa6, 0x54, 0xc0, 0xd2,
1288  0x88, 0x07, 0x24, 0xbf, 0x7d, 0x31,
1289  0xfd, 0x15, 0xa8, 0x92, 0x65, 0xe1,
1290  0x8d, 0xed, 0x70, 0x7b, 0x68, 0x0f,
1291  0xcc, 0x13, 0xb9, 0xb2, 0xdd, 0x3c,
1292  0x6a, 0x52 ),
1293  1024 );
1294  bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1295  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1296  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1297  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1298  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1299  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1300  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1301  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1302  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1303  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1304  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1305  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1306  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1307  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1308  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1309  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1310  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1311  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1312  0x00, 0x00, 0x00, 0x00, 0x66, 0xd9,
1313  0x91, 0x18, 0x6e, 0xd3, 0xff, 0x9b,
1314  0xdf, 0xf1, 0x9c, 0x7b, 0xf0, 0xa0,
1315  0xb9, 0xf5 ),
1316  127 );
1317  bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1318  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1319  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1320  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1321  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1322  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1323  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1324  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1325  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1326  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1327  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1328  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1329  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1330  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1331  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1332  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1333  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1334  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1335  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1336  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1337  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1338  0x00, 0x00 ),
1339  0 );
1340  bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1341  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1342  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1343  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1344  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1345  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1346  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1347  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1348  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1349  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1350  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1351  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1352  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1353  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1354  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1355  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1356  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1357  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1358  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1359  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1360  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1361  0xff, 0xff ),
1362  1024 );
1363  bigint_multiply_ok ( BIGINT ( 0xf0 ),
1364  BIGINT ( 0xeb ),
1365  BIGINT ( 0xdc, 0x50 ) );
1366  bigint_multiply_ok ( BIGINT ( 0xd7, 0x16 ),
1367  BIGINT ( 0x88, 0xfb ),
1368  BIGINT ( 0x73, 0x16, 0x92, 0x92 ) );
1369  bigint_multiply_ok ( BIGINT ( 0xfe, 0xed, 0x1d ),
1370  BIGINT ( 0x69, 0x9c, 0x03 ),
1371  BIGINT ( 0x69, 0x2a, 0x9c, 0x5f, 0x73, 0x57 ) );
1372  bigint_multiply_ok ( BIGINT ( 0x96, 0xe9, 0x6f, 0x81 ),
1373  BIGINT ( 0x67, 0x3c, 0x5a, 0x16 ),
1374  BIGINT ( 0x3c, 0xdb, 0x7f, 0xae, 0x12, 0x7e,
1375  0xef, 0x16 ) );
1376  bigint_multiply_ok ( BIGINT ( 0xe8, 0x08, 0x0b, 0xe9, 0x29, 0x36,
1377  0xea, 0x51, 0x1d, 0x75, 0x1a, 0xd5,
1378  0xba, 0xc6, 0xa0, 0xf3, 0x48, 0x5c,
1379  0xdf, 0x42, 0xdf, 0x28, 0x38 ),
1380  BIGINT ( 0x22, 0x07, 0x41, 0x54, 0x4e, 0xf9,
1381  0x90, 0xa8, 0xaf, 0xba, 0xf6, 0xb0,
1382  0x35, 0x7e, 0x98, 0xef, 0x2c, 0x31,
1383  0xc9, 0xa7, 0x25, 0x74, 0x8d ),
1384  BIGINT ( 0x1e, 0xd7, 0xa5, 0x03, 0xc0, 0x18,
1385  0x2e, 0x29, 0xb1, 0x3e, 0x96, 0x71,
1386  0x90, 0xa5, 0x6d, 0x43, 0x58, 0xf7,
1387  0x22, 0x80, 0x0b, 0x21, 0xc6, 0x70,
1388  0x90, 0x1c, 0xa8, 0x85, 0x87, 0xaf,
1389  0xd7, 0xdd, 0x27, 0x69, 0xaf, 0x20,
1390  0xa0, 0x2d, 0x43, 0x5d, 0xda, 0xba,
1391  0x4b, 0x3a, 0x86, 0xd8 ) );
1392  bigint_multiply_ok ( BIGINT ( 0xa2, 0x0f, 0xc6, 0x08, 0x0a, 0x01,
1393  0x19, 0x42, 0x0e, 0xaa, 0x5c, 0xae,
1394  0x4f, 0x4e, 0xb0, 0xad, 0xb2, 0xe8,
1395  0xee, 0xd5, 0x65, 0xec, 0x5a, 0xda,
1396  0xc0, 0xba, 0x78, 0xa8, 0x0f, 0x15,
1397  0x39, 0xd7, 0x7a, 0x10, 0xc2, 0xa7,
1398  0xec, 0x44, 0xac, 0xad, 0x39, 0x04,
1399  0x2e, 0x66, 0x54, 0x70, 0x57, 0xee,
1400  0xf6, 0x97, 0x19, 0x71, 0x16, 0xf9,
1401  0xbb, 0x2e, 0x84, 0x09, 0x6e, 0x9a,
1402  0x3b, 0x16, 0xb2, 0x65, 0x74, 0x50,
1403  0x19, 0xd1, 0xe9, 0x95, 0xa0, 0x7b,
1404  0x33, 0xb5, 0xac, 0x7c, 0x9e, 0xd4,
1405  0x68, 0x0d, 0xc9, 0xe4, 0x03, 0x86,
1406  0x1a, 0xa3, 0x42, 0x33, 0x28, 0x14,
1407  0x12, 0x7d, 0x5a, 0xd9, 0x30, 0x18,
1408  0x0a, 0xf4, 0x0c, 0x96, 0x58, 0xc9,
1409  0xb5, 0x37, 0xdb, 0x49, 0xdc, 0x01,
1410  0x4a, 0xcb, 0x6d, 0x87, 0x52, 0xf6,
1411  0xae, 0xa7, 0x71, 0x31, 0x9a, 0x1a,
1412  0xe2, 0x1c, 0x87, 0x51, 0xc9, 0xeb,
1413  0x70, 0x71 ),
1414  BIGINT ( 0x7c, 0xdd, 0x2f, 0x5d, 0x27, 0xfe,
1415  0xca, 0x70, 0x96, 0xc3, 0xb1, 0x1f,
1416  0xac, 0xa9, 0x3a, 0xdc, 0xcd, 0xbc,
1417  0x58, 0xb4, 0xde, 0xe7, 0xe5, 0x34,
1418  0x1a, 0xc0, 0xb9, 0x46, 0xf7, 0x52,
1419  0x76, 0x23, 0xe8, 0xe9, 0x92, 0xa1,
1420  0x86, 0x3c, 0x6f, 0xf1, 0x22, 0xf4,
1421  0x72, 0xb1, 0xde, 0xd3, 0x8f, 0x11,
1422  0x9e, 0x52, 0xe5, 0x81, 0x54, 0xe9,
1423  0xa7, 0x72, 0x3f, 0x3e, 0xa0, 0x80,
1424  0xbb, 0xae, 0x0e, 0x30, 0x6a, 0x11,
1425  0x91, 0x11, 0x3b, 0x3f, 0x44, 0x1f,
1426  0x8d, 0x4d, 0xea, 0xdd, 0x09, 0x95,
1427  0x9d, 0x02, 0xa6, 0x6d, 0x3b, 0x08,
1428  0x40, 0x8d, 0xb4, 0x4b, 0x05, 0x74,
1429  0x8c, 0x1f, 0xaa, 0x61, 0x6f, 0x0e,
1430  0xcc, 0xcf, 0xe0, 0x81, 0x03, 0xe4,
1431  0x9b, 0x11, 0xd9, 0xab, 0xf3, 0x24,
1432  0xe2, 0x3b, 0xe0, 0x05, 0x60, 0x65,
1433  0x16, 0xc6, 0x2e, 0x83, 0xa0, 0x98,
1434  0x8e, 0x11, 0x05, 0x00, 0xe4, 0x3f,
1435  0x7e, 0x65 ),
1436  BIGINT ( 0x4f, 0x0b, 0xa9, 0x85, 0xb8, 0x31,
1437  0x48, 0xea, 0x11, 0x44, 0xaf, 0x2d,
1438  0xed, 0x1a, 0x76, 0x45, 0xac, 0x87,
1439  0x0c, 0xf3, 0xd7, 0xc4, 0x8e, 0x5c,
1440  0xd7, 0xdf, 0x28, 0x74, 0xa6, 0x40,
1441  0xe4, 0x6b, 0x5b, 0x19, 0x36, 0x37,
1442  0x9c, 0xcd, 0x43, 0x76, 0x15, 0x00,
1443  0x5d, 0x23, 0xa2, 0x8a, 0x53, 0x25,
1444  0xbf, 0x18, 0xda, 0xe6, 0x09, 0xdf,
1445  0xaa, 0xeb, 0x9a, 0x82, 0x01, 0x14,
1446  0x2b, 0x20, 0x2b, 0xb6, 0x22, 0x62,
1447  0x6b, 0xcc, 0xd4, 0xc9, 0x02, 0x67,
1448  0x95, 0x43, 0x75, 0x4e, 0x97, 0x4e,
1449  0xec, 0x04, 0xde, 0x29, 0x0a, 0xef,
1450  0xf7, 0xc1, 0x72, 0x8c, 0x64, 0x38,
1451  0x16, 0x47, 0x9f, 0x16, 0x0c, 0xa5,
1452  0x79, 0x6b, 0xea, 0x2e, 0x4c, 0x3d,
1453  0x0c, 0xe6, 0x57, 0x51, 0x65, 0xa5,
1454  0x3b, 0xca, 0xae, 0x54, 0x0c, 0x67,
1455  0xf8, 0x23, 0x00, 0xc9, 0x8d, 0xe6,
1456  0x16, 0x91, 0x19, 0xb3, 0x5b, 0x68,
1457  0x7b, 0xf2, 0xe2, 0x5d, 0x69, 0x48,
1458  0x3f, 0x2b, 0xa0, 0x4f, 0x7c, 0x3c,
1459  0x26, 0xf9, 0xd9, 0xfd, 0x3d, 0x5d,
1460  0xd6, 0x05, 0x00, 0xd8, 0xdf, 0x5a,
1461  0x56, 0x8f, 0x16, 0x68, 0x4f, 0x15,
1462  0x19, 0x9d, 0xd7, 0x11, 0x51, 0x7d,
1463  0x73, 0x5c, 0xd4, 0xd5, 0xb4, 0xc7,
1464  0x42, 0xe3, 0xee, 0xf1, 0x67, 0xd6,
1465  0x69, 0x72, 0x04, 0x4b, 0x88, 0x3d,
1466  0x05, 0xd8, 0x1e, 0x50, 0xcb, 0xce,
1467  0x39, 0x19, 0x42, 0xb6, 0xa7, 0xf3,
1468  0xba, 0x78, 0x90, 0xd2, 0x09, 0x05,
1469  0x87, 0xf8, 0xc0, 0x9c, 0x47, 0xff,
1470  0xbf, 0xaa, 0x21, 0x8d, 0x81, 0x86,
1471  0xcd, 0x58, 0xdf, 0x30, 0xf1, 0xd1,
1472  0x60, 0x53, 0x85, 0x40, 0xbf, 0x14,
1473  0x3e, 0xdc, 0x9e, 0x9e, 0xc4, 0xc7,
1474  0x48, 0xa0, 0x83, 0xe0, 0x99, 0x8b,
1475  0x43, 0xf8, 0x52, 0x8a, 0x15, 0x88,
1476  0x89, 0x83, 0x7d, 0x71, 0xbb, 0x62,
1477  0x12, 0x7a, 0x23, 0x85, 0x3a, 0xbb,
1478  0xdb, 0x09, 0xfa, 0x95 ) );
1479  bigint_multiply_ok ( BIGINT ( 0xff ),
1480  BIGINT ( 0xff ),
1481  BIGINT ( 0xfe, 0x01 ) );
1482  bigint_multiply_ok ( BIGINT ( 0xff, 0xff ),
1483  BIGINT ( 0xff, 0xff ),
1484  BIGINT ( 0xff, 0xfe, 0x00, 0x01 ) );
1485  bigint_multiply_ok ( BIGINT ( 0xff, 0xff, 0xff ),
1486  BIGINT ( 0xff, 0xff, 0xff ),
1487  BIGINT ( 0xff, 0xff, 0xfe, 0x00, 0x00, 0x01 ) );
1488  bigint_multiply_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff ),
1489  BIGINT ( 0xff, 0xff, 0xff, 0xff ),
1490  BIGINT ( 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00,
1491  0x00, 0x01 ) );
1492  bigint_multiply_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1493  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1494  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1495  0xff, 0xff, 0xff, 0xff, 0xff ),
1496  BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1497  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1498  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1499  0xff, 0xff, 0xff, 0xff, 0xff ),
1500  BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1501  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1502  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1503  0xff, 0xff, 0xff, 0xff, 0xfe, 0x00,
1504  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1505  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1506  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1507  0x00, 0x00, 0x00, 0x01 ) );
1508  bigint_multiply_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1509  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1510  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1511  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1512  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1513  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1514  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1515  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1516  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1517  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1518  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1519  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1520  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1521  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1522  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1523  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1524  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1525  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1526  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1527  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1528  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1529  0xff, 0xff ),
1530  BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1531  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1532  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1533  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1534  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1535  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1536  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1537  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1538  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1539  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1540  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1541  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1542  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1543  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1544  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1545  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1546  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1547  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1548  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1549  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1550  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1551  0xff, 0xff ),
1552  BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1553  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1554  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1555  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1556  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1557  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1558  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1559  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1560  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1561  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1562  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1563  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1564  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1565  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1566  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1567  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1568  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1569  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1570  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1571  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1572  0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1573  0xff, 0xfe, 0x00, 0x00, 0x00, 0x00,
1574  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1575  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1576  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1577  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1578  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1579  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1580  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1581  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1582  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1583  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1584  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1585  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1586  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1587  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1588  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1589  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1590  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1591  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1592  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1593  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1594  0x00, 0x00, 0x00, 0x01 ) );
1595  bigint_mod_multiply_ok ( BIGINT ( 0x37 ),
1596  BIGINT ( 0x67 ),
1597  BIGINT ( 0x3f ),
1598  BIGINT ( 0x3a ) );
1599  bigint_mod_multiply_ok ( BIGINT ( 0x45, 0x94 ),
1600  BIGINT ( 0xbd, 0xd2 ),
1601  BIGINT ( 0xca, 0xc7 ),
1602  BIGINT ( 0xac, 0xc1 ) );
1603  bigint_mod_multiply_ok ( BIGINT ( 0x8e, 0xcd, 0x74 ),
1604  BIGINT ( 0xe2, 0xf1, 0xea ),
1605  BIGINT ( 0x59, 0x51, 0x53 ),
1606  BIGINT ( 0x22, 0xdd, 0x1c ) );
1607  bigint_mod_multiply_ok ( BIGINT ( 0xc2, 0xa8, 0x40, 0x6f ),
1608  BIGINT ( 0x29, 0xd7, 0xf4, 0x77 ),
1609  BIGINT ( 0xbb, 0xbd, 0xdb, 0x3d ),
1610  BIGINT ( 0x8f, 0x39, 0xd0, 0x47 ) );
1611  bigint_mod_multiply_ok ( BIGINT ( 0x2e, 0xcb, 0x74, 0x7c, 0x64, 0x60,
1612  0xb3, 0x44, 0xf3, 0x23, 0x49, 0x4a,
1613  0xc6, 0xb6, 0xbf, 0xea, 0x80, 0xd8,
1614  0x34, 0xc5, 0x54, 0x22, 0x09 ),
1615  BIGINT ( 0x61, 0x2c, 0x5a, 0xc5, 0xde, 0x07,
1616  0x65, 0x8e, 0xab, 0x88, 0x1a, 0x2e,
1617  0x7a, 0x95, 0x17, 0xe3, 0x3b, 0x17,
1618  0xe4, 0x21, 0xb0, 0xb4, 0x57 ),
1619  BIGINT ( 0x8e, 0x46, 0xa5, 0x87, 0x7b, 0x7f,
1620  0xc4, 0xd7, 0x31, 0xb1, 0x94, 0xe7,
1621  0xe7, 0x1c, 0x7e, 0x7a, 0xc2, 0x6c,
1622  0xce, 0xcb, 0xc8, 0x5d, 0x70 ),
1623  BIGINT ( 0x1e, 0xd1, 0x5b, 0x3d, 0x1d, 0x17,
1624  0x7c, 0x31, 0x95, 0x13, 0x1b, 0xd8,
1625  0xee, 0x0a, 0xb0, 0xe1, 0x5b, 0x13,
1626  0xad, 0x83, 0xe9, 0xf8, 0x7f ) );
1627  bigint_mod_multiply_ok ( BIGINT ( 0x56, 0x37, 0xab, 0x07, 0x8b, 0x25,
1628  0xa7, 0xc2, 0x50, 0x30, 0x43, 0xfc,
1629  0x63, 0x8b, 0xdf, 0x84, 0x68, 0x85,
1630  0xca, 0xce, 0x44, 0x5c, 0xb1, 0x14,
1631  0xa4, 0xb5, 0xba, 0x43, 0xe0, 0x31,
1632  0x45, 0x6b, 0x82, 0xa9, 0x0b, 0x9e,
1633  0x3a, 0xb0, 0x39, 0x09, 0x2a, 0x68,
1634  0x2e, 0x0f, 0x09, 0x54, 0x47, 0x04,
1635  0xdb, 0xcf, 0x4a, 0x3a, 0x2d, 0x7b,
1636  0x7d, 0x50, 0xa4, 0xc5, 0xeb, 0x13,
1637  0xdd, 0x49, 0x61, 0x7d, 0x18, 0xa1,
1638  0x0d, 0x6b, 0x58, 0xba, 0x9f, 0x7c,
1639  0x81, 0x34, 0x9e, 0xf9, 0x9c, 0x9e,
1640  0x28, 0xa8, 0x1c, 0x15, 0x16, 0x20,
1641  0x3c, 0x0a, 0xb1, 0x11, 0x06, 0x93,
1642  0xbc, 0xd8, 0x4e, 0x49, 0xae, 0x7b,
1643  0xb4, 0x02, 0x8b, 0x1c, 0x5b, 0x18,
1644  0xb4, 0xac, 0x7f, 0xdd, 0x70, 0xef,
1645  0x87, 0xac, 0x1b, 0xac, 0x25, 0xa3,
1646  0xc9, 0xa7, 0x3a, 0xc5, 0x76, 0x68,
1647  0x09, 0x1f, 0xa1, 0x48, 0x53, 0xb6,
1648  0x13, 0xac ),
1649  BIGINT ( 0xef, 0x5c, 0x1f, 0x1a, 0x44, 0x64,
1650  0x66, 0xcf, 0xdd, 0x3f, 0x0b, 0x27,
1651  0x81, 0xa7, 0x91, 0x7a, 0x35, 0x7b,
1652  0x0f, 0x46, 0x5e, 0xca, 0xbf, 0xf8,
1653  0x50, 0x5e, 0x99, 0x7c, 0xc6, 0x64,
1654  0x43, 0x00, 0x9f, 0xb2, 0xda, 0xfa,
1655  0x42, 0x15, 0x9c, 0xa3, 0xd6, 0xc8,
1656  0x64, 0xa7, 0x65, 0x4a, 0x98, 0xf7,
1657  0xb3, 0x96, 0x5f, 0x42, 0xf9, 0x73,
1658  0xe1, 0x75, 0xc3, 0xc4, 0x0b, 0x5d,
1659  0x5f, 0xf3, 0x04, 0x8a, 0xee, 0x59,
1660  0xa6, 0x1b, 0x06, 0x38, 0x0b, 0xa2,
1661  0x9f, 0xb4, 0x4f, 0x6d, 0x50, 0x5e,
1662  0x37, 0x37, 0x21, 0x83, 0x9d, 0xa3,
1663  0x12, 0x16, 0x4d, 0xab, 0x36, 0x51,
1664  0x21, 0xb1, 0x74, 0x66, 0x40, 0x9a,
1665  0xd3, 0x72, 0xcc, 0x18, 0x40, 0x53,
1666  0x89, 0xff, 0xd7, 0x00, 0x8d, 0x7e,
1667  0x93, 0x81, 0xdb, 0x29, 0xb6, 0xd7,
1668  0x23, 0x2b, 0x67, 0x2f, 0x11, 0x98,
1669  0x49, 0x87, 0x2f, 0x46, 0xb7, 0x33,
1670  0x6d, 0x12 ),
1671  BIGINT ( 0x67, 0x7a, 0x17, 0x6a, 0xd2, 0xf8,
1672  0x49, 0xfb, 0x7c, 0x95, 0x25, 0x54,
1673  0xf0, 0xab, 0x5b, 0xb3, 0x0e, 0x01,
1674  0xab, 0xd3, 0x65, 0x6f, 0x7e, 0x18,
1675  0x05, 0xed, 0x9b, 0xc4, 0x90, 0x6c,
1676  0xd0, 0x6d, 0x94, 0x79, 0x28, 0xd6,
1677  0x24, 0x77, 0x9a, 0x08, 0xd2, 0x2f,
1678  0x7c, 0x2d, 0xa0, 0x0c, 0x14, 0xbe,
1679  0x7b, 0xee, 0x9e, 0x48, 0x88, 0x3c,
1680  0x8f, 0x9f, 0xb9, 0x7a, 0xcb, 0x98,
1681  0x76, 0x61, 0x0d, 0xee, 0xa2, 0x42,
1682  0x67, 0x1b, 0x2c, 0x42, 0x8f, 0x41,
1683  0xcc, 0x78, 0xba, 0xba, 0xaa, 0xa2,
1684  0x92, 0xb0, 0x6e, 0x0c, 0x4e, 0xe1,
1685  0xa5, 0x13, 0x7d, 0x8a, 0x8f, 0x81,
1686  0x95, 0x8a, 0xdf, 0x57, 0x93, 0x88,
1687  0x27, 0x4f, 0x1a, 0x59, 0xa4, 0x74,
1688  0x22, 0xa9, 0x78, 0xe5, 0xed, 0xb1,
1689  0x09, 0x26, 0x59, 0xde, 0x88, 0x21,
1690  0x8d, 0xa2, 0xa8, 0x58, 0x10, 0x7b,
1691  0x65, 0x96, 0xbf, 0x69, 0x3b, 0xc5,
1692  0x55, 0xf8 ),
1693  BIGINT ( 0x15, 0xf7, 0x00, 0xeb, 0xc7, 0x5a,
1694  0x6f, 0xf0, 0x50, 0xf3, 0x21, 0x8a,
1695  0x8e, 0xa6, 0xf6, 0x67, 0x56, 0x7d,
1696  0x07, 0x45, 0x89, 0xdb, 0xd7, 0x7e,
1697  0x9e, 0x28, 0x7f, 0xfb, 0xed, 0xca,
1698  0x2c, 0xbf, 0x47, 0x77, 0x99, 0x95,
1699  0xf3, 0xd6, 0x9d, 0xc5, 0x57, 0x81,
1700  0x7f, 0x97, 0xf2, 0x6b, 0x24, 0xee,
1701  0xce, 0xc5, 0x9b, 0xe6, 0x42, 0x2d,
1702  0x37, 0xb7, 0xeb, 0x3d, 0xb5, 0xf7,
1703  0x1e, 0x86, 0xc2, 0x40, 0x44, 0xc9,
1704  0x85, 0x5a, 0x1a, 0xc0, 0xac, 0x9e,
1705  0x78, 0x69, 0x00, 0x7b, 0x93, 0x65,
1706  0xd7, 0x7f, 0x0c, 0xd6, 0xba, 0x4f,
1707  0x06, 0x00, 0x61, 0x05, 0xb2, 0x44,
1708  0xb4, 0xe7, 0xbb, 0x3b, 0x96, 0xb0,
1709  0x6d, 0xe8, 0x43, 0xd2, 0x03, 0xb7,
1710  0x0a, 0xc4, 0x6d, 0x30, 0xd8, 0xd5,
1711  0xe6, 0x54, 0x65, 0xdd, 0xa9, 0x1b,
1712  0x50, 0xc0, 0xb9, 0x95, 0xb0, 0x7d,
1713  0x7c, 0xca, 0x63, 0xf8, 0x72, 0xbe,
1714  0x3b, 0x00 ) );
1715  bigint_mod_exp_ok ( BIGINT ( 0xcd ),
1716  BIGINT ( 0xbb ),
1717  BIGINT ( 0x25 ),
1718  BIGINT ( 0xab ) );
1719  bigint_mod_exp_ok ( BIGINT ( 0xc4 ),
1720  BIGINT ( 0xe9 ),
1721  BIGINT ( 0x02, 0x4c ),
1722  BIGINT ( 0x7e ) );
1723  bigint_mod_exp_ok ( BIGINT ( 0xcb ),
1724  BIGINT ( 0xde ),
1725  BIGINT ( 0xbd, 0x73, 0xbf ),
1726  BIGINT ( 0x17 ) );
1727  bigint_mod_exp_ok ( BIGINT ( 0x17 ),
1728  BIGINT ( 0xb9 ),
1729  BIGINT ( 0x39, 0x68, 0xba, 0x7d ),
1730  BIGINT ( 0x17 ) );
1731  bigint_mod_exp_ok ( BIGINT ( 0x2e ),
1732  BIGINT ( 0xb7 ),
1733  BIGINT ( 0x39, 0x07, 0x1b, 0x49, 0x5b, 0xea,
1734  0xf2, 0x61, 0x75, 0x94, 0x60, 0x86,
1735  0x73, 0xd0, 0xeb, 0x11, 0x08, 0x19,
1736  0x90, 0x19, 0xe0, 0xed, 0x2a ),
1737  BIGINT ( 0x19 ) );
1738  bigint_mod_exp_ok ( BIGINT ( 0x59 ),
1739  BIGINT ( 0xce ),
1740  BIGINT ( 0xdf, 0xbc, 0x0d, 0x0c, 0x09, 0xeb,
1741  0xf8, 0xcf, 0xdb, 0xb6, 0x00, 0xa3,
1742  0x9e, 0xc3, 0x6c, 0x8d, 0xf1, 0xc3,
1743  0x03, 0x36, 0xaa, 0xd4, 0x22, 0x7c,
1744  0x20, 0x7b, 0xa9, 0x9a, 0x01, 0xe4,
1745  0xf2, 0x50, 0x42, 0x29, 0x68, 0x7a,
1746  0xa6, 0x2c, 0xdf, 0xb6, 0x51, 0xa9,
1747  0x73, 0x10, 0x98, 0x37, 0x69, 0xb3,
1748  0x21, 0x49, 0x6d, 0xcc, 0x80, 0xfa,
1749  0x7e, 0x12, 0xe4, 0x9c, 0xc2, 0xbb,
1750  0xe3, 0xa3, 0x10, 0x3f, 0xba, 0x99,
1751  0x22, 0x79, 0x71, 0x39, 0x96, 0x7b,
1752  0x1a, 0x89, 0xdc, 0xda, 0x43, 0x52,
1753  0x50, 0x7b, 0xe3, 0x8c, 0xd3, 0xc0,
1754  0xf5, 0x7d, 0xfc, 0x80, 0x71, 0x6e,
1755  0xaf, 0x5c, 0xd0, 0x14, 0xc0, 0x60,
1756  0x24, 0xa8, 0x9a, 0x8a, 0x54, 0x4a,
1757  0x6f, 0x42, 0x7a, 0x14, 0x14, 0x25,
1758  0xd5, 0x22, 0x08, 0x8f, 0xd9, 0xdb,
1759  0xd4, 0x0f, 0x14, 0xf4, 0x3b, 0x26,
1760  0x0e, 0xb6, 0x72, 0xd7, 0x03, 0xd5,
1761  0xf0, 0x0e ),
1762  BIGINT ( 0xa9 ) );
1763  bigint_mod_exp_ok ( BIGINT ( 0x7f, 0x30 ),
1764  BIGINT ( 0x73, 0x74 ),
1765  BIGINT ( 0x75 ),
1766  BIGINT ( 0x4b, 0xe8 ) );
1767  bigint_mod_exp_ok ( BIGINT ( 0x04, 0x6c ),
1768  BIGINT ( 0x99, 0x04 ),
1769  BIGINT ( 0x33, 0xd2 ),
1770  BIGINT ( 0x86, 0x74 ) );
1771  bigint_mod_exp_ok ( BIGINT ( 0xca, 0x88 ),
1772  BIGINT ( 0xdc, 0x60 ),
1773  BIGINT ( 0x7e, 0x76, 0x79 ),
1774  BIGINT ( 0x42, 0x40 ) );
1775  bigint_mod_exp_ok ( BIGINT ( 0x68, 0x97 ),
1776  BIGINT ( 0x52, 0x8b ),
1777  BIGINT ( 0x4f, 0x7f, 0xe7, 0xda ),
1778  BIGINT ( 0x22, 0x77 ) );
1779  bigint_mod_exp_ok ( BIGINT ( 0xbd, 0x14 ),
1780  BIGINT ( 0x9e, 0xfc ),
1781  BIGINT ( 0x23, 0xf7, 0xd0, 0xa1, 0x9e, 0x9b,
1782  0x05, 0xd2, 0x44, 0x24, 0x4f, 0x3f,
1783  0x83, 0xcc, 0x49, 0x70, 0xa5, 0x0d,
1784  0xfc, 0xa7, 0x43, 0xf3, 0x3e ),
1785  BIGINT ( 0x1a, 0xc8 ) );
1786  bigint_mod_exp_ok ( BIGINT ( 0x46, 0x3e ),
1787  BIGINT ( 0xb8, 0xde ),
1788  BIGINT ( 0xa9, 0xc0, 0xdc, 0x45, 0x65, 0x0d,
1789  0xa5, 0x56, 0x70, 0x4c, 0xf1, 0xda,
1790  0xab, 0x64, 0xc2, 0x04, 0xf6, 0x32,
1791  0x20, 0x68, 0x31, 0x5f, 0x9a, 0x00,
1792  0x0f, 0x7b, 0x24, 0x33, 0xdf, 0xaf,
1793  0xfe, 0x03, 0x1e, 0x4a, 0xa1, 0xf8,
1794  0x45, 0x8d, 0x5a, 0x7d, 0x12, 0x58,
1795  0x00, 0x6d, 0xba, 0x79, 0x9f, 0xe1,
1796  0xa1, 0xfc, 0x1f, 0xb9, 0xf3, 0xa7,
1797  0x07, 0xf5, 0xfe, 0xd6, 0xa1, 0xba,
1798  0xda, 0x63, 0xef, 0x39, 0x8e, 0xb7,
1799  0x48, 0xa8, 0x81, 0x86, 0xb1, 0x22,
1800  0x14, 0x9f, 0x9e, 0xac, 0x69, 0xf7,
1801  0xae, 0x1f, 0xf2, 0x99, 0x41, 0xb7,
1802  0x37, 0xa7, 0xbc, 0x42, 0xf2, 0x45,
1803  0x43, 0xf2, 0x2a, 0xef, 0xc2, 0x83,
1804  0xd5, 0x32, 0x6e, 0xfa, 0x49, 0x1c,
1805  0x94, 0x9c, 0xc2, 0xc5, 0xad, 0x28,
1806  0x53, 0x1c, 0x11, 0xc4, 0x1c, 0x78,
1807  0x8f, 0x13, 0xdc, 0xb3, 0x2a, 0x63,
1808  0xfd, 0x1f, 0x89, 0x9b, 0x0c, 0x31,
1809  0x92, 0x73 ),
1810  BIGINT ( 0x7b, 0x8a ) );
1811  bigint_mod_exp_ok ( BIGINT ( 0xf3, 0xc3, 0xab ),
1812  BIGINT ( 0xd0, 0x7e, 0xd0 ),
1813  BIGINT ( 0xf6 ),
1814  BIGINT ( 0x1f, 0xb3, 0x09 ) );
1815  bigint_mod_exp_ok ( BIGINT ( 0x13, 0xec, 0xf6 ),
1816  BIGINT ( 0x87, 0x1a, 0x9a ),
1817  BIGINT ( 0x03, 0xf3 ),
1818  BIGINT ( 0x15, 0xe9, 0x8e ) );
1819  bigint_mod_exp_ok ( BIGINT ( 0x5a, 0x96, 0xe5 ),
1820  BIGINT ( 0x56, 0x4a, 0xd1 ),
1821  BIGINT ( 0x89, 0x62, 0x8e ),
1822  BIGINT ( 0x34, 0xb8, 0xaa ) );
1823  bigint_mod_exp_ok ( BIGINT ( 0x84, 0x7c, 0xbd ),
1824  BIGINT ( 0x3c, 0x80, 0x0a ),
1825  BIGINT ( 0x5e, 0x52, 0x9d, 0xba ),
1826  BIGINT ( 0x04, 0xcb, 0x4f ) );
1827  bigint_mod_exp_ok ( BIGINT ( 0x50, 0x01, 0x51 ),
1828  BIGINT ( 0x02, 0xe6, 0x96 ),
1829  BIGINT ( 0x34, 0x0c, 0x7e, 0xbf, 0x27, 0x23,
1830  0x46, 0x92, 0x1c, 0xca, 0x91, 0xab,
1831  0x50, 0x2c, 0x3a, 0x64, 0xc8, 0x4a,
1832  0x75, 0xd6, 0xe2, 0xde, 0x31 ),
1833  BIGINT ( 0x02, 0x16, 0x05 ) );
1834  bigint_mod_exp_ok ( BIGINT ( 0x5e, 0x47, 0xd8 ),
1835  BIGINT ( 0x26, 0xd1, 0xb6 ),
1836  BIGINT ( 0x49, 0x61, 0x84, 0x7a, 0xa9, 0xfb,
1837  0x93, 0x45, 0xe4, 0xfa, 0x53, 0x60,
1838  0x73, 0x98, 0x5a, 0x17, 0xe7, 0x77,
1839  0x2d, 0xcd, 0x97, 0xf4, 0xc0, 0x34,
1840  0x46, 0xfa, 0xbd, 0x21, 0xdf, 0xa5,
1841  0xa0, 0x12, 0x38, 0x7c, 0xbd, 0xd9,
1842  0xcd, 0xbc, 0xde, 0x29, 0xa5, 0x13,
1843  0xa8, 0xf0, 0xf6, 0x88, 0xc6, 0x31,
1844  0xed, 0x90, 0x19, 0x11, 0x7d, 0xe1,
1845  0x0e, 0x81, 0x98, 0x8e, 0x98, 0x86,
1846  0xde, 0x2a, 0x4c, 0xad, 0xff, 0x57,
1847  0x12, 0xbc, 0x4b, 0xaf, 0x21, 0xde,
1848  0xca, 0x3a, 0x25, 0xd7, 0x98, 0xe3,
1849  0x25, 0xbc, 0x17, 0x74, 0x0b, 0x9c,
1850  0x53, 0xe1, 0x1a, 0xec, 0x9a, 0x5a,
1851  0xdc, 0x68, 0xdf, 0xad, 0xd6, 0x71,
1852  0x6b, 0x5b, 0x8b, 0x85, 0xbb, 0xe5,
1853  0xd5, 0x14, 0x4c, 0x30, 0x27, 0x68,
1854  0xd1, 0xf7, 0x58, 0x34, 0x4c, 0xe1,
1855  0x71, 0xde, 0x7b, 0x8d, 0xa2, 0xe6,
1856  0x0a, 0x44, 0x22, 0x26, 0x5a, 0x70,
1857  0xbb, 0x68 ),
1858  BIGINT ( 0x18, 0x36, 0x96 ) );
1859  bigint_mod_exp_ok ( BIGINT ( 0xc7, 0x4a, 0xf0, 0x48 ),
1860  BIGINT ( 0x5d, 0x27, 0x07, 0x54 ),
1861  BIGINT ( 0x4a ),
1862  BIGINT ( 0x48, 0x68, 0x7b, 0xe0 ) );
1863  bigint_mod_exp_ok ( BIGINT ( 0xb4, 0x89, 0xc9, 0x5b ),
1864  BIGINT ( 0x7c, 0xd7, 0xc7, 0xff ),
1865  BIGINT ( 0xc6, 0x9c ),
1866  BIGINT ( 0x0b, 0x2d, 0xf8, 0xf7 ) );
1867  bigint_mod_exp_ok ( BIGINT ( 0xea, 0x72, 0x43, 0xfe ),
1868  BIGINT ( 0xfc, 0x57, 0x2d, 0x47 ),
1869  BIGINT ( 0x60, 0x01, 0x2c ),
1870  BIGINT ( 0x12, 0x01, 0xe3, 0xf5 ) );
1871  bigint_mod_exp_ok ( BIGINT ( 0x81, 0x7f, 0x27, 0x94 ),
1872  BIGINT ( 0x17, 0x21, 0x67, 0xab ),
1873  BIGINT ( 0x50, 0x19, 0x12, 0x52 ),
1874  BIGINT ( 0x05, 0x17, 0x6b, 0x13 ) );
1875  bigint_mod_exp_ok ( BIGINT ( 0x38, 0xab, 0xd4, 0xec ),
1876  BIGINT ( 0x0c, 0x2a, 0x56, 0x38 ),
1877  BIGINT ( 0x2f, 0x85, 0x85, 0x57, 0xf6, 0xde,
1878  0x24, 0xb4, 0x28, 0x3c, 0x5a, 0x3c,
1879  0x0b, 0x12, 0x85, 0x85, 0x85, 0x98,
1880  0x46, 0x5b, 0x9c, 0x52, 0x3a ),
1881  BIGINT ( 0x02, 0xe6, 0x6a, 0x70 ) );
1882  bigint_mod_exp_ok ( BIGINT ( 0xa6, 0x35, 0xc0, 0x6f ),
1883  BIGINT ( 0x23, 0xac, 0x78, 0x72 ),
1884  BIGINT ( 0x6a, 0x07, 0x80, 0xbf, 0x1b, 0xa5,
1885  0xf8, 0x0b, 0x90, 0x06, 0xa4, 0xa5,
1886  0x44, 0x13, 0xba, 0x4b, 0xb3, 0xce,
1887  0x9f, 0x55, 0x42, 0x56, 0xc3, 0x30,
1888  0x82, 0x85, 0x5a, 0x3b, 0xae, 0x88,
1889  0x92, 0x4e, 0x3c, 0x37, 0xf6, 0x80,
1890  0x4c, 0x03, 0x3c, 0x1e, 0x2c, 0x17,
1891  0xef, 0x9d, 0xd7, 0x6f, 0xdc, 0xbb,
1892  0x42, 0x42, 0xa1, 0x7f, 0x97, 0x66,
1893  0xcd, 0xc8, 0x8a, 0x7c, 0xc6, 0x70,
1894  0x61, 0x54, 0x82, 0xd0, 0xd0, 0x8b,
1895  0xd5, 0x4f, 0x57, 0x7b, 0x8e, 0xab,
1896  0xdc, 0xbf, 0x8e, 0x85, 0x94, 0x83,
1897  0x8a, 0xb3, 0x72, 0x69, 0x2d, 0x51,
1898  0xdd, 0x86, 0x1e, 0x58, 0xb8, 0x00,
1899  0xe2, 0x5e, 0xa7, 0xef, 0x6a, 0x6a,
1900  0xb0, 0x10, 0x3d, 0x53, 0xfe, 0x23,
1901  0x51, 0xc0, 0x51, 0xed, 0x1f, 0x02,
1902  0x4b, 0x73, 0x17, 0x59, 0xfa, 0xb9,
1903  0xa8, 0x05, 0xa7, 0x79, 0xc3, 0xc9,
1904  0x4c, 0x2d, 0x58, 0x59, 0x10, 0x99,
1905  0x71, 0xe6 ),
1906  BIGINT ( 0x01, 0x63, 0xd0, 0x07 ) );
1907  bigint_mod_exp_ok ( BIGINT ( 0xff, 0x2a, 0x37, 0x04, 0xd4, 0x08,
1908  0x9f, 0xf5, 0xac, 0x29, 0x7f, 0x4b,
1909  0x93, 0x86, 0x02, 0x26, 0xac, 0x29,
1910  0xa8, 0xf9, 0x77, 0x91, 0x20 ),
1911  BIGINT ( 0x2c, 0xb2, 0xe2, 0x1f, 0x4b, 0x97,
1912  0xaa, 0x3b, 0xd1, 0x36, 0xb0, 0x40,
1913  0x8b, 0x1c, 0x19, 0xa2, 0xea, 0xc8,
1914  0xc6, 0x4e, 0x2a, 0x66, 0x50 ),
1915  BIGINT ( 0x97 ),
1916  BIGINT ( 0x04, 0x22, 0x44, 0xe2, 0x14, 0x54,
1917  0x6c, 0x5a, 0xba, 0x1b, 0x39, 0xb7,
1918  0xaa, 0x06, 0xcf, 0x2b, 0xc8, 0x7e,
1919  0xc0, 0xe0, 0x70, 0xf2, 0x90 ) );
1920  bigint_mod_exp_ok ( BIGINT ( 0xcd, 0xf3, 0xf7, 0x50, 0x13, 0x39,
1921  0x13, 0x4a, 0x56, 0xc5, 0xb8, 0xa6,
1922  0x42, 0x2d, 0x40, 0x5e, 0x07, 0xf2,
1923  0x92, 0x2a, 0x51, 0x87, 0x20 ),
1924  BIGINT ( 0x93, 0x1a, 0x28, 0xbb, 0x69, 0x4f,
1925  0x31, 0x01, 0xe0, 0x88, 0x8a, 0x4c,
1926  0x4f, 0x9b, 0xda, 0xf6, 0x4e, 0xf3,
1927  0x11, 0xe7, 0x35, 0xa1, 0xfb ),
1928  BIGINT ( 0x66, 0x69 ),
1929  BIGINT ( 0x7a, 0x5a, 0x9b, 0x84, 0x72, 0x8f,
1930  0x57, 0x31, 0xb4, 0x34, 0x70, 0x18,
1931  0x77, 0xa6, 0x43, 0xa9, 0x51, 0x69,
1932  0x07, 0x3e, 0xf6, 0x68, 0x82 ) );
1933  bigint_mod_exp_ok ( BIGINT ( 0xdd, 0x4c, 0x85, 0xcb, 0x3f, 0x45,
1934  0x61, 0xe0, 0x58, 0x1e, 0xad, 0xd3,
1935  0x6b, 0xef, 0x82, 0x53, 0x4a, 0x16,
1936  0x1a, 0xf0, 0x09, 0x82, 0x74 ),
1937  BIGINT ( 0xd2, 0xa2, 0x73, 0x89, 0x0c, 0x56,
1938  0xe4, 0x31, 0xdf, 0x70, 0x3c, 0x40,
1939  0x0d, 0x36, 0xfc, 0x4a, 0xf3, 0xa2,
1940  0x8f, 0x9a, 0x9d, 0xaa, 0xb0 ),
1941  BIGINT ( 0xbc, 0xca, 0x45 ),
1942  BIGINT ( 0x9f, 0x5f, 0x7c, 0xac, 0x5e, 0xc7,
1943  0xf2, 0xc5, 0x72, 0x3d, 0xff, 0x29,
1944  0xd2, 0x25, 0xa9, 0x64, 0x5b, 0xbe,
1945  0x63, 0x63, 0xc6, 0x84, 0x20 ) );
1946  bigint_mod_exp_ok ( BIGINT ( 0xf8, 0xc9, 0xb9, 0x3d, 0xe1, 0xff,
1947  0xa6, 0x8e, 0xb0, 0xd2, 0xa9, 0xa9,
1948  0xc1, 0x5c, 0xc5, 0x94, 0x90, 0xb9,
1949  0xca, 0x2f, 0x1a, 0xbd, 0x21 ),
1950  BIGINT ( 0xa7, 0xf4, 0xb0, 0x3c, 0xf4, 0x2b,
1951  0x9d, 0x40, 0x5f, 0xfd, 0x2e, 0x28,
1952  0xa9, 0x23, 0x01, 0xaf, 0x0b, 0x73,
1953  0xaa, 0xcf, 0x14, 0xdc, 0xd8 ),
1954  BIGINT ( 0x31, 0xe2, 0xe8, 0xf0 ),
1955  BIGINT ( 0x53, 0x30, 0xc6, 0x10, 0x12, 0x7c,
1956  0xb3, 0x91, 0x15, 0x5f, 0x01, 0x62,
1957  0xec, 0x1f, 0x15, 0x61, 0x3b, 0x9a,
1958  0x76, 0x22, 0xf8, 0x31, 0xb1 ) );
1959  bigint_mod_exp_ok ( BIGINT ( 0xff, 0x8c, 0x04, 0x74, 0x3e, 0x93,
1960  0xfd, 0xce, 0xd5, 0x7f, 0xc5, 0x58,
1961  0xce, 0x00, 0x53, 0x44, 0x02, 0xf4,
1962  0xfd, 0x01, 0xc3, 0xb0, 0x3c ),
1963  BIGINT ( 0x2f, 0xbe, 0xb3, 0x2d, 0xd6, 0x59,
1964  0x69, 0x44, 0xc0, 0xd4, 0x27, 0x9c,
1965  0xff, 0x53, 0x9e, 0x66, 0x2c, 0x01,
1966  0x3a, 0x96, 0x5d, 0x75, 0xc1 ),
1967  BIGINT ( 0x47, 0x3e, 0xb2, 0x81, 0x51, 0x9a,
1968  0xdf, 0x75, 0xba, 0xa5, 0x19, 0xc1,
1969  0xc7, 0xcc, 0xae, 0x82, 0x9c, 0x3e,
1970  0xfd, 0x7f, 0xb0, 0xd7, 0x00 ),
1971  BIGINT ( 0x09, 0x9c, 0xd0, 0x49, 0x1d, 0x88,
1972  0xd8, 0x08, 0x45, 0x61, 0x71, 0xa1,
1973  0xb5, 0xab, 0xa9, 0x5b, 0xa8, 0xf1,
1974  0xc6, 0x53, 0x68, 0x8f, 0x3e ) );
1975  bigint_mod_exp_ok ( BIGINT ( 0xd8, 0x78, 0xad, 0x80, 0x81, 0xf1,
1976  0x84, 0x23, 0x82, 0x5d, 0x49, 0x46,
1977  0x75, 0xfd, 0xd1, 0x49, 0x53, 0x10,
1978  0x4d, 0x10, 0xab, 0x0f, 0xf0 ),
1979  BIGINT ( 0x78, 0x3d, 0x09, 0x1b, 0xea, 0xa4,
1980  0xb9, 0x13, 0xf8, 0xb5, 0xb5, 0x5e,
1981  0x69, 0xa4, 0xe1, 0xfd, 0x88, 0x58,
1982  0x26, 0xb3, 0x76, 0xa2, 0x38 ),
1983  BIGINT ( 0x3b, 0x12, 0xe0, 0x8e, 0xa2, 0x2f,
1984  0x2a, 0x2b, 0xb1, 0x78, 0xf9, 0xf6,
1985  0x93, 0x4d, 0x52, 0x82, 0x29, 0x2d,
1986  0xe4, 0x36, 0x92, 0x49, 0xc1, 0x25,
1987  0x6e, 0x26, 0xe6, 0x6e, 0xc2, 0x4d,
1988  0xea, 0x13, 0x86, 0x85, 0x71, 0x4d,
1989  0x85, 0x70, 0xf9, 0x2b, 0xa0, 0x0f,
1990  0x96, 0xe5, 0x63, 0x7a, 0xb4, 0x25,
1991  0x53, 0x1a, 0xd8, 0x30, 0x36, 0xba,
1992  0x6e, 0x2e, 0xce, 0x2d, 0x8f, 0x32,
1993  0xe9, 0xdc, 0x91, 0x9e, 0xd4, 0xf1,
1994  0x3b, 0x40, 0xc9, 0xf4, 0x97, 0x74,
1995  0x5e, 0x69, 0xcd, 0x34, 0x4a, 0x18,
1996  0x65, 0xe5, 0x07, 0xb5, 0x9e, 0x2a,
1997  0xc4, 0xeb, 0xb6, 0x96, 0x7b, 0x99,
1998  0x0c, 0xe4, 0xb3, 0x85, 0xff, 0x17,
1999  0x72, 0x5d, 0xf6, 0x30, 0xb4, 0xff,
2000  0x98, 0xe6, 0xf6, 0x31, 0x24, 0x82,
2001  0x91, 0xa6, 0x18, 0x6d, 0x0b, 0x84,
2002  0x6f, 0x5f, 0x64, 0xa3, 0xdf, 0x92,
2003  0x06, 0x16, 0xe3, 0x7c, 0x08, 0x61,
2004  0x77, 0xce ),
2005  BIGINT ( 0x17, 0xc9, 0xc5, 0x38, 0x4c, 0x15,
2006  0x0f, 0x4e, 0xc2, 0x90, 0x3b, 0x46,
2007  0x7b, 0x2f, 0x95, 0x82, 0xfe, 0x51,
2008  0x95, 0x2b, 0xff, 0xd5, 0x28 ) );
2009  bigint_mod_exp_ok ( BIGINT ( 0x69, 0xa3, 0x7e, 0x24, 0xdf, 0x9e,
2010  0x0b, 0x3e, 0x3f, 0x43, 0x06, 0x0e,
2011  0x1d, 0x57, 0x74, 0xe0, 0xa0, 0x5b,
2012  0x82, 0xca, 0xb0, 0x33, 0x8b, 0xe4,
2013  0x39, 0x27, 0x41, 0xd4, 0x2e, 0x30,
2014  0x3a, 0x0e, 0x62, 0x6f, 0xfa, 0xb4,
2015  0x02, 0x88, 0x70, 0x35, 0xa6, 0xea,
2016  0x7d, 0xb2, 0x87, 0xc3, 0xa5, 0x50,
2017  0x49, 0x38, 0xa4, 0x68, 0xa9, 0xe4,
2018  0xa6, 0xcc, 0xd7, 0x13, 0xb1, 0xd9,
2019  0x1c, 0x6a, 0x9a, 0xb8, 0x6c, 0x9b,
2020  0xff, 0xcd, 0x2c, 0xb3, 0xbd, 0xe2,
2021  0xfd, 0x1f, 0x08, 0xdd, 0xc6, 0xee,
2022  0x18, 0x0c, 0xa5, 0xcd, 0x09, 0x19,
2023  0x51, 0x51, 0xa5, 0x6f, 0x93, 0x1b,
2024  0x34, 0xfd, 0x8f, 0xd9, 0x87, 0xed,
2025  0x15, 0x7e, 0x36, 0x60, 0xdd, 0x1b,
2026  0xf4, 0xcc, 0xc4, 0x4c, 0x19, 0x2b,
2027  0xd6, 0x1e, 0xec, 0x51, 0xe9, 0x27,
2028  0xe9, 0xbd, 0x6a, 0x3f, 0x91, 0x45,
2029  0xc3, 0x6d, 0x40, 0x7e, 0x6c, 0x56,
2030  0x05, 0x5a ),
2031  BIGINT ( 0x5c, 0x96, 0x05, 0x81, 0x94, 0x45,
2032  0xcf, 0x47, 0x5f, 0x1b, 0xb0, 0xf9,
2033  0xef, 0x13, 0x8f, 0xcc, 0x71, 0xfd,
2034  0x50, 0xf1, 0xe7, 0x62, 0x6e, 0xfa,
2035  0x48, 0x66, 0x1c, 0xf7, 0xef, 0x09,
2036  0x12, 0xa2, 0xfd, 0x17, 0xb7, 0x6a,
2037  0x3b, 0xed, 0xf7, 0x86, 0xd2, 0xbe,
2038  0x95, 0x90, 0xc6, 0x00, 0x14, 0x8d,
2039  0xe3, 0x27, 0xbe, 0x03, 0x7c, 0x9e,
2040  0x6b, 0x51, 0x31, 0x8d, 0x18, 0xc4,
2041  0x16, 0xd2, 0x84, 0x63, 0x9b, 0xe9,
2042  0xa4, 0xf8, 0xff, 0x70, 0x4d, 0xeb,
2043  0x6f, 0x4a, 0xb7, 0x5b, 0x54, 0xf1,
2044  0xb5, 0xbe, 0x78, 0xb6, 0xfd, 0x8b,
2045  0xe1, 0x39, 0x62, 0x85, 0x9b, 0xde,
2046  0x30, 0xa8, 0xe4, 0x37, 0x52, 0x57,
2047  0x39, 0x79, 0xdb, 0x0b, 0x19, 0x6b,
2048  0xc9, 0x17, 0xfd, 0x8c, 0x2c, 0xaa,
2049  0xa4, 0xf1, 0x04, 0xd1, 0xd3, 0x2f,
2050  0xbb, 0x3a, 0x36, 0x82, 0x31, 0xa4,
2051  0x40, 0xd4, 0x87, 0x46, 0xe3, 0x6e,
2052  0xd0, 0x17 ),
2053  BIGINT ( 0x93 ),
2054  BIGINT ( 0x0d, 0x39, 0x92, 0x57, 0xaa, 0x6d,
2055  0xfc, 0x3b, 0x10, 0x18, 0x6d, 0x59,
2056  0xbe, 0x31, 0x8f, 0xee, 0xf9, 0x82,
2057  0x84, 0xe0, 0xdf, 0xa5, 0x00, 0x28,
2058  0xd1, 0x64, 0x6b, 0x4b, 0x43, 0x3b,
2059  0x76, 0x3e, 0x6b, 0xc4, 0xe4, 0xf5,
2060  0x0b, 0x59, 0x5a, 0xe4, 0x53, 0x5e,
2061  0x02, 0xd4, 0xde, 0x72, 0xd3, 0xa3,
2062  0x58, 0x66, 0xa7, 0xdd, 0x2b, 0x0b,
2063  0xa4, 0x83, 0xd0, 0xd9, 0xef, 0x29,
2064  0x3d, 0x2f, 0x97, 0xff, 0x9a, 0xc7,
2065  0xf6, 0x8a, 0x8d, 0x59, 0xef, 0x87,
2066  0xd1, 0xe6, 0xba, 0x4d, 0x99, 0xd9,
2067  0x5f, 0x5e, 0x7a, 0x7e, 0x67, 0x22,
2068  0x5b, 0x77, 0x83, 0xa2, 0x02, 0xfd,
2069  0xb2, 0xe4, 0xf6, 0x20, 0x4c, 0x12,
2070  0x20, 0xa7, 0xda, 0x5b, 0x3b, 0x8c,
2071  0xa2, 0xca, 0xda, 0x20, 0xaa, 0x27,
2072  0xe6, 0x54, 0x3e, 0xa8, 0x6f, 0x64,
2073  0x9d, 0xa7, 0x0d, 0x57, 0x1b, 0x21,
2074  0xff, 0xd2, 0xe2, 0xb2, 0x0a, 0x4f,
2075  0xb7, 0x0e ) );
2076  bigint_mod_exp_ok ( BIGINT ( 0x06, 0xcf, 0x54, 0xf2, 0x0d, 0x62,
2077  0x33, 0xdd, 0xe7, 0x4d, 0x7f, 0x2f,
2078  0x8e, 0x52, 0x73, 0xf4, 0x73, 0x68,
2079  0x4b, 0x13, 0x6e, 0x58, 0x6b, 0x4a,
2080  0xb8, 0x4c, 0xef, 0x73, 0xfe, 0x5f,
2081  0xf6, 0xd0, 0xbb, 0x82, 0x17, 0x3f,
2082  0x9d, 0x91, 0xf8, 0xa3, 0xb8, 0x79,
2083  0xef, 0x41, 0x38, 0xc1, 0xef, 0xc9,
2084  0xc6, 0xcf, 0x2a, 0xc3, 0xaa, 0x75,
2085  0x17, 0xda, 0xbc, 0x76, 0x29, 0x61,
2086  0x6d, 0x05, 0x79, 0x0b, 0x44, 0xb1,
2087  0x54, 0x75, 0xb7, 0xd9, 0xf6, 0xa8,
2088  0xbd, 0xf7, 0x85, 0xe0, 0xe7, 0x90,
2089  0x62, 0xce, 0x79, 0xfb, 0xc5, 0x23,
2090  0xa5, 0x09, 0xc0, 0xc4, 0x4d, 0xe7,
2091  0x9c, 0x49, 0x8f, 0x82, 0xf1, 0x31,
2092  0x34, 0x85, 0xdd, 0x3b, 0xbe, 0xe9,
2093  0x93, 0x19, 0x03, 0x75, 0x3f, 0xc4,
2094  0xa4, 0x0f, 0x52, 0x53, 0xc1, 0xcd,
2095  0x08, 0xb0, 0x05, 0x0c, 0xa2, 0x0c,
2096  0x3a, 0x72, 0xb2, 0x3c, 0xdb, 0x4f,
2097  0xac, 0xc6 ),
2098  BIGINT ( 0xe4, 0x40, 0xd8, 0x30, 0x00, 0xcf,
2099  0x4c, 0xfd, 0xda, 0xae, 0x90, 0xd3,
2100  0x5b, 0xc7, 0x20, 0xcc, 0x2b, 0xe2,
2101  0x0a, 0x39, 0x1e, 0xde, 0xef, 0x98,
2102  0x16, 0x3b, 0x9d, 0x36, 0x63, 0x0d,
2103  0x46, 0xed, 0x23, 0x6e, 0x38, 0xa8,
2104  0x15, 0xb5, 0xb1, 0xaf, 0x47, 0xb1,
2105  0xec, 0xaa, 0x8b, 0x57, 0xd6, 0xca,
2106  0x39, 0x2f, 0x62, 0xbd, 0xd5, 0xf8,
2107  0x98, 0x98, 0x5d, 0xfe, 0x14, 0xd6,
2108  0xdc, 0xe5, 0x98, 0x60, 0x5b, 0x16,
2109  0x92, 0xcb, 0xed, 0xb6, 0x9c, 0x5c,
2110  0x82, 0x40, 0x6b, 0xaa, 0x48, 0x7a,
2111  0xd4, 0xfe, 0xa3, 0xe7, 0x30, 0xf1,
2112  0x7c, 0xfb, 0x94, 0x2e, 0xeb, 0xb6,
2113  0x71, 0xe4, 0x33, 0x63, 0xc3, 0xb0,
2114  0x94, 0x6d, 0xee, 0xa5, 0x15, 0x3f,
2115  0x28, 0xf1, 0xfa, 0xdc, 0xf2, 0x13,
2116  0x0f, 0xc7, 0xd9, 0xe0, 0xbf, 0x1b,
2117  0x49, 0xee, 0x21, 0x8e, 0x26, 0xc9,
2118  0x28, 0x21, 0x86, 0x1d, 0x46, 0x33,
2119  0xd4, 0x69 ),
2120  BIGINT ( 0xd9, 0x87 ),
2121  BIGINT ( 0xdf, 0xff, 0xcc, 0xb7, 0xfe, 0x19,
2122  0x02, 0x92, 0x9d, 0xab, 0x33, 0xd2,
2123  0x21, 0xbc, 0xd3, 0xc4, 0x31, 0xad,
2124  0x4b, 0xb3, 0x16, 0x50, 0x96, 0xd9,
2125  0xdc, 0x88, 0x74, 0x60, 0xde, 0xdf,
2126  0xb7, 0x83, 0xdb, 0x22, 0xef, 0xcb,
2127  0xcb, 0xdb, 0x4c, 0xfb, 0x94, 0x4c,
2128  0x3f, 0xf5, 0xf5, 0x99, 0x85, 0x21,
2129  0x1a, 0x2b, 0xec, 0x90, 0x2d, 0xb4,
2130  0x20, 0x3c, 0x27, 0x9f, 0xe5, 0xb1,
2131  0x5c, 0x92, 0xfa, 0xb0, 0xa9, 0x8e,
2132  0x2c, 0x21, 0x8e, 0x8d, 0xe5, 0x55,
2133  0x84, 0x02, 0xa5, 0x15, 0x5c, 0x53,
2134  0x1f, 0x40, 0x81, 0x0a, 0x10, 0xde,
2135  0x21, 0x41, 0xa9, 0x97, 0xf8, 0x6f,
2136  0xbf, 0x42, 0x58, 0x9e, 0xc6, 0xdd,
2137  0x10, 0x33, 0x3f, 0xad, 0xe6, 0x8e,
2138  0x57, 0x27, 0x37, 0x20, 0xa4, 0x86,
2139  0xef, 0x39, 0x7b, 0x6f, 0x78, 0x77,
2140  0xab, 0xa0, 0x62, 0xe1, 0xfd, 0x9c,
2141  0xbe, 0xfa, 0x98, 0x2e, 0x29, 0xe3,
2142  0xeb, 0x52 ) );
2143  bigint_mod_exp_ok ( BIGINT ( 0x00, 0x91, 0xb3, 0x87, 0xe6, 0x01,
2144  0x57, 0xe9, 0x68, 0xa4, 0xf4, 0x9b,
2145  0xea, 0x6a, 0x8a, 0x9e, 0x1a, 0x8b,
2146  0xd3, 0x85, 0x9d, 0xba, 0x85, 0xab,
2147  0xd8, 0xcd, 0x25, 0x56, 0x8e, 0x85,
2148  0x8a, 0x8e, 0x48, 0x9e, 0xb4, 0x90,
2149  0xc8, 0x2e, 0x07, 0x78, 0x80, 0x49,
2150  0xa0, 0xb7, 0x95, 0x6a, 0xd8, 0xad,
2151  0xb5, 0xda, 0x5d, 0xe6, 0x11, 0x87,
2152  0xb8, 0x33, 0x8f, 0xa8, 0x6f, 0x4e,
2153  0xc6, 0xc3, 0x0d, 0xf5, 0xa9, 0x4e,
2154  0xb2, 0x42, 0x53, 0x81, 0xcd, 0x33,
2155  0x83, 0x49, 0xab, 0x0d, 0x0e, 0xf5,
2156  0x2c, 0xcd, 0x84, 0x58, 0xf3, 0x30,
2157  0xa3, 0x6e, 0x3c, 0x3a, 0xc6, 0x77,
2158  0x43, 0xb0, 0xe7, 0x4b, 0x66, 0x30,
2159  0xe9, 0x48, 0x0b, 0x0d, 0x86, 0x3f,
2160  0xd8, 0xe2, 0xb5, 0x88, 0xc1, 0x44,
2161  0xb2, 0x6b, 0xb0, 0x7a, 0x35, 0x3b,
2162  0x56, 0x83, 0xb1, 0xac, 0x9e, 0xeb,
2163  0x9b, 0x08, 0x43, 0xac, 0x0a, 0x3a,
2164  0x31, 0x69 ),
2165  BIGINT ( 0x96, 0x6f, 0xb0, 0xa7, 0x02, 0xb5,
2166  0xd9, 0x19, 0xbe, 0x4b, 0x27, 0x65,
2167  0x5b, 0x96, 0xd4, 0x0b, 0x49, 0x70,
2168  0xf0, 0x09, 0x8e, 0xf2, 0x04, 0x85,
2169  0x93, 0xe9, 0x2e, 0x09, 0x31, 0x76,
2170  0x8b, 0xbb, 0xe9, 0xe1, 0x2b, 0x4f,
2171  0xed, 0x83, 0xa6, 0x87, 0xa3, 0x07,
2172  0x0a, 0x3d, 0x1c, 0x65, 0x14, 0x5a,
2173  0xd5, 0xc0, 0x5d, 0x3c, 0x31, 0x9a,
2174  0x83, 0xad, 0xca, 0x6a, 0x93, 0x0d,
2175  0x1a, 0x67, 0x4e, 0x68, 0x06, 0x64,
2176  0x53, 0x2e, 0x15, 0xd9, 0xdd, 0x5e,
2177  0xcb, 0xb7, 0x2e, 0xef, 0xd3, 0xbb,
2178  0x5f, 0xaf, 0xef, 0x9e, 0xf2, 0x7b,
2179  0x69, 0x15, 0xb0, 0x18, 0x6c, 0x67,
2180  0x10, 0xda, 0x33, 0x07, 0x48, 0x97,
2181  0x31, 0xb3, 0x3d, 0x3d, 0xc9, 0x2e,
2182  0x0b, 0x68, 0x91, 0x3f, 0x6a, 0x3b,
2183  0x1a, 0xdf, 0xa8, 0x69, 0x46, 0x1c,
2184  0xb2, 0x69, 0x08, 0x0b, 0x02, 0x1b,
2185  0x03, 0x64, 0xae, 0xb6, 0x2d, 0xc6,
2186  0xc4, 0x0a ),
2187  BIGINT ( 0x6d, 0x3f, 0xdd ),
2188  BIGINT ( 0x40, 0x6e, 0x9d, 0x3e, 0xeb, 0xa4,
2189  0xb1, 0x8d, 0xb7, 0xb4, 0x0f, 0x5b,
2190  0x12, 0xad, 0x27, 0x9e, 0xbd, 0xe7,
2191  0xe5, 0x9d, 0xec, 0xb4, 0xac, 0x23,
2192  0x5f, 0xa9, 0xec, 0x9c, 0xd1, 0x6a,
2193  0xbe, 0x99, 0xba, 0xb3, 0x66, 0x0e,
2194  0x17, 0xaa, 0x13, 0xa2, 0x2e, 0x01,
2195  0x28, 0xb1, 0x6c, 0xba, 0xad, 0x68,
2196  0x48, 0xf0, 0xf3, 0x4c, 0x08, 0x9f,
2197  0xd1, 0x9c, 0xb7, 0x75, 0xc5, 0xb6,
2198  0x5a, 0x05, 0xb0, 0x14, 0xd4, 0x61,
2199  0xea, 0x18, 0x9f, 0xe6, 0xe5, 0xe3,
2200  0xd4, 0xff, 0x35, 0x43, 0x0b, 0xb8,
2201  0xf6, 0xe9, 0x19, 0x7a, 0x88, 0xa7,
2202  0x4d, 0x01, 0x92, 0x05, 0xd2, 0x6e,
2203  0xa3, 0xc1, 0xb6, 0x66, 0x75, 0xb1,
2204  0x00, 0x0d, 0x42, 0x37, 0xcc, 0xca,
2205  0xc0, 0x8d, 0xc8, 0x7e, 0x5c, 0xc9,
2206  0x53, 0x81, 0x2f, 0xc4, 0x61, 0xb6,
2207  0x96, 0x3b, 0xa5, 0x04, 0x14, 0x1b,
2208  0xa7, 0x77, 0xa1, 0xbc, 0x73, 0x1d,
2209  0xad, 0xed ) );
2210  bigint_mod_exp_ok ( BIGINT ( 0x45, 0xfb, 0xf3, 0xdc, 0x31, 0xe5,
2211  0x56, 0x7a, 0xee, 0x15, 0xfb, 0x16,
2212  0xee, 0x6e, 0x90, 0x3e, 0xa3, 0x89,
2213  0xc2, 0x6d, 0x9b, 0x06, 0x65, 0xd0,
2214  0xcd, 0xa2, 0xcc, 0x01, 0x60, 0x0d,
2215  0xd1, 0xdd, 0x68, 0x14, 0xc2, 0xcd,
2216  0xd8, 0x79, 0x75, 0xad, 0x0a, 0x9f,
2217  0x39, 0x5f, 0x52, 0x4b, 0x58, 0x31,
2218  0x48, 0xbb, 0x2a, 0xcc, 0xe0, 0x42,
2219  0x18, 0x32, 0xdc, 0x63, 0x14, 0x11,
2220  0x4e, 0xab, 0x96, 0x29, 0xc5, 0x06,
2221  0x79, 0xe5, 0x06, 0xf7, 0x59, 0xdb,
2222  0x1e, 0x51, 0xfd, 0xc4, 0x48, 0x3a,
2223  0x4c, 0x7f, 0xd0, 0xe2, 0x36, 0x86,
2224  0xc1, 0x8b, 0xc5, 0x86, 0x52, 0xe0,
2225  0xdb, 0x92, 0x5f, 0x0e, 0x19, 0xb1,
2226  0xa3, 0x23, 0xdd, 0xf0, 0x78, 0xcc,
2227  0x81, 0x3f, 0x4a, 0xe6, 0xb0, 0x32,
2228  0xd1, 0x5c, 0x5e, 0x3a, 0xb0, 0xd8,
2229  0xe2, 0x04, 0xc0, 0x30, 0x85, 0x1d,
2230  0x5e, 0x28, 0xee, 0xd9, 0xb3, 0x83,
2231  0x9f, 0xe2 ),
2232  BIGINT ( 0xb3, 0x2c, 0x2e, 0xc5, 0xba, 0xf8,
2233  0x41, 0x98, 0x79, 0x7e, 0xaa, 0x0c,
2234  0x2a, 0x8f, 0xd9, 0x56, 0x55, 0xaa,
2235  0x74, 0x60, 0x74, 0xd1, 0x49, 0x2c,
2236  0x6f, 0x0a, 0x4e, 0xf8, 0x3f, 0x1b,
2237  0x73, 0x4c, 0xe0, 0x17, 0x37, 0x06,
2238  0x76, 0x73, 0xd5, 0x2d, 0x4d, 0x3f,
2239  0xb0, 0x15, 0x7e, 0x98, 0xd0, 0xdf,
2240  0xf0, 0x33, 0x78, 0xe2, 0xe6, 0xec,
2241  0x21, 0x22, 0xad, 0xd5, 0xab, 0x2d,
2242  0x0d, 0x59, 0x95, 0x05, 0x34, 0x1f,
2243  0x51, 0xf5, 0xec, 0x93, 0x05, 0x15,
2244  0x37, 0xcf, 0x93, 0x03, 0xd7, 0xf6,
2245  0x35, 0x23, 0x8f, 0x33, 0xf6, 0xba,
2246  0x42, 0xc8, 0x52, 0x94, 0xd3, 0x33,
2247  0x3e, 0x39, 0x01, 0xd1, 0x55, 0x3f,
2248  0x48, 0x84, 0xe9, 0xbc, 0x0b, 0x0f,
2249  0xc9, 0x69, 0x41, 0x2c, 0x5f, 0x34,
2250  0xd0, 0xe6, 0x15, 0x50, 0x06, 0x64,
2251  0x5b, 0x8b, 0x71, 0x22, 0xb3, 0x3e,
2252  0x09, 0x9c, 0x76, 0x13, 0x9b, 0x29,
2253  0x57, 0x94 ),
2254  BIGINT ( 0xca, 0x94, 0xf7, 0xca ),
2255  BIGINT ( 0x83, 0x68, 0xb9, 0xe7, 0x91, 0xf3,
2256  0x3b, 0x5a, 0x0b, 0xb6, 0x1e, 0x2f,
2257  0x3f, 0x5f, 0xdc, 0x96, 0x5b, 0x7f,
2258  0x8d, 0xc5, 0x8e, 0xda, 0x6e, 0x21,
2259  0xe3, 0x20, 0xea, 0x37, 0x39, 0x3b,
2260  0xb4, 0xd7, 0xf6, 0xba, 0x61, 0xfe,
2261  0xdc, 0x7e, 0x82, 0x9a, 0x38, 0x7b,
2262  0xd5, 0xb1, 0x11, 0x98, 0xc4, 0x88,
2263  0x0b, 0x01, 0x7d, 0x81, 0xc9, 0x64,
2264  0x23, 0xc3, 0x3e, 0xf3, 0x67, 0x95,
2265  0x78, 0xca, 0xda, 0x52, 0xaf, 0x72,
2266  0x25, 0xd9, 0xf0, 0x27, 0xd3, 0x1c,
2267  0xfb, 0xad, 0xa1, 0xa7, 0x06, 0x2f,
2268  0xaa, 0x2f, 0x86, 0x5c, 0x8b, 0x30,
2269  0xe1, 0xda, 0x5a, 0x36, 0xf9, 0xfd,
2270  0xbf, 0xfe, 0x0d, 0x03, 0xf8, 0x9c,
2271  0x6b, 0x9b, 0xe5, 0x70, 0x6d, 0x75,
2272  0xd7, 0x54, 0x28, 0x43, 0x34, 0x69,
2273  0x98, 0x11, 0x29, 0xee, 0x50, 0x06,
2274  0xa4, 0xc4, 0x11, 0x6d, 0x60, 0x8c,
2275  0xcd, 0xd1, 0x88, 0xe9, 0x6b, 0xbb,
2276  0xc1, 0xd4 ) );
2277  bigint_mod_exp_ok ( BIGINT ( 0xa1, 0x01, 0x7e, 0xb4, 0x0e, 0x66,
2278  0xa5, 0x07, 0x8b, 0x10, 0x84, 0x0d,
2279  0x30, 0x0a, 0xa4, 0x2d, 0x10, 0x2c,
2280  0xd4, 0x9a, 0x27, 0xf1, 0x02, 0x8c,
2281  0x38, 0x18, 0x7f, 0x7f, 0x95, 0x65,
2282  0xf1, 0xa9, 0x3b, 0x7d, 0x1f, 0x4f,
2283  0x88, 0xb0, 0x65, 0x62, 0x63, 0x63,
2284  0xaa, 0x82, 0xfc, 0x83, 0x3a, 0x3a,
2285  0x46, 0x59, 0x6a, 0x89, 0xec, 0xa9,
2286  0xb0, 0x4c, 0x5e, 0xbe, 0x46, 0x98,
2287  0xd0, 0xd4, 0xb7, 0xe3, 0x1b, 0x30,
2288  0x0b, 0xfb, 0xbb, 0x4f, 0x0b, 0xd3,
2289  0xe4, 0xa0, 0x80, 0x54, 0xcb, 0x52,
2290  0x0a, 0xe8, 0x03, 0x75, 0x8e, 0x96,
2291  0xa4, 0x21, 0xaa, 0xbd, 0x7a, 0xfd,
2292  0xfa, 0xf8, 0xaf, 0x42, 0xf6, 0x61,
2293  0xd2, 0x93, 0xce, 0x66, 0x67, 0xe9,
2294  0x02, 0xda, 0x81, 0x0b, 0xb0, 0x1e,
2295  0x9e, 0x27, 0x57, 0x98, 0x18, 0x88,
2296  0x35, 0x49, 0xc0, 0x88, 0x88, 0x59,
2297  0xae, 0x2f, 0x66, 0x59, 0x31, 0x87,
2298  0x88, 0xda ),
2299  BIGINT ( 0xfe, 0x21, 0x7c, 0xf4, 0xbe, 0xae,
2300  0x65, 0xda, 0x89, 0xd2, 0x26, 0xd6,
2301  0x9c, 0x65, 0xc6, 0xb6, 0xb4, 0x0a,
2302  0x84, 0x11, 0xe1, 0xe8, 0xba, 0xd8,
2303  0x16, 0xcf, 0x60, 0x6c, 0x83, 0xa5,
2304  0x4a, 0xbf, 0xa2, 0x24, 0x0b, 0x66,
2305  0xda, 0xe2, 0x4e, 0x2d, 0xe5, 0x9e,
2306  0xbf, 0xad, 0x5c, 0xa3, 0x1e, 0x5c,
2307  0xbd, 0xe2, 0x5b, 0x46, 0xcf, 0xcc,
2308  0xd5, 0xc9, 0x13, 0x95, 0xc3, 0xdb,
2309  0x64, 0xbf, 0xeb, 0x31, 0xa9, 0x8a,
2310  0x3b, 0xd2, 0x5d, 0x3b, 0x2e, 0xdc,
2311  0x0c, 0xca, 0xab, 0xde, 0x92, 0xae,
2312  0x45, 0x35, 0x96, 0xb0, 0xb7, 0xb9,
2313  0xe6, 0xfe, 0x28, 0x0d, 0x10, 0x72,
2314  0x53, 0x8e, 0x21, 0xc0, 0x33, 0x79,
2315  0x01, 0x43, 0x8d, 0x77, 0xc4, 0xaa,
2316  0xcf, 0x7f, 0xc3, 0xd1, 0xf5, 0xfd,
2317  0x79, 0x81, 0xf6, 0x2e, 0xb7, 0xeb,
2318  0x55, 0x5f, 0x74, 0xf0, 0x3a, 0xb9,
2319  0x57, 0x07, 0x09, 0x97, 0xa5, 0x4c,
2320  0x4a, 0x85 ),
2321  BIGINT ( 0xd9, 0xb7, 0xb2, 0xd6, 0xeb, 0xf3,
2322  0x66, 0xbe, 0x15, 0x64, 0xad, 0x2e,
2323  0x9e, 0xc6, 0xaf, 0x5e, 0xaf, 0x40,
2324  0x1e, 0x90, 0x82, 0x2f, 0x98 ),
2325  BIGINT ( 0x12, 0x48, 0x31, 0x7f, 0x09, 0xbb,
2326  0x8f, 0xd9, 0x02, 0x7e, 0x4a, 0xd0,
2327  0x2f, 0x42, 0x7c, 0x17, 0x6e, 0x83,
2328  0x74, 0x21, 0x95, 0x47, 0x7d, 0x93,
2329  0x4a, 0xce, 0x34, 0x7c, 0xde, 0xc7,
2330  0x8f, 0xf6, 0x28, 0x97, 0xba, 0x81,
2331  0x9b, 0xcc, 0x54, 0x14, 0x7f, 0xd3,
2332  0x93, 0x66, 0x41, 0x8c, 0x0e, 0x47,
2333  0xee, 0xc5, 0x5e, 0xd6, 0x5f, 0x01,
2334  0x62, 0x97, 0xf1, 0x2b, 0xee, 0x60,
2335  0x5e, 0x82, 0x2c, 0x7b, 0x0a, 0xf2,
2336  0xc3, 0x23, 0xbf, 0xb9, 0x83, 0xf7,
2337  0x97, 0xf5, 0xca, 0x58, 0xd7, 0xf0,
2338  0x87, 0x7b, 0xcb, 0x87, 0x69, 0x42,
2339  0xbc, 0x05, 0xc4, 0xad, 0xbd, 0x82,
2340  0xcf, 0x44, 0x16, 0x4f, 0x46, 0xe0,
2341  0xde, 0x2f, 0xfa, 0x77, 0xec, 0xa4,
2342  0x23, 0x7d, 0x47, 0x3e, 0x94, 0x19,
2343  0x8b, 0xb8, 0x84, 0x81, 0x80, 0x6c,
2344  0x1e, 0x31, 0xa3, 0x6d, 0x14, 0x94,
2345  0x57, 0x28, 0x99, 0x08, 0x0a, 0xa7,
2346  0x98, 0x4b ) );
2347  bigint_mod_exp_ok ( BIGINT ( 0xda, 0x52, 0xfd, 0x44, 0x5d, 0x11,
2348  0x60, 0x6c, 0xec, 0x87, 0xbf, 0x19,
2349  0xb8, 0x46, 0xaa, 0x41, 0xfc, 0x10,
2350  0xae, 0x47, 0xd6, 0x72, 0x42, 0x57,
2351  0xc3, 0x05, 0xca, 0xe3, 0x59, 0x94,
2352  0x82, 0x7c, 0xa1, 0xe0, 0xd2, 0x6b,
2353  0x77, 0x71, 0x42, 0xa1, 0xf7, 0x84,
2354  0xae, 0xf4, 0x6f, 0x44, 0x0d, 0x88,
2355  0xa2, 0xc5, 0x45, 0x9b, 0x49, 0x36,
2356  0xd4, 0x20, 0x3a, 0x7c, 0x92, 0xdb,
2357  0x65, 0xd9, 0x20, 0xd6, 0x71, 0x22,
2358  0x90, 0x70, 0xbf, 0xf3, 0x17, 0xe8,
2359  0x2c, 0x10, 0xe9, 0x4c, 0x02, 0x69,
2360  0x37, 0xa2, 0x91, 0x04, 0x46, 0x11,
2361  0xdc, 0xab, 0x5b, 0x1e, 0x3e, 0x31,
2362  0xd8, 0x69, 0xf8, 0x48, 0x84, 0x1f,
2363  0x56, 0x46, 0xf1, 0xc0, 0x14, 0x3f,
2364  0xcc, 0x5d, 0xe2, 0xf7, 0x8b, 0xa4,
2365  0x9e, 0x94, 0x32, 0xaa, 0x3c, 0x5e,
2366  0x21, 0x70, 0x00, 0x24, 0x2a, 0x1b,
2367  0xec, 0x25, 0xb1, 0xb6, 0x83, 0x36,
2368  0x5a, 0x95 ),
2369  BIGINT ( 0x5e, 0xdc, 0x71, 0x1f, 0x5b, 0x55,
2370  0xaa, 0xda, 0x56, 0xf5, 0x93, 0x9b,
2371  0xe8, 0xfc, 0x6a, 0x80, 0xe1, 0xe3,
2372  0x93, 0xe4, 0xc0, 0x58, 0x6f, 0x22,
2373  0xce, 0x9d, 0x6f, 0x84, 0x4c, 0xd4,
2374  0x12, 0x44, 0x57, 0x25, 0xca, 0xe5,
2375  0x2b, 0x7c, 0x35, 0x88, 0xc7, 0x38,
2376  0x25, 0x20, 0x9b, 0x57, 0xf2, 0xf2,
2377  0x6c, 0x28, 0x47, 0x9c, 0x3f, 0x91,
2378  0x1e, 0x3f, 0xe9, 0xeb, 0x50, 0xd6,
2379  0xa7, 0x22, 0x88, 0x6c, 0x71, 0xe5,
2380  0x62, 0x2a, 0xb7, 0xce, 0xbe, 0xf7,
2381  0x1a, 0x8c, 0x52, 0xa6, 0xff, 0xb8,
2382  0x34, 0x83, 0x7e, 0x04, 0xa8, 0x9c,
2383  0xa8, 0xa7, 0xd1, 0x05, 0x8e, 0x13,
2384  0x03, 0xe0, 0x49, 0xd8, 0x4a, 0xc4,
2385  0x4d, 0x38, 0x21, 0x5b, 0x62, 0xc2,
2386  0x38, 0x23, 0x7c, 0x9e, 0xf1, 0xe9,
2387  0xb6, 0x9a, 0x75, 0x42, 0x14, 0x99,
2388  0x63, 0x36, 0x13, 0x4c, 0x2d, 0x3a,
2389  0x77, 0xd4, 0x74, 0xb7, 0x30, 0xb2,
2390  0x00, 0x0f ),
2391  BIGINT ( 0xe3, 0xe5, 0x3b, 0xb5, 0x92, 0x5a,
2392  0xc6, 0xfa, 0x8f, 0xe8, 0x00, 0xb9,
2393  0x5c, 0xa0, 0xb6, 0x3e, 0x5e, 0x14,
2394  0x12, 0xa9, 0xdd, 0x2a, 0x3d, 0x4d,
2395  0xa3, 0x91, 0x6a, 0x56, 0x99, 0xc2,
2396  0x6c, 0x8e, 0xda, 0xb0, 0x5a, 0x2a,
2397  0x37, 0x55, 0x8b, 0xd3, 0x9b, 0xb6,
2398  0x1d, 0x49, 0x7d, 0x81, 0x76, 0x1c,
2399  0x2e, 0xb9, 0x92, 0x6d, 0xfa, 0x54,
2400  0x53, 0xfc, 0x74, 0x9b, 0x6b, 0x63,
2401  0x95, 0x1a, 0x89, 0xcc, 0xbd, 0x36,
2402  0xc5, 0x31, 0x7f, 0xf5, 0x31, 0x69,
2403  0x40, 0xd5, 0x7b, 0x94, 0x5d, 0xa9,
2404  0xd1, 0x34, 0x95, 0xa1, 0x8b, 0xa5,
2405  0xb5, 0x83, 0xda, 0xb5, 0x9d, 0x5b,
2406  0x74, 0x41, 0xad, 0x81, 0x45, 0x40,
2407  0x9b, 0xc3, 0xe8, 0xfe, 0x47, 0xdc,
2408  0xb0, 0xc3, 0x34, 0x5d, 0xf6, 0x3c,
2409  0x1d, 0x07, 0x76, 0xd9, 0x25, 0xca,
2410  0xa2, 0x39, 0x6c, 0xa8, 0xae, 0x30,
2411  0x4a, 0xde, 0xfb, 0xeb, 0x19, 0x80,
2412  0x5e, 0x49 ),
2413  BIGINT ( 0x4b, 0x0e, 0x74, 0xb8, 0xa7, 0x92,
2414  0x74, 0xd9, 0x50, 0xf6, 0x1b, 0x67,
2415  0x76, 0x76, 0x56, 0x6c, 0x09, 0x9c,
2416  0x01, 0xda, 0xaf, 0xa3, 0xca, 0xb2,
2417  0x12, 0x85, 0x52, 0x24, 0xe9, 0x7e,
2418  0x2b, 0xf2, 0x6e, 0xe9, 0x1a, 0x10,
2419  0x5d, 0xa0, 0x25, 0x46, 0x8f, 0x2a,
2420  0x95, 0x62, 0x50, 0xb6, 0x66, 0x43,
2421  0x37, 0x8b, 0xcb, 0x05, 0xf8, 0x61,
2422  0x59, 0xf9, 0xdd, 0xd2, 0x68, 0x72,
2423  0xfa, 0x88, 0x13, 0x36, 0xd8, 0x24,
2424  0x73, 0xec, 0x47, 0x44, 0xdd, 0x45,
2425  0x8a, 0x59, 0xd2, 0xbd, 0x43, 0xe3,
2426  0x05, 0x16, 0xd5, 0x9b, 0x1c, 0x8a,
2427  0x4b, 0x07, 0xda, 0x58, 0x0d, 0x4a,
2428  0x4e, 0xe7, 0x15, 0xfc, 0xbd, 0x95,
2429  0xf7, 0x18, 0xa5, 0xa7, 0x93, 0xff,
2430  0xf8, 0x1f, 0xd4, 0x6b, 0x07, 0xc6,
2431  0x5d, 0x90, 0x73, 0x57, 0x57, 0x37,
2432  0xfa, 0x83, 0xd4, 0x7c, 0xe9, 0x77,
2433  0x46, 0x91, 0x3a, 0x50, 0x0d, 0x6a,
2434  0x25, 0xd0 ) );
2435 }
BIGINT
#define BIGINT(...)
Define inline big integer.
Definition: bigint_test.c:41
bigint_is_zero_ok
#define bigint_is_zero_ok(value, expected)
Report result of big integer zero comparison test.
Definition: bigint_test.c:328
bigint_is_geq_ok
#define bigint_is_geq_ok(value, reference, expected)
Report result of big integer greater-than-or-equal comparison test.
Definition: bigint_test.c:351
bigint_add_ok
#define bigint_add_ok(addend, value, expected)
Report result of big integer addition test.
Definition: bigint_test.c:209
bigint_rol_ok
#define bigint_rol_ok(value, expected)
Report result of big integer left rotation test.
Definition: bigint_test.c:276
bigint_ror_ok
#define bigint_ror_ok(value, expected)
Report result of big integer right rotation test.
Definition: bigint_test.c:302
bigint_mod_multiply_ok
#define bigint_mod_multiply_ok(multiplicand, multiplier, modulus, expected)
Report result of big integer modular multiplication test.
Definition: bigint_test.c:468
bigint_max_set_bit_ok
#define bigint_max_set_bit_ok(value, expected)
Report result of big integer maximum set bit test.
Definition: bigint_test.c:405
bigint_bit_is_set_ok
#define bigint_bit_is_set_ok(value, bit, expected)
Report result of big integer bit-set test.
Definition: bigint_test.c:382
bigint_multiply_ok
#define bigint_multiply_ok(multiplicand, multiplier, expected)
Report result of big integer multiplication test.
Definition: bigint_test.c:428
bigint_subtract_ok
#define bigint_subtract_ok(subtrahend, value, expected)
Report result of big integer subtraction test.
Definition: bigint_test.c:243
bigint_mod_exp_ok
#define bigint_mod_exp_ok(base, modulus, exponent, expected)
Report result of big integer modular exponentiation test.
Definition: bigint_test.c:518

References BIGINT, bigint_add_ok, bigint_bit_is_set_ok, bigint_is_geq_ok, bigint_is_zero_ok, bigint_max_set_bit_ok, bigint_mod_exp_ok, bigint_mod_multiply_ok, bigint_multiply_ok, bigint_rol_ok, bigint_ror_ok, and bigint_subtract_ok.

Variable Documentation

◆ __self_test

struct self_test bigint_test __self_test
Initial value:
= {
.name = "bigint",
.exec = bigint_test_exec,
}
bigint_test_exec
static void bigint_test_exec(void)
Perform big integer self-tests.
Definition: bigint_test.c:563

Big integer self-test.

Definition at line 2438 of file bigint_test.c.

Generated by   doxygen 1.8.15