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_swap_ok(first, second)
 Report result of big integer swap 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_copy_sample (const bigint_element_t *source0, bigint_element_t *dest0, unsigned int size)
 
void bigint_swap_sample (bigint_element_t *first0, bigint_element_t *second0, unsigned int size, int swap)
 
void bigint_multiply_sample (const bigint_element_t *multiplicand0, unsigned int multiplicand_size, const bigint_element_t *multiplier0, unsigned int multiplier_size, bigint_element_t *result0)
 
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:40
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 231 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:40
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 265 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:50
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 298 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:50
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 324 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:50
bigint_is_zero
#define bigint_is_zero(value)
Test if big integer is equal to zero.
Definition: bigint.h:118
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 350 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:129
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:40
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 373 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:50
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:141

Report result of big integer bit-set test.

Parameters
valueBig integer
bitBit to test
expectedExpected result

Definition at line 404 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:151
bigint_init
#define bigint_init(value, data, len)
Initialise big integer.
Definition: bigint.h:50
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 427 of file bigint_test.c.

◆ bigint_swap_ok

#define bigint_swap_ok (   first,
  second 
)
Value:
do { \
static const uint8_t first_raw[] = first; \
static const uint8_t second_raw[] = second; \
uint8_t temp[ sizeof ( first_raw ) ]; \
unsigned int size = bigint_required_size ( sizeof ( temp) ); \
bigint_t ( size ) first_temp; \
bigint_t ( size ) second_temp; \
{} /* Fix emacs alignment */ \
\
assert ( sizeof ( first_raw ) == sizeof ( temp ) ); \
assert ( sizeof ( second_raw ) == sizeof ( temp ) ); \
bigint_init ( &first_temp, first_raw, sizeof ( first_raw ) ); \
bigint_init ( &second_temp, second_raw, sizeof ( second_raw ) );\
bigint_swap ( &first_temp, &second_temp, 0 ); \
bigint_done ( &first_temp, temp, sizeof ( temp ) ); \
ok ( memcmp ( temp, first_raw, sizeof ( temp ) ) == 0 ); \
bigint_done ( &second_temp, temp, sizeof ( temp ) ); \
ok ( memcmp ( temp, second_raw, sizeof ( temp ) ) == 0 ); \
bigint_swap ( &first_temp, &second_temp, 1 ); \
bigint_done ( &first_temp, temp, sizeof ( temp ) ); \
ok ( memcmp ( temp, second_raw, sizeof ( temp ) ) == 0 ); \
bigint_done ( &second_temp, temp, sizeof ( temp ) ); \
ok ( memcmp ( temp, first_raw, sizeof ( temp ) ) == 0 ); \
bigint_swap ( &first_temp, &second_temp, 1 ); \
bigint_done ( &first_temp, temp, sizeof ( temp ) ); \
ok ( memcmp ( temp, first_raw, sizeof ( temp ) ) == 0 ); \
bigint_done ( &second_temp, temp, sizeof ( temp ) ); \
ok ( memcmp ( temp, second_raw, sizeof ( temp ) ) == 0 ); \
} while ( 0 )
second
static __always_inline int off_t userptr_t second
Definition: efi_uaccess.h:80
assert
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
bigint_required_size
#define bigint_required_size(len)
Determine number of elements required for a big-integer type.
Definition: bigint.h:30
uint8_t
unsigned char uint8_t
Definition: stdint.h:10
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
memcmp
int memcmp(const void *first, const void *second, size_t len)
Compare memory regions.
Definition: string.c:114
first
uint32_t first
Length to skip in first segment.
Definition: pccrc.h:23

Report result of big integer swap test.

Parameters
firstBig integer to be conditionally swapped
secondBig integer to be conditionally swapped

Definition at line 449 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 486 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 527 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 577 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:50
value0
static uint32_t * value0
Definition: bigint.h:57
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
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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_done
#define bigint_done(value, out, len)
Finalise big integer.
Definition: bigint.h:63
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
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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
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:74
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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
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:85
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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
value
pseudo_bit_t value[0x00020]
Definition: arbel.h:13
bigint_rol
#define bigint_rol(value)
Rotate big integer left.
Definition: bigint.h:96
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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:106
value0
static uint32_t * value0
Definition: bigint.h:57
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_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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:118
value0
static uint32_t * value0
Definition: bigint.h:57
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_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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:129
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_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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
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:141
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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:151
value0
static uint32_t * value0
Definition: bigint.h:57
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_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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:161
dest_size
static unsigned int uint32_t unsigned int dest_size
Definition: bigint.h:253
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
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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:174
dest_size
static unsigned int uint32_t unsigned int dest_size
Definition: bigint.h:253
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
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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

◆ bigint_copy_sample()

void bigint_copy_sample ( const bigint_element_t *  source0,
bigint_element_t *  dest0,
unsigned int  size 
)

Definition at line 152 of file bigint_test.c.

153  {
154  const bigint_t ( size ) *source __attribute__ (( may_alias ))
155  = ( ( const void * ) source0 );
156  bigint_t ( size ) *dest __attribute__ (( may_alias ))
157  = ( ( void * ) dest0 );
158 
159  bigint_copy ( source, dest );
160 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
bigint_copy
#define bigint_copy(source, dest)
Copy big integer.
Definition: bigint.h:187
dest
static void * dest
Definition: strings.h:176
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
dest0
static unsigned int uint32_t * dest0
Definition: bigint.h:252
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

References __attribute__, bigint_copy, bigint_t(), dest, dest0, and size.

◆ bigint_swap_sample()

void bigint_swap_sample ( bigint_element_t *  first0,
bigint_element_t *  second0,
unsigned int  size,
int  swap 
)

Definition at line 162 of file bigint_test.c.

163  {
164  bigint_t ( size ) *first __attribute__ (( may_alias ))
165  = ( ( void * ) first0 );
166  bigint_t ( size ) *second __attribute__ (( may_alias ))
167  = ( ( void * ) second0 );
168 
169  bigint_swap ( first, second, swap );
170 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
second
static __always_inline int off_t userptr_t second
Definition: efi_uaccess.h:80
bigint_swap
#define bigint_swap(first, second, swap)
Conditionally swap big integers (in constant time)
Definition: bigint.h:199
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
first
uint32_t first
Length to skip in first segment.
Definition: pccrc.h:23
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

References __attribute__, bigint_swap, bigint_t(), first, second, and size.

◆ bigint_multiply_sample()

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

Definition at line 172 of file bigint_test.c.

176  {
177  unsigned int result_size = ( multiplicand_size + multiplier_size );
178  const bigint_t ( multiplicand_size ) __attribute__ (( may_alias ))
179  *multiplicand = ( ( const void * ) multiplicand0 );
180  const bigint_t ( multiplier_size ) __attribute__ (( may_alias ))
181  *multiplier = ( ( const void * ) multiplier0 );
182  bigint_t ( result_size ) __attribute__ (( may_alias ))
183  *result = ( ( void * ) result0 );
184 
185  bigint_multiply ( multiplicand, multiplier, result );
186 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
result
static const void const void void * result
Definition: crypto.h:335
multiplier
uint8_t multiplier
Port multiplier number.
Definition: edd.h:32
bigint_multiply
#define bigint_multiply(multiplicand, multiplier, result)
Multiply big integers.
Definition: bigint.h:212
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

References __attribute__, bigint_multiply, bigint_t(), multiplier, and result.

◆ 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 188 of file bigint_test.c.

193  {
194  const bigint_t ( size ) *multiplicand __attribute__ (( may_alias ))
195  = ( ( const void * ) multiplicand0 );
196  const bigint_t ( size ) *multiplier __attribute__ (( may_alias ))
197  = ( ( const void * ) multiplier0 );
198  const bigint_t ( size ) *modulus __attribute__ (( may_alias ))
199  = ( ( const void * ) modulus0 );
200  bigint_t ( size ) *result __attribute__ (( may_alias ))
201  = ( ( void * ) result0 );
202 
203  bigint_mod_multiply ( multiplicand, multiplier, modulus, result, tmp );
204 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
result
static const void const void void * result
Definition: crypto.h:335
multiplier
uint8_t multiplier
Port multiplier number.
Definition: edd.h:32
tmp
unsigned long tmp
Definition: linux_pci.h:53
bigint_mod_multiply
#define bigint_mod_multiply(multiplicand, multiplier, modulus, result, tmp)
Perform modular multiplication of big integers.
Definition: bigint.h:229
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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 206 of file bigint_test.c.

211  {
212  const bigint_t ( size ) *base __attribute__ (( may_alias ))
213  = ( ( const void * ) base0 );
214  const bigint_t ( size ) *modulus __attribute__ (( may_alias ))
215  = ( ( const void * ) modulus0 );
216  const bigint_t ( exponent_size ) *exponent __attribute__ (( may_alias ))
217  = ( ( const void * ) exponent0 );
218  bigint_t ( size ) *result __attribute__ (( may_alias ))
219  = ( ( void * ) result0 );
220 
221  bigint_mod_exp ( base, modulus, exponent, result, tmp );
222 }
__attribute__
#define __attribute__(x)
Definition: compiler.h:10
result
static const void const void void * result
Definition: crypto.h:335
bigint_mod_exp
#define bigint_mod_exp(base, modulus, exponent, result, tmp)
Perform modular exponentiation of big integers.
Definition: bigint.h:260
base
static const void * base
Base address.
Definition: crypto.h:335
tmp
unsigned long tmp
Definition: linux_pci.h:53
size
uint8_t size
Entry size (in 32-bit words)
Definition: ena.h:16
bigint_t
typedef bigint_t(X25519_SIZE) x25519_t
An X25519 unsigned big integer used in internal calculations.

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 622 of file bigint_test.c.

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

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, bigint_subtract_ok, and bigint_swap_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:622

Big integer self-test.

Definition at line 2520 of file bigint_test.c.

Generated by   doxygen 1.8.15