qemu/roms/ipxe/src/tests/bigint_test.c

   1 /*
   2  * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  * You can also choose to distribute this program under the terms of
  20  * the Unmodified Binary Distribution Licence (as given in the file
  21  * COPYING.UBDL), provided that you have satisfied its requirements.
  22  */
  23
  24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  25
  26 /** @file
  27  *
  28  * Big integer self-tests
  29  *
  30  */
  31
  32 /* Forcibly enable assertions */
  33 #undef NDEBUG
  34
  35 #include <assert.h>
  36 #include <string.h>
  37 #include <ipxe/bigint.h>
  38 #include <ipxe/test.h>
  39
  40 /** Define inline big integer */
  41 #define BIGINT(...) { __VA_ARGS__ }
  42
  43 /* Provide global functions to allow inspection of generated assembly code */
  44
  45 void bigint_init_sample ( bigint_element_t *value0, unsigned int size,
  46                           const void *data, size_t len ) {
  47         bigint_t ( size ) *value __attribute__ (( may_alias ))
  48                 = ( ( void * ) value0 );
  49
  50         bigint_init ( value, data, len );
  51 }
  52
  53 void bigint_done_sample ( const bigint_element_t *value0, unsigned int size,
  54                           void *out, size_t len ) {
  55         const bigint_t ( size ) *value __attribute__ (( may_alias ))
  56                 = ( ( const void * ) value0 );
  57
  58         bigint_done ( value, out, len );
  59 }
  60
  61 void bigint_add_sample ( const bigint_element_t *addend0,
  62                          bigint_element_t *value0, unsigned int size ) {
  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 }
  70
  71 void bigint_subtract_sample ( const bigint_element_t *subtrahend0,
  72                               bigint_element_t *value0, unsigned int size ) {
  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 }
  80
  81 void bigint_rol_sample ( bigint_element_t *value0, unsigned int size ) {
  82         bigint_t ( size ) *value __attribute__ (( may_alias ))
  83                 = ( ( void * ) value0 );
  84
  85         bigint_rol ( value );
  86 }
  87
  88 void bigint_ror_sample ( bigint_element_t *value0, unsigned int size ) {
  89         bigint_t ( size ) *value __attribute__ (( may_alias ))
  90                 = ( ( void * ) value0 );
  91
  92         bigint_ror ( value );
  93 }
  94
  95 int bigint_is_zero_sample ( const bigint_element_t *value0,
  96                             unsigned int size ) {
  97         const bigint_t ( size ) *value __attribute__ (( may_alias ))
  98                 = ( ( const void * ) value0 );
  99
 100         return bigint_is_zero ( value );
 101 }
 102
 103 int bigint_is_geq_sample ( const bigint_element_t *value0,
 104                            const bigint_element_t *reference0,
 105                            unsigned int size ) {
 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 }
 113
 114 int bigint_bit_is_set_sample ( const bigint_element_t *value0,
 115                                unsigned int size, unsigned int bit ) {
 116         const bigint_t ( size ) *value __attribute__ (( may_alias ))
 117                 = ( ( const void * ) value0 );
 118
 119         return bigint_bit_is_set ( value, bit );
 120 }
 121
 122 int bigint_max_set_bit_sample ( const bigint_element_t *value0,
 123                                 unsigned int size ) {
 124         const bigint_t ( size ) *value __attribute__ (( may_alias ))
 125                 = ( ( const void * ) value0 );
 126
 127         return bigint_max_set_bit ( value );
 128 }
 129
 130 void bigint_grow_sample ( const bigint_element_t *source0,
 131                           unsigned int source_size, bigint_element_t *dest0,
 132                           unsigned int dest_size ) {
 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 }
 140
 141 void bigint_shrink_sample ( const bigint_element_t *source0,
 142                             unsigned int source_size, bigint_element_t *dest0,
 143                             unsigned int dest_size ) {
 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 }
 151
 152 void bigint_multiply_sample ( const bigint_element_t *multiplicand0,
 153                               const bigint_element_t *multiplier0,
 154                               bigint_element_t *result0,
 155                               unsigned int size ) {
 156         const bigint_t ( size ) *multiplicand __attribute__ (( may_alias ))
 157                 = ( ( const void * ) multiplicand0 );
 158         const bigint_t ( size ) *multiplier __attribute__ (( may_alias ))
 159                 = ( ( const void * ) multiplier0 );
 160         bigint_t ( size * 2 ) *result __attribute__ (( may_alias ))
 161                 = ( ( void * ) result0 );
 162
 163         bigint_multiply ( multiplicand, multiplier, result );
 164 }
 165
 166 void bigint_mod_multiply_sample ( const bigint_element_t *multiplicand0,
 167                                   const bigint_element_t *multiplier0,
 168                                   const bigint_element_t *modulus0,
 169                                   bigint_element_t *result0,
 170                                   unsigned int size,
 171                                   void *tmp ) {
 172         const bigint_t ( size ) *multiplicand __attribute__ (( may_alias ))
 173                 = ( ( const void * ) multiplicand0 );
 174         const bigint_t ( size ) *multiplier __attribute__ (( may_alias ))
 175                 = ( ( const void * ) multiplier0 );
 176         const bigint_t ( size ) *modulus __attribute__ (( may_alias ))
 177                 = ( ( const void * ) modulus0 );
 178         bigint_t ( size ) *result __attribute__ (( may_alias ))
 179                 = ( ( void * ) result0 );
 180
 181         bigint_mod_multiply ( multiplicand, multiplier, modulus, result, tmp );
 182 }
 183
 184 void bigint_mod_exp_sample ( const bigint_element_t *base0,
 185                              const bigint_element_t *modulus0,
 186                              const bigint_element_t *exponent0,
 187                              bigint_element_t *result0,
 188                              unsigned int size, unsigned int exponent_size,
 189                              void *tmp ) {
 190         const bigint_t ( size ) *base __attribute__ (( may_alias ))
 191                 = ( ( const void * ) base0 );
 192         const bigint_t ( size ) *modulus __attribute__ (( may_alias ))
 193                 = ( ( const void * ) modulus0 );
 194         const bigint_t ( exponent_size ) *exponent __attribute__ (( may_alias ))
 195                 = ( ( const void * ) exponent0 );
 196         bigint_t ( size ) *result __attribute__ (( may_alias ))
 197                 = ( ( void * ) result0 );
 198
 199         bigint_mod_exp ( base, modulus, exponent, result, tmp );
 200 }
 201
 202 /**
 203  * Report result of big integer addition test
 204  *
 205  * @v addend            Big integer to add
 206  * @v value             Big integer to be added to
 207  * @v expected          Big integer expected result
 208  */
 209 #define bigint_add_ok( addend, value, expected ) do {                   \
 210         static const uint8_t addend_raw[] = addend;                     \
 211         static const uint8_t value_raw[] = value;                       \
 212         static const uint8_t expected_raw[] = expected;                 \
 213         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
 214         unsigned int size =                                             \
 215                 bigint_required_size ( sizeof ( value_raw ) );          \
 216         bigint_t ( size ) addend_temp;                                  \
 217         bigint_t ( size ) value_temp;                                   \
 218         {} /* Fix emacs alignment */                                    \
 219                                                                         \
 220         assert ( bigint_size ( &addend_temp ) ==                        \
 221                  bigint_size ( &value_temp ) );                         \
 222         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
 223         bigint_init ( &addend_temp, addend_raw,                         \
 224                       sizeof ( addend_raw ) );                          \
 225         DBG ( "Add:\n" );                                               \
 226         DBG_HDA ( 0, &addend_temp, sizeof ( addend_temp ) );            \
 227         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
 228         bigint_add ( &addend_temp, &value_temp );                       \
 229         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
 230         bigint_done ( &value_temp, result_raw, sizeof ( result_raw ) ); \
 231                                                                         \
 232         ok ( memcmp ( result_raw, expected_raw,                         \
 233                       sizeof ( result_raw ) ) == 0 );                   \
 234         } while ( 0 )
 235
 236 /**
 237  * Report result of big integer subtraction test
 238  *
 239  * @v subtrahend        Big integer to subtract
 240  * @v value             Big integer to be subtracted from
 241  * @v expected          Big integer expected result
 242  */
 243 #define bigint_subtract_ok( subtrahend, value, expected ) do {          \
 244         static const uint8_t subtrahend_raw[] = subtrahend;             \
 245         static const uint8_t value_raw[] = value;                       \
 246         static const uint8_t expected_raw[] = expected;                 \
 247         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
 248         unsigned int size =                                             \
 249                 bigint_required_size ( sizeof ( value_raw ) );          \
 250         bigint_t ( size ) subtrahend_temp;                              \
 251         bigint_t ( size ) value_temp;                                   \
 252         {} /* Fix emacs alignment */                                    \
 253                                                                         \
 254         assert ( bigint_size ( &subtrahend_temp ) ==                    \
 255                  bigint_size ( &value_temp ) );                         \
 256         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
 257         bigint_init ( &subtrahend_temp, subtrahend_raw,                 \
 258                       sizeof ( subtrahend_raw ) );                      \
 259         DBG ( "Subtract:\n" );                                          \
 260         DBG_HDA ( 0, &subtrahend_temp, sizeof ( subtrahend_temp ) );    \
 261         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
 262         bigint_subtract ( &subtrahend_temp, &value_temp );              \
 263         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
 264         bigint_done ( &value_temp, result_raw, sizeof ( result_raw ) ); \
 265                                                                         \
 266         ok ( memcmp ( result_raw, expected_raw,                         \
 267                       sizeof ( result_raw ) ) == 0 );                   \
 268         } while ( 0 )
 269
 270 /**
 271  * Report result of big integer left rotation test
 272  *
 273  * @v value             Big integer
 274  * @v expected          Big integer expected result
 275  */
 276 #define bigint_rol_ok( value, expected ) do {                           \
 277         static const uint8_t value_raw[] = value;                       \
 278         static const uint8_t expected_raw[] = expected;                 \
 279         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
 280         unsigned int size =                                             \
 281                 bigint_required_size ( sizeof ( value_raw ) );          \
 282         bigint_t ( size ) value_temp;                                   \
 283         {} /* Fix emacs alignment */                                    \
 284                                                                         \
 285         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
 286         DBG ( "Rotate left:\n" );                                       \
 287         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
 288         bigint_rol ( &value_temp );                                     \
 289         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
 290         bigint_done ( &value_temp, result_raw, sizeof ( result_raw ) ); \
 291                                                                         \
 292         ok ( memcmp ( result_raw, expected_raw,                         \
 293                       sizeof ( result_raw ) ) == 0 );                   \
 294         } while ( 0 )
 295
 296 /**
 297  * Report result of big integer right rotation test
 298  *
 299  * @v value             Big integer
 300  * @v expected          Big integer expected result
 301  */
 302 #define bigint_ror_ok( value, expected ) do {                           \
 303         static const uint8_t value_raw[] = value;                       \
 304         static const uint8_t expected_raw[] = expected;                 \
 305         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
 306         unsigned int size =                                             \
 307                 bigint_required_size ( sizeof ( value_raw ) );          \
 308         bigint_t ( size ) value_temp;                                   \
 309         {} /* Fix emacs alignment */                                    \
 310                                                                         \
 311         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
 312         DBG ( "Rotate right:\n" );                                      \
 313         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
 314         bigint_ror ( &value_temp );                                     \
 315         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
 316         bigint_done ( &value_temp, result_raw, sizeof ( result_raw ) ); \
 317                                                                         \
 318         ok ( memcmp ( result_raw, expected_raw,                         \
 319                       sizeof ( result_raw ) ) == 0 );                   \
 320         } while ( 0 )
 321
 322 /**
 323  * Report result of big integer zero comparison test
 324  *
 325  * @v value             Big integer
 326  * @v expected          Expected result
 327  */
 328 #define bigint_is_zero_ok( value, expected ) do {                       \
 329         static const uint8_t value_raw[] = value;                       \
 330         unsigned int size =                                             \
 331                 bigint_required_size ( sizeof ( value_raw ) );          \
 332         bigint_t ( size ) value_temp;                                   \
 333         int is_zero;                                                    \
 334         {} /* Fix emacs alignment */                                    \
 335                                                                         \
 336         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
 337         DBG ( "Zero comparison:\n" );                                   \
 338         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
 339         is_zero = bigint_is_zero ( &value_temp );                       \
 340         DBG ( "...is %szero\n", ( is_zero ? "" : "not " ) );            \
 341         ok ( ( !! is_zero ) == ( !! (expected) ) );                     \
 342         } while ( 0 )
 343
 344 /**
 345  * Report result of big integer greater-than-or-equal comparison test
 346  *
 347  * @v value             Big integer
 348  * @v reference         Reference big integer
 349  * @v expected          Expected result
 350  */
 351 #define bigint_is_geq_ok( value, reference, expected ) do {             \
 352         static const uint8_t value_raw[] = value;                       \
 353         static const uint8_t reference_raw[] = reference;               \
 354         unsigned int size =                                             \
 355                 bigint_required_size ( sizeof ( value_raw ) );          \
 356         bigint_t ( size ) value_temp;                                   \
 357         bigint_t ( size ) reference_temp;                               \
 358         int is_geq;                                                     \
 359         {} /* Fix emacs alignment */                                    \
 360                                                                         \
 361         assert ( bigint_size ( &reference_temp ) ==                     \
 362                  bigint_size ( &value_temp ) );                         \
 363         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
 364         bigint_init ( &reference_temp, reference_raw,                   \
 365                       sizeof ( reference_raw ) );                       \
 366         DBG ( "Greater-than-or-equal comparison:\n" );                  \
 367         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
 368         DBG_HDA ( 0, &reference_temp, sizeof ( reference_temp ) );      \
 369         is_geq = bigint_is_geq ( &value_temp, &reference_temp );        \
 370         DBG ( "...is %sgreater than or equal\n",                        \
 371               ( is_geq ? "" : "not " ) );                               \
 372         ok ( ( !! is_geq ) == ( !! (expected) ) );                      \
 373         } while ( 0 )
 374
 375 /**
 376  * Report result of big integer bit-set test
 377  *
 378  * @v value             Big integer
 379  * @v bit               Bit to test
 380  * @v expected          Expected result
 381  */
 382 #define bigint_bit_is_set_ok( value, bit, expected ) do {               \
 383         static const uint8_t value_raw[] = value;                       \
 384         unsigned int size =                                             \
 385                 bigint_required_size ( sizeof ( value_raw ) );          \
 386         bigint_t ( size ) value_temp;                                   \
 387         int bit_is_set;                                                 \
 388         {} /* Fix emacs alignment */                                    \
 389                                                                         \
 390         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
 391         DBG ( "Bit set:\n" );                                           \
 392         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
 393         bit_is_set = bigint_bit_is_set ( &value_temp, bit );            \
 394         DBG ( "...bit %d is %sset\n", bit,                              \
 395               ( bit_is_set ? "" : "not " ) );                           \
 396         ok ( ( !! bit_is_set ) == ( !! (expected) ) );                  \
 397         } while ( 0 )
 398
 399 /**
 400  * Report result of big integer maximum set bit test
 401  *
 402  * @v value             Big integer
 403  * @v expected          Expected result
 404  */
 405 #define bigint_max_set_bit_ok( value, expected ) do {                   \
 406         static const uint8_t value_raw[] = value;                       \
 407         unsigned int size =                                             \
 408                 bigint_required_size ( sizeof ( value_raw ) );          \
 409         bigint_t ( size ) value_temp;                                   \
 410         int max_set_bit;                                                \
 411         {} /* Fix emacs alignment */                                    \
 412                                                                         \
 413         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
 414         DBG ( "Maximum set bit:\n" );                                   \
 415         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
 416         max_set_bit = bigint_max_set_bit ( &value_temp );               \
 417         DBG ( "...maximum set bit is bit %d\n", ( max_set_bit - 1 ) );  \
 418         ok ( max_set_bit == (expected) );                               \
 419         } while ( 0 )
 420
 421 /**
 422  * Report result of big integer multiplication test
 423  *
 424  * @v multiplicand      Big integer to be multiplied
 425  * @v multiplier        Big integer to be multiplied
 426  * @v expected          Big integer expected result
 427  */
 428 #define bigint_multiply_ok( multiplicand, multiplier, expected ) do {   \
 429         static const uint8_t multiplicand_raw[] = multiplicand;         \
 430         static const uint8_t multiplier_raw[] = multiplier;             \
 431         static const uint8_t expected_raw[] = expected;                 \
 432         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
 433         unsigned int size =                                             \
 434                 bigint_required_size ( sizeof ( multiplicand_raw ) );   \
 435         bigint_t ( size ) multiplicand_temp;                            \
 436         bigint_t ( size ) multiplier_temp;                              \
 437         bigint_t ( size * 2 ) result_temp;                              \
 438         {} /* Fix emacs alignment */                                    \
 439                                                                         \
 440         assert ( bigint_size ( &multiplier_temp ) ==                    \
 441                  bigint_size ( &multiplicand_temp ) );                  \
 442         assert ( bigint_size ( &result_temp ) ==                        \
 443                  ( 2 * bigint_size ( &multiplicand_temp ) ) );          \
 444         bigint_init ( &multiplicand_temp, multiplicand_raw,             \
 445                       sizeof ( multiplicand_raw ) );                    \
 446         bigint_init ( &multiplier_temp, multiplier_raw,                 \
 447                       sizeof ( multiplier_raw ) );                      \
 448         DBG ( "Multiply:\n" );                                          \
 449         DBG_HDA ( 0, &multiplicand_temp, sizeof ( multiplicand_temp ) );\
 450         DBG_HDA ( 0, &multiplier_temp, sizeof ( multiplier_temp ) );    \
 451         bigint_multiply ( &multiplicand_temp, &multiplier_temp,         \
 452                           &result_temp );                               \
 453         DBG_HDA ( 0, &result_temp, sizeof ( result_temp ) );            \
 454         bigint_done ( &result_temp, result_raw, sizeof ( result_raw ) );\
 455                                                                         \
 456         ok ( memcmp ( result_raw, expected_raw,                         \
 457                       sizeof ( result_raw ) ) == 0 );                   \
 458         } while ( 0 )
 459
 460 /**
 461  * Report result of big integer modular multiplication test
 462  *
 463  * @v multiplicand      Big integer to be multiplied
 464  * @v multiplier        Big integer to be multiplied
 465  * @v modulus           Big integer modulus
 466  * @v expected          Big integer expected result
 467  */
 468 #define bigint_mod_multiply_ok( multiplicand, multiplier, modulus,      \
 469                                 expected ) do {                         \
 470         static const uint8_t multiplicand_raw[] = multiplicand;         \
 471         static const uint8_t multiplier_raw[] = multiplier;             \
 472         static const uint8_t modulus_raw[] = modulus;                   \
 473         static const uint8_t expected_raw[] = expected;                 \
 474         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
 475         unsigned int size =                                             \
 476                 bigint_required_size ( sizeof ( multiplicand_raw ) );   \
 477         bigint_t ( size ) multiplicand_temp;                            \
 478         bigint_t ( size ) multiplier_temp;                              \
 479         bigint_t ( size ) modulus_temp;                                 \
 480         bigint_t ( size ) result_temp;                                  \
 481         size_t tmp_len = bigint_mod_multiply_tmp_len ( &modulus_temp ); \
 482         uint8_t tmp[tmp_len];                                           \
 483         {} /* Fix emacs alignment */                                    \
 484                                                                         \
 485         assert ( bigint_size ( &multiplier_temp ) ==                    \
 486                  bigint_size ( &multiplicand_temp ) );                  \
 487         assert ( bigint_size ( &multiplier_temp ) ==                    \
 488                  bigint_size ( &modulus_temp ) );                       \
 489         assert ( bigint_size ( &multiplier_temp ) ==                    \
 490                  bigint_size ( &result_temp ) );                        \
 491         bigint_init ( &multiplicand_temp, multiplicand_raw,             \
 492                       sizeof ( multiplicand_raw ) );                    \
 493         bigint_init ( &multiplier_temp, multiplier_raw,                 \
 494                       sizeof ( multiplier_raw ) );                      \
 495         bigint_init ( &modulus_temp, modulus_raw,                       \
 496                       sizeof ( modulus_raw ) );                         \
 497         DBG ( "Modular multiply:\n" );                                  \
 498         DBG_HDA ( 0, &multiplicand_temp, sizeof ( multiplicand_temp ) );\
 499         DBG_HDA ( 0, &multiplier_temp, sizeof ( multiplier_temp ) );    \
 500         DBG_HDA ( 0, &modulus_temp, sizeof ( modulus_temp ) );          \
 501         bigint_mod_multiply ( &multiplicand_temp, &multiplier_temp,     \
 502                               &modulus_temp, &result_temp, tmp );       \
 503         DBG_HDA ( 0, &result_temp, sizeof ( result_temp ) );            \
 504         bigint_done ( &result_temp, result_raw, sizeof ( result_raw ) );\
 505                                                                         \
 506         ok ( memcmp ( result_raw, expected_raw,                         \
 507                       sizeof ( result_raw ) ) == 0 );                   \
 508         } while ( 0 )
 509
 510 /**
 511  * Report result of big integer modular exponentiation test
 512  *
 513  * @v base              Big integer base
 514  * @v modulus           Big integer modulus
 515  * @v exponent          Big integer exponent
 516  * @v expected          Big integer expected result
 517  */
 518 #define bigint_mod_exp_ok( base, modulus, exponent, expected ) do {     \
 519         static const uint8_t base_raw[] = base;                         \
 520         static const uint8_t modulus_raw[] = modulus;                   \
 521         static const uint8_t exponent_raw[] = exponent;                 \
 522         static const uint8_t expected_raw[] = expected;                 \
 523         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
 524         unsigned int size =                                             \
 525                 bigint_required_size ( sizeof ( base_raw ) );           \
 526         unsigned int exponent_size =                                    \
 527                 bigint_required_size ( sizeof ( exponent_raw ) );       \
 528         bigint_t ( size ) base_temp;                                    \
 529         bigint_t ( size ) modulus_temp;                                 \
 530         bigint_t ( exponent_size ) exponent_temp;                       \
 531         bigint_t ( size ) result_temp;                                  \
 532         size_t tmp_len = bigint_mod_exp_tmp_len ( &modulus_temp,        \
 533                                                   &exponent_temp );     \
 534         uint8_t tmp[tmp_len];                                           \
 535         {} /* Fix emacs alignment */                                    \
 536                                                                         \
 537         assert ( bigint_size ( &modulus_temp ) ==                       \
 538                  bigint_size ( &base_temp ) );                          \
 539         assert ( bigint_size ( &modulus_temp ) ==                       \
 540                  bigint_size ( &result_temp ) );                        \
 541         bigint_init ( &base_temp, base_raw, sizeof ( base_raw ) );      \
 542         bigint_init ( &modulus_temp, modulus_raw,                       \
 543                       sizeof ( modulus_raw ) );                         \
 544         bigint_init ( &exponent_temp, exponent_raw,                     \
 545                       sizeof ( exponent_raw ) );                        \
 546         DBG ( "Modular exponentiation:\n" );                            \
 547         DBG_HDA ( 0, &base_temp, sizeof ( base_temp ) );                \
 548         DBG_HDA ( 0, &modulus_temp, sizeof ( modulus_temp ) );          \
 549         DBG_HDA ( 0, &exponent_temp, sizeof ( exponent_temp ) );        \
 550         bigint_mod_exp ( &base_temp, &modulus_temp, &exponent_temp,     \
 551                          &result_temp, tmp );                           \
 552         DBG_HDA ( 0, &result_temp, sizeof ( result_temp ) );            \
 553         bigint_done ( &result_temp, result_raw, sizeof ( result_raw ) );\
 554                                                                         \
 555         ok ( memcmp ( result_raw, expected_raw,                         \
 556                       sizeof ( result_raw ) ) == 0 );                   \
 557         } while ( 0 )
 558
 559 /**
 560  * Perform big integer self-tests
 561  *
 562  */
 563 static void bigint_test_exec ( void ) {
 564
 565         bigint_add_ok ( BIGINT ( 0x8a ),
 566                         BIGINT ( 0x43 ),
 567                         BIGINT ( 0xcd ) );
 568         bigint_add_ok ( BIGINT ( 0xc5, 0x7b ),
 569                         BIGINT ( 0xd6, 0xb1 ),
 570                         BIGINT ( 0x9c, 0x2c ) );
 571         bigint_add_ok ( BIGINT ( 0xf9, 0xd9, 0xdc ),
 572                         BIGINT ( 0x6d, 0x4b, 0xca ),
 573                         BIGINT ( 0x67, 0x25, 0xa6 ) );
 574         bigint_add_ok ( BIGINT ( 0xdd, 0xc2, 0x20, 0x5f ),
 575                         BIGINT ( 0x80, 0x32, 0xc4, 0xb0 ),
 576                         BIGINT ( 0x5d, 0xf4, 0xe5, 0x0f ) );
 577         bigint_add_ok ( BIGINT ( 0x01, 0xed, 0x45, 0x4b, 0x41, 0xeb, 0x4c,
 578                                  0x2e, 0x53, 0x07, 0x15, 0x51, 0x56, 0x47,
 579                                  0x29, 0xfc, 0x9c, 0xbd, 0xbd, 0xfb, 0x1b,
 580                                  0xd1, 0x1d ),
 581                         BIGINT ( 0x73, 0xed, 0xfc, 0x35, 0x31, 0x22, 0xd7,
 582                                  0xb1, 0xea, 0x91, 0x5a, 0xe4, 0xba, 0xbc,
 583                                  0xa1, 0x38, 0x72, 0xae, 0x4b, 0x1c, 0xc1,
 584                                  0x05, 0xb3 ),
 585                         BIGINT ( 0x75, 0xdb, 0x41, 0x80, 0x73, 0x0e, 0x23,
 586                                  0xe0, 0x3d, 0x98, 0x70, 0x36, 0x11, 0x03,
 587                                  0xcb, 0x35, 0x0f, 0x6c, 0x09, 0x17, 0xdc,
 588                                  0xd6, 0xd0 ) );
 589         bigint_add_ok ( BIGINT ( 0x06, 0x8e, 0xd6, 0x18, 0xbb, 0x4b, 0x0c,
 590                                  0xc5, 0x85, 0xde, 0xee, 0x9b, 0x3f, 0x65,
 591                                  0x63, 0x86, 0xf5, 0x5a, 0x9f, 0xa2, 0xd7,
 592                                  0xb2, 0xc7, 0xb6, 0x1d, 0x28, 0x6c, 0x50,
 593                                  0x47, 0x10, 0x0a, 0x0e, 0x86, 0xcd, 0x2a,
 594                                  0x64, 0xdc, 0xe6, 0x9d, 0x96, 0xd8, 0xf4,
 595                                  0x56, 0x46, 0x6f, 0xbb, 0x7b, 0x64, 0x6f,
 596                                  0xdc, 0x2a, 0xd1, 0x3b, 0xcc, 0x03, 0x85,
 597                                  0x95, 0xf4, 0xe9, 0x68, 0x1f, 0x5c, 0xc5,
 598                                  0xbf, 0x97, 0x19, 0x12, 0x88, 0x2e, 0x88,
 599                                  0xb9, 0x34, 0xac, 0x74, 0x83, 0x2d, 0x8f,
 600                                  0xb3, 0x97, 0x53, 0x99, 0xf3, 0xb4, 0x8b,
 601                                  0x2d, 0x98, 0x69, 0x8d, 0x19, 0xf0, 0x40,
 602                                  0x66, 0x3f, 0x60, 0x78, 0x34, 0x7f, 0x9b,
 603                                  0xf7, 0x01, 0x74, 0x55, 0xca, 0x63, 0x25,
 604                                  0x7b, 0x86, 0xe9, 0x73, 0xfd, 0x5d, 0x77,
 605                                  0x32, 0x5e, 0x9e, 0x42, 0x53, 0xb6, 0x35,
 606                                  0x92, 0xb9, 0xd7, 0x1b, 0xf7, 0x16, 0x55,
 607                                  0xf6, 0xe2 ),
 608                         BIGINT ( 0x3f, 0x8f, 0x62, 0x21, 0x4a, 0x7a, 0xa2,
 609                                  0xef, 0xa8, 0x79, 0x9b, 0x73, 0xac, 0xde,
 610                                  0x72, 0xe4, 0xfc, 0x3c, 0xd3, 0xa9, 0x44,
 611                                  0x1a, 0x6a, 0x02, 0x76, 0xe3, 0x78, 0x4d,
 612                                  0x2e, 0x07, 0x9b, 0xb6, 0x3d, 0x5d, 0xc5,
 613                                  0xcd, 0x68, 0x23, 0x4b, 0x5f, 0x89, 0x0e,
 614                                  0xd7, 0xa7, 0xff, 0x18, 0x80, 0xdc, 0xfb,
 615                                  0x34, 0x45, 0xca, 0x4b, 0xdb, 0x8a, 0x19,
 616                                  0xcb, 0xc9, 0xe5, 0xa1, 0x63, 0xa2, 0x0d,
 617                                  0x56, 0xc4, 0xf9, 0x51, 0x1b, 0x88, 0x4e,
 618                                  0x36, 0xab, 0x15, 0x4d, 0x8f, 0xdc, 0x08,
 619                                  0xc4, 0x4d, 0x43, 0xc7, 0x2b, 0xc9, 0x5c,
 620                                  0x05, 0x26, 0xe3, 0x46, 0xf0, 0x64, 0xaa,
 621                                  0x02, 0xa4, 0xbe, 0x3a, 0xd1, 0xca, 0x07,
 622                                  0x6a, 0x6e, 0x62, 0xf4, 0x57, 0x71, 0x96,
 623                                  0xec, 0xf0, 0x0b, 0xac, 0xa4, 0x4a, 0xa3,
 624                                  0x6d, 0x01, 0xba, 0xbd, 0x62, 0xc0, 0x10,
 625                                  0x54, 0x33, 0x8a, 0x71, 0xef, 0xaa, 0x1c,
 626                                  0x25, 0x25 ),
 627                         BIGINT ( 0x46, 0x1e, 0x38, 0x3a, 0x05, 0xc5, 0xaf,
 628                                  0xb5, 0x2e, 0x58, 0x8a, 0x0e, 0xec, 0x43,
 629                                  0xd6, 0x6b, 0xf1, 0x97, 0x73, 0x4c, 0x1b,
 630                                  0xcd, 0x31, 0xb8, 0x94, 0x0b, 0xe4, 0x9d,
 631                                  0x75, 0x17, 0xa5, 0xc4, 0xc4, 0x2a, 0xf0,
 632                                  0x32, 0x45, 0x09, 0xe8, 0xf6, 0x62, 0x03,
 633                                  0x2d, 0xee, 0x6e, 0xd3, 0xfc, 0x41, 0x6b,
 634                                  0x10, 0x70, 0x9b, 0x87, 0xa7, 0x8d, 0x9f,
 635                                  0x61, 0xbe, 0xcf, 0x09, 0x82, 0xfe, 0xd3,
 636                                  0x16, 0x5c, 0x12, 0x63, 0xa3, 0xb6, 0xd6,
 637                                  0xef, 0xdf, 0xc1, 0xc2, 0x13, 0x09, 0x98,
 638                                  0x77, 0xe4, 0x97, 0x61, 0x1f, 0x7d, 0xe7,
 639                                  0x32, 0xbf, 0x4c, 0xd4, 0x0a, 0x54, 0xea,
 640                                  0x68, 0xe4, 0x1e, 0xb3, 0x06, 0x49, 0xa3,
 641                                  0x61, 0x6f, 0xd7, 0x4a, 0x21, 0xd4, 0xbc,
 642                                  0x68, 0x76, 0xf5, 0x20, 0xa1, 0xa8, 0x1a,
 643                                  0x9f, 0x60, 0x58, 0xff, 0xb6, 0x76, 0x45,
 644                                  0xe6, 0xed, 0x61, 0x8d, 0xe6, 0xc0, 0x72,
 645                                  0x1c, 0x07 ) );
 646         bigint_subtract_ok ( BIGINT ( 0x83 ),
 647                              BIGINT ( 0x50 ),
 648                              BIGINT ( 0xcd ) );
 649         bigint_subtract_ok ( BIGINT ( 0x2c, 0x7c ),
 650                              BIGINT ( 0x49, 0x0e ),
 651                              BIGINT ( 0x1c, 0x92 ) );
 652         bigint_subtract_ok ( BIGINT ( 0x9c, 0x30, 0xbf ),
 653                              BIGINT ( 0xde, 0x4e, 0x07 ),
 654                              BIGINT ( 0x42, 0x1d, 0x48 ) );
 655         bigint_subtract_ok ( BIGINT ( 0xbb, 0x77, 0x32, 0x5a ),
 656                              BIGINT ( 0x5a, 0xd5, 0xfe, 0x28 ),
 657                              BIGINT ( 0x9f, 0x5e, 0xcb, 0xce ) );
 658         bigint_subtract_ok ( BIGINT ( 0x7b, 0xaa, 0x16, 0xcf, 0x15, 0x87,
 659                                       0xe0, 0x4f, 0x2c, 0xa3, 0xec, 0x2f,
 660                                       0x46, 0xfb, 0x83, 0xc6, 0xe0, 0xee,
 661                                       0x57, 0xfa, 0x04, 0xce, 0xa6 ),
 662                              BIGINT ( 0x46, 0x55, 0xb6, 0x23, 0x63, 0xd0,
 663                                       0x55, 0xdb, 0x8f, 0xcc, 0x55, 0xa8,
 664                                       0x2f, 0x85, 0xc1, 0x9f, 0x2c, 0x13,
 665                                       0x10, 0x9e, 0x76, 0x3c, 0x11 ),
 666                              BIGINT ( 0xca, 0xab, 0x9f, 0x54, 0x4e, 0x48,
 667                                       0x75, 0x8c, 0x63, 0x28, 0x69, 0x78,
 668                                       0xe8, 0x8a, 0x3d, 0xd8, 0x4b, 0x24,
 669                                       0xb8, 0xa4, 0x71, 0x6d, 0x6b ) );
 670         bigint_subtract_ok ( BIGINT ( 0x5b, 0x06, 0x77, 0x7b, 0xfd, 0x34,
 671                                       0x5f, 0x0f, 0xd9, 0xbd, 0x8e, 0x5d,
 672                                       0xc8, 0x4a, 0x70, 0x95, 0x1b, 0xb6,
 673                                       0x48, 0xfb, 0x0e, 0x40, 0xce, 0x06,
 674                                       0x66, 0xcc, 0x29, 0xe9, 0x51, 0x59,
 675                                       0x59, 0xc9, 0x65, 0x07, 0x75, 0xb8,
 676                                       0xd4, 0xcb, 0x07, 0x68, 0x14, 0x48,
 677                                       0xc7, 0x1e, 0xfe, 0xb3, 0x4c, 0xf1,
 678                                       0x10, 0xf0, 0xc7, 0x82, 0x38, 0x4c,
 679                                       0xaf, 0x05, 0x6d, 0x91, 0xc5, 0x18,
 680                                       0xfd, 0x1e, 0x26, 0x1b, 0xef, 0x71,
 681                                       0x70, 0x2e, 0x06, 0x70, 0x8e, 0x54,
 682                                       0xfa, 0x2b, 0x4d, 0x96, 0x85, 0x10,
 683                                       0x03, 0x76, 0xe7, 0x17, 0x59, 0x86,
 684                                       0x6c, 0x8b, 0x24, 0x6e, 0xd9, 0x30,
 685                                       0xf3, 0xd2, 0x9b, 0x62, 0xdc, 0x23,
 686                                       0x54, 0x06, 0x51, 0xb1, 0x95, 0x58,
 687                                       0xec, 0x27, 0xf6, 0x19, 0xae, 0xf4,
 688                                       0x31, 0xec, 0x72, 0x53, 0xcd, 0x32,
 689                                       0xed, 0xf4, 0x25, 0x4a, 0x5b, 0x36,
 690                                       0xa2, 0xb4, 0xa0, 0x29, 0x0c, 0x6b,
 691                                       0x3f, 0xc2 ),
 692                              BIGINT ( 0x7a, 0xd4, 0x25, 0xf1, 0xb5, 0xf5,
 693                                       0x00, 0x96, 0x47, 0x5b, 0x4f, 0x9f,
 694                                       0x1f, 0x61, 0x69, 0xd9, 0x72, 0x47,
 695                                       0xde, 0xbd, 0x87, 0x5d, 0x50, 0x91,
 696                                       0x69, 0xd8, 0x35, 0xe0, 0x43, 0xd8,
 697                                       0xd5, 0x15, 0xf2, 0xcd, 0x01, 0x73,
 698                                       0x0d, 0x34, 0xf0, 0x34, 0x46, 0x76,
 699                                       0xc0, 0x55, 0x7b, 0x27, 0xf5, 0x7b,
 700                                       0x55, 0xe9, 0xd0, 0x29, 0x0b, 0x4b,
 701                                       0x9f, 0x07, 0xbf, 0x2c, 0x3f, 0xef,
 702                                       0x36, 0x34, 0xde, 0x29, 0x1d, 0x5d,
 703                                       0x84, 0x5a, 0x5d, 0xc1, 0x02, 0x4d,
 704                                       0x56, 0xf1, 0x47, 0x39, 0x37, 0xc9,
 705                                       0xb5, 0x5f, 0x73, 0xec, 0x7c, 0x3d,
 706                                       0xbd, 0xc0, 0xfd, 0x38, 0x6c, 0x91,
 707                                       0x88, 0x4a, 0x0f, 0xee, 0xa1, 0x80,
 708                                       0xf5, 0x6a, 0x7c, 0x8c, 0x02, 0xc3,
 709                                       0x5a, 0xb2, 0x15, 0xa6, 0x2f, 0x6b,
 710                                       0x5b, 0x78, 0xb5, 0xf3, 0xbd, 0xd0,
 711                                       0xc8, 0xbc, 0xb1, 0xbb, 0xe1, 0xce,
 712                                       0x22, 0x80, 0x34, 0x5a, 0x2a, 0x27,
 713                                       0x83, 0xdc ),
 714                              BIGINT ( 0x1f, 0xcd, 0xae, 0x75, 0xb8, 0xc0,
 715                                       0xa1, 0x86, 0x6d, 0x9d, 0xc1, 0x41,
 716                                       0x57, 0x16, 0xf9, 0x44, 0x56, 0x91,
 717                                       0x95, 0xc2, 0x79, 0x1c, 0x82, 0x8b,
 718                                       0x03, 0x0c, 0x0b, 0xf6, 0xf2, 0x7f,
 719                                       0x7b, 0x4c, 0x8d, 0xc5, 0x8b, 0xba,
 720                                       0x38, 0x69, 0xe8, 0xcc, 0x32, 0x2d,
 721                                       0xf9, 0x36, 0x7c, 0x74, 0xa8, 0x8a,
 722                                       0x44, 0xf9, 0x08, 0xa6, 0xd2, 0xfe,
 723                                       0xf0, 0x02, 0x51, 0x9a, 0x7a, 0xd6,
 724                                       0x39, 0x16, 0xb8, 0x0d, 0x2d, 0xec,
 725                                       0x14, 0x2c, 0x57, 0x50, 0x73, 0xf8,
 726                                       0x5c, 0xc5, 0xf9, 0xa2, 0xb2, 0xb9,
 727                                       0xb1, 0xe8, 0x8c, 0xd5, 0x22, 0xb7,
 728                                       0x51, 0x35, 0xd8, 0xc9, 0x93, 0x60,
 729                                       0x94, 0x77, 0x74, 0x8b, 0xc5, 0x5d,
 730                                       0xa1, 0x64, 0x2a, 0xda, 0x6d, 0x6a,
 731                                       0x6e, 0x8a, 0x1f, 0x8c, 0x80, 0x77,
 732                                       0x29, 0x8c, 0x43, 0x9f, 0xf0, 0x9d,
 733                                       0xda, 0xc8, 0x8c, 0x71, 0x86, 0x97,
 734                                       0x7f, 0xcb, 0x94, 0x31, 0x1d, 0xbc,
 735                                       0x44, 0x1a ) );
 736         bigint_rol_ok ( BIGINT ( 0xe0 ),
 737                         BIGINT ( 0xc0 ) );
 738         bigint_rol_ok ( BIGINT ( 0x43, 0x1d ),
 739                         BIGINT ( 0x86, 0x3a ) );
 740         bigint_rol_ok ( BIGINT ( 0xac, 0xed, 0x9b ),
 741                         BIGINT ( 0x59, 0xdb, 0x36 ) );
 742         bigint_rol_ok ( BIGINT ( 0x2c, 0xe8, 0x3a, 0x22 ),
 743                         BIGINT ( 0x59, 0xd0, 0x74, 0x44 ) );
 744         bigint_rol_ok ( BIGINT ( 0x4e, 0x88, 0x4a, 0x05, 0x5e, 0x10, 0xee,
 745                                  0x5b, 0xc6, 0x40, 0x0e, 0x03, 0xd7, 0x0d,
 746                                  0x28, 0xa5, 0x55, 0xb2, 0x50, 0xef, 0x69,
 747                                  0xd1, 0x1d ),
 748                         BIGINT ( 0x9d, 0x10, 0x94, 0x0a, 0xbc, 0x21, 0xdc,
 749                                  0xb7, 0x8c, 0x80, 0x1c, 0x07, 0xae, 0x1a,
 750                                  0x51, 0x4a, 0xab, 0x64, 0xa1, 0xde, 0xd3,
 751                                  0xa2, 0x3a ) );
 752         bigint_rol_ok ( BIGINT ( 0x07, 0x62, 0x78, 0x70, 0x2e, 0xd4, 0x41,
 753                                  0xaa, 0x9b, 0x50, 0xb1, 0x9a, 0x71, 0xf5,
 754                                  0x1c, 0x2f, 0xe7, 0x0d, 0xf1, 0x46, 0x57,
 755                                  0x04, 0x99, 0x78, 0x4e, 0x84, 0x78, 0xba,
 756                                  0x57, 0xea, 0xa5, 0x43, 0xf7, 0x02, 0xf0,
 757                                  0x7a, 0x22, 0x60, 0x65, 0x42, 0xf2, 0x33,
 758                                  0x7d, 0xe3, 0xa8, 0x1b, 0xc4, 0x14, 0xdb,
 759                                  0xee, 0x4a, 0xf1, 0xe1, 0x52, 0xd4, 0xda,
 760                                  0x23, 0xed, 0x13, 0x5d, 0xea, 0xcf, 0xf6,
 761                                  0x5e, 0x39, 0x84, 0xe2, 0xb3, 0xa2, 0x05,
 762                                  0xba, 0xd9, 0x49, 0x8e, 0x75, 0x1d, 0xdb,
 763                                  0xe6, 0xb1, 0x6e, 0xda, 0x0a, 0x83, 0xd0,
 764                                  0x6e, 0xcf, 0x7a, 0x66, 0xb7, 0x64, 0x84,
 765                                  0xf5, 0x09, 0x5a, 0xa8, 0x11, 0x93, 0xf3,
 766                                  0x4f, 0x02, 0x28, 0x00, 0x3a, 0xf0, 0xa9,
 767                                  0x08, 0x77, 0x04, 0xf5, 0x04, 0xcd, 0x6b,
 768                                  0x24, 0xbe, 0x0f, 0x6d, 0xe3, 0xb2, 0xd3,
 769                                  0x07, 0x68, 0xe9, 0x00, 0x59, 0xa0, 0xe4,
 770                                  0x9e, 0x5e ),
 771                         BIGINT ( 0x0e, 0xc4, 0xf0, 0xe0, 0x5d, 0xa8, 0x83,
 772                                  0x55, 0x36, 0xa1, 0x63, 0x34, 0xe3, 0xea,
 773                                  0x38, 0x5f, 0xce, 0x1b, 0xe2, 0x8c, 0xae,
 774                                  0x09, 0x32, 0xf0, 0x9d, 0x08, 0xf1, 0x74,
 775                                  0xaf, 0xd5, 0x4a, 0x87, 0xee, 0x05, 0xe0,
 776                                  0xf4, 0x44, 0xc0, 0xca, 0x85, 0xe4, 0x66,
 777                                  0xfb, 0xc7, 0x50, 0x37, 0x88, 0x29, 0xb7,
 778                                  0xdc, 0x95, 0xe3, 0xc2, 0xa5, 0xa9, 0xb4,
 779                                  0x47, 0xda, 0x26, 0xbb, 0xd5, 0x9f, 0xec,
 780                                  0xbc, 0x73, 0x09, 0xc5, 0x67, 0x44, 0x0b,
 781                                  0x75, 0xb2, 0x93, 0x1c, 0xea, 0x3b, 0xb7,
 782                                  0xcd, 0x62, 0xdd, 0xb4, 0x15, 0x07, 0xa0,
 783                                  0xdd, 0x9e, 0xf4, 0xcd, 0x6e, 0xc9, 0x09,
 784                                  0xea, 0x12, 0xb5, 0x50, 0x23, 0x27, 0xe6,
 785                                  0x9e, 0x04, 0x50, 0x00, 0x75, 0xe1, 0x52,
 786                                  0x10, 0xee, 0x09, 0xea, 0x09, 0x9a, 0xd6,
 787                                  0x49, 0x7c, 0x1e, 0xdb, 0xc7, 0x65, 0xa6,
 788                                  0x0e, 0xd1, 0xd2, 0x00, 0xb3, 0x41, 0xc9,
 789                                  0x3c, 0xbc ) );
 790         bigint_ror_ok ( BIGINT ( 0x8f ),
 791                         BIGINT ( 0x47 ) );
 792         bigint_ror_ok ( BIGINT ( 0xaa, 0x1d ),
 793                         BIGINT ( 0x55, 0x0e ) );
 794         bigint_ror_ok ( BIGINT ( 0xf0, 0xbd, 0x68 ),
 795                         BIGINT ( 0x78, 0x5e, 0xb4 ) );
 796         bigint_ror_ok ( BIGINT ( 0x33, 0xa0, 0x3d, 0x95 ),
 797                         BIGINT ( 0x19, 0xd0, 0x1e, 0xca ) );
 798         bigint_ror_ok ( BIGINT ( 0xa1, 0xf4, 0xb9, 0x64, 0x91, 0x99, 0xa1,
 799                                  0xf4, 0xae, 0xeb, 0x71, 0x97, 0x1b, 0x71,
 800                                  0x09, 0x38, 0x3f, 0x8f, 0xc5, 0x3a, 0xb9,
 801                                  0x75, 0x94 ),
 802                         BIGINT ( 0x50, 0xfa, 0x5c, 0xb2, 0x48, 0xcc, 0xd0,
 803                                  0xfa, 0x57, 0x75, 0xb8, 0xcb, 0x8d, 0xb8,
 804                                  0x84, 0x9c, 0x1f, 0xc7, 0xe2, 0x9d, 0x5c,
 805                                  0xba, 0xca ) );
 806         bigint_ror_ok ( BIGINT ( 0xc0, 0xb3, 0x78, 0x46, 0x69, 0x6e, 0x35,
 807                                  0x94, 0xed, 0x28, 0xdc, 0xfd, 0xf6, 0xdb,
 808                                  0x2d, 0x24, 0xcb, 0xa4, 0x6f, 0x0e, 0x58,
 809                                  0x89, 0x04, 0xec, 0xc8, 0x0c, 0x2d, 0xb3,
 810                                  0x58, 0xa7, 0x22, 0x6d, 0x93, 0xe0, 0xb8,
 811                                  0x48, 0x6a, 0x3f, 0x04, 0x7e, 0xbe, 0xb8,
 812                                  0xa7, 0x84, 0xf5, 0xc9, 0x2f, 0x60, 0x9e,
 813                                  0x7c, 0xbc, 0xaf, 0x28, 0x89, 0x2f, 0xaa,
 814                                  0xd1, 0x82, 0x77, 0xa4, 0xdf, 0xf3, 0x4a,
 815                                  0xc6, 0xed, 0xa3, 0x07, 0xb4, 0xa9, 0xfd,
 816                                  0xef, 0xf8, 0x20, 0xb9, 0xb3, 0xff, 0x35,
 817                                  0x27, 0xed, 0x02, 0xea, 0xec, 0x63, 0xc0,
 818                                  0x46, 0x97, 0xc0, 0x4c, 0xca, 0x89, 0xca,
 819                                  0x14, 0xe8, 0xe0, 0x02, 0x14, 0x44, 0x46,
 820                                  0xf3, 0x2f, 0xbc, 0x6a, 0x28, 0xa2, 0xbe,
 821                                  0x20, 0xc8, 0xaa, 0x0f, 0xd9, 0x51, 0x8e,
 822                                  0x8d, 0x51, 0x29, 0x61, 0xef, 0x48, 0xae,
 823                                  0x3e, 0xe5, 0x10, 0xbf, 0xda, 0x9b, 0x92,
 824                                  0xb3, 0x77 ),
 825                         BIGINT ( 0x60, 0x59, 0xbc, 0x23, 0x34, 0xb7, 0x1a,
 826                                  0xca, 0x76, 0x94, 0x6e, 0x7e, 0xfb, 0x6d,
 827                                  0x96, 0x92, 0x65, 0xd2, 0x37, 0x87, 0x2c,
 828                                  0x44, 0x82, 0x76, 0x64, 0x06, 0x16, 0xd9,
 829                                  0xac, 0x53, 0x91, 0x36, 0xc9, 0xf0, 0x5c,
 830                                  0x24, 0x35, 0x1f, 0x82, 0x3f, 0x5f, 0x5c,
 831                                  0x53, 0xc2, 0x7a, 0xe4, 0x97, 0xb0, 0x4f,
 832                                  0x3e, 0x5e, 0x57, 0x94, 0x44, 0x97, 0xd5,
 833                                  0x68, 0xc1, 0x3b, 0xd2, 0x6f, 0xf9, 0xa5,
 834                                  0x63, 0x76, 0xd1, 0x83, 0xda, 0x54, 0xfe,
 835                                  0xf7, 0xfc, 0x10, 0x5c, 0xd9, 0xff, 0x9a,
 836                                  0x93, 0xf6, 0x81, 0x75, 0x76, 0x31, 0xe0,
 837                                  0x23, 0x4b, 0xe0, 0x26, 0x65, 0x44, 0xe5,
 838                                  0x0a, 0x74, 0x70, 0x01, 0x0a, 0x22, 0x23,
 839                                  0x79, 0x97, 0xde, 0x35, 0x14, 0x51, 0x5f,
 840                                  0x10, 0x64, 0x55, 0x07, 0xec, 0xa8, 0xc7,
 841                                  0x46, 0xa8, 0x94, 0xb0, 0xf7, 0xa4, 0x57,
 842                                  0x1f, 0x72, 0x88, 0x5f, 0xed, 0x4d, 0xc9,
 843                                  0x59, 0xbb ) );
 844         bigint_is_zero_ok ( BIGINT ( 0x9b ),
 845                             0 );
 846         bigint_is_zero_ok ( BIGINT ( 0x5a, 0x9d ),
 847                             0 );
 848         bigint_is_zero_ok ( BIGINT ( 0x5f, 0x80, 0x78 ),
 849                             0 );
 850         bigint_is_zero_ok ( BIGINT ( 0xa0, 0x52, 0x47, 0x2e ),
 851                             0 );
 852         bigint_is_zero_ok ( BIGINT ( 0x18, 0x08, 0x49, 0xdb, 0x7b, 0x5c,
 853                                      0xe7, 0x41, 0x07, 0xdf, 0xed, 0xf9,
 854                                      0xd3, 0x92, 0x0d, 0x75, 0xa6, 0xb0,
 855                                      0x14, 0xfa, 0xdd, 0xfd, 0x82 ),
 856                             0 );
 857         bigint_is_zero_ok ( BIGINT ( 0x04, 0x04, 0xb5, 0xf5, 0x01, 0xae,
 858                                      0x2b, 0x91, 0xa7, 0xc1, 0x49, 0x97,
 859                                      0x3f, 0x45, 0x53, 0x52, 0xb8, 0x52,
 860                                      0xf1, 0x62, 0xa5, 0x21, 0x18, 0xd4,
 861                                      0xb0, 0xb4, 0x8a, 0x17, 0x0e, 0xe8,
 862                                      0xeb, 0xaa, 0x28, 0xae, 0x3d, 0x8e,
 863                                      0xe3, 0x6c, 0xd0, 0x01, 0x0c, 0x54,
 864                                      0xca, 0x23, 0xbb, 0x06, 0xcd, 0x7a,
 865                                      0x61, 0x89, 0x38, 0x34, 0x6e, 0xc7,
 866                                      0xc2, 0xee, 0xb1, 0x80, 0x61, 0x0e,
 867                                      0xc6, 0x8d, 0x65, 0xa0, 0xeb, 0x34,
 868                                      0xe9, 0x63, 0x09, 0x4c, 0x20, 0xac,
 869                                      0x42, 0xe3, 0x35, 0xa2, 0x3e, 0x3b,
 870                                      0x2e, 0x18, 0x70, 0x45, 0x7c, 0xab,
 871                                      0x42, 0xcc, 0xe0, 0x9e, 0x7c, 0x42,
 872                                      0xd1, 0xda, 0x6c, 0x51, 0x10, 0x1e,
 873                                      0x0e, 0x3f, 0xe5, 0xd6, 0xd8, 0x56,
 874                                      0x08, 0xb2, 0x3b, 0x15, 0xc4, 0x7c,
 875                                      0x0c, 0x7e, 0xaf, 0x7b, 0x9d, 0xd6,
 876                                      0x2b, 0xc0, 0x2f, 0xa2, 0xa3, 0xa3,
 877                                      0x77, 0x58, 0x1b, 0xe9, 0xa8, 0x9a,
 878                                      0x23, 0x7f ),
 879                             0 );
 880         bigint_is_zero_ok ( BIGINT ( 0x00 ),
 881                             1 );
 882         bigint_is_zero_ok ( BIGINT ( 0x00, 0x00 ),
 883                             1 );
 884         bigint_is_zero_ok ( BIGINT ( 0x00, 0x00, 0x00 ),
 885                             1 );
 886         bigint_is_zero_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00 ),
 887                             1 );
 888         bigint_is_zero_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 889                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 890                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 891                                      0x00, 0x00, 0x00, 0x00, 0x00 ),
 892                             1 );
 893         bigint_is_zero_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 894                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 895                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 896                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 897                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 898                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 899                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 900                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 901                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 902                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 903                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 904                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 905                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 906                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 907                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 908                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 909                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 910                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 911                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 912                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 913                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 914                                      0x00, 0x00 ),
 915                             1 );
 916         bigint_is_zero_ok ( BIGINT ( 0xff ),
 917                             0 );
 918         bigint_is_zero_ok ( BIGINT ( 0xff, 0xff ),
 919                             0 );
 920         bigint_is_zero_ok ( BIGINT ( 0xff, 0xff, 0xff ),
 921                             0 );
 922         bigint_is_zero_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff ),
 923                             0 );
 924         bigint_is_zero_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 925                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 926                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 927                                      0xff, 0xff, 0xff, 0xff, 0xff ),
 928                             0 );
 929         bigint_is_zero_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 930                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 931                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 932                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 933                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 934                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 935                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 936                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 937                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 938                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 939                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 940                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 941                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 942                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 943                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 944                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 945                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 946                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 947                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 948                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 949                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 950                                      0xff, 0xff ),
 951                             0 );
 952         bigint_is_geq_ok ( BIGINT ( 0xa2 ),
 953                            BIGINT ( 0x58 ),
 954                            1 );
 955         bigint_is_geq_ok ( BIGINT ( 0x58 ),
 956                            BIGINT ( 0xa2 ),
 957                            0 );
 958         bigint_is_geq_ok ( BIGINT ( 0xa2 ),
 959                            BIGINT ( 0xa2 ),
 960                            1 );
 961         bigint_is_geq_ok ( BIGINT ( 0x61, 0x29 ),
 962                            BIGINT ( 0x87, 0xac ),
 963                            0 );
 964         bigint_is_geq_ok ( BIGINT ( 0x87, 0xac ),
 965                            BIGINT ( 0x61, 0x29 ),
 966                            1 );
 967         bigint_is_geq_ok ( BIGINT ( 0x61, 0x29 ),
 968                            BIGINT ( 0x61, 0x29 ),
 969                            1 );
 970         bigint_is_geq_ok ( BIGINT ( 0xe6, 0x63, 0x14 ),
 971                            BIGINT ( 0xb7, 0x2b, 0x76 ),
 972                            1 );
 973         bigint_is_geq_ok ( BIGINT ( 0xb7, 0x2b, 0x76 ),
 974                            BIGINT ( 0xe6, 0x63, 0x14 ),
 975                            0 );
 976         bigint_is_geq_ok ( BIGINT ( 0xe6, 0x63, 0x14 ),
 977                            BIGINT ( 0xe6, 0x63, 0x14 ),
 978                            1 );
 979         bigint_is_geq_ok ( BIGINT ( 0xe7, 0x4f, 0xd4, 0x80 ),
 980                            BIGINT ( 0xb5, 0xf9, 0x9b, 0x90 ),
 981                            1 );
 982         bigint_is_geq_ok ( BIGINT ( 0xb5, 0xf9, 0x9b, 0x90 ),
 983                            BIGINT ( 0xe7, 0x4f, 0xd4, 0x80 ),
 984                            0 );
 985         bigint_is_geq_ok ( BIGINT ( 0xe7, 0x4f, 0xd4, 0x80 ),
 986                            BIGINT ( 0xe7, 0x4f, 0xd4, 0x80 ),
 987                            1 );
 988         bigint_is_geq_ok ( BIGINT ( 0xe6, 0x2c, 0x7c, 0x24, 0x78, 0x8f, 0x12,
 989                                     0x20, 0xde, 0xd3, 0x6b, 0xc9, 0x97, 0x2d,
 990                                     0x66, 0x74, 0xe5, 0xb6, 0xf7, 0x8f, 0x2b,
 991                                     0x60, 0x98 ),
 992                            BIGINT ( 0x77, 0xbc, 0x3b, 0x1b, 0x57, 0x43, 0x3b,
 993                                     0x8c, 0x82, 0xda, 0xb5, 0xc7, 0x18, 0x09,
 994                                     0xb3, 0x59, 0x0e, 0x53, 0x2a, 0xb9, 0xd8,
 995                                     0xa2, 0xb4 ),
 996                            1 );
 997         bigint_is_geq_ok ( BIGINT ( 0x77, 0xbc, 0x3b, 0x1b, 0x57, 0x43, 0x3b,
 998                                     0x8c, 0x82, 0xda, 0xb5, 0xc7, 0x18, 0x09,
 999                                     0xb3, 0x59, 0x0e, 0x53, 0x2a, 0xb9, 0xd8,
1000                                     0xa2, 0xb4 ),
1001                            BIGINT ( 0xe6, 0x2c, 0x7c, 0x24, 0x78, 0x8f, 0x12,
1002                                     0x20, 0xde, 0xd3, 0x6b, 0xc9, 0x97, 0x2d,
1003                                     0x66, 0x74, 0xe5, 0xb6, 0xf7, 0x8f, 0x2b,
1004                                     0x60, 0x98 ),
1005                            0 );
1006         bigint_is_geq_ok ( BIGINT ( 0xe6, 0x2c, 0x7c, 0x24, 0x78, 0x8f, 0x12,
1007                                     0x20, 0xde, 0xd3, 0x6b, 0xc9, 0x97, 0x2d,
1008                                     0x66, 0x74, 0xe5, 0xb6, 0xf7, 0x8f, 0x2b,
1009                                     0x60, 0x98 ),
1010                            BIGINT ( 0xe6, 0x2c, 0x7c, 0x24, 0x78, 0x8f, 0x12,
1011                                     0x20, 0xde, 0xd3, 0x6b, 0xc9, 0x97, 0x2d,
1012                                     0x66, 0x74, 0xe5, 0xb6, 0xf7, 0x8f, 0x2b,
1013                                     0x60, 0x98 ),
1014                            1 );
1015         bigint_is_geq_ok ( BIGINT ( 0x2a, 0x98, 0xfd, 0x87, 0x5d, 0x9f, 0xb4,
1016                                     0x8b, 0x5c, 0xcd, 0x5f, 0xcd, 0x53, 0xb3,
1017                                     0xd1, 0x81, 0x6a, 0x9c, 0x93, 0x66, 0x40,
1018                                     0xa7, 0x64, 0xe0, 0x8c, 0xec, 0x96, 0x63,
1019                                     0x4d, 0x29, 0xfa, 0xb1, 0x5d, 0x93, 0x2f,
1020                                     0xf9, 0x36, 0xea, 0x3b, 0xc1, 0xaf, 0x85,
1021                                     0xcb, 0xde, 0x2d, 0xc8, 0x48, 0x33, 0xce,
1022                                     0x7b, 0xa4, 0xa4, 0xda, 0x0f, 0xaa, 0x1b,
1023                                     0xcb, 0xed, 0xbe, 0x3a, 0xa5, 0xbb, 0x73,
1024                                     0x28, 0x04, 0xc6, 0x2a, 0xfb, 0x3a, 0xc3,
1025                                     0xae, 0x42, 0x1f, 0x53, 0x6c, 0xb2, 0x76,
1026                                     0xb7, 0xe2, 0x88, 0xcb, 0x88, 0xcf, 0xf0,
1027                                     0x52, 0x81, 0xd3, 0xb2, 0x1f, 0x56, 0xe1,
1028                                     0xe1, 0x47, 0x93, 0x6f, 0x2b, 0x49, 0xaa,
1029                                     0x50, 0x99, 0x7a, 0xc4, 0x56, 0xb7, 0x13,
1030                                     0x80, 0xf4, 0x73, 0x88, 0xc7, 0x39, 0x83,
1031                                     0x67, 0xc7, 0xcc, 0xb2, 0x28, 0x7a, 0xd3,
1032                                     0xdc, 0x48, 0xea, 0x62, 0x0d, 0xf5, 0x5a,
1033                                     0x27, 0x96 ),
1034                            BIGINT ( 0xd4, 0x6b, 0x0a, 0x2e, 0x9f, 0xde, 0x4b,
1035                                     0x64, 0xfa, 0x6b, 0x37, 0x73, 0x66, 0x06,
1036                                     0xee, 0x04, 0xef, 0xe6, 0x3c, 0x7d, 0x57,
1037                                     0x22, 0x7f, 0x1f, 0x62, 0x1c, 0x7e, 0x20,
1038                                     0xda, 0x97, 0xd0, 0x27, 0x23, 0xf6, 0x77,
1039                                     0x5b, 0x49, 0x97, 0xe1, 0x65, 0x91, 0x13,
1040                                     0x93, 0xd6, 0x12, 0xc3, 0x66, 0x91, 0x76,
1041                                     0xe8, 0x47, 0x4c, 0x6a, 0x1b, 0xa2, 0x02,
1042                                     0xf8, 0x94, 0xaa, 0xe0, 0x1b, 0x0b, 0x17,
1043                                     0x86, 0x5e, 0xf5, 0x17, 0x23, 0xf5, 0x17,
1044                                     0x91, 0x6b, 0xd7, 0x2f, 0x5a, 0xfe, 0x8a,
1045                                     0x63, 0x28, 0x31, 0x1e, 0x09, 0x60, 0x29,
1046                                     0x5d, 0x55, 0xd8, 0x79, 0xeb, 0x78, 0x36,
1047                                     0x44, 0x69, 0xa4, 0x76, 0xa5, 0x35, 0x30,
1048                                     0xca, 0xc9, 0xf9, 0x62, 0xd7, 0x82, 0x13,
1049                                     0x56, 0xd0, 0x58, 0xfe, 0x16, 0x4b, 0xfb,
1050                                     0xa8, 0x4c, 0xb3, 0xd7, 0xcf, 0x5f, 0x93,
1051                                     0x9d, 0xc4, 0x11, 0xb4, 0xdd, 0xf8, 0x8f,
1052                                     0xe1, 0x11 ),
1053                            0 );
1054         bigint_is_geq_ok ( BIGINT ( 0xd4, 0x6b, 0x0a, 0x2e, 0x9f, 0xde, 0x4b,
1055                                     0x64, 0xfa, 0x6b, 0x37, 0x73, 0x66, 0x06,
1056                                     0xee, 0x04, 0xef, 0xe6, 0x3c, 0x7d, 0x57,
1057                                     0x22, 0x7f, 0x1f, 0x62, 0x1c, 0x7e, 0x20,
1058                                     0xda, 0x97, 0xd0, 0x27, 0x23, 0xf6, 0x77,
1059                                     0x5b, 0x49, 0x97, 0xe1, 0x65, 0x91, 0x13,
1060                                     0x93, 0xd6, 0x12, 0xc3, 0x66, 0x91, 0x76,
1061                                     0xe8, 0x47, 0x4c, 0x6a, 0x1b, 0xa2, 0x02,
1062                                     0xf8, 0x94, 0xaa, 0xe0, 0x1b, 0x0b, 0x17,
1063                                     0x86, 0x5e, 0xf5, 0x17, 0x23, 0xf5, 0x17,
1064                                     0x91, 0x6b, 0xd7, 0x2f, 0x5a, 0xfe, 0x8a,
1065                                     0x63, 0x28, 0x31, 0x1e, 0x09, 0x60, 0x29,
1066                                     0x5d, 0x55, 0xd8, 0x79, 0xeb, 0x78, 0x36,
1067                                     0x44, 0x69, 0xa4, 0x76, 0xa5, 0x35, 0x30,
1068                                     0xca, 0xc9, 0xf9, 0x62, 0xd7, 0x82, 0x13,
1069                                     0x56, 0xd0, 0x58, 0xfe, 0x16, 0x4b, 0xfb,
1070                                     0xa8, 0x4c, 0xb3, 0xd7, 0xcf, 0x5f, 0x93,
1071                                     0x9d, 0xc4, 0x11, 0xb4, 0xdd, 0xf8, 0x8f,
1072                                     0xe1, 0x11 ),
1073                            BIGINT ( 0x2a, 0x98, 0xfd, 0x87, 0x5d, 0x9f, 0xb4,
1074                                     0x8b, 0x5c, 0xcd, 0x5f, 0xcd, 0x53, 0xb3,
1075                                     0xd1, 0x81, 0x6a, 0x9c, 0x93, 0x66, 0x40,
1076                                     0xa7, 0x64, 0xe0, 0x8c, 0xec, 0x96, 0x63,
1077                                     0x4d, 0x29, 0xfa, 0xb1, 0x5d, 0x93, 0x2f,
1078                                     0xf9, 0x36, 0xea, 0x3b, 0xc1, 0xaf, 0x85,
1079                                     0xcb, 0xde, 0x2d, 0xc8, 0x48, 0x33, 0xce,
1080                                     0x7b, 0xa4, 0xa4, 0xda, 0x0f, 0xaa, 0x1b,
1081                                     0xcb, 0xed, 0xbe, 0x3a, 0xa5, 0xbb, 0x73,
1082                                     0x28, 0x04, 0xc6, 0x2a, 0xfb, 0x3a, 0xc3,
1083                                     0xae, 0x42, 0x1f, 0x53, 0x6c, 0xb2, 0x76,
1084                                     0xb7, 0xe2, 0x88, 0xcb, 0x88, 0xcf, 0xf0,
1085                                     0x52, 0x81, 0xd3, 0xb2, 0x1f, 0x56, 0xe1,
1086                                     0xe1, 0x47, 0x93, 0x6f, 0x2b, 0x49, 0xaa,
1087                                     0x50, 0x99, 0x7a, 0xc4, 0x56, 0xb7, 0x13,
1088                                     0x80, 0xf4, 0x73, 0x88, 0xc7, 0x39, 0x83,
1089                                     0x67, 0xc7, 0xcc, 0xb2, 0x28, 0x7a, 0xd3,
1090                                     0xdc, 0x48, 0xea, 0x62, 0x0d, 0xf5, 0x5a,
1091                                     0x27, 0x96 ),
1092                            1 );
1093         bigint_is_geq_ok ( BIGINT ( 0x2a, 0x98, 0xfd, 0x87, 0x5d, 0x9f, 0xb4,
1094                                     0x8b, 0x5c, 0xcd, 0x5f, 0xcd, 0x53, 0xb3,
1095                                     0xd1, 0x81, 0x6a, 0x9c, 0x93, 0x66, 0x40,
1096                                     0xa7, 0x64, 0xe0, 0x8c, 0xec, 0x96, 0x63,
1097                                     0x4d, 0x29, 0xfa, 0xb1, 0x5d, 0x93, 0x2f,
1098                                     0xf9, 0x36, 0xea, 0x3b, 0xc1, 0xaf, 0x85,
1099                                     0xcb, 0xde, 0x2d, 0xc8, 0x48, 0x33, 0xce,
1100                                     0x7b, 0xa4, 0xa4, 0xda, 0x0f, 0xaa, 0x1b,
1101                                     0xcb, 0xed, 0xbe, 0x3a, 0xa5, 0xbb, 0x73,
1102                                     0x28, 0x04, 0xc6, 0x2a, 0xfb, 0x3a, 0xc3,
1103                                     0xae, 0x42, 0x1f, 0x53, 0x6c, 0xb2, 0x76,
1104                                     0xb7, 0xe2, 0x88, 0xcb, 0x88, 0xcf, 0xf0,
1105                                     0x52, 0x81, 0xd3, 0xb2, 0x1f, 0x56, 0xe1,
1106                                     0xe1, 0x47, 0x93, 0x6f, 0x2b, 0x49, 0xaa,
1107                                     0x50, 0x99, 0x7a, 0xc4, 0x56, 0xb7, 0x13,
1108                                     0x80, 0xf4, 0x73, 0x88, 0xc7, 0x39, 0x83,
1109                                     0x67, 0xc7, 0xcc, 0xb2, 0x28, 0x7a, 0xd3,
1110                                     0xdc, 0x48, 0xea, 0x62, 0x0d, 0xf5, 0x5a,
1111                                     0x27, 0x96 ),
1112                            BIGINT ( 0x2a, 0x98, 0xfd, 0x87, 0x5d, 0x9f, 0xb4,
1113                                     0x8b, 0x5c, 0xcd, 0x5f, 0xcd, 0x53, 0xb3,
1114                                     0xd1, 0x81, 0x6a, 0x9c, 0x93, 0x66, 0x40,
1115                                     0xa7, 0x64, 0xe0, 0x8c, 0xec, 0x96, 0x63,
1116                                     0x4d, 0x29, 0xfa, 0xb1, 0x5d, 0x93, 0x2f,
1117                                     0xf9, 0x36, 0xea, 0x3b, 0xc1, 0xaf, 0x85,
1118                                     0xcb, 0xde, 0x2d, 0xc8, 0x48, 0x33, 0xce,
1119                                     0x7b, 0xa4, 0xa4, 0xda, 0x0f, 0xaa, 0x1b,
1120                                     0xcb, 0xed, 0xbe, 0x3a, 0xa5, 0xbb, 0x73,
1121                                     0x28, 0x04, 0xc6, 0x2a, 0xfb, 0x3a, 0xc3,
1122                                     0xae, 0x42, 0x1f, 0x53, 0x6c, 0xb2, 0x76,
1123                                     0xb7, 0xe2, 0x88, 0xcb, 0x88, 0xcf, 0xf0,
1124                                     0x52, 0x81, 0xd3, 0xb2, 0x1f, 0x56, 0xe1,
1125                                     0xe1, 0x47, 0x93, 0x6f, 0x2b, 0x49, 0xaa,
1126                                     0x50, 0x99, 0x7a, 0xc4, 0x56, 0xb7, 0x13,
1127                                     0x80, 0xf4, 0x73, 0x88, 0xc7, 0x39, 0x83,
1128                                     0x67, 0xc7, 0xcc, 0xb2, 0x28, 0x7a, 0xd3,
1129                                     0xdc, 0x48, 0xea, 0x62, 0x0d, 0xf5, 0x5a,
1130                                     0x27, 0x96 ),
1131                            1 );
1132         bigint_bit_is_set_ok ( BIGINT ( 0x37 ),
1133                                0, 1 );
1134         bigint_bit_is_set_ok ( BIGINT ( 0xe6, 0xcb ),
1135                                0, 1 );
1136         bigint_bit_is_set_ok ( BIGINT ( 0xd9, 0x0c, 0x5b ),
1137                                0, 1 );
1138         bigint_bit_is_set_ok ( BIGINT ( 0x8b, 0x56, 0x89, 0xaf ),
1139                                0, 1 );
1140         bigint_bit_is_set_ok ( BIGINT ( 0x25, 0xfc, 0xaf, 0xeb, 0x81, 0xc3,
1141                                         0xb8, 0x2f, 0xbb, 0xe3, 0x07, 0xb2,
1142                                         0xe2, 0x2a, 0xe2, 0x2d, 0xb4, 0x4d,
1143                                         0x6d, 0xec, 0x51, 0xa0, 0x2f ),
1144                                0, 1 );
1145         bigint_bit_is_set_ok ( BIGINT ( 0x25, 0xfc, 0xaf, 0xeb, 0x81, 0xc3,
1146                                         0xb8, 0x2f, 0xbb, 0xe3, 0x07, 0xb2,
1147                                         0xe2, 0x2a, 0xe2, 0x2d, 0xb4, 0x4d,
1148                                         0x6d, 0xec, 0x51, 0xa0, 0x2f ),
1149                                45, 0 );
1150         bigint_bit_is_set_ok ( BIGINT ( 0x88, 0x04, 0xec, 0xe6, 0xfb, 0x31,
1151                                         0x87, 0x43, 0xb2, 0x04, 0x9e, 0x09,
1152                                         0xba, 0x3e, 0x6d, 0x64, 0x1a, 0x85,
1153                                         0xb6, 0x46, 0x7d, 0x71, 0x3c, 0x06,
1154                                         0xd6, 0x40, 0x52, 0x39, 0x95, 0xa1,
1155                                         0x06, 0xff, 0x6a, 0x5c, 0xa3, 0x6d,
1156                                         0x4a, 0xc9, 0x77, 0x87, 0x75, 0x25,
1157                                         0x57, 0x65, 0x72, 0x73, 0x64, 0x7e,
1158                                         0xe9, 0x16, 0x17, 0xf3, 0x65, 0x3f,
1159                                         0xd5, 0xcc, 0xd7, 0xa2, 0xee, 0xe7,
1160                                         0x8d, 0x48, 0xd5, 0x7e, 0xdd, 0x59,
1161                                         0x4b, 0xf0, 0x96, 0x8b, 0x21, 0x65,
1162                                         0x04, 0x66, 0xc5, 0xff, 0x3e, 0x60,
1163                                         0xba, 0x28, 0x38, 0x7d, 0x9c, 0x09,
1164                                         0xd1, 0x8e, 0xac, 0x73, 0x8e, 0xf2,
1165                                         0x1e, 0xdf, 0x83, 0x6e, 0x54, 0xd5,
1166                                         0x34, 0xc1, 0xc6, 0xf9, 0x62, 0x2a,
1167                                         0x7d, 0xec, 0x47, 0xf2, 0xfc, 0xa2,
1168                                         0x10, 0x0a, 0x67, 0x1b, 0xc6, 0x11,
1169                                         0x9d, 0x68, 0x25, 0x8b, 0xb5, 0x9b,
1170                                         0x83, 0xf8, 0xa2, 0x11, 0xf5, 0xd4,
1171                                         0xcb, 0xe0 ),
1172                                0, 0 );
1173         bigint_bit_is_set_ok ( BIGINT ( 0x88, 0x04, 0xec, 0xe6, 0xfb, 0x31,
1174                                         0x87, 0x43, 0xb2, 0x04, 0x9e, 0x09,
1175                                         0xba, 0x3e, 0x6d, 0x64, 0x1a, 0x85,
1176                                         0xb6, 0x46, 0x7d, 0x71, 0x3c, 0x06,
1177                                         0xd6, 0x40, 0x52, 0x39, 0x95, 0xa1,
1178                                         0x06, 0xff, 0x6a, 0x5c, 0xa3, 0x6d,
1179                                         0x4a, 0xc9, 0x77, 0x87, 0x75, 0x25,
1180                                         0x57, 0x65, 0x72, 0x73, 0x64, 0x7e,
1181                                         0xe9, 0x16, 0x17, 0xf3, 0x65, 0x3f,
1182                                         0xd5, 0xcc, 0xd7, 0xa2, 0xee, 0xe7,
1183                                         0x8d, 0x48, 0xd5, 0x7e, 0xdd, 0x59,
1184                                         0x4b, 0xf0, 0x96, 0x8b, 0x21, 0x65,
1185                                         0x04, 0x66, 0xc5, 0xff, 0x3e, 0x60,
1186                                         0xba, 0x28, 0x38, 0x7d, 0x9c, 0x09,
1187                                         0xd1, 0x8e, 0xac, 0x73, 0x8e, 0xf2,
1188                                         0x1e, 0xdf, 0x83, 0x6e, 0x54, 0xd5,
1189                                         0x34, 0xc1, 0xc6, 0xf9, 0x62, 0x2a,
1190                                         0x7d, 0xec, 0x47, 0xf2, 0xfc, 0xa2,
1191                                         0x10, 0x0a, 0x67, 0x1b, 0xc6, 0x11,
1192                                         0x9d, 0x68, 0x25, 0x8b, 0xb5, 0x9b,
1193                                         0x83, 0xf8, 0xa2, 0x11, 0xf5, 0xd4,
1194                                         0xcb, 0xe0 ),
1195                                45, 1 );
1196         bigint_bit_is_set_ok ( BIGINT ( 0x88, 0x04, 0xec, 0xe6, 0xfb, 0x31,
1197                                         0x87, 0x43, 0xb2, 0x04, 0x9e, 0x09,
1198                                         0xba, 0x3e, 0x6d, 0x64, 0x1a, 0x85,
1199                                         0xb6, 0x46, 0x7d, 0x71, 0x3c, 0x06,
1200                                         0xd6, 0x40, 0x52, 0x39, 0x95, 0xa1,
1201                                         0x06, 0xff, 0x6a, 0x5c, 0xa3, 0x6d,
1202                                         0x4a, 0xc9, 0x77, 0x87, 0x75, 0x25,
1203                                         0x57, 0x65, 0x72, 0x73, 0x64, 0x7e,
1204                                         0xe9, 0x16, 0x17, 0xf3, 0x65, 0x3f,
1205                                         0xd5, 0xcc, 0xd7, 0xa2, 0xee, 0xe7,
1206                                         0x8d, 0x48, 0xd5, 0x7e, 0xdd, 0x59,
1207                                         0x4b, 0xf0, 0x96, 0x8b, 0x21, 0x65,
1208                                         0x04, 0x66, 0xc5, 0xff, 0x3e, 0x60,
1209                                         0xba, 0x28, 0x38, 0x7d, 0x9c, 0x09,
1210                                         0xd1, 0x8e, 0xac, 0x73, 0x8e, 0xf2,
1211                                         0x1e, 0xdf, 0x83, 0x6e, 0x54, 0xd5,
1212                                         0x34, 0xc1, 0xc6, 0xf9, 0x62, 0x2a,
1213                                         0x7d, 0xec, 0x47, 0xf2, 0xfc, 0xa2,
1214                                         0x10, 0x0a, 0x67, 0x1b, 0xc6, 0x11,
1215                                         0x9d, 0x68, 0x25, 0x8b, 0xb5, 0x9b,
1216                                         0x83, 0xf8, 0xa2, 0x11, 0xf5, 0xd4,
1217                                         0xcb, 0xe0 ),
1218                                1013, 0 );
1219         bigint_max_set_bit_ok ( BIGINT ( 0x3a ),
1220                                 6 );
1221         bigint_max_set_bit_ok ( BIGINT ( 0x03 ),
1222                                 2 );
1223         bigint_max_set_bit_ok ( BIGINT ( 0x00 ),
1224                                 0 );
1225         bigint_max_set_bit_ok ( BIGINT ( 0xff ),
1226                                 8 );
1227         bigint_max_set_bit_ok ( BIGINT ( 0x20, 0x30 ),
1228                                 14 );
1229         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x10 ),
1230                                 5 );
1231         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00 ),
1232                                 0 );
1233         bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff ),
1234                                 16 );
1235         bigint_max_set_bit_ok ( BIGINT ( 0x06, 0xdb, 0x7a ),
1236                                 19 );
1237         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00 ),
1238                                 0 );
1239         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00 ),
1240                                 0 );
1241         bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff, 0xff ),
1242                                 24 );
1243         bigint_max_set_bit_ok ( BIGINT ( 0xee, 0xcb, 0x7b, 0xfd ),
1244                                 32 );
1245         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x01, 0xdd ),
1246                                 9 );
1247         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00 ),
1248                                 0 );
1249         bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff ),
1250                                 32 );
1251         bigint_max_set_bit_ok ( BIGINT ( 0x32, 0x39, 0x96, 0x52, 0x10, 0x67,
1252                                          0x7e, 0x32, 0xfc, 0x4e, 0x56, 0xc3,
1253                                          0x68, 0x18, 0x76, 0x1a, 0xac, 0x0e,
1254                                          0x93, 0xee, 0x55, 0xc5, 0x6e ),
1255                                 182 );
1256         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1257                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1258                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1259                                          0x00, 0x00, 0xc8, 0xe6, 0x59 ),
1260                                 24 );
1261         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1262                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1263                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1264                                          0x00, 0x00, 0x00, 0x00, 0x00 ),
1265                                 0 );
1266         bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1267                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1268                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1269                                          0xff, 0xff, 0xff, 0xff, 0xff ),
1270                                 184 );
1271         bigint_max_set_bit_ok ( BIGINT ( 0xcd, 0xb3, 0x22, 0x30, 0xdd, 0xa7,
1272                                          0xff, 0x37, 0xbf, 0xe3, 0x38, 0xf7,
1273                                          0xe1, 0x41, 0x73, 0xea, 0x3a, 0xfc,
1274                                          0x78, 0x9e, 0xfb, 0x4f, 0x85, 0xdc,
1275                                          0x1c, 0x40, 0x89, 0x6e, 0xda, 0xf9,
1276                                          0x9d, 0x6d, 0x12, 0x97, 0xb1, 0x80,
1277                                          0x2a, 0xeb, 0x91, 0xce, 0x3b, 0x83,
1278                                          0xb8, 0xa5, 0x3d, 0xce, 0x46, 0x56,
1279                                          0xb7, 0xd1, 0x28, 0xbc, 0x93, 0x4e,
1280                                          0x8c, 0x29, 0x6d, 0x2c, 0xcc, 0x58,
1281                                          0x49, 0x2f, 0x37, 0xa0, 0x08, 0x37,
1282                                          0x86, 0xdd, 0x38, 0x21, 0xa7, 0x57,
1283                                          0x37, 0xe3, 0xc5, 0xcc, 0x50, 0x11,
1284                                          0x1a, 0xe4, 0xea, 0xe7, 0x4d, 0x3c,
1285                                          0x37, 0x65, 0x78, 0xd1, 0xf6, 0xc3,
1286                                          0x94, 0x46, 0xd4, 0x0e, 0xd3, 0x9a,
1287                                          0x21, 0x8b, 0xa6, 0x54, 0xc0, 0xd2,
1288                                          0x88, 0x07, 0x24, 0xbf, 0x7d, 0x31,
1289                                          0xfd, 0x15, 0xa8, 0x92, 0x65, 0xe1,
1290                                          0x8d, 0xed, 0x70, 0x7b, 0x68, 0x0f,
1291                                          0xcc, 0x13, 0xb9, 0xb2, 0xdd, 0x3c,
1292                                          0x6a, 0x52 ),
1293                                 1024 );
1294         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1295                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1296                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1297                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1298                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1299                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1300                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1301                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1302                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1303                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1304                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1305                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1306                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1307                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1308                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1309                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1310                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1311                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1312                                          0x00, 0x00, 0x00, 0x00, 0x66, 0xd9,
1313                                          0x91, 0x18, 0x6e, 0xd3, 0xff, 0x9b,
1314                                          0xdf, 0xf1, 0x9c, 0x7b, 0xf0, 0xa0,
1315                                          0xb9, 0xf5 ),
1316                                 127 );
1317         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1318                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1319                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1320                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1321                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1322                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1323                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1324                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1325                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1326                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1327                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1328                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1329                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1330                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1331                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1332                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1333                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1334                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1335                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1336                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1337                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1338                                          0x00, 0x00 ),
1339                                 0 );
1340         bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1341                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1342                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1343                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1344                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1345                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1346                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1347                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1348                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1349                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1350                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1351                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1352                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1353                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1354                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1355                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1356                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1357                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1358                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1359                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1360                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1361                                          0xff, 0xff ),
1362                                 1024 );
1363         bigint_multiply_ok ( BIGINT ( 0xf0 ),
1364                              BIGINT ( 0xeb ),
1365                              BIGINT ( 0xdc, 0x50 ) );
1366         bigint_multiply_ok ( BIGINT ( 0xd7, 0x16 ),
1367                              BIGINT ( 0x88, 0xfb ),
1368                              BIGINT ( 0x73, 0x16, 0x92, 0x92 ) );
1369         bigint_multiply_ok ( BIGINT ( 0xfe, 0xed, 0x1d ),
1370                              BIGINT ( 0x69, 0x9c, 0x03 ),
1371                              BIGINT ( 0x69, 0x2a, 0x9c, 0x5f, 0x73, 0x57 ) );
1372         bigint_multiply_ok ( BIGINT ( 0x96, 0xe9, 0x6f, 0x81 ),
1373                              BIGINT ( 0x67, 0x3c, 0x5a, 0x16 ),
1374                              BIGINT ( 0x3c, 0xdb, 0x7f, 0xae, 0x12, 0x7e,
1375                                       0xef, 0x16 ) );
1376         bigint_multiply_ok ( BIGINT ( 0xe8, 0x08, 0x0b, 0xe9, 0x29, 0x36,
1377                                       0xea, 0x51, 0x1d, 0x75, 0x1a, 0xd5,
1378                                       0xba, 0xc6, 0xa0, 0xf3, 0x48, 0x5c,
1379                                       0xdf, 0x42, 0xdf, 0x28, 0x38 ),
1380                              BIGINT ( 0x22, 0x07, 0x41, 0x54, 0x4e, 0xf9,
1381                                       0x90, 0xa8, 0xaf, 0xba, 0xf6, 0xb0,
1382                                       0x35, 0x7e, 0x98, 0xef, 0x2c, 0x31,
1383                                       0xc9, 0xa7, 0x25, 0x74, 0x8d ),
1384                              BIGINT ( 0x1e, 0xd7, 0xa5, 0x03, 0xc0, 0x18,
1385                                       0x2e, 0x29, 0xb1, 0x3e, 0x96, 0x71,
1386                                       0x90, 0xa5, 0x6d, 0x43, 0x58, 0xf7,
1387                                       0x22, 0x80, 0x0b, 0x21, 0xc6, 0x70,
1388                                       0x90, 0x1c, 0xa8, 0x85, 0x87, 0xaf,
1389                                       0xd7, 0xdd, 0x27, 0x69, 0xaf, 0x20,
1390                                       0xa0, 0x2d, 0x43, 0x5d, 0xda, 0xba,
1391                                       0x4b, 0x3a, 0x86, 0xd8 ) );
1392         bigint_multiply_ok ( BIGINT ( 0xa2, 0x0f, 0xc6, 0x08, 0x0a, 0x01,
1393                                       0x19, 0x42, 0x0e, 0xaa, 0x5c, 0xae,
1394                                       0x4f, 0x4e, 0xb0, 0xad, 0xb2, 0xe8,
1395                                       0xee, 0xd5, 0x65, 0xec, 0x5a, 0xda,
1396                                       0xc0, 0xba, 0x78, 0xa8, 0x0f, 0x15,
1397                                       0x39, 0xd7, 0x7a, 0x10, 0xc2, 0xa7,
1398                                       0xec, 0x44, 0xac, 0xad, 0x39, 0x04,
1399                                       0x2e, 0x66, 0x54, 0x70, 0x57, 0xee,
1400                                       0xf6, 0x97, 0x19, 0x71, 0x16, 0xf9,
1401                                       0xbb, 0x2e, 0x84, 0x09, 0x6e, 0x9a,
1402                                       0x3b, 0x16, 0xb2, 0x65, 0x74, 0x50,
1403                                       0x19, 0xd1, 0xe9, 0x95, 0xa0, 0x7b,
1404                                       0x33, 0xb5, 0xac, 0x7c, 0x9e, 0xd4,
1405                                       0x68, 0x0d, 0xc9, 0xe4, 0x03, 0x86,
1406                                       0x1a, 0xa3, 0x42, 0x33, 0x28, 0x14,
1407                                       0x12, 0x7d, 0x5a, 0xd9, 0x30, 0x18,
1408                                       0x0a, 0xf4, 0x0c, 0x96, 0x58, 0xc9,
1409                                       0xb5, 0x37, 0xdb, 0x49, 0xdc, 0x01,
1410                                       0x4a, 0xcb, 0x6d, 0x87, 0x52, 0xf6,
1411                                       0xae, 0xa7, 0x71, 0x31, 0x9a, 0x1a,
1412                                       0xe2, 0x1c, 0x87, 0x51, 0xc9, 0xeb,
1413                                       0x70, 0x71 ),
1414                              BIGINT ( 0x7c, 0xdd, 0x2f, 0x5d, 0x27, 0xfe,
1415                                       0xca, 0x70, 0x96, 0xc3, 0xb1, 0x1f,
1416                                       0xac, 0xa9, 0x3a, 0xdc, 0xcd, 0xbc,
1417                                       0x58, 0xb4, 0xde, 0xe7, 0xe5, 0x34,
1418                                       0x1a, 0xc0, 0xb9, 0x46, 0xf7, 0x52,
1419                                       0x76, 0x23, 0xe8, 0xe9, 0x92, 0xa1,
1420                                       0x86, 0x3c, 0x6f, 0xf1, 0x22, 0xf4,
1421                                       0x72, 0xb1, 0xde, 0xd3, 0x8f, 0x11,
1422                                       0x9e, 0x52, 0xe5, 0x81, 0x54, 0xe9,
1423                                       0xa7, 0x72, 0x3f, 0x3e, 0xa0, 0x80,
1424                                       0xbb, 0xae, 0x0e, 0x30, 0x6a, 0x11,
1425                                       0x91, 0x11, 0x3b, 0x3f, 0x44, 0x1f,
1426                                       0x8d, 0x4d, 0xea, 0xdd, 0x09, 0x95,
1427                                       0x9d, 0x02, 0xa6, 0x6d, 0x3b, 0x08,
1428                                       0x40, 0x8d, 0xb4, 0x4b, 0x05, 0x74,
1429                                       0x8c, 0x1f, 0xaa, 0x61, 0x6f, 0x0e,
1430                                       0xcc, 0xcf, 0xe0, 0x81, 0x03, 0xe4,
1431                                       0x9b, 0x11, 0xd9, 0xab, 0xf3, 0x24,
1432                                       0xe2, 0x3b, 0xe0, 0x05, 0x60, 0x65,
1433                                       0x16, 0xc6, 0x2e, 0x83, 0xa0, 0x98,
1434                                       0x8e, 0x11, 0x05, 0x00, 0xe4, 0x3f,
1435                                       0x7e, 0x65 ),
1436                              BIGINT ( 0x4f, 0x0b, 0xa9, 0x85, 0xb8, 0x31,
1437                                       0x48, 0xea, 0x11, 0x44, 0xaf, 0x2d,
1438                                       0xed, 0x1a, 0x76, 0x45, 0xac, 0x87,
1439                                       0x0c, 0xf3, 0xd7, 0xc4, 0x8e, 0x5c,
1440                                       0xd7, 0xdf, 0x28, 0x74, 0xa6, 0x40,
1441                                       0xe4, 0x6b, 0x5b, 0x19, 0x36, 0x37,
1442                                       0x9c, 0xcd, 0x43, 0x76, 0x15, 0x00,
1443                                       0x5d, 0x23, 0xa2, 0x8a, 0x53, 0x25,
1444                                       0xbf, 0x18, 0xda, 0xe6, 0x09, 0xdf,
1445                                       0xaa, 0xeb, 0x9a, 0x82, 0x01, 0x14,
1446                                       0x2b, 0x20, 0x2b, 0xb6, 0x22, 0x62,
1447                                       0x6b, 0xcc, 0xd4, 0xc9, 0x02, 0x67,
1448                                       0x95, 0x43, 0x75, 0x4e, 0x97, 0x4e,
1449                                       0xec, 0x04, 0xde, 0x29, 0x0a, 0xef,
1450                                       0xf7, 0xc1, 0x72, 0x8c, 0x64, 0x38,
1451                                       0x16, 0x47, 0x9f, 0x16, 0x0c, 0xa5,
1452                                       0x79, 0x6b, 0xea, 0x2e, 0x4c, 0x3d,
1453                                       0x0c, 0xe6, 0x57, 0x51, 0x65, 0xa5,
1454                                       0x3b, 0xca, 0xae, 0x54, 0x0c, 0x67,
1455                                       0xf8, 0x23, 0x00, 0xc9, 0x8d, 0xe6,
1456                                       0x16, 0x91, 0x19, 0xb3, 0x5b, 0x68,
1457                                       0x7b, 0xf2, 0xe2, 0x5d, 0x69, 0x48,
1458                                       0x3f, 0x2b, 0xa0, 0x4f, 0x7c, 0x3c,
1459                                       0x26, 0xf9, 0xd9, 0xfd, 0x3d, 0x5d,
1460                                       0xd6, 0x05, 0x00, 0xd8, 0xdf, 0x5a,
1461                                       0x56, 0x8f, 0x16, 0x68, 0x4f, 0x15,
1462                                       0x19, 0x9d, 0xd7, 0x11, 0x51, 0x7d,
1463                                       0x73, 0x5c, 0xd4, 0xd5, 0xb4, 0xc7,
1464                                       0x42, 0xe3, 0xee, 0xf1, 0x67, 0xd6,
1465                                       0x69, 0x72, 0x04, 0x4b, 0x88, 0x3d,
1466                                       0x05, 0xd8, 0x1e, 0x50, 0xcb, 0xce,
1467                                       0x39, 0x19, 0x42, 0xb6, 0xa7, 0xf3,
1468                                       0xba, 0x78, 0x90, 0xd2, 0x09, 0x05,
1469                                       0x87, 0xf8, 0xc0, 0x9c, 0x47, 0xff,
1470                                       0xbf, 0xaa, 0x21, 0x8d, 0x81, 0x86,
1471                                       0xcd, 0x58, 0xdf, 0x30, 0xf1, 0xd1,
1472                                       0x60, 0x53, 0x85, 0x40, 0xbf, 0x14,
1473                                       0x3e, 0xdc, 0x9e, 0x9e, 0xc4, 0xc7,
1474                                       0x48, 0xa0, 0x83, 0xe0, 0x99, 0x8b,
1475                                       0x43, 0xf8, 0x52, 0x8a, 0x15, 0x88,
1476                                       0x89, 0x83, 0x7d, 0x71, 0xbb, 0x62,
1477                                       0x12, 0x7a, 0x23, 0x85, 0x3a, 0xbb,
1478                                       0xdb, 0x09, 0xfa, 0x95 ) );
1479         bigint_multiply_ok ( BIGINT ( 0xff ),
1480                              BIGINT ( 0xff ),
1481                              BIGINT ( 0xfe, 0x01 ) );
1482         bigint_multiply_ok ( BIGINT ( 0xff, 0xff ),
1483                              BIGINT ( 0xff, 0xff ),
1484                              BIGINT ( 0xff, 0xfe, 0x00, 0x01 ) );
1485         bigint_multiply_ok ( BIGINT ( 0xff, 0xff, 0xff ),
1486                              BIGINT ( 0xff, 0xff, 0xff ),
1487                              BIGINT ( 0xff, 0xff, 0xfe, 0x00, 0x00, 0x01 ) );
1488         bigint_multiply_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff ),
1489                              BIGINT ( 0xff, 0xff, 0xff, 0xff ),
1490                              BIGINT ( 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00,
1491                                       0x00, 0x01 ) );
1492         bigint_multiply_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1493                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1494                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1495                                       0xff, 0xff, 0xff, 0xff, 0xff ),
1496                              BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1497                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1498                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1499                                       0xff, 0xff, 0xff, 0xff, 0xff ),
1500                              BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1501                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1502                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1503                                       0xff, 0xff, 0xff, 0xff, 0xfe, 0x00,
1504                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1505                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1506                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1507                                       0x00, 0x00, 0x00, 0x01 ) );
1508         bigint_multiply_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1509                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1510                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1511                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1512                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1513                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1514                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1515                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1516                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1517                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1518                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1519                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1520                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1521                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1522                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1523                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1524                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1525                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1526                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1527                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1528                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1529                                       0xff, 0xff ),
1530                              BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1531                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1532                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1533                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1534                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1535                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1536                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1537                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1538                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1539                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1540                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1541                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1542                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1543                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1544                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1545                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1546                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1547                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1548                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1549                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1550                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1551                                       0xff, 0xff ),
1552                              BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1553                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1554                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1555                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1556                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1557                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1558                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1559                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1560                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1561                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1562                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1563                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1564                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1565                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1566                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1567                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1568                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1569                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1570                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1571                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1572                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1573                                       0xff, 0xfe, 0x00, 0x00, 0x00, 0x00,
1574                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1575                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1576                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1577                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1578                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1579                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1580                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1581                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1582                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1583                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1584                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1585                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1586                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1587                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1588                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1589                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1590                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1591                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1592                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1593                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1594                                       0x00, 0x00, 0x00, 0x01 ) );
1595         bigint_mod_multiply_ok ( BIGINT ( 0x37 ),
1596                                  BIGINT ( 0x67 ),
1597                                  BIGINT ( 0x3f ),
1598                                  BIGINT ( 0x3a ) );
1599         bigint_mod_multiply_ok ( BIGINT ( 0x45, 0x94 ),
1600                                  BIGINT ( 0xbd, 0xd2 ),
1601                                  BIGINT ( 0xca, 0xc7 ),
1602                                  BIGINT ( 0xac, 0xc1 ) );
1603         bigint_mod_multiply_ok ( BIGINT ( 0x8e, 0xcd, 0x74 ),
1604                                  BIGINT ( 0xe2, 0xf1, 0xea ),
1605                                  BIGINT ( 0x59, 0x51, 0x53 ),
1606                                  BIGINT ( 0x22, 0xdd, 0x1c ) );
1607         bigint_mod_multiply_ok ( BIGINT ( 0xc2, 0xa8, 0x40, 0x6f ),
1608                                  BIGINT ( 0x29, 0xd7, 0xf4, 0x77 ),
1609                                  BIGINT ( 0xbb, 0xbd, 0xdb, 0x3d ),
1610                                  BIGINT ( 0x8f, 0x39, 0xd0, 0x47 ) );
1611         bigint_mod_multiply_ok ( BIGINT ( 0x2e, 0xcb, 0x74, 0x7c, 0x64, 0x60,
1612                                           0xb3, 0x44, 0xf3, 0x23, 0x49, 0x4a,
1613                                           0xc6, 0xb6, 0xbf, 0xea, 0x80, 0xd8,
1614                                           0x34, 0xc5, 0x54, 0x22, 0x09 ),
1615                                  BIGINT ( 0x61, 0x2c, 0x5a, 0xc5, 0xde, 0x07,
1616                                           0x65, 0x8e, 0xab, 0x88, 0x1a, 0x2e,
1617                                           0x7a, 0x95, 0x17, 0xe3, 0x3b, 0x17,
1618                                           0xe4, 0x21, 0xb0, 0xb4, 0x57 ),
1619                                  BIGINT ( 0x8e, 0x46, 0xa5, 0x87, 0x7b, 0x7f,
1620                                           0xc4, 0xd7, 0x31, 0xb1, 0x94, 0xe7,
1621                                           0xe7, 0x1c, 0x7e, 0x7a, 0xc2, 0x6c,
1622                                           0xce, 0xcb, 0xc8, 0x5d, 0x70 ),
1623                                  BIGINT ( 0x1e, 0xd1, 0x5b, 0x3d, 0x1d, 0x17,
1624                                           0x7c, 0x31, 0x95, 0x13, 0x1b, 0xd8,
1625                                           0xee, 0x0a, 0xb0, 0xe1, 0x5b, 0x13,
1626                                           0xad, 0x83, 0xe9, 0xf8, 0x7f ) );
1627         bigint_mod_multiply_ok ( BIGINT ( 0x56, 0x37, 0xab, 0x07, 0x8b, 0x25,
1628                                           0xa7, 0xc2, 0x50, 0x30, 0x43, 0xfc,
1629                                           0x63, 0x8b, 0xdf, 0x84, 0x68, 0x85,
1630                                           0xca, 0xce, 0x44, 0x5c, 0xb1, 0x14,
1631                                           0xa4, 0xb5, 0xba, 0x43, 0xe0, 0x31,
1632                                           0x45, 0x6b, 0x82, 0xa9, 0x0b, 0x9e,
1633                                           0x3a, 0xb0, 0x39, 0x09, 0x2a, 0x68,
1634                                           0x2e, 0x0f, 0x09, 0x54, 0x47, 0x04,
1635                                           0xdb, 0xcf, 0x4a, 0x3a, 0x2d, 0x7b,
1636                                           0x7d, 0x50, 0xa4, 0xc5, 0xeb, 0x13,
1637                                           0xdd, 0x49, 0x61, 0x7d, 0x18, 0xa1,
1638                                           0x0d, 0x6b, 0x58, 0xba, 0x9f, 0x7c,
1639                                           0x81, 0x34, 0x9e, 0xf9, 0x9c, 0x9e,
1640                                           0x28, 0xa8, 0x1c, 0x15, 0x16, 0x20,
1641                                           0x3c, 0x0a, 0xb1, 0x11, 0x06, 0x93,
1642                                           0xbc, 0xd8, 0x4e, 0x49, 0xae, 0x7b,
1643                                           0xb4, 0x02, 0x8b, 0x1c, 0x5b, 0x18,
1644                                           0xb4, 0xac, 0x7f, 0xdd, 0x70, 0xef,
1645                                           0x87, 0xac, 0x1b, 0xac, 0x25, 0xa3,
1646                                           0xc9, 0xa7, 0x3a, 0xc5, 0x76, 0x68,
1647                                           0x09, 0x1f, 0xa1, 0x48, 0x53, 0xb6,
1648                                           0x13, 0xac ),
1649                                  BIGINT ( 0xef, 0x5c, 0x1f, 0x1a, 0x44, 0x64,
1650                                           0x66, 0xcf, 0xdd, 0x3f, 0x0b, 0x27,
1651                                           0x81, 0xa7, 0x91, 0x7a, 0x35, 0x7b,
1652                                           0x0f, 0x46, 0x5e, 0xca, 0xbf, 0xf8,
1653                                           0x50, 0x5e, 0x99, 0x7c, 0xc6, 0x64,
1654                                           0x43, 0x00, 0x9f, 0xb2, 0xda, 0xfa,
1655                                           0x42, 0x15, 0x9c, 0xa3, 0xd6, 0xc8,
1656                                           0x64, 0xa7, 0x65, 0x4a, 0x98, 0xf7,
1657                                           0xb3, 0x96, 0x5f, 0x42, 0xf9, 0x73,
1658                                           0xe1, 0x75, 0xc3, 0xc4, 0x0b, 0x5d,
1659                                           0x5f, 0xf3, 0x04, 0x8a, 0xee, 0x59,
1660                                           0xa6, 0x1b, 0x06, 0x38, 0x0b, 0xa2,
1661                                           0x9f, 0xb4, 0x4f, 0x6d, 0x50, 0x5e,
1662                                           0x37, 0x37, 0x21, 0x83, 0x9d, 0xa3,
1663                                           0x12, 0x16, 0x4d, 0xab, 0x36, 0x51,
1664                                           0x21, 0xb1, 0x74, 0x66, 0x40, 0x9a,
1665                                           0xd3, 0x72, 0xcc, 0x18, 0x40, 0x53,
1666                                           0x89, 0xff, 0xd7, 0x00, 0x8d, 0x7e,
1667                                           0x93, 0x81, 0xdb, 0x29, 0xb6, 0xd7,
1668                                           0x23, 0x2b, 0x67, 0x2f, 0x11, 0x98,
1669                                           0x49, 0x87, 0x2f, 0x46, 0xb7, 0x33,
1670                                           0x6d, 0x12 ),
1671                                  BIGINT ( 0x67, 0x7a, 0x17, 0x6a, 0xd2, 0xf8,
1672                                           0x49, 0xfb, 0x7c, 0x95, 0x25, 0x54,
1673                                           0xf0, 0xab, 0x5b, 0xb3, 0x0e, 0x01,
1674                                           0xab, 0xd3, 0x65, 0x6f, 0x7e, 0x18,
1675                                           0x05, 0xed, 0x9b, 0xc4, 0x90, 0x6c,
1676                                           0xd0, 0x6d, 0x94, 0x79, 0x28, 0xd6,
1677                                           0x24, 0x77, 0x9a, 0x08, 0xd2, 0x2f,
1678                                           0x7c, 0x2d, 0xa0, 0x0c, 0x14, 0xbe,
1679                                           0x7b, 0xee, 0x9e, 0x48, 0x88, 0x3c,
1680                                           0x8f, 0x9f, 0xb9, 0x7a, 0xcb, 0x98,
1681                                           0x76, 0x61, 0x0d, 0xee, 0xa2, 0x42,
1682                                           0x67, 0x1b, 0x2c, 0x42, 0x8f, 0x41,
1683                                           0xcc, 0x78, 0xba, 0xba, 0xaa, 0xa2,
1684                                           0x92, 0xb0, 0x6e, 0x0c, 0x4e, 0xe1,
1685                                           0xa5, 0x13, 0x7d, 0x8a, 0x8f, 0x81,
1686                                           0x95, 0x8a, 0xdf, 0x57, 0x93, 0x88,
1687                                           0x27, 0x4f, 0x1a, 0x59, 0xa4, 0x74,
1688                                           0x22, 0xa9, 0x78, 0xe5, 0xed, 0xb1,
1689                                           0x09, 0x26, 0x59, 0xde, 0x88, 0x21,
1690                                           0x8d, 0xa2, 0xa8, 0x58, 0x10, 0x7b,
1691                                           0x65, 0x96, 0xbf, 0x69, 0x3b, 0xc5,
1692                                           0x55, 0xf8 ),
1693                                  BIGINT ( 0x15, 0xf7, 0x00, 0xeb, 0xc7, 0x5a,
1694                                           0x6f, 0xf0, 0x50, 0xf3, 0x21, 0x8a,
1695                                           0x8e, 0xa6, 0xf6, 0x67, 0x56, 0x7d,
1696                                           0x07, 0x45, 0x89, 0xdb, 0xd7, 0x7e,
1697                                           0x9e, 0x28, 0x7f, 0xfb, 0xed, 0xca,
1698                                           0x2c, 0xbf, 0x47, 0x77, 0x99, 0x95,
1699                                           0xf3, 0xd6, 0x9d, 0xc5, 0x57, 0x81,
1700                                           0x7f, 0x97, 0xf2, 0x6b, 0x24, 0xee,
1701                                           0xce, 0xc5, 0x9b, 0xe6, 0x42, 0x2d,
1702                                           0x37, 0xb7, 0xeb, 0x3d, 0xb5, 0xf7,
1703                                           0x1e, 0x86, 0xc2, 0x40, 0x44, 0xc9,
1704                                           0x85, 0x5a, 0x1a, 0xc0, 0xac, 0x9e,
1705                                           0x78, 0x69, 0x00, 0x7b, 0x93, 0x65,
1706                                           0xd7, 0x7f, 0x0c, 0xd6, 0xba, 0x4f,
1707                                           0x06, 0x00, 0x61, 0x05, 0xb2, 0x44,
1708                                           0xb4, 0xe7, 0xbb, 0x3b, 0x96, 0xb0,
1709                                           0x6d, 0xe8, 0x43, 0xd2, 0x03, 0xb7,
1710                                           0x0a, 0xc4, 0x6d, 0x30, 0xd8, 0xd5,
1711                                           0xe6, 0x54, 0x65, 0xdd, 0xa9, 0x1b,
1712                                           0x50, 0xc0, 0xb9, 0x95, 0xb0, 0x7d,
1713                                           0x7c, 0xca, 0x63, 0xf8, 0x72, 0xbe,
1714                                           0x3b, 0x00 ) );
1715         bigint_mod_exp_ok ( BIGINT ( 0xcd ),
1716                             BIGINT ( 0xbb ),
1717                             BIGINT ( 0x25 ),
1718                             BIGINT ( 0xab ) );
1719         bigint_mod_exp_ok ( BIGINT ( 0xc4 ),
1720                             BIGINT ( 0xe9 ),
1721                             BIGINT ( 0x02, 0x4c ),
1722                             BIGINT ( 0x7e ) );
1723         bigint_mod_exp_ok ( BIGINT ( 0xcb ),
1724                             BIGINT ( 0xde ),
1725                             BIGINT ( 0xbd, 0x73, 0xbf ),
1726                             BIGINT ( 0x17 ) );
1727         bigint_mod_exp_ok ( BIGINT ( 0x17 ),
1728                             BIGINT ( 0xb9 ),
1729                             BIGINT ( 0x39, 0x68, 0xba, 0x7d ),
1730                             BIGINT ( 0x17 ) );
1731         bigint_mod_exp_ok ( BIGINT ( 0x2e ),
1732                             BIGINT ( 0xb7 ),
1733                             BIGINT ( 0x39, 0x07, 0x1b, 0x49, 0x5b, 0xea,
1734                                      0xf2, 0x61, 0x75, 0x94, 0x60, 0x86,
1735                                      0x73, 0xd0, 0xeb, 0x11, 0x08, 0x19,
1736                                      0x90, 0x19, 0xe0, 0xed, 0x2a ),
1737                             BIGINT ( 0x19 ) );
1738         bigint_mod_exp_ok ( BIGINT ( 0x59 ),
1739                             BIGINT ( 0xce ),
1740                             BIGINT ( 0xdf, 0xbc, 0x0d, 0x0c, 0x09, 0xeb,
1741                                      0xf8, 0xcf, 0xdb, 0xb6, 0x00, 0xa3,
1742                                      0x9e, 0xc3, 0x6c, 0x8d, 0xf1, 0xc3,
1743                                      0x03, 0x36, 0xaa, 0xd4, 0x22, 0x7c,
1744                                      0x20, 0x7b, 0xa9, 0x9a, 0x01, 0xe4,
1745                                      0xf2, 0x50, 0x42, 0x29, 0x68, 0x7a,
1746                                      0xa6, 0x2c, 0xdf, 0xb6, 0x51, 0xa9,
1747                                      0x73, 0x10, 0x98, 0x37, 0x69, 0xb3,
1748                                      0x21, 0x49, 0x6d, 0xcc, 0x80, 0xfa,
1749                                      0x7e, 0x12, 0xe4, 0x9c, 0xc2, 0xbb,
1750                                      0xe3, 0xa3, 0x10, 0x3f, 0xba, 0x99,
1751                                      0x22, 0x79, 0x71, 0x39, 0x96, 0x7b,
1752                                      0x1a, 0x89, 0xdc, 0xda, 0x43, 0x52,
1753                                      0x50, 0x7b, 0xe3, 0x8c, 0xd3, 0xc0,
1754                                      0xf5, 0x7d, 0xfc, 0x80, 0x71, 0x6e,
1755                                      0xaf, 0x5c, 0xd0, 0x14, 0xc0, 0x60,
1756                                      0x24, 0xa8, 0x9a, 0x8a, 0x54, 0x4a,
1757                                      0x6f, 0x42, 0x7a, 0x14, 0x14, 0x25,
1758                                      0xd5, 0x22, 0x08, 0x8f, 0xd9, 0xdb,
1759                                      0xd4, 0x0f, 0x14, 0xf4, 0x3b, 0x26,
1760                                      0x0e, 0xb6, 0x72, 0xd7, 0x03, 0xd5,
1761                                      0xf0, 0x0e ),
1762                             BIGINT ( 0xa9 ) );
1763         bigint_mod_exp_ok ( BIGINT ( 0x7f, 0x30 ),
1764                             BIGINT ( 0x73, 0x74 ),
1765                             BIGINT ( 0x75 ),
1766                             BIGINT ( 0x4b, 0xe8 ) );
1767         bigint_mod_exp_ok ( BIGINT ( 0x04, 0x6c ),
1768                             BIGINT ( 0x99, 0x04 ),
1769                             BIGINT ( 0x33, 0xd2 ),
1770                             BIGINT ( 0x86, 0x74 ) );
1771         bigint_mod_exp_ok ( BIGINT ( 0xca, 0x88 ),
1772                             BIGINT ( 0xdc, 0x60 ),
1773                             BIGINT ( 0x7e, 0x76, 0x79 ),
1774                             BIGINT ( 0x42, 0x40 ) );
1775         bigint_mod_exp_ok ( BIGINT ( 0x68, 0x97 ),
1776                             BIGINT ( 0x52, 0x8b ),
1777                             BIGINT ( 0x4f, 0x7f, 0xe7, 0xda ),
1778                             BIGINT ( 0x22, 0x77 ) );
1779         bigint_mod_exp_ok ( BIGINT ( 0xbd, 0x14 ),
1780                             BIGINT ( 0x9e, 0xfc ),
1781                             BIGINT ( 0x23, 0xf7, 0xd0, 0xa1, 0x9e, 0x9b,
1782                                      0x05, 0xd2, 0x44, 0x24, 0x4f, 0x3f,
1783                                      0x83, 0xcc, 0x49, 0x70, 0xa5, 0x0d,
1784                                      0xfc, 0xa7, 0x43, 0xf3, 0x3e ),
1785                             BIGINT ( 0x1a, 0xc8 ) );
1786         bigint_mod_exp_ok ( BIGINT ( 0x46, 0x3e ),
1787                             BIGINT ( 0xb8, 0xde ),
1788                             BIGINT ( 0xa9, 0xc0, 0xdc, 0x45, 0x65, 0x0d,
1789                                      0xa5, 0x56, 0x70, 0x4c, 0xf1, 0xda,
1790                                      0xab, 0x64, 0xc2, 0x04, 0xf6, 0x32,
1791                                      0x20, 0x68, 0x31, 0x5f, 0x9a, 0x00,
1792                                      0x0f, 0x7b, 0x24, 0x33, 0xdf, 0xaf,
1793                                      0xfe, 0x03, 0x1e, 0x4a, 0xa1, 0xf8,
1794                                      0x45, 0x8d, 0x5a, 0x7d, 0x12, 0x58,
1795                                      0x00, 0x6d, 0xba, 0x79, 0x9f, 0xe1,
1796                                      0xa1, 0xfc, 0x1f, 0xb9, 0xf3, 0xa7,
1797                                      0x07, 0xf5, 0xfe, 0xd6, 0xa1, 0xba,
1798                                      0xda, 0x63, 0xef, 0x39, 0x8e, 0xb7,
1799                                      0x48, 0xa8, 0x81, 0x86, 0xb1, 0x22,
1800                                      0x14, 0x9f, 0x9e, 0xac, 0x69, 0xf7,
1801                                      0xae, 0x1f, 0xf2, 0x99, 0x41, 0xb7,
1802                                      0x37, 0xa7, 0xbc, 0x42, 0xf2, 0x45,
1803                                      0x43, 0xf2, 0x2a, 0xef, 0xc2, 0x83,
1804                                      0xd5, 0x32, 0x6e, 0xfa, 0x49, 0x1c,
1805                                      0x94, 0x9c, 0xc2, 0xc5, 0xad, 0x28,
1806                                      0x53, 0x1c, 0x11, 0xc4, 0x1c, 0x78,
1807                                      0x8f, 0x13, 0xdc, 0xb3, 0x2a, 0x63,
1808                                      0xfd, 0x1f, 0x89, 0x9b, 0x0c, 0x31,
1809                                      0x92, 0x73 ),
1810                             BIGINT ( 0x7b, 0x8a ) );
1811         bigint_mod_exp_ok ( BIGINT ( 0xf3, 0xc3, 0xab ),
1812                             BIGINT ( 0xd0, 0x7e, 0xd0 ),
1813                             BIGINT ( 0xf6 ),
1814                             BIGINT ( 0x1f, 0xb3, 0x09 ) );
1815         bigint_mod_exp_ok ( BIGINT ( 0x13, 0xec, 0xf6 ),
1816                             BIGINT ( 0x87, 0x1a, 0x9a ),
1817                             BIGINT ( 0x03, 0xf3 ),
1818                             BIGINT ( 0x15, 0xe9, 0x8e ) );
1819         bigint_mod_exp_ok ( BIGINT ( 0x5a, 0x96, 0xe5 ),
1820                             BIGINT ( 0x56, 0x4a, 0xd1 ),
1821                             BIGINT ( 0x89, 0x62, 0x8e ),
1822                             BIGINT ( 0x34, 0xb8, 0xaa ) );
1823         bigint_mod_exp_ok ( BIGINT ( 0x84, 0x7c, 0xbd ),
1824                             BIGINT ( 0x3c, 0x80, 0x0a ),
1825                             BIGINT ( 0x5e, 0x52, 0x9d, 0xba ),
1826                             BIGINT ( 0x04, 0xcb, 0x4f ) );
1827         bigint_mod_exp_ok ( BIGINT ( 0x50, 0x01, 0x51 ),
1828                             BIGINT ( 0x02, 0xe6, 0x96 ),
1829                             BIGINT ( 0x34, 0x0c, 0x7e, 0xbf, 0x27, 0x23,
1830                                      0x46, 0x92, 0x1c, 0xca, 0x91, 0xab,
1831                                      0x50, 0x2c, 0x3a, 0x64, 0xc8, 0x4a,
1832                                      0x75, 0xd6, 0xe2, 0xde, 0x31 ),
1833                             BIGINT ( 0x02, 0x16, 0x05 ) );
1834         bigint_mod_exp_ok ( BIGINT ( 0x5e, 0x47, 0xd8 ),
1835                             BIGINT ( 0x26, 0xd1, 0xb6 ),
1836                             BIGINT ( 0x49, 0x61, 0x84, 0x7a, 0xa9, 0xfb,
1837                                      0x93, 0x45, 0xe4, 0xfa, 0x53, 0x60,
1838                                      0x73, 0x98, 0x5a, 0x17, 0xe7, 0x77,
1839                                      0x2d, 0xcd, 0x97, 0xf4, 0xc0, 0x34,
1840                                      0x46, 0xfa, 0xbd, 0x21, 0xdf, 0xa5,
1841                                      0xa0, 0x12, 0x38, 0x7c, 0xbd, 0xd9,
1842                                      0xcd, 0xbc, 0xde, 0x29, 0xa5, 0x13,
1843                                      0xa8, 0xf0, 0xf6, 0x88, 0xc6, 0x31,
1844                                      0xed, 0x90, 0x19, 0x11, 0x7d, 0xe1,
1845                                      0x0e, 0x81, 0x98, 0x8e, 0x98, 0x86,
1846                                      0xde, 0x2a, 0x4c, 0xad, 0xff, 0x57,
1847                                      0x12, 0xbc, 0x4b, 0xaf, 0x21, 0xde,
1848                                      0xca, 0x3a, 0x25, 0xd7, 0x98, 0xe3,
1849                                      0x25, 0xbc, 0x17, 0x74, 0x0b, 0x9c,
1850                                      0x53, 0xe1, 0x1a, 0xec, 0x9a, 0x5a,
1851                                      0xdc, 0x68, 0xdf, 0xad, 0xd6, 0x71,
1852                                      0x6b, 0x5b, 0x8b, 0x85, 0xbb, 0xe5,
1853                                      0xd5, 0x14, 0x4c, 0x30, 0x27, 0x68,
1854                                      0xd1, 0xf7, 0x58, 0x34, 0x4c, 0xe1,
1855                                      0x71, 0xde, 0x7b, 0x8d, 0xa2, 0xe6,
1856                                      0x0a, 0x44, 0x22, 0x26, 0x5a, 0x70,
1857                                      0xbb, 0x68 ),
1858                             BIGINT ( 0x18, 0x36, 0x96 ) );
1859         bigint_mod_exp_ok ( BIGINT ( 0xc7, 0x4a, 0xf0, 0x48 ),
1860                             BIGINT ( 0x5d, 0x27, 0x07, 0x54 ),
1861                             BIGINT ( 0x4a ),
1862                             BIGINT ( 0x48, 0x68, 0x7b, 0xe0 ) );
1863         bigint_mod_exp_ok ( BIGINT ( 0xb4, 0x89, 0xc9, 0x5b ),
1864                             BIGINT ( 0x7c, 0xd7, 0xc7, 0xff ),
1865                             BIGINT ( 0xc6, 0x9c ),
1866                             BIGINT ( 0x0b, 0x2d, 0xf8, 0xf7 ) );
1867         bigint_mod_exp_ok ( BIGINT ( 0xea, 0x72, 0x43, 0xfe ),
1868                             BIGINT ( 0xfc, 0x57, 0x2d, 0x47 ),
1869                             BIGINT ( 0x60, 0x01, 0x2c ),
1870                             BIGINT ( 0x12, 0x01, 0xe3, 0xf5 ) );
1871         bigint_mod_exp_ok ( BIGINT ( 0x81, 0x7f, 0x27, 0x94 ),
1872                             BIGINT ( 0x17, 0x21, 0x67, 0xab ),
1873                             BIGINT ( 0x50, 0x19, 0x12, 0x52 ),
1874                             BIGINT ( 0x05, 0x17, 0x6b, 0x13 ) );
1875         bigint_mod_exp_ok ( BIGINT ( 0x38, 0xab, 0xd4, 0xec ),
1876                             BIGINT ( 0x0c, 0x2a, 0x56, 0x38 ),
1877                             BIGINT ( 0x2f, 0x85, 0x85, 0x57, 0xf6, 0xde,
1878                                      0x24, 0xb4, 0x28, 0x3c, 0x5a, 0x3c,
1879                                      0x0b, 0x12, 0x85, 0x85, 0x85, 0x98,
1880                                      0x46, 0x5b, 0x9c, 0x52, 0x3a ),
1881                             BIGINT ( 0x02, 0xe6, 0x6a, 0x70 ) );
1882         bigint_mod_exp_ok ( BIGINT ( 0xa6, 0x35, 0xc0, 0x6f ),
1883                             BIGINT ( 0x23, 0xac, 0x78, 0x72 ),
1884                             BIGINT ( 0x6a, 0x07, 0x80, 0xbf, 0x1b, 0xa5,
1885                                      0xf8, 0x0b, 0x90, 0x06, 0xa4, 0xa5,
1886                                      0x44, 0x13, 0xba, 0x4b, 0xb3, 0xce,
1887                                      0x9f, 0x55, 0x42, 0x56, 0xc3, 0x30,
1888                                      0x82, 0x85, 0x5a, 0x3b, 0xae, 0x88,
1889                                      0x92, 0x4e, 0x3c, 0x37, 0xf6, 0x80,
1890                                      0x4c, 0x03, 0x3c, 0x1e, 0x2c, 0x17,
1891                                      0xef, 0x9d, 0xd7, 0x6f, 0xdc, 0xbb,
1892                                      0x42, 0x42, 0xa1, 0x7f, 0x97, 0x66,
1893                                      0xcd, 0xc8, 0x8a, 0x7c, 0xc6, 0x70,
1894                                      0x61, 0x54, 0x82, 0xd0, 0xd0, 0x8b,
1895                                      0xd5, 0x4f, 0x57, 0x7b, 0x8e, 0xab,
1896                                      0xdc, 0xbf, 0x8e, 0x85, 0x94, 0x83,
1897                                      0x8a, 0xb3, 0x72, 0x69, 0x2d, 0x51,
1898                                      0xdd, 0x86, 0x1e, 0x58, 0xb8, 0x00,
1899                                      0xe2, 0x5e, 0xa7, 0xef, 0x6a, 0x6a,
1900                                      0xb0, 0x10, 0x3d, 0x53, 0xfe, 0x23,
1901                                      0x51, 0xc0, 0x51, 0xed, 0x1f, 0x02,
1902                                      0x4b, 0x73, 0x17, 0x59, 0xfa, 0xb9,
1903                                      0xa8, 0x05, 0xa7, 0x79, 0xc3, 0xc9,
1904                                      0x4c, 0x2d, 0x58, 0x59, 0x10, 0x99,
1905                                      0x71, 0xe6 ),
1906                             BIGINT ( 0x01, 0x63, 0xd0, 0x07 ) );
1907         bigint_mod_exp_ok ( BIGINT ( 0xff, 0x2a, 0x37, 0x04, 0xd4, 0x08,
1908                                      0x9f, 0xf5, 0xac, 0x29, 0x7f, 0x4b,
1909                                      0x93, 0x86, 0x02, 0x26, 0xac, 0x29,
1910                                      0xa8, 0xf9, 0x77, 0x91, 0x20 ),
1911                             BIGINT ( 0x2c, 0xb2, 0xe2, 0x1f, 0x4b, 0x97,
1912                                      0xaa, 0x3b, 0xd1, 0x36, 0xb0, 0x40,
1913                                      0x8b, 0x1c, 0x19, 0xa2, 0xea, 0xc8,
1914                                      0xc6, 0x4e, 0x2a, 0x66, 0x50 ),
1915                             BIGINT ( 0x97 ),
1916                             BIGINT ( 0x04, 0x22, 0x44, 0xe2, 0x14, 0x54,
1917                                      0x6c, 0x5a, 0xba, 0x1b, 0x39, 0xb7,
1918                                      0xaa, 0x06, 0xcf, 0x2b, 0xc8, 0x7e,
1919                                      0xc0, 0xe0, 0x70, 0xf2, 0x90 ) );
1920         bigint_mod_exp_ok ( BIGINT ( 0xcd, 0xf3, 0xf7, 0x50, 0x13, 0x39,
1921                                      0x13, 0x4a, 0x56, 0xc5, 0xb8, 0xa6,
1922                                      0x42, 0x2d, 0x40, 0x5e, 0x07, 0xf2,
1923                                      0x92, 0x2a, 0x51, 0x87, 0x20 ),
1924                             BIGINT ( 0x93, 0x1a, 0x28, 0xbb, 0x69, 0x4f,
1925                                      0x31, 0x01, 0xe0, 0x88, 0x8a, 0x4c,
1926                                      0x4f, 0x9b, 0xda, 0xf6, 0x4e, 0xf3,
1927                                      0x11, 0xe7, 0x35, 0xa1, 0xfb ),
1928                             BIGINT ( 0x66, 0x69 ),
1929                             BIGINT ( 0x7a, 0x5a, 0x9b, 0x84, 0x72, 0x8f,
1930                                      0x57, 0x31, 0xb4, 0x34, 0x70, 0x18,
1931                                      0x77, 0xa6, 0x43, 0xa9, 0x51, 0x69,
1932                                      0x07, 0x3e, 0xf6, 0x68, 0x82 ) );
1933         bigint_mod_exp_ok ( BIGINT ( 0xdd, 0x4c, 0x85, 0xcb, 0x3f, 0x45,
1934                                      0x61, 0xe0, 0x58, 0x1e, 0xad, 0xd3,
1935                                      0x6b, 0xef, 0x82, 0x53, 0x4a, 0x16,
1936                                      0x1a, 0xf0, 0x09, 0x82, 0x74 ),
1937                             BIGINT ( 0xd2, 0xa2, 0x73, 0x89, 0x0c, 0x56,
1938                                      0xe4, 0x31, 0xdf, 0x70, 0x3c, 0x40,
1939                                      0x0d, 0x36, 0xfc, 0x4a, 0xf3, 0xa2,
1940                                      0x8f, 0x9a, 0x9d, 0xaa, 0xb0 ),
1941                             BIGINT ( 0xbc, 0xca, 0x45 ),
1942                             BIGINT ( 0x9f, 0x5f, 0x7c, 0xac, 0x5e, 0xc7,
1943                                      0xf2, 0xc5, 0x72, 0x3d, 0xff, 0x29,
1944                                      0xd2, 0x25, 0xa9, 0x64, 0x5b, 0xbe,
1945                                      0x63, 0x63, 0xc6, 0x84, 0x20 ) );
1946         bigint_mod_exp_ok ( BIGINT ( 0xf8, 0xc9, 0xb9, 0x3d, 0xe1, 0xff,
1947                                      0xa6, 0x8e, 0xb0, 0xd2, 0xa9, 0xa9,
1948                                      0xc1, 0x5c, 0xc5, 0x94, 0x90, 0xb9,
1949                                      0xca, 0x2f, 0x1a, 0xbd, 0x21 ),
1950                             BIGINT ( 0xa7, 0xf4, 0xb0, 0x3c, 0xf4, 0x2b,
1951                                      0x9d, 0x40, 0x5f, 0xfd, 0x2e, 0x28,
1952                                      0xa9, 0x23, 0x01, 0xaf, 0x0b, 0x73,
1953                                      0xaa, 0xcf, 0x14, 0xdc, 0xd8 ),
1954                             BIGINT ( 0x31, 0xe2, 0xe8, 0xf0 ),
1955                             BIGINT ( 0x53, 0x30, 0xc6, 0x10, 0x12, 0x7c,
1956                                      0xb3, 0x91, 0x15, 0x5f, 0x01, 0x62,
1957                                      0xec, 0x1f, 0x15, 0x61, 0x3b, 0x9a,
1958                                      0x76, 0x22, 0xf8, 0x31, 0xb1 ) );
1959         bigint_mod_exp_ok ( BIGINT ( 0xff, 0x8c, 0x04, 0x74, 0x3e, 0x93,
1960                                      0xfd, 0xce, 0xd5, 0x7f, 0xc5, 0x58,
1961                                      0xce, 0x00, 0x53, 0x44, 0x02, 0xf4,
1962                                      0xfd, 0x01, 0xc3, 0xb0, 0x3c ),
1963                             BIGINT ( 0x2f, 0xbe, 0xb3, 0x2d, 0xd6, 0x59,
1964                                      0x69, 0x44, 0xc0, 0xd4, 0x27, 0x9c,
1965                                      0xff, 0x53, 0x9e, 0x66, 0x2c, 0x01,
1966                                      0x3a, 0x96, 0x5d, 0x75, 0xc1 ),
1967                             BIGINT ( 0x47, 0x3e, 0xb2, 0x81, 0x51, 0x9a,
1968                                      0xdf, 0x75, 0xba, 0xa5, 0x19, 0xc1,
1969                                      0xc7, 0xcc, 0xae, 0x82, 0x9c, 0x3e,
1970                                      0xfd, 0x7f, 0xb0, 0xd7, 0x00 ),
1971                             BIGINT ( 0x09, 0x9c, 0xd0, 0x49, 0x1d, 0x88,
1972                                      0xd8, 0x08, 0x45, 0x61, 0x71, 0xa1,
1973                                      0xb5, 0xab, 0xa9, 0x5b, 0xa8, 0xf1,
1974                                      0xc6, 0x53, 0x68, 0x8f, 0x3e ) );
1975         bigint_mod_exp_ok ( BIGINT ( 0xd8, 0x78, 0xad, 0x80, 0x81, 0xf1,
1976                                      0x84, 0x23, 0x82, 0x5d, 0x49, 0x46,
1977                                      0x75, 0xfd, 0xd1, 0x49, 0x53, 0x10,
1978                                      0x4d, 0x10, 0xab, 0x0f, 0xf0 ),
1979                             BIGINT ( 0x78, 0x3d, 0x09, 0x1b, 0xea, 0xa4,
1980                                      0xb9, 0x13, 0xf8, 0xb5, 0xb5, 0x5e,
1981                                      0x69, 0xa4, 0xe1, 0xfd, 0x88, 0x58,
1982                                      0x26, 0xb3, 0x76, 0xa2, 0x38 ),
1983                             BIGINT ( 0x3b, 0x12, 0xe0, 0x8e, 0xa2, 0x2f,
1984                                      0x2a, 0x2b, 0xb1, 0x78, 0xf9, 0xf6,
1985                                      0x93, 0x4d, 0x52, 0x82, 0x29, 0x2d,
1986                                      0xe4, 0x36, 0x92, 0x49, 0xc1, 0x25,
1987                                      0x6e, 0x26, 0xe6, 0x6e, 0xc2, 0x4d,
1988                                      0xea, 0x13, 0x86, 0x85, 0x71, 0x4d,
1989                                      0x85, 0x70, 0xf9, 0x2b, 0xa0, 0x0f,
1990                                      0x96, 0xe5, 0x63, 0x7a, 0xb4, 0x25,
1991                                      0x53, 0x1a, 0xd8, 0x30, 0x36, 0xba,
1992                                      0x6e, 0x2e, 0xce, 0x2d, 0x8f, 0x32,
1993                                      0xe9, 0xdc, 0x91, 0x9e, 0xd4, 0xf1,
1994                                      0x3b, 0x40, 0xc9, 0xf4, 0x97, 0x74,
1995                                      0x5e, 0x69, 0xcd, 0x34, 0x4a, 0x18,
1996                                      0x65, 0xe5, 0x07, 0xb5, 0x9e, 0x2a,
1997                                      0xc4, 0xeb, 0xb6, 0x96, 0x7b, 0x99,
1998                                      0x0c, 0xe4, 0xb3, 0x85, 0xff, 0x17,
1999                                      0x72, 0x5d, 0xf6, 0x30, 0xb4, 0xff,
2000                                      0x98, 0xe6, 0xf6, 0x31, 0x24, 0x82,
2001                                      0x91, 0xa6, 0x18, 0x6d, 0x0b, 0x84,
2002                                      0x6f, 0x5f, 0x64, 0xa3, 0xdf, 0x92,
2003                                      0x06, 0x16, 0xe3, 0x7c, 0x08, 0x61,
2004                                      0x77, 0xce ),
2005                             BIGINT ( 0x17, 0xc9, 0xc5, 0x38, 0x4c, 0x15,
2006                                      0x0f, 0x4e, 0xc2, 0x90, 0x3b, 0x46,
2007                                      0x7b, 0x2f, 0x95, 0x82, 0xfe, 0x51,
2008                                      0x95, 0x2b, 0xff, 0xd5, 0x28 ) );
2009         bigint_mod_exp_ok ( BIGINT ( 0x69, 0xa3, 0x7e, 0x24, 0xdf, 0x9e,
2010                                      0x0b, 0x3e, 0x3f, 0x43, 0x06, 0x0e,
2011                                      0x1d, 0x57, 0x74, 0xe0, 0xa0, 0x5b,
2012                                      0x82, 0xca, 0xb0, 0x33, 0x8b, 0xe4,
2013                                      0x39, 0x27, 0x41, 0xd4, 0x2e, 0x30,
2014                                      0x3a, 0x0e, 0x62, 0x6f, 0xfa, 0xb4,
2015                                      0x02, 0x88, 0x70, 0x35, 0xa6, 0xea,
2016                                      0x7d, 0xb2, 0x87, 0xc3, 0xa5, 0x50,
2017                                      0x49, 0x38, 0xa4, 0x68, 0xa9, 0xe4,
2018                                      0xa6, 0xcc, 0xd7, 0x13, 0xb1, 0xd9,
2019                                      0x1c, 0x6a, 0x9a, 0xb8, 0x6c, 0x9b,
2020                                      0xff, 0xcd, 0x2c, 0xb3, 0xbd, 0xe2,
2021                                      0xfd, 0x1f, 0x08, 0xdd, 0xc6, 0xee,
2022                                      0x18, 0x0c, 0xa5, 0xcd, 0x09, 0x19,
2023                                      0x51, 0x51, 0xa5, 0x6f, 0x93, 0x1b,
2024                                      0x34, 0xfd, 0x8f, 0xd9, 0x87, 0xed,
2025                                      0x15, 0x7e, 0x36, 0x60, 0xdd, 0x1b,
2026                                      0xf4, 0xcc, 0xc4, 0x4c, 0x19, 0x2b,
2027                                      0xd6, 0x1e, 0xec, 0x51, 0xe9, 0x27,
2028                                      0xe9, 0xbd, 0x6a, 0x3f, 0x91, 0x45,
2029                                      0xc3, 0x6d, 0x40, 0x7e, 0x6c, 0x56,
2030                                      0x05, 0x5a ),
2031                             BIGINT ( 0x5c, 0x96, 0x05, 0x81, 0x94, 0x45,
2032                                      0xcf, 0x47, 0x5f, 0x1b, 0xb0, 0xf9,
2033                                      0xef, 0x13, 0x8f, 0xcc, 0x71, 0xfd,
2034                                      0x50, 0xf1, 0xe7, 0x62, 0x6e, 0xfa,
2035                                      0x48, 0x66, 0x1c, 0xf7, 0xef, 0x09,
2036                                      0x12, 0xa2, 0xfd, 0x17, 0xb7, 0x6a,
2037                                      0x3b, 0xed, 0xf7, 0x86, 0xd2, 0xbe,
2038                                      0x95, 0x90, 0xc6, 0x00, 0x14, 0x8d,
2039                                      0xe3, 0x27, 0xbe, 0x03, 0x7c, 0x9e,
2040                                      0x6b, 0x51, 0x31, 0x8d, 0x18, 0xc4,
2041                                      0x16, 0xd2, 0x84, 0x63, 0x9b, 0xe9,
2042                                      0xa4, 0xf8, 0xff, 0x70, 0x4d, 0xeb,
2043                                      0x6f, 0x4a, 0xb7, 0x5b, 0x54, 0xf1,
2044                                      0xb5, 0xbe, 0x78, 0xb6, 0xfd, 0x8b,
2045                                      0xe1, 0x39, 0x62, 0x85, 0x9b, 0xde,
2046                                      0x30, 0xa8, 0xe4, 0x37, 0x52, 0x57,
2047                                      0x39, 0x79, 0xdb, 0x0b, 0x19, 0x6b,
2048                                      0xc9, 0x17, 0xfd, 0x8c, 0x2c, 0xaa,
2049                                      0xa4, 0xf1, 0x04, 0xd1, 0xd3, 0x2f,
2050                                      0xbb, 0x3a, 0x36, 0x82, 0x31, 0xa4,
2051                                      0x40, 0xd4, 0x87, 0x46, 0xe3, 0x6e,
2052                                      0xd0, 0x17 ),
2053                             BIGINT ( 0x93 ),
2054                             BIGINT ( 0x0d, 0x39, 0x92, 0x57, 0xaa, 0x6d,
2055                                      0xfc, 0x3b, 0x10, 0x18, 0x6d, 0x59,
2056                                      0xbe, 0x31, 0x8f, 0xee, 0xf9, 0x82,
2057                                      0x84, 0xe0, 0xdf, 0xa5, 0x00, 0x28,
2058                                      0xd1, 0x64, 0x6b, 0x4b, 0x43, 0x3b,
2059                                      0x76, 0x3e, 0x6b, 0xc4, 0xe4, 0xf5,
2060                                      0x0b, 0x59, 0x5a, 0xe4, 0x53, 0x5e,
2061                                      0x02, 0xd4, 0xde, 0x72, 0xd3, 0xa3,
2062                                      0x58, 0x66, 0xa7, 0xdd, 0x2b, 0x0b,
2063                                      0xa4, 0x83, 0xd0, 0xd9, 0xef, 0x29,
2064                                      0x3d, 0x2f, 0x97, 0xff, 0x9a, 0xc7,
2065                                      0xf6, 0x8a, 0x8d, 0x59, 0xef, 0x87,
2066                                      0xd1, 0xe6, 0xba, 0x4d, 0x99, 0xd9,
2067                                      0x5f, 0x5e, 0x7a, 0x7e, 0x67, 0x22,
2068                                      0x5b, 0x77, 0x83, 0xa2, 0x02, 0xfd,
2069                                      0xb2, 0xe4, 0xf6, 0x20, 0x4c, 0x12,
2070                                      0x20, 0xa7, 0xda, 0x5b, 0x3b, 0x8c,
2071                                      0xa2, 0xca, 0xda, 0x20, 0xaa, 0x27,
2072                                      0xe6, 0x54, 0x3e, 0xa8, 0x6f, 0x64,
2073                                      0x9d, 0xa7, 0x0d, 0x57, 0x1b, 0x21,
2074                                      0xff, 0xd2, 0xe2, 0xb2, 0x0a, 0x4f,
2075                                      0xb7, 0x0e ) );
2076         bigint_mod_exp_ok ( BIGINT ( 0x06, 0xcf, 0x54, 0xf2, 0x0d, 0x62,
2077                                      0x33, 0xdd, 0xe7, 0x4d, 0x7f, 0x2f,
2078                                      0x8e, 0x52, 0x73, 0xf4, 0x73, 0x68,
2079                                      0x4b, 0x13, 0x6e, 0x58, 0x6b, 0x4a,
2080                                      0xb8, 0x4c, 0xef, 0x73, 0xfe, 0x5f,
2081                                      0xf6, 0xd0, 0xbb, 0x82, 0x17, 0x3f,
2082                                      0x9d, 0x91, 0xf8, 0xa3, 0xb8, 0x79,
2083                                      0xef, 0x41, 0x38, 0xc1, 0xef, 0xc9,
2084                                      0xc6, 0xcf, 0x2a, 0xc3, 0xaa, 0x75,
2085                                      0x17, 0xda, 0xbc, 0x76, 0x29, 0x61,
2086                                      0x6d, 0x05, 0x79, 0x0b, 0x44, 0xb1,
2087                                      0x54, 0x75, 0xb7, 0xd9, 0xf6, 0xa8,
2088                                      0xbd, 0xf7, 0x85, 0xe0, 0xe7, 0x90,
2089                                      0x62, 0xce, 0x79, 0xfb, 0xc5, 0x23,
2090                                      0xa5, 0x09, 0xc0, 0xc4, 0x4d, 0xe7,
2091                                      0x9c, 0x49, 0x8f, 0x82, 0xf1, 0x31,
2092                                      0x34, 0x85, 0xdd, 0x3b, 0xbe, 0xe9,
2093                                      0x93, 0x19, 0x03, 0x75, 0x3f, 0xc4,
2094                                      0xa4, 0x0f, 0x52, 0x53, 0xc1, 0xcd,
2095                                      0x08, 0xb0, 0x05, 0x0c, 0xa2, 0x0c,
2096                                      0x3a, 0x72, 0xb2, 0x3c, 0xdb, 0x4f,
2097                                      0xac, 0xc6 ),
2098                             BIGINT ( 0xe4, 0x40, 0xd8, 0x30, 0x00, 0xcf,
2099                                      0x4c, 0xfd, 0xda, 0xae, 0x90, 0xd3,
2100                                      0x5b, 0xc7, 0x20, 0xcc, 0x2b, 0xe2,
2101                                      0x0a, 0x39, 0x1e, 0xde, 0xef, 0x98,
2102                                      0x16, 0x3b, 0x9d, 0x36, 0x63, 0x0d,
2103                                      0x46, 0xed, 0x23, 0x6e, 0x38, 0xa8,
2104                                      0x15, 0xb5, 0xb1, 0xaf, 0x47, 0xb1,
2105                                      0xec, 0xaa, 0x8b, 0x57, 0xd6, 0xca,
2106                                      0x39, 0x2f, 0x62, 0xbd, 0xd5, 0xf8,
2107                                      0x98, 0x98, 0x5d, 0xfe, 0x14, 0xd6,
2108                                      0xdc, 0xe5, 0x98, 0x60, 0x5b, 0x16,
2109                                      0x92, 0xcb, 0xed, 0xb6, 0x9c, 0x5c,
2110                                      0x82, 0x40, 0x6b, 0xaa, 0x48, 0x7a,
2111                                      0xd4, 0xfe, 0xa3, 0xe7, 0x30, 0xf1,
2112                                      0x7c, 0xfb, 0x94, 0x2e, 0xeb, 0xb6,
2113                                      0x71, 0xe4, 0x33, 0x63, 0xc3, 0xb0,
2114                                      0x94, 0x6d, 0xee, 0xa5, 0x15, 0x3f,
2115                                      0x28, 0xf1, 0xfa, 0xdc, 0xf2, 0x13,
2116                                      0x0f, 0xc7, 0xd9, 0xe0, 0xbf, 0x1b,
2117                                      0x49, 0xee, 0x21, 0x8e, 0x26, 0xc9,
2118                                      0x28, 0x21, 0x86, 0x1d, 0x46, 0x33,
2119                                      0xd4, 0x69 ),
2120                             BIGINT ( 0xd9, 0x87 ),
2121                             BIGINT ( 0xdf, 0xff, 0xcc, 0xb7, 0xfe, 0x19,
2122                                      0x02, 0x92, 0x9d, 0xab, 0x33, 0xd2,
2123                                      0x21, 0xbc, 0xd3, 0xc4, 0x31, 0xad,
2124                                      0x4b, 0xb3, 0x16, 0x50, 0x96, 0xd9,
2125                                      0xdc, 0x88, 0x74, 0x60, 0xde, 0xdf,
2126                                      0xb7, 0x83, 0xdb, 0x22, 0xef, 0xcb,
2127                                      0xcb, 0xdb, 0x4c, 0xfb, 0x94, 0x4c,
2128                                      0x3f, 0xf5, 0xf5, 0x99, 0x85, 0x21,
2129                                      0x1a, 0x2b, 0xec, 0x90, 0x2d, 0xb4,
2130                                      0x20, 0x3c, 0x27, 0x9f, 0xe5, 0xb1,
2131                                      0x5c, 0x92, 0xfa, 0xb0, 0xa9, 0x8e,
2132                                      0x2c, 0x21, 0x8e, 0x8d, 0xe5, 0x55,
2133                                      0x84, 0x02, 0xa5, 0x15, 0x5c, 0x53,
2134                                      0x1f, 0x40, 0x81, 0x0a, 0x10, 0xde,
2135                                      0x21, 0x41, 0xa9, 0x97, 0xf8, 0x6f,
2136                                      0xbf, 0x42, 0x58, 0x9e, 0xc6, 0xdd,
2137                                      0x10, 0x33, 0x3f, 0xad, 0xe6, 0x8e,
2138                                      0x57, 0x27, 0x37, 0x20, 0xa4, 0x86,
2139                                      0xef, 0x39, 0x7b, 0x6f, 0x78, 0x77,
2140                                      0xab, 0xa0, 0x62, 0xe1, 0xfd, 0x9c,
2141                                      0xbe, 0xfa, 0x98, 0x2e, 0x29, 0xe3,
2142                                      0xeb, 0x52 ) );
2143         bigint_mod_exp_ok ( BIGINT ( 0x00, 0x91, 0xb3, 0x87, 0xe6, 0x01,
2144                                      0x57, 0xe9, 0x68, 0xa4, 0xf4, 0x9b,
2145                                      0xea, 0x6a, 0x8a, 0x9e, 0x1a, 0x8b,
2146                                      0xd3, 0x85, 0x9d, 0xba, 0x85, 0xab,
2147                                      0xd8, 0xcd, 0x25, 0x56, 0x8e, 0x85,
2148                                      0x8a, 0x8e, 0x48, 0x9e, 0xb4, 0x90,
2149                                      0xc8, 0x2e, 0x07, 0x78, 0x80, 0x49,
2150                                      0xa0, 0xb7, 0x95, 0x6a, 0xd8, 0xad,
2151                                      0xb5, 0xda, 0x5d, 0xe6, 0x11, 0x87,
2152                                      0xb8, 0x33, 0x8f, 0xa8, 0x6f, 0x4e,
2153                                      0xc6, 0xc3, 0x0d, 0xf5, 0xa9, 0x4e,
2154                                      0xb2, 0x42, 0x53, 0x81, 0xcd, 0x33,
2155                                      0x83, 0x49, 0xab, 0x0d, 0x0e, 0xf5,
2156                                      0x2c, 0xcd, 0x84, 0x58, 0xf3, 0x30,
2157                                      0xa3, 0x6e, 0x3c, 0x3a, 0xc6, 0x77,
2158                                      0x43, 0xb0, 0xe7, 0x4b, 0x66, 0x30,
2159                                      0xe9, 0x48, 0x0b, 0x0d, 0x86, 0x3f,
2160                                      0xd8, 0xe2, 0xb5, 0x88, 0xc1, 0x44,
2161                                      0xb2, 0x6b, 0xb0, 0x7a, 0x35, 0x3b,
2162                                      0x56, 0x83, 0xb1, 0xac, 0x9e, 0xeb,
2163                                      0x9b, 0x08, 0x43, 0xac, 0x0a, 0x3a,
2164                                      0x31, 0x69 ),
2165                             BIGINT ( 0x96, 0x6f, 0xb0, 0xa7, 0x02, 0xb5,
2166                                      0xd9, 0x19, 0xbe, 0x4b, 0x27, 0x65,
2167                                      0x5b, 0x96, 0xd4, 0x0b, 0x49, 0x70,
2168                                      0xf0, 0x09, 0x8e, 0xf2, 0x04, 0x85,
2169                                      0x93, 0xe9, 0x2e, 0x09, 0x31, 0x76,
2170                                      0x8b, 0xbb, 0xe9, 0xe1, 0x2b, 0x4f,
2171                                      0xed, 0x83, 0xa6, 0x87, 0xa3, 0x07,
2172                                      0x0a, 0x3d, 0x1c, 0x65, 0x14, 0x5a,
2173                                      0xd5, 0xc0, 0x5d, 0x3c, 0x31, 0x9a,
2174                                      0x83, 0xad, 0xca, 0x6a, 0x93, 0x0d,
2175                                      0x1a, 0x67, 0x4e, 0x68, 0x06, 0x64,
2176                                      0x53, 0x2e, 0x15, 0xd9, 0xdd, 0x5e,
2177                                      0xcb, 0xb7, 0x2e, 0xef, 0xd3, 0xbb,
2178                                      0x5f, 0xaf, 0xef, 0x9e, 0xf2, 0x7b,
2179                                      0x69, 0x15, 0xb0, 0x18, 0x6c, 0x67,
2180                                      0x10, 0xda, 0x33, 0x07, 0x48, 0x97,
2181                                      0x31, 0xb3, 0x3d, 0x3d, 0xc9, 0x2e,
2182                                      0x0b, 0x68, 0x91, 0x3f, 0x6a, 0x3b,
2183                                      0x1a, 0xdf, 0xa8, 0x69, 0x46, 0x1c,
2184                                      0xb2, 0x69, 0x08, 0x0b, 0x02, 0x1b,
2185                                      0x03, 0x64, 0xae, 0xb6, 0x2d, 0xc6,
2186                                      0xc4, 0x0a ),
2187                             BIGINT ( 0x6d, 0x3f, 0xdd ),
2188                             BIGINT ( 0x40, 0x6e, 0x9d, 0x3e, 0xeb, 0xa4,
2189                                      0xb1, 0x8d, 0xb7, 0xb4, 0x0f, 0x5b,
2190                                      0x12, 0xad, 0x27, 0x9e, 0xbd, 0xe7,
2191                                      0xe5, 0x9d, 0xec, 0xb4, 0xac, 0x23,
2192                                      0x5f, 0xa9, 0xec, 0x9c, 0xd1, 0x6a,
2193                                      0xbe, 0x99, 0xba, 0xb3, 0x66, 0x0e,
2194                                      0x17, 0xaa, 0x13, 0xa2, 0x2e, 0x01,
2195                                      0x28, 0xb1, 0x6c, 0xba, 0xad, 0x68,
2196                                      0x48, 0xf0, 0xf3, 0x4c, 0x08, 0x9f,
2197                                      0xd1, 0x9c, 0xb7, 0x75, 0xc5, 0xb6,
2198                                      0x5a, 0x05, 0xb0, 0x14, 0xd4, 0x61,
2199                                      0xea, 0x18, 0x9f, 0xe6, 0xe5, 0xe3,
2200                                      0xd4, 0xff, 0x35, 0x43, 0x0b, 0xb8,
2201                                      0xf6, 0xe9, 0x19, 0x7a, 0x88, 0xa7,
2202                                      0x4d, 0x01, 0x92, 0x05, 0xd2, 0x6e,
2203                                      0xa3, 0xc1, 0xb6, 0x66, 0x75, 0xb1,
2204                                      0x00, 0x0d, 0x42, 0x37, 0xcc, 0xca,
2205                                      0xc0, 0x8d, 0xc8, 0x7e, 0x5c, 0xc9,
2206                                      0x53, 0x81, 0x2f, 0xc4, 0x61, 0xb6,
2207                                      0x96, 0x3b, 0xa5, 0x04, 0x14, 0x1b,
2208                                      0xa7, 0x77, 0xa1, 0xbc, 0x73, 0x1d,
2209                                      0xad, 0xed ) );
2210         bigint_mod_exp_ok ( BIGINT ( 0x45, 0xfb, 0xf3, 0xdc, 0x31, 0xe5,
2211                                      0x56, 0x7a, 0xee, 0x15, 0xfb, 0x16,
2212                                      0xee, 0x6e, 0x90, 0x3e, 0xa3, 0x89,
2213                                      0xc2, 0x6d, 0x9b, 0x06, 0x65, 0xd0,
2214                                      0xcd, 0xa2, 0xcc, 0x01, 0x60, 0x0d,
2215                                      0xd1, 0xdd, 0x68, 0x14, 0xc2, 0xcd,
2216                                      0xd8, 0x79, 0x75, 0xad, 0x0a, 0x9f,
2217                                      0x39, 0x5f, 0x52, 0x4b, 0x58, 0x31,
2218                                      0x48, 0xbb, 0x2a, 0xcc, 0xe0, 0x42,
2219                                      0x18, 0x32, 0xdc, 0x63, 0x14, 0x11,
2220                                      0x4e, 0xab, 0x96, 0x29, 0xc5, 0x06,
2221                                      0x79, 0xe5, 0x06, 0xf7, 0x59, 0xdb,
2222                                      0x1e, 0x51, 0xfd, 0xc4, 0x48, 0x3a,
2223                                      0x4c, 0x7f, 0xd0, 0xe2, 0x36, 0x86,
2224                                      0xc1, 0x8b, 0xc5, 0x86, 0x52, 0xe0,
2225                                      0xdb, 0x92, 0x5f, 0x0e, 0x19, 0xb1,
2226                                      0xa3, 0x23, 0xdd, 0xf0, 0x78, 0xcc,
2227                                      0x81, 0x3f, 0x4a, 0xe6, 0xb0, 0x32,
2228                                      0xd1, 0x5c, 0x5e, 0x3a, 0xb0, 0xd8,
2229                                      0xe2, 0x04, 0xc0, 0x30, 0x85, 0x1d,
2230                                      0x5e, 0x28, 0xee, 0xd9, 0xb3, 0x83,
2231                                      0x9f, 0xe2 ),
2232                             BIGINT ( 0xb3, 0x2c, 0x2e, 0xc5, 0xba, 0xf8,
2233                                      0x41, 0x98, 0x79, 0x7e, 0xaa, 0x0c,
2234                                      0x2a, 0x8f, 0xd9, 0x56, 0x55, 0xaa,
2235                                      0x74, 0x60, 0x74, 0xd1, 0x49, 0x2c,
2236                                      0x6f, 0x0a, 0x4e, 0xf8, 0x3f, 0x1b,
2237                                      0x73, 0x4c, 0xe0, 0x17, 0x37, 0x06,
2238                                      0x76, 0x73, 0xd5, 0x2d, 0x4d, 0x3f,
2239                                      0xb0, 0x15, 0x7e, 0x98, 0xd0, 0xdf,
2240                                      0xf0, 0x33, 0x78, 0xe2, 0xe6, 0xec,
2241                                      0x21, 0x22, 0xad, 0xd5, 0xab, 0x2d,
2242                                      0x0d, 0x59, 0x95, 0x05, 0x34, 0x1f,
2243                                      0x51, 0xf5, 0xec, 0x93, 0x05, 0x15,
2244                                      0x37, 0xcf, 0x93, 0x03, 0xd7, 0xf6,
2245                                      0x35, 0x23, 0x8f, 0x33, 0xf6, 0xba,
2246                                      0x42, 0xc8, 0x52, 0x94, 0xd3, 0x33,
2247                                      0x3e, 0x39, 0x01, 0xd1, 0x55, 0x3f,
2248                                      0x48, 0x84, 0xe9, 0xbc, 0x0b, 0x0f,
2249                                      0xc9, 0x69, 0x41, 0x2c, 0x5f, 0x34,
2250                                      0xd0, 0xe6, 0x15, 0x50, 0x06, 0x64,
2251                                      0x5b, 0x8b, 0x71, 0x22, 0xb3, 0x3e,
2252                                      0x09, 0x9c, 0x76, 0x13, 0x9b, 0x29,
2253                                      0x57, 0x94 ),
2254                             BIGINT ( 0xca, 0x94, 0xf7, 0xca ),
2255                             BIGINT ( 0x83, 0x68, 0xb9, 0xe7, 0x91, 0xf3,
2256                                      0x3b, 0x5a, 0x0b, 0xb6, 0x1e, 0x2f,
2257                                      0x3f, 0x5f, 0xdc, 0x96, 0x5b, 0x7f,
2258                                      0x8d, 0xc5, 0x8e, 0xda, 0x6e, 0x21,
2259                                      0xe3, 0x20, 0xea, 0x37, 0x39, 0x3b,
2260                                      0xb4, 0xd7, 0xf6, 0xba, 0x61, 0xfe,
2261                                      0xdc, 0x7e, 0x82, 0x9a, 0x38, 0x7b,
2262                                      0xd5, 0xb1, 0x11, 0x98, 0xc4, 0x88,
2263                                      0x0b, 0x01, 0x7d, 0x81, 0xc9, 0x64,
2264                                      0x23, 0xc3, 0x3e, 0xf3, 0x67, 0x95,
2265                                      0x78, 0xca, 0xda, 0x52, 0xaf, 0x72,
2266                                      0x25, 0xd9, 0xf0, 0x27, 0xd3, 0x1c,
2267                                      0xfb, 0xad, 0xa1, 0xa7, 0x06, 0x2f,
2268                                      0xaa, 0x2f, 0x86, 0x5c, 0x8b, 0x30,
2269                                      0xe1, 0xda, 0x5a, 0x36, 0xf9, 0xfd,
2270                                      0xbf, 0xfe, 0x0d, 0x03, 0xf8, 0x9c,
2271                                      0x6b, 0x9b, 0xe5, 0x70, 0x6d, 0x75,
2272                                      0xd7, 0x54, 0x28, 0x43, 0x34, 0x69,
2273                                      0x98, 0x11, 0x29, 0xee, 0x50, 0x06,
2274                                      0xa4, 0xc4, 0x11, 0x6d, 0x60, 0x8c,
2275                                      0xcd, 0xd1, 0x88, 0xe9, 0x6b, 0xbb,
2276                                      0xc1, 0xd4 ) );
2277         bigint_mod_exp_ok ( BIGINT ( 0xa1, 0x01, 0x7e, 0xb4, 0x0e, 0x66,
2278                                      0xa5, 0x07, 0x8b, 0x10, 0x84, 0x0d,
2279                                      0x30, 0x0a, 0xa4, 0x2d, 0x10, 0x2c,
2280                                      0xd4, 0x9a, 0x27, 0xf1, 0x02, 0x8c,
2281                                      0x38, 0x18, 0x7f, 0x7f, 0x95, 0x65,
2282                                      0xf1, 0xa9, 0x3b, 0x7d, 0x1f, 0x4f,
2283                                      0x88, 0xb0, 0x65, 0x62, 0x63, 0x63,
2284                                      0xaa, 0x82, 0xfc, 0x83, 0x3a, 0x3a,
2285                                      0x46, 0x59, 0x6a, 0x89, 0xec, 0xa9,
2286                                      0xb0, 0x4c, 0x5e, 0xbe, 0x46, 0x98,
2287                                      0xd0, 0xd4, 0xb7, 0xe3, 0x1b, 0x30,
2288                                      0x0b, 0xfb, 0xbb, 0x4f, 0x0b, 0xd3,
2289                                      0xe4, 0xa0, 0x80, 0x54, 0xcb, 0x52,
2290                                      0x0a, 0xe8, 0x03, 0x75, 0x8e, 0x96,
2291                                      0xa4, 0x21, 0xaa, 0xbd, 0x7a, 0xfd,
2292                                      0xfa, 0xf8, 0xaf, 0x42, 0xf6, 0x61,
2293                                      0xd2, 0x93, 0xce, 0x66, 0x67, 0xe9,
2294                                      0x02, 0xda, 0x81, 0x0b, 0xb0, 0x1e,
2295                                      0x9e, 0x27, 0x57, 0x98, 0x18, 0x88,
2296                                      0x35, 0x49, 0xc0, 0x88, 0x88, 0x59,
2297                                      0xae, 0x2f, 0x66, 0x59, 0x31, 0x87,
2298                                      0x88, 0xda ),
2299                             BIGINT ( 0xfe, 0x21, 0x7c, 0xf4, 0xbe, 0xae,
2300                                      0x65, 0xda, 0x89, 0xd2, 0x26, 0xd6,
2301                                      0x9c, 0x65, 0xc6, 0xb6, 0xb4, 0x0a,
2302                                      0x84, 0x11, 0xe1, 0xe8, 0xba, 0xd8,
2303                                      0x16, 0xcf, 0x60, 0x6c, 0x83, 0xa5,
2304                                      0x4a, 0xbf, 0xa2, 0x24, 0x0b, 0x66,
2305                                      0xda, 0xe2, 0x4e, 0x2d, 0xe5, 0x9e,
2306                                      0xbf, 0xad, 0x5c, 0xa3, 0x1e, 0x5c,
2307                                      0xbd, 0xe2, 0x5b, 0x46, 0xcf, 0xcc,
2308                                      0xd5, 0xc9, 0x13, 0x95, 0xc3, 0xdb,
2309                                      0x64, 0xbf, 0xeb, 0x31, 0xa9, 0x8a,
2310                                      0x3b, 0xd2, 0x5d, 0x3b, 0x2e, 0xdc,
2311                                      0x0c, 0xca, 0xab, 0xde, 0x92, 0xae,
2312                                      0x45, 0x35, 0x96, 0xb0, 0xb7, 0xb9,
2313                                      0xe6, 0xfe, 0x28, 0x0d, 0x10, 0x72,
2314                                      0x53, 0x8e, 0x21, 0xc0, 0x33, 0x79,
2315                                      0x01, 0x43, 0x8d, 0x77, 0xc4, 0xaa,
2316                                      0xcf, 0x7f, 0xc3, 0xd1, 0xf5, 0xfd,
2317                                      0x79, 0x81, 0xf6, 0x2e, 0xb7, 0xeb,
2318                                      0x55, 0x5f, 0x74, 0xf0, 0x3a, 0xb9,
2319                                      0x57, 0x07, 0x09, 0x97, 0xa5, 0x4c,
2320                                      0x4a, 0x85 ),
2321                             BIGINT ( 0xd9, 0xb7, 0xb2, 0xd6, 0xeb, 0xf3,
2322                                      0x66, 0xbe, 0x15, 0x64, 0xad, 0x2e,
2323                                      0x9e, 0xc6, 0xaf, 0x5e, 0xaf, 0x40,
2324                                      0x1e, 0x90, 0x82, 0x2f, 0x98 ),
2325                             BIGINT ( 0x12, 0x48, 0x31, 0x7f, 0x09, 0xbb,
2326                                      0x8f, 0xd9, 0x02, 0x7e, 0x4a, 0xd0,
2327                                      0x2f, 0x42, 0x7c, 0x17, 0x6e, 0x83,
2328                                      0x74, 0x21, 0x95, 0x47, 0x7d, 0x93,
2329                                      0x4a, 0xce, 0x34, 0x7c, 0xde, 0xc7,
2330                                      0x8f, 0xf6, 0x28, 0x97, 0xba, 0x81,
2331                                      0x9b, 0xcc, 0x54, 0x14, 0x7f, 0xd3,
2332                                      0x93, 0x66, 0x41, 0x8c, 0x0e, 0x47,
2333                                      0xee, 0xc5, 0x5e, 0xd6, 0x5f, 0x01,
2334                                      0x62, 0x97, 0xf1, 0x2b, 0xee, 0x60,
2335                                      0x5e, 0x82, 0x2c, 0x7b, 0x0a, 0xf2,
2336                                      0xc3, 0x23, 0xbf, 0xb9, 0x83, 0xf7,
2337                                      0x97, 0xf5, 0xca, 0x58, 0xd7, 0xf0,
2338                                      0x87, 0x7b, 0xcb, 0x87, 0x69, 0x42,
2339                                      0xbc, 0x05, 0xc4, 0xad, 0xbd, 0x82,
2340                                      0xcf, 0x44, 0x16, 0x4f, 0x46, 0xe0,
2341                                      0xde, 0x2f, 0xfa, 0x77, 0xec, 0xa4,
2342                                      0x23, 0x7d, 0x47, 0x3e, 0x94, 0x19,
2343                                      0x8b, 0xb8, 0x84, 0x81, 0x80, 0x6c,
2344                                      0x1e, 0x31, 0xa3, 0x6d, 0x14, 0x94,
2345                                      0x57, 0x28, 0x99, 0x08, 0x0a, 0xa7,
2346                                      0x98, 0x4b ) );
2347         bigint_mod_exp_ok ( BIGINT ( 0xda, 0x52, 0xfd, 0x44, 0x5d, 0x11,
2348                                      0x60, 0x6c, 0xec, 0x87, 0xbf, 0x19,
2349                                      0xb8, 0x46, 0xaa, 0x41, 0xfc, 0x10,
2350                                      0xae, 0x47, 0xd6, 0x72, 0x42, 0x57,
2351                                      0xc3, 0x05, 0xca, 0xe3, 0x59, 0x94,
2352                                      0x82, 0x7c, 0xa1, 0xe0, 0xd2, 0x6b,
2353                                      0x77, 0x71, 0x42, 0xa1, 0xf7, 0x84,
2354                                      0xae, 0xf4, 0x6f, 0x44, 0x0d, 0x88,
2355                                      0xa2, 0xc5, 0x45, 0x9b, 0x49, 0x36,
2356                                      0xd4, 0x20, 0x3a, 0x7c, 0x92, 0xdb,
2357                                      0x65, 0xd9, 0x20, 0xd6, 0x71, 0x22,
2358                                      0x90, 0x70, 0xbf, 0xf3, 0x17, 0xe8,
2359                                      0x2c, 0x10, 0xe9, 0x4c, 0x02, 0x69,
2360                                      0x37, 0xa2, 0x91, 0x04, 0x46, 0x11,
2361                                      0xdc, 0xab, 0x5b, 0x1e, 0x3e, 0x31,
2362                                      0xd8, 0x69, 0xf8, 0x48, 0x84, 0x1f,
2363                                      0x56, 0x46, 0xf1, 0xc0, 0x14, 0x3f,
2364                                      0xcc, 0x5d, 0xe2, 0xf7, 0x8b, 0xa4,
2365                                      0x9e, 0x94, 0x32, 0xaa, 0x3c, 0x5e,
2366                                      0x21, 0x70, 0x00, 0x24, 0x2a, 0x1b,
2367                                      0xec, 0x25, 0xb1, 0xb6, 0x83, 0x36,
2368                                      0x5a, 0x95 ),
2369                             BIGINT ( 0x5e, 0xdc, 0x71, 0x1f, 0x5b, 0x55,
2370                                      0xaa, 0xda, 0x56, 0xf5, 0x93, 0x9b,
2371                                      0xe8, 0xfc, 0x6a, 0x80, 0xe1, 0xe3,
2372                                      0x93, 0xe4, 0xc0, 0x58, 0x6f, 0x22,
2373                                      0xce, 0x9d, 0x6f, 0x84, 0x4c, 0xd4,
2374                                      0x12, 0x44, 0x57, 0x25, 0xca, 0xe5,
2375                                      0x2b, 0x7c, 0x35, 0x88, 0xc7, 0x38,
2376                                      0x25, 0x20, 0x9b, 0x57, 0xf2, 0xf2,
2377                                      0x6c, 0x28, 0x47, 0x9c, 0x3f, 0x91,
2378                                      0x1e, 0x3f, 0xe9, 0xeb, 0x50, 0xd6,
2379                                      0xa7, 0x22, 0x88, 0x6c, 0x71, 0xe5,
2380                                      0x62, 0x2a, 0xb7, 0xce, 0xbe, 0xf7,
2381                                      0x1a, 0x8c, 0x52, 0xa6, 0xff, 0xb8,
2382                                      0x34, 0x83, 0x7e, 0x04, 0xa8, 0x9c,
2383                                      0xa8, 0xa7, 0xd1, 0x05, 0x8e, 0x13,
2384                                      0x03, 0xe0, 0x49, 0xd8, 0x4a, 0xc4,
2385                                      0x4d, 0x38, 0x21, 0x5b, 0x62, 0xc2,
2386                                      0x38, 0x23, 0x7c, 0x9e, 0xf1, 0xe9,
2387                                      0xb6, 0x9a, 0x75, 0x42, 0x14, 0x99,
2388                                      0x63, 0x36, 0x13, 0x4c, 0x2d, 0x3a,
2389                                      0x77, 0xd4, 0x74, 0xb7, 0x30, 0xb2,
2390                                      0x00, 0x0f ),
2391                             BIGINT ( 0xe3, 0xe5, 0x3b, 0xb5, 0x92, 0x5a,
2392                                      0xc6, 0xfa, 0x8f, 0xe8, 0x00, 0xb9,
2393                                      0x5c, 0xa0, 0xb6, 0x3e, 0x5e, 0x14,
2394                                      0x12, 0xa9, 0xdd, 0x2a, 0x3d, 0x4d,
2395                                      0xa3, 0x91, 0x6a, 0x56, 0x99, 0xc2,
2396                                      0x6c, 0x8e, 0xda, 0xb0, 0x5a, 0x2a,
2397                                      0x37, 0x55, 0x8b, 0xd3, 0x9b, 0xb6,
2398                                      0x1d, 0x49, 0x7d, 0x81, 0x76, 0x1c,
2399                                      0x2e, 0xb9, 0x92, 0x6d, 0xfa, 0x54,
2400                                      0x53, 0xfc, 0x74, 0x9b, 0x6b, 0x63,
2401                                      0x95, 0x1a, 0x89, 0xcc, 0xbd, 0x36,
2402                                      0xc5, 0x31, 0x7f, 0xf5, 0x31, 0x69,
2403                                      0x40, 0xd5, 0x7b, 0x94, 0x5d, 0xa9,
2404                                      0xd1, 0x34, 0x95, 0xa1, 0x8b, 0xa5,
2405                                      0xb5, 0x83, 0xda, 0xb5, 0x9d, 0x5b,
2406                                      0x74, 0x41, 0xad, 0x81, 0x45, 0x40,
2407                                      0x9b, 0xc3, 0xe8, 0xfe, 0x47, 0xdc,
2408                                      0xb0, 0xc3, 0x34, 0x5d, 0xf6, 0x3c,
2409                                      0x1d, 0x07, 0x76, 0xd9, 0x25, 0xca,
2410                                      0xa2, 0x39, 0x6c, 0xa8, 0xae, 0x30,
2411                                      0x4a, 0xde, 0xfb, 0xeb, 0x19, 0x80,
2412                                      0x5e, 0x49 ),
2413                             BIGINT ( 0x4b, 0x0e, 0x74, 0xb8, 0xa7, 0x92,
2414                                      0x74, 0xd9, 0x50, 0xf6, 0x1b, 0x67,
2415                                      0x76, 0x76, 0x56, 0x6c, 0x09, 0x9c,
2416                                      0x01, 0xda, 0xaf, 0xa3, 0xca, 0xb2,
2417                                      0x12, 0x85, 0x52, 0x24, 0xe9, 0x7e,
2418                                      0x2b, 0xf2, 0x6e, 0xe9, 0x1a, 0x10,
2419                                      0x5d, 0xa0, 0x25, 0x46, 0x8f, 0x2a,
2420                                      0x95, 0x62, 0x50, 0xb6, 0x66, 0x43,
2421                                      0x37, 0x8b, 0xcb, 0x05, 0xf8, 0x61,
2422                                      0x59, 0xf9, 0xdd, 0xd2, 0x68, 0x72,
2423                                      0xfa, 0x88, 0x13, 0x36, 0xd8, 0x24,
2424                                      0x73, 0xec, 0x47, 0x44, 0xdd, 0x45,
2425                                      0x8a, 0x59, 0xd2, 0xbd, 0x43, 0xe3,
2426                                      0x05, 0x16, 0xd5, 0x9b, 0x1c, 0x8a,
2427                                      0x4b, 0x07, 0xda, 0x58, 0x0d, 0x4a,
2428                                      0x4e, 0xe7, 0x15, 0xfc, 0xbd, 0x95,
2429                                      0xf7, 0x18, 0xa5, 0xa7, 0x93, 0xff,
2430                                      0xf8, 0x1f, 0xd4, 0x6b, 0x07, 0xc6,
2431                                      0x5d, 0x90, 0x73, 0x57, 0x57, 0x37,
2432                                      0xfa, 0x83, 0xd4, 0x7c, 0xe9, 0x77,
2433                                      0x46, 0x91, 0x3a, 0x50, 0x0d, 0x6a,
2434                                      0x25, 0xd0 ) );
2435 }
2436
2437 /** Big integer self-test */
2438 struct self_test bigint_test __self_test = {
2439         .name = "bigint",
2440         .exec = bigint_test_exec,
2441 };