OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [or1ksim/] [testsuite/] [test-code-or1k/] [testfloat/] [testCases.c] - Blame information for rev 808

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 234 jeremybenn
 
2
/*
3
===============================================================================
4
 
5
This C source file is part of TestFloat, Release 2a, a package of programs
6
for testing the correctness of floating-point arithmetic complying to the
7
IEC/IEEE Standard for Floating-Point.
8
 
9
Written by John R. Hauser.  More information is available through the Web
10
page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
11
 
12
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
13
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
14
TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
15
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
16
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
17
 
18
Derivative works are acceptable, even for commercial purposes, so long as
19
(1) they include prominent notice that the work is derivative, and (2) they
20
include prominent notice akin to these four paragraphs for those parts of
21
this code that are retained.
22
 
23
Modified for use with or1ksim's testsuite.
24
 
25
Contributor Julius Baxter <julius.baxter@orsoc.se>
26
 
27
===============================================================================
28
*/
29
 
30
#include "milieu.h"
31
#include "fail.h"
32
#include "random.h"
33
#include "softfloat.h"
34
#include "testCases.h"
35
 
36
typedef struct {
37
    int16 expNum, term1Num, term2Num;
38
    flag done;
39
} sequenceT;
40
 
41
enum {
42
    int32NumP1 = 124
43
};
44
 
45
static const uint32 int32P1[ int32NumP1 ] = {
46
    0x00000000,
47
    0x00000001,
48
    0x00000002,
49
    0x00000004,
50
    0x00000008,
51
    0x00000010,
52
    0x00000020,
53
    0x00000040,
54
    0x00000080,
55
    0x00000100,
56
    0x00000200,
57
    0x00000400,
58
    0x00000800,
59
    0x00001000,
60
    0x00002000,
61
    0x00004000,
62
    0x00008000,
63
    0x00010000,
64
    0x00020000,
65
    0x00040000,
66
    0x00080000,
67
    0x00100000,
68
    0x00200000,
69
    0x00400000,
70
    0x00800000,
71
    0x01000000,
72
    0x02000000,
73
    0x04000000,
74
    0x08000000,
75
    0x10000000,
76
    0x20000000,
77
    0x40000000,
78
    0x80000000,
79
    0xC0000000,
80
    0xE0000000,
81
    0xF0000000,
82
    0xF8000000,
83
    0xFC000000,
84
    0xFE000000,
85
    0xFF000000,
86
    0xFF800000,
87
    0xFFC00000,
88
    0xFFE00000,
89
    0xFFF00000,
90
    0xFFF80000,
91
    0xFFFC0000,
92
    0xFFFE0000,
93
    0xFFFF0000,
94
    0xFFFF8000,
95
    0xFFFFC000,
96
    0xFFFFE000,
97
    0xFFFFF000,
98
    0xFFFFF800,
99
    0xFFFFFC00,
100
    0xFFFFFE00,
101
    0xFFFFFF00,
102
    0xFFFFFF80,
103
    0xFFFFFFC0,
104
    0xFFFFFFE0,
105
    0xFFFFFFF0,
106
    0xFFFFFFF8,
107
    0xFFFFFFFC,
108
    0xFFFFFFFE,
109
    0xFFFFFFFF,
110
    0xFFFFFFFD,
111
    0xFFFFFFFB,
112
    0xFFFFFFF7,
113
    0xFFFFFFEF,
114
    0xFFFFFFDF,
115
    0xFFFFFFBF,
116
    0xFFFFFF7F,
117
    0xFFFFFEFF,
118
    0xFFFFFDFF,
119
    0xFFFFFBFF,
120
    0xFFFFF7FF,
121
    0xFFFFEFFF,
122
    0xFFFFDFFF,
123
    0xFFFFBFFF,
124
    0xFFFF7FFF,
125
    0xFFFEFFFF,
126
    0xFFFDFFFF,
127
    0xFFFBFFFF,
128
    0xFFF7FFFF,
129
    0xFFEFFFFF,
130
    0xFFDFFFFF,
131
    0xFFBFFFFF,
132
    0xFF7FFFFF,
133
    0xFEFFFFFF,
134
    0xFDFFFFFF,
135
    0xFBFFFFFF,
136
    0xF7FFFFFF,
137
    0xEFFFFFFF,
138
    0xDFFFFFFF,
139
    0xBFFFFFFF,
140
    0x7FFFFFFF,
141
    0x3FFFFFFF,
142
    0x1FFFFFFF,
143
    0x0FFFFFFF,
144
    0x07FFFFFF,
145
    0x03FFFFFF,
146
    0x01FFFFFF,
147
    0x00FFFFFF,
148
    0x007FFFFF,
149
    0x003FFFFF,
150
    0x001FFFFF,
151
    0x000FFFFF,
152
    0x0007FFFF,
153
    0x0003FFFF,
154
    0x0001FFFF,
155
    0x0000FFFF,
156
    0x00007FFF,
157
    0x00003FFF,
158
    0x00001FFF,
159
    0x00000FFF,
160
    0x000007FF,
161
    0x000003FF,
162
    0x000001FF,
163
    0x000000FF,
164
    0x0000007F,
165
    0x0000003F,
166
    0x0000001F,
167
    0x0000000F,
168
    0x00000007,
169
    0x00000003
170
};
171
 
172
static int32 int32NextP1( sequenceT *sequencePtr )
173
{
174
    uint8 termNum;
175
    int32 z;
176
 
177
    termNum = sequencePtr->term1Num;
178
    z = int32P1[ termNum ];
179
    ++termNum;
180
    if ( int32NumP1 <= termNum ) {
181
        termNum = 0;
182
        sequencePtr->done = TRUE;
183
    }
184
    sequencePtr->term1Num = termNum;
185
    return (sbits32) z;
186
 
187
}
188
 
189
static const int32 int32NumP2 = ( int32NumP1 * int32NumP1 + int32NumP1 ) / 2;
190
 
191
static int32 int32NextP2( sequenceT *sequencePtr )
192
{
193
    uint8 term1Num, term2Num;
194
    int32 z;
195
 
196
    term2Num = sequencePtr->term2Num;
197
    term1Num = sequencePtr->term1Num;
198
    z = int32P1[ term1Num ] + int32P1[ term2Num ];
199
    ++term2Num;
200
    if ( int32NumP1 <= term2Num ) {
201
        ++term1Num;
202
        if ( int32NumP1 <= term1Num ) {
203
            term1Num = 0;
204
            sequencePtr->done = TRUE;
205
        }
206
        term2Num = term1Num;
207
        sequencePtr->term1Num = term1Num;
208
    }
209
    sequencePtr->term2Num = term2Num;
210
    return (sbits32) z;
211
 
212
}
213
 
214
static int32 int32RandomP3( void )
215
{
216
 
217
    return
218
        (sbits32) (
219
              int32P1[ randomUint8() % int32NumP1 ]
220
            + int32P1[ randomUint8() % int32NumP1 ]
221
            + int32P1[ randomUint8() % int32NumP1 ]
222
        );
223
 
224
}
225
 
226
enum {
227
    int32NumPInfWeightMasks = 29
228
};
229
 
230
static const uint32 int32PInfWeightMasks[ int32NumPInfWeightMasks ] = {
231
    0xFFFFFFFF,
232
    0x7FFFFFFF,
233
    0x3FFFFFFF,
234
    0x1FFFFFFF,
235
    0x0FFFFFFF,
236
    0x07FFFFFF,
237
    0x03FFFFFF,
238
    0x01FFFFFF,
239
    0x00FFFFFF,
240
    0x007FFFFF,
241
    0x003FFFFF,
242
    0x001FFFFF,
243
    0x000FFFFF,
244
    0x0007FFFF,
245
    0x0003FFFF,
246
    0x0001FFFF,
247
    0x0000FFFF,
248
    0x00007FFF,
249
    0x00003FFF,
250
    0x00001FFF,
251
    0x00000FFF,
252
    0x000007FF,
253
    0x000003FF,
254
    0x000001FF,
255
    0x000000FF,
256
    0x0000007F,
257
    0x0000003F,
258
    0x0000001F,
259
    0x0000000F
260
};
261
 
262
static const uint32 int32PInfWeightOffsets[ int32NumPInfWeightMasks ] = {
263
    0x00000000,
264
    0xC0000000,
265
    0xE0000000,
266
    0xF0000000,
267
    0xF8000000,
268
    0xFC000000,
269
    0xFE000000,
270
    0xFF000000,
271
    0xFF800000,
272
    0xFFC00000,
273
    0xFFE00000,
274
    0xFFF00000,
275
    0xFFF80000,
276
    0xFFFC0000,
277
    0xFFFE0000,
278
    0xFFFF0000,
279
    0xFFFF8000,
280
    0xFFFFC000,
281
    0xFFFFE000,
282
    0xFFFFF000,
283
    0xFFFFF800,
284
    0xFFFFFC00,
285
    0xFFFFFE00,
286
    0xFFFFFF00,
287
    0xFFFFFF80,
288
    0xFFFFFFC0,
289
    0xFFFFFFE0,
290
    0xFFFFFFF0,
291
    0xFFFFFFF8
292
};
293
 
294
static int32 int32RandomPInf( void )
295
{
296
    int8 weightMaskNum;
297
 
298
    weightMaskNum = randomUint8() % int32NumPInfWeightMasks;
299
    return
300
        (sbits32) (
301
              ( randomUint32() & int32PInfWeightMasks[ weightMaskNum ] )
302
            + int32PInfWeightOffsets[ weightMaskNum ]
303
        );
304
 
305
}
306
 
307
#ifdef BITS64
308
 
309
enum {
310
    int64NumP1 = 252
311
};
312
 
313
static const uint64 int64P1[ int64NumP1 ] = {
314
    LIT64( 0x0000000000000000 ),
315
    LIT64( 0x0000000000000001 ),
316
    LIT64( 0x0000000000000002 ),
317
    LIT64( 0x0000000000000004 ),
318
    LIT64( 0x0000000000000008 ),
319
    LIT64( 0x0000000000000010 ),
320
    LIT64( 0x0000000000000020 ),
321
    LIT64( 0x0000000000000040 ),
322
    LIT64( 0x0000000000000080 ),
323
    LIT64( 0x0000000000000100 ),
324
    LIT64( 0x0000000000000200 ),
325
    LIT64( 0x0000000000000400 ),
326
    LIT64( 0x0000000000000800 ),
327
    LIT64( 0x0000000000001000 ),
328
    LIT64( 0x0000000000002000 ),
329
    LIT64( 0x0000000000004000 ),
330
    LIT64( 0x0000000000008000 ),
331
    LIT64( 0x0000000000010000 ),
332
    LIT64( 0x0000000000020000 ),
333
    LIT64( 0x0000000000040000 ),
334
    LIT64( 0x0000000000080000 ),
335
    LIT64( 0x0000000000100000 ),
336
    LIT64( 0x0000000000200000 ),
337
    LIT64( 0x0000000000400000 ),
338
    LIT64( 0x0000000000800000 ),
339
    LIT64( 0x0000000001000000 ),
340
    LIT64( 0x0000000002000000 ),
341
    LIT64( 0x0000000004000000 ),
342
    LIT64( 0x0000000008000000 ),
343
    LIT64( 0x0000000010000000 ),
344
    LIT64( 0x0000000020000000 ),
345
    LIT64( 0x0000000040000000 ),
346
    LIT64( 0x0000000080000000 ),
347
    LIT64( 0x0000000100000000 ),
348
    LIT64( 0x0000000200000000 ),
349
    LIT64( 0x0000000400000000 ),
350
    LIT64( 0x0000000800000000 ),
351
    LIT64( 0x0000001000000000 ),
352
    LIT64( 0x0000002000000000 ),
353
    LIT64( 0x0000004000000000 ),
354
    LIT64( 0x0000008000000000 ),
355
    LIT64( 0x0000010000000000 ),
356
    LIT64( 0x0000020000000000 ),
357
    LIT64( 0x0000040000000000 ),
358
    LIT64( 0x0000080000000000 ),
359
    LIT64( 0x0000100000000000 ),
360
    LIT64( 0x0000200000000000 ),
361
    LIT64( 0x0000400000000000 ),
362
    LIT64( 0x0000800000000000 ),
363
    LIT64( 0x0001000000000000 ),
364
    LIT64( 0x0002000000000000 ),
365
    LIT64( 0x0004000000000000 ),
366
    LIT64( 0x0008000000000000 ),
367
    LIT64( 0x0010000000000000 ),
368
    LIT64( 0x0020000000000000 ),
369
    LIT64( 0x0040000000000000 ),
370
    LIT64( 0x0080000000000000 ),
371
    LIT64( 0x0100000000000000 ),
372
    LIT64( 0x0200000000000000 ),
373
    LIT64( 0x0400000000000000 ),
374
    LIT64( 0x0800000000000000 ),
375
    LIT64( 0x1000000000000000 ),
376
    LIT64( 0x2000000000000000 ),
377
    LIT64( 0x4000000000000000 ),
378
    LIT64( 0x8000000000000000 ),
379
    LIT64( 0xC000000000000000 ),
380
    LIT64( 0xE000000000000000 ),
381
    LIT64( 0xF000000000000000 ),
382
    LIT64( 0xF800000000000000 ),
383
    LIT64( 0xFC00000000000000 ),
384
    LIT64( 0xFE00000000000000 ),
385
    LIT64( 0xFF00000000000000 ),
386
    LIT64( 0xFF80000000000000 ),
387
    LIT64( 0xFFC0000000000000 ),
388
    LIT64( 0xFFE0000000000000 ),
389
    LIT64( 0xFFF0000000000000 ),
390
    LIT64( 0xFFF8000000000000 ),
391
    LIT64( 0xFFFC000000000000 ),
392
    LIT64( 0xFFFE000000000000 ),
393
    LIT64( 0xFFFF000000000000 ),
394
    LIT64( 0xFFFF800000000000 ),
395
    LIT64( 0xFFFFC00000000000 ),
396
    LIT64( 0xFFFFE00000000000 ),
397
    LIT64( 0xFFFFF00000000000 ),
398
    LIT64( 0xFFFFF80000000000 ),
399
    LIT64( 0xFFFFFC0000000000 ),
400
    LIT64( 0xFFFFFE0000000000 ),
401
    LIT64( 0xFFFFFF0000000000 ),
402
    LIT64( 0xFFFFFF8000000000 ),
403
    LIT64( 0xFFFFFFC000000000 ),
404
    LIT64( 0xFFFFFFE000000000 ),
405
    LIT64( 0xFFFFFFF000000000 ),
406
    LIT64( 0xFFFFFFF800000000 ),
407
    LIT64( 0xFFFFFFFC00000000 ),
408
    LIT64( 0xFFFFFFFE00000000 ),
409
    LIT64( 0xFFFFFFFF00000000 ),
410
    LIT64( 0xFFFFFFFF80000000 ),
411
    LIT64( 0xFFFFFFFFC0000000 ),
412
    LIT64( 0xFFFFFFFFE0000000 ),
413
    LIT64( 0xFFFFFFFFF0000000 ),
414
    LIT64( 0xFFFFFFFFF8000000 ),
415
    LIT64( 0xFFFFFFFFFC000000 ),
416
    LIT64( 0xFFFFFFFFFE000000 ),
417
    LIT64( 0xFFFFFFFFFF000000 ),
418
    LIT64( 0xFFFFFFFFFF800000 ),
419
    LIT64( 0xFFFFFFFFFFC00000 ),
420
    LIT64( 0xFFFFFFFFFFE00000 ),
421
    LIT64( 0xFFFFFFFFFFF00000 ),
422
    LIT64( 0xFFFFFFFFFFF80000 ),
423
    LIT64( 0xFFFFFFFFFFFC0000 ),
424
    LIT64( 0xFFFFFFFFFFFE0000 ),
425
    LIT64( 0xFFFFFFFFFFFF0000 ),
426
    LIT64( 0xFFFFFFFFFFFF8000 ),
427
    LIT64( 0xFFFFFFFFFFFFC000 ),
428
    LIT64( 0xFFFFFFFFFFFFE000 ),
429
    LIT64( 0xFFFFFFFFFFFFF000 ),
430
    LIT64( 0xFFFFFFFFFFFFF800 ),
431
    LIT64( 0xFFFFFFFFFFFFFC00 ),
432
    LIT64( 0xFFFFFFFFFFFFFE00 ),
433
    LIT64( 0xFFFFFFFFFFFFFF00 ),
434
    LIT64( 0xFFFFFFFFFFFFFF80 ),
435
    LIT64( 0xFFFFFFFFFFFFFFC0 ),
436
    LIT64( 0xFFFFFFFFFFFFFFE0 ),
437
    LIT64( 0xFFFFFFFFFFFFFFF0 ),
438
    LIT64( 0xFFFFFFFFFFFFFFF8 ),
439
    LIT64( 0xFFFFFFFFFFFFFFFC ),
440
    LIT64( 0xFFFFFFFFFFFFFFFE ),
441
    LIT64( 0xFFFFFFFFFFFFFFFF ),
442
    LIT64( 0xFFFFFFFFFFFFFFFD ),
443
    LIT64( 0xFFFFFFFFFFFFFFFB ),
444
    LIT64( 0xFFFFFFFFFFFFFFF7 ),
445
    LIT64( 0xFFFFFFFFFFFFFFEF ),
446
    LIT64( 0xFFFFFFFFFFFFFFDF ),
447
    LIT64( 0xFFFFFFFFFFFFFFBF ),
448
    LIT64( 0xFFFFFFFFFFFFFF7F ),
449
    LIT64( 0xFFFFFFFFFFFFFEFF ),
450
    LIT64( 0xFFFFFFFFFFFFFDFF ),
451
    LIT64( 0xFFFFFFFFFFFFFBFF ),
452
    LIT64( 0xFFFFFFFFFFFFF7FF ),
453
    LIT64( 0xFFFFFFFFFFFFEFFF ),
454
    LIT64( 0xFFFFFFFFFFFFDFFF ),
455
    LIT64( 0xFFFFFFFFFFFFBFFF ),
456
    LIT64( 0xFFFFFFFFFFFF7FFF ),
457
    LIT64( 0xFFFFFFFFFFFEFFFF ),
458
    LIT64( 0xFFFFFFFFFFFDFFFF ),
459
    LIT64( 0xFFFFFFFFFFFBFFFF ),
460
    LIT64( 0xFFFFFFFFFFF7FFFF ),
461
    LIT64( 0xFFFFFFFFFFEFFFFF ),
462
    LIT64( 0xFFFFFFFFFFDFFFFF ),
463
    LIT64( 0xFFFFFFFFFFBFFFFF ),
464
    LIT64( 0xFFFFFFFFFF7FFFFF ),
465
    LIT64( 0xFFFFFFFFFEFFFFFF ),
466
    LIT64( 0xFFFFFFFFFDFFFFFF ),
467
    LIT64( 0xFFFFFFFFFBFFFFFF ),
468
    LIT64( 0xFFFFFFFFF7FFFFFF ),
469
    LIT64( 0xFFFFFFFFEFFFFFFF ),
470
    LIT64( 0xFFFFFFFFDFFFFFFF ),
471
    LIT64( 0xFFFFFFFFBFFFFFFF ),
472
    LIT64( 0xFFFFFFFF7FFFFFFF ),
473
    LIT64( 0xFFFFFFFEFFFFFFFF ),
474
    LIT64( 0xFFFFFFFDFFFFFFFF ),
475
    LIT64( 0xFFFFFFFBFFFFFFFF ),
476
    LIT64( 0xFFFFFFF7FFFFFFFF ),
477
    LIT64( 0xFFFFFFEFFFFFFFFF ),
478
    LIT64( 0xFFFFFFDFFFFFFFFF ),
479
    LIT64( 0xFFFFFFBFFFFFFFFF ),
480
    LIT64( 0xFFFFFF7FFFFFFFFF ),
481
    LIT64( 0xFFFFFEFFFFFFFFFF ),
482
    LIT64( 0xFFFFFDFFFFFFFFFF ),
483
    LIT64( 0xFFFFFBFFFFFFFFFF ),
484
    LIT64( 0xFFFFF7FFFFFFFFFF ),
485
    LIT64( 0xFFFFEFFFFFFFFFFF ),
486
    LIT64( 0xFFFFDFFFFFFFFFFF ),
487
    LIT64( 0xFFFFBFFFFFFFFFFF ),
488
    LIT64( 0xFFFF7FFFFFFFFFFF ),
489
    LIT64( 0xFFFEFFFFFFFFFFFF ),
490
    LIT64( 0xFFFDFFFFFFFFFFFF ),
491
    LIT64( 0xFFFBFFFFFFFFFFFF ),
492
    LIT64( 0xFFF7FFFFFFFFFFFF ),
493
    LIT64( 0xFFEFFFFFFFFFFFFF ),
494
    LIT64( 0xFFDFFFFFFFFFFFFF ),
495
    LIT64( 0xFFBFFFFFFFFFFFFF ),
496
    LIT64( 0xFF7FFFFFFFFFFFFF ),
497
    LIT64( 0xFEFFFFFFFFFFFFFF ),
498
    LIT64( 0xFDFFFFFFFFFFFFFF ),
499
    LIT64( 0xFBFFFFFFFFFFFFFF ),
500
    LIT64( 0xF7FFFFFFFFFFFFFF ),
501
    LIT64( 0xEFFFFFFFFFFFFFFF ),
502
    LIT64( 0xDFFFFFFFFFFFFFFF ),
503
    LIT64( 0xBFFFFFFFFFFFFFFF ),
504
    LIT64( 0x7FFFFFFFFFFFFFFF ),
505
    LIT64( 0x3FFFFFFFFFFFFFFF ),
506
    LIT64( 0x1FFFFFFFFFFFFFFF ),
507
    LIT64( 0x0FFFFFFFFFFFFFFF ),
508
    LIT64( 0x07FFFFFFFFFFFFFF ),
509
    LIT64( 0x03FFFFFFFFFFFFFF ),
510
    LIT64( 0x01FFFFFFFFFFFFFF ),
511
    LIT64( 0x00FFFFFFFFFFFFFF ),
512
    LIT64( 0x007FFFFFFFFFFFFF ),
513
    LIT64( 0x003FFFFFFFFFFFFF ),
514
    LIT64( 0x001FFFFFFFFFFFFF ),
515
    LIT64( 0x000FFFFFFFFFFFFF ),
516
    LIT64( 0x0007FFFFFFFFFFFF ),
517
    LIT64( 0x0003FFFFFFFFFFFF ),
518
    LIT64( 0x0001FFFFFFFFFFFF ),
519
    LIT64( 0x0000FFFFFFFFFFFF ),
520
    LIT64( 0x00007FFFFFFFFFFF ),
521
    LIT64( 0x00003FFFFFFFFFFF ),
522
    LIT64( 0x00001FFFFFFFFFFF ),
523
    LIT64( 0x00000FFFFFFFFFFF ),
524
    LIT64( 0x000007FFFFFFFFFF ),
525
    LIT64( 0x000003FFFFFFFFFF ),
526
    LIT64( 0x000001FFFFFFFFFF ),
527
    LIT64( 0x000000FFFFFFFFFF ),
528
    LIT64( 0x0000007FFFFFFFFF ),
529
    LIT64( 0x0000003FFFFFFFFF ),
530
    LIT64( 0x0000001FFFFFFFFF ),
531
    LIT64( 0x0000000FFFFFFFFF ),
532
    LIT64( 0x00000007FFFFFFFF ),
533
    LIT64( 0x00000003FFFFFFFF ),
534
    LIT64( 0x00000001FFFFFFFF ),
535
    LIT64( 0x00000000FFFFFFFF ),
536
    LIT64( 0x000000007FFFFFFF ),
537
    LIT64( 0x000000003FFFFFFF ),
538
    LIT64( 0x000000001FFFFFFF ),
539
    LIT64( 0x000000000FFFFFFF ),
540
    LIT64( 0x0000000007FFFFFF ),
541
    LIT64( 0x0000000003FFFFFF ),
542
    LIT64( 0x0000000001FFFFFF ),
543
    LIT64( 0x0000000000FFFFFF ),
544
    LIT64( 0x00000000007FFFFF ),
545
    LIT64( 0x00000000003FFFFF ),
546
    LIT64( 0x00000000001FFFFF ),
547
    LIT64( 0x00000000000FFFFF ),
548
    LIT64( 0x000000000007FFFF ),
549
    LIT64( 0x000000000003FFFF ),
550
    LIT64( 0x000000000001FFFF ),
551
    LIT64( 0x000000000000FFFF ),
552
    LIT64( 0x0000000000007FFF ),
553
    LIT64( 0x0000000000003FFF ),
554
    LIT64( 0x0000000000001FFF ),
555
    LIT64( 0x0000000000000FFF ),
556
    LIT64( 0x00000000000007FF ),
557
    LIT64( 0x00000000000003FF ),
558
    LIT64( 0x00000000000001FF ),
559
    LIT64( 0x00000000000000FF ),
560
    LIT64( 0x000000000000007F ),
561
    LIT64( 0x000000000000003F ),
562
    LIT64( 0x000000000000001F ),
563
    LIT64( 0x000000000000000F ),
564
    LIT64( 0x0000000000000007 ),
565
    LIT64( 0x0000000000000003 )
566
};
567
 
568
static int64 int64NextP1( sequenceT *sequencePtr )
569
{
570
    uint8 termNum;
571
    int64 z;
572
 
573
    termNum = sequencePtr->term1Num;
574
    z = int64P1[ termNum ];
575
    ++termNum;
576
    if ( int64NumP1 <= termNum ) {
577
        termNum = 0;
578
        sequencePtr->done = TRUE;
579
    }
580
    sequencePtr->term1Num = termNum;
581
    return (sbits64) z;
582
 
583
}
584
 
585
static const int64 int64NumP2 = ( int64NumP1 * int64NumP1 + int64NumP1 ) / 2;
586
 
587
static int64 int64NextP2( sequenceT *sequencePtr )
588
{
589
    uint8 term1Num, term2Num;
590
    int64 z;
591
 
592
    term2Num = sequencePtr->term2Num;
593
    term1Num = sequencePtr->term1Num;
594
    z = int64P1[ term1Num ] + int64P1[ term2Num ];
595
    ++term2Num;
596
    if ( int64NumP1 <= term2Num ) {
597
        ++term1Num;
598
        if ( int64NumP1 <= term1Num ) {
599
            term1Num = 0;
600
            sequencePtr->done = TRUE;
601
        }
602
        term2Num = term1Num;
603
        sequencePtr->term1Num = term1Num;
604
    }
605
    sequencePtr->term2Num = term2Num;
606
    return (sbits64) z;
607
 
608
}
609
 
610
static int64 int64RandomP3( void )
611
{
612
 
613
    return
614
        (sbits64) (
615
              int64P1[ randomUint8() % int64NumP1 ]
616
            + int64P1[ randomUint8() % int64NumP1 ]
617
            + int64P1[ randomUint8() % int64NumP1 ]
618
        );
619
 
620
}
621
 
622
enum {
623
    int64NumPInfWeightMasks = 61
624
};
625
 
626
static const uint64 int64PInfWeightMasks[ int64NumPInfWeightMasks ] = {
627
    LIT64( 0xFFFFFFFFFFFFFFFF ),
628
    LIT64( 0x7FFFFFFFFFFFFFFF ),
629
    LIT64( 0x3FFFFFFFFFFFFFFF ),
630
    LIT64( 0x1FFFFFFFFFFFFFFF ),
631
    LIT64( 0x0FFFFFFFFFFFFFFF ),
632
    LIT64( 0x07FFFFFFFFFFFFFF ),
633
    LIT64( 0x03FFFFFFFFFFFFFF ),
634
    LIT64( 0x01FFFFFFFFFFFFFF ),
635
    LIT64( 0x00FFFFFFFFFFFFFF ),
636
    LIT64( 0x007FFFFFFFFFFFFF ),
637
    LIT64( 0x003FFFFFFFFFFFFF ),
638
    LIT64( 0x001FFFFFFFFFFFFF ),
639
    LIT64( 0x000FFFFFFFFFFFFF ),
640
    LIT64( 0x0007FFFFFFFFFFFF ),
641
    LIT64( 0x0003FFFFFFFFFFFF ),
642
    LIT64( 0x0001FFFFFFFFFFFF ),
643
    LIT64( 0x0000FFFFFFFFFFFF ),
644
    LIT64( 0x00007FFFFFFFFFFF ),
645
    LIT64( 0x00003FFFFFFFFFFF ),
646
    LIT64( 0x00001FFFFFFFFFFF ),
647
    LIT64( 0x00000FFFFFFFFFFF ),
648
    LIT64( 0x000007FFFFFFFFFF ),
649
    LIT64( 0x000003FFFFFFFFFF ),
650
    LIT64( 0x000001FFFFFFFFFF ),
651
    LIT64( 0x000000FFFFFFFFFF ),
652
    LIT64( 0x0000007FFFFFFFFF ),
653
    LIT64( 0x0000003FFFFFFFFF ),
654
    LIT64( 0x0000001FFFFFFFFF ),
655
    LIT64( 0x0000000FFFFFFFFF ),
656
    LIT64( 0x00000007FFFFFFFF ),
657
    LIT64( 0x00000003FFFFFFFF ),
658
    LIT64( 0x00000001FFFFFFFF ),
659
    LIT64( 0x00000000FFFFFFFF ),
660
    LIT64( 0x000000007FFFFFFF ),
661
    LIT64( 0x000000003FFFFFFF ),
662
    LIT64( 0x000000001FFFFFFF ),
663
    LIT64( 0x000000000FFFFFFF ),
664
    LIT64( 0x0000000007FFFFFF ),
665
    LIT64( 0x0000000003FFFFFF ),
666
    LIT64( 0x0000000001FFFFFF ),
667
    LIT64( 0x0000000000FFFFFF ),
668
    LIT64( 0x00000000007FFFFF ),
669
    LIT64( 0x00000000003FFFFF ),
670
    LIT64( 0x00000000001FFFFF ),
671
    LIT64( 0x00000000000FFFFF ),
672
    LIT64( 0x000000000007FFFF ),
673
    LIT64( 0x000000000003FFFF ),
674
    LIT64( 0x000000000001FFFF ),
675
    LIT64( 0x000000000000FFFF ),
676
    LIT64( 0x0000000000007FFF ),
677
    LIT64( 0x0000000000003FFF ),
678
    LIT64( 0x0000000000001FFF ),
679
    LIT64( 0x0000000000000FFF ),
680
    LIT64( 0x00000000000007FF ),
681
    LIT64( 0x00000000000003FF ),
682
    LIT64( 0x00000000000001FF ),
683
    LIT64( 0x00000000000000FF ),
684
    LIT64( 0x000000000000007F ),
685
    LIT64( 0x000000000000003F ),
686
    LIT64( 0x000000000000001F ),
687
    LIT64( 0x000000000000000F )
688
};
689
 
690
static const uint64 int64PInfWeightOffsets[ int64NumPInfWeightMasks ] = {
691
    LIT64( 0x0000000000000000 ),
692
    LIT64( 0xC000000000000000 ),
693
    LIT64( 0xE000000000000000 ),
694
    LIT64( 0xF000000000000000 ),
695
    LIT64( 0xF800000000000000 ),
696
    LIT64( 0xFC00000000000000 ),
697
    LIT64( 0xFE00000000000000 ),
698
    LIT64( 0xFF00000000000000 ),
699
    LIT64( 0xFF80000000000000 ),
700
    LIT64( 0xFFC0000000000000 ),
701
    LIT64( 0xFFE0000000000000 ),
702
    LIT64( 0xFFF0000000000000 ),
703
    LIT64( 0xFFF8000000000000 ),
704
    LIT64( 0xFFFC000000000000 ),
705
    LIT64( 0xFFFE000000000000 ),
706
    LIT64( 0xFFFF000000000000 ),
707
    LIT64( 0xFFFF800000000000 ),
708
    LIT64( 0xFFFFC00000000000 ),
709
    LIT64( 0xFFFFE00000000000 ),
710
    LIT64( 0xFFFFF00000000000 ),
711
    LIT64( 0xFFFFF80000000000 ),
712
    LIT64( 0xFFFFFC0000000000 ),
713
    LIT64( 0xFFFFFE0000000000 ),
714
    LIT64( 0xFFFFFF0000000000 ),
715
    LIT64( 0xFFFFFF8000000000 ),
716
    LIT64( 0xFFFFFFC000000000 ),
717
    LIT64( 0xFFFFFFE000000000 ),
718
    LIT64( 0xFFFFFFF000000000 ),
719
    LIT64( 0xFFFFFFF800000000 ),
720
    LIT64( 0xFFFFFFFC00000000 ),
721
    LIT64( 0xFFFFFFFE00000000 ),
722
    LIT64( 0xFFFFFFFF00000000 ),
723
    LIT64( 0xFFFFFFFF80000000 ),
724
    LIT64( 0xFFFFFFFFC0000000 ),
725
    LIT64( 0xFFFFFFFFE0000000 ),
726
    LIT64( 0xFFFFFFFFF0000000 ),
727
    LIT64( 0xFFFFFFFFF8000000 ),
728
    LIT64( 0xFFFFFFFFFC000000 ),
729
    LIT64( 0xFFFFFFFFFE000000 ),
730
    LIT64( 0xFFFFFFFFFF000000 ),
731
    LIT64( 0xFFFFFFFFFF800000 ),
732
    LIT64( 0xFFFFFFFFFFC00000 ),
733
    LIT64( 0xFFFFFFFFFFE00000 ),
734
    LIT64( 0xFFFFFFFFFFF00000 ),
735
    LIT64( 0xFFFFFFFFFFF80000 ),
736
    LIT64( 0xFFFFFFFFFFFC0000 ),
737
    LIT64( 0xFFFFFFFFFFFE0000 ),
738
    LIT64( 0xFFFFFFFFFFFF0000 ),
739
    LIT64( 0xFFFFFFFFFFFF8000 ),
740
    LIT64( 0xFFFFFFFFFFFFC000 ),
741
    LIT64( 0xFFFFFFFFFFFFE000 ),
742
    LIT64( 0xFFFFFFFFFFFFF000 ),
743
    LIT64( 0xFFFFFFFFFFFFF800 ),
744
    LIT64( 0xFFFFFFFFFFFFFC00 ),
745
    LIT64( 0xFFFFFFFFFFFFFE00 ),
746
    LIT64( 0xFFFFFFFFFFFFFF00 ),
747
    LIT64( 0xFFFFFFFFFFFFFF80 ),
748
    LIT64( 0xFFFFFFFFFFFFFFC0 ),
749
    LIT64( 0xFFFFFFFFFFFFFFE0 ),
750
    LIT64( 0xFFFFFFFFFFFFFFF0 ),
751
    LIT64( 0xFFFFFFFFFFFFFFF8 )
752
};
753
 
754
static int64 int64RandomPInf( void )
755
{
756
    int8 weightMaskNum;
757
 
758
    weightMaskNum = randomUint8() % int64NumPInfWeightMasks;
759
    return
760
        (sbits64) (
761
              ( randomUint64() & int64PInfWeightMasks[ weightMaskNum ] )
762
            + int64PInfWeightOffsets[ weightMaskNum ]
763
        );
764
 
765
}
766
 
767
#endif
768
 
769
enum {
770
    float32NumQIn  = 22,
771
    float32NumQOut = 50,
772
    float32NumP1   =  4,
773
    float32NumP2   = 88
774
};
775
 
776
static const uint32 float32QIn[ float32NumQIn ] = {
777
    0x00000000,         /* positive, subnormal          */
778
    0x00800000,         /* positive, -126               */
779
    0x33800000,         /* positive,  -24               */
780
    0x3E800000,         /* positive,   -2               */
781
    0x3F000000,         /* positive,   -1               */
782
    0x3F800000,         /* positive,    0               */
783
    0x40000000,         /* positive,    1               */
784
    0x40800000,         /* positive,    2               */
785
    0x4B800000,         /* positive,   24               */
786
    0x7F000000,         /* positive,  127               */
787
    0x7F800000,         /* positive, infinity or NaN    */
788
    0x80000000,         /* negative, subnormal          */
789
    0x80800000,         /* negative, -126               */
790
    0xB3800000,         /* negative,  -24               */
791
    0xBE800000,         /* negative,   -2               */
792
    0xBF000000,         /* negative,   -1               */
793
    0xBF800000,         /* negative,    0               */
794
    0xC0000000,         /* negative,    1               */
795
    0xC0800000,         /* negative,    2               */
796
    0xCB800000,         /* negative,   24               */
797
    0xFE800000,         /* negative,  126               */
798
    0xFF800000          /* negative, infinity or NaN    */
799
};
800
 
801
static const uint32 float32QOut[ float32NumQOut ] = {
802
    0x00000000,         /* positive, subnormal          */
803
    0x00800000,         /* positive, -126               */
804
    0x01000000,         /* positive, -125               */
805
    0x33800000,         /* positive,  -24               */
806
    0x3D800000,         /* positive,   -4               */
807
    0x3E000000,         /* positive,   -3               */
808
    0x3E800000,         /* positive,   -2               */
809
    0x3F000000,         /* positive,   -1               */
810
    0x3F800000,         /* positive,    0               */
811
    0x40000000,         /* positive,    1               */
812
    0x40800000,         /* positive,    2               */
813
    0x41000000,         /* positive,    3               */
814
    0x41800000,         /* positive,    4               */
815
    0x4B800000,         /* positive,   24               */
816
    0x4E000000,         /* positive,   29               */
817
    0x4E800000,         /* positive,   30               */
818
    0x4F000000,         /* positive,   31               */
819
    0x4F800000,         /* positive,   32               */
820
    0x5E000000,         /* positive,   61               */
821
    0x5E800000,         /* positive,   62               */
822
    0x5F000000,         /* positive,   63               */
823
    0x5F800000,         /* positive,   64               */
824
    0x7E800000,         /* positive,  126               */
825
    0x7F000000,         /* positive,  127               */
826
    0x7F800000,         /* positive, infinity or NaN    */
827
    0x80000000,         /* negative, subnormal          */
828
    0x80800000,         /* negative, -126               */
829
    0x81000000,         /* negative, -125               */
830
    0xB3800000,         /* negative,  -24               */
831
    0xBD800000,         /* negative,   -4               */
832
    0xBE000000,         /* negative,   -3               */
833
    0xBE800000,         /* negative,   -2               */
834
    0xBF000000,         /* negative,   -1               */
835
    0xBF800000,         /* negative,    0               */
836
    0xC0000000,         /* negative,    1               */
837
    0xC0800000,         /* negative,    2               */
838
    0xC1000000,         /* negative,    3               */
839
    0xC1800000,         /* negative,    4               */
840
    0xCB800000,         /* negative,   24               */
841
    0xCE000000,         /* negative,   29               */
842
    0xCE800000,         /* negative,   30               */
843
    0xCF000000,         /* negative,   31               */
844
    0xCF800000,         /* negative,   32               */
845
    0xDE000000,         /* negative,   61               */
846
    0xDE800000,         /* negative,   62               */
847
    0xDF000000,         /* negative,   63               */
848
    0xDF800000,         /* negative,   64               */
849
    0xFE800000,         /* negative,  126               */
850
    0xFF000000,         /* negative,  127               */
851
    0xFF800000          /* negative, infinity or NaN    */
852
};
853
 
854
static const uint32 float32P1[ float32NumP1 ] = {
855
    0x00000000,
856
    0x00000001,
857
    0x007FFFFF,
858
    0x007FFFFE
859
};
860
 
861
static const uint32 float32P2[ float32NumP2 ] = {
862
    0x00000000,
863
    0x00000001,
864
    0x00000002,
865
    0x00000004,
866
    0x00000008,
867
    0x00000010,
868
    0x00000020,
869
    0x00000040,
870
    0x00000080,
871
    0x00000100,
872
    0x00000200,
873
    0x00000400,
874
    0x00000800,
875
    0x00001000,
876
    0x00002000,
877
    0x00004000,
878
    0x00008000,
879
    0x00010000,
880
    0x00020000,
881
    0x00040000,
882
    0x00080000,
883
    0x00100000,
884
    0x00200000,
885
    0x00400000,
886
    0x00600000,
887
    0x00700000,
888
    0x00780000,
889
    0x007C0000,
890
    0x007E0000,
891
    0x007F0000,
892
    0x007F8000,
893
    0x007FC000,
894
    0x007FE000,
895
    0x007FF000,
896
    0x007FF800,
897
    0x007FFC00,
898
    0x007FFE00,
899
    0x007FFF00,
900
    0x007FFF80,
901
    0x007FFFC0,
902
    0x007FFFE0,
903
    0x007FFFF0,
904
    0x007FFFF8,
905
    0x007FFFFC,
906
    0x007FFFFE,
907
    0x007FFFFF,
908
    0x007FFFFD,
909
    0x007FFFFB,
910
    0x007FFFF7,
911
    0x007FFFEF,
912
    0x007FFFDF,
913
    0x007FFFBF,
914
    0x007FFF7F,
915
    0x007FFEFF,
916
    0x007FFDFF,
917
    0x007FFBFF,
918
    0x007FF7FF,
919
    0x007FEFFF,
920
    0x007FDFFF,
921
    0x007FBFFF,
922
    0x007F7FFF,
923
    0x007EFFFF,
924
    0x007DFFFF,
925
    0x007BFFFF,
926
    0x0077FFFF,
927
    0x006FFFFF,
928
    0x005FFFFF,
929
    0x003FFFFF,
930
    0x001FFFFF,
931
    0x000FFFFF,
932
    0x0007FFFF,
933
    0x0003FFFF,
934
    0x0001FFFF,
935
    0x0000FFFF,
936
    0x00007FFF,
937
    0x00003FFF,
938
    0x00001FFF,
939
    0x00000FFF,
940
    0x000007FF,
941
    0x000003FF,
942
    0x000001FF,
943
    0x000000FF,
944
    0x0000007F,
945
    0x0000003F,
946
    0x0000001F,
947
    0x0000000F,
948
    0x00000007,
949
    0x00000003
950
};
951
 
952
static const uint32 float32NumQInP1 = float32NumQIn * float32NumP1;
953
static const uint32 float32NumQOutP1 = float32NumQOut * float32NumP1;
954
 
955
static float32 float32NextQInP1( sequenceT *sequencePtr )
956
{
957
    uint8 expNum, sigNum;
958
    float32 z;
959
 
960
    sigNum = sequencePtr->term1Num;
961
    expNum = sequencePtr->expNum;
962
    z = float32QIn[ expNum ] | float32P1[ sigNum ];
963
    ++sigNum;
964
    if ( float32NumP1 <= sigNum ) {
965
        sigNum = 0;
966
        ++expNum;
967
        if ( float32NumQIn <= expNum ) {
968
            expNum = 0;
969
            sequencePtr->done = TRUE;
970
        }
971
        sequencePtr->expNum = expNum;
972
    }
973
    sequencePtr->term1Num = sigNum;
974
    return z;
975
 
976
}
977
 
978
static float32 float32NextQOutP1( sequenceT *sequencePtr )
979
{
980
    uint8 expNum, sigNum;
981
    float32 z;
982
 
983
    sigNum = sequencePtr->term1Num;
984
    expNum = sequencePtr->expNum;
985
    z = float32QOut[ expNum ] | float32P1[ sigNum ];
986
    ++sigNum;
987
    if ( float32NumP1 <= sigNum ) {
988
        sigNum = 0;
989
        ++expNum;
990
        if ( float32NumQOut <= expNum ) {
991
            expNum = 0;
992
            sequencePtr->done = TRUE;
993
        }
994
        sequencePtr->expNum = expNum;
995
    }
996
    sequencePtr->term1Num = sigNum;
997
    return z;
998
 
999
}
1000
 
1001
static const uint32 float32NumQInP2 = float32NumQIn * float32NumP2;
1002
static const uint32 float32NumQOutP2 = float32NumQOut * float32NumP2;
1003
 
1004
static float32 float32NextQInP2( sequenceT *sequencePtr )
1005
{
1006
    uint8 expNum, sigNum;
1007
    float32 z;
1008
 
1009
    sigNum = sequencePtr->term1Num;
1010
    expNum = sequencePtr->expNum;
1011
    z = float32QIn[ expNum ] | float32P2[ sigNum ];
1012
    ++sigNum;
1013
    if ( float32NumP2 <= sigNum ) {
1014
        sigNum = 0;
1015
        ++expNum;
1016
        if ( float32NumQIn <= expNum ) {
1017
            expNum = 0;
1018
            sequencePtr->done = TRUE;
1019
        }
1020
        sequencePtr->expNum = expNum;
1021
    }
1022
    sequencePtr->term1Num = sigNum;
1023
    return z;
1024
 
1025
}
1026
 
1027
static float32 float32NextQOutP2( sequenceT *sequencePtr )
1028
{
1029
    uint8 expNum, sigNum;
1030
    float32 z;
1031
 
1032
    sigNum = sequencePtr->term1Num;
1033
    expNum = sequencePtr->expNum;
1034
    z = float32QOut[ expNum ] | float32P2[ sigNum ];
1035
    ++sigNum;
1036
    if ( float32NumP2 <= sigNum ) {
1037
        sigNum = 0;
1038
        ++expNum;
1039
        if ( float32NumQOut <= expNum ) {
1040
            expNum = 0;
1041
            sequencePtr->done = TRUE;
1042
        }
1043
        sequencePtr->expNum = expNum;
1044
    }
1045
    sequencePtr->term1Num = sigNum;
1046
    return z;
1047
 
1048
}
1049
 
1050
static float32 float32RandomQOutP3( void )
1051
{
1052
 
1053
    return
1054
          float32QOut[ randomUint8() % float32NumQOut ]
1055
        | (   (   float32P2[ randomUint8() % float32NumP2 ]
1056
                + float32P2[ randomUint8() % float32NumP2 ] )
1057
            & 0x007FFFFF );
1058
 
1059
}
1060
 
1061
static float32 float32RandomQOutPInf( void )
1062
{
1063
 
1064
    return
1065
          float32QOut[ randomUint8() % float32NumQOut ]
1066
        | ( randomUint32() & 0x007FFFFF );
1067
 
1068
}
1069
 
1070
enum {
1071
    float32NumQInfWeightMasks = 7
1072
};
1073
 
1074
static const uint32 float32QInfWeightMasks[ float32NumQInfWeightMasks ] = {
1075
    0x7F800000,
1076
    0x7F800000,
1077
    0x3F800000,
1078
    0x1F800000,
1079
    0x0F800000,
1080
    0x07800000,
1081
    0x03800000
1082
};
1083
 
1084
static const uint32 float32QInfWeightOffsets[ float32NumQInfWeightMasks ] = {
1085
    0x00000000,
1086
    0x00000000,
1087
    0x20000000,
1088
    0x30000000,
1089
    0x38000000,
1090
    0x3C000000,
1091
    0x3E000000
1092
};
1093
 
1094
static float32 float32RandomQInfP3( void )
1095
{
1096
    int8 weightMaskNum;
1097
 
1098
    weightMaskNum = randomUint8() % float32NumQInfWeightMasks;
1099
    return
1100
          ( ( (uint32) ( randomUint8() & 1 ) )<<31 )
1101
        | (   (   ( ( (uint32) ( randomUint16() & 0x1FF ) )<<23 )
1102
                & float32QInfWeightMasks[ weightMaskNum ] )
1103
            + float32QInfWeightOffsets[ weightMaskNum ]
1104
          )
1105
        | (   (   float32P2[ randomUint8() % float32NumP2 ]
1106
                + float32P2[ randomUint8() % float32NumP2 ] )
1107
            & 0x007FFFFF );
1108
 
1109
}
1110
 
1111
static float32 float32RandomQInfPInf( void )
1112
{
1113
    int8 weightMaskNum;
1114
 
1115
    weightMaskNum = randomUint8() % float32NumQInfWeightMasks;
1116
    return
1117
          ( ( (uint32) ( randomUint8() & 1 ) )<<31 )
1118
        | (   (   ( ( (uint32) ( randomUint16() & 0x1FF ) )<<23 )
1119
                & float32QInfWeightMasks[ weightMaskNum ] )
1120
            + float32QInfWeightOffsets[ weightMaskNum ]
1121
          )
1122
        | ( randomUint32() & 0x007FFFFF );
1123
 
1124
}
1125
 
1126
static float32 float32Random( void )
1127
{
1128
 
1129
    switch ( randomUint8() & 7 ) {
1130
     case 0:
1131
     case 1:
1132
     case 2:
1133
        return float32RandomQOutP3();
1134
     case 3:
1135
        return float32RandomQOutPInf();
1136
     case 4:
1137
     case 5:
1138
     case 6:
1139
        return float32RandomQInfP3();
1140
     case 7:
1141
        return float32RandomQInfPInf();
1142
    default:
1143
      // Added this - GCC warning that control reached end of non-void return
1144
      // function, but we actually cover all cases here (0-7) for the 3-bit
1145
      // value that results from the masking in the switch() - JB
1146
      return 0;
1147
    }
1148
 
1149
}
1150
 
1151
#ifdef BITS64
1152
#define SETFLOAT64( z, zHigh, zLow ) z = ( ( (float64) zHigh )<<32 ) | zLow
1153
#else
1154
#define SETFLOAT64( z, zHigh, zLow ) z.low = zLow; z.high = zHigh
1155
#endif
1156
 
1157
enum {
1158
    float64NumQIn  =  22,
1159
    float64NumQOut =  64,
1160
    float64NumP1   =   4,
1161
    float64NumP2   = 204
1162
};
1163
 
1164
static const uint32 float64QIn[ float64NumQIn ] = {
1165
    0x00000000,         /* positive, subnormal          */
1166
    0x00100000,         /* positive, -1022              */
1167
    0x3CA00000,         /* positive,   -53              */
1168
    0x3FD00000,         /* positive,    -2              */
1169
    0x3FE00000,         /* positive,    -1              */
1170
    0x3FF00000,         /* positive,     0              */
1171
    0x40000000,         /* positive,     1              */
1172
    0x40100000,         /* positive,     2              */
1173
    0x43400000,         /* positive,    53              */
1174
    0x7FE00000,         /* positive,  1023              */
1175
    0x7FF00000,         /* positive, infinity or NaN    */
1176
    0x80000000,         /* negative, subnormal          */
1177
    0x80100000,         /* negative, -1022              */
1178
    0xBCA00000,         /* negative,   -53              */
1179
    0xBFD00000,         /* negative,    -2              */
1180
    0xBFE00000,         /* negative,    -1              */
1181
    0xBFF00000,         /* negative,     0              */
1182
    0xC0000000,         /* negative,     1              */
1183
    0xC0100000,         /* negative,     2              */
1184
    0xC3400000,         /* negative,    53              */
1185
    0xFFE00000,         /* negative,  1023              */
1186
    0xFFF00000          /* negative, infinity or NaN    */
1187
};
1188
 
1189
static const uint32 float64QOut[ float64NumQOut ] = {
1190
    0x00000000,         /* positive, subnormal          */
1191
    0x00100000,         /* positive, -1022              */
1192
    0x00200000,         /* positive, -1021              */
1193
    0x37E00000,         /* positive,  -129              */
1194
    0x37F00000,         /* positive,  -128              */
1195
    0x38000000,         /* positive,  -127              */
1196
    0x38100000,         /* positive,  -126              */
1197
    0x3CA00000,         /* positive,   -53              */
1198
    0x3FB00000,         /* positive,    -4              */
1199
    0x3FC00000,         /* positive,    -3              */
1200
    0x3FD00000,         /* positive,    -2              */
1201
    0x3FE00000,         /* positive,    -1              */
1202
    0x3FF00000,         /* positive,     0              */
1203
    0x40000000,         /* positive,     1              */
1204
    0x40100000,         /* positive,     2              */
1205
    0x40200000,         /* positive,     3              */
1206
    0x40300000,         /* positive,     4              */
1207
    0x41C00000,         /* positive,    29              */
1208
    0x41D00000,         /* positive,    30              */
1209
    0x41E00000,         /* positive,    31              */
1210
    0x41F00000,         /* positive,    32              */
1211
    0x43400000,         /* positive,    53              */
1212
    0x43C00000,         /* positive,    61              */
1213
    0x43D00000,         /* positive,    62              */
1214
    0x43E00000,         /* positive,    63              */
1215
    0x43F00000,         /* positive,    64              */
1216
    0x47E00000,         /* positive,   127              */
1217
    0x47F00000,         /* positive,   128              */
1218
    0x48000000,         /* positive,   129              */
1219
    0x7FD00000,         /* positive,  1022              */
1220
    0x7FE00000,         /* positive,  1023              */
1221
    0x7FF00000,         /* positive, infinity or NaN    */
1222
    0x80000000,         /* negative, subnormal          */
1223
    0x80100000,         /* negative, -1022              */
1224
    0x80200000,         /* negative, -1021              */
1225
    0xB7E00000,         /* negative,  -129              */
1226
    0xB7F00000,         /* negative,  -128              */
1227
    0xB8000000,         /* negative,  -127              */
1228
    0xB8100000,         /* negative,  -126              */
1229
    0xBCA00000,         /* negative,   -53              */
1230
    0xBFB00000,         /* negative,    -4              */
1231
    0xBFC00000,         /* negative,    -3              */
1232
    0xBFD00000,         /* negative,    -2              */
1233
    0xBFE00000,         /* negative,    -1              */
1234
    0xBFF00000,         /* negative,     0              */
1235
    0xC0000000,         /* negative,     1              */
1236
    0xC0100000,         /* negative,     2              */
1237
    0xC0200000,         /* negative,     3              */
1238
    0xC0300000,         /* negative,     4              */
1239
    0xC1C00000,         /* negative,    29              */
1240
    0xC1D00000,         /* negative,    30              */
1241
    0xC1E00000,         /* negative,    31              */
1242
    0xC1F00000,         /* negative,    32              */
1243
    0xC3400000,         /* negative,    53              */
1244
    0xC3C00000,         /* negative,    61              */
1245
    0xC3D00000,         /* negative,    62              */
1246
    0xC3E00000,         /* negative,    63              */
1247
    0xC3F00000,         /* negative,    64              */
1248
    0xC7E00000,         /* negative,   127              */
1249
    0xC7F00000,         /* negative,   128              */
1250
    0xC8000000,         /* negative,   129              */
1251
    0xFFD00000,         /* negative,  1022              */
1252
    0xFFE00000,         /* negative,  1023              */
1253
    0xFFF00000          /* negative, infinity or NaN    */
1254
};
1255
 
1256
static const struct { bits32 high, low; } float64P1[ float64NumP1 ] = {
1257
    { 0x00000000, 0x00000000 },
1258
    { 0x00000000, 0x00000001 },
1259
    { 0x000FFFFF, 0xFFFFFFFF },
1260
    { 0x000FFFFF, 0xFFFFFFFE }
1261
};
1262
 
1263
static const struct { bits32 high, low; } float64P2[ float64NumP2 ] = {
1264
    { 0x00000000, 0x00000000 },
1265
    { 0x00000000, 0x00000001 },
1266
    { 0x00000000, 0x00000002 },
1267
    { 0x00000000, 0x00000004 },
1268
    { 0x00000000, 0x00000008 },
1269
    { 0x00000000, 0x00000010 },
1270
    { 0x00000000, 0x00000020 },
1271
    { 0x00000000, 0x00000040 },
1272
    { 0x00000000, 0x00000080 },
1273
    { 0x00000000, 0x00000100 },
1274
    { 0x00000000, 0x00000200 },
1275
    { 0x00000000, 0x00000400 },
1276
    { 0x00000000, 0x00000800 },
1277
    { 0x00000000, 0x00001000 },
1278
    { 0x00000000, 0x00002000 },
1279
    { 0x00000000, 0x00004000 },
1280
    { 0x00000000, 0x00008000 },
1281
    { 0x00000000, 0x00010000 },
1282
    { 0x00000000, 0x00020000 },
1283
    { 0x00000000, 0x00040000 },
1284
    { 0x00000000, 0x00080000 },
1285
    { 0x00000000, 0x00100000 },
1286
    { 0x00000000, 0x00200000 },
1287
    { 0x00000000, 0x00400000 },
1288
    { 0x00000000, 0x00800000 },
1289
    { 0x00000000, 0x01000000 },
1290
    { 0x00000000, 0x02000000 },
1291
    { 0x00000000, 0x04000000 },
1292
    { 0x00000000, 0x08000000 },
1293
    { 0x00000000, 0x10000000 },
1294
    { 0x00000000, 0x20000000 },
1295
    { 0x00000000, 0x40000000 },
1296
    { 0x00000000, 0x80000000 },
1297
    { 0x00000001, 0x00000000 },
1298
    { 0x00000002, 0x00000000 },
1299
    { 0x00000004, 0x00000000 },
1300
    { 0x00000008, 0x00000000 },
1301
    { 0x00000010, 0x00000000 },
1302
    { 0x00000020, 0x00000000 },
1303
    { 0x00000040, 0x00000000 },
1304
    { 0x00000080, 0x00000000 },
1305
    { 0x00000100, 0x00000000 },
1306
    { 0x00000200, 0x00000000 },
1307
    { 0x00000400, 0x00000000 },
1308
    { 0x00000800, 0x00000000 },
1309
    { 0x00001000, 0x00000000 },
1310
    { 0x00002000, 0x00000000 },
1311
    { 0x00004000, 0x00000000 },
1312
    { 0x00008000, 0x00000000 },
1313
    { 0x00010000, 0x00000000 },
1314
    { 0x00020000, 0x00000000 },
1315
    { 0x00040000, 0x00000000 },
1316
    { 0x00080000, 0x00000000 },
1317
    { 0x000C0000, 0x00000000 },
1318
    { 0x000E0000, 0x00000000 },
1319
    { 0x000F0000, 0x00000000 },
1320
    { 0x000F8000, 0x00000000 },
1321
    { 0x000FC000, 0x00000000 },
1322
    { 0x000FE000, 0x00000000 },
1323
    { 0x000FF000, 0x00000000 },
1324
    { 0x000FF800, 0x00000000 },
1325
    { 0x000FFC00, 0x00000000 },
1326
    { 0x000FFE00, 0x00000000 },
1327
    { 0x000FFF00, 0x00000000 },
1328
    { 0x000FFF80, 0x00000000 },
1329
    { 0x000FFFC0, 0x00000000 },
1330
    { 0x000FFFE0, 0x00000000 },
1331
    { 0x000FFFF0, 0x00000000 },
1332
    { 0x000FFFF8, 0x00000000 },
1333
    { 0x000FFFFC, 0x00000000 },
1334
    { 0x000FFFFE, 0x00000000 },
1335
    { 0x000FFFFF, 0x00000000 },
1336
    { 0x000FFFFF, 0x80000000 },
1337
    { 0x000FFFFF, 0xC0000000 },
1338
    { 0x000FFFFF, 0xE0000000 },
1339
    { 0x000FFFFF, 0xF0000000 },
1340
    { 0x000FFFFF, 0xF8000000 },
1341
    { 0x000FFFFF, 0xFC000000 },
1342
    { 0x000FFFFF, 0xFE000000 },
1343
    { 0x000FFFFF, 0xFF000000 },
1344
    { 0x000FFFFF, 0xFF800000 },
1345
    { 0x000FFFFF, 0xFFC00000 },
1346
    { 0x000FFFFF, 0xFFE00000 },
1347
    { 0x000FFFFF, 0xFFF00000 },
1348
    { 0x000FFFFF, 0xFFF80000 },
1349
    { 0x000FFFFF, 0xFFFC0000 },
1350
    { 0x000FFFFF, 0xFFFE0000 },
1351
    { 0x000FFFFF, 0xFFFF0000 },
1352
    { 0x000FFFFF, 0xFFFF8000 },
1353
    { 0x000FFFFF, 0xFFFFC000 },
1354
    { 0x000FFFFF, 0xFFFFE000 },
1355
    { 0x000FFFFF, 0xFFFFF000 },
1356
    { 0x000FFFFF, 0xFFFFF800 },
1357
    { 0x000FFFFF, 0xFFFFFC00 },
1358
    { 0x000FFFFF, 0xFFFFFE00 },
1359
    { 0x000FFFFF, 0xFFFFFF00 },
1360
    { 0x000FFFFF, 0xFFFFFF80 },
1361
    { 0x000FFFFF, 0xFFFFFFC0 },
1362
    { 0x000FFFFF, 0xFFFFFFE0 },
1363
    { 0x000FFFFF, 0xFFFFFFF0 },
1364
    { 0x000FFFFF, 0xFFFFFFF8 },
1365
    { 0x000FFFFF, 0xFFFFFFFC },
1366
    { 0x000FFFFF, 0xFFFFFFFE },
1367
    { 0x000FFFFF, 0xFFFFFFFF },
1368
    { 0x000FFFFF, 0xFFFFFFFD },
1369
    { 0x000FFFFF, 0xFFFFFFFB },
1370
    { 0x000FFFFF, 0xFFFFFFF7 },
1371
    { 0x000FFFFF, 0xFFFFFFEF },
1372
    { 0x000FFFFF, 0xFFFFFFDF },
1373
    { 0x000FFFFF, 0xFFFFFFBF },
1374
    { 0x000FFFFF, 0xFFFFFF7F },
1375
    { 0x000FFFFF, 0xFFFFFEFF },
1376
    { 0x000FFFFF, 0xFFFFFDFF },
1377
    { 0x000FFFFF, 0xFFFFFBFF },
1378
    { 0x000FFFFF, 0xFFFFF7FF },
1379
    { 0x000FFFFF, 0xFFFFEFFF },
1380
    { 0x000FFFFF, 0xFFFFDFFF },
1381
    { 0x000FFFFF, 0xFFFFBFFF },
1382
    { 0x000FFFFF, 0xFFFF7FFF },
1383
    { 0x000FFFFF, 0xFFFEFFFF },
1384
    { 0x000FFFFF, 0xFFFDFFFF },
1385
    { 0x000FFFFF, 0xFFFBFFFF },
1386
    { 0x000FFFFF, 0xFFF7FFFF },
1387
    { 0x000FFFFF, 0xFFEFFFFF },
1388
    { 0x000FFFFF, 0xFFDFFFFF },
1389
    { 0x000FFFFF, 0xFFBFFFFF },
1390
    { 0x000FFFFF, 0xFF7FFFFF },
1391
    { 0x000FFFFF, 0xFEFFFFFF },
1392
    { 0x000FFFFF, 0xFDFFFFFF },
1393
    { 0x000FFFFF, 0xFBFFFFFF },
1394
    { 0x000FFFFF, 0xF7FFFFFF },
1395
    { 0x000FFFFF, 0xEFFFFFFF },
1396
    { 0x000FFFFF, 0xDFFFFFFF },
1397
    { 0x000FFFFF, 0xBFFFFFFF },
1398
    { 0x000FFFFF, 0x7FFFFFFF },
1399
    { 0x000FFFFE, 0xFFFFFFFF },
1400
    { 0x000FFFFD, 0xFFFFFFFF },
1401
    { 0x000FFFFB, 0xFFFFFFFF },
1402
    { 0x000FFFF7, 0xFFFFFFFF },
1403
    { 0x000FFFEF, 0xFFFFFFFF },
1404
    { 0x000FFFDF, 0xFFFFFFFF },
1405
    { 0x000FFFBF, 0xFFFFFFFF },
1406
    { 0x000FFF7F, 0xFFFFFFFF },
1407
    { 0x000FFEFF, 0xFFFFFFFF },
1408
    { 0x000FFDFF, 0xFFFFFFFF },
1409
    { 0x000FFBFF, 0xFFFFFFFF },
1410
    { 0x000FF7FF, 0xFFFFFFFF },
1411
    { 0x000FEFFF, 0xFFFFFFFF },
1412
    { 0x000FDFFF, 0xFFFFFFFF },
1413
    { 0x000FBFFF, 0xFFFFFFFF },
1414
    { 0x000F7FFF, 0xFFFFFFFF },
1415
    { 0x000EFFFF, 0xFFFFFFFF },
1416
    { 0x000DFFFF, 0xFFFFFFFF },
1417
    { 0x000BFFFF, 0xFFFFFFFF },
1418
    { 0x0007FFFF, 0xFFFFFFFF },
1419
    { 0x0003FFFF, 0xFFFFFFFF },
1420
    { 0x0001FFFF, 0xFFFFFFFF },
1421
    { 0x0000FFFF, 0xFFFFFFFF },
1422
    { 0x00007FFF, 0xFFFFFFFF },
1423
    { 0x00003FFF, 0xFFFFFFFF },
1424
    { 0x00001FFF, 0xFFFFFFFF },
1425
    { 0x00000FFF, 0xFFFFFFFF },
1426
    { 0x000007FF, 0xFFFFFFFF },
1427
    { 0x000003FF, 0xFFFFFFFF },
1428
    { 0x000001FF, 0xFFFFFFFF },
1429
    { 0x000000FF, 0xFFFFFFFF },
1430
    { 0x0000007F, 0xFFFFFFFF },
1431
    { 0x0000003F, 0xFFFFFFFF },
1432
    { 0x0000001F, 0xFFFFFFFF },
1433
    { 0x0000000F, 0xFFFFFFFF },
1434
    { 0x00000007, 0xFFFFFFFF },
1435
    { 0x00000003, 0xFFFFFFFF },
1436
    { 0x00000001, 0xFFFFFFFF },
1437
    { 0x00000000, 0xFFFFFFFF },
1438
    { 0x00000000, 0x7FFFFFFF },
1439
    { 0x00000000, 0x3FFFFFFF },
1440
    { 0x00000000, 0x1FFFFFFF },
1441
    { 0x00000000, 0x0FFFFFFF },
1442
    { 0x00000000, 0x07FFFFFF },
1443
    { 0x00000000, 0x03FFFFFF },
1444
    { 0x00000000, 0x01FFFFFF },
1445
    { 0x00000000, 0x00FFFFFF },
1446
    { 0x00000000, 0x007FFFFF },
1447
    { 0x00000000, 0x003FFFFF },
1448
    { 0x00000000, 0x001FFFFF },
1449
    { 0x00000000, 0x000FFFFF },
1450
    { 0x00000000, 0x0007FFFF },
1451
    { 0x00000000, 0x0003FFFF },
1452
    { 0x00000000, 0x0001FFFF },
1453
    { 0x00000000, 0x0000FFFF },
1454
    { 0x00000000, 0x00007FFF },
1455
    { 0x00000000, 0x00003FFF },
1456
    { 0x00000000, 0x00001FFF },
1457
    { 0x00000000, 0x00000FFF },
1458
    { 0x00000000, 0x000007FF },
1459
    { 0x00000000, 0x000003FF },
1460
    { 0x00000000, 0x000001FF },
1461
    { 0x00000000, 0x000000FF },
1462
    { 0x00000000, 0x0000007F },
1463
    { 0x00000000, 0x0000003F },
1464
    { 0x00000000, 0x0000001F },
1465
    { 0x00000000, 0x0000000F },
1466
    { 0x00000000, 0x00000007 },
1467
    { 0x00000000, 0x00000003 }
1468
};
1469
 
1470
static const uint32 float64NumQInP1 = float64NumQIn * float64NumP1;
1471
static const uint32 float64NumQOutP1 = float64NumQOut * float64NumP1;
1472
 
1473
static float64 float64NextQInP1( sequenceT *sequencePtr )
1474
{
1475
    uint8 expNum, sigNum;
1476
    float64 z;
1477
 
1478
    sigNum = sequencePtr->term1Num;
1479
    expNum = sequencePtr->expNum;
1480
    SETFLOAT64(
1481
        z,
1482
        float64QIn[ expNum ] | float64P1[ sigNum ].high,
1483
        float64P1[ sigNum ].low
1484
    );
1485
    ++sigNum;
1486
    if ( float64NumP1 <= sigNum ) {
1487
        sigNum = 0;
1488
        ++expNum;
1489
        if ( float64NumQIn <= expNum ) {
1490
            expNum = 0;
1491
            sequencePtr->done = TRUE;
1492
        }
1493
        sequencePtr->expNum = expNum;
1494
    }
1495
    sequencePtr->term1Num = sigNum;
1496
    return z;
1497
 
1498
}
1499
 
1500
static float64 float64NextQOutP1( sequenceT *sequencePtr )
1501
{
1502
    uint8 expNum, sigNum;
1503
    float64 z;
1504
 
1505
    sigNum = sequencePtr->term1Num;
1506
    expNum = sequencePtr->expNum;
1507
    SETFLOAT64(
1508
        z,
1509
        float64QOut[ expNum ] | float64P1[ sigNum ].high,
1510
        float64P1[ sigNum ].low
1511
    );
1512
    ++sigNum;
1513
    if ( float64NumP1 <= sigNum ) {
1514
        sigNum = 0;
1515
        ++expNum;
1516
        if ( float64NumQOut <= expNum ) {
1517
            expNum = 0;
1518
            sequencePtr->done = TRUE;
1519
        }
1520
        sequencePtr->expNum = expNum;
1521
    }
1522
    sequencePtr->term1Num = sigNum;
1523
    return z;
1524
 
1525
}
1526
 
1527
static const uint32 float64NumQInP2 = float64NumQIn * float64NumP2;
1528
static const uint32 float64NumQOutP2 = float64NumQOut * float64NumP2;
1529
 
1530
static float64 float64NextQInP2( sequenceT *sequencePtr )
1531
{
1532
    uint8 expNum, sigNum;
1533
    float64 z;
1534
 
1535
    sigNum = sequencePtr->term1Num;
1536
    expNum = sequencePtr->expNum;
1537
    SETFLOAT64(
1538
        z,
1539
        float64QIn[ expNum ] | float64P2[ sigNum ].high,
1540
        float64P2[ sigNum ].low
1541
    );
1542
    ++sigNum;
1543
    if ( float64NumP2 <= sigNum ) {
1544
        sigNum = 0;
1545
        ++expNum;
1546
        if ( float64NumQIn <= expNum ) {
1547
            expNum = 0;
1548
            sequencePtr->done = TRUE;
1549
        }
1550
        sequencePtr->expNum = expNum;
1551
    }
1552
    sequencePtr->term1Num = sigNum;
1553
    return z;
1554
 
1555
}
1556
 
1557
static float64 float64NextQOutP2( sequenceT *sequencePtr )
1558
{
1559
    uint8 expNum, sigNum;
1560
    float64 z;
1561
 
1562
    sigNum = sequencePtr->term1Num;
1563
    expNum = sequencePtr->expNum;
1564
    SETFLOAT64(
1565
        z,
1566
        float64QOut[ expNum ] | float64P2[ sigNum ].high,
1567
        float64P2[ sigNum ].low
1568
    );
1569
    ++sigNum;
1570
    if ( float64NumP2 <= sigNum ) {
1571
        sigNum = 0;
1572
        ++expNum;
1573
        if ( float64NumQOut <= expNum ) {
1574
            expNum = 0;
1575
            sequencePtr->done = TRUE;
1576
        }
1577
        sequencePtr->expNum = expNum;
1578
    }
1579
    sequencePtr->term1Num = sigNum;
1580
    return z;
1581
 
1582
}
1583
 
1584
static float64 float64RandomQOutP3( void )
1585
{
1586
    int8 sigNum1, sigNum2;
1587
    uint32 sig1Low, sig2Low, zLow;
1588
    float64 z;
1589
 
1590
    sigNum1 = randomUint8() % float64NumP2;
1591
    sigNum2 = randomUint8() % float64NumP2;
1592
    sig1Low = float64P2[ sigNum1 ].low;
1593
    sig2Low = float64P2[ sigNum2 ].low;
1594
    zLow = sig1Low + sig2Low;
1595
    SETFLOAT64(
1596
        z,
1597
          float64QOut[ randomUint8() % float64NumQOut ]
1598
        | (   (   float64P2[ sigNum1 ].high
1599
                + float64P2[ sigNum2 ].high
1600
                + ( zLow < sig1Low )
1601
              )
1602
            & 0x000FFFFF
1603
          ),
1604
        zLow
1605
    );
1606
    return z;
1607
 
1608
}
1609
 
1610
static float64 float64RandomQOutPInf( void )
1611
{
1612
    float64 z;
1613
 
1614
    SETFLOAT64(
1615
        z,
1616
          float64QOut[ randomUint8() % float64NumQOut ]
1617
        | ( randomUint32() & 0x000FFFFF ),
1618
        randomUint32()
1619
    );
1620
    return z;
1621
 
1622
}
1623
 
1624
enum {
1625
    float64NumQInfWeightMasks = 10
1626
};
1627
 
1628
static const uint32 float64QInfWeightMasks[ float64NumQInfWeightMasks ] = {
1629
    0x7FF00000,
1630
    0x7FF00000,
1631
    0x3FF00000,
1632
    0x1FF00000,
1633
    0x0FF00000,
1634
    0x07F00000,
1635
    0x03F00000,
1636
    0x01F00000,
1637
    0x00F00000,
1638
    0x00700000
1639
};
1640
 
1641
static const uint32 float64QInfWeightOffsets[ float64NumQInfWeightMasks ] = {
1642
    0x00000000,
1643
    0x00000000,
1644
    0x20000000,
1645
    0x30000000,
1646
    0x38000000,
1647
    0x3C000000,
1648
    0x3E000000,
1649
    0x3F000000,
1650
    0x3F800000,
1651
    0x3FC00000
1652
};
1653
 
1654
static float64 float64RandomQInfP3( void )
1655
{
1656
    int8 sigNum1, sigNum2;
1657
    uint32 sig1Low, sig2Low, zLow;
1658
    int8 weightMaskNum;
1659
    float64 z;
1660
 
1661
    sigNum1 = randomUint8() % float64NumP2;
1662
    sigNum2 = randomUint8() % float64NumP2;
1663
    sig1Low = float64P2[ sigNum1 ].low;
1664
    sig2Low = float64P2[ sigNum2 ].low;
1665
    zLow = sig1Low + sig2Low;
1666
    weightMaskNum = randomUint8() % float64NumQInfWeightMasks;
1667
    SETFLOAT64(
1668
        z,
1669
          ( ( (uint32) ( randomUint8() & 1 ) )<<31 )
1670
        | (   (   ( ( (uint32) ( randomUint16() & 0xFFF ) )<<20 )
1671
                & float64QInfWeightMasks[ weightMaskNum ] )
1672
            + float64QInfWeightOffsets[ weightMaskNum ]
1673
          )
1674
        | (   (   float64P2[ sigNum1 ].high
1675
                + float64P2[ sigNum2 ].high
1676
                + ( zLow < sig1Low )
1677
              )
1678
            & 0x000FFFFF
1679
          ),
1680
        zLow
1681
    );
1682
    return z;
1683
 
1684
}
1685
 
1686
static float64 float64RandomQInfPInf( void )
1687
{
1688
    int8 weightMaskNum;
1689
    float64 z;
1690
 
1691
    weightMaskNum = randomUint8() % float64NumQInfWeightMasks;
1692
    SETFLOAT64(
1693
        z,
1694
          ( ( (uint32) ( randomUint8() & 1 ) )<<31 )
1695
        | (   (   ( ( (uint32) ( randomUint16() & 0xFFF ) )<<20 )
1696
                & float64QInfWeightMasks[ weightMaskNum ] )
1697
            + float64QInfWeightOffsets[ weightMaskNum ]
1698
          )
1699
        | ( randomUint32() & 0x000FFFFF ),
1700
        randomUint32()
1701
    );
1702
    return z;
1703
 
1704
}
1705
 
1706
static float64 float64Random( void )
1707
{
1708
 
1709
    switch ( randomUint8() & 7 ) {
1710
     case 0:
1711
     case 1:
1712
     case 2:
1713
        return float64RandomQOutP3();
1714
     case 3:
1715
        return float64RandomQOutPInf();
1716
     case 4:
1717
     case 5:
1718
     case 6:
1719
        return float64RandomQInfP3();
1720
     case 7:
1721
        return float64RandomQInfPInf();
1722
    default:
1723
      // Added this - GCC warning that control reached end of non-void return
1724
      // function, but we actually cover all cases here (0-7) for the 3-bit
1725
      // value that results from the masking in the switch() - JB
1726
      return 0;
1727
    }
1728
 
1729
}
1730
 
1731
#ifdef FLOATX80
1732
 
1733
enum {
1734
    floatx80NumQIn  =  22,
1735
    floatx80NumQOut =  76,
1736
    floatx80NumP1   =   4,
1737
    floatx80NumP2   = 248
1738
};
1739
 
1740
static const uint16 floatx80QIn[ floatx80NumQIn ] = {
1741
    0x0000,             /* positive, subnormal          */
1742
    0x0001,             /* positive, -16382             */
1743
    0x3FBF,             /* positive,    -64             */
1744
    0x3FFD,             /* positive,     -2             */
1745
    0x3FFE,             /* positive,     -1             */
1746
    0x3FFF,             /* positive,      0             */
1747
    0x4000,             /* positive,      1             */
1748
    0x4001,             /* positive,      2             */
1749
    0x403F,             /* positive,     64             */
1750
    0x7FFE,             /* positive,  16383             */
1751
    0x7FFF,             /* positive, infinity or NaN    */
1752
    0x8000,             /* negative, subnormal          */
1753
    0x8001,             /* negative, -16382             */
1754
    0xBFBF,             /* negative,    -64             */
1755
    0xBFFD,             /* negative,     -2             */
1756
    0xBFFE,             /* negative,     -1             */
1757
    0xBFFF,             /* negative,      0             */
1758
    0xC000,             /* negative,      1             */
1759
    0xC001,             /* negative,      2             */
1760
    0xC03F,             /* negative,     64             */
1761
    0xFFFE,             /* negative,  16383             */
1762
    0xFFFF              /* negative, infinity or NaN    */
1763
};
1764
 
1765
static const uint16 floatx80QOut[ floatx80NumQOut ] = {
1766
    0x0000,             /* positive, subnormal          */
1767
    0x0001,             /* positive, -16382             */
1768
    0x0002,             /* positive, -16381             */
1769
    0x3BFE,             /* positive,  -1025             */
1770
    0x3BFF,             /* positive,  -1024             */
1771
    0x3C00,             /* positive,  -1023             */
1772
    0x3C01,             /* positive,  -1022             */
1773
    0x3F7E,             /* positive,   -129             */
1774
    0x3F7F,             /* positive,   -128             */
1775
    0x3F80,             /* positive,   -127             */
1776
    0x3F81,             /* positive,   -126             */
1777
    0x3FBF,             /* positive,    -64             */
1778
    0x3FFB,             /* positive,     -4             */
1779
    0x3FFC,             /* positive,     -3             */
1780
    0x3FFD,             /* positive,     -2             */
1781
    0x3FFE,             /* positive,     -1             */
1782
    0x3FFF,             /* positive,      0             */
1783
    0x4000,             /* positive,      1             */
1784
    0x4001,             /* positive,      2             */
1785
    0x4002,             /* positive,      3             */
1786
    0x4003,             /* positive,      4             */
1787
    0x401C,             /* positive,     29             */
1788
    0x401D,             /* positive,     30             */
1789
    0x401E,             /* positive,     31             */
1790
    0x401F,             /* positive,     32             */
1791
    0x403C,             /* positive,     61             */
1792
    0x403D,             /* positive,     62             */
1793
    0x403E,             /* positive,     63             */
1794
    0x403F,             /* positive,     64             */
1795
    0x407E,             /* positive,    127             */
1796
    0x407F,             /* positive,    128             */
1797
    0x4080,             /* positive,    129             */
1798
    0x43FE,             /* positive,   1023             */
1799
    0x43FF,             /* positive,   1024             */
1800
    0x4400,             /* positive,   1025             */
1801
    0x7FFD,             /* positive,  16382             */
1802
    0x7FFE,             /* positive,  16383             */
1803
    0x7FFF,             /* positive, infinity or NaN    */
1804
    0x8000,             /* negative, subnormal          */
1805
    0x8001,             /* negative, -16382             */
1806
    0x8002,             /* negative, -16381             */
1807
    0xBBFE,             /* negative,  -1025             */
1808
    0xBBFF,             /* negative,  -1024             */
1809
    0xBC00,             /* negative,  -1023             */
1810
    0xBC01,             /* negative,  -1022             */
1811
    0xBF7E,             /* negative,   -129             */
1812
    0xBF7F,             /* negative,   -128             */
1813
    0xBF80,             /* negative,   -127             */
1814
    0xBF81,             /* negative,   -126             */
1815
    0xBFBF,             /* negative,    -64             */
1816
    0xBFFB,             /* negative,     -4             */
1817
    0xBFFC,             /* negative,     -3             */
1818
    0xBFFD,             /* negative,     -2             */
1819
    0xBFFE,             /* negative,     -1             */
1820
    0xBFFF,             /* negative,      0             */
1821
    0xC000,             /* negative,      1             */
1822
    0xC001,             /* negative,      2             */
1823
    0xC002,             /* negative,      3             */
1824
    0xC003,             /* negative,      4             */
1825
    0xC01C,             /* negative,     29             */
1826
    0xC01D,             /* negative,     30             */
1827
    0xC01E,             /* negative,     31             */
1828
    0xC01F,             /* negative,     32             */
1829
    0xC03C,             /* negative,     61             */
1830
    0xC03D,             /* negative,     62             */
1831
    0xC03E,             /* negative,     63             */
1832
    0xC03F,             /* negative,     64             */
1833
    0xC07E,             /* negative,    127             */
1834
    0xC07F,             /* negative,    128             */
1835
    0xC080,             /* negative,    129             */
1836
    0xC3FE,             /* negative,   1023             */
1837
    0xC3FF,             /* negative,   1024             */
1838
    0xC400,             /* negative,   1025             */
1839
    0xFFFD,             /* negative,  16382             */
1840
    0xFFFE,             /* negative,  16383             */
1841
    0xFFFF              /* negative, infinity or NaN    */
1842
};
1843
 
1844
static const bits64 floatx80P1[ floatx80NumP1 ] = {
1845
    LIT64( 0x0000000000000000 ),
1846
    LIT64( 0x0000000000000001 ),
1847
    LIT64( 0x7FFFFFFFFFFFFFFF ),
1848
    LIT64( 0x7FFFFFFFFFFFFFFE )
1849
};
1850
 
1851
static const bits64 floatx80P2[ floatx80NumP2 ] = {
1852
    LIT64( 0x0000000000000000 ),
1853
    LIT64( 0x0000000000000001 ),
1854
    LIT64( 0x0000000000000002 ),
1855
    LIT64( 0x0000000000000004 ),
1856
    LIT64( 0x0000000000000008 ),
1857
    LIT64( 0x0000000000000010 ),
1858
    LIT64( 0x0000000000000020 ),
1859
    LIT64( 0x0000000000000040 ),
1860
    LIT64( 0x0000000000000080 ),
1861
    LIT64( 0x0000000000000100 ),
1862
    LIT64( 0x0000000000000200 ),
1863
    LIT64( 0x0000000000000400 ),
1864
    LIT64( 0x0000000000000800 ),
1865
    LIT64( 0x0000000000001000 ),
1866
    LIT64( 0x0000000000002000 ),
1867
    LIT64( 0x0000000000004000 ),
1868
    LIT64( 0x0000000000008000 ),
1869
    LIT64( 0x0000000000010000 ),
1870
    LIT64( 0x0000000000020000 ),
1871
    LIT64( 0x0000000000040000 ),
1872
    LIT64( 0x0000000000080000 ),
1873
    LIT64( 0x0000000000100000 ),
1874
    LIT64( 0x0000000000200000 ),
1875
    LIT64( 0x0000000000400000 ),
1876
    LIT64( 0x0000000000800000 ),
1877
    LIT64( 0x0000000001000000 ),
1878
    LIT64( 0x0000000002000000 ),
1879
    LIT64( 0x0000000004000000 ),
1880
    LIT64( 0x0000000008000000 ),
1881
    LIT64( 0x0000000010000000 ),
1882
    LIT64( 0x0000000020000000 ),
1883
    LIT64( 0x0000000040000000 ),
1884
    LIT64( 0x0000000080000000 ),
1885
    LIT64( 0x0000000100000000 ),
1886
    LIT64( 0x0000000200000000 ),
1887
    LIT64( 0x0000000400000000 ),
1888
    LIT64( 0x0000000800000000 ),
1889
    LIT64( 0x0000001000000000 ),
1890
    LIT64( 0x0000002000000000 ),
1891
    LIT64( 0x0000004000000000 ),
1892
    LIT64( 0x0000008000000000 ),
1893
    LIT64( 0x0000010000000000 ),
1894
    LIT64( 0x0000020000000000 ),
1895
    LIT64( 0x0000040000000000 ),
1896
    LIT64( 0x0000080000000000 ),
1897
    LIT64( 0x0000100000000000 ),
1898
    LIT64( 0x0000200000000000 ),
1899
    LIT64( 0x0000400000000000 ),
1900
    LIT64( 0x0000800000000000 ),
1901
    LIT64( 0x0001000000000000 ),
1902
    LIT64( 0x0002000000000000 ),
1903
    LIT64( 0x0004000000000000 ),
1904
    LIT64( 0x0008000000000000 ),
1905
    LIT64( 0x0010000000000000 ),
1906
    LIT64( 0x0020000000000000 ),
1907
    LIT64( 0x0040000000000000 ),
1908
    LIT64( 0x0080000000000000 ),
1909
    LIT64( 0x0100000000000000 ),
1910
    LIT64( 0x0200000000000000 ),
1911
    LIT64( 0x0400000000000000 ),
1912
    LIT64( 0x0800000000000000 ),
1913
    LIT64( 0x1000000000000000 ),
1914
    LIT64( 0x2000000000000000 ),
1915
    LIT64( 0x4000000000000000 ),
1916
    LIT64( 0x6000000000000000 ),
1917
    LIT64( 0x7000000000000000 ),
1918
    LIT64( 0x7800000000000000 ),
1919
    LIT64( 0x7C00000000000000 ),
1920
    LIT64( 0x7E00000000000000 ),
1921
    LIT64( 0x7F00000000000000 ),
1922
    LIT64( 0x7F80000000000000 ),
1923
    LIT64( 0x7FC0000000000000 ),
1924
    LIT64( 0x7FE0000000000000 ),
1925
    LIT64( 0x7FF0000000000000 ),
1926
    LIT64( 0x7FF8000000000000 ),
1927
    LIT64( 0x7FFC000000000000 ),
1928
    LIT64( 0x7FFE000000000000 ),
1929
    LIT64( 0x7FFF000000000000 ),
1930
    LIT64( 0x7FFF800000000000 ),
1931
    LIT64( 0x7FFFC00000000000 ),
1932
    LIT64( 0x7FFFE00000000000 ),
1933
    LIT64( 0x7FFFF00000000000 ),
1934
    LIT64( 0x7FFFF80000000000 ),
1935
    LIT64( 0x7FFFFC0000000000 ),
1936
    LIT64( 0x7FFFFE0000000000 ),
1937
    LIT64( 0x7FFFFF0000000000 ),
1938
    LIT64( 0x7FFFFF8000000000 ),
1939
    LIT64( 0x7FFFFFC000000000 ),
1940
    LIT64( 0x7FFFFFE000000000 ),
1941
    LIT64( 0x7FFFFFF000000000 ),
1942
    LIT64( 0x7FFFFFF800000000 ),
1943
    LIT64( 0x7FFFFFFC00000000 ),
1944
    LIT64( 0x7FFFFFFE00000000 ),
1945
    LIT64( 0x7FFFFFFF00000000 ),
1946
    LIT64( 0x7FFFFFFF80000000 ),
1947
    LIT64( 0x7FFFFFFFC0000000 ),
1948
    LIT64( 0x7FFFFFFFE0000000 ),
1949
    LIT64( 0x7FFFFFFFF0000000 ),
1950
    LIT64( 0x7FFFFFFFF8000000 ),
1951
    LIT64( 0x7FFFFFFFFC000000 ),
1952
    LIT64( 0x7FFFFFFFFE000000 ),
1953
    LIT64( 0x7FFFFFFFFF000000 ),
1954
    LIT64( 0x7FFFFFFFFF800000 ),
1955
    LIT64( 0x7FFFFFFFFFC00000 ),
1956
    LIT64( 0x7FFFFFFFFFE00000 ),
1957
    LIT64( 0x7FFFFFFFFFF00000 ),
1958
    LIT64( 0x7FFFFFFFFFF80000 ),
1959
    LIT64( 0x7FFFFFFFFFFC0000 ),
1960
    LIT64( 0x7FFFFFFFFFFE0000 ),
1961
    LIT64( 0x7FFFFFFFFFFF0000 ),
1962
    LIT64( 0x7FFFFFFFFFFF8000 ),
1963
    LIT64( 0x7FFFFFFFFFFFC000 ),
1964
    LIT64( 0x7FFFFFFFFFFFE000 ),
1965
    LIT64( 0x7FFFFFFFFFFFF000 ),
1966
    LIT64( 0x7FFFFFFFFFFFF800 ),
1967
    LIT64( 0x7FFFFFFFFFFFFC00 ),
1968
    LIT64( 0x7FFFFFFFFFFFFE00 ),
1969
    LIT64( 0x7FFFFFFFFFFFFF00 ),
1970
    LIT64( 0x7FFFFFFFFFFFFF80 ),
1971
    LIT64( 0x7FFFFFFFFFFFFFC0 ),
1972
    LIT64( 0x7FFFFFFFFFFFFFE0 ),
1973
    LIT64( 0x7FFFFFFFFFFFFFF0 ),
1974
    LIT64( 0x7FFFFFFFFFFFFFF8 ),
1975
    LIT64( 0x7FFFFFFFFFFFFFFC ),
1976
    LIT64( 0x7FFFFFFFFFFFFFFE ),
1977
    LIT64( 0x7FFFFFFFFFFFFFFF ),
1978
    LIT64( 0x7FFFFFFFFFFFFFFD ),
1979
    LIT64( 0x7FFFFFFFFFFFFFFB ),
1980
    LIT64( 0x7FFFFFFFFFFFFFF7 ),
1981
    LIT64( 0x7FFFFFFFFFFFFFEF ),
1982
    LIT64( 0x7FFFFFFFFFFFFFDF ),
1983
    LIT64( 0x7FFFFFFFFFFFFFBF ),
1984
    LIT64( 0x7FFFFFFFFFFFFF7F ),
1985
    LIT64( 0x7FFFFFFFFFFFFEFF ),
1986
    LIT64( 0x7FFFFFFFFFFFFDFF ),
1987
    LIT64( 0x7FFFFFFFFFFFFBFF ),
1988
    LIT64( 0x7FFFFFFFFFFFF7FF ),
1989
    LIT64( 0x7FFFFFFFFFFFEFFF ),
1990
    LIT64( 0x7FFFFFFFFFFFDFFF ),
1991
    LIT64( 0x7FFFFFFFFFFFBFFF ),
1992
    LIT64( 0x7FFFFFFFFFFF7FFF ),
1993
    LIT64( 0x7FFFFFFFFFFEFFFF ),
1994
    LIT64( 0x7FFFFFFFFFFDFFFF ),
1995
    LIT64( 0x7FFFFFFFFFFBFFFF ),
1996
    LIT64( 0x7FFFFFFFFFF7FFFF ),
1997
    LIT64( 0x7FFFFFFFFFEFFFFF ),
1998
    LIT64( 0x7FFFFFFFFFDFFFFF ),
1999
    LIT64( 0x7FFFFFFFFFBFFFFF ),
2000
    LIT64( 0x7FFFFFFFFF7FFFFF ),
2001
    LIT64( 0x7FFFFFFFFEFFFFFF ),
2002
    LIT64( 0x7FFFFFFFFDFFFFFF ),
2003
    LIT64( 0x7FFFFFFFFBFFFFFF ),
2004
    LIT64( 0x7FFFFFFFF7FFFFFF ),
2005
    LIT64( 0x7FFFFFFFEFFFFFFF ),
2006
    LIT64( 0x7FFFFFFFDFFFFFFF ),
2007
    LIT64( 0x7FFFFFFFBFFFFFFF ),
2008
    LIT64( 0x7FFFFFFF7FFFFFFF ),
2009
    LIT64( 0x7FFFFFFEFFFFFFFF ),
2010
    LIT64( 0x7FFFFFFDFFFFFFFF ),
2011
    LIT64( 0x7FFFFFFBFFFFFFFF ),
2012
    LIT64( 0x7FFFFFF7FFFFFFFF ),
2013
    LIT64( 0x7FFFFFEFFFFFFFFF ),
2014
    LIT64( 0x7FFFFFDFFFFFFFFF ),
2015
    LIT64( 0x7FFFFFBFFFFFFFFF ),
2016
    LIT64( 0x7FFFFF7FFFFFFFFF ),
2017
    LIT64( 0x7FFFFEFFFFFFFFFF ),
2018
    LIT64( 0x7FFFFDFFFFFFFFFF ),
2019
    LIT64( 0x7FFFFBFFFFFFFFFF ),
2020
    LIT64( 0x7FFFF7FFFFFFFFFF ),
2021
    LIT64( 0x7FFFEFFFFFFFFFFF ),
2022
    LIT64( 0x7FFFDFFFFFFFFFFF ),
2023
    LIT64( 0x7FFFBFFFFFFFFFFF ),
2024
    LIT64( 0x7FFF7FFFFFFFFFFF ),
2025
    LIT64( 0x7FFEFFFFFFFFFFFF ),
2026
    LIT64( 0x7FFDFFFFFFFFFFFF ),
2027
    LIT64( 0x7FFBFFFFFFFFFFFF ),
2028
    LIT64( 0x7FF7FFFFFFFFFFFF ),
2029
    LIT64( 0x7FEFFFFFFFFFFFFF ),
2030
    LIT64( 0x7FDFFFFFFFFFFFFF ),
2031
    LIT64( 0x7FBFFFFFFFFFFFFF ),
2032
    LIT64( 0x7F7FFFFFFFFFFFFF ),
2033
    LIT64( 0x7EFFFFFFFFFFFFFF ),
2034
    LIT64( 0x7DFFFFFFFFFFFFFF ),
2035
    LIT64( 0x7BFFFFFFFFFFFFFF ),
2036
    LIT64( 0x77FFFFFFFFFFFFFF ),
2037
    LIT64( 0x6FFFFFFFFFFFFFFF ),
2038
    LIT64( 0x5FFFFFFFFFFFFFFF ),
2039
    LIT64( 0x3FFFFFFFFFFFFFFF ),
2040
    LIT64( 0x1FFFFFFFFFFFFFFF ),
2041
    LIT64( 0x0FFFFFFFFFFFFFFF ),
2042
    LIT64( 0x07FFFFFFFFFFFFFF ),
2043
    LIT64( 0x03FFFFFFFFFFFFFF ),
2044
    LIT64( 0x01FFFFFFFFFFFFFF ),
2045
    LIT64( 0x00FFFFFFFFFFFFFF ),
2046
    LIT64( 0x007FFFFFFFFFFFFF ),
2047
    LIT64( 0x003FFFFFFFFFFFFF ),
2048
    LIT64( 0x001FFFFFFFFFFFFF ),
2049
    LIT64( 0x000FFFFFFFFFFFFF ),
2050
    LIT64( 0x0007FFFFFFFFFFFF ),
2051
    LIT64( 0x0003FFFFFFFFFFFF ),
2052
    LIT64( 0x0001FFFFFFFFFFFF ),
2053
    LIT64( 0x0000FFFFFFFFFFFF ),
2054
    LIT64( 0x00007FFFFFFFFFFF ),
2055
    LIT64( 0x00003FFFFFFFFFFF ),
2056
    LIT64( 0x00001FFFFFFFFFFF ),
2057
    LIT64( 0x00000FFFFFFFFFFF ),
2058
    LIT64( 0x000007FFFFFFFFFF ),
2059
    LIT64( 0x000003FFFFFFFFFF ),
2060
    LIT64( 0x000001FFFFFFFFFF ),
2061
    LIT64( 0x000000FFFFFFFFFF ),
2062
    LIT64( 0x0000007FFFFFFFFF ),
2063
    LIT64( 0x0000003FFFFFFFFF ),
2064
    LIT64( 0x0000001FFFFFFFFF ),
2065
    LIT64( 0x0000000FFFFFFFFF ),
2066
    LIT64( 0x00000007FFFFFFFF ),
2067
    LIT64( 0x00000003FFFFFFFF ),
2068
    LIT64( 0x00000001FFFFFFFF ),
2069
    LIT64( 0x00000000FFFFFFFF ),
2070
    LIT64( 0x000000007FFFFFFF ),
2071
    LIT64( 0x000000003FFFFFFF ),
2072
    LIT64( 0x000000001FFFFFFF ),
2073
    LIT64( 0x000000000FFFFFFF ),
2074
    LIT64( 0x0000000007FFFFFF ),
2075
    LIT64( 0x0000000003FFFFFF ),
2076
    LIT64( 0x0000000001FFFFFF ),
2077
    LIT64( 0x0000000000FFFFFF ),
2078
    LIT64( 0x00000000007FFFFF ),
2079
    LIT64( 0x00000000003FFFFF ),
2080
    LIT64( 0x00000000001FFFFF ),
2081
    LIT64( 0x00000000000FFFFF ),
2082
    LIT64( 0x000000000007FFFF ),
2083
    LIT64( 0x000000000003FFFF ),
2084
    LIT64( 0x000000000001FFFF ),
2085
    LIT64( 0x000000000000FFFF ),
2086
    LIT64( 0x0000000000007FFF ),
2087
    LIT64( 0x0000000000003FFF ),
2088
    LIT64( 0x0000000000001FFF ),
2089
    LIT64( 0x0000000000000FFF ),
2090
    LIT64( 0x00000000000007FF ),
2091
    LIT64( 0x00000000000003FF ),
2092
    LIT64( 0x00000000000001FF ),
2093
    LIT64( 0x00000000000000FF ),
2094
    LIT64( 0x000000000000007F ),
2095
    LIT64( 0x000000000000003F ),
2096
    LIT64( 0x000000000000001F ),
2097
    LIT64( 0x000000000000000F ),
2098
    LIT64( 0x0000000000000007 ),
2099
    LIT64( 0x0000000000000003 )
2100
};
2101
 
2102
static const uint32 floatx80NumQInP1 = floatx80NumQIn * floatx80NumP1;
2103
static const uint32 floatx80NumQOutP1 = floatx80NumQOut * floatx80NumP1;
2104
 
2105
static floatx80 floatx80NextQInP1( sequenceT *sequencePtr )
2106
{
2107
    int16 expNum, sigNum;
2108
    floatx80 z;
2109
 
2110
    sigNum = sequencePtr->term1Num;
2111
    expNum = sequencePtr->expNum;
2112
    z.low = floatx80P1[ sigNum ];
2113
    z.high = floatx80QIn[ expNum ];
2114
    if ( z.high & 0x7FFF ) z.low |= LIT64( 0x8000000000000000 );
2115
    ++sigNum;
2116
    if ( floatx80NumP1 <= sigNum ) {
2117
        sigNum = 0;
2118
        ++expNum;
2119
        if ( floatx80NumQIn <= expNum ) {
2120
            expNum = 0;
2121
            sequencePtr->done = TRUE;
2122
        }
2123
        sequencePtr->expNum = expNum;
2124
    }
2125
    sequencePtr->term1Num = sigNum;
2126
    return z;
2127
 
2128
}
2129
 
2130
static floatx80 floatx80NextQOutP1( sequenceT *sequencePtr )
2131
{
2132
    int16 expNum, sigNum;
2133
    floatx80 z;
2134
 
2135
    sigNum = sequencePtr->term1Num;
2136
    expNum = sequencePtr->expNum;
2137
    z.low = floatx80P1[ sigNum ];
2138
    z.high = floatx80QOut[ expNum ];
2139
    if ( z.high & 0x7FFF ) z.low |= LIT64( 0x8000000000000000 );
2140
    ++sigNum;
2141
    if ( floatx80NumP1 <= sigNum ) {
2142
        sigNum = 0;
2143
        ++expNum;
2144
        if ( floatx80NumQOut <= expNum ) {
2145
            expNum = 0;
2146
            sequencePtr->done = TRUE;
2147
        }
2148
        sequencePtr->expNum = expNum;
2149
    }
2150
    sequencePtr->term1Num = sigNum;
2151
    return z;
2152
 
2153
}
2154
 
2155
static const uint32 floatx80NumQInP2 = floatx80NumQIn * floatx80NumP2;
2156
static const uint32 floatx80NumQOutP2 = floatx80NumQOut * floatx80NumP2;
2157
 
2158
static floatx80 floatx80NextQInP2( sequenceT *sequencePtr )
2159
{
2160
    int16 expNum, sigNum;
2161
    floatx80 z;
2162
 
2163
    sigNum = sequencePtr->term1Num;
2164
    expNum = sequencePtr->expNum;
2165
    z.low = floatx80P2[ sigNum ];
2166
    z.high = floatx80QIn[ expNum ];
2167
    if ( z.high & 0x7FFF ) z.low |= LIT64( 0x8000000000000000 );
2168
    ++sigNum;
2169
    if ( floatx80NumP2 <= sigNum ) {
2170
        sigNum = 0;
2171
        ++expNum;
2172
        if ( floatx80NumQIn <= expNum ) {
2173
            expNum = 0;
2174
            sequencePtr->done = TRUE;
2175
        }
2176
        sequencePtr->expNum = expNum;
2177
    }
2178
    sequencePtr->term1Num = sigNum;
2179
    return z;
2180
 
2181
}
2182
 
2183
static floatx80 floatx80NextQOutP2( sequenceT *sequencePtr )
2184
{
2185
    int16 expNum, sigNum;
2186
    floatx80 z;
2187
 
2188
    sigNum = sequencePtr->term1Num;
2189
    expNum = sequencePtr->expNum;
2190
    z.low = floatx80P2[ sigNum ];
2191
    z.high = floatx80QOut[ expNum ];
2192
    if ( z.high & 0x7FFF ) z.low |= LIT64( 0x8000000000000000 );
2193
    ++sigNum;
2194
    if ( floatx80NumP2 <= sigNum ) {
2195
        sigNum = 0;
2196
        ++expNum;
2197
        if ( floatx80NumQOut <= expNum ) {
2198
            expNum = 0;
2199
            sequencePtr->done = TRUE;
2200
        }
2201
        sequencePtr->expNum = expNum;
2202
    }
2203
    sequencePtr->term1Num = sigNum;
2204
    return z;
2205
 
2206
}
2207
 
2208
static floatx80 floatx80RandomQOutP3( void )
2209
{
2210
    floatx80 z;
2211
 
2212
    z.low =
2213
          (   floatx80P2[ randomUint8() % floatx80NumP2 ]
2214
            + floatx80P2[ randomUint8() % floatx80NumP2 ] )
2215
        & LIT64( 0x7FFFFFFFFFFFFFFF );
2216
    z.high = floatx80QOut[ randomUint8() % floatx80NumQOut ];
2217
    if ( z.high & 0x7FFF ) z.low |= LIT64( 0x8000000000000000 );
2218
    return z;
2219
 
2220
}
2221
 
2222
static floatx80 floatx80RandomQOutPInf( void )
2223
{
2224
    floatx80 z;
2225
 
2226
    z.low = randomUint64() & LIT64( 0x7FFFFFFFFFFFFFFF );
2227
    z.high = floatx80QOut[ randomUint8() % floatx80NumQOut ];
2228
    if ( z.high & 0x7FFF ) z.low |= LIT64( 0x8000000000000000 );
2229
    return z;
2230
 
2231
}
2232
 
2233
enum {
2234
    floatx80NumQInfWeightMasks = 14
2235
};
2236
 
2237
static const uint16 floatx80QInfWeightMasks[ floatx80NumQInfWeightMasks ] = {
2238
    0x7FFF,
2239
    0x7FFF,
2240
    0x3FFF,
2241
    0x1FFF,
2242
    0x07FF,
2243
    0x07FF,
2244
    0x03FF,
2245
    0x01FF,
2246
    0x00FF,
2247
    0x007F,
2248
    0x003F,
2249
    0x001F,
2250
    0x000F,
2251
    0x0007
2252
};
2253
 
2254
static const uint16 floatx80QInfWeightOffsets[ floatx80NumQInfWeightMasks ] = {
2255
    0x0000,
2256
    0x0000,
2257
    0x2000,
2258
    0x3000,
2259
    0x3800,
2260
    0x3C00,
2261
    0x3E00,
2262
    0x3F00,
2263
    0x3F80,
2264
    0x3FC0,
2265
    0x3FE0,
2266
    0x3FF0,
2267
    0x3FF8,
2268
    0x3FFC
2269
};
2270
 
2271
static floatx80 floatx80RandomQInfP3( void )
2272
{
2273
    int8 weightMaskNum;
2274
    floatx80 z;
2275
 
2276
    z.low =
2277
          (   floatx80P2[ randomUint8() % floatx80NumP2 ]
2278
            + floatx80P2[ randomUint8() % floatx80NumP2 ] )
2279
        & LIT64( 0x7FFFFFFFFFFFFFFF );
2280
    weightMaskNum = randomUint8() % floatx80NumQInfWeightMasks;
2281
    z.high =
2282
          randomUint16() & floatx80QInfWeightMasks[ weightMaskNum ]
2283
        + floatx80QInfWeightOffsets[ weightMaskNum ];
2284
    if ( z.high ) z.low |= LIT64( 0x8000000000000000 );
2285
    z.high |= ( (uint16) ( randomUint8() & 1 ) )<<15;
2286
    return z;
2287
 
2288
}
2289
 
2290
static floatx80 floatx80RandomQInfPInf( void )
2291
{
2292
    int8 weightMaskNum;
2293
    floatx80 z;
2294
 
2295
    z.low = randomUint64() & LIT64( 0x7FFFFFFFFFFFFFFF );
2296
    weightMaskNum = randomUint8() % floatx80NumQInfWeightMasks;
2297
    z.high =
2298
          randomUint16() & floatx80QInfWeightMasks[ weightMaskNum ]
2299
        + floatx80QInfWeightOffsets[ weightMaskNum ];
2300
    if ( z.high ) z.low |= LIT64( 0x8000000000000000 );
2301
    z.high |= ( (uint16) ( randomUint8() & 1 ) )<<15;
2302
    return z;
2303
 
2304
}
2305
 
2306
static floatx80 floatx80Random( void )
2307
{
2308
 
2309
    switch ( randomUint8() & 7 ) {
2310
     case 0:
2311
     case 1:
2312
     case 2:
2313
        return floatx80RandomQOutP3();
2314
     case 3:
2315
        return floatx80RandomQOutPInf();
2316
     case 4:
2317
     case 5:
2318
     case 6:
2319
        return floatx80RandomQInfP3();
2320
     case 7:
2321
        return floatx80RandomQInfPInf();
2322
    }
2323
 
2324
}
2325
 
2326
#endif
2327
 
2328
#ifdef FLOAT128
2329
 
2330
enum {
2331
    float128NumQIn  =  22,
2332
    float128NumQOut =  78,
2333
    float128NumP1   =   4,
2334
    float128NumP2   = 443
2335
};
2336
 
2337
static const uint64 float128QIn[ float128NumQIn ] = {
2338
    LIT64( 0x0000000000000000 ),        /* positive, subnormal          */
2339
    LIT64( 0x0001000000000000 ),        /* positive, -16382             */
2340
    LIT64( 0x3F8E000000000000 ),        /* positive,   -113             */
2341
    LIT64( 0x3FFD000000000000 ),        /* positive,     -2             */
2342
    LIT64( 0x3FFE000000000000 ),        /* positive,     -1             */
2343
    LIT64( 0x3FFF000000000000 ),        /* positive,      0             */
2344
    LIT64( 0x4000000000000000 ),        /* positive,      1             */
2345
    LIT64( 0x4001000000000000 ),        /* positive,      2             */
2346
    LIT64( 0x4070000000000000 ),        /* positive,    113             */
2347
    LIT64( 0x7FFE000000000000 ),        /* positive,  16383             */
2348
    LIT64( 0x7FFF000000000000 ),        /* positive, infinity or NaN    */
2349
    LIT64( 0x8000000000000000 ),        /* negative, subnormal          */
2350
    LIT64( 0x8001000000000000 ),        /* negative, -16382             */
2351
    LIT64( 0xBF8E000000000000 ),        /* negative,   -113             */
2352
    LIT64( 0xBFFD000000000000 ),        /* negative,     -2             */
2353
    LIT64( 0xBFFE000000000000 ),        /* negative,     -1             */
2354
    LIT64( 0xBFFF000000000000 ),        /* negative,      0             */
2355
    LIT64( 0xC000000000000000 ),        /* negative,      1             */
2356
    LIT64( 0xC001000000000000 ),        /* negative,      2             */
2357
    LIT64( 0xC070000000000000 ),        /* negative,    113             */
2358
    LIT64( 0xFFFE000000000000 ),        /* negative,  16383             */
2359
    LIT64( 0xFFFF000000000000 )         /* negative, infinity or NaN    */
2360
};
2361
 
2362
static const uint64 float128QOut[ float128NumQOut ] = {
2363
    LIT64( 0x0000000000000000 ),        /* positive, subnormal          */
2364
    LIT64( 0x0001000000000000 ),        /* positive, -16382             */
2365
    LIT64( 0x0002000000000000 ),        /* positive, -16381             */
2366
    LIT64( 0x3BFE000000000000 ),        /* positive,  -1025             */
2367
    LIT64( 0x3BFF000000000000 ),        /* positive,  -1024             */
2368
    LIT64( 0x3C00000000000000 ),        /* positive,  -1023             */
2369
    LIT64( 0x3C01000000000000 ),        /* positive,  -1022             */
2370
    LIT64( 0x3F7E000000000000 ),        /* positive,   -129             */
2371
    LIT64( 0x3F7F000000000000 ),        /* positive,   -128             */
2372
    LIT64( 0x3F80000000000000 ),        /* positive,   -127             */
2373
    LIT64( 0x3F81000000000000 ),        /* positive,   -126             */
2374
    LIT64( 0x3F8E000000000000 ),        /* positive,   -113             */
2375
    LIT64( 0x3FFB000000000000 ),        /* positive,     -4             */
2376
    LIT64( 0x3FFC000000000000 ),        /* positive,     -3             */
2377
    LIT64( 0x3FFD000000000000 ),        /* positive,     -2             */
2378
    LIT64( 0x3FFE000000000000 ),        /* positive,     -1             */
2379
    LIT64( 0x3FFF000000000000 ),        /* positive,      0             */
2380
    LIT64( 0x4000000000000000 ),        /* positive,      1             */
2381
    LIT64( 0x4001000000000000 ),        /* positive,      2             */
2382
    LIT64( 0x4002000000000000 ),        /* positive,      3             */
2383
    LIT64( 0x4003000000000000 ),        /* positive,      4             */
2384
    LIT64( 0x401C000000000000 ),        /* positive,     29             */
2385
    LIT64( 0x401D000000000000 ),        /* positive,     30             */
2386
    LIT64( 0x401E000000000000 ),        /* positive,     31             */
2387
    LIT64( 0x401F000000000000 ),        /* positive,     32             */
2388
    LIT64( 0x403C000000000000 ),        /* positive,     61             */
2389
    LIT64( 0x403D000000000000 ),        /* positive,     62             */
2390
    LIT64( 0x403E000000000000 ),        /* positive,     63             */
2391
    LIT64( 0x403F000000000000 ),        /* positive,     64             */
2392
    LIT64( 0x4070000000000000 ),        /* positive,    113             */
2393
    LIT64( 0x407E000000000000 ),        /* positive,    127             */
2394
    LIT64( 0x407F000000000000 ),        /* positive,    128             */
2395
    LIT64( 0x4080000000000000 ),        /* positive,    129             */
2396
    LIT64( 0x43FE000000000000 ),        /* positive,   1023             */
2397
    LIT64( 0x43FF000000000000 ),        /* positive,   1024             */
2398
    LIT64( 0x4400000000000000 ),        /* positive,   1025             */
2399
    LIT64( 0x7FFD000000000000 ),        /* positive,  16382             */
2400
    LIT64( 0x7FFE000000000000 ),        /* positive,  16383             */
2401
    LIT64( 0x7FFF000000000000 ),        /* positive, infinity or NaN    */
2402
    LIT64( 0x8000000000000000 ),        /* negative, subnormal          */
2403
    LIT64( 0x8001000000000000 ),        /* negative, -16382             */
2404
    LIT64( 0x8002000000000000 ),        /* negative, -16381             */
2405
    LIT64( 0xBBFE000000000000 ),        /* negative,  -1025             */
2406
    LIT64( 0xBBFF000000000000 ),        /* negative,  -1024             */
2407
    LIT64( 0xBC00000000000000 ),        /* negative,  -1023             */
2408
    LIT64( 0xBC01000000000000 ),        /* negative,  -1022             */
2409
    LIT64( 0xBF7E000000000000 ),        /* negative,   -129             */
2410
    LIT64( 0xBF7F000000000000 ),        /* negative,   -128             */
2411
    LIT64( 0xBF80000000000000 ),        /* negative,   -127             */
2412
    LIT64( 0xBF81000000000000 ),        /* negative,   -126             */
2413
    LIT64( 0xBF8E000000000000 ),        /* negative,   -113             */
2414
    LIT64( 0xBFFB000000000000 ),        /* negative,     -4             */
2415
    LIT64( 0xBFFC000000000000 ),        /* negative,     -3             */
2416
    LIT64( 0xBFFD000000000000 ),        /* negative,     -2             */
2417
    LIT64( 0xBFFE000000000000 ),        /* negative,     -1             */
2418
    LIT64( 0xBFFF000000000000 ),        /* negative,      0             */
2419
    LIT64( 0xC000000000000000 ),        /* negative,      1             */
2420
    LIT64( 0xC001000000000000 ),        /* negative,      2             */
2421
    LIT64( 0xC002000000000000 ),        /* negative,      3             */
2422
    LIT64( 0xC003000000000000 ),        /* negative,      4             */
2423
    LIT64( 0xC01C000000000000 ),        /* negative,     29             */
2424
    LIT64( 0xC01D000000000000 ),        /* negative,     30             */
2425
    LIT64( 0xC01E000000000000 ),        /* negative,     31             */
2426
    LIT64( 0xC01F000000000000 ),        /* negative,     32             */
2427
    LIT64( 0xC03C000000000000 ),        /* negative,     61             */
2428
    LIT64( 0xC03D000000000000 ),        /* negative,     62             */
2429
    LIT64( 0xC03E000000000000 ),        /* negative,     63             */
2430
    LIT64( 0xC03F000000000000 ),        /* negative,     64             */
2431
    LIT64( 0xC070000000000000 ),        /* negative,    113             */
2432
    LIT64( 0xC07E000000000000 ),        /* negative,    127             */
2433
    LIT64( 0xC07F000000000000 ),        /* negative,    128             */
2434
    LIT64( 0xC080000000000000 ),        /* negative,    129             */
2435
    LIT64( 0xC3FE000000000000 ),        /* negative,   1023             */
2436
    LIT64( 0xC3FF000000000000 ),        /* negative,   1024             */
2437
    LIT64( 0xC400000000000000 ),        /* negative,   1025             */
2438
    LIT64( 0xFFFD000000000000 ),        /* negative,  16382             */
2439
    LIT64( 0xFFFE000000000000 ),        /* negative,  16383             */
2440
    LIT64( 0xFFFF000000000000 )         /* negative, infinity or NaN    */
2441
};
2442
 
2443
static const struct { bits64 high, low; } float128P1[ float128NumP1 ] = {
2444
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000000 ) },
2445
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000001 ) },
2446
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2447
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFE ) }
2448
};
2449
 
2450
static const struct { bits64 high, low; } float128P2[ float128NumP2 ] = {
2451
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000000 ) },
2452
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000001 ) },
2453
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000002 ) },
2454
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000004 ) },
2455
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000008 ) },
2456
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000010 ) },
2457
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000020 ) },
2458
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000040 ) },
2459
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000080 ) },
2460
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000100 ) },
2461
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000200 ) },
2462
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000400 ) },
2463
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000800 ) },
2464
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000001000 ) },
2465
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000002000 ) },
2466
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000004000 ) },
2467
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000008000 ) },
2468
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000010000 ) },
2469
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000020000 ) },
2470
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000040000 ) },
2471
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000080000 ) },
2472
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000100000 ) },
2473
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000200000 ) },
2474
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000400000 ) },
2475
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000800000 ) },
2476
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000001000000 ) },
2477
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000002000000 ) },
2478
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000004000000 ) },
2479
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000008000000 ) },
2480
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000010000000 ) },
2481
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000020000000 ) },
2482
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000040000000 ) },
2483
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000080000000 ) },
2484
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000100000000 ) },
2485
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000200000000 ) },
2486
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000400000000 ) },
2487
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000800000000 ) },
2488
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000001000000000 ) },
2489
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000002000000000 ) },
2490
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000004000000000 ) },
2491
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000008000000000 ) },
2492
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000010000000000 ) },
2493
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000020000000000 ) },
2494
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000040000000000 ) },
2495
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000080000000000 ) },
2496
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000100000000000 ) },
2497
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000200000000000 ) },
2498
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000400000000000 ) },
2499
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000800000000000 ) },
2500
    { LIT64( 0x0000000000000000 ), LIT64( 0x0001000000000000 ) },
2501
    { LIT64( 0x0000000000000000 ), LIT64( 0x0002000000000000 ) },
2502
    { LIT64( 0x0000000000000000 ), LIT64( 0x0004000000000000 ) },
2503
    { LIT64( 0x0000000000000000 ), LIT64( 0x0008000000000000 ) },
2504
    { LIT64( 0x0000000000000000 ), LIT64( 0x0010000000000000 ) },
2505
    { LIT64( 0x0000000000000000 ), LIT64( 0x0020000000000000 ) },
2506
    { LIT64( 0x0000000000000000 ), LIT64( 0x0040000000000000 ) },
2507
    { LIT64( 0x0000000000000000 ), LIT64( 0x0080000000000000 ) },
2508
    { LIT64( 0x0000000000000000 ), LIT64( 0x0100000000000000 ) },
2509
    { LIT64( 0x0000000000000000 ), LIT64( 0x0200000000000000 ) },
2510
    { LIT64( 0x0000000000000000 ), LIT64( 0x0400000000000000 ) },
2511
    { LIT64( 0x0000000000000000 ), LIT64( 0x0800000000000000 ) },
2512
    { LIT64( 0x0000000000000000 ), LIT64( 0x1000000000000000 ) },
2513
    { LIT64( 0x0000000000000000 ), LIT64( 0x2000000000000000 ) },
2514
    { LIT64( 0x0000000000000000 ), LIT64( 0x4000000000000000 ) },
2515
    { LIT64( 0x0000000000000000 ), LIT64( 0x8000000000000000 ) },
2516
    { LIT64( 0x0000000000000001 ), LIT64( 0x0000000000000000 ) },
2517
    { LIT64( 0x0000000000000002 ), LIT64( 0x0000000000000000 ) },
2518
    { LIT64( 0x0000000000000004 ), LIT64( 0x0000000000000000 ) },
2519
    { LIT64( 0x0000000000000008 ), LIT64( 0x0000000000000000 ) },
2520
    { LIT64( 0x0000000000000010 ), LIT64( 0x0000000000000000 ) },
2521
    { LIT64( 0x0000000000000020 ), LIT64( 0x0000000000000000 ) },
2522
    { LIT64( 0x0000000000000040 ), LIT64( 0x0000000000000000 ) },
2523
    { LIT64( 0x0000000000000080 ), LIT64( 0x0000000000000000 ) },
2524
    { LIT64( 0x0000000000000100 ), LIT64( 0x0000000000000000 ) },
2525
    { LIT64( 0x0000000000000200 ), LIT64( 0x0000000000000000 ) },
2526
    { LIT64( 0x0000000000000400 ), LIT64( 0x0000000000000000 ) },
2527
    { LIT64( 0x0000000000000800 ), LIT64( 0x0000000000000000 ) },
2528
    { LIT64( 0x0000000000001000 ), LIT64( 0x0000000000000000 ) },
2529
    { LIT64( 0x0000000000002000 ), LIT64( 0x0000000000000000 ) },
2530
    { LIT64( 0x0000000000004000 ), LIT64( 0x0000000000000000 ) },
2531
    { LIT64( 0x0000000000008000 ), LIT64( 0x0000000000000000 ) },
2532
    { LIT64( 0x0000000000010000 ), LIT64( 0x0000000000000000 ) },
2533
    { LIT64( 0x0000000000020000 ), LIT64( 0x0000000000000000 ) },
2534
    { LIT64( 0x0000000000040000 ), LIT64( 0x0000000000000000 ) },
2535
    { LIT64( 0x0000000000080000 ), LIT64( 0x0000000000000000 ) },
2536
    { LIT64( 0x0000000000100000 ), LIT64( 0x0000000000000000 ) },
2537
    { LIT64( 0x0000000000200000 ), LIT64( 0x0000000000000000 ) },
2538
    { LIT64( 0x0000000000400000 ), LIT64( 0x0000000000000000 ) },
2539
    { LIT64( 0x0000000000800000 ), LIT64( 0x0000000000000000 ) },
2540
    { LIT64( 0x0000000001000000 ), LIT64( 0x0000000000000000 ) },
2541
    { LIT64( 0x0000000002000000 ), LIT64( 0x0000000000000000 ) },
2542
    { LIT64( 0x0000000004000000 ), LIT64( 0x0000000000000000 ) },
2543
    { LIT64( 0x0000000008000000 ), LIT64( 0x0000000000000000 ) },
2544
    { LIT64( 0x0000000010000000 ), LIT64( 0x0000000000000000 ) },
2545
    { LIT64( 0x0000000020000000 ), LIT64( 0x0000000000000000 ) },
2546
    { LIT64( 0x0000000040000000 ), LIT64( 0x0000000000000000 ) },
2547
    { LIT64( 0x0000000080000000 ), LIT64( 0x0000000000000000 ) },
2548
    { LIT64( 0x0000000100000000 ), LIT64( 0x0000000000000000 ) },
2549
    { LIT64( 0x0000000200000000 ), LIT64( 0x0000000000000000 ) },
2550
    { LIT64( 0x0000000400000000 ), LIT64( 0x0000000000000000 ) },
2551
    { LIT64( 0x0000000800000000 ), LIT64( 0x0000000000000000 ) },
2552
    { LIT64( 0x0000001000000000 ), LIT64( 0x0000000000000000 ) },
2553
    { LIT64( 0x0000002000000000 ), LIT64( 0x0000000000000000 ) },
2554
    { LIT64( 0x0000004000000000 ), LIT64( 0x0000000000000000 ) },
2555
    { LIT64( 0x0000008000000000 ), LIT64( 0x0000000000000000 ) },
2556
    { LIT64( 0x0000010000000000 ), LIT64( 0x0000000000000000 ) },
2557
    { LIT64( 0x0000020000000000 ), LIT64( 0x0000000000000000 ) },
2558
    { LIT64( 0x0000040000000000 ), LIT64( 0x0000000000000000 ) },
2559
    { LIT64( 0x0000080000000000 ), LIT64( 0x0000000000000000 ) },
2560
    { LIT64( 0x0000100000000000 ), LIT64( 0x0000000000000000 ) },
2561
    { LIT64( 0x0000200000000000 ), LIT64( 0x0000000000000000 ) },
2562
    { LIT64( 0x0000400000000000 ), LIT64( 0x0000000000000000 ) },
2563
    { LIT64( 0x0000800000000000 ), LIT64( 0x0000000000000000 ) },
2564
    { LIT64( 0x0000C00000000000 ), LIT64( 0x0000000000000000 ) },
2565
    { LIT64( 0x0000E00000000000 ), LIT64( 0x0000000000000000 ) },
2566
    { LIT64( 0x0000F00000000000 ), LIT64( 0x0000000000000000 ) },
2567
    { LIT64( 0x0000F80000000000 ), LIT64( 0x0000000000000000 ) },
2568
    { LIT64( 0x0000FC0000000000 ), LIT64( 0x0000000000000000 ) },
2569
    { LIT64( 0x0000FE0000000000 ), LIT64( 0x0000000000000000 ) },
2570
    { LIT64( 0x0000FF0000000000 ), LIT64( 0x0000000000000000 ) },
2571
    { LIT64( 0x0000FF8000000000 ), LIT64( 0x0000000000000000 ) },
2572
    { LIT64( 0x0000FFC000000000 ), LIT64( 0x0000000000000000 ) },
2573
    { LIT64( 0x0000FFE000000000 ), LIT64( 0x0000000000000000 ) },
2574
    { LIT64( 0x0000FFF000000000 ), LIT64( 0x0000000000000000 ) },
2575
    { LIT64( 0x0000FFF800000000 ), LIT64( 0x0000000000000000 ) },
2576
    { LIT64( 0x0000FFFC00000000 ), LIT64( 0x0000000000000000 ) },
2577
    { LIT64( 0x0000FFFE00000000 ), LIT64( 0x0000000000000000 ) },
2578
    { LIT64( 0x0000FFFF00000000 ), LIT64( 0x0000000000000000 ) },
2579
    { LIT64( 0x0000FFFF80000000 ), LIT64( 0x0000000000000000 ) },
2580
    { LIT64( 0x0000FFFFC0000000 ), LIT64( 0x0000000000000000 ) },
2581
    { LIT64( 0x0000FFFFE0000000 ), LIT64( 0x0000000000000000 ) },
2582
    { LIT64( 0x0000FFFFF0000000 ), LIT64( 0x0000000000000000 ) },
2583
    { LIT64( 0x0000FFFFF8000000 ), LIT64( 0x0000000000000000 ) },
2584
    { LIT64( 0x0000FFFFFC000000 ), LIT64( 0x0000000000000000 ) },
2585
    { LIT64( 0x0000FFFFFE000000 ), LIT64( 0x0000000000000000 ) },
2586
    { LIT64( 0x0000FFFFFF000000 ), LIT64( 0x0000000000000000 ) },
2587
    { LIT64( 0x0000FFFFFF800000 ), LIT64( 0x0000000000000000 ) },
2588
    { LIT64( 0x0000FFFFFFC00000 ), LIT64( 0x0000000000000000 ) },
2589
    { LIT64( 0x0000FFFFFFE00000 ), LIT64( 0x0000000000000000 ) },
2590
    { LIT64( 0x0000FFFFFFF00000 ), LIT64( 0x0000000000000000 ) },
2591
    { LIT64( 0x0000FFFFFFF80000 ), LIT64( 0x0000000000000000 ) },
2592
    { LIT64( 0x0000FFFFFFFC0000 ), LIT64( 0x0000000000000000 ) },
2593
    { LIT64( 0x0000FFFFFFFE0000 ), LIT64( 0x0000000000000000 ) },
2594
    { LIT64( 0x0000FFFFFFFF0000 ), LIT64( 0x0000000000000000 ) },
2595
    { LIT64( 0x0000FFFFFFFF8000 ), LIT64( 0x0000000000000000 ) },
2596
    { LIT64( 0x0000FFFFFFFFC000 ), LIT64( 0x0000000000000000 ) },
2597
    { LIT64( 0x0000FFFFFFFFE000 ), LIT64( 0x0000000000000000 ) },
2598
    { LIT64( 0x0000FFFFFFFFF000 ), LIT64( 0x0000000000000000 ) },
2599
    { LIT64( 0x0000FFFFFFFFF800 ), LIT64( 0x0000000000000000 ) },
2600
    { LIT64( 0x0000FFFFFFFFFC00 ), LIT64( 0x0000000000000000 ) },
2601
    { LIT64( 0x0000FFFFFFFFFE00 ), LIT64( 0x0000000000000000 ) },
2602
    { LIT64( 0x0000FFFFFFFFFF00 ), LIT64( 0x0000000000000000 ) },
2603
    { LIT64( 0x0000FFFFFFFFFF80 ), LIT64( 0x0000000000000000 ) },
2604
    { LIT64( 0x0000FFFFFFFFFFC0 ), LIT64( 0x0000000000000000 ) },
2605
    { LIT64( 0x0000FFFFFFFFFFE0 ), LIT64( 0x0000000000000000 ) },
2606
    { LIT64( 0x0000FFFFFFFFFFF0 ), LIT64( 0x0000000000000000 ) },
2607
    { LIT64( 0x0000FFFFFFFFFFF8 ), LIT64( 0x0000000000000000 ) },
2608
    { LIT64( 0x0000FFFFFFFFFFFC ), LIT64( 0x0000000000000000 ) },
2609
    { LIT64( 0x0000FFFFFFFFFFFE ), LIT64( 0x0000000000000000 ) },
2610
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0x0000000000000000 ) },
2611
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0x8000000000000000 ) },
2612
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xC000000000000000 ) },
2613
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xE000000000000000 ) },
2614
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xF000000000000000 ) },
2615
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xF800000000000000 ) },
2616
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFC00000000000000 ) },
2617
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFE00000000000000 ) },
2618
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFF00000000000000 ) },
2619
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFF80000000000000 ) },
2620
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFC0000000000000 ) },
2621
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFE0000000000000 ) },
2622
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFF0000000000000 ) },
2623
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFF8000000000000 ) },
2624
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFC000000000000 ) },
2625
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFE000000000000 ) },
2626
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFF000000000000 ) },
2627
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFF800000000000 ) },
2628
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFC00000000000 ) },
2629
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFE00000000000 ) },
2630
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFF00000000000 ) },
2631
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFF80000000000 ) },
2632
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFC0000000000 ) },
2633
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFE0000000000 ) },
2634
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFF0000000000 ) },
2635
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFF8000000000 ) },
2636
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFC000000000 ) },
2637
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFE000000000 ) },
2638
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFF000000000 ) },
2639
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFF800000000 ) },
2640
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFC00000000 ) },
2641
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFE00000000 ) },
2642
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFF00000000 ) },
2643
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFF80000000 ) },
2644
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFC0000000 ) },
2645
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFE0000000 ) },
2646
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFF0000000 ) },
2647
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFF8000000 ) },
2648
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFC000000 ) },
2649
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFE000000 ) },
2650
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFF000000 ) },
2651
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFF800000 ) },
2652
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFC00000 ) },
2653
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFE00000 ) },
2654
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFF00000 ) },
2655
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFF80000 ) },
2656
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFC0000 ) },
2657
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFE0000 ) },
2658
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFF0000 ) },
2659
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFF8000 ) },
2660
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFC000 ) },
2661
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFE000 ) },
2662
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFF000 ) },
2663
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFF800 ) },
2664
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFC00 ) },
2665
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFE00 ) },
2666
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFF00 ) },
2667
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFF80 ) },
2668
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFC0 ) },
2669
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFE0 ) },
2670
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFF0 ) },
2671
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFF8 ) },
2672
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFC ) },
2673
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFE ) },
2674
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2675
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFD ) },
2676
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFB ) },
2677
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFF7 ) },
2678
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFEF ) },
2679
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFDF ) },
2680
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFBF ) },
2681
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFF7F ) },
2682
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFEFF ) },
2683
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFDFF ) },
2684
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFBFF ) },
2685
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFF7FF ) },
2686
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFEFFF ) },
2687
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFDFFF ) },
2688
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFBFFF ) },
2689
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFF7FFF ) },
2690
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFEFFFF ) },
2691
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFDFFFF ) },
2692
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFBFFFF ) },
2693
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFF7FFFF ) },
2694
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFEFFFFF ) },
2695
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFDFFFFF ) },
2696
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFBFFFFF ) },
2697
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFF7FFFFF ) },
2698
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFEFFFFFF ) },
2699
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFDFFFFFF ) },
2700
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFBFFFFFF ) },
2701
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFF7FFFFFF ) },
2702
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFEFFFFFFF ) },
2703
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFDFFFFFFF ) },
2704
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFFBFFFFFFF ) },
2705
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFF7FFFFFFF ) },
2706
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFEFFFFFFFF ) },
2707
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFDFFFFFFFF ) },
2708
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFFBFFFFFFFF ) },
2709
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFF7FFFFFFFF ) },
2710
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFEFFFFFFFFF ) },
2711
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFDFFFFFFFFF ) },
2712
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFFBFFFFFFFFF ) },
2713
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFF7FFFFFFFFF ) },
2714
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFEFFFFFFFFFF ) },
2715
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFDFFFFFFFFFF ) },
2716
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFFBFFFFFFFFFF ) },
2717
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFF7FFFFFFFFFF ) },
2718
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFEFFFFFFFFFFF ) },
2719
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFDFFFFFFFFFFF ) },
2720
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFFBFFFFFFFFFFF ) },
2721
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFF7FFFFFFFFFFF ) },
2722
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFEFFFFFFFFFFFF ) },
2723
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFDFFFFFFFFFFFF ) },
2724
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFFBFFFFFFFFFFFF ) },
2725
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFF7FFFFFFFFFFFF ) },
2726
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFEFFFFFFFFFFFFF ) },
2727
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFDFFFFFFFFFFFFF ) },
2728
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFFBFFFFFFFFFFFFF ) },
2729
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFF7FFFFFFFFFFFFF ) },
2730
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFEFFFFFFFFFFFFFF ) },
2731
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFDFFFFFFFFFFFFFF ) },
2732
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xFBFFFFFFFFFFFFFF ) },
2733
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xF7FFFFFFFFFFFFFF ) },
2734
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xEFFFFFFFFFFFFFFF ) },
2735
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xDFFFFFFFFFFFFFFF ) },
2736
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0xBFFFFFFFFFFFFFFF ) },
2737
    { LIT64( 0x0000FFFFFFFFFFFF ), LIT64( 0x7FFFFFFFFFFFFFFF ) },
2738
    { LIT64( 0x0000FFFFFFFFFFFD ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2739
    { LIT64( 0x0000FFFFFFFFFFFB ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2740
    { LIT64( 0x0000FFFFFFFFFFF7 ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2741
    { LIT64( 0x0000FFFFFFFFFFEF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2742
    { LIT64( 0x0000FFFFFFFFFFDF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2743
    { LIT64( 0x0000FFFFFFFFFFBF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2744
    { LIT64( 0x0000FFFFFFFFFF7F ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2745
    { LIT64( 0x0000FFFFFFFFFEFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2746
    { LIT64( 0x0000FFFFFFFFFDFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2747
    { LIT64( 0x0000FFFFFFFFFBFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2748
    { LIT64( 0x0000FFFFFFFFF7FF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2749
    { LIT64( 0x0000FFFFFFFFEFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2750
    { LIT64( 0x0000FFFFFFFFDFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2751
    { LIT64( 0x0000FFFFFFFFBFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2752
    { LIT64( 0x0000FFFFFFFF7FFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2753
    { LIT64( 0x0000FFFFFFFEFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2754
    { LIT64( 0x0000FFFFFFFDFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2755
    { LIT64( 0x0000FFFFFFFBFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2756
    { LIT64( 0x0000FFFFFFF7FFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2757
    { LIT64( 0x0000FFFFFFEFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2758
    { LIT64( 0x0000FFFFFFDFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2759
    { LIT64( 0x0000FFFFFFBFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2760
    { LIT64( 0x0000FFFFFF7FFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2761
    { LIT64( 0x0000FFFFFEFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2762
    { LIT64( 0x0000FFFFFDFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2763
    { LIT64( 0x0000FFFFFBFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2764
    { LIT64( 0x0000FFFFF7FFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2765
    { LIT64( 0x0000FFFFEFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2766
    { LIT64( 0x0000FFFFDFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2767
    { LIT64( 0x0000FFFFBFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2768
    { LIT64( 0x0000FFFF7FFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2769
    { LIT64( 0x0000FFFEFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2770
    { LIT64( 0x0000FFFDFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2771
    { LIT64( 0x0000FFFBFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2772
    { LIT64( 0x0000FFF7FFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2773
    { LIT64( 0x0000FFEFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2774
    { LIT64( 0x0000FFDFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2775
    { LIT64( 0x0000FFBFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2776
    { LIT64( 0x0000FF7FFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2777
    { LIT64( 0x0000FEFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2778
    { LIT64( 0x0000FDFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2779
    { LIT64( 0x0000FBFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2780
    { LIT64( 0x0000F7FFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2781
    { LIT64( 0x0000EFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2782
    { LIT64( 0x0000DFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2783
    { LIT64( 0x0000BFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2784
    { LIT64( 0x00007FFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2785
    { LIT64( 0x00003FFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2786
    { LIT64( 0x00001FFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2787
    { LIT64( 0x00000FFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2788
    { LIT64( 0x000007FFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2789
    { LIT64( 0x000003FFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2790
    { LIT64( 0x000001FFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2791
    { LIT64( 0x000000FFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2792
    { LIT64( 0x0000007FFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2793
    { LIT64( 0x0000003FFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2794
    { LIT64( 0x0000001FFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2795
    { LIT64( 0x0000000FFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2796
    { LIT64( 0x00000007FFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2797
    { LIT64( 0x00000003FFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2798
    { LIT64( 0x00000001FFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2799
    { LIT64( 0x00000000FFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2800
    { LIT64( 0x000000007FFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2801
    { LIT64( 0x000000003FFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2802
    { LIT64( 0x000000001FFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2803
    { LIT64( 0x000000000FFFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2804
    { LIT64( 0x0000000007FFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2805
    { LIT64( 0x0000000003FFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2806
    { LIT64( 0x0000000001FFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2807
    { LIT64( 0x0000000000FFFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2808
    { LIT64( 0x00000000007FFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2809
    { LIT64( 0x00000000003FFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2810
    { LIT64( 0x00000000001FFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2811
    { LIT64( 0x00000000000FFFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2812
    { LIT64( 0x000000000007FFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2813
    { LIT64( 0x000000000003FFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2814
    { LIT64( 0x000000000001FFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2815
    { LIT64( 0x000000000000FFFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2816
    { LIT64( 0x0000000000007FFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2817
    { LIT64( 0x0000000000003FFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2818
    { LIT64( 0x0000000000001FFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2819
    { LIT64( 0x0000000000000FFF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2820
    { LIT64( 0x00000000000007FF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2821
    { LIT64( 0x00000000000003FF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2822
    { LIT64( 0x00000000000001FF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2823
    { LIT64( 0x00000000000000FF ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2824
    { LIT64( 0x000000000000007F ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2825
    { LIT64( 0x000000000000003F ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2826
    { LIT64( 0x000000000000001F ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2827
    { LIT64( 0x000000000000000F ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2828
    { LIT64( 0x0000000000000007 ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2829
    { LIT64( 0x0000000000000003 ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2830
    { LIT64( 0x0000000000000001 ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2831
    { LIT64( 0x0000000000000000 ), LIT64( 0xFFFFFFFFFFFFFFFF ) },
2832
    { LIT64( 0x0000000000000000 ), LIT64( 0x7FFFFFFFFFFFFFFF ) },
2833
    { LIT64( 0x0000000000000000 ), LIT64( 0x3FFFFFFFFFFFFFFF ) },
2834
    { LIT64( 0x0000000000000000 ), LIT64( 0x1FFFFFFFFFFFFFFF ) },
2835
    { LIT64( 0x0000000000000000 ), LIT64( 0x0FFFFFFFFFFFFFFF ) },
2836
    { LIT64( 0x0000000000000000 ), LIT64( 0x07FFFFFFFFFFFFFF ) },
2837
    { LIT64( 0x0000000000000000 ), LIT64( 0x03FFFFFFFFFFFFFF ) },
2838
    { LIT64( 0x0000000000000000 ), LIT64( 0x01FFFFFFFFFFFFFF ) },
2839
    { LIT64( 0x0000000000000000 ), LIT64( 0x00FFFFFFFFFFFFFF ) },
2840
    { LIT64( 0x0000000000000000 ), LIT64( 0x007FFFFFFFFFFFFF ) },
2841
    { LIT64( 0x0000000000000000 ), LIT64( 0x003FFFFFFFFFFFFF ) },
2842
    { LIT64( 0x0000000000000000 ), LIT64( 0x001FFFFFFFFFFFFF ) },
2843
    { LIT64( 0x0000000000000000 ), LIT64( 0x000FFFFFFFFFFFFF ) },
2844
    { LIT64( 0x0000000000000000 ), LIT64( 0x0007FFFFFFFFFFFF ) },
2845
    { LIT64( 0x0000000000000000 ), LIT64( 0x0003FFFFFFFFFFFF ) },
2846
    { LIT64( 0x0000000000000000 ), LIT64( 0x0001FFFFFFFFFFFF ) },
2847
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000FFFFFFFFFFFF ) },
2848
    { LIT64( 0x0000000000000000 ), LIT64( 0x00007FFFFFFFFFFF ) },
2849
    { LIT64( 0x0000000000000000 ), LIT64( 0x00003FFFFFFFFFFF ) },
2850
    { LIT64( 0x0000000000000000 ), LIT64( 0x00001FFFFFFFFFFF ) },
2851
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000FFFFFFFFFFF ) },
2852
    { LIT64( 0x0000000000000000 ), LIT64( 0x000007FFFFFFFFFF ) },
2853
    { LIT64( 0x0000000000000000 ), LIT64( 0x000003FFFFFFFFFF ) },
2854
    { LIT64( 0x0000000000000000 ), LIT64( 0x000001FFFFFFFFFF ) },
2855
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000FFFFFFFFFF ) },
2856
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000007FFFFFFFFF ) },
2857
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000003FFFFFFFFF ) },
2858
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000001FFFFFFFFF ) },
2859
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000FFFFFFFFF ) },
2860
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000007FFFFFFFF ) },
2861
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000003FFFFFFFF ) },
2862
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000001FFFFFFFF ) },
2863
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000000FFFFFFFF ) },
2864
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000007FFFFFFF ) },
2865
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000003FFFFFFF ) },
2866
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000001FFFFFFF ) },
2867
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000000FFFFFFF ) },
2868
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000007FFFFFF ) },
2869
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000003FFFFFF ) },
2870
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000001FFFFFF ) },
2871
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000FFFFFF ) },
2872
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000000007FFFFF ) },
2873
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000000003FFFFF ) },
2874
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000000001FFFFF ) },
2875
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000000000FFFFF ) },
2876
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000000007FFFF ) },
2877
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000000003FFFF ) },
2878
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000000001FFFF ) },
2879
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000000000FFFF ) },
2880
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000007FFF ) },
2881
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000003FFF ) },
2882
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000001FFF ) },
2883
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000FFF ) },
2884
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000000000007FF ) },
2885
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000000000003FF ) },
2886
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000000000001FF ) },
2887
    { LIT64( 0x0000000000000000 ), LIT64( 0x00000000000000FF ) },
2888
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000000000007F ) },
2889
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000000000003F ) },
2890
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000000000001F ) },
2891
    { LIT64( 0x0000000000000000 ), LIT64( 0x000000000000000F ) },
2892
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000007 ) },
2893
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000003 ) }
2894
};
2895
 
2896
static const uint32 float128NumQInP1 = float128NumQIn * float128NumP1;
2897
static const uint32 float128NumQOutP1 = float128NumQOut * float128NumP1;
2898
 
2899
static float128 float128NextQInP1( sequenceT *sequencePtr )
2900
{
2901
    int16 expNum, sigNum;
2902
    float128 z;
2903
 
2904
    sigNum = sequencePtr->term1Num;
2905
    expNum = sequencePtr->expNum;
2906
    z.low = float128P1[ sigNum ].low;
2907
    z.high = float128QIn[ expNum ] | float128P1[ sigNum ].high;
2908
    ++sigNum;
2909
    if ( float128NumP1 <= sigNum ) {
2910
        sigNum = 0;
2911
        ++expNum;
2912
        if ( float128NumQIn <= expNum ) {
2913
            expNum = 0;
2914
            sequencePtr->done = TRUE;
2915
        }
2916
        sequencePtr->expNum = expNum;
2917
    }
2918
    sequencePtr->term1Num = sigNum;
2919
    return z;
2920
 
2921
}
2922
 
2923
static float128 float128NextQOutP1( sequenceT *sequencePtr )
2924
{
2925
    int16 expNum, sigNum;
2926
    float128 z;
2927
 
2928
    sigNum = sequencePtr->term1Num;
2929
    expNum = sequencePtr->expNum;
2930
    z.low = float128P1[ sigNum ].low;
2931
    z.high = float128QOut[ expNum ] | float128P1[ sigNum ].high;
2932
    ++sigNum;
2933
    if ( float128NumP1 <= sigNum ) {
2934
        sigNum = 0;
2935
        ++expNum;
2936
        if ( float128NumQOut <= expNum ) {
2937
            expNum = 0;
2938
            sequencePtr->done = TRUE;
2939
        }
2940
        sequencePtr->expNum = expNum;
2941
    }
2942
    sequencePtr->term1Num = sigNum;
2943
    return z;
2944
 
2945
}
2946
 
2947
static const uint32 float128NumQInP2 = float128NumQIn * float128NumP2;
2948
static const uint32 float128NumQOutP2 = float128NumQOut * float128NumP2;
2949
 
2950
static float128 float128NextQInP2( sequenceT *sequencePtr )
2951
{
2952
    int16 expNum, sigNum;
2953
    float128 z;
2954
 
2955
    sigNum = sequencePtr->term1Num;
2956
    expNum = sequencePtr->expNum;
2957
    z.low = float128P2[ sigNum ].low;
2958
    z.high = float128QIn[ expNum ] | float128P2[ sigNum ].high;
2959
    ++sigNum;
2960
    if ( float128NumP2 <= sigNum ) {
2961
        sigNum = 0;
2962
        ++expNum;
2963
        if ( float128NumQIn <= expNum ) {
2964
            expNum = 0;
2965
            sequencePtr->done = TRUE;
2966
        }
2967
        sequencePtr->expNum = expNum;
2968
    }
2969
    sequencePtr->term1Num = sigNum;
2970
    return z;
2971
 
2972
}
2973
 
2974
static float128 float128NextQOutP2( sequenceT *sequencePtr )
2975
{
2976
    int16 expNum, sigNum;
2977
    float128 z;
2978
 
2979
    sigNum = sequencePtr->term1Num;
2980
    expNum = sequencePtr->expNum;
2981
    z.low = float128P2[ sigNum ].low;
2982
    z.high = float128QOut[ expNum ] | float128P2[ sigNum ].high;
2983
    ++sigNum;
2984
    if ( float128NumP2 <= sigNum ) {
2985
        sigNum = 0;
2986
        ++expNum;
2987
        if ( float128NumQOut <= expNum ) {
2988
            expNum = 0;
2989
            sequencePtr->done = TRUE;
2990
        }
2991
        sequencePtr->expNum = expNum;
2992
    }
2993
    sequencePtr->term1Num = sigNum;
2994
    return z;
2995
 
2996
}
2997
 
2998
static float128 float128RandomQOutP3( void )
2999
{
3000
    int16 sigNum1, sigNum2;
3001
    uint64 sig1Low, sig2Low;
3002
    float128 z;
3003
 
3004
    sigNum1 = randomUint8() % float128NumP2;
3005
    sigNum2 = randomUint8() % float128NumP2;
3006
    sig1Low = float128P2[ sigNum1 ].low;
3007
    sig2Low = float128P2[ sigNum2 ].low;
3008
    z.low = sig1Low + sig2Low;
3009
    z.high =
3010
          float128QOut[ randomUint8() % float128NumQOut ]
3011
        | (   (   float128P2[ sigNum1 ].high
3012
                + float128P2[ sigNum2 ].high
3013
                + ( z.low < sig1Low )
3014
              )
3015
            & LIT64( 0x0000FFFFFFFFFFFF )
3016
          );
3017
    return z;
3018
 
3019
}
3020
 
3021
static float128 float128RandomQOutPInf( void )
3022
{
3023
    float128 z;
3024
 
3025
    z.low = randomUint64();
3026
    z.high =
3027
          float128QOut[ randomUint8() % float128NumQOut ]
3028
        | ( randomUint64() & LIT64( 0x0000FFFFFFFFFFFF ) );
3029
    return z;
3030
 
3031
}
3032
 
3033
enum {
3034
    float128NumQInfWeightMasks = 14
3035
};
3036
 
3037
static const uint64 float128QInfWeightMasks[ float128NumQInfWeightMasks ] = {
3038
    LIT64( 0x7FFF000000000000 ),
3039
    LIT64( 0x7FFF000000000000 ),
3040
    LIT64( 0x3FFF000000000000 ),
3041
    LIT64( 0x1FFF000000000000 ),
3042
    LIT64( 0x07FF000000000000 ),
3043
    LIT64( 0x07FF000000000000 ),
3044
    LIT64( 0x03FF000000000000 ),
3045
    LIT64( 0x01FF000000000000 ),
3046
    LIT64( 0x00FF000000000000 ),
3047
    LIT64( 0x007F000000000000 ),
3048
    LIT64( 0x003F000000000000 ),
3049
    LIT64( 0x001F000000000000 ),
3050
    LIT64( 0x000F000000000000 ),
3051
    LIT64( 0x0007000000000000 )
3052
};
3053
 
3054
static const uint64 float128QInfWeightOffsets[ float128NumQInfWeightMasks ] = {
3055
    LIT64( 0x0000000000000000 ),
3056
    LIT64( 0x0000000000000000 ),
3057
    LIT64( 0x2000000000000000 ),
3058
    LIT64( 0x3000000000000000 ),
3059
    LIT64( 0x3800000000000000 ),
3060
    LIT64( 0x3C00000000000000 ),
3061
    LIT64( 0x3E00000000000000 ),
3062
    LIT64( 0x3F00000000000000 ),
3063
    LIT64( 0x3F80000000000000 ),
3064
    LIT64( 0x3FC0000000000000 ),
3065
    LIT64( 0x3FE0000000000000 ),
3066
    LIT64( 0x3FF0000000000000 ),
3067
    LIT64( 0x3FF8000000000000 ),
3068
    LIT64( 0x3FFC000000000000 )
3069
};
3070
 
3071
static float128 float128RandomQInfP3( void )
3072
{
3073
    int16 sigNum1, sigNum2;
3074
    uint64 sig1Low, sig2Low;
3075
    int8 weightMaskNum;
3076
    float128 z;
3077
 
3078
    sigNum1 = randomUint8() % float128NumP2;
3079
    sigNum2 = randomUint8() % float128NumP2;
3080
    sig1Low = float128P2[ sigNum1 ].low;
3081
    sig2Low = float128P2[ sigNum2 ].low;
3082
    z.low = sig1Low + sig2Low;
3083
    weightMaskNum = randomUint8() % float128NumQInfWeightMasks;
3084
    z.high =
3085
          ( ( (uint64) ( randomUint8() & 1 ) )<<63 )
3086
        | (   (   ( ( (uint64) randomUint16() )<<48 )
3087
                & float128QInfWeightMasks[ weightMaskNum ] )
3088
            + float128QInfWeightOffsets[ weightMaskNum ]
3089
          )
3090
        | (   (   float128P2[ sigNum1 ].high
3091
                + float128P2[ sigNum2 ].high
3092
                + ( z.low < sig1Low )
3093
              )
3094
            & LIT64( 0x0000FFFFFFFFFFFF )
3095
          );
3096
    return z;
3097
 
3098
}
3099
 
3100
static float128 float128RandomQInfPInf( void )
3101
{
3102
    int8 weightMaskNum;
3103
    float128 z;
3104
 
3105
    weightMaskNum = randomUint8() % float128NumQInfWeightMasks;
3106
    z.low = randomUint64();
3107
    z.high =
3108
          ( ( (uint64) ( randomUint8() & 1 ) )<<63 )
3109
        | (   (   ( ( (uint64) randomUint16() )<<48 )
3110
                & float128QInfWeightMasks[ weightMaskNum ] )
3111
            + float128QInfWeightOffsets[ weightMaskNum ]
3112
          )
3113
        | ( randomUint64() & LIT64( 0x0000FFFFFFFFFFFF ) );
3114
    return z;
3115
 
3116
}
3117
 
3118
static float128 float128Random( void )
3119
{
3120
 
3121
    switch ( randomUint8() & 7 ) {
3122
     case 0:
3123
     case 1:
3124
     case 2:
3125
        return float128RandomQOutP3();
3126
     case 3:
3127
        return float128RandomQOutPInf();
3128
     case 4:
3129
     case 5:
3130
     case 6:
3131
        return float128RandomQInfP3();
3132
     case 7:
3133
        return float128RandomQInfPInf();
3134
    }
3135
 
3136
}
3137
 
3138
#endif
3139
 
3140
static int8 level = 0;
3141
 
3142
void testCases_setLevel( int8 levelIn )
3143
{
3144
 
3145
    if ( ( levelIn < 1 ) || ( 2 < levelIn ) ) {
3146
        fail( "Invalid testing level: %d", levelIn );
3147
    }
3148
    level = levelIn;
3149
 
3150
}
3151
 
3152
static int8 sequenceType;
3153
static sequenceT sequenceA, sequenceB;
3154
static int8 subcase;
3155
 
3156
uint32 testCases_total;
3157
flag testCases_done;
3158
 
3159
static float32 current_a_float32;
3160
static float32 current_b_float32;
3161
static float64 current_a_float64;
3162
static float64 current_b_float64;
3163
#ifdef FLOATX80
3164
static floatx80 current_a_floatx80;
3165
static floatx80 current_b_floatx80;
3166
#endif
3167
#ifdef FLOAT128
3168
static float128 current_a_float128;
3169
static float128 current_b_float128;
3170
#endif
3171
 
3172
void testCases_initSequence( int8 sequenceTypeIn )
3173
{
3174
 
3175
    sequenceType = sequenceTypeIn;
3176
    sequenceA.term2Num = 0;
3177
    sequenceA.term1Num = 0;
3178
    sequenceA.expNum = 0;
3179
    sequenceA.done = FALSE;
3180
    sequenceB.term2Num = 0;
3181
    sequenceB.term1Num = 0;
3182
    sequenceB.expNum = 0;
3183
    sequenceB.done = FALSE;
3184
    subcase = 0;
3185
    switch ( level ) {
3186
     case 1:
3187
        switch ( sequenceTypeIn ) {
3188
         case testCases_sequence_a_int32:
3189
            testCases_total = 3 * int32NumP1;
3190
            break;
3191
#ifdef BITS64
3192
         case testCases_sequence_a_int64:
3193
            testCases_total = 3 * int64NumP1;
3194
            break;
3195
#endif
3196
         case testCases_sequence_a_float32:
3197
            testCases_total = 3 * float32NumQOutP1;
3198
            break;
3199
         case testCases_sequence_ab_float32:
3200
            testCases_total = 6 * float32NumQInP1 * float32NumQInP1;
3201
            current_a_float32 = float32NextQInP1( &sequenceA );
3202
            break;
3203
         case testCases_sequence_a_float64:
3204
            testCases_total = 3 * float64NumQOutP1;
3205
            break;
3206
         case testCases_sequence_ab_float64:
3207
            testCases_total = 6 * float64NumQInP1 * float64NumQInP1;
3208
            current_a_float64 = float64NextQInP1( &sequenceA );
3209
            break;
3210
#ifdef FLOATX80
3211
         case testCases_sequence_a_floatx80:
3212
            testCases_total = 3 * floatx80NumQOutP1;
3213
            break;
3214
         case testCases_sequence_ab_floatx80:
3215
            testCases_total = 6 * floatx80NumQInP1 * floatx80NumQInP1;
3216
            current_a_floatx80 = floatx80NextQInP1( &sequenceA );
3217
            break;
3218
#endif
3219
#ifdef FLOAT128
3220
         case testCases_sequence_a_float128:
3221
            testCases_total = 3 * float128NumQOutP1;
3222
            break;
3223
         case testCases_sequence_ab_float128:
3224
            testCases_total = 6 * float128NumQInP1 * float128NumQInP1;
3225
            current_a_float128 = float128NextQInP1( &sequenceA );
3226
            break;
3227
#endif
3228
        }
3229
        break;
3230
     case 2:
3231
        switch ( sequenceTypeIn ) {
3232
         case testCases_sequence_a_int32:
3233
            testCases_total = 2 * int32NumP2;
3234
            break;
3235
#ifdef BITS64
3236
         case testCases_sequence_a_int64:
3237
            testCases_total = 2 * int64NumP2;
3238
            break;
3239
#endif
3240
         case testCases_sequence_a_float32:
3241
            testCases_total = 2 * float32NumQOutP2;
3242
            break;
3243
         case testCases_sequence_ab_float32:
3244
            testCases_total = 2 * float32NumQInP2 * float32NumQInP2;
3245
            current_a_float32 = float32NextQInP2( &sequenceA );
3246
            break;
3247
         case testCases_sequence_a_float64:
3248
            testCases_total = 2 * float64NumQOutP2;
3249
            break;
3250
         case testCases_sequence_ab_float64:
3251
            testCases_total = 2 * float64NumQInP2 * float64NumQInP2;
3252
            current_a_float64 = float64NextQInP2( &sequenceA );
3253
            break;
3254
#ifdef FLOATX80
3255
         case testCases_sequence_a_floatx80:
3256
            testCases_total = 2 * floatx80NumQOutP2;
3257
            break;
3258
         case testCases_sequence_ab_floatx80:
3259
            testCases_total = 2 * floatx80NumQInP2 * floatx80NumQInP2;
3260
            current_a_floatx80 = floatx80NextQInP2( &sequenceA );
3261
            break;
3262
#endif
3263
#ifdef FLOAT128
3264
         case testCases_sequence_a_float128:
3265
            testCases_total = 2 * float128NumQOutP2;
3266
            break;
3267
         case testCases_sequence_ab_float128:
3268
            testCases_total = 2 * float128NumQInP2 * float128NumQInP2;
3269
            current_a_float128 = float128NextQInP2( &sequenceA );
3270
            break;
3271
#endif
3272
        }
3273
        break;
3274
    }
3275
    testCases_done = FALSE;
3276
 
3277
}
3278
 
3279
int32 testCases_a_int32;
3280
#ifdef BITS64
3281
int64 testCases_a_int64;
3282
#endif
3283
float32 testCases_a_float32;
3284
float32 testCases_b_float32;
3285
float64 testCases_a_float64;
3286
float64 testCases_b_float64;
3287
#ifdef FLOATX80
3288
floatx80 testCases_a_floatx80;
3289
floatx80 testCases_b_floatx80;
3290
#endif
3291
#ifdef FLOAT128
3292
float128 testCases_a_float128;
3293
float128 testCases_b_float128;
3294
#endif
3295
 
3296
void testCases_next( void )
3297
{
3298
 
3299
    switch ( level ) {
3300
     case 1:
3301
        switch ( sequenceType ) {
3302
         case testCases_sequence_a_int32:
3303
            switch ( subcase ) {
3304
             case 0:
3305
                testCases_a_int32 = int32RandomP3();
3306
                break;
3307
             case 1:
3308
                testCases_a_int32 = int32RandomPInf();
3309
                break;
3310
             case 2:
3311
                testCases_a_int32 = int32NextP1( &sequenceA );
3312
                testCases_done = sequenceA.done;
3313
                subcase = -1;
3314
                break;
3315
            }
3316
            ++subcase;
3317
            break;
3318
#ifdef BITS64
3319
         case testCases_sequence_a_int64:
3320
            switch ( subcase ) {
3321
             case 0:
3322
                testCases_a_int64 = int64RandomP3();
3323
                break;
3324
             case 1:
3325
                testCases_a_int64 = int64RandomPInf();
3326
                break;
3327
             case 2:
3328
                testCases_a_int64 = int64NextP1( &sequenceA );
3329
                testCases_done = sequenceA.done;
3330
                subcase = -1;
3331
                break;
3332
            }
3333
            ++subcase;
3334
            break;
3335
#endif
3336
         case testCases_sequence_a_float32:
3337
            switch ( subcase ) {
3338
             case 0:
3339
             case 1:
3340
                testCases_a_float32 = float32Random();
3341
                break;
3342
             case 2:
3343
                testCases_a_float32 = float32NextQOutP1( &sequenceA );
3344
                testCases_done = sequenceA.done;
3345
                subcase = -1;
3346
                break;
3347
            }
3348
            ++subcase;
3349
            break;
3350
         case testCases_sequence_ab_float32:
3351
            switch ( subcase ) {
3352
             case 0:
3353
                if ( sequenceB.done ) {
3354
                    sequenceB.done = FALSE;
3355
                    current_a_float32 = float32NextQInP1( &sequenceA );
3356
                }
3357
                current_b_float32 = float32NextQInP1( &sequenceB );
3358
             case 2:
3359
             case 4:
3360
                testCases_a_float32 = float32Random();
3361
                testCases_b_float32 = float32Random();
3362
                break;
3363
             case 1:
3364
                testCases_a_float32 = current_a_float32;
3365
                testCases_b_float32 = float32Random();
3366
                break;
3367
             case 3:
3368
                testCases_a_float32 = float32Random();
3369
                testCases_b_float32 = current_b_float32;
3370
                break;
3371
             case 5:
3372
                testCases_a_float32 = current_a_float32;
3373
                testCases_b_float32 = current_b_float32;
3374
                testCases_done = sequenceA.done & sequenceB.done;
3375
                subcase = -1;
3376
                break;
3377
            }
3378
            ++subcase;
3379
            break;
3380
         case testCases_sequence_a_float64:
3381
            switch ( subcase ) {
3382
             case 0:
3383
             case 1:
3384
                testCases_a_float64 = float64Random();
3385
                break;
3386
             case 2:
3387
                testCases_a_float64 = float64NextQOutP1( &sequenceA );
3388
                testCases_done = sequenceA.done;
3389
                subcase = -1;
3390
                break;
3391
            }
3392
            ++subcase;
3393
            break;
3394
         case testCases_sequence_ab_float64:
3395
            switch ( subcase ) {
3396
             case 0:
3397
                if ( sequenceB.done ) {
3398
                    sequenceB.done = FALSE;
3399
                    current_a_float64 = float64NextQInP1( &sequenceA );
3400
                }
3401
                current_b_float64 = float64NextQInP1( &sequenceB );
3402
             case 2:
3403
             case 4:
3404
                testCases_a_float64 = float64Random();
3405
                testCases_b_float64 = float64Random();
3406
                break;
3407
             case 1:
3408
                testCases_a_float64 = current_a_float64;
3409
                testCases_b_float64 = float64Random();
3410
                break;
3411
             case 3:
3412
                testCases_a_float64 = float64Random();
3413
                testCases_b_float64 = current_b_float64;
3414
                break;
3415
             case 5:
3416
                testCases_a_float64 = current_a_float64;
3417
                testCases_b_float64 = current_b_float64;
3418
                testCases_done = sequenceA.done & sequenceB.done;
3419
                subcase = -1;
3420
                break;
3421
            }
3422
            ++subcase;
3423
            break;
3424
#ifdef FLOATX80
3425
         case testCases_sequence_a_floatx80:
3426
            switch ( subcase ) {
3427
             case 0:
3428
             case 1:
3429
                testCases_a_floatx80 = floatx80Random();
3430
                break;
3431
             case 2:
3432
                testCases_a_floatx80 = floatx80NextQOutP1( &sequenceA );
3433
                testCases_done = sequenceA.done;
3434
                subcase = -1;
3435
                break;
3436
            }
3437
            ++subcase;
3438
            break;
3439
         case testCases_sequence_ab_floatx80:
3440
            switch ( subcase ) {
3441
             case 0:
3442
                if ( sequenceB.done ) {
3443
                    sequenceB.done = FALSE;
3444
                    current_a_floatx80 = floatx80NextQInP1( &sequenceA );
3445
                }
3446
                current_b_floatx80 = floatx80NextQInP1( &sequenceB );
3447
             case 2:
3448
             case 4:
3449
                testCases_a_floatx80 = floatx80Random();
3450
                testCases_b_floatx80 = floatx80Random();
3451
                break;
3452
             case 1:
3453
                testCases_a_floatx80 = current_a_floatx80;
3454
                testCases_b_floatx80 = floatx80Random();
3455
                break;
3456
             case 3:
3457
                testCases_a_floatx80 = floatx80Random();
3458
                testCases_b_floatx80 = current_b_floatx80;
3459
                break;
3460
             case 5:
3461
                testCases_a_floatx80 = current_a_floatx80;
3462
                testCases_b_floatx80 = current_b_floatx80;
3463
                testCases_done = sequenceA.done & sequenceB.done;
3464
                subcase = -1;
3465
                break;
3466
            }
3467
            ++subcase;
3468
            break;
3469
#endif
3470
#ifdef FLOAT128
3471
         case testCases_sequence_a_float128:
3472
            switch ( subcase ) {
3473
             case 0:
3474
             case 1:
3475
                testCases_a_float128 = float128Random();
3476
                break;
3477
             case 2:
3478
                testCases_a_float128 = float128NextQOutP1( &sequenceA );
3479
                testCases_done = sequenceA.done;
3480
                subcase = -1;
3481
                break;
3482
            }
3483
            ++subcase;
3484
            break;
3485
         case testCases_sequence_ab_float128:
3486
            switch ( subcase ) {
3487
             case 0:
3488
                if ( sequenceB.done ) {
3489
                    sequenceB.done = FALSE;
3490
                    current_a_float128 = float128NextQInP1( &sequenceA );
3491
                }
3492
                current_b_float128 = float128NextQInP1( &sequenceB );
3493
             case 2:
3494
             case 4:
3495
                testCases_a_float128 = float128Random();
3496
                testCases_b_float128 = float128Random();
3497
                break;
3498
             case 1:
3499
                testCases_a_float128 = current_a_float128;
3500
                testCases_b_float128 = float128Random();
3501
                break;
3502
             case 3:
3503
                testCases_a_float128 = float128Random();
3504
                testCases_b_float128 = current_b_float128;
3505
                break;
3506
             case 5:
3507
                testCases_a_float128 = current_a_float128;
3508
                testCases_b_float128 = current_b_float128;
3509
                testCases_done = sequenceA.done & sequenceB.done;
3510
                subcase = -1;
3511
                break;
3512
            }
3513
            ++subcase;
3514
            break;
3515
#endif
3516
        }
3517
        break;
3518
     case 2:
3519
        switch ( sequenceType ) {
3520
         case testCases_sequence_a_int32:
3521
            switch ( subcase ) {
3522
             case 0:
3523
                testCases_a_int32 = int32RandomP3();
3524
                break;
3525
             case 2:
3526
                testCases_a_int32 = int32RandomPInf();
3527
                break;
3528
             case 3:
3529
                subcase = -1;
3530
             case 1:
3531
                testCases_a_int32 = int32NextP2( &sequenceA );
3532
                testCases_done = sequenceA.done;
3533
                break;
3534
            }
3535
            ++subcase;
3536
            break;
3537
#ifdef BITS64
3538
         case testCases_sequence_a_int64:
3539
            switch ( subcase ) {
3540
             case 0:
3541
                testCases_a_int64 = int64RandomP3();
3542
                break;
3543
             case 2:
3544
                testCases_a_int64 = int64RandomPInf();
3545
                break;
3546
             case 3:
3547
                subcase = -1;
3548
             case 1:
3549
                testCases_a_int64 = int64NextP2( &sequenceA );
3550
                testCases_done = sequenceA.done;
3551
                break;
3552
            }
3553
            ++subcase;
3554
            break;
3555
#endif
3556
         case testCases_sequence_a_float32:
3557
            switch ( subcase ) {
3558
             case 0:
3559
                testCases_a_float32 = float32Random();
3560
                break;
3561
             case 1:
3562
                testCases_a_float32 = float32NextQOutP2( &sequenceA );
3563
                testCases_done = sequenceA.done;
3564
                subcase = -1;
3565
                break;
3566
            }
3567
            ++subcase;
3568
            break;
3569
         case testCases_sequence_ab_float32:
3570
            switch ( subcase ) {
3571
             case 0:
3572
                testCases_a_float32 = float32Random();
3573
                testCases_b_float32 = float32Random();
3574
                break;
3575
             case 1:
3576
                if ( sequenceB.done ) {
3577
                    sequenceB.done = FALSE;
3578
                    current_a_float32 = float32NextQInP2( &sequenceA );
3579
                }
3580
                testCases_a_float32 = current_a_float32;
3581
                testCases_b_float32 = float32NextQInP2( &sequenceB );
3582
                testCases_done = sequenceA.done & sequenceB.done;
3583
                subcase = -1;
3584
                break;
3585
            }
3586
            ++subcase;
3587
            break;
3588
         case testCases_sequence_a_float64:
3589
            switch ( subcase ) {
3590
             case 0:
3591
                testCases_a_float64 = float64Random();
3592
                break;
3593
             case 1:
3594
                testCases_a_float64 = float64NextQOutP2( &sequenceA );
3595
                testCases_done = sequenceA.done;
3596
                subcase = -1;
3597
                break;
3598
            }
3599
            ++subcase;
3600
            break;
3601
         case testCases_sequence_ab_float64:
3602
            switch ( subcase ) {
3603
             case 0:
3604
                testCases_a_float64 = float64Random();
3605
                testCases_b_float64 = float64Random();
3606
                break;
3607
             case 1:
3608
                if ( sequenceB.done ) {
3609
                    sequenceB.done = FALSE;
3610
                    current_a_float64 = float64NextQInP2( &sequenceA );
3611
                }
3612
                testCases_a_float64 = current_a_float64;
3613
                testCases_b_float64 = float64NextQInP2( &sequenceB );
3614
                testCases_done = sequenceA.done & sequenceB.done;
3615
                subcase = -1;
3616
                break;
3617
            }
3618
            ++subcase;
3619
            break;
3620
#ifdef FLOATX80
3621
         case testCases_sequence_a_floatx80:
3622
            switch ( subcase ) {
3623
             case 0:
3624
                testCases_a_floatx80 = floatx80Random();
3625
                break;
3626
             case 1:
3627
                testCases_a_floatx80 = floatx80NextQOutP2( &sequenceA );
3628
                testCases_done = sequenceA.done;
3629
                subcase = -1;
3630
                break;
3631
            }
3632
            ++subcase;
3633
            break;
3634
         case testCases_sequence_ab_floatx80:
3635
            switch ( subcase ) {
3636
             case 0:
3637
                testCases_a_floatx80 = floatx80Random();
3638
                testCases_b_floatx80 = floatx80Random();
3639
                break;
3640
             case 1:
3641
                if ( sequenceB.done ) {
3642
                    sequenceB.done = FALSE;
3643
                    current_a_floatx80 = floatx80NextQInP2( &sequenceA );
3644
                }
3645
                testCases_a_floatx80 = current_a_floatx80;
3646
                testCases_b_floatx80 = floatx80NextQInP2( &sequenceB );
3647
                testCases_done = sequenceA.done & sequenceB.done;
3648
                subcase = -1;
3649
                break;
3650
            }
3651
            ++subcase;
3652
            break;
3653
#endif
3654
#ifdef FLOAT128
3655
         case testCases_sequence_a_float128:
3656
            switch ( subcase ) {
3657
             case 0:
3658
                testCases_a_float128 = float128Random();
3659
                break;
3660
             case 1:
3661
                testCases_a_float128 = float128NextQOutP2( &sequenceA );
3662
                testCases_done = sequenceA.done;
3663
                subcase = -1;
3664
                break;
3665
            }
3666
            ++subcase;
3667
            break;
3668
         case testCases_sequence_ab_float128:
3669
            switch ( subcase ) {
3670
             case 0:
3671
                testCases_a_float128 = float128Random();
3672
                testCases_b_float128 = float128Random();
3673
                break;
3674
             case 1:
3675
                if ( sequenceB.done ) {
3676
                    sequenceB.done = FALSE;
3677
                    current_a_float128 = float128NextQInP2( &sequenceA );
3678
                }
3679
                testCases_a_float128 = current_a_float128;
3680
                testCases_b_float128 = float128NextQInP2( &sequenceB );
3681
                testCases_done = sequenceA.done & sequenceB.done;
3682
                subcase = -1;
3683
                break;
3684
            }
3685
            ++subcase;
3686
            break;
3687
#endif
3688
        }
3689
        break;
3690
    }
3691
 
3692
}
3693
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.