iPXE
bigint_test.c
Go to the documentation of this file.
00001 /*
00002  * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
00003  *
00004  * This program is free software; you can redistribute it and/or
00005  * modify it under the terms of the GNU General Public License as
00006  * published by the Free Software Foundation; either version 2 of the
00007  * License, or any later version.
00008  *
00009  * This program is distributed in the hope that it will be useful, but
00010  * WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012  * General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU General Public License
00015  * along with this program; if not, write to the Free Software
00016  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
00017  * 02110-1301, USA.
00018  *
00019  * You can also choose to distribute this program under the terms of
00020  * the Unmodified Binary Distribution Licence (as given in the file
00021  * COPYING.UBDL), provided that you have satisfied its requirements.
00022  */
00023 
00024 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
00025 
00026 /** @file
00027  *
00028  * Big integer self-tests
00029  *
00030  */
00031 
00032 /* Forcibly enable assertions */
00033 #undef NDEBUG
00034 
00035 #include <assert.h>
00036 #include <string.h>
00037 #include <ipxe/bigint.h>
00038 #include <ipxe/test.h>
00039 
00040 /** Define inline big integer */
00041 #define BIGINT(...) { __VA_ARGS__ }
00042 
00043 /* Provide global functions to allow inspection of generated assembly code */
00044 
00045 void bigint_init_sample ( bigint_element_t *value0, unsigned int size,
00046                           const void *data, size_t len ) {
00047         bigint_t ( size ) *value __attribute__ (( may_alias ))
00048                 = ( ( void * ) value0 );
00049 
00050         bigint_init ( value, data, len );
00051 }
00052 
00053 void bigint_done_sample ( const bigint_element_t *value0, unsigned int size,
00054                           void *out, size_t len ) {
00055         const bigint_t ( size ) *value __attribute__ (( may_alias ))
00056                 = ( ( const void * ) value0 );
00057 
00058         bigint_done ( value, out, len );
00059 }
00060 
00061 void bigint_add_sample ( const bigint_element_t *addend0,
00062                          bigint_element_t *value0, unsigned int size ) {
00063         const bigint_t ( size ) *addend __attribute__ (( may_alias ))
00064                 = ( ( const void * ) addend0 );
00065         bigint_t ( size ) *value __attribute__ (( may_alias ))
00066                 = ( ( void * ) value0 );
00067 
00068         bigint_add ( addend, value );
00069 }
00070 
00071 void bigint_subtract_sample ( const bigint_element_t *subtrahend0,
00072                               bigint_element_t *value0, unsigned int size ) {
00073         const bigint_t ( size ) *subtrahend __attribute__ (( may_alias ))
00074                 = ( ( const void * ) subtrahend0 );
00075         bigint_t ( size ) *value __attribute__ (( may_alias ))
00076                 = ( ( void * ) value0 );
00077 
00078         bigint_subtract ( subtrahend, value );
00079 }
00080 
00081 void bigint_rol_sample ( bigint_element_t *value0, unsigned int size ) {
00082         bigint_t ( size ) *value __attribute__ (( may_alias ))
00083                 = ( ( void * ) value0 );
00084 
00085         bigint_rol ( value );
00086 }
00087 
00088 void bigint_ror_sample ( bigint_element_t *value0, unsigned int size ) {
00089         bigint_t ( size ) *value __attribute__ (( may_alias ))
00090                 = ( ( void * ) value0 );
00091 
00092         bigint_ror ( value );
00093 }
00094 
00095 int bigint_is_zero_sample ( const bigint_element_t *value0,
00096                             unsigned int size ) {
00097         const bigint_t ( size ) *value __attribute__ (( may_alias ))
00098                 = ( ( const void * ) value0 );
00099 
00100         return bigint_is_zero ( value );
00101 }
00102 
00103 int bigint_is_geq_sample ( const bigint_element_t *value0,
00104                            const bigint_element_t *reference0,
00105                            unsigned int size ) {
00106         const bigint_t ( size ) *value __attribute__ (( may_alias ))
00107                 = ( ( const void * ) value0 );
00108         const bigint_t ( size ) *reference __attribute__ (( may_alias ))
00109                 = ( ( const void * ) reference0 );
00110 
00111         return bigint_is_geq ( value, reference );
00112 }
00113 
00114 int bigint_bit_is_set_sample ( const bigint_element_t *value0,
00115                                unsigned int size, unsigned int bit ) {
00116         const bigint_t ( size ) *value __attribute__ (( may_alias ))
00117                 = ( ( const void * ) value0 );
00118 
00119         return bigint_bit_is_set ( value, bit );
00120 }
00121 
00122 int bigint_max_set_bit_sample ( const bigint_element_t *value0,
00123                                 unsigned int size ) {
00124         const bigint_t ( size ) *value __attribute__ (( may_alias ))
00125                 = ( ( const void * ) value0 );
00126 
00127         return bigint_max_set_bit ( value );
00128 }
00129 
00130 void bigint_grow_sample ( const bigint_element_t *source0,
00131                           unsigned int source_size, bigint_element_t *dest0,
00132                           unsigned int dest_size ) {
00133         const bigint_t ( source_size ) *source __attribute__ (( may_alias ))
00134                 = ( ( const void * ) source0 );
00135         bigint_t ( dest_size ) *dest __attribute__ (( may_alias ))
00136                 = ( ( void * ) dest0 );
00137 
00138         bigint_grow ( source, dest );
00139 }
00140 
00141 void bigint_shrink_sample ( const bigint_element_t *source0,
00142                             unsigned int source_size, bigint_element_t *dest0,
00143                             unsigned int dest_size ) {
00144         const bigint_t ( source_size ) *source __attribute__ (( may_alias ))
00145                 = ( ( const void * ) source0 );
00146         bigint_t ( dest_size ) *dest __attribute__ (( may_alias ))
00147                 = ( ( void * ) dest0 );
00148 
00149         bigint_shrink ( source, dest );
00150 }
00151 
00152 void bigint_multiply_sample ( const bigint_element_t *multiplicand0,
00153                               const bigint_element_t *multiplier0,
00154                               bigint_element_t *result0,
00155                               unsigned int size ) {
00156         const bigint_t ( size ) *multiplicand __attribute__ (( may_alias ))
00157                 = ( ( const void * ) multiplicand0 );
00158         const bigint_t ( size ) *multiplier __attribute__ (( may_alias ))
00159                 = ( ( const void * ) multiplier0 );
00160         bigint_t ( size * 2 ) *result __attribute__ (( may_alias ))
00161                 = ( ( void * ) result0 );
00162 
00163         bigint_multiply ( multiplicand, multiplier, result );
00164 }
00165 
00166 void bigint_mod_multiply_sample ( const bigint_element_t *multiplicand0,
00167                                   const bigint_element_t *multiplier0,
00168                                   const bigint_element_t *modulus0,
00169                                   bigint_element_t *result0,
00170                                   unsigned int size,
00171                                   void *tmp ) {
00172         const bigint_t ( size ) *multiplicand __attribute__ (( may_alias ))
00173                 = ( ( const void * ) multiplicand0 );
00174         const bigint_t ( size ) *multiplier __attribute__ (( may_alias ))
00175                 = ( ( const void * ) multiplier0 );
00176         const bigint_t ( size ) *modulus __attribute__ (( may_alias ))
00177                 = ( ( const void * ) modulus0 );
00178         bigint_t ( size ) *result __attribute__ (( may_alias ))
00179                 = ( ( void * ) result0 );
00180 
00181         bigint_mod_multiply ( multiplicand, multiplier, modulus, result, tmp );
00182 }
00183 
00184 void bigint_mod_exp_sample ( const bigint_element_t *base0,
00185                              const bigint_element_t *modulus0,
00186                              const bigint_element_t *exponent0,
00187                              bigint_element_t *result0,
00188                              unsigned int size, unsigned int exponent_size,
00189                              void *tmp ) {
00190         const bigint_t ( size ) *base __attribute__ (( may_alias ))
00191                 = ( ( const void * ) base0 );
00192         const bigint_t ( size ) *modulus __attribute__ (( may_alias ))
00193                 = ( ( const void * ) modulus0 );
00194         const bigint_t ( exponent_size ) *exponent __attribute__ (( may_alias ))
00195                 = ( ( const void * ) exponent0 );
00196         bigint_t ( size ) *result __attribute__ (( may_alias ))
00197                 = ( ( void * ) result0 );
00198 
00199         bigint_mod_exp ( base, modulus, exponent, result, tmp );
00200 }
00201 
00202 /**
00203  * Report result of big integer addition test
00204  *
00205  * @v addend            Big integer to add
00206  * @v value             Big integer to be added to
00207  * @v expected          Big integer expected result
00208  */
00209 #define bigint_add_ok( addend, value, expected ) do {                   \
00210         static const uint8_t addend_raw[] = addend;                     \
00211         static const uint8_t value_raw[] = value;                       \
00212         static const uint8_t expected_raw[] = expected;                 \
00213         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
00214         unsigned int size =                                             \
00215                 bigint_required_size ( sizeof ( value_raw ) );          \
00216         bigint_t ( size ) addend_temp;                                  \
00217         bigint_t ( size ) value_temp;                                   \
00218         {} /* Fix emacs alignment */                                    \
00219                                                                         \
00220         assert ( bigint_size ( &addend_temp ) ==                        \
00221                  bigint_size ( &value_temp ) );                         \
00222         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
00223         bigint_init ( &addend_temp, addend_raw,                         \
00224                       sizeof ( addend_raw ) );                          \
00225         DBG ( "Add:\n" );                                               \
00226         DBG_HDA ( 0, &addend_temp, sizeof ( addend_temp ) );            \
00227         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
00228         bigint_add ( &addend_temp, &value_temp );                       \
00229         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
00230         bigint_done ( &value_temp, result_raw, sizeof ( result_raw ) ); \
00231                                                                         \
00232         ok ( memcmp ( result_raw, expected_raw,                         \
00233                       sizeof ( result_raw ) ) == 0 );                   \
00234         } while ( 0 )
00235 
00236 /**
00237  * Report result of big integer subtraction test
00238  *
00239  * @v subtrahend        Big integer to subtract
00240  * @v value             Big integer to be subtracted from
00241  * @v expected          Big integer expected result
00242  */
00243 #define bigint_subtract_ok( subtrahend, value, expected ) do {          \
00244         static const uint8_t subtrahend_raw[] = subtrahend;             \
00245         static const uint8_t value_raw[] = value;                       \
00246         static const uint8_t expected_raw[] = expected;                 \
00247         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
00248         unsigned int size =                                             \
00249                 bigint_required_size ( sizeof ( value_raw ) );          \
00250         bigint_t ( size ) subtrahend_temp;                              \
00251         bigint_t ( size ) value_temp;                                   \
00252         {} /* Fix emacs alignment */                                    \
00253                                                                         \
00254         assert ( bigint_size ( &subtrahend_temp ) ==                    \
00255                  bigint_size ( &value_temp ) );                         \
00256         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
00257         bigint_init ( &subtrahend_temp, subtrahend_raw,                 \
00258                       sizeof ( subtrahend_raw ) );                      \
00259         DBG ( "Subtract:\n" );                                          \
00260         DBG_HDA ( 0, &subtrahend_temp, sizeof ( subtrahend_temp ) );    \
00261         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
00262         bigint_subtract ( &subtrahend_temp, &value_temp );              \
00263         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
00264         bigint_done ( &value_temp, result_raw, sizeof ( result_raw ) ); \
00265                                                                         \
00266         ok ( memcmp ( result_raw, expected_raw,                         \
00267                       sizeof ( result_raw ) ) == 0 );                   \
00268         } while ( 0 )
00269 
00270 /**
00271  * Report result of big integer left rotation test
00272  *
00273  * @v value             Big integer
00274  * @v expected          Big integer expected result
00275  */
00276 #define bigint_rol_ok( value, expected ) do {                           \
00277         static const uint8_t value_raw[] = value;                       \
00278         static const uint8_t expected_raw[] = expected;                 \
00279         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
00280         unsigned int size =                                             \
00281                 bigint_required_size ( sizeof ( value_raw ) );          \
00282         bigint_t ( size ) value_temp;                                   \
00283         {} /* Fix emacs alignment */                                    \
00284                                                                         \
00285         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
00286         DBG ( "Rotate left:\n" );                                       \
00287         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
00288         bigint_rol ( &value_temp );                                     \
00289         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
00290         bigint_done ( &value_temp, result_raw, sizeof ( result_raw ) ); \
00291                                                                         \
00292         ok ( memcmp ( result_raw, expected_raw,                         \
00293                       sizeof ( result_raw ) ) == 0 );                   \
00294         } while ( 0 )
00295 
00296 /**
00297  * Report result of big integer right rotation test
00298  *
00299  * @v value             Big integer
00300  * @v expected          Big integer expected result
00301  */
00302 #define bigint_ror_ok( value, expected ) do {                           \
00303         static const uint8_t value_raw[] = value;                       \
00304         static const uint8_t expected_raw[] = expected;                 \
00305         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
00306         unsigned int size =                                             \
00307                 bigint_required_size ( sizeof ( value_raw ) );          \
00308         bigint_t ( size ) value_temp;                                   \
00309         {} /* Fix emacs alignment */                                    \
00310                                                                         \
00311         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
00312         DBG ( "Rotate right:\n" );                                      \
00313         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
00314         bigint_ror ( &value_temp );                                     \
00315         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
00316         bigint_done ( &value_temp, result_raw, sizeof ( result_raw ) ); \
00317                                                                         \
00318         ok ( memcmp ( result_raw, expected_raw,                         \
00319                       sizeof ( result_raw ) ) == 0 );                   \
00320         } while ( 0 )
00321 
00322 /**
00323  * Report result of big integer zero comparison test
00324  *
00325  * @v value             Big integer
00326  * @v expected          Expected result
00327  */
00328 #define bigint_is_zero_ok( value, expected ) do {                       \
00329         static const uint8_t value_raw[] = value;                       \
00330         unsigned int size =                                             \
00331                 bigint_required_size ( sizeof ( value_raw ) );          \
00332         bigint_t ( size ) value_temp;                                   \
00333         int is_zero;                                                    \
00334         {} /* Fix emacs alignment */                                    \
00335                                                                         \
00336         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
00337         DBG ( "Zero comparison:\n" );                                   \
00338         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
00339         is_zero = bigint_is_zero ( &value_temp );                       \
00340         DBG ( "...is %szero\n", ( is_zero ? "" : "not " ) );            \
00341         ok ( ( !! is_zero ) == ( !! (expected) ) );                     \
00342         } while ( 0 )
00343 
00344 /**
00345  * Report result of big integer greater-than-or-equal comparison test
00346  *
00347  * @v value             Big integer
00348  * @v reference         Reference big integer
00349  * @v expected          Expected result
00350  */
00351 #define bigint_is_geq_ok( value, reference, expected ) do {             \
00352         static const uint8_t value_raw[] = value;                       \
00353         static const uint8_t reference_raw[] = reference;               \
00354         unsigned int size =                                             \
00355                 bigint_required_size ( sizeof ( value_raw ) );          \
00356         bigint_t ( size ) value_temp;                                   \
00357         bigint_t ( size ) reference_temp;                               \
00358         int is_geq;                                                     \
00359         {} /* Fix emacs alignment */                                    \
00360                                                                         \
00361         assert ( bigint_size ( &reference_temp ) ==                     \
00362                  bigint_size ( &value_temp ) );                         \
00363         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
00364         bigint_init ( &reference_temp, reference_raw,                   \
00365                       sizeof ( reference_raw ) );                       \
00366         DBG ( "Greater-than-or-equal comparison:\n" );                  \
00367         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
00368         DBG_HDA ( 0, &reference_temp, sizeof ( reference_temp ) );      \
00369         is_geq = bigint_is_geq ( &value_temp, &reference_temp );        \
00370         DBG ( "...is %sgreater than or equal\n",                        \
00371               ( is_geq ? "" : "not " ) );                               \
00372         ok ( ( !! is_geq ) == ( !! (expected) ) );                      \
00373         } while ( 0 )
00374 
00375 /**
00376  * Report result of big integer bit-set test
00377  *
00378  * @v value             Big integer
00379  * @v bit               Bit to test
00380  * @v expected          Expected result
00381  */
00382 #define bigint_bit_is_set_ok( value, bit, expected ) do {               \
00383         static const uint8_t value_raw[] = value;                       \
00384         unsigned int size =                                             \
00385                 bigint_required_size ( sizeof ( value_raw ) );          \
00386         bigint_t ( size ) value_temp;                                   \
00387         int bit_is_set;                                                 \
00388         {} /* Fix emacs alignment */                                    \
00389                                                                         \
00390         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
00391         DBG ( "Bit set:\n" );                                           \
00392         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
00393         bit_is_set = bigint_bit_is_set ( &value_temp, bit );            \
00394         DBG ( "...bit %d is %sset\n", bit,                              \
00395               ( bit_is_set ? "" : "not " ) );                           \
00396         ok ( ( !! bit_is_set ) == ( !! (expected) ) );                  \
00397         } while ( 0 )
00398 
00399 /**
00400  * Report result of big integer maximum set bit test
00401  *
00402  * @v value             Big integer
00403  * @v expected          Expected result
00404  */
00405 #define bigint_max_set_bit_ok( value, expected ) do {                   \
00406         static const uint8_t value_raw[] = value;                       \
00407         unsigned int size =                                             \
00408                 bigint_required_size ( sizeof ( value_raw ) );          \
00409         bigint_t ( size ) value_temp;                                   \
00410         int max_set_bit;                                                \
00411         {} /* Fix emacs alignment */                                    \
00412                                                                         \
00413         bigint_init ( &value_temp, value_raw, sizeof ( value_raw ) );   \
00414         DBG ( "Maximum set bit:\n" );                                   \
00415         DBG_HDA ( 0, &value_temp, sizeof ( value_temp ) );              \
00416         max_set_bit = bigint_max_set_bit ( &value_temp );               \
00417         DBG ( "...maximum set bit is bit %d\n", ( max_set_bit - 1 ) );  \
00418         ok ( max_set_bit == (expected) );                               \
00419         } while ( 0 )
00420 
00421 /**
00422  * Report result of big integer multiplication test
00423  *
00424  * @v multiplicand      Big integer to be multiplied
00425  * @v multiplier        Big integer to be multiplied
00426  * @v expected          Big integer expected result
00427  */
00428 #define bigint_multiply_ok( multiplicand, multiplier, expected ) do {   \
00429         static const uint8_t multiplicand_raw[] = multiplicand;         \
00430         static const uint8_t multiplier_raw[] = multiplier;             \
00431         static const uint8_t expected_raw[] = expected;                 \
00432         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
00433         unsigned int size =                                             \
00434                 bigint_required_size ( sizeof ( multiplicand_raw ) );   \
00435         bigint_t ( size ) multiplicand_temp;                            \
00436         bigint_t ( size ) multiplier_temp;                              \
00437         bigint_t ( size * 2 ) result_temp;                              \
00438         {} /* Fix emacs alignment */                                    \
00439                                                                         \
00440         assert ( bigint_size ( &multiplier_temp ) ==                    \
00441                  bigint_size ( &multiplicand_temp ) );                  \
00442         assert ( bigint_size ( &result_temp ) ==                        \
00443                  ( 2 * bigint_size ( &multiplicand_temp ) ) );          \
00444         bigint_init ( &multiplicand_temp, multiplicand_raw,             \
00445                       sizeof ( multiplicand_raw ) );                    \
00446         bigint_init ( &multiplier_temp, multiplier_raw,                 \
00447                       sizeof ( multiplier_raw ) );                      \
00448         DBG ( "Multiply:\n" );                                          \
00449         DBG_HDA ( 0, &multiplicand_temp, sizeof ( multiplicand_temp ) );\
00450         DBG_HDA ( 0, &multiplier_temp, sizeof ( multiplier_temp ) );    \
00451         bigint_multiply ( &multiplicand_temp, &multiplier_temp,         \
00452                           &result_temp );                               \
00453         DBG_HDA ( 0, &result_temp, sizeof ( result_temp ) );            \
00454         bigint_done ( &result_temp, result_raw, sizeof ( result_raw ) );\
00455                                                                         \
00456         ok ( memcmp ( result_raw, expected_raw,                         \
00457                       sizeof ( result_raw ) ) == 0 );                   \
00458         } while ( 0 )
00459 
00460 /**
00461  * Report result of big integer modular multiplication test
00462  *
00463  * @v multiplicand      Big integer to be multiplied
00464  * @v multiplier        Big integer to be multiplied
00465  * @v modulus           Big integer modulus
00466  * @v expected          Big integer expected result
00467  */
00468 #define bigint_mod_multiply_ok( multiplicand, multiplier, modulus,      \
00469                                 expected ) do {                         \
00470         static const uint8_t multiplicand_raw[] = multiplicand;         \
00471         static const uint8_t multiplier_raw[] = multiplier;             \
00472         static const uint8_t modulus_raw[] = modulus;                   \
00473         static const uint8_t expected_raw[] = expected;                 \
00474         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
00475         unsigned int size =                                             \
00476                 bigint_required_size ( sizeof ( multiplicand_raw ) );   \
00477         bigint_t ( size ) multiplicand_temp;                            \
00478         bigint_t ( size ) multiplier_temp;                              \
00479         bigint_t ( size ) modulus_temp;                                 \
00480         bigint_t ( size ) result_temp;                                  \
00481         size_t tmp_len = bigint_mod_multiply_tmp_len ( &modulus_temp ); \
00482         uint8_t tmp[tmp_len];                                           \
00483         {} /* Fix emacs alignment */                                    \
00484                                                                         \
00485         assert ( bigint_size ( &multiplier_temp ) ==                    \
00486                  bigint_size ( &multiplicand_temp ) );                  \
00487         assert ( bigint_size ( &multiplier_temp ) ==                    \
00488                  bigint_size ( &modulus_temp ) );                       \
00489         assert ( bigint_size ( &multiplier_temp ) ==                    \
00490                  bigint_size ( &result_temp ) );                        \
00491         bigint_init ( &multiplicand_temp, multiplicand_raw,             \
00492                       sizeof ( multiplicand_raw ) );                    \
00493         bigint_init ( &multiplier_temp, multiplier_raw,                 \
00494                       sizeof ( multiplier_raw ) );                      \
00495         bigint_init ( &modulus_temp, modulus_raw,                       \
00496                       sizeof ( modulus_raw ) );                         \
00497         DBG ( "Modular multiply:\n" );                                  \
00498         DBG_HDA ( 0, &multiplicand_temp, sizeof ( multiplicand_temp ) );\
00499         DBG_HDA ( 0, &multiplier_temp, sizeof ( multiplier_temp ) );    \
00500         DBG_HDA ( 0, &modulus_temp, sizeof ( modulus_temp ) );          \
00501         bigint_mod_multiply ( &multiplicand_temp, &multiplier_temp,     \
00502                               &modulus_temp, &result_temp, tmp );       \
00503         DBG_HDA ( 0, &result_temp, sizeof ( result_temp ) );            \
00504         bigint_done ( &result_temp, result_raw, sizeof ( result_raw ) );\
00505                                                                         \
00506         ok ( memcmp ( result_raw, expected_raw,                         \
00507                       sizeof ( result_raw ) ) == 0 );                   \
00508         } while ( 0 )
00509 
00510 /**
00511  * Report result of big integer modular exponentiation test
00512  *
00513  * @v base              Big integer base
00514  * @v modulus           Big integer modulus
00515  * @v exponent          Big integer exponent
00516  * @v expected          Big integer expected result
00517  */
00518 #define bigint_mod_exp_ok( base, modulus, exponent, expected ) do {     \
00519         static const uint8_t base_raw[] = base;                         \
00520         static const uint8_t modulus_raw[] = modulus;                   \
00521         static const uint8_t exponent_raw[] = exponent;                 \
00522         static const uint8_t expected_raw[] = expected;                 \
00523         uint8_t result_raw[ sizeof ( expected_raw ) ];                  \
00524         unsigned int size =                                             \
00525                 bigint_required_size ( sizeof ( base_raw ) );           \
00526         unsigned int exponent_size =                                    \
00527                 bigint_required_size ( sizeof ( exponent_raw ) );       \
00528         bigint_t ( size ) base_temp;                                    \
00529         bigint_t ( size ) modulus_temp;                                 \
00530         bigint_t ( exponent_size ) exponent_temp;                       \
00531         bigint_t ( size ) result_temp;                                  \
00532         size_t tmp_len = bigint_mod_exp_tmp_len ( &modulus_temp,        \
00533                                                   &exponent_temp );     \
00534         uint8_t tmp[tmp_len];                                           \
00535         {} /* Fix emacs alignment */                                    \
00536                                                                         \
00537         assert ( bigint_size ( &modulus_temp ) ==                       \
00538                  bigint_size ( &base_temp ) );                          \
00539         assert ( bigint_size ( &modulus_temp ) ==                       \
00540                  bigint_size ( &result_temp ) );                        \
00541         bigint_init ( &base_temp, base_raw, sizeof ( base_raw ) );      \
00542         bigint_init ( &modulus_temp, modulus_raw,                       \
00543                       sizeof ( modulus_raw ) );                         \
00544         bigint_init ( &exponent_temp, exponent_raw,                     \
00545                       sizeof ( exponent_raw ) );                        \
00546         DBG ( "Modular exponentiation:\n" );                            \
00547         DBG_HDA ( 0, &base_temp, sizeof ( base_temp ) );                \
00548         DBG_HDA ( 0, &modulus_temp, sizeof ( modulus_temp ) );          \
00549         DBG_HDA ( 0, &exponent_temp, sizeof ( exponent_temp ) );        \
00550         bigint_mod_exp ( &base_temp, &modulus_temp, &exponent_temp,     \
00551                          &result_temp, tmp );                           \
00552         DBG_HDA ( 0, &result_temp, sizeof ( result_temp ) );            \
00553         bigint_done ( &result_temp, result_raw, sizeof ( result_raw ) );\
00554                                                                         \
00555         ok ( memcmp ( result_raw, expected_raw,                         \
00556                       sizeof ( result_raw ) ) == 0 );                   \
00557         } while ( 0 )
00558 
00559 /**
00560  * Perform big integer self-tests
00561  *
00562  */
00563 static void bigint_test_exec ( void ) {
00564 
00565         bigint_add_ok ( BIGINT ( 0x8a ),
00566                         BIGINT ( 0x43 ),
00567                         BIGINT ( 0xcd ) );
00568         bigint_add_ok ( BIGINT ( 0xc5, 0x7b ),
00569                         BIGINT ( 0xd6, 0xb1 ),
00570                         BIGINT ( 0x9c, 0x2c ) );
00571         bigint_add_ok ( BIGINT ( 0xf9, 0xd9, 0xdc ),
00572                         BIGINT ( 0x6d, 0x4b, 0xca ),
00573                         BIGINT ( 0x67, 0x25, 0xa6 ) );
00574         bigint_add_ok ( BIGINT ( 0xdd, 0xc2, 0x20, 0x5f ),
00575                         BIGINT ( 0x80, 0x32, 0xc4, 0xb0 ),
00576                         BIGINT ( 0x5d, 0xf4, 0xe5, 0x0f ) );
00577         bigint_add_ok ( BIGINT ( 0x01, 0xed, 0x45, 0x4b, 0x41, 0xeb, 0x4c,
00578                                  0x2e, 0x53, 0x07, 0x15, 0x51, 0x56, 0x47,
00579                                  0x29, 0xfc, 0x9c, 0xbd, 0xbd, 0xfb, 0x1b,
00580                                  0xd1, 0x1d ),
00581                         BIGINT ( 0x73, 0xed, 0xfc, 0x35, 0x31, 0x22, 0xd7,
00582                                  0xb1, 0xea, 0x91, 0x5a, 0xe4, 0xba, 0xbc,
00583                                  0xa1, 0x38, 0x72, 0xae, 0x4b, 0x1c, 0xc1,
00584                                  0x05, 0xb3 ),
00585                         BIGINT ( 0x75, 0xdb, 0x41, 0x80, 0x73, 0x0e, 0x23,
00586                                  0xe0, 0x3d, 0x98, 0x70, 0x36, 0x11, 0x03,
00587                                  0xcb, 0x35, 0x0f, 0x6c, 0x09, 0x17, 0xdc,
00588                                  0xd6, 0xd0 ) );
00589         bigint_add_ok ( BIGINT ( 0x06, 0x8e, 0xd6, 0x18, 0xbb, 0x4b, 0x0c,
00590                                  0xc5, 0x85, 0xde, 0xee, 0x9b, 0x3f, 0x65,
00591                                  0x63, 0x86, 0xf5, 0x5a, 0x9f, 0xa2, 0xd7,
00592                                  0xb2, 0xc7, 0xb6, 0x1d, 0x28, 0x6c, 0x50,
00593                                  0x47, 0x10, 0x0a, 0x0e, 0x86, 0xcd, 0x2a,
00594                                  0x64, 0xdc, 0xe6, 0x9d, 0x96, 0xd8, 0xf4,
00595                                  0x56, 0x46, 0x6f, 0xbb, 0x7b, 0x64, 0x6f,
00596                                  0xdc, 0x2a, 0xd1, 0x3b, 0xcc, 0x03, 0x85,
00597                                  0x95, 0xf4, 0xe9, 0x68, 0x1f, 0x5c, 0xc5,
00598                                  0xbf, 0x97, 0x19, 0x12, 0x88, 0x2e, 0x88,
00599                                  0xb9, 0x34, 0xac, 0x74, 0x83, 0x2d, 0x8f,
00600                                  0xb3, 0x97, 0x53, 0x99, 0xf3, 0xb4, 0x8b,
00601                                  0x2d, 0x98, 0x69, 0x8d, 0x19, 0xf0, 0x40,
00602                                  0x66, 0x3f, 0x60, 0x78, 0x34, 0x7f, 0x9b,
00603                                  0xf7, 0x01, 0x74, 0x55, 0xca, 0x63, 0x25,
00604                                  0x7b, 0x86, 0xe9, 0x73, 0xfd, 0x5d, 0x77,
00605                                  0x32, 0x5e, 0x9e, 0x42, 0x53, 0xb6, 0x35,
00606                                  0x92, 0xb9, 0xd7, 0x1b, 0xf7, 0x16, 0x55,
00607                                  0xf6, 0xe2 ),
00608                         BIGINT ( 0x3f, 0x8f, 0x62, 0x21, 0x4a, 0x7a, 0xa2,
00609                                  0xef, 0xa8, 0x79, 0x9b, 0x73, 0xac, 0xde,
00610                                  0x72, 0xe4, 0xfc, 0x3c, 0xd3, 0xa9, 0x44,
00611                                  0x1a, 0x6a, 0x02, 0x76, 0xe3, 0x78, 0x4d,
00612                                  0x2e, 0x07, 0x9b, 0xb6, 0x3d, 0x5d, 0xc5,
00613                                  0xcd, 0x68, 0x23, 0x4b, 0x5f, 0x89, 0x0e,
00614                                  0xd7, 0xa7, 0xff, 0x18, 0x80, 0xdc, 0xfb,
00615                                  0x34, 0x45, 0xca, 0x4b, 0xdb, 0x8a, 0x19,
00616                                  0xcb, 0xc9, 0xe5, 0xa1, 0x63, 0xa2, 0x0d,
00617                                  0x56, 0xc4, 0xf9, 0x51, 0x1b, 0x88, 0x4e,
00618                                  0x36, 0xab, 0x15, 0x4d, 0x8f, 0xdc, 0x08,
00619                                  0xc4, 0x4d, 0x43, 0xc7, 0x2b, 0xc9, 0x5c,
00620                                  0x05, 0x26, 0xe3, 0x46, 0xf0, 0x64, 0xaa,
00621                                  0x02, 0xa4, 0xbe, 0x3a, 0xd1, 0xca, 0x07,
00622                                  0x6a, 0x6e, 0x62, 0xf4, 0x57, 0x71, 0x96,
00623                                  0xec, 0xf0, 0x0b, 0xac, 0xa4, 0x4a, 0xa3,
00624                                  0x6d, 0x01, 0xba, 0xbd, 0x62, 0xc0, 0x10,
00625                                  0x54, 0x33, 0x8a, 0x71, 0xef, 0xaa, 0x1c,
00626                                  0x25, 0x25 ),
00627                         BIGINT ( 0x46, 0x1e, 0x38, 0x3a, 0x05, 0xc5, 0xaf,
00628                                  0xb5, 0x2e, 0x58, 0x8a, 0x0e, 0xec, 0x43,
00629                                  0xd6, 0x6b, 0xf1, 0x97, 0x73, 0x4c, 0x1b,
00630                                  0xcd, 0x31, 0xb8, 0x94, 0x0b, 0xe4, 0x9d,
00631                                  0x75, 0x17, 0xa5, 0xc4, 0xc4, 0x2a, 0xf0,
00632                                  0x32, 0x45, 0x09, 0xe8, 0xf6, 0x62, 0x03,
00633                                  0x2d, 0xee, 0x6e, 0xd3, 0xfc, 0x41, 0x6b,
00634                                  0x10, 0x70, 0x9b, 0x87, 0xa7, 0x8d, 0x9f,
00635                                  0x61, 0xbe, 0xcf, 0x09, 0x82, 0xfe, 0xd3,
00636                                  0x16, 0x5c, 0x12, 0x63, 0xa3, 0xb6, 0xd6,
00637                                  0xef, 0xdf, 0xc1, 0xc2, 0x13, 0x09, 0x98,
00638                                  0x77, 0xe4, 0x97, 0x61, 0x1f, 0x7d, 0xe7,
00639                                  0x32, 0xbf, 0x4c, 0xd4, 0x0a, 0x54, 0xea,
00640                                  0x68, 0xe4, 0x1e, 0xb3, 0x06, 0x49, 0xa3,
00641                                  0x61, 0x6f, 0xd7, 0x4a, 0x21, 0xd4, 0xbc,
00642                                  0x68, 0x76, 0xf5, 0x20, 0xa1, 0xa8, 0x1a,
00643                                  0x9f, 0x60, 0x58, 0xff, 0xb6, 0x76, 0x45,
00644                                  0xe6, 0xed, 0x61, 0x8d, 0xe6, 0xc0, 0x72,
00645                                  0x1c, 0x07 ) );
00646         bigint_subtract_ok ( BIGINT ( 0x83 ),
00647                              BIGINT ( 0x50 ),
00648                              BIGINT ( 0xcd ) );
00649         bigint_subtract_ok ( BIGINT ( 0x2c, 0x7c ),
00650                              BIGINT ( 0x49, 0x0e ),
00651                              BIGINT ( 0x1c, 0x92 ) );
00652         bigint_subtract_ok ( BIGINT ( 0x9c, 0x30, 0xbf ),
00653                              BIGINT ( 0xde, 0x4e, 0x07 ),
00654                              BIGINT ( 0x42, 0x1d, 0x48 ) );
00655         bigint_subtract_ok ( BIGINT ( 0xbb, 0x77, 0x32, 0x5a ),
00656                              BIGINT ( 0x5a, 0xd5, 0xfe, 0x28 ),
00657                              BIGINT ( 0x9f, 0x5e, 0xcb, 0xce ) );
00658         bigint_subtract_ok ( BIGINT ( 0x7b, 0xaa, 0x16, 0xcf, 0x15, 0x87,
00659                                       0xe0, 0x4f, 0x2c, 0xa3, 0xec, 0x2f,
00660                                       0x46, 0xfb, 0x83, 0xc6, 0xe0, 0xee,
00661                                       0x57, 0xfa, 0x04, 0xce, 0xa6 ),
00662                              BIGINT ( 0x46, 0x55, 0xb6, 0x23, 0x63, 0xd0,
00663                                       0x55, 0xdb, 0x8f, 0xcc, 0x55, 0xa8,
00664                                       0x2f, 0x85, 0xc1, 0x9f, 0x2c, 0x13,
00665                                       0x10, 0x9e, 0x76, 0x3c, 0x11 ),
00666                              BIGINT ( 0xca, 0xab, 0x9f, 0x54, 0x4e, 0x48,
00667                                       0x75, 0x8c, 0x63, 0x28, 0x69, 0x78,
00668                                       0xe8, 0x8a, 0x3d, 0xd8, 0x4b, 0x24,
00669                                       0xb8, 0xa4, 0x71, 0x6d, 0x6b ) );
00670         bigint_subtract_ok ( BIGINT ( 0x5b, 0x06, 0x77, 0x7b, 0xfd, 0x34,
00671                                       0x5f, 0x0f, 0xd9, 0xbd, 0x8e, 0x5d,
00672                                       0xc8, 0x4a, 0x70, 0x95, 0x1b, 0xb6,
00673                                       0x48, 0xfb, 0x0e, 0x40, 0xce, 0x06,
00674                                       0x66, 0xcc, 0x29, 0xe9, 0x51, 0x59,
00675                                       0x59, 0xc9, 0x65, 0x07, 0x75, 0xb8,
00676                                       0xd4, 0xcb, 0x07, 0x68, 0x14, 0x48,
00677                                       0xc7, 0x1e, 0xfe, 0xb3, 0x4c, 0xf1,
00678                                       0x10, 0xf0, 0xc7, 0x82, 0x38, 0x4c,
00679                                       0xaf, 0x05, 0x6d, 0x91, 0xc5, 0x18,
00680                                       0xfd, 0x1e, 0x26, 0x1b, 0xef, 0x71,
00681                                       0x70, 0x2e, 0x06, 0x70, 0x8e, 0x54,
00682                                       0xfa, 0x2b, 0x4d, 0x96, 0x85, 0x10,
00683                                       0x03, 0x76, 0xe7, 0x17, 0x59, 0x86,
00684                                       0x6c, 0x8b, 0x24, 0x6e, 0xd9, 0x30,
00685                                       0xf3, 0xd2, 0x9b, 0x62, 0xdc, 0x23,
00686                                       0x54, 0x06, 0x51, 0xb1, 0x95, 0x58,
00687                                       0xec, 0x27, 0xf6, 0x19, 0xae, 0xf4,
00688                                       0x31, 0xec, 0x72, 0x53, 0xcd, 0x32,
00689                                       0xed, 0xf4, 0x25, 0x4a, 0x5b, 0x36,
00690                                       0xa2, 0xb4, 0xa0, 0x29, 0x0c, 0x6b,
00691                                       0x3f, 0xc2 ),
00692                              BIGINT ( 0x7a, 0xd4, 0x25, 0xf1, 0xb5, 0xf5,
00693                                       0x00, 0x96, 0x47, 0x5b, 0x4f, 0x9f,
00694                                       0x1f, 0x61, 0x69, 0xd9, 0x72, 0x47,
00695                                       0xde, 0xbd, 0x87, 0x5d, 0x50, 0x91,
00696                                       0x69, 0xd8, 0x35, 0xe0, 0x43, 0xd8,
00697                                       0xd5, 0x15, 0xf2, 0xcd, 0x01, 0x73,
00698                                       0x0d, 0x34, 0xf0, 0x34, 0x46, 0x76,
00699                                       0xc0, 0x55, 0x7b, 0x27, 0xf5, 0x7b,
00700                                       0x55, 0xe9, 0xd0, 0x29, 0x0b, 0x4b,
00701                                       0x9f, 0x07, 0xbf, 0x2c, 0x3f, 0xef,
00702                                       0x36, 0x34, 0xde, 0x29, 0x1d, 0x5d,
00703                                       0x84, 0x5a, 0x5d, 0xc1, 0x02, 0x4d,
00704                                       0x56, 0xf1, 0x47, 0x39, 0x37, 0xc9,
00705                                       0xb5, 0x5f, 0x73, 0xec, 0x7c, 0x3d,
00706                                       0xbd, 0xc0, 0xfd, 0x38, 0x6c, 0x91,
00707                                       0x88, 0x4a, 0x0f, 0xee, 0xa1, 0x80,
00708                                       0xf5, 0x6a, 0x7c, 0x8c, 0x02, 0xc3,
00709                                       0x5a, 0xb2, 0x15, 0xa6, 0x2f, 0x6b,
00710                                       0x5b, 0x78, 0xb5, 0xf3, 0xbd, 0xd0,
00711                                       0xc8, 0xbc, 0xb1, 0xbb, 0xe1, 0xce,
00712                                       0x22, 0x80, 0x34, 0x5a, 0x2a, 0x27,
00713                                       0x83, 0xdc ),
00714                              BIGINT ( 0x1f, 0xcd, 0xae, 0x75, 0xb8, 0xc0,
00715                                       0xa1, 0x86, 0x6d, 0x9d, 0xc1, 0x41,
00716                                       0x57, 0x16, 0xf9, 0x44, 0x56, 0x91,
00717                                       0x95, 0xc2, 0x79, 0x1c, 0x82, 0x8b,
00718                                       0x03, 0x0c, 0x0b, 0xf6, 0xf2, 0x7f,
00719                                       0x7b, 0x4c, 0x8d, 0xc5, 0x8b, 0xba,
00720                                       0x38, 0x69, 0xe8, 0xcc, 0x32, 0x2d,
00721                                       0xf9, 0x36, 0x7c, 0x74, 0xa8, 0x8a,
00722                                       0x44, 0xf9, 0x08, 0xa6, 0xd2, 0xfe,
00723                                       0xf0, 0x02, 0x51, 0x9a, 0x7a, 0xd6,
00724                                       0x39, 0x16, 0xb8, 0x0d, 0x2d, 0xec,
00725                                       0x14, 0x2c, 0x57, 0x50, 0x73, 0xf8,
00726                                       0x5c, 0xc5, 0xf9, 0xa2, 0xb2, 0xb9,
00727                                       0xb1, 0xe8, 0x8c, 0xd5, 0x22, 0xb7,
00728                                       0x51, 0x35, 0xd8, 0xc9, 0x93, 0x60,
00729                                       0x94, 0x77, 0x74, 0x8b, 0xc5, 0x5d,
00730                                       0xa1, 0x64, 0x2a, 0xda, 0x6d, 0x6a,
00731                                       0x6e, 0x8a, 0x1f, 0x8c, 0x80, 0x77,
00732                                       0x29, 0x8c, 0x43, 0x9f, 0xf0, 0x9d,
00733                                       0xda, 0xc8, 0x8c, 0x71, 0x86, 0x97,
00734                                       0x7f, 0xcb, 0x94, 0x31, 0x1d, 0xbc,
00735                                       0x44, 0x1a ) );
00736         bigint_rol_ok ( BIGINT ( 0xe0 ),
00737                         BIGINT ( 0xc0 ) );
00738         bigint_rol_ok ( BIGINT ( 0x43, 0x1d ),
00739                         BIGINT ( 0x86, 0x3a ) );
00740         bigint_rol_ok ( BIGINT ( 0xac, 0xed, 0x9b ),
00741                         BIGINT ( 0x59, 0xdb, 0x36 ) );
00742         bigint_rol_ok ( BIGINT ( 0x2c, 0xe8, 0x3a, 0x22 ),
00743                         BIGINT ( 0x59, 0xd0, 0x74, 0x44 ) );
00744         bigint_rol_ok ( BIGINT ( 0x4e, 0x88, 0x4a, 0x05, 0x5e, 0x10, 0xee,
00745                                  0x5b, 0xc6, 0x40, 0x0e, 0x03, 0xd7, 0x0d,
00746                                  0x28, 0xa5, 0x55, 0xb2, 0x50, 0xef, 0x69,
00747                                  0xd1, 0x1d ),
00748                         BIGINT ( 0x9d, 0x10, 0x94, 0x0a, 0xbc, 0x21, 0xdc,
00749                                  0xb7, 0x8c, 0x80, 0x1c, 0x07, 0xae, 0x1a,
00750                                  0x51, 0x4a, 0xab, 0x64, 0xa1, 0xde, 0xd3,
00751                                  0xa2, 0x3a ) );
00752         bigint_rol_ok ( BIGINT ( 0x07, 0x62, 0x78, 0x70, 0x2e, 0xd4, 0x41,
00753                                  0xaa, 0x9b, 0x50, 0xb1, 0x9a, 0x71, 0xf5,
00754                                  0x1c, 0x2f, 0xe7, 0x0d, 0xf1, 0x46, 0x57,
00755                                  0x04, 0x99, 0x78, 0x4e, 0x84, 0x78, 0xba,
00756                                  0x57, 0xea, 0xa5, 0x43, 0xf7, 0x02, 0xf0,
00757                                  0x7a, 0x22, 0x60, 0x65, 0x42, 0xf2, 0x33,
00758                                  0x7d, 0xe3, 0xa8, 0x1b, 0xc4, 0x14, 0xdb,
00759                                  0xee, 0x4a, 0xf1, 0xe1, 0x52, 0xd4, 0xda,
00760                                  0x23, 0xed, 0x13, 0x5d, 0xea, 0xcf, 0xf6,
00761                                  0x5e, 0x39, 0x84, 0xe2, 0xb3, 0xa2, 0x05,
00762                                  0xba, 0xd9, 0x49, 0x8e, 0x75, 0x1d, 0xdb,
00763                                  0xe6, 0xb1, 0x6e, 0xda, 0x0a, 0x83, 0xd0,
00764                                  0x6e, 0xcf, 0x7a, 0x66, 0xb7, 0x64, 0x84,
00765                                  0xf5, 0x09, 0x5a, 0xa8, 0x11, 0x93, 0xf3,
00766                                  0x4f, 0x02, 0x28, 0x00, 0x3a, 0xf0, 0xa9,
00767                                  0x08, 0x77, 0x04, 0xf5, 0x04, 0xcd, 0x6b,
00768                                  0x24, 0xbe, 0x0f, 0x6d, 0xe3, 0xb2, 0xd3,
00769                                  0x07, 0x68, 0xe9, 0x00, 0x59, 0xa0, 0xe4,
00770                                  0x9e, 0x5e ),
00771                         BIGINT ( 0x0e, 0xc4, 0xf0, 0xe0, 0x5d, 0xa8, 0x83,
00772                                  0x55, 0x36, 0xa1, 0x63, 0x34, 0xe3, 0xea,
00773                                  0x38, 0x5f, 0xce, 0x1b, 0xe2, 0x8c, 0xae,
00774                                  0x09, 0x32, 0xf0, 0x9d, 0x08, 0xf1, 0x74,
00775                                  0xaf, 0xd5, 0x4a, 0x87, 0xee, 0x05, 0xe0,
00776                                  0xf4, 0x44, 0xc0, 0xca, 0x85, 0xe4, 0x66,
00777                                  0xfb, 0xc7, 0x50, 0x37, 0x88, 0x29, 0xb7,
00778                                  0xdc, 0x95, 0xe3, 0xc2, 0xa5, 0xa9, 0xb4,
00779                                  0x47, 0xda, 0x26, 0xbb, 0xd5, 0x9f, 0xec,
00780                                  0xbc, 0x73, 0x09, 0xc5, 0x67, 0x44, 0x0b,
00781                                  0x75, 0xb2, 0x93, 0x1c, 0xea, 0x3b, 0xb7,
00782                                  0xcd, 0x62, 0xdd, 0xb4, 0x15, 0x07, 0xa0,
00783                                  0xdd, 0x9e, 0xf4, 0xcd, 0x6e, 0xc9, 0x09,
00784                                  0xea, 0x12, 0xb5, 0x50, 0x23, 0x27, 0xe6,
00785                                  0x9e, 0x04, 0x50, 0x00, 0x75, 0xe1, 0x52,
00786                                  0x10, 0xee, 0x09, 0xea, 0x09, 0x9a, 0xd6,
00787                                  0x49, 0x7c, 0x1e, 0xdb, 0xc7, 0x65, 0xa6,
00788                                  0x0e, 0xd1, 0xd2, 0x00, 0xb3, 0x41, 0xc9,
00789                                  0x3c, 0xbc ) );
00790         bigint_ror_ok ( BIGINT ( 0x8f ),
00791                         BIGINT ( 0x47 ) );
00792         bigint_ror_ok ( BIGINT ( 0xaa, 0x1d ),
00793                         BIGINT ( 0x55, 0x0e ) );
00794         bigint_ror_ok ( BIGINT ( 0xf0, 0xbd, 0x68 ),
00795                         BIGINT ( 0x78, 0x5e, 0xb4 ) );
00796         bigint_ror_ok ( BIGINT ( 0x33, 0xa0, 0x3d, 0x95 ),
00797                         BIGINT ( 0x19, 0xd0, 0x1e, 0xca ) );
00798         bigint_ror_ok ( BIGINT ( 0xa1, 0xf4, 0xb9, 0x64, 0x91, 0x99, 0xa1,
00799                                  0xf4, 0xae, 0xeb, 0x71, 0x97, 0x1b, 0x71,
00800                                  0x09, 0x38, 0x3f, 0x8f, 0xc5, 0x3a, 0xb9,
00801                                  0x75, 0x94 ),
00802                         BIGINT ( 0x50, 0xfa, 0x5c, 0xb2, 0x48, 0xcc, 0xd0,
00803                                  0xfa, 0x57, 0x75, 0xb8, 0xcb, 0x8d, 0xb8,
00804                                  0x84, 0x9c, 0x1f, 0xc7, 0xe2, 0x9d, 0x5c,
00805                                  0xba, 0xca ) );
00806         bigint_ror_ok ( BIGINT ( 0xc0, 0xb3, 0x78, 0x46, 0x69, 0x6e, 0x35,
00807                                  0x94, 0xed, 0x28, 0xdc, 0xfd, 0xf6, 0xdb,
00808                                  0x2d, 0x24, 0xcb, 0xa4, 0x6f, 0x0e, 0x58,
00809                                  0x89, 0x04, 0xec, 0xc8, 0x0c, 0x2d, 0xb3,
00810                                  0x58, 0xa7, 0x22, 0x6d, 0x93, 0xe0, 0xb8,
00811                                  0x48, 0x6a, 0x3f, 0x04, 0x7e, 0xbe, 0xb8,
00812                                  0xa7, 0x84, 0xf5, 0xc9, 0x2f, 0x60, 0x9e,
00813                                  0x7c, 0xbc, 0xaf, 0x28, 0x89, 0x2f, 0xaa,
00814                                  0xd1, 0x82, 0x77, 0xa4, 0xdf, 0xf3, 0x4a,
00815                                  0xc6, 0xed, 0xa3, 0x07, 0xb4, 0xa9, 0xfd,
00816                                  0xef, 0xf8, 0x20, 0xb9, 0xb3, 0xff, 0x35,
00817                                  0x27, 0xed, 0x02, 0xea, 0xec, 0x63, 0xc0,
00818                                  0x46, 0x97, 0xc0, 0x4c, 0xca, 0x89, 0xca,
00819                                  0x14, 0xe8, 0xe0, 0x02, 0x14, 0x44, 0x46,
00820                                  0xf3, 0x2f, 0xbc, 0x6a, 0x28, 0xa2, 0xbe,
00821                                  0x20, 0xc8, 0xaa, 0x0f, 0xd9, 0x51, 0x8e,
00822                                  0x8d, 0x51, 0x29, 0x61, 0xef, 0x48, 0xae,
00823                                  0x3e, 0xe5, 0x10, 0xbf, 0xda, 0x9b, 0x92,
00824                                  0xb3, 0x77 ),
00825                         BIGINT ( 0x60, 0x59, 0xbc, 0x23, 0x34, 0xb7, 0x1a,
00826                                  0xca, 0x76, 0x94, 0x6e, 0x7e, 0xfb, 0x6d,
00827                                  0x96, 0x92, 0x65, 0xd2, 0x37, 0x87, 0x2c,
00828                                  0x44, 0x82, 0x76, 0x64, 0x06, 0x16, 0xd9,
00829                                  0xac, 0x53, 0x91, 0x36, 0xc9, 0xf0, 0x5c,
00830                                  0x24, 0x35, 0x1f, 0x82, 0x3f, 0x5f, 0x5c,
00831                                  0x53, 0xc2, 0x7a, 0xe4, 0x97, 0xb0, 0x4f,
00832                                  0x3e, 0x5e, 0x57, 0x94, 0x44, 0x97, 0xd5,
00833                                  0x68, 0xc1, 0x3b, 0xd2, 0x6f, 0xf9, 0xa5,
00834                                  0x63, 0x76, 0xd1, 0x83, 0xda, 0x54, 0xfe,
00835                                  0xf7, 0xfc, 0x10, 0x5c, 0xd9, 0xff, 0x9a,
00836                                  0x93, 0xf6, 0x81, 0x75, 0x76, 0x31, 0xe0,
00837                                  0x23, 0x4b, 0xe0, 0x26, 0x65, 0x44, 0xe5,
00838                                  0x0a, 0x74, 0x70, 0x01, 0x0a, 0x22, 0x23,
00839                                  0x79, 0x97, 0xde, 0x35, 0x14, 0x51, 0x5f,
00840                                  0x10, 0x64, 0x55, 0x07, 0xec, 0xa8, 0xc7,
00841                                  0x46, 0xa8, 0x94, 0xb0, 0xf7, 0xa4, 0x57,
00842                                  0x1f, 0x72, 0x88, 0x5f, 0xed, 0x4d, 0xc9,
00843                                  0x59, 0xbb ) );
00844         bigint_is_zero_ok ( BIGINT ( 0x9b ),
00845                             0 );
00846         bigint_is_zero_ok ( BIGINT ( 0x5a, 0x9d ),
00847                             0 );
00848         bigint_is_zero_ok ( BIGINT ( 0x5f, 0x80, 0x78 ),
00849                             0 );
00850         bigint_is_zero_ok ( BIGINT ( 0xa0, 0x52, 0x47, 0x2e ),
00851                             0 );
00852         bigint_is_zero_ok ( BIGINT ( 0x18, 0x08, 0x49, 0xdb, 0x7b, 0x5c,
00853                                      0xe7, 0x41, 0x07, 0xdf, 0xed, 0xf9,
00854                                      0xd3, 0x92, 0x0d, 0x75, 0xa6, 0xb0,
00855                                      0x14, 0xfa, 0xdd, 0xfd, 0x82 ),
00856                             0 );
00857         bigint_is_zero_ok ( BIGINT ( 0x04, 0x04, 0xb5, 0xf5, 0x01, 0xae,
00858                                      0x2b, 0x91, 0xa7, 0xc1, 0x49, 0x97,
00859                                      0x3f, 0x45, 0x53, 0x52, 0xb8, 0x52,
00860                                      0xf1, 0x62, 0xa5, 0x21, 0x18, 0xd4,
00861                                      0xb0, 0xb4, 0x8a, 0x17, 0x0e, 0xe8,
00862                                      0xeb, 0xaa, 0x28, 0xae, 0x3d, 0x8e,
00863                                      0xe3, 0x6c, 0xd0, 0x01, 0x0c, 0x54,
00864                                      0xca, 0x23, 0xbb, 0x06, 0xcd, 0x7a,
00865                                      0x61, 0x89, 0x38, 0x34, 0x6e, 0xc7,
00866                                      0xc2, 0xee, 0xb1, 0x80, 0x61, 0x0e,
00867                                      0xc6, 0x8d, 0x65, 0xa0, 0xeb, 0x34,
00868                                      0xe9, 0x63, 0x09, 0x4c, 0x20, 0xac,
00869                                      0x42, 0xe3, 0x35, 0xa2, 0x3e, 0x3b,
00870                                      0x2e, 0x18, 0x70, 0x45, 0x7c, 0xab,
00871                                      0x42, 0xcc, 0xe0, 0x9e, 0x7c, 0x42,
00872                                      0xd1, 0xda, 0x6c, 0x51, 0x10, 0x1e,
00873                                      0x0e, 0x3f, 0xe5, 0xd6, 0xd8, 0x56,
00874                                      0x08, 0xb2, 0x3b, 0x15, 0xc4, 0x7c,
00875                                      0x0c, 0x7e, 0xaf, 0x7b, 0x9d, 0xd6,
00876                                      0x2b, 0xc0, 0x2f, 0xa2, 0xa3, 0xa3,
00877                                      0x77, 0x58, 0x1b, 0xe9, 0xa8, 0x9a,
00878                                      0x23, 0x7f ),
00879                             0 );
00880         bigint_is_zero_ok ( BIGINT ( 0x00 ),
00881                             1 );
00882         bigint_is_zero_ok ( BIGINT ( 0x00, 0x00 ),
00883                             1 );
00884         bigint_is_zero_ok ( BIGINT ( 0x00, 0x00, 0x00 ),
00885                             1 );
00886         bigint_is_zero_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00 ),
00887                             1 );
00888         bigint_is_zero_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00889                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00890                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00891                                      0x00, 0x00, 0x00, 0x00, 0x00 ),
00892                             1 );
00893         bigint_is_zero_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00894                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00895                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00896                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00897                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00898                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00899                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00900                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00901                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00902                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00903                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00904                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00905                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00906                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00907                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00908                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00909                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00910                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00911                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00912                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00913                                      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00914                                      0x00, 0x00 ),
00915                             1 );
00916         bigint_is_zero_ok ( BIGINT ( 0xff ),
00917                             0 );
00918         bigint_is_zero_ok ( BIGINT ( 0xff, 0xff ),
00919                             0 );
00920         bigint_is_zero_ok ( BIGINT ( 0xff, 0xff, 0xff ),
00921                             0 );
00922         bigint_is_zero_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff ),
00923                             0 );
00924         bigint_is_zero_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00925                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00926                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00927                                      0xff, 0xff, 0xff, 0xff, 0xff ),
00928                             0 );
00929         bigint_is_zero_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00930                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00931                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00932                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00933                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00934                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00935                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00936                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00937                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00938                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00939                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00940                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00941                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00942                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00943                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00944                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00945                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00946                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00947                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00948                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00949                                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
00950                                      0xff, 0xff ),
00951                             0 );
00952         bigint_is_geq_ok ( BIGINT ( 0xa2 ),
00953                            BIGINT ( 0x58 ),
00954                            1 );
00955         bigint_is_geq_ok ( BIGINT ( 0x58 ),
00956                            BIGINT ( 0xa2 ),
00957                            0 );
00958         bigint_is_geq_ok ( BIGINT ( 0xa2 ),
00959                            BIGINT ( 0xa2 ),
00960                            1 );
00961         bigint_is_geq_ok ( BIGINT ( 0x61, 0x29 ),
00962                            BIGINT ( 0x87, 0xac ),
00963                            0 );
00964         bigint_is_geq_ok ( BIGINT ( 0x87, 0xac ),
00965                            BIGINT ( 0x61, 0x29 ),
00966                            1 );
00967         bigint_is_geq_ok ( BIGINT ( 0x61, 0x29 ),
00968                            BIGINT ( 0x61, 0x29 ),
00969                            1 );
00970         bigint_is_geq_ok ( BIGINT ( 0xe6, 0x63, 0x14 ),
00971                            BIGINT ( 0xb7, 0x2b, 0x76 ),
00972                            1 );
00973         bigint_is_geq_ok ( BIGINT ( 0xb7, 0x2b, 0x76 ),
00974                            BIGINT ( 0xe6, 0x63, 0x14 ),
00975                            0 );
00976         bigint_is_geq_ok ( BIGINT ( 0xe6, 0x63, 0x14 ),
00977                            BIGINT ( 0xe6, 0x63, 0x14 ),
00978                            1 );
00979         bigint_is_geq_ok ( BIGINT ( 0xe7, 0x4f, 0xd4, 0x80 ),
00980                            BIGINT ( 0xb5, 0xf9, 0x9b, 0x90 ),
00981                            1 );
00982         bigint_is_geq_ok ( BIGINT ( 0xb5, 0xf9, 0x9b, 0x90 ),
00983                            BIGINT ( 0xe7, 0x4f, 0xd4, 0x80 ),
00984                            0 );
00985         bigint_is_geq_ok ( BIGINT ( 0xe7, 0x4f, 0xd4, 0x80 ),
00986                            BIGINT ( 0xe7, 0x4f, 0xd4, 0x80 ),
00987                            1 );
00988         bigint_is_geq_ok ( BIGINT ( 0xe6, 0x2c, 0x7c, 0x24, 0x78, 0x8f, 0x12,
00989                                     0x20, 0xde, 0xd3, 0x6b, 0xc9, 0x97, 0x2d,
00990                                     0x66, 0x74, 0xe5, 0xb6, 0xf7, 0x8f, 0x2b,
00991                                     0x60, 0x98 ),
00992                            BIGINT ( 0x77, 0xbc, 0x3b, 0x1b, 0x57, 0x43, 0x3b,
00993                                     0x8c, 0x82, 0xda, 0xb5, 0xc7, 0x18, 0x09,
00994                                     0xb3, 0x59, 0x0e, 0x53, 0x2a, 0xb9, 0xd8,
00995                                     0xa2, 0xb4 ),
00996                            1 );
00997         bigint_is_geq_ok ( BIGINT ( 0x77, 0xbc, 0x3b, 0x1b, 0x57, 0x43, 0x3b,
00998                                     0x8c, 0x82, 0xda, 0xb5, 0xc7, 0x18, 0x09,
00999                                     0xb3, 0x59, 0x0e, 0x53, 0x2a, 0xb9, 0xd8,
01000                                     0xa2, 0xb4 ),
01001                            BIGINT ( 0xe6, 0x2c, 0x7c, 0x24, 0x78, 0x8f, 0x12,
01002                                     0x20, 0xde, 0xd3, 0x6b, 0xc9, 0x97, 0x2d,
01003                                     0x66, 0x74, 0xe5, 0xb6, 0xf7, 0x8f, 0x2b,
01004                                     0x60, 0x98 ),
01005                            0 );
01006         bigint_is_geq_ok ( BIGINT ( 0xe6, 0x2c, 0x7c, 0x24, 0x78, 0x8f, 0x12,
01007                                     0x20, 0xde, 0xd3, 0x6b, 0xc9, 0x97, 0x2d,
01008                                     0x66, 0x74, 0xe5, 0xb6, 0xf7, 0x8f, 0x2b,
01009                                     0x60, 0x98 ),
01010                            BIGINT ( 0xe6, 0x2c, 0x7c, 0x24, 0x78, 0x8f, 0x12,
01011                                     0x20, 0xde, 0xd3, 0x6b, 0xc9, 0x97, 0x2d,
01012                                     0x66, 0x74, 0xe5, 0xb6, 0xf7, 0x8f, 0x2b,
01013                                     0x60, 0x98 ),
01014                            1 );
01015         bigint_is_geq_ok ( BIGINT ( 0x2a, 0x98, 0xfd, 0x87, 0x5d, 0x9f, 0xb4,
01016                                     0x8b, 0x5c, 0xcd, 0x5f, 0xcd, 0x53, 0xb3,
01017                                     0xd1, 0x81, 0x6a, 0x9c, 0x93, 0x66, 0x40,
01018                                     0xa7, 0x64, 0xe0, 0x8c, 0xec, 0x96, 0x63,
01019                                     0x4d, 0x29, 0xfa, 0xb1, 0x5d, 0x93, 0x2f,
01020                                     0xf9, 0x36, 0xea, 0x3b, 0xc1, 0xaf, 0x85,
01021                                     0xcb, 0xde, 0x2d, 0xc8, 0x48, 0x33, 0xce,
01022                                     0x7b, 0xa4, 0xa4, 0xda, 0x0f, 0xaa, 0x1b,
01023                                     0xcb, 0xed, 0xbe, 0x3a, 0xa5, 0xbb, 0x73,
01024                                     0x28, 0x04, 0xc6, 0x2a, 0xfb, 0x3a, 0xc3,
01025                                     0xae, 0x42, 0x1f, 0x53, 0x6c, 0xb2, 0x76,
01026                                     0xb7, 0xe2, 0x88, 0xcb, 0x88, 0xcf, 0xf0,
01027                                     0x52, 0x81, 0xd3, 0xb2, 0x1f, 0x56, 0xe1,
01028                                     0xe1, 0x47, 0x93, 0x6f, 0x2b, 0x49, 0xaa,
01029                                     0x50, 0x99, 0x7a, 0xc4, 0x56, 0xb7, 0x13,
01030                                     0x80, 0xf4, 0x73, 0x88, 0xc7, 0x39, 0x83,
01031                                     0x67, 0xc7, 0xcc, 0xb2, 0x28, 0x7a, 0xd3,
01032                                     0xdc, 0x48, 0xea, 0x62, 0x0d, 0xf5, 0x5a,
01033                                     0x27, 0x96 ),
01034                            BIGINT ( 0xd4, 0x6b, 0x0a, 0x2e, 0x9f, 0xde, 0x4b,
01035                                     0x64, 0xfa, 0x6b, 0x37, 0x73, 0x66, 0x06,
01036                                     0xee, 0x04, 0xef, 0xe6, 0x3c, 0x7d, 0x57,
01037                                     0x22, 0x7f, 0x1f, 0x62, 0x1c, 0x7e, 0x20,
01038                                     0xda, 0x97, 0xd0, 0x27, 0x23, 0xf6, 0x77,
01039                                     0x5b, 0x49, 0x97, 0xe1, 0x65, 0x91, 0x13,
01040                                     0x93, 0xd6, 0x12, 0xc3, 0x66, 0x91, 0x76,
01041                                     0xe8, 0x47, 0x4c, 0x6a, 0x1b, 0xa2, 0x02,
01042                                     0xf8, 0x94, 0xaa, 0xe0, 0x1b, 0x0b, 0x17,
01043                                     0x86, 0x5e, 0xf5, 0x17, 0x23, 0xf5, 0x17,
01044                                     0x91, 0x6b, 0xd7, 0x2f, 0x5a, 0xfe, 0x8a,
01045                                     0x63, 0x28, 0x31, 0x1e, 0x09, 0x60, 0x29,
01046                                     0x5d, 0x55, 0xd8, 0x79, 0xeb, 0x78, 0x36,
01047                                     0x44, 0x69, 0xa4, 0x76, 0xa5, 0x35, 0x30,
01048                                     0xca, 0xc9, 0xf9, 0x62, 0xd7, 0x82, 0x13,
01049                                     0x56, 0xd0, 0x58, 0xfe, 0x16, 0x4b, 0xfb,
01050                                     0xa8, 0x4c, 0xb3, 0xd7, 0xcf, 0x5f, 0x93,
01051                                     0x9d, 0xc4, 0x11, 0xb4, 0xdd, 0xf8, 0x8f,
01052                                     0xe1, 0x11 ),
01053                            0 );
01054         bigint_is_geq_ok ( BIGINT ( 0xd4, 0x6b, 0x0a, 0x2e, 0x9f, 0xde, 0x4b,
01055                                     0x64, 0xfa, 0x6b, 0x37, 0x73, 0x66, 0x06,
01056                                     0xee, 0x04, 0xef, 0xe6, 0x3c, 0x7d, 0x57,
01057                                     0x22, 0x7f, 0x1f, 0x62, 0x1c, 0x7e, 0x20,
01058                                     0xda, 0x97, 0xd0, 0x27, 0x23, 0xf6, 0x77,
01059                                     0x5b, 0x49, 0x97, 0xe1, 0x65, 0x91, 0x13,
01060                                     0x93, 0xd6, 0x12, 0xc3, 0x66, 0x91, 0x76,
01061                                     0xe8, 0x47, 0x4c, 0x6a, 0x1b, 0xa2, 0x02,
01062                                     0xf8, 0x94, 0xaa, 0xe0, 0x1b, 0x0b, 0x17,
01063                                     0x86, 0x5e, 0xf5, 0x17, 0x23, 0xf5, 0x17,
01064                                     0x91, 0x6b, 0xd7, 0x2f, 0x5a, 0xfe, 0x8a,
01065                                     0x63, 0x28, 0x31, 0x1e, 0x09, 0x60, 0x29,
01066                                     0x5d, 0x55, 0xd8, 0x79, 0xeb, 0x78, 0x36,
01067                                     0x44, 0x69, 0xa4, 0x76, 0xa5, 0x35, 0x30,
01068                                     0xca, 0xc9, 0xf9, 0x62, 0xd7, 0x82, 0x13,
01069                                     0x56, 0xd0, 0x58, 0xfe, 0x16, 0x4b, 0xfb,
01070                                     0xa8, 0x4c, 0xb3, 0xd7, 0xcf, 0x5f, 0x93,
01071                                     0x9d, 0xc4, 0x11, 0xb4, 0xdd, 0xf8, 0x8f,
01072                                     0xe1, 0x11 ),
01073                            BIGINT ( 0x2a, 0x98, 0xfd, 0x87, 0x5d, 0x9f, 0xb4,
01074                                     0x8b, 0x5c, 0xcd, 0x5f, 0xcd, 0x53, 0xb3,
01075                                     0xd1, 0x81, 0x6a, 0x9c, 0x93, 0x66, 0x40,
01076                                     0xa7, 0x64, 0xe0, 0x8c, 0xec, 0x96, 0x63,
01077                                     0x4d, 0x29, 0xfa, 0xb1, 0x5d, 0x93, 0x2f,
01078                                     0xf9, 0x36, 0xea, 0x3b, 0xc1, 0xaf, 0x85,
01079                                     0xcb, 0xde, 0x2d, 0xc8, 0x48, 0x33, 0xce,
01080                                     0x7b, 0xa4, 0xa4, 0xda, 0x0f, 0xaa, 0x1b,
01081                                     0xcb, 0xed, 0xbe, 0x3a, 0xa5, 0xbb, 0x73,
01082                                     0x28, 0x04, 0xc6, 0x2a, 0xfb, 0x3a, 0xc3,
01083                                     0xae, 0x42, 0x1f, 0x53, 0x6c, 0xb2, 0x76,
01084                                     0xb7, 0xe2, 0x88, 0xcb, 0x88, 0xcf, 0xf0,
01085                                     0x52, 0x81, 0xd3, 0xb2, 0x1f, 0x56, 0xe1,
01086                                     0xe1, 0x47, 0x93, 0x6f, 0x2b, 0x49, 0xaa,
01087                                     0x50, 0x99, 0x7a, 0xc4, 0x56, 0xb7, 0x13,
01088                                     0x80, 0xf4, 0x73, 0x88, 0xc7, 0x39, 0x83,
01089                                     0x67, 0xc7, 0xcc, 0xb2, 0x28, 0x7a, 0xd3,
01090                                     0xdc, 0x48, 0xea, 0x62, 0x0d, 0xf5, 0x5a,
01091                                     0x27, 0x96 ),
01092                            1 );
01093         bigint_is_geq_ok ( BIGINT ( 0x2a, 0x98, 0xfd, 0x87, 0x5d, 0x9f, 0xb4,
01094                                     0x8b, 0x5c, 0xcd, 0x5f, 0xcd, 0x53, 0xb3,
01095                                     0xd1, 0x81, 0x6a, 0x9c, 0x93, 0x66, 0x40,
01096                                     0xa7, 0x64, 0xe0, 0x8c, 0xec, 0x96, 0x63,
01097                                     0x4d, 0x29, 0xfa, 0xb1, 0x5d, 0x93, 0x2f,
01098                                     0xf9, 0x36, 0xea, 0x3b, 0xc1, 0xaf, 0x85,
01099                                     0xcb, 0xde, 0x2d, 0xc8, 0x48, 0x33, 0xce,
01100                                     0x7b, 0xa4, 0xa4, 0xda, 0x0f, 0xaa, 0x1b,
01101                                     0xcb, 0xed, 0xbe, 0x3a, 0xa5, 0xbb, 0x73,
01102                                     0x28, 0x04, 0xc6, 0x2a, 0xfb, 0x3a, 0xc3,
01103                                     0xae, 0x42, 0x1f, 0x53, 0x6c, 0xb2, 0x76,
01104                                     0xb7, 0xe2, 0x88, 0xcb, 0x88, 0xcf, 0xf0,
01105                                     0x52, 0x81, 0xd3, 0xb2, 0x1f, 0x56, 0xe1,
01106                                     0xe1, 0x47, 0x93, 0x6f, 0x2b, 0x49, 0xaa,
01107                                     0x50, 0x99, 0x7a, 0xc4, 0x56, 0xb7, 0x13,
01108                                     0x80, 0xf4, 0x73, 0x88, 0xc7, 0x39, 0x83,
01109                                     0x67, 0xc7, 0xcc, 0xb2, 0x28, 0x7a, 0xd3,
01110                                     0xdc, 0x48, 0xea, 0x62, 0x0d, 0xf5, 0x5a,
01111                                     0x27, 0x96 ),
01112                            BIGINT ( 0x2a, 0x98, 0xfd, 0x87, 0x5d, 0x9f, 0xb4,
01113                                     0x8b, 0x5c, 0xcd, 0x5f, 0xcd, 0x53, 0xb3,
01114                                     0xd1, 0x81, 0x6a, 0x9c, 0x93, 0x66, 0x40,
01115                                     0xa7, 0x64, 0xe0, 0x8c, 0xec, 0x96, 0x63,
01116                                     0x4d, 0x29, 0xfa, 0xb1, 0x5d, 0x93, 0x2f,
01117                                     0xf9, 0x36, 0xea, 0x3b, 0xc1, 0xaf, 0x85,
01118                                     0xcb, 0xde, 0x2d, 0xc8, 0x48, 0x33, 0xce,
01119                                     0x7b, 0xa4, 0xa4, 0xda, 0x0f, 0xaa, 0x1b,
01120                                     0xcb, 0xed, 0xbe, 0x3a, 0xa5, 0xbb, 0x73,
01121                                     0x28, 0x04, 0xc6, 0x2a, 0xfb, 0x3a, 0xc3,
01122                                     0xae, 0x42, 0x1f, 0x53, 0x6c, 0xb2, 0x76,
01123                                     0xb7, 0xe2, 0x88, 0xcb, 0x88, 0xcf, 0xf0,
01124                                     0x52, 0x81, 0xd3, 0xb2, 0x1f, 0x56, 0xe1,
01125                                     0xe1, 0x47, 0x93, 0x6f, 0x2b, 0x49, 0xaa,
01126                                     0x50, 0x99, 0x7a, 0xc4, 0x56, 0xb7, 0x13,
01127                                     0x80, 0xf4, 0x73, 0x88, 0xc7, 0x39, 0x83,
01128                                     0x67, 0xc7, 0xcc, 0xb2, 0x28, 0x7a, 0xd3,
01129                                     0xdc, 0x48, 0xea, 0x62, 0x0d, 0xf5, 0x5a,
01130                                     0x27, 0x96 ),
01131                            1 );
01132         bigint_bit_is_set_ok ( BIGINT ( 0x37 ),
01133                                0, 1 );
01134         bigint_bit_is_set_ok ( BIGINT ( 0xe6, 0xcb ),
01135                                0, 1 );
01136         bigint_bit_is_set_ok ( BIGINT ( 0xd9, 0x0c, 0x5b ),
01137                                0, 1 );
01138         bigint_bit_is_set_ok ( BIGINT ( 0x8b, 0x56, 0x89, 0xaf ),
01139                                0, 1 );
01140         bigint_bit_is_set_ok ( BIGINT ( 0x25, 0xfc, 0xaf, 0xeb, 0x81, 0xc3,
01141                                         0xb8, 0x2f, 0xbb, 0xe3, 0x07, 0xb2,
01142                                         0xe2, 0x2a, 0xe2, 0x2d, 0xb4, 0x4d,
01143                                         0x6d, 0xec, 0x51, 0xa0, 0x2f ),
01144                                0, 1 );
01145         bigint_bit_is_set_ok ( BIGINT ( 0x25, 0xfc, 0xaf, 0xeb, 0x81, 0xc3,
01146                                         0xb8, 0x2f, 0xbb, 0xe3, 0x07, 0xb2,
01147                                         0xe2, 0x2a, 0xe2, 0x2d, 0xb4, 0x4d,
01148                                         0x6d, 0xec, 0x51, 0xa0, 0x2f ),
01149                                45, 0 );
01150         bigint_bit_is_set_ok ( BIGINT ( 0x88, 0x04, 0xec, 0xe6, 0xfb, 0x31,
01151                                         0x87, 0x43, 0xb2, 0x04, 0x9e, 0x09,
01152                                         0xba, 0x3e, 0x6d, 0x64, 0x1a, 0x85,
01153                                         0xb6, 0x46, 0x7d, 0x71, 0x3c, 0x06,
01154                                         0xd6, 0x40, 0x52, 0x39, 0x95, 0xa1,
01155                                         0x06, 0xff, 0x6a, 0x5c, 0xa3, 0x6d,
01156                                         0x4a, 0xc9, 0x77, 0x87, 0x75, 0x25,
01157                                         0x57, 0x65, 0x72, 0x73, 0x64, 0x7e,
01158                                         0xe9, 0x16, 0x17, 0xf3, 0x65, 0x3f,
01159                                         0xd5, 0xcc, 0xd7, 0xa2, 0xee, 0xe7,
01160                                         0x8d, 0x48, 0xd5, 0x7e, 0xdd, 0x59,
01161                                         0x4b, 0xf0, 0x96, 0x8b, 0x21, 0x65,
01162                                         0x04, 0x66, 0xc5, 0xff, 0x3e, 0x60,
01163                                         0xba, 0x28, 0x38, 0x7d, 0x9c, 0x09,
01164                                         0xd1, 0x8e, 0xac, 0x73, 0x8e, 0xf2,
01165                                         0x1e, 0xdf, 0x83, 0x6e, 0x54, 0xd5,
01166                                         0x34, 0xc1, 0xc6, 0xf9, 0x62, 0x2a,
01167                                         0x7d, 0xec, 0x47, 0xf2, 0xfc, 0xa2,
01168                                         0x10, 0x0a, 0x67, 0x1b, 0xc6, 0x11,
01169                                         0x9d, 0x68, 0x25, 0x8b, 0xb5, 0x9b,
01170                                         0x83, 0xf8, 0xa2, 0x11, 0xf5, 0xd4,
01171                                         0xcb, 0xe0 ),
01172                                0, 0 );
01173         bigint_bit_is_set_ok ( BIGINT ( 0x88, 0x04, 0xec, 0xe6, 0xfb, 0x31,
01174                                         0x87, 0x43, 0xb2, 0x04, 0x9e, 0x09,
01175                                         0xba, 0x3e, 0x6d, 0x64, 0x1a, 0x85,
01176                                         0xb6, 0x46, 0x7d, 0x71, 0x3c, 0x06,
01177                                         0xd6, 0x40, 0x52, 0x39, 0x95, 0xa1,
01178                                         0x06, 0xff, 0x6a, 0x5c, 0xa3, 0x6d,
01179                                         0x4a, 0xc9, 0x77, 0x87, 0x75, 0x25,
01180                                         0x57, 0x65, 0x72, 0x73, 0x64, 0x7e,
01181                                         0xe9, 0x16, 0x17, 0xf3, 0x65, 0x3f,
01182                                         0xd5, 0xcc, 0xd7, 0xa2, 0xee, 0xe7,
01183                                         0x8d, 0x48, 0xd5, 0x7e, 0xdd, 0x59,
01184                                         0x4b, 0xf0, 0x96, 0x8b, 0x21, 0x65,
01185                                         0x04, 0x66, 0xc5, 0xff, 0x3e, 0x60,
01186                                         0xba, 0x28, 0x38, 0x7d, 0x9c, 0x09,
01187                                         0xd1, 0x8e, 0xac, 0x73, 0x8e, 0xf2,
01188                                         0x1e, 0xdf, 0x83, 0x6e, 0x54, 0xd5,
01189                                         0x34, 0xc1, 0xc6, 0xf9, 0x62, 0x2a,
01190                                         0x7d, 0xec, 0x47, 0xf2, 0xfc, 0xa2,
01191                                         0x10, 0x0a, 0x67, 0x1b, 0xc6, 0x11,
01192                                         0x9d, 0x68, 0x25, 0x8b, 0xb5, 0x9b,
01193                                         0x83, 0xf8, 0xa2, 0x11, 0xf5, 0xd4,
01194                                         0xcb, 0xe0 ),
01195                                45, 1 );
01196         bigint_bit_is_set_ok ( BIGINT ( 0x88, 0x04, 0xec, 0xe6, 0xfb, 0x31,
01197                                         0x87, 0x43, 0xb2, 0x04, 0x9e, 0x09,
01198                                         0xba, 0x3e, 0x6d, 0x64, 0x1a, 0x85,
01199                                         0xb6, 0x46, 0x7d, 0x71, 0x3c, 0x06,
01200                                         0xd6, 0x40, 0x52, 0x39, 0x95, 0xa1,
01201                                         0x06, 0xff, 0x6a, 0x5c, 0xa3, 0x6d,
01202                                         0x4a, 0xc9, 0x77, 0x87, 0x75, 0x25,
01203                                         0x57, 0x65, 0x72, 0x73, 0x64, 0x7e,
01204                                         0xe9, 0x16, 0x17, 0xf3, 0x65, 0x3f,
01205                                         0xd5, 0xcc, 0xd7, 0xa2, 0xee, 0xe7,
01206                                         0x8d, 0x48, 0xd5, 0x7e, 0xdd, 0x59,
01207                                         0x4b, 0xf0, 0x96, 0x8b, 0x21, 0x65,
01208                                         0x04, 0x66, 0xc5, 0xff, 0x3e, 0x60,
01209                                         0xba, 0x28, 0x38, 0x7d, 0x9c, 0x09,
01210                                         0xd1, 0x8e, 0xac, 0x73, 0x8e, 0xf2,
01211                                         0x1e, 0xdf, 0x83, 0x6e, 0x54, 0xd5,
01212                                         0x34, 0xc1, 0xc6, 0xf9, 0x62, 0x2a,
01213                                         0x7d, 0xec, 0x47, 0xf2, 0xfc, 0xa2,
01214                                         0x10, 0x0a, 0x67, 0x1b, 0xc6, 0x11,
01215                                         0x9d, 0x68, 0x25, 0x8b, 0xb5, 0x9b,
01216                                         0x83, 0xf8, 0xa2, 0x11, 0xf5, 0xd4,
01217                                         0xcb, 0xe0 ),
01218                                1013, 0 );
01219         bigint_max_set_bit_ok ( BIGINT ( 0x3a ),
01220                                 6 );
01221         bigint_max_set_bit_ok ( BIGINT ( 0x03 ),
01222                                 2 );
01223         bigint_max_set_bit_ok ( BIGINT ( 0x00 ),
01224                                 0 );
01225         bigint_max_set_bit_ok ( BIGINT ( 0xff ),
01226                                 8 );
01227         bigint_max_set_bit_ok ( BIGINT ( 0x20, 0x30 ),
01228                                 14 );
01229         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x10 ),
01230                                 5 );
01231         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00 ),
01232                                 0 );
01233         bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff ),
01234                                 16 );
01235         bigint_max_set_bit_ok ( BIGINT ( 0x06, 0xdb, 0x7a ),
01236                                 19 );
01237         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00 ),
01238                                 0 );
01239         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00 ),
01240                                 0 );
01241         bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff, 0xff ),
01242                                 24 );
01243         bigint_max_set_bit_ok ( BIGINT ( 0xee, 0xcb, 0x7b, 0xfd ),
01244                                 32 );
01245         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x01, 0xdd ),
01246                                 9 );
01247         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00 ),
01248                                 0 );
01249         bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff ),
01250                                 32 );
01251         bigint_max_set_bit_ok ( BIGINT ( 0x32, 0x39, 0x96, 0x52, 0x10, 0x67,
01252                                          0x7e, 0x32, 0xfc, 0x4e, 0x56, 0xc3,
01253                                          0x68, 0x18, 0x76, 0x1a, 0xac, 0x0e,
01254                                          0x93, 0xee, 0x55, 0xc5, 0x6e ),
01255                                 182 );
01256         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01257                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01258                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01259                                          0x00, 0x00, 0xc8, 0xe6, 0x59 ),
01260                                 24 );
01261         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01262                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01263                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01264                                          0x00, 0x00, 0x00, 0x00, 0x00 ),
01265                                 0 );
01266         bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01267                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01268                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01269                                          0xff, 0xff, 0xff, 0xff, 0xff ),
01270                                 184 );
01271         bigint_max_set_bit_ok ( BIGINT ( 0xcd, 0xb3, 0x22, 0x30, 0xdd, 0xa7,
01272                                          0xff, 0x37, 0xbf, 0xe3, 0x38, 0xf7,
01273                                          0xe1, 0x41, 0x73, 0xea, 0x3a, 0xfc,
01274                                          0x78, 0x9e, 0xfb, 0x4f, 0x85, 0xdc,
01275                                          0x1c, 0x40, 0x89, 0x6e, 0xda, 0xf9,
01276                                          0x9d, 0x6d, 0x12, 0x97, 0xb1, 0x80,
01277                                          0x2a, 0xeb, 0x91, 0xce, 0x3b, 0x83,
01278                                          0xb8, 0xa5, 0x3d, 0xce, 0x46, 0x56,
01279                                          0xb7, 0xd1, 0x28, 0xbc, 0x93, 0x4e,
01280                                          0x8c, 0x29, 0x6d, 0x2c, 0xcc, 0x58,
01281                                          0x49, 0x2f, 0x37, 0xa0, 0x08, 0x37,
01282                                          0x86, 0xdd, 0x38, 0x21, 0xa7, 0x57,
01283                                          0x37, 0xe3, 0xc5, 0xcc, 0x50, 0x11,
01284                                          0x1a, 0xe4, 0xea, 0xe7, 0x4d, 0x3c,
01285                                          0x37, 0x65, 0x78, 0xd1, 0xf6, 0xc3,
01286                                          0x94, 0x46, 0xd4, 0x0e, 0xd3, 0x9a,
01287                                          0x21, 0x8b, 0xa6, 0x54, 0xc0, 0xd2,
01288                                          0x88, 0x07, 0x24, 0xbf, 0x7d, 0x31,
01289                                          0xfd, 0x15, 0xa8, 0x92, 0x65, 0xe1,
01290                                          0x8d, 0xed, 0x70, 0x7b, 0x68, 0x0f,
01291                                          0xcc, 0x13, 0xb9, 0xb2, 0xdd, 0x3c,
01292                                          0x6a, 0x52 ),
01293                                 1024 );
01294         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01295                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01296                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01297                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01298                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01299                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01300                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01301                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01302                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01303                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01304                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01305                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01306                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01307                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01308                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01309                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01310                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01311                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01312                                          0x00, 0x00, 0x00, 0x00, 0x66, 0xd9,
01313                                          0x91, 0x18, 0x6e, 0xd3, 0xff, 0x9b,
01314                                          0xdf, 0xf1, 0x9c, 0x7b, 0xf0, 0xa0,
01315                                          0xb9, 0xf5 ),
01316                                 127 );
01317         bigint_max_set_bit_ok ( BIGINT ( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01318                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01319                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01320                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01321                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01322                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01323                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01324                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01325                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01326                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01327                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01328                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01329                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01330                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01331                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01332                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01333                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01334                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01335                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01336                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01337                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01338                                          0x00, 0x00 ),
01339                                 0 );
01340         bigint_max_set_bit_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01341                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01342                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01343                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01344                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01345                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01346                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01347                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01348                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01349                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01350                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01351                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01352                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01353                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01354                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01355                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01356                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01357                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01358                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01359                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01360                                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01361                                          0xff, 0xff ),
01362                                 1024 );
01363         bigint_multiply_ok ( BIGINT ( 0xf0 ),
01364                              BIGINT ( 0xeb ),
01365                              BIGINT ( 0xdc, 0x50 ) );
01366         bigint_multiply_ok ( BIGINT ( 0xd7, 0x16 ),
01367                              BIGINT ( 0x88, 0xfb ),
01368                              BIGINT ( 0x73, 0x16, 0x92, 0x92 ) );
01369         bigint_multiply_ok ( BIGINT ( 0xfe, 0xed, 0x1d ),
01370                              BIGINT ( 0x69, 0x9c, 0x03 ),
01371                              BIGINT ( 0x69, 0x2a, 0x9c, 0x5f, 0x73, 0x57 ) );
01372         bigint_multiply_ok ( BIGINT ( 0x96, 0xe9, 0x6f, 0x81 ),
01373                              BIGINT ( 0x67, 0x3c, 0x5a, 0x16 ),
01374                              BIGINT ( 0x3c, 0xdb, 0x7f, 0xae, 0x12, 0x7e,
01375                                       0xef, 0x16 ) );
01376         bigint_multiply_ok ( BIGINT ( 0xe8, 0x08, 0x0b, 0xe9, 0x29, 0x36,
01377                                       0xea, 0x51, 0x1d, 0x75, 0x1a, 0xd5,
01378                                       0xba, 0xc6, 0xa0, 0xf3, 0x48, 0x5c,
01379                                       0xdf, 0x42, 0xdf, 0x28, 0x38 ),
01380                              BIGINT ( 0x22, 0x07, 0x41, 0x54, 0x4e, 0xf9,
01381                                       0x90, 0xa8, 0xaf, 0xba, 0xf6, 0xb0,
01382                                       0x35, 0x7e, 0x98, 0xef, 0x2c, 0x31,
01383                                       0xc9, 0xa7, 0x25, 0x74, 0x8d ),
01384                              BIGINT ( 0x1e, 0xd7, 0xa5, 0x03, 0xc0, 0x18,
01385                                       0x2e, 0x29, 0xb1, 0x3e, 0x96, 0x71,
01386                                       0x90, 0xa5, 0x6d, 0x43, 0x58, 0xf7,
01387                                       0x22, 0x80, 0x0b, 0x21, 0xc6, 0x70,
01388                                       0x90, 0x1c, 0xa8, 0x85, 0x87, 0xaf,
01389                                       0xd7, 0xdd, 0x27, 0x69, 0xaf, 0x20,
01390                                       0xa0, 0x2d, 0x43, 0x5d, 0xda, 0xba,
01391                                       0x4b, 0x3a, 0x86, 0xd8 ) );
01392         bigint_multiply_ok ( BIGINT ( 0xa2, 0x0f, 0xc6, 0x08, 0x0a, 0x01,
01393                                       0x19, 0x42, 0x0e, 0xaa, 0x5c, 0xae,
01394                                       0x4f, 0x4e, 0xb0, 0xad, 0xb2, 0xe8,
01395                                       0xee, 0xd5, 0x65, 0xec, 0x5a, 0xda,
01396                                       0xc0, 0xba, 0x78, 0xa8, 0x0f, 0x15,
01397                                       0x39, 0xd7, 0x7a, 0x10, 0xc2, 0xa7,
01398                                       0xec, 0x44, 0xac, 0xad, 0x39, 0x04,
01399                                       0x2e, 0x66, 0x54, 0x70, 0x57, 0xee,
01400                                       0xf6, 0x97, 0x19, 0x71, 0x16, 0xf9,
01401                                       0xbb, 0x2e, 0x84, 0x09, 0x6e, 0x9a,
01402                                       0x3b, 0x16, 0xb2, 0x65, 0x74, 0x50,
01403                                       0x19, 0xd1, 0xe9, 0x95, 0xa0, 0x7b,
01404                                       0x33, 0xb5, 0xac, 0x7c, 0x9e, 0xd4,
01405                                       0x68, 0x0d, 0xc9, 0xe4, 0x03, 0x86,
01406                                       0x1a, 0xa3, 0x42, 0x33, 0x28, 0x14,
01407                                       0x12, 0x7d, 0x5a, 0xd9, 0x30, 0x18,
01408                                       0x0a, 0xf4, 0x0c, 0x96, 0x58, 0xc9,
01409                                       0xb5, 0x37, 0xdb, 0x49, 0xdc, 0x01,
01410                                       0x4a, 0xcb, 0x6d, 0x87, 0x52, 0xf6,
01411                                       0xae, 0xa7, 0x71, 0x31, 0x9a, 0x1a,
01412                                       0xe2, 0x1c, 0x87, 0x51, 0xc9, 0xeb,
01413                                       0x70, 0x71 ),
01414                              BIGINT ( 0x7c, 0xdd, 0x2f, 0x5d, 0x27, 0xfe,
01415                                       0xca, 0x70, 0x96, 0xc3, 0xb1, 0x1f,
01416                                       0xac, 0xa9, 0x3a, 0xdc, 0xcd, 0xbc,
01417                                       0x58, 0xb4, 0xde, 0xe7, 0xe5, 0x34,
01418                                       0x1a, 0xc0, 0xb9, 0x46, 0xf7, 0x52,
01419                                       0x76, 0x23, 0xe8, 0xe9, 0x92, 0xa1,
01420                                       0x86, 0x3c, 0x6f, 0xf1, 0x22, 0xf4,
01421                                       0x72, 0xb1, 0xde, 0xd3, 0x8f, 0x11,
01422                                       0x9e, 0x52, 0xe5, 0x81, 0x54, 0xe9,
01423                                       0xa7, 0x72, 0x3f, 0x3e, 0xa0, 0x80,
01424                                       0xbb, 0xae, 0x0e, 0x30, 0x6a, 0x11,
01425                                       0x91, 0x11, 0x3b, 0x3f, 0x44, 0x1f,
01426                                       0x8d, 0x4d, 0xea, 0xdd, 0x09, 0x95,
01427                                       0x9d, 0x02, 0xa6, 0x6d, 0x3b, 0x08,
01428                                       0x40, 0x8d, 0xb4, 0x4b, 0x05, 0x74,
01429                                       0x8c, 0x1f, 0xaa, 0x61, 0x6f, 0x0e,
01430                                       0xcc, 0xcf, 0xe0, 0x81, 0x03, 0xe4,
01431                                       0x9b, 0x11, 0xd9, 0xab, 0xf3, 0x24,
01432                                       0xe2, 0x3b, 0xe0, 0x05, 0x60, 0x65,
01433                                       0x16, 0xc6, 0x2e, 0x83, 0xa0, 0x98,
01434                                       0x8e, 0x11, 0x05, 0x00, 0xe4, 0x3f,
01435                                       0x7e, 0x65 ),
01436                              BIGINT ( 0x4f, 0x0b, 0xa9, 0x85, 0xb8, 0x31,
01437                                       0x48, 0xea, 0x11, 0x44, 0xaf, 0x2d,
01438                                       0xed, 0x1a, 0x76, 0x45, 0xac, 0x87,
01439                                       0x0c, 0xf3, 0xd7, 0xc4, 0x8e, 0x5c,
01440                                       0xd7, 0xdf, 0x28, 0x74, 0xa6, 0x40,
01441                                       0xe4, 0x6b, 0x5b, 0x19, 0x36, 0x37,
01442                                       0x9c, 0xcd, 0x43, 0x76, 0x15, 0x00,
01443                                       0x5d, 0x23, 0xa2, 0x8a, 0x53, 0x25,
01444                                       0xbf, 0x18, 0xda, 0xe6, 0x09, 0xdf,
01445                                       0xaa, 0xeb, 0x9a, 0x82, 0x01, 0x14,
01446                                       0x2b, 0x20, 0x2b, 0xb6, 0x22, 0x62,
01447                                       0x6b, 0xcc, 0xd4, 0xc9, 0x02, 0x67,
01448                                       0x95, 0x43, 0x75, 0x4e, 0x97, 0x4e,
01449                                       0xec, 0x04, 0xde, 0x29, 0x0a, 0xef,
01450                                       0xf7, 0xc1, 0x72, 0x8c, 0x64, 0x38,
01451                                       0x16, 0x47, 0x9f, 0x16, 0x0c, 0xa5,
01452                                       0x79, 0x6b, 0xea, 0x2e, 0x4c, 0x3d,
01453                                       0x0c, 0xe6, 0x57, 0x51, 0x65, 0xa5,
01454                                       0x3b, 0xca, 0xae, 0x54, 0x0c, 0x67,
01455                                       0xf8, 0x23, 0x00, 0xc9, 0x8d, 0xe6,
01456                                       0x16, 0x91, 0x19, 0xb3, 0x5b, 0x68,
01457                                       0x7b, 0xf2, 0xe2, 0x5d, 0x69, 0x48,
01458                                       0x3f, 0x2b, 0xa0, 0x4f, 0x7c, 0x3c,
01459                                       0x26, 0xf9, 0xd9, 0xfd, 0x3d, 0x5d,
01460                                       0xd6, 0x05, 0x00, 0xd8, 0xdf, 0x5a,
01461                                       0x56, 0x8f, 0x16, 0x68, 0x4f, 0x15,
01462                                       0x19, 0x9d, 0xd7, 0x11, 0x51, 0x7d,
01463                                       0x73, 0x5c, 0xd4, 0xd5, 0xb4, 0xc7,
01464                                       0x42, 0xe3, 0xee, 0xf1, 0x67, 0xd6,
01465                                       0x69, 0x72, 0x04, 0x4b, 0x88, 0x3d,
01466                                       0x05, 0xd8, 0x1e, 0x50, 0xcb, 0xce,
01467                                       0x39, 0x19, 0x42, 0xb6, 0xa7, 0xf3,
01468                                       0xba, 0x78, 0x90, 0xd2, 0x09, 0x05,
01469                                       0x87, 0xf8, 0xc0, 0x9c, 0x47, 0xff,
01470                                       0xbf, 0xaa, 0x21, 0x8d, 0x81, 0x86,
01471                                       0xcd, 0x58, 0xdf, 0x30, 0xf1, 0xd1,
01472                                       0x60, 0x53, 0x85, 0x40, 0xbf, 0x14,
01473                                       0x3e, 0xdc, 0x9e, 0x9e, 0xc4, 0xc7,
01474                                       0x48, 0xa0, 0x83, 0xe0, 0x99, 0x8b,
01475                                       0x43, 0xf8, 0x52, 0x8a, 0x15, 0x88,
01476                                       0x89, 0x83, 0x7d, 0x71, 0xbb, 0x62,
01477                                       0x12, 0x7a, 0x23, 0x85, 0x3a, 0xbb,
01478                                       0xdb, 0x09, 0xfa, 0x95 ) );
01479         bigint_multiply_ok ( BIGINT ( 0xff ),
01480                              BIGINT ( 0xff ),
01481                              BIGINT ( 0xfe, 0x01 ) );
01482         bigint_multiply_ok ( BIGINT ( 0xff, 0xff ),
01483                              BIGINT ( 0xff, 0xff ),
01484                              BIGINT ( 0xff, 0xfe, 0x00, 0x01 ) );
01485         bigint_multiply_ok ( BIGINT ( 0xff, 0xff, 0xff ),
01486                              BIGINT ( 0xff, 0xff, 0xff ),
01487                              BIGINT ( 0xff, 0xff, 0xfe, 0x00, 0x00, 0x01 ) );
01488         bigint_multiply_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff ),
01489                              BIGINT ( 0xff, 0xff, 0xff, 0xff ),
01490                              BIGINT ( 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00,
01491                                       0x00, 0x01 ) );
01492         bigint_multiply_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01493                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01494                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01495                                       0xff, 0xff, 0xff, 0xff, 0xff ),
01496                              BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01497                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01498                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01499                                       0xff, 0xff, 0xff, 0xff, 0xff ),
01500                              BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01501                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01502                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01503                                       0xff, 0xff, 0xff, 0xff, 0xfe, 0x00,
01504                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01505                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01506                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01507                                       0x00, 0x00, 0x00, 0x01 ) );
01508         bigint_multiply_ok ( BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01509                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01510                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01511                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01512                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01513                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01514                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01515                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01516                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01517                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01518                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01519                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01520                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01521                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01522                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01523                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01524                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01525                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01526                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01527                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01528                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01529                                       0xff, 0xff ),
01530                              BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01531                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01532                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01533                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01534                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01535                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01536                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01537                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01538                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01539                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01540                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01541                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01542                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01543                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01544                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01545                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01546                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01547                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01548                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01549                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01550                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01551                                       0xff, 0xff ),
01552                              BIGINT ( 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01553                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01554                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01555                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01556                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01557                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01558                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01559                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01560                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01561                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01562                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01563                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01564                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01565                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01566                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01567                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01568                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01569                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01570                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01571                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01572                                       0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
01573                                       0xff, 0xfe, 0x00, 0x00, 0x00, 0x00,
01574                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01575                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01576                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01577                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01578                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01579                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01580                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01581                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01582                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01583                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01584                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01585                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01586                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01587                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01588                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01589                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01590                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01591                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01592                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01593                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
01594                                       0x00, 0x00, 0x00, 0x01 ) );
01595         bigint_mod_multiply_ok ( BIGINT ( 0x37 ),
01596                                  BIGINT ( 0x67 ),
01597                                  BIGINT ( 0x3f ),
01598                                  BIGINT ( 0x3a ) );
01599         bigint_mod_multiply_ok ( BIGINT ( 0x45, 0x94 ),
01600                                  BIGINT ( 0xbd, 0xd2 ),
01601                                  BIGINT ( 0xca, 0xc7 ),
01602                                  BIGINT ( 0xac, 0xc1 ) );
01603         bigint_mod_multiply_ok ( BIGINT ( 0x8e, 0xcd, 0x74 ),
01604                                  BIGINT ( 0xe2, 0xf1, 0xea ),
01605                                  BIGINT ( 0x59, 0x51, 0x53 ),
01606                                  BIGINT ( 0x22, 0xdd, 0x1c ) );
01607         bigint_mod_multiply_ok ( BIGINT ( 0xc2, 0xa8, 0x40, 0x6f ),
01608                                  BIGINT ( 0x29, 0xd7, 0xf4, 0x77 ),
01609                                  BIGINT ( 0xbb, 0xbd, 0xdb, 0x3d ),
01610                                  BIGINT ( 0x8f, 0x39, 0xd0, 0x47 ) );
01611         bigint_mod_multiply_ok ( BIGINT ( 0x2e, 0xcb, 0x74, 0x7c, 0x64, 0x60,
01612                                           0xb3, 0x44, 0xf3, 0x23, 0x49, 0x4a,
01613                                           0xc6, 0xb6, 0xbf, 0xea, 0x80, 0xd8,
01614                                           0x34, 0xc5, 0x54, 0x22, 0x09 ),
01615                                  BIGINT ( 0x61, 0x2c, 0x5a, 0xc5, 0xde, 0x07,
01616                                           0x65, 0x8e, 0xab, 0x88, 0x1a, 0x2e,
01617                                           0x7a, 0x95, 0x17, 0xe3, 0x3b, 0x17,
01618                                           0xe4, 0x21, 0xb0, 0xb4, 0x57 ),
01619                                  BIGINT ( 0x8e, 0x46, 0xa5, 0x87, 0x7b, 0x7f,
01620                                           0xc4, 0xd7, 0x31, 0xb1, 0x94, 0xe7,
01621                                           0xe7, 0x1c, 0x7e, 0x7a, 0xc2, 0x6c,
01622                                           0xce, 0xcb, 0xc8, 0x5d, 0x70 ),
01623                                  BIGINT ( 0x1e, 0xd1, 0x5b, 0x3d, 0x1d, 0x17,
01624                                           0x7c, 0x31, 0x95, 0x13, 0x1b, 0xd8,
01625                                           0xee, 0x0a, 0xb0, 0xe1, 0x5b, 0x13,
01626                                           0xad, 0x83, 0xe9, 0xf8, 0x7f ) );
01627         bigint_mod_multiply_ok ( BIGINT ( 0x56, 0x37, 0xab, 0x07, 0x8b, 0x25,
01628                                           0xa7, 0xc2, 0x50, 0x30, 0x43, 0xfc,
01629                                           0x63, 0x8b, 0xdf, 0x84, 0x68, 0x85,
01630                                           0xca, 0xce, 0x44, 0x5c, 0xb1, 0x14,
01631                                           0xa4, 0xb5, 0xba, 0x43, 0xe0, 0x31,
01632                                           0x45, 0x6b, 0x82, 0xa9, 0x0b, 0x9e,
01633                                           0x3a, 0xb0, 0x39, 0x09, 0x2a, 0x68,
01634                                           0x2e, 0x0f, 0x09, 0x54, 0x47, 0x04,
01635                                           0xdb, 0xcf, 0x4a, 0x3a, 0x2d, 0x7b,
01636                                           0x7d, 0x50, 0xa4, 0xc5, 0xeb, 0x13,
01637                                           0xdd, 0x49, 0x61, 0x7d, 0x18, 0xa1,
01638                                           0x0d, 0x6b, 0x58, 0xba, 0x9f, 0x7c,
01639                                           0x81, 0x34, 0x9e, 0xf9, 0x9c, 0x9e,
01640                                           0x28, 0xa8, 0x1c, 0x15, 0x16, 0x20,
01641                                           0x3c, 0x0a, 0xb1, 0x11, 0x06, 0x93,
01642                                           0xbc, 0xd8, 0x4e, 0x49, 0xae, 0x7b,
01643                                           0xb4, 0x02, 0x8b, 0x1c, 0x5b, 0x18,
01644                                           0xb4, 0xac, 0x7f, 0xdd, 0x70, 0xef,
01645                                           0x87, 0xac, 0x1b, 0xac, 0x25, 0xa3,
01646                                           0xc9, 0xa7, 0x3a, 0xc5, 0x76, 0x68,
01647                                           0x09, 0x1f, 0xa1, 0x48, 0x53, 0xb6,
01648                                           0x13, 0xac ),
01649                                  BIGINT ( 0xef, 0x5c, 0x1f, 0x1a, 0x44, 0x64,
01650                                           0x66, 0xcf, 0xdd, 0x3f, 0x0b, 0x27,
01651                                           0x81, 0xa7, 0x91, 0x7a, 0x35, 0x7b,
01652                                           0x0f, 0x46, 0x5e, 0xca, 0xbf, 0xf8,
01653                                           0x50, 0x5e, 0x99, 0x7c, 0xc6, 0x64,
01654                                           0x43, 0x00, 0x9f, 0xb2, 0xda, 0xfa,
01655                                           0x42, 0x15, 0x9c, 0xa3, 0xd6, 0xc8,
01656                                           0x64, 0xa7, 0x65, 0x4a, 0x98, 0xf7,
01657                                           0xb3, 0x96, 0x5f, 0x42, 0xf9, 0x73,
01658                                           0xe1, 0x75, 0xc3, 0xc4, 0x0b, 0x5d,
01659                                           0x5f, 0xf3, 0x04, 0x8a, 0xee, 0x59,
01660                                           0xa6, 0x1b, 0x06, 0x38, 0x0b, 0xa2,
01661                                           0x9f, 0xb4, 0x4f, 0x6d, 0x50, 0x5e,
01662                                           0x37, 0x37, 0x21, 0x83, 0x9d, 0xa3,
01663                                           0x12, 0x16, 0x4d, 0xab, 0x36, 0x51,
01664                                           0x21, 0xb1, 0x74, 0x66, 0x40, 0x9a,
01665                                           0xd3, 0x72, 0xcc, 0x18, 0x40, 0x53,
01666                                           0x89, 0xff, 0xd7, 0x00, 0x8d, 0x7e,
01667                                           0x93, 0x81, 0xdb, 0x29, 0xb6, 0xd7,
01668                                           0x23, 0x2b, 0x67, 0x2f, 0x11, 0x98,
01669                                           0x49, 0x87, 0x2f, 0x46, 0xb7, 0x33,
01670                                           0x6d, 0x12 ),
01671                                  BIGINT ( 0x67, 0x7a, 0x17, 0x6a, 0xd2, 0xf8,
01672                                           0x49, 0xfb, 0x7c, 0x95, 0x25, 0x54,
01673                                           0xf0, 0xab, 0x5b, 0xb3, 0x0e, 0x01,
01674                                           0xab, 0xd3, 0x65, 0x6f, 0x7e, 0x18,
01675                                           0x05, 0xed, 0x9b, 0xc4, 0x90, 0x6c,
01676                                           0xd0, 0x6d, 0x94, 0x79, 0x28, 0xd6,
01677                                           0x24, 0x77, 0x9a, 0x08, 0xd2, 0x2f,
01678                                           0x7c, 0x2d, 0xa0, 0x0c, 0x14, 0xbe,
01679                                           0x7b, 0xee, 0x9e, 0x48, 0x88, 0x3c,
01680                                           0x8f, 0x9f, 0xb9, 0x7a, 0xcb, 0x98,
01681                                           0x76, 0x61, 0x0d, 0xee, 0xa2, 0x42,
01682                                           0x67, 0x1b, 0x2c, 0x42, 0x8f, 0x41,
01683                                           0xcc, 0x78, 0xba, 0xba, 0xaa, 0xa2,
01684                                           0x92, 0xb0, 0x6e, 0x0c, 0x4e, 0xe1,
01685                                           0xa5, 0x13, 0x7d, 0x8a, 0x8f, 0x81,
01686                                           0x95, 0x8a, 0xdf, 0x57, 0x93, 0x88,
01687                                           0x27, 0x4f, 0x1a, 0x59, 0xa4, 0x74,
01688                                           0x22, 0xa9, 0x78, 0xe5, 0xed, 0xb1,
01689                                           0x09, 0x26, 0x59, 0xde, 0x88, 0x21,
01690                                           0x8d, 0xa2, 0xa8, 0x58, 0x10, 0x7b,
01691                                           0x65, 0x96, 0xbf, 0x69, 0x3b, 0xc5,
01692                                           0x55, 0xf8 ),
01693                                  BIGINT ( 0x15, 0xf7, 0x00, 0xeb, 0xc7, 0x5a,
01694                                           0x6f, 0xf0, 0x50, 0xf3, 0x21, 0x8a,
01695                                           0x8e, 0xa6, 0xf6, 0x67, 0x56, 0x7d,
01696                                           0x07, 0x45, 0x89, 0xdb, 0xd7, 0x7e,
01697                                           0x9e, 0x28, 0x7f, 0xfb, 0xed, 0xca,
01698                                           0x2c, 0xbf, 0x47, 0x77, 0x99, 0x95,
01699                                           0xf3, 0xd6, 0x9d, 0xc5, 0x57, 0x81,
01700                                           0x7f, 0x97, 0xf2, 0x6b, 0x24, 0xee,
01701                                           0xce, 0xc5, 0x9b, 0xe6, 0x42, 0x2d,
01702                                           0x37, 0xb7, 0xeb, 0x3d, 0xb5, 0xf7,
01703                                           0x1e, 0x86, 0xc2, 0x40, 0x44, 0xc9,
01704                                           0x85, 0x5a, 0x1a, 0xc0, 0xac, 0x9e,
01705                                           0x78, 0x69, 0x00, 0x7b, 0x93, 0x65,
01706                                           0xd7, 0x7f, 0x0c, 0xd6, 0xba, 0x4f,
01707                                           0x06, 0x00, 0x61, 0x05, 0xb2, 0x44,
01708                                           0xb4, 0xe7, 0xbb, 0x3b, 0x96, 0xb0,
01709                                           0x6d, 0xe8, 0x43, 0xd2, 0x03, 0xb7,
01710                                           0x0a, 0xc4, 0x6d, 0x30, 0xd8, 0xd5,
01711                                           0xe6, 0x54, 0x65, 0xdd, 0xa9, 0x1b,
01712                                           0x50, 0xc0, 0xb9, 0x95, 0xb0, 0x7d,
01713                                           0x7c, 0xca, 0x63, 0xf8, 0x72, 0xbe,
01714                                           0x3b, 0x00 ) );
01715         bigint_mod_exp_ok ( BIGINT ( 0xcd ),
01716                             BIGINT ( 0xbb ),
01717                             BIGINT ( 0x25 ),
01718                             BIGINT ( 0xab ) );
01719         bigint_mod_exp_ok ( BIGINT ( 0xc4 ),
01720                             BIGINT ( 0xe9 ),
01721                             BIGINT ( 0x02, 0x4c ),
01722                             BIGINT ( 0x7e ) );
01723         bigint_mod_exp_ok ( BIGINT ( 0xcb ),
01724                             BIGINT ( 0xde ),
01725                             BIGINT ( 0xbd, 0x73, 0xbf ),
01726                             BIGINT ( 0x17 ) );
01727         bigint_mod_exp_ok ( BIGINT ( 0x17 ),
01728                             BIGINT ( 0xb9 ),
01729                             BIGINT ( 0x39, 0x68, 0xba, 0x7d ),
01730                             BIGINT ( 0x17 ) );
01731         bigint_mod_exp_ok ( BIGINT ( 0x2e ),
01732                             BIGINT ( 0xb7 ),
01733                             BIGINT ( 0x39, 0x07, 0x1b, 0x49, 0x5b, 0xea,
01734                                      0xf2, 0x61, 0x75, 0x94, 0x60, 0x86,
01735                                      0x73, 0xd0, 0xeb, 0x11, 0x08, 0x19,
01736                                      0x90, 0x19, 0xe0, 0xed, 0x2a ),
01737                             BIGINT ( 0x19 ) );
01738         bigint_mod_exp_ok ( BIGINT ( 0x59 ),
01739                             BIGINT ( 0xce ),
01740                             BIGINT ( 0xdf, 0xbc, 0x0d, 0x0c, 0x09, 0xeb,
01741                                      0xf8, 0xcf, 0xdb, 0xb6, 0x00, 0xa3,
01742                                      0x9e, 0xc3, 0x6c, 0x8d, 0xf1, 0xc3,
01743                                      0x03, 0x36, 0xaa, 0xd4, 0x22, 0x7c,
01744                                      0x20, 0x7b, 0xa9, 0x9a, 0x01, 0xe4,
01745                                      0xf2, 0x50, 0x42, 0x29, 0x68, 0x7a,
01746                                      0xa6, 0x2c, 0xdf, 0xb6, 0x51, 0xa9,
01747                                      0x73, 0x10, 0x98, 0x37, 0x69, 0xb3,
01748                                      0x21, 0x49, 0x6d, 0xcc, 0x80, 0xfa,
01749                                      0x7e, 0x12, 0xe4, 0x9c, 0xc2, 0xbb,
01750                                      0xe3, 0xa3, 0x10, 0x3f, 0xba, 0x99,
01751                                      0x22, 0x79, 0x71, 0x39, 0x96, 0x7b,
01752                                      0x1a, 0x89, 0xdc, 0xda, 0x43, 0x52,
01753                                      0x50, 0x7b, 0xe3, 0x8c, 0xd3, 0xc0,
01754                                      0xf5, 0x7d, 0xfc, 0x80, 0x71, 0x6e,
01755                                      0xaf, 0x5c, 0xd0, 0x14, 0xc0, 0x60,
01756                                      0x24, 0xa8, 0x9a, 0x8a, 0x54, 0x4a,
01757                                      0x6f, 0x42, 0x7a, 0x14, 0x14, 0x25,
01758                                      0xd5, 0x22, 0x08, 0x8f, 0xd9, 0xdb,
01759                                      0xd4, 0x0f, 0x14, 0xf4, 0x3b, 0x26,
01760                                      0x0e, 0xb6, 0x72, 0xd7, 0x03, 0xd5,
01761                                      0xf0, 0x0e ),
01762                             BIGINT ( 0xa9 ) );
01763         bigint_mod_exp_ok ( BIGINT ( 0x7f, 0x30 ),
01764                             BIGINT ( 0x73, 0x74 ),
01765                             BIGINT ( 0x75 ),
01766                             BIGINT ( 0x4b, 0xe8 ) );
01767         bigint_mod_exp_ok ( BIGINT ( 0x04, 0x6c ),
01768                             BIGINT ( 0x99, 0x04 ),
01769                             BIGINT ( 0x33, 0xd2 ),
01770                             BIGINT ( 0x86, 0x74 ) );
01771         bigint_mod_exp_ok ( BIGINT ( 0xca, 0x88 ),
01772                             BIGINT ( 0xdc, 0x60 ),
01773                             BIGINT ( 0x7e, 0x76, 0x79 ),
01774                             BIGINT ( 0x42, 0x40 ) );
01775         bigint_mod_exp_ok ( BIGINT ( 0x68, 0x97 ),
01776                             BIGINT ( 0x52, 0x8b ),
01777                             BIGINT ( 0x4f, 0x7f, 0xe7, 0xda ),
01778                             BIGINT ( 0x22, 0x77 ) );
01779         bigint_mod_exp_ok ( BIGINT ( 0xbd, 0x14 ),
01780                             BIGINT ( 0x9e, 0xfc ),
01781                             BIGINT ( 0x23, 0xf7, 0xd0, 0xa1, 0x9e, 0x9b,
01782                                      0x05, 0xd2, 0x44, 0x24, 0x4f, 0x3f,
01783                                      0x83, 0xcc, 0x49, 0x70, 0xa5, 0x0d,
01784                                      0xfc, 0xa7, 0x43, 0xf3, 0x3e ),
01785                             BIGINT ( 0x1a, 0xc8 ) );
01786         bigint_mod_exp_ok ( BIGINT ( 0x46, 0x3e ),
01787                             BIGINT ( 0xb8, 0xde ),
01788                             BIGINT ( 0xa9, 0xc0, 0xdc, 0x45, 0x65, 0x0d,
01789                                      0xa5, 0x56, 0x70, 0x4c, 0xf1, 0xda,
01790                                      0xab, 0x64, 0xc2, 0x04, 0xf6, 0x32,
01791                                      0x20, 0x68, 0x31, 0x5f, 0x9a, 0x00,
01792                                      0x0f, 0x7b, 0x24, 0x33, 0xdf, 0xaf,
01793                                      0xfe, 0x03, 0x1e, 0x4a, 0xa1, 0xf8,
01794                                      0x45, 0x8d, 0x5a, 0x7d, 0x12, 0x58,
01795                                      0x00, 0x6d, 0xba, 0x79, 0x9f, 0xe1,
01796                                      0xa1, 0xfc, 0x1f, 0xb9, 0xf3, 0xa7,
01797                                      0x07, 0xf5, 0xfe, 0xd6, 0xa1, 0xba,
01798                                      0xda, 0x63, 0xef, 0x39, 0x8e, 0xb7,
01799                                      0x48, 0xa8, 0x81, 0x86, 0xb1, 0x22,
01800                                      0x14, 0x9f, 0x9e, 0xac, 0x69, 0xf7,
01801                                      0xae, 0x1f, 0xf2, 0x99, 0x41, 0xb7,
01802                                      0x37, 0xa7, 0xbc, 0x42, 0xf2, 0x45,
01803                                      0x43, 0xf2, 0x2a, 0xef, 0xc2, 0x83,
01804                                      0xd5, 0x32, 0x6e, 0xfa, 0x49, 0x1c,
01805                                      0x94, 0x9c, 0xc2, 0xc5, 0xad, 0x28,
01806                                      0x53, 0x1c, 0x11, 0xc4, 0x1c, 0x78,
01807                                      0x8f, 0x13, 0xdc, 0xb3, 0x2a, 0x63,
01808                                      0xfd, 0x1f, 0x89, 0x9b, 0x0c, 0x31,
01809                                      0x92, 0x73 ),
01810                             BIGINT ( 0x7b, 0x8a ) );
01811         bigint_mod_exp_ok ( BIGINT ( 0xf3, 0xc3, 0xab ),
01812                             BIGINT ( 0xd0, 0x7e, 0xd0 ),
01813                             BIGINT ( 0xf6 ),
01814                             BIGINT ( 0x1f, 0xb3, 0x09 ) );
01815         bigint_mod_exp_ok ( BIGINT ( 0x13, 0xec, 0xf6 ),
01816                             BIGINT ( 0x87, 0x1a, 0x9a ),
01817                             BIGINT ( 0x03, 0xf3 ),
01818                             BIGINT ( 0x15, 0xe9, 0x8e ) );
01819         bigint_mod_exp_ok ( BIGINT ( 0x5a, 0x96, 0xe5 ),
01820                             BIGINT ( 0x56, 0x4a, 0xd1 ),
01821                             BIGINT ( 0x89, 0x62, 0x8e ),
01822                             BIGINT ( 0x34, 0xb8, 0xaa ) );
01823         bigint_mod_exp_ok ( BIGINT ( 0x84, 0x7c, 0xbd ),
01824                             BIGINT ( 0x3c, 0x80, 0x0a ),
01825                             BIGINT ( 0x5e, 0x52, 0x9d, 0xba ),
01826                             BIGINT ( 0x04, 0xcb, 0x4f ) );
01827         bigint_mod_exp_ok ( BIGINT ( 0x50, 0x01, 0x51 ),
01828                             BIGINT ( 0x02, 0xe6, 0x96 ),
01829                             BIGINT ( 0x34, 0x0c, 0x7e, 0xbf, 0x27, 0x23,
01830                                      0x46, 0x92, 0x1c, 0xca, 0x91, 0xab,
01831                                      0x50, 0x2c, 0x3a, 0x64, 0xc8, 0x4a,
01832                                      0x75, 0xd6, 0xe2, 0xde, 0x31 ),
01833                             BIGINT ( 0x02, 0x16, 0x05 ) );
01834         bigint_mod_exp_ok ( BIGINT ( 0x5e, 0x47, 0xd8 ),
01835                             BIGINT ( 0x26, 0xd1, 0xb6 ),
01836                             BIGINT ( 0x49, 0x61, 0x84, 0x7a, 0xa9, 0xfb,
01837                                      0x93, 0x45, 0xe4, 0xfa, 0x53, 0x60,
01838                                      0x73, 0x98, 0x5a, 0x17, 0xe7, 0x77,
01839                                      0x2d, 0xcd, 0x97, 0xf4, 0xc0, 0x34,
01840                                      0x46, 0xfa, 0xbd, 0x21, 0xdf, 0xa5,
01841                                      0xa0, 0x12, 0x38, 0x7c, 0xbd, 0xd9,
01842                                      0xcd, 0xbc, 0xde, 0x29, 0xa5, 0x13,
01843                                      0xa8, 0xf0, 0xf6, 0x88, 0xc6, 0x31,
01844                                      0xed, 0x90, 0x19, 0x11, 0x7d, 0xe1,
01845                                      0x0e, 0x81, 0x98, 0x8e, 0x98, 0x86,
01846                                      0xde, 0x2a, 0x4c, 0xad, 0xff, 0x57,
01847                                      0x12, 0xbc, 0x4b, 0xaf, 0x21, 0xde,
01848                                      0xca, 0x3a, 0x25, 0xd7, 0x98, 0xe3,
01849                                      0x25, 0xbc, 0x17, 0x74, 0x0b, 0x9c,
01850                                      0x53, 0xe1, 0x1a, 0xec, 0x9a, 0x5a,
01851                                      0xdc, 0x68, 0xdf, 0xad, 0xd6, 0x71,
01852                                      0x6b, 0x5b, 0x8b, 0x85, 0xbb, 0xe5,
01853                                      0xd5, 0x14, 0x4c, 0x30, 0x27, 0x68,
01854                                      0xd1, 0xf7, 0x58, 0x34, 0x4c, 0xe1,
01855                                      0x71, 0xde, 0x7b, 0x8d, 0xa2, 0xe6,
01856                                      0x0a, 0x44, 0x22, 0x26, 0x5a, 0x70,
01857                                      0xbb, 0x68 ),
01858                             BIGINT ( 0x18, 0x36, 0x96 ) );
01859         bigint_mod_exp_ok ( BIGINT ( 0xc7, 0x4a, 0xf0, 0x48 ),
01860                             BIGINT ( 0x5d, 0x27, 0x07, 0x54 ),
01861                             BIGINT ( 0x4a ),
01862                             BIGINT ( 0x48, 0x68, 0x7b, 0xe0 ) );
01863         bigint_mod_exp_ok ( BIGINT ( 0xb4, 0x89, 0xc9, 0x5b ),
01864                             BIGINT ( 0x7c, 0xd7, 0xc7, 0xff ),
01865                             BIGINT ( 0xc6, 0x9c ),
01866                             BIGINT ( 0x0b, 0x2d, 0xf8, 0xf7 ) );
01867         bigint_mod_exp_ok ( BIGINT ( 0xea, 0x72, 0x43, 0xfe ),
01868                             BIGINT ( 0xfc, 0x57, 0x2d, 0x47 ),
01869                             BIGINT ( 0x60, 0x01, 0x2c ),
01870                             BIGINT ( 0x12, 0x01, 0xe3, 0xf5 ) );
01871         bigint_mod_exp_ok ( BIGINT ( 0x81, 0x7f, 0x27, 0x94 ),
01872                             BIGINT ( 0x17, 0x21, 0x67, 0xab ),
01873                             BIGINT ( 0x50, 0x19, 0x12, 0x52 ),
01874                             BIGINT ( 0x05, 0x17, 0x6b, 0x13 ) );
01875         bigint_mod_exp_ok ( BIGINT ( 0x38, 0xab, 0xd4, 0xec ),
01876                             BIGINT ( 0x0c, 0x2a, 0x56, 0x38 ),
01877                             BIGINT ( 0x2f, 0x85, 0x85, 0x57, 0xf6, 0xde,
01878                                      0x24, 0xb4, 0x28, 0x3c, 0x5a, 0x3c,
01879                                      0x0b, 0x12, 0x85, 0x85, 0x85, 0x98,
01880                                      0x46, 0x5b, 0x9c, 0x52, 0x3a ),
01881                             BIGINT ( 0x02, 0xe6, 0x6a, 0x70 ) );
01882         bigint_mod_exp_ok ( BIGINT ( 0xa6, 0x35, 0xc0, 0x6f ),
01883                             BIGINT ( 0x23, 0xac, 0x78, 0x72 ),
01884                             BIGINT ( 0x6a, 0x07, 0x80, 0xbf, 0x1b, 0xa5,
01885                                      0xf8, 0x0b, 0x90, 0x06, 0xa4, 0xa5,
01886                                      0x44, 0x13, 0xba, 0x4b, 0xb3, 0xce,
01887                                      0x9f, 0x55, 0x42, 0x56, 0xc3, 0x30,
01888                                      0x82, 0x85, 0x5a, 0x3b, 0xae, 0x88,
01889                                      0x92, 0x4e, 0x3c, 0x37, 0xf6, 0x80,
01890                                      0x4c, 0x03, 0x3c, 0x1e, 0x2c, 0x17,
01891                                      0xef, 0x9d, 0xd7, 0x6f, 0xdc, 0xbb,
01892                                      0x42, 0x42, 0xa1, 0x7f, 0x97, 0x66,
01893                                      0xcd, 0xc8, 0x8a, 0x7c, 0xc6, 0x70,
01894                                      0x61, 0x54, 0x82, 0xd0, 0xd0, 0x8b,
01895                                      0xd5, 0x4f, 0x57, 0x7b, 0x8e, 0xab,
01896                                      0xdc, 0xbf, 0x8e, 0x85, 0x94, 0x83,
01897                                      0x8a, 0xb3, 0x72, 0x69, 0x2d, 0x51,
01898                                      0xdd, 0x86, 0x1e, 0x58, 0xb8, 0x00,
01899                                      0xe2, 0x5e, 0xa7, 0xef, 0x6a, 0x6a,
01900                                      0xb0, 0x10, 0x3d, 0x53, 0xfe, 0x23,
01901                                      0x51, 0xc0, 0x51, 0xed, 0x1f, 0x02,
01902                                      0x4b, 0x73, 0x17, 0x59, 0xfa, 0xb9,
01903                                      0xa8, 0x05, 0xa7, 0x79, 0xc3, 0xc9,
01904                                      0x4c, 0x2d, 0x58, 0x59, 0x10, 0x99,
01905                                      0x71, 0xe6 ),
01906                             BIGINT ( 0x01, 0x63, 0xd0, 0x07 ) );
01907         bigint_mod_exp_ok ( BIGINT ( 0xff, 0x2a, 0x37, 0x04, 0xd4, 0x08,
01908                                      0x9f, 0xf5, 0xac, 0x29, 0x7f, 0x4b,
01909                                      0x93, 0x86, 0x02, 0x26, 0xac, 0x29,
01910                                      0xa8, 0xf9, 0x77, 0x91, 0x20 ),
01911                             BIGINT ( 0x2c, 0xb2, 0xe2, 0x1f, 0x4b, 0x97,
01912                                      0xaa, 0x3b, 0xd1, 0x36, 0xb0, 0x40,
01913                                      0x8b, 0x1c, 0x19, 0xa2, 0xea, 0xc8,
01914                                      0xc6, 0x4e, 0x2a, 0x66, 0x50 ),
01915                             BIGINT ( 0x97 ),
01916                             BIGINT ( 0x04, 0x22, 0x44, 0xe2, 0x14, 0x54,
01917                                      0x6c, 0x5a, 0xba, 0x1b, 0x39, 0xb7,
01918                                      0xaa, 0x06, 0xcf, 0x2b, 0xc8, 0x7e,
01919                                      0xc0, 0xe0, 0x70, 0xf2, 0x90 ) );
01920         bigint_mod_exp_ok ( BIGINT ( 0xcd, 0xf3, 0xf7, 0x50, 0x13, 0x39,
01921                                      0x13, 0x4a, 0x56, 0xc5, 0xb8, 0xa6,
01922                                      0x42, 0x2d, 0x40, 0x5e, 0x07, 0xf2,
01923                                      0x92, 0x2a, 0x51, 0x87, 0x20 ),
01924                             BIGINT ( 0x93, 0x1a, 0x28, 0xbb, 0x69, 0x4f,
01925                                      0x31, 0x01, 0xe0, 0x88, 0x8a, 0x4c,
01926                                      0x4f, 0x9b, 0xda, 0xf6, 0x4e, 0xf3,
01927                                      0x11, 0xe7, 0x35, 0xa1, 0xfb ),
01928                             BIGINT ( 0x66, 0x69 ),
01929                             BIGINT ( 0x7a, 0x5a, 0x9b, 0x84, 0x72, 0x8f,
01930                                      0x57, 0x31, 0xb4, 0x34, 0x70, 0x18,
01931                                      0x77, 0xa6, 0x43, 0xa9, 0x51, 0x69,
01932                                      0x07, 0x3e, 0xf6, 0x68, 0x82 ) );
01933         bigint_mod_exp_ok ( BIGINT ( 0xdd, 0x4c, 0x85, 0xcb, 0x3f, 0x45,
01934                                      0x61, 0xe0, 0x58, 0x1e, 0xad, 0xd3,
01935                                      0x6b, 0xef, 0x82, 0x53, 0x4a, 0x16,
01936                                      0x1a, 0xf0, 0x09, 0x82, 0x74 ),
01937                             BIGINT ( 0xd2, 0xa2, 0x73, 0x89, 0x0c, 0x56,
01938                                      0xe4, 0x31, 0xdf, 0x70, 0x3c, 0x40,
01939                                      0x0d, 0x36, 0xfc, 0x4a, 0xf3, 0xa2,
01940                                      0x8f, 0x9a, 0x9d, 0xaa, 0xb0 ),
01941                             BIGINT ( 0xbc, 0xca, 0x45 ),
01942                             BIGINT ( 0x9f, 0x5f, 0x7c, 0xac, 0x5e, 0xc7,
01943                                      0xf2, 0xc5, 0x72, 0x3d, 0xff, 0x29,
01944                                      0xd2, 0x25, 0xa9, 0x64, 0x5b, 0xbe,
01945                                      0x63, 0x63, 0xc6, 0x84, 0x20 ) );
01946         bigint_mod_exp_ok ( BIGINT ( 0xf8, 0xc9, 0xb9, 0x3d, 0xe1, 0xff,
01947                                      0xa6, 0x8e, 0xb0, 0xd2, 0xa9, 0xa9,
01948                                      0xc1, 0x5c, 0xc5, 0x94, 0x90, 0xb9,
01949                                      0xca, 0x2f, 0x1a, 0xbd, 0x21 ),
01950                             BIGINT ( 0xa7, 0xf4, 0xb0, 0x3c, 0xf4, 0x2b,
01951                                      0x9d, 0x40, 0x5f, 0xfd, 0x2e, 0x28,
01952                                      0xa9, 0x23, 0x01, 0xaf, 0x0b, 0x73,
01953                                      0xaa, 0xcf, 0x14, 0xdc, 0xd8 ),
01954                             BIGINT ( 0x31, 0xe2, 0xe8, 0xf0 ),
01955                             BIGINT ( 0x53, 0x30, 0xc6, 0x10, 0x12, 0x7c,
01956                                      0xb3, 0x91, 0x15, 0x5f, 0x01, 0x62,
01957                                      0xec, 0x1f, 0x15, 0x61, 0x3b, 0x9a,
01958                                      0x76, 0x22, 0xf8, 0x31, 0xb1 ) );
01959         bigint_mod_exp_ok ( BIGINT ( 0xff, 0x8c, 0x04, 0x74, 0x3e, 0x93,
01960                                      0xfd, 0xce, 0xd5, 0x7f, 0xc5, 0x58,
01961                                      0xce, 0x00, 0x53, 0x44, 0x02, 0xf4,
01962                                      0xfd, 0x01, 0xc3, 0xb0, 0x3c ),
01963                             BIGINT ( 0x2f, 0xbe, 0xb3, 0x2d, 0xd6, 0x59,
01964                                      0x69, 0x44, 0xc0, 0xd4, 0x27, 0x9c,
01965                                      0xff, 0x53, 0x9e, 0x66, 0x2c, 0x01,
01966                                      0x3a, 0x96, 0x5d, 0x75, 0xc1 ),
01967                             BIGINT ( 0x47, 0x3e, 0xb2, 0x81, 0x51, 0x9a,
01968                                      0xdf, 0x75, 0xba, 0xa5, 0x19, 0xc1,
01969                                      0xc7, 0xcc, 0xae, 0x82, 0x9c, 0x3e,
01970                                      0xfd, 0x7f, 0xb0, 0xd7, 0x00 ),
01971                             BIGINT ( 0x09, 0x9c, 0xd0, 0x49, 0x1d, 0x88,
01972                                      0xd8, 0x08, 0x45, 0x61, 0x71, 0xa1,
01973                                      0xb5, 0xab, 0xa9, 0x5b, 0xa8, 0xf1,
01974                                      0xc6, 0x53, 0x68, 0x8f, 0x3e ) );
01975         bigint_mod_exp_ok ( BIGINT ( 0xd8, 0x78, 0xad, 0x80, 0x81, 0xf1,
01976                                      0x84, 0x23, 0x82, 0x5d, 0x49, 0x46,
01977                                      0x75, 0xfd, 0xd1, 0x49, 0x53, 0x10,
01978                                      0x4d, 0x10, 0xab, 0x0f, 0xf0 ),
01979                             BIGINT ( 0x78, 0x3d, 0x09, 0x1b, 0xea, 0xa4,
01980                                      0xb9, 0x13, 0xf8, 0xb5, 0xb5, 0x5e,
01981                                      0x69, 0xa4, 0xe1, 0xfd, 0x88, 0x58,
01982                                      0x26, 0xb3, 0x76, 0xa2, 0x38 ),
01983                             BIGINT ( 0x3b, 0x12, 0xe0, 0x8e, 0xa2, 0x2f,
01984                                      0x2a, 0x2b, 0xb1, 0x78, 0xf9, 0xf6,
01985                                      0x93, 0x4d, 0x52, 0x82, 0x29, 0x2d,
01986                                      0xe4, 0x36, 0x92, 0x49, 0xc1, 0x25,
01987                                      0x6e, 0x26, 0xe6, 0x6e, 0xc2, 0x4d,
01988                                      0xea, 0x13, 0x86, 0x85, 0x71, 0x4d,
01989                                      0x85, 0x70, 0xf9, 0x2b, 0xa0, 0x0f,
01990                                      0x96, 0xe5, 0x63, 0x7a, 0xb4, 0x25,
01991                                      0x53, 0x1a, 0xd8, 0x30, 0x36, 0xba,
01992                                      0x6e, 0x2e, 0xce, 0x2d, 0x8f, 0x32,
01993                                      0xe9, 0xdc, 0x91, 0x9e, 0xd4, 0xf1,
01994                                      0x3b, 0x40, 0xc9, 0xf4, 0x97, 0x74,
01995                                      0x5e, 0x69, 0xcd, 0x34, 0x4a, 0x18,
01996                                      0x65, 0xe5, 0x07, 0xb5, 0x9e, 0x2a,
01997                                      0xc4, 0xeb, 0xb6, 0x96, 0x7b, 0x99,
01998                                      0x0c, 0xe4, 0xb3, 0x85, 0xff, 0x17,
01999                                      0x72, 0x5d, 0xf6, 0x30, 0xb4, 0xff,
02000                                      0x98, 0xe6, 0xf6, 0x31, 0x24, 0x82,
02001                                      0x91, 0xa6, 0x18, 0x6d, 0x0b, 0x84,
02002                                      0x6f, 0x5f, 0x64, 0xa3, 0xdf, 0x92,
02003                                      0x06, 0x16, 0xe3, 0x7c, 0x08, 0x61,
02004                                      0x77, 0xce ),
02005                             BIGINT ( 0x17, 0xc9, 0xc5, 0x38, 0x4c, 0x15,
02006                                      0x0f, 0x4e, 0xc2, 0x90, 0x3b, 0x46,
02007                                      0x7b, 0x2f, 0x95, 0x82, 0xfe, 0x51,
02008                                      0x95, 0x2b, 0xff, 0xd5, 0x28 ) );
02009         bigint_mod_exp_ok ( BIGINT ( 0x69, 0xa3, 0x7e, 0x24, 0xdf, 0x9e,
02010                                      0x0b, 0x3e, 0x3f, 0x43, 0x06, 0x0e,
02011                                      0x1d, 0x57, 0x74, 0xe0, 0xa0, 0x5b,
02012                                      0x82, 0xca, 0xb0, 0x33, 0x8b, 0xe4,
02013                                      0x39, 0x27, 0x41, 0xd4, 0x2e, 0x30,
02014                                      0x3a, 0x0e, 0x62, 0x6f, 0xfa, 0xb4,
02015                                      0x02, 0x88, 0x70, 0x35, 0xa6, 0xea,
02016                                      0x7d, 0xb2, 0x87, 0xc3, 0xa5, 0x50,
02017                                      0x49, 0x38, 0xa4, 0x68, 0xa9, 0xe4,
02018                                      0xa6, 0xcc, 0xd7, 0x13, 0xb1, 0xd9,
02019                                      0x1c, 0x6a, 0x9a, 0xb8, 0x6c, 0x9b,
02020                                      0xff, 0xcd, 0x2c, 0xb3, 0xbd, 0xe2,
02021                                      0xfd, 0x1f, 0x08, 0xdd, 0xc6, 0xee,
02022                                      0x18, 0x0c, 0xa5, 0xcd, 0x09, 0x19,
02023                                      0x51, 0x51, 0xa5, 0x6f, 0x93, 0x1b,
02024                                      0x34, 0xfd, 0x8f, 0xd9, 0x87, 0xed,
02025                                      0x15, 0x7e, 0x36, 0x60, 0xdd, 0x1b,
02026                                      0xf4, 0xcc, 0xc4, 0x4c, 0x19, 0x2b,
02027                                      0xd6, 0x1e, 0xec, 0x51, 0xe9, 0x27,
02028                                      0xe9, 0xbd, 0x6a, 0x3f, 0x91, 0x45,
02029                                      0xc3, 0x6d, 0x40, 0x7e, 0x6c, 0x56,
02030                                      0x05, 0x5a ),
02031                             BIGINT ( 0x5c, 0x96, 0x05, 0x81, 0x94, 0x45,
02032                                      0xcf, 0x47, 0x5f, 0x1b, 0xb0, 0xf9,
02033                                      0xef, 0x13, 0x8f, 0xcc, 0x71, 0xfd,
02034                                      0x50, 0xf1, 0xe7, 0x62, 0x6e, 0xfa,
02035                                      0x48, 0x66, 0x1c, 0xf7, 0xef, 0x09,
02036                                      0x12, 0xa2, 0xfd, 0x17, 0xb7, 0x6a,
02037                                      0x3b, 0xed, 0xf7, 0x86, 0xd2, 0xbe,
02038                                      0x95, 0x90, 0xc6, 0x00, 0x14, 0x8d,
02039                                      0xe3, 0x27, 0xbe, 0x03, 0x7c, 0x9e,
02040                                      0x6b, 0x51, 0x31, 0x8d, 0x18, 0xc4,
02041                                      0x16, 0xd2, 0x84, 0x63, 0x9b, 0xe9,
02042                                      0xa4, 0xf8, 0xff, 0x70, 0x4d, 0xeb,
02043                                      0x6f, 0x4a, 0xb7, 0x5b, 0x54, 0xf1,
02044                                      0xb5, 0xbe, 0x78, 0xb6, 0xfd, 0x8b,
02045                                      0xe1, 0x39, 0x62, 0x85, 0x9b, 0xde,
02046                                      0x30, 0xa8, 0xe4, 0x37, 0x52, 0x57,
02047                                      0x39, 0x79, 0xdb, 0x0b, 0x19, 0x6b,
02048                                      0xc9, 0x17, 0xfd, 0x8c, 0x2c, 0xaa,
02049                                      0xa4, 0xf1, 0x04, 0xd1, 0xd3, 0x2f,
02050                                      0xbb, 0x3a, 0x36, 0x82, 0x31, 0xa4,
02051                                      0x40, 0xd4, 0x87, 0x46, 0xe3, 0x6e,
02052                                      0xd0, 0x17 ),
02053                             BIGINT ( 0x93 ),
02054                             BIGINT ( 0x0d, 0x39, 0x92, 0x57, 0xaa, 0x6d,
02055                                      0xfc, 0x3b, 0x10, 0x18, 0x6d, 0x59,
02056                                      0xbe, 0x31, 0x8f, 0xee, 0xf9, 0x82,
02057                                      0x84, 0xe0, 0xdf, 0xa5, 0x00, 0x28,
02058                                      0xd1, 0x64, 0x6b, 0x4b, 0x43, 0x3b,
02059                                      0x76, 0x3e, 0x6b, 0xc4, 0xe4, 0xf5,
02060                                      0x0b, 0x59, 0x5a, 0xe4, 0x53, 0x5e,
02061                                      0x02, 0xd4, 0xde, 0x72, 0xd3, 0xa3,
02062                                      0x58, 0x66, 0xa7, 0xdd, 0x2b, 0x0b,
02063                                      0xa4, 0x83, 0xd0, 0xd9, 0xef, 0x29,
02064                                      0x3d, 0x2f, 0x97, 0xff, 0x9a, 0xc7,
02065                                      0xf6, 0x8a, 0x8d, 0x59, 0xef, 0x87,
02066                                      0xd1, 0xe6, 0xba, 0x4d, 0x99, 0xd9,
02067                                      0x5f, 0x5e, 0x7a, 0x7e, 0x67, 0x22,
02068                                      0x5b, 0x77, 0x83, 0xa2, 0x02, 0xfd,
02069                                      0xb2, 0xe4, 0xf6, 0x20, 0x4c, 0x12,
02070                                      0x20, 0xa7, 0xda, 0x5b, 0x3b, 0x8c,
02071                                      0xa2, 0xca, 0xda, 0x20, 0xaa, 0x27,
02072                                      0xe6, 0x54, 0x3e, 0xa8, 0x6f, 0x64,
02073                                      0x9d, 0xa7, 0x0d, 0x57, 0x1b, 0x21,
02074                                      0xff, 0xd2, 0xe2, 0xb2, 0x0a, 0x4f,
02075                                      0xb7, 0x0e ) );
02076         bigint_mod_exp_ok ( BIGINT ( 0x06, 0xcf, 0x54, 0xf2, 0x0d, 0x62,
02077                                      0x33, 0xdd, 0xe7, 0x4d, 0x7f, 0x2f,
02078                                      0x8e, 0x52, 0x73, 0xf4, 0x73, 0x68,
02079                                      0x4b, 0x13, 0x6e, 0x58, 0x6b, 0x4a,
02080                                      0xb8, 0x4c, 0xef, 0x73, 0xfe, 0x5f,
02081                                      0xf6, 0xd0, 0xbb, 0x82, 0x17, 0x3f,
02082                                      0x9d, 0x91, 0xf8, 0xa3, 0xb8, 0x79,
02083                                      0xef, 0x41, 0x38, 0xc1, 0xef, 0xc9,
02084                                      0xc6, 0xcf, 0x2a, 0xc3, 0xaa, 0x75,
02085                                      0x17, 0xda, 0xbc, 0x76, 0x29, 0x61,
02086                                      0x6d, 0x05, 0x79, 0x0b, 0x44, 0xb1,
02087                                      0x54, 0x75, 0xb7, 0xd9, 0xf6, 0xa8,
02088                                      0xbd, 0xf7, 0x85, 0xe0, 0xe7, 0x90,
02089                                      0x62, 0xce, 0x79, 0xfb, 0xc5, 0x23,
02090                                      0xa5, 0x09, 0xc0, 0xc4, 0x4d, 0xe7,
02091                                      0x9c, 0x49, 0x8f, 0x82, 0xf1, 0x31,
02092                                      0x34, 0x85, 0xdd, 0x3b, 0xbe, 0xe9,
02093                                      0x93, 0x19, 0x03, 0x75, 0x3f, 0xc4,
02094                                      0xa4, 0x0f, 0x52, 0x53, 0xc1, 0xcd,
02095                                      0x08, 0xb0, 0x05, 0x0c, 0xa2, 0x0c,
02096                                      0x3a, 0x72, 0xb2, 0x3c, 0xdb, 0x4f,
02097                                      0xac, 0xc6 ),
02098                             BIGINT ( 0xe4, 0x40, 0xd8, 0x30, 0x00, 0xcf,
02099                                      0x4c, 0xfd, 0xda, 0xae, 0x90, 0xd3,
02100                                      0x5b, 0xc7, 0x20, 0xcc, 0x2b, 0xe2,
02101                                      0x0a, 0x39, 0x1e, 0xde, 0xef, 0x98,
02102                                      0x16, 0x3b, 0x9d, 0x36, 0x63, 0x0d,
02103                                      0x46, 0xed, 0x23, 0x6e, 0x38, 0xa8,
02104                                      0x15, 0xb5, 0xb1, 0xaf, 0x47, 0xb1,
02105                                      0xec, 0xaa, 0x8b, 0x57, 0xd6, 0xca,
02106                                      0x39, 0x2f, 0x62, 0xbd, 0xd5, 0xf8,
02107                                      0x98, 0x98, 0x5d, 0xfe, 0x14, 0xd6,
02108                                      0xdc, 0xe5, 0x98, 0x60, 0x5b, 0x16,
02109                                      0x92, 0xcb, 0xed, 0xb6, 0x9c, 0x5c,
02110                                      0x82, 0x40, 0x6b, 0xaa, 0x48, 0x7a,
02111                                      0xd4, 0xfe, 0xa3, 0xe7, 0x30, 0xf1,
02112                                      0x7c, 0xfb, 0x94, 0x2e, 0xeb, 0xb6,
02113                                      0x71, 0xe4, 0x33, 0x63, 0xc3, 0xb0,
02114                                      0x94, 0x6d, 0xee, 0xa5, 0x15, 0x3f,
02115                                      0x28, 0xf1, 0xfa, 0xdc, 0xf2, 0x13,
02116                                      0x0f, 0xc7, 0xd9, 0xe0, 0xbf, 0x1b,
02117                                      0x49, 0xee, 0x21, 0x8e, 0x26, 0xc9,
02118                                      0x28, 0x21, 0x86, 0x1d, 0x46, 0x33,
02119                                      0xd4, 0x69 ),
02120                             BIGINT ( 0xd9, 0x87 ),
02121                             BIGINT ( 0xdf, 0xff, 0xcc, 0xb7, 0xfe, 0x19,
02122                                      0x02, 0x92, 0x9d, 0xab, 0x33, 0xd2,
02123                                      0x21, 0xbc, 0xd3, 0xc4, 0x31, 0xad,
02124                                      0x4b, 0xb3, 0x16, 0x50, 0x96, 0xd9,
02125                                      0xdc, 0x88, 0x74, 0x60, 0xde, 0xdf,
02126                                      0xb7, 0x83, 0xdb, 0x22, 0xef, 0xcb,
02127                                      0xcb, 0xdb, 0x4c, 0xfb, 0x94, 0x4c,
02128                                      0x3f, 0xf5, 0xf5, 0x99, 0x85, 0x21,
02129                                      0x1a, 0x2b, 0xec, 0x90, 0x2d, 0xb4,
02130                                      0x20, 0x3c, 0x27, 0x9f, 0xe5, 0xb1,
02131                                      0x5c, 0x92, 0xfa, 0xb0, 0xa9, 0x8e,
02132                                      0x2c, 0x21, 0x8e, 0x8d, 0xe5, 0x55,
02133                                      0x84, 0x02, 0xa5, 0x15, 0x5c, 0x53,
02134                                      0x1f, 0x40, 0x81, 0x0a, 0x10, 0xde,
02135                                      0x21, 0x41, 0xa9, 0x97, 0xf8, 0x6f,
02136                                      0xbf, 0x42, 0x58, 0x9e, 0xc6, 0xdd,
02137                                      0x10, 0x33, 0x3f, 0xad, 0xe6, 0x8e,
02138                                      0x57, 0x27, 0x37, 0x20, 0xa4, 0x86,
02139                                      0xef, 0x39, 0x7b, 0x6f, 0x78, 0x77,
02140                                      0xab, 0xa0, 0x62, 0xe1, 0xfd, 0x9c,
02141                                      0xbe, 0xfa, 0x98, 0x2e, 0x29, 0xe3,
02142                                      0xeb, 0x52 ) );
02143         bigint_mod_exp_ok ( BIGINT ( 0x00, 0x91, 0xb3, 0x87, 0xe6, 0x01,
02144                                      0x57, 0xe9, 0x68, 0xa4, 0xf4, 0x9b,
02145                                      0xea, 0x6a, 0x8a, 0x9e, 0x1a, 0x8b,
02146                                      0xd3, 0x85, 0x9d, 0xba, 0x85, 0xab,
02147                                      0xd8, 0xcd, 0x25, 0x56, 0x8e, 0x85,
02148                                      0x8a, 0x8e, 0x48, 0x9e, 0xb4, 0x90,
02149                                      0xc8, 0x2e, 0x07, 0x78, 0x80, 0x49,
02150                                      0xa0, 0xb7, 0x95, 0x6a, 0xd8, 0xad,
02151                                      0xb5, 0xda, 0x5d, 0xe6, 0x11, 0x87,
02152                                      0xb8, 0x33, 0x8f, 0xa8, 0x6f, 0x4e,
02153                                      0xc6, 0xc3, 0x0d, 0xf5, 0xa9, 0x4e,
02154                                      0xb2, 0x42, 0x53, 0x81, 0xcd, 0x33,
02155                                      0x83, 0x49, 0xab, 0x0d, 0x0e, 0xf5,
02156                                      0x2c, 0xcd, 0x84, 0x58, 0xf3, 0x30,
02157                                      0xa3, 0x6e, 0x3c, 0x3a, 0xc6, 0x77,
02158                                      0x43, 0xb0, 0xe7, 0x4b, 0x66, 0x30,
02159                                      0xe9, 0x48, 0x0b, 0x0d, 0x86, 0x3f,
02160                                      0xd8, 0xe2, 0xb5, 0x88, 0xc1, 0x44,
02161                                      0xb2, 0x6b, 0xb0, 0x7a, 0x35, 0x3b,
02162                                      0x56, 0x83, 0xb1, 0xac, 0x9e, 0xeb,
02163                                      0x9b, 0x08, 0x43, 0xac, 0x0a, 0x3a,
02164                                      0x31, 0x69 ),
02165                             BIGINT ( 0x96, 0x6f, 0xb0, 0xa7, 0x02, 0xb5,
02166                                      0xd9, 0x19, 0xbe, 0x4b, 0x27, 0x65,
02167                                      0x5b, 0x96, 0xd4, 0x0b, 0x49, 0x70,
02168                                      0xf0, 0x09, 0x8e, 0xf2, 0x04, 0x85,
02169                                      0x93, 0xe9, 0x2e, 0x09, 0x31, 0x76,
02170                                      0x8b, 0xbb, 0xe9, 0xe1, 0x2b, 0x4f,
02171                                      0xed, 0x83, 0xa6, 0x87, 0xa3, 0x07,
02172                                      0x0a, 0x3d, 0x1c, 0x65, 0x14, 0x5a,
02173                                      0xd5, 0xc0, 0x5d, 0x3c, 0x31, 0x9a,
02174                                      0x83, 0xad, 0xca, 0x6a, 0x93, 0x0d,
02175                                      0x1a, 0x67, 0x4e, 0x68, 0x06, 0x64,
02176                                      0x53, 0x2e, 0x15, 0xd9, 0xdd, 0x5e,
02177                                      0xcb, 0xb7, 0x2e, 0xef, 0xd3, 0xbb,
02178                                      0x5f, 0xaf, 0xef, 0x9e, 0xf2, 0x7b,
02179                                      0x69, 0x15, 0xb0, 0x18, 0x6c, 0x67,
02180                                      0x10, 0xda, 0x33, 0x07, 0x48, 0x97,
02181                                      0x31, 0xb3, 0x3d, 0x3d, 0xc9, 0x2e,
02182                                      0x0b, 0x68, 0x91, 0x3f, 0x6a, 0x3b,
02183                                      0x1a, 0xdf, 0xa8, 0x69, 0x46, 0x1c,
02184                                      0xb2, 0x69, 0x08, 0x0b, 0x02, 0x1b,
02185                                      0x03, 0x64, 0xae, 0xb6, 0x2d, 0xc6,
02186                                      0xc4, 0x0a ),
02187                             BIGINT ( 0x6d, 0x3f, 0xdd ),
02188                             BIGINT ( 0x40, 0x6e, 0x9d, 0x3e, 0xeb, 0xa4,
02189                                      0xb1, 0x8d, 0xb7, 0xb4, 0x0f, 0x5b,
02190                                      0x12, 0xad, 0x27, 0x9e, 0xbd, 0xe7,
02191                                      0xe5, 0x9d, 0xec, 0xb4, 0xac, 0x23,
02192                                      0x5f, 0xa9, 0xec, 0x9c, 0xd1, 0x6a,
02193                                      0xbe, 0x99, 0xba, 0xb3, 0x66, 0x0e,
02194                                      0x17, 0xaa, 0x13, 0xa2, 0x2e, 0x01,
02195                                      0x28, 0xb1, 0x6c, 0xba, 0xad, 0x68,
02196                                      0x48, 0xf0, 0xf3, 0x4c, 0x08, 0x9f,
02197                                      0xd1, 0x9c, 0xb7, 0x75, 0xc5, 0xb6,
02198                                      0x5a, 0x05, 0xb0, 0x14, 0xd4, 0x61,
02199                                      0xea, 0x18, 0x9f, 0xe6, 0xe5, 0xe3,
02200                                      0xd4, 0xff, 0x35, 0x43, 0x0b, 0xb8,
02201                                      0xf6, 0xe9, 0x19, 0x7a, 0x88, 0xa7,
02202                                      0x4d, 0x01, 0x92, 0x05, 0xd2, 0x6e,
02203                                      0xa3, 0xc1, 0xb6, 0x66, 0x75, 0xb1,
02204                                      0x00, 0x0d, 0x42, 0x37, 0xcc, 0xca,
02205                                      0xc0, 0x8d, 0xc8, 0x7e, 0x5c, 0xc9,
02206                                      0x53, 0x81, 0x2f, 0xc4, 0x61, 0xb6,
02207                                      0x96, 0x3b, 0xa5, 0x04, 0x14, 0x1b,
02208                                      0xa7, 0x77, 0xa1, 0xbc, 0x73, 0x1d,
02209                                      0xad, 0xed ) );
02210         bigint_mod_exp_ok ( BIGINT ( 0x45, 0xfb, 0xf3, 0xdc, 0x31, 0xe5,
02211                                      0x56, 0x7a, 0xee, 0x15, 0xfb, 0x16,
02212                                      0xee, 0x6e, 0x90, 0x3e, 0xa3, 0x89,
02213                                      0xc2, 0x6d, 0x9b, 0x06, 0x65, 0xd0,
02214                                      0xcd, 0xa2, 0xcc, 0x01, 0x60, 0x0d,
02215                                      0xd1, 0xdd, 0x68, 0x14, 0xc2, 0xcd,
02216                                      0xd8, 0x79, 0x75, 0xad, 0x0a, 0x9f,
02217                                      0x39, 0x5f, 0x52, 0x4b, 0x58, 0x31,
02218                                      0x48, 0xbb, 0x2a, 0xcc, 0xe0, 0x42,
02219                                      0x18, 0x32, 0xdc, 0x63, 0x14, 0x11,
02220                                      0x4e, 0xab, 0x96, 0x29, 0xc5, 0x06,
02221                                      0x79, 0xe5, 0x06, 0xf7, 0x59, 0xdb,
02222                                      0x1e, 0x51, 0xfd, 0xc4, 0x48, 0x3a,
02223                                      0x4c, 0x7f, 0xd0, 0xe2, 0x36, 0x86,
02224                                      0xc1, 0x8b, 0xc5, 0x86, 0x52, 0xe0,
02225                                      0xdb, 0x92, 0x5f, 0x0e, 0x19, 0xb1,
02226                                      0xa3, 0x23, 0xdd, 0xf0, 0x78, 0xcc,
02227                                      0x81, 0x3f, 0x4a, 0xe6, 0xb0, 0x32,
02228                                      0xd1, 0x5c, 0x5e, 0x3a, 0xb0, 0xd8,
02229                                      0xe2, 0x04, 0xc0, 0x30, 0x85, 0x1d,
02230                                      0x5e, 0x28, 0xee, 0xd9, 0xb3, 0x83,
02231                                      0x9f, 0xe2 ),
02232                             BIGINT ( 0xb3, 0x2c, 0x2e, 0xc5, 0xba, 0xf8,
02233                                      0x41, 0x98, 0x79, 0x7e, 0xaa, 0x0c,
02234                                      0x2a, 0x8f, 0xd9, 0x56, 0x55, 0xaa,
02235                                      0x74, 0x60, 0x74, 0xd1, 0x49, 0x2c,
02236                                      0x6f, 0x0a, 0x4e, 0xf8, 0x3f, 0x1b,
02237                                      0x73, 0x4c, 0xe0, 0x17, 0x37, 0x06,
02238                                      0x76, 0x73, 0xd5, 0x2d, 0x4d, 0x3f,
02239                                      0xb0, 0x15, 0x7e, 0x98, 0xd0, 0xdf,
02240                                      0xf0, 0x33, 0x78, 0xe2, 0xe6, 0xec,
02241                                      0x21, 0x22, 0xad, 0xd5, 0xab, 0x2d,
02242                                      0x0d, 0x59, 0x95, 0x05, 0x34, 0x1f,
02243                                      0x51, 0xf5, 0xec, 0x93, 0x05, 0x15,
02244                                      0x37, 0xcf, 0x93, 0x03, 0xd7, 0xf6,
02245                                      0x35, 0x23, 0x8f, 0x33, 0xf6, 0xba,
02246                                      0x42, 0xc8, 0x52, 0x94, 0xd3, 0x33,
02247                                      0x3e, 0x39, 0x01, 0xd1, 0x55, 0x3f,
02248                                      0x48, 0x84, 0xe9, 0xbc, 0x0b, 0x0f,
02249                                      0xc9, 0x69, 0x41, 0x2c, 0x5f, 0x34,
02250                                      0xd0, 0xe6, 0x15, 0x50, 0x06, 0x64,
02251                                      0x5b, 0x8b, 0x71, 0x22, 0xb3, 0x3e,
02252                                      0x09, 0x9c, 0x76, 0x13, 0x9b, 0x29,
02253                                      0x57, 0x94 ),
02254                             BIGINT ( 0xca, 0x94, 0xf7, 0xca ),
02255                             BIGINT ( 0x83, 0x68, 0xb9, 0xe7, 0x91, 0xf3,
02256                                      0x3b, 0x5a, 0x0b, 0xb6, 0x1e, 0x2f,
02257                                      0x3f, 0x5f, 0xdc, 0x96, 0x5b, 0x7f,
02258                                      0x8d, 0xc5, 0x8e, 0xda, 0x6e, 0x21,
02259                                      0xe3, 0x20, 0xea, 0x37, 0x39, 0x3b,
02260                                      0xb4, 0xd7, 0xf6, 0xba, 0x61, 0xfe,
02261                                      0xdc, 0x7e, 0x82, 0x9a, 0x38, 0x7b,
02262                                      0xd5, 0xb1, 0x11, 0x98, 0xc4, 0x88,
02263                                      0x0b, 0x01, 0x7d, 0x81, 0xc9, 0x64,
02264                                      0x23, 0xc3, 0x3e, 0xf3, 0x67, 0x95,
02265                                      0x78, 0xca, 0xda, 0x52, 0xaf, 0x72,
02266                                      0x25, 0xd9, 0xf0, 0x27, 0xd3, 0x1c,
02267                                      0xfb, 0xad, 0xa1, 0xa7, 0x06, 0x2f,
02268                                      0xaa, 0x2f, 0x86, 0x5c, 0x8b, 0x30,
02269                                      0xe1, 0xda, 0x5a, 0x36, 0xf9, 0xfd,
02270                                      0xbf, 0xfe, 0x0d, 0x03, 0xf8, 0x9c,
02271                                      0x6b, 0x9b, 0xe5, 0x70, 0x6d, 0x75,
02272                                      0xd7, 0x54, 0x28, 0x43, 0x34, 0x69,
02273                                      0x98, 0x11, 0x29, 0xee, 0x50, 0x06,
02274                                      0xa4, 0xc4, 0x11, 0x6d, 0x60, 0x8c,
02275                                      0xcd, 0xd1, 0x88, 0xe9, 0x6b, 0xbb,
02276                                      0xc1, 0xd4 ) );
02277         bigint_mod_exp_ok ( BIGINT ( 0xa1, 0x01, 0x7e, 0xb4, 0x0e, 0x66,
02278                                      0xa5, 0x07, 0x8b, 0x10, 0x84, 0x0d,
02279                                      0x30, 0x0a, 0xa4, 0x2d, 0x10, 0x2c,
02280                                      0xd4, 0x9a, 0x27, 0xf1, 0x02, 0x8c,
02281                                      0x38, 0x18, 0x7f, 0x7f, 0x95, 0x65,
02282                                      0xf1, 0xa9, 0x3b, 0x7d, 0x1f, 0x4f,
02283                                      0x88, 0xb0, 0x65, 0x62, 0x63, 0x63,
02284                                      0xaa, 0x82, 0xfc, 0x83, 0x3a, 0x3a,
02285                                      0x46, 0x59, 0x6a, 0x89, 0xec, 0xa9,
02286                                      0xb0, 0x4c, 0x5e, 0xbe, 0x46, 0x98,
02287                                      0xd0, 0xd4, 0xb7, 0xe3, 0x1b, 0x30,
02288                                      0x0b, 0xfb, 0xbb, 0x4f, 0x0b, 0xd3,
02289                                      0xe4, 0xa0, 0x80, 0x54, 0xcb, 0x52,
02290                                      0x0a, 0xe8, 0x03, 0x75, 0x8e, 0x96,
02291                                      0xa4, 0x21, 0xaa, 0xbd, 0x7a, 0xfd,
02292                                      0xfa, 0xf8, 0xaf, 0x42, 0xf6, 0x61,
02293                                      0xd2, 0x93, 0xce, 0x66, 0x67, 0xe9,
02294                                      0x02, 0xda, 0x81, 0x0b, 0xb0, 0x1e,
02295                                      0x9e, 0x27, 0x57, 0x98, 0x18, 0x88,
02296                                      0x35, 0x49, 0xc0, 0x88, 0x88, 0x59,
02297                                      0xae, 0x2f, 0x66, 0x59, 0x31, 0x87,
02298                                      0x88, 0xda ),
02299                             BIGINT ( 0xfe, 0x21, 0x7c, 0xf4, 0xbe, 0xae,
02300                                      0x65, 0xda, 0x89, 0xd2, 0x26, 0xd6,
02301                                      0x9c, 0x65, 0xc6, 0xb6, 0xb4, 0x0a,
02302                                      0x84, 0x11, 0xe1, 0xe8, 0xba, 0xd8,
02303                                      0x16, 0xcf, 0x60, 0x6c, 0x83, 0xa5,
02304                                      0x4a, 0xbf, 0xa2, 0x24, 0x0b, 0x66,
02305                                      0xda, 0xe2, 0x4e, 0x2d, 0xe5, 0x9e,
02306                                      0xbf, 0xad, 0x5c, 0xa3, 0x1e, 0x5c,
02307                                      0xbd, 0xe2, 0x5b, 0x46, 0xcf, 0xcc,
02308                                      0xd5, 0xc9, 0x13, 0x95, 0xc3, 0xdb,
02309                                      0x64, 0xbf, 0xeb, 0x31, 0xa9, 0x8a,
02310                                      0x3b, 0xd2, 0x5d, 0x3b, 0x2e, 0xdc,
02311                                      0x0c, 0xca, 0xab, 0xde, 0x92, 0xae,
02312                                      0x45, 0x35, 0x96, 0xb0, 0xb7, 0xb9,
02313                                      0xe6, 0xfe, 0x28, 0x0d, 0x10, 0x72,
02314                                      0x53, 0x8e, 0x21, 0xc0, 0x33, 0x79,
02315                                      0x01, 0x43, 0x8d, 0x77, 0xc4, 0xaa,
02316                                      0xcf, 0x7f, 0xc3, 0xd1, 0xf5, 0xfd,
02317                                      0x79, 0x81, 0xf6, 0x2e, 0xb7, 0xeb,
02318                                      0x55, 0x5f, 0x74, 0xf0, 0x3a, 0xb9,
02319                                      0x57, 0x07, 0x09, 0x97, 0xa5, 0x4c,
02320                                      0x4a, 0x85 ),
02321                             BIGINT ( 0xd9, 0xb7, 0xb2, 0xd6, 0xeb, 0xf3,
02322                                      0x66, 0xbe, 0x15, 0x64, 0xad, 0x2e,
02323                                      0x9e, 0xc6, 0xaf, 0x5e, 0xaf, 0x40,
02324                                      0x1e, 0x90, 0x82, 0x2f, 0x98 ),
02325                             BIGINT ( 0x12, 0x48, 0x31, 0x7f, 0x09, 0xbb,
02326                                      0x8f, 0xd9, 0x02, 0x7e, 0x4a, 0xd0,
02327                                      0x2f, 0x42, 0x7c, 0x17, 0x6e, 0x83,
02328                                      0x74, 0x21, 0x95, 0x47, 0x7d, 0x93,
02329                                      0x4a, 0xce, 0x34, 0x7c, 0xde, 0xc7,
02330                                      0x8f, 0xf6, 0x28, 0x97, 0xba, 0x81,
02331                                      0x9b, 0xcc, 0x54, 0x14, 0x7f, 0xd3,
02332                                      0x93, 0x66, 0x41, 0x8c, 0x0e, 0x47,
02333                                      0xee, 0xc5, 0x5e, 0xd6, 0x5f, 0x01,
02334                                      0x62, 0x97, 0xf1, 0x2b, 0xee, 0x60,
02335                                      0x5e, 0x82, 0x2c, 0x7b, 0x0a, 0xf2,
02336                                      0xc3, 0x23, 0xbf, 0xb9, 0x83, 0xf7,
02337                                      0x97, 0xf5, 0xca, 0x58, 0xd7, 0xf0,
02338                                      0x87, 0x7b, 0xcb, 0x87, 0x69, 0x42,
02339                                      0xbc, 0x05, 0xc4, 0xad, 0xbd, 0x82,
02340                                      0xcf, 0x44, 0x16, 0x4f, 0x46, 0xe0,
02341                                      0xde, 0x2f, 0xfa, 0x77, 0xec, 0xa4,
02342                                      0x23, 0x7d, 0x47, 0x3e, 0x94, 0x19,
02343                                      0x8b, 0xb8, 0x84, 0x81, 0x80, 0x6c,
02344                                      0x1e, 0x31, 0xa3, 0x6d, 0x14, 0x94,
02345                                      0x57, 0x28, 0x99, 0x08, 0x0a, 0xa7,
02346                                      0x98, 0x4b ) );
02347         bigint_mod_exp_ok ( BIGINT ( 0xda, 0x52, 0xfd, 0x44, 0x5d, 0x11,
02348                                      0x60, 0x6c, 0xec, 0x87, 0xbf, 0x19,
02349                                      0xb8, 0x46, 0xaa, 0x41, 0xfc, 0x10,
02350                                      0xae, 0x47, 0xd6, 0x72, 0x42, 0x57,
02351                                      0xc3, 0x05, 0xca, 0xe3, 0x59, 0x94,
02352                                      0x82, 0x7c, 0xa1, 0xe0, 0xd2, 0x6b,
02353                                      0x77, 0x71, 0x42, 0xa1, 0xf7, 0x84,
02354                                      0xae, 0xf4, 0x6f, 0x44, 0x0d, 0x88,
02355                                      0xa2, 0xc5, 0x45, 0x9b, 0x49, 0x36,
02356                                      0xd4, 0x20, 0x3a, 0x7c, 0x92, 0xdb,
02357                                      0x65, 0xd9, 0x20, 0xd6, 0x71, 0x22,
02358                                      0x90, 0x70, 0xbf, 0xf3, 0x17, 0xe8,
02359                                      0x2c, 0x10, 0xe9, 0x4c, 0x02, 0x69,
02360                                      0x37, 0xa2, 0x91, 0x04, 0x46, 0x11,
02361                                      0xdc, 0xab, 0x5b, 0x1e, 0x3e, 0x31,
02362                                      0xd8, 0x69, 0xf8, 0x48, 0x84, 0x1f,
02363                                      0x56, 0x46, 0xf1, 0xc0, 0x14, 0x3f,
02364                                      0xcc, 0x5d, 0xe2, 0xf7, 0x8b, 0xa4,
02365                                      0x9e, 0x94, 0x32, 0xaa, 0x3c, 0x5e,
02366                                      0x21, 0x70, 0x00, 0x24, 0x2a, 0x1b,
02367                                      0xec, 0x25, 0xb1, 0xb6, 0x83, 0x36,
02368                                      0x5a, 0x95 ),
02369                             BIGINT ( 0x5e, 0xdc, 0x71, 0x1f, 0x5b, 0x55,
02370                                      0xaa, 0xda, 0x56, 0xf5, 0x93, 0x9b,
02371                                      0xe8, 0xfc, 0x6a, 0x80, 0xe1, 0xe3,
02372                                      0x93, 0xe4, 0xc0, 0x58, 0x6f, 0x22,
02373                                      0xce, 0x9d, 0x6f, 0x84, 0x4c, 0xd4,
02374                                      0x12, 0x44, 0x57, 0x25, 0xca, 0xe5,
02375                                      0x2b, 0x7c, 0x35, 0x88, 0xc7, 0x38,
02376                                      0x25, 0x20, 0x9b, 0x57, 0xf2, 0xf2,
02377                                      0x6c, 0x28, 0x47, 0x9c, 0x3f, 0x91,
02378                                      0x1e, 0x3f, 0xe9, 0xeb, 0x50, 0xd6,
02379                                      0xa7, 0x22, 0x88, 0x6c, 0x71, 0xe5,
02380                                      0x62, 0x2a, 0xb7, 0xce, 0xbe, 0xf7,
02381                                      0x1a, 0x8c, 0x52, 0xa6, 0xff, 0xb8,
02382                                      0x34, 0x83, 0x7e, 0x04, 0xa8, 0x9c,
02383                                      0xa8, 0xa7, 0xd1, 0x05, 0x8e, 0x13,
02384                                      0x03, 0xe0, 0x49, 0xd8, 0x4a, 0xc4,
02385                                      0x4d, 0x38, 0x21, 0x5b, 0x62, 0xc2,
02386                                      0x38, 0x23, 0x7c, 0x9e, 0xf1, 0xe9,
02387                                      0xb6, 0x9a, 0x75, 0x42, 0x14, 0x99,
02388                                      0x63, 0x36, 0x13, 0x4c, 0x2d, 0x3a,
02389                                      0x77, 0xd4, 0x74, 0xb7, 0x30, 0xb2,
02390                                      0x00, 0x0f ),
02391                             BIGINT ( 0xe3, 0xe5, 0x3b, 0xb5, 0x92, 0x5a,
02392                                      0xc6, 0xfa, 0x8f, 0xe8, 0x00, 0xb9,
02393                                      0x5c, 0xa0, 0xb6, 0x3e, 0x5e, 0x14,
02394                                      0x12, 0xa9, 0xdd, 0x2a, 0x3d, 0x4d,
02395                                      0xa3, 0x91, 0x6a, 0x56, 0x99, 0xc2,
02396                                      0x6c, 0x8e, 0xda, 0xb0, 0x5a, 0x2a,
02397                                      0x37, 0x55, 0x8b, 0xd3, 0x9b, 0xb6,
02398                                      0x1d, 0x49, 0x7d, 0x81, 0x76, 0x1c,
02399                                      0x2e, 0xb9, 0x92, 0x6d, 0xfa, 0x54,
02400                                      0x53, 0xfc, 0x74, 0x9b, 0x6b, 0x63,
02401                                      0x95, 0x1a, 0x89, 0xcc, 0xbd, 0x36,
02402                                      0xc5, 0x31, 0x7f, 0xf5, 0x31, 0x69,
02403                                      0x40, 0xd5, 0x7b, 0x94, 0x5d, 0xa9,
02404                                      0xd1, 0x34, 0x95, 0xa1, 0x8b, 0xa5,
02405                                      0xb5, 0x83, 0xda, 0xb5, 0x9d, 0x5b,
02406                                      0x74, 0x41, 0xad, 0x81, 0x45, 0x40,
02407                                      0x9b, 0xc3, 0xe8, 0xfe, 0x47, 0xdc,
02408                                      0xb0, 0xc3, 0x34, 0x5d, 0xf6, 0x3c,
02409                                      0x1d, 0x07, 0x76, 0xd9, 0x25, 0xca,
02410                                      0xa2, 0x39, 0x6c, 0xa8, 0xae, 0x30,
02411                                      0x4a, 0xde, 0xfb, 0xeb, 0x19, 0x80,
02412                                      0x5e, 0x49 ),
02413                             BIGINT ( 0x4b, 0x0e, 0x74, 0xb8, 0xa7, 0x92,
02414                                      0x74, 0xd9, 0x50, 0xf6, 0x1b, 0x67,
02415                                      0x76, 0x76, 0x56, 0x6c, 0x09, 0x9c,
02416                                      0x01, 0xda, 0xaf, 0xa3, 0xca, 0xb2,
02417                                      0x12, 0x85, 0x52, 0x24, 0xe9, 0x7e,
02418                                      0x2b, 0xf2, 0x6e, 0xe9, 0x1a, 0x10,
02419                                      0x5d, 0xa0, 0x25, 0x46, 0x8f, 0x2a,
02420                                      0x95, 0x62, 0x50, 0xb6, 0x66, 0x43,
02421                                      0x37, 0x8b, 0xcb, 0x05, 0xf8, 0x61,
02422                                      0x59, 0xf9, 0xdd, 0xd2, 0x68, 0x72,
02423                                      0xfa, 0x88, 0x13, 0x36, 0xd8, 0x24,
02424                                      0x73, 0xec, 0x47, 0x44, 0xdd, 0x45,
02425                                      0x8a, 0x59, 0xd2, 0xbd, 0x43, 0xe3,
02426                                      0x05, 0x16, 0xd5, 0x9b, 0x1c, 0x8a,
02427                                      0x4b, 0x07, 0xda, 0x58, 0x0d, 0x4a,
02428                                      0x4e, 0xe7, 0x15, 0xfc, 0xbd, 0x95,
02429                                      0xf7, 0x18, 0xa5, 0xa7, 0x93, 0xff,
02430                                      0xf8, 0x1f, 0xd4, 0x6b, 0x07, 0xc6,
02431                                      0x5d, 0x90, 0x73, 0x57, 0x57, 0x37,
02432                                      0xfa, 0x83, 0xd4, 0x7c, 0xe9, 0x77,
02433                                      0x46, 0x91, 0x3a, 0x50, 0x0d, 0x6a,
02434                                      0x25, 0xd0 ) );
02435 }
02436 
02437 /** Big integer self-test */
02438 struct self_test bigint_test __self_test = {
02439         .name = "bigint",
02440         .exec = bigint_test_exec,
02441 };