/*
 *  Classified Tydeman Consulting Proprietary
 *  Copyright (C) 1994, 2009 Tydeman Consulting.  All rights reserved.
 *
 *  Fred Tydeman	tydeman@tybor.com
 *
 * - -- --- ---- ----- -------------------------------------------------
 *
 *    We wish to acknowledge Taligent, Inc., for their support of this
 *	   test suite.  Taligent was early to recognize
 *	   the value and need for a comprehensive test suite of the
 *	   floating point support in C compilers.  Taligent funded the
 *	   original version of this test suite, and has graciously
 *	   released it to us to allow continued extensions and to
 *	   promote wider compliance with the ANSI C Floating-Point
 *	   C Extensions (FPCE).
 *
 *    This code is copyrighted.  Under the copyright laws, this code may
 *         not be copied, in whole or part, without prior written
 *         consent of Tydeman Consulting.
 *
 *    RESTRICTED RIGHTS LEGEND: Use, duplication, or disclosure by the
 *         government is subject to restrictions as set forth in
 *         subparagraph (c)(1)(ii) of the Rights in Technical Data and
 *         Computer Software clause at DFARS 252.227-7013 and
 *         FAR 52.227-19.
 *
 *    TRADEMARKS: Taligent and the Taligent Design Mark are registered
 *         trademarks of Taligent, Inc.
 *
 * - -- --- ---- ----- -------------------------------------------------
 * $Revision: 2.1 $
 ***********************************************************************
 *  FILE: myfloat.h
 *
 *  Description:  Translation time defines of <float.h> equivalents that
 *  will be usable in static initializaion and in #if's.
 *
 *  This is needed since <float.h> defines are NOT guaranteed to be
 *  usable in #if.  It is assumed that myfloat.h is the last #include.
 *  This file must NOT include <float.h>, otherwise the testing for
 *  FLT_EVAL_METHOD (was _MIN_EVAL_FORMAT) will be wrong.
 *
 *  If the values in <float.h> are suitable for use in #if and/or static
 *  initializaion, then you may use those values here.  If you do not
 *  care about the tests of FLT_EVAL_METHOD being in <float.h>, then
 *  you may include <float.h> here.  It is best if the values defined
 *  in this file are done in terms of exact FPCE hex floating-point,
 *  instead of inexact decimal approximations.
 *
 *  This file also defines equivalents of <limits.h>, but in terms of BITS
 *  of precision, instead of ranges.  If an unsigned type has 16 bits of
 *  precision, then the signed type has 1 sign bit and 15 bits of precision.
 *  That is, the signed types have one less bit of precision then do the
 *  corresponding unsigned types.
 *
 *  Not all test cases include this file.  Therefore, if something is needed
 *  by all test cases, it must go in mydefs.h or your *.bug file
 *
 *
 *  One each of a hardware symbolic and a software symbolic are assumed to
 *  be defined by the compiler, compiler options, or the 'make' facility.
 *
 *  May also need a symbolic for the operating system since Gnu gcc has
 *  been ported to different operating systems on the same hardware (such
 *  as, DOS, Windows 3.x, Windows 95, Windows NT, OS/2, Linux on x86).
 *
 *  Hardware symbolics:
 *	DO_106_113	Lint/compile 64-106-113 on X86 development system
 *	FPCE_SAMPLE	Sample FPCE tests to get sample.bug, sample.flt
 *	FENV_MISSING	Gets sample3.bug, sample.flt for missing <fenv.h>
 *	__arm__		ARM
 *	_CRAYIEEE	Cray Research with IEEE hardware
 *	_M_ALPHA	DEC Alpha
 *	__hppa		Hewlett Packard Precision Architecture RISC platform
 *	__POWERPC__	IBM Power PC platform (Apple Mac)
 *	__PPC__		IBM Power PC platform
 *	_M_MPPC		IBM Power PC platform
 *	_IBMR2		IBM POWER RISC platform
 *	__X86__		Intel 80x86 platform with 80x87 floating-point chip
 *	__I86__		Intel 80x86 platform with 80x87 floating-point chip
 *	_M_I386		Intel 80x86 platform with 80x87 floating-point chip
 *	_M_IX86		Intel 80x86 platform with 80x87 floating-point chip
 *	__i386__	Intel 80x86 platform with 80x87 floating-point chip
 *	__i386		Intel 80x86 platform with 80x87 floating-point chip
 *	__ia64		Intel Arch. 64-bit platform (Itanium)
 *	_M_MRX000	MIPS Rx000
 *	__68K__		Motorola 680x0 platform with 6888x floating-point chip
 *	_M_M68K		Motorola 680x0 platform with 6888x floating-point chip
 *	__mcore		Motorola M-CORE
 *	__rce		Motorola M-CORE
 *	__sparc		Sun Sparc
 *	__sparcv9	Sun Sparc in 64-bit mode
 *
 *  Operating system symbolics:
 *	_MAC			Apple MAC OS
 *	__APPLE__		Apple MAC OS
 *	__MACH__		Apple MAC OS X
 *	__hpux			HP Unix
 *	__HOS_MVS__		IBM MVS host compiler is running on OS/390
 *	__TOS_MVS__		IBM MVS target generated code is for OS/390
 *	__linux__		Linux
 *	_NTSDK			MicroSoft NT
 *	_WIN32			MS Windows in 32-bit mode (3.1/95/98/NT ?)
 *	_POSIX_			POSIX
 *	__unix			Unix
 *
 *  Software symbolics:
 *	__APPLE_CC__		Apple CC
 *	__TURBOC__		Borland Turbo C 2.01 (1988) compiler
 *	__BORLANDC__		Borland C/C++ 4 compiler
 *	__COMO__		Comeau Computing
 *	__DCC__			Diab Data C cross compiler
 *	__EDG__			Edison Design Group
 *	__GNUC__		GNU C/C++
 *	__EMX__			GNU C/C++ + emx extensions for OS/2
 *	__IBMC__		IBM C Set or VisualAge compiler, C mode
 *	__IBMCPP__		IBM C Set or VisualAge compiler, C++ mode
 *	__xlc			IBM xlc C compiler
 *	__XLCPP			IBM xlC C/C++ compiler
 *	__ICC			Intel ICC
 *	__LCC__			LCC
 *	__LMPCC__		Lund
 *	_MSC_VER		Microsoft C/C++ 4.0 compiler
 *	__sun			Sun C compiler
 *	__SC__			Symantec C/C++ 7.0 compiler
 *	__TaligentC__		Taligent CompTech C/C++ compiler, C mode
 *	__TaligentCPlusPlus__	Taligent CompTech C/C++ compiler, C++ mode
 *	__TANDEM		Tandem
 *	__WATCOMC__		Watcom
 *
 *  To add a new system (hardware and software combination), add another
 *	#elif (defined hardware) && (defined software)
 *  section.  Each section needs to define:
 *
 *	PBF_SIGNED
 *		Define if Plain Bit Fields are signed or unsigned.
 *			  0 = unsigned
 *			  1 = signed
 *
 *	PC_PREC
 *		Define number of BITS in a plain char.
 *		Supported values are:
 *			  7+ = min required by Standard C for signed
 *			  8+ = min required by Standard C for unsigned
 *
 *	SC_PREC
 *		Define number of BITS in a signed char.
 *		Supported values are:
 *			  7+ = min required by Standard C
 *
 *	UC_PREC
 *		Define number of BITS in an unsigned char.
 *		Supported values are:
 *			  8+ = min required by Standard C
 *
 *	SSI_PREC
 *		Define number of BITS in a signed short int.
 *		Supported values are:
 *			 15+ = min required by Standard C
 *
 *	USI_PREC
 *		Define number of BITS in an unsigned short int.
 *		Supported values are:
 *			 16+ = min required by Standard C
 *
 *	SI_PREC
 *		Define number of BITS in a signed int.
 *		Supported values are:
 *			 15+ = min required by Standard C
 *			 31+ = most big machines
 *
 *	UI_PREC
 *		Define number of BITS in an unsigned int.
 *		Supported values are:
 *			 16+ = min required by Standard C
 *			 32+ = most big machines
 *
 *	SLI_PREC
 *		Define number of BITS in a signed long int.
 *		Supported values are:
 *			 31+ = min required by Standard C
 *
 *	ULI_PREC
 *		Define number of BITS in an unsigned long int.
 *		Supported values are:
 *			 32+ = min required by Standard C
 *
 *	SLLI_PREC
 *		Define number of BITS in a signed long long int.
 *		Supported values are:
 *			  0 = not supported
 *			 63+ = common extension to C; required in C99
 *
 *	ULLI_PREC
 *		Define number of BITS in an unsigned long long int.
 *		Supported values are:
 *			  0 = not supported
 *			 64+ = common extension to C; required in C99
 *
 *	BOOL_PREC
 *		Smaller of number of BITS in a _Bool and maximum number
 *		of bits in a bool bit-field.  Most likely, 1 or CHAR_BIT.
 *		Limits size of bool bit-fields (gcc limit is 1).
 *		Supported values are:
 *			  0 = not supported
 *			 1+ = (min required by C99 might be 8).
 *
 *	F_PREC
 *		Define number of significand BITS in a float.
 *		Supported values are:
 *			 24 = IEEE-754 single
 *
 *	D_PREC
 *		Define number of significand BITS in a double.
 *		Supported values are:
 *			 53 = IEEE-754 double
 *
 *	LD_PREC
 *		Define number of significand BITS in a long double.
 *		Supported values are:
 *			 53 = IEEE-754 double
 *			 64 = Intel 80x87, Motorola 6888x
 *			106 = IBM PowerPC double-double
 *			113 = Hewlett Packard Precision Arch
 *
 *	LD_WIDER_EXP
 *		Does the long double type support a wider exponent range
 *		than double?
 *			0 = No	(like IBM Power PC double-double, or S/360)
 *			1 = Yes
 *
 *	LD_REG_PREC
 *		Define number of significand BITS in a long double in a
 *		register.  This is needed for systems that have registers
 *		that are wider than variables.  For FPCE compliant systems,
 *		it is the same as LD_PREC (see test t0130000).
 *		Supported values are:
 *			 LD_PREC = normal system
 *			 64 = Intel 80x87, Motorola 6888x with LD_PREC=53
 *				That is, compiler has long double be the
 *				same as double, and not what the hardware
 *				is capable of doing.
 *
 *	REG_WIDER_EXP
 *		Do registers support a wider exponent range than long
 *		double?
 *			0 = No	(normal case)
 *			1 = Yes (like Intel x87 set to less than full prec)
 *
 *	LD_IEEE
 *		Is the long double type an IEEE-754 extended type?
 *			0 = No
 *			1 = Yes
 *
 *	F10_PREC
 *		Define number of significand DIGITS in a decimal float.
 *		Supported values are:
 *			 7 = IEEE-754R decimal single
 *
 *	D10_PREC
 *		Define number of significand DIGITS in a decimal double.
 *		Supported values are:
 *			 16 = IEEE-754R decimal double
 *
 *	LD10_PREC
 *		Define number of significand DIGITS in a decimal long double.
 *		Supported values are:
 *			 34 = IEEE-754R decimal quad
 *
 *	LD10_WIDER_EXP
 *		Does the decimal long double type support a wider exponent range
 *		than decimal double?
 *			0 = No	(for fake DFP on some BFP systems)
 *			1 = Yes (for true IEEE 754-2008 DFP)
 *
 *	LD10_REG_PREC
 *		Define number of significand DIGITS in a decimal long double in a
 *		register.  This is needed for systems that have registers
 *		that are wider than variables.
 *		Supported values are:
 *			 34 = IEEE-754R decimal quad
 *
 *	REG10_WIDER_EXP
 *		Do registers support a wider exponent range than decimal long
 *		double?
 *			0 = No	(normal case)
 *			1 = Yes
 *
 *	IMPL_INEXACT_ON_F2I	FLT/DBL/LDBL to I
 *	IMPL_INEXACT_ON_F102I	F10/D10/LD10 to I
 *		Does an inexact in-range floating to integral raise inexact?
 *			0 = No
 *			1 = Yes
 *			2 = Random (do not check)
 *
 *	FMT_F_DEC
 *		printf format for a float as decimal
 *
 *	FMT_F_HEX
 *		printf format for a float as hex (via hex_f(), prt_flt())
 *
 *	FMT_D_DEC
 *		printf format for a double as decimal
 *
 *	FMT_D_HEX
 *		printf format for a double as hex (via hex_d(), prt_dbl())
 *
 *	FMT_LD_DEC
 *		printf format for a long double as decimal
 *
 *	FMT_LD_HEX
 *		printf format for a long double as hex (via hex_ld(), prt_ldbl())
 *
 *	FMT_F10_DEC
 *		printf format for a decimal float as decimal
 *
 *	FMT_F10_HEX
 *		printf format for a decimal float as hex (via hex_f10(), prt_f10())
 *
 *	FMT_D10_DEC
 *		printf format for a decimal double as decimal
 *
 *	FMT_D10_HEX
 *		printf format for a decimal double as hex (via hex_d10(), prt_d10())
 *
 *	FMT_LD10_DEC
 *		printf format for a decimal long double as decimal
 *
 *	FMT_LD10_HEX
 *		printf format for a decimal long double as hex (via hex_ld10(), prt_ld10())
 *
 *	SIZ_FLT
 *		True size of FLT in bytes.  Default is sizeof(FLT)
 *
 *	SIZ_DBL
 *		True size of DBL in bytes.  Default is sizeof(DBL)
 *
 *	SIZ_LDBL
 *		True size of LDBL in bytes.  Default is sizeof(LDBL)
 *
 *	SIZ_F10
 *		True size of F10 in bytes.  Default is sizeof(F10)
 *
 *	SIZ_D10
 *		True size of D10 in bytes.  Default is sizeof(D10)
 *
 *	SIZ_LD10
 *		True size of LD10 in bytes.  Default is sizeof(LD10)
 *
 *	IMPL_REMQUO_BITS
 *		Number of bits remquo() uses in the quotient.  Default is 3.
 *
 *	IMPL_INF_FLAGS
 *		What flags are raised by INF_type?  Three choices:
 *		#undef				if INF_type are 1.0e99999 (quiet)
 *		(FE_DIVBYZERO)			if INF_type are 1.0/0.0
 *		(FE_OVERFLOW|FE_INEXACT)	if INF_type are MAX*MAX
 *		#define FIX_QUIET_INF for the latter two cases,
 *		#undef  FIX_QUIET_INF for the first case.
 *
 *	IMPL_NAN_FLAGS
 *		What flags are raised by NAN_type?  Two choices:
 *		#undef				if NAN_type are quiet
 *		(FE_INVALID)			if NAN_type are 0.0/0.0
 *
 *	For each type float (FLT), double (DBL), and long double (LDBL),
 *	and decimal FP float (F10), double (D10), and long double (LD10):
 *
 *	NAN_type	= NaN, usable in initialization; should be positive.
 *			  Should be consistent with NAN for sign.
 *	INF_type	= Infinity, usable in initialization; shoule be positive.
 *	MAX_type	= Maximum normal number
 *	MAXm1_type	= Maximum normal number - 1 ulp of MAX
 *	MIN_type	= Minimum normal number
 *	DEN_type	= Minimum denormal number.	Nextafter(0.,1.)
 *	ULP_type	= Unit in the Last Place of the value 1.0 (epsilon)
 *	ONEp1_type	= 1.0 + 1 ulp.			Nextafter(1.,2.)
 *	ONEm1_type	= 1.0 - 1 ulp/FLT_RADIX.	Nextafter(1.,0.)
 *	TRD_D_type	= 1.0/3.0, rounded down
 *	TRD_U_type	= 1.0/3.0, rounded up
 *
 *	Some sample definitions follow.  You should use these or sample.flt
 *	as a starting point when you create you own definitions.
 *
 *	IEEE 24-bit as decimal
 *
 *	#define NAN_FLT		(ZERO_FLT/ZERO_FLT)
 *	#define INF_FLT		1.0e+99999f
 *	#define MAX_FLT		3.402823466385288599e+38f
 *	#define MAXm1_FLT	3.402823263561192562e+38f
 *	#define MIN_FLT		1.175494350822287508e-38f
 *	#define DEN_FLT		1.401298464324817071e-45f
 *	#define ULP_FLT		1.192092895507812500e-07f
 *	#define ONEp1_FLT	1.000000119209289551f
 *	#define ONEm1_FLT	0.9999999403953552246f
 *	#define TRD_D_FLT	0.3333333134651184082f
 *	#define TRD_U_FLT	0.3333333432674407959f
 *
 *	#define NAN_F10		(0.0df/0.0df)
 *	#define INF_F10		1.0e+99999df
 *	#define MAX_F10		9.999999e+96df
 *	#define MAXm1_F10	9.999998e+96df
 *	#define MIN_F10		1.000000e-95df
 *	#define DEN_F10		1.000000e-101df
 *	#define ULP_F10		1.000000e-06df
 *	#define ONEp1_F10	1.000001df
 *	#define ONEm1_F10	0.9999999df
 *	#define TRD_D_F10	0.3333333df
 *	#define TRD_U_F10	0.3333334df
 *
 *	IEEE 24-bit as FPCE hex FP
 *
 *	#define NAN_FLT		(ZERO_FLT/ZERO_FLT)
 *	#define INF_FLT		0x1.000000p+16384f
 *	#define MAX_FLT		0x1.fffffep+127f
 *	#define MAXm1_FLT	0x1.fffffcp+127f
 *	#define MIN_FLT		0x1p-126f
 *	#define DEN_FLT		0x1p-149f
 *	#define ULP_FLT		0x1p-23f
 *	#define ONEp1_FLT	0x1.000002p+0f
 *	#define ONEm1_FLT	0x1.fffffep-1f
 *	#define TRD_D_FLT	0x1.555554p-2f
 *	#define TRD_U_FLT	0x1.555556p-2f
 *
 *	IEEE 24-bit as bit patterns (this is not FPCE hex FP)
 *
 *	#define	NAN_FLT		0x7f800001.f thru 0x7fffffff.f
 *	#define	INF_FLT		0x7f800000.f
 *	#define	MAX_FLT		0x7f7fffff.f
 *	#define	MAXm1_FLT	0x7f7ffffe.f
 *	#define	MIN_FLT		0x00800000.f
 *	#define	DEN_FLT		0x00000001.f
 *	#define	ULP_FLT		0x34000000.f
 *	#define	ONEp1_FLT	0x3f800001.f
 *	#define	ONEm1_FLT	0x3f7fffff.f
 *	#define	TRD_D_FLT	0x3eaaaaaa.f
 *	#define	TRD_U_FLT	0x3eaaaaab.f
 *
 *	IEEE 53-bit as decimal
 *
 *	#define NAN_DBL		(ZERO_DBL/ZERO_DBL)
 *	#define INF_DBL		1.0e+99999
 *	#define MAX_DBL		1.797693134862315708e+308
 *	#define MAXm1_DBL	1.797693134862315509e+308
 *	#define MIN_DBL		2.225073858507201383e-308
 *	#define DEN_DBL		4.940656458412465442e-324
 *	#define ULP_DBL		2.220446049250313080e-016
 *	#define ONEp1_DBL	1.000000000000000222
 *	#define ONEm1_DBL	0.9999999999999998890
 *	#define TRD_D_DBL	0.3333333333333333148
 *	#define TRD_U_DBL	0.3333333333333333703
 *
 *	#define NAN_D10		(0.0dd/0.0dd)
 *	#define INF_D10		1.0e+99999dd
 *	#define MAX_D10		9.999999999999999e+384dd
 *	#define MAXm1_D10	9.999999999999998e+384dd
 *	#define MIN_D10		1.000000000000000e-383dd
 *	#define DEN_D10		1.000000000000000e-398dd
 *	#define ULP_D10		1.000000000000000e-15dd
 *	#define ONEp1_D10	1.000000000000001dd
 *	#define ONEm1_D10	0.9999999999999999dd
 *	#define TRD_D_D10	0.3333333333333333dd
 *	#define TRD_U_D10	0.3333333333333334dd
 *
 *	IEEE 53-bit as FPCE hex FP
 *
 *	#define NAN_DBL		(ZERO_DBL/ZERO_DBL)
 *	#define INF_DBL		0x1.0000000000000p+16384
 *	#define MAX_DBL		0x1.fffffffffffffp+1023
 *	#define MAXm1_DBL	0x1.ffffffffffffep+1023
 *	#define MIN_DBL		0x1p-1022
 *	#define DEN_DBL		0x1p-1074
 *	#define ULP_DBL		0x1p-52
 *	#define ONEp1_DBL	0x1.0000000000001p+0
 *	#define ONEm1_DBL	0x1.fffffffffffffp-1
 *	#define TRD_D_DBL	0x1.5555555555555p-2
 *	#define TRD_U_DBL	0x1.5555555555556p-2
 *
 *	IEEE 53-bit as bit patterns (this is not FPCE hex FP)
 *
 *	#define	NAN_DBL		0x7ff0000000000001. thru 0x7fffffffffffffff.
 *	#define	INF_DBL		0x7ff0000000000000.
 *	#define	MAX_DBL		0x7fefffffffffffff.
 *	#define	MAXm1_DBL	0x7feffffffffffffe.
 *	#define	MIN_DBL		0x0010000000000000.
 *	#define	DEN_DBL		0x0000000000000001.
 *	#define	ULP_DBL		0x3cb0000000000000.
 *	#define	ONEp1_DBL	0x3ff0000000000001.
 *	#define	ONEm1_DBL	0x3fefffffffffffff.
 *	#define	TRD_D_DBL	0x3fd5555555555555.
 *	#define	TRD_U_DBL	0x3fd5555555555556.
 *
 *	IEEE 64-bit as decimal
 *
 *	#define NAN_LDBL	(ZERO_LDBL/ZERO_LDBL)
 *	#define INF_LDBL	1.0e+99999L
 *	#define MAX_LDBL	(1.189731495357231765021263e+4932L)
 *	#define MAXm1_LDBL	(1.189731495357231764956768e+4932L)
 *	#define MIN_LDBL	(3.362103143112093506262678e-4932L) Intel x87
 *	#define MIN_LDBL	(1.681051571556046753131339e-4932L) Motorola 68x
 *	#define DEN_LDBL	(3.645199531882474602528405e-4951L)
 *	#define ULP_LDBL	(1.084202172485504434007452e-0019L)
 *	#define ONEp1_LDBL	(1.000000000000000000108420e+0000L)
 *	#define ONEm1_LDBL	(9.999999999999999999457899e-0001L)
 *	#define TRD_D_LDBL	(3.333333333333333333152632e-0001L)
 *	#define TRD_U_LDBL	(3.333333333333333333423683e-0001L)
 *
 *	IEEE 64-bit as FPCE hex FP
 *
 *	#define NAN_LDBL	(ZERO_LDBL/ZERO_LDBL)
 *	#define INF_LDBL	0x1.0000000000000000p+16384L
 *	#define MAX_LDBL	0x0.ffffffffffffffffp+16384L
 *	#define MAXm1_LDBL	0x0.fffffffffffffffep+16384L
 *	#define MIN_LDBL	0x1p-16382L Intel 80x87
 *	#define MIN_LDBL	0x1p-16383L Motoroal 6888x
 *	#define DEN_LDBL	0x1p-16445L
 *	#define ULP_LDBL	0x1p-63L
 *	#define ONEp1_LDBL	0x0.8000000000000001p+1L
 *	#define ONEm1_LDBL	0x0.ffffffffffffffffp-0L
 *	#define TRD_D_LDBL	0x0.AAAAAAAAAAAAAAAAp-1L
 *	#define TRD_U_LDBL	0x0.AAAAAAAAAAAAAAABp-1L
 *
 *	IEEE 64-bit as bit patterns (this is not FPCE hex FP)
 *
 *	#define NAN_LDBL	0x7fff000000000001.L thru 0x7fffffffffffffff.L
 *	#define INF_LDBL	0x7fff000000000000.L
 *	#define MAX_LDBL	0x7ffeffffffffffff.L
 *	#define MAXm1_LDBL	0x7ffefffffffffffe.L
 *	#define MIN_LDBL	0x0001800000000000.L Intel 80x87
 *	#define MIN_LDBL	0x0000800000000000.L Motorola 6888x
 *	#define DEN_LDBL	0x0000000000000001.L
 *	#define ULP_LDBL	0x3f8f000000000000.L
 *	#define ONEp1_LDBL	0x3fff000000000001.L
 *	#define ONEm1_LDBL	0x3ffeffffffffffff.L
 *	#define TRD_D_LDBL	0x3ffd555555555555.L
 *	#define TRD_U_LDBL	0x3ffd555555555556.L
 *
 *	Double-double 106-bit as decimal
 *
 *	#define NAN_LDBL	(ZERO_LDBL/ZERO_LDBL)
 *	#define INF_LDBL	1.0e+99999L
 *	#define MAX_LDBL	1.79769313486231590772930519078900257533932578e+308L
 *	#define MAXm1_LDBL	1.79769313486231590772930519078898041706067457e+308L
 *	#define MIN_LDBL	2.22507385850720138309023271733240406421921598e-308L
 *	#define DEN_LDBL	4.94065645841246544176568792868221372365059803e-324L
 *	#define ULP_LDBL	2.46519032881566189191165176650870696772877011e-032L
 *	#define ONEp1_LDBL	1.00000000000000000000000000000002465190328816e+000L
 *	#define ONEm1_LDBL	9.99999999999999999999999999999987674048355922e-001L
 *	#define TRD_D_LDBL	3.33333333333333333333333333333329224682785307e-001L
 *	#define TRD_U_LDBL	3.33333333333333333333333333333335387658607346e-001L
 *
 *	Double-double 106-bit as FPCE hex FP
 *
 *	#define NAN_LDBL	(ZERO_LDBL/ZERO_LDBL)
 *	#define INF_LDBL	0x1.000000000000000000000000000p+1024L
 *	#define MAX_LDBL	0x1.ffffffffffffffffffffffffff8p+1023L
 *	#define MAXm1_LDBL	0x1.ffffffffffffffffffffffffff0p+1023L
 *	#define MIN_LDBL	0x1p-1022L
 *	#define DEN_LDBL	0x1p-1074L
 *	#define ULP_LDBL	0x1p-105L
 *	#define ONEp1_LDBL	0x1.000000000000000000000000008p+0L
 *	#define ONEm1_LDBL	0x1.ffffffffffffffffffffffffff8p-1L
 *	#define TRD_D_LDBL	0x1.555555555555555555555555550p-2L
 *	#define TRD_U_LDBL	0x1.555555555555555555555555558p-2L
 *
 *	IEEE 113-bit as decimal
 *
 *	#define NAN_LDBL	(ZERO_LDBL/ZERO_LDBL)
 *	#define INF_LDBL	1.0e99999L
 *	#define MAX_LDBL	1.189731495357231765085759326628007016196e4932L
 *	#define MAXm1_LDBL	1.189731495357231765085759326628006901629e4932L
 *	#define MIN_LDBL	3.362103143112093506262677817321752602598e-4932L
 *	#define DEN_LDBL	6.475175119438025110924438958227646552499e-4966L
 *	#define ULP_LDBL	1.925929944387235853055977942584927318538e-34L
 *	#define ONEp1_LDBL	1.000000000000000000000000000000000192592L
 *	#define ONEm1_LDBL	0.9999999999999999999999999999999999037035L
 *	#define TRD_D_LDBL	0.3333333333333333333333333333333333172839L
 *	#define TRD_U_LDBL	0.3333333333333333333333333333333333654321L
 *
 *	#define NAN_LD10	(0.0DL/0.0DL)
 *	#define INF_LD10	1.0e99999DL
 *	#define MAX_LD10	9.999999999999999999999999999999999e+6144DL
 *	#define MAXm1_LD10	9.999999999999999999999999999999998e+6144DL
 *	#define MIN_LD10	1.000000000000000000000000000000000e-6143DL
 *	#define DEN_LD10	1.000000000000000000000000000000000e-6176DL
 *	#define ULP_LD10	1.000000000000000000000000000000000e-33DL
 *	#define ONEp1_LD10	1.000000000000000000000000000000001DL
 *	#define ONEm1_LD10	0.9999999999999999999999999999999999DL
 *	#define TRD_D_LD10	0.3333333333333333333333333333333333DL
 *	#define TRD_U_LD10	0.3333333333333333333333333333333334DL
 *
 *	IEEE 113-bit as FPCE hex FP
 *
 *	#define NAN_LDBL	(ZERO_LDBL/ZERO_LDBL)
 *	#define INF_LDBL	0x1.0000000000000000000000000000p+16384L
 *	#define MAX_LDBL	0x1.ffffffffffffffffffffffffffffp+16383L
 *	#define MAXm1_LDBL	0x1.fffffffffffffffffffffffffffep+16383L
 *	#define MIN_LDBL	0x1p-16382L
 *	#define DEN_LDBL	0x1p-16494L
 *	#define ULP_LDBL	0x1p-112L
 *	#define ONEp1_LDBL	0x1.0000000000000000000000000001p+0L
 *	#define ONEm1_LDBL	0x1.ffffffffffffffffffffffffffffp-1L
 *	#define TRD_D_LDBL	0x1.5555555555555555555555555555p-2L
 *	#define TRD_U_LDBL	0x1.5555555555555555555555555556p-2L
 *
 *	IEEE 113-bit as bit patterns (this is not FPCE hex FP)
 *
 *	#define NAN_LDBL	0x7fff0000000000000000000000000001.L
 *	#define INF_LDBL	0x7fff0000000000000000000000000000.L
 *	#define MAX_LDBL	0x7ffeffffffffffffffffffffffffffff.L
 *	#define MAXm1_LDBL	0x7ffefffffffffffffffffffffffffffe.L
 *	#define MIN_LDBL	0x00010000000000000000000000000000.L
 *	#define DEN_LDBL	0x00000000000000000000000000000001.L
 *	#define ULP_LDBL	0x3f8f0000000000000000000000000000.L
 *	#define ONEp1_LDBL	0x3fff0000000000000000000000000001.L
 *	#define ONEm1_LDBL	0x3ffeffffffffffffffffffffffffffff.L
 *	#define TRD_D_LDBL	0x3ffd5555555555555555555555555555.L
 *	#define TRD_U_LDBL	0x3ffd5555555555555555555555555556.L
 *
 *  MODIFICATION HISTORY:
 *
 * 1994/07/27 - Create skeleton from test plan document.
 * 1994/08/01 - Add IBM IntelPC: Borland Turbo C 2.0
 * 1994/08/01 - Add IBM RS/6000: Taligent CompTech C/C++
 * 1994/08/08 - Add in SETUP1, SETUP2 macros.
 * 1994/08/13 - Change numeric values to be best Turbo C can do.
 * 1994/08/26 - Setup using hardware/software symbolics.
 * 1994/09/02 - Add 1/3 +/- up/down
 * 1994/09/07 - Split into mydefs.h and myfloat.h
 * 1994/09/27 - Add FMT_* so debugging prints are "portable".
 * 1994/09/29 - Add REMAP_LDBL, REMAP_DBL so can mix and match.
 * 1994/10/01 - Add HP PA: C (first pass)
 * 1994/10/01 - Add IBM RS/6000: xlc: IBM C
 * 1994/10/02 - Add IBM RS/6000: xlC: IBM C/C++ in C mode
 * 1994/10/03 - Add IBM RS/6000: xlC: IBM C/C++ in C++ mode
 * 1994/10/04 - Add x86 PC: IBM C (first pass)
 * 1994/10/04 - Add x86 PC: IBM C/C++ (first pass)
 * 1994/10/12 - Add hex_ld(), hex_d(), hex_f().
 * 1994/10/17 - Move hex_ld(), hex_d(), hex_f() to "myfuncs.h".
 * 1995/01/17 - Add x86 PC: Symantec C/C++ 7.0 in C mode
 * 1995/01/18 - Add NAN_FLT, NAN_DBL, NAN_LDBL
 * 1995/01/20 - Add FE_IEEE_EXCEPT
 * 1995/01/23 - Add LD_REG_PREC
 * 1995/01/27 - Add __INTSIZE for Symantec for 16/32 bit ints.
 * 1995/01/27 - Add SLLI_PREC and ULLI_PREC for long long.
 * 1995/01/31 - Add SC_PREC, UC_PREC, PC_PREC.
 * 1995/02/02 - Add FIX_HI_MIN fixup.
 * 1995/02/11 - Add _lint (since not know about hex fp)
 * 1995/02/16 - Moved FPCE_HEX to mydefs.h as FIX_FPCE_HEX.
 * 1995/02/19 - Add x86 PC: Borland C/C++ 4 (first pass)
 * 1995/02/20 - Add NEED_FP_H_4_INFINITY.
 * 1995/02/20 - Add NEED_FP_H_4_NAN.
 * 1995/02/20 - Add PBF_SIGNED.
 * 1995/02/24 - Separate xlc from xlC.
 * 1995/02/24 - Add FIX_BIGGER_THAN_FPMAX.
 * 1995/02/28 - Add FIX LDBL_GT_DBL.
 * 1995/02/28 - Add FIX_LDBL.
 * 1995/03/01 - Fix INF_* for any MIN-EVAL-FORMAT.
 * 1995/03/08 - Make FIX_LDBL matter more than LD_PREC > D_PREC.
 * 1995/03/09 - Add 106 bit long double values.
 * 1995/12/08 - Changed copyright from Taligent to Tydeman.
 * 1996/01/13 - Add FIX_SAME_NAN.
 * 1996/01/13 - Add FIX_F_OF_NAN_IS_QUIET.
 * 1996/01/13 - Add IMPL_UNDERFLOW_DEN_LOSS.
 * 1996/01/13 - Add ULP_*.
 * 1996/01/15 - Start adding math library constants.
 * 1996/03/14 - Add TEST_SNAN for potential extension.
 * 1996/05/27 - Add DO_106_113 so can lint/compile other hardware.
 * 1996/06/03 - Add GNU C/C++ 2.5.7 + emx 0.8h for OS/2 in C mode.
 * 1996/06/07 - Add SIZ_FLT, SIZ_DBL, SIZ_LDBL.
 * 1996/07/15 - Move #undef/#define of REDIRECT to mydefs.h
 * 1996/07/15 - Upgrade to C9X proposal WG14/N546.
 * 1996/07/21 - Added _CRAYIEEE for Cray Research.
 * 1996/09/21 - Added IMPL_REMQUO_BITS.
 * 1996/11/09 - Update acknowledge words as per Taligent VP & CTO.
 * 1996/11/13 - Remove trailing ";" after pragma like macros.
 * 1996/11/17 - Moved definitions of SUFFIX, MODE to mydefs.h
 * 1996/11/17 - Moved definitions of NEED_FP_H_4_* to mydefs.h
 * 1996/11/17 - Moved definitions of SETUP1, SETUP2 to mydefs.h
 * 1996/11/19 - Add get prototypes for startup FPU fixup code.
 * 1996/11/21 - Make separate includes for each compiler.
 * 1996/11/21 - Change FIX_LDBL to REMAP_LDBL most places.
 * 1996/11/21 - Moved definitions of REMAP_* to mydefs.h
 * 1996/12/13 - Do not do #define PI if checking name space.
 * 1997/01/14 - Add FP_F(), FP_D(), FP_LD() macros.
 * 1997/01/18 - Add Linux with Gnu gcc.
 * 1997/01/21 - __MyFloat_H -> MYFLOAT_H_ (out of C's namespace).
 * 1997/01/26 - EE -> M_e (reserved by <errno.h>).
 * 1997/01/26 - <fenv.h> -> FENV_H (so can use one in local directory).
 * 1997/01/26 - LCL_* -> LMS_* (reserved by POSIX.2).
 * 1997/01/31 - *_MAX reserved by POSIX.2 => Rename local macro symbols.
 * 1997/02/24 - Rename rinttol to lrint and make overloaded.
 * 1997/02/24 - Rename roundtol to lround and make overloaded.
 * 1997/02/24 - Rename scalb to scalbn; add scalb and ilogb from XPG4.
 * 1997/08/20 - Motorola vs Intel for minimum normalized value.
 * 1997/09/05 - Add more comments on ULP error of math library functions.
 * 1997/09/20 - Add sqrt() ulp error is smaller when IEC 559 defined.
 * 1997/10/03 - Add IMPL_INEXACT_*.
 * 1997/10/04 - FIX_DEN_UNDER -> IMPL_UNDERFLOW_DEN_LOSS.
 * 1998/07/10 - Move location of PC-Lint override files.
 * 1998/07/11 - Add FIX_MATH_PI (due to gcc 2.7.2 on Linux).
 * 1998/07/21 - Add FENV_MISSING as a "hardware/software" symbolic.
 * 1998/07/24 - Add _MSC_VER for Microsoft C/C++.
 * 1998/08/04 - Add LMS_SIGNED_ZERO_BUGS.
 * 1998/09/03 - Add __DCC__ for Diab Data.
 * 1998/09/07 - Add __rce and __mcore for Motorola M-CORE.
 * 1998/11/09 - Add __MWERKS__ for MetroWerks Code Warrior.
 * 1998/11/18 - Add REG_WIDER_EXP.
 * 1998/11/22 - Add IMPL_INF_FLAGS.
 * 1998/12/13 - Add ULP_cbrt.
 * 1998/12/20 - gamma -> tgamma.
 * 1999/02/19 - Decrease ULP_hypot to be same as ULP_sqrt.
 * 1999/03/03 - Add LARGE_ARG_* and ULP_LARGE_ARG_* for 3 trig functions.
 * 1999/03/18 - Add __TANDEM for Compaq-Tandem.
 * 1999/03/30 - Add *_SCAN2BIN_* like *_DEC2BIN_*.
 * 1999/04/02 - Remove sample.flt setup from here; replaced with include yourfile.flt.
 * 1999/04/14 - Add ULP_scalbln.
 * 1999/04/17 - Add ULP_nexttoward.
 * 1999/04/17 - Add ULP_llrint, ULP_llround, ULP_fma.
 * 1999/04/29 - Add ULP_expm1_exp.
 * 1999/05/03 - Add __WATCOMC__ for Watcom C/C++.
 * 1999/05/05 - Add __IBMC__ for IBM VisualAge for C/C++.
 * 1999/05/06 - Add FIX_FMA_NEG_ZERO.
 * 1999/05/07 - Better documentation on IMPL_INEXACT_*, in particular, cbrt.
 * 1999/05/08 - IMPL_INEXACT_cbrt -> IMPL_OPT_INEXACT_cbrt
 * 1999/05/10 - Add IMPL_OK_fesetprec.
 * 1999/05/12 - FIX LDBL_GT_DBL -> IMPL_LDBL_EQ_DBL
 * 1999/06/05 - Add *_BIN2DEC2BIN_ULPS (* = LD, D, and F).
 * 1999/07/18 - Add LONGLONG, ULONGLONG, SLL_C and ULL_C.
 * 1999/07/19 - Move " to mydefs.h (needed by FP_H in some cases).
 * 2000/03/01 - Make classification explicit in each file.
 * 2000/03/01 - Remove confidential so can post to public ftp site.
 * 2000/03/14 - Add IBM S/390 MVS to symbols and elif chain.
 * 2000/12/10 - Add Sun Sparc/x86/ia64 to symbols and elif chain.
 * 2001/01/16 - Add another HP to symbols and elif chain.
 * 2001/03/11 - Redo location of PC-Lint.
 * 2001/06/23 - Add x86 PC: Digital Mars C/C++ 8.0 in C mode
 * 2002/01/07 - Add FIX_USABLE_FE_DFL_ENV.
 * 2002/01/15 - Add FIX_HEX_PI.
 * 2002/01/15 - Add FIX_MYFLOAT_*.
 * 2002/02/10 - Add LCC to elif chain.
 * 2002/05/21 - Setup for Perennial.
 * 2002/12/01 - Add *_BIN2HEX2BIN_ULPS.
 * 2003/01/23 - Add Intel's ICC to symbols and elif chain.
 * 2003/02/09 - Add undef's for my PI symbols.
 * 2003/02/13 - Provide default definitions of isnan, isinf, DECIMAL_DIG, ...
 * 2003/02/16 - Add Comeau Computing and Edison Design Group symbols.
 * 2003/12/01 - Add LD_STRTOBIN_ULPS, D_STRTOBIN_ULPS, F_STRTOBIN_ULPS.
 * 2004/01/10 - Add BOOL_PREC.
 * 2004/01/25 - Add ULP_acos_sum.
 * 2004/01/27 - REMQUO_BITS -> IMPL_REMQUO_BITS.
 * 2004/01/31 - Lower ULP_erfc_sum due to better identity.
 * 2004/02/04 - INF_FLAGS -> IMPL_INF_FLAGS.
 * 2004/02/04 - Add IMPL_NAN_FLAGS.
 * 2004/04/23 - Add CLEAR_ALL and RAISE_ALL macro definitions.
 * 2004/05/01 - Add IMPL_FLT_EVAL_CONST, IMPL_FLT_EVAL_CONST_EXP, IMPL_FLT_EVAL_OP.
 * 2004/05/05 - Update CLEAR_ALL and RAISE_ALL for fenvdumy.h.
 * 2004/05/08 - Add IMPL_FLT_EVAL_STRTO.
 * 2004/05/09 - Redo LD_STRTOBIN_ULPS, D_STRTOBIN_ULPS, F_STRTOBIN_ULPS to be integers (used in #if).
 * 2004/05/28 - Add IMPL_FLT_EVAL_OP_ANON.
 * 2004/07/17 - ULP_strtold -> LD_STRTOBIN_ULPS.
 * 2004/07/17 - ULP_strtod -> D_STRTOBIN_ULPS.
 * 2004/07/17 - ULP_strtof -> F_STRTOBIN_ULPS.
 * 2004/07/19 - Add IMPL_FLT_EVAL_INT2FLT.
 * 2004/08/02 - Add __LMPCC__ to elif chain.
 * 2004/08/07 - Reformat #if's.
 * 2004/10/04 - Add *_WCSTOBIN_ULPS, *_WSCAN2BIN_ULPS.
 * 2005/01/07 - Add Apple Mac OS X on PowerPC.
 * 2005/02/13 - Add words about FIX_QUIET_INF to IMPL_INF_FLAGS.
 * 2005/05/08 - Add fenvon.h and fpconoff.h.
 * 2005/05/08 - Indent #if's.
 * 2006/03/16 - Add IEEE-754R Decimal FP related items.
 * 2006/03/30 - Rename WANT DEC FP macro.
 * 2006/05/01 - Redo FIX_SAME_DEN.
 * 2006/05/17 - Move NEED_EXIT_SYMS to myfloat.h (after include std headers).
 * 2006/06/01 - Redid many ULP_* due to directed rounding testing (were BIT4BIT).
 * 2006/07/25 - Define FLT_EVAL_METHOD in terms of _MIN_EVAL_FORMAT for old systems.
 * 2006/08/27 - Add ULP10_* symbols.
 * 2006/09/11 - Redo comments on ULP_* values (can have fractional ULP errors).
 * 2006/09/19 - Correct ULP_* for nearbyint, rint, lrint, llrint.
 * 2007/06/13 - Add ARM.
 * 2008/02/11 - Add IMPL_INEXACT10_*.
 * 2008/02/12 - Add LARGE_ARG_* for DFP items.
 * 2008/04/13 - Indent #if's.
 * 2008/06/20 - Add LG10 [base-2 log of 10] for t138{d,e,f}*.
 * 2008/06/20 - Indent #if's.
 * 2008/07/14 - Shorten marco symbols to less than 32 chars.
 * 2008/07/31 - Add more description of FMT_*_HEX and default values.
 * 2008/08/11 - Add MIN_FLAGS and MIN_FLAGS_OPT.
 * 2008/08/20 - Decimal FP detects tiny before rounding => IMPL_UNDERFLOW_MIN_LOSS ignored.
 * 2008/08/24 - Move FP_F(), FP_D(), FP_LD(), FP_F10(), FP_D10(), FP_LD10() to bug.
 * 2008/08/27 - Add "extra" trailing zeros to Decimal FP constants for more signif.
 * 2008/09/10 - Add IMPL_SAME_NAN, IMPL_SAME_2NAN.
 * 2008/09/26 - Add default values for decimal FP symbols.
 * 2008/10/09 - Redo MIN_FLAGS / MIN_FLAGS_OPT and FE_INEXACT.
 * 2008/11/26 - FLT to DEC in *EVAL_STRTO10.
 * 2009/02/07 - Add IMPL_FLT_EVAL_RET, IMPL_FLT_EVAL_IN_RET.
 * 2009/02/10 - Set ULP10_sqrt_sum to specific value for IEEE-754 systems.
 * 2009/06/26 - Add IMPL before INEXACT_ON_F2I.
 *
 ***********************************************************************/

#ifndef   MYFLOAT_H_
  #define MYFLOAT_H_

  #if (defined PERENNIAL)	/* for debug output */
    #undef  printf
    #define printf post
  #elif (defined REDIRECT)	/* Next only needed if redirecting stdout */
    #include <stdio.h>		/* freopen, fprintf, NULL, FILE */
    #include <stdlib.h>		/* EXIT_FAILURE */
  #endif

/*
 * Function prototypes for startup FPU fixup code.
 */
  #if  (!defined ALLOW_NON_STD_STARTUP)\
    && (   (defined NEED_FLAGS_CLEARED	)/* feclearexcept() */\
	|| (defined NEED_ROUND_SET	)/* fesetround()    */\
	|| (defined NEED_PREC_SET	)/* fesetprec()     */\
	|| (defined NEED_TRAPS_DISABLED	)/* fedisabletrap() */\
     )

    #ifdef NEED_STARTUP_FENV_H
      #include FENV_H		/* Prototypes of above functions */
    #endif

    #ifdef NEED_STARTUP_FLOAT_H	/* Common DOS extensions */
      #include <float.h>	/* _clear87(), _control87() prototypes */
    #endif

  #endif

/****************************************************************/
/* Lint/compile (but not link/run) non-standard data formats	*/
/* used on machines other than the x86 development system.	*/
/* This is used to find obvious typos before we ship the code.	*/
/* Can be used with hex or dec via compiler name in makefile.	*/
/****************************************************************/
  #if (defined DO_106_113)
    #include "do106113.flt"

/****************************************************************/
/* Quick and dirty setup based upon <float.h> for sample tests	*/
/****************************************************************/
  #elif (defined FENV_MISSING) || (defined FPCE_SAMPLE)
    #include "sample.flt"

/**********************************************************************/
/* LCC: 32-bit Windows						      */
/**********************************************************************/
  #elif (defined __LCC__)
    #include "lcc.flt"

/**********************************************************************/
/* Watcom: DOS, Win*, OS/2					      */
/**********************************************************************/
  #elif (defined __WATCOMC__)
    #include "watcom.flt"

/**********************************************************************/
/* Metrowerks; Both Mac and Intel				      */
/**********************************************************************/
  #elif (defined __MWERKS__)
    #include "metrowks.flt"

/**********************************************************************/
/* Diab Data C cross compiler					      */
/**********************************************************************/
  #elif (defined __DCC__)
    #include "diab.flt"

/**********************************************************************/
/* Sun: Sparc (32-bit & 64-bit), 32-bit x86, 64-bit ia64	      */
/**********************************************************************/
  #elif (defined __sun) && (defined __unix)
    #include "sun.flt"

/**********************************************************************/
/* Tandem							      */
/**********************************************************************/
  #elif (defined __TANDEM)
    #include "tandem.flt"

/**********************************************************************/
/* CRAY; UNICOS; Cray Standard C/C++ from Programming Environment 2.0 */
/**********************************************************************/
  #elif (defined _CRAYIEEE) /* && (defined ?? ) // need compiler name */
    #include "cray0200.flt"

/**********************************************************************/
/* IBM S/390; MVS; IBM C/C++					      */
/**********************************************************************/
  #elif (defined __HOS_MVS__) || (defined __TOS_MVS__)
    #include "ibm390.flt"

/**********************************************************************/
/* Lund MultiProcessor Compiler: PowerPC			      */
/**********************************************************************/
  #elif (defined __LMPCC__)
    #include "lmpcc.flt"

/*******************************************************************/
/* Apple Mac == PowerPC; Mac OS X; gcc in C or C++ mode		   */
/*******************************************************************/
  #elif (defined __POWERPC__) && (defined __MACH__) && (defined __GNUC__)
    #include "macgcc.flt"

/****************************************************************/
/* Apple Mac == PowerPC; Mac OS X; IBM VA in either C or C++ mode*/
/****************************************************************/
  #elif (defined __PPC__) && (defined __MACH__) && (defined __IBMC__ || defined __IBMCPP__)
    #include "macibm.flt"

/*******************************************************************/
/* POWER or PowerPC; AIX; Taligent CompTech C/C++ in C or C++ mode */
/*******************************************************************/
  #elif (defined __PPC__) && ((defined __TaligentC__) || (defined __TaligentCPlusPlus__))
    #include "taligent.flt"

/****************************************************************/
/* POWER; AIX; IBM xlC C/C++ in either C or C++ mode		*/
/* POWER; AIX; IBM xlc C in C mode				*/
/****************************************************************/
  #elif (defined _IBMR2) && ((defined __xlc) || (defined __XLCPP))
    #include "ibm6xlc.flt"

/****************************************************************/
/* PA, Itanium; HP-UX; HP C/C++ in either C or C++ mode		*/
/****************************************************************/
  #elif (defined __hppa)
    #include "hppa.flt"
  #elif (defined __ia64) && (defined __hpux)
    #include "hpux.flt"

/****************************************************************/
/* 80x86; OS/2; IBM C Set++ in either C or C++ mode		*/
/****************************************************************/
  #elif (defined _M_I386) && (defined __IBMC__ || defined __IBMCPP__)
    #include "ibm2cset.flt"

/****************************************************************/
/* 80x86; Linux; Intel icc in C or C++				*/
/****************************************************************/
  #elif (defined __i386__) && (defined __linux__) && (defined __ICC)
    #include "intel.flt"	/* defines to bypass known bugs */

/****************************************************************/
/* 80x86; Linux; GNU gcc in C or C++				*/
/****************************************************************/
  #elif (defined __i386__) && (defined __linux__) && (defined __GNUC__)
    #include "gcclinux.flt"

/****************************************************************/
/* 80x86; OS/2; GNU gcc 2.7.2.1 + emx 0.9c + fix02 in C or C++	*/
/* 80x86; OS/2; GNU gcc 2.5.7 + emx 0.8h in C or C++ mode	*/
/****************************************************************/
  #elif (defined __i386__) && (defined __EMX__)
    #include "gcc_emx.flt"

/****************************************************************/
/* 80x86; DOS or WinXX; Microsoft C/C++ 4.0 in C or C++ mode	*/
/****************************************************************/
  #elif (defined _MSC_VER)
    #include "microsft.flt"

/****************************************************************/
/* 80x86; WinXX; Digital Mars C/C++ 8.0 in either C or C++ mode	*/
/* Must come before Symantec (since compiler defines __SC__)	*/
/****************************************************************/
  #elif (defined __I86__) && (defined __DMC__)
    #include "digmars.flt"

/****************************************************************/
/* 80x86; DOS; Symantec C/C++ 7.0 in either C or C++ mode	*/
/****************************************************************/
  #elif (defined __I86__) && (defined __SC__)
    #include "symantec.flt"

/****************************************************************/
/* 80x86; DOS; Borland C/C++ 4.01 in C or C++ mode; 1993 version*/
/* 80x86; DOS; Borland Turbo C 2.01  (1988 version)		*/
/****************************************************************/
  #elif (defined __X86__) && ((defined __TURBOC__) || (defined __BORLANDC__))
    #include "borland.flt"

/**********************************************************************/
/* Comeau Computing						      */
/**********************************************************************/
  #elif (defined __COMO__)
    #include "comeau.flt"

/**********************************************************************/
/* Edison Design Group; must be near end as others build upon it      */
/**********************************************************************/
  #elif (defined __EDG__)
    #include "edg.flt"

/**********************************************************************/
/* ARM								      */
/**********************************************************************/
  #elif (defined __arm__)
    #include "arm.flt"

  #else	/*==================ERROR===============================*/

    #error Unknown hardware + software combination.
    #error Add a pair of #elif and #include lines similar to above pairs.
    #error The file to include needs lines like the sample*.flt files.
    #include "yourfile.flt"

  #endif

/*
 * Provide default definitions of common macros (functions and values)
 * if they are missing.  You can define you own verions in your
 * *.flt file (better), or you *.bug file (might be overriden by the
 * compile's header files).  You need to add the appropriate
 * FIX symbol in your *.bug file to enable these.
 */
  #if (defined FIX_MACF_isnan) && (!defined isnan)
    #define isnan(x) ( (x) != (x) )
  #endif

  #if (defined FIX_MACF_isinf) && (!defined isinf)
    #define isinf(x) ( (!isnan(x)) && isnan((x)-(x)) )
  #endif

  #if (defined FIX_MACF_isfinite) && (!defined isfinite)
    #define isfinite(x) ( !isnan((x)-(x)) )
  #endif

  #if (defined FIX_MACF_isnormal) && (!defined isnormal)
    #define isnormal(x) ( isfinite(x) && (0.f != (x)) )
    #define FIX_DEN_isnormal	/* subnormals done wrong */
  #endif

  #if (defined FIX_MACF_signbit) && (!defined signbit)
    #define signbit(x) ( (x) < 0.f )
    #define FIX_ZERO_signbit	/* signed zeros done wrong */
    #define FIX_NAN_signbit	/* NaNs done wrong */
  #endif

  #if (defined FIX_MACF_isless) && (!defined isless)
    #define isless(x,y) ( (!isnan(x)) && (!isnan(y)) && ((x)<(y)) )
  #endif

  #if (defined FIX_MACF_islessequal) && (!defined islessequal)
    #define islessequal(x,y) ( (!isnan(x)) && (!isnan(y)) && ((x)<=(y)) )
  #endif

  #if (defined FIX_MACF_isgreater) && (!defined isgreater)
    #define isgreater(x,y) ( (!isnan(x)) && (!isnan(y)) && ((x)>(y)) )
  #endif

  #if (defined FIX_MACF_isgreaterequal) && (!defined isgreaterequal)
    #define isgreaterequal(x,y) ( (!isnan(x)) && (!isnan(y)) && ((x)>=(y)) )
  #endif

  #if (defined FIX_MACF_islessgreater) && (!defined islessgreater)
    #define islessgreater(x,y) ( (!isnan(x)) && (!isnan(y)) && ((x)!=(y)) )
  #endif

  #if (defined FIX_MACF_isunordered) && (!defined isunordered)
    #define isunordered(x,y) ( isnan(x) || isnan(y) )
  #endif

  #if (defined FIX_SYM_HUGE_VAL) && (!defined HUGE_VAL)
    #define HUGE_VAL 1.0e9999999
  #endif

  #if (defined FIX_SYM_HUGE_VALF) && (!defined HUGE_VALF)
    #define HUGE_VALF 1.0e9999999f
  #endif

  #if (defined FIX_SYM_HUGE_VALL) && (!defined HUGE_VALL)
    #define HUGE_VALL 1.0e9999999L
  #endif

  #if (defined FIX_SYM_DECIMAL_DIG) && (!defined DECIMAL_DIG)
    #define DECIMAL_DIG 50
  #endif

  #if (defined FIX_SYM_INFINITY) && (!defined INFINITY)
    #define INFINITY 1.0e999999f
  #endif

  #if (defined FIX_SYM_NAN) && (!defined NAN)
    #define NAN (0.f/0.f)
  #endif

/*
 * The following are considered simple enough that they will convert correctly.
 */

  #define TENTH_FLT	FP_F(0.1)
  #define QTR_FLT	FP_F(0.25)
  #define HALF_FLT	FP_F(0.5)
  #define ZERO_FLT	FP_F(0.)
  #define ONE_FLT	FP_F(1.)
  #define TWO_FLT	FP_F(2.)
  #define THREE_FLT	FP_F(3.)
  #define FOUR_FLT	FP_F(4.)
  #define EIGHT_FLT	FP_F(8.)
  #define TEN_FLT	FP_F(10.)
  #define F127_FLT	FP_F(127.)
  #define F128_FLT	FP_F(128.)
  #define F255_FLT	FP_F(255.)

  #define TENTH_DBL	FP_D(0.1)
  #define QTR_DBL	FP_D(0.25)
  #define HALF_DBL	FP_D(0.5)
  #define ZERO_DBL	FP_D(0.)
  #define ONE_DBL	FP_D(1.)
  #define TWO_DBL	FP_D(2.)
  #define THREE_DBL	FP_D(3.)
  #define FOUR_DBL	FP_D(4.)
  #define EIGHT_DBL	FP_D(8.)
  #define TEN_DBL	FP_D(10.)
  #define F127_DBL	FP_D(127.)
  #define F128_DBL	FP_D(128.)
  #define F255_DBL	FP_D(255.)

  #define TENTH_LDBL	FP_LD(0.1)
  #define QTR_LDBL	FP_LD(0.25)
  #define HALF_LDBL	FP_LD(0.5)
  #define ZERO_LDBL	FP_LD(0.)
  #define ONE_LDBL	FP_LD(1.)
  #define TWO_LDBL	FP_LD(2.)
  #define THREE_LDBL	FP_LD(3.)
  #define FOUR_LDBL	FP_LD(4.)
  #define EIGHT_LDBL	FP_LD(8.)
  #define TEN_LDBL	FP_LD(10.)
  #define F127_LDBL	FP_LD(127.)
  #define F128_LDBL	FP_LD(128.)
  #define F255_LDBL	FP_LD(255.)

  #ifdef __STDC_WANT_DEC_FP__	/* Decimal FP addon */

/*
 * The following are considered simple enough that they will convert correctly.
 * Trailing zeros were added to force Decimal FP to have full significance.
 */

    #define TENTH_F10	FP_F10(0.10000000000000000000000000000000000000000)
    #define QTR_F10	FP_F10(0.250000000000000000000000000000000000000000)
    #define HALF_F10	FP_F10(0.50000000000000000000000000000000000000000)
    #define ZERO_F10	FP_F10(0.0000000000000000000000000000000000000000)
    #define ONE_F10	FP_F10(1.0000000000000000000000000000000000000000)
    #define TWO_F10	FP_F10(2.0000000000000000000000000000000000000000)
    #define THREE_F10	FP_F10(3.0000000000000000000000000000000000000000)
    #define FOUR_F10	FP_F10(4.0000000000000000000000000000000000000000)
    #define EIGHT_F10	FP_F10(8.0000000000000000000000000000000000000000)
    #define TEN_F10	FP_F10(10.0000000000000000000000000000000000000000)
    #define F127_F10	FP_F10(127.0000000000000000000000000000000000000000)
    #define F128_F10	FP_F10(128.0000000000000000000000000000000000000000)
    #define F255_F10	FP_F10(255.0000000000000000000000000000000000000000)

    #define TENTH_D10	FP_D10(0.10000000000000000000000000000000000000000)
    #define QTR_D10	FP_D10(0.250000000000000000000000000000000000000000)
    #define HALF_D10	FP_D10(0.50000000000000000000000000000000000000000)
    #define ZERO_D10	FP_D10(0.0000000000000000000000000000000000000000)
    #define ONE_D10	FP_D10(1.0000000000000000000000000000000000000000)
    #define TWO_D10	FP_D10(2.0000000000000000000000000000000000000000)
    #define THREE_D10	FP_D10(3.0000000000000000000000000000000000000000)
    #define FOUR_D10	FP_D10(4.0000000000000000000000000000000000000000)
    #define EIGHT_D10	FP_D10(8.0000000000000000000000000000000000000000)
    #define TEN_D10	FP_D10(10.0000000000000000000000000000000000000000)
    #define F127_D10	FP_D10(127.0000000000000000000000000000000000000000)
    #define F128_D10	FP_D10(128.0000000000000000000000000000000000000000)
    #define F255_D10	FP_D10(255.0000000000000000000000000000000000000000)

    #define TENTH_LD10	FP_LD10(0.10000000000000000000000000000000000000000)
    #define QTR_LD10	FP_LD10(0.250000000000000000000000000000000000000000)
    #define HALF_LD10	FP_LD10(0.50000000000000000000000000000000000000000)
    #define ZERO_LD10	FP_LD10(0.0000000000000000000000000000000000000000)
    #define ONE_LD10	FP_LD10(1.0000000000000000000000000000000000000000)
    #define TWO_LD10	FP_LD10(2.0000000000000000000000000000000000000000)
    #define THREE_LD10	FP_LD10(3.0000000000000000000000000000000000000000)
    #define FOUR_LD10	FP_LD10(4.0000000000000000000000000000000000000000)
    #define EIGHT_LD10	FP_LD10(8.0000000000000000000000000000000000000000)
    #define TEN_LD10	FP_LD10(10.0000000000000000000000000000000000000000)
    #define F127_LD10	FP_LD10(127.0000000000000000000000000000000000000000)
    #define F128_LD10	FP_LD10(128.0000000000000000000000000000000000000000)
    #define F255_LD10	FP_LD10(255.0000000000000000000000000000000000000000)

  #endif	/* __STDC_WANT_DEC_FP__	// Decimal FP addon */

/*
 * The following math library constants are defined in terms the longest
 * floating-point type allowed (normally long double).
 * If float or double are needed, just cast them using (FLT) or (DBL)
 * There are 40 digits of precision which should be more than enough for
 * any machine being tested.  128-bit IEEE extended has 113-bits => 36 digits
 *
 * If checking headers for name space pollution then don't define these here.
 *
 * You can define your own values of these in your *.flt or *.bug file.
 * They should be in a similar format.  You also need to define
 * FIX_MYFLOAT_sym, where sym is the symbol you are defining.
 */

  #if (!defined LMS_NO_MYFLOAT_VALUES)
    #ifdef FIX_MATH_PI
      #ifdef PI
        #undef PI
      #endif
      #ifdef PI2
        #undef PI2
      #endif
    #endif
    #if (defined __STDC_WANT_DEC_FP__)	/* Decimal FP addon */

      #if (!defined PI) || (!defined FIX_MYFLOAT_PI)
        #undef  PI
        #define PI	FP_LD10(3.141592653589793238462643383279502884197)
      #endif
      #if (!defined PI34) || (!defined FIX_MYFLOAT_PI34)
        #undef  PI34
        #define PI34	FP_LD10(2.356194490192344928846982537459627163147)
      #endif
      #if (!defined PI2) || (!defined FIX_MYFLOAT_PI2)
        #undef  PI2
        #define PI2	FP_LD10(1.570796326794896619231321691639751442098)
      #endif
      #if (!defined PI4) || (!defined FIX_MYFLOAT_PI4)
        #undef  PI4
        #define PI4	FP_LD10(0.7853981633974483096156608458198757210492)
      #endif
      #if (!defined LN2) || (!defined FIX_MYFLOAT_LN2)
        #undef  LN2
        #define LN2	FP_LD10(0.6931471805599453094172321214581765680755)
      #endif
      #if (!defined LN10) || (!defined FIX_MYFLOAT_LN10)
        #undef  LN10
        #define LN10	FP_LD10(2.302585092994045684017991454684364207601)
      #endif
      #if (!defined LOG2) || (!defined FIX_MYFLOAT_LOG2)
        #undef  LOG2
        #define LOG2	FP_LD10(0.3010299956639811952137388947244930267681)
      #endif
      #if (!defined LG10) || (!defined FIX_MYFLOAT_LG10)
        #undef  LG10
        #define LG10	FP_LD10(3.321928094887362347870319429489390175864)
      #endif
      #if (!defined SQRT2) || (!defined FIX_MYFLOAT_SQRT2)
        #undef  SQRT2
        #define SQRT2	FP_LD10(1.414213562373095048801688724209698078569)
      #endif
      #if (!defined M_e) || (!defined FIX_MYFLOAT_M_e)
        #undef  M_e
        #define M_e	FP_LD10(2.718281828459045235360287471352662497757)
      #endif
      #if (!defined TWORPI) || (!defined FIX_MYFLOAT_TWORPI)
        #undef  TWORPI
        #define TWORPI	FP_LD10(1.128379167095512573896158903121545171688) /* 2/sqrt(pi) */
      #endif

    #elif ((defined FLT_RADIX) && (FLT_RADIX == 10)) \
	|| (defined FIX_FPCE_HEX) \
	|| (defined FIX_HEX_PI)

      #if (!defined PI) || (!defined FIX_MYFLOAT_PI)
        #undef  PI
        #define PI	FP_LD(3.141592653589793238462643383279502884197)
      #endif
      #if (!defined PI34) || (!defined FIX_MYFLOAT_PI34)
        #undef  PI34
        #define PI34	FP_LD(2.356194490192344928846982537459627163147)
      #endif
      #if (!defined PI2) || (!defined FIX_MYFLOAT_PI2)
        #undef  PI2
        #define PI2	FP_LD(1.570796326794896619231321691639751442098)
      #endif
      #if (!defined PI4) || (!defined FIX_MYFLOAT_PI4)
        #undef  PI4
        #define PI4	FP_LD(0.7853981633974483096156608458198757210492)
      #endif
      #if (!defined LN2) || (!defined FIX_MYFLOAT_LN2)
        #undef  LN2
        #define LN2	FP_LD(0.6931471805599453094172321214581765680755)
      #endif
      #if (!defined LN10) || (!defined FIX_MYFLOAT_LN10)
        #undef  LN10
        #define LN10	FP_LD(2.302585092994045684017991454684364207601)
      #endif
      #if (!defined LOG2) || (!defined FIX_MYFLOAT_LOG2)
        #undef  LOG2
        #define LOG2	FP_LD(0.3010299956639811952137388947244930267681)
      #endif
      #if (!defined LG10) || (!defined FIX_MYFLOAT_LG10)
        #undef  LG10
        #define LG10	FP_LD(3.321928094887362347870319429489390175864)
      #endif
      #if (!defined SQRT2) || (!defined FIX_MYFLOAT_SQRT2)
        #undef  SQRT2
        #define SQRT2	FP_LD(1.414213562373095048801688724209698078569)
      #endif
      #if (!defined M_e) || (!defined FIX_MYFLOAT_M_e)
        #undef  M_e
        #define M_e	FP_LD(2.718281828459045235360287471352662497757)
      #endif
      #if (!defined TWORPI) || (!defined FIX_MYFLOAT_TWORPI)
        #undef  TWORPI
        #define TWORPI	FP_LD(1.128379167095512573896158903121545171688) /* 2/sqrt(pi) */
      #endif

    #else

      #if (!defined PI) || (!defined FIX_MYFLOAT_PI)
        #undef  PI
        #define PI	FP_LD(0x3.243F6A8885A308D313198A2E03707344A409382p0)
      #endif
      #if (!defined PI34) || (!defined FIX_MYFLOAT_PI34)
        #undef  PI34
        #define PI34	FP_LD(0x2.5B2F8FE6643A469E4E5327A2829456737B06EA1p0)
      #endif
      #if (!defined PI2) || (!defined FIX_MYFLOAT_PI2)
        #undef  PI2
        #define PI2	FP_LD(0x1.921FB54442D18469898CC51701B839A252049C1p0)
      #endif
      #if (!defined PI4) || (!defined FIX_MYFLOAT_PI4)
        #undef  PI4
        #define PI4	FP_LD(0x0.C90FDAA22168C234C4C6628B80DC1CD129024E08p0)
      #endif
      #if (!defined LN2) || (!defined FIX_MYFLOAT_LN2)
        #undef  LN2
        #define LN2	FP_LD(0x0.B17217F7D1CF79ABC9E3B39803F2F6AF40F34326p0)
      #endif
      #if (!defined LN10) || (!defined FIX_MYFLOAT_LN10)
        #undef  LN10
        #define LN10	FP_LD(0x2.4D763776AAA2B05BA95B58AE0B4C28A38A3FB3Ep0)
      #endif
      #if (!defined LOG2) || (!defined FIX_MYFLOAT_LOG2)
        #undef  LOG2
        #define LOG2	FP_LD(0x0.4D104D427DE7FBCC47C4ACD605BE48BC13569862p0)
      #endif
      #if (!defined LG10) || (!defined FIX_MYFLOAT_LG10)
        #undef  LG10
        #define LG10	FP_LD(0x3.5269E12F346E2BF924AFDBFD36BF6D3365B157Fp0)
      #endif
      #if (!defined SQRT2) || (!defined FIX_MYFLOAT_SQRT2)
        #undef  SQRT2
        #define SQRT2	FP_LD(0x1.6A09E667F3BCC908B2FB1366EA957D3E3AAD436p0)
      #endif
      #if (!defined M_e) || (!defined FIX_MYFLOAT_M_e)
        #undef  M_e
        #define M_e	FP_LD(0x2.B7E151628AED2A6ABF7158809CF4F3C762E7160p0)
      #endif
      #if (!defined TWORPI) || (!defined FIX_MYFLOAT_TWORPI)
        #undef  TWORPI
        #define TWORPI	FP_LD(0x1.20DD750429B6D11AE3A914FED7FD8688281341Dp0)
      #endif
    #endif
  #endif

/*
 * On some 2's complement machines, *_MIN == - *_MAX, which is one too high.
 */
  #ifdef FIX_HI_MIN
    #if SLLI_PREC > 0
      #undef  LLONG_MIN
      #define LLONG_MIN	(-LLONG_MAX-1LL)
    #endif
    #undef  LONG_MIN
    #define LONG_MIN	(-LONG_MAX-1L)
    #undef  INT_MIN
    #define	INT_MIN		(-INT_MAX-1)
    #undef  SHRT_MIN
    #define	SHRT_MIN	(-SHRT_MAX-1)
    #undef  SCHAR_MIN
    #define	SCHAR_MIN	(-SCHAR_MAX-1)
  #endif

  #ifdef	NEED_EXIT_SYMS	/* At least one compiler is missing these */
    #ifndef	EXIT_SUCCESS
      #define	EXIT_SUCCESS 0
    #endif
    #ifndef	EXIT_FAILURE
      #define	EXIT_FAILURE 1
    #endif
  #endif

/*
 * Clear all FP exception flags.  Original C99 did not have a return code.
 * TC1 added success/failure return code.  Only test return value if
 * there are useable flags.
 */
  #ifndef CLEAR_ALL
    #if( 20010901uL <= FPCE_TEST_LVL ) && (!defined FIX_FE_FLAGS)
      #define CLEAR_ALL \
 { int rc_fe; \
   rc_fe = feclearexcept( FE_ALL_EXCEPT ); \
   ck( 0 == rc_fe ); \
 }
    #else
      #define CLEAR_ALL feclearexcept( FE_ALL_EXCEPT )
    #endif
  #endif

/*
 * Raise all FP exception flags.  Original C99 did not have a return code.
 * TC1 added success/failure return code.  Only test return value if
 * there are useable flags.
 */
  #ifndef RAISE_ALL
    #if( 20010901uL <= FPCE_TEST_LVL ) && (!defined FIX_FE_FLAGS)
      #define RAISE_ALL \
 { int rc_fe; \
   rc_fe = feraiseexcept( FE_ALL_EXCEPT ); \
   ck( 0 == rc_fe ); \
 }
    #else
      #define RAISE_ALL feraiseexcept( FE_ALL_EXCEPT )
    #endif
  #endif

/*
 * On some systems FE_ALL_EXCEPT is more than just the 5 required IEEE-754
 * exceptions.  For example, it may include FE_SUBNORMAL or FE_DENORMAL.
 * It may include indicators of the type of invalid operation (inf-inf,
 * 0*inf, inf/inf, 0/0).  So define FE_IEEE_EXCEPT to be just the 5 required
 * IEEE-754 exceptions.  Also, define a local macro symbol LMS_SUBNORMAL
 * for optional subnormal number exception.
 *
 * Set up shorthands for all 5 IEEE-754 traps.
 */

  #ifndef	FE_IEEE_EXCEPT
    #define FE_IEEE_EXCEPT	( \
	FE_INVALID	| \
	FE_DIVBYZERO	| \
	FE_OVERFLOW	| \
	FE_UNDERFLOW	| \
	FE_INEXACT	)
  #endif

  #if (defined FE_DENORMAL)
    #define LMS_SUBNORMAL FE_DENORMAL
  #elif (defined FE_SUBNORMAL)
    #define LMS_SUBNORMAL FE_SUBNORMAL
  #else
    #define LMS_SUBNORMAL 0
  #endif

  #ifndef   FE_TRAP_IEEE
    #define FE_TRAP_IEEE	  ( \
	FE_TRAP_INVALID   | \
	FE_TRAP_DIVBYZERO | \
	FE_TRAP_OVERFLOW  | \
	FE_TRAP_UNDERFLOW | \
	FE_TRAP_INEXACT   )
  #endif

  #ifndef   FE_TRAP_ALL
    #define FE_TRAP_ALL	  ( \
	FE_TRAP_INVALID   | \
	FE_TRAP_DIVBYZERO | \
	FE_TRAP_OVERFLOW  | \
	FE_TRAP_UNDERFLOW | \
	FE_TRAP_INEXACT   )
  #endif

/*
 * Is func(NaN) quiet, or does it raise Invalid?
 */
  #ifdef FIX_F_OF_NAN_IS_QUIET
    #define NAN_FLAGS FE_INVALID
  #else
    #define NAN_FLAGS 0
  #endif

/*
 * If and when Signaling NaNs are supported, then func(SNaN) shall
 * (may for fabs(SNaN), pow(SNaN,0.0)) raise FE_INVALID.
 * Until then, SNaNs are replaced with QNaNs.
 */
  #ifdef TEST_SNAN
    #define SNAN_FLAGS FE_INVALID
  #else
    #define SNAN_FLAGS 0
  #endif

/*
 * Was: Does func(denormal) being same denormal raise Underflow, or not?
 *	FIX_DEN_UNDER was the symbol.
 *
 * Now: Is underflow raised due to denormalization loss or inexact?
 * sin(den) = den - den^3/3! + ... == den.  Since the result does
 * NOT depend upon the exponent range, there is no denormalizaion loss.
 * On the other hand, den is not the exact answer, so there is an
 * inexact result.  Depending upon what the definition of underflow is,
 * underflow must or may (or must not?) be raised.  DEN_FLAGS is used in
 * the test vector files to indicate the required flags.
 * NOTE: FE_INEXACT is NOT here (by itself) due to IMPL_INEXACT_*.
 */
  #if (!defined IMPL_UNDERFLOW_DEN_LOSS)/* inexact => underflow */
    #define DEN_FLAGS (FE_UNDERFLOW | FE_INEXACT)
    #define DEN_FLAGS_OPT 0
  #elif (IMPL_UNDERFLOW_DEN_LOSS > 0)	/* denormalization loss => underflow */
    #define DEN_FLAGS 0
    #define DEN_FLAGS_OPT 0
  #else					/* random underflow */
    #define DEN_FLAGS 0
    #define DEN_FLAGS_OPT (FE_UNDERFLOW | FE_INEXACT)
  #endif

/*
 * Does func(min normal) being same min normal raise Underflow, or not?
 * Is underflow raised due to tininess before or after rounding?
 * sin(min) = min - min^3/3! + ... == min.  Since the result does
 * NOT depend upon the exponent range, there is no denormalizaion loss.
 * On the other hand, min is not the exact answer, so there is an
 * inexact result.  Depending upon what the definition of underflow is,
 * underflow must or may (or must not?) be raised.  MIN_FLAGS is used in
 * the test vector files to indicate the required flags.
 * NOTE: FE_INEXACT is NOT here (by itself) due to IMPL_INEXACT_*.
 */
  #if (defined  __STDC_WANT_DEC_FP__)		/* DFP */
    #if (defined FIX_DFP_UNDERFLOW_MIN_LOSS)	/* Fix for DFP */
      #if (FIX_DFP_UNDERFLOW_MIN_LOSS > 0)	/* after rounding */
        #define MIN_FLAGS 0
        #define MIN_FLAGS_OPT 0
      #elif (FIX_DFP_UNDERFLOW_MIN_LOSS < 0)	/* random undeflow */
        #define MIN_FLAGS 0
        #define MIN_FLAGS_OPT (FE_UNDERFLOW | FE_INEXACT)
      #else /* == 0 */				/* before rounding */
        #define MIN_FLAGS (FE_UNDERFLOW | FE_INEXACT)
        #define MIN_FLAGS_OPT 0
      #endif
    #else					/* DFP before rounding */
      #define MIN_FLAGS (FE_UNDERFLOW | FE_INEXACT)
      #define MIN_FLAGS_OPT 0
    #endif
  #elif (!defined IMPL_UNDERFLOW_MIN_LOSS) ||(IMPL_UNDERFLOW_MIN_LOSS == 0) /* before rounding */
    #define MIN_FLAGS (FE_UNDERFLOW | FE_INEXACT)
    #define MIN_FLAGS_OPT 0
  #elif (IMPL_UNDERFLOW_MIN_LOSS > 0)	/* after rounding */
    #define MIN_FLAGS 0
    #define MIN_FLAGS_OPT 0
  #else /* < 0 */			/* random underflow */
    #define MIN_FLAGS 0
    #define MIN_FLAGS_OPT (FE_UNDERFLOW | FE_INEXACT)
  #endif

/*
 * Is func(NaN,NaN)
 *  a fixed (constant) NaN
 *  one of the two NaN arguments (except for signs)
 *  one of the two NaN arguments (including signs)
 */
  #if (defined FIX_SAME_2NAN)
    #define ULP_2NAN SOME_NAN
  #elif (defined IMPL_SAME_2NAN)
    #define ULP_2NAN SIGN_NAN
  #else
    #define ULP_2NAN EITHER_NAN
  #endif

/*
 * Is func(NaN)
 *   a fixed (constant) NaN
 *   the same (argument) NaN (except for sign)
 *   the same (argument) NaN (including sign)
 */
  #if (defined FIX_SAME_NAN)
    #define ULP_NAN SOME_NAN
  #elif (defined IMPL_SAME_NAN)
    #define ULP_NAN SIGN_NAN
  #else
    #define ULP_NAN BIT4BIT
  #endif

/*
 * Is func(denorm) the same denorm or not?
 * However, when testing directed rounding,
 * need to allow for non-BIT4BIT.
 */
  #ifdef FIX_SAME_DEN
    #define ULP_DEN ULP_f
  #else
    #define ULP_DEN ULP_f		/* was: BIT4BIT */
  #endif

/*
 * Is func(zero) the same zero or not?  Applies to -0.0.
 */
  #ifdef FIX_SAME_ZERO
    #define ULP_M0 SOME_ZERO
  #else
    #define ULP_M0 BIT4BIT
  #endif

/*
 * Are signed zeros done wrong?  f(-0.0) is +0.0, -0.0 is +0.0,
 * or +0.0 is -0.0, or -x not flip sign bit, or -f(-x) != f(x).
 */
  #if (defined FIX_SAME_ZERO) \
   || (defined FIX_RANDOM_SIGNED_ZERO) \
   || (defined FIX_MINUS_ZERO_CONSTANT_EXP) \
   || (defined FIX_NEG_FLIP_SIGN) \
   || (defined FIX_FMA_NEG_ZERO)
    #define LMS_SIGNED_ZERO_BUGS
  #else
    #undef  LMS_SIGNED_ZERO_BUGS
  #endif

/*
 * Define the default accuracy of the math library functions in ULPs.
 * This is the difference between the true value (need not be a machine number)
 * and the computed value from the math function.  These ULP errors are
 * for the Round to Nearest case.  For the other directed rounding cases,
 * 0.5 is added to the ULP error value given here.  For functions independent
 * of the rounding direction (such as fabs), the minimum ULP error is 0.0;
 * for functions dependent upon rounding direction (such as sqrt), the
 * minimum ULP error is 0.5; for functions that are exact, except for
 * over/underflow, (such as ldexp), the ULP error should be 0.5.
 *
 * So far, only g1xx0003.h and g1xy0003.h can have a true value that is not
 * a machine number (they use two machine numbers to hold a high and low part
 * of the expected value).  Hence, they are the only files that need fractional
 * ULP values.  Those files are used by t1***003 tests.  All other tests use
 * one machine value for the expected true value, so the difference between
 * true and computed will be an integer multiple of ULPs for them.
 *
 * These symbols cover all three precisions (float, double, long double).
 *
 * ULP of -5.0 means must bit4bit (except for sign bit); needed for NaNs.
 * ULP of -4.0 means must be an infinity of some flavor (not needed yet)
 * ULP of -3.0 means must be a zero of some flavor
 * ULP of -2.0 means must be a NaN of some flavor
 * ULP of -1.0 means must be either NaN argument
 * ULP of  0.0 means must match bit for bit (and is independend of rounding)
 * ULP of +x   means: math-x <= computed <= math+x; or |computed-math| <= x
 *             (where math is the true value rounded to machine precision).
 * If a function cannot meet this accuracy, then define its symbol in
 * the same file where the #define FIX_* symbols are.
 */
  #define SIGN_NAN	((FP)-5.0)
  #define SOME_INF	((FP)-4.0)
  #define SOME_ZERO	((FP)-3.0)
  #define SOME_NAN	((FP)-2.0)
  #define EITHER_NAN	((FP)-1.0)
  #define BIT4BIT	((FP) 0.0)

  #ifndef   ULP_acos
    #define ULP_acos	5.0
  #endif

  #ifndef   ULP_acos_sum
    #define ULP_acos_sum	8.0	/* error in acos(x) + acos(-x) */
  #endif

  #ifndef   ULP_asin
    #define ULP_asin	5.0
  #endif

  #ifndef   ULP_atan
    #define ULP_atan	5.0
  #endif

  #ifndef   ULP_atan_sum
    #define ULP_atan_sum	8.0	/* error in atan(x) + atan(1/x) */
  #endif

  #ifndef   ULP_atan2
    #define ULP_atan2	5.0
  #endif

  #ifndef   ULP_cos
    #define ULP_cos	3.0
  #endif

  #ifndef   ULP_sin
    #define ULP_sin	3.0
  #endif

  #ifndef   ULP_tan
    #define ULP_tan	3.0
  #endif

  #ifndef   ULP_acosh
    #define ULP_acosh	9.0
  #endif

  #ifndef   ULP_asinh
    #define ULP_asinh	9.0
  #endif

  #ifndef   ULP_atanh
    #define ULP_atanh	9.0
  #endif

  #ifndef   ULP_cosh
    #define ULP_cosh	9.0
  #endif

  #ifndef   ULP_sinh
    #define ULP_sinh	9.0
  #endif

  #ifndef   ULP_tanh
    #define ULP_tanh	9.0
  #endif

  #ifndef   ULP_exp
    #define ULP_exp	5.0
  #endif

  #ifndef   ULP_exp_sum
    #define ULP_exp_sum	10.0	/* error in 1/exp(-x) */
  #endif

  #ifndef   ULP_exp2
    #define ULP_exp2	5.0
  #endif

  #ifndef   ULP_exp2_sum
    #define ULP_exp2_sum	10.0	/* error in 1/exp2(-x) */
  #endif

  #ifndef   ULP_expm1
    #define ULP_expm1	5.0
  #endif

  #ifndef   ULP_expm1_sum
    #define ULP_expm1_sum	10.0	/* error in "1/expm1(-x)" */
  #endif

  #ifndef   ULP_expm1_exp
    #define ULP_expm1_exp	7.0	/* error between expm1(x) and exp(x)-1 */
  #endif

  #ifndef   ULP_frexp
    #define ULP_frexp	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_ldexp
    #define ULP_ldexp	0.5	/* was: BIT4BIT; but can over/underflow */
  #endif

  #ifndef   ULP_log
    #define ULP_log	5.0
  #endif

  #ifndef   ULP_log_sum
    #define ULP_log_sum	15.0	/* error in log(x) + log(1/x) */
  #endif

  #ifndef   ULP_log10
    #define ULP_log10	5.0
  #endif

  #ifndef   ULP_log10_sum
    #define ULP_log10_sum	15.0	/* error in log10(x) + log10(1/x) */
  #endif

  #ifndef   ULP_log1p
    #define ULP_log1p	5.0
  #endif

  #ifndef   ULP_log1p_sum
    #define ULP_log1p_sum	15.0	/* error in log1p(x) + log1p(1/(x+1)-1) */
  #endif

  #ifndef   ULP_log2
    #define ULP_log2	5.0
  #endif

  #ifndef   ULP_log2_sum
    #define ULP_log2_sum	15.0	/* error in log2(x) + log2(1/x) */
  #endif

  #ifndef   ULP_logb
    #define ULP_logb	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_ilogb
    #define ULP_ilogb	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_modf
    #define ULP_modf	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_scalb
    #define ULP_scalb	0.5	/* was: BIT4BIT; but can over/underflow */
  #endif

  #ifndef   ULP_scalbn
    #define ULP_scalbn	0.5	/* was: BIT4BIT; but can over/underflow */
  #endif

  #ifndef   ULP_scalbln
    #define ULP_scalbln	0.5	/* was: BIT4BIT; but can over/underflow */
  #endif

  #ifndef   ULP_fabs
    #define ULP_fabs	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_hypot
    #define ULP_hypot	ULP_sqrt	/* easy to be as good as sqrt */
  #endif

  #ifndef   ULP_pow
    #define ULP_pow	3.0
  #endif

  #ifndef   ULP_pow_sum
    #define ULP_pow_sum	5.0	/* error in pow(1/x,-y) and 1/pow(x,-y) */
  #endif

  #ifndef   ULP_sqrt
    #ifdef  __STDC_IEC_559__
      #define ULP_sqrt	0.5	/* rounding direction matters, so cannot be 0 */
    #else
      #define ULP_sqrt	1.0
    #endif
  #endif

  #ifndef   ULP_sqrt_sum
    #ifdef  __STDC_IEC_559__
      #define ULP_sqrt_sum	2.0	/* error in 1/sqrt(1/3.65625) */
    #else
      #define ULP_sqrt_sum	3.0	/* error in 1/sqrt(1/x) */
    #endif
  #endif

  #ifndef   ULP_cbrt
    #define ULP_cbrt	2.0
  #endif

  #ifndef   ULP_erf
    #define ULP_erf	9.0
  #endif

  #ifndef   ULP_erfc
    #define ULP_erfc	9.0
  #endif

  #ifndef   ULP_erfc_sum
    #define ULP_erfc_sum	9.0	/* error in erfc(-x) vs 2-erfc(x) */
  #endif

  #ifndef   ULP_tgamma
    #define ULP_tgamma	9.0
  #endif

  #ifndef   ULP_lgamma
    #define ULP_lgamma	9.0
  #endif

  #ifndef   ULP_ceil
    #define ULP_ceil	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_floor
    #define ULP_floor	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_nearbyint
    #define ULP_nearbyint	0.5	/* was BIT4BIT exact, but depends upon rounding */
  #endif

  #ifndef   ULP_rint
    #define ULP_rint	0.5	/* was BIT4BIT exact, but depends upon rounding */
  #endif

  #ifndef   ULP_lrint		/* was rinttol */
    #define ULP_lrint	0.5	/* was BIT4BIT exact, but depends upon rounding */
  #endif

  #ifndef   ULP_llrint		/* was rinttoll */
    #define ULP_llrint	0.5	/* was BIT4BIT exact, but depends upon rounding */
  #endif

  #ifndef   ULP_round
    #define ULP_round	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_lround		/* was roundtol */
    #define ULP_lround	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_llround		/* was roundtoll */
    #define ULP_llround	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_trunc
    #define ULP_trunc	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_fmod
    #define ULP_fmod	BIT4BIT	/* exact (if denorm results supported) */
  #endif

  #ifndef   ULP_remainder
    #define ULP_remainder	BIT4BIT	/* exact (if denorm results supported) */
  #endif

  #ifndef   ULP_remquo
    #define ULP_remquo	BIT4BIT	/* exact (if denorm results supported) */
  #endif

  #ifndef   IMPL_REMQUO_BITS
    #define IMPL_REMQUO_BITS	3	/* minimum number of bits of quotient */
  #endif

  #ifndef   ULP_copysign
    #define ULP_copysign	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_nan
    #define ULP_nan		SOME_NAN	/* needs to return some NaN */
  #endif

  #ifndef   ULP_nextafter
    #define ULP_nextafter	BIT4BIT	/* exact, even thou can over/underflow */
  #endif

  #ifndef   ULP_nexttoward
    #define ULP_nexttoward	BIT4BIT	/* exact, even thou can over/underflow */
  #endif

  #ifndef   ULP_fdim
    #define ULP_fdim	0.5	/* was BIT4BIT; but can overflow/underflow */
  #endif

  #ifndef   ULP_fmax
    #define ULP_fmax	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_fmin
    #define ULP_fmin	BIT4BIT	/* exact */
  #endif

  #ifndef   ULP_fma
    #define ULP_fma	0.5	/* was BIT4BIT; but can overflow/underflow */
  #endif

  #ifndef   LD_STRTOBIN_ULPS
    #define LD_STRTOBIN_ULPS 0	/* must be integer since used in #if */
  #endif

  #ifndef    D_STRTOBIN_ULPS
    #define  D_STRTOBIN_ULPS 0	/* must be integer since used in #if */
  #endif

  #ifndef    F_STRTOBIN_ULPS
    #define  F_STRTOBIN_ULPS 0	/* must be integer since used in #if */
  #endif

  #ifndef   LD_WCSTOBIN_ULPS
    #define LD_WCSTOBIN_ULPS 0	/* must be integer since used in #if */
  #endif

  #ifndef    D_WCSTOBIN_ULPS
    #define  D_WCSTOBIN_ULPS 0	/* must be integer since used in #if */
  #endif

  #ifndef    F_WCSTOBIN_ULPS
    #define  F_WCSTOBIN_ULPS 0	/* must be integer since used in #if */
  #endif

  #ifndef   LD_DEC2BIN_ULPS
    #define LD_DEC2BIN_ULPS	0
  #endif

  #ifndef    D_DEC2BIN_ULPS
    #define  D_DEC2BIN_ULPS	0
  #endif

  #ifndef    F_DEC2BIN_ULPS
    #define  F_DEC2BIN_ULPS	0
  #endif

  #ifndef   LD10_DEC2DFP_ULPS
    #define LD10_DEC2DFP_ULPS	0
  #endif

  #ifndef    D10_DEC2DFP_ULPS
    #define  D10_DEC2DFP_ULPS	0
  #endif

  #ifndef    F10_DEC2DFP_ULPS
    #define  F10_DEC2DFP_ULPS	0
  #endif

  #ifndef   LD_SCAN2BIN_ULPS
    #define LD_SCAN2BIN_ULPS 0
  #endif

  #ifndef    D_SCAN2BIN_ULPS
    #define  D_SCAN2BIN_ULPS 0
  #endif

  #ifndef    F_SCAN2BIN_ULPS
    #define  F_SCAN2BIN_ULPS 0
  #endif

  #ifndef   LD_WSCAN2BIN_ULPS
    #define LD_WSCAN2BIN_ULPS 0
  #endif

  #ifndef    D_WSCAN2BIN_ULPS
    #define  D_WSCAN2BIN_ULPS 0
  #endif

  #ifndef    F_WSCAN2BIN_ULPS
    #define  F_WSCAN2BIN_ULPS 0
  #endif

  #ifndef   LD_BIN2DEC2BIN_ULPS
    #define LD_BIN2DEC2BIN_ULPS 0
  #endif

  #ifndef   D_BIN2DEC2BIN_ULPS
    #define D_BIN2DEC2BIN_ULPS 0
  #endif

  #ifndef   F_BIN2DEC2BIN_ULPS
    #define F_BIN2DEC2BIN_ULPS 0
  #endif

  #ifndef   LD_BIN2HEX2BIN_ULPS
    #define LD_BIN2HEX2BIN_ULPS 0
  #endif

  #ifndef   D_BIN2HEX2BIN_ULPS
    #define D_BIN2HEX2BIN_ULPS 0
  #endif

  #ifndef   F_BIN2HEX2BIN_ULPS
    #define F_BIN2HEX2BIN_ULPS 0
  #endif

  #ifndef   ULP_LARGE_ARG_cos
    #define ULP_LARGE_ARG_cos 3.0e10
  #endif

  #ifndef   ULP_LARGE_ARG_sin
    #define ULP_LARGE_ARG_sin 3.0e10
  #endif

  #ifndef   ULP_LARGE_ARG_tan
    #define ULP_LARGE_ARG_tan 3.0e10
  #endif

  #ifndef   LARGE_ARG_cosf
    #define LARGE_ARG_cosf 4096.0 /* 2 ** (24/2) */
  #endif

  #ifndef   LARGE_ARG_sinf
    #define LARGE_ARG_sinf 4096.0 /* 2 ** (24/2) */
  #endif

  #ifndef   LARGE_ARG_tanf
    #define LARGE_ARG_tanf 4096.0 /* 2 ** (24/2) */
  #endif

  #ifndef   LARGE_ARG_cos
    #define LARGE_ARG_cos 9.5e7 /* 2 ** (53/2) */
  #endif

  #ifndef   LARGE_ARG_sin
    #define LARGE_ARG_sin 9.5e7 /* 2 ** (53/2) */
  #endif

  #ifndef   LARGE_ARG_tan
    #define LARGE_ARG_tan 9.5e7 /* 2 ** (53/2) */
  #endif

  #ifndef   LARGE_ARG_cosl
    #define LARGE_ARG_cosl 9.5e7 /* 2 ** (53/2) */
  #endif

  #ifndef   LARGE_ARG_sinl
    #define LARGE_ARG_sinl 9.5e7 /* 2 ** (53/2) */
  #endif

  #ifndef   LARGE_ARG_tanl
    #define LARGE_ARG_tanl 9.5e7 /* 2 ** (53/2) */
  #endif

/*
 * Decimal FP function accuracy.
 */

  #ifndef   ULP10_acos
    #define ULP10_acos  ULP_acos
  #endif

  #ifndef   ULP10_acos_sum
    #define ULP10_acos_sum  ULP_acos_sum
  #endif

  #ifndef   ULP10_asin
    #define ULP10_asin  ULP_asin
  #endif

  #ifndef   ULP10_atan
    #define ULP10_atan  ULP_atan
  #endif

  #ifndef   ULP10_atan_sum
    #define ULP10_atan_sum  ULP_atan_sum
  #endif

  #ifndef   ULP10_atan2
    #define ULP10_atan2  ULP_atan2
  #endif

  #ifndef   ULP10_cos
    #define ULP10_cos  ULP_cos
  #endif

  #ifndef   ULP10_sin
    #define ULP10_sin  ULP_sin
  #endif

  #ifndef   ULP10_tan
    #define ULP10_tan  ULP_tan
  #endif

  #ifndef   ULP10_acosh
    #define ULP10_acosh  ULP_acosh
  #endif

  #ifndef   ULP10_asinh
    #define ULP10_asinh  ULP_asinh
  #endif

  #ifndef   ULP10_atanh
    #define ULP10_atanh  ULP_atanh
  #endif

  #ifndef   ULP10_cosh
    #define ULP10_cosh  ULP_cosh
  #endif

  #ifndef   ULP10_sinh
    #define ULP10_sinh  ULP_sinh
  #endif

  #ifndef   ULP10_tanh
    #define ULP10_tanh  ULP_tanh
  #endif

  #ifndef   ULP10_exp
    #define ULP10_exp  ULP_exp
  #endif

  #ifndef   ULP10_exp_sum
    #define ULP10_exp_sum  ULP_exp_sum
  #endif

  #ifndef   ULP10_exp2
    #define ULP10_exp2  ULP_exp2
  #endif

  #ifndef   ULP10_exp2_sum
    #define ULP10_exp2_sum  ULP_exp2_sum
  #endif

  #ifndef   ULP10_expm1
    #define ULP10_expm1  ULP_expm1
  #endif

  #ifndef   ULP10_expm1_sum
    #define ULP10_expm1_sum  ULP_expm1_sum
  #endif

  #ifndef   ULP10_expm1_exp
    #define ULP10_expm1_exp  ULP_expm1_exp
  #endif

  #ifndef   ULP10_frexp
    #define ULP10_frexp  ULP_frexp
  #endif

  #ifndef   ULP10_ldexp
    #define ULP10_ldexp  ULP_ldexp
  #endif

  #ifndef   ULP10_log
    #define ULP10_log  ULP_log
  #endif

  #ifndef   ULP10_log_sum
    #define ULP10_log_sum  ULP_log_sum
  #endif

  #ifndef   ULP10_log10
    #define ULP10_log10  ULP_log10
  #endif

  #ifndef   ULP10_log10_sum
    #define ULP10_log10_sum  ULP_log10_sum
  #endif

  #ifndef   ULP10_log1p
    #define ULP10_log1p  ULP_log1p
  #endif

  #ifndef   ULP10_log1p_sum
    #define ULP10_log1p_sum  ULP_log1p_sum
  #endif

  #ifndef   ULP10_log2
    #define ULP10_log2  ULP_log2
  #endif

  #ifndef   ULP10_log2_sum
    #define ULP10_log2_sum  ULP_log2_sum
  #endif

  #ifndef   ULP10_logb
    #define ULP10_logb  ULP_logb
  #endif

  #ifndef   ULP10_ilogb
    #define ULP10_ilogb  ULP_ilogb
  #endif

  #ifndef   ULP10_modf
    #define ULP10_modf  ULP_modf
  #endif

  #ifndef   ULP10_scalbn
    #define ULP10_scalbn  ULP_scalbn
  #endif

  #ifndef   ULP10_scalbln
    #define ULP10_scalbln  ULP_scalbln
  #endif

  #ifndef   ULP10_fabs
    #define ULP10_fabs  ULP_fabs
  #endif

  #ifndef   ULP10_hypot
    #define ULP10_hypot  ULP_hypot
  #endif

  #ifndef   ULP10_pow
    #define ULP10_pow  ULP_pow
  #endif

  #ifndef   ULP10_pow_sum
    #define ULP10_pow_sum  ULP_pow_sum
  #endif

  #ifndef   ULP10_sqrt
    #ifdef  __STDC_IEC_559__
      #define ULP10_sqrt  ULP_sqrt
    #else
      #define ULP10_sqrt  ULP_sqrt
    #endif
  #endif

  #ifndef   ULP10_sqrt_sum
    #ifdef  __STDC_IEC_559__
      #define ULP10_sqrt_sum  3.0	/* error in 1./sqrt(1./49.) */
    #else
      #define ULP10_sqrt_sum  ULP_sqrt_sum
    #endif
  #endif

  #ifndef   ULP10_cbrt
    #define ULP10_cbrt  ULP_cbrt
  #endif

  #ifndef   ULP10_erf
    #define ULP10_erf  ULP_erf
  #endif

  #ifndef   ULP10_erfc
    #define ULP10_erfc  ULP_erfc
  #endif

  #ifndef   ULP10_erfc_sum
    #define ULP10_erfc_sum  ULP_erfc_sum
  #endif

  #ifndef   ULP10_tgamma
    #define ULP10_tgamma  ULP_tgamma
  #endif

  #ifndef   ULP10_lgamma
    #define ULP10_lgamma  ULP_lgamma
  #endif

  #ifndef   ULP10_ceil
    #define ULP10_ceil  ULP_ceil
  #endif

  #ifndef   ULP10_floor
    #define ULP10_floor  ULP_floor
  #endif

  #ifndef   ULP10_nearbyint
    #define ULP10_nearbyint  ULP_nearbyint
  #endif

  #ifndef   ULP10_rint
    #define ULP10_rint  ULP_rint
  #endif

  #ifndef   ULP10_lrint			/* was rinttol */
    #define ULP10_lrint  ULP_lrint
  #endif

  #ifndef   ULP10_llrint		/* was rinttoll */
    #define ULP10_llrint  ULP_llrint
  #endif

  #ifndef   ULP10_round
    #define ULP10_round  ULP_round
  #endif

  #ifndef   ULP10_lround		/* was roundtol */
    #define ULP10_lround  ULP_lround
  #endif

  #ifndef   ULP10_llround		/* was roundtoll */
    #define ULP10_llround  ULP_llround
  #endif

  #ifndef   ULP10_trunc
    #define ULP10_trunc  ULP_trunc
  #endif

  #ifndef   ULP10_fmod
    #define ULP10_fmod  ULP_fmod
  #endif

  #ifndef   ULP10_remainder
    #define ULP10_remainder  ULP_remainder
  #endif

  #ifndef   ULP10_copysign
    #define ULP10_copysign  ULP_copysign
  #endif

  #ifndef   ULP10_nan
    #define ULP10_nan  ULP_nan
  #endif

  #ifndef   ULP10_nextafter
    #define ULP10_nextafter  ULP_nextafter
  #endif

  #ifndef   ULP10_nexttoward
    #define ULP10_nexttoward  ULP_nexttoward
  #endif

  #ifndef   ULP10_fdim
    #define ULP10_fdim  ULP_fdim
  #endif

  #ifndef   ULP10_fmax
    #define ULP10_fmax  ULP_fmax
  #endif

  #ifndef   ULP10_fmin
    #define ULP10_fmin  ULP_fmin
  #endif

  #ifndef   ULP10_fma
    #define ULP10_fma  ULP_fma
  #endif

  #ifndef   ULP_LARGE_ARG10_cos
    #define ULP_LARGE_ARG10_cos 3.0e10
  #endif

  #ifndef   ULP_LARGE_ARG10_sin
    #define ULP_LARGE_ARG10_sin 3.0e10
  #endif

  #ifndef   ULP_LARGE_ARG10_tan
    #define ULP_LARGE_ARG10_tan 3.0e10
  #endif

  #ifndef   LARGE_ARG_cosd32
    #define LARGE_ARG_cosd32 3162.0 /* 10 ** (7/2) */
  #endif

  #ifndef   LARGE_ARG_sind32
    #define LARGE_ARG_sind32 3162.0 /* 10 ** (7/2) */
  #endif

  #ifndef   LARGE_ARG_tand32
    #define LARGE_ARG_tand32 3162.0 /* 10 ** (7/2) */
  #endif

  #ifndef   LARGE_ARG_cosd64
    #define LARGE_ARG_cosd64 1e8 /* 10 ** (16/2) */
  #endif

  #ifndef   LARGE_ARG_sind64
    #define LARGE_ARG_sind64 1e8 /* 10 ** (16/2) */
  #endif

  #ifndef   LARGE_ARG_tand64
    #define LARGE_ARG_tand64 1e8 /* 10 ** (16/2) */
  #endif

  #ifndef   LARGE_ARG_cosd128
    #define LARGE_ARG_cosd128 1e17 /* 10 ** (34/2) */
  #endif

  #ifndef   LARGE_ARG_sind128
    #define LARGE_ARG_sind128 1e17 /* 10 ** (34/2) */
  #endif

  #ifndef   LARGE_ARG_tand128
    #define LARGE_ARG_tand128 1e17 /* 10 ** (34/2) */
  #endif

/*
 * Define whether these math functions are required to raise inexact or
 * whether it is optional.  You need to define these symbols to the value 0
 * in the same file where the #define FIX_* symbols are if the given
 * function does not always raise inexact when the result is inexact.
 * This sets the required flags in the test vectors.  The optional flags
 * are FE_INEXACT.
 */
  #ifndef   IMPL_INEXACT_cos
    #define IMPL_INEXACT_cos FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_sin
    #define IMPL_INEXACT_sin FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_tan
    #define IMPL_INEXACT_tan FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_acos
    #define IMPL_INEXACT_acos FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_asin
    #define IMPL_INEXACT_asin FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_atan
    #define IMPL_INEXACT_atan FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_atan2
    #define IMPL_INEXACT_atan2 FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_cosh
    #define IMPL_INEXACT_cosh FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_sinh
    #define IMPL_INEXACT_sinh FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_tanh
    #define IMPL_INEXACT_tanh FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_acosh
    #define IMPL_INEXACT_acosh FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_asinh
    #define IMPL_INEXACT_asinh FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_atanh
    #define IMPL_INEXACT_atanh FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_exp
    #define IMPL_INEXACT_exp FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_expm1
    #define IMPL_INEXACT_expm1 FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_log
    #define IMPL_INEXACT_log FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_log1p
    #define IMPL_INEXACT_log1p FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_erf
    #define IMPL_INEXACT_erf FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_erfc
    #define IMPL_INEXACT_erfc FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT_lgamma
    #define IMPL_INEXACT_lgamma FE_INEXACT
  #endif

  #ifndef   IMPL_INEXACT10_cos
    #define IMPL_INEXACT10_cos FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_sin
    #define IMPL_INEXACT10_sin FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_tan
    #define IMPL_INEXACT10_tan FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_acos
    #define IMPL_INEXACT10_acos FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_asin
    #define IMPL_INEXACT10_asin FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_atan
    #define IMPL_INEXACT10_atan FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_atan2
    #define IMPL_INEXACT10_atan2 FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_cosh
    #define IMPL_INEXACT10_cosh FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_sinh
    #define IMPL_INEXACT10_sinh FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_tanh
    #define IMPL_INEXACT10_tanh FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_acosh
    #define IMPL_INEXACT10_acosh FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_asinh
    #define IMPL_INEXACT10_asinh FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_atanh
    #define IMPL_INEXACT10_atanh FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_exp
    #define IMPL_INEXACT10_exp FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_expm1
    #define IMPL_INEXACT10_expm1 FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_log
    #define IMPL_INEXACT10_log FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_log1p
    #define IMPL_INEXACT10_log1p FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_erf
    #define IMPL_INEXACT10_erf FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_erfc
    #define IMPL_INEXACT10_erfc FE_INEXACT
  #endif
  #ifndef   IMPL_INEXACT10_lgamma
    #define IMPL_INEXACT10_lgamma FE_INEXACT
  #endif

/*
 * Define whether these math functions are allowed to raise inexact when
 * the computed value is exact.  You need to define these symbols to the
 * value FE_INEXACT in the same file where the #define FIX_* symbols
 * are if the given function may raise inexact when the result is exact.
 * This sets the optional flags in the test vectors where the required
 * flag is 0, eg, no required flags.
 */
  #ifndef   IMPL_OPT_INEXACT_cbrt
    #define IMPL_OPT_INEXACT_cbrt 0
  #endif

/*
 * The optional fesetprec() function return code to indicate success has
 * changed over the years.  At one time it was non-zero.  Now, to match
 * the UK comments on the other fenv functions, it is zero.
 */
  #ifndef   IMPL_OK_fesetprec
    #define IMPL_OK_fesetprec 0
  #endif

/*
 * Flags raised by INF_FLT, INF_DBL, INF_LDBL.
 * Tested in t0180000.
 */
  #ifndef   IMPL_INF_FLAGS
    #define IMPL_INF_FLAGS (0)
  #endif

/*
 * Flags raised by NAN_FLT, NAN_DBL, NAN_LDBL.
 * Tested in t0230700.
 */
  #ifndef   IMPL_NAN_FLAGS
    #define IMPL_NAN_FLAGS (0)
  #endif

/*
 * If FE_DFL_ENV is not defined, then it is not usable.
 */
  #ifdef FIX_SYM_FE_DFL_ENV
    #define FIX_USABLE_FE_DFL_ENV
  #endif

/*
 * If FE_DFL_ENV is defined, but not usable,
 * then do not use it in memcmp in t2* tests.
 */
  #ifdef FIX_USABLE_FE_DFL_ENV
    #define IMPL_COMP_FE_DFL_ENV
  #endif

/*
 * If FLT_EVAL_METHOD < 0 (meaning inconsistent or unknown), then
 * allow the implementation to define how it evaluates:
 *   compile time FP constants
 *   compile time FP constant expressions (in static initializers)
 *   runtime FP operations
 *   runtime anonymous (w/o a store) FP operations, eg, FLT_MAX*FLT_MAX;
 *   runtime conversions from integer type to floating type
 * It is not clear if strto* and *scanf are independent of
 * FLT_EVAL_METHOD (and "as if" 0), or dependent.
 *   runtime FP constants via strto* and *scanf to binary
 *   runtime FP constants via strto* and *scanf to decimal
 */
  #if 19960226uL <= FPCE_TEST_LVL		/* C99 names */

    #ifdef FLT_EVAL_METHOD
      #if (0 <= FLT_EVAL_METHOD)
        #ifndef   IMPL_FLT_EVAL_CONST
          #define IMPL_FLT_EVAL_CONST	FLT_EVAL_METHOD
        #endif
        #ifndef   IMPL_FLT_EVAL_CONST_EXP
          #define IMPL_FLT_EVAL_CONST_EXP	FLT_EVAL_METHOD
        #endif
        #ifndef   IMPL_FLT_EVAL_OP
          #define IMPL_FLT_EVAL_OP	FLT_EVAL_METHOD
        #endif
        #ifndef   IMPL_FLT_EVAL_OP_ANON
          #define IMPL_FLT_EVAL_OP_ANON	FLT_EVAL_METHOD
        #endif
        #ifndef   IMPL_FLT_EVAL_INT2FLT
          #define IMPL_FLT_EVAL_INT2FLT	FLT_EVAL_METHOD
        #endif
        #ifndef   IMPL_FLT_EVAL_RET
          #define IMPL_FLT_EVAL_RET	FLT_EVAL_METHOD
        #endif
        #ifndef   IMPL_FLT_EVAL_IN_RET
          #define IMPL_FLT_EVAL_IN_RET	FLT_EVAL_METHOD
        #endif
      #else /* (FLT_EVAL_METHOD < 0), so only define these if user did not */
      #endif
    #else /* no FLT_EVAL_METHOD */
    #endif

  #else /* FPCE_TEST_LVL < 19960226uL	// FPCE names */

    #ifdef _MIN_EVAL_FORMAT
      #if (0 <= _MIN_EVAL_FORMAT)
        #ifndef   IMPL_FLT_EVAL_CONST
          #define IMPL_FLT_EVAL_CONST	_MIN_EVAL_FORMAT
        #endif
        #ifndef   IMPL_FLT_EVAL_CONST_EXP
          #define IMPL_FLT_EVAL_CONST_EXP	_MIN_EVAL_FORMAT
        #endif
        #ifndef   IMPL_FLT_EVAL_OP
          #define IMPL_FLT_EVAL_OP	_MIN_EVAL_FORMAT
        #endif
        #ifndef   IMPL_FLT_EVAL_OP_ANON
          #define IMPL_FLT_EVAL_OP_ANON	_MIN_EVAL_FORMAT
        #endif
        #ifndef   IMPL_FLT_EVAL_INT2FLT
          #define IMPL_FLT_EVAL_INT2FLT	_MIN_EVAL_FORMAT
        #endif
        #ifndef   IMPL_FLT_EVAL_RET
          #define IMPL_FLT_EVAL_RET	_MIN_EVAL_FORMAT
        #endif
        #ifndef   IMPL_FLT_EVAL_IN_RET
          #define IMPL_FLT_EVAL_IN_RET	_MIN_EVAL_FORMAT
        #endif
      #else /* (_MIN_EVAL_FORMAT < 0), so only define these if user did not */
      #endif
    #else /* no _MIN_EVAL_FORMAT */
    #endif

  #endif

  #ifdef DEC_EVAL_METHOD
    #if (0 <= DEC_EVAL_METHOD)
      #ifndef   IMPL_DEC_EVAL_CONST10
        #define IMPL_DEC_EVAL_CONST10	DEC_EVAL_METHOD
      #endif
      #ifndef   IMPL_DEC_EVAL_CONST_EXP10
        #define IMPL_DEC_EVAL_CONST_EXP10	DEC_EVAL_METHOD
      #endif
      #ifndef   IMPL_DEC_EVAL_OP10
        #define IMPL_DEC_EVAL_OP10	DEC_EVAL_METHOD
      #endif
      #ifndef   IMPL_DEC_EVAL_OP_ANON
        #define IMPL_DEC_EVAL_OP_ANON	DEC_EVAL_METHOD
      #endif
      #ifndef   IMPL_DEC_EVAL_INT2DFP
        #define IMPL_DEC_EVAL_INT2DFP	DEC_EVAL_METHOD
      #endif
      #ifndef   IMPL_DEC_EVAL_RET10
        #define IMPL_DEC_EVAL_RET10	DEC_EVAL_METHOD
      #endif
      #ifndef   IMPL_DEC_EVAL_IN_RET10
        #define IMPL_DEC_EVAL_IN_RET10	DEC_EVAL_METHOD
      #endif
    #else /* (DEC_EVAL_METHOD < 0), so only define these if user did not */
    #endif
  #else /* no DEC_EVAL_METHOD */
  #endif

  #ifndef   IMPL_FLT_EVAL_CONST
    #define IMPL_FLT_EVAL_CONST (0)	/* compile-time constants */
  #endif
  #ifndef   IMPL_FLT_EVAL_CONST_EXP
    #define IMPL_FLT_EVAL_CONST_EXP (0) /* compile-time constant expressions */
  #endif
  #ifndef   IMPL_FLT_EVAL_OP
    #define IMPL_FLT_EVAL_OP (0)	/* runtime operations */
  #endif
  #ifndef   IMPL_FLT_EVAL_OP_CONTRACT
    #define IMPL_FLT_EVAL_OP_CONTRACT IMPL_FLT_EVAL_OP
  #endif
  #ifndef   IMPL_FLT_EVAL_OP_ANON
    #define IMPL_FLT_EVAL_OP_ANON IMPL_FLT_EVAL_OP	/* anonymous runtime operations */
  #endif
  #ifndef   IMPL_FLT_EVAL_RET
    #define IMPL_FLT_EVAL_RET IMPL_FLT_EVAL_OP	/* runtime return */
  #endif
  #ifndef   IMPL_FLT_EVAL_IN_RET
    #define IMPL_FLT_EVAL_IN_RET IMPL_FLT_EVAL_RET	/* runtime return */
  #endif
  #ifndef   IMPL_FLT_EVAL_INT2FLT
    #define IMPL_FLT_EVAL_INT2FLT (0)	/* conversion from integer to floating */
  #endif
  #ifndef   IMPL_FLT_EVAL_STRTO
    #define IMPL_FLT_EVAL_STRTO (0)	/* strto* and *scanf of BFP constant */
  #endif

  #ifndef   IMPL_DEC_EVAL_CONST10
    #define IMPL_DEC_EVAL_CONST10 (0)	/* compile-time constants */
  #endif
  #ifndef   IMPL_DEC_EVAL_CONST_EXP10
    #define IMPL_DEC_EVAL_CONST_EXP10 (0)	/* compile-time constant expressions */
  #endif
  #ifndef   IMPL_DEC_EVAL_OP10
    #define IMPL_DEC_EVAL_OP10 (0)	/* runtime operations */
  #endif
  #ifndef   IMPL_DEC_EVAL_RET10
    #define IMPL_DEC_EVAL_RET10 IMPL_DEC_EVAL_OP10	/* runtime return */
  #endif
  #ifndef   IMPL_DEC_EVAL_IN_RET10
    #define IMPL_DEC_EVAL_IN_RET10 IMPL_DEC_EVAL_RET10	/* runtime return */
  #endif
  #ifndef   IMPL_DEC_EVAL_STRTO10
    #define IMPL_DEC_EVAL_STRTO10 (0)	/* strto* and *scanf of DFP constant */
  #endif

/*
 * Assume the compiler tells the truth about the size (in bytes) of the
 * three floating-point types.  These are default definitions.  They
 * can be overriden later for a specific compiler.  These are needed
 * for memcmp to see if the expected bit pattern matches the computed
 * bit pattern and by hex_* routines to convert to printable hex
 * representations of the floating-point types.  These were added after
 * a compiler reported the size of a long double as 12 bytes, when in
 * fact it is 10 bytes.  Being wrong, there were many false failures.
 */
  #ifndef   SIZ_FLT
    #define SIZ_FLT  ((size_t)sizeof(FLT))
  #endif
  #ifndef   SIZ_DBL
    #define SIZ_DBL  ((size_t)sizeof(DBL))
  #endif
  #ifndef   SIZ_LDBL
    #define SIZ_LDBL ((size_t)sizeof(LDBL))
  #endif

  #ifdef __STDC_WANT_DEC_FP__	/* Decimal FP addon */

    #ifndef   SIZ_F10
      #define SIZ_F10  ((size_t)sizeof(F10))
    #endif
    #ifndef   SIZ_D10
      #define SIZ_D10  ((size_t)sizeof(D10))
    #endif
    #ifndef   SIZ_LD10
      #define SIZ_LD10 ((size_t)sizeof(LD10))
    #endif

  #endif	/* __STDC_WANT_DEC_FP__	// Decimal FP addon */

/*
 * How print strings of hex chars of Binary and Decimal FP values as produced
 * by hex_* in s0000000.
 */
  #ifndef   FMT_F_HEX
    #define FMT_F_HEX "%s"
  #endif
  #ifndef   FMT_D_HEX
    #define FMT_D_HEX "%s"
  #endif
  #ifndef   FMT_LD_HEX
    #define FMT_LD_HEX "%s"
  #endif

  #ifdef __STDC_WANT_DEC_FP__	/* Decimal FP addon */

    #ifndef   FMT_F10_HEX
      #define FMT_F10_HEX "%s"
    #endif
    #ifndef   FMT_D10_HEX
      #define FMT_D10_HEX "%s"
    #endif
    #ifndef   FMT_LD10_HEX
      #define FMT_LD10_HEX "%s"
    #endif

  #endif	/* __STDC_WANT_DEC_FP__	// Decimal FP addon */

/*
 * Default way to print decimal FP values.
 */
  #ifdef __STDC_WANT_DEC_FP__	/* Decimal FP addon */

    #ifndef   FMT_F10_DEC
      #define FMT_F10_DEC "%+.7He"
    #endif
    #ifndef   FMT_D10_DEC
      #define FMT_D10_DEC "%+.16De"
    #endif
    #ifndef   FMT_LD10_DEC
      #define FMT_LD10_DEC "%+.34DDe"
    #endif

  #endif	/* __STDC_WANT_DEC_FP__	// Decimal FP addon */

/*
 * Since specification of Decimal FP is fixed by IEEE-754-2008, we can
 * provide default values for almost all the *.flt symbols.
 */
  #ifdef __STDC_WANT_DEC_FP__	/* Decimal FP addon */

    #ifndef   NAN_F10
      #define NAN_F10	(FP_F10(0.)/FP_F10(0.))
    #endif
    #ifndef   INF_F10
      #define INF_F10	FP_F10(9e32767)
    #endif
    #ifndef   MAX_F10
      #define MAX_F10	FP_F10(9.999999e96)
    #endif
    #ifndef   MAXm1_F10
      #define MAXm1_F10	FP_F10(9.999998e96)
    #endif
    #ifndef   MIN_F10
      #define MIN_F10	FP_F10(1e-95)
    #endif
    #ifndef   DEN_F10
      #define DEN_F10	FP_F10(1e-101)
    #endif
    #ifndef   ULP_F10
      #define ULP_F10	FP_F10(1e-6)
    #endif
    #ifndef   ONEp1_F10
      #define ONEp1_F10	FP_F10(1.000001)
    #endif
    #ifndef   ONEm1_F10
      #define ONEm1_F10	FP_F10(.9999999)
    #endif
    #ifndef   TRD_D_F10
      #define TRD_D_F10	FP_F10(.3333333)
    #endif
    #ifndef   TRD_U_F10
      #define TRD_U_F10	FP_F10(.3333334)
    #endif

    #ifndef   NAN_D10
      #define NAN_D10	(FP_D10(0.)/FP_D10(0.))
    #endif
    #ifndef   INF_D10
      #define INF_D10	FP_D10(9e32767)
    #endif
    #ifndef   MAX_D10
      #define MAX_D10	FP_D10(9.999999999999999e384)
    #endif
    #ifndef   MAXm1_D10
      #define MAXm1_D10	FP_D10(9.999999999999998e384)
    #endif
    #ifndef   MIN_D10
      #define MIN_D10	FP_D10(1e-383)
    #endif
    #ifndef   DEN_D10
      #define DEN_D10	FP_D10(1e-398)
    #endif
    #ifndef   ULP_D10
      #define ULP_D10	FP_D10(1e-15)
    #endif
    #ifndef   ONEp1_D10
      #define ONEp1_D10	FP_D10(1.000000000000001)
    #endif
    #ifndef   ONEm1_D10
      #define ONEm1_D10	FP_D10(.9999999999999999)
    #endif
    #ifndef   TRD_D_D10
      #define TRD_D_D10	FP_D10(.3333333333333333)
    #endif
    #ifndef   TRD_U_D10
      #define TRD_U_D10	FP_D10(.3333333333333334)
    #endif

    #ifndef   NAN_LD10
      #define NAN_LD10	(FP_LD10(0.)/FP_LD10(0.))
    #endif
    #ifndef   INF_LD10
      #define INF_LD10	FP_LD10(9e32767)
    #endif
    #ifndef   MAX_LD10
      #define MAX_LD10	FP_LD10(9.999999999999999999999999999999999e6144)
    #endif
    #ifndef   MAXm1_LD10
      #define MAXm1_LD10 FP_LD10(9.999999999999999999999999999999998e6144)
    #endif
    #ifndef   MIN_LD10
      #define MIN_LD10	FP_LD10(1e-6143)
    #endif
    #ifndef   DEN_LD10
      #define DEN_LD10	FP_LD10(1e-6176)
    #endif
    #ifndef   ULP_LD10
      #define ULP_LD10	FP_LD10(1e-33)
    #endif
    #ifndef   ONEp1_LD10
      #define ONEp1_LD10 FP_LD10(1.000000000000000000000000000000001)
    #endif
    #ifndef   ONEm1_LD10
      #define ONEm1_LD10 FP_LD10(.9999999999999999999999999999999999)
    #endif
    #ifndef   TRD_D_LD10
      #define TRD_D_LD10 FP_LD10(.3333333333333333333333333333333333)
    #endif
    #ifndef   TRD_U_LD10
      #define TRD_U_LD10 FP_LD10(.3333333333333333333333333333333334)
    #endif

    #ifndef    F10_PREC
      #define  F10_PREC	 7
    #endif
    #ifndef    D10_PREC
      #define  D10_PREC	16
    #endif
    #ifndef   LD10_PREC
      #define LD10_PREC	34
    #endif
    #ifndef   LD10_REG_PREC
      #define LD10_REG_PREC LD10_PREC
    #endif

  #endif	/* __STDC_WANT_DEC_FP__	// Decimal FP addon */

/*
 * See mydefs.h for details on "pragmas".  Since this file is included
 * after all other headers, the pragma like macros should have values now.
 * At the October, 1996, WG14/X3J11 meeting, these were voted to change
 * form from having a trailing semicolon to not having a trailing ";".
 * With WG14/N631, these were changed back to pragmas, but of a new form.
 */
/*lint -efile(537,fenvon.h) // multiple include */
/*lint -efile(537,fpconoff.h) // multiple include */
  #include "fenvon.h"
  #include "fpconoff.h"

  #if (!defined REG_WIDER_EXP)
    #error  REG_WIDER_EXP must be defined to be 0 or 1 in your *.flt file.
  #elif  (REG_WIDER_EXP != 0) && (REG_WIDER_EXP != 1)
    #error  REG_WIDER_EXP must be defined to be 0 or 1 in your *.flt file.
  #endif

  #if (!defined LD10_WIDER_EXP)
    #define LD10_WIDER_EXP 1
  #endif

  #ifdef FIX_FUNCS_F
    #define FIX_FUNC_nanf
    #define FIX_FUNC_strtof
  #endif

  #ifdef FIX_FUNCS_L
    #define FIX_FUNC_nanl
    #define FIX_FUNC_strtold
  #endif

/*
 * We do have some form of math_errhandling, but not
 * both kinds.  So, do not check that errno and FP
 * exception flags are consistent in the math library.
 */
  #if (defined MATH_ERREXCEPT) && (!defined MATH_ERRNO)
    #define FIX_ERRNO_MATH
  #endif

/*
 * g0080100.h is looking for FLT_EVAL_METHOD,
 * so see if can use new symbol in terms of very old symbol.
 */
  #if (!defined FLT_EVAL_METHOD) && (defined _MIN_EVAL_FORMAT)
    #define FLT_EVAL_METHOD _MIN_EVAL_FORMAT
  #endif

/*
 * Checking code on development system.
 * Bypass nits in my code; bugs in PC-Lint.
 */
  #ifdef _lint
    #include "E:\fpcets\pclint\pclint2.bug"
  #endif

#endif /* MYFLOAT_H_ */
