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