tools/test/testfloat/testCases.c

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