== BEGIN: "toFP_Int8_ToFloat.c" ================
/* File: "toFP_Int8_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat toFP_Int8_ToFloat(const SInt8 a)
{
  const SInt8  s0 = a;
  const SFloat s2 = (SFloat) s0;

  return s2;
}
== END: "toFP_Int8_ToFloat.c" ==================
== BEGIN: "toFP_Int16_ToFloat.c" ================
/* File: "toFP_Int16_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat toFP_Int16_ToFloat(const SInt16 a)
{
  const SInt16 s0 = a;
  const SFloat s2 = (SFloat) s0;

  return s2;
}
== END: "toFP_Int16_ToFloat.c" ==================
== BEGIN: "toFP_Int32_ToFloat.c" ================
/* File: "toFP_Int32_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat toFP_Int32_ToFloat(const SInt32 a)
{
  const SInt32 s0 = a;
  const SFloat s2 = (SFloat) s0;

  return s2;
}
== END: "toFP_Int32_ToFloat.c" ==================
== BEGIN: "toFP_Int64_ToFloat.c" ================
/* File: "toFP_Int64_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat toFP_Int64_ToFloat(const SInt64 a)
{
  const SInt64 s0 = a;
  const SFloat s2 = (SFloat) s0;

  return s2;
}
== END: "toFP_Int64_ToFloat.c" ==================
== BEGIN: "toFP_Word8_ToFloat.c" ================
/* File: "toFP_Word8_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat toFP_Word8_ToFloat(const SWord8 a)
{
  const SWord8 s0 = a;
  const SFloat s2 = (SFloat) s0;

  return s2;
}
== END: "toFP_Word8_ToFloat.c" ==================
== BEGIN: "toFP_Word16_ToFloat.c" ================
/* File: "toFP_Word16_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat toFP_Word16_ToFloat(const SWord16 a)
{
  const SWord16 s0 = a;
  const SFloat  s2 = (SFloat) s0;

  return s2;
}
== END: "toFP_Word16_ToFloat.c" ==================
== BEGIN: "toFP_Word32_ToFloat.c" ================
/* File: "toFP_Word32_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat toFP_Word32_ToFloat(const SWord32 a)
{
  const SWord32 s0 = a;
  const SFloat  s2 = (SFloat) s0;

  return s2;
}
== END: "toFP_Word32_ToFloat.c" ==================
== BEGIN: "toFP_Word64_ToFloat.c" ================
/* File: "toFP_Word64_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat toFP_Word64_ToFloat(const SWord64 a)
{
  const SWord64 s0 = a;
  const SFloat  s2 = (SFloat) s0;

  return s2;
}
== END: "toFP_Word64_ToFloat.c" ==================
== BEGIN: "toFP_Float_ToFloat.c" ================
/* File: "toFP_Float_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat toFP_Float_ToFloat(const SFloat a)
{
  const SFloat s0 = a;
  return s0;
}
== END: "toFP_Float_ToFloat.c" ==================
== BEGIN: "toFP_Double_ToFloat.c" ================
/* File: "toFP_Double_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat toFP_Double_ToFloat(const SDouble a)
{
  const SDouble s0 = a;
  const SFloat  s2 = (SFloat) s0;

  return s2;
}
== END: "toFP_Double_ToFloat.c" ==================
== BEGIN: "toFP_Integer_ToFloat.c" ================
/* File: "toFP_Integer_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat toFP_Integer_ToFloat(const SInteger a)
{
  const SInteger s0 = a;
  const SFloat   s2 = (SFloat) s0;

  return s2;
}
== END: "toFP_Integer_ToFloat.c" ==================
== BEGIN: "toFP_Real_ToFloat.c" ================
/* File: "toFP_Real_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat toFP_Real_ToFloat(const SReal a)
{
  const SReal  s0 = a;
  const SFloat s2 = (SFloat) s0;

  return s2;
}
== END: "toFP_Real_ToFloat.c" ==================
== BEGIN: "toFP_Int8_ToDouble.c" ================
/* File: "toFP_Int8_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble toFP_Int8_ToDouble(const SInt8 a)
{
  const SInt8   s0 = a;
  const SDouble s2 = (SDouble) s0;

  return s2;
}
== END: "toFP_Int8_ToDouble.c" ==================
== BEGIN: "toFP_Int16_ToDouble.c" ================
/* File: "toFP_Int16_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble toFP_Int16_ToDouble(const SInt16 a)
{
  const SInt16  s0 = a;
  const SDouble s2 = (SDouble) s0;

  return s2;
}
== END: "toFP_Int16_ToDouble.c" ==================
== BEGIN: "toFP_Int32_ToDouble.c" ================
/* File: "toFP_Int32_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble toFP_Int32_ToDouble(const SInt32 a)
{
  const SInt32  s0 = a;
  const SDouble s2 = (SDouble) s0;

  return s2;
}
== END: "toFP_Int32_ToDouble.c" ==================
== BEGIN: "toFP_Int64_ToDouble.c" ================
/* File: "toFP_Int64_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble toFP_Int64_ToDouble(const SInt64 a)
{
  const SInt64  s0 = a;
  const SDouble s2 = (SDouble) s0;

  return s2;
}
== END: "toFP_Int64_ToDouble.c" ==================
== BEGIN: "toFP_Word8_ToDouble.c" ================
/* File: "toFP_Word8_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble toFP_Word8_ToDouble(const SWord8 a)
{
  const SWord8  s0 = a;
  const SDouble s2 = (SDouble) s0;

  return s2;
}
== END: "toFP_Word8_ToDouble.c" ==================
== BEGIN: "toFP_Word16_ToDouble.c" ================
/* File: "toFP_Word16_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble toFP_Word16_ToDouble(const SWord16 a)
{
  const SWord16 s0 = a;
  const SDouble s2 = (SDouble) s0;

  return s2;
}
== END: "toFP_Word16_ToDouble.c" ==================
== BEGIN: "toFP_Word32_ToDouble.c" ================
/* File: "toFP_Word32_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble toFP_Word32_ToDouble(const SWord32 a)
{
  const SWord32 s0 = a;
  const SDouble s2 = (SDouble) s0;

  return s2;
}
== END: "toFP_Word32_ToDouble.c" ==================
== BEGIN: "toFP_Word64_ToDouble.c" ================
/* File: "toFP_Word64_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble toFP_Word64_ToDouble(const SWord64 a)
{
  const SWord64 s0 = a;
  const SDouble s2 = (SDouble) s0;

  return s2;
}
== END: "toFP_Word64_ToDouble.c" ==================
== BEGIN: "toFP_Float_ToDouble.c" ================
/* File: "toFP_Float_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble toFP_Float_ToDouble(const SFloat a)
{
  const SFloat  s0 = a;
  const SDouble s2 = (SDouble) s0;

  return s2;
}
== END: "toFP_Float_ToDouble.c" ==================
== BEGIN: "toFP_Double_ToDouble.c" ================
/* File: "toFP_Double_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble toFP_Double_ToDouble(const SDouble a)
{
  const SDouble s0 = a;
  return s0;
}
== END: "toFP_Double_ToDouble.c" ==================
== BEGIN: "toFP_Integer_ToDouble.c" ================
/* File: "toFP_Integer_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble toFP_Integer_ToDouble(const SInteger a)
{
  const SInteger s0 = a;
  const SDouble  s2 = (SDouble) s0;

  return s2;
}
== END: "toFP_Integer_ToDouble.c" ==================
== BEGIN: "toFP_Real_ToDouble.c" ================
/* File: "toFP_Real_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble toFP_Real_ToDouble(const SReal a)
{
  const SReal   s0 = a;
  const SDouble s2 = (SDouble) s0;

  return s2;
}
== END: "toFP_Real_ToDouble.c" ==================
== BEGIN: "fromFP_Float_ToInt8.c" ================
/* File: "fromFP_Float_ToInt8.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SInt8 fromFP_Float_ToInt8(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = isnan(s0);
  const SBool  s2 = isinf(s0);
  const SBool  s3 = s1 || s2;
  const SBool  s4 = !s3;
  const SInt8  s6 = (SInt8) s0;
  const SInt8  s8 = s4 ? s6 : 0;

  return s8;
}
== END: "fromFP_Float_ToInt8.c" ==================
== BEGIN: "fromFP_Float_ToInt16.c" ================
/* File: "fromFP_Float_ToInt16.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SInt16 fromFP_Float_ToInt16(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = isnan(s0);
  const SBool  s2 = isinf(s0);
  const SBool  s3 = s1 || s2;
  const SBool  s4 = !s3;
  const SInt16 s6 = (SInt16) s0;
  const SInt16 s8 = s4 ? s6 : 0x0000;

  return s8;
}
== END: "fromFP_Float_ToInt16.c" ==================
== BEGIN: "fromFP_Float_ToInt32.c" ================
/* File: "fromFP_Float_ToInt32.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SInt32 fromFP_Float_ToInt32(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = isnan(s0);
  const SBool  s2 = isinf(s0);
  const SBool  s3 = s1 || s2;
  const SBool  s4 = !s3;
  const SInt32 s6 = (SInt32) s0;
  const SInt32 s8 = s4 ? s6 : 0x00000000L;

  return s8;
}
== END: "fromFP_Float_ToInt32.c" ==================
== BEGIN: "fromFP_Float_ToInt64.c" ================
/* File: "fromFP_Float_ToInt64.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SInt64 fromFP_Float_ToInt64(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = isnan(s0);
  const SBool  s2 = isinf(s0);
  const SBool  s3 = s1 || s2;
  const SBool  s4 = !s3;
  const SInt64 s6 = (SInt64) s0;
  const SInt64 s8 = s4 ? s6 : 0x0000000000000000LL;

  return s8;
}
== END: "fromFP_Float_ToInt64.c" ==================
== BEGIN: "fromFP_Float_ToWord8.c" ================
/* File: "fromFP_Float_ToWord8.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SWord8 fromFP_Float_ToWord8(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = isnan(s0);
  const SBool  s2 = isinf(s0);
  const SBool  s3 = s1 || s2;
  const SBool  s4 = !s3;
  const SWord8 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord8) fabsf(s0))) : ((SWord8) s0);
  const SWord8 s8 = s4 ? s6 : 0;

  return s8;
}
== END: "fromFP_Float_ToWord8.c" ==================
== BEGIN: "fromFP_Float_ToWord16.c" ================
/* File: "fromFP_Float_ToWord16.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SWord16 fromFP_Float_ToWord16(const SFloat a)
{
  const SFloat  s0 = a;
  const SBool   s1 = isnan(s0);
  const SBool   s2 = isinf(s0);
  const SBool   s3 = s1 || s2;
  const SBool   s4 = !s3;
  const SWord16 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord16) fabsf(s0))) : ((SWord16) s0);
  const SWord16 s8 = s4 ? s6 : 0x0000U;

  return s8;
}
== END: "fromFP_Float_ToWord16.c" ==================
== BEGIN: "fromFP_Float_ToWord32.c" ================
/* File: "fromFP_Float_ToWord32.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SWord32 fromFP_Float_ToWord32(const SFloat a)
{
  const SFloat  s0 = a;
  const SBool   s1 = isnan(s0);
  const SBool   s2 = isinf(s0);
  const SBool   s3 = s1 || s2;
  const SBool   s4 = !s3;
  const SWord32 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord32) fabsf(s0))) : ((SWord32) s0);
  const SWord32 s8 = s4 ? s6 : 0x00000000UL;

  return s8;
}
== END: "fromFP_Float_ToWord32.c" ==================
== BEGIN: "fromFP_Float_ToWord64.c" ================
/* File: "fromFP_Float_ToWord64.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SWord64 fromFP_Float_ToWord64(const SFloat a)
{
  const SFloat  s0 = a;
  const SBool   s1 = isnan(s0);
  const SBool   s2 = isinf(s0);
  const SBool   s3 = s1 || s2;
  const SBool   s4 = !s3;
  const SWord64 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord64) fabsf(s0))) : ((SWord64) s0);
  const SWord64 s8 = s4 ? s6 : 0x0000000000000000ULL;

  return s8;
}
== END: "fromFP_Float_ToWord64.c" ==================
== BEGIN: "fromFP_Float_ToFloat.c" ================
/* File: "fromFP_Float_ToFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat fromFP_Float_ToFloat(const SFloat a)
{
  const SFloat s0 = a;
  return s0;
}
== END: "fromFP_Float_ToFloat.c" ==================
== BEGIN: "fromFP_Float_ToDouble.c" ================
/* File: "fromFP_Float_ToDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble fromFP_Float_ToDouble(const SFloat a)
{
  const SFloat  s0 = a;
  const SDouble s2 = (SDouble) s0;

  return s2;
}
== END: "fromFP_Float_ToDouble.c" ==================
== BEGIN: "fromFP_Float_ToInteger.c" ================
/* File: "fromFP_Float_ToInteger.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SInteger fromFP_Float_ToInteger(const SFloat a)
{
  const SFloat   s0 = a;
  const SBool    s1 = isnan(s0);
  const SBool    s2 = isinf(s0);
  const SBool    s3 = s1 || s2;
  const SBool    s4 = !s3;
  const SInteger s6 = (SInteger) s0;
  const SInteger s8 = s4 ? s6 : 0x0000000000000000LL;

  return s8;
}
== END: "fromFP_Float_ToInteger.c" ==================
== BEGIN: "fromFP_Float_ToReal.c" ================
/* File: "fromFP_Float_ToReal.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SReal fromFP_Float_ToReal(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = isnan(s0);
  const SBool  s2 = isinf(s0);
  const SBool  s3 = s1 || s2;
  const SBool  s4 = !s3;
  const SReal  s6 = (SReal) s0;
  const SReal  s8 = s4 ? s6 : 0.0L;

  return s8;
}
== END: "fromFP_Float_ToReal.c" ==================
== BEGIN: "fromFP_DoubleTo_Int8.c" ================
/* File: "fromFP_DoubleTo_Int8.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SInt8 fromFP_DoubleTo_Int8(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = isnan(s0);
  const SBool   s2 = isinf(s0);
  const SBool   s3 = s1 || s2;
  const SBool   s4 = !s3;
  const SInt8   s6 = (SInt8) s0;
  const SInt8   s8 = s4 ? s6 : 0;

  return s8;
}
== END: "fromFP_DoubleTo_Int8.c" ==================
== BEGIN: "fromFP_DoubleTo_Int16.c" ================
/* File: "fromFP_DoubleTo_Int16.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SInt16 fromFP_DoubleTo_Int16(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = isnan(s0);
  const SBool   s2 = isinf(s0);
  const SBool   s3 = s1 || s2;
  const SBool   s4 = !s3;
  const SInt16  s6 = (SInt16) s0;
  const SInt16  s8 = s4 ? s6 : 0x0000;

  return s8;
}
== END: "fromFP_DoubleTo_Int16.c" ==================
== BEGIN: "fromFP_DoubleTo_Int32.c" ================
/* File: "fromFP_DoubleTo_Int32.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SInt32 fromFP_DoubleTo_Int32(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = isnan(s0);
  const SBool   s2 = isinf(s0);
  const SBool   s3 = s1 || s2;
  const SBool   s4 = !s3;
  const SInt32  s6 = (SInt32) s0;
  const SInt32  s8 = s4 ? s6 : 0x00000000L;

  return s8;
}
== END: "fromFP_DoubleTo_Int32.c" ==================
== BEGIN: "fromFP_DoubleTo_Int64.c" ================
/* File: "fromFP_DoubleTo_Int64.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SInt64 fromFP_DoubleTo_Int64(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = isnan(s0);
  const SBool   s2 = isinf(s0);
  const SBool   s3 = s1 || s2;
  const SBool   s4 = !s3;
  const SInt64  s6 = (SInt64) s0;
  const SInt64  s8 = s4 ? s6 : 0x0000000000000000LL;

  return s8;
}
== END: "fromFP_DoubleTo_Int64.c" ==================
== BEGIN: "fromFP_DoubleTo_Word8.c" ================
/* File: "fromFP_DoubleTo_Word8.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SWord8 fromFP_DoubleTo_Word8(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = isnan(s0);
  const SBool   s2 = isinf(s0);
  const SBool   s3 = s1 || s2;
  const SBool   s4 = !s3;
  const SWord8  s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord8) fabs(s0))) : ((SWord8) s0);
  const SWord8  s8 = s4 ? s6 : 0;

  return s8;
}
== END: "fromFP_DoubleTo_Word8.c" ==================
== BEGIN: "fromFP_DoubleTo_Word16.c" ================
/* File: "fromFP_DoubleTo_Word16.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SWord16 fromFP_DoubleTo_Word16(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = isnan(s0);
  const SBool   s2 = isinf(s0);
  const SBool   s3 = s1 || s2;
  const SBool   s4 = !s3;
  const SWord16 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord16) fabs(s0))) : ((SWord16) s0);
  const SWord16 s8 = s4 ? s6 : 0x0000U;

  return s8;
}
== END: "fromFP_DoubleTo_Word16.c" ==================
== BEGIN: "fromFP_DoubleTo_Word32.c" ================
/* File: "fromFP_DoubleTo_Word32.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SWord32 fromFP_DoubleTo_Word32(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = isnan(s0);
  const SBool   s2 = isinf(s0);
  const SBool   s3 = s1 || s2;
  const SBool   s4 = !s3;
  const SWord32 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord32) fabs(s0))) : ((SWord32) s0);
  const SWord32 s8 = s4 ? s6 : 0x00000000UL;

  return s8;
}
== END: "fromFP_DoubleTo_Word32.c" ==================
== BEGIN: "fromFP_DoubleTo_Word64.c" ================
/* File: "fromFP_DoubleTo_Word64.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SWord64 fromFP_DoubleTo_Word64(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = isnan(s0);
  const SBool   s2 = isinf(s0);
  const SBool   s3 = s1 || s2;
  const SBool   s4 = !s3;
  const SWord64 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord64) fabs(s0))) : ((SWord64) s0);
  const SWord64 s8 = s4 ? s6 : 0x0000000000000000ULL;

  return s8;
}
== END: "fromFP_DoubleTo_Word64.c" ==================
== BEGIN: "fromFP_DoubleTo_Float.c" ================
/* File: "fromFP_DoubleTo_Float.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat fromFP_DoubleTo_Float(const SDouble a)
{
  const SDouble s0 = a;
  const SFloat  s2 = (SFloat) s0;

  return s2;
}
== END: "fromFP_DoubleTo_Float.c" ==================
== BEGIN: "fromFP_DoubleTo_Double.c" ================
/* File: "fromFP_DoubleTo_Double.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble fromFP_DoubleTo_Double(const SDouble a)
{
  const SDouble s0 = a;
  return s0;
}
== END: "fromFP_DoubleTo_Double.c" ==================
== BEGIN: "fromFP_DoubleTo_Integer.c" ================
/* File: "fromFP_DoubleTo_Integer.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SInteger fromFP_DoubleTo_Integer(const SDouble a)
{
  const SDouble  s0 = a;
  const SBool    s1 = isnan(s0);
  const SBool    s2 = isinf(s0);
  const SBool    s3 = s1 || s2;
  const SBool    s4 = !s3;
  const SInteger s6 = (SInteger) s0;
  const SInteger s8 = s4 ? s6 : 0x0000000000000000LL;

  return s8;
}
== END: "fromFP_DoubleTo_Integer.c" ==================
== BEGIN: "fromFP_DoubleTo_Real.c" ================
/* File: "fromFP_DoubleTo_Real.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SReal fromFP_DoubleTo_Real(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = isnan(s0);
  const SBool   s2 = isinf(s0);
  const SBool   s3 = s1 || s2;
  const SBool   s4 = !s3;
  const SReal   s6 = (SReal) s0;
  const SReal   s8 = s4 ? s6 : 0.0L;

  return s8;
}
== END: "fromFP_DoubleTo_Real.c" ==================
== BEGIN: "fromFP_SWord32_SFloat.c" ================
/* File: "fromFP_SWord32_SFloat.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat fromFP_SWord32_SFloat(const SWord32 a)
{
  const SWord32 s0 = a;
        SFloat  s1; memcpy(&s1, &s0, sizeof(SFloat));

  return s1;
}
== END: "fromFP_SWord32_SFloat.c" ==================
== BEGIN: "fromFP_SWord64_SDouble.c" ================
/* File: "fromFP_SWord64_SDouble.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble fromFP_SWord64_SDouble(const SWord64 a)
{
  const SWord64 s0 = a;
        SDouble s1; memcpy(&s1, &s0, sizeof(SDouble));

  return s1;
}
== END: "fromFP_SWord64_SDouble.c" ==================
== BEGIN: "fromFP_SFloat_SWord32.c" ================
/* File: "fromFP_SFloat_SWord32.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SWord32 fromFP_SFloat_SWord32(const SFloat a)
{
  const SFloat  s0 = a;
        SWord32 s1; memcpy(&s1, &s0, sizeof(SWord32));

  return s1;
}
== END: "fromFP_SFloat_SWord32.c" ==================
== BEGIN: "fromFP_SDouble_SWord64.c" ================
/* File: "fromFP_SDouble_SWord64.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SWord64 fromFP_SDouble_SWord64(const SDouble a)
{
  const SDouble s0 = a;
        SWord64 s1; memcpy(&s1, &s0, sizeof(SWord64));

  return s1;
}
== END: "fromFP_SDouble_SWord64.c" ==================
== BEGIN: "f_FP_Abs.c" ================
/* File: "f_FP_Abs.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat f_FP_Abs(const SFloat a)
{
  const SFloat s0 = a;
  const SFloat s1 = fabsf(s0);

  return s1;
}
== END: "f_FP_Abs.c" ==================
== BEGIN: "d_FP_Abs.c" ================
/* File: "d_FP_Abs.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble d_FP_Abs(const SDouble a)
{
  const SDouble s0 = a;
  const SDouble s1 = fabs(s0);

  return s1;
}
== END: "d_FP_Abs.c" ==================
== BEGIN: "f_FP_Neg.c" ================
/* File: "f_FP_Neg.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat f_FP_Neg(const SFloat a)
{
  const SFloat s0 = a;
  const SFloat s1 = (- s0);

  return s1;
}
== END: "f_FP_Neg.c" ==================
== BEGIN: "d_FP_Neg.c" ================
/* File: "d_FP_Neg.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble d_FP_Neg(const SDouble a)
{
  const SDouble s0 = a;
  const SDouble s1 = (- s0);

  return s1;
}
== END: "d_FP_Neg.c" ==================
== BEGIN: "f_FP_Add.c" ================
/* File: "f_FP_Add.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat f_FP_Add(const SFloat a, const SFloat b)
{
  const SFloat s0 = a;
  const SFloat s1 = b;
  const SFloat s3 = s0 + s1;

  return s3;
}
== END: "f_FP_Add.c" ==================
== BEGIN: "d_FP_Add.c" ================
/* File: "d_FP_Add.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble d_FP_Add(const SDouble a, const SDouble b)
{
  const SDouble s0 = a;
  const SDouble s1 = b;
  const SDouble s3 = s0 + s1;

  return s3;
}
== END: "d_FP_Add.c" ==================
== BEGIN: "f_FP_Sub.c" ================
/* File: "f_FP_Sub.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat f_FP_Sub(const SFloat a, const SFloat b)
{
  const SFloat s0 = a;
  const SFloat s1 = b;
  const SFloat s3 = s0 - s1;

  return s3;
}
== END: "f_FP_Sub.c" ==================
== BEGIN: "d_FP_Sub.c" ================
/* File: "d_FP_Sub.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble d_FP_Sub(const SDouble a, const SDouble b)
{
  const SDouble s0 = a;
  const SDouble s1 = b;
  const SDouble s3 = s0 - s1;

  return s3;
}
== END: "d_FP_Sub.c" ==================
== BEGIN: "f_FP_Mul.c" ================
/* File: "f_FP_Mul.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat f_FP_Mul(const SFloat a, const SFloat b)
{
  const SFloat s0 = a;
  const SFloat s1 = b;
  const SFloat s3 = s0 * s1;

  return s3;
}
== END: "f_FP_Mul.c" ==================
== BEGIN: "d_FP_Mul.c" ================
/* File: "d_FP_Mul.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble d_FP_Mul(const SDouble a, const SDouble b)
{
  const SDouble s0 = a;
  const SDouble s1 = b;
  const SDouble s3 = s0 * s1;

  return s3;
}
== END: "d_FP_Mul.c" ==================
== BEGIN: "f_FP_Div.c" ================
/* File: "f_FP_Div.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat f_FP_Div(const SFloat a, const SFloat b)
{
  const SFloat s0 = a;
  const SFloat s1 = b;
  const SFloat s3 = s0 / s1;

  return s3;
}
== END: "f_FP_Div.c" ==================
== BEGIN: "d_FP_Div.c" ================
/* File: "d_FP_Div.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble d_FP_Div(const SDouble a, const SDouble b)
{
  const SDouble s0 = a;
  const SDouble s1 = b;
  const SDouble s3 = s0 / s1;

  return s3;
}
== END: "d_FP_Div.c" ==================
== BEGIN: "f_FP_FMA.c" ================
/* File: "f_FP_FMA.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat f_FP_FMA(const SFloat a, const SFloat b, const SFloat c)
{
  const SFloat s0 = a;
  const SFloat s1 = b;
  const SFloat s2 = c;
  const SFloat s4 = fmaf(s0, s1, s2);

  return s4;
}
== END: "f_FP_FMA.c" ==================
== BEGIN: "d_FP_FMA.c" ================
/* File: "d_FP_FMA.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble d_FP_FMA(const SDouble a, const SDouble b, const SDouble c)
{
  const SDouble s0 = a;
  const SDouble s1 = b;
  const SDouble s2 = c;
  const SDouble s4 = fma(s0, s1, s2);

  return s4;
}
== END: "d_FP_FMA.c" ==================
== BEGIN: "f_FP_Sqrt.c" ================
/* File: "f_FP_Sqrt.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat f_FP_Sqrt(const SFloat a)
{
  const SFloat s0 = a;
  const SFloat s2 = sqrtf(s0);

  return s2;
}
== END: "f_FP_Sqrt.c" ==================
== BEGIN: "d_FP_Sqrt.c" ================
/* File: "d_FP_Sqrt.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble d_FP_Sqrt(const SDouble a)
{
  const SDouble s0 = a;
  const SDouble s2 = sqrt(s0);

  return s2;
}
== END: "d_FP_Sqrt.c" ==================
== BEGIN: "f_FP_Rem.c" ================
/* File: "f_FP_Rem.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat f_FP_Rem(const SFloat a, const SFloat b)
{
  const SFloat s0 = a;
  const SFloat s1 = b;
  const SFloat s2 = fmodf(s0, s1);

  return s2;
}
== END: "f_FP_Rem.c" ==================
== BEGIN: "d_FP_Rem.c" ================
/* File: "d_FP_Rem.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble d_FP_Rem(const SDouble a, const SDouble b)
{
  const SDouble s0 = a;
  const SDouble s1 = b;
  const SDouble s2 = fmod(s0, s1);

  return s2;
}
== END: "d_FP_Rem.c" ==================
== BEGIN: "f_FP_RoundToIntegral.c" ================
/* File: "f_FP_RoundToIntegral.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat f_FP_RoundToIntegral(const SFloat a)
{
  const SFloat s0 = a;
  const SFloat s2 = rintf(s0);

  return s2;
}
== END: "f_FP_RoundToIntegral.c" ==================
== BEGIN: "d_FP_RoundToIntegral.c" ================
/* File: "d_FP_RoundToIntegral.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble d_FP_RoundToIntegral(const SDouble a)
{
  const SDouble s0 = a;
  const SDouble s2 = rint(s0);

  return s2;
}
== END: "d_FP_RoundToIntegral.c" ==================
== BEGIN: "f_FP_Min.c" ================
/* File: "f_FP_Min.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat f_FP_Min(const SFloat a, const SFloat b)
{
  const SFloat s0 = a;
  const SFloat s1 = b;
  const SFloat s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0F : fminf(s0,
                                                                                                                                s1);

  return s2;
}
== END: "f_FP_Min.c" ==================
== BEGIN: "d_FP_Min.c" ================
/* File: "d_FP_Min.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble d_FP_Min(const SDouble a, const SDouble b)
{
  const SDouble s0 = a;
  const SDouble s1 = b;
  const SDouble s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0 : fmin(s0,
                                                                                                                               s1);

  return s2;
}
== END: "d_FP_Min.c" ==================
== BEGIN: "f_FP_Max.c" ================
/* File: "f_FP_Max.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SFloat f_FP_Max(const SFloat a, const SFloat b)
{
  const SFloat s0 = a;
  const SFloat s1 = b;
  const SFloat s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0F : fmaxf(s0,
                                                                                                                                s1);

  return s2;
}
== END: "f_FP_Max.c" ==================
== BEGIN: "d_FP_Max.c" ================
/* File: "d_FP_Max.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SDouble d_FP_Max(const SDouble a, const SDouble b)
{
  const SDouble s0 = a;
  const SDouble s1 = b;
  const SDouble s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0 : fmax(s0,
                                                                                                                               s1);

  return s2;
}
== END: "d_FP_Max.c" ==================
== BEGIN: "f_FP_IsEqualObject.c" ================
/* File: "f_FP_IsEqualObject.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool f_FP_IsEqualObject(const SFloat a, const SFloat b)
{
  const SFloat s0 = a;
  const SFloat s1 = b;
  const SBool  s2 = isnan(s0) ? isnan(s1) : (signbit(s0) && (s0 == 0)) ? (signbit(s1) && (s1 == 0)) : (signbit(s1) && (s1 == 0)) ? (signbit(s0) && (s0 == 0)) : (s0 == s1);

  return s2;
}
== END: "f_FP_IsEqualObject.c" ==================
== BEGIN: "d_FP_IsEqualObject.c" ================
/* File: "d_FP_IsEqualObject.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool d_FP_IsEqualObject(const SDouble a, const SDouble b)
{
  const SDouble s0 = a;
  const SDouble s1 = b;
  const SBool   s2 = isnan(s0) ? isnan(s1) : (signbit(s0) && (s0 == 0)) ? (signbit(s1) && (s1 == 0)) : (signbit(s1) && (s1 == 0)) ? (signbit(s0) && (s0 == 0)) : (s0 == s1);

  return s2;
}
== END: "d_FP_IsEqualObject.c" ==================
== BEGIN: "f_FP_IsNormal.c" ================
/* File: "f_FP_IsNormal.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool f_FP_IsNormal(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = isnormal(s0);

  return s1;
}
== END: "f_FP_IsNormal.c" ==================
== BEGIN: "d_FP_IsNormal.c" ================
/* File: "d_FP_IsNormal.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool d_FP_IsNormal(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = isnormal(s0);

  return s1;
}
== END: "d_FP_IsNormal.c" ==================
== BEGIN: "f_FP_IsZero.c" ================
/* File: "f_FP_IsZero.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool f_FP_IsZero(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = FP_ZERO == fpclassify(s0);

  return s1;
}
== END: "f_FP_IsZero.c" ==================
== BEGIN: "d_FP_IsZero.c" ================
/* File: "d_FP_IsZero.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool d_FP_IsZero(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = FP_ZERO == fpclassify(s0);

  return s1;
}
== END: "d_FP_IsZero.c" ==================
== BEGIN: "f_FP_IsSubnormal.c" ================
/* File: "f_FP_IsSubnormal.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool f_FP_IsSubnormal(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = FP_SUBNORMAL == fpclassify(s0);

  return s1;
}
== END: "f_FP_IsSubnormal.c" ==================
== BEGIN: "d_FP_IsSubnormal.c" ================
/* File: "d_FP_IsSubnormal.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool d_FP_IsSubnormal(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = FP_SUBNORMAL == fpclassify(s0);

  return s1;
}
== END: "d_FP_IsSubnormal.c" ==================
== BEGIN: "f_FP_IsInfinite.c" ================
/* File: "f_FP_IsInfinite.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool f_FP_IsInfinite(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = isinf(s0);

  return s1;
}
== END: "f_FP_IsInfinite.c" ==================
== BEGIN: "d_FP_IsInfinite.c" ================
/* File: "d_FP_IsInfinite.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool d_FP_IsInfinite(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = isinf(s0);

  return s1;
}
== END: "d_FP_IsInfinite.c" ==================
== BEGIN: "f_FP_IsNaN.c" ================
/* File: "f_FP_IsNaN.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool f_FP_IsNaN(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = isnan(s0);

  return s1;
}
== END: "f_FP_IsNaN.c" ==================
== BEGIN: "d_FP_IsNaN.c" ================
/* File: "d_FP_IsNaN.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool d_FP_IsNaN(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = isnan(s0);

  return s1;
}
== END: "d_FP_IsNaN.c" ==================
== BEGIN: "f_FP_IsNegative.c" ================
/* File: "f_FP_IsNegative.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool f_FP_IsNegative(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = !isnan(s0) && signbit(s0);

  return s1;
}
== END: "f_FP_IsNegative.c" ==================
== BEGIN: "d_FP_IsNegative.c" ================
/* File: "d_FP_IsNegative.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool d_FP_IsNegative(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = !isnan(s0) && signbit(s0);

  return s1;
}
== END: "d_FP_IsNegative.c" ==================
== BEGIN: "f_FP_IsPositive.c" ================
/* File: "f_FP_IsPositive.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool f_FP_IsPositive(const SFloat a)
{
  const SFloat s0 = a;
  const SBool  s1 = !isnan(s0) && !signbit(s0);

  return s1;
}
== END: "f_FP_IsPositive.c" ==================
== BEGIN: "d_FP_IsPositive.c" ================
/* File: "d_FP_IsPositive.c". Automatically generated by SBV. Do not edit! */

#include "floatCodeGen.h"

SBool d_FP_IsPositive(const SDouble a)
{
  const SDouble s0 = a;
  const SBool   s1 = !isnan(s0) && !signbit(s0);

  return s1;
}
== END: "d_FP_IsPositive.c" ==================
== BEGIN: "floatCodeGen.h" ================
/* Header file for floatCodeGen. Automatically generated by SBV. Do not edit! */

#ifndef __floatCodeGen__HEADER_INCLUDED__
#define __floatCodeGen__HEADER_INCLUDED__

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <math.h>

/* The boolean type */
typedef bool SBool;

/* The float type */
typedef float SFloat;

/* The double type */
typedef double SDouble;

/* Unsigned bit-vectors */
typedef uint8_t  SWord8 ;
typedef uint16_t SWord16;
typedef uint32_t SWord32;
typedef uint64_t SWord64;

/* Signed bit-vectors */
typedef int8_t  SInt8 ;
typedef int16_t SInt16;
typedef int32_t SInt32;
typedef int64_t SInt64;

/* User requested mapping for SInteger.                                 */
/* NB. Loss of precision: Target type is subject to modular arithmetic. */
typedef SInt64 SInteger;

/* User requested mapping for SReal.                          */
/* NB. Loss of precision: Target type is subject to rounding. */
typedef long double SReal;

/* Entry point prototypes: */
SFloat toFP_Int8_ToFloat(const SInt8 a);
SFloat toFP_Int16_ToFloat(const SInt16 a);
SFloat toFP_Int32_ToFloat(const SInt32 a);
SFloat toFP_Int64_ToFloat(const SInt64 a);
SFloat toFP_Word8_ToFloat(const SWord8 a);
SFloat toFP_Word16_ToFloat(const SWord16 a);
SFloat toFP_Word32_ToFloat(const SWord32 a);
SFloat toFP_Word64_ToFloat(const SWord64 a);
SFloat toFP_Float_ToFloat(const SFloat a);
SFloat toFP_Double_ToFloat(const SDouble a);
SFloat toFP_Integer_ToFloat(const SInteger a);
SFloat toFP_Real_ToFloat(const SReal a);
SDouble toFP_Int8_ToDouble(const SInt8 a);
SDouble toFP_Int16_ToDouble(const SInt16 a);
SDouble toFP_Int32_ToDouble(const SInt32 a);
SDouble toFP_Int64_ToDouble(const SInt64 a);
SDouble toFP_Word8_ToDouble(const SWord8 a);
SDouble toFP_Word16_ToDouble(const SWord16 a);
SDouble toFP_Word32_ToDouble(const SWord32 a);
SDouble toFP_Word64_ToDouble(const SWord64 a);
SDouble toFP_Float_ToDouble(const SFloat a);
SDouble toFP_Double_ToDouble(const SDouble a);
SDouble toFP_Integer_ToDouble(const SInteger a);
SDouble toFP_Real_ToDouble(const SReal a);
SInt8 fromFP_Float_ToInt8(const SFloat a);
SInt16 fromFP_Float_ToInt16(const SFloat a);
SInt32 fromFP_Float_ToInt32(const SFloat a);
SInt64 fromFP_Float_ToInt64(const SFloat a);
SWord8 fromFP_Float_ToWord8(const SFloat a);
SWord16 fromFP_Float_ToWord16(const SFloat a);
SWord32 fromFP_Float_ToWord32(const SFloat a);
SWord64 fromFP_Float_ToWord64(const SFloat a);
SFloat fromFP_Float_ToFloat(const SFloat a);
SDouble fromFP_Float_ToDouble(const SFloat a);
SInteger fromFP_Float_ToInteger(const SFloat a);
SReal fromFP_Float_ToReal(const SFloat a);
SInt8 fromFP_DoubleTo_Int8(const SDouble a);
SInt16 fromFP_DoubleTo_Int16(const SDouble a);
SInt32 fromFP_DoubleTo_Int32(const SDouble a);
SInt64 fromFP_DoubleTo_Int64(const SDouble a);
SWord8 fromFP_DoubleTo_Word8(const SDouble a);
SWord16 fromFP_DoubleTo_Word16(const SDouble a);
SWord32 fromFP_DoubleTo_Word32(const SDouble a);
SWord64 fromFP_DoubleTo_Word64(const SDouble a);
SFloat fromFP_DoubleTo_Float(const SDouble a);
SDouble fromFP_DoubleTo_Double(const SDouble a);
SInteger fromFP_DoubleTo_Integer(const SDouble a);
SReal fromFP_DoubleTo_Real(const SDouble a);
SFloat fromFP_SWord32_SFloat(const SWord32 a);
SDouble fromFP_SWord64_SDouble(const SWord64 a);
SWord32 fromFP_SFloat_SWord32(const SFloat a);
SWord64 fromFP_SDouble_SWord64(const SDouble a);
SFloat f_FP_Abs(const SFloat a);
SDouble d_FP_Abs(const SDouble a);
SFloat f_FP_Neg(const SFloat a);
SDouble d_FP_Neg(const SDouble a);
SFloat f_FP_Add(const SFloat a, const SFloat b);
SDouble d_FP_Add(const SDouble a, const SDouble b);
SFloat f_FP_Sub(const SFloat a, const SFloat b);
SDouble d_FP_Sub(const SDouble a, const SDouble b);
SFloat f_FP_Mul(const SFloat a, const SFloat b);
SDouble d_FP_Mul(const SDouble a, const SDouble b);
SFloat f_FP_Div(const SFloat a, const SFloat b);
SDouble d_FP_Div(const SDouble a, const SDouble b);
SFloat f_FP_FMA(const SFloat a, const SFloat b, const SFloat c);
SDouble d_FP_FMA(const SDouble a, const SDouble b,
                 const SDouble c);
SFloat f_FP_Sqrt(const SFloat a);
SDouble d_FP_Sqrt(const SDouble a);
SFloat f_FP_Rem(const SFloat a, const SFloat b);
SDouble d_FP_Rem(const SDouble a, const SDouble b);
SFloat f_FP_RoundToIntegral(const SFloat a);
SDouble d_FP_RoundToIntegral(const SDouble a);
SFloat f_FP_Min(const SFloat a, const SFloat b);
SDouble d_FP_Min(const SDouble a, const SDouble b);
SFloat f_FP_Max(const SFloat a, const SFloat b);
SDouble d_FP_Max(const SDouble a, const SDouble b);
SBool f_FP_IsEqualObject(const SFloat a, const SFloat b);
SBool d_FP_IsEqualObject(const SDouble a, const SDouble b);
SBool f_FP_IsNormal(const SFloat a);
SBool d_FP_IsNormal(const SDouble a);
SBool f_FP_IsZero(const SFloat a);
SBool d_FP_IsZero(const SDouble a);
SBool f_FP_IsSubnormal(const SFloat a);
SBool d_FP_IsSubnormal(const SDouble a);
SBool f_FP_IsInfinite(const SFloat a);
SBool d_FP_IsInfinite(const SDouble a);
SBool f_FP_IsNaN(const SFloat a);
SBool d_FP_IsNaN(const SDouble a);
SBool f_FP_IsNegative(const SFloat a);
SBool d_FP_IsNegative(const SDouble a);
SBool f_FP_IsPositive(const SFloat a);
SBool d_FP_IsPositive(const SDouble a);

#endif /* __floatCodeGen__HEADER_INCLUDED__ */
== END: "floatCodeGen.h" ==================
== BEGIN: "floatCodeGen_driver.c" ================
/* Example driver program for floatCodeGen. */
/* Automatically generated by SBV. Edit as you see fit! */

#include <stdio.h>
#include "floatCodeGen.h"

void toFP_Int8_ToFloat_driver(void)
{
  const SFloat __result = toFP_Int8_ToFloat(42);

  printf("toFP_Int8_ToFloat(42) = %.6g\n", __result);
}

void toFP_Int16_ToFloat_driver(void)
{
  const SFloat __result = toFP_Int16_ToFloat(0x002a);

  printf("toFP_Int16_ToFloat(0x002a) = %.6g\n", __result);
}

void toFP_Int32_ToFloat_driver(void)
{
  const SFloat __result = toFP_Int32_ToFloat(0x0000002aL);

  printf("toFP_Int32_ToFloat(0x0000002aL) = %.6g\n", __result);
}

void toFP_Int64_ToFloat_driver(void)
{
  const SFloat __result = toFP_Int64_ToFloat(0x000000000000002aLL);

  printf("toFP_Int64_ToFloat(0x000000000000002aLL) = %.6g\n", __result);
}

void toFP_Word8_ToFloat_driver(void)
{
  const SFloat __result = toFP_Word8_ToFloat(42);

  printf("toFP_Word8_ToFloat(42) = %.6g\n", __result);
}

void toFP_Word16_ToFloat_driver(void)
{
  const SFloat __result = toFP_Word16_ToFloat(0x002aU);

  printf("toFP_Word16_ToFloat(0x002aU) = %.6g\n", __result);
}

void toFP_Word32_ToFloat_driver(void)
{
  const SFloat __result = toFP_Word32_ToFloat(0x0000002aUL);

  printf("toFP_Word32_ToFloat(0x0000002aUL) = %.6g\n", __result);
}

void toFP_Word64_ToFloat_driver(void)
{
  const SFloat __result = toFP_Word64_ToFloat(0x000000000000002aULL);

  printf("toFP_Word64_ToFloat(0x000000000000002aULL) = %.6g\n", __result);
}

void toFP_Float_ToFloat_driver(void)
{
  const SFloat __result = toFP_Float_ToFloat(42.0F);

  printf("toFP_Float_ToFloat(42.0F) = %.6g\n", __result);
}

void toFP_Double_ToFloat_driver(void)
{
  const SFloat __result = toFP_Double_ToFloat(42.0);

  printf("toFP_Double_ToFloat(42.0) = %.6g\n", __result);
}

void toFP_Integer_ToFloat_driver(void)
{
  const SFloat __result = toFP_Integer_ToFloat(0x000000000000002aLL);

  printf("toFP_Integer_ToFloat(0x000000000000002aLL) = %.6g\n", __result);
}

void toFP_Real_ToFloat_driver(void)
{
  const SFloat __result = toFP_Real_ToFloat(42.0L);

  printf("toFP_Real_ToFloat(42.0L) = %.6g\n", __result);
}

void toFP_Int8_ToDouble_driver(void)
{
  const SDouble __result = toFP_Int8_ToDouble(42);

  printf("toFP_Int8_ToDouble(42) = %.15g\n", __result);
}

void toFP_Int16_ToDouble_driver(void)
{
  const SDouble __result = toFP_Int16_ToDouble(0x002a);

  printf("toFP_Int16_ToDouble(0x002a) = %.15g\n", __result);
}

void toFP_Int32_ToDouble_driver(void)
{
  const SDouble __result = toFP_Int32_ToDouble(0x0000002aL);

  printf("toFP_Int32_ToDouble(0x0000002aL) = %.15g\n", __result);
}

void toFP_Int64_ToDouble_driver(void)
{
  const SDouble __result = toFP_Int64_ToDouble(0x000000000000002aLL);

  printf("toFP_Int64_ToDouble(0x000000000000002aLL) = %.15g\n", __result);
}

void toFP_Word8_ToDouble_driver(void)
{
  const SDouble __result = toFP_Word8_ToDouble(42);

  printf("toFP_Word8_ToDouble(42) = %.15g\n", __result);
}

void toFP_Word16_ToDouble_driver(void)
{
  const SDouble __result = toFP_Word16_ToDouble(0x002aU);

  printf("toFP_Word16_ToDouble(0x002aU) = %.15g\n", __result);
}

void toFP_Word32_ToDouble_driver(void)
{
  const SDouble __result = toFP_Word32_ToDouble(0x0000002aUL);

  printf("toFP_Word32_ToDouble(0x0000002aUL) = %.15g\n", __result);
}

void toFP_Word64_ToDouble_driver(void)
{
  const SDouble __result = toFP_Word64_ToDouble(0x000000000000002aULL);

  printf("toFP_Word64_ToDouble(0x000000000000002aULL) = %.15g\n", __result);
}

void toFP_Float_ToDouble_driver(void)
{
  const SDouble __result = toFP_Float_ToDouble(42.0F);

  printf("toFP_Float_ToDouble(42.0F) = %.15g\n", __result);
}

void toFP_Double_ToDouble_driver(void)
{
  const SDouble __result = toFP_Double_ToDouble(42.0);

  printf("toFP_Double_ToDouble(42.0) = %.15g\n", __result);
}

void toFP_Integer_ToDouble_driver(void)
{
  const SDouble __result = toFP_Integer_ToDouble(0x000000000000002aLL);

  printf("toFP_Integer_ToDouble(0x000000000000002aLL) = %.15g\n", __result);
}

void toFP_Real_ToDouble_driver(void)
{
  const SDouble __result = toFP_Real_ToDouble(42.0L);

  printf("toFP_Real_ToDouble(42.0L) = %.15g\n", __result);
}

void fromFP_Float_ToInt8_driver(void)
{
  const SInt8 __result = fromFP_Float_ToInt8(42.0F);

  printf("fromFP_Float_ToInt8(42.0F) = %"PRId8"\n", __result);
}

void fromFP_Float_ToInt16_driver(void)
{
  const SInt16 __result = fromFP_Float_ToInt16(42.0F);

  printf("fromFP_Float_ToInt16(42.0F) = %"PRId16"\n", __result);
}

void fromFP_Float_ToInt32_driver(void)
{
  const SInt32 __result = fromFP_Float_ToInt32(42.0F);

  printf("fromFP_Float_ToInt32(42.0F) = %"PRId32"L\n", __result);
}

void fromFP_Float_ToInt64_driver(void)
{
  const SInt64 __result = fromFP_Float_ToInt64(42.0F);

  printf("fromFP_Float_ToInt64(42.0F) = %"PRId64"LL\n", __result);
}

void fromFP_Float_ToWord8_driver(void)
{
  const SWord8 __result = fromFP_Float_ToWord8(42.0F);

  printf("fromFP_Float_ToWord8(42.0F) = %"PRIu8"\n", __result);
}

void fromFP_Float_ToWord16_driver(void)
{
  const SWord16 __result = fromFP_Float_ToWord16(42.0F);

  printf("fromFP_Float_ToWord16(42.0F) = 0x%04"PRIx16"U\n", __result);
}

void fromFP_Float_ToWord32_driver(void)
{
  const SWord32 __result = fromFP_Float_ToWord32(42.0F);

  printf("fromFP_Float_ToWord32(42.0F) = 0x%08"PRIx32"UL\n", __result);
}

void fromFP_Float_ToWord64_driver(void)
{
  const SWord64 __result = fromFP_Float_ToWord64(42.0F);

  printf("fromFP_Float_ToWord64(42.0F) = 0x%016"PRIx64"ULL\n", __result);
}

void fromFP_Float_ToFloat_driver(void)
{
  const SFloat __result = fromFP_Float_ToFloat(42.0F);

  printf("fromFP_Float_ToFloat(42.0F) = %.6g\n", __result);
}

void fromFP_Float_ToDouble_driver(void)
{
  const SDouble __result = fromFP_Float_ToDouble(42.0F);

  printf("fromFP_Float_ToDouble(42.0F) = %.15g\n", __result);
}

void fromFP_Float_ToInteger_driver(void)
{
  const SInteger __result = fromFP_Float_ToInteger(42.0F);

  printf("fromFP_Float_ToInteger(42.0F) = %"PRId64"LL\n", __result);
}

void fromFP_Float_ToReal_driver(void)
{
  const SReal __result = fromFP_Float_ToReal(42.0F);

  printf("fromFP_Float_ToReal(42.0F) = %Lf\n", __result);
}

void fromFP_DoubleTo_Int8_driver(void)
{
  const SInt8 __result = fromFP_DoubleTo_Int8(42.0);

  printf("fromFP_DoubleTo_Int8(42.0) = %"PRId8"\n", __result);
}

void fromFP_DoubleTo_Int16_driver(void)
{
  const SInt16 __result = fromFP_DoubleTo_Int16(42.0);

  printf("fromFP_DoubleTo_Int16(42.0) = %"PRId16"\n", __result);
}

void fromFP_DoubleTo_Int32_driver(void)
{
  const SInt32 __result = fromFP_DoubleTo_Int32(42.0);

  printf("fromFP_DoubleTo_Int32(42.0) = %"PRId32"L\n", __result);
}

void fromFP_DoubleTo_Int64_driver(void)
{
  const SInt64 __result = fromFP_DoubleTo_Int64(42.0);

  printf("fromFP_DoubleTo_Int64(42.0) = %"PRId64"LL\n", __result);
}

void fromFP_DoubleTo_Word8_driver(void)
{
  const SWord8 __result = fromFP_DoubleTo_Word8(42.0);

  printf("fromFP_DoubleTo_Word8(42.0) = %"PRIu8"\n", __result);
}

void fromFP_DoubleTo_Word16_driver(void)
{
  const SWord16 __result = fromFP_DoubleTo_Word16(42.0);

  printf("fromFP_DoubleTo_Word16(42.0) = 0x%04"PRIx16"U\n", __result);
}

void fromFP_DoubleTo_Word32_driver(void)
{
  const SWord32 __result = fromFP_DoubleTo_Word32(42.0);

  printf("fromFP_DoubleTo_Word32(42.0) = 0x%08"PRIx32"UL\n", __result);
}

void fromFP_DoubleTo_Word64_driver(void)
{
  const SWord64 __result = fromFP_DoubleTo_Word64(42.0);

  printf("fromFP_DoubleTo_Word64(42.0) = 0x%016"PRIx64"ULL\n", __result);
}

void fromFP_DoubleTo_Float_driver(void)
{
  const SFloat __result = fromFP_DoubleTo_Float(42.0);

  printf("fromFP_DoubleTo_Float(42.0) = %.6g\n", __result);
}

void fromFP_DoubleTo_Double_driver(void)
{
  const SDouble __result = fromFP_DoubleTo_Double(42.0);

  printf("fromFP_DoubleTo_Double(42.0) = %.15g\n", __result);
}

void fromFP_DoubleTo_Integer_driver(void)
{
  const SInteger __result = fromFP_DoubleTo_Integer(42.0);

  printf("fromFP_DoubleTo_Integer(42.0) = %"PRId64"LL\n", __result);
}

void fromFP_DoubleTo_Real_driver(void)
{
  const SReal __result = fromFP_DoubleTo_Real(42.0);

  printf("fromFP_DoubleTo_Real(42.0) = %Lf\n", __result);
}

void fromFP_SWord32_SFloat_driver(void)
{
  const SFloat __result = fromFP_SWord32_SFloat(0x0000002aUL);

  printf("fromFP_SWord32_SFloat(0x0000002aUL) = %.6g\n", __result);
}

void fromFP_SWord64_SDouble_driver(void)
{
  const SDouble __result = fromFP_SWord64_SDouble(0x000000000000002aULL);

  printf("fromFP_SWord64_SDouble(0x000000000000002aULL) = %.15g\n", __result);
}

void fromFP_SFloat_SWord32_driver(void)
{
  const SWord32 __result = fromFP_SFloat_SWord32(42.0F);

  printf("fromFP_SFloat_SWord32(42.0F) = 0x%08"PRIx32"UL\n", __result);
}

void fromFP_SDouble_SWord64_driver(void)
{
  const SWord64 __result = fromFP_SDouble_SWord64(42.0);

  printf("fromFP_SDouble_SWord64(42.0) = 0x%016"PRIx64"ULL\n", __result);
}

void f_FP_Abs_driver(void)
{
  const SFloat __result = f_FP_Abs(42.0F);

  printf("f_FP_Abs(42.0F) = %.6g\n", __result);
}

void d_FP_Abs_driver(void)
{
  const SDouble __result = d_FP_Abs(42.0);

  printf("d_FP_Abs(42.0) = %.15g\n", __result);
}

void f_FP_Neg_driver(void)
{
  const SFloat __result = f_FP_Neg(42.0F);

  printf("f_FP_Neg(42.0F) = %.6g\n", __result);
}

void d_FP_Neg_driver(void)
{
  const SDouble __result = d_FP_Neg(42.0);

  printf("d_FP_Neg(42.0) = %.15g\n", __result);
}

void f_FP_Add_driver(void)
{
  const SFloat __result = f_FP_Add(42.0F, 43.0F);

  printf("f_FP_Add(42.0F, 43.0F) = %.6g\n", __result);
}

void d_FP_Add_driver(void)
{
  const SDouble __result = d_FP_Add(42.0, 43.0);

  printf("d_FP_Add(42.0, 43.0) = %.15g\n", __result);
}

void f_FP_Sub_driver(void)
{
  const SFloat __result = f_FP_Sub(42.0F, 43.0F);

  printf("f_FP_Sub(42.0F, 43.0F) = %.6g\n", __result);
}

void d_FP_Sub_driver(void)
{
  const SDouble __result = d_FP_Sub(42.0, 43.0);

  printf("d_FP_Sub(42.0, 43.0) = %.15g\n", __result);
}

void f_FP_Mul_driver(void)
{
  const SFloat __result = f_FP_Mul(42.0F, 43.0F);

  printf("f_FP_Mul(42.0F, 43.0F) = %.6g\n", __result);
}

void d_FP_Mul_driver(void)
{
  const SDouble __result = d_FP_Mul(42.0, 43.0);

  printf("d_FP_Mul(42.0, 43.0) = %.15g\n", __result);
}

void f_FP_Div_driver(void)
{
  const SFloat __result = f_FP_Div(42.0F, 43.0F);

  printf("f_FP_Div(42.0F, 43.0F) = %.6g\n", __result);
}

void d_FP_Div_driver(void)
{
  const SDouble __result = d_FP_Div(42.0, 43.0);

  printf("d_FP_Div(42.0, 43.0) = %.15g\n", __result);
}

void f_FP_FMA_driver(void)
{
  const SFloat __result = f_FP_FMA(42.0F, 43.0F, 44.0F);

  printf("f_FP_FMA(42.0F, 43.0F, 44.0F) = %.6g\n", __result);
}

void d_FP_FMA_driver(void)
{
  const SDouble __result = d_FP_FMA(42.0, 43.0, 44.0);

  printf("d_FP_FMA(42.0, 43.0, 44.0) = %.15g\n", __result);
}

void f_FP_Sqrt_driver(void)
{
  const SFloat __result = f_FP_Sqrt(42.0F);

  printf("f_FP_Sqrt(42.0F) = %.6g\n", __result);
}

void d_FP_Sqrt_driver(void)
{
  const SDouble __result = d_FP_Sqrt(42.0);

  printf("d_FP_Sqrt(42.0) = %.15g\n", __result);
}

void f_FP_Rem_driver(void)
{
  const SFloat __result = f_FP_Rem(42.0F, 43.0F);

  printf("f_FP_Rem(42.0F, 43.0F) = %.6g\n", __result);
}

void d_FP_Rem_driver(void)
{
  const SDouble __result = d_FP_Rem(42.0, 43.0);

  printf("d_FP_Rem(42.0, 43.0) = %.15g\n", __result);
}

void f_FP_RoundToIntegral_driver(void)
{
  const SFloat __result = f_FP_RoundToIntegral(42.0F);

  printf("f_FP_RoundToIntegral(42.0F) = %.6g\n", __result);
}

void d_FP_RoundToIntegral_driver(void)
{
  const SDouble __result = d_FP_RoundToIntegral(42.0);

  printf("d_FP_RoundToIntegral(42.0) = %.15g\n", __result);
}

void f_FP_Min_driver(void)
{
  const SFloat __result = f_FP_Min(42.0F, 43.0F);

  printf("f_FP_Min(42.0F, 43.0F) = %.6g\n", __result);
}

void d_FP_Min_driver(void)
{
  const SDouble __result = d_FP_Min(42.0, 43.0);

  printf("d_FP_Min(42.0, 43.0) = %.15g\n", __result);
}

void f_FP_Max_driver(void)
{
  const SFloat __result = f_FP_Max(42.0F, 43.0F);

  printf("f_FP_Max(42.0F, 43.0F) = %.6g\n", __result);
}

void d_FP_Max_driver(void)
{
  const SDouble __result = d_FP_Max(42.0, 43.0);

  printf("d_FP_Max(42.0, 43.0) = %.15g\n", __result);
}

void f_FP_IsEqualObject_driver(void)
{
  const SBool __result = f_FP_IsEqualObject(42.0F, 43.0F);

  printf("f_FP_IsEqualObject(42.0F, 43.0F) = %d\n", __result);
}

void d_FP_IsEqualObject_driver(void)
{
  const SBool __result = d_FP_IsEqualObject(42.0, 43.0);

  printf("d_FP_IsEqualObject(42.0, 43.0) = %d\n", __result);
}

void f_FP_IsNormal_driver(void)
{
  const SBool __result = f_FP_IsNormal(42.0F);

  printf("f_FP_IsNormal(42.0F) = %d\n", __result);
}

void d_FP_IsNormal_driver(void)
{
  const SBool __result = d_FP_IsNormal(42.0);

  printf("d_FP_IsNormal(42.0) = %d\n", __result);
}

void f_FP_IsZero_driver(void)
{
  const SBool __result = f_FP_IsZero(42.0F);

  printf("f_FP_IsZero(42.0F) = %d\n", __result);
}

void d_FP_IsZero_driver(void)
{
  const SBool __result = d_FP_IsZero(42.0);

  printf("d_FP_IsZero(42.0) = %d\n", __result);
}

void f_FP_IsSubnormal_driver(void)
{
  const SBool __result = f_FP_IsSubnormal(42.0F);

  printf("f_FP_IsSubnormal(42.0F) = %d\n", __result);
}

void d_FP_IsSubnormal_driver(void)
{
  const SBool __result = d_FP_IsSubnormal(42.0);

  printf("d_FP_IsSubnormal(42.0) = %d\n", __result);
}

void f_FP_IsInfinite_driver(void)
{
  const SBool __result = f_FP_IsInfinite(42.0F);

  printf("f_FP_IsInfinite(42.0F) = %d\n", __result);
}

void d_FP_IsInfinite_driver(void)
{
  const SBool __result = d_FP_IsInfinite(42.0);

  printf("d_FP_IsInfinite(42.0) = %d\n", __result);
}

void f_FP_IsNaN_driver(void)
{
  const SBool __result = f_FP_IsNaN(42.0F);

  printf("f_FP_IsNaN(42.0F) = %d\n", __result);
}

void d_FP_IsNaN_driver(void)
{
  const SBool __result = d_FP_IsNaN(42.0);

  printf("d_FP_IsNaN(42.0) = %d\n", __result);
}

void f_FP_IsNegative_driver(void)
{
  const SBool __result = f_FP_IsNegative(42.0F);

  printf("f_FP_IsNegative(42.0F) = %d\n", __result);
}

void d_FP_IsNegative_driver(void)
{
  const SBool __result = d_FP_IsNegative(42.0);

  printf("d_FP_IsNegative(42.0) = %d\n", __result);
}

void f_FP_IsPositive_driver(void)
{
  const SBool __result = f_FP_IsPositive(42.0F);

  printf("f_FP_IsPositive(42.0F) = %d\n", __result);
}

void d_FP_IsPositive_driver(void)
{
  const SBool __result = d_FP_IsPositive(42.0);

  printf("d_FP_IsPositive(42.0) = %d\n", __result);
}

int main(void)
{
  printf("====================================\n");
  printf("** Driver run for toFP_Int8_ToFloat:\n");
  printf("====================================\n");
  toFP_Int8_ToFloat_driver();

  printf("=====================================\n");
  printf("** Driver run for toFP_Int16_ToFloat:\n");
  printf("=====================================\n");
  toFP_Int16_ToFloat_driver();

  printf("=====================================\n");
  printf("** Driver run for toFP_Int32_ToFloat:\n");
  printf("=====================================\n");
  toFP_Int32_ToFloat_driver();

  printf("=====================================\n");
  printf("** Driver run for toFP_Int64_ToFloat:\n");
  printf("=====================================\n");
  toFP_Int64_ToFloat_driver();

  printf("=====================================\n");
  printf("** Driver run for toFP_Word8_ToFloat:\n");
  printf("=====================================\n");
  toFP_Word8_ToFloat_driver();

  printf("======================================\n");
  printf("** Driver run for toFP_Word16_ToFloat:\n");
  printf("======================================\n");
  toFP_Word16_ToFloat_driver();

  printf("======================================\n");
  printf("** Driver run for toFP_Word32_ToFloat:\n");
  printf("======================================\n");
  toFP_Word32_ToFloat_driver();

  printf("======================================\n");
  printf("** Driver run for toFP_Word64_ToFloat:\n");
  printf("======================================\n");
  toFP_Word64_ToFloat_driver();

  printf("=====================================\n");
  printf("** Driver run for toFP_Float_ToFloat:\n");
  printf("=====================================\n");
  toFP_Float_ToFloat_driver();

  printf("======================================\n");
  printf("** Driver run for toFP_Double_ToFloat:\n");
  printf("======================================\n");
  toFP_Double_ToFloat_driver();

  printf("=======================================\n");
  printf("** Driver run for toFP_Integer_ToFloat:\n");
  printf("=======================================\n");
  toFP_Integer_ToFloat_driver();

  printf("====================================\n");
  printf("** Driver run for toFP_Real_ToFloat:\n");
  printf("====================================\n");
  toFP_Real_ToFloat_driver();

  printf("=====================================\n");
  printf("** Driver run for toFP_Int8_ToDouble:\n");
  printf("=====================================\n");
  toFP_Int8_ToDouble_driver();

  printf("======================================\n");
  printf("** Driver run for toFP_Int16_ToDouble:\n");
  printf("======================================\n");
  toFP_Int16_ToDouble_driver();

  printf("======================================\n");
  printf("** Driver run for toFP_Int32_ToDouble:\n");
  printf("======================================\n");
  toFP_Int32_ToDouble_driver();

  printf("======================================\n");
  printf("** Driver run for toFP_Int64_ToDouble:\n");
  printf("======================================\n");
  toFP_Int64_ToDouble_driver();

  printf("======================================\n");
  printf("** Driver run for toFP_Word8_ToDouble:\n");
  printf("======================================\n");
  toFP_Word8_ToDouble_driver();

  printf("=======================================\n");
  printf("** Driver run for toFP_Word16_ToDouble:\n");
  printf("=======================================\n");
  toFP_Word16_ToDouble_driver();

  printf("=======================================\n");
  printf("** Driver run for toFP_Word32_ToDouble:\n");
  printf("=======================================\n");
  toFP_Word32_ToDouble_driver();

  printf("=======================================\n");
  printf("** Driver run for toFP_Word64_ToDouble:\n");
  printf("=======================================\n");
  toFP_Word64_ToDouble_driver();

  printf("======================================\n");
  printf("** Driver run for toFP_Float_ToDouble:\n");
  printf("======================================\n");
  toFP_Float_ToDouble_driver();

  printf("=======================================\n");
  printf("** Driver run for toFP_Double_ToDouble:\n");
  printf("=======================================\n");
  toFP_Double_ToDouble_driver();

  printf("========================================\n");
  printf("** Driver run for toFP_Integer_ToDouble:\n");
  printf("========================================\n");
  toFP_Integer_ToDouble_driver();

  printf("=====================================\n");
  printf("** Driver run for toFP_Real_ToDouble:\n");
  printf("=====================================\n");
  toFP_Real_ToDouble_driver();

  printf("======================================\n");
  printf("** Driver run for fromFP_Float_ToInt8:\n");
  printf("======================================\n");
  fromFP_Float_ToInt8_driver();

  printf("=======================================\n");
  printf("** Driver run for fromFP_Float_ToInt16:\n");
  printf("=======================================\n");
  fromFP_Float_ToInt16_driver();

  printf("=======================================\n");
  printf("** Driver run for fromFP_Float_ToInt32:\n");
  printf("=======================================\n");
  fromFP_Float_ToInt32_driver();

  printf("=======================================\n");
  printf("** Driver run for fromFP_Float_ToInt64:\n");
  printf("=======================================\n");
  fromFP_Float_ToInt64_driver();

  printf("=======================================\n");
  printf("** Driver run for fromFP_Float_ToWord8:\n");
  printf("=======================================\n");
  fromFP_Float_ToWord8_driver();

  printf("========================================\n");
  printf("** Driver run for fromFP_Float_ToWord16:\n");
  printf("========================================\n");
  fromFP_Float_ToWord16_driver();

  printf("========================================\n");
  printf("** Driver run for fromFP_Float_ToWord32:\n");
  printf("========================================\n");
  fromFP_Float_ToWord32_driver();

  printf("========================================\n");
  printf("** Driver run for fromFP_Float_ToWord64:\n");
  printf("========================================\n");
  fromFP_Float_ToWord64_driver();

  printf("=======================================\n");
  printf("** Driver run for fromFP_Float_ToFloat:\n");
  printf("=======================================\n");
  fromFP_Float_ToFloat_driver();

  printf("========================================\n");
  printf("** Driver run for fromFP_Float_ToDouble:\n");
  printf("========================================\n");
  fromFP_Float_ToDouble_driver();

  printf("=========================================\n");
  printf("** Driver run for fromFP_Float_ToInteger:\n");
  printf("=========================================\n");
  fromFP_Float_ToInteger_driver();

  printf("======================================\n");
  printf("** Driver run for fromFP_Float_ToReal:\n");
  printf("======================================\n");
  fromFP_Float_ToReal_driver();

  printf("=======================================\n");
  printf("** Driver run for fromFP_DoubleTo_Int8:\n");
  printf("=======================================\n");
  fromFP_DoubleTo_Int8_driver();

  printf("========================================\n");
  printf("** Driver run for fromFP_DoubleTo_Int16:\n");
  printf("========================================\n");
  fromFP_DoubleTo_Int16_driver();

  printf("========================================\n");
  printf("** Driver run for fromFP_DoubleTo_Int32:\n");
  printf("========================================\n");
  fromFP_DoubleTo_Int32_driver();

  printf("========================================\n");
  printf("** Driver run for fromFP_DoubleTo_Int64:\n");
  printf("========================================\n");
  fromFP_DoubleTo_Int64_driver();

  printf("========================================\n");
  printf("** Driver run for fromFP_DoubleTo_Word8:\n");
  printf("========================================\n");
  fromFP_DoubleTo_Word8_driver();

  printf("=========================================\n");
  printf("** Driver run for fromFP_DoubleTo_Word16:\n");
  printf("=========================================\n");
  fromFP_DoubleTo_Word16_driver();

  printf("=========================================\n");
  printf("** Driver run for fromFP_DoubleTo_Word32:\n");
  printf("=========================================\n");
  fromFP_DoubleTo_Word32_driver();

  printf("=========================================\n");
  printf("** Driver run for fromFP_DoubleTo_Word64:\n");
  printf("=========================================\n");
  fromFP_DoubleTo_Word64_driver();

  printf("========================================\n");
  printf("** Driver run for fromFP_DoubleTo_Float:\n");
  printf("========================================\n");
  fromFP_DoubleTo_Float_driver();

  printf("=========================================\n");
  printf("** Driver run for fromFP_DoubleTo_Double:\n");
  printf("=========================================\n");
  fromFP_DoubleTo_Double_driver();

  printf("==========================================\n");
  printf("** Driver run for fromFP_DoubleTo_Integer:\n");
  printf("==========================================\n");
  fromFP_DoubleTo_Integer_driver();

  printf("=======================================\n");
  printf("** Driver run for fromFP_DoubleTo_Real:\n");
  printf("=======================================\n");
  fromFP_DoubleTo_Real_driver();

  printf("========================================\n");
  printf("** Driver run for fromFP_SWord32_SFloat:\n");
  printf("========================================\n");
  fromFP_SWord32_SFloat_driver();

  printf("=========================================\n");
  printf("** Driver run for fromFP_SWord64_SDouble:\n");
  printf("=========================================\n");
  fromFP_SWord64_SDouble_driver();

  printf("========================================\n");
  printf("** Driver run for fromFP_SFloat_SWord32:\n");
  printf("========================================\n");
  fromFP_SFloat_SWord32_driver();

  printf("=========================================\n");
  printf("** Driver run for fromFP_SDouble_SWord64:\n");
  printf("=========================================\n");
  fromFP_SDouble_SWord64_driver();

  printf("===========================\n");
  printf("** Driver run for f_FP_Abs:\n");
  printf("===========================\n");
  f_FP_Abs_driver();

  printf("===========================\n");
  printf("** Driver run for d_FP_Abs:\n");
  printf("===========================\n");
  d_FP_Abs_driver();

  printf("===========================\n");
  printf("** Driver run for f_FP_Neg:\n");
  printf("===========================\n");
  f_FP_Neg_driver();

  printf("===========================\n");
  printf("** Driver run for d_FP_Neg:\n");
  printf("===========================\n");
  d_FP_Neg_driver();

  printf("===========================\n");
  printf("** Driver run for f_FP_Add:\n");
  printf("===========================\n");
  f_FP_Add_driver();

  printf("===========================\n");
  printf("** Driver run for d_FP_Add:\n");
  printf("===========================\n");
  d_FP_Add_driver();

  printf("===========================\n");
  printf("** Driver run for f_FP_Sub:\n");
  printf("===========================\n");
  f_FP_Sub_driver();

  printf("===========================\n");
  printf("** Driver run for d_FP_Sub:\n");
  printf("===========================\n");
  d_FP_Sub_driver();

  printf("===========================\n");
  printf("** Driver run for f_FP_Mul:\n");
  printf("===========================\n");
  f_FP_Mul_driver();

  printf("===========================\n");
  printf("** Driver run for d_FP_Mul:\n");
  printf("===========================\n");
  d_FP_Mul_driver();

  printf("===========================\n");
  printf("** Driver run for f_FP_Div:\n");
  printf("===========================\n");
  f_FP_Div_driver();

  printf("===========================\n");
  printf("** Driver run for d_FP_Div:\n");
  printf("===========================\n");
  d_FP_Div_driver();

  printf("===========================\n");
  printf("** Driver run for f_FP_FMA:\n");
  printf("===========================\n");
  f_FP_FMA_driver();

  printf("===========================\n");
  printf("** Driver run for d_FP_FMA:\n");
  printf("===========================\n");
  d_FP_FMA_driver();

  printf("============================\n");
  printf("** Driver run for f_FP_Sqrt:\n");
  printf("============================\n");
  f_FP_Sqrt_driver();

  printf("============================\n");
  printf("** Driver run for d_FP_Sqrt:\n");
  printf("============================\n");
  d_FP_Sqrt_driver();

  printf("===========================\n");
  printf("** Driver run for f_FP_Rem:\n");
  printf("===========================\n");
  f_FP_Rem_driver();

  printf("===========================\n");
  printf("** Driver run for d_FP_Rem:\n");
  printf("===========================\n");
  d_FP_Rem_driver();

  printf("=======================================\n");
  printf("** Driver run for f_FP_RoundToIntegral:\n");
  printf("=======================================\n");
  f_FP_RoundToIntegral_driver();

  printf("=======================================\n");
  printf("** Driver run for d_FP_RoundToIntegral:\n");
  printf("=======================================\n");
  d_FP_RoundToIntegral_driver();

  printf("===========================\n");
  printf("** Driver run for f_FP_Min:\n");
  printf("===========================\n");
  f_FP_Min_driver();

  printf("===========================\n");
  printf("** Driver run for d_FP_Min:\n");
  printf("===========================\n");
  d_FP_Min_driver();

  printf("===========================\n");
  printf("** Driver run for f_FP_Max:\n");
  printf("===========================\n");
  f_FP_Max_driver();

  printf("===========================\n");
  printf("** Driver run for d_FP_Max:\n");
  printf("===========================\n");
  d_FP_Max_driver();

  printf("=====================================\n");
  printf("** Driver run for f_FP_IsEqualObject:\n");
  printf("=====================================\n");
  f_FP_IsEqualObject_driver();

  printf("=====================================\n");
  printf("** Driver run for d_FP_IsEqualObject:\n");
  printf("=====================================\n");
  d_FP_IsEqualObject_driver();

  printf("================================\n");
  printf("** Driver run for f_FP_IsNormal:\n");
  printf("================================\n");
  f_FP_IsNormal_driver();

  printf("================================\n");
  printf("** Driver run for d_FP_IsNormal:\n");
  printf("================================\n");
  d_FP_IsNormal_driver();

  printf("==============================\n");
  printf("** Driver run for f_FP_IsZero:\n");
  printf("==============================\n");
  f_FP_IsZero_driver();

  printf("==============================\n");
  printf("** Driver run for d_FP_IsZero:\n");
  printf("==============================\n");
  d_FP_IsZero_driver();

  printf("===================================\n");
  printf("** Driver run for f_FP_IsSubnormal:\n");
  printf("===================================\n");
  f_FP_IsSubnormal_driver();

  printf("===================================\n");
  printf("** Driver run for d_FP_IsSubnormal:\n");
  printf("===================================\n");
  d_FP_IsSubnormal_driver();

  printf("==================================\n");
  printf("** Driver run for f_FP_IsInfinite:\n");
  printf("==================================\n");
  f_FP_IsInfinite_driver();

  printf("==================================\n");
  printf("** Driver run for d_FP_IsInfinite:\n");
  printf("==================================\n");
  d_FP_IsInfinite_driver();

  printf("=============================\n");
  printf("** Driver run for f_FP_IsNaN:\n");
  printf("=============================\n");
  f_FP_IsNaN_driver();

  printf("=============================\n");
  printf("** Driver run for d_FP_IsNaN:\n");
  printf("=============================\n");
  d_FP_IsNaN_driver();

  printf("==================================\n");
  printf("** Driver run for f_FP_IsNegative:\n");
  printf("==================================\n");
  f_FP_IsNegative_driver();

  printf("==================================\n");
  printf("** Driver run for d_FP_IsNegative:\n");
  printf("==================================\n");
  d_FP_IsNegative_driver();

  printf("==================================\n");
  printf("** Driver run for f_FP_IsPositive:\n");
  printf("==================================\n");
  f_FP_IsPositive_driver();

  printf("==================================\n");
  printf("** Driver run for d_FP_IsPositive:\n");
  printf("==================================\n");
  d_FP_IsPositive_driver();

  return 0;
}
== END: "floatCodeGen_driver.c" ==================
== BEGIN: "Makefile" ================
# Makefile for floatCodeGen. Automatically generated by SBV. Do not edit!

# include any user-defined .mk file in the current directory.
-include *.mk

CC?=gcc
CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer
AR?=ar
ARFLAGS?=cr

all: floatCodeGen.a floatCodeGen_driver

floatCodeGen.a: toFP_Int8_ToFloat.o toFP_Int16_ToFloat.o toFP_Int32_ToFloat.o toFP_Int64_ToFloat.o toFP_Word8_ToFloat.o toFP_Word16_ToFloat.o toFP_Word32_ToFloat.o toFP_Word64_ToFloat.o toFP_Float_ToFloat.o toFP_Double_ToFloat.o toFP_Integer_ToFloat.o toFP_Real_ToFloat.o toFP_Int8_ToDouble.o toFP_Int16_ToDouble.o toFP_Int32_ToDouble.o toFP_Int64_ToDouble.o toFP_Word8_ToDouble.o toFP_Word16_ToDouble.o toFP_Word32_ToDouble.o toFP_Word64_ToDouble.o toFP_Float_ToDouble.o toFP_Double_ToDouble.o toFP_Integer_ToDouble.o toFP_Real_ToDouble.o fromFP_Float_ToInt8.o fromFP_Float_ToInt16.o fromFP_Float_ToInt32.o fromFP_Float_ToInt64.o fromFP_Float_ToWord8.o fromFP_Float_ToWord16.o fromFP_Float_ToWord32.o fromFP_Float_ToWord64.o fromFP_Float_ToFloat.o fromFP_Float_ToDouble.o fromFP_Float_ToInteger.o fromFP_Float_ToReal.o fromFP_DoubleTo_Int8.o fromFP_DoubleTo_Int16.o fromFP_DoubleTo_Int32.o fromFP_DoubleTo_Int64.o fromFP_DoubleTo_Word8.o fromFP_DoubleTo_Word16.o fromFP_DoubleTo_Word32.o fromFP_DoubleTo_Word64.o fromFP_DoubleTo_Float.o fromFP_DoubleTo_Double.o fromFP_DoubleTo_Integer.o fromFP_DoubleTo_Real.o fromFP_SWord32_SFloat.o fromFP_SWord64_SDouble.o fromFP_SFloat_SWord32.o fromFP_SDouble_SWord64.o f_FP_Abs.o d_FP_Abs.o f_FP_Neg.o d_FP_Neg.o f_FP_Add.o d_FP_Add.o f_FP_Sub.o d_FP_Sub.o f_FP_Mul.o d_FP_Mul.o f_FP_Div.o d_FP_Div.o f_FP_FMA.o d_FP_FMA.o f_FP_Sqrt.o d_FP_Sqrt.o f_FP_Rem.o d_FP_Rem.o f_FP_RoundToIntegral.o d_FP_RoundToIntegral.o f_FP_Min.o d_FP_Min.o f_FP_Max.o d_FP_Max.o f_FP_IsEqualObject.o d_FP_IsEqualObject.o f_FP_IsNormal.o d_FP_IsNormal.o f_FP_IsZero.o d_FP_IsZero.o f_FP_IsSubnormal.o d_FP_IsSubnormal.o f_FP_IsInfinite.o d_FP_IsInfinite.o f_FP_IsNaN.o d_FP_IsNaN.o f_FP_IsNegative.o d_FP_IsNegative.o f_FP_IsPositive.o d_FP_IsPositive.o
	${AR} ${ARFLAGS} $@ $^

floatCodeGen_driver: floatCodeGen_driver.c floatCodeGen.h
	${CC} ${CCFLAGS} $< -o $@ floatCodeGen.a

toFP_Int8_ToFloat.o: toFP_Int8_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Int16_ToFloat.o: toFP_Int16_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Int32_ToFloat.o: toFP_Int32_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Int64_ToFloat.o: toFP_Int64_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Word8_ToFloat.o: toFP_Word8_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Word16_ToFloat.o: toFP_Word16_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Word32_ToFloat.o: toFP_Word32_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Word64_ToFloat.o: toFP_Word64_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Float_ToFloat.o: toFP_Float_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Double_ToFloat.o: toFP_Double_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Integer_ToFloat.o: toFP_Integer_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Real_ToFloat.o: toFP_Real_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Int8_ToDouble.o: toFP_Int8_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Int16_ToDouble.o: toFP_Int16_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Int32_ToDouble.o: toFP_Int32_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Int64_ToDouble.o: toFP_Int64_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Word8_ToDouble.o: toFP_Word8_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Word16_ToDouble.o: toFP_Word16_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Word32_ToDouble.o: toFP_Word32_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Word64_ToDouble.o: toFP_Word64_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Float_ToDouble.o: toFP_Float_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Double_ToDouble.o: toFP_Double_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Integer_ToDouble.o: toFP_Integer_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

toFP_Real_ToDouble.o: toFP_Real_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_Float_ToInt8.o: fromFP_Float_ToInt8.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_Float_ToInt16.o: fromFP_Float_ToInt16.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_Float_ToInt32.o: fromFP_Float_ToInt32.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_Float_ToInt64.o: fromFP_Float_ToInt64.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_Float_ToWord8.o: fromFP_Float_ToWord8.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_Float_ToWord16.o: fromFP_Float_ToWord16.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_Float_ToWord32.o: fromFP_Float_ToWord32.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_Float_ToWord64.o: fromFP_Float_ToWord64.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_Float_ToFloat.o: fromFP_Float_ToFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_Float_ToDouble.o: fromFP_Float_ToDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_Float_ToInteger.o: fromFP_Float_ToInteger.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_Float_ToReal.o: fromFP_Float_ToReal.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_DoubleTo_Int8.o: fromFP_DoubleTo_Int8.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_DoubleTo_Int16.o: fromFP_DoubleTo_Int16.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_DoubleTo_Int32.o: fromFP_DoubleTo_Int32.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_DoubleTo_Int64.o: fromFP_DoubleTo_Int64.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_DoubleTo_Word8.o: fromFP_DoubleTo_Word8.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_DoubleTo_Word16.o: fromFP_DoubleTo_Word16.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_DoubleTo_Word32.o: fromFP_DoubleTo_Word32.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_DoubleTo_Word64.o: fromFP_DoubleTo_Word64.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_DoubleTo_Float.o: fromFP_DoubleTo_Float.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_DoubleTo_Double.o: fromFP_DoubleTo_Double.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_DoubleTo_Integer.o: fromFP_DoubleTo_Integer.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_DoubleTo_Real.o: fromFP_DoubleTo_Real.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_SWord32_SFloat.o: fromFP_SWord32_SFloat.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_SWord64_SDouble.o: fromFP_SWord64_SDouble.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_SFloat_SWord32.o: fromFP_SFloat_SWord32.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

fromFP_SDouble_SWord64.o: fromFP_SDouble_SWord64.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_Abs.o: f_FP_Abs.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_Abs.o: d_FP_Abs.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_Neg.o: f_FP_Neg.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_Neg.o: d_FP_Neg.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_Add.o: f_FP_Add.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_Add.o: d_FP_Add.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_Sub.o: f_FP_Sub.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_Sub.o: d_FP_Sub.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_Mul.o: f_FP_Mul.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_Mul.o: d_FP_Mul.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_Div.o: f_FP_Div.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_Div.o: d_FP_Div.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_FMA.o: f_FP_FMA.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_FMA.o: d_FP_FMA.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_Sqrt.o: f_FP_Sqrt.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_Sqrt.o: d_FP_Sqrt.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_Rem.o: f_FP_Rem.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_Rem.o: d_FP_Rem.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_RoundToIntegral.o: f_FP_RoundToIntegral.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_RoundToIntegral.o: d_FP_RoundToIntegral.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_Min.o: f_FP_Min.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_Min.o: d_FP_Min.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_Max.o: f_FP_Max.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_Max.o: d_FP_Max.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_IsEqualObject.o: f_FP_IsEqualObject.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_IsEqualObject.o: d_FP_IsEqualObject.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_IsNormal.o: f_FP_IsNormal.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_IsNormal.o: d_FP_IsNormal.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_IsZero.o: f_FP_IsZero.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_IsZero.o: d_FP_IsZero.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_IsSubnormal.o: f_FP_IsSubnormal.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_IsSubnormal.o: d_FP_IsSubnormal.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_IsInfinite.o: f_FP_IsInfinite.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_IsInfinite.o: d_FP_IsInfinite.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_IsNaN.o: f_FP_IsNaN.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_IsNaN.o: d_FP_IsNaN.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_IsNegative.o: f_FP_IsNegative.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_IsNegative.o: d_FP_IsNegative.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

f_FP_IsPositive.o: f_FP_IsPositive.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

d_FP_IsPositive.o: d_FP_IsPositive.c floatCodeGen.h
	${CC} ${CCFLAGS} -c $< -o $@

clean:
	rm -f *.o

veryclean: clean
	rm -f floatCodeGen.a floatCodeGen_driver
== END: "Makefile" ==================