VirtualBox

Changeset 94261 in vbox


Ignore:
Timestamp:
Mar 16, 2022 1:34:29 AM (3 years ago)
Author:
vboxsync
Message:

iprt/types.h,VMM,ValKit,IPRT: Dropped the bit counts in member prefixes in the RTFLOATxxU types and added a RTFLOAT32U. Added some fld [mem] tests. bugref:9898

Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/iprt/types.h

    r94253 r94261  
    904904
    905905/**
    906  * Double precision floating point format (64-bit).
    907  */
    908 typedef union RTFLOAT64U
    909 {
     906 * Single precision floating point format (32-bit).
     907 */
     908typedef union RTFLOAT32U
     909{
     910    /** Format using regular bitfields.  */
     911    struct
     912    {
     913# ifdef RT_BIG_ENDIAN
     914        /** The sign indicator. */
     915        uint32_t    fSign : 1;
     916        /** The exponent (offseted by 127). */
     917        uint32_t    uExponent : 8;
     918        /** The fraction. */
     919        uint32_t    uFraction : 23;
     920# else
     921        /** The fraction. */
     922        uint32_t    uFraction : 23;
     923        /** The exponent (offseted by 127). */
     924        uint32_t    uExponent : 8;
     925        /** The sign indicator. */
     926        uint32_t    fSign : 1;
     927# endif
     928    } s;
     929
    910930#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
    911931    /** Double view. */
    912     double      rd;
    913 #endif
     932    float       r;
     933#endif
     934    /** Unsigned integer view. */
     935    uint32_t    u;
     936    /** 32-bit view. */
     937    uint32_t    au32[1];
     938    /** 16-bit view. */
     939    uint16_t    au16[2];
     940    /** 8-bit view. */
     941    uint8_t     au8[4];
     942} RTFLOAT32U;
     943/** Pointer to a single precision floating point format union. */
     944typedef RTFLOAT32U RT_FAR *PRTFLOAT32U;
     945/** Pointer to a const single precision floating point format union. */
     946typedef const RTFLOAT32U RT_FAR *PCRTFLOAT32U;
     947/** RTFLOAT32U initializer. */
     948#ifdef RT_BIG_ENDIAN
     949# define RTFLOAT32U_INIT(a_fSign, a_uFraction, a_uExponent)     { { (a_fSign), (a_uExponent), (a_uFraction) } }
     950#else
     951# define RTFLOAT32U_INIT(a_fSign, a_uFraction, a_uExponent)     { { (a_uFraction), (a_uExponent), (a_fSign) } }
     952#endif
     953#define RTFLOAT32U_INIT_C(a_fSign, a_uFraction, a_uExponent)    RTFLOAT32U_INIT((a_fSign), UINT32_C(a_uFraction), (a_uExponent))
     954/** Check if two 32-bit floating values are identical (memcmp, not
     955 *  numerically). */
     956#define RTFLOAT32U_ARE_IDENTICAL(a_pLeft, a_pRight)             ((a_pLeft)->u == (a_pRight)->u)
     957
     958
     959/**
     960 * Double precision floating point format (64-bit).
     961 */
     962typedef union RTFLOAT64U
     963{
    914964    /** Format using regular bitfields.  */
    915965    struct
     
    921971        uint32_t    uExponent : 11;
    922972        /** The fraction, bits 32 thru 51. */
    923         uint32_t    u20FractionHigh : 20;
     973        uint32_t    uFractionHigh : 20;
    924974        /** The fraction, bits 0 thru 31. */
    925         uint32_t    u32FractionLow;
     975        uint32_t    uFractionLow;
    926976# else
    927977        /** The fraction, bits 0 thru 31. */
    928         uint32_t    u32FractionLow;
     978        uint32_t    uFractionLow;
    929979        /** The fraction, bits 32 thru 51. */
    930         uint32_t    u20FractionHigh : 20;
     980        uint32_t    uFractionHigh : 20;
    931981        /** The exponent (offseted by 1023). */
    932982        uint32_t    uExponent : 11;
     
    9581008#endif
    9591009
     1010#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
     1011    /** Double view. */
     1012    double      rd;
     1013#endif
     1014    /** Unsigned integer view. */
     1015    uint64_t    u;
    9601016    /** 64-bit view. */
    9611017    uint64_t    au64[1];
     
    9711027/** Pointer to a const double precision floating point format union. */
    9721028typedef const RTFLOAT64U RT_FAR *PCRTFLOAT64U;
     1029/** RTFLOAT64U initializer. */
     1030#ifdef RT_BIG_ENDIAN
     1031# define RTFLOAT64U_INIT(a_fSign, a_uFraction, a_uExponent)     \
     1032    { { (a_fSign), (a_uExponent), (uint32_t)((a_uFraction) >> 32), (uint32_t)(a_uFraction) } }
     1033#else
     1034# define RTFLOAT64U_INIT(a_fSign, a_uFraction, a_uExponent)     \
     1035    { { (uint32_t)(a_uFraction), (uint32_t)((a_uFraction) >> 32), (a_uExponent), (a_fSign) } }
     1036#endif
     1037#define RTFLOAT64U_INIT_C(a_fSign, a_uFraction, a_uExponent)    RTFLOAT64U_INIT((a_fSign), UINT64_C(a_uFraction), (a_uExponent))
     1038/** Check if two 64-bit floating values are identical (memcmp, not
     1039 *  numerically). */
     1040#define RTFLOAT64U_ARE_IDENTICAL(a_pLeft, a_pRight)             ((a_pLeft)->u == (a_pRight)->u)
    9731041
    9741042
     
    9901058        RT_GCC_EXTENSION uint16_t   uExponent : 15;
    9911059        /** The mantissa. */
    992         uint64_t                    u64Mantissa;
     1060        uint64_t                    uMantissa;
    9931061# else
    9941062        /** The mantissa. */
    995         uint64_t                    u64Mantissa;
     1063        uint64_t                    uMantissa;
    9961064        /** The exponent (offseted by 16383). */
    9971065        RT_GCC_EXTENSION uint16_t   uExponent : 15;
     
    10131081        RT_GCC_EXTENSION uint64_t   fInteger : 1;
    10141082        /** The fraction. */
    1015         RT_GCC_EXTENSION uint64_t   u63Fraction : 63;
     1083        RT_GCC_EXTENSION uint64_t   uFraction : 63;
    10161084#  else
    10171085        /** The fraction. */
    1018         RT_GCC_EXTENSION uint64_t   u63Fraction : 63;
     1086        RT_GCC_EXTENSION uint64_t   uFraction : 63;
    10191087        /** The J bit, aka the integer bit. */
    10201088        RT_GCC_EXTENSION uint64_t   fInteger : 1;
     
    10471115#  define RTFLOAT80U_INIT(a_fSign, a_uMantissa, a_uExponent)  { { (a_uMantissa), (a_uExponent), (a_fSign) } }
    10481116# endif
    1049 # define RTFLOAT80U_INIT_C(a_fSign, a_uMantissa, a_uExponent) RTFLOAT80U_INIT((a_fSign), (a_uExponent), UINT64_C(a_uMantissa))
    1050 
     1117# define RTFLOAT80U_INIT_C(a_fSign, a_uMantissa, a_uExponent) RTFLOAT80U_INIT((a_fSign), UINT64_C(a_uMantissa), (a_uExponent))
    10511118/** Check if two 80-bit floating values are identical (memcmp, not
    10521119 *  numberically). */
     
    10751142        RT_GCC_EXTENSION uint16_t   uExponent : 15;
    10761143        /** The mantissa. */
    1077         uint64_t                    u64Mantissa;
     1144        uint64_t                    uMantissa;
    10781145# else
    10791146        /** The mantissa. */
    1080         uint64_t                    u64Mantissa;
     1147        uint64_t                    uMantissa;
    10811148        /** The exponent (offseted by 16383). */
    10821149        RT_GCC_EXTENSION uint16_t   uExponent : 15;
     
    10971164        uint32_t                    fInteger : 1;
    10981165        /** The fraction, bits 32 thru 62. */
    1099         uint32_t                    u31FractionHigh : 31;
     1166        uint32_t                    uFractionHigh : 31;
    11001167        /** The fraction, bits 0 thru 31. */
    1101         uint32_t                    u32FractionLow : 32;
     1168        uint32_t                    uFractionLow : 32;
    11021169# else
    11031170        /** The fraction, bits 0 thru 31. */
    1104         uint32_t                    u32FractionLow : 32;
     1171        uint32_t                    uFractionLow : 32;
    11051172        /** The fraction, bits 32 thru 62. */
    1106         uint32_t                    u31FractionHigh : 31;
     1173        uint32_t                    uFractionHigh : 31;
    11071174        /** The J bit, aka the integer bit. */
    11081175        uint32_t                    fInteger : 1;
     
    11261193        RT_GCC_EXTENSION uint64_t   fInteger : 1;
    11271194        /** The fraction. */
    1128         RT_GCC_EXTENSION uint64_t   u63Fraction : 63;
     1195        RT_GCC_EXTENSION uint64_t   uFraction : 63;
    11291196#  else
    11301197        /** The fraction. */
    1131         RT_GCC_EXTENSION uint64_t   u63Fraction : 63;
     1198        RT_GCC_EXTENSION uint64_t   uFraction : 63;
    11321199        /** The J bit, aka the integer bit. */
    11331200        RT_GCC_EXTENSION uint64_t   fInteger : 1;
  • trunk/src/VBox/Runtime/common/string/strformatnum.cpp

    r94257 r94261  
    355355#ifdef RT_COMPILER_GROKS_64BIT_BITFIELDS
    356356    return rtStrFormatR80Worker(pszBuf, cbBuf, pr80Value->sj64.fSign, pr80Value->sj64.fInteger,
    357                                 pr80Value->sj64.u63Fraction, pr80Value->sj64.uExponent, fFlags);
     357                                pr80Value->sj64.uFraction, pr80Value->sj64.uExponent, fFlags);
    358358#else
    359359    return rtStrFormatR80Worker(pszBuf, cbBuf, pr80Value->sj.fSign, pr80Value->sj.fInteger,
     
    368368{
    369369    RT_NOREF(cchWidth, cchPrecision);
    370     return rtStrFormatR80Worker(pszBuf, cbBuf, pr80Value->s.fSign, pr80Value->s.u64Mantissa >> 63,
    371                                 pr80Value->s.u64Mantissa & (RT_BIT_64(63) - 1), pr80Value->s.uExponent, fFlags);
    372 }
    373 
     370    return rtStrFormatR80Worker(pszBuf, cbBuf, pr80Value->s.fSign, pr80Value->s.uMantissa >> 63,
     371                                pr80Value->s.uMantissa & (RT_BIT_64(63) - 1), pr80Value->s.uExponent, fFlags);
     372}
     373
  • trunk/src/VBox/VMM/VMMAll/IEMAll.cpp

    r94163 r94261  
    84058405            else if (pr80Reg->s.uExponent == 0x0000)
    84068406            {
    8407                 if (pr80Reg->s.u64Mantissa == 0x0000)
     8407                if (pr80Reg->s.uMantissa == 0x0000)
    84088408                    uTag = 1; /* All bits are zero => Zero. */
    84098409                else
    84108410                    uTag = 2; /* Must be special. */
    84118411            }
    8412             else if (pr80Reg->s.u64Mantissa & RT_BIT_64(63)) /* The J bit. */
     8412            else if (pr80Reg->s.uMantissa & RT_BIT_64(63)) /* The J bit. */
    84138413                uTag = 0; /* Valid. */
    84148414            else
     
    1222412224#else
    1222512225# define IEM_MC_FETCH_MEM_R32(a_r32Dst, a_iSeg, a_GCPtrMem) \
    12226     ((a_r32Dst).u32 = iemMemFetchDataU32Jmp(pVCpu, (a_iSeg), (a_GCPtrMem)))
     12226    ((a_r32Dst).u = iemMemFetchDataU32Jmp(pVCpu, (a_iSeg), (a_GCPtrMem)))
    1222712227# define IEM_MC_FETCH_MEM_R64(a_r64Dst, a_iSeg, a_GCPtrMem) \
    12228     ((a_r64Dst).au64[0] = iemMemFetchDataU64Jmp(pVCpu, (a_iSeg), (a_GCPtrMem)))
     12228    ((a_r64Dst).u = iemMemFetchDataU64Jmp(pVCpu, (a_iSeg), (a_GCPtrMem)))
    1222912229# define IEM_MC_FETCH_MEM_R80(a_r80Dst, a_iSeg, a_GCPtrMem) \
    1223012230    iemMemFetchDataR80Jmp(pVCpu, &(a_r80Dst), (a_iSeg), (a_GCPtrMem))
     
    1240512405#define IEM_MC_STORE_MEM_I32_CONST_BY_REF(a_pi32Dst, a_i32C)    *(a_pi32Dst) = (a_i32C)
    1240612406#define IEM_MC_STORE_MEM_I64_CONST_BY_REF(a_pi64Dst, a_i64C)    *(a_pi64Dst) = (a_i64C)
    12407 #define IEM_MC_STORE_MEM_NEG_QNAN_R32_BY_REF(a_pr32Dst)         (a_pr32Dst)->u32    = UINT32_C(0xffc00000)
    12408 #define IEM_MC_STORE_MEM_NEG_QNAN_R64_BY_REF(a_pr64Dst)         (a_pr64Dst)->au64[0] = UINT64_C(0xfff8000000000000)
     12407#define IEM_MC_STORE_MEM_NEG_QNAN_R32_BY_REF(a_pr32Dst)         (a_pr32Dst)->u = UINT32_C(0xffc00000)
     12408#define IEM_MC_STORE_MEM_NEG_QNAN_R64_BY_REF(a_pr64Dst)         (a_pr64Dst)->u = UINT64_C(0xfff8000000000000)
    1240912409#define IEM_MC_STORE_MEM_NEG_QNAN_R80_BY_REF(a_pr80Dst) \
    1241012410    do { \
  • trunk/src/VBox/VMM/VMMAll/IEMAllAImpl.asm

    r94191 r94261  
    25132513; @param    A2      Pointer to the 32-bit floating point value to convert.
    25142514;
    2515 BEGINPROC_FASTCALL iemAImpl_fld_r32_to_r80, 12
     2515BEGINPROC_FASTCALL iemAImpl_fld_r80_from_r32, 12
    25162516        PROLOGUE_3_ARGS
    25172517        sub     xSP, 20h
     
    25282528        add     xSP, 20h
    25292529        EPILOGUE_3_ARGS
    2530 ENDPROC iemAImpl_fld_r32_to_r80
     2530ENDPROC iemAImpl_fld_r80_from_r32
    25312531
    25322532
     
    26382638; @param    A2      Pointer to the 64-bit floating point value to convert.
    26392639;
    2640 BEGINPROC_FASTCALL iemAImpl_fld_r64_to_r80, 12
     2640BEGINPROC_FASTCALL iemAImpl_fld_r80_from_r64, 12
    26412641        PROLOGUE_3_ARGS
    26422642        sub     xSP, 20h
     
    26522652        add     xSP, 20h
    26532653        EPILOGUE_3_ARGS
    2654 ENDPROC iemAImpl_fld_r64_to_r80
     2654ENDPROC iemAImpl_fld_r80_from_r64
    26552655
    26562656
  • trunk/src/VBox/VMM/VMMAll/IEMAllAImplC.cpp

    r94256 r94261  
    32513251
    32523252
    3253 IEM_DECL_IMPL_DEF(void, iemAImpl_fld_r32_to_r80,(PCX86FXSTATE pFpuState, PIEMFPURESULT pFpuRes, PCRTFLOAT32U pr32Val))
     3253IEM_DECL_IMPL_DEF(void, iemAImpl_fld_r80_from_r32,(PCX86FXSTATE pFpuState, PIEMFPURESULT pFpuRes, PCRTFLOAT32U pr32Val))
    32543254{
    32553255    RT_NOREF(pFpuState, pFpuRes, pr32Val);
     
    32583258
    32593259
    3260 IEM_DECL_IMPL_DEF(void, iemAImpl_fld_r64_to_r80,(PCX86FXSTATE pFpuState, PIEMFPURESULT pFpuRes, PCRTFLOAT64U pr64Val))
     3260IEM_DECL_IMPL_DEF(void, iemAImpl_fld_r80_from_r64,(PCX86FXSTATE pFpuState, PIEMFPURESULT pFpuRes, PCRTFLOAT64U pr64Val))
    32613261{
    32623262    RT_NOREF(pFpuState, pFpuRes, pr64Val);
     
    32763276    pFpuRes->r80Result.sj64.uExponent   = 0 + 16383;
    32773277    pFpuRes->r80Result.sj64.fInteger    = 1;
    3278     pFpuRes->r80Result.sj64.u63Fraction = 0;
     3278    pFpuRes->r80Result.sj64.uFraction  = 0;
    32793279
    32803280    /*
     
    32933293    pFpuRes->r80Result.sj64.uExponent   = 0 + 16383;
    32943294    pFpuRes->r80Result.sj64.fInteger    = 1;
    3295     pFpuRes->r80Result.sj64.u63Fraction =    (pFpuState->FCW & X86_FCW_RC_MASK) == X86_FCW_RC_NEAREST
     3295    pFpuRes->r80Result.sj64.uFraction  =    (pFpuState->FCW & X86_FCW_RC_MASK) == X86_FCW_RC_NEAREST
    32963296                                          || (pFpuState->FCW & X86_FCW_RC_MASK) == X86_FCW_RC_UP
    32973297                                        ? UINT64_C(0x38aa3b295c17f0bc) : UINT64_C(0x38aa3b295c17f0bb);
     
    33053305    pFpuRes->r80Result.sj64.uExponent   = 1 + 16383;
    33063306    pFpuRes->r80Result.sj64.fInteger    = 1;
    3307     pFpuRes->r80Result.sj64.u63Fraction = (pFpuState->FCW & X86_FCW_RC_MASK) != X86_FCW_RC_UP
     3307    pFpuRes->r80Result.sj64.uFraction  = (pFpuState->FCW & X86_FCW_RC_MASK) != X86_FCW_RC_UP
    33083308                                        ? UINT64_C(0x549a784bcd1b8afe) : UINT64_C(0x549a784bcd1b8aff);
    33093309    pFpuRes->FSW = (7 << X86_FSW_TOP_SHIFT) | (pFpuState->FSW & (X86_FSW_C0 | X86_FSW_C2 | X86_FSW_C3)); /* see iemAImpl_fld1 */
     
    33163316    pFpuRes->r80Result.sj64.uExponent   = -2 + 16383;
    33173317    pFpuRes->r80Result.sj64.fInteger    = 1;
    3318     pFpuRes->r80Result.sj64.u63Fraction =    (pFpuState->FCW & X86_FCW_RC_MASK) == X86_FCW_RC_NEAREST
     3318    pFpuRes->r80Result.sj64.uFraction  =    (pFpuState->FCW & X86_FCW_RC_MASK) == X86_FCW_RC_NEAREST
    33193319                                          || (pFpuState->FCW & X86_FCW_RC_MASK) == X86_FCW_RC_UP
    33203320                                        ? UINT64_C(0x1a209a84fbcff799) : UINT64_C(0x1a209a84fbcff798);
     
    33283328    pFpuRes->r80Result.sj64.uExponent   = -1 + 16383;
    33293329    pFpuRes->r80Result.sj64.fInteger    = 1;
    3330     pFpuRes->r80Result.sj64.u63Fraction =    (pFpuState->FCW & X86_FCW_RC_MASK) == X86_FCW_RC_NEAREST
     3330    pFpuRes->r80Result.sj64.uFraction  =    (pFpuState->FCW & X86_FCW_RC_MASK) == X86_FCW_RC_NEAREST
    33313331                                          || (pFpuState->FCW & X86_FCW_RC_MASK) == X86_FCW_RC_UP
    33323332                                        ? UINT64_C(0x317217f7d1cf79ac) : UINT64_C(0x317217f7d1cf79ab);
     
    33403340    pFpuRes->r80Result.sj64.uExponent   = 1 + 16383;
    33413341    pFpuRes->r80Result.sj64.fInteger    = 1;
    3342     pFpuRes->r80Result.sj64.u63Fraction =    (pFpuState->FCW & X86_FCW_RC_MASK) == X86_FCW_RC_NEAREST
     3342    pFpuRes->r80Result.sj64.uFraction  =    (pFpuState->FCW & X86_FCW_RC_MASK) == X86_FCW_RC_NEAREST
    33433343                                          || (pFpuState->FCW & X86_FCW_RC_MASK) == X86_FCW_RC_UP
    33443344                                        ? UINT64_C(0x490fdaa22168c235) : UINT64_C(0x490fdaa22168c234);
     
    33523352    pFpuRes->r80Result.sj64.uExponent   = 0;
    33533353    pFpuRes->r80Result.sj64.fInteger    = 0;
    3354     pFpuRes->r80Result.sj64.u63Fraction = 0;
     3354    pFpuRes->r80Result.sj64.uFraction  = 0;
    33553355    pFpuRes->FSW = (7 << X86_FSW_TOP_SHIFT) | (pFpuState->FSW & (X86_FSW_C0 | X86_FSW_C2 | X86_FSW_C3)); /* see iemAImpl_fld1 */
    33563356}
  • trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsOneByte.cpp.h

    r94163 r94261  
    74537453    IEM_MC_PREPARE_FPU_USAGE();
    74547454    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    7455         IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r32_to_r80, pFpuRes, pr32Val);
     7455        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r80_from_r32, pFpuRes, pr32Val);
    74567456        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    74577457    IEM_MC_ELSE()
     
    93399339    IEM_MC_PREPARE_FPU_USAGE();
    93409340    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    9341         IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r64_to_r80, pFpuRes, pr64Val);
     9341        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r80_from_r64, pFpuRes, pr64Val);
    93429342        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    93439343    IEM_MC_ELSE()
  • trunk/src/VBox/VMM/VMMR3/DBGFReg.cpp

    r93115 r94261  
    572572    pValue->r80.s.fSign       = 0;
    573573    pValue->r80.s.uExponent   = 16383;
    574     pValue->r80.s.u64Mantissa = u64;
     574    pValue->r80.s.uMantissa  = u64;
    575575}
    576576
     
    587587    pValue->r80.s.fSign       = 0;
    588588    pValue->r80.s.uExponent   = 16383;
    589     pValue->r80.s.u64Mantissa = u128.s.Lo;
     589    pValue->r80.s.uMantissa  = u128.s.Lo;
    590590}
    591591
     
    600600{
    601601    /** @todo stupid, stupid MSC. */
    602     return pValue->r80.s.u64Mantissa;
     602    return pValue->r80.s.uMantissa;
    603603}
    604604
     
    618618    uRet.s.Hi = (uint64_t)InVal.lrd / _4G / _4G;
    619619#else
    620     uRet.s.Lo = pValue->r80.s.u64Mantissa;
     620    uRet.s.Lo = pValue->r80.s.uMantissa;
    621621    uRet.s.Hi = 0;
    622622#endif
  • trunk/src/VBox/VMM/include/IEMInternal.h

    r94163 r94261  
    9292/** Pointer to IEM instruction statistics. */
    9393typedef IEMINSTRSTATS *PIEMINSTRSTATS;
    94 
    95 /** Finish and move to types.h */
    96 typedef union
    97 {
    98     uint32_t u32;
    99 } RTFLOAT32U;
    100 typedef RTFLOAT32U *PRTFLOAT32U;
    101 typedef RTFLOAT32U const *PCRTFLOAT32U;
    10294
    10395
     
    13641356FNIEMAIMPLFPUR32    iemAImpl_fdivr_r80_by_r32;
    13651357
    1366 IEM_DECL_IMPL_DEF(void, iemAImpl_fld_r32_to_r80,(PCX86FXSTATE pFpuState, PIEMFPURESULT pFpuRes, PCRTFLOAT32U pr32Val));
     1358IEM_DECL_IMPL_DEF(void, iemAImpl_fld_r80_from_r32,(PCX86FXSTATE pFpuState, PIEMFPURESULT pFpuRes, PCRTFLOAT32U pr32Val));
    13671359IEM_DECL_IMPL_DEF(void, iemAImpl_fst_r80_to_r32,(PCX86FXSTATE pFpuState, uint16_t *pu16FSW,
    13681360                                                 PRTFLOAT32U pr32Val, PCRTFLOAT80U pr80Val));
     
    13841376IEM_DECL_IMPL_DEF(void, iemAImpl_fcom_r80_by_r64,(PCX86FXSTATE pFpuState, uint16_t *pFSW,
    13851377                                                  PCRTFLOAT80U pr80Val1, PCRTFLOAT64U pr64Val2));
    1386 IEM_DECL_IMPL_DEF(void, iemAImpl_fld_r64_to_r80,(PCX86FXSTATE pFpuState, PIEMFPURESULT pFpuRes, PCRTFLOAT64U pr64Val));
     1378IEM_DECL_IMPL_DEF(void, iemAImpl_fld_r80_from_r64,(PCX86FXSTATE pFpuState, PIEMFPURESULT pFpuRes, PCRTFLOAT64U pr64Val));
    13871379IEM_DECL_IMPL_DEF(void, iemAImpl_fst_r80_to_r64,(PCX86FXSTATE pFpuState, uint16_t *pu16FSW,
    13881380                                                 PRTFLOAT64U pr32Val, PCRTFLOAT80U pr80Val));
  • trunk/src/VBox/VMM/testcase/tstIEMAImpl.cpp

    r94260 r94261  
    194194#define ENTRY(a_Name)       ENTRY_EX(a_Name, 0)
    195195#define ENTRY_EX(a_Name, a_uExtra) \
    196     { #a_Name, iemAImpl_ ## a_Name, NULL, \
     196    { RT_XSTR(a_Name), iemAImpl_ ## a_Name, NULL, \
    197197      g_aTests_ ## a_Name, RT_ELEMENTS(g_aTests_ ## a_Name), \
    198198      a_uExtra, IEMTARGETCPU_EFL_BEHAVIOR_NATIVE /* means same for all here */ }
     
    200200#define ENTRY_INTEL(a_Name, a_fEflUndef) ENTRY_INTEL_EX(a_Name, a_fEflUndef, 0)
    201201#define ENTRY_INTEL_EX(a_Name, a_fEflUndef, a_uExtra) \
    202     { #a_Name "_intel", iemAImpl_ ## a_Name ## _intel, iemAImpl_ ## a_Name, \
     202    { RT_XSTR(a_Name) "_intel", iemAImpl_ ## a_Name ## _intel, iemAImpl_ ## a_Name, \
    203203      g_aTests_ ## a_Name ## _intel, RT_ELEMENTS(g_aTests_ ## a_Name ## _intel), \
    204204      a_uExtra, IEMTARGETCPU_EFL_BEHAVIOR_INTEL }
     
    206206#define ENTRY_AMD(a_Name, a_fEflUndef)   ENTRY_AMD_EX(a_Name, a_fEflUndef, 0)
    207207#define ENTRY_AMD_EX(a_Name, a_fEflUndef, a_uExtra) \
    208     { #a_Name "_amd", iemAImpl_ ## a_Name ## _amd,   iemAImpl_ ## a_Name, \
     208    { RT_XSTR(a_Name) "_amd", iemAImpl_ ## a_Name ## _amd,   iemAImpl_ ## a_Name, \
    209209      g_aTests_ ## a_Name ## _amd, RT_ELEMENTS(g_aTests_ ## a_Name ## _amd), \
    210210      a_uExtra, IEMTARGETCPU_EFL_BEHAVIOR_AMD }
     
    226226static RTUINT128U  *g_pu128, *g_pu128Two;
    227227
     228static char         g_aszBuf[16][256];
     229static unsigned     g_idxBuf = 0;
     230
    228231
    229232#include "tstIEMAImplData.h"
     
    338341        return 0;
    339342    return RandU64();
     343}
     344
     345
     346static RTFLOAT80U RandR80Src(uint32_t iTest)
     347{
     348    RTFLOAT80U lrd;
     349    if (iTest < g_cZeroSrcTests)
     350    {
     351        lrd.au64[0] = 0;
     352        lrd.au16[4] = 0;
     353    }
     354    else
     355    {
     356        lrd.au64[0] = RandU64();
     357        lrd.au16[4] = RandU16();
     358    }
     359    return lrd;
     360}
     361
     362
     363static RTFLOAT64U RandR64Src(uint32_t iTest)
     364{
     365    RTFLOAT64U rd;
     366    if (iTest < g_cZeroSrcTests)
     367        rd.u = 0;
     368    else
     369        rd.u = RandU64();
     370    return rd;
     371}
     372
     373
     374static RTFLOAT32U RandR32Src(uint32_t iTest)
     375{
     376    RTFLOAT32U r;
     377    if (iTest < g_cZeroSrcTests)
     378        r.u = 0;
     379    else
     380        r.u = RandU32();
     381    return r;
     382}
     383
     384
     385const char *GenFormatR80(PCRTFLOAT80U plrd)
     386{
     387    char *pszBuf = g_aszBuf[g_idxBuf++ % RT_ELEMENTS(g_aszBuf)];
     388    RTStrPrintf(pszBuf, sizeof(g_aszBuf[0]), "RTFLOAT80U_INIT_C(%d,%#RX64,%u)",
     389                plrd->s.fSign, plrd->s.uMantissa, plrd->s.uExponent);
     390    return pszBuf;
     391}
     392
     393const char *GenFormatR64(PCRTFLOAT64U prd)
     394{
     395    char *pszBuf = g_aszBuf[g_idxBuf++ % RT_ELEMENTS(g_aszBuf)];
     396    RTStrPrintf(pszBuf, sizeof(g_aszBuf[0]), "RTFLOAT64U_INIT_C(%d,%#RX64,%u)",
     397                prd->s.fSign, RT_MAKE_U64(prd->s.uFractionLow, prd->s.uFractionHigh), prd->s.uExponent);
     398    return pszBuf;
     399}
     400
     401
     402const char *GenFormatR32(PCRTFLOAT32U pr)
     403{
     404    char *pszBuf = g_aszBuf[g_idxBuf++ % RT_ELEMENTS(g_aszBuf)];
     405    RTStrPrintf(pszBuf, sizeof(g_aszBuf[0]), "RTFLOAT32U_INIT_C(%d,%#RX32,%u)", pr->s.fSign, pr->s.uFraction, pr->s.uExponent);
     406    return pszBuf;
    340407}
    341408
     
    399466 * Test helpers.
    400467 */
    401 static char     g_szBuf[16][256];
    402 static unsigned g_idxBuf = 0;
    403 
    404 
    405468static const char *EFlagsDiff(uint32_t fActual, uint32_t fExpected)
    406469{
     
    409472
    410473    uint32_t const fXor = fActual ^ fExpected;
    411     char *pszBuf = g_szBuf[g_idxBuf++ % RT_ELEMENTS(g_szBuf)];
    412     size_t cch = RTStrPrintf(pszBuf, sizeof(g_szBuf[0]), " - %#x", fXor);
     474    char *pszBuf = g_aszBuf[g_idxBuf++ % RT_ELEMENTS(g_aszBuf)];
     475    size_t cch = RTStrPrintf(pszBuf, sizeof(g_aszBuf[0]), " - %#x", fXor);
    413476
    414477    static struct
     
    439502    for (size_t i = 0; i < RT_ELEMENTS(s_aFlags); i++)
    440503        if (s_aFlags[i].fFlag & fXor)
    441             cch += RTStrPrintf(&pszBuf[cch], sizeof(g_szBuf[0]) - cch,
     504            cch += RTStrPrintf(&pszBuf[cch], sizeof(g_aszBuf[0]) - cch,
    442505                               s_aFlags[i].fFlag & fActual ? "/%s" : "/!%s", s_aFlags[i].pszName);
    443     RTStrPrintf(&pszBuf[cch], sizeof(g_szBuf[0]) - cch, "");
     506    RTStrPrintf(&pszBuf[cch], sizeof(g_aszBuf[0]) - cch, "");
    444507    return pszBuf;
    445508}
     
    452515
    453516    uint16_t const fXor = fActual ^ fExpected;
    454     char *pszBuf = g_szBuf[g_idxBuf++ % RT_ELEMENTS(g_szBuf)];
    455     size_t cch = RTStrPrintf(pszBuf, sizeof(g_szBuf[0]), " - %#x", fXor);
     517    char *pszBuf = g_aszBuf[g_idxBuf++ % RT_ELEMENTS(g_aszBuf)];
     518    size_t cch = RTStrPrintf(pszBuf, sizeof(g_aszBuf[0]), " - %#x", fXor);
    456519
    457520    static struct
     
    478541    for (size_t i = 0; i < RT_ELEMENTS(s_aFlags); i++)
    479542        if (s_aFlags[i].fFlag & fXor)
    480             cch += RTStrPrintf(&pszBuf[cch], sizeof(g_szBuf[0]) - cch,
     543            cch += RTStrPrintf(&pszBuf[cch], sizeof(g_aszBuf[0]) - cch,
    481544                               s_aFlags[i].fFlag & fActual ? "/%s" : "/!%s", s_aFlags[i].pszName);
    482545    if (fXor & X86_FSW_TOP_MASK)
    483         cch += RTStrPrintf(&pszBuf[cch], sizeof(g_szBuf[0]) - cch, "/TOP%u!%u",
     546        cch += RTStrPrintf(&pszBuf[cch], sizeof(g_aszBuf[0]) - cch, "/TOP%u!%u",
    484547                           X86_FSW_TOP_GET(fActual), X86_FSW_TOP_GET(fExpected));
    485     RTStrPrintf(&pszBuf[cch], sizeof(g_szBuf[0]) - cch, "");
     548    RTStrPrintf(&pszBuf[cch], sizeof(g_aszBuf[0]) - cch, "");
    486549    return pszBuf;
    487550}
     
    490553static const char *FormatFcw(uint16_t fFcw)
    491554{
    492     char *pszBuf = g_szBuf[g_idxBuf++ % RT_ELEMENTS(g_szBuf)];
     555    char *pszBuf = g_aszBuf[g_idxBuf++ % RT_ELEMENTS(g_aszBuf)];
    493556
    494557    const char *pszPC = NULL; /* (msc+gcc are too stupid) */
     
    509572        case X86_FCW_RC_ZERO:       pszRC = "ZERO"; break;
    510573    }
    511     size_t cch = RTStrPrintf(&pszBuf[0], sizeof(g_szBuf[0]), "%s %s", pszPC, pszRC);
     574    size_t cch = RTStrPrintf(&pszBuf[0], sizeof(g_aszBuf[0]), "%s %s", pszPC, pszRC);
    512575
    513576    static struct
     
    528591    for (size_t i = 0; i < RT_ELEMENTS(s_aFlags); i++)
    529592        if (fFcw & s_aFlags[i].fFlag)
    530             cch += RTStrPrintf(&pszBuf[cch], sizeof(g_szBuf[0]) - cch, " %s", s_aFlags[i].pszName);
    531 
    532     RTStrPrintf(&pszBuf[cch], sizeof(g_szBuf[0]) - cch, "");
     593            cch += RTStrPrintf(&pszBuf[cch], sizeof(g_aszBuf[0]) - cch, " %s", s_aFlags[i].pszName);
     594
     595    RTStrPrintf(&pszBuf[cch], sizeof(g_aszBuf[0]) - cch, "");
    533596    return pszBuf;
    534597}
     
    537600static const char *FormatR80(PCRTFLOAT80U pr80)
    538601{
    539     char *pszBuf = g_szBuf[g_idxBuf++ % RT_ELEMENTS(g_szBuf)];
    540     RTStrFormatR80(pszBuf, sizeof(g_szBuf[0]), pr80, 0, 0, RTSTR_F_SPECIAL);
     602    char *pszBuf = g_aszBuf[g_idxBuf++ % RT_ELEMENTS(g_aszBuf)];
     603    RTStrFormatR80(pszBuf, sizeof(g_aszBuf[0]), pr80, 0, 0, RTSTR_F_SPECIAL);
     604    return pszBuf;
     605}
     606
     607
     608static const char *FormatR64(PCRTFLOAT64U pr64)
     609{
     610    char *pszBuf = g_aszBuf[g_idxBuf++ % RT_ELEMENTS(g_aszBuf)];
     611    RTStrPrintf(pszBuf, sizeof(g_aszBuf[0]), "%c1m%#015RX64^%d",
     612                pr64->s.fSign ? '-' : '+',
     613                RT_MAKE_U64(pr64->s.uFractionLow, pr64->s.uFractionHigh),
     614                pr64->s.uExponent - 1023);
     615    return pszBuf;
     616}
     617
     618
     619static const char *FormatR32(PCRTFLOAT32U pr32)
     620{
     621    char *pszBuf = g_aszBuf[g_idxBuf++ % RT_ELEMENTS(g_aszBuf)];
     622    RTStrPrintf(pszBuf, sizeof(g_aszBuf[0]), "%c1m%#010RX32^%d",
     623                pr32->s.fSign ? '-' : '+',
     624                pr32->s.uFraction,
     625                pr32->s.uExponent - 127);
    541626    return pszBuf;
    542627}
     
    19001985
    19011986
    1902 /*
    1903  * FPU constant loading.
    1904  */
     1987
     1988/*********************************************************************************************************************************
     1989*   Floating point (x87 style)                                                                                                   *
     1990*********************************************************************************************************************************/
    19051991
    19061992typedef struct FPU_LD_CONST_TEST_T
     
    19111997    RTFLOAT80U              rdResult;
    19121998} FPU_LD_CONST_TEST_T;
     1999
     2000typedef struct FPU_R32_IN_TEST_T
     2001{
     2002    uint16_t                fFcw;
     2003    uint16_t                fFswIn;
     2004    uint16_t                fFswOut;
     2005    RTFLOAT80U              rdResult;
     2006    RTFLOAT32U              InVal;
     2007} FPU_R32_IN_TEST_T;
     2008
     2009typedef struct FPU_R64_IN_TEST_T
     2010{
     2011    uint16_t                fFcw;
     2012    uint16_t                fFswIn;
     2013    uint16_t                fFswOut;
     2014    RTFLOAT80U              rdResult;
     2015    RTFLOAT64U              InVal;
     2016} FPU_R64_IN_TEST_T;
     2017
     2018typedef struct FPU_R80_IN_TEST_T
     2019{
     2020    uint16_t                fFcw;
     2021    uint16_t                fFswIn;
     2022    uint16_t                fFswOut;
     2023    RTFLOAT80U              rdResult;
     2024    RTFLOAT80U              InVal;
     2025} FPU_R80_IN_TEST_T;
     2026#include "tstIEMAImplDataFpu.h"
     2027
     2028
     2029/*
     2030 * FPU constant loading.
     2031 */
     2032
     2033#ifndef HAVE_FPU_LOAD_CONST_TESTS
     2034static const FPU_LD_CONST_TEST_T g_aTests_fld1[]   = { {0} };
     2035static const FPU_LD_CONST_TEST_T g_aTests_fldl2t[] = { {0} };
     2036static const FPU_LD_CONST_TEST_T g_aTests_fldl2e[] = { {0} };
     2037static const FPU_LD_CONST_TEST_T g_aTests_fldpi[]  = { {0} };
     2038static const FPU_LD_CONST_TEST_T g_aTests_fldlg2[] = { {0} };
     2039static const FPU_LD_CONST_TEST_T g_aTests_fldln2[] = { {0} };
     2040static const FPU_LD_CONST_TEST_T g_aTests_fldz[]   = { {0} };
     2041#endif
    19132042
    19142043typedef struct FPU_LD_CONST_T
     
    19232052} FPU_LD_CONST_T;
    19242053
    1925 #include "tstIEMAImplDataFpu.h"
    1926 
    1927 #ifndef HAVE_FPU_LOAD_CONST_TESTS
    1928 static const FPU_LD_CONST_TEST_T g_aTests_fld1[]   = { {0} };
    1929 static const FPU_LD_CONST_TEST_T g_aTests_fldl2t[] = { {0} };
    1930 static const FPU_LD_CONST_TEST_T g_aTests_fldl2e[] = { {0} };
    1931 static const FPU_LD_CONST_TEST_T g_aTests_fldpi[]  = { {0} };
    1932 static const FPU_LD_CONST_TEST_T g_aTests_fldlg2[] = { {0} };
    1933 static const FPU_LD_CONST_TEST_T g_aTests_fldln2[] = { {0} };
    1934 static const FPU_LD_CONST_TEST_T g_aTests_fldz[]   = { {0} };
    1935 #endif
    1936 
    19372054static const FPU_LD_CONST_T g_aFpuLdConst[] =
    19382055{
     
    19472064
    19482065#ifdef TSTIEMAIMPL_WITH_GENERATOR
    1949 static void FpuLoadConstGenerate(PRTSTREAM pOut, uint32_t cTests)
     2066static void FpuLdConstGenerate(PRTSTREAM pOut, uint32_t cTests)
    19502067{
    19512068    RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_LOAD_CONST_TESTS\n");
     
    19652082                State.FCW = (State.FCW & ~X86_FCW_RC_MASK) | (iRounding << X86_FCW_RC_SHIFT);
    19662083                g_aFpuLdConst[iFn].pfn(&State, &Res);
    1967                 RTStrmPrintf(pOut, "    { %#06x, %#06x, %#06x, RTFLOAT80U_INIT_C(%d,%u,%#RX64) }, /* #%u */\n",
    1968                              State.FCW, State.FSW, Res.FSW,
    1969                              Res.r80Result.s.fSign, Res.r80Result.s.uExponent, Res.r80Result.s.u64Mantissa, iTest + iRounding);
     2084                RTStrmPrintf(pOut, "    { %#06x, %#06x, %#06x, %s }, /* #%u */\n",
     2085                             State.FCW, State.FSW, Res.FSW, GenFormatR80(&Res.r80Result), iTest + iRounding);
    19702086            }
    19712087        }
     
    20172133}
    20182134
     2135
     2136/*
     2137 * Load values from memory.
     2138 */
     2139
     2140#ifndef HAVE_FPU_LD_MEM
     2141static FPU_R80_IN_TEST_T const g_aTests_fld_r80_from_r80[] = { {0} };
     2142static FPU_R64_IN_TEST_T const g_aTests_fld_r80_from_r64[] = { {0} };
     2143static FPU_R32_IN_TEST_T const g_aTests_fld_r80_from_r32[] = { {0} };
     2144#endif
     2145
     2146#ifdef TSTIEMAIMPL_WITH_GENERATOR
     2147# define GEN_FPU_LOAD(a_cBits, a_rdTypeIn, a_aSubTests, a_TestType) \
     2148static void FpuLdR ## a_cBits ## Generate(PRTSTREAM pOut, uint32_t cTests) \
     2149{ \
     2150    X86FXSTATE State; \
     2151    RT_ZERO(State); \
     2152    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
     2153    { \
     2154        RTStrmPrintf(pOut, "static const " #a_TestType " g_aTests_%s[] =\n{\n", a_aSubTests[iFn].pszName); \
     2155        for (uint32_t iTest = 0; iTest < cTests; iTest += 4) \
     2156        { \
     2157            State.FCW = RandU16() & (X86_FCW_MASK_ALL | X86_FCW_PC_MASK); \
     2158            State.FSW = RandU16() & (X86_FSW_C_MASK | X86_FSW_XCPT_ES_MASK | X86_FSW_TOP_MASK | X86_FSW_B); \
     2159            a_rdTypeIn InVal = RandR ## a_cBits ## Src(iTest); \
     2160            \
     2161            for (uint16_t iRounding = 0; iRounding < 4; iRounding++) \
     2162            { \
     2163                IEMFPURESULT Res; \
     2164                State.FCW = (State.FCW & ~X86_FCW_RC_MASK) | (iRounding << X86_FCW_RC_SHIFT); \
     2165                a_aSubTests[iFn].pfn(&State, &Res, &InVal); \
     2166                RTStrmPrintf(pOut, "    { %#06x, %#06x, %#06x, %s, %s }, /* #%u */\n", \
     2167                             State.FCW, State.FSW, Res.FSW, GenFormatR80(&Res.r80Result), \
     2168                             GenFormatR ## a_cBits(&InVal), iTest + iRounding); \
     2169            } \
     2170        } \
     2171        RTStrmPrintf(pOut, "};\n"); \
     2172    } \
     2173}
     2174#else
     2175# define GEN_FPU_LOAD(a_cBits, a_rdTypeIn, a_aSubTests, a_TestType)
     2176#endif
     2177
     2178#define TEST_FPU_LOAD(a_cBits, a_rdTypeIn, a_SubTestType, a_aSubTests, a_TestType) \
     2179typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLFPULDR80FROM ## a_cBits,(PCX86FXSTATE, PIEMFPURESULT, PC ## a_rdTypeIn)); \
     2180typedef FNIEMAIMPLFPULDR80FROM ## a_cBits *PFNIEMAIMPLFPULDR80FROM ## a_cBits; \
     2181typedef struct a_SubTestType \
     2182{ \
     2183    const char                             *pszName; \
     2184    PFNIEMAIMPLFPULDR80FROM ## a_cBits      pfn, pfnNative; \
     2185    a_TestType const                       *paTests; \
     2186    uint32_t                                cTests; \
     2187    uint32_t                                uExtra; \
     2188    uint8_t                                 idxCpuEflFlavour; \
     2189} a_SubTestType; \
     2190\
     2191static const a_SubTestType a_aSubTests[] = \
     2192{ \
     2193    ENTRY(RT_CONCAT(fld_r80_from_r,a_cBits)) \
     2194}; \
     2195GEN_FPU_LOAD(a_cBits, a_rdTypeIn, a_aSubTests, a_TestType) \
     2196\
     2197static void FpuLdR ## a_cBits ## Test(void) \
     2198{ \
     2199    X86FXSTATE State; \
     2200    RT_ZERO(State); \
     2201    for (size_t iFn = 0; iFn < RT_ELEMENTS(a_aSubTests); iFn++) \
     2202    { \
     2203        RTTestSub(g_hTest, a_aSubTests[iFn].pszName); \
     2204        \
     2205        uint32_t const                     cTests  = a_aSubTests[iFn].cTests; \
     2206        a_TestType const           * const paTests = a_aSubTests[iFn].paTests; \
     2207        PFNIEMAIMPLFPULDR80FROM ## a_cBits pfn     = a_aSubTests[iFn].pfn; \
     2208        uint32_t const cVars = 1 + (a_aSubTests[iFn].idxCpuEflFlavour == g_idxCpuEflFlavour && a_aSubTests[iFn].pfnNative); \
     2209        for (uint32_t iVar = 0; iVar < cVars; iVar++) \
     2210        { \
     2211            for (uint32_t iTest = 0; iTest < cTests; iTest++) \
     2212            { \
     2213                a_rdTypeIn const InVal = paTests[iTest].InVal; \
     2214                State.FCW = paTests[iTest].fFcw; \
     2215                State.FSW = paTests[iTest].fFswIn; \
     2216                IEMFPURESULT Res; \
     2217                pfn(&State, &Res, &InVal); \
     2218                if (   Res.FSW != paTests[iTest].fFswOut \
     2219                    || !RTFLOAT80U_ARE_IDENTICAL(&Res.r80Result, &paTests[iTest].rdResult)) \
     2220                    RTTestFailed(g_hTest, "#%u%s: fcw=%#06x fsw=%#06x in=%s -> fsw=%#06x %s, expected %#06x %s%s%s (%s)\n", \
     2221                                 iTest, iVar ? "/n" : "", paTests[iTest].fFcw, paTests[iTest].fFswIn, \
     2222                                 FormatR ## a_cBits(&paTests[iTest].InVal), \
     2223                                 Res.FSW, FormatR80(&Res.r80Result), \
     2224                                 paTests[iTest].fFswOut, FormatR80(&paTests[iTest].rdResult), \
     2225                                 FswDiff(Res.FSW, paTests[iTest].fFswOut), \
     2226                                 !RTFLOAT80U_ARE_IDENTICAL(&Res.r80Result, &paTests[iTest].rdResult) ? " - val" : "", \
     2227                                 FormatFcw(paTests[iTest].fFcw) ); \
     2228            } \
     2229            pfn = a_aSubTests[iFn].pfnNative; \
     2230        } \
     2231    } \
     2232}
     2233
     2234TEST_FPU_LOAD(80, RTFLOAT80U, FPU_LD_R80_T, g_aFpuLdR80, FPU_R80_IN_TEST_T)
     2235TEST_FPU_LOAD(64, RTFLOAT64U, FPU_LD_R64_T, g_aFpuLdR64, FPU_R64_IN_TEST_T)
     2236TEST_FPU_LOAD(32, RTFLOAT32U, FPU_LD_R32_T, g_aFpuLdR32, FPU_R32_IN_TEST_T)
     2237
     2238#ifdef TSTIEMAIMPL_WITH_GENERATOR
     2239static void FpuLdMemGenerate(PRTSTREAM pOut, uint32_t cTests)
     2240{
     2241    RTStrmPrintf(pOut, "\n\n#define HAVE_FPU_LD_MEM\n");
     2242    FpuLdR80Generate(pOut, cTests);
     2243    FpuLdR64Generate(pOut, cTests);
     2244    FpuLdR32Generate(pOut, cTests);
     2245}
     2246#endif
     2247
     2248static void FpuLdMemTest(void)
     2249{
     2250    FpuLdR80Test();
     2251    FpuLdR64Test();
     2252    FpuLdR32Test();
     2253}
    20192254
    20202255
     
    21272362    {
    21282363#ifdef TSTIEMAIMPL_WITH_GENERATOR
    2129 
    21302364        char szCpuDesc[256] = {0};
    21312365        RTMpGetDescription(NIL_RTCPUID, szCpuDesc, sizeof(szCpuDesc));
     
    21952429            GenerateHeader(pStrmDataCpu, "Fpu", szCpuDesc, pszCpuType, pszCpuSuff);
    21962430
    2197             FpuLoadConstGenerate(pStrmData, cTests);
     2431            FpuLdConstGenerate(pStrmData, cTests);
     2432            FpuLdMemGenerate(pStrmData, cTests);
    21982433
    21992434            RTEXITCODE rcExit = GenerateFooterAndClose(pStrmDataCpu, pszDataCpuFile, "Fpu", pszCpuSuff,
     
    22172452    if (enmMode == kModeTest)
    22182453    {
     2454        RTTestBanner(g_hTest);
     2455
    22192456        /* Allocate guarded memory for use in the tests. */
    22202457#define ALLOC_GUARDED_VAR(a_puVar) do { \
     
    22562493            {
    22572494                FpuLoadConstTest();
     2495                FpuLdMemTest();
    22582496            }
    22592497        }
  • trunk/src/VBox/VMM/testcase/tstIEMAImplDataFpu.h

    r94256 r94261  
    11/* $Id$ */
    22/** @file
    3  * IEM Assembly Instruction Helper Testcase Data - r150477 on Intel(R) Core(TM) i9-10980XE CPU @ 3.00GHz.
     3 * IEM Assembly Instruction Helper Testcase Data - r150519 on Intel(R) Core(TM) i9-10980XE CPU @ 3.00GHz.
    44 */
    55
     
    2626static const FPU_LD_CONST_TEST_T g_aTests_fld1[] =
    2727{
    28     { 0x0317, 0xa71a, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #0 */
    29     { 0x0717, 0xa71a, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #1 */
    30     { 0x0b17, 0xa71a, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #2 */
    31     { 0x0f17, 0xa71a, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #3 */
    32     { 0x0171, 0xed21, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #4 */
    33     { 0x0571, 0xed21, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #5 */
    34     { 0x0971, 0xed21, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #6 */
    35     { 0x0d71, 0xed21, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #7 */
    36     { 0x0316, 0x5ed1, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #8 */
    37     { 0x0716, 0x5ed1, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #9 */
    38     { 0x0b16, 0x5ed1, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #10 */
    39     { 0x0f16, 0x5ed1, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #11 */
    40     { 0x031d, 0xbcec, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #12 */
    41     { 0x071d, 0xbcec, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #13 */
    42     { 0x0b1d, 0xbcec, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #14 */
    43     { 0x0f1d, 0xbcec, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #15 */
    44     { 0x010e, 0x1343, 0x3900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #16 */
    45     { 0x050e, 0x1343, 0x3900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #17 */
    46     { 0x090e, 0x1343, 0x3900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #18 */
    47     { 0x0d0e, 0x1343, 0x3900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #19 */
    48     { 0x017e, 0x345c, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #20 */
    49     { 0x057e, 0x345c, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #21 */
    50     { 0x097e, 0x345c, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #22 */
    51     { 0x0d7e, 0x345c, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #23 */
    52     { 0x0045, 0x6e49, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #24 */
    53     { 0x0445, 0x6e49, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #25 */
    54     { 0x0845, 0x6e49, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #26 */
    55     { 0x0c45, 0x6e49, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #27 */
    56     { 0x012f, 0x2505, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #28 */
    57     { 0x052f, 0x2505, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #29 */
    58     { 0x092f, 0x2505, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #30 */
    59     { 0x0d2f, 0x2505, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #31 */
    60     { 0x0270, 0xb667, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #32 */
    61     { 0x0670, 0xb667, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #33 */
    62     { 0x0a70, 0xb667, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #34 */
    63     { 0x0e70, 0xb667, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #35 */
    64     { 0x0269, 0x6e98, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #36 */
    65     { 0x0669, 0x6e98, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #37 */
    66     { 0x0a69, 0x6e98, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #38 */
    67     { 0x0e69, 0x6e98, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #39 */
    68     { 0x0229, 0x254e, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #40 */
    69     { 0x0629, 0x254e, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #41 */
    70     { 0x0a29, 0x254e, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #42 */
    71     { 0x0e29, 0x254e, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #43 */
    72     { 0x021e, 0xc0e1, 0x7800, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #44 */
    73     { 0x061e, 0xc0e1, 0x7800, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #45 */
    74     { 0x0a1e, 0xc0e1, 0x7800, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #46 */
    75     { 0x0e1e, 0xc0e1, 0x7800, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #47 */
    76     { 0x0047, 0xd889, 0x7800, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #48 */
    77     { 0x0447, 0xd889, 0x7800, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #49 */
    78     { 0x0847, 0xd889, 0x7800, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #50 */
    79     { 0x0c47, 0xd889, 0x7800, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #51 */
    80     { 0x0272, 0xb64c, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #52 */
    81     { 0x0672, 0xb64c, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #53 */
    82     { 0x0a72, 0xb64c, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #54 */
    83     { 0x0e72, 0xb64c, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #55 */
    84     { 0x0275, 0xa6e2, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #56 */
    85     { 0x0675, 0xa6e2, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #57 */
    86     { 0x0a75, 0xa6e2, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #58 */
    87     { 0x0e75, 0xa6e2, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #59 */
    88     { 0x013e, 0xb3f9, 0x3900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #60 */
    89     { 0x053e, 0xb3f9, 0x3900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #61 */
    90     { 0x093e, 0xb3f9, 0x3900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #62 */
    91     { 0x0d3e, 0xb3f9, 0x3900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #63 */
    92     { 0x0102, 0x8e81, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #64 */
    93     { 0x0502, 0x8e81, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #65 */
    94     { 0x0902, 0x8e81, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #66 */
    95     { 0x0d02, 0x8e81, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #67 */
    96     { 0x0131, 0x4c96, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #68 */
    97     { 0x0531, 0x4c96, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #69 */
    98     { 0x0931, 0x4c96, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #70 */
    99     { 0x0d31, 0x4c96, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #71 */
    100     { 0x0271, 0xf9c0, 0x7900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #72 */
    101     { 0x0671, 0xf9c0, 0x7900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #73 */
    102     { 0x0a71, 0xf9c0, 0x7900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #74 */
    103     { 0x0e71, 0xf9c0, 0x7900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #75 */
    104     { 0x021b, 0x1701, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #76 */
    105     { 0x061b, 0x1701, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #77 */
    106     { 0x0a1b, 0x1701, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #78 */
    107     { 0x0e1b, 0x1701, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #79 */
    108     { 0x0045, 0x2457, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #80 */
    109     { 0x0445, 0x2457, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #81 */
    110     { 0x0845, 0x2457, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #82 */
    111     { 0x0c45, 0x2457, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #83 */
    112     { 0x036a, 0xc664, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #84 */
    113     { 0x076a, 0xc664, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #85 */
    114     { 0x0b6a, 0xc664, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #86 */
    115     { 0x0f6a, 0xc664, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #87 */
    116     { 0x0070, 0xb366, 0x3900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #88 */
    117     { 0x0470, 0xb366, 0x3900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #89 */
    118     { 0x0870, 0xb366, 0x3900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #90 */
    119     { 0x0c70, 0xb366, 0x3900, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #91 */
    120     { 0x0358, 0x5753, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #92 */
    121     { 0x0758, 0x5753, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #93 */
    122     { 0x0b58, 0x5753, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #94 */
    123     { 0x0f58, 0x5753, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0x8000000000000000) }, /* #95 */
     28    { 0x001c, 0x7337, 0x7900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #0 */
     29    { 0x041c, 0x7337, 0x7900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #1 */
     30    { 0x081c, 0x7337, 0x7900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #2 */
     31    { 0x0c1c, 0x7337, 0x7900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #3 */
     32    { 0x0020, 0x7b1f, 0x7900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #4 */
     33    { 0x0420, 0x7b1f, 0x7900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #5 */
     34    { 0x0820, 0x7b1f, 0x7900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #6 */
     35    { 0x0c20, 0x7b1f, 0x7900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #7 */
     36    { 0x0273, 0x84ce, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #8 */
     37    { 0x0673, 0x84ce, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #9 */
     38    { 0x0a73, 0x84ce, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #10 */
     39    { 0x0e73, 0x84ce, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #11 */
     40    { 0x002d, 0xfd5b, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #12 */
     41    { 0x042d, 0xfd5b, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #13 */
     42    { 0x082d, 0xfd5b, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #14 */
     43    { 0x0c2d, 0xfd5b, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #15 */
     44    { 0x025f, 0xc280, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #16 */
     45    { 0x065f, 0xc280, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #17 */
     46    { 0x0a5f, 0xc280, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #18 */
     47    { 0x0e5f, 0xc280, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #19 */
     48    { 0x0215, 0x52a0, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #20 */
     49    { 0x0615, 0x52a0, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #21 */
     50    { 0x0a15, 0x52a0, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #22 */
     51    { 0x0e15, 0x52a0, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #23 */
     52    { 0x0329, 0x1c6c, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #24 */
     53    { 0x0729, 0x1c6c, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #25 */
     54    { 0x0b29, 0x1c6c, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #26 */
     55    { 0x0f29, 0x1c6c, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #27 */
     56    { 0x0144, 0x4598, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #28 */
     57    { 0x0544, 0x4598, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #29 */
     58    { 0x0944, 0x4598, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #30 */
     59    { 0x0d44, 0x4598, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #31 */
     60    { 0x025e, 0x7c5c, 0x7c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #32 */
     61    { 0x065e, 0x7c5c, 0x7c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #33 */
     62    { 0x0a5e, 0x7c5c, 0x7c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #34 */
     63    { 0x0e5e, 0x7c5c, 0x7c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #35 */
     64    { 0x0172, 0xe7c5, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #36 */
     65    { 0x0572, 0xe7c5, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #37 */
     66    { 0x0972, 0xe7c5, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #38 */
     67    { 0x0d72, 0xe7c5, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #39 */
     68    { 0x020b, 0xa716, 0x3d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #40 */
     69    { 0x060b, 0xa716, 0x3d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #41 */
     70    { 0x0a0b, 0xa716, 0x3d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #42 */
     71    { 0x0e0b, 0xa716, 0x3d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #43 */
     72    { 0x0100, 0x0f2c, 0x3d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #44 */
     73    { 0x0500, 0x0f2c, 0x3d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #45 */
     74    { 0x0900, 0x0f2c, 0x3d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #46 */
     75    { 0x0d00, 0x0f2c, 0x3d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #47 */
     76    { 0x020d, 0xa1a7, 0x3900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #48 */
     77    { 0x060d, 0xa1a7, 0x3900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #49 */
     78    { 0x0a0d, 0xa1a7, 0x3900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #50 */
     79    { 0x0e0d, 0xa1a7, 0x3900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #51 */
     80    { 0x0031, 0xf252, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #52 */
     81    { 0x0431, 0xf252, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #53 */
     82    { 0x0831, 0xf252, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #54 */
     83    { 0x0c31, 0xf252, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #55 */
     84    { 0x023f, 0xa68f, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #56 */
     85    { 0x063f, 0xa68f, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #57 */
     86    { 0x0a3f, 0xa68f, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #58 */
     87    { 0x0e3f, 0xa68f, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #59 */
     88    { 0x005f, 0x8645, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #60 */
     89    { 0x045f, 0x8645, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #61 */
     90    { 0x085f, 0x8645, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #62 */
     91    { 0x0c5f, 0x8645, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #63 */
     92    { 0x023b, 0xaad8, 0x3800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #64 */
     93    { 0x063b, 0xaad8, 0x3800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #65 */
     94    { 0x0a3b, 0xaad8, 0x3800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #66 */
     95    { 0x0e3b, 0xaad8, 0x3800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #67 */
     96    { 0x0349, 0xda43, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #68 */
     97    { 0x0749, 0xda43, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #69 */
     98    { 0x0b49, 0xda43, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #70 */
     99    { 0x0f49, 0xda43, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #71 */
     100    { 0x011a, 0x3eea, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #72 */
     101    { 0x051a, 0x3eea, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #73 */
     102    { 0x091a, 0x3eea, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #74 */
     103    { 0x0d1a, 0x3eea, 0x3c00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #75 */
     104    { 0x016a, 0x83ae, 0x3900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #76 */
     105    { 0x056a, 0x83ae, 0x3900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #77 */
     106    { 0x096a, 0x83ae, 0x3900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #78 */
     107    { 0x0d6a, 0x83ae, 0x3900, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #79 */
     108    { 0x007a, 0xf00a, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #80 */
     109    { 0x047a, 0xf00a, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #81 */
     110    { 0x087a, 0xf00a, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #82 */
     111    { 0x0c7a, 0xf00a, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #83 */
     112    { 0x0172, 0x188f, 0x3800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #84 */
     113    { 0x0572, 0x188f, 0x3800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #85 */
     114    { 0x0972, 0x188f, 0x3800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #86 */
     115    { 0x0d72, 0x188f, 0x3800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #87 */
     116    { 0x0053, 0x550d, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #88 */
     117    { 0x0453, 0x550d, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #89 */
     118    { 0x0853, 0x550d, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #90 */
     119    { 0x0c53, 0x550d, 0x7d00, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #91 */
     120    { 0x0257, 0x582e, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #92 */
     121    { 0x0657, 0x582e, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #93 */
     122    { 0x0a57, 0x582e, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #94 */
     123    { 0x0e57, 0x582e, 0x7800, RTFLOAT80U_INIT_C(0,0x8000000000000000,16383) }, /* #95 */
    124124};
    125125static const FPU_LD_CONST_TEST_T g_aTests_fldl2t[] =
    126126{
    127     { 0x0364, 0x7510, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #0 */
    128     { 0x0764, 0x7510, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #1 */
    129     { 0x0b64, 0x7510, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #2 */
    130     { 0x0f64, 0x7510, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #3 */
    131     { 0x0212, 0xcdec, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #4 */
    132     { 0x0612, 0xcdec, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #5 */
    133     { 0x0a12, 0xcdec, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #6 */
    134     { 0x0e12, 0xcdec, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #7 */
    135     { 0x0070, 0xa088, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #8 */
    136     { 0x0470, 0xa088, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #9 */
    137     { 0x0870, 0xa088, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #10 */
    138     { 0x0c70, 0xa088, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #11 */
    139     { 0x0217, 0x63d6, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #12 */
    140     { 0x0617, 0x63d6, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #13 */
    141     { 0x0a17, 0x63d6, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #14 */
    142     { 0x0e17, 0x63d6, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #15 */
    143     { 0x032a, 0x0dbb, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #16 */
    144     { 0x072a, 0x0dbb, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #17 */
    145     { 0x0b2a, 0x0dbb, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #18 */
    146     { 0x0f2a, 0x0dbb, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #19 */
    147     { 0x014b, 0x2ef3, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #20 */
    148     { 0x054b, 0x2ef3, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #21 */
    149     { 0x094b, 0x2ef3, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #22 */
    150     { 0x0d4b, 0x2ef3, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #23 */
    151     { 0x012e, 0x7570, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #24 */
    152     { 0x052e, 0x7570, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #25 */
    153     { 0x092e, 0x7570, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #26 */
    154     { 0x0d2e, 0x7570, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #27 */
    155     { 0x0371, 0x4d4b, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #28 */
    156     { 0x0771, 0x4d4b, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #29 */
    157     { 0x0b71, 0x4d4b, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #30 */
    158     { 0x0f71, 0x4d4b, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #31 */
    159     { 0x0116, 0xacee, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #32 */
    160     { 0x0516, 0xacee, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #33 */
    161     { 0x0916, 0xacee, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #34 */
    162     { 0x0d16, 0xacee, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #35 */
    163     { 0x0140, 0x8e20, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #36 */
    164     { 0x0540, 0x8e20, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #37 */
    165     { 0x0940, 0x8e20, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #38 */
    166     { 0x0d40, 0x8e20, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #39 */
    167     { 0x0241, 0xd088, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #40 */
    168     { 0x0641, 0xd088, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #41 */
    169     { 0x0a41, 0xd088, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #42 */
    170     { 0x0e41, 0xd088, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #43 */
    171     { 0x0033, 0x6101, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #44 */
    172     { 0x0433, 0x6101, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #45 */
    173     { 0x0833, 0x6101, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #46 */
    174     { 0x0c33, 0x6101, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #47 */
    175     { 0x036f, 0x493b, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #48 */
    176     { 0x076f, 0x493b, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #49 */
    177     { 0x0b6f, 0x493b, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #50 */
    178     { 0x0f6f, 0x493b, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #51 */
    179     { 0x0048, 0xd844, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #52 */
    180     { 0x0448, 0xd844, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #53 */
    181     { 0x0848, 0xd844, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #54 */
    182     { 0x0c48, 0xd844, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #55 */
    183     { 0x021d, 0x39de, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #56 */
    184     { 0x061d, 0x39de, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #57 */
    185     { 0x0a1d, 0x39de, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #58 */
    186     { 0x0e1d, 0x39de, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #59 */
    187     { 0x0249, 0xe302, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #60 */
    188     { 0x0649, 0xe302, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #61 */
    189     { 0x0a49, 0xe302, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #62 */
    190     { 0x0e49, 0xe302, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #63 */
    191     { 0x0165, 0xb153, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #64 */
    192     { 0x0565, 0xb153, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #65 */
    193     { 0x0965, 0xb153, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #66 */
    194     { 0x0d65, 0xb153, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #67 */
    195     { 0x0236, 0xd117, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #68 */
    196     { 0x0636, 0xd117, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #69 */
    197     { 0x0a36, 0xd117, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #70 */
    198     { 0x0e36, 0xd117, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #71 */
    199     { 0x0231, 0xaa26, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #72 */
    200     { 0x0631, 0xaa26, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #73 */
    201     { 0x0a31, 0xaa26, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #74 */
    202     { 0x0e31, 0xaa26, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #75 */
    203     { 0x031d, 0x25b7, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #76 */
    204     { 0x071d, 0x25b7, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #77 */
    205     { 0x0b1d, 0x25b7, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #78 */
    206     { 0x0f1d, 0x25b7, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #79 */
    207     { 0x0164, 0xb5a1, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #80 */
    208     { 0x0564, 0xb5a1, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #81 */
    209     { 0x0964, 0xb5a1, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #82 */
    210     { 0x0d64, 0xb5a1, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #83 */
    211     { 0x0375, 0xeafd, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #84 */
    212     { 0x0775, 0xeafd, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #85 */
    213     { 0x0b75, 0xeafd, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #86 */
    214     { 0x0f75, 0xeafd, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #87 */
    215     { 0x0256, 0x8375, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #88 */
    216     { 0x0656, 0x8375, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #89 */
    217     { 0x0a56, 0x8375, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #90 */
    218     { 0x0e56, 0x8375, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #91 */
    219     { 0x026a, 0xec6e, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #92 */
    220     { 0x066a, 0xec6e, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #93 */
    221     { 0x0a6a, 0xec6e, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8aff) }, /* #94 */
    222     { 0x0e6a, 0xec6e, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xd49a784bcd1b8afe) }, /* #95 */
     127    { 0x0175, 0x8d22, 0x3d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #0 */
     128    { 0x0575, 0x8d22, 0x3d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #1 */
     129    { 0x0975, 0x8d22, 0x3d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #2 */
     130    { 0x0d75, 0x8d22, 0x3d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #3 */
     131    { 0x0148, 0xbeca, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #4 */
     132    { 0x0548, 0xbeca, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #5 */
     133    { 0x0948, 0xbeca, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #6 */
     134    { 0x0d48, 0xbeca, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #7 */
     135    { 0x0274, 0x812a, 0x3900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #8 */
     136    { 0x0674, 0x812a, 0x3900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #9 */
     137    { 0x0a74, 0x812a, 0x3900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #10 */
     138    { 0x0e74, 0x812a, 0x3900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #11 */
     139    { 0x011e, 0xf719, 0x7d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #12 */
     140    { 0x051e, 0xf719, 0x7d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #13 */
     141    { 0x091e, 0xf719, 0x7d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #14 */
     142    { 0x0d1e, 0xf719, 0x7d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #15 */
     143    { 0x0360, 0xfe71, 0x7c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #16 */
     144    { 0x0760, 0xfe71, 0x7c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #17 */
     145    { 0x0b60, 0xfe71, 0x7c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #18 */
     146    { 0x0f60, 0xfe71, 0x7c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #19 */
     147    { 0x0235, 0xe333, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #20 */
     148    { 0x0635, 0xe333, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #21 */
     149    { 0x0a35, 0xe333, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #22 */
     150    { 0x0e35, 0xe333, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #23 */
     151    { 0x037b, 0x960b, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #24 */
     152    { 0x077b, 0x960b, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #25 */
     153    { 0x0b7b, 0x960b, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #26 */
     154    { 0x0f7b, 0x960b, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #27 */
     155    { 0x0019, 0x24d6, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #28 */
     156    { 0x0419, 0x24d6, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #29 */
     157    { 0x0819, 0x24d6, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #30 */
     158    { 0x0c19, 0x24d6, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #31 */
     159    { 0x0132, 0x4a96, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #32 */
     160    { 0x0532, 0x4a96, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #33 */
     161    { 0x0932, 0x4a96, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #34 */
     162    { 0x0d32, 0x4a96, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #35 */
     163    { 0x017d, 0x9e4e, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #36 */
     164    { 0x057d, 0x9e4e, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #37 */
     165    { 0x097d, 0x9e4e, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #38 */
     166    { 0x0d7d, 0x9e4e, 0x3c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #39 */
     167    { 0x0344, 0x6787, 0x7d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #40 */
     168    { 0x0744, 0x6787, 0x7d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #41 */
     169    { 0x0b44, 0x6787, 0x7d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #42 */
     170    { 0x0f44, 0x6787, 0x7d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #43 */
     171    { 0x034b, 0xdaa9, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #44 */
     172    { 0x074b, 0xdaa9, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #45 */
     173    { 0x0b4b, 0xdaa9, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #46 */
     174    { 0x0f4b, 0xdaa9, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #47 */
     175    { 0x0050, 0xfcc7, 0x7c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #48 */
     176    { 0x0450, 0xfcc7, 0x7c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #49 */
     177    { 0x0850, 0xfcc7, 0x7c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #50 */
     178    { 0x0c50, 0xfcc7, 0x7c00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #51 */
     179    { 0x0125, 0x73b3, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #52 */
     180    { 0x0525, 0x73b3, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #53 */
     181    { 0x0925, 0x73b3, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #54 */
     182    { 0x0d25, 0x73b3, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #55 */
     183    { 0x036b, 0xc819, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #56 */
     184    { 0x076b, 0xc819, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #57 */
     185    { 0x0b6b, 0xc819, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #58 */
     186    { 0x0f6b, 0xc819, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #59 */
     187    { 0x0306, 0x692e, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #60 */
     188    { 0x0706, 0x692e, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #61 */
     189    { 0x0b06, 0x692e, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #62 */
     190    { 0x0f06, 0x692e, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #63 */
     191    { 0x026e, 0xd819, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #64 */
     192    { 0x066e, 0xd819, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #65 */
     193    { 0x0a6e, 0xd819, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #66 */
     194    { 0x0e6e, 0xd819, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #67 */
     195    { 0x0171, 0xe7f6, 0x7d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #68 */
     196    { 0x0571, 0xe7f6, 0x7d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #69 */
     197    { 0x0971, 0xe7f6, 0x7d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #70 */
     198    { 0x0d71, 0xe7f6, 0x7d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #71 */
     199    { 0x006b, 0xb999, 0x3900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #72 */
     200    { 0x046b, 0xb999, 0x3900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #73 */
     201    { 0x086b, 0xb999, 0x3900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #74 */
     202    { 0x0c6b, 0xb999, 0x3900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #75 */
     203    { 0x016b, 0xf1e8, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #76 */
     204    { 0x056b, 0xf1e8, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #77 */
     205    { 0x096b, 0xf1e8, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #78 */
     206    { 0x0d6b, 0xf1e8, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #79 */
     207    { 0x0230, 0xb0e4, 0x3800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #80 */
     208    { 0x0630, 0xb0e4, 0x3800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #81 */
     209    { 0x0a30, 0xb0e4, 0x3800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #82 */
     210    { 0x0e30, 0xb0e4, 0x3800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #83 */
     211    { 0x032d, 0x9782, 0x3d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #84 */
     212    { 0x072d, 0x9782, 0x3d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #85 */
     213    { 0x0b2d, 0x9782, 0x3d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #86 */
     214    { 0x0f2d, 0x9782, 0x3d00, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #87 */
     215    { 0x0220, 0x4bdb, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #88 */
     216    { 0x0620, 0x4bdb, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #89 */
     217    { 0x0a20, 0x4bdb, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #90 */
     218    { 0x0e20, 0x4bdb, 0x7900, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #91 */
     219    { 0x0121, 0x40f7, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #92 */
     220    { 0x0521, 0x40f7, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #93 */
     221    { 0x0921, 0x40f7, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8aff,16384) }, /* #94 */
     222    { 0x0d21, 0x40f7, 0x7800, RTFLOAT80U_INIT_C(0,0xd49a784bcd1b8afe,16384) }, /* #95 */
    223223};
    224224static const FPU_LD_CONST_TEST_T g_aTests_fldl2e[] =
    225225{
    226     { 0x0118, 0x4afc, 0x7800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #0 */
    227     { 0x0518, 0x4afc, 0x7800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #1 */
    228     { 0x0918, 0x4afc, 0x7800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #2 */
    229     { 0x0d18, 0x4afc, 0x7800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #3 */
    230     { 0x0115, 0x71c6, 0x7900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #4 */
    231     { 0x0515, 0x71c6, 0x7900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #5 */
    232     { 0x0915, 0x71c6, 0x7900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #6 */
    233     { 0x0d15, 0x71c6, 0x7900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #7 */
    234     { 0x0241, 0xba93, 0x3800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #8 */
    235     { 0x0641, 0xba93, 0x3800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #9 */
    236     { 0x0a41, 0xba93, 0x3800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #10 */
    237     { 0x0e41, 0xba93, 0x3800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #11 */
    238     { 0x035f, 0xfc61, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #12 */
    239     { 0x075f, 0xfc61, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #13 */
    240     { 0x0b5f, 0xfc61, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #14 */
    241     { 0x0f5f, 0xfc61, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #15 */
    242     { 0x036f, 0x93ab, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #16 */
    243     { 0x076f, 0x93ab, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #17 */
    244     { 0x0b6f, 0x93ab, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #18 */
    245     { 0x0f6f, 0x93ab, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #19 */
    246     { 0x0317, 0xe75b, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #20 */
    247     { 0x0717, 0xe75b, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #21 */
    248     { 0x0b17, 0xe75b, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #22 */
    249     { 0x0f17, 0xe75b, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #23 */
    250     { 0x037c, 0xdcde, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #24 */
    251     { 0x077c, 0xdcde, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #25 */
    252     { 0x0b7c, 0xdcde, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #26 */
    253     { 0x0f7c, 0xdcde, 0x7c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #27 */
    254     { 0x0078, 0x7f49, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #28 */
    255     { 0x0478, 0x7f49, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #29 */
    256     { 0x0878, 0x7f49, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #30 */
    257     { 0x0c78, 0x7f49, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #31 */
    258     { 0x0052, 0x78d3, 0x7800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #32 */
    259     { 0x0452, 0x78d3, 0x7800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #33 */
    260     { 0x0852, 0x78d3, 0x7800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #34 */
    261     { 0x0c52, 0x78d3, 0x7800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #35 */
    262     { 0x0156, 0xd7a1, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #36 */
    263     { 0x0556, 0xd7a1, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #37 */
    264     { 0x0956, 0xd7a1, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #38 */
    265     { 0x0d56, 0xd7a1, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #39 */
    266     { 0x000a, 0x1c2d, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #40 */
    267     { 0x040a, 0x1c2d, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #41 */
    268     { 0x080a, 0x1c2d, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #42 */
    269     { 0x0c0a, 0x1c2d, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #43 */
    270     { 0x036c, 0x5301, 0x7900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #44 */
    271     { 0x076c, 0x5301, 0x7900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #45 */
    272     { 0x0b6c, 0x5301, 0x7900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #46 */
    273     { 0x0f6c, 0x5301, 0x7900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #47 */
    274     { 0x0201, 0x8100, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #48 */
    275     { 0x0601, 0x8100, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #49 */
    276     { 0x0a01, 0x8100, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #50 */
    277     { 0x0e01, 0x8100, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #51 */
    278     { 0x0336, 0x831e, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #52 */
    279     { 0x0736, 0x831e, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #53 */
    280     { 0x0b36, 0x831e, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #54 */
    281     { 0x0f36, 0x831e, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #55 */
    282     { 0x0015, 0x23dc, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #56 */
    283     { 0x0415, 0x23dc, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #57 */
    284     { 0x0815, 0x23dc, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #58 */
    285     { 0x0c15, 0x23dc, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #59 */
    286     { 0x0143, 0x15e5, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #60 */
    287     { 0x0543, 0x15e5, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #61 */
    288     { 0x0943, 0x15e5, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #62 */
    289     { 0x0d43, 0x15e5, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #63 */
    290     { 0x0037, 0x4017, 0x7800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #64 */
    291     { 0x0437, 0x4017, 0x7800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #65 */
    292     { 0x0837, 0x4017, 0x7800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #66 */
    293     { 0x0c37, 0x4017, 0x7800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #67 */
    294     { 0x0244, 0xc967, 0x7900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #68 */
    295     { 0x0644, 0xc967, 0x7900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #69 */
    296     { 0x0a44, 0xc967, 0x7900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #70 */
    297     { 0x0e44, 0xc967, 0x7900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #71 */
    298     { 0x0145, 0xac22, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #72 */
    299     { 0x0545, 0xac22, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #73 */
    300     { 0x0945, 0xac22, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #74 */
    301     { 0x0d45, 0xac22, 0x3c00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #75 */
    302     { 0x0130, 0x5797, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #76 */
    303     { 0x0530, 0x5797, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #77 */
    304     { 0x0930, 0x5797, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #78 */
    305     { 0x0d30, 0x5797, 0x7d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #79 */
    306     { 0x0132, 0xa15d, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #80 */
    307     { 0x0532, 0xa15d, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #81 */
    308     { 0x0932, 0xa15d, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #82 */
    309     { 0x0d32, 0xa15d, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #83 */
    310     { 0x030e, 0x8548, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #84 */
    311     { 0x070e, 0x8548, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #85 */
    312     { 0x0b0e, 0x8548, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #86 */
    313     { 0x0f0e, 0x8548, 0x3d00, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #87 */
    314     { 0x020d, 0x008d, 0x3800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #88 */
    315     { 0x060d, 0x008d, 0x3800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #89 */
    316     { 0x0a0d, 0x008d, 0x3800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #90 */
    317     { 0x0e0d, 0x008d, 0x3800, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #91 */
    318     { 0x0349, 0x1bda, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #92 */
    319     { 0x0749, 0x1bda, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #93 */
    320     { 0x0b49, 0x1bda, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bc) }, /* #94 */
    321     { 0x0f49, 0x1bda, 0x3900, RTFLOAT80U_INIT_C(0,16383,0xb8aa3b295c17f0bb) }, /* #95 */
     226    { 0x031d, 0x0f3c, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #0 */
     227    { 0x071d, 0x0f3c, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #1 */
     228    { 0x0b1d, 0x0f3c, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #2 */
     229    { 0x0f1d, 0x0f3c, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #3 */
     230    { 0x004c, 0x42a0, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #4 */
     231    { 0x044c, 0x42a0, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #5 */
     232    { 0x084c, 0x42a0, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #6 */
     233    { 0x0c4c, 0x42a0, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #7 */
     234    { 0x011f, 0x1e75, 0x3c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #8 */
     235    { 0x051f, 0x1e75, 0x3c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #9 */
     236    { 0x091f, 0x1e75, 0x3c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #10 */
     237    { 0x0d1f, 0x1e75, 0x3c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #11 */
     238    { 0x0271, 0xa1ac, 0x3900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #12 */
     239    { 0x0671, 0xa1ac, 0x3900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #13 */
     240    { 0x0a71, 0xa1ac, 0x3900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #14 */
     241    { 0x0e71, 0xa1ac, 0x3900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #15 */
     242    { 0x0102, 0x7143, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #16 */
     243    { 0x0502, 0x7143, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #17 */
     244    { 0x0902, 0x7143, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #18 */
     245    { 0x0d02, 0x7143, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #19 */
     246    { 0x0035, 0xcfe0, 0x7d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #20 */
     247    { 0x0435, 0xcfe0, 0x7d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #21 */
     248    { 0x0835, 0xcfe0, 0x7d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #22 */
     249    { 0x0c35, 0xcfe0, 0x7d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #23 */
     250    { 0x005b, 0x6ef1, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #24 */
     251    { 0x045b, 0x6ef1, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #25 */
     252    { 0x085b, 0x6ef1, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #26 */
     253    { 0x0c5b, 0x6ef1, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #27 */
     254    { 0x0377, 0xb5b5, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #28 */
     255    { 0x0777, 0xb5b5, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #29 */
     256    { 0x0b77, 0xb5b5, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #30 */
     257    { 0x0f77, 0xb5b5, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #31 */
     258    { 0x000b, 0xf6e3, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #32 */
     259    { 0x040b, 0xf6e3, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #33 */
     260    { 0x080b, 0xf6e3, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #34 */
     261    { 0x0c0b, 0xf6e3, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #35 */
     262    { 0x0145, 0xd47d, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #36 */
     263    { 0x0545, 0xd47d, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #37 */
     264    { 0x0945, 0xd47d, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #38 */
     265    { 0x0d45, 0xd47d, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #39 */
     266    { 0x0027, 0xebb9, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #40 */
     267    { 0x0427, 0xebb9, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #41 */
     268    { 0x0827, 0xebb9, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #42 */
     269    { 0x0c27, 0xebb9, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #43 */
     270    { 0x030b, 0xbf10, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #44 */
     271    { 0x070b, 0xbf10, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #45 */
     272    { 0x0b0b, 0xbf10, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #46 */
     273    { 0x0f0b, 0xbf10, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #47 */
     274    { 0x0244, 0x7236, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #48 */
     275    { 0x0644, 0x7236, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #49 */
     276    { 0x0a44, 0x7236, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #50 */
     277    { 0x0e44, 0x7236, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #51 */
     278    { 0x0025, 0x313c, 0x3900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #52 */
     279    { 0x0425, 0x313c, 0x3900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #53 */
     280    { 0x0825, 0x313c, 0x3900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #54 */
     281    { 0x0c25, 0x313c, 0x3900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #55 */
     282    { 0x0110, 0x9c6b, 0x3c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #56 */
     283    { 0x0510, 0x9c6b, 0x3c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #57 */
     284    { 0x0910, 0x9c6b, 0x3c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #58 */
     285    { 0x0d10, 0x9c6b, 0x3c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #59 */
     286    { 0x0302, 0x64fe, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #60 */
     287    { 0x0702, 0x64fe, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #61 */
     288    { 0x0b02, 0x64fe, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #62 */
     289    { 0x0f02, 0x64fe, 0x7c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #63 */
     290    { 0x0319, 0xe068, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #64 */
     291    { 0x0719, 0xe068, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #65 */
     292    { 0x0b19, 0xe068, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #66 */
     293    { 0x0f19, 0xe068, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #67 */
     294    { 0x014d, 0x5200, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #68 */
     295    { 0x054d, 0x5200, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #69 */
     296    { 0x094d, 0x5200, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #70 */
     297    { 0x0d4d, 0x5200, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #71 */
     298    { 0x0150, 0x16ea, 0x3c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #72 */
     299    { 0x0550, 0x16ea, 0x3c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #73 */
     300    { 0x0950, 0x16ea, 0x3c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #74 */
     301    { 0x0d50, 0x16ea, 0x3c00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #75 */
     302    { 0x030d, 0x6898, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #76 */
     303    { 0x070d, 0x6898, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #77 */
     304    { 0x0b0d, 0x6898, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #78 */
     305    { 0x0f0d, 0x6898, 0x7800, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #79 */
     306    { 0x011e, 0x6b12, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #80 */
     307    { 0x051e, 0x6b12, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #81 */
     308    { 0x091e, 0x6b12, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #82 */
     309    { 0x0d1e, 0x6b12, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #83 */
     310    { 0x0031, 0x8d2c, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #84 */
     311    { 0x0431, 0x8d2c, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #85 */
     312    { 0x0831, 0x8d2c, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #86 */
     313    { 0x0c31, 0x8d2c, 0x3d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #87 */
     314    { 0x035c, 0x573e, 0x7d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #88 */
     315    { 0x075c, 0x573e, 0x7d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #89 */
     316    { 0x0b5c, 0x573e, 0x7d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #90 */
     317    { 0x0f5c, 0x573e, 0x7d00, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #91 */
     318    { 0x0267, 0x53c5, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #92 */
     319    { 0x0667, 0x53c5, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #93 */
     320    { 0x0a67, 0x53c5, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bc,16383) }, /* #94 */
     321    { 0x0e67, 0x53c5, 0x7900, RTFLOAT80U_INIT_C(0,0xb8aa3b295c17f0bb,16383) }, /* #95 */
    322322};
    323323static const FPU_LD_CONST_TEST_T g_aTests_fldpi[] =
    324324{
    325     { 0x031b, 0x0397, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #0 */
    326     { 0x071b, 0x0397, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #1 */
    327     { 0x0b1b, 0x0397, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #2 */
    328     { 0x0f1b, 0x0397, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #3 */
    329     { 0x035a, 0xe254, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #4 */
    330     { 0x075a, 0xe254, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #5 */
    331     { 0x0b5a, 0xe254, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #6 */
    332     { 0x0f5a, 0xe254, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #7 */
    333     { 0x0351, 0x95cd, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #8 */
    334     { 0x0751, 0x95cd, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #9 */
    335     { 0x0b51, 0x95cd, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #10 */
    336     { 0x0f51, 0x95cd, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #11 */
    337     { 0x0008, 0xc068, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #12 */
    338     { 0x0408, 0xc068, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #13 */
    339     { 0x0808, 0xc068, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #14 */
    340     { 0x0c08, 0xc068, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #15 */
    341     { 0x001e, 0x85e2, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #16 */
    342     { 0x041e, 0x85e2, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #17 */
    343     { 0x081e, 0x85e2, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #18 */
    344     { 0x0c1e, 0x85e2, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #19 */
    345     { 0x0117, 0x707d, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #20 */
    346     { 0x0517, 0x707d, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #21 */
    347     { 0x0917, 0x707d, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #22 */
    348     { 0x0d17, 0x707d, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #23 */
    349     { 0x0040, 0x53f3, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #24 */
    350     { 0x0440, 0x53f3, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #25 */
    351     { 0x0840, 0x53f3, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #26 */
    352     { 0x0c40, 0x53f3, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #27 */
    353     { 0x0014, 0xbd70, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #28 */
    354     { 0x0414, 0xbd70, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #29 */
    355     { 0x0814, 0xbd70, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #30 */
    356     { 0x0c14, 0xbd70, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #31 */
    357     { 0x0241, 0xef90, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #32 */
    358     { 0x0641, 0xef90, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #33 */
    359     { 0x0a41, 0xef90, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #34 */
    360     { 0x0e41, 0xef90, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #35 */
    361     { 0x0243, 0x8d6a, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #36 */
    362     { 0x0643, 0x8d6a, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #37 */
    363     { 0x0a43, 0x8d6a, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #38 */
    364     { 0x0e43, 0x8d6a, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #39 */
    365     { 0x015b, 0x055c, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #40 */
    366     { 0x055b, 0x055c, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #41 */
    367     { 0x095b, 0x055c, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #42 */
    368     { 0x0d5b, 0x055c, 0x3d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #43 */
    369     { 0x0208, 0xaecc, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #44 */
    370     { 0x0608, 0xaecc, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #45 */
    371     { 0x0a08, 0xaecc, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #46 */
    372     { 0x0e08, 0xaecc, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #47 */
    373     { 0x013f, 0x0a31, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #48 */
    374     { 0x053f, 0x0a31, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #49 */
    375     { 0x093f, 0x0a31, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #50 */
    376     { 0x0d3f, 0x0a31, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #51 */
    377     { 0x006d, 0x4754, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #52 */
    378     { 0x046d, 0x4754, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #53 */
    379     { 0x086d, 0x4754, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #54 */
    380     { 0x0c6d, 0x4754, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #55 */
    381     { 0x0055, 0x6ee9, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #56 */
    382     { 0x0455, 0x6ee9, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #57 */
    383     { 0x0855, 0x6ee9, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #58 */
    384     { 0x0c55, 0x6ee9, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #59 */
    385     { 0x0035, 0xa92b, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #60 */
    386     { 0x0435, 0xa92b, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #61 */
    387     { 0x0835, 0xa92b, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #62 */
    388     { 0x0c35, 0xa92b, 0x3900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #63 */
    389     { 0x0163, 0xf5e1, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #64 */
    390     { 0x0563, 0xf5e1, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #65 */
    391     { 0x0963, 0xf5e1, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #66 */
    392     { 0x0d63, 0xf5e1, 0x7d00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #67 */
    393     { 0x0130, 0xeafa, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #68 */
    394     { 0x0530, 0xeafa, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #69 */
    395     { 0x0930, 0xeafa, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #70 */
    396     { 0x0d30, 0xeafa, 0x7800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #71 */
    397     { 0x0114, 0xd67c, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #72 */
    398     { 0x0514, 0xd67c, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #73 */
    399     { 0x0914, 0xd67c, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #74 */
    400     { 0x0d14, 0xd67c, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #75 */
    401     { 0x0224, 0x9222, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #76 */
    402     { 0x0624, 0x9222, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #77 */
    403     { 0x0a24, 0x9222, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #78 */
    404     { 0x0e24, 0x9222, 0x3800, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #79 */
    405     { 0x0010, 0x5c4f, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #80 */
    406     { 0x0410, 0x5c4f, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #81 */
    407     { 0x0810, 0x5c4f, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #82 */
    408     { 0x0c10, 0x5c4f, 0x7c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #83 */
    409     { 0x0318, 0x0ef7, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #84 */
    410     { 0x0718, 0x0ef7, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #85 */
    411     { 0x0b18, 0x0ef7, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #86 */
    412     { 0x0f18, 0x0ef7, 0x3c00, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #87 */
    413     { 0x010b, 0xeb72, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #88 */
    414     { 0x050b, 0xeb72, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #89 */
    415     { 0x090b, 0xeb72, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #90 */
    416     { 0x0d0b, 0xeb72, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #91 */
    417     { 0x026b, 0x73a8, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #92 */
    418     { 0x066b, 0x73a8, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #93 */
    419     { 0x0a6b, 0x73a8, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c235) }, /* #94 */
    420     { 0x0e6b, 0x73a8, 0x7900, RTFLOAT80U_INIT_C(0,16384,0xc90fdaa22168c234) }, /* #95 */
     325    { 0x0255, 0xe657, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #0 */
     326    { 0x0655, 0xe657, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #1 */
     327    { 0x0a55, 0xe657, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #2 */
     328    { 0x0e55, 0xe657, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #3 */
     329    { 0x0231, 0x170e, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #4 */
     330    { 0x0631, 0x170e, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #5 */
     331    { 0x0a31, 0x170e, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #6 */
     332    { 0x0e31, 0x170e, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #7 */
     333    { 0x0209, 0xc4da, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #8 */
     334    { 0x0609, 0xc4da, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #9 */
     335    { 0x0a09, 0xc4da, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #10 */
     336    { 0x0e09, 0xc4da, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #11 */
     337    { 0x0267, 0x2fa0, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #12 */
     338    { 0x0667, 0x2fa0, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #13 */
     339    { 0x0a67, 0x2fa0, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #14 */
     340    { 0x0e67, 0x2fa0, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #15 */
     341    { 0x0221, 0x5ea9, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #16 */
     342    { 0x0621, 0x5ea9, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #17 */
     343    { 0x0a21, 0x5ea9, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #18 */
     344    { 0x0e21, 0x5ea9, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #19 */
     345    { 0x0321, 0x25f2, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #20 */
     346    { 0x0721, 0x25f2, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #21 */
     347    { 0x0b21, 0x25f2, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #22 */
     348    { 0x0f21, 0x25f2, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #23 */
     349    { 0x017d, 0xa9cc, 0x3900, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #24 */
     350    { 0x057d, 0xa9cc, 0x3900, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #25 */
     351    { 0x097d, 0xa9cc, 0x3900, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #26 */
     352    { 0x0d7d, 0xa9cc, 0x3900, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #27 */
     353    { 0x0355, 0x25f6, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #28 */
     354    { 0x0755, 0x25f6, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #29 */
     355    { 0x0b55, 0x25f6, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #30 */
     356    { 0x0f55, 0x25f6, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #31 */
     357    { 0x023e, 0x44ee, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #32 */
     358    { 0x063e, 0x44ee, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #33 */
     359    { 0x0a3e, 0x44ee, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #34 */
     360    { 0x0e3e, 0x44ee, 0x7c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #35 */
     361    { 0x020e, 0x9da0, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #36 */
     362    { 0x060e, 0x9da0, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #37 */
     363    { 0x0a0e, 0x9da0, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #38 */
     364    { 0x0e0e, 0x9da0, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #39 */
     365    { 0x0217, 0x0731, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #40 */
     366    { 0x0617, 0x0731, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #41 */
     367    { 0x0a17, 0x0731, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #42 */
     368    { 0x0e17, 0x0731, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #43 */
     369    { 0x0111, 0xb608, 0x3c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #44 */
     370    { 0x0511, 0xb608, 0x3c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #45 */
     371    { 0x0911, 0xb608, 0x3c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #46 */
     372    { 0x0d11, 0xb608, 0x3c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #47 */
     373    { 0x0156, 0x2097, 0x3800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #48 */
     374    { 0x0556, 0x2097, 0x3800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #49 */
     375    { 0x0956, 0x2097, 0x3800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #50 */
     376    { 0x0d56, 0x2097, 0x3800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #51 */
     377    { 0x0021, 0xa6ef, 0x3c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #52 */
     378    { 0x0421, 0xa6ef, 0x3c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #53 */
     379    { 0x0821, 0xa6ef, 0x3c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #54 */
     380    { 0x0c21, 0xa6ef, 0x3c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #55 */
     381    { 0x0279, 0x5a28, 0x7800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #56 */
     382    { 0x0679, 0x5a28, 0x7800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #57 */
     383    { 0x0a79, 0x5a28, 0x7800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #58 */
     384    { 0x0e79, 0x5a28, 0x7800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #59 */
     385    { 0x0205, 0xcfb6, 0x7d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #60 */
     386    { 0x0605, 0xcfb6, 0x7d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #61 */
     387    { 0x0a05, 0xcfb6, 0x7d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #62 */
     388    { 0x0e05, 0xcfb6, 0x7d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #63 */
     389    { 0x0374, 0x5d92, 0x7d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #64 */
     390    { 0x0774, 0x5d92, 0x7d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #65 */
     391    { 0x0b74, 0x5d92, 0x7d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #66 */
     392    { 0x0f74, 0x5d92, 0x7d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #67 */
     393    { 0x0120, 0x8237, 0x3800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #68 */
     394    { 0x0520, 0x8237, 0x3800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #69 */
     395    { 0x0920, 0x8237, 0x3800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #70 */
     396    { 0x0d20, 0x8237, 0x3800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #71 */
     397    { 0x0126, 0xa489, 0x3c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #72 */
     398    { 0x0526, 0xa489, 0x3c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #73 */
     399    { 0x0926, 0xa489, 0x3c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #74 */
     400    { 0x0d26, 0xa489, 0x3c00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #75 */
     401    { 0x007a, 0x528c, 0x7800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #76 */
     402    { 0x047a, 0x528c, 0x7800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #77 */
     403    { 0x087a, 0x528c, 0x7800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #78 */
     404    { 0x0c7a, 0x528c, 0x7800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #79 */
     405    { 0x0172, 0xad78, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #80 */
     406    { 0x0572, 0xad78, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #81 */
     407    { 0x0972, 0xad78, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #82 */
     408    { 0x0d72, 0xad78, 0x3d00, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #83 */
     409    { 0x0229, 0x59d0, 0x7900, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #84 */
     410    { 0x0629, 0x59d0, 0x7900, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #85 */
     411    { 0x0a29, 0x59d0, 0x7900, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #86 */
     412    { 0x0e29, 0x59d0, 0x7900, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #87 */
     413    { 0x0203, 0xd086, 0x7800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #88 */
     414    { 0x0603, 0xd086, 0x7800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #89 */
     415    { 0x0a03, 0xd086, 0x7800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #90 */
     416    { 0x0e03, 0xd086, 0x7800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #91 */
     417    { 0x021b, 0xb860, 0x3800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #92 */
     418    { 0x061b, 0xb860, 0x3800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #93 */
     419    { 0x0a1b, 0xb860, 0x3800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c235,16384) }, /* #94 */
     420    { 0x0e1b, 0xb860, 0x3800, RTFLOAT80U_INIT_C(0,0xc90fdaa22168c234,16384) }, /* #95 */
    421421};
    422422static const FPU_LD_CONST_TEST_T g_aTests_fldlg2[] =
    423423{
    424     { 0x0027, 0x2a93, 0x3800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #0 */
    425     { 0x0427, 0x2a93, 0x3800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #1 */
    426     { 0x0827, 0x2a93, 0x3800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #2 */
    427     { 0x0c27, 0x2a93, 0x3800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #3 */
    428     { 0x017f, 0xf410, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #4 */
    429     { 0x057f, 0xf410, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #5 */
    430     { 0x097f, 0xf410, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #6 */
    431     { 0x0d7f, 0xf410, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #7 */
    432     { 0x0262, 0x7e2b, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #8 */
    433     { 0x0662, 0x7e2b, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #9 */
    434     { 0x0a62, 0x7e2b, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #10 */
    435     { 0x0e62, 0x7e2b, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #11 */
    436     { 0x0162, 0x33d8, 0x3900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #12 */
    437     { 0x0562, 0x33d8, 0x3900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #13 */
    438     { 0x0962, 0x33d8, 0x3900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #14 */
    439     { 0x0d62, 0x33d8, 0x3900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #15 */
    440     { 0x0049, 0xac33, 0x3c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #16 */
    441     { 0x0449, 0xac33, 0x3c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #17 */
    442     { 0x0849, 0xac33, 0x3c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #18 */
    443     { 0x0c49, 0xac33, 0x3c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #19 */
    444     { 0x0245, 0x4c7e, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #20 */
    445     { 0x0645, 0x4c7e, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #21 */
    446     { 0x0a45, 0x4c7e, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #22 */
    447     { 0x0e45, 0x4c7e, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #23 */
    448     { 0x0309, 0x802e, 0x3800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #24 */
    449     { 0x0709, 0x802e, 0x3800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #25 */
    450     { 0x0b09, 0x802e, 0x3800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #26 */
    451     { 0x0f09, 0x802e, 0x3800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #27 */
    452     { 0x024a, 0xf120, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #28 */
    453     { 0x064a, 0xf120, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #29 */
    454     { 0x0a4a, 0xf120, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #30 */
    455     { 0x0e4a, 0xf120, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #31 */
    456     { 0x0317, 0x6687, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #32 */
    457     { 0x0717, 0x6687, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #33 */
    458     { 0x0b17, 0x6687, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #34 */
    459     { 0x0f17, 0x6687, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #35 */
    460     { 0x0204, 0xddf8, 0x7d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #36 */
    461     { 0x0604, 0xddf8, 0x7d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #37 */
    462     { 0x0a04, 0xddf8, 0x7d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #38 */
    463     { 0x0e04, 0xddf8, 0x7d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #39 */
    464     { 0x036a, 0xc58a, 0x7d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #40 */
    465     { 0x076a, 0xc58a, 0x7d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #41 */
    466     { 0x0b6a, 0xc58a, 0x7d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #42 */
    467     { 0x0f6a, 0xc58a, 0x7d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #43 */
    468     { 0x0213, 0xa5bd, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #44 */
    469     { 0x0613, 0xa5bd, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #45 */
    470     { 0x0a13, 0xa5bd, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #46 */
    471     { 0x0e13, 0xa5bd, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #47 */
    472     { 0x0053, 0xf3cb, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #48 */
    473     { 0x0453, 0xf3cb, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #49 */
    474     { 0x0853, 0xf3cb, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #50 */
    475     { 0x0c53, 0xf3cb, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #51 */
    476     { 0x0117, 0x7300, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #52 */
    477     { 0x0517, 0x7300, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #53 */
    478     { 0x0917, 0x7300, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #54 */
    479     { 0x0d17, 0x7300, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #55 */
    480     { 0x0275, 0xe44d, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #56 */
    481     { 0x0675, 0xe44d, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #57 */
    482     { 0x0a75, 0xe44d, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #58 */
    483     { 0x0e75, 0xe44d, 0x7c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #59 */
    484     { 0x0241, 0x2391, 0x3900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #60 */
    485     { 0x0641, 0x2391, 0x3900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #61 */
    486     { 0x0a41, 0x2391, 0x3900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #62 */
    487     { 0x0e41, 0x2391, 0x3900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #63 */
    488     { 0x0276, 0xbf23, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #64 */
    489     { 0x0676, 0xbf23, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #65 */
    490     { 0x0a76, 0xbf23, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #66 */
    491     { 0x0e76, 0xbf23, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #67 */
    492     { 0x025e, 0xa804, 0x3800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #68 */
    493     { 0x065e, 0xa804, 0x3800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #69 */
    494     { 0x0a5e, 0xa804, 0x3800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #70 */
    495     { 0x0e5e, 0xa804, 0x3800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #71 */
    496     { 0x0016, 0xe201, 0x7800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #72 */
    497     { 0x0416, 0xe201, 0x7800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #73 */
    498     { 0x0816, 0xe201, 0x7800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #74 */
    499     { 0x0c16, 0xe201, 0x7800, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #75 */
    500     { 0x0209, 0x1d60, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #76 */
    501     { 0x0609, 0x1d60, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #77 */
    502     { 0x0a09, 0x1d60, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #78 */
    503     { 0x0e09, 0x1d60, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #79 */
    504     { 0x0142, 0x5dec, 0x7d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #80 */
    505     { 0x0542, 0x5dec, 0x7d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #81 */
    506     { 0x0942, 0x5dec, 0x7d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #82 */
    507     { 0x0d42, 0x5dec, 0x7d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #83 */
    508     { 0x013a, 0x1784, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #84 */
    509     { 0x053a, 0x1784, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #85 */
    510     { 0x093a, 0x1784, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #86 */
    511     { 0x0d3a, 0x1784, 0x3d00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #87 */
    512     { 0x004f, 0x61f0, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #88 */
    513     { 0x044f, 0x61f0, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #89 */
    514     { 0x084f, 0x61f0, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #90 */
    515     { 0x0c4f, 0x61f0, 0x7900, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #91 */
    516     { 0x033f, 0xae38, 0x3c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #92 */
    517     { 0x073f, 0xae38, 0x3c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #93 */
    518     { 0x0b3f, 0xae38, 0x3c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff799) }, /* #94 */
    519     { 0x0f3f, 0xae38, 0x3c00, RTFLOAT80U_INIT_C(0,16381,0x9a209a84fbcff798) }, /* #95 */
     424    { 0x0136, 0x71b9, 0x7900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #0 */
     425    { 0x0536, 0x71b9, 0x7900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #1 */
     426    { 0x0936, 0x71b9, 0x7900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #2 */
     427    { 0x0d36, 0x71b9, 0x7900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #3 */
     428    { 0x0369, 0x0399, 0x3900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #4 */
     429    { 0x0769, 0x0399, 0x3900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #5 */
     430    { 0x0b69, 0x0399, 0x3900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #6 */
     431    { 0x0f69, 0x0399, 0x3900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #7 */
     432    { 0x024d, 0xd8f9, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #8 */
     433    { 0x064d, 0xd8f9, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #9 */
     434    { 0x0a4d, 0xd8f9, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #10 */
     435    { 0x0e4d, 0xd8f9, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #11 */
     436    { 0x0323, 0x9f4f, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #12 */
     437    { 0x0723, 0x9f4f, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #13 */
     438    { 0x0b23, 0x9f4f, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #14 */
     439    { 0x0f23, 0x9f4f, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #15 */
     440    { 0x000f, 0x24d0, 0x3c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #16 */
     441    { 0x040f, 0x24d0, 0x3c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #17 */
     442    { 0x080f, 0x24d0, 0x3c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #18 */
     443    { 0x0c0f, 0x24d0, 0x3c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #19 */
     444    { 0x0162, 0x8a81, 0x3800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #20 */
     445    { 0x0562, 0x8a81, 0x3800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #21 */
     446    { 0x0962, 0x8a81, 0x3800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #22 */
     447    { 0x0d62, 0x8a81, 0x3800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #23 */
     448    { 0x035a, 0x9779, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #24 */
     449    { 0x075a, 0x9779, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #25 */
     450    { 0x0b5a, 0x9779, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #26 */
     451    { 0x0f5a, 0x9779, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #27 */
     452    { 0x0051, 0x09db, 0x3900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #28 */
     453    { 0x0451, 0x09db, 0x3900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #29 */
     454    { 0x0851, 0x09db, 0x3900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #30 */
     455    { 0x0c51, 0x09db, 0x3900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #31 */
     456    { 0x0146, 0xe5f9, 0x7d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #32 */
     457    { 0x0546, 0xe5f9, 0x7d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #33 */
     458    { 0x0946, 0xe5f9, 0x7d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #34 */
     459    { 0x0d46, 0xe5f9, 0x7d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #35 */
     460    { 0x0340, 0xba71, 0x3800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #36 */
     461    { 0x0740, 0xba71, 0x3800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #37 */
     462    { 0x0b40, 0xba71, 0x3800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #38 */
     463    { 0x0f40, 0xba71, 0x3800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #39 */
     464    { 0x021a, 0xfc69, 0x7c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #40 */
     465    { 0x061a, 0xfc69, 0x7c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #41 */
     466    { 0x0a1a, 0xfc69, 0x7c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #42 */
     467    { 0x0e1a, 0xfc69, 0x7c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #43 */
     468    { 0x0021, 0x6f94, 0x7d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #44 */
     469    { 0x0421, 0x6f94, 0x7d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #45 */
     470    { 0x0821, 0x6f94, 0x7d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #46 */
     471    { 0x0c21, 0x6f94, 0x7d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #47 */
     472    { 0x0152, 0x96c6, 0x3c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #48 */
     473    { 0x0552, 0x96c6, 0x3c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #49 */
     474    { 0x0952, 0x96c6, 0x3c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #50 */
     475    { 0x0d52, 0x96c6, 0x3c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #51 */
     476    { 0x0334, 0xd397, 0x7900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #52 */
     477    { 0x0734, 0xd397, 0x7900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #53 */
     478    { 0x0b34, 0xd397, 0x7900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #54 */
     479    { 0x0f34, 0xd397, 0x7900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #55 */
     480    { 0x0358, 0x602f, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #56 */
     481    { 0x0758, 0x602f, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #57 */
     482    { 0x0b58, 0x602f, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #58 */
     483    { 0x0f58, 0x602f, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #59 */
     484    { 0x0131, 0x6913, 0x7900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #60 */
     485    { 0x0531, 0x6913, 0x7900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #61 */
     486    { 0x0931, 0x6913, 0x7900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #62 */
     487    { 0x0d31, 0x6913, 0x7900, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #63 */
     488    { 0x002c, 0xfaa7, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #64 */
     489    { 0x042c, 0xfaa7, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #65 */
     490    { 0x082c, 0xfaa7, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #66 */
     491    { 0x0c2c, 0xfaa7, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #67 */
     492    { 0x0265, 0xedc4, 0x7d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #68 */
     493    { 0x0665, 0xedc4, 0x7d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #69 */
     494    { 0x0a65, 0xedc4, 0x7d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #70 */
     495    { 0x0e65, 0xedc4, 0x7d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #71 */
     496    { 0x0255, 0x4e06, 0x7c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #72 */
     497    { 0x0655, 0x4e06, 0x7c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #73 */
     498    { 0x0a55, 0x4e06, 0x7c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #74 */
     499    { 0x0e55, 0x4e06, 0x7c00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #75 */
     500    { 0x037a, 0xad65, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #76 */
     501    { 0x077a, 0xad65, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #77 */
     502    { 0x0b7a, 0xad65, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #78 */
     503    { 0x0f7a, 0xad65, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #79 */
     504    { 0x0021, 0xc076, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #80 */
     505    { 0x0421, 0xc076, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #81 */
     506    { 0x0821, 0xc076, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #82 */
     507    { 0x0c21, 0xc076, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #83 */
     508    { 0x0041, 0x370a, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #84 */
     509    { 0x0441, 0x370a, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #85 */
     510    { 0x0841, 0x370a, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #86 */
     511    { 0x0c41, 0x370a, 0x3d00, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #87 */
     512    { 0x0046, 0x62bf, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #88 */
     513    { 0x0446, 0x62bf, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #89 */
     514    { 0x0846, 0x62bf, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #90 */
     515    { 0x0c46, 0x62bf, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #91 */
     516    { 0x0161, 0xf2cc, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #92 */
     517    { 0x0561, 0xf2cc, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #93 */
     518    { 0x0961, 0xf2cc, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff799,16381) }, /* #94 */
     519    { 0x0d61, 0xf2cc, 0x7800, RTFLOAT80U_INIT_C(0,0x9a209a84fbcff798,16381) }, /* #95 */
    520520};
    521521static const FPU_LD_CONST_TEST_T g_aTests_fldln2[] =
    522522{
    523     { 0x0250, 0x410b, 0x7900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #0 */
    524     { 0x0650, 0x410b, 0x7900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #1 */
    525     { 0x0a50, 0x410b, 0x7900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #2 */
    526     { 0x0e50, 0x410b, 0x7900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #3 */
    527     { 0x0060, 0xd664, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #4 */
    528     { 0x0460, 0xd664, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #5 */
    529     { 0x0860, 0xd664, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #6 */
    530     { 0x0c60, 0xd664, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #7 */
    531     { 0x015d, 0xdcb6, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #8 */
    532     { 0x055d, 0xdcb6, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #9 */
    533     { 0x095d, 0xdcb6, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #10 */
    534     { 0x0d5d, 0xdcb6, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #11 */
    535     { 0x0011, 0x31f8, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #12 */
    536     { 0x0411, 0x31f8, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #13 */
    537     { 0x0811, 0x31f8, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #14 */
    538     { 0x0c11, 0x31f8, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #15 */
    539     { 0x020e, 0x663a, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #16 */
    540     { 0x060e, 0x663a, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #17 */
    541     { 0x0a0e, 0x663a, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #18 */
    542     { 0x0e0e, 0x663a, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #19 */
    543     { 0x0230, 0x2552, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #20 */
    544     { 0x0630, 0x2552, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #21 */
    545     { 0x0a30, 0x2552, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #22 */
    546     { 0x0e30, 0x2552, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #23 */
    547     { 0x016b, 0x8854, 0x3800, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #24 */
    548     { 0x056b, 0x8854, 0x3800, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #25 */
    549     { 0x096b, 0x8854, 0x3800, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #26 */
    550     { 0x0d6b, 0x8854, 0x3800, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #27 */
    551     { 0x0252, 0xbdd0, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #28 */
    552     { 0x0652, 0xbdd0, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #29 */
    553     { 0x0a52, 0xbdd0, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #30 */
    554     { 0x0e52, 0xbdd0, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #31 */
    555     { 0x036c, 0xd6e8, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #32 */
    556     { 0x076c, 0xd6e8, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #33 */
    557     { 0x0b6c, 0xd6e8, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #34 */
    558     { 0x0f6c, 0xd6e8, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #35 */
    559     { 0x0245, 0x5ebc, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #36 */
    560     { 0x0645, 0x5ebc, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #37 */
    561     { 0x0a45, 0x5ebc, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #38 */
    562     { 0x0e45, 0x5ebc, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #39 */
    563     { 0x007b, 0x995d, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #40 */
    564     { 0x047b, 0x995d, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #41 */
    565     { 0x087b, 0x995d, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #42 */
    566     { 0x0c7b, 0x995d, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #43 */
    567     { 0x037d, 0x2b89, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #44 */
    568     { 0x077d, 0x2b89, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #45 */
    569     { 0x0b7d, 0x2b89, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #46 */
    570     { 0x0f7d, 0x2b89, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #47 */
    571     { 0x016c, 0xa13c, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #48 */
    572     { 0x056c, 0xa13c, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #49 */
    573     { 0x096c, 0xa13c, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #50 */
    574     { 0x0d6c, 0xa13c, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #51 */
    575     { 0x0215, 0xaf5d, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #52 */
    576     { 0x0615, 0xaf5d, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #53 */
    577     { 0x0a15, 0xaf5d, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #54 */
    578     { 0x0e15, 0xaf5d, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #55 */
    579     { 0x006e, 0x23d5, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #56 */
    580     { 0x046e, 0x23d5, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #57 */
    581     { 0x086e, 0x23d5, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #58 */
    582     { 0x0c6e, 0x23d5, 0x3900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #59 */
    583     { 0x0077, 0x7302, 0x7900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #60 */
    584     { 0x0477, 0x7302, 0x7900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #61 */
    585     { 0x0877, 0x7302, 0x7900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #62 */
    586     { 0x0c77, 0x7302, 0x7900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #63 */
    587     { 0x025c, 0x5c34, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #64 */
    588     { 0x065c, 0x5c34, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #65 */
    589     { 0x0a5c, 0x5c34, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #66 */
    590     { 0x0e5c, 0x5c34, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #67 */
    591     { 0x005a, 0xf53b, 0x7d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #68 */
    592     { 0x045a, 0xf53b, 0x7d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #69 */
    593     { 0x085a, 0xf53b, 0x7d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #70 */
    594     { 0x0c5a, 0xf53b, 0x7d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #71 */
    595     { 0x020d, 0xf10e, 0x7900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #72 */
    596     { 0x060d, 0xf10e, 0x7900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #73 */
    597     { 0x0a0d, 0xf10e, 0x7900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #74 */
    598     { 0x0e0d, 0xf10e, 0x7900, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #75 */
    599     { 0x021e, 0xea31, 0x7800, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #76 */
    600     { 0x061e, 0xea31, 0x7800, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #77 */
    601     { 0x0a1e, 0xea31, 0x7800, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #78 */
    602     { 0x0e1e, 0xea31, 0x7800, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #79 */
    603     { 0x013c, 0x6c8e, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #80 */
    604     { 0x053c, 0x6c8e, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #81 */
    605     { 0x093c, 0x6c8e, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #82 */
    606     { 0x0d3c, 0x6c8e, 0x7c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #83 */
    607     { 0x0040, 0x85c4, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #84 */
    608     { 0x0440, 0x85c4, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #85 */
    609     { 0x0840, 0x85c4, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #86 */
    610     { 0x0c40, 0x85c4, 0x3d00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #87 */
    611     { 0x0075, 0x2edc, 0x3c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #88 */
    612     { 0x0475, 0x2edc, 0x3c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #89 */
    613     { 0x0875, 0x2edc, 0x3c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #90 */
    614     { 0x0c75, 0x2edc, 0x3c00, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #91 */
    615     { 0x0260, 0x4a5e, 0x7800, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #92 */
    616     { 0x0660, 0x4a5e, 0x7800, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #93 */
    617     { 0x0a60, 0x4a5e, 0x7800, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ac) }, /* #94 */
    618     { 0x0e60, 0x4a5e, 0x7800, RTFLOAT80U_INIT_C(0,16382,0xb17217f7d1cf79ab) }, /* #95 */
     523    { 0x005a, 0x7f91, 0x7d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #0 */
     524    { 0x045a, 0x7f91, 0x7d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #1 */
     525    { 0x085a, 0x7f91, 0x7d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #2 */
     526    { 0x0c5a, 0x7f91, 0x7d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #3 */
     527    { 0x021a, 0x50ac, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #4 */
     528    { 0x061a, 0x50ac, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #5 */
     529    { 0x0a1a, 0x50ac, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #6 */
     530    { 0x0e1a, 0x50ac, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #7 */
     531    { 0x0332, 0x28d3, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #8 */
     532    { 0x0732, 0x28d3, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #9 */
     533    { 0x0b32, 0x28d3, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #10 */
     534    { 0x0f32, 0x28d3, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #11 */
     535    { 0x0230, 0x3444, 0x3c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #12 */
     536    { 0x0630, 0x3444, 0x3c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #13 */
     537    { 0x0a30, 0x3444, 0x3c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #14 */
     538    { 0x0e30, 0x3444, 0x3c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #15 */
     539    { 0x0075, 0x6057, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #16 */
     540    { 0x0475, 0x6057, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #17 */
     541    { 0x0875, 0x6057, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #18 */
     542    { 0x0c75, 0x6057, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #19 */
     543    { 0x026c, 0x2009, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #20 */
     544    { 0x066c, 0x2009, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #21 */
     545    { 0x0a6c, 0x2009, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #22 */
     546    { 0x0e6c, 0x2009, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #23 */
     547    { 0x026e, 0x5c82, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #24 */
     548    { 0x066e, 0x5c82, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #25 */
     549    { 0x0a6e, 0x5c82, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #26 */
     550    { 0x0e6e, 0x5c82, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #27 */
     551    { 0x001c, 0xb59f, 0x3d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #28 */
     552    { 0x041c, 0xb59f, 0x3d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #29 */
     553    { 0x081c, 0xb59f, 0x3d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #30 */
     554    { 0x0c1c, 0xb59f, 0x3d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #31 */
     555    { 0x0028, 0x0186, 0x3900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #32 */
     556    { 0x0428, 0x0186, 0x3900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #33 */
     557    { 0x0828, 0x0186, 0x3900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #34 */
     558    { 0x0c28, 0x0186, 0x3900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #35 */
     559    { 0x033b, 0x7b76, 0x7900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #36 */
     560    { 0x073b, 0x7b76, 0x7900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #37 */
     561    { 0x0b3b, 0x7b76, 0x7900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #38 */
     562    { 0x0f3b, 0x7b76, 0x7900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #39 */
     563    { 0x0024, 0xbbb7, 0x3900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #40 */
     564    { 0x0424, 0xbbb7, 0x3900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #41 */
     565    { 0x0824, 0xbbb7, 0x3900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #42 */
     566    { 0x0c24, 0xbbb7, 0x3900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #43 */
     567    { 0x0258, 0x113b, 0x3900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #44 */
     568    { 0x0658, 0x113b, 0x3900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #45 */
     569    { 0x0a58, 0x113b, 0x3900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #46 */
     570    { 0x0e58, 0x113b, 0x3900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #47 */
     571    { 0x030b, 0xc151, 0x7900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #48 */
     572    { 0x070b, 0xc151, 0x7900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #49 */
     573    { 0x0b0b, 0xc151, 0x7900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #50 */
     574    { 0x0f0b, 0xc151, 0x7900, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #51 */
     575    { 0x0162, 0x3ddc, 0x3d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #52 */
     576    { 0x0562, 0x3ddc, 0x3d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #53 */
     577    { 0x0962, 0x3ddc, 0x3d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #54 */
     578    { 0x0d62, 0x3ddc, 0x3d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #55 */
     579    { 0x007f, 0xf867, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #56 */
     580    { 0x047f, 0xf867, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #57 */
     581    { 0x087f, 0xf867, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #58 */
     582    { 0x0c7f, 0xf867, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #59 */
     583    { 0x035f, 0x74de, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #60 */
     584    { 0x075f, 0x74de, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #61 */
     585    { 0x0b5f, 0x74de, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #62 */
     586    { 0x0f5f, 0x74de, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #63 */
     587    { 0x0140, 0x48d2, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #64 */
     588    { 0x0540, 0x48d2, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #65 */
     589    { 0x0940, 0x48d2, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #66 */
     590    { 0x0d40, 0x48d2, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #67 */
     591    { 0x0139, 0xdde3, 0x7d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #68 */
     592    { 0x0539, 0xdde3, 0x7d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #69 */
     593    { 0x0939, 0xdde3, 0x7d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #70 */
     594    { 0x0d39, 0xdde3, 0x7d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #71 */
     595    { 0x034d, 0x90b6, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #72 */
     596    { 0x074d, 0x90b6, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #73 */
     597    { 0x0b4d, 0x90b6, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #74 */
     598    { 0x0f4d, 0x90b6, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #75 */
     599    { 0x011d, 0x4dbd, 0x7d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #76 */
     600    { 0x051d, 0x4dbd, 0x7d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #77 */
     601    { 0x091d, 0x4dbd, 0x7d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #78 */
     602    { 0x0d1d, 0x4dbd, 0x7d00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #79 */
     603    { 0x0277, 0x8260, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #80 */
     604    { 0x0677, 0x8260, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #81 */
     605    { 0x0a77, 0x8260, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #82 */
     606    { 0x0e77, 0x8260, 0x3800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #83 */
     607    { 0x0310, 0x76ee, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #84 */
     608    { 0x0710, 0x76ee, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #85 */
     609    { 0x0b10, 0x76ee, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #86 */
     610    { 0x0f10, 0x76ee, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #87 */
     611    { 0x024b, 0x724a, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #88 */
     612    { 0x064b, 0x724a, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #89 */
     613    { 0x0a4b, 0x724a, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #90 */
     614    { 0x0e4b, 0x724a, 0x7800, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #91 */
     615    { 0x0205, 0xf4bb, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #92 */
     616    { 0x0605, 0xf4bb, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #93 */
     617    { 0x0a05, 0xf4bb, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ac,16382) }, /* #94 */
     618    { 0x0e05, 0xf4bb, 0x7c00, RTFLOAT80U_INIT_C(0,0xb17217f7d1cf79ab,16382) }, /* #95 */
    619619};
    620620static const FPU_LD_CONST_TEST_T g_aTests_fldz[] =
    621621{
    622     { 0x004d, 0x6e7e, 0x7c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #0 */
    623     { 0x044d, 0x6e7e, 0x7c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #1 */
    624     { 0x084d, 0x6e7e, 0x7c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #2 */
    625     { 0x0c4d, 0x6e7e, 0x7c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #3 */
    626     { 0x0173, 0xb7a2, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #4 */
    627     { 0x0573, 0xb7a2, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #5 */
    628     { 0x0973, 0xb7a2, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #6 */
    629     { 0x0d73, 0xb7a2, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #7 */
    630     { 0x015c, 0xf269, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #8 */
    631     { 0x055c, 0xf269, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #9 */
    632     { 0x095c, 0xf269, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #10 */
    633     { 0x0d5c, 0xf269, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #11 */
    634     { 0x017b, 0x62e5, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #12 */
    635     { 0x057b, 0x62e5, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #13 */
    636     { 0x097b, 0x62e5, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #14 */
    637     { 0x0d7b, 0x62e5, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #15 */
    638     { 0x027c, 0x2dee, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #16 */
    639     { 0x067c, 0x2dee, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #17 */
    640     { 0x0a7c, 0x2dee, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #18 */
    641     { 0x0e7c, 0x2dee, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #19 */
    642     { 0x0318, 0xceba, 0x7c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #20 */
    643     { 0x0718, 0xceba, 0x7c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #21 */
    644     { 0x0b18, 0xceba, 0x7c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #22 */
    645     { 0x0f18, 0xceba, 0x7c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #23 */
    646     { 0x000e, 0x7b7e, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #24 */
    647     { 0x040e, 0x7b7e, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #25 */
    648     { 0x080e, 0x7b7e, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #26 */
    649     { 0x0c0e, 0x7b7e, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #27 */
    650     { 0x036e, 0x8341, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #28 */
    651     { 0x076e, 0x8341, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #29 */
    652     { 0x0b6e, 0x8341, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #30 */
    653     { 0x0f6e, 0x8341, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #31 */
    654     { 0x005a, 0xf1c7, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #32 */
    655     { 0x045a, 0xf1c7, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #33 */
    656     { 0x085a, 0xf1c7, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #34 */
    657     { 0x0c5a, 0xf1c7, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #35 */
    658     { 0x0121, 0x4a6e, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #36 */
    659     { 0x0521, 0x4a6e, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #37 */
    660     { 0x0921, 0x4a6e, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #38 */
    661     { 0x0d21, 0x4a6e, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #39 */
    662     { 0x036f, 0xa93b, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #40 */
    663     { 0x076f, 0xa93b, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #41 */
    664     { 0x0b6f, 0xa93b, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #42 */
    665     { 0x0f6f, 0xa93b, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #43 */
    666     { 0x0164, 0x8d32, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #44 */
    667     { 0x0564, 0x8d32, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #45 */
    668     { 0x0964, 0x8d32, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #46 */
    669     { 0x0d64, 0x8d32, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #47 */
    670     { 0x0034, 0xc7bd, 0x7d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #48 */
    671     { 0x0434, 0xc7bd, 0x7d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #49 */
    672     { 0x0834, 0xc7bd, 0x7d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #50 */
    673     { 0x0c34, 0xc7bd, 0x7d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #51 */
    674     { 0x0348, 0xea21, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #52 */
    675     { 0x0748, 0xea21, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #53 */
    676     { 0x0b48, 0xea21, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #54 */
    677     { 0x0f48, 0xea21, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #55 */
    678     { 0x0132, 0x84ce, 0x3c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #56 */
    679     { 0x0532, 0x84ce, 0x3c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #57 */
    680     { 0x0932, 0x84ce, 0x3c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #58 */
    681     { 0x0d32, 0x84ce, 0x3c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #59 */
    682     { 0x0241, 0x87fe, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #60 */
    683     { 0x0641, 0x87fe, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #61 */
    684     { 0x0a41, 0x87fe, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #62 */
    685     { 0x0e41, 0x87fe, 0x3d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #63 */
    686     { 0x000e, 0x5d26, 0x7d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #64 */
    687     { 0x040e, 0x5d26, 0x7d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #65 */
    688     { 0x080e, 0x5d26, 0x7d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #66 */
    689     { 0x0c0e, 0x5d26, 0x7d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #67 */
    690     { 0x034c, 0xbbf0, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #68 */
    691     { 0x074c, 0xbbf0, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #69 */
    692     { 0x0b4c, 0xbbf0, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #70 */
    693     { 0x0f4c, 0xbbf0, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #71 */
    694     { 0x0352, 0x5235, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #72 */
    695     { 0x0752, 0x5235, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #73 */
    696     { 0x0b52, 0x5235, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #74 */
    697     { 0x0f52, 0x5235, 0x7800, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #75 */
    698     { 0x0144, 0x43fe, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #76 */
    699     { 0x0544, 0x43fe, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #77 */
    700     { 0x0944, 0x43fe, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #78 */
    701     { 0x0d44, 0x43fe, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #79 */
    702     { 0x030e, 0xff73, 0x7d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #80 */
    703     { 0x070e, 0xff73, 0x7d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #81 */
    704     { 0x0b0e, 0xff73, 0x7d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #82 */
    705     { 0x0f0e, 0xff73, 0x7d00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #83 */
    706     { 0x0304, 0x7413, 0x7c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #84 */
    707     { 0x0704, 0x7413, 0x7c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #85 */
    708     { 0x0b04, 0x7413, 0x7c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #86 */
    709     { 0x0f04, 0x7413, 0x7c00, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #87 */
    710     { 0x0210, 0xc9dd, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #88 */
    711     { 0x0610, 0xc9dd, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #89 */
    712     { 0x0a10, 0xc9dd, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #90 */
    713     { 0x0e10, 0xc9dd, 0x7900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #91 */
    714     { 0x015e, 0xbb85, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #92 */
    715     { 0x055e, 0xbb85, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #93 */
    716     { 0x095e, 0xbb85, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #94 */
    717     { 0x0d5e, 0xbb85, 0x3900, RTFLOAT80U_INIT_C(0,0,0x0) }, /* #95 */
     622    { 0x012d, 0xd3de, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #0 */
     623    { 0x052d, 0xd3de, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #1 */
     624    { 0x092d, 0xd3de, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #2 */
     625    { 0x0d2d, 0xd3de, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #3 */
     626    { 0x0323, 0x0a34, 0x3800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #4 */
     627    { 0x0723, 0x0a34, 0x3800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #5 */
     628    { 0x0b23, 0x0a34, 0x3800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #6 */
     629    { 0x0f23, 0x0a34, 0x3800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #7 */
     630    { 0x0160, 0xd9d5, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #8 */
     631    { 0x0560, 0xd9d5, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #9 */
     632    { 0x0960, 0xd9d5, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #10 */
     633    { 0x0d60, 0xd9d5, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #11 */
     634    { 0x0024, 0x8a6f, 0x3800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #12 */
     635    { 0x0424, 0x8a6f, 0x3800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #13 */
     636    { 0x0824, 0x8a6f, 0x3800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #14 */
     637    { 0x0c24, 0x8a6f, 0x3800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #15 */
     638    { 0x013f, 0x340b, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #16 */
     639    { 0x053f, 0x340b, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #17 */
     640    { 0x093f, 0x340b, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #18 */
     641    { 0x0d3f, 0x340b, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #19 */
     642    { 0x037e, 0xbf5e, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #20 */
     643    { 0x077e, 0xbf5e, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #21 */
     644    { 0x0b7e, 0xbf5e, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #22 */
     645    { 0x0f7e, 0xbf5e, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #23 */
     646    { 0x007d, 0xbad6, 0x3800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #24 */
     647    { 0x047d, 0xbad6, 0x3800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #25 */
     648    { 0x087d, 0xbad6, 0x3800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #26 */
     649    { 0x0c7d, 0xbad6, 0x3800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #27 */
     650    { 0x012d, 0x0642, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #28 */
     651    { 0x052d, 0x0642, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #29 */
     652    { 0x092d, 0x0642, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #30 */
     653    { 0x0d2d, 0x0642, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #31 */
     654    { 0x032a, 0x5eea, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #32 */
     655    { 0x072a, 0x5eea, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #33 */
     656    { 0x0b2a, 0x5eea, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #34 */
     657    { 0x0f2a, 0x5eea, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #35 */
     658    { 0x004d, 0xf938, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #36 */
     659    { 0x044d, 0xf938, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #37 */
     660    { 0x084d, 0xf938, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #38 */
     661    { 0x0c4d, 0xf938, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #39 */
     662    { 0x004f, 0x992a, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #40 */
     663    { 0x044f, 0x992a, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #41 */
     664    { 0x084f, 0x992a, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #42 */
     665    { 0x0c4f, 0x992a, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #43 */
     666    { 0x016d, 0x06fd, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #44 */
     667    { 0x056d, 0x06fd, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #45 */
     668    { 0x096d, 0x06fd, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #46 */
     669    { 0x0d6d, 0x06fd, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #47 */
     670    { 0x0149, 0xabf0, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #48 */
     671    { 0x0549, 0xabf0, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #49 */
     672    { 0x0949, 0xabf0, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #50 */
     673    { 0x0d49, 0xabf0, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #51 */
     674    { 0x036e, 0xee5b, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #52 */
     675    { 0x076e, 0xee5b, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #53 */
     676    { 0x0b6e, 0xee5b, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #54 */
     677    { 0x0f6e, 0xee5b, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #55 */
     678    { 0x0006, 0x4734, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #56 */
     679    { 0x0406, 0x4734, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #57 */
     680    { 0x0806, 0x4734, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #58 */
     681    { 0x0c06, 0x4734, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #59 */
     682    { 0x035b, 0xf256, 0x7800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #60 */
     683    { 0x075b, 0xf256, 0x7800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #61 */
     684    { 0x0b5b, 0xf256, 0x7800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #62 */
     685    { 0x0f5b, 0xf256, 0x7800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #63 */
     686    { 0x0313, 0x8d6c, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #64 */
     687    { 0x0713, 0x8d6c, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #65 */
     688    { 0x0b13, 0x8d6c, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #66 */
     689    { 0x0f13, 0x8d6c, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #67 */
     690    { 0x0060, 0x0d42, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #68 */
     691    { 0x0460, 0x0d42, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #69 */
     692    { 0x0860, 0x0d42, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #70 */
     693    { 0x0c60, 0x0d42, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #71 */
     694    { 0x007b, 0xc8b9, 0x7800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #72 */
     695    { 0x047b, 0xc8b9, 0x7800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #73 */
     696    { 0x087b, 0xc8b9, 0x7800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #74 */
     697    { 0x0c7b, 0xc8b9, 0x7800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #75 */
     698    { 0x0234, 0x05cd, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #76 */
     699    { 0x0634, 0x05cd, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #77 */
     700    { 0x0a34, 0x05cd, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #78 */
     701    { 0x0e34, 0x05cd, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #79 */
     702    { 0x024e, 0x1439, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #80 */
     703    { 0x064e, 0x1439, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #81 */
     704    { 0x0a4e, 0x1439, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #82 */
     705    { 0x0e4e, 0x1439, 0x3c00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #83 */
     706    { 0x0338, 0xeaff, 0x7800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #84 */
     707    { 0x0738, 0xeaff, 0x7800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #85 */
     708    { 0x0b38, 0xeaff, 0x7800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #86 */
     709    { 0x0f38, 0xeaff, 0x7800, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #87 */
     710    { 0x0148, 0x95a6, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #88 */
     711    { 0x0548, 0x95a6, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #89 */
     712    { 0x0948, 0x95a6, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #90 */
     713    { 0x0d48, 0x95a6, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #91 */
     714    { 0x0338, 0x5d33, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #92 */
     715    { 0x0738, 0x5d33, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #93 */
     716    { 0x0b38, 0x5d33, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #94 */
     717    { 0x0f38, 0x5d33, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0) }, /* #95 */
     718};
     719
     720
     721#define HAVE_FPU_LD_MEM
     722static const FPU_R80_IN_TEST_T g_aTests_fld_r80_from_r80[] =
     723{
     724    { 0x021b, 0xa5c8, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT80U_INIT_C(0,0x0,0) }, /* #0 */
     725    { 0x061b, 0xa5c8, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT80U_INIT_C(0,0x0,0) }, /* #1 */
     726    { 0x0a1b, 0xa5c8, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT80U_INIT_C(0,0x0,0) }, /* #2 */
     727    { 0x0e1b, 0xa5c8, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT80U_INIT_C(0,0x0,0) }, /* #3 */
     728    { 0x0066, 0x56c5, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT80U_INIT_C(0,0x0,0) }, /* #4 */
     729    { 0x0466, 0x56c5, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT80U_INIT_C(0,0x0,0) }, /* #5 */
     730    { 0x0866, 0x56c5, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT80U_INIT_C(0,0x0,0) }, /* #6 */
     731    { 0x0c66, 0x56c5, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT80U_INIT_C(0,0x0,0) }, /* #7 */
     732    { 0x0347, 0x2593, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT80U_INIT_C(0,0x0,0) }, /* #8 */
     733    { 0x0747, 0x2593, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT80U_INIT_C(0,0x0,0) }, /* #9 */
     734    { 0x0b47, 0x2593, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT80U_INIT_C(0,0x0,0) }, /* #10 */
     735    { 0x0f47, 0x2593, 0x3d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT80U_INIT_C(0,0x0,0) }, /* #11 */
     736    { 0x0025, 0x58a7, 0x7800, RTFLOAT80U_INIT_C(1,0x92fcddabcbdf7728,6127), RTFLOAT80U_INIT_C(1,0x92fcddabcbdf7728,6127) }, /* #12 */
     737    { 0x0425, 0x58a7, 0x7800, RTFLOAT80U_INIT_C(1,0x92fcddabcbdf7728,6127), RTFLOAT80U_INIT_C(1,0x92fcddabcbdf7728,6127) }, /* #13 */
     738    { 0x0825, 0x58a7, 0x7800, RTFLOAT80U_INIT_C(1,0x92fcddabcbdf7728,6127), RTFLOAT80U_INIT_C(1,0x92fcddabcbdf7728,6127) }, /* #14 */
     739    { 0x0c25, 0x58a7, 0x7800, RTFLOAT80U_INIT_C(1,0x92fcddabcbdf7728,6127), RTFLOAT80U_INIT_C(1,0x92fcddabcbdf7728,6127) }, /* #15 */
     740    { 0x0254, 0x3819, 0x3800, RTFLOAT80U_INIT_C(0,0xc03012170ccd9291,30930), RTFLOAT80U_INIT_C(0,0xc03012170ccd9291,30930) }, /* #16 */
     741    { 0x0654, 0x3819, 0x3800, RTFLOAT80U_INIT_C(0,0xc03012170ccd9291,30930), RTFLOAT80U_INIT_C(0,0xc03012170ccd9291,30930) }, /* #17 */
     742    { 0x0a54, 0x3819, 0x3800, RTFLOAT80U_INIT_C(0,0xc03012170ccd9291,30930), RTFLOAT80U_INIT_C(0,0xc03012170ccd9291,30930) }, /* #18 */
     743    { 0x0e54, 0x3819, 0x3800, RTFLOAT80U_INIT_C(0,0xc03012170ccd9291,30930), RTFLOAT80U_INIT_C(0,0xc03012170ccd9291,30930) }, /* #19 */
     744    { 0x0347, 0x8475, 0x3c00, RTFLOAT80U_INIT_C(0,0x7561209128a529c1,12785), RTFLOAT80U_INIT_C(0,0x7561209128a529c1,12785) }, /* #20 */
     745    { 0x0747, 0x8475, 0x3c00, RTFLOAT80U_INIT_C(0,0x7561209128a529c1,12785), RTFLOAT80U_INIT_C(0,0x7561209128a529c1,12785) }, /* #21 */
     746    { 0x0b47, 0x8475, 0x3c00, RTFLOAT80U_INIT_C(0,0x7561209128a529c1,12785), RTFLOAT80U_INIT_C(0,0x7561209128a529c1,12785) }, /* #22 */
     747    { 0x0f47, 0x8475, 0x3c00, RTFLOAT80U_INIT_C(0,0x7561209128a529c1,12785), RTFLOAT80U_INIT_C(0,0x7561209128a529c1,12785) }, /* #23 */
     748    { 0x021b, 0x5415, 0x7c00, RTFLOAT80U_INIT_C(1,0xcaf61d379a16580c,1503), RTFLOAT80U_INIT_C(1,0xcaf61d379a16580c,1503) }, /* #24 */
     749    { 0x061b, 0x5415, 0x7c00, RTFLOAT80U_INIT_C(1,0xcaf61d379a16580c,1503), RTFLOAT80U_INIT_C(1,0xcaf61d379a16580c,1503) }, /* #25 */
     750    { 0x0a1b, 0x5415, 0x7c00, RTFLOAT80U_INIT_C(1,0xcaf61d379a16580c,1503), RTFLOAT80U_INIT_C(1,0xcaf61d379a16580c,1503) }, /* #26 */
     751    { 0x0e1b, 0x5415, 0x7c00, RTFLOAT80U_INIT_C(1,0xcaf61d379a16580c,1503), RTFLOAT80U_INIT_C(1,0xcaf61d379a16580c,1503) }, /* #27 */
     752    { 0x0205, 0xddcb, 0x7d00, RTFLOAT80U_INIT_C(1,0xd0ee478b553eec33,2390), RTFLOAT80U_INIT_C(1,0xd0ee478b553eec33,2390) }, /* #28 */
     753    { 0x0605, 0xddcb, 0x7d00, RTFLOAT80U_INIT_C(1,0xd0ee478b553eec33,2390), RTFLOAT80U_INIT_C(1,0xd0ee478b553eec33,2390) }, /* #29 */
     754    { 0x0a05, 0xddcb, 0x7d00, RTFLOAT80U_INIT_C(1,0xd0ee478b553eec33,2390), RTFLOAT80U_INIT_C(1,0xd0ee478b553eec33,2390) }, /* #30 */
     755    { 0x0e05, 0xddcb, 0x7d00, RTFLOAT80U_INIT_C(1,0xd0ee478b553eec33,2390), RTFLOAT80U_INIT_C(1,0xd0ee478b553eec33,2390) }, /* #31 */
     756    { 0x0376, 0xca59, 0x7800, RTFLOAT80U_INIT_C(1,0x34746bbe9b8871ca,25583), RTFLOAT80U_INIT_C(1,0x34746bbe9b8871ca,25583) }, /* #32 */
     757    { 0x0776, 0xca59, 0x7800, RTFLOAT80U_INIT_C(1,0x34746bbe9b8871ca,25583), RTFLOAT80U_INIT_C(1,0x34746bbe9b8871ca,25583) }, /* #33 */
     758    { 0x0b76, 0xca59, 0x7800, RTFLOAT80U_INIT_C(1,0x34746bbe9b8871ca,25583), RTFLOAT80U_INIT_C(1,0x34746bbe9b8871ca,25583) }, /* #34 */
     759    { 0x0f76, 0xca59, 0x7800, RTFLOAT80U_INIT_C(1,0x34746bbe9b8871ca,25583), RTFLOAT80U_INIT_C(1,0x34746bbe9b8871ca,25583) }, /* #35 */
     760    { 0x0216, 0x8788, 0x3d00, RTFLOAT80U_INIT_C(0,0xa7d1b93255806d41,11343), RTFLOAT80U_INIT_C(0,0xa7d1b93255806d41,11343) }, /* #36 */
     761    { 0x0616, 0x8788, 0x3d00, RTFLOAT80U_INIT_C(0,0xa7d1b93255806d41,11343), RTFLOAT80U_INIT_C(0,0xa7d1b93255806d41,11343) }, /* #37 */
     762    { 0x0a16, 0x8788, 0x3d00, RTFLOAT80U_INIT_C(0,0xa7d1b93255806d41,11343), RTFLOAT80U_INIT_C(0,0xa7d1b93255806d41,11343) }, /* #38 */
     763    { 0x0e16, 0x8788, 0x3d00, RTFLOAT80U_INIT_C(0,0xa7d1b93255806d41,11343), RTFLOAT80U_INIT_C(0,0xa7d1b93255806d41,11343) }, /* #39 */
     764    { 0x0127, 0x5acd, 0x7800, RTFLOAT80U_INIT_C(1,0x6c5d1ebe1a9526ad,3278), RTFLOAT80U_INIT_C(1,0x6c5d1ebe1a9526ad,3278) }, /* #40 */
     765    { 0x0527, 0x5acd, 0x7800, RTFLOAT80U_INIT_C(1,0x6c5d1ebe1a9526ad,3278), RTFLOAT80U_INIT_C(1,0x6c5d1ebe1a9526ad,3278) }, /* #41 */
     766    { 0x0927, 0x5acd, 0x7800, RTFLOAT80U_INIT_C(1,0x6c5d1ebe1a9526ad,3278), RTFLOAT80U_INIT_C(1,0x6c5d1ebe1a9526ad,3278) }, /* #42 */
     767    { 0x0d27, 0x5acd, 0x7800, RTFLOAT80U_INIT_C(1,0x6c5d1ebe1a9526ad,3278), RTFLOAT80U_INIT_C(1,0x6c5d1ebe1a9526ad,3278) }, /* #43 */
     768    { 0x016a, 0x1ce1, 0x3c00, RTFLOAT80U_INIT_C(0,0x6292ff93c8128dc9,3788), RTFLOAT80U_INIT_C(0,0x6292ff93c8128dc9,3788) }, /* #44 */
     769    { 0x056a, 0x1ce1, 0x3c00, RTFLOAT80U_INIT_C(0,0x6292ff93c8128dc9,3788), RTFLOAT80U_INIT_C(0,0x6292ff93c8128dc9,3788) }, /* #45 */
     770    { 0x096a, 0x1ce1, 0x3c00, RTFLOAT80U_INIT_C(0,0x6292ff93c8128dc9,3788), RTFLOAT80U_INIT_C(0,0x6292ff93c8128dc9,3788) }, /* #46 */
     771    { 0x0d6a, 0x1ce1, 0x3c00, RTFLOAT80U_INIT_C(0,0x6292ff93c8128dc9,3788), RTFLOAT80U_INIT_C(0,0x6292ff93c8128dc9,3788) }, /* #47 */
     772    { 0x0014, 0xb9d4, 0x3900, RTFLOAT80U_INIT_C(0,0x6a574d09b96239e9,25981), RTFLOAT80U_INIT_C(0,0x6a574d09b96239e9,25981) }, /* #48 */
     773    { 0x0414, 0xb9d4, 0x3900, RTFLOAT80U_INIT_C(0,0x6a574d09b96239e9,25981), RTFLOAT80U_INIT_C(0,0x6a574d09b96239e9,25981) }, /* #49 */
     774    { 0x0814, 0xb9d4, 0x3900, RTFLOAT80U_INIT_C(0,0x6a574d09b96239e9,25981), RTFLOAT80U_INIT_C(0,0x6a574d09b96239e9,25981) }, /* #50 */
     775    { 0x0c14, 0xb9d4, 0x3900, RTFLOAT80U_INIT_C(0,0x6a574d09b96239e9,25981), RTFLOAT80U_INIT_C(0,0x6a574d09b96239e9,25981) }, /* #51 */
     776    { 0x0272, 0x1b07, 0x3900, RTFLOAT80U_INIT_C(1,0x3c39e3facd4eb25c,14596), RTFLOAT80U_INIT_C(1,0x3c39e3facd4eb25c,14596) }, /* #52 */
     777    { 0x0672, 0x1b07, 0x3900, RTFLOAT80U_INIT_C(1,0x3c39e3facd4eb25c,14596), RTFLOAT80U_INIT_C(1,0x3c39e3facd4eb25c,14596) }, /* #53 */
     778    { 0x0a72, 0x1b07, 0x3900, RTFLOAT80U_INIT_C(1,0x3c39e3facd4eb25c,14596), RTFLOAT80U_INIT_C(1,0x3c39e3facd4eb25c,14596) }, /* #54 */
     779    { 0x0e72, 0x1b07, 0x3900, RTFLOAT80U_INIT_C(1,0x3c39e3facd4eb25c,14596), RTFLOAT80U_INIT_C(1,0x3c39e3facd4eb25c,14596) }, /* #55 */
     780    { 0x002f, 0xdc24, 0x7c00, RTFLOAT80U_INIT_C(0,0xfdb39c33780d3cb5,11466), RTFLOAT80U_INIT_C(0,0xfdb39c33780d3cb5,11466) }, /* #56 */
     781    { 0x042f, 0xdc24, 0x7c00, RTFLOAT80U_INIT_C(0,0xfdb39c33780d3cb5,11466), RTFLOAT80U_INIT_C(0,0xfdb39c33780d3cb5,11466) }, /* #57 */
     782    { 0x082f, 0xdc24, 0x7c00, RTFLOAT80U_INIT_C(0,0xfdb39c33780d3cb5,11466), RTFLOAT80U_INIT_C(0,0xfdb39c33780d3cb5,11466) }, /* #58 */
     783    { 0x0c2f, 0xdc24, 0x7c00, RTFLOAT80U_INIT_C(0,0xfdb39c33780d3cb5,11466), RTFLOAT80U_INIT_C(0,0xfdb39c33780d3cb5,11466) }, /* #59 */
     784    { 0x035f, 0x82a2, 0x3800, RTFLOAT80U_INIT_C(0,0x2b9cb30498070936,5610), RTFLOAT80U_INIT_C(0,0x2b9cb30498070936,5610) }, /* #60 */
     785    { 0x075f, 0x82a2, 0x3800, RTFLOAT80U_INIT_C(0,0x2b9cb30498070936,5610), RTFLOAT80U_INIT_C(0,0x2b9cb30498070936,5610) }, /* #61 */
     786    { 0x0b5f, 0x82a2, 0x3800, RTFLOAT80U_INIT_C(0,0x2b9cb30498070936,5610), RTFLOAT80U_INIT_C(0,0x2b9cb30498070936,5610) }, /* #62 */
     787    { 0x0f5f, 0x82a2, 0x3800, RTFLOAT80U_INIT_C(0,0x2b9cb30498070936,5610), RTFLOAT80U_INIT_C(0,0x2b9cb30498070936,5610) }, /* #63 */
     788    { 0x016b, 0x4cb3, 0x7c00, RTFLOAT80U_INIT_C(1,0xb04ea622ba8fe635,1943), RTFLOAT80U_INIT_C(1,0xb04ea622ba8fe635,1943) }, /* #64 */
     789    { 0x056b, 0x4cb3, 0x7c00, RTFLOAT80U_INIT_C(1,0xb04ea622ba8fe635,1943), RTFLOAT80U_INIT_C(1,0xb04ea622ba8fe635,1943) }, /* #65 */
     790    { 0x096b, 0x4cb3, 0x7c00, RTFLOAT80U_INIT_C(1,0xb04ea622ba8fe635,1943), RTFLOAT80U_INIT_C(1,0xb04ea622ba8fe635,1943) }, /* #66 */
     791    { 0x0d6b, 0x4cb3, 0x7c00, RTFLOAT80U_INIT_C(1,0xb04ea622ba8fe635,1943), RTFLOAT80U_INIT_C(1,0xb04ea622ba8fe635,1943) }, /* #67 */
     792    { 0x025f, 0xf7a9, 0x7d00, RTFLOAT80U_INIT_C(0,0x6bbd11f24a43a899,7013), RTFLOAT80U_INIT_C(0,0x6bbd11f24a43a899,7013) }, /* #68 */
     793    { 0x065f, 0xf7a9, 0x7d00, RTFLOAT80U_INIT_C(0,0x6bbd11f24a43a899,7013), RTFLOAT80U_INIT_C(0,0x6bbd11f24a43a899,7013) }, /* #69 */
     794    { 0x0a5f, 0xf7a9, 0x7d00, RTFLOAT80U_INIT_C(0,0x6bbd11f24a43a899,7013), RTFLOAT80U_INIT_C(0,0x6bbd11f24a43a899,7013) }, /* #70 */
     795    { 0x0e5f, 0xf7a9, 0x7d00, RTFLOAT80U_INIT_C(0,0x6bbd11f24a43a899,7013), RTFLOAT80U_INIT_C(0,0x6bbd11f24a43a899,7013) }, /* #71 */
     796    { 0x0344, 0xb70a, 0x3d00, RTFLOAT80U_INIT_C(0,0x5c646a6eb862789a,31845), RTFLOAT80U_INIT_C(0,0x5c646a6eb862789a,31845) }, /* #72 */
     797    { 0x0744, 0xb70a, 0x3d00, RTFLOAT80U_INIT_C(0,0x5c646a6eb862789a,31845), RTFLOAT80U_INIT_C(0,0x5c646a6eb862789a,31845) }, /* #73 */
     798    { 0x0b44, 0xb70a, 0x3d00, RTFLOAT80U_INIT_C(0,0x5c646a6eb862789a,31845), RTFLOAT80U_INIT_C(0,0x5c646a6eb862789a,31845) }, /* #74 */
     799    { 0x0f44, 0xb70a, 0x3d00, RTFLOAT80U_INIT_C(0,0x5c646a6eb862789a,31845), RTFLOAT80U_INIT_C(0,0x5c646a6eb862789a,31845) }, /* #75 */
     800    { 0x0243, 0x2a94, 0x3800, RTFLOAT80U_INIT_C(1,0x6ab22b9f6597bed0,17417), RTFLOAT80U_INIT_C(1,0x6ab22b9f6597bed0,17417) }, /* #76 */
     801    { 0x0643, 0x2a94, 0x3800, RTFLOAT80U_INIT_C(1,0x6ab22b9f6597bed0,17417), RTFLOAT80U_INIT_C(1,0x6ab22b9f6597bed0,17417) }, /* #77 */
     802    { 0x0a43, 0x2a94, 0x3800, RTFLOAT80U_INIT_C(1,0x6ab22b9f6597bed0,17417), RTFLOAT80U_INIT_C(1,0x6ab22b9f6597bed0,17417) }, /* #78 */
     803    { 0x0e43, 0x2a94, 0x3800, RTFLOAT80U_INIT_C(1,0x6ab22b9f6597bed0,17417), RTFLOAT80U_INIT_C(1,0x6ab22b9f6597bed0,17417) }, /* #79 */
     804    { 0x0025, 0x6e47, 0x7c00, RTFLOAT80U_INIT_C(1,0x5dacc39566dc841c,19988), RTFLOAT80U_INIT_C(1,0x5dacc39566dc841c,19988) }, /* #80 */
     805    { 0x0425, 0x6e47, 0x7c00, RTFLOAT80U_INIT_C(1,0x5dacc39566dc841c,19988), RTFLOAT80U_INIT_C(1,0x5dacc39566dc841c,19988) }, /* #81 */
     806    { 0x0825, 0x6e47, 0x7c00, RTFLOAT80U_INIT_C(1,0x5dacc39566dc841c,19988), RTFLOAT80U_INIT_C(1,0x5dacc39566dc841c,19988) }, /* #82 */
     807    { 0x0c25, 0x6e47, 0x7c00, RTFLOAT80U_INIT_C(1,0x5dacc39566dc841c,19988), RTFLOAT80U_INIT_C(1,0x5dacc39566dc841c,19988) }, /* #83 */
     808    { 0x0220, 0x1c82, 0x3c00, RTFLOAT80U_INIT_C(1,0x40f7693fa86796c,5531), RTFLOAT80U_INIT_C(1,0x40f7693fa86796c,5531) }, /* #84 */
     809    { 0x0620, 0x1c82, 0x3c00, RTFLOAT80U_INIT_C(1,0x40f7693fa86796c,5531), RTFLOAT80U_INIT_C(1,0x40f7693fa86796c,5531) }, /* #85 */
     810    { 0x0a20, 0x1c82, 0x3c00, RTFLOAT80U_INIT_C(1,0x40f7693fa86796c,5531), RTFLOAT80U_INIT_C(1,0x40f7693fa86796c,5531) }, /* #86 */
     811    { 0x0e20, 0x1c82, 0x3c00, RTFLOAT80U_INIT_C(1,0x40f7693fa86796c,5531), RTFLOAT80U_INIT_C(1,0x40f7693fa86796c,5531) }, /* #87 */
     812    { 0x0266, 0x0244, 0x3800, RTFLOAT80U_INIT_C(1,0xd712f72b1f688f18,6389), RTFLOAT80U_INIT_C(1,0xd712f72b1f688f18,6389) }, /* #88 */
     813    { 0x0666, 0x0244, 0x3800, RTFLOAT80U_INIT_C(1,0xd712f72b1f688f18,6389), RTFLOAT80U_INIT_C(1,0xd712f72b1f688f18,6389) }, /* #89 */
     814    { 0x0a66, 0x0244, 0x3800, RTFLOAT80U_INIT_C(1,0xd712f72b1f688f18,6389), RTFLOAT80U_INIT_C(1,0xd712f72b1f688f18,6389) }, /* #90 */
     815    { 0x0e66, 0x0244, 0x3800, RTFLOAT80U_INIT_C(1,0xd712f72b1f688f18,6389), RTFLOAT80U_INIT_C(1,0xd712f72b1f688f18,6389) }, /* #91 */
     816    { 0x0244, 0x8b78, 0x3900, RTFLOAT80U_INIT_C(1,0xc0e3980ecde84314,14558), RTFLOAT80U_INIT_C(1,0xc0e3980ecde84314,14558) }, /* #92 */
     817    { 0x0644, 0x8b78, 0x3900, RTFLOAT80U_INIT_C(1,0xc0e3980ecde84314,14558), RTFLOAT80U_INIT_C(1,0xc0e3980ecde84314,14558) }, /* #93 */
     818    { 0x0a44, 0x8b78, 0x3900, RTFLOAT80U_INIT_C(1,0xc0e3980ecde84314,14558), RTFLOAT80U_INIT_C(1,0xc0e3980ecde84314,14558) }, /* #94 */
     819    { 0x0e44, 0x8b78, 0x3900, RTFLOAT80U_INIT_C(1,0xc0e3980ecde84314,14558), RTFLOAT80U_INIT_C(1,0xc0e3980ecde84314,14558) }, /* #95 */
     820};
     821static const FPU_R64_IN_TEST_T g_aTests_fld_r80_from_r64[] =
     822{
     823    { 0x0106, 0x01d1, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT64U_INIT_C(0,0x0,0) }, /* #0 */
     824    { 0x0506, 0x01d1, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT64U_INIT_C(0,0x0,0) }, /* #1 */
     825    { 0x0906, 0x01d1, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT64U_INIT_C(0,0x0,0) }, /* #2 */
     826    { 0x0d06, 0x01d1, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT64U_INIT_C(0,0x0,0) }, /* #3 */
     827    { 0x0029, 0x79c0, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT64U_INIT_C(0,0x0,0) }, /* #4 */
     828    { 0x0429, 0x79c0, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT64U_INIT_C(0,0x0,0) }, /* #5 */
     829    { 0x0829, 0x79c0, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT64U_INIT_C(0,0x0,0) }, /* #6 */
     830    { 0x0c29, 0x79c0, 0x7900, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT64U_INIT_C(0,0x0,0) }, /* #7 */
     831    { 0x0131, 0x7faa, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT64U_INIT_C(0,0x0,0) }, /* #8 */
     832    { 0x0531, 0x7faa, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT64U_INIT_C(0,0x0,0) }, /* #9 */
     833    { 0x0931, 0x7faa, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT64U_INIT_C(0,0x0,0) }, /* #10 */
     834    { 0x0d31, 0x7faa, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT64U_INIT_C(0,0x0,0) }, /* #11 */
     835    { 0x0266, 0x8f0b, 0x3d00, RTFLOAT80U_INIT_C(0,0xbed189be574cc000,16609), RTFLOAT64U_INIT_C(0,0x7da3137cae998,1249) }, /* #12 */
     836    { 0x0666, 0x8f0b, 0x3d00, RTFLOAT80U_INIT_C(0,0xbed189be574cc000,16609), RTFLOAT64U_INIT_C(0,0x7da3137cae998,1249) }, /* #13 */
     837    { 0x0a66, 0x8f0b, 0x3d00, RTFLOAT80U_INIT_C(0,0xbed189be574cc000,16609), RTFLOAT64U_INIT_C(0,0x7da3137cae998,1249) }, /* #14 */
     838    { 0x0e66, 0x8f0b, 0x3d00, RTFLOAT80U_INIT_C(0,0xbed189be574cc000,16609), RTFLOAT64U_INIT_C(0,0x7da3137cae998,1249) }, /* #15 */
     839    { 0x0155, 0x30de, 0x3800, RTFLOAT80U_INIT_C(1,0xebde35858b188000,17062), RTFLOAT64U_INIT_C(1,0xd7bc6b0b16310,1702) }, /* #16 */
     840    { 0x0555, 0x30de, 0x3800, RTFLOAT80U_INIT_C(1,0xebde35858b188000,17062), RTFLOAT64U_INIT_C(1,0xd7bc6b0b16310,1702) }, /* #17 */
     841    { 0x0955, 0x30de, 0x3800, RTFLOAT80U_INIT_C(1,0xebde35858b188000,17062), RTFLOAT64U_INIT_C(1,0xd7bc6b0b16310,1702) }, /* #18 */
     842    { 0x0d55, 0x30de, 0x3800, RTFLOAT80U_INIT_C(1,0xebde35858b188000,17062), RTFLOAT64U_INIT_C(1,0xd7bc6b0b16310,1702) }, /* #19 */
     843    { 0x0108, 0x949f, 0x3c00, RTFLOAT80U_INIT_C(0,0xf990a753f08f5000,16179), RTFLOAT64U_INIT_C(0,0xf3214ea7e11ea,819) }, /* #20 */
     844    { 0x0508, 0x949f, 0x3c00, RTFLOAT80U_INIT_C(0,0xf990a753f08f5000,16179), RTFLOAT64U_INIT_C(0,0xf3214ea7e11ea,819) }, /* #21 */
     845    { 0x0908, 0x949f, 0x3c00, RTFLOAT80U_INIT_C(0,0xf990a753f08f5000,16179), RTFLOAT64U_INIT_C(0,0xf3214ea7e11ea,819) }, /* #22 */
     846    { 0x0d08, 0x949f, 0x3c00, RTFLOAT80U_INIT_C(0,0xf990a753f08f5000,16179), RTFLOAT64U_INIT_C(0,0xf3214ea7e11ea,819) }, /* #23 */
     847    { 0x012a, 0x4186, 0x7900, RTFLOAT80U_INIT_C(1,0xab5fc8f3f407d800,16311), RTFLOAT64U_INIT_C(1,0x56bf91e7e80fb,951) }, /* #24 */
     848    { 0x052a, 0x4186, 0x7900, RTFLOAT80U_INIT_C(1,0xab5fc8f3f407d800,16311), RTFLOAT64U_INIT_C(1,0x56bf91e7e80fb,951) }, /* #25 */
     849    { 0x092a, 0x4186, 0x7900, RTFLOAT80U_INIT_C(1,0xab5fc8f3f407d800,16311), RTFLOAT64U_INIT_C(1,0x56bf91e7e80fb,951) }, /* #26 */
     850    { 0x0d2a, 0x4186, 0x7900, RTFLOAT80U_INIT_C(1,0xab5fc8f3f407d800,16311), RTFLOAT64U_INIT_C(1,0x56bf91e7e80fb,951) }, /* #27 */
     851    { 0x0009, 0xec0c, 0x7c00, RTFLOAT80U_INIT_C(0,0xcaacbc7ecdc23000,16414), RTFLOAT64U_INIT_C(0,0x955978fd9b846,1054) }, /* #28 */
     852    { 0x0409, 0xec0c, 0x7c00, RTFLOAT80U_INIT_C(0,0xcaacbc7ecdc23000,16414), RTFLOAT64U_INIT_C(0,0x955978fd9b846,1054) }, /* #29 */
     853    { 0x0809, 0xec0c, 0x7c00, RTFLOAT80U_INIT_C(0,0xcaacbc7ecdc23000,16414), RTFLOAT64U_INIT_C(0,0x955978fd9b846,1054) }, /* #30 */
     854    { 0x0c09, 0xec0c, 0x7c00, RTFLOAT80U_INIT_C(0,0xcaacbc7ecdc23000,16414), RTFLOAT64U_INIT_C(0,0x955978fd9b846,1054) }, /* #31 */
     855    { 0x002d, 0x0e54, 0x3c00, RTFLOAT80U_INIT_C(1,0x90586e0a94313000,17405), RTFLOAT64U_INIT_C(1,0x20b0dc1528626,2045) }, /* #32 */
     856    { 0x042d, 0x0e54, 0x3c00, RTFLOAT80U_INIT_C(1,0x90586e0a94313000,17405), RTFLOAT64U_INIT_C(1,0x20b0dc1528626,2045) }, /* #33 */
     857    { 0x082d, 0x0e54, 0x3c00, RTFLOAT80U_INIT_C(1,0x90586e0a94313000,17405), RTFLOAT64U_INIT_C(1,0x20b0dc1528626,2045) }, /* #34 */
     858    { 0x0c2d, 0x0e54, 0x3c00, RTFLOAT80U_INIT_C(1,0x90586e0a94313000,17405), RTFLOAT64U_INIT_C(1,0x20b0dc1528626,2045) }, /* #35 */
     859    { 0x027f, 0x0808, 0x3800, RTFLOAT80U_INIT_C(1,0x85071a1eccc1b800,17039), RTFLOAT64U_INIT_C(1,0xa0e343d99837,1679) }, /* #36 */
     860    { 0x067f, 0x0808, 0x3800, RTFLOAT80U_INIT_C(1,0x85071a1eccc1b800,17039), RTFLOAT64U_INIT_C(1,0xa0e343d99837,1679) }, /* #37 */
     861    { 0x0a7f, 0x0808, 0x3800, RTFLOAT80U_INIT_C(1,0x85071a1eccc1b800,17039), RTFLOAT64U_INIT_C(1,0xa0e343d99837,1679) }, /* #38 */
     862    { 0x0e7f, 0x0808, 0x3800, RTFLOAT80U_INIT_C(1,0x85071a1eccc1b800,17039), RTFLOAT64U_INIT_C(1,0xa0e343d99837,1679) }, /* #39 */
     863    { 0x0259, 0xfcf3, 0x7c00, RTFLOAT80U_INIT_C(0,0x9c545399f856b800,15641), RTFLOAT64U_INIT_C(0,0x38a8a733f0ad7,281) }, /* #40 */
     864    { 0x0659, 0xfcf3, 0x7c00, RTFLOAT80U_INIT_C(0,0x9c545399f856b800,15641), RTFLOAT64U_INIT_C(0,0x38a8a733f0ad7,281) }, /* #41 */
     865    { 0x0a59, 0xfcf3, 0x7c00, RTFLOAT80U_INIT_C(0,0x9c545399f856b800,15641), RTFLOAT64U_INIT_C(0,0x38a8a733f0ad7,281) }, /* #42 */
     866    { 0x0e59, 0xfcf3, 0x7c00, RTFLOAT80U_INIT_C(0,0x9c545399f856b800,15641), RTFLOAT64U_INIT_C(0,0x38a8a733f0ad7,281) }, /* #43 */
     867    { 0x015a, 0xb3e8, 0x3900, RTFLOAT80U_INIT_C(1,0xb80d170029a8e000,16297), RTFLOAT64U_INIT_C(1,0x701a2e005351c,937) }, /* #44 */
     868    { 0x055a, 0xb3e8, 0x3900, RTFLOAT80U_INIT_C(1,0xb80d170029a8e000,16297), RTFLOAT64U_INIT_C(1,0x701a2e005351c,937) }, /* #45 */
     869    { 0x095a, 0xb3e8, 0x3900, RTFLOAT80U_INIT_C(1,0xb80d170029a8e000,16297), RTFLOAT64U_INIT_C(1,0x701a2e005351c,937) }, /* #46 */
     870    { 0x0d5a, 0xb3e8, 0x3900, RTFLOAT80U_INIT_C(1,0xb80d170029a8e000,16297), RTFLOAT64U_INIT_C(1,0x701a2e005351c,937) }, /* #47 */
     871    { 0x026a, 0x3e7f, 0x3c00, RTFLOAT80U_INIT_C(0,0x8f1ab8cd1ef45000,16254), RTFLOAT64U_INIT_C(0,0x1e35719a3de8a,894) }, /* #48 */
     872    { 0x066a, 0x3e7f, 0x3c00, RTFLOAT80U_INIT_C(0,0x8f1ab8cd1ef45000,16254), RTFLOAT64U_INIT_C(0,0x1e35719a3de8a,894) }, /* #49 */
     873    { 0x0a6a, 0x3e7f, 0x3c00, RTFLOAT80U_INIT_C(0,0x8f1ab8cd1ef45000,16254), RTFLOAT64U_INIT_C(0,0x1e35719a3de8a,894) }, /* #50 */
     874    { 0x0e6a, 0x3e7f, 0x3c00, RTFLOAT80U_INIT_C(0,0x8f1ab8cd1ef45000,16254), RTFLOAT64U_INIT_C(0,0x1e35719a3de8a,894) }, /* #51 */
     875    { 0x016c, 0x8331, 0x3900, RTFLOAT80U_INIT_C(1,0xf854fc21ca5e7000,17311), RTFLOAT64U_INIT_C(1,0xf0a9f84394bce,1951) }, /* #52 */
     876    { 0x056c, 0x8331, 0x3900, RTFLOAT80U_INIT_C(1,0xf854fc21ca5e7000,17311), RTFLOAT64U_INIT_C(1,0xf0a9f84394bce,1951) }, /* #53 */
     877    { 0x096c, 0x8331, 0x3900, RTFLOAT80U_INIT_C(1,0xf854fc21ca5e7000,17311), RTFLOAT64U_INIT_C(1,0xf0a9f84394bce,1951) }, /* #54 */
     878    { 0x0d6c, 0x8331, 0x3900, RTFLOAT80U_INIT_C(1,0xf854fc21ca5e7000,17311), RTFLOAT64U_INIT_C(1,0xf0a9f84394bce,1951) }, /* #55 */
     879    { 0x006b, 0x885d, 0x3800, RTFLOAT80U_INIT_C(0,0xc5f4b505258df000,15769), RTFLOAT64U_INIT_C(0,0x8be96a0a4b1be,409) }, /* #56 */
     880    { 0x046b, 0x885d, 0x3800, RTFLOAT80U_INIT_C(0,0xc5f4b505258df000,15769), RTFLOAT64U_INIT_C(0,0x8be96a0a4b1be,409) }, /* #57 */
     881    { 0x086b, 0x885d, 0x3800, RTFLOAT80U_INIT_C(0,0xc5f4b505258df000,15769), RTFLOAT64U_INIT_C(0,0x8be96a0a4b1be,409) }, /* #58 */
     882    { 0x0c6b, 0x885d, 0x3800, RTFLOAT80U_INIT_C(0,0xc5f4b505258df000,15769), RTFLOAT64U_INIT_C(0,0x8be96a0a4b1be,409) }, /* #59 */
     883    { 0x0134, 0xf15f, 0x7900, RTFLOAT80U_INIT_C(0,0xf410c5b4d3a38000,16026), RTFLOAT64U_INIT_C(0,0xe8218b69a7470,666) }, /* #60 */
     884    { 0x0534, 0xf15f, 0x7900, RTFLOAT80U_INIT_C(0,0xf410c5b4d3a38000,16026), RTFLOAT64U_INIT_C(0,0xe8218b69a7470,666) }, /* #61 */
     885    { 0x0934, 0xf15f, 0x7900, RTFLOAT80U_INIT_C(0,0xf410c5b4d3a38000,16026), RTFLOAT64U_INIT_C(0,0xe8218b69a7470,666) }, /* #62 */
     886    { 0x0d34, 0xf15f, 0x7900, RTFLOAT80U_INIT_C(0,0xf410c5b4d3a38000,16026), RTFLOAT64U_INIT_C(0,0xe8218b69a7470,666) }, /* #63 */
     887    { 0x0137, 0xfae5, 0x7800, RTFLOAT80U_INIT_C(0,0xfe51a6d44fb42800,15437), RTFLOAT64U_INIT_C(0,0xfca34da89f685,77) }, /* #64 */
     888    { 0x0537, 0xfae5, 0x7800, RTFLOAT80U_INIT_C(0,0xfe51a6d44fb42800,15437), RTFLOAT64U_INIT_C(0,0xfca34da89f685,77) }, /* #65 */
     889    { 0x0937, 0xfae5, 0x7800, RTFLOAT80U_INIT_C(0,0xfe51a6d44fb42800,15437), RTFLOAT64U_INIT_C(0,0xfca34da89f685,77) }, /* #66 */
     890    { 0x0d37, 0xfae5, 0x7800, RTFLOAT80U_INIT_C(0,0xfe51a6d44fb42800,15437), RTFLOAT64U_INIT_C(0,0xfca34da89f685,77) }, /* #67 */
     891    { 0x0008, 0xc3bc, 0x7900, RTFLOAT80U_INIT_C(1,0x81cc3e88f5886000,17148), RTFLOAT64U_INIT_C(1,0x3987d11eb10c,1788) }, /* #68 */
     892    { 0x0408, 0xc3bc, 0x7900, RTFLOAT80U_INIT_C(1,0x81cc3e88f5886000,17148), RTFLOAT64U_INIT_C(1,0x3987d11eb10c,1788) }, /* #69 */
     893    { 0x0808, 0xc3bc, 0x7900, RTFLOAT80U_INIT_C(1,0x81cc3e88f5886000,17148), RTFLOAT64U_INIT_C(1,0x3987d11eb10c,1788) }, /* #70 */
     894    { 0x0c08, 0xc3bc, 0x7900, RTFLOAT80U_INIT_C(1,0x81cc3e88f5886000,17148), RTFLOAT64U_INIT_C(1,0x3987d11eb10c,1788) }, /* #71 */
     895    { 0x012c, 0x0abe, 0x3800, RTFLOAT80U_INIT_C(0,0xdf8adcb117c50000,15417), RTFLOAT64U_INIT_C(0,0xbf15b9622f8a0,57) }, /* #72 */
     896    { 0x052c, 0x0abe, 0x3800, RTFLOAT80U_INIT_C(0,0xdf8adcb117c50000,15417), RTFLOAT64U_INIT_C(0,0xbf15b9622f8a0,57) }, /* #73 */
     897    { 0x092c, 0x0abe, 0x3800, RTFLOAT80U_INIT_C(0,0xdf8adcb117c50000,15417), RTFLOAT64U_INIT_C(0,0xbf15b9622f8a0,57) }, /* #74 */
     898    { 0x0d2c, 0x0abe, 0x3800, RTFLOAT80U_INIT_C(0,0xdf8adcb117c50000,15417), RTFLOAT64U_INIT_C(0,0xbf15b9622f8a0,57) }, /* #75 */
     899    { 0x0213, 0x224c, 0x3800, RTFLOAT80U_INIT_C(1,0xc931adac574e1800,16191), RTFLOAT64U_INIT_C(1,0x92635b58ae9c3,831) }, /* #76 */
     900    { 0x0613, 0x224c, 0x3800, RTFLOAT80U_INIT_C(1,0xc931adac574e1800,16191), RTFLOAT64U_INIT_C(1,0x92635b58ae9c3,831) }, /* #77 */
     901    { 0x0a13, 0x224c, 0x3800, RTFLOAT80U_INIT_C(1,0xc931adac574e1800,16191), RTFLOAT64U_INIT_C(1,0x92635b58ae9c3,831) }, /* #78 */
     902    { 0x0e13, 0x224c, 0x3800, RTFLOAT80U_INIT_C(1,0xc931adac574e1800,16191), RTFLOAT64U_INIT_C(1,0x92635b58ae9c3,831) }, /* #79 */
     903    { 0x015e, 0x2098, 0x3800, RTFLOAT80U_INIT_C(1,0x8ecf645a401ff000,17246), RTFLOAT64U_INIT_C(1,0x1d9ec8b4803fe,1886) }, /* #80 */
     904    { 0x055e, 0x2098, 0x3800, RTFLOAT80U_INIT_C(1,0x8ecf645a401ff000,17246), RTFLOAT64U_INIT_C(1,0x1d9ec8b4803fe,1886) }, /* #81 */
     905    { 0x095e, 0x2098, 0x3800, RTFLOAT80U_INIT_C(1,0x8ecf645a401ff000,17246), RTFLOAT64U_INIT_C(1,0x1d9ec8b4803fe,1886) }, /* #82 */
     906    { 0x0d5e, 0x2098, 0x3800, RTFLOAT80U_INIT_C(1,0x8ecf645a401ff000,17246), RTFLOAT64U_INIT_C(1,0x1d9ec8b4803fe,1886) }, /* #83 */
     907    { 0x003d, 0x7cee, 0x7c00, RTFLOAT80U_INIT_C(0,0xda3a12784e1ab800,17341), RTFLOAT64U_INIT_C(0,0xb47424f09c357,1981) }, /* #84 */
     908    { 0x043d, 0x7cee, 0x7c00, RTFLOAT80U_INIT_C(0,0xda3a12784e1ab800,17341), RTFLOAT64U_INIT_C(0,0xb47424f09c357,1981) }, /* #85 */
     909    { 0x083d, 0x7cee, 0x7c00, RTFLOAT80U_INIT_C(0,0xda3a12784e1ab800,17341), RTFLOAT64U_INIT_C(0,0xb47424f09c357,1981) }, /* #86 */
     910    { 0x0c3d, 0x7cee, 0x7c00, RTFLOAT80U_INIT_C(0,0xda3a12784e1ab800,17341), RTFLOAT64U_INIT_C(0,0xb47424f09c357,1981) }, /* #87 */
     911    { 0x0132, 0x9524, 0x3d00, RTFLOAT80U_INIT_C(1,0xc9345b46386ec800,17150), RTFLOAT64U_INIT_C(1,0x9268b68c70dd9,1790) }, /* #88 */
     912    { 0x0532, 0x9524, 0x3d00, RTFLOAT80U_INIT_C(1,0xc9345b46386ec800,17150), RTFLOAT64U_INIT_C(1,0x9268b68c70dd9,1790) }, /* #89 */
     913    { 0x0932, 0x9524, 0x3d00, RTFLOAT80U_INIT_C(1,0xc9345b46386ec800,17150), RTFLOAT64U_INIT_C(1,0x9268b68c70dd9,1790) }, /* #90 */
     914    { 0x0d32, 0x9524, 0x3d00, RTFLOAT80U_INIT_C(1,0xc9345b46386ec800,17150), RTFLOAT64U_INIT_C(1,0x9268b68c70dd9,1790) }, /* #91 */
     915    { 0x034c, 0xd36e, 0x7900, RTFLOAT80U_INIT_C(1,0xe947c3856a0f5800,15516), RTFLOAT64U_INIT_C(1,0xd28f870ad41eb,156) }, /* #92 */
     916    { 0x074c, 0xd36e, 0x7900, RTFLOAT80U_INIT_C(1,0xe947c3856a0f5800,15516), RTFLOAT64U_INIT_C(1,0xd28f870ad41eb,156) }, /* #93 */
     917    { 0x0b4c, 0xd36e, 0x7900, RTFLOAT80U_INIT_C(1,0xe947c3856a0f5800,15516), RTFLOAT64U_INIT_C(1,0xd28f870ad41eb,156) }, /* #94 */
     918    { 0x0f4c, 0xd36e, 0x7900, RTFLOAT80U_INIT_C(1,0xe947c3856a0f5800,15516), RTFLOAT64U_INIT_C(1,0xd28f870ad41eb,156) }, /* #95 */
     919};
     920static const FPU_R32_IN_TEST_T g_aTests_fld_r80_from_r32[] =
     921{
     922    { 0x007f, 0x75b1, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT32U_INIT_C(0,0x0,0) }, /* #0 */
     923    { 0x047f, 0x75b1, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT32U_INIT_C(0,0x0,0) }, /* #1 */
     924    { 0x087f, 0x75b1, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT32U_INIT_C(0,0x0,0) }, /* #2 */
     925    { 0x0c7f, 0x75b1, 0x7d00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT32U_INIT_C(0,0x0,0) }, /* #3 */
     926    { 0x001e, 0x23bd, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT32U_INIT_C(0,0x0,0) }, /* #4 */
     927    { 0x041e, 0x23bd, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT32U_INIT_C(0,0x0,0) }, /* #5 */
     928    { 0x081e, 0x23bd, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT32U_INIT_C(0,0x0,0) }, /* #6 */
     929    { 0x0c1e, 0x23bd, 0x3900, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT32U_INIT_C(0,0x0,0) }, /* #7 */
     930    { 0x037e, 0x5697, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT32U_INIT_C(0,0x0,0) }, /* #8 */
     931    { 0x077e, 0x5697, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT32U_INIT_C(0,0x0,0) }, /* #9 */
     932    { 0x0b7e, 0x5697, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT32U_INIT_C(0,0x0,0) }, /* #10 */
     933    { 0x0f7e, 0x5697, 0x7c00, RTFLOAT80U_INIT_C(0,0x0,0), RTFLOAT32U_INIT_C(0,0x0,0) }, /* #11 */
     934    { 0x0050, 0x670c, 0x7d00, RTFLOAT80U_INIT_C(0,0xb163150000000000,16475), RTFLOAT32U_INIT_C(0,0x316315,219) }, /* #12 */
     935    { 0x0450, 0x670c, 0x7d00, RTFLOAT80U_INIT_C(0,0xb163150000000000,16475), RTFLOAT32U_INIT_C(0,0x316315,219) }, /* #13 */
     936    { 0x0850, 0x670c, 0x7d00, RTFLOAT80U_INIT_C(0,0xb163150000000000,16475), RTFLOAT32U_INIT_C(0,0x316315,219) }, /* #14 */
     937    { 0x0c50, 0x670c, 0x7d00, RTFLOAT80U_INIT_C(0,0xb163150000000000,16475), RTFLOAT32U_INIT_C(0,0x316315,219) }, /* #15 */
     938    { 0x005d, 0xf1df, 0x7900, RTFLOAT80U_INIT_C(1,0x9d9c340000000000,16257), RTFLOAT32U_INIT_C(1,0x1d9c34,1) }, /* #16 */
     939    { 0x045d, 0xf1df, 0x7900, RTFLOAT80U_INIT_C(1,0x9d9c340000000000,16257), RTFLOAT32U_INIT_C(1,0x1d9c34,1) }, /* #17 */
     940    { 0x085d, 0xf1df, 0x7900, RTFLOAT80U_INIT_C(1,0x9d9c340000000000,16257), RTFLOAT32U_INIT_C(1,0x1d9c34,1) }, /* #18 */
     941    { 0x0c5d, 0xf1df, 0x7900, RTFLOAT80U_INIT_C(1,0x9d9c340000000000,16257), RTFLOAT32U_INIT_C(1,0x1d9c34,1) }, /* #19 */
     942    { 0x0364, 0x03a2, 0x3900, RTFLOAT80U_INIT_C(1,0x889e900000000000,16321), RTFLOAT32U_INIT_C(1,0x89e90,65) }, /* #20 */
     943    { 0x0764, 0x03a2, 0x3900, RTFLOAT80U_INIT_C(1,0x889e900000000000,16321), RTFLOAT32U_INIT_C(1,0x89e90,65) }, /* #21 */
     944    { 0x0b64, 0x03a2, 0x3900, RTFLOAT80U_INIT_C(1,0x889e900000000000,16321), RTFLOAT32U_INIT_C(1,0x89e90,65) }, /* #22 */
     945    { 0x0f64, 0x03a2, 0x3900, RTFLOAT80U_INIT_C(1,0x889e900000000000,16321), RTFLOAT32U_INIT_C(1,0x89e90,65) }, /* #23 */
     946    { 0x0103, 0xe3c5, 0x7900, RTFLOAT80U_INIT_C(0,0xf4e9c40000000000,16374), RTFLOAT32U_INIT_C(0,0x74e9c4,118) }, /* #24 */
     947    { 0x0503, 0xe3c5, 0x7900, RTFLOAT80U_INIT_C(0,0xf4e9c40000000000,16374), RTFLOAT32U_INIT_C(0,0x74e9c4,118) }, /* #25 */
     948    { 0x0903, 0xe3c5, 0x7900, RTFLOAT80U_INIT_C(0,0xf4e9c40000000000,16374), RTFLOAT32U_INIT_C(0,0x74e9c4,118) }, /* #26 */
     949    { 0x0d03, 0xe3c5, 0x7900, RTFLOAT80U_INIT_C(0,0xf4e9c40000000000,16374), RTFLOAT32U_INIT_C(0,0x74e9c4,118) }, /* #27 */
     950    { 0x0162, 0xa8bf, 0x3800, RTFLOAT80U_INIT_C(0,0xe90d510000000000,16360), RTFLOAT32U_INIT_C(0,0x690d51,104) }, /* #28 */
     951    { 0x0562, 0xa8bf, 0x3800, RTFLOAT80U_INIT_C(0,0xe90d510000000000,16360), RTFLOAT32U_INIT_C(0,0x690d51,104) }, /* #29 */
     952    { 0x0962, 0xa8bf, 0x3800, RTFLOAT80U_INIT_C(0,0xe90d510000000000,16360), RTFLOAT32U_INIT_C(0,0x690d51,104) }, /* #30 */
     953    { 0x0d62, 0xa8bf, 0x3800, RTFLOAT80U_INIT_C(0,0xe90d510000000000,16360), RTFLOAT32U_INIT_C(0,0x690d51,104) }, /* #31 */
     954    { 0x0001, 0xa7c8, 0x3d00, RTFLOAT80U_INIT_C(1,0x85ed3a0000000000,16453), RTFLOAT32U_INIT_C(1,0x5ed3a,197) }, /* #32 */
     955    { 0x0401, 0xa7c8, 0x3d00, RTFLOAT80U_INIT_C(1,0x85ed3a0000000000,16453), RTFLOAT32U_INIT_C(1,0x5ed3a,197) }, /* #33 */
     956    { 0x0801, 0xa7c8, 0x3d00, RTFLOAT80U_INIT_C(1,0x85ed3a0000000000,16453), RTFLOAT32U_INIT_C(1,0x5ed3a,197) }, /* #34 */
     957    { 0x0c01, 0xa7c8, 0x3d00, RTFLOAT80U_INIT_C(1,0x85ed3a0000000000,16453), RTFLOAT32U_INIT_C(1,0x5ed3a,197) }, /* #35 */
     958    { 0x031d, 0xf1a6, 0x7900, RTFLOAT80U_INIT_C(0,0x815a4f0000000000,16331), RTFLOAT32U_INIT_C(0,0x15a4f,75) }, /* #36 */
     959    { 0x071d, 0xf1a6, 0x7900, RTFLOAT80U_INIT_C(0,0x815a4f0000000000,16331), RTFLOAT32U_INIT_C(0,0x15a4f,75) }, /* #37 */
     960    { 0x0b1d, 0xf1a6, 0x7900, RTFLOAT80U_INIT_C(0,0x815a4f0000000000,16331), RTFLOAT32U_INIT_C(0,0x15a4f,75) }, /* #38 */
     961    { 0x0f1d, 0xf1a6, 0x7900, RTFLOAT80U_INIT_C(0,0x815a4f0000000000,16331), RTFLOAT32U_INIT_C(0,0x15a4f,75) }, /* #39 */
     962    { 0x0311, 0x2371, 0x3900, RTFLOAT80U_INIT_C(0,0x8222cf0000000000,16327), RTFLOAT32U_INIT_C(0,0x222cf,71) }, /* #40 */
     963    { 0x0711, 0x2371, 0x3900, RTFLOAT80U_INIT_C(0,0x8222cf0000000000,16327), RTFLOAT32U_INIT_C(0,0x222cf,71) }, /* #41 */
     964    { 0x0b11, 0x2371, 0x3900, RTFLOAT80U_INIT_C(0,0x8222cf0000000000,16327), RTFLOAT32U_INIT_C(0,0x222cf,71) }, /* #42 */
     965    { 0x0f11, 0x2371, 0x3900, RTFLOAT80U_INIT_C(0,0x8222cf0000000000,16327), RTFLOAT32U_INIT_C(0,0x222cf,71) }, /* #43 */
     966    { 0x014e, 0x041a, 0x3c00, RTFLOAT80U_INIT_C(1,0x9aaaa40000000000,16461), RTFLOAT32U_INIT_C(1,0x1aaaa4,205) }, /* #44 */
     967    { 0x054e, 0x041a, 0x3c00, RTFLOAT80U_INIT_C(1,0x9aaaa40000000000,16461), RTFLOAT32U_INIT_C(1,0x1aaaa4,205) }, /* #45 */
     968    { 0x094e, 0x041a, 0x3c00, RTFLOAT80U_INIT_C(1,0x9aaaa40000000000,16461), RTFLOAT32U_INIT_C(1,0x1aaaa4,205) }, /* #46 */
     969    { 0x0d4e, 0x041a, 0x3c00, RTFLOAT80U_INIT_C(1,0x9aaaa40000000000,16461), RTFLOAT32U_INIT_C(1,0x1aaaa4,205) }, /* #47 */
     970    { 0x0243, 0xdab0, 0x7800, RTFLOAT80U_INIT_C(0,0xc917d40000000000,16375), RTFLOAT32U_INIT_C(0,0x4917d4,119) }, /* #48 */
     971    { 0x0643, 0xdab0, 0x7800, RTFLOAT80U_INIT_C(0,0xc917d40000000000,16375), RTFLOAT32U_INIT_C(0,0x4917d4,119) }, /* #49 */
     972    { 0x0a43, 0xdab0, 0x7800, RTFLOAT80U_INIT_C(0,0xc917d40000000000,16375), RTFLOAT32U_INIT_C(0,0x4917d4,119) }, /* #50 */
     973    { 0x0e43, 0xdab0, 0x7800, RTFLOAT80U_INIT_C(0,0xc917d40000000000,16375), RTFLOAT32U_INIT_C(0,0x4917d4,119) }, /* #51 */
     974    { 0x013a, 0x7d71, 0x7d00, RTFLOAT80U_INIT_C(0,0xf789d50000000000,16468), RTFLOAT32U_INIT_C(0,0x7789d5,212) }, /* #52 */
     975    { 0x053a, 0x7d71, 0x7d00, RTFLOAT80U_INIT_C(0,0xf789d50000000000,16468), RTFLOAT32U_INIT_C(0,0x7789d5,212) }, /* #53 */
     976    { 0x093a, 0x7d71, 0x7d00, RTFLOAT80U_INIT_C(0,0xf789d50000000000,16468), RTFLOAT32U_INIT_C(0,0x7789d5,212) }, /* #54 */
     977    { 0x0d3a, 0x7d71, 0x7d00, RTFLOAT80U_INIT_C(0,0xf789d50000000000,16468), RTFLOAT32U_INIT_C(0,0x7789d5,212) }, /* #55 */
     978    { 0x0201, 0x915f, 0x3900, RTFLOAT80U_INIT_C(0,0xf397790000000000,16294), RTFLOAT32U_INIT_C(0,0x739779,38) }, /* #56 */
     979    { 0x0601, 0x915f, 0x3900, RTFLOAT80U_INIT_C(0,0xf397790000000000,16294), RTFLOAT32U_INIT_C(0,0x739779,38) }, /* #57 */
     980    { 0x0a01, 0x915f, 0x3900, RTFLOAT80U_INIT_C(0,0xf397790000000000,16294), RTFLOAT32U_INIT_C(0,0x739779,38) }, /* #58 */
     981    { 0x0e01, 0x915f, 0x3900, RTFLOAT80U_INIT_C(0,0xf397790000000000,16294), RTFLOAT32U_INIT_C(0,0x739779,38) }, /* #59 */
     982    { 0x0050, 0x3359, 0x3900, RTFLOAT80U_INIT_C(1,0xd83bca0000000000,16415), RTFLOAT32U_INIT_C(1,0x583bca,159) }, /* #60 */
     983    { 0x0450, 0x3359, 0x3900, RTFLOAT80U_INIT_C(1,0xd83bca0000000000,16415), RTFLOAT32U_INIT_C(1,0x583bca,159) }, /* #61 */
     984    { 0x0850, 0x3359, 0x3900, RTFLOAT80U_INIT_C(1,0xd83bca0000000000,16415), RTFLOAT32U_INIT_C(1,0x583bca,159) }, /* #62 */
     985    { 0x0c50, 0x3359, 0x3900, RTFLOAT80U_INIT_C(1,0xd83bca0000000000,16415), RTFLOAT32U_INIT_C(1,0x583bca,159) }, /* #63 */
     986    { 0x013c, 0xe15d, 0x7900, RTFLOAT80U_INIT_C(0,0x9ed6860000000000,16315), RTFLOAT32U_INIT_C(0,0x1ed686,59) }, /* #64 */
     987    { 0x053c, 0xe15d, 0x7900, RTFLOAT80U_INIT_C(0,0x9ed6860000000000,16315), RTFLOAT32U_INIT_C(0,0x1ed686,59) }, /* #65 */
     988    { 0x093c, 0xe15d, 0x7900, RTFLOAT80U_INIT_C(0,0x9ed6860000000000,16315), RTFLOAT32U_INIT_C(0,0x1ed686,59) }, /* #66 */
     989    { 0x0d3c, 0xe15d, 0x7900, RTFLOAT80U_INIT_C(0,0x9ed6860000000000,16315), RTFLOAT32U_INIT_C(0,0x1ed686,59) }, /* #67 */
     990    { 0x0156, 0x3147, 0x3900, RTFLOAT80U_INIT_C(1,0xabaa810000000000,16397), RTFLOAT32U_INIT_C(1,0x2baa81,141) }, /* #68 */
     991    { 0x0556, 0x3147, 0x3900, RTFLOAT80U_INIT_C(1,0xabaa810000000000,16397), RTFLOAT32U_INIT_C(1,0x2baa81,141) }, /* #69 */
     992    { 0x0956, 0x3147, 0x3900, RTFLOAT80U_INIT_C(1,0xabaa810000000000,16397), RTFLOAT32U_INIT_C(1,0x2baa81,141) }, /* #70 */
     993    { 0x0d56, 0x3147, 0x3900, RTFLOAT80U_INIT_C(1,0xabaa810000000000,16397), RTFLOAT32U_INIT_C(1,0x2baa81,141) }, /* #71 */
     994    { 0x006f, 0xaba8, 0x3900, RTFLOAT80U_INIT_C(1,0xe857800000000000,16357), RTFLOAT32U_INIT_C(1,0x685780,101) }, /* #72 */
     995    { 0x046f, 0xaba8, 0x3900, RTFLOAT80U_INIT_C(1,0xe857800000000000,16357), RTFLOAT32U_INIT_C(1,0x685780,101) }, /* #73 */
     996    { 0x086f, 0xaba8, 0x3900, RTFLOAT80U_INIT_C(1,0xe857800000000000,16357), RTFLOAT32U_INIT_C(1,0x685780,101) }, /* #74 */
     997    { 0x0c6f, 0xaba8, 0x3900, RTFLOAT80U_INIT_C(1,0xe857800000000000,16357), RTFLOAT32U_INIT_C(1,0x685780,101) }, /* #75 */
     998    { 0x0123, 0x6f3c, 0x7d00, RTFLOAT80U_INIT_C(1,0xec1e020000000000,16435), RTFLOAT32U_INIT_C(1,0x6c1e02,179) }, /* #76 */
     999    { 0x0523, 0x6f3c, 0x7d00, RTFLOAT80U_INIT_C(1,0xec1e020000000000,16435), RTFLOAT32U_INIT_C(1,0x6c1e02,179) }, /* #77 */
     1000    { 0x0923, 0x6f3c, 0x7d00, RTFLOAT80U_INIT_C(1,0xec1e020000000000,16435), RTFLOAT32U_INIT_C(1,0x6c1e02,179) }, /* #78 */
     1001    { 0x0d23, 0x6f3c, 0x7d00, RTFLOAT80U_INIT_C(1,0xec1e020000000000,16435), RTFLOAT32U_INIT_C(1,0x6c1e02,179) }, /* #79 */
     1002    { 0x0172, 0x17df, 0x3d00, RTFLOAT80U_INIT_C(1,0xc24afb0000000000,16277), RTFLOAT32U_INIT_C(1,0x424afb,21) }, /* #80 */
     1003    { 0x0572, 0x17df, 0x3d00, RTFLOAT80U_INIT_C(1,0xc24afb0000000000,16277), RTFLOAT32U_INIT_C(1,0x424afb,21) }, /* #81 */
     1004    { 0x0972, 0x17df, 0x3d00, RTFLOAT80U_INIT_C(1,0xc24afb0000000000,16277), RTFLOAT32U_INIT_C(1,0x424afb,21) }, /* #82 */
     1005    { 0x0d72, 0x17df, 0x3d00, RTFLOAT80U_INIT_C(1,0xc24afb0000000000,16277), RTFLOAT32U_INIT_C(1,0x424afb,21) }, /* #83 */
     1006    { 0x0301, 0x4d69, 0x7d00, RTFLOAT80U_INIT_C(0,0xc716db0000000000,16304), RTFLOAT32U_INIT_C(0,0x4716db,48) }, /* #84 */
     1007    { 0x0701, 0x4d69, 0x7d00, RTFLOAT80U_INIT_C(0,0xc716db0000000000,16304), RTFLOAT32U_INIT_C(0,0x4716db,48) }, /* #85 */
     1008    { 0x0b01, 0x4d69, 0x7d00, RTFLOAT80U_INIT_C(0,0xc716db0000000000,16304), RTFLOAT32U_INIT_C(0,0x4716db,48) }, /* #86 */
     1009    { 0x0f01, 0x4d69, 0x7d00, RTFLOAT80U_INIT_C(0,0xc716db0000000000,16304), RTFLOAT32U_INIT_C(0,0x4716db,48) }, /* #87 */
     1010    { 0x0279, 0x25d0, 0x3d00, RTFLOAT80U_INIT_C(1,0xfbbba70000000000,16321), RTFLOAT32U_INIT_C(1,0x7bbba7,65) }, /* #88 */
     1011    { 0x0679, 0x25d0, 0x3d00, RTFLOAT80U_INIT_C(1,0xfbbba70000000000,16321), RTFLOAT32U_INIT_C(1,0x7bbba7,65) }, /* #89 */
     1012    { 0x0a79, 0x25d0, 0x3d00, RTFLOAT80U_INIT_C(1,0xfbbba70000000000,16321), RTFLOAT32U_INIT_C(1,0x7bbba7,65) }, /* #90 */
     1013    { 0x0e79, 0x25d0, 0x3d00, RTFLOAT80U_INIT_C(1,0xfbbba70000000000,16321), RTFLOAT32U_INIT_C(1,0x7bbba7,65) }, /* #91 */
     1014    { 0x013f, 0xdfc3, 0x7d00, RTFLOAT80U_INIT_C(1,0xfe04230000000000,16329), RTFLOAT32U_INIT_C(1,0x7e0423,73) }, /* #92 */
     1015    { 0x053f, 0xdfc3, 0x7d00, RTFLOAT80U_INIT_C(1,0xfe04230000000000,16329), RTFLOAT32U_INIT_C(1,0x7e0423,73) }, /* #93 */
     1016    { 0x093f, 0xdfc3, 0x7d00, RTFLOAT80U_INIT_C(1,0xfe04230000000000,16329), RTFLOAT32U_INIT_C(1,0x7e0423,73) }, /* #94 */
     1017    { 0x0d3f, 0xdfc3, 0x7d00, RTFLOAT80U_INIT_C(1,0xfe04230000000000,16329), RTFLOAT32U_INIT_C(1,0x7e0423,73) }, /* #95 */
    7181018};
    7191019
  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-generated-1-template.c

    r93115 r94261  
    54585458                        fOkay = Bs3TestFailedF("ST[%u]: %c m=%#RX64 e=%d, expected %c m=%#RX64 e=%d", i,
    54595459                                               pResult->Ctx.x87.aRegs[i].r80Ex.s.fSign ? '-' : '+',
    5460                                                pResult->Ctx.x87.aRegs[i].r80Ex.s.u64Mantissa,
     5460                                               pResult->Ctx.x87.aRegs[i].r80Ex.s.uMantissa,
    54615461                                               pResult->Ctx.x87.aRegs[i].r80Ex.s.uExponent,
    54625462                                               pExpect->Ctx.x87.aRegs[i].r80Ex.s.fSign ? '-' : '+',
    5463                                                pExpect->Ctx.x87.aRegs[i].r80Ex.s.u64Mantissa,
     5463                                               pExpect->Ctx.x87.aRegs[i].r80Ex.s.uMantissa,
    54645464                                               pExpect->Ctx.x87.aRegs[i].r80Ex.s.uExponent);
    54655465                for (i = 0; i < (ARCH_BITS == 64 ? 16 : 8); i++)
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette