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