diff --git a/source/8086-SSE/s_extF80MToCommonNaN.c b/source/8086-SSE/s_extF80MToCommonNaN.c
index 6bf45cf8..92cb6f11 100644
--- a/source/8086-SSE/s_extF80MToCommonNaN.c
+++ b/source/8086-SSE/s_extF80MToCommonNaN.c
@@ -48,11 +48,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr STATE_PARAM )
 {
 
     if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = signExtF80UI64( aSPtr->signExp );
     zPtr->v64 = aSPtr->signif<<1;
diff --git a/source/8086-SSE/s_extF80UIToCommonNaN.c b/source/8086-SSE/s_extF80UIToCommonNaN.c
index 8b8c9278..1c2a0602 100644
--- a/source/8086-SSE/s_extF80UIToCommonNaN.c
+++ b/source/8086-SSE/s_extF80UIToCommonNaN.c
@@ -48,11 +48,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr
+     STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = uiA64>>15;
     zPtr->v64  = uiA0<<1;
diff --git a/source/8086-SSE/s_f128MToCommonNaN.c b/source/8086-SSE/s_f128MToCommonNaN.c
index 22152145..60da58c8 100644
--- a/source/8086-SSE/s_f128MToCommonNaN.c
+++ b/source/8086-SSE/s_f128MToCommonNaN.c
@@ -49,11 +49,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
 void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
+ softfloat_f128MToCommonNaN(
+     const uint32_t *aWPtr, struct commonNaN *zPtr STATE_PARAM )
 {
 
     if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
     softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
diff --git a/source/8086-SSE/s_f128UIToCommonNaN.c b/source/8086-SSE/s_f128UIToCommonNaN.c
index 2510c070..50af5a82 100644
--- a/source/8086-SSE/s_f128UIToCommonNaN.c
+++ b/source/8086-SSE/s_f128UIToCommonNaN.c
@@ -49,12 +49,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr
+     STATE_PARAM )
 {
     struct uint128 NaNSig;
 
     if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
     zPtr->sign = uiA64>>63;
diff --git a/source/8086-SSE/s_f16UIToCommonNaN.c b/source/8086-SSE/s_f16UIToCommonNaN.c
index 4d5003f6..e9267138 100644
--- a/source/8086-SSE/s_f16UIToCommonNaN.c
+++ b/source/8086-SSE/s_f16UIToCommonNaN.c
@@ -45,11 +45,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+void softfloat_f16UIToCommonNaN(
+    uint_fast16_t uiA, struct commonNaN *zPtr STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF16UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = uiA>>15;
     zPtr->v64  = (uint_fast64_t) uiA<<54;
diff --git a/source/8086-SSE/s_f32UIToCommonNaN.c b/source/8086-SSE/s_f32UIToCommonNaN.c
index f4734db7..540232cd 100644
--- a/source/8086-SSE/s_f32UIToCommonNaN.c
+++ b/source/8086-SSE/s_f32UIToCommonNaN.c
@@ -45,11 +45,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
+void softfloat_f32UIToCommonNaN(
+    uint_fast32_t uiA, struct commonNaN *zPtr STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF32UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = uiA>>31;
     zPtr->v64  = (uint_fast64_t) uiA<<41;
diff --git a/source/8086-SSE/s_f64UIToCommonNaN.c b/source/8086-SSE/s_f64UIToCommonNaN.c
index 9a481a74..8203f7f7 100644
--- a/source/8086-SSE/s_f64UIToCommonNaN.c
+++ b/source/8086-SSE/s_f64UIToCommonNaN.c
@@ -45,11 +45,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
+void softfloat_f64UIToCommonNaN(
+    uint_fast64_t uiA, struct commonNaN *zPtr STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF64UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = uiA>>63;
     zPtr->v64  = uiA<<12;
diff --git a/source/8086-SSE/s_propagateNaNExtF80M.c b/source/8086-SSE/s_propagateNaNExtF80M.c
index f35e0665..a8fa1486 100644
--- a/source/8086-SSE/s_propagateNaNExtF80M.c
+++ b/source/8086-SSE/s_propagateNaNExtF80M.c
@@ -52,6 +52,7 @@ void
      const struct extFloat80M *aSPtr,
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     STATE_PARAM
  )
 {
     bool isSigNaNA;
@@ -66,12 +67,13 @@ void
     isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
     sPtr = aSPtr;
     if ( ! bSPtr ) {
-        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) softfloat_raiseFlags(
+                            softfloat_flag_invalid STATE_VAR );
         goto copy;
     }
     isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) {
             uiB64 = bSPtr->signExp;
             if ( isSigNaNB ) goto returnLargerUIMag;
diff --git a/source/8086-SSE/s_propagateNaNExtF80UI.c b/source/8086-SSE/s_propagateNaNExtF80UI.c
index fa2daae2..b27b70d9 100644
--- a/source/8086-SSE/s_propagateNaNExtF80UI.c
+++ b/source/8086-SSE/s_propagateNaNExtF80UI.c
@@ -56,6 +56,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  )
 {
     bool isSigNaNA, isSigNaNB;
@@ -75,7 +76,7 @@ struct uint128
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerMag;
             if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
diff --git a/source/8086-SSE/s_propagateNaNF128M.c b/source/8086-SSE/s_propagateNaNF128M.c
index e8872742..2798f901 100644
--- a/source/8086-SSE/s_propagateNaNF128M.c
+++ b/source/8086-SSE/s_propagateNaNF128M.c
@@ -51,7 +51,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr STATE_PARAM )
 {
     bool isSigNaNA;
     const uint32_t *ptr;
@@ -62,7 +62,7 @@ void
         isSigNaNA
             || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) goto copy;
     }
     if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr;
diff --git a/source/8086-SSE/s_propagateNaNF128UI.c b/source/8086-SSE/s_propagateNaNF128UI.c
index fb0e862d..d6d3aaa6 100644
--- a/source/8086-SSE/s_propagateNaNF128UI.c
+++ b/source/8086-SSE/s_propagateNaNF128UI.c
@@ -56,6 +56,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  )
 {
     bool isSigNaNA;
@@ -63,7 +64,7 @@ struct uint128
 
     isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
     if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) goto returnNonsigA;
     }
     if ( isNaNF128UI( uiA64, uiA0 ) ) {
diff --git a/source/8086-SSE/s_propagateNaNF16UI.c b/source/8086-SSE/s_propagateNaNF16UI.c
index 8e19e430..34304d0a 100644
--- a/source/8086-SSE/s_propagateNaNF16UI.c
+++ b/source/8086-SSE/s_propagateNaNF16UI.c
@@ -48,13 +48,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB STATE_PARAM )
 {
     bool isSigNaNA;
 
     isSigNaNA = softfloat_isSigNaNF16UI( uiA );
     if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) return uiA | 0x0200;
     }
     return (isNaNF16UI( uiA ) ? uiA : uiB) | 0x0200;
diff --git a/source/8086-SSE/s_propagateNaNF32UI.c b/source/8086-SSE/s_propagateNaNF32UI.c
index 6e423cac..a3155893 100644
--- a/source/8086-SSE/s_propagateNaNF32UI.c
+++ b/source/8086-SSE/s_propagateNaNF32UI.c
@@ -48,13 +48,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB STATE_PARAM )
 {
     bool isSigNaNA;
 
     isSigNaNA = softfloat_isSigNaNF32UI( uiA );
     if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) return uiA | 0x00400000;
     }
     return (isNaNF32UI( uiA ) ? uiA : uiB) | 0x00400000;
diff --git a/source/8086-SSE/s_propagateNaNF64UI.c b/source/8086-SSE/s_propagateNaNF64UI.c
index 474c1967..22de288e 100644
--- a/source/8086-SSE/s_propagateNaNF64UI.c
+++ b/source/8086-SSE/s_propagateNaNF64UI.c
@@ -48,13 +48,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB STATE_PARAM )
 {
     bool isSigNaNA;
 
     isSigNaNA = softfloat_isSigNaNF64UI( uiA );
     if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) return uiA | UINT64_C( 0x0008000000000000 );
     }
     return (isNaNF64UI( uiA ) ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
diff --git a/source/8086-SSE/softfloat_raiseFlags.c b/source/8086-SSE/softfloat_raiseFlags.c
index 7a1aee93..43eb40b7 100644
--- a/source/8086-SSE/softfloat_raiseFlags.c
+++ b/source/8086-SSE/softfloat_raiseFlags.c
@@ -43,10 +43,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | to substitute a result value.  If traps are not implemented, this routine
 | should be simply `softfloat_exceptionFlags |= flags;'.
 *----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
+void softfloat_raiseFlags( uint_fast8_t flags STATE_PARAM )
 {
 
-    softfloat_exceptionFlags |= flags;
+    STATE(exceptionFlags) |= flags;
 
 }
 
diff --git a/source/8086-SSE/specialize.h b/source/8086-SSE/specialize.h
index a9166e17..7dc60421 100644
--- a/source/8086-SSE/specialize.h
+++ b/source/8086-SSE/specialize.h
@@ -100,7 +100,8 @@ struct commonNaN {
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+void softfloat_f16UIToCommonNaN(
+    uint_fast16_t uiA, struct commonNaN *zPtr STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
@@ -115,7 +116,8 @@ uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+ softfloat_propagateNaNF16UI(
+     uint_fast16_t uiA, uint_fast16_t uiB STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 32-bit floating-point NaN.
@@ -135,7 +137,8 @@ uint_fast16_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+void softfloat_f32UIToCommonNaN(
+    uint_fast32_t uiA, struct commonNaN *zPtr STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
@@ -150,7 +153,8 @@ uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+ softfloat_propagateNaNF32UI(
+     uint_fast32_t uiA, uint_fast32_t uiB STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 64-bit floating-point NaN.
@@ -170,7 +174,8 @@ uint_fast32_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+void softfloat_f64UIToCommonNaN(
+    uint_fast64_t uiA, struct commonNaN *zPtr STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
@@ -185,7 +190,8 @@ uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+ softfloat_propagateNaNF64UI(
+     uint_fast64_t uiA, uint_fast64_t uiB STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 80-bit extended floating-point NaN.
@@ -217,7 +223,8 @@ uint_fast64_t
 *----------------------------------------------------------------------------*/
 void
  softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr
+     STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
@@ -241,6 +248,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  );
 
 /*----------------------------------------------------------------------------
@@ -266,7 +274,8 @@ struct uint128
 *----------------------------------------------------------------------------*/
 void
  softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr
+     STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -289,6 +298,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  );
 
 #else
@@ -306,7 +316,7 @@ struct uint128
 *----------------------------------------------------------------------------*/
 void
  softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
@@ -328,6 +338,7 @@ void
      const struct extFloat80M *aSPtr,
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     STATE_PARAM
  );
 
 /*----------------------------------------------------------------------------
@@ -347,7 +358,8 @@ void
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
 void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr
+                             STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -368,7 +380,8 @@ void
 *----------------------------------------------------------------------------*/
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr
+     STATE_PARAM );
 
 #endif
 
diff --git a/source/8086/s_extF80MToCommonNaN.c b/source/8086/s_extF80MToCommonNaN.c
index 6bf45cf8..92cb6f11 100644
--- a/source/8086/s_extF80MToCommonNaN.c
+++ b/source/8086/s_extF80MToCommonNaN.c
@@ -48,11 +48,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr STATE_PARAM )
 {
 
     if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = signExtF80UI64( aSPtr->signExp );
     zPtr->v64 = aSPtr->signif<<1;
diff --git a/source/8086/s_extF80UIToCommonNaN.c b/source/8086/s_extF80UIToCommonNaN.c
index 8b8c9278..1c2a0602 100644
--- a/source/8086/s_extF80UIToCommonNaN.c
+++ b/source/8086/s_extF80UIToCommonNaN.c
@@ -48,11 +48,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr
+     STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = uiA64>>15;
     zPtr->v64  = uiA0<<1;
diff --git a/source/8086/s_f128MToCommonNaN.c b/source/8086/s_f128MToCommonNaN.c
index 22152145..68f8d51b 100644
--- a/source/8086/s_f128MToCommonNaN.c
+++ b/source/8086/s_f128MToCommonNaN.c
@@ -49,11 +49,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
 void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr
+                             STATE_PARAM )
 {
 
     if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
     softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
diff --git a/source/8086/s_f128UIToCommonNaN.c b/source/8086/s_f128UIToCommonNaN.c
index 2510c070..50af5a82 100644
--- a/source/8086/s_f128UIToCommonNaN.c
+++ b/source/8086/s_f128UIToCommonNaN.c
@@ -49,12 +49,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr
+     STATE_PARAM )
 {
     struct uint128 NaNSig;
 
     if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
     zPtr->sign = uiA64>>63;
diff --git a/source/8086/s_f16UIToCommonNaN.c b/source/8086/s_f16UIToCommonNaN.c
index 4d5003f6..529b9a51 100644
--- a/source/8086/s_f16UIToCommonNaN.c
+++ b/source/8086/s_f16UIToCommonNaN.c
@@ -45,11 +45,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr
+                                 STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF16UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = uiA>>15;
     zPtr->v64  = (uint_fast64_t) uiA<<54;
diff --git a/source/8086/s_f32UIToCommonNaN.c b/source/8086/s_f32UIToCommonNaN.c
index f4734db7..ffecdc71 100644
--- a/source/8086/s_f32UIToCommonNaN.c
+++ b/source/8086/s_f32UIToCommonNaN.c
@@ -45,11 +45,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr
+                                 STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF32UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = uiA>>31;
     zPtr->v64  = (uint_fast64_t) uiA<<41;
diff --git a/source/8086/s_f64UIToCommonNaN.c b/source/8086/s_f64UIToCommonNaN.c
index 9a481a74..74bd6146 100644
--- a/source/8086/s_f64UIToCommonNaN.c
+++ b/source/8086/s_f64UIToCommonNaN.c
@@ -45,11 +45,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr
+                                 STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF64UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = uiA>>63;
     zPtr->v64  = uiA<<12;
diff --git a/source/8086/s_propagateNaNExtF80M.c b/source/8086/s_propagateNaNExtF80M.c
index f35e0665..f083d81b 100644
--- a/source/8086/s_propagateNaNExtF80M.c
+++ b/source/8086/s_propagateNaNExtF80M.c
@@ -52,6 +52,7 @@ void
      const struct extFloat80M *aSPtr,
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     STATE_PARAM
  )
 {
     bool isSigNaNA;
@@ -66,12 +67,13 @@ void
     isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
     sPtr = aSPtr;
     if ( ! bSPtr ) {
-        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid
+                                               STATE_VAR );
         goto copy;
     }
     isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) {
             uiB64 = bSPtr->signExp;
             if ( isSigNaNB ) goto returnLargerUIMag;
diff --git a/source/8086/s_propagateNaNExtF80UI.c b/source/8086/s_propagateNaNExtF80UI.c
index fa2daae2..b27b70d9 100644
--- a/source/8086/s_propagateNaNExtF80UI.c
+++ b/source/8086/s_propagateNaNExtF80UI.c
@@ -56,6 +56,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  )
 {
     bool isSigNaNA, isSigNaNB;
@@ -75,7 +76,7 @@ struct uint128
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerMag;
             if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
diff --git a/source/8086/s_propagateNaNF128M.c b/source/8086/s_propagateNaNF128M.c
index 7ac2e5f6..eb646a44 100644
--- a/source/8086/s_propagateNaNF128M.c
+++ b/source/8086/s_propagateNaNF128M.c
@@ -51,7 +51,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr STATE_PARAM )
 {
     bool isSigNaNA;
     const uint32_t *ptr;
@@ -61,12 +61,12 @@ void
     isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
     ptr = aWPtr;
     if ( ! bWPtr ) {
-        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) softfloat_raiseFlags(softfloat_flag_invalid STATE_VAR);
         goto copy;
     }
     isSigNaNB = f128M_isSignalingNaN( (const float128_t *) bWPtr );
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerUIMag;
             if ( softfloat_isNaNF128M( bWPtr ) ) goto copyB;
diff --git a/source/8086/s_propagateNaNF128UI.c b/source/8086/s_propagateNaNF128UI.c
index 6caecd20..41ca713d 100644
--- a/source/8086/s_propagateNaNF128UI.c
+++ b/source/8086/s_propagateNaNF128UI.c
@@ -56,6 +56,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  )
 {
     bool isSigNaNA, isSigNaNB;
@@ -74,7 +75,7 @@ struct uint128
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerMag;
             if ( isNaNF128UI( uiB64, uiB0 ) ) goto returnB;
diff --git a/source/8086/s_propagateNaNF16UI.c b/source/8086/s_propagateNaNF16UI.c
index f9d80d6a..fcbc19d7 100644
--- a/source/8086/s_propagateNaNF16UI.c
+++ b/source/8086/s_propagateNaNF16UI.c
@@ -48,7 +48,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB STATE_PARAM )
 {
     bool isSigNaNA, isSigNaNB;
     uint_fast16_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
@@ -65,7 +65,7 @@ uint_fast16_t
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerMag;
             return isNaNF16UI( uiB ) ? uiNonsigB : uiNonsigA;
diff --git a/source/8086/s_propagateNaNF32UI.c b/source/8086/s_propagateNaNF32UI.c
index 2350ad7c..31df2e76 100644
--- a/source/8086/s_propagateNaNF32UI.c
+++ b/source/8086/s_propagateNaNF32UI.c
@@ -48,7 +48,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB STATE_PARAM )
 {
     bool isSigNaNA, isSigNaNB;
     uint_fast32_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
@@ -65,7 +65,7 @@ uint_fast32_t
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerMag;
             return isNaNF32UI( uiB ) ? uiNonsigB : uiNonsigA;
diff --git a/source/8086/s_propagateNaNF64UI.c b/source/8086/s_propagateNaNF64UI.c
index a4013d48..82a83b43 100644
--- a/source/8086/s_propagateNaNF64UI.c
+++ b/source/8086/s_propagateNaNF64UI.c
@@ -48,7 +48,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB STATE_PARAM )
 {
     bool isSigNaNA, isSigNaNB;
     uint_fast64_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
@@ -65,7 +65,7 @@ uint_fast64_t
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) {
             if ( isSigNaNB ) goto returnLargerMag;
             return isNaNF64UI( uiB ) ? uiNonsigB : uiNonsigA;
diff --git a/source/8086/softfloat_raiseFlags.c b/source/8086/softfloat_raiseFlags.c
index 7a1aee93..43eb40b7 100644
--- a/source/8086/softfloat_raiseFlags.c
+++ b/source/8086/softfloat_raiseFlags.c
@@ -43,10 +43,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | to substitute a result value.  If traps are not implemented, this routine
 | should be simply `softfloat_exceptionFlags |= flags;'.
 *----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
+void softfloat_raiseFlags( uint_fast8_t flags STATE_PARAM )
 {
 
-    softfloat_exceptionFlags |= flags;
+    STATE(exceptionFlags) |= flags;
 
 }
 
diff --git a/source/8086/specialize.h b/source/8086/specialize.h
index a9166e17..ffe4e90d 100644
--- a/source/8086/specialize.h
+++ b/source/8086/specialize.h
@@ -100,7 +100,8 @@ struct commonNaN {
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr
+                                 STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
@@ -115,7 +116,7 @@ uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB STATE_PARAM);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 32-bit floating-point NaN.
@@ -135,7 +136,8 @@ uint_fast16_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr
+                                 STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
@@ -150,7 +152,7 @@ uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB STATE_PARAM);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 64-bit floating-point NaN.
@@ -170,7 +172,8 @@ uint_fast32_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr
+                                 STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
@@ -185,7 +188,7 @@ uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB STATE_PARAM);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 80-bit extended floating-point NaN.
@@ -217,7 +220,8 @@ uint_fast64_t
 *----------------------------------------------------------------------------*/
 void
  softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr
+     STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
@@ -241,6 +245,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  );
 
 /*----------------------------------------------------------------------------
@@ -266,7 +271,8 @@ struct uint128
 *----------------------------------------------------------------------------*/
 void
  softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr
+     STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -289,6 +295,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  );
 
 #else
@@ -306,7 +313,7 @@ struct uint128
 *----------------------------------------------------------------------------*/
 void
  softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
@@ -328,6 +335,7 @@ void
      const struct extFloat80M *aSPtr,
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     STATE_PARAM
  );
 
 /*----------------------------------------------------------------------------
@@ -347,7 +355,8 @@ void
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
 void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr
+                             STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -368,7 +377,7 @@ void
 *----------------------------------------------------------------------------*/
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr STATE_PARAM);
 
 #endif
 
diff --git a/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c b/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c
index 827ed5e3..701ee147 100644
--- a/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c
+++ b/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c
@@ -51,6 +51,7 @@ void
      const struct extFloat80M *aSPtr,
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     STATE_PARAM
  )
 {
     uint_fast16_t ui64;
@@ -65,7 +66,7 @@ void
                         ui0  = bSPtr->signif,
                         softfloat_isSigNaNExtF80UI( ui64, ui0 )))
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zSPtr->signExp = defaultNaNExtF80UI64;
     zSPtr->signif  = defaultNaNExtF80UI0;
diff --git a/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c b/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c
index e2ddd937..e63f416d 100644
--- a/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c
+++ b/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c
@@ -55,6 +55,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  )
 {
     struct uint128 uiZ;
@@ -63,7 +64,7 @@ struct uint128
            softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
         || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     uiZ.v64 = defaultNaNExtF80UI64;
     uiZ.v0  = defaultNaNExtF80UI0;
diff --git a/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c b/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c
index b876ae1f..77611669 100644
--- a/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c
+++ b/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c
@@ -50,14 +50,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr STATE_PARAM )
 {
 
     if (
         f128M_isSignalingNaN( (const float128_t *) aWPtr );
             || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
     zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
diff --git a/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c b/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c
index 31b788e0..148aa870 100644
--- a/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c
+++ b/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c
@@ -55,6 +55,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  )
 {
     struct uint128 uiZ;
@@ -63,7 +64,7 @@ struct uint128
            softfloat_isSigNaNF128UI( uiA64, uiA0 )
         || softfloat_isSigNaNF128UI( uiB64, uiB0 )
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     uiZ.v64 = defaultNaNF128UI64;
     uiZ.v0  = defaultNaNF128UI0;
diff --git a/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c b/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c
index 17618fc2..1404d1ec 100644
--- a/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c
+++ b/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c
@@ -46,11 +46,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     return defaultNaNF16UI;
 
diff --git a/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c b/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c
index e4c3fc1a..8f06c0c5 100644
--- a/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c
+++ b/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c
@@ -46,11 +46,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     return defaultNaNF32UI;
 
diff --git a/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c b/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c
index 75361b8e..a4a12a05 100644
--- a/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c
+++ b/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c
@@ -46,11 +46,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     return defaultNaNF64UI;
 
diff --git a/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c b/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c
index f8f10657..ad8fbbfb 100644
--- a/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c
+++ b/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c
@@ -43,10 +43,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | to substitute a result value.  If traps are not implemented, this routine
 | should be simply 'softfloat_exceptionFlags |= flags;'.
 *----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
+void softfloat_raiseFlags( uint_fast8_t flags STATE_PARAM )
 {
 
-    softfloat_exceptionFlags |= flags;
+    STATE(exceptionFlags) |= flags;
 
 }
 
diff --git a/source/ARM-VFPv2-defaultNaN/specialize.h b/source/ARM-VFPv2-defaultNaN/specialize.h
index e4ea15d1..f1e7cf86 100644
--- a/source/ARM-VFPv2-defaultNaN/specialize.h
+++ b/source/ARM-VFPv2-defaultNaN/specialize.h
@@ -93,7 +93,7 @@ struct commonNaN { char _unused; };
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
@@ -108,7 +108,8 @@ struct commonNaN { char _unused; };
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+ softfloat_propagateNaNF16UI(
+     uint_fast16_t uiA, uint_fast16_t uiB STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 32-bit floating-point NaN.
@@ -128,7 +129,7 @@ uint_fast16_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
@@ -143,7 +144,8 @@ uint_fast16_t
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+ softfloat_propagateNaNF32UI(
+     uint_fast32_t uiA, uint_fast32_t uiB STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 64-bit floating-point NaN.
@@ -163,7 +165,7 @@ uint_fast32_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
@@ -178,7 +180,8 @@ uint_fast32_t
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+ softfloat_propagateNaNF64UI(
+     uint_fast64_t uiA, uint_fast64_t uiB STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 80-bit extended floating-point NaN.
@@ -208,7 +211,7 @@ uint_fast64_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
@@ -243,6 +246,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  );
 
 /*----------------------------------------------------------------------------
@@ -266,7 +270,7 @@ struct uint128
 | pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
 | is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -300,6 +304,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  );
 
 #else
@@ -315,7 +320,7 @@ struct uint128
 | common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
 | NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
@@ -348,6 +353,7 @@ void
      const struct extFloat80M *aSPtr,
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     STATE_PARAM
  );
 
 /*----------------------------------------------------------------------------
@@ -366,7 +372,7 @@ void
 | four 32-bit elements that concatenate in the platform's normal endian order
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -399,7 +405,8 @@ void
 *----------------------------------------------------------------------------*/
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr
+     STATE_PARAM );
 
 #endif
 
diff --git a/source/ARM-VFPv2/s_extF80MToCommonNaN.c b/source/ARM-VFPv2/s_extF80MToCommonNaN.c
index 5fd54dbb..1466314e 100644
--- a/source/ARM-VFPv2/s_extF80MToCommonNaN.c
+++ b/source/ARM-VFPv2/s_extF80MToCommonNaN.c
@@ -48,11 +48,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr STATE_PARAM )
 {
 
     if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = signExtF80UI64( aSPtr->signExp );
     zPtr->v64 = aSPtr->signif<<1;
diff --git a/source/ARM-VFPv2/s_extF80UIToCommonNaN.c b/source/ARM-VFPv2/s_extF80UIToCommonNaN.c
index 9c0f0ca0..db297467 100644
--- a/source/ARM-VFPv2/s_extF80UIToCommonNaN.c
+++ b/source/ARM-VFPv2/s_extF80UIToCommonNaN.c
@@ -48,11 +48,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr
+     STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = uiA64>>15;
     zPtr->v64  = uiA0<<1;
diff --git a/source/ARM-VFPv2/s_f128MToCommonNaN.c b/source/ARM-VFPv2/s_f128MToCommonNaN.c
index e54756b1..b173076f 100644
--- a/source/ARM-VFPv2/s_f128MToCommonNaN.c
+++ b/source/ARM-VFPv2/s_f128MToCommonNaN.c
@@ -49,11 +49,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
 void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
+ softfloat_f128MToCommonNaN(
+     const uint32_t *aWPtr, struct commonNaN *zPtr STATE_PARAM )
 {
 
     if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
     softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
diff --git a/source/ARM-VFPv2/s_f128UIToCommonNaN.c b/source/ARM-VFPv2/s_f128UIToCommonNaN.c
index 27952a77..9843d9b6 100644
--- a/source/ARM-VFPv2/s_f128UIToCommonNaN.c
+++ b/source/ARM-VFPv2/s_f128UIToCommonNaN.c
@@ -49,12 +49,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr
+     STATE_PARAM )
 {
     struct uint128 NaNSig;
 
     if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
     zPtr->sign = uiA64>>63;
diff --git a/source/ARM-VFPv2/s_f16UIToCommonNaN.c b/source/ARM-VFPv2/s_f16UIToCommonNaN.c
index ee1928eb..414a820d 100644
--- a/source/ARM-VFPv2/s_f16UIToCommonNaN.c
+++ b/source/ARM-VFPv2/s_f16UIToCommonNaN.c
@@ -45,11 +45,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+void softfloat_f16UIToCommonNaN(
+    uint_fast16_t uiA, struct commonNaN *zPtr STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF16UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = uiA>>15;
     zPtr->v64  = (uint_fast64_t) uiA<<54;
diff --git a/source/ARM-VFPv2/s_f32UIToCommonNaN.c b/source/ARM-VFPv2/s_f32UIToCommonNaN.c
index 249e4782..2dd47d60 100644
--- a/source/ARM-VFPv2/s_f32UIToCommonNaN.c
+++ b/source/ARM-VFPv2/s_f32UIToCommonNaN.c
@@ -45,11 +45,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
+void softfloat_f32UIToCommonNaN(
+    uint_fast32_t uiA, struct commonNaN *zPtr STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF32UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = uiA>>31;
     zPtr->v64  = (uint_fast64_t) uiA<<41;
diff --git a/source/ARM-VFPv2/s_f64UIToCommonNaN.c b/source/ARM-VFPv2/s_f64UIToCommonNaN.c
index adca2d04..5fe0eff2 100644
--- a/source/ARM-VFPv2/s_f64UIToCommonNaN.c
+++ b/source/ARM-VFPv2/s_f64UIToCommonNaN.c
@@ -45,11 +45,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
+void softfloat_f64UIToCommonNaN(
+    uint_fast64_t uiA, struct commonNaN *zPtr STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF64UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zPtr->sign = uiA>>63;
     zPtr->v64  = uiA<<12;
diff --git a/source/ARM-VFPv2/s_propagateNaNExtF80M.c b/source/ARM-VFPv2/s_propagateNaNExtF80M.c
index 1c142562..dccb440e 100644
--- a/source/ARM-VFPv2/s_propagateNaNExtF80M.c
+++ b/source/ARM-VFPv2/s_propagateNaNExtF80M.c
@@ -52,6 +52,7 @@ void
      const struct extFloat80M *aSPtr,
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     STATE_PARAM
  )
 {
     const struct extFloat80M *sPtr;
@@ -66,7 +67,7 @@ void
             || (bSPtr
                     && extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr ))
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) goto copyNonsig;
         goto copyNonsigB;
     }
diff --git a/source/ARM-VFPv2/s_propagateNaNExtF80UI.c b/source/ARM-VFPv2/s_propagateNaNExtF80UI.c
index be95414a..f8c547e6 100644
--- a/source/ARM-VFPv2/s_propagateNaNExtF80UI.c
+++ b/source/ARM-VFPv2/s_propagateNaNExtF80UI.c
@@ -56,6 +56,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  )
 {
     bool isSigNaNA;
@@ -63,7 +64,7 @@ struct uint128
 
     isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
     if ( isSigNaNA || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) goto returnNonsigA;
         goto returnNonsigB;
     }
diff --git a/source/ARM-VFPv2/s_propagateNaNF128M.c b/source/ARM-VFPv2/s_propagateNaNF128M.c
index 6a30052c..63774348 100644
--- a/source/ARM-VFPv2/s_propagateNaNF128M.c
+++ b/source/ARM-VFPv2/s_propagateNaNF128M.c
@@ -51,7 +51,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr STATE_PARAM )
 {
     const uint32_t *ptr;
     bool isSigNaNA;
@@ -62,7 +62,7 @@ void
         isSigNaNA
             || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( ! isSigNaNA ) ptr = bWPtr;
         goto copyNonsig;
     }
diff --git a/source/ARM-VFPv2/s_propagateNaNF128UI.c b/source/ARM-VFPv2/s_propagateNaNF128UI.c
index 5aece622..8432f12c 100644
--- a/source/ARM-VFPv2/s_propagateNaNF128UI.c
+++ b/source/ARM-VFPv2/s_propagateNaNF128UI.c
@@ -56,6 +56,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  )
 {
     bool isSigNaNA;
@@ -63,7 +64,7 @@ struct uint128
 
     isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
     if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         if ( isSigNaNA ) goto returnNonsigA;
         goto returnNonsigB;
     }
diff --git a/source/ARM-VFPv2/s_propagateNaNF16UI.c b/source/ARM-VFPv2/s_propagateNaNF16UI.c
index 88014603..096eb7f6 100644
--- a/source/ARM-VFPv2/s_propagateNaNF16UI.c
+++ b/source/ARM-VFPv2/s_propagateNaNF16UI.c
@@ -48,13 +48,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB STATE_PARAM )
 {
     bool isSigNaNA;
 
     isSigNaNA = softfloat_isSigNaNF16UI( uiA );
     if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return (isSigNaNA ? uiA : uiB) | 0x0200;
     }
     return isNaNF16UI( uiA ) ? uiA : uiB;
diff --git a/source/ARM-VFPv2/s_propagateNaNF32UI.c b/source/ARM-VFPv2/s_propagateNaNF32UI.c
index 31b289e9..8007d1a6 100644
--- a/source/ARM-VFPv2/s_propagateNaNF32UI.c
+++ b/source/ARM-VFPv2/s_propagateNaNF32UI.c
@@ -48,13 +48,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB STATE_PARAM )
 {
     bool isSigNaNA;
 
     isSigNaNA = softfloat_isSigNaNF32UI( uiA );
     if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return (isSigNaNA ? uiA : uiB) | 0x00400000;
     }
     return isNaNF32UI( uiA ) ? uiA : uiB;
diff --git a/source/ARM-VFPv2/s_propagateNaNF64UI.c b/source/ARM-VFPv2/s_propagateNaNF64UI.c
index 224049ab..a278178a 100644
--- a/source/ARM-VFPv2/s_propagateNaNF64UI.c
+++ b/source/ARM-VFPv2/s_propagateNaNF64UI.c
@@ -48,13 +48,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB STATE_PARAM )
 {
     bool isSigNaNA;
 
     isSigNaNA = softfloat_isSigNaNF64UI( uiA );
     if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return (isSigNaNA ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
     }
     return isNaNF64UI( uiA ) ? uiA : uiB;
diff --git a/source/ARM-VFPv2/softfloat_raiseFlags.c b/source/ARM-VFPv2/softfloat_raiseFlags.c
index f8f10657..ad8fbbfb 100644
--- a/source/ARM-VFPv2/softfloat_raiseFlags.c
+++ b/source/ARM-VFPv2/softfloat_raiseFlags.c
@@ -43,10 +43,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | to substitute a result value.  If traps are not implemented, this routine
 | should be simply 'softfloat_exceptionFlags |= flags;'.
 *----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
+void softfloat_raiseFlags( uint_fast8_t flags STATE_PARAM )
 {
 
-    softfloat_exceptionFlags |= flags;
+    STATE(exceptionFlags) |= flags;
 
 }
 
diff --git a/source/ARM-VFPv2/specialize.h b/source/ARM-VFPv2/specialize.h
index 10b0b357..c6b1a797 100644
--- a/source/ARM-VFPv2/specialize.h
+++ b/source/ARM-VFPv2/specialize.h
@@ -100,7 +100,8 @@ struct commonNaN {
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+void softfloat_f16UIToCommonNaN(
+    uint_fast16_t uiA, struct commonNaN *zPtr STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
@@ -115,7 +116,8 @@ uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+ softfloat_propagateNaNF16UI(
+     uint_fast16_t uiA, uint_fast16_t uiB STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 32-bit floating-point NaN.
@@ -135,7 +137,8 @@ uint_fast16_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+void softfloat_f32UIToCommonNaN(
+    uint_fast32_t uiA, struct commonNaN *zPtr STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
@@ -150,7 +153,8 @@ uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+ softfloat_propagateNaNF32UI(
+     uint_fast32_t uiA, uint_fast32_t uiB STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 64-bit floating-point NaN.
@@ -170,7 +174,8 @@ uint_fast32_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+void softfloat_f64UIToCommonNaN(
+    uint_fast64_t uiA, struct commonNaN *zPtr STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
@@ -185,7 +190,8 @@ uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+ softfloat_propagateNaNF64UI(
+     uint_fast64_t uiA, uint_fast64_t uiB STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 80-bit extended floating-point NaN.
@@ -217,7 +223,8 @@ uint_fast64_t
 *----------------------------------------------------------------------------*/
 void
  softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr
+     STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
@@ -241,6 +248,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  );
 
 /*----------------------------------------------------------------------------
@@ -266,7 +274,8 @@ struct uint128
 *----------------------------------------------------------------------------*/
 void
  softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr
+     STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -289,6 +298,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  );
 
 #else
@@ -306,7 +316,7 @@ struct uint128
 *----------------------------------------------------------------------------*/
 void
  softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
@@ -328,6 +338,7 @@ void
      const struct extFloat80M *aSPtr,
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     STATE_PARAM
  );
 
 /*----------------------------------------------------------------------------
@@ -347,7 +358,8 @@ void
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
 void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr
+                             STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -368,7 +380,8 @@ void
 *----------------------------------------------------------------------------*/
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr
+     STATE_PARAM );
 
 #endif
 
diff --git a/source/RISCV/s_propagateNaNExtF80M.c b/source/RISCV/s_propagateNaNExtF80M.c
index 8adc62e9..17de8b92 100644
--- a/source/RISCV/s_propagateNaNExtF80M.c
+++ b/source/RISCV/s_propagateNaNExtF80M.c
@@ -51,6 +51,7 @@ void
      const struct extFloat80M *aSPtr,
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     STATE_PARAM
  )
 {
     uint_fast16_t ui64;
@@ -65,7 +66,7 @@ void
                         ui0  = bSPtr->signif,
                         softfloat_isSigNaNExtF80UI( ui64, ui0 )))
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zSPtr->signExp = defaultNaNExtF80UI64;
     zSPtr->signif  = defaultNaNExtF80UI0;
diff --git a/source/RISCV/s_propagateNaNExtF80UI.c b/source/RISCV/s_propagateNaNExtF80UI.c
index 88bfee5f..82e99136 100644
--- a/source/RISCV/s_propagateNaNExtF80UI.c
+++ b/source/RISCV/s_propagateNaNExtF80UI.c
@@ -55,6 +55,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  )
 {
     struct uint128 uiZ;
@@ -63,7 +64,7 @@ struct uint128
            softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
         || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     uiZ.v64 = defaultNaNExtF80UI64;
     uiZ.v0  = defaultNaNExtF80UI0;
diff --git a/source/RISCV/s_propagateNaNF128M.c b/source/RISCV/s_propagateNaNF128M.c
index df76ab23..1696f42f 100644
--- a/source/RISCV/s_propagateNaNF128M.c
+++ b/source/RISCV/s_propagateNaNF128M.c
@@ -50,14 +50,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr STATE_PARAM )
 {
 
     if (
         f128M_isSignalingNaN( (const float128_t *) aWPtr )
             || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
     zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
diff --git a/source/RISCV/s_propagateNaNF128UI.c b/source/RISCV/s_propagateNaNF128UI.c
index 49e25353..47d71052 100644
--- a/source/RISCV/s_propagateNaNF128UI.c
+++ b/source/RISCV/s_propagateNaNF128UI.c
@@ -55,6 +55,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  )
 {
     struct uint128 uiZ;
@@ -63,7 +64,7 @@ struct uint128
            softfloat_isSigNaNF128UI( uiA64, uiA0 )
         || softfloat_isSigNaNF128UI( uiB64, uiB0 )
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     uiZ.v64 = defaultNaNF128UI64;
     uiZ.v0  = defaultNaNF128UI0;
diff --git a/source/RISCV/s_propagateNaNF16UI.c b/source/RISCV/s_propagateNaNF16UI.c
index 228dcd8d..eb486585 100644
--- a/source/RISCV/s_propagateNaNF16UI.c
+++ b/source/RISCV/s_propagateNaNF16UI.c
@@ -46,11 +46,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     return defaultNaNF16UI;
 
diff --git a/source/RISCV/s_propagateNaNF32UI.c b/source/RISCV/s_propagateNaNF32UI.c
index c6308cc3..a39e58b0 100644
--- a/source/RISCV/s_propagateNaNF32UI.c
+++ b/source/RISCV/s_propagateNaNF32UI.c
@@ -46,11 +46,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     return defaultNaNF32UI;
 
diff --git a/source/RISCV/s_propagateNaNF64UI.c b/source/RISCV/s_propagateNaNF64UI.c
index 22036655..1fe87658 100644
--- a/source/RISCV/s_propagateNaNF64UI.c
+++ b/source/RISCV/s_propagateNaNF64UI.c
@@ -46,11 +46,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB STATE_PARAM )
 {
 
     if ( softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     return defaultNaNF64UI;
 
diff --git a/source/RISCV/softfloat_raiseFlags.c b/source/RISCV/softfloat_raiseFlags.c
index 7a1aee93..43eb40b7 100644
--- a/source/RISCV/softfloat_raiseFlags.c
+++ b/source/RISCV/softfloat_raiseFlags.c
@@ -43,10 +43,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | to substitute a result value.  If traps are not implemented, this routine
 | should be simply `softfloat_exceptionFlags |= flags;'.
 *----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
+void softfloat_raiseFlags( uint_fast8_t flags STATE_PARAM )
 {
 
-    softfloat_exceptionFlags |= flags;
+    STATE(exceptionFlags) |= flags;
 
 }
 
diff --git a/source/RISCV/specialize.h b/source/RISCV/specialize.h
index c6382646..5256ac32 100644
--- a/source/RISCV/specialize.h
+++ b/source/RISCV/specialize.h
@@ -93,7 +93,7 @@ struct commonNaN { char _unused; };
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
@@ -108,7 +108,8 @@ struct commonNaN { char _unused; };
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+ softfloat_propagateNaNF16UI(
+     uint_fast16_t uiA, uint_fast16_t uiB STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 32-bit floating-point NaN.
@@ -128,7 +129,7 @@ uint_fast16_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
@@ -143,7 +144,8 @@ uint_fast16_t
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+ softfloat_propagateNaNF32UI(
+     uint_fast32_t uiA, uint_fast32_t uiB STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 64-bit floating-point NaN.
@@ -163,7 +165,7 @@ uint_fast32_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
@@ -178,7 +180,8 @@ uint_fast32_t
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
 uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+ softfloat_propagateNaNF64UI(
+     uint_fast64_t uiA, uint_fast64_t uiB STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 80-bit extended floating-point NaN.
@@ -208,7 +211,7 @@ uint_fast64_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
@@ -243,6 +246,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast16_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  );
 
 /*----------------------------------------------------------------------------
@@ -266,7 +270,7 @@ struct uint128
 | pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
 | is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -300,6 +304,7 @@ struct uint128
      uint_fast64_t uiA0,
      uint_fast64_t uiB64,
      uint_fast64_t uiB0
+     STATE_PARAM
  );
 
 #else
@@ -315,7 +320,7 @@ struct uint128
 | common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
 | NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
@@ -348,6 +353,7 @@ void
      const struct extFloat80M *aSPtr,
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr
+     STATE_PARAM
  );
 
 /*----------------------------------------------------------------------------
@@ -366,7 +372,7 @@ void
 | four 32-bit elements that concatenate in the platform's normal endian order
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR )
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -399,7 +405,8 @@ void
 *----------------------------------------------------------------------------*/
 void
  softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr
+     STATE_PARAM );
 
 #endif
 
diff --git a/source/extF80M_add.c b/source/extF80M_add.c
index 4ba6a311..ede72b92 100644
--- a/source/extF80M_add.c
+++ b/source/extF80M_add.c
@@ -43,7 +43,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 void
  extF80M_add(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr
+     STATE_PARAM )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
     uint_fast16_t uiA64;
@@ -55,7 +56,8 @@ void
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
     extFloat80_t
         (*magsFuncPtr)(
-            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool
+            STATE_PARAM );
 #endif
 
     aSPtr = (const struct extFloat80M *) aPtr;
@@ -68,14 +70,16 @@ void
     signB = signExtF80UI64( uiB64 );
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA
+                                         STATE_VAR );
     } else {
-        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA
+                                         STATE_VAR );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80;
-    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA STATE_VAR );
 #endif
 
 }
@@ -84,7 +88,8 @@ void
 
 void
  extF80M_add(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr
+     STATE_PARAM )
 {
 
     softfloat_addExtF80M(
@@ -92,6 +97,7 @@ void
         (const struct extFloat80M *) bPtr,
         (struct extFloat80M *) zPtr,
         false
+        STATE_VAR
     );
 
 }
diff --git a/source/extF80M_div.c b/source/extF80M_div.c
index 24c069a9..250d8d20 100644
--- a/source/extF80M_div.c
+++ b/source/extF80M_div.c
@@ -45,10 +45,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 void
  extF80M_div(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr
+     STATE_PARAM )
 {
 
-    *zPtr = extF80_div( *aPtr, *bPtr );
+    *zPtr = extF80_div( *aPtr, *bPtr STATE_VAR );
 
 }
 
@@ -56,7 +57,8 @@ void
 
 void
  extF80M_div(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr
+     STATE_PARAM )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
     struct extFloat80M *zSPtr;
@@ -104,7 +106,7 @@ void
     if ( ! (x64 & UINT64_C( 0x8000000000000000 )) ) {
         if ( ! x64 ) {
             if ( ! sigA ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
+            softfloat_raiseFlags( softfloat_flag_infinite STATE_VAR );
             goto infinity;
         }
         expB += softfloat_normExtF80SigM( &x64 );
@@ -166,12 +168,18 @@ void
     y[indexWord( 3, 1 )] = x64;
     y[indexWord( 3, 2 )] = (qs[1]<<3) + (x64>>32);
     softfloat_roundPackMToExtF80M(
-        signZ, expZ, y, extF80_roundingPrecision, zSPtr );
+        signZ, expZ, y,
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
+        extF80_roundingPrecision,
+#else
+        state->extF80_roundingPrecision,
+#endif
+        zSPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidExtF80M( zSPtr );
+    softfloat_invalidExtF80M( zSPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
diff --git a/source/extF80M_eq.c b/source/extF80M_eq.c
index 24800371..3bd89f69 100644
--- a/source/extF80M_eq.c
+++ b/source/extF80M_eq.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_eq(const extFloat80_t *aPtr, const extFloat80_t *bPtr STATE_PARAM )
 {
 
-    return extF80_eq( *aPtr, *bPtr );
+    return extF80_eq( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
-bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_eq(const extFloat80_t *aPtr, const extFloat80_t *bPtr STATE_PARAM )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
     uint_fast16_t uiA64;
@@ -77,7 +77,7 @@ bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
                softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
             || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/extF80M_eq_signaling.c b/source/extF80M_eq_signaling.c
index 785eba1e..0e9c19ec 100644
--- a/source/extF80M_eq_signaling.c
+++ b/source/extF80M_eq_signaling.c
@@ -42,16 +42,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr
+                           STATE_PARAM )
 {
 
-    return extF80_eq_signaling( *aPtr, *bPtr );
+    return extF80_eq_signaling( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
-bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr
+                           STATE_PARAM )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
     uint_fast16_t uiA64;
@@ -72,7 +74,7 @@ bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     /*------------------------------------------------------------------------
diff --git a/source/extF80M_le.c b/source/extF80M_le.c
index 24edae87..1e77ab8c 100644
--- a/source/extF80M_le.c
+++ b/source/extF80M_le.c
@@ -42,16 +42,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_le(const extFloat80_t *aPtr, const extFloat80_t *bPtr STATE_PARAM )
 {
 
-    return extF80_le( *aPtr, *bPtr );
+    return extF80_le( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
-bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_le(const extFloat80_t *aPtr, const extFloat80_t *bPtr STATE_PARAM )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
     uint_fast16_t uiA64;
@@ -73,7 +73,7 @@ bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     /*------------------------------------------------------------------------
diff --git a/source/extF80M_le_quiet.c b/source/extF80M_le_quiet.c
index 3880e36d..9b55ead6 100644
--- a/source/extF80M_le_quiet.c
+++ b/source/extF80M_le_quiet.c
@@ -43,16 +43,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr
+                       STATE_PARAM )
 {
 
-    return extF80_le_quiet( *aPtr, *bPtr );
+    return extF80_le_quiet( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
-bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr
+                       STATE_PARAM )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
     uint_fast16_t uiA64;
@@ -78,7 +80,7 @@ bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
                softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
             || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/extF80M_lt.c b/source/extF80M_lt.c
index 70fa8f05..a07a949c 100644
--- a/source/extF80M_lt.c
+++ b/source/extF80M_lt.c
@@ -42,16 +42,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_lt(const extFloat80_t *aPtr, const extFloat80_t *bPtr STATE_PARAM )
 {
 
-    return extF80_lt( *aPtr, *bPtr );
+    return extF80_lt( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
-bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_lt(const extFloat80_t *aPtr, const extFloat80_t *bPtr STATE_PARAM )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
     uint_fast16_t uiA64;
@@ -73,7 +73,7 @@ bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     /*------------------------------------------------------------------------
diff --git a/source/extF80M_lt_quiet.c b/source/extF80M_lt_quiet.c
index b119af30..934e41f5 100644
--- a/source/extF80M_lt_quiet.c
+++ b/source/extF80M_lt_quiet.c
@@ -43,16 +43,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr
+                       STATE_PARAM )
 {
 
-    return extF80_lt_quiet( *aPtr, *bPtr );
+    return extF80_lt_quiet( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
-bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr
+                       STATE_PARAM )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
     uint_fast16_t uiA64;
@@ -78,7 +80,7 @@ bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
                softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
             || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/extF80M_mul.c b/source/extF80M_mul.c
index 27344490..3ed921a9 100644
--- a/source/extF80M_mul.c
+++ b/source/extF80M_mul.c
@@ -45,10 +45,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 void
  extF80M_mul(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr
+     STATE_PARAM )
 {
 
-    *zPtr = extF80_mul( *aPtr, *bPtr );
+    *zPtr = extF80_mul( *aPtr, *bPtr STATE_VAR );
 
 }
 
@@ -56,7 +57,8 @@ void
 
 void
  extF80M_mul(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr
+     STATE_PARAM )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
     struct extFloat80M *zSPtr;
@@ -122,7 +124,13 @@ void
         softfloat_add96M( extSigZPtr, extSigZPtr, extSigZPtr );
     }
     softfloat_roundPackMToExtF80M(
-        signZ, expZ, extSigZPtr, extF80_roundingPrecision, zSPtr );
+        signZ, expZ, extSigZPtr,
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
+        extF80_roundingPrecision,
+#else
+        state->extF80_roundingPrecision,
+#endif
+        zSPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
diff --git a/source/extF80M_rem.c b/source/extF80M_rem.c
index 065e271a..2b1bbf5b 100644
--- a/source/extF80M_rem.c
+++ b/source/extF80M_rem.c
@@ -45,10 +45,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 void
  extF80M_rem(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr
+     STATE_PARAM )
 {
 
-    *zPtr = extF80_rem( *aPtr, *bPtr );
+    *zPtr = extF80_rem( *aPtr, *bPtr STATE_VAR );
 
 }
 
@@ -56,7 +57,8 @@ void
 
 void
  extF80M_rem(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr
+     STATE_PARAM )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
     struct extFloat80M *zSPtr;
@@ -186,7 +188,7 @@ void
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidExtF80M( zSPtr );
+    softfloat_invalidExtF80M( zSPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
diff --git a/source/extF80M_roundToInt.c b/source/extF80M_roundToInt.c
index ff4ae876..db07b176 100644
--- a/source/extF80M_roundToInt.c
+++ b/source/extF80M_roundToInt.c
@@ -49,10 +49,11 @@ void
      uint_fast8_t roundingMode,
      bool exact,
      extFloat80_t *zPtr
+     STATE_PARAM
  )
 {
 
-    *zPtr = extF80_roundToInt( *aPtr, roundingMode, exact );
+    *zPtr = extF80_roundToInt( *aPtr, roundingMode, exact STATE_VAR );
 
 }
 
@@ -64,6 +65,7 @@ void
      uint_fast8_t roundingMode,
      bool exact,
      extFloat80_t *zPtr
+     STATE_PARAM
  )
 {
     const struct extFloat80M *aSPtr;
@@ -97,7 +99,7 @@ void
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( exp <= 0x3FFE ) {
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         switch ( roundingMode ) {
          case softfloat_round_near_even:
             if ( !(sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) break;
@@ -128,7 +130,7 @@ void
     if ( 0x403E <= exp ) {
         if ( exp == 0x7FFF ) {
             if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-                softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
+                softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr STATE_VAR );
                 return;
             }
             sigZ = UINT64_C( 0x8000000000000000 );
@@ -163,7 +165,7 @@ void
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) sigZ |= lastBitMask;
 #endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
  uiZ:
     zSPtr->signExp = uiZ64;
diff --git a/source/extF80M_sqrt.c b/source/extF80M_sqrt.c
index 21c15da0..7a74c90e 100644
--- a/source/extF80M_sqrt.c
+++ b/source/extF80M_sqrt.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
+void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr STATE_PARAM )
 {
 
-    *zPtr = extF80_sqrt( *aPtr );
+    *zPtr = extF80_sqrt( *aPtr STATE_VAR );
 
 }
 
 #else
 
-void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
+void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     struct extFloat80M *zSPtr;
@@ -161,12 +161,18 @@ void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
         }
     }
     softfloat_roundPackMToExtF80M(
-        0, expZ, extSigZ, extF80_roundingPrecision, zSPtr );
+        0, expZ, extSigZ,
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
+        extF80_roundingPrecision,
+#else
+        state->extF80_roundingPrecision,
+#endif
+        zSPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidExtF80M( zSPtr );
+    softfloat_invalidExtF80M( zSPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
diff --git a/source/extF80M_sub.c b/source/extF80M_sub.c
index 4f9f1a62..b6509104 100644
--- a/source/extF80M_sub.c
+++ b/source/extF80M_sub.c
@@ -43,7 +43,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 void
  extF80M_sub(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr
+     STATE_PARAM )
 {
     const struct extFloat80M *aSPtr, *bSPtr;
     uint_fast16_t uiA64;
@@ -55,7 +56,8 @@ void
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
     extFloat80_t
         (*magsFuncPtr)(
-            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool
+            STATE_PARAM );
 #endif
 
     aSPtr = (const struct extFloat80M *) aPtr;
@@ -68,14 +70,16 @@ void
     signB = signExtF80UI64( uiB64 );
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA
+                                         STATE_VAR );
     } else {
-        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA
+                                         STATE_VAR );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80;
-    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA STATE_VAR );
 #endif
 
 }
@@ -84,7 +88,8 @@ void
 
 void
  extF80M_sub(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr
+     STATE_PARAM )
 {
 
     softfloat_addExtF80M(
@@ -92,6 +97,7 @@ void
         (const struct extFloat80M *) bPtr,
         (struct extFloat80M *) zPtr,
         true
+        STATE_VAR
     );
 
 }
diff --git a/source/extF80M_to_f128M.c b/source/extF80M_to_f128M.c
index c0306af8..c03d02c1 100644
--- a/source/extF80M_to_f128M.c
+++ b/source/extF80M_to_f128M.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
+void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr STATE_PARAM )
 {
 
-    *zPtr = extF80_to_f128( *aPtr );
+    *zPtr = extF80_to_f128( *aPtr STATE_VAR );
 
 }
 
 #else
 
-void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
+void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     uint32_t *zWPtr;
@@ -78,7 +78,7 @@ void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
     zWPtr[indexWord( 4, 0 )] = 0;
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN STATE_VAR );
             softfloat_commonNaNToF128M( &commonNaN, zWPtr );
             return;
         }
diff --git a/source/extF80M_to_f16.c b/source/extF80M_to_f16.c
index 7ff56de2..8ac6591b 100644
--- a/source/extF80M_to_f16.c
+++ b/source/extF80M_to_f16.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-float16_t extF80M_to_f16( const extFloat80_t *aPtr )
+float16_t extF80M_to_f16( const extFloat80_t *aPtr STATE_PARAM )
 {
 
-    return extF80_to_f16( *aPtr );
+    return extF80_to_f16( *aPtr STATE_VAR );
 
 }
 
 #else
 
-float16_t extF80M_to_f16( const extFloat80_t *aPtr )
+float16_t extF80M_to_f16( const extFloat80_t *aPtr STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     uint_fast16_t uiA64;
@@ -76,7 +76,7 @@ float16_t extF80M_to_f16( const extFloat80_t *aPtr )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF16UI( &commonNaN );
         } else {
             uiZ = packToF16UI( sign, 0x1F, 0 );
@@ -99,7 +99,7 @@ float16_t extF80M_to_f16( const extFloat80_t *aPtr )
     if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
         if ( exp < -0x40 ) exp = -0x40;
     }
-    return softfloat_roundPackToF16( sign, exp, sig16 );
+    return softfloat_roundPackToF16( sign, exp, sig16 STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/extF80M_to_f32.c b/source/extF80M_to_f32.c
index bb1166f9..2ed8c70a 100644
--- a/source/extF80M_to_f32.c
+++ b/source/extF80M_to_f32.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-float32_t extF80M_to_f32( const extFloat80_t *aPtr )
+float32_t extF80M_to_f32( const extFloat80_t *aPtr STATE_PARAM )
 {
 
-    return extF80_to_f32( *aPtr );
+    return extF80_to_f32( *aPtr STATE_VAR );
 
 }
 
 #else
 
-float32_t extF80M_to_f32( const extFloat80_t *aPtr )
+float32_t extF80M_to_f32( const extFloat80_t *aPtr STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     uint_fast16_t uiA64;
@@ -76,7 +76,7 @@ float32_t extF80M_to_f32( const extFloat80_t *aPtr )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF32UI( &commonNaN );
         } else {
             uiZ = packToF32UI( sign, 0xFF, 0 );
@@ -99,7 +99,7 @@ float32_t extF80M_to_f32( const extFloat80_t *aPtr )
     if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
         if ( exp < -0x1000 ) exp = -0x1000;
     }
-    return softfloat_roundPackToF32( sign, exp, sig32 );
+    return softfloat_roundPackToF32( sign, exp, sig32 STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/extF80M_to_f64.c b/source/extF80M_to_f64.c
index 696255f8..e7c91a94 100644
--- a/source/extF80M_to_f64.c
+++ b/source/extF80M_to_f64.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-float64_t extF80M_to_f64( const extFloat80_t *aPtr )
+float64_t extF80M_to_f64( const extFloat80_t *aPtr STATE_PARAM )
 {
 
-    return extF80_to_f64( *aPtr );
+    return extF80_to_f64( *aPtr STATE_VAR );
 
 }
 
 #else
 
-float64_t extF80M_to_f64( const extFloat80_t *aPtr )
+float64_t extF80M_to_f64( const extFloat80_t *aPtr STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     uint_fast16_t uiA64;
@@ -76,7 +76,7 @@ float64_t extF80M_to_f64( const extFloat80_t *aPtr )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF64UI( &commonNaN );
         } else {
             uiZ = packToF64UI( sign, 0x7FF, 0 );
@@ -99,7 +99,7 @@ float64_t extF80M_to_f64( const extFloat80_t *aPtr )
     if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
         if ( exp < -0x1000 ) exp = -0x1000;
     }
-    return softfloat_roundPackToF64( sign, exp, sig );
+    return softfloat_roundPackToF64( sign, exp, sig STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/extF80M_to_i32.c b/source/extF80M_to_i32.c
index c0464b13..9a060c3b 100644
--- a/source/extF80M_to_i32.c
+++ b/source/extF80M_to_i32.c
@@ -45,10 +45,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 int_fast32_t
  extF80M_to_i32(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact
+     STATE_PARAM )
 {
 
-    return extF80_to_i32( *aPtr, roundingMode, exact );
+    return extF80_to_i32( *aPtr, roundingMode, exact STATE_VAR );
 
 }
 
@@ -56,7 +57,8 @@ int_fast32_t
 
 int_fast32_t
  extF80M_to_i32(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact
+     STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     uint_fast16_t uiA64;
@@ -85,11 +87,11 @@ int_fast32_t
     } else {
         sig = softfloat_shiftRightJam64( sig, shiftDist );
     }
-    return softfloat_roundToI32( sign, sig, roundingMode, exact );
+    return softfloat_roundToI32( sign, sig, roundingMode, exact STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i32_fromNaN
             : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
diff --git a/source/extF80M_to_i32_r_minMag.c b/source/extF80M_to_i32_r_minMag.c
index 9a803cc2..83b246c6 100644
--- a/source/extF80M_to_i32_r_minMag.c
+++ b/source/extF80M_to_i32_r_minMag.c
@@ -43,16 +43,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
+int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact
+                                      STATE_PARAM )
 {
 
-    return extF80_to_i32_r_minMag( *aPtr, exact );
+    return extF80_to_i32_r_minMag( *aPtr, exact STATE_VAR );
 
 }
 
 #else
 
-int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
+int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact
+                                      STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     uint_fast16_t uiA64;
@@ -104,12 +106,12 @@ int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
             z = absZ;
         }
     }
-    if ( raiseInexact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    if ( raiseInexact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR);
     return z;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i32_fromNaN
             : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
diff --git a/source/extF80M_to_i64.c b/source/extF80M_to_i64.c
index 2e07207a..a0ae2547 100644
--- a/source/extF80M_to_i64.c
+++ b/source/extF80M_to_i64.c
@@ -45,10 +45,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 int_fast64_t
  extF80M_to_i64(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact
+     STATE_PARAM )
 {
 
-    return extF80_to_i64( *aPtr, roundingMode, exact );
+    return extF80_to_i64( *aPtr, roundingMode, exact STATE_VAR );
 
 }
 
@@ -56,7 +57,8 @@ int_fast64_t
 
 int_fast64_t
  extF80M_to_i64(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact
+     STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     uint_fast16_t uiA64;
@@ -77,7 +79,7 @@ int_fast64_t
     *------------------------------------------------------------------------*/
     shiftDist = 0x403E - exp;
     if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
                 ? i64_fromNaN
@@ -89,7 +91,7 @@ int_fast64_t
     extSig[indexWord( 3, 1 )] = sig;
     extSig[indexWord( 3, 0 )] = 0;
     if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToI64( sign, extSig, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/extF80M_to_i64_r_minMag.c b/source/extF80M_to_i64_r_minMag.c
index 07282cd4..18583e83 100644
--- a/source/extF80M_to_i64_r_minMag.c
+++ b/source/extF80M_to_i64_r_minMag.c
@@ -43,16 +43,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
+int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact
+                                      STATE_PARAM )
 {
 
-    return extF80_to_i64_r_minMag( *aPtr, exact );
+    return extF80_to_i64_r_minMag( *aPtr, exact STATE_VAR );
 
 }
 
 #else
 
-int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
+int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact
+                                      STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     uint_fast16_t uiA64;
@@ -99,12 +101,12 @@ int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
             z = absZ;
         }
     }
-    if ( raiseInexact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    if ( raiseInexact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR);
     return z;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i64_fromNaN
             : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
diff --git a/source/extF80M_to_ui32.c b/source/extF80M_to_ui32.c
index 72579e41..cfa935c0 100644
--- a/source/extF80M_to_ui32.c
+++ b/source/extF80M_to_ui32.c
@@ -45,10 +45,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 uint_fast32_t
  extF80M_to_ui32(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact
+     STATE_PARAM )
 {
 
-    return extF80_to_ui32( *aPtr, roundingMode, exact );
+    return extF80_to_ui32( *aPtr, roundingMode, exact STATE_VAR );
 
 }
 
@@ -56,7 +57,8 @@ uint_fast32_t
 
 uint_fast32_t
  extF80M_to_ui32(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact
+     STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     uint_fast16_t uiA64;
@@ -85,11 +87,11 @@ uint_fast32_t
     } else {
         sig = softfloat_shiftRightJam64( sig, shiftDist );
     }
-    return softfloat_roundToUI32( sign, sig, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig, roundingMode, exact STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
             ? ui32_fromNaN
diff --git a/source/extF80M_to_ui32_r_minMag.c b/source/extF80M_to_ui32_r_minMag.c
index c09e4834..4211ce91 100644
--- a/source/extF80M_to_ui32_r_minMag.c
+++ b/source/extF80M_to_ui32_r_minMag.c
@@ -43,16 +43,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
+uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact
+                                        STATE_PARAM )
 {
 
-    return extF80_to_ui32_r_minMag( *aPtr, exact );
+    return extF80_to_ui32_r_minMag( *aPtr, exact STATE_VAR );
 
 }
 
 #else
 
-uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
+uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact
+                                        STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     uint_fast16_t uiA64;
@@ -74,7 +76,7 @@ uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
     if ( ! sig && (exp != 0x7FFF) ) return 0;
     shiftDist = 0x403E - exp;
     if ( 64 <= shiftDist ) {
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         return 0;
     }
     /*------------------------------------------------------------------------
@@ -92,14 +94,14 @@ uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
         z = shiftedSig;
         if ( sign && z ) goto invalid;
         if ( exact && shiftDist && ((uint64_t) z<<shiftDist != sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
     }
     return z;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
             ? ui32_fromNaN
diff --git a/source/extF80M_to_ui64.c b/source/extF80M_to_ui64.c
index a7ee39fb..2b39699c 100644
--- a/source/extF80M_to_ui64.c
+++ b/source/extF80M_to_ui64.c
@@ -45,10 +45,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 uint_fast64_t
  extF80M_to_ui64(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact
+     STATE_PARAM )
 {
 
-    return extF80_to_ui64( *aPtr, roundingMode, exact );
+    return extF80_to_ui64( *aPtr, roundingMode, exact STATE_VAR );
 
 }
 
@@ -56,7 +57,8 @@ uint_fast64_t
 
 uint_fast64_t
  extF80M_to_ui64(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact
+     STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     uint_fast16_t uiA64;
@@ -77,7 +79,7 @@ uint_fast64_t
     *------------------------------------------------------------------------*/
     shiftDist = 0x403E - exp;
     if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
                 ? ui64_fromNaN
@@ -89,7 +91,7 @@ uint_fast64_t
     extSig[indexWord( 3, 1 )] = sig;
     extSig[indexWord( 3, 0 )] = 0;
     if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact STATE_VAR);
 
 }
 
diff --git a/source/extF80M_to_ui64_r_minMag.c b/source/extF80M_to_ui64_r_minMag.c
index bf483903..0a4d2105 100644
--- a/source/extF80M_to_ui64_r_minMag.c
+++ b/source/extF80M_to_ui64_r_minMag.c
@@ -43,16 +43,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
+uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact
+                                        STATE_PARAM )
 {
 
-    return extF80_to_ui64_r_minMag( *aPtr, exact );
+    return extF80_to_ui64_r_minMag( *aPtr, exact STATE_VAR );
 
 }
 
 #else
 
-uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
+uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact
+                                        STATE_PARAM )
 {
     const struct extFloat80M *aSPtr;
     uint_fast16_t uiA64;
@@ -73,7 +75,7 @@ uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
     if ( ! sig && (exp != 0x7FFF) ) return 0;
     shiftDist = 0x403E - exp;
     if ( 64 <= shiftDist ) {
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         return 0;
     }
     /*------------------------------------------------------------------------
@@ -89,14 +91,14 @@ uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
         if ( shiftDist ) z >>= shiftDist;
         if ( sign && z ) goto invalid;
         if ( exact && shiftDist && (z<<shiftDist != sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
     }
     return z;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
             ? ui64_fromNaN
diff --git a/source/extF80_add.c b/source/extF80_add.c
index c19d25c1..6613bf6e 100644
--- a/source/extF80_add.c
+++ b/source/extF80_add.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-extFloat80_t extF80_add( extFloat80_t a, extFloat80_t b )
+extFloat80_t extF80_add( extFloat80_t a, extFloat80_t b STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -53,7 +53,8 @@ extFloat80_t extF80_add( extFloat80_t a, extFloat80_t b )
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
     extFloat80_t
         (*magsFuncPtr)(
-            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool
+            STATE_PARAM );
 #endif
 
     uA.f = a;
@@ -66,14 +67,16 @@ extFloat80_t extF80_add( extFloat80_t a, extFloat80_t b )
     signB = signExtF80UI64( uiB64 );
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA
+                                        STATE_VAR );
     } else {
-        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA
+                                        STATE_VAR );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80;
-    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA STATE_VAR );
 #endif
 
 }
diff --git a/source/extF80_div.c b/source/extF80_div.c
index 7d649c54..ba6e5dff 100644
--- a/source/extF80_div.c
+++ b/source/extF80_div.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-extFloat80_t extF80_div( extFloat80_t a, extFloat80_t b )
+extFloat80_t extF80_div( extFloat80_t a, extFloat80_t b STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -106,7 +106,7 @@ extFloat80_t extF80_div( extFloat80_t a, extFloat80_t b )
     if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
         if ( ! sigB ) {
             if ( ! sigA ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
+            softfloat_raiseFlags( softfloat_flag_infinite STATE_VAR );
             goto infinity;
         }
         normExpSig = softfloat_normSubnormalExtF80Sig( sigB );
@@ -168,18 +168,24 @@ extFloat80_t extF80_div( extFloat80_t a, extFloat80_t b )
     sigZExtra = (uint64_t) ((uint_fast64_t) q<<41);
     return
         softfloat_roundPackToExtF80(
-            signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
+            signZ, expZ, sigZ, sigZExtra,
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
+            extF80_roundingPrecision
+#else
+            state->extF80_roundingPrecision
+#endif
+            STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 STATE_VAR );
     uiZ64 = uiZ.v64;
     uiZ0  = uiZ.v0;
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ64 = defaultNaNExtF80UI64;
     uiZ0  = defaultNaNExtF80UI0;
     goto uiZ;
diff --git a/source/extF80_eq.c b/source/extF80_eq.c
index 60f29daf..cb15675c 100644
--- a/source/extF80_eq.c
+++ b/source/extF80_eq.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool extF80_eq( extFloat80_t a, extFloat80_t b )
+bool extF80_eq( extFloat80_t a, extFloat80_t b STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -61,7 +61,7 @@ bool extF80_eq( extFloat80_t a, extFloat80_t b )
                softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
             || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/extF80_eq_signaling.c b/source/extF80_eq_signaling.c
index 5a0dfe4a..9f1023dc 100644
--- a/source/extF80_eq_signaling.c
+++ b/source/extF80_eq_signaling.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool extF80_eq_signaling( extFloat80_t a, extFloat80_t b )
+bool extF80_eq_signaling( extFloat80_t a, extFloat80_t b STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -56,7 +56,7 @@ bool extF80_eq_signaling( extFloat80_t a, extFloat80_t b )
     uiB64 = uB.s.signExp;
     uiB0  = uB.s.signif;
     if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     return
diff --git a/source/extF80_le.c b/source/extF80_le.c
index 2a1ee60f..3961feeb 100644
--- a/source/extF80_le.c
+++ b/source/extF80_le.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool extF80_le( extFloat80_t a, extFloat80_t b )
+bool extF80_le( extFloat80_t a, extFloat80_t b STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -58,7 +58,7 @@ bool extF80_le( extFloat80_t a, extFloat80_t b )
     uiB64 = uB.s.signExp;
     uiB0  = uB.s.signif;
     if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     signA = signExtF80UI64( uiA64 );
diff --git a/source/extF80_le_quiet.c b/source/extF80_le_quiet.c
index 5d0c3ae7..92ca1c98 100644
--- a/source/extF80_le_quiet.c
+++ b/source/extF80_le_quiet.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool extF80_le_quiet( extFloat80_t a, extFloat80_t b )
+bool extF80_le_quiet( extFloat80_t a, extFloat80_t b STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -62,7 +62,7 @@ bool extF80_le_quiet( extFloat80_t a, extFloat80_t b )
                softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
             || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/extF80_lt.c b/source/extF80_lt.c
index 9560d8ec..8356cfac 100644
--- a/source/extF80_lt.c
+++ b/source/extF80_lt.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool extF80_lt( extFloat80_t a, extFloat80_t b )
+bool extF80_lt( extFloat80_t a, extFloat80_t b STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -58,7 +58,7 @@ bool extF80_lt( extFloat80_t a, extFloat80_t b )
     uiB64 = uB.s.signExp;
     uiB0  = uB.s.signif;
     if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     signA = signExtF80UI64( uiA64 );
diff --git a/source/extF80_lt_quiet.c b/source/extF80_lt_quiet.c
index 711652c7..b590cbb9 100644
--- a/source/extF80_lt_quiet.c
+++ b/source/extF80_lt_quiet.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool extF80_lt_quiet( extFloat80_t a, extFloat80_t b )
+bool extF80_lt_quiet( extFloat80_t a, extFloat80_t b STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -62,7 +62,7 @@ bool extF80_lt_quiet( extFloat80_t a, extFloat80_t b )
                softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
             || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/extF80_mul.c b/source/extF80_mul.c
index c0c50a6c..a3f23079 100644
--- a/source/extF80_mul.c
+++ b/source/extF80_mul.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-extFloat80_t extF80_mul( extFloat80_t a, extFloat80_t b )
+extFloat80_t extF80_mul( extFloat80_t a, extFloat80_t b STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -124,11 +124,17 @@ extFloat80_t extF80_mul( extFloat80_t a, extFloat80_t b )
     }
     return
         softfloat_roundPackToExtF80(
-            signZ, expZ, sig128Z.v64, sig128Z.v0, extF80_roundingPrecision );
+            signZ, expZ, sig128Z.v64, sig128Z.v0,
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
+            extF80_roundingPrecision
+#else
+            state->extF80_roundingPrecision
+#endif
+            STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 STATE_VAR );
     uiZ64 = uiZ.v64;
     uiZ0  = uiZ.v0;
     goto uiZ;
@@ -136,7 +142,7 @@ extFloat80_t extF80_mul( extFloat80_t a, extFloat80_t b )
     *------------------------------------------------------------------------*/
  infArg:
     if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         uiZ64 = defaultNaNExtF80UI64;
         uiZ0  = defaultNaNExtF80UI0;
     } else {
diff --git a/source/extF80_rem.c b/source/extF80_rem.c
index a2ebaad8..38e22df2 100644
--- a/source/extF80_rem.c
+++ b/source/extF80_rem.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-extFloat80_t extF80_rem( extFloat80_t a, extFloat80_t b )
+extFloat80_t extF80_rem( extFloat80_t a, extFloat80_t b STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -192,18 +192,19 @@ extFloat80_t extF80_rem( extFloat80_t a, extFloat80_t b )
     }
     return
         softfloat_normRoundPackToExtF80(
-            signRem, rem.v64 | rem.v0 ? expB + 32 : 0, rem.v64, rem.v0, 80 );
+            signRem, rem.v64 | rem.v0 ? expB + 32 : 0, rem.v64, rem.v0, 80
+            STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 STATE_VAR );
     uiZ64 = uiZ.v64;
     uiZ0  = uiZ.v0;
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ64 = defaultNaNExtF80UI64;
     uiZ0  = defaultNaNExtF80UI0;
     goto uiZ;
diff --git a/source/extF80_roundToInt.c b/source/extF80_roundToInt.c
index 8103dae8..2a00ea24 100644
--- a/source/extF80_roundToInt.c
+++ b/source/extF80_roundToInt.c
@@ -42,7 +42,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 
 extFloat80_t
- extF80_roundToInt( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+ extF80_roundToInt(
+     extFloat80_t a, uint_fast8_t roundingMode, bool exact STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64, signUI64;
@@ -79,7 +80,8 @@ extFloat80_t
     if ( 0x403E <= exp ) {
         if ( exp == 0x7FFF ) {
             if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-                uiZ = softfloat_propagateNaNExtF80UI( uiA64, sigA, 0, 0 );
+                uiZ = softfloat_propagateNaNExtF80UI(
+                    uiA64, sigA, 0, 0 STATE_VAR );
                 uiZ64 = uiZ.v64;
                 sigZ  = uiZ.v0;
                 goto uiZ;
@@ -92,7 +94,7 @@ extFloat80_t
         goto uiZ;
     }
     if ( exp <= 0x3FFE ) {
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         switch ( roundingMode ) {
          case softfloat_round_near_even:
             if ( !(sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) break;
@@ -143,7 +145,7 @@ extFloat80_t
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) sigZ |= lastBitMask;
 #endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
  uiZ:
     uZ.s.signExp = uiZ64;
diff --git a/source/extF80_sqrt.c b/source/extF80_sqrt.c
index 5d328a0e..fd3803aa 100644
--- a/source/extF80_sqrt.c
+++ b/source/extF80_sqrt.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-extFloat80_t extF80_sqrt( extFloat80_t a )
+extFloat80_t extF80_sqrt( extFloat80_t a STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -73,7 +73,7 @@ extFloat80_t extF80_sqrt( extFloat80_t a )
     *------------------------------------------------------------------------*/
     if ( expA == 0x7FFF ) {
         if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, 0, 0 );
+            uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, 0, 0 STATE_VAR );
             uiZ64 = uiZ.v64;
             uiZ0  = uiZ.v0;
             goto uiZ;
@@ -154,11 +154,17 @@ extFloat80_t extF80_sqrt( extFloat80_t a )
     }
     return
         softfloat_roundPackToExtF80(
-            0, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
+            0, expZ, sigZ, sigZExtra,
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
+            extF80_roundingPrecision
+#else
+            state->extF80_roundingPrecision
+#endif
+            STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ64 = defaultNaNExtF80UI64;
     uiZ0  = defaultNaNExtF80UI0;
     goto uiZ;
diff --git a/source/extF80_sub.c b/source/extF80_sub.c
index 494d3162..f2173216 100644
--- a/source/extF80_sub.c
+++ b/source/extF80_sub.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-extFloat80_t extF80_sub( extFloat80_t a, extFloat80_t b )
+extFloat80_t extF80_sub( extFloat80_t a, extFloat80_t b STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -53,7 +53,8 @@ extFloat80_t extF80_sub( extFloat80_t a, extFloat80_t b )
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
     extFloat80_t
         (*magsFuncPtr)(
-            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool
+            STATE_VAR );
 #endif
 
     uA.f = a;
@@ -66,14 +67,16 @@ extFloat80_t extF80_sub( extFloat80_t a, extFloat80_t b )
     signB = signExtF80UI64( uiB64 );
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA
+                                        STATE_VAR );
     } else {
-        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA
+                                        STATE_VAR );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80;
-    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA STATE_VAR );
 #endif
 
 }
diff --git a/source/extF80_to_f128.c b/source/extF80_to_f128.c
index 7fbc9cb6..03a51835 100644
--- a/source/extF80_to_f128.c
+++ b/source/extF80_to_f128.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float128_t extF80_to_f128( extFloat80_t a )
+float128_t extF80_to_f128( extFloat80_t a STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -60,7 +60,7 @@ float128_t extF80_to_f128( extFloat80_t a )
     exp = expExtF80UI64( uiA64 );
     frac = uiA0 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
     if ( (exp == 0x7FFF) && frac ) {
-        softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+        softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN STATE_VAR );
         uiZ = softfloat_commonNaNToF128UI( &commonNaN );
     } else {
         sign = signExtF80UI64( uiA64 );
diff --git a/source/extF80_to_f16.c b/source/extF80_to_f16.c
index ca5050f4..5183f3f6 100644
--- a/source/extF80_to_f16.c
+++ b/source/extF80_to_f16.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t extF80_to_f16( extFloat80_t a )
+float16_t extF80_to_f16( extFloat80_t a STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -65,7 +65,7 @@ float16_t extF80_to_f16( extFloat80_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF16UI( &commonNaN );
         } else {
             uiZ = packToF16UI( sign, 0x1F, 0 );
@@ -85,7 +85,7 @@ float16_t extF80_to_f16( extFloat80_t a )
     if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
         if ( exp < -0x40 ) exp = -0x40;
     }
-    return softfloat_roundPackToF16( sign, exp, sig16 );
+    return softfloat_roundPackToF16( sign, exp, sig16 STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/extF80_to_f32.c b/source/extF80_to_f32.c
index 357f56e9..c6677b14 100644
--- a/source/extF80_to_f32.c
+++ b/source/extF80_to_f32.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t extF80_to_f32( extFloat80_t a )
+float32_t extF80_to_f32( extFloat80_t a STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -65,7 +65,7 @@ float32_t extF80_to_f32( extFloat80_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF32UI( &commonNaN );
         } else {
             uiZ = packToF32UI( sign, 0xFF, 0 );
@@ -85,7 +85,7 @@ float32_t extF80_to_f32( extFloat80_t a )
     if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
         if ( exp < -0x1000 ) exp = -0x1000;
     }
-    return softfloat_roundPackToF32( sign, exp, sig32 );
+    return softfloat_roundPackToF32( sign, exp, sig32 STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/extF80_to_f64.c b/source/extF80_to_f64.c
index c3873992..6a97a14c 100644
--- a/source/extF80_to_f64.c
+++ b/source/extF80_to_f64.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t extF80_to_f64( extFloat80_t a )
+float64_t extF80_to_f64( extFloat80_t a STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -71,7 +71,7 @@ float64_t extF80_to_f64( extFloat80_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF64UI( &commonNaN );
         } else {
             uiZ = packToF64UI( sign, 0x7FF, 0 );
@@ -85,7 +85,7 @@ float64_t extF80_to_f64( extFloat80_t a )
     if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
         if ( exp < -0x1000 ) exp = -0x1000;
     }
-    return softfloat_roundPackToF64( sign, exp, sig );
+    return softfloat_roundPackToF64( sign, exp, sig STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/extF80_to_i32.c b/source/extF80_to_i32.c
index 549ca765..9bce5239 100644
--- a/source/extF80_to_i32.c
+++ b/source/extF80_to_i32.c
@@ -42,7 +42,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 
 int_fast32_t
- extF80_to_i32( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+ extF80_to_i32( extFloat80_t a, uint_fast8_t roundingMode, bool exact
+                STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -67,7 +68,7 @@ int_fast32_t
 #elif (i32_fromNaN == i32_fromNegOverflow)
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return i32_fromNaN;
 #endif
     }
@@ -77,7 +78,7 @@ int_fast32_t
     shiftDist = 0x4032 - exp;
     if ( shiftDist <= 0 ) shiftDist = 1;
     sig = softfloat_shiftRightJam64( sig, shiftDist );
-    return softfloat_roundToI32( sign, sig, roundingMode, exact );
+    return softfloat_roundToI32( sign, sig, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/extF80_to_i32_r_minMag.c b/source/extF80_to_i32_r_minMag.c
index 2b7b9e2b..2def1e06 100644
--- a/source/extF80_to_i32_r_minMag.c
+++ b/source/extF80_to_i32_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact )
+int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -62,7 +62,7 @@ int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact )
     shiftDist = 0x403E - exp;
     if ( 64 <= shiftDist ) {
         if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -75,11 +75,11 @@ int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact )
                 && (sig < UINT64_C( 0x8000000100000000 ))
         ) {
             if ( exact && (sig & UINT64_C( 0x00000000FFFFFFFF )) ) {
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
+                softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
             }
             return -0x7FFFFFFF - 1;
         }
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
                 ? i32_fromNaN
@@ -89,7 +89,7 @@ int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact )
     *------------------------------------------------------------------------*/
     absZ = sig>>shiftDist;
     if ( exact && ((uint_fast64_t) (uint_fast32_t) absZ<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return sign ? -absZ : absZ;
 
diff --git a/source/extF80_to_i64.c b/source/extF80_to_i64.c
index 35f55de8..1231499c 100644
--- a/source/extF80_to_i64.c
+++ b/source/extF80_to_i64.c
@@ -42,7 +42,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 
 int_fast64_t
- extF80_to_i64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+ extF80_to_i64( extFloat80_t a, uint_fast8_t roundingMode, bool exact
+                STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -67,7 +68,7 @@ int_fast64_t
         /*--------------------------------------------------------------------
         *--------------------------------------------------------------------*/
         if ( shiftDist ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
             return
                 (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
                     ? i64_fromNaN
@@ -83,7 +84,8 @@ int_fast64_t
         sig = sig64Extra.v;
         sigExtra = sig64Extra.extra;
     }
-    return softfloat_roundToI64( sign, sig, sigExtra, roundingMode, exact );
+    return softfloat_roundToI64( sign, sig, sigExtra, roundingMode, exact
+                                 STATE_VAR );
 
 }
 
diff --git a/source/extF80_to_i64_r_minMag.c b/source/extF80_to_i64_r_minMag.c
index 215876da..cbd96cdb 100644
--- a/source/extF80_to_i64_r_minMag.c
+++ b/source/extF80_to_i64_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact )
+int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -62,7 +62,7 @@ int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact )
     shiftDist = 0x403E - exp;
     if ( 64 <= shiftDist ) {
         if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -76,7 +76,7 @@ int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact )
         ) {
             return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
         }
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
                 ? i64_fromNaN
@@ -86,7 +86,7 @@ int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact )
     *------------------------------------------------------------------------*/
     absZ = sig>>shiftDist;
     if ( exact && (uint64_t) (sig<<(-shiftDist & 63)) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return sign ? -absZ : absZ;
 
diff --git a/source/extF80_to_ui32.c b/source/extF80_to_ui32.c
index d121c480..7ac31982 100644
--- a/source/extF80_to_ui32.c
+++ b/source/extF80_to_ui32.c
@@ -42,7 +42,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 
 uint_fast32_t
- extF80_to_ui32( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+ extF80_to_ui32( extFloat80_t a, uint_fast8_t roundingMode, bool exact
+                 STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -67,7 +68,7 @@ uint_fast32_t
 #elif (ui32_fromNaN == ui32_fromNegOverflow)
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return ui32_fromNaN;
 #endif
     }
@@ -77,7 +78,7 @@ uint_fast32_t
     shiftDist = 0x4032 - exp;
     if ( shiftDist <= 0 ) shiftDist = 1;
     sig = softfloat_shiftRightJam64( sig, shiftDist );
-    return softfloat_roundToUI32( sign, sig, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/extF80_to_ui32_r_minMag.c b/source/extF80_to_ui32_r_minMag.c
index ad304834..a1fe4b97 100644
--- a/source/extF80_to_ui32_r_minMag.c
+++ b/source/extF80_to_ui32_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact )
+uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -62,7 +62,7 @@ uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact )
     shiftDist = 0x403E - exp;
     if ( 64 <= shiftDist ) {
         if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -70,7 +70,7 @@ uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact )
     *------------------------------------------------------------------------*/
     sign = signExtF80UI64( uiA64 );
     if ( sign || (shiftDist < 32) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
                 ? ui32_fromNaN
@@ -80,7 +80,7 @@ uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact )
     *------------------------------------------------------------------------*/
     z = sig>>shiftDist;
     if ( exact && ((uint_fast64_t) z<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return z;
 
diff --git a/source/extF80_to_ui64.c b/source/extF80_to_ui64.c
index a81bbd1b..f86c2671 100644
--- a/source/extF80_to_ui64.c
+++ b/source/extF80_to_ui64.c
@@ -42,7 +42,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 
 uint_fast64_t
- extF80_to_ui64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+ extF80_to_ui64( extFloat80_t a, uint_fast8_t roundingMode, bool exact
+                 STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -64,7 +65,7 @@ uint_fast64_t
     *------------------------------------------------------------------------*/
     shiftDist = 0x403E - exp;
     if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
                 ? ui64_fromNaN
@@ -78,7 +79,8 @@ uint_fast64_t
         sig = sig64Extra.v;
         sigExtra = sig64Extra.extra;
     }
-    return softfloat_roundToUI64( sign, sig, sigExtra, roundingMode, exact );
+    return softfloat_roundToUI64( sign, sig, sigExtra, roundingMode, exact
+                                  STATE_VAR );
 
 }
 
diff --git a/source/extF80_to_ui64_r_minMag.c b/source/extF80_to_ui64_r_minMag.c
index 65adfe7e..adddda47 100644
--- a/source/extF80_to_ui64_r_minMag.c
+++ b/source/extF80_to_ui64_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact )
+uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact STATE_PARAM )
 {
     union { struct extFloat80M s; extFloat80_t f; } uA;
     uint_fast16_t uiA64;
@@ -62,7 +62,7 @@ uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact )
     shiftDist = 0x403E - exp;
     if ( 64 <= shiftDist ) {
         if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -70,7 +70,7 @@ uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact )
     *------------------------------------------------------------------------*/
     sign = signExtF80UI64( uiA64 );
     if ( sign || (shiftDist < 0) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
                 ? ui64_fromNaN
@@ -80,7 +80,7 @@ uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact )
     *------------------------------------------------------------------------*/
     z = sig>>shiftDist;
     if ( exact && (z<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return z;
 
diff --git a/source/f128M_add.c b/source/f128M_add.c
index f39b1ff7..b49292cc 100644
--- a/source/f128M_add.c
+++ b/source/f128M_add.c
@@ -43,7 +43,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef SOFTFLOAT_FAST_INT64
 
 void
- f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr
+            STATE_PARAM )
 {
     const uint64_t *aWPtr, *bWPtr;
     uint_fast64_t uiA64, uiA0;
@@ -53,7 +54,8 @@ void
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
     float128_t
         (*magsFuncPtr)(
-            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool
+            STATE_VAR );
 #endif
 
     aWPtr = (const uint64_t *) aPtr;
@@ -66,14 +68,16 @@ void
     signB = signF128UI64( uiB64 );
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA
+                                       STATE_VAR );
     } else {
-        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA
+                                       STATE_VAR );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128;
-    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA STATE_VAR );
 #endif
 
 }
diff --git a/source/f128M_div.c b/source/f128M_div.c
index 8355dc20..b93bb849 100644
--- a/source/f128M_div.c
+++ b/source/f128M_div.c
@@ -44,17 +44,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef SOFTFLOAT_FAST_INT64
 
 void
- f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr
+            STATE_PARAM )
 {
 
-    *zPtr = f128_div( *aPtr, *bPtr );
+    *zPtr = f128_div( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
 void
- f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr
+            STATE_PARAM )
 {
     const uint32_t *aWPtr, *bWPtr;
     uint32_t *zWPtr, uiA96;
@@ -104,7 +106,7 @@ void
         goto zero;
     }
     if ( expB == -128 ) {
-        softfloat_raiseFlags( softfloat_flag_infinite );
+        softfloat_raiseFlags( softfloat_flag_infinite STATE_VAR );
         goto infinity;
     }
     /*------------------------------------------------------------------------
@@ -161,12 +163,12 @@ void
     q64 = ((uint64_t) qs[2]<<19) + (q64>>32);
     y[indexWord( 5, 3 )] = q64;
     y[indexWord( 5, 4 )] = q64>>32;
-    softfloat_roundPackMToF128M( signZ, expZ, y, zWPtr );
+    softfloat_roundPackMToF128M( signZ, expZ, y, zWPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidF128M( zWPtr );
+    softfloat_invalidF128M( zWPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
diff --git a/source/f128M_eq.c b/source/f128M_eq.c
index 4f28f5f3..bcda537f 100644
--- a/source/f128M_eq.c
+++ b/source/f128M_eq.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr STATE_PARAM )
 {
 
-    return f128_eq( *aPtr, *bPtr );
+    return f128_eq( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
-bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr STATE_PARAM )
 {
     const uint32_t *aWPtr, *bWPtr;
     uint32_t wordA, wordB, uiA96, uiB96;
@@ -90,7 +90,7 @@ bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
            f128M_isSignalingNaN( (const float128_t *) aWPtr )
         || f128M_isSignalingNaN( (const float128_t *) bWPtr )
     ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     }
     return false;
 
diff --git a/source/f128M_eq_signaling.c b/source/f128M_eq_signaling.c
index d2ea5f43..57987f9a 100644
--- a/source/f128M_eq_signaling.c
+++ b/source/f128M_eq_signaling.c
@@ -43,16 +43,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr
+                         STATE_PARAM )
 {
 
-    return f128_eq_signaling( *aPtr, *bPtr );
+    return f128_eq_signaling( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
-bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr
+                         STATE_PARAM )
 {
     const uint32_t *aWPtr, *bWPtr;
     uint32_t wordA, wordB, uiA96, uiB96;
@@ -62,7 +64,7 @@ bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
     aWPtr = (const uint32_t *) aPtr;
     bWPtr = (const uint32_t *) bPtr;
     if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     wordA = aWPtr[indexWord( 4, 2 )];
diff --git a/source/f128M_le.c b/source/f128M_le.c
index af1dcba7..b7b28085 100644
--- a/source/f128M_le.c
+++ b/source/f128M_le.c
@@ -42,16 +42,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_le( const float128_t *aPtr, const float128_t *bPtr STATE_PARAM )
 {
 
-    return f128_le( *aPtr, *bPtr );
+    return f128_le( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
-bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_le( const float128_t *aPtr, const float128_t *bPtr STATE_PARAM )
 {
     const uint32_t *aWPtr, *bWPtr;
     uint32_t uiA96, uiB96;
@@ -61,7 +61,7 @@ bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
     aWPtr = (const uint32_t *) aPtr;
     bWPtr = (const uint32_t *) bPtr;
     if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     uiA96 = aWPtr[indexWordHi( 4 )];
diff --git a/source/f128M_le_quiet.c b/source/f128M_le_quiet.c
index 0d051b65..a1628a19 100644
--- a/source/f128M_le_quiet.c
+++ b/source/f128M_le_quiet.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr STATE_PARAM)
 {
 
-    return f128_le_quiet( *aPtr, *bPtr );
+    return f128_le_quiet( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
-bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr STATE_PARAM)
 {
     const uint32_t *aWPtr, *bWPtr;
     uint32_t uiA96, uiB96;
@@ -63,7 +63,7 @@ bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
     bWPtr = (const uint32_t *) bPtr;
     if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
         if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f128M_lt.c b/source/f128M_lt.c
index 64ff9b45..18412c6c 100644
--- a/source/f128M_lt.c
+++ b/source/f128M_lt.c
@@ -42,16 +42,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr STATE_PARAM )
 {
 
-    return f128_lt( *aPtr, *bPtr );
+    return f128_lt( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
-bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr STATE_PARAM )
 {
     const uint32_t *aWPtr, *bWPtr;
     uint32_t uiA96, uiB96;
@@ -61,7 +61,7 @@ bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
     aWPtr = (const uint32_t *) aPtr;
     bWPtr = (const uint32_t *) bPtr;
     if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     uiA96 = aWPtr[indexWordHi( 4 )];
diff --git a/source/f128M_lt_quiet.c b/source/f128M_lt_quiet.c
index 6ccf3c86..ca3a2ee1 100644
--- a/source/f128M_lt_quiet.c
+++ b/source/f128M_lt_quiet.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr STATE_PARAM)
 {
 
-    return f128_lt_quiet( *aPtr, *bPtr );
+    return f128_lt_quiet( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
-bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
+bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr STATE_PARAM)
 {
     const uint32_t *aWPtr, *bWPtr;
     uint32_t uiA96, uiB96;
@@ -63,7 +63,7 @@ bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
     bWPtr = (const uint32_t *) bPtr;
     if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
         if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f128M_mul.c b/source/f128M_mul.c
index f2d6051e..5c7ec957 100644
--- a/source/f128M_mul.c
+++ b/source/f128M_mul.c
@@ -44,17 +44,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef SOFTFLOAT_FAST_INT64
 
 void
- f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr
+            STATE_PARAM )
 {
 
-    *zPtr = f128_mul( *aPtr, *bPtr );
+    *zPtr = f128_mul( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
 void
- f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr
+            STATE_PARAM )
 {
     const uint32_t *aWPtr, *bWPtr;
     uint32_t *zWPtr;
@@ -96,7 +98,7 @@ void
                     && ! (ptr[indexWord( 4, 2 )] | ptr[indexWord( 4, 1 )]
                               | ptr[indexWord( 4, 0 )])
             ) {
-                softfloat_invalidF128M( zWPtr );
+                softfloat_invalidF128M( zWPtr STATE_VAR );
                 return;
             }
         }
@@ -140,7 +142,7 @@ void
         shiftDist = 15;
     }
     softfloat_shortShiftLeft160M( extSigZPtr, shiftDist, extSigZPtr );
-    softfloat_roundPackMToF128M( signZ, expZ, extSigZPtr, zWPtr );
+    softfloat_roundPackMToF128M( signZ, expZ, extSigZPtr, zWPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
diff --git a/source/f128M_mulAdd.c b/source/f128M_mulAdd.c
index e2f95df0..58a72f59 100644
--- a/source/f128M_mulAdd.c
+++ b/source/f128M_mulAdd.c
@@ -47,6 +47,7 @@ void
      const float128_t *bPtr,
      const float128_t *cPtr,
      float128_t *zPtr
+     STATE_PARAM
  )
 {
     const uint64_t *aWPtr, *bWPtr, *cWPtr;
@@ -63,7 +64,8 @@ void
     uiB0  = bWPtr[indexWord( 2, 0 )];
     uiC64 = cWPtr[indexWord( 2, 1 )];
     uiC0  = cWPtr[indexWord( 2, 0 )];
-    *zPtr = softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 );
+    *zPtr = softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0
+                                  STATE_VAR );
 
 }
 
@@ -75,6 +77,7 @@ void
      const float128_t *bPtr,
      const float128_t *cPtr,
      float128_t *zPtr
+     STATE_PARAM
  )
 {
 
@@ -84,6 +87,7 @@ void
         (const uint32_t *) cPtr,
         (uint32_t *) zPtr,
         0
+        STATE_VAR
     );
 
 }
diff --git a/source/f128M_rem.c b/source/f128M_rem.c
index 645ec993..367ba189 100644
--- a/source/f128M_rem.c
+++ b/source/f128M_rem.c
@@ -44,17 +44,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef SOFTFLOAT_FAST_INT64
 
 void
- f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr
+            STATE_PARAM )
 {
 
-    *zPtr = f128_rem( *aPtr, *bPtr );
+    *zPtr = f128_rem( *aPtr, *bPtr STATE_VAR );
 
 }
 
 #else
 
 void
- f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr
+            STATE_PARAM )
 {
     const uint32_t *aWPtr, *bWPtr;
     uint32_t *zWPtr, uiA96;
@@ -166,7 +168,7 @@ void
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidF128M( zWPtr );
+    softfloat_invalidF128M( zWPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
diff --git a/source/f128M_roundToInt.c b/source/f128M_roundToInt.c
index c4671265..46208c58 100644
--- a/source/f128M_roundToInt.c
+++ b/source/f128M_roundToInt.c
@@ -49,10 +49,11 @@ void
      uint_fast8_t roundingMode,
      bool exact,
      float128_t *zPtr
+     STATE_PARAM
  )
 {
 
-    *zPtr = f128_roundToInt( *aPtr, roundingMode, exact );
+    *zPtr = f128_roundToInt( *aPtr, roundingMode, exact STATE_VAR );
 
 }
 
@@ -64,6 +65,7 @@ void
      uint_fast8_t roundingMode,
      bool exact,
      float128_t *zPtr
+     STATE_PARAM
  )
 {
     const uint32_t *aWPtr;
@@ -99,7 +101,7 @@ void
             sigExtra = aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )];
         }
         if ( !sigExtra && !(ui96 & 0x7FFFFFFF) ) goto ui96;
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         sign = signF128UI96( ui96 );
         switch ( roundingMode ) {
          case softfloat_round_near_even:
@@ -133,7 +135,7 @@ void
                         || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
                                 | aWPtr[indexWord( 4, 0 )]))
         ) {
-            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
+            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr STATE_VAR );
             return;
         }
         zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
@@ -166,7 +168,7 @@ void
         bit <<= 1;
         extrasMask = bit - 1;
         if ( exact && (extra || (wordA & extrasMask)) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         if (
             (roundingMode == softfloat_round_near_even)
@@ -187,7 +189,7 @@ void
         carry = 0;
         extrasMask = bit - 1;
         if ( extra || (wordA & extrasMask) ) {
-            if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+            if ( exact ) softfloat_raiseFlags(softfloat_flag_inexact STATE_VAR);
             if (
                 roundingMode
                     == (signF128UI96( ui96 ) ? softfloat_round_min
diff --git a/source/f128M_sqrt.c b/source/f128M_sqrt.c
index 1ede5eff..0515e7f3 100644
--- a/source/f128M_sqrt.c
+++ b/source/f128M_sqrt.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
+void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr STATE_PARAM )
 {
 
-    *zPtr = f128_sqrt( *aPtr );
+    *zPtr = f128_sqrt( *aPtr STATE_VAR );
 
 }
 
 #else
 
-void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
+void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr STATE_PARAM )
 {
     const uint32_t *aWPtr;
     uint32_t *zWPtr;
@@ -85,7 +85,7 @@ void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
                 || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
                         | aWPtr[indexWord( 4, 0 )])
         ) {
-            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
+            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr STATE_VAR );
             return;
         }
         if ( ! signA ) goto copyA;
@@ -207,12 +207,12 @@ void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
             }
         }
     }
-    softfloat_roundPackMToF128M( 0, expZ, y, zWPtr );
+    softfloat_roundPackMToF128M( 0, expZ, y, zWPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidF128M( zWPtr );
+    softfloat_invalidF128M( zWPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
diff --git a/source/f128M_sub.c b/source/f128M_sub.c
index 1b609fda..55d38710 100644
--- a/source/f128M_sub.c
+++ b/source/f128M_sub.c
@@ -43,7 +43,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef SOFTFLOAT_FAST_INT64
 
 void
- f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr
+            STATE_PARAM )
 {
     const uint64_t *aWPtr, *bWPtr;
     uint_fast64_t uiA64, uiA0;
@@ -53,7 +54,8 @@ void
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
     float128_t
         (*magsFuncPtr)(
-            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool
+            STATE_PARAM );
 #endif
 
     aWPtr = (const uint64_t *) aPtr;
@@ -66,14 +68,16 @@ void
     signB = signF128UI64( uiB64 );
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA
+                                       STATE_VAR );
     } else {
-        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA
+                                       STATE_VAR );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128;
-    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA STATE_VAR );
 #endif
 
 }
@@ -81,7 +85,8 @@ void
 #else
 
 void
- f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+ f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr
+            STATE_PARAM )
 {
 
     softfloat_addF128M(
@@ -89,6 +94,7 @@ void
         (const uint32_t *) bPtr,
         (uint32_t *) zPtr,
         true
+        STATE_VAR
     );
 
 }
diff --git a/source/f128M_to_extF80M.c b/source/f128M_to_extF80M.c
index fe8b0fc8..296f128b 100644
--- a/source/f128M_to_extF80M.c
+++ b/source/f128M_to_extF80M.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
+void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr STATE_PARAM )
 {
 
-    *zPtr = f128_to_extF80( *aPtr );
+    *zPtr = f128_to_extF80( *aPtr STATE_VAR );
 
 }
 
 #else
 
-void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
+void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr STATE_PARAM )
 {
     const uint32_t *aWPtr;
     struct extFloat80M *zSPtr;
@@ -75,7 +75,7 @@ void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( softfloat_isNaNF128M( aWPtr ) ) {
-            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+            softfloat_f128MToCommonNaN( aWPtr, &commonNaN STATE_VAR );
             softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
             return;
         }
@@ -93,7 +93,7 @@ void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
     }
     if ( sig[indexWord( 4, 0 )] ) sig[indexWord( 4, 1 )] |= 1;
     softfloat_roundPackMToExtF80M(
-        sign, exp, &sig[indexMultiwordHi( 4, 3 )], 80, zSPtr );
+        sign, exp, &sig[indexMultiwordHi( 4, 3 )], 80, zSPtr STATE_VAR );
 
 }
 
diff --git a/source/f128M_to_f16.c b/source/f128M_to_f16.c
index 4f0c5bb2..11ae99ca 100644
--- a/source/f128M_to_f16.c
+++ b/source/f128M_to_f16.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-float16_t f128M_to_f16( const float128_t *aPtr )
+float16_t f128M_to_f16( const float128_t *aPtr STATE_PARAM )
 {
 
-    return f128_to_f16( *aPtr );
+    return f128_to_f16( *aPtr STATE_VAR );
 
 }
 
 #else
 
-float16_t f128M_to_f16( const float128_t *aPtr )
+float16_t f128M_to_f16( const float128_t *aPtr STATE_PARAM )
 {
     const uint32_t *aWPtr;
     uint32_t uiA96;
@@ -80,7 +80,7 @@ float16_t f128M_to_f16( const float128_t *aPtr )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( frac32 ) {
-            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+            softfloat_f128MToCommonNaN( aWPtr, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF16UI( &commonNaN );
         } else {
             uiZ = packToF16UI( sign, 0x1F, 0 );
@@ -100,7 +100,7 @@ float16_t f128M_to_f16( const float128_t *aPtr )
     if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
         if ( exp < -0x40 ) exp = -0x40;
     }
-    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 );
+    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/f128M_to_f32.c b/source/f128M_to_f32.c
index 8b73de08..53d1e644 100644
--- a/source/f128M_to_f32.c
+++ b/source/f128M_to_f32.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-float32_t f128M_to_f32( const float128_t *aPtr )
+float32_t f128M_to_f32( const float128_t *aPtr STATE_PARAM )
 {
 
-    return f128_to_f32( *aPtr );
+    return f128_to_f32( *aPtr STATE_VAR );
 
 }
 
 #else
 
-float32_t f128M_to_f32( const float128_t *aPtr )
+float32_t f128M_to_f32( const float128_t *aPtr STATE_PARAM )
 {
     const uint32_t *aWPtr;
     uint32_t uiA96;
@@ -76,7 +76,7 @@ float32_t f128M_to_f32( const float128_t *aPtr )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( frac64 ) {
-            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+            softfloat_f128MToCommonNaN( aWPtr, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF32UI( &commonNaN );
         } else {
             uiZ = packToF32UI( sign, 0xFF, 0 );
@@ -96,7 +96,7 @@ float32_t f128M_to_f32( const float128_t *aPtr )
     if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
         if ( exp < -0x1000 ) exp = -0x1000;
     }
-    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 );
+    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/f128M_to_f64.c b/source/f128M_to_f64.c
index 1cddd347..1290c3f7 100644
--- a/source/f128M_to_f64.c
+++ b/source/f128M_to_f64.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-float64_t f128M_to_f64( const float128_t *aPtr )
+float64_t f128M_to_f64( const float128_t *aPtr STATE_PARAM )
 {
 
-    return f128_to_f64( *aPtr );
+    return f128_to_f64( *aPtr STATE_VAR );
 
 }
 
 #else
 
-float64_t f128M_to_f64( const float128_t *aPtr )
+float64_t f128M_to_f64( const float128_t *aPtr STATE_PARAM )
 {
     const uint32_t *aWPtr;
     uint32_t uiA96;
@@ -75,7 +75,7 @@ float64_t f128M_to_f64( const float128_t *aPtr )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( frac64 || aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) {
-            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+            softfloat_f128MToCommonNaN( aWPtr, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF64UI( &commonNaN );
         } else {
             uiZ = packToF64UI( sign, 0x7FF, 0 );
@@ -99,7 +99,7 @@ float64_t f128M_to_f64( const float128_t *aPtr )
     }
     return
         softfloat_roundPackToF64(
-            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) );
+            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/f128M_to_i32.c b/source/f128M_to_i32.c
index 1265c60a..8bf50300 100644
--- a/source/f128M_to_i32.c
+++ b/source/f128M_to_i32.c
@@ -44,17 +44,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef SOFTFLOAT_FAST_INT64
 
 int_fast32_t
- f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact
+               STATE_PARAM )
 {
 
-    return f128_to_i32( *aPtr, roundingMode, exact );
+    return f128_to_i32( *aPtr, roundingMode, exact STATE_VAR );
 
 }
 
 #else
 
 int_fast32_t
- f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact
+               STATE_PARAM )
 {
     const uint32_t *aWPtr;
     uint32_t uiA96;
@@ -80,7 +82,7 @@ int_fast32_t
 #elif (i32_fromNaN == i32_fromNegOverflow)
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return i32_fromNaN;
 #endif
     }
@@ -90,7 +92,7 @@ int_fast32_t
     if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
     shiftDist = 0x4023 - exp;
     if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToI32( sign, sig64, roundingMode, exact );
+    return softfloat_roundToI32( sign, sig64, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/f128M_to_i32_r_minMag.c b/source/f128M_to_i32_r_minMag.c
index dde3dea2..cc89057e 100644
--- a/source/f128M_to_i32_r_minMag.c
+++ b/source/f128M_to_i32_r_minMag.c
@@ -43,16 +43,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact )
+int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact
+                                    STATE_PARAM )
 {
 
-    return f128_to_i32_r_minMag( *aPtr, exact );
+    return f128_to_i32_r_minMag( *aPtr, exact STATE_VAR );
 
 }
 
 #else
 
-int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact )
+int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact
+                                    STATE_PARAM )
 {
     const uint32_t *aWPtr;
     uint32_t uiA96;
@@ -75,7 +77,7 @@ int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact )
     *------------------------------------------------------------------------*/
     if ( exp < 0x3FFF ) {
         if ( exact && (exp | sig64) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -88,14 +90,14 @@ int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact )
     uiZ = sign ? -absZ : absZ;
     if ( uiZ>>31 != sign ) goto invalid;
     if ( exact && ((uint64_t) absZ<<shiftDist != sig64) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     uZ.ui = uiZ;
     return uZ.i;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FFF) && sig64 ? i32_fromNaN
             : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
diff --git a/source/f128M_to_i64.c b/source/f128M_to_i64.c
index c30673f5..fdf797d0 100644
--- a/source/f128M_to_i64.c
+++ b/source/f128M_to_i64.c
@@ -44,17 +44,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef SOFTFLOAT_FAST_INT64
 
 int_fast64_t
- f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact
+               STATE_PARAM )
 {
 
-    return f128_to_i64( *aPtr, roundingMode, exact );
+    return f128_to_i64( *aPtr, roundingMode, exact STATE_VAR );
 
 }
 
 #else
 
 int_fast64_t
- f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact
+               STATE_PARAM )
 {
     const uint32_t *aWPtr;
     uint32_t uiA96;
@@ -75,7 +77,7 @@ int_fast64_t
     *------------------------------------------------------------------------*/
     shiftDist = 0x404F - exp;
     if ( shiftDist < 17 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FFF)
                 && (sig96
@@ -94,7 +96,7 @@ int_fast64_t
     softfloat_shiftRightJam128M( sig, shiftDist, sig );
     return
         softfloat_roundMToI64(
-            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact );
+            sign, sig + indexMultiwordLo(4, 3), roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/f128M_to_i64_r_minMag.c b/source/f128M_to_i64_r_minMag.c
index bcc79502..778bac65 100644
--- a/source/f128M_to_i64_r_minMag.c
+++ b/source/f128M_to_i64_r_minMag.c
@@ -43,16 +43,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact )
+int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact
+                                    STATE_PARAM )
 {
 
-    return f128_to_i64_r_minMag( *aPtr, exact );
+    return f128_to_i64_r_minMag( *aPtr, exact STATE_VAR );
 
 }
 
 #else
 
-int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact )
+int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact
+                                    STATE_PARAM )
 {
     const uint32_t *aWPtr;
     uint32_t uiA96;
@@ -87,7 +89,7 @@ int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact )
             goto invalid;
         }
         if ( sig[indexWordLo( 4 )] ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
     } else {
         if ( 64 <= shiftDist ) return 0;
@@ -109,7 +111,7 @@ int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact )
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FFF)
             && (sig96
diff --git a/source/f128M_to_ui32.c b/source/f128M_to_ui32.c
index 33ed93a3..1ef56c97 100644
--- a/source/f128M_to_ui32.c
+++ b/source/f128M_to_ui32.c
@@ -44,17 +44,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef SOFTFLOAT_FAST_INT64
 
 uint_fast32_t
- f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact
+                STATE_PARAM )
 {
 
-    return f128_to_ui32( *aPtr, roundingMode, exact );
+    return f128_to_ui32( *aPtr, roundingMode, exact STATE_VAR );
 
 }
 
 #else
 
 uint_fast32_t
- f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact
+                STATE_PARAM )
 {
     const uint32_t *aWPtr;
     uint32_t uiA96;
@@ -80,7 +82,7 @@ uint_fast32_t
 #elif (ui32_fromNaN == ui32_fromNegOverflow)
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return ui32_fromNaN;
 #endif
     }
@@ -90,7 +92,7 @@ uint_fast32_t
     if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
     shiftDist = 0x4023 - exp;
     if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig64, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/f128M_to_ui32_r_minMag.c b/source/f128M_to_ui32_r_minMag.c
index 87813c04..abea6f6f 100644
--- a/source/f128M_to_ui32_r_minMag.c
+++ b/source/f128M_to_ui32_r_minMag.c
@@ -43,16 +43,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
+uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact
+                                      STATE_PARAM )
 {
 
-    return f128_to_ui32_r_minMag( *aPtr, exact );
+    return f128_to_ui32_r_minMag( *aPtr, exact STATE_VAR );
 
 }
 
 #else
 
-uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
+uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact
+                                      STATE_PARAM )
 {
     const uint32_t *aWPtr;
     uint32_t uiA96;
@@ -74,7 +76,7 @@ uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
     shiftDist = 0x402F - exp;
     if ( 49 <= shiftDist ) {
         if ( exact && (exp | sig64) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -82,7 +84,7 @@ uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
     *------------------------------------------------------------------------*/
     sign = signF128UI96( uiA96 );
     if ( sign || (shiftDist < 17) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FFF) && sig64 ? ui32_fromNaN
                 : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
@@ -92,7 +94,7 @@ uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
     sig64 |= UINT64_C( 0x0001000000000000 );
     z = sig64>>shiftDist;
     if ( exact && ((uint64_t) z<<shiftDist != sig64) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return z;
 
diff --git a/source/f128M_to_ui64.c b/source/f128M_to_ui64.c
index 86c80d34..cf6008ed 100644
--- a/source/f128M_to_ui64.c
+++ b/source/f128M_to_ui64.c
@@ -44,17 +44,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef SOFTFLOAT_FAST_INT64
 
 uint_fast64_t
- f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact
+                STATE_PARAM )
 {
 
-    return f128_to_ui64( *aPtr, roundingMode, exact );
+    return f128_to_ui64( *aPtr, roundingMode, exact STATE_VAR );
 
 }
 
 #else
 
 uint_fast64_t
- f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+ f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact
+                STATE_PARAM )
 {
     const uint32_t *aWPtr;
     uint32_t uiA96;
@@ -75,7 +77,7 @@ uint_fast64_t
     *------------------------------------------------------------------------*/
     shiftDist = 0x404F - exp;
     if ( shiftDist < 17 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FFF)
                 && (sig96
@@ -94,7 +96,8 @@ uint_fast64_t
     softfloat_shiftRightJam128M( sig, shiftDist, sig );
     return
         softfloat_roundMToUI64(
-            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact );
+            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact
+            STATE_VAR );
 
 }
 
diff --git a/source/f128M_to_ui64_r_minMag.c b/source/f128M_to_ui64_r_minMag.c
index 503a6058..3e2ca5cc 100644
--- a/source/f128M_to_ui64_r_minMag.c
+++ b/source/f128M_to_ui64_r_minMag.c
@@ -43,16 +43,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact )
+uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact
+                                      STATE_PARAM )
 {
 
-    return f128_to_ui64_r_minMag( *aPtr, exact );
+    return f128_to_ui64_r_minMag( *aPtr, exact STATE_VAR );
 
 }
 
 #else
 
-uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact )
+uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact
+                                      STATE_PARAM )
 {
     const uint32_t *aWPtr;
     uint32_t uiA96;
@@ -84,7 +86,7 @@ uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact )
         z = (uint64_t) sig[indexWord( 4, 2 )]<<32 | sig[indexWord( 4, 1 )];
         if ( sign && z ) goto invalid;
         if ( sig[indexWordLo( 4 )] ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
     } else {
         if ( 64 <= shiftDist ) return 0;
@@ -99,7 +101,7 @@ uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact )
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FFF)
             && (sig96
diff --git a/source/f128_add.c b/source/f128_add.c
index 2f6c6b5a..3b6c6dfe 100644
--- a/source/f128_add.c
+++ b/source/f128_add.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float128_t f128_add( float128_t a, float128_t b )
+float128_t f128_add( float128_t a, float128_t b STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -51,7 +51,8 @@ float128_t f128_add( float128_t a, float128_t b )
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
     float128_t
         (*magsFuncPtr)(
-            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool
+            STATE_PARAM );
 #endif
 
     uA.f = a;
@@ -64,14 +65,14 @@ float128_t f128_add( float128_t a, float128_t b )
     signB = signF128UI64( uiB64 );
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_addMagsF128(uiA64, uiA0, uiB64, uiB0, signA STATE_VAR);
     } else {
-        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_subMagsF128(uiA64, uiA0, uiB64, uiB0, signA STATE_VAR);
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128;
-    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA STATE_VAR );
 #endif
 
 }
diff --git a/source/f128_div.c b/source/f128_div.c
index dcd3ecbd..aac3fca6 100644
--- a/source/f128_div.c
+++ b/source/f128_div.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float128_t f128_div( float128_t a, float128_t b )
+float128_t f128_div( float128_t a, float128_t b STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -103,7 +103,7 @@ float128_t f128_div( float128_t a, float128_t b )
     if ( ! expB ) {
         if ( ! (sigB.v64 | sigB.v0) ) {
             if ( ! (expA | sigA.v64 | sigA.v0) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
+            softfloat_raiseFlags( softfloat_flag_infinite STATE_VAR );
             goto infinity;
         }
         normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 );
@@ -167,16 +167,17 @@ float128_t f128_div( float128_t a, float128_t b )
             term.v64, term.v0
         );
     return
-        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
+        softfloat_roundPackToF128(
+            signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ.v64 = defaultNaNF128UI64;
     uiZ.v0  = defaultNaNF128UI0;
     goto uiZ;
diff --git a/source/f128_eq.c b/source/f128_eq.c
index 65183dae..ec8daf3d 100644
--- a/source/f128_eq.c
+++ b/source/f128_eq.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f128_eq( float128_t a, float128_t b )
+bool f128_eq( float128_t a, float128_t b STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -59,7 +59,7 @@ bool f128_eq( float128_t a, float128_t b )
                softfloat_isSigNaNF128UI( uiA64, uiA0 )
             || softfloat_isSigNaNF128UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f128_eq_signaling.c b/source/f128_eq_signaling.c
index 892b7da1..3ea0de7e 100644
--- a/source/f128_eq_signaling.c
+++ b/source/f128_eq_signaling.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool f128_eq_signaling( float128_t a, float128_t b )
+bool f128_eq_signaling( float128_t a, float128_t b STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -54,7 +54,7 @@ bool f128_eq_signaling( float128_t a, float128_t b )
     uiB64 = uB.ui.v64;
     uiB0  = uB.ui.v0;
     if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     return
diff --git a/source/f128_le.c b/source/f128_le.c
index 28d452bd..799e28a4 100644
--- a/source/f128_le.c
+++ b/source/f128_le.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool f128_le( float128_t a, float128_t b )
+bool f128_le( float128_t a, float128_t b STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -55,7 +55,7 @@ bool f128_le( float128_t a, float128_t b )
     uiB64 = uB.ui.v64;
     uiB0  = uB.ui.v0;
     if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     signA = signF128UI64( uiA64 );
diff --git a/source/f128_le_quiet.c b/source/f128_le_quiet.c
index f3ea5a65..1bfebee5 100644
--- a/source/f128_le_quiet.c
+++ b/source/f128_le_quiet.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f128_le_quiet( float128_t a, float128_t b )
+bool f128_le_quiet( float128_t a, float128_t b STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -60,7 +60,7 @@ bool f128_le_quiet( float128_t a, float128_t b )
                softfloat_isSigNaNF128UI( uiA64, uiA0 )
             || softfloat_isSigNaNF128UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f128_lt.c b/source/f128_lt.c
index 97589a47..a4158473 100644
--- a/source/f128_lt.c
+++ b/source/f128_lt.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool f128_lt( float128_t a, float128_t b )
+bool f128_lt( float128_t a, float128_t b STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -55,7 +55,7 @@ bool f128_lt( float128_t a, float128_t b )
     uiB64 = uB.ui.v64;
     uiB0  = uB.ui.v0;
     if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     signA = signF128UI64( uiA64 );
diff --git a/source/f128_lt_quiet.c b/source/f128_lt_quiet.c
index 0daf3295..76f56e1f 100644
--- a/source/f128_lt_quiet.c
+++ b/source/f128_lt_quiet.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f128_lt_quiet( float128_t a, float128_t b )
+bool f128_lt_quiet( float128_t a, float128_t b STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -60,7 +60,7 @@ bool f128_lt_quiet( float128_t a, float128_t b )
                softfloat_isSigNaNF128UI( uiA64, uiA0 )
             || softfloat_isSigNaNF128UI( uiB64, uiB0 )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f128_mul.c b/source/f128_mul.c
index 7dff6edf..3c3e3ef4 100644
--- a/source/f128_mul.c
+++ b/source/f128_mul.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float128_t f128_mul( float128_t a, float128_t b )
+float128_t f128_mul( float128_t a, float128_t b STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -132,17 +132,18 @@ float128_t f128_mul( float128_t a, float128_t b )
         sigZExtra = sig128Extra.extra;
     }
     return
-        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
+        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra
+                                   STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  infArg:
     if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         uiZ.v64 = defaultNaNF128UI64;
         uiZ.v0  = defaultNaNF128UI0;
         goto uiZ;
diff --git a/source/f128_mulAdd.c b/source/f128_mulAdd.c
index 8d4850e6..bd3b4f27 100644
--- a/source/f128_mulAdd.c
+++ b/source/f128_mulAdd.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float128_t f128_mulAdd( float128_t a, float128_t b, float128_t c )
+float128_t f128_mulAdd( float128_t a, float128_t b, float128_t c STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -57,7 +57,8 @@ float128_t f128_mulAdd( float128_t a, float128_t b, float128_t c )
     uC.f = c;
     uiC64 = uC.ui.v64;
     uiC0  = uC.ui.v0;
-    return softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 );
+    return softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0
+                                 STATE_VAR );
 
 }
 
diff --git a/source/f128_rem.c b/source/f128_rem.c
index 28d3df6c..9b68a363 100644
--- a/source/f128_rem.c
+++ b/source/f128_rem.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float128_t f128_rem( float128_t a, float128_t b )
+float128_t f128_rem( float128_t a, float128_t b STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -170,16 +170,17 @@ float128_t f128_rem( float128_t a, float128_t b )
         signRem = ! signRem;
         rem = softfloat_sub128( 0, 0, rem.v64, rem.v0 );
     }
-    return softfloat_normRoundPackToF128( signRem, expB - 1, rem.v64, rem.v0 );
+    return softfloat_normRoundPackToF128(
+        signRem, expB - 1, rem.v64, rem.v0 STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ.v64 = defaultNaNF128UI64;
     uiZ.v0  = defaultNaNF128UI0;
  uiZ:
diff --git a/source/f128_roundToInt.c b/source/f128_roundToInt.c
index 96ae30e3..b03cb90d 100644
--- a/source/f128_roundToInt.c
+++ b/source/f128_roundToInt.c
@@ -42,7 +42,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 
 float128_t
- f128_roundToInt( float128_t a, uint_fast8_t roundingMode, bool exact )
+ f128_roundToInt( float128_t a, uint_fast8_t roundingMode, bool exact
+                  STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -66,7 +67,7 @@ float128_t
         *--------------------------------------------------------------------*/
         if ( 0x406F <= exp ) {
             if ( (exp == 0x7FFF) && (fracF128UI64( uiA64 ) | uiA0) ) {
-                uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 );
+                uiZ = softfloat_propagateNaNF128UI(uiA64, uiA0, 0, 0 STATE_VAR);
                 goto uiZ;
             }
             return a;
@@ -109,7 +110,7 @@ float128_t
         *--------------------------------------------------------------------*/
         if ( exp < 0x3FFF ) {
             if ( !((uiA64 & UINT64_C( 0x7FFFFFFFFFFFFFFF )) | uiA0) ) return a;
-            if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+            if ( exact ) softfloat_raiseFlags(softfloat_flag_inexact STATE_VAR);
             uiZ.v64 = uiA64 & packToF128UI64( 1, 0, 0 );
             uiZ.v0  = 0;
             switch ( roundingMode ) {
@@ -162,7 +163,7 @@ float128_t
             uiZ.v0  |= lastBitMask0;
         }
 #endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/f128_sqrt.c b/source/f128_sqrt.c
index a32fe33f..ec54806b 100644
--- a/source/f128_sqrt.c
+++ b/source/f128_sqrt.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float128_t f128_sqrt( float128_t a )
+float128_t f128_sqrt( float128_t a STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -73,7 +73,7 @@ float128_t f128_sqrt( float128_t a )
     *------------------------------------------------------------------------*/
     if ( expA == 0x7FFF ) {
         if ( sigA.v64 | sigA.v0 ) {
-            uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 );
+            uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 STATE_VAR );
             goto uiZ;
         }
         if ( ! signA ) return a;
@@ -186,11 +186,12 @@ float128_t f128_sqrt( float128_t a )
             }
         }
     }
-    return softfloat_roundPackToF128( 0, expZ, sigZ.v64, sigZ.v0, sigZExtra );
+    return softfloat_roundPackToF128( 0, expZ, sigZ.v64, sigZ.v0, sigZExtra
+                                      STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ.v64 = defaultNaNF128UI64;
     uiZ.v0  = defaultNaNF128UI0;
  uiZ:
diff --git a/source/f128_sub.c b/source/f128_sub.c
index ef76ac4e..d98af0d8 100644
--- a/source/f128_sub.c
+++ b/source/f128_sub.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float128_t f128_sub( float128_t a, float128_t b )
+float128_t f128_sub( float128_t a, float128_t b STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -51,7 +51,8 @@ float128_t f128_sub( float128_t a, float128_t b )
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
     float128_t
         (*magsFuncPtr)(
-            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool
+            STATE_PARAM );
 #endif
 
     uA.f = a;
@@ -64,14 +65,16 @@ float128_t f128_sub( float128_t a, float128_t b )
     signB = signF128UI64( uiB64 );
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA
+                                      STATE_VAR );
     } else {
-        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA
+                                      STATE_VAR );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128;
-    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA STATE_VAR );
 #endif
 
 }
diff --git a/source/f128_to_extF80.c b/source/f128_to_extF80.c
index cb0a6ce6..3dce8e23 100644
--- a/source/f128_to_extF80.c
+++ b/source/f128_to_extF80.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-extFloat80_t f128_to_extF80( float128_t a )
+extFloat80_t f128_to_extF80( float128_t a STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -69,7 +69,7 @@ extFloat80_t f128_to_extF80( float128_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( frac64 | frac0 ) {
-            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
             uiZ64 = uiZ.v64;
             uiZ0  = uiZ.v0;
@@ -97,7 +97,8 @@ extFloat80_t f128_to_extF80( float128_t a )
     sig128 =
         softfloat_shortShiftLeft128(
             frac64 | UINT64_C( 0x0001000000000000 ), frac0, 15 );
-    return softfloat_roundPackToExtF80( sign, exp, sig128.v64, sig128.v0, 80 );
+    return softfloat_roundPackToExtF80(
+        sign, exp, sig128.v64, sig128.v0, 80 STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/f128_to_f16.c b/source/f128_to_f16.c
index 62ed35b7..e562d845 100644
--- a/source/f128_to_f16.c
+++ b/source/f128_to_f16.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t f128_to_f16( float128_t a )
+float16_t f128_to_f16( float128_t a STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -64,7 +64,7 @@ float16_t f128_to_f16( float128_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( frac64 ) {
-            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF16UI( &commonNaN );
         } else {
             uiZ = packToF16UI( sign, 0x1F, 0 );
@@ -84,7 +84,7 @@ float16_t f128_to_f16( float128_t a )
     if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
         if ( exp < -0x40 ) exp = -0x40;
     }
-    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 );
+    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/f128_to_f32.c b/source/f128_to_f32.c
index c10105f7..84a77aaa 100644
--- a/source/f128_to_f32.c
+++ b/source/f128_to_f32.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f128_to_f32( float128_t a )
+float32_t f128_to_f32( float128_t a STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -64,7 +64,7 @@ float32_t f128_to_f32( float128_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( frac64 ) {
-            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF32UI( &commonNaN );
         } else {
             uiZ = packToF32UI( sign, 0xFF, 0 );
@@ -84,7 +84,7 @@ float32_t f128_to_f32( float128_t a )
     if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
         if ( exp < -0x1000 ) exp = -0x1000;
     }
-    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 );
+    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/f128_to_f64.c b/source/f128_to_f64.c
index 76da76cd..5c5ab9f8 100644
--- a/source/f128_to_f64.c
+++ b/source/f128_to_f64.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f128_to_f64( float128_t a )
+float64_t f128_to_f64( float128_t a STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -66,7 +66,7 @@ float64_t f128_to_f64( float128_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FFF ) {
         if ( frac64 | frac0 ) {
-            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF64UI( &commonNaN );
         } else {
             uiZ = packToF64UI( sign, 0x7FF, 0 );
@@ -89,7 +89,7 @@ float64_t f128_to_f64( float128_t a )
     }
     return
         softfloat_roundPackToF64(
-            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) );
+            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  uiZ:
diff --git a/source/f128_to_i32.c b/source/f128_to_i32.c
index cfff04ae..6a357eaa 100644
--- a/source/f128_to_i32.c
+++ b/source/f128_to_i32.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast32_t f128_to_i32( float128_t a, uint_fast8_t roundingMode, bool exact )
+int_fast32_t f128_to_i32( float128_t a, uint_fast8_t roundingMode, bool exact
+                          STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -68,7 +69,7 @@ int_fast32_t f128_to_i32( float128_t a, uint_fast8_t roundingMode, bool exact )
 #elif (i32_fromNaN == i32_fromNegOverflow)
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return i32_fromNaN;
 #endif
     }
@@ -79,7 +80,7 @@ int_fast32_t f128_to_i32( float128_t a, uint_fast8_t roundingMode, bool exact )
     sig64 |= (sig0 != 0);
     shiftDist = 0x4023 - exp;
     if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToI32( sign, sig64, roundingMode, exact );
+    return softfloat_roundToI32( sign, sig64, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/f128_to_i32_r_minMag.c b/source/f128_to_i32_r_minMag.c
index 161b6756..e6f8b4b5 100644
--- a/source/f128_to_i32_r_minMag.c
+++ b/source/f128_to_i32_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast32_t f128_to_i32_r_minMag( float128_t a, bool exact )
+int_fast32_t f128_to_i32_r_minMag( float128_t a, bool exact STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -63,7 +63,7 @@ int_fast32_t f128_to_i32_r_minMag( float128_t a, bool exact )
     shiftDist = 0x402F - exp;
     if ( 49 <= shiftDist ) {
         if ( exact && (exp | sig64) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -76,11 +76,11 @@ int_fast32_t f128_to_i32_r_minMag( float128_t a, bool exact )
                 && (sig64 < UINT64_C( 0x0000000000020000 ))
         ) {
             if ( exact && sig64 ) {
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
+                softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
             }
             return -0x7FFFFFFF - 1;
         }
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FFF) && sig64 ? i32_fromNaN
                 : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
@@ -92,7 +92,7 @@ int_fast32_t f128_to_i32_r_minMag( float128_t a, bool exact )
     if (
         exact && ((uint_fast64_t) (uint_fast32_t) absZ<<shiftDist != sig64)
     ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return sign ? -absZ : absZ;
 
diff --git a/source/f128_to_i64.c b/source/f128_to_i64.c
index 2ff47402..bdda61c1 100644
--- a/source/f128_to_i64.c
+++ b/source/f128_to_i64.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast64_t f128_to_i64( float128_t a, uint_fast8_t roundingMode, bool exact )
+int_fast64_t f128_to_i64( float128_t a, uint_fast8_t roundingMode, bool exact
+                          STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -68,7 +69,7 @@ int_fast64_t f128_to_i64( float128_t a, uint_fast8_t roundingMode, bool exact )
         /*--------------------------------------------------------------------
         *--------------------------------------------------------------------*/
         if ( shiftDist < -15 ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
             return
                 (exp == 0x7FFF) && (sig64 | sig0) ? i64_fromNaN
                     : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
@@ -89,7 +90,8 @@ int_fast64_t f128_to_i64( float128_t a, uint_fast8_t roundingMode, bool exact )
         sig64 = sigExtra.v;
         sig0  = sigExtra.extra;
     }
-    return softfloat_roundToI64( sign, sig64, sig0, roundingMode, exact );
+    return softfloat_roundToI64( sign, sig64, sig0, roundingMode, exact
+                                 STATE_VAR );
 
 }
 
diff --git a/source/f128_to_i64_r_minMag.c b/source/f128_to_i64_r_minMag.c
index dc44e7ae..d0edc120 100644
--- a/source/f128_to_i64_r_minMag.c
+++ b/source/f128_to_i64_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast64_t f128_to_i64_r_minMag( float128_t a, bool exact )
+int_fast64_t f128_to_i64_r_minMag( float128_t a, bool exact STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -73,11 +73,11 @@ int_fast64_t f128_to_i64_r_minMag( float128_t a, bool exact )
                 && (sig0 < UINT64_C( 0x0002000000000000 ))
             ) {
                 if ( exact && sig0 ) {
-                    softfloat_exceptionFlags |= softfloat_flag_inexact;
+                    softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
                 }
                 return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
             }
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
             return
                 (exp == 0x7FFF) && (sig64 | sig0) ? i64_fromNaN
                     : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
@@ -88,14 +88,14 @@ int_fast64_t f128_to_i64_r_minMag( float128_t a, bool exact )
         negShiftDist = -shiftDist;
         absZ = sig64<<negShiftDist | sig0>>(shiftDist & 63);
         if ( exact && (uint64_t) (sig0<<negShiftDist) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
     } else {
         /*--------------------------------------------------------------------
         *--------------------------------------------------------------------*/
         if ( 49 <= shiftDist ) {
             if ( exact && (exp | sig64 | sig0) ) {
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
+                softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
             }
             return 0;
         }
@@ -104,7 +104,7 @@ int_fast64_t f128_to_i64_r_minMag( float128_t a, bool exact )
         sig64 |= UINT64_C( 0x0001000000000000 );
         absZ = sig64>>shiftDist;
         if ( exact && (sig0 || (absZ<<shiftDist != sig64)) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
     }
     return sign ? -absZ : absZ;
diff --git a/source/f128_to_ui32.c b/source/f128_to_ui32.c
index 54b07d69..31139975 100644
--- a/source/f128_to_ui32.c
+++ b/source/f128_to_ui32.c
@@ -42,7 +42,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 
 uint_fast32_t
- f128_to_ui32( float128_t a, uint_fast8_t roundingMode, bool exact )
+ f128_to_ui32( float128_t a, uint_fast8_t roundingMode, bool exact STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -68,7 +68,7 @@ uint_fast32_t
 #elif (ui32_fromNaN == ui32_fromNegOverflow)
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return ui32_fromNaN;
 #endif
     }
@@ -80,7 +80,7 @@ uint_fast32_t
     if ( 0 < shiftDist ) {
         sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
     }
-    return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig64, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/f128_to_ui32_r_minMag.c b/source/f128_to_ui32_r_minMag.c
index 650c18fd..58aefa83 100644
--- a/source/f128_to_ui32_r_minMag.c
+++ b/source/f128_to_ui32_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast32_t f128_to_ui32_r_minMag( float128_t a, bool exact )
+uint_fast32_t f128_to_ui32_r_minMag( float128_t a, bool exact STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -63,7 +63,7 @@ uint_fast32_t f128_to_ui32_r_minMag( float128_t a, bool exact )
     shiftDist = 0x402F - exp;
     if ( 49 <= shiftDist ) {
         if ( exact && (exp | sig64) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -71,7 +71,7 @@ uint_fast32_t f128_to_ui32_r_minMag( float128_t a, bool exact )
     *------------------------------------------------------------------------*/
     sign = signF128UI64( uiA64 );
     if ( sign || (shiftDist < 17) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FFF) && sig64 ? ui32_fromNaN
                 : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
@@ -81,7 +81,7 @@ uint_fast32_t f128_to_ui32_r_minMag( float128_t a, bool exact )
     sig64 |= UINT64_C( 0x0001000000000000 );
     z = sig64>>shiftDist;
     if ( exact && ((uint_fast64_t) z<<shiftDist != sig64) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return z;
 
diff --git a/source/f128_to_ui64.c b/source/f128_to_ui64.c
index 75769928..2420a00e 100644
--- a/source/f128_to_ui64.c
+++ b/source/f128_to_ui64.c
@@ -42,7 +42,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 
 uint_fast64_t
- f128_to_ui64( float128_t a, uint_fast8_t roundingMode, bool exact )
+ f128_to_ui64( float128_t a, uint_fast8_t roundingMode, bool exact STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -69,7 +69,7 @@ uint_fast64_t
         /*--------------------------------------------------------------------
         *--------------------------------------------------------------------*/
         if ( shiftDist < -15 ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
             return
                 (exp == 0x7FFF) && (sig64 | sig0) ? ui64_fromNaN
                     : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
@@ -90,7 +90,8 @@ uint_fast64_t
         sig64 = sigExtra.v;
         sig0  = sigExtra.extra;
     }
-    return softfloat_roundToUI64( sign, sig64, sig0, roundingMode, exact );
+    return softfloat_roundToUI64( sign, sig64, sig0, roundingMode, exact
+                                  STATE_VAR );
 
 }
 
diff --git a/source/f128_to_ui64_r_minMag.c b/source/f128_to_ui64_r_minMag.c
index 3f2fb6bc..4fb42b58 100644
--- a/source/f128_to_ui64_r_minMag.c
+++ b/source/f128_to_ui64_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast64_t f128_to_ui64_r_minMag( float128_t a, bool exact )
+uint_fast64_t f128_to_ui64_r_minMag( float128_t a, bool exact STATE_PARAM )
 {
     union ui128_f128 uA;
     uint_fast64_t uiA64, uiA0;
@@ -72,14 +72,14 @@ uint_fast64_t f128_to_ui64_r_minMag( float128_t a, bool exact )
         negShiftDist = -shiftDist;
         z = sig64<<negShiftDist | sig0>>(shiftDist & 63);
         if ( exact && (uint64_t) (sig0<<negShiftDist) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
     } else {
         /*--------------------------------------------------------------------
         *--------------------------------------------------------------------*/
         if ( 49 <= shiftDist ) {
             if ( exact && (exp | sig64 | sig0) ) {
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
+                softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
             }
             return 0;
         }
@@ -89,14 +89,14 @@ uint_fast64_t f128_to_ui64_r_minMag( float128_t a, bool exact )
         sig64 |= UINT64_C( 0x0001000000000000 );
         z = sig64>>shiftDist;
         if ( exact && (sig0 || (z<<shiftDist != sig64)) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
     }
     return z;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FFF) && (sig64 | sig0) ? ui64_fromNaN
             : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
diff --git a/source/f16_add.c b/source/f16_add.c
index 16e80636..d3bf549d 100644
--- a/source/f16_add.c
+++ b/source/f16_add.c
@@ -40,14 +40,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float16_t f16_add( float16_t a, float16_t b )
+float16_t f16_add( float16_t a, float16_t b STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
     union ui16_f16 uB;
     uint_fast16_t uiB;
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
-    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t );
+    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t STATE_PARAM );
 #endif
 
     uA.f = a;
@@ -56,14 +56,14 @@ float16_t f16_add( float16_t a, float16_t b )
     uiB = uB.ui;
 #if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
     if ( signF16UI( uiA ^ uiB ) ) {
-        return softfloat_subMagsF16( uiA, uiB );
+        return softfloat_subMagsF16( uiA, uiB STATE_VAR );
     } else {
-        return softfloat_addMagsF16( uiA, uiB );
+        return softfloat_addMagsF16( uiA, uiB STATE_VAR );
     }
 #else
     magsFuncPtr =
         signF16UI( uiA ^ uiB ) ? softfloat_subMagsF16 : softfloat_addMagsF16;
-    return (*magsFuncPtr)( uiA, uiB );
+    return (*magsFuncPtr)( uiA, uiB STATE_VAR );
 #endif
 
 }
diff --git a/source/f16_div.c b/source/f16_div.c
index ad91a907..5e210250 100644
--- a/source/f16_div.c
+++ b/source/f16_div.c
@@ -44,7 +44,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 extern const uint16_t softfloat_approxRecip_1k0s[];
 extern const uint16_t softfloat_approxRecip_1k1s[];
 
-float16_t f16_div( float16_t a, float16_t b )
+float16_t f16_div( float16_t a, float16_t b STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -102,7 +102,7 @@ float16_t f16_div( float16_t a, float16_t b )
     if ( ! expB ) {
         if ( ! sigB ) {
             if ( ! (expA | sigA) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
+            softfloat_raiseFlags( softfloat_flag_infinite STATE_VAR );
             goto infinity;
         }
         normExpSig = softfloat_normSubnormalF16Sig( sigB );
@@ -157,16 +157,16 @@ float16_t f16_div( float16_t a, float16_t b )
         }
     }
 #endif
-    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    return softfloat_roundPackToF16( signZ, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR);
     uiZ = defaultNaNF16UI;
     goto uiZ;
     /*------------------------------------------------------------------------
diff --git a/source/f16_eq.c b/source/f16_eq.c
index 4079f50f..f973d302 100644
--- a/source/f16_eq.c
+++ b/source/f16_eq.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f16_eq( float16_t a, float16_t b )
+bool f16_eq( float16_t a, float16_t b STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -56,7 +56,7 @@ bool f16_eq( float16_t a, float16_t b )
         if (
             softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f16_eq_signaling.c b/source/f16_eq_signaling.c
index 117d05d6..2f08df89 100644
--- a/source/f16_eq_signaling.c
+++ b/source/f16_eq_signaling.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool f16_eq_signaling( float16_t a, float16_t b )
+bool f16_eq_signaling( float16_t a, float16_t b STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -52,7 +52,7 @@ bool f16_eq_signaling( float16_t a, float16_t b )
     uB.f = b;
     uiB = uB.ui;
     if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     return (uiA == uiB) || ! (uint16_t) ((uiA | uiB)<<1);
diff --git a/source/f16_le.c b/source/f16_le.c
index fa694322..bd4cfab0 100644
--- a/source/f16_le.c
+++ b/source/f16_le.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool f16_le( float16_t a, float16_t b )
+bool f16_le( float16_t a, float16_t b STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -53,7 +53,7 @@ bool f16_le( float16_t a, float16_t b )
     uB.f = b;
     uiB = uB.ui;
     if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     signA = signF16UI( uiA );
diff --git a/source/f16_le_quiet.c b/source/f16_le_quiet.c
index 769a1dc9..13ff550a 100644
--- a/source/f16_le_quiet.c
+++ b/source/f16_le_quiet.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f16_le_quiet( float16_t a, float16_t b )
+bool f16_le_quiet( float16_t a, float16_t b STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -57,7 +57,7 @@ bool f16_le_quiet( float16_t a, float16_t b )
         if (
             softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f16_lt.c b/source/f16_lt.c
index e796016b..3238a6cf 100644
--- a/source/f16_lt.c
+++ b/source/f16_lt.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool f16_lt( float16_t a, float16_t b )
+bool f16_lt( float16_t a, float16_t b STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -53,7 +53,7 @@ bool f16_lt( float16_t a, float16_t b )
     uB.f = b;
     uiB = uB.ui;
     if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     signA = signF16UI( uiA );
diff --git a/source/f16_lt_quiet.c b/source/f16_lt_quiet.c
index c55bade7..02d4d70d 100644
--- a/source/f16_lt_quiet.c
+++ b/source/f16_lt_quiet.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f16_lt_quiet( float16_t a, float16_t b )
+bool f16_lt_quiet( float16_t a, float16_t b STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -57,7 +57,7 @@ bool f16_lt_quiet( float16_t a, float16_t b )
         if (
             softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f16_mul.c b/source/f16_mul.c
index 112111d8..66eae25c 100644
--- a/source/f16_mul.c
+++ b/source/f16_mul.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t f16_mul( float16_t a, float16_t b )
+float16_t f16_mul( float16_t a, float16_t b STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -112,17 +112,17 @@ float16_t f16_mul( float16_t a, float16_t b )
         --expZ;
         sigZ <<= 1;
     }
-    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    return softfloat_roundPackToF16( signZ, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  infArg:
     if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         uiZ = defaultNaNF16UI;
     } else {
         uiZ = packToF16UI( signZ, 0x1F, 0 );
diff --git a/source/f16_mulAdd.c b/source/f16_mulAdd.c
index 09293729..562a3308 100644
--- a/source/f16_mulAdd.c
+++ b/source/f16_mulAdd.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float16_t f16_mulAdd( float16_t a, float16_t b, float16_t c )
+float16_t f16_mulAdd( float16_t a, float16_t b, float16_t c STATE_PARAM)
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -54,7 +54,7 @@ float16_t f16_mulAdd( float16_t a, float16_t b, float16_t c )
     uiB = uB.ui;
     uC.f = c;
     uiC = uC.ui;
-    return softfloat_mulAddF16( uiA, uiB, uiC, 0 );
+    return softfloat_mulAddF16( uiA, uiB, uiC, 0 STATE_VAR );
 
 }
 
diff --git a/source/f16_rem.c b/source/f16_rem.c
index 76a0de68..4f3d5d87 100644
--- a/source/f16_rem.c
+++ b/source/f16_rem.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t f16_rem( float16_t a, float16_t b )
+float16_t f16_rem( float16_t a, float16_t b STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -154,14 +154,14 @@ float16_t f16_rem( float16_t a, float16_t b )
         signRem = ! signRem;
         rem = -rem;
     }
-    return softfloat_normRoundPackToF16( signRem, expB, rem );
+    return softfloat_normRoundPackToF16( signRem, expB, rem STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB STATE_VAR );
     goto uiZ;
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ = defaultNaNF16UI;
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/f16_roundToInt.c b/source/f16_roundToInt.c
index d5ed190d..ea1d10f7 100644
--- a/source/f16_roundToInt.c
+++ b/source/f16_roundToInt.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact )
+float16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact
+                          STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -58,7 +59,7 @@ float16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact )
     *------------------------------------------------------------------------*/
     if ( exp <= 0xE ) {
         if ( !(uint16_t) (uiA<<1) ) return a;
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         uiZ = uiA & packToF16UI( 1, 0, 0 );
         switch ( roundingMode ) {
          case softfloat_round_near_even:
@@ -84,7 +85,7 @@ float16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact )
     *------------------------------------------------------------------------*/
     if ( 0x19 <= exp ) {
         if ( (exp == 0x1F) && fracF16UI( uiA ) ) {
-            uiZ = softfloat_propagateNaNF16UI( uiA, 0 );
+            uiZ = softfloat_propagateNaNF16UI( uiA, 0 STATE_VAR );
             goto uiZ;
         }
         return a;
@@ -110,7 +111,7 @@ float16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact )
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask;
 #endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/f16_sqrt.c b/source/f16_sqrt.c
index 40865fcc..ca39423d 100644
--- a/source/f16_sqrt.c
+++ b/source/f16_sqrt.c
@@ -44,7 +44,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 extern const uint16_t softfloat_approxRecipSqrt_1k0s[];
 extern const uint16_t softfloat_approxRecipSqrt_1k1s[];
 
-float16_t f16_sqrt( float16_t a )
+float16_t f16_sqrt( float16_t a STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -72,7 +72,7 @@ float16_t f16_sqrt( float16_t a )
     *------------------------------------------------------------------------*/
     if ( expA == 0x1F ) {
         if ( sigA ) {
-            uiZ = softfloat_propagateNaNF16UI( uiA, 0 );
+            uiZ = softfloat_propagateNaNF16UI( uiA, 0 STATE_VAR );
             goto uiZ;
         }
         if ( ! signA ) return a;
@@ -122,11 +122,11 @@ float16_t f16_sqrt( float16_t a )
             if ( negRem ) --sigZ;
         }
     }
-    return softfloat_roundPackToF16( 0, expZ, sigZ );
+    return softfloat_roundPackToF16( 0, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ = defaultNaNF16UI;
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/f16_sub.c b/source/f16_sub.c
index e18f25cf..d1b06ed6 100644
--- a/source/f16_sub.c
+++ b/source/f16_sub.c
@@ -40,14 +40,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float16_t f16_sub( float16_t a, float16_t b )
+float16_t f16_sub( float16_t a, float16_t b STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
     union ui16_f16 uB;
     uint_fast16_t uiB;
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
-    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t );
+    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t STATE_PARAM );
 #endif
 
     uA.f = a;
@@ -56,14 +56,14 @@ float16_t f16_sub( float16_t a, float16_t b )
     uiB = uB.ui;
 #if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
     if ( signF16UI( uiA ^ uiB ) ) {
-        return softfloat_addMagsF16( uiA, uiB );
+        return softfloat_addMagsF16( uiA, uiB STATE_VAR );
     } else {
-        return softfloat_subMagsF16( uiA, uiB );
+        return softfloat_subMagsF16( uiA, uiB STATE_VAR );
     }
 #else
     magsFuncPtr =
         signF16UI( uiA ^ uiB ) ? softfloat_addMagsF16 : softfloat_subMagsF16;
-    return (*magsFuncPtr)( uiA, uiB );
+    return (*magsFuncPtr)( uiA, uiB STATE_VAR );
 #endif
 
 }
diff --git a/source/f16_to_extF80.c b/source/f16_to_extF80.c
index aaeed4d0..c74e3e24 100644
--- a/source/f16_to_extF80.c
+++ b/source/f16_to_extF80.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-extFloat80_t f16_to_extF80( float16_t a )
+extFloat80_t f16_to_extF80( float16_t a STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -66,7 +66,7 @@ extFloat80_t f16_to_extF80( float16_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
         if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
             uiZ64 = uiZ.v64;
             uiZ0  = uiZ.v0;
diff --git a/source/f16_to_extF80M.c b/source/f16_to_extF80M.c
index 75c5e604..6c41c80c 100644
--- a/source/f16_to_extF80M.c
+++ b/source/f16_to_extF80M.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f16_to_extF80M( float16_t a, extFloat80_t *zPtr )
+void f16_to_extF80M( float16_t a, extFloat80_t *zPtr STATE_PARAM )
 {
 
-    *zPtr = f16_to_extF80( a );
+    *zPtr = f16_to_extF80( a STATE_VAR );
 
 }
 
 #else
 
-void f16_to_extF80M( float16_t a, extFloat80_t *zPtr )
+void f16_to_extF80M( float16_t a, extFloat80_t *zPtr STATE_PARAM )
 {
     struct extFloat80M *zSPtr;
     union ui16_f16 uA;
@@ -77,7 +77,7 @@ void f16_to_extF80M( float16_t a, extFloat80_t *zPtr )
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
         if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
             return;
         }
diff --git a/source/f16_to_f128.c b/source/f16_to_f128.c
index 107479af..477604c9 100644
--- a/source/f16_to_f128.c
+++ b/source/f16_to_f128.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float128_t f16_to_f128( float16_t a )
+float128_t f16_to_f128( float16_t a STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -64,7 +64,7 @@ float128_t f16_to_f128( float16_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
         if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF128UI( &commonNaN );
         } else {
             uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 );
diff --git a/source/f16_to_f128M.c b/source/f16_to_f128M.c
index a31dab6c..4cf800b5 100644
--- a/source/f16_to_f128M.c
+++ b/source/f16_to_f128M.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f16_to_f128M( float16_t a, float128_t *zPtr )
+void f16_to_f128M( float16_t a, float128_t *zPtr STATE_PARAM )
 {
 
-    *zPtr = f16_to_f128( a );
+    *zPtr = f16_to_f128( a STATE_VAR );
 
 }
 
 #else
 
-void f16_to_f128M( float16_t a, float128_t *zPtr )
+void f16_to_f128M( float16_t a, float128_t *zPtr STATE_PARAM )
 {
     uint32_t *zWPtr;
     union ui16_f16 uA;
@@ -78,7 +78,7 @@ void f16_to_f128M( float16_t a, float128_t *zPtr )
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
         if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             softfloat_commonNaNToF128M( &commonNaN, zWPtr );
             return;
         }
diff --git a/source/f16_to_f32.c b/source/f16_to_f32.c
index c58208a8..6d90d2ad 100644
--- a/source/f16_to_f32.c
+++ b/source/f16_to_f32.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f16_to_f32( float16_t a )
+float32_t f16_to_f32( float16_t a STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -64,7 +64,7 @@ float32_t f16_to_f32( float16_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
         if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF32UI( &commonNaN );
         } else {
             uiZ = packToF32UI( sign, 0xFF, 0 );
diff --git a/source/f16_to_f64.c b/source/f16_to_f64.c
index dd85d33f..b978fffd 100644
--- a/source/f16_to_f64.c
+++ b/source/f16_to_f64.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f16_to_f64( float16_t a )
+float64_t f16_to_f64( float16_t a STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -64,7 +64,7 @@ float64_t f16_to_f64( float16_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
         if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF64UI( &commonNaN );
         } else {
             uiZ = packToF64UI( sign, 0x7FF, 0 );
diff --git a/source/f16_to_i32.c b/source/f16_to_i32.c
index aeb2faca..9efd607b 100644
--- a/source/f16_to_i32.c
+++ b/source/f16_to_i32.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast32_t f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact )
+int_fast32_t f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact
+                         STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -61,7 +62,7 @@ int_fast32_t f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact )
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             frac ? i32_fromNaN
                 : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
@@ -81,7 +82,7 @@ int_fast32_t f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact )
     }
     return
         softfloat_roundToI32(
-            sign, (uint_fast32_t) sig32, roundingMode, exact );
+            sign, (uint_fast32_t) sig32, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/f16_to_i32_r_minMag.c b/source/f16_to_i32_r_minMag.c
index 1aa72f56..8894d0c3 100644
--- a/source/f16_to_i32_r_minMag.c
+++ b/source/f16_to_i32_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact )
+int_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -62,7 +62,7 @@ int_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact )
     shiftDist = exp - 0x0F;
     if ( shiftDist < 0 ) {
         if ( exact && (exp | frac) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -70,7 +70,7 @@ int_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact )
     *------------------------------------------------------------------------*/
     sign = signF16UI( uiA );
     if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x1F) && frac ? i32_fromNaN
                 : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
@@ -79,7 +79,7 @@ int_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact )
     *------------------------------------------------------------------------*/
     alignedSig = (int_fast32_t) (frac | 0x0400)<<shiftDist;
     if ( exact && (alignedSig & 0x3FF) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     alignedSig >>= 10;
     return sign ? -alignedSig : alignedSig;
diff --git a/source/f16_to_i64.c b/source/f16_to_i64.c
index c0487cf3..6f876c8c 100644
--- a/source/f16_to_i64.c
+++ b/source/f16_to_i64.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast64_t f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact )
+int_fast64_t f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact
+                         STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -61,7 +62,7 @@ int_fast64_t f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact )
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             frac ? i64_fromNaN
                 : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
@@ -81,7 +82,7 @@ int_fast64_t f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact )
     }
     return
         softfloat_roundToI32(
-            sign, (uint_fast32_t) sig32, roundingMode, exact );
+            sign, (uint_fast32_t) sig32, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/f16_to_i64_r_minMag.c b/source/f16_to_i64_r_minMag.c
index 25f91e21..48991785 100644
--- a/source/f16_to_i64_r_minMag.c
+++ b/source/f16_to_i64_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact )
+int_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -62,7 +62,7 @@ int_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact )
     shiftDist = exp - 0x0F;
     if ( shiftDist < 0 ) {
         if ( exact && (exp | frac) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -70,7 +70,7 @@ int_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact )
     *------------------------------------------------------------------------*/
     sign = signF16UI( uiA );
     if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x1F) && frac ? i64_fromNaN
                 : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
@@ -79,7 +79,7 @@ int_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact )
     *------------------------------------------------------------------------*/
     alignedSig = (int_fast32_t) (frac | 0x0400)<<shiftDist;
     if ( exact && (alignedSig & 0x3FF) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     alignedSig >>= 10;
     return sign ? -alignedSig : alignedSig;
diff --git a/source/f16_to_ui32.c b/source/f16_to_ui32.c
index 19ab66e7..168937c4 100644
--- a/source/f16_to_ui32.c
+++ b/source/f16_to_ui32.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast32_t f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact )
+uint_fast32_t f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact
+                           STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -61,7 +62,7 @@ uint_fast32_t f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact )
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             frac ? ui32_fromNaN
                 : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
@@ -78,7 +79,7 @@ uint_fast32_t f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact )
         shiftDist = exp - 0x0D;
         if ( 0 < shiftDist ) sig32 <<= shiftDist;
     }
-    return softfloat_roundToUI32( sign, sig32, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig32, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/f16_to_ui32_r_minMag.c b/source/f16_to_ui32_r_minMag.c
index a21d41a3..b8a153a7 100644
--- a/source/f16_to_ui32_r_minMag.c
+++ b/source/f16_to_ui32_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact )
+uint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -62,7 +62,7 @@ uint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact )
     shiftDist = exp - 0x0F;
     if ( shiftDist < 0 ) {
         if ( exact && (exp | frac) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -70,7 +70,7 @@ uint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact )
     *------------------------------------------------------------------------*/
     sign = signF16UI( uiA );
     if ( sign || (exp == 0x1F) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x1F) && frac ? ui32_fromNaN
                 : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
@@ -79,7 +79,7 @@ uint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact )
     *------------------------------------------------------------------------*/
     alignedSig = (uint_fast32_t) (frac | 0x0400)<<shiftDist;
     if ( exact && (alignedSig & 0x3FF) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return alignedSig>>10;
 
diff --git a/source/f16_to_ui64.c b/source/f16_to_ui64.c
index 4260b7a0..5d9eba10 100644
--- a/source/f16_to_ui64.c
+++ b/source/f16_to_ui64.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast64_t f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact )
+uint_fast64_t f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact
+                           STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -64,7 +65,7 @@ uint_fast64_t f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact )
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             frac ? ui64_fromNaN
                 : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
@@ -84,12 +85,13 @@ uint_fast64_t f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact )
 #ifdef SOFTFLOAT_FAST_INT64
     return
         softfloat_roundToUI64(
-            sign, sig32>>12, (uint_fast64_t) sig32<<52, roundingMode, exact );
+            sign, sig32>>12, (uint_fast64_t) sig32<<52, roundingMode, exact
+            STATE_VAR );
 #else
     extSig[indexWord( 3, 2 )] = 0;
     extSig[indexWord( 3, 1 )] = sig32>>12;
     extSig[indexWord( 3, 0 )] = sig32<<20;
-    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact STATE_VAR);
 #endif
 
 }
diff --git a/source/f16_to_ui64_r_minMag.c b/source/f16_to_ui64_r_minMag.c
index 098a5976..ec78c7dd 100644
--- a/source/f16_to_ui64_r_minMag.c
+++ b/source/f16_to_ui64_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact )
+uint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact STATE_PARAM )
 {
     union ui16_f16 uA;
     uint_fast16_t uiA;
@@ -62,7 +62,7 @@ uint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact )
     shiftDist = exp - 0x0F;
     if ( shiftDist < 0 ) {
         if ( exact && (exp | frac) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -70,7 +70,7 @@ uint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact )
     *------------------------------------------------------------------------*/
     sign = signF16UI( uiA );
     if ( sign || (exp == 0x1F) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x1F) && frac ? ui64_fromNaN
                 : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
@@ -79,7 +79,7 @@ uint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact )
     *------------------------------------------------------------------------*/
     alignedSig = (uint_fast32_t) (frac | 0x0400)<<shiftDist;
     if ( exact && (alignedSig & 0x3FF) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return alignedSig>>10;
 
diff --git a/source/f32_add.c b/source/f32_add.c
index f59ac0a8..96e4586f 100644
--- a/source/f32_add.c
+++ b/source/f32_add.c
@@ -40,14 +40,15 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float32_t f32_add( float32_t a, float32_t b )
+float32_t f32_add(float32_t a, float32_t b STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
     union ui32_f32 uB;
     uint_fast32_t uiB;
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
-    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t );
+    float32_t (*magsFuncPtr)(
+        uint_fast32_t, uint_fast32_t STATE_PARAM );
 #endif
 
     uA.f = a;
@@ -56,15 +57,14 @@ float32_t f32_add( float32_t a, float32_t b )
     uiB = uB.ui;
 #if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
     if ( signF32UI( uiA ^ uiB ) ) {
-        return softfloat_subMagsF32( uiA, uiB );
+        return softfloat_subMagsF32( uiA, uiB STATE_VAR );
     } else {
-        return softfloat_addMagsF32( uiA, uiB );
+        return softfloat_addMagsF32( uiA, uiB STATE_VAR );
     }
 #else
     magsFuncPtr =
         signF32UI( uiA ^ uiB ) ? softfloat_subMagsF32 : softfloat_addMagsF32;
-    return (*magsFuncPtr)( uiA, uiB );
+    return (*magsFuncPtr)( uiA, uiB STATE_VAR );
 #endif
-
 }
 
diff --git a/source/f32_div.c b/source/f32_div.c
index 8d444791..5db0daa3 100644
--- a/source/f32_div.c
+++ b/source/f32_div.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f32_div( float32_t a, float32_t b )
+float32_t f32_div( float32_t a, float32_t b STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -98,7 +98,7 @@ float32_t f32_div( float32_t a, float32_t b )
     if ( ! expB ) {
         if ( ! sigB ) {
             if ( ! (expA | sigA) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
+            softfloat_raiseFlags( softfloat_flag_infinite STATE_VAR );
             goto infinity;
         }
         normExpSig = softfloat_normSubnormalF32Sig( sigB );
@@ -151,16 +151,16 @@ float32_t f32_div( float32_t a, float32_t b )
         }
     }
 #endif
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
+    return softfloat_roundPackToF32( signZ, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ = defaultNaNF32UI;
     goto uiZ;
     /*------------------------------------------------------------------------
diff --git a/source/f32_eq.c b/source/f32_eq.c
index 316fe6a4..92eb52a9 100644
--- a/source/f32_eq.c
+++ b/source/f32_eq.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f32_eq( float32_t a, float32_t b )
+bool f32_eq( float32_t a, float32_t b STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -56,7 +56,7 @@ bool f32_eq( float32_t a, float32_t b )
         if (
             softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f32_eq_signaling.c b/source/f32_eq_signaling.c
index 03395f31..267c2df6 100644
--- a/source/f32_eq_signaling.c
+++ b/source/f32_eq_signaling.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool f32_eq_signaling( float32_t a, float32_t b )
+bool f32_eq_signaling( float32_t a, float32_t b STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -52,7 +52,7 @@ bool f32_eq_signaling( float32_t a, float32_t b )
     uB.f = b;
     uiB = uB.ui;
     if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     return (uiA == uiB) || ! (uint32_t) ((uiA | uiB)<<1);
diff --git a/source/f32_le.c b/source/f32_le.c
index 83a30079..79945a39 100644
--- a/source/f32_le.c
+++ b/source/f32_le.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool f32_le( float32_t a, float32_t b )
+bool f32_le( float32_t a, float32_t b STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -53,7 +53,7 @@ bool f32_le( float32_t a, float32_t b )
     uB.f = b;
     uiB = uB.ui;
     if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     signA = signF32UI( uiA );
diff --git a/source/f32_le_quiet.c b/source/f32_le_quiet.c
index 329fe393..01d058e0 100644
--- a/source/f32_le_quiet.c
+++ b/source/f32_le_quiet.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f32_le_quiet( float32_t a, float32_t b )
+bool f32_le_quiet( float32_t a, float32_t b STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -57,7 +57,7 @@ bool f32_le_quiet( float32_t a, float32_t b )
         if (
             softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f32_lt.c b/source/f32_lt.c
index ddc18049..3a4e7b3c 100644
--- a/source/f32_lt.c
+++ b/source/f32_lt.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool f32_lt( float32_t a, float32_t b )
+bool f32_lt( float32_t a, float32_t b STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -53,7 +53,7 @@ bool f32_lt( float32_t a, float32_t b )
     uB.f = b;
     uiB = uB.ui;
     if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     signA = signF32UI( uiA );
diff --git a/source/f32_lt_quiet.c b/source/f32_lt_quiet.c
index 59c9cf12..730ea757 100644
--- a/source/f32_lt_quiet.c
+++ b/source/f32_lt_quiet.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f32_lt_quiet( float32_t a, float32_t b )
+bool f32_lt_quiet( float32_t a, float32_t b STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -57,7 +57,7 @@ bool f32_lt_quiet( float32_t a, float32_t b )
         if (
             softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f32_mul.c b/source/f32_mul.c
index b1f8ec00..54bbcdf3 100644
--- a/source/f32_mul.c
+++ b/source/f32_mul.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f32_mul( float32_t a, float32_t b )
+float32_t f32_mul( float32_t a, float32_t b STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -109,17 +109,17 @@ float32_t f32_mul( float32_t a, float32_t b )
         --expZ;
         sigZ <<= 1;
     }
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
+    return softfloat_roundPackToF32( signZ, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  infArg:
     if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         uiZ = defaultNaNF32UI;
     } else {
         uiZ = packToF32UI( signZ, 0xFF, 0 );
diff --git a/source/f32_mulAdd.c b/source/f32_mulAdd.c
index b77777e4..06d88eb3 100644
--- a/source/f32_mulAdd.c
+++ b/source/f32_mulAdd.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c )
+float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -54,7 +54,7 @@ float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c )
     uiB = uB.ui;
     uC.f = c;
     uiC = uC.ui;
-    return softfloat_mulAddF32( uiA, uiB, uiC, 0 );
+    return softfloat_mulAddF32( uiA, uiB, uiC, 0 STATE_VAR );
 
 }
 
diff --git a/source/f32_rem.c b/source/f32_rem.c
index 2d74c8cd..92021b77 100644
--- a/source/f32_rem.c
+++ b/source/f32_rem.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f32_rem( float32_t a, float32_t b )
+float32_t f32_rem( float32_t a, float32_t b STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -151,14 +151,14 @@ float32_t f32_rem( float32_t a, float32_t b )
         signRem = ! signRem;
         rem = -rem;
     }
-    return softfloat_normRoundPackToF32( signRem, expB, rem );
+    return softfloat_normRoundPackToF32( signRem, expB, rem STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB STATE_VAR );
     goto uiZ;
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ = defaultNaNF32UI;
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/f32_roundToInt.c b/source/f32_roundToInt.c
index 801a7691..7c9c4e19 100644
--- a/source/f32_roundToInt.c
+++ b/source/f32_roundToInt.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f32_roundToInt( float32_t a, uint_fast8_t roundingMode, bool exact )
+float32_t f32_roundToInt(
+    float32_t a, uint_fast8_t roundingMode, bool exact STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -58,7 +59,7 @@ float32_t f32_roundToInt( float32_t a, uint_fast8_t roundingMode, bool exact )
     *------------------------------------------------------------------------*/
     if ( exp <= 0x7E ) {
         if ( !(uint32_t) (uiA<<1) ) return a;
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         uiZ = uiA & packToF32UI( 1, 0, 0 );
         switch ( roundingMode ) {
          case softfloat_round_near_even:
@@ -84,7 +85,7 @@ float32_t f32_roundToInt( float32_t a, uint_fast8_t roundingMode, bool exact )
     *------------------------------------------------------------------------*/
     if ( 0x96 <= exp ) {
         if ( (exp == 0xFF) && fracF32UI( uiA ) ) {
-            uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
+            uiZ = softfloat_propagateNaNF32UI( uiA, 0 STATE_VAR );
             goto uiZ;
         }
         return a;
@@ -110,7 +111,7 @@ float32_t f32_roundToInt( float32_t a, uint_fast8_t roundingMode, bool exact )
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask;
 #endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/f32_sqrt.c b/source/f32_sqrt.c
index 9c6a9984..b9beffc2 100644
--- a/source/f32_sqrt.c
+++ b/source/f32_sqrt.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f32_sqrt( float32_t a )
+float32_t f32_sqrt( float32_t a STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -65,7 +65,7 @@ float32_t f32_sqrt( float32_t a )
     *------------------------------------------------------------------------*/
     if ( expA == 0xFF ) {
         if ( sigA ) {
-            uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
+            uiZ = softfloat_propagateNaNF32UI( uiA, 0 STATE_VAR );
             goto uiZ;
         }
         if ( ! signA ) return a;
@@ -107,11 +107,11 @@ float32_t f32_sqrt( float32_t a )
             if ( negRem ) --sigZ;
         }
     }
-    return softfloat_roundPackToF32( 0, expZ, sigZ );
+    return softfloat_roundPackToF32( 0, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ = defaultNaNF32UI;
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/f32_sub.c b/source/f32_sub.c
index edbcd2fb..cc10f6ab 100644
--- a/source/f32_sub.c
+++ b/source/f32_sub.c
@@ -40,14 +40,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float32_t f32_sub( float32_t a, float32_t b )
+float32_t f32_sub( float32_t a, float32_t b STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
     union ui32_f32 uB;
     uint_fast32_t uiB;
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
-    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t );
+    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t STATE_PARAM );
 #endif
 
     uA.f = a;
@@ -56,14 +56,14 @@ float32_t f32_sub( float32_t a, float32_t b )
     uiB = uB.ui;
 #if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
     if ( signF32UI( uiA ^ uiB ) ) {
-        return softfloat_addMagsF32( uiA, uiB );
+        return softfloat_addMagsF32( uiA, uiB STATE_VAR );
     } else {
-        return softfloat_subMagsF32( uiA, uiB );
+        return softfloat_subMagsF32( uiA, uiB STATE_VAR );
     }
 #else
     magsFuncPtr =
         signF32UI( uiA ^ uiB ) ? softfloat_addMagsF32 : softfloat_subMagsF32;
-    return (*magsFuncPtr)( uiA, uiB );
+    return (*magsFuncPtr)( uiA, uiB STATE_VAR );
 #endif
 
 }
diff --git a/source/f32_to_extF80.c b/source/f32_to_extF80.c
index 8d354570..a7d6de8f 100644
--- a/source/f32_to_extF80.c
+++ b/source/f32_to_extF80.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-extFloat80_t f32_to_extF80( float32_t a )
+extFloat80_t f32_to_extF80( float32_t a STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -66,7 +66,7 @@ extFloat80_t f32_to_extF80( float32_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0xFF ) {
         if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
             uiZ64 = uiZ.v64;
             uiZ0  = uiZ.v0;
diff --git a/source/f32_to_extF80M.c b/source/f32_to_extF80M.c
index 03580fd5..e7d5850a 100644
--- a/source/f32_to_extF80M.c
+++ b/source/f32_to_extF80M.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f32_to_extF80M( float32_t a, extFloat80_t *zPtr )
+void f32_to_extF80M( float32_t a, extFloat80_t *zPtr STATE_PARAM )
 {
 
-    *zPtr = f32_to_extF80( a );
+    *zPtr = f32_to_extF80( a STATE_VAR );
 
 }
 
 #else
 
-void f32_to_extF80M( float32_t a, extFloat80_t *zPtr )
+void f32_to_extF80M( float32_t a, extFloat80_t *zPtr STATE_PARAM )
 {
     struct extFloat80M *zSPtr;
     union ui32_f32 uA;
@@ -77,7 +77,7 @@ void f32_to_extF80M( float32_t a, extFloat80_t *zPtr )
     *------------------------------------------------------------------------*/
     if ( exp == 0xFF ) {
         if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
             return;
         }
diff --git a/source/f32_to_f128.c b/source/f32_to_f128.c
index ee0b414c..d9195c07 100644
--- a/source/f32_to_f128.c
+++ b/source/f32_to_f128.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float128_t f32_to_f128( float32_t a )
+float128_t f32_to_f128( float32_t a STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -64,7 +64,7 @@ float128_t f32_to_f128( float32_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0xFF ) {
         if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF128UI( &commonNaN );
         } else {
             uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 );
diff --git a/source/f32_to_f128M.c b/source/f32_to_f128M.c
index cd3ad693..5a462eaf 100644
--- a/source/f32_to_f128M.c
+++ b/source/f32_to_f128M.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f32_to_f128M( float32_t a, float128_t *zPtr )
+void f32_to_f128M( float32_t a, float128_t *zPtr STATE_PARAM )
 {
 
-    *zPtr = f32_to_f128( a );
+    *zPtr = f32_to_f128( a STATE_VAR );
 
 }
 
 #else
 
-void f32_to_f128M( float32_t a, float128_t *zPtr )
+void f32_to_f128M( float32_t a, float128_t *zPtr STATE_PARAM )
 {
     uint32_t *zWPtr;
     union ui32_f32 uA;
@@ -80,7 +80,7 @@ void f32_to_f128M( float32_t a, float128_t *zPtr )
     uiZ64 = 0;
     if ( exp == 0xFF ) {
         if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             softfloat_commonNaNToF128M( &commonNaN, zWPtr );
             return;
         }
diff --git a/source/f32_to_f16.c b/source/f32_to_f16.c
index a00b2e8d..73db27c0 100644
--- a/source/f32_to_f16.c
+++ b/source/f32_to_f16.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t f32_to_f16( float32_t a )
+float16_t f32_to_f16( float32_t a STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -63,7 +63,7 @@ float16_t f32_to_f16( float32_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0xFF ) {
         if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF16UI( &commonNaN );
         } else {
             uiZ = packToF16UI( sign, 0x1F, 0 );
@@ -79,7 +79,8 @@ float16_t f32_to_f16( float32_t a )
     }
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    return softfloat_roundPackToF16( sign, exp - 0x71, frac16 | 0x4000 );
+    return softfloat_roundPackToF16(
+        sign, exp - 0x71, frac16 | 0x4000 STATE_VAR );
  uiZ:
     uZ.ui = uiZ;
     return uZ.f;
diff --git a/source/f32_to_f64.c b/source/f32_to_f64.c
index 6cd08edd..1b92bc80 100644
--- a/source/f32_to_f64.c
+++ b/source/f32_to_f64.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f32_to_f64( float32_t a )
+float64_t f32_to_f64( float32_t a STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -64,7 +64,7 @@ float64_t f32_to_f64( float32_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0xFF ) {
         if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF64UI( &commonNaN );
         } else {
             uiZ = packToF64UI( sign, 0x7FF, 0 );
diff --git a/source/f32_to_i32.c b/source/f32_to_i32.c
index 241ab8e8..b3e98665 100644
--- a/source/f32_to_i32.c
+++ b/source/f32_to_i32.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast32_t f32_to_i32( float32_t a, uint_fast8_t roundingMode, bool exact )
+int_fast32_t f32_to_i32( float32_t a, uint_fast8_t roundingMode, bool exact
+                         STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -67,7 +68,7 @@ int_fast32_t f32_to_i32( float32_t a, uint_fast8_t roundingMode, bool exact )
 #elif (i32_fromNaN == i32_fromNegOverflow)
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return i32_fromNaN;
 #endif
     }
@@ -78,7 +79,7 @@ int_fast32_t f32_to_i32( float32_t a, uint_fast8_t roundingMode, bool exact )
     sig64 = (uint_fast64_t) sig<<32;
     shiftDist = 0xAA - exp;
     if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToI32( sign, sig64, roundingMode, exact );
+    return softfloat_roundToI32( sign, sig64, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/f32_to_i32_r_minMag.c b/source/f32_to_i32_r_minMag.c
index f8134f46..55dd7d28 100644
--- a/source/f32_to_i32_r_minMag.c
+++ b/source/f32_to_i32_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact )
+int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -62,7 +62,7 @@ int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact )
     shiftDist = 0x9E - exp;
     if ( 32 <= shiftDist ) {
         if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -71,7 +71,7 @@ int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact )
     sign = signF32UI( uiA );
     if ( shiftDist <= 0 ) {
         if ( uiA == packToF32UI( 1, 0x9E, 0 ) ) return -0x7FFFFFFF - 1;
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0xFF) && sig ? i32_fromNaN
                 : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
@@ -81,7 +81,7 @@ int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact )
     sig = (sig | 0x00800000)<<8;
     absZ = sig>>shiftDist;
     if ( exact && ((uint_fast32_t) absZ<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return sign ? -absZ : absZ;
 
diff --git a/source/f32_to_i64.c b/source/f32_to_i64.c
index 816bc7be..adb67fb8 100644
--- a/source/f32_to_i64.c
+++ b/source/f32_to_i64.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast64_t f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact )
+int_fast64_t f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact
+                         STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -67,7 +68,7 @@ int_fast64_t f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact )
     *------------------------------------------------------------------------*/
     shiftDist = 0xBE - exp;
     if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0xFF) && sig ? i64_fromNaN
                 : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
@@ -83,13 +84,14 @@ int_fast64_t f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact )
         sig64 = sig64Extra.v;
         extra = sig64Extra.extra;
     }
-    return softfloat_roundToI64( sign, sig64, extra, roundingMode, exact );
+    return softfloat_roundToI64( sign, sig64, extra, roundingMode, exact
+                                 STATE_VAR );
 #else
     extSig[indexWord( 3, 2 )] = sig<<8;
     extSig[indexWord( 3, 1 )] = 0;
     extSig[indexWord( 3, 0 )] = 0;
     if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToI64( sign, extSig, roundingMode, exact STATE_VAR );
 #endif
 
 }
diff --git a/source/f32_to_i64_r_minMag.c b/source/f32_to_i64_r_minMag.c
index 346f6b83..76930e55 100644
--- a/source/f32_to_i64_r_minMag.c
+++ b/source/f32_to_i64_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact )
+int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -63,7 +63,7 @@ int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact )
     shiftDist = 0xBE - exp;
     if ( 64 <= shiftDist ) {
         if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -74,7 +74,7 @@ int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact )
         if ( uiA == packToF32UI( 1, 0xBE, 0 ) ) {
             return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
         }
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0xFF) && sig ? i64_fromNaN
                 : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
@@ -86,7 +86,7 @@ int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact )
     absZ = sig64>>shiftDist;
     shiftDist = 40 - shiftDist;
     if ( exact && (shiftDist < 0) && (uint32_t) (sig<<(shiftDist & 31)) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return sign ? -absZ : absZ;
 
diff --git a/source/f32_to_ui32.c b/source/f32_to_ui32.c
index 32d9eaca..a44a7b4a 100644
--- a/source/f32_to_ui32.c
+++ b/source/f32_to_ui32.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast32_t f32_to_ui32( float32_t a, uint_fast8_t roundingMode, bool exact )
+uint_fast32_t f32_to_ui32( float32_t a, uint_fast8_t roundingMode, bool exact
+                           STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -67,7 +68,7 @@ uint_fast32_t f32_to_ui32( float32_t a, uint_fast8_t roundingMode, bool exact )
 #elif (ui32_fromNaN == ui32_fromNegOverflow)
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return ui32_fromNaN;
 #endif
     }
@@ -78,7 +79,7 @@ uint_fast32_t f32_to_ui32( float32_t a, uint_fast8_t roundingMode, bool exact )
     sig64 = (uint_fast64_t) sig<<32;
     shiftDist = 0xAA - exp;
     if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig64, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/f32_to_ui32_r_minMag.c b/source/f32_to_ui32_r_minMag.c
index a90ef926..0fe6beaa 100644
--- a/source/f32_to_ui32_r_minMag.c
+++ b/source/f32_to_ui32_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact )
+uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -62,7 +62,7 @@ uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact )
     shiftDist = 0x9E - exp;
     if ( 32 <= shiftDist ) {
         if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -70,7 +70,7 @@ uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact )
     *------------------------------------------------------------------------*/
     sign = signF32UI( uiA );
     if ( sign || (shiftDist < 0) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0xFF) && sig ? ui32_fromNaN
                 : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
@@ -80,7 +80,7 @@ uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact )
     sig = (sig | 0x00800000)<<8;
     z = sig>>shiftDist;
     if ( exact && (z<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return z;
 
diff --git a/source/f32_to_ui64.c b/source/f32_to_ui64.c
index 16e608a0..00eadd3c 100644
--- a/source/f32_to_ui64.c
+++ b/source/f32_to_ui64.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast64_t f32_to_ui64( float32_t a, uint_fast8_t roundingMode, bool exact )
+uint_fast64_t f32_to_ui64( float32_t a, uint_fast8_t roundingMode, bool exact
+                           STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -67,7 +68,7 @@ uint_fast64_t f32_to_ui64( float32_t a, uint_fast8_t roundingMode, bool exact )
     *------------------------------------------------------------------------*/
     shiftDist = 0xBE - exp;
     if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0xFF) && sig ? ui64_fromNaN
                 : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
@@ -83,13 +84,14 @@ uint_fast64_t f32_to_ui64( float32_t a, uint_fast8_t roundingMode, bool exact )
         sig64 = sig64Extra.v;
         extra = sig64Extra.extra;
     }
-    return softfloat_roundToUI64( sign, sig64, extra, roundingMode, exact );
+    return softfloat_roundToUI64( sign, sig64, extra, roundingMode, exact
+                                  STATE_VAR );
 #else
     extSig[indexWord( 3, 2 )] = sig<<8;
     extSig[indexWord( 3, 1 )] = 0;
     extSig[indexWord( 3, 0 )] = 0;
     if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact STATE_VAR);
 #endif
 
 }
diff --git a/source/f32_to_ui64_r_minMag.c b/source/f32_to_ui64_r_minMag.c
index 69e00648..fb0df60c 100644
--- a/source/f32_to_ui64_r_minMag.c
+++ b/source/f32_to_ui64_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact )
+uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact STATE_PARAM )
 {
     union ui32_f32 uA;
     uint_fast32_t uiA;
@@ -62,7 +62,7 @@ uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact )
     shiftDist = 0xBE - exp;
     if ( 64 <= shiftDist ) {
         if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -70,7 +70,7 @@ uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact )
     *------------------------------------------------------------------------*/
     sign = signF32UI( uiA );
     if ( sign || (shiftDist < 0) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0xFF) && sig ? ui64_fromNaN
                 : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
@@ -82,7 +82,7 @@ uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact )
     z = sig64>>shiftDist;
     shiftDist = 40 - shiftDist;
     if ( exact && (shiftDist < 0) && (uint32_t) (sig<<(shiftDist & 31)) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return z;
 
diff --git a/source/f64_add.c b/source/f64_add.c
index 878f6da7..be7ddc06 100644
--- a/source/f64_add.c
+++ b/source/f64_add.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float64_t f64_add( float64_t a, float64_t b )
+float64_t f64_add( float64_t a, float64_t b STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -49,7 +49,7 @@ float64_t f64_add( float64_t a, float64_t b )
     uint_fast64_t uiB;
     bool signB;
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool );
+    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool STATE_PARAM );
 #endif
 
     uA.f = a;
@@ -60,14 +60,14 @@ float64_t f64_add( float64_t a, float64_t b )
     signB = signF64UI( uiB );
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        return softfloat_addMagsF64( uiA, uiB, signA );
+        return softfloat_addMagsF64( uiA, uiB, signA STATE_VAR );
     } else {
-        return softfloat_subMagsF64( uiA, uiB, signA );
+        return softfloat_subMagsF64( uiA, uiB, signA STATE_VAR );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_addMagsF64 : softfloat_subMagsF64;
-    return (*magsFuncPtr)( uiA, uiB, signA );
+    return (*magsFuncPtr)( uiA, uiB, signA STATE_VAR );
 #endif
 
 }
diff --git a/source/f64_div.c b/source/f64_div.c
index 7f5eddd4..88baf226 100644
--- a/source/f64_div.c
+++ b/source/f64_div.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f64_div( float64_t a, float64_t b )
+float64_t f64_div( float64_t a, float64_t b STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -95,7 +95,7 @@ float64_t f64_div( float64_t a, float64_t b )
     if ( ! expB ) {
         if ( ! sigB ) {
             if ( ! (expA | sigA) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
+            softfloat_raiseFlags( softfloat_flag_infinite STATE_VAR );
             goto infinity;
         }
         normExpSig = softfloat_normSubnormalF64Sig( sigB );
@@ -143,16 +143,16 @@ float64_t f64_div( float64_t a, float64_t b )
             if ( rem ) sigZ |= 1;
         }
     }
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
+    return softfloat_roundPackToF64( signZ, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ = defaultNaNF64UI;
     goto uiZ;
     /*------------------------------------------------------------------------
diff --git a/source/f64_eq.c b/source/f64_eq.c
index e075c02f..45247267 100644
--- a/source/f64_eq.c
+++ b/source/f64_eq.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f64_eq( float64_t a, float64_t b )
+bool f64_eq( float64_t a, float64_t b STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -56,7 +56,7 @@ bool f64_eq( float64_t a, float64_t b )
         if (
             softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f64_eq_signaling.c b/source/f64_eq_signaling.c
index d7e89a2e..8b8f72b0 100644
--- a/source/f64_eq_signaling.c
+++ b/source/f64_eq_signaling.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool f64_eq_signaling( float64_t a, float64_t b )
+bool f64_eq_signaling( float64_t a, float64_t b STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -52,7 +52,7 @@ bool f64_eq_signaling( float64_t a, float64_t b )
     uB.f = b;
     uiB = uB.ui;
     if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     return (uiA == uiB) || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ));
diff --git a/source/f64_le.c b/source/f64_le.c
index a96808f3..c00dffd6 100644
--- a/source/f64_le.c
+++ b/source/f64_le.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool f64_le( float64_t a, float64_t b )
+bool f64_le( float64_t a, float64_t b STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -53,7 +53,7 @@ bool f64_le( float64_t a, float64_t b )
     uB.f = b;
     uiB = uB.ui;
     if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     signA = signF64UI( uiA );
diff --git a/source/f64_le_quiet.c b/source/f64_le_quiet.c
index 942afba7..eb41e908 100644
--- a/source/f64_le_quiet.c
+++ b/source/f64_le_quiet.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f64_le_quiet( float64_t a, float64_t b )
+bool f64_le_quiet( float64_t a, float64_t b STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -57,7 +57,7 @@ bool f64_le_quiet( float64_t a, float64_t b )
         if (
             softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f64_lt.c b/source/f64_lt.c
index d9cf5aa7..ad4b3b66 100644
--- a/source/f64_lt.c
+++ b/source/f64_lt.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-bool f64_lt( float64_t a, float64_t b )
+bool f64_lt( float64_t a, float64_t b STATE_PARAM)
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -53,7 +53,7 @@ bool f64_lt( float64_t a, float64_t b )
     uB.f = b;
     uiB = uB.ui;
     if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return false;
     }
     signA = signF64UI( uiA );
diff --git a/source/f64_lt_quiet.c b/source/f64_lt_quiet.c
index 89d30bc0..0f4aef50 100644
--- a/source/f64_lt_quiet.c
+++ b/source/f64_lt_quiet.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f64_lt_quiet( float64_t a, float64_t b )
+bool f64_lt_quiet( float64_t a, float64_t b STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -57,7 +57,7 @@ bool f64_lt_quiet( float64_t a, float64_t b )
         if (
             softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
         ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         }
         return false;
     }
diff --git a/source/f64_mul.c b/source/f64_mul.c
index 38bdc852..96d000a8 100644
--- a/source/f64_mul.c
+++ b/source/f64_mul.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f64_mul( float64_t a, float64_t b )
+float64_t f64_mul( float64_t a, float64_t b STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -122,17 +122,17 @@ float64_t f64_mul( float64_t a, float64_t b )
         --expZ;
         sigZ <<= 1;
     }
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
+    return softfloat_roundPackToF64( signZ, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  infArg:
     if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         uiZ = defaultNaNF64UI;
     } else {
         uiZ = packToF64UI( signZ, 0x7FF, 0 );
diff --git a/source/f64_mulAdd.c b/source/f64_mulAdd.c
index 13fc3828..b38aab85 100644
--- a/source/f64_mulAdd.c
+++ b/source/f64_mulAdd.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c )
+float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -54,7 +54,7 @@ float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c )
     uiB = uB.ui;
     uC.f = c;
     uiC = uC.ui;
-    return softfloat_mulAddF64( uiA, uiB, uiC, 0 );
+    return softfloat_mulAddF64( uiA, uiB, uiC, 0 STATE_VAR );
 
 }
 
diff --git a/source/f64_rem.c b/source/f64_rem.c
index ca5350c9..5aba64a7 100644
--- a/source/f64_rem.c
+++ b/source/f64_rem.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f64_rem( float64_t a, float64_t b )
+float64_t f64_rem( float64_t a, float64_t b STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -172,14 +172,14 @@ float64_t f64_rem( float64_t a, float64_t b )
         signRem = ! signRem;
         rem = -rem;
     }
-    return softfloat_normRoundPackToF64( signRem, expB, rem );
+    return softfloat_normRoundPackToF64( signRem, expB, rem STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB STATE_VAR );
     goto uiZ;
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ = defaultNaNF64UI;
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/f64_roundToInt.c b/source/f64_roundToInt.c
index c5f08ae1..d7691af2 100644
--- a/source/f64_roundToInt.c
+++ b/source/f64_roundToInt.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact )
+float64_t f64_roundToInt(
+    float64_t a, uint_fast8_t roundingMode, bool exact STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -58,7 +59,7 @@ float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact )
     *------------------------------------------------------------------------*/
     if ( exp <= 0x3FE ) {
         if ( !(uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) return a;
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         uiZ = uiA & packToF64UI( 1, 0, 0 );
         switch ( roundingMode ) {
          case softfloat_round_near_even:
@@ -84,7 +85,7 @@ float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact )
     *------------------------------------------------------------------------*/
     if ( 0x433 <= exp ) {
         if ( (exp == 0x7FF) && fracF64UI( uiA ) ) {
-            uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
+            uiZ = softfloat_propagateNaNF64UI( uiA, 0 STATE_VAR );
             goto uiZ;
         }
         return a;
@@ -110,7 +111,7 @@ float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact )
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask;
 #endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/f64_sqrt.c b/source/f64_sqrt.c
index f12acdb4..3eee585d 100644
--- a/source/f64_sqrt.c
+++ b/source/f64_sqrt.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f64_sqrt( float64_t a )
+float64_t f64_sqrt( float64_t a STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -67,7 +67,7 @@ float64_t f64_sqrt( float64_t a )
     *------------------------------------------------------------------------*/
     if ( expA == 0x7FF ) {
         if ( sigA ) {
-            uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
+            uiZ = softfloat_propagateNaNF64UI( uiA, 0 STATE_VAR );
             goto uiZ;
         }
         if ( ! signA ) return a;
@@ -119,11 +119,11 @@ float64_t f64_sqrt( float64_t a )
             if ( rem ) sigZ |= 1;
         }
     }
-    return softfloat_roundPackToF64( 0, expZ, sigZ );
+    return softfloat_roundPackToF64( 0, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ = defaultNaNF64UI;
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/f64_sub.c b/source/f64_sub.c
index 74158bec..7c1f9360 100644
--- a/source/f64_sub.c
+++ b/source/f64_sub.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float64_t f64_sub( float64_t a, float64_t b )
+float64_t f64_sub( float64_t a, float64_t b STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -49,7 +49,7 @@ float64_t f64_sub( float64_t a, float64_t b )
     uint_fast64_t uiB;
     bool signB;
 #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool );
+    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool STATE_PARAM );
 #endif
 
     uA.f = a;
@@ -60,14 +60,14 @@ float64_t f64_sub( float64_t a, float64_t b )
     signB = signF64UI( uiB );
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
     if ( signA == signB ) {
-        return softfloat_subMagsF64( uiA, uiB, signA );
+        return softfloat_subMagsF64( uiA, uiB, signA STATE_VAR );
     } else {
-        return softfloat_addMagsF64( uiA, uiB, signA );
+        return softfloat_addMagsF64( uiA, uiB, signA STATE_VAR );
     }
 #else
     magsFuncPtr =
         (signA == signB) ? softfloat_subMagsF64 : softfloat_addMagsF64;
-    return (*magsFuncPtr)( uiA, uiB, signA );
+    return (*magsFuncPtr)( uiA, uiB, signA STATE_VAR );
 #endif
 
 }
diff --git a/source/f64_to_extF80.c b/source/f64_to_extF80.c
index 553ebd0c..85cc91d1 100644
--- a/source/f64_to_extF80.c
+++ b/source/f64_to_extF80.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-extFloat80_t f64_to_extF80( float64_t a )
+extFloat80_t f64_to_extF80( float64_t a STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -66,7 +66,7 @@ extFloat80_t f64_to_extF80( float64_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FF ) {
         if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
             uiZ64 = uiZ.v64;
             uiZ0  = uiZ.v0;
diff --git a/source/f64_to_extF80M.c b/source/f64_to_extF80M.c
index d258bdc2..be54df88 100644
--- a/source/f64_to_extF80M.c
+++ b/source/f64_to_extF80M.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f64_to_extF80M( float64_t a, extFloat80_t *zPtr )
+void f64_to_extF80M( float64_t a, extFloat80_t *zPtr STATE_PARAM )
 {
 
-    *zPtr = f64_to_extF80( a );
+    *zPtr = f64_to_extF80( a STATE_VAR );
 
 }
 
 #else
 
-void f64_to_extF80M( float64_t a, extFloat80_t *zPtr )
+void f64_to_extF80M( float64_t a, extFloat80_t *zPtr STATE_PARAM )
 {
     struct extFloat80M *zSPtr;
     union ui64_f64 uA;
@@ -77,7 +77,7 @@ void f64_to_extF80M( float64_t a, extFloat80_t *zPtr )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FF ) {
         if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
             return;
         }
diff --git a/source/f64_to_f128.c b/source/f64_to_f128.c
index 8f03f2ff..f4d961d0 100644
--- a/source/f64_to_f128.c
+++ b/source/f64_to_f128.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float128_t f64_to_f128( float64_t a )
+float128_t f64_to_f128( float64_t a STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -65,7 +65,7 @@ float128_t f64_to_f128( float64_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FF ) {
         if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF128UI( &commonNaN );
         } else {
             uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 );
diff --git a/source/f64_to_f128M.c b/source/f64_to_f128M.c
index e4a862c7..e18a125c 100644
--- a/source/f64_to_f128M.c
+++ b/source/f64_to_f128M.c
@@ -43,16 +43,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef SOFTFLOAT_FAST_INT64
 
-void f64_to_f128M( float64_t a, float128_t *zPtr )
+void f64_to_f128M( float64_t a, float128_t *zPtr STATE_PARAM )
 {
 
-    *zPtr = f64_to_f128( a );
+    *zPtr = f64_to_f128( a STATE_VAR );
 
 }
 
 #else
 
-void f64_to_f128M( float64_t a, float128_t *zPtr )
+void f64_to_f128M( float64_t a, float128_t *zPtr STATE_PARAM )
 {
     uint32_t *zWPtr;
     union ui64_f64 uA;
@@ -79,7 +79,7 @@ void f64_to_f128M( float64_t a, float128_t *zPtr )
     zWPtr[indexWord( 4, 0 )] = 0;
     if ( exp == 0x7FF ) {
         if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             softfloat_commonNaNToF128M( &commonNaN, zWPtr );
             return;
         }
diff --git a/source/f64_to_f16.c b/source/f64_to_f16.c
index 0cc6cc53..ec9f1df0 100644
--- a/source/f64_to_f16.c
+++ b/source/f64_to_f16.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t f64_to_f16( float64_t a )
+float16_t f64_to_f16( float64_t a STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -63,7 +63,7 @@ float16_t f64_to_f16( float64_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FF ) {
         if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF16UI( &commonNaN );
         } else {
             uiZ = packToF16UI( sign, 0x1F, 0 );
@@ -79,7 +79,8 @@ float16_t f64_to_f16( float64_t a )
     }
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    return softfloat_roundPackToF16( sign, exp - 0x3F1, frac16 | 0x4000 );
+    return softfloat_roundPackToF16(
+        sign, exp - 0x3F1, frac16 | 0x4000 STATE_VAR );
  uiZ:
     uZ.ui = uiZ;
     return uZ.f;
diff --git a/source/f64_to_f32.c b/source/f64_to_f32.c
index 6074bb84..73955961 100644
--- a/source/f64_to_f32.c
+++ b/source/f64_to_f32.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f64_to_f32( float64_t a )
+float32_t f64_to_f32( float64_t a STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -63,7 +63,7 @@ float32_t f64_to_f32( float64_t a )
     *------------------------------------------------------------------------*/
     if ( exp == 0x7FF ) {
         if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN STATE_VAR );
             uiZ = softfloat_commonNaNToF32UI( &commonNaN );
         } else {
             uiZ = packToF32UI( sign, 0xFF, 0 );
@@ -79,7 +79,8 @@ float32_t f64_to_f32( float64_t a )
     }
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    return softfloat_roundPackToF32( sign, exp - 0x381, frac32 | 0x40000000 );
+    return softfloat_roundPackToF32(
+        sign, exp - 0x381, frac32 | 0x40000000 STATE_VAR );
  uiZ:
     uZ.ui = uiZ;
     return uZ.f;
diff --git a/source/f64_to_i32.c b/source/f64_to_i32.c
index 2cf26030..2993798d 100644
--- a/source/f64_to_i32.c
+++ b/source/f64_to_i32.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact )
+int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact
+                         STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -66,7 +67,7 @@ int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact )
 #elif (i32_fromNaN == i32_fromNegOverflow)
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return i32_fromNaN;
 #endif
     }
@@ -76,7 +77,7 @@ int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact )
     if ( exp ) sig |= UINT64_C( 0x0010000000000000 );
     shiftDist = 0x427 - exp;
     if ( 0 < shiftDist ) sig = softfloat_shiftRightJam64( sig, shiftDist );
-    return softfloat_roundToI32( sign, sig, roundingMode, exact );
+    return softfloat_roundToI32( sign, sig, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/f64_to_i32_r_minMag.c b/source/f64_to_i32_r_minMag.c
index 8cccb8ef..1440836c 100644
--- a/source/f64_to_i32_r_minMag.c
+++ b/source/f64_to_i32_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact )
+int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -62,7 +62,7 @@ int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact )
     shiftDist = 0x433 - exp;
     if ( 53 <= shiftDist ) {
         if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -74,11 +74,11 @@ int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact )
             sign && (exp == 0x41E) && (sig < UINT64_C( 0x0000000000200000 ))
         ) {
             if ( exact && sig ) {
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
+                softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
             }
             return -0x7FFFFFFF - 1;
         }
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FF) && sig ? i32_fromNaN
                 : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
@@ -88,7 +88,7 @@ int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact )
     sig |= UINT64_C( 0x0010000000000000 );
     absZ = sig>>shiftDist;
     if ( exact && ((uint_fast64_t) (uint_fast32_t) absZ<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return sign ? -absZ : absZ;
 
diff --git a/source/f64_to_i64.c b/source/f64_to_i64.c
index 0acf6c2e..876931d6 100644
--- a/source/f64_to_i64.c
+++ b/source/f64_to_i64.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast64_t f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact )
+int_fast64_t f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact
+                         STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -76,7 +77,7 @@ int_fast64_t f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact )
     }
     return
         softfloat_roundToI64(
-            sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
+            sign, sigExtra.v, sigExtra.extra, roundingMode, exact STATE_VAR );
 #else
     extSig[indexWord( 3, 0 )] = 0;
     if ( shiftDist <= 0 ) {
@@ -89,12 +90,12 @@ int_fast64_t f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact )
         extSig[indexWord( 3, 1 )] = sig;
         softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
     }
-    return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToI64( sign, extSig, roundingMode, exact STATE_VAR );
 #endif
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FF) && fracF64UI( uiA ) ? i64_fromNaN
             : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
diff --git a/source/f64_to_i64_r_minMag.c b/source/f64_to_i64_r_minMag.c
index 4fcc52c5..ca6ab82b 100644
--- a/source/f64_to_i64_r_minMag.c
+++ b/source/f64_to_i64_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact )
+int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -68,7 +68,7 @@ int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact )
             if ( uiA == packToF64UI( 1, 0x43E, 0 ) ) {
                 return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
             }
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
             return
                 (exp == 0x7FF) && sig ? i64_fromNaN
                     : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
@@ -82,7 +82,7 @@ int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact )
         *--------------------------------------------------------------------*/
         if ( 53 <= shiftDist ) {
             if ( exact && (exp | sig) ) {
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
+                softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
             }
             return 0;
         }
@@ -91,7 +91,7 @@ int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact )
         sig |= UINT64_C( 0x0010000000000000 );
         absZ = sig>>shiftDist;
         if ( exact && (absZ<<shiftDist != sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
     }
     return sign ? -absZ : absZ;
diff --git a/source/f64_to_ui32.c b/source/f64_to_ui32.c
index 4326922f..b04a6400 100644
--- a/source/f64_to_ui32.c
+++ b/source/f64_to_ui32.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast32_t f64_to_ui32( float64_t a, uint_fast8_t roundingMode, bool exact )
+uint_fast32_t f64_to_ui32( float64_t a, uint_fast8_t roundingMode, bool exact
+                           STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -66,7 +67,7 @@ uint_fast32_t f64_to_ui32( float64_t a, uint_fast8_t roundingMode, bool exact )
 #elif (ui32_fromNaN == ui32_fromNegOverflow)
         sign = 1;
 #else
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return ui32_fromNaN;
 #endif
     }
@@ -76,7 +77,7 @@ uint_fast32_t f64_to_ui32( float64_t a, uint_fast8_t roundingMode, bool exact )
     if ( exp ) sig |= UINT64_C( 0x0010000000000000 );
     shiftDist = 0x427 - exp;
     if ( 0 < shiftDist ) sig = softfloat_shiftRightJam64( sig, shiftDist );
-    return softfloat_roundToUI32( sign, sig, roundingMode, exact );
+    return softfloat_roundToUI32( sign, sig, roundingMode, exact STATE_VAR );
 
 }
 
diff --git a/source/f64_to_ui32_r_minMag.c b/source/f64_to_ui32_r_minMag.c
index 01758dc5..91278b64 100644
--- a/source/f64_to_ui32_r_minMag.c
+++ b/source/f64_to_ui32_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact )
+uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -62,7 +62,7 @@ uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact )
     shiftDist = 0x433 - exp;
     if ( 53 <= shiftDist ) {
         if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -70,7 +70,7 @@ uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact )
     *------------------------------------------------------------------------*/
     sign = signF64UI( uiA );
     if ( sign || (shiftDist < 21) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         return
             (exp == 0x7FF) && sig ? ui32_fromNaN
                 : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
@@ -80,7 +80,7 @@ uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact )
     sig |= UINT64_C( 0x0010000000000000 );
     z = sig>>shiftDist;
     if ( exact && ((uint_fast64_t) z<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return z;
 
diff --git a/source/f64_to_ui64.c b/source/f64_to_ui64.c
index e7fb8f64..de6562cc 100644
--- a/source/f64_to_ui64.c
+++ b/source/f64_to_ui64.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast64_t f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact )
+uint_fast64_t f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact
+                           STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -76,7 +77,7 @@ uint_fast64_t f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact )
     }
     return
         softfloat_roundToUI64(
-            sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
+            sign, sigExtra.v, sigExtra.extra, roundingMode, exact STATE_VAR );
 #else
     extSig[indexWord( 3, 0 )] = 0;
     if ( shiftDist <= 0 ) {
@@ -89,12 +90,12 @@ uint_fast64_t f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact )
         extSig[indexWord( 3, 1 )] = sig;
         softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
     }
-    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact STATE_VAR);
 #endif
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FF) && fracF64UI( uiA ) ? ui64_fromNaN
             : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
diff --git a/source/f64_to_ui64_r_minMag.c b/source/f64_to_ui64_r_minMag.c
index e1d81a01..a80512d9 100644
--- a/source/f64_to_ui64_r_minMag.c
+++ b/source/f64_to_ui64_r_minMag.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact )
+uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact STATE_PARAM )
 {
     union ui64_f64 uA;
     uint_fast64_t uiA;
@@ -62,7 +62,7 @@ uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact )
     shiftDist = 0x433 - exp;
     if ( 53 <= shiftDist ) {
         if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
         return 0;
     }
@@ -77,14 +77,14 @@ uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact )
         sig |= UINT64_C( 0x0010000000000000 );
         z = sig>>shiftDist;
         if ( exact && (uint64_t) (sig<<(-shiftDist & 63)) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
+            softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
         }
     }
     return z;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return
         (exp == 0x7FF) && sig ? ui64_fromNaN
             : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
diff --git a/source/i32_to_f16.c b/source/i32_to_f16.c
index 14ac5886..f8e857a9 100644
--- a/source/i32_to_f16.c
+++ b/source/i32_to_f16.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float16_t i32_to_f16( int32_t a )
+float16_t i32_to_f16( int32_t a STATE_PARAM )
 {
     bool sign;
     uint_fast32_t absA;
@@ -64,7 +64,8 @@ float16_t i32_to_f16( int32_t a )
                 ? absA>>(-shiftDist)
                       | ((uint32_t) (absA<<(shiftDist & 31)) != 0)
                 : (uint_fast16_t) absA<<shiftDist;
-        return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig );
+        return softfloat_roundPackToF16(
+            sign, 0x1C - shiftDist, sig STATE_VAR );
     }
 
 }
diff --git a/source/i32_to_f32.c b/source/i32_to_f32.c
index 4057655d..96e1b20a 100644
--- a/source/i32_to_f32.c
+++ b/source/i32_to_f32.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float32_t i32_to_f32( int32_t a )
+float32_t i32_to_f32( int32_t a STATE_PARAM )
 {
     bool sign;
     union ui32_f32 uZ;
@@ -52,7 +52,7 @@ float32_t i32_to_f32( int32_t a )
         return uZ.f;
     }
     absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
-    return softfloat_normRoundPackToF32( sign, 0x9C, absA );
+    return softfloat_normRoundPackToF32( sign, 0x9C, absA STATE_VAR );
 
 }
 
diff --git a/source/i64_to_f16.c b/source/i64_to_f16.c
index f16eccf0..7707f187 100644
--- a/source/i64_to_f16.c
+++ b/source/i64_to_f16.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float16_t i64_to_f16( int64_t a )
+float16_t i64_to_f16( int64_t a STATE_PARAM )
 {
     bool sign;
     uint_fast64_t absA;
@@ -63,7 +63,8 @@ float16_t i64_to_f16( int64_t a )
             (shiftDist < 0)
                 ? softfloat_shortShiftRightJam64( absA, -shiftDist )
                 : (uint_fast16_t) absA<<shiftDist;
-        return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig );
+        return softfloat_roundPackToF16(
+            sign, 0x1C - shiftDist, sig STATE_VAR );
     }
 
 }
diff --git a/source/i64_to_f32.c b/source/i64_to_f32.c
index 391e1ae8..8b74dc6b 100644
--- a/source/i64_to_f32.c
+++ b/source/i64_to_f32.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float32_t i64_to_f32( int64_t a )
+float32_t i64_to_f32( int64_t a STATE_PARAM )
 {
     bool sign;
     uint_fast64_t absA;
@@ -63,7 +63,8 @@ float32_t i64_to_f32( int64_t a )
             (shiftDist < 0)
                 ? softfloat_shortShiftRightJam64( absA, -shiftDist )
                 : (uint_fast32_t) absA<<shiftDist;
-        return softfloat_roundPackToF32( sign, 0x9C - shiftDist, sig );
+        return softfloat_roundPackToF32(
+            sign, 0x9C - shiftDist, sig STATE_VAR );
     }
 
 }
diff --git a/source/i64_to_f64.c b/source/i64_to_f64.c
index 6d26ddc0..93027d0d 100644
--- a/source/i64_to_f64.c
+++ b/source/i64_to_f64.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float64_t i64_to_f64( int64_t a )
+float64_t i64_to_f64( int64_t a STATE_PARAM )
 {
     bool sign;
     union ui64_f64 uZ;
@@ -52,7 +52,7 @@ float64_t i64_to_f64( int64_t a )
         return uZ.f;
     }
     absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
-    return softfloat_normRoundPackToF64( sign, 0x43C, absA );
+    return softfloat_normRoundPackToF64( sign, 0x43C, absA STATE_VAR );
 
 }
 
diff --git a/source/include/internals.h b/source/include/internals.h
index f8eac053..4c49e293 100644
--- a/source/include/internals.h
+++ b/source/include/internals.h
@@ -58,24 +58,28 @@ enum {
 
 /*----------------------------------------------------------------------------
 *----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_roundToUI32( bool, uint_fast64_t, uint_fast8_t, bool );
+uint_fast32_t softfloat_roundToUI32(
+    bool, uint_fast64_t, uint_fast8_t, bool STATE_PARAM );
 
 #ifdef SOFTFLOAT_FAST_INT64
 uint_fast64_t
  softfloat_roundToUI64(
-     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );
+     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool STATE_PARAM );
 #else
-uint_fast64_t softfloat_roundMToUI64( bool, uint32_t *, uint_fast8_t, bool );
+uint_fast64_t softfloat_roundMToUI64(
+    bool, uint32_t *, uint_fast8_t, bool STATE_PARAM );
 #endif
 
-int_fast32_t softfloat_roundToI32( bool, uint_fast64_t, uint_fast8_t, bool );
+int_fast32_t softfloat_roundToI32(
+    bool, uint_fast64_t, uint_fast8_t, bool STATE_PARAM );
 
 #ifdef SOFTFLOAT_FAST_INT64
 int_fast64_t
  softfloat_roundToI64(
-     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );
+     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool STATE_PARAM );
 #else
-int_fast64_t softfloat_roundMToI64( bool, uint32_t *, uint_fast8_t, bool );
+int_fast64_t softfloat_roundMToI64(
+    bool, uint32_t *, uint_fast8_t, bool STATE_PARAM );
 #endif
 
 /*----------------------------------------------------------------------------
@@ -90,14 +94,16 @@ int_fast64_t softfloat_roundMToI64( bool, uint32_t *, uint_fast8_t, bool );
 struct exp8_sig16 { int_fast8_t exp; uint_fast16_t sig; };
 struct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t );
 
-float16_t softfloat_roundPackToF16( bool, int_fast16_t, uint_fast16_t );
-float16_t softfloat_normRoundPackToF16( bool, int_fast16_t, uint_fast16_t );
+float16_t softfloat_roundPackToF16(
+    bool, int_fast16_t, uint_fast16_t STATE_PARAM );
+float16_t softfloat_normRoundPackToF16(
+    bool, int_fast16_t, uint_fast16_t STATE_PARAM );
 
-float16_t softfloat_addMagsF16( uint_fast16_t, uint_fast16_t );
-float16_t softfloat_subMagsF16( uint_fast16_t, uint_fast16_t );
+float16_t softfloat_addMagsF16( uint_fast16_t, uint_fast16_t STATE_PARAM );
+float16_t softfloat_subMagsF16( uint_fast16_t, uint_fast16_t STATE_PARAM );
 float16_t
  softfloat_mulAddF16(
-     uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t );
+     uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 *----------------------------------------------------------------------------*/
@@ -111,14 +117,16 @@ float16_t
 struct exp16_sig32 { int_fast16_t exp; uint_fast32_t sig; };
 struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t );
 
-float32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t );
-float32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t );
+float32_t softfloat_roundPackToF32(
+    bool, int_fast16_t, uint_fast32_t STATE_PARAM );
+float32_t softfloat_normRoundPackToF32(
+    bool, int_fast16_t, uint_fast32_t STATE_PARAM );
 
-float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t );
-float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t );
+float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t STATE_PARAM );
+float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t STATE_PARAM );
 float32_t
  softfloat_mulAddF32(
-     uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t );
+     uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 *----------------------------------------------------------------------------*/
@@ -132,14 +140,16 @@ float32_t
 struct exp16_sig64 { int_fast16_t exp; uint_fast64_t sig; };
 struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t );
 
-float64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t );
-float64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t );
+float64_t softfloat_roundPackToF64(
+    bool, int_fast16_t, uint_fast64_t STATE_PARAM );
+float64_t softfloat_normRoundPackToF64(
+    bool, int_fast16_t, uint_fast64_t STATE_PARAM );
 
-float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool );
-float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool );
+float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool STATE_PARAM);
+float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool STATE_PARAM);
 float64_t
  softfloat_mulAddF64(
-     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
+     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 *----------------------------------------------------------------------------*/
@@ -159,17 +169,21 @@ struct exp32_sig64 softfloat_normSubnormalExtF80Sig( uint_fast64_t );
 
 extFloat80_t
  softfloat_roundPackToExtF80(
-     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
+     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t
+     STATE_PARAM );
 extFloat80_t
  softfloat_normRoundPackToExtF80(
-     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
+     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t
+     STATE_PARAM );
 
 extFloat80_t
  softfloat_addMagsExtF80(
-     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool
+     STATE_PARAM );
 extFloat80_t
  softfloat_subMagsExtF80(
-     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool
+     STATE_PARAM );
 
 /*----------------------------------------------------------------------------
 *----------------------------------------------------------------------------*/
@@ -186,17 +200,20 @@ struct exp32_sig128
 
 float128_t
  softfloat_roundPackToF128(
-     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t );
+     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t
+     STATE_PARAM );
 float128_t
  softfloat_normRoundPackToF128(
-     bool, int_fast32_t, uint_fast64_t, uint_fast64_t );
+     bool, int_fast32_t, uint_fast64_t, uint_fast64_t STATE_PARAM );
 
 float128_t
  softfloat_addMagsF128(
-     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool
+     STATE_PARAM );
 float128_t
  softfloat_subMagsF128(
-     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool
+     STATE_PARAM );
 float128_t
  softfloat_mulAddF128(
      uint_fast64_t,
@@ -206,6 +223,7 @@ float128_t
      uint_fast64_t,
      uint_fast64_t,
      uint_fast8_t
+     STATE_PARAM
  );
 
 #else
@@ -219,16 +237,18 @@ bool
      const struct extFloat80M *,
      struct extFloat80M *
  );
-void softfloat_invalidExtF80M( struct extFloat80M * );
+void softfloat_invalidExtF80M( struct extFloat80M * STATE_PARAM );
 
 int softfloat_normExtF80SigM( uint64_t * );
 
 void
  softfloat_roundPackMToExtF80M(
-     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
+     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M *
+     STATE_PARAM );
 void
  softfloat_normRoundPackMToExtF80M(
-     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
+     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M *
+     STATE_PARAM );
 
 void
  softfloat_addExtF80M(
@@ -254,12 +274,14 @@ bool softfloat_isNaNF128M( const uint32_t * );
 bool
  softfloat_tryPropagateNaNF128M(
      const uint32_t *, const uint32_t *, uint32_t * );
-void softfloat_invalidF128M( uint32_t * );
+void softfloat_invalidF128M( uint32_t * STATE_PARAM );
 
 int softfloat_shiftNormSigF128M( const uint32_t *, uint_fast8_t, uint32_t * );
 
-void softfloat_roundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );
-void softfloat_normRoundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );
+void softfloat_roundPackMToF128M(
+    bool, int32_t, uint32_t *, uint32_t * STATE_PARAM );
+void softfloat_normRoundPackMToF128M(
+    bool, int32_t, uint32_t *, uint32_t * STATE_PARAM );
 
 void
  softfloat_addF128M( const uint32_t *, const uint32_t *, uint32_t *, bool );
@@ -270,6 +292,7 @@ void
      const uint32_t *,
      uint32_t *,
      uint_fast8_t
+     STATE_PARAM
  );
 
 #endif
diff --git a/source/include/softfloat.h b/source/include/softfloat.h
index 9ed17c1b..0fa1716a 100644
--- a/source/include/softfloat.h
+++ b/source/include/softfloat.h
@@ -50,14 +50,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <stdint.h>
 #include "softfloat_types.h"
 
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
 #ifndef THREAD_LOCAL
 #define THREAD_LOCAL
 #endif
+#endif
 
 /*----------------------------------------------------------------------------
 | Software floating-point underflow tininess-detection mode.
 *----------------------------------------------------------------------------*/
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
 extern THREAD_LOCAL uint_fast8_t softfloat_detectTininess;
+#endif
 enum {
     softfloat_tininess_beforeRounding = 0,
     softfloat_tininess_afterRounding  = 1
@@ -67,7 +71,9 @@ enum {
 | Software floating-point rounding mode.  (Mode "odd" is supported only if
 | SoftFloat is compiled with macro 'SOFTFLOAT_ROUND_ODD' defined.)
 *----------------------------------------------------------------------------*/
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
 extern THREAD_LOCAL uint_fast8_t softfloat_roundingMode;
+#endif
 enum {
     softfloat_round_near_even   = 0,
     softfloat_round_minMag      = 1,
@@ -80,7 +86,9 @@ enum {
 /*----------------------------------------------------------------------------
 | Software floating-point exception flags.
 *----------------------------------------------------------------------------*/
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
 extern THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags;
+#endif
 enum {
     softfloat_flag_inexact   =  1,
     softfloat_flag_underflow =  2,
@@ -92,13 +100,14 @@ enum {
 /*----------------------------------------------------------------------------
 | Routine to raise any or all of the software floating-point exception flags.
 *----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t );
+void softfloat_raiseFlags( uint_fast8_t STATE_PARAM );
+void softfloat_init_state( softfloat_state_t * state );
 
 /*----------------------------------------------------------------------------
 | Integer-to-floating-point conversion routines.
 *----------------------------------------------------------------------------*/
-float16_t ui32_to_f16( uint32_t );
-float32_t ui32_to_f32( uint32_t );
+float16_t ui32_to_f16( uint32_t STATE_PARAM );
+float32_t ui32_to_f32( uint32_t STATE_PARAM );
 float64_t ui32_to_f64( uint32_t );
 #ifdef SOFTFLOAT_FAST_INT64
 extFloat80_t ui32_to_extF80( uint32_t );
@@ -106,17 +115,17 @@ float128_t ui32_to_f128( uint32_t );
 #endif
 void ui32_to_extF80M( uint32_t, extFloat80_t * );
 void ui32_to_f128M( uint32_t, float128_t * );
-float16_t ui64_to_f16( uint64_t );
-float32_t ui64_to_f32( uint64_t );
-float64_t ui64_to_f64( uint64_t );
+float16_t ui64_to_f16( uint64_t STATE_PARAM );
+float32_t ui64_to_f32( uint64_t STATE_PARAM );
+float64_t ui64_to_f64( uint64_t STATE_PARAM );
 #ifdef SOFTFLOAT_FAST_INT64
 extFloat80_t ui64_to_extF80( uint64_t );
 float128_t ui64_to_f128( uint64_t );
 #endif
 void ui64_to_extF80M( uint64_t, extFloat80_t * );
 void ui64_to_f128M( uint64_t, float128_t * );
-float16_t i32_to_f16( int32_t );
-float32_t i32_to_f32( int32_t );
+float16_t i32_to_f16( int32_t STATE_PARAM );
+float32_t i32_to_f32( int32_t STATE_PARAM );
 float64_t i32_to_f64( int32_t );
 #ifdef SOFTFLOAT_FAST_INT64
 extFloat80_t i32_to_extF80( int32_t );
@@ -124,9 +133,9 @@ float128_t i32_to_f128( int32_t );
 #endif
 void i32_to_extF80M( int32_t, extFloat80_t * );
 void i32_to_f128M( int32_t, float128_t * );
-float16_t i64_to_f16( int64_t );
-float32_t i64_to_f32( int64_t );
-float64_t i64_to_f64( int64_t );
+float16_t i64_to_f16( int64_t STATE_PARAM );
+float32_t i64_to_f32( int64_t STATE_PARAM );
+float64_t i64_to_f64( int64_t STATE_PARAM );
 #ifdef SOFTFLOAT_FAST_INT64
 extFloat80_t i64_to_extF80( int64_t );
 float128_t i64_to_f128( int64_t );
@@ -137,235 +146,257 @@ void i64_to_f128M( int64_t, float128_t * );
 /*----------------------------------------------------------------------------
 | 16-bit (half-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
-uint_fast32_t f16_to_ui32( float16_t, uint_fast8_t, bool );
-uint_fast64_t f16_to_ui64( float16_t, uint_fast8_t, bool );
-int_fast32_t f16_to_i32( float16_t, uint_fast8_t, bool );
-int_fast64_t f16_to_i64( float16_t, uint_fast8_t, bool );
-uint_fast32_t f16_to_ui32_r_minMag( float16_t, bool );
-uint_fast64_t f16_to_ui64_r_minMag( float16_t, bool );
-int_fast32_t f16_to_i32_r_minMag( float16_t, bool );
-int_fast64_t f16_to_i64_r_minMag( float16_t, bool );
-float32_t f16_to_f32( float16_t );
-float64_t f16_to_f64( float16_t );
+uint_fast32_t f16_to_ui32( float16_t, uint_fast8_t, bool STATE_PARAM );
+uint_fast64_t f16_to_ui64( float16_t, uint_fast8_t, bool STATE_PARAM );
+int_fast32_t f16_to_i32( float16_t, uint_fast8_t, bool STATE_PARAM );
+int_fast64_t f16_to_i64( float16_t, uint_fast8_t, bool STATE_PARAM );
+uint_fast32_t f16_to_ui32_r_minMag( float16_t, bool STATE_PARAM );
+uint_fast64_t f16_to_ui64_r_minMag( float16_t, bool STATE_PARAM );
+int_fast32_t f16_to_i32_r_minMag( float16_t, bool STATE_PARAM );
+int_fast64_t f16_to_i64_r_minMag( float16_t, bool STATE_PARAM );
+float32_t f16_to_f32( float16_t STATE_PARAM );
+float64_t f16_to_f64( float16_t STATE_PARAM );
 #ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t f16_to_extF80( float16_t );
-float128_t f16_to_f128( float16_t );
+extFloat80_t f16_to_extF80( float16_t STATE_PARAM );
+float128_t f16_to_f128( float16_t STATE_PARAM );
 #endif
-void f16_to_extF80M( float16_t, extFloat80_t * );
-void f16_to_f128M( float16_t, float128_t * );
-float16_t f16_roundToInt( float16_t, uint_fast8_t, bool );
-float16_t f16_add( float16_t, float16_t );
-float16_t f16_sub( float16_t, float16_t );
-float16_t f16_mul( float16_t, float16_t );
-float16_t f16_mulAdd( float16_t, float16_t, float16_t );
-float16_t f16_div( float16_t, float16_t );
-float16_t f16_rem( float16_t, float16_t );
-float16_t f16_sqrt( float16_t );
-bool f16_eq( float16_t, float16_t );
-bool f16_le( float16_t, float16_t );
-bool f16_lt( float16_t, float16_t );
-bool f16_eq_signaling( float16_t, float16_t );
-bool f16_le_quiet( float16_t, float16_t );
-bool f16_lt_quiet( float16_t, float16_t );
+void f16_to_extF80M( float16_t, extFloat80_t * STATE_PARAM );
+void f16_to_f128M( float16_t, float128_t * STATE_PARAM );
+float16_t f16_roundToInt( float16_t, uint_fast8_t, bool STATE_PARAM );
+float16_t f16_add( float16_t, float16_t STATE_PARAM );
+float16_t f16_sub( float16_t, float16_t STATE_PARAM );
+float16_t f16_mul( float16_t, float16_t STATE_PARAM );
+float16_t f16_mulAdd( float16_t, float16_t, float16_t STATE_PARAM );
+float16_t f16_div( float16_t, float16_t STATE_PARAM );
+float16_t f16_rem( float16_t, float16_t STATE_PARAM );
+float16_t f16_sqrt( float16_t STATE_PARAM );
+bool f16_eq( float16_t, float16_t STATE_PARAM );
+bool f16_le( float16_t, float16_t STATE_PARAM );
+bool f16_lt( float16_t, float16_t STATE_PARAM );
+bool f16_eq_signaling( float16_t, float16_t STATE_PARAM );
+bool f16_le_quiet( float16_t, float16_t STATE_PARAM );
+bool f16_lt_quiet( float16_t, float16_t STATE_PARAM );
 bool f16_isSignalingNaN( float16_t );
 
 /*----------------------------------------------------------------------------
 | 32-bit (single-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
-uint_fast32_t f32_to_ui32( float32_t, uint_fast8_t, bool );
-uint_fast64_t f32_to_ui64( float32_t, uint_fast8_t, bool );
-int_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool );
-int_fast64_t f32_to_i64( float32_t, uint_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 );
-float16_t f32_to_f16( float32_t );
-float64_t f32_to_f64( float32_t );
+uint_fast32_t f32_to_ui32( float32_t, uint_fast8_t, bool STATE_PARAM );
+uint_fast64_t f32_to_ui64( float32_t, uint_fast8_t, bool STATE_PARAM );
+int_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool STATE_PARAM );
+int_fast64_t f32_to_i64( float32_t, uint_fast8_t, bool STATE_PARAM );
+uint_fast32_t f32_to_ui32_r_minMag( float32_t, bool STATE_PARAM );
+uint_fast64_t f32_to_ui64_r_minMag( float32_t, bool STATE_PARAM );
+int_fast32_t f32_to_i32_r_minMag( float32_t, bool STATE_PARAM );
+int_fast64_t f32_to_i64_r_minMag( float32_t, bool STATE_PARAM );
+float16_t f32_to_f16( float32_t STATE_PARAM );
+float64_t f32_to_f64( float32_t STATE_PARAM );
 #ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t f32_to_extF80( float32_t );
-float128_t f32_to_f128( float32_t );
+extFloat80_t f32_to_extF80( float32_t STATE_PARAM );
+float128_t f32_to_f128( float32_t STATE_PARAM );
 #endif
-void f32_to_extF80M( float32_t, extFloat80_t * );
-void f32_to_f128M( float32_t, float128_t * );
-float32_t f32_roundToInt( float32_t, uint_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 );
+void f32_to_extF80M( float32_t, extFloat80_t * STATE_PARAM );
+void f32_to_f128M( float32_t, float128_t * STATE_PARAM );
+float32_t f32_roundToInt( float32_t, uint_fast8_t, bool STATE_PARAM );
+float32_t f32_add( float32_t, float32_t STATE_PARAM );
+float32_t f32_sub( float32_t, float32_t STATE_PARAM );
+float32_t f32_mul( float32_t, float32_t STATE_PARAM );
+float32_t f32_mulAdd( float32_t, float32_t, float32_t STATE_PARAM );
+float32_t f32_div( float32_t, float32_t STATE_PARAM );
+float32_t f32_rem( float32_t, float32_t STATE_PARAM );
+float32_t f32_sqrt( float32_t STATE_PARAM );
+bool f32_eq( float32_t, float32_t STATE_PARAM );
+bool f32_le( float32_t, float32_t STATE_PARAM );
+bool f32_lt( float32_t, float32_t STATE_PARAM );
+bool f32_eq_signaling( float32_t, float32_t STATE_PARAM );
+bool f32_le_quiet( float32_t, float32_t STATE_PARAM );
+bool f32_lt_quiet( float32_t, float32_t STATE_PARAM );
 bool f32_isSignalingNaN( float32_t );
 
 /*----------------------------------------------------------------------------
 | 64-bit (double-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
-uint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool );
-uint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool );
-int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool );
-int_fast64_t f64_to_i64( float64_t, uint_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 );
-float16_t f64_to_f16( float64_t );
-float32_t f64_to_f32( float64_t );
+uint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool STATE_PARAM );
+uint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool STATE_PARAM );
+int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool STATE_PARAM );
+int_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool STATE_PARAM );
+uint_fast32_t f64_to_ui32_r_minMag( float64_t, bool STATE_PARAM );
+uint_fast64_t f64_to_ui64_r_minMag( float64_t, bool STATE_PARAM );
+int_fast32_t f64_to_i32_r_minMag( float64_t, bool STATE_PARAM );
+int_fast64_t f64_to_i64_r_minMag( float64_t, bool STATE_PARAM );
+float16_t f64_to_f16( float64_t STATE_PARAM );
+float32_t f64_to_f32( float64_t STATE_PARAM );
 #ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t f64_to_extF80( float64_t );
-float128_t f64_to_f128( float64_t );
+extFloat80_t f64_to_extF80( float64_t STATE_PARAM );
+float128_t f64_to_f128( float64_t STATE_PARAM );
 #endif
-void f64_to_extF80M( float64_t, extFloat80_t * );
-void f64_to_f128M( float64_t, float128_t * );
-float64_t f64_roundToInt( float64_t, uint_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 );
+void f64_to_extF80M( float64_t, extFloat80_t * STATE_PARAM );
+void f64_to_f128M( float64_t, float128_t * STATE_PARAM );
+float64_t f64_roundToInt( float64_t, uint_fast8_t, bool STATE_PARAM );
+float64_t f64_add( float64_t, float64_t STATE_PARAM );
+float64_t f64_sub( float64_t, float64_t STATE_PARAM );
+float64_t f64_mul( float64_t, float64_t STATE_PARAM );
+float64_t f64_mulAdd( float64_t, float64_t, float64_t STATE_PARAM );
+float64_t f64_div( float64_t, float64_t STATE_PARAM );
+float64_t f64_rem( float64_t, float64_t STATE_PARAM );
+float64_t f64_sqrt( float64_t STATE_PARAM );
+bool f64_eq( float64_t, float64_t STATE_PARAM );
+bool f64_le( float64_t, float64_t STATE_PARAM );
+bool f64_lt( float64_t, float64_t STATE_PARAM );
+bool f64_eq_signaling( float64_t, float64_t STATE_PARAM );
+bool f64_le_quiet( float64_t, float64_t STATE_PARAM );
+bool f64_lt_quiet( float64_t, float64_t STATE_PARAM );
 bool f64_isSignalingNaN( float64_t );
 
 /*----------------------------------------------------------------------------
 | Rounding precision for 80-bit extended double-precision floating-point.
 | Valid values are 32, 64, and 80.
 *----------------------------------------------------------------------------*/
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
 extern THREAD_LOCAL uint_fast8_t extF80_roundingPrecision;
+#endif
 
 /*----------------------------------------------------------------------------
 | 80-bit extended double-precision floating-point operations.
 *----------------------------------------------------------------------------*/
 #ifdef SOFTFLOAT_FAST_INT64
-uint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool );
-uint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool );
-int_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool );
-int_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool );
-uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool );
-uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool );
-int_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool );
-int_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool );
-float16_t extF80_to_f16( extFloat80_t );
-float32_t extF80_to_f32( extFloat80_t );
-float64_t extF80_to_f64( extFloat80_t );
-float128_t extF80_to_f128( extFloat80_t );
-extFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool );
-extFloat80_t extF80_add( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_sub( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_mul( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_div( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_rem( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_sqrt( extFloat80_t );
-bool extF80_eq( extFloat80_t, extFloat80_t );
-bool extF80_le( extFloat80_t, extFloat80_t );
-bool extF80_lt( extFloat80_t, extFloat80_t );
-bool extF80_eq_signaling( extFloat80_t, extFloat80_t );
-bool extF80_le_quiet( extFloat80_t, extFloat80_t );
-bool extF80_lt_quiet( extFloat80_t, extFloat80_t );
+uint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool STATE_PARAM );
+uint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool STATE_PARAM );
+int_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool STATE_PARAM );
+int_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool STATE_PARAM );
+uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool STATE_PARAM );
+uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool STATE_PARAM );
+int_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool STATE_PARAM );
+int_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool STATE_PARAM );
+float16_t extF80_to_f16( extFloat80_t STATE_PARAM );
+float32_t extF80_to_f32( extFloat80_t STATE_PARAM );
+float64_t extF80_to_f64( extFloat80_t STATE_PARAM );
+float128_t extF80_to_f128( extFloat80_t STATE_PARAM );
+extFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool STATE_PARAM );
+extFloat80_t extF80_add( extFloat80_t, extFloat80_t STATE_PARAM );
+extFloat80_t extF80_sub( extFloat80_t, extFloat80_t STATE_PARAM );
+extFloat80_t extF80_mul( extFloat80_t, extFloat80_t STATE_PARAM );
+extFloat80_t extF80_div( extFloat80_t, extFloat80_t STATE_PARAM );
+extFloat80_t extF80_rem( extFloat80_t, extFloat80_t STATE_PARAM );
+extFloat80_t extF80_sqrt( extFloat80_t STATE_PARAM );
+bool extF80_eq( extFloat80_t, extFloat80_t STATE_PARAM );
+bool extF80_le( extFloat80_t, extFloat80_t STATE_PARAM );
+bool extF80_lt( extFloat80_t, extFloat80_t STATE_PARAM );
+bool extF80_eq_signaling( extFloat80_t, extFloat80_t STATE_PARAM );
+bool extF80_le_quiet( extFloat80_t, extFloat80_t STATE_PARAM );
+bool extF80_lt_quiet( extFloat80_t, extFloat80_t STATE_PARAM );
 bool extF80_isSignalingNaN( extFloat80_t );
 #endif
-uint_fast32_t extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool );
-uint_fast64_t extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool );
-int_fast32_t extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool );
-int_fast64_t extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool );
-uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *, bool );
-uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *, bool );
-int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool );
-int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool );
-float16_t extF80M_to_f16( const extFloat80_t * );
-float32_t extF80M_to_f32( const extFloat80_t * );
-float64_t extF80M_to_f64( const extFloat80_t * );
-void extF80M_to_f128M( const extFloat80_t *, float128_t * );
+uint_fast32_t extF80M_to_ui32(
+    const extFloat80_t *, uint_fast8_t, bool STATE_PARAM );
+uint_fast64_t extF80M_to_ui64(
+    const extFloat80_t *, uint_fast8_t, bool STATE_PARAM );
+int_fast32_t extF80M_to_i32(
+    const extFloat80_t *, uint_fast8_t, bool STATE_PARAM );
+int_fast64_t extF80M_to_i64(
+    const extFloat80_t *, uint_fast8_t, bool STATE_PARAM );
+uint_fast32_t extF80M_to_ui32_r_minMag(
+    const extFloat80_t *, bool STATE_PARAM );
+uint_fast64_t extF80M_to_ui64_r_minMag(
+    const extFloat80_t *, bool STATE_PARAM );
+int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool STATE_PARAM );
+int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool STATE_PARAM );
+float16_t extF80M_to_f16( const extFloat80_t * STATE_PARAM );
+float32_t extF80M_to_f32( const extFloat80_t * STATE_PARAM );
+float64_t extF80M_to_f64( const extFloat80_t * STATE_PARAM );
+void extF80M_to_f128M( const extFloat80_t *, float128_t * STATE_PARAM );
 void
  extF80M_roundToInt(
-     const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * );
-void extF80M_add( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_sub( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_mul( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_div( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_rem( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_sqrt( const extFloat80_t *, extFloat80_t * );
-bool extF80M_eq( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_le( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_lt( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * );
+     const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * STATE_PARAM );
+void extF80M_add(
+    const extFloat80_t *, const extFloat80_t *, extFloat80_t * STATE_PARAM );
+void extF80M_sub(
+    const extFloat80_t *, const extFloat80_t *, extFloat80_t * STATE_PARAM);
+void extF80M_mul(
+    const extFloat80_t *, const extFloat80_t *, extFloat80_t * STATE_PARAM );
+void extF80M_div(
+    const extFloat80_t *, const extFloat80_t *, extFloat80_t * STATE_PARAM );
+void extF80M_rem(
+    const extFloat80_t *, const extFloat80_t *, extFloat80_t * STATE_PARAM );
+void extF80M_sqrt( const extFloat80_t *, extFloat80_t * STATE_PARAM );
+bool extF80M_eq( const extFloat80_t *, const extFloat80_t * STATE_PARAM );
+bool extF80M_le( const extFloat80_t *, const extFloat80_t * STATE_PARAM );
+bool extF80M_lt( const extFloat80_t *, const extFloat80_t * STATE_PARAM );
+bool extF80M_eq_signaling(
+    const extFloat80_t *, const extFloat80_t * STATE_PARAM );
+bool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * STATE_PARAM );
+bool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * STATE_PARAM );
 bool extF80M_isSignalingNaN( const extFloat80_t * );
 
 /*----------------------------------------------------------------------------
 | 128-bit (quadruple-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
 #ifdef SOFTFLOAT_FAST_INT64
-uint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool );
-uint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool );
-int_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool );
-int_fast64_t f128_to_i64( float128_t, uint_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 );
-float16_t f128_to_f16( float128_t );
-float32_t f128_to_f32( float128_t );
-float64_t f128_to_f64( float128_t );
-extFloat80_t f128_to_extF80( float128_t );
-float128_t f128_roundToInt( float128_t, uint_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 );
+uint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool STATE_PARAM );
+uint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool STATE_PARAM );
+int_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool STATE_PARAM );
+int_fast64_t f128_to_i64( float128_t, uint_fast8_t, bool STATE_PARAM );
+uint_fast32_t f128_to_ui32_r_minMag( float128_t, bool STATE_PARAM );
+uint_fast64_t f128_to_ui64_r_minMag( float128_t, bool STATE_PARAM );
+int_fast32_t f128_to_i32_r_minMag( float128_t, bool STATE_PARAM );
+int_fast64_t f128_to_i64_r_minMag( float128_t, bool STATE_PARAM );
+float16_t f128_to_f16( float128_t STATE_PARAM );
+float32_t f128_to_f32( float128_t STATE_PARAM );
+float64_t f128_to_f64( float128_t STATE_PARAM );
+extFloat80_t f128_to_extF80( float128_t STATE_PARAM );
+float128_t f128_roundToInt( float128_t, uint_fast8_t, bool STATE_PARAM );
+float128_t f128_add( float128_t, float128_t STATE_PARAM );
+float128_t f128_sub( float128_t, float128_t STATE_PARAM );
+float128_t f128_mul( float128_t, float128_t STATE_PARAM );
+float128_t f128_mulAdd( float128_t, float128_t, float128_t STATE_PARAM );
+float128_t f128_div( float128_t, float128_t STATE_PARAM );
+float128_t f128_rem( float128_t, float128_t STATE_PARAM );
+float128_t f128_sqrt( float128_t STATE_PARAM );
+bool f128_eq( float128_t, float128_t STATE_PARAM );
+bool f128_le( float128_t, float128_t STATE_PARAM );
+bool f128_lt( float128_t, float128_t STATE_PARAM );
+bool f128_eq_signaling( float128_t, float128_t STATE_PARAM );
+bool f128_le_quiet( float128_t, float128_t STATE_PARAM );
+bool f128_lt_quiet( float128_t, float128_t STATE_PARAM );
 bool f128_isSignalingNaN( float128_t );
 #endif
-uint_fast32_t f128M_to_ui32( const float128_t *, uint_fast8_t, bool );
-uint_fast64_t f128M_to_ui64( const float128_t *, uint_fast8_t, bool );
-int_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool );
-int_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool );
-uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool );
-uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool );
-int_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool );
-int_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool );
-float16_t f128M_to_f16( const float128_t * );
-float32_t f128M_to_f32( const float128_t * );
-float64_t f128M_to_f64( const float128_t * );
-void f128M_to_extF80M( const float128_t *, extFloat80_t * );
-void f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * );
-void f128M_add( const float128_t *, const float128_t *, float128_t * );
-void f128M_sub( const float128_t *, const float128_t *, float128_t * );
-void f128M_mul( const float128_t *, const float128_t *, float128_t * );
+uint_fast32_t f128M_to_ui32(
+    const float128_t *, uint_fast8_t, bool STATE_PARAM );
+uint_fast64_t f128M_to_ui64(
+    const float128_t *, uint_fast8_t, bool STATE_PARAM );
+int_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool STATE_PARAM );
+int_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool STATE_PARAM );
+uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool STATE_PARAM );
+uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool STATE_PARAM );
+int_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool STATE_PARAM );
+int_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool STATE_PARAM );
+float16_t f128M_to_f16( const float128_t * STATE_PARAM );
+float32_t f128M_to_f32( const float128_t * STATE_PARAM );
+float64_t f128M_to_f64( const float128_t * STATE_PARAM );
+void f128M_to_extF80M( const float128_t *, extFloat80_t * STATE_PARAM );
+void f128M_roundToInt(
+    const float128_t *, uint_fast8_t, bool, float128_t * STATE_PARAM );
+void f128M_add(
+    const float128_t *, const float128_t *, float128_t * STATE_PARAM );
+void f128M_sub(
+    const float128_t *, const float128_t *, float128_t * STATE_PARAM );
+void f128M_mul(
+    const float128_t *, const float128_t *, float128_t * STATE_PARAM );
 void
  f128M_mulAdd(
      const float128_t *, const float128_t *, const float128_t *, float128_t *
- );
-void f128M_div( const float128_t *, const float128_t *, float128_t * );
-void f128M_rem( const float128_t *, const float128_t *, float128_t * );
-void f128M_sqrt( const float128_t *, float128_t * );
-bool f128M_eq( const float128_t *, const float128_t * );
-bool f128M_le( const float128_t *, const float128_t * );
-bool f128M_lt( const float128_t *, const float128_t * );
-bool f128M_eq_signaling( const float128_t *, const float128_t * );
-bool f128M_le_quiet( const float128_t *, const float128_t * );
-bool f128M_lt_quiet( const float128_t *, const float128_t * );
+     STATE_PARAM );
+void f128M_div(
+    const float128_t *, const float128_t *, float128_t * STATE_PARAM );
+void f128M_rem(
+    const float128_t *, const float128_t *, float128_t * STATE_PARAM );
+void f128M_sqrt( const float128_t *, float128_t * STATE_PARAM );
+bool f128M_eq( const float128_t *, const float128_t * STATE_PARAM );
+bool f128M_le( const float128_t *, const float128_t * STATE_PARAM );
+bool f128M_lt( const float128_t *, const float128_t * STATE_PARAM );
+bool f128M_eq_signaling( const float128_t *, const float128_t * STATE_PARAM );
+bool f128M_le_quiet( const float128_t *, const float128_t * STATE_PARAM );
+bool f128M_lt_quiet( const float128_t *, const float128_t * STATE_PARAM );
 bool f128M_isSignalingNaN( const float128_t * );
 
 #endif
diff --git a/source/include/softfloat_types.h b/source/include/softfloat_types.h
index b92d2462..5123759b 100644
--- a/source/include/softfloat_types.h
+++ b/source/include/softfloat_types.h
@@ -39,6 +39,26 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <stdint.h>
 
+// Uncomment the following line to use global state
+//#define SOFTFLOAT_USE_GLOBAL_STATE
+
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
+
+// Use global state
+#define STATE_PARAM
+#define STATE_VAR
+#define STATE(field)          softfloat_ ## field
+
+#else
+
+// No global state
+#define STATE_PARAM           , softfloat_state_t *state
+#define STATE_VAR             , state
+#define STATE(field)          state->field
+
+#endif
+
+
 /*----------------------------------------------------------------------------
 | Types used to pass 16-bit, 32-bit, 64-bit, and 128-bit floating-point
 | arguments and results to/from functions.  These types must be exactly
@@ -77,5 +97,15 @@ struct extFloat80M { uint16_t signExp; uint64_t signif; };
 *----------------------------------------------------------------------------*/
 typedef struct extFloat80M extFloat80_t;
 
+/*----------------------------------------------------------------------------
+| State struct. Used when USE_GLOBAL_STATE is defined
+*----------------------------------------------------------------------------*/
+typedef struct {
+    uint_fast8_t detectTininess;
+    uint_fast8_t roundingMode;
+    uint_fast8_t exceptionFlags;
+    uint_fast8_t extF80_roundingPrecision;
+} softfloat_state_t;
+
 #endif
 
diff --git a/source/s_addExtF80M.c b/source/s_addExtF80M.c
index f0142905..0d3808c3 100644
--- a/source/s_addExtF80M.c
+++ b/source/s_addExtF80M.c
@@ -47,6 +47,7 @@ void
      const struct extFloat80M *bSPtr,
      struct extFloat80M *zSPtr,
      bool negateB
+     STATE_PARAM
  )
 {
     uint32_t uiA64;
@@ -59,7 +60,8 @@ void
     uint64_t sigZ, sigB;
     void
      (*roundPackRoutinePtr)(
-         bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
+         bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M *
+         STATE_VAR );
     int32_t expDiff;
     uint32_t extSigX[3], sigZExtra;
 
@@ -77,7 +79,7 @@ void
         if ( expB == 0x7FFF ) {
             uiZ64 = uiB64 ^ packToExtF80UI64( negateB, 0 );
             if ( (expA == 0x7FFF) && (uiZ64 != uiA64) ) {
-                softfloat_invalidExtF80M( zSPtr );
+                softfloat_invalidExtF80M( zSPtr STATE_VAR );
                 return;
             }
         }
@@ -151,7 +153,7 @@ void
             } else {
                 sigZ -= sigB;
                 if ( ! sigZ ) {
-                    signZ = (softfloat_roundingMode == softfloat_round_min);
+                    signZ = (STATE(roundingMode) == softfloat_round_min);
                     zSPtr->signExp = packToExtF80UI64( signZ, 0 );
                     zSPtr->signif = 0;
                     return;
@@ -180,7 +182,13 @@ void
     *------------------------------------------------------------------------*/
  roundPack:
     (*roundPackRoutinePtr)(
-        signZ, expA, extSigX, extF80_roundingPrecision, zSPtr );
+        signZ, expA, extSigX,
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
+        extF80_roundingPrecision,
+#else
+        state->extF80_roundingPrecision,
+#endif
+        zSPtr );
 
 }
 
diff --git a/source/s_addF128M.c b/source/s_addF128M.c
index c5fcf704..c7578501 100644
--- a/source/s_addF128M.c
+++ b/source/s_addF128M.c
@@ -47,6 +47,7 @@ void
      const uint32_t *bWPtr,
      uint32_t *zWPtr,
      bool negateB
+     STATE_PARAM
  )
 {
     uint32_t uiA96;
@@ -84,7 +85,7 @@ void
         if ( expB == 0x7FFF ) {
             uiZ96 = uiB96 ^ packToF128UI96( negateB, 0, 0 );
             if ( (expA == 0x7FFF) && (uiZ96 != uiA96) ) {
-                softfloat_invalidF128M( zWPtr );
+                softfloat_invalidF128M( zWPtr STATE_VAR );
                 return;
             }
         }
@@ -182,7 +183,7 @@ void
                               | extSigZ[indexWord( 5, 0 )]
                              )
                 ) {
-                    signZ = (softfloat_roundingMode == softfloat_round_min);
+                    signZ = (STATE(roundingMode) == softfloat_round_min);
                     zWPtr[indexWordHi( 4 )] = packToF128UI96( signZ, 0, 0 );
                     zWPtr[indexWord( 4, 2 )] = 0;
                     zWPtr[indexWord( 4, 1 )] = 0;
diff --git a/source/s_addMagsExtF80.c b/source/s_addMagsExtF80.c
index 6e7d1a6f..dd77d2b4 100644
--- a/source/s_addMagsExtF80.c
+++ b/source/s_addMagsExtF80.c
@@ -48,6 +48,7 @@ extFloat80_t
      uint_fast16_t uiB64,
      uint_fast64_t uiB0,
      bool signZ
+     STATE_PARAM
  )
 {
     int_fast32_t expA;
@@ -140,11 +141,17 @@ extFloat80_t
  roundAndPack:
     return
         softfloat_roundPackToExtF80(
-            signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
+            signZ, expZ, sigZ, sigZExtra,
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
+            extF80_roundingPrecision
+#else
+            state->extF80_roundingPrecision
+#endif
+            STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 STATE_VAR );
     uiZ64 = uiZ.v64;
     uiZ0  = uiZ.v0;
  uiZ:
diff --git a/source/s_addMagsF128.c b/source/s_addMagsF128.c
index da8e8882..83d2307d 100644
--- a/source/s_addMagsF128.c
+++ b/source/s_addMagsF128.c
@@ -47,6 +47,7 @@ float128_t
      uint_fast64_t uiB64,
      uint_fast64_t uiB0,
      bool signZ
+     STATE_PARAM
  )
 {
     int_fast32_t expA;
@@ -143,9 +144,10 @@ float128_t
     sigZExtra = sig128Extra.extra;
  roundAndPack:
     return
-        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
+        softfloat_roundPackToF128(
+            signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra STATE_VAR );
  propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 STATE_VAR );
  uiZ:
     uZ.ui = uiZ;
     return uZ.f;
diff --git a/source/s_addMagsF16.c b/source/s_addMagsF16.c
index abc42b8a..1c435a84 100644
--- a/source/s_addMagsF16.c
+++ b/source/s_addMagsF16.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
+float16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB
+                                STATE_PARAM )
 {
     int_fast8_t expA;
     uint_fast16_t sigA;
@@ -141,16 +142,16 @@ float16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
             }
         }
     }
-    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    return softfloat_roundPackToF16( signZ, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  addEpsilon:
-    roundingMode = softfloat_roundingMode;
+    roundingMode = STATE(roundingMode);
     if ( roundingMode != softfloat_round_near_even ) {
         if (
             roundingMode
@@ -160,7 +161,7 @@ float16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
             ++uiZ;
             if ( (uint16_t) (uiZ<<1) == 0xF800 ) {
                 softfloat_raiseFlags(
-                    softfloat_flag_overflow | softfloat_flag_inexact );
+                    softfloat_flag_overflow | softfloat_flag_inexact STATE_VAR);
             }
         }
 #ifdef SOFTFLOAT_ROUND_ODD
@@ -169,7 +170,7 @@ float16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
         }
 #endif
     }
-    softfloat_exceptionFlags |= softfloat_flag_inexact;
+    softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
diff --git a/source/s_addMagsF32.c b/source/s_addMagsF32.c
index ed85bb00..4eedf727 100644
--- a/source/s_addMagsF32.c
+++ b/source/s_addMagsF32.c
@@ -40,7 +40,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "specialize.h"
 
-float32_t softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
+float32_t softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB
+                                STATE_PARAM )
 {
     int_fast16_t expA;
     uint_fast32_t sigA;
@@ -113,11 +114,11 @@ float32_t softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
             sigZ <<= 1;
         }
     }
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
+    return softfloat_roundPackToF32( signZ, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB STATE_VAR );
  uiZ:
     uZ.ui = uiZ;
     return uZ.f;
diff --git a/source/s_addMagsF64.c b/source/s_addMagsF64.c
index 25b8f386..2ec5dc3b 100644
--- a/source/s_addMagsF64.c
+++ b/source/s_addMagsF64.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 
 float64_t
- softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )
+ softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ
+                       STATE_PARAM )
 {
     int_fast16_t expA;
     uint_fast64_t sigA;
@@ -115,11 +116,11 @@ float64_t
             sigZ <<= 1;
         }
     }
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
+    return softfloat_roundPackToF64( signZ, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB STATE_VAR );
  uiZ:
     uZ.ui = uiZ;
     return uZ.f;
diff --git a/source/s_invalidExtF80M.c b/source/s_invalidExtF80M.c
index d3304786..75c1468d 100644
--- a/source/s_invalidExtF80M.c
+++ b/source/s_invalidExtF80M.c
@@ -38,10 +38,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-void softfloat_invalidExtF80M( struct extFloat80M *zSPtr )
+void softfloat_invalidExtF80M( struct extFloat80M *zSPtr STATE_PARAM )
 {
 
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     zSPtr->signExp = defaultNaNExtF80UI64;
     zSPtr->signif  = defaultNaNExtF80UI0;
 
diff --git a/source/s_invalidF128M.c b/source/s_invalidF128M.c
index ee63cc3b..4310e659 100644
--- a/source/s_invalidF128M.c
+++ b/source/s_invalidF128M.c
@@ -40,10 +40,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-void softfloat_invalidF128M( uint32_t *zWPtr )
+void softfloat_invalidF128M( uint32_t *zWPtr STATE_PARAM )
 {
 
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
     zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
     zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
diff --git a/source/s_mulAddF128.c b/source/s_mulAddF128.c
index 9b98b9f6..392ce9d5 100644
--- a/source/s_mulAddF128.c
+++ b/source/s_mulAddF128.c
@@ -50,6 +50,7 @@ float128_t
      uint_fast64_t uiC64,
      uint_fast64_t uiC0,
      uint_fast8_t op
+     STATE_PARAM
  )
 {
     bool signA;
@@ -308,11 +309,11 @@ float128_t
  roundPack:
     return
         softfloat_roundPackToF128(
-            signZ, expZ - 1, sigZ.v64, sigZ.v0, sigZExtra );
+            signZ, expZ - 1, sigZ.v64, sigZ.v0, sigZExtra STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 STATE_VAR );
     goto propagateNaN_ZC;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
@@ -324,11 +325,11 @@ float128_t
         if ( sigC.v64 | sigC.v0 ) goto propagateNaN_ZC;
         if ( signZ == signC ) goto uiZ;
     }
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ.v64 = defaultNaNF128UI64;
     uiZ.v0  = defaultNaNF128UI0;
  propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF128UI( uiZ.v64, uiZ.v0, uiC64, uiC0 );
+    uiZ = softfloat_propagateNaNF128UI( uiZ.v64, uiZ.v0, uiC64, uiC0 STATE_VAR);
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
@@ -339,7 +340,7 @@ float128_t
  completeCancellation:
         uiZ.v64 =
             packToF128UI64(
-                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+                (STATE(roundingMode) == softfloat_round_min), 0, 0 );
         uiZ.v0 = 0;
     }
  uiZ:
diff --git a/source/s_mulAddF128M.c b/source/s_mulAddF128M.c
index 3ed3bae4..d9b8b511 100644
--- a/source/s_mulAddF128M.c
+++ b/source/s_mulAddF128M.c
@@ -48,6 +48,7 @@ void
      const uint32_t *cWPtr,
      uint32_t *zWPtr,
      uint_fast8_t op
+     STATE_PARAM
  )
 {
     uint32_t uiA96;
@@ -333,12 +334,12 @@ void
  roundPack:
     roundPackRoutinePtr = softfloat_roundPackMToF128M;
  doRoundPack:
-    (*roundPackRoutinePtr)( signZ, expZ, extSigPtr, zWPtr );
+    (*roundPackRoutinePtr)( signZ, expZ, extSigPtr, zWPtr STATE_VAR );
     return;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_invalidF128M( zWPtr );
+    softfloat_invalidF128M( zWPtr STATE_VAR );
  propagateNaN_ZC:
     softfloat_propagateNaNF128M( zWPtr, cWPtr, zWPtr );
     return;
@@ -371,7 +372,7 @@ void
  completeCancellation:
     uiZ96 =
         packToF128UI96(
-            (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+            (STATE(roundingMode) == softfloat_round_min), 0, 0 );
  uiZ:
     zWPtr[indexWordHi( 4 )] = uiZ96;
     zWPtr[indexWord( 4, 2 )] = 0;
diff --git a/source/s_mulAddF16.c b/source/s_mulAddF16.c
index cca4db42..9007725f 100644
--- a/source/s_mulAddF16.c
+++ b/source/s_mulAddF16.c
@@ -43,7 +43,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 float16_t
  softfloat_mulAddF16(
-     uint_fast16_t uiA, uint_fast16_t uiB, uint_fast16_t uiC, uint_fast8_t op )
+     uint_fast16_t uiA, uint_fast16_t uiB, uint_fast16_t uiC, uint_fast8_t op
+     STATE_PARAM )
 {
     bool signA;
     int_fast8_t expA;
@@ -188,11 +189,11 @@ float16_t
         }
     }
  roundPack:
-    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    return softfloat_roundPackToF16( signZ, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB STATE_VAR );
     goto propagateNaN_ZC;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
@@ -203,10 +204,10 @@ float16_t
         if ( sigC ) goto propagateNaN_ZC;
         if ( signProd == signC ) goto uiZ;
     }
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ = defaultNaNF16UI;
  propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF16UI( uiZ, uiC );
+    uiZ = softfloat_propagateNaNF16UI( uiZ, uiC STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
@@ -216,7 +217,7 @@ float16_t
  completeCancellation:
         uiZ =
             packToF16UI(
-                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+                (STATE(roundingMode) == softfloat_round_min), 0, 0 );
     }
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/s_mulAddF32.c b/source/s_mulAddF32.c
index 805517c5..e9f327e3 100644
--- a/source/s_mulAddF32.c
+++ b/source/s_mulAddF32.c
@@ -43,7 +43,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 float32_t
  softfloat_mulAddF32(
-     uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC, uint_fast8_t op )
+     uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC, uint_fast8_t op
+     STATE_PARAM )
 {
     bool signA;
     int_fast16_t expA;
@@ -186,11 +187,11 @@ float32_t
         }
     }
  roundPack:
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
+    return softfloat_roundPackToF32( signZ, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB STATE_VAR );
     goto propagateNaN_ZC;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
@@ -201,10 +202,10 @@ float32_t
         if ( sigC ) goto propagateNaN_ZC;
         if ( signProd == signC ) goto uiZ;
     }
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ = defaultNaNF32UI;
  propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF32UI( uiZ, uiC );
+    uiZ = softfloat_propagateNaNF32UI( uiZ, uiC STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
@@ -214,7 +215,7 @@ float32_t
  completeCancellation:
         uiZ =
             packToF32UI(
-                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+                (STATE(roundingMode) == softfloat_round_min), 0, 0 );
     }
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/s_mulAddF64.c b/source/s_mulAddF64.c
index cc1df45d..c019ee58 100644
--- a/source/s_mulAddF64.c
+++ b/source/s_mulAddF64.c
@@ -45,7 +45,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 float64_t
  softfloat_mulAddF64(
-     uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op )
+     uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op
+     STATE_PARAM )
 {
     bool signA;
     int_fast16_t expA;
@@ -205,11 +206,11 @@ float64_t
         sigZ |= (sig128Z.v0 != 0);
     }
  roundPack:
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
+    return softfloat_roundPackToF64( signZ, expZ, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB STATE_VAR );
     goto propagateNaN_ZC;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
@@ -220,10 +221,10 @@ float64_t
         if ( sigC ) goto propagateNaN_ZC;
         if ( signZ == signC ) goto uiZ;
     }
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ = defaultNaNF64UI;
  propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );
+    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
@@ -233,7 +234,7 @@ float64_t
  completeCancellation:
         uiZ =
             packToF64UI(
-                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+                (STATE(roundingMode) == softfloat_round_min), 0, 0 );
     }
  uiZ:
     uZ.ui = uiZ;
@@ -456,11 +457,11 @@ float64_t
  sigZ:
     if ( sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )] ) sigZ |= 1;
  roundPack:
-    return softfloat_roundPackToF64( signZ, expZ - 1, sigZ );
+    return softfloat_roundPackToF64( signZ, expZ - 1, sigZ STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB STATE_VAR );
     goto propagateNaN_ZC;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
@@ -471,10 +472,10 @@ float64_t
         if ( sigC ) goto propagateNaN_ZC;
         if ( signZ == signC ) goto uiZ;
     }
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     uiZ = defaultNaNF64UI;
  propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );
+    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
@@ -484,7 +485,7 @@ float64_t
  completeCancellation:
         uiZ =
             packToF64UI(
-                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+                (STATE(roundingMode) == softfloat_round_min), 0, 0 );
     }
  uiZ:
     uZ.ui = uiZ;
diff --git a/source/s_normRoundPackMToExtF80M.c b/source/s_normRoundPackMToExtF80M.c
index 2a8988f8..41c86fb0 100644
--- a/source/s_normRoundPackMToExtF80M.c
+++ b/source/s_normRoundPackMToExtF80M.c
@@ -46,6 +46,7 @@ void
      uint32_t *extSigPtr,
      uint_fast8_t roundingPrecision,
      struct extFloat80M *zSPtr
+     STATE_PARAM
  )
 {
     int_fast16_t shiftDist;
@@ -72,7 +73,7 @@ void
         softfloat_shiftLeft96M( extSigPtr, shiftDist, extSigPtr );
     }
     softfloat_roundPackMToExtF80M(
-        sign, exp, extSigPtr, roundingPrecision, zSPtr );
+        sign, exp, extSigPtr, roundingPrecision, zSPtr STATE_VAR );
 
 }
 
diff --git a/source/s_normRoundPackMToF128M.c b/source/s_normRoundPackMToF128M.c
index b15d160e..0cee1fd2 100644
--- a/source/s_normRoundPackMToF128M.c
+++ b/source/s_normRoundPackMToF128M.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 void
  softfloat_normRoundPackMToF128M(
-     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr )
+     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr STATE_PARAM )
 {
     const uint32_t *ptr;
     int_fast16_t shiftDist;
@@ -67,7 +67,7 @@ void
         exp -= shiftDist;
         softfloat_shiftLeft160M( extSigPtr, shiftDist, extSigPtr );
     }
-    softfloat_roundPackMToF128M( sign, exp, extSigPtr, zWPtr );
+    softfloat_roundPackMToF128M( sign, exp, extSigPtr, zWPtr STATE_VAR );
 
 }
 
diff --git a/source/s_normRoundPackToExtF80.c b/source/s_normRoundPackToExtF80.c
index 2518bf44..d057eea3 100644
--- a/source/s_normRoundPackToExtF80.c
+++ b/source/s_normRoundPackToExtF80.c
@@ -46,6 +46,7 @@ extFloat80_t
      uint_fast64_t sig,
      uint_fast64_t sigExtra,
      uint_fast8_t roundingPrecision
+     STATE_PARAM
  )
 {
     int_fast8_t shiftDist;
@@ -65,7 +66,7 @@ extFloat80_t
     }
     return
         softfloat_roundPackToExtF80(
-            sign, exp, sig, sigExtra, roundingPrecision );
+            sign, exp, sig, sigExtra, roundingPrecision STATE_VAR );
 
 }
 
diff --git a/source/s_normRoundPackToF128.c b/source/s_normRoundPackToF128.c
index 14cf28ea..30fffab3 100644
--- a/source/s_normRoundPackToF128.c
+++ b/source/s_normRoundPackToF128.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 float128_t
  softfloat_normRoundPackToF128(
-     bool sign, int_fast32_t exp, uint_fast64_t sig64, uint_fast64_t sig0 )
+     bool sign, int_fast32_t exp, uint_fast64_t sig64, uint_fast64_t sig0
+     STATE_PARAM )
 {
     int_fast8_t shiftDist;
     struct uint128 sig128;
@@ -75,7 +76,8 @@ float128_t
         sig0  = sig128Extra.v.v0;
         sigExtra = sig128Extra.extra;
     }
-    return softfloat_roundPackToF128( sign, exp, sig64, sig0, sigExtra );
+    return softfloat_roundPackToF128(
+        sign, exp, sig64, sig0, sigExtra STATE_VAR );
 
 }
 
diff --git a/source/s_normRoundPackToF16.c b/source/s_normRoundPackToF16.c
index 008c5f12..48ffa582 100644
--- a/source/s_normRoundPackToF16.c
+++ b/source/s_normRoundPackToF16.c
@@ -40,7 +40,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 
 float16_t
- softfloat_normRoundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig )
+ softfloat_normRoundPackToF16(
+     bool sign, int_fast16_t exp, uint_fast16_t sig STATE_PARAM )
 {
     int_fast8_t shiftDist;
     union ui16_f16 uZ;
@@ -51,7 +52,7 @@ float16_t
         uZ.ui = packToF16UI( sign, sig ? exp : 0, sig<<(shiftDist - 4) );
         return uZ.f;
     } else {
-        return softfloat_roundPackToF16( sign, exp, sig<<shiftDist );
+        return softfloat_roundPackToF16( sign, exp, sig<<shiftDist STATE_VAR );
     }
 
 }
diff --git a/source/s_normRoundPackToF32.c b/source/s_normRoundPackToF32.c
index 28df7376..642921f0 100644
--- a/source/s_normRoundPackToF32.c
+++ b/source/s_normRoundPackToF32.c
@@ -40,7 +40,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 
 float32_t
- softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )
+ softfloat_normRoundPackToF32(
+     bool sign, int_fast16_t exp, uint_fast32_t sig STATE_PARAM )
 {
     int_fast8_t shiftDist;
     union ui32_f32 uZ;
@@ -51,7 +52,7 @@ float32_t
         uZ.ui = packToF32UI( sign, sig ? exp : 0, sig<<(shiftDist - 7) );
         return uZ.f;
     } else {
-        return softfloat_roundPackToF32( sign, exp, sig<<shiftDist );
+        return softfloat_roundPackToF32( sign, exp, sig<<shiftDist STATE_VAR );
     }
 
 }
diff --git a/source/s_normRoundPackToF64.c b/source/s_normRoundPackToF64.c
index 8c19ad85..334abb5f 100644
--- a/source/s_normRoundPackToF64.c
+++ b/source/s_normRoundPackToF64.c
@@ -40,7 +40,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 
 float64_t
- softfloat_normRoundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )
+ softfloat_normRoundPackToF64(
+     bool sign, int_fast16_t exp, uint_fast64_t sig STATE_PARAM )
 {
     int_fast8_t shiftDist;
     union ui64_f64 uZ;
@@ -51,7 +52,7 @@ float64_t
         uZ.ui = packToF64UI( sign, sig ? exp : 0, sig<<(shiftDist - 10) );
         return uZ.f;
     } else {
-        return softfloat_roundPackToF64( sign, exp, sig<<shiftDist );
+        return softfloat_roundPackToF64( sign, exp, sig<<shiftDist STATE_VAR );
     }
 
 }
diff --git a/source/s_roundMToI64.c b/source/s_roundMToI64.c
index 557a532d..68b98f13 100644
--- a/source/s_roundMToI64.c
+++ b/source/s_roundMToI64.c
@@ -43,7 +43,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 int_fast64_t
  softfloat_roundMToI64(
-     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact )
+     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact
+     STATE_PARAM )
 {
     uint64_t sig;
     uint32_t sigExtra;
@@ -89,13 +90,13 @@ int_fast64_t
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) z |= 1;
 #endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return z;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return sign ? i64_fromNegOverflow : i64_fromPosOverflow;
 
 }
diff --git a/source/s_roundMToUI64.c b/source/s_roundMToUI64.c
index c9114745..2a9a04ca 100644
--- a/source/s_roundMToUI64.c
+++ b/source/s_roundMToUI64.c
@@ -43,7 +43,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 uint_fast64_t
  softfloat_roundMToUI64(
-     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact )
+     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact
+     STATE_PARAM )
 {
     uint64_t sig;
     uint32_t sigExtra;
@@ -85,13 +86,13 @@ uint_fast64_t
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) sig |= 1;
 #endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return sig;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
 
 }
diff --git a/source/s_roundPackMToExtF80M.c b/source/s_roundPackMToExtF80M.c
index e9d3c3b1..a5163b50 100644
--- a/source/s_roundPackMToExtF80M.c
+++ b/source/s_roundPackMToExtF80M.c
@@ -47,6 +47,7 @@ void
      uint32_t *extSigPtr,
      uint_fast8_t roundingPrecision,
      struct extFloat80M *zSPtr
+     STATE_PARAM
  )
 {
     uint_fast8_t roundingMode;
@@ -58,7 +59,7 @@ void
 
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
+    roundingMode = STATE(roundingMode);
     roundNearEven = (roundingMode == softfloat_round_near_even);
     sig =
         (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32
@@ -91,15 +92,16 @@ void
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             isTiny =
-                   (softfloat_detectTininess
+                   (STATE(detectTininess)
                         == softfloat_tininess_beforeRounding)
                 || (exp < 0)
                 || (sig <= (uint64_t) (sig + roundIncrement));
             sig = softfloat_shiftRightJam64( sig, 1 - exp );
             roundBits = sig & roundMask;
             if ( roundBits ) {
-                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
+                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow
+                                                    STATE_VAR );
+                softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
 #ifdef SOFTFLOAT_ROUND_ODD
                 if ( roundingMode == softfloat_round_odd ) {
                     sig |= roundMask + 1;
@@ -125,7 +127,7 @@ void
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( roundBits ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) {
             sig = (sig & ~roundMask) | (roundMask + 1);
@@ -162,7 +164,7 @@ void
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             isTiny =
-                   (softfloat_detectTininess
+                   (STATE(detectTininess)
                         == softfloat_tininess_beforeRounding)
                 || (exp < 0)
                 || ! doIncrement
@@ -174,8 +176,9 @@ void
                     | extSigPtr[indexWord( 3, 1 )];
             sigExtra = extSigPtr[indexWordLo( 3 )];
             if ( sigExtra ) {
-                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
+                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow
+                                                    STATE_VAR );
+                softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
 #ifdef SOFTFLOAT_ROUND_ODD
                 if ( roundingMode == softfloat_round_odd ) {
                     sig |= 1;
@@ -210,7 +213,7 @@ void
             roundMask = 0;
  overflow:
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact STATE_VAR );
             if (
                    roundNearEven
                 || (roundingMode == softfloat_round_near_maxMag)
@@ -229,7 +232,7 @@ void
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( sigExtra ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) {
             sig |= 1;
diff --git a/source/s_roundPackMToF128M.c b/source/s_roundPackMToF128M.c
index fad5d08d..83a8690f 100644
--- a/source/s_roundPackMToF128M.c
+++ b/source/s_roundPackMToF128M.c
@@ -42,7 +42,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 void
  softfloat_roundPackMToF128M(
-     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr )
+     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr STATE_PARAM)
 {
     uint_fast8_t roundingMode;
     bool roundNearEven;
@@ -54,7 +54,7 @@ void
 
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
+    roundingMode = STATE(roundingMode);
     roundNearEven = (roundingMode == softfloat_round_near_even);
     sigExtra = extSigPtr[indexWordLo( 5 )];
     doIncrement = (0x80000000 <= sigExtra);
@@ -71,7 +71,7 @@ void
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             isTiny =
-                   (softfloat_detectTininess
+                   (STATE(detectTininess)
                         == softfloat_tininess_beforeRounding)
                 || (exp < -1)
                 || ! doIncrement
@@ -82,7 +82,7 @@ void
             exp = 0;
             sigExtra = extSigPtr[indexWordLo( 5 )];
             if ( isTiny && sigExtra ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_raiseFlags( softfloat_flag_underflow STATE_VAR );
             }
             doIncrement = (0x80000000 <= sigExtra);
             if (
@@ -104,7 +104,7 @@ void
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact STATE_VAR );
             if (
                    roundNearEven
                 || (roundingMode == softfloat_round_near_maxMag)
@@ -128,7 +128,7 @@ void
     *------------------------------------------------------------------------*/
     uj = extSigPtr[indexWord( 5, 1 )];
     if ( sigExtra ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) {
             uj |= 1;
diff --git a/source/s_roundPackToExtF80.c b/source/s_roundPackToExtF80.c
index a5ea38c6..29d2ee26 100644
--- a/source/s_roundPackToExtF80.c
+++ b/source/s_roundPackToExtF80.c
@@ -47,6 +47,7 @@ extFloat80_t
      uint_fast64_t sig,
      uint_fast64_t sigExtra,
      uint_fast8_t roundingPrecision
+     STATE_PARAM
  )
 {
     uint_fast8_t roundingMode;
@@ -58,7 +59,7 @@ extFloat80_t
 
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
+    roundingMode = STATE(roundingMode);
     roundNearEven = (roundingMode == softfloat_round_near_even);
     if ( roundingPrecision == 80 ) goto precision80;
     if ( roundingPrecision == 64 ) {
@@ -86,15 +87,16 @@ extFloat80_t
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             isTiny =
-                   (softfloat_detectTininess
+                   (STATE(detectTininess)
                         == softfloat_tininess_beforeRounding)
                 || (exp < 0)
                 || (sig <= (uint64_t) (sig + roundIncrement));
             sig = softfloat_shiftRightJam64( sig, 1 - exp );
             roundBits = sig & roundMask;
             if ( roundBits ) {
-                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
+                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow
+                                                    STATE_VAR );
+                softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
 #ifdef SOFTFLOAT_ROUND_ODD
                 if ( roundingMode == softfloat_round_odd ) {
                     sig |= roundMask + 1;
@@ -120,7 +122,7 @@ extFloat80_t
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( roundBits ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) {
             sig = (sig & ~roundMask) | (roundMask + 1);
@@ -156,7 +158,7 @@ extFloat80_t
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             isTiny =
-                   (softfloat_detectTininess
+                   (STATE(detectTininess)
                         == softfloat_tininess_beforeRounding)
                 || (exp < 0)
                 || ! doIncrement
@@ -167,8 +169,9 @@ extFloat80_t
             sig = sig64Extra.v;
             sigExtra = sig64Extra.extra;
             if ( sigExtra ) {
-                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
+                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow
+                                                    STATE_VAR );
+                softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
 #ifdef SOFTFLOAT_ROUND_ODD
                 if ( roundingMode == softfloat_round_odd ) {
                     sig |= 1;
@@ -206,7 +209,7 @@ extFloat80_t
             roundMask = 0;
  overflow:
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact STATE_VAR );
             if (
                    roundNearEven
                 || (roundingMode == softfloat_round_near_maxMag)
@@ -225,7 +228,7 @@ extFloat80_t
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( sigExtra ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) {
             sig |= 1;
diff --git a/source/s_roundPackToF128.c b/source/s_roundPackToF128.c
index 6688c524..263144c5 100644
--- a/source/s_roundPackToF128.c
+++ b/source/s_roundPackToF128.c
@@ -47,6 +47,7 @@ float128_t
      uint_fast64_t sig64,
      uint_fast64_t sig0,
      uint_fast64_t sigExtra
+     STATE_PARAM
  )
 {
     uint_fast8_t roundingMode;
@@ -58,7 +59,7 @@ float128_t
 
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
+    roundingMode = STATE(roundingMode);
     roundNearEven = (roundingMode == softfloat_round_near_even);
     doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
     if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
@@ -74,7 +75,7 @@ float128_t
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             isTiny =
-                   (softfloat_detectTininess
+                   (STATE(detectTininess)
                         == softfloat_tininess_beforeRounding)
                 || (exp < -1)
                 || ! doIncrement
@@ -91,7 +92,7 @@ float128_t
             sigExtra = sig128Extra.extra;
             exp = 0;
             if ( isTiny && sigExtra ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_raiseFlags( softfloat_flag_underflow STATE_VAR );
             }
             doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
             if (
@@ -117,7 +118,7 @@ float128_t
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact STATE_VAR );
             if (
                    roundNearEven
                 || (roundingMode == softfloat_round_near_maxMag)
@@ -138,7 +139,7 @@ float128_t
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     if ( sigExtra ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR);
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) {
             sig0 |= 1;
diff --git a/source/s_roundPackToF16.c b/source/s_roundPackToF16.c
index 8d03d3b2..f658a960 100644
--- a/source/s_roundPackToF16.c
+++ b/source/s_roundPackToF16.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 
 float16_t
- softfloat_roundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig )
+ softfloat_roundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig
+                           STATE_PARAM )
 {
     uint_fast8_t roundingMode;
     bool roundNearEven;
@@ -52,7 +53,7 @@ float16_t
 
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
+    roundingMode = STATE(roundingMode);
     roundNearEven = (roundingMode == softfloat_round_near_even);
     roundIncrement = 0x8;
     if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
@@ -70,19 +71,19 @@ float16_t
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             isTiny =
-                (softfloat_detectTininess == softfloat_tininess_beforeRounding)
+                (STATE(detectTininess) == softfloat_tininess_beforeRounding)
                     || (exp < -1) || (sig + roundIncrement < 0x8000);
             sig = softfloat_shiftRightJam32( sig, -exp );
             exp = 0;
             roundBits = sig & 0xF;
             if ( isTiny && roundBits ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_raiseFlags( softfloat_flag_underflow STATE_VAR );
             }
         } else if ( (0x1D < exp) || (0x8000 <= sig + roundIncrement) ) {
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact STATE_VAR );
             uiZ = packToF16UI( sign, 0x1F, 0 ) - ! roundIncrement;
             goto uiZ;
         }
@@ -91,7 +92,7 @@ float16_t
     *------------------------------------------------------------------------*/
     sig = (sig + roundIncrement)>>4;
     if ( roundBits ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) {
             sig |= 1;
diff --git a/source/s_roundPackToF32.c b/source/s_roundPackToF32.c
index f1eb0c2a..5831ca7a 100644
--- a/source/s_roundPackToF32.c
+++ b/source/s_roundPackToF32.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 
 float32_t
- softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )
+ softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig
+                           STATE_PARAM )
 {
     uint_fast8_t roundingMode;
     bool roundNearEven;
@@ -52,7 +53,7 @@ float32_t
 
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
+    roundingMode = STATE(roundingMode);
     roundNearEven = (roundingMode == softfloat_round_near_even);
     roundIncrement = 0x40;
     if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
@@ -70,19 +71,19 @@ float32_t
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             isTiny =
-                (softfloat_detectTininess == softfloat_tininess_beforeRounding)
+                (STATE(detectTininess) == softfloat_tininess_beforeRounding)
                     || (exp < -1) || (sig + roundIncrement < 0x80000000);
             sig = softfloat_shiftRightJam32( sig, -exp );
             exp = 0;
             roundBits = sig & 0x7F;
             if ( isTiny && roundBits ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_raiseFlags( softfloat_flag_underflow STATE_VAR );
             }
         } else if ( (0xFD < exp) || (0x80000000 <= sig + roundIncrement) ) {
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact STATE_VAR );
             uiZ = packToF32UI( sign, 0xFF, 0 ) - ! roundIncrement;
             goto uiZ;
         }
@@ -91,7 +92,7 @@ float32_t
     *------------------------------------------------------------------------*/
     sig = (sig + roundIncrement)>>7;
     if ( roundBits ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) {
             sig |= 1;
diff --git a/source/s_roundPackToF64.c b/source/s_roundPackToF64.c
index 98c1639a..61ac79eb 100644
--- a/source/s_roundPackToF64.c
+++ b/source/s_roundPackToF64.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 
 float64_t
- softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )
+ softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig
+                           STATE_PARAM )
 {
     uint_fast8_t roundingMode;
     bool roundNearEven;
@@ -52,7 +53,7 @@ float64_t
 
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
+    roundingMode = STATE(roundingMode);
     roundNearEven = (roundingMode == softfloat_round_near_even);
     roundIncrement = 0x200;
     if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
@@ -70,14 +71,14 @@ float64_t
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             isTiny =
-                (softfloat_detectTininess == softfloat_tininess_beforeRounding)
+                (STATE(detectTininess) == softfloat_tininess_beforeRounding)
                     || (exp < -1)
                     || (sig + roundIncrement < UINT64_C( 0x8000000000000000 ));
             sig = softfloat_shiftRightJam64( sig, -exp );
             exp = 0;
             roundBits = sig & 0x3FF;
             if ( isTiny && roundBits ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_raiseFlags( softfloat_flag_underflow STATE_VAR );
             }
         } else if (
             (0x7FD < exp)
@@ -86,7 +87,7 @@ float64_t
             /*----------------------------------------------------------------
             *----------------------------------------------------------------*/
             softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
+                softfloat_flag_overflow | softfloat_flag_inexact STATE_VAR );
             uiZ = packToF64UI( sign, 0x7FF, 0 ) - ! roundIncrement;
             goto uiZ;
         }
@@ -95,7 +96,7 @@ float64_t
     *------------------------------------------------------------------------*/
     sig = (sig + roundIncrement)>>10;
     if ( roundBits ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
+        softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) {
             sig |= 1;
diff --git a/source/s_roundToI32.c b/source/s_roundToI32.c
index 1999dcf5..6b70f09b 100644
--- a/source/s_roundToI32.c
+++ b/source/s_roundToI32.c
@@ -43,7 +43,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 int_fast32_t
  softfloat_roundToI32(
-     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact )
+     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact
+     STATE_PARAM )
 {
     uint_fast16_t roundIncrement, roundBits;
     uint_fast32_t sig32;
@@ -58,7 +59,7 @@ int_fast32_t
             && (roundingMode != softfloat_round_near_even)
     ) {
         roundIncrement = 0;
-        if ( 
+        if (
             sign
                 ? (roundingMode == softfloat_round_min)
 #ifdef SOFTFLOAT_ROUND_ODD
@@ -85,13 +86,13 @@ int_fast32_t
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) z |= 1;
 #endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return z;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return sign ? i32_fromNegOverflow : i32_fromPosOverflow;
 
 }
diff --git a/source/s_roundToI64.c b/source/s_roundToI64.c
index d1e9d279..208bb92b 100644
--- a/source/s_roundToI64.c
+++ b/source/s_roundToI64.c
@@ -48,6 +48,7 @@ int_fast64_t
      uint_fast64_t sigExtra,
      uint_fast8_t roundingMode,
      bool exact
+     STATE_PARAM
  )
 {
     union { uint64_t ui; int64_t i; } uZ;
@@ -88,13 +89,13 @@ int_fast64_t
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) z |= 1;
 #endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return z;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return sign ? i64_fromNegOverflow : i64_fromPosOverflow;
 
 }
diff --git a/source/s_roundToUI32.c b/source/s_roundToUI32.c
index eaad69e7..504433f3 100644
--- a/source/s_roundToUI32.c
+++ b/source/s_roundToUI32.c
@@ -43,7 +43,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 uint_fast32_t
  softfloat_roundToUI32(
-     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact )
+     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact
+     STATE_PARAM )
 {
     uint_fast16_t roundIncrement, roundBits;
     uint_fast32_t z;
@@ -51,8 +52,8 @@ uint_fast32_t
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
     roundIncrement = 0x800;
-    if ( 
-        (roundingMode != softfloat_round_near_maxMag) 
+    if (
+        (roundingMode != softfloat_round_near_maxMag)
             && (roundingMode != softfloat_round_near_even)
     ) {
         roundIncrement = 0;
@@ -70,7 +71,7 @@ uint_fast32_t
     sig += roundIncrement;
     if ( sig & UINT64_C( 0xFFFFF00000000000 ) ) goto invalid;
     z = sig>>12;
-    if ( 
+    if (
         (roundBits == 0x800) && (roundingMode == softfloat_round_near_even)
     ) {
         z &= ~(uint_fast32_t) 1;
@@ -80,13 +81,13 @@ uint_fast32_t
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) z |= 1;
 #endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return z;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
 
 }
diff --git a/source/s_roundToUI64.c b/source/s_roundToUI64.c
index 0ba78a64..6e7e3110 100644
--- a/source/s_roundToUI64.c
+++ b/source/s_roundToUI64.c
@@ -48,6 +48,7 @@ uint_fast64_t
      uint_fast64_t sigExtra,
      uint_fast8_t roundingMode,
      bool exact
+     STATE_PARAM
  )
 {
 
@@ -70,7 +71,7 @@ uint_fast64_t
  increment:
                 ++sig;
                 if ( !sig ) goto invalid;
-                if ( 
+                if (
                     (sigExtra == UINT64_C( 0x8000000000000000 ))
                         && (roundingMode == softfloat_round_near_even)
                 ) {
@@ -84,13 +85,13 @@ uint_fast64_t
 #ifdef SOFTFLOAT_ROUND_ODD
         if ( roundingMode == softfloat_round_odd ) sig |= 1;
 #endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        if ( exact ) softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     }
     return sig;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
+    softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
     return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
 
 }
diff --git a/source/s_subMagsExtF80.c b/source/s_subMagsExtF80.c
index 86ffd9b8..23a304be 100644
--- a/source/s_subMagsExtF80.c
+++ b/source/s_subMagsExtF80.c
@@ -48,6 +48,7 @@ extFloat80_t
      uint_fast16_t uiB64,
      uint_fast64_t uiB0,
      bool signZ
+     STATE_PARAM
  )
 {
     int_fast32_t expA;
@@ -77,7 +78,7 @@ extFloat80_t
         if ( (sigA | sigB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
             goto propagateNaN;
         }
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         uiZ64 = defaultNaNExtF80UI64;
         uiZ0  = defaultNaNExtF80UI0;
         goto uiZ;
@@ -90,7 +91,7 @@ extFloat80_t
     if ( sigB < sigA ) goto aBigger;
     if ( sigA < sigB ) goto bBigger;
     uiZ64 =
-        packToExtF80UI64( (softfloat_roundingMode == softfloat_round_min), 0 );
+        packToExtF80UI64( (STATE(roundingMode) == softfloat_round_min), 0 );
     uiZ0 = 0;
     goto uiZ;
     /*------------------------------------------------------------------------
@@ -142,11 +143,17 @@ extFloat80_t
  normRoundPack:
     return
         softfloat_normRoundPackToExtF80(
-            signZ, expZ, sig128.v64, sig128.v0, extF80_roundingPrecision );
+            signZ, expZ, sig128.v64, sig128.v0,
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
+            extF80_roundingPrecision
+#else
+            state->extF80_roundingPrecision
+#endif
+            STATE_VAR );
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 STATE_VAR );
     uiZ64 = uiZ.v64;
     uiZ0  = uiZ.v0;
  uiZ:
diff --git a/source/s_subMagsF128.c b/source/s_subMagsF128.c
index 595ed7e8..7d550467 100644
--- a/source/s_subMagsF128.c
+++ b/source/s_subMagsF128.c
@@ -48,6 +48,7 @@ float128_t
      uint_fast64_t uiB64,
      uint_fast64_t uiB0,
      bool signZ
+     STATE_PARAM
  )
 {
     int_fast32_t expA;
@@ -71,7 +72,7 @@ float128_t
     if ( expDiff < 0 ) goto expBBigger;
     if ( expA == 0x7FFF ) {
         if ( sigA.v64 | sigA.v0 | sigB.v64 | sigB.v0 ) goto propagateNaN;
-        softfloat_raiseFlags( softfloat_flag_invalid );
+        softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
         uiZ.v64 = defaultNaNF128UI64;
         uiZ.v0  = defaultNaNF128UI0;
         goto uiZ;
@@ -84,7 +85,7 @@ float128_t
     if ( sigA.v0 < sigB.v0 ) goto bBigger;
     uiZ.v64 =
         packToF128UI64(
-            (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+            (STATE(roundingMode) == softfloat_round_min), 0, 0 );
     uiZ.v0 = 0;
     goto uiZ;
  expBBigger:
@@ -128,9 +129,10 @@ float128_t
  aBigger:
     sigZ = softfloat_sub128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 );
  normRoundPack:
-    return softfloat_normRoundPackToF128( signZ, expZ - 5, sigZ.v64, sigZ.v0 );
+    return softfloat_normRoundPackToF128(
+        signZ, expZ - 5, sigZ.v64, sigZ.v0 STATE_VAR );
  propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 STATE_VAR );
  uiZ:
     uZ.ui = uiZ;
     return uZ.f;
diff --git a/source/s_subMagsF16.c b/source/s_subMagsF16.c
index 6bbcb5c8..0cc0c516 100644
--- a/source/s_subMagsF16.c
+++ b/source/s_subMagsF16.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
+float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB
+                                STATE_PARAM )
 {
     int_fast8_t expA;
     uint_fast16_t sigA;
@@ -71,7 +72,7 @@ float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
         *--------------------------------------------------------------------*/
         if ( expA == 0x1F ) {
             if ( sigA | sigB ) goto propagateNaN;
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
             uiZ = defaultNaNF16UI;
             goto uiZ;
         }
@@ -79,7 +80,7 @@ float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
         if ( ! sigDiff ) {
             uiZ =
                 packToF16UI(
-                    (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+                    (STATE(roundingMode) == softfloat_round_min), 0, 0 );
             goto uiZ;
         }
         if ( expA ) --expA;
@@ -147,17 +148,17 @@ float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
                 goto pack;
             }
         }
-        return softfloat_roundPackToF16( signZ, expZ, sigZ );
+        return softfloat_roundPackToF16( signZ, expZ, sigZ STATE_VAR );
     }
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  subEpsilon:
-    roundingMode = softfloat_roundingMode;
+    roundingMode = STATE(roundingMode);
     if ( roundingMode != softfloat_round_near_even ) {
         if (
             (roundingMode == softfloat_round_minMag)
@@ -173,7 +174,7 @@ float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
         }
 #endif
     }
-    softfloat_exceptionFlags |= softfloat_flag_inexact;
+    softfloat_raiseFlags( softfloat_flag_inexact STATE_VAR );
     goto uiZ;
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
diff --git a/source/s_subMagsF32.c b/source/s_subMagsF32.c
index 8b3aee0d..b0162286 100644
--- a/source/s_subMagsF32.c
+++ b/source/s_subMagsF32.c
@@ -41,7 +41,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
+float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB
+                                STATE_PARAM )
 {
     int_fast16_t expA;
     uint_fast32_t sigA;
@@ -70,7 +71,7 @@ float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
         *--------------------------------------------------------------------*/
         if ( expA == 0xFF ) {
             if ( sigA | sigB ) goto propagateNaN;
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
             uiZ = defaultNaNF32UI;
             goto uiZ;
         }
@@ -78,7 +79,7 @@ float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
         if ( ! sigDiff ) {
             uiZ =
                 packToF32UI(
-                    (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+                    (STATE(roundingMode) == softfloat_round_min), 0, 0 );
             goto uiZ;
         }
         if ( expA ) --expA;
@@ -129,12 +130,13 @@ float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
         return
             softfloat_normRoundPackToF32(
                 signZ, expZ, sigX - softfloat_shiftRightJam32( sigY, expDiff )
+                STATE_VAR
             );
     }
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB STATE_VAR );
  uiZ:
     uZ.ui = uiZ;
     return uZ.f;
diff --git a/source/s_subMagsF64.c b/source/s_subMagsF64.c
index 3a4acb10..4a59759a 100644
--- a/source/s_subMagsF64.c
+++ b/source/s_subMagsF64.c
@@ -42,7 +42,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 
 float64_t
- softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )
+ softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ
+                       STATE_PARAM )
 {
     int_fast16_t expA;
     uint_fast64_t sigA;
@@ -70,7 +71,7 @@ float64_t
         *--------------------------------------------------------------------*/
         if ( expA == 0x7FF ) {
             if ( sigA | sigB ) goto propagateNaN;
-            softfloat_raiseFlags( softfloat_flag_invalid );
+            softfloat_raiseFlags( softfloat_flag_invalid STATE_VAR );
             uiZ = defaultNaNF64UI;
             goto uiZ;
         }
@@ -78,7 +79,7 @@ float64_t
         if ( ! sigDiff ) {
             uiZ =
                 packToF64UI(
-                    (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+                    (STATE(roundingMode) == softfloat_round_min), 0, 0 );
             goto uiZ;
         }
         if ( expA ) --expA;
@@ -127,12 +128,12 @@ float64_t
             expZ = expA;
             sigZ = sigA - sigB;
         }
-        return softfloat_normRoundPackToF64( signZ, expZ - 1, sigZ );
+        return softfloat_normRoundPackToF64( signZ, expZ - 1, sigZ STATE_VAR );
     }
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB STATE_VAR );
  uiZ:
     uZ.ui = uiZ;
     return uZ.f;
diff --git a/source/softfloat_state.c b/source/softfloat_state.c
index 277d76f9..1aaf31e8 100644
--- a/source/softfloat_state.c
+++ b/source/softfloat_state.c
@@ -40,6 +40,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
+#ifdef SOFTFLOAT_USE_GLOBAL_STATE
+
 #ifndef THREAD_LOCAL
 #define THREAD_LOCAL
 #endif
@@ -50,3 +52,13 @@ THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags = 0;
 
 THREAD_LOCAL uint_fast8_t extF80_roundingPrecision = 80;
 
+#endif
+
+void softfloat_init_state(softfloat_state_t * state)
+{
+    state->roundingMode = softfloat_round_near_even;
+    state->detectTininess = init_detectTininess;
+    state->exceptionFlags = 0;
+    state->extF80_roundingPrecision = 80;
+}
+
diff --git a/source/ui32_to_f16.c b/source/ui32_to_f16.c
index a923f223..133b4d5f 100644
--- a/source/ui32_to_f16.c
+++ b/source/ui32_to_f16.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float16_t ui32_to_f16( uint32_t a )
+float16_t ui32_to_f16( uint32_t a STATE_PARAM )
 {
     int_fast8_t shiftDist;
     union ui16_f16 u;
@@ -58,7 +58,7 @@ float16_t ui32_to_f16( uint32_t a )
             (shiftDist < 0)
                 ? a>>(-shiftDist) | ((uint32_t) (a<<(shiftDist & 31)) != 0)
                 : (uint_fast16_t) a<<shiftDist;
-        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig );
+        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig STATE_VAR );
     }
 
 }
diff --git a/source/ui32_to_f32.c b/source/ui32_to_f32.c
index e74ee7be..ed94c760 100644
--- a/source/ui32_to_f32.c
+++ b/source/ui32_to_f32.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float32_t ui32_to_f32( uint32_t a )
+float32_t ui32_to_f32( uint32_t a STATE_PARAM )
 {
     union ui32_f32 uZ;
 
@@ -48,9 +48,9 @@ float32_t ui32_to_f32( uint32_t a )
         return uZ.f;
     }
     if ( a & 0x80000000 ) {
-        return softfloat_roundPackToF32( 0, 0x9D, a>>1 | (a & 1) );
+        return softfloat_roundPackToF32( 0, 0x9D, a>>1 | (a & 1) STATE_VAR );
     } else {
-        return softfloat_normRoundPackToF32( 0, 0x9C, a );
+        return softfloat_normRoundPackToF32( 0, 0x9C, a STATE_VAR );
     }
 
 }
diff --git a/source/ui64_to_f16.c b/source/ui64_to_f16.c
index 9ff6e173..e91ee9fe 100644
--- a/source/ui64_to_f16.c
+++ b/source/ui64_to_f16.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float16_t ui64_to_f16( uint64_t a )
+float16_t ui64_to_f16( uint64_t a STATE_PARAM )
 {
     int_fast8_t shiftDist;
     union ui16_f16 u;
@@ -57,7 +57,7 @@ float16_t ui64_to_f16( uint64_t a )
         sig =
             (shiftDist < 0) ? softfloat_shortShiftRightJam64( a, -shiftDist )
                 : (uint_fast16_t) a<<shiftDist;
-        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig );
+        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig STATE_VAR );
     }
 
 }
diff --git a/source/ui64_to_f32.c b/source/ui64_to_f32.c
index 9065b92d..f2495165 100644
--- a/source/ui64_to_f32.c
+++ b/source/ui64_to_f32.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float32_t ui64_to_f32( uint64_t a )
+float32_t ui64_to_f32( uint64_t a STATE_PARAM )
 {
     int_fast8_t shiftDist;
     union ui32_f32 u;
@@ -57,7 +57,7 @@ float32_t ui64_to_f32( uint64_t a )
         sig =
             (shiftDist < 0) ? softfloat_shortShiftRightJam64( a, -shiftDist )
                 : (uint_fast32_t) a<<shiftDist;
-        return softfloat_roundPackToF32( 0, 0x9C - shiftDist, sig );
+        return softfloat_roundPackToF32( 0, 0x9C - shiftDist, sig STATE_VAR );
     }
 
 }
diff --git a/source/ui64_to_f64.c b/source/ui64_to_f64.c
index 4693086f..1b83d579 100644
--- a/source/ui64_to_f64.c
+++ b/source/ui64_to_f64.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float64_t ui64_to_f64( uint64_t a )
+float64_t ui64_to_f64( uint64_t a STATE_PARAM )
 {
     union ui64_f64 uZ;
 
@@ -50,9 +50,9 @@ float64_t ui64_to_f64( uint64_t a )
     if ( a & UINT64_C( 0x8000000000000000 ) ) {
         return
             softfloat_roundPackToF64(
-                0, 0x43D, softfloat_shortShiftRightJam64( a, 1 ) );
+                0, 0x43D, softfloat_shortShiftRightJam64( a, 1 ) STATE_VAR );
     } else {
-        return softfloat_normRoundPackToF64( 0, 0x43C, a );
+        return softfloat_normRoundPackToF64( 0, 0x43C, a STATE_VAR );
     }
 
 }