aIsSignalingNaN = float64_is_signaling_nan( a );    bIsNaN = float64_is_nan( b );    bIsSignalingNaN = float64_is_signaling_nan( b );    av = float64_val(a);    bv = float64_val(b);#if SNAN_BIT_IS_ONE    av &= ~LIT64( 0x0008000000000000 );    bv &= ~LIT64( 0x0008000000000000 );#else    av |= LIT64( 0x0008000000000000 );    bv |= LIT64( 0x0008000000000000 );#endif    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);    if ( aIsSignalingNaN ) {        if ( bIsSignalingNaN ) goto returnLargerSignificand;        res = bIsNaN ? bv : av;    }    else if ( aIsNaN ) {        if ( bIsSignalingNaN | ! bIsNaN )            res = av;        else { returnLargerSignificand:            if ( (bits64) ( av<<1 ) < (bits64) ( bv<<1 ) )                res = bv;            else if ( (bits64) ( bv<<1 ) < (bits64) ( av<<1 ) )                res = av;            else                res = ( av < bv ) ? av : bv;        }    }    else {        res = bv;    }    return make_float64(res);}#ifdef FLOATX80/*----------------------------------------------------------------------------| The pattern for a default generated extended double-precision NaN.  The| `high' and `low' values hold the most- and least-significant bits,| respectively.*----------------------------------------------------------------------------*/#if SNAN_BIT_IS_ONE#define floatx80_default_nan_high 0x7FFF#define floatx80_default_nan_low  LIT64( 0xBFFFFFFFFFFFFFFF )#else#define floatx80_default_nan_high 0xFFFF#define floatx80_default_nan_low  LIT64( 0xC000000000000000 )#endif/*----------------------------------------------------------------------------| Returns 1 if the extended double-precision floating-point value `a' is a| quiet NaN; otherwise returns 0.*----------------------------------------------------------------------------*/int floatx80_is_nan( floatx80 a ){#if SNAN_BIT_IS_ONE    bits64 aLow;    aLow = a.low & ~ LIT64( 0x4000000000000000 );    return           ( ( a.high & 0x7FFF ) == 0x7FFF )        && (bits64) ( aLow<<1 )        && ( a.low == aLow );#else    return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );#endif}/*----------------------------------------------------------------------------| Returns 1 if the extended double-precision floating-point value `a' is a| signaling NaN; otherwise returns 0.*----------------------------------------------------------------------------*/int floatx80_is_signaling_nan( floatx80 a ){#if SNAN_BIT_IS_ONE    return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );#else    bits64 aLow;    aLow = a.low & ~ LIT64( 0x4000000000000000 );    return           ( ( a.high & 0x7FFF ) == 0x7FFF )        && (bits64) ( aLow<<1 )        && ( a.low == aLow );#endif}/*----------------------------------------------------------------------------| Returns the result of converting the extended double-precision floating-| point NaN `a' to the canonical NaN format.  If `a' is a signaling NaN, the| invalid exception is raised.*----------------------------------------------------------------------------*/static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM){    commonNaNT z;    if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);    z.sign = a.high>>15;    z.low = 0;    z.high = a.low;    return z;}/*----------------------------------------------------------------------------| Returns the result of converting the canonical NaN `a' to the extended| double-precision floating-point format.*----------------------------------------------------------------------------*/static floatx80 commonNaNToFloatx80( commonNaNT a ){    floatx80 z;    if (a.high)        z.low = a.high;    else        z.low = floatx80_default_nan_low;    z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;    return z;}/*----------------------------------------------------------------------------| Takes two extended double-precision floating-point values `a' and `b', one| of which is a NaN, and returns the appropriate NaN result.  If either `a' or| `b' is a signaling NaN, the invalid exception is raised.*----------------------------------------------------------------------------*/static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b STATUS_PARAM){    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;    aIsNaN = floatx80_is_nan( a );    aIsSignalingNaN = floatx80_is_signaling_nan( a );    bIsNaN = floatx80_is_nan( b );    bIsSignalingNaN = floatx80_is_signaling_nan( b );#if SNAN_BIT_IS_ONE    a.low &= ~LIT64( 0xC000000000000000 );    b.low &= ~LIT64( 0xC000000000000000 );#else    a.low |= LIT64( 0xC000000000000000 );    b.low |= LIT64( 0xC000000000000000 );#endif    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);    if ( aIsSignalingNaN ) {        if ( bIsSignalingNaN ) goto returnLargerSignificand;        return bIsNaN ? b : a;    }    else if ( aIsNaN ) {        if ( bIsSignalingNaN | ! bIsNaN ) return a; returnLargerSignificand:        if ( a.low < b.low ) return b;        if ( b.low < a.low ) return a;        return ( a.high < b.high ) ? a : b;    }    else {        return b;    }}#endif#ifdef FLOAT128/*----------------------------------------------------------------------------| The pattern for a default generated quadruple-precision NaN.  The `high' and| `low' values hold the most- and least-significant bits, respectively.*----------------------------------------------------------------------------*/#if SNAN_BIT_IS_ONE#define float128_default_nan_high LIT64( 0x7FFF7FFFFFFFFFFF )#define float128_default_nan_low  LIT64( 0xFFFFFFFFFFFFFFFF )#else#define float128_default_nan_high LIT64( 0xFFFF800000000000 )#define float128_default_nan_low  LIT64( 0x0000000000000000 )#endif/*----------------------------------------------------------------------------| Returns 1 if the quadruple-precision floating-point value `a' is a quiet| NaN; otherwise returns 0.*----------------------------------------------------------------------------*/int float128_is_nan( float128 a ){#if SNAN_BIT_IS_ONE    return           ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )        && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );#else    return           ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )        && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );#endif}/*----------------------------------------------------------------------------| Returns 1 if the quadruple-precision floating-point value `a' is a| signaling NaN; otherwise returns 0.*----------------------------------------------------------------------------*/int float128_is_signaling_nan( float128 a ){#if SNAN_BIT_IS_ONE    return           ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )        && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );#else    return           ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )        && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );#endif}/*----------------------------------------------------------------------------| Returns the result of converting the quadruple-precision floating-point NaN| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid| exception is raised.*----------------------------------------------------------------------------*/static commonNaNT float128ToCommonNaN( float128 a STATUS_PARAM){    commonNaNT z;    if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);    z.sign = a.high>>63;    shortShift128Left( a.high, a.low, 16, &z.high, &z.low );    return z;}/*----------------------------------------------------------------------------| Returns the result of converting the canonical NaN `a' to the quadruple-| precision floating-point format.*----------------------------------------------------------------------------*/static float128 commonNaNToFloat128( commonNaNT a ){    float128 z;    shift128Right( a.high, a.low, 16, &z.high, &z.low );    z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 );    return z;}/*----------------------------------------------------------------------------| Takes two quadruple-precision floating-point values `a' and `b', one of| which is a NaN, and returns the appropriate NaN result.  If either `a' or| `b' is a signaling NaN, the invalid exception is raised.*----------------------------------------------------------------------------*/static float128 propagateFloat128NaN( float128 a, float128 b STATUS_PARAM){    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;    aIsNaN = float128_is_nan( a );    aIsSignalingNaN = float128_is_signaling_nan( a );    bIsNaN = float128_is_nan( b );    bIsSignalingNaN = float128_is_signaling_nan( b );#if SNAN_BIT_IS_ONE    a.high &= ~LIT64( 0x0000800000000000 );    b.high &= ~LIT64( 0x0000800000000000 );#else    a.high |= LIT64( 0x0000800000000000 );    b.high |= LIT64( 0x0000800000000000 );#endif    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);    if ( aIsSignalingNaN ) {        if ( bIsSignalingNaN ) goto returnLargerSignificand;        return bIsNaN ? b : a;    }    else if ( aIsNaN ) {        if ( bIsSignalingNaN | ! bIsNaN ) return a; returnLargerSignificand:        if ( lt128( a.high<<1, a.low, b.high<<1, b.low ) ) return b;        if ( lt128( b.high<<1, b.low, a.high<<1, a.low ) ) return a;        return ( a.high < b.high ) ? a : b;    }    else {        return b;    }}#endif