// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // e32\euser\epoc\win32\uc_realx.cpp

 // 

 //

 #include "u32std.h"

 #include <e32math.h>

 #pragma warning (disable : 4100)	// unreferenced formal parameter

 #pragma warning (disable : 4700)	// local variable 'this' used without

 									// having been initialised

 #pragma warning ( disable : 4414 )  // short jump to function converted to near

 #if defined(__VC32__) && (_MSC_VER==1100)	// untested on MSVC++ > 5.0

 // Workaround for MSVC++ 5.0 bug; MSVC incorrectly fixes up conditional jumps

 // when the destination is a C++ function.

 #define _ASM_j(cond,dest) _asm jn##cond short $+11 _asm jmp dest

 #define _ASM_jn(cond,dest) _asm j##cond short $+11 _asm jmp dest

 #pragma optimize( "", off )			// stop MSVC murdering the code

 #else

 #define _ASM_j(cond,dest) _asm j##cond dest

 #define _ASM_jn(cond,dest) _asm jn##cond dest

 #endif

 //

 // 64-bit precision floating point routines

 // Register storage format:

 // edx:ebx=64 bit normalised mantissa

 // ecx bits 16-31 = 16-bit exponent, biased by 7FFF

 // ecx bit 0 = sign

 // ecx bit 8 = rounded-down flag

 // ecx bit 9 = rounded-up flag

 //

 // Memory storage format:

 // 3 doublewords per number

 // Low 32 bits of mantissa at [addr]

 // High 32 bits of mantissa at [addr+4]

 // Exponent/flags/sign at [addr+8]

 //

 LOCAL_C void TRealXPanic(TInt aErr)

 	{

 	User::Panic(_L("MATHX"),aErr);

 	}

 __NAKED__ LOCAL_C void TRealXPanicEax(void)

 	{

 	_asm push eax

 	_asm call TRealXPanic

 	}

 LOCAL_C __NAKED__ void TRealXRealIndefinite(void)

 	{

 	// return 'real indefinite' NaN in ecx,edx:ebx

 	_asm mov ecx, 0xFFFF0001	// exponent=FFFF, sign negative

 	_asm mov edx, 0xC0000000	// mantissa=C0000000 00000000

 	_asm xor ebx, ebx

 	_asm mov eax, -6			// return KErrArgument

 	_asm ret

 	}

 LOCAL_C __NAKED__ void TRealXBinOpNaN(void)

 	{

 	// generic routine to process NaN's in binary operations

 	// destination operand in ecx,edx:eax

 	// source operand at [esi]

 	_asm mov eax, [esi+8]		// source operand into eax,edi:ebp

 	_asm mov edi, [esi+4]

 	_asm mov ebp, [esi]

 	_asm cmp ecx, 0xFFFF0000	// check if dest is a NaN

 	_asm jb short TRealXBinOpNaN1	// if not, swap them

 	_asm cmp edx, 0x80000000

 	_asm jne short TRealXBinOpNaN2

 	_asm test ebx, ebx

 	_asm jne short TRealXBinOpNaN2

 	TRealXBinOpNaN1:			// swap the operands

 	_asm xchg ecx, eax

 	_asm xchg edx, edi

 	_asm xchg ebx, ebp

 	TRealXBinOpNaN2:

 	_asm cmp eax, 0xFFFF0000	// check if both operands are NaNs

 	_asm jb short TRealXBinOpNaN4	// if not, ignore non-NaN operand

 	_asm cmp edi, 0x80000000

 	_asm jne short TRealXBinOpNaN3

 	_asm test ebp, ebp

 	_asm je short TRealXBinOpNaN4

 	TRealXBinOpNaN3:			// if both operands are NaN's, compare significands

 	_asm cmp edx, edi

 	_asm ja short TRealXBinOpNaN4

 	_asm jb short TRealXBinOpNaN5

 	_asm cmp ebx, ebp

 	_asm jae short TRealXBinOpNaN4

 	TRealXBinOpNaN5:			// come here if dest is smaller - copy source to dest

 	_asm mov ecx, eax

 	_asm mov edx, edi

 	_asm mov ebx, ebp

 	TRealXBinOpNaN4:			// NaN with larger significand is in ecx,edx:ebx

 	_asm or edx, 0x40000000		// convert an SNaN to a QNaN

 	_asm mov eax, -6			// return KErrArgument

 	_asm ret

 	}

 // Add TRealX at [esi] + ecx,edx:ebx

 // Result in ecx,edx:ebx

 // Error code in eax

 // Note:	+0 + +0 = +0, -0 + -0 = -0, +0 + -0 = -0 + +0 = +0,

 //			+/-0 + X = X + +/-0 = X, X + -X = -X + X = +0

 __NAKED__ LOCAL_C void TRealXAdd()

 	{

 	_asm xor ch, ch				// clear rounding flags

 	_asm cmp ecx, 0xFFFF0000	// check if dest=NaN or infinity

 	_asm jnc addfpsd			// branch if it is

 	_asm mov eax, [esi+8]		// fetch sign/exponent of source

 	_asm cmp eax, 0xFFFF0000	// check if source=NaN or infinity

 	_asm jnc addfpss			// branch if it is

 	_asm cmp eax, 0x10000		// check if source=0

 	_asm jc addfp0s				// branch if it is

 	_asm cmp ecx, 0x10000		// check if dest=0

 	_asm jc addfp0d				// branch if it is

 	_asm and cl, 1				// clear bits 1-7 of ecx

 	_asm and al, 1				// clear bits 1-7 of eax

 	_asm mov ch, cl

 	_asm xor ch, al				// xor of signs into ch bit 0

 	_asm add ch, ch

 	_asm or cl, ch				// and into cl bit 1

 	_asm or al, ch				// and al bit 1

 	_asm xor ch, ch				// clear rounding flags

 	_asm mov ebp, [esi]			// fetch source mantissa 0-31

 	_asm mov edi, [esi+4]		// fetch source mantissa 32-63

 	_asm ror ecx, 16			// dest exponent into cx

 	_asm ror eax, 16			// source exponent into ax

 	_asm push ecx				// push dest exponent/sign

 	_asm sub cx, ax				// cx = dest exponent - source exponent

 	_asm je short addfp3b		// if equal, no shifting required

 	_asm ja short addfp1		// branch if dest exponent >= source exponent

 	_asm xchg ebx, ebp			// make sure edi:ebp contains the mantissa to be shifted

 	_asm xchg edx, edi			//

 	_asm xchg eax, [esp]		// and larger exponent and corresponding sign is on the stack

 	_asm neg cx					// make cx positive = number of right shifts needed

 	addfp1:

 	_asm cmp cx, 64				// if more than 64 shifts needed

 	_asm ja addfp2				// branch to output larger number

 	_asm jb addfp3				// branch if <64 shifts

 	_asm mov eax, edi			// exactly 64 shifts needed - rounding word=mant high

 	_asm test ebp, ebp			// check bits lost

 	_asm jz short addfp3a

 	_asm or ch, 1				// if not all zero, set rounded-down flag

 	addfp3a:

 	_asm xor edi, edi			// clear edx:ebx

 	_asm xor ebp, ebp

 	_asm jmp short addfp5		// finished shifting

 	addfp3b:					// exponents equal

 	_asm xor eax, eax			// set rounding word=0

 	_asm jmp short addfp5

 	addfp3:

 	_asm cmp cl, 32				// 32 or more shifts needed ?

 	_asm jb short addfp4		// skip if <32

 	_asm mov eax, ebp			// rounding word=mant low

 	_asm mov ebp, edi			// mant low=mant high

 	_asm xor edi, edi			// mant high=0

 	_asm sub cl, 32				// reduce count by 32

 	_asm jz short addfp5		// if now zero, finished shifting

 	_asm shrd edi, eax, cl		// shift ebp:eax:edi right by cl bits

 	_asm shrd eax, ebp, cl		//

 	_asm shr ebp, cl			//

 	_asm test edi, edi			// check bits lost in shift

 	_asm jz short addfp5		// if all zero, finished

 	_asm or ch, 1				// else set rounded-down flag

 	_asm xor edi, edi			// clear edx again

 	_asm jmp short addfp5		// finished shifting

 	addfp4:						// <32 shifts needed now

 	_asm xor eax, eax			// clear rounding word initially

 	_asm shrd eax, ebp, cl		// shift edi:ebp:eax right by cl bits

 	_asm shrd ebp, edi, cl		//

 	_asm shr edi, cl			//

 	addfp5:

 	_asm mov [esp+3], ch		// rounding flag into ch image on stack

 	_asm pop ecx				// recover sign and exponent into ecx, with rounding flag

 	_asm ror ecx, 16			// into normal position

 	_asm test cl, 2				// addition or subtraction needed ?

 	_asm jnz short subfp1		// branch if subtraction

 	_asm add ebx,ebp			// addition required - add mantissas

 	_asm adc edx,edi			//

 	_asm jnc short roundfp		// branch if no carry

 	_asm rcr edx,1				// shift carry right into mantissa

 	_asm rcr ebx,1				//

 	_asm rcr eax,1				// and into rounding word

 	_asm jnc short addfp5a

 	_asm or ch, 1				// if 1 shifted out, set rounded-down flag

 	addfp5a:

 	_asm add ecx, 0x10000		// and increment exponent

 	// perform rounding based on rounding word in eax and rounding flag in ch

 	roundfp:

 	_asm cmp eax, 0x80000000

 	_asm jc roundfp0			// if rounding word<80000000, round down

 	_asm ja roundfp1			// if >80000000, round up

 	_asm test ch, 1

 	_asm jnz short roundfp1		// if rounded-down flag set, round up

 	_asm test ch, 2

 	_asm jnz short roundfp0		// if rounded-up flag set, round down

 	_asm test bl, 1				// else test mantissa lsb

 	_asm jz short roundfp0		// round down if 0, up if 1 (round to even)

 	roundfp1:					// Come here to round up

 	_asm add ebx, 1				// increment mantissa

 	_asm adc edx,0				//

 	_asm jnc roundfp1a			// if no carry OK

 	_asm rcr edx,1				// else shift carry into mantissa (edx:ebx=0 here)

 	_asm add ecx, 0x10000		// and increment exponent

 	roundfp1a:

 	_asm cmp ecx, 0xFFFF0000	// check for overflow

 	_asm jae short addfpovfw	// jump if overflow

 	_asm mov ch, 2				// else set rounded-up flag

 	_asm xor eax, eax			// return KErrNone

 	_asm ret

 	roundfp0:					// Come here to round down

 	_asm cmp ecx, 0xFFFF0000	// check for overflow

 	_asm jae short addfpovfw	// jump if overflow

 	_asm test eax, eax			// else check if rounding word zero

 	_asm jz short roundfp0a		// if so, leave rounding flags as they are

 	_asm mov ch, 1				// else set rounded-down flag

 	roundfp0a:

 	_asm xor eax, eax			// return KErrNone

 	_asm ret					// exit

 	addfpovfw:					// Come here if overflow occurs

 	_asm xor ch, ch				// clear rounding flags, exponent=FFFF

 	_asm xor ebx, ebx

 	_asm mov edx, 0x80000000	// mantissa=80000000 00000000 for infinity

 	_asm mov eax, -9			// return KErrOverflow

 	_asm ret

 	// exponents differ by more than 64 - output larger number

 	addfp2:

 	_asm pop ecx				// recover exponent and sign

 	_asm ror ecx, 16			// into normal position

 	_asm or ch, 1				// set rounded-down flag

 	_asm test cl, 2				// check if signs the same

 	_asm jz addfp2a

 	_asm xor ch, 3				// if not, set rounded-up flag

 	addfp2a:

 	_asm xor eax, eax			// return KErrNone

 	_asm ret

 	// signs differ, so must subtract mantissas

 	subfp1:

 	_asm add ch, ch				// if rounded-down flag set, change it to rounded-up

 	_asm neg eax				// subtract rounding word from 0

 	_asm sbb ebx, ebp			// and subtract mantissas with borrow

 	_asm sbb edx, edi			//

 	_asm jnc short subfp2		// if no borrow, sign is correct

 	_asm xor cl, 1				// else change sign of result

 	_asm shr ch, 1				// change rounding back to rounded-down

 	_asm not eax				// negate rounding word

 	_asm not ebx				// and mantissa

 	_asm not edx				//

 	_asm add eax,1				// two's complement negation

 	_asm adc ebx,0				//

 	_asm adc edx,0				//

 	subfp2:

 	_asm jnz short subfp3		// branch if edx non-zero at this point

 	_asm mov edx, ebx			// else shift ebx into edx

 	_asm or edx, edx			//

 	_asm jz short subfp4		// if still zero, branch

 	_asm mov ebx, eax			// else shift rounding word into ebx

 	_asm xor eax, eax			// and zero rounding word

 	_asm sub ecx, 0x200000		// decrease exponent by 32 due to shift

 	_asm jnc short subfp3		// if no borrow, carry on

 	_asm jmp short subfpundflw	// if borrow here, underflow

 	subfp4:

 	_asm mov edx, eax			// move rounding word into edx

 	_asm or edx, edx			// is edx still zero ?

 	_asm jz short subfp0		// if so, result is precisely zero

 	_asm xor ebx, ebx			// else zero ebx and rounding word

 	_asm xor eax, eax			//

 	_asm sub ecx, 0x400000		// and decrease exponent by 64 due to shift

 	_asm jc short subfpundflw	// if borrow, underflow

 	subfp3:

 	_asm mov edi, ecx			// preserve sign and exponent

 	_asm bsr ecx, edx			// position of most significant 1 into ecx

 	_asm neg ecx				//

 	_asm add ecx, 31			// cl = 31-position of MS 1 = number of shifts to normalise

 	_asm shld edx, ebx, cl		// shift edx:ebx:eax left by cl bits

 	_asm shld ebx, eax, cl		//

 	_asm shl eax, cl			//

 	_asm mov ebp, ecx			// bit count into ebp for subtraction

 	_asm shl ebp, 16			// shift left by 16 to align with exponent

 	_asm mov ecx, edi			// exponent, sign, rounding flags back into ecx

 	_asm sub ecx, ebp			// subtract shift count from exponent

 	_asm jc short subfpundflw	// if borrow, underflow

 	_asm cmp ecx, 0x10000		// check if exponent 0

 	_asm jnc roundfp			// if not, jump to round result, else underflow

 	// come here if underflow

 	subfpundflw:

 	_asm and ecx, 1				// set exponent to zero, leave sign

 	_asm xor edx, edx

 	_asm xor ebx, ebx

 	_asm mov eax, -10			// return KErrUnderflow

 	_asm ret

 	// come here to return zero result

 	subfp0:

 	_asm xor ecx, ecx			// set exponent to zero, positive sign

 	_asm xor edx, edx

 	_asm xor ebx, ebx

 	addfp0snzd:

 	_asm xor eax, eax			// return KErrNone

 	_asm ret

 	// come here if source=0 - eax=source exponent/sign

 	addfp0s:

 	_asm cmp ecx, 0x10000		// check if dest=0

 	_asm jnc addfp0snzd			// if not, return dest unaltered

 	_asm and ecx, eax			// else both zero, result negative iff both zeros negative

 	_asm and ecx, 1

 	_asm xor eax, eax			// return KErrNone

 	_asm ret

 	// come here if dest=0, source nonzero

 	addfp0d:

 	_asm mov ebx, [esi]			// return source unaltered

 	_asm mov edx, [esi+4]

 	_asm mov ecx, [esi+8]

 	_asm xor eax, eax			// return KErrNone

 	_asm ret

 	// come here if dest=NaN or infinity

 	addfpsd:

 	_asm cmp edx, 0x80000000	// check for infinity

 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

 	_asm test ebx, ebx

 	_ASM_jn(e,TRealXBinOpNaN)

 	_asm mov eax, [esi+8]		// eax=second operand exponent

 	_asm cmp eax, 0xFFFF0000	// check second operand for NaN or infinity

 	_asm jae short addfpsd1		// branch if NaN or infinity

 	addfpsd2:

 	_asm mov eax, -9			// else return dest unaltered (infinity) and KErrOverflow

 	_asm ret

 	addfpsd1:

 	_asm mov ebp, [esi]			// source mantissa into edi:ebp

 	_asm mov edi, [esi+4]

 	_asm cmp edi, 0x80000000	// check for infinity

 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

 	_asm test ebp, ebp

 	_ASM_jn(e,TRealXBinOpNaN)

 	_asm xor al, cl				// both operands are infinity - check signs

 	_asm test al, 1

 	_asm jz short addfpsd2		// if both the same, return KErrOverflow

 	_asm jmp TRealXRealIndefinite	// else return 'real indefinite'

 	// come here if source=NaN or infinity, dest finite

 	addfpss:

 	_asm mov ebp, [esi]			// source mantissa into edi:ebp

 	_asm mov edi, [esi+4]

 	_asm cmp edi, 0x80000000	// check for infinity

 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

 	_asm test ebp, ebp

 	_ASM_jn(e,TRealXBinOpNaN)

 	_asm mov ecx, eax			// if source=infinity, return source unaltered

 	_asm mov edx, edi

 	_asm mov ebx, ebp

 	_asm mov eax, -9			// return KErrOverflow

 	_asm ret

 	}

 // Subtract TRealX at [esi] - ecx,edx:ebx

 // Result in ecx,edx:ebx

 // Error code in eax

 __NAKED__ LOCAL_C void TRealXSubtract()

 	{

 	_asm xor cl, 1              // negate subtrahend

 	_asm jmp TRealXAdd

 	}

 // Multiply TRealX at [esi] * ecx,edx:ebx

 // Result in ecx,edx:ebx

 // Error code in eax

 __NAKED__ LOCAL_C void TRealXMultiply()

 	{

 	_asm xor ch, ch				// clear rounding flags

 	_asm mov eax, [esi+8]		// fetch sign/exponent of source

 	_asm xor cl, al				// xor signs

 	_asm cmp ecx, 0xFFFF0000	// check if dest=NaN or infinity

 	_asm jnc mulfpsd			// branch if it is

 	_asm cmp eax, 0xFFFF0000	// check if source=NaN or infinity

 	_asm jnc mulfpss			// branch if it is

 	_asm cmp eax, 0x10000		// check if source=0

 	_asm jc mulfp0				// branch if it is

 	_asm cmp ecx, 0x10000		// check if dest=0

 	_asm jc mulfp0				// branch if it is

 	_asm push ecx				// save result sign

 	_asm shr ecx, 16			// dest exponent into cx

 	_asm shr eax, 16			// source exponent into ax

 	_asm add eax, ecx			// add exponents

 	_asm sub eax, 0x7FFE		// eax now contains result exponent

 	_asm push eax				// save it

 	_asm mov edi, edx			// save dest mantissa high

 	_asm mov eax, ebx			// dest mantissa low -> eax

 	_asm mul dword ptr [esi]	// dest mantissa low * source mantissa low -> edx:eax

 	_asm xchg ebx, eax			// result dword 0 -> ebx, dest mant low -> eax

 	_asm mov ebp, edx			// result dword 1 -> ebp

 	_asm mul dword ptr [esi+4]	// dest mant low * src mant high -> edx:eax

 	_asm add ebp, eax			// add in partial product to dwords 1 and 2

 	_asm adc edx, 0				//

 	_asm mov ecx, edx			// result dword 2 -> ecx

 	_asm mov eax, edi			// dest mant high -> eax

 	_asm mul dword ptr [esi+4]	// dest mant high * src mant high -> edx:eax

 	_asm add ecx, eax			// add in partial product to dwords 2, 3

 	_asm adc edx, 0				//

 	_asm mov eax, edi			// dest mant high -> eax

 	_asm mov edi, edx			// result dword 3 -> edi

 	_asm mul dword ptr [esi]	// dest mant high * src mant low -> edx:eax

 	_asm add ebp, eax			// add in partial product to dwords 1, 2

 	_asm adc ecx, edx			//

 	_asm adc edi, 0				// 128-bit mantissa product is now in edi:ecx:ebp:ebx

 	_asm mov edx, edi			// top 64 bits into edx:ebx

 	_asm mov edi, ebx

 	_asm mov ebx, ecx			// bottom 64 bits now in ebp:edi

 	_asm pop ecx				// recover exponent

 	_asm js short mulfp1		// skip if mantissa normalised

 	_asm add edi, edi			// else shift left (only one shift will be needed)

 	_asm adc ebp, ebp

 	_asm adc ebx, ebx

 	_asm adc edx, edx

 	_asm dec ecx				// and decrement exponent

 	mulfp1:

 	_asm cmp ebp, 0x80000000	// compare bottom 64 bits with 80000000 00000000 for rounding

 	_asm ja short mulfp2		// branch to round up

 	_asm jb short mulfp3		// branch to round down

 	_asm test edi, edi

 	_asm jnz short mulfp2		// branch to round up

 	_asm test bl, 1				// if exactly half-way, test LSB of result mantissa

 	_asm jz short mulfp4		// if LSB=0, round down (round to even)

 	mulfp2:

 	_asm add ebx, 1				// round up - increment mantissa

 	_asm adc edx, 0

 	_asm jnc short mulfp2a

 	_asm rcr edx, 1

 	_asm inc ecx

 	mulfp2a:

 	_asm mov al, 2				// set rounded-up flag

 	_asm jmp short mulfp5

 	mulfp3:						// round down

 	_asm xor al, al				// clear rounding flags

 	_asm or ebp, edi			// check for exact result

 	_asm jz short mulfp5		// skip if exact

 	mulfp4:						// come here to round down when we know result inexact

 	_asm mov al, 1				// else set rounded-down flag

 	mulfp5:						// final mantissa now in edx:ebx, exponent in ecx

 	_asm cmp ecx, 0xFFFF		// check for overflow

 	_asm jge short mulfp6		// branch if overflow

 	_asm cmp ecx, 0				// check for underflow

 	_asm jle short mulfp7		// branch if underflow

 	_asm shl ecx, 16			// else exponent up to top end of ecx

 	_asm mov ch, al				// rounding flags into ch

 	_asm pop eax				// recover result sign

 	_asm mov cl, al				// into cl

 	_asm xor eax, eax			// return KErrNone

 	_asm ret

 	// come here if overflow

 	mulfp6:

 	_asm pop eax				// recover result sign

 	_asm mov ecx, 0xFFFF0000	// exponent=FFFF

 	_asm mov cl, al				// sign into cl

 	_asm mov edx, 0x80000000	// set mantissa to 80000000 00000000 for infinity

 	_asm xor ebx, ebx

 	_asm mov eax, -9			// return KErrOverflow

 	_asm ret

 	// come here if underflow

 	mulfp7:

 	_asm pop eax				// recover result sign

 	_asm xor ecx, ecx			// exponent=0

 	_asm mov cl, al				// sign into cl

 	_asm xor edx, edx

 	_asm xor ebx, ebx

 	_asm mov eax, -10			// return KErrUnderflow

 	_asm ret

 	// come here if either operand zero

 	mulfp0:

 	_asm and ecx, 1				// set exponent=0, keep sign

 	_asm xor edx, edx

 	_asm xor ebx, ebx

 	_asm xor eax, eax			// return KErrNone

 	_asm ret

 	// come here if destination operand NaN or infinity

 	mulfpsd:

 	_asm cmp edx, 0x80000000	// check for infinity

 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

 	_asm test ebx, ebx

 	_ASM_jn(e,TRealXBinOpNaN)

 	_asm cmp eax, 0xFFFF0000	// check second operand for NaN or infinity

 	_asm jae short mulfpsd1		// branch if NaN or infinity

 	_asm cmp eax, 0x10000		// check if second operand zero

 	_ASM_j(c,TRealXRealIndefinite)	// if so, return 'real indefinite'

 	_asm mov eax, -9			// else return dest (infinity) with xor sign and KErrOverflow

 	_asm ret

 	mulfpsd1:

 	_asm mov ebp, [esi]			// source mantissa into edi:ebp

 	_asm mov edi, [esi+4]

 	_asm cmp edi, 0x80000000	// check for infinity

 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

 	_asm test ebp, ebp

 	_ASM_jn(e,TRealXBinOpNaN)

 	_asm mov eax, -9			// both operands infinity - return infinity with xor sign

 	_asm ret					// and KErrOverflow

 	// come here if source operand NaN or infinity, destination finite

 	mulfpss:

 	_asm mov ebp, [esi]			// source mantissa into edi:ebp

 	_asm mov edi, [esi+4]

 	_asm cmp edi, 0x80000000	// check for infinity

 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

 	_asm test ebp, ebp

 	_ASM_jn(e,TRealXBinOpNaN)

 	_asm cmp ecx, 0x10000		// source=infinity, check if dest=0

 	_ASM_j(c,TRealXRealIndefinite)	// if so, return 'real indefinite'

 	_asm or ecx, 0xFFFF0000		// set exp=FFFF, leave xor sign in cl

 	_asm mov edx, edi			// set mantissa for infinity

 	_asm mov ebx, ebp

 	_asm mov eax, -9			// return KErrOverflow

 	_asm ret

 	}

 // Divide 96-bit unsigned dividend EDX:EAX:0 by 64-bit unsigned divisor ECX:EBX

 // Assume ECX bit 31 = 1, ie 2^63 <= divisor < 2^64

 // Assume the quotient fits in 32 bits

 // Return 32 bit quotient in EDI

 // Return 64 bit remainder in EBP:ESI

 __NAKED__ LOCAL_C void LongDivide(void)

 	{

 	_asm push edx				// save dividend

 	_asm push eax				//

 	_asm cmp edx, ecx			// check if truncation of divisor will overflow DIV instruction

 	_asm jb short longdiv1		// skip if not

 	_asm xor eax, eax			// else return quotient of 0xFFFFFFFF

 	_asm dec eax				//

 	_asm jmp short longdiv2		//

 	longdiv1:

 	_asm div ecx				// divide EDX:EAX by ECX to give approximate quotient in EAX

 	longdiv2:

 	_asm mov edi, eax			// save approx quotient

 	_asm mul ebx				// multiply approx quotient by full divisor ECX:EBX

 	_asm mov esi, eax			// first partial product into EBP:ESI

 	_asm mov ebp, edx			//

 	_asm mov eax, edi			// approx quotient back into eax

 	_asm mul ecx				// upper partial product now in EDX:EAX

 	_asm add eax, ebp			// add to form 96-bit product in EDX:EAX:ESI

 	_asm adc edx, 0				//

 	_asm neg esi				// remainder = dividend - approx quotient * divisor

 	_asm mov ebp, [esp]			// fetch dividend bits 32-63

 	_asm sbb ebp, eax			//

 	_asm mov eax, [esp+4]		// fetch dividend bits 64-95

 	_asm sbb eax, edx			// remainder is now in EAX:EBP:ESI

 	_asm jns short longdiv4		// if remainder positive, quotient is correct, so exit

 	longdiv3:

 	_asm dec edi				// else quotient is too big, so decrement it

 	_asm add esi, ebx			// and add divisor to remainder

 	_asm adc ebp, ecx			//

 	_asm adc eax, 0				//

 	_asm js short longdiv3		// if still negative, repeat (requires <4 iterations)

 	longdiv4:

 	_asm add esp, 8				// remove dividend from stack

 	_asm ret					// return with quotient in EDI, remainder in EBP:ESI

 	}

 // Divide TRealX at [esi] / ecx,edx:ebx

 // Result in ecx,edx:ebx

 // Error code in eax

 __NAKED__ LOCAL_C void TRealXDivide(void)

 	{

 	_asm xor ch, ch				// clear rounding flags

 	_asm mov eax, [esi+8]		// fetch sign/exponent of dividend

 	_asm xor cl, al				// xor signs

 	_asm cmp eax, 0xFFFF0000	// check if dividend=NaN or infinity

 	_asm jnc divfpss			// branch if it is

 	_asm cmp ecx, 0xFFFF0000	// check if divisor=NaN or infinity

 	_asm jnc divfpsd			// branch if it is

 	_asm cmp ecx, 0x10000		// check if divisor=0

 	_asm jc divfpdv0			// branch if it is

 	_asm cmp eax, 0x10000		// check if dividend=0

 	_asm jc divfpdd0			// branch if it is

 	_asm push esi				// save pointer to dividend

 	_asm push ecx				// save result sign

 	_asm shr ecx, 16			// divisor exponent into cx

 	_asm shr eax, 16			// dividend exponent into ax

 	_asm sub eax, ecx			// subtract exponents

 	_asm add eax, 0x7FFE		// eax now contains result exponent

 	_asm push eax				// save it

 	_asm mov ecx, edx			// divisor mantissa into ecx:ebx

 	_asm mov edx, [esi+4]		// dividend mantissa into edx:eax

 	_asm mov eax, [esi]

 	_asm xor edi, edi			// clear edi initially

 	_asm cmp edx, ecx			// compare EDX:EAX with ECX:EBX

 	_asm jb short divfp1		// if EDX:EAX < ECX:EBX, leave everything as is

 	_asm ja short divfp2		//

 	_asm cmp eax, ebx			// if EDX=ECX, then compare ls dwords

 	_asm jb short divfp1		// if dividend mant < divisor mant, leave everything as is

 	divfp2:

 	_asm sub eax, ebx			// else dividend mant -= divisor mant

 	_asm sbb edx, ecx			//

 	_asm inc edi				// and EDI=1 (bit 0 of EDI is the integer part of the result)

 	_asm inc dword ptr [esp]	// also increment result exponent

 	divfp1:

 	_asm push edi				// save top bit of result

 	_asm call LongDivide		// divide EDX:EAX:0 by ECX:EBX to give next 32 bits of result in EDI

 	_asm push edi				// save next 32 bits of result

 	_asm mov edx, ebp			// remainder from EBP:ESI into EDX:EAX

 	_asm mov eax, esi			//

 	_asm call LongDivide		// divide EDX:EAX:0 by ECX:EBX to give next 32 bits of result in EDI

 	_asm test byte ptr [esp+4], 1	// test integer bit of result

 	_asm jnz short divfp4		// if set, no need to calculate another bit

 	_asm xor eax, eax			//

 	_asm add esi, esi			// 2*remainder into EAX:EBP:ESI

 	_asm adc ebp, ebp			//

 	_asm adc eax, eax			//

 	_asm sub esi, ebx			// subtract divisor to generate final quotient bit

 	_asm sbb ebp, ecx			//

 	_asm sbb eax, 0				//

 	_asm jnc short divfp3		// skip if no borrow - in this case eax=0

 	_asm add esi, ebx			// if borrow add back - final remainder now in EBP:ESI

 	_asm adc ebp, ecx			//

 	_asm adc eax, 0				// eax will be zero after this and carry will be set

 	divfp3:

 	_asm cmc					// final bit = 1-C

 	_asm rcr eax, 1				// shift it into eax bit 31

 	_asm mov ebx, edi			// result into EDX:EBX:EAX, remainder in EBP:ESI

 	_asm pop edx

 	_asm add esp, 4				// discard integer bit (zero)

 	_asm jmp short divfp5		// branch to round

 	divfp4:						// integer bit was set

 	_asm mov ebx, edi			// result into EDX:EBX:EAX

 	_asm pop edx				//

 	_asm pop eax				// integer part of result into eax (=1)

 	_asm stc					// shift a 1 into top end of mantissa

 	_asm rcr edx,1				//

 	_asm rcr ebx,1				//

 	_asm rcr eax,1				// bottom bit into eax bit 31

 	// when we get to here we have 65 bits of quotient mantissa in

 	// EDX:EBX:EAX (bottom bit in eax bit 31)

 	// and the remainder is in EBP:ESI

 	divfp5:

 	_asm pop ecx				// recover result exponent

 	_asm add eax, eax			// test rounding bit

 	_asm jnc short divfp6		// branch to round down

 	_asm or ebp, esi			// test remainder to see if we are exactly half-way

 	_asm jnz short divfp7		// if not, round up

 	_asm test bl, 1				// exactly halfway - test LSB of mantissa

 	_asm jz short divfp8		// round down if LSB=0 (round to even)

 	divfp7:

 	_asm add ebx, 1				// round up - increment mantissa

 	_asm adc edx, 0

 	_asm jnc short divfp7a

 	_asm rcr edx, 1				// if carry, shift 1 into mantissa MSB

 	_asm inc ecx				// and increment exponent

 	divfp7a:

 	_asm mov al, 2				// set rounded-up flag

 	_asm jmp short divfp9

 	divfp6:

 	_asm xor al, al				// round down - first clear rounding flags

 	_asm or ebp, esi			// test if result exact

 	_asm jz short divfp9		// skip if exact

 	divfp8:						// come here to round down when we know result is inexact

 	_asm mov al, 1				// set rounded-down flag

 	divfp9:						// final mantissa now in edx:ebx, exponent in ecx

 	_asm cmp ecx, 0xFFFF		// check for overflow

 	_asm jge short divfp10		// branch if overflow

 	_asm cmp ecx, 0				// check for underflow

 	_asm jle short divfp11		// branch if underflow

 	_asm shl ecx, 16			// else exponent up to top end of ecx

 	_asm mov ch, al				// rounding flags into ch

 	_asm pop eax				// recover result sign

 	_asm mov cl, al				// into cl

 	_asm pop esi				// recover dividend pointer

 	_asm xor eax, eax			// return KErrNone

 	_asm ret

 	// come here if overflow

 	divfp10:

 	_asm pop eax				// recover result sign

 	_asm mov ecx, 0xFFFF0000	// exponent=FFFF

 	_asm mov cl, al				// sign into cl

 	_asm mov edx, 0x80000000	// set mantissa to 80000000 00000000 for infinity

 	_asm xor ebx, ebx

 	_asm mov eax, -9			// return KErrOverflow

 	_asm pop esi				// recover dividend pointer

 	_asm ret

 	// come here if underflow

 	divfp11:

 	_asm pop eax				// recover result sign

 	_asm xor ecx, ecx			// exponent=0

 	_asm mov cl, al				// sign into cl

 	_asm xor edx, edx

 	_asm xor ebx, ebx

 	_asm mov eax, -10			// return KErrUnderflow

 	_asm pop esi				// recover dividend pointer

 	_asm ret

 	// come here if divisor=0, dividend finite

 	divfpdv0:

 	_asm cmp eax, 0x10000		// check if dividend also zero

 	_ASM_j(c,TRealXRealIndefinite)	// if so, return 'real indefinite'

 	_asm or ecx, 0xFFFF0000		// else set exponent=FFFF, leave xor sign in cl

 	_asm mov edx, 0x80000000	// set mantissa for infinity

 	_asm xor ebx, ebx

 	_asm mov eax, -41			// return KErrDivideByZero

 	_asm ret

 	// come here if dividend=0, divisor finite and nonzero

 	divfpdd0:

 	_asm and ecx, 1				// exponent=0, leave xor sign in cl

 	_asm xor eax, eax			// return KErrNone

 	_asm ret

 	// come here if dividend is a NaN or infinity

 	divfpss:

 	_asm mov ebp, [esi]			// dividend mantissa into edi:ebp

 	_asm mov edi, [esi+4]

 	_asm cmp edi, 0x80000000	// check for infinity

 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

 	_asm test ebp, ebp

 	_ASM_jn(e,TRealXBinOpNaN)

 	_asm cmp ecx, 0xFFFF0000	// check divisor for NaN or infinity

 	_asm jae short divfpss1		// branch if NaN or infinity

 	_asm or ecx, 0xFFFF0000		// infinity/finite - return infinity with xor sign

 	_asm mov edx, 0x80000000

 	_asm xor ebx, ebx

 	_asm mov eax, -9			// return KErrOverflow

 	_asm ret

 	divfpss1:

 	_asm cmp edx, 0x80000000	// check for infinity

 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

 	_asm test ebx, ebx

 	_ASM_jn(e,TRealXBinOpNaN)

 	_asm jmp TRealXRealIndefinite	// if both operands infinite, return 'real indefinite'

 	// come here if divisor is a NaN or infinity, dividend finite

 	divfpsd:

 	_asm cmp edx, 0x80000000	// check for infinity

 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

 	_asm test ebx, ebx

 	_ASM_jn(e,TRealXBinOpNaN)

 	_asm and ecx, 1				// dividend is finite, divisor=infinity, so return 0 with xor sign

 	_asm xor edx, edx

 	_asm xor ebx, ebx

 	_asm xor eax, eax			// return KErrNone

 	_asm ret

 	}

 // TRealX modulo - dividend at [esi], divisor in ecx,edx:ebx

 // Result in ecx,edx:ebx

 // Error code in eax

 __NAKED__ LOCAL_C void TRealXModulo(void)

 	{

 	_asm mov eax, [esi+8]		// fetch sign/exponent of dividend

 	_asm mov cl, al				// result sign=dividend sign

 	_asm xor ch, ch				// clear rounding flags

 	_asm cmp eax, 0xFFFF0000	// check if dividend=NaN or infinity

 	_asm jnc modfpss			// branch if it is

 	_asm cmp ecx, 0xFFFF0000	// check if divisor=NaN or infinity

 	_asm jnc modfpsd			// branch if it is

 	_asm cmp ecx, 0x10000		// check if divisor=0

 	_ASM_j(c,TRealXRealIndefinite)	// if so, return 'real indefinite'

 	_asm shr eax, 16			// ax=dividend exponent

 	_asm ror ecx, 16			// cx=divisor exponent

 	_asm sub ax, cx				// ax=dividend exponent-divisor exponent

 	_asm jc modfpdd0			// if dividend exponent is smaller, return dividend

 	_asm cmp ax, 64				// check if exponents differ by >= 64 bits

 	_asm jnc modfplp			// if so, underflow

 	_asm mov ah, 0				// ah bit 0 acts as 65th accumulator bit

 	_asm mov ebp, [esi]			// edi:ebp=dividend mantissa

 	_asm mov edi, [esi+4]		//

 	_asm jmp short modfp2		// skip left shift on first iteration

 	modfp1:

 	_asm add ebp, ebp			// shift accumulator left (65 bits)

 	_asm adc edi, edi

 	_asm adc ah, ah

 	modfp2:

 	_asm sub ebp, ebx			// subtract divisor from dividend

 	_asm sbb edi, edx

 	_asm sbb ah, 0

 	_asm jnc short modfp3		// skip if no borrow

 	_asm add ebp, ebx			// else add back

 	_asm adc edi, edx

 	_asm adc ah, 0

 	modfp3:

 	_asm dec al					// any more bits to do?

 	_asm jns short modfp1		// loop if there are

 	_asm mov edx, edi			// result mantissa (not yet normalised) into edx:ebx

 	_asm mov ebx, ebp

 	_asm or edi, ebx			// check for zero

 	_asm jz modfp0				// jump if result zero

 	_asm or edx, edx			// check if ms dword zero

 	_asm jnz short modfp4

 	_asm mov edx, ebx			// if so, shift left by 32

 	_asm xor ebx, ebx

 	_asm sub cx, 32				// and decrement exponent by 32

 	_asm jbe modfpund			// if borrow or exponent zero, underflow

 	modfp4:

 	_asm mov edi, ecx			// preserve sign and exponent

 	_asm bsr ecx, edx			// position of most significant 1 into ecx

 	_asm neg ecx				//

 	_asm add ecx, 31			// cl = 31-position of MS 1 = number of shifts to normalise

 	_asm shld edx, ebx, cl		// shift edx:ebx left by cl bits

 	_asm shl ebx, cl			//

 	_asm mov ebp, ecx			// bit count into ebp for subtraction

 	_asm mov ecx, edi			// exponent & sign back into ecx

 	_asm sub cx, bp				// subtract shift count from exponent

 	_asm jbe short modfpund		// if borrow or exponent 0, underflow

 	_asm rol ecx, 16			// else ecx=exponent:sign

 	_asm xor eax, eax			// normal exit, result in ecx,edx:ebx

 	_asm ret

 	// dividend=NaN or infinity

 	modfpss:

 	_asm mov ebp, [esi]			// dividend mantissa into edi:ebp

 	_asm mov edi, [esi+4]

 	_asm cmp edi, 0x80000000	// check for infinity

 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

 	_asm test ebp, ebp

 	_ASM_jn(e,TRealXBinOpNaN)

 	_asm cmp ecx, 0xFFFF0000	// check divisor for NaN or infinity

 	_ASM_j(b,TRealXRealIndefinite)	// infinity%finite - return 'real indefinite'

 	_asm cmp edx, 0x80000000	// check for divisor=infinity

 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

 	_asm test ebx, ebx

 	_ASM_jn(e,TRealXBinOpNaN)

 	_asm jmp TRealXRealIndefinite	// if both operands infinite, return 'real indefinite'

 	// divisor=NaN or infinity, dividend finite

 	modfpsd:

 	_asm cmp edx, 0x80000000	// check for infinity

 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

 	_asm test ebx, ebx

 	_ASM_jn(e,TRealXBinOpNaN)

 	// finite%infinity - return dividend unaltered

 	modfpdd0:

 	_asm mov ebx, [esi]			// normal exit, return dividend unaltered

 	_asm mov edx, [esi+4]

 	_asm mov ecx, [esi+8]

 	_asm xor eax, eax

 	_asm ret

 	modfp0:

 	_asm shr ecx, 16			// normal exit, result 0

 	_asm xor eax, eax

 	_asm ret

 	modfpund:

 	_asm shr ecx, 16			// underflow, result 0

 	_asm mov eax, -10			// return KErrUnderflow

 	_asm ret

 	modfplp:

 	_asm shr ecx, 16			// loss of precision, result 0

 	_asm mov eax, -7			// return KErrTotalLossOfPrecision

 	_asm ret

 	}

 __NAKED__ EXPORT_C TRealX::TRealX()

 /**

 Constructs a default extended precision object.

 This sets the value to zero.

 */

 	{

 	_asm xor eax, eax

 	_asm mov [ecx], eax			// set value to zero

 	_asm mov [ecx+4], eax

 	_asm mov [ecx+8], eax

 	_asm mov eax, ecx			// must return this

 	_asm ret

 	}

 __NAKED__ EXPORT_C TRealX::TRealX(TUint /*aExp*/, TUint /*aMantHi*/, TUint /*aMantLo*/)

 /**

 Constructs an extended precision object from an explicit exponent and

 a 64 bit mantissa.

 @param aExp    The exponent 

 @param aMantHi The high order 32 bits of the 64 bit mantissa 

 @param aMantLo The low order 32 bits of the 64 bit mantissa 

 */

 	{

 	_asm mov eax, [esp+4]		// eax=aExp

 	_asm mov [ecx+8], eax

 	_asm mov eax, [esp+8]		// eax=aMantHi

 	_asm mov [ecx+4], eax

 	_asm mov eax, [esp+12]		// eax=aMantLo

 	_asm mov [ecx], eax

 	_asm mov eax, ecx			// must return this

 	_asm ret 12

 	}

 __NAKED__ EXPORT_C TInt TRealX::Set(TInt /*aInt*/)

 /**

 Gives this extended precision object a new value taken

 from a signed integer.

 @param aInt The signed integer value.

 @return KErrNone, always.

 */

 	{

 	// on entry ecx=this, [esp+4]=aInt, return code in eax

 	_asm mov edx, [esp+4]		// edx=aInt

 	_asm or edx, edx			// test sign/zero

 	_asm mov eax, 0x7FFF

 	_asm jz short trealxfromint0	// branch if 0

 	_asm jns short trealxfromint1	// skip if positive

 	_asm neg edx					// take absolute value

 	_asm add eax, 0x10000			// sign bit in eax bit 16

 	trealxfromint1:

 	_asm push ecx					// save this

 	_asm bsr ecx, edx				// bit number of edx MSB into ecx

 	_asm add eax, ecx				// add to eax to form result exponent

 	_asm neg cl

 	_asm add cl, 31					// 31-bit number = number of shifts to normalise edx

 	_asm shl edx, cl				// normalise edx

 	_asm pop ecx					// this back into ecx

 	_asm ror eax, 16				// sign/exponent into normal positions

 	_asm mov [ecx+4], edx			// store mantissa high word

 	_asm mov [ecx+8], eax			// store sign/exponent

 	_asm xor eax, eax

 	_asm mov [ecx], eax				// zero mantissa low word

 	_asm ret 4						// return KErrNone

 	trealxfromint0:

 	_asm mov [ecx], edx

 	_asm mov [ecx+4], edx			// store mantissa high word=0

 	_asm mov [ecx+8], edx			// store sign/exponent=0

 	_asm xor eax, eax				// return KErrNone

 	_asm ret 4

 	}

 __NAKED__ EXPORT_C TInt TRealX::Set(TUint /*aInt*/)

 /**

 Gives this extended precision object a new value taken from

 an unsigned integer.

 @param aInt The unsigned integer value.

 @return KErrNone, always.

 */

 	{

 	// on entry ecx=this, [esp+4]=aInt, return code in eax

 	_asm mov edx, [esp+4]		// edx=aInt

 	_asm mov eax, 0x7FFF

 	_asm or edx, edx				// test for 0

 	_asm jz short trealxfromuint0	// branch if 0

 	_asm push ecx					// save this

 	_asm bsr ecx, edx				// bit number of edx MSB into ecx

 	_asm add eax, ecx				// add to eax to form result exponent

 	_asm neg cl

 	_asm add cl, 31					// 31-bit number = number of shifts to normalise edx

 	_asm shl edx, cl				// normalise edx

 	_asm pop ecx					// this back into ecx

 	_asm shl eax, 16				// exponent into normal position

 	_asm mov [ecx+4], edx			// store mantissa high word

 	_asm mov [ecx+8], eax			// store exponent

 	_asm xor eax, eax

 	_asm mov [ecx], eax				// zero mantissa low word

 	_asm ret 4						// return KErrNone

 	trealxfromuint0:

 	_asm mov [ecx], edx

 	_asm mov [ecx+4], edx			// store mantissa high word=0

 	_asm mov [ecx+8], edx			// store sign/exponent=0

 	_asm xor eax, eax				// return KErrNone

 	_asm ret 4

 	}

 __NAKED__ LOCAL_C void TRealXFromTInt64(void)

 	{

 	// Convert TInt64 in edx:ebx to TRealX in ecx,edx:ebx

 	_asm mov eax, 0x7FFF

 	_asm or edx, edx				// test sign/zero

 	_asm jz short trealxfromtint64a	// branch if top word zero

 	_asm jns short trealxfromtint64b

 	_asm add eax, 0x10000			// sign bit into eax bit 16

 	_asm neg edx					// take absolute value

 	_asm neg ebx

 	_asm sbb edx, 0

 	_asm jz short trealxfromtint64d	// branch if top word zero

 	trealxfromtint64b:

 	_asm bsr ecx, edx				// ecx=bit number of edx MSB

 	_asm add eax, ecx				// add to exponent in eax

 	_asm add eax, 32

 	_asm neg cl

 	_asm add cl, 31					// 31-bit number = number of left shifts to normalise

 	_asm shld edx, ebx, cl			// shift left to normalise edx:ebx

 	_asm shl ebx, cl

 	_asm mov ecx, eax				// sign/exponent into ecx

 	_asm ror ecx, 16				// and into normal positions

 	_asm ret

 	trealxfromtint64a:				// come here if top word zero

 	_asm or ebx, ebx				// test for bottom word also zero

 	_asm jz short trealxfromtint64c	// branch if it is

 	trealxfromtint64d:				// come here if top word zero, bottom word not

 	_asm mov edx, ebx				// shift edx:ebx left 32

 	_asm xor ebx, ebx

 	_asm bsr ecx, edx				// ecx=bit number of edx MSB

 	_asm add eax, ecx				// add to exponent in eax

 	_asm neg cl

 	_asm add cl, 31					// 31-bit number = number of left shifts to normalise

 	_asm shl edx, cl				// normalise

 	_asm mov ecx, eax				// sign/exponent into ecx

 	_asm ror ecx, 16				// and into normal positions

 	_asm ret

 	trealxfromtint64c:				// entire number is zero

 	_asm xor ecx, ecx

 	_asm ret

 	}

 __NAKED__ EXPORT_C TInt TRealX::Set(const TInt64& /*aInt*/)

 /**

 Gives this extended precision object a new value taken from

 a 64 bit integer.

 @param aInt The 64 bit integer value.

 @return KErrNone, always.

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aInt, return code in eax

 	_asm push ebx

 	_asm push ecx

 	_asm mov edx, [esp+12]		// edx=address of aInt

 	_asm mov ebx, [edx]

 	_asm mov edx, [edx+4]		// edx:ebx=aInt

 	_asm call TRealXFromTInt64	// convert to TRealX in ecx,edx:ebx

 	_asm pop eax				// eax=this

 	_asm mov [eax], ebx			// store result

 	_asm mov [eax+4], edx

 	_asm mov [eax+8], ecx

 	_asm xor eax, eax			// return KErrNone

 	_asm pop ebx

 	_asm ret 4

 	}

 __NAKED__ LOCAL_C void __6TRealXi()

 	{

 	// common function for int to TRealX

 	_asm mov edx, [esp+4]		// edx=aInt

 	_asm or edx, edx			// test sign/zero

 	_asm mov eax, 0x7FFF

 	_asm jz short trealxfromint0	// branch if 0

 	_asm jns short trealxfromint1	// skip if positive

 	_asm neg edx					// take absolute value

 	_asm add eax, 0x10000			// sign bit in eax bit 16

 	trealxfromint1:

 	_asm push ecx					// save this

 	_asm bsr ecx, edx				// bit number of edx MSB into ecx

 	_asm add eax, ecx				// add to eax to form result exponent

 	_asm neg cl

 	_asm add cl, 31					// 31-bit number = number of shifts to normalise edx

 	_asm shl edx, cl				// normalise edx

 	_asm pop ecx					// this back into ecx

 	_asm ror eax, 16				// sign/exponent into normal positions

 	_asm mov [ecx+4], edx			// store mantissa high word

 	_asm mov [ecx+8], eax			// store sign/exponent

 	_asm xor eax, eax

 	_asm mov [ecx], eax				// zero mantissa low word

 	_asm mov eax, ecx				// return eax=this

 	_asm ret 4

 	trealxfromint0:

 	_asm mov [ecx], edx

 	_asm mov [ecx+4], edx			// store mantissa high word=0

 	_asm mov [ecx+8], edx			// store sign/exponent=0

 	_asm mov eax, ecx				// return eax=this

 	_asm ret 4

 	}

 __NAKED__ EXPORT_C TRealX::TRealX(TInt /*aInt*/)

 /**

 Constructs an extended precision object from a signed integer value.

 @param aInt The signed integer value.

 */

 	{

 	// on entry ecx=this, [esp+4]=aInt, return eax=this

 	_asm jmp __6TRealXi

 	}

 __NAKED__ EXPORT_C TRealX& TRealX::operator=(TInt /*aInt*/)

 /**

 Assigns the specified signed integer value to this extended precision object.

 @param aInt The signed integer value.

 @return A reference to this extended precision object.

 */

 	{

 	// on entry ecx=this, [esp+4]=aInt, return eax=this

 	_asm jmp __6TRealXi

 	}

 __NAKED__ LOCAL_C void __6TRealXui()

 	{

 	// common function for unsigned int to TRealX

 	_asm mov edx, [esp+4]		// edx=aInt

 	_asm mov eax, 0x7FFF

 	_asm or edx, edx				// test for zero

 	_asm jz short trealxfromuint0	// branch if 0

 	_asm push ecx					// save this

 	_asm bsr ecx, edx				// bit number of edx MSB into ecx

 	_asm add eax, ecx				// add to eax to form result exponent

 	_asm neg cl

 	_asm add cl, 31					// 31-bit number = number of shifts to normalise edx

 	_asm shl edx, cl				// normalise edx

 	_asm pop ecx					// this back into ecx

 	_asm shl eax, 16				// exponent into normal position

 	_asm mov [ecx+4], edx			// store mantissa high word

 	_asm mov [ecx+8], eax			// store exponent

 	_asm xor eax, eax

 	_asm mov [ecx], eax				// zero mantissa low word

 	_asm mov eax, ecx				// return eax=this

 	_asm ret 4

 	trealxfromuint0:

 	_asm mov [ecx], edx

 	_asm mov [ecx+4], edx			// store mantissa high word=0

 	_asm mov [ecx+8], edx			// store sign/exponent=0

 	_asm mov eax, ecx				// return eax=this

 	_asm ret 4

 	}

 __NAKED__ EXPORT_C TRealX::TRealX(TUint /*aInt*/)

 /**

 Constructs an extended precision object from an unsigned integer value.

 @param aInt The unsigned integer value.

 */

 	{

 	// on entry ecx=this, [esp+4]=aInt, return eax=this

 	_asm jmp __6TRealXui

 	}

 __NAKED__ EXPORT_C TRealX& TRealX::operator=(TUint /*aInt*/)

 /**

 Assigns the specified unsigned integer value to this extended precision object.

 @param aInt The unsigned integer value.

 @return A reference to this extended precision object.

 */

 	{

 	// on entry ecx=this, [esp+4]=aInt, return eax=this

 	_asm jmp __6TRealXui

 	}

 __NAKED__ LOCAL_C void __6TRealXRC6TInt64()

 	{

 	// common function for TInt64 to TRealX

 	_asm push ebx				// preserve ebx

 	_asm push ecx				// save this

 	_asm mov edx, [esp+12]		// edx=address of aInt

 	_asm mov ebx, [edx]

 	_asm mov edx, [edx+4]		// edx:ebx=aInt

 	_asm call TRealXFromTInt64	// convert to TRealX in ecx,edx:ebx

 	_asm pop eax				// eax=this

 	_asm mov [eax], ebx			// store result

 	_asm mov [eax+4], edx

 	_asm mov [eax+8], ecx

 	_asm pop ebx				// restore ebx

 	_asm ret 4					// return this in eax

 	}

 __NAKED__ EXPORT_C TRealX::TRealX(const TInt64& /*aInt*/)

 /**

 Constructs an extended precision object from a 64 bit integer.

 @param aInt A reference to a 64 bit integer. 

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aInt, return eax=this

 	_asm jmp __6TRealXRC6TInt64

 	}

 __NAKED__ EXPORT_C TRealX& TRealX::operator=(const TInt64& /*aInt*/)

 /**

 Assigns the specified 64 bit integer value to this extended precision object.

 @param aInt A reference to a 64 bit integer. 

 @return A reference to this extended precision object.

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aInt, return eax=this

 	_asm jmp __6TRealXRC6TInt64

 	}

 __NAKED__ LOCAL_C void ConvertTReal32ToTRealX(void)

 	{

 	// Convert TReal32 in edx to TRealX in ecx:edx,ebx

 	_asm xor ebx, ebx			// mant low always zero

 	_asm mov eax, edx

 	_asm shr eax, 23			// exponent now in al, sign in ah bit 0

 	_asm test al, al			// check for denormal/zero

 	_asm jz short treal32totrealx2	// branch if denormal/zero

 	_asm xor ecx, ecx

 	_asm mov cl, al

 	_asm add ecx, 0x7F80		// bias exponent correctly for TRealX

 	_asm cmp al, 0xFF			// check for infinity/NaN

 	_asm jnz short treal32totrealx1	// skip if neither

 	_asm mov cl, al				// else set TRealX exponent to FFFF

 	_asm mov ch, al

 	treal32totrealx1:

 	_asm shl edx, 8				// left-justify mantissa in edx

 	_asm or edx, 0x80000000		// put in implied integer bit

 	_asm shl ecx, 16			// exponent into ecx bits 16-31

 	_asm mov cl, ah				// sign into ecx bit 0

 	_asm ret

 	treal32totrealx2:			// come here if exponent 0

 	_asm shl edx, 9				// left-justify mantissa in edx (shift out integer bit as well)

 	_asm jnz short treal32totrealx3	// jump if denormal

 	_asm xor ecx, ecx			// else return 0

 	_asm mov cl, ah				// with same sign as input value

 	_asm ret

 	treal32totrealx3:			// come here if denormal

 	_asm bsr ecx, edx			// ecx=bit number of MSB of edx

 	_asm neg ecx

 	_asm add ecx, 31			// ecx=number of left shifts to normalise edx

 	_asm shl edx, cl			// normalise

 	_asm neg ecx

 	_asm add ecx, 0x7F80			// exponent=7F80-number of shifts

 	_asm shl ecx, 16			// exponent into ecx bits 16-31

 	_asm mov cl, ah				// sign into ecx bit 0

 	_asm ret

 	}

 __NAKED__ LOCAL_C void ConvertTReal64ToTRealX(void)

 	{

 	// Convert TReal64 in edx:ebx to TRealX in ecx:edx,ebx

 	_asm mov eax, edx

 	_asm shr eax, 20

 	_asm mov ecx, 0x7FF

 	_asm and ecx, eax				// ecx=exponent

 	_asm jz short treal64totrealx1	// branch if zero/denormal

 	_asm add ecx, 0x7C00			// else bias exponent correctly for TRealX

 	_asm cmp ecx, 0x83FF			// check for infinity/NaN

 	_asm jnz short treal64totrealx2

 	_asm mov ch, cl					// if so, set exponent to FFFF

 	treal64totrealx2:

 	_asm shl ecx, 16				// exponent into ecx bits 16-31

 	_asm mov cl, 11					// number of shifts needed to justify mantissa correctly

 	_asm shld edx, ebx, cl			// shift mantissa left

 	_asm shl ebx, cl

 	_asm or edx, 0x80000000			// put in implied integer bit

 	_asm shr eax, 11				// sign bit into al bit 0

 	_asm mov cl, al					// into ecx bit 0

 	_asm ret

 	treal64totrealx1:				// come here if zero/denormal

 	_asm mov cl, 12					// number of shifts needed to justify mantissa correctly

 	_asm shld edx, ebx, cl			// shift mantissa left

 	_asm shl ebx, cl

 	_asm test edx, edx				// check for zero

 	_asm jnz short treal64totrealx3

 	_asm test ebx, ebx

 	_asm jnz short treal64totrealx4

 	_asm shr eax, 11				// sign bit into eax bit 0, rest of eax=0

 	_asm mov ecx, eax				// return 0 result with correct sign

 	_asm ret

 	treal64totrealx4:				// come here if denormal, edx=0

 	_asm mov edx, ebx				// shift mantissa left 32

 	_asm xor ebx, ebx

 	_asm bsr ecx, edx				// ecx=bit number of MSB of edx

 	_asm neg ecx

 	_asm add ecx, 31				// ecx=number of left shifts to normalise edx

 	_asm shl edx, cl				// normalise

 	_asm neg ecx

 	_asm add ecx, 0x7BE0			// exponent=7BE0-number of shifts

 	_asm shl ecx, 16				// exponent into bits 16-31 of ecx

 	_asm shr eax, 11

 	_asm mov cl, al					// sign into bit 0 of ecx

 	_asm ret

 	treal64totrealx3:				// come here if denormal, edx nonzero

 	_asm bsr ecx, edx				// ecx=bit number of MSB of edx

 	_asm neg ecx

 	_asm add ecx, 31				// ecx=number of left shifts to normalise edx:ebx

 	_asm shld edx, ebx, cl			// normalise

 	_asm shl ebx, cl

 	_asm neg ecx

 	_asm add ecx, 0x7C00				// exponent=7C00-number of shifts

 	_asm shl ecx, 16				// exponent into bits 16-31 of ecx

 	_asm shr eax, 11

 	_asm mov cl, al					// sign into bit 0 of ecx

 	_asm ret

 	}

 __NAKED__ EXPORT_C TInt TRealX::Set(TReal32 /*aReal*/)

 /**

 Gives this extended precision object a new value taken from

 a single precision floating point number.

 @param aReal The single precision floating point value. 

 @return KErrNone, if a valid number;

         KErrOverflow, if the number is infinite;

         KErrArgument, if not a number.

 */

 	{

 	// on entry, ecx=this and aReal is in [esp+4]

 	// on exit, error code in eax

 	_asm push ebx					// save ebx

 	_asm push ecx					// save this

 	_asm mov edx, [esp+12]			// aReal into edx

 	_asm call ConvertTReal32ToTRealX

 	_asm pop eax					// eax=this

 	_asm mov [eax], ebx				// store result

 	_asm mov [eax+4], edx

 	_asm mov [eax+8], ecx

 	_asm xor eax, eax				// error code=KErrNone initially

 	_asm cmp ecx, 0xFFFF0000		// check for infinity/NaN

 	_asm jb short trealxsettreal32a	// if neither, return KErrNone

 	_asm mov eax, -9				// eax=KErrOverflow

 	_asm cmp edx, 0x80000000			// check for infinity

 	_asm je short trealxsettreal32a	// if infinity, return KErrOverflow

 	_asm mov eax, -6				// if NaN, return KErrArgument

 	trealxsettreal32a:

 	_asm pop ebx

 	_asm ret 4

 	}

 __NAKED__ EXPORT_C TInt TRealX::Set(TReal64 /*aReal*/)

 /**

 Gives this extended precision object a new value taken from

 a double precision floating point number.

 @param aReal The double precision floating point value. 

 @return KErrNone, if a valid number;

         KErrOverflow, if the number is infinite;

         KErrArgument, if not a number.

 */

 	{

 	// on entry, ecx=this and aReal is in [esp+4] (mant low) and [esp+8] (sign/exp/mant high)

 	// on exit, error code in eax

 	_asm push ebx				// save ebx

 	_asm push ecx				// save this

 	_asm mov ebx, [esp+12]		// aReal into edx:ebx

 	_asm mov edx, [esp+16]

 	_asm call ConvertTReal64ToTRealX

 	_asm pop eax				// eax=this

 	_asm mov [eax], ebx			// store result

 	_asm mov [eax+4], edx

 	_asm mov [eax+8], ecx

 	_asm xor eax, eax				// error code=KErrNone initially

 	_asm cmp ecx, 0xFFFF0000		// check for infinity/NaN

 	_asm jb short trealxsettreal64a	// if neither, return KErrNone

 	_asm mov eax, -9				// eax=KErrOverflow

 	_asm cmp edx, 0x80000000			// check for infinity

 	_asm jne short trealxsettreal64b	// branch if NaN

 	_asm test ebx, ebx

 	_asm je short trealxsettreal64a		// if infinity, return KErrOverflow

 	trealxsettreal64b:

 	_asm mov eax, -6				// if NaN, return KErrArgument

 	trealxsettreal64a:

 	_asm pop ebx

 	_asm ret 8

 	}

 __NAKED__ LOCAL_C void __6TRealXf()

 	{

 	// common function for float to TRealX

 	_asm push ebx				// save ebx

 	_asm push ecx				// save this

 	_asm mov edx, [esp+12]		// aReal into edx

 	_asm call ConvertTReal32ToTRealX

 	_asm pop eax				// eax=this

 	_asm mov [eax], ebx			// store result

 	_asm mov [eax+4], edx

 	_asm mov [eax+8], ecx

 	_asm pop ebx

 	_asm ret 4

 	}

 __NAKED__ EXPORT_C TRealX::TRealX(TReal32 /*aReal*/)

 /**

 Constructs an extended precision object from

 a single precision floating point number.

 @param aReal The single precision floating point value.

 */

 	{

 	// on entry, ecx=this and aReal is in [esp+4]

 	// on exit, eax=this

 	_asm jmp __6TRealXf

 	}

 __NAKED__ EXPORT_C TRealX& TRealX::operator=(TReal32 /*aReal*/)

 /**

 Assigns the specified single precision floating point number to

 this extended precision object.

 @param aReal The single precision floating point value.

 @return A reference to this extended precision object.

 */

 	{

 	// on entry, ecx=this and aReal is in [esp+4]

 	// on exit, eax=this

 	_asm jmp __6TRealXf

 	}

 __NAKED__ LOCAL_C void __6TRealXd()

 	{

 	// common function for double to TRealX

 	_asm push ebx				// save ebx

 	_asm push ecx				// save this

 	_asm mov ebx, [esp+12]		// aReal into edx:ebx

 	_asm mov edx, [esp+16]

 	_asm call ConvertTReal64ToTRealX

 	_asm pop eax				// eax=this

 	_asm mov [eax], ebx			// store result

 	_asm mov [eax+4], edx

 	_asm mov [eax+8], ecx

 	_asm pop ebx

 	_asm ret 8

 	}

 __NAKED__ EXPORT_C TRealX::TRealX(TReal64 /*aReal*/)

 /**

 Constructs an extended precision object from

 a double precision floating point number.

 @param aReal The double precision floating point value.

 */

 	{

 	// on entry, ecx=this and aReal is in [esp+4] (mant low) and [esp+8] (sign/exp/mant high)

 	// on exit, eax=this

 	_asm jmp __6TRealXd

 	}

 __NAKED__ EXPORT_C TRealX& TRealX::operator=(TReal64 /*aReal*/)

 /**

 Assigns the specified double precision floating point number to

 this extended precision object.

 @param aReal The double precision floating point value.

 @return A reference to this extended precision object.

 */

 	{

 	// on entry, ecx=this and aReal is in [esp+4] (mant low) and [esp+8] (sign/exp/mant high)

 	// on exit, eax=this

 	_asm jmp __6TRealXd

 	}

 __NAKED__ EXPORT_C TRealX::operator TInt() const

 /**

 Gets the extended precision value as a signed integer value.

 The operator returns:

 1. zero , if the extended precision value is not a number

 2. 0x7FFFFFFF, if the value is positive and too big to fit into a TInt.

 3. 0x80000000, if the value is negative and too big to fit into a TInt.

 */

 	{

 	// on entry ecx=this, return value in eax

 	_asm mov edx, [ecx]			// edx=mantissa low

 	_asm mov eax, [ecx+4]		// eax=mantissa high

 	_asm mov ecx, [ecx+8]		// ecx=exponent/sign

 	_asm ror ecx, 16			// exponent into cx

 	_asm cmp cx, 0xFFFF

 	_asm jz short trealxtoint1	// branch if exp=FFFF

 	_asm mov dx, cx

 	_asm mov cx, 0x801E

 	_asm sub cx, dx				// cx=number of right shifts needed to convert mantissa to int

 	_asm jbe short trealxtoint2	// if exp>=801E, saturate result

 	_asm cmp cx, 31				// more than 31 shifts needed?

 	_asm ja short trealxtoint0	// if so, underflow to zero

 	_asm shr eax, cl			// else ABS(result)=eax>>cl

 	_asm test ecx, 0x10000		// test sign

 	_asm jz short trealxtoint3	// skip if +

 	_asm neg eax

 	trealxtoint3:

 	_asm ret

 	trealxtoint1:			// come here if exponent=FFFF

 	_asm cmp eax, 0x80000000		// check for infinity

 	_asm jnz short trealxtoint0	// if NaN, return 0

 	_asm test edx, edx

 	_asm jnz short trealxtoint0	// if NaN, return 0

 	trealxtoint2:			// come here if argument too big for 32-bit integer

 	_asm mov eax, 0x7FFFFFFF

 	_asm shr ecx, 17			// sign bit into carry flag

 	_asm adc eax, 0				// eax=7FFFFFFF if +, 80000000 if -

 	_asm ret					// return saturated value

 	trealxtoint0:			// come here if INT(argument)=0 or NaN

 	_asm xor eax, eax			// return 0

 	_asm ret

 	}

 __NAKED__ EXPORT_C TRealX::operator TUint() const

 /**

 Returns the extended precision value as an unsigned signed integer value.

 The operator returns:

 1. zero, if the extended precision value is not a number

 2. 0xFFFFFFFF, if the value is positive and too big to fit into a TUint.

 3. zero, if the value is negative and too big to fit into a TUint.

 */

 	{

 	// on entry ecx=this, return value in eax

 	_asm mov edx, [ecx]			// edx=mantissa low

 	_asm mov eax, [ecx+4]		// eax=mantissa high

 	_asm mov ecx, [ecx+8]		// ecx=exponent/sign

 	_asm ror ecx, 16			// exponent into cx

 	_asm cmp cx, 0xFFFF

 	_asm jz short trealxtouint1	// branch if exp=FFFF

 	_asm mov dx, cx

 	_asm mov cx, 0x801E

 	_asm sub cx, dx				// cx=number of right shifts needed to convert mantissa to int

 	_asm jb short trealxtouint2	// if exp>801E, saturate result

 	_asm cmp cx, 31				// more than 31 shifts needed?

 	_asm ja short trealxtouint0	// if so, underflow to zero

 	_asm test ecx, 0x10000		// test sign

 	_asm jnz short trealxtouint0	// if -, return 0

 	_asm shr eax, cl			// else result=eax>>cl

 	_asm ret

 	trealxtouint1:			// come here if exponent=FFFF

 	_asm cmp eax, 0x80000000		// check for infinity

 	_asm jnz short trealxtouint0	// if NaN, return 0

 	_asm test edx, edx

 	_asm jnz short trealxtouint0	// if NaN, return 0

 	trealxtouint2:			// come here if argument too big for 32-bit integer

 	_asm mov eax, 0xFFFFFFFF

 	_asm shr ecx, 17			// sign bit into carry flag

 	_asm adc eax, 0				// eax=FFFFFFFF if +, 0 if -

 	_asm ret					// return saturated value

 	trealxtouint0:			// come here if INT(argument)=0 or NaN

 	_asm xor eax, eax			// return 0

 	_asm ret

 	}

 __NAKED__ LOCAL_C void ConvertTRealXToTInt64(void)

 	{

 	// Convert TRealX in ecx,edx:ebx to TInt64 in edx:ebx

 	_asm ror ecx, 16				// exponent into cx

 	_asm cmp cx, 0xFFFF

 	_asm jz short trealxtoint64a	// branch if exp=FFFF

 	_asm mov ax, cx

 	_asm mov cx, 0x803E

 	_asm sub cx, ax					// cx=number of right shifts needed to convert mantissa to int

 	_asm jbe short trealxtoint64b	// if exp>=803E, saturate result

 	_asm cmp cx, 63					// more than 63 shifts needed?

 	_asm ja short trealxtoint64z	// if so, underflow to zero

 	_asm cmp cl, 31					// more than 31 shifts needed?

 	_asm jbe short trealxtoint64d	// branch if not

 	_asm sub cl, 32					// cl=shift count - 32

 	_asm mov ebx, edx				// shift right by 32

 	_asm xor edx, edx

 	trealxtoint64d:

 	_asm shrd ebx, edx, cl			// shift edx:ebx right by cl to give ABS(result)

 	_asm shr edx, cl

 	_asm test ecx, 0x10000			// test sign

 	_asm jz short trealxtoint64c	// skip if +

 	_asm neg edx					// if -, negate

 	_asm neg ebx

 	_asm sbb edx, 0

 	trealxtoint64c:

 	_asm ret

 	trealxtoint64a:			// come here if exponent=FFFF

 	_asm cmp edx, 0x80000000			// check for infinity

 	_asm jnz short trealxtoint64z	// if NaN, return 0

 	_asm test ebx, ebx

 	_asm jnz short trealxtoint64z	// if NaN, return 0

 	trealxtoint64b:			// come here if argument too big for 32-bit integer

 	_asm mov edx, 0x7FFFFFFF

 	_asm mov ebx, 0xFFFFFFFF

 	_asm shr ecx, 17				// sign bit into carry flag

 	_asm adc ebx, 0					// edx:ebx=7FFFFFFF FFFFFFFF if +,

 	_asm adc edx, 0					// or 80000000 00000000 if -

 	_asm ret						// return saturated value

 	trealxtoint64z:			// come here if INT(argument)=0 or NaN

 	_asm xor edx, edx				// return 0

 	_asm xor ebx, ebx

 	_asm ret

 	}

 /**

 Returns the extended precision value as a 64 bit integer value.

 The operator returns:

 1. zero, if the extended precision value is not a number

 2. 0x7FFFFFFF FFFFFFFF, if the value is positive and too big to fit

    into a TInt64

 3. 0x80000000 00000000, if the value is negative and too big to fit

    into a TInt64.

 */

 __NAKED__ EXPORT_C TRealX::operator TInt64() const

 	{

 	// on entry, ecx=this, return value in edx:eax

 	_asm push ebx

 	_asm mov ebx, [ecx]			// get TRealX value into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call ConvertTRealXToTInt64

 	_asm mov eax, ebx			// store low result into eax

 	_asm pop ebx

 	_asm ret

 	}

 __NAKED__ LOCAL_C void TRealXGetTReal32(void)

 	{

 	// Convert TRealX in ecx,edx:ebx to TReal32 in edx

 	// Return error code in eax

 	_asm cmp ecx, 0xFFFF0000		// check for infinity/NaN

 	_asm jnc short trealxgettreal32a

 	_asm xor eax, eax

 	_asm ror ecx, 16				// exponent into cx

 	_asm sub cx, 0x7F80				// cx=result exponent if normalised

 	_asm jbe short trealxgettreal32b	// jump if denormal, zero or underflow

 	_asm cmp cx, 0xFF				// check if overflow

 	_asm jb short trealxgettreal32c	// jump if not

 	trealxgettreal32d:			// come here if overflow

 	_asm xor edx, edx				// set mantissa=0 to generate infinity

 	_asm ror ecx, 16				// ecx back to normal format

 	trealxgettreal32a:			// come here if infinity or NaN

 	_asm shr edx, 7

 	_asm or edx, 0xFF000000			// set exponent to FF

 	_asm shr ecx, 1					// sign bit -> carry

 	_asm rcr edx, 1					// sign bit -> MSB of result

 	_asm mov eax, edx

 	_asm shl eax, 9					// test for infinity or NaN

 	_asm mov eax, -9				// eax=KErrOverflow

 	_asm jz short trealxgettreal32e

 	_asm mov eax, -6				// if NaN, eax=KErrArgument

 	trealxgettreal32e:

 	_asm ret

 	trealxgettreal32b:			// come here if exponent<=7F80

 	_asm cmp cx, -24				// check for zero or total underflow

 	_asm jle short trealxgettreal32z

 	_asm neg cl

 	_asm inc cl						// cl=number of right shifts to form denormal mantissa

 	_asm shrd eax, ebx, cl			// shift mantissa right into eax

 	_asm shrd ebx, edx, cl

 	_asm shr edx, cl

 	_asm or edx, 0x80000000			// set top bit to ensure correct rounding up

 	_asm xor cl, cl					// cl=result exponent=0

 	trealxgettreal32c:			// come here if result normalised

 	_asm cmp dl, 0x80				// check rounding bits

 	_asm ja short trealxgettreal32f	// branch to round up

 	_asm jb short trealxgettreal32g	// branch to round down

 	_asm test ebx, ebx

 	_asm jnz short trealxgettreal32f	// branch to round up

 	_asm test eax, eax

 	_asm jnz short trealxgettreal32f	// branch to round up

 	_asm test ecx, 0x01000000			// check rounded-down flag

 	_asm jnz short trealxgettreal32f	// branch to round up

 	_asm test ecx, 0x02000000			// check rounded-up flag

 	_asm jnz short trealxgettreal32g	// branch to round down

 	_asm test dh, 1						// else round to even

 	_asm jz short trealxgettreal32g		// branch to round down if LSB=0

 	trealxgettreal32f:				// come here to round up

 	_asm add edx, 0x100					// increment mantissa

 	_asm jnc short trealxgettreal32g

 	_asm rcr edx, 1

 	_asm inc cl							// if carry, increment exponent

 	_asm cmp cl, 0xFF					// and check for overflow

 	_asm jz short trealxgettreal32d		// branch out if overflow

 	trealxgettreal32g:				// come here to round down

 	_asm xor dl, dl

 	_asm add edx, edx					// shift out integer bit

 	_asm mov dl, cl

 	_asm ror edx, 8						// exponent->edx bits 24-31, mantissa in 23-1

 	_asm test edx, edx					// check if underflow

 	_asm jz short trealxgettreal32h		// branch out if underflow

 	_asm shr ecx, 17					// sign bit->carry

 	_asm rcr edx, 1						// ->edx bit 31, exp->edx bits 23-30, mant->edx bits 22-0

 	_asm xor eax, eax					// return KErrNone

 	_asm ret

 	trealxgettreal32z:				// come here if zero or underflow

 	_asm xor eax, eax

 	_asm cmp cx, 0x8080					// check for zero

 	_asm jz short trealxgettreal32y		// if zero, return KErrNone

 	trealxgettreal32h:				// come here if underflow after rounding

 	_asm mov eax, -10					// eax=KErrUnderflow

 	trealxgettreal32y:

 	_asm xor edx, edx

 	_asm shr ecx, 17

 	_asm rcr edx, 1						// sign bit into edx bit 31, rest of edx=0

 	_asm ret

 	}

 __NAKED__ LOCAL_C void TRealXGetTReal64(void)

 	{

 	// Convert TRealX in ecx,edx:ebx to TReal64 in edx:ebx

 	// Return error code in eax

 	// edi, esi also modified

 	_asm ror ecx, 16				// exponent into cx

 	_asm cmp cx, 0xFFFF				// check for infinity/NaN

 	_asm jnc short trealxgettreal64a

 	_asm xor eax, eax

 	_asm xor edi, edi

 	_asm sub cx, 0x7C00				// cx=result exponent if normalised

 	_asm jbe short trealxgettreal64b	// jump if denormal, zero or underflow

 	_asm cmp cx, 0x07FF				// check if overflow

 	_asm jb short trealxgettreal64c	// jump if not

 	trealxgettreal64d:			// come here if overflow

 	_asm xor edx, edx				// set mantissa=0 to generate infinity

 	_asm xor ebx, ebx

 	trealxgettreal64a:			// come here if infinity or NaN

 	_asm mov cl, 10

 	_asm shrd ebx, edx, cl

 	_asm shr edx, cl

 	_asm or edx, 0xFFE00000			// set exponent to 7FF

 	_asm shr ecx, 17				// sign bit -> carry

 	_asm rcr edx, 1					// sign bit -> MSB of result

 	_asm rcr ebx, 1

 	_asm mov eax, edx

 	_asm shl eax, 12				// test for infinity or NaN

 	_asm mov eax, -9				// eax=KErrOverflow

 	_asm jnz short trealxgettreal64n

 	_asm test ebx, ebx

 	_asm jz short trealxgettreal64e

 	trealxgettreal64n:

 	_asm mov eax, -6				// if NaN, eax=KErrArgument

 	trealxgettreal64e:

 	_asm ret

 	trealxgettreal64b:			// come here if exponent<=7C00

 	_asm cmp cx, -53				// check for zero or total underflow

 	_asm jle trealxgettreal64z

 	_asm neg cl

 	_asm inc cl						// cl=number of right shifts to form denormal mantissa

 	_asm cmp cl, 32

 	_asm jb trealxgettreal64x

 	_asm mov eax, ebx				// if >=32 shifts, do 32 shifts and decrement count by 32

 	_asm mov ebx, edx

 	_asm xor edx, edx

 	trealxgettreal64x:

 	_asm shrd edi, eax, cl

 	_asm shrd eax, ebx, cl			// shift mantissa right into eax

 	_asm shrd ebx, edx, cl

 	_asm shr edx, cl

 	_asm or edx, 0x80000000			// set top bit to ensure correct rounding up

 	_asm xor cx, cx					// cx=result exponent=0

 	trealxgettreal64c:			// come here if result normalised

 	_asm mov esi, ebx

 	_asm and esi, 0x7FF				// esi=rounding bits

 	_asm cmp esi, 0x400				// check rounding bits

 	_asm ja short trealxgettreal64f	// branch to round up

 	_asm jb short trealxgettreal64g	// branch to round down

 	_asm test eax, eax

 	_asm jnz short trealxgettreal64f	// branch to round up

 	_asm test edi, edi

 	_asm jnz short trealxgettreal64f	// branch to round up

 	_asm test ecx, 0x01000000			// check rounded-down flag

 	_asm jnz short trealxgettreal64f	// branch to round up

 	_asm test ecx, 0x02000000			// check rounded-up flag

 	_asm jnz short trealxgettreal64g	// branch to round down

 	_asm test ebx, 0x800					// else round to even

 	_asm jz short trealxgettreal64g		// branch to round down if LSB=0

 	trealxgettreal64f:				// come here to round up

 	_asm add ebx, 0x800					// increment mantissa

 	_asm adc edx, 0

 	_asm jnc short trealxgettreal64g

 	_asm rcr edx, 1

 	_asm inc cx							// if carry, increment exponent

 	_asm cmp cx, 0x7FF					// and check for overflow

 	_asm jz trealxgettreal64d			// branch out if overflow

 	trealxgettreal64g:				// come here to round down

 	_asm xor bl, bl						// clear rounding bits

 	_asm and bh, 0xF8

 	_asm mov di, cx						// save exponent

 	_asm mov cl, 10

 	_asm and edx, 0x7FFFFFFF				// clear integer bit

 	_asm shrd ebx, edx, cl				// shift mantissa right by 10

 	_asm shr edx, cl

 	_asm shl edi, 21					// exponent into edi bits 21-31

 	_asm or edx, edi					// into edx bits 21-31

 	_asm test edx, edx					// check if underflow

 	_asm jnz short trealxgettreal64i

 	_asm test ebx, ebx

 	_asm jz short trealxgettreal64h		// branch out if underflow

 	trealxgettreal64i:

 	_asm shr ecx, 17					// sign bit->carry

 	_asm rcr edx, 1						// ->edx bit 31, exp->edx bits 20-30, mant->edx bits 20-0

 	_asm rcr ebx, 1

 	_asm xor eax, eax					// return KErrNone

 	_asm ret

 	trealxgettreal64z:				// come here if zero or underflow

 	_asm xor eax, eax

 	_asm cmp cx, 0x8400					// check for zero

 	_asm jz short trealxgettreal64y		// if zero, return KErrNone

 	trealxgettreal64h:				// come here if underflow after rounding

 	_asm mov eax, -10					// eax=KErrUnderflow

 	trealxgettreal64y:

 	_asm xor edx, edx

 	_asm xor ebx, ebx

 	_asm shr ecx, 17

 	_asm rcr edx, 1						// sign bit into edx bit 31, rest of edx=0, ebx=0

 	_asm ret

 	}

 __NAKED__ EXPORT_C TRealX::operator TReal32() const

 /**

 Returns the extended precision value as

 a single precision floating point value.

 */

 	{

 	// On entry, ecx=this

 	// On exit, TReal32 value on top of FPU stack

 	_asm push ebx

 	_asm mov ebx, [ecx]			// *this into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXGetTReal32	// Convert to TReal32 in edx

 	_asm push edx				// push TReal32 onto stack

 	_asm fld dword ptr [esp]	// push TReal32 onto FPU stack

 	_asm pop edx

 	_asm pop ebx

 	_asm ret

 	}

 __NAKED__ EXPORT_C TRealX::operator TReal64() const

 /**

 Returns the extended precision value as

 a double precision floating point value.

 */

 	{

 	// On entry, ecx=this

 	// On exit, TReal64 value on top of FPU stack

 	_asm push ebx

 	_asm push esi

 	_asm push edi

 	_asm mov ebx, [ecx]			// *this into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXGetTReal64	// Convert to TReal32 in edx:ebx

 	_asm push edx				// push TReal64 onto stack

 	_asm push ebx

 	_asm fld qword ptr [esp]	// push TReal64 onto FPU stack

 	_asm add esp, 8

 	_asm pop edi

 	_asm pop esi

 	_asm pop ebx

 	_asm ret

 	}

 __NAKED__ EXPORT_C TInt TRealX::GetTReal(TReal32& /*aVal*/) const

 /**

 Extracts the extended precision value as

 a single precision floating point value.

 @param aVal A reference to a single precision object which contains

             the result of the operation.

 @return KErrNone, if the operation is successful;

         KErrOverflow, if the operation results in overflow;

         KErrUnderflow, if the operation results in underflow.

 */

 	{

 	// On entry, ecx=this, [esp+4]=address of aVal

 	// On exit, eax=return code

 	_asm push ebx

 	_asm mov ebx, [ecx]			// *this into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXGetTReal32

 	_asm mov ecx, [esp+8]		// ecx=address of aVal

 	_asm mov [ecx], edx			// store result

 	_asm pop ebx

 	_asm ret 4					// return with error code in eax

 	}

 __NAKED__ EXPORT_C TInt TRealX::GetTReal(TReal64& /*aVal*/) const

 /**

 Extracts the extended precision value as

 a double precision floating point value.

 @param aVal A reference to a double precision object which

             contains the result of the operation.

 @return KErrNone, if the operation is successful;

         KErrOverflow, if the operation results in overflow;

         KErrUnderflow, if the operation results in underflow.

 */

 	{

 	// On entry, ecx=this, [esp+4]=address of aVal

 	// On exit, eax=return code

 	_asm push ebx

 	_asm push esi

 	_asm push edi

 	_asm mov ebx, [ecx]			// *this into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXGetTReal64

 	_asm mov ecx, [esp+16]		// ecx=address of aVal

 	_asm mov [ecx], ebx			// store result

 	_asm mov [ecx+4], edx

 	_asm pop edi

 	_asm pop esi

 	_asm pop ebx

 	_asm ret 4					// return with error code in eax

 	}

 __NAKED__ EXPORT_C void TRealX::SetZero(TBool /*aNegative*/)

 /**

 Sets the value of this extended precision object to zero.

 @param aNegative ETrue, the value is a negative zero;

                  EFalse, the value is a positive zero, this is the default.

 */

 	{

 	_asm mov edx, [esp+4]		// aNegative into edx

 	_asm xor eax, eax			// eax=0

 	_asm mov [ecx], eax

 	_asm mov [ecx+4], eax

 	_asm test edx, edx

 	_asm jz short setzero1

 	_asm inc eax				// eax=1 if aNegative!=0

 	setzero1:

 	_asm mov [ecx+8], eax		// generate positive or negative zero

 	_asm ret 4

 	}

 __NAKED__ EXPORT_C void TRealX::SetNaN()

 /**

 Sets the value of this extended precision object to 'not a number'.

 */

 	{

 	_asm xor eax, eax			// set *this to 'real indefinite'

 	_asm mov [ecx], eax

 	_asm mov eax, 0xC0000000

 	_asm mov [ecx+4], eax

 	_asm mov eax, 0xFFFF0001

 	_asm mov [ecx+8], eax

 	_asm ret

 	}

 __NAKED__ EXPORT_C void TRealX::SetInfinite(TBool /*aNegative*/)

 /**

 Sets the value of this extended precision object to infinity.

 @param aNegative ETrue, the value is a negative zero;

                  EFalse, the value is a positive zero.

 */

 	{

 	_asm mov edx, [esp+4]		// aNegative into edx

 	_asm mov eax, 0xFFFF0000	// exponent=FFFF, sign=0 initially

 	_asm test edx, edx

 	_asm jz short setinf1

 	_asm inc eax				// sign=1 if aNegative!=0

 	setinf1:

 	_asm mov [ecx+8], eax		// generate positive or negative infinity

 	_asm mov eax, 0x80000000

 	_asm mov [ecx+4], eax

 	_asm xor eax, eax

 	_asm mov [ecx], eax

 	_asm ret 4

 	}

 __NAKED__ EXPORT_C TBool TRealX::IsZero() const

 /**

 Determines whether the extended precision value is zero.

 @return True, if the extended precision value is zero, false, otherwise.

 */

 	{

 	_asm mov eax, [ecx+8]		// check exponent

 	_asm shr eax, 16			// move exponent into ax

 	_asm jz short iszero1		// branch if zero

 	_asm xor eax, eax			// else return 0

 	_asm ret

 	iszero1:

 	_asm inc eax				// if zero, return 1

 	_asm ret

 	}

 __NAKED__ EXPORT_C TBool TRealX::IsNaN() const

 /**

 Determines whether the extended precision value is 'not a number'.

 @return True, if the extended precision value is 'not a number',

         false, otherwise.

 */

 	{

 	_asm mov eax, [ecx+8]		// check exponent

 	_asm cmp eax, 0xFFFF0000

 	_asm jc short isnan0		// branch if not FFFF

 	_asm mov eax, [ecx+4]

 	_asm cmp eax, 0x80000000		// check for infinity

 	_asm jne short isnan1

 	_asm mov eax, [ecx]

 	_asm test eax, eax

 	_asm jne short isnan1

 	isnan0:

 	_asm xor eax, eax			// return 0 if not NaN

 	_asm ret

 	isnan1:

 	_asm mov eax, 1				// return 1 if NaN

 	_asm ret

 	}

 __NAKED__ EXPORT_C TBool TRealX::IsInfinite() const

 /**

 Determines whether the extended precision value has a finite value.

 @return True, if the extended precision value is finite,

         false, if the value is 'not a number' or is infinite,

 */

 	{

 	_asm mov eax, [ecx+8]		// check exponent

 	_asm cmp eax, 0xFFFF0000

 	_asm jc short isinf0		// branch if not FFFF

 	_asm mov eax, [ecx+4]

 	_asm cmp eax, 0x80000000		// check for infinity

 	_asm jne short isinf0

 	_asm mov eax, [ecx]

 	_asm test eax, eax

 	_asm jne short isinf0

 	_asm inc eax				// return 1 if infinity

 	_asm ret

 	isinf0:

 	_asm xor eax, eax			// return 0 if not infinity

 	_asm ret

 	}

 __NAKED__ EXPORT_C TBool TRealX::IsFinite() const

 /**

 Determines whether the extended precision value has a finite value.

 @return True, if the extended precision value is finite,

         false, if the value is 'not a number' or is infinite,

 */

 	{

 	_asm mov eax, [ecx+8]		// check exponent

 	_asm cmp eax, 0xFFFF0000	// check for NaN or infinity

 	_asm jnc short isfinite0	// branch if NaN or infinity

 	_asm mov eax, 1				// return 1 if finite

 	_asm ret

 	isfinite0:

 	_asm xor eax, eax			// return 0 if NaN or infinity

 	_asm ret

 	}

 __NAKED__ EXPORT_C const TRealX& TRealX::operator+=(const TRealX& /*aVal*/)

 /**

 Adds an extended precision value to this extended precision number.

 @param aVal The extended precision value to be added.

 @return A reference to this object.

 @panic MATHX KErrOverflow if the operation results in overflow.

 @panic MATHX KErrUnderflow if  the operation results in underflow.

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aVal

 	_asm push ebx				// save registers

 	_asm push ebp

 	_asm push esi

 	_asm push edi

 	_asm mov esi, ecx			// this into esi

 	_asm mov ecx, [esp+20]		// address of aVal into ecx

 	_asm mov ebx, [ecx]			// aVal into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXAdd			// do addition, result in ecx,edx:ebx, error code in eax

 	_asm mov [esi], ebx			// store result in *this

 	_asm mov [esi+4], edx

 	_asm mov [esi+8], ecx

 	_asm test eax, eax

 	_ASM_jn(z,TRealXPanicEax)	// panic if error

 	_asm mov eax, esi			// return this in eax

 	_asm pop edi				// restore registers

 	_asm pop esi

 	_asm pop ebp

 	_asm pop ebx

 	_asm ret 4

 	}

 __NAKED__ EXPORT_C const TRealX& TRealX::operator-=(const TRealX& /*aVal*/)

 /**

 Subtracts an extended precision value from this extended precision number. 

 @param aVal The extended precision value to be subtracted.

 @return A reference to this object.

 @panic MATHX KErrOverflow if the operation results in overflow.

 @panic MATHX KErrUnderflow if  the operation results in underflow.

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aVal

 	_asm push ebx				// save registers

 	_asm push ebp

 	_asm push esi

 	_asm push edi

 	_asm mov esi, ecx			// this into esi

 	_asm mov ecx, [esp+20]		// address of aVal into ecx

 	_asm mov ebx, [ecx]			// aVal into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXSubtract	// do subtraction, result in ecx,edx:ebx, error code in eax

 	_asm mov [esi], ebx			// store result in *this

 	_asm mov [esi+4], edx

 	_asm mov [esi+8], ecx

 	_asm test eax, eax

 	_ASM_jn(z,TRealXPanicEax)	// panic if error

 	_asm mov eax, esi			// return this in eax

 	_asm pop edi				// restore registers

 	_asm pop esi

 	_asm pop ebp

 	_asm pop ebx

 	_asm ret 4

 	}

 __NAKED__ EXPORT_C const TRealX& TRealX::operator*=(const TRealX& /*aVal*/)

 /**

 Multiplies this extended precision number by an extended precision value.

 @param aVal The extended precision value to be subtracted.

 @return A reference to this object.

 @panic MATHX KErrOverflow if the operation results in overflow.

 @panic MATHX KErrUnderflow if  the operation results in underflow.

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aVal

 	_asm push ebx				// save registers

 	_asm push ebp

 	_asm push esi

 	_asm push edi

 	_asm mov esi, ecx			// this into esi

 	_asm mov ecx, [esp+20]		// address of aVal into ecx

 	_asm mov ebx, [ecx]			// aVal into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXMultiply	// do multiplication, result in ecx,edx:ebx, error code in eax

 	_asm mov [esi], ebx			// store result in *this

 	_asm mov [esi+4], edx

 	_asm mov [esi+8], ecx

 	_asm test eax, eax

 	_ASM_jn(z,TRealXPanicEax)	// panic if error

 	_asm mov eax, esi			// return this in eax

 	_asm pop edi				// restore registers

 	_asm pop esi

 	_asm pop ebp

 	_asm pop ebx

 	_asm ret 4

 	}

 __NAKED__ EXPORT_C const TRealX& TRealX::operator/=(const TRealX& /*aVal*/)

 /**

 Divides this extended precision number by an extended precision value.

 @param aVal The extended precision value to be used as the divisor. 

 @return A reference to this object.

 @panic MATHX KErrOverflow if the operation results in overflow.

 @panic MATHX KErrUnderflow if  the operation results in underflow.

 @panic MATHX KErrDivideByZero if the divisor is zero.

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aVal

 	_asm push ebx				// save registers

 	_asm push ebp

 	_asm push esi

 	_asm push edi

 	_asm mov esi, ecx			// this into esi

 	_asm mov ecx, [esp+20]		// address of aVal into ecx

 	_asm mov ebx, [ecx]			// aVal into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXDivide		// do division, result in ecx,edx:ebx, error code in eax

 	_asm mov [esi], ebx			// store result in *this

 	_asm mov [esi+4], edx

 	_asm mov [esi+8], ecx

 	_asm test eax, eax

 	_ASM_jn(z,TRealXPanicEax)	// panic if error

 	_asm mov eax, esi			// return this in eax

 	_asm pop edi				// restore registers

 	_asm pop esi

 	_asm pop ebp

 	_asm pop ebx

 	_asm ret 4

 	}

 __NAKED__ EXPORT_C const TRealX& TRealX::operator%=(const TRealX& /*aVal*/)

 /**

 Modulo-divides this extended precision number by an extended precision value.

 @param aVal The extended precision value to be used as the divisor. 

 @return A reference to this object.

 @panic MATHX KErrTotalLossOfPrecision panic if precision is lost.

 @panic MATHX KErrUnderflow if  the operation results in underflow.

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aVal

 	_asm push ebx				// save registers

 	_asm push ebp

 	_asm push esi

 	_asm push edi

 	_asm mov esi, ecx			// this into esi

 	_asm mov ecx, [esp+20]		// address of aVal into ecx

 	_asm mov ebx, [ecx]			// aVal into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXModulo		// do modulo, result in ecx,edx:ebx, error code in eax

 	_asm mov [esi], ebx			// store result in *this

 	_asm mov [esi+4], edx

 	_asm mov [esi+8], ecx

 	_asm test eax, eax

 	_ASM_jn(z,TRealXPanicEax)	// panic if error

 	_asm mov eax, esi			// return this in eax

 	_asm pop edi				// restore registers

 	_asm pop esi

 	_asm pop ebp

 	_asm pop ebx

 	_asm ret 4

 	}

 __NAKED__ EXPORT_C TInt TRealX::AddEq(const TRealX& /*aVal*/)

 /**

 Adds an extended precision value to this extended precision number.

 @param aVal The extended precision value to be added.

 @return KErrNone, if the operation is successful;

         KErrOverflow,if the operation results in overflow;

         KErrUnderflow, if the operation results in underflow. 

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aVal

 	_asm push ebx				// save registers

 	_asm push ebp

 	_asm push esi

 	_asm push edi

 	_asm mov esi, ecx			// this into esi

 	_asm mov ecx, [esp+20]		// address of aVal into ecx

 	_asm mov ebx, [ecx]			// aVal into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXAdd			// do addition, result in ecx,edx:ebx, error code in eax

 	_asm mov [esi], ebx			// store result

 	_asm mov [esi+4], edx

 	_asm mov [esi+8], ecx

 	_asm pop edi				// restore registers

 	_asm pop esi

 	_asm pop ebp

 	_asm pop ebx

 	_asm ret 4					// return with error code in eax

 	}

 __NAKED__ EXPORT_C TInt TRealX::SubEq(const TRealX& /*aVal*/)

 /**

 Subtracts an extended precision value from this extended precision number.

 @param aVal The extended precision value to be subtracted.

 @return KErrNone, if the operation is successful;

         KErrOverflow, if the operation results in overflow;

         KErrUnderflow, if the operation results in underflow.

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aVal

 	_asm push ebx				// save registers

 	_asm push ebp

 	_asm push esi

 	_asm push edi

 	_asm mov esi, ecx			// this into esi

 	_asm mov ecx, [esp+20]		// address of aVal into ecx

 	_asm mov ebx, [ecx]			// aVal into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXSubtract	// do subtraction, result in ecx,edx:ebx, error code in eax

 	_asm mov [esi], ebx			// store result

 	_asm mov [esi+4], edx

 	_asm mov [esi+8], ecx

 	_asm pop edi				// restore registers

 	_asm pop esi

 	_asm pop ebp

 	_asm pop ebx

 	_asm ret 4					// return with error code in eax

 	}

 __NAKED__ EXPORT_C TInt TRealX::MultEq(const TRealX& /*aVal*/)

 /**

 Multiplies this extended precision number by an extended precision value.

 @param aVal The extended precision value to be used as the multiplier.

 @return KErrNone, if the operation is successful;

         KErrOverflow, if the operation results in overflow;

         KErrUnderflow, if the operation results in underflow

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aVal

 	_asm push ebx				// save registers

 	_asm push ebp

 	_asm push esi

 	_asm push edi

 	_asm mov esi, ecx			// this into esi

 	_asm mov ecx, [esp+20]		// address of aVal into ecx

 	_asm mov ebx, [ecx]			// aVal into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXMultiply	// do multiplication, result in ecx,edx:ebx, error code in eax

 	_asm mov [esi], ebx			// store result

 	_asm mov [esi+4], edx

 	_asm mov [esi+8], ecx

 	_asm pop edi				// restore registers

 	_asm pop esi

 	_asm pop ebp

 	_asm pop ebx

 	_asm ret 4					// return with error code in eax

 	}

 __NAKED__ EXPORT_C TInt TRealX::DivEq(const TRealX& /*aVal*/)

 /**

 Divides this extended precision number by an extended precision value.

 @param aVal The extended precision value to be used as the divisor.

 @return KErrNone, if the operation is successful;

         KErrOverflow, if the operation results in overflow;

         KErrUnderflow, if the operation results in underflow;

         KErrDivideByZero, if the divisor is zero. 

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aVal

 	_asm push ebx				// save registers

 	_asm push ebp

 	_asm push esi

 	_asm push edi

 	_asm mov esi, ecx			// this into esi

 	_asm mov ecx, [esp+20]		// address of aVal into ecx

 	_asm mov ebx, [ecx]			// aVal into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXDivide		// do division, result in ecx,edx:ebx, error code in eax

 	_asm mov [esi], ebx			// store result

 	_asm mov [esi+4], edx

 	_asm mov [esi+8], ecx

 	_asm pop edi				// restore registers

 	_asm pop esi

 	_asm pop ebp

 	_asm pop ebx

 	_asm ret 4					// return with error code in eax

 	}

 __NAKED__ EXPORT_C TInt TRealX::ModEq(const TRealX& /*aVal*/)

 /**

 Modulo-divides this extended precision number by an extended precision value.

 @param aVal The extended precision value to be used as the divisor. 

 @return KErrNone, if the operation is successful;

         KErrTotalLossOfPrecision, if precision is lost;

         KErrUnderflow, if the operation results in underflow.

 */

 	{

 	// on entry ecx=this, [esp+4]=address of aVal

 	_asm push ebx				// save registers

 	_asm push ebp

 	_asm push esi

 	_asm push edi

 	_asm mov esi, ecx			// this into esi

 	_asm mov ecx, [esp+20]		// address of aVal into ecx

 	_asm mov ebx, [ecx]			// aVal into ecx,edx:ebx

 	_asm mov edx, [ecx+4]

 	_asm mov ecx, [ecx+8]

 	_asm call TRealXModulo		// do modulo, result in ecx,edx:ebx, error code in eax

 	_asm mov [esi], ebx			// store result

 	_asm mov [esi+4], edx

 	_asm mov [esi+8], ecx

 	_asm pop edi				// restore registers

 	_asm pop esi

 	_asm pop ebp

 	_asm pop ebx

 	_asm ret 4					// return with error code in eax

 	}

 __NAKED__ EXPORT_C TRealX TRealX::operator+() const

 /**

 Returns this extended precision number unchanged.

 Note that this may also be referred to as a unary plus operator. 

 @return The extended precision number.

 */

 	{

 	_asm mov eax, [esp+4]		// eax=address to write return value

 	_asm mov edx, [ecx]

 	_asm mov [eax], edx

 	_asm mov edx, [ecx+4]

 	_asm mov [eax+4], edx

 	_asm mov edx, [ecx+8]

 	_asm mov [eax+8], edx

 	_asm ret 4					// return address of return value in eax

 	}

 __NAKED__ EXPORT_C TRealX TRealX::operator-() const

 /**

 Negates this extended precision number.

 This may also be referred to as a unary minus operator.

 @return The negative of the extended precision number.

 */

 	{

 	_asm mov eax, [esp+4]		// eax=address to write return value

 	_asm mov edx, [ecx]

 	_asm mov [eax], edx

 	_asm mov edx, [ecx+4]

 	_asm mov [eax+4], edx

 	_asm mov edx, [ecx+8]

 	_asm xor dl, 1				// change sign bit

 	_asm mov [eax+8], edx

 	_asm ret 4					// return address of return value in eax

 	}

 __NAKED__ EXPORT_C TRealX& TRealX::operator++()

 /**

 Increments this extended precision number by one,

 and then returns a reference to it.

 This is also referred to as a prefix operator. 

 @return A reference to this object.

 @panic MATHX KErrOverflow if the operation results in overflow.

 @panic MATHX KErrUnderflow if  the operation results in underflow.

 */

 	{

 	// pre-increment

 	// on entry ecx=this, return this in eax

 	_asm push ebx				// save registers

 	_asm push ebp

 	_asm push esi

 	_asm push edi

 	_asm mov esi, ecx			// this into esi

 	_asm mov ecx, 0x7FFF0000	// set ecx,edx:ebx to 1.0

 	_asm mov edx, 0x80000000

 	_asm xor ebx, ebx

 	_asm call TRealXAdd			// add 1 to *this

 	_asm mov [esi], ebx			// store result

 	_asm mov [esi+4], edx

 	_asm mov [esi+8], ecx

 	_asm test eax, eax			// check error code

 	_ASM_jn(z,TRealXPanicEax)	// panic if error

 	_asm mov eax, esi			// else return this in eax

 	_asm pop edi

 	_asm pop esi

 	_asm pop ebp

 	_asm pop ebx

 	_asm ret

 	}

 __NAKED__ EXPORT_C TRealX TRealX::operator++(TInt)

 /**