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