2F9B			  ; ********************************************************************
2F9B			  ; THE  ' PREPAE TO ADD '  SUBROUTINE
2F9B			  ; THIS SUBROUTINE IS THE FIRST OF FOUR SUBROUTINES THAT ARE USED BY
2F9B			  ; THE MAIN ARITHMETIC OPERATION  ROUTINES -  SUBSTRACTION ,ADDITION
2F9B			  ; MULTIPLICATION AND DIVISION.
2F9B			  ; THIS PARTICULAR SUBROUTINE PREPARES A FLOATING-POINT NUMBER FOR
2F9B			  ; ADDITION, MAINLY BY REPLACING THE SIGN BIT WITH A TRUE NUMERICAL
2F9B			  ; BIT  1 , AND  NEGATING THE NUMBER (TWO'S  COMPLEMENT) IF IS IS
2F9B			  ; NEGATIVE. THE  EXPONENT  IS RETURNED IN THE  A  REGISTER AND
2F9B			  ; THE FIRST BYTE  IS	SET TO	HEX.00	FOR  A NEGATIVE NUMBER.
2F9B			  ;
2F9B 7E 		  PREP_ADD:	LD    A,(HL)		      ; TRANSFER THE EXPONENT TO 'A'.
2F9C 3600				LD    (HL),0		      ; PRESUME A POSITIVE NUMBER.
2F9E A7 				AND   A 		      ; IF THE NUMBER IS ZERO THEN THE
2F9F C8 				RET   Z 		      ; PREPARATION IS ALREADY FINISHED.
2FA0 23 				INC   HL		      ; NOW POINT TO THE SIGN BYTE.
2FA1 CB7E				BIT  7,(HL)		      ; SET THE ZERO FLAG FOR POSITIVE
2FA3					;			      ; NUMBER.
2FA3 CBFE				SET  7,(HL)		      ; RESTORE THE TRUE NUMERIC BIT.
2FA5 2B 				DEC   HL		      ; POINT TO THE FIRST BYTE AGAIN.
2FA6 C8 				RET   Z 		      ; POSITIVE NUMBERS HAVE BEEN
2FA7					;			      ; PREPARED,BUT NEGATIVE NUMBERS
2FA7					;			      ; NEED TO BE TWOS COMPLEMENTED.
2FA7 C5 				PUSH  BC		      ; SAVE ANY EARLIER EXPONENT.
2FA8 010500				LD    BC,00005H 	      ; THERE ARE 5 BYTES TO BE HANDLED.
2FAB 09 				ADD   HL,BC		      ; POINT ONE-PAST THE LAST BYTE.
2FAC 41 				LD    B,C		      ; TRANSFER THE '5' TO 'B'.
2FAD 4F 				LD    C,A		      ; SAVE THE EXPONENT IN 'C'.
2FAE 37 				SCF			      ; SET CARRY FLAG FOR NEGATION.
2FAF 2B 		  NEG_BYTE:	DEC   HL		      ; POINT TO EACH BYTE IN TURN.
2FB0 7E 				LD    A,(HL)		      ; GET EACH BYTE.
2FB1 2F 				CPL			      ; ONE'S COMPLEMENT THE BYTE.
2FB2 CE00				ADC   A,0		      ; ADD IN CARRY FOR NEGATION.
2FB4 77 				LD    (HL),A		      ; RESTORE THE BYTE.
2FB5 10F8				DJNZ  NEG_BYTE		      ; LOOP THE '5' TIMES.
2FB7 79 				LD    A,C		      ; RESTORE THE EXPONENT TO 'A'.
2FB8 C1 				POP   BC		      ; RESTORE ANY EARLIER EXPONENT.
2FB9 C9 				RET			      ; FINISHED.
2FBA			  ;
2FBA			  ; ********************************************************************
2FBA			  ; THE  ' FETCH  TWO  NUMBERS '  SUBROUTINE
2FBA			  ; THIS SUBROUTINE IS CALLED BY ADDITION , MULTIPLICATION AND DIVISION
2FBA			  ; TO GET TWO	NUMBERS FROM THE CALCULATOR STACK AND PUT THEM INTO THE
2FBA			  ; REGISTER, INCLUDING THE EXCHANGE REGISTERS.
2FBA			  ; ON	ENTRY  TO  THE SUBROUTINE  THE	 HL   REGISTER	PAIR  POINTS TO
2FBA			  ; THE FIRST  BYTE  OF  THE FIRST  NUMBER  AND  THE  DE  REGISTER PAIR
2FBA			  ; POINTS  TO THE FIRST BYTE  OF THE SECOND NUMBER.
2FBA			  ; WHEN  THE  SUBROUTINE   IS	CALLED	FROM  MULTIPLICATION OR DIVISION
2FBA			  ; THE SIGN OF THE REZULT IS SAVED  IN  THE SECOND  BYTE  OF  THE FIRST
2FBA			  ; NUMBER.
2FBA			  ;
2FBA E5 		  FETCH_TWO:	PUSH  HL		      ; 'HL' IS PRESERVED.
2FBB F5 				PUSH  AF		      ; 'AF' IS PRESERVED.
2FBC			  ;
2FBC			  ; CALL THE FIVE BYTES OF THE FIRST NUMBER   -   M1,M2,M3,M4 & M5
2FBC			  ; AND THE SECOND NUMBER		      -   N1,N2,N3,N4 & N5
2FBC			  ;
2FBC 4E 				LD    C,(HL)		      ; M1 TO 'C'.
2FBD 23 				INC   HL		      ; NEXT.
2FBE 46 				LD    B,(HL)		      ; M2 TO 'B'.
2FBF 77 				LD    (HL),A		      ; COPY THE SING OF THE RESULT
2FC0					;			      ; TO 'HL'.
2FC0 23 				INC   HL		      ; NEXT.
2FC1 79 				LD    A,C		      ; M1 TO 'A'.
2FC2 4E 				LD    C,(HL)		      ; M3 TO 'C'.
2FC3 C5 				PUSH  BC		      ; SAVE M2&M3 ON THE MACHINE STACK.
2FC4 23 				INC   HL		      ; NEXT.
2FC5 4E 				LD    C,(HL)		      ; M4 TO 'C'.
2FC6 23 				INC   HL		      ; NEXT.
2FC7 46 				LD    B,(HL)		      ; M5 TO 'B'.
2FC8 EB 				EX    DE,HL		      ; 'HL' NOW POINTS TO N1.
2FC9 57 				LD    D,A		      ; M1 TO 'D'.
2FCA 5E 				LD    E,(HL)		      ; N1 TO 'E'.
2FCB D5 				PUSH  DE		      ; SAVE M1 & N1 ON THE
2FCC					;			      ; MACHINE STACK.
2FCC 23 				INC   HL		      ; NEXT.
2FCD 56 				LD    D,(HL)		      ; N2 TO 'D'.
2FCE 23 				INC   HL		      ; NEXT.
2FCF 5E 				LD    E,(HL)		      ; N3 TO 'E'.
2FD0 D5 				PUSH  DE		      ; SAVE N2 & N3 ON THE
2FD1					;			      ; MACHINE STACK.
2FD1 D9 				EXX			      ; GET THE EXCHANGE REGISTERS.
2FD2 D1 				POP   DE		      ; N2 TO D'& N3 TO E'.
2FD3 E1 				POP   HL		      ; M1 TO H'& N1 TO L'.
2FD4 C1 				POP   BC		      ; M2 TO B' 6 M3 TO C'.
2FD5 D9 				EXX			      ; GET THE ORIGINALL SET OF REGISTERS.
2FD6 23 				INC   HL		      ; NEXT.
2FD7 56 				LD    D,(HL)		      ; N4 TO 'D'.
2FD8 23 				INC   HL		      ; NEXT.
2FD9 5E 				LD    E,(HL)		      ; N5 TO 'E'.
2FDA F1 				POP   AF		      ; RESTORE THE ORIGINAL 'AF'.
2FDB E1 				POP   HL		      ; RESTORE THE ORIGINAL 'HL'.
2FDC C9 				RET			      ; FINISHED.
2FDD			  ;
2FDD			  ; SUMMARY :  M1-M5 ARE IN H',B',C',C,B.
2FDD			  ;	       N1-N5 ARE IN L',D',E',D,E.
2FDD			  ;	       HL  POINTS TO THE FIRST BYTE OF THE FIRST NUMBER.
2FDD			  ;
2FDD			  ;
2FDD			  ; ********************************************************************
2FDD			  ; THE  'SHIFT  ADDEND'  SUBROUTINE
2FDD			  ; THIS  SUBROUTINE  SHIFTS  A  FLOATING-POINT NUMBER UP TO 32 DECIMAL,
2FDD			  ; HEX.20, PLACES RIGHT TO LINE IT UP PROPERLY FOR ADDITION. THE NUMBER
2FDD			  ; WITH  THE  SMALLER	EXPONENT  HAS BEEN  PUT  IN  THE ADDEND POSITION
2FDD			  ; BEFORE  THIS  SUBROUTINE  IS CALLED. ANY OVERFLOW TO THE RIGHT, INTO
2FDD			  ; THE CARRY, IS ADDED BACK INTO THE NUMBER. IF THE EXPONENT DIFFERENCE
2FDD			  ; IS GREATE THAN 32 DECIMAL, OR THE CARRY RIPPLES RIGHT BACK TO
2FDD			  ; THE BEGINING  OF THE NUMBER, THEN THE NUMBER IS SET TO  ZERO SO THAT
2FDD			  ; THE  ADDITION  WILL  NOT  ALTER  THE OTHER	NUMBER (THE AUGENT).
2FDD			  ;
2FDD A7 		  SHIFT_FP:	AND   A 		      ; IF THE EXPONENT DIFFERENCE IS
2FDE C8 				RET   Z 		      ; ZERO, THE SUBROUTINE RETURNS AT
2FDF FE21				CP    021H		      ; ONCE. IF THE DIFFERENCE IS GREATER
2FE1 3016				JR    NC,ADDEND_0	      ; THAN HEX.20, JUMP FORWARD.
2FE3 C5 				PUSH  BC		      ; SAVE 'BC' BRIEFLY.
2FE4 47 				LD    B,A		      ; TRANSFER THE EXPONENT DIFFERENCE
2FE5					;			      ; TO 'B' TO CUONT THE SHIFTS RIGHT.
2FE5 D9 		  ONE_SHIFT:	EXX			      ; ARITHMETIC SHIFT RIGHT FOR  L',
2FE6 CB2D				SRA   L 		      ; PRESERVING THE SING MARKER BITS.
2FE8 CB1A				RR    D 		      ; ROTATE RIGHT WITH CARRY D',E',D,E.
2FEA CB1B				RR    E 		      ;
2FEC D9 				EXX			      ; THREBY SHIFTING THE WHOLE FIVE
2FED CB1A				RR    D 		      ; BYTES OF THE NUMBER TO THE RIGHT
2FEF CB1B				RR    E 		      ; AS MANY TIMES AS B COUNTS
2FF1 10F2				DJNZ  ONE_SHIFT 	      ; LOOP BACK UNTIL B REACHES ZERO
2FF3 C1 				POP   BC		      ; RESTORE THE ORIGINAL BC
2FF4 D0 				RET   NC		      ; DONE IF NO CARRY TO RETRIVE
2FF5 CD0430				CALL  ADD_BACK		      ; RETRIVE CARRY
2FF8 C0 				RET   NZ		      ; RETURN UNLESS THE CARRY RIPPLED RIGHT BACK
2FF9					;			      ; (IN THIS CASE THERE IS NOTHING TO ADD)
2FF9 D9 		  ADDEND_0:	EXX			      ; FETCH L',D' & E'
2FFA AF 				XOR   A 		      ; CLEAR THE A REGISTER
2FFB 2E00		  ZEROS_4_5:	LD    L,0		      ; SET THE ADDEND TO ZERO IN D'E',
2FFD 57 				LD    D,A		      ; D & E, TOGETHERWITH ITS MARKER
2FFE 5D 				LD    E,L		      ; BYTE (SIGN INDICATOR) L', WHICH
2FFF D9 				EXX			      ; WAS HEX. 00 FOR A POSITIVE NUMBER AND
3000 110000				LD    DE,0		      ; HEX. FF FOR A NEGATIVE NUMBER. ZEROS_4_5
3003					;			      ; PRODUCES ONLY 4 ZERO BYTES WHEN CALLED FOR
3003					;			      ; NEAR UNDERFLOW AT 3160
3003 C9 				RET			      ; FINISHED
3004			  ; THE "ADD_BACK" SUBROUTINE
3004			  ; THIS SUBROUTINE ADDS BACK INTO THE NUMBER ANY CARRY WHICH HAS OVERFLOWED TO
3004			  ; THE RIGHT. IN THE EXTREME CASE, THE CARRY RIPPLES RIGHT BACK TO THE LEFT OF
3004			  ; THE NUMBER.
3004			  ;   WHEN THIS SUBROUTINE IS CALLED DURING ADDITION, THIS RIPPLE MEANS THAT A
3004			  ; MANTISSA OF 0.5 WAS SHIFTED A FULL 32 PLACES RIGHT, AND THE ADDEND WILL NOW
3004			  ; BE SET TO ZERO; WHEN CALLED FROM MULTIPLICATION, IT MEANS THAT THE EXPONENT
3004			  ; MUST BE INCREMENTED, AND THIS MAY RESULT IN OVERFLOW.
3004 1C 		  ADD_BACK:	INC   E 		      ; ADD CARRY TO RIGHTMOST BYTE
3005 C0 				RET   NZ		      ; RETURN IF NO OVERFLOW TO LEFT
3006 14 				INC   D 		      ; CONTINUE TO THE NEXT BYTE
3007 C0 				RET   NZ		      ; RETURN IF NO OVERFLOW TO LEFT
3008 D9 				EXX			      ; GET THE NEXT BYTE
3009 1C 				INC   E 		      ; INCREMENT IT TOO
300A 2001				JR    NZ,ALL_ADDED	      ; JUMP IF NO OVERFLOW
300C 14 				INC   D 		      ; INCREMENT THE LAST BYTE
300D D9 		  ALL_ADDED:	EXX			      ; RESTORE THE ORIGINAL REGISTERS
300E C9 				RET			      ; FINISHED
300F			  ; THE "SUBTRACTION" OPERATION
300F			  ; (OFFSET 03 - SEE CALCULATE BELOW: "SUBTRACT")
300F			  ; THIS SUBROUTINE SIMPLY CHANGES THE SIGN OF THE SUBTRAHEND AND CARRIED ON INTO
300F			  ; ADDITION.
300F			  ;   NOTE THAT HL POINTS TO THE MINUEND AND DE POINTS TO THE SUBTRAHEND. (SEE
300F			  ; ADDITION FOR MORE DETAILS.)
300F EB 		  SUBTRACT:	EX    DE,HL		      ; EXCHANNGE THE POINTERS
3010 CD6E34				CALL  NEGATE		      ; CHANGE THE SIGN OF THE SUBTRAHEND
3013 EB 				EX    DE,HL		      ; EXCHANGE THE POINTERS BACK AND CONTINUE
3014					;			      ; INTO ADDITION
3014			  ; THE "ADDITION" OPERATION
3014			  ; (OFFSET 0F - SEE CALCULATE BELOW: "ADDITION")
3014			  ; THE FIRST OF THREE MAJOR ARITHMETICAL SUBROUTINES, THIS SUBROUTINE CARRIES OUT
3014			  ; THE FLOATING-POINT ADDITION OF TWO NUMBERS, EACH WITH A 4-BYTE MANTISSA AND
3014			  ; 1-BYTE EXPONENT. IN THESE THREE SUBROUTINES, THE TWO NUMBERS AT THE TOP OF THE
3014			  ; CALCULATOR STACK ARE ADDED/MULTIPLIED/DIVIDED TO GIVE ONE NUMBER AT THE TOP
3014			  ; OF THE CALCULATOR STACK, A "LAST" VALUE. HL POINT TO THE SECOND NUMBER FROM
3014			  ; THE TOP, THE ADDEND/MULTIPLIER/DIVIDEND, DE POINTS TO THE NUMBER AT THE TOP
3014			  ; OF THE CALCULATOR STACK, THE ADDEND/MULTIPLIER/DIVIDEND SO???. AFTERWARDS HL
3014			  ; POINTS TO THE RESULTANT "LAST VALUE" WHOSE ADDRESS CAN ALSO BE CALCULATED TO
3014			  ; BY STKEND_5.
3014			  ;   BUT THE ADDITION SUBROUTINE FIRST TESTS WHETHER  THE TWO NUMBERS TO BE ADDED
3014			  ; ARE SMALL INTERVALS. IF THEY ARE, IT ADDS THEM QUITE SIMPLY IN HL AND BC, AND
3014			  ; PUT THE RESULT DIRECTLY ON THE STACK. NO TWOS COMPLEMENTING IS NEEDED BEFORE
3014			  ; OF ALTER THE ADDITION, SINCE SUCH NUMBERS ARE HELD ON THE STACK IN TWO
3014			  ; COMPLEMENT FORM, READY FOR ADDITION.
3014 1A 		  ADDITION:	LD    A,(DE)		      ; TEST WHETHER THE FIRST BYTES OF
3015 B6 				OR    (HL)		      ; BOTH NUMBERS ARE ZERO
3016 2026				JR    NZ,FULL_ADDN	      ; IF NOT, JUMP FOR FULL ADDITION.
3018 D5 				PUSH  DE		      ; SAVE THE POINTER TO THE SECOND NUMBER.
3019 23 				INC   HL		      ; POINT TO THE SECOND BYTE OF THE FIRST
301A E5 				PUSH  HL		      ; NUMBER AND SAVE THAT POINTER TOO
301B 23 				INC   HL		      ; POINT TO THE LESS SIGNIFICANT BYTE
301C 5E 				LD    E,(HL)		      ; FETCH IT IN E
301D 23 				INC   HL		      ; POINT TO MORE SIGNIFICANT BYTE
301E 56 				LD    D,(HL)		      ; FETCH IT IN D
301F 23 				INC   HL		      ; MOVE ON TO THE SECOND BYTE OF
3020 23 				INC   HL		      ; THE SECOND NUMBER
3021 23 				INC   HL
3022 7E 				LD    A,(HL)		      ; FETCH IT IN A (THIS IN THE SIGN BYTE)
3023 23 				INC   HL		      ; POINT TO THE LESS SIGNIFICANT BYTE
3024 4E 				LD    C,(HL)		      ; FETCH IT IN C
3025 23 				INC   HL		      ; POINT TO MORE SIGNIFICANT BYTE
3026 46 				LD    B,(HL)		      ; FETCH IT IN B
3027 E1 				POP   HL		     ; FETCH THE POINTER TO THE SIGN
3028 EB 				EX    DE,HL		      ; BYTE OF THE FIRST NUMBER, PUT IT N DE
3029					;			      ; AND THE NUMBER IN HL
3029 09 				ADD   HL,BC		      ; PERFORM THE ADDITION RESULT IN HL
302A EB 				EX    DE,HL		      ; RESULT TO DE, SIGN BYTE TO HL
302B 8E 				ADC   A,(HL)		      ; ADD THE SIGN BYTE AND TH CARRY
302C 0F 				RRCA			      ; INTO A; THIS WILL DETECT ANY OVERFLOW
302D CE00				ADC   A,0		      ; A NON-ZERO A NOW INDICATES OVERFLOW
302F 00B				JR    NZ,ADDN_OFLW	      ; JUMP TO RESET THE POINTERS AND TO DO FULL
3031					;			      ; ADDITION
3031 9F 				SBC   A,A		      ; DEFINE THE CORRECT SIGN BYTE FOR THE
3032					;			      ; RESULT
3032 77 				LD    (HL),A		      ; STORE IT ON THE STACK
3033 23 				INC   HL		      ; POINT TO THE NEXT LOCATION
3034 73 				LD    (HL),E		      ; STORE THE LOW BYTE OF THE RESULT
3035 23 				INC   HL		      ; POINT TO THE NEXT LOCATION
3036 72 				LD    (HL),D		      ; STORE THE HIGH BYTE OF THE RESULT
3037 2B 				DEC   HL		      ; MOVE THE POINTER BACK TO
3038 2B 				DEC   HL		      ; ADDRESS THE FIRST BYTE OF THE
3039 2B 				DEC   HL		      ; RESULT
303A D1 				POP   DE		      ; RESTORE STKEND TO DE
303B C9 				RET			      ; FINISHED
303C			  ; NOTE THAT THE NUMBER 65536 DECIMAL CAN ARISE HERE IN THE FORM 00 FF 00 00 00
303C			  ; AS THE RESULT OF THE ADDITION OF TWO SMALLER NEGATIVE INTEGERS, E.G.
303C			  ; -65000 AND 535. IT IS SIMPLY STACKD IN THIS FORM. THIS IS A MISTAKE. THE
303C			  ; SPECTRUM SYSTEM CANNOT HANDLE THIS NUMBER.
303C			  ; MOST FUNCTIONS TREAT IT AS ZERO, AND IT IS PRINTED AS -1E-38, OBTAINED  BY
303C			  ; TREATING IT AS "MINUS ZERO" IN AN ILLEGITIMATE FORMAT.
303C			  ;   ONE POSSIBLE REMADY WOULD BE TEST FOR THE NUMBER AT ABOUT BYTE 3032 AND, IF
303C			  ; IT IS PRESENT, TO MAKE THE SECOND BYTE 80 HEX. AND THE FIRST BYTE 91 HEX., SO
303C			  ; PRODUCING THE FULL FIVE BYTE FLOATING-POINT FORM OF THE NUMBER, I.E.
303C			  ; 91 80 00 00 00, WHICH CAUSES NO PROBLEMS. SEE ALSO THE REMARKS IN "TRUNCATE"
303C			  ; BELOW, BEFORE BYTE 3225, AND THE APPENDIX.
303C 2B 		  ADDN_OFLW:	DEC   HL		      ; RESTORE THE POINTER TO THE FIRST NUMBER
303D D1 				POP   DE		      ; RESTORE THE POINTER TO THE SECOND NUMBER
303E CD9332		  FULL_ADDN:	CALL  RE_ST_TWO 	      ; RESTACK BOTH NUMBERS IN FULL FIVE BYTE
3041					;			      ; FLOATING-POINT FORM.
3041			  ; THE FULL ADDITION SUBROUTINE FIRST CALLS PREP_ADD FOR EACH NUMBER, THEN GETS
3041			  ; THE TWO NUMBERS FROM THE CALCULATOR STACK AND PUTS THE ONE WITH THE SMALLER
3041			  ; EXPONENT INTO HE ADDEND POSITION. IT THEN CALLS SHIFT_FP TO SHIFT THE ADDEND
3041			  ; UP TO 32 DECIMAL PLACES RIGHT TO LINE IT UP FOR ADDITION. THE ACTUAL ADDITION
3041			  ; IS DONE IN A FEW BYTES, A SINGLE SHIFT IS MADE  FOR CARRY (OVERFLOW TO THE
3041			  ; LEFT) IF NEEDED, THE RESULT IS TWOS COMPLEMENTED IF NEGATIVE, AND ANY ARITHMETIC OVERFLOW
3041			  ; IS REPORTED; OTHERWISE THE SUBROUTINE JUMPS TO TEST_NORM TO NORMALISE THE
3041			  ; RESULT AND RETURN IT TO THE STACK WITH THE CORRECT SIGN BIT INSERTED INTO THE
3041			  ; SECOND BYTE.
3041 D9 				EXX			      ; EXCHANGE THE REGISTERS
3042 E5 				PUSH  HL		      ; SAVE THE NEXT LITERAL ADDRESS
3043 D9 				EXX			      ; EXCHANGE THE REGISTERS
3044 D5 				PUSH  DE		      ; SAVE POINTER TO THE ADDEND
3045 E5 				PUSH  HL		      ; SAVE POINTER TO THE AUGEND
3046 CD9B2F				CALL  PREP_ADD		      ; PREPARE THE AUGEND
3049 47 				LD    B,A		      ; SAVE THE EXPONENT IN B
304A EB 				EX    DE,HL		      ; EXCHANGE THE POINTERS
304B CD9B2F				CALL  PREP_ADD		      ; PREPARE THE ADDEND
304E 4F 				LD    ,A		      ; SAVE ITS EXPONENT IN C
304F B8 				CP    B 		      ; IF THE FIRST EXPONENT IS SMALLER
3050 3003				JR    NC,SHIFT_LEN	      ; KEEP THE FIRST NUMBER IN THE
3052 78 				LD    A,B		      ; ADDEND POSITION; OTHERWISE
3053 41 				LD    B,C		      ; CHANGE THE EXPONENTS AND THE
3054 EB 				EX    DE,HL		      ; POINTERS BACK AGAIN.
3055 F5 		  SHIFT_LEN:	PUSH  AF		      ; SAVE THE LARGER EXPONENT IN A
3056 90 				SUB   B 		      ; THE DIFFERENCE BETWEEN THE EXPONENTS IS
3057					;			      ; THE LENGTH OF THE SHIFT RIGHT
3057 CDBA2F				CALL  FETCH_TWO 	      ; GET TWO NUMBERS FROM THE STACK
305A CDDD2F				CALL  SHIFT_FP		      ; SHIFT THE ADDEND RIGHT
305D F1 				POP   AF		      ; RESTORE THE LARGER EXPONENT
305E E1 				POP   HL		      ; HL IS TO POINT TO RESULT
305F 77 				LD    (HL),A		      ; STORE THE EXPONET OF THE RESULT
3060 E5 				PUSH  HL		      ; SAVE THE POINTER AGAIN
3061 68 				LD    L,B		      ; M4 TO H & M5 TO L
3062 61 				LD    H,C		      ; (SEE FETCH TWO)
3063 19 				ADD   HL,DE		      ; ADD THE TWO RIGHT BYTES
3064 D9 				EXX			      ; N2 TO H' & N3 TO L'
3065 EB 				EX    DE,HL		      ; (SEE FETCH TWO)
3066 ED4A				ADC   HL,BC		      ; ADD THE BYTES WITH CARRY
3068 EB 				EX    DE,HL		      ; RESULT BACK IN D'E'
3069 7C 				LD    A,H		      ; ADD H'L' AND THE CARRY; THE
306A 8D 				ADC   A,L		      ; RESULTING MECANISMS WILL ENSURE
306B 6F 				LD    L,A		      ; THAT A SINGLE SHIFT RIGHT IS CALLED
306C 1F 				RRA			      ; IF THE SUM OF 2 POSITIVE NUMBERS
306D AD 				XOR   L 		      ; HAS OVERFLOWED LEFT, OR THE SUM OF TWO
306E D9 				EXX			      ; NEGATIVE NUMBERS HAS NOT OVERFLOWED LEFT
306F EB 				EX    DE,HL		      ; THE RESULT IS NOW IN DED'E'
3070 E1 				POP   HL		      ; GET THE POINTER TO THE EXPONENT
3071 1F 				RRA			      ; THE TEST FOR SHIFT (H'L' WERE HEX. 00 FOR
3072 3008				JR    NC,TEST_NEG	      ; POSITIVE NUMBERS AND HEX. FF FOR NEGATIVE
3074 3E01				LD    A,001H		      ; A COUNTS A SINGLE SHIFT RIGHT
3076 CDDD2F				CALL  SHIFT_FP		      ; THE SHIFT IS CALLED
3079 34 				INC   (HL)		      ; ADD 1 TO THE EXPONENT; THIS
307A 2823				JR    Z,ADD_REP_6	      ; MAY LEAD TO ARITHMETIC OVERFLOW
307C D9 		  TEST_NEG:	EXX			      ; TEST FOR NEGATIVE RESULT; GET
307D 7D 				LD    A,L		      ; SIGN BIT OF L' INTO A (THIS NOW
307E E680				AND   080H		      ; CORRECTLY INICATES THE SIGN OF
3080 D9 				EXX			      ; THE RESULT)
3081 23 				INC   HL		      ; STORE IT IN THE SECOND BYTE
3082 77 				LD    (HL),A		      ; POSITION OF THE RESULT ON
3083 2B 				DEC   HL		      ; THE CALCULATOR STACK
3084 281F				JR    Z,GO_NC_MLT	      ; IF IT IS ZERO, THEN DO NOT
3086					;			      ; TWOS COMPLEMENT THE RESULT
3086 7B 				LD    A,E		      ; GET THE FIRST BYTE
3087 ED44				NEG			      ; NEGATE IT
3089 3F 				CCF			      ; COMPLEMENT THE CARRY FOR
308A 5F 				LD    E,A		      ; CONTINUED NEGATION, AND STORE BYTE
308B 7A 				LD    A,D		      ; GET THE NEXT BYTE
308C 2F 				CPL			      ; ONES COMPLEMENT IT
308D CE00				ADC   A,0		      ; ADD IN THE CARRY FOR NEGATION
308F 57 				LD    D,A		      ; STORE THE BYTE
3090 D9 				EXX			      ; PROCEED TO GET NEXT BYTE INTO
3091 7B 				LD    A,E		      ; THE A REGISTER
3092 2F 				CPL			      ; ONES COMPLEMENT IT
3093 CE00				ADC   A,0		      ; ADD IN THE CARRY FOR NEGATION
3095 5F 				LD    E,A		      ; STORE THE BYTE
3096 7A 				LD    A,D		      ; GET THE LAST BYTE
3097 2F 				CPL			      ; ONES COMPLEMENT IT
3098 CE00				ADC   A,0		      ; ADD IN THE CARRY FOR NEGATION
309A 3007				JR    NC,END_COMPL	      ; DONE IF NO CARRY
309C 1F 				RRA			      ; ELSE GET .5 INTO MANTISSA AND
309D D9 				EXX			      ; ADD 1 TO THE EXPONENT; THIS WILL BE NEEDED
309E 34 				INC   (HL)		      ; WHEN TWO NEGATIVE NUMBERS ADD TO GIVE AN
309F					;			      ; EXACT POWER OF 2, AND IT MAY LEAD TO
309F					;			      ; ARITHMETIC OVERFLOW.
309F CAAD31		  ADD_REP_6:	JP    Z,REPORT_6	      ; GIVE AN ERROR IF REQUIRED
30A2 D9 				EXX
30A3 57 		  END_COMPL:	LD    D,A		      ; STORE THE LAST BYTE
30A4 D9 				EXX
30A5 AF 		  GO_NC_MLT:	XOR   A 		      ; CLEAR THE CARRY FLAG
30A6 C35531				JP    TEST_NORM 	      ; EXIT VIA TEST_NORM
30A9			  ; THE "HL=HL*DE" SUBROUTINE
30A9			  ; THIS SUBROUTINE IS CALLED BY "GET_HL_DE" AND BY "MULTIPLICATION" TO PERFORM
30A9			  ; THE 16-BIT MULTIPLICATION AS STATED.
30A9			  ;   ANY OVERFLOW OF THE 16 BITS AVAILABLE IS DEALT WITH ON RETURN FROM THE
30A9			  ; SUBROUTINE.
30A9 C5 		  HL_HL_DE:	PUSH  BC		      ; BC IS SAVED
30AA 0610				LD    B,010H		      ; IT IS TO BE A 16 BIT MULTIPLICATION
30AC 7C 				LD    A,H		      ; A HOLDS THE HIGH BYTE
30AD 4D 				LD    C,L		      ; C HOLDS THE LOW BYTE
30AE 210000				LD    HL,0		      ; INITIALISE THE RESULT TO ZERO
30B1 29 		  HL_LOOP:	ADD   HL,HL		      ; DOUBLE THE RESULT
30B2 380A				JR    C,HL_END		      ; JUMP IF OVERFLOW
30B4 CB11				RL    C 		      ; RESTATE BIT 7 OF C INTO THE CARRY
30B6 17 				RLA			      ; ROTATE THE CARRY BIT INTO BIT 0 AND
30B7					;			      ; BIT 7 INTO THE CARRY FLAG
30B7 3003				JR    NC,HL_AGAIN	      ; JUMP IF THE CARRY FLAG IS RESET
30B9 19 				ADD   HL,DE		      ; OTHERWISE ADD DE ONCE
30BA 3802				JR    C,HL_END		      ; JUMP IF OVERFLOW
30BC 10F3		  HL_AGAIN:	DJNZ  HL_LOOP		      ; UNTIL 16 PASSES HAVE BEEN MADE
30BE C1 		  HL_END:	POP   BC		      ; RESTORE BC
30BF C9 				RET			      ; FINISHED
30C0			  ; THE "PREPARE TO MULTIPLY OR DIVIDE" SUBROUTINE
30C0			  ; THIS SUBROUTINE PREPARES A FLOATING-POINT NUMBER FOR MULTIPLICATION OR
30C0			  ; DIVISION, RETURNINGWITH CARRY SET IF THE NUMBER IS ZERO, GETTING THE SIGN OF
30C0			  ; THE RESULT INTO A REGISTER, AND REPLACING THE SIGN BIT IN THE NUMBER BY THE
30C0			  ; TRUE NUMERIC BIT 1.
30C0 CDE934		  PREP_M_D:	CALL  TEST_ZERO 	      ; IF THE NUMBER IS ZERO, RETURN
30C3 D8 				RET   C 		      ; WITH CARRY SET
30C4 23 				INC   HL		      ; POINT TO THE SIGN BYTE
30C5 AE 				XOR   (HL)		      ; GET SIGN FOR RESULT INTO A (LIKE SIGNS
30C6					;			      ; GIVE MINUS); ALSO RESET THE CARRY FLAG
30C6 CBFE				SET  7,(HL)		      ; SET THE TRUE NUMERIC BIT
30C8 2B 				DEC   HL		      ; POINT TO THE EXPONENT AGAIN
30C9 C9 				RET			      ; RETURN WITH CARRY FLAG RESET
30CA			  ; THE "MULTIPLICATION" OPERATION
30CA			  ; (OFFSET 04 - SEE CALCULATE BELOW: "MULTIPLY")
30CA			  ; THIS SUBROUTINE FIRST TESTS WHETHER THE TWO NUMBERS TO BE MULTIPLIED ARE
30CA			  ; "SMALL INTEGERS". IF THEY ARE, IT USES INT_FETCH TO GET THEM FROM THE STACK.
30CA			  ; HL_HL_DE TO MULTIPLY THEM AND INT_STORE TO RETURN THE RESULT TO THE STACK.
30CA			  ; ANY OVERFLOW OF THIS "SHORT MULTIPLICATION" (I.E. IF THE RESULT IS NOT ITSELF
30CA			  ; A "SMALL INTEGER") CAUSES A JUMP TO MULTIPLICATION IN FIVE BYTE FLOATING POINT
30CA			  ; FORM (SEE BELLOW).
30CA 1A 		  MULTIPLY:	LD    A,(DE)		      ; TEST WHETHER THE FIRST BYTES OF
30CB B6 				OR    (HL)		      ; BOTH NUMBERS ARE ZERO
30CC 2022				JR    NZ,MULT_LONG	      ; IF NOT, JUMP FOR "LONG" MULTIPLICATION
30CE D5 				PUSH  DE		      ; SAVE THE POINTERS: TO THE SECOND NUMBER
30CF E5 				PUSH  HL		      ; AND TO THE FIRST NUMBER
30D0 D5 				PUSH  DE		      ; AND TO THE SECOND NUMBER YET AGAIN
30D1 CD7F2D				CALL  INT_FETCH 	      ; FETCH SIGN IN C, NUMBER IN DE
30D4 EB 				EX    DE,HL		      ; NUMBER IN HL NOW
30D5 E3 				EX    (SP),HL		      ; NUMBER TO STACK, SECOND POINTER TO HL
30D6 41 				LD    B,C		      ; SAVE FIRST SIGN IN B
30D7 CD7F2D				CALL  INT_FETCH 	      ; FETCH SECOND SIGN IN C, NUMBER IN DE
30DA 78 				LD    A,B		      ; FORM SIGN OF RESULT IN A; LIKE SIGN GIVE
30DB A9 				XOR   C 		      ; PLUS (00), UNLIKE GIVE MINUL (FF)
30DC 4F 				LD    C,A		      ; STORE SIGN OF RESULT IN C
30DD E1 				POP   HL		      ; RESTORE THE FIRST NUMBER TO HL
30DE CDA930				CALL  HL_HL_DE		      ; PERFORM THE ACTUAL MULTIPLICATION
30E1 EB 				EX    DE,HL		      ; STORE THE RESULT IN DE
30E2 E1 				POP   HL		      ; RESTORE THE POINTER TO THE FIRST NUMBER
30E3 380A				JR    C,MULT_OFLW	      ; JUMP ON OVERFLOW TO "FULL" MULTIPLICATION
30E5 7A 				LD    A,D		      ; THESE 5 BYTE ENSURE THAT
30E6 B3 				OR    E 		      ; 00 FF 00 00 00 IS REPLACED BY
30E7 2001				JR    NZ,MULT_RSLT	      ; ZERO; THAT THEY SHOULD NOT BE NEEDED IF
30E9 4F 				LD    C,A		      ; THE NUMBER WERE EXCLUDED FROM THE SYSTEM
30EA					;			      ; (SEE AFTER 303B ABOVE)
30EA CD8E2D		  MULT_RSLT:	CALL  INT_STORE 	      ; NEW STORE THE RESULT ON THE STACK
30ED D1 				POP   DE		      ; RESTORE STKEND TO DE
30EE C9 				RET			      ; FINISHED
30EF D1 		  MULT_OFLW:	POP   DE		      ; RESTORE THE POINTER TO THE SECOND NUMBER
30F0 CD9332		  MULT_LONG:	CALL  RE_ST_TWO 	      ; RESTACK BOTH NUMBERS IN "FULL" FIVE BYTE
30F3					;			      ; FLOATING-POINT FORM
30F3			  ; THE FULL MULTIPLICATION SUBROUTINE PREPARES THE FIRST NUMBER FOR
30F3			  ; MULTIPLICATION BY CALLING PERP_M_D, RETURNING IF IT IS ZERO; OTHERWISE THE
30F3			  ; SECOND NUMBER IS PREPARED BY AGAIN CALLING PREP_M_D, AAD IF IT IS ZERO THE
30F3			  ; SUBROUTINE GOES TO SET THE RESULT TO ZERO. NEXT IT FETCHS THE TWO NUMBERS FROM
30F3			  ; THE CALCULATOR STACK AND MULTIIPLIES THEIR MANTISAS IN THE USUAL WAY,
30F3			  ; RETAITING THE FIRST NUMBER (TREATED AS THE MULTIPLIER) RIGHT AND ADDING IN
30F3			  ; THE SECOND NUMBER (THE MULTIPLICAND) TO THE RESULT WHENEVER THE MULTIPLIER
30F3			  ; BIT IS SET. THE EXPONENTS ARE THEN ADDED TOGETHER AND CHECKS ARE MADE FOR
30F3			  ; OVERFLOW AND FOR UNDERFLOW (GIVING THE RESULT ZERO). FINALLY, THE RESULT IS
30F3			  ; NORMALISED AND RETURNED TO THE CALCULATOR STACK WITH THE CORRECT SIGN BIT IN
30F3			  ; THE SECOND BYTE
30F3 AF 				XOR   A 		      ; A IS SET TO HEX.. 00 SO THAT THE SIGN
30F4					;			      ; OF THE FIRST NUMBER WILL GO INTO A
30F4 CDC030				CALL  PREP_M_D		      ; PREPARE THE FIRST NUMBER, AND
30F7 D8 				RET   C 		      ; RETURN IF ZERO. (RESULT ALREADY ZERO).
30F8 D9 				EXX			      ; EXCHANGE THE REGISTERS
30F9 E5 				PUSH  HL		      ; SAVE THE NEXT LITERAL ADDRESS
30FA D9 				EXX			      ; EXCHANGE THE REGISTERS
30FB D5 				PUSH  DE		      ; SAVE THE POINTER TO THE MULTIPLICAND
30FC EB 				EX    DE,HL		      ; EXCHANGE THE POINTERS
30FD CDC030				CALL  PREP_M_D		      ; PREPARE THE 2ND NUMBER
3100 EB 				EX    DE,HL		      ; EXCHANGE THE POINTERS AGAIN
3101 385A				JR    C,ZERO_RSLT	      ; JUMP FORWARD IF SECOND NUMBER IS ZERO
3103 E5 				PUSH  HL		      ; SAVE THE POINTER TO THE RESULT
3104 CDBA2F				CALL  FETCH_TWO 	      ; GET THE TWO NUMBERS FROM THE STACK
3107 78 				LD    A,B		      ; M5 TO A (SEE FETCH_TWO)
3108 A7 				AND   A 		      ; PREPARE FOR A SUBTRACTION
3109 ED62				SBC   HL,HL		      ; INITIALISE HL TO ZERO FOR A RESULT
310B D9 				EXX			      ; EXCHANGE THE REGISTERS
310C E5 				PUSH  HL		      ; SAVE M1 & N1 (SEE FETCH_TWO)
310D ED62				SBC   HL,HL		      ; ALSO INITIALISE H'L' FOR THE RESULT
310F D9 				EXX			      ; EXCHANGE THE REGISTERS
3110 0621				LD    B,021H		      ; B COUNTS 33 DECIMAL, HEX. 21 SHIFTS
3112 1811				JR    STRT_MLT		      ; JUMPP FORWARD INTO THE LOOP
3114			  ; NOW ENTER THE MULTIPLIER LOOP
3114 3005		  MLT_LOOP:	JR    NC,NO_ADD 	      ; JUMP FORWARD TO NO_ADD IF NO CARRY, I.E.
3116					;			      ; THE MULTIPLIER BIT WAS RESET
3116 19 				ADD   HL,DE		      ; ELSE, ADD THE MULTIPLICAND IN
3117 D9 				EXX			      ; D'E'DE (SEE FETCH_TWO) INTO
3118 ED5A				ADC   HL,DE		      ; THE RESULT BEING BUILT UP ON
311A D9 				EXX			      ; H'L'HL
311B D9 		  NO_ADD:	EXX			      ; WHETHER MULTIPLICAND WAS ADDED
311C CB1C				RR    H 		      ; OR NOT, SHIFT RESULT RIGHT IN
311E CB1D				RR    L 		      ; H'L'HL, I.E. THE SHIFT IS DONE BY
3120 D9 				EXX			      ; ROTATING EACH BYTE WITH CARRY, SO
3121 CB1C				RR    H 		      ; THAT ANY BIT THAT DROPS INTO THE
3123 CB1D				RR    L 		      ; CARRY IS PICKED UP BY THE NEXT BYTE
3125					;			      ; AND THE SHIFT CONTINUED INTO B'C'CA
3125 D9 		  STRT_MLT:	EXX			      ; SHIFT RIGHT THE MULTIPLIER IN
3126 CB18				RR    B 		      ; B'C'CA (SEE FETCH_TWO & ABOVE)
3128 CB19				RR    C 		      ; A FINAL DROPPING INTO THE
312A D9 				EXX			      ; CARRY WILL TRIGGER ANOTHER ADD OF
312B CB19				RR    C 		      ; THE MULTIPLICAND TO THE RESULT
312D 1F 				RRA
312E 10E4				DJNZ  MLT_LOOP		      ; LOO 33 TIMES TO GET ALL THE BITS
3130 EB 				EX    DE,HL		      ; MOVE THE RESULT FROM:
3131 D9 				EXX
3132 EB 				EX    DE,HL		      ; H'L'HL TO D'E'DE
3133 D9 				EXX
3134			  ; NOW ADD THE EXPONENTS TOGETHER
3134 C1 				POP   BC		      ; RESTORE THE EXPONENT M1 & N1
3135 E1 				POP   HL		      ; RESTORE THE POINTER TO THE EXPONENT BYTE
3136 78 				LD    A,B		      ; GET THE SUM OF THE TWO
3137 81 				ADD   A,C		      ; EXPONENT BYTES IN A, AND THE CORRECT CARRY
3138 2001				JR    NZ,MAKE_EXPT	      ; IF THE SUM EQUALS ZERO THEN CLEAR
313A A7 				AND   A 		      ; THE CARRY; ELSE LEAVE IT UNCHANGED
313B 3D 		  MAKE_EXPT:	DEC   A 		      ; PREPARE TO INCREASE THE
313C 3F 				CCF			      ; EXPONENT BY HEX. 80
313D			  ; THE REST OF THE SUBROUTINE IS COMMON TO BOTH MULTIPLICATION AND DIVISION
313D 17 		  DIVN_EXPT:	RLA			      ; THESE FEW BYTES VERY CLEVERLY MAKE THE
313E 3F 				CCF			      ; CORRECT EXPONENT BYTE
313F 1F 				RRA			      ; ROTATING LEFT THEN RIGHT GETS THE EXPONENT
3140					;			      ; BYTE (TRUE EXPONENT PLUS HEX.80) INTO A
3140 F24631				JP    P,OFLW_1_CLR	      ; IF THE SIGN FLAG IS RESET, NO REPORT OF
3143					;			      ; ARITHMETIC OVERFLOW NEEDED
3143 3068				JR    NC,REPORT_6	      ; REPORT THE OVERFLOW IF CARRY RESET
3145 A7 				AND   A 		      ; CLEAR THE CARRY NOW
3146 3C 		  OFLW_1_CLR:	INC   A 		      ; THE EXPONENT BYTE IS NOW COMPLETE;
3147 2008				JR    NZ,OFLW_2_CLR	      ; BUT IF A IS ZERO A FURTHER
3149 3806				JR    C,OFLW_2_CLR	      ; CHECK FOR OVERFLOW IS NEEDED
314B D9 				EXX			      ; IF THERE IS NO CARRY SET AND THE
314C CB7A				BIT  7,D		      ; RESULT IS ALREADY IN NORMAL FORM
314E D9 				EXX			      ; (BIT 7 OF D' SET) THEN THERE IS
314F 205C				JR    NZ,REPORT_6	      ; OVERFLOW TO REPORT; BUT IF BIT 7 OF D'
3151					;			      ; IS RESET, THE RESULT IS JUST IN RANGE,
3151					;			      ; I.E. JUST UNDER 2**127
3151 77 		  OFLW_2_CLR:	LD    (HL),A		      ; STORE THE EXPONENT BYTE, AS LAST
3152 D9 				EXX			      ; PASS THE FIFTH RESULT BYTE TO A
3153 78 				LD    A,B		      ; FOR THE NORMALISATION SEQUENCE
3154 D9 				EXX			      ; I.E. THE OVERFLOW FROM L INTO B'
3155			  ; THE REMAINDER OF THHE SUBROUTINE DEALS WITH NORMALISATION AND IS COMMON TO
3155			  ; ALL THE ARITHMETIC ROUTINES
3155 3015		  TEST_NORM:	JR    NC,NORMALISE	      ; IF NO CARRY THEN NORMALISE NOW
3157 7E 				LD    A,(HL)		      ; ELSE, DEAL WITH UNDERFLOW (ZERO RESULT)
3158 A7 				AND   A 		      ; OR NEAR UNDERFLOW
3159 3E80		  NEAR_ZERO:	LD    A,080H		      ; (RESULT 2**-128)
315B 2801				JR    Z,SKIP_ZERO	      ; RETURN EXPONENT TO A, TEST IF A
315D AF 		  ZERO_RSLT:	XOR   A 		      ; IS ZERO (CASE 2**-128) AND IF SO
315E D9 		  SKIP_ZERO:	EXX			      ; PRODUCE 2**-128 IF NUMBER IS
315F A2 				AND   D 		      ; NORMAL; OTHERWISE PRODUCE ZERO
3160 CDFB2F				CALL  ZEROS_4_5 	      ; THE EXPONENT MUST THEN BE SET
3163 07 				RLCA			      ; TO ZERO (FOR ZERO) OR 1 (FOR 2**-128)
3164 77 				LD    (HL),A		      ; RESTORE THE EXPONENT BYTE
3165 382E				JR    C,OFLOW_CLR	      ; JUMP IF CASE 2**-128
3167 23 				INC   HL		      ; OTHERWISE, PUT ZERO INTO SECOND
3168 77 				LD    (HL),A		      ; OF RESULT ON THE CALCULATOR
3169 2B 				DEC   HL		      ; STACK
316A 1829				JR    OFLOW_CLR 	      ; JUMP FORWARD TO TRANSFER THE RESULT
316C			  ; THE ACTUAL NORMALISATION OPERATION
316C 0620		  NORMALISE:	LD    B,020H		      ; NORMALISE THE RESULT BY UP TO 32
316E D9 		  SHIFT_ONE:	EXX			      ; DECIMAL, HEX. 20 SHIFTS LEFT OF
316F CB7A				BIT  7,D		      ; D'E'DE (WITH A ADJOINED) UNTIL
3171 D9 				EXX			      ; BIT 7 OF D' IS SET; A HOLDS ZERO
3172 2012				JR    NZ,NORML_NOW	      ; AFTER ADDITION SO NO PRECISION IS
3174 07 				RLCA			      ; GAINED OR LOST; A HOLDS THE  FIFTH
3175 CB13				RL    E 		      ; BYTE FROM B' AFTER MULTIPLICATION
3177 CB12				RL    D 		      ; OR DIVISION; BUT AS ONLY
3179 D9 				EXX			      ; ABOUT 32 BITS CAN BE CORRECT, NO
317A CB13				RL    E 		      ; PRECISION IS LOST. NOTE THAT A IS
317C CB12				RL    D 		      ; ROTATED CIRCULARLY, WITH BRANCH
317E D9 				EXX			      ; AT CARRY ... EVENTUALLY A RANDOM PROCESS
317F 35 				DEC   (HL)		      ; THE EXPONENT IS DECREMENTED ON EACH SHIFT
3180 28D7				JR    Z,NEAR_ZERO	      ; IF THE EXPONENT BECAMES ZERO, THAN NUMBER
3182					;			      ; FROM 2**-129 ARE ROUNDED UP TO 2**-128
3182 10EA				DJNZ  SHIFT_ONE 	      ; LOOP BACK, UP TO 32 TIMES
3184 18D7				JR    ZERO_RSLT 	      ; IF BIT 7 NEVER BECAME 1 THEN THE
3186					;			      ; WHOLE RESULT IS TO BE ZERO
3186			  ; FINISH THE NORMALISATION BY CONSIDERING THE "CARRY"
3186 17 		  NORML_NOW:	RLA			      ; AFTER NORMALISATION ADD BACK
3187 300C				JR    NC,OFLOW_CLR	      ; ANY FINAL CARRY THAT WENT INTO A.
3189 CD0430				CALL  ADD_BACK		      ; JUMP FORWARD IF THE CARRY DOES
318C 2007				JR    NZ,OFLOW_CLR	      ; NOT RIPPLE RIGHT BACK
318E D9 				EXX			      ; IF IT SHOULD RIPPLE RIGHT BACK
318F 1680				LD    D,080H		      ; THEN SET MANTISSA TO 0.5 AND
3191 D9 				EXX			      ; INCREMENT THE EXPONENT
3192 34 				INC   (HL)		      ; THIS ACTION MAY LEAD TO ARITHMETIC
3193 2818				JR    Z,REPORT_6	      ; OVERFLOW (FINAL CASE)
3195			  ; THE FINAL PART OF THE SUBROUTINE INVOLVES PASSING THE RESULT TO THE BYTES
3195			  ; RESERVED FOR IT ON THE CALCULATOR STACK AND RESETTING THE POINTERS.
3195 E5 		  OFLOW_CLR:	PUSH  HL		      ; SAVE THE RESULT POINTER
3196 23 				INC   HL		      ; POINT TO THE SIGN BYTE IN THE RESULT
3197 D9 				EXX			      ; THE RESULT IS MOVED FROM ITS
3198 D5 				PUSH  DE		      ; PRESENT REGISTER, D'E'DE TO BCDE;
3199 D9 				EXX			      ; AND THEN ACDE
319A C1 				POP   BC
319B 78 				LD    A,B		      ; THE SIGN BIT IS RETRIEVED FROM
319C 17 				RLA			      ; ITS TEMPORARY STORE AND TRANSFERED
319D CB16				RL    (HL)		      ; TO ITS CORRECT POSITION OF
319F 1F 				RRA			      ; BIT 7 OF THE FIRST BYTE OF THE MANTISSA
31A0 77 				LD    (HL),A		      ; THE FIRST BYTE IS STORED
31A1 23 				INC   HL		      ; NEXT
31A2 71 				LD    (HL),C		      ; THE SECOND BYTE IS STORED
31A3 23 				INC   HL		      ; NEXT
31A4 72 				LD    (HL),D		      ; THE THIRD BYTE IS STORED
31A5 23 				INC   HL		      ; NEXT
31A6 73 				LD    (HL),E		      ; THE FOURTH BYTE IS STORED
31A7 E1 				POP   HL		      ; RESTORE THE POINTER TO THE RESULT
31A8 D1 				POP   DE		      ; RESTORE THE POINTER TO THE SECOND NUMBER
31A9 D9 				EXX			      ; EXCHANGE THE REGISTERS
31AA E1 				POP   HL		      ; RESTORE THE NEXT LITERAL ADDRESS
31AB D9 				EXX			      ; EXCHANGE THE REGISTERS
31AC C9 				RET			      ; FINISHED
31AD			  ; REPORT 6 - ARITHMETIC OVERFLOW
31AD CF 		  REPORT_6:	RST   ERROR_1		      ; CALL THE ERROR HANDLING
31AE 05 				DEFB 005H		      ; ROUTINE
31AF			  ;
31AF			  ; THE "DIVISION" OPERATIOON
31AF			  ; (OFFSET 05 - SEE CALCULATE BELOW: "DIVISION")
31AF			  ; THIS SUBROUTINE FIRST PREPARED THE DIVISOR BY CALLING PERP_M_D, REPORTING
31AF			  ; ARITHMETIC OVERFLOW IF IT IS ZERO; THEN IT PREPARES THE DIVIDEND BY AGAIN
31AF			  ; CALLING PREP_M_D, RETURNING IF IT IS ZERO. NEXT FETCHES THE TWO NUMBERS FROM
31AF			  ; THE CALCULATOR STACK AND DIVIDES THEIR MANTISSA BY MEANS OF THE USUAL
31AF			  ; RESTORING DIVISION, TRIAL SUBTRACTING THE DIVISOR FROM THE DIVIDEND AND
31AF			  ; RESTORING IF THERE IS CARRY, OTHERWISE ADDING 1 TO THE QUOTIENT. THE MAXIMUM
31AF			  ; PRECISION IS OBTAINED FOR A 4-BYTE DIVISION, AND AFTER SUBTRACTING THE
31AF			  ; EXPONENTS THE SUBROUTINE EXITS BY JOINING THE LATER PART OF MULTIPLICATION.
31AF CD9332		  DIVISION:	CALL  RE_ST_TWO 	      ; USE FULL FLOATING POINT FORM
31B2 EB 				EX    DE,HL		      ; EXCHANGE THE POINTERS
31B3 AF 				XOR   A 		      ; A IS SET TO 00, SO THAT THE SIGN OF THE
31B4					;			      ; FIRST NUMBER WILL GO INTO A
31B4 CDC030				CALL  PREP_M_D		      ; PREPARE THE DIVISOR AND GIVE THE
31B7 38F4				JR    C,REPORT_6	      ; REPORT FOR ARITHMETIC OVERFLOW IF IT IS 0
31B9 EB 				EX    DE,HL		      ; EXCHANGE THE POINTERS
31BA CDC030				CALL  PREP_M_D		      ; PREPARE THE DIVIDED AND RETURN
31BD D8 				RET   C 		      ; IF IT IS ZERO (RESULT ALREADY ZERO).
31BE D9 				EXX			      ; EXCHANGE THE REGISTERS
31BF E5 				PUSH  HL		      ; SAVE THE NEXT LITERAL ADDRESS
31C0 D9 				EXX			      ; EXCHANGE THE REGISTERS
31C1 D5 				PUSH  DE		      ; SAVE POINTER TO DIVISOR
31C2 E5 				PUSH  HL		      ; SAVE POINTER TO DIVIDEND
31C3 CDBA2F				CALL  FETCH_TWO 	      ; GET THE TWO NUMBERS FROM TE STACK
31C6 D9 				EXX			      ; EXCHANGE THE REGISTERS
31C7 E5 				PUSH  HL		      ; SAVE M1 & N1 ON THE MACHINE STACK
31C8 60 				LD    H,B		      ; COPY THE FOUR BYTES OF THE
31C9 69 				LD    L,C		      ; DIVIDEND FROM REGISTERS B'C'CB
31CA D9 				EXX			      ; I.E. M2,M3,M4 & M5; (SEE
31CB 61 				LD    H,C		      ; FETCH_TWO) TO THE REGISTERS H'L'HL
31CC 68 				LD    L,B
31CD AF 				XOR   A 		      ; CLEAR A AND RESET THE CARRY FLAG
31CE 06DF				LD    B,0DFH		      ; B WILL COUNT UPWARDS FROM -33 TO -1, TWO
31D0					;			      ; COMPLEMENT. HEX. DF TO FF, LOOPING ON
31D0					;			      ; MINUS AND WILL JUMP AGAIN ON ZERO FOR
31D0					;			      ; EXTRA PRECISION.
31D0 1810				JR    DIV_START 	      ; JUMP FORWARD INTO THE DIVISION LOOP FOR
31D2					;			      ; THE FIRST TRIAL SUBTRACTION.
31D2			  ; NOW ENTER THE DIVISION LOOP
31D2 17 		  DIV_LOOP:	RLA			      ; SHIFT THE RESULT LEFT INTO B'C'CA
31D3 CB11				RL    C 		      ; SHIFTING OUT THE BITS ALREADY
31D5 D9 				EXX			      ; THERE, PICKING UP 1 FROM THE
31D6 CB11				RL    C 		      ; CARY WHENEVER IT IS SET, AND
31D8 CB10				RL    B 		      ; ROTATING LEFT EACH BYTE WITH
31DA D9 				EXX			      ; CARRY TO ACHIVE THE 32 BIT SHIT
31DB 29 		  DIV_34TH:	ADD   HL,HL		      ; MOVE WHAT REMAINS OF THE DIVIDEND
31DC D9 				EXX			      ; LEFT IN H'L'HL BEFORE THE NEXT TRIAL
31DD ED6A				ADC   HL,HL		      ; SUBTRACTION; IF A BIT DROPS INTO CARRY,
31DF D9 				EXX			      ; FORCE NO RESTORE AND A BIT FOR THE
31E0 3810				JR    C,SUBN_ONLY	      ; QUOTIENT, THUS RESULTING A FULL 32 BIT
31E2					;			      ; DIVISOR.
31E2 ED52		  DIV_START:	SBC   HL,DE		      ; TRIAL SUBTRACT DIVISOR IN D'E'DE
31E4 D9 				EXX			      ; FROM REST OF DIVIDEND IN H'L'HL;
31E5 ED52				SBC   HL,DE		      ; THERE IS NO INITIAL CARRY (SEE
31E7 D9 				EXX			      ; PREVIOUS STEP).
31E8 300F				JR    NC,NO_RSTORE	      ; JUMP FORWARD IF THERE IS NO CARRY
31EA 19 				ADD   HL,DE		      ; OTHERWISE RESTORE, I.E. ADD BACK
31EB D9 				EXX			      ; THE DIVISOR. THEN CLEAR THE CARRY
31EC ED5A				ADC   HL,DE		      ; SO THAT THERE WILL BE NO BIT FOR
31EE D9 				EXX			      ; THE QUOTIENT (THE DIVISOR DID
31EF A7 				AND   A 		      ; NOT GO)
31F0 1808				JR    COUNT_ONE 	      ; JUMP FORWARD TO THE COUNTER
31F2 A7 		  SUBN_ONLY:	AND   A 		      ; JUST SUBTRACT WITH NO RESTORE
31F3 ED52				SBC   HL,DE		      ; AND GO ON TO SET THE CARRY FLAG
31F5 D9 				EXX			      ; BECAUSE THE LOST BIT OF THE DIVIDEND
31F6 ED52				SBC   HL,DE		      ; IS TO BE RETRIEVED AND USED
31F8 D9 				EXX			      ; FOR THE QUOTIENT.
31F9 37 		  NO_RSTORE:	SCF			      ; ONE FOR THE QUOTIENT IN B'C'CA
31FA 04 		  COUNT_ONE:	INC   B 		      ; STEP THE LOOP COUNT UP BY ONE
31FB FAD231				JP    M,DIV_LOOP	      ; LOOP 32 TIMES FOR ALL BITS
31FE F5 				PUSH  AF		      ; SAVE THE 33RD BIT FOR EXTRA PRECISION
31FF					;			      ; (THE PRESENT CARRY)
31FF 28E1				JR    Z,DIV_START	      ; TRIAL SUBTRACT YET AGAIN FOR ANY 34THD
3201					;			      ; BIT; THE PUSH_AF ABOVE SAVES THIS BIT TOO
3201			  ; !!!???!!!
3201			  ; NOTE: THIS JUMP IS MADE TO WRONG PLACE. NO 34TH BIT WILL EVER BE OBTAINED
3201			  ; WITHOUT FIRST SHIFTING THE DIVIDEND. HENCE	IMPORTANT RESULT LIKE 1/10 AND
3201			  ; 1/1000 ARE NOT ROUNDED UP AS THEY SHOULD BE. ROUNDING UP NEVER OCCURS WHEN
3201			  ; IT DEPENDS ON THE 34TH BIT. THE JUMP SHOULD HAVE BEEN TO 31DB DIV_34TH ABOVE
3201			  ; I.E. BYTE 3200 HEX. IN THE ROM SHOULD READ DA HEX (218 DECIMAL) INSTEAD OF
3201			  ; E1 HEX. (225 DECIMAL).
3201 5F 				LD    E,A		      ; NOW MOVE THE FOUR BYTES THAT
3202 51 				LD    D,C		      ; FORM THE MANTISSA BYTES OF THE
3203 D9 				EXX			      ; RESULT FROM B'C'CA TO D'E'DE
3204 59 				LD    E,C
3205 50 				LD    D,B
3206 F1 				POP   AF		      ; THEN PUT THE 34TH 33RD BITS
3207 CB18				RR    B 		      ; INTO B' TO BE PICKED UP ON
3209 F1 				POP   AF		      ; NORMALISATION.
320A CB18				RR    B
320C D9 				EXX
320D C1 				POP   BC		      ; RESTORE THE EXPONENT BYTES, M1 & N1
320E E1 				POP   HL		      ; RESTORE THE POINTER TO THE RESULT
320F 78 				LD    A,B		      ; GET THE DIFFERENCE BETWEEN THE TWO
3210 91 				SUB   C 		      ; EXPONENT BYTES INTO A AND SET THE
3211					;			      ; CARRY FLAG IF REQUIRED
3211 C33D31				JP    DIVN_EXPT 	      ; EXIT VIA DIVN_EXPT
3214			  ; THE "INTEGER TRUNCATION TOWARDS ZERO" SUBROUTINE
3214			  ; (OFFSET 3A - SEE CALCULATE BELOW: "TRUNCATE")
3214			  ; THIS SUBROUTINE (SAY I(X)) RETURNS THE RESULT OF INTEGER TRUNCATION OF X,
3214			  ; THE "LATS VALUE", TOWARDS ZERO. THUS, I(2.4) IS 2 AND I(-2.4) IS -2. THE
3214			  ; SUBROUTINE RETURNS AT ONCE IF X IS IN THE FORM OF A "SHORT INTEGER". IT
3214			  ; RETURNS ZERO IF THE EXPONENT BYTE OF X IS LESS THAN 81 HEX. (ABS(X) LESS THAN
3214			  ; 1). IF I(X) IS A "SHORT INTEGER" THE SUBROUTINE RETURNS IT IN THAT FORM.
3214			  ; IT RETURNS X IF THE EXPONENT BYTE IS A0 HEX. OR GREATER (X HAS NO SIGNIFICANT
3214			  ; NON-INTEGRAL PART). OTHERWISE THE CORRECT NUMBER OF BYTES OF X ARE SET TO ZERO
3214			  ; IF NEEDED, ONE MORE BYTE IS SPLIT WITH A MASK.
3214 7E 		  TRUNCATE:	LD    A,(HL)		      ; GET THE EXPONENT BYTE OF X INTO A
3215 A7 				AND   A 		      ; IF A IS ZERO, RETURN SINCE X IS
3216 C8 				RET   Z 		      ; ALREADY A SMALL INTEGER
3217 FE81				CP    081H		      ; COMPARE E, THE EXPONENT, TO 81 HEX.
3219 3006				JR    NC,T_GR_ZERO	      ; JUMP IF E IS GREATER THAN 80H
321B 3600				LD    (HL),0		      ; ELSE, SET THE EXPONENT TO ZERO
321D 3E20				LD    A,020H		      ; ENTER 32 DECIMAL, 20H, INTO A AND JUMP
321F 1851				JR    NIL_BYTES 	      ; FORWARD TO NIL_BYTES TO MAKE ALL THE
3221					;			      ; BITS OF X BE ZERO.
3221 FE91		  T_GR_ZERO:	CP    091H		      ; COMAPARE E TO 91H, 145 DECIMAL
3223 201A				JR    NZ,T_SMALL	      ; JUMP IF E NOT 91H
3225			  ; !!!???!!!
3225			  ; THE NEXT 26 BYTES SEEM DESIGNED TO TEST WHETHER X IS IN FACT -65536 DECIMAL,
3225			  ; I.E. 91 80 00 00 00, AND IF IT IS, TO SET IT TO 00 FF 00 00 00. THIS IS A
3225			  ; MISTAKE. AS ALREADY STATED AT BYTE 303B ABOVE, THE SPECTRUM SYSTEM CANNOT
3225			  ; HANDLE THIS NUMBER. THE RESULT HERE IS SIMPLY TO MAKE INT(-65536) RETURN THE
3225			  ; VALUE -1. THIS IS A PITY, SINCE THE NUMBER WOULD HAVE BEEN PERFECTLY ALL RIGHT
3225			  ; IF LEFT ALONE. THE REMEDY WOULD SEEM TO BE SIMPLY TO OMIT THE 28 BYTES FROM
3225			  ; 3223 ABOVE TO 323E INCLUSIVE FROM THE PROGRAM.
3225 23 				INC   HL		      ; HL IS POINTED AT THE FOURTH BYTE
3226 23 				INC   HL		      ; OF X, WHERE THE 17 BITS OF THE
3227 23 				INC   HL		      ; INTEGER PART OF X END AFTER THE FIRST BIT
3228 3E80				LD    A,080H		      ; THE FIRST BIT IS OBTAINED IN A
322A A6 				AND   (HL)		      ; USING 80H AS A MASK
322B 2B 				DEC   HL		      ; THAT BIT IS A PREVIOUS 8 BITS
322C B6 				OR    (HL)		      ; ARE TESTED TOGETHER FOR ZERO
322D 2B 				DEC   HL		      ; HL IS POINTED AT THE SECOND BYTE OF X
322E 2003				JR    NZ,T_FIRST	      ; IF ALREDY NON ZERO, THE TEST CAN END
3230 3E80				LD    A,080H		      ; OTHERWISE, THE TEST FOR -65536 IS NOW
3232 AE 				XOR   (HL)		      ; COMPLETED: 91 80 00 00 00 WILL LEAVE THE
3233					;			      ; ZERO FLAG SET NOW
3233 2B 		  T_FIRST:	DEC   HL		      ; HL IS POINTED AT THE FIRST BYTE OF X
3234 2036				JR    NZ,T_EXPNENT	      ; IF ZERO RESET, THE JUMP  IS MADE
3236 77 				LD    (HL),A		      ; THE FIRST BYTE IS SET TO ZERO.
3237 23 				INC   HL		      ; HL POINTS TO THE SECOND BYTE
3238 36FF				LD    (HL),0FFH 	      ; THE SECOND BYTE IS FF
323A 2B 				DEC   HL		      ; HL AGAIN POINTS TO THE FIRST BYTE
323B 3E18				LD    A,018H		      ; THE LAST 24 BITS ARE SET TO ZERO
323D 1833				JR    NIL_BYTES 	      ; THE JUMP TO NIL_BYTES COMPLETES THE
323F					;			      ; NUMBER 00 FF 00 00 00
323F			  ; IF THE EXPONENT BYTE OF X IS BETWEEN 81H AND 90H (129 AND 144) INCLUSIVE
323F			  ; I(X) IS A "SMALL INTEGER", AND WILL BE COMPRESSED INTO ONE OR TWO BYTES.
323F			  ; BUT FIRST A TEST IS MADE TO SEE WHETHER X IS, AFTER ALL, LARGE.
323F 302C		  T_SMALL:	JR    NC,X_LARGE	      ; JUMP WITH EXPONENT BYTE 92 OR MORE (IT
3241					;			      ; WOULD BE BETTER TO JUMP WITH 91 TOO)
3241					;			      ; !!!???!!!
3241 D5 				PUSH  DE		      ; SAVE STKEND IN DE
3242 2F 				CPL			      ; RANGE 129<=A<=144 BECOMES 126>=A>=111
3243 C691				ADD   A,091H		      ; RANGE IS NOW 15D>=A>=0
3245 23 				INC   HL		      ; POINT HL AT SECOND BYTE
3246 56 				LD    D,(HL)		      ; SECOND BYTE TO D
3247 23 				INC   HL		      ; POINT HL AT THIRD BYTE
3248 5E 				LD    E,(HL)		      ; THIRD BYTE TO E
3249 2B 				DEC   HL		      ; POINT HL AT FIRST BYTE AGAIN
324A 2B 				DEC   HL
324B 0E00				LD    C,0		      ; ASSUME A POSITIVE NUMBER
324D CB7A				BIT  7,D		      ; NOW TEST FOR NEGATIVE (BIT 7 SET)
324F 2801				JR    Z,T_NUMERIC	      ; JUMP IF POSITIVE AFTER ALL
3251 0D 				DEC   C 		      ; CHANGE THE SIGN
3252 CBFA		  T_NUMERIC:	SET  7,D		      ; INSERT TRUE NUMERIC BIT 1 IN D
3254 0608				LD    B,008H		      ; NOW TEST WHETHER A >=8 (ONE
3256 90 				SUB   B 		      ; BYTE ONLY) OR TWO BYTES NEEDED
3257 80 				ADD   A,B		      ; LEAVE A UNCHANGED
3258 3804				JR    C,T_TEST		      ; JUMP IF TWO BYTES NEEDED
325A 5A 				LD    E,D		      ; PUT THE ONE BYTE INTO E
325B 1600				LD    D,0		      ; AND SET D TO ZERO
325D 90 				SUB   B 		      ; NOW 1 <=A<=7 TO COUNT THE SHIFTS NEEDED
325E 2807		  T_TEST:	JR    Z,T_STORE 	      ; JUMP IF NO SHIFT NEEDED
3260 47 				LD    B,A		      ; B WILL COUNT THE SHIFTS
3261 CB3A		  T_SHIFT:	SRL   D 		      ; SHIFT D AND E B TIMES RIGHT TO
3263 CB1B				RR    E 		      ; PRODUCE THE CORRECT NUMBER
3265 10FA				DJNZ  T_SHIFT		      ; LOOP UNTIL B IS ZERO
3267 CD8E2D		  T_STORE:	CALL  INT_STORE 	      ; STORE THE RESULT ON THE STACK
326A D1 				POP   DE		      ; RESTORE STKEND TO DE
326B C9 				RET			      ; FINISHED
326C			  ; LARGE VALUES OF X REMAINS TO BE CONSIDERED.
326C 7E 		  T_EXPNENT:	LD    A,(HL)		      ; GET THE EXPONENT BYTE OF X INTO A
326D D6A0		  X_LARGE:	SUB   0A0H		      ; SUBTRACT 160D, A0H, FROM E
326F F0 				RET   P 		      ; RETURN ON PLUS - X HAS NO SIGNIFICANT
3270					;			      ; NON-INTEGRAL PART. (IF THE TRUE EXPONENT
3270					;			      ; WERE REDUCED TO ZERO, THE BINARY POINT
3270					;			      ; WOULD COME AT OR AFTER THE END OF THE
3270					;			      ; FOUR BYTES OF THE MANTISSA).
3270 ED44				NEG			      ; ELSE NEGATE THE REMAINDER, THIS GIVES
3272					;			      ; THE NUMBER OF BITS TO BECOME ZERO (THE
3272					;			      ; NUMBER OF BITS AFTER THE "BINARY POINT").
3272			  ; NOW THE BITS OF THE MANTISSA CAN BE ENTERED.
3272 D5 		  NIL_BYTES:	PUSH  DE		      ; GET THE CURRENT VALUE OF DE (STKEND)
3273 EB 				EX    DE,HL		      ; MAKE HL POINT ONE PAST THE FIFTH BYTE
3274 2B 				DEC   HL		      ; HL NOW POINTS TO THE FIFTH BYTE OF X
3275 47 				LD    B,A		      ; GET THE NUMBER OF BITS TO BE SET
3276 CB38				SRL   B 		      ; TO ZERO INTO B AND DIVIDE IT BY 8
3278 CB38				SRL   B 		      ; TO GIVE THE NUMBER OF WHOLE
327A CB38				SRL   B 		      ; BYTES IMPLIED
327C 2805				JR    Z,BITS_ZERO	      ; JUMP FORWARD IF THE RESULT IS ZERO
327E 3600		  BYTE_ZERO:	LD    (HL),0		      ; ELSE SET THE BYTES TO ZERO
3280 2B 				DEC   HL		      ; B COUNTS THEM
3281 10FB				DJNZ  BYTE_ZERO
3283 E607		  BITS_ZERO:	AND   007H		      ; GET A MOD 8; THIS IS THE NUMBER
3285					;			      ; OF BITS STILL TO BE SET TO ZERO
3285 2809				JR    Z,IX_END		      ; JUMP TO THE END IF NOTHING MORE TO DO
3287 47 				LD    B,A		      ; B WILL COUNT THE BITS NOW
3288 3EFF				LD    A,0FFH		      ; PREPARE THE MASK
328A CB27		  LESS_MASK:	SLA   A 		      ; WHICH EACH LOOP A ZERO ENTERS THE MASK
328C 10FC				DJNZ  LESS_MASK 	      ; FROM THE RIGHT AND THEREBY A MASK OF THE
328E					;			      ; CORRECT LENGTH IS PRODUCED
328E A6 				AND   (HL)		      ; THE UNWANTED BITS OF (HL) ARE
328F 77 				LD    (HL),A		      ; LOST AS THE MASKING IS PERFORMED
3290 EB 		  IX_END:	EX    DE,HL		      ; RETURN THE POINTER TO HL
3291 D1 				POP   DE		      ; RETURN STKEND TO DE
3292 C9 				RET			      ; FINISHED
3293			  ; THE "RE_STACK TWO" SUBROUTINE
3293			  ; THIS SUBROUTINE IS CALLED TO RE-STACK TWO "SMALL INTEGERS" IN FULL FIVE BYTE
3293			  ; FLOATING-POINT FORM FOR THE BINARY OPERATIONS OF ADDITION,MULTIPLICATION AND
3293			  ; DIVISION. IT DOES SO BY CALLING THE FOLLOWING SUBROUTINE TWICE.
3293 CD9632		  RE_ST_TWO:	CALL  RESTK_SUB 	      ; CALL THE SUBROUTINE, AND THEN CONTINUE
3296					;			      ; INTO IT FOR THE SECOND CALL.
3296 EB 		  RESTK_SUB:	EX    DE,HL		      ; EXCHANGE THE POINTERS AT EACH CALL.
3297			  ; THE "RE-STACK" SUBROUTINE
3297			  ; (OFFSET 3D - SEE CALCULATE BELOW: "RE_STACK")
3297			  ; THIS SUBROUTINE IS CALLED TO RE-STACK ONE NUMBER (WHICH COULD BE A "SMALL
3297			  ; INTEGER") IN FULL FIVE BYTE FLOATING-POINT FORM. IT IS USED FOR A SINGLE
3297			  ; NUMBER BY ARCTAN AND ALSO THROUGTH THE CALCULATOR OFFSET, BY EXP,LN AND
3297			  ; "GET_ARG"
3297 7E 		  RE_STACK:	LD    A,(HL)		      ; IF THE FIRST BYTE IS NOT ZERO
3298 A7 				AND   A 		      ; RETURN - THE NUMBER CANNOT BE
3299 C0 				RET   NZ		      ; A "SMALL INTEGER"
329A D5 				PUSH  DE		      ; SAVE THE "OTHER" POINTER IN DE
329B CD7F2D				CALL  INT_FETCH 	      ; FETCH THE SIGN IN C AND THE NUMBER IN DE
329E AF 				XOR   A 		      ; CLEAR THE A REGISTER
329F 23 				INC   HL		      ; POINT TO THE FIRST LOCATION
32A0 77 				LD    (HL),A		      ; SET THE FIFTH BYTE TO ZERO
32A1 2B 				DEC   HL		      ; POINT TO THE FOURTH LOCATION
32A2 77 				LD    (HL),A		      ; SET THE FOURTH BYTE TO ZERO, BYTES 2 AND 3
32A3					;			      ; WILL HOLD THE MANTISSA
32A3 0691				LD    B,091H		      ; SET B TO 145D FOR THE EXPONENT I.E. FOR
32A5					;			      ; UP TO 16 BTS IN THE INTEGER
32A5 7A 				LD    A,D		      ; TEST WHETHER D IS ZERO SO THAT
32A6 A7 				AND   A 		      ; AT MOST 8 BITS WOULD BE NEEDED
32A7 2008				JR    NZ,RS_NRMLSE	      ; JUMP IF MORE THAN 8 BITS NEEDED
32A9 B3 				OR    E 		      ; NOW TEST E TOO
32AA 42 				LD    B,D		      ; SAVE THE ZERO IN B (IT WILL GIVE ZERO
32AB					;			      ; EXPONENT IF E TOO IS ZERO)
32AB 2810				JR    Z,RS_STORE	      ; JUMP IF E IS INDEED ZERO
32AD 53 				LD    D,E		      ; MOVE E TO D (D WAS ZERO, E NOT).
32AE 58 				LD    E,B		      ; SET E TO ZERO NOW
32AF 0689				LD    B,089H		      ; SET B TO 137D FOR THE EXPONENT - NO MORE
32B1					;			      ; THAN 8 BITS NOW.
32B1 EB 		  RS_NRMLSE:	EX    DE,HL		      ; POINTER TO DE, NUMBER TO HL
32B2 05 		  RSTK_LOOP:	DEC   B 		      ; DECREMENT THE EXPONENT ON SUCH SHIFT
32B3 29 				ADD  HL,HL		      ; SHIFT THE NUMBER RIGHT ONE POSITION
32B4 30FC				JR    NC,RSTK_LOOP	      ; UNTIL THE CARRY IS SET
32B6 CB09				RRC  C 		      ; SIGN BIT TO CARRY FLAG NOW
32B8 CB1C				RR    H 		      ; INSERT IT IN PLACEAS THE NUMBER
32BA CB1D				RR    L 		      ; IS SHIFTED BACK ONE PLACE - NORMAL NOW
32BC EB 				EX    DE,HL		      ; POINTER TO BYTE 4 BACK TO HL
32BD 2B 		  RS_STORE:	DEC   HL		      ; POINT TO THE THIRD LOCATION
32BE 73 				LD    (HL),E		      ; STORE THE THIRD BYTE
32BF 2B 				DEC   HL		      ; POINT TO THE SECOND LOCATION
32C0 72 				LD    (HL),D		      ; STORE THE SECOND BYTE
32C1 2B 				DEC   HL		      ; POINT TO THE FIRST LOCATION
32C2 70 				LD    (HL),B		      ; STORE THE EXPONENT BYTE
32C3 D1 				POP   DE		      ; RESTORE THE "OTHER" POINTER TO DE
32C4 C9 				RET			      ; FINISHED
32C5			  ;
32C5			  ; THE FLOATING-POINT CALCULATOR
32C5			  ;
32C5			  ; THE TABLE OF CONSTANTS
32C5			  ;
32C5			  ; THIS FIRST TABLE GIVES THE FIVE USFUL AND FREQUENTLY NEEDED NUMBERS ZERO,
32C5			  ; ONE, A HALF, A HALF OF PI AND TEN. THE NUMBERS ARE HELD IN A CONDENSED FORM
32C5			  ; WHICH IS EXPANDED BY THE STACK_LITERALS SUBROUTINE, SEE BELOW, TO GIVE THE
32C5			  ; REQUIRED FLOATING POINT FORM.
32C5			  ;	       DATA			  CONSTANT	  WHEN EXPANDED GIVES
32C5			  ;
32C5 00 		  STK_XZERO:	DEFB 000H		      ;   ZERO		  00 00 00 00 00
32C6 B0 				DEFB 0B0H
32C7 00 				DEFB 000H
32C8			  ;
32C8 40 		  STK_ONE:	DEFB 040H		      ;   ONE		  00 00 01 00 00
32C9 B0 				DEFB 0B0H
32CA 00 				DEFB 000H
32CB 01 				DEFB 001H
32CC			  ;
32CC 30 		  STK_HALF:	DEFB 030H		      ;   A HALF	  80 00 00 00 00
32CD 00 				DEFB 000H
32CE			  ;
32CE F1 		  STK_PI_2:	DEFB 0F1H		      ; A HALF OF PI	  81 49 0F DA A2
32CF 49 				DEFB 049H
32D0 0F 				DEFB 00FH
32D1 DA 				DEFB 0DAH
32D2 A2 				DEFB 0A2H
32D3			  ;
32D3 40 		  STK_TEN:	DEFB 040H		      ; TEN		  00 00 0A 00 00
32D4 B0 				DEFB 0B0H
32D5 00 				DEFB 000H
32D6 0A 				DEFB 00AH
32D7			  ;
32D7			  ; THE TABLE OF ADDRESSES:
32D7			  ;
32D7			  ; THE SECOND TABLE IS A LOOK-UP TABLE OF THE ADDRESSES OF THE SIXTY-SIX
32D7			  ; OPERATIONAL SUBROUTINES OF THE CALCULATOR. THE OFFSETS USED TO INDEX INTO THE
32D7			  ; TABLE ARE DERIVED EITHER FROM THE OPERATION CODES USED IN SCANNING, SEE 2734,
32D7			  ; ETC., OR FROM THE LITERALS THAT FOLLOW A RST 028H INSTRUCTION.
32D7			  ;
32D7			  ;		  LABEL 		 OFFSET
32D7 8F36		  D008: 	DEFW  JUMP_TRUE 	      ; 00
32D9 3C34				DEFW  EXCHANGE		      ; 01
32DB A133				DEFW  DELETE		      ; 02
32DD 0F30				DEFW  SUBTRACT		      ; 03
32DF CA30				DEFW  MULTIPLY		      ; 04
32E1 AF31				DEFW  DIVISION		      ; 05
32E3 5138				DEFW  TO_POWER		      ; 06
32E5 1B35				DEFW  OR		      ; 07
32E7 2435				DEFW  NO_AND_NO 	      ; 08
32E9 3B35				DEFW  NO_EQL		      ; 09
32EB 3B35				DEFW  NO_EQL		      ; 0A
32ED 3B35				DEFW  NO_EQL		      ; 0B
32EF 3B35				DEFW  NO_EQL		      ; 0C
32F1 3B35				DEFW  NO_EQL		      ; 0D
32F3 3B35				DEFW  NO_EQL		      ; 0E
32F5 1430				DEFW  ADDITION		      ; 0F
32F7 2D35				DEFW  STR_AND_NO	      ; 10
32F9 3B35				DEFW  NO_EQL		      ; 11
32FB 3B35				DEFW  NO_EQL		      ; 12
32FD 3B35				DEFW  NO_EQL		      ; 13
32FF 3B35				DEFW  NO_EQL		      ; 14
3301 3B35				DEFW  NO_EQL		      ; 15
3303 3B35				DEFW  NO_EQL		      ; 16
3305 9C35				DEFW  STRS_ADD		      ; 17
3307 DE35				DEFW  VAL_DOLL		      ; 18
3309 BC34				DEFW  USR_DOLL		      ; 19
330B 4536				DEFW  READ_IN		      ; 1A
330D 6E34				DEFW  NEGATE		      ; 1B
330F 6936				DEFW  CODE		      ; 1C
3311 DE35				DEFW  VAL_DOLL		      ; 1D
3313 7436				DEFW  LEN		      ; 1E
3315 B537				DEFW  SIN		      ; 1F
3317 AA37				DEFW  COS		      ; 20
3319 DA37				DEFW  TAN		      ; 21
331B 3338				DEFW  ASIN		      ; 22
331D 4338				DEFW  ACOS		      ; 23
331F E237				DEFW  ATAN		      ; 24
3321 1337				DEFW  LN		      ; 25
3323 C436				DEFW  EXP		      ; 26
3325 AF36				DEFW  INT		      ; 27
3327 4A38				DEFW  SQR		      ; 28
3329 9234				DEFW  SGN		      ; 29
332B 6A34				DEFW  ABS		      ; 2A
332D AC34				DEFW  PEEK		      ; 2B
332F A534				DEFW  IN		      ; 2C
3331 B334				DEFW  USER_NO		      ; 2D
3333 1F36				DEFW  STR_DOLL		      ; 2E
3335 C935				DEFW  CHAR_DOLL 	      ; 2F
3337 0135				DEFW  NOT		      ; 30
3339 C033				DEFW  MOVE_FP		      ; 31
333B A036				DEFW  N_MOD_M		      ; 32
333D 8636				DEFW  JUMP		      ; 33
333F C633				DEFW  STK_DATA		      ; 34
3341 7A36				DEFW  DEC_JR_NZ 	      ; 35
3343 0635				DEFW  LESS_0		      ; 36
3345 F934				DEFW  GREATE_0		      ; 37
3347 9B36				DEFW  END_CALC		      ; 38
3349 8337				DEFW  GET_ARGT		      ; 39
334B 1432				DEFW  TRUNCATE		      ; 3A
334D A233				DEFW  FP_CALC_2 	      ; 3B
334F 4F2D				DEFW  E_TO_FP		      ; 3C
3351 9732				DEFW  RE_STACK		      ; 3D
3353 4934				DEFW  SERIES_06 	      ; 3E
3355 1B34				DEFW  STK_ZERO		      ; 3F
3357 2D34				DEFW  STK_MEM_0 	      ; 40
3359 0F34				DEFW  GET_MEM_0 	      ; 41
335B			  ; NOTE: THE LAST FOUR SUBROUTINES ARE MULTY-PURPOSE SUBROUTINES AND ARE ENTERED
335B			  ; WITH A PARAMETER THAT IS A COPY OF THE RIGHT HAND FIVE BITS OF THE ORIGINAL
335B			  ; LITERALS. THE FULL SET FOLLOWS:
335B			  ; OFFSET 3E:	  SERIES-06, SERIES-08 & SERIES-0C; LITERALS 86,88 & 8C
335B			  ; OFFSET 3F:	  STK_XZERO, STK_ONE, STK_HALF,STK_PI_2 & STK_TEN; LITERALS A0 TO A4
335B			  ; OFSET 40:	  ST_MEM0, ST_MEM1, ST_MEM2, ST_MEM3, ST_MEM4 & ST_MEM5;
335B			  ;		  LITERALS C0 TO C5
335B			  ; OFFSET 41:	  GET_MEM0, GET_MEM1, GET_MEM2, GET_MEM3, GET_MEM4 & GET_MEM5;
335B			  ;		  LITERALS E0 TO E5
335B			  ;
335B			  ; THE "CALCULATE" SUBROUTINE
335B			  ;
335B			  ; THIS SUBROUTINE IS USED TO PERFORM FLOATING-POINT CALCULATIONS. THIS CAN BE
335B			  ; CONSIDERED TO BE OF THREE TYPES:
335B			  ;   I.  BINARY OPERATIONS, E.G. ADDITION, WHERE TWO NUMBERS IN FLOATING-POINT FORM ARE
335B			  ;	  ADDED TOGETHER TO GIVE ONE "LAST VALUE".
335B			  ;  II.  UNARY OPERATIONS, E.G. SIN, WHERE THE "LAST VALUE" IS CHANGED TO GIVE
335B			  ;	  THE APPROPRIATE FUNCTION RESULT AS A NEW "LAST VALUE".
335B			  ; III.  MANIPULATORY OPERATIONS, E.G. ST_MEM0, WHERE THE "LAST VALUE" IS COPIED
335B			  ;	  TO THE FIRST FIVE BYTES OF THE CALCULATOR AREA.
335B			  ;
335B			  ; THE OPERATIONS TO BE PERFORMED ARE SPECIFIED AS A SERIES OF DATA-BYTES, THE
335B			  ; LITERALS, THAT FOLLOW AN RST 028H INSTRUCTION THAT CALLS THIS SUBROUTINE. THE
335B			  ; LAST LITERAL IN THE LIST IS ALWAYS "38" WHICH LEADS TO AN END TO THE WHOLE
335B			  ; OPERATION.
335B			  ;   IN THE CASE OF A SINGLE OPERATION NEEDENG TO BE PERFORMED, THE OPERATION
335B			  ; OFFSET CAN BE PASSED TO THE CALCULATOR IN THE B REGISTER, AND OPERATION "3B",
335B			  ; THE SINGLE CALLCULATION OPERATION, PREFORMED.
335B			  ;   IT IS ALSO POSSIBLE TO CALL THIS SUBROUTINE RECURSIVELY, I.E. FROM WITHIN
335B			  ; ITSELF, AND IN SUCH A CASE IT IS POSSIBLE TO USE THE SYSTEM VARIABLE BREG AS
335B			  ; A COUNTER THAT CONTROLS HOW MANY OPERATIONS ARE PERFORMED BEFORE RETURNING.
335B			  ;   THE FIRST PART OF THIS SUBROUTINE IS COMPLICATED BUT ESSENTIALLY IT PERFORMS
335B			  ; THE TWO TASKS OF SETTING THE REGISTERS TO HOLD THEIR REQUIRED VALUES, AND TO
335B			  ; PRODUCE AN OFFSET, AND POSSIBLY A PARAMETER, FROM THE LITERAL THAT IS
335B			  ; CURRENTLY BEING CONSIDERED.
335B			  ;   THE OFFSET IS USED TO INDEX INTO THE CALCULATOR"S TABLE OF ADDRESSES, SEE
335B			  ; ABOVE, TO FIND THE REQUIRED SUBROUTINE ADDRESS.
335B			  ;   THE PARAMETER IS USED WHEN THE MULTI-PURPOSE SUBROUTINES ARE CALLED.
335B			  ; NOT: A FLOATING-POINT NUMBER MAY IN REALITY BE A SET OF STRING PARAMETERS.
335B			  ;
335B CDBF35		  CALCULATE:	CALL  STK_PNTRS 	      ; PRESUME A UNARY OPERATION AND THEREFORE
335E					;			      ; SET HL TO PINT TO THE START OF THE "LAST
335E					;			      ; VALUE" ON THE CALCULATOR STACK AND DE ONE
335E					;			      ; PAST THIS FLOATING-POINT NUMBER (STKEND).
335E 78 		  GEN_ENT_1:	LD    A,B		      ; FITHER, TRANSFER A SINGLE
335F 32675C				LD    (BREG),A		      ; OPERATION OFFSET TO BREG TEMPORARILY, OR
3362					;			      ; WHEN USING THE SUBROUTINE RECURSIVELY
3362					;			      ; PASS THE PARAMETER TO BREG TO BE USED AS
3362					;			      ; A COUNTER.
3362 D9 		  GEN_ENT_2:	EXX			      ; THE RETURN ADDRESS OF THE SUBROUTINE
3363 E3 				EX    (SP),HL		      ; IS STORE IN H'L'. THIS SAVES THE POINTER
3364 D9 				EXX			      ; TO THE FIRST LITERAL. ENTERING THE
3365					;			      ; CALCULATOR AT GEN_ENT_2 IS USED WHENEVER
3365					;			      ; BREG IS IN USE AS A COUNTER AND IS NOT
3365					;			      ; TO BE DISTURBED.
3365 ED53655C		  RE_ENTRY:	LD    (STKEND),DE	      ; A LOOP IS NOW ENTERED TO HANDLE EACH
3369					;			      ; LITERAL IN THE LIST THAT FOLLOWS THE
3369					;			      ; CALLING INSTRUCTION; SO FIRST, ALWAYS SET
3369					;			      ; STKEND.
3369 D9 				EXX			      ; GO TO THE ALTERNATE REGISTER SET, AND
336A 7E 				LD    A,(HL)		      ; FETCH THE LITERAL FOR THIS LOOP.
336B 23 				INC   HL		      ; MAKE H'L' POINT TO THE NEXT LITERAL
336C E5 		  SCAN_ENT:	PUSH  HL		      ; THIS POINTER IS SAVED BRIEFLY ON THE
336D					;			      ; MACHINE STACK. SCAN_INT? IS USED BY THE
336D					;			      ; SIGNLE CALLCULATION SUBROUTINE TO FIND
336D					;			      ; THE SUBROUTINE THAT IS REQUIRED
336D A7 				AND   A 		      ; TEST THE A REGISTER
336E F28033				JP    P,FIRST_3D	      ; SEPARATE THE SIMPLE LITERALS FROM THE
3371					;			      ; MULTIPURPOSE LITERALS. JUMP WITH
3371					;			      ; LITERALS 00 - 3D
3371 57 				LD    D,A		      ; SAVE THE LITERAL IN D
3372 E660				AND   060H		      ; CONTINUE ONLY WITH BITS 5 & 6
3374 0F 				RRCA			      ; FOUR RIGHT SHIFTS MAKE THEM
3375 0F 				RRCA			      ; NOW BITS 1 & 2
3376 0F 				RRCA
3377 0F 				RRCA
3378 C67C				ADD   A,07CH		      ; THE OFFSET REQUIRED ARE 3E-41
337A 6F 				LD    L,A		      ; AND L WILL NOW HOLD DOUBLE THE
337B					;			      ; REQUIRED OFFSET
337B 7A 				LD    A,D		      ; NOW PRODUCE THE PARAMETER BY
337C E61F				AND   01FH		      ; TAKING BITS 0,1,2,3 & 4 OF THE LITERAL;
337E					;			      ; KEEP THE PARAMETER IN A
337E 180E				JR    ENT_TABLE 	      ; JUMP FORWARD TO FIND TH ADDRESS OF THE
3380					;			      ; REQUIRED SUBROUTINE
3380 FE18		  FIRST_3D:	CP    018H		      ; JUMP FORWARD IF PERFORMING A
3382 3008				JR    NC,DOUBLE_A	      ; UNARY OPERATION
3384 D9 				EXX			      ; ALL OF THE SUBROUTINES THAT PREFORMS
3385 01FBFF				LD    BC,-5		      ; BINARY OPERATIONS REQUIRE
3388 54 				LD    D,H		      ; THAT HL POINTS TO THE FIRST OPERAND
3389 5D 				LD    E,L		      ; AND DE POINTS TO THE SECOND
338A 09 				ADD   HL,BC		      ; OPERAND (THE "LAST VALUE") AS THEY
338B D9 				EXX			      ; APPEAR ON THE CALCULATOR STACK
338C 07 		  DOUBLE_A:	RLCA			      ; AS EACH ENTRY IN THE TABLE OF
338D 6F 				LD    L,A		      ; ADDRESSES TAKES UP TO TWO BYTES THE
338E					;			      ; OFFSET PRODUCED IS DOUBLED
338E 11D732		  ENT_TABLE:	LD    DE,D008		      ; THE BASE ADDRESS OF THE TABLE
3391 2600				LD    H,0		      ; THE ADDRESS OF THE REQUIRED
3393 19 				ADD   HL,DE		      ; TABLE ENTRY IS FORMED IN HL; AND
3394 5E 				LD    E,(HL)		      ; THE REQUIRED SUBROUTINE ADDRESS
3395 23 				INC   HL		      ; IS LOADED INTO DE
3396 56 				LD    D,(HL)		      ; REGISTER PAIR
3397 216533				LD    HL,RE_ENTRY	      ; THE RE_ENTRY ADDRESS
339A E3 				EX    (SP),HL		      ; IS PUT N THE MACHINE STACK
339B D5 				PUSH  DE		      ; UNDERNEATH? THE SUBROUTINE ADDRESS
339C D9 				EXX			      ; RETURN TO THE MAIN SET OF REGISTERS
339D ED4B665C				LD    BC,(STKEND+1)	      ; THE CURRENT VALUE OF BREG IS TRANSFERED TO
33A1					;			      ; THE B REGISTER THEREBY RETURNING THE
33A1					;			      ; SINGLE OPERATION OFFSET.
33A1					;			      ; (SEE COMPARISON AT 353B)

                                                                                                                                                                                                                                                                                                                                                                                            