Math I

Date: 198x

Type: Program

Platform(s): TS 1000

Math I is a collection of mathematical utility programs covering numerical methods, algebra, and number theory. The collection includes a Gauss-Jordan elimination routine that both solves simultaneous linear equations and inverts N×N matrices, a bisection method zero-finder (BIS), a Newton-Raphson zero-finder (NM), Simpson’s Rule numerical integrator (SIM), a quadratic solver handling complex roots, a function table printer (PL), a general base conversion utility (BSCV), a hex/decimal converter (HEXD), and a prime factor finder (PFD). The function plotter (Plot) is technically ambitious: it uses VAL of a string to evaluate user-entered expressions, compiles a 386-byte machine code routine at address 16514 during the first plot pass, and then allows the same function to be re-plotted at high speed via RAND USR 16514. The LIN program uses SCROLL extensively to manage screen real estate during data entry, and stores the augmented matrix (or identity extension for inversion) in a single two-dimensional array X(N,M).

Side A

LIN = Solves simultaneous linear equations
LINv2 = Solves simultaneous linear equations
QUAD = Computes roots and roots complex
SIM = Computes integral
BIS = Computes zero crossing
PL = Computes values of F(x)

Side B

Plot = Function Plotter, see 9999 REM for instructions
NM = Computes zero crossing
PFD = Prime Factor Finder
BSCV = Base conversion
HEXD = Hex / Decimal converter

Program Analysis

Program Structure

The cassette holds over a dozen independent BASIC programs, each identified by a REM name token at line 5 or 10. They are stored as separate files and cover a broad range of numerical and algebraic topics. The programs share common idioms — notably VAL F$ for runtime function evaluation and FAST/SLOW bracketing of computation loops — suggesting a single consistent authoring style.

BIS — Bisection Root Finder

Uses the classic bisection method. The user enters a function as a string and two bracket limits. The program evaluates VAL F$ at each endpoint and checks that the signs differ (line 140: IF M*N>0). If the positive root is at A rather than B, the limits are swapped (lines 160–180) so that B always holds the positive side. The loop bisects until MID stops changing (line 192: IF MID1=MID), which is a convergence test exploiting the machine’s finite floating-point precision rather than an epsilon comparison.

LIN — Simultaneous Equations / Matrix Inversion

This is the most substantial program. It implements full Gauss-Jordan elimination with partial pivoting on an augmented matrix stored in X(N,M). The mode flag M is repurposed: initially 1 (equations) or 2 (inversion), it is then overwritten with the actual column count — N+1 for equation solving or 2*N for inversion. The identity columns for matrix inversion are seeded at line 380 (LET X(R,N+R)=1).

Forward elimination (lines 610–820): sweeps columns left to right, swapping rows when a zero pivot is encountered.
Backward elimination (lines 900–980): sweeps columns right to left to fully diagonalize.
Determinant (lines 840–880): computed as the product of diagonal elements after forward elimination; zero determinant triggers the “SINGULAR” error path at line 1240.
Results: for equations, prints X(I,M)/X(I,I); for inversion, prints X(R,N+C)/X(R,R).

Two versions of LIN appear on the tape (both labeled REM "LIN"). The second version omits line 330’s label misprint (the first version uses line 320 with an incorrect PRINT; the second version uses line 320 without it), and uses GOTO 580 instead of GOTO 590 at line 440, suggesting it is a corrected revision. Both versions use SCROLL before most PRINT statements to prevent the screen from halting on a full display.

QUAD — Quadratic Solver

Solves Ax²+Bx+C=0. At line 60, the discriminant is computed as (ABS B)**2-4*A*C — the ABS wrapper around B is redundant since squaring always yields a positive result, but causes no error. When D<0, the program prints the complex root in the form F +/- G J using engineering notation.

SIM — Simpson’s Rule Integrator

Implements Simpson’s composite rule. The user specifies the number of divisions N, which is immediately doubled at line 95 (LET N=N*2) to give the actual number of sub-intervals. The three sums — endpoint sum Y, odd-index sum Y1 (weight 4), and even-index sum Y2 (weight 2) — are accumulated in separate loops before being combined at line 205 and divided by 3*N.

NM — Newton-Raphson Zero Finder

Accepts both the function and its derivative as separate string inputs, then iterates I = X - F/F' using VAL F$ and VAL G$. Convergence is tested at line 100 with an absolute tolerance of 10E-9 (i.e., 1×10⁻⁸). The iteration count is tracked in C and reported alongside the result. The program runs in FAST mode during iteration.

Plot — Function Plotter with Machine Code Compilation

This is the most technically sophisticated program in the collection. On first run it compiles a 386-byte machine code routine into RAM starting at address 16514. The compilation loop (lines 130–150) uses POKE N+SGN PI, I and POKE N+VAL "2", VAL "43-(H-VAL A$)/(H-L)*43" to write both opcode bytes and computed plot-position values directly into memory. The data for the machine code is encoded in the block-graphic characters of the line 0 REM statement, which the loop reads via CODE "RND" and CODE "Z" as loop bounds.

Line 0’s REM holds the machine code byte stream encoded as character pairs.
Line 40 computes DX=(A-X)/VAL "63" — 63 steps to fill the 64-column display.
Lines 50–110 perform a first pass to find the function’s min (L) and max (H) for auto-scaling.
After plotting, RAND USR 16514 re-executes the compiled routine at full machine-code speed without recompilation.
The variable T is set to PI+PI (≈2π) so the user can type T as a limit shorthand.
Line 500 uses UNPLOT NOT USR VAL "16514", RND as an indirect call idiom.
Lines 9900–9930 provide a self-listing/printing routine, and line 9999 holds a lengthy REM with usage instructions.

PFD — Prime Factor Finder

Factors integers up to 10⁹ into a pre-allocated array B(50). Trial division starts with 2, then proceeds through odd candidates generated by C=1+2*D. The loop exits when C>SQR A, at which point any remaining A>1 is itself prime and stored directly. Results accumulate across runs without reinitializing the factor array — lines 25–27 reset K and D to zero before each new number.

BSCV — General Base Conversion

Converts integers between arbitrary bases. The subroutine at line 480 computes a digit-position multiplier V using INT(10**(1+INT(LN(U-1)/LN 10))+.5), which finds the next power of ten above the base. The conversion from a non-decimal source first converts to decimal (subroutine at line 390), then from decimal to the target base. When both source and target are non-decimal, an intermediate decimal value is also printed (line 360).

HEXD — Hex/Decimal Converter

Uses GOTO 200*B (line 80) to branch to either the hex-input section at line 200 or the decimal-input section at line 400, a compact dispatch idiom. Hex digits are mapped to/from their character codes via offset 28 (CODE A$(L-I)-28), which maps the ZX character set positions of digits and letters onto the values 0–15. Invalid hex input triggers RUN to restart. The output array B$(10) stores hex digit characters in reverse order, then prints them in reverse for correct significance ordering.

PL — Function Table Printer

A straightforward tabulator: accepts a function string, lower/upper limits, and a step increment, then prints X and VAL A$ in two columns inside a FAST/SLOW bracket. After printing, the user presses 1 to re-enter limits or 2 to stop, using a polling loop at lines 190–200 rather than INPUT.

Notable Techniques and Anomalies

VAL F$ used as a runtime expression evaluator appears in BIS, NM, SIM, PL, and Plot — a standard technique for user-defined functions in the absence of DEF FN with string arguments.
FAST/SLOW bracketing is used consistently around computation loops to suppress display overhead.
In LIN, M is reused as both a mode selector and a column-count variable, which would cause IF M=N+1 THEN PRINT... at line 210 to behave incorrectly if N+1 happened to equal the original mode value of 1 or 2. In practice this only arises for trivial 0×0 or 1×1 systems.
The PRIME program (a simple sieve listing odd primes to 999) appears to be a standalone bonus, with no REM name header beyond its FOR loop.
The CPO program (specific heat of nitrogen gas) is a single-purpose formula evaluator with no user input, computing Cp° across 300–3500 K using a polynomial fit.
INTP is a minimal linear interpolation utility, accepting five values and computing the interpolated result with no labels or prompts.

Content

Appears On

Image Gallery

Source Code
REM "BIS"
PRINT "ENTER FUNCTION IN TERMS OF X"
INPUT F$
PRINT "ENTER LIMITS"
INPUT A 
LET MID1=A
INPUT B
FAST 
LET X=A
LET M=VAL F$
LET X=B
LET N=VAL F$
IF M*N>0 THEN GOTO 260
IF N>0 THEN GOTO 190
LET C=A
LET A=B
LET B=C
LET MID=(B+A)/2
IF MID1=MID THEN GOTO 280
LET MID1=MID
LET X=MID
IF VAL F$>0 THEN GOTO 240
LET A=MID
GOTO 190
LET B=MID
GOTO 190
PRINT "LIMITS DO NOT STRATTLE A ZERO"
GOTO 120
CLS 
PRINT "ZERO AT X= ";MID
SLOW 
 
REM "BSCV"
CLS 
PRINT "GENERAL BASE CONVERSION"
PRINT "ENTER ARGUMENT";
INPUT C
PRINT C
IF C<>INT (ABS C) THEN GOTO 40
PRINT "ENTER OLD BASE?";
INPUT D
PRINT D
IF D<>(ABS D) THEN GOTO 80
PRINT "ENTER NEW BASE?";
INPUT E
PRINT E
IF E<>(ABS E) THEN GOTO 120
IF D<>10 THEN GOTO 190
LET N=C
GOTO 250
LET U=D
GOSUB 480
LET S=C
LET Q=D
LET R=V
GOSUB 390
IF E<>10 THEN GOTO 280
LET S=N
GOTO 340
LET U=E
GOSUB 480
LET S=N
LET Q=V
LET R=E
GOSUB 390
PRINT C;" TO BASE ";D
PRINT "=";N;" TO BASE ";E
IF D<>10 AND E<>10 THEN PRINT "=";S;" TO BASE 10"
PRINT " "
GOTO 40
LET M=0
LET N=0
LET P=S
LET T=P
LET P=INT (P/R)
LET N=N+INT ((T-P*R)*Q**M+.5)
IF P=0 THEN RETURN 
LET M=M+1
GOTO 420
LET V=INT (10**(1+INT (LN (U-1)/LN 10))+.5)
RETURN 
 
REM "CPO"
REM CPO SPECIFIC HEAT
REM FOR NITROGEN GAS
FOR T=300 TO 3500 STEP 100
LET S=T/100
LET C=39.06-512.79*S**-1.5+1072.7*S**-2-820.4*S**-3
LET C=C/28.013
PRINT T;" K ";"CPO= ";C;" KJ/KMOL K"
NEXT T
DIM B$(10)
CLS 
PRINT 
PRINT "HEX-TO-DECIMAL, ENTER 1"
PRINT "DECIMAL-TO-HEX, ENTER 2?";
INPUT B
PRINT B
IF B<>1 AND B<>2 THEN GOTO 30
GOTO 200*B
PRINT "ENTER ARGUMENT IN HEX?";
INPUT A$
PRINT A$
LET L=LEN A$
LET N=0
FOR I=0 TO L-1
LET C=CODE A$(L-I)-28
IF C>=0 AND C<=16 THEN GOTO 310
PRINT "BAD ENTRY"
PAUSE 200
RUN 
LET N=N+C*16**I
NEXT I
PRINT "=";N;" IN BASE 10"
GOTO 640
PRINT "ENTER ARGUMENT IN BASE 10?";
INPUT D
PRINT D
IF D=INT (ABS D) THEN GOTO 470
PRINT "BAD ENTRY"
PAUSE 200
RUN 
LET K=0
LET K=K+1
LET F=D
LET D=INT (D/16)
LET E=F-16*D
LET B$(K)=CHR$ (E+28)
IF F>0 THEN GOTO 480
PRINT "=";
FOR I=1 TO K-1
PRINT B$(K-I);
NEXT I
PRINT " IN BASE 16"
PRINT " "
GOTO 30
 
REM "INTP"
INPUT A
INPUT B
INPUT C
INPUT D
INPUT E
LET F=(B-A)*(E-D)/(C-A)+D
PRINT F
GOTO 70
 
REM "LIN"
PRINT "THIS PROGRAM SOLVES"
PRINT "SIMULTANEOUS LINEAR"
PRINT "EQUATIONS (E) OR"
PRINT "INVERTS AN N*N MATRIX (I)"
PRINT 
PRINT "WHICH ONE,(E) OR (I)? ";
INPUT Q$
PRINT Q$
IF Q$="E" THEN LET M=1
IF Q$="I" THEN LET M=2
IF M<>1 AND M<>2 THEN GOTO 60
PRINT 
PRINT "GIVE SIZE? ";
INPUT N
PRINT N
IF M=1 THEN LET M=N+1
IF M=2 THEN LET M=2*N
DIM X(N,M)
SCROLL 
PRINT "ENTER COEFFICIENTS"
SCROLL 
IF M=N+1 THEN PRINT "AND OUTPUT ARRAY"
SCROLL 
PRINT "ROW COLUMN"
SCROLL 
FOR R=1 TO N
FOR C=1 TO N
PRINT " ";R;TAB 6;C,
INPUT X(R,C)
PRINT X(R,C)
SCROLL 
NEXT C
IF M<>N+1 THEN GOTO 380
PRINT " ";R;"    OUT",
INPUT X(R,M)
PRINT X(R,M)
GOTO 390
LET X(R,N+R)=1
SCROLL 
NEXT R
SCROLL 
PRINT "ANY CORRECTIONS (Y)?"
INPUT Q$
IF Q$<>"Y" THEN GOTO 590
SCROLL 
PRINT "WHICH ROW?";
INPUT R
PRINT R
SCROLL 
PRINT "WHICH COLUMN (OUT IS N+1)?";
INPUT C
PRINT C
SCROLL 
PRINT "ENTER VALUE ";
INPUT X(R,C)
PRINT X(R,C)
GOTO 410
CLS 
REM FOWARD ELIMINATION
FOR C=1 TO N-1
LET A=0
IF X(C,C)<>0 THEN GOTO 730
FOR R=C+1 TO N
IF X(R,C)=0 THEN GOTO 720
FOR I=1 TO M
LET T=-X(R,I)
LET X(R,I)=X(C,I)
LET X(C,I)=T
NEXT I
GOTO 730
NEXT R
LET A=X(C,C)
IF A=0 THEN GOTO 1240
FOR R=C+1 TO N
LET B=X(R,C)/A
IF B=0 THEN GOTO 810
FOR I=C TO M
LET X(R,I)=X(R,I)-B*X(C,I)
NEXT I
NEXT R
NEXT C
REM CHECK DETERMINATE
LET D=1
FOR I=1 TO N
LET D=D*X(I,I)
NEXT I
IF D=0 THEN GOTO 1240
REM BACKWARD ELIMINATION
FOR C=N TO 2 STEP -1
LET A=X(C,C)
FOR R=C-1 TO 1 STEP -1
LET B=X(R,C)/A
FOR I=C TO M
LET X(R,I)=X(R,I)-B*X(C,I)
NEXT I
NEXT R
NEXT C
REM PRINT RESULTS
IF M=2*N THEN GOTO 1100
PRINT "THE INPUT ARRAY IS:"
PRINT 
FOR I=1 TO N
PRINT "X-";I;" = ";X(I,M)/X(I,I)
NEXT I
GOTO 1180
PRINT "THE INVERTED MATRIX IS:"
PRINT 
PRINT "ROW COLUMN"
FOR R=1 TO N
PRINT 
FOR C=1 TO N
PRINT " ";R;TAB 7;C,X(R,N+C)/X(R,R)
NEXT C
NEXT R
PRINT 
PRINT "DETERMINATE IS:",D
PRINT 
PRINT "RUN AGAIN (Y)?"
INPUT Q$
CLS 
IF Q$="Y" THEN RUN 
STOP 
PRINT "SINGULAR COEFFICIENT MATRIX"
PRINT "NO UNIQUE SOLUTION"
GOTO 1200
 
REM "LIN"
PRINT "THIS PROGRAM SOLVES"
PRINT "SIMULTANEOUS LINEAR"
PRINT "EQUATIONS (E) OR"
PRINT "INVERTS AN N*N MATRIX (I)"
PRINT 
PRINT "WHICH ONE, (E) OR (I)?";
INPUT Q$
PRINT Q$
IF Q$="E" THEN LET M=1
IF Q$="I" THEN LET M=2
IF M<>1 AND M<>2 THEN GOTO 60
PRINT 
PRINT "GIVE SIZE? ";
INPUT N
PRINT N
IF M=1 THEN LET M=N+1
IF M=2 THEN LET M=2*N
DIM X(N,M)
SCROLL 
PRINT "ENTER COEFFICIENTS"
SCROLL 
IF M=N+1 THEN PRINT "AND OUTPUT ARRAY"
SCROLL 
PRINT "ROW COLUMN"
SCROLL 
FOR R=1 TO N
FOR C=1 TO N
PRINT " ";R;TAB 6;C,
INPUT X(R,C)
PRINT X(R,C)
SCROLL 
NEXT C
IF M<>N+1 THEN GOTO 380
PRINT " ";R;"    OUT",
INPUT X(R,M)
PRINT X(R,M)
GOTO 390
LET X(R,N+R)=1
SCROLL 
NEXT R
SCROLL 
PRINT "ANY CORRECTIONS (Y)?"
INPUT Q$
IF Q$<>"Y" THEN GOTO 580
SCROLL 
PRINT "WHICH ROW? ";
INPUT R
PRINT R
SCROLL 
 
REM "NM"
PRINT "ENTER FUNCTION IN TERMS OF X"
INPUT F$
PRINT "ENTER DERIVITIVE IN TERMS OF X"
INPUT G$
PRINT "ENTER GUESS"
INPUT X
FAST 
LET C=0
LET I=X-VAL F$/VAL G$
LET C=C+1
IF ABS (I-X)<10E-9 THEN GOTO 130
LET X=I
GOTO 90
SLOW 
PRINT "ZERO AT X=";X
PRINT "AFTER ";C;" INTERATIONS"
 
REM "PFD"
CLS 
LET K=0
LET D=0
DIM B(50)
PRINT "PRIME FACTOR FINDER"
PRINT "ENTER NUMBER?";
INPUT A
PRINT A
LET F=A
IF A=INT A AND A>1 AND A<1E9 THEN GOTO 120
PRINT "ERROR, REENTER"
GOTO 50
LET E=A/2
LET C=2
IF E<>INT E OR 2*E<A THEN GOTO 170
GOSUB 320
GOTO 120
LET D=D+1
LET C=1+2*D
IF C>SQR A THEN GOTO 250
LET E=A/C
IF E<>INT E OR E*C<>A THEN GOTO 170
LET D=D-1
GOSUB 320
GOTO 170
IF A<=1 THEN GOTO 280
LET K=K+1
LET B(K)=A
PRINT "NO. OF FACTORS=";K
FOR I=1 TO K
PRINT "FACTOR NO. ";I;"=";B(I)
NEXT I
PRINT " "
GOTO 25
IF K>=50 THEN RETURN 
LET K=K+1
LET B(K)=C
LET A=E
RETURN 
 
REM "PL"
PRINT "ENTER FUNCTION IN TERMS OF X"
INPUT A$
PRINT "ENTER LOWER LIMIT"
INPUT B
PRINT "ENTER UPPER LIMIT"
INPUT C
PRINT "ENTER INCREMENT"
INPUT D
FAST 
CLS 
PRINT "X","F(X)"
PRINT "------------------------------"
FOR X=B TO C STEP D
PRINT X,VAL A$
NEXT X
SLOW 
PRINT "ENTER 1 TO CONTINUE, 2 TO STOP "
IF INKEY$="1" THEN GOTO 210
IF INKEY$="2" THEN STOP 
GOTO 190
CLS 
SLOW 
GOTO 40
 
REM '  .LN %M"' ' .LN %M"'  ',LN %M"' ''0LN %M"' . 1LN %M"' : /LN %M"' .',LN %M"' :'*LN %M"' ##3LN %M"' ,,-LN %M"' ~~4LN %M"' "1LN %M"' £=LN %M"' $/LN %M"' :4LN %M"' ?8LN %M"' (4LN %M"' );LN %M"' ><LN %M"' <(LN %M"' =)LN %M"' +=LN %M"' -;LN %M"' *3LN %M"' /8LN %M"' ;CLN %M"' ,ELN %M"' .FLN %M"' 0FLN %M"' 1DLN %M"' 2BLN %M"' 38LN %M"' 44LN %M"' 51LN %M"' 6;LN %M"' 7+LN %M"' 8>LN %M"' 9?LN %M"' A£LN %M"' B,,LN %M"' C:'LN %M"' D: LN %M"' E''LN %M"' F 'LN %M"' G' LN %M"' H LN %M"' I LN %M"' J LN %M"' K LN %M"' L' LN %M"' M' LN %M"' N 'LN %M"' O''LN %M"' P. LN %M"' Q: LN %M"' R:'LN %M"' S##LN %M"' T~~LN %M"' U"LN %M"' V$LN %M"' W?LN %M"' X(LN %M"' Y>LN %M"' Z=LN %M"TAN AA
FAST 
FOR L=SGN PI TO 44
PRINT "% % % % % % % % % % % % % % % % ";
NEXT L
SLOW 
INPUT A$
LET N=VAL "16514"
LET T=PI+PI
INPUT X
LET X1=X
INPUT A
FAST 
LET DX=(A-X)/VAL "63"
LET H=VAL A$
LET L=H
FOR I=SGN PI TO CODE "RND"
LET Z=VAL A$
IF H<Z THEN LET H=Z
IF L>Z THEN LET L=Z
LET X=X+DX
NEXT I
LET X=X1
FOR I=NOT PI TO CODE "Z"
POKE N+SGN PI,I
POKE N+VAL "2",VAL "43-(H-VAL A$)/(H-L)*43"
LET X=X+DX
LET N=N+VAL "6"
NEXT I
SLOW 
UNPLOT NOT USR VAL "16514",RND
GOTO PI*PI
FOR L=1 TO 20
LPRINT "      *** SUPER FN PLOT ***",,,
LLIST 
LPRINT ,,,,,,,,
NEXT L
REM  WELCOME  TO  SUPER  FNPLOT.  WHEN YOU RUN THE PROGRAM,THE COMPUTER WILL REQUEST  THREEINPUTS.  ANSWER THE FIRST WITH AFUNCTION, SUCH AS "SIN X" OR "X*X+5*X-3".  THE NEXT  TWO  INPUTSARE THE LOWER AND  UPPER LIMITS,RESPECTIVELY,  ON  "X"  IN   THEFUNCTION.   IF  YOU  WERE  USING"SIN X", THEN YOU MIGHT WANT  TOUSE THE LIMITS OF 0 AND 2*PI. ASAN ADDED CONVEINANCE, THE LETTER"T" CAN BE SUBSTITUTED FOR 2*PI.AFTER PLOTTING THE FIRST FN, TRYTHIS:  STOP THE PROGRAM AND TYPE"RAND USR 16514" AND THE SAME FNWILL BE RAPIDLY PLOTTED. THIS ISBECAUSE THE PROGRAM  COMPILES  AMACHINE CODE  ROUTINE  AT  16514THAT IS 386 BYTES LONG.    THOSEOF YOU WHO  HAVE  EPROM/CMOS/64KMEMORIES MAY  WANT  TO  RELOCATETHE MC TO WHERE IT CAN BE CALLED LATER.
 
REM "PRIME"
FOR A=3 TO 999 STEP 2
FOR B=3 TO A/2 STEP 2
IF A/B=INT (A/B) THEN GOTO 60
NEXT B
PRINT A;" ";
NEXT A
REM "QUAD"
PRINT "INPUT COEFFICIENTS"
INPUT A
INPUT B
INPUT C
LET D=(ABS B)**2-4*A*C
IF D<0 THEN GOTO 120
LET R1=(-B+SQR D)/(2*A)
LET R2=(-B-SQR D)/(2*A)
PRINT "ROOTS ARE ";R1;TAB 10;R2
STOP 
PRINT "ROOTS COMPLEX"
LET D=ABS D
LET E=2*A
LET F=-B/E
LET G=SQR D/E
PRINT F;" +/- ";G;" J"
 
REM "SIM"
PRINT "ENTER FUNCTION"
INPUT F$
PRINT "ENTER LOWER LIMIT"
INPUT A
PRINT "ENTER UPPER LIMIT"
INPUT B
PRINT "ENTER NUMBER OF DIVISIONS"
INPUT N
LET N=N*2
LET X=A
LET Y=VAL F$
LET X=B
LET Y=VAL F$+Y
LET C=2*(B-A)/N
LET Y1=0
FOR X=A+C/2 TO B STEP C
LET Y1=VAL F$+Y1
NEXT X
LET Y2=0
FOR X=A+C TO B-C/2 STEP C
LET Y2=VAL F$+Y2
NEXT X
LET Y=Y+4*Y1+2*Y2
LET IN=Y*(B-A)/(3*N)
PRINT "INTEGRAL= ";IN

Note: Type-in program listings on this website use ZMAKEBAS notation for graphics characters.