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