Moved, renamed, and deleted files

The original directory structure was scattered and unorganized.
Changes are basically to make it look like kernel structure.

1 files changed, 0 insertions, 10980 deletions

diff --git a/ANDROID_3.4.5/arch/m68k/ifpsp060/src/fplsp.S b/ANDROID_3.4.5/arch/m68k/ifpsp060/src/fplsp.S
deleted file mode 100644
index 3b7ea2dc..00000000
--- a/ANDROID_3.4.5/arch/m68k/ifpsp060/src/fplsp.S
+++ /dev/null
@@ -1,10980 +0,0 @@
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUP
-M68000 Hi-Performance Microprocessor Division
-M68060 Software Package
-Production Release P1.00 -- October 10, 1994
-
-M68060 Software Package Copyright © 1993, 1994 Motorola Inc.  All rights reserved.
-
-THE SOFTWARE is provided on an "AS IS" basis and without warranty.
-To the maximum extent permitted by applicable law,
-MOTOROLA DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED,
-INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
-and any warranty against infringement with regard to the SOFTWARE
-(INCLUDING ANY MODIFIED VERSIONS THEREOF) and any accompanying written materials.
-
-To the maximum extent permitted by applicable law,
-IN NO EVENT SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER
-(INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
-BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS)
-ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
-Motorola assumes no responsibility for the maintenance and support of the SOFTWARE.
-
-You are hereby granted a copyright license to use, modify, and distribute the SOFTWARE
-so long as this entire notice is retained without alteration in any modified and/or
-redistributed versions, and that such modified versions are clearly identified as such.
-No licenses are granted by implication, estoppel or otherwise under any patents
-or trademarks of Motorola, Inc.
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-#
-# lfptop.s:
-#	This file is appended to the top of the 060ILSP package
-# and contains the entry points into the package. The user, in
-# effect, branches to one of the branch table entries located here.
-#
-
-	bra.l	_facoss_
-	short	0x0000
-	bra.l	_facosd_
-	short	0x0000
-	bra.l	_facosx_
-	short	0x0000
-
-	bra.l	_fasins_
-	short	0x0000
-	bra.l	_fasind_
-	short	0x0000
-	bra.l	_fasinx_
-	short	0x0000
-
-	bra.l	_fatans_
-	short	0x0000
-	bra.l	_fatand_
-	short	0x0000
-	bra.l	_fatanx_
-	short	0x0000
-
-	bra.l	_fatanhs_
-	short	0x0000
-	bra.l	_fatanhd_
-	short	0x0000
-	bra.l	_fatanhx_
-	short	0x0000
-
-	bra.l	_fcoss_
-	short	0x0000
-	bra.l	_fcosd_
-	short	0x0000
-	bra.l	_fcosx_
-	short	0x0000
-
-	bra.l	_fcoshs_
-	short	0x0000
-	bra.l	_fcoshd_
-	short	0x0000
-	bra.l	_fcoshx_
-	short	0x0000
-
-	bra.l	_fetoxs_
-	short	0x0000
-	bra.l	_fetoxd_
-	short	0x0000
-	bra.l	_fetoxx_
-	short	0x0000
-
-	bra.l	_fetoxm1s_
-	short	0x0000
-	bra.l	_fetoxm1d_
-	short	0x0000
-	bra.l	_fetoxm1x_
-	short	0x0000
-
-	bra.l	_fgetexps_
-	short	0x0000
-	bra.l	_fgetexpd_
-	short	0x0000
-	bra.l	_fgetexpx_
-	short	0x0000
-
-	bra.l	_fgetmans_
-	short	0x0000
-	bra.l	_fgetmand_
-	short	0x0000
-	bra.l	_fgetmanx_
-	short	0x0000
-
-	bra.l	_flog10s_
-	short	0x0000
-	bra.l	_flog10d_
-	short	0x0000
-	bra.l	_flog10x_
-	short	0x0000
-
-	bra.l	_flog2s_
-	short	0x0000
-	bra.l	_flog2d_
-	short	0x0000
-	bra.l	_flog2x_
-	short	0x0000
-
-	bra.l	_flogns_
-	short	0x0000
-	bra.l	_flognd_
-	short	0x0000
-	bra.l	_flognx_
-	short	0x0000
-
-	bra.l	_flognp1s_
-	short	0x0000
-	bra.l	_flognp1d_
-	short	0x0000
-	bra.l	_flognp1x_
-	short	0x0000
-
-	bra.l	_fmods_
-	short	0x0000
-	bra.l	_fmodd_
-	short	0x0000
-	bra.l	_fmodx_
-	short	0x0000
-
-	bra.l	_frems_
-	short	0x0000
-	bra.l	_fremd_
-	short	0x0000
-	bra.l	_fremx_
-	short	0x0000
-
-	bra.l	_fscales_
-	short	0x0000
-	bra.l	_fscaled_
-	short	0x0000
-	bra.l	_fscalex_
-	short	0x0000
-
-	bra.l	_fsins_
-	short	0x0000
-	bra.l	_fsind_
-	short	0x0000
-	bra.l	_fsinx_
-	short	0x0000
-
-	bra.l	_fsincoss_
-	short	0x0000
-	bra.l	_fsincosd_
-	short	0x0000
-	bra.l	_fsincosx_
-	short	0x0000
-
-	bra.l	_fsinhs_
-	short	0x0000
-	bra.l	_fsinhd_
-	short	0x0000
-	bra.l	_fsinhx_
-	short	0x0000
-
-	bra.l	_ftans_
-	short	0x0000
-	bra.l	_ftand_
-	short	0x0000
-	bra.l	_ftanx_
-	short	0x0000
-
-	bra.l	_ftanhs_
-	short	0x0000
-	bra.l	_ftanhd_
-	short	0x0000
-	bra.l	_ftanhx_
-	short	0x0000
-
-	bra.l	_ftentoxs_
-	short	0x0000
-	bra.l	_ftentoxd_
-	short	0x0000
-	bra.l	_ftentoxx_
-	short	0x0000
-
-	bra.l	_ftwotoxs_
-	short	0x0000
-	bra.l	_ftwotoxd_
-	short	0x0000
-	bra.l	_ftwotoxx_
-	short	0x0000
-
-	bra.l	_fabss_
-	short	0x0000
-	bra.l	_fabsd_
-	short	0x0000
-	bra.l	_fabsx_
-	short	0x0000
-
-	bra.l	_fadds_
-	short	0x0000
-	bra.l	_faddd_
-	short	0x0000
-	bra.l	_faddx_
-	short	0x0000
-
-	bra.l	_fdivs_
-	short	0x0000
-	bra.l	_fdivd_
-	short	0x0000
-	bra.l	_fdivx_
-	short	0x0000
-
-	bra.l	_fints_
-	short	0x0000
-	bra.l	_fintd_
-	short	0x0000
-	bra.l	_fintx_
-	short	0x0000
-
-	bra.l	_fintrzs_
-	short	0x0000
-	bra.l	_fintrzd_
-	short	0x0000
-	bra.l	_fintrzx_
-	short	0x0000
-
-	bra.l	_fmuls_
-	short	0x0000
-	bra.l	_fmuld_
-	short	0x0000
-	bra.l	_fmulx_
-	short	0x0000
-
-	bra.l	_fnegs_
-	short	0x0000
-	bra.l	_fnegd_
-	short	0x0000
-	bra.l	_fnegx_
-	short	0x0000
-
-	bra.l	_fsqrts_
-	short	0x0000
-	bra.l	_fsqrtd_
-	short	0x0000
-	bra.l	_fsqrtx_
-	short	0x0000
-
-	bra.l	_fsubs_
-	short	0x0000
-	bra.l	_fsubd_
-	short	0x0000
-	bra.l	_fsubx_
-	short	0x0000
-
-# leave room for future possible additions
-	align	0x400
-
-#
-# This file contains a set of define statements for constants
-# in order to promote readability within the corecode itself.
-#
-
-set LOCAL_SIZE,		192			# stack frame size(bytes)
-set LV,			-LOCAL_SIZE		# stack offset
-
-set EXC_SR,		0x4			# stack status register
-set EXC_PC,		0x6			# stack pc
-set EXC_VOFF,		0xa			# stacked vector offset
-set EXC_EA,		0xc			# stacked <ea>
-
-set EXC_FP,		0x0			# frame pointer
-
-set EXC_AREGS,		-68			# offset of all address regs
-set EXC_DREGS,		-100			# offset of all data regs
-set EXC_FPREGS,		-36			# offset of all fp regs
-
-set EXC_A7,		EXC_AREGS+(7*4)		# offset of saved a7
-set OLD_A7,		EXC_AREGS+(6*4)		# extra copy of saved a7
-set EXC_A6,		EXC_AREGS+(6*4)		# offset of saved a6
-set EXC_A5,		EXC_AREGS+(5*4)
-set EXC_A4,		EXC_AREGS+(4*4)
-set EXC_A3,		EXC_AREGS+(3*4)
-set EXC_A2,		EXC_AREGS+(2*4)
-set EXC_A1,		EXC_AREGS+(1*4)
-set EXC_A0,		EXC_AREGS+(0*4)
-set EXC_D7,		EXC_DREGS+(7*4)
-set EXC_D6,		EXC_DREGS+(6*4)
-set EXC_D5,		EXC_DREGS+(5*4)
-set EXC_D4,		EXC_DREGS+(4*4)
-set EXC_D3,		EXC_DREGS+(3*4)
-set EXC_D2,		EXC_DREGS+(2*4)
-set EXC_D1,		EXC_DREGS+(1*4)
-set EXC_D0,		EXC_DREGS+(0*4)
-
-set EXC_FP0,		EXC_FPREGS+(0*12)	# offset of saved fp0
-set EXC_FP1,		EXC_FPREGS+(1*12)	# offset of saved fp1
-set EXC_FP2,		EXC_FPREGS+(2*12)	# offset of saved fp2 (not used)
-
-set FP_SCR1,		LV+80			# fp scratch 1
-set FP_SCR1_EX,		FP_SCR1+0
-set FP_SCR1_SGN,	FP_SCR1+2
-set FP_SCR1_HI,		FP_SCR1+4
-set FP_SCR1_LO,		FP_SCR1+8
-
-set FP_SCR0,		LV+68			# fp scratch 0
-set FP_SCR0_EX,		FP_SCR0+0
-set FP_SCR0_SGN,	FP_SCR0+2
-set FP_SCR0_HI,		FP_SCR0+4
-set FP_SCR0_LO,		FP_SCR0+8
-
-set FP_DST,		LV+56			# fp destination operand
-set FP_DST_EX,		FP_DST+0
-set FP_DST_SGN,		FP_DST+2
-set FP_DST_HI,		FP_DST+4
-set FP_DST_LO,		FP_DST+8
-
-set FP_SRC,		LV+44			# fp source operand
-set FP_SRC_EX,		FP_SRC+0
-set FP_SRC_SGN,		FP_SRC+2
-set FP_SRC_HI,		FP_SRC+4
-set FP_SRC_LO,		FP_SRC+8
-
-set USER_FPIAR,		LV+40			# FP instr address register
-
-set USER_FPSR,		LV+36			# FP status register
-set FPSR_CC,		USER_FPSR+0		# FPSR condition codes
-set FPSR_QBYTE,		USER_FPSR+1		# FPSR qoutient byte
-set FPSR_EXCEPT,	USER_FPSR+2		# FPSR exception status byte
-set FPSR_AEXCEPT,	USER_FPSR+3		# FPSR accrued exception byte
-
-set USER_FPCR,		LV+32			# FP control register
-set FPCR_ENABLE,	USER_FPCR+2		# FPCR exception enable
-set FPCR_MODE,		USER_FPCR+3		# FPCR rounding mode control
-
-set L_SCR3,		LV+28			# integer scratch 3
-set L_SCR2,		LV+24			# integer scratch 2
-set L_SCR1,		LV+20			# integer scratch 1
-
-set STORE_FLG,		LV+19			# flag: operand store (ie. not fcmp/ftst)
-
-set EXC_TEMP2,		LV+24			# temporary space
-set EXC_TEMP,		LV+16			# temporary space
-
-set DTAG,		LV+15			# destination operand type
-set STAG,		LV+14			# source operand type
-
-set SPCOND_FLG,		LV+10			# flag: special case (see below)
-
-set EXC_CC,		LV+8			# saved condition codes
-set EXC_EXTWPTR,	LV+4			# saved current PC (active)
-set EXC_EXTWORD,	LV+2			# saved extension word
-set EXC_CMDREG,		LV+2			# saved extension word
-set EXC_OPWORD,		LV+0			# saved operation word
-
-################################
-
-# Helpful macros
-
-set FTEMP,		0			# offsets within an
-set FTEMP_EX,		0			# extended precision
-set FTEMP_SGN,		2			# value saved in memory.
-set FTEMP_HI,		4
-set FTEMP_LO,		8
-set FTEMP_GRS,		12
-
-set LOCAL,		0			# offsets within an
-set LOCAL_EX,		0			# extended precision
-set LOCAL_SGN,		2			# value saved in memory.
-set LOCAL_HI,		4
-set LOCAL_LO,		8
-set LOCAL_GRS,		12
-
-set DST,		0			# offsets within an
-set DST_EX,		0			# extended precision
-set DST_HI,		4			# value saved in memory.
-set DST_LO,		8
-
-set SRC,		0			# offsets within an
-set SRC_EX,		0			# extended precision
-set SRC_HI,		4			# value saved in memory.
-set SRC_LO,		8
-
-set SGL_LO,		0x3f81			# min sgl prec exponent
-set SGL_HI,		0x407e			# max sgl prec exponent
-set DBL_LO,		0x3c01			# min dbl prec exponent
-set DBL_HI,		0x43fe			# max dbl prec exponent
-set EXT_LO,		0x0			# min ext prec exponent
-set EXT_HI,		0x7ffe			# max ext prec exponent
-
-set EXT_BIAS,		0x3fff			# extended precision bias
-set SGL_BIAS,		0x007f			# single precision bias
-set DBL_BIAS,		0x03ff			# double precision bias
-
-set NORM,		0x00			# operand type for STAG/DTAG
-set ZERO,		0x01			# operand type for STAG/DTAG
-set INF,		0x02			# operand type for STAG/DTAG
-set QNAN,		0x03			# operand type for STAG/DTAG
-set DENORM,		0x04			# operand type for STAG/DTAG
-set SNAN,		0x05			# operand type for STAG/DTAG
-set UNNORM,		0x06			# operand type for STAG/DTAG
-
-##################
-# FPSR/FPCR bits #
-##################
-set neg_bit,		0x3			# negative result
-set z_bit,		0x2			# zero result
-set inf_bit,		0x1			# infinite result
-set nan_bit,		0x0			# NAN result
-
-set q_sn_bit,		0x7			# sign bit of quotient byte
-
-set bsun_bit,		7			# branch on unordered
-set snan_bit,		6			# signalling NAN
-set operr_bit,		5			# operand error
-set ovfl_bit,		4			# overflow
-set unfl_bit,		3			# underflow
-set dz_bit,		2			# divide by zero
-set inex2_bit,		1			# inexact result 2
-set inex1_bit,		0			# inexact result 1
-
-set aiop_bit,		7			# accrued inexact operation bit
-set aovfl_bit,		6			# accrued overflow bit
-set aunfl_bit,		5			# accrued underflow bit
-set adz_bit,		4			# accrued dz bit
-set ainex_bit,		3			# accrued inexact bit
-
-#############################
-# FPSR individual bit masks #
-#############################
-set neg_mask,		0x08000000		# negative bit mask (lw)
-set inf_mask,		0x02000000		# infinity bit mask (lw)
-set z_mask,		0x04000000		# zero bit mask (lw)
-set nan_mask,		0x01000000		# nan bit mask (lw)
-
-set neg_bmask,		0x08			# negative bit mask (byte)
-set inf_bmask,		0x02			# infinity bit mask (byte)
-set z_bmask,		0x04			# zero bit mask (byte)
-set nan_bmask,		0x01			# nan bit mask (byte)
-
-set bsun_mask,		0x00008000		# bsun exception mask
-set snan_mask,		0x00004000		# snan exception mask
-set operr_mask,		0x00002000		# operr exception mask
-set ovfl_mask,		0x00001000		# overflow exception mask
-set unfl_mask,		0x00000800		# underflow exception mask
-set dz_mask,		0x00000400		# dz exception mask
-set inex2_mask,		0x00000200		# inex2 exception mask
-set inex1_mask,		0x00000100		# inex1 exception mask
-
-set aiop_mask,		0x00000080		# accrued illegal operation
-set aovfl_mask,		0x00000040		# accrued overflow
-set aunfl_mask,		0x00000020		# accrued underflow
-set adz_mask,		0x00000010		# accrued divide by zero
-set ainex_mask,		0x00000008		# accrued inexact
-
-######################################
-# FPSR combinations used in the FPSP #
-######################################
-set dzinf_mask,		inf_mask+dz_mask+adz_mask
-set opnan_mask,		nan_mask+operr_mask+aiop_mask
-set nzi_mask,		0x01ffffff		#clears N, Z, and I
-set unfinx_mask,	unfl_mask+inex2_mask+aunfl_mask+ainex_mask
-set unf2inx_mask,	unfl_mask+inex2_mask+ainex_mask
-set ovfinx_mask,	ovfl_mask+inex2_mask+aovfl_mask+ainex_mask
-set inx1a_mask,		inex1_mask+ainex_mask
-set inx2a_mask,		inex2_mask+ainex_mask
-set snaniop_mask,	nan_mask+snan_mask+aiop_mask
-set snaniop2_mask,	snan_mask+aiop_mask
-set naniop_mask,	nan_mask+aiop_mask
-set neginf_mask,	neg_mask+inf_mask
-set infaiop_mask,	inf_mask+aiop_mask
-set negz_mask,		neg_mask+z_mask
-set opaop_mask,		operr_mask+aiop_mask
-set unfl_inx_mask,	unfl_mask+aunfl_mask+ainex_mask
-set ovfl_inx_mask,	ovfl_mask+aovfl_mask+ainex_mask
-
-#########
-# misc. #
-#########
-set rnd_stky_bit,	29			# stky bit pos in longword
-
-set sign_bit,		0x7			# sign bit
-set signan_bit,		0x6			# signalling nan bit
-
-set sgl_thresh,		0x3f81			# minimum sgl exponent
-set dbl_thresh,		0x3c01			# minimum dbl exponent
-
-set x_mode,		0x0			# extended precision
-set s_mode,		0x4			# single precision
-set d_mode,		0x8			# double precision
-
-set rn_mode,		0x0			# round-to-nearest
-set rz_mode,		0x1			# round-to-zero
-set rm_mode,		0x2			# round-tp-minus-infinity
-set rp_mode,		0x3			# round-to-plus-infinity
-
-set mantissalen,	64			# length of mantissa in bits
-
-set BYTE,		1			# len(byte) == 1 byte
-set WORD,		2			# len(word) == 2 bytes
-set LONG,		4			# len(longword) == 2 bytes
-
-set BSUN_VEC,		0xc0			# bsun    vector offset
-set INEX_VEC,		0xc4			# inexact vector offset
-set DZ_VEC,		0xc8			# dz      vector offset
-set UNFL_VEC,		0xcc			# unfl    vector offset
-set OPERR_VEC,		0xd0			# operr   vector offset
-set OVFL_VEC,		0xd4			# ovfl    vector offset
-set SNAN_VEC,		0xd8			# snan    vector offset
-
-###########################
-# SPecial CONDition FLaGs #
-###########################
-set ftrapcc_flg,	0x01			# flag bit: ftrapcc exception
-set fbsun_flg,		0x02			# flag bit: bsun exception
-set mia7_flg,		0x04			# flag bit: (a7)+ <ea>
-set mda7_flg,		0x08			# flag bit: -(a7) <ea>
-set fmovm_flg,		0x40			# flag bit: fmovm instruction
-set immed_flg,		0x80			# flag bit: &<data> <ea>
-
-set ftrapcc_bit,	0x0
-set fbsun_bit,		0x1
-set mia7_bit,		0x2
-set mda7_bit,		0x3
-set immed_bit,		0x7
-
-##################################
-# TRANSCENDENTAL "LAST-OP" FLAGS #
-##################################
-set FMUL_OP,		0x0			# fmul instr performed last
-set FDIV_OP,		0x1			# fdiv performed last
-set FADD_OP,		0x2			# fadd performed last
-set FMOV_OP,		0x3			# fmov performed last
-
-#############
-# CONSTANTS #
-#############
-T1:	long		0x40C62D38,0xD3D64634	# 16381 LOG2 LEAD
-T2:	long		0x3D6F90AE,0xB1E75CC7	# 16381 LOG2 TRAIL
-
-PI:	long		0x40000000,0xC90FDAA2,0x2168C235,0x00000000
-PIBY2:	long		0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000
-
-TWOBYPI:
-	long		0x3FE45F30,0x6DC9C883
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_fsins_
-_fsins_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L0_2s
-	bsr.l		ssin			# operand is a NORM
-	bra.b		_L0_6s
-_L0_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L0_3s			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L0_6s
-_L0_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L0_4s			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L0_6s
-_L0_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L0_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L0_6s
-_L0_5s:
-	bsr.l		ssind			# operand is a DENORM
-_L0_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fsind_
-_fsind_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L0_2d
-	bsr.l		ssin			# operand is a NORM
-	bra.b		_L0_6d
-_L0_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L0_3d			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L0_6d
-_L0_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L0_4d			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L0_6d
-_L0_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L0_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L0_6d
-_L0_5d:
-	bsr.l		ssind			# operand is a DENORM
-_L0_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fsinx_
-_fsinx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L0_2x
-	bsr.l		ssin			# operand is a NORM
-	bra.b		_L0_6x
-_L0_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L0_3x			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L0_6x
-_L0_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L0_4x			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L0_6x
-_L0_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L0_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L0_6x
-_L0_5x:
-	bsr.l		ssind			# operand is a DENORM
-_L0_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_fcoss_
-_fcoss_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L1_2s
-	bsr.l		scos			# operand is a NORM
-	bra.b		_L1_6s
-_L1_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L1_3s			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L1_6s
-_L1_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L1_4s			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L1_6s
-_L1_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L1_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L1_6s
-_L1_5s:
-	bsr.l		scosd			# operand is a DENORM
-_L1_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fcosd_
-_fcosd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L1_2d
-	bsr.l		scos			# operand is a NORM
-	bra.b		_L1_6d
-_L1_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L1_3d			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L1_6d
-_L1_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L1_4d			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L1_6d
-_L1_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L1_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L1_6d
-_L1_5d:
-	bsr.l		scosd			# operand is a DENORM
-_L1_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fcosx_
-_fcosx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L1_2x
-	bsr.l		scos			# operand is a NORM
-	bra.b		_L1_6x
-_L1_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L1_3x			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L1_6x
-_L1_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L1_4x			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L1_6x
-_L1_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L1_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L1_6x
-_L1_5x:
-	bsr.l		scosd			# operand is a DENORM
-_L1_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_fsinhs_
-_fsinhs_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L2_2s
-	bsr.l		ssinh			# operand is a NORM
-	bra.b		_L2_6s
-_L2_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L2_3s			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L2_6s
-_L2_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L2_4s			# no
-	bsr.l		src_inf			# yes
-	bra.b		_L2_6s
-_L2_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L2_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L2_6s
-_L2_5s:
-	bsr.l		ssinhd			# operand is a DENORM
-_L2_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fsinhd_
-_fsinhd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L2_2d
-	bsr.l		ssinh			# operand is a NORM
-	bra.b		_L2_6d
-_L2_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L2_3d			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L2_6d
-_L2_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L2_4d			# no
-	bsr.l		src_inf			# yes
-	bra.b		_L2_6d
-_L2_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L2_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L2_6d
-_L2_5d:
-	bsr.l		ssinhd			# operand is a DENORM
-_L2_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fsinhx_
-_fsinhx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L2_2x
-	bsr.l		ssinh			# operand is a NORM
-	bra.b		_L2_6x
-_L2_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L2_3x			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L2_6x
-_L2_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L2_4x			# no
-	bsr.l		src_inf			# yes
-	bra.b		_L2_6x
-_L2_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L2_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L2_6x
-_L2_5x:
-	bsr.l		ssinhd			# operand is a DENORM
-_L2_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_flognp1s_
-_flognp1s_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L3_2s
-	bsr.l		slognp1			# operand is a NORM
-	bra.b		_L3_6s
-_L3_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L3_3s			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L3_6s
-_L3_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L3_4s			# no
-	bsr.l		sopr_inf			# yes
-	bra.b		_L3_6s
-_L3_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L3_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L3_6s
-_L3_5s:
-	bsr.l		slognp1d			# operand is a DENORM
-_L3_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_flognp1d_
-_flognp1d_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L3_2d
-	bsr.l		slognp1			# operand is a NORM
-	bra.b		_L3_6d
-_L3_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L3_3d			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L3_6d
-_L3_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L3_4d			# no
-	bsr.l		sopr_inf			# yes
-	bra.b		_L3_6d
-_L3_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L3_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L3_6d
-_L3_5d:
-	bsr.l		slognp1d			# operand is a DENORM
-_L3_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_flognp1x_
-_flognp1x_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L3_2x
-	bsr.l		slognp1			# operand is a NORM
-	bra.b		_L3_6x
-_L3_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L3_3x			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L3_6x
-_L3_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L3_4x			# no
-	bsr.l		sopr_inf			# yes
-	bra.b		_L3_6x
-_L3_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L3_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L3_6x
-_L3_5x:
-	bsr.l		slognp1d			# operand is a DENORM
-_L3_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_fetoxm1s_
-_fetoxm1s_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L4_2s
-	bsr.l		setoxm1			# operand is a NORM
-	bra.b		_L4_6s
-_L4_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L4_3s			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L4_6s
-_L4_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L4_4s			# no
-	bsr.l		setoxm1i			# yes
-	bra.b		_L4_6s
-_L4_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L4_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L4_6s
-_L4_5s:
-	bsr.l		setoxm1d			# operand is a DENORM
-_L4_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fetoxm1d_
-_fetoxm1d_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L4_2d
-	bsr.l		setoxm1			# operand is a NORM
-	bra.b		_L4_6d
-_L4_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L4_3d			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L4_6d
-_L4_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L4_4d			# no
-	bsr.l		setoxm1i			# yes
-	bra.b		_L4_6d
-_L4_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L4_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L4_6d
-_L4_5d:
-	bsr.l		setoxm1d			# operand is a DENORM
-_L4_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fetoxm1x_
-_fetoxm1x_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L4_2x
-	bsr.l		setoxm1			# operand is a NORM
-	bra.b		_L4_6x
-_L4_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L4_3x			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L4_6x
-_L4_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L4_4x			# no
-	bsr.l		setoxm1i			# yes
-	bra.b		_L4_6x
-_L4_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L4_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L4_6x
-_L4_5x:
-	bsr.l		setoxm1d			# operand is a DENORM
-_L4_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_ftanhs_
-_ftanhs_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L5_2s
-	bsr.l		stanh			# operand is a NORM
-	bra.b		_L5_6s
-_L5_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L5_3s			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L5_6s
-_L5_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L5_4s			# no
-	bsr.l		src_one			# yes
-	bra.b		_L5_6s
-_L5_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L5_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L5_6s
-_L5_5s:
-	bsr.l		stanhd			# operand is a DENORM
-_L5_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_ftanhd_
-_ftanhd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L5_2d
-	bsr.l		stanh			# operand is a NORM
-	bra.b		_L5_6d
-_L5_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L5_3d			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L5_6d
-_L5_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L5_4d			# no
-	bsr.l		src_one			# yes
-	bra.b		_L5_6d
-_L5_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L5_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L5_6d
-_L5_5d:
-	bsr.l		stanhd			# operand is a DENORM
-_L5_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_ftanhx_
-_ftanhx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L5_2x
-	bsr.l		stanh			# operand is a NORM
-	bra.b		_L5_6x
-_L5_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L5_3x			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L5_6x
-_L5_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L5_4x			# no
-	bsr.l		src_one			# yes
-	bra.b		_L5_6x
-_L5_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L5_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L5_6x
-_L5_5x:
-	bsr.l		stanhd			# operand is a DENORM
-_L5_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_fatans_
-_fatans_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L6_2s
-	bsr.l		satan			# operand is a NORM
-	bra.b		_L6_6s
-_L6_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L6_3s			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L6_6s
-_L6_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L6_4s			# no
-	bsr.l		spi_2			# yes
-	bra.b		_L6_6s
-_L6_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L6_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L6_6s
-_L6_5s:
-	bsr.l		satand			# operand is a DENORM
-_L6_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fatand_
-_fatand_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L6_2d
-	bsr.l		satan			# operand is a NORM
-	bra.b		_L6_6d
-_L6_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L6_3d			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L6_6d
-_L6_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L6_4d			# no
-	bsr.l		spi_2			# yes
-	bra.b		_L6_6d
-_L6_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L6_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L6_6d
-_L6_5d:
-	bsr.l		satand			# operand is a DENORM
-_L6_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fatanx_
-_fatanx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L6_2x
-	bsr.l		satan			# operand is a NORM
-	bra.b		_L6_6x
-_L6_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L6_3x			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L6_6x
-_L6_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L6_4x			# no
-	bsr.l		spi_2			# yes
-	bra.b		_L6_6x
-_L6_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L6_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L6_6x
-_L6_5x:
-	bsr.l		satand			# operand is a DENORM
-_L6_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_fasins_
-_fasins_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L7_2s
-	bsr.l		sasin			# operand is a NORM
-	bra.b		_L7_6s
-_L7_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L7_3s			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L7_6s
-_L7_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L7_4s			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L7_6s
-_L7_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L7_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L7_6s
-_L7_5s:
-	bsr.l		sasind			# operand is a DENORM
-_L7_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fasind_
-_fasind_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L7_2d
-	bsr.l		sasin			# operand is a NORM
-	bra.b		_L7_6d
-_L7_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L7_3d			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L7_6d
-_L7_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L7_4d			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L7_6d
-_L7_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L7_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L7_6d
-_L7_5d:
-	bsr.l		sasind			# operand is a DENORM
-_L7_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fasinx_
-_fasinx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L7_2x
-	bsr.l		sasin			# operand is a NORM
-	bra.b		_L7_6x
-_L7_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L7_3x			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L7_6x
-_L7_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L7_4x			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L7_6x
-_L7_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L7_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L7_6x
-_L7_5x:
-	bsr.l		sasind			# operand is a DENORM
-_L7_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_fatanhs_
-_fatanhs_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L8_2s
-	bsr.l		satanh			# operand is a NORM
-	bra.b		_L8_6s
-_L8_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L8_3s			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L8_6s
-_L8_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L8_4s			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L8_6s
-_L8_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L8_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L8_6s
-_L8_5s:
-	bsr.l		satanhd			# operand is a DENORM
-_L8_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fatanhd_
-_fatanhd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L8_2d
-	bsr.l		satanh			# operand is a NORM
-	bra.b		_L8_6d
-_L8_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L8_3d			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L8_6d
-_L8_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L8_4d			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L8_6d
-_L8_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L8_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L8_6d
-_L8_5d:
-	bsr.l		satanhd			# operand is a DENORM
-_L8_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fatanhx_
-_fatanhx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L8_2x
-	bsr.l		satanh			# operand is a NORM
-	bra.b		_L8_6x
-_L8_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L8_3x			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L8_6x
-_L8_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L8_4x			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L8_6x
-_L8_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L8_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L8_6x
-_L8_5x:
-	bsr.l		satanhd			# operand is a DENORM
-_L8_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_ftans_
-_ftans_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L9_2s
-	bsr.l		stan			# operand is a NORM
-	bra.b		_L9_6s
-_L9_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L9_3s			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L9_6s
-_L9_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L9_4s			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L9_6s
-_L9_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L9_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L9_6s
-_L9_5s:
-	bsr.l		stand			# operand is a DENORM
-_L9_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_ftand_
-_ftand_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L9_2d
-	bsr.l		stan			# operand is a NORM
-	bra.b		_L9_6d
-_L9_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L9_3d			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L9_6d
-_L9_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L9_4d			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L9_6d
-_L9_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L9_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L9_6d
-_L9_5d:
-	bsr.l		stand			# operand is a DENORM
-_L9_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_ftanx_
-_ftanx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L9_2x
-	bsr.l		stan			# operand is a NORM
-	bra.b		_L9_6x
-_L9_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L9_3x			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L9_6x
-_L9_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L9_4x			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L9_6x
-_L9_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L9_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L9_6x
-_L9_5x:
-	bsr.l		stand			# operand is a DENORM
-_L9_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_fetoxs_
-_fetoxs_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L10_2s
-	bsr.l		setox			# operand is a NORM
-	bra.b		_L10_6s
-_L10_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L10_3s			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L10_6s
-_L10_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L10_4s			# no
-	bsr.l		szr_inf			# yes
-	bra.b		_L10_6s
-_L10_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L10_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L10_6s
-_L10_5s:
-	bsr.l		setoxd			# operand is a DENORM
-_L10_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fetoxd_
-_fetoxd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L10_2d
-	bsr.l		setox			# operand is a NORM
-	bra.b		_L10_6d
-_L10_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L10_3d			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L10_6d
-_L10_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L10_4d			# no
-	bsr.l		szr_inf			# yes
-	bra.b		_L10_6d
-_L10_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L10_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L10_6d
-_L10_5d:
-	bsr.l		setoxd			# operand is a DENORM
-_L10_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fetoxx_
-_fetoxx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L10_2x
-	bsr.l		setox			# operand is a NORM
-	bra.b		_L10_6x
-_L10_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L10_3x			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L10_6x
-_L10_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L10_4x			# no
-	bsr.l		szr_inf			# yes
-	bra.b		_L10_6x
-_L10_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L10_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L10_6x
-_L10_5x:
-	bsr.l		setoxd			# operand is a DENORM
-_L10_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_ftwotoxs_
-_ftwotoxs_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L11_2s
-	bsr.l		stwotox			# operand is a NORM
-	bra.b		_L11_6s
-_L11_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L11_3s			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L11_6s
-_L11_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L11_4s			# no
-	bsr.l		szr_inf			# yes
-	bra.b		_L11_6s
-_L11_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L11_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L11_6s
-_L11_5s:
-	bsr.l		stwotoxd			# operand is a DENORM
-_L11_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_ftwotoxd_
-_ftwotoxd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L11_2d
-	bsr.l		stwotox			# operand is a NORM
-	bra.b		_L11_6d
-_L11_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L11_3d			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L11_6d
-_L11_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L11_4d			# no
-	bsr.l		szr_inf			# yes
-	bra.b		_L11_6d
-_L11_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L11_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L11_6d
-_L11_5d:
-	bsr.l		stwotoxd			# operand is a DENORM
-_L11_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_ftwotoxx_
-_ftwotoxx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L11_2x
-	bsr.l		stwotox			# operand is a NORM
-	bra.b		_L11_6x
-_L11_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L11_3x			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L11_6x
-_L11_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L11_4x			# no
-	bsr.l		szr_inf			# yes
-	bra.b		_L11_6x
-_L11_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L11_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L11_6x
-_L11_5x:
-	bsr.l		stwotoxd			# operand is a DENORM
-_L11_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_ftentoxs_
-_ftentoxs_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L12_2s
-	bsr.l		stentox			# operand is a NORM
-	bra.b		_L12_6s
-_L12_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L12_3s			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L12_6s
-_L12_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L12_4s			# no
-	bsr.l		szr_inf			# yes
-	bra.b		_L12_6s
-_L12_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L12_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L12_6s
-_L12_5s:
-	bsr.l		stentoxd			# operand is a DENORM
-_L12_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_ftentoxd_
-_ftentoxd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L12_2d
-	bsr.l		stentox			# operand is a NORM
-	bra.b		_L12_6d
-_L12_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L12_3d			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L12_6d
-_L12_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L12_4d			# no
-	bsr.l		szr_inf			# yes
-	bra.b		_L12_6d
-_L12_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L12_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L12_6d
-_L12_5d:
-	bsr.l		stentoxd			# operand is a DENORM
-_L12_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_ftentoxx_
-_ftentoxx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L12_2x
-	bsr.l		stentox			# operand is a NORM
-	bra.b		_L12_6x
-_L12_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L12_3x			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L12_6x
-_L12_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L12_4x			# no
-	bsr.l		szr_inf			# yes
-	bra.b		_L12_6x
-_L12_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L12_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L12_6x
-_L12_5x:
-	bsr.l		stentoxd			# operand is a DENORM
-_L12_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_flogns_
-_flogns_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L13_2s
-	bsr.l		slogn			# operand is a NORM
-	bra.b		_L13_6s
-_L13_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L13_3s			# no
-	bsr.l		t_dz2			# yes
-	bra.b		_L13_6s
-_L13_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L13_4s			# no
-	bsr.l		sopr_inf			# yes
-	bra.b		_L13_6s
-_L13_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L13_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L13_6s
-_L13_5s:
-	bsr.l		slognd			# operand is a DENORM
-_L13_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_flognd_
-_flognd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L13_2d
-	bsr.l		slogn			# operand is a NORM
-	bra.b		_L13_6d
-_L13_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L13_3d			# no
-	bsr.l		t_dz2			# yes
-	bra.b		_L13_6d
-_L13_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L13_4d			# no
-	bsr.l		sopr_inf			# yes
-	bra.b		_L13_6d
-_L13_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L13_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L13_6d
-_L13_5d:
-	bsr.l		slognd			# operand is a DENORM
-_L13_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_flognx_
-_flognx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L13_2x
-	bsr.l		slogn			# operand is a NORM
-	bra.b		_L13_6x
-_L13_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L13_3x			# no
-	bsr.l		t_dz2			# yes
-	bra.b		_L13_6x
-_L13_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L13_4x			# no
-	bsr.l		sopr_inf			# yes
-	bra.b		_L13_6x
-_L13_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L13_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L13_6x
-_L13_5x:
-	bsr.l		slognd			# operand is a DENORM
-_L13_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_flog10s_
-_flog10s_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L14_2s
-	bsr.l		slog10			# operand is a NORM
-	bra.b		_L14_6s
-_L14_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L14_3s			# no
-	bsr.l		t_dz2			# yes
-	bra.b		_L14_6s
-_L14_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L14_4s			# no
-	bsr.l		sopr_inf			# yes
-	bra.b		_L14_6s
-_L14_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L14_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L14_6s
-_L14_5s:
-	bsr.l		slog10d			# operand is a DENORM
-_L14_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_flog10d_
-_flog10d_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L14_2d
-	bsr.l		slog10			# operand is a NORM
-	bra.b		_L14_6d
-_L14_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L14_3d			# no
-	bsr.l		t_dz2			# yes
-	bra.b		_L14_6d
-_L14_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L14_4d			# no
-	bsr.l		sopr_inf			# yes
-	bra.b		_L14_6d
-_L14_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L14_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L14_6d
-_L14_5d:
-	bsr.l		slog10d			# operand is a DENORM
-_L14_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_flog10x_
-_flog10x_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L14_2x
-	bsr.l		slog10			# operand is a NORM
-	bra.b		_L14_6x
-_L14_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L14_3x			# no
-	bsr.l		t_dz2			# yes
-	bra.b		_L14_6x
-_L14_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L14_4x			# no
-	bsr.l		sopr_inf			# yes
-	bra.b		_L14_6x
-_L14_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L14_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L14_6x
-_L14_5x:
-	bsr.l		slog10d			# operand is a DENORM
-_L14_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_flog2s_
-_flog2s_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L15_2s
-	bsr.l		slog2			# operand is a NORM
-	bra.b		_L15_6s
-_L15_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L15_3s			# no
-	bsr.l		t_dz2			# yes
-	bra.b		_L15_6s
-_L15_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L15_4s			# no
-	bsr.l		sopr_inf			# yes
-	bra.b		_L15_6s
-_L15_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L15_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L15_6s
-_L15_5s:
-	bsr.l		slog2d			# operand is a DENORM
-_L15_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_flog2d_
-_flog2d_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L15_2d
-	bsr.l		slog2			# operand is a NORM
-	bra.b		_L15_6d
-_L15_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L15_3d			# no
-	bsr.l		t_dz2			# yes
-	bra.b		_L15_6d
-_L15_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L15_4d			# no
-	bsr.l		sopr_inf			# yes
-	bra.b		_L15_6d
-_L15_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L15_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L15_6d
-_L15_5d:
-	bsr.l		slog2d			# operand is a DENORM
-_L15_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_flog2x_
-_flog2x_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L15_2x
-	bsr.l		slog2			# operand is a NORM
-	bra.b		_L15_6x
-_L15_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L15_3x			# no
-	bsr.l		t_dz2			# yes
-	bra.b		_L15_6x
-_L15_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L15_4x			# no
-	bsr.l		sopr_inf			# yes
-	bra.b		_L15_6x
-_L15_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L15_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L15_6x
-_L15_5x:
-	bsr.l		slog2d			# operand is a DENORM
-_L15_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_fcoshs_
-_fcoshs_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L16_2s
-	bsr.l		scosh			# operand is a NORM
-	bra.b		_L16_6s
-_L16_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L16_3s			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L16_6s
-_L16_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L16_4s			# no
-	bsr.l		ld_pinf			# yes
-	bra.b		_L16_6s
-_L16_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L16_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L16_6s
-_L16_5s:
-	bsr.l		scoshd			# operand is a DENORM
-_L16_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fcoshd_
-_fcoshd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L16_2d
-	bsr.l		scosh			# operand is a NORM
-	bra.b		_L16_6d
-_L16_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L16_3d			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L16_6d
-_L16_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L16_4d			# no
-	bsr.l		ld_pinf			# yes
-	bra.b		_L16_6d
-_L16_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L16_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L16_6d
-_L16_5d:
-	bsr.l		scoshd			# operand is a DENORM
-_L16_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fcoshx_
-_fcoshx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L16_2x
-	bsr.l		scosh			# operand is a NORM
-	bra.b		_L16_6x
-_L16_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L16_3x			# no
-	bsr.l		ld_pone			# yes
-	bra.b		_L16_6x
-_L16_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L16_4x			# no
-	bsr.l		ld_pinf			# yes
-	bra.b		_L16_6x
-_L16_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L16_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L16_6x
-_L16_5x:
-	bsr.l		scoshd			# operand is a DENORM
-_L16_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_facoss_
-_facoss_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L17_2s
-	bsr.l		sacos			# operand is a NORM
-	bra.b		_L17_6s
-_L17_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L17_3s			# no
-	bsr.l		ld_ppi2			# yes
-	bra.b		_L17_6s
-_L17_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L17_4s			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L17_6s
-_L17_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L17_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L17_6s
-_L17_5s:
-	bsr.l		sacosd			# operand is a DENORM
-_L17_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_facosd_
-_facosd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L17_2d
-	bsr.l		sacos			# operand is a NORM
-	bra.b		_L17_6d
-_L17_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L17_3d			# no
-	bsr.l		ld_ppi2			# yes
-	bra.b		_L17_6d
-_L17_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L17_4d			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L17_6d
-_L17_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L17_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L17_6d
-_L17_5d:
-	bsr.l		sacosd			# operand is a DENORM
-_L17_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_facosx_
-_facosx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L17_2x
-	bsr.l		sacos			# operand is a NORM
-	bra.b		_L17_6x
-_L17_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L17_3x			# no
-	bsr.l		ld_ppi2			# yes
-	bra.b		_L17_6x
-_L17_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L17_4x			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L17_6x
-_L17_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L17_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L17_6x
-_L17_5x:
-	bsr.l		sacosd			# operand is a DENORM
-_L17_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_fgetexps_
-_fgetexps_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L18_2s
-	bsr.l		sgetexp			# operand is a NORM
-	bra.b		_L18_6s
-_L18_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L18_3s			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L18_6s
-_L18_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L18_4s			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L18_6s
-_L18_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L18_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L18_6s
-_L18_5s:
-	bsr.l		sgetexpd			# operand is a DENORM
-_L18_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fgetexpd_
-_fgetexpd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L18_2d
-	bsr.l		sgetexp			# operand is a NORM
-	bra.b		_L18_6d
-_L18_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L18_3d			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L18_6d
-_L18_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L18_4d			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L18_6d
-_L18_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L18_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L18_6d
-_L18_5d:
-	bsr.l		sgetexpd			# operand is a DENORM
-_L18_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fgetexpx_
-_fgetexpx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L18_2x
-	bsr.l		sgetexp			# operand is a NORM
-	bra.b		_L18_6x
-_L18_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L18_3x			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L18_6x
-_L18_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L18_4x			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L18_6x
-_L18_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L18_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L18_6x
-_L18_5x:
-	bsr.l		sgetexpd			# operand is a DENORM
-_L18_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_fgetmans_
-_fgetmans_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L19_2s
-	bsr.l		sgetman			# operand is a NORM
-	bra.b		_L19_6s
-_L19_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L19_3s			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L19_6s
-_L19_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L19_4s			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L19_6s
-_L19_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L19_5s			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L19_6s
-_L19_5s:
-	bsr.l		sgetmand			# operand is a DENORM
-_L19_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fgetmand_
-_fgetmand_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L19_2d
-	bsr.l		sgetman			# operand is a NORM
-	bra.b		_L19_6d
-_L19_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L19_3d			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L19_6d
-_L19_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L19_4d			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L19_6d
-_L19_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L19_5d			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L19_6d
-_L19_5d:
-	bsr.l		sgetmand			# operand is a DENORM
-_L19_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fgetmanx_
-_fgetmanx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L19_2x
-	bsr.l		sgetman			# operand is a NORM
-	bra.b		_L19_6x
-_L19_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L19_3x			# no
-	bsr.l		src_zero			# yes
-	bra.b		_L19_6x
-_L19_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L19_4x			# no
-	bsr.l		t_operr			# yes
-	bra.b		_L19_6x
-_L19_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L19_5x			# no
-	bsr.l		src_qnan			# yes
-	bra.b		_L19_6x
-_L19_5x:
-	bsr.l		sgetmand			# operand is a DENORM
-_L19_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# MONADIC TEMPLATE							#
-#########################################################################
-	global		_fsincoss_
-_fsincoss_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L20_2s
-	bsr.l		ssincos			# operand is a NORM
-	bra.b		_L20_6s
-_L20_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L20_3s			# no
-	bsr.l		ssincosz			# yes
-	bra.b		_L20_6s
-_L20_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L20_4s			# no
-	bsr.l		ssincosi			# yes
-	bra.b		_L20_6s
-_L20_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L20_5s			# no
-	bsr.l		ssincosqnan			# yes
-	bra.b		_L20_6s
-_L20_5s:
-	bsr.l		ssincosd			# operand is a DENORM
-_L20_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		&0x03,-(%sp)		# store off fp0/fp1
-	fmovm.x		(%sp)+,&0x40		# fp0 now in fp1
-	fmovm.x		(%sp)+,&0x80		# fp1 now in fp0
-	unlk		%a6
-	rts
-
-	global		_fsincosd_
-_fsincosd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl input
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	mov.b		%d1,STAG(%a6)
-	tst.b		%d1
-	bne.b		_L20_2d
-	bsr.l		ssincos			# operand is a NORM
-	bra.b		_L20_6d
-_L20_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L20_3d			# no
-	bsr.l		ssincosz			# yes
-	bra.b		_L20_6d
-_L20_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L20_4d			# no
-	bsr.l		ssincosi			# yes
-	bra.b		_L20_6d
-_L20_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L20_5d			# no
-	bsr.l		ssincosqnan			# yes
-	bra.b		_L20_6d
-_L20_5d:
-	bsr.l		ssincosd			# operand is a DENORM
-_L20_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		&0x03,-(%sp)		# store off fp0/fp1
-	fmovm.x		(%sp)+,&0x40		# fp0 now in fp1
-	fmovm.x		(%sp)+,&0x80		# fp1 now in fp0
-	unlk		%a6
-	rts
-
-	global		_fsincosx_
-_fsincosx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.b		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	tst.b		%d1
-	bne.b		_L20_2x
-	bsr.l		ssincos			# operand is a NORM
-	bra.b		_L20_6x
-_L20_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L20_3x			# no
-	bsr.l		ssincosz			# yes
-	bra.b		_L20_6x
-_L20_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L20_4x			# no
-	bsr.l		ssincosi			# yes
-	bra.b		_L20_6x
-_L20_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L20_5x			# no
-	bsr.l		ssincosqnan			# yes
-	bra.b		_L20_6x
-_L20_5x:
-	bsr.l		ssincosd			# operand is a DENORM
-_L20_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		&0x03,-(%sp)		# store off fp0/fp1
-	fmovm.x		(%sp)+,&0x40		# fp0 now in fp1
-	fmovm.x		(%sp)+,&0x80		# fp1 now in fp0
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# DYADIC TEMPLATE							#
-#########################################################################
-	global		_frems_
-_frems_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl dst
-	fmov.x		%fp0,FP_DST(%a6)
-	lea		FP_DST(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,DTAG(%a6)
-
-	fmov.s		0xc(%a6),%fp0		# load sgl src
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.l		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	lea		FP_SRC(%a6),%a0		# pass ptr to src
-	lea		FP_DST(%a6),%a1		# pass ptr to dst
-
-	tst.b		%d1
-	bne.b		_L21_2s
-	bsr.l		srem_snorm			# operand is a NORM
-	bra.b		_L21_6s
-_L21_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L21_3s			# no
-	bsr.l		srem_szero			# yes
-	bra.b		_L21_6s
-_L21_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L21_4s			# no
-	bsr.l		srem_sinf			# yes
-	bra.b		_L21_6s
-_L21_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L21_5s			# no
-	bsr.l		sop_sqnan			# yes
-	bra.b		_L21_6s
-_L21_5s:
-	bsr.l		srem_sdnrm			# operand is a DENORM
-_L21_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fremd_
-_fremd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl dst
-	fmov.x		%fp0,FP_DST(%a6)
-	lea		FP_DST(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,DTAG(%a6)
-
-	fmov.d		0x10(%a6),%fp0		# load dbl src
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.l		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	lea		FP_SRC(%a6),%a0		# pass ptr to src
-	lea		FP_DST(%a6),%a1		# pass ptr to dst
-
-	tst.b		%d1
-	bne.b		_L21_2d
-	bsr.l		srem_snorm			# operand is a NORM
-	bra.b		_L21_6d
-_L21_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L21_3d			# no
-	bsr.l		srem_szero			# yes
-	bra.b		_L21_6d
-_L21_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L21_4d			# no
-	bsr.l		srem_sinf			# yes
-	bra.b		_L21_6d
-_L21_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L21_5d			# no
-	bsr.l		sop_sqnan			# yes
-	bra.b		_L21_6d
-_L21_5d:
-	bsr.l		srem_sdnrm			# operand is a DENORM
-_L21_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fremx_
-_fremx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_DST(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext dst
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,DTAG(%a6)
-
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x14+0x0(%a6),0x0(%a0)	# load ext src
-	mov.l		0x14+0x4(%a6),0x4(%a0)
-	mov.l		0x14+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.l		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	lea		FP_SRC(%a6),%a0		# pass ptr to src
-	lea		FP_DST(%a6),%a1		# pass ptr to dst
-
-	tst.b		%d1
-	bne.b		_L21_2x
-	bsr.l		srem_snorm			# operand is a NORM
-	bra.b		_L21_6x
-_L21_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L21_3x			# no
-	bsr.l		srem_szero			# yes
-	bra.b		_L21_6x
-_L21_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L21_4x			# no
-	bsr.l		srem_sinf			# yes
-	bra.b		_L21_6x
-_L21_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L21_5x			# no
-	bsr.l		sop_sqnan			# yes
-	bra.b		_L21_6x
-_L21_5x:
-	bsr.l		srem_sdnrm			# operand is a DENORM
-_L21_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# DYADIC TEMPLATE							#
-#########################################################################
-	global		_fmods_
-_fmods_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl dst
-	fmov.x		%fp0,FP_DST(%a6)
-	lea		FP_DST(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,DTAG(%a6)
-
-	fmov.s		0xc(%a6),%fp0		# load sgl src
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.l		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	lea		FP_SRC(%a6),%a0		# pass ptr to src
-	lea		FP_DST(%a6),%a1		# pass ptr to dst
-
-	tst.b		%d1
-	bne.b		_L22_2s
-	bsr.l		smod_snorm			# operand is a NORM
-	bra.b		_L22_6s
-_L22_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L22_3s			# no
-	bsr.l		smod_szero			# yes
-	bra.b		_L22_6s
-_L22_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L22_4s			# no
-	bsr.l		smod_sinf			# yes
-	bra.b		_L22_6s
-_L22_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L22_5s			# no
-	bsr.l		sop_sqnan			# yes
-	bra.b		_L22_6s
-_L22_5s:
-	bsr.l		smod_sdnrm			# operand is a DENORM
-_L22_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fmodd_
-_fmodd_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl dst
-	fmov.x		%fp0,FP_DST(%a6)
-	lea		FP_DST(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,DTAG(%a6)
-
-	fmov.d		0x10(%a6),%fp0		# load dbl src
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.l		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	lea		FP_SRC(%a6),%a0		# pass ptr to src
-	lea		FP_DST(%a6),%a1		# pass ptr to dst
-
-	tst.b		%d1
-	bne.b		_L22_2d
-	bsr.l		smod_snorm			# operand is a NORM
-	bra.b		_L22_6d
-_L22_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L22_3d			# no
-	bsr.l		smod_szero			# yes
-	bra.b		_L22_6d
-_L22_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L22_4d			# no
-	bsr.l		smod_sinf			# yes
-	bra.b		_L22_6d
-_L22_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L22_5d			# no
-	bsr.l		sop_sqnan			# yes
-	bra.b		_L22_6d
-_L22_5d:
-	bsr.l		smod_sdnrm			# operand is a DENORM
-_L22_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fmodx_
-_fmodx_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_DST(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext dst
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,DTAG(%a6)
-
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x14+0x0(%a6),0x0(%a0)	# load ext src
-	mov.l		0x14+0x4(%a6),0x4(%a0)
-	mov.l		0x14+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.l		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	lea		FP_SRC(%a6),%a0		# pass ptr to src
-	lea		FP_DST(%a6),%a1		# pass ptr to dst
-
-	tst.b		%d1
-	bne.b		_L22_2x
-	bsr.l		smod_snorm			# operand is a NORM
-	bra.b		_L22_6x
-_L22_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L22_3x			# no
-	bsr.l		smod_szero			# yes
-	bra.b		_L22_6x
-_L22_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L22_4x			# no
-	bsr.l		smod_sinf			# yes
-	bra.b		_L22_6x
-_L22_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L22_5x			# no
-	bsr.l		sop_sqnan			# yes
-	bra.b		_L22_6x
-_L22_5x:
-	bsr.l		smod_sdnrm			# operand is a DENORM
-_L22_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# DYADIC TEMPLATE							#
-#########################################################################
-	global		_fscales_
-_fscales_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.s		0x8(%a6),%fp0		# load sgl dst
-	fmov.x		%fp0,FP_DST(%a6)
-	lea		FP_DST(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,DTAG(%a6)
-
-	fmov.s		0xc(%a6),%fp0		# load sgl src
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.l		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	lea		FP_SRC(%a6),%a0		# pass ptr to src
-	lea		FP_DST(%a6),%a1		# pass ptr to dst
-
-	tst.b		%d1
-	bne.b		_L23_2s
-	bsr.l		sscale_snorm			# operand is a NORM
-	bra.b		_L23_6s
-_L23_2s:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L23_3s			# no
-	bsr.l		sscale_szero			# yes
-	bra.b		_L23_6s
-_L23_3s:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L23_4s			# no
-	bsr.l		sscale_sinf			# yes
-	bra.b		_L23_6s
-_L23_4s:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L23_5s			# no
-	bsr.l		sop_sqnan			# yes
-	bra.b		_L23_6s
-_L23_5s:
-	bsr.l		sscale_sdnrm			# operand is a DENORM
-_L23_6s:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fscaled_
-_fscaled_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	fmov.d		0x8(%a6),%fp0		# load dbl dst
-	fmov.x		%fp0,FP_DST(%a6)
-	lea		FP_DST(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,DTAG(%a6)
-
-	fmov.d		0x10(%a6),%fp0		# load dbl src
-	fmov.x		%fp0,FP_SRC(%a6)
-	lea		FP_SRC(%a6),%a0
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.l		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	lea		FP_SRC(%a6),%a0		# pass ptr to src
-	lea		FP_DST(%a6),%a1		# pass ptr to dst
-
-	tst.b		%d1
-	bne.b		_L23_2d
-	bsr.l		sscale_snorm			# operand is a NORM
-	bra.b		_L23_6d
-_L23_2d:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L23_3d			# no
-	bsr.l		sscale_szero			# yes
-	bra.b		_L23_6d
-_L23_3d:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L23_4d			# no
-	bsr.l		sscale_sinf			# yes
-	bra.b		_L23_6d
-_L23_4d:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L23_5d			# no
-	bsr.l		sop_sqnan			# yes
-	bra.b		_L23_6d
-_L23_5d:
-	bsr.l		sscale_sdnrm			# operand is a DENORM
-_L23_6d:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-	global		_fscalex_
-_fscalex_:
-	link		%a6,&-LOCAL_SIZE
-
-	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
-	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
-	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
-
-	fmov.l		&0x0,%fpcr		# zero FPCR
-
-#
-#	copy, convert, and tag input argument
-#
-	lea		FP_DST(%a6),%a0
-	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext dst
-	mov.l		0x8+0x4(%a6),0x4(%a0)
-	mov.l		0x8+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,DTAG(%a6)
-
-	lea		FP_SRC(%a6),%a0
-	mov.l		0x14+0x0(%a6),0x0(%a0)	# load ext src
-	mov.l		0x14+0x4(%a6),0x4(%a0)
-	mov.l		0x14+0x8(%a6),0x8(%a0)
-	bsr.l		tag			# fetch operand type
-	mov.b		%d0,STAG(%a6)
-	mov.l		%d0,%d1
-
-	andi.l		&0x00ff00ff,USER_FPSR(%a6)
-
-	clr.l		%d0
-	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
-
-	lea		FP_SRC(%a6),%a0		# pass ptr to src
-	lea		FP_DST(%a6),%a1		# pass ptr to dst
-
-	tst.b		%d1
-	bne.b		_L23_2x
-	bsr.l		sscale_snorm			# operand is a NORM
-	bra.b		_L23_6x
-_L23_2x:
-	cmpi.b		%d1,&ZERO		# is operand a ZERO?
-	bne.b		_L23_3x			# no
-	bsr.l		sscale_szero			# yes
-	bra.b		_L23_6x
-_L23_3x:
-	cmpi.b		%d1,&INF		# is operand an INF?
-	bne.b		_L23_4x			# no
-	bsr.l		sscale_sinf			# yes
-	bra.b		_L23_6x
-_L23_4x:
-	cmpi.b		%d1,&QNAN		# is operand a QNAN?
-	bne.b		_L23_5x			# no
-	bsr.l		sop_sqnan			# yes
-	bra.b		_L23_6x
-_L23_5x:
-	bsr.l		sscale_sdnrm			# operand is a DENORM
-_L23_6x:
-
-#
-#	Result is now in FP0
-#
-	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
-	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
-	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
-	unlk		%a6
-	rts
-
-
-#########################################################################
-# ssin():     computes the sine of a normalized input			#
-# ssind():    computes the sine of a denormalized input			#
-# scos():     computes the cosine of a normalized input			#
-# scosd():    computes the cosine of a denormalized input		#
-# ssincos():  computes the sine and cosine of a normalized input	#
-# ssincosd(): computes the sine and cosine of a denormalized input	#
-#									#
-# INPUT *************************************************************** #
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT ************************************************************** #
-#	fp0 = sin(X) or cos(X)						#
-#									#
-#    For ssincos(X):							#
-#	fp0 = sin(X)							#
-#	fp1 = cos(X)							#
-#									#
-# ACCURACY and MONOTONICITY ******************************************* #
-#	The returned result is within 1 ulp in 64 significant bit, i.e.	#
-#	within 0.5001 ulp to 53 bits if the result is subsequently	#
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM ***********************************************************	#
-#									#
-#	SIN and COS:							#
-#	1. If SIN is invoked, set AdjN := 0; otherwise, set AdjN := 1.	#
-#									#
-#	2. If |X| >= 15Pi or |X| < 2**(-40), go to 7.			#
-#									#
-#	3. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let	#
-#		k = N mod 4, so in particular, k = 0,1,2,or 3.		#
-#		Overwrite k by k := k + AdjN.				#
-#									#
-#	4. If k is even, go to 6.					#
-#									#
-#	5. (k is odd) Set j := (k-1)/2, sgn := (-1)**j.			#
-#		Return sgn*cos(r) where cos(r) is approximated by an	#
-#		even polynomial in r, 1 + r*r*(B1+s*(B2+ ... + s*B8)),	#
-#		s = r*r.						#
-#		Exit.							#
-#									#
-#	6. (k is even) Set j := k/2, sgn := (-1)**j. Return sgn*sin(r)	#
-#		where sin(r) is approximated by an odd polynomial in r	#
-#		r + r*s*(A1+s*(A2+ ... + s*A7)),	s = r*r.	#
-#		Exit.							#
-#									#
-#	7. If |X| > 1, go to 9.						#
-#									#
-#	8. (|X|<2**(-40)) If SIN is invoked, return X;			#
-#		otherwise return 1.					#
-#									#
-#	9. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi,		#
-#		go back to 3.						#
-#									#
-#	SINCOS:								#
-#	1. If |X| >= 15Pi or |X| < 2**(-40), go to 6.			#
-#									#
-#	2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let	#
-#		k = N mod 4, so in particular, k = 0,1,2,or 3.		#
-#									#
-#	3. If k is even, go to 5.					#
-#									#
-#	4. (k is odd) Set j1 := (k-1)/2, j2 := j1 (EOR) (k mod 2), ie.	#
-#		j1 exclusive or with the l.s.b. of k.			#
-#		sgn1 := (-1)**j1, sgn2 := (-1)**j2.			#
-#		SIN(X) = sgn1 * cos(r) and COS(X) = sgn2*sin(r) where	#
-#		sin(r) and cos(r) are computed as odd and even		#
-#		polynomials in r, respectively. Exit			#
-#									#
-#	5. (k is even) Set j1 := k/2, sgn1 := (-1)**j1.			#
-#		SIN(X) = sgn1 * sin(r) and COS(X) = sgn1*cos(r) where	#
-#		sin(r) and cos(r) are computed as odd and even		#
-#		polynomials in r, respectively. Exit			#
-#									#
-#	6. If |X| > 1, go to 8.						#
-#									#
-#	7. (|X|<2**(-40)) SIN(X) = X and COS(X) = 1. Exit.		#
-#									#
-#	8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi,		#
-#		go back to 2.						#
-#									#
-#########################################################################
-
-SINA7:	long		0xBD6AAA77,0xCCC994F5
-SINA6:	long		0x3DE61209,0x7AAE8DA1
-SINA5:	long		0xBE5AE645,0x2A118AE4
-SINA4:	long		0x3EC71DE3,0xA5341531
-SINA3:	long		0xBF2A01A0,0x1A018B59,0x00000000,0x00000000
-SINA2:	long		0x3FF80000,0x88888888,0x888859AF,0x00000000
-SINA1:	long		0xBFFC0000,0xAAAAAAAA,0xAAAAAA99,0x00000000
-
-COSB8:	long		0x3D2AC4D0,0xD6011EE3
-COSB7:	long		0xBDA9396F,0x9F45AC19
-COSB6:	long		0x3E21EED9,0x0612C972
-COSB5:	long		0xBE927E4F,0xB79D9FCF
-COSB4:	long		0x3EFA01A0,0x1A01D423,0x00000000,0x00000000
-COSB3:	long		0xBFF50000,0xB60B60B6,0x0B61D438,0x00000000
-COSB2:	long		0x3FFA0000,0xAAAAAAAA,0xAAAAAB5E
-COSB1:	long		0xBF000000
-
-	set		INARG,FP_SCR0
-
-	set		X,FP_SCR0
-#	set		XDCARE,X+2
-	set		XFRAC,X+4
-
-	set		RPRIME,FP_SCR0
-	set		SPRIME,FP_SCR1
-
-	set		POSNEG1,L_SCR1
-	set		TWOTO63,L_SCR1
-
-	set		ENDFLAG,L_SCR2
-	set		INT,L_SCR2
-
-	set		ADJN,L_SCR3
-
-############################################
-	global		ssin
-ssin:
-	mov.l		&0,ADJN(%a6)		# yes; SET ADJN TO 0
-	bra.b		SINBGN
-
-############################################
-	global		scos
-scos:
-	mov.l		&1,ADJN(%a6)		# yes; SET ADJN TO 1
-
-############################################
-SINBGN:
-#--SAVE FPCR, FP1. CHECK IF |X| IS TOO SMALL OR LARGE
-
-	fmov.x		(%a0),%fp0		# LOAD INPUT
-	fmov.x		%fp0,X(%a6)		# save input at X
-
-# "COMPACTIFY" X
-	mov.l		(%a0),%d1		# put exp in hi word
-	mov.w		4(%a0),%d1		# fetch hi(man)
-	and.l		&0x7FFFFFFF,%d1		# strip sign
-
-	cmpi.l		%d1,&0x3FD78000		# is |X| >= 2**(-40)?
-	bge.b		SOK1			# no
-	bra.w		SINSM			# yes; input is very small
-
-SOK1:
-	cmp.l		%d1,&0x4004BC7E		# is |X| < 15 PI?
-	blt.b		SINMAIN			# no
-	bra.w		SREDUCEX		# yes; input is very large
-
-#--THIS IS THE USUAL CASE, |X| <= 15 PI.
-#--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
-SINMAIN:
-	fmov.x		%fp0,%fp1
-	fmul.d		TWOBYPI(%pc),%fp1	# X*2/PI
-
-	lea		PITBL+0x200(%pc),%a1	# TABLE OF N*PI/2, N = -32,...,32
-
-	fmov.l		%fp1,INT(%a6)		# CONVERT TO INTEGER
-
-	mov.l		INT(%a6),%d1		# make a copy of N
-	asl.l		&4,%d1			# N *= 16
-	add.l		%d1,%a1			# tbl_addr = a1 + (N*16)
-
-# A1 IS THE ADDRESS OF N*PIBY2
-# ...WHICH IS IN TWO PIECES Y1 & Y2
-	fsub.x		(%a1)+,%fp0		# X-Y1
-	fsub.s		(%a1),%fp0		# fp0 = R = (X-Y1)-Y2
-
-SINCONT:
-#--continuation from REDUCEX
-
-#--GET N+ADJN AND SEE IF SIN(R) OR COS(R) IS NEEDED
-	mov.l		INT(%a6),%d1
-	add.l		ADJN(%a6),%d1		# SEE IF D0 IS ODD OR EVEN
-	ror.l		&1,%d1			# D0 WAS ODD IFF D0 IS NEGATIVE
-	cmp.l		%d1,&0
-	blt.w		COSPOLY
-
-#--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J.
-#--THEN WE RETURN	SGN*SIN(R). SGN*SIN(R) IS COMPUTED BY
-#--R' + R'*S*(A1 + S(A2 + S(A3 + S(A4 + ... + SA7)))), WHERE
-#--R' = SGN*R, S=R*R. THIS CAN BE REWRITTEN AS
-#--R' + R'*S*( [A1+T(A3+T(A5+TA7))] + [S(A2+T(A4+TA6))])
-#--WHERE T=S*S.
-#--NOTE THAT A3 THROUGH A7 ARE STORED IN DOUBLE PRECISION
-#--WHILE A1 AND A2 ARE IN DOUBLE-EXTENDED FORMAT.
-SINPOLY:
-	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
-
-	fmov.x		%fp0,X(%a6)		# X IS R
-	fmul.x		%fp0,%fp0		# FP0 IS S
-
-	fmov.d		SINA7(%pc),%fp3
-	fmov.d		SINA6(%pc),%fp2
-
-	fmov.x		%fp0,%fp1
-	fmul.x		%fp1,%fp1		# FP1 IS T
-
-	ror.l		&1,%d1
-	and.l		&0x80000000,%d1
-# ...LEAST SIG. BIT OF D0 IN SIGN POSITION
-	eor.l		%d1,X(%a6)		# X IS NOW R'= SGN*R
-
-	fmul.x		%fp1,%fp3		# TA7
-	fmul.x		%fp1,%fp2		# TA6
-
-	fadd.d		SINA5(%pc),%fp3		# A5+TA7
-	fadd.d		SINA4(%pc),%fp2		# A4+TA6
-
-	fmul.x		%fp1,%fp3		# T(A5+TA7)
-	fmul.x		%fp1,%fp2		# T(A4+TA6)
-
-	fadd.d		SINA3(%pc),%fp3		# A3+T(A5+TA7)
-	fadd.x		SINA2(%pc),%fp2		# A2+T(A4+TA6)
-
-	fmul.x		%fp3,%fp1		# T(A3+T(A5+TA7))
-
-	fmul.x		%fp0,%fp2		# S(A2+T(A4+TA6))
-	fadd.x		SINA1(%pc),%fp1		# A1+T(A3+T(A5+TA7))
-	fmul.x		X(%a6),%fp0		# R'*S
-
-	fadd.x		%fp2,%fp1		# [A1+T(A3+T(A5+TA7))]+[S(A2+T(A4+TA6))]
-
-	fmul.x		%fp1,%fp0		# SIN(R')-R'
-
-	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
-
-	fmov.l		%d0,%fpcr		# restore users round mode,prec
-	fadd.x		X(%a6),%fp0		# last inst - possible exception set
-	bra		t_inx2
-
-#--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J.
-#--THEN WE RETURN	SGN*COS(R). SGN*COS(R) IS COMPUTED BY
-#--SGN + S'*(B1 + S(B2 + S(B3 + S(B4 + ... + SB8)))), WHERE
-#--S=R*R AND S'=SGN*S. THIS CAN BE REWRITTEN AS
-#--SGN + S'*([B1+T(B3+T(B5+TB7))] + [S(B2+T(B4+T(B6+TB8)))])
-#--WHERE T=S*S.
-#--NOTE THAT B4 THROUGH B8 ARE STORED IN DOUBLE PRECISION
-#--WHILE B2 AND B3 ARE IN DOUBLE-EXTENDED FORMAT, B1 IS -1/2
-#--AND IS THEREFORE STORED AS SINGLE PRECISION.
-COSPOLY:
-	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
-
-	fmul.x		%fp0,%fp0		# FP0 IS S
-
-	fmov.d		COSB8(%pc),%fp2
-	fmov.d		COSB7(%pc),%fp3
-
-	fmov.x		%fp0,%fp1
-	fmul.x		%fp1,%fp1		# FP1 IS T
-
-	fmov.x		%fp0,X(%a6)		# X IS S
-	ror.l		&1,%d1
-	and.l		&0x80000000,%d1
-# ...LEAST SIG. BIT OF D0 IN SIGN POSITION
-
-	fmul.x		%fp1,%fp2		# TB8
-
-	eor.l		%d1,X(%a6)		# X IS NOW S'= SGN*S
-	and.l		&0x80000000,%d1
-
-	fmul.x		%fp1,%fp3		# TB7
-
-	or.l		&0x3F800000,%d1		# D0 IS SGN IN SINGLE
-	mov.l		%d1,POSNEG1(%a6)
-
-	fadd.d		COSB6(%pc),%fp2		# B6+TB8
-	fadd.d		COSB5(%pc),%fp3		# B5+TB7
-
-	fmul.x		%fp1,%fp2		# T(B6+TB8)
-	fmul.x		%fp1,%fp3		# T(B5+TB7)
-
-	fadd.d		COSB4(%pc),%fp2		# B4+T(B6+TB8)
-	fadd.x		COSB3(%pc),%fp3		# B3+T(B5+TB7)
-
-	fmul.x		%fp1,%fp2		# T(B4+T(B6+TB8))
-	fmul.x		%fp3,%fp1		# T(B3+T(B5+TB7))
-
-	fadd.x		COSB2(%pc),%fp2		# B2+T(B4+T(B6+TB8))
-	fadd.s		COSB1(%pc),%fp1		# B1+T(B3+T(B5+TB7))
-
-	fmul.x		%fp2,%fp0		# S(B2+T(B4+T(B6+TB8)))
-
-	fadd.x		%fp1,%fp0
-
-	fmul.x		X(%a6),%fp0
-
-	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
-
-	fmov.l		%d0,%fpcr		# restore users round mode,prec
-	fadd.s		POSNEG1(%a6),%fp0	# last inst - possible exception set
-	bra		t_inx2
-
-##############################################
-
-# SINe: Big OR Small?
-#--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
-#--IF |X| < 2**(-40), RETURN X OR 1.
-SINBORS:
-	cmp.l		%d1,&0x3FFF8000
-	bgt.l		SREDUCEX
-
-SINSM:
-	mov.l		ADJN(%a6),%d1
-	cmp.l		%d1,&0
-	bgt.b		COSTINY
-
-# here, the operation may underflow iff the precision is sgl or dbl.
-# extended denorms are handled through another entry point.
-SINTINY:
-#	mov.w		&0x0000,XDCARE(%a6)	# JUST IN CASE
-
-	fmov.l		%d0,%fpcr		# restore users round mode,prec
-	mov.b		&FMOV_OP,%d1		# last inst is MOVE
-	fmov.x		X(%a6),%fp0		# last inst - possible exception set
-	bra		t_catch
-
-COSTINY:
-	fmov.s		&0x3F800000,%fp0	# fp0 = 1.0
-	fmov.l		%d0,%fpcr		# restore users round mode,prec
-	fadd.s		&0x80800000,%fp0	# last inst - possible exception set
-	bra		t_pinx2
-
-################################################
-	global		ssind
-#--SIN(X) = X FOR DENORMALIZED X
-ssind:
-	bra		t_extdnrm
-
-############################################
-	global		scosd
-#--COS(X) = 1 FOR DENORMALIZED X
-scosd:
-	fmov.s		&0x3F800000,%fp0	# fp0 = 1.0
-	bra		t_pinx2
-
-##################################################
-
-	global		ssincos
-ssincos:
-#--SET ADJN TO 4
-	mov.l		&4,ADJN(%a6)
-
-	fmov.x		(%a0),%fp0		# LOAD INPUT
-	fmov.x		%fp0,X(%a6)
-
-	mov.l		(%a0),%d1
-	mov.w		4(%a0),%d1
-	and.l		&0x7FFFFFFF,%d1		# COMPACTIFY X
-
-	cmp.l		%d1,&0x3FD78000		# |X| >= 2**(-40)?
-	bge.b		SCOK1
-	bra.w		SCSM
-
-SCOK1:
-	cmp.l		%d1,&0x4004BC7E		# |X| < 15 PI?
-	blt.b		SCMAIN
-	bra.w		SREDUCEX
-
-
-#--THIS IS THE USUAL CASE, |X| <= 15 PI.
-#--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
-SCMAIN:
-	fmov.x		%fp0,%fp1
-
-	fmul.d		TWOBYPI(%pc),%fp1	# X*2/PI
-
-	lea		PITBL+0x200(%pc),%a1	# TABLE OF N*PI/2, N = -32,...,32
-
-	fmov.l		%fp1,INT(%a6)		# CONVERT TO INTEGER
-
-	mov.l		INT(%a6),%d1
-	asl.l		&4,%d1
-	add.l		%d1,%a1			# ADDRESS OF N*PIBY2, IN Y1, Y2
-
-	fsub.x		(%a1)+,%fp0		# X-Y1
-	fsub.s		(%a1),%fp0		# FP0 IS R = (X-Y1)-Y2
-
-SCCONT:
-#--continuation point from REDUCEX
-
-	mov.l		INT(%a6),%d1
-	ror.l		&1,%d1
-	cmp.l		%d1,&0			# D0 < 0 IFF N IS ODD
-	bge.w		NEVEN
-
-SNODD:
-#--REGISTERS SAVED SO FAR: D0, A0, FP2.
-	fmovm.x		&0x04,-(%sp)		# save fp2
-
-	fmov.x		%fp0,RPRIME(%a6)
-	fmul.x		%fp0,%fp0		# FP0 IS S = R*R
-	fmov.d		SINA7(%pc),%fp1		# A7
-	fmov.d		COSB8(%pc),%fp2		# B8
-	fmul.x		%fp0,%fp1		# SA7
-	fmul.x		%fp0,%fp2		# SB8
-
-	mov.l		%d2,-(%sp)
-	mov.l		%d1,%d2
-	ror.l		&1,%d2
-	and.l		&0x80000000,%d2
-	eor.l		%d1,%d2
-	and.l		&0x80000000,%d2
-
-	fadd.d		SINA6(%pc),%fp1		# A6+SA7
-	fadd.d		COSB7(%pc),%fp2		# B7+SB8
-
-	fmul.x		%fp0,%fp1		# S(A6+SA7)
-	eor.l		%d2,RPRIME(%a6)
-	mov.l		(%sp)+,%d2
-	fmul.x		%fp0,%fp2		# S(B7+SB8)
-	ror.l		&1,%d1
-	and.l		&0x80000000,%d1
-	mov.l		&0x3F800000,POSNEG1(%a6)
-	eor.l		%d1,POSNEG1(%a6)
-
-	fadd.d		SINA5(%pc),%fp1		# A5+S(A6+SA7)
-	fadd.d		COSB6(%pc),%fp2		# B6+S(B7+SB8)
-
-	fmul.x		%fp0,%fp1		# S(A5+S(A6+SA7))
-	fmul.x		%fp0,%fp2		# S(B6+S(B7+SB8))
-	fmov.x		%fp0,SPRIME(%a6)
-
-	fadd.d		SINA4(%pc),%fp1		# A4+S(A5+S(A6+SA7))
-	eor.l		%d1,SPRIME(%a6)
-	fadd.d		COSB5(%pc),%fp2		# B5+S(B6+S(B7+SB8))
-
-	fmul.x		%fp0,%fp1		# S(A4+...)
-	fmul.x		%fp0,%fp2		# S(B5+...)
-
-	fadd.d		SINA3(%pc),%fp1		# A3+S(A4+...)
-	fadd.d		COSB4(%pc),%fp2		# B4+S(B5+...)
-
-	fmul.x		%fp0,%fp1		# S(A3+...)
-	fmul.x		%fp0,%fp2		# S(B4+...)
-
-	fadd.x		SINA2(%pc),%fp1		# A2+S(A3+...)
-	fadd.x		COSB3(%pc),%fp2		# B3+S(B4+...)
-
-	fmul.x		%fp0,%fp1		# S(A2+...)
-	fmul.x		%fp0,%fp2		# S(B3+...)
-
-	fadd.x		SINA1(%pc),%fp1		# A1+S(A2+...)
-	fadd.x		COSB2(%pc),%fp2		# B2+S(B3+...)
-
-	fmul.x		%fp0,%fp1		# S(A1+...)
-	fmul.x		%fp2,%fp0		# S(B2+...)
-
-	fmul.x		RPRIME(%a6),%fp1	# R'S(A1+...)
-	fadd.s		COSB1(%pc),%fp0		# B1+S(B2...)
-	fmul.x		SPRIME(%a6),%fp0	# S'(B1+S(B2+...))
-
-	fmovm.x		(%sp)+,&0x20		# restore fp2
-
-	fmov.l		%d0,%fpcr
-	fadd.x		RPRIME(%a6),%fp1	# COS(X)
-	bsr		sto_cos			# store cosine result
-	fadd.s		POSNEG1(%a6),%fp0	# SIN(X)
-	bra		t_inx2
-
-NEVEN:
-#--REGISTERS SAVED SO FAR: FP2.
-	fmovm.x		&0x04,-(%sp)		# save fp2
-
-	fmov.x		%fp0,RPRIME(%a6)
-	fmul.x		%fp0,%fp0		# FP0 IS S = R*R
-
-	fmov.d		COSB8(%pc),%fp1		# B8
-	fmov.d		SINA7(%pc),%fp2		# A7
-
-	fmul.x		%fp0,%fp1		# SB8
-	fmov.x		%fp0,SPRIME(%a6)
-	fmul.x		%fp0,%fp2		# SA7
-
-	ror.l		&1,%d1
-	and.l		&0x80000000,%d1
-
-	fadd.d		COSB7(%pc),%fp1		# B7+SB8
-	fadd.d		SINA6(%pc),%fp2		# A6+SA7
-
-	eor.l		%d1,RPRIME(%a6)
-	eor.l		%d1,SPRIME(%a6)
-
-	fmul.x		%fp0,%fp1		# S(B7+SB8)
-
-	or.l		&0x3F800000,%d1
-	mov.l		%d1,POSNEG1(%a6)
-
-	fmul.x		%fp0,%fp2		# S(A6+SA7)
-
-	fadd.d		COSB6(%pc),%fp1		# B6+S(B7+SB8)
-	fadd.d		SINA5(%pc),%fp2		# A5+S(A6+SA7)
-
-	fmul.x		%fp0,%fp1		# S(B6+S(B7+SB8))
-	fmul.x		%fp0,%fp2		# S(A5+S(A6+SA7))
-
-	fadd.d		COSB5(%pc),%fp1		# B5+S(B6+S(B7+SB8))
-	fadd.d		SINA4(%pc),%fp2		# A4+S(A5+S(A6+SA7))
-
-	fmul.x		%fp0,%fp1		# S(B5+...)
-	fmul.x		%fp0,%fp2		# S(A4+...)
-
-	fadd.d		COSB4(%pc),%fp1		# B4+S(B5+...)
-	fadd.d		SINA3(%pc),%fp2		# A3+S(A4+...)
-
-	fmul.x		%fp0,%fp1		# S(B4+...)
-	fmul.x		%fp0,%fp2		# S(A3+...)
-
-	fadd.x		COSB3(%pc),%fp1		# B3+S(B4+...)
-	fadd.x		SINA2(%pc),%fp2		# A2+S(A3+...)
-
-	fmul.x		%fp0,%fp1		# S(B3+...)
-	fmul.x		%fp0,%fp2		# S(A2+...)
-
-	fadd.x		COSB2(%pc),%fp1		# B2+S(B3+...)
-	fadd.x		SINA1(%pc),%fp2		# A1+S(A2+...)
-
-	fmul.x		%fp0,%fp1		# S(B2+...)
-	fmul.x		%fp2,%fp0		# s(a1+...)
-
-
-	fadd.s		COSB1(%pc),%fp1		# B1+S(B2...)
-	fmul.x		RPRIME(%a6),%fp0	# R'S(A1+...)
-	fmul.x		SPRIME(%a6),%fp1	# S'(B1+S(B2+...))
-
-	fmovm.x		(%sp)+,&0x20		# restore fp2
-
-	fmov.l		%d0,%fpcr
-	fadd.s		POSNEG1(%a6),%fp1	# COS(X)
-	bsr		sto_cos			# store cosine result
-	fadd.x		RPRIME(%a6),%fp0	# SIN(X)
-	bra		t_inx2
-
-################################################
-
-SCBORS:
-	cmp.l		%d1,&0x3FFF8000
-	bgt.w		SREDUCEX
-
-################################################
-
-SCSM:
-#	mov.w		&0x0000,XDCARE(%a6)
-	fmov.s		&0x3F800000,%fp1
-
-	fmov.l		%d0,%fpcr
-	fsub.s		&0x00800000,%fp1
-	bsr		sto_cos			# store cosine result
-	fmov.l		%fpcr,%d0		# d0 must have fpcr,too
-	mov.b		&FMOV_OP,%d1		# last inst is MOVE
-	fmov.x		X(%a6),%fp0
-	bra		t_catch
-
-##############################################
-
-	global		ssincosd
-#--SIN AND COS OF X FOR DENORMALIZED X
-ssincosd:
-	mov.l		%d0,-(%sp)		# save d0
-	fmov.s		&0x3F800000,%fp1
-	bsr		sto_cos			# store cosine result
-	mov.l		(%sp)+,%d0		# restore d0
-	bra		t_extdnrm
-
-############################################
-
-#--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW.
-#--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING
-#--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.
-SREDUCEX:
-	fmovm.x		&0x3c,-(%sp)		# save {fp2-fp5}
-	mov.l		%d2,-(%sp)		# save d2
-	fmov.s		&0x00000000,%fp1	# fp1 = 0
-
-#--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that
-#--there is a danger of unwanted overflow in first LOOP iteration.  In this
-#--case, reduce argument by one remainder step to make subsequent reduction
-#--safe.
-	cmp.l		%d1,&0x7ffeffff		# is arg dangerously large?
-	bne.b		SLOOP			# no
-
-# yes; create 2**16383*PI/2
-	mov.w		&0x7ffe,FP_SCR0_EX(%a6)
-	mov.l		&0xc90fdaa2,FP_SCR0_HI(%a6)
-	clr.l		FP_SCR0_LO(%a6)
-
-# create low half of 2**16383*PI/2 at FP_SCR1
-	mov.w		&0x7fdc,FP_SCR1_EX(%a6)
-	mov.l		&0x85a308d3,FP_SCR1_HI(%a6)
-	clr.l		FP_SCR1_LO(%a6)
-
-	ftest.x		%fp0			# test sign of argument
-	fblt.w		sred_neg
-
-	or.b		&0x80,FP_SCR0_EX(%a6)	# positive arg
-	or.b		&0x80,FP_SCR1_EX(%a6)
-sred_neg:
-	fadd.x		FP_SCR0(%a6),%fp0	# high part of reduction is exact
-	fmov.x		%fp0,%fp1		# save high result in fp1
-	fadd.x		FP_SCR1(%a6),%fp0	# low part of reduction
-	fsub.x		%fp0,%fp1		# determine low component of result
-	fadd.x		FP_SCR1(%a6),%fp1	# fp0/fp1 are reduced argument.
-
-#--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
-#--integer quotient will be stored in N
-#--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
-SLOOP:
-	fmov.x		%fp0,INARG(%a6)		# +-2**K * F, 1 <= F < 2
-	mov.w		INARG(%a6),%d1
-	mov.l		%d1,%a1			# save a copy of D0
-	and.l		&0x00007FFF,%d1
-	sub.l		&0x00003FFF,%d1		# d0 = K
-	cmp.l		%d1,&28
-	ble.b		SLASTLOOP
-SCONTLOOP:
-	sub.l		&27,%d1			# d0 = L := K-27
-	mov.b		&0,ENDFLAG(%a6)
-	bra.b		SWORK
-SLASTLOOP:
-	clr.l		%d1			# d0 = L := 0
-	mov.b		&1,ENDFLAG(%a6)
-
-SWORK:
-#--FIND THE REMAINDER OF (R,r) W.R.T.	2**L * (PI/2). L IS SO CHOSEN
-#--THAT	INT( X * (2/PI) / 2**(L) ) < 2**29.
-
-#--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63),
-#--2**L * (PIby2_1), 2**L * (PIby2_2)
-
-	mov.l		&0x00003FFE,%d2		# BIASED EXP OF 2/PI
-	sub.l		%d1,%d2			# BIASED EXP OF 2**(-L)*(2/PI)
-
-	mov.l		&0xA2F9836E,FP_SCR0_HI(%a6)
-	mov.l		&0x4E44152A,FP_SCR0_LO(%a6)
-	mov.w		%d2,FP_SCR0_EX(%a6)	# FP_SCR0 = 2**(-L)*(2/PI)
-
-	fmov.x		%fp0,%fp2
-	fmul.x		FP_SCR0(%a6),%fp2	# fp2 = X * 2**(-L)*(2/PI)
-
-#--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN
-#--FLOATING POINT FORMAT, THE TWO FMOVE'S	FMOVE.L FP <--> N
-#--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT
-#--(SIGN(INARG)*2**63	+	FP2) - SIGN(INARG)*2**63 WILL GIVE
-#--US THE DESIRED VALUE IN FLOATING POINT.
-	mov.l		%a1,%d2
-	swap		%d2
-	and.l		&0x80000000,%d2
-	or.l		&0x5F000000,%d2		# d2 = SIGN(INARG)*2**63 IN SGL
-	mov.l		%d2,TWOTO63(%a6)
-	fadd.s		TWOTO63(%a6),%fp2	# THE FRACTIONAL PART OF FP1 IS ROUNDED
-	fsub.s		TWOTO63(%a6),%fp2	# fp2 = N
-#	fint.x		%fp2
-
-#--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2
-	mov.l		%d1,%d2			# d2 = L
-
-	add.l		&0x00003FFF,%d2		# BIASED EXP OF 2**L * (PI/2)
-	mov.w		%d2,FP_SCR0_EX(%a6)
-	mov.l		&0xC90FDAA2,FP_SCR0_HI(%a6)
-	clr.l		FP_SCR0_LO(%a6)		# FP_SCR0 = 2**(L) * Piby2_1
-
-	add.l		&0x00003FDD,%d1
-	mov.w		%d1,FP_SCR1_EX(%a6)
-	mov.l		&0x85A308D3,FP_SCR1_HI(%a6)
-	clr.l		FP_SCR1_LO(%a6)		# FP_SCR1 = 2**(L) * Piby2_2
-
-	mov.b		ENDFLAG(%a6),%d1
-
-#--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and
-#--P2 = 2**(L) * Piby2_2
-	fmov.x		%fp2,%fp4		# fp4 = N
-	fmul.x		FP_SCR0(%a6),%fp4	# fp4 = W = N*P1
-	fmov.x		%fp2,%fp5		# fp5 = N
-	fmul.x		FP_SCR1(%a6),%fp5	# fp5 = w = N*P2
-	fmov.x		%fp4,%fp3		# fp3 = W = N*P1
-
-#--we want P+p = W+w  but  |p| <= half ulp of P
-#--Then, we need to compute  A := R-P   and  a := r-p
-	fadd.x		%fp5,%fp3		# fp3 = P
-	fsub.x		%fp3,%fp4		# fp4 = W-P
-
-	fsub.x		%fp3,%fp0		# fp0 = A := R - P
-	fadd.x		%fp5,%fp4		# fp4 = p = (W-P)+w
-
-	fmov.x		%fp0,%fp3		# fp3 = A
-	fsub.x		%fp4,%fp1		# fp1 = a := r - p
-
-#--Now we need to normalize (A,a) to  "new (R,r)" where R+r = A+a but
-#--|r| <= half ulp of R.
-	fadd.x		%fp1,%fp0		# fp0 = R := A+a
-#--No need to calculate r if this is the last loop
-	cmp.b		%d1,&0
-	bgt.w		SRESTORE
-
-#--Need to calculate r
-	fsub.x		%fp0,%fp3		# fp3 = A-R
-	fadd.x		%fp3,%fp1		# fp1 = r := (A-R)+a
-	bra.w		SLOOP
-
-SRESTORE:
-	fmov.l		%fp2,INT(%a6)
-	mov.l		(%sp)+,%d2		# restore d2
-	fmovm.x		(%sp)+,&0x3c		# restore {fp2-fp5}
-
-	mov.l		ADJN(%a6),%d1
-	cmp.l		%d1,&4
-
-	blt.w		SINCONT
-	bra.w		SCCONT
-
-#########################################################################
-# stan():  computes the tangent of a normalized input			#
-# stand(): computes the tangent of a denormalized input			#
-#									#
-# INPUT *************************************************************** #
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT ************************************************************** #
-#	fp0 = tan(X)							#
-#									#
-# ACCURACY and MONOTONICITY ******************************************* #
-#	The returned result is within 3 ulp in 64 significant bit, i.e. #
-#	within 0.5001 ulp to 53 bits if the result is subsequently	#
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM *********************************************************** #
-#									#
-#	1. If |X| >= 15Pi or |X| < 2**(-40), go to 6.			#
-#									#
-#	2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let	#
-#		k = N mod 2, so in particular, k = 0 or 1.		#
-#									#
-#	3. If k is odd, go to 5.					#
-#									#
-#	4. (k is even) Tan(X) = tan(r) and tan(r) is approximated by a	#
-#		rational function U/V where				#
-#		U = r + r*s*(P1 + s*(P2 + s*P3)), and			#
-#		V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))),  s = r*r.	#
-#		Exit.							#
-#									#
-#	4. (k is odd) Tan(X) = -cot(r). Since tan(r) is approximated by #
-#		a rational function U/V where				#
-#		U = r + r*s*(P1 + s*(P2 + s*P3)), and			#
-#		V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))), s = r*r,	#
-#		-Cot(r) = -V/U. Exit.					#
-#									#
-#	6. If |X| > 1, go to 8.						#
-#									#
-#	7. (|X|<2**(-40)) Tan(X) = X. Exit.				#
-#									#
-#	8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, go back	#
-#		to 2.							#
-#									#
-#########################################################################
-
-TANQ4:
-	long		0x3EA0B759,0xF50F8688
-TANP3:
-	long		0xBEF2BAA5,0xA8924F04
-
-TANQ3:
-	long		0xBF346F59,0xB39BA65F,0x00000000,0x00000000
-
-TANP2:
-	long		0x3FF60000,0xE073D3FC,0x199C4A00,0x00000000
-
-TANQ2:
-	long		0x3FF90000,0xD23CD684,0x15D95FA1,0x00000000
-
-TANP1:
-	long		0xBFFC0000,0x8895A6C5,0xFB423BCA,0x00000000
-
-TANQ1:
-	long		0xBFFD0000,0xEEF57E0D,0xA84BC8CE,0x00000000
-
-INVTWOPI:
-	long		0x3FFC0000,0xA2F9836E,0x4E44152A,0x00000000
-
-TWOPI1:
-	long		0x40010000,0xC90FDAA2,0x00000000,0x00000000
-TWOPI2:
-	long		0x3FDF0000,0x85A308D4,0x00000000,0x00000000
-
-#--N*PI/2, -32 <= N <= 32, IN A LEADING TERM IN EXT. AND TRAILING
-#--TERM IN SGL. NOTE THAT PI IS 64-BIT LONG, THUS N*PI/2 IS AT
-#--MOST 69 BITS LONG.
-#	global		PITBL
-PITBL:
-	long		0xC0040000,0xC90FDAA2,0x2168C235,0x21800000
-	long		0xC0040000,0xC2C75BCD,0x105D7C23,0xA0D00000
-	long		0xC0040000,0xBC7EDCF7,0xFF523611,0xA1E80000
-	long		0xC0040000,0xB6365E22,0xEE46F000,0x21480000
-	long		0xC0040000,0xAFEDDF4D,0xDD3BA9EE,0xA1200000
-	long		0xC0040000,0xA9A56078,0xCC3063DD,0x21FC0000
-	long		0xC0040000,0xA35CE1A3,0xBB251DCB,0x21100000
-	long		0xC0040000,0x9D1462CE,0xAA19D7B9,0xA1580000
-	long		0xC0040000,0x96CBE3F9,0x990E91A8,0x21E00000
-	long		0xC0040000,0x90836524,0x88034B96,0x20B00000
-	long		0xC0040000,0x8A3AE64F,0x76F80584,0xA1880000
-	long		0xC0040000,0x83F2677A,0x65ECBF73,0x21C40000
-	long		0xC0030000,0xFB53D14A,0xA9C2F2C2,0x20000000
-	long		0xC0030000,0xEEC2D3A0,0x87AC669F,0x21380000
-	long		0xC0030000,0xE231D5F6,0x6595DA7B,0xA1300000
-	long		0xC0030000,0xD5A0D84C,0x437F4E58,0x9FC00000
-	long		0xC0030000,0xC90FDAA2,0x2168C235,0x21000000
-	long		0xC0030000,0xBC7EDCF7,0xFF523611,0xA1680000
-	long		0xC0030000,0xAFEDDF4D,0xDD3BA9EE,0xA0A00000
-	long		0xC0030000,0xA35CE1A3,0xBB251DCB,0x20900000
-	long		0xC0030000,0x96CBE3F9,0x990E91A8,0x21600000
-	long		0xC0030000,0x8A3AE64F,0x76F80584,0xA1080000
-	long		0xC0020000,0xFB53D14A,0xA9C2F2C2,0x1F800000
-	long		0xC0020000,0xE231D5F6,0x6595DA7B,0xA0B00000
-	long		0xC0020000,0xC90FDAA2,0x2168C235,0x20800000
-	long		0xC0020000,0xAFEDDF4D,0xDD3BA9EE,0xA0200000
-	long		0xC0020000,0x96CBE3F9,0x990E91A8,0x20E00000
-	long		0xC0010000,0xFB53D14A,0xA9C2F2C2,0x1F000000
-	long		0xC0010000,0xC90FDAA2,0x2168C235,0x20000000
-	long		0xC0010000,0x96CBE3F9,0x990E91A8,0x20600000
-	long		0xC0000000,0xC90FDAA2,0x2168C235,0x1F800000
-	long		0xBFFF0000,0xC90FDAA2,0x2168C235,0x1F000000
-	long		0x00000000,0x00000000,0x00000000,0x00000000
-	long		0x3FFF0000,0xC90FDAA2,0x2168C235,0x9F000000
-	long		0x40000000,0xC90FDAA2,0x2168C235,0x9F800000
-	long		0x40010000,0x96CBE3F9,0x990E91A8,0xA0600000
-	long		0x40010000,0xC90FDAA2,0x2168C235,0xA0000000
-	long		0x40010000,0xFB53D14A,0xA9C2F2C2,0x9F000000
-	long		0x40020000,0x96CBE3F9,0x990E91A8,0xA0E00000
-	long		0x40020000,0xAFEDDF4D,0xDD3BA9EE,0x20200000
-	long		0x40020000,0xC90FDAA2,0x2168C235,0xA0800000
-	long		0x40020000,0xE231D5F6,0x6595DA7B,0x20B00000
-	long		0x40020000,0xFB53D14A,0xA9C2F2C2,0x9F800000
-	long		0x40030000,0x8A3AE64F,0x76F80584,0x21080000
-	long		0x40030000,0x96CBE3F9,0x990E91A8,0xA1600000
-	long		0x40030000,0xA35CE1A3,0xBB251DCB,0xA0900000
-	long		0x40030000,0xAFEDDF4D,0xDD3BA9EE,0x20A00000
-	long		0x40030000,0xBC7EDCF7,0xFF523611,0x21680000
-	long		0x40030000,0xC90FDAA2,0x2168C235,0xA1000000
-	long		0x40030000,0xD5A0D84C,0x437F4E58,0x1FC00000
-	long		0x40030000,0xE231D5F6,0x6595DA7B,0x21300000
-	long		0x40030000,0xEEC2D3A0,0x87AC669F,0xA1380000
-	long		0x40030000,0xFB53D14A,0xA9C2F2C2,0xA0000000
-	long		0x40040000,0x83F2677A,0x65ECBF73,0xA1C40000
-	long		0x40040000,0x8A3AE64F,0x76F80584,0x21880000
-	long		0x40040000,0x90836524,0x88034B96,0xA0B00000
-	long		0x40040000,0x96CBE3F9,0x990E91A8,0xA1E00000
-	long		0x40040000,0x9D1462CE,0xAA19D7B9,0x21580000
-	long		0x40040000,0xA35CE1A3,0xBB251DCB,0xA1100000
-	long		0x40040000,0xA9A56078,0xCC3063DD,0xA1FC0000
-	long		0x40040000,0xAFEDDF4D,0xDD3BA9EE,0x21200000
-	long		0x40040000,0xB6365E22,0xEE46F000,0xA1480000
-	long		0x40040000,0xBC7EDCF7,0xFF523611,0x21E80000
-	long		0x40040000,0xC2C75BCD,0x105D7C23,0x20D00000
-	long		0x40040000,0xC90FDAA2,0x2168C235,0xA1800000
-
-	set		INARG,FP_SCR0
-
-	set		TWOTO63,L_SCR1
-	set		INT,L_SCR1
-	set		ENDFLAG,L_SCR2
-
-	global		stan
-stan:
-	fmov.x		(%a0),%fp0		# LOAD INPUT
-
-	mov.l		(%a0),%d1
-	mov.w		4(%a0),%d1
-	and.l		&0x7FFFFFFF,%d1
-
-	cmp.l		%d1,&0x3FD78000		# |X| >= 2**(-40)?
-	bge.b		TANOK1
-	bra.w		TANSM
-TANOK1:
-	cmp.l		%d1,&0x4004BC7E		# |X| < 15 PI?
-	blt.b		TANMAIN
-	bra.w		REDUCEX
-
-TANMAIN:
-#--THIS IS THE USUAL CASE, |X| <= 15 PI.
-#--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
-	fmov.x		%fp0,%fp1
-	fmul.d		TWOBYPI(%pc),%fp1	# X*2/PI
-
-	lea.l		PITBL+0x200(%pc),%a1	# TABLE OF N*PI/2, N = -32,...,32
-
-	fmov.l		%fp1,%d1		# CONVERT TO INTEGER
-
-	asl.l		&4,%d1
-	add.l		%d1,%a1			# ADDRESS N*PIBY2 IN Y1, Y2
-
-	fsub.x		(%a1)+,%fp0		# X-Y1
-
-	fsub.s		(%a1),%fp0		# FP0 IS R = (X-Y1)-Y2
-
-	ror.l		&5,%d1
-	and.l		&0x80000000,%d1		# D0 WAS ODD IFF D0 < 0
-
-TANCONT:
-	fmovm.x		&0x0c,-(%sp)		# save fp2,fp3
-
-	cmp.l		%d1,&0
-	blt.w		NODD
-
-	fmov.x		%fp0,%fp1
-	fmul.x		%fp1,%fp1		# S = R*R
-
-	fmov.d		TANQ4(%pc),%fp3
-	fmov.d		TANP3(%pc),%fp2
-
-	fmul.x		%fp1,%fp3		# SQ4
-	fmul.x		%fp1,%fp2		# SP3
-
-	fadd.d		TANQ3(%pc),%fp3		# Q3+SQ4
-	fadd.x		TANP2(%pc),%fp2		# P2+SP3
-
-	fmul.x		%fp1,%fp3		# S(Q3+SQ4)
-	fmul.x		%fp1,%fp2		# S(P2+SP3)
-
-	fadd.x		TANQ2(%pc),%fp3		# Q2+S(Q3+SQ4)
-	fadd.x		TANP1(%pc),%fp2		# P1+S(P2+SP3)
-
-	fmul.x		%fp1,%fp3		# S(Q2+S(Q3+SQ4))
-	fmul.x		%fp1,%fp2		# S(P1+S(P2+SP3))
-
-	fadd.x		TANQ1(%pc),%fp3		# Q1+S(Q2+S(Q3+SQ4))
-	fmul.x		%fp0,%fp2		# RS(P1+S(P2+SP3))
-
-	fmul.x		%fp3,%fp1		# S(Q1+S(Q2+S(Q3+SQ4)))
-
-	fadd.x		%fp2,%fp0		# R+RS(P1+S(P2+SP3))
-
-	fadd.s		&0x3F800000,%fp1	# 1+S(Q1+...)
-
-	fmovm.x		(%sp)+,&0x30		# restore fp2,fp3
-
-	fmov.l		%d0,%fpcr		# restore users round mode,prec
-	fdiv.x		%fp1,%fp0		# last inst - possible exception set
-	bra		t_inx2
-
-NODD:
-	fmov.x		%fp0,%fp1
-	fmul.x		%fp0,%fp0		# S = R*R
-
-	fmov.d		TANQ4(%pc),%fp3
-	fmov.d		TANP3(%pc),%fp2
-
-	fmul.x		%fp0,%fp3		# SQ4
-	fmul.x		%fp0,%fp2		# SP3
-
-	fadd.d		TANQ3(%pc),%fp3		# Q3+SQ4
-	fadd.x		TANP2(%pc),%fp2		# P2+SP3
-
-	fmul.x		%fp0,%fp3		# S(Q3+SQ4)
-	fmul.x		%fp0,%fp2		# S(P2+SP3)
-
-	fadd.x		TANQ2(%pc),%fp3		# Q2+S(Q3+SQ4)
-	fadd.x		TANP1(%pc),%fp2		# P1+S(P2+SP3)
-
-	fmul.x		%fp0,%fp3		# S(Q2+S(Q3+SQ4))
-	fmul.x		%fp0,%fp2		# S(P1+S(P2+SP3))
-
-	fadd.x		TANQ1(%pc),%fp3		# Q1+S(Q2+S(Q3+SQ4))
-	fmul.x		%fp1,%fp2		# RS(P1+S(P2+SP3))
-
-	fmul.x		%fp3,%fp0		# S(Q1+S(Q2+S(Q3+SQ4)))
-
-	fadd.x		%fp2,%fp1		# R+RS(P1+S(P2+SP3))
-	fadd.s		&0x3F800000,%fp0	# 1+S(Q1+...)
-
-	fmovm.x		(%sp)+,&0x30		# restore fp2,fp3
-
-	fmov.x		%fp1,-(%sp)
-	eor.l		&0x80000000,(%sp)
-
-	fmov.l		%d0,%fpcr		# restore users round mode,prec
-	fdiv.x		(%sp)+,%fp0		# last inst - possible exception set
-	bra		t_inx2
-
-TANBORS:
-#--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
-#--IF |X| < 2**(-40), RETURN X OR 1.
-	cmp.l		%d1,&0x3FFF8000
-	bgt.b		REDUCEX
-
-TANSM:
-	fmov.x		%fp0,-(%sp)
-	fmov.l		%d0,%fpcr		# restore users round mode,prec
-	mov.b		&FMOV_OP,%d1		# last inst is MOVE
-	fmov.x		(%sp)+,%fp0		# last inst - posibble exception set
-	bra		t_catch
-
-	global		stand
-#--TAN(X) = X FOR DENORMALIZED X
-stand:
-	bra		t_extdnrm
-
-#--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW.
-#--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING
-#--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.
-REDUCEX:
-	fmovm.x		&0x3c,-(%sp)		# save {fp2-fp5}
-	mov.l		%d2,-(%sp)		# save d2
-	fmov.s		&0x00000000,%fp1	# fp1 = 0
-
-#--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that
-#--there is a danger of unwanted overflow in first LOOP iteration.  In this
-#--case, reduce argument by one remainder step to make subsequent reduction
-#--safe.
-	cmp.l		%d1,&0x7ffeffff		# is arg dangerously large?
-	bne.b		LOOP			# no
-
-# yes; create 2**16383*PI/2
-	mov.w		&0x7ffe,FP_SCR0_EX(%a6)
-	mov.l		&0xc90fdaa2,FP_SCR0_HI(%a6)
-	clr.l		FP_SCR0_LO(%a6)
-
-# create low half of 2**16383*PI/2 at FP_SCR1
-	mov.w		&0x7fdc,FP_SCR1_EX(%a6)
-	mov.l		&0x85a308d3,FP_SCR1_HI(%a6)
-	clr.l		FP_SCR1_LO(%a6)
-
-	ftest.x		%fp0			# test sign of argument
-	fblt.w		red_neg
-
-	or.b		&0x80,FP_SCR0_EX(%a6)	# positive arg
-	or.b		&0x80,FP_SCR1_EX(%a6)
-red_neg:
-	fadd.x		FP_SCR0(%a6),%fp0	# high part of reduction is exact
-	fmov.x		%fp0,%fp1		# save high result in fp1
-	fadd.x		FP_SCR1(%a6),%fp0	# low part of reduction
-	fsub.x		%fp0,%fp1		# determine low component of result
-	fadd.x		FP_SCR1(%a6),%fp1	# fp0/fp1 are reduced argument.
-
-#--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
-#--integer quotient will be stored in N
-#--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
-LOOP:
-	fmov.x		%fp0,INARG(%a6)		# +-2**K * F, 1 <= F < 2
-	mov.w		INARG(%a6),%d1
-	mov.l		%d1,%a1			# save a copy of D0
-	and.l		&0x00007FFF,%d1
-	sub.l		&0x00003FFF,%d1		# d0 = K
-	cmp.l		%d1,&28
-	ble.b		LASTLOOP
-CONTLOOP:
-	sub.l		&27,%d1			# d0 = L := K-27
-	mov.b		&0,ENDFLAG(%a6)
-	bra.b		WORK
-LASTLOOP:
-	clr.l		%d1			# d0 = L := 0
-	mov.b		&1,ENDFLAG(%a6)
-
-WORK:
-#--FIND THE REMAINDER OF (R,r) W.R.T.	2**L * (PI/2). L IS SO CHOSEN
-#--THAT	INT( X * (2/PI) / 2**(L) ) < 2**29.
-
-#--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63),
-#--2**L * (PIby2_1), 2**L * (PIby2_2)
-
-	mov.l		&0x00003FFE,%d2		# BIASED EXP OF 2/PI
-	sub.l		%d1,%d2			# BIASED EXP OF 2**(-L)*(2/PI)
-
-	mov.l		&0xA2F9836E,FP_SCR0_HI(%a6)
-	mov.l		&0x4E44152A,FP_SCR0_LO(%a6)
-	mov.w		%d2,FP_SCR0_EX(%a6)	# FP_SCR0 = 2**(-L)*(2/PI)
-
-	fmov.x		%fp0,%fp2
-	fmul.x		FP_SCR0(%a6),%fp2	# fp2 = X * 2**(-L)*(2/PI)
-
-#--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN
-#--FLOATING POINT FORMAT, THE TWO FMOVE'S	FMOVE.L FP <--> N
-#--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT
-#--(SIGN(INARG)*2**63	+	FP2) - SIGN(INARG)*2**63 WILL GIVE
-#--US THE DESIRED VALUE IN FLOATING POINT.
-	mov.l		%a1,%d2
-	swap		%d2
-	and.l		&0x80000000,%d2
-	or.l		&0x5F000000,%d2		# d2 = SIGN(INARG)*2**63 IN SGL
-	mov.l		%d2,TWOTO63(%a6)
-	fadd.s		TWOTO63(%a6),%fp2	# THE FRACTIONAL PART OF FP1 IS ROUNDED
-	fsub.s		TWOTO63(%a6),%fp2	# fp2 = N
-#	fintrz.x	%fp2,%fp2
-
-#--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2
-	mov.l		%d1,%d2			# d2 = L
-
-	add.l		&0x00003FFF,%d2		# BIASED EXP OF 2**L * (PI/2)
-	mov.w		%d2,FP_SCR0_EX(%a6)
-	mov.l		&0xC90FDAA2,FP_SCR0_HI(%a6)
-	clr.l		FP_SCR0_LO(%a6)		# FP_SCR0 = 2**(L) * Piby2_1
-
-	add.l		&0x00003FDD,%d1
-	mov.w		%d1,FP_SCR1_EX(%a6)
-	mov.l		&0x85A308D3,FP_SCR1_HI(%a6)
-	clr.l		FP_SCR1_LO(%a6)		# FP_SCR1 = 2**(L) * Piby2_2
-
-	mov.b		ENDFLAG(%a6),%d1
-
-#--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and
-#--P2 = 2**(L) * Piby2_2
-	fmov.x		%fp2,%fp4		# fp4 = N
-	fmul.x		FP_SCR0(%a6),%fp4	# fp4 = W = N*P1
-	fmov.x		%fp2,%fp5		# fp5 = N
-	fmul.x		FP_SCR1(%a6),%fp5	# fp5 = w = N*P2
-	fmov.x		%fp4,%fp3		# fp3 = W = N*P1
-
-#--we want P+p = W+w  but  |p| <= half ulp of P
-#--Then, we need to compute  A := R-P   and  a := r-p
-	fadd.x		%fp5,%fp3		# fp3 = P
-	fsub.x		%fp3,%fp4		# fp4 = W-P
-
-	fsub.x		%fp3,%fp0		# fp0 = A := R - P
-	fadd.x		%fp5,%fp4		# fp4 = p = (W-P)+w
-
-	fmov.x		%fp0,%fp3		# fp3 = A
-	fsub.x		%fp4,%fp1		# fp1 = a := r - p
-
-#--Now we need to normalize (A,a) to  "new (R,r)" where R+r = A+a but
-#--|r| <= half ulp of R.
-	fadd.x		%fp1,%fp0		# fp0 = R := A+a
-#--No need to calculate r if this is the last loop
-	cmp.b		%d1,&0
-	bgt.w		RESTORE
-
-#--Need to calculate r
-	fsub.x		%fp0,%fp3		# fp3 = A-R
-	fadd.x		%fp3,%fp1		# fp1 = r := (A-R)+a
-	bra.w		LOOP
-
-RESTORE:
-	fmov.l		%fp2,INT(%a6)
-	mov.l		(%sp)+,%d2		# restore d2
-	fmovm.x		(%sp)+,&0x3c		# restore {fp2-fp5}
-
-	mov.l		INT(%a6),%d1
-	ror.l		&1,%d1
-
-	bra.w		TANCONT
-
-#########################################################################
-# satan():  computes the arctangent of a normalized number		#
-# satand(): computes the arctangent of a denormalized number		#
-#									#
-# INPUT	*************************************************************** #
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT ************************************************************** #
-#	fp0 = arctan(X)							#
-#									#
-# ACCURACY and MONOTONICITY ******************************************* #
-#	The returned result is within 2 ulps in	64 significant bit,	#
-#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM *********************************************************** #
-#	Step 1. If |X| >= 16 or |X| < 1/16, go to Step 5.		#
-#									#
-#	Step 2. Let X = sgn * 2**k * 1.xxxxxxxx...x.			#
-#		Note that k = -4, -3,..., or 3.				#
-#		Define F = sgn * 2**k * 1.xxxx1, i.e. the first 5	#
-#		significant bits of X with a bit-1 attached at the 6-th	#
-#		bit position. Define u to be u = (X-F) / (1 + X*F).	#
-#									#
-#	Step 3. Approximate arctan(u) by a polynomial poly.		#
-#									#
-#	Step 4. Return arctan(F) + poly, arctan(F) is fetched from a	#
-#		table of values calculated beforehand. Exit.		#
-#									#
-#	Step 5. If |X| >= 16, go to Step 7.				#
-#									#
-#	Step 6. Approximate arctan(X) by an odd polynomial in X. Exit.	#
-#									#
-#	Step 7. Define X' = -1/X. Approximate arctan(X') by an odd	#
-#		polynomial in X'.					#
-#		Arctan(X) = sign(X)*Pi/2 + arctan(X'). Exit.		#
-#									#
-#########################################################################
-
-ATANA3:	long		0xBFF6687E,0x314987D8
-ATANA2:	long		0x4002AC69,0x34A26DB3
-ATANA1:	long		0xBFC2476F,0x4E1DA28E
-
-ATANB6:	long		0x3FB34444,0x7F876989
-ATANB5:	long		0xBFB744EE,0x7FAF45DB
-ATANB4:	long		0x3FBC71C6,0x46940220
-ATANB3:	long		0xBFC24924,0x921872F9
-ATANB2:	long		0x3FC99999,0x99998FA9
-ATANB1:	long		0xBFD55555,0x55555555
-
-ATANC5:	long		0xBFB70BF3,0x98539E6A
-ATANC4:	long		0x3FBC7187,0x962D1D7D
-ATANC3:	long		0xBFC24924,0x827107B8
-ATANC2:	long		0x3FC99999,0x9996263E
-ATANC1:	long		0xBFD55555,0x55555536
-
-PPIBY2:	long		0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000
-NPIBY2:	long		0xBFFF0000,0xC90FDAA2,0x2168C235,0x00000000
-
-PTINY:	long		0x00010000,0x80000000,0x00000000,0x00000000
-NTINY:	long		0x80010000,0x80000000,0x00000000,0x00000000
-
-ATANTBL:
-	long		0x3FFB0000,0x83D152C5,0x060B7A51,0x00000000
-	long		0x3FFB0000,0x8BC85445,0x65498B8B,0x00000000
-	long		0x3FFB0000,0x93BE4060,0x17626B0D,0x00000000
-	long		0x3FFB0000,0x9BB3078D,0x35AEC202,0x00000000
-	long		0x3FFB0000,0xA3A69A52,0x5DDCE7DE,0x00000000
-	long		0x3FFB0000,0xAB98E943,0x62765619,0x00000000
-	long		0x3FFB0000,0xB389E502,0xF9C59862,0x00000000
-	long		0x3FFB0000,0xBB797E43,0x6B09E6FB,0x00000000
-	long		0x3FFB0000,0xC367A5C7,0x39E5F446,0x00000000
-	long		0x3FFB0000,0xCB544C61,0xCFF7D5C6,0x00000000
-	long		0x3FFB0000,0xD33F62F8,0x2488533E,0x00000000
-	long		0x3FFB0000,0xDB28DA81,0x62404C77,0x00000000
-	long		0x3FFB0000,0xE310A407,0x8AD34F18,0x00000000
-	long		0x3FFB0000,0xEAF6B0A8,0x188EE1EB,0x00000000
-	long		0x3FFB0000,0xF2DAF194,0x9DBE79D5,0x00000000
-	long		0x3FFB0000,0xFABD5813,0x61D47E3E,0x00000000
-	long		0x3FFC0000,0x8346AC21,0x0959ECC4,0x00000000
-	long		0x3FFC0000,0x8B232A08,0x304282D8,0x00000000
-	long		0x3FFC0000,0x92FB70B8,0xD29AE2F9,0x00000000
-	long		0x3FFC0000,0x9ACF476F,0x5CCD1CB4,0x00000000
-	long		0x3FFC0000,0xA29E7630,0x4954F23F,0x00000000
-	long		0x3FFC0000,0xAA68C5D0,0x8AB85230,0x00000000
-	long		0x3FFC0000,0xB22DFFFD,0x9D539F83,0x00000000
-	long		0x3FFC0000,0xB9EDEF45,0x3E900EA5,0x00000000
-	long		0x3FFC0000,0xC1A85F1C,0xC75E3EA5,0x00000000
-	long		0x3FFC0000,0xC95D1BE8,0x28138DE6,0x00000000
-	long		0x3FFC0000,0xD10BF300,0x840D2DE4,0x00000000
-	long		0x3FFC0000,0xD8B4B2BA,0x6BC05E7A,0x00000000
-	long		0x3FFC0000,0xE0572A6B,0xB42335F6,0x00000000
-	long		0x3FFC0000,0xE7F32A70,0xEA9CAA8F,0x00000000
-	long		0x3FFC0000,0xEF888432,0x64ECEFAA,0x00000000
-	long		0x3FFC0000,0xF7170A28,0xECC06666,0x00000000
-	long		0x3FFD0000,0x812FD288,0x332DAD32,0x00000000
-	long		0x3FFD0000,0x88A8D1B1,0x218E4D64,0x00000000
-	long		0x3FFD0000,0x9012AB3F,0x23E4AEE8,0x00000000
-	long		0x3FFD0000,0x976CC3D4,0x11E7F1B9,0x00000000
-	long		0x3FFD0000,0x9EB68949,0x3889A227,0x00000000
-	long		0x3FFD0000,0xA5EF72C3,0x4487361B,0x00000000
-	long		0x3FFD0000,0xAD1700BA,0xF07A7227,0x00000000
-	long		0x3FFD0000,0xB42CBCFA,0xFD37EFB7,0x00000000
-	long		0x3FFD0000,0xBB303A94,0x0BA80F89,0x00000000
-	long		0x3FFD0000,0xC22115C6,0xFCAEBBAF,0x00000000
-	long		0x3FFD0000,0xC8FEF3E6,0x86331221,0x00000000
-	long		0x3FFD0000,0xCFC98330,0xB4000C70,0x00000000
-	long		0x3FFD0000,0xD6807AA1,0x102C5BF9,0x00000000
-	long		0x3FFD0000,0xDD2399BC,0x31252AA3,0x00000000
-	long		0x3FFD0000,0xE3B2A855,0x6B8FC517,0x00000000
-	long		0x3FFD0000,0xEA2D764F,0x64315989,0x00000000
-	long		0x3FFD0000,0xF3BF5BF8,0xBAD1A21D,0x00000000
-	long		0x3FFE0000,0x801CE39E,0x0D205C9A,0x00000000
-	long		0x3FFE0000,0x8630A2DA,0xDA1ED066,0x00000000
-	long		0x3FFE0000,0x8C1AD445,0xF3E09B8C,0x00000000
-	long		0x3FFE0000,0x91DB8F16,0x64F350E2,0x00000000
-	long		0x3FFE0000,0x97731420,0x365E538C,0x00000000
-	long		0x3FFE0000,0x9CE1C8E6,0xA0B8CDBA,0x00000000
-	long		0x3FFE0000,0xA22832DB,0xCADAAE09,0x00000000
-	long		0x3FFE0000,0xA746F2DD,0xB7602294,0x00000000
-	long		0x3FFE0000,0xAC3EC0FB,0x997DD6A2,0x00000000
-	long		0x3FFE0000,0xB110688A,0xEBDC6F6A,0x00000000
-	long		0x3FFE0000,0xB5BCC490,0x59ECC4B0,0x00000000
-	long		0x3FFE0000,0xBA44BC7D,0xD470782F,0x00000000
-	long		0x3FFE0000,0xBEA94144,0xFD049AAC,0x00000000
-	long		0x3FFE0000,0xC2EB4ABB,0x661628B6,0x00000000
-	long		0x3FFE0000,0xC70BD54C,0xE602EE14,0x00000000
-	long		0x3FFE0000,0xCD000549,0xADEC7159,0x00000000
-	long		0x3FFE0000,0xD48457D2,0xD8EA4EA3,0x00000000
-	long		0x3FFE0000,0xDB948DA7,0x12DECE3B,0x00000000
-	long		0x3FFE0000,0xE23855F9,0x69E8096A,0x00000000
-	long		0x3FFE0000,0xE8771129,0xC4353259,0x00000000
-	long		0x3FFE0000,0xEE57C16E,0x0D379C0D,0x00000000
-	long		0x3FFE0000,0xF3E10211,0xA87C3779,0x00000000
-	long		0x3FFE0000,0xF919039D,0x758B8D41,0x00000000
-	long		0x3FFE0000,0xFE058B8F,0x64935FB3,0x00000000
-	long		0x3FFF0000,0x8155FB49,0x7B685D04,0x00000000
-	long		0x3FFF0000,0x83889E35,0x49D108E1,0x00000000
-	long		0x3FFF0000,0x859CFA76,0x511D724B,0x00000000
-	long		0x3FFF0000,0x87952ECF,0xFF8131E7,0x00000000
-	long		0x3FFF0000,0x89732FD1,0x9557641B,0x00000000
-	long		0x3FFF0000,0x8B38CAD1,0x01932A35,0x00000000
-	long		0x3FFF0000,0x8CE7A8D8,0x301EE6B5,0x00000000
-	long		0x3FFF0000,0x8F46A39E,0x2EAE5281,0x00000000
-	long		0x3FFF0000,0x922DA7D7,0x91888487,0x00000000
-	long		0x3FFF0000,0x94D19FCB,0xDEDF5241,0x00000000
-	long		0x3FFF0000,0x973AB944,0x19D2A08B,0x00000000
-	long		0x3FFF0000,0x996FF00E,0x08E10B96,0x00000000
-	long		0x3FFF0000,0x9B773F95,0x12321DA7,0x00000000
-	long		0x3FFF0000,0x9D55CC32,0x0F935624,0x00000000
-	long		0x3FFF0000,0x9F100575,0x006CC571,0x00000000
-	long		0x3FFF0000,0xA0A9C290,0xD97CC06C,0x00000000
-	long		0x3FFF0000,0xA22659EB,0xEBC0630A,0x00000000
-	long		0x3FFF0000,0xA388B4AF,0xF6EF0EC9,0x00000000
-	long		0x3FFF0000,0xA4D35F10,0x61D292C4,0x00000000
-	long		0x3FFF0000,0xA60895DC,0xFBE3187E,0x00000000
-	long		0x3FFF0000,0xA72A51DC,0x7367BEAC,0x00000000
-	long		0x3FFF0000,0xA83A5153,0x0956168F,0x00000000
-	long		0x3FFF0000,0xA93A2007,0x7539546E,0x00000000
-	long		0x3FFF0000,0xAA9E7245,0x023B2605,0x00000000
-	long		0x3FFF0000,0xAC4C84BA,0x6FE4D58F,0x00000000
-	long		0x3FFF0000,0xADCE4A4A,0x606B9712,0x00000000
-	long		0x3FFF0000,0xAF2A2DCD,0x8D263C9C,0x00000000
-	long		0x3FFF0000,0xB0656F81,0xF22265C7,0x00000000
-	long		0x3FFF0000,0xB1846515,0x0F71496A,0x00000000
-	long		0x3FFF0000,0xB28AAA15,0x6F9ADA35,0x00000000
-	long		0x3FFF0000,0xB37B44FF,0x3766B895,0x00000000
-	long		0x3FFF0000,0xB458C3DC,0xE9630433,0x00000000
-	long		0x3FFF0000,0xB525529D,0x562246BD,0x00000000
-	long		0x3FFF0000,0xB5E2CCA9,0x5F9D88CC,0x00000000
-	long		0x3FFF0000,0xB692CADA,0x7ACA1ADA,0x00000000
-	long		0x3FFF0000,0xB736AEA7,0xA6925838,0x00000000
-	long		0x3FFF0000,0xB7CFAB28,0x7E9F7B36,0x00000000
-	long		0x3FFF0000,0xB85ECC66,0xCB219835,0x00000000
-	long		0x3FFF0000,0xB8E4FD5A,0x20A593DA,0x00000000
-	long		0x3FFF0000,0xB99F41F6,0x4AFF9BB5,0x00000000
-	long		0x3FFF0000,0xBA7F1E17,0x842BBE7B,0x00000000
-	long		0x3FFF0000,0xBB471285,0x7637E17D,0x00000000
-	long		0x3FFF0000,0xBBFABE8A,0x4788DF6F,0x00000000
-	long		0x3FFF0000,0xBC9D0FAD,0x2B689D79,0x00000000
-	long		0x3FFF0000,0xBD306A39,0x471ECD86,0x00000000
-	long		0x3FFF0000,0xBDB6C731,0x856AF18A,0x00000000
-	long		0x3FFF0000,0xBE31CAC5,0x02E80D70,0x00000000
-	long		0x3FFF0000,0xBEA2D55C,0xE33194E2,0x00000000
-	long		0x3FFF0000,0xBF0B10B7,0xC03128F0,0x00000000
-	long		0x3FFF0000,0xBF6B7A18,0xDACB778D,0x00000000
-	long		0x3FFF0000,0xBFC4EA46,0x63FA18F6,0x00000000
-	long		0x3FFF0000,0xC0181BDE,0x8B89A454,0x00000000
-	long		0x3FFF0000,0xC065B066,0xCFBF6439,0x00000000
-	long		0x3FFF0000,0xC0AE345F,0x56340AE6,0x00000000
-	long		0x3FFF0000,0xC0F22291,0x9CB9E6A7,0x00000000
-
-	set		X,FP_SCR0
-	set		XDCARE,X+2
-	set		XFRAC,X+4
-	set		XFRACLO,X+8
-
-	set		ATANF,FP_SCR1
-	set		ATANFHI,ATANF+4
-	set		ATANFLO,ATANF+8
-
-	global		satan
-#--ENTRY POINT FOR ATAN(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
-satan:
-	fmov.x		(%a0),%fp0		# LOAD INPUT
-
-	mov.l		(%a0),%d1
-	mov.w		4(%a0),%d1
-	fmov.x		%fp0,X(%a6)
-	and.l		&0x7FFFFFFF,%d1
-
-	cmp.l		%d1,&0x3FFB8000		# |X| >= 1/16?
-	bge.b		ATANOK1
-	bra.w		ATANSM
-
-ATANOK1:
-	cmp.l		%d1,&0x4002FFFF		# |X| < 16 ?
-	ble.b		ATANMAIN
-	bra.w		ATANBIG
-
-#--THE MOST LIKELY CASE, |X| IN [1/16, 16). WE USE TABLE TECHNIQUE
-#--THE IDEA IS ATAN(X) = ATAN(F) + ATAN( [X-F] / [1+XF] ).
-#--SO IF F IS CHOSEN TO BE CLOSE TO X AND ATAN(F) IS STORED IN
-#--A TABLE, ALL WE NEED IS TO APPROXIMATE ATAN(U) WHERE
-#--U = (X-F)/(1+XF) IS SMALL (REMEMBER F IS CLOSE TO X). IT IS
-#--TRUE THAT A DIVIDE IS NOW NEEDED, BUT THE APPROXIMATION FOR
-#--ATAN(U) IS A VERY SHORT POLYNOMIAL AND THE INDEXING TO
-#--FETCH F AND SAVING OF REGISTERS CAN BE ALL HIDED UNDER THE
-#--DIVIDE. IN THE END THIS METHOD IS MUCH FASTER THAN A TRADITIONAL
-#--ONE. NOTE ALSO THAT THE TRADITIONAL SCHEME THAT APPROXIMATE
-#--ATAN(X) DIRECTLY WILL NEED TO USE A RATIONAL APPROXIMATION
-#--(DIVISION NEEDED) ANYWAY BECAUSE A POLYNOMIAL APPROXIMATION
-#--WILL INVOLVE A VERY LONG POLYNOMIAL.
-
-#--NOW WE SEE X AS +-2^K * 1.BBBBBBB....B <- 1. + 63 BITS
-#--WE CHOSE F TO BE +-2^K * 1.BBBB1
-#--THAT IS IT MATCHES THE EXPONENT AND FIRST 5 BITS OF X, THE
-#--SIXTH BITS IS SET TO BE 1. SINCE K = -4, -3, ..., 3, THERE
-#--ARE ONLY 8 TIMES 16 = 2^7 = 128 |F|'S. SINCE ATAN(-|F|) IS
-#-- -ATAN(|F|), WE NEED TO STORE ONLY ATAN(|F|).
-
-ATANMAIN:
-
-	and.l		&0xF8000000,XFRAC(%a6)	# FIRST 5 BITS
-	or.l		&0x04000000,XFRAC(%a6)	# SET 6-TH BIT TO 1
-	mov.l		&0x00000000,XFRACLO(%a6) # LOCATION OF X IS NOW F
-
-	fmov.x		%fp0,%fp1		# FP1 IS X
-	fmul.x		X(%a6),%fp1		# FP1 IS X*F, NOTE THAT X*F > 0
-	fsub.x		X(%a6),%fp0		# FP0 IS X-F
-	fadd.s		&0x3F800000,%fp1	# FP1 IS 1 + X*F
-	fdiv.x		%fp1,%fp0		# FP0 IS U = (X-F)/(1+X*F)
-
-#--WHILE THE DIVISION IS TAKING ITS TIME, WE FETCH ATAN(|F|)
-#--CREATE ATAN(F) AND STORE IT IN ATANF, AND
-#--SAVE REGISTERS FP2.
-
-	mov.l		%d2,-(%sp)		# SAVE d2 TEMPORARILY
-	mov.l		%d1,%d2			# THE EXP AND 16 BITS OF X
-	and.l		&0x00007800,%d1		# 4 VARYING BITS OF F'S FRACTION
-	and.l		&0x7FFF0000,%d2		# EXPONENT OF F
-	sub.l		&0x3FFB0000,%d2		# K+4
-	asr.l		&1,%d2
-	add.l		%d2,%d1			# THE 7 BITS IDENTIFYING F
-	asr.l		&7,%d1			# INDEX INTO TBL OF ATAN(|F|)
-	lea		ATANTBL(%pc),%a1
-	add.l		%d1,%a1			# ADDRESS OF ATAN(|F|)
-	mov.l		(%a1)+,ATANF(%a6)
-	mov.l		(%a1)+,ATANFHI(%a6)
-	mov.l		(%a1)+,ATANFLO(%a6)	# ATANF IS NOW ATAN(|F|)
-	mov.l		X(%a6),%d1		# LOAD SIGN AND EXPO. AGAIN
-	and.l		&0x80000000,%d1		# SIGN(F)
-	or.l		%d1,ATANF(%a6)		# ATANF IS NOW SIGN(F)*ATAN(|F|)
-	mov.l		(%sp)+,%d2		# RESTORE d2
-
-#--THAT'S ALL I HAVE TO DO FOR NOW,
-#--BUT ALAS, THE DIVIDE IS STILL CRANKING!
-
-#--U IN FP0, WE ARE NOW READY TO COMPUTE ATAN(U) AS
-#--U + A1*U*V*(A2 + V*(A3 + V)), V = U*U
-#--THE POLYNOMIAL MAY LOOK STRANGE, BUT IS NEVERTHELESS CORRECT.
-#--THE NATURAL FORM IS U + U*V*(A1 + V*(A2 + V*A3))
-#--WHAT WE HAVE HERE IS MERELY	A1 = A3, A2 = A1/A3, A3 = A2/A3.
-#--THE REASON FOR THIS REARRANGEMENT IS TO MAKE THE INDEPENDENT
-#--PARTS A1*U*V AND (A2 + ... STUFF) MORE LOAD-BALANCED
-
-	fmovm.x		&0x04,-(%sp)		# save fp2
-
-	fmov.x		%fp0,%fp1
-	fmul.x		%fp1,%fp1
-	fmov.d		ATANA3(%pc),%fp2
-	fadd.x		%fp1,%fp2		# A3+V
-	fmul.x		%fp1,%fp2		# V*(A3+V)
-	fmul.x		%fp0,%fp1		# U*V
-	fadd.d		ATANA2(%pc),%fp2	# A2+V*(A3+V)
-	fmul.d		ATANA1(%pc),%fp1	# A1*U*V
-	fmul.x		%fp2,%fp1		# A1*U*V*(A2+V*(A3+V))
-	fadd.x		%fp1,%fp0		# ATAN(U), FP1 RELEASED
-
-	fmovm.x		(%sp)+,&0x20		# restore fp2
-
-	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
-	fadd.x		ATANF(%a6),%fp0		# ATAN(X)
-	bra		t_inx2
-
-ATANBORS:
-#--|X| IS IN d0 IN COMPACT FORM. FP1, d0 SAVED.
-#--FP0 IS X AND |X| <= 1/16 OR |X| >= 16.
-	cmp.l		%d1,&0x3FFF8000
-	bgt.w		ATANBIG			# I.E. |X| >= 16
-
-ATANSM:
-#--|X| <= 1/16
-#--IF |X| < 2^(-40), RETURN X AS ANSWER. OTHERWISE, APPROXIMATE
-#--ATAN(X) BY X + X*Y*(B1+Y*(B2+Y*(B3+Y*(B4+Y*(B5+Y*B6)))))
-#--WHICH IS X + X*Y*( [B1+Z*(B3+Z*B5)] + [Y*(B2+Z*(B4+Z*B6)] )
-#--WHERE Y = X*X, AND Z = Y*Y.
-
-	cmp.l		%d1,&0x3FD78000
-	blt.w		ATANTINY
-
-#--COMPUTE POLYNOMIAL
-	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
-
-	fmul.x		%fp0,%fp0		# FPO IS Y = X*X
-
-	fmov.x		%fp0,%fp1
-	fmul.x		%fp1,%fp1		# FP1 IS Z = Y*Y
-
-	fmov.d		ATANB6(%pc),%fp2
-	fmov.d		ATANB5(%pc),%fp3
-
-	fmul.x		%fp1,%fp2		# Z*B6
-	fmul.x		%fp1,%fp3		# Z*B5
-
-	fadd.d		ATANB4(%pc),%fp2	# B4+Z*B6
-	fadd.d		ATANB3(%pc),%fp3	# B3+Z*B5
-
-	fmul.x		%fp1,%fp2		# Z*(B4+Z*B6)
-	fmul.x		%fp3,%fp1		# Z*(B3+Z*B5)
-
-	fadd.d		ATANB2(%pc),%fp2	# B2+Z*(B4+Z*B6)
-	fadd.d		ATANB1(%pc),%fp1	# B1+Z*(B3+Z*B5)
-
-	fmul.x		%fp0,%fp2		# Y*(B2+Z*(B4+Z*B6))
-	fmul.x		X(%a6),%fp0		# X*Y
-
-	fadd.x		%fp2,%fp1		# [B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]
-
-	fmul.x		%fp1,%fp0		# X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))])
-
-	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
-
-	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
-	fadd.x		X(%a6),%fp0
-	bra		t_inx2
-
-ATANTINY:
-#--|X| < 2^(-40), ATAN(X) = X
-
-	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
-	mov.b		&FMOV_OP,%d1		# last inst is MOVE
-	fmov.x		X(%a6),%fp0		# last inst - possible exception set
-
-	bra		t_catch
-
-ATANBIG:
-#--IF |X| > 2^(100), RETURN	SIGN(X)*(PI/2 - TINY). OTHERWISE,
-#--RETURN SIGN(X)*PI/2 + ATAN(-1/X).
-	cmp.l		%d1,&0x40638000
-	bgt.w		ATANHUGE
-
-#--APPROXIMATE ATAN(-1/X) BY
-#--X'+X'*Y*(C1+Y*(C2+Y*(C3+Y*(C4+Y*C5)))), X' = -1/X, Y = X'*X'
-#--THIS CAN BE RE-WRITTEN AS
-#--X'+X'*Y*( [C1+Z*(C3+Z*C5)] + [Y*(C2+Z*C4)] ), Z = Y*Y.
-
-	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
-
-	fmov.s		&0xBF800000,%fp1	# LOAD -1
-	fdiv.x		%fp0,%fp1		# FP1 IS -1/X
-
-#--DIVIDE IS STILL CRANKING
-
-	fmov.x		%fp1,%fp0		# FP0 IS X'
-	fmul.x		%fp0,%fp0		# FP0 IS Y = X'*X'
-	fmov.x		%fp1,X(%a6)		# X IS REALLY X'
-
-	fmov.x		%fp0,%fp1
-	fmul.x		%fp1,%fp1		# FP1 IS Z = Y*Y
-
-	fmov.d		ATANC5(%pc),%fp3
-	fmov.d		ATANC4(%pc),%fp2
-
-	fmul.x		%fp1,%fp3		# Z*C5
-	fmul.x		%fp1,%fp2		# Z*B4
-
-	fadd.d		ATANC3(%pc),%fp3	# C3+Z*C5
-	fadd.d		ATANC2(%pc),%fp2	# C2+Z*C4
-
-	fmul.x		%fp3,%fp1		# Z*(C3+Z*C5), FP3 RELEASED
-	fmul.x		%fp0,%fp2		# Y*(C2+Z*C4)
-
-	fadd.d		ATANC1(%pc),%fp1	# C1+Z*(C3+Z*C5)
-	fmul.x		X(%a6),%fp0		# X'*Y
-
-	fadd.x		%fp2,%fp1		# [Y*(C2+Z*C4)]+[C1+Z*(C3+Z*C5)]
-
-	fmul.x		%fp1,%fp0		# X'*Y*([B1+Z*(B3+Z*B5)]
-#					...	+[Y*(B2+Z*(B4+Z*B6))])
-	fadd.x		X(%a6),%fp0
-
-	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
-
-	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
-	tst.b		(%a0)
-	bpl.b		pos_big
-
-neg_big:
-	fadd.x		NPIBY2(%pc),%fp0
-	bra		t_minx2
-
-pos_big:
-	fadd.x		PPIBY2(%pc),%fp0
-	bra		t_pinx2
-
-ATANHUGE:
-#--RETURN SIGN(X)*(PIBY2 - TINY) = SIGN(X)*PIBY2 - SIGN(X)*TINY
-	tst.b		(%a0)
-	bpl.b		pos_huge
-
-neg_huge:
-	fmov.x		NPIBY2(%pc),%fp0
-	fmov.l		%d0,%fpcr
-	fadd.x		PTINY(%pc),%fp0
-	bra		t_minx2
-
-pos_huge:
-	fmov.x		PPIBY2(%pc),%fp0
-	fmov.l		%d0,%fpcr
-	fadd.x		NTINY(%pc),%fp0
-	bra		t_pinx2
-
-	global		satand
-#--ENTRY POINT FOR ATAN(X) FOR DENORMALIZED ARGUMENT
-satand:
-	bra		t_extdnrm
-
-#########################################################################
-# sasin():  computes the inverse sine of a normalized input		#
-# sasind(): computes the inverse sine of a denormalized input		#
-#									#
-# INPUT ***************************************************************	#
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = arcsin(X)							#
-#									#
-# ACCURACY and MONOTONICITY *******************************************	#
-#	The returned result is within 3 ulps in	64 significant bit,	#
-#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM ***********************************************************	#
-#									#
-#	ASIN								#
-#	1. If |X| >= 1, go to 3.					#
-#									#
-#	2. (|X| < 1) Calculate asin(X) by				#
-#		z := sqrt( [1-X][1+X] )					#
-#		asin(X) = atan( x / z ).				#
-#		Exit.							#
-#									#
-#	3. If |X| > 1, go to 5.						#
-#									#
-#	4. (|X| = 1) sgn := sign(X), return asin(X) := sgn * Pi/2. Exit.#
-#									#
-#	5. (|X| > 1) Generate an invalid operation by 0 * infinity.	#
-#		Exit.							#
-#									#
-#########################################################################
-
-	global		sasin
-sasin:
-	fmov.x		(%a0),%fp0		# LOAD INPUT
-
-	mov.l		(%a0),%d1
-	mov.w		4(%a0),%d1
-	and.l		&0x7FFFFFFF,%d1
-	cmp.l		%d1,&0x3FFF8000
-	bge.b		ASINBIG
-
-# This catch is added here for the '060 QSP. Originally, the call to
-# satan() would handle this case by causing the exception which would
-# not be caught until gen_except(). Now, with the exceptions being
-# detected inside of satan(), the exception would have been handled there
-# instead of inside sasin() as expected.
-	cmp.l		%d1,&0x3FD78000
-	blt.w		ASINTINY
-
-#--THIS IS THE USUAL CASE, |X| < 1
-#--ASIN(X) = ATAN( X / SQRT( (1-X)(1+X) ) )
-
-ASINMAIN:
-	fmov.s		&0x3F800000,%fp1
-	fsub.x		%fp0,%fp1		# 1-X
-	fmovm.x		&0x4,-(%sp)		#  {fp2}
-	fmov.s		&0x3F800000,%fp2
-	fadd.x		%fp0,%fp2		# 1+X
-	fmul.x		%fp2,%fp1		# (1+X)(1-X)
-	fmovm.x		(%sp)+,&0x20		#  {fp2}
-	fsqrt.x		%fp1			# SQRT([1-X][1+X])
-	fdiv.x		%fp1,%fp0		# X/SQRT([1-X][1+X])
-	fmovm.x		&0x01,-(%sp)		# save X/SQRT(...)
-	lea		(%sp),%a0		# pass ptr to X/SQRT(...)
-	bsr		satan
-	add.l		&0xc,%sp		# clear X/SQRT(...) from stack
-	bra		t_inx2
-
-ASINBIG:
-	fabs.x		%fp0			# |X|
-	fcmp.s		%fp0,&0x3F800000
-	fbgt		t_operr			# cause an operr exception
-
-#--|X| = 1, ASIN(X) = +- PI/2.
-ASINONE:
-	fmov.x		PIBY2(%pc),%fp0
-	mov.l		(%a0),%d1
-	and.l		&0x80000000,%d1		# SIGN BIT OF X
-	or.l		&0x3F800000,%d1		# +-1 IN SGL FORMAT
-	mov.l		%d1,-(%sp)		# push SIGN(X) IN SGL-FMT
-	fmov.l		%d0,%fpcr
-	fmul.s		(%sp)+,%fp0
-	bra		t_inx2
-
-#--|X| < 2^(-40), ATAN(X) = X
-ASINTINY:
-	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
-	mov.b		&FMOV_OP,%d1		# last inst is MOVE
-	fmov.x		(%a0),%fp0		# last inst - possible exception
-	bra		t_catch
-
-	global		sasind
-#--ASIN(X) = X FOR DENORMALIZED X
-sasind:
-	bra		t_extdnrm
-
-#########################################################################
-# sacos():  computes the inverse cosine of a normalized input		#
-# sacosd(): computes the inverse cosine of a denormalized input		#
-#									#
-# INPUT ***************************************************************	#
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT ************************************************************** #
-#	fp0 = arccos(X)							#
-#									#
-# ACCURACY and MONOTONICITY *******************************************	#
-#	The returned result is within 3 ulps in	64 significant bit,	#
-#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM *********************************************************** #
-#									#
-#	ACOS								#
-#	1. If |X| >= 1, go to 3.					#
-#									#
-#	2. (|X| < 1) Calculate acos(X) by				#
-#		z := (1-X) / (1+X)					#
-#		acos(X) = 2 * atan( sqrt(z) ).				#
-#		Exit.							#
-#									#
-#	3. If |X| > 1, go to 5.						#
-#									#
-#	4. (|X| = 1) If X > 0, return 0. Otherwise, return Pi. Exit.	#
-#									#
-#	5. (|X| > 1) Generate an invalid operation by 0 * infinity.	#
-#		Exit.							#
-#									#
-#########################################################################
-
-	global		sacos
-sacos:
-	fmov.x		(%a0),%fp0		# LOAD INPUT
-
-	mov.l		(%a0),%d1		# pack exp w/ upper 16 fraction
-	mov.w		4(%a0),%d1
-	and.l		&0x7FFFFFFF,%d1
-	cmp.l		%d1,&0x3FFF8000
-	bge.b		ACOSBIG
-
-#--THIS IS THE USUAL CASE, |X| < 1
-#--ACOS(X) = 2 * ATAN(	SQRT( (1-X)/(1+X) ) )
-
-ACOSMAIN:
-	fmov.s		&0x3F800000,%fp1
-	fadd.x		%fp0,%fp1		# 1+X
-	fneg.x		%fp0			# -X
-	fadd.s		&0x3F800000,%fp0	# 1-X
-	fdiv.x		%fp1,%fp0		# (1-X)/(1+X)
-	fsqrt.x		%fp0			# SQRT((1-X)/(1+X))
-	mov.l		%d0,-(%sp)		# save original users fpcr
-	clr.l		%d0
-	fmovm.x		&0x01,-(%sp)		# save SQRT(...) to stack
-	lea		(%sp),%a0		# pass ptr to sqrt
-	bsr		satan			# ATAN(SQRT([1-X]/[1+X]))
-	add.l		&0xc,%sp		# clear SQRT(...) from stack
-
-	fmov.l		(%sp)+,%fpcr		# restore users round prec,mode
-	fadd.x		%fp0,%fp0		# 2 * ATAN( STUFF )
-	bra		t_pinx2
-
-ACOSBIG:
-	fabs.x		%fp0
-	fcmp.s		%fp0,&0x3F800000
-	fbgt		t_operr			# cause an operr exception
-
-#--|X| = 1, ACOS(X) = 0 OR PI
-	tst.b		(%a0)			# is X positive or negative?
-	bpl.b		ACOSP1
-
-#--X = -1
-#Returns PI and inexact exception
-ACOSM1:
-	fmov.x		PI(%pc),%fp0		# load PI
-	fmov.l		%d0,%fpcr		# load round mode,prec
-	fadd.s		&0x00800000,%fp0	# add a small value
-	bra		t_pinx2
-
-ACOSP1:
-	bra		ld_pzero		# answer is positive zero
-
-	global		sacosd
-#--ACOS(X) = PI/2 FOR DENORMALIZED X
-sacosd:
-	fmov.l		%d0,%fpcr		# load user's rnd mode/prec
-	fmov.x		PIBY2(%pc),%fp0
-	bra		t_pinx2
-
-#########################################################################
-# setox():    computes the exponential for a normalized input		#
-# setoxd():   computes the exponential for a denormalized input		#
-# setoxm1():  computes the exponential minus 1 for a normalized input	#
-# setoxm1d(): computes the exponential minus 1 for a denormalized input	#
-#									#
-# INPUT	*************************************************************** #
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT ************************************************************** #
-#	fp0 = exp(X) or exp(X)-1					#
-#									#
-# ACCURACY and MONOTONICITY ******************************************* #
-#	The returned result is within 0.85 ulps in 64 significant bit,	#
-#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM and IMPLEMENTATION **************************************** #
-#									#
-#	setoxd								#
-#	------								#
-#	Step 1.	Set ans := 1.0						#
-#									#
-#	Step 2.	Return	ans := ans + sign(X)*2^(-126). Exit.		#
-#	Notes:	This will always generate one exception -- inexact.	#
-#									#
-#									#
-#	setox								#
-#	-----								#
-#									#
-#	Step 1.	Filter out extreme cases of input argument.		#
-#		1.1	If |X| >= 2^(-65), go to Step 1.3.		#
-#		1.2	Go to Step 7.					#
-#		1.3	If |X| < 16380 log(2), go to Step 2.		#
-#		1.4	Go to Step 8.					#
-#	Notes:	The usual case should take the branches 1.1 -> 1.3 -> 2.#
-#		To avoid the use of floating-point comparisons, a	#
-#		compact representation of |X| is used. This format is a	#
-#		32-bit integer, the upper (more significant) 16 bits	#
-#		are the sign and biased exponent field of |X|; the	#
-#		lower 16 bits are the 16 most significant fraction	#
-#		(including the explicit bit) bits of |X|. Consequently,	#
-#		the comparisons in Steps 1.1 and 1.3 can be performed	#
-#		by integer comparison. Note also that the constant	#
-#		16380 log(2) used in Step 1.3 is also in the compact	#
-#		form. Thus taking the branch to Step 2 guarantees	#
-#		|X| < 16380 log(2). There is no harm to have a small	#
-#		number of cases where |X| is less than,	but close to,	#
-#		16380 log(2) and the branch to Step 9 is taken.		#
-#									#
-#	Step 2.	Calculate N = round-to-nearest-int( X * 64/log2 ).	#
-#		2.1	Set AdjFlag := 0 (indicates the branch 1.3 -> 2 #
-#			was taken)					#
-#		2.2	N := round-to-nearest-integer( X * 64/log2 ).	#
-#		2.3	Calculate	J = N mod 64; so J = 0,1,2,..., #
-#			or 63.						#
-#		2.4	Calculate	M = (N - J)/64; so N = 64M + J.	#
-#		2.5	Calculate the address of the stored value of	#
-#			2^(J/64).					#
-#		2.6	Create the value Scale = 2^M.			#
-#	Notes:	The calculation in 2.2 is really performed by		#
-#			Z := X * constant				#
-#			N := round-to-nearest-integer(Z)		#
-#		where							#
-#			constant := single-precision( 64/log 2 ).	#
-#									#
-#		Using a single-precision constant avoids memory		#
-#		access. Another effect of using a single-precision	#
-#		"constant" is that the calculated value Z is		#
-#									#
-#			Z = X*(64/log2)*(1+eps), |eps| <= 2^(-24).	#
-#									#
-#		This error has to be considered later in Steps 3 and 4.	#
-#									#
-#	Step 3.	Calculate X - N*log2/64.				#
-#		3.1	R := X + N*L1,					#
-#				where L1 := single-precision(-log2/64).	#
-#		3.2	R := R + N*L2,					#
-#				L2 := extended-precision(-log2/64 - L1).#
-#	Notes:	a) The way L1 and L2 are chosen ensures L1+L2		#
-#		approximate the value -log2/64 to 88 bits of accuracy.	#
-#		b) N*L1 is exact because N is no longer than 22 bits	#
-#		and L1 is no longer than 24 bits.			#
-#		c) The calculation X+N*L1 is also exact due to		#
-#		cancellation. Thus, R is practically X+N(L1+L2) to full	#
-#		64 bits.						#
-#		d) It is important to estimate how large can |R| be	#
-#		after Step 3.2.						#
-#									#
-#		N = rnd-to-int( X*64/log2 (1+eps) ), |eps|<=2^(-24)	#
-#		X*64/log2 (1+eps)	=	N + f,	|f| <= 0.5	#
-#		X*64/log2 - N	=	f - eps*X 64/log2		#
-#		X - N*log2/64	=	f*log2/64 - eps*X		#
-#									#
-#									#
-#		Now |X| <= 16446 log2, thus				#
-#									#
-#			|X - N*log2/64| <= (0.5 + 16446/2^(18))*log2/64	#
-#					<= 0.57 log2/64.		#
-#		 This bound will be used in Step 4.			#
-#									#
-#	Step 4.	Approximate exp(R)-1 by a polynomial			#
-#		p = R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5))))	#
-#	Notes:	a) In order to reduce memory access, the coefficients	#
-#		are made as "short" as possible: A1 (which is 1/2), A4	#
-#		and A5 are single precision; A2 and A3 are double	#
-#		precision.						#
-#		b) Even with the restrictions above,			#
-#		   |p - (exp(R)-1)| < 2^(-68.8) for all |R| <= 0.0062.	#
-#		Note that 0.0062 is slightly bigger than 0.57 log2/64.	#
-#		c) To fully utilize the pipeline, p is separated into	#
-#		two independent pieces of roughly equal complexities	#
-#			p = [ R + R*S*(A2 + S*A4) ]	+		#
-#				[ S*(A1 + S*(A3 + S*A5)) ]		#
-#		where S = R*R.						#
-#									#
-#	Step 5.	Compute 2^(J/64)*exp(R) = 2^(J/64)*(1+p) by		#
-#				ans := T + ( T*p + t)			#
-#		where T and t are the stored values for 2^(J/64).	#
-#	Notes:	2^(J/64) is stored as T and t where T+t approximates	#
-#		2^(J/64) to roughly 85 bits; T is in extended precision	#
-#		and t is in single precision. Note also that T is	#
-#		rounded to 62 bits so that the last two bits of T are	#
-#		zero. The reason for such a special form is that T-1,	#
-#		T-2, and T-8 will all be exact --- a property that will	#
-#		give much more accurate computation of the function	#
-#		EXPM1.							#
-#									#
-#	Step 6.	Reconstruction of exp(X)				#
-#			exp(X) = 2^M * 2^(J/64) * exp(R).		#
-#		6.1	If AdjFlag = 0, go to 6.3			#
-#		6.2	ans := ans * AdjScale				#
-#		6.3	Restore the user FPCR				#
-#		6.4	Return ans := ans * Scale. Exit.		#
-#	Notes:	If AdjFlag = 0, we have X = Mlog2 + Jlog2/64 + R,	#
-#		|M| <= 16380, and Scale = 2^M. Moreover, exp(X) will	#
-#		neither overflow nor underflow. If AdjFlag = 1, that	#
-#		means that						#
-#			X = (M1+M)log2 + Jlog2/64 + R, |M1+M| >= 16380.	#
-#		Hence, exp(X) may overflow or underflow or neither.	#
-#		When that is the case, AdjScale = 2^(M1) where M1 is	#
-#		approximately M. Thus 6.2 will never cause		#
-#		over/underflow. Possible exception in 6.4 is overflow	#
-#		or underflow. The inexact exception is not generated in	#
-#		6.4. Although one can argue that the inexact flag	#
-#		should always be raised, to simulate that exception	#
-#		cost to much than the flag is worth in practical uses.	#
-#									#
-#	Step 7.	Return 1 + X.						#
-#		7.1	ans := X					#
-#		7.2	Restore user FPCR.				#
-#		7.3	Return ans := 1 + ans. Exit			#
-#	Notes:	For non-zero X, the inexact exception will always be	#
-#		raised by 7.3. That is the only exception raised by 7.3.#
-#		Note also that we use the FMOVEM instruction to move X	#
-#		in Step 7.1 to avoid unnecessary trapping. (Although	#
-#		the FMOVEM may not seem relevant since X is normalized,	#
-#		the precaution will be useful in the library version of	#
-#		this code where the separate entry for denormalized	#
-#		inputs will be done away with.)				#
-#									#
-#	Step 8.	Handle exp(X) where |X| >= 16380log2.			#
-#		8.1	If |X| > 16480 log2, go to Step 9.		#
-#		(mimic 2.2 - 2.6)					#
-#		8.2	N := round-to-integer( X * 64/log2 )		#
-#		8.3	Calculate J = N mod 64, J = 0,1,...,63		#
-#		8.4	K := (N-J)/64, M1 := truncate(K/2), M = K-M1,	#
-#			AdjFlag := 1.					#
-#		8.5	Calculate the address of the stored value	#
-#			2^(J/64).					#
-#		8.6	Create the values Scale = 2^M, AdjScale = 2^M1.	#
-#		8.7	Go to Step 3.					#
-#	Notes:	Refer to notes for 2.2 - 2.6.				#
-#									#
-#	Step 9.	Handle exp(X), |X| > 16480 log2.			#
-#		9.1	If X < 0, go to 9.3				#
-#		9.2	ans := Huge, go to 9.4				#
-#		9.3	ans := Tiny.					#
-#		9.4	Restore user FPCR.				#
-#		9.5	Return ans := ans * ans. Exit.			#
-#	Notes:	Exp(X) will surely overflow or underflow, depending on	#
-#		X's sign. "Huge" and "Tiny" are respectively large/tiny	#
-#		extended-precision numbers whose square over/underflow	#
-#		with an inexact result. Thus, 9.5 always raises the	#
-#		inexact together with either overflow or underflow.	#
-#									#
-#	setoxm1d							#
-#	--------							#
-#									#
-#	Step 1.	Set ans := 0						#
-#									#
-#	Step 2.	Return	ans := X + ans. Exit.				#
-#	Notes:	This will return X with the appropriate rounding	#
-#		 precision prescribed by the user FPCR.			#
-#									#
-#	setoxm1								#
-#	-------								#
-#									#
-#	Step 1.	Check |X|						#
-#		1.1	If |X| >= 1/4, go to Step 1.3.			#
-#		1.2	Go to Step 7.					#
-#		1.3	If |X| < 70 log(2), go to Step 2.		#
-#		1.4	Go to Step 10.					#
-#	Notes:	The usual case should take the branches 1.1 -> 1.3 -> 2.#
-#		However, it is conceivable |X| can be small very often	#
-#		because EXPM1 is intended to evaluate exp(X)-1		#
-#		accurately when |X| is small. For further details on	#
-#		the comparisons, see the notes on Step 1 of setox.	#
-#									#
-#	Step 2.	Calculate N = round-to-nearest-int( X * 64/log2 ).	#
-#		2.1	N := round-to-nearest-integer( X * 64/log2 ).	#
-#		2.2	Calculate	J = N mod 64; so J = 0,1,2,..., #
-#			or 63.						#
-#		2.3	Calculate	M = (N - J)/64; so N = 64M + J.	#
-#		2.4	Calculate the address of the stored value of	#
-#			2^(J/64).					#
-#		2.5	Create the values Sc = 2^M and			#
-#			OnebySc := -2^(-M).				#
-#	Notes:	See the notes on Step 2 of setox.			#
-#									#
-#	Step 3.	Calculate X - N*log2/64.				#
-#		3.1	R := X + N*L1,					#
-#				where L1 := single-precision(-log2/64).	#
-#		3.2	R := R + N*L2,					#
-#				L2 := extended-precision(-log2/64 - L1).#
-#	Notes:	Applying the analysis of Step 3 of setox in this case	#
-#		shows that |R| <= 0.0055 (note that |X| <= 70 log2 in	#
-#		this case).						#
-#									#
-#	Step 4.	Approximate exp(R)-1 by a polynomial			#
-#			p = R+R*R*(A1+R*(A2+R*(A3+R*(A4+R*(A5+R*A6)))))	#
-#	Notes:	a) In order to reduce memory access, the coefficients	#
-#		are made as "short" as possible: A1 (which is 1/2), A5	#
-#		and A6 are single precision; A2, A3 and A4 are double	#
-#		precision.						#
-#		b) Even with the restriction above,			#
-#			|p - (exp(R)-1)| <	|R| * 2^(-72.7)		#
-#		for all |R| <= 0.0055.					#
-#		c) To fully utilize the pipeline, p is separated into	#
-#		two independent pieces of roughly equal complexity	#
-#			p = [ R*S*(A2 + S*(A4 + S*A6)) ]	+	#
-#				[ R + S*(A1 + S*(A3 + S*A5)) ]		#
-#		where S = R*R.						#
-#									#
-#	Step 5.	Compute 2^(J/64)*p by					#
-#				p := T*p				#
-#		where T and t are the stored values for 2^(J/64).	#
-#	Notes:	2^(J/64) is stored as T and t where T+t approximates	#
-#		2^(J/64) to roughly 85 bits; T is in extended precision	#
-#		and t is in single precision. Note also that T is	#
-#		rounded to 62 bits so that the last two bits of T are	#
-#		zero. The reason for such a special form is that T-1,	#
-#		T-2, and T-8 will all be exact --- a property that will	#
-#		be exploited in Step 6 below. The total relative error	#
-#		in p is no bigger than 2^(-67.7) compared to the final	#
-#		result.							#
-#									#
-#	Step 6.	Reconstruction of exp(X)-1				#
-#			exp(X)-1 = 2^M * ( 2^(J/64) + p - 2^(-M) ).	#
-#		6.1	If M <= 63, go to Step 6.3.			#
-#		6.2	ans := T + (p + (t + OnebySc)). Go to 6.6	#
-#		6.3	If M >= -3, go to 6.5.				#
-#		6.4	ans := (T + (p + t)) + OnebySc. Go to 6.6	#
-#		6.5	ans := (T + OnebySc) + (p + t).			#
-#		6.6	Restore user FPCR.				#
-#		6.7	Return ans := Sc * ans. Exit.			#
-#	Notes:	The various arrangements of the expressions give	#
-#		accurate evaluations.					#
-#									#
-#	Step 7.	exp(X)-1 for |X| < 1/4.					#
-#		7.1	If |X| >= 2^(-65), go to Step 9.		#
-#		7.2	Go to Step 8.					#
-#									#
-#	Step 8.	Calculate exp(X)-1, |X| < 2^(-65).			#
-#		8.1	If |X| < 2^(-16312), goto 8.3			#
-#		8.2	Restore FPCR; return ans := X - 2^(-16382).	#
-#			Exit.						#
-#		8.3	X := X * 2^(140).				#
-#		8.4	Restore FPCR; ans := ans - 2^(-16382).		#
-#		 Return ans := ans*2^(140). Exit			#
-#	Notes:	The idea is to return "X - tiny" under the user		#
-#		precision and rounding modes. To avoid unnecessary	#
-#		inefficiency, we stay away from denormalized numbers	#
-#		the best we can. For |X| >= 2^(-16312), the		#
-#		straightforward 8.2 generates the inexact exception as	#
-#		the case warrants.					#
-#									#
-#	Step 9.	Calculate exp(X)-1, |X| < 1/4, by a polynomial		#
-#			p = X + X*X*(B1 + X*(B2 + ... + X*B12))		#
-#	Notes:	a) In order to reduce memory access, the coefficients	#
-#		are made as "short" as possible: B1 (which is 1/2), B9	#
-#		to B12 are single precision; B3 to B8 are double	#
-#		precision; and B2 is double extended.			#
-#		b) Even with the restriction above,			#
-#			|p - (exp(X)-1)| < |X| 2^(-70.6)		#
-#		for all |X| <= 0.251.					#
-#		Note that 0.251 is slightly bigger than 1/4.		#
-#		c) To fully preserve accuracy, the polynomial is	#
-#		computed as						#
-#			X + ( S*B1 +	Q ) where S = X*X and		#
-#			Q	=	X*S*(B2 + X*(B3 + ... + X*B12))	#
-#		d) To fully utilize the pipeline, Q is separated into	#
-#		two independent pieces of roughly equal complexity	#
-#			Q = [ X*S*(B2 + S*(B4 + ... + S*B12)) ] +	#
-#				[ S*S*(B3 + S*(B5 + ... + S*B11)) ]	#
-#									#
-#	Step 10. Calculate exp(X)-1 for |X| >= 70 log 2.		#
-#		10.1 If X >= 70log2 , exp(X) - 1 = exp(X) for all	#
-#		practical purposes. Therefore, go to Step 1 of setox.	#
-#		10.2 If X <= -70log2, exp(X) - 1 = -1 for all practical	#
-#		purposes.						#
-#		ans := -1						#
-#		Restore user FPCR					#
-#		Return ans := ans + 2^(-126). Exit.			#
-#	Notes:	10.2 will always create an inexact and return -1 + tiny	#
-#		in the user rounding precision and mode.		#
-#									#
-#########################################################################
-
-L2:	long		0x3FDC0000,0x82E30865,0x4361C4C6,0x00000000
-
-EEXPA3:	long		0x3FA55555,0x55554CC1
-EEXPA2:	long		0x3FC55555,0x55554A54
-
-EM1A4:	long		0x3F811111,0x11174385
-EM1A3:	long		0x3FA55555,0x55554F5A
-
-EM1A2:	long		0x3FC55555,0x55555555,0x00000000,0x00000000
-
-EM1B8:	long		0x3EC71DE3,0xA5774682
-EM1B7:	long		0x3EFA01A0,0x19D7CB68
-
-EM1B6:	long		0x3F2A01A0,0x1A019DF3
-EM1B5:	long		0x3F56C16C,0x16C170E2
-
-EM1B4:	long		0x3F811111,0x11111111
-EM1B3:	long		0x3FA55555,0x55555555
-
-EM1B2:	long		0x3FFC0000,0xAAAAAAAA,0xAAAAAAAB
-	long		0x00000000
-
-TWO140:	long		0x48B00000,0x00000000
-TWON140:
-	long		0x37300000,0x00000000
-
-EEXPTBL:
-	long		0x3FFF0000,0x80000000,0x00000000,0x00000000
-	long		0x3FFF0000,0x8164D1F3,0xBC030774,0x9F841A9B
-	long		0x3FFF0000,0x82CD8698,0xAC2BA1D8,0x9FC1D5B9
-	long		0x3FFF0000,0x843A28C3,0xACDE4048,0xA0728369
-	long		0x3FFF0000,0x85AAC367,0xCC487B14,0x1FC5C95C
-	long		0x3FFF0000,0x871F6196,0x9E8D1010,0x1EE85C9F
-	long		0x3FFF0000,0x88980E80,0x92DA8528,0x9FA20729
-	long		0x3FFF0000,0x8A14D575,0x496EFD9C,0xA07BF9AF
-	long		0x3FFF0000,0x8B95C1E3,0xEA8BD6E8,0xA0020DCF
-	long		0x3FFF0000,0x8D1ADF5B,0x7E5BA9E4,0x205A63DA
-	long		0x3FFF0000,0x8EA4398B,0x45CD53C0,0x1EB70051
-	long		0x3FFF0000,0x9031DC43,0x1466B1DC,0x1F6EB029
-	long		0x3FFF0000,0x91C3D373,0xAB11C338,0xA0781494
-	long		0x3FFF0000,0x935A2B2F,0x13E6E92C,0x9EB319B0
-	long		0x3FFF0000,0x94F4EFA8,0xFEF70960,0x2017457D
-	long		0x3FFF0000,0x96942D37,0x20185A00,0x1F11D537
-	long		0x3FFF0000,0x9837F051,0x8DB8A970,0x9FB952DD
-	long		0x3FFF0000,0x99E04593,0x20B7FA64,0x1FE43087
-	long		0x3FFF0000,0x9B8D39B9,0xD54E5538,0x1FA2A818
-	long		0x3FFF0000,0x9D3ED9A7,0x2CFFB750,0x1FDE494D
-	long		0x3FFF0000,0x9EF53260,0x91A111AC,0x20504890
-	long		0x3FFF0000,0xA0B0510F,0xB9714FC4,0xA073691C
-	long		0x3FFF0000,0xA2704303,0x0C496818,0x1F9B7A05
-	long		0x3FFF0000,0xA43515AE,0x09E680A0,0xA0797126
-	long		0x3FFF0000,0xA5FED6A9,0xB15138EC,0xA071A140
-	long		0x3FFF0000,0xA7CD93B4,0xE9653568,0x204F62DA
-	long		0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x1F283C4A
-	long		0x3FFF0000,0xAB7A39B5,0xA93ED338,0x9F9A7FDC
-	long		0x3FFF0000,0xAD583EEA,0x42A14AC8,0xA05B3FAC
-	long		0x3FFF0000,0xAF3B78AD,0x690A4374,0x1FDF2610
-	long		0x3FFF0000,0xB123F581,0xD2AC2590,0x9F705F90
-	long		0x3FFF0000,0xB311C412,0xA9112488,0x201F678A
-	long		0x3FFF0000,0xB504F333,0xF9DE6484,0x1F32FB13
-	long		0x3FFF0000,0xB6FD91E3,0x28D17790,0x20038B30
-	long		0x3FFF0000,0xB8FBAF47,0x62FB9EE8,0x200DC3CC
-	long		0x3FFF0000,0xBAFF5AB2,0x133E45FC,0x9F8B2AE6
-	long		0x3FFF0000,0xBD08A39F,0x580C36C0,0xA02BBF70
-	long		0x3FFF0000,0xBF1799B6,0x7A731084,0xA00BF518
-	long		0x3FFF0000,0xC12C4CCA,0x66709458,0xA041DD41
-	long		0x3FFF0000,0xC346CCDA,0x24976408,0x9FDF137B
-	long		0x3FFF0000,0xC5672A11,0x5506DADC,0x201F1568
-	long		0x3FFF0000,0xC78D74C8,0xABB9B15C,0x1FC13A2E
-	long		0x3FFF0000,0xC9B9BD86,0x6E2F27A4,0xA03F8F03
-	long		0x3FFF0000,0xCBEC14FE,0xF2727C5C,0x1FF4907D
-	long		0x3FFF0000,0xCE248C15,0x1F8480E4,0x9E6E53E4
-	long		0x3FFF0000,0xD06333DA,0xEF2B2594,0x1FD6D45C
-	long		0x3FFF0000,0xD2A81D91,0xF12AE45C,0xA076EDB9
-	long		0x3FFF0000,0xD4F35AAB,0xCFEDFA20,0x9FA6DE21
-	long		0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x1EE69A2F
-	long		0x3FFF0000,0xD99D15C2,0x78AFD7B4,0x207F439F
-	long		0x3FFF0000,0xDBFBB797,0xDAF23754,0x201EC207
-	long		0x3FFF0000,0xDE60F482,0x5E0E9124,0x9E8BE175
-	long		0x3FFF0000,0xE0CCDEEC,0x2A94E110,0x20032C4B
-	long		0x3FFF0000,0xE33F8972,0xBE8A5A50,0x2004DFF5
-	long		0x3FFF0000,0xE5B906E7,0x7C8348A8,0x1E72F47A
-	long		0x3FFF0000,0xE8396A50,0x3C4BDC68,0x1F722F22
-	long		0x3FFF0000,0xEAC0C6E7,0xDD243930,0xA017E945
-	long		0x3FFF0000,0xED4F301E,0xD9942B84,0x1F401A5B
-	long		0x3FFF0000,0xEFE4B99B,0xDCDAF5CC,0x9FB9A9E3
-	long		0x3FFF0000,0xF281773C,0x59FFB138,0x20744C05
-	long		0x3FFF0000,0xF5257D15,0x2486CC2C,0x1F773A19
-	long		0x3FFF0000,0xF7D0DF73,0x0AD13BB8,0x1FFE90D5
-	long		0x3FFF0000,0xFA83B2DB,0x722A033C,0xA041ED22
-	long		0x3FFF0000,0xFD3E0C0C,0xF486C174,0x1F853F3A
-
-	set		ADJFLAG,L_SCR2
-	set		SCALE,FP_SCR0
-	set		ADJSCALE,FP_SCR1
-	set		SC,FP_SCR0
-	set		ONEBYSC,FP_SCR1
-
-	global		setox
-setox:
-#--entry point for EXP(X), here X is finite, non-zero, and not NaN's
-
-#--Step 1.
-	mov.l		(%a0),%d1		# load part of input X
-	and.l		&0x7FFF0000,%d1		# biased expo. of X
-	cmp.l		%d1,&0x3FBE0000		# 2^(-65)
-	bge.b		EXPC1			# normal case
-	bra		EXPSM
-
-EXPC1:
-#--The case |X| >= 2^(-65)
-	mov.w		4(%a0),%d1		# expo. and partial sig. of |X|
-	cmp.l		%d1,&0x400CB167		# 16380 log2 trunc. 16 bits
-	blt.b		EXPMAIN			# normal case
-	bra		EEXPBIG
-
-EXPMAIN:
-#--Step 2.
-#--This is the normal branch:	2^(-65) <= |X| < 16380 log2.
-	fmov.x		(%a0),%fp0		# load input from (a0)
-
-	fmov.x		%fp0,%fp1
-	fmul.s		&0x42B8AA3B,%fp0	# 64/log2 * X
-	fmovm.x		&0xc,-(%sp)		# save fp2 {%fp2/%fp3}
-	mov.l		&0,ADJFLAG(%a6)
-	fmov.l		%fp0,%d1		# N = int( X * 64/log2 )
-	lea		EEXPTBL(%pc),%a1
-	fmov.l		%d1,%fp0		# convert to floating-format
-
-	mov.l		%d1,L_SCR1(%a6)		# save N temporarily
-	and.l		&0x3F,%d1		# D0 is J = N mod 64
-	lsl.l		&4,%d1
-	add.l		%d1,%a1			# address of 2^(J/64)
-	mov.l		L_SCR1(%a6),%d1
-	asr.l		&6,%d1			# D0 is M
-	add.w		&0x3FFF,%d1		# biased expo. of 2^(M)
-	mov.w		L2(%pc),L_SCR1(%a6)	# prefetch L2, no need in CB
-
-EXPCONT1:
-#--Step 3.
-#--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
-#--a0 points to 2^(J/64), D0 is biased expo. of 2^(M)
-	fmov.x		%fp0,%fp2
-	fmul.s		&0xBC317218,%fp0	# N * L1, L1 = lead(-log2/64)
-	fmul.x		L2(%pc),%fp2		# N * L2, L1+L2 = -log2/64
-	fadd.x		%fp1,%fp0		# X + N*L1
-	fadd.x		%fp2,%fp0		# fp0 is R, reduced arg.
-
-#--Step 4.
-#--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL
-#-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5))))
-#--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R
-#--[R+R*S*(A2+S*A4)] + [S*(A1+S*(A3+S*A5))]
-
-	fmov.x		%fp0,%fp1
-	fmul.x		%fp1,%fp1		# fp1 IS S = R*R
-
-	fmov.s		&0x3AB60B70,%fp2	# fp2 IS A5
-
-	fmul.x		%fp1,%fp2		# fp2 IS S*A5
-	fmov.x		%fp1,%fp3
-	fmul.s		&0x3C088895,%fp3	# fp3 IS S*A4
-
-	fadd.d		EEXPA3(%pc),%fp2	# fp2 IS A3+S*A5
-	fadd.d		EEXPA2(%pc),%fp3	# fp3 IS A2+S*A4
-
-	fmul.x		%fp1,%fp2		# fp2 IS S*(A3+S*A5)
-	mov.w		%d1,SCALE(%a6)		# SCALE is 2^(M) in extended
-	mov.l		&0x80000000,SCALE+4(%a6)
-	clr.l		SCALE+8(%a6)
-
-	fmul.x		%fp1,%fp3		# fp3 IS S*(A2+S*A4)
-
-	fadd.s		&0x3F000000,%fp2	# fp2 IS A1+S*(A3+S*A5)
-	fmul.x		%fp0,%fp3		# fp3 IS R*S*(A2+S*A4)
-
-	fmul.x		%fp1,%fp2		# fp2 IS S*(A1+S*(A3+S*A5))
-	fadd.x		%fp3,%fp0		# fp0 IS R+R*S*(A2+S*A4),
-
-	fmov.x		(%a1)+,%fp1		# fp1 is lead. pt. of 2^(J/64)
-	fadd.x		%fp2,%fp0		# fp0 is EXP(R) - 1
-
-#--Step 5
-#--final reconstruction process
-#--EXP(X) = 2^M * ( 2^(J/64) + 2^(J/64)*(EXP(R)-1) )
-
-	fmul.x		%fp1,%fp0		# 2^(J/64)*(Exp(R)-1)
-	fmovm.x		(%sp)+,&0x30		# fp2 restored {%fp2/%fp3}
-	fadd.s		(%a1),%fp0		# accurate 2^(J/64)
-
-	fadd.x		%fp1,%fp0		# 2^(J/64) + 2^(J/64)*...
-	mov.l		ADJFLAG(%a6),%d1
-
-#--Step 6
-	tst.l		%d1
-	beq.b		NORMAL
-ADJUST:
-	fmul.x		ADJSCALE(%a6),%fp0
-NORMAL:
-	fmov.l		%d0,%fpcr		# restore user FPCR
-	mov.b		&FMUL_OP,%d1		# last inst is MUL
-	fmul.x		SCALE(%a6),%fp0		# multiply 2^(M)
-	bra		t_catch
-
-EXPSM:
-#--Step 7
-	fmovm.x		(%a0),&0x80		# load X
-	fmov.l		%d0,%fpcr
-	fadd.s		&0x3F800000,%fp0	# 1+X in user mode
-	bra		t_pinx2
-
-EEXPBIG:
-#--Step 8
-	cmp.l		%d1,&0x400CB27C		# 16480 log2
-	bgt.b		EXP2BIG
-#--Steps 8.2 -- 8.6
-	fmov.x		(%a0),%fp0		# load input from (a0)
-
-	fmov.x		%fp0,%fp1
-	fmul.s		&0x42B8AA3B,%fp0	# 64/log2 * X
-	fmovm.x		&0xc,-(%sp)		# save fp2 {%fp2/%fp3}
-	mov.l		&1,ADJFLAG(%a6)
-	fmov.l		%fp0,%d1		# N = int( X * 64/log2 )
-	lea		EEXPTBL(%pc),%a1
-	fmov.l		%d1,%fp0		# convert to floating-format
-	mov.l		%d1,L_SCR1(%a6)		# save N temporarily
-	and.l		&0x3F,%d1		# D0 is J = N mod 64
-	lsl.l		&4,%d1
-	add.l		%d1,%a1			# address of 2^(J/64)
-	mov.l		L_SCR1(%a6),%d1
-	asr.l		&6,%d1			# D0 is K
-	mov.l		%d1,L_SCR1(%a6)		# save K temporarily
-	asr.l		&1,%d1			# D0 is M1
-	sub.l		%d1,L_SCR1(%a6)		# a1 is M
-	add.w		&0x3FFF,%d1		# biased expo. of 2^(M1)
-	mov.w		%d1,ADJSCALE(%a6)	# ADJSCALE := 2^(M1)
-	mov.l		&0x80000000,ADJSCALE+4(%a6)
-	clr.l		ADJSCALE+8(%a6)
-	mov.l		L_SCR1(%a6),%d1		# D0 is M
-	add.w		&0x3FFF,%d1		# biased expo. of 2^(M)
-	bra.w		EXPCONT1		# go back to Step 3
-
-EXP2BIG:
-#--Step 9
-	tst.b		(%a0)			# is X positive or negative?
-	bmi		t_unfl2
-	bra		t_ovfl2
-
-	global		setoxd
-setoxd:
-#--entry point for EXP(X), X is denormalized
-	mov.l		(%a0),-(%sp)
-	andi.l		&0x80000000,(%sp)
-	ori.l		&0x00800000,(%sp)	# sign(X)*2^(-126)
-
-	fmov.s		&0x3F800000,%fp0
-
-	fmov.l		%d0,%fpcr
-	fadd.s		(%sp)+,%fp0
-	bra		t_pinx2
-
-	global		setoxm1
-setoxm1:
-#--entry point for EXPM1(X), here X is finite, non-zero, non-NaN
-
-#--Step 1.
-#--Step 1.1
-	mov.l		(%a0),%d1		# load part of input X
-	and.l		&0x7FFF0000,%d1		# biased expo. of X
-	cmp.l		%d1,&0x3FFD0000		# 1/4
-	bge.b		EM1CON1			# |X| >= 1/4
-	bra		EM1SM
-
-EM1CON1:
-#--Step 1.3
-#--The case |X| >= 1/4
-	mov.w		4(%a0),%d1		# expo. and partial sig. of |X|
-	cmp.l		%d1,&0x4004C215		# 70log2 rounded up to 16 bits
-	ble.b		EM1MAIN			# 1/4 <= |X| <= 70log2
-	bra		EM1BIG
-
-EM1MAIN:
-#--Step 2.
-#--This is the case:	1/4 <= |X| <= 70 log2.
-	fmov.x		(%a0),%fp0		# load input from (a0)
-
-	fmov.x		%fp0,%fp1
-	fmul.s		&0x42B8AA3B,%fp0	# 64/log2 * X
-	fmovm.x		&0xc,-(%sp)		# save fp2 {%fp2/%fp3}
-	fmov.l		%fp0,%d1		# N = int( X * 64/log2 )
-	lea		EEXPTBL(%pc),%a1
-	fmov.l		%d1,%fp0		# convert to floating-format
-
-	mov.l		%d1,L_SCR1(%a6)		# save N temporarily
-	and.l		&0x3F,%d1		# D0 is J = N mod 64
-	lsl.l		&4,%d1
-	add.l		%d1,%a1			# address of 2^(J/64)
-	mov.l		L_SCR1(%a6),%d1
-	asr.l		&6,%d1			# D0 is M
-	mov.l		%d1,L_SCR1(%a6)		# save a copy of M
-
-#--Step 3.
-#--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
-#--a0 points to 2^(J/64), D0 and a1 both contain M
-	fmov.x		%fp0,%fp2
-	fmul.s		&0xBC317218,%fp0	# N * L1, L1 = lead(-log2/64)
-	fmul.x		L2(%pc),%fp2		# N * L2, L1+L2 = -log2/64
-	fadd.x		%fp1,%fp0		# X + N*L1
-	fadd.x		%fp2,%fp0		# fp0 is R, reduced arg.
-	add.w		&0x3FFF,%d1		# D0 is biased expo. of 2^M
-
-#--Step 4.
-#--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL
-#-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*(A5 + R*A6)))))
-#--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R
-#--[R*S*(A2+S*(A4+S*A6))] + [R+S*(A1+S*(A3+S*A5))]
-
-	fmov.x		%fp0,%fp1
-	fmul.x		%fp1,%fp1		# fp1 IS S = R*R
-
-	fmov.s		&0x3950097B,%fp2	# fp2 IS a6
-
-	fmul.x		%fp1,%fp2		# fp2 IS S*A6
-	fmov.x		%fp1,%fp3
-	fmul.s		&0x3AB60B6A,%fp3	# fp3 IS S*A5
-
-	fadd.d		EM1A4(%pc),%fp2		# fp2 IS A4+S*A6
-	fadd.d		EM1A3(%pc),%fp3		# fp3 IS A3+S*A5
-	mov.w		%d1,SC(%a6)		# SC is 2^(M) in extended
-	mov.l		&0x80000000,SC+4(%a6)
-	clr.l		SC+8(%a6)
-
-	fmul.x		%fp1,%fp2		# fp2 IS S*(A4+S*A6)
-	mov.l		L_SCR1(%a6),%d1		# D0 is	M
-	neg.w		%d1			# D0 is -M
-	fmul.x		%fp1,%fp3		# fp3 IS S*(A3+S*A5)
-	add.w		&0x3FFF,%d1		# biased expo. of 2^(-M)
-	fadd.d		EM1A2(%pc),%fp2		# fp2 IS A2+S*(A4+S*A6)
-	fadd.s		&0x3F000000,%fp3	# fp3 IS A1+S*(A3+S*A5)
-
-	fmul.x		%fp1,%fp2		# fp2 IS S*(A2+S*(A4+S*A6))
-	or.w		&0x8000,%d1		# signed/expo. of -2^(-M)
-	mov.w		%d1,ONEBYSC(%a6)	# OnebySc is -2^(-M)
-	mov.l		&0x80000000,ONEBYSC+4(%a6)
-	clr.l		ONEBYSC+8(%a6)
-	fmul.x		%fp3,%fp1		# fp1 IS S*(A1+S*(A3+S*A5))
-
-	fmul.x		%fp0,%fp2		# fp2 IS R*S*(A2+S*(A4+S*A6))
-	fadd.x		%fp1,%fp0		# fp0 IS R+S*(A1+S*(A3+S*A5))
-
-	fadd.x		%fp2,%fp0		# fp0 IS EXP(R)-1
-
-	fmovm.x		(%sp)+,&0x30		# fp2 restored {%fp2/%fp3}
-
-#--Step 5
-#--Compute 2^(J/64)*p
-
-	fmul.x		(%a1),%fp0		# 2^(J/64)*(Exp(R)-1)
-
-#--Step 6
-#--Step 6.1
-	mov.l		L_SCR1(%a6),%d1		# retrieve M
-	cmp.l		%d1,&63
-	ble.b		MLE63
-#--Step 6.2	M >= 64
-	fmov.s		12(%a1),%fp1		# fp1 is t
-	fadd.x		ONEBYSC(%a6),%fp1	# fp1 is t+OnebySc
-	fadd.x		%fp1,%fp0		# p+(t+OnebySc), fp1 released
-	fadd.x		(%a1),%fp0		# T+(p+(t+OnebySc))
-	bra		EM1SCALE
-MLE63:
-#--Step 6.3	M <= 63
-	cmp.l		%d1,&-3
-	bge.b		MGEN3
-MLTN3:
-#--Step 6.4	M <= -4
-	fadd.s		12(%a1),%fp0		# p+t
-	fadd.x		(%a1),%fp0		# T+(p+t)
-	fadd.x		ONEBYSC(%a6),%fp0	# OnebySc + (T+(p+t))
-	bra		EM1SCALE
-MGEN3:
-#--Step 6.5	-3 <= M <= 63
-	fmov.x		(%a1)+,%fp1		# fp1 is T
-	fadd.s		(%a1),%fp0		# fp0 is p+t
-	fadd.x		ONEBYSC(%a6),%fp1	# fp1 is T+OnebySc
-	fadd.x		%fp1,%fp0		# (T+OnebySc)+(p+t)
-
-EM1SCALE:
-#--Step 6.6
-	fmov.l		%d0,%fpcr
-	fmul.x		SC(%a6),%fp0
-	bra		t_inx2
-
-EM1SM:
-#--Step 7	|X| < 1/4.
-	cmp.l		%d1,&0x3FBE0000		# 2^(-65)
-	bge.b		EM1POLY
-
-EM1TINY:
-#--Step 8	|X| < 2^(-65)
-	cmp.l		%d1,&0x00330000		# 2^(-16312)
-	blt.b		EM12TINY
-#--Step 8.2
-	mov.l		&0x80010000,SC(%a6)	# SC is -2^(-16382)
-	mov.l		&0x80000000,SC+4(%a6)
-	clr.l		SC+8(%a6)
-	fmov.x		(%a0),%fp0
-	fmov.l		%d0,%fpcr
-	mov.b		&FADD_OP,%d1		# last inst is ADD
-	fadd.x		SC(%a6),%fp0
-	bra		t_catch
-
-EM12TINY:
-#--Step 8.3
-	fmov.x		(%a0),%fp0
-	fmul.d		TWO140(%pc),%fp0
-	mov.l		&0x80010000,SC(%a6)
-	mov.l		&0x80000000,SC+4(%a6)
-	clr.l		SC+8(%a6)
-	fadd.x		SC(%a6),%fp0
-	fmov.l		%d0,%fpcr
-	mov.b		&FMUL_OP,%d1		# last inst is MUL
-	fmul.d		TWON140(%pc),%fp0
-	bra		t_catch
-
-EM1POLY:
-#--Step 9	exp(X)-1 by a simple polynomial
-	fmov.x		(%a0),%fp0		# fp0 is X
-	fmul.x		%fp0,%fp0		# fp0 is S := X*X
-	fmovm.x		&0xc,-(%sp)		# save fp2 {%fp2/%fp3}
-	fmov.s		&0x2F30CAA8,%fp1	# fp1 is B12
-	fmul.x		%fp0,%fp1		# fp1 is S*B12
-	fmov.s		&0x310F8290,%fp2	# fp2 is B11
-	fadd.s		&0x32D73220,%fp1	# fp1 is B10+S*B12
-
-	fmul.x		%fp0,%fp2		# fp2 is S*B11
-	fmul.x		%fp0,%fp1		# fp1 is S*(B10 + ...
-
-	fadd.s		&0x3493F281,%fp2	# fp2 is B9+S*...
-	fadd.d		EM1B8(%pc),%fp1		# fp1 is B8+S*...
-
-	fmul.x		%fp0,%fp2		# fp2 is S*(B9+...
-	fmul.x		%fp0,%fp1		# fp1 is S*(B8+...
-
-	fadd.d		EM1B7(%pc),%fp2		# fp2 is B7+S*...
-	fadd.d		EM1B6(%pc),%fp1		# fp1 is B6+S*...
-
-	fmul.x		%fp0,%fp2		# fp2 is S*(B7+...
-	fmul.x		%fp0,%fp1		# fp1 is S*(B6+...
-
-	fadd.d		EM1B5(%pc),%fp2		# fp2 is B5+S*...
-	fadd.d		EM1B4(%pc),%fp1		# fp1 is B4+S*...
-
-	fmul.x		%fp0,%fp2		# fp2 is S*(B5+...
-	fmul.x		%fp0,%fp1		# fp1 is S*(B4+...
-
-	fadd.d		EM1B3(%pc),%fp2		# fp2 is B3+S*...
-	fadd.x		EM1B2(%pc),%fp1		# fp1 is B2+S*...
-
-	fmul.x		%fp0,%fp2		# fp2 is S*(B3+...
-	fmul.x		%fp0,%fp1		# fp1 is S*(B2+...
-
-	fmul.x		%fp0,%fp2		# fp2 is S*S*(B3+...)
-	fmul.x		(%a0),%fp1		# fp1 is X*S*(B2...
-
-	fmul.s		&0x3F000000,%fp0	# fp0 is S*B1
-	fadd.x		%fp2,%fp1		# fp1 is Q
-
-	fmovm.x		(%sp)+,&0x30		# fp2 restored {%fp2/%fp3}
-
-	fadd.x		%fp1,%fp0		# fp0 is S*B1+Q
-
-	fmov.l		%d0,%fpcr
-	fadd.x		(%a0),%fp0
-	bra		t_inx2
-
-EM1BIG:
-#--Step 10	|X| > 70 log2
-	mov.l		(%a0),%d1
-	cmp.l		%d1,&0
-	bgt.w		EXPC1
-#--Step 10.2
-	fmov.s		&0xBF800000,%fp0	# fp0 is -1
-	fmov.l		%d0,%fpcr
-	fadd.s		&0x00800000,%fp0	# -1 + 2^(-126)
-	bra		t_minx2
-
-	global		setoxm1d
-setoxm1d:
-#--entry point for EXPM1(X), here X is denormalized
-#--Step 0.
-	bra		t_extdnrm
-
-#########################################################################
-# sgetexp():  returns the exponent portion of the input argument.	#
-#	      The exponent bias is removed and the exponent value is	#
-#	      returned as an extended precision number in fp0.		#
-# sgetexpd(): handles denormalized numbers.				#
-#									#
-# sgetman():  extracts the mantissa of the input argument. The		#
-#	      mantissa is converted to an extended precision number w/	#
-#	      an exponent of $3fff and is returned in fp0. The range of #
-#	      the result is [1.0 - 2.0).				#
-# sgetmand(): handles denormalized numbers.				#
-#									#
-# INPUT *************************************************************** #
-#	a0  = pointer to extended precision input			#
-#									#
-# OUTPUT ************************************************************** #
-#	fp0 = exponent(X) or mantissa(X)				#
-#									#
-#########################################################################
-
-	global		sgetexp
-sgetexp:
-	mov.w		SRC_EX(%a0),%d0		# get the exponent
-	bclr		&0xf,%d0		# clear the sign bit
-	subi.w		&0x3fff,%d0		# subtract off the bias
-	fmov.w		%d0,%fp0		# return exp in fp0
-	blt.b		sgetexpn		# it's negative
-	rts
-
-sgetexpn:
-	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' ccode bit
-	rts
-
-	global		sgetexpd
-sgetexpd:
-	bsr.l		norm			# normalize
-	neg.w		%d0			# new exp = -(shft amt)
-	subi.w		&0x3fff,%d0		# subtract off the bias
-	fmov.w		%d0,%fp0		# return exp in fp0
-	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' ccode bit
-	rts
-
-	global		sgetman
-sgetman:
-	mov.w		SRC_EX(%a0),%d0		# get the exp
-	ori.w		&0x7fff,%d0		# clear old exp
-	bclr		&0xe,%d0		# make it the new exp +-3fff
-
-# here, we build the result in a tmp location so as not to disturb the input
-	mov.l		SRC_HI(%a0),FP_SCR0_HI(%a6) # copy to tmp loc
-	mov.l		SRC_LO(%a0),FP_SCR0_LO(%a6) # copy to tmp loc
-	mov.w		%d0,FP_SCR0_EX(%a6)	# insert new exponent
-	fmov.x		FP_SCR0(%a6),%fp0	# put new value back in fp0
-	bmi.b		sgetmann		# it's negative
-	rts
-
-sgetmann:
-	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' ccode bit
-	rts
-
-#
-# For denormalized numbers, shift the mantissa until the j-bit = 1,
-# then load the exponent with +/1 $3fff.
-#
-	global		sgetmand
-sgetmand:
-	bsr.l		norm			# normalize exponent
-	bra.b		sgetman
-
-#########################################################################
-# scosh():  computes the hyperbolic cosine of a normalized input	#
-# scoshd(): computes the hyperbolic cosine of a denormalized input	#
-#									#
-# INPUT ***************************************************************	#
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = cosh(X)							#
-#									#
-# ACCURACY and MONOTONICITY *******************************************	#
-#	The returned result is within 3 ulps in 64 significant bit,	#
-#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM ***********************************************************	#
-#									#
-#	COSH								#
-#	1. If |X| > 16380 log2, go to 3.				#
-#									#
-#	2. (|X| <= 16380 log2) Cosh(X) is obtained by the formulae	#
-#		y = |X|, z = exp(Y), and				#
-#		cosh(X) = (1/2)*( z + 1/z ).				#
-#		Exit.							#
-#									#
-#	3. (|X| > 16380 log2). If |X| > 16480 log2, go to 5.		#
-#									#
-#	4. (16380 log2 < |X| <= 16480 log2)				#
-#		cosh(X) = sign(X) * exp(|X|)/2.				#
-#		However, invoking exp(|X|) may cause premature		#
-#		overflow. Thus, we calculate sinh(X) as follows:	#
-#		Y	:= |X|						#
-#		Fact	:=	2**(16380)				#
-#		Y'	:= Y - 16381 log2				#
-#		cosh(X) := Fact * exp(Y').				#
-#		Exit.							#
-#									#
-#	5. (|X| > 16480 log2) sinh(X) must overflow. Return		#
-#		Huge*Huge to generate overflow and an infinity with	#
-#		the appropriate sign. Huge is the largest finite number	#
-#		in extended format. Exit.				#
-#									#
-#########################################################################
-
-TWO16380:
-	long		0x7FFB0000,0x80000000,0x00000000,0x00000000
-
-	global		scosh
-scosh:
-	fmov.x		(%a0),%fp0		# LOAD INPUT
-
-	mov.l		(%a0),%d1
-	mov.w		4(%a0),%d1
-	and.l		&0x7FFFFFFF,%d1
-	cmp.l		%d1,&0x400CB167
-	bgt.b		COSHBIG
-
-#--THIS IS THE USUAL CASE, |X| < 16380 LOG2
-#--COSH(X) = (1/2) * ( EXP(X) + 1/EXP(X) )
-
-	fabs.x		%fp0			# |X|
-
-	mov.l		%d0,-(%sp)
-	clr.l		%d0
-	fmovm.x		&0x01,-(%sp)		# save |X| to stack
-	lea		(%sp),%a0		# pass ptr to |X|
-	bsr		setox			# FP0 IS EXP(|X|)
-	add.l		&0xc,%sp		# erase |X| from stack
-	fmul.s		&0x3F000000,%fp0	# (1/2)EXP(|X|)
-	mov.l		(%sp)+,%d0
-
-	fmov.s		&0x3E800000,%fp1	# (1/4)
-	fdiv.x		%fp0,%fp1		# 1/(2 EXP(|X|))
-
-	fmov.l		%d0,%fpcr
-	mov.b		&FADD_OP,%d1		# last inst is ADD
-	fadd.x		%fp1,%fp0
-	bra		t_catch
-
-COSHBIG:
-	cmp.l		%d1,&0x400CB2B3
-	bgt.b		COSHHUGE
-
-	fabs.x		%fp0
-	fsub.d		T1(%pc),%fp0		# (|X|-16381LOG2_LEAD)
-	fsub.d		T2(%pc),%fp0		# |X| - 16381 LOG2, ACCURATE
-
-	mov.l		%d0,-(%sp)
-	clr.l		%d0
-	fmovm.x		&0x01,-(%sp)		# save fp0 to stack
-	lea		(%sp),%a0		# pass ptr to fp0
-	bsr		setox
-	add.l		&0xc,%sp		# clear fp0 from stack
-	mov.l		(%sp)+,%d0
-
-	fmov.l		%d0,%fpcr
-	mov.b		&FMUL_OP,%d1		# last inst is MUL
-	fmul.x		TWO16380(%pc),%fp0
-	bra		t_catch
-
-COSHHUGE:
-	bra		t_ovfl2
-
-	global		scoshd
-#--COSH(X) = 1 FOR DENORMALIZED X
-scoshd:
-	fmov.s		&0x3F800000,%fp0
-
-	fmov.l		%d0,%fpcr
-	fadd.s		&0x00800000,%fp0
-	bra		t_pinx2
-
-#########################################################################
-# ssinh():  computes the hyperbolic sine of a normalized input		#
-# ssinhd(): computes the hyperbolic sine of a denormalized input	#
-#									#
-# INPUT *************************************************************** #
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT ************************************************************** #
-#	fp0 = sinh(X)							#
-#									#
-# ACCURACY and MONOTONICITY *******************************************	#
-#	The returned result is within 3 ulps in 64 significant bit,	#
-#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM *********************************************************** #
-#									#
-#       SINH								#
-#       1. If |X| > 16380 log2, go to 3.				#
-#									#
-#       2. (|X| <= 16380 log2) Sinh(X) is obtained by the formula	#
-#               y = |X|, sgn = sign(X), and z = expm1(Y),		#
-#               sinh(X) = sgn*(1/2)*( z + z/(1+z) ).			#
-#          Exit.							#
-#									#
-#       3. If |X| > 16480 log2, go to 5.				#
-#									#
-#       4. (16380 log2 < |X| <= 16480 log2)				#
-#               sinh(X) = sign(X) * exp(|X|)/2.				#
-#          However, invoking exp(|X|) may cause premature overflow.	#
-#          Thus, we calculate sinh(X) as follows:			#
-#             Y       := |X|						#
-#             sgn     := sign(X)					#
-#             sgnFact := sgn * 2**(16380)				#
-#             Y'      := Y - 16381 log2					#
-#             sinh(X) := sgnFact * exp(Y').				#
-#          Exit.							#
-#									#
-#       5. (|X| > 16480 log2) sinh(X) must overflow. Return		#
-#          sign(X)*Huge*Huge to generate overflow and an infinity with	#
-#          the appropriate sign. Huge is the largest finite number in	#
-#          extended format. Exit.					#
-#									#
-#########################################################################
-
-	global		ssinh
-ssinh:
-	fmov.x		(%a0),%fp0		# LOAD INPUT
-
-	mov.l		(%a0),%d1
-	mov.w		4(%a0),%d1
-	mov.l		%d1,%a1			# save (compacted) operand
-	and.l		&0x7FFFFFFF,%d1
-	cmp.l		%d1,&0x400CB167
-	bgt.b		SINHBIG
-
-#--THIS IS THE USUAL CASE, |X| < 16380 LOG2
-#--Y = |X|, Z = EXPM1(Y), SINH(X) = SIGN(X)*(1/2)*( Z + Z/(1+Z) )
-
-	fabs.x		%fp0			# Y = |X|
-
-	movm.l		&0x8040,-(%sp)		# {a1/d0}
-	fmovm.x		&0x01,-(%sp)		# save Y on stack
-	lea		(%sp),%a0		# pass ptr to Y
-	clr.l		%d0
-	bsr		setoxm1			# FP0 IS Z = EXPM1(Y)
-	add.l		&0xc,%sp		# clear Y from stack
-	fmov.l		&0,%fpcr
-	movm.l		(%sp)+,&0x0201		# {a1/d0}
-
-	fmov.x		%fp0,%fp1
-	fadd.s		&0x3F800000,%fp1	# 1+Z
-	fmov.x		%fp0,-(%sp)
-	fdiv.x		%fp1,%fp0		# Z/(1+Z)
-	mov.l		%a1,%d1
-	and.l		&0x80000000,%d1
-	or.l		&0x3F000000,%d1
-	fadd.x		(%sp)+,%fp0
-	mov.l		%d1,-(%sp)
-
-	fmov.l		%d0,%fpcr
-	mov.b		&FMUL_OP,%d1		# last inst is MUL
-	fmul.s		(%sp)+,%fp0		# last fp inst - possible exceptions set
-	bra		t_catch
-
-SINHBIG:
-	cmp.l		%d1,&0x400CB2B3
-	bgt		t_ovfl
-	fabs.x		%fp0
-	fsub.d		T1(%pc),%fp0		# (|X|-16381LOG2_LEAD)
-	mov.l		&0,-(%sp)
-	mov.l		&0x80000000,-(%sp)
-	mov.l		%a1,%d1
-	and.l		&0x80000000,%d1
-	or.l		&0x7FFB0000,%d1
-	mov.l		%d1,-(%sp)		# EXTENDED FMT
-	fsub.d		T2(%pc),%fp0		# |X| - 16381 LOG2, ACCURATE
-
-	mov.l		%d0,-(%sp)
-	clr.l		%d0
-	fmovm.x		&0x01,-(%sp)		# save fp0 on stack
-	lea		(%sp),%a0		# pass ptr to fp0
-	bsr		setox
-	add.l		&0xc,%sp		# clear fp0 from stack
-
-	mov.l		(%sp)+,%d0
-	fmov.l		%d0,%fpcr
-	mov.b		&FMUL_OP,%d1		# last inst is MUL
-	fmul.x		(%sp)+,%fp0		# possible exception
-	bra		t_catch
-
-	global		ssinhd
-#--SINH(X) = X FOR DENORMALIZED X
-ssinhd:
-	bra		t_extdnrm
-
-#########################################################################
-# stanh():  computes the hyperbolic tangent of a normalized input	#
-# stanhd(): computes the hyperbolic tangent of a denormalized input	#
-#									#
-# INPUT ***************************************************************	#
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = tanh(X)							#
-#									#
-# ACCURACY and MONOTONICITY *******************************************	#
-#	The returned result is within 3 ulps in 64 significant bit,	#
-#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM ***********************************************************	#
-#									#
-#	TANH								#
-#	1. If |X| >= (5/2) log2 or |X| <= 2**(-40), go to 3.		#
-#									#
-#	2. (2**(-40) < |X| < (5/2) log2) Calculate tanh(X) by		#
-#		sgn := sign(X), y := 2|X|, z := expm1(Y), and		#
-#		tanh(X) = sgn*( z/(2+z) ).				#
-#		Exit.							#
-#									#
-#	3. (|X| <= 2**(-40) or |X| >= (5/2) log2). If |X| < 1,		#
-#		go to 7.						#
-#									#
-#	4. (|X| >= (5/2) log2) If |X| >= 50 log2, go to 6.		#
-#									#
-#	5. ((5/2) log2 <= |X| < 50 log2) Calculate tanh(X) by		#
-#		sgn := sign(X), y := 2|X|, z := exp(Y),			#
-#		tanh(X) = sgn - [ sgn*2/(1+z) ].			#
-#		Exit.							#
-#									#
-#	6. (|X| >= 50 log2) Tanh(X) = +-1 (round to nearest). Thus, we	#
-#		calculate Tanh(X) by					#
-#		sgn := sign(X), Tiny := 2**(-126),			#
-#		tanh(X) := sgn - sgn*Tiny.				#
-#		Exit.							#
-#									#
-#	7. (|X| < 2**(-40)). Tanh(X) = X.	Exit.			#
-#									#
-#########################################################################
-
-	set		X,FP_SCR0
-	set		XFRAC,X+4
-
-	set		SGN,L_SCR3
-
-	set		V,FP_SCR0
-
-	global		stanh
-stanh:
-	fmov.x		(%a0),%fp0		# LOAD INPUT
-
-	fmov.x		%fp0,X(%a6)
-	mov.l		(%a0),%d1
-	mov.w		4(%a0),%d1
-	mov.l		%d1,X(%a6)
-	and.l		&0x7FFFFFFF,%d1
-	cmp.l		%d1, &0x3fd78000	# is |X| < 2^(-40)?
-	blt.w		TANHBORS		# yes
-	cmp.l		%d1, &0x3fffddce	# is |X| > (5/2)LOG2?
-	bgt.w		TANHBORS		# yes
-
-#--THIS IS THE USUAL CASE
-#--Y = 2|X|, Z = EXPM1(Y), TANH(X) = SIGN(X) * Z / (Z+2).
-
-	mov.l		X(%a6),%d1
-	mov.l		%d1,SGN(%a6)
-	and.l		&0x7FFF0000,%d1
-	add.l		&0x00010000,%d1		# EXPONENT OF 2|X|
-	mov.l		%d1,X(%a6)
-	and.l		&0x80000000,SGN(%a6)
-	fmov.x		X(%a6),%fp0		# FP0 IS Y = 2|X|
-
-	mov.l		%d0,-(%sp)
-	clr.l		%d0
-	fmovm.x		&0x1,-(%sp)		# save Y on stack
-	lea		(%sp),%a0		# pass ptr to Y
-	bsr		setoxm1			# FP0 IS Z = EXPM1(Y)
-	add.l		&0xc,%sp		# clear Y from stack
-	mov.l		(%sp)+,%d0
-
-	fmov.x		%fp0,%fp1
-	fadd.s		&0x40000000,%fp1	# Z+2
-	mov.l		SGN(%a6),%d1
-	fmov.x		%fp1,V(%a6)
-	eor.l		%d1,V(%a6)
-
-	fmov.l		%d0,%fpcr		# restore users round prec,mode
-	fdiv.x		V(%a6),%fp0
-	bra		t_inx2
-
-TANHBORS:
-	cmp.l		%d1,&0x3FFF8000
-	blt.w		TANHSM
-
-	cmp.l		%d1,&0x40048AA1
-	bgt.w		TANHHUGE
-
-#-- (5/2) LOG2 < |X| < 50 LOG2,
-#--TANH(X) = 1 - (2/[EXP(2X)+1]). LET Y = 2|X|, SGN = SIGN(X),
-#--TANH(X) = SGN -	SGN*2/[EXP(Y)+1].
-
-	mov.l		X(%a6),%d1
-	mov.l		%d1,SGN(%a6)
-	and.l		&0x7FFF0000,%d1
-	add.l		&0x00010000,%d1		# EXPO OF 2|X|
-	mov.l		%d1,X(%a6)		# Y = 2|X|
-	and.l		&0x80000000,SGN(%a6)
-	mov.l		SGN(%a6),%d1
-	fmov.x		X(%a6),%fp0		# Y = 2|X|
-
-	mov.l		%d0,-(%sp)
-	clr.l		%d0
-	fmovm.x		&0x01,-(%sp)		# save Y on stack
-	lea		(%sp),%a0		# pass ptr to Y
-	bsr		setox			# FP0 IS EXP(Y)
-	add.l		&0xc,%sp		# clear Y from stack
-	mov.l		(%sp)+,%d0
-	mov.l		SGN(%a6),%d1
-	fadd.s		&0x3F800000,%fp0	# EXP(Y)+1
-
-	eor.l		&0xC0000000,%d1		# -SIGN(X)*2
-	fmov.s		%d1,%fp1		# -SIGN(X)*2 IN SGL FMT
-	fdiv.x		%fp0,%fp1		# -SIGN(X)2 / [EXP(Y)+1 ]
-
-	mov.l		SGN(%a6),%d1
-	or.l		&0x3F800000,%d1		# SGN
-	fmov.s		%d1,%fp0		# SGN IN SGL FMT
-
-	fmov.l		%d0,%fpcr		# restore users round prec,mode
-	mov.b		&FADD_OP,%d1		# last inst is ADD
-	fadd.x		%fp1,%fp0
-	bra		t_inx2
-
-TANHSM:
-	fmov.l		%d0,%fpcr		# restore users round prec,mode
-	mov.b		&FMOV_OP,%d1		# last inst is MOVE
-	fmov.x		X(%a6),%fp0		# last inst - possible exception set
-	bra		t_catch
-
-#---RETURN SGN(X) - SGN(X)EPS
-TANHHUGE:
-	mov.l		X(%a6),%d1
-	and.l		&0x80000000,%d1
-	or.l		&0x3F800000,%d1
-	fmov.s		%d1,%fp0
-	and.l		&0x80000000,%d1
-	eor.l		&0x80800000,%d1		# -SIGN(X)*EPS
-
-	fmov.l		%d0,%fpcr		# restore users round prec,mode
-	fadd.s		%d1,%fp0
-	bra		t_inx2
-
-	global		stanhd
-#--TANH(X) = X FOR DENORMALIZED X
-stanhd:
-	bra		t_extdnrm
-
-#########################################################################
-# slogn():    computes the natural logarithm of a normalized input	#
-# slognd():   computes the natural logarithm of a denormalized input	#
-# slognp1():  computes the log(1+X) of a normalized input		#
-# slognp1d(): computes the log(1+X) of a denormalized input		#
-#									#
-# INPUT ***************************************************************	#
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = log(X) or log(1+X)					#
-#									#
-# ACCURACY and MONOTONICITY *******************************************	#
-#	The returned result is within 2 ulps in 64 significant bit,	#
-#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM ***********************************************************	#
-#	LOGN:								#
-#	Step 1. If |X-1| < 1/16, approximate log(X) by an odd		#
-#		polynomial in u, where u = 2(X-1)/(X+1). Otherwise,	#
-#		move on to Step 2.					#
-#									#
-#	Step 2. X = 2**k * Y where 1 <= Y < 2. Define F to be the first	#
-#		seven significant bits of Y plus 2**(-7), i.e.		#
-#		F = 1.xxxxxx1 in base 2 where the six "x" match those	#
-#		of Y. Note that |Y-F| <= 2**(-7).			#
-#									#
-#	Step 3. Define u = (Y-F)/F. Approximate log(1+u) by a		#
-#		polynomial in u, log(1+u) = poly.			#
-#									#
-#	Step 4. Reconstruct						#
-#		log(X) = log( 2**k * Y ) = k*log(2) + log(F) + log(1+u)	#
-#		by k*log(2) + (log(F) + poly). The values of log(F) are	#
-#		calculated beforehand and stored in the program.	#
-#									#
-#	lognp1:								#
-#	Step 1: If |X| < 1/16, approximate log(1+X) by an odd		#
-#		polynomial in u where u = 2X/(2+X). Otherwise, move on	#
-#		to Step 2.						#
-#									#
-#	Step 2: Let 1+X = 2**k * Y, where 1 <= Y < 2. Define F as done	#
-#		in Step 2 of the algorithm for LOGN and compute		#
-#		log(1+X) as k*log(2) + log(F) + poly where poly		#
-#		approximates log(1+u), u = (Y-F)/F.			#
-#									#
-#	Implementation Notes:						#
-#	Note 1. There are 64 different possible values for F, thus 64	#
-#		log(F)'s need to be tabulated. Moreover, the values of	#
-#		1/F are also tabulated so that the division in (Y-F)/F	#
-#		can be performed by a multiplication.			#
-#									#
-#	Note 2. In Step 2 of lognp1, in order to preserved accuracy,	#
-#		the value Y-F has to be calculated carefully when	#
-#		1/2 <= X < 3/2.						#
-#									#
-#	Note 3. To fully exploit the pipeline, polynomials are usually	#
-#		separated into two parts evaluated independently before	#
-#		being added up.						#
-#									#
-#########################################################################
-LOGOF2:
-	long		0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000
-
-one:
-	long		0x3F800000
-zero:
-	long		0x00000000
-infty:
-	long		0x7F800000
-negone:
-	long		0xBF800000
-
-LOGA6:
-	long		0x3FC2499A,0xB5E4040B
-LOGA5:
-	long		0xBFC555B5,0x848CB7DB
-
-LOGA4:
-	long		0x3FC99999,0x987D8730
-LOGA3:
-	long		0xBFCFFFFF,0xFF6F7E97
-
-LOGA2:
-	long		0x3FD55555,0x555555A4
-LOGA1:
-	long		0xBFE00000,0x00000008
-
-LOGB5:
-	long		0x3F175496,0xADD7DAD6
-LOGB4:
-	long		0x3F3C71C2,0xFE80C7E0
-
-LOGB3:
-	long		0x3F624924,0x928BCCFF
-LOGB2:
-	long		0x3F899999,0x999995EC
-
-LOGB1:
-	long		0x3FB55555,0x55555555
-TWO:
-	long		0x40000000,0x00000000
-
-LTHOLD:
-	long		0x3f990000,0x80000000,0x00000000,0x00000000
-
-LOGTBL:
-	long		0x3FFE0000,0xFE03F80F,0xE03F80FE,0x00000000
-	long		0x3FF70000,0xFF015358,0x833C47E2,0x00000000
-	long		0x3FFE0000,0xFA232CF2,0x52138AC0,0x00000000
-	long		0x3FF90000,0xBDC8D83E,0xAD88D549,0x00000000
-	long		0x3FFE0000,0xF6603D98,0x0F6603DA,0x00000000
-	long		0x3FFA0000,0x9CF43DCF,0xF5EAFD48,0x00000000
-	long		0x3FFE0000,0xF2B9D648,0x0F2B9D65,0x00000000
-	long		0x3FFA0000,0xDA16EB88,0xCB8DF614,0x00000000
-	long		0x3FFE0000,0xEF2EB71F,0xC4345238,0x00000000
-	long		0x3FFB0000,0x8B29B775,0x1BD70743,0x00000000
-	long		0x3FFE0000,0xEBBDB2A5,0xC1619C8C,0x00000000
-	long		0x3FFB0000,0xA8D839F8,0x30C1FB49,0x00000000
-	long		0x3FFE0000,0xE865AC7B,0x7603A197,0x00000000
-	long		0x3FFB0000,0xC61A2EB1,0x8CD907AD,0x00000000
-	long		0x3FFE0000,0xE525982A,0xF70C880E,0x00000000
-	long		0x3FFB0000,0xE2F2A47A,0xDE3A18AF,0x00000000
-	long		0x3FFE0000,0xE1FC780E,0x1FC780E2,0x00000000
-	long		0x3FFB0000,0xFF64898E,0xDF55D551,0x00000000
-	long		0x3FFE0000,0xDEE95C4C,0xA037BA57,0x00000000
-	long		0x3FFC0000,0x8DB956A9,0x7B3D0148,0x00000000
-	long		0x3FFE0000,0xDBEB61EE,0xD19C5958,0x00000000
-	long		0x3FFC0000,0x9B8FE100,0xF47BA1DE,0x00000000
-	long		0x3FFE0000,0xD901B203,0x6406C80E,0x00000000
-	long		0x3FFC0000,0xA9372F1D,0x0DA1BD17,0x00000000
-	long		0x3FFE0000,0xD62B80D6,0x2B80D62C,0x00000000
-	long		0x3FFC0000,0xB6B07F38,0xCE90E46B,0x00000000
-	long		0x3FFE0000,0xD3680D36,0x80D3680D,0x00000000
-	long		0x3FFC0000,0xC3FD0329,0x06488481,0x00000000
-	long		0x3FFE0000,0xD0B69FCB,0xD2580D0B,0x00000000
-	long		0x3FFC0000,0xD11DE0FF,0x15AB18CA,0x00000000
-	long		0x3FFE0000,0xCE168A77,0x25080CE1,0x00000000
-	long		0x3FFC0000,0xDE1433A1,0x6C66B150,0x00000000
-	long		0x3FFE0000,0xCB8727C0,0x65C393E0,0x00000000
-	long		0x3FFC0000,0xEAE10B5A,0x7DDC8ADD,0x00000000
-	long		0x3FFE0000,0xC907DA4E,0x871146AD,0x00000000
-	long		0x3FFC0000,0xF7856E5E,0xE2C9B291,0x00000000
-	long		0x3FFE0000,0xC6980C69,0x80C6980C,0x00000000
-	long		0x3FFD0000,0x82012CA5,0xA68206D7,0x00000000
-	long		0x3FFE0000,0xC4372F85,0x5D824CA6,0x00000000
-	long		0x3FFD0000,0x882C5FCD,0x7256A8C5,0x00000000
-	long		0x3FFE0000,0xC1E4BBD5,0x95F6E947,0x00000000
-	long		0x3FFD0000,0x8E44C60B,0x4CCFD7DE,0x00000000
-	long		0x3FFE0000,0xBFA02FE8,0x0BFA02FF,0x00000000
-	long		0x3FFD0000,0x944AD09E,0xF4351AF6,0x00000000
-	long		0x3FFE0000,0xBD691047,0x07661AA3,0x00000000
-	long		0x3FFD0000,0x9A3EECD4,0xC3EAA6B2,0x00000000
-	long		0x3FFE0000,0xBB3EE721,0xA54D880C,0x00000000
-	long		0x3FFD0000,0xA0218434,0x353F1DE8,0x00000000
-	long		0x3FFE0000,0xB92143FA,0x36F5E02E,0x00000000
-	long		0x3FFD0000,0xA5F2FCAB,0xBBC506DA,0x00000000
-	long		0x3FFE0000,0xB70FBB5A,0x19BE3659,0x00000000
-	long		0x3FFD0000,0xABB3B8BA,0x2AD362A5,0x00000000
-	long		0x3FFE0000,0xB509E68A,0x9B94821F,0x00000000
-	long		0x3FFD0000,0xB1641795,0xCE3CA97B,0x00000000
-	long		0x3FFE0000,0xB30F6352,0x8917C80B,0x00000000
-	long		0x3FFD0000,0xB7047551,0x5D0F1C61,0x00000000
-	long		0x3FFE0000,0xB11FD3B8,0x0B11FD3C,0x00000000
-	long		0x3FFD0000,0xBC952AFE,0xEA3D13E1,0x00000000
-	long		0x3FFE0000,0xAF3ADDC6,0x80AF3ADE,0x00000000
-	long		0x3FFD0000,0xC2168ED0,0xF458BA4A,0x00000000
-	long		0x3FFE0000,0xAD602B58,0x0AD602B6,0x00000000
-	long		0x3FFD0000,0xC788F439,0xB3163BF1,0x00000000
-	long		0x3FFE0000,0xAB8F69E2,0x8359CD11,0x00000000
-	long		0x3FFD0000,0xCCECAC08,0xBF04565D,0x00000000
-	long		0x3FFE0000,0xA9C84A47,0xA07F5638,0x00000000
-	long		0x3FFD0000,0xD2420487,0x2DD85160,0x00000000
-	long		0x3FFE0000,0xA80A80A8,0x0A80A80B,0x00000000
-	long		0x3FFD0000,0xD7894992,0x3BC3588A,0x00000000
-	long		0x3FFE0000,0xA655C439,0x2D7B73A8,0x00000000
-	long		0x3FFD0000,0xDCC2C4B4,0x9887DACC,0x00000000
-	long		0x3FFE0000,0xA4A9CF1D,0x96833751,0x00000000
-	long		0x3FFD0000,0xE1EEBD3E,0x6D6A6B9E,0x00000000
-	long		0x3FFE0000,0xA3065E3F,0xAE7CD0E0,0x00000000
-	long		0x3FFD0000,0xE70D785C,0x2F9F5BDC,0x00000000
-	long		0x3FFE0000,0xA16B312E,0xA8FC377D,0x00000000
-	long		0x3FFD0000,0xEC1F392C,0x5179F283,0x00000000
-	long		0x3FFE0000,0x9FD809FD,0x809FD80A,0x00000000
-	long		0x3FFD0000,0xF12440D3,0xE36130E6,0x00000000
-	long		0x3FFE0000,0x9E4CAD23,0xDD5F3A20,0x00000000
-	long		0x3FFD0000,0xF61CCE92,0x346600BB,0x00000000
-	long		0x3FFE0000,0x9CC8E160,0xC3FB19B9,0x00000000
-	long		0x3FFD0000,0xFB091FD3,0x8145630A,0x00000000
-	long		0x3FFE0000,0x9B4C6F9E,0xF03A3CAA,0x00000000
-	long		0x3FFD0000,0xFFE97042,0xBFA4C2AD,0x00000000
-	long		0x3FFE0000,0x99D722DA,0xBDE58F06,0x00000000
-	long		0x3FFE0000,0x825EFCED,0x49369330,0x00000000
-	long		0x3FFE0000,0x9868C809,0x868C8098,0x00000000
-	long		0x3FFE0000,0x84C37A7A,0xB9A905C9,0x00000000
-	long		0x3FFE0000,0x97012E02,0x5C04B809,0x00000000
-	long		0x3FFE0000,0x87224C2E,0x8E645FB7,0x00000000
-	long		0x3FFE0000,0x95A02568,0x095A0257,0x00000000
-	long		0x3FFE0000,0x897B8CAC,0x9F7DE298,0x00000000
-	long		0x3FFE0000,0x94458094,0x45809446,0x00000000
-	long		0x3FFE0000,0x8BCF55DE,0xC4CD05FE,0x00000000
-	long		0x3FFE0000,0x92F11384,0x0497889C,0x00000000
-	long		0x3FFE0000,0x8E1DC0FB,0x89E125E5,0x00000000
-	long		0x3FFE0000,0x91A2B3C4,0xD5E6F809,0x00000000
-	long		0x3FFE0000,0x9066E68C,0x955B6C9B,0x00000000
-	long		0x3FFE0000,0x905A3863,0x3E06C43B,0x00000000
-	long		0x3FFE0000,0x92AADE74,0xC7BE59E0,0x00000000
-	long		0x3FFE0000,0x8F1779D9,0xFDC3A219,0x00000000
-	long		0x3FFE0000,0x94E9BFF6,0x15845643,0x00000000
-	long		0x3FFE0000,0x8DDA5202,0x37694809,0x00000000
-	long		0x3FFE0000,0x9723A1B7,0x20134203,0x00000000
-	long		0x3FFE0000,0x8CA29C04,0x6514E023,0x00000000
-	long		0x3FFE0000,0x995899C8,0x90EB8990,0x00000000
-	long		0x3FFE0000,0x8B70344A,0x139BC75A,0x00000000
-	long		0x3FFE0000,0x9B88BDAA,0x3A3DAE2F,0x00000000
-	long		0x3FFE0000,0x8A42F870,0x5669DB46,0x00000000
-	long		0x3FFE0000,0x9DB4224F,0xFFE1157C,0x00000000
-	long		0x3FFE0000,0x891AC73A,0xE9819B50,0x00000000
-	long		0x3FFE0000,0x9FDADC26,0x8B7A12DA,0x00000000
-	long		0x3FFE0000,0x87F78087,0xF78087F8,0x00000000
-	long		0x3FFE0000,0xA1FCFF17,0xCE733BD4,0x00000000
-	long		0x3FFE0000,0x86D90544,0x7A34ACC6,0x00000000
-	long		0x3FFE0000,0xA41A9E8F,0x5446FB9F,0x00000000
-	long		0x3FFE0000,0x85BF3761,0x2CEE3C9B,0x00000000
-	long		0x3FFE0000,0xA633CD7E,0x6771CD8B,0x00000000
-	long		0x3FFE0000,0x84A9F9C8,0x084A9F9D,0x00000000
-	long		0x3FFE0000,0xA8489E60,0x0B435A5E,0x00000000
-	long		0x3FFE0000,0x83993052,0x3FBE3368,0x00000000
-	long		0x3FFE0000,0xAA59233C,0xCCA4BD49,0x00000000
-	long		0x3FFE0000,0x828CBFBE,0xB9A020A3,0x00000000
-	long		0x3FFE0000,0xAC656DAE,0x6BCC4985,0x00000000
-	long		0x3FFE0000,0x81848DA8,0xFAF0D277,0x00000000
-	long		0x3FFE0000,0xAE6D8EE3,0x60BB2468,0x00000000
-	long		0x3FFE0000,0x80808080,0x80808081,0x00000000
-	long		0x3FFE0000,0xB07197A2,0x3C46C654,0x00000000
-
-	set		ADJK,L_SCR1
-
-	set		X,FP_SCR0
-	set		XDCARE,X+2
-	set		XFRAC,X+4
-
-	set		F,FP_SCR1
-	set		FFRAC,F+4
-
-	set		KLOG2,FP_SCR0
-
-	set		SAVEU,FP_SCR0
-
-	global		slogn
-#--ENTRY POINT FOR LOG(X) FOR X FINITE, NON-ZERO, NOT NAN'S
-slogn:
-	fmov.x		(%a0),%fp0		# LOAD INPUT
-	mov.l		&0x00000000,ADJK(%a6)
-
-LOGBGN:
-#--FPCR SAVED AND CLEARED, INPUT IS 2^(ADJK)*FP0, FP0 CONTAINS
-#--A FINITE, NON-ZERO, NORMALIZED NUMBER.
-
-	mov.l		(%a0),%d1
-	mov.w		4(%a0),%d1
-
-	mov.l		(%a0),X(%a6)
-	mov.l		4(%a0),X+4(%a6)
-	mov.l		8(%a0),X+8(%a6)
-
-	cmp.l		%d1,&0			# CHECK IF X IS NEGATIVE
-	blt.w		LOGNEG			# LOG OF NEGATIVE ARGUMENT IS INVALID
-# X IS POSITIVE, CHECK IF X IS NEAR 1
-	cmp.l		%d1,&0x3ffef07d		# IS X < 15/16?
-	blt.b		LOGMAIN			# YES
-	cmp.l		%d1,&0x3fff8841		# IS X > 17/16?
-	ble.w		LOGNEAR1		# NO
-
-LOGMAIN:
-#--THIS SHOULD BE THE USUAL CASE, X NOT VERY CLOSE TO 1
-
-#--X = 2^(K) * Y, 1 <= Y < 2. THUS, Y = 1.XXXXXXXX....XX IN BINARY.
-#--WE DEFINE F = 1.XXXXXX1, I.E. FIRST 7 BITS OF Y AND ATTACH A 1.
-#--THE IDEA IS THAT LOG(X) = K*LOG2 + LOG(Y)
-#--			 = K*LOG2 + LOG(F) + LOG(1 + (Y-F)/F).
-#--NOTE THAT U = (Y-F)/F IS VERY SMALL AND THUS APPROXIMATING
-#--LOG(1+U) CAN BE VERY EFFICIENT.
-#--ALSO NOTE THAT THE VALUE 1/F IS STORED IN A TABLE SO THAT NO
-#--DIVISION IS NEEDED TO CALCULATE (Y-F)/F.
-
-#--GET K, Y, F, AND ADDRESS OF 1/F.
-	asr.l		&8,%d1
-	asr.l		&8,%d1			# SHIFTED 16 BITS, BIASED EXPO. OF X
-	sub.l		&0x3FFF,%d1		# THIS IS K
-	add.l		ADJK(%a6),%d1		# ADJUST K, ORIGINAL INPUT MAY BE  DENORM.
-	lea		LOGTBL(%pc),%a0		# BASE ADDRESS OF 1/F AND LOG(F)
-	fmov.l		%d1,%fp1		# CONVERT K TO FLOATING-POINT FORMAT
-
-#--WHILE THE CONVERSION IS GOING ON, WE GET F AND ADDRESS OF 1/F
-	mov.l		&0x3FFF0000,X(%a6)	# X IS NOW Y, I.E. 2^(-K)*X
-	mov.l		XFRAC(%a6),FFRAC(%a6)
-	and.l		&0xFE000000,FFRAC(%a6)	# FIRST 7 BITS OF Y
-	or.l		&0x01000000,FFRAC(%a6)	# GET F: ATTACH A 1 AT THE EIGHTH BIT
-	mov.l		FFRAC(%a6),%d1	# READY TO GET ADDRESS OF 1/F
-	and.l		&0x7E000000,%d1
-	asr.l		&8,%d1
-	asr.l		&8,%d1
-	asr.l		&4,%d1			# SHIFTED 20, D0 IS THE DISPLACEMENT
-	add.l		%d1,%a0			# A0 IS THE ADDRESS FOR 1/F
-
-	fmov.x		X(%a6),%fp0
-	mov.l		&0x3fff0000,F(%a6)
-	clr.l		F+8(%a6)
-	fsub.x		F(%a6),%fp0		# Y-F
-	fmovm.x		&0xc,-(%sp)		# SAVE FP2-3 WHILE FP0 IS NOT READY
-#--SUMMARY: FP0 IS Y-F, A0 IS ADDRESS OF 1/F, FP1 IS K
-#--REGISTERS SAVED: FPCR, FP1, FP2
-
-LP1CONT1:
-#--AN RE-ENTRY POINT FOR LOGNP1
-	fmul.x		(%a0),%fp0		# FP0 IS U = (Y-F)/F
-	fmul.x		LOGOF2(%pc),%fp1	# GET K*LOG2 WHILE FP0 IS NOT READY
-	fmov.x		%fp0,%fp2
-	fmul.x		%fp2,%fp2		# FP2 IS V=U*U
-	fmov.x		%fp1,KLOG2(%a6)		# PUT K*LOG2 IN MEMEORY, FREE FP1
-
-#--LOG(1+U) IS APPROXIMATED BY
-#--U + V*(A1+U*(A2+U*(A3+U*(A4+U*(A5+U*A6))))) WHICH IS
-#--[U + V*(A1+V*(A3+V*A5))]  +  [U*V*(A2+V*(A4+V*A6))]
-
-	fmov.x		%fp2,%fp3
-	fmov.x		%fp2,%fp1
-
-	fmul.d		LOGA6(%pc),%fp1		# V*A6
-	fmul.d		LOGA5(%pc),%fp2		# V*A5
-
-	fadd.d		LOGA4(%pc),%fp1		# A4+V*A6
-	fadd.d		LOGA3(%pc),%fp2		# A3+V*A5
-
-	fmul.x		%fp3,%fp1		# V*(A4+V*A6)
-	fmul.x		%fp3,%fp2		# V*(A3+V*A5)
-
-	fadd.d		LOGA2(%pc),%fp1		# A2+V*(A4+V*A6)
-	fadd.d		LOGA1(%pc),%fp2		# A1+V*(A3+V*A5)
-
-	fmul.x		%fp3,%fp1		# V*(A2+V*(A4+V*A6))
-	add.l		&16,%a0			# ADDRESS OF LOG(F)
-	fmul.x		%fp3,%fp2		# V*(A1+V*(A3+V*A5))
-
-	fmul.x		%fp0,%fp1		# U*V*(A2+V*(A4+V*A6))
-	fadd.x		%fp2,%fp0		# U+V*(A1+V*(A3+V*A5))
-
-	fadd.x		(%a0),%fp1		# LOG(F)+U*V*(A2+V*(A4+V*A6))
-	fmovm.x		(%sp)+,&0x30		# RESTORE FP2-3
-	fadd.x		%fp1,%fp0		# FP0 IS LOG(F) + LOG(1+U)
-
-	fmov.l		%d0,%fpcr
-	fadd.x		KLOG2(%a6),%fp0		# FINAL ADD
-	bra		t_inx2
-
-
-LOGNEAR1:
-
-# if the input is exactly equal to one, then exit through ld_pzero.
-# if these 2 lines weren't here, the correct answer would be returned
-# but the INEX2 bit would be set.
-	fcmp.b		%fp0,&0x1		# is it equal to one?
-	fbeq.l		ld_pzero		# yes
-
-#--REGISTERS SAVED: FPCR, FP1. FP0 CONTAINS THE INPUT.
-	fmov.x		%fp0,%fp1
-	fsub.s		one(%pc),%fp1		# FP1 IS X-1
-	fadd.s		one(%pc),%fp0		# FP0 IS X+1
-	fadd.x		%fp1,%fp1		# FP1 IS 2(X-1)
-#--LOG(X) = LOG(1+U/2)-LOG(1-U/2) WHICH IS AN ODD POLYNOMIAL
-#--IN U, U = 2(X-1)/(X+1) = FP1/FP0
-
-LP1CONT2:
-#--THIS IS AN RE-ENTRY POINT FOR LOGNP1
-	fdiv.x		%fp0,%fp1		# FP1 IS U
-	fmovm.x		&0xc,-(%sp)		# SAVE FP2-3
-#--REGISTERS SAVED ARE NOW FPCR,FP1,FP2,FP3
-#--LET V=U*U, W=V*V, CALCULATE
-#--U + U*V*(B1 + V*(B2 + V*(B3 + V*(B4 + V*B5)))) BY
-#--U + U*V*(  [B1 + W*(B3 + W*B5)]  +  [V*(B2 + W*B4)]  )
-	fmov.x		%fp1,%fp0
-	fmul.x		%fp0,%fp0		# FP0 IS V
-	fmov.x		%fp1,SAVEU(%a6)		# STORE U IN MEMORY, FREE FP1
-	fmov.x		%fp0,%fp1
-	fmul.x		%fp1,%fp1		# FP1 IS W
-
-	fmov.d		LOGB5(%pc),%fp3
-	fmov.d		LOGB4(%pc),%fp2
-
-	fmul.x		%fp1,%fp3		# W*B5
-	fmul.x		%fp1,%fp2		# W*B4
-
-	fadd.d		LOGB3(%pc),%fp3		# B3+W*B5
-	fadd.d		LOGB2(%pc),%fp2		# B2+W*B4
-
-	fmul.x		%fp3,%fp1		# W*(B3+W*B5), FP3 RELEASED
-
-	fmul.x		%fp0,%fp2		# V*(B2+W*B4)
-
-	fadd.d		LOGB1(%pc),%fp1		# B1+W*(B3+W*B5)
-	fmul.x		SAVEU(%a6),%fp0		# FP0 IS U*V
-
-	fadd.x		%fp2,%fp1		# B1+W*(B3+W*B5) + V*(B2+W*B4), FP2 RELEASED
-	fmovm.x		(%sp)+,&0x30		# FP2-3 RESTORED
-
-	fmul.x		%fp1,%fp0		# U*V*( [B1+W*(B3+W*B5)] + [V*(B2+W*B4)] )
-
-	fmov.l		%d0,%fpcr
-	fadd.x		SAVEU(%a6),%fp0
-	bra		t_inx2
-
-#--REGISTERS SAVED FPCR. LOG(-VE) IS INVALID
-LOGNEG:
-	bra		t_operr
-
-	global		slognd
-slognd:
-#--ENTRY POINT FOR LOG(X) FOR DENORMALIZED INPUT
-
-	mov.l		&-100,ADJK(%a6)		# INPUT = 2^(ADJK) * FP0
-
-#----normalize the input value by left shifting k bits (k to be determined
-#----below), adjusting exponent and storing -k to  ADJK
-#----the value TWOTO100 is no longer needed.
-#----Note that this code assumes the denormalized input is NON-ZERO.
-
-	movm.l		&0x3f00,-(%sp)		# save some registers  {d2-d7}
-	mov.l		(%a0),%d3		# D3 is exponent of smallest norm. #
-	mov.l		4(%a0),%d4
-	mov.l		8(%a0),%d5		# (D4,D5) is (Hi_X,Lo_X)
-	clr.l		%d2			# D2 used for holding K
-
-	tst.l		%d4
-	bne.b		Hi_not0
-
-Hi_0:
-	mov.l		%d5,%d4
-	clr.l		%d5
-	mov.l		&32,%d2
-	clr.l		%d6
-	bfffo		%d4{&0:&32},%d6
-	lsl.l		%d6,%d4
-	add.l		%d6,%d2			# (D3,D4,D5) is normalized
-
-	mov.l		%d3,X(%a6)
-	mov.l		%d4,XFRAC(%a6)
-	mov.l		%d5,XFRAC+4(%a6)
-	neg.l		%d2
-	mov.l		%d2,ADJK(%a6)
-	fmov.x		X(%a6),%fp0
-	movm.l		(%sp)+,&0xfc		# restore registers {d2-d7}
-	lea		X(%a6),%a0
-	bra.w		LOGBGN			# begin regular log(X)
-
-Hi_not0:
-	clr.l		%d6
-	bfffo		%d4{&0:&32},%d6		# find first 1
-	mov.l		%d6,%d2			# get k
-	lsl.l		%d6,%d4
-	mov.l		%d5,%d7			# a copy of D5
-	lsl.l		%d6,%d5
-	neg.l		%d6
-	add.l		&32,%d6
-	lsr.l		%d6,%d7
-	or.l		%d7,%d4			# (D3,D4,D5) normalized
-
-	mov.l		%d3,X(%a6)
-	mov.l		%d4,XFRAC(%a6)
-	mov.l		%d5,XFRAC+4(%a6)
-	neg.l		%d2
-	mov.l		%d2,ADJK(%a6)
-	fmov.x		X(%a6),%fp0
-	movm.l		(%sp)+,&0xfc		# restore registers {d2-d7}
-	lea		X(%a6),%a0
-	bra.w		LOGBGN			# begin regular log(X)
-
-	global		slognp1
-#--ENTRY POINT FOR LOG(1+X) FOR X FINITE, NON-ZERO, NOT NAN'S
-slognp1:
-	fmov.x		(%a0),%fp0		# LOAD INPUT
-	fabs.x		%fp0			# test magnitude
-	fcmp.x		%fp0,LTHOLD(%pc)	# compare with min threshold
-	fbgt.w		LP1REAL			# if greater, continue
-	fmov.l		%d0,%fpcr
-	mov.b		&FMOV_OP,%d1		# last inst is MOVE
-	fmov.x		(%a0),%fp0		# return signed argument
-	bra		t_catch
-
-LP1REAL:
-	fmov.x		(%a0),%fp0		# LOAD INPUT
-	mov.l		&0x00000000,ADJK(%a6)
-	fmov.x		%fp0,%fp1		# FP1 IS INPUT Z
-	fadd.s		one(%pc),%fp0		# X := ROUND(1+Z)
-	fmov.x		%fp0,X(%a6)
-	mov.w		XFRAC(%a6),XDCARE(%a6)
-	mov.l		X(%a6),%d1
-	cmp.l		%d1,&0
-	ble.w		LP1NEG0			# LOG OF ZERO OR -VE
-	cmp.l		%d1,&0x3ffe8000		# IS BOUNDS [1/2,3/2]?
-	blt.w		LOGMAIN
-	cmp.l		%d1,&0x3fffc000
-	bgt.w		LOGMAIN
-#--IF 1+Z > 3/2 OR 1+Z < 1/2, THEN X, WHICH IS ROUNDING 1+Z,
-#--CONTAINS AT LEAST 63 BITS OF INFORMATION OF Z. IN THAT CASE,
-#--SIMPLY INVOKE LOG(X) FOR LOG(1+Z).
-
-LP1NEAR1:
-#--NEXT SEE IF EXP(-1/16) < X < EXP(1/16)
-	cmp.l		%d1,&0x3ffef07d
-	blt.w		LP1CARE
-	cmp.l		%d1,&0x3fff8841
-	bgt.w		LP1CARE
-
-LP1ONE16:
-#--EXP(-1/16) < X < EXP(1/16). LOG(1+Z) = LOG(1+U/2) - LOG(1-U/2)
-#--WHERE U = 2Z/(2+Z) = 2Z/(1+X).
-	fadd.x		%fp1,%fp1		# FP1 IS 2Z
-	fadd.s		one(%pc),%fp0		# FP0 IS 1+X
-#--U = FP1/FP0
-	bra.w		LP1CONT2
-
-LP1CARE:
-#--HERE WE USE THE USUAL TABLE DRIVEN APPROACH. CARE HAS TO BE
-#--TAKEN BECAUSE 1+Z CAN HAVE 67 BITS OF INFORMATION AND WE MUST
-#--PRESERVE ALL THE INFORMATION. BECAUSE 1+Z IS IN [1/2,3/2],
-#--THERE ARE ONLY TWO CASES.
-#--CASE 1: 1+Z < 1, THEN K = -1 AND Y-F = (2-F) + 2Z
-#--CASE 2: 1+Z > 1, THEN K = 0  AND Y-F = (1-F) + Z
-#--ON RETURNING TO LP1CONT1, WE MUST HAVE K IN FP1, ADDRESS OF
-#--(1/F) IN A0, Y-F IN FP0, AND FP2 SAVED.
-
-	mov.l		XFRAC(%a6),FFRAC(%a6)
-	and.l		&0xFE000000,FFRAC(%a6)
-	or.l		&0x01000000,FFRAC(%a6)	# F OBTAINED
-	cmp.l		%d1,&0x3FFF8000		# SEE IF 1+Z > 1
-	bge.b		KISZERO
-
-KISNEG1:
-	fmov.s		TWO(%pc),%fp0
-	mov.l		&0x3fff0000,F(%a6)
-	clr.l		F+8(%a6)
-	fsub.x		F(%a6),%fp0		# 2-F
-	mov.l		FFRAC(%a6),%d1
-	and.l		&0x7E000000,%d1
-	asr.l		&8,%d1
-	asr.l		&8,%d1
-	asr.l		&4,%d1			# D0 CONTAINS DISPLACEMENT FOR 1/F
-	fadd.x		%fp1,%fp1		# GET 2Z
-	fmovm.x		&0xc,-(%sp)		# SAVE FP2  {%fp2/%fp3}
-	fadd.x		%fp1,%fp0		# FP0 IS Y-F = (2-F)+2Z
-	lea		LOGTBL(%pc),%a0		# A0 IS ADDRESS OF 1/F
-	add.l		%d1,%a0
-	fmov.s		negone(%pc),%fp1	# FP1 IS K = -1
-	bra.w		LP1CONT1
-
-KISZERO:
-	fmov.s		one(%pc),%fp0
-	mov.l		&0x3fff0000,F(%a6)
-	clr.l		F+8(%a6)
-	fsub.x		F(%a6),%fp0		# 1-F
-	mov.l		FFRAC(%a6),%d1
-	and.l		&0x7E000000,%d1
-	asr.l		&8,%d1
-	asr.l		&8,%d1
-	asr.l		&4,%d1
-	fadd.x		%fp1,%fp0		# FP0 IS Y-F
-	fmovm.x		&0xc,-(%sp)		# FP2 SAVED {%fp2/%fp3}
-	lea		LOGTBL(%pc),%a0
-	add.l		%d1,%a0			# A0 IS ADDRESS OF 1/F
-	fmov.s		zero(%pc),%fp1		# FP1 IS K = 0
-	bra.w		LP1CONT1
-
-LP1NEG0:
-#--FPCR SAVED. D0 IS X IN COMPACT FORM.
-	cmp.l		%d1,&0
-	blt.b		LP1NEG
-LP1ZERO:
-	fmov.s		negone(%pc),%fp0
-
-	fmov.l		%d0,%fpcr
-	bra		t_dz
-
-LP1NEG:
-	fmov.s		zero(%pc),%fp0
-
-	fmov.l		%d0,%fpcr
-	bra		t_operr
-
-	global		slognp1d
-#--ENTRY POINT FOR LOG(1+Z) FOR DENORMALIZED INPUT
-# Simply return the denorm
-slognp1d:
-	bra		t_extdnrm
-
-#########################################################################
-# satanh():  computes the inverse hyperbolic tangent of a norm input	#
-# satanhd(): computes the inverse hyperbolic tangent of a denorm input	#
-#									#
-# INPUT ***************************************************************	#
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = arctanh(X)						#
-#									#
-# ACCURACY and MONOTONICITY *******************************************	#
-#	The returned result is within 3 ulps in	64 significant bit,	#
-#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM ***********************************************************	#
-#									#
-#	ATANH								#
-#	1. If |X| >= 1, go to 3.					#
-#									#
-#	2. (|X| < 1) Calculate atanh(X) by				#
-#		sgn := sign(X)						#
-#		y := |X|						#
-#		z := 2y/(1-y)						#
-#		atanh(X) := sgn * (1/2) * logp1(z)			#
-#		Exit.							#
-#									#
-#	3. If |X| > 1, go to 5.						#
-#									#
-#	4. (|X| = 1) Generate infinity with an appropriate sign and	#
-#		divide-by-zero by					#
-#		sgn := sign(X)						#
-#		atan(X) := sgn / (+0).					#
-#		Exit.							#
-#									#
-#	5. (|X| > 1) Generate an invalid operation by 0 * infinity.	#
-#		Exit.							#
-#									#
-#########################################################################
-
-	global		satanh
-satanh:
-	mov.l		(%a0),%d1
-	mov.w		4(%a0),%d1
-	and.l		&0x7FFFFFFF,%d1
-	cmp.l		%d1,&0x3FFF8000
-	bge.b		ATANHBIG
-
-#--THIS IS THE USUAL CASE, |X| < 1
-#--Y = |X|, Z = 2Y/(1-Y), ATANH(X) = SIGN(X) * (1/2) * LOG1P(Z).
-
-	fabs.x		(%a0),%fp0		# Y = |X|
-	fmov.x		%fp0,%fp1
-	fneg.x		%fp1			# -Y
-	fadd.x		%fp0,%fp0		# 2Y
-	fadd.s		&0x3F800000,%fp1	# 1-Y
-	fdiv.x		%fp1,%fp0		# 2Y/(1-Y)
-	mov.l		(%a0),%d1
-	and.l		&0x80000000,%d1
-	or.l		&0x3F000000,%d1		# SIGN(X)*HALF
-	mov.l		%d1,-(%sp)
-
-	mov.l		%d0,-(%sp)		# save rnd prec,mode
-	clr.l		%d0			# pass ext prec,RN
-	fmovm.x		&0x01,-(%sp)		# save Z on stack
-	lea		(%sp),%a0		# pass ptr to Z
-	bsr		slognp1			# LOG1P(Z)
-	add.l		&0xc,%sp		# clear Z from stack
-
-	mov.l		(%sp)+,%d0		# fetch old prec,mode
-	fmov.l		%d0,%fpcr		# load it
-	mov.b		&FMUL_OP,%d1		# last inst is MUL
-	fmul.s		(%sp)+,%fp0
-	bra		t_catch
-
-ATANHBIG:
-	fabs.x		(%a0),%fp0		# |X|
-	fcmp.s		%fp0,&0x3F800000
-	fbgt		t_operr
-	bra		t_dz
-
-	global		satanhd
-#--ATANH(X) = X FOR DENORMALIZED X
-satanhd:
-	bra		t_extdnrm
-
-#########################################################################
-# slog10():  computes the base-10 logarithm of a normalized input	#
-# slog10d(): computes the base-10 logarithm of a denormalized input	#
-# slog2():   computes the base-2 logarithm of a normalized input	#
-# slog2d():  computes the base-2 logarithm of a denormalized input	#
-#									#
-# INPUT *************************************************************** #
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = log_10(X) or log_2(X)					#
-#									#
-# ACCURACY and MONOTONICITY *******************************************	#
-#	The returned result is within 1.7 ulps in 64 significant bit,	#
-#	i.e. within 0.5003 ulp to 53 bits if the result is subsequently	#
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM ***********************************************************	#
-#									#
-#       slog10d:							#
-#									#
-#       Step 0.	If X < 0, create a NaN and raise the invalid operation	#
-#               flag. Otherwise, save FPCR in D1; set FpCR to default.	#
-#       Notes:  Default means round-to-nearest mode, no floating-point	#
-#               traps, and precision control = double extended.		#
-#									#
-#       Step 1. Call slognd to obtain Y = log(X), the natural log of X.	#
-#       Notes:  Even if X is denormalized, log(X) is always normalized.	#
-#									#
-#       Step 2.  Compute log_10(X) = log(X) * (1/log(10)).		#
-#            2.1 Restore the user FPCR					#
-#            2.2 Return ans := Y * INV_L10.				#
-#									#
-#       slog10:								#
-#									#
-#       Step 0. If X < 0, create a NaN and raise the invalid operation	#
-#               flag. Otherwise, save FPCR in D1; set FpCR to default.	#
-#       Notes:  Default means round-to-nearest mode, no floating-point	#
-#               traps, and precision control = double extended.		#
-#									#
-#       Step 1. Call sLogN to obtain Y = log(X), the natural log of X.	#
-#									#
-#       Step 2.   Compute log_10(X) = log(X) * (1/log(10)).		#
-#            2.1  Restore the user FPCR					#
-#            2.2  Return ans := Y * INV_L10.				#
-#									#
-#       sLog2d:								#
-#									#
-#       Step 0. If X < 0, create a NaN and raise the invalid operation	#
-#               flag. Otherwise, save FPCR in D1; set FpCR to default.	#
-#       Notes:  Default means round-to-nearest mode, no floating-point	#
-#               traps, and precision control = double extended.		#
-#									#
-#       Step 1. Call slognd to obtain Y = log(X), the natural log of X.	#
-#       Notes:  Even if X is denormalized, log(X) is always normalized.	#
-#									#
-#       Step 2.   Compute log_10(X) = log(X) * (1/log(2)).		#
-#            2.1  Restore the user FPCR					#
-#            2.2  Return ans := Y * INV_L2.				#
-#									#
-#       sLog2:								#
-#									#
-#       Step 0. If X < 0, create a NaN and raise the invalid operation	#
-#               flag. Otherwise, save FPCR in D1; set FpCR to default.	#
-#       Notes:  Default means round-to-nearest mode, no floating-point	#
-#               traps, and precision control = double extended.		#
-#									#
-#       Step 1. If X is not an integer power of two, i.e., X != 2^k,	#
-#               go to Step 3.						#
-#									#
-#       Step 2.   Return k.						#
-#            2.1  Get integer k, X = 2^k.				#
-#            2.2  Restore the user FPCR.				#
-#            2.3  Return ans := convert-to-double-extended(k).		#
-#									#
-#       Step 3. Call sLogN to obtain Y = log(X), the natural log of X.	#
-#									#
-#       Step 4.   Compute log_2(X) = log(X) * (1/log(2)).		#
-#            4.1  Restore the user FPCR					#
-#            4.2  Return ans := Y * INV_L2.				#
-#									#
-#########################################################################
-
-INV_L10:
-	long		0x3FFD0000,0xDE5BD8A9,0x37287195,0x00000000
-
-INV_L2:
-	long		0x3FFF0000,0xB8AA3B29,0x5C17F0BC,0x00000000
-
-	global		slog10
-#--entry point for Log10(X), X is normalized
-slog10:
-	fmov.b		&0x1,%fp0
-	fcmp.x		%fp0,(%a0)		# if operand == 1,
-	fbeq.l		ld_pzero		# return an EXACT zero
-
-	mov.l		(%a0),%d1
-	blt.w		invalid
-	mov.l		%d0,-(%sp)
-	clr.l		%d0
-	bsr		slogn			# log(X), X normal.
-	fmov.l		(%sp)+,%fpcr
-	fmul.x		INV_L10(%pc),%fp0
-	bra		t_inx2
-
-	global		slog10d
-#--entry point for Log10(X), X is denormalized
-slog10d:
-	mov.l		(%a0),%d1
-	blt.w		invalid
-	mov.l		%d0,-(%sp)
-	clr.l		%d0
-	bsr		slognd			# log(X), X denorm.
-	fmov.l		(%sp)+,%fpcr
-	fmul.x		INV_L10(%pc),%fp0
-	bra		t_minx2
-
-	global		slog2
-#--entry point for Log2(X), X is normalized
-slog2:
-	mov.l		(%a0),%d1
-	blt.w		invalid
-
-	mov.l		8(%a0),%d1
-	bne.b		continue		# X is not 2^k
-
-	mov.l		4(%a0),%d1
-	and.l		&0x7FFFFFFF,%d1
-	bne.b		continue
-
-#--X = 2^k.
-	mov.w		(%a0),%d1
-	and.l		&0x00007FFF,%d1
-	sub.l		&0x3FFF,%d1
-	beq.l		ld_pzero
-	fmov.l		%d0,%fpcr
-	fmov.l		%d1,%fp0
-	bra		t_inx2
-
-continue:
-	mov.l		%d0,-(%sp)
-	clr.l		%d0
-	bsr		slogn			# log(X), X normal.
-	fmov.l		(%sp)+,%fpcr
-	fmul.x		INV_L2(%pc),%fp0
-	bra		t_inx2
-
-invalid:
-	bra		t_operr
-
-	global		slog2d
-#--entry point for Log2(X), X is denormalized
-slog2d:
-	mov.l		(%a0),%d1
-	blt.w		invalid
-	mov.l		%d0,-(%sp)
-	clr.l		%d0
-	bsr		slognd			# log(X), X denorm.
-	fmov.l		(%sp)+,%fpcr
-	fmul.x		INV_L2(%pc),%fp0
-	bra		t_minx2
-
-#########################################################################
-# stwotox():  computes 2**X for a normalized input			#
-# stwotoxd(): computes 2**X for a denormalized input			#
-# stentox():  computes 10**X for a normalized input			#
-# stentoxd(): computes 10**X for a denormalized input			#
-#									#
-# INPUT ***************************************************************	#
-#	a0 = pointer to extended precision input			#
-#	d0 = round precision,mode					#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = 2**X or 10**X						#
-#									#
-# ACCURACY and MONOTONICITY *******************************************	#
-#	The returned result is within 2 ulps in 64 significant bit,	#
-#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
-#	rounded to double precision. The result is provably monotonic	#
-#	in double precision.						#
-#									#
-# ALGORITHM ***********************************************************	#
-#									#
-#	twotox								#
-#	1. If |X| > 16480, go to ExpBig.				#
-#									#
-#	2. If |X| < 2**(-70), go to ExpSm.				#
-#									#
-#	3. Decompose X as X = N/64 + r where |r| <= 1/128. Furthermore	#
-#		decompose N as						#
-#		 N = 64(M + M') + j,  j = 0,1,2,...,63.			#
-#									#
-#	4. Overwrite r := r * log2. Then				#
-#		2**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r).		#
-#		Go to expr to compute that expression.			#
-#									#
-#	tentox								#
-#	1. If |X| > 16480*log_10(2) (base 10 log of 2), go to ExpBig.	#
-#									#
-#	2. If |X| < 2**(-70), go to ExpSm.				#
-#									#
-#	3. Set y := X*log_2(10)*64 (base 2 log of 10). Set		#
-#		N := round-to-int(y). Decompose N as			#
-#		 N = 64(M + M') + j,  j = 0,1,2,...,63.			#
-#									#
-#	4. Define r as							#
-#		r := ((X - N*L1)-N*L2) * L10				#
-#		where L1, L2 are the leading and trailing parts of	#
-#		log_10(2)/64 and L10 is the natural log of 10. Then	#
-#		10**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r).		#
-#		Go to expr to compute that expression.			#
-#									#
-#	expr								#
-#	1. Fetch 2**(j/64) from table as Fact1 and Fact2.		#
-#									#
-#	2. Overwrite Fact1 and Fact2 by					#
-#		Fact1 := 2**(M) * Fact1					#
-#		Fact2 := 2**(M) * Fact2					#
-#		Thus Fact1 + Fact2 = 2**(M) * 2**(j/64).		#
-#									#
-#	3. Calculate P where 1 + P approximates exp(r):			#
-#		P = r + r*r*(A1+r*(A2+...+r*A5)).			#
-#									#
-#	4. Let AdjFact := 2**(M'). Return				#
-#		AdjFact * ( Fact1 + ((Fact1*P) + Fact2) ).		#
-#		Exit.							#
-#									#
-#	ExpBig								#
-#	1. Generate overflow by Huge * Huge if X > 0; otherwise,	#
-#	        generate underflow by Tiny * Tiny.			#
-#									#
-#	ExpSm								#
-#	1. Return 1 + X.						#
-#									#
-#########################################################################
-
-L2TEN64:
-	long		0x406A934F,0x0979A371	# 64LOG10/LOG2
-L10TWO1:
-	long		0x3F734413,0x509F8000	# LOG2/64LOG10
-
-L10TWO2:
-	long		0xBFCD0000,0xC0219DC1,0xDA994FD2,0x00000000
-
-LOG10:	long		0x40000000,0x935D8DDD,0xAAA8AC17,0x00000000
-
-LOG2:	long		0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000
-
-EXPA5:	long		0x3F56C16D,0x6F7BD0B2
-EXPA4:	long		0x3F811112,0x302C712C
-EXPA3:	long		0x3FA55555,0x55554CC1
-EXPA2:	long		0x3FC55555,0x55554A54
-EXPA1:	long		0x3FE00000,0x00000000,0x00000000,0x00000000
-
-TEXPTBL:
-	long		0x3FFF0000,0x80000000,0x00000000,0x3F738000
-	long		0x3FFF0000,0x8164D1F3,0xBC030773,0x3FBEF7CA
-	long		0x3FFF0000,0x82CD8698,0xAC2BA1D7,0x3FBDF8A9
-	long		0x3FFF0000,0x843A28C3,0xACDE4046,0x3FBCD7C9
-	long		0x3FFF0000,0x85AAC367,0xCC487B15,0xBFBDE8DA
-	long		0x3FFF0000,0x871F6196,0x9E8D1010,0x3FBDE85C
-	long		0x3FFF0000,0x88980E80,0x92DA8527,0x3FBEBBF1
-	long		0x3FFF0000,0x8A14D575,0x496EFD9A,0x3FBB80CA
-	long		0x3FFF0000,0x8B95C1E3,0xEA8BD6E7,0xBFBA8373
-	long		0x3FFF0000,0x8D1ADF5B,0x7E5BA9E6,0xBFBE9670
-	long		0x3FFF0000,0x8EA4398B,0x45CD53C0,0x3FBDB700
-	long		0x3FFF0000,0x9031DC43,0x1466B1DC,0x3FBEEEB0
-	long		0x3FFF0000,0x91C3D373,0xAB11C336,0x3FBBFD6D
-	long		0x3FFF0000,0x935A2B2F,0x13E6E92C,0xBFBDB319
-	long		0x3FFF0000,0x94F4EFA8,0xFEF70961,0x3FBDBA2B
-	long		0x3FFF0000,0x96942D37,0x20185A00,0x3FBE91D5
-	long		0x3FFF0000,0x9837F051,0x8DB8A96F,0x3FBE8D5A
-	long		0x3FFF0000,0x99E04593,0x20B7FA65,0xBFBCDE7B
-	long		0x3FFF0000,0x9B8D39B9,0xD54E5539,0xBFBEBAAF
-	long		0x3FFF0000,0x9D3ED9A7,0x2CFFB751,0xBFBD86DA
-	long		0x3FFF0000,0x9EF53260,0x91A111AE,0xBFBEBEDD
-	long		0x3FFF0000,0xA0B0510F,0xB9714FC2,0x3FBCC96E
-	long		0x3FFF0000,0xA2704303,0x0C496819,0xBFBEC90B
-	long		0x3FFF0000,0xA43515AE,0x09E6809E,0x3FBBD1DB
-	long		0x3FFF0000,0xA5FED6A9,0xB15138EA,0x3FBCE5EB
-	long		0x3FFF0000,0xA7CD93B4,0xE965356A,0xBFBEC274
-	long		0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x3FBEA83C
-	long		0x3FFF0000,0xAB7A39B5,0xA93ED337,0x3FBECB00
-	long		0x3FFF0000,0xAD583EEA,0x42A14AC6,0x3FBE9301
-	long		0x3FFF0000,0xAF3B78AD,0x690A4375,0xBFBD8367
-	long		0x3FFF0000,0xB123F581,0xD2AC2590,0xBFBEF05F
-	long		0x3FFF0000,0xB311C412,0xA9112489,0x3FBDFB3C
-	long		0x3FFF0000,0xB504F333,0xF9DE6484,0x3FBEB2FB
-	long		0x3FFF0000,0xB6FD91E3,0x28D17791,0x3FBAE2CB
-	long		0x3FFF0000,0xB8FBAF47,0x62FB9EE9,0x3FBCDC3C
-	long		0x3FFF0000,0xBAFF5AB2,0x133E45FB,0x3FBEE9AA
-	long		0x3FFF0000,0xBD08A39F,0x580C36BF,0xBFBEAEFD
-	long		0x3FFF0000,0xBF1799B6,0x7A731083,0xBFBCBF51
-	long		0x3FFF0000,0xC12C4CCA,0x66709456,0x3FBEF88A
-	long		0x3FFF0000,0xC346CCDA,0x24976407,0x3FBD83B2
-	long		0x3FFF0000,0xC5672A11,0x5506DADD,0x3FBDF8AB
-	long		0x3FFF0000,0xC78D74C8,0xABB9B15D,0xBFBDFB17
-	long		0x3FFF0000,0xC9B9BD86,0x6E2F27A3,0xBFBEFE3C
-	long		0x3FFF0000,0xCBEC14FE,0xF2727C5D,0xBFBBB6F8
-	long		0x3FFF0000,0xCE248C15,0x1F8480E4,0xBFBCEE53
-	long		0x3FFF0000,0xD06333DA,0xEF2B2595,0xBFBDA4AE
-	long		0x3FFF0000,0xD2A81D91,0xF12AE45A,0x3FBC9124
-	long		0x3FFF0000,0xD4F35AAB,0xCFEDFA1F,0x3FBEB243
-	long		0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x3FBDE69A
-	long		0x3FFF0000,0xD99D15C2,0x78AFD7B6,0xBFB8BC61
-	long		0x3FFF0000,0xDBFBB797,0xDAF23755,0x3FBDF610
-	long		0x3FFF0000,0xDE60F482,0x5E0E9124,0xBFBD8BE1
-	long		0x3FFF0000,0xE0CCDEEC,0x2A94E111,0x3FBACB12
-	long		0x3FFF0000,0xE33F8972,0xBE8A5A51,0x3FBB9BFE
-	long		0x3FFF0000,0xE5B906E7,0x7C8348A8,0x3FBCF2F4
-	long		0x3FFF0000,0xE8396A50,0x3C4BDC68,0x3FBEF22F
-	long		0x3FFF0000,0xEAC0C6E7,0xDD24392F,0xBFBDBF4A
-	long		0x3FFF0000,0xED4F301E,0xD9942B84,0x3FBEC01A
-	long		0x3FFF0000,0xEFE4B99B,0xDCDAF5CB,0x3FBE8CAC
-	long		0x3FFF0000,0xF281773C,0x59FFB13A,0xBFBCBB3F
-	long		0x3FFF0000,0xF5257D15,0x2486CC2C,0x3FBEF73A
-	long		0x3FFF0000,0xF7D0DF73,0x0AD13BB9,0xBFB8B795
-	long		0x3FFF0000,0xFA83B2DB,0x722A033A,0x3FBEF84B
-	long		0x3FFF0000,0xFD3E0C0C,0xF486C175,0xBFBEF581
-
-	set		INT,L_SCR1
-
-	set		X,FP_SCR0
-	set		XDCARE,X+2
-	set		XFRAC,X+4
-
-	set		ADJFACT,FP_SCR0
-
-	set		FACT1,FP_SCR0
-	set		FACT1HI,FACT1+4
-	set		FACT1LOW,FACT1+8
-
-	set		FACT2,FP_SCR1
-	set		FACT2HI,FACT2+4
-	set		FACT2LOW,FACT2+8
-
-	global		stwotox
-#--ENTRY POINT FOR 2**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
-stwotox:
-	fmovm.x		(%a0),&0x80		# LOAD INPUT
-
-	mov.l		(%a0),%d1
-	mov.w		4(%a0),%d1
-	fmov.x		%fp0,X(%a6)
-	and.l		&0x7FFFFFFF,%d1
-
-	cmp.l		%d1,&0x3FB98000		# |X| >= 2**(-70)?
-	bge.b		TWOOK1
-	bra.w		EXPBORS
-
-TWOOK1:
-	cmp.l		%d1,&0x400D80C0		# |X| > 16480?
-	ble.b		TWOMAIN
-	bra.w		EXPBORS
-
-TWOMAIN:
-#--USUAL CASE, 2^(-70) <= |X| <= 16480
-
-	fmov.x		%fp0,%fp1
-	fmul.s		&0x42800000,%fp1	# 64 * X
-	fmov.l		%fp1,INT(%a6)		# N = ROUND-TO-INT(64 X)
-	mov.l		%d2,-(%sp)
-	lea		TEXPTBL(%pc),%a1	# LOAD ADDRESS OF TABLE OF 2^(J/64)
-	fmov.l		INT(%a6),%fp1		# N --> FLOATING FMT
-	mov.l		INT(%a6),%d1
-	mov.l		%d1,%d2
-	and.l		&0x3F,%d1		# D0 IS J
-	asl.l		&4,%d1			# DISPLACEMENT FOR 2^(J/64)
-	add.l		%d1,%a1			# ADDRESS FOR 2^(J/64)
-	asr.l		&6,%d2			# d2 IS L, N = 64L + J
-	mov.l		%d2,%d1
-	asr.l		&1,%d1			# D0 IS M
-	sub.l		%d1,%d2			# d2 IS M', N = 64(M+M') + J
-	add.l		&0x3FFF,%d2
-
-#--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64),
-#--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN.
-#--ADJFACT = 2^(M').
-#--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.
-
-	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
-
-	fmul.s		&0x3C800000,%fp1	# (1/64)*N
-	mov.l		(%a1)+,FACT1(%a6)
-	mov.l		(%a1)+,FACT1HI(%a6)
-	mov.l		(%a1)+,FACT1LOW(%a6)
-	mov.w		(%a1)+,FACT2(%a6)
-
-	fsub.x		%fp1,%fp0		# X - (1/64)*INT(64 X)
-
-	mov.w		(%a1)+,FACT2HI(%a6)
-	clr.w		FACT2HI+2(%a6)
-	clr.l		FACT2LOW(%a6)
-	add.w		%d1,FACT1(%a6)
-	fmul.x		LOG2(%pc),%fp0		# FP0 IS R
-	add.w		%d1,FACT2(%a6)
-
-	bra.w		expr
-
-EXPBORS:
-#--FPCR, D0 SAVED
-	cmp.l		%d1,&0x3FFF8000
-	bgt.b		TEXPBIG
-
-#--|X| IS SMALL, RETURN 1 + X
-
-	fmov.l		%d0,%fpcr		# restore users round prec,mode
-	fadd.s		&0x3F800000,%fp0	# RETURN 1 + X
-	bra		t_pinx2
-
-TEXPBIG:
-#--|X| IS LARGE, GENERATE OVERFLOW IF X > 0; ELSE GENERATE UNDERFLOW
-#--REGISTERS SAVE SO FAR ARE FPCR AND  D0
-	mov.l		X(%a6),%d1
-	cmp.l		%d1,&0
-	blt.b		EXPNEG
-
-	bra		t_ovfl2			# t_ovfl expects positive value
-
-EXPNEG:
-	bra		t_unfl2			# t_unfl expects positive value
-
-	global		stwotoxd
-stwotoxd:
-#--ENTRY POINT FOR 2**(X) FOR DENORMALIZED ARGUMENT
-
-	fmov.l		%d0,%fpcr		# set user's rounding mode/precision
-	fmov.s		&0x3F800000,%fp0	# RETURN 1 + X
-	mov.l		(%a0),%d1
-	or.l		&0x00800001,%d1
-	fadd.s		%d1,%fp0
-	bra		t_pinx2
-
-	global		stentox
-#--ENTRY POINT FOR 10**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
-stentox:
-	fmovm.x		(%a0),&0x80		# LOAD INPUT
-
-	mov.l		(%a0),%d1
-	mov.w		4(%a0),%d1
-	fmov.x		%fp0,X(%a6)
-	and.l		&0x7FFFFFFF,%d1
-
-	cmp.l		%d1,&0x3FB98000		# |X| >= 2**(-70)?
-	bge.b		TENOK1
-	bra.w		EXPBORS
-
-TENOK1:
-	cmp.l		%d1,&0x400B9B07		# |X| <= 16480*log2/log10 ?
-	ble.b		TENMAIN
-	bra.w		EXPBORS
-
-TENMAIN:
-#--USUAL CASE, 2^(-70) <= |X| <= 16480 LOG 2 / LOG 10
-
-	fmov.x		%fp0,%fp1
-	fmul.d		L2TEN64(%pc),%fp1	# X*64*LOG10/LOG2
-	fmov.l		%fp1,INT(%a6)		# N=INT(X*64*LOG10/LOG2)
-	mov.l		%d2,-(%sp)
-	lea		TEXPTBL(%pc),%a1	# LOAD ADDRESS OF TABLE OF 2^(J/64)
-	fmov.l		INT(%a6),%fp1		# N --> FLOATING FMT
-	mov.l		INT(%a6),%d1
-	mov.l		%d1,%d2
-	and.l		&0x3F,%d1		# D0 IS J
-	asl.l		&4,%d1			# DISPLACEMENT FOR 2^(J/64)
-	add.l		%d1,%a1			# ADDRESS FOR 2^(J/64)
-	asr.l		&6,%d2			# d2 IS L, N = 64L + J
-	mov.l		%d2,%d1
-	asr.l		&1,%d1			# D0 IS M
-	sub.l		%d1,%d2			# d2 IS M', N = 64(M+M') + J
-	add.l		&0x3FFF,%d2
-
-#--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64),
-#--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN.
-#--ADJFACT = 2^(M').
-#--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.
-	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
-
-	fmov.x		%fp1,%fp2
-
-	fmul.d		L10TWO1(%pc),%fp1	# N*(LOG2/64LOG10)_LEAD
-	mov.l		(%a1)+,FACT1(%a6)
-
-	fmul.x		L10TWO2(%pc),%fp2	# N*(LOG2/64LOG10)_TRAIL
-
-	mov.l		(%a1)+,FACT1HI(%a6)
-	mov.l		(%a1)+,FACT1LOW(%a6)
-	fsub.x		%fp1,%fp0		# X - N L_LEAD
-	mov.w		(%a1)+,FACT2(%a6)
-
-	fsub.x		%fp2,%fp0		# X - N L_TRAIL
-
-	mov.w		(%a1)+,FACT2HI(%a6)
-	clr.w		FACT2HI+2(%a6)
-	clr.l		FACT2LOW(%a6)
-
-	fmul.x		LOG10(%pc),%fp0		# FP0 IS R
-	add.w		%d1,FACT1(%a6)
-	add.w		%d1,FACT2(%a6)
-
-expr:
-#--FPCR, FP2, FP3 ARE SAVED IN ORDER AS SHOWN.
-#--ADJFACT CONTAINS 2**(M'), FACT1 + FACT2 = 2**(M) * 2**(J/64).
-#--FP0 IS R. THE FOLLOWING CODE COMPUTES
-#--	2**(M'+M) * 2**(J/64) * EXP(R)
-
-	fmov.x		%fp0,%fp1
-	fmul.x		%fp1,%fp1		# FP1 IS S = R*R
-
-	fmov.d		EXPA5(%pc),%fp2		# FP2 IS A5
-	fmov.d		EXPA4(%pc),%fp3		# FP3 IS A4
-
-	fmul.x		%fp1,%fp2		# FP2 IS S*A5
-	fmul.x		%fp1,%fp3		# FP3 IS S*A4
-
-	fadd.d		EXPA3(%pc),%fp2		# FP2 IS A3+S*A5
-	fadd.d		EXPA2(%pc),%fp3		# FP3 IS A2+S*A4
-
-	fmul.x		%fp1,%fp2		# FP2 IS S*(A3+S*A5)
-	fmul.x		%fp1,%fp3		# FP3 IS S*(A2+S*A4)
-
-	fadd.d		EXPA1(%pc),%fp2		# FP2 IS A1+S*(A3+S*A5)
-	fmul.x		%fp0,%fp3		# FP3 IS R*S*(A2+S*A4)
-
-	fmul.x		%fp1,%fp2		# FP2 IS S*(A1+S*(A3+S*A5))
-	fadd.x		%fp3,%fp0		# FP0 IS R+R*S*(A2+S*A4)
-	fadd.x		%fp2,%fp0		# FP0 IS EXP(R) - 1
-
-	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
-
-#--FINAL RECONSTRUCTION PROCESS
-#--EXP(X) = 2^M*2^(J/64) + 2^M*2^(J/64)*(EXP(R)-1)  -  (1 OR 0)
-
-	fmul.x		FACT1(%a6),%fp0
-	fadd.x		FACT2(%a6),%fp0
-	fadd.x		FACT1(%a6),%fp0
-
-	fmov.l		%d0,%fpcr		# restore users round prec,mode
-	mov.w		%d2,ADJFACT(%a6)	# INSERT EXPONENT
-	mov.l		(%sp)+,%d2
-	mov.l		&0x80000000,ADJFACT+4(%a6)
-	clr.l		ADJFACT+8(%a6)
-	mov.b		&FMUL_OP,%d1		# last inst is MUL
-	fmul.x		ADJFACT(%a6),%fp0	# FINAL ADJUSTMENT
-	bra		t_catch
-
-	global		stentoxd
-stentoxd:
-#--ENTRY POINT FOR 10**(X) FOR DENORMALIZED ARGUMENT
-
-	fmov.l		%d0,%fpcr		# set user's rounding mode/precision
-	fmov.s		&0x3F800000,%fp0	# RETURN 1 + X
-	mov.l		(%a0),%d1
-	or.l		&0x00800001,%d1
-	fadd.s		%d1,%fp0
-	bra		t_pinx2
-
-#########################################################################
-# sscale(): computes the destination operand scaled by the source	#
-#	    operand. If the absoulute value of the source operand is	#
-#	    >= 2^14, an overflow or underflow is returned.		#
-#									#
-# INPUT *************************************************************** #
-#	a0  = pointer to double-extended source operand X		#
-#	a1  = pointer to double-extended destination operand Y		#
-#									#
-# OUTPUT ************************************************************** #
-#	fp0 =  scale(X,Y)						#
-#									#
-#########################################################################
-
-set	SIGN,		L_SCR1
-
-	global		sscale
-sscale:
-	mov.l		%d0,-(%sp)		# store off ctrl bits for now
-
-	mov.w		DST_EX(%a1),%d1		# get dst exponent
-	smi.b		SIGN(%a6)		# use SIGN to hold dst sign
-	andi.l		&0x00007fff,%d1		# strip sign from dst exp
-
-	mov.w		SRC_EX(%a0),%d0		# check src bounds
-	andi.w		&0x7fff,%d0		# clr src sign bit
-	cmpi.w		%d0,&0x3fff		# is src ~ ZERO?
-	blt.w		src_small		# yes
-	cmpi.w		%d0,&0x400c		# no; is src too big?
-	bgt.w		src_out			# yes
-
-#
-# Source is within 2^14 range.
-#
-src_ok:
-	fintrz.x	SRC(%a0),%fp0		# calc int of src
-	fmov.l		%fp0,%d0		# int src to d0
-# don't want any accrued bits from the fintrz showing up later since
-# we may need to read the fpsr for the last fp op in t_catch2().
-	fmov.l		&0x0,%fpsr
-
-	tst.b		DST_HI(%a1)		# is dst denormalized?
-	bmi.b		sok_norm
-
-# the dst is a DENORM. normalize the DENORM and add the adjustment to
-# the src value. then, jump to the norm part of the routine.
-sok_dnrm:
-	mov.l		%d0,-(%sp)		# save src for now
-
-	mov.w		DST_EX(%a1),FP_SCR0_EX(%a6) # make a copy
-	mov.l		DST_HI(%a1),FP_SCR0_HI(%a6)
-	mov.l		DST_LO(%a1),FP_SCR0_LO(%a6)
-
-	lea		FP_SCR0(%a6),%a0	# pass ptr to DENORM
-	bsr.l		norm			# normalize the DENORM
-	neg.l		%d0
-	add.l		(%sp)+,%d0		# add adjustment to src
-
-	fmovm.x		FP_SCR0(%a6),&0x80	# load normalized DENORM
-
-	cmpi.w		%d0,&-0x3fff		# is the shft amt really low?
-	bge.b		sok_norm2		# thank goodness no
-
-# the multiply factor that we're trying to create should be a denorm
-# for the multiply to work. therefore, we're going to actually do a
-# multiply with a denorm which will cause an unimplemented data type
-# exception to be put into the machine which will be caught and corrected
-# later. we don't do this with the DENORMs above because this method
-# is slower. but, don't fret, I don't see it being used much either.
-	fmov.l		(%sp)+,%fpcr		# restore user fpcr
-	mov.l		&0x80000000,%d1		# load normalized mantissa
-	subi.l		&-0x3fff,%d0		# how many should we shift?
-	neg.l		%d0			# make it positive
-	cmpi.b		%d0,&0x20		# is it > 32?
-	bge.b		sok_dnrm_32		# yes
-	lsr.l		%d0,%d1			# no; bit stays in upper lw
-	clr.l		-(%sp)			# insert zero low mantissa
-	mov.l		%d1,-(%sp)		# insert new high mantissa
-	clr.l		-(%sp)			# make zero exponent
-	bra.b		sok_norm_cont
-sok_dnrm_32:
-	subi.b		&0x20,%d0		# get shift count
-	lsr.l		%d0,%d1			# make low mantissa longword
-	mov.l		%d1,-(%sp)		# insert new low mantissa
-	clr.l		-(%sp)			# insert zero high mantissa
-	clr.l		-(%sp)			# make zero exponent
-	bra.b		sok_norm_cont
-
-# the src will force the dst to a DENORM value or worse. so, let's
-# create an fp multiply that will create the result.
-sok_norm:
-	fmovm.x		DST(%a1),&0x80		# load fp0 with normalized src
-sok_norm2:
-	fmov.l		(%sp)+,%fpcr		# restore user fpcr
-
-	addi.w		&0x3fff,%d0		# turn src amt into exp value
-	swap		%d0			# put exponent in high word
-	clr.l		-(%sp)			# insert new exponent
-	mov.l		&0x80000000,-(%sp)	# insert new high mantissa
-	mov.l		%d0,-(%sp)		# insert new lo mantissa
-
-sok_norm_cont:
-	fmov.l		%fpcr,%d0		# d0 needs fpcr for t_catch2
-	mov.b		&FMUL_OP,%d1		# last inst is MUL
-	fmul.x		(%sp)+,%fp0		# do the multiply
-	bra		t_catch2		# catch any exceptions
-
-#
-# Source is outside of 2^14 range.  Test the sign and branch
-# to the appropriate exception handler.
-#
-src_out:
-	mov.l		(%sp)+,%d0		# restore ctrl bits
-	exg		%a0,%a1			# swap src,dst ptrs
-	tst.b		SRC_EX(%a1)		# is src negative?
-	bmi		t_unfl			# yes; underflow
-	bra		t_ovfl_sc		# no; overflow
-
-#
-# The source input is below 1, so we check for denormalized numbers
-# and set unfl.
-#
-src_small:
-	tst.b		DST_HI(%a1)		# is dst denormalized?
-	bpl.b		ssmall_done		# yes
-
-	mov.l		(%sp)+,%d0
-	fmov.l		%d0,%fpcr		# no; load control bits
-	mov.b		&FMOV_OP,%d1		# last inst is MOVE
-	fmov.x		DST(%a1),%fp0		# simply return dest
-	bra		t_catch2
-ssmall_done:
-	mov.l		(%sp)+,%d0		# load control bits into d1
-	mov.l		%a1,%a0			# pass ptr to dst
-	bra		t_resdnrm
-
-#########################################################################
-# smod(): computes the fp MOD of the input values X,Y.			#
-# srem(): computes the fp (IEEE) REM of the input values X,Y.		#
-#									#
-# INPUT *************************************************************** #
-#	a0 = pointer to extended precision input X			#
-#	a1 = pointer to extended precision input Y			#
-#	d0 = round precision,mode					#
-#									#
-#	The input operands X and Y can be either normalized or		#
-#	denormalized.							#
-#									#
-# OUTPUT ************************************************************** #
-#      fp0 = FREM(X,Y) or FMOD(X,Y)					#
-#									#
-# ALGORITHM *********************************************************** #
-#									#
-#       Step 1.  Save and strip signs of X and Y: signX := sign(X),	#
-#                signY := sign(Y), X := |X|, Y := |Y|,			#
-#                signQ := signX EOR signY. Record whether MOD or REM	#
-#                is requested.						#
-#									#
-#       Step 2.  Set L := expo(X)-expo(Y), k := 0, Q := 0.		#
-#                If (L < 0) then					#
-#                   R := X, go to Step 4.				#
-#                else							#
-#                   R := 2^(-L)X, j := L.				#
-#                endif							#
-#									#
-#       Step 3.  Perform MOD(X,Y)					#
-#            3.1 If R = Y, go to Step 9.				#
-#            3.2 If R > Y, then { R := R - Y, Q := Q + 1}		#
-#            3.3 If j = 0, go to Step 4.				#
-#            3.4 k := k + 1, j := j - 1, Q := 2Q, R := 2R. Go to	#
-#                Step 3.1.						#
-#									#
-#       Step 4.  At this point, R = X - QY = MOD(X,Y). Set		#
-#                Last_Subtract := false (used in Step 7 below). If	#
-#                MOD is requested, go to Step 6.			#
-#									#
-#       Step 5.  R = MOD(X,Y), but REM(X,Y) is requested.		#
-#            5.1 If R < Y/2, then R = MOD(X,Y) = REM(X,Y). Go to	#
-#                Step 6.						#
-#            5.2 If R > Y/2, then { set Last_Subtract := true,		#
-#                Q := Q + 1, Y := signY*Y }. Go to Step 6.		#
-#            5.3 This is the tricky case of R = Y/2. If Q is odd,	#
-#                then { Q := Q + 1, signX := -signX }.			#
-#									#
-#       Step 6.  R := signX*R.						#
-#									#
-#       Step 7.  If Last_Subtract = true, R := R - Y.			#
-#									#
-#       Step 8.  Return signQ, last 7 bits of Q, and R as required.	#
-#									#
-#       Step 9.  At this point, R = 2^(-j)*X - Q Y = Y. Thus,		#
-#                X = 2^(j)*(Q+1)Y. set Q := 2^(j)*(Q+1),		#
-#                R := 0. Return signQ, last 7 bits of Q, and R.		#
-#									#
-#########################################################################
-
-	set		Mod_Flag,L_SCR3
-	set		Sc_Flag,L_SCR3+1
-
-	set		SignY,L_SCR2
-	set		SignX,L_SCR2+2
-	set		SignQ,L_SCR3+2
-
-	set		Y,FP_SCR0
-	set		Y_Hi,Y+4
-	set		Y_Lo,Y+8
-
-	set		R,FP_SCR1
-	set		R_Hi,R+4
-	set		R_Lo,R+8
-
-Scale:
-	long		0x00010000,0x80000000,0x00000000,0x00000000
-
-	global		smod
-smod:
-	clr.b		FPSR_QBYTE(%a6)
-	mov.l		%d0,-(%sp)		# save ctrl bits
-	clr.b		Mod_Flag(%a6)
-	bra.b		Mod_Rem
-
-	global		srem
-srem:
-	clr.b		FPSR_QBYTE(%a6)
-	mov.l		%d0,-(%sp)		# save ctrl bits
-	mov.b		&0x1,Mod_Flag(%a6)
-
-Mod_Rem:
-#..Save sign of X and Y
-	movm.l		&0x3f00,-(%sp)		# save data registers
-	mov.w		SRC_EX(%a0),%d3
-	mov.w		%d3,SignY(%a6)
-	and.l		&0x00007FFF,%d3		# Y := |Y|
-
-#
-	mov.l		SRC_HI(%a0),%d4
-	mov.l		SRC_LO(%a0),%d5		# (D3,D4,D5) is |Y|
-
-	tst.l		%d3
-	bne.b		Y_Normal
-
-	mov.l		&0x00003FFE,%d3		# $3FFD + 1
-	tst.l		%d4
-	bne.b		HiY_not0
-
-HiY_0:
-	mov.l		%d5,%d4
-	clr.l		%d5
-	sub.l		&32,%d3
-	clr.l		%d6
-	bfffo		%d4{&0:&32},%d6
-	lsl.l		%d6,%d4
-	sub.l		%d6,%d3			# (D3,D4,D5) is normalized
-#	                                        ...with bias $7FFD
-	bra.b		Chk_X
-
-HiY_not0:
-	clr.l		%d6
-	bfffo		%d4{&0:&32},%d6
-	sub.l		%d6,%d3
-	lsl.l		%d6,%d4
-	mov.l		%d5,%d7			# a copy of D5
-	lsl.l		%d6,%d5
-	neg.l		%d6
-	add.l		&32,%d6
-	lsr.l		%d6,%d7
-	or.l		%d7,%d4			# (D3,D4,D5) normalized
-#                                       ...with bias $7FFD
-	bra.b		Chk_X
-
-Y_Normal:
-	add.l		&0x00003FFE,%d3		# (D3,D4,D5) normalized
-#                                       ...with bias $7FFD
-
-Chk_X:
-	mov.w		DST_EX(%a1),%d0
-	mov.w		%d0,SignX(%a6)
-	mov.w		SignY(%a6),%d1
-	eor.l		%d0,%d1
-	and.l		&0x00008000,%d1
-	mov.w		%d1,SignQ(%a6)		# sign(Q) obtained
-	and.l		&0x00007FFF,%d0
-	mov.l		DST_HI(%a1),%d1
-	mov.l		DST_LO(%a1),%d2		# (D0,D1,D2) is |X|
-	tst.l		%d0
-	bne.b		X_Normal
-	mov.l		&0x00003FFE,%d0
-	tst.l		%d1
-	bne.b		HiX_not0
-
-HiX_0:
-	mov.l		%d2,%d1
-	clr.l		%d2
-	sub.l		&32,%d0
-	clr.l		%d6
-	bfffo		%d1{&0:&32},%d6
-	lsl.l		%d6,%d1
-	sub.l		%d6,%d0			# (D0,D1,D2) is normalized
-#                                       ...with bias $7FFD
-	bra.b		Init
-
-HiX_not0:
-	clr.l		%d6
-	bfffo		%d1{&0:&32},%d6
-	sub.l		%d6,%d0
-	lsl.l		%d6,%d1
-	mov.l		%d2,%d7			# a copy of D2
-	lsl.l		%d6,%d2
-	neg.l		%d6
-	add.l		&32,%d6
-	lsr.l		%d6,%d7
-	or.l		%d7,%d1			# (D0,D1,D2) normalized
-#                                       ...with bias $7FFD
-	bra.b		Init
-
-X_Normal:
-	add.l		&0x00003FFE,%d0		# (D0,D1,D2) normalized
-#                                       ...with bias $7FFD
-
-Init:
-#
-	mov.l		%d3,L_SCR1(%a6)		# save biased exp(Y)
-	mov.l		%d0,-(%sp)		# save biased exp(X)
-	sub.l		%d3,%d0			# L := expo(X)-expo(Y)
-
-	clr.l		%d6			# D6 := carry <- 0
-	clr.l		%d3			# D3 is Q
-	mov.l		&0,%a1			# A1 is k; j+k=L, Q=0
-
-#..(Carry,D1,D2) is R
-	tst.l		%d0
-	bge.b		Mod_Loop_pre
-
-#..expo(X) < expo(Y). Thus X = mod(X,Y)
-#
-	mov.l		(%sp)+,%d0		# restore d0
-	bra.w		Get_Mod
-
-Mod_Loop_pre:
-	addq.l		&0x4,%sp		# erase exp(X)
-#..At this point  R = 2^(-L)X; Q = 0; k = 0; and  k+j = L
-Mod_Loop:
-	tst.l		%d6			# test carry bit
-	bgt.b		R_GT_Y
-
-#..At this point carry = 0, R = (D1,D2), Y = (D4,D5)
-	cmp.l		%d1,%d4			# compare hi(R) and hi(Y)
-	bne.b		R_NE_Y
-	cmp.l		%d2,%d5			# compare lo(R) and lo(Y)
-	bne.b		R_NE_Y
-
-#..At this point, R = Y
-	bra.w		Rem_is_0
-
-R_NE_Y:
-#..use the borrow of the previous compare
-	bcs.b		R_LT_Y			# borrow is set iff R < Y
-
-R_GT_Y:
-#..If Carry is set, then Y < (Carry,D1,D2) < 2Y. Otherwise, Carry = 0
-#..and Y < (D1,D2) < 2Y. Either way, perform R - Y
-	sub.l		%d5,%d2			# lo(R) - lo(Y)
-	subx.l		%d4,%d1			# hi(R) - hi(Y)
-	clr.l		%d6			# clear carry
-	addq.l		&1,%d3			# Q := Q + 1
-
-R_LT_Y:
-#..At this point, Carry=0, R < Y. R = 2^(k-L)X - QY; k+j = L; j >= 0.
-	tst.l		%d0			# see if j = 0.
-	beq.b		PostLoop
-
-	add.l		%d3,%d3			# Q := 2Q
-	add.l		%d2,%d2			# lo(R) = 2lo(R)
-	roxl.l		&1,%d1			# hi(R) = 2hi(R) + carry
-	scs		%d6			# set Carry if 2(R) overflows
-	addq.l		&1,%a1			# k := k+1
-	subq.l		&1,%d0			# j := j - 1
-#..At this point, R=(Carry,D1,D2) = 2^(k-L)X - QY, j+k=L, j >= 0, R < 2Y.
-
-	bra.b		Mod_Loop
-
-PostLoop:
-#..k = L, j = 0, Carry = 0, R = (D1,D2) = X - QY, R < Y.
-
-#..normalize R.
-	mov.l		L_SCR1(%a6),%d0		# new biased expo of R
-	tst.l		%d1
-	bne.b		HiR_not0
-
-HiR_0:
-	mov.l		%d2,%d1
-	clr.l		%d2
-	sub.l		&32,%d0
-	clr.l		%d6
-	bfffo		%d1{&0:&32},%d6
-	lsl.l		%d6,%d1
-	sub.l		%d6,%d0			# (D0,D1,D2) is normalized
-#                                       ...with bias $7FFD
-	bra.b		Get_Mod
-
-HiR_not0:
-	clr.l		%d6
-	bfffo		%d1{&0:&32},%d6
-	bmi.b		Get_Mod			# already normalized
-	sub.l		%d6,%d0
-	lsl.l		%d6,%d1
-	mov.l		%d2,%d7			# a copy of D2
-	lsl.l		%d6,%d2
-	neg.l		%d6
-	add.l		&32,%d6
-	lsr.l		%d6,%d7
-	or.l		%d7,%d1			# (D0,D1,D2) normalized
-
-#
-Get_Mod:
-	cmp.l		%d0,&0x000041FE
-	bge.b		No_Scale
-Do_Scale:
-	mov.w		%d0,R(%a6)
-	mov.l		%d1,R_Hi(%a6)
-	mov.l		%d2,R_Lo(%a6)
-	mov.l		L_SCR1(%a6),%d6
-	mov.w		%d6,Y(%a6)
-	mov.l		%d4,Y_Hi(%a6)
-	mov.l		%d5,Y_Lo(%a6)
-	fmov.x		R(%a6),%fp0		# no exception
-	mov.b		&1,Sc_Flag(%a6)
-	bra.b		ModOrRem
-No_Scale:
-	mov.l		%d1,R_Hi(%a6)
-	mov.l		%d2,R_Lo(%a6)
-	sub.l		&0x3FFE,%d0
-	mov.w		%d0,R(%a6)
-	mov.l		L_SCR1(%a6),%d6
-	sub.l		&0x3FFE,%d6
-	mov.l		%d6,L_SCR1(%a6)
-	fmov.x		R(%a6),%fp0
-	mov.w		%d6,Y(%a6)
-	mov.l		%d4,Y_Hi(%a6)
-	mov.l		%d5,Y_Lo(%a6)
-	clr.b		Sc_Flag(%a6)
-
-#
-ModOrRem:
-	tst.b		Mod_Flag(%a6)
-	beq.b		Fix_Sign
-
-	mov.l		L_SCR1(%a6),%d6		# new biased expo(Y)
-	subq.l		&1,%d6			# biased expo(Y/2)
-	cmp.l		%d0,%d6
-	blt.b		Fix_Sign
-	bgt.b		Last_Sub
-
-	cmp.l		%d1,%d4
-	bne.b		Not_EQ
-	cmp.l		%d2,%d5
-	bne.b		Not_EQ
-	bra.w		Tie_Case
-
-Not_EQ:
-	bcs.b		Fix_Sign
-
-Last_Sub:
-#
-	fsub.x		Y(%a6),%fp0		# no exceptions
-	addq.l		&1,%d3			# Q := Q + 1
-
-#
-Fix_Sign:
-#..Get sign of X
-	mov.w		SignX(%a6),%d6
-	bge.b		Get_Q
-	fneg.x		%fp0
-
-#..Get Q
-#
-Get_Q:
-	clr.l		%d6
-	mov.w		SignQ(%a6),%d6		# D6 is sign(Q)
-	mov.l		&8,%d7
-	lsr.l		%d7,%d6
-	and.l		&0x0000007F,%d3		# 7 bits of Q
-	or.l		%d6,%d3			# sign and bits of Q
-#	swap		%d3
-#	fmov.l		%fpsr,%d6
-#	and.l		&0xFF00FFFF,%d6
-#	or.l		%d3,%d6
-#	fmov.l		%d6,%fpsr		# put Q in fpsr
-	mov.b		%d3,FPSR_QBYTE(%a6)	# put Q in fpsr
-
-#
-Restore:
-	movm.l		(%sp)+,&0xfc		#  {%d2-%d7}
-	mov.l		(%sp)+,%d0
-	fmov.l		%d0,%fpcr
-	tst.b		Sc_Flag(%a6)
-	beq.b		Finish
-	mov.b		&FMUL_OP,%d1		# last inst is MUL
-	fmul.x		Scale(%pc),%fp0		# may cause underflow
-	bra		t_catch2
-# the '040 package did this apparently to see if the dst operand for the
-# preceding fmul was a denorm. but, it better not have been since the
-# algorithm just got done playing with fp0 and expected no exceptions
-# as a result. trust me...
-#	bra		t_avoid_unsupp		# check for denorm as a
-#						;result of the scaling
-
-Finish:
-	mov.b		&FMOV_OP,%d1		# last inst is MOVE
-	fmov.x		%fp0,%fp0		# capture exceptions & round
-	bra		t_catch2
-
-Rem_is_0:
-#..R = 2^(-j)X - Q Y = Y, thus R = 0 and quotient = 2^j (Q+1)
-	addq.l		&1,%d3
-	cmp.l		%d0,&8			# D0 is j
-	bge.b		Q_Big
-
-	lsl.l		%d0,%d3
-	bra.b		Set_R_0
-
-Q_Big:
-	clr.l		%d3
-
-Set_R_0:
-	fmov.s		&0x00000000,%fp0
-	clr.b		Sc_Flag(%a6)
-	bra.w		Fix_Sign
-
-Tie_Case:
-#..Check parity of Q
-	mov.l		%d3,%d6
-	and.l		&0x00000001,%d6
-	tst.l		%d6
-	beq.w		Fix_Sign		# Q is even
-
-#..Q is odd, Q := Q + 1, signX := -signX
-	addq.l		&1,%d3
-	mov.w		SignX(%a6),%d6
-	eor.l		&0x00008000,%d6
-	mov.w		%d6,SignX(%a6)
-	bra.w		Fix_Sign
-
-#########################################################################
-# XDEF ****************************************************************	#
-#	tag(): return the optype of the input ext fp number		#
-#									#
-#	This routine is used by the 060FPLSP.				#
-#									#
-# XREF ****************************************************************	#
-#	None								#
-#									#
-# INPUT ***************************************************************	#
-#	a0 = pointer to extended precision operand			#
-#									#
-# OUTPUT **************************************************************	#
-#	d0 = value of type tag						#
-#		one of: NORM, INF, QNAN, SNAN, DENORM, ZERO		#
-#									#
-# ALGORITHM ***********************************************************	#
-#	Simply test the exponent, j-bit, and mantissa values to		#
-# determine the type of operand.					#
-#	If it's an unnormalized zero, alter the operand and force it	#
-# to be a normal zero.							#
-#									#
-#########################################################################
-
-	global		tag
-tag:
-	mov.w		FTEMP_EX(%a0), %d0	# extract exponent
-	andi.w		&0x7fff, %d0		# strip off sign
-	cmpi.w		%d0, &0x7fff		# is (EXP == MAX)?
-	beq.b		inf_or_nan_x
-not_inf_or_nan_x:
-	btst		&0x7,FTEMP_HI(%a0)
-	beq.b		not_norm_x
-is_norm_x:
-	mov.b		&NORM, %d0
-	rts
-not_norm_x:
-	tst.w		%d0			# is exponent = 0?
-	bne.b		is_unnorm_x
-not_unnorm_x:
-	tst.l		FTEMP_HI(%a0)
-	bne.b		is_denorm_x
-	tst.l		FTEMP_LO(%a0)
-	bne.b		is_denorm_x
-is_zero_x:
-	mov.b		&ZERO, %d0
-	rts
-is_denorm_x:
-	mov.b		&DENORM, %d0
-	rts
-is_unnorm_x:
-	bsr.l		unnorm_fix		# convert to norm,denorm,or zero
-	rts
-is_unnorm_reg_x:
-	mov.b		&UNNORM, %d0
-	rts
-inf_or_nan_x:
-	tst.l		FTEMP_LO(%a0)
-	bne.b		is_nan_x
-	mov.l		FTEMP_HI(%a0), %d0
-	and.l		&0x7fffffff, %d0	# msb is a don't care!
-	bne.b		is_nan_x
-is_inf_x:
-	mov.b		&INF, %d0
-	rts
-is_nan_x:
-	mov.b		&QNAN, %d0
-	rts
-
-#############################################################
-
-qnan:	long		0x7fff0000, 0xffffffff, 0xffffffff
-
-#########################################################################
-# XDEF ****************************************************************	#
-#	t_dz(): Handle 060FPLSP dz exception for "flogn" emulation.	#
-#	t_dz2(): Handle 060FPLSP dz exception for "fatanh" emulation.	#
-#									#
-#	These rouitnes are used by the 060FPLSP package.		#
-#									#
-# XREF ****************************************************************	#
-#	None								#
-#									#
-# INPUT ***************************************************************	#
-#	a0 = pointer to extended precision source operand.		#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = default DZ result.					#
-#									#
-# ALGORITHM ***********************************************************	#
-#	Transcendental emulation for the 060FPLSP has detected that	#
-# a DZ exception should occur for the instruction. If DZ is disabled,	#
-# return the default result.						#
-#	If DZ is enabled, the dst operand should be returned unscathed	#
-# in fp0 while fp1 is used to create a DZ exception so that the		#
-# operating system can log that such an event occurred.			#
-#									#
-#########################################################################
-
-	global		t_dz
-t_dz:
-	tst.b		SRC_EX(%a0)		# check sign for neg or pos
-	bpl.b		dz_pinf			# branch if pos sign
-
-	global		t_dz2
-t_dz2:
-	ori.l		&dzinf_mask+neg_mask,USER_FPSR(%a6) # set N/I/DZ/ADZ
-
-	btst		&dz_bit,FPCR_ENABLE(%a6)
-	bne.b		dz_minf_ena
-
-# dz is disabled. return a -INF.
-	fmov.s		&0xff800000,%fp0	# return -INF
-	rts
-
-# dz is enabled. create a dz exception so the user can record it
-# but use fp1 instead. return the dst operand unscathed in fp0.
-dz_minf_ena:
-	fmovm.x		EXC_FP0(%a6),&0x80	# return fp0 unscathed
-	fmov.l		USER_FPCR(%a6),%fpcr
-	fmov.s		&0xbf800000,%fp1	# load -1
-	fdiv.s		&0x00000000,%fp1	# -1 / 0
-	rts
-
-dz_pinf:
-	ori.l		&dzinf_mask,USER_FPSR(%a6) # set I/DZ/ADZ
-
-	btst		&dz_bit,FPCR_ENABLE(%a6)
-	bne.b		dz_pinf_ena
-
-# dz is disabled. return a +INF.
-	fmov.s		&0x7f800000,%fp0	# return +INF
-	rts
-
-# dz is enabled. create a dz exception so the user can record it
-# but use fp1 instead. return the dst operand unscathed in fp0.
-dz_pinf_ena:
-	fmovm.x		EXC_FP0(%a6),&0x80	# return fp0 unscathed
-	fmov.l		USER_FPCR(%a6),%fpcr
-	fmov.s		&0x3f800000,%fp1	# load +1
-	fdiv.s		&0x00000000,%fp1	# +1 / 0
-	rts
-
-#########################################################################
-# XDEF ****************************************************************	#
-#	t_operr(): Handle 060FPLSP OPERR exception during emulation.	#
-#									#
-#	This routine is used by the 060FPLSP package.			#
-#									#
-# XREF ****************************************************************	#
-#	None.								#
-#									#
-# INPUT ***************************************************************	#
-#	fp1 = source operand						#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = default result						#
-#	fp1 = unchanged							#
-#									#
-# ALGORITHM ***********************************************************	#
-#	An operand error should occur as the result of transcendental	#
-# emulation in the 060FPLSP. If OPERR is disabled, just return a NAN	#
-# in fp0. If OPERR is enabled, return the dst operand unscathed in fp0	#
-# and the source operand in fp1. Use fp2 to create an OPERR exception	#
-# so that the operating system can log the event.			#
-#									#
-#########################################################################
-
-	global		t_operr
-t_operr:
-	ori.l		&opnan_mask,USER_FPSR(%a6) # set NAN/OPERR/AIOP
-
-	btst		&operr_bit,FPCR_ENABLE(%a6)
-	bne.b		operr_ena
-
-# operr is disabled. return a QNAN in fp0
-	fmovm.x		qnan(%pc),&0x80		# return QNAN
-	rts
-
-# operr is enabled. create an operr exception so the user can record it
-# but use fp2 instead. return the dst operand unscathed in fp0.
-operr_ena:
-	fmovm.x		EXC_FP0(%a6),&0x80	# return fp0 unscathed
-	fmov.l		USER_FPCR(%a6),%fpcr
-	fmovm.x		&0x04,-(%sp)		# save fp2
-	fmov.s		&0x7f800000,%fp2	# load +INF
-	fmul.s		&0x00000000,%fp2	# +INF x 0
-	fmovm.x		(%sp)+,&0x20		# restore fp2
-	rts
-
-pls_huge:
-	long		0x7ffe0000,0xffffffff,0xffffffff
-mns_huge:
-	long		0xfffe0000,0xffffffff,0xffffffff
-pls_tiny:
-	long		0x00000000,0x80000000,0x00000000
-mns_tiny:
-	long		0x80000000,0x80000000,0x00000000
-
-#########################################################################
-# XDEF ****************************************************************	#
-#	t_unfl(): Handle 060FPLSP underflow exception during emulation.	#
-#	t_unfl2(): Handle 060FPLSP underflow exception during		#
-#	           emulation. result always positive.			#
-#									#
-#	This routine is used by the 060FPLSP package.			#
-#									#
-# XREF ****************************************************************	#
-#	None.								#
-#									#
-# INPUT ***************************************************************	#
-#	a0 = pointer to extended precision source operand		#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = default underflow result					#
-#									#
-# ALGORITHM ***********************************************************	#
-#	An underflow should occur as the result of transcendental	#
-# emulation in the 060FPLSP. Create an underflow by using "fmul"	#
-# and two very small numbers of appropriate sign so the operating	#
-# system can log the event.						#
-#									#
-#########################################################################
-
-	global		t_unfl
-t_unfl:
-	tst.b		SRC_EX(%a0)
-	bpl.b		unf_pos
-
-	global		t_unfl2
-t_unfl2:
-	ori.l		&unfinx_mask+neg_mask,USER_FPSR(%a6) # set N/UNFL/INEX2/AUNFL/AINEX
-
-	fmov.l		USER_FPCR(%a6),%fpcr
-	fmovm.x		mns_tiny(%pc),&0x80
-	fmul.x		pls_tiny(%pc),%fp0
-
-	fmov.l		%fpsr,%d0
-	rol.l		&0x8,%d0
-	mov.b		%d0,FPSR_CC(%a6)
-	rts
-unf_pos:
-	ori.w		&unfinx_mask,FPSR_EXCEPT(%a6) # set UNFL/INEX2/AUNFL/AINEX
-
-	fmov.l		USER_FPCR(%a6),%fpcr
-	fmovm.x		pls_tiny(%pc),&0x80
-	fmul.x		%fp0,%fp0
-
-	fmov.l		%fpsr,%d0
-	rol.l		&0x8,%d0
-	mov.b		%d0,FPSR_CC(%a6)
-	rts
-
-#########################################################################
-# XDEF ****************************************************************	#
-#	t_ovfl(): Handle 060FPLSP overflow exception during emulation.	#
-#		  (monadic)						#
-#	t_ovfl2(): Handle 060FPLSP overflow exception during		#
-#	           emulation. result always positive. (dyadic)		#
-#	t_ovfl_sc(): Handle 060FPLSP overflow exception during		#
-#	             emulation for "fscale".				#
-#									#
-#	This routine is used by the 060FPLSP package.			#
-#									#
-# XREF ****************************************************************	#
-#	None.								#
-#									#
-# INPUT ***************************************************************	#
-#	a0 = pointer to extended precision source operand		#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = default underflow result					#
-#									#
-# ALGORITHM ***********************************************************	#
-#	An overflow should occur as the result of transcendental	#
-# emulation in the 060FPLSP. Create an overflow by using "fmul"		#
-# and two very lareg numbers of appropriate sign so the operating	#
-# system can log the event.						#
-#	For t_ovfl_sc() we take special care not to lose the INEX2 bit.	#
-#									#
-#########################################################################
-
-	global		t_ovfl_sc
-t_ovfl_sc:
-	ori.l		&ovfl_inx_mask,USER_FPSR(%a6) # set OVFL/AOVFL/AINEX
-
-	mov.b		%d0,%d1			# fetch rnd prec,mode
-	andi.b		&0xc0,%d1		# extract prec
-	beq.w		ovfl_work
-
-# dst op is a DENORM. we have to normalize the mantissa to see if the
-# result would be inexact for the given precision. make a copy of the
-# dst so we don't screw up the version passed to us.
-	mov.w		LOCAL_EX(%a0),FP_SCR0_EX(%a6)
-	mov.l		LOCAL_HI(%a0),FP_SCR0_HI(%a6)
-	mov.l		LOCAL_LO(%a0),FP_SCR0_LO(%a6)
-	lea		FP_SCR0(%a6),%a0	# pass ptr to FP_SCR0
-	movm.l		&0xc080,-(%sp)		# save d0-d1/a0
-	bsr.l		norm			# normalize mantissa
-	movm.l		(%sp)+,&0x0103		# restore d0-d1/a0
-
-	cmpi.b		%d1,&0x40		# is precision sgl?
-	bne.b		ovfl_sc_dbl		# no; dbl
-ovfl_sc_sgl:
-	tst.l		LOCAL_LO(%a0)		# is lo lw of sgl set?
-	bne.b		ovfl_sc_inx		# yes
-	tst.b		3+LOCAL_HI(%a0)		# is lo byte of hi lw set?
-	bne.b		ovfl_sc_inx		# yes
-	bra.w		ovfl_work		# don't set INEX2
-ovfl_sc_dbl:
-	mov.l		LOCAL_LO(%a0),%d1	# are any of lo 11 bits of
-	andi.l		&0x7ff,%d1		# dbl mantissa set?
-	beq.w		ovfl_work		# no; don't set INEX2
-ovfl_sc_inx:
-	ori.l		&inex2_mask,USER_FPSR(%a6) # set INEX2
-	bra.b		ovfl_work		# continue
-
-	global		t_ovfl
-t_ovfl:
-	ori.w		&ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX
-ovfl_work:
-	tst.b		SRC_EX(%a0)
-	bpl.b		ovfl_p
-ovfl_m:
-	fmov.l		USER_FPCR(%a6),%fpcr
-	fmovm.x		mns_huge(%pc),&0x80
-	fmul.x		pls_huge(%pc),%fp0
-
-	fmov.l		%fpsr,%d0
-	rol.l		&0x8,%d0
-	ori.b		&neg_mask,%d0
-	mov.b		%d0,FPSR_CC(%a6)
-	rts
-ovfl_p:
-	fmov.l		USER_FPCR(%a6),%fpcr
-	fmovm.x		pls_huge(%pc),&0x80
-	fmul.x		pls_huge(%pc),%fp0
-
-	fmov.l		%fpsr,%d0
-	rol.l		&0x8,%d0
-	mov.b		%d0,FPSR_CC(%a6)
-	rts
-
-	global		t_ovfl2
-t_ovfl2:
-	ori.w		&ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX
-	fmov.l		USER_FPCR(%a6),%fpcr
-	fmovm.x		pls_huge(%pc),&0x80
-	fmul.x		pls_huge(%pc),%fp0
-
-	fmov.l		%fpsr,%d0
-	rol.l		&0x8,%d0
-	mov.b		%d0,FPSR_CC(%a6)
-	rts
-
-#########################################################################
-# XDEF ****************************************************************	#
-#	t_catch(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during	#
-#		   emulation.						#
-#	t_catch2(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during	#
-#		    emulation.						#
-#									#
-#	These routines are used by the 060FPLSP package.		#
-#									#
-# XREF ****************************************************************	#
-#	None.								#
-#									#
-# INPUT ***************************************************************	#
-#	fp0 = default underflow or overflow result			#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = default result						#
-#									#
-# ALGORITHM ***********************************************************	#
-#	If an overflow or underflow occurred during the last		#
-# instruction of transcendental 060FPLSP emulation, then it has already	#
-# occurred and has been logged. Now we need to see if an inexact	#
-# exception should occur.						#
-#									#
-#########################################################################
-
-	global		t_catch2
-t_catch2:
-	fmov.l		%fpsr,%d0
-	or.l		%d0,USER_FPSR(%a6)
-	bra.b		inx2_work
-
-	global		t_catch
-t_catch:
-	fmov.l		%fpsr,%d0
-	or.l		%d0,USER_FPSR(%a6)
-
-#########################################################################
-# XDEF ****************************************************************	#
-#	t_inx2(): Handle inexact 060FPLSP exception during emulation.	#
-#	t_pinx2(): Handle inexact 060FPLSP exception for "+" results.	#
-#	t_minx2(): Handle inexact 060FPLSP exception for "-" results.	#
-#									#
-# XREF ****************************************************************	#
-#	None.								#
-#									#
-# INPUT ***************************************************************	#
-#	fp0 = default result						#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = default result						#
-#									#
-# ALGORITHM ***********************************************************	#
-#	The last instruction of transcendental emulation for the	#
-# 060FPLSP should be inexact. So, if inexact is enabled, then we create	#
-# the event here by adding a large and very small number together	#
-# so that the operating system can log the event.			#
-#	Must check, too, if the result was zero, in which case we just	#
-# set the FPSR bits and return.						#
-#									#
-#########################################################################
-
-	global		t_inx2
-t_inx2:
-	fblt.w		t_minx2
-	fbeq.w		inx2_zero
-
-	global		t_pinx2
-t_pinx2:
-	ori.w		&inx2a_mask,FPSR_EXCEPT(%a6) # set INEX2/AINEX
-	bra.b		inx2_work
-
-	global		t_minx2
-t_minx2:
-	ori.l		&inx2a_mask+neg_mask,USER_FPSR(%a6)
-
-inx2_work:
-	btst		&inex2_bit,FPCR_ENABLE(%a6) # is inexact enabled?
-	bne.b		inx2_work_ena		# yes
-	rts
-inx2_work_ena:
-	fmov.l		USER_FPCR(%a6),%fpcr	# insert user's exceptions
-	fmov.s		&0x3f800000,%fp1	# load +1
-	fadd.x		pls_tiny(%pc),%fp1	# cause exception
-	rts
-
-inx2_zero:
-	mov.b		&z_bmask,FPSR_CC(%a6)
-	ori.w		&inx2a_mask,2+USER_FPSR(%a6) # set INEX/AINEX
-	rts
-
-#########################################################################
-# XDEF ****************************************************************	#
-#	t_extdnrm(): Handle DENORM inputs in 060FPLSP.			#
-#	t_resdnrm(): Handle DENORM inputs in 060FPLSP for "fscale".	#
-#									#
-#	This routine is used by the 060FPLSP package.			#
-#									#
-# XREF ****************************************************************	#
-#	None.								#
-#									#
-# INPUT ***************************************************************	#
-#	a0 = pointer to extended precision input operand		#
-#									#
-# OUTPUT **************************************************************	#
-#	fp0 = default result						#
-#									#
-# ALGORITHM ***********************************************************	#
-#	For all functions that have a denormalized input and that	#
-# f(x)=x, this is the entry point.					#
-#	DENORM value is moved using "fmove" which triggers an exception	#
-# if enabled so the operating system can log the event.			#
-#									#
-#########################################################################
-
-	global		t_extdnrm
-t_extdnrm:
-	fmov.l		USER_FPCR(%a6),%fpcr
-	fmov.x		SRC_EX(%a0),%fp0
-	fmov.l		%fpsr,%d0
-	ori.l		&unfinx_mask,%d0
-	or.l		%d0,USER_FPSR(%a6)
-	rts
-
-	global		t_resdnrm
-t_resdnrm:
-	fmov.l		USER_FPCR(%a6),%fpcr
-	fmov.x		SRC_EX(%a0),%fp0
-	fmov.l		%fpsr,%d0
-	or.l		%d0,USER_FPSR(%a6)
-	rts
-
-##########################################
-
-#
-# sto_cos:
-#	This is used by fsincos library emulation. The correct
-# values are already in fp0 and fp1 so we do nothing here.
-#
-	global		sto_cos
-sto_cos:
-	rts
-
-##########################################
-
-#
-#	dst_qnan --- force result when destination is a NaN
-#
-	global		dst_qnan
-dst_qnan:
-	fmov.x		DST(%a1),%fp0
-	tst.b		DST_EX(%a1)
-	bmi.b		dst_qnan_m
-dst_qnan_p:
-	mov.b		&nan_bmask,FPSR_CC(%a6)
-	rts
-dst_qnan_m:
-	mov.b		&nan_bmask+neg_bmask,FPSR_CC(%a6)
-	rts
-
-#
-#	src_qnan --- force result when source is a NaN
-#
-	global		src_qnan
-src_qnan:
-	fmov.x		SRC(%a0),%fp0
-	tst.b		SRC_EX(%a0)
-	bmi.b		src_qnan_m
-src_qnan_p:
-	mov.b		&nan_bmask,FPSR_CC(%a6)
-	rts
-src_qnan_m:
-	mov.b		&nan_bmask+neg_bmask,FPSR_CC(%a6)
-	rts
-
-##########################################
-
-#
-#	Native instruction support
-#
-#	Some systems may need entry points even for 68060 native
-#	instructions.  These routines are provided for
-#	convenience.
-#
-	global		_fadds_
-_fadds_:
-	fmov.l		%fpcr,-(%sp)		# save fpcr
-	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
-	fmov.s		0x8(%sp),%fp0		# load sgl dst
-	fmov.l		(%sp)+,%fpcr		# restore fpcr
-	fadd.s		0x8(%sp),%fp0		# fadd w/ sgl src
-	rts
-
-	global		_faddd_
-_faddd_:
-	fmov.l		%fpcr,-(%sp)		# save fpcr
-	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
-	fmov.d		0x8(%sp),%fp0		# load dbl dst
-	fmov.l		(%sp)+,%fpcr		# restore fpcr
-	fadd.d		0xc(%sp),%fp0		# fadd w/ dbl src
-	rts
-
-	global		_faddx_
-_faddx_:
-	fmovm.x		0x4(%sp),&0x80		# load ext dst
-	fadd.x		0x10(%sp),%fp0		# fadd w/ ext src
-	rts
-
-	global		_fsubs_
-_fsubs_:
-	fmov.l		%fpcr,-(%sp)		# save fpcr
-	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
-	fmov.s		0x8(%sp),%fp0		# load sgl dst
-	fmov.l		(%sp)+,%fpcr		# restore fpcr
-	fsub.s		0x8(%sp),%fp0		# fsub w/ sgl src
-	rts
-
-	global		_fsubd_
-_fsubd_:
-	fmov.l		%fpcr,-(%sp)		# save fpcr
-	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
-	fmov.d		0x8(%sp),%fp0		# load dbl dst
-	fmov.l		(%sp)+,%fpcr		# restore fpcr
-	fsub.d		0xc(%sp),%fp0		# fsub w/ dbl src
-	rts
-
-	global		_fsubx_
-_fsubx_:
-	fmovm.x		0x4(%sp),&0x80		# load ext dst
-	fsub.x		0x10(%sp),%fp0		# fsub w/ ext src
-	rts
-
-	global		_fmuls_
-_fmuls_:
-	fmov.l		%fpcr,-(%sp)		# save fpcr
-	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
-	fmov.s		0x8(%sp),%fp0		# load sgl dst
-	fmov.l		(%sp)+,%fpcr		# restore fpcr
-	fmul.s		0x8(%sp),%fp0		# fmul w/ sgl src
-	rts
-
-	global		_fmuld_
-_fmuld_:
-	fmov.l		%fpcr,-(%sp)		# save fpcr
-	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
-	fmov.d		0x8(%sp),%fp0		# load dbl dst
-	fmov.l		(%sp)+,%fpcr		# restore fpcr
-	fmul.d		0xc(%sp),%fp0		# fmul w/ dbl src
-	rts
-
-	global		_fmulx_
-_fmulx_:
-	fmovm.x		0x4(%sp),&0x80		# load ext dst
-	fmul.x		0x10(%sp),%fp0		# fmul w/ ext src
-	rts
-
-	global		_fdivs_
-_fdivs_:
-	fmov.l		%fpcr,-(%sp)		# save fpcr
-	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
-	fmov.s		0x8(%sp),%fp0		# load sgl dst
-	fmov.l		(%sp)+,%fpcr		# restore fpcr
-	fdiv.s		0x8(%sp),%fp0		# fdiv w/ sgl src
-	rts
-
-	global		_fdivd_
-_fdivd_:
-	fmov.l		%fpcr,-(%sp)		# save fpcr
-	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
-	fmov.d		0x8(%sp),%fp0		# load dbl dst
-	fmov.l		(%sp)+,%fpcr		# restore fpcr
-	fdiv.d		0xc(%sp),%fp0		# fdiv w/ dbl src
-	rts
-
-	global		_fdivx_
-_fdivx_:
-	fmovm.x		0x4(%sp),&0x80		# load ext dst
-	fdiv.x		0x10(%sp),%fp0		# fdiv w/ ext src
-	rts
-
-	global		_fabss_
-_fabss_:
-	fabs.s		0x4(%sp),%fp0		# fabs w/ sgl src
-	rts
-
-	global		_fabsd_
-_fabsd_:
-	fabs.d		0x4(%sp),%fp0		# fabs w/ dbl src
-	rts
-
-	global		_fabsx_
-_fabsx_:
-	fabs.x		0x4(%sp),%fp0		# fabs w/ ext src
-	rts
-
-	global		_fnegs_
-_fnegs_:
-	fneg.s		0x4(%sp),%fp0		# fneg w/ sgl src
-	rts
-
-	global		_fnegd_
-_fnegd_:
-	fneg.d		0x4(%sp),%fp0		# fneg w/ dbl src
-	rts
-
-	global		_fnegx_
-_fnegx_:
-	fneg.x		0x4(%sp),%fp0		# fneg w/ ext src
-	rts
-
-	global		_fsqrts_
-_fsqrts_:
-	fsqrt.s		0x4(%sp),%fp0		# fsqrt w/ sgl src
-	rts
-
-	global		_fsqrtd_
-_fsqrtd_:
-	fsqrt.d		0x4(%sp),%fp0		# fsqrt w/ dbl src
-	rts
-
-	global		_fsqrtx_
-_fsqrtx_:
-	fsqrt.x		0x4(%sp),%fp0		# fsqrt w/ ext src
-	rts
-
-	global		_fints_
-_fints_:
-	fint.s		0x4(%sp),%fp0		# fint w/ sgl src
-	rts
-
-	global		_fintd_
-_fintd_:
-	fint.d		0x4(%sp),%fp0		# fint w/ dbl src
-	rts
-
-	global		_fintx_
-_fintx_:
-	fint.x		0x4(%sp),%fp0		# fint w/ ext src
-	rts
-
-	global		_fintrzs_
-_fintrzs_:
-	fintrz.s	0x4(%sp),%fp0		# fintrz w/ sgl src
-	rts
-
-	global		_fintrzd_
-_fintrzd_:
-	fintrz.d	0x4(%sp),%fp0		# fintrx w/ dbl src
-	rts
-
-	global		_fintrzx_
-_fintrzx_:
-	fintrz.x	0x4(%sp),%fp0		# fintrz w/ ext src
-	rts
-
-########################################################################
-
-#########################################################################
-# src_zero(): Return signed zero according to sign of src operand.	#
-#########################################################################
-	global		src_zero
-src_zero:
-	tst.b		SRC_EX(%a0)		# get sign of src operand
-	bmi.b		ld_mzero		# if neg, load neg zero
-
-#
-# ld_pzero(): return a positive zero.
-#
-	global		ld_pzero
-ld_pzero:
-	fmov.s		&0x00000000,%fp0	# load +0
-	mov.b		&z_bmask,FPSR_CC(%a6)	# set 'Z' ccode bit
-	rts
-
-# ld_mzero(): return a negative zero.
-	global		ld_mzero
-ld_mzero:
-	fmov.s		&0x80000000,%fp0	# load -0
-	mov.b		&neg_bmask+z_bmask,FPSR_CC(%a6) # set 'N','Z' ccode bits
-	rts
-
-#########################################################################
-# dst_zero(): Return signed zero according to sign of dst operand.	#
-#########################################################################
-	global		dst_zero
-dst_zero:
-	tst.b		DST_EX(%a1)		# get sign of dst operand
-	bmi.b		ld_mzero		# if neg, load neg zero
-	bra.b		ld_pzero		# load positive zero
-
-#########################################################################
-# src_inf(): Return signed inf according to sign of src operand.	#
-#########################################################################
-	global		src_inf
-src_inf:
-	tst.b		SRC_EX(%a0)		# get sign of src operand
-	bmi.b		ld_minf			# if negative branch
-
-#
-# ld_pinf(): return a positive infinity.
-#
-	global		ld_pinf
-ld_pinf:
-	fmov.s		&0x7f800000,%fp0	# load +INF
-	mov.b		&inf_bmask,FPSR_CC(%a6)	# set 'INF' ccode bit
-	rts
-
-#
-# ld_minf():return a negative infinity.
-#
-	global		ld_minf
-ld_minf:
-	fmov.s		&0xff800000,%fp0	# load -INF
-	mov.b		&neg_bmask+inf_bmask,FPSR_CC(%a6) # set 'N','I' ccode bits
-	rts
-
-#########################################################################
-# dst_inf(): Return signed inf according to sign of dst operand.	#
-#########################################################################
-	global		dst_inf
-dst_inf:
-	tst.b		DST_EX(%a1)		# get sign of dst operand
-	bmi.b		ld_minf			# if negative branch
-	bra.b		ld_pinf
-
-	global		szr_inf
-#################################################################
-# szr_inf(): Return +ZERO for a negative src operand or		#
-#	            +INF for a positive src operand.		#
-#	     Routine used for fetox, ftwotox, and ftentox.	#
-#################################################################
-szr_inf:
-	tst.b		SRC_EX(%a0)		# check sign of source
-	bmi.b		ld_pzero
-	bra.b		ld_pinf
-
-#########################################################################
-# sopr_inf(): Return +INF for a positive src operand or			#
-#	      jump to operand error routine for a negative src operand.	#
-#	      Routine used for flogn, flognp1, flog10, and flog2.	#
-#########################################################################
-	global		sopr_inf
-sopr_inf:
-	tst.b		SRC_EX(%a0)		# check sign of source
-	bmi.w		t_operr
-	bra.b		ld_pinf
-
-#################################################################
-# setoxm1i(): Return minus one for a negative src operand or	#
-#	      positive infinity for a positive src operand.	#
-#	      Routine used for fetoxm1.				#
-#################################################################
-	global		setoxm1i
-setoxm1i:
-	tst.b		SRC_EX(%a0)		# check sign of source
-	bmi.b		ld_mone
-	bra.b		ld_pinf
-
-#########################################################################
-# src_one(): Return signed one according to sign of src operand.	#
-#########################################################################
-	global		src_one
-src_one:
-	tst.b		SRC_EX(%a0)		# check sign of source
-	bmi.b		ld_mone
-
-#
-# ld_pone(): return positive one.
-#
-	global		ld_pone
-ld_pone:
-	fmov.s		&0x3f800000,%fp0	# load +1
-	clr.b		FPSR_CC(%a6)
-	rts
-
-#
-# ld_mone(): return negative one.
-#
-	global		ld_mone
-ld_mone:
-	fmov.s		&0xbf800000,%fp0	# load -1
-	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' ccode bit
-	rts
-
-ppiby2:	long		0x3fff0000, 0xc90fdaa2, 0x2168c235
-mpiby2:	long		0xbfff0000, 0xc90fdaa2, 0x2168c235
-
-#################################################################
-# spi_2(): Return signed PI/2 according to sign of src operand.	#
-#################################################################
-	global		spi_2
-spi_2:
-	tst.b		SRC_EX(%a0)		# check sign of source
-	bmi.b		ld_mpi2
-
-#
-# ld_ppi2(): return positive PI/2.
-#
-	global		ld_ppi2
-ld_ppi2:
-	fmov.l		%d0,%fpcr
-	fmov.x		ppiby2(%pc),%fp0	# load +pi/2
-	bra.w		t_pinx2			# set INEX2
-
-#
-# ld_mpi2(): return negative PI/2.
-#
-	global		ld_mpi2
-ld_mpi2:
-	fmov.l		%d0,%fpcr
-	fmov.x		mpiby2(%pc),%fp0	# load -pi/2
-	bra.w		t_minx2			# set INEX2
-
-####################################################
-# The following routines give support for fsincos. #
-####################################################
-
-#
-# ssincosz(): When the src operand is ZERO, store a one in the
-#	      cosine register and return a ZERO in fp0 w/ the same sign
-#	      as the src operand.
-#
-	global		ssincosz
-ssincosz:
-	fmov.s		&0x3f800000,%fp1
-	tst.b		SRC_EX(%a0)		# test sign
-	bpl.b		sincoszp
-	fmov.s		&0x80000000,%fp0	# return sin result in fp0
-	mov.b		&z_bmask+neg_bmask,FPSR_CC(%a6)
-	rts
-sincoszp:
-	fmov.s		&0x00000000,%fp0	# return sin result in fp0
-	mov.b		&z_bmask,FPSR_CC(%a6)
-	rts
-
-#
-# ssincosi(): When the src operand is INF, store a QNAN in the cosine
-#	      register and jump to the operand error routine for negative
-#	      src operands.
-#
-	global		ssincosi
-ssincosi:
-	fmov.x		qnan(%pc),%fp1		# load NAN
-	bra.w		t_operr
-
-#
-# ssincosqnan(): When the src operand is a QNAN, store the QNAN in the cosine
-#		 register and branch to the src QNAN routine.
-#
-	global		ssincosqnan
-ssincosqnan:
-	fmov.x		LOCAL_EX(%a0),%fp1
-	bra.w		src_qnan
-
-########################################################################
-
-	global		smod_sdnrm
-	global		smod_snorm
-smod_sdnrm:
-smod_snorm:
-	mov.b		DTAG(%a6),%d1
-	beq.l		smod
-	cmpi.b		%d1,&ZERO
-	beq.w		smod_zro
-	cmpi.b		%d1,&INF
-	beq.l		t_operr
-	cmpi.b		%d1,&DENORM
-	beq.l		smod
-	bra.l		dst_qnan
-
-	global		smod_szero
-smod_szero:
-	mov.b		DTAG(%a6),%d1
-	beq.l		t_operr
-	cmpi.b		%d1,&ZERO
-	beq.l		t_operr
-	cmpi.b		%d1,&INF
-	beq.l		t_operr
-	cmpi.b		%d1,&DENORM
-	beq.l		t_operr
-	bra.l		dst_qnan
-
-	global		smod_sinf
-smod_sinf:
-	mov.b		DTAG(%a6),%d1
-	beq.l		smod_fpn
-	cmpi.b		%d1,&ZERO
-	beq.l		smod_zro
-	cmpi.b		%d1,&INF
-	beq.l		t_operr
-	cmpi.b		%d1,&DENORM
-	beq.l		smod_fpn
-	bra.l		dst_qnan
-
-smod_zro:
-srem_zro:
-	mov.b		SRC_EX(%a0),%d1		# get src sign
-	mov.b		DST_EX(%a1),%d0		# get dst sign
-	eor.b		%d0,%d1			# get qbyte sign
-	andi.b		&0x80,%d1
-	mov.b		%d1,FPSR_QBYTE(%a6)
-	tst.b		%d0
-	bpl.w		ld_pzero
-	bra.w		ld_mzero
-
-smod_fpn:
-srem_fpn:
-	clr.b		FPSR_QBYTE(%a6)
-	mov.l		%d0,-(%sp)
-	mov.b		SRC_EX(%a0),%d1		# get src sign
-	mov.b		DST_EX(%a1),%d0		# get dst sign
-	eor.b		%d0,%d1			# get qbyte sign
-	andi.b		&0x80,%d1
-	mov.b		%d1,FPSR_QBYTE(%a6)
-	cmpi.b		DTAG(%a6),&DENORM
-	bne.b		smod_nrm
-	lea		DST(%a1),%a0
-	mov.l		(%sp)+,%d0
-	bra		t_resdnrm
-smod_nrm:
-	fmov.l		(%sp)+,%fpcr
-	fmov.x		DST(%a1),%fp0
-	tst.b		DST_EX(%a1)
-	bmi.b		smod_nrm_neg
-	rts
-
-smod_nrm_neg:
-	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' code
-	rts
-
-#########################################################################
-	global		srem_snorm
-	global		srem_sdnrm
-srem_sdnrm:
-srem_snorm:
-	mov.b		DTAG(%a6),%d1
-	beq.l		srem
-	cmpi.b		%d1,&ZERO
-	beq.w		srem_zro
-	cmpi.b		%d1,&INF
-	beq.l		t_operr
-	cmpi.b		%d1,&DENORM
-	beq.l		srem
-	bra.l		dst_qnan
-
-	global		srem_szero
-srem_szero:
-	mov.b		DTAG(%a6),%d1
-	beq.l		t_operr
-	cmpi.b		%d1,&ZERO
-	beq.l		t_operr
-	cmpi.b		%d1,&INF
-	beq.l		t_operr
-	cmpi.b		%d1,&DENORM
-	beq.l		t_operr
-	bra.l		dst_qnan
-
-	global		srem_sinf
-srem_sinf:
-	mov.b		DTAG(%a6),%d1
-	beq.w		srem_fpn
-	cmpi.b		%d1,&ZERO
-	beq.w		srem_zro
-	cmpi.b		%d1,&INF
-	beq.l		t_operr
-	cmpi.b		%d1,&DENORM
-	beq.l		srem_fpn
-	bra.l		dst_qnan
-
-#########################################################################
-
-	global		sscale_snorm
-	global		sscale_sdnrm
-sscale_snorm:
-sscale_sdnrm:
-	mov.b		DTAG(%a6),%d1
-	beq.l		sscale
-	cmpi.b		%d1,&ZERO
-	beq.l		dst_zero
-	cmpi.b		%d1,&INF
-	beq.l		dst_inf
-	cmpi.b		%d1,&DENORM
-	beq.l		sscale
-	bra.l		dst_qnan
-
-	global		sscale_szero
-sscale_szero:
-	mov.b		DTAG(%a6),%d1
-	beq.l		sscale
-	cmpi.b		%d1,&ZERO
-	beq.l		dst_zero
-	cmpi.b		%d1,&INF
-	beq.l		dst_inf
-	cmpi.b		%d1,&DENORM
-	beq.l		sscale
-	bra.l		dst_qnan
-
-	global		sscale_sinf
-sscale_sinf:
-	mov.b		DTAG(%a6),%d1
-	beq.l		t_operr
-	cmpi.b		%d1,&QNAN
-	beq.l		dst_qnan
-	bra.l		t_operr
-
-########################################################################
-
-	global		sop_sqnan
-sop_sqnan:
-	mov.b		DTAG(%a6),%d1
-	cmpi.b		%d1,&QNAN
-	beq.l		dst_qnan
-	bra.l		src_qnan
-
-#########################################################################
-# norm(): normalize the mantissa of an extended precision input. the	#
-#	  input operand should not be normalized already.		#
-#									#
-# XDEF ****************************************************************	#
-#	norm()								#
-#									#
-# XREF **************************************************************** #
-#	none								#
-#									#
-# INPUT *************************************************************** #
-#	a0 = pointer fp extended precision operand to normalize		#
-#									#
-# OUTPUT ************************************************************** #
-#	d0 = number of bit positions the mantissa was shifted		#
-#	a0 = the input operand's mantissa is normalized; the exponent	#
-#	     is unchanged.						#
-#									#
-#########################################################################
-	global		norm
-norm:
-	mov.l		%d2, -(%sp)		# create some temp regs
-	mov.l		%d3, -(%sp)
-
-	mov.l		FTEMP_HI(%a0), %d0	# load hi(mantissa)
-	mov.l		FTEMP_LO(%a0), %d1	# load lo(mantissa)
-
-	bfffo		%d0{&0:&32}, %d2	# how many places to shift?
-	beq.b		norm_lo			# hi(man) is all zeroes!
-
-norm_hi:
-	lsl.l		%d2, %d0		# left shift hi(man)
-	bfextu		%d1{&0:%d2}, %d3	# extract lo bits
-
-	or.l		%d3, %d0		# create hi(man)
-	lsl.l		%d2, %d1		# create lo(man)
-
-	mov.l		%d0, FTEMP_HI(%a0)	# store new hi(man)
-	mov.l		%d1, FTEMP_LO(%a0)	# store new lo(man)
-
-	mov.l		%d2, %d0		# return shift amount
-
-	mov.l		(%sp)+, %d3		# restore temp regs
-	mov.l		(%sp)+, %d2
-
-	rts
-
-norm_lo:
-	bfffo		%d1{&0:&32}, %d2	# how many places to shift?
-	lsl.l		%d2, %d1		# shift lo(man)
-	add.l		&32, %d2		# add 32 to shft amount
-
-	mov.l		%d1, FTEMP_HI(%a0)	# store hi(man)
-	clr.l		FTEMP_LO(%a0)		# lo(man) is now zero
-
-	mov.l		%d2, %d0		# return shift amount
-
-	mov.l		(%sp)+, %d3		# restore temp regs
-	mov.l		(%sp)+, %d2
-
-	rts
-
-#########################################################################
-# unnorm_fix(): - changes an UNNORM to one of NORM, DENORM, or ZERO	#
-#		- returns corresponding optype tag			#
-#									#
-# XDEF ****************************************************************	#
-#	unnorm_fix()							#
-#									#
-# XREF **************************************************************** #
-#	norm() - normalize the mantissa					#
-#									#
-# INPUT *************************************************************** #
-#	a0 = pointer to unnormalized extended precision number		#
-#									#
-# OUTPUT ************************************************************** #
-#	d0 = optype tag - is corrected to one of NORM, DENORM, or ZERO	#
-#	a0 = input operand has been converted to a norm, denorm, or	#
-#	     zero; both the exponent and mantissa are changed.		#
-#									#
-#########################################################################
-
-	global		unnorm_fix
-unnorm_fix:
-	bfffo		FTEMP_HI(%a0){&0:&32}, %d0 # how many shifts are needed?
-	bne.b		unnorm_shift		# hi(man) is not all zeroes
-
-#
-# hi(man) is all zeroes so see if any bits in lo(man) are set
-#
-unnorm_chk_lo:
-	bfffo		FTEMP_LO(%a0){&0:&32}, %d0 # is operand really a zero?
-	beq.w		unnorm_zero		# yes
-
-	add.w		&32, %d0		# no; fix shift distance
-
-#
-# d0 = # shifts needed for complete normalization
-#
-unnorm_shift:
-	clr.l		%d1			# clear top word
-	mov.w		FTEMP_EX(%a0), %d1	# extract exponent
-	and.w		&0x7fff, %d1		# strip off sgn
-
-	cmp.w		%d0, %d1		# will denorm push exp < 0?
-	bgt.b		unnorm_nrm_zero		# yes; denorm only until exp = 0
-
-#
-# exponent would not go < 0. therefore, number stays normalized
-#
-	sub.w		%d0, %d1		# shift exponent value
-	mov.w		FTEMP_EX(%a0), %d0	# load old exponent
-	and.w		&0x8000, %d0		# save old sign
-	or.w		%d0, %d1		# {sgn,new exp}
-	mov.w		%d1, FTEMP_EX(%a0)	# insert new exponent
-
-	bsr.l		norm			# normalize UNNORM
-
-	mov.b		&NORM, %d0		# return new optype tag
-	rts
-
-#
-# exponent would go < 0, so only denormalize until exp = 0
-#
-unnorm_nrm_zero:
-	cmp.b		%d1, &32		# is exp <= 32?
-	bgt.b		unnorm_nrm_zero_lrg	# no; go handle large exponent
-
-	bfextu		FTEMP_HI(%a0){%d1:&32}, %d0 # extract new hi(man)
-	mov.l		%d0, FTEMP_HI(%a0)	# save new hi(man)
-
-	mov.l		FTEMP_LO(%a0), %d0	# fetch old lo(man)
-	lsl.l		%d1, %d0		# extract new lo(man)
-	mov.l		%d0, FTEMP_LO(%a0)	# save new lo(man)
-
-	and.w		&0x8000, FTEMP_EX(%a0)	# set exp = 0
-
-	mov.b		&DENORM, %d0		# return new optype tag
-	rts
-
-#
-# only mantissa bits set are in lo(man)
-#
-unnorm_nrm_zero_lrg:
-	sub.w		&32, %d1		# adjust shft amt by 32
-
-	mov.l		FTEMP_LO(%a0), %d0	# fetch old lo(man)
-	lsl.l		%d1, %d0		# left shift lo(man)
-
-	mov.l		%d0, FTEMP_HI(%a0)	# store new hi(man)
-	clr.l		FTEMP_LO(%a0)		# lo(man) = 0
-
-	and.w		&0x8000, FTEMP_EX(%a0)	# set exp = 0
-
-	mov.b		&DENORM, %d0		# return new optype tag
-	rts
-
-#
-# whole mantissa is zero so this UNNORM is actually a zero
-#
-unnorm_zero:
-	and.w		&0x8000, FTEMP_EX(%a0)	# force exponent to zero
-
-	mov.b		&ZERO, %d0		# fix optype tag
-	rts