[sim] renamed to riscv-isa-run

119 files changed, 0 insertions, 6271 deletions

diff --git a/softfloat/8086/OLD-specialize.c b/softfloat/8086/OLD-specialize.c
deleted file mode 100755
index ffb306d..0000000
--- a/softfloat/8086/OLD-specialize.c
+++ /dev/null
@@ -1,40 +0,0 @@
-

-/*============================================================================

-

-*** FIX.

-

-This C source fragment is part of the SoftFloat IEC/IEEE Floating-point

-Arithmetic Package, Release 2b.

-

-Written by John R. Hauser.  This work was made possible in part by the

-International Computer Science Institute, located at Suite 600, 1947 Center

-Street, Berkeley, California 94704.  Funding was partially provided by the

-National Science Foundation under grant MIP-9311980.  The original version

-of this code was written as part of a project to build a fixed-point vector

-processor in collaboration with the University of California at Berkeley,

-overseen by Profs. Nelson Morgan and John Wawrzynek.  More information

-is available through the Web page `http://www.cs.berkeley.edu/~jhauser/

-arithmetic/SoftFloat.html'.

-

-THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has

-been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES

-RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS

-AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,

-COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE

-EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE

-INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR

-OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.

-

-Derivative works are acceptable, even for commercial purposes, so long as

-(1) the source code for the derivative work includes prominent notice that

-the work is derivative, and (2) the source code includes prominent notice with

-these four paragraphs for those parts of this code that are retained.

-

-=============================================================================*/

-

-/*----------------------------------------------------------------------------

-| Underflow tininess-detection mode, statically initialized to default value.

-| (The declaration in `softfloat.h' must match the `int8' type here.)

-*----------------------------------------------------------------------------*/

-bool float_detectTininess = float_tininess_afterRounding;

-

diff --git a/softfloat/8086/OLD-specialize.h b/softfloat/8086/OLD-specialize.h
deleted file mode 100755
index 9e4461c..0000000
--- a/softfloat/8086/OLD-specialize.h
+++ /dev/null
@@ -1,379 +0,0 @@
-

-/*============================================================================

-

-*** FIX.

-

-This C source fragment is part of the SoftFloat IEC/IEEE Floating-point

-Arithmetic Package, Release 2b.

-

-Written by John R. Hauser.  This work was made possible in part by the

-International Computer Science Institute, located at Suite 600, 1947 Center

-Street, Berkeley, California 94704.  Funding was partially provided by the

-National Science Foundation under grant MIP-9311980.  The original version

-of this code was written as part of a project to build a fixed-point vector

-processor in collaboration with the University of California at Berkeley,

-overseen by Profs. Nelson Morgan and John Wawrzynek.  More information

-is available through the Web page `http://www.cs.berkeley.edu/~jhauser/

-arithmetic/SoftFloat.html'.

-

-THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has

-been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES

-RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS

-AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,

-COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE

-EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE

-INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR

-OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.

-

-Derivative works are acceptable, even for commercial purposes, so long as

-(1) the source code for the derivative work includes prominent notice that

-the work is derivative, and (2) the source code includes prominent notice with

-these four paragraphs for those parts of this code that are retained.

-

-=============================================================================*/

-

-/*----------------------------------------------------------------------------

-| Internal canonical NaN format.

-*----------------------------------------------------------------------------*/

-*** COMMON

-typedef struct {

-    flag sign;

-    uint128_t bits;

-} commonNaNT;

-

-/*----------------------------------------------------------------------------

-| The pattern for a default generated single-precision NaN.

-*----------------------------------------------------------------------------*/

-#define float32Bits_defaultNaN 0xFFC00000

-

-/*----------------------------------------------------------------------------

-| Returns 1 if the single-precision floating-point value `a' is a NaN;

-| otherwise, returns 0.

-*----------------------------------------------------------------------------*/

-*** COMMON

-#define softfloat_isNaNFloat32Bits( a ) ( 0xFF000000 < (uint32_t) ( a )<<1 )

-

-/*----------------------------------------------------------------------------

-| Returns 1 if the single-precision floating-point value `a' is a signaling

-| NaN; otherwise, returns 0.

-*----------------------------------------------------------------------------*/

-inline bool softfloat_isSigNaNFloat32Bits( uint32_t a )

-    { return ( ( a>>22 & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF ); }

-

-/*----------------------------------------------------------------------------

-*----------------------------------------------------------------------------*/

-commonNaNT softfloat_NaNFromFloat32Bits( uint32_t );

-uint32_t softfloat_float32BitsFromNaN( commonNaNT );

-uint32_t softfloat_propNaNFloat32Bits( uint32_t, uint32_t );

-

-/*----------------------------------------------------------------------------

-| The pattern for a default generated double-precision NaN.

-*----------------------------------------------------------------------------*/

-#define float64Bits_defaultNaN 0xFFF8000000000000

-

-/*----------------------------------------------------------------------------

-| Returns 1 if the double-precision floating-point value `a' is a NaN;

-| otherwise, returns 0.

-*----------------------------------------------------------------------------*/

-*** COMMON

-#define softfloat_isNaNFloat64Bits( a ) ( 0xFFE0000000000000 < (uint64_t) ( a )<<1 )

-

-

-

-

-

-

-/*----------------------------------------------------------------------------

-| Returns 1 if the double-precision floating-point value `a' is a signaling

-| NaN; otherwise, returns 0.

-*----------------------------------------------------------------------------*/

-

-flag float64_is_signaling_nan( float64 a )

-{

-

-    return

-           ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )

-        && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );

-

-}

-

-/*----------------------------------------------------------------------------

-| Returns the result of converting the double-precision floating-point NaN

-| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid

-| exception is raised.

-*----------------------------------------------------------------------------*/

-

-static commonNaNT float64ToCommonNaN( float64 a )

-{

-    commonNaNT z;

-

-    if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid );

-    z.sign = a>>63;

-    z.low = 0;

-    z.high = a<<12;

-    return z;

-

-}

-

-/*----------------------------------------------------------------------------

-| Returns the result of converting the canonical NaN `a' to the double-

-| precision floating-point format.

-*----------------------------------------------------------------------------*/

-

-static float64 commonNaNToFloat64( commonNaNT a )

-{

-

-    return

-          ( ( (bits64) a.sign )<<63 )

-        | LIT64( 0x7FF8000000000000 )

-        | ( a.high>>12 );

-

-}

-

-/*----------------------------------------------------------------------------

-| Takes two 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 float64 propagateFloat64NaN( float64 a, float64 b )

-{

-    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;

-

-    aIsNaN = float64_is_nan( a );

-    aIsSignalingNaN = float64_is_signaling_nan( a );

-    bIsNaN = float64_is_nan( b );

-    bIsSignalingNaN = float64_is_signaling_nan( b );

-    a |= LIT64( 0x0008000000000000 );

-    b |= LIT64( 0x0008000000000000 );

-    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );

-    if ( aIsSignalingNaN ) {

-        if ( bIsSignalingNaN ) goto returnLargerSignificand;

-        return bIsNaN ? b : a;

-    }

-    else if ( aIsNaN ) {

-        if ( bIsSignalingNaN | ! bIsNaN ) return a;

- returnLargerSignificand:

-        if ( (bits64) ( a<<1 ) < (bits64) ( b<<1 ) ) return b;

-        if ( (bits64) ( b<<1 ) < (bits64) ( a<<1 ) ) return a;

-        return ( a < b ) ? a : b;

-    }

-    else {

-        return b;

-    }

-

-}

-

-#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.

-*----------------------------------------------------------------------------*/

-#define floatx80_default_nan_high 0xFFFF

-#define floatx80_default_nan_low  LIT64( 0xC000000000000000 )

-

-/*----------------------------------------------------------------------------

-| Returns 1 if the extended double-precision floating-point value `a' is a

-| NaN; otherwise, returns 0.

-*----------------------------------------------------------------------------*/

-

-flag floatx80_is_nan( floatx80 a )

-{

-

-    return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );

-

-}

-

-/*----------------------------------------------------------------------------

-| Returns 1 if the extended double-precision floating-point value `a' is a

-| signaling NaN; otherwise, returns 0.

-*----------------------------------------------------------------------------*/

-

-flag floatx80_is_signaling_nan( floatx80 a )

-{

-    bits64 aLow;

-

-    aLow = a.low & ~ LIT64( 0x4000000000000000 );

-    return

-           ( ( a.high & 0x7FFF ) == 0x7FFF )

-        && (bits64) ( aLow<<1 )

-        && ( a.low == aLow );

-

-}

-

-/*----------------------------------------------------------------------------

-| 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 )

-{

-    commonNaNT z;

-

-    if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid );

-    z.sign = a.high>>15;

-    z.low = 0;

-    z.high = a.low<<1;

-    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;

-

-    z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );

-    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 )

-{

-    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 );

-    a.low |= LIT64( 0xC000000000000000 );

-    b.low |= LIT64( 0xC000000000000000 );

-    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );

-    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.

-*----------------------------------------------------------------------------*/

-#define float128_default_nan_high LIT64( 0xFFFF800000000000 )

-#define float128_default_nan_low  LIT64( 0x0000000000000000 )

-

-/*----------------------------------------------------------------------------

-| Returns 1 if the quadruple-precision floating-point value `a' is a NaN;

-| otherwise, returns 0.

-*----------------------------------------------------------------------------*/

-

-flag float128_is_nan( float128 a )

-{

-

-    return

-           ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )

-        && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );

-

-}

-

-/*----------------------------------------------------------------------------

-| Returns 1 if the quadruple-precision floating-point value `a' is a

-| signaling NaN; otherwise, returns 0.

-*----------------------------------------------------------------------------*/

-

-flag float128_is_signaling_nan( float128 a )

-{

-

-    return

-           ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )

-        && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );

-

-}

-

-/*----------------------------------------------------------------------------

-| 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 )

-{

-    commonNaNT z;

-

-    if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid );

-    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( 0x7FFF800000000000 );

-    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 )

-{

-    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 );

-    a.high |= LIT64( 0x0000800000000000 );

-    b.high |= LIT64( 0x0000800000000000 );

-    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );

-    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

-

diff --git a/softfloat/8086/platform.h b/softfloat/8086/platform.h
deleted file mode 100755
index 9355edf..0000000
--- a/softfloat/8086/platform.h
+++ /dev/null
@@ -1,38 +0,0 @@
-
-/*============================================================================
-
-*** FIX.
-
-This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
-Arithmetic Package, Release 2b.
-
-Written by John R. Hauser.  This work was made possible in part by the
-International Computer Science Institute, located at Suite 600, 1947 Center
-Street, Berkeley, California 94704.  Funding was partially provided by the
-National Science Foundation under grant MIP-9311980.  The original version
-of this code was written as part of a project to build a fixed-point vector
-processor in collaboration with the University of California at Berkeley,
-overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
-is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
-arithmetic/SoftFloat.html'.
-
-THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
-been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
-RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
-AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
-COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
-EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
-INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
-OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
-
-Derivative works are acceptable, even for commercial purposes, so long as
-(1) the source code for the derivative work includes prominent notice that
-the work is derivative, and (2) the source code includes prominent notice with
-these four paragraphs for those parts of this code that are retained.
-
-=============================================================================*/
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-#define LITTLEENDIAN
-
diff --git a/softfloat/8086/s_commonNaNToF32UI.c b/softfloat/8086/s_commonNaNToF32UI.c
deleted file mode 100755
index 3b96c41..0000000
--- a/softfloat/8086/s_commonNaNToF32UI.c
+++ /dev/null
@@ -1,17 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "specialize.h"

-

-/*----------------------------------------------------------------------------

-| Returns the result of converting the canonical NaN `a' to the single-

-| precision floating-point format.

-*----------------------------------------------------------------------------*/

-

-uint_fast32_t softfloat_commonNaNToF32UI( struct commonNaN a )

-{

-

-    return (uint_fast32_t) a.sign<<31 | 0x7FC00000 | a.v64>>41;

-

-}

-

diff --git a/softfloat/8086/s_commonNaNToF64UI.c b/softfloat/8086/s_commonNaNToF64UI.c
deleted file mode 100755
index 474ceee..0000000
--- a/softfloat/8086/s_commonNaNToF64UI.c
+++ /dev/null
@@ -1,19 +0,0 @@
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Returns the result of converting the canonical NaN `a' to the double-
-| precision floating-point format.
-*----------------------------------------------------------------------------*/
-
-uint_fast64_t softfloat_commonNaNToF64UI( struct commonNaN a )
-{
-
-    return
-        (uint_fast64_t) a.sign<<63 | UINT64_C( 0x7FF8000000000000 )
-            | a.v64>>12;
-
-}
-
diff --git a/softfloat/8086/s_f32UIToCommonNaN.c b/softfloat/8086/s_f32UIToCommonNaN.c
deleted file mode 100755
index 067e8da..0000000
--- a/softfloat/8086/s_f32UIToCommonNaN.c
+++ /dev/null
@@ -1,25 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "specialize.h"

-#include "softfloat.h"

-

-/*----------------------------------------------------------------------------

-| Returns the result of converting the single-precision floating-point NaN

-| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid

-| exception is raised.

-*----------------------------------------------------------------------------*/

-struct commonNaN softfloat_f32UIToCommonNaN( uint_fast32_t uiA )

-{

-    struct commonNaN z;

-

-    if ( softfloat_isSigNaNF32UI( uiA ) ) {

-        softfloat_raiseFlags( softfloat_flag_invalid );

-    }

-    z.sign = uiA>>31;

-    z.v64 = (uint_fast64_t) uiA<<41;

-    z.v0 = 0;

-    return z;

-

-}

-

diff --git a/softfloat/8086/s_f64UIToCommonNaN.c b/softfloat/8086/s_f64UIToCommonNaN.c
deleted file mode 100755
index f933ded..0000000
--- a/softfloat/8086/s_f64UIToCommonNaN.c
+++ /dev/null
@@ -1,25 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "specialize.h"

-#include "softfloat.h"

-

-/*----------------------------------------------------------------------------

-| Returns the result of converting the double-precision floating-point NaN

-| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid

-| exception is raised.

-*----------------------------------------------------------------------------*/

-struct commonNaN softfloat_f64UIToCommonNaN( uint_fast64_t uiA )

-{

-    struct commonNaN z;

-

-    if ( softfloat_isSigNaNF64UI( uiA ) ) {

-        softfloat_raiseFlags( softfloat_flag_invalid );

-    }

-    z.sign = uiA>>63;

-    z.v64 = uiA<<12;

-    z.v0 = 0;

-    return z;

-

-}

-

diff --git a/softfloat/8086/s_isSigNaNF32UI.c b/softfloat/8086/s_isSigNaNF32UI.c
deleted file mode 100755
index 0a9c33f..0000000
--- a/softfloat/8086/s_isSigNaNF32UI.c
+++ /dev/null
@@ -1,13 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-bool softfloat_isSigNaNF32UI( uint_fast32_t ui )
-{
-
-    return ( ( ui>>22 & 0x1FF ) == 0x1FE ) && ( ui & 0x003FFFFF );
-
-}
-
diff --git a/softfloat/8086/s_isSigNaNF64UI.c b/softfloat/8086/s_isSigNaNF64UI.c
deleted file mode 100755
index d255213..0000000
--- a/softfloat/8086/s_isSigNaNF64UI.c
+++ /dev/null
@@ -1,15 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-bool softfloat_isSigNaNF64UI( uint_fast64_t ui )
-{
-
-    return
-        ( ( ui>>51 & 0xFFF ) == 0xFFE )
-            && ( ui & UINT64_C( 0x0007FFFFFFFFFFFF ) );
-
-}
-
diff --git a/softfloat/8086/s_propagateNaNF32UI.c b/softfloat/8086/s_propagateNaNF32UI.c
deleted file mode 100755
index 07774e8..0000000
--- a/softfloat/8086/s_propagateNaNF32UI.c
+++ /dev/null
@@ -1,55 +0,0 @@
-

-/*** UPDATE COMMENTS. ***/

-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "specialize.h"

-#include "softfloat.h"

-

-/*----------------------------------------------------------------------------

-| Takes two single-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.

-*----------------------------------------------------------------------------*/

-

-uint_fast32_t

- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )

-{

-    bool isNaNA, isSigNaNA, isNaNB, isSigNaNB;

-    uint_fast32_t uiMagA, uiMagB;

-

-    /*------------------------------------------------------------------------

-    *------------------------------------------------------------------------*/

-    isNaNA = isNaNF32UI( uiA );

-    isSigNaNA = softfloat_isSigNaNF32UI( uiA );

-    isNaNB = isNaNF32UI( uiB );

-    isSigNaNB = softfloat_isSigNaNF32UI( uiB );

-    /*------------------------------------------------------------------------

-    | Make NaNs non-signaling.

-    *------------------------------------------------------------------------*/

-    uiA |= 0x00400000;

-    uiB |= 0x00400000;

-    /*------------------------------------------------------------------------

-    *------------------------------------------------------------------------*/

-    if ( isSigNaNA | isSigNaNB ) {

-        softfloat_raiseFlags( softfloat_flag_invalid );

-    }

-    if ( isSigNaNA ) {

-        if ( isSigNaNB ) goto returnLargerSignificand;

-        return isNaNB ? uiB : uiA;

-    } else if ( isNaNA ) {

-        if ( isSigNaNB || ! isNaNB ) return uiA;

- returnLargerSignificand:

-        uiMagA = uiA<<1;

-        uiMagB = uiB<<1;

-        if ( uiMagA < uiMagB ) return uiB;

-        if ( uiMagB < uiMagA ) return uiA;

-        return ( uiA < uiB ) ? uiA : uiB;

-    } else {

-        return uiB;

-    }

-

-}

-

diff --git a/softfloat/8086/s_propagateNaNF64UI.c b/softfloat/8086/s_propagateNaNF64UI.c
deleted file mode 100755
index 0ff6446..0000000
--- a/softfloat/8086/s_propagateNaNF64UI.c
+++ /dev/null
@@ -1,55 +0,0 @@
-
-/*** UPDATE COMMENTS. ***/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Takes two 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.
-*----------------------------------------------------------------------------*/
-
-uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
-{
-    bool isNaNA, isSigNaNA, isNaNB, isSigNaNB;
-    uint_fast64_t uiMagA, uiMagB;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    isNaNA = isNaNF64UI( uiA );
-    isSigNaNA = softfloat_isSigNaNF64UI( uiA );
-    isNaNB = isNaNF64UI( uiB );
-    isSigNaNB = softfloat_isSigNaNF64UI( uiB );
-    /*------------------------------------------------------------------------
-    | Make NaNs non-signaling.
-    *------------------------------------------------------------------------*/
-    uiA |= UINT64_C( 0x0008000000000000 );
-    uiB |= UINT64_C( 0x0008000000000000 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    if ( isSigNaNA ) {
-        if ( isSigNaNB ) goto returnLargerSignificand;
-        return isNaNB ? uiB : uiA;
-    } else if ( isNaNA ) {
-        if ( isSigNaNB || ! isNaNB ) return uiA;
- returnLargerSignificand:
-        uiMagA = uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF );
-        uiMagB = uiB & UINT64_C( 0x7FFFFFFFFFFFFFFF );
-        if ( uiMagA < uiMagB ) return uiB;
-        if ( uiMagB < uiMagA ) return uiA;
-        return ( uiA < uiB ) ? uiA : uiB;
-    } else {
-        return uiB;
-    }
-
-}
-
diff --git a/softfloat/8086/softfloat_raiseFlags.c b/softfloat/8086/softfloat_raiseFlags.c
deleted file mode 100755
index c0c0dc8..0000000
--- a/softfloat/8086/softfloat_raiseFlags.c
+++ /dev/null
@@ -1,51 +0,0 @@
-
-/*============================================================================
-
-*** FIX.
-
-This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
-Arithmetic Package, Release 2b.
-
-Written by John R. Hauser.  This work was made possible in part by the
-International Computer Science Institute, located at Suite 600, 1947 Center
-Street, Berkeley, California 94704.  Funding was partially provided by the
-National Science Foundation under grant MIP-9311980.  The original version
-of this code was written as part of a project to build a fixed-point vector
-processor in collaboration with the University of California at Berkeley,
-overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
-is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
-arithmetic/SoftFloat.html'.
-
-THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
-been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
-RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
-AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
-COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
-EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
-INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
-OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
-
-Derivative works are acceptable, even for commercial purposes, so long as
-(1) the source code for the derivative work includes prominent notice that
-the work is derivative, and (2) the source code includes prominent notice with
-these four paragraphs for those parts of this code that are retained.
-
-=============================================================================*/
-
-#include "platform.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Raises the exceptions specified by `flags'.  Floating-point traps can be
-| defined here if desired.  It is currently not possible for such a trap
-| to substitute a result value.  If traps are not implemented, this routine
-| should be simply `float_exception_flags |= flags;'.
-*----------------------------------------------------------------------------*/
-
-void softfloat_raiseFlags( int_fast8_t flags )
-{
-
-    softfloat_exceptionFlags |= flags;
-
-}
-
diff --git a/softfloat/8086/softfloat_types.h b/softfloat/8086/softfloat_types.h
deleted file mode 100755
index b5c1828..0000000
--- a/softfloat/8086/softfloat_types.h
+++ /dev/null
@@ -1,16 +0,0 @@
-
-#ifndef softfloat_types_h
-#define softfloat_types_h
-
-/*** COMMENTS. ***/
-
-#include <stdbool.h>
-#include <stdint.h>
-
-typedef struct { uint32_t v; } float32_t;
-typedef struct { uint64_t v; } float64_t;
-typedef struct { uint64_t v; uint16_t x; } floatx80_t;
-typedef struct { uint64_t v[ 2 ]; } float128_t;
-
-#endif
-
diff --git a/softfloat/8086/specialize.h b/softfloat/8086/specialize.h
deleted file mode 100755
index ca0bb1d..0000000
--- a/softfloat/8086/specialize.h
+++ /dev/null
@@ -1,113 +0,0 @@
-

-/*============================================================================

-

-*** FIX.

-

-This C source fragment is part of the SoftFloat IEC/IEEE Floating-point

-Arithmetic Package, Release 2b.

-

-Written by John R. Hauser.  This work was made possible in part by the

-International Computer Science Institute, located at Suite 600, 1947 Center

-Street, Berkeley, California 94704.  Funding was partially provided by the

-National Science Foundation under grant MIP-9311980.  The original version

-of this code was written as part of a project to build a fixed-point vector

-processor in collaboration with the University of California at Berkeley,

-overseen by Profs. Nelson Morgan and John Wawrzynek.  More information

-is available through the Web page `http://www.cs.berkeley.edu/~jhauser/

-arithmetic/SoftFloat.html'.

-

-THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has

-been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES

-RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS

-AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,

-COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE

-EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE

-INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR

-OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.

-

-Derivative works are acceptable, even for commercial purposes, so long as

-(1) the source code for the derivative work includes prominent notice that

-the work is derivative, and (2) the source code includes prominent notice with

-these four paragraphs for those parts of this code that are retained.

-

-=============================================================================*/

-

-#include <stdbool.h>

-#include <stdint.h>

-

-/*----------------------------------------------------------------------------

-*----------------------------------------------------------------------------*/

-#define init_detectTininess softfloat_tininess_afterRounding;

-

-/*----------------------------------------------------------------------------

-| Structure used to transfer NaN representations from one format to another.

-*----------------------------------------------------------------------------*/

-struct commonNaN {

-    bool sign;

-    uint64_t v64, v0;

-};

-

-/*----------------------------------------------------------------------------

-| The pattern for a default generated single-precision NaN.

-*----------------------------------------------------------------------------*/

-#define defaultNaNF32UI 0xFFC00000

-

-/*----------------------------------------------------------------------------

-| Returns 1 if the single-precision floating-point value `a' is a signaling

-| NaN; otherwise, returns 0.

-*----------------------------------------------------------------------------*/

-#if defined INLINE_LEVEL && ( 1 <= INLINE_LEVEL )

-INLINE bool softfloat_isSigNaNF32UI( uint_fast32_t ui )

-    { return ( ( ui>>22 & 0x1FF ) == 0x1FE ) && ( ui & 0x003FFFFF ); }

-#else

-bool softfloat_isSigNaNF32UI( uint_fast32_t );

-#endif

-

-/*----------------------------------------------------------------------------

-*----------------------------------------------------------------------------*/

-struct commonNaN softfloat_f32UIToCommonNaN( uint_fast32_t );

-#if defined INLINE_LEVEL && ( 1 <= INLINE_LEVEL )

-INLINE uint_fast32_t softfloat_commonNaNToF32UI( struct commonNaN a )

-    { return (uint_fast32_t) a.sign<<31 | 0x7FC00000 | a.v64>>41; }

-#else

-uint_fast32_t softfloat_commonNaNToF32UI( struct commonNaN );

-#endif

-

-/*----------------------------------------------------------------------------

-| Takes two single-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.

-*----------------------------------------------------------------------------*/

-uint_fast32_t softfloat_propagateNaNF32UI( uint_fast32_t, uint_fast32_t );

-

-/*----------------------------------------------------------------------------

-| The pattern for a default generated double-precision NaN.

-*----------------------------------------------------------------------------*/

-#define defaultNaNF64UI UINT64_C(0xFFF8000000000000)

-

-/*----------------------------------------------------------------------------

-*----------------------------------------------------------------------------*/

-#if defined INLINE_LEVEL && ( 1 <= INLINE_LEVEL )

-INLINE bool softfloat_isSigNaNF64UI( uint_fast64_t ui )

-{

-    return

-        ( ( ui>>51 & 0xFFF ) == 0xFFE )

-            && ( ui & UINT64_C( 0x0007FFFFFFFFFFFF ) );

-}

-#else

-bool softfloat_isSigNaNF64UI( uint_fast64_t );

-#endif

-

-/*----------------------------------------------------------------------------

-*----------------------------------------------------------------------------*/

-/*** MIGHT BE INLINE'D. ***/

-struct commonNaN softfloat_f64UIToCommonNaN( uint_fast64_t );

-uint_fast64_t softfloat_commonNaNToF64UI( struct commonNaN );

-

-/*----------------------------------------------------------------------------

-| Takes two 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.

-*----------------------------------------------------------------------------*/

-uint_fast64_t softfloat_propagateNaNF64UI( uint_fast64_t, uint_fast64_t );

-

diff --git a/softfloat/f32_add.c b/softfloat/f32_add.c
deleted file mode 100755
index dc53d68..0000000
--- a/softfloat/f32_add.c
+++ /dev/null
@@ -1,29 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float32_t f32_add( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool signA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signB;
-    float32_t ( *magsRoutine )( uint_fast32_t, uint_fast32_t, bool );
-
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF32UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF32UI( uiB );
-    magsRoutine =
-        ( signA == signB ) ? softfloat_addMagsF32 : softfloat_subMagsF32;
-    return magsRoutine( uiA, uiB, signA );
-
-}
-
diff --git a/softfloat/f32_div.c b/softfloat/f32_div.c
deleted file mode 100755
index 958b140..0000000
--- a/softfloat/f32_div.c
+++ /dev/null
@@ -1,96 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t f32_div( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool signA;
-    int_fast16_t expA;
-    uint_fast32_t sigA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signB;
-    int_fast16_t expB;
-    uint_fast32_t sigB;
-    bool signZ;
-    struct exp16_sig32 normExpSig;
-    int_fast16_t expZ;
-    uint_fast32_t sigZ;
-    uint_fast32_t uiZ;
-    union ui32_f32 uZ;
-
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF32UI( uiA );
-    expA = expF32UI( uiA );
-    sigA = fracF32UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF32UI( uiB );
-    expB = expF32UI( uiB );
-    sigB = fracF32UI( uiB );
-    signZ = signA ^ signB;
-    if ( expA == 0xFF ) {
-        if ( sigA ) goto propagateNaN;
-        if ( expB == 0xFF ) {
-            if ( sigB ) goto propagateNaN;
-            goto invalid;
-        }
-        goto infinity;
-    }
-    if ( expB == 0xFF ) {
-        if ( sigB ) goto propagateNaN;
-        goto zero;
-    }
-    if ( ! expB ) {
-        if ( ! sigB ) {
-            if ( ! ( expA | sigA ) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinity );
-            goto infinity;
-        }
-        normExpSig = softfloat_normSubnormalF32Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) {
-        if ( ! sigA ) goto zero;
-        normExpSig = softfloat_normSubnormalF32Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    expZ = expA - expB + 0x7D;
-    sigA = ( sigA | 0x00800000 )<<7;
-    sigB = ( sigB | 0x00800000 )<<8;
-    if ( sigB <= ( sigA + sigA ) ) {
-        ++expZ;
-        sigA >>= 1;
-    }
-    sigZ = ( (uint_fast64_t) sigA<<32 ) / sigB;
-    if ( ! ( sigZ & 0x3F ) ) {
-        sigZ |= ( (uint_fast64_t) sigB * sigZ != (uint_fast64_t) sigA<<32 );
-    }
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
- propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
-    goto uiZ;
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF32UI;
-    goto uiZ;
- infinity:
-    uiZ = packToF32UI( signZ, 0xFF, 0 );
-    goto uiZ;
- zero:
-    uiZ = packToF32UI( signZ, 0, 0 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
diff --git a/softfloat/f32_eq.c b/softfloat/f32_eq.c
deleted file mode 100755
index 8f2306b..0000000
--- a/softfloat/f32_eq.c
+++ /dev/null
@@ -1,34 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f32_eq( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if (
-           ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) )
-        || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) )
-    ) {
-        if (
-            softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    return ( uiA == uiB ) || ! (uint32_t) ( ( uiA | uiB )<<1 );
-
-}
-
diff --git a/softfloat/f32_eq_signaling.c b/softfloat/f32_eq_signaling.c
deleted file mode 100755
index bfba48a..0000000
--- a/softfloat/f32_eq_signaling.c
+++ /dev/null
@@ -1,29 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f32_eq_signaling( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if (
-           ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) )
-        || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) )
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    return ( uiA == uiB ) || ! (uint32_t) ( ( uiA | uiB )<<1 );
-
-}
-
diff --git a/softfloat/f32_isSignalingNaN.c b/softfloat/f32_isSignalingNaN.c
deleted file mode 100755
index 09aaa82..0000000
--- a/softfloat/f32_isSignalingNaN.c
+++ /dev/null
@@ -1,16 +0,0 @@
-
-#include <stdbool.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f32_isSignalingNaN( float32_t a )
-{
-    union ui32_f32 uA;
-
-    uA.f = a;
-    return softfloat_isSigNaNF32UI( uA.ui );
-
-}
-
diff --git a/softfloat/f32_le.c b/softfloat/f32_le.c
deleted file mode 100755
index 5f47be5..0000000
--- a/softfloat/f32_le.c
+++ /dev/null
@@ -1,34 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f32_le( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if (
-           ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) )
-        || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) )
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signF32UI( uiA );
-    signB = signF32UI( uiB );
-    return
-        ( signA != signB ) ? signA || ! (uint32_t) ( ( uiA | uiB )<<1 )
-            : ( uiA == uiB ) || ( signA ^ ( uiA < uiB ) );
-
-}
-
diff --git a/softfloat/f32_le_quiet.c b/softfloat/f32_le_quiet.c
deleted file mode 100755
index 2b541da..0000000
--- a/softfloat/f32_le_quiet.c
+++ /dev/null
@@ -1,39 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f32_le_quiet( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if (
-           ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) )
-        || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) )
-    ) {
-        if (
-            softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signF32UI( uiA );
-    signB = signF32UI( uiB );
-    return
-        ( signA != signB ) ? signA || ! (uint32_t) ( ( uiA | uiB )<<1 )
-            : ( uiA == uiB ) || ( signA ^ ( uiA < uiB ) );
-
-}
-
diff --git a/softfloat/f32_lt.c b/softfloat/f32_lt.c
deleted file mode 100755
index 753b28a..0000000
--- a/softfloat/f32_lt.c
+++ /dev/null
@@ -1,34 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f32_lt( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if (
-           ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) )
-        || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) )
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signF32UI( uiA );
-    signB = signF32UI( uiB );
-    return
-        ( signA != signB ) ? signA && ( (uint32_t) ( ( uiA | uiB )<<1 ) != 0 )
-            : ( uiA != uiB ) && ( signA ^ ( uiA < uiB ) );
-
-}
-
diff --git a/softfloat/f32_lt_quiet.c b/softfloat/f32_lt_quiet.c
deleted file mode 100755
index ecd90bf..0000000
--- a/softfloat/f32_lt_quiet.c
+++ /dev/null
@@ -1,39 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f32_lt_quiet( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if (
-           ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) )
-        || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) )
-    ) {
-        if (
-            softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signF32UI( uiA );
-    signB = signF32UI( uiB );
-    return
-        ( signA != signB ) ? signA && ( (uint32_t) ( ( uiA | uiB )<<1 ) != 0 )
-            : ( uiA != uiB ) && ( signA ^ ( uiA < uiB ) );
-
-}
-
diff --git a/softfloat/f32_mul.c b/softfloat/f32_mul.c
deleted file mode 100755
index d49c1dd..0000000
--- a/softfloat/f32_mul.c
+++ /dev/null
@@ -1,89 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "specialize.h"

-#include "softfloat.h"

-

-float32_t f32_mul( float32_t a, float32_t b )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    bool signA;

-    int_fast16_t expA;

-    uint_fast32_t sigA;

-    union ui32_f32 uB;

-    uint_fast32_t uiB;

-    bool signB;

-    int_fast16_t expB;

-    uint_fast32_t sigB;

-    bool signZ;

-    uint_fast32_t magBits;

-    struct exp16_sig32 normExpSig;

-    int_fast16_t expZ;

-    uint_fast32_t sigZ, uiZ;

-    union ui32_f32 uZ;

-

-    uA.f = a;

-    uiA = uA.ui;

-    signA = signF32UI( uiA );

-    expA = expF32UI( uiA );

-    sigA = fracF32UI( uiA );

-    uB.f = b;

-    uiB = uB.ui;

-    signB = signF32UI( uiB );

-    expB = expF32UI( uiB );

-    sigB = fracF32UI( uiB );

-    signZ = signA ^ signB;

-    if ( expA == 0xFF ) {

-        if ( sigA || ( ( expB == 0xFF ) && sigB ) ) goto propagateNaN;

-        magBits = expB | sigB;

-        goto infArg;

-    }

-    if ( expB == 0xFF ) {

-        if ( sigB ) goto propagateNaN;

-        magBits = expA | sigA;

-        goto infArg;

-    }

-    if ( ! expA ) {

-        if ( ! sigA ) goto zero;

-        normExpSig = softfloat_normSubnormalF32Sig( sigA );

-        expA = normExpSig.exp;

-        sigA = normExpSig.sig;

-    }

-    if ( ! expB ) {

-        if ( ! sigB ) goto zero;

-        normExpSig = softfloat_normSubnormalF32Sig( sigB );

-        expB = normExpSig.exp;

-        sigB = normExpSig.sig;

-    }

-    expZ = expA + expB - 0x7F;

-    sigA = ( sigA | 0x00800000 )<<7;

-    sigB = ( sigB | 0x00800000 )<<8;

-    sigZ = softfloat_shortShift64RightJam( (uint_fast64_t) sigA * sigB, 32 );

-    if ( sigZ < 0x40000000 ) {

-        --expZ;

-        sigZ <<= 1;

-    }

-    return softfloat_roundPackToF32( signZ, expZ, sigZ );

- propagateNaN:

-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );

-    goto uiZ;

- infArg:

-    if ( ! magBits ) {

-        softfloat_raiseFlags( softfloat_flag_invalid );

-        uiZ = defaultNaNF32UI;

-    } else {

-        uiZ = packToF32UI( signZ, 0xFF, 0 );

-    }

-    goto uiZ;

- zero:

-    uiZ = packToF32UI( signZ, 0, 0 );

- uiZ:

-    uZ.ui = uiZ;

-    return uZ.f;

-

-}

-

diff --git a/softfloat/f32_mulAdd.c b/softfloat/f32_mulAdd.c
deleted file mode 100755
index 3d4cee9..0000000
--- a/softfloat/f32_mulAdd.c
+++ /dev/null
@@ -1,25 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    union ui32_f32 uB;

-    uint_fast32_t uiB;

-    union ui32_f32 uC;

-    uint_fast32_t uiC;

-

-    uA.f = a;

-    uiA = uA.ui;

-    uB.f = b;

-    uiB = uB.ui;

-    uC.f = c;

-    uiC = uC.ui;

-    return softfloat_mulAddF32( 0, uiA, uiB, uiC );

-

-}

-

diff --git a/softfloat/f32_rem.c b/softfloat/f32_rem.c
deleted file mode 100755
index d29b840..0000000
--- a/softfloat/f32_rem.c
+++ /dev/null
@@ -1,124 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t f32_rem( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool signA;
-    int_fast16_t expA;
-    uint_fast32_t sigA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signB;
-    int_fast16_t expB;
-    uint_fast32_t sigB;
-    struct exp16_sig32 normExpSig;
-    int_fast16_t expDiff;
-    uint_fast32_t q;
-    uint_fast64_t sigA64, sigB64, q64;
-    uint_fast32_t alternateSigA;
-    uint32_t sigMean;
-    bool signZ;
-    uint_fast32_t uiZ;
-    union ui32_f32 uZ;
-
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF32UI( uiA );
-    expA = expF32UI( uiA );
-    sigA = fracF32UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF32UI( uiB );
-    expB = expF32UI( uiB );
-    sigB = fracF32UI( uiB );
-    if ( expA == 0xFF ) {
-        if ( sigA || ( ( expB == 0xFF ) && sigB ) ) goto propagateNaN;
-        goto invalid;
-    }
-    if ( expB == 0xFF ) {
-        if ( sigB ) goto propagateNaN;
-        return a;
-    }
-    if ( ! expB ) {
-        if ( ! sigB ) goto invalid;
-        normExpSig = softfloat_normSubnormalF32Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) {
-        if ( ! sigA ) return a;
-        normExpSig = softfloat_normSubnormalF32Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    expDiff = expA - expB;
-    sigA |= 0x00800000;
-    sigB |= 0x00800000;
-    if ( expDiff < 32 ) {
-        sigA <<= 8;
-        sigB <<= 8;
-        if ( expDiff < 0 ) {
-            if ( expDiff < -1 ) return a;
-            sigA >>= 1;
-        }
-        q = ( sigB <= sigA );
-        if ( q ) sigA -= sigB;
-        if ( 0 < expDiff ) {
-            q = ( (uint_fast64_t) sigA<<32 ) / sigB;
-            q >>= 32 - expDiff;
-            sigB >>= 2;
-            sigA = ( ( sigA>>1 )<<( expDiff - 1 ) ) - sigB * q;
-        } else {
-            sigA >>= 2;
-            sigB >>= 2;
-        }
-    } else {
-        if ( sigB <= sigA ) sigA -= sigB;
-        sigA64 = (uint_fast64_t) sigA<<40;
-        sigB64 = (uint_fast64_t) sigB<<40;
-        expDiff -= 64;
-        while ( 0 < expDiff ) {
-            q64 = softfloat_estimateDiv128To64( sigA64, 0, sigB64 );
-            q64 = ( 2 < q64 ) ? q64 - 2 : 0;
-            sigA64 = - ( ( sigB * q64 )<<38 );
-            expDiff -= 62;
-        }
-        expDiff += 64;
-        q64 = softfloat_estimateDiv128To64( sigA64, 0, sigB64 );
-        q64 = ( 2 < q64 ) ? q64 - 2 : 0;
-        q = q64>>( 64 - expDiff );
-        sigB <<= 6;
-        sigA = ( ( sigA64>>33 )<<( expDiff - 1 ) ) - sigB * q;
-    }
-    do {
-        alternateSigA = sigA;
-        ++q;
-        sigA -= sigB;
-    } while ( sigA < 0x80000000 );
-    sigMean = sigA + alternateSigA;
-    if ( ( 0x80000000 <= sigMean ) || ( ! sigMean && ( q & 1 ) ) ) {
-        sigA = alternateSigA;
-    }
-    signZ = ( 0x80000000 <= sigA );
-    if ( signZ ) sigA = - sigA;
-    return softfloat_normRoundPackToF32( signA ^ signZ, expB, sigA );
- propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
-    goto uiZ;
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF32UI;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
diff --git a/softfloat/f32_roundToInt.c b/softfloat/f32_roundToInt.c
deleted file mode 100755
index f8f9114..0000000
--- a/softfloat/f32_roundToInt.c
+++ /dev/null
@@ -1,78 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t f32_roundToInt( float32_t a, int_fast8_t roundingMode, bool exact )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    int_fast16_t expA;
-    uint_fast32_t uiZ;
-    bool signA;
-    uint_fast32_t lastBitMask, roundBitsMask;
-    union ui32_f32 uZ;
-
-    uA.f = a;
-    uiA = uA.ui;
-    expA = expF32UI( uiA );
-    if ( 0x96 <= expA ) {
-        if ( ( expA == 0xFF ) && fracF32UI( uiA ) ) {
-            uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
-            goto uiZ;
-        }
-        return a;
-    }
-    if ( expA <= 0x7E ) {
-        if ( ! (uint32_t) ( uiA<<1 ) ) return a;
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-        signA = signF32UI( uiA );
-        switch ( roundingMode ) {
-         case softfloat_round_nearest_even:
-            if ( ( expA == 0x7E ) && fracF32UI( uiA ) ) {
-                uiZ = packToF32UI( signA, 0x7F, 0 );
-                goto uiZ;
-            }
-            break;
-         case softfloat_round_min:
-            uiZ = signA ? 0xBF800000 : 0;
-            goto uiZ;
-         case softfloat_round_max:
-            uiZ = signA ? 0x80000000 : 0x3F800000;
-            goto uiZ;
-         case softfloat_round_nearest_maxMag:
-            if ( expA == 0x7E ) {
-                uiZ = packToF32UI( signA, 0x7F, 0 );
-                goto uiZ;
-            }
-            break;
-        }
-        uiZ = packToF32UI( signA, 0, 0 );
-        goto uiZ;
-    }
-    lastBitMask = (uint_fast32_t) 1<<( 0x96 - expA );
-    roundBitsMask = lastBitMask - 1;
-    uiZ = uiA;
-    if ( roundingMode == softfloat_round_nearest_maxMag ) {
-        uiZ += lastBitMask>>1;
-    } else if ( roundingMode == softfloat_round_nearest_even ) {
-        uiZ += lastBitMask>>1;
-        if ( ! ( uiZ & roundBitsMask ) ) uiZ &= ~ lastBitMask;
-    } else if ( roundingMode != softfloat_round_minMag ) {
-        if ( signF32UI( uiZ ) ^ ( roundingMode == softfloat_round_max ) ) {
-            uiZ += roundBitsMask;
-        }
-    }
-    uiZ &= ~ roundBitsMask;
-    if ( exact && ( uiZ != uiA ) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
diff --git a/softfloat/f32_sqrt.c b/softfloat/f32_sqrt.c
deleted file mode 100755
index c9eb907..0000000
--- a/softfloat/f32_sqrt.c
+++ /dev/null
@@ -1,74 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "specialize.h"

-#include "softfloat.h"

-

-float32_t f32_sqrt( float32_t a )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    bool signA;

-    int_fast16_t expA;

-    uint_fast32_t sigA, uiZ;

-    struct exp16_sig32 normExpSig;

-    int_fast16_t expZ;

-    uint_fast32_t sigZ;

-    uint_fast64_t term, rem;

-    union ui32_f32 uZ;

-

-    uA.f = a;

-    uiA = uA.ui;

-    signA = signF32UI( uiA );

-    expA = expF32UI( uiA );

-    sigA = fracF32UI( uiA );

-    if ( expA == 0xFF ) {

-        if ( sigA ) {

-            uiZ = softfloat_propagateNaNF32UI( uiA, 0 );

-            goto uiZ;

-        }

-        if ( ! signA ) return a;

-        goto invalid;

-    }

-    if ( signA ) {

-        if ( ! ( expA | sigA ) ) return a;

-        goto invalid;

-    }

-    if ( ! expA ) {

-        if ( ! sigA ) return a;

-        normExpSig = softfloat_normSubnormalF32Sig( sigA );

-        expA = normExpSig.exp;

-        sigA = normExpSig.sig;

-    }

-    expZ = ( ( expA - 0x7F )>>1 ) + 0x7E;

-    sigA = ( sigA | 0x00800000 )<<8;

-    sigZ = softfloat_estimateSqrt32( expA, sigA ) + 2;

-    if ( ( sigZ & 0x7F ) <= 5 ) {

-        if ( sigZ < 2 ) {

-            sigZ = 0x7FFFFFFF;

-            goto roundPack;

-        }

-        sigA >>= expA & 1;

-        term = (uint_fast64_t) sigZ * sigZ;

-        rem = ( (uint_fast64_t) sigA<<32 ) - term;

-        while ( UINT64_C( 0x8000000000000000 ) <= rem ) {

-            --sigZ;

-            rem += ( (uint_fast64_t) sigZ<<1 ) | 1;

-        }

-        sigZ |= ( rem != 0 );

-    }

-    sigZ = softfloat_shortShift32Right1Jam( sigZ );

- roundPack:

-    return softfloat_roundPackToF32( 0, expZ, sigZ );

- invalid:

-    softfloat_raiseFlags( softfloat_flag_invalid );

-    uiZ = defaultNaNF32UI;

- uiZ:

-    uZ.ui = uiZ;

-    return uZ.f;

-

-}

-

diff --git a/softfloat/f32_sub.c b/softfloat/f32_sub.c
deleted file mode 100755
index c64df8e..0000000
--- a/softfloat/f32_sub.c
+++ /dev/null
@@ -1,29 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-float32_t f32_sub( float32_t a, float32_t b )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    bool signA;

-    union ui32_f32 uB;

-    uint_fast32_t uiB;

-    bool signB;

-    float32_t ( *magsRoutine )( uint_fast32_t, uint_fast32_t, bool );

-

-    uA.f = a;

-    uiA = uA.ui;

-    signA = signF32UI( uiA );

-    uB.f = b;

-    uiB = uB.ui;

-    signB = signF32UI( uiB );

-    magsRoutine =

-        ( signA == signB ) ? softfloat_subMagsF32 : softfloat_addMagsF32;

-    return magsRoutine( uiA, uiB ^ 0x80000000, signA );

-

-}

-

diff --git a/softfloat/f32_to_f64.c b/softfloat/f32_to_f64.c
deleted file mode 100755
index 9f0ae5c..0000000
--- a/softfloat/f32_to_f64.c
+++ /dev/null
@@ -1,47 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "specialize.h"

-#include "softfloat.h"

-

-float64_t f32_to_f64( float32_t a )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    bool sign;

-    int_fast16_t exp;

-    uint_fast32_t sig;

-    uint_fast64_t uiZ;

-    struct exp16_sig32 normExpSig;

-    union ui64_f64 uZ;

-

-    uA.f = a;

-    uiA = uA.ui;

-    sign = signF32UI( uiA );

-    exp = expF32UI( uiA );

-    sig = fracF32UI( uiA );

-    if ( exp == 0xFF ) {

-        uiZ =

-            sig ? softfloat_commonNaNToF64UI(

-                      softfloat_f32UIToCommonNaN( uiA ) )

-                : packToF64UI( sign, 0x7FF, 0 );

-        goto uiZ;

-    }

-    if ( ! exp ) {

-        if ( ! sig ) {

-            uiZ = packToF64UI( sign, 0, 0 );

-            goto uiZ;

-        }

-        normExpSig = softfloat_normSubnormalF32Sig( sig );

-        exp = normExpSig.exp - 1;

-        sig = normExpSig.sig;

-    }

-    uiZ = packToF64UI( sign, exp + 0x380, (uint_fast64_t) sig<<29 );

- uiZ:

-    uZ.ui = uiZ;

-    return uZ.f;

-

-}

-

diff --git a/softfloat/f32_to_i32.c b/softfloat/f32_to_i32.c
deleted file mode 100755
index bbbaee0..0000000
--- a/softfloat/f32_to_i32.c
+++ /dev/null
@@ -1,34 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-int_fast32_t f32_to_i32( float32_t a, int_fast8_t roundingMode, bool exact )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    bool sign;

-    int_fast16_t exp;

-    uint_fast32_t sig;

-    uint_fast64_t sig64;

-    int_fast16_t shiftCount;

-

-    uA.f = a;

-    uiA = uA.ui;

-    sign = signF32UI( uiA );

-    exp = expF32UI( uiA );

-    sig = fracF32UI( uiA );

-    if ( ( exp == 0xFF ) && sig ) sign = 0;

-    if ( exp ) sig |= 0x00800000;

-    sig64 = (uint_fast64_t) sig<<32;

-    shiftCount = 0xAF - exp;

-    if ( 0 < shiftCount ) {

-        sig64 = softfloat_shift64RightJam( sig64, shiftCount );

-    }

-    return softfloat_roundPackToI32( sign, sig64, roundingMode, exact );

-

-}

-

diff --git a/softfloat/f32_to_i32_r_minMag.c b/softfloat/f32_to_i32_r_minMag.c
deleted file mode 100755
index 63ff1e2..0000000
--- a/softfloat/f32_to_i32_r_minMag.c
+++ /dev/null
@@ -1,45 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    int_fast16_t exp;

-    uint_fast32_t sig;

-    bool sign;

-    int_fast16_t shiftCount;

-    int_fast32_t absZ;

-

-    uA.f = a;

-    uiA = uA.ui;

-    exp = expF32UI( uiA );

-    sig = fracF32UI( uiA );

-    if ( exp < 0x7F ) {

-        if ( exact && ( exp | sig ) ) {

-            softfloat_exceptionFlags |= softfloat_flag_inexact;

-        }

-        return 0;

-    }

-    sign = signF32UI( uiA );

-    shiftCount = 0x9E - exp;

-    if ( shiftCount <= 0 ) {

-        if ( uiA != packToF32UI( 1, 0x9E, 0 ) ) {

-            softfloat_raiseFlags( softfloat_flag_invalid );

-            if ( ! sign || ( ( exp == 0xFF ) && sig ) ) return 0x7FFFFFFF;

-        }

-        return -0x7FFFFFFF - 1;

-    }

-    sig = ( sig | 0x00800000 )<<8;

-    absZ = sig>>shiftCount;

-    if ( exact && (uint32_t) ( sig<<( ( - shiftCount ) & 31 ) ) ) {

-        softfloat_exceptionFlags |= softfloat_flag_inexact;

-    }

-    return sign ? - absZ : absZ;

-

-}

-

diff --git a/softfloat/f32_to_i64.c b/softfloat/f32_to_i64.c
deleted file mode 100755
index c0b8981..0000000
--- a/softfloat/f32_to_i64.c
+++ /dev/null
@@ -1,44 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-int_fast64_t f32_to_i64( float32_t a, int_fast8_t roundingMode, bool exact )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    bool sign;

-    int_fast16_t exp;

-    uint_fast32_t sig;

-    int_fast16_t shiftCount;

-    uint_fast64_t sig64, extra;

-    struct uint64_extra sig64Extra;

-

-    uA.f = a;

-    uiA = uA.ui;

-    sign = signF32UI( uiA );

-    exp = expF32UI( uiA );

-    sig = fracF32UI( uiA );

-    shiftCount = 0xBE - exp;

-    if ( shiftCount < 0 ) {

-        softfloat_raiseFlags( softfloat_flag_invalid );

-        if ( ! sign || ( ( exp == 0xFF ) && sig ) ) {

-            return INT64_C( 0x7FFFFFFFFFFFFFFF );

-        }

-        return - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;

-    }

-    if ( exp ) sig |= 0x00800000;

-    sig64 = (uint_fast64_t) sig<<40;

-    extra = 0;

-    if ( shiftCount ) {

-        sig64Extra = softfloat_shift64ExtraRightJam( sig64, 0, shiftCount );

-        sig64 = sig64Extra.v;

-        extra = sig64Extra.extra;

-    }

-    return softfloat_roundPackToI64( sign, sig64, extra, roundingMode, exact );

-

-}

-

diff --git a/softfloat/f32_to_i64_r_minMag.c b/softfloat/f32_to_i64_r_minMag.c
deleted file mode 100755
index 33bff93..0000000
--- a/softfloat/f32_to_i64_r_minMag.c
+++ /dev/null
@@ -1,52 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    int_fast16_t exp;

-    uint_fast32_t sig;

-    bool sign;

-    int_fast16_t shiftCount;

-    uint_fast64_t sig64;

-    int_fast64_t absZ;

-

-    uA.f = a;

-    uiA = uA.ui;

-    exp = expF32UI( uiA );

-    sig = fracF32UI( uiA );

-    if ( exp < 0x7F ) {

-        if ( exact && ( exp | sig ) ) {

-            softfloat_exceptionFlags |= softfloat_flag_inexact;

-        }

-        return 0;

-    }

-    sign = signF32UI( uiA );

-    shiftCount = 0xBE - exp;

-    if ( shiftCount <= 0 ) {

-        if ( uiA != packToF32UI( 1, 0xBE, 0 ) ) {

-            softfloat_raiseFlags( softfloat_flag_invalid );

-            if ( ! sign || ( ( exp == 0xFF ) && sig ) ) {

-                return INT64_C( 0x7FFFFFFFFFFFFFFF );

-            }

-        }

-        return - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;

-    }

-    sig |= 0x00800000;

-    sig64 = (uint_fast64_t) sig<<40;

-    absZ = sig64>>shiftCount;

-    shiftCount = 40 - shiftCount;

-    if (

-        exact && ( shiftCount < 0 ) && (uint32_t) ( sig<<( shiftCount & 31 ) )

-    ) {

-        softfloat_exceptionFlags |= softfloat_flag_inexact;

-    }

-    return sign ? - absZ : absZ;

-

-}

-

diff --git a/softfloat/f32_to_ui32.c b/softfloat/f32_to_ui32.c
deleted file mode 100755
index 3501db8..0000000
--- a/softfloat/f32_to_ui32.c
+++ /dev/null
@@ -1,33 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-uint_fast32_t f32_to_ui32( float32_t a, int_fast8_t roundingMode, bool exact )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    bool sign;

-    int_fast16_t exp;

-    uint_fast32_t sig;

-    uint_fast64_t sig64;

-    int_fast16_t shiftCount;

-

-    uA.f = a;

-    uiA = uA.ui;

-    sign = signF32UI( uiA );

-    exp = expF32UI( uiA );

-    sig = fracF32UI( uiA );

-    if ( exp ) sig |= 0x00800000;

-    sig64 = (uint_fast64_t) sig<<32;

-    shiftCount = 0xAF - exp;

-    if ( 0 < shiftCount ) {

-        sig64 = softfloat_shift64RightJam( sig64, shiftCount );

-    }

-    return softfloat_roundPackToUI32( sign, sig64, roundingMode, exact );

-

-}

-

diff --git a/softfloat/f32_to_ui32_r_minMag.c b/softfloat/f32_to_ui32_r_minMag.c
deleted file mode 100755
index edd858d..0000000
--- a/softfloat/f32_to_ui32_r_minMag.c
+++ /dev/null
@@ -1,41 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    int_fast16_t exp;

-    uint_fast32_t sig;

-    int_fast16_t shiftCount;

-    uint_fast32_t z;

-

-    uA.f = a;

-    uiA = uA.ui;

-    exp = expF32UI( uiA );

-    sig = fracF32UI( uiA );

-    if ( exp < 0x7F ) {

-        if ( exact && ( exp | sig ) ) {

-            softfloat_exceptionFlags |= softfloat_flag_inexact;

-        }

-        return 0;

-    }

-    if ( signF32UI( uiA ) ) goto invalid;

-    shiftCount = 0x9E - exp;

-    if ( shiftCount < 0 ) goto invalid;

-    sig = ( sig | 0x00800000 )<<8;

-    z = sig>>shiftCount;

-    if ( exact && ( sig & ( ( (uint_fast32_t) 1<<shiftCount ) - 1 ) ) ) {

-        softfloat_exceptionFlags |= softfloat_flag_inexact;

-    }

-    return z;

- invalid:

-    softfloat_raiseFlags( softfloat_flag_invalid );

-    return 0xFFFFFFFF;

-

-}

-

diff --git a/softfloat/f32_to_ui64.c b/softfloat/f32_to_ui64.c
deleted file mode 100755
index 6cdcf74..0000000
--- a/softfloat/f32_to_ui64.c
+++ /dev/null
@@ -1,42 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-uint_fast64_t f32_to_ui64( float32_t a, int_fast8_t roundingMode, bool exact )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    bool sign;

-    int_fast16_t exp;

-    uint_fast32_t sig;

-    int_fast16_t shiftCount;

-    uint_fast64_t sig64, extra;

-    struct uint64_extra sig64Extra;

-

-    uA.f = a;

-    uiA = uA.ui;

-    sign = signF32UI( uiA );

-    exp = expF32UI( uiA );

-    sig = fracF32UI( uiA );

-    shiftCount = 0xBE - exp;

-    if ( shiftCount < 0 ) {

-        softfloat_raiseFlags( softfloat_flag_invalid );

-        return UINT64_C( 0xFFFFFFFFFFFFFFFF );

-    }

-    if ( exp ) sig |= 0x00800000;

-    sig64 = (uint_fast64_t) sig<<40;

-    extra = 0;

-    if ( shiftCount ) {

-        sig64Extra = softfloat_shift64ExtraRightJam( sig64, 0, shiftCount );

-        sig64 = sig64Extra.v;

-        extra = sig64Extra.extra;

-    }

-    return

-        softfloat_roundPackToUI64( sign, sig64, extra, roundingMode, exact );

-

-}

-

diff --git a/softfloat/f32_to_ui64_r_minMag.c b/softfloat/f32_to_ui64_r_minMag.c
deleted file mode 100755
index 738d6b1..0000000
--- a/softfloat/f32_to_ui64_r_minMag.c
+++ /dev/null
@@ -1,45 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact )

-{

-    union ui32_f32 uA;

-    uint_fast32_t uiA;

-    int_fast16_t exp;

-    uint_fast32_t sig;

-    int_fast16_t shiftCount;

-    uint_fast64_t sig64, z;

-

-    uA.f = a;

-    uiA = uA.ui;

-    exp = expF32UI( uiA );

-    sig = fracF32UI( uiA );

-    if ( exp < 0x7F ) {

-        if ( exact && ( exp | sig ) ) {

-            softfloat_exceptionFlags |= softfloat_flag_inexact;

-        }

-        return 0;

-    }

-    if ( signF32UI( uiA ) ) goto invalid;

-    shiftCount = 0xBE - exp;

-    if ( shiftCount < 0 ) goto invalid;

-    sig |= 0x00800000;

-    sig64 = (uint_fast64_t) sig<<40;

-    z = sig64>>shiftCount;

-    shiftCount = 40 - shiftCount;

-    if (

-        exact && ( shiftCount < 0 ) && (uint32_t) ( sig<<( shiftCount & 31 ) )

-    ) {

-        softfloat_exceptionFlags |= softfloat_flag_inexact;

-    }

-    return z;

- invalid:

-    softfloat_raiseFlags( softfloat_flag_invalid );

-    return UINT64_C( 0xFFFFFFFFFFFFFFFF );

-

-}

-

diff --git a/softfloat/f64_add.c b/softfloat/f64_add.c
deleted file mode 100755
index 9ec4b5f..0000000
--- a/softfloat/f64_add.c
+++ /dev/null
@@ -1,29 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float64_t f64_add( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool signA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signB;
-    float64_t ( *magsRoutine )( uint_fast64_t, uint_fast64_t, bool );
-
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF64UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF64UI( uiB );
-    magsRoutine =
-        ( signA == signB ) ? softfloat_addMagsF64 : softfloat_subMagsF64;
-    return magsRoutine( uiA, uiB, signA );
-
-}
-
diff --git a/softfloat/f64_div.c b/softfloat/f64_div.c
deleted file mode 100755
index 9bc72b3..0000000
--- a/softfloat/f64_div.c
+++ /dev/null
@@ -1,104 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t f64_div( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool signA;
-    int_fast16_t expA;
-    uint_fast64_t sigA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signB;
-    int_fast16_t expB;
-    uint_fast64_t sigB;
-    bool signZ;
-    struct exp16_sig64 normExpSig;
-    int_fast16_t expZ;
-    uint_fast64_t sigZ;
-    struct uint128 term, rem;
-    uint_fast64_t uiZ;
-    union ui64_f64 uZ;
-
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF64UI( uiA );
-    expA = expF64UI( uiA );
-    sigA = fracF64UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF64UI( uiB );
-    expB = expF64UI( uiB );
-    sigB = fracF64UI( uiB );
-    signZ = signA ^ signB;
-    if ( expA == 0x7FF ) {
-        if ( sigA ) goto propagateNaN;
-        if ( expB == 0x7FF ) {
-            if ( sigB ) goto propagateNaN;
-            goto invalid;
-        }
-        goto infinity;
-    }
-    if ( expB == 0x7FF ) {
-        if ( sigB ) goto propagateNaN;
-        goto zero;
-    }
-    if ( ! expB ) {
-        if ( ! sigB ) {
-            if ( ! ( expA | sigA ) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinity );
-            goto infinity;
-        }
-        normExpSig = softfloat_normSubnormalF64Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) {
-        if ( ! sigA ) goto zero;
-        normExpSig = softfloat_normSubnormalF64Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    expZ = expA - expB + 0x3FD;
-    sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<10;
-    sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<11;
-    if ( sigB <= ( sigA + sigA ) ) {
-        ++expZ;
-        sigA >>= 1;
-    }
-    sigZ = softfloat_estimateDiv128To64( sigA, 0, sigB );
-    if ( ( sigZ & 0x1FF ) <= 2 ) {
-        term = softfloat_mul64To128( sigB, sigZ );
-        rem = softfloat_sub128( sigA, 0, term.v64, term.v0 );
-        while ( UINT64_C( 0x8000000000000000 ) <= rem.v64 ) {
-            --sigZ;
-            rem = softfloat_add128( rem.v64, rem.v0, 0, sigB );
-        }
-        sigZ |= ( rem.v0 != 0 );
-    }
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
- propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
-    goto uiZ;
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF64UI;
-    goto uiZ;
- infinity:
-    uiZ = packToF64UI( signZ, 0x7FF, 0 );
-    goto uiZ;
- zero:
-    uiZ = packToF64UI( signZ, 0, 0 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
diff --git a/softfloat/f64_eq.c b/softfloat/f64_eq.c
deleted file mode 100755
index 925aabc..0000000
--- a/softfloat/f64_eq.c
+++ /dev/null
@@ -1,35 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f64_eq( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if (
-           ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) )
-        || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) )
-    ) {
-        if (
-            softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    return
-        ( uiA == uiB ) || ! ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) );
-
-}
-
diff --git a/softfloat/f64_eq_signaling.c b/softfloat/f64_eq_signaling.c
deleted file mode 100755
index 7a54dc1..0000000
--- a/softfloat/f64_eq_signaling.c
+++ /dev/null
@@ -1,30 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f64_eq_signaling( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if (
-           ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) )
-        || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) )
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    return
-        ( uiA == uiB ) || ! ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) );
-
-}
-
diff --git a/softfloat/f64_isSignalingNaN.c b/softfloat/f64_isSignalingNaN.c
deleted file mode 100755
index d720ac1..0000000
--- a/softfloat/f64_isSignalingNaN.c
+++ /dev/null
@@ -1,16 +0,0 @@
-
-#include <stdbool.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f64_isSignalingNaN( float64_t a )
-{
-    union ui64_f64 uA;
-
-    uA.f = a;
-    return softfloat_isSigNaNF64UI( uA.ui );
-
-}
-
diff --git a/softfloat/f64_le.c b/softfloat/f64_le.c
deleted file mode 100755
index e6c5caf..0000000
--- a/softfloat/f64_le.c
+++ /dev/null
@@ -1,35 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f64_le( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if (
-           ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) )
-        || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) )
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signF64UI( uiA );
-    signB = signF64UI( uiB );
-    return
-        ( signA != signB )
-            ? signA || ! ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) )
-            : ( uiA == uiB ) || ( signA ^ ( uiA < uiB ) );
-
-}
-
diff --git a/softfloat/f64_le_quiet.c b/softfloat/f64_le_quiet.c
deleted file mode 100755
index e9b7ede..0000000
--- a/softfloat/f64_le_quiet.c
+++ /dev/null
@@ -1,40 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f64_le_quiet( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if (
-           ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) )
-        || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) )
-    ) {
-        if (
-            softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signF64UI( uiA );
-    signB = signF64UI( uiB );
-    return
-        ( signA != signB )
-            ? signA || ! ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) )
-            : ( uiA == uiB ) || ( signA ^ ( uiA < uiB ) );
-
-}
-
diff --git a/softfloat/f64_lt.c b/softfloat/f64_lt.c
deleted file mode 100755
index 1b2f696..0000000
--- a/softfloat/f64_lt.c
+++ /dev/null
@@ -1,35 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f64_lt( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if (
-           ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) )
-        || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) )
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signF64UI( uiA );
-    signB = signF64UI( uiB );
-    return
-        ( signA != signB )
-            ? signA && ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) )
-            : ( uiA != uiB ) && ( signA ^ ( uiA < uiB ) );
-
-}
-
diff --git a/softfloat/f64_lt_quiet.c b/softfloat/f64_lt_quiet.c
deleted file mode 100755
index f27e6da..0000000
--- a/softfloat/f64_lt_quiet.c
+++ /dev/null
@@ -1,40 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f64_lt_quiet( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if (
-           ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) )
-        || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) )
-    ) {
-        if (
-            softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signF64UI( uiA );
-    signB = signF64UI( uiB );
-    return
-        ( signA != signB )
-            ? signA && ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) )
-            : ( uiA != uiB ) && ( signA ^ ( uiA < uiB ) );
-
-}
-
diff --git a/softfloat/f64_mul.c b/softfloat/f64_mul.c
deleted file mode 100755
index 4b5dc4e..0000000
--- a/softfloat/f64_mul.c
+++ /dev/null
@@ -1,91 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "specialize.h"

-#include "softfloat.h"

-

-float64_t f64_mul( float64_t a, float64_t b )

-{

-    union ui64_f64 uA;

-    uint_fast64_t uiA;

-    bool signA;

-    int_fast16_t expA;

-    uint_fast64_t sigA;

-    union ui64_f64 uB;

-    uint_fast64_t uiB;

-    bool signB;

-    int_fast16_t expB;

-    uint_fast64_t sigB;

-    bool signZ;

-    uint_fast64_t magBits;

-    struct exp16_sig64 normExpSig;

-    int_fast16_t expZ;

-    struct uint128 sigZ128;

-    uint_fast64_t sigZ, uiZ;

-    union ui64_f64 uZ;

-

-    uA.f = a;

-    uiA = uA.ui;

-    signA = signF64UI( uiA );

-    expA = expF64UI( uiA );

-    sigA = fracF64UI( uiA );

-    uB.f = b;

-    uiB = uB.ui;

-    signB = signF64UI( uiB );

-    expB = expF64UI( uiB );

-    sigB = fracF64UI( uiB );

-    signZ = signA ^ signB;

-    if ( expA == 0x7FF ) {

-        if ( sigA || ( ( expB == 0x7FF ) && sigB ) ) goto propagateNaN;

-        magBits = expB | sigB;

-        goto infArg;

-    }

-    if ( expB == 0x7FF ) {

-        if ( sigB ) goto propagateNaN;

-        magBits = expA | sigA;

-        goto infArg;

-    }

-    if ( ! expA ) {

-        if ( ! sigA ) goto zero;

-        normExpSig = softfloat_normSubnormalF64Sig( sigA );

-        expA = normExpSig.exp;

-        sigA = normExpSig.sig;

-    }

-    if ( ! expB ) {

-        if ( ! sigB ) goto zero;

-        normExpSig = softfloat_normSubnormalF64Sig( sigB );

-        expB = normExpSig.exp;

-        sigB = normExpSig.sig;

-    }

-    expZ = expA + expB - 0x3FF;

-    sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<10;

-    sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<11;

-    sigZ128 = softfloat_mul64To128( sigA, sigB );

-    sigZ = sigZ128.v64 | ( sigZ128.v0 != 0 );

-    if ( sigZ < UINT64_C( 0x4000000000000000 ) ) {

-        --expZ;

-        sigZ <<= 1;

-    }

-    return softfloat_roundPackToF64( signZ, expZ, sigZ );

- propagateNaN:

-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );

-    goto uiZ;

- infArg:

-    if ( ! magBits ) {

-        softfloat_raiseFlags( softfloat_flag_invalid );

-        uiZ = defaultNaNF64UI;

-    } else {

-        uiZ = packToF64UI( signZ, 0x7FF, 0 );

-    }

-    goto uiZ;

- zero:

-    uiZ = packToF64UI( signZ, 0, 0 );

- uiZ:

-    uZ.ui = uiZ;

-    return uZ.f;

-

-}

-

diff --git a/softfloat/f64_mulAdd.c b/softfloat/f64_mulAdd.c
deleted file mode 100755
index fa1669a..0000000
--- a/softfloat/f64_mulAdd.c
+++ /dev/null
@@ -1,25 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c )

-{

-    union ui64_f64 uA;

-    uint_fast64_t uiA;

-    union ui64_f64 uB;

-    uint_fast64_t uiB;

-    union ui64_f64 uC;

-    uint_fast64_t uiC;

-

-    uA.f = a;

-    uiA = uA.ui;

-    uB.f = b;

-    uiB = uB.ui;

-    uC.f = c;

-    uiC = uC.ui;

-    return softfloat_mulAddF64( 0, uiA, uiB, uiC );

-

-}

-

diff --git a/softfloat/f64_rem.c b/softfloat/f64_rem.c
deleted file mode 100755
index 08fcd78..0000000
--- a/softfloat/f64_rem.c
+++ /dev/null
@@ -1,113 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t f64_rem( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool signA;
-    int_fast16_t expA;
-    uint_fast64_t sigA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signB;
-    int_fast16_t expB;
-    uint_fast64_t sigB;
-    struct exp16_sig64 normExpSig;
-    int_fast16_t expDiff;
-    uint_fast64_t q, alternateSigA;
-    uint64_t sigMean;
-    bool signZ;
-    uint_fast64_t uiZ;
-    union ui64_f64 uZ;
-
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF64UI( uiA );
-    expA = expF64UI( uiA );
-    sigA = fracF64UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF64UI( uiB );
-    expB = expF64UI( uiB );
-    sigB = fracF64UI( uiB );
-    if ( expA == 0x7FF ) {
-        if ( sigA || ( ( expB == 0x7FF ) && sigB ) ) goto propagateNaN;
-        goto invalid;
-    }
-    if ( expB == 0x7FF ) {
-        if ( sigB ) goto propagateNaN;
-        return a;
-    }
-    if ( ! expB ) {
-        if ( ! sigB ) goto invalid;
-        normExpSig = softfloat_normSubnormalF64Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) {
-        if ( ! sigA ) return a;
-        normExpSig = softfloat_normSubnormalF64Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    expDiff = expA - expB;
-    sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<11;
-    sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<11;
-    if ( expDiff < 0 ) {
-        if ( expDiff < -1 ) return a;
-        sigA >>= 1;
-    }
-    q = ( sigB <= sigA );
-    if ( q ) sigA -= sigB;
-    expDiff -= 64;
-    while ( 0 < expDiff ) {
-        q = softfloat_estimateDiv128To64( sigA, 0, sigB );
-        q = ( 2 < q ) ? q - 2 : 0;
-        sigA = - ( ( sigB>>2 ) * q );
-        expDiff -= 62;
-    }
-    expDiff += 64;
-    if ( 0 < expDiff ) {
-        q = softfloat_estimateDiv128To64( sigA, 0, sigB );
-        q = ( 2 < q ) ? q - 2 : 0;
-        q >>= 64 - expDiff;
-        sigB >>= 2;
-        sigA = ( ( sigA>>1 )<<( expDiff - 1 ) ) - sigB * q;
-    } else {
-        sigA >>= 2;
-        sigB >>= 2;
-    }
-    do {
-        alternateSigA = sigA;
-        ++q;
-        sigA -= sigB;
-    } while ( sigA < UINT64_C( 0x8000000000000000 ) );
-    sigMean = sigA + alternateSigA;
-    if (
-        ( UINT64_C( 0x8000000000000000 ) <= sigMean )
-            || ( ! sigMean && ( q & 1 ) )
-    ) {
-        sigA = alternateSigA;
-    }
-    signZ = ( UINT64_C( 0x8000000000000000 ) <= sigA );
-    if ( signZ ) sigA = - sigA;
-    return softfloat_normRoundPackToF64( signA ^ signZ, expB, sigA );
- propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
-    goto uiZ;
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF64UI;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
diff --git a/softfloat/f64_roundToInt.c b/softfloat/f64_roundToInt.c
deleted file mode 100755
index ef16dfa..0000000
--- a/softfloat/f64_roundToInt.c
+++ /dev/null
@@ -1,80 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t f64_roundToInt( float64_t a, int_fast8_t roundingMode, bool exact )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    int_fast16_t expA;
-    uint_fast64_t uiZ;
-    bool signA;
-    uint_fast64_t lastBitMask, roundBitsMask;
-    union ui64_f64 uZ;
-
-    uA.f = a;
-    uiA = uA.ui;
-    expA = expF64UI( uiA );
-    if ( 0x433 <= expA ) {
-        if ( ( expA == 0x7FF ) && fracF64UI( uiA ) ) {
-            uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
-            goto uiZ;
-        }
-        return a;
-    }
-    if ( expA <= 0x3FE ) {
-        if ( ! ( uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) ) return a;
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-        signA = signF64UI( uiA );
-        switch ( roundingMode ) {
-         case softfloat_round_nearest_even:
-            if ( ( expA == 0x3FE ) && fracF64UI( uiA ) ) {
-                uiZ = packToF64UI( signA, 0x3FF, 0 );
-                goto uiZ;
-            }
-            break;
-         case softfloat_round_min:
-            uiZ = signA ? UINT64_C( 0xBFF0000000000000 ) : 0;
-            goto uiZ;
-         case softfloat_round_max:
-            uiZ =
-                signA ? UINT64_C( 0x8000000000000000 )
-                    : UINT64_C( 0x3FF0000000000000 );
-            goto uiZ;
-         case softfloat_round_nearest_maxMag:
-            if ( expA == 0x3FE ) {
-                uiZ = packToF64UI( signA, 0x3FF, 0 );
-                goto uiZ;
-            }
-            break;
-        }
-        uiZ = packToF64UI( signA, 0, 0 );
-        goto uiZ;
-    }
-    lastBitMask = (uint_fast64_t) 1<<( 0x433 - expA );
-    roundBitsMask = lastBitMask - 1;
-    uiZ = uiA;
-    if ( roundingMode == softfloat_round_nearest_maxMag ) {
-        uiZ += lastBitMask>>1;
-    } else if ( roundingMode == softfloat_round_nearest_even ) {
-        uiZ += lastBitMask>>1;
-        if ( ! ( uiZ & roundBitsMask ) ) uiZ &= ~ lastBitMask;
-    } else if ( roundingMode != softfloat_round_minMag ) {
-        if ( signF64UI( uiZ ) ^ ( roundingMode == softfloat_round_max ) ) {
-            uiZ += roundBitsMask;
-        }
-    }
-    uiZ &= ~ roundBitsMask;
-    if ( exact && ( uiZ != uiA ) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
diff --git a/softfloat/f64_sqrt.c b/softfloat/f64_sqrt.c
deleted file mode 100755
index cd91010..0000000
--- a/softfloat/f64_sqrt.c
+++ /dev/null
@@ -1,74 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "specialize.h"

-#include "softfloat.h"

-

-float64_t f64_sqrt( float64_t a )

-{

-    union ui64_f64 uA;

-    uint_fast64_t uiA;

-    bool signA;

-    int_fast16_t expA;

-    uint_fast64_t sigA, uiZ;

-    struct exp16_sig64 normExpSig;

-    int_fast16_t expZ;

-    uint_fast32_t sigZ32;

-    uint_fast64_t sigZ;

-    struct uint128 term, rem;

-    union ui64_f64 uZ;

-

-    uA.f = a;

-    uiA = uA.ui;

-    signA = signF64UI( uiA );

-    expA = expF64UI( uiA );

-    sigA = fracF64UI( uiA );

-    if ( expA == 0x7FF ) {

-        if ( sigA ) {

-            uiZ = softfloat_propagateNaNF64UI( uiA, 0 );

-            goto uiZ;

-        }

-        if ( ! signA ) return a;

-        goto invalid;

-    }

-    if ( signA ) {

-        if ( ! ( expA | sigA ) ) return a;

-        goto invalid;

-    }

-    if ( ! expA ) {

-        if ( ! sigA ) return a;

-        normExpSig = softfloat_normSubnormalF64Sig( sigA );

-        expA = normExpSig.exp;

-        sigA = normExpSig.sig;

-    }

-    expZ = ( ( expA - 0x3FF )>>1 ) + 0x3FE;

-    sigA |= UINT64_C( 0x0010000000000000 );

-    sigZ32 = softfloat_estimateSqrt32( expA, sigA>>21 );

-    sigA <<= 9 - ( expA & 1 );

-    sigZ =

-        softfloat_estimateDiv128To64( sigA, 0, (uint_fast64_t) sigZ32<<32 )

-            + ( (uint_fast64_t) sigZ32<<30 );

-    if ( ( sigZ & 0x1FF ) <= 5 ) {

-        term = softfloat_mul64To128( sigZ, sigZ );

-        rem = softfloat_sub128( sigA, 0, term.v64, term.v0 );

-        while ( UINT64_C( 0x8000000000000000 ) <= rem.v64 ) {

-            --sigZ;

-            rem =

-                softfloat_add128(

-                    rem.v64, rem.v0, sigZ>>63, (uint64_t) ( sigZ<<1 ) );

-        }

-        sigZ |= ( ( rem.v64 | rem.v0 ) != 0 );

-    }

-    return softfloat_roundPackToF64( 0, expZ, sigZ );

- invalid:

-    softfloat_raiseFlags( softfloat_flag_invalid );

-    uiZ = defaultNaNF64UI;

- uiZ:

-    uZ.ui = uiZ;

-    return uZ.f;

-

-}

-

diff --git a/softfloat/f64_sub.c b/softfloat/f64_sub.c
deleted file mode 100755
index 38bd574..0000000
--- a/softfloat/f64_sub.c
+++ /dev/null
@@ -1,29 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float64_t f64_sub( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool signA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signB;
-    float64_t ( *magsRoutine )( uint_fast64_t, uint_fast64_t, bool );
-
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF64UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF64UI( uiB );
-    magsRoutine =
-        ( signA == signB ) ? softfloat_subMagsF64 : softfloat_addMagsF64;
-    return magsRoutine( uiA, uiB, signA );
-
-}
-
diff --git a/softfloat/f64_to_f32.c b/softfloat/f64_to_f32.c
deleted file mode 100755
index 395d6c6..0000000
--- a/softfloat/f64_to_f32.c
+++ /dev/null
@@ -1,43 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "specialize.h"

-#include "softfloat.h"

-

-float32_t f64_to_f32( float64_t a )

-{

-    union ui64_f64 uA;

-    uint_fast64_t uiA;

-    bool sign;

-    int_fast16_t exp;

-    uint_fast64_t sig;

-    uint_fast32_t uiZ, sig32;

-    union ui32_f32 uZ;

-

-    uA.f = a;

-    uiA = uA.ui;

-    sign = signF64UI( uiA );

-    exp = expF64UI( uiA );

-    sig = fracF64UI( uiA );

-    if ( exp == 0x7FF ) {

-        uiZ =

-            sig ? softfloat_commonNaNToF32UI(

-                      softfloat_f64UIToCommonNaN( uiA ) )

-                : packToF32UI( sign, 0xFF, 0 );

-        goto uiZ;

-    }

-    sig32 = softfloat_shortShift64RightJam( sig, 22 );

-    if ( ! ( exp | sig32 ) ) {

-        uiZ = packToF32UI( sign, 0, 0 );

-        goto uiZ;

-    }

-    return softfloat_roundPackToF32( sign, exp - 0x381, sig32 | 0x40000000 );

- uiZ:

-    uZ.ui = uiZ;

-    return uZ.f;

-

-}

-

diff --git a/softfloat/f64_to_i32.c b/softfloat/f64_to_i32.c
deleted file mode 100755
index 0778a86..0000000
--- a/softfloat/f64_to_i32.c
+++ /dev/null
@@ -1,30 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-int_fast32_t f64_to_i32( float64_t a, int_fast8_t roundingMode, bool exact )

-{

-    union ui64_f64 uA;

-    uint_fast64_t uiA;

-    bool sign;

-    int_fast16_t exp;

-    uint_fast64_t sig;

-    int_fast16_t shiftCount;

-

-    uA.f = a;

-    uiA = uA.ui;

-    sign = signF64UI( uiA );

-    exp = expF64UI( uiA );

-    sig = fracF64UI( uiA );

-    if ( ( exp == 0x7FF ) && sig ) sign = 0;

-    if ( exp ) sig |= UINT64_C( 0x0010000000000000 );

-    shiftCount = 0x42C - exp;

-    if ( 0 < shiftCount ) sig = softfloat_shift64RightJam( sig, shiftCount );

-    return softfloat_roundPackToI32( sign, sig, roundingMode, exact );

-

-}

-

diff --git a/softfloat/f64_to_i32_r_minMag.c b/softfloat/f64_to_i32_r_minMag.c
deleted file mode 100755
index 39246c2..0000000
--- a/softfloat/f64_to_i32_r_minMag.c
+++ /dev/null
@@ -1,50 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact )

-{

-    union ui64_f64 uA;

-    uint_fast64_t uiA;

-    int_fast16_t exp;

-    uint_fast64_t sig;

-    bool sign;

-    int_fast16_t shiftCount;

-    uint_fast32_t absZ;

-    union { uint32_t ui; int32_t i; } uZ;

-    int_fast32_t z;

-

-    uA.f = a;

-    uiA = uA.ui;

-    exp = expF64UI( uiA );

-    sig = fracF64UI( uiA );

-    if ( exp < 0x3FF ) {

-        if ( exact && ( exp | sig ) ) {

-            softfloat_exceptionFlags |= softfloat_flag_inexact;

-        }

-        return 0;

-    }

-    sign = signF64UI( uiA );

-    if ( 0x41E < exp ) {

-        if ( ( exp == 0x7FF ) && sig ) sign = 0;

-        goto invalid;

-    }

-    sig |= UINT64_C( 0x0010000000000000 );

-    shiftCount = 0x433 - exp;

-    absZ = sig>>shiftCount;

-    uZ.ui = sign ? - absZ : absZ;

-    z = uZ.i;

-    if ( ( z < 0 ) != sign ) goto invalid;

-    if ( exact && ( (uint_fast64_t) absZ<<shiftCount != sig ) ) {

-        softfloat_exceptionFlags |= softfloat_flag_inexact;

-    }

-    return z;

- invalid:

-    softfloat_raiseFlags( softfloat_flag_invalid );

-    return sign ? -0x7FFFFFFF - 1 : 0x7FFFFFFF;

-

-}

-

diff --git a/softfloat/f64_to_i64.c b/softfloat/f64_to_i64.c
deleted file mode 100755
index 89663ee..0000000
--- a/softfloat/f64_to_i64.c
+++ /dev/null
@@ -1,46 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-int_fast64_t f64_to_i64( float64_t a, int_fast8_t roundingMode, bool exact )

-{

-    union ui64_f64 uA;

-    uint_fast64_t uiA;

-    bool sign;

-    int_fast16_t exp;

-    uint_fast64_t sig;

-    int_fast16_t shiftCount;

-    struct uint64_extra sigExtra;

-

-    uA.f = a;

-    uiA = uA.ui;

-    sign = signF64UI( uiA );

-    exp = expF64UI( uiA );

-    sig = fracF64UI( uiA );

-    if ( exp ) sig |= UINT64_C( 0x0010000000000000 );

-    shiftCount = 0x433 - exp;

-    if ( shiftCount <= 0 ) {

-        if ( 0x43E < exp ) {

-            softfloat_raiseFlags( softfloat_flag_invalid );

-            return

-                ! sign

-                    || ( ( exp == 0x7FF )

-                             && ( sig != UINT64_C( 0x0010000000000000 ) ) )

-                    ? INT64_C( 0x7FFFFFFFFFFFFFFF )

-                    : - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;

-        }

-        sigExtra.v = sig<<( - shiftCount );

-        sigExtra.extra = 0;

-    } else {

-        sigExtra = softfloat_shift64ExtraRightJam( sig, 0, shiftCount );

-    }

-    return

-        softfloat_roundPackToI64(

-            sign, sigExtra.v, sigExtra.extra, roundingMode, exact );

-

-}

-

diff --git a/softfloat/f64_to_i64_r_minMag.c b/softfloat/f64_to_i64_r_minMag.c
deleted file mode 100755
index 525705b..0000000
--- a/softfloat/f64_to_i64_r_minMag.c
+++ /dev/null
@@ -1,52 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact )

-{

-    union ui64_f64 uA;

-    uint_fast64_t uiA;

-    bool sign;

-    int_fast16_t exp;

-    uint_fast64_t sig;

-    int_fast16_t shiftCount;

-    int_fast64_t absZ;

-

-    uA.f = a;

-    uiA = uA.ui;

-    sign = signF64UI( uiA );

-    exp = expF64UI( uiA );

-    sig = fracF64UI( uiA );

-    shiftCount = exp - 0x433;

-    if ( 0 <= shiftCount ) {

-        if ( 0x43E <= exp ) {

-            if ( uiA != packToF64UI( 1, 0x43E, 0 ) ) {

-                softfloat_raiseFlags( softfloat_flag_invalid );

-                if ( ! sign || ( ( exp == 0x7FF ) && sig ) ) {

-                    return INT64_C( 0x7FFFFFFFFFFFFFFF );

-                }

-            }

-            return - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;

-        }

-        sig |= UINT64_C( 0x0010000000000000 );

-        absZ = sig<<shiftCount;

-    } else {

-        if ( exp < 0x3FF ) {

-            if ( exact && ( exp | sig ) ) {

-                softfloat_exceptionFlags |= softfloat_flag_inexact;

-            }

-            return 0;

-        }

-        sig |= UINT64_C( 0x0010000000000000 );

-        absZ = sig>>( - shiftCount );

-        if ( exact && (uint64_t) ( sig<<( shiftCount & 63 ) ) ) {

-            softfloat_exceptionFlags |= softfloat_flag_inexact;

-        }

-    }

-    return sign ? - absZ : absZ;

-

-}

-

diff --git a/softfloat/f64_to_ui32.c b/softfloat/f64_to_ui32.c
deleted file mode 100755
index b186605..0000000
--- a/softfloat/f64_to_ui32.c
+++ /dev/null
@@ -1,29 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-uint_fast32_t f64_to_ui32( float64_t a, int_fast8_t roundingMode, bool exact )

-{

-    union ui64_f64 uA;

-    uint_fast64_t uiA;

-    bool sign;

-    int_fast16_t exp;

-    uint_fast64_t sig;

-    int_fast16_t shiftCount;

-

-    uA.f = a;

-    uiA = uA.ui;

-    sign = signF64UI( uiA );

-    exp = expF64UI( uiA );

-    sig = fracF64UI( uiA );

-    if ( exp ) sig |= UINT64_C( 0x0010000000000000 );

-    shiftCount = 0x42C - exp;

-    if ( 0 < shiftCount ) sig = softfloat_shift64RightJam( sig, shiftCount );

-    return softfloat_roundPackToUI32( sign, sig, roundingMode, exact );

-

-}

-

diff --git a/softfloat/f64_to_ui32_r_minMag.c b/softfloat/f64_to_ui32_r_minMag.c
deleted file mode 100755
index 9f1dd4d..0000000
--- a/softfloat/f64_to_ui32_r_minMag.c
+++ /dev/null
@@ -1,40 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact )

-{

-    union ui64_f64 uA;

-    uint_fast64_t uiA;

-    int_fast16_t exp;

-    uint_fast64_t sig;

-    int_fast16_t shiftCount;

-    uint_fast32_t z;

-

-    uA.f = a;

-    uiA = uA.ui;

-    exp = expF64UI( uiA );

-    sig = fracF64UI( uiA );

-    if ( exp < 0x3FF ) {

-        if ( exact && ( exp | sig ) ) {

-            softfloat_exceptionFlags |= softfloat_flag_inexact;

-        }

-        return 0;

-    }

-    if ( signF64UI( uiA ) || ( 0x41E < exp ) ) {

-        softfloat_raiseFlags( softfloat_flag_invalid );

-        return 0xFFFFFFFF;

-    }

-    sig |= UINT64_C( 0x0010000000000000 );

-    shiftCount = 0x433 - exp;

-    z = sig>>shiftCount;

-    if ( exact && ( (uint_fast64_t) z<<shiftCount != sig ) ) {

-        softfloat_exceptionFlags |= softfloat_flag_inexact;

-    }

-    return z;

-

-}

-

diff --git a/softfloat/f64_to_ui64.c b/softfloat/f64_to_ui64.c
deleted file mode 100755
index 9afebd7..0000000
--- a/softfloat/f64_to_ui64.c
+++ /dev/null
@@ -1,41 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-uint_fast64_t f64_to_ui64( float64_t a, int_fast8_t roundingMode, bool exact )

-{

-    union ui64_f64 uA;

-    uint_fast64_t uiA;

-    bool sign;

-    int_fast16_t exp;

-    uint_fast64_t sig;

-    int_fast16_t shiftCount;

-    struct uint64_extra sigExtra;

-

-    uA.f = a;

-    uiA = uA.ui;

-    sign = signF64UI( uiA );

-    exp = expF64UI( uiA );

-    sig = fracF64UI( uiA );

-    if ( exp ) sig |= UINT64_C( 0x0010000000000000 );

-    shiftCount = 0x433 - exp;

-    if ( shiftCount <= 0 ) {

-        if ( 0x43E < exp ) {

-            softfloat_raiseFlags( softfloat_flag_invalid );

-            return UINT64_C( 0xFFFFFFFFFFFFFFFF );

-        }

-        sigExtra.v = sig<<( - shiftCount );

-        sigExtra.extra = 0;

-    } else {

-        sigExtra = softfloat_shift64ExtraRightJam( sig, 0, shiftCount );

-    }

-    return

-        softfloat_roundPackToUI64(

-            sign, sigExtra.v, sigExtra.extra, roundingMode, exact );

-

-}

-

diff --git a/softfloat/f64_to_ui64_r_minMag.c b/softfloat/f64_to_ui64_r_minMag.c
deleted file mode 100755
index a66d3ff..0000000
--- a/softfloat/f64_to_ui64_r_minMag.c
+++ /dev/null
@@ -1,45 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact )

-{

-    union ui64_f64 uA;

-    uint_fast64_t uiA;

-    int_fast16_t exp;

-    uint_fast64_t sig;

-    int_fast16_t shiftCount;

-    uint_fast64_t z;

-

-    uA.f = a;

-    uiA = uA.ui;

-    exp = expF64UI( uiA );

-    sig = fracF64UI( uiA );

-    if ( exp < 0x3FF ) {

-        if ( exact && ( exp | sig ) ) {

-            softfloat_exceptionFlags |= softfloat_flag_inexact;

-        }

-        return 0;

-    }

-    if ( signF64UI( uiA ) ) goto invalid;

-    shiftCount = exp - 0x433;

-    if ( 0 <= shiftCount ) {

-        if ( 0x43E < exp ) goto invalid;

-        z = ( sig | UINT64_C( 0x0010000000000000 ) )<<shiftCount;

-    } else {

-        sig |= UINT64_C( 0x0010000000000000 );

-        z = sig>>( - shiftCount );

-        if ( exact && (uint64_t) ( sig<<( shiftCount & 63 ) ) ) {

-            softfloat_exceptionFlags |= softfloat_flag_inexact;

-        }

-    }

-    return z;

- invalid:

-    softfloat_raiseFlags( softfloat_flag_invalid );

-    return UINT64_C( 0xFFFFFFFFFFFFFFFF );

-

-}

-

diff --git a/softfloat/i32_to_f32.c b/softfloat/i32_to_f32.c
deleted file mode 100755
index f51facd..0000000
--- a/softfloat/i32_to_f32.c
+++ /dev/null
@@ -1,21 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-float32_t i32_to_f32( int_fast32_t a )

-{

-    bool sign;

-    union ui32_f32 uZ;

-

-    sign = ( a < 0 );

-    if ( ! ( a & 0x7FFFFFFF ) ) {

-        uZ.ui = sign ? packToF32UI( 1, 0x9E, 0 ) : 0;

-        return uZ.f;

-    }

-    return softfloat_normRoundPackToF32( sign, 0x9C, sign ? - a : a );

-

-}

-

diff --git a/softfloat/i32_to_f64.c b/softfloat/i32_to_f64.c
deleted file mode 100755
index d42cbe8..0000000
--- a/softfloat/i32_to_f64.c
+++ /dev/null
@@ -1,31 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-float64_t i32_to_f64( int_fast32_t a )

-{

-    uint_fast64_t uiZ;

-    bool sign;

-    uint_fast32_t absA;

-    int shiftCount;

-    union ui64_f64 uZ;

-

-    if ( ! a ) {

-        uiZ = 0;

-    } else {

-        sign = ( a < 0 );

-        absA = sign ? - a : a;

-        shiftCount = softfloat_countLeadingZeros32( absA ) + 21;

-        uiZ =

-            packToF64UI(

-                sign, 0x432 - shiftCount, (uint_fast64_t) absA<<shiftCount );

-    }

-    uZ.ui = uiZ;

-    return uZ.f;

-

-}

-

diff --git a/softfloat/i64_to_f32.c b/softfloat/i64_to_f32.c
deleted file mode 100755
index 4fecbb9..0000000
--- a/softfloat/i64_to_f32.c
+++ /dev/null
@@ -1,36 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-float32_t i64_to_f32( int_fast64_t a )

-{

-    bool sign;

-    uint_fast64_t absA;

-    int shiftCount;

-    union ui32_f32 u;

-    uint_fast32_t sig;

-

-    sign = ( a < 0 );

-    absA = sign ? - (uint_fast64_t) a : a;

-    shiftCount = softfloat_countLeadingZeros64( absA ) - 40;

-    if ( 0 <= shiftCount ) {

-        u.ui =

-            a ? packToF32UI(

-                    sign, 0x95 - shiftCount, (uint_fast32_t) absA<<shiftCount )

-                : 0;

-        return u.f;

-    } else {

-        shiftCount += 7;

-        sig =

-            ( shiftCount < 0 )

-                ? softfloat_shortShift64RightJam( absA, - shiftCount )

-                : (uint_fast32_t) absA<<shiftCount;

-        return softfloat_roundPackToF32( sign, 0x9C - shiftCount, sig );

-    }

-

-}

-

diff --git a/softfloat/i64_to_f64.c b/softfloat/i64_to_f64.c
deleted file mode 100755
index 1add960..0000000
--- a/softfloat/i64_to_f64.c
+++ /dev/null
@@ -1,21 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "softfloat.h"

-

-float64_t i64_to_f64( int_fast64_t a )

-{

-    bool sign;

-    union ui64_f64 uZ;

-

-    sign = ( a < 0 );

-    if ( ! ( a & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) ) {

-        uZ.ui = sign ? packToF64UI( 1, 0x43E, 0 ) : 0;

-        return uZ.f;

-    }

-    return softfloat_normRoundPackToF64( sign, 0x43C, sign ? - a : a );

-

-}

-

diff --git a/softfloat/internals.h b/softfloat/internals.h
deleted file mode 100755
index 5e6fd76..0000000
--- a/softfloat/internals.h
+++ /dev/null
@@ -1,232 +0,0 @@
-

-/*** UPDATE COMMENTS. ***/

-

-#include "softfloat_types.h"

-

-union ui32_f32 { uint32_t ui; float32_t f; };

-union ui64_f64 { uint64_t ui; float64_t f; };

-#ifdef LITTLEENDIAN

-union ui128_f128 { uint64_t ui0, ui64; float128_t f; };

-#else

-union ui128_f128 { uint64_t ui64, ui0; float128_t f; };

-#endif

-

-enum {

-    softfloat_mulAdd_subC    = 1,

-    softfloat_mulAdd_subProd = 2

-};

-

-uint_fast32_t

- softfloat_roundPackToUI32( bool, uint_fast64_t, int_fast8_t, bool );

-uint_fast64_t

- softfloat_roundPackToUI64(

-     bool, uint_fast64_t, uint_fast64_t, int_fast8_t, bool );

-/*----------------------------------------------------------------------------

-| Takes a 64-bit fixed-point value `absZ' with binary point between bits 6

-| and 7, and returns the properly rounded 32-bit integer corresponding to the

-| input.  If `zSign' is 1, the input is negated before being converted to an

-| integer.  Bit 63 of `absZ' must be zero.  Ordinarily, the fixed-point input

-| is simply rounded to an integer, with the inexact exception raised if the

-| input cannot be represented exactly as an integer.  However, if the fixed-

-| point input is too large, the invalid exception is raised and the largest

-| positive or negative integer is returned.

-*----------------------------------------------------------------------------*/

-int_fast32_t

- softfloat_roundPackToI32( bool, uint_fast64_t, int_fast8_t, bool );

-/*----------------------------------------------------------------------------

-| Takes the 128-bit fixed-point value formed by concatenating `absZ0' and

-| `absZ1', with binary point between bits 63 and 64 (between the input words),

-| and returns the properly rounded 64-bit integer corresponding to the input.

-| If `zSign' is 1, the input is negated before being converted to an integer.

-| Ordinarily, the fixed-point input is simply rounded to an integer, with

-| the inexact exception raised if the input cannot be represented exactly as

-| an integer.  However, if the fixed-point input is too large, the invalid

-| exception is raised and the largest positive or negative integer is

-| returned.

-*----------------------------------------------------------------------------*/

-int_fast64_t

- softfloat_roundPackToI64(

-     bool, uint_fast64_t, uint_fast64_t, int_fast8_t, bool );

-

-/*----------------------------------------------------------------------------

-| Returns 1 if the single-precision floating-point value `a' is a NaN;

-| otherwise, returns 0.

-*----------------------------------------------------------------------------*/

-#define isNaNF32UI( ui ) (0xFF000000<(uint32_t)((uint_fast32_t)(ui)<<1))

-/*----------------------------------------------------------------------------

-| Returns the sign bit of the single-precision floating-point value `a'.

-*----------------------------------------------------------------------------*/

-#define signF32UI( a ) ((bool)((uint32_t)(a)>>31))

-/*----------------------------------------------------------------------------

-| Returns the exponent bits of the single-precision floating-point value `a'.

-*----------------------------------------------------------------------------*/

-#define expF32UI( a ) ((int_fast16_t)((a)>>23)&0xFF)

-/*----------------------------------------------------------------------------

-| Returns the fraction bits of the single-precision floating-point value `a'.

-*----------------------------------------------------------------------------*/

-#define fracF32UI( a ) ((a)&0x007FFFFF)

-/*----------------------------------------------------------------------------

-| Packs the sign `zSign', exponent `zExp', and significand `zSig' into a

-| single-precision floating-point value, returning the result.  After being

-| shifted into the proper positions, the three fields are simply added

-| together to form the result.  This means that any integer portion of `zSig'

-| will be added into the exponent.  Since a properly normalized significand

-| will have an integer portion equal to 1, the `zExp' input should be 1 less

-| than the desired result exponent whenever `zSig' is a complete, normalized

-| significand.

-*----------------------------------------------------------------------------*/

-#define packToF32UI( sign, exp, sig ) (((uint32_t)(sign)<<31)+((uint32_t)(exp)<<23)+(sig))

-

-/*----------------------------------------------------------------------------

-| Normalizes the subnormal single-precision floating-point value represented

-| by the denormalized significand `aSig'.  The normalized exponent and

-| significand are stored at the locations pointed to by `zExpPtr' and

-| `zSigPtr', respectively.

-*----------------------------------------------------------------------------*/

-struct exp16_sig32 { int_fast16_t exp; uint_fast32_t sig; };

-struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t );

-

-/*----------------------------------------------------------------------------

-| Takes an abstract floating-point value having sign `zSign', exponent `zExp',

-| and significand `zSig', and returns the proper single-precision floating-

-| point value corresponding to the abstract input.  Ordinarily, the abstract

-| value is simply rounded and packed into the single-precision format, with

-| the inexact exception raised if the abstract input cannot be represented

-| exactly.  However, if the abstract value is too large, the overflow and

-| inexact exceptions are raised and an infinity or maximal finite value is

-| returned.  If the abstract value is too small, the input value is rounded to

-| a subnormal number, and the underflow and inexact exceptions are raised if

-| the abstract input cannot be represented exactly as a subnormal single-

-| precision floating-point number.

-|     The input significand `zSig' has its binary point between bits 30

-| and 29, which is 7 bits to the left of the usual location.  This shifted

-| significand must be normalized or smaller.  If `zSig' is not normalized,

-| `zExp' must be 0; in that case, the result returned is a subnormal number,

-| and it must not require rounding.  In the usual case that `zSig' is

-| normalized, `zExp' must be 1 less than the ``true'' floating-point exponent.

-| The handling of underflow and overflow follows the IEC/IEEE Standard for

-| Binary Floating-Point Arithmetic.

-*----------------------------------------------------------------------------*/

-float32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t );

-/*----------------------------------------------------------------------------

-| Takes an abstract floating-point value having sign `zSign', exponent `zExp',

-| and significand `zSig', and returns the proper single-precision floating-

-| point value corresponding to the abstract input.  This routine is just like

-| `roundAndPackFloat32' except that `zSig' does not have to be normalized.

-| Bit 31 of `zSig' must be zero, and `zExp' must be 1 less than the ``true''

-| floating-point exponent.

-*----------------------------------------------------------------------------*/

-float32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t );

-

-/*----------------------------------------------------------------------------

-| Returns the result of adding the absolute values of the single-precision

-| floating-point values `a' and `b'.  If `zSign' is 1, the sum is negated

-| before being returned.  `zSign' is ignored if the result is a NaN.

-| The addition is performed according to the IEC/IEEE Standard for Binary

-| Floating-Point Arithmetic.

-*----------------------------------------------------------------------------*/

-float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t, bool );

-/*----------------------------------------------------------------------------

-| Returns the result of subtracting the absolute values of the single-

-| precision floating-point values `a' and `b'.  If `zSign' is 1, the

-| difference is negated before being returned.  `zSign' is ignored if the

-| result is a NaN.  The subtraction is performed according to the IEC/IEEE

-| Standard for Binary Floating-Point Arithmetic.

-*----------------------------------------------------------------------------*/

-float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t, bool );

-/*----------------------------------------------------------------------------

-*----------------------------------------------------------------------------*/

-float32_t

- softfloat_mulAddF32( int, uint_fast32_t, uint_fast32_t, uint_fast32_t );

-

-/*----------------------------------------------------------------------------

-| Returns 1 if the double-precision floating-point value `a' is a NaN;

-| otherwise, returns 0.

-*----------------------------------------------------------------------------*/

-#define isNaNF64UI( ui ) (UINT64_C(0xFFE0000000000000)<(uint64_t)((uint_fast64_t)(ui)<<1))

-/*----------------------------------------------------------------------------

-| Returns the sign bit of the double-precision floating-point value `a'.

-*----------------------------------------------------------------------------*/

-#define signF64UI( a ) ((bool)((uint64_t)(a)>>63))

-/*----------------------------------------------------------------------------

-| Returns the exponent bits of the double-precision floating-point value `a'.

-*----------------------------------------------------------------------------*/

-#define expF64UI( a ) ((int_fast16_t)((a)>>52)&0x7FF)

-/*----------------------------------------------------------------------------

-| Returns the fraction bits of the double-precision floating-point value `a'.

-*----------------------------------------------------------------------------*/

-#define fracF64UI( a ) ((a)&UINT64_C(0x000FFFFFFFFFFFFF))

-/*----------------------------------------------------------------------------

-| Packs the sign `zSign', exponent `zExp', and significand `zSig' into a

-| double-precision floating-point value, returning the result.  After being

-| shifted into the proper positions, the three fields are simply added

-| together to form the result.  This means that any integer portion of `zSig'

-| will be added into the exponent.  Since a properly normalized significand

-| will have an integer portion equal to 1, the `zExp' input should be 1 less

-| than the desired result exponent whenever `zSig' is a complete, normalized

-| significand.

-*----------------------------------------------------------------------------*/

-#define packToF64UI( sign, exp, sig ) (((uint64_t)(sign)<<63)+((uint64_t)(exp)<<52)+(sig))

-

-/*----------------------------------------------------------------------------

-| Normalizes the subnormal double-precision floating-point value represented

-| by the denormalized significand `aSig'.  The normalized exponent and

-| significand are stored at the locations pointed to by `zExpPtr' and

-| `zSigPtr', respectively.

-*----------------------------------------------------------------------------*/

-struct exp16_sig64 { int_fast16_t exp; uint_fast64_t sig; };

-struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t );

-

-/*----------------------------------------------------------------------------

-| Takes an abstract floating-point value having sign `zSign', exponent `zExp',

-| and significand `zSig', and returns the proper double-precision floating-

-| point value corresponding to the abstract input.  Ordinarily, the abstract

-| value is simply rounded and packed into the double-precision format, with

-| the inexact exception raised if the abstract input cannot be represented

-| exactly.  However, if the abstract value is too large, the overflow and

-| inexact exceptions are raised and an infinity or maximal finite value is

-| returned.  If the abstract value is too small, the input value is rounded

-| to a subnormal number, and the underflow and inexact exceptions are raised

-| if the abstract input cannot be represented exactly as a subnormal double-

-| precision floating-point number.

-|     The input significand `zSig' has its binary point between bits 62

-| and 61, which is 10 bits to the left of the usual location.  This shifted

-| significand must be normalized or smaller.  If `zSig' is not normalized,

-| `zExp' must be 0; in that case, the result returned is a subnormal number,

-| and it must not require rounding.  In the usual case that `zSig' is

-| normalized, `zExp' must be 1 less than the ``true'' floating-point exponent.

-| The handling of underflow and overflow follows the IEC/IEEE Standard for

-| Binary Floating-Point Arithmetic.

-*----------------------------------------------------------------------------*/

-float64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t );

-/*----------------------------------------------------------------------------

-| Takes an abstract floating-point value having sign `zSign', exponent `zExp',

-| and significand `zSig', and returns the proper double-precision floating-

-| point value corresponding to the abstract input.  This routine is just like

-| `roundAndPackFloat64' except that `zSig' does not have to be normalized.

-| Bit 63 of `zSig' must be zero, and `zExp' must be 1 less than the ``true''

-| floating-point exponent.

-*----------------------------------------------------------------------------*/

-float64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t );

-

-/*----------------------------------------------------------------------------

-| Returns the result of adding the absolute values of the double-precision

-| floating-point values `a' and `b'.  If `zSign' is 1, the sum is negated

-| before being returned.  `zSign' is ignored if the result is a NaN.

-| The addition is performed according to the IEC/IEEE Standard for Binary

-| Floating-Point Arithmetic.

-*----------------------------------------------------------------------------*/

-float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool );

-/*----------------------------------------------------------------------------

-| Returns the result of subtracting the absolute values of the double-

-| precision floating-point values `a' and `b'.  If `zSign' is 1, the

-| difference is negated before being returned.  `zSign' is ignored if the

-| result is a NaN.  The subtraction is performed according to the IEC/IEEE

-| Standard for Binary Floating-Point Arithmetic.

-*----------------------------------------------------------------------------*/

-float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool );

-/*----------------------------------------------------------------------------

-*----------------------------------------------------------------------------*/

-float64_t

- softfloat_mulAddF64( int, uint_fast64_t, uint_fast64_t, uint_fast64_t );

-

diff --git a/softfloat/primitives.h b/softfloat/primitives.h
deleted file mode 100755
index 71038ea..0000000
--- a/softfloat/primitives.h
+++ /dev/null
@@ -1,628 +0,0 @@
-
-/*============================================================================
-
-This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
-Arithmetic Package, Release 3.
-
-*** UPDATE
-
-Written by John R. Hauser.  This work was made possible in part by the
-International Computer Science Institute, located at Suite 600, 1947 Center
-Street, Berkeley, California 94704.  Funding was partially provided by the
-National Science Foundation under grant MIP-9311980.  The original version
-of this code was written as part of a project to build a fixed-point vector
-processor in collaboration with the University of California at Berkeley,
-overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
-is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
-arithmetic/SoftFloat.html'.
-
-THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
-been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
-RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
-AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
-COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
-EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
-INSTITUTE (possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR
-OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
-
-Derivative works are acceptable, even for commercial purposes, so long as
-(1) the source code for the derivative work includes prominent notice that
-the work is derivative, and (2) the source code includes prominent notice with
-these four paragraphs for those parts of this code that are retained.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-
-/*** CHANGE TO USE `fast' INTEGER TYPES? ***/
-/*** ADD 80-BIT FUNCTIONS? ***/
-
-#ifdef LITTLEENDIAN
-struct uintx80 { uint64_t v0; uint16_t v64; };
-struct uint128 { uint64_t v0, v64; };
-struct uint192 { uint64_t v0, v64, v128; };
-struct uint256 { uint64_t v0, v64, v128, v192; };
-#else
-struct uintx80 { uint16_t v64; uint64_t v0; };
-struct uint128 { uint64_t v64, v0; };
-struct uint192 { uint64_t v128, v64, v0; };
-struct uint256 { uint64_t v256, v128, v64, v0; };
-#endif
-
-struct uint64_extra { uint64_t v, extra; };
-struct uint128_extra { uint64_t v64; uint64_t v0; uint64_t extra; };
-
-
-/*** SHIFT COUNTS CANNOT BE ZERO.  MUST CHECK BEFORE CALLING! ***/
-
-
-/*----------------------------------------------------------------------------
-| Returns 1 if the 128-bit value formed by concatenating `a0' and `a1'
-| is equal to the 128-bit value formed by concatenating `b0' and `b1'.
-| Otherwise, returns 0.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 1 <= INLINE_LEVEL )
-INLINE bool
- softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-    { return ( a64 == b64 ) && ( a0 == b0 ); }
-#else
-bool softfloat_eq128( uint64_t, uint64_t, uint64_t, uint64_t );
-#endif
-
-/*----------------------------------------------------------------------------
-| Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
-| than or equal to the 128-bit value formed by concatenating `b0' and `b1'.
-| Otherwise, returns 0.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 1 <= INLINE_LEVEL )
-INLINE bool
- softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-    { return ( a64 < b64 ) || ( ( a64 == b64 ) && ( a0 <= b0 ) ); }
-#else
-bool softfloat_le128( uint64_t, uint64_t, uint64_t, uint64_t );
-#endif
-
-/*----------------------------------------------------------------------------
-| Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
-| than the 128-bit value formed by concatenating `b0' and `b1'.  Otherwise,
-| returns 0.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 1 <= INLINE_LEVEL )
-INLINE bool
- softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-    { return ( a64 < b64 ) || ( ( a64 == b64 ) && ( a0 < b0 ) ); }
-#else
-bool softfloat_lt128( uint64_t, uint64_t, uint64_t, uint64_t );
-#endif
-
-/*----------------------------------------------------------------------------
-| Shifts the 128-bit value formed by concatenating `a0' and `a1' left by the
-| number of bits given in `count'.  Any bits shifted off are lost.  The value
-| of `count' must be less than 64.  The result is broken into two 64-bit
-| pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 2 <= INLINE_LEVEL )
-INLINE struct uint128
- softfloat_shortShift128Left( uint64_t a64, uint64_t a0, unsigned int count )
-{
-    struct uint128 z;
-    z.v64 = a64<<count | a0>>( ( - count ) & 63 );
-    z.v0 = a0<<count;
-    return z;
-}
-#else
-struct uint128 softfloat_shortShift128Left( uint64_t, uint64_t, unsigned int );
-#endif
-
-/*----------------------------------------------------------------------------
-| Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' left
-| by the number of bits given in `count'.  Any bits shifted off are lost.
-| The value of `count' must be less than 64.  The result is broken into three
-| 64-bit pieces which are stored at the locations pointed to by `z0Ptr',
-| `z1Ptr', and `z2Ptr'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 3 <= INLINE_LEVEL )
-INLINE struct uint192
- softfloat_shortShift192Left(
-     uint64_t a128, uint64_t a64, uint64_t a0, unsigned int count )
-{
-    unsigned int negCount = - count;
-    struct uint192 z;
-    z.v128 = a128<<count | a64>>( negCount & 63 );
-    z.v64 = a64<<count | a0>>( negCount & 63 );
-    z.v0 = a0<<count;
-    return z;
-}
-#else
-struct uint192
- softfloat_shortShift192Left( uint64_t, uint64_t, uint64_t, unsigned int );
-#endif
-
-/*----------------------------------------------------------------------------
-| Shifts `a' right by the number of bits given in `count'.  If any nonzero
-| bits are shifted off, they are ``jammed'' into the least significant bit of
-| the result by setting the least significant bit to 1.  The value of `count'
-| can be arbitrarily large; in particular, if `count' is greater than 32, the
-| result will be either 0 or 1, depending on whether `a' is zero or nonzero.
-| The result is stored in the location pointed to by `zPtr'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 2 <= INLINE_LEVEL )
-INLINE uint32_t softfloat_shift32RightJam( uint32_t a, unsigned int count )
-{
-    return
-        ( count < 32 )
-            ? a>>count | ( (uint32_t) ( a<<( ( - count ) & 31 ) ) != 0 )
-            : ( a != 0 );
-}
-#else
-uint32_t softfloat_shift32RightJam( uint32_t, unsigned int );
-#endif
-
-/*----------------------------------------------------------------------------
-| Shift count is less than 32.
-*----------------------------------------------------------------------------*/
-#if defined INLINE
-INLINE uint32_t softfloat_shortShift32Right1Jam( uint32_t a )
-    { return a>>1 | ( a & 1 ); }
-#else
-uint32_t softfloat_shortShift32Right1Jam( uint32_t );
-#endif
-
-/*----------------------------------------------------------------------------
-| Shifts `a' right by the number of bits given in `count'.  If any nonzero
-| bits are shifted off, they are ``jammed'' into the least significant bit of
-| the result by setting the least significant bit to 1.  The value of `count'
-| can be arbitrarily large; in particular, if `count' is greater than 64, the
-| result will be either 0 or 1, depending on whether `a' is zero or nonzero.
-| The result is stored in the location pointed to by `zPtr'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 3 <= INLINE_LEVEL )
-INLINE uint64_t softfloat_shift64RightJam( uint64_t a, unsigned int count )
-{
-    return
-        ( count < 64 )
-            ? a>>count | ( (uint64_t) ( a<<( ( - count ) & 63 ) ) != 0 )
-            : ( a != 0 );
-}
-#else
-uint64_t softfloat_shift64RightJam( uint64_t, unsigned int );
-#endif
-
-/*----------------------------------------------------------------------------
-| Shift count is less than 64.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 2 <= INLINE_LEVEL )
-INLINE uint64_t
- softfloat_shortShift64RightJam( uint64_t a, unsigned int count )
-    { return a>>count | ( ( a & ( ( (uint64_t) 1<<count ) - 1 ) ) != 0 ); }
-#else
-uint64_t softfloat_shortShift64RightJam( uint64_t, unsigned int );
-#endif
-
-/*----------------------------------------------------------------------------
-| Shifts the 128-bit value formed by concatenating `a0' and `a1' right by 64
-| _plus_ the number of bits given in `count'.  The shifted result is at most
-| 64 nonzero bits; this is stored at the location pointed to by `z0Ptr'.  The
-| bits shifted off form a second 64-bit result as follows:  The _last_ bit
-| shifted off is the most-significant bit of the extra result, and the other
-| 63 bits of the extra result are all zero if and only if _all_but_the_last_
-| bits shifted off were all zero.  This extra result is stored in the location
-| pointed to by `z1Ptr'.  The value of `count' can be arbitrarily large.
-|     (This routine makes more sense if `a0' and `a1' are considered to form
-| a fixed-point value with binary point between `a0' and `a1'.  This fixed-
-| point value is shifted right by the number of bits given in `count', and
-| the integer part of the result is returned at the location pointed to by
-| `z0Ptr'.  The fractional part of the result may be slightly corrupted as
-| described above, and is returned at the location pointed to by `z1Ptr'.)
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 3 <= INLINE_LEVEL )
-INLINE struct uint64_extra
- softfloat_shift64ExtraRightJam(
-     uint64_t a, uint64_t extra, unsigned int count )
-{
-    struct uint64_extra z;
-    if ( count < 64 ) {
-        z.v = a>>count;
-        z.extra = a<<( ( - count ) & 63 );
-    } else {
-        z.v = 0;
-        z.extra = ( count == 64 ) ? a : ( a != 0 );
-    }
-    z.extra |= ( extra != 0 );
-    return z;
-}
-#else
-struct uint64_extra
- softfloat_shift64ExtraRightJam( uint64_t, uint64_t, unsigned int );
-#endif
-
-/*----------------------------------------------------------------------------
-| Shift count is less than 64.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 2 <= INLINE_LEVEL )
-INLINE struct uint64_extra
- softfloat_shortShift64ExtraRightJam(
-     uint64_t a, uint64_t extra, unsigned int count )
-{
-    struct uint64_extra z;
-    z.v = a>>count;
-    z.extra = a<<( ( - count ) & 63 ) | ( extra != 0 );
-    return z;
-}
-#else
-struct uint64_extra
- softfloat_shortShift64ExtraRightJam( uint64_t, uint64_t, unsigned int );
-#endif
-
-/*----------------------------------------------------------------------------
-| Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
-| number of bits given in `count'.  Any bits shifted off are lost.  The value
-| of `count' can be arbitrarily large; in particular, if `count' is greater
-| than 128, the result will be 0.  The result is broken into two 64-bit pieces
-| which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
-*----------------------------------------------------------------------------*/
-/*----------------------------------------------------------------------------
-| Shift count is less than 64.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 2 <= INLINE_LEVEL )
-INLINE struct uint128
- softfloat_shortShift128Right( uint64_t a64, uint64_t a0, unsigned int count )
-{
-    struct uint128 z;
-    z.v64 = a64>>count;
-    z.v0 = a64<<( ( - count ) & 63 ) | a0>>count;
-    return z;
-}
-#else
-struct uint128
- softfloat_shortShift128Right( uint64_t, uint64_t, unsigned int );
-#endif
-
-/*----------------------------------------------------------------------------
-| Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
-| number of bits given in `count'.  If any nonzero bits are shifted off, they
-| are ``jammed'' into the least significant bit of the result by setting the
-| least significant bit to 1.  The value of `count' can be arbitrarily large;
-| in particular, if `count' is greater than 128, the result will be either
-| 0 or 1, depending on whether the concatenation of `a0' and `a1' is zero or
-| nonzero.  The result is broken into two 64-bit pieces which are stored at
-| the locations pointed to by `z0Ptr' and `z1Ptr'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 4 <= INLINE_LEVEL )
-INLINE struct uint128
- softfloat_shift128RightJam( uint64_t a64, uint64_t a0, unsigned int count )
-{
-    unsigned int negCount;
-    struct uint128 z;
-    if ( count < 64 ) {
-        negCount = - count;
-        z.v64 = a64>>( count & 63 );
-        z.v0 =
-            a64<<( negCount & 63 ) | a0>>count
-                | ( (uint64_t) ( a0<<( negCount & 63 ) ) != 0 );
-    } else {
-        z.v64 = 0;
-        z.v0 =
-            ( count < 128 )
-                ? a64>>( count & 63 )
-                      | ( ( ( a64 & ( ( (uint64_t) 1<<( count & 63 ) ) - 1 ) )
-                                | a0 )
-                              != 0 )
-                : ( ( a64 | a0 ) != 0 );
-    }
-    return z;
-}
-#else
-struct uint128
- softfloat_shift128RightJam( uint64_t, uint64_t, unsigned int );
-#endif
-
-/*----------------------------------------------------------------------------
-| Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' right
-| by 64 _plus_ the number of bits given in `count'.  The shifted result is
-| at most 128 nonzero bits; these are broken into two 64-bit pieces which are
-| stored at the locations pointed to by `z0Ptr' and `z1Ptr'.  The bits shifted
-| off form a third 64-bit result as follows:  The _last_ bit shifted off is
-| the most-significant bit of the extra result, and the other 63 bits of the
-| extra result are all zero if and only if _all_but_the_last_ bits shifted off
-| were all zero.  This extra result is stored in the location pointed to by
-| `z2Ptr'.  The value of `count' can be arbitrarily large.
-|     (This routine makes more sense if `a0', `a1', and `a2' are considered
-| to form a fixed-point value with binary point between `a1' and `a2'.  This
-| fixed-point value is shifted right by the number of bits given in `count',
-| and the integer part of the result is returned at the locations pointed to
-| by `z0Ptr' and `z1Ptr'.  The fractional part of the result may be slightly
-| corrupted as described above, and is returned at the location pointed to by
-| `z2Ptr'.)
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 5 <= INLINE_LEVEL )
-INLINE struct uint128_extra
- softfloat_shift128ExtraRightJam(
-     uint64_t a64, uint64_t a0, uint64_t extra, unsigned int count )
-{
-    unsigned int negCount = - count;
-    struct uint128_extra z;
-    if ( count < 64 ) {
-        z.v64 = a64>>count;
-        z.v0 = a64<<( negCount & 63 ) | a0>>count;
-        z.extra = a0<<( negCount & 63 );
-    } else {
-        z.v64 = 0;
-        if ( count == 64 ) {
-            z.v0 = a64;
-            z.extra = a0;
-        } else {
-            extra |= a0;
-            if ( count < 128 ) {
-                z.v0 = a64>>( count & 63 );
-                z.extra = a64<<( negCount & 63 );
-            } else {
-                z.v0 = 0;
-                z.extra = ( count == 128 ) ? a64 : ( a64 != 0 );
-            }
-        }
-    }
-    z.extra |= ( extra != 0 );
-    return z;
-}
-#else
-struct uint128_extra
- softfloat_shift128ExtraRightJam( uint64_t, uint64_t, uint64_t, unsigned int );
-#endif
-
-/*----------------------------------------------------------------------------
-| Shift count is less than 64.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 3 <= INLINE_LEVEL )
-INLINE struct uint128_extra
- softfloat_shortShift128ExtraRightJam(
-     uint64_t a64, uint64_t a0, uint64_t extra, unsigned int count )
-{
-    unsigned int negCount = - count;
-    struct uint128_extra z;
-    z.v64 = a64>>count;
-    z.v0 = a64<<( negCount & 63 ) | a0>>count;
-    z.extra = a0<<( negCount & 63 ) | ( extra != 0 );
-    return z;
-}
-#else
-struct uint128_extra
- softfloat_shortShift128ExtraRightJam(
-     uint64_t, uint64_t, uint64_t, unsigned int );
-#endif
-
-extern const uint8_t softfloat_countLeadingZeros8[ 256 ];
-
-/*----------------------------------------------------------------------------
-| Returns the number of leading 0 bits before the most-significant 1 bit of
-| `a'.  If `a' is zero, 32 is returned.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 2 <= INLINE_LEVEL )
-INLINE int softfloat_countLeadingZeros32( uint32_t a )
-{
-    int count = 0;
-    if ( a < 0x10000 ) {
-        count = 16;
-        a <<= 16;
-    }
-    if ( a < 0x1000000 ) {
-        count += 8;
-        a <<= 8;
-    }
-    count += softfloat_countLeadingZeros8[ a>>24 ];
-    return count;
-}
-#else
-int softfloat_countLeadingZeros32( uint32_t );
-#endif
-
-/*----------------------------------------------------------------------------
-| Returns the number of leading 0 bits before the most-significant 1 bit of
-| `a'.  If `a' is zero, 64 is returned.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 4 <= INLINE_LEVEL )
-INLINE int softfloat_countLeadingZeros64( uint64_t a )
-{
-    int count = 32;
-    uint32_t a32 = a;
-    if ( UINT64_C( 0x100000000 ) <= a ) {
-        count = 0;
-        a32 = a>>32;
-    }
-    /*------------------------------------------------------------------------
-    | From here, result is current count + count leading zeros of `a32'.
-    *------------------------------------------------------------------------*/
-    if ( a32 < 0x10000 ) {
-        count += 16;
-        a32 <<= 16;
-    }
-    if ( a32 < 0x1000000 ) {
-        count += 8;
-        a32 <<= 8;
-    }
-    count += softfloat_countLeadingZeros8[ a32>>24 ];
-    return count;
-}
-#else
-int softfloat_countLeadingZeros64( uint64_t );
-#endif
-
-/*----------------------------------------------------------------------------
-| Adds the 128-bit value formed by concatenating `a0' and `a1' to the 128-bit
-| value formed by concatenating `b0' and `b1'.  Addition is modulo 2^128, so
-| any carry out is lost.  The result is broken into two 64-bit pieces which
-| are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 2 <= INLINE_LEVEL )
-INLINE struct uint128
- softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-{
-    struct uint128 z;
-    z.v0 = a0 + b0;
-    z.v64 = a64 + b64;
-    z.v64 += ( z.v0 < a0 );
-    return z;
-}
-#else
-struct uint128 softfloat_add128( uint64_t, uint64_t, uint64_t, uint64_t );
-#endif
-
-/*----------------------------------------------------------------------------
-| Adds the 192-bit value formed by concatenating `a0', `a1', and `a2' to the
-| 192-bit value formed by concatenating `b0', `b1', and `b2'.  Addition is
-| modulo 2^192, so any carry out is lost.  The result is broken into three
-| 64-bit pieces which are stored at the locations pointed to by `z0Ptr',
-| `z1Ptr', and `z2Ptr'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 3 <= INLINE_LEVEL )
-INLINE struct uint192
- softfloat_add192(
-     uint64_t a128,
-     uint64_t a64,
-     uint64_t a0,
-     uint64_t b128,
-     uint64_t b64,
-     uint64_t b0
- )
-{
-    struct uint192 z;
-    unsigned int carry64, carry128;
-    z.v0 = a0 + b0;
-    carry64 = ( z.v0 < a0 );
-    z.v64 = a64 + b64;
-    carry128 = ( z.v64 < a64 );
-    z.v128 = a128 + b128;
-    z.v64 += carry64;
-    carry128 += ( z.v64 < carry64 );
-    z.v128 += carry128;
-    return z;
-}
-#else
-struct uint192
- softfloat_add192(
-     uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t );
-#endif
-
-/*----------------------------------------------------------------------------
-| Subtracts the 128-bit value formed by concatenating `b0' and `b1' from the
-| 128-bit value formed by concatenating `a0' and `a1'.  Subtraction is modulo
-| 2^128, so any borrow out (carry out) is lost.  The result is broken into two
-| 64-bit pieces which are stored at the locations pointed to by `z0Ptr' and
-| `z1Ptr'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 2 <= INLINE_LEVEL )
-INLINE struct uint128
- softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-{
-    struct uint128 z;
-    z.v0 = a0 - b0;
-    z.v64 = a64 - b64;
-    z.v64 -= ( a0 < b0 );
-    return z;
-}
-#else
-struct uint128 softfloat_sub128( uint64_t, uint64_t, uint64_t, uint64_t );
-#endif
-
-/*----------------------------------------------------------------------------
-| Subtracts the 192-bit value formed by concatenating `b0', `b1', and `b2'
-| from the 192-bit value formed by concatenating `a0', `a1', and `a2'.
-| Subtraction is modulo 2^192, so any borrow out (carry out) is lost.  The
-| result is broken into three 64-bit pieces which are stored at the locations
-| pointed to by `z0Ptr', `z1Ptr', and `z2Ptr'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 3 <= INLINE_LEVEL )
-INLINE struct uint192
- softfloat_sub192(
-     uint64_t a128,
-     uint64_t a64,
-     uint64_t a0,
-     uint64_t b128,
-     uint64_t b64,
-     uint64_t b0
- )
-{
-    struct uint192 z;
-    unsigned int borrow64, borrow128;
-    z.v0 = a0 - b0;
-    borrow64 = ( a0 < b0 );
-    z.v64 = a64 - b64;
-    borrow128 = ( a64 < b64 );
-    z.v128 = a128 - b128;
-    borrow128 += ( z.v64 < borrow64 );
-    z.v64 -= borrow64;
-    z.v128 -= borrow128;
-    return z;
-}
-#else
-struct uint192
- softfloat_sub192(
-     uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t );
-#endif
-
-/*----------------------------------------------------------------------------
-| Multiplies `a' by `b' to obtain a 128-bit product.  The product is broken
-| into two 64-bit pieces which are stored at the locations pointed to by
-| `z0Ptr' and `z1Ptr'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && ( 4 <= INLINE_LEVEL )
-INLINE struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b )
-{
-    uint32_t a32 = a>>32;
-    uint32_t a0 = a;
-    uint32_t b32 = b>>32;
-    uint32_t b0 = b;
-    struct uint128 z;
-    uint64_t mid1, mid2, mid;
-    z.v0 = (uint64_t) a0 * b0;
-    mid1 = (uint64_t) a32 * b0;
-    mid2 = (uint64_t) a0 * b32;
-    z.v64 = (uint64_t) a32 * b32;
-    mid = mid1 + mid2;
-    z.v64 += ( (uint64_t) ( mid < mid1 ) )<<32 | mid>>32;
-    mid <<= 32;
-    z.v0 += mid;
-    z.v64 += ( z.v0 < mid );
-    return z;
-}
-#else
-struct uint128 softfloat_mul64To128( uint64_t, uint64_t );
-#endif
-
-/*----------------------------------------------------------------------------
-| Multiplies the 128-bit value formed by concatenating `a0' and `a1' by
-| `b' to obtain a 192-bit product.  The product is broken into three 64-bit
-| pieces which are stored at the locations pointed to by `z0Ptr', `z1Ptr', and
-| `z2Ptr'.
-*----------------------------------------------------------------------------*/
-struct uint192 softfloat_mul128By64To192( uint64_t, uint64_t, uint64_t );
-/*----------------------------------------------------------------------------
-| Multiplies the 128-bit value formed by concatenating `a0' and `a1' to the
-| 128-bit value formed by concatenating `b0' and `b1' to obtain a 256-bit
-| product.  The product is broken into four 64-bit pieces which are stored at
-| the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'.
-*----------------------------------------------------------------------------*/
-struct uint256 softfloat_mul128To256( uint64_t, uint64_t, uint64_t, uint64_t );
-
-/*----------------------------------------------------------------------------
-| Returns an approximation to the 64-bit integer quotient obtained by dividing
-| `b' into the 128-bit value formed by concatenating `a0' and `a1'.  The
-| divisor `b' must be at least 2^63.  If q is the exact quotient truncated
-| toward zero, the approximation returned lies between q and q + 2 inclusive.
-| If the exact quotient q is larger than 64 bits, the maximum positive 64-bit
-| unsigned integer is returned.
-*----------------------------------------------------------------------------*/
-uint64_t softfloat_estimateDiv128To64( uint64_t, uint64_t, uint64_t );
-
-/*----------------------------------------------------------------------------
-| Returns an approximation to the square root of the 32-bit significand given
-| by `a'.  Considered as an integer, `a' must be at least 2^31.  If bit 0 of
-| `aExp' (the least significant bit) is 1, the integer returned approximates
-| 2^31*sqrt(`a'/2^31), where `a' is considered an integer.  If bit 0 of `aExp'
-| is 0, the integer returned approximates 2^31*sqrt(`a'/2^30).  In either
-| case, the approximation returned lies strictly within +/-2 of the exact
-| value.
-*----------------------------------------------------------------------------*/
-uint32_t softfloat_estimateSqrt32( unsigned int, uint32_t );
-
diff --git a/softfloat/s_add128.c b/softfloat/s_add128.c
deleted file mode 100755
index 59c0348..0000000
--- a/softfloat/s_add128.c
+++ /dev/null
@@ -1,17 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint128

- softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )

-{

-    struct uint128 z;

-

-    z.v0 = a0 + b0;

-    z.v64 = a64 + b64;

-    z.v64 += ( z.v0 < a0 );

-    return z;

-

-}

-

diff --git a/softfloat/s_add192.c b/softfloat/s_add192.c
deleted file mode 100755
index 543eb5d..0000000
--- a/softfloat/s_add192.c
+++ /dev/null
@@ -1,30 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint192

- softfloat_add192(

-     uint64_t a128,

-     uint64_t a64,

-     uint64_t a0,

-     uint64_t b128,

-     uint64_t b64,

-     uint64_t b0

- )

-{

-    struct uint192 z;

-    unsigned int carry64, carry128;

-

-    z.v0 = a0 + b0;

-    carry64 = ( z.v0 < a0 );

-    z.v64 = a64 + b64;

-    carry128 = ( z.v64 < a64 );

-    z.v128 = a128 + b128;

-    z.v64 += carry64;

-    carry128 += ( z.v64 < carry64 );

-    z.v128 += carry128;

-    return z;

-

-}

-

diff --git a/softfloat/s_addMagsF32.c b/softfloat/s_addMagsF32.c
deleted file mode 100755
index f361e2b..0000000
--- a/softfloat/s_addMagsF32.c
+++ /dev/null
@@ -1,75 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "specialize.h"

-

-float32_t

- softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB, bool signZ )

-{

-    int_fast16_t expA;

-    uint_fast32_t sigA;

-    int_fast16_t expB;

-    uint_fast32_t sigB;

-    int_fast16_t expDiff;

-    uint_fast32_t uiZ;

-    int_fast16_t expZ;

-    uint_fast32_t sigZ;

-    union ui32_f32 uZ;

-

-    expA = expF32UI( uiA );

-    sigA = fracF32UI( uiA );

-    expB = expF32UI( uiB );

-    sigB = fracF32UI( uiB );

-    expDiff = expA - expB;

-    sigA <<= 6;

-    sigB <<= 6;

-    if ( ! expDiff ) {

-        if ( expA == 0xFF ) {

-            if ( sigA | sigB ) goto propagateNaN;

-            uiZ = uiA;

-            goto uiZ;

-        }

-        if ( ! expA ) {

-            uiZ = packToF32UI( signZ, 0, ( uiA + uiB ) & 0x7FFFFFFF );

-            goto uiZ;

-        }

-        expZ = expA;

-        sigZ = 0x40000000 + sigA + sigB;

-    } else {

-        if ( expDiff < 0 ) {

-            if ( expB == 0xFF ) {

-                if ( sigB ) goto propagateNaN;

-                uiZ = packToF32UI( signZ, 0xFF, 0 );

-                goto uiZ;

-            }

-            expZ = expB;

-            sigA += expA ? 0x20000000 : sigA;

-            sigA = softfloat_shift32RightJam( sigA, - expDiff );

-        } else {

-            if ( expA == 0xFF ) {

-                if ( sigA ) goto propagateNaN;

-                uiZ = uiA;

-                goto uiZ;

-            }

-            expZ = expA;

-            sigB += expB ? 0x20000000 : sigB;

-            sigB = softfloat_shift32RightJam( sigB, expDiff );

-        }

-        sigZ = 0x20000000 + sigA + sigB;

-        if ( sigZ < 0x40000000 ) {

-            --expZ;

-            sigZ <<= 1;

-        }

-    }

-    return softfloat_roundPackToF32( signZ, expZ, sigZ );

- propagateNaN:

-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );

- uiZ:

-    uZ.ui = uiZ;

-    return uZ.f;

-

-}

-

diff --git a/softfloat/s_addMagsF64.c b/softfloat/s_addMagsF64.c
deleted file mode 100755
index a81c3e4..0000000
--- a/softfloat/s_addMagsF64.c
+++ /dev/null
@@ -1,77 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "internals.h"
-#include "specialize.h"
-
-float64_t
- softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )
-{
-    int_fast16_t expA;
-    uint_fast64_t sigA;
-    int_fast16_t expB;
-    uint_fast64_t sigB;
-    int_fast16_t expDiff;
-    uint_fast64_t uiZ;
-    int_fast16_t expZ;
-    uint_fast64_t sigZ;
-    union ui64_f64 uZ;
-
-    expA = expF64UI( uiA );
-    sigA = fracF64UI( uiA );
-    expB = expF64UI( uiB );
-    sigB = fracF64UI( uiB );
-    expDiff = expA - expB;
-    sigA <<= 9;
-    sigB <<= 9;
-    if ( ! expDiff ) {
-        if ( expA == 0x7FF ) {
-            if ( sigA | sigB ) goto propagateNaN;
-            uiZ = uiA;
-            goto uiZ;
-        }
-        if ( ! expA ) {
-            uiZ =
-                packToF64UI(
-                    signZ, 0, ( uiA + uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) );
-            goto uiZ;
-        }
-        expZ = expA;
-        sigZ = UINT64_C( 0x4000000000000000 ) + sigA + sigB;
-    } else {
-        if ( expDiff < 0 ) {
-            if ( expB == 0x7FF ) {
-                if ( sigB ) goto propagateNaN;
-                uiZ = packToF64UI( signZ, 0x7FF, 0 );
-                goto uiZ;
-            }
-            expZ = expB;
-            sigA += expA ? UINT64_C( 0x2000000000000000 ) : sigA;
-            sigA = softfloat_shift64RightJam( sigA, - expDiff );
-        } else {
-            if ( expA == 0x7FF ) {
-                if ( sigA ) goto propagateNaN;
-                uiZ = uiA;
-                goto uiZ;
-            }
-            expZ = expA;
-            sigB += expB ? UINT64_C( 0x2000000000000000 ) : sigB;
-            sigB = softfloat_shift64RightJam( sigB, expDiff );
-        }
-        sigZ = UINT64_C( 0x2000000000000000 ) + sigA + sigB;
-        if ( sigZ < UINT64_C( 0x4000000000000000 ) ) {
-            --expZ;
-            sigZ <<= 1;
-        }
-    }
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
- propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
diff --git a/softfloat/s_countLeadingZeros32.c b/softfloat/s_countLeadingZeros32.c
deleted file mode 100755
index 0bd17e1..0000000
--- a/softfloat/s_countLeadingZeros32.c
+++ /dev/null
@@ -1,22 +0,0 @@
-
-#include <stdint.h>
-#include "primitives.h"
-
-int softfloat_countLeadingZeros32( uint32_t a )
-{
-    int count;
-
-    count = 0;
-    if ( a < 0x10000 ) {
-        count = 16;
-        a <<= 16;
-    }
-    if ( a < 0x1000000 ) {
-        count += 8;
-        a <<= 8;
-    }
-    count += softfloat_countLeadingZeros8[ a>>24 ];
-    return count;
-
-}
-
diff --git a/softfloat/s_countLeadingZeros64.c b/softfloat/s_countLeadingZeros64.c
deleted file mode 100755
index 79f4280..0000000
--- a/softfloat/s_countLeadingZeros64.c
+++ /dev/null
@@ -1,32 +0,0 @@
-
-#include <stdint.h>
-#include "primitives.h"
-#include "platform.h"
-
-int softfloat_countLeadingZeros64( uint64_t a )
-{
-    int count;
-    uint32_t a32;
-
-    count = 32;
-    a32 = a;
-    if ( UINT64_C( 0x100000000 ) <= a ) {
-        count = 0;
-        a32 = a>>32;
-    }
-    /*------------------------------------------------------------------------
-    | From here, result is current count + count leading zeros of `a32'.
-    *------------------------------------------------------------------------*/
-    if ( a32 < 0x10000 ) {
-        count += 16;
-        a32 <<= 16;
-    }
-    if ( a32 < 0x1000000 ) {
-        count += 8;
-        a32 <<= 8;
-    }
-    count += softfloat_countLeadingZeros8[ a32>>24 ];
-    return count;
-
-}
-
diff --git a/softfloat/s_countLeadingZeros8.c b/softfloat/s_countLeadingZeros8.c
deleted file mode 100755
index 4eca7e9..0000000
--- a/softfloat/s_countLeadingZeros8.c
+++ /dev/null
@@ -1,24 +0,0 @@
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-const uint8_t softfloat_countLeadingZeros8[ 256 ] = {
-    8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-};
-
diff --git a/softfloat/s_eq128.c b/softfloat/s_eq128.c
deleted file mode 100755
index 7261dc4..0000000
--- a/softfloat/s_eq128.c
+++ /dev/null
@@ -1,13 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-{
-
-    return ( a64 == b64 ) && ( a0 == b0 );
-
-}
-
diff --git a/softfloat/s_estimateDiv128To64.c b/softfloat/s_estimateDiv128To64.c
deleted file mode 100755
index f8610a2..0000000
--- a/softfloat/s_estimateDiv128To64.c
+++ /dev/null
@@ -1,28 +0,0 @@
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-uint64_t softfloat_estimateDiv128To64( uint64_t a64, uint64_t a0, uint64_t b )
-{
-    uint32_t b32;
-    uint64_t z;
-    struct uint128 term, rem;
-    uint64_t rem32;
-
-    if ( b <= a64 ) return UINT64_C( 0xFFFFFFFFFFFFFFFF );
-    b32 = b>>32;
-    z = ( (uint64_t) b32<<32 <= a64 ) ? UINT64_C( 0xFFFFFFFF00000000 )
-            : ( a64 / b32 )<<32;
-    term = softfloat_mul64To128( b, z );
-    rem = softfloat_sub128( a64, a0, term.v64, term.v0 );
-    while ( UINT64_C( 0x8000000000000000 ) <= rem.v64 ) {
-        z -= UINT64_C( 0x100000000 );
-        rem = softfloat_add128( rem.v64, rem.v0, b32, (uint64_t) ( b<<32 ) );
-    }
-    rem32 = ( rem.v64<<32 ) | ( rem.v0>>32 );
-    z |= ( (uint64_t) b32<<32 <= rem32 ) ? 0xFFFFFFFF : rem32 / b32;
-    return z;
-
-}
-
diff --git a/softfloat/s_estimateSqrt32.c b/softfloat/s_estimateSqrt32.c
deleted file mode 100755
index e22a9dc..0000000
--- a/softfloat/s_estimateSqrt32.c
+++ /dev/null
@@ -1,37 +0,0 @@
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-uint32_t softfloat_estimateSqrt32( unsigned int expA, uint32_t a )
-{
-    static const uint16_t sqrtOddAdjustments[] = {
-        0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,
-        0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67
-    };
-    static const uint16_t sqrtEvenAdjustments[] = {
-        0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,
-        0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002
-    };
-    int index;
-    uint32_t z;
-    union { uint32_t ui; int32_t i; } u32;
-
-    index = ( a>>27 ) & 15;
-    if ( expA & 1 ) {
-        z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ index ];
-        z = ( ( a / z )<<14 ) + ( z<<15 );
-        a >>= 1;
-    } else {
-        z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ index ];
-        z = a / z + z;
-        z = ( 0x20000 <= z ) ? 0xFFFF8000 : z<<15;
-        if ( z <= a ) {
-            u32.ui = a;
-            return u32.i>>1;
-        }
-    }
-    return (uint32_t) ( ( (uint64_t) a<<31 ) / z ) + ( z>>1 );
-
-}
-
diff --git a/softfloat/s_le128.c b/softfloat/s_le128.c
deleted file mode 100755
index 83b1d7f..0000000
--- a/softfloat/s_le128.c
+++ /dev/null
@@ -1,13 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )

-{

-

-    return ( a64 < b64 ) || ( ( a64 == b64 ) && ( a0 <= b0 ) );

-

-}

-

diff --git a/softfloat/s_lt128.c b/softfloat/s_lt128.c
deleted file mode 100755
index 33a3df4..0000000
--- a/softfloat/s_lt128.c
+++ /dev/null
@@ -1,13 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )

-{

-

-    return ( a64 < b64 ) || ( ( a64 == b64 ) && ( a0 < b0 ) );

-

-}

-

diff --git a/softfloat/s_mul128By64To192.c b/softfloat/s_mul128By64To192.c
deleted file mode 100755
index dfa8825..0000000
--- a/softfloat/s_mul128By64To192.c
+++ /dev/null
@@ -1,20 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint192

- softfloat_mul128By64To192( uint64_t a64, uint64_t a0, uint64_t b )

-{

-    struct uint128 p0, p64;

-    struct uint192 z;

-

-    p0 = softfloat_mul64To128( a0, b );

-    z.v0 = p0.v0;

-    p64 = softfloat_mul64To128( a64, b );

-    z.v64 = p64.v0 + p0.v64;

-    z.v128 = p64.v64 + ( z.v64 < p64.v0 );

-    return z;

-

-}

-

diff --git a/softfloat/s_mul128To256.c b/softfloat/s_mul128To256.c
deleted file mode 100755
index a96cd94..0000000
--- a/softfloat/s_mul128To256.c
+++ /dev/null
@@ -1,28 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint256

- softfloat_mul128To256( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )

-{

-    struct uint128 p0, p64, p128;

-    struct uint256 z;

-

-    p0 = softfloat_mul64To128( a0, b0 );

-    z.v0 = p0.v0;

-    p64 = softfloat_mul64To128( a64, b0 );

-    z.v64 = p64.v0 + p0.v64;

-    z.v128 = p64.v64 + ( z.v64 < p64.v0 );

-    p128 = softfloat_mul64To128( a64, b64 );

-    z.v128 += p128.v0;

-    z.v192 = p128.v64 + ( z.v128 < p128.v0 );

-    p64 = softfloat_mul64To128( a0, b64 );

-    z.v64 += p64.v0;

-    p64.v64 += ( z.v64 < p64.v0 );

-    z.v128 += p64.v64;

-    z.v192 += ( z.v128 < p64.v64 );

-    return z;

-

-}

-

diff --git a/softfloat/s_mul64To128.c b/softfloat/s_mul64To128.c
deleted file mode 100755
index c17780b..0000000
--- a/softfloat/s_mul64To128.c
+++ /dev/null
@@ -1,28 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b )

-{

-    uint32_t a32, a0, b32, b0;

-    struct uint128 z;

-    uint64_t mid1, mid2, mid;

-

-    a32 = a>>32;

-    a0 = a;

-    b32 = b>>32;

-    b0 = b;

-    z.v0 = (uint64_t) a0 * b0;

-    mid1 = (uint64_t) a32 * b0;

-    mid2 = (uint64_t) a0 * b32;

-    z.v64 = (uint64_t) a32 * b32;

-    mid = mid1 + mid2;

-    z.v64 += ( (uint64_t) ( mid < mid1 ) )<<32 | mid>>32;

-    mid <<= 32;

-    z.v0 += mid;

-    z.v64 += ( z.v0 < mid );

-    return z;

-

-}

-

diff --git a/softfloat/s_mulAddF32.c b/softfloat/s_mulAddF32.c
deleted file mode 100755
index e55a0ba..0000000
--- a/softfloat/s_mulAddF32.c
+++ /dev/null
@@ -1,171 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "specialize.h"

-#include "softfloat.h"

-

-float32_t

- softfloat_mulAddF32(

-     int op, uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC )

-{

-    bool signA;

-    int_fast16_t expA;

-    uint_fast32_t sigA;

-    bool signB;

-    int_fast16_t expB;

-    uint_fast32_t sigB;

-    bool signC;

-    int_fast16_t expC;

-    uint_fast32_t sigC;

-    bool signProd;

-    uint_fast32_t magBits, uiZ;

-    struct exp16_sig32 normExpSig;

-    int_fast16_t expProd;

-    uint_fast64_t sigProd;

-    bool signZ;

-    int_fast16_t expZ;

-    uint_fast32_t sigZ;

-    int_fast16_t expDiff;

-    uint_fast64_t sigZ64, sigC64;

-    int shiftCount;

-    union ui32_f32 uZ;

-

-    signA = signF32UI( uiA );

-    expA = expF32UI( uiA );

-    sigA = fracF32UI( uiA );

-    signB = signF32UI( uiB );

-    expB = expF32UI( uiB );

-    sigB = fracF32UI( uiB );

-    signC = signF32UI( uiC ) ^ ( op == softfloat_mulAdd_subC );

-    expC = expF32UI( uiC );

-    sigC = fracF32UI( uiC );

-    signProd = signA ^ signB ^ ( op == softfloat_mulAdd_subProd );

-    if ( expA == 0xFF ) {

-        if ( sigA || ( ( expB == 0xFF ) && sigB ) ) goto propagateNaN_ABC;

-        magBits = expB | sigB;

-        goto infProdArg;

-    }

-    if ( expB == 0xFF ) {

-        if ( sigB ) goto propagateNaN_ABC;

-        magBits = expA | sigA;

-        goto infProdArg;

-    }

-    if ( expC == 0xFF ) {

-        if ( sigC ) {

-            uiZ = 0;

-            goto propagateNaN_ZC;

-        }

-        uiZ = uiC;

-        goto uiZ;

-    }

-    if ( ! expA ) {

-        if ( ! sigA ) goto zeroProd;

-        normExpSig = softfloat_normSubnormalF32Sig( sigA );

-        expA = normExpSig.exp;

-        sigA = normExpSig.sig;

-    }

-    if ( ! expB ) {

-        if ( ! sigB ) goto zeroProd;

-        normExpSig = softfloat_normSubnormalF32Sig( sigB );

-        expB = normExpSig.exp;

-        sigB = normExpSig.sig;

-    }

-    expProd = expA + expB - 0x7E;

-    sigA = ( sigA | 0x00800000 )<<7;

-    sigB = ( sigB | 0x00800000 )<<7;

-    sigProd = (uint_fast64_t) sigA * sigB;

-    if ( sigProd < UINT64_C( 0x2000000000000000 ) ) {

-        --expProd;

-        sigProd <<= 1;

-    }

-    signZ = signProd;

-    if ( ! expC ) {

-        if ( ! sigC ) {

-            expZ = expProd - 1;

-            sigZ = softfloat_shortShift64RightJam( sigProd, 31 );

-            goto roundPack;

-        }

-        normExpSig = softfloat_normSubnormalF32Sig( sigC );

-        expC = normExpSig.exp;

-        sigC = normExpSig.sig;

-    }

-    sigC = ( sigC | 0x00800000 )<<6;

-    expDiff = expProd - expC;

-    if ( signProd == signC ) {

-        if ( expDiff <= 0 ) {

-            expZ = expC;

-            sigZ = sigC + softfloat_shift64RightJam( sigProd, 32 - expDiff );

-        } else {

-            expZ = expProd;

-            sigZ64 =

-                sigProd

-                    + softfloat_shift64RightJam(

-                          (uint_fast64_t) sigC<<32, expDiff );

-            sigZ = softfloat_shortShift64RightJam( sigZ64, 32 );

-        }

-        if ( sigZ < 0x40000000 ) {

-            --expZ;

-            sigZ <<= 1;

-        }

-    } else {

-/*** OPTIMIZE BETTER? ***/

-        sigC64 = (uint_fast64_t) sigC<<32;

-        if ( expDiff < 0 ) {

-            signZ = signC;

-            expZ = expC;

-            sigZ64 = sigC64 - softfloat_shift64RightJam( sigProd, - expDiff );

-        } else if ( ! expDiff ) {

-            expZ = expProd;

-            sigZ64 = sigProd - sigC64;

-            if ( ! sigZ64 ) goto completeCancellation;

-            if ( sigZ64 & UINT64_C( 0x8000000000000000 ) ) {

-                signZ ^= 1;

-                sigZ64 = - sigZ64;

-            }

-        } else {

-            expZ = expProd;

-            sigZ64 = sigProd - softfloat_shift64RightJam( sigC64, expDiff );

-        }

-        shiftCount = softfloat_countLeadingZeros64( sigZ64 ) - 1;

-        expZ -= shiftCount;

-        shiftCount -= 32;

-        if ( shiftCount < 0 ) {

-            sigZ = softfloat_shortShift64RightJam( sigZ64, - shiftCount );

-        } else {

-            sigZ = (uint_fast32_t) sigZ64<<shiftCount;

-        }

-    }

- roundPack:

-    return softfloat_roundPackToF32( signZ, expZ, sigZ );

- propagateNaN_ABC:

-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );

-    goto propagateNaN_ZC;

- infProdArg:

-    if ( magBits ) {

-        uiZ = packToF32UI( signProd, 0xFF, 0 );

-        if ( expC != 0xFF ) goto uiZ;

-        if ( sigC ) goto propagateNaN_ZC;

-        if ( signProd == signC ) goto uiZ;

-    }

- invalid:

-    softfloat_raiseFlags( softfloat_flag_invalid );

-    uiZ = defaultNaNF32UI;

- propagateNaN_ZC:

-    uiZ = softfloat_propagateNaNF32UI( uiZ, uiC );

-    goto uiZ;

- zeroProd:

-    uiZ = uiC;

-    if ( ! ( expC | sigC ) && ( signProd != signC ) ) {

- completeCancellation:

-        uiZ =

-            packToF32UI( softfloat_roundingMode == softfloat_round_min, 0, 0 );

-    }

- uiZ:

-    uZ.ui = uiZ;

-    return uZ.f;

-

-}

-

diff --git a/softfloat/s_mulAddF64.c b/softfloat/s_mulAddF64.c
deleted file mode 100755
index 01ba3b4..0000000
--- a/softfloat/s_mulAddF64.c
+++ /dev/null
@@ -1,188 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "specialize.h"

-#include "softfloat.h"

-

-float64_t

- softfloat_mulAddF64(

-     int op, uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC )

-{

-    bool signA;

-    int_fast16_t expA;

-    uint_fast64_t sigA;

-    bool signB;

-    int_fast16_t expB;

-    uint_fast64_t sigB;

-    bool signC;

-    int_fast16_t expC;

-    uint_fast64_t sigC;

-    bool signProd;

-    uint_fast64_t magBits, uiZ;

-    struct exp16_sig64 normExpSig;

-    int_fast16_t expProd;

-    struct uint128 sigProd;

-    bool signZ;

-    int_fast16_t expZ;

-    uint_fast64_t sigZ;

-    int_fast16_t expDiff;

-    struct uint128 sigC128, sigZ128;

-    int shiftCount;

-    union ui64_f64 uZ;

-

-    signA = signF64UI( uiA );

-    expA = expF64UI( uiA );

-    sigA = fracF64UI( uiA );

-    signB = signF64UI( uiB );

-    expB = expF64UI( uiB );

-    sigB = fracF64UI( uiB );

-    signC = signF64UI( uiC ) ^ ( op == softfloat_mulAdd_subC );

-    expC = expF64UI( uiC );

-    sigC = fracF64UI( uiC );

-    signProd = signA ^ signB ^ ( op == softfloat_mulAdd_subProd );

-    if ( expA == 0x7FF ) {

-        if ( sigA || ( ( expB == 0x7FF ) && sigB ) ) goto propagateNaN_ABC;

-        magBits = expB | sigB;

-        goto infProdArg;

-    }

-    if ( expB == 0x7FF ) {

-        if ( sigB ) goto propagateNaN_ABC;

-        magBits = expA | sigA;

-        goto infProdArg;

-    }

-    if ( expC == 0x7FF ) {

-        if ( sigC ) {

-            uiZ = 0;

-            goto propagateNaN_ZC;

-        }

-        uiZ = uiC;

-        goto uiZ;

-    }

-    if ( ! expA ) {

-        if ( ! sigA ) goto zeroProd;

-        normExpSig = softfloat_normSubnormalF64Sig( sigA );

-        expA = normExpSig.exp;

-        sigA = normExpSig.sig;

-    }

-    if ( ! expB ) {

-        if ( ! sigB ) goto zeroProd;

-        normExpSig = softfloat_normSubnormalF64Sig( sigB );

-        expB = normExpSig.exp;

-        sigB = normExpSig.sig;

-    }

-    expProd = expA + expB - 0x3FE;

-    sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<10;

-    sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<10;

-    sigProd = softfloat_mul64To128( sigA, sigB );

-    if ( sigProd.v64 < UINT64_C( 0x2000000000000000 ) ) {

-        --expProd;

-        sigProd = softfloat_shortShift128Left( sigProd.v64, sigProd.v0, 1 );

-    }

-    signZ = signProd;

-    if ( ! expC ) {

-        if ( ! sigC ) {

-            expZ = expProd - 1;

-            sigZ = sigProd.v64<<1 | ( sigProd.v0 != 0 );

-            goto roundPack;

-        }

-        normExpSig = softfloat_normSubnormalF64Sig( sigC );

-        expC = normExpSig.exp;

-        sigC = normExpSig.sig;

-    }

-    sigC = ( sigC | UINT64_C( 0x0010000000000000 ) )<<9;

-    expDiff = expProd - expC;

-    if ( signProd == signC ) {

-        if ( expDiff <= 0 ) {

-            expZ = expC;

-            if ( expDiff ) {

-                sigProd.v64 =

-                    softfloat_shift64RightJam( sigProd.v64, - expDiff );

-            }

-            sigZ = ( sigC + sigProd.v64 ) | ( sigProd.v0 != 0 );

-        } else {

-            expZ = expProd;

-            sigC128 = softfloat_shift128RightJam( sigC, 0, expDiff );

-            sigZ128 =

-                softfloat_add128(

-                    sigProd.v64, sigProd.v0, sigC128.v64, sigC128.v0 );

-            sigZ = sigZ128.v64 | ( sigZ128.v0 != 0 );

-        }

-        if ( sigZ < UINT64_C( 0x4000000000000000 ) ) {

-            --expZ;

-            sigZ <<= 1;

-        }

-    } else {

-/*** OPTIMIZE BETTER? ***/

-        if ( expDiff < 0 ) {

-            signZ = signC;

-            expZ = expC;

-            sigProd =

-                softfloat_shift128RightJam(

-                    sigProd.v64, sigProd.v0, - expDiff );

-            sigZ128 = softfloat_sub128( sigC, 0, sigProd.v64, sigProd.v0 );

-        } else if ( ! expDiff ) {

-            expZ = expProd;

-            sigZ128 = softfloat_sub128( sigProd.v64, sigProd.v0, sigC, 0 );

-            if ( ! ( sigZ128.v64 | sigZ128.v0 ) ) goto completeCancellation;

-            if ( sigZ128.v64 & UINT64_C( 0x8000000000000000 ) ) {

-                signZ ^= 1;

-                sigZ128 = softfloat_sub128( 0, 0, sigZ128.v64, sigZ128.v0 );

-            }

-        } else {

-            expZ = expProd;

-            sigC128 = softfloat_shift128RightJam( sigC, 0, expDiff );

-            sigZ128 =

-                softfloat_sub128(

-                    sigProd.v64, sigProd.v0, sigC128.v64, sigC128.v0 );

-        }

-        if ( ! sigZ128.v64 ) {

-            expZ -= 64;

-            sigZ128.v64 = sigZ128.v0;

-            sigZ128.v0 = 0;

-        }

-        shiftCount = softfloat_countLeadingZeros64( sigZ128.v64 ) - 1;

-        expZ -= shiftCount;

-        if ( shiftCount < 0 ) {

-            sigZ = softfloat_shortShift64RightJam( sigZ128.v64, - shiftCount );

-        } else {

-            sigZ128 =

-                softfloat_shortShift128Left(

-                    sigZ128.v64, sigZ128.v0, shiftCount );

-            sigZ = sigZ128.v64;

-        }

-        sigZ |= ( sigZ128.v0 != 0 );

-    }

- roundPack:

-    return softfloat_roundPackToF64( signZ, expZ, sigZ );

- propagateNaN_ABC:

-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );

-    goto propagateNaN_ZC;

- infProdArg:

-    if ( magBits ) {

-        uiZ = packToF64UI( signProd, 0x7FF, 0 );

-        if ( expC != 0x7FF ) goto uiZ;

-        if ( sigC ) goto propagateNaN_ZC;

-        if ( signProd == signC ) goto uiZ;

-    }

- invalid:

-    softfloat_raiseFlags( softfloat_flag_invalid );

-    uiZ = defaultNaNF64UI;

- propagateNaN_ZC:

-    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );

-    goto uiZ;

- zeroProd:

-    uiZ = uiC;

-    if ( ! ( expC | sigC ) && ( signProd != signC ) ) {

- completeCancellation:

-        uiZ =

-            packToF64UI( softfloat_roundingMode == softfloat_round_min, 0, 0 );

-    }

- uiZ:

-    uZ.ui = uiZ;

-    return uZ.f;

-

-}

-

diff --git a/softfloat/s_normRoundPackToF32.c b/softfloat/s_normRoundPackToF32.c
deleted file mode 100755
index 2e6f4b0..0000000
--- a/softfloat/s_normRoundPackToF32.c
+++ /dev/null
@@ -1,24 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-

-float32_t

- softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )

-{

-    int shiftCount;

-    union ui32_f32 uZ;

-

-    shiftCount = softfloat_countLeadingZeros32( sig ) - 1;

-    exp -= shiftCount;

-    if ( ( 7 <= shiftCount ) && ( (uint16_t) exp < 0xFD ) ) {

-        uZ.ui = packToF32UI( sign, sig ? exp : 0, sig<<( shiftCount - 7 ) );

-        return uZ.f;

-    } else {

-        return softfloat_roundPackToF32( sign, exp, sig<<shiftCount );

-    }

-

-}

-

diff --git a/softfloat/s_normRoundPackToF64.c b/softfloat/s_normRoundPackToF64.c
deleted file mode 100755
index 64dced4..0000000
--- a/softfloat/s_normRoundPackToF64.c
+++ /dev/null
@@ -1,24 +0,0 @@
-

-#include <stdbool.h>

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-

-float64_t

- softfloat_normRoundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )

-{

-    int shiftCount;

-    union ui64_f64 uZ;

-

-    shiftCount = softfloat_countLeadingZeros64( sig ) - 1;

-    exp -= shiftCount;

-    if ( ( 10 <= shiftCount ) && ( (uint16_t) exp < 0x7FD ) ) {

-        uZ.ui = packToF64UI( sign, sig ? exp : 0, sig<<( shiftCount - 10 ) );

-        return uZ.f;

-    } else {

-        return softfloat_roundPackToF64( sign, exp, sig<<shiftCount );

-    }

-

-}

-

diff --git a/softfloat/s_normSubnormalF32Sig.c b/softfloat/s_normSubnormalF32Sig.c
deleted file mode 100755
index b98eb86..0000000
--- a/softfloat/s_normSubnormalF32Sig.c
+++ /dev/null
@@ -1,18 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-

-struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t sig )

-{

-    int shiftCount;

-    struct exp16_sig32 z;

-

-    shiftCount = softfloat_countLeadingZeros32( sig ) - 8;

-    z.exp = 1 - shiftCount;

-    z.sig = sig<<shiftCount;

-    return z;

-

-}

-

diff --git a/softfloat/s_normSubnormalF64Sig.c b/softfloat/s_normSubnormalF64Sig.c
deleted file mode 100755
index 45a7c9e..0000000
--- a/softfloat/s_normSubnormalF64Sig.c
+++ /dev/null
@@ -1,18 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-

-struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t sig )

-{

-    int shiftCount;

-    struct exp16_sig64 z;

-

-    shiftCount = softfloat_countLeadingZeros64( sig ) - 11;

-    z.exp = 1 - shiftCount;

-    z.sig = sig<<shiftCount;

-    return z;

-

-}

-

diff --git a/softfloat/s_roundPackToF32.c b/softfloat/s_roundPackToF32.c
deleted file mode 100755
index 11764f1..0000000
--- a/softfloat/s_roundPackToF32.c
+++ /dev/null
@@ -1,65 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float32_t
- softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )
-{
-    int roundingMode;
-    bool roundNearestEven;
-    int roundIncrement, roundBits;
-    bool isTiny;
-    uint_fast32_t uiZ;
-    union ui32_f32 uZ;
-
-    roundingMode = softfloat_roundingMode;
-    roundNearestEven = ( roundingMode == softfloat_round_nearest_even );
-    roundIncrement = 0x40;
-    if (
-           ! roundNearestEven
-        && ( roundingMode != softfloat_round_nearest_maxMag )
-    ) {
-        roundIncrement =
-               ( roundingMode == softfloat_round_minMag )
-            || ( roundingMode
-                     == ( sign ? softfloat_round_max : softfloat_round_min ) )
-                ? 0
-                : 0x7F;
-    }
-    roundBits = sig & 0x7F;
-    if ( 0xFD <= (uint16_t) exp ) {
-        if ( exp < 0 ) {
-            isTiny =
-                   ( softfloat_detectTininess
-                         == softfloat_tininess_beforeRounding )
-                || ( exp < -1 )
-                || ( sig + roundIncrement < 0x80000000 );
-            sig = softfloat_shift32RightJam( sig, - exp );
-            exp = 0;
-            roundBits = sig & 0x7F;
-            if ( isTiny && roundBits ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
-            }
-        } else if (
-            ( 0xFD < exp ) || ( 0x80000000 <= sig + roundIncrement )
-        ) {
-            softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
-            uiZ = packToF32UI( sign, 0xFF, 0 ) - ! roundIncrement;
-            goto uiZ;
-        }
-    }
-    if ( roundBits ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    sig = ( sig + roundIncrement )>>7;
-    sig &= ~ ( ! ( roundBits ^ 0x40 ) & roundNearestEven );
-    uiZ = packToF32UI( sign, sig ? exp : 0, sig );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
diff --git a/softfloat/s_roundPackToF64.c b/softfloat/s_roundPackToF64.c
deleted file mode 100755
index fb0ef1d..0000000
--- a/softfloat/s_roundPackToF64.c
+++ /dev/null
@@ -1,66 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float64_t
- softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )
-{
-    int roundingMode;
-    bool roundNearestEven;
-    int roundIncrement, roundBits;
-    bool isTiny;
-    uint_fast64_t uiZ;
-    union ui64_f64 uZ;
-
-    roundingMode = softfloat_roundingMode;
-    roundNearestEven = ( roundingMode == softfloat_round_nearest_even );
-    roundIncrement = 0x200;
-    if (
-           ! roundNearestEven
-        && ( roundingMode != softfloat_round_nearest_maxMag )
-    ) {
-        roundIncrement =
-               ( roundingMode == softfloat_round_minMag )
-            || ( roundingMode
-                     == ( sign ? softfloat_round_max : softfloat_round_min ) )
-                ? 0
-                : 0x3FF;
-    }
-    roundBits = sig & 0x3FF;
-    if ( 0x7FD <= (uint16_t) exp ) {
-        if ( exp < 0 ) {
-            isTiny =
-                   ( softfloat_detectTininess
-                         == softfloat_tininess_beforeRounding )
-                || ( exp < -1 )
-                || ( sig + roundIncrement < UINT64_C( 0x8000000000000000 ) );
-            sig = softfloat_shift64RightJam( sig, - exp );
-            exp = 0;
-            roundBits = sig & 0x3FF;
-            if ( isTiny && roundBits ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
-            }
-        } else if (
-            ( 0x7FD < exp )
-                || ( UINT64_C( 0x8000000000000000 ) <= sig + roundIncrement )
-        ) {
-            softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
-            uiZ = packToF64UI( sign, 0x7FF, 0 ) - ! roundIncrement;
-            goto uiZ;
-        }
-    }
-    if ( roundBits ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    sig = ( sig + roundIncrement )>>10;
-    sig &= ~ ( ! ( roundBits ^ 0x200 ) & roundNearestEven );
-    uiZ = packToF64UI( sign, sig ? exp : 0, sig );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
diff --git a/softfloat/s_roundPackToI32.c b/softfloat/s_roundPackToI32.c
deleted file mode 100755
index 1c91497..0000000
--- a/softfloat/s_roundPackToI32.c
+++ /dev/null
@@ -1,48 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-int_fast32_t
- softfloat_roundPackToI32(
-     bool sign, uint_fast64_t sig, int_fast8_t roundingMode, bool exact )
-{
-    bool roundNearestEven;
-    int roundIncrement, roundBits;
-    uint_fast32_t sig32;
-    union { uint32_t ui; int32_t i; } uZ;
-    int_fast32_t z;
-
-    roundNearestEven = ( roundingMode == softfloat_round_nearest_even );
-    roundIncrement = 0x40;
-    if (
-           ! roundNearestEven
-        && ( roundingMode != softfloat_round_nearest_maxMag )
-    ) {
-        roundIncrement =
-               ( roundingMode == softfloat_round_minMag )
-            || ( roundingMode
-                     == ( sign ? softfloat_round_max : softfloat_round_min ) )
-                ? 0
-                : 0x7F;
-    }
-    roundBits = sig & 0x7F;
-    sig += roundIncrement;
-    if ( sig & UINT64_C( 0xFFFFFF8000000000 ) ) goto invalid;
-    sig32 = sig>>7;
-    sig32 &= ~ ( ! ( roundBits ^ 0x40 ) & roundNearestEven );
-    uZ.ui = sign ? - sig32 : sig32;
-    z = uZ.i;
-    if ( z && ( ( z < 0 ) ^ sign ) ) goto invalid;
-    if ( exact && roundBits ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return sign ? -0x7FFFFFFF - 1 : 0x7FFFFFFF;
-
-}
-
diff --git a/softfloat/s_roundPackToI64.c b/softfloat/s_roundPackToI64.c
deleted file mode 100755
index b2f5d63..0000000
--- a/softfloat/s_roundPackToI64.c
+++ /dev/null
@@ -1,52 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-int_fast64_t
- softfloat_roundPackToI64(
-     bool sign,
-     uint_fast64_t sig64,
-     uint_fast64_t sig0,
-     int_fast8_t roundingMode,
-     bool exact
- )
-{
-    bool roundNearestEven, increment;
-    union { uint64_t ui; int64_t i; } uZ;
-    int_fast64_t z;
-
-    roundNearestEven = ( roundingMode == softfloat_round_nearest_even );
-    increment = ( UINT64_C( 0x8000000000000000 ) <= sig0 );
-    if (
-           ! roundNearestEven
-        && ( roundingMode != softfloat_round_nearest_maxMag )
-    ) {
-        increment =
-               ( roundingMode != softfloat_round_minMag )
-            && ( roundingMode
-                     == ( sign ? softfloat_round_min : softfloat_round_max ) )
-            && sig0;
-    }
-    if ( increment ) {
-        ++sig64;
-        if ( ! sig64 ) goto invalid;
-        sig64 &=
-            ~ ( ! ( sig0 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) )
-                    & roundNearestEven );
-    }
-    uZ.ui = sign ? - sig64 : sig64;
-    z = uZ.i;
-    if ( z && ( ( z < 0 ) ^ sign ) ) goto invalid;
-    if ( exact && sig0 ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    return z;
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        sign ? - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1
-            : INT64_C( 0x7FFFFFFFFFFFFFFF );
-
-}
-
diff --git a/softfloat/s_roundPackToUI32.c b/softfloat/s_roundPackToUI32.c
deleted file mode 100755
index ab44ec7..0000000
--- a/softfloat/s_roundPackToUI32.c
+++ /dev/null
@@ -1,44 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-uint_fast32_t
- softfloat_roundPackToUI32(
-     bool sign, uint_fast64_t sig, int_fast8_t roundingMode, bool exact )
-{
-    bool roundNearestEven;
-    int roundIncrement, roundBits;
-    uint_fast32_t z;
-
-    roundNearestEven = ( roundingMode == softfloat_round_nearest_even );
-    roundIncrement = 0x40;
-    if (
-           ! roundNearestEven
-        && ( roundingMode != softfloat_round_nearest_maxMag )
-    ) {
-        roundIncrement =
-               ( roundingMode == softfloat_round_minMag )
-            || ( roundingMode
-                     == ( sign ? softfloat_round_max : softfloat_round_min ) )
-                ? 0
-                : 0x7F;
-    }
-    roundBits = sig & 0x7F;
-    sig += roundIncrement;
-    if ( sig & UINT64_C( 0xFFFFFF8000000000 ) ) goto invalid;
-    z = sig>>7;
-    z &= ~ ( ! ( roundBits ^ 0x40 ) & roundNearestEven );
-    if ( sign && z ) goto invalid;
-    if ( exact && roundBits ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return 0xFFFFFFFF;
-
-}
-
diff --git a/softfloat/s_roundPackToUI64.c b/softfloat/s_roundPackToUI64.c
deleted file mode 100755
index d42266f..0000000
--- a/softfloat/s_roundPackToUI64.c
+++ /dev/null
@@ -1,46 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-uint_fast64_t
- softfloat_roundPackToUI64(
-     bool sign,
-     uint_fast64_t sig64,
-     uint_fast64_t sig0,
-     int_fast8_t roundingMode,
-     bool exact
- )
-{
-    bool roundNearestEven, increment;
-
-    roundNearestEven = ( roundingMode == softfloat_round_nearest_even );
-    increment = ( UINT64_C( 0x8000000000000000 ) <= sig0 );
-    if (
-           ! roundNearestEven
-        && ( roundingMode != softfloat_round_nearest_maxMag )
-    ) {
-        increment =
-               ( roundingMode != softfloat_round_minMag )
-            && ( roundingMode
-                     == ( sign ? softfloat_round_min : softfloat_round_max ) )
-            && sig0;
-    }
-    if ( increment ) {
-        ++sig64;
-        if ( ! sig64 ) goto invalid;
-        sig64 &=
-            ~ ( ! ( sig0 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) )
-                    & roundNearestEven );
-    }
-    if ( sign && sig64 ) goto invalid;
-    if ( exact && sig0 ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    return sig64;
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return UINT64_C( 0xFFFFFFFFFFFFFFFF );
-
-}
-
diff --git a/softfloat/s_shift128ExtraRightJam.c b/softfloat/s_shift128ExtraRightJam.c
deleted file mode 100755
index 6c57974..0000000
--- a/softfloat/s_shift128ExtraRightJam.c
+++ /dev/null
@@ -1,38 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint128_extra

- softfloat_shift128ExtraRightJam(

-     uint64_t a64, uint64_t a0, uint64_t extra, unsigned int count )

-{

-    unsigned int negCount;

-    struct uint128_extra z;

-

-    negCount = - count;

-    if ( count < 64 ) {

-        z.v64 = a64>>count;

-        z.v0 = a64<<( negCount & 63 ) | a0>>count;

-        z.extra = a0<<( negCount & 63 );

-    } else {

-        z.v64 = 0;

-        if ( count == 64 ) {

-            z.v0 = a64;

-            z.extra = a0;

-        } else {

-            extra |= a0;

-            if ( count < 128 ) {

-                z.v0 = a64>>( count & 63 );

-                z.extra = a64<<( negCount & 63 );

-            } else {

-                z.v0 = 0;

-                z.extra = ( count == 128 ) ? a64 : ( a64 != 0 );

-            }

-        }

-    }

-    z.extra |= ( extra != 0 );

-    return z;

-

-}

-

diff --git a/softfloat/s_shift128RightJam.c b/softfloat/s_shift128RightJam.c
deleted file mode 100755
index 5a4e188..0000000
--- a/softfloat/s_shift128RightJam.c
+++ /dev/null
@@ -1,31 +0,0 @@
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-struct uint128
- softfloat_shift128RightJam( uint64_t a64, uint64_t a0, unsigned int count )
-{
-    unsigned int negCount;
-    struct uint128 z;
-
-    if ( count < 64 ) {
-        negCount = - count;
-        z.v64 = a64>>( count & 63 );
-        z.v0 =
-            a64<<( negCount & 63 ) | a0>>count
-                | ( (uint64_t) ( a0<<( negCount & 63 ) ) != 0 );
-    } else {
-        z.v64 = 0;
-        z.v0 =
-            ( count < 128 )
-                ? a64>>( count & 63 )
-                      | ( ( ( a64 & ( ( (uint64_t) 1<<( count & 63 ) ) - 1 ) )
-                                | a0 )
-                              != 0 )
-                : ( ( a64 | a0 ) != 0 );
-    }
-    return z;
-
-}
-
diff --git a/softfloat/s_shift32RightJam.c b/softfloat/s_shift32RightJam.c
deleted file mode 100755
index b697a34..0000000
--- a/softfloat/s_shift32RightJam.c
+++ /dev/null
@@ -1,15 +0,0 @@
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-uint32_t softfloat_shift32RightJam( uint32_t a, unsigned int count )
-{
-
-    return
-        ( count < 32 )
-            ? a>>count | ( (uint32_t) ( a<<( ( - count ) & 31 ) ) != 0 )
-            : ( a != 0 );
-
-}
-
diff --git a/softfloat/s_shift64ExtraRightJam.c b/softfloat/s_shift64ExtraRightJam.c
deleted file mode 100755
index 167ea54..0000000
--- a/softfloat/s_shift64ExtraRightJam.c
+++ /dev/null
@@ -1,23 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint64_extra

- softfloat_shift64ExtraRightJam(

-     uint64_t a, uint64_t extra, unsigned int count )

-{

-    struct uint64_extra z;

-

-    if ( count < 64 ) {

-        z.v = a>>count;

-        z.extra = a<<( ( - count ) & 63 );

-    } else {

-        z.v = 0;

-        z.extra = ( count == 64 ) ? a : ( a != 0 );

-    }

-    z.extra |= ( extra != 0 );

-    return z;

-

-}

-

diff --git a/softfloat/s_shift64RightJam.c b/softfloat/s_shift64RightJam.c
deleted file mode 100755
index ebebb61..0000000
--- a/softfloat/s_shift64RightJam.c
+++ /dev/null
@@ -1,15 +0,0 @@
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-uint64_t softfloat_shift64RightJam( uint64_t a, unsigned int count )
-{
-
-    return
-        ( count < 64 )
-            ? a>>count | ( (uint64_t) ( a<<( ( - count ) & 63 ) ) != 0 )
-            : ( a != 0 );
-
-}
-
diff --git a/softfloat/s_shortShift128ExtraRightJam.c b/softfloat/s_shortShift128ExtraRightJam.c
deleted file mode 100755
index c772740..0000000
--- a/softfloat/s_shortShift128ExtraRightJam.c
+++ /dev/null
@@ -1,20 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint128_extra

- softfloat_shortShift128ExtraRightJam(

-     uint64_t a64, uint64_t a0, uint64_t extra, unsigned int count )

-{

-    unsigned int negCount;

-    struct uint128_extra z;

-

-    negCount = - count;

-    z.v64 = a64>>count;

-    z.v0 = a64<<( negCount & 63 ) | a0>>count;

-    z.extra = a0<<( negCount & 63 ) | ( extra != 0 );

-    return z;

-

-}

-

diff --git a/softfloat/s_shortShift128Left.c b/softfloat/s_shortShift128Left.c
deleted file mode 100755
index 9c29988..0000000
--- a/softfloat/s_shortShift128Left.c
+++ /dev/null
@@ -1,16 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint128

- softfloat_shortShift128Left( uint64_t a64, uint64_t a0, unsigned int count )

-{

-    struct uint128 z;

-

-    z.v64 = a64<<count | a0>>( ( - count ) & 63 );

-    z.v0 = a0<<count;

-    return z;

-

-}

-

diff --git a/softfloat/s_shortShift128Right.c b/softfloat/s_shortShift128Right.c
deleted file mode 100755
index f7f4ce8..0000000
--- a/softfloat/s_shortShift128Right.c
+++ /dev/null
@@ -1,16 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint128

- softfloat_shortShift128Right( uint64_t a64, uint64_t a0, unsigned int count )

-{

-    struct uint128 z;

-

-    z.v64 = a64>>count;

-    z.v0 = a64<<( ( - count ) & 63 ) | a0>>count;

-    return z;

-

-}

-

diff --git a/softfloat/s_shortShift192Left.c b/softfloat/s_shortShift192Left.c
deleted file mode 100755
index cf1e55d..0000000
--- a/softfloat/s_shortShift192Left.c
+++ /dev/null
@@ -1,20 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint192

- softfloat_shortShift192Left(

-     uint64_t a128, uint64_t a64, uint64_t a0, unsigned int count )

-{

-    unsigned int negCount;

-    struct uint192 z;

-

-    negCount = - count;

-    z.v128 = a128<<count | a64>>( negCount & 63 );

-    z.v64 = a64<<count | a0>>( negCount & 63 );

-    z.v0 = a0<<count;

-    return z;

-

-}

-

diff --git a/softfloat/s_shortShift32Right1Jam.c b/softfloat/s_shortShift32Right1Jam.c
deleted file mode 100755
index db4c304..0000000
--- a/softfloat/s_shortShift32Right1Jam.c
+++ /dev/null
@@ -1,12 +0,0 @@
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-uint32_t softfloat_shortShift32Right1Jam( uint32_t a )
-{
-
-    return a>>1 | ( a & 1 );
-
-}
-
diff --git a/softfloat/s_shortShift64ExtraRightJam.c b/softfloat/s_shortShift64ExtraRightJam.c
deleted file mode 100755
index b861c67..0000000
--- a/softfloat/s_shortShift64ExtraRightJam.c
+++ /dev/null
@@ -1,17 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint64_extra

- softfloat_shortShift64ExtraRightJam(

-     uint64_t a, uint64_t extra, unsigned int count )

-{

-    struct uint64_extra z;

-

-    z.v = a>>count;

-    z.extra = a<<( ( - count ) & 63 ) | ( extra != 0 );

-    return z;

-

-}

-

diff --git a/softfloat/s_shortShift64RightJam.c b/softfloat/s_shortShift64RightJam.c
deleted file mode 100755
index 0da6c93..0000000
--- a/softfloat/s_shortShift64RightJam.c
+++ /dev/null
@@ -1,12 +0,0 @@
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-uint64_t softfloat_shortShift64RightJam( uint64_t a, unsigned int count )
-{
-
-    return a>>count | ( ( a & ( ( (uint64_t) 1<<count ) - 1 ) ) != 0 );
-
-}
-
diff --git a/softfloat/s_sub128.c b/softfloat/s_sub128.c
deleted file mode 100755
index 0c4f181..0000000
--- a/softfloat/s_sub128.c
+++ /dev/null
@@ -1,17 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint128

- softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )

-{

-    struct uint128 z;

-

-    z.v0 = a0 - b0;

-    z.v64 = a64 - b64;

-    z.v64 -= ( a0 < b0 );

-    return z;

-

-}

-

diff --git a/softfloat/s_sub192.c b/softfloat/s_sub192.c
deleted file mode 100755
index 96f21c9..0000000
--- a/softfloat/s_sub192.c
+++ /dev/null
@@ -1,30 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-

-struct uint192

- softfloat_sub192(

-     uint64_t a128,

-     uint64_t a64,

-     uint64_t a0,

-     uint64_t b128,

-     uint64_t b64,

-     uint64_t b0

- )

-{

-    struct uint192 z;

-    unsigned int borrow64, borrow128;

-

-    z.v0 = a0 - b0;

-    borrow64 = ( a0 < b0 );

-    z.v64 = a64 - b64;

-    borrow128 = ( a64 < b64 );

-    z.v128 = a128 - b128;

-    borrow128 += ( z.v64 < borrow64 );

-    z.v64 -= borrow64;

-    z.v128 -= borrow128;

-    return z;

-

-}

-

diff --git a/softfloat/s_subMagsF32.c b/softfloat/s_subMagsF32.c
deleted file mode 100755
index 0c83b02..0000000
--- a/softfloat/s_subMagsF32.c
+++ /dev/null
@@ -1,81 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t
- softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB, bool signZ )
-{
-    int_fast16_t expA;
-    uint_fast32_t sigA;
-    int_fast16_t expB;
-    uint_fast32_t sigB;
-    int_fast16_t expDiff;
-    uint_fast32_t uiZ;
-    int_fast16_t expZ;
-    uint_fast32_t sigZ;
-    union ui32_f32 uZ;
-
-    expA = expF32UI( uiA );
-    sigA = fracF32UI( uiA );
-    expB = expF32UI( uiB );
-    sigB = fracF32UI( uiB );
-    expDiff = expA - expB;
-    sigA <<= 7;
-    sigB <<= 7;
-    if ( 0 < expDiff ) goto expABigger;
-    if ( expDiff < 0 ) goto expBBigger;
-    if ( expA == 0xFF ) {
-        if ( sigA | sigB ) goto propagateNaN;
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        uiZ = defaultNaNF32UI;
-        goto uiZ;
-    }
-    if ( ! expA ) {
-        expA = 1;
-        expB = 1;
-    }
-    if ( sigB < sigA ) goto aBigger;
-    if ( sigA < sigB ) goto bBigger;
-    uiZ = packToF32UI( softfloat_roundingMode == softfloat_round_min, 0, 0 );
-    goto uiZ;
- expBBigger:
-    if ( expB == 0xFF ) {
-        if ( sigB ) goto propagateNaN;
-        uiZ = packToF32UI( signZ ^ 1, 0xFF, 0 );
-        goto uiZ;
-    }
-    sigA += expA ? 0x40000000 : sigA;
-    sigA = softfloat_shift32RightJam( sigA, - expDiff );
-    sigB |= 0x40000000;
- bBigger:
-    signZ ^= 1;
-    expZ = expB;
-    sigZ = sigB - sigA;
-    goto normRoundPack;
- expABigger:
-    if ( expA == 0xFF ) {
-        if ( sigA ) goto propagateNaN;
-        uiZ = uiA;
-        goto uiZ;
-    }
-    sigB += expB ? 0x40000000 : sigB;
-    sigB = softfloat_shift32RightJam( sigB, expDiff );
-    sigA |= 0x40000000;
- aBigger:
-    expZ = expA;
-    sigZ = sigA - sigB;
- normRoundPack:
-    return softfloat_normRoundPackToF32( signZ, expZ - 1, sigZ );
- propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
diff --git a/softfloat/s_subMagsF64.c b/softfloat/s_subMagsF64.c
deleted file mode 100755
index 45b81ba..0000000
--- a/softfloat/s_subMagsF64.c
+++ /dev/null
@@ -1,81 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t
- softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )
-{
-    int_fast16_t expA;
-    uint_fast64_t sigA;
-    int_fast16_t expB;
-    uint_fast64_t sigB;
-    int_fast16_t expDiff;
-    uint_fast64_t uiZ;
-    int_fast16_t expZ;
-    uint_fast64_t sigZ;
-    union ui64_f64 uZ;
-
-    expA = expF64UI( uiA );
-    sigA = fracF64UI( uiA );
-    expB = expF64UI( uiB );
-    sigB = fracF64UI( uiB );
-    expDiff = expA - expB;
-    sigA <<= 10;
-    sigB <<= 10;
-    if ( 0 < expDiff ) goto expABigger;
-    if ( expDiff < 0 ) goto expBBigger;
-    if ( expA == 0x7FF ) {
-        if ( sigA | sigB ) goto propagateNaN;
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        uiZ = defaultNaNF64UI;
-        goto uiZ;
-    }
-    if ( ! expA ) {
-        expA = 1;
-        expB = 1;
-    }
-    if ( sigB < sigA ) goto aBigger;
-    if ( sigA < sigB ) goto bBigger;
-    uiZ = packToF64UI( softfloat_roundingMode == softfloat_round_min, 0, 0 );
-    goto uiZ;
- expBBigger:
-    if ( expB == 0x7FF ) {
-        if ( sigB ) goto propagateNaN;
-        uiZ = packToF64UI( signZ ^ 1, 0x7FF, 0 );
-        goto uiZ;
-    }
-    sigA += expA ? UINT64_C( 0x4000000000000000 ) : sigA;
-    sigA = softfloat_shift64RightJam( sigA, - expDiff );
-    sigB |= UINT64_C( 0x4000000000000000 );
- bBigger:
-    signZ ^= 1;
-    expZ = expB;
-    sigZ = sigB - sigA;
-    goto normRoundPack;
- expABigger:
-    if ( expA == 0x7FF ) {
-        if ( sigA ) goto propagateNaN;
-        uiZ = uiA;
-        goto uiZ;
-    }
-    sigB += expB ? UINT64_C( 0x4000000000000000 ) : sigB;
-    sigB = softfloat_shift64RightJam( sigB, expDiff );
-    sigA |= UINT64_C( 0x4000000000000000 );
- aBigger:
-    expZ = expA;
-    sigZ = sigA - sigB;
- normRoundPack:
-    return softfloat_normRoundPackToF64( signZ, expZ - 1, sigZ );
- propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
diff --git a/softfloat/softfloat.ac b/softfloat/softfloat.ac
deleted file mode 100644
index e69de29..0000000
--- a/softfloat/softfloat.ac
+++ /dev/null
diff --git a/softfloat/softfloat.h b/softfloat/softfloat.h
deleted file mode 100755
index 3eddeed..0000000
--- a/softfloat/softfloat.h
+++ /dev/null
@@ -1,233 +0,0 @@
-

-#ifndef softfloat_h

-#define softfloat_h

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-

-/*** UPDATE COMMENTS. ***/

-

-/*============================================================================

-

-This C header file is part of the SoftFloat IEEE Floating-point Arithmetic

-Package, Release 2b.

-

-Written by John R. Hauser.  This work was made possible in part by the

-International Computer Science Institute, located at Suite 600, 1947 Center

-Street, Berkeley, California 94704.  Funding was partially provided by the

-National Science Foundation under grant MIP-9311980.  The original version

-of this code was written as part of a project to build a fixed-point vector

-processor in collaboration with the University of California at Berkeley,

-overseen by Profs. Nelson Morgan and John Wawrzynek.  More information

-is available through the Web page `http://www.cs.berkeley.edu/~jhauser/

-arithmetic/SoftFloat.html'.

-

-THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has

-been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES

-RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS

-AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,

-COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE

-EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE

-INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR

-OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.

-

-Derivative works are acceptable, even for commercial purposes, so long as

-(1) the source code for the derivative work includes prominent notice that

-the work is derivative, and (2) the source code includes prominent notice with

-these four paragraphs for those parts of this code that are retained.

-

-=============================================================================*/

-

-#include "softfloat_types.h"

-

-/*----------------------------------------------------------------------------

-| Software floating-point underflow tininess-detection mode.

-*----------------------------------------------------------------------------*/

-extern int_fast8_t softfloat_detectTininess;

-enum {

-    softfloat_tininess_beforeRounding = 0,

-    softfloat_tininess_afterRounding  = 1

-};

-

-/*----------------------------------------------------------------------------

-| Software floating-point rounding mode.

-*----------------------------------------------------------------------------*/

-extern int_fast8_t softfloat_roundingMode;

-enum {

-    softfloat_round_nearest_even   = 0,

-    softfloat_round_minMag         = 1,

-    softfloat_round_min            = 2,

-    softfloat_round_max            = 3,

-    softfloat_round_nearest_maxMag = 4

-};

-

-/*----------------------------------------------------------------------------

-| Software floating-point exception flags.

-*----------------------------------------------------------------------------*/

-extern int_fast8_t softfloat_exceptionFlags;

-enum {

-    softfloat_flag_inexact   =  1,

-    softfloat_flag_underflow =  2,

-    softfloat_flag_overflow  =  4,

-    softfloat_flag_infinity  =  8,

-    softfloat_flag_invalid   = 16

-};

-

-/*----------------------------------------------------------------------------

-| Routine to raise any or all of the software floating-point exception flags.

-*----------------------------------------------------------------------------*/

-void softfloat_raiseFlags( int_fast8_t );

-

-/*----------------------------------------------------------------------------

-| Integer-to-floating-point conversion routines.

-*----------------------------------------------------------------------------*/

-float32_t ui32_to_f32( uint_fast32_t );

-float64_t ui32_to_f64( uint_fast32_t );

-floatx80_t ui32_to_fx80( uint_fast32_t );

-float128_t ui32_to_f128( uint_fast32_t );

-float32_t ui64_to_f32( uint_fast64_t );

-float64_t ui64_to_f64( uint_fast64_t );

-floatx80_t ui64_to_fx80( uint_fast64_t );

-float128_t ui64_to_f128( uint_fast64_t );

-float32_t i32_to_f32( int_fast32_t );

-float64_t i32_to_f64( int_fast32_t );

-floatx80_t i32_to_fx80( int_fast32_t );

-float128_t i32_to_f128( int_fast32_t );

-float32_t i64_to_f32( int_fast64_t );

-float64_t i64_to_f64( int_fast64_t );

-floatx80_t i64_to_fx80( int_fast64_t );

-float128_t i64_to_f128( int_fast64_t );

-

-/*----------------------------------------------------------------------------

-| 32-bit (single-precision) floating-point operations.

-*----------------------------------------------------------------------------*/

-uint_fast32_t f32_to_ui32( float32_t, int_fast8_t, bool );

-uint_fast64_t f32_to_ui64( float32_t, int_fast8_t, bool );

-int_fast32_t f32_to_i32( float32_t, int_fast8_t, bool );

-int_fast64_t f32_to_i64( float32_t, int_fast8_t, bool );

-uint_fast32_t f32_to_ui32_r_minMag( float32_t, bool );

-uint_fast64_t f32_to_ui64_r_minMag( float32_t, bool );

-int_fast32_t f32_to_i32_r_minMag( float32_t, bool );

-int_fast64_t f32_to_i64_r_minMag( float32_t, bool );

-float64_t f32_to_f64( float32_t );

-floatx80_t f32_to_fx80( float32_t );

-float128_t f32_to_f128( float32_t );

-float32_t f32_roundToInt( float32_t, int_fast8_t, bool );

-float32_t f32_add( float32_t, float32_t );

-float32_t f32_sub( float32_t, float32_t );

-float32_t f32_mul( float32_t, float32_t );

-float32_t f32_mulAdd( float32_t, float32_t, float32_t );

-float32_t f32_div( float32_t, float32_t );

-float32_t f32_rem( float32_t, float32_t );

-float32_t f32_sqrt( float32_t );

-bool f32_eq( float32_t, float32_t );

-bool f32_le( float32_t, float32_t );

-bool f32_lt( float32_t, float32_t );

-bool f32_eq_signaling( float32_t, float32_t );

-bool f32_le_quiet( float32_t, float32_t );

-bool f32_lt_quiet( float32_t, float32_t );

-bool f32_isSignalingNaN( float32_t );

-

-/*----------------------------------------------------------------------------

-| 64-bit (double-precision) floating-point operations.

-*----------------------------------------------------------------------------*/

-uint_fast32_t f64_to_ui32( float64_t, int_fast8_t, bool );

-uint_fast64_t f64_to_ui64( float64_t, int_fast8_t, bool );

-int_fast32_t f64_to_i32( float64_t, int_fast8_t, bool );

-int_fast64_t f64_to_i64( float64_t, int_fast8_t, bool );

-uint_fast32_t f64_to_ui32_r_minMag( float64_t, bool );

-uint_fast64_t f64_to_ui64_r_minMag( float64_t, bool );

-int_fast32_t f64_to_i32_r_minMag( float64_t, bool );

-int_fast64_t f64_to_i64_r_minMag( float64_t, bool );

-float32_t f64_to_f32( float64_t );

-floatx80_t f64_to_fx80( float64_t );

-float128_t f64_to_f128( float64_t );

-float64_t f64_roundToInt( float64_t, int_fast8_t, bool );

-float64_t f64_add( float64_t, float64_t );

-float64_t f64_sub( float64_t, float64_t );

-float64_t f64_mul( float64_t, float64_t );

-float64_t f64_mulAdd( float64_t, float64_t, float64_t );

-float64_t f64_div( float64_t, float64_t );

-float64_t f64_rem( float64_t, float64_t );

-float64_t f64_sqrt( float64_t );

-bool f64_eq( float64_t, float64_t );

-bool f64_le( float64_t, float64_t );

-bool f64_lt( float64_t, float64_t );

-bool f64_eq_signaling( float64_t, float64_t );

-bool f64_le_quiet( float64_t, float64_t );

-bool f64_lt_quiet( float64_t, float64_t );

-bool f64_isSignalingNaN( float64_t );

-

-/*----------------------------------------------------------------------------

-| Extended double-precision rounding precision.  Valid values are 32, 64, and

-| 80.

-*----------------------------------------------------------------------------*/

-extern int_fast8_t floatx80_roundingPrecision;

-

-/*----------------------------------------------------------------------------

-| Extended double-precision floating-point operations.

-*----------------------------------------------------------------------------*/

-uint_fast32_t fx80_to_ui32( floatx80_t, int_fast8_t, bool );

-uint_fast64_t fx80_to_ui64( floatx80_t, int_fast8_t, bool );

-int_fast32_t fx80_to_i32( floatx80_t, int_fast8_t, bool );

-int_fast64_t fx80_to_i64( floatx80_t, int_fast8_t, bool );

-uint_fast32_t fx80_to_ui32_r_minMag( floatx80_t, bool );

-uint_fast64_t fx80_to_ui64_r_minMag( floatx80_t, bool );

-int_fast32_t fx80_to_i32_r_minMag( floatx80_t, bool );

-int_fast64_t fx80_to_i64_r_minMag( floatx80_t, bool );

-float32_t fx80_to_f32( floatx80_t );

-float64_t fx80_to_f64( floatx80_t );

-float128_t fx80_to_f128( floatx80_t );

-floatx80_t fx80_roundToInt( floatx80_t, int_fast8_t, bool );

-floatx80_t fx80_add( floatx80_t, floatx80_t );

-floatx80_t fx80_sub( floatx80_t, floatx80_t );

-floatx80_t fx80_mul( floatx80_t, floatx80_t );

-floatx80_t fx80_mulAdd( floatx80_t, floatx80_t, floatx80_t );

-floatx80_t fx80_div( floatx80_t, floatx80_t );

-floatx80_t fx80_rem( floatx80_t, floatx80_t );

-floatx80_t fx80_sqrt( floatx80_t );

-bool fx80_eq( floatx80_t, floatx80_t );

-bool fx80_le( floatx80_t, floatx80_t );

-bool fx80_lt( floatx80_t, floatx80_t );

-bool fx80_eq_signaling( floatx80_t, floatx80_t );

-bool fx80_le_quiet( floatx80_t, floatx80_t );

-bool fx80_lt_quiet( floatx80_t, floatx80_t );

-bool fx80_isSignalingNaN( floatx80_t );

-

-/*----------------------------------------------------------------------------

-| 128-bit (quadruple-precision) floating-point operations.

-*----------------------------------------------------------------------------*/

-uint_fast32_t f128_to_ui32( float128_t, int_fast8_t, bool );

-uint_fast64_t f128_to_ui64( float128_t, int_fast8_t, bool );

-int_fast32_t f128_to_i32( float128_t, int_fast8_t, bool );

-int_fast64_t f128_to_i64( float128_t, int_fast8_t, bool );

-uint_fast32_t f128_to_ui32_r_minMag( float128_t, bool );

-uint_fast64_t f128_to_ui64_r_minMag( float128_t, bool );

-int_fast32_t f128_to_i32_r_minMag( float128_t, bool );

-int_fast64_t f128_to_i64_r_minMag( float128_t, bool );

-float32_t f128_to_f32( float128_t );

-float64_t f128_to_f64( float128_t );

-floatx80_t f128_to_fx80( float128_t );

-float128_t f128_roundToInt( float128_t, int_fast8_t, bool );

-float128_t f128_add( float128_t, float128_t );

-float128_t f128_sub( float128_t, float128_t );

-float128_t f128_mul( float128_t, float128_t );

-float128_t f128_mulAdd( float128_t, float128_t, float128_t );

-float128_t f128_div( float128_t, float128_t );

-float128_t f128_rem( float128_t, float128_t );

-float128_t f128_sqrt( float128_t );

-bool f128_eq( float128_t, float128_t );

-bool f128_le( float128_t, float128_t );

-bool f128_lt( float128_t, float128_t );

-bool f128_eq_signaling( float128_t, float128_t );

-bool f128_le_quiet( float128_t, float128_t );

-bool f128_lt_quiet( float128_t, float128_t );

-bool f128_isSignalingNaN( float128_t );

-

-#ifdef __cplusplus

-}

-#endif

-

-#endif

-

diff --git a/softfloat/softfloat.mk.in b/softfloat/softfloat.mk.in
deleted file mode 100644
index 59993cb..0000000
--- a/softfloat/softfloat.mk.in
+++ /dev/null
@@ -1,113 +0,0 @@
-softfloat_subproject_deps = \
-	sotfloat_riscv \
-
-softfloat_hdrs = \
-	internals.h \
-	primitives.h \
-	softfloat.h \
-
-softfloat_c_srcs = \
-	f32_add.c                      \
-	f32_div.c                      \
-	f32_eq.c                       \
-	f32_eq_signaling.c             \
-	f32_isSignalingNaN.c           \
-	f32_le.c                       \
-	f32_le_quiet.c                 \
-	f32_lt.c                       \
-	f32_lt_quiet.c                 \
-	f32_mulAdd.c                   \
-	f32_mul.c                      \
-	f32_rem.c                      \
-	f32_roundToInt.c               \
-	f32_sqrt.c                     \
-	f32_sub.c                      \
-	f32_to_f64.c                   \
-	f32_to_i32.c                   \
-	f32_to_i32_r_minMag.c          \
-	f32_to_i64.c                   \
-	f32_to_i64_r_minMag.c          \
-	f32_to_ui32.c                  \
-	f32_to_ui32_r_minMag.c         \
-	f32_to_ui64.c                  \
-	f32_to_ui64_r_minMag.c         \
-	f64_add.c                      \
-	f64_div.c                      \
-	f64_eq.c                       \
-	f64_eq_signaling.c             \
-	f64_isSignalingNaN.c           \
-	f64_le.c                       \
-	f64_le_quiet.c                 \
-	f64_lt.c                       \
-	f64_lt_quiet.c                 \
-	f64_mulAdd.c                   \
-	f64_mul.c                      \
-	f64_rem.c                      \
-	f64_roundToInt.c               \
-	f64_sqrt.c                     \
-	f64_sub.c                      \
-	f64_to_f32.c                   \
-	f64_to_i32.c                   \
-	f64_to_i32_r_minMag.c          \
-	f64_to_i64.c                   \
-	f64_to_i64_r_minMag.c          \
-	f64_to_ui32.c                  \
-	f64_to_ui32_r_minMag.c         \
-	f64_to_ui64.c                  \
-	f64_to_ui64_r_minMag.c         \
-	i32_to_f32.c                   \
-	i32_to_f64.c                   \
-	i64_to_f32.c                   \
-	i64_to_f64.c                   \
-	s_add128.c                     \
-	s_add192.c                     \
-	s_addMagsF32.c                 \
-	s_addMagsF64.c                 \
-	s_countLeadingZeros32.c        \
-	s_countLeadingZeros64.c        \
-	s_countLeadingZeros8.c         \
-	s_eq128.c                      \
-	s_estimateDiv128To64.c         \
-	s_estimateSqrt32.c             \
-	s_le128.c                      \
-	s_lt128.c                      \
-	s_mul128By64To192.c            \
-	s_mul128To256.c                \
-	s_mul64To128.c                 \
-	s_mulAddF32.c                  \
-	s_mulAddF64.c                  \
-	s_normRoundPackToF32.c         \
-	s_normRoundPackToF64.c         \
-	s_normSubnormalF32Sig.c        \
-	s_normSubnormalF64Sig.c        \
-	softfloat_state.c              \
-	s_roundPackToF32.c             \
-	s_roundPackToF64.c             \
-	s_roundPackToI32.c             \
-	s_roundPackToI64.c             \
-	s_roundPackToUI32.c            \
-	s_roundPackToUI64.c            \
-	s_shift128ExtraRightJam.c      \
-	s_shift128RightJam.c           \
-	s_shift32RightJam.c            \
-	s_shift64ExtraRightJam.c       \
-	s_shift64RightJam.c            \
-	s_shortShift128ExtraRightJam.c \
-	s_shortShift128Left.c          \
-	s_shortShift128Right.c         \
-	s_shortShift192Left.c          \
-	s_shortShift32Right1Jam.c      \
-	s_shortShift64ExtraRightJam.c  \
-	s_shortShift64RightJam.c       \
-	s_sub128.c                     \
-	s_sub192.c                     \
-	s_subMagsF32.c                 \
-	s_subMagsF64.c                 \
-	ui32_to_f32.c                  \
-	ui32_to_f64.c                  \
-	ui64_to_f32.c                  \
-	ui64_to_f64.c                  \
-
-softfloat_test_srcs =
-
-softfloat_install_prog_srcs =
diff --git a/softfloat/softfloat_state.c b/softfloat/softfloat_state.c
deleted file mode 100755
index 8859089..0000000
--- a/softfloat/softfloat_state.c
+++ /dev/null
@@ -1,19 +0,0 @@
-

-/*** COMMENTS. ***/

-

-#include <stdint.h>

-#include "platform.h"

-#include "internals.h"

-#include "specialize.h"

-#include "softfloat.h"

-

-/*----------------------------------------------------------------------------

-| Floating-point rounding mode, extended double-precision rounding precision,

-| and exception flags.

-*----------------------------------------------------------------------------*/

-int_fast8_t softfloat_roundingMode = softfloat_round_nearest_even;

-int_fast8_t softfloat_detectTininess = init_detectTininess;

-int_fast8_t softfloat_exceptionFlags = 0;

-

-int_fast8_t floatx80_roundingPrecision = 80;

-

diff --git a/softfloat/ui32_to_f32.c b/softfloat/ui32_to_f32.c
deleted file mode 100755
index ba0fc1a..0000000
--- a/softfloat/ui32_to_f32.c
+++ /dev/null
@@ -1,25 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-float32_t ui32_to_f32( uint_fast32_t a )

-{

-    union ui32_f32 uZ;

-

-    if ( ! a ) {

-        uZ.ui = 0;

-        return uZ.f;

-    }

-    if ( a & 0x80000000 ) {

-        return

-            softfloat_roundPackToF32(

-                0, 0x9D, softfloat_shortShift32Right1Jam( a ) );

-    } else {

-        return softfloat_normRoundPackToF32( 0, 0x9C, a );

-    }

-

-}

-

diff --git a/softfloat/ui32_to_f64.c b/softfloat/ui32_to_f64.c
deleted file mode 100755
index d0bd177..0000000
--- a/softfloat/ui32_to_f64.c
+++ /dev/null
@@ -1,26 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-float64_t ui32_to_f64( uint_fast32_t a )

-{

-    uint_fast64_t uiZ;

-    int shiftCount;

-    union ui64_f64 uZ;

-

-    if ( ! a ) {

-        uiZ = 0;

-    } else {

-        shiftCount = softfloat_countLeadingZeros32( a ) + 21;

-        uiZ =

-            packToF64UI(

-                0, 0x432 - shiftCount, (uint_fast64_t) a<<shiftCount );

-    }

-    uZ.ui = uiZ;

-    return uZ.f;

-

-}

-

diff --git a/softfloat/ui64_to_f32.c b/softfloat/ui64_to_f32.c
deleted file mode 100755
index 82afbdc..0000000
--- a/softfloat/ui64_to_f32.c
+++ /dev/null
@@ -1,31 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-float32_t ui64_to_f32( uint_fast64_t a )

-{

-    int shiftCount;

-    union ui32_f32 u;

-    uint_fast32_t sig;

-

-    shiftCount = softfloat_countLeadingZeros64( a ) - 40;

-    if ( 0 <= shiftCount ) {

-        u.ui =

-            a ? packToF32UI(

-                    0, 0x95 - shiftCount, (uint_fast32_t) a<<shiftCount )

-                : 0;

-        return u.f;

-    } else {

-        shiftCount += 7;

-        sig =

-            ( shiftCount < 0 )

-                ? softfloat_shortShift64RightJam( a, - shiftCount )

-                : (uint_fast32_t) a<<shiftCount;

-        return softfloat_roundPackToF32( 0, 0x9C - shiftCount, sig );

-    }

-

-}

-

diff --git a/softfloat/ui64_to_f64.c b/softfloat/ui64_to_f64.c
deleted file mode 100755
index 52c158b..0000000
--- a/softfloat/ui64_to_f64.c
+++ /dev/null
@@ -1,25 +0,0 @@
-

-#include <stdint.h>

-#include "platform.h"

-#include "primitives.h"

-#include "internals.h"

-#include "softfloat.h"

-

-float64_t ui64_to_f64( uint_fast64_t a )

-{

-    union ui64_f64 uZ;

-

-    if ( ! a ) {

-        uZ.ui = 0;

-        return uZ.f;

-    }

-    if ( a & UINT64_C( 0x8000000000000000 ) ) {

-        return

-            softfloat_roundPackToF64(

-                0, 0x43D, softfloat_shortShift64RightJam( a, 1 ) );

-    } else {

-        return softfloat_normRoundPackToF64( 0, 0x43C, a );

-    }

-

-}

-