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