Rework the math library tests per the glibc math test code, with

many unsupported tests disabled for the moment.
 -Erik

1 files changed, 0 insertions, 4119 deletions

diff --git a/test/math/ieee.c b/test/math/ieee.c
deleted file mode 100644
index 17efea01c..000000000
--- a/test/math/ieee.c
+++ /dev/null
@@ -1,4119 +0,0 @@
-/*							ieee.c
- *
- *    Extended precision IEEE binary floating point arithmetic routines
- *
- * Numbers are stored in C language as arrays of 16-bit unsigned
- * short integers.  The arguments of the routines are pointers to
- * the arrays.
- *
- *
- * External e type data structure, simulates Intel 8087 chip
- * temporary real format but possibly with a larger significand:
- *
- *	NE-1 significand words	(least significant word first,
- *				 most significant bit is normally set)
- *	exponent		(value = EXONE for 1.0,
- *				top bit is the sign)
- *
- *
- * Internal data structure of a number (a "word" is 16 bits):
- *
- * ei[0]	sign word	(0 for positive, 0xffff for negative)
- * ei[1]	biased exponent	(value = EXONE for the number 1.0)
- * ei[2]	high guard word	(always zero after normalization)
- * ei[3]
- * to ei[NI-2]	significand	(NI-4 significand words,
- *				 most significant word first,
- *				 most significant bit is set)
- * ei[NI-1]	low guard word	(0x8000 bit is rounding place)
- *
- *
- *
- *		Routines for external format numbers
- *
- *	asctoe( string, e )	ASCII string to extended double e type
- *	asctoe64( string, &d )	ASCII string to long double
- *	asctoe53( string, &d )	ASCII string to double
- *	asctoe24( string, &f )	ASCII string to single
- *	asctoeg( string, e, prec ) ASCII string to specified precision
- *	e24toe( &f, e )		IEEE single precision to e type
- *	e53toe( &d, e )		IEEE double precision to e type
- *	e64toe( &d, e )		IEEE long double precision to e type
- *	eabs(e)			absolute value
- *	eadd( a, b, c )		c = b + a
- *	eclear(e)		e = 0
- *	ecmp (a, b)		Returns 1 if a > b, 0 if a == b,
- *				-1 if a < b, -2 if either a or b is a NaN.
- *	ediv( a, b, c )		c = b / a
- *	efloor( a, b )		truncate to integer, toward -infinity
- *	efrexp( a, exp, s )	extract exponent and significand
- *	eifrac( e, &l, frac )   e to long integer and e type fraction
- *	euifrac( e, &l, frac )  e to unsigned long integer and e type fraction
- *	einfin( e )		set e to infinity, leaving its sign alone
- *	eldexp( a, n, b )	multiply by 2**n
- *	emov( a, b )		b = a
- *	emul( a, b, c )		c = b * a
- *	eneg(e)			e = -e
- *	eround( a, b )		b = nearest integer value to a
- *	esub( a, b, c )		c = b - a
- *	e24toasc( &f, str, n )	single to ASCII string, n digits after decimal
- *	e53toasc( &d, str, n )	double to ASCII string, n digits after decimal
- *	e64toasc( &d, str, n )	long double to ASCII string
- *	etoasc( e, str, n )	e to ASCII string, n digits after decimal
- *	etoe24( e, &f )		convert e type to IEEE single precision
- *	etoe53( e, &d )		convert e type to IEEE double precision
- *	etoe64( e, &d )		convert e type to IEEE long double precision
- *	ltoe( &l, e )		long (32 bit) integer to e type
- *	ultoe( &l, e )		unsigned long (32 bit) integer to e type
- *      eisneg( e )             1 if sign bit of e != 0, else 0
- *      eisinf( e )             1 if e has maximum exponent (non-IEEE)
- *				or is infinite (IEEE)
- *      eisnan( e )             1 if e is a NaN
- *	esqrt( a, b )		b = square root of a
- *
- *
- *		Routines for internal format numbers
- *
- *	eaddm( ai, bi )		add significands, bi = bi + ai
- *	ecleaz(ei)		ei = 0
- *	ecleazs(ei)		set ei = 0 but leave its sign alone
- *	ecmpm( ai, bi )		compare significands, return 1, 0, or -1
- *	edivm( ai, bi )		divide  significands, bi = bi / ai
- *	emdnorm(ai,l,s,exp)	normalize and round off
- *	emovi( a, ai )		convert external a to internal ai
- *	emovo( ai, a )		convert internal ai to external a
- *	emovz( ai, bi )		bi = ai, low guard word of bi = 0
- *	emulm( ai, bi )		multiply significands, bi = bi * ai
- *	enormlz(ei)		left-justify the significand
- *	eshdn1( ai )		shift significand and guards down 1 bit
- *	eshdn8( ai )		shift down 8 bits
- *	eshdn6( ai )		shift down 16 bits
- *	eshift( ai, n )		shift ai n bits up (or down if n < 0)
- *	eshup1( ai )		shift significand and guards up 1 bit
- *	eshup8( ai )		shift up 8 bits
- *	eshup6( ai )		shift up 16 bits
- *	esubm( ai, bi )		subtract significands, bi = bi - ai
- *
- *
- * The result is always normalized and rounded to NI-4 word precision
- * after each arithmetic operation.
- *
- * Exception flags are NOT fully supported.
- *
- * Define INFINITY in mconf.h for support of infinity; otherwise a
- * saturation arithmetic is implemented.
- *
- * Define NANS for support of Not-a-Number items; otherwise the
- * arithmetic will never produce a NaN output, and might be confused
- * by a NaN input.
- * If NaN's are supported, the output of ecmp(a,b) is -2 if
- * either a or b is a NaN. This means asking if(ecmp(a,b) < 0)
- * may not be legitimate. Use if(ecmp(a,b) == -1) for less-than
- * if in doubt.
- * Signaling NaN's are NOT supported; they are treated the same
- * as quiet NaN's.
- *
- * Denormals are always supported here where appropriate (e.g., not
- * for conversion to DEC numbers).
- */
-
-/*
- * Revision history:
- *
- *  5 Jan 84	PDP-11 assembly language version
- *  2 Mar 86	fixed bug in asctoq()
- *  6 Dec 86	C language version
- * 30 Aug 88	100 digit version, improved rounding
- * 15 May 92    80-bit long double support
- *
- * Author:  S. L. Moshier.
- */
-
-#include <stdio.h>
-/* #include "\usr\include\stdio.h" */
-#include "ehead.h"
-#include "mconf.h"
-
-/* Change UNK into something else. */
-#ifdef UNK
-#undef UNK
-#define IBMPC 1
-#endif
-
-/* NaN's require infinity support. */
-#ifdef NANS
-#ifndef INFINITY
-#define INFINITY
-#endif
-#endif
-
-/* This handles 64-bit long ints. */
-#define LONGBITS (8 * sizeof(long))
-
-/* Control register for rounding precision.
- * This can be set to 80 (if NE=6), 64, 56, 53, or 24 bits.
- */
-int rndprc = NBITS;
-extern int rndprc;
-
-void eaddm(), esubm(), emdnorm(), asctoeg(), enan();
-static void toe24(), toe53(), toe64(), toe113();
-void eremain(), einit(), eiremain();
-int ecmpm(), edivm(), emulm(), eisneg(), eisinf();
-void emovi(), emovo(), emovz(), ecleaz(), eadd1();
-void etodec(), todec(), dectoe();
-int eisnan(), eiisnan();
-
-
-
-void einit()
-{
-}
-
-/*
-; Clear out entire external format number.
-;
-; unsigned short x[];
-; eclear( x );
-*/
-
-void eclear( x )
-register unsigned short *x;
-{
-register int i;
-
-for( i=0; i<NE; i++ )
-	*x++ = 0;
-}
-
-
-
-/* Move external format number from a to b.
- *
- * emov( a, b );
- */
-
-void emov( a, b )
-register unsigned short *a, *b;
-{
-register int i;
-
-for( i=0; i<NE; i++ )
-	*b++ = *a++;
-}
-
-
-/*
-;	Absolute value of external format number
-;
-;	short x[NE];
-;	eabs( x );
-*/
-
-void eabs(x)
-unsigned short x[];	/* x is the memory address of a short */
-{
-
-x[NE-1] &= 0x7fff; /* sign is top bit of last word of external format */
-}
-
-
-
-
-/*
-;	Negate external format number
-;
-;	unsigned short x[NE];
-;	eneg( x );
-*/
-
-void eneg(x)
-unsigned short x[];
-{
-
-#ifdef NANS
-if( eisnan(x) )
-	return;
-#endif
-x[NE-1] ^= 0x8000; /* Toggle the sign bit */
-}
-
-
-
-/* Return 1 if external format number is negative,
- * else return zero.
- */
-int eisneg(x)
-unsigned short x[];
-{
-
-#ifdef NANS
-if( eisnan(x) )
-	return( 0 );
-#endif
-if( x[NE-1] & 0x8000 )
-	return( 1 );
-else
-	return( 0 );
-}
-
-
-/* Return 1 if external format number has maximum possible exponent,
- * else return zero.
- */
-int eisinf(x)
-unsigned short x[];
-{
-
-if( (x[NE-1] & 0x7fff) == 0x7fff )
-	{
-#ifdef NANS
-	if( eisnan(x) )
-		return( 0 );
-#endif
-	return( 1 );
-	}
-else
-	return( 0 );
-}
-
-/* Check if e-type number is not a number.
- */
-int eisnan(x)
-unsigned short x[];
-{
-
-#ifdef NANS
-int i;
-/* NaN has maximum exponent */
-if( (x[NE-1] & 0x7fff) != 0x7fff )
-	return (0);
-/* ... and non-zero significand field. */
-for( i=0; i<NE-1; i++ )
-	{
-	if( *x++ != 0 )
-		return (1);
-	}
-#endif
-return (0);
-}
-
-/*
-; Fill entire number, including exponent and significand, with
-; largest possible number.  These programs implement a saturation
-; value that is an ordinary, legal number.  A special value
-; "infinity" may also be implemented; this would require tests
-; for that value and implementation of special rules for arithmetic
-; operations involving inifinity.
-*/
-
-void einfin(x)
-register unsigned short *x;
-{
-register int i;
-
-#ifdef INFINITY
-for( i=0; i<NE-1; i++ )
-	*x++ = 0;
-*x |= 32767;
-#else
-for( i=0; i<NE-1; i++ )
-	*x++ = 0xffff;
-*x |= 32766;
-if( rndprc < NBITS )
-	{
-	if (rndprc == 113)
-		{
-		*(x - 9) = 0;
-		*(x - 8) = 0;
-		}
-	if( rndprc == 64 )
-		{
-		*(x-5) = 0;
-		}
-	if( rndprc == 53 )
-		{
-		*(x-4) = 0xf800;
-		}
-	else
-		{
-		*(x-4) = 0;
-		*(x-3) = 0;
-		*(x-2) = 0xff00;
-		}
-	}
-#endif
-}
-
-
-
-/* Move in external format number,
- * converting it to internal format.
- */
-void emovi( a, b )
-unsigned short *a, *b;
-{
-register unsigned short *p, *q;
-int i;
-
-q = b;
-p = a + (NE-1);	/* point to last word of external number */
-/* get the sign bit */
-if( *p & 0x8000 )
-	*q++ = 0xffff;
-else
-	*q++ = 0;
-/* get the exponent */
-*q = *p--;
-*q++ &= 0x7fff;	/* delete the sign bit */
-#ifdef INFINITY
-if( (*(q-1) & 0x7fff) == 0x7fff )
-	{
-#ifdef NANS
-	if( eisnan(a) )
-		{
-		*q++ = 0;
-		for( i=3; i<NI; i++ )
-			*q++ = *p--;
-		return;
-		}
-#endif
-	for( i=2; i<NI; i++ )
-		*q++ = 0;
-	return;
-	}
-#endif
-/* clear high guard word */
-*q++ = 0;
-/* move in the significand */
-for( i=0; i<NE-1; i++ )
-	*q++ = *p--;
-/* clear low guard word */
-*q = 0;
-}
-
-
-/* Move internal format number out,
- * converting it to external format.
- */
-void emovo( a, b )
-unsigned short *a, *b;
-{
-register unsigned short *p, *q;
-unsigned short i;
-
-p = a;
-q = b + (NE-1); /* point to output exponent */
-/* combine sign and exponent */
-i = *p++;
-if( i )
-	*q-- = *p++ | 0x8000;
-else
-	*q-- = *p++;
-#ifdef INFINITY
-if( *(p-1) == 0x7fff )
-	{
-#ifdef NANS
-	if( eiisnan(a) )
-		{
-		enan( b, NBITS );
-		return;
-		}
-#endif
-	einfin(b);
-	return;
-	}
-#endif
-/* skip over guard word */
-++p;
-/* move the significand */
-for( i=0; i<NE-1; i++ )
-	*q-- = *p++;
-}
-
-
-
-
-/* Clear out internal format number.
- */
-
-void ecleaz( xi )
-register unsigned short *xi;
-{
-register int i;
-
-for( i=0; i<NI; i++ )
-	*xi++ = 0;
-}
-
-/* same, but don't touch the sign. */
-
-void ecleazs( xi )
-register unsigned short *xi;
-{
-register int i;
-
-++xi;
-for(i=0; i<NI-1; i++)
-	*xi++ = 0;
-}
-
-
-
-
-/* Move internal format number from a to b.
- */
-void emovz( a, b )
-register unsigned short *a, *b;
-{
-register int i;
-
-for( i=0; i<NI-1; i++ )
-	*b++ = *a++;
-/* clear low guard word */
-*b = 0;
-}
-
-/* Return nonzero if internal format number is a NaN.
- */
-
-int eiisnan (x)
-unsigned short x[];
-{
-int i;
-
-if( (x[E] & 0x7fff) == 0x7fff )
-	{
-	for( i=M+1; i<NI; i++ )
-		{
-		if( x[i] != 0 )
-			return(1);
-		}
-	}
-return(0);
-}
-
-#ifdef INFINITY
-/* Return nonzero if internal format number is infinite. */
-
-static int 
-eiisinf (x)
-     unsigned short x[];
-{
-
-#ifdef NANS
-  if (eiisnan (x))
-    return (0);
-#endif
-  if ((x[E] & 0x7fff) == 0x7fff)
-    return (1);
-  return (0);
-}
-#endif
-
-/*
-;	Compare significands of numbers in internal format.
-;	Guard words are included in the comparison.
-;
-;	unsigned short a[NI], b[NI];
-;	cmpm( a, b );
-;
-;	for the significands:
-;	returns	+1 if a > b
-;		 0 if a == b
-;		-1 if a < b
-*/
-int ecmpm( a, b )
-register unsigned short *a, *b;
-{
-int i;
-
-a += M; /* skip up to significand area */
-b += M;
-for( i=M; i<NI; i++ )
-	{
-	if( *a++ != *b++ )
-		goto difrnt;
-	}
-return(0);
-
-difrnt:
-if( *(--a) > *(--b) )
-	return(1);
-else
-	return(-1);
-}
-
-
-/*
-;	Shift significand down by 1 bit
-*/
-
-void eshdn1(x)
-register unsigned short *x;
-{
-register unsigned short bits;
-int i;
-
-x += M;	/* point to significand area */
-
-bits = 0;
-for( i=M; i<NI; i++ )
-	{
-	if( *x & 1 )
-		bits |= 1;
-	*x >>= 1;
-	if( bits & 2 )
-		*x |= 0x8000;
-	bits <<= 1;
-	++x;
-	}	
-}
-
-
-
-/*
-;	Shift significand up by 1 bit
-*/
-
-void eshup1(x)
-register unsigned short *x;
-{
-register unsigned short bits;
-int i;
-
-x += NI-1;
-bits = 0;
-
-for( i=M; i<NI; i++ )
-	{
-	if( *x & 0x8000 )
-		bits |= 1;
-	*x <<= 1;
-	if( bits & 2 )
-		*x |= 1;
-	bits <<= 1;
-	--x;
-	}
-}
-
-
-
-/*
-;	Shift significand down by 8 bits
-*/
-
-void eshdn8(x)
-register unsigned short *x;
-{
-register unsigned short newbyt, oldbyt;
-int i;
-
-x += M;
-oldbyt = 0;
-for( i=M; i<NI; i++ )
-	{
-	newbyt = *x << 8;
-	*x >>= 8;
-	*x |= oldbyt;
-	oldbyt = newbyt;
-	++x;
-	}
-}
-
-/*
-;	Shift significand up by 8 bits
-*/
-
-void eshup8(x)
-register unsigned short *x;
-{
-int i;
-register unsigned short newbyt, oldbyt;
-
-x += NI-1;
-oldbyt = 0;
-
-for( i=M; i<NI; i++ )
-	{
-	newbyt = *x >> 8;
-	*x <<= 8;
-	*x |= oldbyt;
-	oldbyt = newbyt;
-	--x;
-	}
-}
-
-/*
-;	Shift significand up by 16 bits
-*/
-
-void eshup6(x)
-register unsigned short *x;
-{
-int i;
-register unsigned short *p;
-
-p = x + M;
-x += M + 1;
-
-for( i=M; i<NI-1; i++ )
-	*p++ = *x++;
-
-*p = 0;
-}
-
-/*
-;	Shift significand down by 16 bits
-*/
-
-void eshdn6(x)
-register unsigned short *x;
-{
-int i;
-register unsigned short *p;
-
-x += NI-1;
-p = x + 1;
-
-for( i=M; i<NI-1; i++ )
-	*(--p) = *(--x);
-
-*(--p) = 0;
-}
-
-/*
-;	Add significands
-;	x + y replaces y
-*/
-
-void eaddm( x, y )
-unsigned short *x, *y;
-{
-register unsigned long a;
-int i;
-unsigned int carry;
-
-x += NI-1;
-y += NI-1;
-carry = 0;
-for( i=M; i<NI; i++ )
-	{
-	a = (unsigned long )(*x) + (unsigned long )(*y) + carry;
-	if( a & 0x10000 )
-		carry = 1;
-	else
-		carry = 0;
-	*y = (unsigned short )a;
-	--x;
-	--y;
-	}
-}
-
-/*
-;	Subtract significands
-;	y - x replaces y
-*/
-
-void esubm( x, y )
-unsigned short *x, *y;
-{
-unsigned long a;
-int i;
-unsigned int carry;
-
-x += NI-1;
-y += NI-1;
-carry = 0;
-for( i=M; i<NI; i++ )
-	{
-	a = (unsigned long )(*y) - (unsigned long )(*x) - carry;
-	if( a & 0x10000 )
-		carry = 1;
-	else
-		carry = 0;
-	*y = (unsigned short )a;
-	--x;
-	--y;
-	}
-}
-
-
-/* Divide significands */
-
-static unsigned short equot[NI] = {0}; /* was static */
-
-#if 0
-int edivm( den, num )
-unsigned short den[], num[];
-{
-int i;
-register unsigned short *p, *q;
-unsigned short j;
-
-p = &equot[0];
-*p++ = num[0];
-*p++ = num[1];
-
-for( i=M; i<NI; i++ )
-	{
-	*p++ = 0;
-	}
-
-/* Use faster compare and subtraction if denominator
- * has only 15 bits of significance.
- */
-p = &den[M+2];
-if( *p++ == 0 )
-	{
-	for( i=M+3; i<NI; i++ )
-		{
-		if( *p++ != 0 )
-			goto fulldiv;
-		}
-	if( (den[M+1] & 1) != 0 )
-		goto fulldiv;
-	eshdn1(num);
-	eshdn1(den);
-
-	p = &den[M+1];
-	q = &num[M+1];
-
-	for( i=0; i<NBITS+2; i++ )
-		{
-		if( *p <= *q )
-			{
-			*q -= *p;
-			j = 1;
-			}
-		else
-			{
-			j = 0;
-			}
-		eshup1(equot);
-		equot[NI-2] |= j;
-		eshup1(num);
-		}
-	goto divdon;
-	}
-
-/* The number of quotient bits to calculate is
- * NBITS + 1 scaling guard bit + 1 roundoff bit.
- */
-fulldiv:
-
-p = &equot[NI-2];
-for( i=0; i<NBITS+2; i++ )
-	{
-	if( ecmpm(den,num) <= 0 )
-		{
-		esubm(den, num);
-		j = 1;	/* quotient bit = 1 */
-		}
-	else
-		j = 0;
-	eshup1(equot);
-	*p |= j;
-	eshup1(num);
-	}
-
-divdon:
-
-eshdn1( equot );
-eshdn1( equot );
-
-/* test for nonzero remainder after roundoff bit */
-p = &num[M];
-j = 0;
-for( i=M; i<NI; i++ )
-	{
-	j |= *p++;
-	}
-if( j )
-	j = 1;
-
-
-for( i=0; i<NI; i++ )
-	num[i] = equot[i];
-return( (int )j );
-}
-
-/* Multiply significands */
-int emulm( a, b )
-unsigned short a[], b[];
-{
-unsigned short *p, *q;
-int i, j, k;
-
-equot[0] = b[0];
-equot[1] = b[1];
-for( i=M; i<NI; i++ )
-	equot[i] = 0;
-
-p = &a[NI-2];
-k = NBITS;
-while( *p == 0 ) /* significand is not supposed to be all zero */
-	{
-	eshdn6(a);
-	k -= 16;
-	}
-if( (*p & 0xff) == 0 )
-	{
-	eshdn8(a);
-	k -= 8;
-	}
-
-q = &equot[NI-1];
-j = 0;
-for( i=0; i<k; i++ )
-	{
-	if( *p & 1 )
-		eaddm(b, equot);
-/* remember if there were any nonzero bits shifted out */
-	if( *q & 1 )
-		j |= 1;
-	eshdn1(a);
-	eshdn1(equot);
-	}
-
-for( i=0; i<NI; i++ )
-	b[i] = equot[i];
-
-/* return flag for lost nonzero bits */
-return(j);
-}
-
-#else
-
-/* Multiply significand of e-type number b
-by 16-bit quantity a, e-type result to c. */
-
-void m16m( a, b, c )
-unsigned short a;
-unsigned short b[], c[];
-{
-register unsigned short *pp;
-register unsigned long carry;
-unsigned short *ps;
-unsigned short p[NI];
-unsigned long aa, m;
-int i;
-
-aa = a;
-pp = &p[NI-2];
-*pp++ = 0;
-*pp = 0;
-ps = &b[NI-1];
-
-for( i=M+1; i<NI; i++ )
-	{
-	if( *ps == 0 )
-		{
-		--ps;
-		--pp;
-		*(pp-1) = 0;
-		}
-	else
-		{
-		m = (unsigned long) aa * *ps--;
-		carry = (m & 0xffff) + *pp;
-		*pp-- = (unsigned short )carry;
-		carry = (carry >> 16) + (m >> 16) + *pp;
-		*pp = (unsigned short )carry;
-		*(pp-1) = carry >> 16;
-		}
-	}
-for( i=M; i<NI; i++ )
-	c[i] = p[i];
-}
-
-
-/* Divide significands. Neither the numerator nor the denominator
-is permitted to have its high guard word nonzero.  */
-
-
-int edivm( den, num )
-unsigned short den[], num[];
-{
-int i;
-register unsigned short *p;
-unsigned long tnum;
-unsigned short j, tdenm, tquot;
-unsigned short tprod[NI+1];
-
-p = &equot[0];
-*p++ = num[0];
-*p++ = num[1];
-
-for( i=M; i<NI; i++ )
-	{
-	*p++ = 0;
-	}
-eshdn1( num );
-tdenm = den[M+1];
-for( i=M; i<NI; i++ )
-	{
-	/* Find trial quotient digit (the radix is 65536). */
-	tnum = (((unsigned long) num[M]) << 16) + num[M+1];
-
-	/* Do not execute the divide instruction if it will overflow. */
-        if( (tdenm * 0xffffL) < tnum )
-		tquot = 0xffff;
-	else
-		tquot = tnum / tdenm;
-
-		/* Prove that the divide worked. */
-/*
-	tcheck = (unsigned long )tquot * tdenm;
-	if( tnum - tcheck > tdenm )
-		tquot = 0xffff;
-*/
-	/* Multiply denominator by trial quotient digit. */
-	m16m( tquot, den, tprod );
-	/* The quotient digit may have been overestimated. */
-	if( ecmpm( tprod, num ) > 0 )
-		{
-		tquot -= 1;
-		esubm( den, tprod );
-		if( ecmpm( tprod, num ) > 0 )
-			{
-			tquot -= 1;
-			esubm( den, tprod );
-			}
-		}
-/*
-	if( ecmpm( tprod, num ) > 0 )
-		{
-		eshow( "tprod", tprod );
-		eshow( "num  ", num );
-		printf( "tnum = %08lx, tden = %04x, tquot = %04x\n",
-			 tnum, den[M+1], tquot );
-		}
-*/
-	esubm( tprod, num );
-/*
-	if( ecmpm( num, den ) >= 0 )
-		{
-		eshow( "num  ", num );
-		eshow( "den  ", den );
-		printf( "tnum = %08lx, tden = %04x, tquot = %04x\n",
-			 tnum, den[M+1], tquot );
-		}
-*/
-	equot[i] = tquot;
-	eshup6(num);
-	}
-/* test for nonzero remainder after roundoff bit */
-p = &num[M];
-j = 0;
-for( i=M; i<NI; i++ )
-	{
-	j |= *p++;
-	}
-if( j )
-	j = 1;
-
-for( i=0; i<NI; i++ )
-	num[i] = equot[i];
-
-return( (int )j );
-}
-
-
-
-/* Multiply significands */
-int emulm( a, b )
-unsigned short a[], b[];
-{
-unsigned short *p, *q;
-unsigned short pprod[NI];
-unsigned short j;
-int i;
-
-equot[0] = b[0];
-equot[1] = b[1];
-for( i=M; i<NI; i++ )
-	equot[i] = 0;
-
-j = 0;
-p = &a[NI-1];
-q = &equot[NI-1];
-for( i=M+1; i<NI; i++ )
-	{
-	if( *p == 0 )
-		{
-		--p;
-		}
-	else
-		{
-		m16m( *p--, b, pprod );
-		eaddm(pprod, equot);
-		}
-	j |= *q;
-	eshdn6(equot);
-	}
-
-for( i=0; i<NI; i++ )
-	b[i] = equot[i];
-
-/* return flag for lost nonzero bits */
-return( (int)j );
-}
-
-
-/*
-eshow(str, x)
-char *str;
-unsigned short *x;
-{
-int i;
-
-printf( "%s ", str );
-for( i=0; i<NI; i++ )
-	printf( "%04x ", *x++ );
-printf( "\n" );
-}
-*/
-#endif
-
-
-
-/*
- * Normalize and round off.
- *
- * The internal format number to be rounded is "s".
- * Input "lost" indicates whether the number is exact.
- * This is the so-called sticky bit.
- *
- * Input "subflg" indicates whether the number was obtained
- * by a subtraction operation.  In that case if lost is nonzero
- * then the number is slightly smaller than indicated.
- *
- * Input "exp" is the biased exponent, which may be negative.
- * the exponent field of "s" is ignored but is replaced by
- * "exp" as adjusted by normalization and rounding.
- *
- * Input "rcntrl" is the rounding control.
- */
-
-static int rlast = -1;
-static int rw = 0;
-static unsigned short rmsk = 0;
-static unsigned short rmbit = 0;
-static unsigned short rebit = 0;
-static int re = 0;
-static unsigned short rbit[NI] = {0,0,0,0,0,0,0,0};
-
-void emdnorm( s, lost, subflg, exp, rcntrl )
-unsigned short s[];
-int lost;
-int subflg;
-long exp;
-int rcntrl;
-{
-int i, j;
-unsigned short r;
-
-/* Normalize */
-j = enormlz( s );
-
-/* a blank significand could mean either zero or infinity. */
-#ifndef INFINITY
-if( j > NBITS )
-	{
-	ecleazs( s );
-	return;
-	}
-#endif
-exp -= j;
-#ifndef INFINITY
-if( exp >= 32767L )
-	goto overf;
-#else
-if( (j > NBITS) && (exp < 32767L) )
-	{
-	ecleazs( s );
-	return;
-	}
-#endif
-if( exp < 0L )
-	{
-	if( exp > (long )(-NBITS-1) )
-		{
-		j = (int )exp;
-		i = eshift( s, j );
-		if( i )
-			lost = 1;
-		}
-	else
-		{
-		ecleazs( s );
-		return;
-		}
-	}
-/* Round off, unless told not to by rcntrl. */
-if( rcntrl == 0 )
-	goto mdfin;
-/* Set up rounding parameters if the control register changed. */
-if( rndprc != rlast )
-	{
-	ecleaz( rbit );
-	switch( rndprc )
-		{
-		default:
-		case NBITS:
-			rw = NI-1; /* low guard word */
-			rmsk = 0xffff;
-			rmbit = 0x8000;
-			rebit = 1;
-			re = rw - 1;
-			break;
-		case 113:
-			rw = 10;
-			rmsk = 0x7fff;
-			rmbit = 0x4000;
-			rebit = 0x8000;
-			re = rw;
-			break;
-		case 64:
-			rw = 7;
-			rmsk = 0xffff;
-			rmbit = 0x8000;
-			rebit = 1;
-			re = rw-1;
-			break;
-/* For DEC arithmetic */
-		case 56:
-			rw = 6;
-			rmsk = 0xff;
-			rmbit = 0x80;
-			rebit = 0x100;
-			re = rw;
-			break;
-		case 53:
-			rw = 6;
-			rmsk = 0x7ff;
-			rmbit = 0x0400;
-			rebit = 0x800;
-			re = rw;
-			break;
-		case 24:
-			rw = 4;
-			rmsk = 0xff;
-			rmbit = 0x80;
-			rebit = 0x100;
-			re = rw;
-			break;
-		}
-	rbit[re] = rebit;
-	rlast = rndprc;
-	}
-
-/* Shift down 1 temporarily if the data structure has an implied
- * most significant bit and the number is denormal.
- * For rndprc = 64 or NBITS, there is no implied bit.
- * But Intel long double denormals lose one bit of significance even so.
- */
-#if IBMPC
-if( (exp <= 0) && (rndprc != NBITS) )
-#else
-if( (exp <= 0) && (rndprc != 64) && (rndprc != NBITS) )
-#endif
-	{
-	lost |= s[NI-1] & 1;
-	eshdn1(s);
-	}
-/* Clear out all bits below the rounding bit,
- * remembering in r if any were nonzero.
- */
-r = s[rw] & rmsk;
-if( rndprc < NBITS )
-	{
-	i = rw + 1;
-	while( i < NI )
-		{
-		if( s[i] )
-			r |= 1;
-		s[i] = 0;
-		++i;
-		}
-	}
-s[rw] &= ~rmsk;
-if( (r & rmbit) != 0 )
-	{
-	if( r == rmbit )
-		{
-		if( lost == 0 )
-			{ /* round to even */
-			if( (s[re] & rebit) == 0 )
-				goto mddone;
-			}
-		else
-			{
-			if( subflg != 0 )
-				goto mddone;
-			}
-		}
-	eaddm( rbit, s );
-	}
-mddone:
-#if IBMPC
-if( (exp <= 0) && (rndprc != NBITS) )
-#else
-if( (exp <= 0) && (rndprc != 64) && (rndprc != NBITS) )
-#endif
-	{
-	eshup1(s);
-	}
-if( s[2] != 0 )
-	{ /* overflow on roundoff */
-	eshdn1(s);
-	exp += 1;
-	}
-mdfin:
-s[NI-1] = 0;
-if( exp >= 32767L )
-	{
-#ifndef INFINITY
-overf:
-#endif
-#ifdef INFINITY
-	s[1] = 32767;
-	for( i=2; i<NI-1; i++ )
-		s[i] = 0;
-#else
-	s[1] = 32766;
-	s[2] = 0;
-	for( i=M+1; i<NI-1; i++ )
-		s[i] = 0xffff;
-	s[NI-1] = 0;
-	if( (rndprc < 64) || (rndprc == 113) )
-		{
-		s[rw] &= ~rmsk;
-		if( rndprc == 24 )
-			{
-			s[5] = 0;
-			s[6] = 0;
-			}
-		}
-#endif
-	return;
-	}
-if( exp < 0 )
-	s[1] = 0;
-else
-	s[1] = (unsigned short )exp;
-}
-
-
-
-/*
-;	Subtract external format numbers.
-;
-;	unsigned short a[NE], b[NE], c[NE];
-;	esub( a, b, c );	 c = b - a
-*/
-
-static int subflg = 0;
-
-void esub( a, b, c )
-unsigned short *a, *b, *c;
-{
-
-#ifdef NANS
-if( eisnan(a) )
-	{
-	emov (a, c);
-	return;
-	}
-if( eisnan(b) )
-	{
-	emov(b,c);
-	return;
-	}
-/* Infinity minus infinity is a NaN.
- * Test for subtracting infinities of the same sign.
- */
-if( eisinf(a) && eisinf(b) && ((eisneg (a) ^ eisneg (b)) == 0))
-	{
-	mtherr( "esub", DOMAIN );
-	enan( c, NBITS );
-	return;
-	}
-#endif
-subflg = 1;
-eadd1( a, b, c );
-}
-
-
-/*
-;	Add.
-;
-;	unsigned short a[NE], b[NE], c[NE];
-;	eadd( a, b, c );	 c = b + a
-*/
-void eadd( a, b, c )
-unsigned short *a, *b, *c;
-{
-
-#ifdef NANS
-/* NaN plus anything is a NaN. */
-if( eisnan(a) )
-	{
-	emov(a,c);
-	return;
-	}
-if( eisnan(b) )
-	{
-	emov(b,c);
-	return;
-	}
-/* Infinity minus infinity is a NaN.
- * Test for adding infinities of opposite signs.
- */
-if( eisinf(a) && eisinf(b)
-	&& ((eisneg(a) ^ eisneg(b)) != 0) )
-	{
-	mtherr( "eadd", DOMAIN );
-	enan( c, NBITS );
-	return;
-	}
-#endif
-subflg = 0;
-eadd1( a, b, c );
-}
-
-void eadd1( a, b, c )
-unsigned short *a, *b, *c;
-{
-unsigned short ai[NI], bi[NI], ci[NI];
-int i, lost, j, k;
-long lt, lta, ltb;
-
-#ifdef INFINITY
-if( eisinf(a) )
-	{
-	emov(a,c);
-	if( subflg )
-		eneg(c);
-	return;
-	}
-if( eisinf(b) )
-	{
-	emov(b,c);
-	return;
-	}
-#endif
-emovi( a, ai );
-emovi( b, bi );
-if( subflg )
-	ai[0] = ~ai[0];
-
-/* compare exponents */
-lta = ai[E];
-ltb = bi[E];
-lt = lta - ltb;
-if( lt > 0L )
-	{	/* put the larger number in bi */
-	emovz( bi, ci );
-	emovz( ai, bi );
-	emovz( ci, ai );
-	ltb = bi[E];
-	lt = -lt;
-	}
-lost = 0;
-if( lt != 0L )
-	{
-	if( lt < (long )(-NBITS-1) )
-		goto done;	/* answer same as larger addend */
-	k = (int )lt;
-	lost = eshift( ai, k ); /* shift the smaller number down */
-	}
-else
-	{
-/* exponents were the same, so must compare significands */
-	i = ecmpm( ai, bi );
-	if( i == 0 )
-		{ /* the numbers are identical in magnitude */
-		/* if different signs, result is zero */
-		if( ai[0] != bi[0] )
-			{
-			eclear(c);
-			return;
-			}
-		/* if same sign, result is double */
-		/* double denomalized tiny number */
-		if( (bi[E] == 0) && ((bi[3] & 0x8000) == 0) )
-			{
-			eshup1( bi );
-			goto done;
-			}
-		/* add 1 to exponent unless both are zero! */
-		for( j=1; j<NI-1; j++ )
-			{
-			if( bi[j] != 0 )
-				{
-/* This could overflow, but let emovo take care of that. */
-				ltb += 1;
-				break;
-				}
-			}
-		bi[E] = (unsigned short )ltb;
-		goto done;
-		}
-	if( i > 0 )
-		{	/* put the larger number in bi */
-		emovz( bi, ci );
-		emovz( ai, bi );
-		emovz( ci, ai );
-		}
-	}
-if( ai[0] == bi[0] )
-	{
-	eaddm( ai, bi );
-	subflg = 0;
-	}
-else
-	{
-	esubm( ai, bi );
-	subflg = 1;
-	}
-emdnorm( bi, lost, subflg, ltb, 64 );
-
-done:
-emovo( bi, c );
-}
-
-
-
-/*
-;	Divide.
-;
-;	unsigned short a[NE], b[NE], c[NE];
-;	ediv( a, b, c );	c = b / a
-*/
-void ediv( a, b, c )
-unsigned short *a, *b, *c;
-{
-unsigned short ai[NI], bi[NI];
-int i;
-long lt, lta, ltb;
-
-#ifdef NANS
-/* Return any NaN input. */
-if( eisnan(a) )
-	{
-	emov(a,c);
-	return;
-	}
-if( eisnan(b) )
-	{
-	emov(b,c);
-	return;
-	}
-/* Zero over zero, or infinity over infinity, is a NaN. */
-if( ((ecmp(a,ezero) == 0) && (ecmp(b,ezero) == 0))
-	|| (eisinf (a) && eisinf (b)) )
-	{
-	mtherr( "ediv", DOMAIN );
-	enan( c, NBITS );
-	return;
-	}
-#endif
-/* Infinity over anything else is infinity. */
-#ifdef INFINITY
-if( eisinf(b) )
-	{
-	if( eisneg(a) ^ eisneg(b) )
-		*(c+(NE-1)) = 0x8000;
-	else
-		*(c+(NE-1)) = 0;
-	einfin(c);
-	return;
-	}
-if( eisinf(a) )
-	{
-	eclear(c);
-	return;
-	}
-#endif
-emovi( a, ai );
-emovi( b, bi );
-lta = ai[E];
-ltb = bi[E];
-if( bi[E] == 0 )
-	{ /* See if numerator is zero. */
-	for( i=1; i<NI-1; i++ )
-		{
-		if( bi[i] != 0 )
-			{
-			ltb -= enormlz( bi );
-			goto dnzro1;
-			}
-		}
-	eclear(c);
-	return;
-	}
-dnzro1:
-
-if( ai[E] == 0 )
-	{	/* possible divide by zero */
-	for( i=1; i<NI-1; i++ )
-		{
-		if( ai[i] != 0 )
-			{
-			lta -= enormlz( ai );
-			goto dnzro2;
-			}
-		}
-	if( ai[0] == bi[0] )
-		*(c+(NE-1)) = 0;
-	else
-		*(c+(NE-1)) = 0x8000;
-	einfin(c);
-	mtherr( "ediv", SING );
-	return;
-	}
-dnzro2:
-
-i = edivm( ai, bi );
-/* calculate exponent */
-lt = ltb - lta + EXONE;
-emdnorm( bi, i, 0, lt, 64 );
-/* set the sign */
-if( ai[0] == bi[0] )
-	bi[0] = 0;
-else
-	bi[0] = 0Xffff;
-emovo( bi, c );
-}
-
-
-
-/*
-;	Multiply.
-;
-;	unsigned short a[NE], b[NE], c[NE];
-;	emul( a, b, c );	c = b * a
-*/
-void emul( a, b, c )
-unsigned short *a, *b, *c;
-{
-unsigned short ai[NI], bi[NI];
-int i, j;
-long lt, lta, ltb;
-
-#ifdef NANS
-/* NaN times anything is the same NaN. */
-if( eisnan(a) )
-	{
-	emov(a,c);
-	return;
-	}
-if( eisnan(b) )
-	{
-	emov(b,c);
-	return;
-	}
-/* Zero times infinity is a NaN. */
-if( (eisinf(a) && (ecmp(b,ezero) == 0))
-	|| (eisinf(b) && (ecmp(a,ezero) == 0)) )
-	{
-	mtherr( "emul", DOMAIN );
-	enan( c, NBITS );
-	return;
-	}
-#endif
-/* Infinity times anything else is infinity. */
-#ifdef INFINITY
-if( eisinf(a) || eisinf(b) )
-	{
-	if( eisneg(a) ^ eisneg(b) )
-		*(c+(NE-1)) = 0x8000;
-	else
-		*(c+(NE-1)) = 0;
-	einfin(c);
-	return;
-	}
-#endif
-emovi( a, ai );
-emovi( b, bi );
-lta = ai[E];
-ltb = bi[E];
-if( ai[E] == 0 )
-	{
-	for( i=1; i<NI-1; i++ )
-		{
-		if( ai[i] != 0 )
-			{
-			lta -= enormlz( ai );
-			goto mnzer1;
-			}
-		}
-	eclear(c);
-	return;
-	}
-mnzer1:
-
-if( bi[E] == 0 )
-	{
-	for( i=1; i<NI-1; i++ )
-		{
-		if( bi[i] != 0 )
-			{
-			ltb -= enormlz( bi );
-			goto mnzer2;
-			}
-		}
-	eclear(c);
-	return;
-	}
-mnzer2:
-
-/* Multiply significands */
-j = emulm( ai, bi );
-/* calculate exponent */
-lt = lta + ltb - (EXONE - 1);
-emdnorm( bi, j, 0, lt, 64 );
-/* calculate sign of product */
-if( ai[0] == bi[0] )
-	bi[0] = 0;
-else
-	bi[0] = 0xffff;
-emovo( bi, c );
-}
-
-
-
-
-/*
-; Convert IEEE double precision to e type
-;	double d;
-;	unsigned short x[N+2];
-;	e53toe( &d, x );
-*/
-void e53toe( pe, y )
-unsigned short *pe, *y;
-{
-#ifdef DEC
-
-dectoe( pe, y ); /* see etodec.c */
-
-#else
-
-register unsigned short r;
-register unsigned short *p, *e;
-unsigned short yy[NI];
-int denorm, k;
-
-e = pe;
-denorm = 0;	/* flag if denormalized number */
-ecleaz(yy);
-#ifdef IBMPC
-e += 3;
-#endif
-r = *e;
-yy[0] = 0;
-if( r & 0x8000 )
-	yy[0] = 0xffff;
-yy[M] = (r & 0x0f) | 0x10;
-r &= ~0x800f;	/* strip sign and 4 significand bits */
-#ifdef INFINITY
-if( r == 0x7ff0 )
-	{
-#ifdef NANS
-#ifdef IBMPC
-	if( ((pe[3] & 0xf) != 0) || (pe[2] != 0)
-		|| (pe[1] != 0) || (pe[0] != 0) )
-		{
-		enan( y, NBITS );
-		return;
-		}
-#else
-	if( ((pe[0] & 0xf) != 0) || (pe[1] != 0)
-		 || (pe[2] != 0) || (pe[3] != 0) )
-		{
-		enan( y, NBITS );
-		return;
-		}
-#endif
-#endif  /* NANS */
-	eclear( y );
-	einfin( y );
-	if( yy[0] )
-		eneg(y);
-	return;
-	}
-#endif
-r >>= 4;
-/* If zero exponent, then the significand is denormalized.
- * So, take back the understood high significand bit. */ 
-if( r == 0 )
-	{
-	denorm = 1;
-	yy[M] &= ~0x10;
-	}
-r += EXONE - 01777;
-yy[E] = r;
-p = &yy[M+1];
-#ifdef IBMPC
-*p++ = *(--e);
-*p++ = *(--e);
-*p++ = *(--e);
-#endif
-#ifdef MIEEE
-++e;
-*p++ = *e++;
-*p++ = *e++;
-*p++ = *e++;
-#endif
-(void )eshift( yy, -5 );
-if( denorm )
-	{ /* if zero exponent, then normalize the significand */
-	if( (k = enormlz(yy)) > NBITS )
-		ecleazs(yy);
-	else
-		yy[E] -= (unsigned short )(k-1);
-	}
-emovo( yy, y );
-#endif /* not DEC */
-}
-
-void e64toe( pe, y )
-unsigned short *pe, *y;
-{
-unsigned short yy[NI];
-unsigned short *p, *q, *e;
-int i;
-
-e = pe;
-p = yy;
-for( i=0; i<NE-5; i++ )
-	*p++ = 0;
-#ifdef IBMPC
-for( i=0; i<5; i++ )
-	*p++ = *e++;
-#endif
-#ifdef DEC
-for( i=0; i<5; i++ )
-	*p++ = *e++;
-#endif
-#ifdef MIEEE
-p = &yy[0] + (NE-1);
-*p-- = *e++;
-++e;
-for( i=0; i<4; i++ )
-	*p-- = *e++;
-#endif
-
-#ifdef IBMPC
-/* For Intel long double, shift denormal significand up 1
-   -- but only if the top significand bit is zero.  */
-if((yy[NE-1] & 0x7fff) == 0 && (yy[NE-2] & 0x8000) == 0)
-  {
-    unsigned short temp[NI+1];
-    emovi(yy, temp);
-    eshup1(temp);
-    emovo(temp,y);
-    return;
-  }
-#endif
-#ifdef INFINITY
-/* Point to the exponent field.  */
-p = &yy[NE-1];
-if( *p == 0x7fff )
-	{
-#ifdef NANS
-#ifdef IBMPC
-	for( i=0; i<4; i++ )
-		{
-		if((i != 3 && pe[i] != 0)
-		   /* Check for Intel long double infinity pattern.  */
-		   || (i == 3 && pe[i] != 0x8000))
-			{
-			enan( y, NBITS );
-			return;
-			}
-		}
-#else
-	for( i=1; i<=4; i++ )
-		{
-		if( pe[i] != 0 )
-			{
-			enan( y, NBITS );
-			return;
-			}
-		}
-#endif
-#endif /* NANS */
-	eclear( y );
-	einfin( y );
-	if( *p & 0x8000 )
-		eneg(y);
-	return;
-	}
-#endif
-p = yy;
-q = y;
-for( i=0; i<NE; i++ )
-	*q++ = *p++;
-}
-
-void e113toe(pe,y)
-unsigned short *pe, *y;
-{
-register unsigned short r;
-unsigned short *e, *p;
-unsigned short yy[NI];
-int denorm, i;
-
-e = pe;
-denorm = 0;
-ecleaz(yy);
-#ifdef IBMPC
-e += 7;
-#endif
-r = *e;
-yy[0] = 0;
-if( r & 0x8000 )
-	yy[0] = 0xffff;
-r &= 0x7fff;
-#ifdef INFINITY
-if( r == 0x7fff )
-	{
-#ifdef NANS
-#ifdef IBMPC
-	for( i=0; i<7; i++ )
-		{
-		if( pe[i] != 0 )
-			{
-			enan( y, NBITS );
-			return;
-			}
-		}
-#else
-	for( i=1; i<8; i++ )
-		{
-		if( pe[i] != 0 )
-			{
-			enan( y, NBITS );
-			return;
-			}
-		}
-#endif
-#endif /* NANS */
-	eclear( y );
-	einfin( y );
-	if( *e & 0x8000 )
-		eneg(y);
-	return;
-	}
-#endif  /* INFINITY */
-yy[E] = r;
-p = &yy[M + 1];
-#ifdef IBMPC
-for( i=0; i<7; i++ )
-	*p++ = *(--e);
-#endif
-#ifdef MIEEE
-++e;
-for( i=0; i<7; i++ )
-	*p++ = *e++;
-#endif
-/* If denormal, remove the implied bit; else shift down 1. */
-if( r == 0 )
-	{
-	yy[M] = 0;
-	}
-else
-	{
-	yy[M] = 1;
-	eshift( yy, -1 );
-	}
-emovo(yy,y);
-}
-
-
-/*
-; Convert IEEE single precision to e type
-;	float d;
-;	unsigned short x[N+2];
-;	dtox( &d, x );
-*/
-void e24toe( pe, y )
-unsigned short *pe, *y;
-{
-register unsigned short r;
-register unsigned short *p, *e;
-unsigned short yy[NI];
-int denorm, k;
-
-e = pe;
-denorm = 0;	/* flag if denormalized number */
-ecleaz(yy);
-#ifdef IBMPC
-e += 1;
-#endif
-#ifdef DEC
-e += 1;
-#endif
-r = *e;
-yy[0] = 0;
-if( r & 0x8000 )
-	yy[0] = 0xffff;
-yy[M] = (r & 0x7f) | 0200;
-r &= ~0x807f;	/* strip sign and 7 significand bits */
-#ifdef INFINITY
-if( r == 0x7f80 )
-	{
-#ifdef NANS
-#ifdef MIEEE
-	if( ((pe[0] & 0x7f) != 0) || (pe[1] != 0) )
-		{
-		enan( y, NBITS );
-		return;
-		}
-#else
-	if( ((pe[1] & 0x7f) != 0) || (pe[0] != 0) )
-		{
-		enan( y, NBITS );
-		return;
-		}
-#endif
-#endif  /* NANS */
-	eclear( y );
-	einfin( y );
-	if( yy[0] )
-		eneg(y);
-	return;
-	}
-#endif
-r >>= 7;
-/* If zero exponent, then the significand is denormalized.
- * So, take back the understood high significand bit. */ 
-if( r == 0 )
-	{
-	denorm = 1;
-	yy[M] &= ~0200;
-	}
-r += EXONE - 0177;
-yy[E] = r;
-p = &yy[M+1];
-#ifdef IBMPC
-*p++ = *(--e);
-#endif
-#ifdef DEC
-*p++ = *(--e);
-#endif
-#ifdef MIEEE
-++e;
-*p++ = *e++;
-#endif
-(void )eshift( yy, -8 );
-if( denorm )
-	{ /* if zero exponent, then normalize the significand */
-	if( (k = enormlz(yy)) > NBITS )
-		ecleazs(yy);
-	else
-		yy[E] -= (unsigned short )(k-1);
-	}
-emovo( yy, y );
-}
-
-void etoe113(x,e)
-unsigned short *x, *e;
-{
-unsigned short xi[NI];
-long exp;
-int rndsav;
-
-#ifdef NANS
-if( eisnan(x) )
-	{
-	enan( e, 113 );
-	return;
-	}
-#endif
-emovi( x, xi );
-exp = (long )xi[E];
-#ifdef INFINITY
-if( eisinf(x) )
-	goto nonorm;
-#endif
-/* round off to nearest or even */
-rndsav = rndprc;
-rndprc = 113;
-emdnorm( xi, 0, 0, exp, 64 );
-rndprc = rndsav;
-nonorm:
-toe113 (xi, e);
-}
-
-/* move out internal format to ieee long double */
-static void toe113(a,b)
-unsigned short *a, *b;
-{
-register unsigned short *p, *q;
-unsigned short i;
-
-#ifdef NANS
-if( eiisnan(a) )
-	{
-	enan( b, 113 );
-	return;
-	}
-#endif
-p = a;
-#ifdef MIEEE
-q = b;
-#else
-q = b + 7;			/* point to output exponent */
-#endif
-
-/* If not denormal, delete the implied bit. */
-if( a[E] != 0 )
-	{
-	eshup1 (a);
-	}
-/* combine sign and exponent */
-i = *p++;
-#ifdef MIEEE
-if( i )
-	*q++ = *p++ | 0x8000;
-else
-	*q++ = *p++;
-#else
-if( i )
-	*q-- = *p++ | 0x8000;
-else
-	*q-- = *p++;
-#endif
-/* skip over guard word */
-++p;
-/* move the significand */
-#ifdef MIEEE
-for (i = 0; i < 7; i++)
-	*q++ = *p++;
-#else
-for (i = 0; i < 7; i++)
-	*q-- = *p++;
-#endif
-}
-
-
-void etoe64( x, e )
-unsigned short *x, *e;
-{
-unsigned short xi[NI];
-long exp;
-int rndsav;
-
-#ifdef NANS
-if( eisnan(x) )
-	{
-	enan( e, 64 );
-	return;
-	}
-#endif
-emovi( x, xi );
-exp = (long )xi[E]; /* adjust exponent for offset */
-#ifdef INFINITY
-if( eisinf(x) )
-	goto nonorm;
-#endif
-/* round off to nearest or even */
-rndsav = rndprc;
-rndprc = 64;
-emdnorm( xi, 0, 0, exp, 64 );
-rndprc = rndsav;
-nonorm:
-toe64( xi, e );
-}
-
-/* move out internal format to ieee long double */
-static void toe64( a, b )
-unsigned short *a, *b;
-{
-register unsigned short *p, *q;
-unsigned short i;
-
-#ifdef NANS
-if( eiisnan(a) )
-	{
-	enan( b, 64 );
-	return;
-	}
-#endif
-#ifdef IBMPC
-/* Shift Intel denormal significand down 1.  */
-if( a[E] == 0 )
-  eshdn1(a);
-#endif
-p = a;
-#ifdef MIEEE
-q = b;
-#else
-q = b + 4; /* point to output exponent */
-#if 1
-/* NOTE: if data type is 96 bits wide, clear the last word here. */
-*(q+1)= 0;
-#endif
-#endif
-
-/* combine sign and exponent */
-i = *p++;
-#ifdef MIEEE
-if( i )
-	*q++ = *p++ | 0x8000;
-else
-	*q++ = *p++;
-*q++ = 0;
-#else
-if( i )
-	*q-- = *p++ | 0x8000;
-else
-	*q-- = *p++;
-#endif
-/* skip over guard word */
-++p;
-/* move the significand */
-#ifdef MIEEE
-for( i=0; i<4; i++ )
-	*q++ = *p++;
-#else
-#ifdef INFINITY
-if (eiisinf (a))
-        {
-	/* Intel long double infinity.  */
-	*q-- = 0x8000;
-	*q-- = 0;
-	*q-- = 0;
-	*q = 0;
-	return;
-	}
-#endif
-for( i=0; i<4; i++ )
-	*q-- = *p++;
-#endif
-}
-
-
-/*
-; e type to IEEE double precision
-;	double d;
-;	unsigned short x[NE];
-;	etoe53( x, &d );
-*/
-
-#ifdef DEC
-
-void etoe53( x, e )
-unsigned short *x, *e;
-{
-etodec( x, e ); /* see etodec.c */
-}
-
-static void toe53( x, y )
-unsigned short *x, *y;
-{
-todec( x, y );
-}
-
-#else
-
-void etoe53( x, e )
-unsigned short *x, *e;
-{
-unsigned short xi[NI];
-long exp;
-int rndsav;
-
-#ifdef NANS
-if( eisnan(x) )
-	{
-	enan( e, 53 );
-	return;
-	}
-#endif
-emovi( x, xi );
-exp = (long )xi[E] - (EXONE - 0x3ff); /* adjust exponent for offsets */
-#ifdef INFINITY
-if( eisinf(x) )
-	goto nonorm;
-#endif
-/* round off to nearest or even */
-rndsav = rndprc;
-rndprc = 53;
-emdnorm( xi, 0, 0, exp, 64 );
-rndprc = rndsav;
-nonorm:
-toe53( xi, e );
-}
-
-
-static void toe53( x, y )
-unsigned short *x, *y;
-{
-unsigned short i;
-unsigned short *p;
-
-
-#ifdef NANS
-if( eiisnan(x) )
-	{
-	enan( y, 53 );
-	return;
-	}
-#endif
-p = &x[0];
-#ifdef IBMPC
-y += 3;
-#endif
-*y = 0;	/* output high order */
-if( *p++ )
-	*y = 0x8000;	/* output sign bit */
-
-i = *p++;
-if( i >= (unsigned int )2047 )
-	{	/* Saturate at largest number less than infinity. */
-#ifdef INFINITY
-	*y |= 0x7ff0;
-#ifdef IBMPC
-	*(--y) = 0;
-	*(--y) = 0;
-	*(--y) = 0;
-#endif
-#ifdef MIEEE
-	++y;
-	*y++ = 0;
-	*y++ = 0;
-	*y++ = 0;
-#endif
-#else
-	*y |= (unsigned short )0x7fef;
-#ifdef IBMPC
-	*(--y) = 0xffff;
-	*(--y) = 0xffff;
-	*(--y) = 0xffff;
-#endif
-#ifdef MIEEE
-	++y;
-	*y++ = 0xffff;
-	*y++ = 0xffff;
-	*y++ = 0xffff;
-#endif
-#endif
-	return;
-	}
-if( i == 0 )
-	{
-	(void )eshift( x, 4 );
-	}
-else
-	{
-	i <<= 4;
-	(void )eshift( x, 5 );
-	}
-i |= *p++ & (unsigned short )0x0f;	/* *p = xi[M] */
-*y |= (unsigned short )i; /* high order output already has sign bit set */
-#ifdef IBMPC
-*(--y) = *p++;
-*(--y) = *p++;
-*(--y) = *p;
-#endif
-#ifdef MIEEE
-++y;
-*y++ = *p++;
-*y++ = *p++;
-*y++ = *p++;
-#endif
-}
-
-#endif /* not DEC */
-
-
-
-/*
-; e type to IEEE single precision
-;	float d;
-;	unsigned short x[N+2];
-;	xtod( x, &d );
-*/
-void etoe24( x, e )
-unsigned short *x, *e;
-{
-long exp;
-unsigned short xi[NI];
-int rndsav;
-
-#ifdef NANS
-if( eisnan(x) )
-	{
-	enan( e, 24 );
-	return;
-	}
-#endif
-emovi( x, xi );
-exp = (long )xi[E] - (EXONE - 0177); /* adjust exponent for offsets */
-#ifdef INFINITY
-if( eisinf(x) )
-	goto nonorm;
-#endif
-/* round off to nearest or even */
-rndsav = rndprc;
-rndprc = 24;
-emdnorm( xi, 0, 0, exp, 64 );
-rndprc = rndsav;
-nonorm:
-toe24( xi, e );
-}
-
-static void toe24( x, y )
-unsigned short *x, *y;
-{
-unsigned short i;
-unsigned short *p;
-
-#ifdef NANS
-if( eiisnan(x) )
-	{
-	enan( y, 24 );
-	return;
-	}
-#endif
-p = &x[0];
-#ifdef IBMPC
-y += 1;
-#endif
-#ifdef DEC
-y += 1;
-#endif
-*y = 0;	/* output high order */
-if( *p++ )
-	*y = 0x8000;	/* output sign bit */
-
-i = *p++;
-if( i >= 255 )
-	{	/* Saturate at largest number less than infinity. */
-#ifdef INFINITY
-	*y |= (unsigned short )0x7f80;
-#ifdef IBMPC
-	*(--y) = 0;
-#endif
-#ifdef DEC
-	*(--y) = 0;
-#endif
-#ifdef MIEEE
-	++y;
-	*y = 0;
-#endif
-#else
-	*y |= (unsigned short )0x7f7f;
-#ifdef IBMPC
-	*(--y) = 0xffff;
-#endif
-#ifdef DEC
-	*(--y) = 0xffff;
-#endif
-#ifdef MIEEE
-	++y;
-	*y = 0xffff;
-#endif
-#endif
-	return;
-	}
-if( i == 0 )
-	{
-	(void )eshift( x, 7 );
-	}
-else
-	{
-	i <<= 7;
-	(void )eshift( x, 8 );
-	}
-i |= *p++ & (unsigned short )0x7f;	/* *p = xi[M] */
-*y |= i;	/* high order output already has sign bit set */
-#ifdef IBMPC
-*(--y) = *p;
-#endif
-#ifdef DEC
-*(--y) = *p;
-#endif
-#ifdef MIEEE
-++y;
-*y = *p;
-#endif
-}
-
-
-/* Compare two e type numbers.
- *
- * unsigned short a[NE], b[NE];
- * ecmp( a, b );
- *
- *  returns +1 if a > b
- *           0 if a == b
- *          -1 if a < b
- *          -2 if either a or b is a NaN.
- */
-int ecmp( a, b )
-unsigned short *a, *b;
-{
-unsigned short ai[NI], bi[NI];
-register unsigned short *p, *q;
-register int i;
-int msign;
-
-#ifdef NANS
-if (eisnan (a)  || eisnan (b))
-	return( -2 );
-#endif
-emovi( a, ai );
-p = ai;
-emovi( b, bi );
-q = bi;
-
-if( *p != *q )
-	{ /* the signs are different */
-/* -0 equals + 0 */
-	for( i=1; i<NI-1; i++ )
-		{
-		if( ai[i] != 0 )
-			goto nzro;
-		if( bi[i] != 0 )
-			goto nzro;
-		}
-	return(0);
-nzro:
-	if( *p == 0 )
-		return( 1 );
-	else
-		return( -1 );
-	}
-/* both are the same sign */
-if( *p == 0 )
-	msign = 1;
-else
-	msign = -1;
-i = NI-1;
-do
-	{
-	if( *p++ != *q++ )
-		{
-		goto diff;
-		}
-	}
-while( --i > 0 );
-
-return(0);	/* equality */
-
-
-
-diff:
-
-if( *(--p) > *(--q) )
-	return( msign );		/* p is bigger */
-else
-	return( -msign );	/* p is littler */
-}
-
-
-
-
-/* Find nearest integer to x = floor( x + 0.5 )
- *
- * unsigned short x[NE], y[NE]
- * eround( x, y );
- */
-void eround( x, y )
-unsigned short *x, *y;
-{
-
-eadd( ehalf, x, y );
-efloor( y, y );
-}
-
-
-
-
-/*
-; convert long (32-bit) integer to e type
-;
-;	long l;
-;	unsigned short x[NE];
-;	ltoe( &l, x );
-; note &l is the memory address of l
-*/
-void ltoe( lp, y )
-long *lp;	/* lp is the memory address of a long integer */
-unsigned short *y;	/* y is the address of a short */
-{
-unsigned short yi[NI];
-unsigned long ll;
-int k;
-
-ecleaz( yi );
-if( *lp < 0 )
-	{
-	ll =  (unsigned long )( -(*lp) ); /* make it positive */
-	yi[0] = 0xffff; /* put correct sign in the e type number */
-	}
-else
-	{
-	ll = (unsigned long )( *lp );
-	}
-/* move the long integer to yi significand area */
-if( sizeof(long) == 8 )
-	{
-	yi[M] = (unsigned short) (ll >> (LONGBITS - 16));
-	yi[M + 1] = (unsigned short) (ll >> (LONGBITS - 32));
-	yi[M + 2] = (unsigned short) (ll >> 16);
-	yi[M + 3] = (unsigned short) ll;
-	yi[E] = EXONE + 47; /* exponent if normalize shift count were 0 */
-	}
-else
-	{
-	yi[M] = (unsigned short )(ll >> 16); 
-	yi[M+1] = (unsigned short )ll;
-	yi[E] = EXONE + 15; /* exponent if normalize shift count were 0 */
-	}
-if( (k = enormlz( yi )) > NBITS ) /* normalize the significand */
-	ecleaz( yi );	/* it was zero */
-else
-	yi[E] -= (unsigned short )k; /* subtract shift count from exponent */
-emovo( yi, y );	/* output the answer */
-}
-
-/*
-; convert unsigned long (32-bit) integer to e type
-;
-;	unsigned long l;
-;	unsigned short x[NE];
-;	ltox( &l, x );
-; note &l is the memory address of l
-*/
-void ultoe( lp, y )
-unsigned long *lp; /* lp is the memory address of a long integer */
-unsigned short *y;	/* y is the address of a short */
-{
-unsigned short yi[NI];
-unsigned long ll;
-int k;
-
-ecleaz( yi );
-ll = *lp;
-
-/* move the long integer to ayi significand area */
-if( sizeof(long) == 8 )
-	{
-	yi[M] = (unsigned short) (ll >> (LONGBITS - 16));
-	yi[M + 1] = (unsigned short) (ll >> (LONGBITS - 32));
-	yi[M + 2] = (unsigned short) (ll >> 16);
-	yi[M + 3] = (unsigned short) ll;
-	yi[E] = EXONE + 47; /* exponent if normalize shift count were 0 */
-	}
-else
-	{
-	yi[M] = (unsigned short )(ll >> 16); 
-	yi[M+1] = (unsigned short )ll;
-	yi[E] = EXONE + 15; /* exponent if normalize shift count were 0 */
-	}
-if( (k = enormlz( yi )) > NBITS ) /* normalize the significand */
-	ecleaz( yi );	/* it was zero */
-else
-	yi[E] -= (unsigned short )k; /* subtract shift count from exponent */
-emovo( yi, y );	/* output the answer */
-}
-
-
-/*
-;	Find long integer and fractional parts
-
-;	long i;
-;	unsigned short x[NE], frac[NE];
-;	xifrac( x, &i, frac );
- 
-  The integer output has the sign of the input.  The fraction is
-  the positive fractional part of abs(x).
-*/
-void eifrac( x, i, frac )
-unsigned short *x;
-long *i;
-unsigned short *frac;
-{
-unsigned short xi[NI];
-int j, k;
-unsigned long ll;
-
-emovi( x, xi );
-k = (int )xi[E] - (EXONE - 1);
-if( k <= 0 )
-	{
-/* if exponent <= 0, integer = 0 and real output is fraction */
-	*i = 0L;
-	emovo( xi, frac );
-	return;
-	}
-if( k > (8 * sizeof(long) - 1) )
-	{
-/*
-;	long integer overflow: output large integer
-;	and correct fraction
-*/
-	j = 8 * sizeof(long) - 1;
-	if( xi[0] )
-		*i = (long) ((unsigned long) 1) << j;
-	else
-		*i = (long) (((unsigned long) (~(0L))) >> 1);
-	(void )eshift( xi, k );
-	}
-if( k > 16 )
-	{
-/*
-  Shift more than 16 bits: shift up k-16 mod 16
-  then shift by 16's.
-*/
-	j = k - ((k >> 4) << 4);
-	eshift (xi, j);
-	ll = xi[M];
-	k -= j;
-	do
-		{
-		eshup6 (xi);
-		ll = (ll << 16) | xi[M];
-		}
-	while ((k -= 16) > 0);
-	*i = ll;
-	if (xi[0])
-		*i = -(*i);
-	}
-else
-	{
-/* shift not more than 16 bits */
-	eshift( xi, k );
-	*i = (long )xi[M] & 0xffff;
-	if( xi[0] )
-		*i = -(*i);
-	}
-xi[0] = 0;
-xi[E] = EXONE - 1;
-xi[M] = 0;
-if( (k = enormlz( xi )) > NBITS )
-	ecleaz( xi );
-else
-	xi[E] -= (unsigned short )k;
-
-emovo( xi, frac );
-}
-
-
-/*
-;	Find unsigned long integer and fractional parts
-
-;	unsigned long i;
-;	unsigned short x[NE], frac[NE];
-;	xifrac( x, &i, frac );
-
-  A negative e type input yields integer output = 0
-  but correct fraction.
-*/
-void euifrac( x, i, frac )
-unsigned short *x;
-unsigned long *i;
-unsigned short *frac;
-{
-unsigned short xi[NI];
-int j, k;
-unsigned long ll;
-
-emovi( x, xi );
-k = (int )xi[E] - (EXONE - 1);
-if( k <= 0 )
-	{
-/* if exponent <= 0, integer = 0 and argument is fraction */
-	*i = 0L;
-	emovo( xi, frac );
-	return;
-	}
-if( k > (8 * sizeof(long)) )
-	{
-/*
-;	long integer overflow: output large integer
-;	and correct fraction
-*/
-	*i = ~(0L);
-	(void )eshift( xi, k );
-	}
-else if( k > 16 )
-	{
-/*
-  Shift more than 16 bits: shift up k-16 mod 16
-  then shift up by 16's.
-*/
-	j = k - ((k >> 4) << 4);
-	eshift (xi, j);
-	ll = xi[M];
-	k -= j;
-	do
-		{
-		eshup6 (xi);
-		ll = (ll << 16) | xi[M];
-		}
-	while ((k -= 16) > 0);
-	*i = ll;
-	}
-else
-	{
-/* shift not more than 16 bits */
-	eshift( xi, k );
-	*i = (long )xi[M] & 0xffff;
-	}
-
-if( xi[0] )  /* A negative value yields unsigned integer 0. */
-	*i = 0L;
-
-xi[0] = 0;
-xi[E] = EXONE - 1;
-xi[M] = 0;
-if( (k = enormlz( xi )) > NBITS )
-	ecleaz( xi );
-else
-	xi[E] -= (unsigned short )k;
-
-emovo( xi, frac );
-}
-
-
-
-/*
-;	Shift significand
-;
-;	Shifts significand area up or down by the number of bits
-;	given by the variable sc.
-*/
-int eshift( x, sc )
-unsigned short *x;
-int sc;
-{
-unsigned short lost;
-unsigned short *p;
-
-if( sc == 0 )
-	return( 0 );
-
-lost = 0;
-p = x + NI-1;
-
-if( sc < 0 )
-	{
-	sc = -sc;
-	while( sc >= 16 )
-		{
-		lost |= *p;	/* remember lost bits */
-		eshdn6(x);
-		sc -= 16;
-		}
-
-	while( sc >= 8 )
-		{
-		lost |= *p & 0xff;
-		eshdn8(x);
-		sc -= 8;
-		}
-
-	while( sc > 0 )
-		{
-		lost |= *p & 1;
-		eshdn1(x);
-		sc -= 1;
-		}
-	}
-else
-	{
-	while( sc >= 16 )
-		{
-		eshup6(x);
-		sc -= 16;
-		}
-
-	while( sc >= 8 )
-		{
-		eshup8(x);
-		sc -= 8;
-		}
-
-	while( sc > 0 )
-		{
-		eshup1(x);
-		sc -= 1;
-		}
-	}
-if( lost )
-	lost = 1;
-return( (int )lost );
-}
-
-
-
-/*
-;	normalize
-;
-; Shift normalizes the significand area pointed to by argument
-; shift count (up = positive) is returned.
-*/
-int enormlz(x)
-unsigned short x[];
-{
-register unsigned short *p;
-int sc;
-
-sc = 0;
-p = &x[M];
-if( *p != 0 )
-	goto normdn;
-++p;
-if( *p & 0x8000 )
-	return( 0 );	/* already normalized */
-while( *p == 0 )
-	{
-	eshup6(x);
-	sc += 16;
-/* With guard word, there are NBITS+16 bits available.
- * return true if all are zero.
- */
-	if( sc > NBITS )
-		return( sc );
-	}
-/* see if high byte is zero */
-while( (*p & 0xff00) == 0 )
-	{
-	eshup8(x);
-	sc += 8;
-	}
-/* now shift 1 bit at a time */
-while( (*p  & 0x8000) == 0)
-	{
-	eshup1(x);
-	sc += 1;
-	if( sc > (NBITS+16) )
-		{
-		mtherr( "enormlz", UNDERFLOW );
-		return( sc );
-		}
-	}
-return( sc );
-
-/* Normalize by shifting down out of the high guard word
-   of the significand */
-normdn:
-
-if( *p & 0xff00 )
-	{
-	eshdn8(x);
-	sc -= 8;
-	}
-while( *p != 0 )
-	{
-	eshdn1(x);
-	sc -= 1;
-
-	if( sc < -NBITS )
-		{
-		mtherr( "enormlz", OVERFLOW );
-		return( sc );
-		}
-	}
-return( sc );
-}
-
-
-
-
-/* Convert e type number to decimal format ASCII string.
- * The constants are for 64 bit precision.
- */
-
-#define NTEN 12
-#define MAXP 4096
-
-#if NE == 10
-static unsigned short etens[NTEN + 1][NE] =
-{
-  {0x6576, 0x4a92, 0x804a, 0x153f,
-   0xc94c, 0x979a, 0x8a20, 0x5202, 0xc460, 0x7525,},	/* 10**4096 */
-  {0x6a32, 0xce52, 0x329a, 0x28ce,
-   0xa74d, 0x5de4, 0xc53d, 0x3b5d, 0x9e8b, 0x5a92,},	/* 10**2048 */
-  {0x526c, 0x50ce, 0xf18b, 0x3d28,
-   0x650d, 0x0c17, 0x8175, 0x7586, 0xc976, 0x4d48,},
-  {0x9c66, 0x58f8, 0xbc50, 0x5c54,
-   0xcc65, 0x91c6, 0xa60e, 0xa0ae, 0xe319, 0x46a3,},
-  {0x851e, 0xeab7, 0x98fe, 0x901b,
-   0xddbb, 0xde8d, 0x9df9, 0xebfb, 0xaa7e, 0x4351,},
-  {0x0235, 0x0137, 0x36b1, 0x336c,
-   0xc66f, 0x8cdf, 0x80e9, 0x47c9, 0x93ba, 0x41a8,},
-  {0x50f8, 0x25fb, 0xc76b, 0x6b71,
-   0x3cbf, 0xa6d5, 0xffcf, 0x1f49, 0xc278, 0x40d3,},
-  {0x0000, 0x0000, 0x0000, 0x0000,
-   0xf020, 0xb59d, 0x2b70, 0xada8, 0x9dc5, 0x4069,},
-  {0x0000, 0x0000, 0x0000, 0x0000,
-   0x0000, 0x0000, 0x0400, 0xc9bf, 0x8e1b, 0x4034,},
-  {0x0000, 0x0000, 0x0000, 0x0000,
-   0x0000, 0x0000, 0x0000, 0x2000, 0xbebc, 0x4019,},
-  {0x0000, 0x0000, 0x0000, 0x0000,
-   0x0000, 0x0000, 0x0000, 0x0000, 0x9c40, 0x400c,},
-  {0x0000, 0x0000, 0x0000, 0x0000,
-   0x0000, 0x0000, 0x0000, 0x0000, 0xc800, 0x4005,},
-  {0x0000, 0x0000, 0x0000, 0x0000,
-   0x0000, 0x0000, 0x0000, 0x0000, 0xa000, 0x4002,},	/* 10**1 */
-};
-
-static unsigned short emtens[NTEN + 1][NE] =
-{
-  {0x2030, 0xcffc, 0xa1c3, 0x8123,
-   0x2de3, 0x9fde, 0xd2ce, 0x04c8, 0xa6dd, 0x0ad8,},	/* 10**-4096 */
-  {0x8264, 0xd2cb, 0xf2ea, 0x12d4,
-   0x4925, 0x2de4, 0x3436, 0x534f, 0xceae, 0x256b,},	/* 10**-2048 */
-  {0xf53f, 0xf698, 0x6bd3, 0x0158,
-   0x87a6, 0xc0bd, 0xda57, 0x82a5, 0xa2a6, 0x32b5,},
-  {0xe731, 0x04d4, 0xe3f2, 0xd332,
-   0x7132, 0xd21c, 0xdb23, 0xee32, 0x9049, 0x395a,},
-  {0xa23e, 0x5308, 0xfefb, 0x1155,
-   0xfa91, 0x1939, 0x637a, 0x4325, 0xc031, 0x3cac,},
-  {0xe26d, 0xdbde, 0xd05d, 0xb3f6,
-   0xac7c, 0xe4a0, 0x64bc, 0x467c, 0xddd0, 0x3e55,},
-  {0x2a20, 0x6224, 0x47b3, 0x98d7,
-   0x3f23, 0xe9a5, 0xa539, 0xea27, 0xa87f, 0x3f2a,},
-  {0x0b5b, 0x4af2, 0xa581, 0x18ed,
-   0x67de, 0x94ba, 0x4539, 0x1ead, 0xcfb1, 0x3f94,},
-  {0xbf71, 0xa9b3, 0x7989, 0xbe68,
-   0x4c2e, 0xe15b, 0xc44d, 0x94be, 0xe695, 0x3fc9,},
-  {0x3d4d, 0x7c3d, 0x36ba, 0x0d2b,
-   0xfdc2, 0xcefc, 0x8461, 0x7711, 0xabcc, 0x3fe4,},
-  {0xc155, 0xa4a8, 0x404e, 0x6113,
-   0xd3c3, 0x652b, 0xe219, 0x1758, 0xd1b7, 0x3ff1,},
-  {0xd70a, 0x70a3, 0x0a3d, 0xa3d7,
-   0x3d70, 0xd70a, 0x70a3, 0x0a3d, 0xa3d7, 0x3ff8,},
-  {0xcccd, 0xcccc, 0xcccc, 0xcccc,
-   0xcccc, 0xcccc, 0xcccc, 0xcccc, 0xcccc, 0x3ffb,},	/* 10**-1 */
-};
-#else
-static unsigned short etens[NTEN+1][NE] = {
-{0xc94c,0x979a,0x8a20,0x5202,0xc460,0x7525,},/* 10**4096 */
-{0xa74d,0x5de4,0xc53d,0x3b5d,0x9e8b,0x5a92,},/* 10**2048 */
-{0x650d,0x0c17,0x8175,0x7586,0xc976,0x4d48,},
-{0xcc65,0x91c6,0xa60e,0xa0ae,0xe319,0x46a3,},
-{0xddbc,0xde8d,0x9df9,0xebfb,0xaa7e,0x4351,},
-{0xc66f,0x8cdf,0x80e9,0x47c9,0x93ba,0x41a8,},
-{0x3cbf,0xa6d5,0xffcf,0x1f49,0xc278,0x40d3,},
-{0xf020,0xb59d,0x2b70,0xada8,0x9dc5,0x4069,},
-{0x0000,0x0000,0x0400,0xc9bf,0x8e1b,0x4034,},
-{0x0000,0x0000,0x0000,0x2000,0xbebc,0x4019,},
-{0x0000,0x0000,0x0000,0x0000,0x9c40,0x400c,},
-{0x0000,0x0000,0x0000,0x0000,0xc800,0x4005,},
-{0x0000,0x0000,0x0000,0x0000,0xa000,0x4002,}, /* 10**1 */
-};
-
-static unsigned short emtens[NTEN+1][NE] = {
-{0x2de4,0x9fde,0xd2ce,0x04c8,0xa6dd,0x0ad8,}, /* 10**-4096 */
-{0x4925,0x2de4,0x3436,0x534f,0xceae,0x256b,}, /* 10**-2048 */
-{0x87a6,0xc0bd,0xda57,0x82a5,0xa2a6,0x32b5,},
-{0x7133,0xd21c,0xdb23,0xee32,0x9049,0x395a,},
-{0xfa91,0x1939,0x637a,0x4325,0xc031,0x3cac,},
-{0xac7d,0xe4a0,0x64bc,0x467c,0xddd0,0x3e55,},
-{0x3f24,0xe9a5,0xa539,0xea27,0xa87f,0x3f2a,},
-{0x67de,0x94ba,0x4539,0x1ead,0xcfb1,0x3f94,},
-{0x4c2f,0xe15b,0xc44d,0x94be,0xe695,0x3fc9,},
-{0xfdc2,0xcefc,0x8461,0x7711,0xabcc,0x3fe4,},
-{0xd3c3,0x652b,0xe219,0x1758,0xd1b7,0x3ff1,},
-{0x3d71,0xd70a,0x70a3,0x0a3d,0xa3d7,0x3ff8,},
-{0xcccd,0xcccc,0xcccc,0xcccc,0xcccc,0x3ffb,}, /* 10**-1 */
-};
-#endif
-
-void e24toasc( x, string, ndigs )
-unsigned short x[];
-char *string;
-int ndigs;
-{
-unsigned short w[NI];
-
-e24toe( x, w );
-etoasc( w, string, ndigs );
-}
-
-
-void e53toasc( x, string, ndigs )
-unsigned short x[];
-char *string;
-int ndigs;
-{
-unsigned short w[NI];
-
-e53toe( x, w );
-etoasc( w, string, ndigs );
-}
-
-
-void e64toasc( x, string, ndigs )
-unsigned short x[];
-char *string;
-int ndigs;
-{
-unsigned short w[NI];
-
-e64toe( x, w );
-etoasc( w, string, ndigs );
-}
-
-void e113toasc (x, string, ndigs)
-unsigned short x[];
-char *string;
-int ndigs;
-{
-unsigned short w[NI];
-
-e113toe (x, w);
-etoasc (w, string, ndigs);
-}
-
-
-void etoasc( x, string, ndigs )
-unsigned short x[];
-char *string;
-int ndigs;
-{
-long digit;
-unsigned short y[NI], t[NI], u[NI], w[NI];
-unsigned short *p, *r, *ten;
-unsigned short sign;
-int i, j, k, expon, rndsav;
-char *s, *ss;
-unsigned short m;
-
-rndsav = rndprc;
-#ifdef NANS
-if( eisnan(x) )
-	{
-	sprintf( string, " NaN " );
-	goto bxit;
-	}
-#endif
-rndprc = NBITS;		/* set to full precision */
-emov( x, y ); /* retain external format */
-if( y[NE-1] & 0x8000 )
-	{
-	sign = 0xffff;
-	y[NE-1] &= 0x7fff;
-	}
-else
-	{
-	sign = 0;
-	}
-expon = 0;
-ten = &etens[NTEN][0];
-emov( eone, t );
-/* Test for zero exponent */
-if( y[NE-1] == 0 )
-	{
-	for( k=0; k<NE-1; k++ )
-		{
-		if( y[k] != 0 )
-			goto tnzro; /* denormalized number */
-		}
-	goto isone; /* legal all zeros */
-	}
-tnzro:
-
-/* Test for infinity.
- */
-if( y[NE-1] == 0x7fff )
-	{
-	if( sign )
-		sprintf( string, " -Infinity " );
-	else
-		sprintf( string, " Infinity " );
-	goto bxit;
-	}
-
-/* Test for exponent nonzero but significand denormalized.
- * This is an error condition.
- */
-if( (y[NE-1] != 0) && ((y[NE-2] & 0x8000) == 0) )
-	{
-	mtherr( "etoasc", DOMAIN );
-	sprintf( string, "NaN" );
-	goto bxit;
-	}
-
-/* Compare to 1.0 */
-i = ecmp( eone, y );
-if( i == 0 )
-	goto isone;
-
-if( i < 0 )
-	{ /* Number is greater than 1 */
-/* Convert significand to an integer and strip trailing decimal zeros. */
-	emov( y, u );
-	u[NE-1] = EXONE + NBITS - 1;
-
-	p = &etens[NTEN-4][0];
-	m = 16;
-do
-	{
-	ediv( p, u, t );
-	efloor( t, w );
-	for( j=0; j<NE-1; j++ )
-		{
-		if( t[j] != w[j] )
-			goto noint;
-		}
-	emov( t, u );
-	expon += (int )m;
-noint:
-	p += NE;
-	m >>= 1;
-	}
-while( m != 0 );
-
-/* Rescale from integer significand */
-	u[NE-1] += y[NE-1] - (unsigned int )(EXONE + NBITS - 1);
-	emov( u, y );
-/* Find power of 10 */
-	emov( eone, t );
-	m = MAXP;
-	p = &etens[0][0];
-	while( ecmp( ten, u ) <= 0 )
-		{
-		if( ecmp( p, u ) <= 0 )
-			{
-			ediv( p, u, u );
-			emul( p, t, t );
-			expon += (int )m;
-			}
-		m >>= 1;
-		if( m == 0 )
-			break;
-		p += NE;
-		}
-	}
-else
-	{ /* Number is less than 1.0 */
-/* Pad significand with trailing decimal zeros. */
-	if( y[NE-1] == 0 )
-		{
-		while( (y[NE-2] & 0x8000) == 0 )
-			{
-			emul( ten, y, y );
-			expon -= 1;
-			}
-		}
-	else
-		{
-		emovi( y, w );
-		for( i=0; i<NDEC+1; i++ )
-			{
-			if( (w[NI-1] & 0x7) != 0 )
-				break;
-/* multiply by 10 */
-			emovz( w, u );
-			eshdn1( u );
-			eshdn1( u );
-			eaddm( w, u );
-			u[1] += 3;
-			while( u[2] != 0 )
-				{
-				eshdn1(u);
-				u[1] += 1;
-				}
-			if( u[NI-1] != 0 )
-				break;
-			if( eone[NE-1] <= u[1] )
-				break;
-			emovz( u, w );
-			expon -= 1;
-			}
-		emovo( w, y );
-		}
-	k = -MAXP;
-	p = &emtens[0][0];
-	r = &etens[0][0];
-	emov( y, w );
-	emov( eone, t );
-	while( ecmp( eone, w ) > 0 )
-		{
-		if( ecmp( p, w ) >= 0 )
-			{
-			emul( r, w, w );
-			emul( r, t, t );
-			expon += k;
-			}
-		k /= 2;
-		if( k == 0 )
-			break;
-		p += NE;
-		r += NE;
-		}
-	ediv( t, eone, t );
-	}
-isone:
-/* Find the first (leading) digit. */
-emovi( t, w );
-emovz( w, t );
-emovi( y, w );
-emovz( w, y );
-eiremain( t, y );
-digit = equot[NI-1];
-while( (digit == 0) && (ecmp(y,ezero) != 0) )
-	{
-	eshup1( y );
-	emovz( y, u );
-	eshup1( u );
-	eshup1( u );
-	eaddm( u, y );
-	eiremain( t, y );
-	digit = equot[NI-1];
-	expon -= 1;
-	}
-s = string;
-if( sign )
-	*s++ = '-';
-else
-	*s++ = ' ';
-/* Examine number of digits requested by caller. */
-if( ndigs < 0 )
-	ndigs = 0;
-if( ndigs > NDEC )
-	ndigs = NDEC;
-if( digit == 10 )
-	{
-	*s++ = '1';
-	*s++ = '.';
-	if( ndigs > 0 )
-		{
-		*s++ = '0';
-		ndigs -= 1;
-		}
-	expon += 1;
-	}
-else
-	{
-	*s++ = (char )digit + '0';
-	*s++ = '.';
-	}
-/* Generate digits after the decimal point. */
-for( k=0; k<=ndigs; k++ )
-	{
-/* multiply current number by 10, without normalizing */
-	eshup1( y );
-	emovz( y, u );
-	eshup1( u );
-	eshup1( u );
-	eaddm( u, y );
-	eiremain( t, y );
-	*s++ = (char )equot[NI-1] + '0';
-	}
-digit = equot[NI-1];
---s;
-ss = s;
-/* round off the ASCII string */
-if( digit > 4 )
-	{
-/* Test for critical rounding case in ASCII output. */
-	if( digit == 5 )
-		{
-		emovo( y, t );
-		if( ecmp(t,ezero) != 0 )
-			goto roun;	/* round to nearest */
-		if( (*(s-1) & 1) == 0 )
-			goto doexp;	/* round to even */
-		}
-/* Round up and propagate carry-outs */
-roun:
-	--s;
-	k = *s & 0x7f;
-/* Carry out to most significant digit? */
-	if( k == '.' )
-		{
-		--s;
-		k = *s;
-		k += 1;
-		*s = (char )k;
-/* Most significant digit carries to 10? */
-		if( k > '9' )
-			{
-			expon += 1;
-			*s = '1';
-			}
-		goto doexp;
-		}
-/* Round up and carry out from less significant digits */
-	k += 1;
-	*s = (char )k;
-	if( k > '9' )
-		{
-		*s = '0';
-		goto roun;
-		}
-	}
-doexp:
-/*
-if( expon >= 0 )
-	sprintf( ss, "e+%d", expon );
-else
-	sprintf( ss, "e%d", expon );
-*/
-	sprintf( ss, "E%d", expon );
-bxit:
-rndprc = rndsav;
-}
-
-
-
-
-/*
-;								ASCTOQ
-;		ASCTOQ.MAC		LATEST REV: 11 JAN 84
-;					SLM, 3 JAN 78
-;
-;	Convert ASCII string to quadruple precision floating point
-;
-;		Numeric input is free field decimal number
-;		with max of 15 digits with or without 
-;		decimal point entered as ASCII from teletype.
-;	Entering E after the number followed by a second
-;	number causes the second number to be interpreted
-;	as a power of 10 to be multiplied by the first number
-;	(i.e., "scientific" notation).
-;
-;	Usage:
-;		asctoq( string, q );
-*/
-
-/* ASCII to single */
-void asctoe24( s, y )
-char *s;
-unsigned short *y;
-{
-asctoeg( s, y, 24 );
-}
-
-
-/* ASCII to double */
-void asctoe53( s, y )
-char *s;
-unsigned short *y;
-{
-#ifdef DEC
-asctoeg( s, y, 56 );
-#else
-asctoeg( s, y, 53 );
-#endif
-}
-
-
-/* ASCII to long double */
-void asctoe64( s, y )
-char *s;
-unsigned short *y;
-{
-asctoeg( s, y, 64 );
-}
-
-/* ASCII to 128-bit long double */
-void asctoe113 (s, y)
-char *s;
-unsigned short *y;
-{
-asctoeg( s, y, 113 );
-}
-
-/* ASCII to super double */
-void asctoe( s, y )
-char *s;
-unsigned short *y;
-{
-asctoeg( s, y, NBITS );
-}
-
-/* Space to make a copy of the input string: */
-static char lstr[82] = {0};
-
-void asctoeg( ss, y, oprec )
-char *ss;
-unsigned short *y;
-int oprec;
-{
-unsigned short yy[NI], xt[NI], tt[NI];
-int esign, decflg, sgnflg, nexp, exp, prec, lost;
-int k, trail, c, rndsav;
-long lexp;
-unsigned short nsign, *p;
-char *sp, *s;
-
-/* Copy the input string. */
-s = ss;
-while( *s == ' ' ) /* skip leading spaces */
-	++s;
-sp = lstr;
-for( k=0; k<79; k++ )
-	{
-	if( (*sp++ = *s++) == '\0' )
-		break;
-	}
-*sp = '\0';
-s = lstr;
-
-rndsav = rndprc;
-rndprc = NBITS; /* Set to full precision */
-lost = 0;
-nsign = 0;
-decflg = 0;
-sgnflg = 0;
-nexp = 0;
-exp = 0;
-prec = 0;
-ecleaz( yy );
-trail = 0;
-
-nxtcom:
-k = *s - '0';
-if( (k >= 0) && (k <= 9) )
-	{
-/* Ignore leading zeros */
-	if( (prec == 0) && (decflg == 0) && (k == 0) )
-		goto donchr;
-/* Identify and strip trailing zeros after the decimal point. */
-	if( (trail == 0) && (decflg != 0) )
-		{
-		sp = s;
-		while( (*sp >= '0') && (*sp <= '9') )
-			++sp;
-/* Check for syntax error */
-		c = *sp & 0x7f;
-		if( (c != 'e') && (c != 'E') && (c != '\0')
-			&& (c != '\n') && (c != '\r') && (c != ' ')
-			&& (c != ',') )
-			goto error;
-		--sp;
-		while( *sp == '0' )
-			*sp-- = 'z';
-		trail = 1;
-		if( *s == 'z' )
-			goto donchr;
-		}
-/* If enough digits were given to more than fill up the yy register,
- * continuing until overflow into the high guard word yy[2]
- * guarantees that there will be a roundoff bit at the top
- * of the low guard word after normalization.
- */
-	if( yy[2] == 0 )
-		{
-		if( decflg )
-			nexp += 1; /* count digits after decimal point */
-		eshup1( yy );	/* multiply current number by 10 */
-		emovz( yy, xt );
-		eshup1( xt );
-		eshup1( xt );
-		eaddm( xt, yy );
-		ecleaz( xt );
-		xt[NI-2] = (unsigned short )k;
-		eaddm( xt, yy );
-		}
-	else
-		{
-		/* Mark any lost non-zero digit.  */
-		lost |= k;
-		/* Count lost digits before the decimal point.  */
-		if (decflg == 0)
-		        nexp -= 1;
-		}
-	prec += 1;
-	goto donchr;
-	}
-
-switch( *s )
-	{
-	case 'z':
-		break;
-	case 'E':
-	case 'e':
-		goto expnt;
-	case '.':	/* decimal point */
-		if( decflg )
-			goto error;
-		++decflg;
-		break;
-	case '-':
-		nsign = 0xffff;
-		if( sgnflg )
-			goto error;
-		++sgnflg;
-		break;
-	case '+':
-		if( sgnflg )
-			goto error;
-		++sgnflg;
-		break;
-	case ',':
-	case ' ':
-	case '\0':
-	case '\n':
-	case '\r':
-		goto daldone;
-	case 'i':
-	case 'I':
-		goto infinite;
-	default:
-	error:
-#ifdef NANS
-		enan( yy, NI*16 );
-#else
-		mtherr( "asctoe", DOMAIN );
-		ecleaz(yy);
-#endif
-		goto aexit;
-	}
-donchr:
-++s;
-goto nxtcom;
-
-/* Exponent interpretation */
-expnt:
-
-esign = 1;
-exp = 0;
-++s;
-/* check for + or - */
-if( *s == '-' )
-	{
-	esign = -1;
-	++s;
-	}
-if( *s == '+' )
-	++s;
-while( (*s >= '0') && (*s <= '9') )
-	{
-	exp *= 10;
-	exp += *s++ - '0';
-	if (exp > 4977)
-		{
-		if (esign < 0)
-			goto zero;
-		else
-			goto infinite;
-		}
-	}
-if( esign < 0 )
-	exp = -exp;
-if( exp > 4932 )
-	{
-infinite:
-	ecleaz(yy);
-	yy[E] = 0x7fff;  /* infinity */
-	goto aexit;
-	}
-if( exp < -4977 )
-	{
-zero:
-	ecleaz(yy);
-	goto aexit;
-	}
-
-daldone:
-nexp = exp - nexp;
-/* Pad trailing zeros to minimize power of 10, per IEEE spec. */
-while( (nexp > 0) && (yy[2] == 0) )
-	{
-	emovz( yy, xt );
-	eshup1( xt );
-	eshup1( xt );
-	eaddm( yy, xt );
-	eshup1( xt );
-	if( xt[2] != 0 )
-		break;
-	nexp -= 1;
-	emovz( xt, yy );
-	}
-if( (k = enormlz(yy)) > NBITS )
-	{
-	ecleaz(yy);
-	goto aexit;
-	}
-lexp = (EXONE - 1 + NBITS) - k;
-emdnorm( yy, lost, 0, lexp, 64 );
-/* convert to external format */
-
-
-/* Multiply by 10**nexp.  If precision is 64 bits,
- * the maximum relative error incurred in forming 10**n
- * for 0 <= n <= 324 is 8.2e-20, at 10**180.
- * For 0 <= n <= 999, the peak relative error is 1.4e-19 at 10**947.
- * For 0 >= n >= -999, it is -1.55e-19 at 10**-435.
- */
-lexp = yy[E];
-if( nexp == 0 )
-	{
-	k = 0;
-	goto expdon;
-	}
-esign = 1;
-if( nexp < 0 )
-	{
-	nexp = -nexp;
-	esign = -1;
-	if( nexp > 4096 )
-		{ /* Punt.  Can't handle this without 2 divides. */
-		emovi( etens[0], tt );
-		lexp -= tt[E];
-		k = edivm( tt, yy );
-		lexp += EXONE;
-		nexp -= 4096;
-		}
-	}
-p = &etens[NTEN][0];
-emov( eone, xt );
-exp = 1;
-do
-	{
-	if( exp & nexp )
-		emul( p, xt, xt );
-	p -= NE;
-	exp = exp + exp;
-	}
-while( exp <= MAXP );
-
-emovi( xt, tt );
-if( esign < 0 )
-	{
-	lexp -= tt[E];
-	k = edivm( tt, yy );
-	lexp += EXONE;
-	}
-else
-	{
-	lexp += tt[E];
-	k = emulm( tt, yy );
-	lexp -= EXONE - 1;
-	}
-
-expdon:
-
-/* Round and convert directly to the destination type */
-if( oprec == 53 )
-	lexp -= EXONE - 0x3ff;
-else if( oprec == 24 )
-	lexp -= EXONE - 0177;
-#ifdef DEC
-else if( oprec == 56 )
-	lexp -= EXONE - 0201;
-#endif
-rndprc = oprec;
-emdnorm( yy, k, 0, lexp, 64 );
-
-aexit:
-
-rndprc = rndsav;
-yy[0] = nsign;
-switch( oprec )
-	{
-#ifdef DEC
-	case 56:
-		todec( yy, y ); /* see etodec.c */
-		break;
-#endif
-	case 53:
-		toe53( yy, y );
-		break;
-	case 24:
-		toe24( yy, y );
-		break;
-	case 64:
-		toe64( yy, y );
-		break;
-	case 113:
-		toe113( yy, y );
-		break;
-	case NBITS:
-		emovo( yy, y );
-		break;
-	}
-}
-
-
- 
-/* y = largest integer not greater than x
- * (truncated toward minus infinity)
- *
- * unsigned short x[NE], y[NE]
- *
- * efloor( x, y );
- */
-static unsigned short bmask[] = {
-0xffff,
-0xfffe,
-0xfffc,
-0xfff8,
-0xfff0,
-0xffe0,
-0xffc0,
-0xff80,
-0xff00,
-0xfe00,
-0xfc00,
-0xf800,
-0xf000,
-0xe000,
-0xc000,
-0x8000,
-0x0000,
-};
-
-void efloor( x, y )
-unsigned short x[], y[];
-{
-register unsigned short *p;
-int e, expon, i;
-unsigned short f[NE];
-
-emov( x, f ); /* leave in external format */
-expon = (int )f[NE-1];
-e = (expon & 0x7fff) - (EXONE - 1);
-if( e <= 0 )
-	{
-	eclear(y);
-	goto isitneg;
-	}
-/* number of bits to clear out */
-e = NBITS - e;
-emov( f, y );
-if( e <= 0 )
-	return;
-
-p = &y[0];
-while( e >= 16 )
-	{
-	*p++ = 0;
-	e -= 16;
-	}
-/* clear the remaining bits */
-*p &= bmask[e];
-/* truncate negatives toward minus infinity */
-isitneg:
-
-if( (unsigned short )expon & (unsigned short )0x8000 )
-	{
-	for( i=0; i<NE-1; i++ )
-		{
-		if( f[i] != y[i] )
-			{
-			esub( eone, y, y );
-			break;
-			}
-		}
-	}
-}
-
-
-/* unsigned short x[], s[];
- * long *exp;
- *
- * efrexp( x, exp, s );
- *
- * Returns s and exp such that  s * 2**exp = x and .5 <= s < 1.
- * For example, 1.1 = 0.55 * 2**1
- * Handles denormalized numbers properly using long integer exp.
- */
-void efrexp( x, exp, s )
-unsigned short x[];
-long *exp;
-unsigned short s[];
-{
-unsigned short xi[NI];
-long li;
-
-emovi( x, xi );
-li = (long )((short )xi[1]);
-
-if( li == 0 )
-	{
-	li -= enormlz( xi );
-	}
-xi[1] = 0x3ffe;
-emovo( xi, s );
-*exp = li - 0x3ffe;
-}
-
-
-
-/* unsigned short x[], y[];
- * long pwr2;
- *
- * eldexp( x, pwr2, y );
- *
- * Returns y = x * 2**pwr2.
- */
-void eldexp( x, pwr2, y )
-unsigned short x[];
-long pwr2;
-unsigned short y[];
-{
-unsigned short xi[NI];
-long li;
-int i;
-
-emovi( x, xi );
-li = xi[1];
-li += pwr2;
-i = 0;
-emdnorm( xi, i, i, li, 64 );
-emovo( xi, y );
-}
-
-
-/* c = remainder after dividing b by a
- * Least significant integer quotient bits left in equot[].
- */
-void eremain( a, b, c )
-unsigned short a[], b[], c[];
-{
-unsigned short den[NI], num[NI];
-
-#ifdef NANS
-if( eisinf(b) || (ecmp(a,ezero) == 0) || eisnan(a) || eisnan(b))
-	{
-	enan( c, NBITS );
-	return;
-	}
-#endif
-if( ecmp(a,ezero) == 0 )
-	{
-	mtherr( "eremain", SING );
-	eclear( c );
-	return;
-	}
-emovi( a, den );
-emovi( b, num );
-eiremain( den, num );
-/* Sign of remainder = sign of quotient */
-if( a[0] == b[0] )
-	num[0] = 0;
-else
-	num[0] = 0xffff;
-emovo( num, c );
-}
-
-
-void eiremain( den, num )
-unsigned short den[], num[];
-{
-long ld, ln;
-unsigned short j;
-
-ld = den[E];
-ld -= enormlz( den );
-ln = num[E];
-ln -= enormlz( num );
-ecleaz( equot );
-while( ln >= ld )
-	{
-	if( ecmpm(den,num) <= 0 )
-		{
-		esubm(den, num);
-		j = 1;
-		}
-	else
-		{
-		j = 0;
-		}
-	eshup1(equot);
-	equot[NI-1] |= j;
-	eshup1(num);
-	ln -= 1;
-	}
-emdnorm( num, 0, 0, ln, 0 );
-}
-
-/* NaN bit patterns
- */
-#ifdef MIEEE
-unsigned short nan113[8] = {
-  0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff};
-unsigned short nan64[6] = {0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff};
-unsigned short nan53[4] = {0x7fff, 0xffff, 0xffff, 0xffff};
-unsigned short nan24[2] = {0x7fff, 0xffff};
-#endif
-
-#ifdef IBMPC
-unsigned short nan113[8] = {0, 0, 0, 0, 0, 0, 0xc000, 0xffff};
-unsigned short nan64[6] = {0, 0, 0, 0xc000, 0xffff, 0};
-unsigned short nan53[4] = {0, 0, 0, 0xfff8};
-unsigned short nan24[2] = {0, 0xffc0};
-#endif
-
-
-void enan (nan, size)
-unsigned short *nan;
-int size;
-{
-int i, n;
-unsigned short *p;
-
-switch( size )
-	{
-#ifndef DEC
-	case 113:
-	n = 8;
-	p = nan113;
-	break;
-
-	case 64:
-	n = 6;
-	p = nan64;
-	break;
-
-	case 53:
-	n = 4;
-	p = nan53;
-	break;
-
-	case 24:
-	n = 2;
-	p = nan24;
-	break;
-
-	case NBITS:
-	for( i=0; i<NE-2; i++ )
-		*nan++ = 0;
-	*nan++ = 0xc000;
-	*nan++ = 0x7fff;
-	return;
-
-	case NI*16:
-	*nan++ = 0;
-	*nan++ = 0x7fff;
-	*nan++ = 0;
-	*nan++ = 0xc000;
-	for( i=4; i<NI; i++ )
-		*nan++ = 0;
-	return;
-#endif
-	default:
-	mtherr( "enan", DOMAIN );
-	return;
-	}
-for (i=0; i < n; i++)
-	*nan++ = *p++;
-}
-
-
-
-/* Longhand square root. */
-
-static int esqinited = 0;
-static unsigned short sqrndbit[NI];
-
-void esqrt( x, y )
-short *x, *y;
-{
-unsigned short temp[NI], num[NI], sq[NI], xx[NI];
-int i, j, k, n, nlups;
-long m, exp;
-
-if( esqinited == 0 )
-	{
-	ecleaz( sqrndbit );
-	sqrndbit[NI-2] = 1;
-	esqinited = 1;
-	}
-/* Check for arg <= 0 */
-i = ecmp( x, ezero );
-if( i <= 0 )
-	{
-#ifdef NANS
-	if (i == -2)
-		{
-		enan (y, NBITS);
-		return;
-		}
-#endif
-	eclear(y);
-	if( i < 0 )
-		mtherr( "esqrt", DOMAIN );
-	return;
-	}
-
-#ifdef INFINITY
-if( eisinf(x) )
-	{
-	eclear(y);
-	einfin(y);
-	return;
-	}
-#endif
-/* Bring in the arg and renormalize if it is denormal. */
-emovi( x, xx );
-m = (long )xx[1]; /* local long word exponent */
-if( m == 0 )
-	m -= enormlz( xx );
-
-/* Divide exponent by 2 */
-m -= 0x3ffe;
-exp = (unsigned short )( (m / 2) + 0x3ffe );
-
-/* Adjust if exponent odd */
-if( (m & 1) != 0 )
-	{
-	if( m > 0 )
-		exp += 1;
-	eshdn1( xx );
-	}
-
-ecleaz( sq );
-ecleaz( num );
-n = 8; /* get 8 bits of result per inner loop */
-nlups = rndprc;
-j = 0;
-
-while( nlups > 0 )
-	{
-/* bring in next word of arg */
-	if( j < NE )
-		num[NI-1] = xx[j+3];
-/* Do additional bit on last outer loop, for roundoff. */
-	if( nlups <= 8 )
-		n = nlups + 1;
-	for( i=0; i<n; i++ )
-		{
-/* Next 2 bits of arg */
-		eshup1( num );
-		eshup1( num );
-/* Shift up answer */
-		eshup1( sq );
-/* Make trial divisor */
-		for( k=0; k<NI; k++ )
-			temp[k] = sq[k];
-		eshup1( temp );
-		eaddm( sqrndbit, temp );
-/* Subtract and insert answer bit if it goes in */
-		if( ecmpm( temp, num ) <= 0 )
-			{
-			esubm( temp, num );
-			sq[NI-2] |= 1;
-			}
-		}
-	nlups -= n;
-	j += 1;
-	}
-
-/* Adjust for extra, roundoff loop done. */
-exp += (NBITS - 1) - rndprc;
-
-/* Sticky bit = 1 if the remainder is nonzero. */
-k = 0;
-for( i=3; i<NI; i++ )
-	k |= (int )num[i];
-
-/* Renormalize and round off. */
-emdnorm( sq, k, 0, exp, 64 );
-emovo( sq, y );
-}