33A1 C9 		  DELETE:	RET			      ; AN INDIRECT JUMP TO THE REQUIRED
33A2					;			      ; SUBROUTINE
33A2			  ; THE "DELETE" SUBROUTINE
33A2			  ; (OFFSET 02: "DELETE")
33A2			  ; THIS SUBROUTINE CONTAINS ONLY THE SINGLE RET INSTRUCTION AT 33A1, ABOVE. THE
33A2			  ; LITERAL 02 ????? IN THIS SUBROUTINE BEING CONSIDERED AS A BINARY OPERATION
33A2			  ; THAT IS TO BE ENTERED WITH A FIRST NUMBER ADDRESSED BY THE HL REGISTER PAIR AND
33A2			  ; A SECOND NUMBER ADDRESSED BY THE DE REGISTER PAIR, AND THE RESULT PRODUCED
33A2			  ; AGAIN ADDRESSED BY THE HL REGISTER PAIR.
33A2			  ;   THE SINGLE RET INSTRUCTION THEREBY LEADS TO THE FIRST NUMBER  BEING
33A2			  ; CONSIDERED AS THE RESULTING "LAST VALUE" AND THE SECOND NUMBER CONSIDERED AS
33A2			  ; BEING DELETED; OF COURSE THE NUMBER HAS NOT BEEN DELETED FROM THE MEMORY, BUT
33A2			  ; REMAINS INACTIVE AND WILL PROBABLY SOON BY OVERWRITEN.
33A2			  ;
33A2			  ; THA "SINGLE OPERATION" SUBROUTINE
33A2			  ; (OFFSET 3B: "FP_CALC_2")
33A2			  ; THIS SUBROUTINE IS ONLY CALLED FROM SCANNING AT 2757 HEX AND IS USED TO
33A2			  ; PERFORM A SINGLE ARITHMETIC OPERATION. THE OFFSET THAT SPECIFIES WHICH
33A2			  ; OPERATION IS TO BE PERFORMED IS SUPPLIED TO THE CALCULATOR IN THE B REGISTER
33A2			  ; AND SUBSEQUENTLY TRANSFERED TO THE SYSTEM VARIABLE BREG.
33A2			  ;   THE EFFECT OF CALLING THIS SUBROUTINE IS ESSENTIALLY TO MAKE A JUMP TO THE
33A2			  ; APPROPRIATE SUBROUTINE FOR THE SINGLE OPERATION.
33A2 F1 		  FP_CALC_2:	POP   AF		      ; DISCARD THE RE_ENTRY ADDRESS
33A3 3A675C				LD    A,(BREG)		      ; TRANSFER THE OFFSET TO A
33A6 D9 				EXX			      ; ENTER THE ALTERNATE REGISTER SET
33A7 18C3				JR    SCAN_ENT		      ; JUMP BACK TO FIND THE REQUIRED ADDRESS;
33A9					;			      ; STACK THE RE_ENTRY ADDRESS AND JUMP TO
33A9					;			      ; THE SUBROUTINE FOR THE OPERATION
33A9			  ; THE "TEST 5-SPACES" SUBROUTINE
33A9			  ; THIS SUBROUTINE TESTS WHENEVER THERE IS SUFFICIENT ROOM IN MEMORY FOR ANOTHER
33A9			  ; 5-BYTE FLOATING POINT NUMBER TO BE ADDED TO THE CALCULATOR STACK.
33A9 D5 		  CH_5CMEM:	PUSH  DE		      ; SAVE DE BRIEFLY
33AA E5 				PUSH  HL		      ; SAVE HL BRIEFLY
33AB 010500				LD    BC,5		      ; SPECIFY THE TEST IN FOR 5 BYTES
33AE CD051F				CALL  TEST_ROOM 	      ; MAKE THE TEST
33B1 E1 				POP   HL		      ; RESTORE HL
33B2 D1 				POP   DE		      ; RESTORE DE
33B3 C9 				RET			      ; FINISHED
33B4			  ; THE "STACK NUMBER" SUBROUTINE
33B4			  ; THIS SUBROUTINE IS CALLED BY BEEP AND BY SCANNING TWICE TO COPY STKEND TO DE,
33B4			  ; MOVE A FLOATING-POINT NUMBER TO THE CALCULATOR STACK, AND RESET STKEND FROM
33B4			  ; DE. IT CALLS "MOVE_FP" TO DO THE ACTUAL MOVE.
33B4 ED5B655C		  STACK_NUM:	LD    DE,(STKEND)	      ; COPY STKEND TO DE AS DESTINATION ADDRESS
33B8 CDC033				CALL  MOVE_FP		      ; MOVE THE NUMBER
33BB ED53655C				LD    (STKEND),DE	      ; RESET STKEND FROM DE
33BF C9 				RET			      ; FINISHED
33C0			  ; THE "MOVE A FLOATING-POINT NUMBER" SUBROUTINE
33C0			  ; (OFFSET 31: "DUPLICATE")
33C0			  ; THIS SUBROUTINE MOVES A FLOATING-POINT NUMBER TO THE TOP OF THE CALCULATOR
33C0			  ; STACK (3 CASES) OR FROM THE TOP OF THE STACK TO THE CALCULATOR'S MEMORY AREA
33C0			  ; (1 CASE). IT IS ALSO CALLE THROUGHT THE CALCULATOR WHEN IT SYMPLY DUPLICATES
33C0			  ; THE NUMBER AT THE TOP OF THE CALCULATOR STACK, THE "LAST VALUE", THEREBY
33C0			  ; EXTENDING THE STACK BY FIVE BYTES.
33C0 CDA933		  MOVE_FP:	CALL  CH_5CMEM		      ; A TEST IS MADE FOR ROOM
33C3 EDB0				LDIR			      ; MOVE THE FIVE BYTES INVOLVED
33C5 C9 				RET			      ; FINISHED
33C6			  ; THE "STACK LITERALS" SUBROUTINE
33C6			  ; (OFFSET 34: "STK_DATA")
33C6			  ; THIS SUBROUTINE PLACES ON THE CALCULATOR STACK, AS A "LAST VALUE", THE
33C6			  ; FLOATING-POINT NUMBER SUPPLIED TO AS 2,3,4 OR 5 LITERALS.
33C6			  ;   WHEN CALLING BY USING OFFSET 34 THE LITERALS FOLLOW THE 34 IN THE LIST OF
33C6			  ; LITERALS; WHEN CALLED BY THE SERIES GENERATOR, SEE BELOW, THE LITERALS ARE
33C6			  ; SUPPLIED BY THE SUBROUTINE THAT CALLED FOR A SERIES TO BE GENERATED; AND WHEN
33C6			  ; CALLED BA SKIP CONSTANTS & STACK A CONSTANT THE LITERALS ARE OBTAINED FROM THE
33C6			  ; CALCULATOR'S TABLE OF CONSTANTS (32C5-32D6).
33C6			  ;   IN EACH CASE, THE FIRST LITERAL SUPPLED IS DIVIDED BY 40H, AND THE INTEGER
33C6			  ; QUOTIENT PLUS 1 DETERMINES WHETHER 1,2,3 OR 4 FURTHER LITERALS WILL BE TAKEN
33C6			  ; FROM THE SOURCE TO FORM THE MANTISSA OF THE NUMBER. ANY UNFILLED BYTES OF THE
33C6			  ; FIVE BYTES THAT GO TO FORM A 5-BYTE FLOATING POINT NUMBER ARE SET TO ZERO.
33C6			  ; THE FIRST LITERAL IS ALSO USED TO DETERMINE THE EXPONENT, AFTER REDUCING
33C6			  ; MOD 40H.  IN EITHER CASE 50H IS ADDED TO THE LITERAL, GIVING THE AUGMENTED
33C6			  ; EXPONENT BYTE, E ( THE TRUE EXPONENT'S PLUS 80H). THE REST OF THE 5 BYTES ARE
33C6			  ; STACKED, INCLUDING ANY ZEROES NEEDED, AND THE SUBROUTINE RETURNS
33C6 62 		  STK_DATA:	LD    H,D		      ; THIS SUBROUTINE PERFORM THE MANIPULATORY
33C7 6B				LD    L,E		      ; OPERATION OF ADDING A "LAST VALUE" TO THE
33C8					;			      ; CALCULATOR STACK; HENCE HL IS SET TO POINT
33C8					;			      ; ONE-PAST THE PRESENT "LAST VALUE" AND
33C8					;			      ; HENCE POINT TO THE RESULT.
33C8 CDA933		  STK_CONST:	CALL  CH_5CMEM		      ; NOW TEST THAT THERE IS NEEDED ROOM
33CB D9				EXX			      ; GO TO THE ALTERNATE REGISTER SET
33CC E5 				PUSH  HL		      ; AND STACK THE POINTER TO THE
33CD D9 				EXX			      ; NEXT LITERAL
33CE E3 				EX    (SP),HL		      ; SWITCH OVER THE RESULT POINTER
33CF					;			      ; AND THE NEXT LITERAL POINTER
33CF C5 				PUSH  BC		      ; SAVE BC BRIEFLY
33D0 7E 				LD    A,(HL)		      ; THE FIRST LITERAL IS PUT INTO A
33D1 E6C0				AND   0C0H		      ; AND DIVIDED BY 40H TO GIVE
33D3 07 				RLCA			      ; THE INTEGER VALUES 0,1,2 OR 3
33D4 07 				RLCA
33D5 4F 				LD    C,A		      ; THE INTEGER VALUE IS TRASFERED
33D6 0C 				INC   C 		      ; TO C AND INCREMENTED, THEREBY GIVING THE
33D7					;			      ; RANGE 1,2,3 OR 4 FOR THE NUMBER OF
33D7					;			      ; LITERALS THAT WILL BE NEEDED
33D7 7E 				LD    A,(HL)		      ; THE LITERAL IS FETCH ANEW
33D8 E63F				AND   03FH		      ; REDUCED MOD 40H AND
33DA 2002				JR    NZ,FROM_EXP	      ; DISCARDED AS INAPPROPRIATE IF THE
33DC 23 				INC   HL		      ; REMAINDER IS ZERO, IN WHICH CASE
33DD 7E 				LD    A,(HL)		      ; THE NEXT LITERAL IS FETCHED AND USED
33DE					;			      ; UNREDUCED
33DE C650		  FROM_EXP:	ADD   A,050H		      ; THE EXPONENT E IS FORMED BY THE ADDITION
33E0 12 				LD    (DE),A		      ; OF 50H AND PASSED TO THE CALCULATOR STACK
33E1					;			      ; AS THE FIRST OF THE FIVE BYTES OF THE
33E1					;			      ; RESULT
33E1 3E05				LD    A,5		      ; THE NUMBER OF LITERALS SPECIFIED
33E3 91 				SUB   C 		      ; IN C ARE TAKEN FROM THE SOURCE
33E4 23 				INC   HL		      ; AND ENTERED INTO THE BYTES
33E5 13 				INC   DE		      ; OF THE RESULT
33E6 0600				LD    B,0
33E8 EDB0				LDIR
33EA C1 				POP   BC		      ; RESTORE BC
33EB E3 				EX    (SP),HL		      ; RETURN THE RESULT POINTER TO HL
33EC D9 				EXX			      ; AND THE NEXT LITERAL POINTER TO
33ED E1 				POP   HL		      ; ITS USIAL POSITION IN H'L'
33EE D9 				EXX
33EF 47 				LD    B,A		      ; THE NUMBER OF ZERO BYTES
33F0 AF 				XOR   A 		      ; REQUIRED AT THIS STAGE IS GIVEN BY
33F1 05 		  STK_ZEROS:	DEC   B 		      ; 5_C_1; AND THIS NUMBER OF ZEROES
33F2 C8 				RET   Z 		      ; IS ADDED TO THE RESULT TO MAKE
33F3 12 				LD    (DE),A		      ; UP THE REQUIRED FIVE BYTES.
33F4 13 				INC   DE
33F5 18FA				JR    STK_ZEROS
33F7			  ; THE "SKIP CONSTANT" SUBROUTINE
33F7			  ; THIS SUBROUTINE IS ENTERED WITH THE HL REGISTER PAIR HOLDING THE BASE ADDRESS
33F7			  ; OF THE CALCULATOR'S TABLE OF CONSTANTS AND THE A REGISTER HOLDING A PARAMETER
33F7			  ; THAT SHOWS WHICH OF THE FIVE CONSTANTS IS BEING REQUESTED.
33F7			  ;   THE SUBROUTINE PERFORMS THE NULL OPERATIONS OF LOADING THE FIVE BYTES OF
33F7			  ; EACH UNWANTED CONSTANT INTO THE LOCATIONS 0000, 0001, 0002, 0003 AND 0004 AT
33F7			  ; THE BEGINING OF THE ROM UNTIL THE REQUESTED CONSTANT IS REACHED.
33F7			  ;   THE SUBROUTINE RETURNS WITH HL REGISTER PAIR HOLDING THE BASE ADDRESS OF THE
33F7			  ;  REQUESTED CONSTANT WITHIN THE TABLE OF CONSTANTS.
33F7 A7 		  SKIP_CONST:	AND   A 		      ; THE SUBROUTINE RETURNS IF THE PARAMETER IS
33F8 C8 		  SKIP_NEXT:	RET   Z 		      ; IS ZERO, OR WHEN THE REQUESTED CONSTANT
33F9					;			      ; HAS BEEN REACHED
33F9 F5 				PUSH  AF		      ; SAVE THE PARAMETER
33FA D5 				PUSH  DE		      ; SAVE THE RESULT POINTER
33FB 110000				LD    DE,0		      ; THE DUMMY ADDRESS
33FE CDC833				CALL  STK_CONST 	      ; PERFORM IMAGINARY STACKING OF AN
3401					;			      ; EXPANDED CONSTANT
3401 D1 				POP   DE		      ; RESTORE THE RESULT POINTER
3402 F1 				POP   AF		      ; RESTORE THE PARAMETER
3403 3D 				DEC   A 		      ; COUNT THE LOOPS
3404 18F2				JR    SKIP_NEXT 	      ; JUMP BACK TO CONSIDER THE VALUE
3406					;			      ; OF THE COUNTER
3406			  ; THE "MEMORY LOCATION" SUBROUTINE
3406			  ; THIS SUBROUTINE FINDS THE BASE ADDRESS FOR EACH FIVE BYTE PORTION OF THE
3406			  ; CALCULATOR'S MEMORY AREATO OR FROM WHICH A FLOATING-POINT NUMBER IS TO BE
3406			  ; MOVED FROM OR TO  THE CALCULATOR STACK. IT DOES THIS OPERATION BY ADDING FIVE
3406			  ; TIMES THE PARAMETER SUPPLIED TO THE BASE ADDRESS FOR THE AREA WHICH IS HELD
3406			  ; IN THE HL REGISTER PAIR.
3406			  ;   NOTE THAT WHEN A FOR-NEXT VARIABLE IS BEING HANDLED THEN THE POINTERS ARE
3406			  ; CHANGED SO THAT THE VARIABLE IS TREATED AS IF IT WERE THE CALCULATOR'S MEMORY
3406			  ; AREA (SEE ADDRESS 1D20).
3406 4F 		  LOC_MEM:	LD    C,A		      ; COPY THE PARAMETER TO C
3407 07 				RLCA			      ; DOUBLE THE PARAMETER
3408 07 				RLCA			      ; DOUBLE THE RESULT
3409 81 				ADD   A,C		      ; ADD THE VALUE OF PARAMETER
340A					;			      ; TO GIVE FIVE TIMES THE ORIGINAL VALUE
340A 4F 				LD    C,A		      ; THIS RESULT IS WANTED IN THE
340B 0600				LD    B,0		      ; BC REGISTER PAIR
340D 09 				ADD   HL,BC		      ; PRODUCE THE NEW BASE ADDRESS
340E C9 				RET			      ; FINISHED
340F			 ; THE "GET FROM MEMORY AREA" SUBROUTINE
340F			  ; (OFFSET E0 TO E5: "GET_MEM0 TO GET_MEM5")
340F			  ; THIS SUBROUTINE IS CALLED USING THE LITERALS E0 TO E5 AND THE PARAMETER
340F			  ; DERIVED FROM THESE LITERALS IS HELD IN THE A REGISTER. THE SUBROUTINE CALLS
340F			  ; MEMORY LOCATION TO PUT THE REQUIRED SOURCE ADDRESS INTO HL REGISTER PAIR AND
340F			  ; MOVE A FLOATING POINT NUMBER TO COPY THE FIVE BYTES INVOLVED FROM THE
340F			  ; CALCULATOR'S MEMORY AREA TO THE TOP OF THE CALCULATOR STACK TO FORM A NEW
340F			  ; "LAST VALUE".
340F D5 		  GET_MEM_0:	PUSH  DE		      ; SAVE THE RESULTPOINTER
3410 2A685C				LD    HL,(MEM)		      ; FETCH THE POINTER TO THE CURRENT
3413					;			      ; MEMORY AREA (SEE ABOVE)
3413 CD0634				CALL  LOC_MEM		      ; THE BASE ADDRESS IS FOUND
3416 CDC033				CALL  MOVE_FP		      ; THE FIVE BYTES ARE MOVED
3419 E1 				POP   HL		      ; SET THE RESULT POINTER
341A C9 				RET			      ; FINISHED
341B			  ; THE "STACK A CONSTANT" SUBROUTINE
341B			  ; OFFSETS A0 TO A4: "STK_XZERO", "STK_ONE", "STK_HALF", "STK_PI_2" & "STK_TEN")
341B			  ; THIS SUBROUTINE USES SKIP CONSTANTS TO FIND THE BASE ADDRESS OF THE REQUISTED
341B			  ; CONSTANTS FROM THE CALCULATOR'S TABLE OF CONSTANTS AND THEN CALLS
341B			  ; STACK LITERALS, ENTERING A STK_CONST, TO MAKE THE EXPANDED FORM OF THE
341B			  ; CONSTANT THE "LAST VALUE" ON THE CALCULATOR STACK.
341B 62 		  STK_ZERO:	LD    H,D		      ; SET HL TO HOLD THE RESULT POINTER
341C 6B 				LD    L,E
341D D9 				EXX			      ; GO TO THE ALTERNATE REGISTER SET
341E E5 				PUSH  HL		      ; AND SAVE THE NEXT LITERAL POINTER
341F 21C532				LD    HL,STK_XZERO	      ; THE BASE ADDRESS OF THE CALCULATOR'S
3422					;			      ; TABLE OF CONSTANT
3422 D9 				EXX			      ; BACK TO THE MAIN SET OF REGISTERS
3423 CDF733				CALL  SKIP_CONST	      ; FIND THE REQUESTED BASE ADDRESS
3426 CDC833				CALL  STK_CONST 	      ; EXPAND THE CONSTANT
3429 D9 				EXX
342A E1 				POP   HL		      ; RESTORE THE NEXT LITERAL POINTER
342B D9 				EXX
342C C9 				ET			      ; FINISHED
342D			  ; THE "STORE IN MEMORY AREA" SUBROUTINE
342D			  ; (OFFSETS C0 TO C5: "ST_MEM0 TO ST_MEM5")
342D			  ; THIS SUBROUTINE IS CALLED USING THE LITERALS C0 TO C5 AND THE PARAMETER
342D			  ; DERIVED FROM THESE LITERALS IS HELD IN THE A REGISTER. THIS SUBROUTINE IS VERY
342D			  ; SIMILAR TO THE GET FROM MEMORY SUBROUTINE BUT THE SOURCE AND THE DESTINATION
342D			  ; POINTERS ARE EXCHANGED.
342D E5 		  STK_MEM_0:	PUSH  HL		      ; SAVE THE RESULT POINTER
342E EB 				EX    DE,HL		      ; SOURCE TO DE BRIEFLLY
342F 2A685C				LD    HL,(MEM)		      ; FETCH THE POINTER TO THE CURRENT MEMORY
3432					;			      ; AREA
3432 CD0634				CALL  LOC_MEM		      ; THE BASE ADDRESS IS FOUND
3435 EB 				EX    DE,HL		      ; EXCHANGE SOURCE AND DESTINATION POINTERS
3436 CDC033				CALL  MOVE_FP		      ; THE FIVE BYTES ARE MOVED
3439 EB 				EX    DE,HL		      ; "LAST VALUE" + 5, I.E. STKEND, TO DE
343A E1 				POP   HL		      ; RESULT POINTER TO HL
343B C9 				RET			      ; FINISHED
343C			  ; NOTE THAT THE POINTERS HL AND DE REMAINS AS THEY WERE, POINTING TO STKEND-5
343C			  ; AND STKEND RESPCTIVELY, SO THAT THE "LAST VALUE" REMAINS ON THE CALCULATOR
343C			  ; STACK. IF REQUIRED IT CAN BE REMOVED BY USING "DELETE".
343C			  ;
343C			  ; THE "EXCHANGE" SUBROUTINE
343C			  ; (OFFSET 01: "EXCHANGE")
343C			  ; THIS BINARY OPERATION "EXCHANGES" THE FIRST NUMBER WITH THE SECOND NUMBER,
343C			  ; I.E. THE TOP MOST TWO NUMBERS ON THE CALCULATOR STACK ARE EXCHANGED.
343C 0605		  EXCHANGE:	LD    B,5		      ; THERE ARE FIVE BYTES INVOLVED
343E 1A 		  SWAP_BYTE:	LD    A,(DE)		      ; EACH BYTE OF THE SECOND NUMBER
343F 4E 				LD    C,(HL)		      ; EACH BYTE OF THE FIRST NUMBER
3440 EB 				EX    DE,HL		      ; SWITCH SOURCE AND DESTINATION
3441 12 				LD    (DE),A		      ; NOW TO THE FIRST NUMBER
3442 71 				LD    (HL),C		      ; NOW TO THE SECOND NUMBER
3443 23 				INC   HL		      ; MOVE TO CONSIDER THE NEXT
3444 13 				INC   DE		      ; PAIR OF BYTES
3445 10F7				DJNZ  SWAP_BYTE 	      ; EXCHANGE THE FIVE BYTES
3447 EB 				EX    DE,HL		      ; GET THE POINTER CORRECT AS THE
3448					;			      ; NUMBER 5 IS AN ODD NUMBER
3448 C9 				RET			      ; FINISHED
3449			  ;
3449			  ; THE "SERIES GENERATOR" SUBROUTINE
3449			  ; (OFFSET 86,88 & 8C: "SERIES_06", SERIES_08" & "SERIES_0C")
3449			  ; THIS IMPORTANT SUBROUTINE GENERATES THE SERIES OF CHEBYSHEV POLYNOMIALS WHICH
3449			  ; ARE USED TO APPROXIMATE TO SIN, ATN, LN AND EXP AND HENCE TO DERIVE THE OTHER
3449			  ; ARITHMETIC FUNCTIONS WHICH DEPEND ON THESE (COS,TAN,ASN,ACS,** AND SQR).
3449			  ;   THE POLYNOMIALS AREGENERATED, FOR N=1,2,..., BY THE RECURRENCE RELATION:
3449			  ;	  TN+1(Z)=2*Z*TN(Z)-TN-1(Z), WHERE TN(Z) IS THE NTH CHEBYSHEV POLYNOMIAL
3449			  ;   IN Z.
3449			  ;   THE SERIES IN FACT GENERATES:
3449			  ;	  T0,2T1,2T2,...,2TN-1, WHERE N IS 6 FOR SIN, 8 FOR EXP AND 12D, FOR LN
3449			  ;   AND ATN.
3449			  ;   THE COEFFICIENTS OF THE POWERS OF Z IN THESE POLYNOMIALS MAY BE FOUND IN
3449			  ; THE HANDBOOK OF MATHEATICAL FUNCTIONS BY M.ABRAMOWITZ AND I.A. STEGUN
3449			  ; (DOVER 1965), PAGE 795.
3449			  ;   BASIC PROGRAMS SHOWING THE GENERATION OF EACH OF THE FOUR FUNCTIONS ARE
3449			  ; GIVEN HERE IN THE APPENDIX.
3449			  ;   IN SIMPLE TERMS THIIS SUBROUTINE IS CALLED WITH THE "LAST VALUE" ON THE
3449			  ; CALCULATOR STACK, SAY Z, BEING A NUMBER THAT BEARS A SIMPLE RELATIONSHIP TO
3449			  ; THE ARGUMENT, SAY X, WHEN THE TASK IS TO EVALUATE, FOR INSTANCE, SIN(X).
3449			  ; THE CALLING SUBROUTINE ALSO SUPPLIES THE LIST OF CONSTANTS THAT ARE TO BE
3449			  ; REQUIRED (SIX CONSTANTS FOR SIN). THE SERIES GENERATOR THEN MANIPULATES ITS
3449			  ; DATA AND RETURNS TO THE CALLING ROUTINE A "LAST VALUE" THAT BEARS A SIMPLE
3449			  ; RELATIONSHIP TO THE REQUESTED FUNCTION, FOR INSTANCE, SIN(X).
3449			  ;   THIS SUBROUTINE CAN BE CONSIDERED TO HAVE FOUR MAJOR PARTS.
3449			  ;   I.  THE SETTING OF THE LOOP COUNTER:
3449			  ;	  THE CALLING SUBROUTINE PASSES ITS PARAMETERS IN THE A REGISTER FOR USE
3449			  ;	  AS A COUNTER. THE CALCULATOR IS ENTERED AT GEN_ENT_1 SO, THAT THE
3449			  ;	  COUNTER CAN BE SET.
3449 47 		  SERIES_06:	LD    B,A		      ; MOVE THE PARAMETER TO B
344A CD5E33				CALL  GEN_ENT_1 	      ; IN EFFECT A RST 028H INSTRUCTION BUT
344D					;			      ; SETS THE COUNTER
344D			  ;  II.  THE HANDLING OF THE "LAST VALUE", Z:
344D			  ;	  THE LOOP OF THE GENERATOR REQUIRES 2*Z TO BE PLACED IN MEM_0, ZERO TO BE
344D			  ;	  PLACED IN MEM_2 AND THE "LAST VALUE" TO BE ZERO.
344D			  ;				  CALCULATOR STACK
344D 31 				DEFB  31H		      ; DUPLICATE:    Z,Z
344E 0F 				DEFB  0FH		      ; ADDITION:     2*Z
344F C0 				DEFB  0C0H		      ; ST_MEM0:      2*Z	      MEM_0 HOLDS 2*Z
3450 02 				DEFB  02H		      ; DELETE:       -
3451 A0 				DEFB  0A0H		      ; STK_ZERO:     0
3452 C2 				DEFB  0C2H		      ; ST_MEM2:      0 	      MEM_2 HOLDS 0
3453			  ; III.  THE MAIN LOOP:
3453			  ; THE SERIES IS GENERATED BY LOOPING, USING BREG AS A COUNTER; THE CONSTANTS IN
3453			  ; THE CALLING SUBROUTINE ARE STACKED IN TURN BY CALLING STK_DATA; THE CALCULATOR
3453			  ; IS REENTERED AT GET_ENT_2 SO AS NOT TO DISTURB THE VALUE OF BREG; AND THE
3453			  ; SERIES IS BUILT UP IN THE FORM:
3453			  ;	  B(R)=2*Z*B(R-1)-B(R-2)+A(R), FOR R=1,2,...,N, WHERE A(1), A(2),..., A(N)
3453			  ;	  ARE THE CONSTANTS SUPPLIED BY THE CALLING SUBROUTINE (SIN,ATN,LN AND
3453			  ;	  EXP) AND B(0) = 0 = B(-1).
3453			  ;   THE (R+1)TH LOOP STARTS WITH B(R) ON THE STACK AND WITH 2*Z, B(R-2) AND
3453			  ; B(R-1) IN MEM_0, MEM_1 AND MEM_2 RESPECTIVELY.
3453 31 		  G_LOOP:	DEFB  31H		      ; DUPLICATE:    B(R),B(R)
3454 E0 				DEFB  0E0H		      ; GET_MEM_0:    B(R),B(R),2*Z
3455 04 				DEFB  04H		      ; MULTIPLY:     B(R),2*B(R)*Z
3456 E2 				DEFB  0E2H		      ; GET_MEM_2:    B(R),2*B(R)*Z,B(R-1)
3457 C1 				DEFB  0C1H		      ; ST_MEM_1:     B(R),2*B(R)*Z,B(R-1) MEM_1 HOLDS B(R-1)
3458 03 				DEFB  003H		      ; SUBTRACT:     B(R),2*B(R)*Z-B(R-1)
3459 38 				DEFB  038H		      ; END_CALC
345A			  ; THE NEXT CONSTANT IS PLACED ON THE CALCULATOR STACK
345A CDC633				CALL  STK_DATA		      ; 	      B(R),2*B(R)*ZZ-B(R-1),A(R+1)
345D			  ; THE CALCULATOR IS RE-ENTERED WITHOUT DISTURBING BREG.
345D CD6233				CALL  GEN_ENT_2
3460 0F 				DEFB  0FH		      ; ADDITION:     B(R),2*B(R)*Z-B(R-1)+A(R+1)
3461 01 				DEFB  01H		      ; EXCHANGE:     2*B(R)*Z-B(R-1)+A(R+1),B(R)
3462 C2 				DEFB  0C2H		      ; ST_MEM_2:     MEM_2 HOLDS B(R)
3463 02 				DEFB  02H		      ; DELETE:       2*B(R)*Z-B(R-1)+A(R+1) = B(R+1)
3464 35 				DEFB  35H		      ; DEC_JR_NZ     B(R+1)
3465 EE 				DEFB  G_LOOP-$		      ; TO 3453, GLOOP
3466			  ;  IV.  THE SUBTRACTION OF B(N-2):
3466			  ;	  THE LOOP ABOVE LEEVES B(N) ON THE STACK AND THE REQUIRED RESULT IS GIVEN BY B(N),
3466			  ;	  B(N-2).
3466 E1 				DEFB  0E1H		      ; GET_MEM_1:    B(N),B(N-2)
3467 03 				DEFB  03H		      ; SUBTRACT:     B(N)-B(N-2)
3468 38 				DEFB  38H		      ; END_CALC
3469 C9 				RET			      ; FINISED
346A			  ; THE "ABSOLUTE MAGNITUDE" FUNCTION
346A			  ; (OFFSET 2A: "ABS")
346A			  ; THIS SUBROUTINE PREFORMS ITS UNARY OPERATION BY ENSURING THAT THE SIGN BIT OF
346A			  ; A FLOATING-POINT NUMBER IS RESET.
346A			  ;   "SMALL INTEGERS"HAVE TO BE TREATED SEPARATLY. MOST OF THE WORK IS SHARED
346A			  ; WITH THE "UNARY MINUS" OPERATION.
346A 06FF		  ABS:		LD    B,-1		      ; B IS SET TO 0FFH
346C 1806				JR    NEG_TEST		      ; THE JUMP IS MADE INTO "UNARY MINUS"
346E			  ; THE "UNARY MINUS" OPERATION
346E			  ; (OFFSET 1B: "NEGATE")
346E			  ; THIS SUBROUTINE PERFORMS ITS UNARY OPERATION BY CHANGING THE SIGN OF THE
346E			  ; "LAST VALUE" ON THE CALCULATOR STACK.
346E			  ;   ZERO IS SIMPLY RETURNED UNCHANGED. FULL FIVE BYTE FLOATING-POINT NUMBERS
346E			  ; HAVE THEIR SIGN BIT MANIPULATED SO THAT IT ENDS UP RESET (FOR "ABS") OR
346E			  ; CHANGED (FOR "NEGATE"). "SMALL INTEGERS" HAVE THEIR SIGN BYTE SET TO ZERO (FOR
346E			  ; "ABS" OR CHANGED (FOR "NEGATE").
346E CDE934		  NEGATE:	CALL  TEST_ZERO 	      ; IF THE NUMBER IS ZERO, THE SUBROUTINE
3471 D8 				RET   C 		      ; RETURNS LEAVING 00 00 00 00 00 UNCHANGED.
3472 0600				LD    B,0		      ; B IS SET TO 00H FOR "NEGATE"
3474			  ; "ABS" ENTERS HERE.
3474 7E 		  NEG_TEST:	LD    A,(HL)		      ; IF THE FIRST BYTE IS ZERO, THE
3475 A7 				AND   A 		      ; JUMP IS MADE TO DEAL WITH A
3476 280B				JR    Z,INT_CASE	      ; "SMALL INTEGER"
3478 23 				INC   HL		      ; POINT TO THE SECOND BYTE
3479 78 				LD    A,B		      ; GET FF FOR "ABS", 00 FOR "NEGATE"
347A E680				AND   80H		      ; NOW 80 FOR "ABS", 00 FOR "NEGATE"
347C B6 				OR    (HL)		      ; THIS SETS BIT 7 FOR "ABS" BUT CHANGES
347D					;			      ; NOTHING FOR "NEGATE"
347D 17 				RLA			      ; NOW BIT 7 IS CHANGED, LEADING TO
347E 3F 				CCF			      ; BIT 7 OF BYTE 2 RESET FOR "ABS"
347F 1F 				RRA			      ; AND SIMPLY CHANGED FOR "NEGATE"
3480 77 				LD    (HL),A		      ; THE NEW SECOND BYTE IS STORED
3481 2B 				DEC   HL		      ; HL POINTS TO THE FIRST BYTE AGAIN
3482 C9 				RET			      ; FINISHED
3483			  ; THE "INTEGER CASE" DOES A SIMILAR OPERATION WITH THE SIGN BYTE.
3483 D5 		  INT_CASE:	PUSH  DE		      ; SAVE STKEND IN DE
3484 E5 				PUSH  HL		      ; SAVE POINTER TO THE NUMBER IN HL
3485 CD7F2D				CALL  INT_FETCH 	      ; FETCH THE SIGN IN C, THE NUMBER IN DE
3488 E1 				POP   HL		      ; RESTORE THE POINTER TO THE NUMBER IN HL
3489 78 				LD    A,B		      ; GET FF FOR "ABS", 00 FOR "NEGATE"
348A B1 				OR    C 		      ; NOW FF FOR "ABS", NO CHANGE FOR "NEGATE"
348B 2F 				CPL			      ; NOW 00 FOR "ABS", AND A CHANGED BYTE
348C 4F 				LD    C,A		      ; FOR "NEGATE": STORE IT IN C
348D CD8E2D				CALL  INT_STORE 	      ; STORE RESULT ON THE STACK
3490 D1 				POP   DE		      ; RETURN STKEND TO DE
3491 C9 				RET			      ; FINISHED
3492			  ; THE "SIGNUM" FUNCTION
3492			  ; (OFFSET 29: "SGN")
3492			  ; THIS SUBROUTINE HANDLES THE FUNCTION SGN(X) AND THEREFORE RETURNS A
3492			  ; "LAST VALUE" OF 1 IF X IS POSITIVE, ZERO IF X IS ZERO AND -1 IF X IS NEGATIVE.
3492 CDE934		  SGN:		CALL  TEST_ZERO 	      ; IF X IS ZERO, JUST RETURN WITH
3495 D8 				RET   C 		      ; ZERO AS THE "LAST VALUE"
3496 D5 				PUSH  DE		      ; SAVE THE POINTER TO STKEND
3497 110100				LD    DE,001H		      ; STORE 1 IN DE
349A 23 				INC   HL		      ; POINT TO THE SECOND BYTE OF X
349B CB16				RL    (HL)		      ; ROTATE BIT 7 INTO THE CARRY FLAG
349D 2B 				DEC   HL		      ; POINT TO THE DESTINATION AGAIN
349E 9F 				SBC   A,A		      ; SET C TO ZERO FOR POSITIVE X AND
349F 4F 				LD    C,A		      ; TO FF FOR NEGATIVE X.
34A0 CD8E2D				CALL  INT_STORE 	      ; STACK 1 OR -7 AS REQUIRED
34A3 D1 				POP   DE		      ; RESTORE THE POINTER TO STKEND
34A4 C9 				RET			      ; FINISHED
34A5			  ;
34A5			  ; THE "IN" FUNCTION
34A5			  ; OFFSET 2C: "IN")
34A5			  ; THIS SUBROUTINE HANDLES THE FUNCTION IN X. IT INPUTS AT PROCESSOR LEVEL FROM
34A5			  ; PORT X, LOADING BC WITH X AND PERFORMING THE INSTRUCTION IN A,(C).
34A5 CD991E		  IN:		CALL  FIND_INT2 	      ; THE "LAST VALUE", X IS COMPRESSED INTO BC
34A8 ED78				IN    A,(C)		      ; THE SIGNAL IS RECEIVED
34AA 1804				JR    IN_PK_STK 	      ; JUMP TO STACK THE RESULT
34AC			  ;
34AC			  ; THE "PEEK" FUNCTION
34AC			  ; (OFFSET 28: "PEEK")
34AC			  ; THIS SUBROUTINE HANDLES THE FUNCTION PEEK X. THE "LAST VALUE" IS UNSTACKED BY
34AC			  ; CALLING FIND_INT2 AND REPLACED BY THE VALUE OF THE CONTENTS OF THE REQUIRED
34AC			  ; LOCATION.
34AC CD991E		  PEEK: 	CALL  FIND_INT2 	      ; EVALUATE THE "LATS VALUE" ROUNDED TO THE
34AF					;			      ; NEAREST INTEGER, TEST THAT IT IS IN RANGE
34AF					;			      ; AND RETURN IT IN BC
34AF 0A 				LD    A,(BC)		      ; FETCH THE REQUIRED BYTE
34B0 C3282D		  IN_PK_STK:	JP    STACK_A		      ; EXIT BY JUMPING TO STACK_A
34B3			  ;
34B3			  ; THE "USR" FUNCTION
34B3			  ; (OFFSET 2D: "USR_NO")
34B3			  ; THIS SUBROUTINE ("USR NUMBER" AS DISTINCT FROM THE "USR STRING" HANDLES THE
34B3			  ; FUNCTION USR X, WHERE X IS A NUMBER. THE VALUE OF X IS OBTAINED IN BC, A
34B3			  ; RETURN ADDRESS IS STACKED AND THE MACHINE CODE IS EXECUTED FROM LOCATION X.
34B3 CD991E		  USER_NO:	CALL  FIND_INT2 	      ; EVALUATE THE "LAST VALUE", ROUNDED TO THE
34B6					;			      ; NEAREST INTEGER; TEST THAT IT IS IN RANGE
34B6					;			      ; AND RETURN IT IN BC
34B6 212B2D				LD    HL,STACK_BC	      ; MAKE THE RETURN ADDRESS BE THAT OF THE
34B9 E5 				PUSH  HL		      ; SUBROUTINE STACK_BC
34BA C5 				PUSH  BC		      ; MOVE AN INDIRECT JUMP TO THE
34BB C9 				RET			      ; REQUIRED LOCATION
34BC			  ; !!!???!!!
34BC			  ; NOTE: IT IS INTERESTING THAT THE IY REGISTER PAIR IS RE-INITIALISED WHEN THE
34BC			  ; RETURN TO STACK_BC HAS BEEN MADE, BUT THE IMPORTANT H'L' THAT HOLDS THE NEXT
34BC			  ; LITERAL POINTER IS NOT RESTORED SHOULD IT HAVE BEEN DISTURBED. FOR A
34BC			  ; SUCCESSFUL RETURN TO BASIC, H'L' MUST ON EXIT FROM THE MACHINE CODE CONTAIN
34BC			  ; THE ADDRESS IN SCANNING OF THE "END_CALC" INSTRUCTION, 2758H (10072D).
34BC			  ;
34BC			  ; THE "USR STRING" FUNCTION
34BC			  ; (OFFSET 19: "USR_DOLL")
34BC			  ; THIS SUBROUTINE HANDLES THE FUNCTION USR X$, WHERE X$ IS A STRING. THE
34BC			  ; SUBROUTINE RETURNS IN BC THE ADDRESS OF THE BIT PATTERN FOR THE USER DEFINED
34BC			  ; GRAPHIC CORRESPONDING TO X$. IT REPORTS ERROR A IF X$ IS NOT A SINGLE LETTER
34BC			  ; BETWEEN "A" AND "U" OR A USER DEFINED GRAPHIC.
34BC CDF12B		  USR_DOLL:	CALL  STK_FETCH 	      ; FETCH THE PARAMETERS OF THE STRING X$
34BF 0B 				DEC   BC		      ; DECREASE THE LENGTH BY 1 TO TEST IT
34C0 78 				LD    A,B		      ; IF THE LENGTH WAS NOT 1,
34C1 B1 				OR    C 		      ; THEN
34C2 2023				JR    NZ,REPORT_A	      ; JUMP TO GIVE ERROR REPORT A.
34C4 1A 				LD    A,(DE)		      ; FETCH THE SINGLE CODE OF THE STRING
34C5 CD8D2C				CALL  ALPHA		      ; DOES IT DENOTE A LETTER?
34C8 3809				JR    C,USR_RANGE	      ; IF SO, JUMP TO GETS ITS ADDRESS
34CA D690				SUB   090H		      ; REDUCE RANGE FOR ACTUAL USER-DEFINED
34CC					;			      ; GRAPHICS TO 00-20 DECIMAL
34CC 3819				JR    C,REPORT_A	      ; GIVE REPORT A IF OUT OF RANGE
34CE FE15				CP    015H		      ; TEST THE RANGE AGAIN
34D0 3015				JR    NC,REPORT_A	      ; GIVE REPORT A IF OUT OF RANGE
34D2 3C 				INC   A 		      ; MAKE RANGE OF USER-DEFINED GRAPHICS
34D3					;			      ; 1-21 DECIMAL, AS FOR "A" TO "U"
34D3 3D 		  USR_RANGE:	DEC   A 		      ; NOW MAKE THE RANGE 0 TO 20 DECIMAL IN
34D4					;			      ; EACH CASE
34D4 87 				ADD   A,A		      ; MULTIPLY BY 8 TO GET AN OFFSET
34D5 87 				ADD   A,A		      ; FOR THE ADDRESS
34D6 87 				ADD   A,A
34D7 FEA8				CP    0A8H		      ; TEST THE RANGE OF THE OFFSET
34D9 300C				JR    NC,REPORT_A	      ; GIVE REPORT A IF OUT OF RANGE
34DB ED4B7B5C				LD    BC,(UDG)		      ; FETCH THE ADDRESS OF THE FIRST
34DF					;			      ; USER-DEFINED GRAPHIC IN BC
34DF 81 				ADD   A,C		      ; ADD C TO THE OFFSET
34E0 4F 				LD    C,A		      ; STORE THE RESULT BACK IN C
34E1 3001				JR    NC,USR_STACK	      ; JUMP IF TERE IS NO CARRY
34E3 04 				INC   B 		      ; INCREMENT B TO COMPLETE THE ADDRESS
34E4 C32B2D		  USR_STACK:	JP    STACK_BC		      ; JUMP TO STACK THE ADDRESS
34E7			  ;
34E7			  ; REPORT A - INVALID ARGUMENT
34E7 CF 		  REPORT_A:	RST   ERROR_1		      ; CALL THE ERROR HANLING
34E8 09 				DEFB 009H		      ; ROUTINE
34E9			  ;
34E9			  ; THE "TEST_ZERO" SUBROUTINE
34E9			  ; THIS SUBROUTINE IS CALLED AT LEASTNINE TIMES TO TEST WHETHER A FLOATING-POINT
34E9			  ; NUMBER IS ZERO. THIS TEST REQUIRES THAT THE FIRST FOUR BYTES OF THE NUMBER
34E9			  ; SHOULD EACH BE ZERO. THE SUBROUTINE RETURNS WITH THE CARRY FLAG SET IF THE
34E9			  ; NUMBER WAS IN FACT ZERO.
34E9 E5 		  TEST_ZERO:	PUSH  HL		      ; SAVE HL ON THE STACK
34EA C5 				PUSH  BC		      ; SAVE BC ON THE STACK
34EB 47 				LD    B,A		      ; SAVE THE VALUE OF A IN B
34EC 7E 				LD    A,(HL)		      ; GET THE FIRST BYTE
34ED 23 				INC   HL		      ; POINT TO THE SECOND BYTE
34EE B6 				OR    (HL)		      ; OR FIRST BYTE WITHS ECOND
34EF 23 				INC   HL		      ; POINT TO THE THIRD BYTE
34F0 B6 				OR    (HL)		      ; OR THE RESULT WITH THE THIRD BYTE
34F1 23 				INC   HL		      ; POINT TO FOURTH BYTE
34F2 B6 				OR    (HL)		      ; OR THE RESULT WITH THE FOURTH BYTE
34F3 78 				LD    A,B		      ; RESTORE THE ORIGINAL VALUE OF A
34F4 C1 				POP   BC		      ; AND OF BC
34F5 E1 				POP   HL		      ; RESTORE THE POINTER TO THE NUMBER TO HL
34F6 C0 				RET   NZ		      ; RETURN WITH CARRY RESET IF ANY OF THE
34F7					;			      ; FOUR BYTES WAS NON-ZERO
34F7 37 				SCF			      ; SET THE CARRY FLAG TO INDICATE
34F8 C9 				RET			      ; THAT THE NUMBER WAS ZERO AND RETURN.
34F9			  ; THE "GREATER THAN ZERO" OPERATION
34F9			  ; (OFFSET 37: "GREATE_0")
34F9			  ; THIS SUBROUTINE RETURNS A "LAST VALUE" OF ONE IF THE PRESENT "LAST VALUE" IS
34F9			  ; GREATER THAN ZERO AND ZERO OTHERWISE. IT IS ALSO USED BY OTHER SUBROUTINES
34F9			  ; TO "JUMP ON PLUS"
34F9 CDE934		  GREATE_0:	CALL  TEST_ZERO 	      ; IS THE "LAST VALUE" ZERO?
34FC D8 				RET   C 		      ; IF SO RETURN
34FD 3EFF				LD    A,0FFH		      ; JUMP FORWARD TO LESS THAN ZERO
34FF 1806				JR    SIGN_TO_C 	      ; BUT SIGNAL THE OPPOSITE ACTION IS NEEDED.
3501			  ;
3501			  ; THE "NOT" FUNCTION
3501			  ; (OFFSET 30: "NOT")
3501			  ; THIS SUBROUTINE RETURNS A "LAST VALUE" OF ONE IF PRESENT "LAST VALUE" IS ZERO
3501			  ; AND ZERO OTHERWISE. IT IS ALSO USED BY OTHER SUBROUTINES TO "JUMP ON ZERO"
3501 CDE934		  NOT:		CALL  TEST_ZERO 	      ; THE CARRY FLAG WILL BE SET ONLY IF THE
3504					;			      ; LAST VALUE" IS ZERO; THIS GIVES THE
3504					;			      ; CORRECT RESULT.
3504 1805				JR    FP_0_1		      ; JUMP FORWARD
3506			  ;
3506			  ; THE "LESS THEN ZERO" OPERATION
3506			  ; (OFFSET 36: "LESS_0")
3506			  ; THIS SUBROUTINE RETURNS A "LAST VALUE" OF ONE IF THE PRESENT "LAST VALUE" IS
3506			  ; LESS THAN ZERO AND ZERO OTHERWISE. IT IS ALSO USED BY OTHER SUBROUTINES TO
3506			  ; "JUMP ON MINUS"
3506 AF 		  LESS_0:	XOR   A 		      ; CLEAR THE A REGISTER
3507 23 		  SIGN_TO_C:	INC   HL		      ; POINT TO THE SIGN BYTE
3508 AE 				XOR   (HL)		      ; THE CARRY IS RESET FOR A POSITIVE
3509 2B 				DEC   HL		      ; NUMBER AND SET FOR A NEGATIVE NUMBER;
350A 07 				RLCA			      ; WHEN ENTERED FROM GREATE_0 THE OPPOSITE
350B					;			      ; SIGN GOES TO THE CARRY.
350B			  ;
350B			  ; THE "ZERO OR ONE" SUBROUTINE
350B			  ; THIS SUBROUTINE SETS THE "LAST VALUE" TO ZERO, IF THE CARRY FLAG IS RESET AND
350B			  ; TO ONE IF IT IS SET. WHEN CALLED FROM "E_TO_FP" HOWEVER IT CREATES THE ZERO OR
350B			  ; ONE NOT ON THE STACK BUT IN MEM_0.
350B E5 		  FP_0_1:	PUSH  HL		      ; SAVE THE RESULT POINTER
350C 3E00				LD    A,0		      ; CLEAR A WITHOUT DISTURBING THE CARRY
350E 77 				LD    (HL),A		      ; SET THE FIRST BYTE TO ZERO
350F 23 				INC   HL		      ; POINT TO THE SECOND BYTE
3510 77 				LD    (HL),A		      ; SET THE SECOND BYTE TO ZERO
3511 23 				INC   HL		      ; POINT TO THE THIRD BYTE
3512 17 				RLA			      ; ROTATE THE CARRY INTO A, MAKING A ONE IF
3513					;			      ; THE CARRY WAS SET, BUT ZERO IF THE CARRY
3513					;			      ; WAS RESET
3513 77 				LD    (HL),A		      ; SET THE THIRD BYTE TO ONE OR ZERO
3514 1F 				RRA			      ; ENSURE THAT A IS ZERO AGAIN
3515 23 				INC   HL		      ; POINT TO THE FOURTH BYTE
3516 77 				LD    (HL),A		      ; SET THE FOURTH BYTE TO ZERO
3517 23 				INC   HL		      ; POINT TO THE FIFTH BYTE
3518 77 				LD    (HL),A		      ; SET THE FIFTH BYTE TO ZERO
3519 E1 				POP   HL		      ; RESTORE THE RESULT POINTER
351A C9 				RET			      ; FINISHED
351B			  ;
351B			  ; THE "OR" OPERATION
351B			  ; (OFFSET 07: "OR")
351B			  ; THIS SUBROUTINE PERFORMS THE BINARY OPERATION "X OR Y" AND RETURNS X IF Y IS
351B			  ; ZERO AND THE VALUE 1 OTHERWISE.
351B EB 		  OR:		EX    DE,HL		      ; POINT HL AT Y, THE SECOND NUMBER
351C CDE934				CALL  TEST_ZERO 	      ; TEST WHETHER Y IS ZERO
351F EB 				EX    DE,HL		      ; RESTORE THE POINTERS
3520 D8 				RET   C 		      ; RETURN IF Y WAS ZERO; X IS NOW THE
3521					;			      ; "LAST VALUE"
3521 37 				SCF			      ; SET THE CARRY FLAG AND JUMP BACK
3522 18E7				JR    FP_0_1		      ; TO SET THE "LAST VALUE" TO 1
3524			  ;
3524			  ; THE "NUMBER AND NUMBER" OPERATION
3524			  ; (OFFSET 08: "NO_AND_NO")
3524			  ; THIS SUBROUTINE PREFORMS THE BANARY OPERATION "X AND Y" AND RETURNS X IF Y
3524			  ; IS NON-ZERO AND THE VALUE ZERO OTHERWISE.
3524 EB 		  NO_AND_NO:	EX    DE,HL		      ; POINT HL AT Y, DE AT X
3525 CDE934				CALL  TEST_ZERO 	      ; TEST WHETER Y IS ZERO
3528 EB 				EX    DE,HL		      ; SWAP THE POINTERS BACK
3529 D0 				RET   NC		      ; RETURN WITH X AS "LAST VALUE" IF
352A					;			      ; Y WAS NON-ZERO
352A A7 				AND   A 		      ; RESET THE CARRY FLAG AND JUMP
352B 18DE				JR    FP_0_1		      ; BACK TO SET THE "LAST VALUE" TO ZERO
352D			  ;
352D			  ; THE "STRING AND NUMBER" OPERATION
352D			  ; (OFFSET 10: "STR_AND_NO")
352D			  ; THIS SUBROUTINE PERFORMS THE BINARY OPERATION "X$ AND Y" AND RETURNS X$ IF
352D			  ; Y IS NON ZERO AND A NULL STRING OTHERWISE.
352D EB 		  STR_AND_NO:	EX    DE,HL		      ; POINT HL AT Y, DE AT X$
352E CDE934				CALL  TEST_ZERO 	      ; TEST WHETHER Y IS ZERO
3531 EB 				EX    DE,HL		      ; SWAP THE POINTERS BACK
3532 D0 				RET   NC		      ; RETURN WITH X$ AS THE "LAST VALUE",
3533					;			      ; IF Y WAS NON-ZERO
3533 D5 				PUSH  DE		      ; SAVE THE POINTER TO THE NUMBER
3534 1B 				DEC   DE		      ; POINT TO THE FIFTH BYTE OF THE STRING
3535					;			      ; PARAMETERS I.E. LENGTH-HIGH
3535 AF 				XOR   A 		      ; CLEAR THE A REGISTER
3536 12 				LD    (DE),A		      ; LENGTH-HIGH IS NOW SET TO ZERO
3537 1B 				DEC   DE		      ; POINT TO LENGTH-LOW
3538 12 				LD    (DE),A		      ; LENGTH-LOW IS NOW SET TO ZERO
3539 D1 				POP   DE		      ; RESTORE THE POINTER
353A C9 				RET			      ; RETURN WITH THE STRING PARAMETERS
353B					;			      ; BEING THE "LAST VALUE"
353B			  ;
353B			  ; THE "COMAPRISON" OPERATION
353B			  ; (OFFSETS 09 TO 0E & 11 TO 16: "NO_GR_EQ", "POS_NEQL", "NO_GRTR", "NO_LESS",
353B			  ;				  "NOS_EQL", "STR_L_EQL", STR_GR_EQ", "STR_NEQL"
353B			  ;				  "STR_GRTR", "STR_LESS" & "STRS_EQL"
353B			  ; THIS SUBROUTINE IS USED TO PREFORM THE TWELVE POSSIBLE COMPARISON OPERATIONS.
353B			  ; THE SINGLE OPERATION OFFSET IS PRESENT IN THE B REGISTER AT THE START OF THE
353B			  ; SUBROUTINE.
353B 78 		  NO_EQL:	LD    A,B		      ; THE SINGLE OFFSET GOES TO THE A REGISTER
353C D608				SUB   008H		      ; THE RANGE IS NOW 01-06 & 09-0E
353E CB57				BIT  2,A		      ; THIS RANGE IS CHANGED TO
3540 2001				JR    NZ,EX_OR_NOT	      ; 00-02,04-06,08-0A &
3542 3D 				DEC   A 		      ; 0C-0E
3543 0F 		  EX_OR_NOT:	RRCA			      ; THEN REDUCED TO 00-07 WITH CARRY SET FOR
3544					;			      ; "GREATER THAN OR EQUALS TO" & "LESS THAN"
3544					;			      ; THE OPERATIONS WITH CARRY SET ARE
3544 3008				JR    NC,NU_OR_STR	      ; THEN TREATED AS THEIR
3546 F5 				PUSH  AF		      ; COMPLEMENTARY OPERATION ONCE
3547 E5 				PUSH  HL		      ; THE VALUE HAVE BEEN EXCHANGED
3548 CD3C34				CALL  EXCHANGE
354B D1 				POP   DE
354C EB 				EX    DE,HL
354D F1 				POP   AF
354E CB57		  NU_OR_STR:	BIT  2,A		      ; THE NUMERICAL COMPARISONS ARE NOW
3550 2007				JR    NZ,STRINGS	      ; SEPARATED FROM THE STRING COMPARISONS BY
3552					;			      ; TESTING BIT 2.
3552 0F 				RRCA			      ; THE NUMERICAL OPERATIONS NOW HAVE THE
3553					;			      ; RANGE 00-01 WITH CARRY SET FOR "EQUAL"
3553					;			      ; AND "NOT EQUAL"
3553 F5 				PUSH  AF		      ; SAVE THE OFFSET
3554 CD0F30				CALL  SUBTRACT		      ; THE NUMBERS ARE SUBTRACTED FOR
3557 1833				JR    END_TESTS 	      ; THE FINAL TEST
3559 0F 		  STRINGS:	RRCA			      ; THE STRING COMPARISON NOW HAVE THE RANGE
355A					;			      ; 02-03 WITH CARRY SET FOR "EQUAL" AND
355A					;			      ; "NOT EQUAL"
355A F5 				PUSH  AF		      ; SAVE THE OFFSET
355B CDF12B				CALL  STK_FETCH 	      ; THE LENGTH AND STARTING ADDRESS
355E D5 				PUSH  DE		      ; OF THE STRINGS ARE
355F C5 				PUSH  BC		      ; FETCHED FROM THE
3560 CDF12B				CALL  STK_FETCH 	      ; CALCULATOR STACK
3563 E1 				POP   HL		      ; THE LENGTH OF THE SECOND STRING
3564 7C 		  BYTE_COMP:	LD    A,H
3565 B5 				OR    L
3566 E3 				EX    (SP),HL
3567 78 				LD    A,B
3568 200B				JR    NZ,SEC_PLUS	      ; JUMP UNLESS THE SECOND STRING
356A B1 				OR    C 		      ; IS NULL
356B C1 		  SECOND_LOW:	POP   BC		      ; HERE THE SECOND STRING IS EITHER NULL
356C					;			      ; OR LESS THAN THE FIRST
356C 2804				JR    Z,BOTH_NULL
356E F1 				POP   AF
356F 3F 				CCF			      ; THE CARRY IS COMPLEMENTED TO
3570 1816				JR    STR_TEST		      ; GIVE THE CORRECT TEST RESULTS
3572 F1 		  BOTH_NULL:	POP   AF		      ; HERE THE CARRY IS USED AS IT
3573 1813				JR    STR_TEST		      ; STANDS
3575 B1 		  SEC_PLUS:	OR    C
3576 280D				JR    Z,FRST_LESS	      ; THE FIRST STRING IS NOW NULL, THE
3578					;			      ; SECOND NOT
3578 1A 				LD    A,(DE)		      ; NEITHER STRING IS NULL, SO THEIR
3579 96 				SUB   (HL)		      ; NEXT BYTES ARE COMPARED
357A 3809				JR    C,FRST_LESS	      ; THE FIRST BYTE IS LESS
357C 20ED				JR    NZ,SECOND_LOW	      ; THE SECOND BYTE IS LESS
357E 0B 				DEC   BC		      ; THE BYTES ARE EQUAL; SO THE
357F 13 				INC   DE		      ; LENGTH ARE DECREMENTED AND A
3580 23 				INC   HL		      ; JUMP IS MADE TO BYTE_COMP
3581 E3 				EX    (SP),HL		      ; TO COMPARE THE NEXT BYTES OF THE
3582 2B 				DEC   HL		      ; REDUCED STRING
3583 18DF				JR    BYTE_COMP
3585 C1 		  FRST_LESS:	POP   BC
3586 F1 				POP   AF
3587 A7 				AND   A 		      ; THE CARRY IS CLEARED HERE FOR THE
3588					;			      ; CORRECT TEST RESULT
3588 F5 		  STR_TEST:	PUSH  AF		      ; FOR THE STRING TESTS, AZERO IS
3589 EF 				RST   28H		      ; PUT ON THE CALCULATOR STACK.
358A A0 				DEFB 0A0H		      ; STK_ZERO
358B 38 				DEFB 038H		      ; CALC_END
358C F1 		  END_TESTS:	POP   AF		      ; THESE THREE TESTS CALLED AS
358D F5 				PUSH  AF		      ; NEEDED, GIVE THE CORRECT RESULTS
358E DC0135				CALL  C,NOT		      ; FOR ALL TWELWE COMPARISONS. THE
3591 F1 				POP   AF		      ; INITIAL CARRY IS SET FOR "NOT EQUAL"
3592 F5 				PUSH  AF		      ; AND "EQUAL", AND THE FINAL CARRY
3593 D4F934				CALL  NC,GREATE_0	      ; IS SET FOR "GREATER THAN",
3596 F1 				POP   AF		      ; "LESS THAN" AND "EQUAL"
3597 0F 				RRCA
3598 D40135				CALL  NC,NOT
359B C9 				RET			      ; FINISHED
359C			  ;
359C			  ; THE "STRING CONCATENATION" OPERATION
359C			  ; (OFFSET 17: "STRS_ADD")
359C			  ; THIS SUBROUTINE PERFORMS THE BINARY OPERATION "A$+B$". THE PARAMETERS FOR
359C			  ; THESE STRINGSARE FETCHEDAND THE TOTAL LENGTH FOUND. SUFFICIENT ROOM TO HOLD
359C			  ; BOTH THE STRINGS IS MADE AVAILABLE IN THE WORK SPACE AND THE STRINGS ARE
359C			  ; COPIED OVER. THE RESULT OF THIS SUBROUTINE IS THEREFORE TO PRODUCE A TEMPORARY
359C			  ; VARIABLE A$+B$ THAT RESIDES IN THE WORK SPACE.
359C CDF12B		  STRS_ADD:	CALL  STK_FETCH 	      ; THE PARAMETERS OF THE SECOND STRING
359F D5 				PUSH  DE		      ; ARE FETCHED AND SAVED
35A0 C5 				PUSH  BC
35A1 CDF12B				CALL  STK_FETCH 	      ; THE PARAMETERS OF THE FIRS STRING
35A4					;			      ; ARE FETCHED
35A4 E1 				POP   HL
35A5 E5 				PUSH  HL		      ; THE LENGTH ARE NOW IN HL AND BC
35A6 D5 				PUSH  DE		     ; THE PARAMETERS OF THE FIRST
35A7 C5 				PUSH  BC		      ; STRING ARE SAVED
35A8 09 				ADD   HL,BC		      ; THE TOTAL LENGTH OF THE TWO
35A9 44 				LD    B,H		      ; STRINGS IS CALCULATED AND PASSED
35AA 4D 				LD    C,L		      ; TO BC
35AB F7 				RST   30H		      ; SUFFICIENT ROOM IS MADE AVAILABLE
35AC CDB22A				CALL  STK_ST_S		      ; THE PARAMETERS OF THE NEW STRING ARE
35AF					;			      ; PASSED TO THE CALCULATOR STACK
35AF C1 				POP   BC		      ; THE PARAMETERS OF THE FIRST
35B0 E1 				POP   HL		      ; STRING ARE RETRIEVED AND THE
35B1 78 				LD    A,B		      ; STRING COPIED TO THE WORK SPACE
35B2 B1 				OR    C 		      ; AS LONG AS IT IS NOT A NULL STRING
35B3 2802				JR    Z,OTHER_STR
35B5 EDB0				LDIR
35B7 C1 		  OTHER_STR:	POP   BC		      ; EXACTLY THE SAME PROCEDURE IS
35B8 E1 				POP   HL		      ; FOLLOWED FOR THE SECOND STRING
35B9 78 				LD    A,B		      ; THEREBY GIVING "A$+B$"
35BA B1 				OR    C
35BB 2802				JR    Z,STK_PNTRS
35BD EDB0				LDIR
35BF			  ;
35BF			  ; THE "STK_PNTRS" SUBROUTINE
35BF			  ; THIS SUBROUTINE RESETS THE HL REGISTER PAIR TO POINT TO THE FIRST BYTE OF THE
35BF			  ; "LAST VALUE" I.E. STKEND-5, AND THE DE REGISTER PAIR TO POINT ONE-PAST THE
35BF			  ; "LAST VALUE", I.E. STKEND.
35BF 2A655C		  STK_PNTRS:	LD    HL,(STKEND)	      ; FETCH THE CURRENT VALUE OF STKEND
35C2 11FBFF				LD    DE,-5		      ; SET DE TO -5 TWOS COMPLEMENT
35C5 E5 				PUSH  HL		      ; STACK THE VALUE FOR STKEND
35C6 19 				ADD   HL,DE		      ; CALCULATE STKEND-5
35C7 D1 				POP   DE		      ; DE NOW HOLDS STKEND AND HL
35C8 C9 				RET			      ; HOLDS STKEND-5
35C9			  ;
35C9			  ; THE "CHR$" FUNCTION
35C9			  ; (OFFSET 2F: "CHR_DOLL")
35C9			  ; THIS SUBROUTINE HADLES THE FUNCTION CHR$ X AND CREATES A SINGLE CHARACTER
35C9			  ; STRING IN THE WORK SPACE
35C9 CDD52D		  CHAR_DOLL:	CALL  FP_TO_A		      ; THE "LAST VALUE" IS COMPRESSED
35CC					;			      ; INTO THE A REGISTER
35CC 380E				JR    C,YREPORT_B	      ; GIVE THE ERROR REPORT IF X WAS GREATER
35CE					;			      ; THAN 255D, OR
35CE 200C				JR    NZ,YREPORT_B	      ; X WAS A NEGATIVE NUMBER.
35D0 F5 				PUSH  AF		      ; SAVE THE COMPRESSED VALUE OF X
35D1 010100				LD    BC,001H		      ; MAKE ONE SPACE AVAILABLE IN THE
35D F7 				RST   BC_SPACES 	      ; WORK SPACE
35D5 F1 				POP   AF		      ; FETCH THE VALUE
35D6 12 				LD    (DE),A		      ; COPY THE VALUE TO THE WORK SPACE
35D7 CDB22A				CALL  STK_ST_S		      ; PASS THE PARAMETERS OF THE NEW STRING
35DA					;			      ; TO THE CALCULATOR STACK
35DA EB 				EX    DE,HL		      ; RESET THE POINTERS
35DB C9 				RET			      ; FINISHED
35DC			  ;
35DC			  ; REPORT B - INTEGER OUT OF RANGE
35DC CF 		  YREPORT_B:	RST   ERROR_1		      ; CALL THE ERROR HANDLING
35DD 0A 				DEFB 00AH		      ; ROUTINE
35DE			  ;
35DE			  ; THE "VAL" AND "VAL$" FUNCTIONS
35DE			  ; (OFFSETS 1D: "VAL", AND 18: "VAL$")
35DE			  ; THIS SUBROUTINE HANDLES THE FUNCTIONS VAL X$ AND VAL$ X$. WHEN HANDLING VAL X$
35DE			  ; IT RETURNS A "LAST VALUE" THAT IS THE RESULT OF AVALUATING THE STRING
35DE			  ; (WITHOUT ITS BOUNDING QUOTES) AS A NUMERICAL EXPRESSION. WHEN HANDLING VAL$ X$
35DE			  ; IT EVALUATES X$ (WITHOUT ITS BOUNDING QUOTES)AS A STRING EXPRESSION, AND
35DE			  ; RETURNS THE PARAMETERS OF THAT STRING EXPRESSION AS A "LAST VALUE" ON THE
35DE			  ; CALCULATOR STACK.
35DE 2A5D5C		  VAL_DOLL:	LD    HL,(CH_ADD)	      ; THE CURRENT VALUE OF CH_ADD IS
35E1 E5 				PUSH  HL		      ; PRESERVED ON THE MACHINE STACK.
35E2 78 				LD    A,B		      ; THE OFFSET FOR "VAL" OR "VAL$" MUST BE
35E3					;			      ; IN THE B REGISTER; IT IS NOW COPIED TO A
35E3 C6E3				ADD   A,0E3H		      ; PRODUCE 00 AND CARRY SET FOR "VAL",
35E5					;			      ; FB AND CARRY RESET FOR "VAL$"
35E5 9F 				SBC   A,A		      ; PRODUCE FF (BIT 6 THEREFORE SET) FOR "VAL"
35E6					;			      ; BUT 00 (BIT 6 RESET) FOR "VAL$"
35E6 F5 				PUSH  AF		      ; SAVE THIS "FLAG" ON THE MACHINE STACK
35E7 CDF12B				CALL  STK_FETCH 	      ; THE PARAMETERS OF THE SRING ARE
35EA D5 				PUSH  DE		      ; FETCHED; THE STARTING ADDRESS IS
35EB 03 				INC   BC		      ; SAVED; ONE BYTE IS ADDED TO THHE
35EC F7 				RST   BC_SPACES 	      ; LENGTH AND ROOM MADE AVAILABLE FOR
35ED					;			      ; THE STRING (+1) IN THE WORK SPACE.
35ED E1 				POP   HL		      ; THE STARTING ADDRESS OF THE STRING GOES
35EE					;			      ; TO HL AS A SOURCE ADDRESS
35EE ED535D5C				LD    (CH_ADD),DE	      ; THE POINTER TO THE FIRST NEW
35F2 D5 				PUSH  DE		      ; SPACE GOES TO CH_ADD AND TO
35F3					;			      ; THE MACHINE STACK.
35F3 EDB0				LDIR			      ; THE STRING IS COPIED TO THE WORK SPACE
35F5					;			      ; TOGETHER WITH AN EXTRA BYTE
35F5 EB 				EX    DE,HL		      ; SWITCH THE POINTERS
35F6 2B 				DEC   HL		      ; THE EXTRA BYTE IS REPLACED BY A
35F7 360D				LD    (HL),00DH 	      ; !CARRIAGE RETURN" CHARACTER
35F9 FDCB01BE				RES  LIN_EXEC,(IY+FLAGS-YBASE) ; THE SYNTAX FLAG IS RESET AND THE
35FD CDFB24				CALL  SCANNING		      ; STRING IS SCANNED FOR CORRECT SYNTAX
3600 DF 				RST   GET_BT		      ; THE CHARACTER AFTER THE STRING IS FETCHED
3601 FE0D				CP    CR		      ; A CHECK IS MADE THAT THE END OF
3603					;			      ; THE EXPRESSION HAS BEEN REACHED
3603 2007				JR    NZ,V_REPORT_C	      ; IF NOT, THE ERROR IS REPORTED
3605 E1 				POP   HL		      ; THE STARTING ADDRESS OF THE
3606					;			      ; STRING IS FETCHED
3606 F1 				POP   AF		      ; THE FLAG FOR "VAL/VAL$" IS
3607 FDAE01				XOR   (IY+FLAGS-YBASE)	      ; FETCHED AND BIT 6 IS COMPARED WITH BIT 6
360A E640				AND   040H		      ; OF THE RESULT OF THE SYNTAX SCAN
360C C28A1C		  V_REPORT_C:	JP    NZ,REPS) AS A NUMERICAL EXPRESSION. WHEN HANDLING VAL$ X$
35DE			  ; IT EVALUATES X$ (WITHOUT ITS BOUNDING QUOTES)AS A STRING EXPRESSION, AND
35DE			  ; RETURNS THE PARAMETERS OF THAT STRING EXPRESSION AS A "LAST VALUE" ON THE
35DE			  ; CALCULATOR STACK.
35DE 2A5D5C		  VAL_DOLL:	LD    HL,(CH_ADD)	      ; THE CURRENT VALUE OF CH_ADD IS
35E1 E5 				PUSH  HL		      ; PRESERVED ON THE MACHINE STACK.
35E2 78 				LD    A,B		      ; THE OFFSET FOR "VAL" OR "VAL$" MUST BE
35E3					;			      ; IN THE B REGISTER; IT IS NOW COPIED TO A
35E3 C6E3				ADD   A,0E3H		      ; PRODUCE 00 AND CARRY SET FOR "VAL",
35E5					;			      ; FB AND CARRY RESET FOR "VAL$"
35E5 9F 				SBC   A,A		      ; PRODUCE FF (BIT 6 THEREFORE SET) FOR "VAL"
35E6					;			      ; BUT 00 (BIT 6 RESET) FOR "VAL$"
35E6 F5 				PUSH  AF		      ; SAVE THIS "FLAG" ON THE MACHINE STACK
35E7 CDF12B				CALL  STK_FETCH 	      ; THE PARAMETERS OF THE SRING ARE
35EA D5 				PUSH  DE		      ; FETCHED; THE STARTING ADDRESS IS
35EB 03 				INC   BC		      ; SC9 				RET			      ; FINISHED
35DC			  ;
35DC			  ; REPORT B - INTEGER OUT OF RANGE
35DC CF 		  YREPORT_B:	RST   ERROR_1		      ; CALL THE ERROR HANDLING
35DD 0A 				DEFB 00AH		      ; ROUTINE
35DE			  ;
35DE			  ; THE "VAL" AND "VAL$" FUNCTIONS
35DE			  ; (OFFSETS 1D: "VAL", AND 18: "VAL$")
35DE			  ; THIS SUBROUTINE HANDLES THE FUNCTIONS VAL X$ AND VAL$ X$. WHEN HANDLING VAL X$
35DE			  ; IT RETURNS A "LAST VALUE" THAT IS THE RESULT OF AVALUATING THE STRING
35DE			  ; (WITHOUT ITS BOUNDING QUOTES) AS A NUMERICAL EXPRESSION. WHEN HANDLING VAL$ X$
35DE			  ; IT EVALUATES X$ (WITHOUT ITS BOUNDING QUOTES)AS A STRING EXPRESSION, AND
35DE			  ; RETURNS THE PARAMETERS OF THAT STRING EXPRESSION AS A "LAST VALUE" ON THE
35DE			  ; CALCULATOR STACK.
35DE 2A5D5C		  VAL_DOLL:	LD    HL,(CH_ADD)	      ; THE CURRENT VALUE OF CH_ADD IS
35E1 E5 				PUSH  HL		      ; PRESERVED ON THE MACHINE STACK.
35E2 78 				LD    A,B		      ; THE OFFSET FOR "VAL" OR "VAL$" MUST BE
35E3					;			      ; IN THE B REGISTER; IT IS NOW COPIED TO A
35E3 C6E3				ADD   A,0E3H		      ; PRODUCE 00 AND CARRY SET FOR "VAL",
35E5					;			      ; FB AND CARRY RESET FOR "VAL$"
35E5 9F 				SBC   A,A		      ; PRODUCE FF (BIT 6 THEREFORE SET) FOR "VAL"
35E6					;			      ; BUT 00 (BIT 6 RESET) FOR "VAL$"
35E6 F5 				PUSH  AF		      ; SAVE THIS "FLAG" ON THE MACHINE STACK
35E7 CDF12B				CALL  STK_FETCH 	      ; THE PARAMETERS OF THE SRING ARE
35EA D5 				PUSH  DE		      ; FETCHED; THE STARTING ADDRESS IS
35EB 03 				INC   BC		      ; SAVED; ONE BYTE IS ADDED TO THHE
35EC F7 				RST   BC_SPACES 	      ; LENGTH AND ROOM MADE AVAILABLE FOR
35ED					;			      ; THE STRING (+1) IN THE WORK SPACE.
35ED E1 				POP   HL		      ; THE STARTING ADDRESS OF THE STRING GOES
35EE					;			      ; TO HL AS A SOURCE ADDRESS
35EE ED535D5C				LD    (CH_ADD),DE	      ; THE POINTER TO THE FIRST NEW
35F2 D5 				PUSH  DE		      ; SPACE GOES TO CH_ADD AND TO
35F3					;			      ; THE MACHINE STACK.
35F3 EDB0				LDIR			      ; THE STRING IS COPIED TO THE WORK SPACE
35F5					;			      ; TOGETHER WITH AN EXTRA BYTE
35F5 EB 				EX    DE,HL		      ; SWITCH THE POINTERS
35F6 2B 				DEC   HL		      ; THE EXTRA BYTE IS REPLACED BY A
35F7 360D				LD    (HL),00DH 	      ; !CARRIAGE RETURN" CHARACTER
35F9 FDCB01BE				RES  LIN_EXEC,(IY+FLAGS-YBASE) ; THE SYNTAX FLAG IS RESET AND THE
35FD CDFB24				CALL  SCANNING		      ; STRING IS SCANNED FOR CORRECT SYNTAX
3600 DF 				RST   GET_BT		      ; THE CHARACTER AFTER THE STRING IS FETCHED
3601 FE0D				CP    CR		      ; A CHECK IS MADE THAT THE END OF
3603					;			      ; THE EXPRESSION HAS BEEN REACHED
3603 2007				JR    NZ,V_REPORT_C	      ; IF NOT, THE ERROR IS REPORTED
3605 E1 				POP   HL		      ; THE STARTING ADDRESS OF THE
3606					;			      ; STRING IS FETCHED
3606 F1 				POP   AF		      ; THE FLAG FOR "VAL/VAL$" IS
3607 FDAE01				XOR   (IY+FLAGS-YBASE)	      ; FETCHED AND BIT 6 IS COMPARED WITH BIT 6
360A E640				AND   040H		      ; OF THE RESULT OF THE SYNTAX SCAN
360C C28A1C		  V_REPORT_C:	JP    NZ,REPORT_C	      ; REPORT THE ERROR IF THEY DO NOT MATCH
360F 225D5C				LD    (CH_ADD),HL	      ; START ADDRESS TO CH_ADD AGAIN
3612 FDCB01FE				SET   LIN_EXEC,(IY+FLAGS-YBASE) ; THE FLAG IS SET FOR LINE EXECUTION
3616 CDFB24				CALL  SCANNING		      ; THE STRING IS TREATED AS A "NEXT
3619					;			      ; EXPRESSION" AND A "LAST VALUE" PRODUCED
3619 E1 				POP   HL		      ; THE ORIGINAL VALUE OF CH_ADD IS
361A 225D5C				LD    (CH_ADD),HL	      ; RESTORED
361D 18A0				JR    STK_PNTRS 	      ; THE SUBROUTINE EXITS VIA STK_PNTRS WHICH
361F					;			      ; RESETS THE POINTERS
361F			  ;
361F			  ; THE "STR$" FUNCTION
361F			  ; (OFFSET 2E: "STR_DOLL")
361F			  ; THIS SUBROUTINE HANDLES THE FUNCTION STR$ X AND RETURNS A "LAST VALUE" WHICH
361F			  ; IS A SET OF PARAMETERS THAT DEFINE	A STRING CONTAINING WHAT WOULD APPEAR ON
361F			  ; THE SCREEN IF X WERE DISPLAYED BY A PPRINT COMMAND.
361F 010100		  STR_DOLL:	LD    BC,1		      ; ONE SPACE IS MADE IN THE WORK
3622 F7 				RST   BC_SPACES 	      ; SPACE AND ITS ADDRESS IS COPIED
3623 225B5C				LD    (K_CUR),HL	      ; TO K_CUR, THE ADDRESS OF THE CURSOR
3626 E5 				PUSH  HL		      ; THIS ADDRESS IS SAVED ON THE STACK TOO
3627 2A515C				LD    HL,(CURCHL)	      ; THE CURRENT CHANNEL ADDRESS IS
362A E5 				PUSH  HL		      ; SAVED ON THE MACHINE STACK
362B 3EFF				LD    A,-1		      ; CHANNEL "R" IS OPENED, ALLOWING
362D CD0116				CALL  CHAN_OPEN 	      ; THE STRING TO BE PRINTED OUT INTO THE
3630					;			      ; WORK SPACE
3630 CDE32D				CALL  PRINT_FP		      ; THE "LAST VALUE", X IS NOW PRINTED OUT IN
3633					;			      ; THE WORK SPACE AND THE WORK SPACE IS
3633					;			      ; EXPANDED WITH EACH CHARACTER.
3633 E1 				POP   HL		      ; RESTORE CURCHL TO HL AND
3634 CD1516				CALL  CHAN_FLAG 	      ; RESTORE THE FLAGS THAT ARE
3637					;			      ; APPROPRIATE TO IT
3637 D1 				POP   DE		      ; RESTORE THE START ADDRESS OF THE STRING
3638 2A5B5C				LD    HL,(K_CUR)	      ; NOW THE CURSOR ADDRESS IS ONE PAST THE
363B A7 				AND   A 		      ; END OF THE STRING AND HENCE
363C ED52				SBC   HL,DE		      ; THE DIFFERENCE IS THE LENGTH
363E 44 				LD    B,H		      ; TRANSFER THE LENGTH TO BC
363F 4D 				LD    C,L
3640 CDB22A				CALL  STK_ST_S		      ; PASS THE PARAMETERS OF THE NEW STRING
3643					;			      ; TO THE CALCULATOR STACK
3643 EB 				EX    DE,HL		      ; RESET THE POINTERS
3644 C9 				RET			      ; FINISHED
3645			  ; NOTE: SEE PRINT_FP FOR AN EXPLANATION OF THE PRINT "A"!STR$ 0.1 ERROR.
3645			  ;
3645			  ; THE "READ_IN" SUBROUTINE
3645			  ; (OFFSET 1A: "READ_IN")
3645			  ; THIS SUBROUTINE IS CALLED VIA CALCULATOR OFFSET THROUGH THE FIRST LINE OF
3645			  ; THE S_INKEY ROUTINE IN SCANNING. IT APPEARS TO PROVE FOR THE READING IN OF
3645			  ; DATA THROUGH DIFFERENT STREAMS FROM THOSE AVAILABLE ON THE STANDARD SPECTRUM.
3645			  ; LIKE INKEY THE SUBROUTINE RETURNS A STRING
3645 CD941E		  READ_IN:	CALL  FIND_INT1 	      ; THE NUMERICAL PARAMETER IS
3648					;			      ; COMPRESSED INTO THE A REGISTER
3648 FE10				CP    010H		      ; IT IS SMALLER THAN 16D ?
364A D29F1E				JP    NC,REPORT_B	      ; IF NOT, REPORT THE ERROR
364D 2A515C				LD    HL,(CURCHL)	      ; THE CURRENT CHANNEL ADDRESS IS
3650 E5 				PUSH  HL		      ; SAVED ON THE MACHINE STACK
3651 CD0116				CALL  CHAN_OPEN 	      ; THE CHANNEL CPECIFIED BY THE PARAMETER
3654					;			      ; IS OPENED
3654 CDE615				CALL  INPUT_AD		      ; THE SIGNAL IS NOW ACCEPDET, LIKE
3657					;			      ; A KEY-VALUE
3657 010000				LD    BC,0		      ; THE DEFAULT LENGTH OF THE
365A					;			      ; RESULTING STRING IS ZERO
365A 3003				JR    NC,R_I_STORE	      ; JUMP IF THERE WAS NO SIGNAL
365C 0C 				INC   C 		      ; SET THE LENGTH TO 1 NOW
365D F7 				RST   BC_SPACES 	      ; MAKE A SPACE IN THE WORK SPACE
365E 12 				LD    (DE),A		      ; PUT THE STRING INTO IT
365F CDB22A		  R_I_STORE:	CALL  STK_ST_S		      ; PASS THE PARAMETERS OF THE STRING
3662					;			      ; TO THE CALCULATOR STACK
3662 E1 				POP   HL		      ; RESTORE CURCHLAND THE
3663 CD1516				CALL  CHAN_FLAG 	      ; APPROPRIATE FLAGS
3666 C3BF35				JP    STK_PNTRS 	      ; EXIT, SETTING THE POINTERS
3669			  ;
3669			  ; THE "CODE" FUNCTION
3669			  ; (OFFSET 1C: "CODE")
3669			  ; THIS SUBROUTINE HANDLES THE FUNCTION CODE A$ AND RETURNS THE SPECTRUM CODE OF
3669			  ; THE FIRSTCHARACTER IN A$, OR ZERO IF A$ SHOULD BE NULL.
3669 CDF12B		  CODE: 	CALL  STK_FETCH 	      ; THE PARAMETERS OF THE STRING ARE FETCHED
366C 78 				LD    A,B		      ; THE LENGTH IS TESTED AND THE A
366D B1 				OR    C 		      ; REGISTER HOLDING ZERO IS CARRIED
366E 2801				JR    Z,STK_CODE	      ; FORWARD IF A$ IS A NULL STRING
3670 1A 				LD    A,(DE)		      ; THE CODE OF THE FIRST CHARACTER
3671					;			      ; IS PUT INTO A OTHERWISE
3671 C3282D		  STK_CODE:	JP    STACK_A		      ; THE SUBROUTINE EXITS VIA STACK_A
3674					;			      ; WHICH GIVES THE CORRECT "LAST VALUE"
3674			  ;
3674			  ; THE "LEN" FUNCTION
3674			  ; (OFFSET 1E: "LEN")
3674			  ; THIS SUBROUTINE HANDLES THE FUNCTION LEN A$ AND RETURNS A "LAST VALUE" THAT IS
3674			  ; EQUAL TO THE LENGTH OF THE STRING
3674 CDF12B		  LEN:		CALL  STK_FETCH 	      ; THE PARAMETERS OF THE STRING ARE FETCHED
3677 C32B2D				JP    STACK_BC		      ; THE SUBROUTINE EXITS VIA STACK_BC
367A					;			      ; WHICH GIVES THE CORRECT "LAST VALUE"
367A			  ;
367A			  ; THE "DECREASE THE COUNTER" SUBROUTINE
367A			  ; (OFFSET 35: "DEC_JR_NZ")
367A			  ; THIS SUBROUTINE IS ONLY CALLED BY THE SERIES GENERATOR SUBROUTINE AND IN
367A			  ; EFFECT IS A "DJNZ" OPERATION BUT THE COUNTER IS THE SYSTEM VARIABLE, BREG
367A			  ; RATHER THAN THE B REGISTER.
367A D9 		  DEC_JR_NZ:	EXX			      ; GO TO THE ALTERATIVE REGISTER
367B E5 				PUSH  HL		      ; SET AND SAVE THE NEXT LITERAL POINTER
367C					;			      ; ON THE MACHINE STACK
367C 21675C				LD    HL,BREG		      ; MAKE HL POINT TO BREG
367F 35 				DEC   (HL)		      ; DECREASE BREG
3680 E1 				POP   HL		      ; RESTORE THE NEXT LITERAL POINTER
3681 2004				JR    NZ,JUMP_2 	      ; THE JUMP IS MADE ON NON-ZERO
3683 23 				INC   HL		      ; THE NEXT LITERAL IS PASSED OVER
3684 D9 				EXX			      ; RETURN TO THE MAIN REGISTER SET
3685 C9 				RET			      ; FINISHED
3686			  ;
3686			  ; THE "JUMP" SUBROUTINE
3686			  ; (OFFSET 33: "JUMP")
3686			  ; THIS SUBROUTINE EXECUTES AN UNCODITIONAL JUMP WHEN CALLED BY THE LITERAL "33"
3686			  ; IT IS ALSO CALLED BY THE SUBROUTINE DECREASE THE COUNTER AND JUMP ON TRUE.
3686 D9 		  JUMP: 	EXX			      ; GOTO ALTERNATIVE REGISTER SET
3687 5E 		  JUMP_2:	LD    E,(HL)		      ; THE NEXT LITERAL (JUMP LENGTH) IS
3688					;			      ; PUT IN THE E' REGISTER
3688 7B 				LD    A,E		      ; THE NUMBER 00H OR FFH
3689 17 				RLA			      ; IS FORMED IN A ACCORDING AS E'
368A 9F 				SBC   A,A		      ; IS POSITIVE OR NEGATIVE, AND IS
368B 57 				LD    D,A		      ; THEN COPIED TO D'
368C 19 				ADD   HL,DE		      ; THE REGISTERS H' & L' NOW HOLD
368D D9 				EXX			      ; THE NEXT LITERAL POINTER
368E C9 				RET			      ; FINISHED
368F			  ;
368F			  ; THE "JUMP ON TRUE" SUBROUTINE
368F			  ; (OFFSET 00: "JUMP TRUE")
368F			  ; THIS SUBROUTINE EXECUTES A CONDITIONAL JUMP IF THE "LAST VALUE" ON THE
368F			  ; CALCULATOR STACK, OR MORE PRECISELY THE NUMBER ADDRESSED CURRENTLY BY THE DE
368F			  ; REGISTER PAIR, IS TRUE
368F 13 		  JUMP_TRUE:	INC   DE		      ; POINT TO THE THIRD BYTE, WHICH IS
3690 13 				INC   DE		      ; ZERO OR ONE
3691 1A 				LD    A,(DE)		      ; COLLECT THIS BYTE IN THE A REGISTER
3692 1B 				DEC   DE		      ; POINT TO THE FIRST BYTE
3693 1B 				DEC   DE		      ; ONCE AGAIN
3694 A7 				AND   A 		      ; TEST THE THIRD BYTE: IS IT ZERO?
3695 20EF				JR    NZ,JUMP		      ; MAKE THE JUMP IF THE BYTE IS NON-ZERO
3697					;			      ; I.E. IF THE NUMBER IS NON-FALSE
3697 D9 				EXX			      ; GO TO THE ALTERNATE REGISTER SET
3698 23 				INC   HL		      ; PASS OVER THE JUMP LENGTH
3699 D9 				EXX			      ; BACK TO THE MAIN SET OF REGISTERS
369A C9 				RET			      ; FINISHED
369B			  ;
369B			  ; THE "END_CALC" SUBROUTINE
369B			  ; (OFFSET 38: "END_CALC")
369B			  ; THIS SUBROUTINE ENDS A RST 028H OPERATION
369B F1 		  END_CALC:	POP   AF		      ; THE RETURN ADDRESS TO THE CALCULATOR
369C					;			      ; ("RE_ENTRY") IS DISCARDED.
369C D9 				EXX			      ; INSTEAD, THE ADDRESS IN H'L' IS PUT
369D E3 				EX    (SP),HL		      ; ON THE MACHINE STACK AND AN INDIRECT
369E					;			      ; JUMP IS MADE TO IT
369E D9 				EXX			      ; H'L' WILL NOW HOLD ANY EARLIER ADDRESS IN
369F					;			      ; THE CALCULATOR CHAIN OF ADDRESSES
369F C9 				RET			      ; FINISHED
36A0			  ;
36A0			  ; THE "MODULUS" SUBROUTINE
36A0			  ; (OFFSET 32: "N_MOD_M")
36A0			  ; THIS SUBROUTINE CALCULATES N (MOD M), WHERE M IS A POSITIVE INTEGER HELD AT THE
36A0			  ; TOP OF THE STACK, THE "LAST VALUE", AND N IS AN INTEGER HELD ON THE STACK
36A0			  ; BENEATH M.
36A0			  ;   THE SUBROUTINE RETURNS THE INTEGER QUOTIENT INT(N/M) AT THE TOP OF THE
36A0			  ; CALCULATOR STACK, THE "LAST VALUE", AND THE REMAINDER N - INT(N/M) IN THE
36A0			  ; SECOND PLACE ON THE STACK.
36A0			  ;   THIS SUBROUTINE IS CALLED DURING THE CALCULATION OF A RANDOM NUMBER TO
36A0			  ; REDUCE N MOD 65537D.
36A0 EF 		  N_MOD_M:	RST   28H
36A1 C0 				DEFB 0C0H		      ; ST_MEM_0: N,M		  MEM_0 HOLDS M
36A2 02 				DEFB 002H		      ; DELETE:   N
36A3 31 				DEFB 031H		      ; DUPLICATE:N,N
36A4 E0 				DEFB 0E0H		      ; GET_MEM_0:N,N,M
36A5 05 				DEFB 005H		      ; DIVISION: N,N/M
36A6 27 				DEFB 027H		      ; INT:	  N,INT(N/M)
36A7 E0 				DEFB 0E0H		      ; GET_MEM_0:N,INT(N/M),M
36A8 01 				DEFB 001H		      ; EXCHANGE: N,M,INT(N/M)
36A9 C0 				DEFB 0C0H		      ; ST_MEM_0:		  MEM_0 HOLDS INT(N/M)
36AA 04 				DEFB 004H		      ; MULTIPLY: N,M*INT(N/M)
36AB 03 				DEFB 003H		      ; SUBTRACT: N-M*INT(N/M)
36AC E0 				DEFB 0E0H		      ; GET_MEM_0:N-M*INT(N/M),INT(N/M)
36AD 38 				DEFB 038H		      ; END_CALC
36AE C9 				RET			      ; FINISHED
36AF			  ;
36AF			  ; THE "INT" FUNCTION
36AF			  ; (OFFSET 27: "INT")
36AF			  ; THIS SUBROUTINEHANDLES THE FUNCTION INT X AND RETURNS A "LAST VALUE" THAT IS
36AF			  ; THE "INTEGER PART" OF THE VALUE SUPPLIED. THUS INT 2.4 GIVES 2 BUT AS THE
36AF			  ; SUBROUTINE ALWAYS ROUND THE RESULT DOWN INT -2.4 GIVES -3.
36AF			  ;   THE SUBROUTINE USES THE INTEGER TRUNCATION TOWARDS ZERO SUBROUTINE AT
36AF			  ; 3214 TO PRODUCE I(X) SUCH THAT I(2.4) GIVES 2 AND I(-2.4) GIVES -2. THUS INT X
36AF			  ; IS GIVES BY I(X) FOR VALUES OF X THAT ARE GREATER THAN OR EQUAL TO ZERO, AND
36AF			  ; I(X)-1 FOR NEGATIVE VALUES OF X THAT A NOT ALREADY INTEGERS, WHEN THE
36AF			  ; RESULT IS, OF COURSE I(X).
36AF EF 		  INT:		RST   28H		      ; 	  X
36B0 31 				DEFB 031H		      ; DUPLICATE:X,X
36B1 36 				DEFB 036H		      ; LESS_0:   X,(1/0)
36B2 00 				DEFB 0			      ; JUMP TRUE:X
36B3 04 				DEFB X_NEG-$		      ; TO 36B7,X_NEG: X
36B4			  ; FOR VALUES OF X THAT HAVE BEEN SHOWN TO BE GREATERTHAN OR EQUAL TO ZERO
36B4			  ; THERE IS NO JUMP AND I(X) IS READILY FOUND
36B4 3A 				DEFB 03AH		      ; TRUNCATE: I(X)
36B5 38 				DEFB 038H		      ; END CALC
36B6 C9 				RET			      ; FINISHED
36B7			  ; WHEN X IS NEGATIVE INTEGER I(X) IS RETURNED, OTHERWISE I(X)-1 IS RETURNED
36B7 31 		  X_NEG:	DEFB 031H		      ; DUPLICATE:X,X
36B8 3A 				DEFB 03AH		      ; TRUNCATE: X,I(X)
36B9 C0 				DEFB 0C0H		      ; ST_MEM_0: X,I(X)	  MEM_0 HOLDS I(X)
36BA 03 				DEFB 003H		      ; SUBTRACT: X-I(X)
36BB E0 				DEFB 0E0H		      ; GET_MEM_0:X-I(X),I(X)
36BC 01 				DEFB 001H		      ; EXCHANGE: I(X),X-I(X)
36BD 30 				DEFB 030H		      ; NOT:	  I(X),(1/0)
36BE 00 				DEFB 0			      ; JUMP TRUE:I(X)
36BF 03 				DEFB EXIT-$		      ; TO 36C2 EXIT: I(X)
36C0			  ; THE JUMP IS MADE FOR VALUES OF X THAT ARE NEGATIVE INTEGERS, OTHERWISE THERE
36C0			  ; IS NO JUMP AND I(X)-1 IS CALCULATED.
36C0 A1 				DEFB 0A1H		      ; STK_ONE:  I(X),1
36C1 03 				DEFB 003H		      ; SUBTRACT: I(X)-1
36C2 38 		  EXIT: 	DEFB 038H		      ; END_CALC
36C3 C9 				RET
36C4			  ; THE "EXPONENTIAL" FUNCTION
36C4			  ; (OFFSET 26: "EXP")
36C4			  ; THIS SUBROUTINE HANDLES THE FUNCTION EXP X AND TIS THE FIRST OF FOUR ROUTINES
36C4			  ; THAT USE SERIES GENERATOR TO PRODUCE CHEBYSHEV POLINOMIALS.
36C4			  ;   THE APPROXIMATION TO EXP X IS FOUND AS FOLLOWS:
36C4			  ;   I. X IS DIVIDED BY LN 2 TO GIVE Y, SO THAT 2 TO THE POWER Y IS NOW THE
36C4			  ;	 REQUIRED RESULT.
36C4			  ;  II. THE VALUE N IS FOUND, SUCH THAT N=INT(Y).
36C4			  ; III. THE VALUE W IS FOUND, SUCH THAT W=Y-N, WHERE 0<=W<=1, AS REQUIRED FOR THE
36C4			  ;	 SERIES TO CONVERGE.
36C4			  ; IV. THE ARGUMENT Z IF FORMED , SUCH THAT Z=2*W-1
36C4			  ;  V. THE SERIES GENERATOR IS USED TO RETURN 2**W
36C4			  ; VI. FINALLY N IS ADDED TO THE EXPONENT , GIVING 2**(N+W),WHICH
36C4			  ; IS 2**Y AND THEREFORE THE REQUARED ANSWER FOR EXP X.
36C4 EF 		  EXP:		RST   28H		      ;  FP-CALC	 X
36C5			  ; PERFORM STEP I.
36C5 3D 				DEFB 03DH		      ;  RE-STACK	 X (IN FULL FP FORM)
36C6 34 				DEFB 034H		      ;  STK-DATA	 X, 1/LN 2
36C7 F1 				DEFB 0F1H		      ;  EXPONENT+81
36C8 38AA3B29				DEFB 038H, 0AAH, 03BH, 029H
36CC 04 				DEFB 004H		      ;  MULTIPLY	 X/LN 2=Y
36CD			  ; PERFORM STEP II.
36CD 31 				DEFB 031H		      ;  DUPLICATE	Y,Y
36CE 27 				DEFB 027H		      ;  INT, 1C40	Y,INT Y=N
36CF C3 				DEFB 0C3H		      ;  ST-MEM-3	Y,N    MEM -3  HOLDS N
36D0			  ; PERFORM STEP III.
36D0 03 				DEFB 003H		      ; SUBSTRACT	Y-N=W
36D1			  ; PKRFORM STEP IV.
36D1 31 				DEFB 031H		      ; DUPLICATE	W,W
36D2 0F 				DEFB 00FH		      ; ADDITION	2*W
36D3 A1 				DEFB 0A1H		      ; STK ONE 	2*W,1
36D4 03 				DEFB 003H		      ; SUBSTRACT	2*W-1=Z
36D5			  ; PERFORM STEP V. PASSING TO THE SERIES GENERATOR THE PARAMETER '8' AND THE
36D5			  ; EGHT CONSTANTS REQUARED.
36D5 88 				DEFB 088H		      ; SERIES 08	  Z
36D6 13 				DEFB 013H		      ; EXPONENT  63	  1.
36D7 36 				DEFB 036H		      ; (00,00,00)
36D8 58 				DEFB 058H		      ; EXPONENT  68	  2.
36D9 6566				DEFB 065H, 066H 	      ; (00,00)
36DB 9D 				DEFB 09DH		      ; EXPONENT  6D	  3.
36DC 786540				DEFB 078H, 065H, 040H;	      ; (00)
36DF A2 				DEFB 0A2H		      ; EXPONENT  72	  4.
36E0 6032C9				DEFB 060H, 032H, 0C9H;	      ; (00)
36E3 E7 				DEFB 0E7H		      ; EXPONENT  77	  5.
36E4 21F7AF24				DEFB 021H, 0F7H, 0AFH, 024H
36E8 EB 				DEFB 0EBH		      ; EXPONENT  7B	  6.
36E9 2FB0B014				DEFB 02FH, 0B0H, 0B0H, 014H
36ED EE 				DEFB 0EEH		      ; EXPONENT  7E	  7.
36EE 7EBB9458				DEFB 07EH, 0BBH, 094H, 058H
36F2 F1 				DEFB 0F1H		      ; EXPONENT  81	  8.
36F3 3A7EF8CF				DEFB 03AH, 07EH, 0F8H, 0CFH
36F7			  ; AT THE END OF THE START LOOP THE 'LAST VALUE' IS 2**W
36F7			  ; PERFORM STEP VI.
36F7 E3 				DEFB 0E3H		      ; GET-MEM-3	2**W,N
36F8 38 				DEFB 038H		      ; END-CALC
36F9 CDD52D				CALL FP_TO_A		      ; THE ABSOLUTE VALUE OF N MOD 256 DECIMAL,
36FC					;			      ; IS PUT IN A REGISTER.
36FC 2007				JR   NZ,N_NEGTV 	      ; JUMP FORWARD IF N WAS NEGATIVE.
36FE 3803				JR   C,REPORT6		      ; ERROR IF ABS N > 255 DEC.
3700 86 				ADD  A,(HL)		      ; NOW ADD ABS N TO THE EXPONENT
3701 3009				JR   NC,RESULT_OK	      ; JUMP UNLESS E > 255 DEC
3703			  ; REPORT- NUMBER TOO BIG
3703 CF 		  REPORT6:	RST ERROR_1		      ; CALL ERROR HANDLING ROUTINE.
3704 05 				DEFB 005H		      ;
3705 3807		  N_NEGTV:	JR   C,RSLT_ZERO	      ; THE RESULT IS TO BE ZERO IF N < 255 DEC
3707 96 				SUB  (HL)		      ; SUBSTRACT ABS N FROM EXPONENT AS N WAS NEGATIVE
3708 3004				JR   NC,RSLT_ZERO	      ; ZERO RESULT IF IF E < 0
370A ED44				NEG			      ; MINUS E IS CHANGED TO E
370C 77 		  RESULT_OK:	LD   (HL),A		      ; THE EXPONENT, E, IS ENTERED
370D C9 				RET			      ; FINISH, 'LAST VALUE'  IS  EXP X
370E EF 		  RSLT_ZERO:	RST  28H		      ; USE THE CALCULATOR TO MAKE THE 'LAST VALUE'
370F					;			      ; ZERO
370F 02 				DEFB 002H		      ; DELETE
3710 A0 				DEFB 0A0H		      ; STK ZERO
3711 38 				DEFB 038H		      ; END CALC
3712 C9 				RET			      ; FINISH WITH EXP X =  0

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